From fff080d8b40a8e69caaccaec20141ed941a3495a Mon Sep 17 00:00:00 2001
From: DragonAura <dragonaurapvp@gmail.com>
Date: Sat, 15 Apr 2023 23:00:08 +0800
Subject: [PATCH 01/10] fix(CAPI): :pencil2: fix some missing headers

---
 CAPI/cpp/API/include/state.h      | 1 +
 CAPI/cpp/API/include/structures.h | 2 ++
 CAPI/cpp/API/include/utils.hpp    | 2 ++
 3 files changed, 5 insertions(+)

diff --git a/CAPI/cpp/API/include/state.h b/CAPI/cpp/API/include/state.h
index 1440a2d..02f5543 100644
--- a/CAPI/cpp/API/include/state.h
+++ b/CAPI/cpp/API/include/state.h
@@ -5,6 +5,7 @@
 #include <vector>
 #include <array>
 #include <map>
+#include <memory>
 
 #include "structures.h"
 
diff --git a/CAPI/cpp/API/include/structures.h b/CAPI/cpp/API/include/structures.h
index 613e04e..1b10d20 100644
--- a/CAPI/cpp/API/include/structures.h
+++ b/CAPI/cpp/API/include/structures.h
@@ -5,6 +5,8 @@
 #include <cstdint>
 #include <array>
 #include <map>
+#include <vector>
+#include <string>
 
 namespace THUAI6
 {
diff --git a/CAPI/cpp/API/include/utils.hpp b/CAPI/cpp/API/include/utils.hpp
index 3472cf6..3c61f8a 100644
--- a/CAPI/cpp/API/include/utils.hpp
+++ b/CAPI/cpp/API/include/utils.hpp
@@ -5,6 +5,8 @@
 
 #include <cstdint>
 #include <cmath>
+#include <map>
+#include <vector>
 #include "Message2Clients.pb.h"
 #include "Message2Server.pb.h"
 #include "MessageType.pb.h"

From c430cc60aae9102062a5e16d99c55b411a69af9a Mon Sep 17 00:00:00 2001
From: DragonAura <dragonaurapvp@gmail.com>
Date: Sat, 15 Apr 2023 23:33:24 +0800
Subject: [PATCH 02/10] style(CAPI): :bug: fix some warnings

---
 CAPI/cpp/API/include/logic.h      | 4 ++--
 CAPI/cpp/API/include/structures.h | 2 +-
 CAPI/cpp/API/include/utils.hpp    | 7 ++++++-
 CAPI/cpp/API/src/logic.cpp        | 2 +-
 4 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/CAPI/cpp/API/include/logic.h b/CAPI/cpp/API/include/logic.h
index 3e33682..a496a2d 100644
--- a/CAPI/cpp/API/include/logic.h
+++ b/CAPI/cpp/API/include/logic.h
@@ -42,12 +42,12 @@ private:
     std::unique_ptr<Communication> pComm;
 
     // ID、阵营记录
-    int64_t playerID;
     THUAI6::PlayerType playerType;
+    int64_t playerID;
 
     // 类型记录
-    THUAI6::StudentType studentType;
     THUAI6::TrickerType trickerType;
+    THUAI6::StudentType studentType;
 
     // GUID信息
     std::vector<int64_t> playerGUIDs;
diff --git a/CAPI/cpp/API/include/structures.h b/CAPI/cpp/API/include/structures.h
index 1b10d20..d92a5d2 100644
--- a/CAPI/cpp/API/include/structures.h
+++ b/CAPI/cpp/API/include/structures.h
@@ -177,7 +177,7 @@ namespace THUAI6
         int32_t viewRange;  // 视野范围
         int64_t playerID;   // 玩家ID
         int64_t guid;       // 全局唯一ID
-        int16_t radius;     // 圆形物体的半径或正方形物体的内切圆半径
+        int32_t radius;     // 圆形物体的半径或正方形物体的内切圆半径
         int32_t score;      // 分数
 
         double facingDirection;  // 朝向
diff --git a/CAPI/cpp/API/include/utils.hpp b/CAPI/cpp/API/include/utils.hpp
index 3c61f8a..e4f9260 100644
--- a/CAPI/cpp/API/include/utils.hpp
+++ b/CAPI/cpp/API/include/utils.hpp
@@ -23,6 +23,11 @@ namespace AssistFunction
         return grid / numOfGridPerCell;
     }
 
+    [[nodiscard]] constexpr inline int GridToCell(double grid) noexcept
+    {
+        return int(grid) / numOfGridPerCell;
+    }
+
     inline bool HaveView(int viewRange, int x, int y, int newX, int newY, std::vector<std::vector<THUAI6::PlaceType>>& map)
     {
         int deltaX = newX - x;
@@ -419,7 +424,7 @@ namespace THUAI62Proto
         return playerMsg;
     }
 
-    inline protobuf::IDMsg THUAI62ProtobufID(int playerID)
+    inline protobuf::IDMsg THUAI62ProtobufID(int64_t playerID)
     {
         protobuf::IDMsg idMsg;
         idMsg.set_player_id(playerID);
diff --git a/CAPI/cpp/API/src/logic.cpp b/CAPI/cpp/API/src/logic.cpp
index 799b281..abb4440 100644
--- a/CAPI/cpp/API/src/logic.cpp
+++ b/CAPI/cpp/API/src/logic.cpp
@@ -84,7 +84,7 @@ std::vector<std::vector<THUAI6::PlaceType>> Logic::GetFullMap() const
 THUAI6::PlaceType Logic::GetPlaceType(int32_t cellX, int32_t cellY) const
 {
     std::unique_lock<std::mutex> lock(mtxState);
-    if (cellX < 0 || cellX >= currentState->gameMap.size() || cellY < 0 || cellY >= currentState->gameMap[0].size())
+    if (cellX < 0 || uint64_t(cellX) >= currentState->gameMap.size() || cellY < 0 || uint64_t(cellY) >= currentState->gameMap[0].size())
     {
         logger->warn("Invalid position!");
         return THUAI6::PlaceType::NullPlaceType;

From 1ebf0709b2b5a0a6f921d17873edd39fb99559b3 Mon Sep 17 00:00:00 2001
From: Shawqeem <1004837646@qq.com>
Date: Sat, 15 Apr 2023 23:33:25 +0800
Subject: [PATCH 03/10] feat: :sparkles: add Sunshine and make everything
 visible when running playback mode

add Sunshine and make everything visible when running playback mode
---
 logic/Client/MainWindow.xaml.cs             |  13 ++--
 logic/Client/PlaybackClient.cs              |   3 -
 logic/Client/Properties/launchSettings.json |   2 +-
 logic/Client/StatusBarOfSurvivor.xaml.cs    |   3 +
 logic/Preparation/Utility/Transformation.cs |   4 ++
 logic/cmd/gameServer.cmd                    |   6 +-
 logic/cmd/playback.cmd                      |   2 +-
 resource/client.png                         | Bin 0 -> 135159 bytes
 使用文档.md                             |  63 ++++++++++++++------
 9 files changed, 65 insertions(+), 31 deletions(-)
 create mode 100644 resource/client.png

diff --git a/logic/Client/MainWindow.xaml.cs b/logic/Client/MainWindow.xaml.cs
index 714fea1..7999ed6 100644
--- a/logic/Client/MainWindow.xaml.cs
+++ b/logic/Client/MainWindow.xaml.cs
@@ -221,6 +221,9 @@ namespace Client
                             case 5:
                                 playerMsg.StudentType = StudentType.TechOtaku;
                                 break;
+                            case 6:
+                                playerMsg.StudentType = StudentType.Sunshine;
+                                break;
                             case 0:
                             default:
                                 playerMsg.StudentType = StudentType.NullStudentType;
@@ -560,7 +563,7 @@ namespace Client
         {
             if (msg.PlayerState == PlayerState.Quit || msg.PlayerState == PlayerState.Graduated)
                 return false;
-            if (isSpectatorMode)
+            if (isSpectatorMode || isPlaybackMode)
                 return true;
             if (humanOrButcher && human != null)
             {
@@ -579,7 +582,7 @@ namespace Client
 
         private bool CanSee(MessageOfTricker msg)
         {
-            if (isSpectatorMode)
+            if (isSpectatorMode || isPlaybackMode)
                 return true;
             if (!humanOrButcher && butcher != null)
             {
@@ -606,7 +609,7 @@ namespace Client
 
         private bool CanSee(MessageOfProp msg)
         {
-            if (isSpectatorMode)
+            if (isSpectatorMode || isPlaybackMode)
                 return true;
             if (humanOrButcher && human != null)
             {
@@ -625,7 +628,7 @@ namespace Client
 
         private bool CanSee(MessageOfBullet msg)
         {
-            if (isSpectatorMode)
+            if (isSpectatorMode || isPlaybackMode)
                 return true;
             if (humanOrButcher && human != null)
             {
@@ -644,7 +647,7 @@ namespace Client
 
         private bool CanSee(MessageOfBombedBullet msg)
         {
-            if (isSpectatorMode)
+            if (isSpectatorMode || isPlaybackMode)
                 return true;
             //if (humanOrButcher && human != null)
             //{
diff --git a/logic/Client/PlaybackClient.cs b/logic/Client/PlaybackClient.cs
index 5290b37..11acdc5 100644
--- a/logic/Client/PlaybackClient.cs
+++ b/logic/Client/PlaybackClient.cs
@@ -82,7 +82,6 @@ namespace Client
             };
             new Thread(() =>
             {
-                int i = 0;
                 try
                 {
                     new FrameRateTaskExecutor<int>
@@ -91,10 +90,8 @@ namespace Client
                         () =>
                         {
                             var content = Reader.ReadOne();
-                            i++;
                             if (content == null)
                             {
-                                MessageBox.Show($"End! {i}");
                                 endFile = true;
                             }
                             else
diff --git a/logic/Client/Properties/launchSettings.json b/logic/Client/Properties/launchSettings.json
index a671030..a747e32 100644
--- a/logic/Client/Properties/launchSettings.json
+++ b/logic/Client/Properties/launchSettings.json
@@ -2,7 +2,7 @@
   "profiles": {
     "Client": {
       "commandName": "Project",
-      "commandLineArgs": "--cl --port 8888 --characterID 2031"
+      "commandLineArgs": "--cl --playbackFile .\\video.thuaipb"
     }
   }
 }
\ No newline at end of file
diff --git a/logic/Client/StatusBarOfSurvivor.xaml.cs b/logic/Client/StatusBarOfSurvivor.xaml.cs
index fa7ca3e..75011d8 100644
--- a/logic/Client/StatusBarOfSurvivor.xaml.cs
+++ b/logic/Client/StatusBarOfSurvivor.xaml.cs
@@ -53,6 +53,9 @@ namespace Client
                 case StudentType.TechOtaku:
                     serial.Text = "👥" + Convert.ToString(2) + "🧓" + Convert.ToString(obj.PlayerId) + "\nTechOtaku";
                     break;
+                case StudentType.Sunshine:
+                    serial.Text = "👥" + Convert.ToString(2) + "🧓" + Convert.ToString(obj.PlayerId) + "\nSunshine";
+                    break;
                 case StudentType.NullStudentType:
                     serial.Text = "👥" + Convert.ToString(2) + "🧓" + Convert.ToString(obj.PlayerId) + "\nNullStudentType";
                     break;
diff --git a/logic/Preparation/Utility/Transformation.cs b/logic/Preparation/Utility/Transformation.cs
index 62fb05d..22b3464 100644
--- a/logic/Preparation/Utility/Transformation.cs
+++ b/logic/Preparation/Utility/Transformation.cs
@@ -200,6 +200,8 @@ namespace Preparation.Utility
                     return Protobuf.StudentType.Robot;
                 case Preparation.Utility.CharacterType.TechOtaku:
                     return Protobuf.StudentType.TechOtaku;
+                case Preparation.Utility.CharacterType.Sunshine:
+                    return Protobuf.StudentType.Sunshine;
                 default:
                     return Protobuf.StudentType.NullStudentType;
             }
@@ -218,6 +220,8 @@ namespace Preparation.Utility
                     return Preparation.Utility.CharacterType.Robot;
                 case Protobuf.StudentType.TechOtaku:
                     return Preparation.Utility.CharacterType.TechOtaku;
+                case Protobuf.StudentType.Sunshine:
+                    return Preparation.Utility.CharacterType.Sunshine;
                 default:
                     return Preparation.Utility.CharacterType.Null;
             }
diff --git a/logic/cmd/gameServer.cmd b/logic/cmd/gameServer.cmd
index 3d9e370..22cac6c 100644
--- a/logic/cmd/gameServer.cmd
+++ b/logic/cmd/gameServer.cmd
@@ -1,12 +1,12 @@
 @echo off
 
-start cmd /k ..\Server\bin\Debug\net6.0\Server.exe --ip  0.0.0.0  --port 8888 --studentCount 4 --trickerCount 1 --gameTimeInSecond 600 --fileName test 
+start cmd /k ..\Server\bin\Debug\net6.0\Server.exe --ip  0.0.0.0  --port 8888 --studentCount 4 --trickerCount 1 --gameTimeInSecond 600 --fileName video
 
 ping -n 2 127.0.0.1 > NUL
 
-start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 4 --type 2 --occupation 1
+start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 4 --type 2 --occupation 4
 
-start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 0 --type 1 --occupation 1
+start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 0 --type 1 --occupation 6
 
 start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 1 --type 1 --occupation 2
 
diff --git a/logic/cmd/playback.cmd b/logic/cmd/playback.cmd
index 32156c7..8e413d5 100644
--- a/logic/cmd/playback.cmd
+++ b/logic/cmd/playback.cmd
@@ -1,5 +1,5 @@
 @echo off
 
-start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --playbackFile .\test.thuaipb --playbackSpeed 1
+start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --playbackFile .\video.thuaipb --playbackSpeed 1
 
 ping -n 2 127.0.0.1 > NUL
\ No newline at end of file
diff --git a/resource/client.png b/resource/client.png
new file mode 100644
index 0000000000000000000000000000000000000000..f63b2840224f45736d844e8994444b9df99a6df1
GIT binary patch
literal 135159
zcmce-byr*Mw>4b7fkJUBT7tW~6?b<{3EJZBP>Mr=LJ2O#3X~whJuMJi3KWN+!QBD`
zdHCJu9q)6_`2f!!N%qdz*BE=rT>DyU&K;|*sr334#j7Vzp1f93me+mq<R8N)PhQAl
z{`2?`MlFZ%<Ihu1T_xEkRijipk0&qeWi(`-Jb@-*-&(zVJjZfVHt~G&gp~0=pQkFi
z498ENJd~)&%jo-A?&o6o5l=mf6vo1ukZHyIOpFaE6Oj4fqurAj_o`6f_h%`EIF`6V
zOqS08Knx~}axzy0paZ2Ti>HD~mk{yQ2Qhp&Jl*DO_pEK;dfB&=+1KuHbXe2J?g)mm
z)N|@(%xUuwefRA*&-K@HS;BE>V0;-()Oeb4b&Hn)5wq$K_gG<`ttoRKBG;i{<<DU)
zE4&|?zgjsFR)e^1vb>g4yujab@_zE3Hs%3lH&Yl{Wm5h+g6oN^Rrr|=@Vzrjy`OO+
zE~h3>X1OQR)TWDDV_|y>eIda*@(X1ImE218Rnf(&3;hJsjB(iqx%7+EDPBN8nI0EW
z)gI?=qp7u5@O7HLG+^G6c)Ss(o2Qpa4qt0X{>1n0lbUKAW1+3bU!<5v3qJE?&W2+S
z!%|BZaf}UvMNgFX-k(w}*Nh%ndVIjgb6awHdKVln5d!ME(wN=%<Oc*p#ORop${~!>
zC2>^AZ^sGgi(|P7um~#&ut`KeBo6Q}0iLGN61*bzRYB1tU-geQlf0FJTNchDQ|gDM
zc5en@3eVO}l}IQK2de`ndida?RVgwI6!Lp7Oxq7C?oP<bjObPvh#@Dw!RVOAx+Dim
z!NLn<%=E=q{STC)U9Ix&bse4&3#MxTwnccAlqWsRff`uoQZ1-BlkN%?<OoP|2z+!A
zA5OPl659*;p`7)%_^E!TOmVP140B!LrvOtXC5tM0z^e9Fzz~s63soEm6aF_hE+%bw
zT-kWK)tAI(-sbo6UhN3L&uFW91rFUDdeXPo;9EkrkMb!!%a|o`!7XQe)Q=`}{%i7@
z&32OVXYw}%A}48HC<2wF+eD41*#SHl2pFBBrrVM(G8FGfZC}3nVa`A;%eYviPx$F-
zyXM>8h0b}}BzJd`XPUCVDMDwOk{rYzE!Lqo1tvOJ;HiKclj$L9#KH^WO3jswT!meF
z#jV2xoM(a`ss9Zwsaba+DyET4p`Npw=gXFe+S75dOLxoV5Xx~rom&g(m6SqE{Bb_f
zU603mjs8sR3xWd-SPV0Mseg(k(Xr<4-mvdU=n8u?eosj-?#TP)GKMjZ1@trph~))c
zGt8OgCgMc#0$2-~L79aNa>;K2P{5<(cmZ!f`VkX7GsSI+43ekfiLwj^);W909x7}o
z{J;+cm;|b?SrKVlffGFdxJ6E6n6-Q%0JeVQ7-$Bxa50zX`$foH{yxz`@-eCh^z*$^
zh0cFtrqk(7XXJECoHsD{2;n1_qXaIFvGHa7N6P3TcEy=3-jD0w9Wt9{DM&k%>N{8p
zo$q3GE_iT=)ZNpb6?*Tlw|CwN71|bFwT1j*R3Lc!U%3rP!F|ap6t>0%m~$7TPh-57
z|I0J>!k5L6yq9h*YR!>$yp!Tz!#n@WaF7>7RzdTJJHY^fq&vIjetK*g8b6tQoTxyZ
zmw6-whw+jRF172CK!8P11R!SWWLgpgoFp&169dZs>1oqXw&oUmMkiZN2cP7VOZlNp
z@UQEo0Vx=1G4cu_eakbKjh(HF%`rBg7&Uc&Q;i3Fl;2xWs!#BgUl<^$WdHAYzPp@&
zO&#Q}*XD9^J$jG+AnB0YB7dPQA-vEQ0dh1x=PVT4e{|k5xd~Y}&u>C|*0-ig31_Vz
z+c|v`AM@OB|3%F0a-sJl!T~7+FF8R4g^CQ~RdzkKJ^3*do0%(`PaadCh`alRY)?X;
zk#OPN1m*Z1&lg^Tc;c=8weIWXUM5)aBfP1`DapbBY?JtpM~{9u5qxt4NTE|yU{SkO
zX?2uelLP8X_S7b>f{-ak?rD@We6r>4f+;^R|F7|lF*XVzz4<c@%Ua_?qeBU?%KsRH
zxJmXmKKK2b>&v2r2OBZd4UagN(Jk>tV(uN&?LH<zWkrvSu6cqo+S>R_)fnTy3BU~%
z<oXZ1A5mgO9(6*KOn&SwDcA|IrVX9J%PDS-oeW^r%^Z!9mzVis{Ij26AhF^Nl;ecC
zFv_2)ndmJ@;qUekPZ+WLI<zy!vQMfLQp7xpeyohWI$0u0q_l+|qE(;e)lT&um&Ov%
zuL1Nn%%{m7E&ukJ$si&{UTwl+okihXkwI_Y+T_SIjzknN;LZt1r7)uZ5Qk5|`K^cx
zMGx>_A-A_m&Of;jJV1>}A=1!f4N#!|CPi2Ve$^J$xQ~bYo|sa7F4cJJD1q}<s{RK_
z(XNBwnAQ$Y`8_sw0@`cp51}~m;}<RR&Q!#lXUvU?ibn*_kL8~0G13$bVV3p7+aj1x
z84+pXefi$VtG3P)6&---ChM-xsJkh*0^8)9<Or6s0%NPsj7<2lm~;{U?JNJg@&7oN
z#XKR1Bl%w!(H8u_y=XufI>F2J)Ome$J?v}?O!z-<=j#d+uxId&*?N4}i)y~7r^wk!
zVjiB~_neF{wdB9s_PFeKYyqg`x`4c1BmkGQXmquc2<qU?hFdw-yFPVBmMZu^ogw>~
zOs;28Qe3O(<dEN?^@t;jS|UC$spmT!>e+nc2dVw%fBH)KxJV7M*mD1Z!bL2$tue1_
zY2k5c6~99*3MY$Nqyn;<3vVvGCHr5i-WRDrhNZGUFVGk1gpRli7zaM{brFeG%+^{v
zbS_O5Y@b|JC8QZs=_T?X*p9I&N&Ro}dbEkb?Zgc7*TjwZf|RzKbEwd5A<p41(3{Hl
z)|V=qXfjn$f`40=jYdVS$NCM~xD-EDl0EZktoh*ois}m~sd#Yqy+lM-9p3t8i<0(M
zeo<N5Ho1!lMWk7}604(M>7!$5L_%rsEYyE>vyvS<1OVoNon;)1FZxH76+Ao$btmdl
z2_xI7Y%B(3HS<o7-ZFCU0W=SmVy2SWYd~<eeUWeF99T3Sgm_lngJ9#9%eP!Cwh?6v
zuD8#ecN=?FrmBpT6wg68E)N_bi=Ha1P<j-O9c-F>?4gDLsu_CEwUO7AUoF^8bfndn
zM_e)-hLdB8e%@LiNTxQ5WU;*wfz@OD1cqWDuFl9mA5~xO5{OqmSN{>`caiU@8cPJ7
z{PWvJ7H;$qmM!>-;f>P0Y?8QRQFhyztXE1xeLQP3C`55KOb0csu+$gY6T%q^nae)D
zmPD;yTVdlPed^~0AQXON6q56=VNN63gO~%%RXOm^aQEXNVKrGB7^P03s&!EFTD$Hh
z2G-elor{IU`FcpnFY0u6r$db9hf5<KVMSKJzZqHlb<F^xpIb{i6(aqK@<Akqf*-G7
z6VhEKxP|#~OuFzfQv&h&zT2LQ){Buu3-O*fkUjd{Qu)`_hsS^_e@{tIk8WQy-%x$1
z&Na6IYASs^RWNU7VdN!<jV1f)$NMs!%U;Esy@C##m(qT92FPr6bHlHisV>BoH=pF3
z-3U55!Ilwc*V3GzgIwL21^sP!e&~w88Of6T6gIRDF8SS!Tv}c&pqSF>IBA+KNKJnG
z_5yR7%QQkk5xMLv;%QR8kQiTqE=nt>2;lT|o*fVoz@i?^!uJ_^0@2WYHL|g`*fpaA
zw~;N6W?K35-4X+I-^I^Z9FUdNO=qR1$CP+KO<=2G)olCARHQwXY1H~d5*ttCQbM(_
z|AOdpzoukTMh1CLX&EUi<%ccnoWUNOQc+h*5psINHQv%di@%k7W?8{C=JQ?B6O9Qy
za-UnzOWsJip)&Jo37+p|;+wki2>oEQJ?!uJQY><9DiUi^L1r}?VdaMgV~l^-#8CG@
zZ-c|@U-)N>Ft7^`EDkgDsLZIS@4qxZ-6Zqm2hV(gzw}1t2r%?7^f6)#2MddHKHUOo
zzDH%jjRl+qq;{_bvX%qr2P3lHzY2Zh$vucioXuMtcYajsYSl8gYDa&Qv^9R4t03Y(
zhptnf|9M|V0h0AA-HCDcMbrvgDPQ34n7SsFyBM8DoeSr?jovm<dD2<j5T8dm--+yK
zT>3Fg1k&#5yV~hOkPSg|h?hGzF%3?RExoCgFRO{PZRD-Ox9^ccLp9g(974B$Y46Z&
zV`TAKEZpzutU|PYZ-w<roYPbNRlITe^1%e>2WW%`R1uArRIGg7CewPzj`}t6qGXtM
z&3;8?r>+GNv!og(e(FYd>im}{vhebg_wl9s=I82s_LlUoZXfZcXJOJqjVsC!=e9*P
ztW8Hg!@EE9|7P(9+qxlSk?;B~o5pPPAZ%Z5Y5?ut?TX>HULRg2wf?m>%9p}fDl*U~
zM@Y+I`BodpluA4rUBb;#Io9)7PZVirhRf)>Ce}4qw#SQf6Ic2P)NpB~oCXTyL>RVK
zWT*tTp5Rhz)!ed)ia+f`9d&mGW4J3`4LOK==(&G<(A-~a!C<EH5yyr`H(D(;I?wtq
zsu2M-2@8FkdU{`H*PtNjKpDH---m*ZHFhJW`y${f;#N9l0*o2XzEfoKtcUEeqdR+x
zvLy74CydtV{`3kFc(mGqr)1T;`Ry1c%8O^RGtlgJPwZ29g<bT|`MV_H<(_QU_Aue%
z^LrbrO~_&-QS2^R;n1vT`&0D^vbK+MO)R#AEn6pAGakDBm{p-xLi=E~KVQ=mpVuub
z)_GX57^2<;-R}Xf95<^o8W^u`g3J-uj1<a8$vaU6HG%2M-#tAD=Le6nb;_r)pZTuo
zKxVO%+F%IVJM{rc+F0L@D&B^E1a(@0&QE*GcXG95e->Rg%N>UP&USwyEvf(PM-1te
z6|6deE8Xq=v^`gX!yQ^GsclFVZPbWm8L;pnQ%w;R*#tbXyv3uP#ttvn$52l&Oj^PD
zA>kz2l+Y<&mKr;tVVr<+%*Hn@!XV9?nlGyehluPa);sRk4xOVYRQj}ERsN$v#sw6(
zlN3lvgz8twWN?{wI$>-6U<Z|GdZ)4isO@8aHqRBDKyiPjvp&;vz|!w%;reLMK6*0m
zm3~7H)e?P?4_B>>Yu22f_NJAG#)5MM)WY*Q?V-LPjMS==XH2RnJ+!R{eG{8y1ln0c
zrT*crxh2G2R|r=jc*mT?RhS?etOjsC!(U``HM+MQKJ(G|;oSSx3^~J+ls*Oa{8kgP
zQaRyY6=$@Sb9(A{9mHVGuPDG8ubqBom43YEu9u5T-lP@cq1O|)!#E5!3!d}=sb^1M
zCQq{?*7R<DxfaYTGXx;JKm*ezjsPwV4|dw16mEpFS>(NettkD0<6NF`)`o_6PS<(j
zgnd^1eJ=3e^pEEu@qJKhju#Gi+}FSMf?No%93&3p?Chfpoi9w%l+E5tb=L4*tFRcX
zuvfC)U7wJO6z+{V_z*IfRq+Xc4e2`&M4n76N@koCJ7jW>p3;T%e$(|Q@p`j$<u7!0
z7x<oSj_~<?4R?O{_}JnTJunx!ebZr~0{_Xqr0(5?;xDL=flYt@b?`|w<%g8!8g^B+
zy~RJiF9i}_zQt$v|C!@Gy2D96z8C=zY+D@*{*3hbJd-To^k({rf;#-qZeMuUSZez@
zQ4G~MR#PgrujtXouHwMuLeGiTf$U?I;GK5;0D?NrfSWd^f1%G1>c(zZMcal!(t98S
z&%Z1@?Fla98!(%3qkQNsS-k|0H?PBp9Gb`Z%7fRJ?EmclGO>L<RwfIV3W&A5B6$Rw
zMf=&PxZl=6(|9#d`uqS*irAgR2o69gR$F%bsVJQ|e%Pek=Kt7$B&$iEUPV_`uQnK=
zK{ro54Gvp8Uhv;YMr!6-b`v*T^nN*4xI61R-Y!a7i3DD<*t+yfd{W^SRyx~sK1RrD
zankuKo1otuwp|!5dZ<YX+%3b7ubwvyOOj8v0@w`864UK+4PQ|Ys7Zf@1q#25J?4ps
zQU+ei$q|r}CLSLHSac7FoD8SW5~$2IMWdbdS_`c*-6DutqiPKt3tc(_nib}^7F;Uh
zDGUY+jg48oaza$+Hu-#ly-Tmv^uTmJ)oH>1JOurD^?FzE-Comu)KU1@8?{k5i_?Sa
z%d|@I{Ra|%e=<cu&W|qNclm6YH7(jB)XK@+=tPf0+z%6mEr6?<*F(-=x)4jEjjT1f
zB(Mq4=bgfJN5}Q+TY&K)erNz>!)~SU#&K)C;&^Idc@;))pZZTmk@2miWJD(0TFbJ}
z`j>egqWov8K&3-g^`pl+0m56I5u7}!tqEI5$s&mZtleZs3~{*A)b0ZeQPs$am~~(l
zD5noMm+WLY`t-!`SA3n;f*{8=m!VBdYRygX-?ZtD`#EX%(~nJlXojZ(Kh`R0e0+2)
z`x<=JUJ2ns>@84hH%BMtMY=pBl?j)U3bhp&^GhsK&di2EitB%D)AGbM`!<;_lvD#t
zs2s=V561NnTQb(XdiUaHog_*nu;^LrokMt3{lT9bh4*Y{4EHs0VmkwJ)yB#F8m38M
z9{xLhyn?$Qfevg~#(x?()Zy$!K1+&z^$Tr&_b&13fgewKWsc&Pt_-DUe;OwbB=#-}
zyT~*LNwG<XFXNTOGrn6iZ`U_9Exp8d@<1<;8gynHU-fhkZe_f+3~=um2_9I)cWJ?u
zh^NBtj0Nk3N+o#EF{!yeYkNiA6IU)2)hzvvxfW{ObHD;xn%0CU+bC(l*BOgX=bzV%
z-oJcKP$%&f8S9mxHgn57(Qwca9hFc&lArPLqX$$%lT*Q$o}OMM7Y&06INfg;hP{hz
z!lX|3h?P+A$dc7Tf<;BZMSrb=wQj!*NvUA=#09i>iAnTcnD-Yuzlr)sL7ipEip^YF
z^Ym+DC|_R3Zzg@&c%$DVuW1y7cle=4b(}h=O;r{qZg#YUU3RD~IC?`P|9hvt;b}6^
zJ=G=h-{!&Gb}<fITjaZbbL3leix=qj;I&+$S_#7|x|CMZaUI}YY?Pq5Frw|t-P5`f
zNY&T3#LesX1hXl|faPG`a@j)8<BiVZ^^VNQuto>-qKxa`9sLQu>jlv?z1?`ypOt9*
zUnEK0u;fwI4^PCTh~aT((;l;1A2U6IcVIDr;I+cu4-jG~jT;NxVF0QudO`EBUaZUV
zmir|;qWlZbS*Hq6iVgPJKd&8}9&pBW&^3!ONG~Dqq5!$@zQ5f<B;=54G*>*{+H7+j
z{h)DTJzFYaQ$hvLp=ltXAxzYra#0#$Mz5SLlf7?fi5{W2Z3<w$zunP04_^In>l!wX
z!AR7mBp^Vm#aMcl>TkzRdV7s0l&7kvS|yd<6qMBGQvKx>^~0xVUqxj^q=}y;&ClZP
zyQ>}Tceoj={F!YqMY-$N3IR+?FrO|@jWWSbhqD-NC*I|Dj5fsFJmKCWi5Ph{SlT=n
zJsfU5&Nm$K%3_m#b67nI1P@${ArbCymnc$wGX`Sx9^w&5y@csUm)AHxPd`?IC~x#y
zsU%SrUsQZYgO&rrD5AW}*k<-AQJ?CykSB|OgS(Kt=-$<*JLE&s!X#+<A#3ip7Lwdj
zaU?B9+t8EB_pdszmt#Yo6#UiOJ&|4!`ILm`K+OIz3Cxcn{Jz`L05Ff-(1gS+Mt++J
zT|gP1pu9hM?ce;sipz*ATI%V>J%wXJ0csK#Gp9&k9)|0bIj6qLamrNAY|$%BaVX#$
zb-3-(l1nl>9N4q$-WUii^1|=CG5r}t09pT<z8OHy#ER<)WaF$PON<(!ENZUrL?O7P
zV!+Lze;PoT>R>d;zjocTDd3AOyFQOvO08simm~9=Hw~k@wmOD4`yQn1wSJ=KdXAoB
zTw{_So_z`;VZWZThRf!$iON+Jjlt~Qyzbp9Bo0ws7IrFRI(xk5+Jh2ye{7t<Z4I+{
zV4<_%Mfxe7k|7b>PyiHtOe4=WL^gU)0=qp)svQ=^=0(o{kNc!|Vf4_k>lw>8fjmF`
z2{Pgux{@$*xz8mSTxp^dSJPm*e>|K|<_hJMiDOb0Q`e29?}Q;b(ky2ifvy@K+G_m}
zAhUnR1j=D_*igz4cw5pkr^DDu-aiL7puxr$JCthotA>zNnigzZr32Z@F(p>Uyz<j{
z+vb|xNxZcmCeiL^?et}B$1E-;n`RH6FEh!;>Dd3PDPOelswd(QP9m>>l;jp$FVt9d
zD>^N**iJGz&9~F=2Oyk6K5<VXjm~&178+gqE~&+9<OWB>x8C1#E|*;UDVX-z{QML~
zIc(6fHAoXQsa$`^I2;N;wJrGEqzdsSRzfc?2`_Ikar9=Nk}XY8p9~jGkb%E?Y+ptD
z#o+T#2gIvfhzW8cORP~DXl;qV5rC%Gzd~dEEkgu%GTVpGj30I^Foh!v{SuUT9Y&>A
z)9LyB-!y+M!?pH#8Q7T|oqVz?Vey=6BoyB63a3FY9rd>CTT2&$gQ!UYaYjp}XPaxc
zC>I%N)vlA0VMn?&9<{Y!85tJ_6p%=})zcFFVg{i68k~Wlw0PB{apmVo+voGY#Kp=(
z{Es{Y7riJQE_4e-kZv<``z<^6FE&&p@a9EfB8}X6te!|P*V7NXBBzlrDnZDN;>Jzb
zYbzTS0{a<jcou!eOi@(5rX0?)4Y2chk*V?m7K)A}J9?4HSr7ZDdR*Ewjy;a5{Pfkm
z#Cw=lr@SN$9*7Zzb05$N$-YDBL6ps<ct|<pGu$kOj%t|SZH^`8Pg(?gI^mg7zNPX?
zr*R9)B7@sQpY@FFM*x19oglenhUx)IAMp?`wq*GAgmC30(R&7Zi^HtnYH6PDDvyzC
z-LEo?*Sdi=&zceXFD|6#Sf~>s6rm}U!nD<v+y~vSgKHK)*r-_d#PxuSGX7`=jK(x$
z&^HFY@i}KJP=WN@Fuxxu<+kogV~9pDq}>b_?hG9@3&_GwRub$83Oc99Rh)+j3oeU-
zEv5yxuG>b2B;!cD9V(ACGdlMj&v;xATaG78hP6<%+4bB|1nDxZM<z^G(%#o6ghXSw
zJD}kgO6m*74;t4wA8NP!MSi#fM46%b9gJ;)|HGUS4=P7V+{<~u2&(%6`7<8&=Q_=_
zOkZ6L=F$^)tL|kr;t+JY^|W-4?RlHhB4<a4?YTCy(SY8j`l(P-?1UQp(!`Fo&60V-
zey-G)R1RuK|2Aur@ko{dQAH3(*wAK`IFGdyCXoZY5*t*zFg%3*Er||BL^5vcjGwm7
z2vU9OH-6~6u~X3M>Rx4vSiXMQ=tpso@$W<J1%YUc$s)F}f__&=aLBJ^F6qOQH0cvL
z*mN18JNA8(*za|RX917<){nT<VXe~Yy$6$IER3MRFY~sCbGlZymijkye6;ZrWNHc0
z!P)W1)l_Uh0ZxLX5}-VKh-`c{4q)Vw;@*wU|2{pl?mm<%IykTB@iI^eVH*+yyI;Rh
z&HQv8dYpBQ-Frd4VkO9L63BbXHQu^&wIw)27Pa@EC*8W3gxHh?b`b99aKKYrS#_2<
zTU^|+Ak7;9^=HD7zBby;o+^Y=&hALU10^>YGm^DXv~ywaDB{Pc4ZW2Lw|+{ZVEy^Q
zHvd)xtsT$MO<t;}nAY5migGG*hnDvl2`}?=vawwGzvFVVum}7^#e79`)gOD%446|M
ze6EgHSwL9cj-K;g1ovPrY=pA$eP3R<2pwn5-EZXTX(Yc$h`H(3OzAM%@VqnGn3g)S
zjD>X^di*z<iCYp^C%QP;^fs&{jJ@z>r@8kN3|wVVzuppV!_CO`*^WyfN0#_=m}XAY
z9Co_ZQr@>_778L(?$@Q4&V82$;sm)Ycj9}`607bo`0a*&<+CRl_k1_=NG9x{rWAto
z^>(LKHyf?tfiCueJRa|X=ai?MOd}@IMbGHd8jj2sIce2el4>+r>r&Dqi@Pb0`%wAs
zkHxvy!br!y&wMAysJ$$<px36+#jS=HMq)$V1~hX#eSh2L!W-e9Joclq`!NQC#m;ry
zrGV89(&77`(ukm1(cSuhe}bj%upSP@!m%eVR<$jr3FPlDDSzB{;s+Ay;s@Hi4xyZ&
ztnQd5xwAJjg?V!4_6^8U@`f%xX}?|zchJA{sSnt-JtvoVI)n#oqtTstW&nw3$oXWg
zn#r95JnLxCfd)FZoK%s!?949c3Z3Kala6X3tD^f<)IYLY0G~lq0ynuOxW~K;%avle
z%g_v=h946Gp@o-?SZ!#>=FzYtn6b>E$?b)c%7<*zs}<=xN%1>+qSCa^c*To=_rKqm
z$$fNL3kaI?CO7Pjk*cV}ZxYuH_+=7%SNo!0qo>Ls`>nZwV)E<hRVZY~@y*SUCdBwf
z?Be^~d2fFIgXreD5xyZG1)a8Ft+tzki6Uy3R0PpXa82=%XM*<Nfz4f}h|s|Yb62)R
zQu-z{O1V1C;hwV@HB|q{B_5!pZ&r^gX<<mnWA|9ld{D>9HPO!l1uSu|ZF-Ljhlc<5
zBW0ghhEGmhShZr%k9b!3_37rnBUjGJLJ%<iozdM=NREsV#{%S{*iQXXZw-Ay&6YVF
zIXd)lS4-0rM*8Rp0YdFDB;05_5_aHS0`0tUlx~Hj&9^Q4$bD*Z_cjTLsWVRI1-4i#
z5&PrNS<Kvck2Xog$Zo~$L!X00;b6S!skUwbiw@H6j7rlsK0~|M+&g>GEl&i2<qKk@
z{}_JW!n9pt#rX6rFrY&ExejG9_ormE1m3}(JmNaiucQ6kU)L8?=qK&7H~|mt55(=~
z#!%`p68SMdTx6wOGAo?VpA7%H@wVtQ$Uz8Hag{YDmZ*}XJfq`afdf4(RuyXuHe3#p
z%u<#53~cza1!l%0GgkarL>R#JjW!1BKl6X(W6u}T2+FWP*h00{s4Ey}pE^)l6(Kze
z6J@&lRcYMfed@Hx8%lC$%1QHtZN~#QF0_-H5jG#oNAFv(NIq0!MZ&yqFnz4vc6H|W
zmhS1lL-_%+W95$knvT?%K0YVloMR9_K?C#H@5(bnc1FdN$l&Ec*fC$hz7p3+w-6s`
zVa08YD_c08B*c!%kydeu(^U95cH1D5DfPrKwjr_5&o3^UhDCHDeXmrti&&SmdL&8d
z^7`erq2m0H?IrStg%Pq8$lY`Rtw)(K#yCvkJ&i6z9tC%!5bX-BqU!QR4OZ*D5R^7X
zZoPFenUx+q%}c#@tJG!s7T>H93hIi;=lKBM6CG&xdllVS`RjZvaJ{83tMHJM^H{#=
zVYO|pqUOw4g6|-Sb&F&A_LQXa<|6|swd(KK+=>&F7VRqd616t{(|4tlxfS%MIJD-Z
z?8b4LD#!9(@*iBPm<Ml&BckcgPv_&!=!foydz5q#kDHK$M#nc#4?3x%B}&Qs4>5eF
z-o&N^8hN45m)d-lPzYGJ*t({n#3e^w9B=+PJRVQ5&!TDO-F5Ah_ED9c-*KcR`SHk+
zad6j;z2BV9RUHt+Yx@`{WIlj!NC^c$tE4QnTxu;_K5+G;!Kb5C3JH9pktLwG=PFEZ
zwS@BPkW&+AZlPdH<%(LfWm}2LYAV_Z?>OG$>ht9dd|)|Cch%d$vwGm7a}*BQccc8M
zU;as#u}W?{27rnES}r*TlbF+z;&tmog7qLWvm>;=BoW|iH7s?a;Ojr6{Wp0UtKw41
zkTrxJ<pH?7y^(N9-Q_YV5u#X}#2Lw63K##FCMWM;A|Vh!w8pnDagL1KW`b#sV;px6
z?reMLz5Lr+6zjE^@Mrt%^+fuKK+X-yv%Z`#5j2&(7MqTESKSn_I#R{GI*{hOb}jw6
zJuo@H3{+xTZTn}FQ=fO$<uoAhmV|xcwYwMp&~Y>_NWlcig<_T!E!x*>!8qAbFM$qh
z4R@tev#ENw5wT~A@U+I(FD@0MDSG1M_j5*BSe^Cu!XI$R1tw`dlAB#>Y`e}$>7f=b
z8bcCMAGCnn)Zs<SH3jDayi?Ksrpd46+}ajvOb)QVAn=a@G>PX{P7&qM{3L}Pu*Y6{
zTh8u@gnEVoq?w4G&@$@TS!?h#*6_YLHfQu*w4Z<9MyND*ZqXVi&qUA!aeWLJVokoR
zDu!3!3)-NWVILHM0^F^hwhnd!m;R8kSJj&6M84~kPo{mG1jJ9%RZG0Wa(yJT*qzRP
zmUYNVj2*0*K#CPE`B9jdq5fQ4uUsmGptaa1>^B9fG3No6Oe0!`GvAoolClnEAj<pq
z(-UVuE|Nq@-`T+da;il;YIozXneZ~JxObI(0pCMmWNztR8tE=Kgg2<8XtG1L0|WWy
zIIxY=)qp{B>kl#-2wiUWgvLpVTZ?DsFHk;>bk)jsgpXS$4#EfuN_wA2f>En!H64%C
zfvi5@e?VE2sc8|1xk2gK1D?&RdPgIqo^j>A(lc6@^vC7U6FIyEVb}YJsF<EcU5mEq
zj@f=U{g<6&ebU4IJKMmu7vo`vvXUWWAiFH!4C9YUg4yHX;0Al9U_5K7*?v!_q(?FN
zsTn@61A7(PhB6LsAu*-f_xt&bcyh+-oslAp5hz<R>Fz*8l+@_Hb@J=_%#VlnDITN6
zuO>3;&>{otE~mfuo-bW2Qfc``ZLA-*1BZcpYIjG{CF<`sW!t$bt@*$y2=$U->Nzy8
zDGlwM?UFi2fCX2&<&YWUv>4#{*M>vMpXB}L(gomiq)_oWdj?s)<Nef8q4374ZI}C5
z-$QJmwhe8~6uQEqqowp@!P-jK-`&e>W1i!22*VD)OLwvNDCX93-Z&%iq3oPrJ*pn9
zb${otr7D)g?2DW@EY0gplMX0Y^<HHG!X#Te&*=Way?WA-*G4uKr|>;s%YD|Z>+p;6
zmX*5owFGguqcqpA6{W22!AHNZoMw4&&^7F)`q<H|#V;s2(0GYiuqEWm#^<p=MM_%j
z<C-+xCO05ssHkN~1^3P6UUbOO*ty6XkHei%-hf|Eg3bf5J;S3V{O_Iz|6|?%RqJ?Q
z>&)tK2Auvm_zc!F<ZJZKuV-ZYe1KutvgQeP@$kLv+q^OZ;vX@)4oh1~kfwaq-vJyG
zfv7p*=IZ%MKaXF+SF6#`E2kc5%gwOl(VdLm&2`orZKHEXQw)tjjbE^AU#pozi`n{f
zjCNfmF|q=<cEgU6u^p;)4x{%wG>C&y`WHpX@GzKho4}G(BQPY%KO1*dU6z6`1yo~g
z$h}C)Wl?Q~JeilUJ<iW@P<Nm|3M8ipY3qZg$7ZTK-RYB>D7XzBJ5L}~H*D87maD(l
z)@$sD9q_J<9mKSxCbSQcxjS4N`BiDMMnoVYn$mhqr_)<%F_)0RoF2kr-XG)aETrM}
zC6qN*!3_77!Q}qsjwh=cr)XVjtt4P<(aGtH@i}FfA8GUhnzByV0@=b|#oG!WEO92E
zeis6)_%4@^Iv&_BQl%g8=Xm%Ydtmf?^KWlL334nC(>(NBu)l^r3)|ExgCV5DU;{NN
z6PMGMb)@iG&l0e&QWQg?AqiTH1w<~cXPkcuYWIDAr8$1YSsx2t)YCgITg>nuvY*{-
z$u^bxe%X(y(2%aUwl`|<cI;w&ZEvKR#p%5#G5hJ3<JzUWUv1p2+GcHYXpfzU#9lM_
zb(LHgoilb6f+<6Z5ykOCl4}YW$RmWM2puGY7UKB+u$=V%IMp?>3v)CO5dI#WR`!v-
z0?iVF*o7GnNQ%Es8anF8w&vG|Y~*!+(X7R3#-eq_Z#R~zwf@^N=wFNM<tx~Pf!Dx}
zZ5(x+c<EARyO`-_XNS6H{NJ=dwzss~A>sPfO{-PyG2nWGJDn+$k7aV<{yF-HZ^i??
zKj@}Lh<2OuDb^XtIA`O*>J^JvN~Jq%7bUq}44z}8wz+ziJ*t;XIOQ||PLxpb+|*-P
zOSP(8#C^HxBI~bI)o9!j<Ruk_J!tS3!S-WN@_XVlyWS_zwVV07@uR7&k}Y6cZ4*$D
z|N0_cU#{)Y2dVpy27+yg#P-z9B}ziS2ut|&?8-#l;lvNRW(89wl-)I`4Yo|_v;lvJ
zv`31X{!{^GiBggO*Pe<VpIsCy5b7}^!_Y!G!_NFP(5R{l@nXRf*+9fT)U-b8jdn)~
z%{;Y|eQ0{4AT|H_ILu7Pt6zv1?bTM>!;hkgl^H5~)ON^onC8aG?bV$)P*S=cb^z9T
zRj{=^6&ZGi&xHO-C-s259%4lJI?(uR41(0UA>}V_0*y!1M`ax4n$}y5YOY?lEJmy$
z*r3w{iH+anK??InC!E@Ui9i25QUuHe@gnIiV0gpdhN27uFp>dvfGKot83IDG&7QPl
zUd$LGkrS<^^zfTmOGqX+ZicQ{UvTks#q5fe?^U|TqD4bu@#q0aN>eZM-uM88Dx#vg
z9X-t>K5|`F8_@8#{6~{BkoF=z;=Ak_4fzGiCr7gl5Zt1rw0Muqm_@s!@{zzT@*$6u
zIr`M!0gxZf^S7h!d26sV24!NdlCCZxSDxgj{sGs*g2iT?de+W4tLvL|f<PP$Jer<P
zV4l#Cobk6Y=*_Vem6XQ|rNmz2-acPB1oA~rT%zLNpL7my^V0#3baOXWj)*@YvsSLK
zu$Vn{Ubv-i+9%dE-1BTG0b0}Y-Nyj2iIQTboSv`|{y*q6z(k|)%1LaS6D*~HMvdj;
z;w{TR9Ej-cI(L!Kdx_E9ww3#tdb<rzwub;j#Mcy(lV3)AZZ|=Ed{xGq0xc=YpCj}h
z1s5s$p$=~ZDD4l-=sWg(9RRdyP}ItwbdD{2At#ae^C6?Jj27IawCT}{`vMSJhs?1u
z<0b`FIXxP#VSkm@#F819JByHbHh5TroI}fp#uAS{RnxPDHQBE%PM_3W{GXN}z$TrQ
zj;}fQl+i{Q5WmDS&}0Gw+FpIC?LX4lWmhUZ6u?0+W_{_u{1Q~-ZnrtKrl?T*w-Z|5
zqNHp*K&fq3vnZ&wF5LE^p39liu4PmMu8r*7BOo;-TDljDQ)|(=DhGRZgv5Xs&tig<
z(nvj)bWa0WYCuijtzG*R0Z0DWTFZ380j&h=C)nc}G;*B*KzXr|NGq9aW0@PxAl9*b
z@1^G%`wOXdy(!r-4YUKb^7GMuY8}oh#mfQf9EKbl3@&}mWO+RfXc{WM`xug(zFV%6
z;xja^;asQ$!+ku$pd&U}JM}BgtkcYQi;uDLF`V8%(`5+kp&ss%A;gySho_8b`%P38
zZ8K1$&Mo9ieb$w$t3LR$(gOwWy8ehm!ruJlt|&`&i2lzS^Kw+ch?c&}TbfrmBIkN)
zXLs-=5Bs1!XiD6EM6PkmH5C{2H3m!}uR$d!P$CZeAI5cx<K19q!{Xu0wa|yP5M6&Q
zkOH;l@ZGWf<A(C4sUiK#BBjC~PN~2?OwS~~iYKQ`hHvru7#{jdIS{5aBAg4CAVzLG
zwt4hhLk`a${e5hS3zpO_v3*~dOPucrs0n}eLpvIm+L<Tx5P3QyC1d#jhvOZJ9BBR-
zdjKn<g1$2J>@B30+lW3Z5Uv7g?raQY<+gZ8(@J5Gzig9XtN1iSYTVY!vO(w4>QTjh
z5mBYn&WE=u?jO>4+<Wy~&&cCH%CxUfn7xnGgV=5n+pPJZP0Qs@^o!SAASA%BBk<e#
zzVVBuTi1rlTq8#2f7EWK1jj`E7nrjvm*G{Jk4@i>&|hE!hOdj;-81S_1XDyv%^NFP
z7adgz&#}=-huSTitOM!z&1maCYuloWWYqC!Eivi$;=0H_|1u$4ESIbnT~^+d$BKZM
zs0msMq=}-a6B;I!iT7o;KCS-7vy%?wabFwD;IVqfbbC$|a_cV9n}B{Q9rVCUQ_fKx
zNR6;4adKs%R72DUjW>_Fhq1RrA9u7s+c8bGi0e~qUEoF+CER0l;1kW_C0dOeCY&lx
zXEG1T)?uO?BgYOa+>6cJyVpqrePq+Gq&aAk8cX8d>fbY#TxUFzsep%@W3j)1p`xRK
z-s~+R#W|BT(?qMGl=;r+LfkDC^St!h=RiSrzyW$>yW{H1d7@Z~w-eudx&YnAO_lNY
zMzMjdg7P3II+htLz@>O73RX|HoRJ>A+KH8@%NzIsZwT6O`Y`K(7o7CtR1`c~x4sa7
zC0@eaJEMZuyKG?<;h3muQ4x{2{*ao|$nCLUKMSEC+Jh?3Os&IK9I~WA@1#mS=rg@S
z*e-huuZAXO%$QHPtRBipH@yKgw<JFkha?52Jva!Cew}dhW6Tv|Z7|l7!gc}<xvGDo
zNs0qxf3B@xBmz$+jXIsv7!=HI9d@SZ50<V?#<Hc~#tYDdOQv(Ldno?Hm)cLbJJIsS
zPZ3cKpysu3ULQ7zqw&ZrXPMXZ2%b6BRPXy%Qj9F{K0y?Ai})V`COmINlYWQw4IsVY
zmVh#%p&{hdAIEz!^<8bl)=kHvhaAyu;7|+mmo^%ja*<je0@6w;hl38c6BwQj_i%(R
zUPn01=~hO#@qps4zf5;>QxB8sQG;$IiEVzD>RQzN=<9hzVH^NzJdkjMRk`6wpCR7+
zSrPi#cz7qMa?=F5=MJFF&fV@;QNzzcSsUM8j_`m(arIE5+;t3>pBEj~e{(}q;_D`9
zlnC^kaT@nJt&;Idj+?Ws?l?g3J1X`xQGIom$@chYBuzlO@xZU-7U1`XmE{_X^LM3G
z6-CD7k#V)#+`71e5Zj-|1Mp1Nq>Qn^;6OFoXeda5<~79e*KpmM1|&z<rr)!UF!#`T
z;L6pF(u<;nqLh0f?TXEC*v9GCifO^-KZ^tlljcXcamMaoT0(cvlN5>Ktnz=POt-EU
z9u*|qnPb)H)fR~u@csq)`;dEL_1Wqb4nrq2V3*OF=-sqGusx1sVUagXU@We~SjFOj
zcQ<2q<?LXh^otR6P3%o@?yl`fA2Ts~y3hM_`oz73LUncSJ5D1quBMFw+NF_Sh5Py8
z#yU0$_0l0q41N%hLaP)P6+G<%BQkW$#NKfIh%q{O+wi-1GFf=}0rFAs>`T&iZSXPp
z>B-7uXG#R4t6Sc`n#>o{WB_z#sL0VN&K9rWAFW&L(G`Wi){J(%0ZR-`Z6X6C;^n#<
zX(%W_=t%(NZyxMv6USWKf>CRTKTk)S$~E_xfU)nh*TQ){7G_$jdDNxjeyBGBOTMHd
zcme1r*VUWx(87tUmS(F7KuM3Xhr1u7#7cCH8gGrso;84t?4w^SAB$dZ%0!8pc(H!D
zuC8jKLs`3v2*Rg~4?``G&0B=ajS<Dun?*S!=MK~B?i>bRglkKxyWoW4RZJYf{D5hl
zUQ@g<#eu$3QQSy?wNZ5kPrvx-^Q_0Zpi5v-ktUm6J-zxxzuNz*8e;5pyGfUtoWxqp
zcf-~6<>g_X#GdHujxpFkHRo(2UZ}V(>$l{g?98F~Suha6gD<RNO9u`B-4FQn^bN(z
znddM<w+yYn-^NQ$Uet_6=KGRM3)JOAM>FN?zB(A_n#W_$1P=Kh<}TWH3?oewIge^Q
z^5l-fyBD&2@t1|uqB*eSO5Z>y3|N_FZrRoR(P>vIONc|`L&{M3+aZ%C<*jp!A<@@?
z{#6St-c?Q%PEvh82#?I7?`mn(l0#}j(;?=aF+^?C@8=eQ$5Y>B{EDot7cJE8YuR(#
z(xm5d+sq*k%>Y?-y0Y7G(>9=%-Fu`svgD$=TaSNgEY2K)R?cht9pRyc+XoE2i<Ex2
zCE~Xq?HPW<&trY#rT(xU+6+W+qdimGa5^?>zh?6|W$W5$Ay|hWz6<WArbuOUSF9GG
zN>`S1(e4{pCJa9U1!G@+A-}!&QZhbD>?7RilWVa=-?BxzcEJXBvyaBmR?D<zMBTCl
z-CYB667OFpDd(G^zKFhOe%FDMYm21XY&RzTp?kpNGDbHP#D)uEq}?<gh%Wfmj#u}?
z0K%Y_Z_-e5@bf!*twPw#LUT>?cKU);%{4JDX?;?QQ|@#5x3WIXz4ziXAw4pMEVaMW
z2li}h6BCr!+k(GR&Kq`m7I_^=;QCH7`cu9du3hYCKW^-Jos3f}$C3=<tqk|F+)X0J
z5iP&GcYl~yj3;U6JmntK3yBRmcw}w(_}^;PfjdH;u&E7Ezmyj$eDHgP+@MX;4<Yd!
zn?20>|A??z3;VS8M<#5u*9$$PYAOBV^@de+&Mxn|%wq{*NO0o<N4(trNOSmS>DZj6
zCyq_>@b;BUPIQH_422L*3p~gvP33$flJxJ*K64jJ22$3?EOzM_sR6NhkBVt~6sDxV
z^)=Rkt6un~t=Omwq;)b&%8AF27!iEOO}dD5ct%{(nZk*&f|oAZ+%BIff(X_kPc}Z`
z!O7$c{jyNd*J-?eE=h;+K`FGWdqOHgQ9h$OHYG{3;r@GXR4Z-CxO?l?Q~OGmEqDNe
znnxE><_(6Q)k%)=DgTFZChX6EtCpb0HO{G+)rA*<<!&(~Z^&9wkd{CD&H16a)`|=+
z_ko<dob!;>E6qAE^Zzdehe(Er3+Koejg-2f8uen-E`t3&=>l(~Jm~Gecg@bJ#wKs9
z#?03&YRyVG$v9^SMi!3zYRM3HmD(K3PYS(H-uh)66S>K)5D)b`A>=UO!>V59sHTkS
zWKTU9*;rjhc(k0GCSscph<|q9>^;S=uW7`sC<b{yP!7KyZ;<k#E)_XDHeO^t+Ve(P
zby<~Y!!<hmm3mDm21-s<UAelh&9_J|Z8$>J^1jYRe8ruNkSm|{+*eY=i~h=F?cQG(
zN#J3VgOtSb7Sk#`<^M)2l%BcU5yRb=2uCf4CLMKBhVxo0TAy!^lMC+BOBfnRHEOq^
z<izksa)+oy1*Rv&d;Muo?+={0@IIW-o7>Zze)h`C9zs)0Jd>Vx&1rgdGze1`nt~gN
zgZT(V)xdi-0{8a0yq1z__+G$`P@>*(_Yuy%$t~c{EAMbGjm+r5SN_;TV891Cr1AdX
zFau~S)v_6OnNX%%K&6__mbkaUy>09AZi#XO_*ZRVanI}UG9+GnL$NAuB09$d)Blay
zA9`6f_IVQQgQ&xsrX+o)DFVYnz|SQ=`kympVc9M}W3x_gUp6=vY38<;nN`!cv|RY#
zhM3Q>90AXhfiqs!>;6sj;_euBI0vz#2iZlIa6(Lel5UNp_IQ;c)Jjj}ldLddm`?Q1
zSMl%UGq4&Ez;%)3NTt+RWV~eDIBf9QZ}-!i;pasoGvgz!x1gDfV$I7Ce#Dgmr|0NL
zs#Kq~+X>&}+h)n;VpU>{lY(<M0+%DY2bb<QWWL4y$!ygtW6#%UNDe(;oCW;-nz&^e
z3)U8(-n#vrFKv^blUTZuXE_nB-cZW?K3d|^=tdLAl?A-?2V<yYtL5B!@8wpo7~)$r
zCqKAv9eBrS+=)5Vm{Y&BKs@*UejguhqHD7c7fvV{J6w?JCT&S62K#L(5)De+G0Rg}
z^a?|Di7T1n4)WU$ERr5vgV6d08LACk-*+yN@iiVWuddI^kO(32$PU%H23hb6PK^5m
zSSU@Dl$LN`rEr=|+5C3sHgkPyG;uv;;t-qM3rUT?Hxh82H5+SGlW!(1qMI`5mk*kz
z$ORrJW*^%&a5RZOr**Frb{^1$wUR)}PB`6SVY(8y=l6bYmUqp^bG@~@#^$kOJAUj8
z#?TFlk8~AR)3B0m>$=wvm6u5$?+!spQ!WKJ2u>gOuI6<Z5(B}MNESzeSH{;p^vC**
zQrdf)>S%44F7JXUi!N?c{ZaVQ)<O9CaQZKB5z(Kj7%aHyT}*h@rq&lFXiBWyvPq}#
zc0Q#7341}aZ4Xz;m;W%|3|Bny;54Ea(jM+g0!;NB5+H?M%c|5W?deMW<Q6+n$u2jx
z&K)XL$1|-dR)MNq@&R*~Ln1CfEpc@ksnZ;6D{yG+N#$GRd*-QwM@%X4lrdUEF_U02
zmC#yL%<_YA$Pm<jmY~6EIwCKg<IJ*Ikvhdex>GO8Zg*WD=~1FHyV3qDvWVQ(g+sXD
z+OITiB|>4_(vl`i?WT5NTg5Bzz@YtRkbQds$=H4lviCalBV+5YwtA(sRGqWc;jVWy
ze$qVCuJPig68}L~+EE2BVsNh+=WauF_j6SY&kTxf6L`7|p`s40_NUbdzBf?ih#5?}
zFH1EjOTwW2kI?Lre7@=E6E3yb$_aDcyS_xNwE<@Ff=NBCRg4N+i8$ILFiI;R>7L{$
zzrnIJ_}6LEa5pF;E6FqUd8gaC5>i6APb4}aeVy~{kE5^1u;@x$t0losx9*bbj<Kn6
zRW!mS5l*BO>SQIFhoI>h%&T_KzV;66z9F1|*1K`Z30)=xVhX3S#{Eh0Em$6VWUYGM
zFcjMY_|IO|rd>3e%T2U+I^{`(mnRL-MiFec{GAvKcDE!uqmnH_nB$;XbpXq_!nBSJ
zF0l6sHVlSU=B&0PhLtI`0fL4@CUyTfPCF^oHz?S@yvYhoR@qvzu8vX9kv^rpr{X7f
zg<XmqRsn=V41P_*_7y+{+s!Gl^xtR%g=3a@owz~{^kr|_9(B7~=xGnoP9;b-lIzU<
z4+lOKJg%_{qN^X4k{!u$Ru$6|mt5ANnRD4)O&kOT0J;0_sUis2ts#;ld`X(W*X`zX
zsgFd|JwQsQra=z(Ct-m)tDm%m`kVLek|WFVY2Oh{zMha2A?+*mmSsH)Z43QXA47oh
zg#7)<5=z<(<jS#D=*p)N-$d{Xn)6I8o7gf7R7V<@$IOt%1WH-3LsK$|<B8g4-k;Qu
zUzKf5I)v;cq~+E7Z2d`DD>FyGRF54@@ev}t+fZq6eV|$>F;nw7r}g`p69j{NG1|&=
z-&y^Tj4Orv@<$4FLV1#zywbtby{|tP@y70L-?UCDgzVpwULZx)Am}~T%R)Iu+MZWy
zJgAb1O^=FwmH%kEk)B8ad1LK(u!qBh{7oQMWx~@vr@*vyf11FV{?DGciqf9pbRhU8
z%}ss<ry=C5EF$e)W#Ey}a_LlX4c8?39@LMReL`tDhin8GaWR%43;lNt@cAh`?lZ=t
zYR=P+#!?V3ngjX6(wJ(U&A{fd(=R{1<IvCJd3^uJ>}RUqX0J4EVQ+r4w&$hQq6F#@
zog#6q@ky&`w)bQ81%&s%jm?FRl~T!X;&nkB9!IaLUk^=3nE)xOlUA99UoW+FcEV3h
zUAZp#4(lru({np}`bI)uA~(c}BS>T4$wydpbraCg*nMbEOP{$R&Zf5PH*~FYS90ph
zZliLI99R&5&vv^c9&Kx-MV)^|T+Nu#pPdZ&X&*YjZ>4eN)Hn_Na$qgpP@hw3IYbo&
zCj{qb-F`><9Z^P+m^J<T;zeh0o2a<YevQqR=6))nw~VCFj>Kb;Mer5O@SXhbuePn4
z`9S+NxOo7!A|Qx<dZ-CDOT3Fn+uSRA6XG^&eADG0e%qNUL#y?zgJ}e=wuvg2>YQ^F
zPs2j_OOa|(WxM4gMcTMMa(ndYWNy05)GbTzg=dR8d!Sg&V?i7p?*r#vlk1w?BeyQL
zn<U<38r3FSXLcaeFKaDb#w-S<tFvs)<&zlu`#WN;t4Y6gZWwjHEA=<JOmK0STTb74
z3*YKa=vml|;@CPn%*%<#fbQ>ImN5X&N|t|tR*g|Fu?@aF$^?6xgVWtZKH%x|Mi$sD
zBV8CiNydG_Y<u~9nu+z<ZyktDX`b)yk~`HyFx?m@15EfeZ_u|pK2dQV)x3zt(I=3m
zCP$YZ)!pQVY2X8zs!i0~iKS2XP$o!BuV!RfkJrEV*^GzhUmB4}YZjhB526_>w>!Wz
zosG+#NBVnmdhar>Azo5vQ3RSh?~auHwBc6Rl7n$7)C@y{!P)VkV=b!Qnf^q3NvzC3
zjX^V2R8v+>84oo2DC%Z5G<S!M*?~$69{1N&(NvSnhFs2Q9N+#e@xqtwqr$Y(&#6a_
zMmSw4U8<+F-|xzwpL(z7%#Ve{zrmgc9qnMdQFWY%{E#v<H!YP6xj!=U;!^{!Ih-8e
z#{8h4WH4l?Eh=4euXAdC-tB7~LiN4sh=s?g<DGmTU7TZe+ATi&1iJO7^v^+*xUCDB
zcUAhakn~#3o%1XnbgedY2H!CWd=bcNeHzNu!Nb9_*7XFcdsxmoyY41^Mu)-C?e?fS
z_xPIjwoECZX<)CUhY`p-mVWwwczf%pIJcx<I0C^TxVyU~!6m`n(=;BM03kR8x8UxY
zV8Ma}Yn))g9Rk4u1b1(&aqiPOXXc!lZ{~f!Kkm9~v7qUGdQ0u9+O<o5dun0U{wV&$
zWOv+3mhx<nuSr^>$v%Z+F??x~*<%(<gm%NQY5r?*HOGS*svQ%~I_#8nnG(P@2}H@C
zO7bOefp3a&js0*HBtXOs@Sg5chRqJaed#rE0{9>Gt9eBFL1fwzz|b_UE=S7x58sWJ
zKZYgo8Q(<j$PG#7Q{RFVJGC?GabEiTiXrzAc~4$IDIG-`V*dkCz}FLEoXhr3x>9I3
zutf}AW}Z4Ahx+zYB1uGzNy7%834Lskd=n=QC2i@H(}y|`jlPuYNPhHA=7&p?_SLDc
zrVM8uZwXom!dj*Vu<i*!4w<fmb9hR<b*l{OU8fayXPQww&vv`!n?0d+3*x)8t<+aI
z6yN+ZByw`+?osREdMD3hX<07p*X`>6fQIY^wrR*b4g5-}%4Roo#lm{v*%bqwpJn}K
za((n(lp^FLzo}1tSHADW-qtYe^1^4peY;`YL`1{=ve;Ea!xppf7<ck=?wm3xOTSNy
zL3wlOgsMpTX0HE8PmBV7pM3#((rqbB6yjw&trL1lTB_~0R^jk~=pDO-kMWLA#UnIZ
zY<h<Y&qBt5Nb-e_Z35?f7UgQHh&yAMTqd?2T{#cqQs)``kPAbOE71O4QthM6!mxhm
z$@^0?wd-({!3Qf;kwTkZj+IbLdFKcctIOt{1|?m8DziK*@th~O;)f{0il>3kDAtZ#
z<C|@1iu=pSZ!vEL6Yh_SUI?XV#cqGcs{u^=j<(c~i=Lxt$<7LT3pJt#=L~CZdP^H`
z+FX#s5RUeqF{O@~%`A7M1S-z^T40qEUB}^pg$lE=OLXqx;JG##1`tKx^ONiOLSmxe
zP}GY{!qCt;mg{lF7Nc}e!LY9I&wUq$+rzT5vP^tj-Qmo&fMXJ$sywh#<q_>s`ex*+
zUagons(u}HNEOpiYu^rj#p+Q1n2Ug$;KqfVZNKgH$@Hl?>5R=7!%5*=$)cV+`-}~Y
zEuf|>yV{6TbTm8e<gRY%iCVW*H(&vJ3ZcO!6%KwtchZ;?AJ%fW(_<9eZH3J|`)YDa
zS^$4ZsyC?Z$+NrO;reYw9ils$dIr*oybw^lWQWdfq$-6PT@%WdSBjnMZ98PXUPu7L
z#NEZXIG*bqudV`z&)|)V$MJa~aPn0r5bRm~Rt3bcVA%>Iud!o--t)&seZgq%<{1p0
z3OfK%M5%Pov=J%L#8a|uOK&H)y2CYPWWRvpBm}TksG}F)`O`ip*(C=&evLK6p}$@q
zO70>>4v2C*QZp)#Zzf-uXN03BZMf)$psg?U_bZM-RgbqXXh7O%E-~*^!l&vl!JUdg
z@e?!N^4sf8Xgpy|z?G_`3obUxgQe|3XpZT!2P0Scnu%Z~`{<KH19$xJXXJjR!&6g;
zgxNAw<$MuI!M*UFz8%I&H4{ZorI^+4irgmA=FIWo69+&cik9l7{^?nR+V5j^y?O~t
zJw7`&{zPlgMcR5ObG1%AU^Sn|W@&668*8|n6XbWsDVoARH6^02z;ng|y$g>9e6%x~
zewXh?S}%~%iM(b6YN{i&al;6;vdVFfCZ|w6J@bIwS_5C79cxob^jcC8I9F%);Mqk@
zX{1i;S#G-M2{>(_KIIcYpXyn3-e>lcXsjSF?yLNytj1Aew;O$l6_c0<&n1;TP?H0>
z@K+-D#kCv`x$E981G%Dx#EUsK=<W*~rV0XaE#tHE*#^7hzk0o>*v|CK>stB=cW>9Z
zEZtGV-(?0!yNcM#&0LN+sF7aOw2z+Wt_iyE5~j$MF1k1LDmR8=^wpLxXtY*CpRzPH
zbY|B@REV12|GL1Eb+ElzwJ6AiuE*xc)wR6Zpxt;(8Du;I9_~m}>b$X>+k2?proBR6
zay&-0DLKyl#?-dZ&i^3Y=QCy9w$vOg{HOtj=2b`6FPt8#IQij@=d6zm^;uGTz`|a&
zCr(aj&rvr726dy;6C0*Wf-P>u39i`R^5LGs^$U&Jq`#UUbnDFSeGJQ;Fm-=8nKEP$
zJU`WEMhNT9ImVuXcRizCIm=0Y#Hf{UfYhov(*0S@N^uH|l<9NJO7JWwd+ofVEb8K?
z2=DrQB@5k+x3-TtpG%LSw5B7vW_&_idSYN_pp#&=7Xy=Bg#_`J(boDV<0!-7#t%;9
zQ2PlViU@H(EelhJTQ82`^vLe)iyM2VLNu8jtae|?E$!#MDqSsEBA-gG=e0fYBX$E{
zbkC2zVe&Qqz#Ih^J-o;lbApZBH)9cqfiOOlvv7HFTER2EdyHb98WjD!#2|6LPLD}@
ztEIQ-{!{|E$Y1AHl;+y3Oe%U%Duzsxa@c?6TJxk3&yU<VE#SwP!~_+SN~uVSpHu?J
z23yX&2$(66-2r^wjfIMj#_Einw(U*pGe61#Dx>HIySsI$Z;2X}#(g7j94_w&<tHjS
znpt4BXZ)RCuov+hX_e_ZqRzJZghsdZz@n=D9U+q{5Z0d?kPjCLkV;E7y{#^XeH3-~
z-gIWsojW3Z^Mzf<!+zVZ_~@BoHLL9Y$*oC-yER#6i;)M*mx+fMyQ|?cE~)CChfL>J
zaoh>jN0f7K&}Ew2$SFJfuW$Mr3P1N#yo?|3euWaS0;I0zhMe+KTdeIz;Fc!}#d=~t
z5!M}6>om+Vtr9_TU_{r-s>VcFYY_l)OPQ;Ij5e77jVX^{!ZZfJ|5u4$VKe@a1;`0P
zZ^h-l^+DY_qh3Rsg)T05%Qrz-$GJcTxTSV`gpjvU)P~Gz4m3cNaL%@+M|c1W2Z9`O
zs5Ou?R_V#(m<6`1Cj<`iMr?HpK_aW34R0L1%ONru^h^}xoQHb`hFI5RV?gEwgoq`Z
z<>y=fcawYSor-V5*y?q^Hx8M;eaQ#MJ~J$NP4hP3`S-#PPsm2*XeiZydQ4_LE=I>J
ztp!Q|NaylG{XX|CtM@Q_7f~6FN4FCTw^-{hF-T+DNFT%2*ZQ`m8!HS*5}({y9hMyZ
zam=)&#(wqz^hb6<am;I_5fmIn=fL>~(MYn0fa0rQh|CKHP<md!|4On8OA6ZFUUla)
ze0JP}m^NqXNZBxW>q|xJ#7ht6ey>KL>g1sNbm8Ddkb|c>te|;)p1tM!ohJJ4tWYjv
z=@51WH&JF%%3~x*{zeK<vk)e2xo=J)iPA}4ZL+PDof}!El1=JqK1`S_VMfo#d989k
zzvDc=S(HPD#r6%H^>*I3ZR=S%jrs9`TS3vB)F;$^im#*mCM=auc!;Nl=B?)ZJAyO)
zGID`cI%i$GW8&9Zu;^45#paLJSCejoFG3!*&i#0D_)Y;|vfWnlAgGr2*o+VRIxs{r
zFg3-yY4Sq9RwTY+=?jWR?z{ST982{uD0juH5zEdjiI`)}<&~Ak#KaL!1u-ToyJ|d#
zG4zu+VVUDV0>nGx-3sdEBcu{?*u7$T<L>ae+ebdejVLJ5(zI-B=snSt9ogO@Q1_)b
zUcx^>tzJ|<HWorSzleo=#I(b1UwU&E&{jq(f4ed7n|ypQe1(%HVAmb|a`v%}FW)cR
z8}^wGtxx&8Qy;35=TUSNYp8wFe8a+4w;Qyy@)=Tl5pf_nn0EW5#r^7qHoGR$MAi*1
z`N&M`#TZodaW+LnJ#82MXsh_EEx#Z2gflPg-iH|P$8h&V^_)8_K;&ao>+8%F0u>Jy
z47195+^@FtP2InV&gr{O8}Z`~T)j+~#A$P0+g^;z41o2;wrwt~`OIk-3x9=sbo1?M
zt?&xc93_NwuNXOHXoibM8mon>y`5RtaJxQZV<DwtGh7hJ{iP)Ky~;xEWOo!9XF-#w
ztAFBK2>aeb&E27&uKaw!Xb!RXg@|xs=<^S0`pbO+;@x$*k8(GDl&XJuhc;)gBiAHi
zYWMAWd(z&K8#3#P1I`Ptun1RS2u!kzC>LN7<Rk`g0A6Qx6p!dBo&txXa%91b{9%h_
zHqiJyr7PwFT2G9K8l+2$n^c6r639asUmDrJ^+>sRX4n-TxtE^!^}xzn!)~ykAls@y
zjmOI30T<=RKy0)8%Z#AJ84S7oiM4CeSF*X_u#AA=qi04+9_seZQR_GjDUX}2NvMi7
zJ2_q&UEa`e3>EH6KL^TBlRR+}+Y)@G>6rzvkByUplvSGOJ<gRRg6}>@wSQ|F$&PcM
zClWv_4ZSkjiFsjap~u{;!>F+7%&5@>_}la&J6+0cni}K{1g1srWZrc3z*eFodiz8p
zVMj5zUWre*Udt?Ppycfhh=xfF3ZPvX@i)ky!#S(o6;0ZR55LanSl~{sJo^S+(giZI
zKKRS69^3DvOfz1u3?@<aFM!qs&}A+{WM7^3DPjBe2obxQZnF#MGkA82kwAa_f*O7E
zFLPYk#@cLL&e3$)J7fS=nu1Kgjp)f#eU9xSCLWPL&}M`&pXFH;SK4t3z`33PVFEET
z>z&zkUf!B4^bJD?nIs0)gdR@<_Mc#h=lc!j?Lgc#NMatw0NV8&@5MbUhOvQMR%S0N
zdylzd%9ys*U)g2^kxB$V5Rt$bQOqLbN*HH{Fs3q<yM7xI?>+v$d%hx8{e@M{o*Jmo
znOVtQ5LjHzXO{<ypkn1Y(eCy^7;$*DW|d|?s&5?cEpMQ1i7c+0L~)GFYqqmV_?Lq+
zzcFs~@NdoIH#&)ndtVq1y6*psuST*<jH@jl#~;8;;`{9|p$P;|UBEHz)l{9z;7DXn
z*!JF9|ILc^f(76(LGwJ;BG?i~#Vz;xlz6X8{8#kyn3O}<l8E}-PSwO)bK?H!nIOl7
zi|grVM5gI;$p=)5U*F4V;={m~GSwplz6t`(;sl?$sM}8FW);JrVDe;R<JD}KHei)4
zIhRLG)dt&6IafVy_2e@uAwt)BBQ$sGCeU=VMB~Nx8ubwlRcOo={F_s$t!$AxK3g?e
zbnla`TJCNkkwa(ifs|b$Q|#r+P4X&A_mta?kcqXW=J1@Mzz#(_APo|9wwF12Md`V@
zy0*BvDyPoJfRw$oX5WKvmveV@kbB2Iq`@yu#Kow7u*VpBTuL7wv`bP#ar^Y+_?O_y
zuJ*x>=Y-{M_-`jmit;K?JhEBzE+4(SJ`HvDjaKtfcUL14Zerf=ci5MR^sK`t1960Z
zr^~muO0$4nJB=(gSY&lQ#9~{#e2X<|HLL(QQF?eUUJNws)~Z_<u1@jAY|Ptao95cC
z<8qLFe?*wi9fv!yFWHDf^?X1?{2QNLN>HRIJW{uRE<ocdqm@<hWzTN=Sk`5>P1G_f
zyB?Y|*{`6+{kMUa&jzx=MPD}st@-&W!ks)0Vodv`GGn^%dw|MZq2ZLfZ=-iD9a_$1
zau;kb)$<)?5*xTMm(0kscM?kl(-OC)<(<6Hsraas1OT0fqpQ$(xTEB(q5L(vovy6I
zStf!m=bhNQo0Z37pt}*et9?@Bwk0Ks_Ve}1L-ZFgE~mg1y5iSV88K}m^D&JF*6&3Q
ztOI3Te+7B&TLvfZWqwQRurQrMzKU{PEFcyJ9K#38Bc}euE%o;$nx`Hb8t+FE8+)N~
zH(&D^xt}_pc-XP{7`(ejeABQV5IQ#=aGtB=tQ6B+@p1EPN+Tuv%iwBePw{<Ma9Kh{
z@#guBY^R4Mw-X@(NaX9|fLU!mxMJ~?9j<EHPDNN!+lqL%)X_$?yY*R%+wFd(rn^v^
z;MN5L$WhJYtEh=DG~{rHcc35$Tp};O@p>%;z7oWWQnI0JSU3FsG!_L(xb?_;9ODUX
zi8(a~^vt>;(58b-{z?}U=f*?%d;M#CcB&tnBGXnWNL#eomD)!6Kwy?%G{IRlsgjd-
zx7BSHx~kZ77+M{JP4|t7Go1f+Z00=K-Az<)fUaZ4ssnq60e)28`ek`NnDTq`9Zh6L
z1A!GhQ+hW@u%wC{U0EiH?K6-j?|6kwk#_d9EM@yprEGQa`YY}mdOK>p2T8@fP6dU{
zD%V|1s@Ah2*v5}!xPp?sAFqIv1x7Hm*0&@a`kTtaEuav};*vK?k*)$JDz<q1USr?r
zR0q*y!r1z~_-fc#k0}(;IAeOc4_tgp6yi3S?;gyjgdLVYkc7r(yw7ND_7hPABfVIY
zYi%o+(*GDU>f`ACArRSc$X}bXY(O6HBH4jxX>n=@>21L-%bR)p$?)zM=<ayzwWf}V
zy!@i!gj=kG!bl(FrTg6Q*+YCJl`ejM>k#FhdXU?t2s%NkP8v>#U{HT8D_z?2y+ime
zG-m7cQ%5Ikcr|~&tv<v|NQd&E9JVC<RJ{b;*BGcp?%UM}*QqgJ&c+Rm74J}4Gw$5g
z$}Ha=xRT2*s#cM%f=(aUPBgu?ro1AtRS!1iXD;C={?hDWTYIw2o08&9H5`Ld^kpGI
z+$n$O?&9azuitoH3~t$A4SQU6poDRZdPomTGA}_}qc2R?PmRjsURH@hY)g_pa479M
zv6cuF9i`01ag{yq(Z>Z6@58Zw2JeXf3SRE0&Fv%>Q9t^U(LXca0GG$y7omy(6|8(;
zHxQl4kcdIS#~=JP`pd*)$uL#81?`6vH!EW|#0KnQ``q;vr+A|8ea6y_X4s69l<Ooi
z#lockz_DD3F{m%(-FOMOjpouJOW7=%U&V#JFPUqlGkO>sAN@K}$y(w+CXPZmbgJfF
z06l@Od=VKk_G&-4C2AasN*!wvv;JAvD7WXdm7S2{M9Q3k)$Y9}iHk?KmqyTVpQ(Cq
z&&_gKHD#&Di=LeL>^h*_)A{+VXIi$x5A!!J2hDFra~StqTREw`O7M;D&Mi13K3X>~
zj&PBNr--<AD=n0|o-g~_UZ9?AkK&6lTRU1l?p2tNL6-0ezkhHhlO=AqRNCS_da&mT
z8~rrG>oF!VO=Wf0IN)Y|?M)!-BZBVa(s)hvL%F@Sl^3>=#p?j`NjXl$ZN_#gQ0)|K
zu;@95otw?PrEoS<kUpX<F|0*WN-1p<&wkb`(|ut&U1KQ*;<`b(yRN#2LB!G7&KL)-
zb4S6>RB%Z&G3Qzu^fR2Uu@Z>xcE8nRU+%Pv0h8Gp>AzP>NqFqaPln>EaJn}i^{WwQ
zx&Fk}gLW@`hugS{o0b*8@H%>IcZPB782iBiEo>ut<=lalS#`zhEmP&H$)cmvV8_(j
zYCSKZI|}dZJZh>W+fqi7rDC=PU&0D5F*DpJJ|PfOWvVcUy@)tAHulwU5C&`SxQ5R2
zgtYKn43u0I#(~(N&!HZhb(_@#&in7ZM~GN)1;hfVC$k(f0;JoFN>)Epb+xzIs4Gxu
za+HY9_%!39P3~Dk)@B=WN2QAv;&~E%Pvq*OpC?QF1H%9+nQ}2{Ox8%q&h>iv+a}Z4
z&TIrtjfE1@{>597adzS3MR0YZQNgrSt0YXo<;`RE1`F6!6=VJp+1SF+#7&s(`iEvg
zl7n}T!|rliU*d<?ek@F%rARk^g5+w<yjQ2|GA)2=zPy>(qoFALc{ysnqaEKRs|PRu
zotE?59nE-E<0UVzm4AxeS7Q@<^L0qV)bemprSofB^8CZDG|VpF;j0~GRl3?3UkbvK
zjYib|Uo-c;dxpCv3o&fV-HFF)mm_4yS_DI>H@uUn(3Y_mpDV}nF)Ndb-W2450Aney
zbq)w~#ny6$C$CU?<_ObdjI0cVtN>B^Inr(D&uAzlL5J7HJN;@e|Cn5$JVG~GXA3$$
zw7Q@}jN%@b5xlvUm2HSTAnN#e*)<1lj1o(?U^~YDs+ZG|J6r_Tb@p`UW^n9F-Xn3%
z?o;iZV}gawehp>55e>)}eGY}DS4kviPBlP9<)jgFKf}o|@Cr|kIXmj4Zkr>!1c*KH
z^RBpKfA|t3Q!*F%;tP_LlpcOm{=oz^JoLCKGbuX1=_IpJud_4AFuxV~;@F7l=~%QE
z9*`(+1+z3&vWp7^3d}g~NPMO<H<u1x(n)lNE35KF--@8C^><h*?&#6MAzPu``4;PL
zu6ACN4$2<Vmm-mGf}yrU;mTa`XWZWe%IBgS&-}agYr+>!SZ?80=7L@+!%Bc5YnHc0
zn0H_-E{cMPQwJjP5U`_XGL^#vte8PmZuhef>|{6Z`000ZIa!WiMADertNq_?dXJ$?
z(9vYAdW#Lqr@uTO4dHZsG8-3~^W`Hd9YL2va{YE9Pn^2%J0|)X>=XOW{uvRML1++p
z4sz5a+eU@O5L<~}Gnt55gYkeQ8Gt?*Y%^QC6l;I&9acinnJMTW;8|z7^3@q!=OZ>*
zzVIF^&2{P9=!zg^mcMdA?M8YcI9=Esy+E~#u5Xr$<+Y(=dzZ93cDPb6U#pH#Z&PCM
zc=gjfi*Pt6w*ZQe&{q9pCnAd><EPw$(F$cDg9Pa@F>+1M6pTFQ&y`eV`S8{r`8vhN
z?yoc)rR`$oea@qiQT)2LN~SoR^e(S}y&>H!NmbTq8Q#Oudh2;gy_N!Z@9pcCOitY0
zr5GwtOG$~CGhl7;k(YlBV847dVG0EKP=E2JbcjBG!9RR(jeqw9P6mCdE<JZb_jy<0
zY);UW@!@F1USMRC_k<^G9cRE{(?2&Ez}OPB8o|=-j$GIlO-#K}fAv#d%x<ce(HlG5
zEQT417aT7z?m|&#lsF@hQ_bN~0{Jr&tU{mXRq3AU7i>AuZcE%WL4j)IzPxR>O#0k8
zzVOSqZT2&k&od(;neOOmQ<Tz`H^Fa5ND8LL`jhAt%VQpOKyQlgeyuJ$YEnRw6jq$#
zV-~Yq*SfdW=gxi-<!yX^bugZyp>!+b6sNZdeI7@7_L{0EeZOWf3hH=}qNXE^Ewe=>
zqJZm!CT9U}=d5hf*znMp<V$eJ{E^u*?=^&OOb_SdqA-kUZSlZ${kZWcVam#1+*EcY
zqgLRj$GcuMPFk_pXVM}2H>1Aa!GqfCY~YsD!o8WOuz=kFM?6=^Qhz{wY^=3U^PJKZ
z5T(N?aCGIU^}OyA6-JIpi8nf~9a$7kX%&FdO?d9xIoYLr|9DXUp|K~EB9F0iadp3D
zJyU|07h1o__pt6>gT{%8uHHn~W7n$l4fda7K3N?>@7Br^y&qK>CHgiS6WMX5>>Ks%
z@aFl=tw06$cW;QXQ=`J8R!^nAKex@pvWxU%S5q3H>Q~oa;x;YggQm*}2d-SEZP$C5
z&lxnNHcXWUfQ1@WJbV)8?`k|9^t=z$cDt|J;Mvup)?W;N>EOJy4a^;i2`Mj|Q_qi<
zIND^(Hj5^#36X({EOed=)w(MX4N*qu*e2f*+4i7rz~BTQOjgxj>Eu`}=NBJsX!1V2
za-?65)?<oG33@Y8>wS1*Yz2kqUH;5vID5clW=6L)$Gf}Wgv7j;@{?Kh(z?IzdGLi~
z-;3)?amj{+1fq}*a&yzy<tQ5EC2LQ{wDZ_ze5)Q6ET2L4nbkg-^A22KaB5)ep$v7a
z5_iOhxK*WN$wal>T{2lXansVSV@6vWMVskI%U^k6qj8xA==O>~L*C18g?;}>ZJJSW
z#ra2l&nqJKQxB8MOU&(O38P<(?h~++&cZHilD>OGTd0RSxpss5ol#zSi(_T%8<jLQ
zqR}2G#I5zCq~V?|5fPA9AWyU&*~ordLczDc>VGo_Jp+(hMZ+5FvSbs){=_Id=<Ns+
zOLuG&rB?Ez=SI=tdlFZ)u2^d|a!>LoF5!nTnCWbfZ{#xK(&~kgEnV_ySzv4|-5b8*
zdn1;PL-K8tOK`BqMjsk`4AEU$OfDH2b>)a%M<>@QCq%M%z@d;G<4g=RC~1D<E4cZJ
zSbJ^+x||7wNb!CWJG|a7X`FwG_dyP(FXt}Lx7OsYjI@0k6UbfXS>vi)gstVBmeohu
z-~b+z%6wcOe)7qo=F$BsxeWVXFav_33G%yLgP<jxm%JGGS}-P(w-N@aPd*e>jB~tR
z-HZ6tpODZrNY9iTn#8B_y~W0P&6#ZJCjWsuJs?fK?`n5r+`$!jg4U_$v_|d~_lw#2
zx|$A>KIZJCnh83Nf|OMCFkNI+I|^^ra@|YAqjO|pb5!Kog&8A+pML!12;|@cWe^1@
zWlu1&_c8XmpH?j!mfYJ?j7eF3BLJ(oIxZod73JJ#t{w3O@&Zkg$<H>%T5u&q%q3jX
z<(-ZL-djuG!3g?4Fvp~n`Nbby18UCoqix1PCmraT1f2s>i|fQ%bhR97|C9<!X*so=
z&9zVcu9W0~)>;cV)2qgXhCIaQt<CMM{Ve%983dR8<#)66O{Kz*LL@hlC+@{(hrPl<
zKg(I9j2iMt_Pq{_j~D#SdU-~LA4$)o>@iy`ei+LxJnE+?%(XETq6}M78?VNS$Y;$i
z6nRZQmUIEJUP~G^we&wp&TMO%$I|!`Kd04Q+a%xB?dCj=N1^)eI<HSbJlwa{6St1l
zzl%T*xqQg!vLywIlKW99tFB9LNzPS@_${rPPjVq^v#oC1VfJqfy*9b+`48vX;{!iU
z#k&TZTTUu)n7B-KHe6|zlk0da7A&Wz(Jx}P8b2@9q|w<=5$iw0gzb@2b%hI68f>-p
zap-vEukUsgiruknbBYJgCd=jCZm-lkb)c=To}ba!P_c0seTZ0tJfKqLdNmmpd+)go
z2Ve73fd%nba|vP9<I1b%`H;I+W(_U|q$PpVZaOTfkGRymf`JNZbD<t1ckfRvI-9w@
zn2AX@_)U)*?M&i#z=o=jE_@&{cTdW%f$>Vz<yH)j8iU#(5tB5;*X1iU*$}dObTWL0
zc2N61_po>=thraF{bP*1J}!Ql@0nV9ldLcQ7K-`OlP!u9_ggg4g#w93Q95~n4Jq=-
zi8e<qE02x$dtZ8F7#xTiq>5OJfy}wC9&v6vcbx<n)eZ>7IIpyHX&!rV=?d~5yB}Y(
z%k=*W$M)`l?4N11G>0^##1Rk&JPF}9X_%uC@g<YR(k>6df!&aKzK919IK``s*e8!o
z<<>_R4m}nw>@&@~{kehCJVvu&@>%JN?zpt-`&mz8x4CWvKg*Kp*GZ&jOg+TfL*Bai
zb-41?>9E=KEk6Vl)rk>RCIBQr)ObSXNoOZTWPh<wTnYNj9TX$u@m~kV<iQW7O3!|^
zM?>ZxpL(Z^9b1ZyUf684wsuyRT3{W-?TGM)t-8o_2lPeXK2%G>@GCmISJFtvy~&*7
z64_1fOdUV3pZ~m<ahK!<bzA&|zU0fA*>d~nP;#r2)os@#ixT(K50QmfE(4gVtKtka
zShK!aY^fyTI3I|kA;*rE%?%POPN%{rLLG-OqEu`7lq5Hym#)stnWPO=$vqVu>FF>`
z#gOFZNg^}3J%_AdsKmS#cVUxK5AMaUi25&kENQQ5<3sYWq=piHrR?(%c6+6-(z+k>
zJVh7CUZrnce&chh&HS5vr-GH_c)m<gvJ_p{Pu&s7Wb9Yj5AMVW)T|hm$itEVJlGB_
zE$l@gwQ2ctEA|osQrdM%W88RK|I5!@lpKczG&8E?RJQ?Xc)tNh;A2yvXH^OAJ`c4v
zgnA389H^%KvnM#H-_d59gtGj^qu=XpWp0ZQ6$M!<bKo`CYHrZ2KsX?IBbNj*2~E?v
zn50B$o8M70Gdzrnds3zndxyStfs3%~I-(4bxo$&nc7ocpiywY|`v!GH1so7#%kKZ3
zOswLtgtk;GI3Xc(yU|*+cc{NVgo@a<SD^#hjHJr{d4G3yp>b#6@*dN2g$7E#su#5$
zVfnDo%U8oM+cpqjpA?eH2(VAb+j*U;Tv(6Rm=yr&i8|kbK{RR79?5{EAFPnY`Wf=(
zG&jUO+lztQ{YmgMbh$VA#JoEUrRcwRv=@xbVz^L$D%N>N@n?5gxWB>)eOZq8xDu~y
z1=u2I0~93=5U9Eud+>*ayvG2duElBt!^eFItIUA>u2H9Th5Z8w!jMUe@~%UsKmzRH
zVPE_@AcdH$nb_zd)RDw#-Uqq7Wrpw|Iz6b=f~)F9Faa9}AIl?Hi#{X!Ps^D)Mr6W)
zYu0TF?%>#jV5AE_?aYW5taL9V&EwZ1dV<~wbmWqDPIypi+VdPbF~T+dFN{d6rbDO@
zV@IXE%~mQI6tc(d3bB#v;|9w91w=GlPHYnqu%Ny(2)J_q!~DaBv1QW^=Er@J2y>K?
z<#~GEb2{;?&pUrG(eHK;zeYpNp_;3?oT$|Ggfb!4QqYk<ycvLZS9x}0R{FS3PIe{w
zS<mRJUuaL~-r>30hylRDdQA2I)()EV)3BsiI7h<I5bt{AC2BjF&c)Jt+f9D6B8ydp
zy&W#$VEts-rCP$#!q#m;G9WQNm|Ts`>i6;FuU|+^UxOcDxcfe7zpc}~NU;dMb47jj
z4{UUIIdzLRjd6WP%sQ?Z%}JVn&fzyz(5x{(G|iL0WZLWb&Hk1s8m8T}<LS;MHR}{F
zcGs@6GP3^a2=S_u<>+OJ!QBm&Hc1@{fa)T%W_*^ty?Rr4c6EO|-9cVA;9s9-aO)+8
z(y2j=FViwuMBWnjd)JY#`A!FfOYF(4g<buBQS4)YqD#%A0ZNveQ`N)^7vlb?pQVX-
zhy&SQ4I^=12op?)<teYV{>%H1CH=F$@VSfq{aFCL=EZx+A4rn_Y@t(*1@v#<^a}j{
z`_MA}@%m85_iQQBVBq40KYvnb)HF5Y$Cjl~M;~;d({?g{b=gBt=<DPGF01*+50X33
z>nO_akAaIj{_$1d1-k5Cp8$DYe|?2VxeXO~{*q^JwhjkqC$i<Aa{%apj`CS4h0D+6
z0qe$aMioD3;Eq!-#N+|v_Nn6EX2(il&%%Re-y1anpo`w6#Xgs9Hu??g^XD@`55o!Z
z><wN59?an54aj4Br~6y(ilnqY&wuBJ{@J1YQqH}IB!b;@Zyo^b<G}Ti%CBew{z~H~
zN5&<u>0IEVUZ>Y$g^q@(%1jADOA`y7*HuFO!hz?HfZ_kObU_$c5Job5y?(4wPF`9)
zR&@DgsE4{~B6`i!k5`$H!n<3(&e!Y{v0qeg!;+NK4Q`)h+JUjN+u`$pjyH61WhIm+
ztCZc-pT``6=0nhW68Rv41nhq`A4tHZeDk)RpDQ9aG;tH{jpeN?)=5Out0G2qp(o@c
zNzUTfcJ4&JjBK;y%KhDbg&T)@r@UjaXVYNioma-?iQ(nTSx)^BV$BMNS7JS<ShK`8
zB;26NxC&ErqjKX1w4dz_7EU;oe-T7A|HzbKw17=+TJ1LESg*4ef2%0(Aqc-Js~JLl
z1C0+b6U!L>kajaDB1)u^zm^SGc}{al`!APMpcCIlBz@X~($PjFtv`fr2a1LS;|Sq~
zwYfIMazhwh^iT?pEtR~*Wa-W5A5G#<u_rS=Kr>a5Y1*FeHh2b9FMnW$E;c`6!G%b|
zg1vd1XLSu~v5%9Z3b&#i8Lv-e4sQsL?cJ=k8jm;9tvGZ5z%Nvp#E<q(ltm>4@l}{&
z`DT7xpmEbTKR!oQ{*8i<H6J^WqH}miDmksZ8hBsFByMlcFYJ1QvEiM`y~bef;xXX{
z#S_7z9E>W9UT$a87d_*G`E!6iirCpPt8K>w=IY0#2w@O6QgL{kb<srPvH!G4$?*-q
zLq#i(j$Wyw)osD%OL$C<A5g!_USU9V=Ez7<KBxxjZ%(KxDOgJnLkicWs!!IhZBT4q
z1Fj`e<CC5*Umw1DJr%%sZ6jDu_%B41zo${rrFh2g<uI}Xj$Jg>a=(^**JwvlODfzK
ztfE(crVK@UY}gEvF68Uc(SYn-IPQfYJ&`PVO_dpL!4^c<bg6W{A|I@q{8~<>r%Llf
z!+p^v;rVo5qU56ODySLQCNQYg|HAxg8KW5WP%geu%mBRwJo?ltg-+ezOotW6b*mqb
zM7`v1LaABLG7UlgIsN1-=|{}jNP_acHP-3tF0nTkd*TKlMa&n3M7BsF!Uu|oyB)GA
zWty7G*o#-ue4z1^ry|11STEcX+Q8&i8q7yE6(;I016iUL))RL^<aKk*>^cth+tth9
zeAH$5gurqJmpNi|h0D$Dm20a0T~txgke-GT!YJ5*(#-7OYQrd>xO$o!?n+}UE2-Qf
zSqT97!&PtH0ncm0Ib-L@FLCHRN0+lnc!!}fkxr-5VYz&`eyPl4dRJ-StHhY(p3pKM
zLyG@^V@*iJ@P%rkhc^-bHgCi1$d^zqsH5Yf%y)5Ye3sz(g7lRdf?HuCg$d@HSrkI4
z?N^&bzKI`gd<YM)ZZp>*8l92EXv@0V^&e1g3pa#qq&^hkD$p_e<?R>T>`YIT?iZLg
zC%cKM`QThI3YHIdgc>6Mi;`wFSPcM^#*7ROWI%}MwrhuRdy_EY>?NQr%%m%dXJN>0
zjT(ec-HvriBr^RC@(qaCQdCPiM(p?{lhy+&j!HaFAu%%pox~SQHFDuqc^Y?nmgIKe
zjdw68JnZyYfY;IGF3a^iltYruwd=a-OtVXJ2C%89ZH4M8SqdfI(T`PPznb%w!M*K#
zn(pwc^U3!2myV+Rn;W@c=mLtXLy;B@WOte6`EF;wqd>WtPOCW-B8D9|hr7t(w!5su
zP5SU(ZmY?&H>n5n3UJk?)0E~fa>!G7q)$sn<QGJQH##;>!Rj^?&luCeaPr`HE#!4)
zhS9GXAQvL14kJ&bc%5$?@}{jLT!B=><vQ@_m}!@4H+TiQ5%z2K?5!6SAIIG&8wj$|
z?0*E*zPr3epF0)l7i~a(;zJfgdPgZ+Ts_uDs+MCdPl-7fyY50BBN%~|g%t6Mg+~R_
zr5Y>PTo$lsU-(1ysQv@PyoRlyA_<BR#C3Ogtg{qV6Szu9!XpjrIg1*dE$}azoq?Ly
zs01}IMCGfXttpeo13h6Ii=CTgmX{ob9RX<DM`4ubIU~mMouq@eZ}QskCmNSq!K3fx
zOL`sHb&w!3s_%OVTRRoaIb24r&_@=ukf(xDuXo(>L~zOzabBzm5YY}(LxGDPq%=v{
zK_y3>1N_(nFG-hWA>hEEo7<nA;e|b6Y=Y^?;Y?7v9=V3)edluIf7=<3ETajTwcQ~L
z2{JN!qY!4$xc4E&UGT$%K4tM>&O5KLvvO9*+UW+5*OIw3qxsvN(#3~504~?3GY?qv
z{In%y;xU<W!W8v492L66n`ABQ=9IqXmz8luHIEX+eTatk-LYHu8*@tRLQ+gRs+W1}
z!XgfNKqZCcYc8RjFET(sml<n?_kthbH${s00avQjzhW+!OMi%x-Z@x9!0~T`eV|@~
z%2Yz!jRTE$C;QUkg_P8hXp{A_v){>#^A5W_xTht&v+v!?X}GgEQ5JK#0D781(LpY&
z##;D#gCS<SD>Oc;N@=0Hbi0WaC?W~TU1-a#QKZ+tt&6W63;I}UZNemi{v)e2@H>zT
zXTFi|75lc<h$<TERu(AtaxOyMe)m{{%JCFPc~L2=Pm;l&?jw2DB2OBCMgYaDb7ud%
z;L~WLdvx-n-LX`6vZ1QNz$)2wi;iQ8EO$pAw*3Y1Hf+WU_`~aUhgmkV3Gdk48QHvy
zy!F(dZfOP{k1Vq*I}u`KoBF7$l7>Ej0Wp7O34H&fyUi^6Ku!1NB@v0&9_dXTXnH@%
z&*xyVS<~39e4IG<z@|y(EzUvGCEg~y_Iaz0?cFx}8o7r(Y`^i~kpU{&qX%Dm!mqp!
z19tJxzc?|51iJvRM0v{*zDs#_$5U6)Y^rl76tJ0G8I)oc*vpdDjh6F(1E2&=p{#xt
zO<BZ3U|46&_WFA^hh+Pgm7xm@69Z#HIc@0T^!I}Rume4hw3PAI7IeAsu>K>YE5y_>
z<n&qrW?Du>4?v%+eXs~z`{>w189XVF>*Fm&{T{1aP1q=x`a3<AEeHC^<?1nWD|e2W
z9;8f7y$rbG&th{SEwL*@8146r*Q;$g0SXAg7q~g#B4<<SxKqZTrkKsj+75!2PD$q~
z-kdDxWq;Kn^RioM*7O~O(*=lQtde-!J^9)KP=d?{@wR?snHu^*k}%}3nUiEcDeV!q
zc1t!2ab+)wfGtHbm!ZcH{Q+Qsq7gkn6zrl+!4sZTWl8Baa9!2ovNLIsHXTlp_RM2_
z)!2A~t0G%&lH-xZiYW#ns5Ir>NE%!Bc2zz9@#OIrx1_-i-{q)F#>aT`NC8vb>uK6?
zz|Brz<lr|SN-ct$3oBZJdoDE7&t7Dhc5P%*`pubkk&aw_G)4*shv6(zu^&DB9M{V6
zarBcP6z7}l6f<S{XshD0ue`FiFUy;<5Hxz{z1~f-<&Dev1MlMUiQ^q`aoVQwBQCcS
z4U>jR62pZ#P-)<r-m%U~cl(ils_rA|FQW%Rqo<_a|6m*0`B{J%sy-)R-V-BBd+#Ql
zZKY2Ovj7`W&9k2}embxLR^X&rbEfsxK7b@1_5Arf4qyp$AmxFf$!K*@OhP6vO5!uq
zU9qLfM`}v#8hgJ8<z?xT;mxB^=7@Bng%$PBl?@`->BL>a6sbS187JLUD1z@F%hiG>
zoe63Ai|D*m+A2&Zz59s!R;Ymst9FsBNiOd7hxA`@Dhe8X$ciipe3&Yc7v<i3xXry3
zLr?l$;yNWC*O&!c+nu({p@G@ql|EB4um7d!$(TLK(LlENOL4&zeIC0F^%QaFGMhI?
z&x*(VZp@EHk~sK}HHu5lD4-am%k#nQeL-rfLRQd8P?XH2BvjMBqnpl~_tLIZ{TF-w
z4FJAHVvq&g6zRPLNY#Uz<3zaP9`Mq0b>yBDf+#6CaK&)K8}*XdS9CmG;ej<%;c4d#
zpy9!8C$k9~w&iTKbyGF}8|l*z^5V5b60JW`^Gl+RN0!T_&7kDgIh{IaCfvg5D^GQs
z*lhC5<~^g`igluQZhs<$3$~ou_Nf6->C6_QVU@H=qqoOf=XM<iCyf)jITPQSaTdZH
zk37kZC@EVF1D>QrebneuRj-c_aagLz%#g0Y=fjTMzJM8XKah(3PUQW4){=$i$-a?X
z)P0D|2^kUYGE2C@ipemEh`~rM=Zr_=n~*=L@r^udRlQ^rgFNCS2*POJ{&#ZZf=7WG
zS8ucvPqR<HnMX!NVt|H;0h0JOn};?pkCu!SpgGh4UnnD$fT5pSlD)4}tBnZRm!b|$
zR(0#M#2N85ei%PztTKRcfv)$UIm>j<0`VuWewcRot0%jqVlFTR?=EjZSD67wM#J;<
zNuI==W=z&%b_KnV7j+^7gh~{XPaZowY-JW&<RD59462G%&kOCzt}$Q;KDvAxLu7)3
z4PCTP!XpD#qUr=%uJ1NKhiS<qTYWe0`E?bAfPEhS5a-+d`E!O4h>Y<xIFFlv-4CCi
zXe(mW*D7e+h;@&;E4&4mJ;40z5C6y2ZkH(`U?G4yu6TZlD<)`QMrL0qdyv(M-lqeE
zV3`ZDr5x~uM^r0!{1O2GkVL;CH^RB8r5AJ78Q*W2yqcCOE3s+2C85h=_wVjeEJmq0
zviySs@dQmw<61}nbzZoiG<K^2ECnzoq|0W$?-FY6zXh^J?iQ2hWZoRO=+(YF4?Kzk
zC@CiN3UEW9)Dt5)Ae7L&-0ZfNal5&&p!M~WdxLta^0U#ka{5<Ku4_76p_<fLvit4V
zyws4v<x;S49<pLk;7XXKMQng|y5S|iZPLP>uoN`Nj-`*81=Pg6Nd5j{6HEac7)1qC
z-k1gSfZ3X3j5zmh5`6;D2oeB8WP?Xj0JZw)a)b3CX{N(7|ExFbelS9(a8vIm5de^x
zVA?k6`$X)cskf`AWeGp7Vj&r~-?pst$s8wO3MJ`TF*=GOt*%`T3l>(mX{Nf!l?J*(
zM5gp3ZF<t7ZR#a%YTqR8p}4IiAVd*CAN3L>RmA$q-jxy-d*)aB0-Z=gbGZF{$}vwy
zwC34sLI6pPlX!^PTt{kXEI!8$h`1C~(m%{!jDQ495m=<kr$1W=B0$z%qXB6Z??&|~
z>fO3*!90>>*nj5}Kr0|bARCO9j+lMqtv<UpT+#9_vI%H6ivrM&L2yMtBL1g7(EyRK
zKW74=qGA4>pa=>3t#tlv$w}RTZAx4S(7_nLH}9;1Klbq%df!JR9*8Z>t6oR5WV%;A
zvaR8`=+N~!4MOGs9rQi`5`={Re{J{}&EP(zo>BLM<@qDrN&fiQG1tYKtU8)`xelNf
z*8lgk5Sq{bZ>j@9r2iyXS#faw+?@n~H(Cyjin#r5-TMJH0bYt7S-j6id^Ql`X_igI
z?hXTw)iKc}*5Ymu_}bH9U(x8WfaG~zKqVhw|5h!)t_bL%^yhY7@d#c0AGzU={R|r*
zUpvqt(tqa5AW+G)QquRd!|On-&<2hq3&xejrj~koNn37K|4IB@jvY_H8-}1K!y<4X
zX+!D?ha+7-w0|!k-iPS*KS~2VVpm`WnD6g92HLsjnrRGRx-k9TNr6qHUy>C>k*BEA
z1RG&3aDRF9SYk)$_$ZcKqKhbhoD%3U73lFk!unwPFDwJd++Q;I-+E>23SVFCX|7Zc
zPXdx8dOB%j6;F!XmR_H_hgBVx%$eieKD~|9LjMK0um1Pt1VrzzjqwPfejJb1j4T(M
zdp9o;24{GZKRIG|*z`;rJzeVndJQ8ymOeemR+)&OJd4dq(qAeq5{WG=$%*$gN2iLL
z3UkB4&`gvR_=AUnkSGxIMturB3i;8IG0EY+PI`Ptu90>9-twKdti(NX-GxDsgQwNv
zLUE4-h>$%1qlfMfqsPhnbO$5F61W?<$QNgOA!NSrlyiT)&+J1oVEkaN-ECCc+T7TQ
zK_^}BZi2^krs=Y(8pb@cZ|ja7eG|A(72w*Ztr;m+VR3Lep`a}z%ai6PxZ(}(LWEoS
ziO35lz*yv?q04##XccCOeH%c>%ssXLbc7{Vf2d#LmR=}MP&036$*jX=I%`q)F@?}l
z40qmK7oqczfCUspurKZ#NLL}r&6nr&zPb!Oo82V2I~c*nOX2+p`#sV}BC_QcVYIc@
z1?|mZ{5EmNAKlC4`(mkO;{IZ=gh>Uk-%L+DP2PD274?Lt|5mom0sqQnf0!s$U7I6g
zlB1?FJQ_E!<Dy<giKx47@i6j18+yjWlfkO7{twe|Zw#|vX|UG2rgu7Vf3WsH#>oO<
z^tp05E_aRW|9X2fRM}nFd&LYKJ<cgbfFa;-o@NM~Ujwuc+PisneL(+xXSP-aj4;r3
zQt`N1ek8mvFR!>MC9E9LL>P{XI~XUeb@y89V83kzz^I&ZebrB}1UD)D2^$jV7dTmL
zw}3A5Y25JcQY{eW7h`qH9<Q=B2%dQ3TLO-jM!rd=m&#qR#m<iQ3!U_TB`FI;#)qZ)
zR#TSB<%L?FFkPd|%eQ~rVutYdQjH$3lb(s`QR$Vu!a+7)xROq0D~NS==M-;xVT*w#
zGbC^;dtyezz4iEvLdfs5<2r?n55a#teNq0H`0_%o`{^%BdjIJqCR2xWz3=U?{HOa0
znGgk<^Q02Y+AHO^mYEt_>)0qK|FVgHBau$==y7Xa2;X%|Vh*9k7h6hg&Z6sCwIVvi
z{)3h<^L_|$bH4#L?SD9X@kD_X)I%=NQLNyOu2Wjb4$_IcV5>VvW)Z204RIX4=DHCk
z_%k}m!k_a8eB1XmsHy&P`NVz$tT%sGXwF~;gm3Aqs}8G~>Z;kI<hYA8mtJHP$_V|0
zac<6UA;(7U=E2ORr$GOWFoJMqqKUJBIL?2VGVYcg*gt2jiFZY7l&g6j=+06R?6&24
z7kpP4f>49$O_`4+-_Z>G&8x^z{|O9T1abo0!<-H^1LyWNDE4G+Uo^c{JsLJm_$7Uc
zbM1C7B}qo_PadNU-27X7;g62#K!Y8AQ98)sXfo`RlE1z>Yg9D}*M<B1NiKv7bM*e-
zXyt{Vl}bsk!Hbg;s`~uA{F{!CJKM`^3#Uqiq=*dyIGk+>ir%~&=W~S}C8KJ4ZWHgS
z>F_fK#!3R>_)nVuZpW|$+&fVJ{$_{RWHd(x+ytZHA~Vq@Ku9bt5&Opa(%RARgD$Q1
z?=E8wW~P#;tiVeBlLOjNy26otyA*wXZ-!8CSmt}?{e$4!o2#p2Tlh*C+Gu}ww}bnJ
z{nH9!!F*wpbyhQ4AXo0*U+xR}!xvD99}rBj0V>zLuW=b~%MKp)ISJ1OhD#NjY!aC<
zN}@J&|9h7JNvfALfNV}_lOL5b;Oe&$cvYH@Yb;5LIQ4>V!gS@sW&+J3h)gDKrB}%~
zLGc@(sv@KtA~QP3Q^~oMoIj$u7y!d~@SlbOBpvoJ*T|$cKr0xTII`X+D|VO+pt185
z*`(&vLf4R_$$=`LdA5o4#?J=xVM|zfQ>(GB0Ax(W9R7?u{a#gI$T?A8SU~Z-1yxPW
zb=ggcr-4V(do}G#-%x4&{(U(C?vN%I$3m{P)*{dx&;FKdBdHw@M6LL&!xdo;EIfcw
zKEs|rqaF&XIx%MrQr)ctxc1)P*ncqq(uD{m%^b3ThKD_f^4GfCLqlM*!Mbj>)pPbF
zej&cI?{!C#`32}?MX$+KFBw2yoe|)MCMQ8M1a%)E{pBfVI0tx|CL+>drTasEcTIE?
zHJ}y1K*K=gqBa>uM#uyGXf#gFJDYO~c7TMjH2!~|dn5t7qrYwmk{;k*0kBU`I-Cw=
z?rt|F7A>qrok*NoVs9Jo?p-&*FtJB2BrgwcNe+)?4eG-oK~jFWk`Kb3<Faqm*~zV1
zm6Ik9Nd>b!OYraA#{a_m?o_>lZc6TV6iWWZisD<gvuJV)Ft$oY@woB>zXYWe^i~|J
zq5aX^q>pH{L4M!x*%9K3CtcBljwU;Ac*doir8rgcg0#vqQuE0lGJqVSWHEx?%56E+
z<g%CeQGw<g6%Za0Lz-8A1#+j`Ov*Vk$5kW-81NFYKT8v_n`8x{F@`1o$&Ru9p-Yf_
z8~uE9JXHH=Ldj672X;puXak~bM^-=K${IltXcN<hL67lh5MTdi#PC49guoiHbRGan
zy}AodlW1GK$hrrZGz^x__W@yVAo?%QqpCw8ZG0NdO;L>b!b3=M_vizW@PM@;0kq=p
zpiHL-0Xs5afdE6911?4qCp7*s_AMJ=I0i66{~&^czn`1W2D45hW^qD8#9pM&TVj$L
zAP7rW+^pqM{Rvz-gpTuHTJ40$(A}((DPQMFT*BeW_erWYc{Cl9u+V7p9s~BN|37b3
zZ<2y)Rv?D8*;a}e+%hGgm?Hlq9OAzue=J}$(m+Rnk8=<)#s7yNQgtc{=OjnAy}!K~
zT`+z0YA~lmzV9VJ{U7=f4G~`bO(z(3mttEmz}z_~bwED&4$srb!uOxKPY8Pn8k<J3
zC)(MvXWIqMl>X3)|8a?d>Rv!<0*ls=b|pknj6(y%g&rOrciW_X9}7&z&q?Ae$4YU<
zmV20hHW3Vf;Q}jlhuGr&!%8i_EaAxdjv+ze@MKu$1nJ~Mh3G<;;!*nWq^y!vF;-Bs
zB!b)q7zoY%2Tspp$xv4o5IR4C#A4?(pv!NiPx|bj@uDahFXQOKGYtOt0^r*lFE8iT
zq>M9cWJ8GC_X(*We`%}L%Ri{V`bIF6aMYFAmu`Z$+)xC;?T9x#*X3SAD=inF=bKB)
zo6x-K3TIOUJnG@@LcqGNlHvbhMj=etj>@GDoTQIoM0|L7gOvk?y~Y4^MBUoLQrCz+
zS+X6mkN*TSh&*|^8f>P922*X{|JB}__8g5?I`UeV`zy+up|4syfaT>xw-s1f5Ey$c
z`|b`iG2I9%dG4)XMQ7}5crL7mkFdNVLa<p66qgpym%G~G3RW&&$5DW&=kYvFg{&O`
zSZy={n#qy{9|{sBM-ZG?h78yMp@P>}2kpnj&pdmgwBGVRYKZu{>0G^D!yAL@S@~ut
z(NHT<jImRs>LWj)QHmd)WGIO{iNdJZbE_F;OM1YCjqRk+J0bP%ZX9q;e?%RqF)us0
zQPoD6gLR9eazSf)TGK5kWI_a~6xhhJ@=NVsz`DFePrhFB;6xB{Iu5NGxs6&t<0FMK
z@<X(>p1C<uZ>O`}%HzdAWS-`wej<(}{W7kxV(x3Wed1#f80#<hDJ)4Moocr_Sjum!
zV-w|FZdbTL7BJ$^aDly`C`~=U!n%H8`ze*Sp6elF;A7q+i{?$LPtQsVs)>@VutFLb
zR<~)t`aY6e-H2!?)z`n9b#G|xOSvS_FqQUpM4yE}r*EwrYC2X$jFz_J3s@)_FGyto
zNmHi3$+C4h>!BwW5qk>M$?ajQ3{cut=-gM%9{$6sKJ7=BLOUw+4}l&y6+bY}7vC_E
zyQ$dk%kZ3l<9hB9H76(cih&~2F|!~+=K-Uw%Fl#>!R-QpNDbUy5;f)^z%lDs`eC*>
z>9@N-MhtY)*0+NO=twru+)ljGG|bF&?rfC%eC~VpH-h_G#rW3_1a#1x<OW4DktGPT
z3P*dVLUgYfn5r6|9dxlQ+h4zfCWXox3oJD5Z_kM2HLyj;E+W)$4&7JZw^+aZT)&Ob
zAe?fD+1--Rd5*8|39<P-pZWTsMIjInjV=~-n2PAEL5Z5d&(|*aU=JUYyvTW_yKbyT
zE-7yh&{`VdDC|Oqp#VzPA0MH4!#8h>p8esA5o_ZBNyFQ$NG1J|fgUabjn0?k%QUy8
zTa=CL62UN|m<R@3Oyu>2?+`~p0O&sm@F&pu1AaLcP^bhjaJ+N`n`%qL)k+a(-EhJ^
zG#BXD8%g?OFS9AWBk|rVN%@M$?;%}G+!Xo27MQr~=151K!cD}01a<<d_<wB+a^kJ6
zG;?kK6Xo{^*S2wxnU-v+@Nr0Z2~ydIcM6>y>$xREk^i@*fYBkGp4M)J?DNhF)i6j`
zkws|XM!0U?v<kri8_3$MjII;ZY9mhAu=_$_=Vxu*B<m&`J^VfFsRRaX-XgGd{Lh30
z=!rNwU;$LzE72J}`q|<?&vr8k|M}T%yDka1CDhm>bb5tFClE#lYMNZ4krOSkf(y@Y
z=YeVS>=CV#aDlpGbO8AdC)A7u_Cf|hgz_s4-OmCfCI@hW&H#TTfL(7IV7O$p&4+cv
zo#jFx;Nl<j6jzAbLwAuLK@3bN82W0bVcEwMV_V$g|FHJu@ldvH|4PcfFGUC;CRDcU
zZI&joHpaeF_AJRR*&-x{BujP~jD06#Um~((&%TT$WFP#_q5FRB_j#ZDe&6@=`TbFR
zYUaGo^Ei+5IKJQSaa`A>qpX`TUrfY?OSu1R>A#o<!sRR%!#az@+PSeKBm#`!DK!9!
zf;4y!h$}$UqxAmA+1a}nvn2M?8<Ev~E&;FJ(B^u>>wp7`lU}c%;G#Yc&Sm}whYvo)
z;fwm^zW451tW~N~9YgT>>uJL#Jrjy2xeQl!5riY}sUhe8)*EBcTT*WT<?<L$fwMJu
zg9mezU%39gSnaENqcp_jhlXWI0RbE6umP@2c&v}I9Rl{HV2_*R@sUse`U=s^LIZ+Q
zWAGL@MK}pp<asfOu;hRH9q_aWa5joEK8GOm)of$b^zT|KEO5zc<mrK|hpNj)0D1<l
z^3T3RppA5jq2`)-$RqGX0m8GsC7?jnmj~j)8Kx?2kaf-xz>rSM096(lPUBa6sGe%#
z5oUV%XOPun3El)B-l^AJaMX0t+l$}ZY&^;lhBE(qu>At^C_;+UZ(4L~TS@Qwo<6^s
zEv6q=<*brUNq8AWTeA8>E(D>3e~wr99K*V2R|-7B{nN;t#;jdJ1pBuB1yjvgTHL9+
z32e&~q%BO9_-i%%@cj)u6MAMjXs#M7u&+JwC%9G}3#8&&RdaBivFsry0we>umHbJp
z3KBfgyMfhQ*ov#_Bp3V{Zky&4kQ+lKbkSC!-J5)m$Mu1J;lJ#j)GZSPc_Rfo3(dNe
zR;U*nUB#C6E^2$Z?E{YAkq!5~X9}EI?Ue)X0v{Rr7<lXbbLH?bGF54I(&BNgu$ygk
zcNEwFyA8Ugjci#B%+$4lRqcH`j_0ef`OCU21)HX0A6?rd?w<DD6+QJWO<v_CPT!eu
zroF<Jnq*i+_~aliUrO;cJw$HX=X!<oA>oTRKc;&I3(<1~Ia&ib@jrJJ9AUa~tAzu^
z!E_|+p8g=1ALZ-kWa$KcG-{CAanK?Dbu;2uwM>%I8sj{J>unw$-OF7I);5NGeNVU^
z^2}%kns!9U%tM{g9of6+<CDGMoJ|HK$DlXp(}AZs*k60yifI<7M_4I=YHA4LYu6n;
zmZIW-P~}riRZNWr)57Mqn0^0&i1F)gJCteUcZiAQ$Vcf!u99vm)hL%KTAkMO!v$?q
zu!y5)mOLKPJs%W;>2i2bcVB=TcLg3q1a4cVV)xl*#>07zN`TYz_`vh}ry_^gk-HQ(
zlPfdsgXf$IeVp-oJTuOyknpl|tiewJqieR5Mhv35|4YD+)|T?ARnCu^G(LXHR$D9g
zP~XnU6R0pZkU{M)OZrjGP#+@{Jhrdl`+dt$ay9}24tHdWG3R+Vq@O1}mu@<z+<-jp
zBpN>tM+~H{Ci>2Cd@%~A`@(~Y9B`+G<fOIOuoWmq9C?PU+m(lYb=3nQ6Au`<n?@Vm
z>u}m>p3?sgFHED{@KeCYfewDKT8Cl~Oxbbu8{;$|lOp&N#r!)heV<kG*Do{%kAV;1
z64@DgS_u90K5i9<Ce_+JFehqC2V6=9<|n4QeH?@dKyl-aFZD^h@N4;RUy5&p+RCvT
zPpL=bV0D^w>1kf>Xzce`r#218s3O62)SiRj`Nu@2<dC|H0@Vg>7Ekg6xIR!KIdIq3
z1eqGtGT8iDbd~Z8GDCm4ew5THc2}<odvFCN1d3wdLp-MNJXjpORdytp!d}PENi`0w
zGI1E5e~p)UVW0a)M2|ykRM7Cxy5O7B>8wpfoqd#CG5(J}A0+0;>E=r0CkyTE-_VFQ
z&!4<Pe{oI{(DlxeI(@>-BfcD+FGlD34oVt_9UeqY2~7)Y@SDv2Jj>F*v9a?g%JGTL
zK)w5PL9WK?v_CB*^(#1aC!q{_O8yco_w}_2{)NGf?bWMChjY?2Z88gGVU;-ZJ0~5Z
zgF8VTebkV174InZ$Ne7fj;kxp^LuJ~dZRFI{2&DZ+wy=>-xyVE=KwY%7%-xJ(Wc27
zoi#7KQ!*9*d~;Rl-B|uj%U`-aky#n}sdhH^ir)L!K*sNWnY2j_Tzb3|yMLXftdME;
z0~u-l4X>!Fd+X6RTM4p%&A*g>W?at;(Y@@;S2D2q2s!Ucc0nM|q^WBv#y-K`V7LMb
z;xikFnnA}iMVtoDidu5*R!w~;``|u}$oHHnen3)mnU7t_pOW1Xw5|xzH1#^r@)SJg
z>8`V7cKL4$a1@XeCA+&YyK1!8f8KQZeT;a^Tat(al@vLd4jpk)G7jD!huaw@R*Gjk
zvh}}x{Jb>%vfdtE0(vl(-QJWzPYsJqj&VNpZK<&cRx@qN9H3;$8+kc%TQi@%Hd>(B
z4k7-qIXQZGHP2a3)S=DQ^A0i5pE;V=9`qosd|Y2ssVr#as<Iq-*{BXUW4ZVV7-YLQ
z`zeU7JP@i%)Bhczx0|R(L9hH@=f6A$Z<VfO<VY;1OG7ILl`Z2VgCw|UArTBcRK@m`
zEV++}jnWB6w(5u}?!MT4p~8NXO}9Dp*Bh$V)7iB4wKevvQD)>f8nWTtyNrv65`;7s
zSP8EO6tn{gJU61vO5A`#6?R&oZZw}pjSzPvKr~w4X9FTOU0#hP5`Mi*Iv8w1Av~f6
z>+MJbj>QXHaTEB`9n;(Zc<XMHUlT1v8c1`uYw{jbLu_y{0TJaro{O!FShw2;_~CTW
zre*Ofgmo&{<@fHNOq=u2=QeR7A@Mma2QMuFjqF_(SfaA*o#YX9P9_V6&3mDf%-0W`
z@Pg<fJSc?^-6>BW^WNS1&v!5C568i~4;Y_StM-=lE_AI`b`DH3KB~yX5c`F`4m7!(
zn)D~qhMo$P0#!udPaxO;PpM~tydVG~<Zey!edG=R;K!i~2Hxr;JeGYSfLO`>M~Fa0
zis}N;Hhx~|r^pOJSt?IpWW4I!zdT4$EA{^_ye%6=lI@c&RrC2x#wWI=ezxx)EI+{4
zdR6kEL=%+S1ZqgQ{b-Z^Gu%o0YoG)1MY4Z*%dQgyQ-EM`AkvRAHk%8ER@`xZo%7le
z8T1k8Xyc%GN4Um{>9Yjy2MUR*5BaH7DpHnWYvL4(Vt!SA%Xada;(QO~ObFsmPM}Ql
z;?44F1c3~mujZHrWJjCyt{J%}7Zsl}ZXA-RSGrqM{Bhj%JY=dd*nS>DwX%3)UHF4N
zbHalV_*0j#<)<z+bRLvOezY2YA}F38gbl%k3Qy_z5<oO*=>w1d1PF?d?FQ&oQ+P_r
zbGmyH=mYQ74IA6I)hwZ|ZMljMDjx9g&)`?y$T)_HZpA}g`N<R<4Z%u`Wg^(&%_4g$
z!lqYrm>Us_Z)ANptje<6lLp>!cD#Iew&797jtjPbOu%<@X2Wh=r>P=$WB((RPAnO0
zq7P0I=rjcV{m~DLPCz%o#TW31!a3Q612yRf?J^4$BLK+#^&DBgqEi$!Qsi6MxZ_&l
z=8ZCBR%Pdb6{UX;rV|T)z{8UkNL$|gs@C-Z)Qm?dEof2m7^q<S-X9q^>Il$U^lpyI
z_PV2Q<+B?_68WBIgI)IUB-_ReCMwH>kL#-uP2MDp4Rn4WEbmCste|ikXgz;MD5m^m
zK;!-rluXLt3q!CSk5n<7!IB!=D0#LY5Fw1mS>}~(5$pN1st33*hXU~xUl|EUZR+NS
z44?HdX$-#L%xsspn#+%GP(Pzvb}^$C;AVxPGNyzMSJsa8#u%J&{u1j!t>I0Q-ya(V
z`ZG=(eDa&86N*+foYroQU8DE+-XtW9Q8i-7Kku2Q-Gaor|8(X!!0D(8*ZzdT;Kbm@
zO9cf`qq8A&_!xlKaqNfaDkyriY}2KzrfC0RHFpQ`1YSKx8#$z`q8uQq+=H*aAJ%hR
z(Zilny!kGRmimrD9p~4EHr9s}F4{DM#o20t-M$eN^A4unoFKT|%2TF?SbOk(ZZS3s
z7-e{#qq_KRc+abYQdb@*C&a|-7FqLxum|Ws|EZeRZK9Ybp;!6u9hcPB#^e<2lY{9v
z67;6U50`s;Cdw6nb|qvn8}DNL?eh!hmpXqB1CX{Gyq9wObsKVa@JeMB7z%rCW%5v!
zPUN_%Drj1Q`i8IK?d5#-?KhW(hyqw3$pC9tNNXW)%9vt^+>vL_Z&(J^wpeu_)0O-O
zRFlBReIuk`(`W96)2WvCpG3c*=}qlIz<QLwo8V500&2pcc-H*#WJ4GNUi3I(T&rXP
z&sePx@tzRy*8d`MrE3Z}=Fz1Tm^2WYDU+PLKtyCdXr>`z9o`fbe?MSm{5p;QYGpri
zVN?g8ZK-CNP&pdL3(*(cEv~F88nPdG1|8ZKnNJ0>o^&)GVg?B!1e|YNh3I?AK4&I?
z-kZCmQt-pO`ip^KC^SPx0@TuHi^mh_R!aM=ukC0jtj!Fg5BlH7%vD_leSz0$_K3E1
ztYBWftllmwrtsP7{Q!W(4_)&D!H?6`HMQKz4R*B$=I}$o9sOTxMG0t(n$@$$6}6T3
zerH6*Vq?*Bo;l?xM-s}?p)%d8y53gY^aAwKwNJi;+1038lJj?{fmRF3+KE0OT8b04
zus}93m=KLXtjc2zPX`9)T@sP*&I(7d9ZL)Pnju7vjG9!49M-U-m|fn>yN^XUdFJq5
z?%m)K6VB;E%9wLDIYhq<Hru>e<q~Q^k0XJTr=xbMNJ-89s%Vk4)jiBk<fY8jxh+0F
zZ$WMKnPFZ)qn_Mc;<_6?(BdAa+nlK%PQ0!2V7g0E>r6=WlUKUqpOslem!8i&or-Z;
zphj)BI-h?g@Rp_p{Gt#m^6aYg{*s`_-a<xz>C-&@$$<^gw!_%fnM6hx0RvCtVuyjt
zew0)8^ZD$1iW?m3)uBLa11irS{FHc6#qdFb7kGj`=Q{qZ_rV^IJG97<4szCPjoaY;
zI79b-8s~>9eO5V&&5{!l&;+bUr<gk0>WjfCY1itA>u$-1iL8~HJEAGVfCHWjxUgN$
z-VB!V!OmTpeZ-D0g4@wfBrDcFHo7J8BX~ue#dOzmjzCW#&=s?L-P-)pIK(Xf26zqY
z$IIPs8}%v~E4;(8Uwb_CLUNV)aOigW+=r?$U#!@J{5wHMKf%$UWClG%;aDHgp9cCC
zas5i5Tj4X&i3kQ7*p!bG80a9nL)c1ziwuc{4qaNV(kQD7#oPRBb-pp#!VIs5GbST}
zXkP1W;N+RbU89A5wE!5iKj?m$KBowVJqAEHAaUm5afX%!ZGzALxE!E|;4UHK+rP@)
z`R*#9e#}@(h26JF3uH^H`}zSDaK1$Nk=8>(Hh-X}tVXb21MNx^`bcaDJ&52=G)^Df
zWl>>Pp!bU8WIUGNKR`>(Niy+!gT~3`_bBum+U_fQ7D8%vb~P3EQl&om-=`2xCzQkv
z-!~HjoY@xilgN9025n=3aO6d_x{H7EUf}*(8g`Y)lgiwUX0${iZ;laI=S2J{!gb04
z)uDNQZ~8aDOFdTDyI+F02eMJWl);k3xiHI77d*9Bq<N=UYTPoL{mlf_O(z~F3Ble2
zt<pR}jUL2Kyj!5%Z5^MhF<9EqcqVZz^Ma*-+STN=!Ls%+4AGr@YWRu$aB>J}dD}V<
z+N+LN2_}79l)$N>W9}17SO#Yn%{L*Df{F6}L28-L_N5+gEIoMsNlBhm>z#~aE{^lk
z@RDZ*eAJ0T5CS#+?q4p9L#`d{5A5hT?W)e(V(KQ@PErimHK2y#Ht%tG_h##{hkz|J
zI#x{2F@Rf6YR^F!`0CR$X{XsQFx4)FeH5fO8f^1_w^NsrNoRCtZA<;Bq^7o*D8YWl
zv*t)vfqPLA&p2Jl#VZw}+QCzwUzAT201?%&8H{@AU#7TcJoEB49~Ec?1R(mj;}X}#
z1{66C?<Vz=-alMuUI#@YP}jQH2%Xh`?YgCeE&6Hav4$quG4d2L?qq3RWOLDGBKty=
z9l({t+9<IxJ;qzEFepPeY7iTAaJH4MxD+Zpm&<d)`8UNbpJ%&#D+#{FvU@7hSeA9^
z5BH}Asqt89jgXnb^~C;8!@IbO?LCSx9C50d-z9mLAQk>=>E6Y$YZOy5yJx1nSwrVO
z-KP-x1kb`U&L%!A_yyZFX6C=dEK%cu9~lPOB)s4Bp>us}EMQ%&pQeqbcz`$%AC&LT
zf>t#S8AG77)#t#=rzC!je~f+_Mu($2|9Cz@_0XP?_$oM&+({2A`FEt(DJKP|*J>{F
z-%B<iTX+Fp*OGo*&eMJqR{yOsWi4m>$1ZCLM`J+=lLsxtGB3*VE}Qn3p13qx@%(mT
zw##_`vIW?Qt7^LULIBLik#<~Hq15jmxW=yE7V*c``hr**A_v;5AN4CXiyj!<i<4kX
zagMYkEQHcMKrd3%HJO@uasWw|fAwM*Sm|+@{Etu()EFG)-IQXU>1O8zjvPrpm7g&u
z>V(NI|K0<Ty#d%d4oW=7^+8;{^5HZ~V(?aD+PU{AwX)4vfqX-6c7AItZM^)7Z-iri
z94`Ew0TSrH?Am?)e{+~Aj5!&2D!tJp%APMb*9M`n9Rx^h850*vhsGgaPHaSwpT@qk
z&~Z8SHm(t_h2kBU+sTBFyCZ*}+Lpw%6KmlJ!5b{D-6Q!NxJQrSDMb2KO0<D-h~a6(
z(o2({)_JY(gb!(ct&Zb|_XqoAIk_u}TSxL8*5e8vb@>0+OLQ4?Itny7F}?7P@d%ic
z(e*7Hyk$G0joq4i_CZYY+^XczxkB=WOI%zmS%X>MC8uGI^~MYGT!yu?*U=jPUhe)s
zqzZ*3-0c)M9uk>?a(_p)$ybZX>(lJO@ynR{w53BV66gKdJXdaq4$MtCiM)wte2LFA
zYlP*7hSNDt89$Mfz#!E^j^MMZ5t#hd*kob`nos$az#(ymlMfiOg(9EbEwQL+zUjIa
zGKld}Q95||;GaEWvn9v3K^)iKNQ_AtAj>+0N9IN8i=~f1?d_W_+;hUqO6gJvofx=R
z<@irP$eT-)e?r5cGq3tvKtH&+Hb)3uw==GC1NQ8*LOwe{&GWMKMBwh-rhJoqV$bOf
z$_8Ujy13f;ms!n@5$?}e#=P8FI%j!93c8FpTVlFr#{$<To2RbZ)t~xszvGteGf9!7
z9uk`sS6YMI$|NK*nRIRD+ckZWSCiDDj(L=KT8b~JG_>t54^!<9Sp}FWB}xNOGbm{q
zRFH9xB%^1&!=W*A>A;TUq|f2tuo3{bblI?aAS;u#=YH2~izQW@7H~@5ND@BBtqiJr
zK+DZp>3gsv_E8uz{`@Yy^Lf{Yn$fRrP^<d&pGASd9vfHzX21O$VY%_)bW))$td#WB
zQ*eKThj@C3eQmM%M$&C`?UNiaA?IV&wuS+8xec>(<hyNJ))yRZbm8zT_WHci>w_O!
z^#w-QD-*6?8Np393$K{$#rn!FVwW{1Fps|+zM}D;dA+?PxHHn4=y}=xX1P<=PeDbi
zXW=Y4y^291rV*DO5R@}lqquo3y(vQw)0^jqEW{tSNA^-IhQx9|%1);9ZU`o5zqcup
zrS|EYqWzg`AYlNJyT%`Ie>UEYp<)`ZhmXnJLB4Vao$5xIe6+y?z4f$(aQA+$aJ#t6
zu`#@B<+hs?rMFX}?8w@yp4s^2r3mAi^}D5PX67zY-^4YB2wj0$gT(vxRef!Bki=rY
z>}Z^AQ+r_-yXSyHmAC_gka8?&>LECfLnO`b({LrD4y$3<j@CzE@aiA;o6W&Bv?XG&
z?{E!NL}K4-@NYo7?zi|gp4Yt*c!3`_#0Y`mZXrpT3y4g7sqo{o7)&7v$SMyggAp3m
z%>9%`P<*2`k=4lqO_@8X8=3l`J);8vHC$_413)-`1VSSd)w+|wd-_<^2gKxf7<+Pp
z=s4f{keYkk8~1*tt@Zwj{3=0s9^eHa0aO7OrZfgA{SQ2W%Fq0P!%7tmZCL`S<;0a8
ztA6*Ju5D^^#}U4P_0M6u!0p|^JKyh_e*FZx2z35oEbT^U&!K2{q1$;VEXyYjBL8DX
zUm&&}kaTeM9ee<qk8NxVa3xy<Xcrm-QVwB0Sd05_fCy~&6Bq7njLj}bZ}Po>=GDBS
zS+6ybuHWnC`_c}8*Ix(11@||nfmpST!vss<i+|ui5qdfgFr;iYJa)s9@V&RxXYJ^s
zPldZj|2CEXafHS~_%5TxmX~jR<p;qtk%?q=QZL7&5BJqSNFDIK-Kw%017#>Mdt8b3
z%`MP(MGq1oA<vJ0*tU@nM8tRLWP08aXVJ06!68ra(I8^Jg!=1d632UdTpK%07EGt(
ztBo{mwrjFub-LFsGJ4HpkMUw~7v5YxcoqbB3c=s*sBI&(qxt+OlD^5B_G+PWhy2cL
zf;PNtVBPND$A=+PSrY;}``A@JE|AO*r*JSvhx@eB2B;Nle;mjgj!>uv8)g0vms)8I
zmVI|K2%(OD-RkGmj?Lz^m`z~!zitxlM1@3+POT{{T+_fvk_CS2n<Q;u)qc5<`0P$j
zP|tHyv{z;bAkf!vxD-TON?^`EV0K`rECDDcd#>prUpLg)Vcyk>`jtE<caQG}J@4Q@
zCPA(A@>kHI#yQ^rot?P<*g%}Lc%Q#+&^qnw3*81j%u7b2?H?Gu-Mkan0X0bz`!B7B
zf9rwXZph2a7~f{4kIyaH-I3G4;D7FMbP^5ZxBvof;cwL-rY#UiW53IM2oWW3AI}O6
z8d^1)AxOK*s*vz)kW1sD8rj{_D-fzXEy4kS8sYRda0LGV*Az@4#L^(KO%A9ST8uYf
z(p7$aFw>OFH-`W9dY5P*43vX;XBCC_*n0HenXc5ibd83Kj9N?})uNb6FRu26-CA~u
z=HQo^)wvJKMEuk<H=dE(8QPXz1*NX<PeI!m;XimJmKvfq_+6gyhkVA3U^){(`*7_M
zXBcTAC1*0=*B{*}^?y41cBHKM{P2OQP|b|o$fzUZvnI3Hb~ApY2SqW5<y8F4(`!RH
znbnUziMc41SJBinDHzb-{1aE>&>`4cTwNUp=Ifi1eR1rfi~+)G;v~qO&raMJYy=J?
zt}J}w`ijU84R#dr@0iX)ocCqiw@-6F(vtD=h)UFs)(+6piaP2|JWwe#aNRAwpwCOj
z$A_#+kDkf-Vg(!f7~&h0W{x=s%Oc_>ykhnIlq><2?CmqRU(B$(OmkfwKN1t1Tk81W
z+PU;$&eeP_RxoiJv+2oWVcyl*xwH~1mMG;I@G22DG+v|ka4W%HXmc<3qW#zM8`GQq
zyQOC$`)*_%4W#LW3z})j2IgFi2@GFLn0MKO>DO&WtzDM1^e@H7|8W)#ox2M^r4ocn
zmhq!2WCIm#iIARfl(9&@QKO93!MIDziow2t7^X;n&9QebZC})z-R>N#JaB3>@!Lzt
z&%%BPY_Aqvi#u|EHGWuZCu_>=v5xJN{R+Apj@X;7lhKC`tEuG$$*7M=FQr@=d#l}F
zU4d;Q4~L=tMx2toW*P0W&c!3$SBG0vFBY8seClBUB0=g)lTLGxv?nsh4pkb~AE``k
z%i|*ldd^?w9OSOgP2iKGDr&-1^|)Jm>-KCH50qvex{l^E!)k_BLtwS~al<0s%mW|1
z-mO2wbeMaJMpo-o4HyTvJ2e>?sKQk}$%vZ9wSJ*x83<$=6*!L89!YJz;@(McU-zTw
zjp2?r^kkN){e-z3Yv>uy>KxU#ne(`^JMKk+M~!7}H0P=wXUG_z=z-a*?X^MY=Yp3>
zA)mTpO?`)(OVk{zoJkk@+86h*bGPl~!KI|ki2`gmtuG;`Ggcnz*E(R+3f!N~8Hx@r
z$RE8~BN06lv-83%6sg`2*{7~O{ne%v!8$5B+^OU1ObzR=S!WoGM4kRjmFtJ_r{OX+
zupfG#@lfhfxvopX&cWaf^ZxTzf}00fb(-W!W3Q`!_*z>R3m-{ta}P3)<c2MZRNe?b
zSRobr*@>U?g<|FCwg~z6_x0N38e<t1j#I2*>ih%okRu1=y4TluaO<W%81_(lUT8){
z%Y}>lJSCQvBQ$-)A!L2qZ$;93t+8#UVgu{Xz#D@JTi(pk{)zHHO`oz7+`>9WCCa;C
zIo@it$9B#w6n3f|KI~;aa;6_y>zoRQuyT(Y=@6;ooJ0>E(U{XS!cpq@HPLpI;*AV>
z99#CwkUm&@RP<f5VH*lWG|x<)78RP<M;xv5;*p5A*pdB=LGNN`Yq<RxQlAgYxg!sE
z-O-3AmkXo6sEwVgD8x8d;wHpurP1!(9L~UBxVy!5_;ZU3kFool;~cLy_hRSQyW~Xu
zqztGWKPy7WZdNU7a&&%9V3}tW%j`E=60wr_v#Y!yZ3(+kX$I|f_mM@$ag}b3!Ahix
zWM2;x+Yy{i3M-?Bt%OSEe`7w%v%ww>!4tg|ijHEcKgFwwf6Flt1@k3Otekah8>h=v
z<N$7HEmPu0cTnz~SN+_b29Jz~6mmGsB=0TC#q7;oMfXnUI}Ck%YK-7($ONwK0}qQq
zhv9>no(LM#X|r<*+qQ?@ka5H*69(wvm%8BMt{P>pqUC;vADem34t@_TZn{eO>`ip&
zyb$wRcZ-up?r=|YBJl`q9A`vMrZ5piSNeTKOXzu*)GkC9kF0f%3Un2Z@xV$EAF5dB
zDPimCiAIeBHFwgb_S^@LB1dO@Hul?ED_sRx3M9x%qw+p%q7>Cxs(bhy0}pkjt2ZfT
zYPNl4wb9R$Z}M_VzL&kAhnIw*f{B9=-~(Q5k>^LJNeLT4ce3MMlZW3IEkW3m8F9*N
zGQmzW(T5>UjV~v-TcMP_H6I?$92VqkAB{fSi@=(AOwS|w)Td`Tuo#j1?Hz`(=_9Th
zRb5(6rqJ`cHwtJ1v+?ZD7^Q8nA@MS~(7_Uf5L+V)D!g|b$W*3bXjuU2ZDIulL~Hqh
z>790Ev$^nRG5GvUJT!9py!&>T>UZ<A2m9gmrU6Ga2H6=3?H`BFO3+WCp+D&j=&D0C
zrIVu+JIXcjlIRH`@f1b`w}h!+Be&sCNhCt>K3_EA9R0mXsT@et;`ZPt;ccti<FJy^
zeZ#@+Z(|{^47n$xC0H*9t}x5d*;O!KF0G;QfJa<5;^cNo2FHJBHgn(K1rPrR_3!wq
z<VWZ7A8f=!40%CDVz%V7YOZW<a9(o#n^KL(R%F2~XJUFh1-8HcveFkcblB73&bHpn
zTZY+B0(o_*0=SvJCE{EE7GHXmkoVA<$DrI$NR{B$T{fhXv>zQ_-#z%#b4HDPOIJ_h
zIr<@-Omv6_ZZg0M+N<YkWXV3qv5v5l5a((7-+uycePVE3iRHj^#dPZ)9bRZKs%MuH
zhNnSe)X3~dSBfem#Ot7f^@Q4R>V9)JGJ8)dWwh^cMfHpK(L?=rEM)vssYfdpcI!Ot
z7?9cGk&CFeg}0*>nYg<Y-*a09@!~O3{{6N#ec^zuw{vfg^D*ec=yfxo-|&nG@EDo?
z{u}8J>f5Gk3fxfw4}=F()QIb$_6J8brbS4NoUU~+>q|5Lu*JEo`8`x76+bfR(8PGD
zA0S3%r+_oOWJi|0L`~8^qd(;%hK5$;gXmGgkDTsAP_MMBb#2eoXwubj20{9yyNJQ;
z)WZJWKI)Miu!4{Go)!hmeB#g|gfJ6A@C<$a{`22vj5wJdwtW!gB!%3yYtt7P*+xjc
zH+wO;M<0kfjmIMoU+@4!e0qhNBu5A9eAhaIH%kavXey!3T^K@9S22I5u#F(-ZV&c_
zc648T#DZIvu4O$mQMzqLdrGRVYW7!slth}7`9@6~4Ghm|XGAzr{V><wjPcbn%6LDY
z6FDDVTR86@!cW{!iWge%1{d4;Vfe-V6gYC}5Mb%U%B&QymQp;-BsiJ3+MYH*%}h3e
z=)A$K?hNY{$AgRk`KEwm&3BNJN4`Uq7q+k-5;NT5C}4)M>~^~N3fB`@LnhwmN*QyC
z4t}Oy`u6GZr19&S<H6E|k))E#Dl-o+j}ET(A4Ih~gGFDu2S3&OU2FQCs7280=S^cB
zdX&iXxC49afa--P>QK(>^2jKuw#JkF?qP&k*E+|1simIH`HV+93H}lu8*8}!%_1BB
z{-mqO_PE%_OFH~at})`Pe;o8<N6{sMkT6Rdr|FE_!ouMb)0=q2HjbR!dFM2cD_4gc
zl@EyrqP!d0S}p~DKOY7^RdI$pPg!)>$lr!jkqWjBaFkCJ$M3UN^u>S(;zKMEauNLV
zBK7Zx!XJQGnyHh{Q%uJ^e60M}&;MTIc{H&~%<uiol7*{2?4W|^iGjnb0Q~S6sewpx
zD>Pm<>=g-w;uj+EOc#eBD~6L|jJaIWmJo6)=F&-cY>Guqe(sfpuelK401s7j`_|tt
z2VXEfah=nd`GqalKcQ~?GT;5iAj2hpv^GBIEpRaP;_dD)0kb<3&XWPC(@sRcT_2Y?
zLr{~el&0W0ZXE$AY5)~+(d2kn&db8J4z>-TUFbJ&$@nCowY773G!lMvNe?JbHs~(A
zmBPs1=zRL^|NhOjaFyN3SE3A8nfNKZAl_#l3<5XM^F_V21unvfhI&1RTnjLI7e!%5
z(EmFE5vZ70M3_L)ZIL%78sdSCr+%A@4LKbcIe>qwZTG1^O3mx9E4`S1x|j1`i#c|+
zKk^ql63=q!s)M2;d~iiav*m;Rg*o`C4|h-USZIimnFDxacCEk#J_udRBS$dm8wWo`
zCveN8_k<81MzFytgplqxYSiF?Z$<?3)V~9(lMVa=_kqi{e&Lz@LgKk|+ts5_rO?nS
zY<6`lUk`0LO`Nv*Sq60F%hWWUDmym?N6e&Qd7JSQn-x_j19LZ_2ZI#(HczvKwtq_7
zsfW0<t6##piLZR)ni!_xx93D&MO}pDf^}rl{B{Rbe>ywZ(Lqd)phxJ&f<c>K%S=A-
zyoxiwJ+GJ$;!l<4G$?ez4ZY=uI6tWAE~xXqirb+Z{-gQDfdmm@D0>huq9LLzX(BMY
zrJynAOHYdSizJeI=%ZS41Ihz8p;EVTM9no_Doqvlf3pA$4Isk*<}l$X>ZPLD`KTMv
zXG_gQ&vrDOoS=xQTQU9!OZl*O`$9W=;@*lri|l{qrW0@ai~m36M!x=X7GZCox!_^2
zqN7sAzpu_<#OYFW+rrMK?*}hAq%MMwu8|ZCl{LnPD%zi_IR9ssAWmxPWN)T~`BdCH
z*-0fnH1z4UR;57>7}qvplnA1A8-9O1=4c}97dBqct?0qTu7a=X(vPlMg2DD(41>PF
zYkX#m>bay5w>ATL9zw3&@K7(l;Jo_8@A116o9*%eKc&NSMYqeR#-Clqmc8AVaFf|(
zm5`D~(vBMhV`%+S7b1qWcRbY&F)gpWt<kF~>*1Q^KQp{YB$BMkj}c}0w|J|EGK%Fd
zRV*qtF<kDYOF31F7T8TH7@nWB%a^&RT8Qq2B$)Ne)e3+mr%ysM-|rwM{zni?zlJ0Y
z!|L~5@MgYCA$=1rsQVe@f~RvqbZ97Nm8LtvT2f&O6PkG^BK}ZNr?VsQ%uF});*U4u
z3%TFLa^cDgVNQLjBx40No)S{Qx69R~N%_p~+~v;Z3nGhO{z*}PM+lAMIK#T<wS#Nu
z8|O&D(>bc`<0HZ;WW3i7D7T%Rw!ZtZY94y=GAOsnG9+cEZU!M<(1*j<nrEpXhaj%{
zl~g)N%&Zb=p3S6-lL*01<k^$$f_Qz8`Xzv>Ne|#M#xrm3{>}@Gn)T3bXOJfy^0wIJ
zC8I7<MbMSvSNm9Udn!EDIuC=sl%-^V_S3u~C-RkNGfN_j3SmHaC3sxpEz9AYT<HQ3
z?66|OhM$ZhjV;-<dZIZRskympTtoh)nTyxO;8X3~WDQFaq?{T?|M1-<j=f*`A}0Jd
z<(oPfO>7e450DP!D~g`pmOl~rkDbC3T!XRu?@~T6C&A364$B;v@+4@^krMWk@>%r<
zU)3_V>(8NpktV%|eTmD!#%D?>Cpf(=O7JKsc1<tW0)(nb@A*eC;CKD;hU{EomJ1R%
zROzMg^QAAZ(Dy_rI(Smt3%<KL-bw<g56|k{d66ZJhF%(}OBlX=elV8VFTz2h?STuH
zfp_#2tBcSbEcr%@IPF@JWBi%q8}jy-L(bgxBV6g~2`{FEwT<S!&EtUQE!G6*azCs7
zG<<Qx`LUEp8X?3!K2jd}Yw3x|m^hX@2Tz3};CZc!&A|$UvCsLfB8nvm7JNvoxheJD
z5W5{Zx2%LGl$^`~qpfA72`vp{t9BdIGuV-A>Dj~HG_>+O)JYuFPh1|z!liI+KZLzE
zY{JPes$_rKZ>6%0Q=nscr>x|o3}VF(adl>&W;(pAWwnT(RmoxU&iyMDk&-KWyIriJ
z6XL;BvgO0k46OVPw5RSskY~`JC&rtSTMSuXZ8BUDc_}}iH7GU@Sa2Zy5@p~nX5mU%
z4&&;6bY+)v><C2mQX_qZ@qLC_Ml4uoR<9rXm7N`$$n}&E?=blP>EUr0V7JZW5{h6G
z<gh!<Z8PFib`o;Tj<45m#IFs^v3@k60f45d94ypsUl!gP;yE>EpW#_%QiG|7`b%`s
z)g@scV)@A-T1KW<u<tEtVZoCRNg+m!kvsW3kN6Yr)h7CAUjq2Y2Ao#m6Py?foZV+y
zmjp5xwEj}Z^mg-%AL5Q#XXb^$>jt-Vuhgc<d_QGCNjiBN%1M=Rulpg^K{Z{G@FxL=
zXHPt|9=anuNCq*p)4Z?n%D|3D$B0v7%_N0#B)VtSzh{*jM^x}sbWWl@o?+OrUUNyT
z6!=iX<{02~ll9R1hM9)V9<80&)4_&R?xxW4O{e6yDSB=GaXomG`IImXdCko5vLF(=
ziFNewsH-1O6$PZ+u7KJfQI?mY(U@4PaQUY{?YQzSK5%N2N>0)njt<EJaCgh0m>2>?
zp8kA;?8mgHINe8ERIm2Et0067GXLZ}#bG|@g{qgT;P5tYk7XVpahYdW{Rung;~+8Q
z7=u{3xgEp6lHZ*%zYYyICakR?#)mc<H6Dr687Ox&H=j-T>BawCSNzWX>Akjn3G7ab
zIQqQmdf8t4wm?~zajpL5w*NZjXTR!U{wr5f4XCYhTDYK!CqN;YeCXp)k7J%VN$QO*
zNH9y~>b{=MWB0<Lt$O+%J$ob5VaB_w59He0l4rIuyu!eZ0933G?^_cQM5O+x;514y
zIp^i2p_=@S<2-FCWUm~J_w9OqX{Ck{vPG%G<`o$kuhF$k!|DjkC*S+c;#GMVvqztQ
zX68x=Ze_AIE{B{A{+=g_{XXB#vzV8HHKFlRBrs}ZIM7%4c@rOpl6*jyJPu>vSQp&^
zNZPH=%T$o--<~CY_*#AGlj)HjO1Xq&>}*G(xJ)xKUXtK{TGt1_y&`@Cm;bOgKw$Yz
zb^e2s033CKTmFN+0N2H#IRGz-@xUEAICOQ)vF8CPRtQ7A1vbS?y$DE-We5rf8;_aa
zFOcjn%j0m}G5I--S1fxB29LSO9)KNhIRF?tp)3Dk`TxSo|Ka?6VudBdypR%nyWkmF
zw0q=r(A6Ut88OQ5rUr}B6&2lJm4ZEMSz>1hjf*_k#^Beo$NG9}0&NF}%l^aqbe-$l
zbk^tZk8&0c@7}PLMJaM1uMDXB|I3stBQ6GiL=ljkfX3h>XDWsKwU`Fl;=@_oGI0?c
zXgIh(Wfx&soSyZF3><Q5v7UPn<a5CzFR>?quYc9d<s@T<F8;wI`zlx4NW8Hr#jaER
zIxmGq1469^+I$%dibS$!J5)h<qL}>xG&tsg0gL@ZM^Dc<5nIw4nvW)ndM>S2q9Z?+
z@QT+Dr(4@>s#dBF^1OMx0~g4Lp@l{|u?`T}tE>9vc1bn|ZHTtz%9SdwjW2C8Lyj9t
z4#UM3I&l-CM>v&Gt_1t2T&bIRI8WWi4q_pVwMUuXQWma<Zt+zm%g4?K(Ah;{3U40o
zz9u^O$j@MtL9pW6WA7)0>!U7+?UyT6uFcFq_?ue23F8}x&nmG?oY_=b)3^T=jp@uD
z(9Z@2DjAqN!k+fA$+a8)4tpQEY%_DYeOP1|V^wA|vk`euPSV8gjkcAvE=Me+Y9Kj!
z_Vt9tl^9H?&qNH5ce=Ah8(--egL3AQQp9Q~3p4V<SM_StTZvNW{ae=wA#EInSIJLY
z>@B%SqRReijt-EgvBOyviWb&+UE{|Z7b0fiHR~PgG3j9p2LQxpV@hqnq$q%`*6s#<
z8Mbf-aiadVW%)%|#pbfPFmk6>U6&kkxXgk4tkH*t>Ylky1bO5oaqYy>IRQa8zYD+4
zgwwVzA>WZ1HChuw0tg|QltzuDMg+N8FnDWY#A>UQO+>pdihAW+Fl%1~&vp4aIOG3*
zgjZ6m!L3w~^=L^qHJ8?3HTQ>tqlYj2<M)lxZJ!?04y;v}U_AMw2ZJ$J&H;jW{Vx0k
zPT2hI&OI-Ha(}Gj14E#L2Pt8It{E#(!TOJ;oCe*q4`vc14!pzP%9D4tkjqr&PrJ3<
zwxoh}P{MxT*cL$JI}!xAXMR^dv9ba}8y;BwcP&#eBwpVwV3ZPsd3{Nb%6<3~L~HH$
zv@5BmciW$Fw{6G{gj`6a|I<JVOBW$-M*faSQ!KMD?vdVLB8yCaHx`Zr`ssoP2^O$<
zN6<)w87`Q<(e|SQVX!P++lZ4vh4yK~Wn@RK!NVaoj_Os{?C0faY)J4d7NM5EA65t{
z=~nsc$lH%DiXHim4HPOKkw9*r;UT)hWyHzf4`&=Ber<G~Yo=c3McPY@k=f9w3nT_Z
zE)miZ5HE|jcnUXJ*n6^J=-rF?zQiXcdjH8E@zdi<_XhI3AL9E)37qkvJ_R1nTr+^$
z2Zc2o3!M_c8Oe{=c_xVpd?~;tZ4i|slu8QGX`Nt@{F)E?>p#oGubW6Ai%QN~o&BXD
zfP8MUK^VzfOZM(}9EOVHb}e2Oc;P7(GO(FOI!{EbA!G<Y#A5{>GCs3E_x%$i47?zy
z`<*3g&gAb<{FWT|1&at^a6AqCe=Q;y#m=E^wl45&;rVEOeV46<F1PugMy@bwjQgPw
zskj=Ks^siS5E;t*NU{`q5*W~bHyxh(;JQnIRhk2Ysnk~wWmfX^N8qUK(s|O1EHiU^
zwkin)?f2;Y^gy9fe)8x*`Uh5y;mP~TVp8wZrtfl?mk7BIJn{^4@Ez8y+pFxIggseN
zea<RGG!9ds`P-{f!Bp7L!QiCm0$D+M)Q@g6%tMBDDbaq;OMBs7$fcskeqp_Sh)eyO
zk8L+s$PCUW20;`k{+Gjf`XLPGMCCK0RH+GhKeEDp0p;Jg=I{q$wCOhI5B~q<D0+Sf
z9C_wg>!u<DBDJpdt%b#Xf=qtydT3XI`BaX{<ReW2D_c@o<;+Lh_kGtARcc*_ZD6e7
z0Mk`SE<DF9eBVt4zkJtCtR=TAkO<K@E=uK%K2O<OPgPID@k5Q5%QnMI^v97duYS-b
zPDW&4F0US(PacK<L<D`4L07s`U2ud5Ml@Gbj%+ml0!#!`8LNBv-Je;exh-++jNo^j
z=4nhWNsWVqHAoH=tSlh-;%v(7kGR}@$wPvBmBH*<ntbIMiCvQ1$S0O-(e&-LGkwS0
zIByzzaS<;{M|l@>#o0~&LgT=MvaD*7$1TFu?eyrFjcp72(Vf!MA!DFFJF_0z>`9}=
z;&mA2ENf?RThXn2>Tq)$4e`LXk9W=Z#*gX5pR#q}L|W?>%IPl-bPZKWIGCbln^4cz
zjAss#BpjPww>I(U2p;(}06nmIbMuS)ir9?9XnwUcu6DOlF?F1PFwy*v4#~eU4|t0f
z<_G~x*bZKE4nQXUd|y2HquP9JN+U&)<H>k0|J-Zw<{_+ATW!J9#(v3bYx*-?MJwOE
z;w|@`f1rtI0JCtz30{$oNZKW&W<xl;(fpM`S8wyf4;R`}B+y-|9=4$#l&VXnn#c^N
zz$#w-=k0r2d|_vZ+v4|)9={r+Xv@nIMEKJkVZsBl+U#^D2DBMr;?nZd7#_V^_BOx7
zuDHp($^uj}mhtpVGKq@aa|p@_<w{s4bCLp|OxF^;SbRDVFE@M&4^Ke`#N33NhtF}Q
zxJw~+uUs;8$~)(4srB-WnQrb1lZ~9u*r&VTuL<W%I2BS|lsj*gkgG22_U0}O&Ae##
zP?9BAp6)Si%*?ZzY+qSaO0B6>1YQ!IB$|1DF;Cr9OSnFGvgXqjk0_OKQBDj+bd1Mx
zciwgEPC=re{)&}~cOE6|4Ogx|!kt5T$*KA1LA{*u2GQn$`!Z+Y%`=jHV-?$DBg1)D
zSdK2!99B`o@bI319MM73%pBu6oHBn9;e>W3l>o0N#$*S&KCV6Rb*B=y4nWu*R5*ib
zSm;33p^nX?&79Aqfdem4FF;jij|lQ2EdF5d)e<cQTA{p5g&+PrCfYByEQN8>rAoe^
zih-hS@iJxBq>7NZMk+95MILk|rtG|0>LsKiMNPolF1=Y1*;?D2Jh5<;uiOL_zI%-j
zQWC%c`_=4??lRy_i#v*OIGjSdVV!}@iKl=|YY8{E;3p=QhW|FPg)mZRvK8aXOnCRC
zen~X*EZDu4kmQ+HOgNX=(~p;FM+aG44zP3KarVr&6$ztbC@4O5h8+^}yIes!J*%Ci
z9cNhVVk!@_L<Z1p+HfH+DFLnWGmYitI#4UaYctV#5^&7pK&m?c+jm?jwyh5q7+GUo
zdAz!ZQkw|d{;3dRn2|0+$2#~?*E2p4!QwgHA$>?C_6g&%Rm^aW6f!e;|JOcVrUeil
ze-H`3H3aw_ZzexS=q`>BflwKI_*0xx1XuMNFiJDw_VDF6-_{({^Ocf;l=sz5&fwDz
z$_c4P!pfNUKb1;mKZR#49bS3ORd*CKLJ{w=>`w}q=~`N8IriXmFB1rXKm8c*;|f4N
z>mWbk`UP-VU)K9MGa(c1*sP+|sL%7>9Aa}z2)l!$p_k=OXsAS+fAEM|M0nou6@nzC
zCz|iEL(L+ZOc-J4VVdeM!K?U52|(0;!QHEX-s)sOnq$E85n{t7?|;8Y2<q)<w|+sr
z^lVFjp@q8;eTTJJ;gs7%*#0E*+~O5=e&1<+$mpq6fz_bXW6KNbPOfS4cl`_u{7<Fz
z8#U7C*WT24o|s}cZg>#9f77EXn5FrL8|QXqZPgFAd;`Z0&kVJKFeoc)k{6J$antby
zUUJLz7?J?~c08dxd?S2Zk<+mO+DyLV`$|fjedKy#;@g{FpBCN2kx5;6tJ+BJ{2Vd9
zVsn(#rxdt6a{k@BVQQueZTU>F0_e&Bh>cT^4y~^08?+wK({#T^2Mg?-=X&np<8}*v
z|6GC!2N3{-cr(Y?128UQoUc@o`;p<CaaRnSvv@XSD!y`N#2J8*eb$dtF(6+65_Yrd
zpF@Mzj^DKJ#4&(cfv3W9vRfygt;gK@e(O&b_m;drQKb~15;;bYVeqbiCXoN;oxeHV
z|1i5_CJJgPhapORkrJb^3ZUODK_!Fr|I;)jKgv-9K#JGK@gIESPayn{+lJ#j<-Gw2
zpvv`+oVS+wm>}ix9A%!`UF5!ss0(h^cVV;v=jhS_@Nw74vZ*LQhHx=#X1(ECVaDE(
za|SWS{a>-{%f2mtjLfr-d-**VR-OBCdDS+H8SK@c&>R%D6n_NKrA!DQdcGVz5bK-D
z1vL`9TSEXHZcMK=Lsrj?UT|w+Ynyp;@yN<wI?kw(6<6DzS_c{`IKSzC!T5E1G>hFS
zFNHZmtyizQWf{nTWVma%#!*mZlT_@wQssyM9T^ElSk1D#wHwSc>q246%qGeo?0t2g
zHq!OainPlxbtQO~09q?FR6>@?i6;Ik-0x8)cR|Q$?u4E_toNq_9`uHlI)L2s3KJcp
zCwBh@j?OpX(DL%#&lXP!pMR=0+g(=DFJXZNw6B*~nQ9H+O3{)&dT$MPotO;4b%i9{
zoIMZb_N1s(l<25-+9C9UGj^@*R<cCtm`CCI#(bxGM#3k+Awx@S@GV=nO5Os6A!ocy
zA55g#9R8%C^z;<SX}fGMcvxb9OMdnN`kTyd@nUQIihV=yp{cTV3kc@#{|x3$yBx62
zeD_|TWmL~&?&(K>v#K^TXOLd5Fp)q??hlWHW)X6E<aG7Mi1u#RqjuAuuSjO>_B$em
z!`}<kAEEAXjg_kP=Z(?ol6<vr*SQZg4P8(TWK-7f!rV&w2;BNJo)IVW^E;uJ)tF&p
z`yo{~uo|vEUKE<mBC`wI2_Y+_0C5vS*aZ{xIqrJz*O1Qd>MxDBVDGqk&Y!E3#{<CP
z)&L-tAlBp2fbGBb$3fq&Z~NL~sMe||rOyA|lVtaMMrC`9%m$U%q=ifyKR2=rWQf8i
zzfcACi+fAmJfGerzh5gw5=v78iRQEu83^<G=T2X{4L^m4|2qw!SYUfwkAS`~idyer
zmElYj-@6<uGH|q=XgZQ~P|%*piM)9{=rnH7K!??*BvGe0ZEYp(6BJpix#0M30NI^q
z1Tn9Q{EQ(k0G|DwyCV8gH`bBiZJGj=;A!$PQjUsSwV=BJ@Jx}=i?AkAU480@a>~{e
z{F@2#iUvHT^8DL#>8r)}_s@2g`%eFj1zzouL-0+<Ffpw~_tQ4=B4ya6x+K)c-Z}Yq
zxDHgVOgk2^-i1H40CDSErjeO?WeeZ99VCp4+xyb06jg$iSyqQ$x$2l$;g5A+tsCxl
zQCvwt4N9^CObQ$xpI5JI)!%@(Sarvhl!&0A#JC*R>j;naIMAFHboY4Fc{3;G1D&Y6
z_x)$sy@(rT4_8cnZziKK5~<anOUkvYbwz#5DrS52eO}p;l<Rh5aou~LHY%7;?rr#W
z5J>U3ZXA-|2F$q$IKXBoh(5_)^=+IE8!k0hybqPV8_oP3BSyYsLT>D&of`C}fsKI7
zJSb!d-~DkA+Gf~u-CLg<)9-ObfHkYEBW@tjgAz%U33Ru=YytWjsfp3Q28Z&$qxDB@
z^CRT<nAu9DUHz|y>V~5xffn46ZdBhkxr1^zN?|fJiOrnslIVKcKnz4VJiV77st>%t
zQ~U`t1jPL8G5y`-?#;=mdmkb9gc$Peusp+~_vm1=m}4ewJ2+1s{?zWb)u;B99Hw4u
zKz(0%ukV#b_A_)QFR-4qI?XE&>WpVWV#&il_3j5Knj3x&hxj4(ngP&>NJkZTEDB7Q
z<p{1<*BZdw8rs_Z=mw6Rg%RdK5nqyd^WBc!QStK}N!>EV>-gJl%KbT(6#b_){_5GP
z21aI^!|Nl<2Q$4KhnmkuoiztHnPj323=Wl_cv_|XbkV@GtV5tCYrktqfx6l&Kf2`!
zBIms{USv@`=bUw1#MDYff#C(C#y*h0l{f+sv0b@{=+)_P?baFsxV_f=%egUuVBSN;
zD!WJaJpaY_lOLknEMvWnc-GVS1Pl5yDBetU)oQO?lvcD|_0GNM{=;HsDmKS7#$@#^
zPt}2d55L?=_I~B$j|iDAVcm?fYN8e3K$d|re&Lg8)FhL4d+=L(HQR)xQVkIsV(Ie=
zL4P^KsxMIm3TIhkBbLLN*f)GRXL4eA283Iqb(YyPq=eKpmQ6Q*$)~!8^O<Gqb;a~^
z)}f(aYINM}mJfQmK3oa+puCFj1N4ex-13JDCL75LgC;G2Aw)u1U>*YF)oO<&T^G$1
zcs>|0T#Xif;7W3B{;%HQWCU*|K-kZjq#2nF&YKTD*|2Lh;Brz^>{pJ!yf1m%_2D{{
z*A7xRvofZ0uJje?(E#lU$I!6X4u0XvH{0F!9=73mZ5J{&-xf~J&I`1L8OW%mceHwf
z2nk>dkkvRXc1Oqt?bo*t=I9$~k34u?j+|a}Ja<#FSGom|!k>PBhZ!bvHL6vaEM}tq
z-~y;H!P#WJ^LlIKW|iD{%RI^?g`XrKc{a`|Wj7gcRa!iY%+}vL%zuo!sPzOsD5PU6
zW$L(Vd8Ao5r=qoq?(3Q3_B5NWth?}N$ly(l!H}Bt(>(>Pi6h4$=YrK)1B6w^H2+F(
zSxBloN-zp_`c|No(acy24#Yg~dsO$H>E##h-tE=mn2xQIP=&lF+hdTI?pqqthxfU#
zuAW&2wQt*<xOB(Qg#^Z&L11<HNYXbWUB<46dcQ5%b{N={ne`75;N8^~7reQX#|lFq
ziN@M9*N5Fix9u$&u?*RPOdh|sTBzF0ng@~=O#q!v_$tVeLu*If?at}lB{m57Q5~0-
zwB1V(l=$P4x%EzwejkGY&Q-k0Gyq8nSb>v44k}t_!u8<43axK=mA&&Ab*|I2J%>A*
zSBN0XBy#Np27?7A+(yqToMSj_6WFs4AjkxEQPys~3OfCS1ug^W{rg%ft=*GE=(hAy
zyQuUp6mOzS3y<Cs)C;^x5%5w-_X|udQjXN|LS-+xFTAscM<_YYbgtU*?;n|HZ%wW@
zwaSiG4|`1(uZJ(GLO_;lO#>BSx&3VYIOWWPzXG7GaJXygrPOy_j&t$ZSjmcwhNsOu
zF_?#Une!cRP^dz1(T^tT#XT3>LTq6j739`IL3Pe$P)p%w&7TYhjbecKg2p32J%pka
zKnrpn*^nr;lJD*>o*ULLS|<C=7d}=<7FOzt*Z6WvfaNqrWZa)MnQQ-6S1U2VPjgrl
zV*Ru!bBT(7=5=LerAyqwJL($d^PvCB0kqtPTJ^WIAM9zxxyXl+0+86xuaB%^b+VZ7
zBf^EsWmd0uqje@$*hGUqhta{_!;jWOMV&*|x|Oh9S0{`5#Xc~96L-&0p+nEoes>R>
zFMFF9959pCEr#w&zyQD;KHH4+&@r79+cF>BuL~ZXmSIpkxVRWrn{&p}NZs9iD@a~P
za5KRjr+OHSZ+Nd**`!mrYXD_`Y^y(GFSeg~c-R4#_o;{=A!)_s^3CMv$tQ24W7$_n
z+}?;+nVxi&NSQe?!iLO-JeymORw}ZW)(6AeXU`QWZ28a~1t9{xc`Du7Q#Qt%N4N`p
zF;$)>k)|a>x1Vjr9PPkj(|NDf>G;II<KqGQxc5QQxY2u<AabpLLgv2RWm)g6)Cy(l
z*WN*USIJME!!z+}FdYu)eayt;khr}*+`sd&$>>n$1&=p<<inp5pS^QQdeP~jOgXk8
zII^9MAsH9>*1s1#mJD-_KQmQ}n1kS-h3gqS8Yfm<6N?1d<VDkz6i2(x_SRj8Jxz3E
zx%}L>^_NyGZ!qD5JX}a?K7-x9gByJNUPfk4^e_=V1Y5HmPn_qX{EeRx6YCny`(CaB
zxm+^rM;?=$t{Z6?j&m-qvz)F62w3?>KKA}2k?N!OMdYl!n#^lNtxgiqvjT+t^OQ9N
z-#Ol5uHe@DTbOyimFk}&f6nSG-u!xawAw*JAM+S7sqp5QN<`ggZ^S)|ixi;0mgR{m
zE$r%R?_4q95BUcru>#s2A=*bSpHpiOlw4ywcQB6N9U1^kF$QnHzAA9|IEpx9__hN^
zqONUH17zbk`p~FZ0UMrSW_qbf)0EeTO4C>YPCL31{jstQg~2C<0zgaJQ00=RQw7DY
zUndbB?+0k`Q}ag|3;EIY5+B!T@p?Ml<zR-J)~;2qrD4o|vKv_(GyR%#ZNH4Z6vQpA
zci8q|ca}zoR@$?EUWCNalSLYMe2Tm1VYQ-E;{e>md7s{M?2EK}>}!DFY~Fi@Tr3*2
zn0~F=ok^XbX=ZofnyV+O0c8B7aMW9J$&Y98wt+mv>qnQuhD?GHf+rrrPrZ3ICRkvc
z&z&)T<mQ?^T8Wk@ZM!{68)J8Hw|upFM7-_Ouj$QYb<?i{C2s`f=n^l3ree;0vC^SO
zo#8Bqf~Tn;N(L=v3eZE7ah|2W#>5@s5O)nvsr*hccq4b=w?8%bBjN<tBYzfWZo6&P
zVK`!%Pr9#;3#<wfs~5By*5_t=5=O<JQO}y|EO=sswB`)PYHlS+?zcyjl43xh+vdso
z(YuKVM3minTPzpdVHN2Qp|eO2C%UnA)0n^q^kU#r+R61Y(QV8ZcE8ODI{dP8Jkno0
z5d9{_K|`EJBYM*6hAW9)TK<2$y?Hp5TmL`48&ndaD079-HWWn&bqX0GLu^w>NEtFE
z<1Q7IDZ?fSWr%8H8!``}%tKUU&alZm&%^${?@i})o^#IgoX_>UuHPTeb*`styYIEu
zz1Dkpy<hLw$~V8N#&UHr;%uMOvb%6r>;$J_2#2AJN`KNMt#)M#VS*xOt=upq;Hnds
z$GO7WBT2#*gI?boRWz5hjBL7iFGO%05KxE~vUbt4wrtg>NnF@M`5)g}mQG8HB+e;C
zbyjh=?visgRZ0Ss96xdYvhw*~MZ79MdXI4FZIj$VmCz=dSDlLGI5fXHi5g6HK@+Tj
z@GV0V%oG`UHNJ$<C~f-0&B{k4u4jv?gk?xzf@z=0z`p24X?ElPSOVUX$JqN-`vU4n
zZPDB3t2v6*Z><v!ky`QTR_FSP&BK?2&n(MzZRQ_z2zK9I5b9b@ILY9J^W#)Siyw10
zZ8fcWky6QM?i*C~4AP4~uP|>3V57UWj<A*Ny#9a;i=iwAq&TVgt#SSA4HtvlfPtoU
zD;bw2TG=KhT8Wsj1&7H}1`X4ZiG-^?d1#+|mCwY5Upi*{y4t_S*9v~)vL9dZXei%&
z8u&3tJhX9IIJJDe2%frRSZQP2z{|8TK<^o-#f4c*soxq}VAZP>OpxNTsfpkbky|}8
z_f43TlO^f!#5Z!#pomo1IQm`BREr>rN@Rphg2DdQ(aMZxLcQ=IcxpbPM7NDb1d4YH
z*TE&C8|RW)7!QfaHC{Lv@2i^o*3fmq({&;d=rQaC%TvUbjB9bnu@=?sbyZgLVIHbN
zHSDj`T&9xj9J1Zs8uWe3dv!HHQ>UxxNSMcJZ}F4?aixj7Wfn!|!2Uij*cmYg<GC_I
zpmh1`eh>~z3got;GBvHNRF@86plZ8nF;-CY7_Sp^nFguqAz;pyJFYv>=NT?xCe3D}
zMH)qJvxg5x1yTl9o4~dP9w<U>LB&PR`|d*K_{+IJW-JSTiLg$8-vlTWa6%B26Lk~z
z#p~ZN$DlC!>lfXE`f-R1Ty1(Ub)O+_r}4*YP+n#D=a>A&xCo=}Ak~;}ZoiGvswQp%
zh6=^&9&d(A2O1(JcA(!xpY1@55#AeT5&$W1r1`T59QaT(prj%HBNBRO5$Dn)#fi?$
zey8KIAi2Z!xDpUBjXR$430$yP)J0`i;0TR{9tFw;!-6-E(t{^d@EzZ3RiZiNFcGrp
z=7>AEcEd*7I@Te<Y6PP*(c{xp*2T2NiC-^Inan0*6nGZv*6uiPuSLVOI57fW`^L$f
zS0-Q#|IB25*d04{m016BY@y!q?lVHZz_Sx>*;D3nPNDgeUI5JCZx67ompIzmI%liH
zkUkn63CHUMGnC%}pspdMG^6dtv=+(B%#ih8G+<2)qEQOv4@4(tm$WJqDNmsGr@Mc6
zJX%yj+_67v;TV_wgL$`_##7VZYpco)oL+U>dc$j!b6UnmBOFHGt;Z@*>C{d2_)ukA
zPI1GF3K-nNE)K{WU!25~4<XZF!+`Q&FDWbM(hoY+Zo~nImMV4?x`UB20^YoWCMW*e
zDfx#ST9(Q6wCH>D?HY*VJNTi0G`&C?HbFcyG}Jf&k)p*O4_qlP^}SjpS(|QLcNTVv
zlYgavFk&~O6p_OUc*EF1`~lc`NG0<GaCZR!ddj;4UEF3yam>_AN#hoev4*nF;K_YT
zN4c9LS`J;H2n%ChrS~ZGL~2!XTjd)*81ke=#bm9j=QCikrLj_hZHX%@sEgYG!T}G8
zcur_wgG_|tBGOU<=ID_dhVsx^c@*ES-7V-oVvN#c13yqEM;4p}bN5Ean%dql9BiAk
zk-2@&-|LZwhamya+j_gYt_B;^t{2AO;hTlG>6+*=EqPqDC*!8`ew~MC6g|+fw*c;m
z_$&Y|p}`Jy9S|DGwT?E>Y1yU59re1;lNPY`iEuHuJe|l9dbdLV0H4Jb3Pl@x%^U)~
zfz3cPEh+{M)M)^B5LdgE3^Cnd23{}BLV2sPEZf<VtmVh-bV1a6QoFe@+A*i;<orqk
zsKP#a2iJ8b<1I0dr05g$6F1$t0<Q)bn0(kh$xMOMe!#VcSm$t>u`JU?x2lKg`_Js<
z=%u_Tf9s0BC10*eL*G5+24{WEgFJ4_$ra^9r1%IV+<#g@<>MiVJj^U5vFcMAteCyS
z{5zN)6vs{U+8M{5d=j$t>3Ji*$3iW9E4P7O0c?YRTAM(=eavZ^Jh<_TtQf_vASFi!
zrEL7njy;z!lnfM%AFVENbo_>F`+uH~u<?`g4pBi5RhrfIntKw|(+ZC^LMc+qoG!61
z6B4F>m_)=Zp%F3Vr#UMem_<%?HymoY+2j34`lDLR!ujCv#>Rw`&-zM~q%k30PfIxU
zN@f?Tm-cogANX{iLo7XB)pjdojKbOvFnIrUc9l^pQgb_=oW32j@ZCk$CXc8(^CLJW
zxN2F0*}4R?$Dc##@fJTG-veyTK5_vQykRSQIZhyKfd4k%V(caq^FQyCpWx-+?|h`v
zu>YU8>Q7+tANCGB)98IAp)oz7<@WH?jYN5r(1TS)p=vU)3opM~wJAX=WndU<g*Gq;
zEcV0<qhuF)?e=iEOS3^!;rvRa7sFSg0uQF^hFE7};i*AQ3t;VhQAFA`0}eCUu&J^-
z=@ZPdU-04++0(c7dgEG3y}<;3+ChFdj*w<s`)q`UQ*U~#A`sH_((PcXD_)*Ws?8hE
z--CGO8<0?mUjFvXN#6IO^|V7mLnbacVs7oYxXA)jlUd`3gph!|u?#=9w=0ETBAx4{
z5&)M@PN|piq)w#3>K$LJLMPRR<c-rnFCpF_AG0W_=L7`e-N;TsR%H{klCW8_Zyu|6
zT~8IVJ*`Z0rKE-}h=Dx0y+sU9k&14-O(9deI%+nqpuoU6BzLU+R-0Avv+m8mgSUTF
zS*zdwT4iNLJul4^?szk&Wfa=Ks%=OO4Y4j)B=PMo!vNg<`hfd5T4?&?1h$kp86Mws
z$NuCM?v6LMA0F2Rr`Uhkc`+I`N!dDJse%BOayG54tvk?sh{rxJvu<gDI>OxndG-5q
zWnBj=fNBF~GQMyUf??<lCL0VSa1dJ`Hvp@tM*;6E`@08hwV^0GDbuYdu-Ho~8j{$h
z@wPkZJvkVA;<0WBfvBXII|(Q)C9r7*79~?k2|Xm4??DsG!36cL+rLqx29d79bv{-c
z3mM7a(9%*3UiMg|ZiyW<vS>BYUMy4HUYSnSdXMTZ0J3)hizi1Q<oW2(qG`cwfm`uM
zkk1fmv{LzVwBgQMj9%%>@x7*|H^o0O0E>l*jP0+#F6&r&8Sj=yV{mL1ey*1UB^nz<
zMG{vpE11b>zdf@rPVX?M)H6L(+ndfOl9;jKBT+3El3h+<cHaoxB`wU^#vyjDpF$~y
zky<*9mu8ePtMO7VF|A{|x!Mx@e3x3X1J1X|a=xmG(j@W$PHfvKQEFRW1xJ}6ZD`1}
z*RIxT*P2_4_Z;-y*N%#t%G<OUJAL$^-DLag%n)Pz`<DtQq^V!dol;&Ls2;D3aqN^a
z&pfYThF+X=OsQDW2{tYH@*wTi&hee0R7X04TSh{t&^a&Y$7(daaYyg$#hW)6iK{!V
z1`!_z)b5nFIpaWSBVrp5(G+=E@G>v0t*D_P>?Xy!-+2RtdTXRI5HmuD_R$jxvmbxT
zJH1LsyW+Vr`hAouef8y30v0ek+RFk7tR32N^&L<0(o#z}ReNIOR2mxiZC`%ar_V^u
zp2LaR+05ov_=E09F&+Pd;X3!RQDSxv`i%^`7O>KUH*&DQY&$hpt=4@NKa^anvx=rQ
zm?qkLMk<HLWrk0;xQ-tloc%i1lC`<op-ns4!}%`1;b*~7^s9=F1P%c#bNcBK_I!2d
z)8N|!^eHYrKhAjhmwj8So$?gzZak#r9s0f*D%m%~q1ZH67qgBepFm|l`j34N12F64
z4kOv$_hljlopLkg7_@J+>C4xk4epRhH7!>uRW{RWS-w9_oQYKp%S*sdhzcw9wN%%I
zEO&xz6hl-NS3?8qtrEp{(^Pr<IT^#5hYTO-_}QvDX!bYIqR*TgT<DZi9(xwXkMC<T
zAkg$s9s2dt`#~g;xOwB`JnA8&txzlu2Nu;(1RDj~KzLMKM^vqxJlmEgpWg1?q|+#T
zJ#l3*42v7+rD04o#Z2}cQY;SSDxOuU^QP~tvjfu8vOcg;e6Kyg9Sz;PEu`dAqXi~h
zs8pq;AupN3q(qjr#Zw&)EKm$kaU8G-%HU{dZu)5^2E`GSb~5XDHC>mau7`W4vt5)}
z0_((}f27x%!?FuDJfpQ}OwrkCiYq*|WKL&f^Z|pRU~-=gc0{4SG@Jgi81ucJ7~cSb
z`iaWY$A=!@*DRK$Q|_mgl)a_NN)fCV6$rlDS59_4TRFW1@JG@SW7B#mTtGn`gpx~0
zn-5}+)aLqTJx=PRxxLA7%hMx#zNyr*n27H451l4{!R8<K(0fgzWGw5L;d?!t$5-e<
zL)=v+<M_k$-ncaRP|YbVqhd!*4pP~Hmg;5pZ$w&?_>(y=)Z#_)`i_@?l4P_@IXlu_
zdhf&*lzuVT<1!2lT9vv$b}@UnZaL-FTnXbHpP$yE${UBjBs@7Zem=#1JUFaBiL&#M
zW$G!%Nt?d4mdpT6%9b5y(<Zvrr;5#LXFeRne+xT_5AowDZr~@DC@$F8u-QV$$eUyw
z-vC{Q{d=xs7nHamqiU;iV9|KMsig_->Ly~%ExmDV)_DR*-w$Hc;k9$zQ#~(Yi33jg
zI(80<%dWJQ6xzN)Oyh+Id*!5fwMh=zErSmuOdsP)G5q&&6BQx;_OJHpa@`A<5v20h
z<rAk>x_hZtD7d3w);vI+Z=b4X+sjkWDCDj)YK6$>qdr1+<>iq!ZGa&Uua4RvC@s+}
zPg2q{WxN2Y((>CZjuRR4updW&m6ZrVf6#=J|7&(9$jDH$7N5)fs-i7AoTs3qUhSAL
zyV7-}moWBRWa#;Kw9T%j(w&f(d8v!y@vfuWEDGJ8tc)$lR6eCxYv6lpI(Osq)ymu)
z;ia_bs&KJgxb9N<%51U2l~OXRAy<Xls$L3c@aM}ujWy<8Ir&k-zF8w>iy87=jk${T
z?m{{HArvmB)Qdcz4>rA=eX8otrlIQNW;g4jw9Y=9opm-G2M|;BUDjBE_BJ%TD>7b#
zQm9F1ZC1+49Ej489?OMd*{0dbTNvk_ZzhmX4m|p-a%meq{PG7mpVT;v=MPK87GCtq
ze3Vh2Z$Q(vnqap`OsHs(85J;;d9NpJ^&q2qn~wN6HIvv3huy8)p36zJfuUl}6vLm0
zKlJW8+tD4)t^4lM5ZqDv_=9nLd*$%GSe+_whOZKvPH2}@d51bNwjda+rv)_JlFp^U
z$VXx1LfF?K)@wi%_(^GUp!SD!1O7!6+e~)(NGj})kj|Uzv9VBESf_|=_T!Pp^K+oJ
zFAFO(R$LFC$ui4vt`gQMbo0x|5(=cudVbiOqgBttt<hQdd!3rFZ4<qYIM%a$KJV<+
zfk^BjCl&M#bax=<qnLYsgdR2acl4}|^g3BXiMWYtxE{xS9HTwG*Kk9M>{_RcPxGC+
z&b^CwZAzs?aV<CSWUo+HG^fs!^>*g-09hb$2|~01dMx7XQF~I2O^XRieO0N|rX3k=
zefT2j6l~0xt``n}G;Xi&)M)Y4L2hhEHiq87oFZ#aYX;C~e9_%kO%%CpC>VDJxIIed
z%-%n-n=Dh%2t2PZJmiEAH37E658iXm7Gn`DK>M5!Y&kf7pncKJ*=16n$z_eZG52IP
zYvSEH7?TpY(a|#l*}RVko?H-Zx~)eoN7d-H#+Dm0i)l)%Oi8iWBSksb%!P!c?SOP_
z2DSnsj?h?k3p0uJ*rW;dEQO6oLJqUZC}t+<eXDjwhCGRPyTkb5j>1mE!$~xuTTc8&
zj$9Bu0t*QDhxYvW&kg~8%+gfxjJlY#<;1za{&b<u4%TfWRenf|zQalO-iU(20V@D$
z+z%lM^-dIGy<sBC;9gGwkrvv5p`-k7Kf!&5lL70qiT2ush8i*Fz2nf!^6OHhvuh#s
zm%SxBpUeMsNWV-PKJ5S<ICSVV7>$$_qJxf6o-YvD{biaze@O0kKGV8x+>zuNB|T7D
z<y?ypNY?pspKikh0j3mOZ@P|yR6bGlJ_8q|E8jO#dYJFujq7UZ<9XIIv)_gRg@iv@
zPskx|oJJh~&yt@r)bmELR``0X=OS2(7E;zb={5i}md3hn2!#V-XrkhP->VMSlwD&j
z8jA}&;S&SJq(zF0?$FJ!Cnfg?Mx-%uG-m)wEb>W1Z;PL8`VvfT)>Iz$E%N8_m&)uV
z#R9i?WJyKx64QAHZ!*7YE3;}@7hlCuK~+6HJ$cL|$<UF_>-E?BUC|bjSBSDcKnfza
z+gp0=##*KX6lp4oksdOv^NC*EfNG%K2gO`yuS^7+i?mlt>p*)Y+1x^RbOaEA5u)fP
zjBq#24J7!-UWfW>vJR)v{II!IC)=?@d0VQQ7P3^|={t!g>mgZCW^?mew>R?Xbx#_5
zP7TO8tpFtP)!bcA9C*6Gnd*`Cx%$B*K!*kE{z)w1-3ix_r%ABwFI795w@S@Jw+AT3
zSY5ZF9aH#mQK}0XU$m3dtu-75{Mu~721xDAt@+2M0xk7ZPn=Dlp&pYJOM?8$xoF6r
zB(dpq?*WA9kJ+E#kD2U>skoZ&xFGZ%l~~|7UN96L8MkMpW=W<9^(MfIJLvZEXcqA?
zI+-A9-(LfoFKlb|5lPVo*eKHKcv5moZ$1+u>T@IsI1>IboJN`fIzf|7lV4sZ=o)l=
z*1nv4DoECxOp>08R`N_~zaR^1I2H_rsgE=KQ17|Mo6oQxS{aJtfU63^E(fAUgPZpN
z|D!mQUO_oh;?mOG=v!YdiC!7=`_iO=3$yl#lJzTdSqQYYe7`TVnI}S&VxH@I?VO&E
z)Qv?~=NdyH4LSPA!KSPT{l({PZHmJ@DI8J~7?C@2?<<Ely}!eu4Tsi*Y<ggN2k_ZY
z=YdWPL`MX`kDr{J)4l&6esPFH%M7vvg2~b6uR_C%A5dRGTF!a%X`jV4jBQ3$!r?0;
zTcS2aI90Y(WbA2-JQOgXqWBt1iy&n(!M{$hMu$JCc3D0&9<w_XX%;uksV6PD?$$<y
zKyw%~*tA4dOEhp5KMIg>FtWe~V&}t;@*Zz*;FI-y*chwxxJ`X*N2r@6f>klRm_!c$
z2UuV7l%XewtO5h`JsPOf-pVhf=&xmQG<6gA;cV3DJA}>00n)n|{Y~o-z=nE2S^>ro
zqIZJ8TOcXWm*_hokd|*4QXIlQDy*UVY%0t=;q^y7U49bdRiS|t!`lTx_ECvjE?P^y
z8NQztyVB;2^HCbgQrL0_sjz^pIqiN$?-BR_Ychd>EQJCF?rFtd+1;`$y!2lF6?ClR
z7Hgj%d)&g8yPO>7_ICf48r4|wQX=MqUcc0)x>X>4s|!ZmJV$%S4j%aT-|osrcgUw5
zX*?+b>`XDzU5dBk6vNNctrNK)7{||C3qSBM1kZzE_u6avK|#<-@{8d<sKNlp<iD*N
z75eUkRk5Aq4$hYccW@F9$t_Icyu!0NWqVBIuCkrM49=X7P=PrCK#%eR=>H2(CJvl(
z4<i|eB@5&rIB5)lerEs|pD#NxRzXFdmr{0%T>I>Fw2XC$<KBF~a518_o;cB3?0=5u
z<t}vL(YX8a_Z-|YuaBCY>nu~|A%ytwG_>tPJ^07vK{o#(QT+Ma$ImZ_>M=a8k8^Y5
zlWK6&KmD4kCxmw=KZ9KO#ff(~kHW_P{Tyk0$a4*DyPn$&A1Q|<dFvYJ*BfUKH8cpa
zT~P^5$*x6#I@*8RTf!}|XB9Wg4L<5mFA4rA-&0i+Dk7P@kKIb0mGg_*EB&pN23pJ~
zR)}o!p|`UVR2zs5oXREk1StAm=9cffnX&Uu9q`D?dLhoM_XEUX-J~oS%Q7H7;R*y1
z&T}K_<bac0&tO9u-LgyJpVzz0Exj19%zXF-IH=4@V-ImhpYBx|X*dMktE!cH*B;0}
z->Wb0_(eWJK8)8|d&d63rdKA9t)1Yj`glnDahjoyGisM8E-%dr&nD;LYghJNMjG5%
z+6t_?g<Yq+y^KEIEN*<Qfs+v<cUqiCwFu_FJt=!5z0Xe!f_U@F2%9RrPCCAJd3pei
z-R6iuYb?#lm!ws4)34XDlF6x^r{F(2Q+1M4L$Lw65jY=4Fog~ak}{V9g2(U^><EV<
zb#1wRYH0_WCbeKRQdl;}uQ5``Bs%bhVRln%Mq%%*YnURp98fC*ak0&J%GCN<(WpCh
zkOGBh;pv$seG7Eb_%X-y-_xPbQ?+4F+*lUEM@tW|5)Ide>i`Kvs29vudO0(-Vt?vv
z{G^U_Hip_nV@aFtSb5B7t=2WL`D2bn%*zD;*!O}CP6Mz$DHQMHG<#X$*~7*kr^Gi!
ziO=hs9%x_#<|R;dNo=}6gYO@AK|rdT;`rlz;!p}lgqHvrEZG^d1N~YKb4Hikjfd#$
zp$G^K4`NV+xxH(*)(gm9Pe8o5j>)egf5t{;o1+dR_$HXP_-_QeSp9s1F<0*37TG0I
z>?K>akGr*=|Mp)W3w>v_6;jJ?=jPTvj;7U-=1=fc(S(mza-NN8)&M3JusY(PR~Z<K
zNZB4GNv4G(f#Ld;-w^BuKH4p4Jvhj{Pgf<|L346e6KpC-9$5hC5v(y%6?_jeL`di2
z2A}nA&=LHCd?M@0KAlU1kwp{fKpD^Y_WwQ79q4qS1(}v-grJ@OeNasS7#()}e!&Cy
z0|I0lkF<TGzQKTC3O}9V#m7`=(zrwT%C&6%O5|GzLJa&LKmXZ-w~ish8gpO5Jn{+&
z`lJpmZ7P5L{jZN#hu+z-d<;$3k@<q4N;g%o(b@jj|MAZb^^WgFv~y-&B_;V0Jk@QD
zWu5-pk9S{v>he?}n5VKjMa5|UKtE2~5DJ?6jk&)<piV`$#R%U3bqjVBe1fMCBsq$>
z>tY4;q|?x)C&jv$*Gx)wKBm)Bhqq;ri(E(xKMG2QNDu2BN@#wx^(e{GU8;Qg87KLU
z=~WYe4IuaPhED4VBiTJ8<y_PV{3+sX;ZoD?Q!>eL*m|cxG0bJ|IExM2dWf5WUpl}c
zE5{67kK&&pcV0~ocJPeWL5h8V)fdVK`(`1bZqv|`uBzk(h;kF)pQX(q^lG@)Rz(ys
z!{m`xB2{hLZ$*49kLAQC3aUz6!gMXC6f(C5ql{FSy*c_lv|AS3iAlYKXd!Kgm|F1T
zW_FcWK}ze_5synA4@oN=UCXqZo9KoJ`}k&Zz;CS2v9F}+nXFG=j(z<*QK8OBRVI-e
zzVE`1W7Tgev3yvfm3>v0A;y8H)Y`SLhW*%Yi}taSYxP1GsaTruY96XXb@$&USCwr8
z{#B=|>6b*crhdQ5V8n*>AOB_;pR6aL+L@nT^e$XxO@X-jMsnKl_89;~ke+1c?FY(&
zOm8LJ{ni;8P%t`fH*-&3FXD{QuAMO46&dD>9kfsnP(gh<NlsoK*t+ZQKvP|I;Uk5K
zGMat2@IFEsI`8Da)T~x4Krz%MQd?UU&C&t!^j+NrqcMHreB9VBDY(78_I#`(hjIwf
z3gjJI8AuTDzUY1+@6z^^r+gdQYL`-i$|dVyFvgd+*Y#QbwrPI_a9)4u&U|T;njtzr
z5h|w8(36PhGL|kcykewGAs58=CZ*KmmIRDvvqic|$FUnDgWQRpmy7x~D5US<h(eKO
z6waN|tUHmw@yhKAUZi8mF?h>3zIJu9W+~M^1Fn0kXV(~HBoR_1Hx%Ma2*M{9E+7A0
zp{DWL>JT5KaU$r}ZI#c6vCwjN?Y75mrbSB&E(M8h3Fe2jRyi_$a}uA-Fo=v|TFM^O
zaeqrpcuON!xH7GUwZU_Pr@iF?t5l(mXE2mKDgpgk<IIISWq4q}mt;!|f?y^MPz0kh
zo^V3z8iIqUUQ@=LNkWunUflD9&WREBR6A;UJgUNH8+|aONwF3g&38phACs2uaDp!m
zqBN14Y~VYx6d0REpywZM;Q#2(v+w#;DutgH@`n33Q2Ro1Q{=R888d2aJKyGGUi~Bw
zE083#(z1+%KAV7!0REw2H^>Y_{1Bxq=yEPVOYOBC<`FgTv0@79dw+crG@Y*Ts~W6u
zx0nqFREOPKyKmV%YSK6-2%1zEPcxj)cOLfbki2X@x)NJdt^Uzb5s1`4{X#s3AI}an
zj+HKk2Hjom#NX_OCfMDTU)3_bw)Z|m+3Z1l2m(j|?*+`k0m@Nm3JB;MZX4$l3mA`H
zoqui&nygvL5cO4PYz>mdF1>WKE|0GIOuIxX)K2aa;M^WLZB#k?r`PqaG6#kp9uJEu
z(jXl03IT9<;{N;t`QU3_IJ?O>eTOpu((Z5eCQEUhXK4d3xkz#SE`TT*rB%UQVUbSD
zQ7h(h*(3ToCs!50apnh|o=Wr`>L?(0m1_%yIQb+e?Ehr}0pORsa-Lvv(Y+9Neix<8
z;r{2mF2?Z(TK68n9~Ujz*}DWXIP2I6;%lFrGdDJ^^evofimSe=>%e{rQ#e6#seCdS
zRykv#U741tWI8#r37oMr_uUUNzY(#-CP}K$4!g{e&$e5Y!Vlv2Q<DjGr+X_O;7;#9
z4N-G!U@X+@<#Tv{+hI%*`s?(_&fAl#$_uBh5*qE^En>I8SI~$5++)VE*rXC2rX;ua
zb$LG&xL%w-?%$4m_k4~I<e4`7EztNc3fkQ++Tn9WZvWX8;#wl-Lmdp%$u2(r>lRTH
z#OFJfH=A}%*N2KiSAocEXn`rmxC@lLP&;v3>HRUU_ik8ufcYI+3mWOpPaW&45wY)<
zT?{pTW*o17iqGjd6;xFIvXSB0_lvnWw6;~uymXK2>cXNwcM22$!g4w==yZ=auD;57
z)!T_5;-Kpr;mH*MQii$bZyAC_q_7BfMo~e(VHcYI`HrIFO<SA&qN@LPn+NjZ^VgKb
zyEQte@6?zRgLsnpbC9>t$sXXN;fsIC4a71za{nUaT_9|;`#dC+ipl2ZOwQkq!d0jp
z&NYtb>f5Sly`7mFF-|+sL~q#H>puJZp%ywcHq^MNRZDo8gt-i-8x^TW5kwbImDq_K
z9yW)%dmx|i>(L4JV{dr+au>&AQ{!`dzUWqH5@da+PH%rwH~uB^nadv#(%#!)av)~=
z04N$n66X);0MWgEZBip>ag9<q9eN8W?gSlq@&g><HRe&r14y3KPKQ48X@}D;vxJy$
zJ$wt_EKh>gMBxuBz8tn|aBTncSU!p~HXVxW3h4}s(#ZD(_W4Ez@biQx)Iist*zR9W
z)z5AB0GBnkkUPRciGBm7;G#MOf=d6se?k2Kniv1_Hala}#o?kL!?6`6@s*Ivc1;$x
z=>cvx66&kDIY~pn)c=bOgZvuMG-Lf}O)uPMS`BIOrf{V7ZF{Fq1a!E2?GwyBzYXnS
z4Nbyu)QdNyBhSaqzD)p)DAUI}Q)7mvbu&dFkvZwxD%8hws|O4@Z-fSb(&UTo#WPp0
zay|K>obA8uimP7dwUjMZ-VEeWe;t?e9S$xd2!HA^JhE5{G5#I|^dhHA7txtcWv8Yh
z$G1Y~B2MaxtO<}ePkUcGa4ejsoB~{7W&mcxy32qN;Bm&E5dr{=>0L?7z&Hnm;pePw
z#G7|Xn}3^ij{_aAo1Q?A@|7U>uca0g(#fo)!awX9?$FzC^Wn7cA)b85$Q##!%7Dny
zfQ&Z4>kT}SaR8aEHT%r8=9$_M?Ug%P2A@SDX;M>~PO*Sv@Q`^K&iQ7vJ3{KlMkpb9
zPeEZhzl`cMHcXU$J&p#@6^<sbmKG;zH)SpMd^O|%7$c?Q=Dn%q^G+)S;cRnNqNzl%
zLG%@}xEM%f!{Y`fWBt{k;p=C1h}79@=i1`G`Ts}?Eqz>Mb=Jjwc+Q3|+I*<ae7lDh
zOavG>-)<*sWz+0y9;khCxd0i|(o%kN^c!OCXBRt@f;vPy6T-{&{bPF&#D<HspuvWX
ztUD}_;ryWrJG(4Y^4Mghs3y%>c-}Jmn>{kNUJm0c({qSa7^fDy<jB!=G8^DGcy9)k
z%hA_GK_3oV4z-Ev7WFLin$q=OBI|dp_`(_^oqeYk{A>`Fm?t*ajrE?JKJE`~t)$sa
z;I#b!Vh1ewr*i=i8IfxN;N6o88m-5jc#SFEox>c9T?)4~{XIq40E>TGiy#kjn2S)B
z0pRdN`i#|9YqEuZ4}PzmBBS3wZKQ$>Iqbd&4Gn;Vop}b4ccO=xKGMXs;oyHB4vrE<
zkYj-wDUw$Ktr20FA&uW=nld8E>kWcPwuK;Kb)5L4$+X7tpxs2)Tql!7ky62v!(d<E
zL^Ek4jZz!_9fF8|m^4gb4<un<>wVE=<r=aOSy}L;ldgzwH3)x(Qln*<>~rlBL`%Q8
zkZt9^m^~BL`$XxN(izuo-9^AAM11Y-dn&rX!|pQXUL~*UnIsq}WUv-M@%-yrD|hSy
z>PNN&Ybv6}`Rh0O`{6=y?N}Y?e3orQSN~$c$$Sx8D2DD2`@=wcZvDr>eO81<<aH<y
z$_D>yCs6OxDkQnX#$6{0|DX3mlp6%Bhb|QR7vFq_FdLT;)+ViubMRgPf8F*YwNm*3
zHrE3uuKVak#LG7<9l>Z5qI%ly$ejZN`)~J<>VH76lfC6@6xF%B`1>3jBXL~#JBT3>
zBuh7pISf1ln_XD(IUJ-HDmw*S(L$e@ut2lQ%D+`gT{X_x0VJ%pm#@gS#pH&2cl|IJ
z7Dd6&;WrT>e9cNz3Fv3JcaKD`)lTPyn@BzOM?hcEUze~v--=$&({v0UTaerW;D32n
z=D~tO$K|Y$dJ)Hg^er-oT-1FAv9hjA>cOvX*J~ed@b#{%Ol#QgfyT(DV3uLWP!KkO
z6k;!#f_Gp3jRX79BfHQ$ab7sf?}H8e9@TuS`;Q+%g1xxOKkH1k_mE6OhrmEuj$2L#
z990uQOd*h9s|cM10G^f40k$+o@c2-5&>Qg-NFkL2%A^7<E3q6{vfd`5HXI{EJC+^*
zcIbY0Nz*sPe)+6+#ru5#;;=V4GpMBS{n2pb$X8l4Ae1|P1_w7w?vEH2v_0d&t|~3g
zACuRKcxfJqhY54mlP=7qytb?j(X*z63dn?0-I8s66aVv*YG8n$8%EDhztu&kW;VUK
zj>S$i*R8(hJ6BoV89U|Ns8H3Fnmhe%yza@C@l&5#*URMI{_;H12fFgthMW4Iws|DN
zJH!lJf~J<$ojUVZ=f0!mnb}AalP%d-Zmi7?n}pQsI1b1Zi7PF-syRhjSc5Pk8yJd8
zJjasb+gO*imy%Qr)yieFvjUM4Cl>fDcBQjp^%tdHZwOt!paTI}gya<OrmI%|WTICx
zR8OKD5TJv|CphW!;W3F(_Hb`fDOUX&s6!eLYBdjB0O6a!>R|sOX_}U8pB_H;$2?lG
zRzB4!QIaK=`mQj7#zuXO8{!pPilwoq4&GB9Uy&%ndNt{3a^ClAl3lLA3tV?z^Id1R
zZyTt+=q|$zd#&>n>zec>xb@-wu;h2t+u`B;>jIWJLMBdkb~3P~#w@X4IJ&0CG@VO-
zjlYx8{8h$rXVq;hk)9OC;zAAq(Kes9vk(nBb`UEg;Y8Nv^u?xgYkQO<Y$E%jzqI%3
z$u17}QXU2Ux8<bwmeEh<mrQ6h$KHR5bfH1BXbA)|r1%F>1Q-aU+nkc^m%90ypUJfd
zA1Nk~EjMehT=K4J`4T9(jvg);8;Q?Xc7oaPAjfKbE|tR^L&Q1CIu3%{Z%%EozMQ$!
z-$jdKcRBcjXz|f*E5}m|kw>NJ&z1!6`5uuj*~$NhZ$P~V(dT*h?5oNA`)~Ovul7n$
zwK7SChzum#6Ypgi?vjoHtB$w;z4hAunaxPaBR@&y@_rE{YiZcXT1x($wV=KqE_vJr
z#lM3h+gM-w@-;a3=1Zl?XMoH*V$*GJAgy=sV1UNn-_QEWcOpHW@0$YVw)*l>uZ8N>
zM~@EOXTZq)Zmm#vBH(~sH=Mtl?^NDW^^jidGigRjN2-@-L_G(%61cQ1IVL29<r-h3
zh8(tCl2eJHnGe82U`eBpCHNxYe|c~R*W!M={_vcM7+?0kd4aC<q^;?xLCemZIrC!X
z5l*siwe~ymgn!9hPCDzXTvVa>{P-}*P>yEl(jbzuA|3&yd|NN_WO182q+QiDD-CGw
z?t2^i;4Fp@fn;xjz@mXj%3$m+9$d|{`OCCTSD>ImUI)#)SHB$mc#xY#ca4X0oKasM
zsw`Z<$2KZy8~U(gvjV^ml?6<g<6id%bokuzj)G_ZB{?K7bA+_MsA1<xEUoGB*H=UR
zuqQFW27q%?8h=buqo614!0C}L6D*D7=J-x}BH0gl(a#-bIlA-EdH*AByrCf8d^CBt
z7Ni+J{nlobHOSOkjOJTZ8L1D}xPEUmx^Qb_onLYJuZVCaxCaqDhY+qgvb{v~;`qMt
zeLKeRkx{j{+>G;YHbaE;?PYG$qpuwpr9G?&hx2~!s-0ZW8j!p(W0duO>`XB${es_K
zt=Srq=cdX`hp!Zb#N<AqrzvssBMz;)JT4O4H|_~?dgPIyvi^wO$cvL_)^+=_@H0)}
z;r{v^zb-o$vw93U8T`2iH?{xge$$<6yy)E9PEzv<wiCft7~VVaO`aT{wKJO@m^Axx
zuyd6qzfR(Z_Rw$$WHgirTsn~{ai<M20l$2Dt7-4GOH8UgW=*p^RZH_-RMM?*2+5OJ
z=Yc+fBETI=o3~rC$ruwE0osHTgKHx)2TL8NI<1P-<U)QZ=k-NQ75j#H2H<J_-JcKL
zBV`(m>%00&B<j1|;b(TdXNg(#xH&om*(^kj)_%fBPWg`mkN2>=-gV$cfBr$GvQD9C
z_H0c?zd{AA3+^g#u<7(;!Rh^tWuW=KftN^dkd;P2Z3GaQKV&bPS8K-n=fUa;5`ZuO
z*mLNdb&K92q(-!C*TnIdHTR|O(#yPIdBW>#3@#&)_4<=f*4K@11o&$V<(|0NxL|y(
z{Xn!3lD@oio}Oz1Uu@p<RU2)SHI^@N?cz<<&38;co42v~G^OajUSWGHnQ|FhFy(|F
zJGBy_5!cLCfUm7*UkcZk?zg*PUmhpv>6&&-`I(G@v&@gWMb)Sjx91K6Hri1!E7FaT
zVQVYq#Cd3JDOk3K$PHnaL;byXX~|M1EPuJ)yvlJOtCdyM%B&EsOFmbmW!e2rZU+$9
z`k_I{fXR8(F0YqhdIO{>;pUjGsG*d6RmXB#YQL*<6@gXJXF9qaxj$ik!nTdKKU7^C
zS9n=%NiwB_tR(RnUH!KR1buZ39_2K$<Vd};Ec8WubD8h@{}W!%5y?TxO!8=~k5x+j
zT*H@AmwCh|x5+<UC{hhnL9Vs|8MDZH%d?suw1fV`kO%hyf&qn~pE0XJ{g7+7oj*u2
z#_i<F{cHq0RiwmW{n{J!4-5;3gd;&3O$NVEZ>;%;G-f*7zOa#pxvT6gQFLjcL3_`n
z&)fIY0?Ku=oLu1k{SCnSd0`EQ7pjraE7!AL{sk#Xq-zdn2;{=m&*TMef<b+u{vGTD
zZURyof~*M1m9miYR<R(N#8gHENy%z2T(qyaL5@a*@pY;DxMZOJTolv1`ypb`d`-1H
zvsX!e^+G6bvIeAKvE(;xs97Ru8dTk(?my{-5mA<^5!f>p7#w}d+xU5ejQ<jqal8+C
z6tV}LN%iuT12U_77VEdH6^#dDN1_5R7rDRabK!>Ei1{ZmU?X9KnUO13udL0c`YIb+
zTdR)N)oQ3p$zle9e}Hm~<$7}JuqtceS+(<(UZGN0p7h5*G0DG~=l7)d`v-Ucc@^t&
z(<lqz5MmLvG}>=oM(X6kJ4nF+%T=R4zrv|G7pgbLi@7zNlZGv)<2PLgqF|+9fsy$_
zBkwwC0dD$vK2VOEc!+Dh>?(lSnQgo@Gk71z40be;rQxI<>9lydq;Y%@WScDHY!es{
zNK*Eb9zy0@l_*-lH~8Wgbh?BNjiVuRzu<TOu>c!9uj}9xUs#81rI*3G$<^gt$CN`8
zV+=c)Q}&;un=&>v^Epl-xvkXVdN`B*4?UoNNaYhRsArtKzJ75*;cMBFw*uByq3p85
zK6=f{78XYesl(Z85rW-*YEX>;p4|Eyc{eNABHEUz|M-ns2*T;{3c}&+jry8LR~AyS
z#c9{QaqVgBwMm_%2PL2A3#_hjfnumHL7fHpa%UON%dLO9^32#~8;*<m^2h#hQ&9$J
z@<~g`LN{#8MPNNk8_=oleYp*R8Gaw(e>)844)2pXB7P{Y)tFo5CVahkV}$6ovGD)(
zWb7zWJUqpye`IJsy@y-5U93GmakmyT8=2DfWg7r+9T$H>dB~Q4_A#Vi?HvSXR0zJP
zET28$v@_Ii-{bxCQ4@s|Tc<Ni6(__cXl2f$$;`gj)X1)T31;G-7dE)r>BAGF@)t{P
z=s*~Tva#l5%Purq*4rRXy(e0*q%}WVd#*_>_8HY$A92}?Ut*@OF#=&2)SJV;hd8Nu
z^aDyCmnil*S@ldd*?#W6P!)L|UTIs+7Cd&bGbPu)gF?P-v2(gyPjy&<CnrZ5qIuxp
z4S}8|L7GTZNKhPRX-H5VBVB4%5H4O~ml@)HJM5aRE%X+s4sl^nuK4O<II>U(r8#cs
z21+iX$*3I~u9BMj4i?$S&Y1fNR!;~Ub8I8f_4H06(6du(%-CK#hfDzagOCJ`N<~j(
ztc2>`iM+wcat`fI>yGe~MyH{}kudVH@>aR=TTo<P^Zy#T9qXtp>h<l}c;~7CcoFfn
z?%sPTtP*mCQo<|=mbE9E*A$b*SC8JX{~XVQpogE7BGM)Kt!k(D86qiPT}r*H^&3d)
zGMnd>(>uzYYL~~i%kWt<i`-Bytr1C&Mu@n^8eUbY*z0Mc11qny>{#ANB6IR<#-Ws<
z8t|zm^pz2haks)~>HeTL=lv|Q{GfC?ARl`O|K1dEL91`4uC{TkrGXgtq?S=)Ji1K(
zCAh%^aF%3TaaiPlfM!>3a*ZhTr^1NH*OL)*H5~3gdH~V{w?KEX1tbSfo2Yp)7?wAn
z+3s?2oUJ=0vQIihK4|{~oagO5?mowk^TQtM*Tv+BO?^;tS}6*#4<DT`;l{tuJfYNP
zx)w5<X58`0i1LYtF@}kCQR=P8ngm?e!ezVov>FGrj&F#_@|MQmW~HK<7Hi(uBY<9%
zd(o%VNFVFvApau&gPp_m6TpBR_C=gr`eN?XTESco@<IPxRp2<S*z*{;Nhj6gzncJ^
zLcbp_KZAazxtmii-=@}PXo(H>`>JJVqj<Ks6oy6KbuHj=n$tN@ub-#ilw?VpOc}RF
z9wHcMfl|yW><9@P+$9g86?uKiNlUiyg%?NO*Ml}#UDT=zZ<cc|;LB!~q+)giYUGy2
zZ@n8QZ~wNBhV@a|lZjL4z^vg$YV_lPEpES?o9wII8MN`UDN4lFl={IPN8aQNJf)Z#
zy7xBD-DKkK=_>GrN<hpSPAn`p_ysYHQWkXy`LOFN9k=O~^TzrO)ac^MAtnDiXG%ev
z+VnoI6@XWU8`>GwCj0ocy!L+8FKBk18an&dGhkaIfStNft}~FIl^TQRgK<WPB`+rX
z{4ta<a@i(FB{$;y*oS5q$`lO;md9RuTEqZ30m3h07W9v;^)po6QMVqGaJidt;W7t)
z6A0z*ybfmBf$i&j_ODQ)29Ry;us{R?y%M7EpS##AOGV={V)QDEl`Qrpdzx%Q!ixm+
z`DH*vjVqhx3FK{G=t09r;?212Um?s5)A-%fLKQDad6;%r+X0p?Lo}`2nv6?99ya#?
zhU(uwAyte&VCx>zHQX&7hw_#0UDa2|j?Ai|?-h#5hZg1?#O!$jddUA~C{0EDK3n(5
z;4OJ~@HJrf)w>EMQ8jHv+EW2Z-jwS<<l2rS8(;EO2teCI5b+IXll}c;o0i-a1)?!=
z=~YhJ^@cK|3#TRi;hVGnPDp+Sbqy*r={!+-<-Il(nLo}t4{m?ZTv@xyBe1J!bKLfS
z_39Vyu@$iMwf8Eo>}g5?C9HPF6)f}(M2}=0{};;$O$D2)jpK2I&6<6)^3qSv7)ERC
zzOWLjB}x?3Pm<Opc8hd{;ijEgj>bV!`=_PwLk=yHTW-*%H@1etpu$M6`S;7uGuQ`Z
z0bN5B(qfm`olKeG23FECMB_i}dgOo>;cg?2POybw9h@(G8`thQv)NRca$r)1|KOVg
zz;_|*6FMTN)fe1A_+7+$LRno8$?1P*u#-3ROz|>{Y0Z10@WO`&Q(5kIHnjcG_e_7-
zbcHF9ba7HVR8P!cGpJuGQIvs8BLFONGL`n=HvV{Zo&K}|$iFvzO^xP>X2rK$(27RQ
zk0@ZyT*B+LvafJ_+7G=p2zoUZ(#QrOkpW~R#NIeb4-A4elIAv9yj)^e9mde2-HTqd
z_Yc<X9-mFPo->xcCh<uWZV79~A#7gq#^Fx_&6+K2sXer+cQ(C$KFg`)FNw*~Pz1PT
zP|FXxdjN_=s0+yXF>6C-Au0xu$t?;18P1K(a}z~Xo!HlFQTkZ6YZ0T(IHa-_>Ra^r
znX!IUW@aXcFizKs5eE~Z>&7a~_G_Dsd`n%A9Pfy?9lZME%yw{G{-cE7b^z^5v&iIv
z+&k(|k=y56<dOOoqUE29g!$0^X<U1B_Gr3UZP24VJi@;A)6t|A9!KK`S(~@qnSrFj
zYyF;t%&whKuteQT^eBI(JU3rB|NK-g+xb%uh6$<CHtWy(I5ez?@Tfso9Ej&s8pDJ%
zpl4(tcXnOVY$~nFDoO%Zm8p6e?nV1`OhuE_V4_nCtW5L<8DSX_6c+9W{n~Qh#)lX{
zBE1<tIz}5{;&RxHpAu~V=pJ$*9ty?wrYrSuZ0k0pAiF_uW2WUvNfBA|Z@=lCPa-9%
zp7I~0lMaP61PIE=-5jVpG+)Ot!D?1p5Z>h<br*H>ZwI4k;MZr!mJ_*x5`}U=rs{j0
z<pp5c5SJl*DJT)(BuZ%(9lqNtgXTCAcO%jis268vC7Z5lwxOVu0P)*T6Y_=WRz<=V
z82N5;6#QR?Z5&@mI4jL|oAvX(_3##MJK2Q#adFlE1k+d1)39qGqDOdeNRi9Yi*0J~
zeeY9tvI9ZE1%^9Or@e=q@Rf;~n~*qgow$b(yI+fpJW<`wUOsbxd<c<C9Z@KWpW6XW
z*&nqn#YkgsH;IXpueOt20CEG(X4I#bOKdlU-vC<uiw6Qt{#}xNpYN6*liGm>Blqu?
z7F3#bjKuL7(3*c>_8-6B|5^wzGOVsorlh~Z*nyn*|HmBRz8@e)wGXNcSMqGXaVvO~
z=RNEsKi*yFdz?l49Lo&Lp|C0euFbh|vUxo;mWHqJ`xa-rY5XRYytgA#(Bsfqa#?#b
z=*IuP=el(<sV8Dtejq|;n}LrC?HnK5w!sY?pkxY=>(7t%=d=59Zdeg6C}f7j_~*_k
zB?rM<nHmxT-Z`%!QE*$T!_b!zwWFE+In(t&qv4xMn_k%BpNXk1N~$@ruY66NsvRz}
zw(`#>=B?j2Y_S&i9lag(bYt_q$1S#W(WpU7y|-1o9&$_8lx-s$%mK2eKjxr_;gh%$
zZ?2jS(qZLP5tf~W#hs^|ODMIP%jwW4X0--7bYPd?qjJ6S3k5~5SBAAa25qeZzK3o`
zH7dWOzG*r)vP=Qm_F4`f9uFN;I-39S_@8#ViWdWw2|)J!8JS090_qlcB7}CLy-J~r
zf_x#=t<Uo$)tt}rPILLT^*<l_DKdaG+YA0E-Moms$|`E?%XFq)Y3l{y@vn};#8le8
zoZ--FrL2^Y!KAmQm3Zpn6GH)`_D;|uidgYq&h8Q9W6r}_M+shBw;WyD$8ACe^t382
zblnKvB-N!+7ds#rs$<f;jYCal-EaMJL?EspD{`Pv`_>O=>W$Le3savgd_s<KOWa#?
z^3RvfD4erFkQ6wle;AFwzPSF?tw0_@!#BRXw)UT2S_x0LEQ#B#!!^I}1F#@~xTCV6
zoQ%48cin!un#mMtF{xVTdlcZ?2x_my!Y=pMkIL7E`Egk9Z0Z555a_+Xnl>n_lLb^z
z?<v+#|H$I}U_%xvLdfRbqYR<W1J$AB-VE54;P&P%|Kg9Yb@4V%MLJhq6aEhFyC|42
z)jzTHtsZO#5PE;#MPPja!9}E0HlealgTI19&bFrK{Mu9D){!0P`pbEzFu{Q9B5}cg
zUEki)uV%(XqNMh=8+M593lLv_v2K7pk(G;3-#4$@)=*3OoYC#mxQ4hOg0TC{Gb33*
zz>&D;7xSqJ%pgRu28GgpvF>xC<m(OazK7w~j?Ct!?Kf=y#f#>YZ45X`3z<Dz=OXXp
z;6omPOM(97`ZF&F5UXy}i_J%7Uu0BSKDuyi9*j8xy-|cOg+oN(&o;G2dYfFDEd!1$
zd?J+#AA&fMKW$v?Ww}6}Wr0foWb2cXa;EC+Z`=#O)53xr7VfSyAoq&_e*hkgC^w<*
zP_6qk&GHN$t?IK00_xjvEQM0qQLD>#AX0hu=IGM;C)`l3{p%k#zoB3;?Tm92o}K(U
zHTU#H+RauM9nu;1=c=;gZHtIUh~-~k)KCR_z@;)oy$LDA0!T#%st#Z(+6QALrEEqJ
zRgKfnUW0!FrRR~a<37lNCL}rd)PmL%IA(s(=c}7^(((otBKEy$_xz2d(m&wo1tlTs
zCQI+xHmAvtQ?1lu7#5k8_iSsuFI@myHnnj#Df3MgO<7&;s;ZBbwCVK7gYqzxhKr^P
z0u#sXWz_Wzr)VR%0Z*O81wjt`oOd~M4{qF(|9D}o-fPI?D_fgPp2m2t61m>nMZRao
ze|p${Ws*=Z>b_dIj7Vi$lJb)bbA%UaA#Sm{gPzVxSVD8ycQ{Y_W5J@0Wfvwnbc_UY
z;_59N2ELvF3hS0@TY;YftT&e)MW8ovYMm_M>R2h)o`qI)wq`>iZGGDZ@0?fq$fV`<
zEAVnf@J==mN+Cj06BWm|eRcm{^*hssO#U(dQM`To{1p=z7@K3wF))rM%RlNGWJozM
zV+_=)+hw6IP@m*tB~zGLM6$GT^<Et@M^*(|9{uLzcbwJ*jyP)1>>jPAqJvIs^IcQ6
z*a4zwbl5%Y&HE!Q?$smyHCFTEJSJgVo6mMAoyAxfo>JL1H+GO?vQQ>#p^sEC?{Skb
zlGcHB?n=?C7zil5aM_SSpUx440hrnbFo1MMkQSB#(uXFSnXm&Ypgo0?yzWp&i(Yf(
zeJdSS2cSa$+pVWCT!2BDhK-5qR{_4<&bGJR$FI0QvzZim#lAdqb~?~GtKMusp+Fi7
zq<71;<SgVmk#{*sGcYf>ORDWMFjmQu<X?E|QXvxF_W*ZEcrC3%^46(-GqIeZuity>
zEOog!RlE46CO=L$+|#|<>Rmi5c|t{S=<>p(YxSMV;d|8=Z@i;LPZLvvZ}BdyO(bNs
ze`eHg4|n`bOpeVAaC7Un6pWUcJr<sKEZZYqizcvFm?M~@ecqaYg8l}uDM-gL0@lXn
z(jrtNNP3olg8`Av1{nK78ad=Yf(U8XCIW+6MvqiFg}7a7NwPH1;k3V8XecN}aMPqT
ze{0|$cq8f=ADm{bXNaU?Yu?(Ufb-ea9_^sj8o-mB9n)k?oW1LM{?)ux&^Yhnr^Y;e
zgO+UNPLCxs@o5%fjN-`%xRiU@ul-oz1&PtSEidRjSdBlzHTHl#Y)Dd>Y0lpT&;XE0
zS!hhHhr1^rdW3P38?RA&h6riKFO@y6XYb+|tLJq#F578AD_C{ikaPO56obCBe$=z$
zs!e+hUVeKs_}TRG1j*Uw>O>$@B_fr=S8&leq)JP2gg*}iOvUml%w?hsFQ3w@v|cSM
zAH&zlhU_5*#;neQfCxn@#k=5>czlF_kpHeCL-}g7eRI{T?=g7lw^z#+0@=D!>I+jf
zoA$wb+{Tw3W#K(3)$gV9#{&(7f^6gW9r0Ih(U)Fp5!&9BB3VttK^Z1*Hm#~S-j?9A
z^d09YJXn>YXjZO7q!>3ud$SH8a>oCcMc_7$cQ3w{^BtXIALgK(HD>prR^#eB?1Qfw
zef^xdN?9e<A{~9z<}!R#RUdHb#cJqd#__8;UDXK^O+}Hct-{={Tve}_0xF~HBvtFA
zW>2@g{vo<oIjhrd{&~C0<B!|-I^H}Zz(t8>F>B|M$GS}Slw*B_DpJ_PBYYUDqk^mF
z)}C5w-F7ykYB7J0o;nkrt$yU>b#BltV6}U0`FV1&h(AF}SdwL4OC?uZaJJAeB4E+W
z($IlrXa96<qi(UdCzN3h{ripi@IKCQs`Z6CX9L$$)#yW|j1T#dYQURnk-X~oUhQqe
zug~QW(iF_P>@E^IYx_istZ)pSX%w_1;gg#WIPE<>FHl-vfEyv$cNgVV7H8G%Y`SFB
zF5B3Vw{lKaD%{=4rbVJ(*deK^wCae3lxz9<<CJD$)x?kQI(uE}yIacN^-a~BX%x0U
zONdegxtq6r#6s7t!>bQhx?X6T`r&b6y8boTqOmFGma!tw`hvxBV!GtM70GFx#n}qk
z;@lpn?VcmY9Kgs!4xF4L2SN~pO3e(giJ&YB$sCefBAxZ9|E0pqfH`qlu&rY`JH|ex
z@11I%%3N)-6P38h7w<HWHLgW%(sbWSk^d7n;TEoGIogovI!VKAG|_x-&AX0xUzIVt
zvG{SKv2<ruS+H;eg~8h?g0SA0xZAMjcyWoi8oLg+@Y+=5mu~L#tQl21mB___N(IT=
z9NG?JxO}1s=|JAq<~;ALPFmBi_<_E;!huQ-y)p&qaD3=%T2ke*M*+s#Ir&29g&#bw
zOC0Ho>{AJ0&0Cuvf%f|z<9L`cFdmVtkqPk_<nmGjN89l9dX5aaFCqv47E%qPvo6)!
zb4wGe>v6Moi{0um$&dGONknu}uHh@wE+M=~@!}=nwrbm|J^0(8*z4^vWN1#cII1x^
z)wGAUDm%wEA>L5HCV(AnW5ddqu$X1)(^aKW%>4i${(i36`wZrq%vxF(R=inLHL{So
zx5%pGOmABJoRtZ(o6#Ywg3ju#UwFhG?Wju$YPlq+9%b|~eN7;zu(GJ`vhWW-;#3vE
zcxq_*nE6smHs<nb{nl`qaY6B#A^}(GATdv$DkwTWA_vGo+C;vt?~wFO2zH_N_#<F+
zc5yv>2D^p`&VY~uFa86EpL(~0<auj%9*oZOiSrEOONj21t@`rw3qEpHgOa9KBkHlL
z)@~ik^UFe2t70--0W#CMeX8=Qmpff26_{?34213abpshlfj)C1f_m0-+&PwRgDO@f
zitdTW*Pm}WNyXIJQp(2uy2k+9>{G_4ay>fTdda}<%bZ>X4{1PKxKC=lE1ksY)Fpl{
z>b9{LerGc0D7r5xHTLR{0@{k~Oj=@T3vH#4Q;W*lut^tAFTv?DKn4Gov&`#(CVWjN
zPWFSM?rz4~1pg2{!$|aJ?-SM5$az+n?oGGn$qq=pzG9l@dULfSS-oHr=2|c!DD5!p
zp4C@(rbwNAnaF3?>uz4<L=wIj#rpZMiQX7ayVK=2_MBzK#X1UXuncKJb;@oocernG
zT83Ni`LQFeQxm^I$pcx7inP~u)eUXu3Tf{x_E=1PtH}{2hQ?0w;DnxS>8lqKsEGV7
zUA9uL62#^?JYOh3yUpk&ZmNVkuX-Rt&%VK?R5^#ZuP9hAMMllTgE%U@gv&DhkW@;1
zr!7}eWFxKZ;j(yId^|+b^cA*a&Uxy)YF41slB%Gq9svEo^MG_~L&EW?TE}*T$qN;^
zRVcMXXWd3Y711z3DW9uLRqyYcSvG`Z$W{CHfR=b-M9)+bmUq4&OwYS2rdWPkbH{}$
zQ5;?$)3S00Tan=@k!ChIJoV$NQ-zYqSjf1!^x-0_NFEdGJdLu#bj>LndPWW{2^nYi
zng;$K>I~itsw0(y0nX<`t)`NXuGzI%h<qeQTZT3XGfd3h?XLXcs?_o-2uFpMjGB2^
zGn&ZBV*0gx(r&!VyQ(iNIV8nu?F7?t<7c~ytR5;qPd`K|P{6!~E8YLKE9W+r4V4iJ
zoAZszy7EuT%8w)+-OB@yv~lp*CTKny0x9kK)ht%~E`FP0yYQtM4Po0cW}T%^ss;5q
z;cjzjlT+P~UklGo?jv^47DUVqbrD}g_JR<&S(iXTR$WEsmcvTNqY;(%thzl9wrE`!
zQosZ*o+W-zwbGg>_)+g~H#9-f<8->^=-IKgZk|InOqmZx>@N(?pHA#Oj|119t?}j@
zTsMXZSS8LU`J8L24^uFS3Kr`mo$kyntXzK15qQr!Qt-w;<<MhE!KMvzf!w5=^K+}G
zY$&wGp|1+KIO|fRHHl+eprU~=BGw=UfRf8bO%@RzK^;~seQf!JXhRd&H9B9}?q3q%
zrsm<cdNMrga9)JOjna~ReM=lzHR+&^zy-R+p46<WxOf&%rC85BUwIxL(TQNJC}`Q!
zZX>uoBcF}GMn`6tf=L>=;eZ>P$<PJr^+fCG^185ud!`@Fsyhm@LTfs=#4WrJv9(ik
z8t+wcJNM(ryD(mSg@iNdV;eC$#WLJ=By08YbI}Dyo!m|teQxuPJkGu#o3Y&=-dhpT
z12ln7T0|is#^;IBXEZByhuzx?*Or_@G`wnQ8JAj37r&V2k2eQSt<?CZCta=08zzic
zb*`{9D{$xG|Btp~C;F}Vu3#V97KO}RU_Df_tZs#wkfhIzE%$C}G?>*g>d39$gk?P}
z5@VCH_c^|>{n5}@(aM;>gld(}T$x)Q(!m+3?wI8K$zn?k)2(I0I8%L(^5s_Jq6zD2
ztu(!&$#|PBj5|TR%9oclsV7viv?@(|{D~oHoX2$f$9#;Ko@G(WbI0abyJ;bps&Y*z
zw|v~!=e;F5c(GxNtY`4oFiEw7R*7(rX0<eTGyBCd$3?b_)rPrB+d4(LmRFa?SyDo`
zckb%SNH*v!n3W7_SqW}jo*RrTq<#u&B8N*9!9_q90RkC|yjgw^+XYB6F*2EO4ed`}
z23h6?QJB@4f3~YtY>ClGAt7Q!^2fV&J+B9h)S;ZX=33R2M<dPEzF77{5!hMXaC-j9
zB#&i<obI%@#N+{Uxw@oAgG}kkz;?<H)s(%8w^<bZjm`*M+N-7YuBt_nth#M^P=@`K
z%zUWv%jWG>>{Y}4JagyfMys!`5M8Tyuv1TJC>a+AbahsScIUk6aulAyWme=|$_!4?
zm%jWsz~ukx@IgEZ(dLeq3=D=A%%*SlNk6`2IK(~gT#dE6Se>yDd$A-|Pn7g#276*n
zH<6a%0j_1fqWgiZvi;l`2R503ZP>h>Tc&+%+HT0izMAy`J!{8Q<^N;uz2m9w|Nn6<
zNhB+K?~avF$Y>ZzcE_<hgqCFQkz^bq<B+l<BnOAe%E(Ga$%sl3l2v4HzK_?@)%Cuv
z_x1jK-k;m=pWi>%CC7P<=j-`;%=_bh=W6+4jAze9kQe{8#XZV}c4~iUT=jGqUDR@@
zM`MC*_CjApVB&PqC;zbreZ##?*pm2giAPNH?C7HQual{-B2E4D7gk?$NKO72oa$N3
zQW86|`R#tukb0G<9hC%=rLII06-v?j-tCge?pU3DP#t*Pd*nUn-<8|cX?}I=x%b6;
zGG!v)VDe#ma-)v2`TBB<_Vrb@xiRZuJ3h1iA$1NLSKo~`2fjVk*M@y#F4WE+t*GLu
z^fET@e|wW=-(<tf^RB($@-l|pZ`_{uG+;pUCJ1r(+eNob%=WailE_dShv%0kehRXo
z5&h4=c@YU6`I;3Z<qjFpo0p5#y1oj+oqHhoJV*(Y*V8+P9C|&HDW&6Ki!I;#<lo@w
z)aPmI+^}BI)O;Q<o0qZy_`)Usmd3qqxR57j+frMUEzL9xPlw?Es8{GTH1)3k=IN}>
z&<{mCm`p`Bo9X)JUrTl`+=+_wslLXez<K?~F=-nXJplm_cH1kY^=k4?q0EqYg(T()
zN3lbH{k9#*SnaO@1Tp?V83eF-uMZoU<8Mb5fAgFgISZA86s2_+L}U?J81SKj8D0@)
ziCgU4cHeg~?Ie{R?AeCazdxQd`s}$e7>)q<=jU%%&*?+q!qL|^Uzszi-#H2aOthI)
zK?MTUf5rawOSI{epTh}TDF1+`9wXC@c;(LWx(UOyLWbmuDsi9E69?Sbx4jiSGb?0#
zT+@&NJ$`ESV`fp>(5mYVLfS@VB(OdD-{_o%8SIzCCEI61s&@jf(w4la|E3IGuY(w9
zpCwXvv@8_&(3q2z2ZPe}{wbLN=<mI^=)bu-iA*=Bn7sEvN%{i{BCW8?5_5b!Q-r|1
zzSSXkKNh)};3NB?!k67D*$>z$XF2WO4M96<Z<d<WN<BS(@npvye+#xB5(XKIH^;au
zp=$<Ddt3dJXL)n|FWWY!>MFfl*Q%Qg?R|H%pSSTHAiIP;O!!pYV^N{Kixn!PZvdy6
zQVQ(gCL6iN+7?kJ&B2V}LSOBnI3(Y9q^|=et3JSCISYX*9hw8>Z-&%4bJmQzl6m?!
z5H&csj~)F>2>m$OC7Af%hRl7*LB|x-cz@ZqtsLksRR?t0x?t+-0~ruOkVqFspxv$W
z+fhQP0&<1(QW_FK$WsmB(GH-QK<ccNNf1OS^8C&qLBI~wnW_JFymWprERZK|?5ib#
z#W0vcU|u#HXcR}xO`q$1lZvSAGgfuYvrH}fYTisZIS=yX2GWdLJ(-HGD_OW!2epmc
z*S1{__#MeZs)p>hn{$w;&4+`bR)GOwvb&I<HgtUa#P|OA`;+&qCp4~C#t3(~g5-3-
zy@$6B#>y9B1rAb($?O%;3&IEgnF>NS2w_0%aW80YuYd+O8!`|Iz?~30x7*yPbJpDS
zX78ti%}R7^s^td>LEA!!F>3$KIzl=T<glZ=YvzLZo%&mQYbhUxLVfSV?-cYuofq_u
zaXSmGevzW<l?nUg5^MMDP(O}I<P3_9nb_GJgpZu92r}4zSyOy(){|Zq?>XuuYZ*dN
zVaAX*)?o}H%j?*_S*9u7>m2^t48xbtbQ@i-tR>PZa<%rYt4?21s3IR;@!2)uGn7(i
zGx6QE%W?+*_mD;ck|+I#)!kwoh!dgMKO8AM_B|B;ec#K#J9HM+KQ-d-x_%AR9#}Rv
zRIiCsuu^qgAMGK}Hr|V>8TMXG6~zX>+7&k_IUs?uXq<JL-q*LN%OBjjuU2hfrKm^o
z@X-^QlI0A3SDAHq)r*2ATKp$JIJFI!dUF+o%HX0x0I2dSVEYgIFf5X&&nn$qAFf@e
zITki`rn|sIeZLAWN@+SSD0-<ke)X7ROH1+{u6!arI`F7I9bZ>F|3M~2%I#VM?ZRaO
znex0Ea~Bhq&g-*ZI@aDs|6IEix)lHOT2KH_#iRYzzF+&?a=&Usy{Xl_pjfrGY#JCP
zY^=Wj3<DRN_vec$d-Aj8r82+H))|9J-D&2rv`}{1foT2>?V0PJrzcRlf>o!Y;+ob?
zUD<dCvRmZ`$bn4nb+W<+bWL?nk|wf|@Z-WA3qS(-fo>={kcB`w_5-owl1kXi$j30E
ze=$L-(-^ZS@~WQSRY{mC0T$BC5v?%o<6RW}kIx(`b9LvmE;<M#0xO!zmW|LzA^%+g
z*s4Qnkpr${+c*;hHUYpT0Fc}!bzER_xd6TA-n`4;xoA-WKw0@FQ@{WFExdN5<g{zW
zyZ9rx*>uAr1eYQun2YrMoohf61sS#^%R?Bocw`B|^futYfl`8?Qp`@n!t{e!0l|1-
zyg!QgzF?PYjT%No@lb`y_j%rleBmxbcJx8BREWQh{crY(w{y8n-LQ}!V=F@daB=Vo
z|NQAeDl;2Cf*~va;G5)_y<EE{_9+=PHGSJFK!IY+YlF&%#pSwYq@!D0H~uC&MR5;G
zB!L>$M`GA~>0i^Op_b~APGTb(DT%&NeT}W(zefI!1-hit`#aXRcQ4Sx*$;!oMqn26
z^BmU$oID4yy}@yX9B7i4){+f!q2qO;&5-n{-$nI=*fBlbUc%WTF0o-&NGo`(O><6m
zsYNa(QyjAgl_D8=YUoyV#gH}7iMh^rrF!|cwKUj~bKU1BFeKS!E-kFKEVfy~QdB$*
z#<wHX7c@GU&e#4v=YV@q`Xeoh&u`5dalGt>R<arrP~1lBf8>8~VN|FMsNw@f;0KC!
z<LeaGssr=2k};nXnbl}Ii81uSNo$X4b(r0qdPMe#V$(#J(=|U68PP?76AXS5ac0V1
z9LiSpdCxES?ix9LngQ)Z$)|mdw}*!S5M%ws9E0p;Mk6z<J*Vf_Xy7p615eSb5FX!F
zW*lEa{ZuxJ-H8awppifkS-g8??NN3)An+I3f`80IzsH%$qk4Zz;Sq;76lkinKEhr9
zN~ik-@VbaCf3<USSCXD1W*hsRZlcxd4-MPb_cE#Y<vU9pENeBJ0VipDwYsvY=tIe?
zKh#S1xWA;5do^h}@X^mZHfFPjqffly{ch)x_`U-2!|6I)2<)W1>T(6+`=sUL44%bD
z?~Jx;IB*nHG7^|oDvit11fEl)?Nei0XO>}>XD?`5AcRi8-LULiTGaZ=JOEhDWC`D!
znkHNo{krs;SC6~H?dI^|-rs!ybJ;)WXFhU{UU|ree(W^kh0IlxATH(4tTtSm?Tf${
zV-*Ob=K+8z7zCLQ`fY0*4-zUC?L3#;Et_}Hq@bSkzZT;or0EASf-NB17E3I;+RZq#
zR#zS8PgAM#?RAsb4$|B8$2Ef1&Q?j|@S7mKNOer7w@Yl))O+))iXpVq+NDO@1bVct
zNG%RV{Q?56VT`3Wb}mB@Bhc%c|J)~M^?*~;J3E_%9se8xBsNAJ(}xj_NDEAvNy^2I
zyWg)5=18Gdr>dmfbPX1yYAFwb=VV|*Pexb!%Pm$2#4abTU3)Qvn>dBE3}h;a9Xgy#
z9~v*T?Y(akxjE&&DQvyz>9HWS<!b@?1*ClAdwv_IAx#X+%<St6)wvsQ3$K3gk8IjV
zAO>pEqNzmcn)###i8@W26V8>Qvzxx14#WP3`|l`BMp{TfaWgG{>=qvNwYaW0KEvTT
z!P>ajU;EVt)0XM{)noh92fNr~#w46Ao@-^D#l6XNTGf$_-K<<H>D#pAaqedmZV^n4
zU1#39xrdafo2xB3y-dMzW*3(y%V-!aCFGIw;i*xx`7!Q7xy8fPvB!7&8Ag^a_#`e|
zw!C!zu<n6MFN+21Ez=6nI%hz@3H`R0T1LV6J?rlAlir(<&zcl0Ew?j0T-{th)wfRx
zx<$zC=8#mHdN#P7DdW#7+Lx@+iUO1Lws8|5%yRBA*8%OBTMm=CeZjkDbL*7&EZ3Su
z%1U<5{_+(6e!Iq)#6|Tow`z%|G)G(urCs0D@OXj$>EN?(*6;sX-`eI{KlN93kc!lW
zQKJsOi4I>}zxQbsH&|5bxmq%_THt@y;$F(?5riuTkx2#B0mn<AIUrw)BcZn<Q1pJ)
zbZC%sMv5$n`9Ms69+YAFDlwcDUn$C*wW?!a#^esLn(PP23q^e}p8GCCFy5w9;*NsE
za`c+_CreG3BthtSzzhT_5Luv6y$*~w@H;y2iqEJ}1(r|FEVvKYZZ6U%vLjR@r(vZU
zZsFTF`P!5i#DUO6h40ZZf|-c5#7B|mVw+t$+R<at$XOw!M`mw8EA;??a*%IA6xKBt
ziWd=jMI&{;N$&_KfFFGe6a?_N+wbVpnIOb&UC;Q{38Jj4e9P6XZcg2GFg`bjU<QDR
z`p_F{=xTR$mI9JwuV@G!4Vc?dqE%KF)~2uEYeM4duRSyjfQnRs(!m`mg2&;~>ZEet
zNzXHav(#ln*BV^YNlz16erxkX!#`X1IW3O{+JOCGKq72pBz{RDcS}N{=;tc_&uf+?
ztXbqMyU>&!Dgvk;@XMV98ZuDSRWUyUi>+k3!m)C8*{B`f%nqcS|L<19oC&=l+%w5U
zA{kMEamoEKpui0i=ttGX`;O3|fgA2P>_8G<#9#A<td?5b5rh0yoJ;?z|1hD`tD!Bb
ziu*H^XJ*`f!dQkOj%WoOi`@I!&>!>T9F4w<S}uL78n^e5td{?Nc%~sWiPt$WYRh_^
z(!yLykU8_MrNR@E{5651EJcjj#X3#nQOn8KwRpC`TUiI1zVOv8uD*VK&8U*q>;Pls
z<bu<uJDxQ*4Tu!O7cZ6%8>Kwy72h6DJAIhEHSy_eSE?ULiy?3VUzQwB-V(iwq|xxm
z!FJeE=c51(itWO?^x{v86M@4;eg?$Sx8*ic%1eIc6(+8`IFSA!CD)UPxvFfjQqhB6
zpUsEU9Z`WTxJsq#QGpXS7ocDtHgj*5D;Ao-W_AvG{wvEf?@uc*m=(1C@bOLiu6Mn%
zHJ>SL#TLCW-|GLJ|HFgp$(2*lrQSK5We3ocw~v9K?N$+@5qK8kKyVOHqDU~Zm;T*i
z)|(}XyR1#4^g4!pG^d5ue2cCwh(#w$-a4%EF>B$M_~^1Tc{A>dbuhb28kP9cv2yzS
zp@ALyh(%SGspotp-LEYuJ)K{Q9PJcZwKVP3ygxDPKk}h(p&7g$vuF9yn9&F>w1qbc
zb11;;iPQ1$5{@dtB5E323;)E$tjnwBk`5cj2U_Rz6_iW%af@9I#*>%;<jGZrKyehQ
z`zdq21#!{u6rY_&Qd>S7pf!pMo)+8@ao;p^>yz^L%rbSC`w~@m;pO=EgVM{`2S+au
zSV2r<GOwCHC}`V-l3e}@FY%O9)~A?ND7)E$B4b?RMU8x}qW7y%Za?jzkl~o=;yKo6
zdv0xBI+!2yYIEIRNqG5b$<9uW{9JXMDA>?et9XtsTE0-XDm6KN@~gr95s9{|)4P@j
zUW{DWc=^XkgSI_D&i9a8`0L<lX*KxieC6>`VPm@{r-nw`UGTx3ppwI^Mw$r;epk^A
zmQhw^gVqztSFjD;5pGKW&x5D(t(sfU*K%Atg9C>D3T6`8%F0}XB5HuJjeB^c9WZ*I
zjmkdZZ&azt1NlHUaG)TZ0*I@h|K;joj1r~~RIEiPL8~<-?n(8hJnP-q_N&jU=e(~)
zYF&~uEIwzBsI(rP*GtTmFIT-Uf9h-cNv)s4q4ZeMF!HF5C>mZ(_-BM<8HSGjI!?*L
z(c1^tYdGE0$$gL-X$*@guhrYuELvW0`z}^eRi&Hqe98a9-gm=^Vh=}#+gc8q?k>2H
zbMln9c>T_(+86ulV=n#_USHx)NB&6>8!m8YTlVM>V@YFn=~+g9MO^QYL4VfDFu*sD
zVoxkc*db#u7R-bXk;?^D2kWBbUVf}tDyiNDj0<PkB~_Mva}?UluODBKsIh-tF_N+u
zA;n8>_q+N`=1M{(A6s`duu!K;>meGd11%CLm@u8c25>kj|7Nd5kA6+hqJDiuy8Y|z
zMx{H8+5XIC887ZF^XB!rz3m`yZdebuJ)Jz}-sjoe2t+yd1yG$?QhtukGnFX1kXUJK
zGiT&Nc6k(PQ!(vA99QfO+oC$;qt+*><bJ*Z8a=&Dc})Q6L;`^W4CZr?m=KbVyRY>e
zB4dSQnj|n=GOB?eby*#49M1UMl`w2;v|RUo80vBw`$dnnt323uAm!pG-JNksqa#s!
zBvWF((9yeUI{1Sb$#^76AjEV(aTk@>7mzpg`94(i&UU=Tsgu8_I`h3qn%HsT&r>^Y
z$zwdy9r*+?aef<j$%aJ2*beDs&n*~j%-560z3;V5h3ebJzQoAtxUmnNR}nUB-m68P
ztK{BwJl$jQz9{0Wp?sN|#ZR$9NogRXv~%Lh(~<)xtv_~&BZDJfQ>>X@1*A-g*j=1m
zm9lQV_l55mS1Vmvo3|(Sl2Yk<IES)(b7~Vm@Hs3LQ<IH1K!ppJ*Pp4HQLY`6b94T4
z*XsS4vRdyvyGu%ke;x*WQ0LG`PGqeRvh1qebP=1yDM&RceDSfs+l_d$>gvUCx%YC9
z6rNkkTcF8vTPgd$Y0~n^XNT@9tl^Dd8?dp7Tneq2k6#gvOEUXJAs$XGnexT$Rzib%
zH20gJ1mvBLgaT!--LQLVvu|5s>v6HenWI$42Tae2Se+VSXy=i|1P$<1h$>-RK4pC=
za#HvCI;eKtxGaG7Q~uAQ_mAjbCjKnKRi`XH>YRRd`E%o>qZ9$d-0QGQHv8E**kv!3
zbL1db5@SP)rd0TK9csiV+J$efQ$0-fzkoZKbqYoqrkc)_>}GRm!P<<8E%;r7mY@BO
z0Iz9e0NP(7%aL>KCBlOX8uy#2QWqh0Ar_6?_9l;#azToL;E<&`r_P-@Pa28zJG5J2
zw`(?x6N&CaCuVY>dAITE%E~gR;WUnkpxMoFgQrjFxrEin@~XD0`u3i@)t)(6kbMK{
zmA3tSAr8r#Rh`L|t2*)XH3y$Ot<&UJ*@?40c?$b5v_96Vp*>SL<rITz0vt-8!Mv+P
z(U95v;D#4K2AtY60W<U~+D|Kf*+(>E(Hs2cu=*N*B&0wP@TVE18Hg?6g}&VQ7v)VI
z{ti=2&O~Qj_bQi3W@A=@RH0<>&I$cp5l-p}k7{vJfx>k-`9S0+mq)dlT3TRT7=09}
zAEpzF#!t)5#x74WeqMelV}PsEq{C9}>CU8N9*z{(yTxd;6UNS5cW(W33xD^m9xM9b
zl2<dw4M3z*lBVXjcfB#q=y^rmpJK|c^TwPnSC-u9Zi&e?m@&FrBP1TTDAa}~M>x(%
zM7a>_k@Wlaz&c+<Xe~!!%N<FLHwYG^=(ZDQ;>Hb80BI4_$+tigUsko<-J)A8&DaQS
zX5uOgjkL8ew3)j_yOidZQfhVSv^0zIwd7-;ziw_?B^Ew1|46P{dqy&LcVh_Nw2Dq?
zbLLxGgb%ZYTVBbJh@`q{2cr=P+5YWf`o>SM4^P<WX!kdLU)f#gHR+`ze&TE0N%2$l
z_2jAu!{4}$4OaES2YS2aeWX8=HkUxRnNKyThWdECx)pl2^Z^BGeE$PV)OacUrx}w$
zi8@r6B~38=IUiJF%mO7>5aL4Er~*EgO$FU*z8G_#vFQ3bd7{_d@uJ1AIm(s2wEC2G
zt&5fR7mjPmxwk~Djn{se2|qm3zL^kxWU9$h8S*HEJ{QIZwnP?xT0CR8Xvv-Nrc3d%
zjp=f`?~_bL3|^+aR98@zfor{exoM(KMSt>9bUJ90aO|QlGgsv@;&+lh(_pDHgmmeH
zS)9}zK4+la;`)p8@0_i9ObFu?pj&spF_@v;%sxOXcQ5mk9-pfElQ;!RL8s?9rF;$k
zK*P0pApRbXw9QfeBiq^a=r(@#NOS+90sHL^$ls^+8d7&_N7A4;cm$Rfm4s|BWNbPp
z6Bsya^r4c4a4N$H+?JHXK;>nT?y4`R<yKn|0bsOz>c+Be;+4wB9_a%Qv_1((ve@)R
z<_==$&DDJfVQP1lgz1dcN!NcAa4D^&rhZFduW?mOs6=ydR-s&i5u=XuvA8g{hC>-z
zp^uJspX#CIl1z6LRO&v}tvB6curjr8I8cY<H#ADc-iPRsVYVqY-|I8{QrSviBk#q=
zI?5H(RQ0(>d^tmZjSsE%DS361CENCEb)fwt<y+ej1Thf$0$J#mB4dS-SSDKMQuN7^
zdB4+46|Y2&e6I2-K30~-dQKo>@2wlW;&<cJqDo8kSVgS@!+5<OS%(bDHtdRx2{l;m
z=@gC$V(c#h*!kuM-p%#*AFdX*k$Dc^yljY<6l5UBm7dpURU8~tyOb8XM-X@ZK_nZl
zmw`z^lUEyD)mY=VIEBG1&fgulG`9^`r?Qgm-a4F~UKyfn?O7Gy$51Un_}UV-NY9Ca
zpI%AUz!uDlOu=kvi+B{67=E;=iM0dm(xd&FB@&xzYOSC5`y`#%&m5;7$?)^0s`QDk
zwV}M)K@*~(`)qEi56qNi7z7S4x4k?4Qy9a^biKAWb<=EkhxUl2j<p6WdaWe$uHz!j
zFg;_EgH5>a#z6@&3Hoz^FVc=VJq+LyO{e8$qGE95HM2YJBFuJ-GNF+pnNGCLKVLgg
zy=JDANZYruHgb^by8NbB?eMNtl=zpfLx0o_w|8kzSf&dVSn}+(%ZtDNWYZFqRtz`|
zQ!DzE9eo>3{XOXwM>Ge59O#RiR{j6&b*ZVpl(5S>|IT^~ds)%2(Hng9a5}D_mN?kb
z5LDZyCny>;L0!Q1d_yunsOMazq7io}ilgVYq6t3*Km5Ns8Edwuz?3fR1VmF~3C9Ra
zvacdSbfV3Xqs^C)$3-2iqO8M7Fi}$~t6##5?$19`aqasGqM23F8qIOsY^?N}bbt%c
z&@{RZIoL59)lR%5zXKkxV>M?^taY62j}pnY%XZzfSBAe$F>yr?a%Ivf-84DknP_Ht
z-T3IHl5aHO?x9@%xFGchK@RKqWGNwn5ZE(d2m8~wGHS{FD6(occWTvccg}Z-o$Tk}
zmk`f+)9e4BaO@UiKe?y>r*kuT_UR*LA5K(V|5Q2CeQ&&Cor(2dE@2{50UaL{>*PFi
zeD=c2yE1)hdbH>Y5%>D$h$}NKPih)^;~_65JI_R#k{UzQa%#Qbb(Ad#NHnKSxg}it
zz!B2hypa$Y|7M@zHkYvwd=j;@db6iD#QQCN)sw=N4j#tx3c9=As{YY73HZ1Q0b?Ak
zfc%a{FCB|=#iLhc1PMz+sYInu=mS;M7!V_enRft{|NZr2{7BRlq$)cZtc4MlW;Bew
zglRH4VwzI6xQ|87)uz$Z2$4@lW)h$#Kz5`;#_RUlYJ_TY+F;wOGYPLMjCywWEX3_W
z$s+>`3V(612VRIl-v3thk4^>Umq_Xf*`_s-37bJ*)NqsEnJ4N+71Qr`Bje3CuK>X<
zSwQUHkMOT8rR`lJurH5>{lx@s10slj>9(mPL-*@H9tKenKr$HRs>dJ@yhcoi0rnt9
z?%*FpCt!4JO9MbPne<~MgIV@IbQ{Ri=Qgq+-1&n_(yQ<NVUM^6bzAU!=>t>e_I?3!
zjqxxP)}}pZPls2>>2BM#%mi{Ms4x8R{xUv0JaZ_)^!@{b5b~0z$3=|=rF@Gkr+e(8
zxx_7=50GCujC6kyk{0i;uV7|J_^IDCyXTLhjJ(%hTXb|csK$}8dpyk4m3e)7halB~
zo6dq6Vc(=K$=j)aVcgtZB$Y4I6&X=r@%)(M1QZ0O_qQc%YI%KbZ~4eRUyu=~&LY1y
zGLPJ^1&6dSqP(K=tKya)gjWN(otQI`!pm30V&#^jV{e*%<nBx2ks4(2K78dG(dvj|
z=O+S?&VX9Lwl1Z+3P#I^GZdmYy&gdWmFn0J-C-EaLs)Z=na$^}%1}&R?*7pa44ui&
zYRUA+I>^4{&!dbEmTW6O{Ln}OsWtoVgvs=~2w$zBR9^w@rAsq@Jc}3OyBlgcoDi87
zlG>y|#mZo}?bv|W6=2;E%_;hBKg#pE@W|1ndx0FuiBdh(4&IHV4rwGs)wiGW%>~XR
zNtY_iv}_-Yr-gW5jW_$kq(p4b?(k;M4XY0|-mMFh%Eq<1ZB--JKYTQGLwczK=i)1=
zz0YjEXJhv{%h7K=y>(a}pHrGuxGz`s6=bZ*+aVFDxlc6|sxqa3I@^De`aX8JdS%_n
zIv5|__Lwj1P1kYE0F>6|fotX$D!-H+4Gd|}hgs^C1?Hh@Ffe5EFT60z3nirPy`1UM
zMjQ(XaPNBypZ<cD{!HKtJ!TEtVrh{A%ObPs!hxd50<lu+2FnSnOZJlwBBeA$Ww4pT
z*X!$JxUVyi$Bany9rq;ZSW+jr`q<al3vZa%wJ3%-<iVc;I|%dytx4>{+qy_E6zSCj
z@D6mHVCZJ>IxUl?Pg%>ohf7&IEi-uUo{Exe@)cWlwd;WyYfV1QN$d1f`torIJ3_)s
zbq8C_-O?HQ<Gx%m+!;GcD_B+_P(As51s8bw(y1n2tvTltOeFIQjkE~x?~iCnT;PbE
zL5MR0!peaxW{H?iA$;TF^)T|debHa^S<&e&PN|1kFQyf2)M*y}$4`-o2)LEO+U5+S
zCW*kQ;Z}cN^J~u)ojgHpfegT%E5FRn*1atg_2;@x`<4#z=wbFCdXj9@0<r|*{w!4X
zk}SD;vaq%O^g0CMPF$u876)(ZKMHljh<HtiIjr5iBTU#iA&v>Ty+p@`j&tb58~Cu@
z%+QWIl(V!UOpPjw5~GyBtBDwr8WT8cL#)kvbE%6xn=vQfEE_HKPvnn^B}PG^mBB*j
z8uZD5R~38;DOLttF-giLh$nqiBO(xyoYYGy;8%LVPtSyI&aW0Oj|)59J{q%L8rXJj
zX=>DlctVKq-~TbGD~q#cz}lQ_arim`G8SwmN(Y&!UResc{lkTv;6NJ+Inq1|Jag%7
zr~)rP=9-66%nY<3A-};5P8jqpe6e;`(5{;w>DFUNIj=fMOqUPyR$(;Lys7qymZ!$4
zZZ<lO26gDcNk%k-W$H}vZm#>Qe$+jwrs{egfsCZEmK_qU4cdcTQ_ki!MQE0dN+{3U
zfa`g&HNT4l;v}gv!8qXc;Zp`a@$^tV(FOYoy3rY8`khs?<J^=d<4XMeL&a=kg7KP>
zYr<@39Ism8`;uwRw3a&DiAm>OH-xG5`c~F?ilH+PLnMQDV~8_co<lvGXE8a~DNvvt
z{)ZX_$#dP+4aOHu^Eo*!eo7xC(rqYwYRAaGqe2be)CK+Jm$8(!n%B7)@^gnagv+Vq
z;jI7q$ENF*<2o{Rn#<gfq{dA@3?$Nh+I?$cyi^${esdow!iq%r_2G#FXZT+peEMT-
zrimlZ!UA4SU(o$N5Faw>G;_Qj+^Zy8daR^xutc_{uj+l2y4__)^kYUQD+kL&J{zYJ
zk+r+PFaN1swCaoX%@*egF~2KMzW)ec_i%v%J@QIe)i%d_Z(7&}w;XNM{0=XJ%x|R<
z1g=0PsrRmAdv3R>RYNeN>fD}TB|$Eg^vy|KTaK!W8ciDtbQcX<bju!+9>76Q6!CJU
z0QxFM?^LSpr1i`;eu(vLx(C98<Gxq(-B5c*g@-mWEHbm|FZGar+~d<t6VAueW5KIt
zs}^D#o~w@Y=`pB3sAvBivua`$*}bRRVCI>+lI6kz5StV~#6pDsI78g&&#wq9XfQPB
z2_I4~`C1i!H^Vh>KF;SybX!8DFMDD7?X4R(#5UZg7ORdf*xlbkdgD%sM{z({fG~W)
zeh2lBU(Xu=#LT*sbtjp1*M^7dG;3V>Zq!&-`8PHm3{>AWScg-mz2(#+p(vkuK{1&<
zFQ(E@`r|2O!6kR;_i0XHbvPj^;adYdh?wIHHuFn)^ouVN{nbO(j5QhCr?Cwgp(n~F
z5;&9fi&C^B(M=Z0toG?#^lJ*NS9RsK_5(omKZ0@kvNbi2sEk142XG3oFibD;*Ndjp
zKy`EPt!TdT$S+o(DfDCsOX;ab)6Z_DTUvjzZ}PpJT%V-feWQ6ah|v<_-KLi}fmlG4
zK`nArJ}}&s@6-oG+Q_1z=K#*{wquFFqKq4zv%K+csDD7P*04nb^>4e8mwv58(5di*
zV+y_WQ@Ag;Uq4H4T{DSJeU~mDY0&@AOO~NVeaKKf%Cv{q?DtQkpzi1vtCz}cBqAdv
zrzG`Atu9HzS8Zu7cO`mh@gsGblc#1KM-Cq!a*`s<eZM5zCvT!t%*INZkA6>ux<CJ!
zFkRa`_o0kis-t#kV!CI9h>)x=SH^h+PGL89F$d_YVpZo4$AK^&)pT)=Y>)fvu@I4x
z9p%<gN$%wZ0$dif?9_A5A$!!eF0uQ)ky{u<(v-Dgu7YCz4_cphZ}k{JPu4ha8uTy9
zcc=_K8ly!8;O=90={gG#M3W?sBe+KUm*yT=qOHQ!{wh;(CF96-gV<**E{&camaMNF
z&`v^lXgA(y=6-8s@^mbMKyHK>wu4-_I?81PxRz+TBc%1$sj^%T9E?wF1&MT&zpcwi
z6TP-BghMqW8)jv|KG9D_D!=+UuG17bHgvOlPtYKWD`x#@@tKq>kK!jHCxFj)^MghI
zy~TbSzufKSZJT_DOlRke?L<mM$`8*mH6HYD9Dh?#pm^eCE337=;OkV<)Stga0Zei>
z`hSMe_Fs)-2umCMxAp$U`!)7|$RaT|9r?xN-gB*#r&Q=coj*$Q9SFPtbi6!=)7j`-
zjqd_N-;~aGLNwyX{0A6{_{9wm=sC+b%4W+wugaa<ZPbNfYV&<xvGHGqCf!-KrYh@-
z=`LYc?ZxdKPzB20RFFt<U&RyI0=p{>-%M{TBRaDrj&lT5_a}O=#~48mZt!%=x(mYD
z*1dn&_}YP@PlUfl)#d@G$E#>NfZ4kkD1N(?RMQva;4rx9KL-q3`1xH5saFYYT$>W7
z*Ec_YM1M3(trja<M%#dH%M(^K01Y1(=3RZpjyAId8LZ|0Bad5L1fMGv<5j{W38m$E
z6=OdIhuywxmMltKcQSOX-R$45cZA^ay4=DI%{A3xGrO7*WAjDti(^lShw1bOMoG%&
z7DJK3<)w5x>5K$KUr~;}aiZl34gY>3NTrmDyo^6!&weWR6Lj44;(Xh-@8L<9E$H-p
zoL#<R`tI{c(xjaEyl1sVKhwjk?5y1EPDO)ML;R2Z=<n*)C5{Ir(?BkV0&o!P{Bgu|
zoe|#k>vjqcEGzm(-Y`#1^x7W*{v#@;0(GH>Q=Y=Jxr<dsX4e#|BwkH;``XA`saC5k
zAG1=0KexlQPvMpNdwmLYbl^MF%Y6ghzVG(aDMofQURC2Nto0Un+qz1NO6f<*SvA~l
zBc@xPl(X6;%v4Jm2z^dv9>P<gTZHcLkswBw6DuhpfFvjZ73Zj_#o}ufM!=B`@!l&6
zR0E{2Uw~l#%YO7*sMh@eXgG`&0f}4kovM)sV2<o5Pzyt=m3eGac+wHbfH<xYx~QdK
z6@e;c4$zn0fVPLhN;oa)uHZ))##&$UbC`JP4g585ga8O^uY#Eo|Ft$j#12m2_Jvt3
zIPIP>Z%$-v3oMdyRex{!w8d%U2$bA>1O{X(9WY}5_ghL&cc+xn(l{(HZ$g7w+05*f
z)Dosww%mhS{_ijL;Pk$$(5in4{P4)PoJVy0tT<1<=O(1lcPt)@+gd6=pXw6Vp~@K2
zVygfI3}GW+B5}yjoWwK%QVSLX?na)+x9udjf4J%Ijf>u<NBRI94a>IeLJ-~xYO~jC
za$em15^Qke(7JRIB?0Ew;c=A$WcGhOmstg8O}j$w5HWp|i^6!#M}Y7Z^!NU6Pcc@v
zw%IzRu9*Vc;8kAuB$PM^a1CvZ{#jiJ9bgx&POtZM-(J)tT|XIcDZK}WZMGl1AF8t}
zfO7dSF86>BM$SWd+V=&-whI}SCjpO9_J2CSA8R{=wHYR|N-K~Lv9McQQo_(#^Ig8k
zz06GYxJYp)&qWkLG$k{OKPA`8wzdB}e4IOyGZq^gRYP^IID~s=5PpHQ*Z%nioAZMh
zqXudhftFSU7%gy!5VNWbfxymbh;I&HWo5|~C$Jdso$S<ap==GxyzwCVVv9`W`i}OY
z6J}%2&{&&kf=K(K&EtE|eV!Pn=b>k_bk2yOB<bU`-k9fKHYJq!JI$5uH}c9OVuy)!
zt@qY{dTxrpcQvZ!sb5@4=X&IuuhW*Coq7$n8OCX@eSG_X<1>!+z0A1W72ik;rjGu_
zNTIUG{XI;t8@QGNN<X<(6i9gK;NyGWFz)8y7cb!`m<aDv(B7B{X-GDceKPc&qcQ~l
zwjVXGOc@>Dt35i=8I`)hqPBAPwPBBtXbDFjN{^wh4mYycyqTmVTt)L9*oge*yzg&R
z?ojbG98A+K&oE%U8!9FFkhNF;2Sxl1udBx;z6LYWGibWIXzrlb%X)L}wtbG<&K3{&
zfI)^Z>OVgg+s22UTk2yO^7ieEf|>ZE?dk-LsN5ev3$BNsMNCn(SO04LaItff-)dNk
zedFSaxZ+P0$Fd(mKJ_@xRCU7WGz)spL%H@LO(X^`J927%dE<jBS0S(1))iOP;ieXw
zJNJFC^r0aF%SJEY&veD{h0#1RZ(W{hHeDc(i}(_l-wZRgBWI0b??<9V5?cdeXwBZ9
z3u4rmRGd0C4a@3wpp04}{B77!lycuhTIqp26aLA#qU6dqAJ2eIUR}G&1(&q;bF`Y#
zlHNWfS%<9omHQ*oJ4tpOTdOIgZd0HA3TNT+TAJ%ekv=s|q<@9{&ARpuwV`b8)z3>m
zVoR=+e+y#|xI7VkjlMr>t<!V3L10<>(r8vUHZwLuYS7?9LmSQ5#e{~--Eq@VMs_cK
z-nrzih`c&*yI;xkdDfMbSKA&HbB@VQufI}GHnK2_(TNSdcJMN0+V>!_XnK8zeD)E?
z`{OG?!^L%DXK`n7eBw6;XJF-Wo@edTVN|v~?B%Oe*Zfc}wj$LeqBE0Bn6Dpu%iu=Y
zfZ=&EGsBldC#6rUUECiM*+t8a3bBg}3D3HMzv%RZnTGd7>Hh9ccDaXqn&~!A?CvX<
zFrjA#_o&a!Sy*5$g>wJ?TDaY7b{eL$JqO#rzBt5rD(E^7AzRK#Lp|<POXRVJwX#ZL
z43o~$^z6kGdr(mTMAG#E?5Bd+=v2W*jU{ZtB@0WLpzFsiwDyZcmQvwb!0Qdvj?ki3
z2It`!Birc8vCYR!DlDF$jMmA;U|C`hQ@zS7i`0F+0Zus<6-vGrLVYUnOB(nj4cY>A
zO6l6hL1Kr`(}+F1XD1G|4Bg>XOM3HeGNi&h2;bL2gNp8o=9!sC5AvOJ;#IBS6nRU*
z6<((~+b$&-DxKFT8g&xK>?m*aoNES{%DsSP7zoh8ecjd2XLn>_Fv_WIzS@Sp1zSNA
zN2G)DAsN#%qE&tNuG}BoTDQpQ)n<6r)|P(+CldHni>%cya|jZi9_z^3RjY|H31;L|
z62tshzDG$d81Yp#VrjOQ`mnJ&?m}ZkmpovGJRhFj8-yqBM{|?>$}alTq~{3=I5Y~W
zWO0mG0pQpq6KAc}6jh4hXHlHVIDHl^9G1C5t@}q~wO@DrghtX!(R&rE@j_F6^k}bw
z&qTWLDE`xGQEM0VV;MEA#sZ>USEmb7Wv1onvJZs|PE`#zJ@1EQ0W22~wt|ZijA2kW
zBX1a%A+$ozRfT0gx)!u-znq{#nXu~*W*qn8LVt{4$?3d1HYQE{+7LVEtG4LMihg?Z
zVZHjzIVHkVmc#nlhdMhioo@;k8e5H+{QHqrF@;=iO521{upo&4xDbpV9nPGV7qT~N
z<5#Ydw!El>N_$H0cu#s~yljS6>s8a)o-0*tqe}OQ=^Z_CmxjCqm!~tAPs|!`%S;aK
ze8@w5%3@<>+k3CtVivB2_J3KsqB_k^nREI~kqHz`j|%AX+haU0X!d!TjE-JRD31sq
z-n+>1*^Uu?FFz-y{CdTyQWf9i>$l@u`3z>dJ5Q*qKku?J6SXXb%c-RVDqnEV=Xp;%
z*4yZsfq%q~&<7Op5`qv~7}ZQK7Y&0K7pva-obxGMGBh)mJNCry`O?MMm&`osi4_$3
zs~G35w=EOu@uwC?(t@M1qa?!$YC2x#RNRYvHE<Ch7Q=*otR5o0E8^SU*G3IY;W`cY
zh9|b&4oqD39n5@Rg=3kHU*@_J$?D~~{wij4<9pA~={Z`#X&KDNqj;lES~>PSDLo3*
zouz%Kl~o?GlH@B&tH#yXhFNfHzxFcV<Ne+*?@WV9Ni5VpuInjS3G5SWYC2}ZAIUh>
z=|Y*e6dGG^|1d+zgwve&Q^8yhZikjH>!kZ`tm+wm#c)2`FX9pe!-g7uxkUBw`a&z8
zd)f~exg29kZ@YA<w`80NTE%aeI0oeC)UAUc_r<XSJI8vePygE^a>_5<t`!lF-9-WP
z|8%5iLo)i|(LpI;aR@1ivwKvGX}5OepE2tll0Od&<8Po%IPOS`{!X&hf4rbUj5~pa
z#*a=D<JszrX=geUqWJ&iu+842D8{uHiDK%!*>shDo!|uK1}F+ZsHDYDvSl#Eqx{`x
zyDpmaQvXZ1{J-oSRghx6d&kzr<tZn6Zu3kD_O7m=UsW(2`i%~fO7Mkn*mhH~Dfz4P
zWSmTR`pNBtr6p9W_sKk;Jm}YIJGaQxAV69NPimC2U`|e*K||Ds2#eG<Vo_&Oa#wq!
z-zlH7PZKRC3qwpG!1xxuGhimPu6b8ZkLvyQiKVu&n}ZX@NH!C)D4XW<I|9bJ)#H>-
zY+qP`TG^$tA4?Xg`*=E>dJ)IoVh<p(fAKy`kibMiKGFzw+-u3GlB_v2yeFh#Q8{#|
zk{a?8Tw`M4=#|Txxf?0dk}HLAoYpV<fBMWHIb5*zCMX2om>_=6h~4E*iLp<Yp6zR5
z;dGNwZedH$F<M{$%;94Cl@(6QVl5<T>dCII7S7+5y79E<xMN=b(<)XYpV#xb1xyLO
zZ>X<a+YkRcyXl&>bok~EQHAMKvl`n+6-q=G6$FZ~KTM`&+TFz02D5Y3kFDH0xjCZi
ztkZ&hH=GcT#3_B`aeK43&q_|`1oU}*P#Vvi?XU5;TVf`Q@zs)Jyt^5eT2Qb)Z#Z3O
zC!gwjz(<Mzj!GoTOweR^_VyjRXeG-t^JJ>+KMTAvM|^f?=q$b((+^N`YjC*o<gMf2
ze4GYA=xQgd)#>wYBHp-?I$*E3#ng>H<2-l6>RZG?`#z^jVuaDg1AYx{FhNtjN1Win
zti6jojqtGNRKhk~?Z_qZvKJC>M+UhEuV@At+_=>+lJmmDVMjBheA|FRYCpOhenM($
zy6hcS(p$(>p^&XB1p7jS_Lu41k3RM&1b=3CLvp^>$Vto?q+^?42UHw23c|#9Fu*vR
zN-}tZtW&@2!*R@X0O^pQPhzH#ijnZXF`0IofOIHWK8hXGkiJq?Ww#Ea%p3jw22p!U
zXtV$L<{?frdSCAGS#svKFF!SBkK1eArlLO8vin@!;L}1{8R`AL8()Yx2U%IEhvcl?
z2~YBuW+xUi8hZAU!JRy%LWSGqh|G^@*ps69N2HKCGQLfhI=mCzX3#05o~mqJg>xwO
z>T{7P!}`ii;FPQVludjp$@ZhyfLn_Uchc*u3rm_Xtj2iI(V4DK)kY4!uhrkx?ww1O
z(6`gcd$j1cyq47)X2ARFRecnU$JgC_tk0r*lF$0xEg5+~tuvw%z%k-zcm5)O`K|76
zJxS+-7&l{?&<EP?(J2aLJuYiGa$n$HBv&V0i`Ra%)~7^y_p-;n?_{gL?c^gY0rMpp
zL&)5{Q7IKYsP}fsG(_(jFW0Gh!1K`XWQ#(i?xO4`acj+>Uoi##sI4?-GH+oN`;S|U
zPp+QVkXcAJdBhSWHUI*5sjWmSE486^5xUh^?G~6rEl33Jn|<K&OY1YxRoOuL#0@-^
zg5^}YpsY&fde-q2*Mk{x*Kw9Gn-M=#4qec@ZioZC5h<KF_-r&<$wakdm>9#ND;0P~
z1&$zuB6OvzuUuq2olvJ~tI|Xvz75X%_j|~!dsU!)u7Ay-Rug*1Bp(7nv4VQgE3ClA
z+KN+)!HwZvoXdtb1Ke=YYs8K>v^*d!t6W|6X~yup=M8nGbH+#i@p^;!&>vMXdk_Zs
zaLqZX^x)kYOuCf@lC&r9?ZFCEees>SNY{b{mNV&RD7LOw_!;K)J*$+0Fy;;|3e@zj
zsaW+`OfbH}BZkTRgv!5f*ef_bc|rx+ciOu;Ut)+A1vL#)Kw>CiVHw3^+n5G1r6E<A
zve3{yVK=M*tvwyk%H97?qzkhS^{i^{F+JUIXUSPAKg@~=P1i1XgQ#Ei_m^kCI_pVI
z=Zj6rbUeSJ0x<%!BUuhait3RUsKTP0XhEg**0f|9wjp$f1_XwY>`lycT*JIU`$4-3
z`)@CAH0r>k38m%Wl_}M!^_k^bd#T?qCusOuJ$pr4`AD`t;%M;bu-8|L!2{@{jLZi2
z-D))n2ju3QrC1IRGSewr4*&59#Cw0)lSm}<dk0!!+Q-!kx^^^qP$kMeIbcz55Nu3Z
zPIqb2l4nDw;9ZnO&hD6LW+`V|v5L@aswY$^&uRXti}Cya;l)E-xWI{D54Dv@S6R`e
zy(kcbAHWZ(7f3fSwh+@>Z~eS)eY?zl#e}rqQnl-FIEl*=LHK31mr)j%aHx2!YU193
zBaN)iy>rjZwx9U-#~M2r+VXpA7uDhR@b5Uu_qh9T$07czH=5(Z^u5Fm2B(OuRa(T{
zjU6T2RgrR?bUHV|GR912X(!+s7iN#SL@B4%xlRG&4PZyf(vEJ~Txh_iX+uQ*r;#ws
zP?xt29XN?OpdNR@tZ*NS*11d5pmopEMaJ7;DT`_~WxO6*2Qw=L**Km${gQElNOwp*
zPr4x~APU|7w~en<hvS66*jI~mhN`;e9RJO2hwdQRxIJRmGr|4tVV#bw8Gp)X${W^}
z7fhc(OwXJ;^Xo#tau!+zs;$eVXXm}AJMD8#CaE-tQOwu!-lVz*@`eNvXX-mLFMoAT
zos~V}zxdqtHQD}R?>CAt#J)1tr?zDv(Gq6DN{#j-kzDJqK;Evu%>P-xNHldu#^9Co
zA7=CKByxrhaE#c$DO+a;XL(~$mP{PNwLr*})^x66Zh*emCV~yPd$ihXbG4zTP?ubo
z60iqk?p0A3<DZ35i86KMFd%dN-&_gu4JZg~eFFkOvPqv1e2emi;}hHWUsy?Xrek14
z000PVkR+Qf2nE(rAc-d{<=c9>c3~TKkUW^nujh7t5HN>*2rfn8PmlNilY<z}X`^4-
ztEsDB!46B+;tJZMGX1pXtx<~KBG&6k9v_U!i+cD^CHQSJ_dndyC<h@TRc_`;V@_TE
zhWrqA&RRtAWkmJB^0-5l^YG#x6p(&y)vd^0aQrgx6e!M-muwD(e0+QnA#kEO=EED`
z$|v&axxBMx%N9Of`NwY^WxN{_rjzH=dG<&S9%b}c%(Pf?Uk2C7b<B8UoWYG{u9N~l
zb>(>QFL$8^oOT3^)tAU$-pj0_Z%5@5lPR-z>c#}~=iQ>W#MYT#LQ!Wco&mu_dYxm~
z_}cFE#eSgD4%h=sRbHU$LN@uAPy>Jo&nZwaB}{hS3g+1V;ZcGJ4kQIIl}mOP^Y@GR
zTaED1?VRWbH!d!xUB)EI%BBaCr?+vjqo-fLR15A>sayGoNifzK@}+>8p@QPt=0W4j
zn&Zpz)*IvytvtJT#MkMmPcVG5*em6plHAG~%j`LyC+}vna+|0pu2`GfD&Ah?(F$U$
zhE<R({Obb<`aWT~={1nuf3B{%dEofD9I8hTq6^1sSvi!m1mfp`pDWeDO&^BKvd>|R
zk6qE6`*ip5H}U?f@fWv(4n6Rg{l}neJq(rNfH0VB{+FfVz94_h%&AFr{KjrS%hLAV
za}h+VNW)7Uk{_v1fo^r0GC!%PL_Ry+Qx<{@wc4o;C#Rq3`r_hY0>wva)VmjlUGqD{
zvX`A}RWZ}3SHz-;{A=`i)?bmb<TmcBOzH*Ct1MPo)ymHbS$FSXP_26-G$z+yGn%Y(
zCQ|7mfrYFYn&uP*Q5<KVMxNPs^aX)M*2CfCD;JNqv?p@1_a5<jP6_fk+xUE+;vTMI
z1%S59!V{Z$K(a$USEHN@9RnVf5t1^WF@4vD<GVfY-;b1UCX}(uDlK1-(O$mSm>@<E
z5j=hSqLIlpg$D&w3#&}Is<{U|@4K>fCr(M@MnAUsTljE1;oyk(-KWbyWA0bB<o?nv
zKG`GP_%K;qWAL*p4LzrN+m(0Ma8B7%uwVsz1PO*+FW!bW>!6&#xkDt<DT9W~cqb3P
z?<#9K=Vuaat+BQ|Kb(?Zcmg9Lp}h-Dr9`u>$N9CLG75^T>+5%*8o9VS;_16PxxD%@
zJJ)*hjC8^$=dfk%j8MP%jm7XbzTR!zvz`Yf6_dnwsjxU6Bodc46z?p`E}g>cu@vxP
z(W|?O|EOJait3VJ{hg)2#cy-wP?UVaP&`wM(+__~5c#%zFO=tX5ICfteMwchFnShW
zi@t~*UhAT9D>f+hxA`%<dmPE%%2y7j(kk03@TJsgLSYwc(~)%AioY<?`I>U0PqyBv
z6~psP6kFG`ZqYQRPZp=gj`msmp56nkhEG5Hg6}{oZB*&us~CKj<EB%q1`^Z6=&AA%
z?q(A4Txec<b4ew}lY?!i)xe`6S0S0b9kjlLl>F1WN4n>IcZN(|e^6b$;-|^=gry&@
zU|7J}f>(|1{y-?+YSwq!i%hD3si5E2edC-&fc{`8{$G~@iH2GqA<<CORx||aj}4-?
z^5P*JvQ|UFA<kdn5N$2an9>xwB-}_>V;4P4|IG#W5NqEEkqK<Yi9Fy13U~<h=zTQz
zl7pJUKQ<mZCD9X03;0D_k*m+x&{pAgXAiYCeO3K2gako{(@EzNtJOU8t9I~L8^jGg
znV(@;)m*MheH#9uLl?fant0G=Kra(65aJTFvR5Xj#!Ks0t%=Wm@~YAN!v%t71Q}F2
zpn!H9x@-e2RH*irGe2A`PheOq<oxC|4VHkIB9mxCj~-`w23mA$)JPz7>%TeFK9t}c
zDyrL$J~qAB3T$Rvuv=?{#y0GX$#G7|{r8Xlx_p1Tx?IB@YP^A68h->cK$rnL0BTU%
z_-Kz`e)y9|G@MUUDjz0G_22Un7<T+BivHE;o=}4g{v#Apr^|1@GZ1u43k719K3(2P
zI@r6JP^e&aG0Z0A{`CV@j7ad?I^2dI)DhJCl?%3tRHJ}C`xpNni0sq^=i7`=!-<1N
zEyV3YBx~ECvQ@T3q+I?C21tLbPD)pQ`w-lXU!@rUwIcFc*VRd(D6(&Wl>ky^iCRr}
zh-3c8n*(MDh%qdK@RPiRCB$@X)srM3@PVeDWc1%Ge*}?EsTQ}Jbfurc#D){~seV-r
zfBUm3>@a<*<dtB!dSv<jat2r#@_#;Zt2gF@%L93z1ir5Mj>f@DBeI;(t%GspU)T0O
zeA68RR3x{?_j;>U^HpC}c71cQ!=BS1frHbxVusQcIovwDVy?e0I`>zfs-<R;rpw6x
z+u^~+tLh=*Py!07QsO|nB~@lHpT7DnskiM=|0Ra@hW3g4xntuVZl9m6SdvNgPvQUY
z6?N{IvabO<TJK?RF3JWWoolZ-S`n{J{C*=@bGM5+>9~~IAjZmAyyN}$_V)3}@%z`x
zPv;pwQM2!_N_J#kXC80VSI$}~#B(~o^z*1%Nq#<6_52Q2m5WDD5V1#{G^A1#^padK
z(c8m*T(8$GT)$jUSw9l}gX|8{RHymfNO0Kf25057$@$8g&1YN_6K30jo65bkxr!Q(
z=ojU(ycXCZt}b@9)V?H36016O-exUAsoCnng`jE4X<C%lBDCLm6&JKd4C;wa4MNHy
z;w8!b`=}GWSp|Jh-F$ko&rRv)EKO*O{YaO?x-xW{lG~DJjtuq`CetJhxqHji?o9Tu
z{d{SBtUb1Znk;dONVlSV;%)C<vc4$E4-U%EbONIUolz+VtbmecgH<`B2?a{4Q`EA`
z4C1hezZA`GQK3kEzk8qE_HJ}pZMA#4l$3kb*Y5sETFKLCipm@I8Lr>aP+$#kX|0EL
zTx|K|(eshBbMm#6cN!PR^iL?;e?wZ1#q27H%llAF{$F+sI`u-2=o%!DC%W_a&@l#z
z>qg&XjLMJP+JoxI3B3D8(DQQUL_xKMn0a{|@^G9E5+|wKjH)xD*7ooaj&c5k7S8Tg
zDUL#^OAGu{>V%|)wv8xE`=Y^$iEIWmcIIi(Z^P`mlTDOA);E&f@vQV%pM36IPZ?14
zMUk*JwJ8QmiX;HeI#}2^kX0bwlZ&ZfQDutIt?;<aqms+4qU!nJ2nv437Z=_`kE|FV
z2m-^t(xJNxQu5;0+LRw}RxO!c{=xUmhU|hxo#xz=ZBW%x<|d&E{^8Ys3Q6HAWDQq~
zvBOQKwvVboE4vHTza&2&-}B?4ZSv74<?H}t*q#<af=!U@Iv>FU$_wGd4s+5glLuut
zC<t@kH^(feth}pH$ThE)dC1xBZ{hs3{E~;)yfxVcFh4e@NHBpD-vkIp%}SM0u9>|^
z`RfaO2^#8)kN|x64lSqoCp$JZd}msxx)btD=Mu;Lw}DH6vMLEv5k#0!C)Brt><r;{
z$d>VCj<CD#k-3~Eo23Sk?(ogWSjUg=Ls?lvmHe+`8ji5BvFPuho@g=Y(Udv%-h=Dl
zj+2)!wE7&?g<JSYNvgLsjhvP~{LMj<s|%g$2{pDByGOwdmq?BDjJDK6mJLTt6&=d&
zeIiy7T*c5&vZVV$n!Cy_FWb%zsF2L)@3kz$+Wgpa`SpzTyULR65#jl%)oL>ikD2K4
zJ_Xy{c6DuioxbVU<0E8X;mP7?Nw@+EWB0n|yC#k^U6&1)o1$pWNvyur={h<1qx|qK
zN)#$&_qj}|v|v`sU{blQoCAHig*;d-eKWk_fq-v6c--mSU%_+|1k<t%RHRtjRe{hI
ze>VBK+3o)DqfZ}BnL@z_vI`T)7k$BU7k?+t?07cX>wtFH$X(1S@EhBaID3m`Gl%u)
zDDk66P5L%~qd*6h1b*3HbS)S!hN>!9AXFIojwTJar*eT2?MpWBvpMTni^SQ}qYS6-
zV^!Z?!<23M@uW~Z5R``H-HO5g`7;U>Y4>E)p#!uM0pf6^>(Er{<2R<D8ze`=`Jn2_
zh@oqX?=$5ce_5)MT1~OX4^K453ygnN^ky=mq(@(F&q(Gw0qat9Hv_`k%xI>6`_*yG
z?+qpeWfH+AV$sG8fAk3FY{_`~{f%d1Zm@~D;B8@{MKBP7ca~{T-{vgm`OfKc9dXPo
zYM~upnQJ_zQ&X!c;7TbT#tu<pfrNYcOB{f#W%KI(>9;}nZa@Y>8SzfuI&tQtYv&<{
z{3>+yN?Ki)Z%!|`M4++#^UXL+xLW@G?MJ^{+4R#sz1J+<GbOQ^oZ@pg@3TpeVq+!G
z8=n2x2A|vA19p(>uR*hasOM0a;1LT7sP;gSaQiH@ke6BW>e?WaUQ+$@j^*X7hMO8v
zBmD9|srnA{LWx2i@+w_55)Oy^f>N!f&&Pr{Q76Kpu8nD*7tzIp)gP+=&Ky@z5`*KJ
z9^ucxeLGC(nle&QFV<oQr@M?5pljSe>x2JKfAAm(-$;SdCIOFXPL1;uj#UmG9?!t{
zJf5;h28Hr%AEC|q=lP>Bd+c$H=!oe~ud&mO5nIu5U`PRxj*GhUrzaMok9Sf8=ArEQ
zj@U?+tsr?PjU_k>)~tcq+EXNZ<ON#ikTMpzGN3uv%2)dO*YGPgbwHl+7IdEjq$rgL
zK7;h%QfeU*{EyKyAmNuMLXeQ_IaZ+9qnlyY=d?waQY6pxtPCFx3QIFRG|)$c*l7ZK
z)=+DI70-f3`<>*N-7v&N1HSAjbVL8uTGIb5bmrkaJ;;Ejn-=uN6$XIa7?&nooX;>C
zzj5JMaBGtBUarAter+hfI&@?+?`8h`nbiCr9cbII9DnUUuLRX8UvB5Bp99M0cI@WJ
z;yjeP8?ab^E-J+HHl${=Te$=efvSL=hWo5z1L)*L8A7=Xe8Lh$;)XtY-aLfXeo0Q1
zdxJPY<8tLd1nUO|9`%&y<ToCo&|5Z`cJuM(e4*0%j&HB9A&AdU#oA=cDdhP26-O-{
z>Xn-}O{L>9?OkpT+l{kqbc1Llz89)h$sP-Z*!kAcrkqDswm;0CElkRdKX~r+ZPNc-
zlp^bAH*<RqvI|P?O6yKhie2wgmm}a<EYs}h$z$s-Plm~wMZq&awBWm{RxmV3<CC_r
zITqzE@5Pb8em$Tpn>esqY2VbYeqUw>6j26RerE_b_<j{O%f)+%ygnAy$c-|hwYW+B
z367&N@GM=?`q>jj)Tr8#`Mt24*$X@R;>JQ56#=@l9KXqje)vb^(4E}PZpcm^(26wn
zj#_~${pnY)Ik%b)UC2_8O14z2Dg<FKglaXH4!#?0XE+S-5hp7Rsr>iBjLwBCS$yYL
zprun#LDav^dG^pr`E-7vVE!STJ?0Qou7mvcEE;%=DFq0}s$4G33)5RV|6r=(hB#oj
zkt3^1WA6RZJw`wO^X4VkWRs_tqf5%Luc;wUSsobfKj)oVoL#cK!PpoIEAHb^u;CYU
zwIR_C9aTFc6CNe63Ejd61v(*U2wTk--$^{WqU262*~Z<w^!5Mo_T}+VuJ8Zar6NgA
z*@{q25kmG-vQ%UnLm>%8NU|H#BC<}%9?CupBRd(&nmr6+FekeiOqQ|C81uV_vwhC@
zoX_w3`{(ypy<Ro*-19uoecjh}y_YMp2l4fX{cnh(?p4)&TA&Oe-`FME97>=@uO`_l
zRuR0fB!i)Hlfx6ns<gOOTIg)ZdadefjC{%B7{7b0?SV(=iuEV+wEK!JI!c}Bqs-a@
z)Ir=_G9&yidmchct{zIh9V!$Jpo^Qe@CUJvCGP8jBWj!zB5HR*Np&FTTzK6iH1)ML
zEYPX@vEVV$!F~N);7)*w$;{m~;Q>E2K+S^G9grnKYY2#<sxL*4T8V$Zj1sX-Hf=2h
zE!n=Oh5;>8lrKptbrxQE?n)D67@eH(G(o2Ut($DGI7Xo(<#+jeB<P5m6RK!lW`Zm%
zT(c4Ml@;pn1PxoD(&eBKC!R}Q9YwClswOGpN%U^QZNF5IbxnKsewi}3>vHD&>exB-
zBa;-J;lhaTw*4D3PjG6UiD3rltx^n-TP}haTaWr|irm=dQvb1gT=SkZPi5Lu%kfq9
z#^C35ZaOAUf=r|z0eToJxvy(+$i^qxi`>P5fNdhVleCmvo~jirc%a)@?xvU(5PV0x
z-_EZ3V)lFbmah!oJN_|Iup>^`mml8=*7h>EPxwCe;yr6--mVP6+|n?UKvdoa1XTXN
zlyb}*WUKkhq*=0n^Q;~)Ihm#9X2iR<vG1?NSr;>6ZgwD<O$HX`X+&ePFa5avKqXfd
zv?jp^-cKR))88WALvCpMaPji@>9wxXar_0ql=TDwely1ZFRryv)9ktjisR+T$`V^j
zM%>Y(X&`?*6q6z30pO>7lT6EG<gl;+;^{JzSPO`=%nla!qQyn9hktK<M)gJ>g|=s9
zIq5vye_ElalI#+Q*94yizZ|emK~>7a@>K(nZUFrh2zS2v_(k1};Ws5%SSx?x`;f=e
zI}2FBxXpy^_n+0YA3|k~Vi@VIh(zbEsg1BkqXB^rBuRiz3YbtVEPz}39fbNsK>xkZ
z_wgTYOcNVKm)}6oNdyhTKOjl{&t-rRl@rUT`D@u-l!VR)^S@^|+xbiu1q;gplgR-{
zsLV=;8B)B&AfvLWsi{5uJ#s@&BTWl!LI<kgilgVLlDNM#&;gY|(VYO7vrMla^N%t%
z#ziqCt3vG2AY}$1<v%~$;V;drN8xYlzkX#MwHy(K#?FPR+*9|OiE9U9chxvck$C?%
zLVib_|LddqgYuhHnV+)xOi;>hUOI|eWjDdA^<SRpD|v31kC(8rx(eLzXi22Q*@m~4
zyp%e;7OW|0F#n#kANM3!_`j`v&56*hcyTnbjLHbk-j8pRJ#yt}iC%DNWPSvwA-1ps
zP#A4zxugOZG)%fR=r#0$VSCeRu4VlQ?v56fB`(UFr+9HNd;PpMKJfO~?0w$g5Bu?1
z^~@#w`z9jQb3(YlbeYd@9mE{NOTohZr5>doaT2o>0gUkfx|f^?5WLQykdqi5w%_{u
zwR6KdHQE~<2O!`^>44W4l!!}8rThd0L0oZ@7`kds_>J%COQ~7`oY6fj&jQ_=HfX_Q
zy%NAqmm1rvg1!nOLoHwsUV%N=1?Rm{D}rX;?>2J8Q?b9{-l<wyyLmUAr!dcZ)A}+C
z<sF_0B%Aibpu;@k<fAv_Ig?r0Cd}hYc;qR6*0flYzjW%NQ)=HHZ};^njgiGcx4Dbs
zhg~P9Grbc&A(o{<jSiL+B;5{3CV-u~?UJg;{rgva4iqLbLAA}0W?ZsTLhxB@8R^(x
zve+T!s}BcNI5zZY@|Ae?V9>?p#bBZ9$4XKej>q|Oc*GAg+P{ZwC~x}-_6*2ClTX*W
z6@=E`@^`?E%#OW|S}$MdPCf!w8<C2Xz0JOqL<W=-f(4j{`2lexV%XqO<4T8JRUZ$v
zGqDQUu!OBL^UV+TI9xc(qW*<*D|GlpsTlbG=c9$^nIu==vB;;*f!4q&LLcDjf^SSm
z9O+W!(jr4-QxVX`wc!bGcopa{_i-#@tBluwMb=-sr+7*4ap-1X{QFu@qVI#~pw0}q
zH!f`M{XqZ&{@&h7?|5tZ=hHX@EdU!lg?UlYW1Hc{ag%v+f}{iUykX|%v1IDFY&i?g
zn)H&hdSc{<8w8)qWk%N|?P!hm-R2Um(yxDi-w!im_xaAvFzn3BBz>^P#pK^h(W>mo
z7BKL`<AhqITp7wd*|ii0i;`r8$q#k2O8@ravjs8tP3(g$D*gc`pTe(|!3jC4k$M57
zNgntZ_>>s&!<d8efq&UL|MU%LTg!BfOosOV%T+gfiU0Xh{OgUL5P&w|f+90}SBy<`
zdGd+@>VD%d+rY&rxK!G=_5}LEKR>75Pr?AT$++ET05bSPu?4er=NA5a760|By`+5o
z{&7}U_`S7^7WUbJ=`XC1=coV2CI{U6Tc8kT`FwRtqTs+J5FNiiv>$RC>SHl$GK8e)
zQ$Dyv8w+bMytODsRvX@=eXEwMJ7RI=KYs>uH~;JVvv?Gm{iANCv@23&*7#gnr5e90
ze4R0bjaB}CcuuVvu)vqv=OXSWvYm~;$$Vot&ve`Id?MQzf)Mi`_w>In#<Nb_;Ym%<
z8qCKo-@{X;H7yT20wmu5`@5sO57Lurl+w3C#Odrgf(XfvK<0PZHs>ckvXTTxMX`tC
zUPwPk5&#VZq;`OO0M5_SZ9#w``NmawD{YhZGQ-rh*a-?&Z)~+z^4=W*FV){4@BTCB
znTj0zRZ<zKb1HMm+X<v#W>YOK8PVlZI4X$%c?ioh9U~B*hr6a@S5k6R7mu!uChElW
z8Z%7vH=#oJH8GVRu5iZUbB>+ZD!F&7UQ8mxEwD4ysfxHSQ~5Py)K64`rO4uT%EVL@
zaly{xp^{82z;AYDJW_NHuKe?7i79MV13Wqwg;OmSP(Xg1aBx&0o&xa~eR1(d;W+CT
z7o>`5=#Hw1dFvJ+DFBj#Qa(iG>Pmy#R(Sk4Q^!@mau{!-Kzdv}!z;KfTdlavI&XUs
zFTY~JZXkwOs~rZO5-zWSmO@8);rLc$7wcfeQh)7GodWNt$J9d0CXk3}dnVxvngg?k
zr6usXiHmQZeyTeec7M9z;pe4;(Cr2#iDl};Iwc=}Y0eKdtxV+Nhc2}bQ>%;S&-eMv
zx!AN_vZuarpZ2`3*n=291GE>(nJL|1y;QOU3rk{_fb!|e%<t_D3;{zT4>w}*tH?wW
z^@IDwbq$^G?VohKW55E3Jr;QDH-98aE>{kD^4ZDc%<bK^sL#Jff<mq4AEKi4TV~<9
zM-ku2kUIFF5A=D(Rgj>A&z(GJjmgs$Op)+uweiW7*q~{Hi2XF%>&$s1IjY0FtXiLE
z=9I>v1QXA&@=RYqB>u!`oCE2(XRVgg)}fbcTHUM^!4l!)9|h1zz<hjZ%sh3MbiN3+
z0!B4lEN=rbEvp_Y^$48uA*X9)iGigqDYea`z-)AH8pAqz<)D7bz6CH)nI$pXpBr4Z
zM;Iy|dlFo9@A~Vg(qyU|co^%`T8J|MdL@tm@_4DCp2WGC49<t?{-(@2CH-553EV@N
z+1;~iTZo%5`uzS{4`6lM9J09~ST1FH9f9hgvMw*WIF1){%Pb_LkhUPJeYl0&Y$lm(
zpw!8@Xb^3nDOt~CTponpVe;vw40UUo5m1~ewj{+rERVkS1@YQ<7;dbddt+GCelurb
z;_{ow6A!&^ho3qb9R@%x#PR#{i&6P6q(HC>-JtDbxg-WW`5USX^bpbePm31qPnPmc
zXa)H-ST_^F+Jw-SxHt|1X#r4G?E-)&XdSS8Ljl8dxL>nM=gF7@)h_F-(Sv{a%!Ddh
zDMMVbGQ~~a?t}jA=&Z;UpH~V*uW7d-z?i`}R9#Q>{`v_gNJ@;scoYsWQU&!sRnMjO
z@W*|+k&x=R{<55(YR*~HT=Fpir?rPYD@LQEBhj4BL&T_7RD01N7KfBA-1VI{aQ(y;
z-qr)1D<A||*1K*70*VkiWF6RB41qJ89tduLCkG@!+%Uk{JX_^y`vNgp&de<<yAF}(
zA3dd9JA=>e5ZA~eb(7}L1IPbIx8wwAb2z!lM53Q!YryUP4L{S>ak+GrYUhmy)t0X0
z;ECmOXwD-0yLW(dVW+a^+D@yH+GYjU>B)?=B;h^To~aYHxs{Kr6;`+~T5#VdZiY@9
z>*>VKT<|&bTcwPj5`ZT?iQG`jl@zS61MOQs?!L_o2PCe{lJGqzC@lz<>Bsc-KU_8K
zZEpk*yX(1__-a{p<>F46VZ8=G&U7I)U!!~_`=Y97U)Hk@b+im`Jak<shV+Oo_D3Xy
z`6gz!#$p=W`;Y<AM{!ZdZ#;#q(X~FInx8M?JT#7SoZB<e6O~Kq+0mEy!KO-1BD=0I
z)r(@zNNX?mG_+p1#BY>=LT(6!>m^}f{3)so3c=`ltI&<JHEaOfWQyb88(`TWI}iqX
zR`XJMA0vQq?R!<`x~nZkoR8&Cb!?uSYXx+iJcm|k?g7j6;wdqKFVT%X3-&x&yY?;J
zK}9RAh78!K7#2IEntIcUCr0<-ic2v@yu6Oz9@NrTa*8JyjmjUyS3Q<Q8Sz(e^=*QO
zk@}wfZ%eb?D@XY|E6uP!kc}~N?JYRP$-#H!g<h^tEo2iIg6@$DRM*Z)9c8_9P8-L)
z(4+YaHFmBoHLGi0p%t^8H|;*H-Rg-xK>U)x)0>RxBT(KB3_gB&jg&I^RT^B9Zk||l
zdx_7pv6GlF!NI11n#tN&J>VqW(N~&%S^^o9Y13$&vjgE)ZAbbwDtnbRx-W;U4}Eb7
zwv82%$ILIEX7gBz@axB`T^~LOeFsvtC1x{o@fb8aa~p4U2AgF)a!M@e8eZVjH8@GR
z*gghl+eN}@w8K6m^~rhozET(!#u!9K2x4yNJ1LIXQD8cE9@>PNHnBqRj;keJ4sbfg
z5FuTe;&rlld5?q<L2*Ho654^dg+={PIcd}NoLH%0M|y~qw*x7=pAIl}*n{|>LJ?Dx
z^<}tIr75r0kiGZnsl2$42JTSBld9(ZT3B)&9_J$OoE|4{CnAhi@|{0H<fdR4vXu0-
zoE&FzKfc455SoO!lI)A|0?i`L)`S3@=AJ%QFIlRoU({o8zSjhin5TRqQ47G9Gm6|4
z+j;Uia&}e}2xfpS_(w29SX$r6z36GTWUd37KSvD|o8IL*i5yN261CYFd+ge8)meJ)
zzUBc<K}_Xs_{xNBo7Vuq2}*K$Z0BryKfR=OV?wiRQ>>Bn4%K*J7CVh?m2>IyeZFz=
z3%z5>VkmltsdaA;@Xyd30Pe%MubdcNbuMWqRh^-N)719%ggnvff|!|1e`7~U(nAe%
zSpR!pId8eb;h3CiYA3&4>Ok7uv5nQ$Marxb6yp=PHlVoi(W~}07b36nGTiwGmyKC&
ztT5DVBTGB!#C|TZxA_aPllfABOtI&;4$ISQV<1)iOX&67N|IIpMDO0ItE6RRcmKir
zs+alByL*0Wrwb_9tIAgz?#6xl8f&7<D?5k|gS#(z9_TYaS~@#y&_l~14Qav0n|XRB
zTuXBp@!o0F368v5qfPfenR>Tr5x)voqjXI3^_8osXI(E*Ttssau;YoC)3wA!-1ErP
z4*RlYHc@Swr8S_7Vcp>GCgMI!INc&nj1Hd+h-o&IDUA#&nbW6~pYEKLx#Mj;*e$ma
z?B(r>{iIHU>p8$&UsC&LgnQimo%BbW#ynj+7(NnSRqgt=!{@VmB@$EJ`jQJr9f{u6
z_y>-W7`LM4_Rv1FFMhx;>-UhRzDb2(*~Du0LgqWqbkab7<rCNd&Js$G!>J421#X6n
zK<ZQzPj<HoJtHJv$^<*Pui9`0+QHKsR9>Y$E<-#xza0`jtBVTW&>`4}QHt$LQM5d2
zRK;{Bx}{4MBTzPRjq<to74bT?YGz5sHFr(Zeu8=?3PrriZoF6RlcjZSL2?$d@?nJM
zM*8F|@n^C{R#j;SU{^Qi^q4o^$-RcJC<|m>il6v^d8xJ)RQGO*!}2ZF3erPYymbsp
zF{!nztD{%awb3a$+tt3qNU(Rs8YzhS)EW@4oFlGsvZ|x=aVHh1)&JNDe>wI+f6MMt
z=jCy`ypLT6z)LV%fV}q5MRYc^-Rmp*>~)_s?WeRpz9%0a>(Sz8b<Y}F_!_8VN7@j%
zzQ>dUN>n|AspCg^P%Q|Ww~ViRP#f{b?L24<ec?{=<8jgSq_t25ua!Pj%-qi-t}|^W
zF&N#~NW;Ln793a1KAz&ns}JPR_XR_{CT5m6>@MeAc?(2_DfsHqsRX~^fxgPejB+9u
z2E+iWMAdt7-;2~mA|Y$h*Y{(EUDHdum*t@Y%OMry21t*{q(zqFF}NPKj4DJyIw8`%
zn%V{RZHEZM<0OkRdH_*^0vF5Q2^f>VXD7gUp4pna01}7^U;uKlpha(Axd%Mvs_Ohn
zrD{_%m8JH1{*ETk*~T6dcctvP>PMPb1FFY(qTSR&Pw~D%+wYGTKN5!~mdQ$&6}G`1
zee(J>^QB$a^GVcz%v7>b%*N;sVrF$LN@a;2iR%fz))QJgnS-DEq}`@U4j?joNQ9nh
z-x+VBdk?<qeI9MXzDLKRyufSz=h>VN#eCn{(4&j;+hCf2bZAFcCbsHgh35Hgv?e38
z%qkZ2ibq;?LoE!eESHTKUL-5#a$xS$leoh!v>lULVl2VRInjKJj+BWH;igOY0{z4_
z4hFhi!NH$8!-2@iE1%uwT5qxsmso1{VS^UplvS-bchYt2hpI7z;!v7vR89S4oHaBd
z-hq|Sa=zoKY>eShv#f0f(2dNFTqgT@Wbvz8wxxBS8PG}HaD~@A!Ovq==qo&+%rUGD
zYFufyl^C=@?Q?r09N30dY8*6B1?1!*hLt-=PAh+;$pM}RAe}&S1yw&NJaYz+qp!nm
zpLtFw5r}GnnCDL%PiC@Pe1+5Pr!NEA^=UT`si>@35qUWJdQW(cyg(-4s|?0vqq0q5
z{mz8sEN?E?`=j5<Js8F;pDXF5sxhOqppZK7)wFnOCOL;!&`Ucs`6SvERz5w|7e|x2
z(rH-J?FI|HZ~kthn+HX~r}7T^yz}a2uW7VUPP_Kx%&%nKAc<>;_stGxjEeIYs2y#_
z$X?P{Xz`EEgq}6ks;lR!Dc~96=NSg7rd}A+$IJD0{lXm~s&eOQg1mmXQEIEvS&6FD
zef3dLQFFc8W*Lyavri%7M3k9z#6AG2ObOpe+bl{zU4JQasa<hex!x@s&~ZT9e>>3a
znq^{{f@&v)wVR-T0CyK4uJ@UY_pq%-ox19Lni3WUckf$rg}CYMNpi(_T}Jret%yY7
z;b;Zx?<XlGPIqz&#LX;J^~Yrbve4JF(|UAwEjPHMbQ$-Iihh0Q+Tq%lZH;s^)HPdj
z@9Z1AjQ#OFp(nUwFx9bg{Yddd{Z!u2yj3yb_M+}CsH(m-F)-+QwjT<p7<$c8Y%1LX
z>Rj|XNIjE0N*Pc07~U2zoP^I9p+LJVZP@+EGKxUd$gUiH5ap^BRYXO7-kpJRLMna0
zO}G-5)#b82CHd$Kxewf3lCj8JRwVfrPk$V@>-_qJQU^`n_?eK}Ln93KqdsS|LN4zW
zK|k_cHkk(n*^fPHPe*=)bIyZ;Fw;WXc<}UH#ng_HvtwMOxjj)8Bc&TQ_7whuQ{KE5
zgQqqUOA;|>SA#$e=z}2#$o(7+URGWuFwRv4474|hr4TGxK1<UFgs>Ce+k>P#F4!-R
z_RHAU0pyOu!X?y1nn}*Cn#fNn$;u>G!RU+Tn7r9jK5NN2x=C)4rk|YGW0uY#CG;}k
z3mrWzIf{oY@;26gEyT_0I!FrMl;+7MAI~;)K-@^Qz<#EO*%5y1X|0KG%ZUd0<&i9V
z;}8o6b$rFo>&3LnMY$eV8!+4bgI9|7Hw9n|yo)k+PSqfwax%S`Ocy8XSycSGLPWJu
zA4kRW^xpXp*6$q@`217WiqGgh$~XUcq@2`mR|`@h)4k{z;{c12_OrMWR3>@NVadlV
z>j(yI;gD`OTP~P4JjqY+&aP-YYY(c=eb>RuS-_=p-hQ_!FZRdo&HIXcm&K&0m5p}V
z^eXXt_*dDc^Jyw1zUu4S_*DE7#<BC!VsG0B;URvnJbJ3H(#qE*r2ol#8Gfiw65C99
z=Vu1z_GeW~H3qtY7<p(R-qCIil^HKX`yq{<GI*YAnh!|Nn{eM1nCHfq794uVaGJTD
z+d)y=F34~$`^J1dk%!Q4jMY)#{+`x{f>*o5d7X!Qi2yXTa$iqNNsibNUlZ(U)0K7t
zU&l%O+?pVzHhCla7*w3rztZ#b=BVPZoY^u*C)_j6Yw}&fc=xlo;2xI`)O<i`?Ik#e
zQAZf$9=paR7s>cU^F?1uj|(EVeKo+Wr@agH*$w2NA0r)ak-BI}t@Xr3aYG63%R`7c
zF`WGw#q5<Ng(R({D#{(#u6`clWDJAejWFOD=1(qiOfYrnW#~omTja8@_tQrne$L(|
z0uQI!N<agqXdU&Wmz;q67%mJw|9puPq9QSohlF`Hy^DFRDCi&xe1nx<MR@>pc$Z#=
zFjTZHu8tEjr3n<Ol^)7K{4uqiY41RgQv>)4LG`x)0C-D0bB3y32<qXxiR~vT8-hb7
ziq^21z<s#JdVHAf@~auSoIQ+Dmf}&1q!ehZ$iO1Uom?H&Wdg1|*f=9EcR@kMvtfN;
zSDlC)f3CTh4}I+M30hzu6xM$}CCmf9`L#O4NFH=fqSV=CS|rYK#Gz4aQEeIDo0EXV
zn_;O8vorz8;I{+W4Rd9%L?uAAX>v$K+2>U1V<*cJj7FW$hK{5fG*oZ26H}{y-Ff!}
zs3XC&Z$Iu!fH_<MxJyerYS`{Nfti0y;*ueyfP;Qj`K0flLl6(N;TrDSrKOkfTAjgm
zrhstK6e3%qT6_z>=88yL=B<)jythP2z3sMsU1lY0=Jp5GB5vrWw6Ue*i;fNPPPK-F
zgYVBfl#j+$Ch(0e4HxliPGOFo6tSLNITy{YS8o=!e_slw&oaH@?8lCxh%zks1p0mm
zIbT0m^a}Bu1U$}*mZ=LBcF#4k?-QN)LO@ygt~jM2tM%cl=*ra>zMUPQB)-{BLl7wv
z@Zteda=V_K^0!qV_-Yafca%|7>P2rM9HC1k@mPG5*lY%v^wyJf=^B*DdGFq2Myjb-
z;A37;iJW?^4@Rm2{~=JDy%z*2n>S$L-8HDpUzkZG#xx3|!j!rk!WiR;M3X}8<fLjw
zAMsN+A${ZG@Rv8S#xqnCieRadj^XLoK$F2Gm!0f;+n3!<$^`?<Er~Uv78-?~Q#6Lp
zzT80^zuD23h$F4gqbnZNgUE9ku=rG1A-vS{=y!6r;dYay+48DY71YUe=?z1p<+$99
zH&uzC4Sg73!CwJQ<QoUDC{hL><1umI>tyb8P1#&^`&~n28Q*a3!&h%xrt3b!FTM3b
zZ}`A(C|{vNfawjW&PDyAG^!RaQ=0E<qWq&dvMtQMdnf{o@DwZHI056Bt)C2fViYiH
z^9T27^!rtCne2`2mtoGwHyb*cRfWet&g`dPRgbE^5OM#9kAg~n%V7uff-c&#K^VEd
z#U1T_+;738pZ{3-AI3@`D}3i%$95dl2L0gSPyy#LA21RCnd=LHvy(Ry=fV)6_6U*2
zEizjQFAn|wUoTJBG=F`)by@(AgWpV-nD4n7Oe^4R#<vJyCiS29jA1!0>DvFJvm=QK
zDEA?T0WW!Qro}Ek1|;3(h(HC;jw!|{-uvCiD<(JbJmok$JLZDmOcfB=cJ}cx1-3R?
zwoDn$GcxTC;>K>HoSxn}#KOEiUEVj>kolkZf6<TTusr`8Gw}e@UA--~`ioCKjj6qb
zx1sFj7TUmfKs!LuNvrChG~V~OD;^l2>#F$Xsy1Sn<|<Ppoy458f;D&j4nbwT*&!`}
z1^{|k;fJ9qo@0uFhL{kG%oXrf93Q*}?lv3H`rQYcY6{Q;J|_|Kr81!Jl!}ks5RhuQ
z0rTt+@J$i0tH2(0NiYjDJ%t#2!p039%aR0K%Z&8s9=BnR{h?O{DLJK<>Q4A)+56cw
zZofTu^m;*G0_O#0Bq+ia*kyerH27fmL5dqIynkdF!NOA;>|~s%;GYKCX@I{EA<*W$
zd7(=sH=$8LY&4u3`SGMT_UL6RijoZ6)Xqc(_ua{=YWP*ufYlK8F^E6_Uj{-l3IJCQ
z0^%Mp&0^AAS(YpPqwJ1*qNv~GTMSx21K|OaYHjsq{(Svj$V661$qT=72f3P{oUodp
zFo7MN5|TiR>KF7S&d!EXz2IO!pN{?d>oMd4<qSIZl#HHbJzrEO^v(Iw*=sQ89z9rR
zr`3}sY})~dsA22tBuo#Zxiq&vW?AT^y;5^u4glQ_Tc(e0Q7AP27AQMxVVt9yfFJ3A
zN<7p$sRseX;^O0-6YU#PucD|W=2_xs|DDs4QsE!kVgXlC*Bpl06)5Yz9CI3tD|LOY
zkaO%%TI1KN{<2nJ{3C$5fixWub6<l_E^yy^1{ho0X4b&%wa>Y*>#bXDkW?n;qDOAj
zi&s(5k99Lea*FIEE^?jj&KN?EZgSN3c}JC`^}(ksO(E<zlX-Jjh!dY9_d}WtJf@FU
zoAK?6AazHE?VO*rTM?s4+Eto~TGA-E-WaYkhmiK81Kk7;dU-z}_b@2<OsB~GH>YXw
zuXTa>OgFTZc!`wXbtXDCaT!H3Ap|Ca`60y24(%BaIYC`tM}=qiuLWdug!X#7y8No;
zA2oKmaw&u$9=5%SGOeZYV%4pf24=O%42wtR)4l9SEql2G8;hN1r^x{ugERSu2n_0M
zcd3?t#uEHyU1kO)_94W^_4w~ZH50d*y-dg<Rc`P&==e`A+3OfaPTV-;t}@UXpV=4d
zeJsn{=T#KRjxkixgZ^d8DWTNy2tx<2^UYGkt4(o2t}*u99@8AqmuF=C_-iI)WMSpA
zo|J8|7@h2uZBi%*DCZI@->>AFZze;N=g^v&+j1nF#L%m%{4k&huhpRr8d#|pxGjmf
zH3SP@&ovG@)g>kQ;J#1pm=0rX;bOssnRO@EI_>U8m$2PhgUQh6m%}vp{i9Z^WCmmE
zR?fQ$CRAtSpPN_cP8M{!T|4^L1)<!u4{|_p+C?{%yJ?^^`TJ1`-?PQ$r&Bar>fVRX
z7e^@4BU?tlcI7WtgK3{P1v})AopeT+?%FLc;Q9-6gx34m;t&C_P9JT=*Ob(eZXkRs
z9S$H3+Ub;&MfoH4(NF5w6y76Y;Yk`Lso)Pcr2%%3y3kQKK<WZmQBTzZxTlqIZcGZC
z9MkPW_v_X_td2nd+BOd_wjJjtW|0g8r7cB<lcU}(J*<}Mvy|V(1_>Vvqdbt>@w_P2
zBG~=&^&gk-Rhhf6XzhHKQ6{OwCQiwZsKOQ{y>qpnuZTdt<Wskc&=ZrmSO#3=@eTNs
ze&HEpTQBVVq-?G+)eGQDLQVXn&ilK!Kh&r`LVgxg^RmtdJHZmc%5u}$>fPZxL`xC4
z_d{iQQtybXh~OUiAl%7R9rMSJIUw?-p`}`^!Z!&WOJ1WL4yKqTN;4O<#BngoSI#!9
z)THoMb>Q|{&xsEKO#MX2S&Lgkmecm))r=<;3Z#0@A<1V$t8hGN>fpl25yWV}aHqs;
z>M2<Z7jmWNW{Fn?!BlpUG%aea)k@%a*?ARwyK?7>+kAEVvh0e*vON>OE4x><8gHe@
zlUMdlDdLhnQo`&Evzp2HI6-jP_StBvI+NI^GEMp(wpmbfL#2?i)4#rsYE3min+db5
ze{hr)M6`_Y2&&HdgF}|W{QPNUdSX7<8T=&QhZFu$A&>7?*+4^%GAbt=g5?9E25E`I
zI)&z^-O~Fa3jy(s?-ESXboYxRmgx`6)2g^s<F9_#)Yx;{5x3Vug0?KL@!++kh%jF)
zCXU;xK^5bPzt?Ulvf`Ur+Ko02GMlE1p-b0PV#LsZ2(Trbyh8rAeZWYSJ9f#3c)!(U
zbt#;yhrQ7KAVa;ht+mRrWZ;Jfg2dElBn>IqNB5D*Moi-pirI2F(!-1}-zZ3S9iaqS
z6h;R2I(M3T$C0&TOPq#?uHG2>`Xn}w+$--=nMbY=6cDSr_C3V6ZPf7Y)K!Y%U4YAW
z16&qpHJ&-X*4;HRid}i}fZt4+JNBoH;!${Zfzdm*{a{o^O&`-FAaS~rV{MxCE;sa0
zCQ4iPo`$d2o+`c*A%M@``s|RCM$Y>;--iuxkJ*83wu?gAn9|(*k|!*%$1Q{8psmi5
zlOJ*Mrjgen#f5IgpX02SPo>eoYt2K^bl0o8<%|@67g!VgUH1u*NoOQrP6Zo0w-lPb
zG7L|e99pR-RZA}<5?_5tNA|Z)6^;+AJ-xED1G5A#Nc4iuUx=Bht_IaD(<h*-FP|Tq
zdjjBU0uxjW{3hrfl(r@@B_Zmn7ok3(`A5agkvh&mUPyoclm}BiajejWsdx6-axFON
zUSd1@y<_l)AlVPu+nw(+JhP;WR(zYUPphDA*dRR)-+Vbgt26ATR-=7p?lo0ulXD!Q
zh%a=Tv7P&gbgv<iU7k!<_D?6n+)r7iFS}CcZ36SB;&+eY6Dw!^{Gtp8IXR(MnNB~O
zYJkCO)MF)pwFLNjfd2kl+E-PhonwzK;)0en1f2zRarf3weo?Lb%el49b-><HJ>=`&
zgEw2@OTf{*+Lv184u-{nVaAFRW;NOq?6h7>>w7x8dWEiy?R+gdq2dKx%q>*m1VvVm
zH*#)DAenZWrQucnOsx<==!HN%vX!r3@*_NpwDtgaJ&UL1v@c9j5zl)su;_+8C$zvZ
znFnf0o^iV4q+uyy9&PU4>xL^9<hEPMlmxN!f_#}KzF(o{WT~{AjtC%*k61qk{v(Ch
z6VaM2MMo?}NXtOLOKIO|ptv1|`sEu$74y5!YP=etKMVmO{U*D3ms?5L`KH;{Py;P~
zPz3^;$nMSapJ{Me7P=(!Xv>oHFn~6HOHf`#ox6@}@@CtXKD(7?85z0BtC>moRxX~t
z0YlCCI1PMAD&C<w`Z}x?7^8^|2V&gSCSFBp@*Rn=JRY{os~ipsFOe|s<+~U$f-#^C
z6n8wN#+!UdQGaGvhIBrqMNlzMy5qhe8MR%%TXuT9W+kmHzsoKE<6EF^R3s$0W!cVt
z?zosDEUn2(3UnVKHOfk$ua4xu*}ud2?6;QL+Mpu%e8I%$@WY72fxbMrPIq4`8~3^G
zhPCjJD_Yd$`Gv8HNF?g;oA?qf37#r32mh#&m!Tre`rtGW<l#XG1V&K+Y`h!}GVjeI
zvEw#OPc$SAdGVnfI`(`a=+%xRZ{PSB2Gg3U!yxk`v1dH-9%8=G^I1XebB(F)Qwi3f
z6?ddDiaOQ7S!Hf(DH0LFNmZfiyyiW0;>Cp_jd@?(NhiqeNRK5dB4)l!yOh7>d%NZ$
z{rc{7%>YYv#w)aX)&SLKPc&d&M|}^p5VREYHd-i|*I7s3y~Rx)L~4+~$$|8c`&<}=
z(wQvmg9YQiPaYLsf>&JshimXyE9G@L$k{%!O<UU#d8waPn|}!YBJfr*WsMzp%Dm^O
zX)aExZ3f!K7N(8VCiwp66JLK7^`Jm!PjADj%7NIVd#|E=t!mUt!(u<z*&T&aL-+0*
zQn<IBE122b4hjRGWd?&yfd3Y-Tw|d>%isPTAbf@mdXU_VeHuAaC(t+E59l36rHbGB
zMIEGksi*Wc%-)~>z0f)h90LCFAvnPT8?Hu_V4}LFXBB^`(e9fzxNV($EF{$^C`Yw6
zNTt|l8TI9&X?hv6z)hb5&rleC0KY}TR0nd6t&)*!Df0dVdg<zDv65YF_!;#+z=5}~
zjMi|tsL%Y&zkE`g2MVSQ#cu=T%%7A=8R)GCbY3XXe}FVr|LH$(YXK16{xBK?>ApJC
zS9aQd(;x(tjfZ~EdO@5AQ)PjP{*>7N=da_&8oaSoiwELOFIXo-V#wc8EpBy98+JL4
zlPMwk$0x~@Z66|kw)w^1l1cTI>b6w(66g<OhjfK$;5#kVf$-mYA4E>TGi?<d6FKZE
zOtv_{K>;15n*Z3L7`)C`pg90!<Zs}E<^zB$0TQzP5HB@$CX@7MAd^bTR(n1qAZ{wZ
zz+utGwWEB}E5Y@8bS!B8E0?<Et|}EI?unMrGv1)8V%wA<>v`lRBaZAw$MSl-(&D!(
zTggl(uhZdb-IB!sZV0obiYOzAGZPro;%1U2@_CC#G5pi&FW=k0n?Z2(#_Krz`b0x8
z)7}(cz&S5joM<Gs0Zl9zJM1LAa8S|eTUF*<xrUGVK)W==I0%7pu&otF0uaHLG$C0$
z{we_5R%j0mWa=2IdDhI6eX$z9lxPrwH=Pgg*PNv7*$qHy<mgL%IR9I21pI}Nz&7~H
zfz0hz)Q2Duc%RLXx(;q6XazF~s_p!l?}RofG@o4C`M}EWAnG``I`MGBD{<f_%&w~3
zt6$+1HRkim_c-Z4>oZcVasr&UPUZ``BlHq5LFUWV1z_AUo5VDvCYOt040Vx7V-AiN
z7kGiLm7kztMKu?+6ydvF;=oDR@o4hB1^@kCzKkyZk5AfUY}%L}EURT6$}dvgp^YFS
zsU9rYdNro=M;4Dk6ws?mPL=E@RLIG|=@mR%ijNr^fdq)=x<4()-{=M_!XHgKF-T5;
z`^5DG_Tw02>MhwGJ#}zo5!<#x1$YdpdTvGVz-pCmEEz~kYknxAeTc@%Qs7=qGo2is
zYk-~h*H#Lk)uew<Yh+px{}!8>hiIT0pvu$Z0m>W)tS|q%k46-LI4n|N$DaXU`mVs*
zb5q}X9^5MiMTYYE3Il3(4csQC#kTKFaOwdcsvlrt^p-_7vt5*U+qMHRcmeJ6Y?swt
zAjSm-lJ7NHAr9^EE5ulogh6CxB@{awDq$>0|AaIG!_Cj@Z8{|zfDH~@wpRg+DqB3y
zLBb6b+xHB(B5v`P#?@=xPBKE0kQ$4tg|}PPjCHg2sR&@@WBK2D4SUw`PgsS@4*H<I
z+(+D^`uI}B&FxiU7wUEiI>9FG*~?*pazl>`6_$qrU7^FMF^THSLq0Q~xJp~9k~?{f
z1$76-X}%eybQ$6s^no*F?X}HEihl%l4lGhWX7<=j+cxm@=D1F*DJ)lF1kWHaIs@m{
zlykCnOoqlIWlWh6-rKs_Gvte=LrWoRcbmz&1G$!o<cm~Mk>RI9=|mTULnJg`7PzX8
z8MXX$Al{nLF%_IMbclKRX$M4rf`a`^wy@t&PW?y!anEMkM*5u$G4v^099ggzv0?1m
zqPvU|7en7o0cVazbq45!h;Esq^swp`0c(`6`3vhWV^HK7nt}|fs<tS_oZ8!wy$DrG
z&4yd!rS0lHlZ~9<)2oe;Nb}5Pdb>68%VbVYep;=X)z{afS_*zs<K4%i>-B{A)kat%
zV2)}U26rBsiu*W5t(gX1Iz;Grdgr0}@OrtC^Ec1Qy>{!4#9s{C%eu5+CWuCPqM+N5
z$?QSp_W4EU1&fWsihFIMM)XeSmPld-Lh%yTtr6J&{?V_0w@jMK|MrX2h(`qb39q#x
ze{1KrngMSvK06tm@U8Q(aeVZ?<lEL&P@y+<E7JVN@iB4;M<c$c?C&xg$Qfam$3q~X
z2eb}U<?TWsKh*-;`;Q#4NUnOVHwS0oL*pfW^ynWs+QT^XAFmm|K#&SO?*#gh_l%uu
z9bUA@{h(~CcsK4HuYexJpK)zg2wo|rMem<P<O)QEIev`h6xw-j@chS<{7QD6LPu}h
zxZ1=j(8Ov$Q<(ns1iY%890=1F8O)rZrCR&=?k(blmMD27QNQQ7X)5jETBPpiF{wt}
z89Gmr!0B`~LKIPE$lGXH5Bi#v@Kx5jGRu2f3Ldx=b*b3c*Abjb5u6#zu3cZQP<>no
zTp!c4%XHgTG+I{I4}o6SCJ*9p!qP8)9*NpdbPVl{`Eus4SWoedW^rPo1wEo-ae1_-
zHivOj89VZoI0<|k{@7$JYQU35B1;jmwBavo)FnNQ+<?(LPp(-Ndj?Qrcq!#wKH$ei
zl)O|w3BP^fJua=<cbWc>P5h`{rhM%EJ#SlS7LR9NMIEpkd)+6;hl)r_blb3^6!4EB
zdu(ncx)FkH;41fba%kbd2t`!o9=v7OWuZ#jxUefGB&(b6M!^p43A)6^8n*Y@)t6QW
zJvS|RwPF7eq#7pkq%*SRs%_mV^%C$)a2flJIRr{>WBjRWBXQtwKSoLbS~8TWlW+uk
zJ|XdC$>JP&7@Z`OgAUSl>CxeP*tMa@+olmQ=Hp1j-Coc;C37Hita<-=PA>fsq_qYo
zmo4~XckHTflOUu3^xvaNJ*w3u%kNy`=>Epp{*ayZndNq3VHX}UvO*_>wVtTRxf0K<
zoq8MZZ}0?s?)Bc&^Nj_muLGs$8>M#K@Tnd{av%MT(D=8=J0cHFT=}SK+<1p_<%d<1
z{5AT_XH{cW3#n47E$}1;G%nvIdp2;iYc|w2Z_3!sW82y<<B$GwOwY<D%Ba^;g!}kH
zTFNz}Gf5ZhLc|ZupG-edp=lx3d(dow>@8I>))4t_O8>sYtEiqu+)~qMha#RSe;jxO
zHL>Q0>TeU$J!5B>KBAS{Fx7QXSN~W_@RIAj1Dzs_DzVh-j!I2|;_3h+*d(2umYtUT
zGarp=xZ8CQDj*Lv+jxo0V%+g~ckKF57&u3+ZJr~Cd|*e9O4{$fwR_ZZ{MESK9B%4W
z{|sMIVyTZ+xK}f}z{+{QB<au&f4yL?d52fe!rh++{sJ9i6?(-j`BW2hA4FvWxaEll
zp-;eo;hdgUW2CC_qe-k7=D~hQ;%lqdCNaO94>5iB+6l5Vq%!q-UA~aU!PDs1AFi-L
zj!L5B(O>lfK+U^xXfw40ht1!1ht+w|bEI|j8(_5=kE-xbT}QJUfDD@{o&fgz;Lrj4
zp{$`f_Sn&5S!BMV1XaBNi{)68<WCoq#&$(#d%e-B17@NGI|w?f$8LD3sb?~PUTMbf
z-XdD4;_j@}wC}7D<#^<4VZW#<Ag}(H+xNJx8E#={;o+bT|Ftev{$BllkVOFHT_@%=
zNcT@@`EjQwRm1ZJq*q3k&Q0($QYy_qsptnEJo@9r=`hGVs=5o|_!;$Ct=Al;XGb@Z
z?s+>H++7;`rTcB4eV>LMr;xDH$$DoI6^b#n<G@93*jHv!&Lpqaiz@H_vuN-7<;F40
z$0vT&cHY#!H`3KHK$U&@mp^X=c+9wxMqHG%1Jbl#ojxl8&2g|X8ZP4J>Cy-+s`7yI
zX)c5vdw4NkgyMNXf2Hup;<2<j+xF#gfj0fSv;N%0<Ck6ApO<LlR+_^d#*U8D8(T_7
z)u^Y!dwDR(9a_VB!Ur@8(^N2*iN3Nv<}Y#d*8Zx&R1-GP)ZQfd{O$M){gNh$=1Xl?
zy>Co;nZp|cQk(5S+%?sA7}No8F8D`%EosbyYE(Mt!^JE=Es7;$uPPI<*;moE+U?V2
zU8L6aW3!F%Pj@zj387ra>f&cE8a#3ci2546r^7(dyNCT|M<aA`In_y@w_?699ZZFl
z=Qs9BjI&6k!y?0u_v@W34tocS<hNyxNBF1p&GY57(_ji{AVvI-yLcE{G-<p)r@CLn
zD_mBQ?RHyQDgTE&Uo@|gNZ39HzTy+_s1S(bg+0L`cZIHU$h)y}ia}y8sJ}zAymhI&
z`Nj1Rw1^_ts*m{Cy}J0ZXJ)C2tH+_kb#hNjW%pB=gF5smZn^lE>etS5rUdXQ`n`_i
zz7a2^17&HJAIbRjpC7!G3dg(B7_Sy@H)D(Su01&8!U^(5jMu1zj<GvB4-P5{u2)RM
zc^RN&KYsEac*zpHW{AQ#{6N`ob6P1qvSOt3+{EHe=bvxF__V%#5#m2#XL*uaESq#a
z-~iW&f)^T3JbOD&+pMkj*>NfzYAM{V<HKmIhWdWi5|<!#o-xg|6rpxrRrVNe#N{x*
zQ-@4@UO}0DCwOM`*Ax8m5$|8BE2!aWG|%W5_QkOCimKh;g&bQzry8^_%wu|lJWfX2
z?s~Vnfkfo4Ka0F$-kWMvbiB4X?^6YEWwRE0cei(ck*rtkf#D=?uWTT|@W{04b)VEl
zoIzA}Pj^ur6QwhOpvpnvXkk@7VZ-ek3E}_?7l_mmHEmP}^Lu)U8dqT9RW@Q=xuZc>
zIF7hezqea-(3t&O0G~eORfv1Q-$(y>5tJgWpxJq=aed;K#l&q)++e!Ae>%3B>qE7%
zikzF#xioa-1OX=~pmJIHqo~tF_Q&E*hnpcLQlzPYigZkWQ!LGx<HVK{*@;#%w|)io
zwA~%H_H#{8)}Fn4pRTeILLjK4lYIg-H(PX-d(izzf1qe@)43K9)wAyiDCkbT49QP%
zFhHJDFu&O%|71L!yykBj%VSgoW<NrM_cmd|IggCEiaO$--q$qaGakWD@X_y$XwyrW
z{^cjcl4e*AHAbzL#H~nUZ#pQMtM_=qI!m(lFeV>U!rloRi;`XL`5JZtYdzC*q9?1b
zU4y;uiz{>J4nN`Qd?(N;!DT5p5JJJ*2%I|<@Xn)PhbHq9Hp3lDAZPdBHacZ#O=<}3
zNi3|gX{&j)DF)#=#6RlOHo)r$YBc6#4g>+vsDQt9bBT+FSE%bz{w{c1Ft4oP=rfFo
z*Kiz>Wb8YHUtgUN%wbZ2O3NSjuZ>vQDXy5QSX2_gFb(AxAV&W-5a~X6qN-s)XNnw^
zkc_?V;N=!x>gh3d20Wv7?BWCvPfpGib{w&AXLjRk=oysZi8!7ll)tZq%Yc)v>`GVU
zEIz^4{Bb;mR6m(E3*75myT8Y-x;~nmPru$4zwPa19dKh%w$OJufJeF{V=Rj5gHLG?
zqg8)S>}Sl>1eK^Odv@=&OEyl!lov!&3$L^ruQ-hTv|Z)VhIOhI^)k{!1DGQyehpYU
zX0OO}FksS}1T70z`n?l!m#s#Fd6{lSUVGjyUHr~Yj$)}8&%VOJ&0Mg-^ZrG+Uz3XM
z+&NzWYWZUjLrg**!`zcr&G-bqMoon~RsbG!pJlvL2#tG0t35~55cEonHym;<3yxnN
zvNz1xVZ?HK*)rXxC3Rm<_$M;jElb710>iFEchBy5e&$*3x0>cPl;F%G4aRkO;2t_H
z)9bc``kXc{o2r`$3d<Xc_VN98s<KW)XMq|$u$B!hP|dyPM1Y}1W_n)|5ZUk1K!0E4
zhc2sFnbxi}ST8B~F4jxLdlLgXz#JCTM@Pl^IwFH+YGDkz^%tuLtvHH<44!XG?}EZm
z0}ExQUi0$Ak#r;^o~@!u25pGVH>EGHyWncPlZ-BKKQ%aIIj#-}bkB}!VLq0mN|;N4
znJ5IFgcW`$6OS@6bN%^cgcJt+uY$0SuedEnX|K7HtBr}ER({Qmt@>5Myn_>R2~{Kr
zeI_sutY!q5f`|o8@LgLS>}S50VS9nm9Z<@%fCk*}bD>zCDRtSSw+e~v?=3)ie0ft=
z{w(Fs8kglblKDV43tN^co=v_wXzOf$4?1C+6R|*ZoaL)9wgEJ1HVLcLU0a7eSi&jb
zM)f=2;9r-Mmx2S1MZaJ_bL>ZjOBP<}XttDrp|YNT;N&LwJOXU?t1Y_&jN?VjpjeI_
zcBdBE6C9)z6_{Wb*_&PhMzh#v#yW&K2|G?Q)5r%tckX7=^9z7;bj0d#T%080<(kLc
zBOUq%DKt6Y3S8WOmIyrSGH?RP0E54cY$tl!QO9srimrL4=GCJ)J(bguspHaySsd;d
z(A#D4OzVUF)*rY8d^Y@Ef^!4pFzS64mgy%R->*Bwbur@k{qdjgJ!l!@HIof3M7+)1
zmC=$gU`@JBzWKe?EC2{@9o+NWpY`DDz55_dEInuZ>Pi!{Co%*t!5JhZ>FO))MOXZR
ztI7c1W*G}Nw*tdZHns9}Fx8TMQ{ByS*euyEs^M`sw|3D$<8Gr-GfDiZosnQTM6ttB
z3wKxefiG$DDL54|x{M{$C5h?c#HUOsK;DpaK3-QQ#d+gfoTQ7*Y_+*S>0UO7^F?9w
z1@L$-#s1rmi^<#$>_*fsNp^h^;lD-H|B^0`PK)WOvQhZ<*_??!FmBJnkXC9=9GR^8
zvr|ccuJNMq3338O$jdzjMp6Rm)IZ+2^!*TFVPI3-d|VZM;hh)c7(W-F6WV}Q#p-K`
zI7@Y<o5nXs;TJR#UrVCq=O3^`iaQ)wC1$UkE)tPI7pa(v^zz+}`0?KNjHI+l=44Q{
zIlW~1RQN?~A0364%{2h2;1lnz6|LchRYS8TyjdbVO{*5wIr588eWdJ5BQq&<8rk65
zyN4By!9JfF8c$T+T&F}NV>0_Ph3r8w@b7ou1{QebYHj#0f#15M(5!usCie4*z!9OG
z<n&rxUh*`*S$1;Fs%evIrs{5qg&J*#Om9WS?gV6(=3IWv$TbB&oMZCfn$vbQsk^Z-
zeKRK^?boE%y^v|zVM3pOnUJ}vD5s2He#Cw`qZ)WtvuV=lqY8eFr|8OudI{^R@vgFu
zG>T@v8Z<CkIU#YIOqcH_J6X*Cw!Jm_Yl1*50?xldI-u98K6v1C*@Zo!XkoS1Cyk`=
zv4E(MZzo=HThi)ijw+=kqZiB(4*Umx>@~k15H$gd5aYKbTB?6PO(=>a_&v)=z1H>o
z^Ln|w-F=PN`**-lfhD*d8>>8Cd^gWcD&G%Z_4w^KuFqE_sAhVaP1wsS&!K2SN-8&5
zA#otY928~7*Uc{6HYS<u2P-fp8s!Dj$F2BsOXVKy;pA83V1Cy@$z#?@4LLiMIUp|v
z`lOzpV%O`WQV!l8d@6@NiF~8^fc5kQ>B6fZO|M2@oBapp>~&xd*^i;7-tZnCgGEr}
zo$qS<-lTz?K|&vIa=Ub?EVI{AMM5tAAXEyxgvW3EOMK(1)plIhG#kX0WJ#jy5Mk~Y
zWOcz{Oy7fctdM(34}n=~<MHx5>S*Ur$?sp;A<l;%08qFw9QdxE+Z}sL4^hR|P0Ej0
zbG;ys*4&n^&Gw6pi5w7-suqZuYmAPH5A)P$ivpRKpO#l>@fOm-vb3*8`{JhW$F^Hf
z%??0@g7(F&NK9(R4Zwp`#Uzr(_}fzAI%EVfxux?sn;u%s+S&u=TaUQ^s$VPl`!<3z
zOiOT^P}6<^z!5km{7Na1*6W-<bpd@}Y3|`XU30L*ztKNGq6v&L`LVOmhUHl>kwnb<
zB#Ui#Q|eR@AF#(z8FKK!dwCa^?mA~8XF<E2$quOwWB#quc>7dz4!itSpP`S5v-pxY
znN))h0Z{~>`C#zWeo$7LhujQGfeG)rWI|wX={nA!O_>5r{7kTSpPNWOlbRx;K1Y<!
zp9U_(onlbhyLpy~4HvU^g`%gLs114U2Wi$1EWnT{@5YM$^5ntO$)zu=B_EFgUq$m*
zQG>HbYP20+hgUi7!Qbieg*{aD7XhP!>Q;axx(WCMTKw4lOpy5;?>zau4Rp9oR^zVJ
zC90H2dn~^PXZF?s37`7#+X1Oeu(T#f@2Mw;&kjBw3ui8$wxZ1>sP0_@21tA#x4*sK
z$b-S`3OoX^h)fM&1X7`~5Pqsg@6=I^Qe271=mY-3qzngLIF?8U@>KhBOOY-w4eZ_n
zs6_JoY1BaAafildVBNB6*QCHCDDA6khxyfmmut0cNe;M5{)H7cAz*~KuP?VkXT84F
z&5;+|28`EBnJ2r;{I)%>5t$B+?yU2m${O?VNYpo8?<G{enfKlyx)U6n;HHz17uEhi
z$N32->g0f-XuLgumfk++g9<rc(((_u_`Zl85{S>({?c3}ccWbG=YuOiFTkpo<wl!G
zHHh!+9(fQ&obB!urOQurOy7OET+9YBwK>Ttbmi;@pK{Y1P6?+FUYk9>2JgPLELv%W
zlJiq|;v6FHy*3vh$eN2P?H(PW#SB!f+TY(5NmWo}h4iQ|tX!ACIC(F5(qw!FeM0?b
zzphr;BqUUG3>o9{Yo>436g=n=n&*+mn=E`i1m3?PDBO(VapwFqxd<Q;t}#x4vG8^N
zt3vt_a|w-zum-f%sA%Cmzh_|3iSUxab2HjnM=;1@0VASr9NPWLz<q6kW_ULTARo8R
zfTJOJR9mUX<6ArG^F8M=O-!xNcUd(svhEz+^_4?#dZ{F-3Rm(`z4hTo_M*&00EvdM
zQJPe=Q%hVd5I*67qO-m_3neIis@m18X*F19tHLp|?x@44Ye~?4&r<v0xd+F>4o#m$
z8_Eo=Ow2k`E4so@A0W6dQgTS`8!B$U<!7ghNKoKs`3=K7H_JU3^!n=V5-u;MmF4jO
z0JdC*NrE9Tmw${<ey}Q|?=XrnATMW5%o!^CUg<RaTb5?niV(Yc4$9gme;HNG4^_Az
z01aBc{&Fv5TcSWtUp4_hDEt&mdU;_E8ld#+e*}<Qr~IPS0Jipf1|s*tGTp0)wNL0W
zn`Qcy3C%YXspicoZc8_Ez{g+x-#`8wOdI~N=5O$F8?YI^L146Y+efWFh?=^bCGb&N
z&l2c<|HlGMEUkw-iM11xUClWgn2H&mO|7*ESQrp7ZY71HOF+=A25UNE!6O1-{me>@
zY`^FK@KyS-HF9@Pb>(~y@#m-nYQu9@Zbd(;)Ym9ib5neM8Q@>P|57GqQ^5^=<_KnV
z@&Gm<BjS%F>2T0NXp+kGEz0sHUAGh^cmPQdbpfJ`zkPlSJ6(FQl3xJOhozuDa@zN|
z{PI(fxB5r-O^Qa-kqRr=QH}gDfam=6SN)OdzA%RYo3hp5IFK|y8~!s{JFIO0D_0v@
zb$1d)11{}mx9dL>;Qz65HVyRQWB;rFseKLRNe|GuMH;cbW0md%pfGTZChPl0g>!;^
zW_=0V9*{*bC+b8od9!GXokwy^3{nK|w(5|z+Z~LV9NIo7p0<!RyO(P)GYTn`VAHUk
zaeImzjL?MG5eLVEEOdjA|L~OlWC%yS|66qc8n6DJ!#S_t_*HXv1W2e~mpU<llS;IJ
zK`Z=02xK#p9zXR`4Vb?@TIPdBe=Iz83J?hp%s9AJm9VL^K{}P-T_1?E^JFb2dbVje
z)nnoy^aU_C0ohD*t{*qBAY=h1`IjFr)M{ImePt6dowbrS9K9?u!FuFGY#Q=BivNpL
z)f|y}?1h%gRTNx@YM%nSfm6GHC1UlT+3l+cPAEDc|IlG@1i#>bXz&3X6dcRIIO*8}
zYAW%?ey*;Nu&`dHxE~B=T%QvY)B{}IScS<I!1tpiQkyiEjc5Xh&|~&60Yv*eG5+H~
zvS7uMCIyk^s`M14u)vtfVON}7v4gLBq9`)rIq<gC<pZR9Y>Jys0gix+{a<#naiIHM
z>HW3mm%$H}1D2T^B7am<r@)FoY&~#b_r<KsnEnT`V6H2uX6GK+_U{#ol@Z=qRofh)
z!Nk9(WSN;4IP4|nLD=;ZfHEuEVW+K%_LQH-Z{*OjCiE{S%7|~S;C9uJbTYXxR<sfa
zo3<&#QZTrJOfF7l_|O^Mf~9e{CtFb)eU0Af><5_r8KnqIFpAQ*yivf8@?sY=kq6;h
z^2<#z08+;WCZ!~?g&<z>9s!jsHHNvvcmy9mTXi3BTUPOQa*?P7s*y|V@H%aSlg__@
ziOE4AP2DPLnP+yg^vaQH4dDAULMioN@-O4UV4WbGUMhb)@3m9oFWw8Tz;B{Al(&aG
z(K;_{e?<I({WaEJjF;xQjlTY2oBjnt7RF-D6#(<!nEoGItj0?W+CaKAww-#Dgl+S0
z<88(6?=G3e<BX5^)Z_1zJxXG_0@{0E>aKQa9Iq^^C*+SRpStc?cG=8%I(^tikzgU#
z<()M<wPH?3j`*}iPbPzbWMLaveZXe8E%yq3VKC#P<h=5*n}9_H4jlJj%;F};U+WY=
z#=n^|Vx&IJ5oJ3SE@HJ{0@W0#D&e+rr<ZsoHFKo;ePN<OG!x8E+_UlX8IUS5v^t#e
zo;`apQugNp9240>R<v0@D3Z{HI3}YIs6wBinLd8>s+XOaDz||_-!uIaTcC90@!Ft(
zA4{T^r~qzVX>xowF0DVZjvp!OvM>^f%>#Q}C_HJjWN|_e+m9~hWAY2Zd_xxO5BdnD
z?~YaP{`dR;66>}OpfG@L|6bW|S+eu|Z4k$Q8`jG~Q~EKSo0OTMtD~}8+OS{X#X(?K
zwr?{MfM2=Ay<wKtn`2RaO*sbUig9FXTVFa58e+uL8v^R+hbZe^HZ@(JziAeY#}98j
zpK?Btw`7`=U*G{m05mD1HnXb!vz<&&<IMDE?%2K84JQ9jYv&zLb^rf=S6!tgt7RvJ
zI@u(<D;bG2IVe&YnU@tEt7We!Eg5B1jxD1)T$v?%BpstDoP^|XI2^vu_xn(BRo8WW
ze!ufiH+0_P^?JSEujhQ+MfD$vydtW|;g0!Z2oUubgC~7@i&DjRzBMW=04yr*Iq2<D
z-y^4t9>V*C*QjnK)Xe|x)4&tm@YkMe51fvE`vbtS7lE#aNrO|{cODLc6=ul49~`pk
z!G)ywqgsMeai@P@?|jsl?u@s6$FJQqw~4_#e2dPY1dzX=U_P2Vk~MY{hPtFod!$|z
z)BO4EctwiTPHqufX|EMooxg&}T7fYkw@pA<O>b)IO6XYwytxj?jGK#jmA+2i!`O>9
z^}nFkg13UZ02`wiNe+r}kSYcw*h7cF96Q3f$)81qv-GZj%kLGH?{0O!yGJtIa+`Z+
z`6YiA(aWRK8mmeE5tgl=T6=0CSNhbgm{o~zW4+$@U+XfEswh!we555U_h&F8EB~=&
z{bxeC8(6p0X9?&^c-x8L-<Pq6_K}p}LY{eJ<s#u?{K?$NYZ_5J1n-G1@-O;ueY!3m
z$0if|Ey{<s2puZz4__4WIddmonos1^Ma@QB)t8+K{;bJPk0$x;*PA9%VCUHE@*jAz
z0x&<kPd=<ev_D}0ToZcpzl)He$eKS7uEeN&7-qa#U3|n++;p?p$<o+PyPGfM4{cU3
zPk06O@h=5z4Ix^TXoi*OYP{GSlm4LYM6srEslQ55yZBX?1kJNmnyDq1Bd=?`$=QWP
zsAvQT|G-Og!3}qmpuIciB`ud>GRHL|PLrR93CbAU-F$uZ27^4l8L9z$x_|>`w&j;W
zqnM|YI#?0`5HbIbCHrl||G^UuRkvMNK$^H=GNZw~N;A4#TQ~W_7O|LwA*sjdjT!gK
z_(7OBfnu6ieKTA><W|i7#rupE_jX!1Lrc<+Zv~=eq998h7`8M(H@mrfRQpT!z7e0E
z>_u7%tjT*-Pn?meEUn6w@h0>DV>Wv^W}9d9)g5UT5qu`M#iV1`9(WV5Q-^cWzNmwO
z=DDd8{WAY_uK$l**k3#u3xTeYB~tx)L18=21hYC`dl9tpQJ9Pd6XB`X>AlY0tF6Y}
zsLQU7b8ff2Q<*~Y=ML4oB@D&43%Rn2*5<Uc!}Wq861zhs&#@+qW%k^^d!r?6d%$3=
z7ZaZ@pDCNkrNofK=VW-oOX{~lE^E$I|G`8)642{95pky~Uabo&p{$c!7Z|p4Z=1UO
z$M_HRTZ(B~-l;qPYD#|R<;tR$LvG35d2;C>M6ix>Ye!r?m!rvzDNiP?F&t(U0tr$L
z&m6_ad-6?4>1!EpQl;C5AUb({8n;fP3JSG<G3)d2uY|ggj7<a1IXpaikQhNqXf+pX
z14th(V)jAB7FzNMLff`cvMHd!*h0h`Wt9TuA=mEBkr4hubDAe5pi`*7U}&97WyIm9
z)jHO8P(N7HuG^Lh;P3ag<Qjt$_cUww-q^}c5IBHaWz$>e;`$;z;JOs9JEY4xcVM<0
z@Z4GFBdJjNN5p%7*^8u9d^LDkk^NmmaM!^$SK8>uP?MQAM4QfBaOKtFueRQ{$a9ZM
zHWt>uOq?P&cDX+tP;{wPLJgwX=sK{mK}hv_@?fEn$1z)tnJc0|>^;|VM{wHOjyMcu
zcNF{aLNHI%V|ipcIT*}9wD-&P)@&$-bDGV1*cH89G;ESatjWTpu|Sxn&9g=h!XNbx
zON0Z_P)!Um6!1I6Z?beA@O6yc%PZ&!Pc^Up@RsHuX`P0aD10q0y^sK^QO{ej^>msK
zFl8Z3mvaS5V#S`+W;i|@eB#c8$&R-j1<?2yBoJ)$c|0=4L9Me`%Yjv|&8?^$YBhw{
zehuf(vZWE14AG746DeK+bVmme@Oirs;kzh~iyrmD1!W*uIY2tVPPx$NUd3LCK+;w~
zu?`~QRL6u0^)e9Duzx(sDyek(n1Sdx>wD|A?<EYpp1e#1p+h8{v1{T;7td=jo`b=d
zzp@9d*PnM)Tl^w*K5})o9oE6kaD0p%jkTY6gtIrZcr<j2M3k932!K;-9Ask?3Y}?r
z9L({2`$!VzQ^3CPc4|B7v>aoJFlmNN%@%`hmuZ<9qAdm?9#IMWlwAS!xyfc#Es>n3
z&gGij1DByx5C%k;Z~u}W)2_q65k|8-oA&h<T^bg*FR;m=-gMk1KEtkJVlvtPpzBnv
zv-0Hj@y(`7nBcZYX#EhpouVu8q9eM+7ZC{K^HlYe$oyoYtK<P9VRz<E@JqNXn1doy
z8IIeaz=lM3&B^ObmkdM{S5jssH;)PyYZ<`;I0m;pkDhl190@{iv=HJQfu1~qDW9EO
zL|kk38$Te-Zluc-GPLhP^G9_?m)GWCr0`EqtGLvep$b=J?sH``m)AmH?lfp}L5JTA
zJpXi!P=?1B(9B9)-ZG5kjSYGY{E1t0Ky;Ko$HD)NfnlHzxUb3juKpzm-PX_-ffQY%
zIwkD*cl3)pE@iPMMSLQK#ti6{UZhK&GB^Vw30ZRJ+{@wjj6C`9QNWv(w*44Q$pu+Z
z#kO<PA8UmLJopAe-RgN{IG{u2ONmRfwePkbvEDBZY(waI1Bz8Z4Ey2cwhvL&Y&sQT
zX9CQWmSF@3wE=6<Txb<#;&c(joM9r)%-Us8gpYWx9bicwzhzqHsJ;yI3Z9wDWVVXn
z^7zA>$HL<YK=xu<^#DZaR?2i|ZUN2z8PJs0uCi2=S3Aik_hu!=ytS#|VdhZN?rJxi
z<uJ~G#k>L?pwR9z@9~*^sP7#L;w8l&-F$pC=GJdp1oD3eDmDVc6u~8g>4iJXAq_*p
zZ`oK-TH}va1Mmi*UmP)T2e?@``9%T__@#*MlI!c;-XD(ixdcZ8JMAZ&S@3)te(+j=
zUm+{<$Th<UzKobh(HDQpi8U})djK87KswMVy<)x_8zANut9ZLq5=_pkPy5)Q%4P;=
z%yf-REZSn3F-*S1jH7uqfhOkgej&qJAAQ=MRV=wqu+2ab_{gPx@3^x!375ttq6|jJ
zoKPKcz`U>%V;?P5L8OZMzj7c32vLnpq~UpL@L5S~FM{y7YqV!>-YCfhs#rJc^EmqF
z6>;Hm?TO~Eg739HR$|q&>+ISA(wK&6y;@M7F}>PFoJz2rb+hAe!&KZV35BH}`co55
zYEH><wCu@Ti3za03N0y}kipU9R;?O2TG*kr&9^l6s)Np&Cm9j`JC<LL{GzjrUZlXI
zI9sIfA<nzCNukZ7dZhnV0D!Uav;m|B8w%U4n`Ol&gzTjphazF4DImv~(2EkzO%+sB
zyK?p^kz_VqYyC1cVuchKn3tHpV~js<)1LEy%FO5y;+1|4IC?{)N{%l@K2~DV$vc=+
zvHXxuKS!qamr;a?=cpGLOM43jY=}<{Ai!PNk~iwJ9!3-7GCw_cb)wXI2`bmx`VIMU
zk(6rBlHC)@K>jlh?s%DANI7HgRNKu}t#_jY@w1152LLGW0LeVu_gO2jdgCLW%cSSw
z!TiGqMRzab$BXj{%A#CeC6mT*0S?u!_+yt@c4JKyS0yj%_eS7<-IHWN${qJK*ntO!
zJ!cfthsf4Fff_NdYx=SwP|dD^3nkWUVdO?w1(?-J*eQim3huFlyjH6?na<?u?L_wv
z^Xl-ULjZqS*qGtaeAh1!2KCQv;_hhO{D_UkY-GcU)>0@4Z&oj6=P1AQf^sBEAbmL!
zE8@6EjLIY-5Xz4$;FY_W@3VIQlJcgc=nS?Lwbisc+T}q1g}w3XUj!4rs((i0XnRcW
zqP<iavs5Gm_zf3k3x6JsR(8C1Te_lC#t7Vd!3c0EqJzfXfLM<dwdpV{$eiq?Td7M8
zt#{fc`E4aaXa_^hk!q;0>8XL<McfKG(y1LIZNfA6pZP%9g;(@-UgD3+AJU+Kv419Z
zI=}j}dmOE=bFsd|Hu1P4rT>5s))iU^;M3(W=g|AowYQ^wJ3nkju`I=vLEM>LrM=8e
z?fDziDbWh`w2=a-atalMNsQ4L`psR4_buA$?Tz$3I6O}-E0RJ?Ng)8)M_%c~q?npf
z+Clj#7-I6hNDfE#*i&Wh_7#{yUje-~gxn~gcis_1@wIL>dM-CLbNet}j{$OsBwpBw
zf2s$2$}Xz#I!et>23Mym=*>z~vuWSqczpnfm|+k0>>jVqEN|Q4DRSdHimpwZ0kZ~P
zZ>O)KK0VSE20ubG9}*Ww%IW@6JByXLaQcMho@Si7yl-iX!CoG-lU#bYcZb$Hs}v*f
zbsoR9?3zh6$J4Bo1b9@t`tb>&l9@~x9sUZ-$9(TlRJYa)G~9ux=yO3dkb$%Z!jFls
zA;C(=UqLkE*K}flfd2#Fco~KU>^zVf-WY}YqDb>2{D}1WK|CJmPh=3a(!k%0V;$On
z-#<$O-083!V@NHOZV&qm<DokU5Dd$vSOMHD1*0TjAGW@Ml1TEp45bYKut!hv%r6p*
zJZ)}zzyW&6%50(MgSdP)bWcCkLKHEyWvQS6f%7)>01PxqA@KniWT=(U%7mP6{zjDE
zr2<61e>rLZNC8m@uti89i$4RWD60F;460L@I}?bC+6+a`9}8$_r7r<@x=}Mj->9;X
z2p+u?1kBm3JJ8f`8Pphnd5n+=VYh`84>}gL?%0WmT3D_0DBDfVxzo+NF_2)TS5AOM
zGynVlI9>BD5unjotxi~ja^|L2@!oNQ=z>z)^tS~iY=nJB*##B5cOeFHY~CTjbo=>T
zevPhsG3W5nI6;57GVz{kmZY7Oyu9H`3>3A(MzMYL)I&Zal7z)4A+JI<y(w74|NI1@
z$i6CaigI#?>x9OJ?~U}4Rv%Rm!biI2K%_+nUfodQsn!5Yk5l=d2_R+<>jH8nFbyjh
zAgC4Q)Ey%GFuYIgngbsVs}&~EZJ+jJP<}YmLO#|yosjEh`r$Hr)$NzhAeBC8Gkhwy
z+tZ@Hpf?cJgxg=#v*%IwC!R7Bb%>ZZT35loNccE{YdIbj)61iq6AJIzl<65AzPy`r
z`vz#`bdebO*2LZb(krFX3Oh_TjO&HB?UCafx93Ios!wPziKfZFXF;ff-;(dvDl_Nc
z{WkY{6~jW=XWXjqA<phY1by4K{P3?N#XBpiW>8c{n}Y^_N#&vG#E3>R#Lyd1g*MO9
zKyuK1C?Z=y-xYxGy9@T=l`2mD2xE6?Ew8i@Q_idJnTxQYgQgS2xZ#c5^AYOx`1FYo
zdUl6xq|jn@V5b1$%C0D4e9Qz|3LlEg`jzSwQbt3q0J{PGOx1^8H-wpblm>d)ywjiZ
zXx6|hJ`+={87!Ldf|*$3PrkjO@|XuC_4jiUCps;Lcx?Y9_n%KMxDBztl(iNyTMGw~
z#t)El?ijN)N~9<fTPN`ZuvI{*J&2NlcA-Hn5tV6K8j5{;j8Lr(mT0xE{*CcGcGRV=
z@xhbQnY?JA?LbRCoP<NsI=u&)(b2uiq}_FT;?9cg8)4K!$PoT_k0wzFHy|HfMtSg;
z9=e^~>pcH9Fry3Nh)>`QK5Tl%?*WGXc{fgHm6>P<>_0*w5FBJEg{=wMVt|s3FdW7L
zJ1~i0*FaF+Wb!tc7&}jvc|qK=*MDu?5jbQpN>lxJK)>%%)U#?i4|@B9C%CE@AE6cc
z^<Ov;6d+p1);D5Nr9WJas^-Yz(?eWtjRM3^9A&{U?8?+k54gJuT*5ra<v~{*`n=GS
zU;$o>8+6PL9No6q%JMY+afUkG4OxL1?v0AR23911aS&x5CE28h1utczw%kTBeK=?*
zuayPAU26hHAr70+QhEUP!8mX(O~Fq^x2riXUEru8V=z?h#<gc0Vp3eJs+D)Ar*=6!
zqv?P{nGd+uj!toYd1m^~pWk1&wpdAJwKrFL`P00CVanP^KwxPEF9_NYAbeWJi>4^X
zP&eq%$_<FG($0+83s(*Zxku;2l?~MzXc-ZJXcR-1UJ$bM$lLJv2`e?)@GiCX>5(_F
zVV+0Tc&0{sh%$(BH?WB_z;#A<cBJMn&I4N4k+Q_dSiScf*u1?w3zDtzEP9nGF7SJV
z&pVZ~sp1Oa*eD%8<pW@B*eiwCkz^#Uk&a>uPSloPIm9I5uHPgTK=g;}q(bjKbXL2g
zP8}LEi0zY&i?nhR$6aVqSi&xmaEnE?Yh_1Nqw7&tgwYE(qJ>}?Z}wVm@|9*ksp;{|
z-HDpEjm|0l?p*a6_m6q#ooxLSh*JgB4@i+Scm`##0klU6-BXZE{WV=O*MWr8mF3BZ
zH}T^BJ^Cq_G2ywQ8)9dPc<NY*eWuX0%}}<9Am}Tpv>cPH*Hi)8!@pGmMdEMAtIOYM
z-gK5FDPBX;w^XBGndxPeFa0v(WT`~_n1{}MCNzYMX6FH3NayV!Uk^3;^v!G%3IDOv
zmNwZyVP)&yn@{h1a;uUZl{gO4k2nXeyQBRLTsMm`o?Ye0Vqx|cpSDQLT(kyySicRl
zt_(gn7%eRClig@Q>x;x~<Ot)JvUpV-v;o|1AWOS&>g7=DF{8UAc~#A8@ILD$a0?Ee
zUaTdbkf6E`a@9Xre?n9y;UKy88!URh`k{P;hBY8s28V6E44AJ0pA1Rw62#hk2h|M#
z--ZhE?B0wlXbFi+K%Sl?eN(mCCGP5Z5<|9(-p30UuJOt-_l+Qj9|TKf)&ByF{<=)e
zu$i2YQh{&_@}y#pW97P*!EQqj7G2X#<P>LPO;BIKSDdx;-sW!T*8)g3NDVM;2v~MV
zz=zq?fcs#C1I*a<VhAiT1gar#L~zHU^5pLe<G|?;8JyAzOZpr2Yyvhb=W+f)M|dlq
zG#lP7Q>NJaasD5`iu={OWKYp=&(^|w<GSgR{m5H+onDPD?N19Jwe5U{5bV)w5q<M=
zs0Ktx3O2H8*l47Kur4{(y;jBKct(F(mvvaRqO82tt5sZxBmQ`o+cAY`Hy&c1t(3JW
zBjS9H$!9B=mbFkQfTJ%&uzW=ARxf7q{M`4#jVBCiP|1p6(9%M82j#a6$nNmTeau9L
zk?lr-mHmkDqCQzFByL?QkR2fe(%;=yu(O_2@pgG-0;NK8o+6S1H=9(d1MCr+0H3|#
zS)4UeP|==$kY-oIZJ+(IVPDFO;fof$LH+^Q%dPG6|A2q)rrWniYylsBxu>Vu<TQ19
zl9fswjF#0!-EJXxn5BbeTypaarbn`yviPb%zvm8Ds;-;1Z7*+aCozk597D9;IuvO)
z(sxg-%Q}=EBY^UKGk5zZ{hzYSDw@xFbQaZV;A*pZXvSNiTAiRwazCx$O8aDioR&t}
z)!FYZjZ2N-Wh9>SARQXvl0Pp=x6Eg`x)&kGA6x#+?4C;-C+$F=wI?-$Oa#_mC-t6z
zLpjI0H2b{vhefL<4P%Wf8vQQnGcYg{_wM=Qh*ED%zr}IfZsS;E4QcA+K_#Am{+pxi
z6OFNzd_&HUbChZOu%k1HL}y8J&!8gOKwOJ!bF#{Si{}l`_X5T(`h27v(c0@@B}1LQ
zlP6Q}=Nop7FPu$1he<jfskOcCQA49kW{gP_gb<3BUwyxS5}5p>MfUV=nz~M+TYAnN
zOP;6t^4d9}aY*C57$*R+>1AqYXcO?WbUQ?M$=R2mTDu&h>Qzp3Ob^Y7LeyRKwI`*V
z?>tY%B=z0^Ve*bsX;|xiPmAE>0-?v=R4*;QY>v+Ul)>$Rg<^<D9(s8HFmA>pJ^kH!
zEc1v_ZSv*MghJ>5)^$QCSucZj7UnfmD8<k%AKOt1*B*0-ps!A$-v#L%p~2RUGKG+y
z@^I6WTvT_ip~$fk_eA3FG~}1Z-O@eAp{~%r56U>^^U`x--g+~v_UOIJdv;v`oe}qL
zl|m3Wwa_&+jc$pEkC+Fi@PYvWLm#r22Tp%~|6nqW{yww#&$kM(<c#d+P_zJ!&~l5{
z2JhjEll2t(n;!Da`Aqbyf<`w62tICF2wxT&=R3c+b0WbnTFs8#1H0VAg4J}(9aD>N
zaQi+1Tpr!h;L5soJk@{049AK$Sqv|tK>VEBp@kh5hP1{hj8ac94M{Qt@&UD$eTw<7
z3qu|aB{iGSi}<(4%#id_uQ(qb&RSklYU)Gk=*vK<;i}jdvEPpwI#_Hq^gADm9|BCF
zty{V?!teWRd`1N>HOz|%iXMbP;jf~gJ5-^mA#vZl%)|eFL?rbPk-X^Yw2VUI#Ge51
z*7*YFFOqDy967aon(^&luF5220O?n^U}h;=KbVy6u2J5;=w=5*reQGO&C|84RzEGX
zi?Ia&yw7GBxW{XRlqfN-F<|S`XE+azPy1JQ53YC7GEBP~9dLVb=C^z<g;=j?C-A$F
z@(6SRE|~An#-#bH@4({>Ny(F5s*DGg{%8%#o>gWAmIN#y@WluJ_p1Uh0e!iwah<o0
zpXxtG9unk9=)eqU6ais|VNI(WqyX?st3#i;A^j`NRtURbqoMMB&UMKlA@}cI=o?}5
zJL-|08O|?Lhak5RVayQ9T}kl-_3|pe#V{Z#sZir`{dR;$%pR#z(@RJGumuo-r(=$X
zuNC%AE-vP_vK%l}M&KaLBS|SQQ2O^t8EdU>&--9PU$@`Ew;ELBVcY0OX5H?S$0mT%
zpeyrG+q?(pZv%=x&dnKFj&7(=aR2U!zHteWOgzyvG1msvZmC6BZo>wO2-sCchCWC`
z&7RtT2Ud2f&+3Lx8J;xAE77ur1jEbbae}`pfCYSfP$vp~BmCFd$kOsi(CV(=8bNm+
z9A{{|6<K%dKt+Vt2Vl_t>~BB;*Zr)*;CiZ;9S9oed_{Jxp7#>_;Zjd&x~Bn&2xkTS
zX$g%~7CkKiG5o?`UCL;{&92n{v?gvX$3!-5&EM>}DnO;Eu#LotVJp^Zg;MSx{FX)U
z4OgrRL;vu^;tbx-{(irVO-NH%{|Jp%r{D^?a|oLkx~@AuC;L)3tEBU3dlp}3=gQ9h
z$$`2n@H`^2IlH~n$vnHM{CLfmwtjHe%V`8ja?4>@tjJHpw2pOD_brgMyrEUHq}!?6
z2X#Dz#Keab@Hf-z<)=_0_Bm6tDS5&A_vI`3eM{Fr)iplR;fj?oiFX;l1$rn&knkqv
z*&PjQcMQryH3rcu<l;TI2Q^5B3i@0QLLlL8db&+#XWdNUgmEX|;A2EXzOY3<X*tdP
zojcenPxNwI4s~GK1<9ks9X&gcKW!yauESNfK385BcLcoX^a_^jQwQc!9l_gf*Jd0l
zG8y1*l?0hyuMZ1zAq)QlIPnbh4_RI0m%!~5sNN~p?N1cqk&2MmtX!$Kj28spJfyWt
zdVK<r^}K|B9N`<_4H?NPTApPS6tm*1xbmi^q)NDpAOGA$<rs_%AQCd+3Ax$3@5{Y0
zhgAWw=^O`3A;nYVl@Aw;^hzP0^Ny_l&me6;%OalxqEIlu)#-nNVk7Pz`nk66Ys`8z
z_g-*p<uMN$U0QwDz8irSzcMk<f?f0i9`U0Ce}y}*3P{h6kUxII7R#!f4vmC>)TJMV
z;lrT^>S0MY`FRdTu&YKml<mOZ3~H9;`K=L{FJ2#fBCW`lfgDf<CMU6(L*J$(umJ1X
z$SUp$2FZ8h`v$=(mntkxne!9WwwGvmMEOqEiN7;`9s^OImjZg)O_pw6IctqJ1=Oah
zv%Ul^)ueaI(%Sj!vp}{K#0uyaRJo;>6Jv>l9cJB!Z{yF8299UVQ!pXW&#nS`l6(%%
z3k+N2GZzz`LkE8y`T6_L+zMHbhM2$Zb8|xsfeRqpm_Vo+@bBL)5nh(xV|3|fL<(Yt
z(P2SjQQs~b3YhW1M5te8(^J&)T}ykd6()B|1t~o4V*Iv513M5LF3)0hb@dI*?0##L
z+z}q@YpG~REYnXQ%uJWn0_U6l`EcOo;R|KSvJHpdH)=$ph)->x(CR*ohR6o`iQ``3
zG>ju$lIjRZnJKzIA6`iRFT3Pe^r-N)??AG1=VM$zMBV)L#JjL0DYMt#sC(bew+!Q%
zG>?ZnH<XJ_7h*{1=Rfbb5l_B_;_Bw0v~zQ{`fu>mxixa(ZzRTlyqUBCVkFMvlYz_R
zab|Wss?HDZI87%i@BS0s4M+7m{saTLb3Qk9_JX_K<df7MnUlA=^b*3@es(A*Ud~Ig
zCFcJ0T%oDN+?3H;n<KhPG!L2kHeuJ5M%n~jI#t7d`jw?T2Vbc?IoOWtwR&VzR$|qk
zYuj9xMXgu4&vipt6HAi);hbzBlL}uc4F?-Kzx4c=`-C@b`ds%)v4>CijwPoZcNF{C
zZJw-4p2m4~n?D+SVbRoBYZp9?ZweB#OO4^w78Cf%l+_jG+O;R`u)_gI$IN=PmMXlK
z=V%Nr>1@c_0iX4G_cKRpS${HMeY)~dippd7$FwxR=00{^{ToU}BsCYx;{K*UM)j0%
zwY<o2$a5{A>CP?)YUA}(V$*Tv;D;Fd{C%m$lYSq4KJvMLF>o2^a&NA7RXjp)qa{@v
zeFW3_$BV5lHrJ;0;j3Wf#KEVO`j0M0oGm9xsJ%_m6eU9@5eQFHrA>#yN&4~XCX4at
zb{+PTnQq<gUkW<sKlxvbo)@S`!>0dG%I|q$s2K2d!c&A|-qd~h`Q4RJEo2`W4IN9p
zp6Zs5qpk7OiEM_$wC9um82$V>`JqPY`*z=-JrdqnN~x4py$Iz2aS)e}ldddZZ+yg6
xC4c|%C-03Pjb)BDTjPK6^<mn0Me@TLmC#+)`&k4VGm(d2uiE}SX}eEc{6CS%(v1KB

literal 0
HcmV?d00001

diff --git a/使用文档.md b/使用文档.md
index 4008f0b..92e23ba 100644
--- a/使用文档.md
+++ b/使用文档.md
@@ -6,27 +6,42 @@
 
 Windows选手使用脚本位于Win文件夹下，Linux选手使用脚本位于Linux文件夹下
 
-## 游戏启动方式
+## 游戏启动方式（For Debug）
 
-1. 首先启动Server：`RunServer.cmd`
+1. 首先启动Server：`RunServerForDebug.cmd`
 2. 再启动Client：Python使用`RunPython.cmd`，C++使用`RunCpp.cmd`
 
-## Server
+## 实机体验游戏（ServerForPlay）
+
+启动游戏：ServerForPlay.cmd，其内部参数可自主设定，设定方式：右键-编辑
 
 Server脚本中参数格式一般如下：
 
 ```shell
---port 8888 --studentCount 4 --trickerCount 1 --gameTimeInSecond 600 --fileName test
+--ip 0.0.0.0 --port 8888 --studentCount 4 --trickerCount 1 --gameTimeInSecond 600 --fileName video
 ```
 
+`--ip`是服务器ipv4地址
+
+- 在不同电脑间体验游戏时需要修改`--ip`这一参数，默认值为0.0.0.0
+- 对于windows选手，在连接同一wifi（如Tsinghua-Secure）的情况下，打开终端输入`ipconfig`，找到IPv4地址即可
+
 `--port`是服务器端口
 
+- 自己规定，默认值为8888
+
 `--studentCount`为本局学生个数
 
+- 取值为0，1，2，3，4，默认值为4
+
 `--trickerCount`为本局捣蛋鬼个数
 
+- 取值为0，1，默认值为1
+
 `--gameTimeInSecond`为本局最大游戏时长
 
+- 可自主设定，默认值为600（秒）
+
 `--fileName`为回放文件的保存名称
 
 此外，Server中还可以默认打开一个/多个WPF客户端，一般格式如下：
@@ -35,26 +50,36 @@ Server脚本中参数格式一般如下：
 --port 8888 --characterID 4 --type 2 --occupation 1
 ```
 
-`--port`是服务器端口
+`--ip`是服务器ipv4地址
+
+- 默认值为127.0.0.1，其余内容与Server相同，在不同电脑间连接时ip应相同
+
+`-port`是服务器端口
+
+- 默认值为8888，其余内容与Server相同，在不同电脑间连接时port应相同
 
-`--characterID`为玩家id，一般学生为0~3，捣蛋鬼为4
+`--characterID`为玩家id
 
-`--type`为玩家类型，一般学生为1，捣蛋鬼为2
+- 学生取值为0，1，2，3，捣蛋鬼取值为4
 
-`--occupation`为职业选择
+`--type`为玩家类型
+
+- 学生取值为1，捣蛋鬼取值为2
+
+`--occupation`为职业选择，参考下表
 
 ### 职业对应表：
 
 * 学生
 
-  | 参数 | 职业类型         |
-  | ---- | ---------------- |
-  | 1    | Athlete          |
-  | 2    | Teacher          |
-  | 3    | StraightAStudent |
-  | 4    | Robot            |
-  | 5    | TechOtaku        |
-  | 6    | Sunshine         |
+  | 参数 | 职业类型                        |
+  | ---- | ------------------------------- |
+  | 1    | Athlete                         |
+  | 2    | Teacher                         |
+  | 3    | StraightAStudent                |
+  | 4    | Robot（目前未实现所有功能）     |
+  | 5    | TechOtaku（目前未实现所有功能） |
+  | 6    | Sunshine                        |
 
 * 捣蛋鬼
 
@@ -103,7 +128,7 @@ Server脚本中参数格式一般如下：
 
 ## WPF简易调试界面
 
-![image-20230415191314116](src/WPF_Image.png)
+![client](D:\2_autumn\thuai6\THUAI6\resource\client.png)
 
 ### 界面介绍
 
@@ -112,7 +137,9 @@ Server脚本中参数格式一般如下：
 * 物件：橙色圆代表捣蛋鬼，紫色圆代表学生，且上面的编号对应学生的ID
 * UI：左侧为UI，表示游戏内各类信息
 
-### 操作方法
+### 实机体验之键鼠操作
+
+仅当启动ServerForPlay.cmd时可以使用，观看回放时不能使用
 
 | 键位         | 效果                                           |
 | ------------ | ---------------------------------------------- |

From d4616bf48cc53e88717358ad9ee6a21a17f8a79d Mon Sep 17 00:00:00 2001
From: wihn <88038740+wihn2021@users.noreply.github.com>
Date: Sat, 15 Apr 2023 23:49:21 +0800
Subject: [PATCH 04/10] build(deps): add grpc headers for windows

---
 CAPI/cpp/grpc/LICENSE                         |   610 +
 .../grpc/include/absl/algorithm/algorithm.h   |   159 +
 .../grpc/include/absl/algorithm/container.h   |  1774 ++
 CAPI/cpp/grpc/include/absl/base/attributes.h  |   762 +
 CAPI/cpp/grpc/include/absl/base/call_once.h   |   219 +
 CAPI/cpp/grpc/include/absl/base/casts.h       |   180 +
 CAPI/cpp/grpc/include/absl/base/config.h      |   913 +
 CAPI/cpp/grpc/include/absl/base/const_init.h  |    76 +
 .../include/absl/base/dynamic_annotations.h   |   471 +
 .../include/absl/base/internal/atomic_hook.h  |   200 +
 .../base/internal/atomic_hook_test_helper.h   |    34 +
 .../include/absl/base/internal/cycleclock.h   |   159 +
 .../include/absl/base/internal/direct_mmap.h  |   169 +
 .../absl/base/internal/dynamic_annotations.h  |   398 +
 .../grpc/include/absl/base/internal/endian.h  |   282 +
 .../include/absl/base/internal/errno_saver.h  |    43 +
 .../base/internal/exception_safety_testing.h  |  1109 ++
 .../absl/base/internal/exception_testing.h    |    42 +
 .../include/absl/base/internal/fast_type_id.h |    50 +
 .../include/absl/base/internal/hide_ptr.h     |    51 +
 .../include/absl/base/internal/identity.h     |    37 +
 .../absl/base/internal/inline_variable.h      |   107 +
 .../base/internal/inline_variable_testing.h   |    46 +
 .../grpc/include/absl/base/internal/invoke.h  |   241 +
 .../absl/base/internal/low_level_alloc.h      |   126 +
 .../absl/base/internal/low_level_scheduling.h |   134 +
 .../absl/base/internal/per_thread_tls.h       |    52 +
 .../include/absl/base/internal/prefetch.h     |   138 +
 .../absl/base/internal/pretty_function.h      |    33 +
 .../include/absl/base/internal/raw_logging.h  |   196 +
 .../absl/base/internal/scheduling_mode.h      |    58 +
 .../absl/base/internal/scoped_set_env.h       |    45 +
 .../include/absl/base/internal/spinlock.h     |   256 +
 .../absl/base/internal/spinlock_akaros.inc    |    35 +
 .../absl/base/internal/spinlock_linux.inc     |    71 +
 .../absl/base/internal/spinlock_posix.inc     |    46 +
 .../absl/base/internal/spinlock_wait.h        |    95 +
 .../absl/base/internal/spinlock_win32.inc     |    37 +
 .../include/absl/base/internal/strerror.h     |    39 +
 .../grpc/include/absl/base/internal/sysinfo.h |    74 +
 .../absl/base/internal/thread_annotations.h   |   271 +
 .../absl/base/internal/thread_identity.h      |   265 +
 .../absl/base/internal/throw_delegate.h       |    75 +
 .../absl/base/internal/tsan_mutex_interface.h |    68 +
 .../absl/base/internal/unaligned_access.h     |    82 +
 .../absl/base/internal/unscaledcycleclock.h   |   133 +
 .../cpp/grpc/include/absl/base/log_severity.h |   172 +
 CAPI/cpp/grpc/include/absl/base/macros.h      |   158 +
 .../cpp/grpc/include/absl/base/optimization.h |   252 +
 CAPI/cpp/grpc/include/absl/base/options.h     |   238 +
 .../grpc/include/absl/base/policy_checks.h    |   111 +
 CAPI/cpp/grpc/include/absl/base/port.h        |    25 +
 .../include/absl/base/thread_annotations.h    |   335 +
 CAPI/cpp/grpc/include/absl/cleanup/cleanup.h  |   140 +
 .../include/absl/cleanup/internal/cleanup.h   |   100 +
 .../grpc/include/absl/container/btree_map.h   |   851 +
 .../grpc/include/absl/container/btree_set.h   |   793 +
 .../grpc/include/absl/container/btree_test.h  |   166 +
 .../grpc/include/absl/container/fixed_array.h |   529 +
 .../include/absl/container/flat_hash_map.h    |   613 +
 .../include/absl/container/flat_hash_set.h    |   510 +
 .../include/absl/container/inlined_vector.h   |   866 +
 .../include/absl/container/internal/btree.h   |  2854 +++
 .../absl/container/internal/btree_container.h |   699 +
 .../include/absl/container/internal/common.h  |   207 +
 .../container/internal/compressed_tuple.h     |   290 +
 .../container/internal/container_memory.h     |   442 +
 .../container/internal/counting_allocator.h   |   122 +
 .../internal/hash_function_defaults.h         |   163 +
 .../internal/hash_generator_testing.h         |   182 +
 .../container/internal/hash_policy_testing.h  |   184 +
 .../container/internal/hash_policy_traits.h   |   208 +
 .../absl/container/internal/hashtable_debug.h |   110 +
 .../internal/hashtable_debug_hooks.h          |    85 +
 .../container/internal/hashtablez_sampler.h   |   299 +
 .../absl/container/internal/inlined_vector.h  |   953 +
 .../include/absl/container/internal/layout.h  |   743 +
 .../container/internal/node_slot_policy.h     |    92 +
 .../absl/container/internal/raw_hash_map.h    |   198 +
 .../absl/container/internal/raw_hash_set.h    |  2365 +++
 .../internal/test_instance_tracker.h          |   274 +
 .../include/absl/container/internal/tracked.h |    83 +
 .../internal/unordered_map_constructor_test.h |   494 +
 .../internal/unordered_map_lookup_test.h      |   117 +
 .../internal/unordered_map_members_test.h     |    87 +
 .../internal/unordered_map_modifiers_test.h   |   352 +
 .../internal/unordered_set_constructor_test.h |   496 +
 .../internal/unordered_set_lookup_test.h      |    91 +
 .../internal/unordered_set_members_test.h     |    86 +
 .../internal/unordered_set_modifiers_test.h   |   221 +
 .../include/absl/container/node_hash_map.h    |   604 +
 .../include/absl/container/node_hash_set.h    |   500 +
 .../absl/debugging/failure_signal_handler.h   |   121 +
 .../debugging/internal/address_is_readable.h  |    32 +
 .../absl/debugging/internal/demangle.h        |    71 +
 .../absl/debugging/internal/elf_mem_image.h   |   139 +
 .../absl/debugging/internal/examine_stack.h   |    64 +
 .../debugging/internal/stack_consumption.h    |    50 +
 .../internal/stacktrace_aarch64-inl.inc       |   204 +
 .../debugging/internal/stacktrace_arm-inl.inc |   139 +
 .../debugging/internal/stacktrace_config.h    |    88 +
 .../internal/stacktrace_emscripten-inl.inc    |   110 +
 .../internal/stacktrace_generic-inl.inc       |   108 +
 .../internal/stacktrace_powerpc-inl.inc       |   258 +
 .../internal/stacktrace_riscv-inl.inc         |   236 +
 .../internal/stacktrace_unimplemented-inl.inc |    24 +
 .../internal/stacktrace_win32-inl.inc         |    93 +
 .../debugging/internal/stacktrace_x86-inl.inc |   369 +
 .../absl/debugging/internal/symbolize.h       |   153 +
 .../absl/debugging/internal/vdso_support.h    |   158 +
 .../grpc/include/absl/debugging/leak_check.h  |   150 +
 .../grpc/include/absl/debugging/stacktrace.h  |   231 +
 .../grpc/include/absl/debugging/symbolize.h   |    99 +
 .../absl/debugging/symbolize_darwin.inc       |   101 +
 .../include/absl/debugging/symbolize_elf.inc  |  1613 ++
 .../absl/debugging/symbolize_emscripten.inc   |    72 +
 .../debugging/symbolize_unimplemented.inc     |    40 +
 .../absl/debugging/symbolize_win32.inc        |    81 +
 .../grpc/include/absl/flags/commandlineflag.h |   200 +
 CAPI/cpp/grpc/include/absl/flags/config.h     |    68 +
 CAPI/cpp/grpc/include/absl/flags/declare.h    |    73 +
 CAPI/cpp/grpc/include/absl/flags/flag.h       |   310 +
 .../absl/flags/internal/commandlineflag.h     |    68 +
 .../grpc/include/absl/flags/internal/flag.h   |   800 +
 .../include/absl/flags/internal/flag_msvc.inc |   116 +
 .../grpc/include/absl/flags/internal/parse.h  |    59 +
 .../include/absl/flags/internal/path_util.h   |    62 +
 .../flags/internal/private_handle_accessor.h  |    61 +
 .../absl/flags/internal/program_name.h        |    50 +
 .../include/absl/flags/internal/registry.h    |    97 +
 .../absl/flags/internal/sequence_lock.h       |   187 +
 .../grpc/include/absl/flags/internal/usage.h  |   104 +
 .../cpp/grpc/include/absl/flags/marshalling.h |   356 +
 CAPI/cpp/grpc/include/absl/flags/parse.h      |    60 +
 CAPI/cpp/grpc/include/absl/flags/reflection.h |    90 +
 CAPI/cpp/grpc/include/absl/flags/usage.h      |    43 +
 .../grpc/include/absl/flags/usage_config.h    |   135 +
 .../include/absl/functional/any_invocable.h   |   313 +
 .../grpc/include/absl/functional/bind_front.h |   193 +
 .../include/absl/functional/function_ref.h    |   143 +
 .../absl/functional/internal/any_invocable.h  |   857 +
 .../absl/functional/internal/front_binder.h   |    95 +
 .../absl/functional/internal/function_ref.h   |   106 +
 CAPI/cpp/grpc/include/absl/hash/hash.h        |   421 +
 .../cpp/grpc/include/absl/hash/hash_testing.h |   378 +
 .../grpc/include/absl/hash/internal/city.h    |    78 +
 .../grpc/include/absl/hash/internal/hash.h    |  1291 ++
 .../absl/hash/internal/low_level_hash.h       |    50 +
 .../absl/hash/internal/spy_hash_state.h       |   266 +
 CAPI/cpp/grpc/include/absl/memory/memory.h    |   699 +
 CAPI/cpp/grpc/include/absl/meta/type_traits.h |   797 +
 CAPI/cpp/grpc/include/absl/numeric/bits.h     |   178 +
 CAPI/cpp/grpc/include/absl/numeric/int128.h   |  1165 ++
 .../absl/numeric/int128_have_intrinsic.inc    |   296 +
 .../absl/numeric/int128_no_intrinsic.inc      |   311 +
 .../grpc/include/absl/numeric/internal/bits.h |   358 +
 .../absl/numeric/internal/representation.h    |    55 +
 .../profiling/internal/exponential_biased.h   |   130 +
 .../profiling/internal/periodic_sampler.h     |   211 +
 .../absl/profiling/internal/sample_recorder.h |   245 +
 .../absl/random/bernoulli_distribution.h      |   200 +
 .../include/absl/random/beta_distribution.h   |   427 +
 .../grpc/include/absl/random/bit_gen_ref.h    |   185 +
 .../absl/random/discrete_distribution.h       |   247 +
 .../grpc/include/absl/random/distributions.h  |   452 +
 .../absl/random/exponential_distribution.h    |   165 +
 .../absl/random/gaussian_distribution.h       |   275 +
 .../include/absl/random/internal/chi_square.h |    89 +
 .../random/internal/distribution_caller.h     |    95 +
 .../random/internal/distribution_test_util.h  |   113 +
 .../absl/random/internal/explicit_seed_seq.h  |    92 +
 .../absl/random/internal/fast_uniform_bits.h  |   269 +
 .../include/absl/random/internal/fastmath.h   |    57 +
 .../absl/random/internal/generate_real.h      |   144 +
 .../random/internal/iostream_state_saver.h    |   245 +
 .../absl/random/internal/mock_helpers.h       |   135 +
 .../absl/random/internal/mock_overload_set.h  |   100 +
 .../absl/random/internal/nanobenchmark.h      |   172 +
 .../absl/random/internal/nonsecure_base.h     |   161 +
 .../include/absl/random/internal/pcg_engine.h |   308 +
 .../include/absl/random/internal/platform.h   |   171 +
 .../include/absl/random/internal/pool_urbg.h  |   131 +
 .../include/absl/random/internal/randen.h     |    96 +
 .../absl/random/internal/randen_detect.h      |    33 +
 .../absl/random/internal/randen_engine.h      |   264 +
 .../absl/random/internal/randen_hwaes.h       |    50 +
 .../absl/random/internal/randen_slow.h        |    40 +
 .../absl/random/internal/randen_traits.h      |    88 +
 .../absl/random/internal/salted_seed_seq.h    |   165 +
 .../absl/random/internal/seed_material.h      |   104 +
 .../absl/random/internal/sequence_urbg.h      |    60 +
 .../include/absl/random/internal/traits.h     |   149 +
 .../absl/random/internal/uniform_helper.h     |   244 +
 .../absl/random/internal/wide_multiply.h      |    96 +
 .../random/log_uniform_int_distribution.h     |   256 +
 .../include/absl/random/mock_distributions.h  |   266 +
 .../include/absl/random/mocking_bit_gen.h     |   240 +
 .../absl/random/poisson_distribution.h        |   261 +
 CAPI/cpp/grpc/include/absl/random/random.h    |   189 +
 .../include/absl/random/seed_gen_exception.h  |    55 +
 .../grpc/include/absl/random/seed_sequences.h |   111 +
 .../absl/random/uniform_int_distribution.h    |   275 +
 .../absl/random/uniform_real_distribution.h   |   202 +
 .../include/absl/random/zipf_distribution.h   |   272 +
 .../absl/status/internal/status_internal.h    |    86 +
 .../absl/status/internal/statusor_internal.h  |   396 +
 CAPI/cpp/grpc/include/absl/status/status.h    |   892 +
 .../absl/status/status_payload_printer.h      |    51 +
 CAPI/cpp/grpc/include/absl/status/statusor.h  |   776 +
 CAPI/cpp/grpc/include/absl/strings/ascii.h    |   242 +
 CAPI/cpp/grpc/include/absl/strings/charconv.h |   120 +
 CAPI/cpp/grpc/include/absl/strings/cord.h     |  1642 ++
 .../grpc/include/absl/strings/cord_analysis.h |    44 +
 .../grpc/include/absl/strings/cord_buffer.h   |   572 +
 .../include/absl/strings/cord_test_helpers.h  |   122 +
 .../include/absl/strings/cordz_test_helpers.h |   151 +
 CAPI/cpp/grpc/include/absl/strings/escaping.h |   164 +
 .../include/absl/strings/internal/char_map.h  |   156 +
 .../absl/strings/internal/charconv_bigint.h   |   423 +
 .../absl/strings/internal/charconv_parse.h    |    99 +
 .../absl/strings/internal/cord_data_edge.h    |    63 +
 .../absl/strings/internal/cord_internal.h     |   655 +
 .../absl/strings/internal/cord_rep_btree.h    |   924 +
 .../internal/cord_rep_btree_navigator.h       |   267 +
 .../strings/internal/cord_rep_btree_reader.h  |   212 +
 .../absl/strings/internal/cord_rep_consume.h  |    50 +
 .../absl/strings/internal/cord_rep_crc.h      |   102 +
 .../absl/strings/internal/cord_rep_flat.h     |   187 +
 .../absl/strings/internal/cord_rep_ring.h     |   607 +
 .../strings/internal/cord_rep_ring_reader.h   |   118 +
 .../strings/internal/cord_rep_test_util.h     |   205 +
 .../absl/strings/internal/cordz_functions.h   |    85 +
 .../absl/strings/internal/cordz_handle.h      |   131 +
 .../absl/strings/internal/cordz_info.h        |   298 +
 .../strings/internal/cordz_sample_token.h     |    97 +
 .../absl/strings/internal/cordz_statistics.h  |    88 +
 .../strings/internal/cordz_update_scope.h     |    71 +
 .../strings/internal/cordz_update_tracker.h   |   123 +
 .../include/absl/strings/internal/escaping.h  |    58 +
 .../strings/internal/escaping_test_common.h   |   133 +
 .../include/absl/strings/internal/memutil.h   |   148 +
 .../strings/internal/numbers_test_common.h    |   184 +
 .../absl/strings/internal/ostringstream.h     |    89 +
 .../absl/strings/internal/pow10_helper.h      |    40 +
 .../strings/internal/resize_uninitialized.h   |   119 +
 .../absl/strings/internal/stl_type_traits.h   |   248 +
 .../absl/strings/internal/str_format/arg.h    |   526 +
 .../absl/strings/internal/str_format/bind.h   |   248 +
 .../strings/internal/str_format/checker.h     |   338 +
 .../strings/internal/str_format/extension.h   |   448 +
 .../internal/str_format/float_conversion.h    |    37 +
 .../absl/strings/internal/str_format/output.h |    97 +
 .../absl/strings/internal/str_format/parser.h |   359 +
 .../absl/strings/internal/str_join_internal.h |   317 +
 .../strings/internal/str_split_internal.h     |   430 +
 .../absl/strings/internal/string_constant.h   |    72 +
 .../grpc/include/absl/strings/internal/utf8.h |    50 +
 CAPI/cpp/grpc/include/absl/strings/match.h    |   100 +
 CAPI/cpp/grpc/include/absl/strings/numbers.h  |   303 +
 CAPI/cpp/grpc/include/absl/strings/str_cat.h  |   415 +
 .../grpc/include/absl/strings/str_format.h    |   812 +
 CAPI/cpp/grpc/include/absl/strings/str_join.h |   287 +
 .../grpc/include/absl/strings/str_replace.h   |   219 +
 .../cpp/grpc/include/absl/strings/str_split.h |   547 +
 .../grpc/include/absl/strings/string_view.h   |   711 +
 CAPI/cpp/grpc/include/absl/strings/strip.h    |    93 +
 .../grpc/include/absl/strings/substitute.h    |   729 +
 .../include/absl/synchronization/barrier.h    |    79 +
 .../absl/synchronization/blocking_counter.h   |   101 +
 .../internal/create_thread_identity.h         |    56 +
 .../absl/synchronization/internal/futex.h     |   154 +
 .../synchronization/internal/graphcycles.h    |   141 +
 .../synchronization/internal/kernel_timeout.h |   156 +
 .../synchronization/internal/per_thread_sem.h |   110 +
 .../synchronization/internal/thread_pool.h    |    93 +
 .../absl/synchronization/internal/waiter.h    |   161 +
 .../grpc/include/absl/synchronization/mutex.h |  1090 ++
 .../absl/synchronization/notification.h       |   124 +
 CAPI/cpp/grpc/include/absl/time/civil_time.h  |   538 +
 CAPI/cpp/grpc/include/absl/time/clock.h       |    74 +
 .../internal/cctz/include/cctz/civil_time.h   |   332 +
 .../cctz/include/cctz/civil_time_detail.h     |   632 +
 .../internal/cctz/include/cctz/time_zone.h    |   459 +
 .../cctz/include/cctz/zone_info_source.h      |   102 +
 .../time/internal/cctz/src/time_zone_fixed.h  |    52 +
 .../time/internal/cctz/src/time_zone_if.h     |    77 +
 .../time/internal/cctz/src/time_zone_impl.h   |    93 +
 .../time/internal/cctz/src/time_zone_info.h   |   137 +
 .../time/internal/cctz/src/time_zone_libc.h   |    55 +
 .../time/internal/cctz/src/time_zone_posix.h  |   132 +
 .../absl/time/internal/cctz/src/tzfile.h      |   122 +
 .../time/internal/get_current_time_chrono.inc |    31 +
 .../time/internal/get_current_time_posix.inc  |    24 +
 .../include/absl/time/internal/test_util.h    |    33 +
 .../include/absl/time/internal/zoneinfo.inc   |   724 +
 CAPI/cpp/grpc/include/absl/time/time.h        |  1620 ++
 CAPI/cpp/grpc/include/absl/types/any.h        |   517 +
 .../grpc/include/absl/types/bad_any_cast.h    |    75 +
 .../include/absl/types/bad_optional_access.h  |    78 +
 .../include/absl/types/bad_variant_access.h   |    82 +
 CAPI/cpp/grpc/include/absl/types/compare.h    |   600 +
 .../absl/types/internal/conformance_aliases.h |   447 +
 .../types/internal/conformance_archetype.h    |   978 +
 .../absl/types/internal/conformance_profile.h |   933 +
 .../absl/types/internal/conformance_testing.h |  1386 ++
 .../internal/conformance_testing_helpers.h    |   391 +
 .../include/absl/types/internal/optional.h    |   404 +
 .../include/absl/types/internal/parentheses.h |    34 +
 .../grpc/include/absl/types/internal/span.h   |   128 +
 .../absl/types/internal/transform_args.h      |   246 +
 .../include/absl/types/internal/variant.h     |  1646 ++
 CAPI/cpp/grpc/include/absl/types/optional.h   |   779 +
 CAPI/cpp/grpc/include/absl/types/span.h       |   727 +
 CAPI/cpp/grpc/include/absl/types/variant.h    |   866 +
 CAPI/cpp/grpc/include/absl/utility/utility.h  |   350 +
 CAPI/cpp/grpc/include/ares.h                  |   755 +
 CAPI/cpp/grpc/include/ares_build.h            |    43 +
 CAPI/cpp/grpc/include/ares_dns.h              |   112 +
 CAPI/cpp/grpc/include/ares_nameser.h          |   484 +
 CAPI/cpp/grpc/include/ares_rules.h            |   125 +
 CAPI/cpp/grpc/include/ares_version.h          |    24 +
 CAPI/cpp/grpc/include/google/protobuf/any.h   |   157 +
 .../cpp/grpc/include/google/protobuf/any.pb.h |   384 +
 .../grpc/include/google/protobuf/any.proto    |   158 +
 .../cpp/grpc/include/google/protobuf/api.pb.h |  1437 ++
 .../grpc/include/google/protobuf/api.proto    |   208 +
 CAPI/cpp/grpc/include/google/protobuf/arena.h |   851 +
 .../grpc/include/google/protobuf/arena_impl.h |   686 +
 .../include/google/protobuf/arenastring.h     |   480 +
 .../include/google/protobuf/arenaz_sampler.h  |   207 +
 .../google/protobuf/compiler/code_generator.h |   207 +
 .../compiler/command_line_interface.h         |   464 +
 .../protobuf/compiler/cpp/cpp_generator.h     |     6 +
 .../google/protobuf/compiler/cpp/file.h       |   209 +
 .../google/protobuf/compiler/cpp/generator.h  |   107 +
 .../google/protobuf/compiler/cpp/helpers.h    |  1064 ++
 .../google/protobuf/compiler/cpp/names.h      |    97 +
 .../compiler/csharp/csharp_doc_comment.h      |    51 +
 .../compiler/csharp/csharp_generator.h        |    70 +
 .../protobuf/compiler/csharp/csharp_names.h   |   109 +
 .../protobuf/compiler/csharp/csharp_options.h |    81 +
 .../google/protobuf/compiler/importer.h       |   338 +
 .../google/protobuf/compiler/java/generator.h |    77 +
 .../protobuf/compiler/java/java_generator.h   |     6 +
 .../protobuf/compiler/java/kotlin_generator.h |    74 +
 .../google/protobuf/compiler/java/names.h     |   100 +
 .../objectivec/objectivec_generator.h         |    79 +
 .../compiler/objectivec/objectivec_helpers.h  |   353 +
 .../include/google/protobuf/compiler/parser.h |   602 +
 .../protobuf/compiler/php/php_generator.h     |    92 +
 .../include/google/protobuf/compiler/plugin.h |    96 +
 .../google/protobuf/compiler/plugin.pb.h      |  1901 ++
 .../google/protobuf/compiler/plugin.proto     |   183 +
 .../protobuf/compiler/python/generator.h      |   185 +
 .../protobuf/compiler/python/pyi_generator.h  |   120 +
 .../compiler/python/python_generator.h        |     6 +
 .../protobuf/compiler/ruby/ruby_generator.h   |    67 +
 .../grpc/include/google/protobuf/descriptor.h |  2440 +++
 .../include/google/protobuf/descriptor.pb.h   | 14821 ++++++++++++++++
 .../include/google/protobuf/descriptor.proto  |   921 +
 .../google/protobuf/descriptor_database.h     |   398 +
 .../include/google/protobuf/duration.pb.h     |   278 +
 .../include/google/protobuf/duration.proto    |   116 +
 .../include/google/protobuf/dynamic_message.h |   227 +
 .../grpc/include/google/protobuf/empty.pb.h   |   198 +
 .../grpc/include/google/protobuf/empty.proto  |    51 +
 .../cpp/grpc/include/google/protobuf/endian.h |   198 +
 .../google/protobuf/explicitly_constructed.h  |    97 +
 .../include/google/protobuf/extension_set.h   |  1561 ++
 .../google/protobuf/extension_set_inl.h       |   285 +
 .../google/protobuf/field_access_listener.h   |   172 +
 .../include/google/protobuf/field_mask.pb.h   |   317 +
 .../include/google/protobuf/field_mask.proto  |   245 +
 .../protobuf/generated_enum_reflection.h      |   100 +
 .../google/protobuf/generated_enum_util.h     |    85 +
 .../google/protobuf/generated_message_bases.h |    87 +
 .../protobuf/generated_message_reflection.h   |   354 +
 .../protobuf/generated_message_tctable_decl.h |   312 +
 .../protobuf/generated_message_tctable_impl.h |   553 +
 .../google/protobuf/generated_message_util.h  |   214 +
 .../grpc/include/google/protobuf/has_bits.h   |   117 +
 .../google/protobuf/implicit_weak_message.h   |   213 +
 .../google/protobuf/inlined_string_field.h    |   532 +
 .../include/google/protobuf/io/coded_stream.h |  1799 ++
 .../include/google/protobuf/io/gzip_stream.h  |   205 +
 .../include/google/protobuf/io/io_win32.h     |   141 +
 .../grpc/include/google/protobuf/io/printer.h |   387 +
 .../grpc/include/google/protobuf/io/strtod.h  |    55 +
 .../include/google/protobuf/io/tokenizer.h    |   442 +
 .../google/protobuf/io/zero_copy_stream.h     |   260 +
 .../protobuf/io/zero_copy_stream_impl.h       |   336 +
 .../protobuf/io/zero_copy_stream_impl_lite.h  |   413 +
 CAPI/cpp/grpc/include/google/protobuf/map.h   |  1448 ++
 .../grpc/include/google/protobuf/map_entry.h  |   134 +
 .../include/google/protobuf/map_entry_lite.h  |   563 +
 .../grpc/include/google/protobuf/map_field.h  |   946 +
 .../include/google/protobuf/map_field_inl.h   |   375 +
 .../include/google/protobuf/map_field_lite.h  |   209 +
 .../google/protobuf/map_type_handler.h        |   736 +
 .../grpc/include/google/protobuf/message.h    |  1497 ++
 .../include/google/protobuf/message_lite.h    |   591 +
 .../grpc/include/google/protobuf/metadata.h   |    36 +
 .../include/google/protobuf/metadata_lite.h   |   316 +
 .../include/google/protobuf/parse_context.h   |  1025 ++
 CAPI/cpp/grpc/include/google/protobuf/port.h  |    80 +
 .../grpc/include/google/protobuf/port_def.inc |   928 +
 .../include/google/protobuf/port_undef.inc    |   160 +
 .../grpc/include/google/protobuf/reflection.h |   570 +
 .../include/google/protobuf/reflection_ops.h  |    92 +
 .../include/google/protobuf/repeated_field.h  |  1219 ++
 .../google/protobuf/repeated_ptr_field.h      |  1970 ++
 .../grpc/include/google/protobuf/service.h    |   295 +
 .../google/protobuf/source_context.pb.h       |   282 +
 .../google/protobuf/source_context.proto      |    48 +
 .../grpc/include/google/protobuf/struct.pb.h  |  1177 ++
 .../grpc/include/google/protobuf/struct.proto |    95 +
 .../google/protobuf/stubs/bytestream.h        |   351 +
 .../include/google/protobuf/stubs/callback.h  |   583 +
 .../include/google/protobuf/stubs/casts.h     |   138 +
 .../include/google/protobuf/stubs/common.h    |   197 +
 .../grpc/include/google/protobuf/stubs/hash.h |   114 +
 .../include/google/protobuf/stubs/logging.h   |   239 +
 .../include/google/protobuf/stubs/macros.h    |    93 +
 .../include/google/protobuf/stubs/map_util.h  |   769 +
 .../include/google/protobuf/stubs/mutex.h     |   218 +
 .../grpc/include/google/protobuf/stubs/once.h |    55 +
 .../google/protobuf/stubs/platform_macros.h   |   138 +
 .../grpc/include/google/protobuf/stubs/port.h |   413 +
 .../include/google/protobuf/stubs/status.h    |   196 +
 .../include/google/protobuf/stubs/stl_util.h  |    90 +
 .../google/protobuf/stubs/stringpiece.h       |   402 +
 .../include/google/protobuf/stubs/strutil.h   |   950 +
 .../google/protobuf/stubs/template_util.h     |   138 +
 .../include/google/protobuf/text_format.h     |   693 +
 .../include/google/protobuf/timestamp.pb.h    |   278 +
 .../include/google/protobuf/timestamp.proto   |   147 +
 .../grpc/include/google/protobuf/type.pb.h    |  2571 +++
 .../grpc/include/google/protobuf/type.proto   |   187 +
 .../google/protobuf/unknown_field_set.h       |   407 +
 .../protobuf/util/delimited_message_util.h    |   109 +
 .../google/protobuf/util/field_comparator.h   |   288 +
 .../google/protobuf/util/field_mask_util.h    |   263 +
 .../include/google/protobuf/util/json_util.h  |   204 +
 .../protobuf/util/message_differencer.h       |   980 +
 .../include/google/protobuf/util/time_util.h  |   314 +
 .../google/protobuf/util/type_resolver.h      |    77 +
 .../google/protobuf/util/type_resolver_util.h |    58 +
 .../include/google/protobuf/wire_format.h     |   414 +
 .../google/protobuf/wire_format_lite.h        |  1908 ++
 .../include/google/protobuf/wrappers.pb.h     |  1741 ++
 .../include/google/protobuf/wrappers.proto    |   123 +
 CAPI/cpp/grpc/include/grpc++/alarm.h          |    28 +
 CAPI/cpp/grpc/include/grpc++/channel.h        |    28 +
 CAPI/cpp/grpc/include/grpc++/client_context.h |    28 +
 .../grpc/include/grpc++/completion_queue.h    |    28 +
 CAPI/cpp/grpc/include/grpc++/create_channel.h |    28 +
 .../include/grpc++/create_channel_posix.h     |    28 +
 ...alth_check_service_server_builder_option.h |    28 +
 .../grpc++/generic/async_generic_service.h    |    28 +
 .../include/grpc++/generic/generic_stub.h     |    28 +
 CAPI/cpp/grpc/include/grpc++/grpc++.h         |    28 +
 .../grpc++/health_check_service_interface.h   |    28 +
 CAPI/cpp/grpc/include/grpc++/impl/call.h      |    28 +
 .../grpc++/impl/channel_argument_option.h     |    28 +
 .../include/grpc++/impl/client_unary_call.h   |    28 +
 .../grpc++/impl/codegen/async_stream.h        |    28 +
 .../grpc++/impl/codegen/async_unary_call.h    |    28 +
 .../include/grpc++/impl/codegen/byte_buffer.h |    28 +
 .../grpc/include/grpc++/impl/codegen/call.h   |    28 +
 .../include/grpc++/impl/codegen/call_hook.h   |    28 +
 .../grpc++/impl/codegen/channel_interface.h   |    28 +
 .../grpc++/impl/codegen/client_context.h      |    28 +
 .../grpc++/impl/codegen/client_unary_call.h   |    28 +
 .../grpc++/impl/codegen/completion_queue.h    |    28 +
 .../impl/codegen/completion_queue_tag.h       |    28 +
 .../grpc/include/grpc++/impl/codegen/config.h |    28 +
 .../grpc++/impl/codegen/config_protobuf.h     |    28 +
 .../grpc++/impl/codegen/core_codegen.h        |    28 +
 .../impl/codegen/core_codegen_interface.h     |    28 +
 .../grpc++/impl/codegen/create_auth_context.h |    28 +
 .../grpc++/impl/codegen/grpc_library.h        |    28 +
 .../grpc++/impl/codegen/metadata_map.h        |    28 +
 .../grpc++/impl/codegen/method_handler_impl.h |    28 +
 .../include/grpc++/impl/codegen/proto_utils.h |    28 +
 .../include/grpc++/impl/codegen/rpc_method.h  |    28 +
 .../grpc++/impl/codegen/rpc_service_method.h  |    28 +
 .../impl/codegen/security/auth_context.h      |    28 +
 .../impl/codegen/serialization_traits.h       |    28 +
 .../grpc++/impl/codegen/server_context.h      |    28 +
 .../grpc++/impl/codegen/server_interface.h    |    28 +
 .../grpc++/impl/codegen/service_type.h        |    28 +
 .../grpc/include/grpc++/impl/codegen/slice.h  |    28 +
 .../grpc/include/grpc++/impl/codegen/status.h |    28 +
 .../grpc++/impl/codegen/status_code_enum.h    |    28 +
 .../include/grpc++/impl/codegen/string_ref.h  |    28 +
 .../grpc++/impl/codegen/stub_options.h        |    28 +
 .../include/grpc++/impl/codegen/sync_stream.h |    28 +
 .../grpc/include/grpc++/impl/codegen/time.h   |    28 +
 .../grpc/include/grpc++/impl/grpc_library.h   |    28 +
 .../include/grpc++/impl/method_handler_impl.h |    28 +
 .../cpp/grpc/include/grpc++/impl/rpc_method.h |    28 +
 .../include/grpc++/impl/rpc_service_method.h  |    28 +
 .../grpc++/impl/serialization_traits.h        |    28 +
 .../grpc++/impl/server_builder_option.h       |    28 +
 .../grpc++/impl/server_builder_plugin.h       |    28 +
 .../include/grpc++/impl/server_initializer.h  |    28 +
 .../grpc/include/grpc++/impl/service_type.h   |    28 +
 CAPI/cpp/grpc/include/grpc++/resource_quota.h |    28 +
 .../include/grpc++/security/auth_context.h    |    28 +
 .../grpc++/security/auth_metadata_processor.h |    28 +
 .../include/grpc++/security/credentials.h     |    28 +
 .../grpc++/security/server_credentials.h      |    28 +
 CAPI/cpp/grpc/include/grpc++/server.h         |    28 +
 CAPI/cpp/grpc/include/grpc++/server_builder.h |    28 +
 CAPI/cpp/grpc/include/grpc++/server_context.h |    28 +
 CAPI/cpp/grpc/include/grpc++/server_posix.h   |    28 +
 .../include/grpc++/support/async_stream.h     |    28 +
 .../include/grpc++/support/async_unary_call.h |    28 +
 .../grpc/include/grpc++/support/byte_buffer.h |    28 +
 .../grpc++/support/channel_arguments.h        |    28 +
 CAPI/cpp/grpc/include/grpc++/support/config.h |    28 +
 .../include/grpc++/support/error_details.h    |    28 +
 CAPI/cpp/grpc/include/grpc++/support/slice.h  |    28 +
 CAPI/cpp/grpc/include/grpc++/support/status.h |    28 +
 .../include/grpc++/support/status_code_enum.h |    28 +
 .../grpc/include/grpc++/support/string_ref.h  |    28 +
 .../include/grpc++/support/stub_options.h     |    28 +
 .../grpc/include/grpc++/support/sync_stream.h |    28 +
 CAPI/cpp/grpc/include/grpc++/support/time.h   |    28 +
 CAPI/cpp/grpc/include/grpc/byte_buffer.h      |    27 +
 .../grpc/include/grpc/byte_buffer_reader.h    |    26 +
 CAPI/cpp/grpc/include/grpc/census.h           |    40 +
 CAPI/cpp/grpc/include/grpc/compression.h      |    75 +
 .../grpc/event_engine/endpoint_config.h       |    43 +
 .../include/grpc/event_engine/event_engine.h  |   446 +
 .../internal/memory_allocator_impl.h          |    68 +
 .../grpc/event_engine/memory_allocator.h      |   211 +
 .../grpc/event_engine/memory_request.h        |    57 +
 .../cpp/grpc/include/grpc/event_engine/port.h |    39 +
 .../grpc/include/grpc/event_engine/slice.h    |   286 +
 .../include/grpc/event_engine/slice_buffer.h  |   118 +
 CAPI/cpp/grpc/include/grpc/fork.h             |    26 +
 CAPI/cpp/grpc/include/grpc/grpc.h             |   605 +
 CAPI/cpp/grpc/include/grpc/grpc_posix.h       |    63 +
 CAPI/cpp/grpc/include/grpc/grpc_security.h    |  1270 ++
 .../include/grpc/grpc_security_constants.h    |   152 +
 CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h |    97 +
 .../grpc/impl/codegen/atm_gcc_atomic.h        |    93 +
 .../include/grpc/impl/codegen/atm_gcc_sync.h  |    87 +
 .../include/grpc/impl/codegen/atm_windows.h   |   134 +
 .../include/grpc/impl/codegen/byte_buffer.h   |   103 +
 .../grpc/impl/codegen/byte_buffer_reader.h    |    44 +
 .../grpc/impl/codegen/compression_types.h     |   109 +
 .../grpc/impl/codegen/connectivity_state.h    |    47 +
 .../cpp/grpc/include/grpc/impl/codegen/fork.h |    50 +
 .../include/grpc/impl/codegen/gpr_slice.h     |    71 +
 .../include/grpc/impl/codegen/gpr_types.h     |    62 +
 .../include/grpc/impl/codegen/grpc_types.h    |   812 +
 CAPI/cpp/grpc/include/grpc/impl/codegen/log.h |   112 +
 .../include/grpc/impl/codegen/port_platform.h |   782 +
 .../grpc/impl/codegen/propagation_bits.h      |    54 +
 .../grpc/include/grpc/impl/codegen/slice.h    |   132 +
 .../grpc/include/grpc/impl/codegen/status.h   |   156 +
 .../cpp/grpc/include/grpc/impl/codegen/sync.h |    68 +
 .../include/grpc/impl/codegen/sync_abseil.h   |    38 +
 .../include/grpc/impl/codegen/sync_custom.h   |    40 +
 .../include/grpc/impl/codegen/sync_generic.h  |    51 +
 .../include/grpc/impl/codegen/sync_posix.h    |    54 +
 .../include/grpc/impl/codegen/sync_windows.h  |    42 +
 CAPI/cpp/grpc/include/grpc/load_reporting.h   |    48 +
 CAPI/cpp/grpc/include/grpc/slice.h            |   161 +
 CAPI/cpp/grpc/include/grpc/slice_buffer.h     |    84 +
 CAPI/cpp/grpc/include/grpc/status.h           |    26 +
 CAPI/cpp/grpc/include/grpc/support/alloc.h    |    52 +
 CAPI/cpp/grpc/include/grpc/support/atm.h      |    26 +
 .../include/grpc/support/atm_gcc_atomic.h     |    26 +
 .../grpc/include/grpc/support/atm_gcc_sync.h  |    26 +
 .../grpc/include/grpc/support/atm_windows.h   |    26 +
 CAPI/cpp/grpc/include/grpc/support/cpu.h      |    44 +
 CAPI/cpp/grpc/include/grpc/support/log.h      |    26 +
 .../grpc/include/grpc/support/log_windows.h   |    38 +
 .../grpc/include/grpc/support/port_platform.h |    24 +
 .../grpc/include/grpc/support/string_util.h   |    51 +
 CAPI/cpp/grpc/include/grpc/support/sync.h     |   282 +
 .../grpc/include/grpc/support/sync_abseil.h   |    26 +
 .../grpc/include/grpc/support/sync_custom.h   |    26 +
 .../grpc/include/grpc/support/sync_generic.h  |    26 +
 .../grpc/include/grpc/support/sync_posix.h    |    26 +
 .../grpc/include/grpc/support/sync_windows.h  |    26 +
 CAPI/cpp/grpc/include/grpc/support/thd_id.h   |    44 +
 CAPI/cpp/grpc/include/grpc/support/time.h     |    92 +
 .../include/grpc/support/workaround_list.h    |    31 +
 CAPI/cpp/grpc/include/grpcpp/alarm.h          |   101 +
 CAPI/cpp/grpc/include/grpcpp/channel.h        |   126 +
 CAPI/cpp/grpc/include/grpcpp/client_context.h |    39 +
 .../grpc/include/grpcpp/completion_queue.h    |    24 +
 CAPI/cpp/grpc/include/grpcpp/create_channel.h |    78 +
 .../include/grpcpp/create_channel_binder.h    |   126 +
 .../include/grpcpp/create_channel_posix.h     |    71 +
 .../include/grpcpp/ext/call_metric_recorder.h |    94 +
 ...alth_check_service_server_builder_option.h |    47 +
 .../grpcpp/generic/async_generic_service.h    |    24 +
 .../include/grpcpp/generic/generic_stub.h     |   175 +
 CAPI/cpp/grpc/include/grpcpp/grpcpp.h         |    68 +
 .../grpcpp/health_check_service_interface.h   |    58 +
 CAPI/cpp/grpc/include/grpcpp/impl/call.h      |    24 +
 .../grpcpp/impl/channel_argument_option.h     |    37 +
 .../include/grpcpp/impl/client_unary_call.h   |    24 +
 .../impl/codegen/async_generic_service.h      |   137 +
 .../grpcpp/impl/codegen/async_stream.h        |  1132 ++
 .../grpcpp/impl/codegen/async_unary_call.h    |   420 +
 .../include/grpcpp/impl/codegen/byte_buffer.h |   239 +
 .../grpc/include/grpcpp/impl/codegen/call.h   |    95 +
 .../include/grpcpp/impl/codegen/call_hook.h   |    41 +
 .../include/grpcpp/impl/codegen/call_op_set.h |  1045 ++
 .../impl/codegen/call_op_set_interface.h      |    61 +
 .../grpcpp/impl/codegen/callback_common.h     |   222 +
 .../grpcpp/impl/codegen/channel_interface.h   |   172 +
 .../grpcpp/impl/codegen/client_callback.h     |  1229 ++
 .../grpcpp/impl/codegen/client_context.h      |   518 +
 .../grpcpp/impl/codegen/client_interceptor.h  |   199 +
 .../grpcpp/impl/codegen/client_unary_call.h   |   105 +
 .../grpcpp/impl/codegen/completion_queue.h    |   466 +
 .../impl/codegen/completion_queue_tag.h       |    56 +
 .../grpc/include/grpcpp/impl/codegen/config.h |    46 +
 .../grpcpp/impl/codegen/config_protobuf.h     |   108 +
 .../grpcpp/impl/codegen/core_codegen.h        |   131 +
 .../impl/codegen/core_codegen_interface.h     |   169 +
 .../grpcpp/impl/codegen/create_auth_context.h |    35 +
 .../grpcpp/impl/codegen/delegating_channel.h  |    93 +
 .../grpcpp/impl/codegen/grpc_library.h        |    67 +
 .../grpcpp/impl/codegen/intercepted_channel.h |    85 +
 .../include/grpcpp/impl/codegen/interceptor.h |   233 +
 .../grpcpp/impl/codegen/interceptor_common.h  |   540 +
 .../grpcpp/impl/codegen/message_allocator.h   |    73 +
 .../grpcpp/impl/codegen/metadata_map.h        |   107 +
 .../grpcpp/impl/codegen/method_handler.h      |   406 +
 .../grpcpp/impl/codegen/method_handler_impl.h |    24 +
 .../grpcpp/impl/codegen/proto_buffer_reader.h |   151 +
 .../grpcpp/impl/codegen/proto_buffer_writer.h |   181 +
 .../include/grpcpp/impl/codegen/proto_utils.h |   121 +
 .../include/grpcpp/impl/codegen/rpc_method.h  |    82 +
 .../grpcpp/impl/codegen/rpc_service_method.h  |   155 +
 .../impl/codegen/security/auth_context.h      |   101 +
 .../impl/codegen/serialization_traits.h       |    64 +
 .../grpcpp/impl/codegen/server_callback.h     |   799 +
 .../impl/codegen/server_callback_handlers.h   |   889 +
 .../grpcpp/impl/codegen/server_context.h      |   679 +
 .../grpcpp/impl/codegen/server_interceptor.h  |   141 +
 .../grpcpp/impl/codegen/server_interface.h    |   370 +
 .../grpcpp/impl/codegen/service_type.h        |   238 +
 .../grpc/include/grpcpp/impl/codegen/slice.h  |   156 +
 .../grpc/include/grpcpp/impl/codegen/status.h |   141 +
 .../grpcpp/impl/codegen/status_code_enum.h    |   145 +
 .../include/grpcpp/impl/codegen/string_ref.h  |   151 +
 .../grpcpp/impl/codegen/stub_options.h        |    44 +
 .../grpc/include/grpcpp/impl/codegen/sync.h   |   158 +
 .../include/grpcpp/impl/codegen/sync_stream.h |   950 +
 .../grpc/include/grpcpp/impl/codegen/time.h   |    91 +
 .../grpc/include/grpcpp/impl/grpc_library.h   |    60 +
 .../include/grpcpp/impl/method_handler_impl.h |    24 +
 .../cpp/grpc/include/grpcpp/impl/rpc_method.h |    24 +
 .../include/grpcpp/impl/rpc_service_method.h  |    24 +
 .../grpcpp/impl/serialization_traits.h        |    24 +
 .../grpcpp/impl/server_builder_option.h       |    43 +
 .../grpcpp/impl/server_builder_plugin.h       |    66 +
 .../include/grpcpp/impl/server_initializer.h  |    54 +
 .../grpc/include/grpcpp/impl/service_type.h   |    24 +
 CAPI/cpp/grpc/include/grpcpp/resource_quota.h |    68 +
 .../include/grpcpp/security/alts_context.h    |    69 +
 .../grpc/include/grpcpp/security/alts_util.h  |    50 +
 .../include/grpcpp/security/auth_context.h    |    24 +
 .../grpcpp/security/auth_metadata_processor.h |    73 +
 .../security/authorization_policy_provider.h  |    88 +
 .../grpcpp/security/binder_credentials.h      |    43 +
 .../grpcpp/security/binder_security_policy.h  |    82 +
 .../include/grpcpp/security/credentials.h     |   349 +
 .../grpcpp/security/server_credentials.h      |   145 +
 .../security/tls_certificate_provider.h       |   127 +
 .../security/tls_certificate_verifier.h       |   238 +
 .../grpcpp/security/tls_credentials_options.h |   157 +
 CAPI/cpp/grpc/include/grpcpp/server.h         |   347 +
 CAPI/cpp/grpc/include/grpcpp/server_builder.h |   419 +
 CAPI/cpp/grpc/include/grpcpp/server_context.h |    24 +
 CAPI/cpp/grpc/include/grpcpp/server_posix.h   |    43 +
 .../include/grpcpp/support/async_stream.h     |    24 +
 .../include/grpcpp/support/async_unary_call.h |    24 +
 .../grpc/include/grpcpp/support/byte_buffer.h |    31 +
 .../grpcpp/support/channel_arguments.h        |   146 +
 .../include/grpcpp/support/client_callback.h  |    24 +
 .../grpcpp/support/client_interceptor.h       |    24 +
 CAPI/cpp/grpc/include/grpcpp/support/config.h |    24 +
 .../include/grpcpp/support/error_details.h    |    76 +
 .../grpc/include/grpcpp/support/interceptor.h |    24 +
 .../grpcpp/support/message_allocator.h        |    24 +
 .../include/grpcpp/support/method_handler.h   |    24 +
 .../grpcpp/support/proto_buffer_reader.h      |    24 +
 .../grpcpp/support/proto_buffer_writer.h      |    24 +
 .../include/grpcpp/support/server_callback.h  |    24 +
 .../grpcpp/support/server_interceptor.h       |    24 +
 CAPI/cpp/grpc/include/grpcpp/support/slice.h  |    26 +
 CAPI/cpp/grpc/include/grpcpp/support/status.h |    24 +
 .../include/grpcpp/support/status_code_enum.h |    24 +
 .../grpc/include/grpcpp/support/string_ref.h  |    24 +
 .../include/grpcpp/support/stub_options.h     |    24 +
 .../grpc/include/grpcpp/support/sync_stream.h |    24 +
 CAPI/cpp/grpc/include/grpcpp/support/time.h   |    24 +
 .../grpcpp/support/validate_service_config.h  |    36 +
 .../grpc/include/grpcpp/xds_server_builder.h  |   123 +
 .../include/openssl/__DECC_INCLUDE_EPILOGUE.H |    22 +
 .../include/openssl/__DECC_INCLUDE_PROLOGUE.H |    26 +
 CAPI/cpp/grpc/include/openssl/aes.h           |   111 +
 CAPI/cpp/grpc/include/openssl/asn1.h          |  1128 ++
 CAPI/cpp/grpc/include/openssl/asn1_mac.h      |    10 +
 CAPI/cpp/grpc/include/openssl/asn1err.h       |   140 +
 CAPI/cpp/grpc/include/openssl/asn1t.h         |   946 +
 CAPI/cpp/grpc/include/openssl/async.h         |    96 +
 CAPI/cpp/grpc/include/openssl/asyncerr.h      |    29 +
 CAPI/cpp/grpc/include/openssl/bio.h           |   886 +
 CAPI/cpp/grpc/include/openssl/bioerr.h        |    65 +
 CAPI/cpp/grpc/include/openssl/blowfish.h      |    78 +
 CAPI/cpp/grpc/include/openssl/bn.h            |   583 +
 CAPI/cpp/grpc/include/openssl/bnerr.h         |    47 +
 CAPI/cpp/grpc/include/openssl/buffer.h        |    62 +
 CAPI/cpp/grpc/include/openssl/buffererr.h     |    25 +
 CAPI/cpp/grpc/include/openssl/camellia.h      |   117 +
 CAPI/cpp/grpc/include/openssl/cast.h          |    71 +
 CAPI/cpp/grpc/include/openssl/cmac.h          |    52 +
 CAPI/cpp/grpc/include/openssl/cmp.h           |   592 +
 CAPI/cpp/grpc/include/openssl/cmp_util.h      |    56 +
 CAPI/cpp/grpc/include/openssl/cmperr.h        |   112 +
 CAPI/cpp/grpc/include/openssl/cms.h           |   493 +
 CAPI/cpp/grpc/include/openssl/cmserr.h        |   122 +
 CAPI/cpp/grpc/include/openssl/comp.h          |    59 +
 CAPI/cpp/grpc/include/openssl/comperr.h       |    31 +
 CAPI/cpp/grpc/include/openssl/conf.h          |   211 +
 CAPI/cpp/grpc/include/openssl/conf_api.h      |    46 +
 CAPI/cpp/grpc/include/openssl/conferr.h       |    51 +
 CAPI/cpp/grpc/include/openssl/configuration.h |   146 +
 CAPI/cpp/grpc/include/openssl/conftypes.h     |    44 +
 CAPI/cpp/grpc/include/openssl/core.h          |   233 +
 CAPI/cpp/grpc/include/openssl/core_dispatch.h |   943 +
 CAPI/cpp/grpc/include/openssl/core_names.h    |   556 +
 CAPI/cpp/grpc/include/openssl/core_object.h   |    41 +
 CAPI/cpp/grpc/include/openssl/crmf.h          |   227 +
 CAPI/cpp/grpc/include/openssl/crmferr.h       |    50 +
 CAPI/cpp/grpc/include/openssl/crypto.h        |   558 +
 CAPI/cpp/grpc/include/openssl/cryptoerr.h     |    46 +
 .../grpc/include/openssl/cryptoerr_legacy.h   |  1466 ++
 CAPI/cpp/grpc/include/openssl/ct.h            |   573 +
 CAPI/cpp/grpc/include/openssl/cterr.h         |    45 +
 CAPI/cpp/grpc/include/openssl/decoder.h       |   133 +
 CAPI/cpp/grpc/include/openssl/decodererr.h    |    28 +
 CAPI/cpp/grpc/include/openssl/des.h           |   211 +
 CAPI/cpp/grpc/include/openssl/dh.h            |   328 +
 CAPI/cpp/grpc/include/openssl/dherr.h         |    57 +
 CAPI/cpp/grpc/include/openssl/dsa.h           |   275 +
 CAPI/cpp/grpc/include/openssl/dsaerr.h        |    43 +
 CAPI/cpp/grpc/include/openssl/dtls1.h         |    57 +
 CAPI/cpp/grpc/include/openssl/e_os2.h         |   305 +
 CAPI/cpp/grpc/include/openssl/ebcdic.h        |    39 +
 CAPI/cpp/grpc/include/openssl/ec.h            |  1569 ++
 CAPI/cpp/grpc/include/openssl/ecdh.h          |    10 +
 CAPI/cpp/grpc/include/openssl/ecdsa.h         |    10 +
 CAPI/cpp/grpc/include/openssl/ecerr.h         |   103 +
 CAPI/cpp/grpc/include/openssl/encoder.h       |   124 +
 CAPI/cpp/grpc/include/openssl/encodererr.h    |    28 +
 CAPI/cpp/grpc/include/openssl/engine.h        |   833 +
 CAPI/cpp/grpc/include/openssl/engineerr.h     |    63 +
 CAPI/cpp/grpc/include/openssl/err.h           |   492 +
 CAPI/cpp/grpc/include/openssl/ess.h           |   128 +
 CAPI/cpp/grpc/include/openssl/esserr.h        |    32 +
 CAPI/cpp/grpc/include/openssl/evp.h           |  2170 +++
 CAPI/cpp/grpc/include/openssl/evperr.h        |   134 +
 CAPI/cpp/grpc/include/openssl/fips_names.h    |    60 +
 CAPI/cpp/grpc/include/openssl/fipskey.h       |    36 +
 CAPI/cpp/grpc/include/openssl/hmac.h          |    62 +
 CAPI/cpp/grpc/include/openssl/http.h          |   109 +
 CAPI/cpp/grpc/include/openssl/httperr.h       |    55 +
 CAPI/cpp/grpc/include/openssl/idea.h          |    82 +
 CAPI/cpp/grpc/include/openssl/kdf.h           |   138 +
 CAPI/cpp/grpc/include/openssl/kdferr.h        |    16 +
 CAPI/cpp/grpc/include/openssl/lhash.h         |   288 +
 CAPI/cpp/grpc/include/openssl/macros.h        |   304 +
 CAPI/cpp/grpc/include/openssl/md2.h           |    56 +
 CAPI/cpp/grpc/include/openssl/md4.h           |    63 +
 CAPI/cpp/grpc/include/openssl/md5.h           |    62 +
 CAPI/cpp/grpc/include/openssl/mdc2.h          |    55 +
 CAPI/cpp/grpc/include/openssl/modes.h         |   219 +
 CAPI/cpp/grpc/include/openssl/obj_mac.h       |  5481 ++++++
 CAPI/cpp/grpc/include/openssl/objects.h       |   183 +
 CAPI/cpp/grpc/include/openssl/objectserr.h    |    28 +
 CAPI/cpp/grpc/include/openssl/ocsp.h          |   483 +
 CAPI/cpp/grpc/include/openssl/ocsperr.h       |    53 +
 CAPI/cpp/grpc/include/openssl/opensslconf.h   |    17 +
 CAPI/cpp/grpc/include/openssl/opensslv.h      |   114 +
 CAPI/cpp/grpc/include/openssl/ossl_typ.h      |    16 +
 CAPI/cpp/grpc/include/openssl/param_build.h   |    63 +
 CAPI/cpp/grpc/include/openssl/params.h        |   160 +
 CAPI/cpp/grpc/include/openssl/pem.h           |   538 +
 CAPI/cpp/grpc/include/openssl/pem2.h          |    19 +
 CAPI/cpp/grpc/include/openssl/pemerr.h        |    58 +
 CAPI/cpp/grpc/include/openssl/pkcs12.h        |   350 +
 CAPI/cpp/grpc/include/openssl/pkcs12err.h     |    45 +
 CAPI/cpp/grpc/include/openssl/pkcs7.h         |   427 +
 CAPI/cpp/grpc/include/openssl/pkcs7err.h      |    63 +
 CAPI/cpp/grpc/include/openssl/prov_ssl.h      |    34 +
 CAPI/cpp/grpc/include/openssl/proverr.h       |   148 +
 CAPI/cpp/grpc/include/openssl/provider.h      |    60 +
 CAPI/cpp/grpc/include/openssl/rand.h          |   123 +
 CAPI/cpp/grpc/include/openssl/randerr.h       |    68 +
 CAPI/cpp/grpc/include/openssl/rc2.h           |    68 +
 CAPI/cpp/grpc/include/openssl/rc4.h           |    47 +
 CAPI/cpp/grpc/include/openssl/rc5.h           |    79 +
 CAPI/cpp/grpc/include/openssl/ripemd.h        |    59 +
 CAPI/cpp/grpc/include/openssl/rsa.h           |   604 +
 CAPI/cpp/grpc/include/openssl/rsaerr.h        |   107 +
 CAPI/cpp/grpc/include/openssl/safestack.h     |   297 +
 CAPI/cpp/grpc/include/openssl/seed.h          |   113 +
 CAPI/cpp/grpc/include/openssl/self_test.h     |    92 +
 CAPI/cpp/grpc/include/openssl/sha.h           |   138 +
 CAPI/cpp/grpc/include/openssl/srp.h           |   285 +
 CAPI/cpp/grpc/include/openssl/srtp.h          |    56 +
 CAPI/cpp/grpc/include/openssl/ssl.h           |  2599 +++
 CAPI/cpp/grpc/include/openssl/ssl2.h          |    30 +
 CAPI/cpp/grpc/include/openssl/ssl3.h          |   347 +
 CAPI/cpp/grpc/include/openssl/sslerr.h        |   343 +
 CAPI/cpp/grpc/include/openssl/sslerr_legacy.h |   468 +
 CAPI/cpp/grpc/include/openssl/stack.h         |    90 +
 CAPI/cpp/grpc/include/openssl/store.h         |   369 +
 CAPI/cpp/grpc/include/openssl/storeerr.h      |    49 +
 CAPI/cpp/grpc/include/openssl/symhacks.h      |    39 +
 CAPI/cpp/grpc/include/openssl/tls1.h          |  1223 ++
 CAPI/cpp/grpc/include/openssl/trace.h         |   312 +
 CAPI/cpp/grpc/include/openssl/ts.h            |   503 +
 CAPI/cpp/grpc/include/openssl/tserr.h         |    67 +
 CAPI/cpp/grpc/include/openssl/txt_db.h        |    63 +
 CAPI/cpp/grpc/include/openssl/types.h         |   236 +
 CAPI/cpp/grpc/include/openssl/ui.h            |   407 +
 CAPI/cpp/grpc/include/openssl/uierr.h         |    38 +
 CAPI/cpp/grpc/include/openssl/whrlpool.h      |    62 +
 CAPI/cpp/grpc/include/openssl/x509.h          |  1276 ++
 CAPI/cpp/grpc/include/openssl/x509_vfy.h      |   894 +
 CAPI/cpp/grpc/include/openssl/x509err.h       |    68 +
 CAPI/cpp/grpc/include/openssl/x509v3.h        |  1450 ++
 CAPI/cpp/grpc/include/openssl/x509v3err.h     |    93 +
 CAPI/cpp/grpc/include/re2/filtered_re2.h      |   114 +
 CAPI/cpp/grpc/include/re2/re2.h               |  1017 ++
 CAPI/cpp/grpc/include/re2/set.h               |    85 +
 CAPI/cpp/grpc/include/re2/stringpiece.h       |   210 +
 CAPI/cpp/grpc/include/upb/arena.h             |   225 +
 CAPI/cpp/grpc/include/upb/array.h             |    83 +
 CAPI/cpp/grpc/include/upb/bindings/lua/upb.h  |   132 +
 CAPI/cpp/grpc/include/upb/collections.h       |    36 +
 CAPI/cpp/grpc/include/upb/decode.h            |    95 +
 CAPI/cpp/grpc/include/upb/decode_fast.h       |   153 +
 CAPI/cpp/grpc/include/upb/decode_internal.h   |    36 +
 CAPI/cpp/grpc/include/upb/def.h               |   416 +
 CAPI/cpp/grpc/include/upb/def.hpp             |   441 +
 CAPI/cpp/grpc/include/upb/encode.h            |    81 +
 .../cpp/grpc/include/upb/extension_registry.h |    84 +
 CAPI/cpp/grpc/include/upb/internal/decode.h   |   211 +
 .../upb/internal/mini_table_accessors.h       |    59 +
 CAPI/cpp/grpc/include/upb/internal/table.h    |   385 +
 CAPI/cpp/grpc/include/upb/internal/upb.h      |    68 +
 .../include/upb/internal/vsnprintf_compat.h   |    52 +
 CAPI/cpp/grpc/include/upb/json_decode.h       |    47 +
 CAPI/cpp/grpc/include/upb/json_encode.h       |    65 +
 CAPI/cpp/grpc/include/upb/map.h               |   117 +
 CAPI/cpp/grpc/include/upb/message_value.h     |    66 +
 CAPI/cpp/grpc/include/upb/mini_descriptor.h   |    58 +
 CAPI/cpp/grpc/include/upb/mini_table.h        |   189 +
 CAPI/cpp/grpc/include/upb/mini_table.hpp      |   112 +
 .../grpc/include/upb/mini_table_accessors.h   |   271 +
 .../upb/mini_table_accessors_internal.h       |    36 +
 CAPI/cpp/grpc/include/upb/msg.h               |    71 +
 CAPI/cpp/grpc/include/upb/msg_internal.h      |   837 +
 CAPI/cpp/grpc/include/upb/port_def.inc        |   262 +
 CAPI/cpp/grpc/include/upb/port_undef.inc      |    63 +
 CAPI/cpp/grpc/include/upb/reflection.h        |   110 +
 CAPI/cpp/grpc/include/upb/reflection.hpp      |    37 +
 CAPI/cpp/grpc/include/upb/status.h            |    66 +
 CAPI/cpp/grpc/include/upb/table_internal.h    |    36 +
 CAPI/cpp/grpc/include/upb/text_encode.h       |    64 +
 CAPI/cpp/grpc/include/upb/upb.h               |   184 +
 CAPI/cpp/grpc/include/upb/upb.hpp             |   115 +
 CAPI/cpp/grpc/include/upb/upb_internal.h      |    36 +
 CAPI/cpp/grpc/include/upb/util/compare.h      |    66 +
 CAPI/cpp/grpc/include/upb/util/def_to_proto.h |    62 +
 .../grpc/include/upb/util/required_fields.h   |    94 +
 CAPI/cpp/grpc/include/zconf.h                 |   544 +
 CAPI/cpp/grpc/include/zlib.h                  |  1935 ++
 892 files changed, 242964 insertions(+)
 create mode 100644 CAPI/cpp/grpc/LICENSE
 create mode 100644 CAPI/cpp/grpc/include/absl/algorithm/algorithm.h
 create mode 100644 CAPI/cpp/grpc/include/absl/algorithm/container.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/attributes.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/call_once.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/casts.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/config.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/const_init.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/dynamic_annotations.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/atomic_hook.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/atomic_hook_test_helper.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/cycleclock.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/direct_mmap.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/dynamic_annotations.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/endian.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/errno_saver.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/exception_safety_testing.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/exception_testing.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/fast_type_id.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/hide_ptr.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/identity.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/inline_variable.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/inline_variable_testing.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/invoke.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/low_level_alloc.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/low_level_scheduling.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/per_thread_tls.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/prefetch.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/pretty_function.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/scheduling_mode.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/scoped_set_env.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/spinlock.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/spinlock_akaros.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/spinlock_linux.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/spinlock_posix.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/spinlock_wait.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/spinlock_win32.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/strerror.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/sysinfo.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/thread_annotations.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/thread_identity.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/throw_delegate.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/tsan_mutex_interface.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/unaligned_access.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/internal/unscaledcycleclock.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/log_severity.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/macros.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/optimization.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/options.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/policy_checks.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/port.h
 create mode 100644 CAPI/cpp/grpc/include/absl/base/thread_annotations.h
 create mode 100644 CAPI/cpp/grpc/include/absl/cleanup/cleanup.h
 create mode 100644 CAPI/cpp/grpc/include/absl/cleanup/internal/cleanup.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/btree_map.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/btree_set.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/btree_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/fixed_array.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/flat_hash_map.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/flat_hash_set.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/inlined_vector.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/btree.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/btree_container.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/common.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/compressed_tuple.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/container_memory.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/counting_allocator.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/hash_function_defaults.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/hash_generator_testing.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/hash_policy_testing.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/hash_policy_traits.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug_hooks.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/hashtablez_sampler.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/inlined_vector.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/layout.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/node_slot_policy.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/raw_hash_map.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/raw_hash_set.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/test_instance_tracker.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/tracked.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/unordered_map_constructor_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/unordered_map_lookup_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/unordered_map_members_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/unordered_map_modifiers_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/unordered_set_constructor_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/unordered_set_lookup_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/unordered_set_members_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/internal/unordered_set_modifiers_test.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/node_hash_map.h
 create mode 100644 CAPI/cpp/grpc/include/absl/container/node_hash_set.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/failure_signal_handler.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/address_is_readable.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/demangle.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/elf_mem_image.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/examine_stack.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stack_consumption.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_aarch64-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_arm-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_config.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_emscripten-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_generic-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_powerpc-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_riscv-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_unimplemented-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_win32-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_x86-inl.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/symbolize.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/internal/vdso_support.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/leak_check.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/stacktrace.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/symbolize.h
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/symbolize_darwin.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/symbolize_elf.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/symbolize_emscripten.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/symbolize_unimplemented.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/debugging/symbolize_win32.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/commandlineflag.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/config.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/declare.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/flag.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/commandlineflag.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/flag.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/flag_msvc.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/parse.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/path_util.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/private_handle_accessor.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/program_name.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/registry.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/sequence_lock.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/internal/usage.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/marshalling.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/parse.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/reflection.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/usage.h
 create mode 100644 CAPI/cpp/grpc/include/absl/flags/usage_config.h
 create mode 100644 CAPI/cpp/grpc/include/absl/functional/any_invocable.h
 create mode 100644 CAPI/cpp/grpc/include/absl/functional/bind_front.h
 create mode 100644 CAPI/cpp/grpc/include/absl/functional/function_ref.h
 create mode 100644 CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h
 create mode 100644 CAPI/cpp/grpc/include/absl/functional/internal/front_binder.h
 create mode 100644 CAPI/cpp/grpc/include/absl/functional/internal/function_ref.h
 create mode 100644 CAPI/cpp/grpc/include/absl/hash/hash.h
 create mode 100644 CAPI/cpp/grpc/include/absl/hash/hash_testing.h
 create mode 100644 CAPI/cpp/grpc/include/absl/hash/internal/city.h
 create mode 100644 CAPI/cpp/grpc/include/absl/hash/internal/hash.h
 create mode 100644 CAPI/cpp/grpc/include/absl/hash/internal/low_level_hash.h
 create mode 100644 CAPI/cpp/grpc/include/absl/hash/internal/spy_hash_state.h
 create mode 100644 CAPI/cpp/grpc/include/absl/memory/memory.h
 create mode 100644 CAPI/cpp/grpc/include/absl/meta/type_traits.h
 create mode 100644 CAPI/cpp/grpc/include/absl/numeric/bits.h
 create mode 100644 CAPI/cpp/grpc/include/absl/numeric/int128.h
 create mode 100644 CAPI/cpp/grpc/include/absl/numeric/int128_have_intrinsic.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/numeric/int128_no_intrinsic.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/numeric/internal/bits.h
 create mode 100644 CAPI/cpp/grpc/include/absl/numeric/internal/representation.h
 create mode 100644 CAPI/cpp/grpc/include/absl/profiling/internal/exponential_biased.h
 create mode 100644 CAPI/cpp/grpc/include/absl/profiling/internal/periodic_sampler.h
 create mode 100644 CAPI/cpp/grpc/include/absl/profiling/internal/sample_recorder.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/bernoulli_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/beta_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/bit_gen_ref.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/discrete_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/distributions.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/exponential_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/gaussian_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/chi_square.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/distribution_caller.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/distribution_test_util.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/explicit_seed_seq.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/fast_uniform_bits.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/fastmath.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/generate_real.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/iostream_state_saver.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/mock_helpers.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/mock_overload_set.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/nanobenchmark.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/nonsecure_base.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/pcg_engine.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/platform.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/pool_urbg.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/randen.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/randen_detect.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/randen_engine.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/randen_hwaes.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/randen_slow.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/randen_traits.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/salted_seed_seq.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/seed_material.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/sequence_urbg.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/traits.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/uniform_helper.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/internal/wide_multiply.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/log_uniform_int_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/mock_distributions.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/mocking_bit_gen.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/poisson_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/random.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/seed_gen_exception.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/seed_sequences.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/uniform_int_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/uniform_real_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/random/zipf_distribution.h
 create mode 100644 CAPI/cpp/grpc/include/absl/status/internal/status_internal.h
 create mode 100644 CAPI/cpp/grpc/include/absl/status/internal/statusor_internal.h
 create mode 100644 CAPI/cpp/grpc/include/absl/status/status.h
 create mode 100644 CAPI/cpp/grpc/include/absl/status/status_payload_printer.h
 create mode 100644 CAPI/cpp/grpc/include/absl/status/statusor.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/ascii.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/charconv.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/cord.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/cord_analysis.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/cord_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/cord_test_helpers.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/cordz_test_helpers.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/escaping.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/char_map.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/charconv_bigint.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/charconv_parse.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_data_edge.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_internal.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_navigator.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_reader.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_consume.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_crc.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_flat.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring_reader.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_test_util.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cordz_functions.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cordz_handle.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cordz_info.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cordz_sample_token.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cordz_statistics.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_scope.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_tracker.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/escaping.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/escaping_test_common.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/memutil.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/numbers_test_common.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/ostringstream.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/pow10_helper.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/resize_uninitialized.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/stl_type_traits.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_format/arg.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_format/bind.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_format/checker.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_format/extension.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_format/float_conversion.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_format/output.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_format/parser.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_join_internal.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/str_split_internal.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/string_constant.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/internal/utf8.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/match.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/numbers.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/str_cat.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/str_format.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/str_join.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/str_replace.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/str_split.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/string_view.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/strip.h
 create mode 100644 CAPI/cpp/grpc/include/absl/strings/substitute.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/barrier.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/blocking_counter.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/internal/create_thread_identity.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/internal/futex.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/internal/graphcycles.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/internal/per_thread_sem.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/internal/thread_pool.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/internal/waiter.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/mutex.h
 create mode 100644 CAPI/cpp/grpc/include/absl/synchronization/notification.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/civil_time.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/clock.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time_detail.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/time_zone.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/zone_info_source.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_fixed.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_if.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_impl.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_info.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_libc.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_posix.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/cctz/src/tzfile.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/get_current_time_chrono.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/get_current_time_posix.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/test_util.h
 create mode 100644 CAPI/cpp/grpc/include/absl/time/internal/zoneinfo.inc
 create mode 100644 CAPI/cpp/grpc/include/absl/time/time.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/any.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/bad_any_cast.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/bad_optional_access.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/bad_variant_access.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/compare.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/conformance_aliases.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/conformance_archetype.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/conformance_profile.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/conformance_testing.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/conformance_testing_helpers.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/optional.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/parentheses.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/span.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/transform_args.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/internal/variant.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/optional.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/span.h
 create mode 100644 CAPI/cpp/grpc/include/absl/types/variant.h
 create mode 100644 CAPI/cpp/grpc/include/absl/utility/utility.h
 create mode 100644 CAPI/cpp/grpc/include/ares.h
 create mode 100644 CAPI/cpp/grpc/include/ares_build.h
 create mode 100644 CAPI/cpp/grpc/include/ares_dns.h
 create mode 100644 CAPI/cpp/grpc/include/ares_nameser.h
 create mode 100644 CAPI/cpp/grpc/include/ares_rules.h
 create mode 100644 CAPI/cpp/grpc/include/ares_version.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/any.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/any.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/any.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/api.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/api.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/arena.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/arena_impl.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/arenastring.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/code_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/command_line_interface.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/cpp_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/file.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/helpers.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/names.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_doc_comment.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_names.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_options.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/importer.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/java/generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/java/java_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/java/kotlin_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/java/names.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_helpers.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/parser.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/php/php_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/python/generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/python/pyi_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/python/python_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/compiler/ruby/ruby_generator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/descriptor.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/descriptor.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/descriptor.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/descriptor_database.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/duration.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/duration.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/dynamic_message.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/empty.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/empty.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/endian.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/explicitly_constructed.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/extension_set.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/extension_set_inl.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/field_access_listener.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/field_mask.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/field_mask.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/generated_enum_reflection.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/generated_enum_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/generated_message_bases.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/generated_message_reflection.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_decl.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_impl.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/generated_message_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/has_bits.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/implicit_weak_message.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/inlined_string_field.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/coded_stream.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/gzip_stream.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/io_win32.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/printer.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/strtod.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/tokenizer.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl_lite.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/map.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/map_entry.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/map_entry_lite.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/map_field.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/map_field_inl.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/map_field_lite.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/map_type_handler.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/message.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/message_lite.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/metadata.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/metadata_lite.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/parse_context.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/port.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/port_def.inc
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/port_undef.inc
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/reflection.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/reflection_ops.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/repeated_field.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/service.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/source_context.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/source_context.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/struct.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/struct.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/bytestream.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/callback.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/casts.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/common.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/hash.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/logging.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/macros.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/mutex.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/once.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/platform_macros.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/port.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/status.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/stl_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/stringpiece.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/strutil.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/text_format.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/timestamp.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/timestamp.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/type.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/type.proto
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/unknown_field_set.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/util/delimited_message_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/util/field_comparator.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/util/field_mask_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/util/json_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/util/message_differencer.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/util/time_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/util/type_resolver.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/util/type_resolver_util.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/wire_format.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/wire_format_lite.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/wrappers.pb.h
 create mode 100644 CAPI/cpp/grpc/include/google/protobuf/wrappers.proto
 create mode 100644 CAPI/cpp/grpc/include/grpc++/alarm.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/channel.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/client_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/completion_queue.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/create_channel.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/create_channel_posix.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/ext/health_check_service_server_builder_option.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/generic/async_generic_service.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/generic/generic_stub.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/grpc++.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/health_check_service_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/call.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/channel_argument_option.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/client_unary_call.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/async_stream.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/async_unary_call.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/byte_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/call.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/call_hook.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/channel_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/client_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/client_unary_call.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/completion_queue.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/completion_queue_tag.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/config.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/config_protobuf.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/core_codegen.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/core_codegen_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/create_auth_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/grpc_library.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/metadata_map.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/method_handler_impl.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/proto_utils.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/rpc_method.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/rpc_service_method.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/security/auth_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/serialization_traits.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/server_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/server_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/service_type.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/slice.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/status.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/status_code_enum.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/string_ref.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/stub_options.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/sync_stream.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/codegen/time.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/grpc_library.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/method_handler_impl.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/rpc_method.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/rpc_service_method.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/serialization_traits.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/server_builder_option.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/server_builder_plugin.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/server_initializer.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/impl/service_type.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/resource_quota.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/security/auth_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/security/auth_metadata_processor.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/security/credentials.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/security/server_credentials.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/server.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/server_builder.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/server_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/server_posix.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/async_stream.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/async_unary_call.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/byte_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/channel_arguments.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/config.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/error_details.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/slice.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/status.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/status_code_enum.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/string_ref.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/stub_options.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/sync_stream.h
 create mode 100644 CAPI/cpp/grpc/include/grpc++/support/time.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/byte_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/byte_buffer_reader.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/census.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/compression.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/event_engine/endpoint_config.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/event_engine/event_engine.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/event_engine/internal/memory_allocator_impl.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/event_engine/memory_allocator.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/event_engine/memory_request.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/event_engine/port.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/event_engine/slice.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/event_engine/slice_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/fork.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/grpc.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/grpc_posix.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/grpc_security.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/grpc_security_constants.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_atomic.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_sync.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/atm_windows.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer_reader.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/compression_types.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/connectivity_state.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/fork.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_slice.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_types.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/grpc_types.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/log.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/port_platform.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/propagation_bits.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/slice.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/status.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/sync.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/sync_abseil.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/sync_custom.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/sync_generic.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/sync_posix.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/impl/codegen/sync_windows.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/load_reporting.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/slice.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/slice_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/status.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/alloc.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/atm.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/atm_gcc_atomic.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/atm_gcc_sync.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/atm_windows.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/cpu.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/log.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/log_windows.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/port_platform.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/string_util.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/sync.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/sync_abseil.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/sync_custom.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/sync_generic.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/sync_posix.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/sync_windows.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/thd_id.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/time.h
 create mode 100644 CAPI/cpp/grpc/include/grpc/support/workaround_list.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/alarm.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/channel.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/client_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/completion_queue.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/create_channel.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/create_channel_binder.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/create_channel_posix.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/ext/call_metric_recorder.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/ext/health_check_service_server_builder_option.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/generic/async_generic_service.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/generic/generic_stub.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/grpcpp.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/health_check_service_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/call.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/channel_argument_option.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/client_unary_call.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_generic_service.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_stream.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_unary_call.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/byte_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/call.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_hook.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/callback_common.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/channel_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_callback.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_interceptor.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_unary_call.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue_tag.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/config.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/config_protobuf.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/create_auth_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/delegating_channel.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/grpc_library.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/intercepted_channel.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor_common.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/message_allocator.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/metadata_map.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler_impl.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_reader.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_writer.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_utils.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_method.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_service_method.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/security/auth_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/serialization_traits.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback_handlers.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interceptor.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interface.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/service_type.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/slice.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/status.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/status_code_enum.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/string_ref.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/stub_options.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync_stream.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/codegen/time.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/grpc_library.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/method_handler_impl.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/rpc_method.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/rpc_service_method.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/serialization_traits.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/server_builder_option.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/server_builder_plugin.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/server_initializer.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/impl/service_type.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/resource_quota.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/alts_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/alts_util.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/auth_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/auth_metadata_processor.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/authorization_policy_provider.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/binder_credentials.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/binder_security_policy.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/credentials.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/server_credentials.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_provider.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_verifier.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/security/tls_credentials_options.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/server.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/server_builder.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/server_context.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/server_posix.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/async_stream.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/async_unary_call.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/byte_buffer.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/channel_arguments.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/client_callback.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/client_interceptor.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/config.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/error_details.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/interceptor.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/message_allocator.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/method_handler.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/proto_buffer_reader.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/proto_buffer_writer.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/server_callback.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/server_interceptor.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/slice.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/status.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/status_code_enum.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/string_ref.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/stub_options.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/sync_stream.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/time.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/support/validate_service_config.h
 create mode 100644 CAPI/cpp/grpc/include/grpcpp/xds_server_builder.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_EPILOGUE.H
 create mode 100644 CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_PROLOGUE.H
 create mode 100644 CAPI/cpp/grpc/include/openssl/aes.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/asn1.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/asn1_mac.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/asn1err.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/asn1t.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/async.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/asyncerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/bio.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/bioerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/blowfish.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/bn.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/bnerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/buffer.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/buffererr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/camellia.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cast.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cmac.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cmp.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cmp_util.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cmperr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cms.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cmserr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/comp.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/comperr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/conf.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/conf_api.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/conferr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/configuration.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/conftypes.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/core.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/core_dispatch.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/core_names.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/core_object.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/crmf.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/crmferr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/crypto.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cryptoerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cryptoerr_legacy.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ct.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/cterr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/decoder.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/decodererr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/des.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/dh.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/dherr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/dsa.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/dsaerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/dtls1.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/e_os2.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ebcdic.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ec.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ecdh.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ecdsa.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ecerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/encoder.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/encodererr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/engine.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/engineerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/err.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ess.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/esserr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/evp.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/evperr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/fips_names.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/fipskey.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/hmac.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/http.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/httperr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/idea.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/kdf.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/kdferr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/lhash.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/macros.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/md2.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/md4.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/md5.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/mdc2.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/modes.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/obj_mac.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/objects.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/objectserr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ocsp.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ocsperr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/opensslconf.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/opensslv.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ossl_typ.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/param_build.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/params.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/pem.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/pem2.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/pemerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/pkcs12.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/pkcs12err.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/pkcs7.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/pkcs7err.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/prov_ssl.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/proverr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/provider.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/rand.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/randerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/rc2.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/rc4.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/rc5.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ripemd.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/rsa.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/rsaerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/safestack.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/seed.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/self_test.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/sha.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/srp.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/srtp.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ssl.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ssl2.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ssl3.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/sslerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/sslerr_legacy.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/stack.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/store.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/storeerr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/symhacks.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/tls1.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/trace.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ts.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/tserr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/txt_db.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/types.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/ui.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/uierr.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/whrlpool.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/x509.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/x509_vfy.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/x509err.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/x509v3.h
 create mode 100644 CAPI/cpp/grpc/include/openssl/x509v3err.h
 create mode 100644 CAPI/cpp/grpc/include/re2/filtered_re2.h
 create mode 100644 CAPI/cpp/grpc/include/re2/re2.h
 create mode 100644 CAPI/cpp/grpc/include/re2/set.h
 create mode 100644 CAPI/cpp/grpc/include/re2/stringpiece.h
 create mode 100644 CAPI/cpp/grpc/include/upb/arena.h
 create mode 100644 CAPI/cpp/grpc/include/upb/array.h
 create mode 100644 CAPI/cpp/grpc/include/upb/bindings/lua/upb.h
 create mode 100644 CAPI/cpp/grpc/include/upb/collections.h
 create mode 100644 CAPI/cpp/grpc/include/upb/decode.h
 create mode 100644 CAPI/cpp/grpc/include/upb/decode_fast.h
 create mode 100644 CAPI/cpp/grpc/include/upb/decode_internal.h
 create mode 100644 CAPI/cpp/grpc/include/upb/def.h
 create mode 100644 CAPI/cpp/grpc/include/upb/def.hpp
 create mode 100644 CAPI/cpp/grpc/include/upb/encode.h
 create mode 100644 CAPI/cpp/grpc/include/upb/extension_registry.h
 create mode 100644 CAPI/cpp/grpc/include/upb/internal/decode.h
 create mode 100644 CAPI/cpp/grpc/include/upb/internal/mini_table_accessors.h
 create mode 100644 CAPI/cpp/grpc/include/upb/internal/table.h
 create mode 100644 CAPI/cpp/grpc/include/upb/internal/upb.h
 create mode 100644 CAPI/cpp/grpc/include/upb/internal/vsnprintf_compat.h
 create mode 100644 CAPI/cpp/grpc/include/upb/json_decode.h
 create mode 100644 CAPI/cpp/grpc/include/upb/json_encode.h
 create mode 100644 CAPI/cpp/grpc/include/upb/map.h
 create mode 100644 CAPI/cpp/grpc/include/upb/message_value.h
 create mode 100644 CAPI/cpp/grpc/include/upb/mini_descriptor.h
 create mode 100644 CAPI/cpp/grpc/include/upb/mini_table.h
 create mode 100644 CAPI/cpp/grpc/include/upb/mini_table.hpp
 create mode 100644 CAPI/cpp/grpc/include/upb/mini_table_accessors.h
 create mode 100644 CAPI/cpp/grpc/include/upb/mini_table_accessors_internal.h
 create mode 100644 CAPI/cpp/grpc/include/upb/msg.h
 create mode 100644 CAPI/cpp/grpc/include/upb/msg_internal.h
 create mode 100644 CAPI/cpp/grpc/include/upb/port_def.inc
 create mode 100644 CAPI/cpp/grpc/include/upb/port_undef.inc
 create mode 100644 CAPI/cpp/grpc/include/upb/reflection.h
 create mode 100644 CAPI/cpp/grpc/include/upb/reflection.hpp
 create mode 100644 CAPI/cpp/grpc/include/upb/status.h
 create mode 100644 CAPI/cpp/grpc/include/upb/table_internal.h
 create mode 100644 CAPI/cpp/grpc/include/upb/text_encode.h
 create mode 100644 CAPI/cpp/grpc/include/upb/upb.h
 create mode 100644 CAPI/cpp/grpc/include/upb/upb.hpp
 create mode 100644 CAPI/cpp/grpc/include/upb/upb_internal.h
 create mode 100644 CAPI/cpp/grpc/include/upb/util/compare.h
 create mode 100644 CAPI/cpp/grpc/include/upb/util/def_to_proto.h
 create mode 100644 CAPI/cpp/grpc/include/upb/util/required_fields.h
 create mode 100644 CAPI/cpp/grpc/include/zconf.h
 create mode 100644 CAPI/cpp/grpc/include/zlib.h

diff --git a/CAPI/cpp/grpc/LICENSE b/CAPI/cpp/grpc/LICENSE
new file mode 100644
index 0000000..0e09a3e
--- /dev/null
+++ b/CAPI/cpp/grpc/LICENSE
@@ -0,0 +1,610 @@
+
+                                 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.
+
+-----------------------------------------------------------
+
+BSD 3-Clause License
+
+Copyright 2016, Google Inc.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+
+-----------------------------------------------------------
+
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in 
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
diff --git a/CAPI/cpp/grpc/include/absl/algorithm/algorithm.h b/CAPI/cpp/grpc/include/absl/algorithm/algorithm.h
new file mode 100644
index 0000000..e9b4733
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/algorithm/algorithm.h
@@ -0,0 +1,159 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: algorithm.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains Google extensions to the standard <algorithm> C++
+// header.
+
+#ifndef ABSL_ALGORITHM_ALGORITHM_H_
+#define ABSL_ALGORITHM_ALGORITHM_H_
+
+#include <algorithm>
+#include <iterator>
+#include <type_traits>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace algorithm_internal {
+
+// Performs comparisons with operator==, similar to C++14's `std::equal_to<>`.
+struct EqualTo {
+  template <typename T, typename U>
+  bool operator()(const T& a, const U& b) const {
+    return a == b;
+  }
+};
+
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+               InputIter2 last2, Pred pred, std::input_iterator_tag,
+               std::input_iterator_tag) {
+  while (true) {
+    if (first1 == last1) return first2 == last2;
+    if (first2 == last2) return false;
+    if (!pred(*first1, *first2)) return false;
+    ++first1;
+    ++first2;
+  }
+}
+
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+               InputIter2 last2, Pred&& pred, std::random_access_iterator_tag,
+               std::random_access_iterator_tag) {
+  return (last1 - first1 == last2 - first2) &&
+         std::equal(first1, last1, first2, std::forward<Pred>(pred));
+}
+
+// When we are using our own internal predicate that just applies operator==, we
+// forward to the non-predicate form of std::equal. This enables an optimization
+// in libstdc++ that can result in std::memcmp being used for integer types.
+template <typename InputIter1, typename InputIter2>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+               InputIter2 last2, algorithm_internal::EqualTo /* unused */,
+               std::random_access_iterator_tag,
+               std::random_access_iterator_tag) {
+  return (last1 - first1 == last2 - first2) &&
+         std::equal(first1, last1, first2);
+}
+
+template <typename It>
+It RotateImpl(It first, It middle, It last, std::true_type) {
+  return std::rotate(first, middle, last);
+}
+
+template <typename It>
+It RotateImpl(It first, It middle, It last, std::false_type) {
+  std::rotate(first, middle, last);
+  return std::next(first, std::distance(middle, last));
+}
+
+}  // namespace algorithm_internal
+
+// equal()
+//
+// Compares the equality of two ranges specified by pairs of iterators, using
+// the given predicate, returning true iff for each corresponding iterator i1
+// and i2 in the first and second range respectively, pred(*i1, *i2) == true
+//
+// This comparison takes at most min(`last1` - `first1`, `last2` - `first2`)
+// invocations of the predicate. Additionally, if InputIter1 and InputIter2 are
+// both random-access iterators, and `last1` - `first1` != `last2` - `first2`,
+// then the predicate is never invoked and the function returns false.
+//
+// This is a C++11-compatible implementation of C++14 `std::equal`.  See
+// https://en.cppreference.com/w/cpp/algorithm/equal for more information.
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+           InputIter2 last2, Pred&& pred) {
+  return algorithm_internal::EqualImpl(
+      first1, last1, first2, last2, std::forward<Pred>(pred),
+      typename std::iterator_traits<InputIter1>::iterator_category{},
+      typename std::iterator_traits<InputIter2>::iterator_category{});
+}
+
+// Overload of equal() that performs comparison of two ranges specified by pairs
+// of iterators using operator==.
+template <typename InputIter1, typename InputIter2>
+bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+           InputIter2 last2) {
+  return absl::equal(first1, last1, first2, last2,
+                     algorithm_internal::EqualTo{});
+}
+
+// linear_search()
+//
+// Performs a linear search for `value` using the iterator `first` up to
+// but not including `last`, returning true if [`first`, `last`) contains an
+// element equal to `value`.
+//
+// A linear search is of O(n) complexity which is guaranteed to make at most
+// n = (`last` - `first`) comparisons. A linear search over short containers
+// may be faster than a binary search, even when the container is sorted.
+template <typename InputIterator, typename EqualityComparable>
+bool linear_search(InputIterator first, InputIterator last,
+                   const EqualityComparable& value) {
+  return std::find(first, last, value) != last;
+}
+
+// rotate()
+//
+// Performs a left rotation on a range of elements (`first`, `last`) such that
+// `middle` is now the first element. `rotate()` returns an iterator pointing to
+// the first element before rotation. This function is exactly the same as
+// `std::rotate`, but fixes a bug in gcc
+// <= 4.9 where `std::rotate` returns `void` instead of an iterator.
+//
+// The complexity of this algorithm is the same as that of `std::rotate`, but if
+// `ForwardIterator` is not a random-access iterator, then `absl::rotate`
+// performs an additional pass over the range to construct the return value.
+template <typename ForwardIterator>
+ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
+                       ForwardIterator last) {
+  return algorithm_internal::RotateImpl(
+      first, middle, last,
+      std::is_same<decltype(std::rotate(first, middle, last)),
+                   ForwardIterator>());
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_ALGORITHM_ALGORITHM_H_
diff --git a/CAPI/cpp/grpc/include/absl/algorithm/container.h b/CAPI/cpp/grpc/include/absl/algorithm/container.h
new file mode 100644
index 0000000..26b1952
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/algorithm/container.h
@@ -0,0 +1,1774 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: container.h
+// -----------------------------------------------------------------------------
+//
+// This header file provides Container-based versions of algorithmic functions
+// within the C++ standard library. The following standard library sets of
+// functions are covered within this file:
+//
+//   * Algorithmic <iterator> functions
+//   * Algorithmic <numeric> functions
+//   * <algorithm> functions
+//
+// The standard library functions operate on iterator ranges; the functions
+// within this API operate on containers, though many return iterator ranges.
+//
+// All functions within this API are named with a `c_` prefix. Calls such as
+// `absl::c_xx(container, ...) are equivalent to std:: functions such as
+// `std::xx(std::begin(cont), std::end(cont), ...)`. Functions that act on
+// iterators but not conceptually on iterator ranges (e.g. `std::iter_swap`)
+// have no equivalent here.
+//
+// For template parameter and variable naming, `C` indicates the container type
+// to which the function is applied, `Pred` indicates the predicate object type
+// to be used by the function and `T` indicates the applicable element type.
+
+#ifndef ABSL_ALGORITHM_CONTAINER_H_
+#define ABSL_ALGORITHM_CONTAINER_H_
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <numeric>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "absl/algorithm/algorithm.h"
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_algorithm_internal {
+
+// NOTE: it is important to defer to ADL lookup for building with C++ modules,
+// especially for headers like <valarray> which are not visible from this file
+// but specialize std::begin and std::end.
+using std::begin;
+using std::end;
+
+// The type of the iterator given by begin(c) (possibly std::begin(c)).
+// ContainerIter<const vector<T>> gives vector<T>::const_iterator,
+// while ContainerIter<vector<T>> gives vector<T>::iterator.
+template <typename C>
+using ContainerIter = decltype(begin(std::declval<C&>()));
+
+// An MSVC bug involving template parameter substitution requires us to use
+// decltype() here instead of just std::pair.
+template <typename C1, typename C2>
+using ContainerIterPairType =
+    decltype(std::make_pair(ContainerIter<C1>(), ContainerIter<C2>()));
+
+template <typename C>
+using ContainerDifferenceType =
+    decltype(std::distance(std::declval<ContainerIter<C>>(),
+                           std::declval<ContainerIter<C>>()));
+
+template <typename C>
+using ContainerPointerType =
+    typename std::iterator_traits<ContainerIter<C>>::pointer;
+
+// container_algorithm_internal::c_begin and
+// container_algorithm_internal::c_end are abbreviations for proper ADL
+// lookup of std::begin and std::end, i.e.
+//   using std::begin;
+//   using std::end;
+//   std::foo(begin(c), end(c));
+// becomes
+//   std::foo(container_algorithm_internal::begin(c),
+//            container_algorithm_internal::end(c));
+// These are meant for internal use only.
+
+template <typename C>
+ContainerIter<C> c_begin(C& c) { return begin(c); }
+
+template <typename C>
+ContainerIter<C> c_end(C& c) { return end(c); }
+
+template <typename T>
+struct IsUnorderedContainer : std::false_type {};
+
+template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+struct IsUnorderedContainer<
+    std::unordered_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {};
+
+template <class Key, class Hash, class KeyEqual, class Allocator>
+struct IsUnorderedContainer<std::unordered_set<Key, Hash, KeyEqual, Allocator>>
+    : std::true_type {};
+
+// container_algorithm_internal::c_size. It is meant for internal use only.
+
+template <class C>
+auto c_size(C& c) -> decltype(c.size()) {
+  return c.size();
+}
+
+template <class T, std::size_t N>
+constexpr std::size_t c_size(T (&)[N]) {
+  return N;
+}
+
+}  // namespace container_algorithm_internal
+
+// PUBLIC API
+
+//------------------------------------------------------------------------------
+// Abseil algorithm.h functions
+//------------------------------------------------------------------------------
+
+// c_linear_search()
+//
+// Container-based version of absl::linear_search() for performing a linear
+// search within a container.
+template <typename C, typename EqualityComparable>
+bool c_linear_search(const C& c, EqualityComparable&& value) {
+  return linear_search(container_algorithm_internal::c_begin(c),
+                       container_algorithm_internal::c_end(c),
+                       std::forward<EqualityComparable>(value));
+}
+
+//------------------------------------------------------------------------------
+// <iterator> algorithms
+//------------------------------------------------------------------------------
+
+// c_distance()
+//
+// Container-based version of the <iterator> `std::distance()` function to
+// return the number of elements within a container.
+template <typename C>
+container_algorithm_internal::ContainerDifferenceType<const C> c_distance(
+    const C& c) {
+  return std::distance(container_algorithm_internal::c_begin(c),
+                       container_algorithm_internal::c_end(c));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Non-modifying sequence operations
+//------------------------------------------------------------------------------
+
+// c_all_of()
+//
+// Container-based version of the <algorithm> `std::all_of()` function to
+// test if all elements within a container satisfy a condition.
+template <typename C, typename Pred>
+bool c_all_of(const C& c, Pred&& pred) {
+  return std::all_of(container_algorithm_internal::c_begin(c),
+                     container_algorithm_internal::c_end(c),
+                     std::forward<Pred>(pred));
+}
+
+// c_any_of()
+//
+// Container-based version of the <algorithm> `std::any_of()` function to
+// test if any element in a container fulfills a condition.
+template <typename C, typename Pred>
+bool c_any_of(const C& c, Pred&& pred) {
+  return std::any_of(container_algorithm_internal::c_begin(c),
+                     container_algorithm_internal::c_end(c),
+                     std::forward<Pred>(pred));
+}
+
+// c_none_of()
+//
+// Container-based version of the <algorithm> `std::none_of()` function to
+// test if no elements in a container fulfill a condition.
+template <typename C, typename Pred>
+bool c_none_of(const C& c, Pred&& pred) {
+  return std::none_of(container_algorithm_internal::c_begin(c),
+                      container_algorithm_internal::c_end(c),
+                      std::forward<Pred>(pred));
+}
+
+// c_for_each()
+//
+// Container-based version of the <algorithm> `std::for_each()` function to
+// apply a function to a container's elements.
+template <typename C, typename Function>
+decay_t<Function> c_for_each(C&& c, Function&& f) {
+  return std::for_each(container_algorithm_internal::c_begin(c),
+                       container_algorithm_internal::c_end(c),
+                       std::forward<Function>(f));
+}
+
+// c_find()
+//
+// Container-based version of the <algorithm> `std::find()` function to find
+// the first element containing the passed value within a container value.
+template <typename C, typename T>
+container_algorithm_internal::ContainerIter<C> c_find(C& c, T&& value) {
+  return std::find(container_algorithm_internal::c_begin(c),
+                   container_algorithm_internal::c_end(c),
+                   std::forward<T>(value));
+}
+
+// c_find_if()
+//
+// Container-based version of the <algorithm> `std::find_if()` function to find
+// the first element in a container matching the given condition.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_find_if(C& c, Pred&& pred) {
+  return std::find_if(container_algorithm_internal::c_begin(c),
+                      container_algorithm_internal::c_end(c),
+                      std::forward<Pred>(pred));
+}
+
+// c_find_if_not()
+//
+// Container-based version of the <algorithm> `std::find_if_not()` function to
+// find the first element in a container not matching the given condition.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_find_if_not(C& c,
+                                                             Pred&& pred) {
+  return std::find_if_not(container_algorithm_internal::c_begin(c),
+                          container_algorithm_internal::c_end(c),
+                          std::forward<Pred>(pred));
+}
+
+// c_find_end()
+//
+// Container-based version of the <algorithm> `std::find_end()` function to
+// find the last subsequence within a container.
+template <typename Sequence1, typename Sequence2>
+container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
+    Sequence1& sequence, Sequence2& subsequence) {
+  return std::find_end(container_algorithm_internal::c_begin(sequence),
+                       container_algorithm_internal::c_end(sequence),
+                       container_algorithm_internal::c_begin(subsequence),
+                       container_algorithm_internal::c_end(subsequence));
+}
+
+// Overload of c_find_end() for using a predicate evaluation other than `==` as
+// the function's test condition.
+template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
+    Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
+  return std::find_end(container_algorithm_internal::c_begin(sequence),
+                       container_algorithm_internal::c_end(sequence),
+                       container_algorithm_internal::c_begin(subsequence),
+                       container_algorithm_internal::c_end(subsequence),
+                       std::forward<BinaryPredicate>(pred));
+}
+
+// c_find_first_of()
+//
+// Container-based version of the <algorithm> `std::find_first_of()` function to
+// find the first element within the container that is also within the options
+// container.
+template <typename C1, typename C2>
+container_algorithm_internal::ContainerIter<C1> c_find_first_of(C1& container,
+                                                                C2& options) {
+  return std::find_first_of(container_algorithm_internal::c_begin(container),
+                            container_algorithm_internal::c_end(container),
+                            container_algorithm_internal::c_begin(options),
+                            container_algorithm_internal::c_end(options));
+}
+
+// Overload of c_find_first_of() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename C1, typename C2, typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<C1> c_find_first_of(
+    C1& container, C2& options, BinaryPredicate&& pred) {
+  return std::find_first_of(container_algorithm_internal::c_begin(container),
+                            container_algorithm_internal::c_end(container),
+                            container_algorithm_internal::c_begin(options),
+                            container_algorithm_internal::c_end(options),
+                            std::forward<BinaryPredicate>(pred));
+}
+
+// c_adjacent_find()
+//
+// Container-based version of the <algorithm> `std::adjacent_find()` function to
+// find equal adjacent elements within a container.
+template <typename Sequence>
+container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
+    Sequence& sequence) {
+  return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
+                            container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_adjacent_find() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename Sequence, typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
+    Sequence& sequence, BinaryPredicate&& pred) {
+  return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
+                            container_algorithm_internal::c_end(sequence),
+                            std::forward<BinaryPredicate>(pred));
+}
+
+// c_count()
+//
+// Container-based version of the <algorithm> `std::count()` function to count
+// values that match within a container.
+template <typename C, typename T>
+container_algorithm_internal::ContainerDifferenceType<const C> c_count(
+    const C& c, T&& value) {
+  return std::count(container_algorithm_internal::c_begin(c),
+                    container_algorithm_internal::c_end(c),
+                    std::forward<T>(value));
+}
+
+// c_count_if()
+//
+// Container-based version of the <algorithm> `std::count_if()` function to
+// count values matching a condition within a container.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerDifferenceType<const C> c_count_if(
+    const C& c, Pred&& pred) {
+  return std::count_if(container_algorithm_internal::c_begin(c),
+                       container_algorithm_internal::c_end(c),
+                       std::forward<Pred>(pred));
+}
+
+// c_mismatch()
+//
+// Container-based version of the <algorithm> `std::mismatch()` function to
+// return the first element where two ordered containers differ. Applies `==` to
+// the first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
+template <typename C1, typename C2>
+container_algorithm_internal::ContainerIterPairType<C1, C2>
+c_mismatch(C1& c1, C2& c2) {
+  auto first1 = container_algorithm_internal::c_begin(c1);
+  auto last1 = container_algorithm_internal::c_end(c1);
+  auto first2 = container_algorithm_internal::c_begin(c2);
+  auto last2 = container_algorithm_internal::c_end(c2);
+
+  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
+    // Negates equality because Cpp17EqualityComparable doesn't require clients
+    // to overload both `operator==` and `operator!=`.
+    if (!(*first1 == *first2)) {
+      break;
+    }
+  }
+
+  return std::make_pair(first1, first2);
+}
+
+// Overload of c_mismatch() for using a predicate evaluation other than `==` as
+// the function's test condition. Applies `pred`to the first N elements of `c1`
+// and `c2`, where N = min(size(c1), size(c2)).
+template <typename C1, typename C2, typename BinaryPredicate>
+container_algorithm_internal::ContainerIterPairType<C1, C2>
+c_mismatch(C1& c1, C2& c2, BinaryPredicate pred) {
+  auto first1 = container_algorithm_internal::c_begin(c1);
+  auto last1 = container_algorithm_internal::c_end(c1);
+  auto first2 = container_algorithm_internal::c_begin(c2);
+  auto last2 = container_algorithm_internal::c_end(c2);
+
+  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
+    if (!pred(*first1, *first2)) {
+      break;
+    }
+  }
+
+  return std::make_pair(first1, first2);
+}
+
+// c_equal()
+//
+// Container-based version of the <algorithm> `std::equal()` function to
+// test whether two containers are equal.
+//
+// NOTE: the semantics of c_equal() are slightly different than those of
+// equal(): while the latter iterates over the second container only up to the
+// size of the first container, c_equal() also checks whether the container
+// sizes are equal.  This better matches expectations about c_equal() based on
+// its signature.
+//
+// Example:
+//   vector v1 = <1, 2, 3>;
+//   vector v2 = <1, 2, 3, 4>;
+//   equal(std::begin(v1), std::end(v1), std::begin(v2)) returns true
+//   c_equal(v1, v2) returns false
+
+template <typename C1, typename C2>
+bool c_equal(const C1& c1, const C2& c2) {
+  return ((container_algorithm_internal::c_size(c1) ==
+           container_algorithm_internal::c_size(c2)) &&
+          std::equal(container_algorithm_internal::c_begin(c1),
+                     container_algorithm_internal::c_end(c1),
+                     container_algorithm_internal::c_begin(c2)));
+}
+
+// Overload of c_equal() for using a predicate evaluation other than `==` as
+// the function's test condition.
+template <typename C1, typename C2, typename BinaryPredicate>
+bool c_equal(const C1& c1, const C2& c2, BinaryPredicate&& pred) {
+  return ((container_algorithm_internal::c_size(c1) ==
+           container_algorithm_internal::c_size(c2)) &&
+          std::equal(container_algorithm_internal::c_begin(c1),
+                     container_algorithm_internal::c_end(c1),
+                     container_algorithm_internal::c_begin(c2),
+                     std::forward<BinaryPredicate>(pred)));
+}
+
+// c_is_permutation()
+//
+// Container-based version of the <algorithm> `std::is_permutation()` function
+// to test whether a container is a permutation of another.
+template <typename C1, typename C2>
+bool c_is_permutation(const C1& c1, const C2& c2) {
+  using std::begin;
+  using std::end;
+  return c1.size() == c2.size() &&
+         std::is_permutation(begin(c1), end(c1), begin(c2));
+}
+
+// Overload of c_is_permutation() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename C1, typename C2, typename BinaryPredicate>
+bool c_is_permutation(const C1& c1, const C2& c2, BinaryPredicate&& pred) {
+  using std::begin;
+  using std::end;
+  return c1.size() == c2.size() &&
+         std::is_permutation(begin(c1), end(c1), begin(c2),
+                             std::forward<BinaryPredicate>(pred));
+}
+
+// c_search()
+//
+// Container-based version of the <algorithm> `std::search()` function to search
+// a container for a subsequence.
+template <typename Sequence1, typename Sequence2>
+container_algorithm_internal::ContainerIter<Sequence1> c_search(
+    Sequence1& sequence, Sequence2& subsequence) {
+  return std::search(container_algorithm_internal::c_begin(sequence),
+                     container_algorithm_internal::c_end(sequence),
+                     container_algorithm_internal::c_begin(subsequence),
+                     container_algorithm_internal::c_end(subsequence));
+}
+
+// Overload of c_search() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<Sequence1> c_search(
+    Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
+  return std::search(container_algorithm_internal::c_begin(sequence),
+                     container_algorithm_internal::c_end(sequence),
+                     container_algorithm_internal::c_begin(subsequence),
+                     container_algorithm_internal::c_end(subsequence),
+                     std::forward<BinaryPredicate>(pred));
+}
+
+// c_search_n()
+//
+// Container-based version of the <algorithm> `std::search_n()` function to
+// search a container for the first sequence of N elements.
+template <typename Sequence, typename Size, typename T>
+container_algorithm_internal::ContainerIter<Sequence> c_search_n(
+    Sequence& sequence, Size count, T&& value) {
+  return std::search_n(container_algorithm_internal::c_begin(sequence),
+                       container_algorithm_internal::c_end(sequence), count,
+                       std::forward<T>(value));
+}
+
+// Overload of c_search_n() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename Sequence, typename Size, typename T,
+          typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<Sequence> c_search_n(
+    Sequence& sequence, Size count, T&& value, BinaryPredicate&& pred) {
+  return std::search_n(container_algorithm_internal::c_begin(sequence),
+                       container_algorithm_internal::c_end(sequence), count,
+                       std::forward<T>(value),
+                       std::forward<BinaryPredicate>(pred));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Modifying sequence operations
+//------------------------------------------------------------------------------
+
+// c_copy()
+//
+// Container-based version of the <algorithm> `std::copy()` function to copy a
+// container's elements into an iterator.
+template <typename InputSequence, typename OutputIterator>
+OutputIterator c_copy(const InputSequence& input, OutputIterator output) {
+  return std::copy(container_algorithm_internal::c_begin(input),
+                   container_algorithm_internal::c_end(input), output);
+}
+
+// c_copy_n()
+//
+// Container-based version of the <algorithm> `std::copy_n()` function to copy a
+// container's first N elements into an iterator.
+template <typename C, typename Size, typename OutputIterator>
+OutputIterator c_copy_n(const C& input, Size n, OutputIterator output) {
+  return std::copy_n(container_algorithm_internal::c_begin(input), n, output);
+}
+
+// c_copy_if()
+//
+// Container-based version of the <algorithm> `std::copy_if()` function to copy
+// a container's elements satisfying some condition into an iterator.
+template <typename InputSequence, typename OutputIterator, typename Pred>
+OutputIterator c_copy_if(const InputSequence& input, OutputIterator output,
+                         Pred&& pred) {
+  return std::copy_if(container_algorithm_internal::c_begin(input),
+                      container_algorithm_internal::c_end(input), output,
+                      std::forward<Pred>(pred));
+}
+
+// c_copy_backward()
+//
+// Container-based version of the <algorithm> `std::copy_backward()` function to
+// copy a container's elements in reverse order into an iterator.
+template <typename C, typename BidirectionalIterator>
+BidirectionalIterator c_copy_backward(const C& src,
+                                      BidirectionalIterator dest) {
+  return std::copy_backward(container_algorithm_internal::c_begin(src),
+                            container_algorithm_internal::c_end(src), dest);
+}
+
+// c_move()
+//
+// Container-based version of the <algorithm> `std::move()` function to move
+// a container's elements into an iterator.
+template <typename C, typename OutputIterator>
+OutputIterator c_move(C&& src, OutputIterator dest) {
+  return std::move(container_algorithm_internal::c_begin(src),
+                   container_algorithm_internal::c_end(src), dest);
+}
+
+// c_move_backward()
+//
+// Container-based version of the <algorithm> `std::move_backward()` function to
+// move a container's elements into an iterator in reverse order.
+template <typename C, typename BidirectionalIterator>
+BidirectionalIterator c_move_backward(C&& src, BidirectionalIterator dest) {
+  return std::move_backward(container_algorithm_internal::c_begin(src),
+                            container_algorithm_internal::c_end(src), dest);
+}
+
+// c_swap_ranges()
+//
+// Container-based version of the <algorithm> `std::swap_ranges()` function to
+// swap a container's elements with another container's elements. Swaps the
+// first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
+template <typename C1, typename C2>
+container_algorithm_internal::ContainerIter<C2> c_swap_ranges(C1& c1, C2& c2) {
+  auto first1 = container_algorithm_internal::c_begin(c1);
+  auto last1 = container_algorithm_internal::c_end(c1);
+  auto first2 = container_algorithm_internal::c_begin(c2);
+  auto last2 = container_algorithm_internal::c_end(c2);
+
+  using std::swap;
+  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
+    swap(*first1, *first2);
+  }
+  return first2;
+}
+
+// c_transform()
+//
+// Container-based version of the <algorithm> `std::transform()` function to
+// transform a container's elements using the unary operation, storing the
+// result in an iterator pointing to the last transformed element in the output
+// range.
+template <typename InputSequence, typename OutputIterator, typename UnaryOp>
+OutputIterator c_transform(const InputSequence& input, OutputIterator output,
+                           UnaryOp&& unary_op) {
+  return std::transform(container_algorithm_internal::c_begin(input),
+                        container_algorithm_internal::c_end(input), output,
+                        std::forward<UnaryOp>(unary_op));
+}
+
+// Overload of c_transform() for performing a transformation using a binary
+// predicate. Applies `binary_op` to the first N elements of `c1` and `c2`,
+// where N = min(size(c1), size(c2)).
+template <typename InputSequence1, typename InputSequence2,
+          typename OutputIterator, typename BinaryOp>
+OutputIterator c_transform(const InputSequence1& input1,
+                           const InputSequence2& input2, OutputIterator output,
+                           BinaryOp&& binary_op) {
+  auto first1 = container_algorithm_internal::c_begin(input1);
+  auto last1 = container_algorithm_internal::c_end(input1);
+  auto first2 = container_algorithm_internal::c_begin(input2);
+  auto last2 = container_algorithm_internal::c_end(input2);
+  for (; first1 != last1 && first2 != last2;
+       ++first1, (void)++first2, ++output) {
+    *output = binary_op(*first1, *first2);
+  }
+
+  return output;
+}
+
+// c_replace()
+//
+// Container-based version of the <algorithm> `std::replace()` function to
+// replace a container's elements of some value with a new value. The container
+// is modified in place.
+template <typename Sequence, typename T>
+void c_replace(Sequence& sequence, const T& old_value, const T& new_value) {
+  std::replace(container_algorithm_internal::c_begin(sequence),
+               container_algorithm_internal::c_end(sequence), old_value,
+               new_value);
+}
+
+// c_replace_if()
+//
+// Container-based version of the <algorithm> `std::replace_if()` function to
+// replace a container's elements of some value with a new value based on some
+// condition. The container is modified in place.
+template <typename C, typename Pred, typename T>
+void c_replace_if(C& c, Pred&& pred, T&& new_value) {
+  std::replace_if(container_algorithm_internal::c_begin(c),
+                  container_algorithm_internal::c_end(c),
+                  std::forward<Pred>(pred), std::forward<T>(new_value));
+}
+
+// c_replace_copy()
+//
+// Container-based version of the <algorithm> `std::replace_copy()` function to
+// replace a container's elements of some value with a new value  and return the
+// results within an iterator.
+template <typename C, typename OutputIterator, typename T>
+OutputIterator c_replace_copy(const C& c, OutputIterator result, T&& old_value,
+                              T&& new_value) {
+  return std::replace_copy(container_algorithm_internal::c_begin(c),
+                           container_algorithm_internal::c_end(c), result,
+                           std::forward<T>(old_value),
+                           std::forward<T>(new_value));
+}
+
+// c_replace_copy_if()
+//
+// Container-based version of the <algorithm> `std::replace_copy_if()` function
+// to replace a container's elements of some value with a new value based on
+// some condition, and return the results within an iterator.
+template <typename C, typename OutputIterator, typename Pred, typename T>
+OutputIterator c_replace_copy_if(const C& c, OutputIterator result, Pred&& pred,
+                                 T&& new_value) {
+  return std::replace_copy_if(container_algorithm_internal::c_begin(c),
+                              container_algorithm_internal::c_end(c), result,
+                              std::forward<Pred>(pred),
+                              std::forward<T>(new_value));
+}
+
+// c_fill()
+//
+// Container-based version of the <algorithm> `std::fill()` function to fill a
+// container with some value.
+template <typename C, typename T>
+void c_fill(C& c, T&& value) {
+  std::fill(container_algorithm_internal::c_begin(c),
+            container_algorithm_internal::c_end(c), std::forward<T>(value));
+}
+
+// c_fill_n()
+//
+// Container-based version of the <algorithm> `std::fill_n()` function to fill
+// the first N elements in a container with some value.
+template <typename C, typename Size, typename T>
+void c_fill_n(C& c, Size n, T&& value) {
+  std::fill_n(container_algorithm_internal::c_begin(c), n,
+              std::forward<T>(value));
+}
+
+// c_generate()
+//
+// Container-based version of the <algorithm> `std::generate()` function to
+// assign a container's elements to the values provided by the given generator.
+template <typename C, typename Generator>
+void c_generate(C& c, Generator&& gen) {
+  std::generate(container_algorithm_internal::c_begin(c),
+                container_algorithm_internal::c_end(c),
+                std::forward<Generator>(gen));
+}
+
+// c_generate_n()
+//
+// Container-based version of the <algorithm> `std::generate_n()` function to
+// assign a container's first N elements to the values provided by the given
+// generator.
+template <typename C, typename Size, typename Generator>
+container_algorithm_internal::ContainerIter<C> c_generate_n(C& c, Size n,
+                                                            Generator&& gen) {
+  return std::generate_n(container_algorithm_internal::c_begin(c), n,
+                         std::forward<Generator>(gen));
+}
+
+// Note: `c_xx()` <algorithm> container versions for `remove()`, `remove_if()`,
+// and `unique()` are omitted, because it's not clear whether or not such
+// functions should call erase on their supplied sequences afterwards. Either
+// behavior would be surprising for a different set of users.
+
+// c_remove_copy()
+//
+// Container-based version of the <algorithm> `std::remove_copy()` function to
+// copy a container's elements while removing any elements matching the given
+// `value`.
+template <typename C, typename OutputIterator, typename T>
+OutputIterator c_remove_copy(const C& c, OutputIterator result, T&& value) {
+  return std::remove_copy(container_algorithm_internal::c_begin(c),
+                          container_algorithm_internal::c_end(c), result,
+                          std::forward<T>(value));
+}
+
+// c_remove_copy_if()
+//
+// Container-based version of the <algorithm> `std::remove_copy_if()` function
+// to copy a container's elements while removing any elements matching the given
+// condition.
+template <typename C, typename OutputIterator, typename Pred>
+OutputIterator c_remove_copy_if(const C& c, OutputIterator result,
+                                Pred&& pred) {
+  return std::remove_copy_if(container_algorithm_internal::c_begin(c),
+                             container_algorithm_internal::c_end(c), result,
+                             std::forward<Pred>(pred));
+}
+
+// c_unique_copy()
+//
+// Container-based version of the <algorithm> `std::unique_copy()` function to
+// copy a container's elements while removing any elements containing duplicate
+// values.
+template <typename C, typename OutputIterator>
+OutputIterator c_unique_copy(const C& c, OutputIterator result) {
+  return std::unique_copy(container_algorithm_internal::c_begin(c),
+                          container_algorithm_internal::c_end(c), result);
+}
+
+// Overload of c_unique_copy() for using a predicate evaluation other than
+// `==` for comparing uniqueness of the element values.
+template <typename C, typename OutputIterator, typename BinaryPredicate>
+OutputIterator c_unique_copy(const C& c, OutputIterator result,
+                             BinaryPredicate&& pred) {
+  return std::unique_copy(container_algorithm_internal::c_begin(c),
+                          container_algorithm_internal::c_end(c), result,
+                          std::forward<BinaryPredicate>(pred));
+}
+
+// c_reverse()
+//
+// Container-based version of the <algorithm> `std::reverse()` function to
+// reverse a container's elements.
+template <typename Sequence>
+void c_reverse(Sequence& sequence) {
+  std::reverse(container_algorithm_internal::c_begin(sequence),
+               container_algorithm_internal::c_end(sequence));
+}
+
+// c_reverse_copy()
+//
+// Container-based version of the <algorithm> `std::reverse()` function to
+// reverse a container's elements and write them to an iterator range.
+template <typename C, typename OutputIterator>
+OutputIterator c_reverse_copy(const C& sequence, OutputIterator result) {
+  return std::reverse_copy(container_algorithm_internal::c_begin(sequence),
+                           container_algorithm_internal::c_end(sequence),
+                           result);
+}
+
+// c_rotate()
+//
+// Container-based version of the <algorithm> `std::rotate()` function to
+// shift a container's elements leftward such that the `middle` element becomes
+// the first element in the container.
+template <typename C,
+          typename Iterator = container_algorithm_internal::ContainerIter<C>>
+Iterator c_rotate(C& sequence, Iterator middle) {
+  return absl::rotate(container_algorithm_internal::c_begin(sequence), middle,
+                      container_algorithm_internal::c_end(sequence));
+}
+
+// c_rotate_copy()
+//
+// Container-based version of the <algorithm> `std::rotate_copy()` function to
+// shift a container's elements leftward such that the `middle` element becomes
+// the first element in a new iterator range.
+template <typename C, typename OutputIterator>
+OutputIterator c_rotate_copy(
+    const C& sequence,
+    container_algorithm_internal::ContainerIter<const C> middle,
+    OutputIterator result) {
+  return std::rotate_copy(container_algorithm_internal::c_begin(sequence),
+                          middle, container_algorithm_internal::c_end(sequence),
+                          result);
+}
+
+// c_shuffle()
+//
+// Container-based version of the <algorithm> `std::shuffle()` function to
+// randomly shuffle elements within the container using a `gen()` uniform random
+// number generator.
+template <typename RandomAccessContainer, typename UniformRandomBitGenerator>
+void c_shuffle(RandomAccessContainer& c, UniformRandomBitGenerator&& gen) {
+  std::shuffle(container_algorithm_internal::c_begin(c),
+               container_algorithm_internal::c_end(c),
+               std::forward<UniformRandomBitGenerator>(gen));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Partition functions
+//------------------------------------------------------------------------------
+
+// c_is_partitioned()
+//
+// Container-based version of the <algorithm> `std::is_partitioned()` function
+// to test whether all elements in the container for which `pred` returns `true`
+// precede those for which `pred` is `false`.
+template <typename C, typename Pred>
+bool c_is_partitioned(const C& c, Pred&& pred) {
+  return std::is_partitioned(container_algorithm_internal::c_begin(c),
+                             container_algorithm_internal::c_end(c),
+                             std::forward<Pred>(pred));
+}
+
+// c_partition()
+//
+// Container-based version of the <algorithm> `std::partition()` function
+// to rearrange all elements in a container in such a way that all elements for
+// which `pred` returns `true` precede all those for which it returns `false`,
+// returning an iterator to the first element of the second group.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_partition(C& c, Pred&& pred) {
+  return std::partition(container_algorithm_internal::c_begin(c),
+                        container_algorithm_internal::c_end(c),
+                        std::forward<Pred>(pred));
+}
+
+// c_stable_partition()
+//
+// Container-based version of the <algorithm> `std::stable_partition()` function
+// to rearrange all elements in a container in such a way that all elements for
+// which `pred` returns `true` precede all those for which it returns `false`,
+// preserving the relative ordering between the two groups. The function returns
+// an iterator to the first element of the second group.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_stable_partition(C& c,
+                                                                  Pred&& pred) {
+  return std::stable_partition(container_algorithm_internal::c_begin(c),
+                               container_algorithm_internal::c_end(c),
+                               std::forward<Pred>(pred));
+}
+
+// c_partition_copy()
+//
+// Container-based version of the <algorithm> `std::partition_copy()` function
+// to partition a container's elements and return them into two iterators: one
+// for which `pred` returns `true`, and one for which `pred` returns `false.`
+
+template <typename C, typename OutputIterator1, typename OutputIterator2,
+          typename Pred>
+std::pair<OutputIterator1, OutputIterator2> c_partition_copy(
+    const C& c, OutputIterator1 out_true, OutputIterator2 out_false,
+    Pred&& pred) {
+  return std::partition_copy(container_algorithm_internal::c_begin(c),
+                             container_algorithm_internal::c_end(c), out_true,
+                             out_false, std::forward<Pred>(pred));
+}
+
+// c_partition_point()
+//
+// Container-based version of the <algorithm> `std::partition_point()` function
+// to return the first element of an already partitioned container for which
+// the given `pred` is not `true`.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_partition_point(C& c,
+                                                                 Pred&& pred) {
+  return std::partition_point(container_algorithm_internal::c_begin(c),
+                              container_algorithm_internal::c_end(c),
+                              std::forward<Pred>(pred));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Sorting functions
+//------------------------------------------------------------------------------
+
+// c_sort()
+//
+// Container-based version of the <algorithm> `std::sort()` function
+// to sort elements in ascending order of their values.
+template <typename C>
+void c_sort(C& c) {
+  std::sort(container_algorithm_internal::c_begin(c),
+            container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_sort() for performing a `comp` comparison other than the
+// default `operator<`.
+template <typename C, typename LessThan>
+void c_sort(C& c, LessThan&& comp) {
+  std::sort(container_algorithm_internal::c_begin(c),
+            container_algorithm_internal::c_end(c),
+            std::forward<LessThan>(comp));
+}
+
+// c_stable_sort()
+//
+// Container-based version of the <algorithm> `std::stable_sort()` function
+// to sort elements in ascending order of their values, preserving the order
+// of equivalents.
+template <typename C>
+void c_stable_sort(C& c) {
+  std::stable_sort(container_algorithm_internal::c_begin(c),
+                   container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_stable_sort() for performing a `comp` comparison other than the
+// default `operator<`.
+template <typename C, typename LessThan>
+void c_stable_sort(C& c, LessThan&& comp) {
+  std::stable_sort(container_algorithm_internal::c_begin(c),
+                   container_algorithm_internal::c_end(c),
+                   std::forward<LessThan>(comp));
+}
+
+// c_is_sorted()
+//
+// Container-based version of the <algorithm> `std::is_sorted()` function
+// to evaluate whether the given container is sorted in ascending order.
+template <typename C>
+bool c_is_sorted(const C& c) {
+  return std::is_sorted(container_algorithm_internal::c_begin(c),
+                        container_algorithm_internal::c_end(c));
+}
+
+// c_is_sorted() overload for performing a `comp` comparison other than the
+// default `operator<`.
+template <typename C, typename LessThan>
+bool c_is_sorted(const C& c, LessThan&& comp) {
+  return std::is_sorted(container_algorithm_internal::c_begin(c),
+                        container_algorithm_internal::c_end(c),
+                        std::forward<LessThan>(comp));
+}
+
+// c_partial_sort()
+//
+// Container-based version of the <algorithm> `std::partial_sort()` function
+// to rearrange elements within a container such that elements before `middle`
+// are sorted in ascending order.
+template <typename RandomAccessContainer>
+void c_partial_sort(
+    RandomAccessContainer& sequence,
+    container_algorithm_internal::ContainerIter<RandomAccessContainer> middle) {
+  std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
+                    container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_partial_sort() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename RandomAccessContainer, typename LessThan>
+void c_partial_sort(
+    RandomAccessContainer& sequence,
+    container_algorithm_internal::ContainerIter<RandomAccessContainer> middle,
+    LessThan&& comp) {
+  std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
+                    container_algorithm_internal::c_end(sequence),
+                    std::forward<LessThan>(comp));
+}
+
+// c_partial_sort_copy()
+//
+// Container-based version of the <algorithm> `std::partial_sort_copy()`
+// function to sort the elements in the given range `result` within the larger
+// `sequence` in ascending order (and using `result` as the output parameter).
+// At most min(result.last - result.first, sequence.last - sequence.first)
+// elements from the sequence will be stored in the result.
+template <typename C, typename RandomAccessContainer>
+container_algorithm_internal::ContainerIter<RandomAccessContainer>
+c_partial_sort_copy(const C& sequence, RandomAccessContainer& result) {
+  return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
+                                container_algorithm_internal::c_end(sequence),
+                                container_algorithm_internal::c_begin(result),
+                                container_algorithm_internal::c_end(result));
+}
+
+// Overload of c_partial_sort_copy() for performing a `comp` comparison other
+// than the default `operator<`.
+template <typename C, typename RandomAccessContainer, typename LessThan>
+container_algorithm_internal::ContainerIter<RandomAccessContainer>
+c_partial_sort_copy(const C& sequence, RandomAccessContainer& result,
+                    LessThan&& comp) {
+  return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
+                                container_algorithm_internal::c_end(sequence),
+                                container_algorithm_internal::c_begin(result),
+                                container_algorithm_internal::c_end(result),
+                                std::forward<LessThan>(comp));
+}
+
+// c_is_sorted_until()
+//
+// Container-based version of the <algorithm> `std::is_sorted_until()` function
+// to return the first element within a container that is not sorted in
+// ascending order as an iterator.
+template <typename C>
+container_algorithm_internal::ContainerIter<C> c_is_sorted_until(C& c) {
+  return std::is_sorted_until(container_algorithm_internal::c_begin(c),
+                              container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_is_sorted_until() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename C, typename LessThan>
+container_algorithm_internal::ContainerIter<C> c_is_sorted_until(
+    C& c, LessThan&& comp) {
+  return std::is_sorted_until(container_algorithm_internal::c_begin(c),
+                              container_algorithm_internal::c_end(c),
+                              std::forward<LessThan>(comp));
+}
+
+// c_nth_element()
+//
+// Container-based version of the <algorithm> `std::nth_element()` function
+// to rearrange the elements within a container such that the `nth` element
+// would be in that position in an ordered sequence; other elements may be in
+// any order, except that all preceding `nth` will be less than that element,
+// and all following `nth` will be greater than that element.
+template <typename RandomAccessContainer>
+void c_nth_element(
+    RandomAccessContainer& sequence,
+    container_algorithm_internal::ContainerIter<RandomAccessContainer> nth) {
+  std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
+                   container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_nth_element() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename RandomAccessContainer, typename LessThan>
+void c_nth_element(
+    RandomAccessContainer& sequence,
+    container_algorithm_internal::ContainerIter<RandomAccessContainer> nth,
+    LessThan&& comp) {
+  std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
+                   container_algorithm_internal::c_end(sequence),
+                   std::forward<LessThan>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Binary Search
+//------------------------------------------------------------------------------
+
+// c_lower_bound()
+//
+// Container-based version of the <algorithm> `std::lower_bound()` function
+// to return an iterator pointing to the first element in a sorted container
+// which does not compare less than `value`.
+template <typename Sequence, typename T>
+container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
+    Sequence& sequence, T&& value) {
+  return std::lower_bound(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence),
+                          std::forward<T>(value));
+}
+
+// Overload of c_lower_bound() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename Sequence, typename T, typename LessThan>
+container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
+    Sequence& sequence, T&& value, LessThan&& comp) {
+  return std::lower_bound(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence),
+                          std::forward<T>(value), std::forward<LessThan>(comp));
+}
+
+// c_upper_bound()
+//
+// Container-based version of the <algorithm> `std::upper_bound()` function
+// to return an iterator pointing to the first element in a sorted container
+// which is greater than `value`.
+template <typename Sequence, typename T>
+container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
+    Sequence& sequence, T&& value) {
+  return std::upper_bound(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence),
+                          std::forward<T>(value));
+}
+
+// Overload of c_upper_bound() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename Sequence, typename T, typename LessThan>
+container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
+    Sequence& sequence, T&& value, LessThan&& comp) {
+  return std::upper_bound(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence),
+                          std::forward<T>(value), std::forward<LessThan>(comp));
+}
+
+// c_equal_range()
+//
+// Container-based version of the <algorithm> `std::equal_range()` function
+// to return an iterator pair pointing to the first and last elements in a
+// sorted container which compare equal to `value`.
+template <typename Sequence, typename T>
+container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
+c_equal_range(Sequence& sequence, T&& value) {
+  return std::equal_range(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence),
+                          std::forward<T>(value));
+}
+
+// Overload of c_equal_range() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename Sequence, typename T, typename LessThan>
+container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
+c_equal_range(Sequence& sequence, T&& value, LessThan&& comp) {
+  return std::equal_range(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence),
+                          std::forward<T>(value), std::forward<LessThan>(comp));
+}
+
+// c_binary_search()
+//
+// Container-based version of the <algorithm> `std::binary_search()` function
+// to test if any element in the sorted container contains a value equivalent to
+// 'value'.
+template <typename Sequence, typename T>
+bool c_binary_search(Sequence&& sequence, T&& value) {
+  return std::binary_search(container_algorithm_internal::c_begin(sequence),
+                            container_algorithm_internal::c_end(sequence),
+                            std::forward<T>(value));
+}
+
+// Overload of c_binary_search() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename Sequence, typename T, typename LessThan>
+bool c_binary_search(Sequence&& sequence, T&& value, LessThan&& comp) {
+  return std::binary_search(container_algorithm_internal::c_begin(sequence),
+                            container_algorithm_internal::c_end(sequence),
+                            std::forward<T>(value),
+                            std::forward<LessThan>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Merge functions
+//------------------------------------------------------------------------------
+
+// c_merge()
+//
+// Container-based version of the <algorithm> `std::merge()` function
+// to merge two sorted containers into a single sorted iterator.
+template <typename C1, typename C2, typename OutputIterator>
+OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result) {
+  return std::merge(container_algorithm_internal::c_begin(c1),
+                    container_algorithm_internal::c_end(c1),
+                    container_algorithm_internal::c_begin(c2),
+                    container_algorithm_internal::c_end(c2), result);
+}
+
+// Overload of c_merge() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename LessThan>
+OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result,
+                       LessThan&& comp) {
+  return std::merge(container_algorithm_internal::c_begin(c1),
+                    container_algorithm_internal::c_end(c1),
+                    container_algorithm_internal::c_begin(c2),
+                    container_algorithm_internal::c_end(c2), result,
+                    std::forward<LessThan>(comp));
+}
+
+// c_inplace_merge()
+//
+// Container-based version of the <algorithm> `std::inplace_merge()` function
+// to merge a supplied iterator `middle` into a container.
+template <typename C>
+void c_inplace_merge(C& c,
+                     container_algorithm_internal::ContainerIter<C> middle) {
+  std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
+                     container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_inplace_merge() for performing a merge using a `comp` other
+// than `operator<`.
+template <typename C, typename LessThan>
+void c_inplace_merge(C& c,
+                     container_algorithm_internal::ContainerIter<C> middle,
+                     LessThan&& comp) {
+  std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
+                     container_algorithm_internal::c_end(c),
+                     std::forward<LessThan>(comp));
+}
+
+// c_includes()
+//
+// Container-based version of the <algorithm> `std::includes()` function
+// to test whether a sorted container `c1` entirely contains another sorted
+// container `c2`.
+template <typename C1, typename C2>
+bool c_includes(const C1& c1, const C2& c2) {
+  return std::includes(container_algorithm_internal::c_begin(c1),
+                       container_algorithm_internal::c_end(c1),
+                       container_algorithm_internal::c_begin(c2),
+                       container_algorithm_internal::c_end(c2));
+}
+
+// Overload of c_includes() for performing a merge using a `comp` other than
+// `operator<`.
+template <typename C1, typename C2, typename LessThan>
+bool c_includes(const C1& c1, const C2& c2, LessThan&& comp) {
+  return std::includes(container_algorithm_internal::c_begin(c1),
+                       container_algorithm_internal::c_end(c1),
+                       container_algorithm_internal::c_begin(c2),
+                       container_algorithm_internal::c_end(c2),
+                       std::forward<LessThan>(comp));
+}
+
+// c_set_union()
+//
+// Container-based version of the <algorithm> `std::set_union()` function
+// to return an iterator containing the union of two containers; duplicate
+// values are not copied into the output.
+template <typename C1, typename C2, typename OutputIterator,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
+              void>::type,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
+              void>::type>
+OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output) {
+  return std::set_union(container_algorithm_internal::c_begin(c1),
+                        container_algorithm_internal::c_end(c1),
+                        container_algorithm_internal::c_begin(c2),
+                        container_algorithm_internal::c_end(c2), output);
+}
+
+// Overload of c_set_union() for performing a merge using a `comp` other than
+// `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename LessThan,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
+              void>::type,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
+              void>::type>
+OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output,
+                           LessThan&& comp) {
+  return std::set_union(container_algorithm_internal::c_begin(c1),
+                        container_algorithm_internal::c_end(c1),
+                        container_algorithm_internal::c_begin(c2),
+                        container_algorithm_internal::c_end(c2), output,
+                        std::forward<LessThan>(comp));
+}
+
+// c_set_intersection()
+//
+// Container-based version of the <algorithm> `std::set_intersection()` function
+// to return an iterator containing the intersection of two sorted containers.
+template <typename C1, typename C2, typename OutputIterator,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
+              void>::type,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
+              void>::type>
+OutputIterator c_set_intersection(const C1& c1, const C2& c2,
+                                  OutputIterator output) {
+  // In debug builds, ensure that both containers are sorted with respect to the
+  // default comparator. std::set_intersection requires the containers be sorted
+  // using operator<.
+  assert(absl::c_is_sorted(c1));
+  assert(absl::c_is_sorted(c2));
+  return std::set_intersection(container_algorithm_internal::c_begin(c1),
+                               container_algorithm_internal::c_end(c1),
+                               container_algorithm_internal::c_begin(c2),
+                               container_algorithm_internal::c_end(c2), output);
+}
+
+// Overload of c_set_intersection() for performing a merge using a `comp` other
+// than `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename LessThan,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
+              void>::type,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
+              void>::type>
+OutputIterator c_set_intersection(const C1& c1, const C2& c2,
+                                  OutputIterator output, LessThan&& comp) {
+  // In debug builds, ensure that both containers are sorted with respect to the
+  // default comparator. std::set_intersection requires the containers be sorted
+  // using the same comparator.
+  assert(absl::c_is_sorted(c1, comp));
+  assert(absl::c_is_sorted(c2, comp));
+  return std::set_intersection(container_algorithm_internal::c_begin(c1),
+                               container_algorithm_internal::c_end(c1),
+                               container_algorithm_internal::c_begin(c2),
+                               container_algorithm_internal::c_end(c2), output,
+                               std::forward<LessThan>(comp));
+}
+
+// c_set_difference()
+//
+// Container-based version of the <algorithm> `std::set_difference()` function
+// to return an iterator containing elements present in the first container but
+// not in the second.
+template <typename C1, typename C2, typename OutputIterator,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
+              void>::type,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
+              void>::type>
+OutputIterator c_set_difference(const C1& c1, const C2& c2,
+                                OutputIterator output) {
+  return std::set_difference(container_algorithm_internal::c_begin(c1),
+                             container_algorithm_internal::c_end(c1),
+                             container_algorithm_internal::c_begin(c2),
+                             container_algorithm_internal::c_end(c2), output);
+}
+
+// Overload of c_set_difference() for performing a merge using a `comp` other
+// than `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename LessThan,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
+              void>::type,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
+              void>::type>
+OutputIterator c_set_difference(const C1& c1, const C2& c2,
+                                OutputIterator output, LessThan&& comp) {
+  return std::set_difference(container_algorithm_internal::c_begin(c1),
+                             container_algorithm_internal::c_end(c1),
+                             container_algorithm_internal::c_begin(c2),
+                             container_algorithm_internal::c_end(c2), output,
+                             std::forward<LessThan>(comp));
+}
+
+// c_set_symmetric_difference()
+//
+// Container-based version of the <algorithm> `std::set_symmetric_difference()`
+// function to return an iterator containing elements present in either one
+// container or the other, but not both.
+template <typename C1, typename C2, typename OutputIterator,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
+              void>::type,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
+              void>::type>
+OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2,
+                                          OutputIterator output) {
+  return std::set_symmetric_difference(
+      container_algorithm_internal::c_begin(c1),
+      container_algorithm_internal::c_end(c1),
+      container_algorithm_internal::c_begin(c2),
+      container_algorithm_internal::c_end(c2), output);
+}
+
+// Overload of c_set_symmetric_difference() for performing a merge using a
+// `comp` other than `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename LessThan,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
+              void>::type,
+          typename = typename std::enable_if<
+              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
+              void>::type>
+OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2,
+                                          OutputIterator output,
+                                          LessThan&& comp) {
+  return std::set_symmetric_difference(
+      container_algorithm_internal::c_begin(c1),
+      container_algorithm_internal::c_end(c1),
+      container_algorithm_internal::c_begin(c2),
+      container_algorithm_internal::c_end(c2), output,
+      std::forward<LessThan>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Heap functions
+//------------------------------------------------------------------------------
+
+// c_push_heap()
+//
+// Container-based version of the <algorithm> `std::push_heap()` function
+// to push a value onto a container heap.
+template <typename RandomAccessContainer>
+void c_push_heap(RandomAccessContainer& sequence) {
+  std::push_heap(container_algorithm_internal::c_begin(sequence),
+                 container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_push_heap() for performing a push operation on a heap using a
+// `comp` other than `operator<`.
+template <typename RandomAccessContainer, typename LessThan>
+void c_push_heap(RandomAccessContainer& sequence, LessThan&& comp) {
+  std::push_heap(container_algorithm_internal::c_begin(sequence),
+                 container_algorithm_internal::c_end(sequence),
+                 std::forward<LessThan>(comp));
+}
+
+// c_pop_heap()
+//
+// Container-based version of the <algorithm> `std::pop_heap()` function
+// to pop a value from a heap container.
+template <typename RandomAccessContainer>
+void c_pop_heap(RandomAccessContainer& sequence) {
+  std::pop_heap(container_algorithm_internal::c_begin(sequence),
+                container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_pop_heap() for performing a pop operation on a heap using a
+// `comp` other than `operator<`.
+template <typename RandomAccessContainer, typename LessThan>
+void c_pop_heap(RandomAccessContainer& sequence, LessThan&& comp) {
+  std::pop_heap(container_algorithm_internal::c_begin(sequence),
+                container_algorithm_internal::c_end(sequence),
+                std::forward<LessThan>(comp));
+}
+
+// c_make_heap()
+//
+// Container-based version of the <algorithm> `std::make_heap()` function
+// to make a container a heap.
+template <typename RandomAccessContainer>
+void c_make_heap(RandomAccessContainer& sequence) {
+  std::make_heap(container_algorithm_internal::c_begin(sequence),
+                 container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_make_heap() for performing heap comparisons using a
+// `comp` other than `operator<`
+template <typename RandomAccessContainer, typename LessThan>
+void c_make_heap(RandomAccessContainer& sequence, LessThan&& comp) {
+  std::make_heap(container_algorithm_internal::c_begin(sequence),
+                 container_algorithm_internal::c_end(sequence),
+                 std::forward<LessThan>(comp));
+}
+
+// c_sort_heap()
+//
+// Container-based version of the <algorithm> `std::sort_heap()` function
+// to sort a heap into ascending order (after which it is no longer a heap).
+template <typename RandomAccessContainer>
+void c_sort_heap(RandomAccessContainer& sequence) {
+  std::sort_heap(container_algorithm_internal::c_begin(sequence),
+                 container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_sort_heap() for performing heap comparisons using a
+// `comp` other than `operator<`
+template <typename RandomAccessContainer, typename LessThan>
+void c_sort_heap(RandomAccessContainer& sequence, LessThan&& comp) {
+  std::sort_heap(container_algorithm_internal::c_begin(sequence),
+                 container_algorithm_internal::c_end(sequence),
+                 std::forward<LessThan>(comp));
+}
+
+// c_is_heap()
+//
+// Container-based version of the <algorithm> `std::is_heap()` function
+// to check whether the given container is a heap.
+template <typename RandomAccessContainer>
+bool c_is_heap(const RandomAccessContainer& sequence) {
+  return std::is_heap(container_algorithm_internal::c_begin(sequence),
+                      container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_is_heap() for performing heap comparisons using a
+// `comp` other than `operator<`
+template <typename RandomAccessContainer, typename LessThan>
+bool c_is_heap(const RandomAccessContainer& sequence, LessThan&& comp) {
+  return std::is_heap(container_algorithm_internal::c_begin(sequence),
+                      container_algorithm_internal::c_end(sequence),
+                      std::forward<LessThan>(comp));
+}
+
+// c_is_heap_until()
+//
+// Container-based version of the <algorithm> `std::is_heap_until()` function
+// to find the first element in a given container which is not in heap order.
+template <typename RandomAccessContainer>
+container_algorithm_internal::ContainerIter<RandomAccessContainer>
+c_is_heap_until(RandomAccessContainer& sequence) {
+  return std::is_heap_until(container_algorithm_internal::c_begin(sequence),
+                            container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_is_heap_until() for performing heap comparisons using a
+// `comp` other than `operator<`
+template <typename RandomAccessContainer, typename LessThan>
+container_algorithm_internal::ContainerIter<RandomAccessContainer>
+c_is_heap_until(RandomAccessContainer& sequence, LessThan&& comp) {
+  return std::is_heap_until(container_algorithm_internal::c_begin(sequence),
+                            container_algorithm_internal::c_end(sequence),
+                            std::forward<LessThan>(comp));
+}
+
+//------------------------------------------------------------------------------
+//  <algorithm> Min/max
+//------------------------------------------------------------------------------
+
+// c_min_element()
+//
+// Container-based version of the <algorithm> `std::min_element()` function
+// to return an iterator pointing to the element with the smallest value, using
+// `operator<` to make the comparisons.
+template <typename Sequence>
+container_algorithm_internal::ContainerIter<Sequence> c_min_element(
+    Sequence& sequence) {
+  return std::min_element(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_min_element() for performing a `comp` comparison other than
+// `operator<`.
+template <typename Sequence, typename LessThan>
+container_algorithm_internal::ContainerIter<Sequence> c_min_element(
+    Sequence& sequence, LessThan&& comp) {
+  return std::min_element(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence),
+                          std::forward<LessThan>(comp));
+}
+
+// c_max_element()
+//
+// Container-based version of the <algorithm> `std::max_element()` function
+// to return an iterator pointing to the element with the largest value, using
+// `operator<` to make the comparisons.
+template <typename Sequence>
+container_algorithm_internal::ContainerIter<Sequence> c_max_element(
+    Sequence& sequence) {
+  return std::max_element(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_max_element() for performing a `comp` comparison other than
+// `operator<`.
+template <typename Sequence, typename LessThan>
+container_algorithm_internal::ContainerIter<Sequence> c_max_element(
+    Sequence& sequence, LessThan&& comp) {
+  return std::max_element(container_algorithm_internal::c_begin(sequence),
+                          container_algorithm_internal::c_end(sequence),
+                          std::forward<LessThan>(comp));
+}
+
+// c_minmax_element()
+//
+// Container-based version of the <algorithm> `std::minmax_element()` function
+// to return a pair of iterators pointing to the elements containing the
+// smallest and largest values, respectively, using `operator<` to make the
+// comparisons.
+template <typename C>
+container_algorithm_internal::ContainerIterPairType<C, C>
+c_minmax_element(C& c) {
+  return std::minmax_element(container_algorithm_internal::c_begin(c),
+                             container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_minmax_element() for performing `comp` comparisons other than
+// `operator<`.
+template <typename C, typename LessThan>
+container_algorithm_internal::ContainerIterPairType<C, C>
+c_minmax_element(C& c, LessThan&& comp) {
+  return std::minmax_element(container_algorithm_internal::c_begin(c),
+                             container_algorithm_internal::c_end(c),
+                             std::forward<LessThan>(comp));
+}
+
+//------------------------------------------------------------------------------
+//  <algorithm> Lexicographical Comparisons
+//------------------------------------------------------------------------------
+
+// c_lexicographical_compare()
+//
+// Container-based version of the <algorithm> `std::lexicographical_compare()`
+// function to lexicographically compare (e.g. sort words alphabetically) two
+// container sequences. The comparison is performed using `operator<`. Note
+// that capital letters ("A-Z") have ASCII values less than lowercase letters
+// ("a-z").
+template <typename Sequence1, typename Sequence2>
+bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2) {
+  return std::lexicographical_compare(
+      container_algorithm_internal::c_begin(sequence1),
+      container_algorithm_internal::c_end(sequence1),
+      container_algorithm_internal::c_begin(sequence2),
+      container_algorithm_internal::c_end(sequence2));
+}
+
+// Overload of c_lexicographical_compare() for performing a lexicographical
+// comparison using a `comp` operator instead of `operator<`.
+template <typename Sequence1, typename Sequence2, typename LessThan>
+bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2,
+                               LessThan&& comp) {
+  return std::lexicographical_compare(
+      container_algorithm_internal::c_begin(sequence1),
+      container_algorithm_internal::c_end(sequence1),
+      container_algorithm_internal::c_begin(sequence2),
+      container_algorithm_internal::c_end(sequence2),
+      std::forward<LessThan>(comp));
+}
+
+// c_next_permutation()
+//
+// Container-based version of the <algorithm> `std::next_permutation()` function
+// to rearrange a container's elements into the next lexicographically greater
+// permutation.
+template <typename C>
+bool c_next_permutation(C& c) {
+  return std::next_permutation(container_algorithm_internal::c_begin(c),
+                               container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_next_permutation() for performing a lexicographical
+// comparison using a `comp` operator instead of `operator<`.
+template <typename C, typename LessThan>
+bool c_next_permutation(C& c, LessThan&& comp) {
+  return std::next_permutation(container_algorithm_internal::c_begin(c),
+                               container_algorithm_internal::c_end(c),
+                               std::forward<LessThan>(comp));
+}
+
+// c_prev_permutation()
+//
+// Container-based version of the <algorithm> `std::prev_permutation()` function
+// to rearrange a container's elements into the next lexicographically lesser
+// permutation.
+template <typename C>
+bool c_prev_permutation(C& c) {
+  return std::prev_permutation(container_algorithm_internal::c_begin(c),
+                               container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_prev_permutation() for performing a lexicographical
+// comparison using a `comp` operator instead of `operator<`.
+template <typename C, typename LessThan>
+bool c_prev_permutation(C& c, LessThan&& comp) {
+  return std::prev_permutation(container_algorithm_internal::c_begin(c),
+                               container_algorithm_internal::c_end(c),
+                               std::forward<LessThan>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <numeric> algorithms
+//------------------------------------------------------------------------------
+
+// c_iota()
+//
+// Container-based version of the <algorithm> `std::iota()` function
+// to compute successive values of `value`, as if incremented with `++value`
+// after each element is written. and write them to the container.
+template <typename Sequence, typename T>
+void c_iota(Sequence& sequence, T&& value) {
+  std::iota(container_algorithm_internal::c_begin(sequence),
+            container_algorithm_internal::c_end(sequence),
+            std::forward<T>(value));
+}
+// c_accumulate()
+//
+// Container-based version of the <algorithm> `std::accumulate()` function
+// to accumulate the element values of a container to `init` and return that
+// accumulation by value.
+//
+// Note: Due to a language technicality this function has return type
+// absl::decay_t<T>. As a user of this function you can casually read
+// this as "returns T by value" and assume it does the right thing.
+template <typename Sequence, typename T>
+decay_t<T> c_accumulate(const Sequence& sequence, T&& init) {
+  return std::accumulate(container_algorithm_internal::c_begin(sequence),
+                         container_algorithm_internal::c_end(sequence),
+                         std::forward<T>(init));
+}
+
+// Overload of c_accumulate() for using a binary operations other than
+// addition for computing the accumulation.
+template <typename Sequence, typename T, typename BinaryOp>
+decay_t<T> c_accumulate(const Sequence& sequence, T&& init,
+                        BinaryOp&& binary_op) {
+  return std::accumulate(container_algorithm_internal::c_begin(sequence),
+                         container_algorithm_internal::c_end(sequence),
+                         std::forward<T>(init),
+                         std::forward<BinaryOp>(binary_op));
+}
+
+// c_inner_product()
+//
+// Container-based version of the <algorithm> `std::inner_product()` function
+// to compute the cumulative inner product of container element pairs.
+//
+// Note: Due to a language technicality this function has return type
+// absl::decay_t<T>. As a user of this function you can casually read
+// this as "returns T by value" and assume it does the right thing.
+template <typename Sequence1, typename Sequence2, typename T>
+decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2,
+                           T&& sum) {
+  return std::inner_product(container_algorithm_internal::c_begin(factors1),
+                            container_algorithm_internal::c_end(factors1),
+                            container_algorithm_internal::c_begin(factors2),
+                            std::forward<T>(sum));
+}
+
+// Overload of c_inner_product() for using binary operations other than
+// `operator+` (for computing the accumulation) and `operator*` (for computing
+// the product between the two container's element pair).
+template <typename Sequence1, typename Sequence2, typename T,
+          typename BinaryOp1, typename BinaryOp2>
+decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2,
+                           T&& sum, BinaryOp1&& op1, BinaryOp2&& op2) {
+  return std::inner_product(container_algorithm_internal::c_begin(factors1),
+                            container_algorithm_internal::c_end(factors1),
+                            container_algorithm_internal::c_begin(factors2),
+                            std::forward<T>(sum), std::forward<BinaryOp1>(op1),
+                            std::forward<BinaryOp2>(op2));
+}
+
+// c_adjacent_difference()
+//
+// Container-based version of the <algorithm> `std::adjacent_difference()`
+// function to compute the difference between each element and the one preceding
+// it and write it to an iterator.
+template <typename InputSequence, typename OutputIt>
+OutputIt c_adjacent_difference(const InputSequence& input,
+                               OutputIt output_first) {
+  return std::adjacent_difference(container_algorithm_internal::c_begin(input),
+                                  container_algorithm_internal::c_end(input),
+                                  output_first);
+}
+
+// Overload of c_adjacent_difference() for using a binary operation other than
+// subtraction to compute the adjacent difference.
+template <typename InputSequence, typename OutputIt, typename BinaryOp>
+OutputIt c_adjacent_difference(const InputSequence& input,
+                               OutputIt output_first, BinaryOp&& op) {
+  return std::adjacent_difference(container_algorithm_internal::c_begin(input),
+                                  container_algorithm_internal::c_end(input),
+                                  output_first, std::forward<BinaryOp>(op));
+}
+
+// c_partial_sum()
+//
+// Container-based version of the <algorithm> `std::partial_sum()` function
+// to compute the partial sum of the elements in a sequence and write them
+// to an iterator. The partial sum is the sum of all element values so far in
+// the sequence.
+template <typename InputSequence, typename OutputIt>
+OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first) {
+  return std::partial_sum(container_algorithm_internal::c_begin(input),
+                          container_algorithm_internal::c_end(input),
+                          output_first);
+}
+
+// Overload of c_partial_sum() for using a binary operation other than addition
+// to compute the "partial sum".
+template <typename InputSequence, typename OutputIt, typename BinaryOp>
+OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first,
+                       BinaryOp&& op) {
+  return std::partial_sum(container_algorithm_internal::c_begin(input),
+                          container_algorithm_internal::c_end(input),
+                          output_first, std::forward<BinaryOp>(op));
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_ALGORITHM_CONTAINER_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/attributes.h b/CAPI/cpp/grpc/include/absl/base/attributes.h
new file mode 100644
index 0000000..e4e7a3d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/attributes.h
@@ -0,0 +1,762 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This header file defines macros for declaring attributes for functions,
+// types, and variables.
+//
+// These macros are used within Abseil and allow the compiler to optimize, where
+// applicable, certain function calls.
+//
+// Most macros here are exposing GCC or Clang features, and are stubbed out for
+// other compilers.
+//
+// GCC attributes documentation:
+//   https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html
+//   https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Variable-Attributes.html
+//   https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Type-Attributes.html
+//
+// Most attributes in this file are already supported by GCC 4.7. However, some
+// of them are not supported in older version of Clang. Thus, we check
+// `__has_attribute()` first. If the check fails, we check if we are on GCC and
+// assume the attribute exists on GCC (which is verified on GCC 4.7).
+
+#ifndef ABSL_BASE_ATTRIBUTES_H_
+#define ABSL_BASE_ATTRIBUTES_H_
+
+#include "absl/base/config.h"
+
+// ABSL_HAVE_ATTRIBUTE
+//
+// A function-like feature checking macro that is a wrapper around
+// `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
+// nonzero constant integer if the attribute is supported or 0 if not.
+//
+// It evaluates to zero if `__has_attribute` is not defined by the compiler.
+//
+// GCC: https://gcc.gnu.org/gcc-5/changes.html
+// Clang: https://clang.llvm.org/docs/LanguageExtensions.html
+#ifdef __has_attribute
+#define ABSL_HAVE_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define ABSL_HAVE_ATTRIBUTE(x) 0
+#endif
+
+// ABSL_HAVE_CPP_ATTRIBUTE
+//
+// A function-like feature checking macro that accepts C++11 style attributes.
+// It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
+// (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
+// find `__has_cpp_attribute`, will evaluate to 0.
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+// NOTE: requiring __cplusplus above should not be necessary, but
+// works around https://bugs.llvm.org/show_bug.cgi?id=23435.
+#define ABSL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+#define ABSL_HAVE_CPP_ATTRIBUTE(x) 0
+#endif
+
+// -----------------------------------------------------------------------------
+// Function Attributes
+// -----------------------------------------------------------------------------
+//
+// GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
+// Clang: https://clang.llvm.org/docs/AttributeReference.html
+
+// ABSL_PRINTF_ATTRIBUTE
+// ABSL_SCANF_ATTRIBUTE
+//
+// Tells the compiler to perform `printf` format string checking if the
+// compiler supports it; see the 'format' attribute in
+// <https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html>.
+//
+// Note: As the GCC manual states, "[s]ince non-static C++ methods
+// have an implicit 'this' argument, the arguments of such methods
+// should be counted from two, not one."
+#if ABSL_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check) \
+  __attribute__((__format__(__printf__, string_index, first_to_check)))
+#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check) \
+  __attribute__((__format__(__scanf__, string_index, first_to_check)))
+#else
+#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check)
+#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check)
+#endif
+
+// ABSL_ATTRIBUTE_ALWAYS_INLINE
+// ABSL_ATTRIBUTE_NOINLINE
+//
+// Forces functions to either inline or not inline. Introduced in gcc 3.1.
+#if ABSL_HAVE_ATTRIBUTE(always_inline) || \
+    (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
+#define ABSL_HAVE_ATTRIBUTE_ALWAYS_INLINE 1
+#else
+#define ABSL_ATTRIBUTE_ALWAYS_INLINE
+#endif
+
+#if ABSL_HAVE_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_NOINLINE __attribute__((noinline))
+#define ABSL_HAVE_ATTRIBUTE_NOINLINE 1
+#else
+#define ABSL_ATTRIBUTE_NOINLINE
+#endif
+
+// ABSL_ATTRIBUTE_NO_TAIL_CALL
+//
+// Prevents the compiler from optimizing away stack frames for functions which
+// end in a call to another function.
+#if ABSL_HAVE_ATTRIBUTE(disable_tail_calls)
+#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+#define ABSL_ATTRIBUTE_NO_TAIL_CALL __attribute__((disable_tail_calls))
+#elif defined(__GNUC__) && !defined(__clang__) && !defined(__e2k__)
+#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+#define ABSL_ATTRIBUTE_NO_TAIL_CALL \
+  __attribute__((optimize("no-optimize-sibling-calls")))
+#else
+#define ABSL_ATTRIBUTE_NO_TAIL_CALL
+#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 0
+#endif
+
+// ABSL_ATTRIBUTE_WEAK
+//
+// Tags a function as weak for the purposes of compilation and linking.
+// Weak attributes did not work properly in LLVM's Windows backend before
+// 9.0.0, so disable them there. See https://bugs.llvm.org/show_bug.cgi?id=37598
+// for further information.
+// The MinGW compiler doesn't complain about the weak attribute until the link
+// step, presumably because Windows doesn't use ELF binaries.
+#if (ABSL_HAVE_ATTRIBUTE(weak) ||                                         \
+     (defined(__GNUC__) && !defined(__clang__))) &&                       \
+    (!defined(_WIN32) || (defined(__clang__) && __clang_major__ >= 9)) && \
+    !defined(__MINGW32__)
+#undef ABSL_ATTRIBUTE_WEAK
+#define ABSL_ATTRIBUTE_WEAK __attribute__((weak))
+#define ABSL_HAVE_ATTRIBUTE_WEAK 1
+#else
+#define ABSL_ATTRIBUTE_WEAK
+#define ABSL_HAVE_ATTRIBUTE_WEAK 0
+#endif
+
+// ABSL_ATTRIBUTE_NONNULL
+//
+// Tells the compiler either (a) that a particular function parameter
+// should be a non-null pointer, or (b) that all pointer arguments should
+// be non-null.
+//
+// Note: As the GCC manual states, "[s]ince non-static C++ methods
+// have an implicit 'this' argument, the arguments of such methods
+// should be counted from two, not one."
+//
+// Args are indexed starting at 1.
+//
+// For non-static class member functions, the implicit `this` argument
+// is arg 1, and the first explicit argument is arg 2. For static class member
+// functions, there is no implicit `this`, and the first explicit argument is
+// arg 1.
+//
+// Example:
+//
+//   /* arg_a cannot be null, but arg_b can */
+//   void Function(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(1);
+//
+//   class C {
+//     /* arg_a cannot be null, but arg_b can */
+//     void Method(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(2);
+//
+//     /* arg_a cannot be null, but arg_b can */
+//     static void StaticMethod(void* arg_a, void* arg_b)
+//     ABSL_ATTRIBUTE_NONNULL(1);
+//   };
+//
+// If no arguments are provided, then all pointer arguments should be non-null.
+//
+//  /* No pointer arguments may be null. */
+//  void Function(void* arg_a, void* arg_b, int arg_c) ABSL_ATTRIBUTE_NONNULL();
+//
+// NOTE: The GCC nonnull attribute actually accepts a list of arguments, but
+// ABSL_ATTRIBUTE_NONNULL does not.
+#if ABSL_HAVE_ATTRIBUTE(nonnull) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_NONNULL(arg_index) __attribute__((nonnull(arg_index)))
+#else
+#define ABSL_ATTRIBUTE_NONNULL(...)
+#endif
+
+// ABSL_ATTRIBUTE_NORETURN
+//
+// Tells the compiler that a given function never returns.
+#if ABSL_HAVE_ATTRIBUTE(noreturn) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#elif defined(_MSC_VER)
+#define ABSL_ATTRIBUTE_NORETURN __declspec(noreturn)
+#else
+#define ABSL_ATTRIBUTE_NORETURN
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
+//
+// Tells the AddressSanitizer (or other memory testing tools) to ignore a given
+// function. Useful for cases when a function reads random locations on stack,
+// calls _exit from a cloned subprocess, deliberately accesses buffer
+// out of bounds or does other scary things with memory.
+// NOTE: GCC supports AddressSanitizer(asan) since 4.8.
+// https://gcc.gnu.org/gcc-4.8/changes.html
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize_address)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
+#elif defined(_MSC_VER) && _MSC_VER >= 1928
+// https://docs.microsoft.com/en-us/cpp/cpp/no-sanitize-address
+#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __declspec(no_sanitize_address)
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
+//
+// Tells the MemorySanitizer to relax the handling of a given function. All "Use
+// of uninitialized value" warnings from such functions will be suppressed, and
+// all values loaded from memory will be considered fully initialized.  This
+// attribute is similar to the ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS attribute
+// above, but deals with initialized-ness rather than addressability issues.
+// NOTE: MemorySanitizer(msan) is supported by Clang but not GCC.
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize_memory)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
+//
+// Tells the ThreadSanitizer to not instrument a given function.
+// NOTE: GCC supports ThreadSanitizer(tsan) since 4.8.
+// https://gcc.gnu.org/gcc-4.8/changes.html
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize_thread)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
+//
+// Tells the UndefinedSanitizer to ignore a given function. Useful for cases
+// where certain behavior (eg. division by zero) is being used intentionally.
+// NOTE: GCC supports UndefinedBehaviorSanitizer(ubsan) since 4.9.
+// https://gcc.gnu.org/gcc-4.9/changes.html
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize_undefined)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
+  __attribute__((no_sanitize_undefined))
+#elif ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
+  __attribute__((no_sanitize("undefined")))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_CFI
+//
+// Tells the ControlFlowIntegrity sanitizer to not instrument a given function.
+// See https://clang.llvm.org/docs/ControlFlowIntegrity.html for details.
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize("cfi")))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
+//
+// Tells the SafeStack to not instrument a given function.
+// See https://clang.llvm.org/docs/SafeStack.html for details.
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK \
+  __attribute__((no_sanitize("safe-stack")))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
+#endif
+
+// ABSL_ATTRIBUTE_RETURNS_NONNULL
+//
+// Tells the compiler that a particular function never returns a null pointer.
+#if ABSL_HAVE_ATTRIBUTE(returns_nonnull)
+#define ABSL_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
+#else
+#define ABSL_ATTRIBUTE_RETURNS_NONNULL
+#endif
+
+// ABSL_HAVE_ATTRIBUTE_SECTION
+//
+// Indicates whether labeled sections are supported. Weak symbol support is
+// a prerequisite. Labeled sections are not supported on Darwin/iOS.
+#ifdef ABSL_HAVE_ATTRIBUTE_SECTION
+#error ABSL_HAVE_ATTRIBUTE_SECTION cannot be directly set
+#elif (ABSL_HAVE_ATTRIBUTE(section) ||                \
+       (defined(__GNUC__) && !defined(__clang__))) && \
+    !defined(__APPLE__) && ABSL_HAVE_ATTRIBUTE_WEAK
+#define ABSL_HAVE_ATTRIBUTE_SECTION 1
+
+// ABSL_ATTRIBUTE_SECTION
+//
+// Tells the compiler/linker to put a given function into a section and define
+// `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.
+// This functionality is supported by GNU linker.  Any function annotated with
+// `ABSL_ATTRIBUTE_SECTION` must not be inlined, or it will be placed into
+// whatever section its caller is placed into.
+//
+#ifndef ABSL_ATTRIBUTE_SECTION
+#define ABSL_ATTRIBUTE_SECTION(name) \
+  __attribute__((section(#name))) __attribute__((noinline))
+#endif
+
+// ABSL_ATTRIBUTE_SECTION_VARIABLE
+//
+// Tells the compiler/linker to put a given variable into a section and define
+// `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.
+// This functionality is supported by GNU linker.
+#ifndef ABSL_ATTRIBUTE_SECTION_VARIABLE
+#ifdef _AIX
+// __attribute__((section(#name))) on AIX is achived by using the `.csect` psudo
+// op which includes an additional integer as part of its syntax indcating
+// alignment. If data fall under different alignments then you might get a
+// compilation error indicating a `Section type conflict`.
+#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
+#else
+#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name) __attribute__((section(#name)))
+#endif
+#endif
+
+// ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
+//
+// A weak section declaration to be used as a global declaration
+// for ABSL_ATTRIBUTE_SECTION_START|STOP(name) to compile and link
+// even without functions with ABSL_ATTRIBUTE_SECTION(name).
+// ABSL_DEFINE_ATTRIBUTE_SECTION should be in the exactly one file; it's
+// a no-op on ELF but not on Mach-O.
+//
+#ifndef ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
+#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)   \
+  extern char __start_##name[] ABSL_ATTRIBUTE_WEAK; \
+  extern char __stop_##name[] ABSL_ATTRIBUTE_WEAK
+#endif
+#ifndef ABSL_DEFINE_ATTRIBUTE_SECTION_VARS
+#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
+#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+#endif
+
+// ABSL_ATTRIBUTE_SECTION_START
+//
+// Returns `void*` pointers to start/end of a section of code with
+// functions having ABSL_ATTRIBUTE_SECTION(name).
+// Returns 0 if no such functions exist.
+// One must ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) for this to compile and
+// link.
+//
+#define ABSL_ATTRIBUTE_SECTION_START(name) \
+  (reinterpret_cast<void *>(__start_##name))
+#define ABSL_ATTRIBUTE_SECTION_STOP(name) \
+  (reinterpret_cast<void *>(__stop_##name))
+
+#else  // !ABSL_HAVE_ATTRIBUTE_SECTION
+
+#define ABSL_HAVE_ATTRIBUTE_SECTION 0
+
+// provide dummy definitions
+#define ABSL_ATTRIBUTE_SECTION(name)
+#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
+#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
+#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)
+#define ABSL_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void *>(0))
+#define ABSL_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void *>(0))
+
+#endif  // ABSL_ATTRIBUTE_SECTION
+
+// ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+//
+// Support for aligning the stack on 32-bit x86.
+#if ABSL_HAVE_ATTRIBUTE(force_align_arg_pointer) || \
+    (defined(__GNUC__) && !defined(__clang__))
+#if defined(__i386__)
+#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC \
+  __attribute__((force_align_arg_pointer))
+#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#elif defined(__x86_64__)
+#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)
+#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#else  // !__i386__ && !__x86_64
+#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#endif  // __i386__
+#else
+#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#endif
+
+// ABSL_MUST_USE_RESULT
+//
+// Tells the compiler to warn about unused results.
+//
+// For code or headers that are assured to only build with C++17 and up, prefer
+// just using the standard `[[nodiscard]]` directly over this macro.
+//
+// When annotating a function, it must appear as the first part of the
+// declaration or definition. The compiler will warn if the return value from
+// such a function is unused:
+//
+//   ABSL_MUST_USE_RESULT Sprocket* AllocateSprocket();
+//   AllocateSprocket();  // Triggers a warning.
+//
+// When annotating a class, it is equivalent to annotating every function which
+// returns an instance.
+//
+//   class ABSL_MUST_USE_RESULT Sprocket {};
+//   Sprocket();  // Triggers a warning.
+//
+//   Sprocket MakeSprocket();
+//   MakeSprocket();  // Triggers a warning.
+//
+// Note that references and pointers are not instances:
+//
+//   Sprocket* SprocketPointer();
+//   SprocketPointer();  // Does *not* trigger a warning.
+//
+// ABSL_MUST_USE_RESULT allows using cast-to-void to suppress the unused result
+// warning. For that, warn_unused_result is used only for clang but not for gcc.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425
+//
+// Note: past advice was to place the macro after the argument list.
+//
+// TODO(b/176172494): Use ABSL_HAVE_CPP_ATTRIBUTE(nodiscard) when all code is
+// compliant with the stricter [[nodiscard]].
+#if defined(__clang__) && ABSL_HAVE_ATTRIBUTE(warn_unused_result)
+#define ABSL_MUST_USE_RESULT __attribute__((warn_unused_result))
+#else
+#define ABSL_MUST_USE_RESULT
+#endif
+
+// ABSL_ATTRIBUTE_HOT, ABSL_ATTRIBUTE_COLD
+//
+// Tells GCC that a function is hot or cold. GCC can use this information to
+// improve static analysis, i.e. a conditional branch to a cold function
+// is likely to be not-taken.
+// This annotation is used for function declarations.
+//
+// Example:
+//
+//   int foo() ABSL_ATTRIBUTE_HOT;
+#if ABSL_HAVE_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_HOT __attribute__((hot))
+#else
+#define ABSL_ATTRIBUTE_HOT
+#endif
+
+#if ABSL_HAVE_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_COLD __attribute__((cold))
+#else
+#define ABSL_ATTRIBUTE_COLD
+#endif
+
+// ABSL_XRAY_ALWAYS_INSTRUMENT, ABSL_XRAY_NEVER_INSTRUMENT, ABSL_XRAY_LOG_ARGS
+//
+// We define the ABSL_XRAY_ALWAYS_INSTRUMENT and ABSL_XRAY_NEVER_INSTRUMENT
+// macro used as an attribute to mark functions that must always or never be
+// instrumented by XRay. Currently, this is only supported in Clang/LLVM.
+//
+// For reference on the LLVM XRay instrumentation, see
+// http://llvm.org/docs/XRay.html.
+//
+// A function with the XRAY_ALWAYS_INSTRUMENT macro attribute in its declaration
+// will always get the XRay instrumentation sleds. These sleds may introduce
+// some binary size and runtime overhead and must be used sparingly.
+//
+// These attributes only take effect when the following conditions are met:
+//
+//   * The file/target is built in at least C++11 mode, with a Clang compiler
+//     that supports XRay attributes.
+//   * The file/target is built with the -fxray-instrument flag set for the
+//     Clang/LLVM compiler.
+//   * The function is defined in the translation unit (the compiler honors the
+//     attribute in either the definition or the declaration, and must match).
+//
+// There are cases when, even when building with XRay instrumentation, users
+// might want to control specifically which functions are instrumented for a
+// particular build using special-case lists provided to the compiler. These
+// special case lists are provided to Clang via the
+// -fxray-always-instrument=... and -fxray-never-instrument=... flags. The
+// attributes in source take precedence over these special-case lists.
+//
+// To disable the XRay attributes at build-time, users may define
+// ABSL_NO_XRAY_ATTRIBUTES. Do NOT define ABSL_NO_XRAY_ATTRIBUTES on specific
+// packages/targets, as this may lead to conflicting definitions of functions at
+// link-time.
+//
+// XRay isn't currently supported on Android:
+// https://github.com/android/ndk/issues/368
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_always_instrument) && \
+    !defined(ABSL_NO_XRAY_ATTRIBUTES) && !defined(__ANDROID__)
+#define ABSL_XRAY_ALWAYS_INSTRUMENT [[clang::xray_always_instrument]]
+#define ABSL_XRAY_NEVER_INSTRUMENT [[clang::xray_never_instrument]]
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_log_args)
+#define ABSL_XRAY_LOG_ARGS(N) \
+  [[clang::xray_always_instrument, clang::xray_log_args(N)]]
+#else
+#define ABSL_XRAY_LOG_ARGS(N) [[clang::xray_always_instrument]]
+#endif
+#else
+#define ABSL_XRAY_ALWAYS_INSTRUMENT
+#define ABSL_XRAY_NEVER_INSTRUMENT
+#define ABSL_XRAY_LOG_ARGS(N)
+#endif
+
+// ABSL_ATTRIBUTE_REINITIALIZES
+//
+// Indicates that a member function reinitializes the entire object to a known
+// state, independent of the previous state of the object.
+//
+// The clang-tidy check bugprone-use-after-move allows member functions marked
+// with this attribute to be called on objects that have been moved from;
+// without the attribute, this would result in a use-after-move warning.
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::reinitializes)
+#define ABSL_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
+#else
+#define ABSL_ATTRIBUTE_REINITIALIZES
+#endif
+
+// -----------------------------------------------------------------------------
+// Variable Attributes
+// -----------------------------------------------------------------------------
+
+// ABSL_ATTRIBUTE_UNUSED
+//
+// Prevents the compiler from complaining about variables that appear unused.
+//
+// For code or headers that are assured to only build with C++17 and up, prefer
+// just using the standard '[[maybe_unused]]' directly over this macro.
+//
+// Due to differences in positioning requirements between the old, compiler
+// specific __attribute__ syntax and the now standard [[maybe_unused]], this
+// macro does not attempt to take advantage of '[[maybe_unused]]'.
+#if ABSL_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))
+#undef ABSL_ATTRIBUTE_UNUSED
+#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
+#else
+#define ABSL_ATTRIBUTE_UNUSED
+#endif
+
+// ABSL_ATTRIBUTE_INITIAL_EXEC
+//
+// Tells the compiler to use "initial-exec" mode for a thread-local variable.
+// See http://people.redhat.com/drepper/tls.pdf for the gory details.
+#if ABSL_HAVE_ATTRIBUTE(tls_model) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_INITIAL_EXEC __attribute__((tls_model("initial-exec")))
+#else
+#define ABSL_ATTRIBUTE_INITIAL_EXEC
+#endif
+
+// ABSL_ATTRIBUTE_PACKED
+//
+// Instructs the compiler not to use natural alignment for a tagged data
+// structure, but instead to reduce its alignment to 1.
+//
+// Therefore, DO NOT APPLY THIS ATTRIBUTE TO STRUCTS CONTAINING ATOMICS. Doing
+// so can cause atomic variables to be mis-aligned and silently violate
+// atomicity on x86.
+//
+// This attribute can either be applied to members of a structure or to a
+// structure in its entirety. Applying this attribute (judiciously) to a
+// structure in its entirety to optimize the memory footprint of very
+// commonly-used structs is fine. Do not apply this attribute to a structure in
+// its entirety if the purpose is to control the offsets of the members in the
+// structure. Instead, apply this attribute only to structure members that need
+// it.
+//
+// When applying ABSL_ATTRIBUTE_PACKED only to specific structure members the
+// natural alignment of structure members not annotated is preserved. Aligned
+// member accesses are faster than non-aligned member accesses even if the
+// targeted microprocessor supports non-aligned accesses.
+#if ABSL_HAVE_ATTRIBUTE(packed) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_PACKED __attribute__((__packed__))
+#else
+#define ABSL_ATTRIBUTE_PACKED
+#endif
+
+// ABSL_ATTRIBUTE_FUNC_ALIGN
+//
+// Tells the compiler to align the function start at least to certain
+// alignment boundary
+#if ABSL_HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))
+#else
+#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes)
+#endif
+
+// ABSL_FALLTHROUGH_INTENDED
+//
+// Annotates implicit fall-through between switch labels, allowing a case to
+// indicate intentional fallthrough and turn off warnings about any lack of a
+// `break` statement. The ABSL_FALLTHROUGH_INTENDED macro should be followed by
+// a semicolon and can be used in most places where `break` can, provided that
+// no statements exist between it and the next switch label.
+//
+// Example:
+//
+//  switch (x) {
+//    case 40:
+//    case 41:
+//      if (truth_is_out_there) {
+//        ++x;
+//        ABSL_FALLTHROUGH_INTENDED;  // Use instead of/along with annotations
+//                                    // in comments
+//      } else {
+//        return x;
+//      }
+//    case 42:
+//      ...
+//
+// Notes: When supported, GCC and Clang can issue a warning on switch labels
+// with unannotated fallthrough using the warning `-Wimplicit-fallthrough`. See
+// clang documentation on language extensions for details:
+// https://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough
+//
+// When used with unsupported compilers, the ABSL_FALLTHROUGH_INTENDED macro has
+// no effect on diagnostics. In any case this macro has no effect on runtime
+// behavior and performance of code.
+
+#ifdef ABSL_FALLTHROUGH_INTENDED
+#error "ABSL_FALLTHROUGH_INTENDED should not be defined."
+#elif ABSL_HAVE_CPP_ATTRIBUTE(fallthrough)
+#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
+#elif ABSL_HAVE_CPP_ATTRIBUTE(clang::fallthrough)
+#define ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#elif ABSL_HAVE_CPP_ATTRIBUTE(gnu::fallthrough)
+#define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#else
+#define ABSL_FALLTHROUGH_INTENDED \
+  do {                            \
+  } while (0)
+#endif
+
+// ABSL_DEPRECATED()
+//
+// Marks a deprecated class, struct, enum, function, method and variable
+// declarations. The macro argument is used as a custom diagnostic message (e.g.
+// suggestion of a better alternative).
+//
+// For code or headers that are assured to only build with C++14 and up, prefer
+// just using the standard `[[deprecated("message")]]` directly over this macro.
+//
+// Examples:
+//
+//   class ABSL_DEPRECATED("Use Bar instead") Foo {...};
+//
+//   ABSL_DEPRECATED("Use Baz() instead") void Bar() {...}
+//
+//   template <typename T>
+//   ABSL_DEPRECATED("Use DoThat() instead")
+//   void DoThis();
+//
+//   enum FooEnum {
+//     kBar ABSL_DEPRECATED("Use kBaz instead"),
+//   };
+//
+// Every usage of a deprecated entity will trigger a warning when compiled with
+// GCC/Clang's `-Wdeprecated-declarations` option. Google's production toolchain
+// turns this warning off by default, instead relying on clang-tidy to report
+// new uses of deprecated code.
+#if ABSL_HAVE_ATTRIBUTE(deprecated)
+#define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
+#else
+#define ABSL_DEPRECATED(message)
+#endif
+
+// ABSL_CONST_INIT
+//
+// A variable declaration annotated with the `ABSL_CONST_INIT` attribute will
+// not compile (on supported platforms) unless the variable has a constant
+// initializer. This is useful for variables with static and thread storage
+// duration, because it guarantees that they will not suffer from the so-called
+// "static init order fiasco".
+//
+// This attribute must be placed on the initializing declaration of the
+// variable. Some compilers will give a -Wmissing-constinit warning when this
+// attribute is placed on some other declaration but missing from the
+// initializing declaration.
+//
+// In some cases (notably with thread_local variables), `ABSL_CONST_INIT` can
+// also be used in a non-initializing declaration to tell the compiler that a
+// variable is already initialized, reducing overhead that would otherwise be
+// incurred by a hidden guard variable. Thus annotating all declarations with
+// this attribute is recommended to potentially enhance optimization.
+//
+// Example:
+//
+//   class MyClass {
+//    public:
+//     ABSL_CONST_INIT static MyType my_var;
+//   };
+//
+//   ABSL_CONST_INIT MyType MyClass::my_var = MakeMyType(...);
+//
+// For code or headers that are assured to only build with C++20 and up, prefer
+// just using the standard `constinit` keyword directly over this macro.
+//
+// Note that this attribute is redundant if the variable is declared constexpr.
+#if defined(__cpp_constinit) && __cpp_constinit >= 201907L
+#define ABSL_CONST_INIT constinit
+#elif ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
+#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
+#else
+#define ABSL_CONST_INIT
+#endif
+
+// ABSL_ATTRIBUTE_PURE_FUNCTION
+//
+// ABSL_ATTRIBUTE_PURE_FUNCTION is used to annotate declarations of "pure"
+// functions. A function is pure if its return value is only a function of its
+// arguments. The pure attribute prohibits a function from modifying the state
+// of the program that is observable by means other than inspecting the
+// function's return value. Declaring such functions with the pure attribute
+// allows the compiler to avoid emitting some calls in repeated invocations of
+// the function with the same argument values.
+//
+// Example:
+//
+//  ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
+#if ABSL_HAVE_CPP_ATTRIBUTE(gnu::pure)
+#define ABSL_ATTRIBUTE_PURE_FUNCTION [[gnu::pure]]
+#elif ABSL_HAVE_ATTRIBUTE(pure)
+#define ABSL_ATTRIBUTE_PURE_FUNCTION __attribute__((pure))
+#else
+#define ABSL_ATTRIBUTE_PURE_FUNCTION
+#endif
+
+// ABSL_ATTRIBUTE_LIFETIME_BOUND indicates that a resource owned by a function
+// parameter or implicit object parameter is retained by the return value of the
+// annotated function (or, for a parameter of a constructor, in the value of the
+// constructed object). This attribute causes warnings to be produced if a
+// temporary object does not live long enough.
+//
+// When applied to a reference parameter, the referenced object is assumed to be
+// retained by the return value of the function. When applied to a non-reference
+// parameter (for example, a pointer or a class type), all temporaries
+// referenced by the parameter are assumed to be retained by the return value of
+// the function.
+//
+// See also the upstream documentation:
+// https://clang.llvm.org/docs/AttributeReference.html#lifetimebound
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::lifetimebound)
+#define ABSL_ATTRIBUTE_LIFETIME_BOUND [[clang::lifetimebound]]
+#elif ABSL_HAVE_ATTRIBUTE(lifetimebound)
+#define ABSL_ATTRIBUTE_LIFETIME_BOUND __attribute__((lifetimebound))
+#else
+#define ABSL_ATTRIBUTE_LIFETIME_BOUND
+#endif
+
+#endif  // ABSL_BASE_ATTRIBUTES_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/call_once.h b/CAPI/cpp/grpc/include/absl/base/call_once.h
new file mode 100644
index 0000000..96109f5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/call_once.h
@@ -0,0 +1,219 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: call_once.h
+// -----------------------------------------------------------------------------
+//
+// This header file provides an Abseil version of `std::call_once` for invoking
+// a given function at most once, across all threads. This Abseil version is
+// faster than the C++11 version and incorporates the C++17 argument-passing
+// fix, so that (for example) non-const references may be passed to the invoked
+// function.
+
+#ifndef ABSL_BASE_CALL_ONCE_H_
+#define ABSL_BASE_CALL_ONCE_H_
+
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/invoke.h"
+#include "absl/base/internal/low_level_scheduling.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/internal/spinlock_wait.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class once_flag;
+
+namespace base_internal {
+std::atomic<uint32_t>* ControlWord(absl::once_flag* flag);
+}  // namespace base_internal
+
+// call_once()
+//
+// For all invocations using a given `once_flag`, invokes a given `fn` exactly
+// once across all threads. The first call to `call_once()` with a particular
+// `once_flag` argument (that does not throw an exception) will run the
+// specified function with the provided `args`; other calls with the same
+// `once_flag` argument will not run the function, but will wait
+// for the provided function to finish running (if it is still running).
+//
+// This mechanism provides a safe, simple, and fast mechanism for one-time
+// initialization in a multi-threaded process.
+//
+// Example:
+//
+// class MyInitClass {
+//  public:
+//  ...
+//  mutable absl::once_flag once_;
+//
+//  MyInitClass* init() const {
+//    absl::call_once(once_, &MyInitClass::Init, this);
+//    return ptr_;
+//  }
+//
+template <typename Callable, typename... Args>
+void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args);
+
+// once_flag
+//
+// Objects of this type are used to distinguish calls to `call_once()` and
+// ensure the provided function is only invoked once across all threads. This
+// type is not copyable or movable. However, it has a `constexpr`
+// constructor, and is safe to use as a namespace-scoped global variable.
+class once_flag {
+ public:
+  constexpr once_flag() : control_(0) {}
+  once_flag(const once_flag&) = delete;
+  once_flag& operator=(const once_flag&) = delete;
+
+ private:
+  friend std::atomic<uint32_t>* base_internal::ControlWord(once_flag* flag);
+  std::atomic<uint32_t> control_;
+};
+
+//------------------------------------------------------------------------------
+// End of public interfaces.
+// Implementation details follow.
+//------------------------------------------------------------------------------
+
+namespace base_internal {
+
+// Like call_once, but uses KERNEL_ONLY scheduling. Intended to be used to
+// initialize entities used by the scheduler implementation.
+template <typename Callable, typename... Args>
+void LowLevelCallOnce(absl::once_flag* flag, Callable&& fn, Args&&... args);
+
+// Disables scheduling while on stack when scheduling mode is non-cooperative.
+// No effect for cooperative scheduling modes.
+class SchedulingHelper {
+ public:
+  explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
+    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
+      guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
+    }
+  }
+
+  ~SchedulingHelper() {
+    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
+      base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
+    }
+  }
+
+ private:
+  base_internal::SchedulingMode mode_;
+  bool guard_result_;
+};
+
+// Bit patterns for call_once state machine values.  Internal implementation
+// detail, not for use by clients.
+//
+// The bit patterns are arbitrarily chosen from unlikely values, to aid in
+// debugging.  However, kOnceInit must be 0, so that a zero-initialized
+// once_flag will be valid for immediate use.
+enum {
+  kOnceInit = 0,
+  kOnceRunning = 0x65C2937B,
+  kOnceWaiter = 0x05A308D2,
+  // A very small constant is chosen for kOnceDone so that it fit in a single
+  // compare with immediate instruction for most common ISAs.  This is verified
+  // for x86, POWER and ARM.
+  kOnceDone = 221,    // Random Number
+};
+
+template <typename Callable, typename... Args>
+ABSL_ATTRIBUTE_NOINLINE
+void CallOnceImpl(std::atomic<uint32_t>* control,
+                  base_internal::SchedulingMode scheduling_mode, Callable&& fn,
+                  Args&&... args) {
+#ifndef NDEBUG
+  {
+    uint32_t old_control = control->load(std::memory_order_relaxed);
+    if (old_control != kOnceInit &&
+        old_control != kOnceRunning &&
+        old_control != kOnceWaiter &&
+        old_control != kOnceDone) {
+      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
+                   static_cast<unsigned long>(old_control));  // NOLINT
+    }
+  }
+#endif  // NDEBUG
+  static const base_internal::SpinLockWaitTransition trans[] = {
+      {kOnceInit, kOnceRunning, true},
+      {kOnceRunning, kOnceWaiter, false},
+      {kOnceDone, kOnceDone, true}};
+
+  // Must do this before potentially modifying control word's state.
+  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
+  // Short circuit the simplest case to avoid procedure call overhead.
+  // The base_internal::SpinLockWait() call returns either kOnceInit or
+  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
+  // with std::memory_order_acquire and seen a value of kOnceDone.
+  uint32_t old_control = kOnceInit;
+  if (control->compare_exchange_strong(old_control, kOnceRunning,
+                                       std::memory_order_relaxed) ||
+      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
+                                  scheduling_mode) == kOnceInit) {
+    base_internal::invoke(std::forward<Callable>(fn),
+                          std::forward<Args>(args)...);
+    old_control =
+        control->exchange(base_internal::kOnceDone, std::memory_order_release);
+    if (old_control == base_internal::kOnceWaiter) {
+      base_internal::SpinLockWake(control, true);
+    }
+  }  // else *control is already kOnceDone
+}
+
+inline std::atomic<uint32_t>* ControlWord(once_flag* flag) {
+  return &flag->control_;
+}
+
+template <typename Callable, typename... Args>
+void LowLevelCallOnce(absl::once_flag* flag, Callable&& fn, Args&&... args) {
+  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
+  uint32_t s = once->load(std::memory_order_acquire);
+  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
+    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
+                                std::forward<Callable>(fn),
+                                std::forward<Args>(args)...);
+  }
+}
+
+}  // namespace base_internal
+
+template <typename Callable, typename... Args>
+void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
+  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
+  uint32_t s = once->load(std::memory_order_acquire);
+  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
+    base_internal::CallOnceImpl(
+        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
+        std::forward<Callable>(fn), std::forward<Args>(args)...);
+  }
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_CALL_ONCE_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/casts.h b/CAPI/cpp/grpc/include/absl/base/casts.h
new file mode 100644
index 0000000..b99adb0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/casts.h
@@ -0,0 +1,180 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: casts.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines casting templates to fit use cases not covered by
+// the standard casts provided in the C++ standard. As with all cast operations,
+// use these with caution and only if alternatives do not exist.
+
+#ifndef ABSL_BASE_CASTS_H_
+#define ABSL_BASE_CASTS_H_
+
+#include <cstring>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+#include <bit>  // For std::bit_cast.
+#endif  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+
+#include "absl/base/internal/identity.h"
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// implicit_cast()
+//
+// Performs an implicit conversion between types following the language
+// rules for implicit conversion; if an implicit conversion is otherwise
+// allowed by the language in the given context, this function performs such an
+// implicit conversion.
+//
+// Example:
+//
+//   // If the context allows implicit conversion:
+//   From from;
+//   To to = from;
+//
+//   // Such code can be replaced by:
+//   implicit_cast<To>(from);
+//
+// An `implicit_cast()` may also be used to annotate numeric type conversions
+// that, although safe, may produce compiler warnings (such as `long` to `int`).
+// Additionally, an `implicit_cast()` is also useful within return statements to
+// indicate a specific implicit conversion is being undertaken.
+//
+// Example:
+//
+//   return implicit_cast<double>(size_in_bytes) / capacity_;
+//
+// Annotating code with `implicit_cast()` allows you to explicitly select
+// particular overloads and template instantiations, while providing a safer
+// cast than `reinterpret_cast()` or `static_cast()`.
+//
+// Additionally, an `implicit_cast()` can be used to allow upcasting within a
+// type hierarchy where incorrect use of `static_cast()` could accidentally
+// allow downcasting.
+//
+// Finally, an `implicit_cast()` can be used to perform implicit conversions
+// from unrelated types that otherwise couldn't be implicitly cast directly;
+// C++ will normally only implicitly cast "one step" in such conversions.
+//
+// That is, if C is a type which can be implicitly converted to B, with B being
+// a type that can be implicitly converted to A, an `implicit_cast()` can be
+// used to convert C to B (which the compiler can then implicitly convert to A
+// using language rules).
+//
+// Example:
+//
+//   // Assume an object C is convertible to B, which is implicitly convertible
+//   // to A
+//   A a = implicit_cast<B>(C);
+//
+// Such implicit cast chaining may be useful within template logic.
+template <typename To>
+constexpr To implicit_cast(typename absl::internal::identity_t<To> to) {
+  return to;
+}
+
+// bit_cast()
+//
+// Creates a value of the new type `Dest` whose representation is the same as
+// that of the argument, which is of (deduced) type `Source` (a "bitwise cast";
+// every bit in the value representation of the result is equal to the
+// corresponding bit in the object representation of the source). Source and
+// destination types must be of the same size, and both types must be trivially
+// copyable.
+//
+// As with most casts, use with caution. A `bit_cast()` might be needed when you
+// need to treat a value as the value of some other type, for example, to access
+// the individual bits of an object which are not normally accessible through
+// the object's type, such as for working with the binary representation of a
+// floating point value:
+//
+//   float f = 3.14159265358979;
+//   int i = bit_cast<int>(f);
+//   // i = 0x40490fdb
+//
+// Reinterpreting and accessing a value directly as a different type (as shown
+// below) usually results in undefined behavior.
+//
+// Example:
+//
+//   // WRONG
+//   float f = 3.14159265358979;
+//   int i = reinterpret_cast<int&>(f);    // Wrong
+//   int j = *reinterpret_cast<int*>(&f);  // Equally wrong
+//   int k = *bit_cast<int*>(&f);          // Equally wrong
+//
+// Reinterpret-casting results in undefined behavior according to the ISO C++
+// specification, section [basic.lval]. Roughly, this section says: if an object
+// in memory has one type, and a program accesses it with a different type, the
+// result is undefined behavior for most "different type".
+//
+// Using bit_cast on a pointer and then dereferencing it is no better than using
+// reinterpret_cast. You should only use bit_cast on the value itself.
+//
+// Such casting results in type punning: holding an object in memory of one type
+// and reading its bits back using a different type. A `bit_cast()` avoids this
+// issue by copying the object representation to a new value, which avoids
+// introducing this undefined behavior (since the original value is never
+// accessed in the wrong way).
+//
+// The requirements of `absl::bit_cast` are more strict than that of
+// `std::bit_cast` unless compiler support is available. Specifically, without
+// compiler support, this implementation also requires `Dest` to be
+// default-constructible. In C++20, `absl::bit_cast` is replaced by
+// `std::bit_cast`.
+#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+
+using std::bit_cast;
+
+#else  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+
+template <typename Dest, typename Source,
+          typename std::enable_if<
+              sizeof(Dest) == sizeof(Source) &&
+                  type_traits_internal::is_trivially_copyable<Source>::value &&
+                  type_traits_internal::is_trivially_copyable<Dest>::value
+#if !ABSL_HAVE_BUILTIN(__builtin_bit_cast)
+                  && std::is_default_constructible<Dest>::value
+#endif  // !ABSL_HAVE_BUILTIN(__builtin_bit_cast)
+              ,
+              int>::type = 0>
+#if ABSL_HAVE_BUILTIN(__builtin_bit_cast)
+inline constexpr Dest bit_cast(const Source& source) {
+  return __builtin_bit_cast(Dest, source);
+}
+#else  // ABSL_HAVE_BUILTIN(__builtin_bit_cast)
+inline Dest bit_cast(const Source& source) {
+  Dest dest;
+  memcpy(static_cast<void*>(std::addressof(dest)),
+         static_cast<const void*>(std::addressof(source)), sizeof(dest));
+  return dest;
+}
+#endif  // ABSL_HAVE_BUILTIN(__builtin_bit_cast)
+
+#endif  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_CASTS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/config.h b/CAPI/cpp/grpc/include/absl/base/config.h
new file mode 100644
index 0000000..705ecea
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/config.h
@@ -0,0 +1,913 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: config.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a set of macros for checking the presence of
+// important compiler and platform features. Such macros can be used to
+// produce portable code by parameterizing compilation based on the presence or
+// lack of a given feature.
+//
+// We define a "feature" as some interface we wish to program to: for example,
+// a library function or system call. A value of `1` indicates support for
+// that feature; any other value indicates the feature support is undefined.
+//
+// Example:
+//
+// Suppose a programmer wants to write a program that uses the 'mmap()' system
+// call. The Abseil macro for that feature (`ABSL_HAVE_MMAP`) allows you to
+// selectively include the `mmap.h` header and bracket code using that feature
+// in the macro:
+//
+//   #include "absl/base/config.h"
+//
+//   #ifdef ABSL_HAVE_MMAP
+//   #include "sys/mman.h"
+//   #endif  //ABSL_HAVE_MMAP
+//
+//   ...
+//   #ifdef ABSL_HAVE_MMAP
+//   void *ptr = mmap(...);
+//   ...
+//   #endif  // ABSL_HAVE_MMAP
+
+#ifndef ABSL_BASE_CONFIG_H_
+#define ABSL_BASE_CONFIG_H_
+
+// Included for the __GLIBC__ macro (or similar macros on other systems).
+#include <limits.h>
+
+#ifdef __cplusplus
+// Included for __GLIBCXX__, _LIBCPP_VERSION
+#include <cstddef>
+#endif  // __cplusplus
+
+// ABSL_INTERNAL_CPLUSPLUS_LANG
+//
+// MSVC does not set the value of __cplusplus correctly, but instead uses
+// _MSVC_LANG as a stand-in.
+// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
+//
+// However, there are reports that MSVC even sets _MSVC_LANG incorrectly at
+// times, for example:
+// https://github.com/microsoft/vscode-cpptools/issues/1770
+// https://reviews.llvm.org/D70996
+//
+// For this reason, this symbol is considered INTERNAL and code outside of
+// Abseil must not use it.
+#if defined(_MSVC_LANG)
+#define ABSL_INTERNAL_CPLUSPLUS_LANG _MSVC_LANG
+#elif defined(__cplusplus)
+#define ABSL_INTERNAL_CPLUSPLUS_LANG __cplusplus
+#endif
+
+#if defined(__APPLE__)
+// Included for TARGET_OS_IPHONE, __IPHONE_OS_VERSION_MIN_REQUIRED,
+// __IPHONE_8_0.
+#include <Availability.h>
+#include <TargetConditionals.h>
+#endif
+
+#include "absl/base/options.h"
+#include "absl/base/policy_checks.h"
+
+// Abseil long-term support (LTS) releases will define
+// `ABSL_LTS_RELEASE_VERSION` to the integer representing the date string of the
+// LTS release version, and will define `ABSL_LTS_RELEASE_PATCH_LEVEL` to the
+// integer representing the patch-level for that release.
+//
+// For example, for LTS release version "20300401.2", this would give us
+// ABSL_LTS_RELEASE_VERSION == 20300401 && ABSL_LTS_RELEASE_PATCH_LEVEL == 2
+//
+// These symbols will not be defined in non-LTS code.
+//
+// Abseil recommends that clients live-at-head. Therefore, if you are using
+// these symbols to assert a minimum version requirement, we recommend you do it
+// as
+//
+// #if defined(ABSL_LTS_RELEASE_VERSION) && ABSL_LTS_RELEASE_VERSION < 20300401
+// #error Project foo requires Abseil LTS version >= 20300401
+// #endif
+//
+// The `defined(ABSL_LTS_RELEASE_VERSION)` part of the check excludes
+// live-at-head clients from the minimum version assertion.
+//
+// See https://abseil.io/about/releases for more information on Abseil release
+// management.
+//
+// LTS releases can be obtained from
+// https://github.com/abseil/abseil-cpp/releases.
+#define ABSL_LTS_RELEASE_VERSION 20220623
+#define ABSL_LTS_RELEASE_PATCH_LEVEL 1
+
+// Helper macro to convert a CPP variable to a string literal.
+#define ABSL_INTERNAL_DO_TOKEN_STR(x) #x
+#define ABSL_INTERNAL_TOKEN_STR(x) ABSL_INTERNAL_DO_TOKEN_STR(x)
+
+// -----------------------------------------------------------------------------
+// Abseil namespace annotations
+// -----------------------------------------------------------------------------
+
+// ABSL_NAMESPACE_BEGIN/ABSL_NAMESPACE_END
+//
+// An annotation placed at the beginning/end of each `namespace absl` scope.
+// This is used to inject an inline namespace.
+//
+// The proper way to write Abseil code in the `absl` namespace is:
+//
+// namespace absl {
+// ABSL_NAMESPACE_BEGIN
+//
+// void Foo();  // absl::Foo().
+//
+// ABSL_NAMESPACE_END
+// }  // namespace absl
+//
+// Users of Abseil should not use these macros, because users of Abseil should
+// not write `namespace absl {` in their own code for any reason.  (Abseil does
+// not support forward declarations of its own types, nor does it support
+// user-provided specialization of Abseil templates.  Code that violates these
+// rules may be broken without warning.)
+#if !defined(ABSL_OPTION_USE_INLINE_NAMESPACE) || \
+    !defined(ABSL_OPTION_INLINE_NAMESPACE_NAME)
+#error options.h is misconfigured.
+#endif
+
+// Check that ABSL_OPTION_INLINE_NAMESPACE_NAME is neither "head" nor ""
+#if defined(__cplusplus) && ABSL_OPTION_USE_INLINE_NAMESPACE == 1
+
+#define ABSL_INTERNAL_INLINE_NAMESPACE_STR \
+  ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME)
+
+static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != '\0',
+              "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
+              "not be empty.");
+static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
+                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[1] != 'e' ||
+                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[2] != 'a' ||
+                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[3] != 'd' ||
+                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[4] != '\0',
+              "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
+              "be changed to a new, unique identifier name.");
+
+#endif
+
+#if ABSL_OPTION_USE_INLINE_NAMESPACE == 0
+#define ABSL_NAMESPACE_BEGIN
+#define ABSL_NAMESPACE_END
+#define ABSL_INTERNAL_C_SYMBOL(x) x
+#elif ABSL_OPTION_USE_INLINE_NAMESPACE == 1
+#define ABSL_NAMESPACE_BEGIN \
+  inline namespace ABSL_OPTION_INLINE_NAMESPACE_NAME {
+#define ABSL_NAMESPACE_END }
+#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
+#define ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, v) \
+  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
+#define ABSL_INTERNAL_C_SYMBOL(x) \
+  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
+#else
+#error options.h is misconfigured.
+#endif
+
+// -----------------------------------------------------------------------------
+// Compiler Feature Checks
+// -----------------------------------------------------------------------------
+
+// ABSL_HAVE_BUILTIN()
+//
+// Checks whether the compiler supports a Clang Feature Checking Macro, and if
+// so, checks whether it supports the provided builtin function "x" where x
+// is one of the functions noted in
+// https://clang.llvm.org/docs/LanguageExtensions.html
+//
+// Note: Use this macro to avoid an extra level of #ifdef __has_builtin check.
+// http://releases.llvm.org/3.3/tools/clang/docs/LanguageExtensions.html
+#ifdef __has_builtin
+#define ABSL_HAVE_BUILTIN(x) __has_builtin(x)
+#else
+#define ABSL_HAVE_BUILTIN(x) 0
+#endif
+
+#ifdef __has_feature
+#define ABSL_HAVE_FEATURE(f) __has_feature(f)
+#else
+#define ABSL_HAVE_FEATURE(f) 0
+#endif
+
+// Portable check for GCC minimum version:
+// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+#if defined(__GNUC__) && defined(__GNUC_MINOR__)
+#define ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) \
+  (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
+#else
+#define ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) 0
+#endif
+
+#if defined(__clang__) && defined(__clang_major__) && defined(__clang_minor__)
+#define ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) \
+  (__clang_major__ > (x) || __clang_major__ == (x) && __clang_minor__ >= (y))
+#else
+#define ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) 0
+#endif
+
+// ABSL_HAVE_TLS is defined to 1 when __thread should be supported.
+// We assume __thread is supported on Linux or Asylo when compiled with Clang or
+// compiled against libstdc++ with _GLIBCXX_HAVE_TLS defined.
+#ifdef ABSL_HAVE_TLS
+#error ABSL_HAVE_TLS cannot be directly set
+#elif (defined(__linux__) || defined(__ASYLO__)) && \
+    (defined(__clang__) || defined(_GLIBCXX_HAVE_TLS))
+#define ABSL_HAVE_TLS 1
+#endif
+
+// ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+//
+// Checks whether `std::is_trivially_destructible<T>` is supported.
+//
+// Notes: All supported compilers using libc++ support this feature, as does
+// gcc >= 4.8.1 using libstdc++, and Visual Studio.
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+#error ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE cannot be directly set
+#elif defined(_LIBCPP_VERSION) || defined(_MSC_VER) || \
+    (!defined(__clang__) && defined(__GLIBCXX__) &&    \
+     ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(4, 8))
+#define ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE 1
+#endif
+
+// ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+//
+// Checks whether `std::is_trivially_default_constructible<T>` and
+// `std::is_trivially_copy_constructible<T>` are supported.
+
+// ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+//
+// Checks whether `std::is_trivially_copy_assignable<T>` is supported.
+
+// Notes: Clang with libc++ supports these features, as does gcc >= 7.4 with
+// libstdc++, or gcc >= 8.2 with libc++, and Visual Studio (but not NVCC).
+#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE)
+#error ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE cannot be directly set
+#elif defined(ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE)
+#error ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE cannot directly set
+#elif (defined(__clang__) && defined(_LIBCPP_VERSION)) ||                    \
+    (!defined(__clang__) &&                                                  \
+     ((ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(7, 4) && defined(__GLIBCXX__)) || \
+      (ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(8, 2) &&                          \
+       defined(_LIBCPP_VERSION)))) ||                                        \
+    (defined(_MSC_VER) && !defined(__NVCC__))
+#define ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE 1
+#define ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE 1
+#endif
+
+// ABSL_HAVE_THREAD_LOCAL
+//
+// Checks whether C++11's `thread_local` storage duration specifier is
+// supported.
+#ifdef ABSL_HAVE_THREAD_LOCAL
+#error ABSL_HAVE_THREAD_LOCAL cannot be directly set
+#elif defined(__APPLE__)
+// Notes:
+// * Xcode's clang did not support `thread_local` until version 8, and
+//   even then not for all iOS < 9.0.
+// * Xcode 9.3 started disallowing `thread_local` for 32-bit iOS simulator
+//   targeting iOS 9.x.
+// * Xcode 10 moves the deployment target check for iOS < 9.0 to link time
+//   making ABSL_HAVE_FEATURE unreliable there.
+//
+#if ABSL_HAVE_FEATURE(cxx_thread_local) && \
+    !(TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_9_0)
+#define ABSL_HAVE_THREAD_LOCAL 1
+#endif
+#else  // !defined(__APPLE__)
+#define ABSL_HAVE_THREAD_LOCAL 1
+#endif
+
+// There are platforms for which TLS should not be used even though the compiler
+// makes it seem like it's supported (Android NDK < r12b for example).
+// This is primarily because of linker problems and toolchain misconfiguration:
+// Abseil does not intend to support this indefinitely. Currently, the newest
+// toolchain that we intend to support that requires this behavior is the
+// r11 NDK - allowing for a 5 year support window on that means this option
+// is likely to be removed around June of 2021.
+// TLS isn't supported until NDK r12b per
+// https://developer.android.com/ndk/downloads/revision_history.html
+// Since NDK r16, `__NDK_MAJOR__` and `__NDK_MINOR__` are defined in
+// <android/ndk-version.h>. For NDK < r16, users should define these macros,
+// e.g. `-D__NDK_MAJOR__=11 -D__NKD_MINOR__=0` for NDK r11.
+#if defined(__ANDROID__) && defined(__clang__)
+#if __has_include(<android/ndk-version.h>)
+#include <android/ndk-version.h>
+#endif  // __has_include(<android/ndk-version.h>)
+#if defined(__ANDROID__) && defined(__clang__) && defined(__NDK_MAJOR__) && \
+    defined(__NDK_MINOR__) &&                                               \
+    ((__NDK_MAJOR__ < 12) || ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))
+#undef ABSL_HAVE_TLS
+#undef ABSL_HAVE_THREAD_LOCAL
+#endif
+#endif  // defined(__ANDROID__) && defined(__clang__)
+
+// ABSL_HAVE_INTRINSIC_INT128
+//
+// Checks whether the __int128 compiler extension for a 128-bit integral type is
+// supported.
+//
+// Note: __SIZEOF_INT128__ is defined by Clang and GCC when __int128 is
+// supported, but we avoid using it in certain cases:
+// * On Clang:
+//   * Building using Clang for Windows, where the Clang runtime library has
+//     128-bit support only on LP64 architectures, but Windows is LLP64.
+// * On Nvidia's nvcc:
+//   * nvcc also defines __GNUC__ and __SIZEOF_INT128__, but not all versions
+//     actually support __int128.
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+#error ABSL_HAVE_INTRINSIC_INT128 cannot be directly set
+#elif defined(__SIZEOF_INT128__)
+#if (defined(__clang__) && !defined(_WIN32)) || \
+    (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) ||                \
+    (defined(__GNUC__) && !defined(__clang__) && !defined(__CUDACC__))
+#define ABSL_HAVE_INTRINSIC_INT128 1
+#elif defined(__CUDACC__)
+// __CUDACC_VER__ is a full version number before CUDA 9, and is defined to a
+// string explaining that it has been removed starting with CUDA 9. We use
+// nested #ifs because there is no short-circuiting in the preprocessor.
+// NOTE: `__CUDACC__` could be undefined while `__CUDACC_VER__` is defined.
+#if __CUDACC_VER__ >= 70000
+#define ABSL_HAVE_INTRINSIC_INT128 1
+#endif  // __CUDACC_VER__ >= 70000
+#endif  // defined(__CUDACC__)
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+// ABSL_HAVE_EXCEPTIONS
+//
+// Checks whether the compiler both supports and enables exceptions. Many
+// compilers support a "no exceptions" mode that disables exceptions.
+//
+// Generally, when ABSL_HAVE_EXCEPTIONS is not defined:
+//
+// * Code using `throw` and `try` may not compile.
+// * The `noexcept` specifier will still compile and behave as normal.
+// * The `noexcept` operator may still return `false`.
+//
+// For further details, consult the compiler's documentation.
+#ifdef ABSL_HAVE_EXCEPTIONS
+#error ABSL_HAVE_EXCEPTIONS cannot be directly set.
+#elif ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(3, 6)
+// Clang >= 3.6
+#if ABSL_HAVE_FEATURE(cxx_exceptions)
+#define ABSL_HAVE_EXCEPTIONS 1
+#endif  // ABSL_HAVE_FEATURE(cxx_exceptions)
+#elif defined(__clang__)
+// Clang < 3.6
+// http://releases.llvm.org/3.6.0/tools/clang/docs/ReleaseNotes.html#the-exceptions-macro
+#if defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions)
+#define ABSL_HAVE_EXCEPTIONS 1
+#endif  // defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions)
+// Handle remaining special cases and default to exceptions being supported.
+#elif !(defined(__GNUC__) && (__GNUC__ < 5) && !defined(__EXCEPTIONS)) && \
+    !(ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(5, 0) &&                        \
+      !defined(__cpp_exceptions)) &&                                      \
+    !(defined(_MSC_VER) && !defined(_CPPUNWIND))
+#define ABSL_HAVE_EXCEPTIONS 1
+#endif
+
+// -----------------------------------------------------------------------------
+// Platform Feature Checks
+// -----------------------------------------------------------------------------
+
+// Currently supported operating systems and associated preprocessor
+// symbols:
+//
+//   Linux and Linux-derived           __linux__
+//   Android                           __ANDROID__ (implies __linux__)
+//   Linux (non-Android)               __linux__ && !__ANDROID__
+//   Darwin (macOS and iOS)            __APPLE__
+//   Akaros (http://akaros.org)        __ros__
+//   Windows                           _WIN32
+//   NaCL                              __native_client__
+//   AsmJS                             __asmjs__
+//   WebAssembly                       __wasm__
+//   Fuchsia                           __Fuchsia__
+//
+// Note that since Android defines both __ANDROID__ and __linux__, one
+// may probe for either Linux or Android by simply testing for __linux__.
+
+// ABSL_HAVE_MMAP
+//
+// Checks whether the platform has an mmap(2) implementation as defined in
+// POSIX.1-2001.
+#ifdef ABSL_HAVE_MMAP
+#error ABSL_HAVE_MMAP cannot be directly set
+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
+    defined(_AIX) || defined(__ros__) || defined(__native_client__) ||    \
+    defined(__asmjs__) || defined(__wasm__) || defined(__Fuchsia__) ||    \
+    defined(__sun) || defined(__ASYLO__) || defined(__myriad2__) ||       \
+    defined(__HAIKU__) || defined(__OpenBSD__) || defined(__NetBSD__) ||  \
+    defined(__QNX__)
+#define ABSL_HAVE_MMAP 1
+#endif
+
+// ABSL_HAVE_PTHREAD_GETSCHEDPARAM
+//
+// Checks whether the platform implements the pthread_(get|set)schedparam(3)
+// functions as defined in POSIX.1-2001.
+#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
+#error ABSL_HAVE_PTHREAD_GETSCHEDPARAM cannot be directly set
+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
+    defined(_AIX) || defined(__ros__) || defined(__OpenBSD__) ||          \
+    defined(__NetBSD__)
+#define ABSL_HAVE_PTHREAD_GETSCHEDPARAM 1
+#endif
+
+// ABSL_HAVE_SCHED_GETCPU
+//
+// Checks whether sched_getcpu is available.
+#ifdef ABSL_HAVE_SCHED_GETCPU
+#error ABSL_HAVE_SCHED_GETCPU cannot be directly set
+#elif defined(__linux__)
+#define ABSL_HAVE_SCHED_GETCPU 1
+#endif
+
+// ABSL_HAVE_SCHED_YIELD
+//
+// Checks whether the platform implements sched_yield(2) as defined in
+// POSIX.1-2001.
+#ifdef ABSL_HAVE_SCHED_YIELD
+#error ABSL_HAVE_SCHED_YIELD cannot be directly set
+#elif defined(__linux__) || defined(__ros__) || defined(__native_client__)
+#define ABSL_HAVE_SCHED_YIELD 1
+#endif
+
+// ABSL_HAVE_SEMAPHORE_H
+//
+// Checks whether the platform supports the <semaphore.h> header and sem_init(3)
+// family of functions as standardized in POSIX.1-2001.
+//
+// Note: While Apple provides <semaphore.h> for both iOS and macOS, it is
+// explicitly deprecated and will cause build failures if enabled for those
+// platforms.  We side-step the issue by not defining it here for Apple
+// platforms.
+#ifdef ABSL_HAVE_SEMAPHORE_H
+#error ABSL_HAVE_SEMAPHORE_H cannot be directly set
+#elif defined(__linux__) || defined(__ros__)
+#define ABSL_HAVE_SEMAPHORE_H 1
+#endif
+
+// ABSL_HAVE_ALARM
+//
+// Checks whether the platform supports the <signal.h> header and alarm(2)
+// function as standardized in POSIX.1-2001.
+#ifdef ABSL_HAVE_ALARM
+#error ABSL_HAVE_ALARM cannot be directly set
+#elif defined(__GOOGLE_GRTE_VERSION__)
+// feature tests for Google's GRTE
+#define ABSL_HAVE_ALARM 1
+#elif defined(__GLIBC__)
+// feature test for glibc
+#define ABSL_HAVE_ALARM 1
+#elif defined(_MSC_VER)
+// feature tests for Microsoft's library
+#elif defined(__MINGW32__)
+// mingw32 doesn't provide alarm(2):
+// https://osdn.net/projects/mingw/scm/git/mingw-org-wsl/blobs/5.2-trunk/mingwrt/include/unistd.h
+// mingw-w64 provides a no-op implementation:
+// https://sourceforge.net/p/mingw-w64/mingw-w64/ci/master/tree/mingw-w64-crt/misc/alarm.c
+#elif defined(__EMSCRIPTEN__)
+// emscripten doesn't support signals
+#elif defined(__Fuchsia__)
+// Signals don't exist on fuchsia.
+#elif defined(__native_client__)
+#else
+// other standard libraries
+#define ABSL_HAVE_ALARM 1
+#endif
+
+// ABSL_IS_LITTLE_ENDIAN
+// ABSL_IS_BIG_ENDIAN
+//
+// Checks the endianness of the platform.
+//
+// Notes: uses the built in endian macros provided by GCC (since 4.6) and
+// Clang (since 3.2); see
+// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html.
+// Otherwise, if _WIN32, assume little endian. Otherwise, bail with an error.
+#if defined(ABSL_IS_BIG_ENDIAN)
+#error "ABSL_IS_BIG_ENDIAN cannot be directly set."
+#endif
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+#error "ABSL_IS_LITTLE_ENDIAN cannot be directly set."
+#endif
+
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
+     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define ABSL_IS_LITTLE_ENDIAN 1
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define ABSL_IS_BIG_ENDIAN 1
+#elif defined(_WIN32)
+#define ABSL_IS_LITTLE_ENDIAN 1
+#else
+#error "absl endian detection needs to be set up for your compiler"
+#endif
+
+// macOS < 10.13 and iOS < 11 don't let you use <any>, <optional>, or <variant>
+// even though the headers exist and are publicly noted to work, because the
+// libc++ shared library shipped on the system doesn't have the requisite
+// exported symbols.  See https://github.com/abseil/abseil-cpp/issues/207 and
+// https://developer.apple.com/documentation/xcode_release_notes/xcode_10_release_notes
+//
+// libc++ spells out the availability requirements in the file
+// llvm-project/libcxx/include/__config via the #define
+// _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS.
+//
+// Unfortunately, Apple initially mis-stated the requirements as macOS < 10.14
+// and iOS < 12 in the libc++ headers. This was corrected by
+// https://github.com/llvm/llvm-project/commit/7fb40e1569dd66292b647f4501b85517e9247953
+// which subsequently made it into the XCode 12.5 release. We need to match the
+// old (incorrect) conditions when built with old XCode, but can use the
+// corrected earlier versions with new XCode.
+#if defined(__APPLE__) && defined(_LIBCPP_VERSION) &&               \
+    ((_LIBCPP_VERSION >= 11000 && /* XCode 12.5 or later: */        \
+      ((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) &&   \
+        __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101300) ||  \
+       (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) &&  \
+        __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 110000) || \
+       (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) &&   \
+        __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 40000) ||   \
+       (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) &&      \
+        __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 110000))) ||   \
+     (_LIBCPP_VERSION < 11000 && /* Pre-XCode 12.5: */              \
+      ((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) &&   \
+        __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101400) ||  \
+       (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) &&  \
+        __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 120000) || \
+       (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) &&   \
+        __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 50000) ||   \
+       (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) &&      \
+        __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 120000))))
+#define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 1
+#else
+#define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 0
+#endif
+
+// ABSL_HAVE_STD_ANY
+//
+// Checks whether C++17 std::any is available by checking whether <any> exists.
+#ifdef ABSL_HAVE_STD_ANY
+#error "ABSL_HAVE_STD_ANY cannot be directly set."
+#endif
+
+#ifdef __has_include
+#if __has_include(<any>) && defined(__cplusplus) && __cplusplus >= 201703L && \
+    !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#define ABSL_HAVE_STD_ANY 1
+#endif
+#endif
+
+// ABSL_HAVE_STD_OPTIONAL
+//
+// Checks whether C++17 std::optional is available.
+#ifdef ABSL_HAVE_STD_OPTIONAL
+#error "ABSL_HAVE_STD_OPTIONAL cannot be directly set."
+#endif
+
+#ifdef __has_include
+#if __has_include(<optional>) && defined(__cplusplus) && \
+    __cplusplus >= 201703L && !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#define ABSL_HAVE_STD_OPTIONAL 1
+#endif
+#endif
+
+// ABSL_HAVE_STD_VARIANT
+//
+// Checks whether C++17 std::variant is available.
+#ifdef ABSL_HAVE_STD_VARIANT
+#error "ABSL_HAVE_STD_VARIANT cannot be directly set."
+#endif
+
+#ifdef __has_include
+#if __has_include(<variant>) && defined(__cplusplus) && \
+    __cplusplus >= 201703L && !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#define ABSL_HAVE_STD_VARIANT 1
+#endif
+#endif
+
+// ABSL_HAVE_STD_STRING_VIEW
+//
+// Checks whether C++17 std::string_view is available.
+#ifdef ABSL_HAVE_STD_STRING_VIEW
+#error "ABSL_HAVE_STD_STRING_VIEW cannot be directly set."
+#endif
+
+#ifdef __has_include
+#if __has_include(<string_view>) && defined(__cplusplus) && \
+    __cplusplus >= 201703L
+#define ABSL_HAVE_STD_STRING_VIEW 1
+#endif
+#endif
+
+// For MSVC, `__has_include` is supported in VS 2017 15.3, which is later than
+// the support for <optional>, <any>, <string_view>, <variant>. So we use
+// _MSC_VER to check whether we have VS 2017 RTM (when <optional>, <any>,
+// <string_view>, <variant> is implemented) or higher. Also, `__cplusplus` is
+// not correctly set by MSVC, so we use `_MSVC_LANG` to check the language
+// version.
+// TODO(zhangxy): fix tests before enabling aliasing for `std::any`.
+#if defined(_MSC_VER) && _MSC_VER >= 1910 &&         \
+    ((defined(_MSVC_LANG) && _MSVC_LANG > 201402) || \
+     (defined(__cplusplus) && __cplusplus > 201402))
+// #define ABSL_HAVE_STD_ANY 1
+#define ABSL_HAVE_STD_OPTIONAL 1
+#define ABSL_HAVE_STD_VARIANT 1
+#define ABSL_HAVE_STD_STRING_VIEW 1
+#endif
+
+// ABSL_USES_STD_ANY
+//
+// Indicates whether absl::any is an alias for std::any.
+#if !defined(ABSL_OPTION_USE_STD_ANY)
+#error options.h is misconfigured.
+#elif ABSL_OPTION_USE_STD_ANY == 0 || \
+    (ABSL_OPTION_USE_STD_ANY == 2 && !defined(ABSL_HAVE_STD_ANY))
+#undef ABSL_USES_STD_ANY
+#elif ABSL_OPTION_USE_STD_ANY == 1 || \
+    (ABSL_OPTION_USE_STD_ANY == 2 && defined(ABSL_HAVE_STD_ANY))
+#define ABSL_USES_STD_ANY 1
+#else
+#error options.h is misconfigured.
+#endif
+
+// ABSL_USES_STD_OPTIONAL
+//
+// Indicates whether absl::optional is an alias for std::optional.
+#if !defined(ABSL_OPTION_USE_STD_OPTIONAL)
+#error options.h is misconfigured.
+#elif ABSL_OPTION_USE_STD_OPTIONAL == 0 || \
+    (ABSL_OPTION_USE_STD_OPTIONAL == 2 && !defined(ABSL_HAVE_STD_OPTIONAL))
+#undef ABSL_USES_STD_OPTIONAL
+#elif ABSL_OPTION_USE_STD_OPTIONAL == 1 || \
+    (ABSL_OPTION_USE_STD_OPTIONAL == 2 && defined(ABSL_HAVE_STD_OPTIONAL))
+#define ABSL_USES_STD_OPTIONAL 1
+#else
+#error options.h is misconfigured.
+#endif
+
+// ABSL_USES_STD_VARIANT
+//
+// Indicates whether absl::variant is an alias for std::variant.
+#if !defined(ABSL_OPTION_USE_STD_VARIANT)
+#error options.h is misconfigured.
+#elif ABSL_OPTION_USE_STD_VARIANT == 0 || \
+    (ABSL_OPTION_USE_STD_VARIANT == 2 && !defined(ABSL_HAVE_STD_VARIANT))
+#undef ABSL_USES_STD_VARIANT
+#elif ABSL_OPTION_USE_STD_VARIANT == 1 || \
+    (ABSL_OPTION_USE_STD_VARIANT == 2 && defined(ABSL_HAVE_STD_VARIANT))
+#define ABSL_USES_STD_VARIANT 1
+#else
+#error options.h is misconfigured.
+#endif
+
+// ABSL_USES_STD_STRING_VIEW
+//
+// Indicates whether absl::string_view is an alias for std::string_view.
+#if !defined(ABSL_OPTION_USE_STD_STRING_VIEW)
+#error options.h is misconfigured.
+#elif ABSL_OPTION_USE_STD_STRING_VIEW == 0 || \
+    (ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&  \
+     !defined(ABSL_HAVE_STD_STRING_VIEW))
+#undef ABSL_USES_STD_STRING_VIEW
+#elif ABSL_OPTION_USE_STD_STRING_VIEW == 1 || \
+    (ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&  \
+     defined(ABSL_HAVE_STD_STRING_VIEW))
+#define ABSL_USES_STD_STRING_VIEW 1
+#else
+#error options.h is misconfigured.
+#endif
+
+// In debug mode, MSVC 2017's std::variant throws a EXCEPTION_ACCESS_VIOLATION
+// SEH exception from emplace for variant<SomeStruct> when constructing the
+// struct can throw. This defeats some of variant_test and
+// variant_exception_safety_test.
+#if defined(_MSC_VER) && _MSC_VER >= 1700 && defined(_DEBUG)
+#define ABSL_INTERNAL_MSVC_2017_DBG_MODE
+#endif
+
+// ABSL_INTERNAL_MANGLED_NS
+// ABSL_INTERNAL_MANGLED_BACKREFERENCE
+//
+// Internal macros for building up mangled names in our internal fork of CCTZ.
+// This implementation detail is only needed and provided for the MSVC build.
+//
+// These macros both expand to string literals.  ABSL_INTERNAL_MANGLED_NS is
+// the mangled spelling of the `absl` namespace, and
+// ABSL_INTERNAL_MANGLED_BACKREFERENCE is a back-reference integer representing
+// the proper count to skip past the CCTZ fork namespace names.  (This number
+// is one larger when there is an inline namespace name to skip.)
+#if defined(_MSC_VER)
+#if ABSL_OPTION_USE_INLINE_NAMESPACE == 0
+#define ABSL_INTERNAL_MANGLED_NS "absl"
+#define ABSL_INTERNAL_MANGLED_BACKREFERENCE "5"
+#else
+#define ABSL_INTERNAL_MANGLED_NS \
+  ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME) "@absl"
+#define ABSL_INTERNAL_MANGLED_BACKREFERENCE "6"
+#endif
+#endif
+
+// ABSL_DLL
+//
+// When building Abseil as a DLL, this macro expands to `__declspec(dllexport)`
+// so we can annotate symbols appropriately as being exported. When used in
+// headers consuming a DLL, this macro expands to `__declspec(dllimport)` so
+// that consumers know the symbol is defined inside the DLL. In all other cases,
+// the macro expands to nothing.
+#if defined(_MSC_VER)
+#if defined(ABSL_BUILD_DLL)
+#define ABSL_DLL __declspec(dllexport)
+#elif defined(ABSL_CONSUME_DLL)
+#define ABSL_DLL __declspec(dllimport)
+#else
+#define ABSL_DLL
+#endif
+#else
+#define ABSL_DLL
+#endif  // defined(_MSC_VER)
+
+// ABSL_HAVE_MEMORY_SANITIZER
+//
+// MemorySanitizer (MSan) is a detector of uninitialized reads. It consists of
+// a compiler instrumentation module and a run-time library.
+#ifdef ABSL_HAVE_MEMORY_SANITIZER
+#error "ABSL_HAVE_MEMORY_SANITIZER cannot be directly set."
+#elif !defined(__native_client__) && ABSL_HAVE_FEATURE(memory_sanitizer)
+#define ABSL_HAVE_MEMORY_SANITIZER 1
+#endif
+
+// ABSL_HAVE_THREAD_SANITIZER
+//
+// ThreadSanitizer (TSan) is a fast data race detector.
+#ifdef ABSL_HAVE_THREAD_SANITIZER
+#error "ABSL_HAVE_THREAD_SANITIZER cannot be directly set."
+#elif defined(__SANITIZE_THREAD__)
+#define ABSL_HAVE_THREAD_SANITIZER 1
+#elif ABSL_HAVE_FEATURE(thread_sanitizer)
+#define ABSL_HAVE_THREAD_SANITIZER 1
+#endif
+
+// ABSL_HAVE_ADDRESS_SANITIZER
+//
+// AddressSanitizer (ASan) is a fast memory error detector.
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#error "ABSL_HAVE_ADDRESS_SANITIZER cannot be directly set."
+#elif defined(__SANITIZE_ADDRESS__)
+#define ABSL_HAVE_ADDRESS_SANITIZER 1
+#elif ABSL_HAVE_FEATURE(address_sanitizer)
+#define ABSL_HAVE_ADDRESS_SANITIZER 1
+#endif
+
+// ABSL_HAVE_HWADDRESS_SANITIZER
+//
+// Hardware-Assisted AddressSanitizer (or HWASAN) is even faster than asan
+// memory error detector which can use CPU features like ARM TBI, Intel LAM or
+// AMD UAI.
+#ifdef ABSL_HAVE_HWADDRESS_SANITIZER
+#error "ABSL_HAVE_HWADDRESS_SANITIZER cannot be directly set."
+#elif defined(__SANITIZE_HWADDRESS__)
+#define ABSL_HAVE_HWADDRESS_SANITIZER 1
+#elif ABSL_HAVE_FEATURE(hwaddress_sanitizer)
+#define ABSL_HAVE_HWADDRESS_SANITIZER 1
+#endif
+
+// ABSL_HAVE_LEAK_SANITIZER
+//
+// LeakSanitizer (or lsan) is a detector of memory leaks.
+// https://clang.llvm.org/docs/LeakSanitizer.html
+// https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer
+//
+// The macro ABSL_HAVE_LEAK_SANITIZER can be used to detect at compile-time
+// whether the LeakSanitizer is potentially available. However, just because the
+// LeakSanitizer is available does not mean it is active. Use the
+// always-available run-time interface in //absl/debugging/leak_check.h for
+// interacting with LeakSanitizer.
+#ifdef ABSL_HAVE_LEAK_SANITIZER
+#error "ABSL_HAVE_LEAK_SANITIZER cannot be directly set."
+#elif defined(LEAK_SANITIZER)
+// GCC provides no method for detecting the presense of the standalone
+// LeakSanitizer (-fsanitize=leak), so GCC users of -fsanitize=leak should also
+// use -DLEAK_SANITIZER.
+#define ABSL_HAVE_LEAK_SANITIZER 1
+// Clang standalone LeakSanitizer (-fsanitize=leak)
+#elif ABSL_HAVE_FEATURE(leak_sanitizer)
+#define ABSL_HAVE_LEAK_SANITIZER 1
+#elif defined(ABSL_HAVE_ADDRESS_SANITIZER)
+// GCC or Clang using the LeakSanitizer integrated into AddressSanitizer.
+#define ABSL_HAVE_LEAK_SANITIZER 1
+#endif
+
+// ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
+//
+// Class template argument deduction is a language feature added in C++17.
+#ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
+#error "ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION cannot be directly set."
+#elif defined(__cpp_deduction_guides)
+#define ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
+#endif
+
+// ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+//
+// Prior to C++17, static constexpr variables defined in classes required a
+// separate definition outside of the class body, for example:
+//
+// class Foo {
+//   static constexpr int kBar = 0;
+// };
+// constexpr int Foo::kBar;
+//
+// In C++17, these variables defined in classes are considered inline variables,
+// and the extra declaration is redundant. Since some compilers warn on the
+// extra declarations, ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL can be used
+// conditionally ignore them:
+//
+// #ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+// constexpr int Foo::kBar;
+// #endif
+#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \
+    ABSL_INTERNAL_CPLUSPLUS_LANG < 201703L
+#define ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL 1
+#endif
+
+// `ABSL_INTERNAL_HAS_RTTI` determines whether abseil is being compiled with
+// RTTI support.
+#ifdef ABSL_INTERNAL_HAS_RTTI
+#error ABSL_INTERNAL_HAS_RTTI cannot be directly set
+#elif !defined(__GNUC__) || defined(__GXX_RTTI)
+#define ABSL_INTERNAL_HAS_RTTI 1
+#endif  // !defined(__GNUC__) || defined(__GXX_RTTI)
+
+// ABSL_INTERNAL_HAVE_SSE is used for compile-time detection of SSE support.
+// See https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html for an overview of
+// which architectures support the various x86 instruction sets.
+#ifdef ABSL_INTERNAL_HAVE_SSE
+#error ABSL_INTERNAL_HAVE_SSE cannot be directly set
+#elif defined(__SSE__)
+#define ABSL_INTERNAL_HAVE_SSE 1
+#elif defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1)
+// MSVC only defines _M_IX86_FP for x86 32-bit code, and _M_IX86_FP >= 1
+// indicates that at least SSE was targeted with the /arch:SSE option.
+// All x86-64 processors support SSE, so support can be assumed.
+// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
+#define ABSL_INTERNAL_HAVE_SSE 1
+#endif
+
+// ABSL_INTERNAL_HAVE_SSE2 is used for compile-time detection of SSE2 support.
+// See https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html for an overview of
+// which architectures support the various x86 instruction sets.
+#ifdef ABSL_INTERNAL_HAVE_SSE2
+#error ABSL_INTERNAL_HAVE_SSE2 cannot be directly set
+#elif defined(__SSE2__)
+#define ABSL_INTERNAL_HAVE_SSE2 1
+#elif defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
+// MSVC only defines _M_IX86_FP for x86 32-bit code, and _M_IX86_FP >= 2
+// indicates that at least SSE2 was targeted with the /arch:SSE2 option.
+// All x86-64 processors support SSE2, so support can be assumed.
+// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
+#define ABSL_INTERNAL_HAVE_SSE2 1
+#endif
+
+// ABSL_INTERNAL_HAVE_SSSE3 is used for compile-time detection of SSSE3 support.
+// See https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html for an overview of
+// which architectures support the various x86 instruction sets.
+//
+// MSVC does not have a mode that targets SSSE3 at compile-time. To use SSSE3
+// with MSVC requires either assuming that the code will only every run on CPUs
+// that support SSSE3, otherwise __cpuid() can be used to detect support at
+// runtime and fallback to a non-SSSE3 implementation when SSSE3 is unsupported
+// by the CPU.
+#ifdef ABSL_INTERNAL_HAVE_SSSE3
+#error ABSL_INTERNAL_HAVE_SSSE3 cannot be directly set
+#elif defined(__SSSE3__)
+#define ABSL_INTERNAL_HAVE_SSSE3 1
+#endif
+
+// ABSL_INTERNAL_HAVE_ARM_NEON is used for compile-time detection of NEON (ARM
+// SIMD).
+#ifdef ABSL_INTERNAL_HAVE_ARM_NEON
+#error ABSL_INTERNAL_HAVE_ARM_NEON cannot be directly set
+#elif defined(__ARM_NEON)
+#define ABSL_INTERNAL_HAVE_ARM_NEON 1
+#endif
+
+#endif  // ABSL_BASE_CONFIG_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/const_init.h b/CAPI/cpp/grpc/include/absl/base/const_init.h
new file mode 100644
index 0000000..16520b6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/const_init.h
@@ -0,0 +1,76 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// kConstInit
+// -----------------------------------------------------------------------------
+//
+// A constructor tag used to mark an object as safe for use as a global
+// variable, avoiding the usual lifetime issues that can affect globals.
+
+#ifndef ABSL_BASE_CONST_INIT_H_
+#define ABSL_BASE_CONST_INIT_H_
+
+#include "absl/base/config.h"
+
+// In general, objects with static storage duration (such as global variables)
+// can trigger tricky object lifetime situations.  Attempting to access them
+// from the constructors or destructors of other global objects can result in
+// undefined behavior, unless their constructors and destructors are designed
+// with this issue in mind.
+//
+// The normal way to deal with this issue in C++11 is to use constant
+// initialization and trivial destructors.
+//
+// Constant initialization is guaranteed to occur before any other code
+// executes.  Constructors that are declared 'constexpr' are eligible for
+// constant initialization.  You can annotate a variable declaration with the
+// ABSL_CONST_INIT macro to express this intent.  For compilers that support
+// it, this annotation will cause a compilation error for declarations that
+// aren't subject to constant initialization (perhaps because a runtime value
+// was passed as a constructor argument).
+//
+// On program shutdown, lifetime issues can be avoided on global objects by
+// ensuring that they contain  trivial destructors.  A class has a trivial
+// destructor unless it has a user-defined destructor, a virtual method or base
+// class, or a data member or base class with a non-trivial destructor of its
+// own.  Objects with static storage duration and a trivial destructor are not
+// cleaned up on program shutdown, and are thus safe to access from other code
+// running during shutdown.
+//
+// For a few core Abseil classes, we make a best effort to allow for safe global
+// instances, even though these classes have non-trivial destructors.  These
+// objects can be created with the absl::kConstInit tag.  For example:
+//   ABSL_CONST_INIT absl::Mutex global_mutex(absl::kConstInit);
+//
+// The line above declares a global variable of type absl::Mutex which can be
+// accessed at any point during startup or shutdown.  global_mutex's destructor
+// will still run, but will not invalidate the object.  Note that C++ specifies
+// that accessing an object after its destructor has run results in undefined
+// behavior, but this pattern works on the toolchains we support.
+//
+// The absl::kConstInit tag should only be used to define objects with static
+// or thread_local storage duration.
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+enum ConstInitType {
+  kConstInit,
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_CONST_INIT_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/dynamic_annotations.h b/CAPI/cpp/grpc/include/absl/base/dynamic_annotations.h
new file mode 100644
index 0000000..3ea7c15
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/dynamic_annotations.h
@@ -0,0 +1,471 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// This file defines dynamic annotations for use with dynamic analysis tool
+// such as valgrind, PIN, etc.
+//
+// Dynamic annotation is a source code annotation that affects the generated
+// code (that is, the annotation is not a comment). Each such annotation is
+// attached to a particular instruction and/or to a particular object (address)
+// in the program.
+//
+// The annotations that should be used by users are macros in all upper-case
+// (e.g., ABSL_ANNOTATE_THREAD_NAME).
+//
+// Actual implementation of these macros may differ depending on the dynamic
+// analysis tool being used.
+//
+// This file supports the following configurations:
+// - Dynamic Annotations enabled (with static thread-safety warnings disabled).
+//   In this case, macros expand to functions implemented by Thread Sanitizer,
+//   when building with TSan. When not provided an external implementation,
+//   dynamic_annotations.cc provides no-op implementations.
+//
+// - Static Clang thread-safety warnings enabled.
+//   When building with a Clang compiler that supports thread-safety warnings,
+//   a subset of annotations can be statically-checked at compile-time. We
+//   expand these macros to static-inline functions that can be analyzed for
+//   thread-safety, but afterwards elided when building the final binary.
+//
+// - All annotations are disabled.
+//   If neither Dynamic Annotations nor Clang thread-safety warnings are
+//   enabled, then all annotation-macros expand to empty.
+
+#ifndef ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
+#define ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
+
+#include <stddef.h>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#ifdef __cplusplus
+#include "absl/base/macros.h"
+#endif
+
+// TODO(rogeeff): Remove after the backward compatibility period.
+#include "absl/base/internal/dynamic_annotations.h"  // IWYU pragma: export
+
+// -------------------------------------------------------------------------
+// Decide which features are enabled.
+
+#ifdef ABSL_HAVE_THREAD_SANITIZER
+
+#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1
+#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1
+#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
+#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 1
+
+#else
+
+#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0
+#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0
+#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 0
+
+// Clang provides limited support for static thread-safety analysis through a
+// feature called Annotalysis. We configure macro-definitions according to
+// whether Annotalysis support is available. When running in opt-mode, GCC
+// will issue a warning, if these attributes are compiled. Only include them
+// when compiling using Clang.
+
+#if defined(__clang__)
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 1
+#if !defined(SWIG)
+#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
+#endif
+#else
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
+#endif
+
+// Read/write annotations are enabled in Annotalysis mode; disabled otherwise.
+#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \
+  ABSL_INTERNAL_ANNOTALYSIS_ENABLED
+
+#endif  // ABSL_HAVE_THREAD_SANITIZER
+
+#ifdef __cplusplus
+#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
+#define ABSL_INTERNAL_END_EXTERN_C }  // extern "C"
+#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
+#define ABSL_INTERNAL_STATIC_INLINE inline
+#else
+#define ABSL_INTERNAL_BEGIN_EXTERN_C  // empty
+#define ABSL_INTERNAL_END_EXTERN_C    // empty
+#define ABSL_INTERNAL_GLOBAL_SCOPED(F) F
+#define ABSL_INTERNAL_STATIC_INLINE static inline
+#endif
+
+// -------------------------------------------------------------------------
+// Define race annotations.
+
+#if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
+// Some of the symbols used in this section (e.g. AnnotateBenignRaceSized) are
+// defined by the compiler-based santizer implementation, not by the Abseil
+// library. Therefore they do not use ABSL_INTERNAL_C_SYMBOL.
+
+// -------------------------------------------------------------
+// Annotations that suppress errors. It is usually better to express the
+// program's synchronization using the other annotations, but these can be used
+// when all else fails.
+
+// Report that we may have a benign race at `pointer`, with size
+// "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the
+// point where `pointer` has been allocated, preferably close to the point
+// where the race happens. See also ABSL_ANNOTATE_BENIGN_RACE_STATIC.
+#define ABSL_ANNOTATE_BENIGN_RACE(pointer, description) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)  \
+  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
+
+// Same as ABSL_ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
+// the memory range [`address`, `address`+`size`).
+#define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)              \
+  (__FILE__, __LINE__, address, size, description)
+
+// Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads.
+// This annotation could be useful if you want to skip expensive race analysis
+// during some period of program execution, e.g. during initialization.
+#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)        \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
+  (__FILE__, __LINE__, enable)
+
+// -------------------------------------------------------------
+// Annotations useful for debugging.
+
+// Report the current thread `name` to a race detector.
+#define ABSL_ANNOTATE_THREAD_NAME(name) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
+
+// -------------------------------------------------------------
+// Annotations useful when implementing locks. They are not normally needed by
+// modules that merely use locks. The `lock` argument is a pointer to the lock
+// object.
+
+// Report that a lock has been created at address `lock`.
+#define ABSL_ANNOTATE_RWLOCK_CREATE(lock) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
+
+// Report that a linker initialized lock has been created at address `lock`.
+#ifdef ABSL_HAVE_THREAD_SANITIZER
+#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)          \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
+  (__FILE__, __LINE__, lock)
+#else
+#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock) \
+  ABSL_ANNOTATE_RWLOCK_CREATE(lock)
+#endif
+
+// Report that the lock at address `lock` is about to be destroyed.
+#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
+
+// Report that the lock at address `lock` has been acquired.
+// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
+#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)     \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \
+  (__FILE__, __LINE__, lock, is_w)
+
+// Report that the lock at address `lock` is about to be released.
+// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
+#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)     \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
+  (__FILE__, __LINE__, lock, is_w)
+
+// Apply ABSL_ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
+#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)      \
+  namespace {                                                          \
+  class static_var##_annotator {                                       \
+   public:                                                             \
+    static_var##_annotator() {                                         \
+      ABSL_ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \
+                                      #static_var ": " description);   \
+    }                                                                  \
+  };                                                                   \
+  static static_var##_annotator the##static_var##_annotator;           \
+  }  // namespace
+
+// Function prototypes of annotations provided by the compiler-based sanitizer
+// implementation.
+ABSL_INTERNAL_BEGIN_EXTERN_C
+void AnnotateRWLockCreate(const char* file, int line,
+                          const volatile void* lock);
+void AnnotateRWLockCreateStatic(const char* file, int line,
+                                const volatile void* lock);
+void AnnotateRWLockDestroy(const char* file, int line,
+                           const volatile void* lock);
+void AnnotateRWLockAcquired(const char* file, int line,
+                            const volatile void* lock, long is_w);  // NOLINT
+void AnnotateRWLockReleased(const char* file, int line,
+                            const volatile void* lock, long is_w);  // NOLINT
+void AnnotateBenignRace(const char* file, int line,
+                        const volatile void* address, const char* description);
+void AnnotateBenignRaceSized(const char* file, int line,
+                             const volatile void* address, size_t size,
+                             const char* description);
+void AnnotateThreadName(const char* file, int line, const char* name);
+void AnnotateEnableRaceDetection(const char* file, int line, int enable);
+ABSL_INTERNAL_END_EXTERN_C
+
+#else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
+
+#define ABSL_ANNOTATE_RWLOCK_CREATE(lock)                            // empty
+#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)                     // empty
+#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock)                           // empty
+#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                    // empty
+#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)                    // empty
+#define ABSL_ANNOTATE_BENIGN_RACE(address, description)              // empty
+#define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description)  // empty
+#define ABSL_ANNOTATE_THREAD_NAME(name)                              // empty
+#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)                  // empty
+#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)    // empty
+
+#endif  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
+
+// -------------------------------------------------------------------------
+// Define memory annotations.
+
+#ifdef ABSL_HAVE_MEMORY_SANITIZER
+
+#include <sanitizer/msan_interface.h>
+
+#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
+  __msan_unpoison(address, size)
+
+#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
+  __msan_allocated_memory(address, size)
+
+#else  // !defined(ABSL_HAVE_MEMORY_SANITIZER)
+
+// TODO(rogeeff): remove this branch
+#ifdef ABSL_HAVE_THREAD_SANITIZER
+#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
+  do {                                                     \
+    (void)(address);                                       \
+    (void)(size);                                          \
+  } while (0)
+#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
+  do {                                                       \
+    (void)(address);                                         \
+    (void)(size);                                            \
+  } while (0)
+#else
+
+#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty
+#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty
+
+#endif
+
+#endif  // ABSL_HAVE_MEMORY_SANITIZER
+
+// -------------------------------------------------------------------------
+// Define IGNORE_READS_BEGIN/_END attributes.
+
+#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+
+#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
+  __attribute((exclusive_lock_function("*")))
+#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
+  __attribute((unlock_function("*")))
+
+#else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+
+#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty
+#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty
+
+#endif  // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+
+// -------------------------------------------------------------------------
+// Define IGNORE_READS_BEGIN/_END annotations.
+
+#if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1
+// Some of the symbols used in this section (e.g. AnnotateIgnoreReadsBegin) are
+// defined by the compiler-based implementation, not by the Abseil
+// library. Therefore they do not use ABSL_INTERNAL_C_SYMBOL.
+
+// Request the analysis tool to ignore all reads in the current thread until
+// ABSL_ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey
+// reads, while still checking other reads and all writes.
+// See also ABSL_ANNOTATE_UNPROTECTED_READ.
+#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()              \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin) \
+  (__FILE__, __LINE__)
+
+// Stop ignoring reads.
+#define ABSL_ANNOTATE_IGNORE_READS_END()              \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \
+  (__FILE__, __LINE__)
+
+// Function prototypes of annotations provided by the compiler-based sanitizer
+// implementation.
+ABSL_INTERNAL_BEGIN_EXTERN_C
+void AnnotateIgnoreReadsBegin(const char* file, int line)
+    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE;
+void AnnotateIgnoreReadsEnd(const char* file,
+                            int line) ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE;
+ABSL_INTERNAL_END_EXTERN_C
+
+#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
+
+// When Annotalysis is enabled without Dynamic Annotations, the use of
+// static-inline functions allows the annotations to be read at compile-time,
+// while still letting the compiler elide the functions from the final build.
+//
+// TODO(delesley) -- The exclusive lock here ignores writes as well, but
+// allows IGNORE_READS_AND_WRITES to work properly.
+
+#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                          \
+  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
+      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
+  ()
+
+#define ABSL_ANNOTATE_IGNORE_READS_END()                          \
+  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
+      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
+  ()
+
+ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
+    AbslInternalAnnotateIgnoreReadsBegin)()
+    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE {}
+
+ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
+    AbslInternalAnnotateIgnoreReadsEnd)()
+    ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE {}
+
+#else
+
+#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()  // empty
+#define ABSL_ANNOTATE_IGNORE_READS_END()    // empty
+
+#endif
+
+// -------------------------------------------------------------------------
+// Define IGNORE_WRITES_BEGIN/_END annotations.
+
+#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
+
+// Similar to ABSL_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
+#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN() \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
+
+// Stop ignoring writes.
+#define ABSL_ANNOTATE_IGNORE_WRITES_END() \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
+
+// Function prototypes of annotations provided by the compiler-based sanitizer
+// implementation.
+ABSL_INTERNAL_BEGIN_EXTERN_C
+void AnnotateIgnoreWritesBegin(const char* file, int line);
+void AnnotateIgnoreWritesEnd(const char* file, int line);
+ABSL_INTERNAL_END_EXTERN_C
+
+#else
+
+#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN()  // empty
+#define ABSL_ANNOTATE_IGNORE_WRITES_END()    // empty
+
+#endif
+
+// -------------------------------------------------------------------------
+// Define the ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
+// primitive annotations defined above.
+//
+//     Instead of doing
+//        ABSL_ANNOTATE_IGNORE_READS_BEGIN();
+//        ... = x;
+//        ABSL_ANNOTATE_IGNORE_READS_END();
+//     one can use
+//        ... = ABSL_ANNOTATE_UNPROTECTED_READ(x);
+
+#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
+
+// Start ignoring all memory accesses (both reads and writes).
+#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
+  do {                                                \
+    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
+    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
+  } while (0)
+
+// Stop ignoring both reads and writes.
+#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END() \
+  do {                                              \
+    ABSL_ANNOTATE_IGNORE_WRITES_END();              \
+    ABSL_ANNOTATE_IGNORE_READS_END();               \
+  } while (0)
+
+#ifdef __cplusplus
+// ABSL_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
+#define ABSL_ANNOTATE_UNPROTECTED_READ(x) \
+  absl::base_internal::AnnotateUnprotectedRead(x)
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+template <typename T>
+inline T AnnotateUnprotectedRead(const volatile T& x) {  // NOLINT
+  ABSL_ANNOTATE_IGNORE_READS_BEGIN();
+  T res = x;
+  ABSL_ANNOTATE_IGNORE_READS_END();
+  return res;
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif
+
+#else
+
+#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()  // empty
+#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END()    // empty
+#define ABSL_ANNOTATE_UNPROTECTED_READ(x) (x)
+
+#endif
+
+// -------------------------------------------------------------------------
+// Address sanitizer annotations
+
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+// Describe the current state of a contiguous container such as e.g.
+// std::vector or std::string. For more details see
+// sanitizer/common_interface_defs.h, which is provided by the compiler.
+#include <sanitizer/common_interface_defs.h>
+
+#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \
+  __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
+#define ABSL_ADDRESS_SANITIZER_REDZONE(name) \
+  struct {                                   \
+    alignas(8) char x[8];                    \
+  } name
+
+#else
+
+#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)  // empty
+#define ABSL_ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
+
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+
+// -------------------------------------------------------------------------
+// Undefine the macros intended only for this file.
+
+#undef ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_ANNOTALYSIS_ENABLED
+#undef ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_BEGIN_EXTERN_C
+#undef ABSL_INTERNAL_END_EXTERN_C
+#undef ABSL_INTERNAL_STATIC_INLINE
+
+#endif  // ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook.h b/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook.h
new file mode 100644
index 0000000..ae21cd7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook.h
@@ -0,0 +1,200 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
+#define ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
+
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 0
+#else
+#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 1
+#endif
+
+#if defined(_MSC_VER)
+#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
+#else
+#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+template <typename T>
+class AtomicHook;
+
+// To workaround AtomicHook not being constant-initializable on some platforms,
+// prefer to annotate instances with `ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES`
+// instead of `ABSL_CONST_INIT`.
+#if ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
+#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_CONST_INIT
+#else
+#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
+#endif
+
+// `AtomicHook` is a helper class, templatized on a raw function pointer type,
+// for implementing Abseil customization hooks.  It is a callable object that
+// dispatches to the registered hook.  Objects of type `AtomicHook` must have
+// static or thread storage duration.
+//
+// A default constructed object performs a no-op (and returns a default
+// constructed object) if no hook has been registered.
+//
+// Hooks can be pre-registered via constant initialization, for example:
+//
+// ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void(*)()>
+//     my_hook(DefaultAction);
+//
+// and then changed at runtime via a call to `Store()`.
+//
+// Reads and writes guarantee memory_order_acquire/memory_order_release
+// semantics.
+template <typename ReturnType, typename... Args>
+class AtomicHook<ReturnType (*)(Args...)> {
+ public:
+  using FnPtr = ReturnType (*)(Args...);
+
+  // Constructs an object that by default performs a no-op (and
+  // returns a default constructed object) when no hook as been registered.
+  constexpr AtomicHook() : AtomicHook(DummyFunction) {}
+
+  // Constructs an object that by default dispatches to/returns the
+  // pre-registered default_fn when no hook has been registered at runtime.
+#if ABSL_HAVE_WORKING_ATOMIC_POINTER && ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
+  explicit constexpr AtomicHook(FnPtr default_fn)
+      : hook_(default_fn), default_fn_(default_fn) {}
+#elif ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
+  explicit constexpr AtomicHook(FnPtr default_fn)
+      : hook_(kUninitialized), default_fn_(default_fn) {}
+#else
+  // As of January 2020, on all known versions of MSVC this constructor runs in
+  // the global constructor sequence.  If `Store()` is called by a dynamic
+  // initializer, we want to preserve the value, even if this constructor runs
+  // after the call to `Store()`.  If not, `hook_` will be
+  // zero-initialized by the linker and we have no need to set it.
+  // https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html
+  explicit constexpr AtomicHook(FnPtr default_fn)
+      : /* hook_(deliberately omitted), */ default_fn_(default_fn) {
+    static_assert(kUninitialized == 0, "here we rely on zero-initialization");
+  }
+#endif
+
+  // Stores the provided function pointer as the value for this hook.
+  //
+  // This is intended to be called once.  Multiple calls are legal only if the
+  // same function pointer is provided for each call.  The store is implemented
+  // as a memory_order_release operation, and read accesses are implemented as
+  // memory_order_acquire.
+  void Store(FnPtr fn) {
+    bool success = DoStore(fn);
+    static_cast<void>(success);
+    assert(success);
+  }
+
+  // Invokes the registered callback.  If no callback has yet been registered, a
+  // default-constructed object of the appropriate type is returned instead.
+  template <typename... CallArgs>
+  ReturnType operator()(CallArgs&&... args) const {
+    return DoLoad()(std::forward<CallArgs>(args)...);
+  }
+
+  // Returns the registered callback, or nullptr if none has been registered.
+  // Useful if client code needs to conditionalize behavior based on whether a
+  // callback was registered.
+  //
+  // Note that atomic_hook.Load()() and atomic_hook() have different semantics:
+  // operator()() will perform a no-op if no callback was registered, while
+  // Load()() will dereference a null function pointer.  Prefer operator()() to
+  // Load()() unless you must conditionalize behavior on whether a hook was
+  // registered.
+  FnPtr Load() const {
+    FnPtr ptr = DoLoad();
+    return (ptr == DummyFunction) ? nullptr : ptr;
+  }
+
+ private:
+  static ReturnType DummyFunction(Args...) {
+    return ReturnType();
+  }
+
+  // Current versions of MSVC (as of September 2017) have a broken
+  // implementation of std::atomic<T*>:  Its constructor attempts to do the
+  // equivalent of a reinterpret_cast in a constexpr context, which is not
+  // allowed.
+  //
+  // This causes an issue when building with LLVM under Windows.  To avoid this,
+  // we use a less-efficient, intptr_t-based implementation on Windows.
+#if ABSL_HAVE_WORKING_ATOMIC_POINTER
+  // Return the stored value, or DummyFunction if no value has been stored.
+  FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }
+
+  // Store the given value.  Returns false if a different value was already
+  // stored to this object.
+  bool DoStore(FnPtr fn) {
+    assert(fn);
+    FnPtr expected = default_fn_;
+    const bool store_succeeded = hook_.compare_exchange_strong(
+        expected, fn, std::memory_order_acq_rel, std::memory_order_acquire);
+    const bool same_value_already_stored = (expected == fn);
+    return store_succeeded || same_value_already_stored;
+  }
+
+  std::atomic<FnPtr> hook_;
+#else  // !ABSL_HAVE_WORKING_ATOMIC_POINTER
+  // Use a sentinel value unlikely to be the address of an actual function.
+  static constexpr intptr_t kUninitialized = 0;
+
+  static_assert(sizeof(intptr_t) >= sizeof(FnPtr),
+                "intptr_t can't contain a function pointer");
+
+  FnPtr DoLoad() const {
+    const intptr_t value = hook_.load(std::memory_order_acquire);
+    if (value == kUninitialized) {
+      return default_fn_;
+    }
+    return reinterpret_cast<FnPtr>(value);
+  }
+
+  bool DoStore(FnPtr fn) {
+    assert(fn);
+    const auto value = reinterpret_cast<intptr_t>(fn);
+    intptr_t expected = kUninitialized;
+    const bool store_succeeded = hook_.compare_exchange_strong(
+        expected, value, std::memory_order_acq_rel, std::memory_order_acquire);
+    const bool same_value_already_stored = (expected == value);
+    return store_succeeded || same_value_already_stored;
+  }
+
+  std::atomic<intptr_t> hook_;
+#endif
+
+  const FnPtr default_fn_;
+};
+
+#undef ABSL_HAVE_WORKING_ATOMIC_POINTER
+#undef ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook_test_helper.h b/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook_test_helper.h
new file mode 100644
index 0000000..3e72b49
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook_test_helper.h
@@ -0,0 +1,34 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
+#define ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
+
+#include "absl/base/internal/atomic_hook.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace atomic_hook_internal {
+
+using VoidF = void (*)();
+extern absl::base_internal::AtomicHook<VoidF> func;
+extern int default_func_calls;
+void DefaultFunc();
+void RegisterFunc(VoidF func);
+
+}  // namespace atomic_hook_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/cycleclock.h b/CAPI/cpp/grpc/include/absl/base/internal/cycleclock.h
new file mode 100644
index 0000000..9704e38
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/cycleclock.h
@@ -0,0 +1,159 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// -----------------------------------------------------------------------------
+// File: cycleclock.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a `CycleClock`, which yields the value and frequency
+// of a cycle counter that increments at a rate that is approximately constant.
+//
+// NOTE:
+//
+// The cycle counter frequency is not necessarily related to the core clock
+// frequency and should not be treated as such. That is, `CycleClock` cycles are
+// not necessarily "CPU cycles" and code should not rely on that behavior, even
+// if experimentally observed.
+//
+// An arbitrary offset may have been added to the counter at power on.
+//
+// On some platforms, the rate and offset of the counter may differ
+// slightly when read from different CPUs of a multiprocessor. Usually,
+// we try to ensure that the operating system adjusts values periodically
+// so that values agree approximately.   If you need stronger guarantees,
+// consider using alternate interfaces.
+//
+// The CPU is not required to maintain the ordering of a cycle counter read
+// with respect to surrounding instructions.
+
+#ifndef ABSL_BASE_INTERNAL_CYCLECLOCK_H_
+#define ABSL_BASE_INTERNAL_CYCLECLOCK_H_
+
+#include <atomic>
+#include <cstdint>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/unscaledcycleclock.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+using CycleClockSourceFunc = int64_t (*)();
+
+// -----------------------------------------------------------------------------
+// CycleClock
+// -----------------------------------------------------------------------------
+class CycleClock {
+ public:
+  // CycleClock::Now()
+  //
+  // Returns the value of a cycle counter that counts at a rate that is
+  // approximately constant.
+  static int64_t Now();
+
+  // CycleClock::Frequency()
+  //
+  // Returns the amount by which `CycleClock::Now()` increases per second. Note
+  // that this value may not necessarily match the core CPU clock frequency.
+  static double Frequency();
+
+ private:
+#if ABSL_USE_UNSCALED_CYCLECLOCK
+  static CycleClockSourceFunc LoadCycleClockSource();
+
+#ifdef NDEBUG
+#ifdef ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+  // Not debug mode and the UnscaledCycleClock frequency is the CPU
+  // frequency.  Scale the CycleClock to prevent overflow if someone
+  // tries to represent the time as cycles since the Unix epoch.
+  static constexpr int32_t kShift = 1;
+#else
+  // Not debug mode and the UnscaledCycleClock isn't operating at the
+  // raw CPU frequency. There is no need to do any scaling, so don't
+  // needlessly sacrifice precision.
+  static constexpr int32_t kShift = 0;
+#endif
+#else   // NDEBUG
+  // In debug mode use a different shift to discourage depending on a
+  // particular shift value.
+  static constexpr int32_t kShift = 2;
+#endif  // NDEBUG
+
+  static constexpr double kFrequencyScale = 1.0 / (1 << kShift);
+  ABSL_CONST_INIT static std::atomic<CycleClockSourceFunc> cycle_clock_source_;
+#endif  //  ABSL_USE_UNSCALED_CYCLECLOC
+
+  CycleClock() = delete;  // no instances
+  CycleClock(const CycleClock&) = delete;
+  CycleClock& operator=(const CycleClock&) = delete;
+
+  friend class CycleClockSource;
+};
+
+class CycleClockSource {
+ private:
+  // CycleClockSource::Register()
+  //
+  // Register a function that provides an alternate source for the unscaled CPU
+  // cycle count value. The source function must be async signal safe, must not
+  // call CycleClock::Now(), and must have a frequency that matches that of the
+  // unscaled clock used by CycleClock. A nullptr value resets CycleClock to use
+  // the default source.
+  static void Register(CycleClockSourceFunc source);
+};
+
+#if ABSL_USE_UNSCALED_CYCLECLOCK
+
+inline CycleClockSourceFunc CycleClock::LoadCycleClockSource() {
+#if !defined(__x86_64__)
+  // Optimize for the common case (no callback) by first doing a relaxed load;
+  // this is significantly faster on non-x86 platforms.
+  if (cycle_clock_source_.load(std::memory_order_relaxed) == nullptr) {
+    return nullptr;
+  }
+#endif  // !defined(__x86_64__)
+
+  // This corresponds to the store(std::memory_order_release) in
+  // CycleClockSource::Register, and makes sure that any updates made prior to
+  // registering the callback are visible to this thread before the callback
+  // is invoked.
+  return cycle_clock_source_.load(std::memory_order_acquire);
+}
+
+// Accessing globals in inlined code in Window DLLs is problematic.
+#ifndef _WIN32
+inline int64_t CycleClock::Now() {
+  auto fn = LoadCycleClockSource();
+  if (fn == nullptr) {
+    return base_internal::UnscaledCycleClock::Now() >> kShift;
+  }
+  return fn() >> kShift;
+}
+#endif
+
+inline double CycleClock::Frequency() {
+  return kFrequencyScale * base_internal::UnscaledCycleClock::Frequency();
+}
+
+#endif  // ABSL_USE_UNSCALED_CYCLECLOCK
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_CYCLECLOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/direct_mmap.h b/CAPI/cpp/grpc/include/absl/base/internal/direct_mmap.h
new file mode 100644
index 0000000..e492bb0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/direct_mmap.h
@@ -0,0 +1,169 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Functions for directly invoking mmap() via syscall, avoiding the case where
+// mmap() has been locally overridden.
+
+#ifndef ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
+#define ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
+
+#include "absl/base/config.h"
+
+#ifdef ABSL_HAVE_MMAP
+
+#include <sys/mman.h>
+
+#ifdef __linux__
+
+#include <sys/types.h>
+#ifdef __BIONIC__
+#include <sys/syscall.h>
+#else
+#include <syscall.h>
+#endif
+
+#include <linux/unistd.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstdarg>
+#include <cstdint>
+
+#ifdef __mips__
+// Include definitions of the ABI currently in use.
+#if defined(__BIONIC__) || !defined(__GLIBC__)
+// Android doesn't have sgidefs.h, but does have asm/sgidefs.h, which has the
+// definitions we need.
+#include <asm/sgidefs.h>
+#else
+#include <sgidefs.h>
+#endif  // __BIONIC__ || !__GLIBC__
+#endif  // __mips__
+
+// SYS_mmap and SYS_munmap are not defined in Android.
+#ifdef __BIONIC__
+extern "C" void* __mmap2(void*, size_t, int, int, int, size_t);
+#if defined(__NR_mmap) && !defined(SYS_mmap)
+#define SYS_mmap __NR_mmap
+#endif
+#ifndef SYS_munmap
+#define SYS_munmap __NR_munmap
+#endif
+#endif  // __BIONIC__
+
+#if defined(__NR_mmap2) && !defined(SYS_mmap2)
+#define SYS_mmap2 __NR_mmap2
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// Platform specific logic extracted from
+// https://chromium.googlesource.com/linux-syscall-support/+/master/linux_syscall_support.h
+inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
+                        off64_t offset) noexcept {
+#if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \
+    defined(__m68k__) || defined(__sh__) ||                                  \
+    (defined(__hppa__) && !defined(__LP64__)) ||                             \
+    (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) ||                   \
+    (defined(__PPC__) && !defined(__PPC64__)) ||                             \
+    (defined(__riscv) && __riscv_xlen == 32) ||                              \
+    (defined(__s390__) && !defined(__s390x__)) ||                            \
+    (defined(__sparc__) && !defined(__arch64__))
+  // On these architectures, implement mmap with mmap2.
+  static int pagesize = 0;
+  if (pagesize == 0) {
+#if defined(__wasm__) || defined(__asmjs__)
+    pagesize = getpagesize();
+#else
+    pagesize = sysconf(_SC_PAGESIZE);
+#endif
+  }
+  if (offset < 0 || offset % pagesize != 0) {
+    errno = EINVAL;
+    return MAP_FAILED;
+  }
+#ifdef __BIONIC__
+  // SYS_mmap2 has problems on Android API level <= 16.
+  // Workaround by invoking __mmap2() instead.
+  return __mmap2(start, length, prot, flags, fd, offset / pagesize);
+#else
+  return reinterpret_cast<void*>(
+      syscall(SYS_mmap2, start, length, prot, flags, fd,
+              static_cast<off_t>(offset / pagesize)));
+#endif
+#elif defined(__s390x__)
+  // On s390x, mmap() arguments are passed in memory.
+  unsigned long buf[6] = {reinterpret_cast<unsigned long>(start),  // NOLINT
+                          static_cast<unsigned long>(length),      // NOLINT
+                          static_cast<unsigned long>(prot),        // NOLINT
+                          static_cast<unsigned long>(flags),       // NOLINT
+                          static_cast<unsigned long>(fd),          // NOLINT
+                          static_cast<unsigned long>(offset)};     // NOLINT
+  return reinterpret_cast<void*>(syscall(SYS_mmap, buf));
+#elif defined(__x86_64__)
+// The x32 ABI has 32 bit longs, but the syscall interface is 64 bit.
+// We need to explicitly cast to an unsigned 64 bit type to avoid implicit
+// sign extension.  We can't cast pointers directly because those are
+// 32 bits, and gcc will dump ugly warnings about casting from a pointer
+// to an integer of a different size. We also need to make sure __off64_t
+// isn't truncated to 32-bits under x32.
+#define MMAP_SYSCALL_ARG(x) ((uint64_t)(uintptr_t)(x))
+  return reinterpret_cast<void*>(
+      syscall(SYS_mmap, MMAP_SYSCALL_ARG(start), MMAP_SYSCALL_ARG(length),
+              MMAP_SYSCALL_ARG(prot), MMAP_SYSCALL_ARG(flags),
+              MMAP_SYSCALL_ARG(fd), static_cast<uint64_t>(offset)));
+#undef MMAP_SYSCALL_ARG
+#else  // Remaining 64-bit aritectures.
+  static_assert(sizeof(unsigned long) == 8, "Platform is not 64-bit");
+  return reinterpret_cast<void*>(
+      syscall(SYS_mmap, start, length, prot, flags, fd, offset));
+#endif
+}
+
+inline int DirectMunmap(void* start, size_t length) {
+  return static_cast<int>(syscall(SYS_munmap, start, length));
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // !__linux__
+
+// For non-linux platforms where we have mmap, just dispatch directly to the
+// actual mmap()/munmap() methods.
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
+                        off_t offset) {
+  return mmap(start, length, prot, flags, fd, offset);
+}
+
+inline int DirectMunmap(void* start, size_t length) {
+  return munmap(start, length);
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // __linux__
+
+#endif  // ABSL_HAVE_MMAP
+
+#endif  // ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/dynamic_annotations.h b/CAPI/cpp/grpc/include/absl/base/internal/dynamic_annotations.h
new file mode 100644
index 0000000..b23c5ec
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/dynamic_annotations.h
@@ -0,0 +1,398 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// This file defines dynamic annotations for use with dynamic analysis tool
+// such as valgrind, PIN, etc.
+//
+// Dynamic annotation is a source code annotation that affects the generated
+// code (that is, the annotation is not a comment). Each such annotation is
+// attached to a particular instruction and/or to a particular object (address)
+// in the program.
+//
+// The annotations that should be used by users are macros in all upper-case
+// (e.g., ANNOTATE_THREAD_NAME).
+//
+// Actual implementation of these macros may differ depending on the dynamic
+// analysis tool being used.
+//
+// This file supports the following configurations:
+// - Dynamic Annotations enabled (with static thread-safety warnings disabled).
+//   In this case, macros expand to functions implemented by Thread Sanitizer,
+//   when building with TSan. When not provided an external implementation,
+//   dynamic_annotations.cc provides no-op implementations.
+//
+// - Static Clang thread-safety warnings enabled.
+//   When building with a Clang compiler that supports thread-safety warnings,
+//   a subset of annotations can be statically-checked at compile-time. We
+//   expand these macros to static-inline functions that can be analyzed for
+//   thread-safety, but afterwards elided when building the final binary.
+//
+// - All annotations are disabled.
+//   If neither Dynamic Annotations nor Clang thread-safety warnings are
+//   enabled, then all annotation-macros expand to empty.
+
+#ifndef ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
+#define ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
+
+#include <stddef.h>
+
+#include "absl/base/config.h"
+
+// -------------------------------------------------------------------------
+// Decide which features are enabled
+
+#ifndef DYNAMIC_ANNOTATIONS_ENABLED
+#define DYNAMIC_ANNOTATIONS_ENABLED 0
+#endif
+
+#if defined(__clang__) && !defined(SWIG)
+#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
+#endif
+
+#if DYNAMIC_ANNOTATIONS_ENABLED != 0
+
+#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1
+#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1
+#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
+#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 1
+
+#else
+
+#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0
+#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0
+#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 0
+
+// Clang provides limited support for static thread-safety analysis through a
+// feature called Annotalysis. We configure macro-definitions according to
+// whether Annotalysis support is available. When running in opt-mode, GCC
+// will issue a warning, if these attributes are compiled. Only include them
+// when compiling using Clang.
+
+// ANNOTALYSIS_ENABLED == 1 when IGNORE_READ_ATTRIBUTE_ENABLED == 1
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED \
+  defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+// Read/write annotations are enabled in Annotalysis mode; disabled otherwise.
+#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \
+  ABSL_INTERNAL_ANNOTALYSIS_ENABLED
+#endif
+
+// Memory annotations are also made available to LLVM's Memory Sanitizer
+#if defined(ABSL_HAVE_MEMORY_SANITIZER) && !defined(__native_client__)
+#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 1
+#endif
+
+#ifndef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
+#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 0
+#endif
+
+#ifdef __cplusplus
+#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
+#define ABSL_INTERNAL_END_EXTERN_C }  // extern "C"
+#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
+#define ABSL_INTERNAL_STATIC_INLINE inline
+#else
+#define ABSL_INTERNAL_BEGIN_EXTERN_C  // empty
+#define ABSL_INTERNAL_END_EXTERN_C    // empty
+#define ABSL_INTERNAL_GLOBAL_SCOPED(F) F
+#define ABSL_INTERNAL_STATIC_INLINE static inline
+#endif
+
+// -------------------------------------------------------------------------
+// Define race annotations.
+
+#if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
+
+// -------------------------------------------------------------
+// Annotations that suppress errors. It is usually better to express the
+// program's synchronization using the other annotations, but these can be used
+// when all else fails.
+
+// Report that we may have a benign race at `pointer`, with size
+// "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the
+// point where `pointer` has been allocated, preferably close to the point
+// where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC.
+#define ANNOTATE_BENIGN_RACE(pointer, description)     \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized) \
+  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
+
+// Same as ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
+// the memory range [`address`, `address`+`size`).
+#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)         \
+  (__FILE__, __LINE__, address, size, description)
+
+// Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads.
+// This annotation could be useful if you want to skip expensive race analysis
+// during some period of program execution, e.g. during initialization.
+#define ANNOTATE_ENABLE_RACE_DETECTION(enable)             \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
+  (__FILE__, __LINE__, enable)
+
+// -------------------------------------------------------------
+// Annotations useful for debugging.
+
+// Report the current thread `name` to a race detector.
+#define ANNOTATE_THREAD_NAME(name) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
+
+// -------------------------------------------------------------
+// Annotations useful when implementing locks. They are not normally needed by
+// modules that merely use locks. The `lock` argument is a pointer to the lock
+// object.
+
+// Report that a lock has been created at address `lock`.
+#define ANNOTATE_RWLOCK_CREATE(lock) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
+
+// Report that a linker initialized lock has been created at address `lock`.
+#ifdef ABSL_HAVE_THREAD_SANITIZER
+#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)               \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
+  (__FILE__, __LINE__, lock)
+#else
+#define ANNOTATE_RWLOCK_CREATE_STATIC(lock) ANNOTATE_RWLOCK_CREATE(lock)
+#endif
+
+// Report that the lock at address `lock` is about to be destroyed.
+#define ANNOTATE_RWLOCK_DESTROY(lock) \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
+
+// Report that the lock at address `lock` has been acquired.
+// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
+#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)          \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \
+  (__FILE__, __LINE__, lock, is_w)
+
+// Report that the lock at address `lock` is about to be released.
+// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
+#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)          \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
+  (__FILE__, __LINE__, lock, is_w)
+
+// Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
+#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)      \
+  namespace {                                                     \
+  class static_var##_annotator {                                  \
+   public:                                                        \
+    static_var##_annotator() {                                    \
+      ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \
+                                 #static_var ": " description);   \
+    }                                                             \
+  };                                                              \
+  static static_var##_annotator the##static_var##_annotator;      \
+  }  // namespace
+
+#else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
+
+#define ANNOTATE_RWLOCK_CREATE(lock)                            // empty
+#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)                     // empty
+#define ANNOTATE_RWLOCK_DESTROY(lock)                           // empty
+#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                    // empty
+#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)                    // empty
+#define ANNOTATE_BENIGN_RACE(address, description)              // empty
+#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description)  // empty
+#define ANNOTATE_THREAD_NAME(name)                              // empty
+#define ANNOTATE_ENABLE_RACE_DETECTION(enable)                  // empty
+#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)    // empty
+
+#endif  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
+
+// -------------------------------------------------------------------------
+// Define memory annotations.
+
+#if ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 1
+
+#include <sanitizer/msan_interface.h>
+
+#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
+  __msan_unpoison(address, size)
+
+#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
+  __msan_allocated_memory(address, size)
+
+#else  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 0
+
+#if DYNAMIC_ANNOTATIONS_ENABLED == 1
+#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
+  do {                                                \
+    (void)(address);                                  \
+    (void)(size);                                     \
+  } while (0)
+#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
+  do {                                                  \
+    (void)(address);                                    \
+    (void)(size);                                       \
+  } while (0)
+#else
+#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty
+#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty
+#endif
+
+#endif  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
+
+// -------------------------------------------------------------------------
+// Define IGNORE_READS_BEGIN/_END attributes.
+
+#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+
+#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
+  __attribute((exclusive_lock_function("*")))
+#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
+  __attribute((unlock_function("*")))
+
+#else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+
+#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty
+#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty
+
+#endif  // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+
+// -------------------------------------------------------------------------
+// Define IGNORE_READS_BEGIN/_END annotations.
+
+#if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1
+
+// Request the analysis tool to ignore all reads in the current thread until
+// ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey
+// reads, while still checking other reads and all writes.
+// See also ANNOTATE_UNPROTECTED_READ.
+#define ANNOTATE_IGNORE_READS_BEGIN() \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin)(__FILE__, __LINE__)
+
+// Stop ignoring reads.
+#define ANNOTATE_IGNORE_READS_END() \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd)(__FILE__, __LINE__)
+
+#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
+
+// When Annotalysis is enabled without Dynamic Annotations, the use of
+// static-inline functions allows the annotations to be read at compile-time,
+// while still letting the compiler elide the functions from the final build.
+//
+// TODO(delesley) -- The exclusive lock here ignores writes as well, but
+// allows IGNORE_READS_AND_WRITES to work properly.
+
+#define ANNOTATE_IGNORE_READS_BEGIN() \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsBegin)()
+
+#define ANNOTATE_IGNORE_READS_END() \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsEnd)()
+
+#else
+
+#define ANNOTATE_IGNORE_READS_BEGIN()  // empty
+#define ANNOTATE_IGNORE_READS_END()    // empty
+
+#endif
+
+// -------------------------------------------------------------------------
+// Define IGNORE_WRITES_BEGIN/_END annotations.
+
+#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
+
+// Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
+#define ANNOTATE_IGNORE_WRITES_BEGIN() \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
+
+// Stop ignoring writes.
+#define ANNOTATE_IGNORE_WRITES_END() \
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
+
+#else
+
+#define ANNOTATE_IGNORE_WRITES_BEGIN()  // empty
+#define ANNOTATE_IGNORE_WRITES_END()    // empty
+
+#endif
+
+// -------------------------------------------------------------------------
+// Define the ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
+// primitive annotations defined above.
+//
+//     Instead of doing
+//        ANNOTATE_IGNORE_READS_BEGIN();
+//        ... = x;
+//        ANNOTATE_IGNORE_READS_END();
+//     one can use
+//        ... = ANNOTATE_UNPROTECTED_READ(x);
+
+#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
+
+// Start ignoring all memory accesses (both reads and writes).
+#define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
+  do {                                           \
+    ANNOTATE_IGNORE_READS_BEGIN();               \
+    ANNOTATE_IGNORE_WRITES_BEGIN();              \
+  } while (0)
+
+// Stop ignoring both reads and writes.
+#define ANNOTATE_IGNORE_READS_AND_WRITES_END() \
+  do {                                         \
+    ANNOTATE_IGNORE_WRITES_END();              \
+    ANNOTATE_IGNORE_READS_END();               \
+  } while (0)
+
+#ifdef __cplusplus
+// ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
+#define ANNOTATE_UNPROTECTED_READ(x) \
+  absl::base_internal::AnnotateUnprotectedRead(x)
+
+#endif
+
+#else
+
+#define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()  // empty
+#define ANNOTATE_IGNORE_READS_AND_WRITES_END()    // empty
+#define ANNOTATE_UNPROTECTED_READ(x) (x)
+
+#endif
+
+// -------------------------------------------------------------------------
+// Address sanitizer annotations
+
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+// Describe the current state of a contiguous container such as e.g.
+// std::vector or std::string. For more details see
+// sanitizer/common_interface_defs.h, which is provided by the compiler.
+#include <sanitizer/common_interface_defs.h>
+
+#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \
+  __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
+#define ADDRESS_SANITIZER_REDZONE(name)    \
+  struct {                                 \
+    char x[8] __attribute__((aligned(8))); \
+  } name
+
+#else
+
+#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)
+#define ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
+
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+
+// -------------------------------------------------------------------------
+// Undefine the macros intended only for this file.
+
+#undef ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_ANNOTALYSIS_ENABLED
+#undef ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED
+#undef ABSL_INTERNAL_BEGIN_EXTERN_C
+#undef ABSL_INTERNAL_END_EXTERN_C
+#undef ABSL_INTERNAL_STATIC_INLINE
+
+#endif  // ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/endian.h b/CAPI/cpp/grpc/include/absl/base/internal/endian.h
new file mode 100644
index 0000000..50747d7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/endian.h
@@ -0,0 +1,282 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_BASE_INTERNAL_ENDIAN_H_
+#define ABSL_BASE_INTERNAL_ENDIAN_H_
+
+#include <cstdint>
+#include <cstdlib>
+
+#include "absl/base/casts.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/unaligned_access.h"
+#include "absl/base/port.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+inline uint64_t gbswap_64(uint64_t host_int) {
+#if ABSL_HAVE_BUILTIN(__builtin_bswap64) || defined(__GNUC__)
+  return __builtin_bswap64(host_int);
+#elif defined(_MSC_VER)
+  return _byteswap_uint64(host_int);
+#else
+  return (((host_int & uint64_t{0xFF}) << 56) |
+          ((host_int & uint64_t{0xFF00}) << 40) |
+          ((host_int & uint64_t{0xFF0000}) << 24) |
+          ((host_int & uint64_t{0xFF000000}) << 8) |
+          ((host_int & uint64_t{0xFF00000000}) >> 8) |
+          ((host_int & uint64_t{0xFF0000000000}) >> 24) |
+          ((host_int & uint64_t{0xFF000000000000}) >> 40) |
+          ((host_int & uint64_t{0xFF00000000000000}) >> 56));
+#endif
+}
+
+inline uint32_t gbswap_32(uint32_t host_int) {
+#if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)
+  return __builtin_bswap32(host_int);
+#elif defined(_MSC_VER)
+  return _byteswap_ulong(host_int);
+#else
+  return (((host_int & uint32_t{0xFF}) << 24) |
+          ((host_int & uint32_t{0xFF00}) << 8) |
+          ((host_int & uint32_t{0xFF0000}) >> 8) |
+          ((host_int & uint32_t{0xFF000000}) >> 24));
+#endif
+}
+
+inline uint16_t gbswap_16(uint16_t host_int) {
+#if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)
+  return __builtin_bswap16(host_int);
+#elif defined(_MSC_VER)
+  return _byteswap_ushort(host_int);
+#else
+  return (((host_int & uint16_t{0xFF}) << 8) |
+          ((host_int & uint16_t{0xFF00}) >> 8));
+#endif
+}
+
+#ifdef ABSL_IS_LITTLE_ENDIAN
+
+// Portable definitions for htonl (host-to-network) and friends on little-endian
+// architectures.
+inline uint16_t ghtons(uint16_t x) { return gbswap_16(x); }
+inline uint32_t ghtonl(uint32_t x) { return gbswap_32(x); }
+inline uint64_t ghtonll(uint64_t x) { return gbswap_64(x); }
+
+#elif defined ABSL_IS_BIG_ENDIAN
+
+// Portable definitions for htonl (host-to-network) etc on big-endian
+// architectures. These definitions are simpler since the host byte order is the
+// same as network byte order.
+inline uint16_t ghtons(uint16_t x) { return x; }
+inline uint32_t ghtonl(uint32_t x) { return x; }
+inline uint64_t ghtonll(uint64_t x) { return x; }
+
+#else
+#error \
+    "Unsupported byte order: Either ABSL_IS_BIG_ENDIAN or " \
+       "ABSL_IS_LITTLE_ENDIAN must be defined"
+#endif  // byte order
+
+inline uint16_t gntohs(uint16_t x) { return ghtons(x); }
+inline uint32_t gntohl(uint32_t x) { return ghtonl(x); }
+inline uint64_t gntohll(uint64_t x) { return ghtonll(x); }
+
+// Utilities to convert numbers between the current hosts's native byte
+// order and little-endian byte order
+//
+// Load/Store methods are alignment safe
+namespace little_endian {
+// Conversion functions.
+#ifdef ABSL_IS_LITTLE_ENDIAN
+
+inline uint16_t FromHost16(uint16_t x) { return x; }
+inline uint16_t ToHost16(uint16_t x) { return x; }
+
+inline uint32_t FromHost32(uint32_t x) { return x; }
+inline uint32_t ToHost32(uint32_t x) { return x; }
+
+inline uint64_t FromHost64(uint64_t x) { return x; }
+inline uint64_t ToHost64(uint64_t x) { return x; }
+
+inline constexpr bool IsLittleEndian() { return true; }
+
+#elif defined ABSL_IS_BIG_ENDIAN
+
+inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
+inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
+
+inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
+inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
+
+inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
+inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
+
+inline constexpr bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+inline uint8_t FromHost(uint8_t x) { return x; }
+inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
+inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
+inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
+inline uint8_t ToHost(uint8_t x) { return x; }
+inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
+inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
+inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
+
+inline int8_t FromHost(int8_t x) { return x; }
+inline int16_t FromHost(int16_t x) {
+  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
+}
+inline int32_t FromHost(int32_t x) {
+  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
+}
+inline int64_t FromHost(int64_t x) {
+  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
+}
+inline int8_t ToHost(int8_t x) { return x; }
+inline int16_t ToHost(int16_t x) {
+  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
+}
+inline int32_t ToHost(int32_t x) {
+  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
+}
+inline int64_t ToHost(int64_t x) {
+  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
+}
+
+// Functions to do unaligned loads and stores in little-endian order.
+inline uint16_t Load16(const void *p) {
+  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
+}
+
+inline void Store16(void *p, uint16_t v) {
+  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+}
+
+inline uint32_t Load32(const void *p) {
+  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+}
+
+inline void Store32(void *p, uint32_t v) {
+  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+}
+
+inline uint64_t Load64(const void *p) {
+  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+}
+
+inline void Store64(void *p, uint64_t v) {
+  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+}
+
+}  // namespace little_endian
+
+// Utilities to convert numbers between the current hosts's native byte
+// order and big-endian byte order (same as network byte order)
+//
+// Load/Store methods are alignment safe
+namespace big_endian {
+#ifdef ABSL_IS_LITTLE_ENDIAN
+
+inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
+inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
+
+inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
+inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
+
+inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
+inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
+
+inline constexpr bool IsLittleEndian() { return true; }
+
+#elif defined ABSL_IS_BIG_ENDIAN
+
+inline uint16_t FromHost16(uint16_t x) { return x; }
+inline uint16_t ToHost16(uint16_t x) { return x; }
+
+inline uint32_t FromHost32(uint32_t x) { return x; }
+inline uint32_t ToHost32(uint32_t x) { return x; }
+
+inline uint64_t FromHost64(uint64_t x) { return x; }
+inline uint64_t ToHost64(uint64_t x) { return x; }
+
+inline constexpr bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+inline uint8_t FromHost(uint8_t x) { return x; }
+inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
+inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
+inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
+inline uint8_t ToHost(uint8_t x) { return x; }
+inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
+inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
+inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
+
+inline int8_t FromHost(int8_t x) { return x; }
+inline int16_t FromHost(int16_t x) {
+  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
+}
+inline int32_t FromHost(int32_t x) {
+  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
+}
+inline int64_t FromHost(int64_t x) {
+  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
+}
+inline int8_t ToHost(int8_t x) { return x; }
+inline int16_t ToHost(int16_t x) {
+  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
+}
+inline int32_t ToHost(int32_t x) {
+  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
+}
+inline int64_t ToHost(int64_t x) {
+  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
+}
+
+// Functions to do unaligned loads and stores in big-endian order.
+inline uint16_t Load16(const void *p) {
+  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
+}
+
+inline void Store16(void *p, uint16_t v) {
+  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+}
+
+inline uint32_t Load32(const void *p) {
+  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+}
+
+inline void Store32(void *p, uint32_t v) {
+  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+}
+
+inline uint64_t Load64(const void *p) {
+  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+}
+
+inline void Store64(void *p, uint64_t v) {
+  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+}
+
+}  // namespace big_endian
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_ENDIAN_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/errno_saver.h b/CAPI/cpp/grpc/include/absl/base/internal/errno_saver.h
new file mode 100644
index 0000000..251de51
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/errno_saver.h
@@ -0,0 +1,43 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
+#define ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
+
+#include <cerrno>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// `ErrnoSaver` captures the value of `errno` upon construction and restores it
+// upon deletion.  It is used in low-level code and must be super fast.  Do not
+// add instrumentation, even in debug modes.
+class ErrnoSaver {
+ public:
+  ErrnoSaver() : saved_errno_(errno) {}
+  ~ErrnoSaver() { errno = saved_errno_; }
+  int operator()() const { return saved_errno_; }
+
+ private:
+  const int saved_errno_;
+};
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/exception_safety_testing.h b/CAPI/cpp/grpc/include/absl/base/internal/exception_safety_testing.h
new file mode 100644
index 0000000..77a5aec
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/exception_safety_testing.h
@@ -0,0 +1,1109 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// Utilities for testing exception-safety
+
+#ifndef ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
+#define ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
+
+#include "absl/base/config.h"
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <initializer_list>
+#include <iosfwd>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/pretty_function.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/substitute.h"
+#include "absl/utility/utility.h"
+
+namespace testing {
+
+enum class TypeSpec;
+enum class AllocSpec;
+
+constexpr TypeSpec operator|(TypeSpec a, TypeSpec b) {
+  using T = absl::underlying_type_t<TypeSpec>;
+  return static_cast<TypeSpec>(static_cast<T>(a) | static_cast<T>(b));
+}
+
+constexpr TypeSpec operator&(TypeSpec a, TypeSpec b) {
+  using T = absl::underlying_type_t<TypeSpec>;
+  return static_cast<TypeSpec>(static_cast<T>(a) & static_cast<T>(b));
+}
+
+constexpr AllocSpec operator|(AllocSpec a, AllocSpec b) {
+  using T = absl::underlying_type_t<AllocSpec>;
+  return static_cast<AllocSpec>(static_cast<T>(a) | static_cast<T>(b));
+}
+
+constexpr AllocSpec operator&(AllocSpec a, AllocSpec b) {
+  using T = absl::underlying_type_t<AllocSpec>;
+  return static_cast<AllocSpec>(static_cast<T>(a) & static_cast<T>(b));
+}
+
+namespace exceptions_internal {
+
+std::string GetSpecString(TypeSpec);
+std::string GetSpecString(AllocSpec);
+
+struct NoThrowTag {};
+struct StrongGuaranteeTagType {};
+
+// A simple exception class.  We throw this so that test code can catch
+// exceptions specifically thrown by ThrowingValue.
+class TestException {
+ public:
+  explicit TestException(absl::string_view msg) : msg_(msg) {}
+  virtual ~TestException() {}
+  virtual const char* what() const noexcept { return msg_.c_str(); }
+
+ private:
+  std::string msg_;
+};
+
+// TestBadAllocException exists because allocation functions must throw an
+// exception which can be caught by a handler of std::bad_alloc.  We use a child
+// class of std::bad_alloc so we can customise the error message, and also
+// derive from TestException so we don't accidentally end up catching an actual
+// bad_alloc exception in TestExceptionSafety.
+class TestBadAllocException : public std::bad_alloc, public TestException {
+ public:
+  explicit TestBadAllocException(absl::string_view msg) : TestException(msg) {}
+  using TestException::what;
+};
+
+extern int countdown;
+
+// Allows the countdown variable to be set manually (defaulting to the initial
+// value of 0)
+inline void SetCountdown(int i = 0) { countdown = i; }
+// Sets the countdown to the terminal value -1
+inline void UnsetCountdown() { SetCountdown(-1); }
+
+void MaybeThrow(absl::string_view msg, bool throw_bad_alloc = false);
+
+testing::AssertionResult FailureMessage(const TestException& e,
+                                        int countdown) noexcept;
+
+struct TrackedAddress {
+  bool is_alive;
+  std::string description;
+};
+
+// Inspects the constructions and destructions of anything inheriting from
+// TrackedObject. This allows us to safely "leak" TrackedObjects, as
+// ConstructorTracker will destroy everything left over in its destructor.
+class ConstructorTracker {
+ public:
+  explicit ConstructorTracker(int count) : countdown_(count) {
+    assert(current_tracker_instance_ == nullptr);
+    current_tracker_instance_ = this;
+  }
+
+  ~ConstructorTracker() {
+    assert(current_tracker_instance_ == this);
+    current_tracker_instance_ = nullptr;
+
+    for (auto& it : address_map_) {
+      void* address = it.first;
+      TrackedAddress& tracked_address = it.second;
+      if (tracked_address.is_alive) {
+        ADD_FAILURE() << ErrorMessage(address, tracked_address.description,
+                                      countdown_, "Object was not destroyed.");
+      }
+    }
+  }
+
+  static void ObjectConstructed(void* address, std::string description) {
+    if (!CurrentlyTracking()) return;
+
+    TrackedAddress& tracked_address =
+        current_tracker_instance_->address_map_[address];
+    if (tracked_address.is_alive) {
+      ADD_FAILURE() << ErrorMessage(
+          address, tracked_address.description,
+          current_tracker_instance_->countdown_,
+          "Object was re-constructed. Current object was constructed by " +
+              description);
+    }
+    tracked_address = {true, std::move(description)};
+  }
+
+  static void ObjectDestructed(void* address) {
+    if (!CurrentlyTracking()) return;
+
+    auto it = current_tracker_instance_->address_map_.find(address);
+    // Not tracked. Ignore.
+    if (it == current_tracker_instance_->address_map_.end()) return;
+
+    TrackedAddress& tracked_address = it->second;
+    if (!tracked_address.is_alive) {
+      ADD_FAILURE() << ErrorMessage(address, tracked_address.description,
+                                    current_tracker_instance_->countdown_,
+                                    "Object was re-destroyed.");
+    }
+    tracked_address.is_alive = false;
+  }
+
+ private:
+  static bool CurrentlyTracking() {
+    return current_tracker_instance_ != nullptr;
+  }
+
+  static std::string ErrorMessage(void* address,
+                                  const std::string& address_description,
+                                  int countdown,
+                                  const std::string& error_description) {
+    return absl::Substitute(
+        "With coundtown at $0:\n"
+        "  $1\n"
+        "  Object originally constructed by $2\n"
+        "  Object address: $3\n",
+        countdown, error_description, address_description, address);
+  }
+
+  std::unordered_map<void*, TrackedAddress> address_map_;
+  int countdown_;
+
+  static ConstructorTracker* current_tracker_instance_;
+};
+
+class TrackedObject {
+ public:
+  TrackedObject(const TrackedObject&) = delete;
+  TrackedObject(TrackedObject&&) = delete;
+
+ protected:
+  explicit TrackedObject(std::string description) {
+    ConstructorTracker::ObjectConstructed(this, std::move(description));
+  }
+
+  ~TrackedObject() noexcept { ConstructorTracker::ObjectDestructed(this); }
+};
+}  // namespace exceptions_internal
+
+extern exceptions_internal::NoThrowTag nothrow_ctor;
+
+extern exceptions_internal::StrongGuaranteeTagType strong_guarantee;
+
+// A test class which is convertible to bool.  The conversion can be
+// instrumented to throw at a controlled time.
+class ThrowingBool {
+ public:
+  ThrowingBool(bool b) noexcept : b_(b) {}  // NOLINT(runtime/explicit)
+  operator bool() const {                   // NOLINT
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return b_;
+  }
+
+ private:
+  bool b_;
+};
+
+/*
+ * Configuration enum for the ThrowingValue type that defines behavior for the
+ * lifetime of the instance. Use testing::nothrow_ctor to prevent the integer
+ * constructor from throwing.
+ *
+ * kEverythingThrows: Every operation can throw an exception
+ * kNoThrowCopy: Copy construction and copy assignment will not throw
+ * kNoThrowMove: Move construction and move assignment will not throw
+ * kNoThrowNew: Overloaded operators new and new[] will not throw
+ */
+enum class TypeSpec {
+  kEverythingThrows = 0,
+  kNoThrowCopy = 1,
+  kNoThrowMove = 1 << 1,
+  kNoThrowNew = 1 << 2,
+};
+
+/*
+ * A testing class instrumented to throw an exception at a controlled time.
+ *
+ * ThrowingValue implements a slightly relaxed version of the Regular concept --
+ * that is it's a value type with the expected semantics.  It also implements
+ * arithmetic operations.  It doesn't implement member and pointer operators
+ * like operator-> or operator[].
+ *
+ * ThrowingValue can be instrumented to have certain operations be noexcept by
+ * using compile-time bitfield template arguments.  That is, to make an
+ * ThrowingValue which has noexcept move construction/assignment and noexcept
+ * copy construction/assignment, use the following:
+ *   ThrowingValue<testing::kNoThrowMove | testing::kNoThrowCopy> my_thrwr{val};
+ */
+template <TypeSpec Spec = TypeSpec::kEverythingThrows>
+class ThrowingValue : private exceptions_internal::TrackedObject {
+  static constexpr bool IsSpecified(TypeSpec spec) {
+    return static_cast<bool>(Spec & spec);
+  }
+
+  static constexpr int kDefaultValue = 0;
+  static constexpr int kBadValue = 938550620;
+
+ public:
+  ThrowingValue() : TrackedObject(GetInstanceString(kDefaultValue)) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ = kDefaultValue;
+  }
+
+  ThrowingValue(const ThrowingValue& other) noexcept(
+      IsSpecified(TypeSpec::kNoThrowCopy))
+      : TrackedObject(GetInstanceString(other.dummy_)) {
+    if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    }
+    dummy_ = other.dummy_;
+  }
+
+  ThrowingValue(ThrowingValue&& other) noexcept(
+      IsSpecified(TypeSpec::kNoThrowMove))
+      : TrackedObject(GetInstanceString(other.dummy_)) {
+    if (!IsSpecified(TypeSpec::kNoThrowMove)) {
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    }
+    dummy_ = other.dummy_;
+  }
+
+  explicit ThrowingValue(int i) : TrackedObject(GetInstanceString(i)) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ = i;
+  }
+
+  ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept
+      : TrackedObject(GetInstanceString(i)), dummy_(i) {}
+
+  // absl expects nothrow destructors
+  ~ThrowingValue() noexcept = default;
+
+  ThrowingValue& operator=(const ThrowingValue& other) noexcept(
+      IsSpecified(TypeSpec::kNoThrowCopy)) {
+    dummy_ = kBadValue;
+    if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    }
+    dummy_ = other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator=(ThrowingValue&& other) noexcept(
+      IsSpecified(TypeSpec::kNoThrowMove)) {
+    dummy_ = kBadValue;
+    if (!IsSpecified(TypeSpec::kNoThrowMove)) {
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    }
+    dummy_ = other.dummy_;
+    return *this;
+  }
+
+  // Arithmetic Operators
+  ThrowingValue operator+(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ + other.dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator+() const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator-(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ - other.dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator-() const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(-dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue& operator++() {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    ++dummy_;
+    return *this;
+  }
+
+  ThrowingValue operator++(int) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    auto out = ThrowingValue(dummy_, nothrow_ctor);
+    ++dummy_;
+    return out;
+  }
+
+  ThrowingValue& operator--() {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    --dummy_;
+    return *this;
+  }
+
+  ThrowingValue operator--(int) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    auto out = ThrowingValue(dummy_, nothrow_ctor);
+    --dummy_;
+    return out;
+  }
+
+  ThrowingValue operator*(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ * other.dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator/(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ / other.dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator%(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ % other.dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator<<(int shift) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ << shift, nothrow_ctor);
+  }
+
+  ThrowingValue operator>>(int shift) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ >> shift, nothrow_ctor);
+  }
+
+  // Comparison Operators
+  // NOTE: We use `ThrowingBool` instead of `bool` because most STL
+  // types/containers requires T to be convertible to bool.
+  friend ThrowingBool operator==(const ThrowingValue& a,
+                                 const ThrowingValue& b) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return a.dummy_ == b.dummy_;
+  }
+  friend ThrowingBool operator!=(const ThrowingValue& a,
+                                 const ThrowingValue& b) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return a.dummy_ != b.dummy_;
+  }
+  friend ThrowingBool operator<(const ThrowingValue& a,
+                                const ThrowingValue& b) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return a.dummy_ < b.dummy_;
+  }
+  friend ThrowingBool operator<=(const ThrowingValue& a,
+                                 const ThrowingValue& b) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return a.dummy_ <= b.dummy_;
+  }
+  friend ThrowingBool operator>(const ThrowingValue& a,
+                                const ThrowingValue& b) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return a.dummy_ > b.dummy_;
+  }
+  friend ThrowingBool operator>=(const ThrowingValue& a,
+                                 const ThrowingValue& b) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return a.dummy_ >= b.dummy_;
+  }
+
+  // Logical Operators
+  ThrowingBool operator!() const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return !dummy_;
+  }
+
+  ThrowingBool operator&&(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return dummy_ && other.dummy_;
+  }
+
+  ThrowingBool operator||(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return dummy_ || other.dummy_;
+  }
+
+  // Bitwise Logical Operators
+  ThrowingValue operator~() const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(~dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator&(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ & other.dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator|(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ | other.dummy_, nothrow_ctor);
+  }
+
+  ThrowingValue operator^(const ThrowingValue& other) const {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return ThrowingValue(dummy_ ^ other.dummy_, nothrow_ctor);
+  }
+
+  // Compound Assignment operators
+  ThrowingValue& operator+=(const ThrowingValue& other) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ += other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator-=(const ThrowingValue& other) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ -= other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator*=(const ThrowingValue& other) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ *= other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator/=(const ThrowingValue& other) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ /= other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator%=(const ThrowingValue& other) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ %= other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator&=(const ThrowingValue& other) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ &= other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator|=(const ThrowingValue& other) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ |= other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator^=(const ThrowingValue& other) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ ^= other.dummy_;
+    return *this;
+  }
+
+  ThrowingValue& operator<<=(int shift) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ <<= shift;
+    return *this;
+  }
+
+  ThrowingValue& operator>>=(int shift) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ >>= shift;
+    return *this;
+  }
+
+  // Pointer operators
+  void operator&() const = delete;  // NOLINT(runtime/operator)
+
+  // Stream operators
+  friend std::ostream& operator<<(std::ostream& os, const ThrowingValue& tv) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return os << GetInstanceString(tv.dummy_);
+  }
+
+  friend std::istream& operator>>(std::istream& is, const ThrowingValue&) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    return is;
+  }
+
+  // Memory management operators
+  static void* operator new(size_t s) noexcept(
+      IsSpecified(TypeSpec::kNoThrowNew)) {
+    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+    }
+    return ::operator new(s);
+  }
+
+  static void* operator new[](size_t s) noexcept(
+      IsSpecified(TypeSpec::kNoThrowNew)) {
+    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+    }
+    return ::operator new[](s);
+  }
+
+  template <typename... Args>
+  static void* operator new(size_t s, Args&&... args) noexcept(
+      IsSpecified(TypeSpec::kNoThrowNew)) {
+    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+    }
+    return ::operator new(s, std::forward<Args>(args)...);
+  }
+
+  template <typename... Args>
+  static void* operator new[](size_t s, Args&&... args) noexcept(
+      IsSpecified(TypeSpec::kNoThrowNew)) {
+    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
+      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+    }
+    return ::operator new[](s, std::forward<Args>(args)...);
+  }
+
+  // Abseil doesn't support throwing overloaded operator delete.  These are
+  // provided so a throwing operator-new can clean up after itself.
+  void operator delete(void* p) noexcept { ::operator delete(p); }
+
+  template <typename... Args>
+  void operator delete(void* p, Args&&... args) noexcept {
+    ::operator delete(p, std::forward<Args>(args)...);
+  }
+
+  void operator delete[](void* p) noexcept { return ::operator delete[](p); }
+
+  template <typename... Args>
+  void operator delete[](void* p, Args&&... args) noexcept {
+    return ::operator delete[](p, std::forward<Args>(args)...);
+  }
+
+  // Non-standard access to the actual contained value.  No need for this to
+  // throw.
+  int& Get() noexcept { return dummy_; }
+  const int& Get() const noexcept { return dummy_; }
+
+ private:
+  static std::string GetInstanceString(int dummy) {
+    return absl::StrCat("ThrowingValue<",
+                        exceptions_internal::GetSpecString(Spec), ">(", dummy,
+                        ")");
+  }
+
+  int dummy_;
+};
+// While not having to do with exceptions, explicitly delete comma operator, to
+// make sure we don't use it on user-supplied types.
+template <TypeSpec Spec, typename T>
+void operator,(const ThrowingValue<Spec>&, T&&) = delete;
+template <TypeSpec Spec, typename T>
+void operator,(T&&, const ThrowingValue<Spec>&) = delete;
+
+/*
+ * Configuration enum for the ThrowingAllocator type that defines behavior for
+ * the lifetime of the instance.
+ *
+ * kEverythingThrows: Calls to the member functions may throw
+ * kNoThrowAllocate: Calls to the member functions will not throw
+ */
+enum class AllocSpec {
+  kEverythingThrows = 0,
+  kNoThrowAllocate = 1,
+};
+
+/*
+ * An allocator type which is instrumented to throw at a controlled time, or not
+ * to throw, using AllocSpec. The supported settings are the default of every
+ * function which is allowed to throw in a conforming allocator possibly
+ * throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS
+ * configuration macro.
+ */
+template <typename T, AllocSpec Spec = AllocSpec::kEverythingThrows>
+class ThrowingAllocator : private exceptions_internal::TrackedObject {
+  static constexpr bool IsSpecified(AllocSpec spec) {
+    return static_cast<bool>(Spec & spec);
+  }
+
+ public:
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using void_pointer = void*;
+  using const_void_pointer = const void*;
+  using value_type = T;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+
+  using is_nothrow =
+      std::integral_constant<bool, Spec == AllocSpec::kNoThrowAllocate>;
+  using propagate_on_container_copy_assignment = std::true_type;
+  using propagate_on_container_move_assignment = std::true_type;
+  using propagate_on_container_swap = std::true_type;
+  using is_always_equal = std::false_type;
+
+  ThrowingAllocator() : TrackedObject(GetInstanceString(next_id_)) {
+    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    dummy_ = std::make_shared<const int>(next_id_++);
+  }
+
+  template <typename U>
+  ThrowingAllocator(const ThrowingAllocator<U, Spec>& other) noexcept  // NOLINT
+      : TrackedObject(GetInstanceString(*other.State())),
+        dummy_(other.State()) {}
+
+  // According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of
+  // allocator shall not exit via an exception, thus they are marked noexcept.
+  ThrowingAllocator(const ThrowingAllocator& other) noexcept
+      : TrackedObject(GetInstanceString(*other.State())),
+        dummy_(other.State()) {}
+
+  template <typename U>
+  ThrowingAllocator(ThrowingAllocator<U, Spec>&& other) noexcept  // NOLINT
+      : TrackedObject(GetInstanceString(*other.State())),
+        dummy_(std::move(other.State())) {}
+
+  ThrowingAllocator(ThrowingAllocator&& other) noexcept
+      : TrackedObject(GetInstanceString(*other.State())),
+        dummy_(std::move(other.State())) {}
+
+  ~ThrowingAllocator() noexcept = default;
+
+  ThrowingAllocator& operator=(const ThrowingAllocator& other) noexcept {
+    dummy_ = other.State();
+    return *this;
+  }
+
+  template <typename U>
+  ThrowingAllocator& operator=(
+      const ThrowingAllocator<U, Spec>& other) noexcept {
+    dummy_ = other.State();
+    return *this;
+  }
+
+  template <typename U>
+  ThrowingAllocator& operator=(ThrowingAllocator<U, Spec>&& other) noexcept {
+    dummy_ = std::move(other.State());
+    return *this;
+  }
+
+  template <typename U>
+  struct rebind {
+    using other = ThrowingAllocator<U, Spec>;
+  };
+
+  pointer allocate(size_type n) noexcept(
+      IsSpecified(AllocSpec::kNoThrowAllocate)) {
+    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+    return static_cast<pointer>(::operator new(n * sizeof(T)));
+  }
+
+  pointer allocate(size_type n, const_void_pointer) noexcept(
+      IsSpecified(AllocSpec::kNoThrowAllocate)) {
+    return allocate(n);
+  }
+
+  void deallocate(pointer ptr, size_type) noexcept {
+    ReadState();
+    ::operator delete(static_cast<void*>(ptr));
+  }
+
+  template <typename U, typename... Args>
+  void construct(U* ptr, Args&&... args) noexcept(
+      IsSpecified(AllocSpec::kNoThrowAllocate)) {
+    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+    ::new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
+  }
+
+  template <typename U>
+  void destroy(U* p) noexcept {
+    ReadState();
+    p->~U();
+  }
+
+  size_type max_size() const noexcept {
+    return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
+  }
+
+  ThrowingAllocator select_on_container_copy_construction() noexcept(
+      IsSpecified(AllocSpec::kNoThrowAllocate)) {
+    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+    return *this;
+  }
+
+  template <typename U>
+  bool operator==(const ThrowingAllocator<U, Spec>& other) const noexcept {
+    return dummy_ == other.dummy_;
+  }
+
+  template <typename U>
+  bool operator!=(const ThrowingAllocator<U, Spec>& other) const noexcept {
+    return dummy_ != other.dummy_;
+  }
+
+  template <typename, AllocSpec>
+  friend class ThrowingAllocator;
+
+ private:
+  static std::string GetInstanceString(int dummy) {
+    return absl::StrCat("ThrowingAllocator<",
+                        exceptions_internal::GetSpecString(Spec), ">(", dummy,
+                        ")");
+  }
+
+  const std::shared_ptr<const int>& State() const { return dummy_; }
+  std::shared_ptr<const int>& State() { return dummy_; }
+
+  void ReadState() {
+    // we know that this will never be true, but the compiler doesn't, so this
+    // should safely force a read of the value.
+    if (*dummy_ < 0) std::abort();
+  }
+
+  void ReadStateAndMaybeThrow(absl::string_view msg) const {
+    if (!IsSpecified(AllocSpec::kNoThrowAllocate)) {
+      exceptions_internal::MaybeThrow(
+          absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg));
+    }
+  }
+
+  static int next_id_;
+  std::shared_ptr<const int> dummy_;
+};
+
+template <typename T, AllocSpec Spec>
+int ThrowingAllocator<T, Spec>::next_id_ = 0;
+
+// Tests for resource leaks by attempting to construct a T using args repeatedly
+// until successful, using the countdown method.  Side effects can then be
+// tested for resource leaks.
+template <typename T, typename... Args>
+void TestThrowingCtor(Args&&... args) {
+  struct Cleanup {
+    ~Cleanup() { exceptions_internal::UnsetCountdown(); }
+  } c;
+  for (int count = 0;; ++count) {
+    exceptions_internal::ConstructorTracker ct(count);
+    exceptions_internal::SetCountdown(count);
+    try {
+      T temp(std::forward<Args>(args)...);
+      static_cast<void>(temp);
+      break;
+    } catch (const exceptions_internal::TestException&) {
+    }
+  }
+}
+
+// Tests the nothrow guarantee of the provided nullary operation. If the an
+// exception is thrown, the result will be AssertionFailure(). Otherwise, it
+// will be AssertionSuccess().
+template <typename Operation>
+testing::AssertionResult TestNothrowOp(const Operation& operation) {
+  struct Cleanup {
+    Cleanup() { exceptions_internal::SetCountdown(); }
+    ~Cleanup() { exceptions_internal::UnsetCountdown(); }
+  } c;
+  try {
+    operation();
+    return testing::AssertionSuccess();
+  } catch (const exceptions_internal::TestException&) {
+    return testing::AssertionFailure()
+           << "TestException thrown during call to operation() when nothrow "
+              "guarantee was expected.";
+  } catch (...) {
+    return testing::AssertionFailure()
+           << "Unknown exception thrown during call to operation() when "
+              "nothrow guarantee was expected.";
+  }
+}
+
+namespace exceptions_internal {
+
+// Dummy struct for ExceptionSafetyTestBuilder<> partial state.
+struct UninitializedT {};
+
+template <typename T>
+class DefaultFactory {
+ public:
+  explicit DefaultFactory(const T& t) : t_(t) {}
+  std::unique_ptr<T> operator()() const { return absl::make_unique<T>(t_); }
+
+ private:
+  T t_;
+};
+
+template <size_t LazyContractsCount, typename LazyFactory,
+          typename LazyOperation>
+using EnableIfTestable = typename absl::enable_if_t<
+    LazyContractsCount != 0 &&
+    !std::is_same<LazyFactory, UninitializedT>::value &&
+    !std::is_same<LazyOperation, UninitializedT>::value>;
+
+template <typename Factory = UninitializedT,
+          typename Operation = UninitializedT, typename... Contracts>
+class ExceptionSafetyTestBuilder;
+
+}  // namespace exceptions_internal
+
+/*
+ * Constructs an empty ExceptionSafetyTestBuilder. All
+ * ExceptionSafetyTestBuilder objects are immutable and all With[thing] mutation
+ * methods return new instances of ExceptionSafetyTestBuilder.
+ *
+ * In order to test a T for exception safety, a factory for that T, a testable
+ * operation, and at least one contract callback returning an assertion
+ * result must be applied using the respective methods.
+ */
+exceptions_internal::ExceptionSafetyTestBuilder<> MakeExceptionSafetyTester();
+
+namespace exceptions_internal {
+template <typename T>
+struct IsUniquePtr : std::false_type {};
+
+template <typename T, typename D>
+struct IsUniquePtr<std::unique_ptr<T, D>> : std::true_type {};
+
+template <typename Factory>
+struct FactoryPtrTypeHelper {
+  using type = decltype(std::declval<const Factory&>()());
+
+  static_assert(IsUniquePtr<type>::value, "Factories must return a unique_ptr");
+};
+
+template <typename Factory>
+using FactoryPtrType = typename FactoryPtrTypeHelper<Factory>::type;
+
+template <typename Factory>
+using FactoryElementType = typename FactoryPtrType<Factory>::element_type;
+
+template <typename T>
+class ExceptionSafetyTest {
+  using Factory = std::function<std::unique_ptr<T>()>;
+  using Operation = std::function<void(T*)>;
+  using Contract = std::function<AssertionResult(T*)>;
+
+ public:
+  template <typename... Contracts>
+  explicit ExceptionSafetyTest(const Factory& f, const Operation& op,
+                               const Contracts&... contracts)
+      : factory_(f), operation_(op), contracts_{WrapContract(contracts)...} {}
+
+  AssertionResult Test() const {
+    for (int count = 0;; ++count) {
+      exceptions_internal::ConstructorTracker ct(count);
+
+      for (const auto& contract : contracts_) {
+        auto t_ptr = factory_();
+        try {
+          SetCountdown(count);
+          operation_(t_ptr.get());
+          // Unset for the case that the operation throws no exceptions, which
+          // would leave the countdown set and break the *next* exception safety
+          // test after this one.
+          UnsetCountdown();
+          return AssertionSuccess();
+        } catch (const exceptions_internal::TestException& e) {
+          if (!contract(t_ptr.get())) {
+            return AssertionFailure() << e.what() << " failed contract check";
+          }
+        }
+      }
+    }
+  }
+
+ private:
+  template <typename ContractFn>
+  Contract WrapContract(const ContractFn& contract) {
+    return [contract](T* t_ptr) { return AssertionResult(contract(t_ptr)); };
+  }
+
+  Contract WrapContract(StrongGuaranteeTagType) {
+    return [this](T* t_ptr) { return AssertionResult(*factory_() == *t_ptr); };
+  }
+
+  Factory factory_;
+  Operation operation_;
+  std::vector<Contract> contracts_;
+};
+
+/*
+ * Builds a tester object that tests if performing a operation on a T follows
+ * exception safety guarantees. Verification is done via contract assertion
+ * callbacks applied to T instances post-throw.
+ *
+ * Template parameters for ExceptionSafetyTestBuilder:
+ *
+ * - Factory: The factory object (passed in via tester.WithFactory(...) or
+ *   tester.WithInitialValue(...)) must be invocable with the signature
+ *   `std::unique_ptr<T> operator()() const` where T is the type being tested.
+ *   It is used for reliably creating identical T instances to test on.
+ *
+ * - Operation: The operation object (passsed in via tester.WithOperation(...)
+ *   or tester.Test(...)) must be invocable with the signature
+ *   `void operator()(T*) const` where T is the type being tested. It is used
+ *   for performing steps on a T instance that may throw and that need to be
+ *   checked for exception safety. Each call to the operation will receive a
+ *   fresh T instance so it's free to modify and destroy the T instances as it
+ *   pleases.
+ *
+ * - Contracts...: The contract assertion callback objects (passed in via
+ *   tester.WithContracts(...)) must be invocable with the signature
+ *   `testing::AssertionResult operator()(T*) const` where T is the type being
+ *   tested. Contract assertion callbacks are provided T instances post-throw.
+ *   They must return testing::AssertionSuccess when the type contracts of the
+ *   provided T instance hold. If the type contracts of the T instance do not
+ *   hold, they must return testing::AssertionFailure. Execution order of
+ *   Contracts... is unspecified. They will each individually get a fresh T
+ *   instance so they are free to modify and destroy the T instances as they
+ *   please.
+ */
+template <typename Factory, typename Operation, typename... Contracts>
+class ExceptionSafetyTestBuilder {
+ public:
+  /*
+   * Returns a new ExceptionSafetyTestBuilder with an included T factory based
+   * on the provided T instance. The existing factory will not be included in
+   * the newly created tester instance. The created factory returns a new T
+   * instance by copy-constructing the provided const T& t.
+   *
+   * Preconditions for tester.WithInitialValue(const T& t):
+   *
+   * - The const T& t object must be copy-constructible where T is the type
+   *   being tested. For non-copy-constructible objects, use the method
+   *   tester.WithFactory(...).
+   */
+  template <typename T>
+  ExceptionSafetyTestBuilder<DefaultFactory<T>, Operation, Contracts...>
+  WithInitialValue(const T& t) const {
+    return WithFactory(DefaultFactory<T>(t));
+  }
+
+  /*
+   * Returns a new ExceptionSafetyTestBuilder with the provided T factory
+   * included. The existing factory will not be included in the newly-created
+   * tester instance. This method is intended for use with types lacking a copy
+   * constructor. Types that can be copy-constructed should instead use the
+   * method tester.WithInitialValue(...).
+   */
+  template <typename NewFactory>
+  ExceptionSafetyTestBuilder<absl::decay_t<NewFactory>, Operation, Contracts...>
+  WithFactory(const NewFactory& new_factory) const {
+    return {new_factory, operation_, contracts_};
+  }
+
+  /*
+   * Returns a new ExceptionSafetyTestBuilder with the provided testable
+   * operation included. The existing operation will not be included in the
+   * newly created tester.
+   */
+  template <typename NewOperation>
+  ExceptionSafetyTestBuilder<Factory, absl::decay_t<NewOperation>, Contracts...>
+  WithOperation(const NewOperation& new_operation) const {
+    return {factory_, new_operation, contracts_};
+  }
+
+  /*
+   * Returns a new ExceptionSafetyTestBuilder with the provided MoreContracts...
+   * combined with the Contracts... that were already included in the instance
+   * on which the method was called. Contracts... cannot be removed or replaced
+   * once added to an ExceptionSafetyTestBuilder instance. A fresh object must
+   * be created in order to get an empty Contracts... list.
+   *
+   * In addition to passing in custom contract assertion callbacks, this method
+   * accepts `testing::strong_guarantee` as an argument which checks T instances
+   * post-throw against freshly created T instances via operator== to verify
+   * that any state changes made during the execution of the operation were
+   * properly rolled back.
+   */
+  template <typename... MoreContracts>
+  ExceptionSafetyTestBuilder<Factory, Operation, Contracts...,
+                             absl::decay_t<MoreContracts>...>
+  WithContracts(const MoreContracts&... more_contracts) const {
+    return {
+        factory_, operation_,
+        std::tuple_cat(contracts_, std::tuple<absl::decay_t<MoreContracts>...>(
+                                       more_contracts...))};
+  }
+
+  /*
+   * Returns a testing::AssertionResult that is the reduced result of the
+   * exception safety algorithm. The algorithm short circuits and returns
+   * AssertionFailure after the first contract callback returns an
+   * AssertionFailure. Otherwise, if all contract callbacks return an
+   * AssertionSuccess, the reduced result is AssertionSuccess.
+   *
+   * The passed-in testable operation will not be saved in a new tester instance
+   * nor will it modify/replace the existing tester instance. This is useful
+   * when each operation being tested is unique and does not need to be reused.
+   *
+   * Preconditions for tester.Test(const NewOperation& new_operation):
+   *
+   * - May only be called after at least one contract assertion callback and a
+   *   factory or initial value have been provided.
+   */
+  template <
+      typename NewOperation,
+      typename = EnableIfTestable<sizeof...(Contracts), Factory, NewOperation>>
+  testing::AssertionResult Test(const NewOperation& new_operation) const {
+    return TestImpl(new_operation, absl::index_sequence_for<Contracts...>());
+  }
+
+  /*
+   * Returns a testing::AssertionResult that is the reduced result of the
+   * exception safety algorithm. The algorithm short circuits and returns
+   * AssertionFailure after the first contract callback returns an
+   * AssertionFailure. Otherwise, if all contract callbacks return an
+   * AssertionSuccess, the reduced result is AssertionSuccess.
+   *
+   * Preconditions for tester.Test():
+   *
+   * - May only be called after at least one contract assertion callback, a
+   *   factory or initial value and a testable operation have been provided.
+   */
+  template <
+      typename LazyOperation = Operation,
+      typename = EnableIfTestable<sizeof...(Contracts), Factory, LazyOperation>>
+  testing::AssertionResult Test() const {
+    return Test(operation_);
+  }
+
+ private:
+  template <typename, typename, typename...>
+  friend class ExceptionSafetyTestBuilder;
+
+  friend ExceptionSafetyTestBuilder<> testing::MakeExceptionSafetyTester();
+
+  ExceptionSafetyTestBuilder() {}
+
+  ExceptionSafetyTestBuilder(const Factory& f, const Operation& o,
+                             const std::tuple<Contracts...>& i)
+      : factory_(f), operation_(o), contracts_(i) {}
+
+  template <typename SelectedOperation, size_t... Indices>
+  testing::AssertionResult TestImpl(SelectedOperation selected_operation,
+                                    absl::index_sequence<Indices...>) const {
+    return ExceptionSafetyTest<FactoryElementType<Factory>>(
+               factory_, selected_operation, std::get<Indices>(contracts_)...)
+        .Test();
+  }
+
+  Factory factory_;
+  Operation operation_;
+  std::tuple<Contracts...> contracts_;
+};
+
+}  // namespace exceptions_internal
+
+}  // namespace testing
+
+#endif  // ABSL_HAVE_EXCEPTIONS
+
+#endif  // ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/exception_testing.h b/CAPI/cpp/grpc/include/absl/base/internal/exception_testing.h
new file mode 100644
index 0000000..01b5465
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/exception_testing.h
@@ -0,0 +1,42 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// Testing utilities for ABSL types which throw exceptions.
+
+#ifndef ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
+#define ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+
+// ABSL_BASE_INTERNAL_EXPECT_FAIL tests either for a specified thrown exception
+// if exceptions are enabled, or for death with a specified text in the error
+// message
+#ifdef ABSL_HAVE_EXCEPTIONS
+
+#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
+  EXPECT_THROW(expr, exception_t)
+
+#elif defined(__ANDROID__)
+// Android asserts do not log anywhere that gtest can currently inspect.
+// So we expect exit, but cannot match the message.
+#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
+  EXPECT_DEATH(expr, ".*")
+#else
+#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
+  EXPECT_DEATH_IF_SUPPORTED(expr, text)
+
+#endif
+
+#endif  // ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/fast_type_id.h b/CAPI/cpp/grpc/include/absl/base/internal/fast_type_id.h
new file mode 100644
index 0000000..a547b3a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/fast_type_id.h
@@ -0,0 +1,50 @@
+//
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
+#define ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+template <typename Type>
+struct FastTypeTag {
+  constexpr static char dummy_var = 0;
+};
+
+#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+template <typename Type>
+constexpr char FastTypeTag<Type>::dummy_var;
+#endif
+
+// FastTypeId<Type>() evaluates at compile/link-time to a unique pointer for the
+// passed-in type. These are meant to be good match for keys into maps or
+// straight up comparisons.
+using FastTypeIdType = const void*;
+
+template <typename Type>
+constexpr inline FastTypeIdType FastTypeId() {
+  return &FastTypeTag<Type>::dummy_var;
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/hide_ptr.h b/CAPI/cpp/grpc/include/absl/base/internal/hide_ptr.h
new file mode 100644
index 0000000..1dba809
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/hide_ptr.h
@@ -0,0 +1,51 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_HIDE_PTR_H_
+#define ABSL_BASE_INTERNAL_HIDE_PTR_H_
+
+#include <cstdint>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// Arbitrary value with high bits set. Xor'ing with it is unlikely
+// to map one valid pointer to another valid pointer.
+constexpr uintptr_t HideMask() {
+  return (uintptr_t{0xF03A5F7BU} << (sizeof(uintptr_t) - 4) * 8) | 0xF03A5F7BU;
+}
+
+// Hide a pointer from the leak checker. For internal use only.
+// Differs from absl::IgnoreLeak(ptr) in that absl::IgnoreLeak(ptr) causes ptr
+// and all objects reachable from ptr to be ignored by the leak checker.
+template <class T>
+inline uintptr_t HidePtr(T* ptr) {
+  return reinterpret_cast<uintptr_t>(ptr) ^ HideMask();
+}
+
+// Return a pointer that has been hidden from the leak checker.
+// For internal use only.
+template <class T>
+inline T* UnhidePtr(uintptr_t hidden) {
+  return reinterpret_cast<T*>(hidden ^ HideMask());
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_HIDE_PTR_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/identity.h b/CAPI/cpp/grpc/include/absl/base/internal/identity.h
new file mode 100644
index 0000000..a3154ed
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/identity.h
@@ -0,0 +1,37 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_BASE_INTERNAL_IDENTITY_H_
+#define ABSL_BASE_INTERNAL_IDENTITY_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace internal {
+
+template <typename T>
+struct identity {
+  typedef T type;
+};
+
+template <typename T>
+using identity_t = typename identity<T>::type;
+
+}  // namespace internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_IDENTITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/inline_variable.h b/CAPI/cpp/grpc/include/absl/base/internal/inline_variable.h
new file mode 100644
index 0000000..130d8c2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/inline_variable.h
@@ -0,0 +1,107 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
+#define ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
+
+#include <type_traits>
+
+#include "absl/base/internal/identity.h"
+
+// File:
+//   This file define a macro that allows the creation of or emulation of C++17
+//   inline variables based on whether or not the feature is supported.
+
+////////////////////////////////////////////////////////////////////////////////
+// Macro: ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init)
+//
+// Description:
+//   Expands to the equivalent of an inline constexpr instance of the specified
+//   `type` and `name`, initialized to the value `init`. If the compiler being
+//   used is detected as supporting actual inline variables as a language
+//   feature, then the macro expands to an actual inline variable definition.
+//
+// Requires:
+//   `type` is a type that is usable in an extern variable declaration.
+//
+// Requires: `name` is a valid identifier
+//
+// Requires:
+//   `init` is an expression that can be used in the following definition:
+//     constexpr type name = init;
+//
+// Usage:
+//
+//   // Equivalent to: `inline constexpr size_t variant_npos = -1;`
+//   ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, -1);
+//
+// Differences in implementation:
+//   For a direct, language-level inline variable, decltype(name) will be the
+//   type that was specified along with const qualification, whereas for
+//   emulated inline variables, decltype(name) may be different (in practice
+//   it will likely be a reference type).
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cpp_inline_variables
+
+// Clang's -Wmissing-variable-declarations option erroneously warned that
+// inline constexpr objects need to be pre-declared. This has now been fixed,
+// but we will need to support this workaround for people building with older
+// versions of clang.
+//
+// Bug: https://bugs.llvm.org/show_bug.cgi?id=35862
+//
+// Note:
+//   identity_t is used here so that the const and name are in the
+//   appropriate place for pointer types, reference types, function pointer
+//   types, etc..
+#if defined(__clang__)
+#define ABSL_INTERNAL_EXTERN_DECL(type, name) \
+  extern const ::absl::internal::identity_t<type> name;
+#else  // Otherwise, just define the macro to do nothing.
+#define ABSL_INTERNAL_EXTERN_DECL(type, name)
+#endif  // defined(__clang__)
+
+// See above comment at top of file for details.
+#define ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
+  ABSL_INTERNAL_EXTERN_DECL(type, name)                  \
+  inline constexpr ::absl::internal::identity_t<type> name = init
+
+#else
+
+// See above comment at top of file for details.
+//
+// Note:
+//   identity_t is used here so that the const and name are in the
+//   appropriate place for pointer types, reference types, function pointer
+//   types, etc..
+#define ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                  \
+  template <class /*AbslInternalDummy*/ = void>                               \
+  struct AbslInternalInlineVariableHolder##name {                             \
+    static constexpr ::absl::internal::identity_t<var_type> kInstance = init; \
+  };                                                                          \
+                                                                              \
+  template <class AbslInternalDummy>                                          \
+  constexpr ::absl::internal::identity_t<var_type>                            \
+      AbslInternalInlineVariableHolder##name<AbslInternalDummy>::kInstance;   \
+                                                                              \
+  static constexpr const ::absl::internal::identity_t<var_type>&              \
+      name = /* NOLINT */                                                     \
+      AbslInternalInlineVariableHolder##name<>::kInstance;                    \
+  static_assert(sizeof(void (*)(decltype(name))) != 0,                        \
+                "Silence unused variable warnings.")
+
+#endif  // __cpp_inline_variables
+
+#endif  // ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/inline_variable_testing.h b/CAPI/cpp/grpc/include/absl/base/internal/inline_variable_testing.h
new file mode 100644
index 0000000..3856b9f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/inline_variable_testing.h
@@ -0,0 +1,46 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INLINE_VARIABLE_TESTING_H_
+#define ABSL_BASE_INLINE_VARIABLE_TESTING_H_
+
+#include "absl/base/internal/inline_variable.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace inline_variable_testing_internal {
+
+struct Foo {
+  int value = 5;
+};
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, inline_variable_foo, {});
+ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, other_inline_variable_foo, {});
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(int, inline_variable_int, 5);
+ABSL_INTERNAL_INLINE_CONSTEXPR(int, other_inline_variable_int, 5);
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(void(*)(), inline_variable_fun_ptr, nullptr);
+
+const Foo& get_foo_a();
+const Foo& get_foo_b();
+
+const int& get_int_a();
+const int& get_int_b();
+
+}  // namespace inline_variable_testing_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INLINE_VARIABLE_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/invoke.h b/CAPI/cpp/grpc/include/absl/base/internal/invoke.h
new file mode 100644
index 0000000..643c2a4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/invoke.h
@@ -0,0 +1,241 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// absl::base_internal::invoke(f, args...) is an implementation of
+// INVOKE(f, args...) from section [func.require] of the C++ standard.
+// When compiled as C++17 and later versions, it is implemented as an alias of
+// std::invoke.
+//
+// [func.require]
+// Define INVOKE (f, t1, t2, ..., tN) as follows:
+// 1. (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
+//    and t1 is an object of type T or a reference to an object of type T or a
+//    reference to an object of a type derived from T;
+// 2. ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
+//    class T and t1 is not one of the types described in the previous item;
+// 3. t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
+//    an object of type T or a reference to an object of type T or a reference
+//    to an object of a type derived from T;
+// 4. (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
+//    is not one of the types described in the previous item;
+// 5. f(t1, t2, ..., tN) in all other cases.
+//
+// The implementation is SFINAE-friendly: substitution failure within invoke()
+// isn't an error.
+
+#ifndef ABSL_BASE_INTERNAL_INVOKE_H_
+#define ABSL_BASE_INTERNAL_INVOKE_H_
+
+#include "absl/base/config.h"
+
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
+
+#include <functional>
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+using std::invoke;
+using std::invoke_result_t;
+using std::is_invocable_r;
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
+
+#include <algorithm>
+#include <type_traits>
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+
+// The following code is internal implementation detail.  See the comment at the
+// top of this file for the API documentation.
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// The five classes below each implement one of the clauses from the definition
+// of INVOKE. The inner class template Accept<F, Args...> checks whether the
+// clause is applicable; static function template Invoke(f, args...) does the
+// invocation.
+//
+// By separating the clause selection logic from invocation we make sure that
+// Invoke() does exactly what the standard says.
+
+template <typename Derived>
+struct StrippedAccept {
+  template <typename... Args>
+  struct Accept : Derived::template AcceptImpl<typename std::remove_cv<
+                      typename std::remove_reference<Args>::type>::type...> {};
+};
+
+// (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
+// and t1 is an object of type T or a reference to an object of type T or a
+// reference to an object of a type derived from T.
+struct MemFunAndRef : StrippedAccept<MemFunAndRef> {
+  template <typename... Args>
+  struct AcceptImpl : std::false_type {};
+
+  template <typename MemFunType, typename C, typename Obj, typename... Args>
+  struct AcceptImpl<MemFunType C::*, Obj, Args...>
+      : std::integral_constant<bool, std::is_base_of<C, Obj>::value &&
+                                         absl::is_function<MemFunType>::value> {
+  };
+
+  template <typename MemFun, typename Obj, typename... Args>
+  static decltype((std::declval<Obj>().*
+                   std::declval<MemFun>())(std::declval<Args>()...))
+  Invoke(MemFun&& mem_fun, Obj&& obj, Args&&... args) {
+// Ignore bogus GCC warnings on this line.
+// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101436 for similar example.
+#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(11, 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+    return (std::forward<Obj>(obj).*
+            std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(11, 0)
+#pragma GCC diagnostic pop
+#endif
+  }
+};
+
+// ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
+// class T and t1 is not one of the types described in the previous item.
+struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> {
+  template <typename... Args>
+  struct AcceptImpl : std::false_type {};
+
+  template <typename MemFunType, typename C, typename Ptr, typename... Args>
+  struct AcceptImpl<MemFunType C::*, Ptr, Args...>
+      : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value &&
+                                         absl::is_function<MemFunType>::value> {
+  };
+
+  template <typename MemFun, typename Ptr, typename... Args>
+  static decltype(((*std::declval<Ptr>()).*
+                   std::declval<MemFun>())(std::declval<Args>()...))
+  Invoke(MemFun&& mem_fun, Ptr&& ptr, Args&&... args) {
+    return ((*std::forward<Ptr>(ptr)).*
+            std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+  }
+};
+
+// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
+// an object of type T or a reference to an object of type T or a reference
+// to an object of a type derived from T.
+struct DataMemAndRef : StrippedAccept<DataMemAndRef> {
+  template <typename... Args>
+  struct AcceptImpl : std::false_type {};
+
+  template <typename R, typename C, typename Obj>
+  struct AcceptImpl<R C::*, Obj>
+      : std::integral_constant<bool, std::is_base_of<C, Obj>::value &&
+                                         !absl::is_function<R>::value> {};
+
+  template <typename DataMem, typename Ref>
+  static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke(
+      DataMem&& data_mem, Ref&& ref) {
+    return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
+  }
+};
+
+// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
+// is not one of the types described in the previous item.
+struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> {
+  template <typename... Args>
+  struct AcceptImpl : std::false_type {};
+
+  template <typename R, typename C, typename Ptr>
+  struct AcceptImpl<R C::*, Ptr>
+      : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value &&
+                                         !absl::is_function<R>::value> {};
+
+  template <typename DataMem, typename Ptr>
+  static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke(
+      DataMem&& data_mem, Ptr&& ptr) {
+    return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
+  }
+};
+
+// f(t1, t2, ..., tN) in all other cases.
+struct Callable {
+  // Callable doesn't have Accept because it's the last clause that gets picked
+  // when none of the previous clauses are applicable.
+  template <typename F, typename... Args>
+  static decltype(std::declval<F>()(std::declval<Args>()...)) Invoke(
+      F&& f, Args&&... args) {
+    return std::forward<F>(f)(std::forward<Args>(args)...);
+  }
+};
+
+// Resolves to the first matching clause.
+template <typename... Args>
+struct Invoker {
+  typedef typename std::conditional<
+      MemFunAndRef::Accept<Args...>::value, MemFunAndRef,
+      typename std::conditional<
+          MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr,
+          typename std::conditional<
+              DataMemAndRef::Accept<Args...>::value, DataMemAndRef,
+              typename std::conditional<DataMemAndPtr::Accept<Args...>::value,
+                                        DataMemAndPtr, Callable>::type>::type>::
+          type>::type type;
+};
+
+// The result type of Invoke<F, Args...>.
+template <typename F, typename... Args>
+using invoke_result_t = decltype(Invoker<F, Args...>::type::Invoke(
+    std::declval<F>(), std::declval<Args>()...));
+
+// Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
+// [func.require] of the C++ standard.
+template <typename F, typename... Args>
+invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) {
+  return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
+                                           std::forward<Args>(args)...);
+}
+
+template <typename AlwaysVoid, typename, typename, typename...>
+struct IsInvocableRImpl : std::false_type {};
+
+template <typename R, typename F, typename... Args>
+struct IsInvocableRImpl<
+    absl::void_t<absl::base_internal::invoke_result_t<F, Args...> >, R, F,
+    Args...>
+    : std::integral_constant<
+          bool,
+          std::is_convertible<absl::base_internal::invoke_result_t<F, Args...>,
+                              R>::value ||
+              std::is_void<R>::value> {};
+
+// Type trait whose member `value` is true if invoking `F` with `Args` is valid,
+// and either the return type is convertible to `R`, or `R` is void.
+// C++11-compatible version of `std::is_invocable_r`.
+template <typename R, typename F, typename... Args>
+using is_invocable_r = IsInvocableRImpl<void, R, F, Args...>;
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
+
+#endif  // ABSL_BASE_INTERNAL_INVOKE_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/low_level_alloc.h b/CAPI/cpp/grpc/include/absl/base/internal/low_level_alloc.h
new file mode 100644
index 0000000..db91951
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/low_level_alloc.h
@@ -0,0 +1,126 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
+#define ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
+
+// A simple thread-safe memory allocator that does not depend on
+// mutexes or thread-specific data.  It is intended to be used
+// sparingly, and only when malloc() would introduce an unwanted
+// dependency, such as inside the heap-checker, or the Mutex
+// implementation.
+
+// IWYU pragma: private, include "base/low_level_alloc.h"
+
+#include <sys/types.h>
+
+#include <cstdint>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+
+// LowLevelAlloc requires that the platform support low-level
+// allocation of virtual memory. Platforms lacking this cannot use
+// LowLevelAlloc.
+#ifdef ABSL_LOW_LEVEL_ALLOC_MISSING
+#error ABSL_LOW_LEVEL_ALLOC_MISSING cannot be directly set
+#elif !defined(ABSL_HAVE_MMAP) && !defined(_WIN32)
+#define ABSL_LOW_LEVEL_ALLOC_MISSING 1
+#endif
+
+// Using LowLevelAlloc with kAsyncSignalSafe isn't supported on Windows or
+// asm.js / WebAssembly.
+// See https://kripken.github.io/emscripten-site/docs/porting/pthreads.html
+// for more information.
+#ifdef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#error ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING cannot be directly set
+#elif defined(_WIN32) || defined(__asmjs__) || defined(__wasm__)
+#define ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING 1
+#endif
+
+#include <cstddef>
+
+#include "absl/base/port.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+class LowLevelAlloc {
+ public:
+  struct Arena;       // an arena from which memory may be allocated
+
+  // Returns a pointer to a block of at least "request" bytes
+  // that have been newly allocated from the specific arena.
+  // for Alloc() call the DefaultArena() is used.
+  // Returns 0 if passed request==0.
+  // Does not return 0 under other circumstances; it crashes if memory
+  // is not available.
+  static void *Alloc(size_t request) ABSL_ATTRIBUTE_SECTION(malloc_hook);
+  static void *AllocWithArena(size_t request, Arena *arena)
+      ABSL_ATTRIBUTE_SECTION(malloc_hook);
+
+  // Deallocates a region of memory that was previously allocated with
+  // Alloc().   Does nothing if passed 0.   "s" must be either 0,
+  // or must have been returned from a call to Alloc() and not yet passed to
+  // Free() since that call to Alloc().  The space is returned to the arena
+  // from which it was allocated.
+  static void Free(void *s) ABSL_ATTRIBUTE_SECTION(malloc_hook);
+
+  // ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
+  // are to put all callers of MallocHook::Invoke* in this module
+  // into special section,
+  // so that MallocHook::GetCallerStackTrace can function accurately.
+
+  // Create a new arena.
+  // The root metadata for the new arena is allocated in the
+  // meta_data_arena; the DefaultArena() can be passed for meta_data_arena.
+  // These values may be ored into flags:
+  enum {
+    // Report calls to Alloc() and Free() via the MallocHook interface.
+    // Set in the DefaultArena.
+    kCallMallocHook = 0x0001,
+
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+    // Make calls to Alloc(), Free() be async-signal-safe. Not set in
+    // DefaultArena(). Not supported on all platforms.
+    kAsyncSignalSafe = 0x0002,
+#endif
+  };
+  // Construct a new arena.  The allocation of the underlying metadata honors
+  // the provided flags.  For example, the call NewArena(kAsyncSignalSafe)
+  // is itself async-signal-safe, as well as generatating an arena that provides
+  // async-signal-safe Alloc/Free.
+  static Arena *NewArena(int32_t flags);
+
+  // Destroys an arena allocated by NewArena and returns true,
+  // provided no allocated blocks remain in the arena.
+  // If allocated blocks remain in the arena, does nothing and
+  // returns false.
+  // It is illegal to attempt to destroy the DefaultArena().
+  static bool DeleteArena(Arena *arena);
+
+  // The default arena that always exists.
+  static Arena *DefaultArena();
+
+ private:
+  LowLevelAlloc();      // no instances
+};
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/low_level_scheduling.h b/CAPI/cpp/grpc/include/absl/base/internal/low_level_scheduling.h
new file mode 100644
index 0000000..9baccc0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/low_level_scheduling.h
@@ -0,0 +1,134 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Core interfaces and definitions used by by low-level interfaces such as
+// SpinLock.
+
+#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
+#define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/macros.h"
+
+// The following two declarations exist so SchedulingGuard may friend them with
+// the appropriate language linkage.  These callbacks allow libc internals, such
+// as function level statics, to schedule cooperatively when locking.
+extern "C" bool __google_disable_rescheduling(void);
+extern "C" void __google_enable_rescheduling(bool disable_result);
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+class CondVar;
+class Mutex;
+
+namespace synchronization_internal {
+int MutexDelay(int32_t c, int mode);
+}  // namespace synchronization_internal
+
+namespace base_internal {
+
+class SchedulingHelper;  // To allow use of SchedulingGuard.
+class SpinLock;          // To allow use of SchedulingGuard.
+
+// SchedulingGuard
+// Provides guard semantics that may be used to disable cooperative rescheduling
+// of the calling thread within specific program blocks.  This is used to
+// protect resources (e.g. low-level SpinLocks or Domain code) that cooperative
+// scheduling depends on.
+//
+// Domain implementations capable of rescheduling in reaction to involuntary
+// kernel thread actions (e.g blocking due to a pagefault or syscall) must
+// guarantee that an annotated thread is not allowed to (cooperatively)
+// reschedule until the annotated region is complete.
+//
+// It is an error to attempt to use a cooperatively scheduled resource (e.g.
+// Mutex) within a rescheduling-disabled region.
+//
+// All methods are async-signal safe.
+class SchedulingGuard {
+ public:
+  // Returns true iff the calling thread may be cooperatively rescheduled.
+  static bool ReschedulingIsAllowed();
+  SchedulingGuard(const SchedulingGuard&) = delete;
+  SchedulingGuard& operator=(const SchedulingGuard&) = delete;
+
+ private:
+  // Disable cooperative rescheduling of the calling thread.  It may still
+  // initiate scheduling operations (e.g. wake-ups), however, it may not itself
+  // reschedule.  Nestable.  The returned result is opaque, clients should not
+  // attempt to interpret it.
+  // REQUIRES: Result must be passed to a pairing EnableScheduling().
+  static bool DisableRescheduling();
+
+  // Marks the end of a rescheduling disabled region, previously started by
+  // DisableRescheduling().
+  // REQUIRES: Pairs with innermost call (and result) of DisableRescheduling().
+  static void EnableRescheduling(bool disable_result);
+
+  // A scoped helper for {Disable, Enable}Rescheduling().
+  // REQUIRES: destructor must run in same thread as constructor.
+  struct ScopedDisable {
+    ScopedDisable() { disabled = SchedulingGuard::DisableRescheduling(); }
+    ~ScopedDisable() { SchedulingGuard::EnableRescheduling(disabled); }
+
+    bool disabled;
+  };
+
+  // A scoped helper to enable rescheduling temporarily.
+  // REQUIRES: destructor must run in same thread as constructor.
+  class ScopedEnable {
+   public:
+    ScopedEnable();
+    ~ScopedEnable();
+
+   private:
+    int scheduling_disabled_depth_;
+  };
+
+  // Access to SchedulingGuard is explicitly permitted.
+  friend class absl::CondVar;
+  friend class absl::Mutex;
+  friend class SchedulingHelper;
+  friend class SpinLock;
+  friend int absl::synchronization_internal::MutexDelay(int32_t c, int mode);
+};
+
+//------------------------------------------------------------------------------
+// End of public interfaces.
+//------------------------------------------------------------------------------
+
+inline bool SchedulingGuard::ReschedulingIsAllowed() {
+  return false;
+}
+
+inline bool SchedulingGuard::DisableRescheduling() {
+  return false;
+}
+
+inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
+  return;
+}
+
+inline SchedulingGuard::ScopedEnable::ScopedEnable()
+    : scheduling_disabled_depth_(0) {}
+inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
+  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/per_thread_tls.h b/CAPI/cpp/grpc/include/absl/base/internal/per_thread_tls.h
new file mode 100644
index 0000000..cf5e97a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/per_thread_tls.h
@@ -0,0 +1,52 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
+#define ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
+
+// This header defines two macros:
+//
+// If the platform supports thread-local storage:
+//
+// * ABSL_PER_THREAD_TLS_KEYWORD is the C keyword needed to declare a
+//   thread-local variable
+// * ABSL_PER_THREAD_TLS is 1
+//
+// Otherwise:
+//
+// * ABSL_PER_THREAD_TLS_KEYWORD is empty
+// * ABSL_PER_THREAD_TLS is 0
+//
+// Microsoft C supports thread-local storage.
+// GCC supports it if the appropriate version of glibc is available,
+// which the programmer can indicate by defining ABSL_HAVE_TLS
+
+#include "absl/base/port.h"  // For ABSL_HAVE_TLS
+
+#if defined(ABSL_PER_THREAD_TLS)
+#error ABSL_PER_THREAD_TLS cannot be directly set
+#elif defined(ABSL_PER_THREAD_TLS_KEYWORD)
+#error ABSL_PER_THREAD_TLS_KEYWORD cannot be directly set
+#elif defined(ABSL_HAVE_TLS)
+#define ABSL_PER_THREAD_TLS_KEYWORD __thread
+#define ABSL_PER_THREAD_TLS 1
+#elif defined(_MSC_VER)
+#define ABSL_PER_THREAD_TLS_KEYWORD __declspec(thread)
+#define ABSL_PER_THREAD_TLS 1
+#else
+#define ABSL_PER_THREAD_TLS_KEYWORD
+#define ABSL_PER_THREAD_TLS 0
+#endif
+
+#endif  // ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/prefetch.h b/CAPI/cpp/grpc/include/absl/base/internal/prefetch.h
new file mode 100644
index 0000000..0641928
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/prefetch.h
@@ -0,0 +1,138 @@
+// Copyright 2022 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_PREFETCH_H_
+#define ABSL_BASE_INTERNAL_PREFETCH_H_
+
+#include "absl/base/config.h"
+
+#ifdef __SSE__
+#include <xmmintrin.h>
+#endif
+
+#if defined(_MSC_VER) && defined(ABSL_INTERNAL_HAVE_SSE)
+#include <intrin.h>
+#pragma intrinsic(_mm_prefetch)
+#endif
+
+// Compatibility wrappers around __builtin_prefetch, to prefetch data
+// for read if supported by the toolchain.
+
+// Move data into the cache before it is read, or "prefetch" it.
+//
+// The value of `addr` is the address of the memory to prefetch. If
+// the target and compiler support it, data prefetch instructions are
+// generated. If the prefetch is done some time before the memory is
+// read, it may be in the cache by the time the read occurs.
+//
+// The function names specify the temporal locality heuristic applied,
+// using the names of Intel prefetch instructions:
+//
+//   T0 - high degree of temporal locality; data should be left in as
+//        many levels of the cache possible
+//   T1 - moderate degree of temporal locality
+//   T2 - low degree of temporal locality
+//   Nta - no temporal locality, data need not be left in the cache
+//         after the read
+//
+// Incorrect or gratuitous use of these functions can degrade
+// performance, so use them only when representative benchmarks show
+// an improvement.
+//
+// Example usage:
+//
+//   absl::base_internal::PrefetchT0(addr);
+//
+// Currently, the different prefetch calls behave on some Intel
+// architectures as follows:
+//
+//                 SNB..SKL   SKX
+// PrefetchT0()   L1/L2/L3  L1/L2
+// PrefetchT1()      L2/L3     L2
+// PrefetchT2()      L2/L3     L2
+// PrefetchNta()  L1/--/L3  L1*
+//
+// * On SKX PrefetchNta() will bring the line into L1 but will evict
+//   from L3 cache. This might result in surprising behavior.
+//
+// SNB = Sandy Bridge, SKL = Skylake, SKX = Skylake Xeon.
+//
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+void PrefetchT0(const void* addr);
+void PrefetchT1(const void* addr);
+void PrefetchT2(const void* addr);
+void PrefetchNta(const void* addr);
+
+// Implementation details follow.
+
+#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
+
+#define ABSL_INTERNAL_HAVE_PREFETCH 1
+
+// See __builtin_prefetch:
+// https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html.
+//
+// These functions speculatively load for read only. This is
+// safe for all currently supported platforms. However, prefetch for
+// store may have problems depending on the target platform.
+//
+inline void PrefetchT0(const void* addr) {
+  // Note: this uses prefetcht0 on Intel.
+  __builtin_prefetch(addr, 0, 3);
+}
+inline void PrefetchT1(const void* addr) {
+  // Note: this uses prefetcht1 on Intel.
+  __builtin_prefetch(addr, 0, 2);
+}
+inline void PrefetchT2(const void* addr) {
+  // Note: this uses prefetcht2 on Intel.
+  __builtin_prefetch(addr, 0, 1);
+}
+inline void PrefetchNta(const void* addr) {
+  // Note: this uses prefetchtnta on Intel.
+  __builtin_prefetch(addr, 0, 0);
+}
+
+#elif defined(ABSL_INTERNAL_HAVE_SSE)
+
+#define ABSL_INTERNAL_HAVE_PREFETCH 1
+
+inline void PrefetchT0(const void* addr) {
+  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T0);
+}
+inline void PrefetchT1(const void* addr) {
+  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T1);
+}
+inline void PrefetchT2(const void* addr) {
+  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T2);
+}
+inline void PrefetchNta(const void* addr) {
+  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_NTA);
+}
+
+#else
+inline void PrefetchT0(const void*) {}
+inline void PrefetchT1(const void*) {}
+inline void PrefetchT2(const void*) {}
+inline void PrefetchNta(const void*) {}
+#endif
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_PREFETCH_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/pretty_function.h b/CAPI/cpp/grpc/include/absl/base/internal/pretty_function.h
new file mode 100644
index 0000000..35d5167
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/pretty_function.h
@@ -0,0 +1,33 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
+#define ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
+
+// ABSL_PRETTY_FUNCTION
+//
+// In C++11, __func__ gives the undecorated name of the current function.  That
+// is, "main", not "int main()".  Various compilers give extra macros to get the
+// decorated function name, including return type and arguments, to
+// differentiate between overload sets.  ABSL_PRETTY_FUNCTION is a portable
+// version of these macros which forwards to the correct macro on each compiler.
+#if defined(_MSC_VER)
+#define ABSL_PRETTY_FUNCTION __FUNCSIG__
+#elif defined(__GNUC__)
+#define ABSL_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#else
+#error "Unsupported compiler"
+#endif
+
+#endif  // ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h b/CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h
new file mode 100644
index 0000000..0747c9d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h
@@ -0,0 +1,196 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Thread-safe logging routines that do not allocate any memory or
+// acquire any locks, and can therefore be used by low-level memory
+// allocation, synchronization, and signal-handling code.
+
+#ifndef ABSL_BASE_INTERNAL_RAW_LOGGING_H_
+#define ABSL_BASE_INTERNAL_RAW_LOGGING_H_
+
+#include <string>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/atomic_hook.h"
+#include "absl/base/log_severity.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+
+// This is similar to LOG(severity) << format..., but
+// * it is to be used ONLY by low-level modules that can't use normal LOG()
+// * it is designed to be a low-level logger that does not allocate any
+//   memory and does not need any locks, hence:
+// * it logs straight and ONLY to STDERR w/o buffering
+// * it uses an explicit printf-format and arguments list
+// * it will silently chop off really long message strings
+// Usage example:
+//   ABSL_RAW_LOG(ERROR, "Failed foo with %i: %s", status, error);
+// This will print an almost standard log line like this to stderr only:
+//   E0821 211317 file.cc:123] RAW: Failed foo with 22: bad_file
+
+#define ABSL_RAW_LOG(severity, ...)                                            \
+  do {                                                                         \
+    constexpr const char* absl_raw_logging_internal_basename =                 \
+        ::absl::raw_logging_internal::Basename(__FILE__,                       \
+                                               sizeof(__FILE__) - 1);          \
+    ::absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, \
+                                         absl_raw_logging_internal_basename,   \
+                                         __LINE__, __VA_ARGS__);               \
+  } while (0)
+
+// Similar to CHECK(condition) << message, but for low-level modules:
+// we use only ABSL_RAW_LOG that does not allocate memory.
+// We do not want to provide args list here to encourage this usage:
+//   if (!cond)  ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
+// so that the args are not computed when not needed.
+#define ABSL_RAW_CHECK(condition, message)                             \
+  do {                                                                 \
+    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
+      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
+    }                                                                  \
+  } while (0)
+
+// ABSL_INTERNAL_LOG and ABSL_INTERNAL_CHECK work like the RAW variants above,
+// except that if the richer log library is linked into the binary, we dispatch
+// to that instead.  This is potentially useful for internal logging and
+// assertions, where we are using RAW_LOG neither for its async-signal-safety
+// nor for its non-allocating nature, but rather because raw logging has very
+// few other dependencies.
+//
+// The API is a subset of the above: each macro only takes two arguments.  Use
+// StrCat if you need to build a richer message.
+#define ABSL_INTERNAL_LOG(severity, message)                                 \
+  do {                                                                       \
+    constexpr const char* absl_raw_logging_internal_filename = __FILE__;     \
+    ::absl::raw_logging_internal::internal_log_function(                     \
+        ABSL_RAW_LOGGING_INTERNAL_##severity,                                \
+        absl_raw_logging_internal_filename, __LINE__, message);              \
+    if (ABSL_RAW_LOGGING_INTERNAL_##severity == ::absl::LogSeverity::kFatal) \
+      ABSL_INTERNAL_UNREACHABLE;                                             \
+  } while (0)
+
+#define ABSL_INTERNAL_CHECK(condition, message)                    \
+  do {                                                             \
+    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
+      std::string death_message = "Check " #condition " failed: "; \
+      death_message += std::string(message);                       \
+      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
+    }                                                              \
+  } while (0)
+
+#define ABSL_RAW_LOGGING_INTERNAL_INFO ::absl::LogSeverity::kInfo
+#define ABSL_RAW_LOGGING_INTERNAL_WARNING ::absl::LogSeverity::kWarning
+#define ABSL_RAW_LOGGING_INTERNAL_ERROR ::absl::LogSeverity::kError
+#define ABSL_RAW_LOGGING_INTERNAL_FATAL ::absl::LogSeverity::kFatal
+#define ABSL_RAW_LOGGING_INTERNAL_LEVEL(severity) \
+  ::absl::NormalizeLogSeverity(severity)
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace raw_logging_internal {
+
+// Helper function to implement ABSL_RAW_LOG
+// Logs format... at "severity" level, reporting it
+// as called from file:line.
+// This does not allocate memory or acquire locks.
+void RawLog(absl::LogSeverity severity, const char* file, int line,
+            const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
+
+// Writes the provided buffer directly to stderr, in a signal-safe, low-level
+// manner.
+void AsyncSignalSafeWriteToStderr(const char* s, size_t len);
+
+// compile-time function to get the "base" filename, that is, the part of
+// a filename after the last "/" or "\" path separator.  The search starts at
+// the end of the string; the second parameter is the length of the string.
+constexpr const char* Basename(const char* fname, int offset) {
+  return offset == 0 || fname[offset - 1] == '/' || fname[offset - 1] == '\\'
+             ? fname + offset
+             : Basename(fname, offset - 1);
+}
+
+// For testing only.
+// Returns true if raw logging is fully supported. When it is not
+// fully supported, no messages will be emitted, but a log at FATAL
+// severity will cause an abort.
+//
+// TODO(gfalcon): Come up with a better name for this method.
+bool RawLoggingFullySupported();
+
+// Function type for a raw_logging customization hook for suppressing messages
+// by severity, and for writing custom prefixes on non-suppressed messages.
+//
+// The installed hook is called for every raw log invocation.  The message will
+// be logged to stderr only if the hook returns true.  FATAL errors will cause
+// the process to abort, even if writing to stderr is suppressed.  The hook is
+// also provided with an output buffer, where it can write a custom log message
+// prefix.
+//
+// The raw_logging system does not allocate memory or grab locks.  User-provided
+// hooks must avoid these operations, and must not throw exceptions.
+//
+// 'severity' is the severity level of the message being written.
+// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
+// was located.
+// 'buf' and 'buf_size' are pointers to the buffer and buffer size.  If the
+// hook writes a prefix, it must increment *buf and decrement *buf_size
+// accordingly.
+using LogFilterAndPrefixHook = bool (*)(absl::LogSeverity severity,
+                                        const char* file, int line, char** buf,
+                                        int* buf_size);
+
+// Function type for a raw_logging customization hook called to abort a process
+// when a FATAL message is logged.  If the provided AbortHook() returns, the
+// logging system will call abort().
+//
+// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
+// was located.
+// The NUL-terminated logged message lives in the buffer between 'buf_start'
+// and 'buf_end'.  'prefix_end' points to the first non-prefix character of the
+// buffer (as written by the LogFilterAndPrefixHook.)
+//
+// The lifetime of the filename and message buffers will not end while the
+// process remains alive.
+using AbortHook = void (*)(const char* file, int line, const char* buf_start,
+                           const char* prefix_end, const char* buf_end);
+
+// Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
+//
+// TODO(gfalcon): When string_view no longer depends on base, change this
+// interface to take its message as a string_view instead.
+using InternalLogFunction = void (*)(absl::LogSeverity severity,
+                                     const char* file, int line,
+                                     const std::string& message);
+
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL extern base_internal::AtomicHook<
+    InternalLogFunction>
+    internal_log_function;
+
+// Registers hooks of the above types.  Only a single hook of each type may be
+// registered.  It is an error to call these functions multiple times with
+// different input arguments.
+//
+// These functions are safe to call at any point during initialization; they do
+// not block or malloc, and are async-signal safe.
+void RegisterLogFilterAndPrefixHook(LogFilterAndPrefixHook func);
+void RegisterAbortHook(AbortHook func);
+void RegisterInternalLogFunction(InternalLogFunction func);
+
+}  // namespace raw_logging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_RAW_LOGGING_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/scheduling_mode.h b/CAPI/cpp/grpc/include/absl/base/internal/scheduling_mode.h
new file mode 100644
index 0000000..8be5ab6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/scheduling_mode.h
@@ -0,0 +1,58 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Core interfaces and definitions used by by low-level interfaces such as
+// SpinLock.
+
+#ifndef ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
+#define ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// Used to describe how a thread may be scheduled.  Typically associated with
+// the declaration of a resource supporting synchronized access.
+//
+// SCHEDULE_COOPERATIVE_AND_KERNEL:
+// Specifies that when waiting, a cooperative thread (e.g. a Fiber) may
+// reschedule (using base::scheduling semantics); allowing other cooperative
+// threads to proceed.
+//
+// SCHEDULE_KERNEL_ONLY: (Also described as "non-cooperative")
+// Specifies that no cooperative scheduling semantics may be used, even if the
+// current thread is itself cooperatively scheduled.  This means that
+// cooperative threads will NOT allow other cooperative threads to execute in
+// their place while waiting for a resource of this type.  Host operating system
+// semantics (e.g. a futex) may still be used.
+//
+// When optional, clients should strongly prefer SCHEDULE_COOPERATIVE_AND_KERNEL
+// by default.  SCHEDULE_KERNEL_ONLY should only be used for resources on which
+// base::scheduling (e.g. the implementation of a Scheduler) may depend.
+//
+// NOTE: Cooperative resources may not be nested below non-cooperative ones.
+// This means that it is invalid to to acquire a SCHEDULE_COOPERATIVE_AND_KERNEL
+// resource if a SCHEDULE_KERNEL_ONLY resource is already held.
+enum SchedulingMode {
+  SCHEDULE_KERNEL_ONLY = 0,         // Allow scheduling only the host OS.
+  SCHEDULE_COOPERATIVE_AND_KERNEL,  // Also allow cooperative scheduling.
+};
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/scoped_set_env.h b/CAPI/cpp/grpc/include/absl/base/internal/scoped_set_env.h
new file mode 100644
index 0000000..19ec7b5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/scoped_set_env.h
@@ -0,0 +1,45 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
+#define ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
+
+#include <string>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+class ScopedSetEnv {
+ public:
+  ScopedSetEnv(const char* var_name, const char* new_value);
+  ~ScopedSetEnv();
+
+ private:
+  std::string var_name_;
+  std::string old_value_;
+
+  // True if the environment variable was initially not set.
+  bool was_unset_;
+};
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/spinlock.h b/CAPI/cpp/grpc/include/absl/base/internal/spinlock.h
new file mode 100644
index 0000000..6d8d8dd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/spinlock.h
@@ -0,0 +1,256 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+//  Most users requiring mutual exclusion should use Mutex.
+//  SpinLock is provided for use in two situations:
+//   - for use by Abseil internal code that Mutex itself depends on
+//   - for async signal safety (see below)
+
+// SpinLock is async signal safe.  If a spinlock is used within a signal
+// handler, all code that acquires the lock must ensure that the signal cannot
+// arrive while they are holding the lock.  Typically, this is done by blocking
+// the signal.
+//
+// Threads waiting on a SpinLock may be woken in an arbitrary order.
+
+#ifndef ABSL_BASE_INTERNAL_SPINLOCK_H_
+#define ABSL_BASE_INTERNAL_SPINLOCK_H_
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <atomic>
+
+#include "absl/base/attributes.h"
+#include "absl/base/const_init.h"
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/low_level_scheduling.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/internal/tsan_mutex_interface.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/base/thread_annotations.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+class ABSL_LOCKABLE SpinLock {
+ public:
+  SpinLock() : lockword_(kSpinLockCooperative) {
+    ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+  }
+
+  // Constructors that allow non-cooperative spinlocks to be created for use
+  // inside thread schedulers.  Normal clients should not use these.
+  explicit SpinLock(base_internal::SchedulingMode mode);
+
+  // Constructor for global SpinLock instances.  See absl/base/const_init.h.
+  constexpr SpinLock(absl::ConstInitType, base_internal::SchedulingMode mode)
+      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {}
+
+  // For global SpinLock instances prefer trivial destructor when possible.
+  // Default but non-trivial destructor in some build configurations causes an
+  // extra static initializer.
+#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+  ~SpinLock() { ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static); }
+#else
+  ~SpinLock() = default;
+#endif
+
+  // Acquire this SpinLock.
+  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+    if (!TryLockImpl()) {
+      SlowLock();
+    }
+    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+  }
+
+  // Try to acquire this SpinLock without blocking and return true if the
+  // acquisition was successful.  If the lock was not acquired, false is
+  // returned.  If this SpinLock is free at the time of the call, TryLock
+  // will return true with high probability.
+  inline bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
+    bool res = TryLockImpl();
+    ABSL_TSAN_MUTEX_POST_LOCK(
+        this, __tsan_mutex_try_lock | (res ? 0 : __tsan_mutex_try_lock_failed),
+        0);
+    return res;
+  }
+
+  // Release this SpinLock, which must be held by the calling thread.
+  inline void Unlock() ABSL_UNLOCK_FUNCTION() {
+    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
+    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
+    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
+                                    std::memory_order_release);
+
+    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
+      base_internal::SchedulingGuard::EnableRescheduling(true);
+    }
+    if ((lock_value & kWaitTimeMask) != 0) {
+      // Collect contentionz profile info, and speed the wakeup of any waiter.
+      // The wait_cycles value indicates how long this thread spent waiting
+      // for the lock.
+      SlowUnlock(lock_value);
+    }
+    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
+  }
+
+  // Determine if the lock is held.  When the lock is held by the invoking
+  // thread, true will always be returned. Intended to be used as
+  // CHECK(lock.IsHeld()).
+  inline bool IsHeld() const {
+    return (lockword_.load(std::memory_order_relaxed) & kSpinLockHeld) != 0;
+  }
+
+  // Return immediately if this thread holds the SpinLock exclusively.
+  // Otherwise, report an error by crashing with a diagnostic.
+  inline void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK() {
+    if (!IsHeld()) {
+      ABSL_RAW_LOG(FATAL, "thread should hold the lock on SpinLock");
+    }
+  }
+
+ protected:
+  // These should not be exported except for testing.
+
+  // Store number of cycles between wait_start_time and wait_end_time in a
+  // lock value.
+  static uint32_t EncodeWaitCycles(int64_t wait_start_time,
+                                   int64_t wait_end_time);
+
+  // Extract number of wait cycles in a lock value.
+  static uint64_t DecodeWaitCycles(uint32_t lock_value);
+
+  // Provide access to protected method above.  Use for testing only.
+  friend struct SpinLockTest;
+
+ private:
+  // lockword_ is used to store the following:
+  //
+  // bit[0] encodes whether a lock is being held.
+  // bit[1] encodes whether a lock uses cooperative scheduling.
+  // bit[2] encodes whether the current lock holder disabled scheduling when
+  //        acquiring the lock. Only set when kSpinLockHeld is also set.
+  // bit[3:31] encodes time a lock spent on waiting as a 29-bit unsigned int.
+  //        This is set by the lock holder to indicate how long it waited on
+  //        the lock before eventually acquiring it. The number of cycles is
+  //        encoded as a 29-bit unsigned int, or in the case that the current
+  //        holder did not wait but another waiter is queued, the LSB
+  //        (kSpinLockSleeper) is set. The implementation does not explicitly
+  //        track the number of queued waiters beyond this. It must always be
+  //        assumed that waiters may exist if the current holder was required to
+  //        queue.
+  //
+  // Invariant: if the lock is not held, the value is either 0 or
+  // kSpinLockCooperative.
+  static constexpr uint32_t kSpinLockHeld = 1;
+  static constexpr uint32_t kSpinLockCooperative = 2;
+  static constexpr uint32_t kSpinLockDisabledScheduling = 4;
+  static constexpr uint32_t kSpinLockSleeper = 8;
+  // Includes kSpinLockSleeper.
+  static constexpr uint32_t kWaitTimeMask =
+      ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling);
+
+  // Returns true if the provided scheduling mode is cooperative.
+  static constexpr bool IsCooperative(
+      base_internal::SchedulingMode scheduling_mode) {
+    return scheduling_mode == base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
+  }
+
+  uint32_t TryLockInternal(uint32_t lock_value, uint32_t wait_cycles);
+  void SlowLock() ABSL_ATTRIBUTE_COLD;
+  void SlowUnlock(uint32_t lock_value) ABSL_ATTRIBUTE_COLD;
+  uint32_t SpinLoop();
+
+  inline bool TryLockImpl() {
+    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
+    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
+  }
+
+  std::atomic<uint32_t> lockword_;
+
+  SpinLock(const SpinLock&) = delete;
+  SpinLock& operator=(const SpinLock&) = delete;
+};
+
+// Corresponding locker object that arranges to acquire a spinlock for
+// the duration of a C++ scope.
+class ABSL_SCOPED_LOCKABLE SpinLockHolder {
+ public:
+  inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
+      : lock_(l) {
+    l->Lock();
+  }
+  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
+
+  SpinLockHolder(const SpinLockHolder&) = delete;
+  SpinLockHolder& operator=(const SpinLockHolder&) = delete;
+
+ private:
+  SpinLock* lock_;
+};
+
+// Register a hook for profiling support.
+//
+// The function pointer registered here will be called whenever a spinlock is
+// contended.  The callback is given an opaque handle to the contended spinlock
+// and the number of wait cycles.  This is thread-safe, but only a single
+// profiler can be registered.  It is an error to call this function multiple
+// times with different arguments.
+void RegisterSpinLockProfiler(void (*fn)(const void* lock,
+                                         int64_t wait_cycles));
+
+//------------------------------------------------------------------------------
+// Public interface ends here.
+//------------------------------------------------------------------------------
+
+// If (result & kSpinLockHeld) == 0, then *this was successfully locked.
+// Otherwise, returns last observed value for lockword_.
+inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
+                                          uint32_t wait_cycles) {
+  if ((lock_value & kSpinLockHeld) != 0) {
+    return lock_value;
+  }
+
+  uint32_t sched_disabled_bit = 0;
+  if ((lock_value & kSpinLockCooperative) == 0) {
+    // For non-cooperative locks we must make sure we mark ourselves as
+    // non-reschedulable before we attempt to CompareAndSwap.
+    if (base_internal::SchedulingGuard::DisableRescheduling()) {
+      sched_disabled_bit = kSpinLockDisabledScheduling;
+    }
+  }
+
+  if (!lockword_.compare_exchange_strong(
+          lock_value,
+          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
+          std::memory_order_acquire, std::memory_order_relaxed)) {
+    base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
+  }
+
+  return lock_value;
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_SPINLOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/spinlock_akaros.inc b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_akaros.inc
new file mode 100644
index 0000000..7b0cada
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_akaros.inc
@@ -0,0 +1,35 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This file is an Akaros-specific part of spinlock_wait.cc
+
+#include <atomic>
+
+#include "absl/base/internal/scheduling_mode.h"
+
+extern "C" {
+
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */,
+    int /* loop */, absl::base_internal::SchedulingMode /* mode */) {
+  // In Akaros, one must take care not to call anything that could cause a
+  // malloc(), a blocking system call, or a uthread_yield() while holding a
+  // spinlock. Our callers assume will not call into libraries or other
+  // arbitrary code.
+}
+
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
+    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
+
+}  // extern "C"
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/spinlock_linux.inc b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_linux.inc
new file mode 100644
index 0000000..fe8ba67
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_linux.inc
@@ -0,0 +1,71 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This file is a Linux-specific part of spinlock_wait.cc
+
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#include <atomic>
+#include <climits>
+#include <cstdint>
+#include <ctime>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/errno_saver.h"
+
+// The SpinLock lockword is `std::atomic<uint32_t>`. Here we assert that
+// `std::atomic<uint32_t>` is bitwise equivalent of the `int` expected
+// by SYS_futex. We also assume that reads/writes done to the lockword
+// by SYS_futex have rational semantics with regard to the
+// std::atomic<> API. C++ provides no guarantees of these assumptions,
+// but they are believed to hold in practice.
+static_assert(sizeof(std::atomic<uint32_t>) == sizeof(int),
+              "SpinLock lockword has the wrong size for a futex");
+
+// Some Android headers are missing these definitions even though they
+// support these futex operations.
+#ifdef __BIONIC__
+#ifndef SYS_futex
+#define SYS_futex __NR_futex
+#endif
+#ifndef FUTEX_PRIVATE_FLAG
+#define FUTEX_PRIVATE_FLAG 128
+#endif
+#endif
+
+#if defined(__NR_futex_time64) && !defined(SYS_futex_time64)
+#define SYS_futex_time64 __NR_futex_time64
+#endif
+
+#if defined(SYS_futex_time64) && !defined(SYS_futex)
+#define SYS_futex SYS_futex_time64
+#endif
+
+extern "C" {
+
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+    std::atomic<uint32_t> *w, uint32_t value, int,
+    absl::base_internal::SchedulingMode) {
+  absl::base_internal::ErrnoSaver errno_saver;
+  syscall(SYS_futex, w, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, value, nullptr);
+}
+
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
+    std::atomic<uint32_t> *w, bool all) {
+  syscall(SYS_futex, w, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, all ? INT_MAX : 1, 0);
+}
+
+}  // extern "C"
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/spinlock_posix.inc b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_posix.inc
new file mode 100644
index 0000000..4f6f887
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_posix.inc
@@ -0,0 +1,46 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This file is a Posix-specific part of spinlock_wait.cc
+
+#include <sched.h>
+
+#include <atomic>
+#include <ctime>
+
+#include "absl/base/internal/errno_saver.h"
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/port.h"
+
+extern "C" {
+
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop,
+    absl::base_internal::SchedulingMode /* mode */) {
+  absl::base_internal::ErrnoSaver errno_saver;
+  if (loop == 0) {
+  } else if (loop == 1) {
+    sched_yield();
+  } else {
+    struct timespec tm;
+    tm.tv_sec = 0;
+    tm.tv_nsec = absl::base_internal::SpinLockSuggestedDelayNS(loop);
+    nanosleep(&tm, nullptr);
+  }
+}
+
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
+    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
+
+}  // extern "C"
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/spinlock_wait.h b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_wait.h
new file mode 100644
index 0000000..9a1adcd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_wait.h
@@ -0,0 +1,95 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
+#define ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
+
+// Operations to make atomic transitions on a word, and to allow
+// waiting for those transitions to become possible.
+
+#include <stdint.h>
+#include <atomic>
+
+#include "absl/base/internal/scheduling_mode.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// SpinLockWait() waits until it can perform one of several transitions from
+// "from" to "to".  It returns when it performs a transition where done==true.
+struct SpinLockWaitTransition {
+  uint32_t from;
+  uint32_t to;
+  bool done;
+};
+
+// Wait until *w can transition from trans[i].from to trans[i].to for some i
+// satisfying 0<=i<n && trans[i].done, atomically make the transition,
+// then return the old value of *w.   Make any other atomic transitions
+// where !trans[i].done, but continue waiting.
+//
+// Wakeups for threads blocked on SpinLockWait do not respect priorities.
+uint32_t SpinLockWait(std::atomic<uint32_t> *w, int n,
+                      const SpinLockWaitTransition trans[],
+                      SchedulingMode scheduling_mode);
+
+// If possible, wake some thread that has called SpinLockDelay(w, ...). If `all`
+// is true, wake all such threads. On some systems, this may be a no-op; on
+// those systems, threads calling SpinLockDelay() will always wake eventually
+// even if SpinLockWake() is never called.
+void SpinLockWake(std::atomic<uint32_t> *w, bool all);
+
+// Wait for an appropriate spin delay on iteration "loop" of a
+// spin loop on location *w, whose previously observed value was "value".
+// SpinLockDelay() may do nothing, may yield the CPU, may sleep a clock tick,
+// or may wait for a call to SpinLockWake(w).
+void SpinLockDelay(std::atomic<uint32_t> *w, uint32_t value, int loop,
+                   base_internal::SchedulingMode scheduling_mode);
+
+// Helper used by AbslInternalSpinLockDelay.
+// Returns a suggested delay in nanoseconds for iteration number "loop".
+int SpinLockSuggestedDelayNS(int loop);
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// In some build configurations we pass --detect-odr-violations to the
+// gold linker.  This causes it to flag weak symbol overrides as ODR
+// violations.  Because ODR only applies to C++ and not C,
+// --detect-odr-violations ignores symbols not mangled with C++ names.
+// By changing our extension points to be extern "C", we dodge this
+// check.
+extern "C" {
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(std::atomic<uint32_t> *w,
+                                                      bool all);
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+    std::atomic<uint32_t> *w, uint32_t value, int loop,
+    absl::base_internal::SchedulingMode scheduling_mode);
+}
+
+inline void absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w,
+                                              bool all) {
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(w, all);
+}
+
+inline void absl::base_internal::SpinLockDelay(
+    std::atomic<uint32_t> *w, uint32_t value, int loop,
+    absl::base_internal::SchedulingMode scheduling_mode) {
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)
+  (w, value, loop, scheduling_mode);
+}
+
+#endif  // ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/spinlock_win32.inc b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_win32.inc
new file mode 100644
index 0000000..9d22481
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_win32.inc
@@ -0,0 +1,37 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This file is a Win32-specific part of spinlock_wait.cc
+
+#include <windows.h>
+#include <atomic>
+#include "absl/base/internal/scheduling_mode.h"
+
+extern "C" {
+
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop,
+    absl::base_internal::SchedulingMode /* mode */) {
+  if (loop == 0) {
+  } else if (loop == 1) {
+    Sleep(0);
+  } else {
+    Sleep(absl::base_internal::SpinLockSuggestedDelayNS(loop) / 1000000);
+  }
+}
+
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
+    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
+
+}  // extern "C"
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/strerror.h b/CAPI/cpp/grpc/include/absl/base/internal/strerror.h
new file mode 100644
index 0000000..3500973
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/strerror.h
@@ -0,0 +1,39 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_INTERNAL_STRERROR_H_
+#define ABSL_BASE_INTERNAL_STRERROR_H_
+
+#include <string>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// A portable and thread-safe alternative to C89's `strerror`.
+//
+// The C89 specification of `strerror` is not suitable for use in a
+// multi-threaded application as the returned string may be changed by calls to
+// `strerror` from another thread.  The many non-stdlib alternatives differ
+// enough in their names, availability, and semantics to justify this wrapper
+// around them.  `errno` will not be modified by a call to `absl::StrError`.
+std::string StrError(int errnum);
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_STRERROR_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/sysinfo.h b/CAPI/cpp/grpc/include/absl/base/internal/sysinfo.h
new file mode 100644
index 0000000..119cf1f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/sysinfo.h
@@ -0,0 +1,74 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This file includes routines to find out characteristics
+// of the machine a program is running on.  It is undoubtedly
+// system-dependent.
+
+// Functions listed here that accept a pid_t as an argument act on the
+// current process if the pid_t argument is 0
+// All functions here are thread-hostile due to file caching unless
+// commented otherwise.
+
+#ifndef ABSL_BASE_INTERNAL_SYSINFO_H_
+#define ABSL_BASE_INTERNAL_SYSINFO_H_
+
+#ifndef _WIN32
+#include <sys/types.h>
+#endif
+
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/base/port.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// Nominal core processor cycles per second of each processor.   This is _not_
+// necessarily the frequency of the CycleClock counter (see cycleclock.h)
+// Thread-safe.
+double NominalCPUFrequency();
+
+// Number of logical processors (hyperthreads) in system. Thread-safe.
+int NumCPUs();
+
+// Return the thread id of the current thread, as told by the system.
+// No two currently-live threads implemented by the OS shall have the same ID.
+// Thread ids of exited threads may be reused.   Multiple user-level threads
+// may have the same thread ID if multiplexed on the same OS thread.
+//
+// On Linux, you may send a signal to the resulting ID with kill().  However,
+// it is recommended for portability that you use pthread_kill() instead.
+#ifdef _WIN32
+// On Windows, process id and thread id are of the same type according to the
+// return types of GetProcessId() and GetThreadId() are both DWORD, an unsigned
+// 32-bit type.
+using pid_t = uint32_t;
+#endif
+pid_t GetTID();
+
+// Like GetTID(), but caches the result in thread-local storage in order
+// to avoid unnecessary system calls. Note that there are some cases where
+// one must call through to GetTID directly, which is why this exists as a
+// separate function. For example, GetCachedTID() is not safe to call in
+// an asynchronous signal-handling context nor right after a call to fork().
+pid_t GetCachedTID();
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_SYSINFO_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/thread_annotations.h b/CAPI/cpp/grpc/include/absl/base/internal/thread_annotations.h
new file mode 100644
index 0000000..4dab6a9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/thread_annotations.h
@@ -0,0 +1,271 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: thread_annotations.h
+// -----------------------------------------------------------------------------
+//
+// WARNING: This is a backwards compatible header and it will be removed after
+// the migration to prefixed thread annotations is finished; please include
+// "absl/base/thread_annotations.h".
+//
+// This header file contains macro definitions for thread safety annotations
+// that allow developers to document the locking policies of multi-threaded
+// code. The annotations can also help program analysis tools to identify
+// potential thread safety issues.
+//
+// These annotations are implemented using compiler attributes. Using the macros
+// defined here instead of raw attributes allow for portability and future
+// compatibility.
+//
+// When referring to mutexes in the arguments of the attributes, you should
+// use variable names or more complex expressions (e.g. my_object->mutex_)
+// that evaluate to a concrete mutex object whenever possible. If the mutex
+// you want to refer to is not in scope, you may use a member pointer
+// (e.g. &MyClass::mutex_) to refer to a mutex in some (unknown) object.
+
+#ifndef ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
+#define ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
+
+#if defined(__clang__)
+#define THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
+#else
+#define THREAD_ANNOTATION_ATTRIBUTE__(x)   // no-op
+#endif
+
+// GUARDED_BY()
+//
+// Documents if a shared field or global variable needs to be protected by a
+// mutex. GUARDED_BY() allows the user to specify a particular mutex that
+// should be held when accessing the annotated variable.
+//
+// Although this annotation (and PT_GUARDED_BY, below) cannot be applied to
+// local variables, a local variable and its associated mutex can often be
+// combined into a small class or struct, thereby allowing the annotation.
+//
+// Example:
+//
+//   class Foo {
+//     Mutex mu_;
+//     int p1_ GUARDED_BY(mu_);
+//     ...
+//   };
+#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+
+// PT_GUARDED_BY()
+//
+// Documents if the memory location pointed to by a pointer should be guarded
+// by a mutex when dereferencing the pointer.
+//
+// Example:
+//   class Foo {
+//     Mutex mu_;
+//     int *p1_ PT_GUARDED_BY(mu_);
+//     ...
+//   };
+//
+// Note that a pointer variable to a shared memory location could itself be a
+// shared variable.
+//
+// Example:
+//
+//   // `q_`, guarded by `mu1_`, points to a shared memory location that is
+//   // guarded by `mu2_`:
+//   int *q_ GUARDED_BY(mu1_) PT_GUARDED_BY(mu2_);
+#define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+// ACQUIRED_AFTER() / ACQUIRED_BEFORE()
+//
+// Documents the acquisition order between locks that can be held
+// simultaneously by a thread. For any two locks that need to be annotated
+// to establish an acquisition order, only one of them needs the annotation.
+// (i.e. You don't have to annotate both locks with both ACQUIRED_AFTER
+// and ACQUIRED_BEFORE.)
+//
+// As with GUARDED_BY, this is only applicable to mutexes that are shared
+// fields or global variables.
+//
+// Example:
+//
+//   Mutex m1_;
+//   Mutex m2_ ACQUIRED_AFTER(m1_);
+#define ACQUIRED_AFTER(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define ACQUIRED_BEFORE(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+// EXCLUSIVE_LOCKS_REQUIRED() / SHARED_LOCKS_REQUIRED()
+//
+// Documents a function that expects a mutex to be held prior to entry.
+// The mutex is expected to be held both on entry to, and exit from, the
+// function.
+//
+// An exclusive lock allows read-write access to the guarded data member(s), and
+// only one thread can acquire a lock exclusively at any one time. A shared lock
+// allows read-only access, and any number of threads can acquire a shared lock
+// concurrently.
+//
+// Generally, non-const methods should be annotated with
+// EXCLUSIVE_LOCKS_REQUIRED, while const methods should be annotated with
+// SHARED_LOCKS_REQUIRED.
+//
+// Example:
+//
+//   Mutex mu1, mu2;
+//   int a GUARDED_BY(mu1);
+//   int b GUARDED_BY(mu2);
+//
+//   void foo() EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... }
+//   void bar() const SHARED_LOCKS_REQUIRED(mu1, mu2) { ... }
+#define EXCLUSIVE_LOCKS_REQUIRED(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+
+#define SHARED_LOCKS_REQUIRED(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+
+// LOCKS_EXCLUDED()
+//
+// Documents the locks acquired in the body of the function. These locks
+// cannot be held when calling this function (as Abseil's `Mutex` locks are
+// non-reentrant).
+#define LOCKS_EXCLUDED(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+// LOCK_RETURNED()
+//
+// Documents a function that returns a mutex without acquiring it.  For example,
+// a public getter method that returns a pointer to a private mutex should
+// be annotated with LOCK_RETURNED.
+#define LOCK_RETURNED(x) \
+  THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+// LOCKABLE
+//
+// Documents if a class/type is a lockable type (such as the `Mutex` class).
+#define LOCKABLE \
+  THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+
+// SCOPED_LOCKABLE
+//
+// Documents if a class does RAII locking (such as the `MutexLock` class).
+// The constructor should use `LOCK_FUNCTION()` to specify the mutex that is
+// acquired, and the destructor should use `UNLOCK_FUNCTION()` with no
+// arguments; the analysis will assume that the destructor unlocks whatever the
+// constructor locked.
+#define SCOPED_LOCKABLE \
+  THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+// EXCLUSIVE_LOCK_FUNCTION()
+//
+// Documents functions that acquire a lock in the body of a function, and do
+// not release it.
+#define EXCLUSIVE_LOCK_FUNCTION(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+
+// SHARED_LOCK_FUNCTION()
+//
+// Documents functions that acquire a shared (reader) lock in the body of a
+// function, and do not release it.
+#define SHARED_LOCK_FUNCTION(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+
+// UNLOCK_FUNCTION()
+//
+// Documents functions that expect a lock to be held on entry to the function,
+// and release it in the body of the function.
+#define UNLOCK_FUNCTION(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+
+// EXCLUSIVE_TRYLOCK_FUNCTION() / SHARED_TRYLOCK_FUNCTION()
+//
+// Documents functions that try to acquire a lock, and return success or failure
+// (or a non-boolean value that can be interpreted as a boolean).
+// The first argument should be `true` for functions that return `true` on
+// success, or `false` for functions that return `false` on success. The second
+// argument specifies the mutex that is locked on success. If unspecified, this
+// mutex is assumed to be `this`.
+#define EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
+
+#define SHARED_TRYLOCK_FUNCTION(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+
+// ASSERT_EXCLUSIVE_LOCK() / ASSERT_SHARED_LOCK()
+//
+// Documents functions that dynamically check to see if a lock is held, and fail
+// if it is not held.
+#define ASSERT_EXCLUSIVE_LOCK(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
+
+#define ASSERT_SHARED_LOCK(...) \
+  THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
+
+// NO_THREAD_SAFETY_ANALYSIS
+//
+// Turns off thread safety checking within the body of a particular function.
+// This annotation is used to mark functions that are known to be correct, but
+// the locking behavior is more complicated than the analyzer can handle.
+#define NO_THREAD_SAFETY_ANALYSIS \
+  THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+
+//------------------------------------------------------------------------------
+// Tool-Supplied Annotations
+//------------------------------------------------------------------------------
+
+// TS_UNCHECKED should be placed around lock expressions that are not valid
+// C++ syntax, but which are present for documentation purposes.  These
+// annotations will be ignored by the analysis.
+#define TS_UNCHECKED(x) ""
+
+// TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
+// It is used by automated tools to mark and disable invalid expressions.
+// The annotation should either be fixed, or changed to TS_UNCHECKED.
+#define TS_FIXME(x) ""
+
+// Like NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body of
+// a particular function.  However, this attribute is used to mark functions
+// that are incorrect and need to be fixed.  It is used by automated tools to
+// avoid breaking the build when the analysis is updated.
+// Code owners are expected to eventually fix the routine.
+#define NO_THREAD_SAFETY_ANALYSIS_FIXME  NO_THREAD_SAFETY_ANALYSIS
+
+// Similar to NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a GUARDED_BY
+// annotation that needs to be fixed, because it is producing thread safety
+// warning.  It disables the GUARDED_BY.
+#define GUARDED_BY_FIXME(x)
+
+// Disables warnings for a single read operation.  This can be used to avoid
+// warnings when it is known that the read is not actually involved in a race,
+// but the compiler cannot confirm that.
+#define TS_UNCHECKED_READ(x) thread_safety_analysis::ts_unchecked_read(x)
+
+
+namespace thread_safety_analysis {
+
+// Takes a reference to a guarded data member, and returns an unguarded
+// reference.
+template <typename T>
+inline const T& ts_unchecked_read(const T& v) NO_THREAD_SAFETY_ANALYSIS {
+  return v;
+}
+
+template <typename T>
+inline T& ts_unchecked_read(T& v) NO_THREAD_SAFETY_ANALYSIS {
+  return v;
+}
+
+}  // namespace thread_safety_analysis
+
+#endif  // ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/thread_identity.h b/CAPI/cpp/grpc/include/absl/base/internal/thread_identity.h
new file mode 100644
index 0000000..659694b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/thread_identity.h
@@ -0,0 +1,265 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Each active thread has an ThreadIdentity that may represent the thread in
+// various level interfaces.  ThreadIdentity objects are never deallocated.
+// When a thread terminates, its ThreadIdentity object may be reused for a
+// thread created later.
+
+#ifndef ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
+#define ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
+
+#ifndef _WIN32
+#include <pthread.h>
+// Defines __GOOGLE_GRTE_VERSION__ (via glibc-specific features.h) when
+// supported.
+#include <unistd.h>
+#endif
+
+#include <atomic>
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/per_thread_tls.h"
+#include "absl/base/optimization.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+struct SynchLocksHeld;
+struct SynchWaitParams;
+
+namespace base_internal {
+
+class SpinLock;
+struct ThreadIdentity;
+
+// Used by the implementation of absl::Mutex and absl::CondVar.
+struct PerThreadSynch {
+  // The internal representation of absl::Mutex and absl::CondVar rely
+  // on the alignment of PerThreadSynch. Both store the address of the
+  // PerThreadSynch in the high-order bits of their internal state,
+  // which means the low kLowZeroBits of the address of PerThreadSynch
+  // must be zero.
+  static constexpr int kLowZeroBits = 8;
+  static constexpr int kAlignment = 1 << kLowZeroBits;
+
+  // Returns the associated ThreadIdentity.
+  // This can be implemented as a cast because we guarantee
+  // PerThreadSynch is the first element of ThreadIdentity.
+  ThreadIdentity* thread_identity() {
+    return reinterpret_cast<ThreadIdentity*>(this);
+  }
+
+  PerThreadSynch *next;  // Circular waiter queue; initialized to 0.
+  PerThreadSynch *skip;  // If non-zero, all entries in Mutex queue
+                         // up to and including "skip" have same
+                         // condition as this, and will be woken later
+  bool may_skip;         // if false while on mutex queue, a mutex unlocker
+                         // is using this PerThreadSynch as a terminator.  Its
+                         // skip field must not be filled in because the loop
+                         // might then skip over the terminator.
+  bool wake;             // This thread is to be woken from a Mutex.
+  // If "x" is on a waiter list for a mutex, "x->cond_waiter" is true iff the
+  // waiter is waiting on the mutex as part of a CV Wait or Mutex Await.
+  //
+  // The value of "x->cond_waiter" is meaningless if "x" is not on a
+  // Mutex waiter list.
+  bool cond_waiter;
+  bool maybe_unlocking;  // Valid at head of Mutex waiter queue;
+                         // true if UnlockSlow could be searching
+                         // for a waiter to wake.  Used for an optimization
+                         // in Enqueue().  true is always a valid value.
+                         // Can be reset to false when the unlocker or any
+                         // writer releases the lock, or a reader fully
+                         // releases the lock.  It may not be set to false
+                         // by a reader that decrements the count to
+                         // non-zero. protected by mutex spinlock
+  bool suppress_fatal_errors;  // If true, try to proceed even in the face
+                               // of broken invariants.  This is used within
+                               // fatal signal handlers to improve the
+                               // chances of debug logging information being
+                               // output successfully.
+  int priority;                // Priority of thread (updated every so often).
+
+  // State values:
+  //   kAvailable: This PerThreadSynch is available.
+  //   kQueued: This PerThreadSynch is unavailable, it's currently queued on a
+  //            Mutex or CondVar waistlist.
+  //
+  // Transitions from kQueued to kAvailable require a release
+  // barrier. This is needed as a waiter may use "state" to
+  // independently observe that it's no longer queued.
+  //
+  // Transitions from kAvailable to kQueued require no barrier, they
+  // are externally ordered by the Mutex.
+  enum State {
+    kAvailable,
+    kQueued
+  };
+  std::atomic<State> state;
+
+  // The wait parameters of the current wait.  waitp is null if the
+  // thread is not waiting. Transitions from null to non-null must
+  // occur before the enqueue commit point (state = kQueued in
+  // Enqueue() and CondVarEnqueue()). Transitions from non-null to
+  // null must occur after the wait is finished (state = kAvailable in
+  // Mutex::Block() and CondVar::WaitCommon()). This field may be
+  // changed only by the thread that describes this PerThreadSynch.  A
+  // special case is Fer(), which calls Enqueue() on another thread,
+  // but with an identical SynchWaitParams pointer, thus leaving the
+  // pointer unchanged.
+  SynchWaitParams* waitp;
+
+  intptr_t readers;     // Number of readers in mutex.
+
+  // When priority will next be read (cycles).
+  int64_t next_priority_read_cycles;
+
+  // Locks held; used during deadlock detection.
+  // Allocated in Synch_GetAllLocks() and freed in ReclaimThreadIdentity().
+  SynchLocksHeld *all_locks;
+};
+
+// The instances of this class are allocated in NewThreadIdentity() with an
+// alignment of PerThreadSynch::kAlignment.
+struct ThreadIdentity {
+  // Must be the first member.  The Mutex implementation requires that
+  // the PerThreadSynch object associated with each thread is
+  // PerThreadSynch::kAlignment aligned.  We provide this alignment on
+  // ThreadIdentity itself.
+  PerThreadSynch per_thread_synch;
+
+  // Private: Reserved for absl::synchronization_internal::Waiter.
+  struct WaiterState {
+    alignas(void*) char data[128];
+  } waiter_state;
+
+  // Used by PerThreadSem::{Get,Set}ThreadBlockedCounter().
+  std::atomic<int>* blocked_count_ptr;
+
+  // The following variables are mostly read/written just by the
+  // thread itself.  The only exception is that these are read by
+  // a ticker thread as a hint.
+  std::atomic<int> ticker;      // Tick counter, incremented once per second.
+  std::atomic<int> wait_start;  // Ticker value when thread started waiting.
+  std::atomic<bool> is_idle;    // Has thread become idle yet?
+
+  ThreadIdentity* next;
+};
+
+// Returns the ThreadIdentity object representing the calling thread; guaranteed
+// to be unique for its lifetime.  The returned object will remain valid for the
+// program's lifetime; although it may be re-assigned to a subsequent thread.
+// If one does not exist, return nullptr instead.
+//
+// Does not malloc(*), and is async-signal safe.
+// [*] Technically pthread_setspecific() does malloc on first use; however this
+// is handled internally within tcmalloc's initialization already.
+//
+// New ThreadIdentity objects can be constructed and associated with a thread
+// by calling GetOrCreateCurrentThreadIdentity() in per-thread-sem.h.
+ThreadIdentity* CurrentThreadIdentityIfPresent();
+
+using ThreadIdentityReclaimerFunction = void (*)(void*);
+
+// Sets the current thread identity to the given value.  'reclaimer' is a
+// pointer to the global function for cleaning up instances on thread
+// destruction.
+void SetCurrentThreadIdentity(ThreadIdentity* identity,
+                              ThreadIdentityReclaimerFunction reclaimer);
+
+// Removes the currently associated ThreadIdentity from the running thread.
+// This must be called from inside the ThreadIdentityReclaimerFunction, and only
+// from that function.
+void ClearCurrentThreadIdentity();
+
+// May be chosen at compile time via: -DABSL_FORCE_THREAD_IDENTITY_MODE=<mode
+// index>
+#ifdef ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#error ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC cannot be directly set
+#else
+#define ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC 0
+#endif
+
+#ifdef ABSL_THREAD_IDENTITY_MODE_USE_TLS
+#error ABSL_THREAD_IDENTITY_MODE_USE_TLS cannot be directly set
+#else
+#define ABSL_THREAD_IDENTITY_MODE_USE_TLS 1
+#endif
+
+#ifdef ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#error ABSL_THREAD_IDENTITY_MODE_USE_CPP11 cannot be directly set
+#else
+#define ABSL_THREAD_IDENTITY_MODE_USE_CPP11 2
+#endif
+
+#ifdef ABSL_THREAD_IDENTITY_MODE
+#error ABSL_THREAD_IDENTITY_MODE cannot be directly set
+#elif defined(ABSL_FORCE_THREAD_IDENTITY_MODE)
+#define ABSL_THREAD_IDENTITY_MODE ABSL_FORCE_THREAD_IDENTITY_MODE
+#elif defined(_WIN32) && !defined(__MINGW32__)
+#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#elif defined(__APPLE__) && defined(ABSL_HAVE_THREAD_LOCAL)
+#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#elif ABSL_PER_THREAD_TLS && defined(__GOOGLE_GRTE_VERSION__) &&        \
+    (__GOOGLE_GRTE_VERSION__ >= 20140228L)
+// Support for async-safe TLS was specifically added in GRTEv4.  It's not
+// present in the upstream eglibc.
+// Note:  Current default for production systems.
+#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_TLS
+#else
+#define ABSL_THREAD_IDENTITY_MODE \
+  ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#endif
+
+#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
+    ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+
+#if ABSL_PER_THREAD_TLS
+ABSL_CONST_INIT extern ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity*
+    thread_identity_ptr;
+#elif defined(ABSL_HAVE_THREAD_LOCAL)
+ABSL_CONST_INIT extern thread_local ThreadIdentity* thread_identity_ptr;
+#else
+#error Thread-local storage not detected on this platform
+#endif
+
+// thread_local variables cannot be in headers exposed by DLLs or in certain
+// build configurations on Apple platforms. However, it is important for
+// performance reasons in general that `CurrentThreadIdentityIfPresent` be
+// inlined. In the other cases we opt to have the function not be inlined. Note
+// that `CurrentThreadIdentityIfPresent` is declared above so we can exclude
+// this entire inline definition.
+#if !defined(__APPLE__) && !defined(ABSL_BUILD_DLL) && \
+    !defined(ABSL_CONSUME_DLL)
+#define ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT 1
+#endif
+
+#ifdef ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT
+inline ThreadIdentity* CurrentThreadIdentityIfPresent() {
+  return thread_identity_ptr;
+}
+#endif
+
+#elif ABSL_THREAD_IDENTITY_MODE != \
+    ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#error Unknown ABSL_THREAD_IDENTITY_MODE
+#endif
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/throw_delegate.h b/CAPI/cpp/grpc/include/absl/base/internal/throw_delegate.h
new file mode 100644
index 0000000..075f527
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/throw_delegate.h
@@ -0,0 +1,75 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+#define ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+
+#include <string>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// Helper functions that allow throwing exceptions consistently from anywhere.
+// The main use case is for header-based libraries (eg templates), as they will
+// be built by many different targets with their own compiler options.
+// In particular, this will allow a safe way to throw exceptions even if the
+// caller is compiled with -fno-exceptions.  This is intended for implementing
+// things like map<>::at(), which the standard documents as throwing an
+// exception on error.
+//
+// Using other techniques like #if tricks could lead to ODR violations.
+//
+// You shouldn't use it unless you're writing code that you know will be built
+// both with and without exceptions and you need to conform to an interface
+// that uses exceptions.
+
+[[noreturn]] void ThrowStdLogicError(const std::string& what_arg);
+[[noreturn]] void ThrowStdLogicError(const char* what_arg);
+[[noreturn]] void ThrowStdInvalidArgument(const std::string& what_arg);
+[[noreturn]] void ThrowStdInvalidArgument(const char* what_arg);
+[[noreturn]] void ThrowStdDomainError(const std::string& what_arg);
+[[noreturn]] void ThrowStdDomainError(const char* what_arg);
+[[noreturn]] void ThrowStdLengthError(const std::string& what_arg);
+[[noreturn]] void ThrowStdLengthError(const char* what_arg);
+[[noreturn]] void ThrowStdOutOfRange(const std::string& what_arg);
+[[noreturn]] void ThrowStdOutOfRange(const char* what_arg);
+[[noreturn]] void ThrowStdRuntimeError(const std::string& what_arg);
+[[noreturn]] void ThrowStdRuntimeError(const char* what_arg);
+[[noreturn]] void ThrowStdRangeError(const std::string& what_arg);
+[[noreturn]] void ThrowStdRangeError(const char* what_arg);
+[[noreturn]] void ThrowStdOverflowError(const std::string& what_arg);
+[[noreturn]] void ThrowStdOverflowError(const char* what_arg);
+[[noreturn]] void ThrowStdUnderflowError(const std::string& what_arg);
+[[noreturn]] void ThrowStdUnderflowError(const char* what_arg);
+
+[[noreturn]] void ThrowStdBadFunctionCall();
+[[noreturn]] void ThrowStdBadAlloc();
+
+// ThrowStdBadArrayNewLength() cannot be consistently supported because
+// std::bad_array_new_length is missing in libstdc++ until 4.9.0.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.3/libstdc++/api/a01379_source.html
+// https://gcc.gnu.org/onlinedocs/gcc-4.9.0/libstdc++/api/a01327_source.html
+// libcxx (as of 3.2) and msvc (as of 2015) both have it.
+// [[noreturn]] void ThrowStdBadArrayNewLength();
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/tsan_mutex_interface.h b/CAPI/cpp/grpc/include/absl/base/internal/tsan_mutex_interface.h
new file mode 100644
index 0000000..39207d8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/tsan_mutex_interface.h
@@ -0,0 +1,68 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This file is intended solely for spinlock.h.
+// It provides ThreadSanitizer annotations for custom mutexes.
+// See <sanitizer/tsan_interface.h> for meaning of these annotations.
+
+#ifndef ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
+#define ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
+
+#include "absl/base/config.h"
+
+// ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+// Macro intended only for internal use.
+//
+// Checks whether LLVM Thread Sanitizer interfaces are available.
+// First made available in LLVM 5.0 (Sep 2017).
+#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#error "ABSL_INTERNAL_HAVE_TSAN_INTERFACE cannot be directly set."
+#endif
+
+#if defined(ABSL_HAVE_THREAD_SANITIZER) && defined(__has_include)
+#if __has_include(<sanitizer/tsan_interface.h>)
+#define ABSL_INTERNAL_HAVE_TSAN_INTERFACE 1
+#endif
+#endif
+
+#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#include <sanitizer/tsan_interface.h>
+
+#define ABSL_TSAN_MUTEX_CREATE __tsan_mutex_create
+#define ABSL_TSAN_MUTEX_DESTROY __tsan_mutex_destroy
+#define ABSL_TSAN_MUTEX_PRE_LOCK __tsan_mutex_pre_lock
+#define ABSL_TSAN_MUTEX_POST_LOCK __tsan_mutex_post_lock
+#define ABSL_TSAN_MUTEX_PRE_UNLOCK __tsan_mutex_pre_unlock
+#define ABSL_TSAN_MUTEX_POST_UNLOCK __tsan_mutex_post_unlock
+#define ABSL_TSAN_MUTEX_PRE_SIGNAL __tsan_mutex_pre_signal
+#define ABSL_TSAN_MUTEX_POST_SIGNAL __tsan_mutex_post_signal
+#define ABSL_TSAN_MUTEX_PRE_DIVERT __tsan_mutex_pre_divert
+#define ABSL_TSAN_MUTEX_POST_DIVERT __tsan_mutex_post_divert
+
+#else
+
+#define ABSL_TSAN_MUTEX_CREATE(...)
+#define ABSL_TSAN_MUTEX_DESTROY(...)
+#define ABSL_TSAN_MUTEX_PRE_LOCK(...)
+#define ABSL_TSAN_MUTEX_POST_LOCK(...)
+#define ABSL_TSAN_MUTEX_PRE_UNLOCK(...)
+#define ABSL_TSAN_MUTEX_POST_UNLOCK(...)
+#define ABSL_TSAN_MUTEX_PRE_SIGNAL(...)
+#define ABSL_TSAN_MUTEX_POST_SIGNAL(...)
+#define ABSL_TSAN_MUTEX_PRE_DIVERT(...)
+#define ABSL_TSAN_MUTEX_POST_DIVERT(...)
+
+#endif
+
+#endif  // ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/unaligned_access.h b/CAPI/cpp/grpc/include/absl/base/internal/unaligned_access.h
new file mode 100644
index 0000000..093dd9b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/unaligned_access.h
@@ -0,0 +1,82 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
+#define ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
+
+#include <string.h>
+
+#include <cstdint>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+
+// unaligned APIs
+
+// Portable handling of unaligned loads, stores, and copies.
+
+// The unaligned API is C++ only.  The declarations use C++ features
+// (namespaces, inline) which are absent or incompatible in C.
+#if defined(__cplusplus)
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+inline uint16_t UnalignedLoad16(const void *p) {
+  uint16_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32_t UnalignedLoad32(const void *p) {
+  uint32_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64_t UnalignedLoad64(const void *p) {
+  uint64_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UnalignedStore16(void *p, uint16_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) \
+  (absl::base_internal::UnalignedLoad16(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) \
+  (absl::base_internal::UnalignedLoad32(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) \
+  (absl::base_internal::UnalignedLoad64(_p))
+
+#define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
+  (absl::base_internal::UnalignedStore16(_p, _val))
+#define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
+  (absl::base_internal::UnalignedStore32(_p, _val))
+#define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
+  (absl::base_internal::UnalignedStore64(_p, _val))
+
+#endif  // defined(__cplusplus), end of unaligned API
+
+#endif  // ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/unscaledcycleclock.h b/CAPI/cpp/grpc/include/absl/base/internal/unscaledcycleclock.h
new file mode 100644
index 0000000..2cbeae3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/internal/unscaledcycleclock.h
@@ -0,0 +1,133 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// UnscaledCycleClock
+//    An UnscaledCycleClock yields the value and frequency of a cycle counter
+//    that increments at a rate that is approximately constant.
+//    This class is for internal use only, you should consider using CycleClock
+//    instead.
+//
+// Notes:
+// The cycle counter frequency is not necessarily the core clock frequency.
+// That is, CycleCounter cycles are not necessarily "CPU cycles".
+//
+// An arbitrary offset may have been added to the counter at power on.
+//
+// On some platforms, the rate and offset of the counter may differ
+// slightly when read from different CPUs of a multiprocessor.  Usually,
+// we try to ensure that the operating system adjusts values periodically
+// so that values agree approximately.   If you need stronger guarantees,
+// consider using alternate interfaces.
+//
+// The CPU is not required to maintain the ordering of a cycle counter read
+// with respect to surrounding instructions.
+
+#ifndef ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
+#define ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
+
+#include <cstdint>
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+#include "absl/base/port.h"
+
+// The following platforms have an implementation of a hardware counter.
+#if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) || \
+    defined(__powerpc__) || defined(__ppc__) || defined(__riscv) ||     \
+    defined(_M_IX86) || (defined(_M_X64) && !defined(_M_ARM64EC))
+#define ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 1
+#else
+#define ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 0
+#endif
+
+// The following platforms often disable access to the hardware
+// counter (through a sandbox) even if the underlying hardware has a
+// usable counter. The CycleTimer interface also requires a *scaled*
+// CycleClock that runs at atleast 1 MHz. We've found some Android
+// ARM64 devices where this is not the case, so we disable it by
+// default on Android ARM64.
+#if defined(__native_client__) || (defined(__APPLE__)) || \
+    (defined(__ANDROID__) && defined(__aarch64__))
+#define ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 0
+#else
+#define ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 1
+#endif
+
+// UnscaledCycleClock is an optional internal feature.
+// Use "#if ABSL_USE_UNSCALED_CYCLECLOCK" to test for its presence.
+// Can be overridden at compile-time via -DABSL_USE_UNSCALED_CYCLECLOCK=0|1
+#if !defined(ABSL_USE_UNSCALED_CYCLECLOCK)
+#define ABSL_USE_UNSCALED_CYCLECLOCK               \
+  (ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION && \
+   ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT)
+#endif
+
+#if ABSL_USE_UNSCALED_CYCLECLOCK
+
+// This macro can be used to test if UnscaledCycleClock::Frequency()
+// is NominalCPUFrequency() on a particular platform.
+#if (defined(__i386__) || defined(__x86_64__) || defined(__riscv) || \
+     defined(_M_IX86) || defined(_M_X64))
+#define ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+class UnscaledCycleClockWrapperForGetCurrentTime;
+}  // namespace time_internal
+
+namespace base_internal {
+class CycleClock;
+class UnscaledCycleClockWrapperForInitializeFrequency;
+
+class UnscaledCycleClock {
+ private:
+  UnscaledCycleClock() = delete;
+
+  // Return the value of a cycle counter that counts at a rate that is
+  // approximately constant.
+  static int64_t Now();
+
+  // Return the how much UnscaledCycleClock::Now() increases per second.
+  // This is not necessarily the core CPU clock frequency.
+  // It may be the nominal value report by the kernel, rather than a measured
+  // value.
+  static double Frequency();
+
+  // Allowed users
+  friend class base_internal::CycleClock;
+  friend class time_internal::UnscaledCycleClockWrapperForGetCurrentTime;
+  friend class base_internal::UnscaledCycleClockWrapperForInitializeFrequency;
+};
+
+#if defined(__x86_64__)
+
+inline int64_t UnscaledCycleClock::Now() {
+  uint64_t low, high;
+  __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
+  return (high << 32) | low;
+}
+
+#endif
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_USE_UNSCALED_CYCLECLOCK
+
+#endif  // ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/log_severity.h b/CAPI/cpp/grpc/include/absl/base/log_severity.h
new file mode 100644
index 0000000..8bdca38
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/log_severity.h
@@ -0,0 +1,172 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_BASE_LOG_SEVERITY_H_
+#define ABSL_BASE_LOG_SEVERITY_H_
+
+#include <array>
+#include <ostream>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::LogSeverity
+//
+// Four severity levels are defined. Logging APIs should terminate the program
+// when a message is logged at severity `kFatal`; the other levels have no
+// special semantics.
+//
+// Values other than the four defined levels (e.g. produced by `static_cast`)
+// are valid, but their semantics when passed to a function, macro, or flag
+// depend on the function, macro, or flag. The usual behavior is to normalize
+// such values to a defined severity level, however in some cases values other
+// than the defined levels are useful for comparison.
+//
+// Example:
+//
+//   // Effectively disables all logging:
+//   SetMinLogLevel(static_cast<absl::LogSeverity>(100));
+//
+// Abseil flags may be defined with type `LogSeverity`. Dependency layering
+// constraints require that the `AbslParseFlag()` overload be declared and
+// defined in the flags library itself rather than here. The `AbslUnparseFlag()`
+// overload is defined there as well for consistency.
+//
+// absl::LogSeverity Flag String Representation
+//
+// An `absl::LogSeverity` has a string representation used for parsing
+// command-line flags based on the enumerator name (e.g. `kFatal`) or
+// its unprefixed name (without the `k`) in any case-insensitive form. (E.g.
+// "FATAL", "fatal" or "Fatal" are all valid.) Unparsing such flags produces an
+// unprefixed string representation in all caps (e.g. "FATAL") or an integer.
+//
+// Additionally, the parser accepts arbitrary integers (as if the type were
+// `int`).
+//
+// Examples:
+//
+//   --my_log_level=kInfo
+//   --my_log_level=INFO
+//   --my_log_level=info
+//   --my_log_level=0
+//
+// Unparsing a flag produces the same result as `absl::LogSeverityName()` for
+// the standard levels and a base-ten integer otherwise.
+enum class LogSeverity : int {
+  kInfo = 0,
+  kWarning = 1,
+  kError = 2,
+  kFatal = 3,
+};
+
+// LogSeverities()
+//
+// Returns an iterable of all standard `absl::LogSeverity` values, ordered from
+// least to most severe.
+constexpr std::array<absl::LogSeverity, 4> LogSeverities() {
+  return {{absl::LogSeverity::kInfo, absl::LogSeverity::kWarning,
+           absl::LogSeverity::kError, absl::LogSeverity::kFatal}};
+}
+
+// LogSeverityName()
+//
+// Returns the all-caps string representation (e.g. "INFO") of the specified
+// severity level if it is one of the standard levels and "UNKNOWN" otherwise.
+constexpr const char* LogSeverityName(absl::LogSeverity s) {
+  return s == absl::LogSeverity::kInfo
+             ? "INFO"
+             : s == absl::LogSeverity::kWarning
+                   ? "WARNING"
+                   : s == absl::LogSeverity::kError
+                         ? "ERROR"
+                         : s == absl::LogSeverity::kFatal ? "FATAL" : "UNKNOWN";
+}
+
+// NormalizeLogSeverity()
+//
+// Values less than `kInfo` normalize to `kInfo`; values greater than `kFatal`
+// normalize to `kError` (**NOT** `kFatal`).
+constexpr absl::LogSeverity NormalizeLogSeverity(absl::LogSeverity s) {
+  return s < absl::LogSeverity::kInfo
+             ? absl::LogSeverity::kInfo
+             : s > absl::LogSeverity::kFatal ? absl::LogSeverity::kError : s;
+}
+constexpr absl::LogSeverity NormalizeLogSeverity(int s) {
+  return absl::NormalizeLogSeverity(static_cast<absl::LogSeverity>(s));
+}
+
+// operator<<
+//
+// The exact representation of a streamed `absl::LogSeverity` is deliberately
+// unspecified; do not rely on it.
+std::ostream& operator<<(std::ostream& os, absl::LogSeverity s);
+
+// Enums representing a lower bound for LogSeverity. APIs that only operate on
+// messages of at least a certain level (for example, `SetMinLogLevel()`) use
+// this type to specify that level. absl::LogSeverityAtLeast::kInfinity is
+// a level above all threshold levels and therefore no log message will
+// ever meet this threshold.
+enum class LogSeverityAtLeast : int {
+  kInfo = static_cast<int>(absl::LogSeverity::kInfo),
+  kWarning = static_cast<int>(absl::LogSeverity::kWarning),
+  kError = static_cast<int>(absl::LogSeverity::kError),
+  kFatal = static_cast<int>(absl::LogSeverity::kFatal),
+  kInfinity = 1000,
+};
+
+std::ostream& operator<<(std::ostream& os, absl::LogSeverityAtLeast s);
+
+// Enums representing an upper bound for LogSeverity. APIs that only operate on
+// messages of at most a certain level (for example, buffer all messages at or
+// below a certain level) use this type to specify that level.
+// absl::LogSeverityAtMost::kNegativeInfinity is a level below all threshold
+// levels and therefore will exclude all log messages.
+enum class LogSeverityAtMost : int {
+  kNegativeInfinity = -1000,
+  kInfo = static_cast<int>(absl::LogSeverity::kInfo),
+  kWarning = static_cast<int>(absl::LogSeverity::kWarning),
+  kError = static_cast<int>(absl::LogSeverity::kError),
+  kFatal = static_cast<int>(absl::LogSeverity::kFatal),
+};
+
+std::ostream& operator<<(std::ostream& os, absl::LogSeverityAtMost s);
+
+#define COMPOP(op1, op2, T)                                         \
+  constexpr bool operator op1(absl::T lhs, absl::LogSeverity rhs) { \
+    return static_cast<absl::LogSeverity>(lhs) op1 rhs;             \
+  }                                                                 \
+  constexpr bool operator op2(absl::LogSeverity lhs, absl::T rhs) { \
+    return lhs op2 static_cast<absl::LogSeverity>(rhs);             \
+  }
+
+// Comparisons between `LogSeverity` and `LogSeverityAtLeast`/
+// `LogSeverityAtMost` are only supported in one direction.
+// Valid checks are:
+//   LogSeverity >= LogSeverityAtLeast
+//   LogSeverity < LogSeverityAtLeast
+//   LogSeverity <= LogSeverityAtMost
+//   LogSeverity > LogSeverityAtMost
+COMPOP(>, <, LogSeverityAtLeast)
+COMPOP(<=, >=, LogSeverityAtLeast)
+COMPOP(<, >, LogSeverityAtMost)
+COMPOP(>=, <=, LogSeverityAtMost)
+#undef COMPOP
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_LOG_SEVERITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/macros.h b/CAPI/cpp/grpc/include/absl/base/macros.h
new file mode 100644
index 0000000..3e085a9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/macros.h
@@ -0,0 +1,158 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: macros.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the set of language macros used within Abseil code.
+// For the set of macros used to determine supported compilers and platforms,
+// see absl/base/config.h instead.
+//
+// This code is compiled directly on many platforms, including client
+// platforms like Windows, Mac, and embedded systems.  Before making
+// any changes here, make sure that you're not breaking any platforms.
+
+#ifndef ABSL_BASE_MACROS_H_
+#define ABSL_BASE_MACROS_H_
+
+#include <cassert>
+#include <cstddef>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+
+// ABSL_ARRAYSIZE()
+//
+// Returns the number of elements in an array as a compile-time constant, which
+// can be used in defining new arrays. If you use this macro on a pointer by
+// mistake, you will get a compile-time error.
+#define ABSL_ARRAYSIZE(array) \
+  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace macros_internal {
+// Note: this internal template function declaration is used by ABSL_ARRAYSIZE.
+// The function doesn't need a definition, as we only use its type.
+template <typename T, size_t N>
+auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
+}  // namespace macros_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// ABSL_BAD_CALL_IF()
+//
+// Used on a function overload to trap bad calls: any call that matches the
+// overload will cause a compile-time error. This macro uses a clang-specific
+// "enable_if" attribute, as described at
+// https://clang.llvm.org/docs/AttributeReference.html#enable-if
+//
+// Overloads which use this macro should be bracketed by
+// `#ifdef ABSL_BAD_CALL_IF`.
+//
+// Example:
+//
+//   int isdigit(int c);
+//   #ifdef ABSL_BAD_CALL_IF
+//   int isdigit(int c)
+//     ABSL_BAD_CALL_IF(c <= -1 || c > 255,
+//                       "'c' must have the value of an unsigned char or EOF");
+//   #endif // ABSL_BAD_CALL_IF
+#if ABSL_HAVE_ATTRIBUTE(enable_if)
+#define ABSL_BAD_CALL_IF(expr, msg) \
+  __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
+#endif
+
+// ABSL_ASSERT()
+//
+// In C++11, `assert` can't be used portably within constexpr functions.
+// ABSL_ASSERT functions as a runtime assert but works in C++11 constexpr
+// functions.  Example:
+//
+// constexpr double Divide(double a, double b) {
+//   return ABSL_ASSERT(b != 0), a / b;
+// }
+//
+// This macro is inspired by
+// https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
+#if defined(NDEBUG)
+#define ABSL_ASSERT(expr) \
+  (false ? static_cast<void>(expr) : static_cast<void>(0))
+#else
+#define ABSL_ASSERT(expr)                           \
+  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
+                             : [] { assert(false && #expr); }())  // NOLINT
+#endif
+
+// `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`
+// aborts the program in release mode (when NDEBUG is defined). The
+// implementation should abort the program as quickly as possible and ideally it
+// should not be possible to ignore the abort request.
+#if (ABSL_HAVE_BUILTIN(__builtin_trap) &&         \
+     ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
+    (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_INTERNAL_HARDENING_ABORT() \
+  do {                                  \
+    __builtin_trap();                   \
+    __builtin_unreachable();            \
+  } while (false)
+#else
+#define ABSL_INTERNAL_HARDENING_ABORT() abort()
+#endif
+
+// ABSL_HARDENING_ASSERT()
+//
+// `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
+// runtime assertions that should be enabled in hardened builds even when
+// `NDEBUG` is defined.
+//
+// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT()` is identical to
+// `ABSL_ASSERT()`.
+//
+// See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
+// hardened mode.
+#if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
+#define ABSL_HARDENING_ASSERT(expr)                 \
+  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
+                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
+#else
+#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
+#endif
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+#define ABSL_INTERNAL_TRY try
+#define ABSL_INTERNAL_CATCH_ANY catch (...)
+#define ABSL_INTERNAL_RETHROW do { throw; } while (false)
+#else  // ABSL_HAVE_EXCEPTIONS
+#define ABSL_INTERNAL_TRY if (true)
+#define ABSL_INTERNAL_CATCH_ANY else if (false)
+#define ABSL_INTERNAL_RETHROW do {} while (false)
+#endif  // ABSL_HAVE_EXCEPTIONS
+
+// `ABSL_INTERNAL_UNREACHABLE` is an unreachable statement.  A program which
+// reaches one has undefined behavior, and the compiler may optimize
+// accordingly.
+#if defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable)
+#define ABSL_INTERNAL_UNREACHABLE __builtin_unreachable()
+#elif defined(_MSC_VER)
+#define ABSL_INTERNAL_UNREACHABLE __assume(0)
+#else
+#define ABSL_INTERNAL_UNREACHABLE
+#endif
+
+#endif  // ABSL_BASE_MACROS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/optimization.h b/CAPI/cpp/grpc/include/absl/base/optimization.h
new file mode 100644
index 0000000..db5cc09
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/optimization.h
@@ -0,0 +1,252 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: optimization.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines portable macros for performance optimization.
+
+#ifndef ABSL_BASE_OPTIMIZATION_H_
+#define ABSL_BASE_OPTIMIZATION_H_
+
+#include <assert.h>
+
+#include "absl/base/config.h"
+
+// ABSL_BLOCK_TAIL_CALL_OPTIMIZATION
+//
+// Instructs the compiler to avoid optimizing tail-call recursion. This macro is
+// useful when you wish to preserve the existing function order within a stack
+// trace for logging, debugging, or profiling purposes.
+//
+// Example:
+//
+//   int f() {
+//     int result = g();
+//     ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+//     return result;
+//   }
+#if defined(__pnacl__)
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#elif defined(__clang__)
+// Clang will not tail call given inline volatile assembly.
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#elif defined(__GNUC__)
+// GCC will not tail call given inline volatile assembly.
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#elif defined(_MSC_VER)
+#include <intrin.h>
+// The __nop() intrinsic blocks the optimisation.
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
+#else
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#endif
+
+// ABSL_CACHELINE_SIZE
+//
+// Explicitly defines the size of the L1 cache for purposes of alignment.
+// Setting the cacheline size allows you to specify that certain objects be
+// aligned on a cacheline boundary with `ABSL_CACHELINE_ALIGNED` declarations.
+// (See below.)
+//
+// NOTE: this macro should be replaced with the following C++17 features, when
+// those are generally available:
+//
+//   * `std::hardware_constructive_interference_size`
+//   * `std::hardware_destructive_interference_size`
+//
+// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html
+// for more information.
+#if defined(__GNUC__)
+// Cache line alignment
+#if defined(__i386__) || defined(__x86_64__)
+#define ABSL_CACHELINE_SIZE 64
+#elif defined(__powerpc64__)
+#define ABSL_CACHELINE_SIZE 128
+#elif defined(__aarch64__)
+// We would need to read special register ctr_el0 to find out L1 dcache size.
+// This value is a good estimate based on a real aarch64 machine.
+#define ABSL_CACHELINE_SIZE 64
+#elif defined(__arm__)
+// Cache line sizes for ARM: These values are not strictly correct since
+// cache line sizes depend on implementations, not architectures.  There
+// are even implementations with cache line sizes configurable at boot
+// time.
+#if defined(__ARM_ARCH_5T__)
+#define ABSL_CACHELINE_SIZE 32
+#elif defined(__ARM_ARCH_7A__)
+#define ABSL_CACHELINE_SIZE 64
+#endif
+#endif
+
+#ifndef ABSL_CACHELINE_SIZE
+// A reasonable default guess.  Note that overestimates tend to waste more
+// space, while underestimates tend to waste more time.
+#define ABSL_CACHELINE_SIZE 64
+#endif
+
+// ABSL_CACHELINE_ALIGNED
+//
+// Indicates that the declared object be cache aligned using
+// `ABSL_CACHELINE_SIZE` (see above). Cacheline aligning objects allows you to
+// load a set of related objects in the L1 cache for performance improvements.
+// Cacheline aligning objects properly allows constructive memory sharing and
+// prevents destructive (or "false") memory sharing.
+//
+// NOTE: callers should replace uses of this macro with `alignas()` using
+// `std::hardware_constructive_interference_size` and/or
+// `std::hardware_destructive_interference_size` when C++17 becomes available to
+// them.
+//
+// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html
+// for more information.
+//
+// On some compilers, `ABSL_CACHELINE_ALIGNED` expands to an `__attribute__`
+// or `__declspec` attribute. For compilers where this is not known to work,
+// the macro expands to nothing.
+//
+// No further guarantees are made here. The result of applying the macro
+// to variables and types is always implementation-defined.
+//
+// WARNING: It is easy to use this attribute incorrectly, even to the point
+// of causing bugs that are difficult to diagnose, crash, etc. It does not
+// of itself guarantee that objects are aligned to a cache line.
+//
+// NOTE: Some compilers are picky about the locations of annotations such as
+// this attribute, so prefer to put it at the beginning of your declaration.
+// For example,
+//
+//   ABSL_CACHELINE_ALIGNED static Foo* foo = ...
+//
+//   class ABSL_CACHELINE_ALIGNED Bar { ...
+//
+// Recommendations:
+//
+// 1) Consult compiler documentation; this comment is not kept in sync as
+//    toolchains evolve.
+// 2) Verify your use has the intended effect. This often requires inspecting
+//    the generated machine code.
+// 3) Prefer applying this attribute to individual variables. Avoid
+//    applying it to types. This tends to localize the effect.
+#define ABSL_CACHELINE_ALIGNED __attribute__((aligned(ABSL_CACHELINE_SIZE)))
+#elif defined(_MSC_VER)
+#define ABSL_CACHELINE_SIZE 64
+#define ABSL_CACHELINE_ALIGNED __declspec(align(ABSL_CACHELINE_SIZE))
+#else
+#define ABSL_CACHELINE_SIZE 64
+#define ABSL_CACHELINE_ALIGNED
+#endif
+
+// ABSL_PREDICT_TRUE, ABSL_PREDICT_FALSE
+//
+// Enables the compiler to prioritize compilation using static analysis for
+// likely paths within a boolean branch.
+//
+// Example:
+//
+//   if (ABSL_PREDICT_TRUE(expression)) {
+//     return result;                        // Faster if more likely
+//   } else {
+//     return 0;
+//   }
+//
+// Compilers can use the information that a certain branch is not likely to be
+// taken (for instance, a CHECK failure) to optimize for the common case in
+// the absence of better information (ie. compiling gcc with `-fprofile-arcs`).
+//
+// Recommendation: Modern CPUs dynamically predict branch execution paths,
+// typically with accuracy greater than 97%. As a result, annotating every
+// branch in a codebase is likely counterproductive; however, annotating
+// specific branches that are both hot and consistently mispredicted is likely
+// to yield performance improvements.
+#if ABSL_HAVE_BUILTIN(__builtin_expect) || \
+    (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
+#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
+#else
+#define ABSL_PREDICT_FALSE(x) (x)
+#define ABSL_PREDICT_TRUE(x) (x)
+#endif
+
+// ABSL_ASSUME(cond)
+//
+// Informs the compiler that a condition is always true and that it can assume
+// it to be true for optimization purposes.
+//
+// WARNING: If the condition is false, the program can produce undefined and
+// potentially dangerous behavior.
+//
+// In !NDEBUG mode, the condition is checked with an assert().
+//
+// NOTE: The expression must not have side effects, as it may only be evaluated
+// in some compilation modes and not others. Some compilers may issue a warning
+// if the compiler cannot prove the expression has no side effects. For example,
+// the expression should not use a function call since the compiler cannot prove
+// that a function call does not have side effects.
+//
+// Example:
+//
+//   int x = ...;
+//   ABSL_ASSUME(x >= 0);
+//   // The compiler can optimize the division to a simple right shift using the
+//   // assumption specified above.
+//   int y = x / 16;
+//
+#if !defined(NDEBUG)
+#define ABSL_ASSUME(cond) assert(cond)
+#elif ABSL_HAVE_BUILTIN(__builtin_assume)
+#define ABSL_ASSUME(cond) __builtin_assume(cond)
+#elif defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable)
+#define ABSL_ASSUME(cond)                 \
+  do {                                    \
+    if (!(cond)) __builtin_unreachable(); \
+  } while (0)
+#elif defined(_MSC_VER)
+#define ABSL_ASSUME(cond) __assume(cond)
+#else
+#define ABSL_ASSUME(cond)               \
+  do {                                  \
+    static_cast<void>(false && (cond)); \
+  } while (0)
+#endif
+
+// ABSL_INTERNAL_UNIQUE_SMALL_NAME(cond)
+// This macro forces small unique name on a static file level symbols like
+// static local variables or static functions. This is intended to be used in
+// macro definitions to optimize the cost of generated code. Do NOT use it on
+// symbols exported from translation unit since it may cause a link time
+// conflict.
+//
+// Example:
+//
+// #define MY_MACRO(txt)
+// namespace {
+//  char VeryVeryLongVarName[] ABSL_INTERNAL_UNIQUE_SMALL_NAME() = txt;
+//  const char* VeryVeryLongFuncName() ABSL_INTERNAL_UNIQUE_SMALL_NAME();
+//  const char* VeryVeryLongFuncName() { return txt; }
+// }
+//
+
+#if defined(__GNUC__)
+#define ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x) #x
+#define ABSL_INTERNAL_UNIQUE_SMALL_NAME1(x) ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x)
+#define ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
+  asm(ABSL_INTERNAL_UNIQUE_SMALL_NAME1(.absl.__COUNTER__))
+#else
+#define ABSL_INTERNAL_UNIQUE_SMALL_NAME()
+#endif
+
+#endif  // ABSL_BASE_OPTIMIZATION_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/options.h b/CAPI/cpp/grpc/include/absl/base/options.h
new file mode 100644
index 0000000..13aeda3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/options.h
@@ -0,0 +1,238 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: options.h
+// -----------------------------------------------------------------------------
+//
+// This file contains Abseil configuration options for setting specific
+// implementations instead of letting Abseil determine which implementation to
+// use at compile-time. Setting these options may be useful for package or build
+// managers who wish to guarantee ABI stability within binary builds (which are
+// otherwise difficult to enforce).
+//
+// *** IMPORTANT NOTICE FOR PACKAGE MANAGERS:  It is important that
+// maintainers of package managers who wish to package Abseil read and
+// understand this file! ***
+//
+// Abseil contains a number of possible configuration endpoints, based on
+// parameters such as the detected platform, language version, or command-line
+// flags used to invoke the underlying binary. As is the case with all
+// libraries, binaries which contain Abseil code must ensure that separate
+// packages use the same compiled copy of Abseil to avoid a diamond dependency
+// problem, which can occur if two packages built with different Abseil
+// configuration settings are linked together. Diamond dependency problems in
+// C++ may manifest as violations to the One Definition Rule (ODR) (resulting in
+// linker errors), or undefined behavior (resulting in crashes).
+//
+// Diamond dependency problems can be avoided if all packages utilize the same
+// exact version of Abseil. Building from source code with the same compilation
+// parameters is the easiest way to avoid such dependency problems. However, for
+// package managers who cannot control such compilation parameters, we are
+// providing the file to allow you to inject ABI (Application Binary Interface)
+// stability across builds. Settings options in this file will neither change
+// API nor ABI, providing a stable copy of Abseil between packages.
+//
+// Care must be taken to keep options within these configurations isolated
+// from any other dynamic settings, such as command-line flags which could alter
+// these options. This file is provided specifically to help build and package
+// managers provide a stable copy of Abseil within their libraries and binaries;
+// other developers should not have need to alter the contents of this file.
+//
+// -----------------------------------------------------------------------------
+// Usage
+// -----------------------------------------------------------------------------
+//
+// For any particular package release, set the appropriate definitions within
+// this file to whatever value makes the most sense for your package(s). Note
+// that, by default, most of these options, at the moment, affect the
+// implementation of types; future options may affect other implementation
+// details.
+//
+// NOTE: the defaults within this file all assume that Abseil can select the
+// proper Abseil implementation at compile-time, which will not be sufficient
+// to guarantee ABI stability to package managers.
+
+#ifndef ABSL_BASE_OPTIONS_H_
+#define ABSL_BASE_OPTIONS_H_
+
+// Include a standard library header to allow configuration based on the
+// standard library in use.
+#ifdef __cplusplus
+#include <ciso646>
+#endif
+
+// -----------------------------------------------------------------------------
+// Type Compatibility Options
+// -----------------------------------------------------------------------------
+//
+// ABSL_OPTION_USE_STD_ANY
+//
+// This option controls whether absl::any is implemented as an alias to
+// std::any, or as an independent implementation.
+//
+// A value of 0 means to use Abseil's implementation.  This requires only C++11
+// support, and is expected to work on every toolchain we support.
+//
+// A value of 1 means to use an alias to std::any.  This requires that all code
+// using Abseil is built in C++17 mode or later.
+//
+// A value of 2 means to detect the C++ version being used to compile Abseil,
+// and use an alias only if a working std::any is available.  This option is
+// useful when you are building your entire program, including all of its
+// dependencies, from source.  It should not be used otherwise -- for example,
+// if you are distributing Abseil in a binary package manager -- since in
+// mode 2, absl::any will name a different type, with a different mangled name
+// and binary layout, depending on the compiler flags passed by the end user.
+// For more info, see https://abseil.io/about/design/dropin-types.
+//
+// User code should not inspect this macro.  To check in the preprocessor if
+// absl::any is a typedef of std::any, use the feature macro ABSL_USES_STD_ANY.
+
+#define ABSL_OPTION_USE_STD_ANY 0
+
+
+// ABSL_OPTION_USE_STD_OPTIONAL
+//
+// This option controls whether absl::optional is implemented as an alias to
+// std::optional, or as an independent implementation.
+//
+// A value of 0 means to use Abseil's implementation.  This requires only C++11
+// support, and is expected to work on every toolchain we support.
+//
+// A value of 1 means to use an alias to std::optional.  This requires that all
+// code using Abseil is built in C++17 mode or later.
+//
+// A value of 2 means to detect the C++ version being used to compile Abseil,
+// and use an alias only if a working std::optional is available.  This option
+// is useful when you are building your program from source.  It should not be
+// used otherwise -- for example, if you are distributing Abseil in a binary
+// package manager -- since in mode 2, absl::optional will name a different
+// type, with a different mangled name and binary layout, depending on the
+// compiler flags passed by the end user.  For more info, see
+// https://abseil.io/about/design/dropin-types.
+
+// User code should not inspect this macro.  To check in the preprocessor if
+// absl::optional is a typedef of std::optional, use the feature macro
+// ABSL_USES_STD_OPTIONAL.
+
+#define ABSL_OPTION_USE_STD_OPTIONAL 0
+
+
+// ABSL_OPTION_USE_STD_STRING_VIEW
+//
+// This option controls whether absl::string_view is implemented as an alias to
+// std::string_view, or as an independent implementation.
+//
+// A value of 0 means to use Abseil's implementation.  This requires only C++11
+// support, and is expected to work on every toolchain we support.
+//
+// A value of 1 means to use an alias to std::string_view.  This requires that
+// all code using Abseil is built in C++17 mode or later.
+//
+// A value of 2 means to detect the C++ version being used to compile Abseil,
+// and use an alias only if a working std::string_view is available.  This
+// option is useful when you are building your program from source.  It should
+// not be used otherwise -- for example, if you are distributing Abseil in a
+// binary package manager -- since in mode 2, absl::string_view will name a
+// different type, with a different mangled name and binary layout, depending on
+// the compiler flags passed by the end user.  For more info, see
+// https://abseil.io/about/design/dropin-types.
+//
+// User code should not inspect this macro.  To check in the preprocessor if
+// absl::string_view is a typedef of std::string_view, use the feature macro
+// ABSL_USES_STD_STRING_VIEW.
+
+#define ABSL_OPTION_USE_STD_STRING_VIEW 0
+
+// ABSL_OPTION_USE_STD_VARIANT
+//
+// This option controls whether absl::variant is implemented as an alias to
+// std::variant, or as an independent implementation.
+//
+// A value of 0 means to use Abseil's implementation.  This requires only C++11
+// support, and is expected to work on every toolchain we support.
+//
+// A value of 1 means to use an alias to std::variant.  This requires that all
+// code using Abseil is built in C++17 mode or later.
+//
+// A value of 2 means to detect the C++ version being used to compile Abseil,
+// and use an alias only if a working std::variant is available.  This option
+// is useful when you are building your program from source.  It should not be
+// used otherwise -- for example, if you are distributing Abseil in a binary
+// package manager -- since in mode 2, absl::variant will name a different
+// type, with a different mangled name and binary layout, depending on the
+// compiler flags passed by the end user.  For more info, see
+// https://abseil.io/about/design/dropin-types.
+//
+// User code should not inspect this macro.  To check in the preprocessor if
+// absl::variant is a typedef of std::variant, use the feature macro
+// ABSL_USES_STD_VARIANT.
+
+#define ABSL_OPTION_USE_STD_VARIANT 0
+
+
+// ABSL_OPTION_USE_INLINE_NAMESPACE
+// ABSL_OPTION_INLINE_NAMESPACE_NAME
+//
+// These options controls whether all entities in the absl namespace are
+// contained within an inner inline namespace.  This does not affect the
+// user-visible API of Abseil, but it changes the mangled names of all symbols.
+//
+// This can be useful as a version tag if you are distributing Abseil in
+// precompiled form.  This will prevent a binary library build of Abseil with
+// one inline namespace being used with headers configured with a different
+// inline namespace name.  Binary packagers are reminded that Abseil does not
+// guarantee any ABI stability in Abseil, so any update of Abseil or
+// configuration change in such a binary package should be combined with a
+// new, unique value for the inline namespace name.
+//
+// A value of 0 means not to use inline namespaces.
+//
+// A value of 1 means to use an inline namespace with the given name inside
+// namespace absl.  If this is set, ABSL_OPTION_INLINE_NAMESPACE_NAME must also
+// be changed to a new, unique identifier name.  In particular "head" is not
+// allowed.
+
+#define ABSL_OPTION_USE_INLINE_NAMESPACE 1
+#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20220623
+
+// ABSL_OPTION_HARDENED
+//
+// This option enables a "hardened" build in release mode (in this context,
+// release mode is defined as a build where the `NDEBUG` macro is defined).
+//
+// A value of 0 means that "hardened" mode is not enabled.
+//
+// A value of 1 means that "hardened" mode is enabled.
+//
+// Hardened builds have additional security checks enabled when `NDEBUG` is
+// defined. Defining `NDEBUG` is normally used to turn `assert()` macro into a
+// no-op, as well as disabling other bespoke program consistency checks. By
+// defining ABSL_OPTION_HARDENED to 1, a select set of checks remain enabled in
+// release mode. These checks guard against programming errors that may lead to
+// security vulnerabilities. In release mode, when one of these programming
+// errors is encountered, the program will immediately abort, possibly without
+// any attempt at logging.
+//
+// The checks enabled by this option are not free; they do incur runtime cost.
+//
+// The checks enabled by this option are always active when `NDEBUG` is not
+// defined, even in the case when ABSL_OPTION_HARDENED is defined to 0. The
+// checks enabled by this option may abort the program in a different way and
+// log additional information when `NDEBUG` is not defined.
+
+#define ABSL_OPTION_HARDENED 0
+
+#endif  // ABSL_BASE_OPTIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/policy_checks.h b/CAPI/cpp/grpc/include/absl/base/policy_checks.h
new file mode 100644
index 0000000..06b3243
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/policy_checks.h
@@ -0,0 +1,111 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: policy_checks.h
+// -----------------------------------------------------------------------------
+//
+// This header enforces a minimum set of policies at build time, such as the
+// supported compiler and library versions. Unsupported configurations are
+// reported with `#error`. This enforcement is best effort, so successfully
+// compiling this header does not guarantee a supported configuration.
+
+#ifndef ABSL_BASE_POLICY_CHECKS_H_
+#define ABSL_BASE_POLICY_CHECKS_H_
+
+// Included for the __GLIBC_PREREQ macro used below.
+#include <limits.h>
+
+// Included for the _STLPORT_VERSION macro used below.
+#if defined(__cplusplus)
+#include <cstddef>
+#endif
+
+// -----------------------------------------------------------------------------
+// Operating System Check
+// -----------------------------------------------------------------------------
+
+#if defined(__CYGWIN__)
+#error "Cygwin is not supported."
+#endif
+
+// -----------------------------------------------------------------------------
+// Toolchain Check
+// -----------------------------------------------------------------------------
+
+// We support MSVC++ 14.0 update 2 and later.
+// This minimum will go up.
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023918 && !defined(__clang__)
+#error "This package requires Visual Studio 2015 Update 2 or higher."
+#endif
+
+// We support gcc 4.7 and later.
+// This minimum will go up.
+#if defined(__GNUC__) && !defined(__clang__)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7)
+#error "This package requires gcc 4.7 or higher."
+#endif
+#endif
+
+// We support Apple Xcode clang 4.2.1 (version 421.11.65) and later.
+// This corresponds to Apple Xcode version 4.5.
+// This minimum will go up.
+#if defined(__apple_build_version__) && __apple_build_version__ < 4211165
+#error "This package requires __apple_build_version__ of 4211165 or higher."
+#endif
+
+// -----------------------------------------------------------------------------
+// C++ Version Check
+// -----------------------------------------------------------------------------
+
+// Enforce C++11 as the minimum.  Note that Visual Studio has not
+// advanced __cplusplus despite being good enough for our purposes, so
+// so we exempt it from the check.
+#if defined(__cplusplus) && !defined(_MSC_VER)
+#if __cplusplus < 201103L
+#error "C++ versions less than C++11 are not supported."
+#endif
+#endif
+
+// -----------------------------------------------------------------------------
+// Standard Library Check
+// -----------------------------------------------------------------------------
+
+#if defined(_STLPORT_VERSION)
+#error "STLPort is not supported."
+#endif
+
+// -----------------------------------------------------------------------------
+// `char` Size Check
+// -----------------------------------------------------------------------------
+
+// Abseil currently assumes CHAR_BIT == 8. If you would like to use Abseil on a
+// platform where this is not the case, please provide us with the details about
+// your platform so we can consider relaxing this requirement.
+#if CHAR_BIT != 8
+#error "Abseil assumes CHAR_BIT == 8."
+#endif
+
+// -----------------------------------------------------------------------------
+// `int` Size Check
+// -----------------------------------------------------------------------------
+
+// Abseil currently assumes that an int is 4 bytes. If you would like to use
+// Abseil on a platform where this is not the case, please provide us with the
+// details about your platform so we can consider relaxing this requirement.
+#if INT_MAX < 2147483647
+#error "Abseil assumes that int is at least 4 bytes. "
+#endif
+
+#endif  // ABSL_BASE_POLICY_CHECKS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/port.h b/CAPI/cpp/grpc/include/absl/base/port.h
new file mode 100644
index 0000000..5bc4d6c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/port.h
@@ -0,0 +1,25 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This files is a forwarding header for other headers containing various
+// portability macros and functions.
+
+#ifndef ABSL_BASE_PORT_H_
+#define ABSL_BASE_PORT_H_
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+
+#endif  // ABSL_BASE_PORT_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/thread_annotations.h b/CAPI/cpp/grpc/include/absl/base/thread_annotations.h
new file mode 100644
index 0000000..bc8a620
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/base/thread_annotations.h
@@ -0,0 +1,335 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: thread_annotations.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains macro definitions for thread safety annotations
+// that allow developers to document the locking policies of multi-threaded
+// code. The annotations can also help program analysis tools to identify
+// potential thread safety issues.
+//
+// These annotations are implemented using compiler attributes. Using the macros
+// defined here instead of raw attributes allow for portability and future
+// compatibility.
+//
+// When referring to mutexes in the arguments of the attributes, you should
+// use variable names or more complex expressions (e.g. my_object->mutex_)
+// that evaluate to a concrete mutex object whenever possible. If the mutex
+// you want to refer to is not in scope, you may use a member pointer
+// (e.g. &MyClass::mutex_) to refer to a mutex in some (unknown) object.
+
+#ifndef ABSL_BASE_THREAD_ANNOTATIONS_H_
+#define ABSL_BASE_THREAD_ANNOTATIONS_H_
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+// TODO(mbonadei): Remove after the backward compatibility period.
+#include "absl/base/internal/thread_annotations.h"  // IWYU pragma: export
+
+// ABSL_GUARDED_BY()
+//
+// Documents if a shared field or global variable needs to be protected by a
+// mutex. ABSL_GUARDED_BY() allows the user to specify a particular mutex that
+// should be held when accessing the annotated variable.
+//
+// Although this annotation (and ABSL_PT_GUARDED_BY, below) cannot be applied to
+// local variables, a local variable and its associated mutex can often be
+// combined into a small class or struct, thereby allowing the annotation.
+//
+// Example:
+//
+//   class Foo {
+//     Mutex mu_;
+//     int p1_ ABSL_GUARDED_BY(mu_);
+//     ...
+//   };
+#if ABSL_HAVE_ATTRIBUTE(guarded_by)
+#define ABSL_GUARDED_BY(x) __attribute__((guarded_by(x)))
+#else
+#define ABSL_GUARDED_BY(x)
+#endif
+
+// ABSL_PT_GUARDED_BY()
+//
+// Documents if the memory location pointed to by a pointer should be guarded
+// by a mutex when dereferencing the pointer.
+//
+// Example:
+//   class Foo {
+//     Mutex mu_;
+//     int *p1_ ABSL_PT_GUARDED_BY(mu_);
+//     ...
+//   };
+//
+// Note that a pointer variable to a shared memory location could itself be a
+// shared variable.
+//
+// Example:
+//
+//   // `q_`, guarded by `mu1_`, points to a shared memory location that is
+//   // guarded by `mu2_`:
+//   int *q_ ABSL_GUARDED_BY(mu1_) ABSL_PT_GUARDED_BY(mu2_);
+#if ABSL_HAVE_ATTRIBUTE(pt_guarded_by)
+#define ABSL_PT_GUARDED_BY(x) __attribute__((pt_guarded_by(x)))
+#else
+#define ABSL_PT_GUARDED_BY(x)
+#endif
+
+// ABSL_ACQUIRED_AFTER() / ABSL_ACQUIRED_BEFORE()
+//
+// Documents the acquisition order between locks that can be held
+// simultaneously by a thread. For any two locks that need to be annotated
+// to establish an acquisition order, only one of them needs the annotation.
+// (i.e. You don't have to annotate both locks with both ABSL_ACQUIRED_AFTER
+// and ABSL_ACQUIRED_BEFORE.)
+//
+// As with ABSL_GUARDED_BY, this is only applicable to mutexes that are shared
+// fields or global variables.
+//
+// Example:
+//
+//   Mutex m1_;
+//   Mutex m2_ ABSL_ACQUIRED_AFTER(m1_);
+#if ABSL_HAVE_ATTRIBUTE(acquired_after)
+#define ABSL_ACQUIRED_AFTER(...) __attribute__((acquired_after(__VA_ARGS__)))
+#else
+#define ABSL_ACQUIRED_AFTER(...)
+#endif
+
+#if ABSL_HAVE_ATTRIBUTE(acquired_before)
+#define ABSL_ACQUIRED_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__)))
+#else
+#define ABSL_ACQUIRED_BEFORE(...)
+#endif
+
+// ABSL_EXCLUSIVE_LOCKS_REQUIRED() / ABSL_SHARED_LOCKS_REQUIRED()
+//
+// Documents a function that expects a mutex to be held prior to entry.
+// The mutex is expected to be held both on entry to, and exit from, the
+// function.
+//
+// An exclusive lock allows read-write access to the guarded data member(s), and
+// only one thread can acquire a lock exclusively at any one time. A shared lock
+// allows read-only access, and any number of threads can acquire a shared lock
+// concurrently.
+//
+// Generally, non-const methods should be annotated with
+// ABSL_EXCLUSIVE_LOCKS_REQUIRED, while const methods should be annotated with
+// ABSL_SHARED_LOCKS_REQUIRED.
+//
+// Example:
+//
+//   Mutex mu1, mu2;
+//   int a ABSL_GUARDED_BY(mu1);
+//   int b ABSL_GUARDED_BY(mu2);
+//
+//   void foo() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... }
+//   void bar() const ABSL_SHARED_LOCKS_REQUIRED(mu1, mu2) { ... }
+#if ABSL_HAVE_ATTRIBUTE(exclusive_locks_required)
+#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) \
+  __attribute__((exclusive_locks_required(__VA_ARGS__)))
+#else
+#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...)
+#endif
+
+#if ABSL_HAVE_ATTRIBUTE(shared_locks_required)
+#define ABSL_SHARED_LOCKS_REQUIRED(...) \
+  __attribute__((shared_locks_required(__VA_ARGS__)))
+#else
+#define ABSL_SHARED_LOCKS_REQUIRED(...)
+#endif
+
+// ABSL_LOCKS_EXCLUDED()
+//
+// Documents the locks that cannot be held by callers of this function, as they
+// might be acquired by this function (Abseil's `Mutex` locks are
+// non-reentrant).
+#if ABSL_HAVE_ATTRIBUTE(locks_excluded)
+#define ABSL_LOCKS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__)))
+#else
+#define ABSL_LOCKS_EXCLUDED(...)
+#endif
+
+// ABSL_LOCK_RETURNED()
+//
+// Documents a function that returns a mutex without acquiring it.  For example,
+// a public getter method that returns a pointer to a private mutex should
+// be annotated with ABSL_LOCK_RETURNED.
+#if ABSL_HAVE_ATTRIBUTE(lock_returned)
+#define ABSL_LOCK_RETURNED(x) __attribute__((lock_returned(x)))
+#else
+#define ABSL_LOCK_RETURNED(x)
+#endif
+
+// ABSL_LOCKABLE
+//
+// Documents if a class/type is a lockable type (such as the `Mutex` class).
+#if ABSL_HAVE_ATTRIBUTE(lockable)
+#define ABSL_LOCKABLE __attribute__((lockable))
+#else
+#define ABSL_LOCKABLE
+#endif
+
+// ABSL_SCOPED_LOCKABLE
+//
+// Documents if a class does RAII locking (such as the `MutexLock` class).
+// The constructor should use `LOCK_FUNCTION()` to specify the mutex that is
+// acquired, and the destructor should use `UNLOCK_FUNCTION()` with no
+// arguments; the analysis will assume that the destructor unlocks whatever the
+// constructor locked.
+#if ABSL_HAVE_ATTRIBUTE(scoped_lockable)
+#define ABSL_SCOPED_LOCKABLE __attribute__((scoped_lockable))
+#else
+#define ABSL_SCOPED_LOCKABLE
+#endif
+
+// ABSL_EXCLUSIVE_LOCK_FUNCTION()
+//
+// Documents functions that acquire a lock in the body of a function, and do
+// not release it.
+#if ABSL_HAVE_ATTRIBUTE(exclusive_lock_function)
+#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...) \
+  __attribute__((exclusive_lock_function(__VA_ARGS__)))
+#else
+#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...)
+#endif
+
+// ABSL_SHARED_LOCK_FUNCTION()
+//
+// Documents functions that acquire a shared (reader) lock in the body of a
+// function, and do not release it.
+#if ABSL_HAVE_ATTRIBUTE(shared_lock_function)
+#define ABSL_SHARED_LOCK_FUNCTION(...) \
+  __attribute__((shared_lock_function(__VA_ARGS__)))
+#else
+#define ABSL_SHARED_LOCK_FUNCTION(...)
+#endif
+
+// ABSL_UNLOCK_FUNCTION()
+//
+// Documents functions that expect a lock to be held on entry to the function,
+// and release it in the body of the function.
+#if ABSL_HAVE_ATTRIBUTE(unlock_function)
+#define ABSL_UNLOCK_FUNCTION(...) __attribute__((unlock_function(__VA_ARGS__)))
+#else
+#define ABSL_UNLOCK_FUNCTION(...)
+#endif
+
+// ABSL_EXCLUSIVE_TRYLOCK_FUNCTION() / ABSL_SHARED_TRYLOCK_FUNCTION()
+//
+// Documents functions that try to acquire a lock, and return success or failure
+// (or a non-boolean value that can be interpreted as a boolean).
+// The first argument should be `true` for functions that return `true` on
+// success, or `false` for functions that return `false` on success. The second
+// argument specifies the mutex that is locked on success. If unspecified, this
+// mutex is assumed to be `this`.
+#if ABSL_HAVE_ATTRIBUTE(exclusive_trylock_function)
+#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+  __attribute__((exclusive_trylock_function(__VA_ARGS__)))
+#else
+#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...)
+#endif
+
+#if ABSL_HAVE_ATTRIBUTE(shared_trylock_function)
+#define ABSL_SHARED_TRYLOCK_FUNCTION(...) \
+  __attribute__((shared_trylock_function(__VA_ARGS__)))
+#else
+#define ABSL_SHARED_TRYLOCK_FUNCTION(...)
+#endif
+
+// ABSL_ASSERT_EXCLUSIVE_LOCK() / ABSL_ASSERT_SHARED_LOCK()
+//
+// Documents functions that dynamically check to see if a lock is held, and fail
+// if it is not held.
+#if ABSL_HAVE_ATTRIBUTE(assert_exclusive_lock)
+#define ABSL_ASSERT_EXCLUSIVE_LOCK(...) \
+  __attribute__((assert_exclusive_lock(__VA_ARGS__)))
+#else
+#define ABSL_ASSERT_EXCLUSIVE_LOCK(...)
+#endif
+
+#if ABSL_HAVE_ATTRIBUTE(assert_shared_lock)
+#define ABSL_ASSERT_SHARED_LOCK(...) \
+  __attribute__((assert_shared_lock(__VA_ARGS__)))
+#else
+#define ABSL_ASSERT_SHARED_LOCK(...)
+#endif
+
+// ABSL_NO_THREAD_SAFETY_ANALYSIS
+//
+// Turns off thread safety checking within the body of a particular function.
+// This annotation is used to mark functions that are known to be correct, but
+// the locking behavior is more complicated than the analyzer can handle.
+#if ABSL_HAVE_ATTRIBUTE(no_thread_safety_analysis)
+#define ABSL_NO_THREAD_SAFETY_ANALYSIS \
+  __attribute__((no_thread_safety_analysis))
+#else
+#define ABSL_NO_THREAD_SAFETY_ANALYSIS
+#endif
+
+//------------------------------------------------------------------------------
+// Tool-Supplied Annotations
+//------------------------------------------------------------------------------
+
+// ABSL_TS_UNCHECKED should be placed around lock expressions that are not valid
+// C++ syntax, but which are present for documentation purposes.  These
+// annotations will be ignored by the analysis.
+#define ABSL_TS_UNCHECKED(x) ""
+
+// ABSL_TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
+// It is used by automated tools to mark and disable invalid expressions.
+// The annotation should either be fixed, or changed to ABSL_TS_UNCHECKED.
+#define ABSL_TS_FIXME(x) ""
+
+// Like ABSL_NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body
+// of a particular function.  However, this attribute is used to mark functions
+// that are incorrect and need to be fixed.  It is used by automated tools to
+// avoid breaking the build when the analysis is updated.
+// Code owners are expected to eventually fix the routine.
+#define ABSL_NO_THREAD_SAFETY_ANALYSIS_FIXME ABSL_NO_THREAD_SAFETY_ANALYSIS
+
+// Similar to ABSL_NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a
+// ABSL_GUARDED_BY annotation that needs to be fixed, because it is producing
+// thread safety warning. It disables the ABSL_GUARDED_BY.
+#define ABSL_GUARDED_BY_FIXME(x)
+
+// Disables warnings for a single read operation.  This can be used to avoid
+// warnings when it is known that the read is not actually involved in a race,
+// but the compiler cannot confirm that.
+#define ABSL_TS_UNCHECKED_READ(x) absl::base_internal::ts_unchecked_read(x)
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+// Takes a reference to a guarded data member, and returns an unguarded
+// reference.
+// Do not use this function directly, use ABSL_TS_UNCHECKED_READ instead.
+template <typename T>
+inline const T& ts_unchecked_read(const T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  return v;
+}
+
+template <typename T>
+inline T& ts_unchecked_read(T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  return v;
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_THREAD_ANNOTATIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/cleanup/cleanup.h b/CAPI/cpp/grpc/include/absl/cleanup/cleanup.h
new file mode 100644
index 0000000..960ccd0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/cleanup/cleanup.h
@@ -0,0 +1,140 @@
+// Copyright 2021 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: cleanup.h
+// -----------------------------------------------------------------------------
+//
+// `absl::Cleanup` implements the scope guard idiom, invoking the contained
+// callback's `operator()() &&` on scope exit.
+//
+// Example:
+//
+// ```
+//   absl::Status CopyGoodData(const char* source_path, const char* sink_path) {
+//     FILE* source_file = fopen(source_path, "r");
+//     if (source_file == nullptr) {
+//       return absl::NotFoundError("No source file");  // No cleanups execute
+//     }
+//
+//     // C++17 style cleanup using class template argument deduction
+//     absl::Cleanup source_closer = [source_file] { fclose(source_file); };
+//
+//     FILE* sink_file = fopen(sink_path, "w");
+//     if (sink_file == nullptr) {
+//       return absl::NotFoundError("No sink file");  // First cleanup executes
+//     }
+//
+//     // C++11 style cleanup using the factory function
+//     auto sink_closer = absl::MakeCleanup([sink_file] { fclose(sink_file); });
+//
+//     Data data;
+//     while (ReadData(source_file, &data)) {
+//       if (!data.IsGood()) {
+//         absl::Status result = absl::FailedPreconditionError("Read bad data");
+//         return result;  // Both cleanups execute
+//       }
+//       SaveData(sink_file, &data);
+//     }
+//
+//     return absl::OkStatus();  // Both cleanups execute
+//   }
+// ```
+//
+// Methods:
+//
+// `std::move(cleanup).Cancel()` will prevent the callback from executing.
+//
+// `std::move(cleanup).Invoke()` will execute the callback early, before
+// destruction, and prevent the callback from executing in the destructor.
+//
+// Usage:
+//
+// `absl::Cleanup` is not an interface type. It is only intended to be used
+// within the body of a function. It is not a value type and instead models a
+// control flow construct. Check out `defer` in Golang for something similar.
+
+#ifndef ABSL_CLEANUP_CLEANUP_H_
+#define ABSL_CLEANUP_CLEANUP_H_
+
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/cleanup/internal/cleanup.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+template <typename Arg, typename Callback = void()>
+class ABSL_MUST_USE_RESULT Cleanup final {
+  static_assert(cleanup_internal::WasDeduced<Arg>(),
+                "Explicit template parameters are not supported.");
+
+  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
+                "Callbacks that return values are not supported.");
+
+ public:
+  Cleanup(Callback callback) : storage_(std::move(callback)) {}  // NOLINT
+
+  Cleanup(Cleanup&& other) = default;
+
+  void Cancel() && {
+    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+    storage_.DestroyCallback();
+  }
+
+  void Invoke() && {
+    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+    storage_.InvokeCallback();
+    storage_.DestroyCallback();
+  }
+
+  ~Cleanup() {
+    if (storage_.IsCallbackEngaged()) {
+      storage_.InvokeCallback();
+      storage_.DestroyCallback();
+    }
+  }
+
+ private:
+  cleanup_internal::Storage<Callback> storage_;
+};
+
+// `absl::Cleanup c = /* callback */;`
+//
+// C++17 type deduction API for creating an instance of `absl::Cleanup`
+#if defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
+template <typename Callback>
+Cleanup(Callback callback) -> Cleanup<cleanup_internal::Tag, Callback>;
+#endif  // defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
+
+// `auto c = absl::MakeCleanup(/* callback */);`
+//
+// C++11 type deduction API for creating an instance of `absl::Cleanup`
+template <typename... Args, typename Callback>
+absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
+  static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(),
+                "Explicit template parameters are not supported.");
+
+  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
+                "Callbacks that return values are not supported.");
+
+  return {std::move(callback)};
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CLEANUP_CLEANUP_H_
diff --git a/CAPI/cpp/grpc/include/absl/cleanup/internal/cleanup.h b/CAPI/cpp/grpc/include/absl/cleanup/internal/cleanup.h
new file mode 100644
index 0000000..2783fcb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/cleanup/internal/cleanup.h
@@ -0,0 +1,100 @@
+// Copyright 2021 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CLEANUP_INTERNAL_CLEANUP_H_
+#define ABSL_CLEANUP_INTERNAL_CLEANUP_H_
+
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/invoke.h"
+#include "absl/base/macros.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace cleanup_internal {
+
+struct Tag {};
+
+template <typename Arg, typename... Args>
+constexpr bool WasDeduced() {
+  return (std::is_same<cleanup_internal::Tag, Arg>::value) &&
+         (sizeof...(Args) == 0);
+}
+
+template <typename Callback>
+constexpr bool ReturnsVoid() {
+  return (std::is_same<base_internal::invoke_result_t<Callback>, void>::value);
+}
+
+template <typename Callback>
+class Storage {
+ public:
+  Storage() = delete;
+
+  explicit Storage(Callback callback) {
+    // Placement-new into a character buffer is used for eager destruction when
+    // the cleanup is invoked or cancelled. To ensure this optimizes well, the
+    // behavior is implemented locally instead of using an absl::optional.
+    ::new (GetCallbackBuffer()) Callback(std::move(callback));
+    is_callback_engaged_ = true;
+  }
+
+  Storage(Storage&& other) {
+    ABSL_HARDENING_ASSERT(other.IsCallbackEngaged());
+
+    ::new (GetCallbackBuffer()) Callback(std::move(other.GetCallback()));
+    is_callback_engaged_ = true;
+
+    other.DestroyCallback();
+  }
+
+  Storage(const Storage& other) = delete;
+
+  Storage& operator=(Storage&& other) = delete;
+
+  Storage& operator=(const Storage& other) = delete;
+
+  void* GetCallbackBuffer() { return static_cast<void*>(+callback_buffer_); }
+
+  Callback& GetCallback() {
+    return *reinterpret_cast<Callback*>(GetCallbackBuffer());
+  }
+
+  bool IsCallbackEngaged() const { return is_callback_engaged_; }
+
+  void DestroyCallback() {
+    is_callback_engaged_ = false;
+    GetCallback().~Callback();
+  }
+
+  void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS {
+    std::move(GetCallback())();
+  }
+
+ private:
+  bool is_callback_engaged_;
+  alignas(Callback) char callback_buffer_[sizeof(Callback)];
+};
+
+}  // namespace cleanup_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CLEANUP_INTERNAL_CLEANUP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/btree_map.h b/CAPI/cpp/grpc/include/absl/container/btree_map.h
new file mode 100644
index 0000000..286817f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/btree_map.h
@@ -0,0 +1,851 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: btree_map.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines B-tree maps: sorted associative containers mapping
+// keys to values.
+//
+//     * `absl::btree_map<>`
+//     * `absl::btree_multimap<>`
+//
+// These B-tree types are similar to the corresponding types in the STL
+// (`std::map` and `std::multimap`) and generally conform to the STL interfaces
+// of those types. However, because they are implemented using B-trees, they
+// are more efficient in most situations.
+//
+// Unlike `std::map` and `std::multimap`, which are commonly implemented using
+// red-black tree nodes, B-tree maps use more generic B-tree nodes able to hold
+// multiple values per node. Holding multiple values per node often makes
+// B-tree maps perform better than their `std::map` counterparts, because
+// multiple entries can be checked within the same cache hit.
+//
+// However, these types should not be considered drop-in replacements for
+// `std::map` and `std::multimap` as there are some API differences, which are
+// noted in this header file. The most consequential differences with respect to
+// migrating to b-tree from the STL types are listed in the next paragraph.
+// Other API differences are minor.
+//
+// Importantly, insertions and deletions may invalidate outstanding iterators,
+// pointers, and references to elements. Such invalidations are typically only
+// an issue if insertion and deletion operations are interleaved with the use of
+// more than one iterator, pointer, or reference simultaneously. For this
+// reason, `insert()` and `erase()` return a valid iterator at the current
+// position. Another important difference is that key-types must be
+// copy-constructible.
+
+#ifndef ABSL_CONTAINER_BTREE_MAP_H_
+#define ABSL_CONTAINER_BTREE_MAP_H_
+
+#include "absl/container/internal/btree.h"  // IWYU pragma: export
+#include "absl/container/internal/btree_container.h"  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace container_internal {
+
+template <typename Key, typename Data, typename Compare, typename Alloc,
+          int TargetNodeSize, bool IsMulti>
+struct map_params;
+
+}  // namespace container_internal
+
+// absl::btree_map<>
+//
+// An `absl::btree_map<K, V>` is an ordered associative container of
+// unique keys and associated values designed to be a more efficient replacement
+// for `std::map` (in most cases).
+//
+// Keys are sorted using an (optional) comparison function, which defaults to
+// `std::less<K>`.
+//
+// An `absl::btree_map<K, V>` uses a default allocator of
+// `std::allocator<std::pair<const K, V>>` to allocate (and deallocate)
+// nodes, and construct and destruct values within those nodes. You may
+// instead specify a custom allocator `A` (which in turn requires specifying a
+// custom comparator `C`) as in `absl::btree_map<K, V, C, A>`.
+//
+template <typename Key, typename Value, typename Compare = std::less<Key>,
+          typename Alloc = std::allocator<std::pair<const Key, Value>>>
+class btree_map
+    : public container_internal::btree_map_container<
+          container_internal::btree<container_internal::map_params<
+              Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
+              /*IsMulti=*/false>>> {
+  using Base = typename btree_map::btree_map_container;
+
+ public:
+  // Constructors and Assignment Operators
+  //
+  // A `btree_map` supports the same overload set as `std::map`
+  // for construction and assignment:
+  //
+  // * Default constructor
+  //
+  //   absl::btree_map<int, std::string> map1;
+  //
+  // * Initializer List constructor
+  //
+  //   absl::btree_map<int, std::string> map2 =
+  //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
+  //
+  // * Copy constructor
+  //
+  //   absl::btree_map<int, std::string> map3(map2);
+  //
+  // * Copy assignment operator
+  //
+  //  absl::btree_map<int, std::string> map4;
+  //  map4 = map3;
+  //
+  // * Move constructor
+  //
+  //   // Move is guaranteed efficient
+  //   absl::btree_map<int, std::string> map5(std::move(map4));
+  //
+  // * Move assignment operator
+  //
+  //   // May be efficient if allocators are compatible
+  //   absl::btree_map<int, std::string> map6;
+  //   map6 = std::move(map5);
+  //
+  // * Range constructor
+  //
+  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+  //   absl::btree_map<int, std::string> map7(v.begin(), v.end());
+  btree_map() {}
+  using Base::Base;
+
+  // btree_map::begin()
+  //
+  // Returns an iterator to the beginning of the `btree_map`.
+  using Base::begin;
+
+  // btree_map::cbegin()
+  //
+  // Returns a const iterator to the beginning of the `btree_map`.
+  using Base::cbegin;
+
+  // btree_map::end()
+  //
+  // Returns an iterator to the end of the `btree_map`.
+  using Base::end;
+
+  // btree_map::cend()
+  //
+  // Returns a const iterator to the end of the `btree_map`.
+  using Base::cend;
+
+  // btree_map::empty()
+  //
+  // Returns whether or not the `btree_map` is empty.
+  using Base::empty;
+
+  // btree_map::max_size()
+  //
+  // Returns the largest theoretical possible number of elements within a
+  // `btree_map` under current memory constraints. This value can be thought
+  // of as the largest value of `std::distance(begin(), end())` for a
+  // `btree_map<Key, T>`.
+  using Base::max_size;
+
+  // btree_map::size()
+  //
+  // Returns the number of elements currently within the `btree_map`.
+  using Base::size;
+
+  // btree_map::clear()
+  //
+  // Removes all elements from the `btree_map`. Invalidates any references,
+  // pointers, or iterators referring to contained elements.
+  using Base::clear;
+
+  // btree_map::erase()
+  //
+  // Erases elements within the `btree_map`. If an erase occurs, any references,
+  // pointers, or iterators are invalidated.
+  // Overloads are listed below.
+  //
+  // iterator erase(iterator position):
+  // iterator erase(const_iterator position):
+  //
+  //   Erases the element at `position` of the `btree_map`, returning
+  //   the iterator pointing to the element after the one that was erased
+  //   (or end() if none exists).
+  //
+  // iterator erase(const_iterator first, const_iterator last):
+  //
+  //   Erases the elements in the open interval [`first`, `last`), returning
+  //   the iterator pointing to the element after the interval that was erased
+  //   (or end() if none exists).
+  //
+  // template <typename K> size_type erase(const K& key):
+  //
+  //   Erases the element with the matching key, if it exists, returning the
+  //   number of elements erased (0 or 1).
+  using Base::erase;
+
+  // btree_map::insert()
+  //
+  // Inserts an element of the specified value into the `btree_map`,
+  // returning an iterator pointing to the newly inserted element, provided that
+  // an element with the given key does not already exist. If an insertion
+  // occurs, any references, pointers, or iterators are invalidated.
+  // Overloads are listed below.
+  //
+  // std::pair<iterator,bool> insert(const value_type& value):
+  //
+  //   Inserts a value into the `btree_map`. Returns a pair consisting of an
+  //   iterator to the inserted element (or to the element that prevented the
+  //   insertion) and a bool denoting whether the insertion took place.
+  //
+  // std::pair<iterator,bool> insert(value_type&& value):
+  //
+  //   Inserts a moveable value into the `btree_map`. Returns a pair
+  //   consisting of an iterator to the inserted element (or to the element that
+  //   prevented the insertion) and a bool denoting whether the insertion took
+  //   place.
+  //
+  // iterator insert(const_iterator hint, const value_type& value):
+  // iterator insert(const_iterator hint, value_type&& value):
+  //
+  //   Inserts a value, using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search. Returns an iterator to the
+  //   inserted element, or to the existing element that prevented the
+  //   insertion.
+  //
+  // void insert(InputIterator first, InputIterator last):
+  //
+  //   Inserts a range of values [`first`, `last`).
+  //
+  // void insert(std::initializer_list<init_type> ilist):
+  //
+  //   Inserts the elements within the initializer list `ilist`.
+  using Base::insert;
+
+  // btree_map::insert_or_assign()
+  //
+  // Inserts an element of the specified value into the `btree_map` provided
+  // that a value with the given key does not already exist, or replaces the
+  // corresponding mapped type with the forwarded `obj` argument if a key for
+  // that value already exists, returning an iterator pointing to the newly
+  // inserted element. Overloads are listed below.
+  //
+  // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj):
+  // pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj):
+  //
+  //   Inserts/Assigns (or moves) the element of the specified key into the
+  //   `btree_map`. If the returned bool is true, insertion took place, and if
+  //   it's false, assignment took place.
+  //
+  // iterator insert_or_assign(const_iterator hint,
+  //                           const key_type& k, M&& obj):
+  // iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj):
+  //
+  //   Inserts/Assigns (or moves) the element of the specified key into the
+  //   `btree_map` using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search.
+  using Base::insert_or_assign;
+
+  // btree_map::emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_map`, provided that no element with the given key
+  // already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately. Prefer `try_emplace()` unless your key is not
+  // copyable or moveable.
+  //
+  // If an insertion occurs, any references, pointers, or iterators are
+  // invalidated.
+  using Base::emplace;
+
+  // btree_map::emplace_hint()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_map`, using the position of `hint` as a non-binding
+  // suggestion for where to begin the insertion search, and only inserts
+  // provided that no element with the given key already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately. Prefer `try_emplace()` unless your key is not
+  // copyable or moveable.
+  //
+  // If an insertion occurs, any references, pointers, or iterators are
+  // invalidated.
+  using Base::emplace_hint;
+
+  // btree_map::try_emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_map`, provided that no element with the given key
+  // already exists. Unlike `emplace()`, if an element with the given key
+  // already exists, we guarantee that no element is constructed.
+  //
+  // If an insertion occurs, any references, pointers, or iterators are
+  // invalidated.
+  //
+  // Overloads are listed below.
+  //
+  //   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
+  //   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
+  //
+  // Inserts (via copy or move) the element of the specified key into the
+  // `btree_map`.
+  //
+  //   iterator try_emplace(const_iterator hint,
+  //                        const key_type& k, Args&&... args):
+  //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
+  //
+  // Inserts (via copy or move) the element of the specified key into the
+  // `btree_map` using the position of `hint` as a non-binding suggestion
+  // for where to begin the insertion search.
+  using Base::try_emplace;
+
+  // btree_map::extract()
+  //
+  // Extracts the indicated element, erasing it in the process, and returns it
+  // as a C++17-compatible node handle. Overloads are listed below.
+  //
+  // node_type extract(const_iterator position):
+  //
+  //   Extracts the element at the indicated position and returns a node handle
+  //   owning that extracted data.
+  //
+  // template <typename K> node_type extract(const K& k):
+  //
+  //   Extracts the element with the key matching the passed key value and
+  //   returns a node handle owning that extracted data. If the `btree_map`
+  //   does not contain an element with a matching key, this function returns an
+  //   empty node handle.
+  //
+  // NOTE: when compiled in an earlier version of C++ than C++17,
+  // `node_type::key()` returns a const reference to the key instead of a
+  // mutable reference. We cannot safely return a mutable reference without
+  // std::launder (which is not available before C++17).
+  //
+  // NOTE: In this context, `node_type` refers to the C++17 concept of a
+  // move-only type that owns and provides access to the elements in associative
+  // containers (https://en.cppreference.com/w/cpp/container/node_handle).
+  // It does NOT refer to the data layout of the underlying btree.
+  using Base::extract;
+
+  // btree_map::merge()
+  //
+  // Extracts elements from a given `source` btree_map into this
+  // `btree_map`. If the destination `btree_map` already contains an
+  // element with an equivalent key, that element is not extracted.
+  using Base::merge;
+
+  // btree_map::swap(btree_map& other)
+  //
+  // Exchanges the contents of this `btree_map` with those of the `other`
+  // btree_map, avoiding invocation of any move, copy, or swap operations on
+  // individual elements.
+  //
+  // All iterators and references on the `btree_map` remain valid, excepting
+  // for the past-the-end iterator, which is invalidated.
+  using Base::swap;
+
+  // btree_map::at()
+  //
+  // Returns a reference to the mapped value of the element with key equivalent
+  // to the passed key.
+  using Base::at;
+
+  // btree_map::contains()
+  //
+  // template <typename K> bool contains(const K& key) const:
+  //
+  // Determines whether an element comparing equal to the given `key` exists
+  // within the `btree_map`, returning `true` if so or `false` otherwise.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::contains;
+
+  // btree_map::count()
+  //
+  // template <typename K> size_type count(const K& key) const:
+  //
+  // Returns the number of elements comparing equal to the given `key` within
+  // the `btree_map`. Note that this function will return either `1` or `0`
+  // since duplicate elements are not allowed within a `btree_map`.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::count;
+
+  // btree_map::equal_range()
+  //
+  // Returns a half-open range [first, last), defined by a `std::pair` of two
+  // iterators, containing all elements with the passed key in the `btree_map`.
+  using Base::equal_range;
+
+  // btree_map::find()
+  //
+  // template <typename K> iterator find(const K& key):
+  // template <typename K> const_iterator find(const K& key) const:
+  //
+  // Finds an element with the passed `key` within the `btree_map`.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::find;
+
+  // btree_map::lower_bound()
+  //
+  // template <typename K> iterator lower_bound(const K& key):
+  // template <typename K> const_iterator lower_bound(const K& key) const:
+  //
+  // Finds the first element with a key that is not less than `key` within the
+  // `btree_map`.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::lower_bound;
+
+  // btree_map::upper_bound()
+  //
+  // template <typename K> iterator upper_bound(const K& key):
+  // template <typename K> const_iterator upper_bound(const K& key) const:
+  //
+  // Finds the first element with a key that is greater than `key` within the
+  // `btree_map`.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::upper_bound;
+
+  // btree_map::operator[]()
+  //
+  // Returns a reference to the value mapped to the passed key within the
+  // `btree_map`, performing an `insert()` if the key does not already
+  // exist.
+  //
+  // If an insertion occurs, any references, pointers, or iterators are
+  // invalidated. Otherwise iterators are not affected and references are not
+  // invalidated. Overloads are listed below.
+  //
+  // T& operator[](key_type&& key):
+  // T& operator[](const key_type& key):
+  //
+  //   Inserts a value_type object constructed in-place if the element with the
+  //   given key does not exist.
+  using Base::operator[];
+
+  // btree_map::get_allocator()
+  //
+  // Returns the allocator function associated with this `btree_map`.
+  using Base::get_allocator;
+
+  // btree_map::key_comp();
+  //
+  // Returns the key comparator associated with this `btree_map`.
+  using Base::key_comp;
+
+  // btree_map::value_comp();
+  //
+  // Returns the value comparator associated with this `btree_map`.
+  using Base::value_comp;
+};
+
+// absl::swap(absl::btree_map<>, absl::btree_map<>)
+//
+// Swaps the contents of two `absl::btree_map` containers.
+template <typename K, typename V, typename C, typename A>
+void swap(btree_map<K, V, C, A> &x, btree_map<K, V, C, A> &y) {
+  return x.swap(y);
+}
+
+// absl::erase_if(absl::btree_map<>, Pred)
+//
+// Erases all elements that satisfy the predicate pred from the container.
+// Returns the number of erased elements.
+template <typename K, typename V, typename C, typename A, typename Pred>
+typename btree_map<K, V, C, A>::size_type erase_if(
+    btree_map<K, V, C, A> &map, Pred pred) {
+  return container_internal::btree_access::erase_if(map, std::move(pred));
+}
+
+// absl::btree_multimap
+//
+// An `absl::btree_multimap<K, V>` is an ordered associative container of
+// keys and associated values designed to be a more efficient replacement for
+// `std::multimap` (in most cases). Unlike `absl::btree_map`, a B-tree multimap
+// allows multiple elements with equivalent keys.
+//
+// Keys are sorted using an (optional) comparison function, which defaults to
+// `std::less<K>`.
+//
+// An `absl::btree_multimap<K, V>` uses a default allocator of
+// `std::allocator<std::pair<const K, V>>` to allocate (and deallocate)
+// nodes, and construct and destruct values within those nodes. You may
+// instead specify a custom allocator `A` (which in turn requires specifying a
+// custom comparator `C`) as in `absl::btree_multimap<K, V, C, A>`.
+//
+template <typename Key, typename Value, typename Compare = std::less<Key>,
+          typename Alloc = std::allocator<std::pair<const Key, Value>>>
+class btree_multimap
+    : public container_internal::btree_multimap_container<
+          container_internal::btree<container_internal::map_params<
+              Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
+              /*IsMulti=*/true>>> {
+  using Base = typename btree_multimap::btree_multimap_container;
+
+ public:
+  // Constructors and Assignment Operators
+  //
+  // A `btree_multimap` supports the same overload set as `std::multimap`
+  // for construction and assignment:
+  //
+  // * Default constructor
+  //
+  //   absl::btree_multimap<int, std::string> map1;
+  //
+  // * Initializer List constructor
+  //
+  //   absl::btree_multimap<int, std::string> map2 =
+  //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
+  //
+  // * Copy constructor
+  //
+  //   absl::btree_multimap<int, std::string> map3(map2);
+  //
+  // * Copy assignment operator
+  //
+  //  absl::btree_multimap<int, std::string> map4;
+  //  map4 = map3;
+  //
+  // * Move constructor
+  //
+  //   // Move is guaranteed efficient
+  //   absl::btree_multimap<int, std::string> map5(std::move(map4));
+  //
+  // * Move assignment operator
+  //
+  //   // May be efficient if allocators are compatible
+  //   absl::btree_multimap<int, std::string> map6;
+  //   map6 = std::move(map5);
+  //
+  // * Range constructor
+  //
+  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+  //   absl::btree_multimap<int, std::string> map7(v.begin(), v.end());
+  btree_multimap() {}
+  using Base::Base;
+
+  // btree_multimap::begin()
+  //
+  // Returns an iterator to the beginning of the `btree_multimap`.
+  using Base::begin;
+
+  // btree_multimap::cbegin()
+  //
+  // Returns a const iterator to the beginning of the `btree_multimap`.
+  using Base::cbegin;
+
+  // btree_multimap::end()
+  //
+  // Returns an iterator to the end of the `btree_multimap`.
+  using Base::end;
+
+  // btree_multimap::cend()
+  //
+  // Returns a const iterator to the end of the `btree_multimap`.
+  using Base::cend;
+
+  // btree_multimap::empty()
+  //
+  // Returns whether or not the `btree_multimap` is empty.
+  using Base::empty;
+
+  // btree_multimap::max_size()
+  //
+  // Returns the largest theoretical possible number of elements within a
+  // `btree_multimap` under current memory constraints. This value can be
+  // thought of as the largest value of `std::distance(begin(), end())` for a
+  // `btree_multimap<Key, T>`.
+  using Base::max_size;
+
+  // btree_multimap::size()
+  //
+  // Returns the number of elements currently within the `btree_multimap`.
+  using Base::size;
+
+  // btree_multimap::clear()
+  //
+  // Removes all elements from the `btree_multimap`. Invalidates any references,
+  // pointers, or iterators referring to contained elements.
+  using Base::clear;
+
+  // btree_multimap::erase()
+  //
+  // Erases elements within the `btree_multimap`. If an erase occurs, any
+  // references, pointers, or iterators are invalidated.
+  // Overloads are listed below.
+  //
+  // iterator erase(iterator position):
+  // iterator erase(const_iterator position):
+  //
+  //   Erases the element at `position` of the `btree_multimap`, returning
+  //   the iterator pointing to the element after the one that was erased
+  //   (or end() if none exists).
+  //
+  // iterator erase(const_iterator first, const_iterator last):
+  //
+  //   Erases the elements in the open interval [`first`, `last`), returning
+  //   the iterator pointing to the element after the interval that was erased
+  //   (or end() if none exists).
+  //
+  // template <typename K> size_type erase(const K& key):
+  //
+  //   Erases the elements matching the key, if any exist, returning the
+  //   number of elements erased.
+  using Base::erase;
+
+  // btree_multimap::insert()
+  //
+  // Inserts an element of the specified value into the `btree_multimap`,
+  // returning an iterator pointing to the newly inserted element.
+  // Any references, pointers, or iterators are invalidated.  Overloads are
+  // listed below.
+  //
+  // iterator insert(const value_type& value):
+  //
+  //   Inserts a value into the `btree_multimap`, returning an iterator to the
+  //   inserted element.
+  //
+  // iterator insert(value_type&& value):
+  //
+  //   Inserts a moveable value into the `btree_multimap`, returning an iterator
+  //   to the inserted element.
+  //
+  // iterator insert(const_iterator hint, const value_type& value):
+  // iterator insert(const_iterator hint, value_type&& value):
+  //
+  //   Inserts a value, using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search. Returns an iterator to the
+  //   inserted element.
+  //
+  // void insert(InputIterator first, InputIterator last):
+  //
+  //   Inserts a range of values [`first`, `last`).
+  //
+  // void insert(std::initializer_list<init_type> ilist):
+  //
+  //   Inserts the elements within the initializer list `ilist`.
+  using Base::insert;
+
+  // btree_multimap::emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_multimap`. Any references, pointers, or iterators are
+  // invalidated.
+  using Base::emplace;
+
+  // btree_multimap::emplace_hint()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_multimap`, using the position of `hint` as a non-binding
+  // suggestion for where to begin the insertion search.
+  //
+  // Any references, pointers, or iterators are invalidated.
+  using Base::emplace_hint;
+
+  // btree_multimap::extract()
+  //
+  // Extracts the indicated element, erasing it in the process, and returns it
+  // as a C++17-compatible node handle. Overloads are listed below.
+  //
+  // node_type extract(const_iterator position):
+  //
+  //   Extracts the element at the indicated position and returns a node handle
+  //   owning that extracted data.
+  //
+  // template <typename K> node_type extract(const K& k):
+  //
+  //   Extracts the element with the key matching the passed key value and
+  //   returns a node handle owning that extracted data. If the `btree_multimap`
+  //   does not contain an element with a matching key, this function returns an
+  //   empty node handle.
+  //
+  // NOTE: when compiled in an earlier version of C++ than C++17,
+  // `node_type::key()` returns a const reference to the key instead of a
+  // mutable reference. We cannot safely return a mutable reference without
+  // std::launder (which is not available before C++17).
+  //
+  // NOTE: In this context, `node_type` refers to the C++17 concept of a
+  // move-only type that owns and provides access to the elements in associative
+  // containers (https://en.cppreference.com/w/cpp/container/node_handle).
+  // It does NOT refer to the data layout of the underlying btree.
+  using Base::extract;
+
+  // btree_multimap::merge()
+  //
+  // Extracts all elements from a given `source` btree_multimap into this
+  // `btree_multimap`.
+  using Base::merge;
+
+  // btree_multimap::swap(btree_multimap& other)
+  //
+  // Exchanges the contents of this `btree_multimap` with those of the `other`
+  // btree_multimap, avoiding invocation of any move, copy, or swap operations
+  // on individual elements.
+  //
+  // All iterators and references on the `btree_multimap` remain valid,
+  // excepting for the past-the-end iterator, which is invalidated.
+  using Base::swap;
+
+  // btree_multimap::contains()
+  //
+  // template <typename K> bool contains(const K& key) const:
+  //
+  // Determines whether an element comparing equal to the given `key` exists
+  // within the `btree_multimap`, returning `true` if so or `false` otherwise.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::contains;
+
+  // btree_multimap::count()
+  //
+  // template <typename K> size_type count(const K& key) const:
+  //
+  // Returns the number of elements comparing equal to the given `key` within
+  // the `btree_multimap`.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::count;
+
+  // btree_multimap::equal_range()
+  //
+  // Returns a half-open range [first, last), defined by a `std::pair` of two
+  // iterators, containing all elements with the passed key in the
+  // `btree_multimap`.
+  using Base::equal_range;
+
+  // btree_multimap::find()
+  //
+  // template <typename K> iterator find(const K& key):
+  // template <typename K> const_iterator find(const K& key) const:
+  //
+  // Finds an element with the passed `key` within the `btree_multimap`.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::find;
+
+  // btree_multimap::lower_bound()
+  //
+  // template <typename K> iterator lower_bound(const K& key):
+  // template <typename K> const_iterator lower_bound(const K& key) const:
+  //
+  // Finds the first element with a key that is not less than `key` within the
+  // `btree_multimap`.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::lower_bound;
+
+  // btree_multimap::upper_bound()
+  //
+  // template <typename K> iterator upper_bound(const K& key):
+  // template <typename K> const_iterator upper_bound(const K& key) const:
+  //
+  // Finds the first element with a key that is greater than `key` within the
+  // `btree_multimap`.
+  //
+  // Supports heterogeneous lookup, provided that the map has a compatible
+  // heterogeneous comparator.
+  using Base::upper_bound;
+
+  // btree_multimap::get_allocator()
+  //
+  // Returns the allocator function associated with this `btree_multimap`.
+  using Base::get_allocator;
+
+  // btree_multimap::key_comp();
+  //
+  // Returns the key comparator associated with this `btree_multimap`.
+  using Base::key_comp;
+
+  // btree_multimap::value_comp();
+  //
+  // Returns the value comparator associated with this `btree_multimap`.
+  using Base::value_comp;
+};
+
+// absl::swap(absl::btree_multimap<>, absl::btree_multimap<>)
+//
+// Swaps the contents of two `absl::btree_multimap` containers.
+template <typename K, typename V, typename C, typename A>
+void swap(btree_multimap<K, V, C, A> &x, btree_multimap<K, V, C, A> &y) {
+  return x.swap(y);
+}
+
+// absl::erase_if(absl::btree_multimap<>, Pred)
+//
+// Erases all elements that satisfy the predicate pred from the container.
+// Returns the number of erased elements.
+template <typename K, typename V, typename C, typename A, typename Pred>
+typename btree_multimap<K, V, C, A>::size_type erase_if(
+    btree_multimap<K, V, C, A> &map, Pred pred) {
+  return container_internal::btree_access::erase_if(map, std::move(pred));
+}
+
+namespace container_internal {
+
+// A parameters structure for holding the type parameters for a btree_map.
+// Compare and Alloc should be nothrow copy-constructible.
+template <typename Key, typename Data, typename Compare, typename Alloc,
+          int TargetNodeSize, bool IsMulti>
+struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
+                                  /*IsMap=*/true, map_slot_policy<Key, Data>> {
+  using super_type = typename map_params::common_params;
+  using mapped_type = Data;
+  // This type allows us to move keys when it is safe to do so. It is safe
+  // for maps in which value_type and mutable_value_type are layout compatible.
+  using slot_policy = typename super_type::slot_policy;
+  using slot_type = typename super_type::slot_type;
+  using value_type = typename super_type::value_type;
+  using init_type = typename super_type::init_type;
+
+  template <typename V>
+  static auto key(const V &value) -> decltype(value.first) {
+    return value.first;
+  }
+  static const Key &key(const slot_type *s) { return slot_policy::key(s); }
+  static const Key &key(slot_type *s) { return slot_policy::key(s); }
+  // For use in node handle.
+  static auto mutable_key(slot_type *s)
+      -> decltype(slot_policy::mutable_key(s)) {
+    return slot_policy::mutable_key(s);
+  }
+  static mapped_type &value(value_type *value) { return value->second; }
+};
+
+}  // namespace container_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_BTREE_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/btree_set.h b/CAPI/cpp/grpc/include/absl/container/btree_set.h
new file mode 100644
index 0000000..695b09f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/btree_set.h
@@ -0,0 +1,793 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: btree_set.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines B-tree sets: sorted associative containers of
+// values.
+//
+//     * `absl::btree_set<>`
+//     * `absl::btree_multiset<>`
+//
+// These B-tree types are similar to the corresponding types in the STL
+// (`std::set` and `std::multiset`) and generally conform to the STL interfaces
+// of those types. However, because they are implemented using B-trees, they
+// are more efficient in most situations.
+//
+// Unlike `std::set` and `std::multiset`, which are commonly implemented using
+// red-black tree nodes, B-tree sets use more generic B-tree nodes able to hold
+// multiple values per node. Holding multiple values per node often makes
+// B-tree sets perform better than their `std::set` counterparts, because
+// multiple entries can be checked within the same cache hit.
+//
+// However, these types should not be considered drop-in replacements for
+// `std::set` and `std::multiset` as there are some API differences, which are
+// noted in this header file. The most consequential differences with respect to
+// migrating to b-tree from the STL types are listed in the next paragraph.
+// Other API differences are minor.
+//
+// Importantly, insertions and deletions may invalidate outstanding iterators,
+// pointers, and references to elements. Such invalidations are typically only
+// an issue if insertion and deletion operations are interleaved with the use of
+// more than one iterator, pointer, or reference simultaneously. For this
+// reason, `insert()` and `erase()` return a valid iterator at the current
+// position.
+
+#ifndef ABSL_CONTAINER_BTREE_SET_H_
+#define ABSL_CONTAINER_BTREE_SET_H_
+
+#include "absl/container/internal/btree.h"  // IWYU pragma: export
+#include "absl/container/internal/btree_container.h"  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace container_internal {
+
+template <typename Key>
+struct set_slot_policy;
+
+template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
+          bool IsMulti>
+struct set_params;
+
+}  // namespace container_internal
+
+// absl::btree_set<>
+//
+// An `absl::btree_set<K>` is an ordered associative container of unique key
+// values designed to be a more efficient replacement for `std::set` (in most
+// cases).
+//
+// Keys are sorted using an (optional) comparison function, which defaults to
+// `std::less<K>`.
+//
+// An `absl::btree_set<K>` uses a default allocator of `std::allocator<K>` to
+// allocate (and deallocate) nodes, and construct and destruct values within
+// those nodes. You may instead specify a custom allocator `A` (which in turn
+// requires specifying a custom comparator `C`) as in
+// `absl::btree_set<K, C, A>`.
+//
+template <typename Key, typename Compare = std::less<Key>,
+          typename Alloc = std::allocator<Key>>
+class btree_set
+    : public container_internal::btree_set_container<
+          container_internal::btree<container_internal::set_params<
+              Key, Compare, Alloc, /*TargetNodeSize=*/256,
+              /*IsMulti=*/false>>> {
+  using Base = typename btree_set::btree_set_container;
+
+ public:
+  // Constructors and Assignment Operators
+  //
+  // A `btree_set` supports the same overload set as `std::set`
+  // for construction and assignment:
+  //
+  // * Default constructor
+  //
+  //   absl::btree_set<std::string> set1;
+  //
+  // * Initializer List constructor
+  //
+  //   absl::btree_set<std::string> set2 =
+  //       {{"huey"}, {"dewey"}, {"louie"},};
+  //
+  // * Copy constructor
+  //
+  //   absl::btree_set<std::string> set3(set2);
+  //
+  // * Copy assignment operator
+  //
+  //  absl::btree_set<std::string> set4;
+  //  set4 = set3;
+  //
+  // * Move constructor
+  //
+  //   // Move is guaranteed efficient
+  //   absl::btree_set<std::string> set5(std::move(set4));
+  //
+  // * Move assignment operator
+  //
+  //   // May be efficient if allocators are compatible
+  //   absl::btree_set<std::string> set6;
+  //   set6 = std::move(set5);
+  //
+  // * Range constructor
+  //
+  //   std::vector<std::string> v = {"a", "b"};
+  //   absl::btree_set<std::string> set7(v.begin(), v.end());
+  btree_set() {}
+  using Base::Base;
+
+  // btree_set::begin()
+  //
+  // Returns an iterator to the beginning of the `btree_set`.
+  using Base::begin;
+
+  // btree_set::cbegin()
+  //
+  // Returns a const iterator to the beginning of the `btree_set`.
+  using Base::cbegin;
+
+  // btree_set::end()
+  //
+  // Returns an iterator to the end of the `btree_set`.
+  using Base::end;
+
+  // btree_set::cend()
+  //
+  // Returns a const iterator to the end of the `btree_set`.
+  using Base::cend;
+
+  // btree_set::empty()
+  //
+  // Returns whether or not the `btree_set` is empty.
+  using Base::empty;
+
+  // btree_set::max_size()
+  //
+  // Returns the largest theoretical possible number of elements within a
+  // `btree_set` under current memory constraints. This value can be thought
+  // of as the largest value of `std::distance(begin(), end())` for a
+  // `btree_set<Key>`.
+  using Base::max_size;
+
+  // btree_set::size()
+  //
+  // Returns the number of elements currently within the `btree_set`.
+  using Base::size;
+
+  // btree_set::clear()
+  //
+  // Removes all elements from the `btree_set`. Invalidates any references,
+  // pointers, or iterators referring to contained elements.
+  using Base::clear;
+
+  // btree_set::erase()
+  //
+  // Erases elements within the `btree_set`. Overloads are listed below.
+  //
+  // iterator erase(iterator position):
+  // iterator erase(const_iterator position):
+  //
+  //   Erases the element at `position` of the `btree_set`, returning
+  //   the iterator pointing to the element after the one that was erased
+  //   (or end() if none exists).
+  //
+  // iterator erase(const_iterator first, const_iterator last):
+  //
+  //   Erases the elements in the open interval [`first`, `last`), returning
+  //   the iterator pointing to the element after the interval that was erased
+  //   (or end() if none exists).
+  //
+  // template <typename K> size_type erase(const K& key):
+  //
+  //   Erases the element with the matching key, if it exists, returning the
+  //   number of elements erased (0 or 1).
+  using Base::erase;
+
+  // btree_set::insert()
+  //
+  // Inserts an element of the specified value into the `btree_set`,
+  // returning an iterator pointing to the newly inserted element, provided that
+  // an element with the given key does not already exist. If an insertion
+  // occurs, any references, pointers, or iterators are invalidated.
+  // Overloads are listed below.
+  //
+  // std::pair<iterator,bool> insert(const value_type& value):
+  //
+  //   Inserts a value into the `btree_set`. Returns a pair consisting of an
+  //   iterator to the inserted element (or to the element that prevented the
+  //   insertion) and a bool denoting whether the insertion took place.
+  //
+  // std::pair<iterator,bool> insert(value_type&& value):
+  //
+  //   Inserts a moveable value into the `btree_set`. Returns a pair
+  //   consisting of an iterator to the inserted element (or to the element that
+  //   prevented the insertion) and a bool denoting whether the insertion took
+  //   place.
+  //
+  // iterator insert(const_iterator hint, const value_type& value):
+  // iterator insert(const_iterator hint, value_type&& value):
+  //
+  //   Inserts a value, using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search. Returns an iterator to the
+  //   inserted element, or to the existing element that prevented the
+  //   insertion.
+  //
+  // void insert(InputIterator first, InputIterator last):
+  //
+  //   Inserts a range of values [`first`, `last`).
+  //
+  // void insert(std::initializer_list<init_type> ilist):
+  //
+  //   Inserts the elements within the initializer list `ilist`.
+  using Base::insert;
+
+  // btree_set::emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_set`, provided that no element with the given key
+  // already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately.
+  //
+  // If an insertion occurs, any references, pointers, or iterators are
+  // invalidated.
+  using Base::emplace;
+
+  // btree_set::emplace_hint()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_set`, using the position of `hint` as a non-binding
+  // suggestion for where to begin the insertion search, and only inserts
+  // provided that no element with the given key already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately.
+  //
+  // If an insertion occurs, any references, pointers, or iterators are
+  // invalidated.
+  using Base::emplace_hint;
+
+  // btree_set::extract()
+  //
+  // Extracts the indicated element, erasing it in the process, and returns it
+  // as a C++17-compatible node handle. Overloads are listed below.
+  //
+  // node_type extract(const_iterator position):
+  //
+  //   Extracts the element at the indicated position and returns a node handle
+  //   owning that extracted data.
+  //
+  // template <typename K> node_type extract(const K& k):
+  //
+  //   Extracts the element with the key matching the passed key value and
+  //   returns a node handle owning that extracted data. If the `btree_set`
+  //   does not contain an element with a matching key, this function returns an
+  //   empty node handle.
+  //
+  // NOTE: In this context, `node_type` refers to the C++17 concept of a
+  // move-only type that owns and provides access to the elements in associative
+  // containers (https://en.cppreference.com/w/cpp/container/node_handle).
+  // It does NOT refer to the data layout of the underlying btree.
+  using Base::extract;
+
+  // btree_set::merge()
+  //
+  // Extracts elements from a given `source` btree_set into this
+  // `btree_set`. If the destination `btree_set` already contains an
+  // element with an equivalent key, that element is not extracted.
+  using Base::merge;
+
+  // btree_set::swap(btree_set& other)
+  //
+  // Exchanges the contents of this `btree_set` with those of the `other`
+  // btree_set, avoiding invocation of any move, copy, or swap operations on
+  // individual elements.
+  //
+  // All iterators and references on the `btree_set` remain valid, excepting
+  // for the past-the-end iterator, which is invalidated.
+  using Base::swap;
+
+  // btree_set::contains()
+  //
+  // template <typename K> bool contains(const K& key) const:
+  //
+  // Determines whether an element comparing equal to the given `key` exists
+  // within the `btree_set`, returning `true` if so or `false` otherwise.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::contains;
+
+  // btree_set::count()
+  //
+  // template <typename K> size_type count(const K& key) const:
+  //
+  // Returns the number of elements comparing equal to the given `key` within
+  // the `btree_set`. Note that this function will return either `1` or `0`
+  // since duplicate elements are not allowed within a `btree_set`.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::count;
+
+  // btree_set::equal_range()
+  //
+  // Returns a closed range [first, last], defined by a `std::pair` of two
+  // iterators, containing all elements with the passed key in the
+  // `btree_set`.
+  using Base::equal_range;
+
+  // btree_set::find()
+  //
+  // template <typename K> iterator find(const K& key):
+  // template <typename K> const_iterator find(const K& key) const:
+  //
+  // Finds an element with the passed `key` within the `btree_set`.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::find;
+
+  // btree_set::lower_bound()
+  //
+  // template <typename K> iterator lower_bound(const K& key):
+  // template <typename K> const_iterator lower_bound(const K& key) const:
+  //
+  // Finds the first element that is not less than `key` within the `btree_set`.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::lower_bound;
+
+  // btree_set::upper_bound()
+  //
+  // template <typename K> iterator upper_bound(const K& key):
+  // template <typename K> const_iterator upper_bound(const K& key) const:
+  //
+  // Finds the first element that is greater than `key` within the `btree_set`.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::upper_bound;
+
+  // btree_set::get_allocator()
+  //
+  // Returns the allocator function associated with this `btree_set`.
+  using Base::get_allocator;
+
+  // btree_set::key_comp();
+  //
+  // Returns the key comparator associated with this `btree_set`.
+  using Base::key_comp;
+
+  // btree_set::value_comp();
+  //
+  // Returns the value comparator associated with this `btree_set`. The keys to
+  // sort the elements are the values themselves, therefore `value_comp` and its
+  // sibling member function `key_comp` are equivalent.
+  using Base::value_comp;
+};
+
+// absl::swap(absl::btree_set<>, absl::btree_set<>)
+//
+// Swaps the contents of two `absl::btree_set` containers.
+template <typename K, typename C, typename A>
+void swap(btree_set<K, C, A> &x, btree_set<K, C, A> &y) {
+  return x.swap(y);
+}
+
+// absl::erase_if(absl::btree_set<>, Pred)
+//
+// Erases all elements that satisfy the predicate pred from the container.
+// Returns the number of erased elements.
+template <typename K, typename C, typename A, typename Pred>
+typename btree_set<K, C, A>::size_type erase_if(btree_set<K, C, A> &set,
+                                                Pred pred) {
+  return container_internal::btree_access::erase_if(set, std::move(pred));
+}
+
+// absl::btree_multiset<>
+//
+// An `absl::btree_multiset<K>` is an ordered associative container of
+// keys and associated values designed to be a more efficient replacement
+// for `std::multiset` (in most cases). Unlike `absl::btree_set`, a B-tree
+// multiset allows equivalent elements.
+//
+// Keys are sorted using an (optional) comparison function, which defaults to
+// `std::less<K>`.
+//
+// An `absl::btree_multiset<K>` uses a default allocator of `std::allocator<K>`
+// to allocate (and deallocate) nodes, and construct and destruct values within
+// those nodes. You may instead specify a custom allocator `A` (which in turn
+// requires specifying a custom comparator `C`) as in
+// `absl::btree_multiset<K, C, A>`.
+//
+template <typename Key, typename Compare = std::less<Key>,
+          typename Alloc = std::allocator<Key>>
+class btree_multiset
+    : public container_internal::btree_multiset_container<
+          container_internal::btree<container_internal::set_params<
+              Key, Compare, Alloc, /*TargetNodeSize=*/256,
+              /*IsMulti=*/true>>> {
+  using Base = typename btree_multiset::btree_multiset_container;
+
+ public:
+  // Constructors and Assignment Operators
+  //
+  // A `btree_multiset` supports the same overload set as `std::set`
+  // for construction and assignment:
+  //
+  // * Default constructor
+  //
+  //   absl::btree_multiset<std::string> set1;
+  //
+  // * Initializer List constructor
+  //
+  //   absl::btree_multiset<std::string> set2 =
+  //       {{"huey"}, {"dewey"}, {"louie"},};
+  //
+  // * Copy constructor
+  //
+  //   absl::btree_multiset<std::string> set3(set2);
+  //
+  // * Copy assignment operator
+  //
+  //  absl::btree_multiset<std::string> set4;
+  //  set4 = set3;
+  //
+  // * Move constructor
+  //
+  //   // Move is guaranteed efficient
+  //   absl::btree_multiset<std::string> set5(std::move(set4));
+  //
+  // * Move assignment operator
+  //
+  //   // May be efficient if allocators are compatible
+  //   absl::btree_multiset<std::string> set6;
+  //   set6 = std::move(set5);
+  //
+  // * Range constructor
+  //
+  //   std::vector<std::string> v = {"a", "b"};
+  //   absl::btree_multiset<std::string> set7(v.begin(), v.end());
+  btree_multiset() {}
+  using Base::Base;
+
+  // btree_multiset::begin()
+  //
+  // Returns an iterator to the beginning of the `btree_multiset`.
+  using Base::begin;
+
+  // btree_multiset::cbegin()
+  //
+  // Returns a const iterator to the beginning of the `btree_multiset`.
+  using Base::cbegin;
+
+  // btree_multiset::end()
+  //
+  // Returns an iterator to the end of the `btree_multiset`.
+  using Base::end;
+
+  // btree_multiset::cend()
+  //
+  // Returns a const iterator to the end of the `btree_multiset`.
+  using Base::cend;
+
+  // btree_multiset::empty()
+  //
+  // Returns whether or not the `btree_multiset` is empty.
+  using Base::empty;
+
+  // btree_multiset::max_size()
+  //
+  // Returns the largest theoretical possible number of elements within a
+  // `btree_multiset` under current memory constraints. This value can be
+  // thought of as the largest value of `std::distance(begin(), end())` for a
+  // `btree_multiset<Key>`.
+  using Base::max_size;
+
+  // btree_multiset::size()
+  //
+  // Returns the number of elements currently within the `btree_multiset`.
+  using Base::size;
+
+  // btree_multiset::clear()
+  //
+  // Removes all elements from the `btree_multiset`. Invalidates any references,
+  // pointers, or iterators referring to contained elements.
+  using Base::clear;
+
+  // btree_multiset::erase()
+  //
+  // Erases elements within the `btree_multiset`. Overloads are listed below.
+  //
+  // iterator erase(iterator position):
+  // iterator erase(const_iterator position):
+  //
+  //   Erases the element at `position` of the `btree_multiset`, returning
+  //   the iterator pointing to the element after the one that was erased
+  //   (or end() if none exists).
+  //
+  // iterator erase(const_iterator first, const_iterator last):
+  //
+  //   Erases the elements in the open interval [`first`, `last`), returning
+  //   the iterator pointing to the element after the interval that was erased
+  //   (or end() if none exists).
+  //
+  // template <typename K> size_type erase(const K& key):
+  //
+  //   Erases the elements matching the key, if any exist, returning the
+  //   number of elements erased.
+  using Base::erase;
+
+  // btree_multiset::insert()
+  //
+  // Inserts an element of the specified value into the `btree_multiset`,
+  // returning an iterator pointing to the newly inserted element.
+  // Any references, pointers, or iterators are invalidated.  Overloads are
+  // listed below.
+  //
+  // iterator insert(const value_type& value):
+  //
+  //   Inserts a value into the `btree_multiset`, returning an iterator to the
+  //   inserted element.
+  //
+  // iterator insert(value_type&& value):
+  //
+  //   Inserts a moveable value into the `btree_multiset`, returning an iterator
+  //   to the inserted element.
+  //
+  // iterator insert(const_iterator hint, const value_type& value):
+  // iterator insert(const_iterator hint, value_type&& value):
+  //
+  //   Inserts a value, using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search. Returns an iterator to the
+  //   inserted element.
+  //
+  // void insert(InputIterator first, InputIterator last):
+  //
+  //   Inserts a range of values [`first`, `last`).
+  //
+  // void insert(std::initializer_list<init_type> ilist):
+  //
+  //   Inserts the elements within the initializer list `ilist`.
+  using Base::insert;
+
+  // btree_multiset::emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_multiset`. Any references, pointers, or iterators are
+  // invalidated.
+  using Base::emplace;
+
+  // btree_multiset::emplace_hint()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `btree_multiset`, using the position of `hint` as a non-binding
+  // suggestion for where to begin the insertion search.
+  //
+  // Any references, pointers, or iterators are invalidated.
+  using Base::emplace_hint;
+
+  // btree_multiset::extract()
+  //
+  // Extracts the indicated element, erasing it in the process, and returns it
+  // as a C++17-compatible node handle. Overloads are listed below.
+  //
+  // node_type extract(const_iterator position):
+  //
+  //   Extracts the element at the indicated position and returns a node handle
+  //   owning that extracted data.
+  //
+  // template <typename K> node_type extract(const K& k):
+  //
+  //   Extracts the element with the key matching the passed key value and
+  //   returns a node handle owning that extracted data. If the `btree_multiset`
+  //   does not contain an element with a matching key, this function returns an
+  //   empty node handle.
+  //
+  // NOTE: In this context, `node_type` refers to the C++17 concept of a
+  // move-only type that owns and provides access to the elements in associative
+  // containers (https://en.cppreference.com/w/cpp/container/node_handle).
+  // It does NOT refer to the data layout of the underlying btree.
+  using Base::extract;
+
+  // btree_multiset::merge()
+  //
+  // Extracts all elements from a given `source` btree_multiset into this
+  // `btree_multiset`.
+  using Base::merge;
+
+  // btree_multiset::swap(btree_multiset& other)
+  //
+  // Exchanges the contents of this `btree_multiset` with those of the `other`
+  // btree_multiset, avoiding invocation of any move, copy, or swap operations
+  // on individual elements.
+  //
+  // All iterators and references on the `btree_multiset` remain valid,
+  // excepting for the past-the-end iterator, which is invalidated.
+  using Base::swap;
+
+  // btree_multiset::contains()
+  //
+  // template <typename K> bool contains(const K& key) const:
+  //
+  // Determines whether an element comparing equal to the given `key` exists
+  // within the `btree_multiset`, returning `true` if so or `false` otherwise.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::contains;
+
+  // btree_multiset::count()
+  //
+  // template <typename K> size_type count(const K& key) const:
+  //
+  // Returns the number of elements comparing equal to the given `key` within
+  // the `btree_multiset`.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::count;
+
+  // btree_multiset::equal_range()
+  //
+  // Returns a closed range [first, last], defined by a `std::pair` of two
+  // iterators, containing all elements with the passed key in the
+  // `btree_multiset`.
+  using Base::equal_range;
+
+  // btree_multiset::find()
+  //
+  // template <typename K> iterator find(const K& key):
+  // template <typename K> const_iterator find(const K& key) const:
+  //
+  // Finds an element with the passed `key` within the `btree_multiset`.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::find;
+
+  // btree_multiset::lower_bound()
+  //
+  // template <typename K> iterator lower_bound(const K& key):
+  // template <typename K> const_iterator lower_bound(const K& key) const:
+  //
+  // Finds the first element that is not less than `key` within the
+  // `btree_multiset`.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::lower_bound;
+
+  // btree_multiset::upper_bound()
+  //
+  // template <typename K> iterator upper_bound(const K& key):
+  // template <typename K> const_iterator upper_bound(const K& key) const:
+  //
+  // Finds the first element that is greater than `key` within the
+  // `btree_multiset`.
+  //
+  // Supports heterogeneous lookup, provided that the set has a compatible
+  // heterogeneous comparator.
+  using Base::upper_bound;
+
+  // btree_multiset::get_allocator()
+  //
+  // Returns the allocator function associated with this `btree_multiset`.
+  using Base::get_allocator;
+
+  // btree_multiset::key_comp();
+  //
+  // Returns the key comparator associated with this `btree_multiset`.
+  using Base::key_comp;
+
+  // btree_multiset::value_comp();
+  //
+  // Returns the value comparator associated with this `btree_multiset`. The
+  // keys to sort the elements are the values themselves, therefore `value_comp`
+  // and its sibling member function `key_comp` are equivalent.
+  using Base::value_comp;
+};
+
+// absl::swap(absl::btree_multiset<>, absl::btree_multiset<>)
+//
+// Swaps the contents of two `absl::btree_multiset` containers.
+template <typename K, typename C, typename A>
+void swap(btree_multiset<K, C, A> &x, btree_multiset<K, C, A> &y) {
+  return x.swap(y);
+}
+
+// absl::erase_if(absl::btree_multiset<>, Pred)
+//
+// Erases all elements that satisfy the predicate pred from the container.
+// Returns the number of erased elements.
+template <typename K, typename C, typename A, typename Pred>
+typename btree_multiset<K, C, A>::size_type erase_if(
+   btree_multiset<K, C, A> & set, Pred pred) {
+  return container_internal::btree_access::erase_if(set, std::move(pred));
+}
+
+namespace container_internal {
+
+// This type implements the necessary functions from the
+// absl::container_internal::slot_type interface for btree_(multi)set.
+template <typename Key>
+struct set_slot_policy {
+  using slot_type = Key;
+  using value_type = Key;
+  using mutable_value_type = Key;
+
+  static value_type &element(slot_type *slot) { return *slot; }
+  static const value_type &element(const slot_type *slot) { return *slot; }
+
+  template <typename Alloc, class... Args>
+  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
+    absl::allocator_traits<Alloc>::construct(*alloc, slot,
+                                             std::forward<Args>(args)...);
+  }
+
+  template <typename Alloc>
+  static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
+    absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
+  }
+
+  template <typename Alloc>
+  static void construct(Alloc *alloc, slot_type *slot, const slot_type *other) {
+    absl::allocator_traits<Alloc>::construct(*alloc, slot, *other);
+  }
+
+  template <typename Alloc>
+  static void destroy(Alloc *alloc, slot_type *slot) {
+    absl::allocator_traits<Alloc>::destroy(*alloc, slot);
+  }
+
+  template <typename Alloc>
+  static void transfer(Alloc *alloc, slot_type *new_slot, slot_type *old_slot) {
+    construct(alloc, new_slot, old_slot);
+    destroy(alloc, old_slot);
+  }
+};
+
+// A parameters structure for holding the type parameters for a btree_set.
+// Compare and Alloc should be nothrow copy-constructible.
+template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
+          bool IsMulti>
+struct set_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
+                                  /*IsMap=*/false, set_slot_policy<Key>> {
+  using value_type = Key;
+  using slot_type = typename set_params::common_params::slot_type;
+
+  template <typename V>
+  static const V &key(const V &value) {
+    return value;
+  }
+  static const Key &key(const slot_type *slot) { return *slot; }
+  static const Key &key(slot_type *slot) { return *slot; }
+};
+
+}  // namespace container_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_BTREE_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/btree_test.h b/CAPI/cpp/grpc/include/absl/container/btree_test.h
new file mode 100644
index 0000000..6249080
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/btree_test.h
@@ -0,0 +1,166 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_BTREE_TEST_H_
+#define ABSL_CONTAINER_BTREE_TEST_H_
+
+#include <algorithm>
+#include <cassert>
+#include <random>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/container/btree_map.h"
+#include "absl/container/btree_set.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/cord.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// Like remove_const but propagates the removal through std::pair.
+template <typename T>
+struct remove_pair_const {
+  using type = typename std::remove_const<T>::type;
+};
+template <typename T, typename U>
+struct remove_pair_const<std::pair<T, U> > {
+  using type = std::pair<typename remove_pair_const<T>::type,
+                         typename remove_pair_const<U>::type>;
+};
+
+// Utility class to provide an accessor for a key given a value. The default
+// behavior is to treat the value as a pair and return the first element.
+template <typename K, typename V>
+struct KeyOfValue {
+  struct type {
+    const K& operator()(const V& p) const { return p.first; }
+  };
+};
+
+// Partial specialization of KeyOfValue class for when the key and value are
+// the same type such as in set<> and btree_set<>.
+template <typename K>
+struct KeyOfValue<K, K> {
+  struct type {
+    const K& operator()(const K& k) const { return k; }
+  };
+};
+
+inline char* GenerateDigits(char buf[16], unsigned val, unsigned maxval) {
+  assert(val <= maxval);
+  constexpr unsigned kBase = 64;  // avoid integer division.
+  unsigned p = 15;
+  buf[p--] = 0;
+  while (maxval > 0) {
+    buf[p--] = ' ' + (val % kBase);
+    val /= kBase;
+    maxval /= kBase;
+  }
+  return buf + p + 1;
+}
+
+template <typename K>
+struct Generator {
+  int maxval;
+  explicit Generator(int m) : maxval(m) {}
+  K operator()(int i) const {
+    assert(i <= maxval);
+    return K(i);
+  }
+};
+
+template <>
+struct Generator<absl::Time> {
+  int maxval;
+  explicit Generator(int m) : maxval(m) {}
+  absl::Time operator()(int i) const { return absl::FromUnixMillis(i); }
+};
+
+template <>
+struct Generator<std::string> {
+  int maxval;
+  explicit Generator(int m) : maxval(m) {}
+  std::string operator()(int i) const {
+    char buf[16];
+    return GenerateDigits(buf, i, maxval);
+  }
+};
+
+template <>
+struct Generator<Cord> {
+  int maxval;
+  explicit Generator(int m) : maxval(m) {}
+  Cord operator()(int i) const {
+    char buf[16];
+    return Cord(GenerateDigits(buf, i, maxval));
+  }
+};
+
+template <typename T, typename U>
+struct Generator<std::pair<T, U> > {
+  Generator<typename remove_pair_const<T>::type> tgen;
+  Generator<typename remove_pair_const<U>::type> ugen;
+
+  explicit Generator(int m) : tgen(m), ugen(m) {}
+  std::pair<T, U> operator()(int i) const {
+    return std::make_pair(tgen(i), ugen(i));
+  }
+};
+
+// Generate n values for our tests and benchmarks. Value range is [0, maxval].
+inline std::vector<int> GenerateNumbersWithSeed(int n, int maxval, int seed) {
+  // NOTE: Some tests rely on generated numbers not changing between test runs.
+  // We use std::minstd_rand0 because it is well-defined, but don't use
+  // std::uniform_int_distribution because platforms use different algorithms.
+  std::minstd_rand0 rng(seed);
+
+  std::vector<int> values;
+  absl::flat_hash_set<int> unique_values;
+  if (values.size() < n) {
+    for (int i = values.size(); i < n; i++) {
+      int value;
+      do {
+        value = static_cast<int>(rng()) % (maxval + 1);
+      } while (!unique_values.insert(value).second);
+
+      values.push_back(value);
+    }
+  }
+  return values;
+}
+
+// Generates n values in the range [0, maxval].
+template <typename V>
+std::vector<V> GenerateValuesWithSeed(int n, int maxval, int seed) {
+  const std::vector<int> nums = GenerateNumbersWithSeed(n, maxval, seed);
+  Generator<V> gen(maxval);
+  std::vector<V> vec;
+
+  vec.reserve(n);
+  for (int i = 0; i < n; i++) {
+    vec.push_back(gen(nums[i]));
+  }
+
+  return vec;
+}
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_BTREE_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/fixed_array.h b/CAPI/cpp/grpc/include/absl/container/fixed_array.h
new file mode 100644
index 0000000..2aefae3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/fixed_array.h
@@ -0,0 +1,529 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: fixed_array.h
+// -----------------------------------------------------------------------------
+//
+// A `FixedArray<T>` represents a non-resizable array of `T` where the length of
+// the array can be determined at run-time. It is a good replacement for
+// non-standard and deprecated uses of `alloca()` and variable length arrays
+// within the GCC extension. (See
+// https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html).
+//
+// `FixedArray` allocates small arrays inline, keeping performance fast by
+// avoiding heap operations. It also helps reduce the chances of
+// accidentally overflowing your stack if large input is passed to
+// your function.
+
+#ifndef ABSL_CONTAINER_FIXED_ARRAY_H_
+#define ABSL_CONTAINER_FIXED_ARRAY_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <new>
+#include <type_traits>
+
+#include "absl/algorithm/algorithm.h"
+#include "absl/base/config.h"
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+#include "absl/container/internal/compressed_tuple.h"
+#include "absl/memory/memory.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1);
+
+// -----------------------------------------------------------------------------
+// FixedArray
+// -----------------------------------------------------------------------------
+//
+// A `FixedArray` provides a run-time fixed-size array, allocating a small array
+// inline for efficiency.
+//
+// Most users should not specify an `inline_elements` argument and let
+// `FixedArray` automatically determine the number of elements
+// to store inline based on `sizeof(T)`. If `inline_elements` is specified, the
+// `FixedArray` implementation will use inline storage for arrays with a
+// length <= `inline_elements`.
+//
+// Note that a `FixedArray` constructed with a `size_type` argument will
+// default-initialize its values by leaving trivially constructible types
+// uninitialized (e.g. int, int[4], double), and others default-constructed.
+// This matches the behavior of c-style arrays and `std::array`, but not
+// `std::vector`.
+template <typename T, size_t N = kFixedArrayUseDefault,
+          typename A = std::allocator<T>>
+class FixedArray {
+  static_assert(!std::is_array<T>::value || std::extent<T>::value > 0,
+                "Arrays with unknown bounds cannot be used with FixedArray.");
+
+  static constexpr size_t kInlineBytesDefault = 256;
+
+  using AllocatorTraits = std::allocator_traits<A>;
+  // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17,
+  // but this seems to be mostly pedantic.
+  template <typename Iterator>
+  using EnableIfForwardIterator = absl::enable_if_t<std::is_convertible<
+      typename std::iterator_traits<Iterator>::iterator_category,
+      std::forward_iterator_tag>::value>;
+  static constexpr bool NoexceptCopyable() {
+    return std::is_nothrow_copy_constructible<StorageElement>::value &&
+           absl::allocator_is_nothrow<allocator_type>::value;
+  }
+  static constexpr bool NoexceptMovable() {
+    return std::is_nothrow_move_constructible<StorageElement>::value &&
+           absl::allocator_is_nothrow<allocator_type>::value;
+  }
+  static constexpr bool DefaultConstructorIsNonTrivial() {
+    return !absl::is_trivially_default_constructible<StorageElement>::value;
+  }
+
+ public:
+  using allocator_type = typename AllocatorTraits::allocator_type;
+  using value_type = typename AllocatorTraits::value_type;
+  using pointer = typename AllocatorTraits::pointer;
+  using const_pointer = typename AllocatorTraits::const_pointer;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using size_type = typename AllocatorTraits::size_type;
+  using difference_type = typename AllocatorTraits::difference_type;
+  using iterator = pointer;
+  using const_iterator = const_pointer;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  static constexpr size_type inline_elements =
+      (N == kFixedArrayUseDefault ? kInlineBytesDefault / sizeof(value_type)
+                                  : static_cast<size_type>(N));
+
+  FixedArray(
+      const FixedArray& other,
+      const allocator_type& a = allocator_type()) noexcept(NoexceptCopyable())
+      : FixedArray(other.begin(), other.end(), a) {}
+
+  FixedArray(
+      FixedArray&& other,
+      const allocator_type& a = allocator_type()) noexcept(NoexceptMovable())
+      : FixedArray(std::make_move_iterator(other.begin()),
+                   std::make_move_iterator(other.end()), a) {}
+
+  // Creates an array object that can store `n` elements.
+  // Note that trivially constructible elements will be uninitialized.
+  explicit FixedArray(size_type n, const allocator_type& a = allocator_type())
+      : storage_(n, a) {
+    if (DefaultConstructorIsNonTrivial()) {
+      memory_internal::ConstructRange(storage_.alloc(), storage_.begin(),
+                                      storage_.end());
+    }
+  }
+
+  // Creates an array initialized with `n` copies of `val`.
+  FixedArray(size_type n, const value_type& val,
+             const allocator_type& a = allocator_type())
+      : storage_(n, a) {
+    memory_internal::ConstructRange(storage_.alloc(), storage_.begin(),
+                                    storage_.end(), val);
+  }
+
+  // Creates an array initialized with the size and contents of `init_list`.
+  FixedArray(std::initializer_list<value_type> init_list,
+             const allocator_type& a = allocator_type())
+      : FixedArray(init_list.begin(), init_list.end(), a) {}
+
+  // Creates an array initialized with the elements from the input
+  // range. The array's size will always be `std::distance(first, last)`.
+  // REQUIRES: Iterator must be a forward_iterator or better.
+  template <typename Iterator, EnableIfForwardIterator<Iterator>* = nullptr>
+  FixedArray(Iterator first, Iterator last,
+             const allocator_type& a = allocator_type())
+      : storage_(std::distance(first, last), a) {
+    memory_internal::CopyRange(storage_.alloc(), storage_.begin(), first, last);
+  }
+
+  ~FixedArray() noexcept {
+    for (auto* cur = storage_.begin(); cur != storage_.end(); ++cur) {
+      AllocatorTraits::destroy(storage_.alloc(), cur);
+    }
+  }
+
+  // Assignments are deleted because they break the invariant that the size of a
+  // `FixedArray` never changes.
+  void operator=(FixedArray&&) = delete;
+  void operator=(const FixedArray&) = delete;
+
+  // FixedArray::size()
+  //
+  // Returns the length of the fixed array.
+  size_type size() const { return storage_.size(); }
+
+  // FixedArray::max_size()
+  //
+  // Returns the largest possible value of `std::distance(begin(), end())` for a
+  // `FixedArray<T>`. This is equivalent to the most possible addressable bytes
+  // over the number of bytes taken by T.
+  constexpr size_type max_size() const {
+    return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
+  }
+
+  // FixedArray::empty()
+  //
+  // Returns whether or not the fixed array is empty.
+  bool empty() const { return size() == 0; }
+
+  // FixedArray::memsize()
+  //
+  // Returns the memory size of the fixed array in bytes.
+  size_t memsize() const { return size() * sizeof(value_type); }
+
+  // FixedArray::data()
+  //
+  // Returns a const T* pointer to elements of the `FixedArray`. This pointer
+  // can be used to access (but not modify) the contained elements.
+  const_pointer data() const { return AsValueType(storage_.begin()); }
+
+  // Overload of FixedArray::data() to return a T* pointer to elements of the
+  // fixed array. This pointer can be used to access and modify the contained
+  // elements.
+  pointer data() { return AsValueType(storage_.begin()); }
+
+  // FixedArray::operator[]
+  //
+  // Returns a reference the ith element of the fixed array.
+  // REQUIRES: 0 <= i < size()
+  reference operator[](size_type i) {
+    ABSL_HARDENING_ASSERT(i < size());
+    return data()[i];
+  }
+
+  // Overload of FixedArray::operator()[] to return a const reference to the
+  // ith element of the fixed array.
+  // REQUIRES: 0 <= i < size()
+  const_reference operator[](size_type i) const {
+    ABSL_HARDENING_ASSERT(i < size());
+    return data()[i];
+  }
+
+  // FixedArray::at
+  //
+  // Bounds-checked access.  Returns a reference to the ith element of the fixed
+  // array, or throws std::out_of_range
+  reference at(size_type i) {
+    if (ABSL_PREDICT_FALSE(i >= size())) {
+      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
+    }
+    return data()[i];
+  }
+
+  // Overload of FixedArray::at() to return a const reference to the ith element
+  // of the fixed array.
+  const_reference at(size_type i) const {
+    if (ABSL_PREDICT_FALSE(i >= size())) {
+      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
+    }
+    return data()[i];
+  }
+
+  // FixedArray::front()
+  //
+  // Returns a reference to the first element of the fixed array.
+  reference front() {
+    ABSL_HARDENING_ASSERT(!empty());
+    return data()[0];
+  }
+
+  // Overload of FixedArray::front() to return a reference to the first element
+  // of a fixed array of const values.
+  const_reference front() const {
+    ABSL_HARDENING_ASSERT(!empty());
+    return data()[0];
+  }
+
+  // FixedArray::back()
+  //
+  // Returns a reference to the last element of the fixed array.
+  reference back() {
+    ABSL_HARDENING_ASSERT(!empty());
+    return data()[size() - 1];
+  }
+
+  // Overload of FixedArray::back() to return a reference to the last element
+  // of a fixed array of const values.
+  const_reference back() const {
+    ABSL_HARDENING_ASSERT(!empty());
+    return data()[size() - 1];
+  }
+
+  // FixedArray::begin()
+  //
+  // Returns an iterator to the beginning of the fixed array.
+  iterator begin() { return data(); }
+
+  // Overload of FixedArray::begin() to return a const iterator to the
+  // beginning of the fixed array.
+  const_iterator begin() const { return data(); }
+
+  // FixedArray::cbegin()
+  //
+  // Returns a const iterator to the beginning of the fixed array.
+  const_iterator cbegin() const { return begin(); }
+
+  // FixedArray::end()
+  //
+  // Returns an iterator to the end of the fixed array.
+  iterator end() { return data() + size(); }
+
+  // Overload of FixedArray::end() to return a const iterator to the end of the
+  // fixed array.
+  const_iterator end() const { return data() + size(); }
+
+  // FixedArray::cend()
+  //
+  // Returns a const iterator to the end of the fixed array.
+  const_iterator cend() const { return end(); }
+
+  // FixedArray::rbegin()
+  //
+  // Returns a reverse iterator from the end of the fixed array.
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+
+  // Overload of FixedArray::rbegin() to return a const reverse iterator from
+  // the end of the fixed array.
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+
+  // FixedArray::crbegin()
+  //
+  // Returns a const reverse iterator from the end of the fixed array.
+  const_reverse_iterator crbegin() const { return rbegin(); }
+
+  // FixedArray::rend()
+  //
+  // Returns a reverse iterator from the beginning of the fixed array.
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+
+  // Overload of FixedArray::rend() for returning a const reverse iterator
+  // from the beginning of the fixed array.
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  // FixedArray::crend()
+  //
+  // Returns a reverse iterator from the beginning of the fixed array.
+  const_reverse_iterator crend() const { return rend(); }
+
+  // FixedArray::fill()
+  //
+  // Assigns the given `value` to all elements in the fixed array.
+  void fill(const value_type& val) { std::fill(begin(), end(), val); }
+
+  // Relational operators. Equality operators are elementwise using
+  // `operator==`, while order operators order FixedArrays lexicographically.
+  friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) {
+    return absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+  }
+
+  friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) {
+    return !(lhs == rhs);
+  }
+
+  friend bool operator<(const FixedArray& lhs, const FixedArray& rhs) {
+    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(),
+                                        rhs.end());
+  }
+
+  friend bool operator>(const FixedArray& lhs, const FixedArray& rhs) {
+    return rhs < lhs;
+  }
+
+  friend bool operator<=(const FixedArray& lhs, const FixedArray& rhs) {
+    return !(rhs < lhs);
+  }
+
+  friend bool operator>=(const FixedArray& lhs, const FixedArray& rhs) {
+    return !(lhs < rhs);
+  }
+
+  template <typename H>
+  friend H AbslHashValue(H h, const FixedArray& v) {
+    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
+                      v.size());
+  }
+
+ private:
+  // StorageElement
+  //
+  // For FixedArrays with a C-style-array value_type, StorageElement is a POD
+  // wrapper struct called StorageElementWrapper that holds the value_type
+  // instance inside. This is needed for construction and destruction of the
+  // entire array regardless of how many dimensions it has. For all other cases,
+  // StorageElement is just an alias of value_type.
+  //
+  // Maintainer's Note: The simpler solution would be to simply wrap value_type
+  // in a struct whether it's an array or not. That causes some paranoid
+  // diagnostics to misfire, believing that 'data()' returns a pointer to a
+  // single element, rather than the packed array that it really is.
+  // e.g.:
+  //
+  //     FixedArray<char> buf(1);
+  //     sprintf(buf.data(), "foo");
+  //
+  //     error: call to int __builtin___sprintf_chk(etc...)
+  //     will always overflow destination buffer [-Werror]
+  //
+  template <typename OuterT, typename InnerT = absl::remove_extent_t<OuterT>,
+            size_t InnerN = std::extent<OuterT>::value>
+  struct StorageElementWrapper {
+    InnerT array[InnerN];
+  };
+
+  using StorageElement =
+      absl::conditional_t<std::is_array<value_type>::value,
+                          StorageElementWrapper<value_type>, value_type>;
+
+  static pointer AsValueType(pointer ptr) { return ptr; }
+  static pointer AsValueType(StorageElementWrapper<value_type>* ptr) {
+    return std::addressof(ptr->array);
+  }
+
+  static_assert(sizeof(StorageElement) == sizeof(value_type), "");
+  static_assert(alignof(StorageElement) == alignof(value_type), "");
+
+  class NonEmptyInlinedStorage {
+   public:
+    StorageElement* data() { return reinterpret_cast<StorageElement*>(buff_); }
+    void AnnotateConstruct(size_type n);
+    void AnnotateDestruct(size_type n);
+
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+    void* RedzoneBegin() { return &redzone_begin_; }
+    void* RedzoneEnd() { return &redzone_end_ + 1; }
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+
+   private:
+    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
+    alignas(StorageElement) char buff_[sizeof(StorageElement[inline_elements])];
+    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_);
+  };
+
+  class EmptyInlinedStorage {
+   public:
+    StorageElement* data() { return nullptr; }
+    void AnnotateConstruct(size_type) {}
+    void AnnotateDestruct(size_type) {}
+  };
+
+  using InlinedStorage =
+      absl::conditional_t<inline_elements == 0, EmptyInlinedStorage,
+                          NonEmptyInlinedStorage>;
+
+  // Storage
+  //
+  // An instance of Storage manages the inline and out-of-line memory for
+  // instances of FixedArray. This guarantees that even when construction of
+  // individual elements fails in the FixedArray constructor body, the
+  // destructor for Storage will still be called and out-of-line memory will be
+  // properly deallocated.
+  //
+  class Storage : public InlinedStorage {
+   public:
+    Storage(size_type n, const allocator_type& a)
+        : size_alloc_(n, a), data_(InitializeData()) {}
+
+    ~Storage() noexcept {
+      if (UsingInlinedStorage(size())) {
+        InlinedStorage::AnnotateDestruct(size());
+      } else {
+        AllocatorTraits::deallocate(alloc(), AsValueType(begin()), size());
+      }
+    }
+
+    size_type size() const { return size_alloc_.template get<0>(); }
+    StorageElement* begin() const { return data_; }
+    StorageElement* end() const { return begin() + size(); }
+    allocator_type& alloc() { return size_alloc_.template get<1>(); }
+
+   private:
+    static bool UsingInlinedStorage(size_type n) {
+      return n <= inline_elements;
+    }
+
+    StorageElement* InitializeData() {
+      if (UsingInlinedStorage(size())) {
+        InlinedStorage::AnnotateConstruct(size());
+        return InlinedStorage::data();
+      } else {
+        return reinterpret_cast<StorageElement*>(
+            AllocatorTraits::allocate(alloc(), size()));
+      }
+    }
+
+    // `CompressedTuple` takes advantage of EBCO for stateless `allocator_type`s
+    container_internal::CompressedTuple<size_type, allocator_type> size_alloc_;
+    StorageElement* data_;
+  };
+
+  Storage storage_;
+};
+
+#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+template <typename T, size_t N, typename A>
+constexpr size_t FixedArray<T, N, A>::kInlineBytesDefault;
+
+template <typename T, size_t N, typename A>
+constexpr typename FixedArray<T, N, A>::size_type
+    FixedArray<T, N, A>::inline_elements;
+#endif
+
+template <typename T, size_t N, typename A>
+void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct(
+    typename FixedArray<T, N, A>::size_type n) {
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+  if (!n) return;
+  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(),
+                                     data() + n);
+  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(),
+                                     RedzoneBegin());
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+  static_cast<void>(n);  // Mark used when not in asan mode
+}
+
+template <typename T, size_t N, typename A>
+void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct(
+    typename FixedArray<T, N, A>::size_type n) {
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+  if (!n) return;
+  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n,
+                                     RedzoneEnd());
+  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(),
+                                     data());
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+  static_cast<void>(n);  // Mark used when not in asan mode
+}
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_FIXED_ARRAY_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/flat_hash_map.h b/CAPI/cpp/grpc/include/absl/container/flat_hash_map.h
new file mode 100644
index 0000000..e6bdbd9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/flat_hash_map.h
@@ -0,0 +1,613 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: flat_hash_map.h
+// -----------------------------------------------------------------------------
+//
+// An `absl::flat_hash_map<K, V>` is an unordered associative container of
+// unique keys and associated values designed to be a more efficient replacement
+// for `std::unordered_map`. Like `unordered_map`, search, insertion, and
+// deletion of map elements can be done as an `O(1)` operation. However,
+// `flat_hash_map` (and other unordered associative containers known as the
+// collection of Abseil "Swiss tables") contain other optimizations that result
+// in both memory and computation advantages.
+//
+// In most cases, your default choice for a hash map should be a map of type
+// `flat_hash_map`.
+
+#ifndef ABSL_CONTAINER_FLAT_HASH_MAP_H_
+#define ABSL_CONTAINER_FLAT_HASH_MAP_H_
+
+#include <cstddef>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/algorithm/container.h"
+#include "absl/base/macros.h"
+#include "absl/container/internal/container_memory.h"
+#include "absl/container/internal/hash_function_defaults.h"  // IWYU pragma: export
+#include "absl/container/internal/raw_hash_map.h"  // IWYU pragma: export
+#include "absl/memory/memory.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+template <class K, class V>
+struct FlatHashMapPolicy;
+}  // namespace container_internal
+
+// -----------------------------------------------------------------------------
+// absl::flat_hash_map
+// -----------------------------------------------------------------------------
+//
+// An `absl::flat_hash_map<K, V>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_map<K, V>` with
+// the following notable differences:
+//
+// * Requires keys that are CopyConstructible
+// * Requires values that are MoveConstructible
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the map is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Invalidates any references and pointers to elements within the table after
+//   `rehash()`.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash map.
+// * Returns `void` from the `erase(iterator)` overload.
+//
+// By default, `flat_hash_map` uses the `absl::Hash` hashing framework.
+// All fundamental and Abseil types that support the `absl::Hash` framework have
+// a compatible equality operator for comparing insertions into `flat_hash_map`.
+// If your type is not yet supported by the `absl::Hash` framework, see
+// absl/hash/hash.h for information on extending Abseil hashing to user-defined
+// types.
+//
+// Using `absl::flat_hash_map` at interface boundaries in dynamically loaded
+// libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
+// be randomized across dynamically loaded libraries.
+//
+// NOTE: A `flat_hash_map` stores its value types directly inside its
+// implementation array to avoid memory indirection. Because a `flat_hash_map`
+// is designed to move data when rehashed, map values will not retain pointer
+// stability. If you require pointer stability, or if your values are large,
+// consider using `absl::flat_hash_map<Key, std::unique_ptr<Value>>` instead.
+// If your types are not moveable or you require pointer stability for keys,
+// consider `absl::node_hash_map`.
+//
+// Example:
+//
+//   // Create a flat hash map of three strings (that map to strings)
+//   absl::flat_hash_map<std::string, std::string> ducks =
+//     {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}};
+//
+//  // Insert a new element into the flat hash map
+//  ducks.insert({"d", "donald"});
+//
+//  // Force a rehash of the flat hash map
+//  ducks.rehash(0);
+//
+//  // Find the element with the key "b"
+//  std::string search_key = "b";
+//  auto result = ducks.find(search_key);
+//  if (result != ducks.end()) {
+//    std::cout << "Result: " << result->second << std::endl;
+//  }
+template <class K, class V,
+          class Hash = absl::container_internal::hash_default_hash<K>,
+          class Eq = absl::container_internal::hash_default_eq<K>,
+          class Allocator = std::allocator<std::pair<const K, V>>>
+class flat_hash_map : public absl::container_internal::raw_hash_map<
+                          absl::container_internal::FlatHashMapPolicy<K, V>,
+                          Hash, Eq, Allocator> {
+  using Base = typename flat_hash_map::raw_hash_map;
+
+ public:
+  // Constructors and Assignment Operators
+  //
+  // A flat_hash_map supports the same overload set as `std::unordered_map`
+  // for construction and assignment:
+  //
+  // *  Default constructor
+  //
+  //    // No allocation for the table's elements is made.
+  //    absl::flat_hash_map<int, std::string> map1;
+  //
+  // * Initializer List constructor
+  //
+  //   absl::flat_hash_map<int, std::string> map2 =
+  //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
+  //
+  // * Copy constructor
+  //
+  //   absl::flat_hash_map<int, std::string> map3(map2);
+  //
+  // * Copy assignment operator
+  //
+  //  // Hash functor and Comparator are copied as well
+  //  absl::flat_hash_map<int, std::string> map4;
+  //  map4 = map3;
+  //
+  // * Move constructor
+  //
+  //   // Move is guaranteed efficient
+  //   absl::flat_hash_map<int, std::string> map5(std::move(map4));
+  //
+  // * Move assignment operator
+  //
+  //   // May be efficient if allocators are compatible
+  //   absl::flat_hash_map<int, std::string> map6;
+  //   map6 = std::move(map5);
+  //
+  // * Range constructor
+  //
+  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+  //   absl::flat_hash_map<int, std::string> map7(v.begin(), v.end());
+  flat_hash_map() {}
+  using Base::Base;
+
+  // flat_hash_map::begin()
+  //
+  // Returns an iterator to the beginning of the `flat_hash_map`.
+  using Base::begin;
+
+  // flat_hash_map::cbegin()
+  //
+  // Returns a const iterator to the beginning of the `flat_hash_map`.
+  using Base::cbegin;
+
+  // flat_hash_map::cend()
+  //
+  // Returns a const iterator to the end of the `flat_hash_map`.
+  using Base::cend;
+
+  // flat_hash_map::end()
+  //
+  // Returns an iterator to the end of the `flat_hash_map`.
+  using Base::end;
+
+  // flat_hash_map::capacity()
+  //
+  // Returns the number of element slots (assigned, deleted, and empty)
+  // available within the `flat_hash_map`.
+  //
+  // NOTE: this member function is particular to `absl::flat_hash_map` and is
+  // not provided in the `std::unordered_map` API.
+  using Base::capacity;
+
+  // flat_hash_map::empty()
+  //
+  // Returns whether or not the `flat_hash_map` is empty.
+  using Base::empty;
+
+  // flat_hash_map::max_size()
+  //
+  // Returns the largest theoretical possible number of elements within a
+  // `flat_hash_map` under current memory constraints. This value can be thought
+  // of the largest value of `std::distance(begin(), end())` for a
+  // `flat_hash_map<K, V>`.
+  using Base::max_size;
+
+  // flat_hash_map::size()
+  //
+  // Returns the number of elements currently within the `flat_hash_map`.
+  using Base::size;
+
+  // flat_hash_map::clear()
+  //
+  // Removes all elements from the `flat_hash_map`. Invalidates any references,
+  // pointers, or iterators referring to contained elements.
+  //
+  // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
+  // the underlying buffer call `erase(begin(), end())`.
+  using Base::clear;
+
+  // flat_hash_map::erase()
+  //
+  // Erases elements within the `flat_hash_map`. Erasing does not trigger a
+  // rehash. Overloads are listed below.
+  //
+  // void erase(const_iterator pos):
+  //
+  //   Erases the element at `position` of the `flat_hash_map`, returning
+  //   `void`.
+  //
+  //   NOTE: returning `void` in this case is different than that of STL
+  //   containers in general and `std::unordered_map` in particular (which
+  //   return an iterator to the element following the erased element). If that
+  //   iterator is needed, simply post increment the iterator:
+  //
+  //     map.erase(it++);
+  //
+  // iterator erase(const_iterator first, const_iterator last):
+  //
+  //   Erases the elements in the open interval [`first`, `last`), returning an
+  //   iterator pointing to `last`.
+  //
+  // size_type erase(const key_type& key):
+  //
+  //   Erases the element with the matching key, if it exists, returning the
+  //   number of elements erased (0 or 1).
+  using Base::erase;
+
+  // flat_hash_map::insert()
+  //
+  // Inserts an element of the specified value into the `flat_hash_map`,
+  // returning an iterator pointing to the newly inserted element, provided that
+  // an element with the given key does not already exist. If rehashing occurs
+  // due to the insertion, all iterators are invalidated. Overloads are listed
+  // below.
+  //
+  // std::pair<iterator,bool> insert(const init_type& value):
+  //
+  //   Inserts a value into the `flat_hash_map`. Returns a pair consisting of an
+  //   iterator to the inserted element (or to the element that prevented the
+  //   insertion) and a bool denoting whether the insertion took place.
+  //
+  // std::pair<iterator,bool> insert(T&& value):
+  // std::pair<iterator,bool> insert(init_type&& value):
+  //
+  //   Inserts a moveable value into the `flat_hash_map`. Returns a pair
+  //   consisting of an iterator to the inserted element (or to the element that
+  //   prevented the insertion) and a bool denoting whether the insertion took
+  //   place.
+  //
+  // iterator insert(const_iterator hint, const init_type& value):
+  // iterator insert(const_iterator hint, T&& value):
+  // iterator insert(const_iterator hint, init_type&& value);
+  //
+  //   Inserts a value, using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search. Returns an iterator to the
+  //   inserted element, or to the existing element that prevented the
+  //   insertion.
+  //
+  // void insert(InputIterator first, InputIterator last):
+  //
+  //   Inserts a range of values [`first`, `last`).
+  //
+  //   NOTE: Although the STL does not specify which element may be inserted if
+  //   multiple keys compare equivalently, for `flat_hash_map` we guarantee the
+  //   first match is inserted.
+  //
+  // void insert(std::initializer_list<init_type> ilist):
+  //
+  //   Inserts the elements within the initializer list `ilist`.
+  //
+  //   NOTE: Although the STL does not specify which element may be inserted if
+  //   multiple keys compare equivalently within the initializer list, for
+  //   `flat_hash_map` we guarantee the first match is inserted.
+  using Base::insert;
+
+  // flat_hash_map::insert_or_assign()
+  //
+  // Inserts an element of the specified value into the `flat_hash_map` provided
+  // that a value with the given key does not already exist, or replaces it with
+  // the element value if a key for that value already exists, returning an
+  // iterator pointing to the newly inserted element.  If rehashing occurs due
+  // to the insertion, all existing iterators are invalidated. Overloads are
+  // listed below.
+  //
+  // pair<iterator, bool> insert_or_assign(const init_type& k, T&& obj):
+  // pair<iterator, bool> insert_or_assign(init_type&& k, T&& obj):
+  //
+  //   Inserts/Assigns (or moves) the element of the specified key into the
+  //   `flat_hash_map`.
+  //
+  // iterator insert_or_assign(const_iterator hint,
+  //                           const init_type& k, T&& obj):
+  // iterator insert_or_assign(const_iterator hint, init_type&& k, T&& obj):
+  //
+  //   Inserts/Assigns (or moves) the element of the specified key into the
+  //   `flat_hash_map` using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search.
+  using Base::insert_or_assign;
+
+  // flat_hash_map::emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `flat_hash_map`, provided that no element with the given key
+  // already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately. Prefer `try_emplace()` unless your key is not
+  // copyable or moveable.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  using Base::emplace;
+
+  // flat_hash_map::emplace_hint()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `flat_hash_map`, using the position of `hint` as a non-binding
+  // suggestion for where to begin the insertion search, and only inserts
+  // provided that no element with the given key already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately. Prefer `try_emplace()` unless your key is not
+  // copyable or moveable.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  using Base::emplace_hint;
+
+  // flat_hash_map::try_emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `flat_hash_map`, provided that no element with the given key
+  // already exists. Unlike `emplace()`, if an element with the given key
+  // already exists, we guarantee that no element is constructed.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  // Overloads are listed below.
+  //
+  //   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
+  //   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
+  //
+  // Inserts (via copy or move) the element of the specified key into the
+  // `flat_hash_map`.
+  //
+  //   iterator try_emplace(const_iterator hint,
+  //                        const key_type& k, Args&&... args):
+  //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
+  //
+  // Inserts (via copy or move) the element of the specified key into the
+  // `flat_hash_map` using the position of `hint` as a non-binding suggestion
+  // for where to begin the insertion search.
+  //
+  // All `try_emplace()` overloads make the same guarantees regarding rvalue
+  // arguments as `std::unordered_map::try_emplace()`, namely that these
+  // functions will not move from rvalue arguments if insertions do not happen.
+  using Base::try_emplace;
+
+  // flat_hash_map::extract()
+  //
+  // Extracts the indicated element, erasing it in the process, and returns it
+  // as a C++17-compatible node handle. Overloads are listed below.
+  //
+  // node_type extract(const_iterator position):
+  //
+  //   Extracts the key,value pair of the element at the indicated position and
+  //   returns a node handle owning that extracted data.
+  //
+  // node_type extract(const key_type& x):
+  //
+  //   Extracts the key,value pair of the element with a key matching the passed
+  //   key value and returns a node handle owning that extracted data. If the
+  //   `flat_hash_map` does not contain an element with a matching key, this
+  //   function returns an empty node handle.
+  //
+  // NOTE: when compiled in an earlier version of C++ than C++17,
+  // `node_type::key()` returns a const reference to the key instead of a
+  // mutable reference. We cannot safely return a mutable reference without
+  // std::launder (which is not available before C++17).
+  using Base::extract;
+
+  // flat_hash_map::merge()
+  //
+  // Extracts elements from a given `source` flat hash map into this
+  // `flat_hash_map`. If the destination `flat_hash_map` already contains an
+  // element with an equivalent key, that element is not extracted.
+  using Base::merge;
+
+  // flat_hash_map::swap(flat_hash_map& other)
+  //
+  // Exchanges the contents of this `flat_hash_map` with those of the `other`
+  // flat hash map, avoiding invocation of any move, copy, or swap operations on
+  // individual elements.
+  //
+  // All iterators and references on the `flat_hash_map` remain valid, excepting
+  // for the past-the-end iterator, which is invalidated.
+  //
+  // `swap()` requires that the flat hash map's hashing and key equivalence
+  // functions be Swappable, and are exchanged using unqualified calls to
+  // non-member `swap()`. If the map's allocator has
+  // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
+  // set to `true`, the allocators are also exchanged using an unqualified call
+  // to non-member `swap()`; otherwise, the allocators are not swapped.
+  using Base::swap;
+
+  // flat_hash_map::rehash(count)
+  //
+  // Rehashes the `flat_hash_map`, setting the number of slots to be at least
+  // the passed value. If the new number of slots increases the load factor more
+  // than the current maximum load factor
+  // (`count` < `size()` / `max_load_factor()`), then the new number of slots
+  // will be at least `size()` / `max_load_factor()`.
+  //
+  // To force a rehash, pass rehash(0).
+  //
+  // NOTE: unlike behavior in `std::unordered_map`, references are also
+  // invalidated upon a `rehash()`.
+  using Base::rehash;
+
+  // flat_hash_map::reserve(count)
+  //
+  // Sets the number of slots in the `flat_hash_map` to the number needed to
+  // accommodate at least `count` total elements without exceeding the current
+  // maximum load factor, and may rehash the container if needed.
+  using Base::reserve;
+
+  // flat_hash_map::at()
+  //
+  // Returns a reference to the mapped value of the element with key equivalent
+  // to the passed key.
+  using Base::at;
+
+  // flat_hash_map::contains()
+  //
+  // Determines whether an element with a key comparing equal to the given `key`
+  // exists within the `flat_hash_map`, returning `true` if so or `false`
+  // otherwise.
+  using Base::contains;
+
+  // flat_hash_map::count(const Key& key) const
+  //
+  // Returns the number of elements with a key comparing equal to the given
+  // `key` within the `flat_hash_map`. note that this function will return
+  // either `1` or `0` since duplicate keys are not allowed within a
+  // `flat_hash_map`.
+  using Base::count;
+
+  // flat_hash_map::equal_range()
+  //
+  // Returns a closed range [first, last], defined by a `std::pair` of two
+  // iterators, containing all elements with the passed key in the
+  // `flat_hash_map`.
+  using Base::equal_range;
+
+  // flat_hash_map::find()
+  //
+  // Finds an element with the passed `key` within the `flat_hash_map`.
+  using Base::find;
+
+  // flat_hash_map::operator[]()
+  //
+  // Returns a reference to the value mapped to the passed key within the
+  // `flat_hash_map`, performing an `insert()` if the key does not already
+  // exist.
+  //
+  // If an insertion occurs and results in a rehashing of the container, all
+  // iterators are invalidated. Otherwise iterators are not affected and
+  // references are not invalidated. Overloads are listed below.
+  //
+  // T& operator[](const Key& key):
+  //
+  //   Inserts an init_type object constructed in-place if the element with the
+  //   given key does not exist.
+  //
+  // T& operator[](Key&& key):
+  //
+  //   Inserts an init_type object constructed in-place provided that an element
+  //   with the given key does not exist.
+  using Base::operator[];
+
+  // flat_hash_map::bucket_count()
+  //
+  // Returns the number of "buckets" within the `flat_hash_map`. Note that
+  // because a flat hash map contains all elements within its internal storage,
+  // this value simply equals the current capacity of the `flat_hash_map`.
+  using Base::bucket_count;
+
+  // flat_hash_map::load_factor()
+  //
+  // Returns the current load factor of the `flat_hash_map` (the average number
+  // of slots occupied with a value within the hash map).
+  using Base::load_factor;
+
+  // flat_hash_map::max_load_factor()
+  //
+  // Manages the maximum load factor of the `flat_hash_map`. Overloads are
+  // listed below.
+  //
+  // float flat_hash_map::max_load_factor()
+  //
+  //   Returns the current maximum load factor of the `flat_hash_map`.
+  //
+  // void flat_hash_map::max_load_factor(float ml)
+  //
+  //   Sets the maximum load factor of the `flat_hash_map` to the passed value.
+  //
+  //   NOTE: This overload is provided only for API compatibility with the STL;
+  //   `flat_hash_map` will ignore any set load factor and manage its rehashing
+  //   internally as an implementation detail.
+  using Base::max_load_factor;
+
+  // flat_hash_map::get_allocator()
+  //
+  // Returns the allocator function associated with this `flat_hash_map`.
+  using Base::get_allocator;
+
+  // flat_hash_map::hash_function()
+  //
+  // Returns the hashing function used to hash the keys within this
+  // `flat_hash_map`.
+  using Base::hash_function;
+
+  // flat_hash_map::key_eq()
+  //
+  // Returns the function used for comparing keys equality.
+  using Base::key_eq;
+};
+
+// erase_if(flat_hash_map<>, Pred)
+//
+// Erases all elements that satisfy the predicate `pred` from the container `c`.
+// Returns the number of erased elements.
+template <typename K, typename V, typename H, typename E, typename A,
+          typename Predicate>
+typename flat_hash_map<K, V, H, E, A>::size_type erase_if(
+    flat_hash_map<K, V, H, E, A>& c, Predicate pred) {
+  return container_internal::EraseIf(pred, &c);
+}
+
+namespace container_internal {
+
+template <class K, class V>
+struct FlatHashMapPolicy {
+  using slot_policy = container_internal::map_slot_policy<K, V>;
+  using slot_type = typename slot_policy::slot_type;
+  using key_type = K;
+  using mapped_type = V;
+  using init_type = std::pair</*non const*/ key_type, mapped_type>;
+
+  template <class Allocator, class... Args>
+  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
+  }
+
+  template <class Allocator>
+  static void destroy(Allocator* alloc, slot_type* slot) {
+    slot_policy::destroy(alloc, slot);
+  }
+
+  template <class Allocator>
+  static void transfer(Allocator* alloc, slot_type* new_slot,
+                       slot_type* old_slot) {
+    slot_policy::transfer(alloc, new_slot, old_slot);
+  }
+
+  template <class F, class... Args>
+  static decltype(absl::container_internal::DecomposePair(
+      std::declval<F>(), std::declval<Args>()...))
+  apply(F&& f, Args&&... args) {
+    return absl::container_internal::DecomposePair(std::forward<F>(f),
+                                                   std::forward<Args>(args)...);
+  }
+
+  static size_t space_used(const slot_type*) { return 0; }
+
+  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
+
+  static V& value(std::pair<const K, V>* kv) { return kv->second; }
+  static const V& value(const std::pair<const K, V>* kv) { return kv->second; }
+};
+
+}  // namespace container_internal
+
+namespace container_algorithm_internal {
+
+// Specialization of trait in absl/algorithm/container.h
+template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+struct IsUnorderedContainer<
+    absl::flat_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {};
+
+}  // namespace container_algorithm_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_FLAT_HASH_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/flat_hash_set.h b/CAPI/cpp/grpc/include/absl/container/flat_hash_set.h
new file mode 100644
index 0000000..4938c70
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/flat_hash_set.h
@@ -0,0 +1,510 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: flat_hash_set.h
+// -----------------------------------------------------------------------------
+//
+// An `absl::flat_hash_set<T>` is an unordered associative container designed to
+// be a more efficient replacement for `std::unordered_set`. Like
+// `unordered_set`, search, insertion, and deletion of set elements can be done
+// as an `O(1)` operation. However, `flat_hash_set` (and other unordered
+// associative containers known as the collection of Abseil "Swiss tables")
+// contain other optimizations that result in both memory and computation
+// advantages.
+//
+// In most cases, your default choice for a hash set should be a set of type
+// `flat_hash_set`.
+#ifndef ABSL_CONTAINER_FLAT_HASH_SET_H_
+#define ABSL_CONTAINER_FLAT_HASH_SET_H_
+
+#include <type_traits>
+#include <utility>
+
+#include "absl/algorithm/container.h"
+#include "absl/base/macros.h"
+#include "absl/container/internal/container_memory.h"
+#include "absl/container/internal/hash_function_defaults.h"  // IWYU pragma: export
+#include "absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
+#include "absl/memory/memory.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+template <typename T>
+struct FlatHashSetPolicy;
+}  // namespace container_internal
+
+// -----------------------------------------------------------------------------
+// absl::flat_hash_set
+// -----------------------------------------------------------------------------
+//
+// An `absl::flat_hash_set<T>` is an unordered associative container which has
+// been optimized for both speed and memory footprint in most common use cases.
+// Its interface is similar to that of `std::unordered_set<T>` with the
+// following notable differences:
+//
+// * Requires keys that are CopyConstructible
+// * Supports heterogeneous lookup, through `find()` and `insert()`, provided
+//   that the set is provided a compatible heterogeneous hashing function and
+//   equality operator.
+// * Invalidates any references and pointers to elements within the table after
+//   `rehash()`.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash set.
+// * Returns `void` from the `erase(iterator)` overload.
+//
+// By default, `flat_hash_set` uses the `absl::Hash` hashing framework. All
+// fundamental and Abseil types that support the `absl::Hash` framework have a
+// compatible equality operator for comparing insertions into `flat_hash_set`.
+// If your type is not yet supported by the `absl::Hash` framework, see
+// absl/hash/hash.h for information on extending Abseil hashing to user-defined
+// types.
+//
+// Using `absl::flat_hash_set` at interface boundaries in dynamically loaded
+// libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
+// be randomized across dynamically loaded libraries.
+//
+// NOTE: A `flat_hash_set` stores its keys directly inside its implementation
+// array to avoid memory indirection. Because a `flat_hash_set` is designed to
+// move data when rehashed, set keys will not retain pointer stability. If you
+// require pointer stability, consider using
+// `absl::flat_hash_set<std::unique_ptr<T>>`. If your type is not moveable and
+// you require pointer stability, consider `absl::node_hash_set` instead.
+//
+// Example:
+//
+//   // Create a flat hash set of three strings
+//   absl::flat_hash_set<std::string> ducks =
+//     {"huey", "dewey", "louie"};
+//
+//  // Insert a new element into the flat hash set
+//  ducks.insert("donald");
+//
+//  // Force a rehash of the flat hash set
+//  ducks.rehash(0);
+//
+//  // See if "dewey" is present
+//  if (ducks.contains("dewey")) {
+//    std::cout << "We found dewey!" << std::endl;
+//  }
+template <class T, class Hash = absl::container_internal::hash_default_hash<T>,
+          class Eq = absl::container_internal::hash_default_eq<T>,
+          class Allocator = std::allocator<T>>
+class flat_hash_set
+    : public absl::container_internal::raw_hash_set<
+          absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator> {
+  using Base = typename flat_hash_set::raw_hash_set;
+
+ public:
+  // Constructors and Assignment Operators
+  //
+  // A flat_hash_set supports the same overload set as `std::unordered_set`
+  // for construction and assignment:
+  //
+  // *  Default constructor
+  //
+  //    // No allocation for the table's elements is made.
+  //    absl::flat_hash_set<std::string> set1;
+  //
+  // * Initializer List constructor
+  //
+  //   absl::flat_hash_set<std::string> set2 =
+  //       {{"huey"}, {"dewey"}, {"louie"},};
+  //
+  // * Copy constructor
+  //
+  //   absl::flat_hash_set<std::string> set3(set2);
+  //
+  // * Copy assignment operator
+  //
+  //  // Hash functor and Comparator are copied as well
+  //  absl::flat_hash_set<std::string> set4;
+  //  set4 = set3;
+  //
+  // * Move constructor
+  //
+  //   // Move is guaranteed efficient
+  //   absl::flat_hash_set<std::string> set5(std::move(set4));
+  //
+  // * Move assignment operator
+  //
+  //   // May be efficient if allocators are compatible
+  //   absl::flat_hash_set<std::string> set6;
+  //   set6 = std::move(set5);
+  //
+  // * Range constructor
+  //
+  //   std::vector<std::string> v = {"a", "b"};
+  //   absl::flat_hash_set<std::string> set7(v.begin(), v.end());
+  flat_hash_set() {}
+  using Base::Base;
+
+  // flat_hash_set::begin()
+  //
+  // Returns an iterator to the beginning of the `flat_hash_set`.
+  using Base::begin;
+
+  // flat_hash_set::cbegin()
+  //
+  // Returns a const iterator to the beginning of the `flat_hash_set`.
+  using Base::cbegin;
+
+  // flat_hash_set::cend()
+  //
+  // Returns a const iterator to the end of the `flat_hash_set`.
+  using Base::cend;
+
+  // flat_hash_set::end()
+  //
+  // Returns an iterator to the end of the `flat_hash_set`.
+  using Base::end;
+
+  // flat_hash_set::capacity()
+  //
+  // Returns the number of element slots (assigned, deleted, and empty)
+  // available within the `flat_hash_set`.
+  //
+  // NOTE: this member function is particular to `absl::flat_hash_set` and is
+  // not provided in the `std::unordered_set` API.
+  using Base::capacity;
+
+  // flat_hash_set::empty()
+  //
+  // Returns whether or not the `flat_hash_set` is empty.
+  using Base::empty;
+
+  // flat_hash_set::max_size()
+  //
+  // Returns the largest theoretical possible number of elements within a
+  // `flat_hash_set` under current memory constraints. This value can be thought
+  // of the largest value of `std::distance(begin(), end())` for a
+  // `flat_hash_set<T>`.
+  using Base::max_size;
+
+  // flat_hash_set::size()
+  //
+  // Returns the number of elements currently within the `flat_hash_set`.
+  using Base::size;
+
+  // flat_hash_set::clear()
+  //
+  // Removes all elements from the `flat_hash_set`. Invalidates any references,
+  // pointers, or iterators referring to contained elements.
+  //
+  // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
+  // the underlying buffer call `erase(begin(), end())`.
+  using Base::clear;
+
+  // flat_hash_set::erase()
+  //
+  // Erases elements within the `flat_hash_set`. Erasing does not trigger a
+  // rehash. Overloads are listed below.
+  //
+  // void erase(const_iterator pos):
+  //
+  //   Erases the element at `position` of the `flat_hash_set`, returning
+  //   `void`.
+  //
+  //   NOTE: returning `void` in this case is different than that of STL
+  //   containers in general and `std::unordered_set` in particular (which
+  //   return an iterator to the element following the erased element). If that
+  //   iterator is needed, simply post increment the iterator:
+  //
+  //     set.erase(it++);
+  //
+  // iterator erase(const_iterator first, const_iterator last):
+  //
+  //   Erases the elements in the open interval [`first`, `last`), returning an
+  //   iterator pointing to `last`.
+  //
+  // size_type erase(const key_type& key):
+  //
+  //   Erases the element with the matching key, if it exists, returning the
+  //   number of elements erased (0 or 1).
+  using Base::erase;
+
+  // flat_hash_set::insert()
+  //
+  // Inserts an element of the specified value into the `flat_hash_set`,
+  // returning an iterator pointing to the newly inserted element, provided that
+  // an element with the given key does not already exist. If rehashing occurs
+  // due to the insertion, all iterators are invalidated. Overloads are listed
+  // below.
+  //
+  // std::pair<iterator,bool> insert(const T& value):
+  //
+  //   Inserts a value into the `flat_hash_set`. Returns a pair consisting of an
+  //   iterator to the inserted element (or to the element that prevented the
+  //   insertion) and a bool denoting whether the insertion took place.
+  //
+  // std::pair<iterator,bool> insert(T&& value):
+  //
+  //   Inserts a moveable value into the `flat_hash_set`. Returns a pair
+  //   consisting of an iterator to the inserted element (or to the element that
+  //   prevented the insertion) and a bool denoting whether the insertion took
+  //   place.
+  //
+  // iterator insert(const_iterator hint, const T& value):
+  // iterator insert(const_iterator hint, T&& value):
+  //
+  //   Inserts a value, using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search. Returns an iterator to the
+  //   inserted element, or to the existing element that prevented the
+  //   insertion.
+  //
+  // void insert(InputIterator first, InputIterator last):
+  //
+  //   Inserts a range of values [`first`, `last`).
+  //
+  //   NOTE: Although the STL does not specify which element may be inserted if
+  //   multiple keys compare equivalently, for `flat_hash_set` we guarantee the
+  //   first match is inserted.
+  //
+  // void insert(std::initializer_list<T> ilist):
+  //
+  //   Inserts the elements within the initializer list `ilist`.
+  //
+  //   NOTE: Although the STL does not specify which element may be inserted if
+  //   multiple keys compare equivalently within the initializer list, for
+  //   `flat_hash_set` we guarantee the first match is inserted.
+  using Base::insert;
+
+  // flat_hash_set::emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `flat_hash_set`, provided that no element with the given key
+  // already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  using Base::emplace;
+
+  // flat_hash_set::emplace_hint()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `flat_hash_set`, using the position of `hint` as a non-binding
+  // suggestion for where to begin the insertion search, and only inserts
+  // provided that no element with the given key already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  using Base::emplace_hint;
+
+  // flat_hash_set::extract()
+  //
+  // Extracts the indicated element, erasing it in the process, and returns it
+  // as a C++17-compatible node handle. Overloads are listed below.
+  //
+  // node_type extract(const_iterator position):
+  //
+  //   Extracts the element at the indicated position and returns a node handle
+  //   owning that extracted data.
+  //
+  // node_type extract(const key_type& x):
+  //
+  //   Extracts the element with the key matching the passed key value and
+  //   returns a node handle owning that extracted data. If the `flat_hash_set`
+  //   does not contain an element with a matching key, this function returns an
+  //   empty node handle.
+  using Base::extract;
+
+  // flat_hash_set::merge()
+  //
+  // Extracts elements from a given `source` flat hash set into this
+  // `flat_hash_set`. If the destination `flat_hash_set` already contains an
+  // element with an equivalent key, that element is not extracted.
+  using Base::merge;
+
+  // flat_hash_set::swap(flat_hash_set& other)
+  //
+  // Exchanges the contents of this `flat_hash_set` with those of the `other`
+  // flat hash set, avoiding invocation of any move, copy, or swap operations on
+  // individual elements.
+  //
+  // All iterators and references on the `flat_hash_set` remain valid, excepting
+  // for the past-the-end iterator, which is invalidated.
+  //
+  // `swap()` requires that the flat hash set's hashing and key equivalence
+  // functions be Swappable, and are exchaged using unqualified calls to
+  // non-member `swap()`. If the set's allocator has
+  // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
+  // set to `true`, the allocators are also exchanged using an unqualified call
+  // to non-member `swap()`; otherwise, the allocators are not swapped.
+  using Base::swap;
+
+  // flat_hash_set::rehash(count)
+  //
+  // Rehashes the `flat_hash_set`, setting the number of slots to be at least
+  // the passed value. If the new number of slots increases the load factor more
+  // than the current maximum load factor
+  // (`count` < `size()` / `max_load_factor()`), then the new number of slots
+  // will be at least `size()` / `max_load_factor()`.
+  //
+  // To force a rehash, pass rehash(0).
+  //
+  // NOTE: unlike behavior in `std::unordered_set`, references are also
+  // invalidated upon a `rehash()`.
+  using Base::rehash;
+
+  // flat_hash_set::reserve(count)
+  //
+  // Sets the number of slots in the `flat_hash_set` to the number needed to
+  // accommodate at least `count` total elements without exceeding the current
+  // maximum load factor, and may rehash the container if needed.
+  using Base::reserve;
+
+  // flat_hash_set::contains()
+  //
+  // Determines whether an element comparing equal to the given `key` exists
+  // within the `flat_hash_set`, returning `true` if so or `false` otherwise.
+  using Base::contains;
+
+  // flat_hash_set::count(const Key& key) const
+  //
+  // Returns the number of elements comparing equal to the given `key` within
+  // the `flat_hash_set`. note that this function will return either `1` or `0`
+  // since duplicate elements are not allowed within a `flat_hash_set`.
+  using Base::count;
+
+  // flat_hash_set::equal_range()
+  //
+  // Returns a closed range [first, last], defined by a `std::pair` of two
+  // iterators, containing all elements with the passed key in the
+  // `flat_hash_set`.
+  using Base::equal_range;
+
+  // flat_hash_set::find()
+  //
+  // Finds an element with the passed `key` within the `flat_hash_set`.
+  using Base::find;
+
+  // flat_hash_set::bucket_count()
+  //
+  // Returns the number of "buckets" within the `flat_hash_set`. Note that
+  // because a flat hash set contains all elements within its internal storage,
+  // this value simply equals the current capacity of the `flat_hash_set`.
+  using Base::bucket_count;
+
+  // flat_hash_set::load_factor()
+  //
+  // Returns the current load factor of the `flat_hash_set` (the average number
+  // of slots occupied with a value within the hash set).
+  using Base::load_factor;
+
+  // flat_hash_set::max_load_factor()
+  //
+  // Manages the maximum load factor of the `flat_hash_set`. Overloads are
+  // listed below.
+  //
+  // float flat_hash_set::max_load_factor()
+  //
+  //   Returns the current maximum load factor of the `flat_hash_set`.
+  //
+  // void flat_hash_set::max_load_factor(float ml)
+  //
+  //   Sets the maximum load factor of the `flat_hash_set` to the passed value.
+  //
+  //   NOTE: This overload is provided only for API compatibility with the STL;
+  //   `flat_hash_set` will ignore any set load factor and manage its rehashing
+  //   internally as an implementation detail.
+  using Base::max_load_factor;
+
+  // flat_hash_set::get_allocator()
+  //
+  // Returns the allocator function associated with this `flat_hash_set`.
+  using Base::get_allocator;
+
+  // flat_hash_set::hash_function()
+  //
+  // Returns the hashing function used to hash the keys within this
+  // `flat_hash_set`.
+  using Base::hash_function;
+
+  // flat_hash_set::key_eq()
+  //
+  // Returns the function used for comparing keys equality.
+  using Base::key_eq;
+};
+
+// erase_if(flat_hash_set<>, Pred)
+//
+// Erases all elements that satisfy the predicate `pred` from the container `c`.
+// Returns the number of erased elements.
+template <typename T, typename H, typename E, typename A, typename Predicate>
+typename flat_hash_set<T, H, E, A>::size_type erase_if(
+    flat_hash_set<T, H, E, A>& c, Predicate pred) {
+  return container_internal::EraseIf(pred, &c);
+}
+
+namespace container_internal {
+
+template <class T>
+struct FlatHashSetPolicy {
+  using slot_type = T;
+  using key_type = T;
+  using init_type = T;
+  using constant_iterators = std::true_type;
+
+  template <class Allocator, class... Args>
+  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+    absl::allocator_traits<Allocator>::construct(*alloc, slot,
+                                                 std::forward<Args>(args)...);
+  }
+
+  template <class Allocator>
+  static void destroy(Allocator* alloc, slot_type* slot) {
+    absl::allocator_traits<Allocator>::destroy(*alloc, slot);
+  }
+
+  template <class Allocator>
+  static void transfer(Allocator* alloc, slot_type* new_slot,
+                       slot_type* old_slot) {
+    construct(alloc, new_slot, std::move(*old_slot));
+    destroy(alloc, old_slot);
+  }
+
+  static T& element(slot_type* slot) { return *slot; }
+
+  template <class F, class... Args>
+  static decltype(absl::container_internal::DecomposeValue(
+      std::declval<F>(), std::declval<Args>()...))
+  apply(F&& f, Args&&... args) {
+    return absl::container_internal::DecomposeValue(
+        std::forward<F>(f), std::forward<Args>(args)...);
+  }
+
+  static size_t space_used(const T*) { return 0; }
+};
+}  // namespace container_internal
+
+namespace container_algorithm_internal {
+
+// Specialization of trait in absl/algorithm/container.h
+template <class Key, class Hash, class KeyEqual, class Allocator>
+struct IsUnorderedContainer<absl::flat_hash_set<Key, Hash, KeyEqual, Allocator>>
+    : std::true_type {};
+
+}  // namespace container_algorithm_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_FLAT_HASH_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/inlined_vector.h b/CAPI/cpp/grpc/include/absl/container/inlined_vector.h
new file mode 100644
index 0000000..bc1c4a7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/inlined_vector.h
@@ -0,0 +1,866 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: inlined_vector.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains the declaration and definition of an "inlined
+// vector" which behaves in an equivalent fashion to a `std::vector`, except
+// that storage for small sequences of the vector are provided inline without
+// requiring any heap allocation.
+//
+// An `absl::InlinedVector<T, N>` specifies the default capacity `N` as one of
+// its template parameters. Instances where `size() <= N` hold contained
+// elements in inline space. Typically `N` is very small so that sequences that
+// are expected to be short do not require allocations.
+//
+// An `absl::InlinedVector` does not usually require a specific allocator. If
+// the inlined vector grows beyond its initial constraints, it will need to
+// allocate (as any normal `std::vector` would). This is usually performed with
+// the default allocator (defined as `std::allocator<T>`). Optionally, a custom
+// allocator type may be specified as `A` in `absl::InlinedVector<T, N, A>`.
+
+#ifndef ABSL_CONTAINER_INLINED_VECTOR_H_
+#define ABSL_CONTAINER_INLINED_VECTOR_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <initializer_list>
+#include <iterator>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "absl/algorithm/algorithm.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+#include "absl/container/internal/inlined_vector.h"
+#include "absl/memory/memory.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+// -----------------------------------------------------------------------------
+// InlinedVector
+// -----------------------------------------------------------------------------
+//
+// An `absl::InlinedVector` is designed to be a drop-in replacement for
+// `std::vector` for use cases where the vector's size is sufficiently small
+// that it can be inlined. If the inlined vector does grow beyond its estimated
+// capacity, it will trigger an initial allocation on the heap, and will behave
+// as a `std::vector`. The API of the `absl::InlinedVector` within this file is
+// designed to cover the same API footprint as covered by `std::vector`.
+template <typename T, size_t N, typename A = std::allocator<T>>
+class InlinedVector {
+  static_assert(N > 0, "`absl::InlinedVector` requires an inlined capacity.");
+
+  using Storage = inlined_vector_internal::Storage<T, N, A>;
+
+  template <typename TheA>
+  using AllocatorTraits = inlined_vector_internal::AllocatorTraits<TheA>;
+  template <typename TheA>
+  using MoveIterator = inlined_vector_internal::MoveIterator<TheA>;
+  template <typename TheA>
+  using IsMemcpyOk = inlined_vector_internal::IsMemcpyOk<TheA>;
+
+  template <typename TheA, typename Iterator>
+  using IteratorValueAdapter =
+      inlined_vector_internal::IteratorValueAdapter<TheA, Iterator>;
+  template <typename TheA>
+  using CopyValueAdapter = inlined_vector_internal::CopyValueAdapter<TheA>;
+  template <typename TheA>
+  using DefaultValueAdapter =
+      inlined_vector_internal::DefaultValueAdapter<TheA>;
+
+  template <typename Iterator>
+  using EnableIfAtLeastForwardIterator = absl::enable_if_t<
+      inlined_vector_internal::IsAtLeastForwardIterator<Iterator>::value, int>;
+  template <typename Iterator>
+  using DisableIfAtLeastForwardIterator = absl::enable_if_t<
+      !inlined_vector_internal::IsAtLeastForwardIterator<Iterator>::value, int>;
+
+ public:
+  using allocator_type = A;
+  using value_type = inlined_vector_internal::ValueType<A>;
+  using pointer = inlined_vector_internal::Pointer<A>;
+  using const_pointer = inlined_vector_internal::ConstPointer<A>;
+  using size_type = inlined_vector_internal::SizeType<A>;
+  using difference_type = inlined_vector_internal::DifferenceType<A>;
+  using reference = inlined_vector_internal::Reference<A>;
+  using const_reference = inlined_vector_internal::ConstReference<A>;
+  using iterator = inlined_vector_internal::Iterator<A>;
+  using const_iterator = inlined_vector_internal::ConstIterator<A>;
+  using reverse_iterator = inlined_vector_internal::ReverseIterator<A>;
+  using const_reverse_iterator =
+      inlined_vector_internal::ConstReverseIterator<A>;
+
+  // ---------------------------------------------------------------------------
+  // InlinedVector Constructors and Destructor
+  // ---------------------------------------------------------------------------
+
+  // Creates an empty inlined vector with a value-initialized allocator.
+  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
+
+  // Creates an empty inlined vector with a copy of `allocator`.
+  explicit InlinedVector(const allocator_type& allocator) noexcept
+      : storage_(allocator) {}
+
+  // Creates an inlined vector with `n` copies of `value_type()`.
+  explicit InlinedVector(size_type n,
+                         const allocator_type& allocator = allocator_type())
+      : storage_(allocator) {
+    storage_.Initialize(DefaultValueAdapter<A>(), n);
+  }
+
+  // Creates an inlined vector with `n` copies of `v`.
+  InlinedVector(size_type n, const_reference v,
+                const allocator_type& allocator = allocator_type())
+      : storage_(allocator) {
+    storage_.Initialize(CopyValueAdapter<A>(std::addressof(v)), n);
+  }
+
+  // Creates an inlined vector with copies of the elements of `list`.
+  InlinedVector(std::initializer_list<value_type> list,
+                const allocator_type& allocator = allocator_type())
+      : InlinedVector(list.begin(), list.end(), allocator) {}
+
+  // Creates an inlined vector with elements constructed from the provided
+  // forward iterator range [`first`, `last`).
+  //
+  // NOTE: the `enable_if` prevents ambiguous interpretation between a call to
+  // this constructor with two integral arguments and a call to the above
+  // `InlinedVector(size_type, const_reference)` constructor.
+  template <typename ForwardIterator,
+            EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
+  InlinedVector(ForwardIterator first, ForwardIterator last,
+                const allocator_type& allocator = allocator_type())
+      : storage_(allocator) {
+    storage_.Initialize(IteratorValueAdapter<A, ForwardIterator>(first),
+                        static_cast<size_t>(std::distance(first, last)));
+  }
+
+  // Creates an inlined vector with elements constructed from the provided input
+  // iterator range [`first`, `last`).
+  template <typename InputIterator,
+            DisableIfAtLeastForwardIterator<InputIterator> = 0>
+  InlinedVector(InputIterator first, InputIterator last,
+                const allocator_type& allocator = allocator_type())
+      : storage_(allocator) {
+    std::copy(first, last, std::back_inserter(*this));
+  }
+
+  // Creates an inlined vector by copying the contents of `other` using
+  // `other`'s allocator.
+  InlinedVector(const InlinedVector& other)
+      : InlinedVector(other, other.storage_.GetAllocator()) {}
+
+  // Creates an inlined vector by copying the contents of `other` using the
+  // provided `allocator`.
+  InlinedVector(const InlinedVector& other, const allocator_type& allocator)
+      : storage_(allocator) {
+    if (other.empty()) {
+      // Empty; nothing to do.
+    } else if (IsMemcpyOk<A>::value && !other.storage_.GetIsAllocated()) {
+      // Memcpy-able and do not need allocation.
+      storage_.MemcpyFrom(other.storage_);
+    } else {
+      storage_.InitFrom(other.storage_);
+    }
+  }
+
+  // Creates an inlined vector by moving in the contents of `other` without
+  // allocating. If `other` contains allocated memory, the newly-created inlined
+  // vector will take ownership of that memory. However, if `other` does not
+  // contain allocated memory, the newly-created inlined vector will perform
+  // element-wise move construction of the contents of `other`.
+  //
+  // NOTE: since no allocation is performed for the inlined vector in either
+  // case, the `noexcept(...)` specification depends on whether moving the
+  // underlying objects can throw. It is assumed assumed that...
+  //  a) move constructors should only throw due to allocation failure.
+  //  b) if `value_type`'s move constructor allocates, it uses the same
+  //     allocation function as the inlined vector's allocator.
+  // Thus, the move constructor is non-throwing if the allocator is non-throwing
+  // or `value_type`'s move constructor is specified as `noexcept`.
+  InlinedVector(InlinedVector&& other) noexcept(
+      absl::allocator_is_nothrow<allocator_type>::value ||
+      std::is_nothrow_move_constructible<value_type>::value)
+      : storage_(other.storage_.GetAllocator()) {
+    if (IsMemcpyOk<A>::value) {
+      storage_.MemcpyFrom(other.storage_);
+
+      other.storage_.SetInlinedSize(0);
+    } else if (other.storage_.GetIsAllocated()) {
+      storage_.SetAllocation({other.storage_.GetAllocatedData(),
+                              other.storage_.GetAllocatedCapacity()});
+      storage_.SetAllocatedSize(other.storage_.GetSize());
+
+      other.storage_.SetInlinedSize(0);
+    } else {
+      IteratorValueAdapter<A, MoveIterator<A>> other_values(
+          MoveIterator<A>(other.storage_.GetInlinedData()));
+
+      inlined_vector_internal::ConstructElements<A>(
+          storage_.GetAllocator(), storage_.GetInlinedData(), other_values,
+          other.storage_.GetSize());
+
+      storage_.SetInlinedSize(other.storage_.GetSize());
+    }
+  }
+
+  // Creates an inlined vector by moving in the contents of `other` with a copy
+  // of `allocator`.
+  //
+  // NOTE: if `other`'s allocator is not equal to `allocator`, even if `other`
+  // contains allocated memory, this move constructor will still allocate. Since
+  // allocation is performed, this constructor can only be `noexcept` if the
+  // specified allocator is also `noexcept`.
+  InlinedVector(
+      InlinedVector&& other,
+      const allocator_type&
+          allocator) noexcept(absl::allocator_is_nothrow<allocator_type>::value)
+      : storage_(allocator) {
+    if (IsMemcpyOk<A>::value) {
+      storage_.MemcpyFrom(other.storage_);
+
+      other.storage_.SetInlinedSize(0);
+    } else if ((storage_.GetAllocator() == other.storage_.GetAllocator()) &&
+               other.storage_.GetIsAllocated()) {
+      storage_.SetAllocation({other.storage_.GetAllocatedData(),
+                              other.storage_.GetAllocatedCapacity()});
+      storage_.SetAllocatedSize(other.storage_.GetSize());
+
+      other.storage_.SetInlinedSize(0);
+    } else {
+      storage_.Initialize(IteratorValueAdapter<A, MoveIterator<A>>(
+                              MoveIterator<A>(other.data())),
+                          other.size());
+    }
+  }
+
+  ~InlinedVector() {}
+
+  // ---------------------------------------------------------------------------
+  // InlinedVector Member Accessors
+  // ---------------------------------------------------------------------------
+
+  // `InlinedVector::empty()`
+  //
+  // Returns whether the inlined vector contains no elements.
+  bool empty() const noexcept { return !size(); }
+
+  // `InlinedVector::size()`
+  //
+  // Returns the number of elements in the inlined vector.
+  size_type size() const noexcept { return storage_.GetSize(); }
+
+  // `InlinedVector::max_size()`
+  //
+  // Returns the maximum number of elements the inlined vector can hold.
+  size_type max_size() const noexcept {
+    // One bit of the size storage is used to indicate whether the inlined
+    // vector contains allocated memory. As a result, the maximum size that the
+    // inlined vector can express is half of the max for `size_type`.
+    return (std::numeric_limits<size_type>::max)() / 2;
+  }
+
+  // `InlinedVector::capacity()`
+  //
+  // Returns the number of elements that could be stored in the inlined vector
+  // without requiring a reallocation.
+  //
+  // NOTE: for most inlined vectors, `capacity()` should be equal to the
+  // template parameter `N`. For inlined vectors which exceed this capacity,
+  // they will no longer be inlined and `capacity()` will equal the capactity of
+  // the allocated memory.
+  size_type capacity() const noexcept {
+    return storage_.GetIsAllocated() ? storage_.GetAllocatedCapacity()
+                                     : storage_.GetInlinedCapacity();
+  }
+
+  // `InlinedVector::data()`
+  //
+  // Returns a `pointer` to the elements of the inlined vector. This pointer
+  // can be used to access and modify the contained elements.
+  //
+  // NOTE: only elements within [`data()`, `data() + size()`) are valid.
+  pointer data() noexcept {
+    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
+                                     : storage_.GetInlinedData();
+  }
+
+  // Overload of `InlinedVector::data()` that returns a `const_pointer` to the
+  // elements of the inlined vector. This pointer can be used to access but not
+  // modify the contained elements.
+  //
+  // NOTE: only elements within [`data()`, `data() + size()`) are valid.
+  const_pointer data() const noexcept {
+    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
+                                     : storage_.GetInlinedData();
+  }
+
+  // `InlinedVector::operator[](...)`
+  //
+  // Returns a `reference` to the `i`th element of the inlined vector.
+  reference operator[](size_type i) {
+    ABSL_HARDENING_ASSERT(i < size());
+    return data()[i];
+  }
+
+  // Overload of `InlinedVector::operator[](...)` that returns a
+  // `const_reference` to the `i`th element of the inlined vector.
+  const_reference operator[](size_type i) const {
+    ABSL_HARDENING_ASSERT(i < size());
+    return data()[i];
+  }
+
+  // `InlinedVector::at(...)`
+  //
+  // Returns a `reference` to the `i`th element of the inlined vector.
+  //
+  // NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,
+  // in both debug and non-debug builds, `std::out_of_range` will be thrown.
+  reference at(size_type i) {
+    if (ABSL_PREDICT_FALSE(i >= size())) {
+      base_internal::ThrowStdOutOfRange(
+          "`InlinedVector::at(size_type)` failed bounds check");
+    }
+    return data()[i];
+  }
+
+  // Overload of `InlinedVector::at(...)` that returns a `const_reference` to
+  // the `i`th element of the inlined vector.
+  //
+  // NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,
+  // in both debug and non-debug builds, `std::out_of_range` will be thrown.
+  const_reference at(size_type i) const {
+    if (ABSL_PREDICT_FALSE(i >= size())) {
+      base_internal::ThrowStdOutOfRange(
+          "`InlinedVector::at(size_type) const` failed bounds check");
+    }
+    return data()[i];
+  }
+
+  // `InlinedVector::front()`
+  //
+  // Returns a `reference` to the first element of the inlined vector.
+  reference front() {
+    ABSL_HARDENING_ASSERT(!empty());
+    return data()[0];
+  }
+
+  // Overload of `InlinedVector::front()` that returns a `const_reference` to
+  // the first element of the inlined vector.
+  const_reference front() const {
+    ABSL_HARDENING_ASSERT(!empty());
+    return data()[0];
+  }
+
+  // `InlinedVector::back()`
+  //
+  // Returns a `reference` to the last element of the inlined vector.
+  reference back() {
+    ABSL_HARDENING_ASSERT(!empty());
+    return data()[size() - 1];
+  }
+
+  // Overload of `InlinedVector::back()` that returns a `const_reference` to the
+  // last element of the inlined vector.
+  const_reference back() const {
+    ABSL_HARDENING_ASSERT(!empty());
+    return data()[size() - 1];
+  }
+
+  // `InlinedVector::begin()`
+  //
+  // Returns an `iterator` to the beginning of the inlined vector.
+  iterator begin() noexcept { return data(); }
+
+  // Overload of `InlinedVector::begin()` that returns a `const_iterator` to
+  // the beginning of the inlined vector.
+  const_iterator begin() const noexcept { return data(); }
+
+  // `InlinedVector::end()`
+  //
+  // Returns an `iterator` to the end of the inlined vector.
+  iterator end() noexcept { return data() + size(); }
+
+  // Overload of `InlinedVector::end()` that returns a `const_iterator` to the
+  // end of the inlined vector.
+  const_iterator end() const noexcept { return data() + size(); }
+
+  // `InlinedVector::cbegin()`
+  //
+  // Returns a `const_iterator` to the beginning of the inlined vector.
+  const_iterator cbegin() const noexcept { return begin(); }
+
+  // `InlinedVector::cend()`
+  //
+  // Returns a `const_iterator` to the end of the inlined vector.
+  const_iterator cend() const noexcept { return end(); }
+
+  // `InlinedVector::rbegin()`
+  //
+  // Returns a `reverse_iterator` from the end of the inlined vector.
+  reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+
+  // Overload of `InlinedVector::rbegin()` that returns a
+  // `const_reverse_iterator` from the end of the inlined vector.
+  const_reverse_iterator rbegin() const noexcept {
+    return const_reverse_iterator(end());
+  }
+
+  // `InlinedVector::rend()`
+  //
+  // Returns a `reverse_iterator` from the beginning of the inlined vector.
+  reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+
+  // Overload of `InlinedVector::rend()` that returns a `const_reverse_iterator`
+  // from the beginning of the inlined vector.
+  const_reverse_iterator rend() const noexcept {
+    return const_reverse_iterator(begin());
+  }
+
+  // `InlinedVector::crbegin()`
+  //
+  // Returns a `const_reverse_iterator` from the end of the inlined vector.
+  const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+  // `InlinedVector::crend()`
+  //
+  // Returns a `const_reverse_iterator` from the beginning of the inlined
+  // vector.
+  const_reverse_iterator crend() const noexcept { return rend(); }
+
+  // `InlinedVector::get_allocator()`
+  //
+  // Returns a copy of the inlined vector's allocator.
+  allocator_type get_allocator() const { return storage_.GetAllocator(); }
+
+  // ---------------------------------------------------------------------------
+  // InlinedVector Member Mutators
+  // ---------------------------------------------------------------------------
+
+  // `InlinedVector::operator=(...)`
+  //
+  // Replaces the elements of the inlined vector with copies of the elements of
+  // `list`.
+  InlinedVector& operator=(std::initializer_list<value_type> list) {
+    assign(list.begin(), list.end());
+
+    return *this;
+  }
+
+  // Overload of `InlinedVector::operator=(...)` that replaces the elements of
+  // the inlined vector with copies of the elements of `other`.
+  InlinedVector& operator=(const InlinedVector& other) {
+    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
+      const_pointer other_data = other.data();
+      assign(other_data, other_data + other.size());
+    }
+
+    return *this;
+  }
+
+  // Overload of `InlinedVector::operator=(...)` that moves the elements of
+  // `other` into the inlined vector.
+  //
+  // NOTE: as a result of calling this overload, `other` is left in a valid but
+  // unspecified state.
+  InlinedVector& operator=(InlinedVector&& other) {
+    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
+      if (IsMemcpyOk<A>::value || other.storage_.GetIsAllocated()) {
+        inlined_vector_internal::DestroyAdapter<A>::DestroyElements(
+            storage_.GetAllocator(), data(), size());
+        storage_.DeallocateIfAllocated();
+        storage_.MemcpyFrom(other.storage_);
+
+        other.storage_.SetInlinedSize(0);
+      } else {
+        storage_.Assign(IteratorValueAdapter<A, MoveIterator<A>>(
+                            MoveIterator<A>(other.storage_.GetInlinedData())),
+                        other.size());
+      }
+    }
+
+    return *this;
+  }
+
+  // `InlinedVector::assign(...)`
+  //
+  // Replaces the contents of the inlined vector with `n` copies of `v`.
+  void assign(size_type n, const_reference v) {
+    storage_.Assign(CopyValueAdapter<A>(std::addressof(v)), n);
+  }
+
+  // Overload of `InlinedVector::assign(...)` that replaces the contents of the
+  // inlined vector with copies of the elements of `list`.
+  void assign(std::initializer_list<value_type> list) {
+    assign(list.begin(), list.end());
+  }
+
+  // Overload of `InlinedVector::assign(...)` to replace the contents of the
+  // inlined vector with the range [`first`, `last`).
+  //
+  // NOTE: this overload is for iterators that are "forward" category or better.
+  template <typename ForwardIterator,
+            EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
+  void assign(ForwardIterator first, ForwardIterator last) {
+    storage_.Assign(IteratorValueAdapter<A, ForwardIterator>(first),
+                    static_cast<size_t>(std::distance(first, last)));
+  }
+
+  // Overload of `InlinedVector::assign(...)` to replace the contents of the
+  // inlined vector with the range [`first`, `last`).
+  //
+  // NOTE: this overload is for iterators that are "input" category.
+  template <typename InputIterator,
+            DisableIfAtLeastForwardIterator<InputIterator> = 0>
+  void assign(InputIterator first, InputIterator last) {
+    size_type i = 0;
+    for (; i < size() && first != last; ++i, static_cast<void>(++first)) {
+      data()[i] = *first;
+    }
+
+    erase(data() + i, data() + size());
+    std::copy(first, last, std::back_inserter(*this));
+  }
+
+  // `InlinedVector::resize(...)`
+  //
+  // Resizes the inlined vector to contain `n` elements.
+  //
+  // NOTE: If `n` is smaller than `size()`, extra elements are destroyed. If `n`
+  // is larger than `size()`, new elements are value-initialized.
+  void resize(size_type n) {
+    ABSL_HARDENING_ASSERT(n <= max_size());
+    storage_.Resize(DefaultValueAdapter<A>(), n);
+  }
+
+  // Overload of `InlinedVector::resize(...)` that resizes the inlined vector to
+  // contain `n` elements.
+  //
+  // NOTE: if `n` is smaller than `size()`, extra elements are destroyed. If `n`
+  // is larger than `size()`, new elements are copied-constructed from `v`.
+  void resize(size_type n, const_reference v) {
+    ABSL_HARDENING_ASSERT(n <= max_size());
+    storage_.Resize(CopyValueAdapter<A>(std::addressof(v)), n);
+  }
+
+  // `InlinedVector::insert(...)`
+  //
+  // Inserts a copy of `v` at `pos`, returning an `iterator` to the newly
+  // inserted element.
+  iterator insert(const_iterator pos, const_reference v) {
+    return emplace(pos, v);
+  }
+
+  // Overload of `InlinedVector::insert(...)` that inserts `v` at `pos` using
+  // move semantics, returning an `iterator` to the newly inserted element.
+  iterator insert(const_iterator pos, value_type&& v) {
+    return emplace(pos, std::move(v));
+  }
+
+  // Overload of `InlinedVector::insert(...)` that inserts `n` contiguous copies
+  // of `v` starting at `pos`, returning an `iterator` pointing to the first of
+  // the newly inserted elements.
+  iterator insert(const_iterator pos, size_type n, const_reference v) {
+    ABSL_HARDENING_ASSERT(pos >= begin());
+    ABSL_HARDENING_ASSERT(pos <= end());
+
+    if (ABSL_PREDICT_TRUE(n != 0)) {
+      value_type dealias = v;
+      // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102329#c2
+      // It appears that GCC thinks that since `pos` is a const pointer and may
+      // point to uninitialized memory at this point, a warning should be
+      // issued. But `pos` is actually only used to compute an array index to
+      // write to.
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+      return storage_.Insert(pos, CopyValueAdapter<A>(std::addressof(dealias)),
+                             n);
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+    } else {
+      return const_cast<iterator>(pos);
+    }
+  }
+
+  // Overload of `InlinedVector::insert(...)` that inserts copies of the
+  // elements of `list` starting at `pos`, returning an `iterator` pointing to
+  // the first of the newly inserted elements.
+  iterator insert(const_iterator pos, std::initializer_list<value_type> list) {
+    return insert(pos, list.begin(), list.end());
+  }
+
+  // Overload of `InlinedVector::insert(...)` that inserts the range [`first`,
+  // `last`) starting at `pos`, returning an `iterator` pointing to the first
+  // of the newly inserted elements.
+  //
+  // NOTE: this overload is for iterators that are "forward" category or better.
+  template <typename ForwardIterator,
+            EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
+  iterator insert(const_iterator pos, ForwardIterator first,
+                  ForwardIterator last) {
+    ABSL_HARDENING_ASSERT(pos >= begin());
+    ABSL_HARDENING_ASSERT(pos <= end());
+
+    if (ABSL_PREDICT_TRUE(first != last)) {
+      return storage_.Insert(pos,
+                             IteratorValueAdapter<A, ForwardIterator>(first),
+                             std::distance(first, last));
+    } else {
+      return const_cast<iterator>(pos);
+    }
+  }
+
+  // Overload of `InlinedVector::insert(...)` that inserts the range [`first`,
+  // `last`) starting at `pos`, returning an `iterator` pointing to the first
+  // of the newly inserted elements.
+  //
+  // NOTE: this overload is for iterators that are "input" category.
+  template <typename InputIterator,
+            DisableIfAtLeastForwardIterator<InputIterator> = 0>
+  iterator insert(const_iterator pos, InputIterator first, InputIterator last) {
+    ABSL_HARDENING_ASSERT(pos >= begin());
+    ABSL_HARDENING_ASSERT(pos <= end());
+
+    size_type index = std::distance(cbegin(), pos);
+    for (size_type i = index; first != last; ++i, static_cast<void>(++first)) {
+      insert(data() + i, *first);
+    }
+
+    return iterator(data() + index);
+  }
+
+  // `InlinedVector::emplace(...)`
+  //
+  // Constructs and inserts an element using `args...` in the inlined vector at
+  // `pos`, returning an `iterator` pointing to the newly emplaced element.
+  template <typename... Args>
+  iterator emplace(const_iterator pos, Args&&... args) {
+    ABSL_HARDENING_ASSERT(pos >= begin());
+    ABSL_HARDENING_ASSERT(pos <= end());
+
+    value_type dealias(std::forward<Args>(args)...);
+    return storage_.Insert(pos,
+                           IteratorValueAdapter<A, MoveIterator<A>>(
+                               MoveIterator<A>(std::addressof(dealias))),
+                           1);
+  }
+
+  // `InlinedVector::emplace_back(...)`
+  //
+  // Constructs and inserts an element using `args...` in the inlined vector at
+  // `end()`, returning a `reference` to the newly emplaced element.
+  template <typename... Args>
+  reference emplace_back(Args&&... args) {
+    return storage_.EmplaceBack(std::forward<Args>(args)...);
+  }
+
+  // `InlinedVector::push_back(...)`
+  //
+  // Inserts a copy of `v` in the inlined vector at `end()`.
+  void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
+
+  // Overload of `InlinedVector::push_back(...)` for inserting `v` at `end()`
+  // using move semantics.
+  void push_back(value_type&& v) {
+    static_cast<void>(emplace_back(std::move(v)));
+  }
+
+  // `InlinedVector::pop_back()`
+  //
+  // Destroys the element at `back()`, reducing the size by `1`.
+  void pop_back() noexcept {
+    ABSL_HARDENING_ASSERT(!empty());
+
+    AllocatorTraits<A>::destroy(storage_.GetAllocator(), data() + (size() - 1));
+    storage_.SubtractSize(1);
+  }
+
+  // `InlinedVector::erase(...)`
+  //
+  // Erases the element at `pos`, returning an `iterator` pointing to where the
+  // erased element was located.
+  //
+  // NOTE: may return `end()`, which is not dereferencable.
+  iterator erase(const_iterator pos) {
+    ABSL_HARDENING_ASSERT(pos >= begin());
+    ABSL_HARDENING_ASSERT(pos < end());
+
+    return storage_.Erase(pos, pos + 1);
+  }
+
+  // Overload of `InlinedVector::erase(...)` that erases every element in the
+  // range [`from`, `to`), returning an `iterator` pointing to where the first
+  // erased element was located.
+  //
+  // NOTE: may return `end()`, which is not dereferencable.
+  iterator erase(const_iterator from, const_iterator to) {
+    ABSL_HARDENING_ASSERT(from >= begin());
+    ABSL_HARDENING_ASSERT(from <= to);
+    ABSL_HARDENING_ASSERT(to <= end());
+
+    if (ABSL_PREDICT_TRUE(from != to)) {
+      return storage_.Erase(from, to);
+    } else {
+      return const_cast<iterator>(from);
+    }
+  }
+
+  // `InlinedVector::clear()`
+  //
+  // Destroys all elements in the inlined vector, setting the size to `0` and
+  // deallocating any held memory.
+  void clear() noexcept {
+    inlined_vector_internal::DestroyAdapter<A>::DestroyElements(
+        storage_.GetAllocator(), data(), size());
+    storage_.DeallocateIfAllocated();
+
+    storage_.SetInlinedSize(0);
+  }
+
+  // `InlinedVector::reserve(...)`
+  //
+  // Ensures that there is enough room for at least `n` elements.
+  void reserve(size_type n) { storage_.Reserve(n); }
+
+  // `InlinedVector::shrink_to_fit()`
+  //
+  // Attempts to reduce memory usage by moving elements to (or keeping elements
+  // in) the smallest available buffer sufficient for containing `size()`
+  // elements.
+  //
+  // If `size()` is sufficiently small, the elements will be moved into (or kept
+  // in) the inlined space.
+  void shrink_to_fit() {
+    if (storage_.GetIsAllocated()) {
+      storage_.ShrinkToFit();
+    }
+  }
+
+  // `InlinedVector::swap(...)`
+  //
+  // Swaps the contents of the inlined vector with `other`.
+  void swap(InlinedVector& other) {
+    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
+      storage_.Swap(std::addressof(other.storage_));
+    }
+  }
+
+ private:
+  template <typename H, typename TheT, size_t TheN, typename TheA>
+  friend H AbslHashValue(H h, const absl::InlinedVector<TheT, TheN, TheA>& a);
+
+  Storage storage_;
+};
+
+// -----------------------------------------------------------------------------
+// InlinedVector Non-Member Functions
+// -----------------------------------------------------------------------------
+
+// `swap(...)`
+//
+// Swaps the contents of two inlined vectors.
+template <typename T, size_t N, typename A>
+void swap(absl::InlinedVector<T, N, A>& a,
+          absl::InlinedVector<T, N, A>& b) noexcept(noexcept(a.swap(b))) {
+  a.swap(b);
+}
+
+// `operator==(...)`
+//
+// Tests for value-equality of two inlined vectors.
+template <typename T, size_t N, typename A>
+bool operator==(const absl::InlinedVector<T, N, A>& a,
+                const absl::InlinedVector<T, N, A>& b) {
+  auto a_data = a.data();
+  auto b_data = b.data();
+  return absl::equal(a_data, a_data + a.size(), b_data, b_data + b.size());
+}
+
+// `operator!=(...)`
+//
+// Tests for value-inequality of two inlined vectors.
+template <typename T, size_t N, typename A>
+bool operator!=(const absl::InlinedVector<T, N, A>& a,
+                const absl::InlinedVector<T, N, A>& b) {
+  return !(a == b);
+}
+
+// `operator<(...)`
+//
+// Tests whether the value of an inlined vector is less than the value of
+// another inlined vector using a lexicographical comparison algorithm.
+template <typename T, size_t N, typename A>
+bool operator<(const absl::InlinedVector<T, N, A>& a,
+               const absl::InlinedVector<T, N, A>& b) {
+  auto a_data = a.data();
+  auto b_data = b.data();
+  return std::lexicographical_compare(a_data, a_data + a.size(), b_data,
+                                      b_data + b.size());
+}
+
+// `operator>(...)`
+//
+// Tests whether the value of an inlined vector is greater than the value of
+// another inlined vector using a lexicographical comparison algorithm.
+template <typename T, size_t N, typename A>
+bool operator>(const absl::InlinedVector<T, N, A>& a,
+               const absl::InlinedVector<T, N, A>& b) {
+  return b < a;
+}
+
+// `operator<=(...)`
+//
+// Tests whether the value of an inlined vector is less than or equal to the
+// value of another inlined vector using a lexicographical comparison algorithm.
+template <typename T, size_t N, typename A>
+bool operator<=(const absl::InlinedVector<T, N, A>& a,
+                const absl::InlinedVector<T, N, A>& b) {
+  return !(b < a);
+}
+
+// `operator>=(...)`
+//
+// Tests whether the value of an inlined vector is greater than or equal to the
+// value of another inlined vector using a lexicographical comparison algorithm.
+template <typename T, size_t N, typename A>
+bool operator>=(const absl::InlinedVector<T, N, A>& a,
+                const absl::InlinedVector<T, N, A>& b) {
+  return !(a < b);
+}
+
+// `AbslHashValue(...)`
+//
+// Provides `absl::Hash` support for `absl::InlinedVector`. It is uncommon to
+// call this directly.
+template <typename H, typename T, size_t N, typename A>
+H AbslHashValue(H h, const absl::InlinedVector<T, N, A>& a) {
+  auto size = a.size();
+  return H::combine(H::combine_contiguous(std::move(h), a.data(), size), size);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INLINED_VECTOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/btree.h b/CAPI/cpp/grpc/include/absl/container/internal/btree.h
new file mode 100644
index 0000000..01f4e74
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/btree.h
@@ -0,0 +1,2854 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// A btree implementation of the STL set and map interfaces. A btree is smaller
+// and generally also faster than STL set/map (refer to the benchmarks below).
+// The red-black tree implementation of STL set/map has an overhead of 3
+// pointers (left, right and parent) plus the node color information for each
+// stored value. So a set<int32_t> consumes 40 bytes for each value stored in
+// 64-bit mode. This btree implementation stores multiple values on fixed
+// size nodes (usually 256 bytes) and doesn't store child pointers for leaf
+// nodes. The result is that a btree_set<int32_t> may use much less memory per
+// stored value. For the random insertion benchmark in btree_bench.cc, a
+// btree_set<int32_t> with node-size of 256 uses 5.1 bytes per stored value.
+//
+// The packing of multiple values on to each node of a btree has another effect
+// besides better space utilization: better cache locality due to fewer cache
+// lines being accessed. Better cache locality translates into faster
+// operations.
+//
+// CAVEATS
+//
+// Insertions and deletions on a btree can cause splitting, merging or
+// rebalancing of btree nodes. And even without these operations, insertions
+// and deletions on a btree will move values around within a node. In both
+// cases, the result is that insertions and deletions can invalidate iterators
+// pointing to values other than the one being inserted/deleted. Therefore, this
+// container does not provide pointer stability. This is notably different from
+// STL set/map which takes care to not invalidate iterators on insert/erase
+// except, of course, for iterators pointing to the value being erased.  A
+// partial workaround when erasing is available: erase() returns an iterator
+// pointing to the item just after the one that was erased (or end() if none
+// exists).
+
+#ifndef ABSL_CONTAINER_INTERNAL_BTREE_H_
+#define ABSL_CONTAINER_INTERNAL_BTREE_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/macros.h"
+#include "absl/container/internal/common.h"
+#include "absl/container/internal/compressed_tuple.h"
+#include "absl/container/internal/container_memory.h"
+#include "absl/container/internal/layout.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/compare.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+#error ABSL_BTREE_ENABLE_GENERATIONS cannot be directly set
+#elif defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
+    defined(ABSL_HAVE_MEMORY_SANITIZER)
+// When compiled in sanitizer mode, we add generation integers to the nodes and
+// iterators. When iterators are used, we validate that the container has not
+// been mutated since the iterator was constructed.
+#define ABSL_BTREE_ENABLE_GENERATIONS
+#endif
+
+template <typename Compare, typename T, typename U>
+using compare_result_t = absl::result_of_t<const Compare(const T &, const U &)>;
+
+// A helper class that indicates if the Compare parameter is a key-compare-to
+// comparator.
+template <typename Compare, typename T>
+using btree_is_key_compare_to =
+    std::is_convertible<compare_result_t<Compare, T, T>, absl::weak_ordering>;
+
+struct StringBtreeDefaultLess {
+  using is_transparent = void;
+
+  StringBtreeDefaultLess() = default;
+
+  // Compatibility constructor.
+  StringBtreeDefaultLess(std::less<std::string>) {}  // NOLINT
+  StringBtreeDefaultLess(std::less<absl::string_view>) {}  // NOLINT
+
+  // Allow converting to std::less for use in key_comp()/value_comp().
+  explicit operator std::less<std::string>() const { return {}; }
+  explicit operator std::less<absl::string_view>() const { return {}; }
+  explicit operator std::less<absl::Cord>() const { return {}; }
+
+  absl::weak_ordering operator()(absl::string_view lhs,
+                                 absl::string_view rhs) const {
+    return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
+  }
+  StringBtreeDefaultLess(std::less<absl::Cord>) {}  // NOLINT
+  absl::weak_ordering operator()(const absl::Cord &lhs,
+                                 const absl::Cord &rhs) const {
+    return compare_internal::compare_result_as_ordering(lhs.Compare(rhs));
+  }
+  absl::weak_ordering operator()(const absl::Cord &lhs,
+                                 absl::string_view rhs) const {
+    return compare_internal::compare_result_as_ordering(lhs.Compare(rhs));
+  }
+  absl::weak_ordering operator()(absl::string_view lhs,
+                                 const absl::Cord &rhs) const {
+    return compare_internal::compare_result_as_ordering(-rhs.Compare(lhs));
+  }
+};
+
+struct StringBtreeDefaultGreater {
+  using is_transparent = void;
+
+  StringBtreeDefaultGreater() = default;
+
+  StringBtreeDefaultGreater(std::greater<std::string>) {}  // NOLINT
+  StringBtreeDefaultGreater(std::greater<absl::string_view>) {}  // NOLINT
+
+  // Allow converting to std::greater for use in key_comp()/value_comp().
+  explicit operator std::greater<std::string>() const { return {}; }
+  explicit operator std::greater<absl::string_view>() const { return {}; }
+  explicit operator std::greater<absl::Cord>() const { return {}; }
+
+  absl::weak_ordering operator()(absl::string_view lhs,
+                                 absl::string_view rhs) const {
+    return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
+  }
+  StringBtreeDefaultGreater(std::greater<absl::Cord>) {}  // NOLINT
+  absl::weak_ordering operator()(const absl::Cord &lhs,
+                                 const absl::Cord &rhs) const {
+    return compare_internal::compare_result_as_ordering(rhs.Compare(lhs));
+  }
+  absl::weak_ordering operator()(const absl::Cord &lhs,
+                                 absl::string_view rhs) const {
+    return compare_internal::compare_result_as_ordering(-lhs.Compare(rhs));
+  }
+  absl::weak_ordering operator()(absl::string_view lhs,
+                                 const absl::Cord &rhs) const {
+    return compare_internal::compare_result_as_ordering(rhs.Compare(lhs));
+  }
+};
+
+// See below comments for checked_compare.
+template <typename Compare, bool is_class = std::is_class<Compare>::value>
+struct checked_compare_base : Compare {
+  using Compare::Compare;
+  explicit checked_compare_base(Compare c) : Compare(std::move(c)) {}
+  const Compare &comp() const { return *this; }
+};
+template <typename Compare>
+struct checked_compare_base<Compare, false> {
+  explicit checked_compare_base(Compare c) : compare(std::move(c)) {}
+  const Compare &comp() const { return compare; }
+  Compare compare;
+};
+
+// A mechanism for opting out of checked_compare for use only in btree_test.cc.
+struct BtreeTestOnlyCheckedCompareOptOutBase {};
+
+// A helper class to adapt the specified comparator for two use cases:
+// (1) When using common Abseil string types with common comparison functors,
+// convert a boolean comparison into a three-way comparison that returns an
+// `absl::weak_ordering`. This helper class is specialized for
+// less<std::string>, greater<std::string>, less<string_view>,
+// greater<string_view>, less<absl::Cord>, and greater<absl::Cord>.
+// (2) Adapt the comparator to diagnose cases of non-strict-weak-ordering (see
+// https://en.cppreference.com/w/cpp/named_req/Compare) in debug mode. Whenever
+// a comparison is made, we will make assertions to verify that the comparator
+// is valid.
+template <typename Compare, typename Key>
+struct key_compare_adapter {
+  // Inherit from checked_compare_base to support function pointers and also
+  // keep empty-base-optimization (EBO) support for classes.
+  // Note: we can't use CompressedTuple here because that would interfere
+  // with the EBO for `btree::rightmost_`. `btree::rightmost_` is itself a
+  // CompressedTuple and nested `CompressedTuple`s don't support EBO.
+  // TODO(b/214288561): use CompressedTuple instead once it supports EBO for
+  // nested `CompressedTuple`s.
+  struct checked_compare : checked_compare_base<Compare> {
+   private:
+    using Base = typename checked_compare::checked_compare_base;
+    using Base::comp;
+
+    // If possible, returns whether `t` is equivalent to itself. We can only do
+    // this for `Key`s because we can't be sure that it's safe to call
+    // `comp()(k, k)` otherwise. Even if SFINAE allows it, there could be a
+    // compilation failure inside the implementation of the comparison operator.
+    bool is_self_equivalent(const Key &k) const {
+      // Note: this works for both boolean and three-way comparators.
+      return comp()(k, k) == 0;
+    }
+    // If we can't compare `t` with itself, returns true unconditionally.
+    template <typename T>
+    bool is_self_equivalent(const T &) const {
+      return true;
+    }
+
+   public:
+    using Base::Base;
+    checked_compare(Compare comp) : Base(std::move(comp)) {}  // NOLINT
+
+    // Allow converting to Compare for use in key_comp()/value_comp().
+    explicit operator Compare() const { return comp(); }
+
+    template <typename T, typename U,
+              absl::enable_if_t<
+                  std::is_same<bool, compare_result_t<Compare, T, U>>::value,
+                  int> = 0>
+    bool operator()(const T &lhs, const U &rhs) const {
+      // NOTE: if any of these assertions fail, then the comparator does not
+      // establish a strict-weak-ordering (see
+      // https://en.cppreference.com/w/cpp/named_req/Compare).
+      assert(is_self_equivalent(lhs));
+      assert(is_self_equivalent(rhs));
+      const bool lhs_comp_rhs = comp()(lhs, rhs);
+      assert(!lhs_comp_rhs || !comp()(rhs, lhs));
+      return lhs_comp_rhs;
+    }
+
+    template <
+        typename T, typename U,
+        absl::enable_if_t<std::is_convertible<compare_result_t<Compare, T, U>,
+                                              absl::weak_ordering>::value,
+                          int> = 0>
+    absl::weak_ordering operator()(const T &lhs, const U &rhs) const {
+      // NOTE: if any of these assertions fail, then the comparator does not
+      // establish a strict-weak-ordering (see
+      // https://en.cppreference.com/w/cpp/named_req/Compare).
+      assert(is_self_equivalent(lhs));
+      assert(is_self_equivalent(rhs));
+      const absl::weak_ordering lhs_comp_rhs = comp()(lhs, rhs);
+#ifndef NDEBUG
+      const absl::weak_ordering rhs_comp_lhs = comp()(rhs, lhs);
+      if (lhs_comp_rhs > 0) {
+        assert(rhs_comp_lhs < 0 && "lhs_comp_rhs > 0 -> rhs_comp_lhs < 0");
+      } else if (lhs_comp_rhs == 0) {
+        assert(rhs_comp_lhs == 0 && "lhs_comp_rhs == 0 -> rhs_comp_lhs == 0");
+      } else {
+        assert(rhs_comp_lhs > 0 && "lhs_comp_rhs < 0 -> rhs_comp_lhs > 0");
+      }
+#endif
+      return lhs_comp_rhs;
+    }
+  };
+  using type = absl::conditional_t<
+      std::is_base_of<BtreeTestOnlyCheckedCompareOptOutBase, Compare>::value,
+      Compare, checked_compare>;
+};
+
+template <>
+struct key_compare_adapter<std::less<std::string>, std::string> {
+  using type = StringBtreeDefaultLess;
+};
+
+template <>
+struct key_compare_adapter<std::greater<std::string>, std::string> {
+  using type = StringBtreeDefaultGreater;
+};
+
+template <>
+struct key_compare_adapter<std::less<absl::string_view>, absl::string_view> {
+  using type = StringBtreeDefaultLess;
+};
+
+template <>
+struct key_compare_adapter<std::greater<absl::string_view>, absl::string_view> {
+  using type = StringBtreeDefaultGreater;
+};
+
+template <>
+struct key_compare_adapter<std::less<absl::Cord>, absl::Cord> {
+  using type = StringBtreeDefaultLess;
+};
+
+template <>
+struct key_compare_adapter<std::greater<absl::Cord>, absl::Cord> {
+  using type = StringBtreeDefaultGreater;
+};
+
+// Detects an 'absl_btree_prefer_linear_node_search' member. This is
+// a protocol used as an opt-in or opt-out of linear search.
+//
+//  For example, this would be useful for key types that wrap an integer
+//  and define their own cheap operator<(). For example:
+//
+//   class K {
+//    public:
+//     using absl_btree_prefer_linear_node_search = std::true_type;
+//     ...
+//    private:
+//     friend bool operator<(K a, K b) { return a.k_ < b.k_; }
+//     int k_;
+//   };
+//
+//   btree_map<K, V> m;  // Uses linear search
+//
+// If T has the preference tag, then it has a preference.
+// Btree will use the tag's truth value.
+template <typename T, typename = void>
+struct has_linear_node_search_preference : std::false_type {};
+template <typename T, typename = void>
+struct prefers_linear_node_search : std::false_type {};
+template <typename T>
+struct has_linear_node_search_preference<
+    T, absl::void_t<typename T::absl_btree_prefer_linear_node_search>>
+    : std::true_type {};
+template <typename T>
+struct prefers_linear_node_search<
+    T, absl::void_t<typename T::absl_btree_prefer_linear_node_search>>
+    : T::absl_btree_prefer_linear_node_search {};
+
+template <typename Compare, typename Key>
+constexpr bool compare_has_valid_result_type() {
+  using compare_result_type = compare_result_t<Compare, Key, Key>;
+  return std::is_same<compare_result_type, bool>::value ||
+         std::is_convertible<compare_result_type, absl::weak_ordering>::value;
+}
+
+template <typename original_key_compare, typename value_type>
+class map_value_compare {
+  template <typename Params>
+  friend class btree;
+
+  // Note: this `protected` is part of the API of std::map::value_compare. See
+  // https://en.cppreference.com/w/cpp/container/map/value_compare.
+ protected:
+  explicit map_value_compare(original_key_compare c) : comp(std::move(c)) {}
+
+  original_key_compare comp;  // NOLINT
+
+ public:
+  auto operator()(const value_type &lhs, const value_type &rhs) const
+      -> decltype(comp(lhs.first, rhs.first)) {
+    return comp(lhs.first, rhs.first);
+  }
+};
+
+template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
+          bool IsMulti, bool IsMap, typename SlotPolicy>
+struct common_params {
+  using original_key_compare = Compare;
+
+  // If Compare is a common comparator for a string-like type, then we adapt it
+  // to use heterogeneous lookup and to be a key-compare-to comparator.
+  // We also adapt the comparator to diagnose invalid comparators in debug mode.
+  // We disable this when `Compare` is invalid in a way that will cause
+  // adaptation to fail (having invalid return type) so that we can give a
+  // better compilation failure in static_assert_validation. If we don't do
+  // this, then there will be cascading compilation failures that are confusing
+  // for users.
+  using key_compare =
+      absl::conditional_t<!compare_has_valid_result_type<Compare, Key>(),
+                          Compare,
+                          typename key_compare_adapter<Compare, Key>::type>;
+
+  static constexpr bool kIsKeyCompareStringAdapted =
+      std::is_same<key_compare, StringBtreeDefaultLess>::value ||
+      std::is_same<key_compare, StringBtreeDefaultGreater>::value;
+  static constexpr bool kIsKeyCompareTransparent =
+      IsTransparent<original_key_compare>::value ||
+      kIsKeyCompareStringAdapted;
+  static constexpr bool kEnableGenerations =
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+      true;
+#else
+      false;
+#endif
+
+  // A type which indicates if we have a key-compare-to functor or a plain old
+  // key-compare functor.
+  using is_key_compare_to = btree_is_key_compare_to<key_compare, Key>;
+
+  using allocator_type = Alloc;
+  using key_type = Key;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+
+  using slot_policy = SlotPolicy;
+  using slot_type = typename slot_policy::slot_type;
+  using value_type = typename slot_policy::value_type;
+  using init_type = typename slot_policy::mutable_value_type;
+  using pointer = value_type *;
+  using const_pointer = const value_type *;
+  using reference = value_type &;
+  using const_reference = const value_type &;
+
+  using value_compare =
+      absl::conditional_t<IsMap,
+                          map_value_compare<original_key_compare, value_type>,
+                          original_key_compare>;
+  using is_map_container = std::integral_constant<bool, IsMap>;
+
+  // For the given lookup key type, returns whether we can have multiple
+  // equivalent keys in the btree. If this is a multi-container, then we can.
+  // Otherwise, we can have multiple equivalent keys only if all of the
+  // following conditions are met:
+  // - The comparator is transparent.
+  // - The lookup key type is not the same as key_type.
+  // - The comparator is not a StringBtreeDefault{Less,Greater} comparator
+  //   that we know has the same equivalence classes for all lookup types.
+  template <typename LookupKey>
+  constexpr static bool can_have_multiple_equivalent_keys() {
+    return IsMulti || (IsTransparent<key_compare>::value &&
+                       !std::is_same<LookupKey, Key>::value &&
+                       !kIsKeyCompareStringAdapted);
+  }
+
+  enum {
+    kTargetNodeSize = TargetNodeSize,
+
+    // Upper bound for the available space for slots. This is largest for leaf
+    // nodes, which have overhead of at least a pointer + 4 bytes (for storing
+    // 3 field_types and an enum).
+    kNodeSlotSpace =
+        TargetNodeSize - /*minimum overhead=*/(sizeof(void *) + 4),
+  };
+
+  // This is an integral type large enough to hold as many slots as will fit a
+  // node of TargetNodeSize bytes.
+  using node_count_type =
+      absl::conditional_t<(kNodeSlotSpace / sizeof(slot_type) >
+                           (std::numeric_limits<uint8_t>::max)()),
+                          uint16_t, uint8_t>;  // NOLINT
+
+  // The following methods are necessary for passing this struct as PolicyTraits
+  // for node_handle and/or are used within btree.
+  static value_type &element(slot_type *slot) {
+    return slot_policy::element(slot);
+  }
+  static const value_type &element(const slot_type *slot) {
+    return slot_policy::element(slot);
+  }
+  template <class... Args>
+  static void construct(Alloc *alloc, slot_type *slot, Args &&... args) {
+    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
+  }
+  static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
+    slot_policy::construct(alloc, slot, other);
+  }
+  static void destroy(Alloc *alloc, slot_type *slot) {
+    slot_policy::destroy(alloc, slot);
+  }
+  static void transfer(Alloc *alloc, slot_type *new_slot, slot_type *old_slot) {
+    slot_policy::transfer(alloc, new_slot, old_slot);
+  }
+};
+
+// An adapter class that converts a lower-bound compare into an upper-bound
+// compare. Note: there is no need to make a version of this adapter specialized
+// for key-compare-to functors because the upper-bound (the first value greater
+// than the input) is never an exact match.
+template <typename Compare>
+struct upper_bound_adapter {
+  explicit upper_bound_adapter(const Compare &c) : comp(c) {}
+  template <typename K1, typename K2>
+  bool operator()(const K1 &a, const K2 &b) const {
+    // Returns true when a is not greater than b.
+    return !compare_internal::compare_result_as_less_than(comp(b, a));
+  }
+
+ private:
+  Compare comp;
+};
+
+enum class MatchKind : uint8_t { kEq, kNe };
+
+template <typename V, bool IsCompareTo>
+struct SearchResult {
+  V value;
+  MatchKind match;
+
+  static constexpr bool HasMatch() { return true; }
+  bool IsEq() const { return match == MatchKind::kEq; }
+};
+
+// When we don't use CompareTo, `match` is not present.
+// This ensures that callers can't use it accidentally when it provides no
+// useful information.
+template <typename V>
+struct SearchResult<V, false> {
+  SearchResult() {}
+  explicit SearchResult(V v) : value(v) {}
+  SearchResult(V v, MatchKind /*match*/) : value(v) {}
+
+  V value;
+
+  static constexpr bool HasMatch() { return false; }
+  static constexpr bool IsEq() { return false; }
+};
+
+// A node in the btree holding. The same node type is used for both internal
+// and leaf nodes in the btree, though the nodes are allocated in such a way
+// that the children array is only valid in internal nodes.
+template <typename Params>
+class btree_node {
+  using is_key_compare_to = typename Params::is_key_compare_to;
+  using field_type = typename Params::node_count_type;
+  using allocator_type = typename Params::allocator_type;
+  using slot_type = typename Params::slot_type;
+  using original_key_compare = typename Params::original_key_compare;
+
+ public:
+  using params_type = Params;
+  using key_type = typename Params::key_type;
+  using value_type = typename Params::value_type;
+  using pointer = typename Params::pointer;
+  using const_pointer = typename Params::const_pointer;
+  using reference = typename Params::reference;
+  using const_reference = typename Params::const_reference;
+  using key_compare = typename Params::key_compare;
+  using size_type = typename Params::size_type;
+  using difference_type = typename Params::difference_type;
+
+  // Btree decides whether to use linear node search as follows:
+  //   - If the comparator expresses a preference, use that.
+  //   - If the key expresses a preference, use that.
+  //   - If the key is arithmetic and the comparator is std::less or
+  //     std::greater, choose linear.
+  //   - Otherwise, choose binary.
+  // TODO(ezb): Might make sense to add condition(s) based on node-size.
+  using use_linear_search = std::integral_constant<
+      bool, has_linear_node_search_preference<original_key_compare>::value
+                ? prefers_linear_node_search<original_key_compare>::value
+            : has_linear_node_search_preference<key_type>::value
+                ? prefers_linear_node_search<key_type>::value
+                : std::is_arithmetic<key_type>::value &&
+                      (std::is_same<std::less<key_type>,
+                                    original_key_compare>::value ||
+                       std::is_same<std::greater<key_type>,
+                                    original_key_compare>::value)>;
+
+  // This class is organized by absl::container_internal::Layout as if it had
+  // the following structure:
+  //   // A pointer to the node's parent.
+  //   btree_node *parent;
+  //
+  //   // When ABSL_BTREE_ENABLE_GENERATIONS is defined, we also have a
+  //   // generation integer in order to check that when iterators are
+  //   // used, they haven't been invalidated already. Only the generation on
+  //   // the root is used, but we have one on each node because whether a node
+  //   // is root or not can change.
+  //   uint32_t generation;
+  //
+  //   // The position of the node in the node's parent.
+  //   field_type position;
+  //   // The index of the first populated value in `values`.
+  //   // TODO(ezb): right now, `start` is always 0. Update insertion/merge
+  //   // logic to allow for floating storage within nodes.
+  //   field_type start;
+  //   // The index after the last populated value in `values`. Currently, this
+  //   // is the same as the count of values.
+  //   field_type finish;
+  //   // The maximum number of values the node can hold. This is an integer in
+  //   // [1, kNodeSlots] for root leaf nodes, kNodeSlots for non-root leaf
+  //   // nodes, and kInternalNodeMaxCount (as a sentinel value) for internal
+  //   // nodes (even though there are still kNodeSlots values in the node).
+  //   // TODO(ezb): make max_count use only 4 bits and record log2(capacity)
+  //   // to free extra bits for is_root, etc.
+  //   field_type max_count;
+  //
+  //   // The array of values. The capacity is `max_count` for leaf nodes and
+  //   // kNodeSlots for internal nodes. Only the values in
+  //   // [start, finish) have been initialized and are valid.
+  //   slot_type values[max_count];
+  //
+  //   // The array of child pointers. The keys in children[i] are all less
+  //   // than key(i). The keys in children[i + 1] are all greater than key(i).
+  //   // There are 0 children for leaf nodes and kNodeSlots + 1 children for
+  //   // internal nodes.
+  //   btree_node *children[kNodeSlots + 1];
+  //
+  // This class is only constructed by EmptyNodeType. Normally, pointers to the
+  // layout above are allocated, cast to btree_node*, and de-allocated within
+  // the btree implementation.
+  ~btree_node() = default;
+  btree_node(btree_node const &) = delete;
+  btree_node &operator=(btree_node const &) = delete;
+
+  // Public for EmptyNodeType.
+  constexpr static size_type Alignment() {
+    static_assert(LeafLayout(1).Alignment() == InternalLayout().Alignment(),
+                  "Alignment of all nodes must be equal.");
+    return InternalLayout().Alignment();
+  }
+
+ protected:
+  btree_node() = default;
+
+ private:
+  using layout_type =
+      absl::container_internal::Layout<btree_node *, uint32_t, field_type,
+                                       slot_type, btree_node *>;
+  constexpr static size_type SizeWithNSlots(size_type n) {
+    return layout_type(
+               /*parent*/ 1,
+               /*generation*/ params_type::kEnableGenerations ? 1 : 0,
+               /*position, start, finish, max_count*/ 4,
+               /*slots*/ n,
+               /*children*/ 0)
+        .AllocSize();
+  }
+  // A lower bound for the overhead of fields other than slots in a leaf node.
+  constexpr static size_type MinimumOverhead() {
+    return SizeWithNSlots(1) - sizeof(slot_type);
+  }
+
+  // Compute how many values we can fit onto a leaf node taking into account
+  // padding.
+  constexpr static size_type NodeTargetSlots(const size_type begin,
+                                             const size_type end) {
+    return begin == end ? begin
+                        : SizeWithNSlots((begin + end) / 2 + 1) >
+                                  params_type::kTargetNodeSize
+                              ? NodeTargetSlots(begin, (begin + end) / 2)
+                              : NodeTargetSlots((begin + end) / 2 + 1, end);
+  }
+
+  enum {
+    kTargetNodeSize = params_type::kTargetNodeSize,
+    kNodeTargetSlots = NodeTargetSlots(0, params_type::kTargetNodeSize),
+
+    // We need a minimum of 3 slots per internal node in order to perform
+    // splitting (1 value for the two nodes involved in the split and 1 value
+    // propagated to the parent as the delimiter for the split). For performance
+    // reasons, we don't allow 3 slots-per-node due to bad worst case occupancy
+    // of 1/3 (for a node, not a b-tree).
+    kMinNodeSlots = 4,
+
+    kNodeSlots =
+        kNodeTargetSlots >= kMinNodeSlots ? kNodeTargetSlots : kMinNodeSlots,
+
+    // The node is internal (i.e. is not a leaf node) if and only if `max_count`
+    // has this value.
+    kInternalNodeMaxCount = 0,
+  };
+
+  // Leaves can have less than kNodeSlots values.
+  constexpr static layout_type LeafLayout(const int slot_count = kNodeSlots) {
+    return layout_type(
+        /*parent*/ 1,
+        /*generation*/ params_type::kEnableGenerations ? 1 : 0,
+        /*position, start, finish, max_count*/ 4,
+        /*slots*/ slot_count,
+        /*children*/ 0);
+  }
+  constexpr static layout_type InternalLayout() {
+    return layout_type(
+        /*parent*/ 1,
+        /*generation*/ params_type::kEnableGenerations ? 1 : 0,
+        /*position, start, finish, max_count*/ 4,
+        /*slots*/ kNodeSlots,
+        /*children*/ kNodeSlots + 1);
+  }
+  constexpr static size_type LeafSize(const int slot_count = kNodeSlots) {
+    return LeafLayout(slot_count).AllocSize();
+  }
+  constexpr static size_type InternalSize() {
+    return InternalLayout().AllocSize();
+  }
+
+  // N is the index of the type in the Layout definition.
+  // ElementType<N> is the Nth type in the Layout definition.
+  template <size_type N>
+  inline typename layout_type::template ElementType<N> *GetField() {
+    // We assert that we don't read from values that aren't there.
+    assert(N < 4 || is_internal());
+    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
+  }
+  template <size_type N>
+  inline const typename layout_type::template ElementType<N> *GetField() const {
+    assert(N < 4 || is_internal());
+    return InternalLayout().template Pointer<N>(
+        reinterpret_cast<const char *>(this));
+  }
+  void set_parent(btree_node *p) { *GetField<0>() = p; }
+  field_type &mutable_finish() { return GetField<2>()[2]; }
+  slot_type *slot(int i) { return &GetField<3>()[i]; }
+  slot_type *start_slot() { return slot(start()); }
+  slot_type *finish_slot() { return slot(finish()); }
+  const slot_type *slot(int i) const { return &GetField<3>()[i]; }
+  void set_position(field_type v) { GetField<2>()[0] = v; }
+  void set_start(field_type v) { GetField<2>()[1] = v; }
+  void set_finish(field_type v) { GetField<2>()[2] = v; }
+  // This method is only called by the node init methods.
+  void set_max_count(field_type v) { GetField<2>()[3] = v; }
+
+ public:
+  // Whether this is a leaf node or not. This value doesn't change after the
+  // node is created.
+  bool is_leaf() const { return GetField<2>()[3] != kInternalNodeMaxCount; }
+  // Whether this is an internal node or not. This value doesn't change after
+  // the node is created.
+  bool is_internal() const { return !is_leaf(); }
+
+  // Getter for the position of this node in its parent.
+  field_type position() const { return GetField<2>()[0]; }
+
+  // Getter for the offset of the first value in the `values` array.
+  field_type start() const {
+    // TODO(ezb): when floating storage is implemented, return GetField<2>()[1];
+    assert(GetField<2>()[1] == 0);
+    return 0;
+  }
+
+  // Getter for the offset after the last value in the `values` array.
+  field_type finish() const { return GetField<2>()[2]; }
+
+  // Getters for the number of values stored in this node.
+  field_type count() const {
+    assert(finish() >= start());
+    return finish() - start();
+  }
+  field_type max_count() const {
+    // Internal nodes have max_count==kInternalNodeMaxCount.
+    // Leaf nodes have max_count in [1, kNodeSlots].
+    const field_type max_count = GetField<2>()[3];
+    return max_count == field_type{kInternalNodeMaxCount}
+               ? field_type{kNodeSlots}
+               : max_count;
+  }
+
+  // Getter for the parent of this node.
+  btree_node *parent() const { return *GetField<0>(); }
+  // Getter for whether the node is the root of the tree. The parent of the
+  // root of the tree is the leftmost node in the tree which is guaranteed to
+  // be a leaf.
+  bool is_root() const { return parent()->is_leaf(); }
+  void make_root() {
+    assert(parent()->is_root());
+    set_generation(parent()->generation());
+    set_parent(parent()->parent());
+  }
+
+  // Gets the root node's generation integer, which is the one used by the tree.
+  uint32_t *get_root_generation() const {
+    assert(params_type::kEnableGenerations);
+    const btree_node *curr = this;
+    for (; !curr->is_root(); curr = curr->parent()) continue;
+    return const_cast<uint32_t *>(&curr->GetField<1>()[0]);
+  }
+
+  // Returns the generation for iterator validation.
+  uint32_t generation() const {
+    return params_type::kEnableGenerations ? *get_root_generation() : 0;
+  }
+  // Updates generation. Should only be called on a root node or during node
+  // initialization.
+  void set_generation(uint32_t generation) {
+    if (params_type::kEnableGenerations) GetField<1>()[0] = generation;
+  }
+  // Updates the generation. We do this whenever the node is mutated.
+  void next_generation() {
+    if (params_type::kEnableGenerations) ++*get_root_generation();
+  }
+
+  // Getters for the key/value at position i in the node.
+  const key_type &key(int i) const { return params_type::key(slot(i)); }
+  reference value(int i) { return params_type::element(slot(i)); }
+  const_reference value(int i) const { return params_type::element(slot(i)); }
+
+  // Getters/setter for the child at position i in the node.
+  btree_node *child(int i) const { return GetField<4>()[i]; }
+  btree_node *start_child() const { return child(start()); }
+  btree_node *&mutable_child(int i) { return GetField<4>()[i]; }
+  void clear_child(int i) {
+    absl::container_internal::SanitizerPoisonObject(&mutable_child(i));
+  }
+  void set_child(int i, btree_node *c) {
+    absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i));
+    mutable_child(i) = c;
+    c->set_position(i);
+  }
+  void init_child(int i, btree_node *c) {
+    set_child(i, c);
+    c->set_parent(this);
+  }
+
+  // Returns the position of the first value whose key is not less than k.
+  template <typename K>
+  SearchResult<int, is_key_compare_to::value> lower_bound(
+      const K &k, const key_compare &comp) const {
+    return use_linear_search::value ? linear_search(k, comp)
+                                    : binary_search(k, comp);
+  }
+  // Returns the position of the first value whose key is greater than k.
+  template <typename K>
+  int upper_bound(const K &k, const key_compare &comp) const {
+    auto upper_compare = upper_bound_adapter<key_compare>(comp);
+    return use_linear_search::value ? linear_search(k, upper_compare).value
+                                    : binary_search(k, upper_compare).value;
+  }
+
+  template <typename K, typename Compare>
+  SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
+  linear_search(const K &k, const Compare &comp) const {
+    return linear_search_impl(k, start(), finish(), comp,
+                              btree_is_key_compare_to<Compare, key_type>());
+  }
+
+  template <typename K, typename Compare>
+  SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
+  binary_search(const K &k, const Compare &comp) const {
+    return binary_search_impl(k, start(), finish(), comp,
+                              btree_is_key_compare_to<Compare, key_type>());
+  }
+
+  // Returns the position of the first value whose key is not less than k using
+  // linear search performed using plain compare.
+  template <typename K, typename Compare>
+  SearchResult<int, false> linear_search_impl(
+      const K &k, int s, const int e, const Compare &comp,
+      std::false_type /* IsCompareTo */) const {
+    while (s < e) {
+      if (!comp(key(s), k)) {
+        break;
+      }
+      ++s;
+    }
+    return SearchResult<int, false>{s};
+  }
+
+  // Returns the position of the first value whose key is not less than k using
+  // linear search performed using compare-to.
+  template <typename K, typename Compare>
+  SearchResult<int, true> linear_search_impl(
+      const K &k, int s, const int e, const Compare &comp,
+      std::true_type /* IsCompareTo */) const {
+    while (s < e) {
+      const absl::weak_ordering c = comp(key(s), k);
+      if (c == 0) {
+        return {s, MatchKind::kEq};
+      } else if (c > 0) {
+        break;
+      }
+      ++s;
+    }
+    return {s, MatchKind::kNe};
+  }
+
+  // Returns the position of the first value whose key is not less than k using
+  // binary search performed using plain compare.
+  template <typename K, typename Compare>
+  SearchResult<int, false> binary_search_impl(
+      const K &k, int s, int e, const Compare &comp,
+      std::false_type /* IsCompareTo */) const {
+    while (s != e) {
+      const int mid = (s + e) >> 1;
+      if (comp(key(mid), k)) {
+        s = mid + 1;
+      } else {
+        e = mid;
+      }
+    }
+    return SearchResult<int, false>{s};
+  }
+
+  // Returns the position of the first value whose key is not less than k using
+  // binary search performed using compare-to.
+  template <typename K, typename CompareTo>
+  SearchResult<int, true> binary_search_impl(
+      const K &k, int s, int e, const CompareTo &comp,
+      std::true_type /* IsCompareTo */) const {
+    if (params_type::template can_have_multiple_equivalent_keys<K>()) {
+      MatchKind exact_match = MatchKind::kNe;
+      while (s != e) {
+        const int mid = (s + e) >> 1;
+        const absl::weak_ordering c = comp(key(mid), k);
+        if (c < 0) {
+          s = mid + 1;
+        } else {
+          e = mid;
+          if (c == 0) {
+            // Need to return the first value whose key is not less than k,
+            // which requires continuing the binary search if there could be
+            // multiple equivalent keys.
+            exact_match = MatchKind::kEq;
+          }
+        }
+      }
+      return {s, exact_match};
+    } else {  // Can't have multiple equivalent keys.
+      while (s != e) {
+        const int mid = (s + e) >> 1;
+        const absl::weak_ordering c = comp(key(mid), k);
+        if (c < 0) {
+          s = mid + 1;
+        } else if (c > 0) {
+          e = mid;
+        } else {
+          return {mid, MatchKind::kEq};
+        }
+      }
+      return {s, MatchKind::kNe};
+    }
+  }
+
+  // Emplaces a value at position i, shifting all existing values and
+  // children at positions >= i to the right by 1.
+  template <typename... Args>
+  void emplace_value(size_type i, allocator_type *alloc, Args &&... args);
+
+  // Removes the values at positions [i, i + to_erase), shifting all existing
+  // values and children after that range to the left by to_erase. Clears all
+  // children between [i, i + to_erase).
+  void remove_values(field_type i, field_type to_erase, allocator_type *alloc);
+
+  // Rebalances a node with its right sibling.
+  void rebalance_right_to_left(int to_move, btree_node *right,
+                               allocator_type *alloc);
+  void rebalance_left_to_right(int to_move, btree_node *right,
+                               allocator_type *alloc);
+
+  // Splits a node, moving a portion of the node's values to its right sibling.
+  void split(int insert_position, btree_node *dest, allocator_type *alloc);
+
+  // Merges a node with its right sibling, moving all of the values and the
+  // delimiting key in the parent node onto itself, and deleting the src node.
+  void merge(btree_node *src, allocator_type *alloc);
+
+  // Node allocation/deletion routines.
+  void init_leaf(int max_count, btree_node *parent) {
+    set_generation(0);
+    set_parent(parent);
+    set_position(0);
+    set_start(0);
+    set_finish(0);
+    set_max_count(max_count);
+    absl::container_internal::SanitizerPoisonMemoryRegion(
+        start_slot(), max_count * sizeof(slot_type));
+  }
+  void init_internal(btree_node *parent) {
+    init_leaf(kNodeSlots, parent);
+    // Set `max_count` to a sentinel value to indicate that this node is
+    // internal.
+    set_max_count(kInternalNodeMaxCount);
+    absl::container_internal::SanitizerPoisonMemoryRegion(
+        &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *));
+  }
+
+  static void deallocate(const size_type size, btree_node *node,
+                         allocator_type *alloc) {
+    absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
+  }
+
+  // Deletes a node and all of its children.
+  static void clear_and_delete(btree_node *node, allocator_type *alloc);
+
+ private:
+  template <typename... Args>
+  void value_init(const field_type i, allocator_type *alloc, Args &&... args) {
+    next_generation();
+    absl::container_internal::SanitizerUnpoisonObject(slot(i));
+    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
+  }
+  void value_destroy(const field_type i, allocator_type *alloc) {
+    next_generation();
+    params_type::destroy(alloc, slot(i));
+    absl::container_internal::SanitizerPoisonObject(slot(i));
+  }
+  void value_destroy_n(const field_type i, const field_type n,
+                       allocator_type *alloc) {
+    next_generation();
+    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) {
+      params_type::destroy(alloc, s);
+      absl::container_internal::SanitizerPoisonObject(s);
+    }
+  }
+
+  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) {
+    absl::container_internal::SanitizerUnpoisonObject(dest);
+    params_type::transfer(alloc, dest, src);
+    absl::container_internal::SanitizerPoisonObject(src);
+  }
+
+  // Transfers value from slot `src_i` in `src_node` to slot `dest_i` in `this`.
+  void transfer(const size_type dest_i, const size_type src_i,
+                btree_node *src_node, allocator_type *alloc) {
+    next_generation();
+    transfer(slot(dest_i), src_node->slot(src_i), alloc);
+  }
+
+  // Transfers `n` values starting at value `src_i` in `src_node` into the
+  // values starting at value `dest_i` in `this`.
+  void transfer_n(const size_type n, const size_type dest_i,
+                  const size_type src_i, btree_node *src_node,
+                  allocator_type *alloc) {
+    next_generation();
+    for (slot_type *src = src_node->slot(src_i), *end = src + n,
+                   *dest = slot(dest_i);
+         src != end; ++src, ++dest) {
+      transfer(dest, src, alloc);
+    }
+  }
+
+  // Same as above, except that we start at the end and work our way to the
+  // beginning.
+  void transfer_n_backward(const size_type n, const size_type dest_i,
+                           const size_type src_i, btree_node *src_node,
+                           allocator_type *alloc) {
+    next_generation();
+    for (slot_type *src = src_node->slot(src_i + n - 1), *end = src - n,
+                   *dest = slot(dest_i + n - 1);
+         src != end; --src, --dest) {
+      transfer(dest, src, alloc);
+    }
+  }
+
+  template <typename P>
+  friend class btree;
+  template <typename N, typename R, typename P>
+  friend class btree_iterator;
+  friend class BtreeNodePeer;
+  friend struct btree_access;
+};
+
+template <typename Node, typename Reference, typename Pointer>
+class btree_iterator {
+  using key_type = typename Node::key_type;
+  using size_type = typename Node::size_type;
+  using params_type = typename Node::params_type;
+  using is_map_container = typename params_type::is_map_container;
+
+  using node_type = Node;
+  using normal_node = typename std::remove_const<Node>::type;
+  using const_node = const Node;
+  using normal_pointer = typename params_type::pointer;
+  using normal_reference = typename params_type::reference;
+  using const_pointer = typename params_type::const_pointer;
+  using const_reference = typename params_type::const_reference;
+  using slot_type = typename params_type::slot_type;
+
+  using iterator =
+     btree_iterator<normal_node, normal_reference, normal_pointer>;
+  using const_iterator =
+      btree_iterator<const_node, const_reference, const_pointer>;
+
+ public:
+  // These aliases are public for std::iterator_traits.
+  using difference_type = typename Node::difference_type;
+  using value_type = typename params_type::value_type;
+  using pointer = Pointer;
+  using reference = Reference;
+  using iterator_category = std::bidirectional_iterator_tag;
+
+  btree_iterator() : btree_iterator(nullptr, -1) {}
+  explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
+  btree_iterator(Node *n, int p) : node_(n), position_(p) {
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+    // Use `~uint32_t{}` as a sentinel value for iterator generations so it
+    // doesn't match the initial value for the actual generation.
+    generation_ = n != nullptr ? n->generation() : ~uint32_t{};
+#endif
+  }
+
+  // NOTE: this SFINAE allows for implicit conversions from iterator to
+  // const_iterator, but it specifically avoids hiding the copy constructor so
+  // that the trivial one will be used when possible.
+  template <typename N, typename R, typename P,
+            absl::enable_if_t<
+                std::is_same<btree_iterator<N, R, P>, iterator>::value &&
+                    std::is_same<btree_iterator, const_iterator>::value,
+                int> = 0>
+  btree_iterator(const btree_iterator<N, R, P> other)  // NOLINT
+      : node_(other.node_), position_(other.position_) {
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+    generation_ = other.generation_;
+#endif
+  }
+
+  bool operator==(const iterator &other) const {
+    return node_ == other.node_ && position_ == other.position_;
+  }
+  bool operator==(const const_iterator &other) const {
+    return node_ == other.node_ && position_ == other.position_;
+  }
+  bool operator!=(const iterator &other) const {
+    return node_ != other.node_ || position_ != other.position_;
+  }
+  bool operator!=(const const_iterator &other) const {
+    return node_ != other.node_ || position_ != other.position_;
+  }
+
+  // Accessors for the key/value the iterator is pointing at.
+  reference operator*() const {
+    ABSL_HARDENING_ASSERT(node_ != nullptr);
+    ABSL_HARDENING_ASSERT(node_->start() <= position_);
+    ABSL_HARDENING_ASSERT(node_->finish() > position_);
+    assert_valid_generation();
+    return node_->value(position_);
+  }
+  pointer operator->() const { return &operator*(); }
+
+  btree_iterator &operator++() {
+    increment();
+    return *this;
+  }
+  btree_iterator &operator--() {
+    decrement();
+    return *this;
+  }
+  btree_iterator operator++(int) {
+    btree_iterator tmp = *this;
+    ++*this;
+    return tmp;
+  }
+  btree_iterator operator--(int) {
+    btree_iterator tmp = *this;
+    --*this;
+    return tmp;
+  }
+
+ private:
+  friend iterator;
+  friend const_iterator;
+  template <typename Params>
+  friend class btree;
+  template <typename Tree>
+  friend class btree_container;
+  template <typename Tree>
+  friend class btree_set_container;
+  template <typename Tree>
+  friend class btree_map_container;
+  template <typename Tree>
+  friend class btree_multiset_container;
+  template <typename TreeType, typename CheckerType>
+  friend class base_checker;
+  friend struct btree_access;
+
+  // This SFINAE allows explicit conversions from const_iterator to
+  // iterator, but also avoids hiding the copy constructor.
+  // NOTE: the const_cast is safe because this constructor is only called by
+  // non-const methods and the container owns the nodes.
+  template <typename N, typename R, typename P,
+            absl::enable_if_t<
+                std::is_same<btree_iterator<N, R, P>, const_iterator>::value &&
+                    std::is_same<btree_iterator, iterator>::value,
+                int> = 0>
+  explicit btree_iterator(const btree_iterator<N, R, P> other)
+      : node_(const_cast<node_type *>(other.node_)),
+        position_(other.position_) {
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+    generation_ = other.generation_;
+#endif
+  }
+
+  // Increment/decrement the iterator.
+  void increment() {
+    assert_valid_generation();
+    if (node_->is_leaf() && ++position_ < node_->finish()) {
+      return;
+    }
+    increment_slow();
+  }
+  void increment_slow();
+
+  void decrement() {
+    assert_valid_generation();
+    if (node_->is_leaf() && --position_ >= node_->start()) {
+      return;
+    }
+    decrement_slow();
+  }
+  void decrement_slow();
+
+  // Updates the generation. For use internally right before we return an
+  // iterator to the user.
+  void update_generation() {
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+    if (node_ != nullptr) generation_ = node_->generation();
+#endif
+  }
+
+  const key_type &key() const { return node_->key(position_); }
+  decltype(std::declval<Node *>()->slot(0)) slot() {
+    return node_->slot(position_);
+  }
+
+  void assert_valid_generation() const {
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+    if (node_ != nullptr && node_->generation() != generation_) {
+      ABSL_INTERNAL_LOG(
+          FATAL,
+          "Attempting to use an invalidated iterator. The corresponding b-tree "
+          "container has been mutated since this iterator was constructed.");
+    }
+#endif
+  }
+
+  // The node in the tree the iterator is pointing at.
+  Node *node_;
+  // The position within the node of the tree the iterator is pointing at.
+  // NOTE: this is an int rather than a field_type because iterators can point
+  // to invalid positions (such as -1) in certain circumstances.
+  int position_;
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+  // Used to check that the iterator hasn't been invalidated.
+  uint32_t generation_;
+#endif
+};
+
+template <typename Params>
+class btree {
+  using node_type = btree_node<Params>;
+  using is_key_compare_to = typename Params::is_key_compare_to;
+  using field_type = typename node_type::field_type;
+
+  // We use a static empty node for the root/leftmost/rightmost of empty btrees
+  // in order to avoid branching in begin()/end().
+  struct alignas(node_type::Alignment()) EmptyNodeType : node_type {
+    using field_type = typename node_type::field_type;
+    node_type *parent;
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+    uint32_t generation = 0;
+#endif
+    field_type position = 0;
+    field_type start = 0;
+    field_type finish = 0;
+    // max_count must be != kInternalNodeMaxCount (so that this node is regarded
+    // as a leaf node). max_count() is never called when the tree is empty.
+    field_type max_count = node_type::kInternalNodeMaxCount + 1;
+
+#ifdef _MSC_VER
+    // MSVC has constexpr code generations bugs here.
+    EmptyNodeType() : parent(this) {}
+#else
+    constexpr EmptyNodeType(node_type *p) : parent(p) {}
+#endif
+  };
+
+  static node_type *EmptyNode() {
+#ifdef _MSC_VER
+    static EmptyNodeType *empty_node = new EmptyNodeType;
+    // This assert fails on some other construction methods.
+    assert(empty_node->parent == empty_node);
+    return empty_node;
+#else
+    static constexpr EmptyNodeType empty_node(
+        const_cast<EmptyNodeType *>(&empty_node));
+    return const_cast<EmptyNodeType *>(&empty_node);
+#endif
+  }
+
+  enum : uint32_t {
+    kNodeSlots = node_type::kNodeSlots,
+    kMinNodeValues = kNodeSlots / 2,
+  };
+
+  struct node_stats {
+    using size_type = typename Params::size_type;
+
+    node_stats(size_type l, size_type i) : leaf_nodes(l), internal_nodes(i) {}
+
+    node_stats &operator+=(const node_stats &other) {
+      leaf_nodes += other.leaf_nodes;
+      internal_nodes += other.internal_nodes;
+      return *this;
+    }
+
+    size_type leaf_nodes;
+    size_type internal_nodes;
+  };
+
+ public:
+  using key_type = typename Params::key_type;
+  using value_type = typename Params::value_type;
+  using size_type = typename Params::size_type;
+  using difference_type = typename Params::difference_type;
+  using key_compare = typename Params::key_compare;
+  using original_key_compare = typename Params::original_key_compare;
+  using value_compare = typename Params::value_compare;
+  using allocator_type = typename Params::allocator_type;
+  using reference = typename Params::reference;
+  using const_reference = typename Params::const_reference;
+  using pointer = typename Params::pointer;
+  using const_pointer = typename Params::const_pointer;
+  using iterator =
+      typename btree_iterator<node_type, reference, pointer>::iterator;
+  using const_iterator = typename iterator::const_iterator;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  using node_handle_type = node_handle<Params, Params, allocator_type>;
+
+  // Internal types made public for use by btree_container types.
+  using params_type = Params;
+  using slot_type = typename Params::slot_type;
+
+ private:
+  // Copies or moves (depending on the template parameter) the values in
+  // other into this btree in their order in other. This btree must be empty
+  // before this method is called. This method is used in copy construction,
+  // copy assignment, and move assignment.
+  template <typename Btree>
+  void copy_or_move_values_in_order(Btree &other);
+
+  // Validates that various assumptions/requirements are true at compile time.
+  constexpr static bool static_assert_validation();
+
+ public:
+  btree(const key_compare &comp, const allocator_type &alloc)
+      : root_(EmptyNode()), rightmost_(comp, alloc, EmptyNode()), size_(0) {}
+
+  btree(const btree &other) : btree(other, other.allocator()) {}
+  btree(const btree &other, const allocator_type &alloc)
+      : btree(other.key_comp(), alloc) {
+    copy_or_move_values_in_order(other);
+  }
+  btree(btree &&other) noexcept
+      : root_(absl::exchange(other.root_, EmptyNode())),
+        rightmost_(std::move(other.rightmost_)),
+        size_(absl::exchange(other.size_, 0)) {
+    other.mutable_rightmost() = EmptyNode();
+  }
+  btree(btree &&other, const allocator_type &alloc)
+      : btree(other.key_comp(), alloc) {
+    if (alloc == other.allocator()) {
+      swap(other);
+    } else {
+      // Move values from `other` one at a time when allocators are different.
+      copy_or_move_values_in_order(other);
+    }
+  }
+
+  ~btree() {
+    // Put static_asserts in destructor to avoid triggering them before the type
+    // is complete.
+    static_assert(static_assert_validation(), "This call must be elided.");
+    clear();
+  }
+
+  // Assign the contents of other to *this.
+  btree &operator=(const btree &other);
+  btree &operator=(btree &&other) noexcept;
+
+  iterator begin() { return iterator(leftmost()); }
+  const_iterator begin() const { return const_iterator(leftmost()); }
+  iterator end() { return iterator(rightmost(), rightmost()->finish()); }
+  const_iterator end() const {
+    return const_iterator(rightmost(), rightmost()->finish());
+  }
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  // Finds the first element whose key is not less than `key`.
+  template <typename K>
+  iterator lower_bound(const K &key) {
+    return internal_end(internal_lower_bound(key).value);
+  }
+  template <typename K>
+  const_iterator lower_bound(const K &key) const {
+    return internal_end(internal_lower_bound(key).value);
+  }
+
+  // Finds the first element whose key is not less than `key` and also returns
+  // whether that element is equal to `key`.
+  template <typename K>
+  std::pair<iterator, bool> lower_bound_equal(const K &key) const;
+
+  // Finds the first element whose key is greater than `key`.
+  template <typename K>
+  iterator upper_bound(const K &key) {
+    return internal_end(internal_upper_bound(key));
+  }
+  template <typename K>
+  const_iterator upper_bound(const K &key) const {
+    return internal_end(internal_upper_bound(key));
+  }
+
+  // Finds the range of values which compare equal to key. The first member of
+  // the returned pair is equal to lower_bound(key). The second member of the
+  // pair is equal to upper_bound(key).
+  template <typename K>
+  std::pair<iterator, iterator> equal_range(const K &key);
+  template <typename K>
+  std::pair<const_iterator, const_iterator> equal_range(const K &key) const {
+    return const_cast<btree *>(this)->equal_range(key);
+  }
+
+  // Inserts a value into the btree only if it does not already exist. The
+  // boolean return value indicates whether insertion succeeded or failed.
+  // Requirement: if `key` already exists in the btree, does not consume `args`.
+  // Requirement: `key` is never referenced after consuming `args`.
+  template <typename K, typename... Args>
+  std::pair<iterator, bool> insert_unique(const K &key, Args &&... args);
+
+  // Inserts with hint. Checks to see if the value should be placed immediately
+  // before `position` in the tree. If so, then the insertion will take
+  // amortized constant time. If not, the insertion will take amortized
+  // logarithmic time as if a call to insert_unique() were made.
+  // Requirement: if `key` already exists in the btree, does not consume `args`.
+  // Requirement: `key` is never referenced after consuming `args`.
+  template <typename K, typename... Args>
+  std::pair<iterator, bool> insert_hint_unique(iterator position,
+                                               const K &key,
+                                               Args &&... args);
+
+  // Insert a range of values into the btree.
+  // Note: the first overload avoids constructing a value_type if the key
+  // already exists in the btree.
+  template <typename InputIterator,
+            typename = decltype(std::declval<const key_compare &>()(
+                params_type::key(*std::declval<InputIterator>()),
+                std::declval<const key_type &>()))>
+  void insert_iterator_unique(InputIterator b, InputIterator e, int);
+  // We need the second overload for cases in which we need to construct a
+  // value_type in order to compare it with the keys already in the btree.
+  template <typename InputIterator>
+  void insert_iterator_unique(InputIterator b, InputIterator e, char);
+
+  // Inserts a value into the btree.
+  template <typename ValueType>
+  iterator insert_multi(const key_type &key, ValueType &&v);
+
+  // Inserts a value into the btree.
+  template <typename ValueType>
+  iterator insert_multi(ValueType &&v) {
+    return insert_multi(params_type::key(v), std::forward<ValueType>(v));
+  }
+
+  // Insert with hint. Check to see if the value should be placed immediately
+  // before position in the tree. If it does, then the insertion will take
+  // amortized constant time. If not, the insertion will take amortized
+  // logarithmic time as if a call to insert_multi(v) were made.
+  template <typename ValueType>
+  iterator insert_hint_multi(iterator position, ValueType &&v);
+
+  // Insert a range of values into the btree.
+  template <typename InputIterator>
+  void insert_iterator_multi(InputIterator b, InputIterator e);
+
+  // Erase the specified iterator from the btree. The iterator must be valid
+  // (i.e. not equal to end()).  Return an iterator pointing to the node after
+  // the one that was erased (or end() if none exists).
+  // Requirement: does not read the value at `*iter`.
+  iterator erase(iterator iter);
+
+  // Erases range. Returns the number of keys erased and an iterator pointing
+  // to the element after the last erased element.
+  std::pair<size_type, iterator> erase_range(iterator begin, iterator end);
+
+  // Finds an element with key equivalent to `key` or returns `end()` if `key`
+  // is not present.
+  template <typename K>
+  iterator find(const K &key) {
+    return internal_end(internal_find(key));
+  }
+  template <typename K>
+  const_iterator find(const K &key) const {
+    return internal_end(internal_find(key));
+  }
+
+  // Clear the btree, deleting all of the values it contains.
+  void clear();
+
+  // Swaps the contents of `this` and `other`.
+  void swap(btree &other);
+
+  const key_compare &key_comp() const noexcept {
+    return rightmost_.template get<0>();
+  }
+  template <typename K1, typename K2>
+  bool compare_keys(const K1 &a, const K2 &b) const {
+    return compare_internal::compare_result_as_less_than(key_comp()(a, b));
+  }
+
+  value_compare value_comp() const {
+    return value_compare(original_key_compare(key_comp()));
+  }
+
+  // Verifies the structure of the btree.
+  void verify() const;
+
+  // Size routines.
+  size_type size() const { return size_; }
+  size_type max_size() const { return (std::numeric_limits<size_type>::max)(); }
+  bool empty() const { return size_ == 0; }
+
+  // The height of the btree. An empty tree will have height 0.
+  size_type height() const {
+    size_type h = 0;
+    if (!empty()) {
+      // Count the length of the chain from the leftmost node up to the
+      // root. We actually count from the root back around to the level below
+      // the root, but the calculation is the same because of the circularity
+      // of that traversal.
+      const node_type *n = root();
+      do {
+        ++h;
+        n = n->parent();
+      } while (n != root());
+    }
+    return h;
+  }
+
+  // The number of internal, leaf and total nodes used by the btree.
+  size_type leaf_nodes() const { return internal_stats(root()).leaf_nodes; }
+  size_type internal_nodes() const {
+    return internal_stats(root()).internal_nodes;
+  }
+  size_type nodes() const {
+    node_stats stats = internal_stats(root());
+    return stats.leaf_nodes + stats.internal_nodes;
+  }
+
+  // The total number of bytes used by the btree.
+  // TODO(b/169338300): update to support node_btree_*.
+  size_type bytes_used() const {
+    node_stats stats = internal_stats(root());
+    if (stats.leaf_nodes == 1 && stats.internal_nodes == 0) {
+      return sizeof(*this) + node_type::LeafSize(root()->max_count());
+    } else {
+      return sizeof(*this) + stats.leaf_nodes * node_type::LeafSize() +
+             stats.internal_nodes * node_type::InternalSize();
+    }
+  }
+
+  // The average number of bytes used per value stored in the btree assuming
+  // random insertion order.
+  static double average_bytes_per_value() {
+    // The expected number of values per node with random insertion order is the
+    // average of the maximum and minimum numbers of values per node.
+    const double expected_values_per_node =
+        (kNodeSlots + kMinNodeValues) / 2.0;
+    return node_type::LeafSize() / expected_values_per_node;
+  }
+
+  // The fullness of the btree. Computed as the number of elements in the btree
+  // divided by the maximum number of elements a tree with the current number
+  // of nodes could hold. A value of 1 indicates perfect space
+  // utilization. Smaller values indicate space wastage.
+  // Returns 0 for empty trees.
+  double fullness() const {
+    if (empty()) return 0.0;
+    return static_cast<double>(size()) / (nodes() * kNodeSlots);
+  }
+  // The overhead of the btree structure in bytes per node. Computed as the
+  // total number of bytes used by the btree minus the number of bytes used for
+  // storing elements divided by the number of elements.
+  // Returns 0 for empty trees.
+  double overhead() const {
+    if (empty()) return 0.0;
+    return (bytes_used() - size() * sizeof(value_type)) /
+           static_cast<double>(size());
+  }
+
+  // The allocator used by the btree.
+  allocator_type get_allocator() const { return allocator(); }
+
+ private:
+  friend struct btree_access;
+
+  // Internal accessor routines.
+  node_type *root() { return root_; }
+  const node_type *root() const { return root_; }
+  node_type *&mutable_root() noexcept { return root_; }
+  node_type *rightmost() { return rightmost_.template get<2>(); }
+  const node_type *rightmost() const { return rightmost_.template get<2>(); }
+  node_type *&mutable_rightmost() noexcept {
+    return rightmost_.template get<2>();
+  }
+  key_compare *mutable_key_comp() noexcept {
+    return &rightmost_.template get<0>();
+  }
+
+  // The leftmost node is stored as the parent of the root node.
+  node_type *leftmost() { return root()->parent(); }
+  const node_type *leftmost() const { return root()->parent(); }
+
+  // Allocator routines.
+  allocator_type *mutable_allocator() noexcept {
+    return &rightmost_.template get<1>();
+  }
+  const allocator_type &allocator() const noexcept {
+    return rightmost_.template get<1>();
+  }
+
+  // Allocates a correctly aligned node of at least size bytes using the
+  // allocator.
+  node_type *allocate(const size_type size) {
+    return reinterpret_cast<node_type *>(
+        absl::container_internal::Allocate<node_type::Alignment()>(
+            mutable_allocator(), size));
+  }
+
+  // Node creation/deletion routines.
+  node_type *new_internal_node(node_type *parent) {
+    node_type *n = allocate(node_type::InternalSize());
+    n->init_internal(parent);
+    return n;
+  }
+  node_type *new_leaf_node(node_type *parent) {
+    node_type *n = allocate(node_type::LeafSize());
+    n->init_leaf(kNodeSlots, parent);
+    return n;
+  }
+  node_type *new_leaf_root_node(const int max_count) {
+    node_type *n = allocate(node_type::LeafSize(max_count));
+    n->init_leaf(max_count, /*parent=*/n);
+    return n;
+  }
+
+  // Deletion helper routines.
+  iterator rebalance_after_delete(iterator iter);
+
+  // Rebalances or splits the node iter points to.
+  void rebalance_or_split(iterator *iter);
+
+  // Merges the values of left, right and the delimiting key on their parent
+  // onto left, removing the delimiting key and deleting right.
+  void merge_nodes(node_type *left, node_type *right);
+
+  // Tries to merge node with its left or right sibling, and failing that,
+  // rebalance with its left or right sibling. Returns true if a merge
+  // occurred, at which point it is no longer valid to access node. Returns
+  // false if no merging took place.
+  bool try_merge_or_rebalance(iterator *iter);
+
+  // Tries to shrink the height of the tree by 1.
+  void try_shrink();
+
+  iterator internal_end(iterator iter) {
+    return iter.node_ != nullptr ? iter : end();
+  }
+  const_iterator internal_end(const_iterator iter) const {
+    return iter.node_ != nullptr ? iter : end();
+  }
+
+  // Emplaces a value into the btree immediately before iter. Requires that
+  // key(v) <= iter.key() and (--iter).key() <= key(v).
+  template <typename... Args>
+  iterator internal_emplace(iterator iter, Args &&... args);
+
+  // Returns an iterator pointing to the first value >= the value "iter" is
+  // pointing at. Note that "iter" might be pointing to an invalid location such
+  // as iter.position_ == iter.node_->finish(). This routine simply moves iter
+  // up in the tree to a valid location. Requires: iter.node_ is non-null.
+  template <typename IterType>
+  static IterType internal_last(IterType iter);
+
+  // Returns an iterator pointing to the leaf position at which key would
+  // reside in the tree, unless there is an exact match - in which case, the
+  // result may not be on a leaf. When there's a three-way comparator, we can
+  // return whether there was an exact match. This allows the caller to avoid a
+  // subsequent comparison to determine if an exact match was made, which is
+  // important for keys with expensive comparison, such as strings.
+  template <typename K>
+  SearchResult<iterator, is_key_compare_to::value> internal_locate(
+      const K &key) const;
+
+  // Internal routine which implements lower_bound().
+  template <typename K>
+  SearchResult<iterator, is_key_compare_to::value> internal_lower_bound(
+      const K &key) const;
+
+  // Internal routine which implements upper_bound().
+  template <typename K>
+  iterator internal_upper_bound(const K &key) const;
+
+  // Internal routine which implements find().
+  template <typename K>
+  iterator internal_find(const K &key) const;
+
+  // Verifies the tree structure of node.
+  int internal_verify(const node_type *node, const key_type *lo,
+                      const key_type *hi) const;
+
+  node_stats internal_stats(const node_type *node) const {
+    // The root can be a static empty node.
+    if (node == nullptr || (node == root() && empty())) {
+      return node_stats(0, 0);
+    }
+    if (node->is_leaf()) {
+      return node_stats(1, 0);
+    }
+    node_stats res(0, 1);
+    for (int i = node->start(); i <= node->finish(); ++i) {
+      res += internal_stats(node->child(i));
+    }
+    return res;
+  }
+
+  node_type *root_;
+
+  // A pointer to the rightmost node. Note that the leftmost node is stored as
+  // the root's parent. We use compressed tuple in order to save space because
+  // key_compare and allocator_type are usually empty.
+  absl::container_internal::CompressedTuple<key_compare, allocator_type,
+                                            node_type *>
+      rightmost_;
+
+  // Number of values.
+  size_type size_;
+};
+
+////
+// btree_node methods
+template <typename P>
+template <typename... Args>
+inline void btree_node<P>::emplace_value(const size_type i,
+                                         allocator_type *alloc,
+                                         Args &&... args) {
+  assert(i >= start());
+  assert(i <= finish());
+  // Shift old values to create space for new value and then construct it in
+  // place.
+  if (i < finish()) {
+    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
+                        alloc);
+  }
+  value_init(i, alloc, std::forward<Args>(args)...);
+  set_finish(finish() + 1);
+
+  if (is_internal() && finish() > i + 1) {
+    for (field_type j = finish(); j > i + 1; --j) {
+      set_child(j, child(j - 1));
+    }
+    clear_child(i + 1);
+  }
+}
+
+template <typename P>
+inline void btree_node<P>::remove_values(const field_type i,
+                                         const field_type to_erase,
+                                         allocator_type *alloc) {
+  // Transfer values after the removed range into their new places.
+  value_destroy_n(i, to_erase, alloc);
+  const field_type orig_finish = finish();
+  const field_type src_i = i + to_erase;
+  transfer_n(orig_finish - src_i, i, src_i, this, alloc);
+
+  if (is_internal()) {
+    // Delete all children between begin and end.
+    for (int j = 0; j < to_erase; ++j) {
+      clear_and_delete(child(i + j + 1), alloc);
+    }
+    // Rotate children after end into new positions.
+    for (int j = i + to_erase + 1; j <= orig_finish; ++j) {
+      set_child(j - to_erase, child(j));
+      clear_child(j);
+    }
+  }
+  set_finish(orig_finish - to_erase);
+}
+
+template <typename P>
+void btree_node<P>::rebalance_right_to_left(const int to_move,
+                                            btree_node *right,
+                                            allocator_type *alloc) {
+  assert(parent() == right->parent());
+  assert(position() + 1 == right->position());
+  assert(right->count() >= count());
+  assert(to_move >= 1);
+  assert(to_move <= right->count());
+
+  // 1) Move the delimiting value in the parent to the left node.
+  transfer(finish(), position(), parent(), alloc);
+
+  // 2) Move the (to_move - 1) values from the right node to the left node.
+  transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc);
+
+  // 3) Move the new delimiting value to the parent from the right node.
+  parent()->transfer(position(), right->start() + to_move - 1, right, alloc);
+
+  // 4) Shift the values in the right node to their correct positions.
+  right->transfer_n(right->count() - to_move, right->start(),
+                    right->start() + to_move, right, alloc);
+
+  if (is_internal()) {
+    // Move the child pointers from the right to the left node.
+    for (int i = 0; i < to_move; ++i) {
+      init_child(finish() + i + 1, right->child(i));
+    }
+    for (int i = right->start(); i <= right->finish() - to_move; ++i) {
+      assert(i + to_move <= right->max_count());
+      right->init_child(i, right->child(i + to_move));
+      right->clear_child(i + to_move);
+    }
+  }
+
+  // Fixup `finish` on the left and right nodes.
+  set_finish(finish() + to_move);
+  right->set_finish(right->finish() - to_move);
+}
+
+template <typename P>
+void btree_node<P>::rebalance_left_to_right(const int to_move,
+                                            btree_node *right,
+                                            allocator_type *alloc) {
+  assert(parent() == right->parent());
+  assert(position() + 1 == right->position());
+  assert(count() >= right->count());
+  assert(to_move >= 1);
+  assert(to_move <= count());
+
+  // Values in the right node are shifted to the right to make room for the
+  // new to_move values. Then, the delimiting value in the parent and the
+  // other (to_move - 1) values in the left node are moved into the right node.
+  // Lastly, a new delimiting value is moved from the left node into the
+  // parent, and the remaining empty left node entries are destroyed.
+
+  // 1) Shift existing values in the right node to their correct positions.
+  right->transfer_n_backward(right->count(), right->start() + to_move,
+                             right->start(), right, alloc);
+
+  // 2) Move the delimiting value in the parent to the right node.
+  right->transfer(right->start() + to_move - 1, position(), parent(), alloc);
+
+  // 3) Move the (to_move - 1) values from the left node to the right node.
+  right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this,
+                    alloc);
+
+  // 4) Move the new delimiting value to the parent from the left node.
+  parent()->transfer(position(), finish() - to_move, this, alloc);
+
+  if (is_internal()) {
+    // Move the child pointers from the left to the right node.
+    for (int i = right->finish(); i >= right->start(); --i) {
+      right->init_child(i + to_move, right->child(i));
+      right->clear_child(i);
+    }
+    for (int i = 1; i <= to_move; ++i) {
+      right->init_child(i - 1, child(finish() - to_move + i));
+      clear_child(finish() - to_move + i);
+    }
+  }
+
+  // Fixup the counts on the left and right nodes.
+  set_finish(finish() - to_move);
+  right->set_finish(right->finish() + to_move);
+}
+
+template <typename P>
+void btree_node<P>::split(const int insert_position, btree_node *dest,
+                          allocator_type *alloc) {
+  assert(dest->count() == 0);
+  assert(max_count() == kNodeSlots);
+
+  // We bias the split based on the position being inserted. If we're
+  // inserting at the beginning of the left node then bias the split to put
+  // more values on the right node. If we're inserting at the end of the
+  // right node then bias the split to put more values on the left node.
+  if (insert_position == start()) {
+    dest->set_finish(dest->start() + finish() - 1);
+  } else if (insert_position == kNodeSlots) {
+    dest->set_finish(dest->start());
+  } else {
+    dest->set_finish(dest->start() + count() / 2);
+  }
+  set_finish(finish() - dest->count());
+  assert(count() >= 1);
+
+  // Move values from the left sibling to the right sibling.
+  dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc);
+
+  // The split key is the largest value in the left sibling.
+  --mutable_finish();
+  parent()->emplace_value(position(), alloc, finish_slot());
+  value_destroy(finish(), alloc);
+  parent()->init_child(position() + 1, dest);
+
+  if (is_internal()) {
+    for (int i = dest->start(), j = finish() + 1; i <= dest->finish();
+         ++i, ++j) {
+      assert(child(j) != nullptr);
+      dest->init_child(i, child(j));
+      clear_child(j);
+    }
+  }
+}
+
+template <typename P>
+void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
+  assert(parent() == src->parent());
+  assert(position() + 1 == src->position());
+
+  // Move the delimiting value to the left node.
+  value_init(finish(), alloc, parent()->slot(position()));
+
+  // Move the values from the right to the left node.
+  transfer_n(src->count(), finish() + 1, src->start(), src, alloc);
+
+  if (is_internal()) {
+    // Move the child pointers from the right to the left node.
+    for (int i = src->start(), j = finish() + 1; i <= src->finish(); ++i, ++j) {
+      init_child(j, src->child(i));
+      src->clear_child(i);
+    }
+  }
+
+  // Fixup `finish` on the src and dest nodes.
+  set_finish(start() + 1 + count() + src->count());
+  src->set_finish(src->start());
+
+  // Remove the value on the parent node and delete the src node.
+  parent()->remove_values(position(), /*to_erase=*/1, alloc);
+}
+
+template <typename P>
+void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
+  if (node->is_leaf()) {
+    node->value_destroy_n(node->start(), node->count(), alloc);
+    deallocate(LeafSize(node->max_count()), node, alloc);
+    return;
+  }
+  if (node->count() == 0) {
+    deallocate(InternalSize(), node, alloc);
+    return;
+  }
+
+  // The parent of the root of the subtree we are deleting.
+  btree_node *delete_root_parent = node->parent();
+
+  // Navigate to the leftmost leaf under node, and then delete upwards.
+  while (node->is_internal()) node = node->start_child();
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+  // When generations are enabled, we delete the leftmost leaf last in case it's
+  // the parent of the root and we need to check whether it's a leaf before we
+  // can update the root's generation.
+  // TODO(ezb): if we change btree_node::is_root to check a bool inside the node
+  // instead of checking whether the parent is a leaf, we can remove this logic.
+  btree_node *leftmost_leaf = node;
+#endif
+  // Use `int` because `pos` needs to be able to hold `kNodeSlots+1`, which
+  // isn't guaranteed to be a valid `field_type`.
+  int pos = node->position();
+  btree_node *parent = node->parent();
+  for (;;) {
+    // In each iteration of the next loop, we delete one leaf node and go right.
+    assert(pos <= parent->finish());
+    do {
+      node = parent->child(pos);
+      if (node->is_internal()) {
+        // Navigate to the leftmost leaf under node.
+        while (node->is_internal()) node = node->start_child();
+        pos = node->position();
+        parent = node->parent();
+      }
+      node->value_destroy_n(node->start(), node->count(), alloc);
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+      if (leftmost_leaf != node)
+#endif
+        deallocate(LeafSize(node->max_count()), node, alloc);
+      ++pos;
+    } while (pos <= parent->finish());
+
+    // Once we've deleted all children of parent, delete parent and go up/right.
+    assert(pos > parent->finish());
+    do {
+      node = parent;
+      pos = node->position();
+      parent = node->parent();
+      node->value_destroy_n(node->start(), node->count(), alloc);
+      deallocate(InternalSize(), node, alloc);
+      if (parent == delete_root_parent) {
+#ifdef ABSL_BTREE_ENABLE_GENERATIONS
+        deallocate(LeafSize(leftmost_leaf->max_count()), leftmost_leaf, alloc);
+#endif
+        return;
+      }
+      ++pos;
+    } while (pos > parent->finish());
+  }
+}
+
+////
+// btree_iterator methods
+template <typename N, typename R, typename P>
+void btree_iterator<N, R, P>::increment_slow() {
+  if (node_->is_leaf()) {
+    assert(position_ >= node_->finish());
+    btree_iterator save(*this);
+    while (position_ == node_->finish() && !node_->is_root()) {
+      assert(node_->parent()->child(node_->position()) == node_);
+      position_ = node_->position();
+      node_ = node_->parent();
+    }
+    // TODO(ezb): assert we aren't incrementing end() instead of handling.
+    if (position_ == node_->finish()) {
+      *this = save;
+    }
+  } else {
+    assert(position_ < node_->finish());
+    node_ = node_->child(position_ + 1);
+    while (node_->is_internal()) {
+      node_ = node_->start_child();
+    }
+    position_ = node_->start();
+  }
+}
+
+template <typename N, typename R, typename P>
+void btree_iterator<N, R, P>::decrement_slow() {
+  if (node_->is_leaf()) {
+    assert(position_ <= -1);
+    btree_iterator save(*this);
+    while (position_ < node_->start() && !node_->is_root()) {
+      assert(node_->parent()->child(node_->position()) == node_);
+      position_ = node_->position() - 1;
+      node_ = node_->parent();
+    }
+    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
+    if (position_ < node_->start()) {
+      *this = save;
+    }
+  } else {
+    assert(position_ >= node_->start());
+    node_ = node_->child(position_);
+    while (node_->is_internal()) {
+      node_ = node_->child(node_->finish());
+    }
+    position_ = node_->finish() - 1;
+  }
+}
+
+////
+// btree methods
+template <typename P>
+template <typename Btree>
+void btree<P>::copy_or_move_values_in_order(Btree &other) {
+  static_assert(std::is_same<btree, Btree>::value ||
+                    std::is_same<const btree, Btree>::value,
+                "Btree type must be same or const.");
+  assert(empty());
+
+  // We can avoid key comparisons because we know the order of the
+  // values is the same order we'll store them in.
+  auto iter = other.begin();
+  if (iter == other.end()) return;
+  insert_multi(iter.slot());
+  ++iter;
+  for (; iter != other.end(); ++iter) {
+    // If the btree is not empty, we can just insert the new value at the end
+    // of the tree.
+    internal_emplace(end(), iter.slot());
+  }
+}
+
+template <typename P>
+constexpr bool btree<P>::static_assert_validation() {
+  static_assert(std::is_nothrow_copy_constructible<key_compare>::value,
+                "Key comparison must be nothrow copy constructible");
+  static_assert(std::is_nothrow_copy_constructible<allocator_type>::value,
+                "Allocator must be nothrow copy constructible");
+  static_assert(type_traits_internal::is_trivially_copyable<iterator>::value,
+                "iterator not trivially copyable.");
+
+  // Note: We assert that kTargetValues, which is computed from
+  // Params::kTargetNodeSize, must fit the node_type::field_type.
+  static_assert(
+      kNodeSlots < (1 << (8 * sizeof(typename node_type::field_type))),
+      "target node size too large");
+
+  // Verify that key_compare returns an absl::{weak,strong}_ordering or bool.
+  static_assert(
+      compare_has_valid_result_type<key_compare, key_type>(),
+      "key comparison function must return absl::{weak,strong}_ordering or "
+      "bool.");
+
+  // Test the assumption made in setting kNodeSlotSpace.
+  static_assert(node_type::MinimumOverhead() >= sizeof(void *) + 4,
+                "node space assumption incorrect");
+
+  return true;
+}
+
+template <typename P>
+template <typename K>
+auto btree<P>::lower_bound_equal(const K &key) const
+    -> std::pair<iterator, bool> {
+  const SearchResult<iterator, is_key_compare_to::value> res =
+      internal_lower_bound(key);
+  const iterator lower = iterator(internal_end(res.value));
+  const bool equal = res.HasMatch()
+                         ? res.IsEq()
+                         : lower != end() && !compare_keys(key, lower.key());
+  return {lower, equal};
+}
+
+template <typename P>
+template <typename K>
+auto btree<P>::equal_range(const K &key) -> std::pair<iterator, iterator> {
+  const std::pair<iterator, bool> lower_and_equal = lower_bound_equal(key);
+  const iterator lower = lower_and_equal.first;
+  if (!lower_and_equal.second) {
+    return {lower, lower};
+  }
+
+  const iterator next = std::next(lower);
+  if (!params_type::template can_have_multiple_equivalent_keys<K>()) {
+    // The next iterator after lower must point to a key greater than `key`.
+    // Note: if this assert fails, then it may indicate that the comparator does
+    // not meet the equivalence requirements for Compare
+    // (see https://en.cppreference.com/w/cpp/named_req/Compare).
+    assert(next == end() || compare_keys(key, next.key()));
+    return {lower, next};
+  }
+  // Try once more to avoid the call to upper_bound() if there's only one
+  // equivalent key. This should prevent all calls to upper_bound() in cases of
+  // unique-containers with heterogeneous comparators in which all comparison
+  // operators have the same equivalence classes.
+  if (next == end() || compare_keys(key, next.key())) return {lower, next};
+
+  // In this case, we need to call upper_bound() to avoid worst case O(N)
+  // behavior if we were to iterate over equal keys.
+  return {lower, upper_bound(key)};
+}
+
+template <typename P>
+template <typename K, typename... Args>
+auto btree<P>::insert_unique(const K &key, Args &&... args)
+    -> std::pair<iterator, bool> {
+  if (empty()) {
+    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
+  }
+
+  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
+  iterator iter = res.value;
+
+  if (res.HasMatch()) {
+    if (res.IsEq()) {
+      // The key already exists in the tree, do nothing.
+      return {iter, false};
+    }
+  } else {
+    iterator last = internal_last(iter);
+    if (last.node_ && !compare_keys(key, last.key())) {
+      // The key already exists in the tree, do nothing.
+      return {last, false};
+    }
+  }
+  return {internal_emplace(iter, std::forward<Args>(args)...), true};
+}
+
+template <typename P>
+template <typename K, typename... Args>
+inline auto btree<P>::insert_hint_unique(iterator position, const K &key,
+                                         Args &&... args)
+    -> std::pair<iterator, bool> {
+  if (!empty()) {
+    if (position == end() || compare_keys(key, position.key())) {
+      if (position == begin() || compare_keys(std::prev(position).key(), key)) {
+        // prev.key() < key < position.key()
+        return {internal_emplace(position, std::forward<Args>(args)...), true};
+      }
+    } else if (compare_keys(position.key(), key)) {
+      ++position;
+      if (position == end() || compare_keys(key, position.key())) {
+        // {original `position`}.key() < key < {current `position`}.key()
+        return {internal_emplace(position, std::forward<Args>(args)...), true};
+      }
+    } else {
+      // position.key() == key
+      return {position, false};
+    }
+  }
+  return insert_unique(key, std::forward<Args>(args)...);
+}
+
+template <typename P>
+template <typename InputIterator, typename>
+void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, int) {
+  for (; b != e; ++b) {
+    insert_hint_unique(end(), params_type::key(*b), *b);
+  }
+}
+
+template <typename P>
+template <typename InputIterator>
+void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, char) {
+  for (; b != e; ++b) {
+    // Use a node handle to manage a temp slot.
+    auto node_handle =
+        CommonAccess::Construct<node_handle_type>(get_allocator(), *b);
+    slot_type *slot = CommonAccess::GetSlot(node_handle);
+    insert_hint_unique(end(), params_type::key(slot), slot);
+  }
+}
+
+template <typename P>
+template <typename ValueType>
+auto btree<P>::insert_multi(const key_type &key, ValueType &&v) -> iterator {
+  if (empty()) {
+    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
+  }
+
+  iterator iter = internal_upper_bound(key);
+  if (iter.node_ == nullptr) {
+    iter = end();
+  }
+  return internal_emplace(iter, std::forward<ValueType>(v));
+}
+
+template <typename P>
+template <typename ValueType>
+auto btree<P>::insert_hint_multi(iterator position, ValueType &&v) -> iterator {
+  if (!empty()) {
+    const key_type &key = params_type::key(v);
+    if (position == end() || !compare_keys(position.key(), key)) {
+      if (position == begin() ||
+          !compare_keys(key, std::prev(position).key())) {
+        // prev.key() <= key <= position.key()
+        return internal_emplace(position, std::forward<ValueType>(v));
+      }
+    } else {
+      ++position;
+      if (position == end() || !compare_keys(position.key(), key)) {
+        // {original `position`}.key() < key < {current `position`}.key()
+        return internal_emplace(position, std::forward<ValueType>(v));
+      }
+    }
+  }
+  return insert_multi(std::forward<ValueType>(v));
+}
+
+template <typename P>
+template <typename InputIterator>
+void btree<P>::insert_iterator_multi(InputIterator b, InputIterator e) {
+  for (; b != e; ++b) {
+    insert_hint_multi(end(), *b);
+  }
+}
+
+template <typename P>
+auto btree<P>::operator=(const btree &other) -> btree & {
+  if (this != &other) {
+    clear();
+
+    *mutable_key_comp() = other.key_comp();
+    if (absl::allocator_traits<
+            allocator_type>::propagate_on_container_copy_assignment::value) {
+      *mutable_allocator() = other.allocator();
+    }
+
+    copy_or_move_values_in_order(other);
+  }
+  return *this;
+}
+
+template <typename P>
+auto btree<P>::operator=(btree &&other) noexcept -> btree & {
+  if (this != &other) {
+    clear();
+
+    using std::swap;
+    if (absl::allocator_traits<
+            allocator_type>::propagate_on_container_copy_assignment::value) {
+      swap(root_, other.root_);
+      // Note: `rightmost_` also contains the allocator and the key comparator.
+      swap(rightmost_, other.rightmost_);
+      swap(size_, other.size_);
+    } else {
+      if (allocator() == other.allocator()) {
+        swap(mutable_root(), other.mutable_root());
+        swap(*mutable_key_comp(), *other.mutable_key_comp());
+        swap(mutable_rightmost(), other.mutable_rightmost());
+        swap(size_, other.size_);
+      } else {
+        // We aren't allowed to propagate the allocator and the allocator is
+        // different so we can't take over its memory. We must move each element
+        // individually. We need both `other` and `this` to have `other`s key
+        // comparator while moving the values so we can't swap the key
+        // comparators.
+        *mutable_key_comp() = other.key_comp();
+        copy_or_move_values_in_order(other);
+      }
+    }
+  }
+  return *this;
+}
+
+template <typename P>
+auto btree<P>::erase(iterator iter) -> iterator {
+  iter.node_->value_destroy(iter.position_, mutable_allocator());
+  iter.update_generation();
+
+  const bool internal_delete = iter.node_->is_internal();
+  if (internal_delete) {
+    // Deletion of a value on an internal node. First, transfer the largest
+    // value from our left child here, then erase/rebalance from that position.
+    // We can get to the largest value from our left child by decrementing iter.
+    iterator internal_iter(iter);
+    --iter;
+    assert(iter.node_->is_leaf());
+    internal_iter.node_->transfer(internal_iter.position_, iter.position_,
+                                  iter.node_, mutable_allocator());
+  } else {
+    // Shift values after erased position in leaf. In the internal case, we
+    // don't need to do this because the leaf position is the end of the node.
+    const field_type transfer_from = iter.position_ + 1;
+    const field_type num_to_transfer = iter.node_->finish() - transfer_from;
+    iter.node_->transfer_n(num_to_transfer, iter.position_, transfer_from,
+                           iter.node_, mutable_allocator());
+  }
+  // Update node finish and container size.
+  iter.node_->set_finish(iter.node_->finish() - 1);
+  --size_;
+
+  // We want to return the next value after the one we just erased. If we
+  // erased from an internal node (internal_delete == true), then the next
+  // value is ++(++iter). If we erased from a leaf node (internal_delete ==
+  // false) then the next value is ++iter. Note that ++iter may point to an
+  // internal node and the value in the internal node may move to a leaf node
+  // (iter.node_) when rebalancing is performed at the leaf level.
+
+  iterator res = rebalance_after_delete(iter);
+
+  // If we erased from an internal node, advance the iterator.
+  if (internal_delete) {
+    ++res;
+  }
+  return res;
+}
+
+template <typename P>
+auto btree<P>::rebalance_after_delete(iterator iter) -> iterator {
+  // Merge/rebalance as we walk back up the tree.
+  iterator res(iter);
+  bool first_iteration = true;
+  for (;;) {
+    if (iter.node_ == root()) {
+      try_shrink();
+      if (empty()) {
+        return end();
+      }
+      break;
+    }
+    if (iter.node_->count() >= kMinNodeValues) {
+      break;
+    }
+    bool merged = try_merge_or_rebalance(&iter);
+    // On the first iteration, we should update `res` with `iter` because `res`
+    // may have been invalidated.
+    if (first_iteration) {
+      res = iter;
+      first_iteration = false;
+    }
+    if (!merged) {
+      break;
+    }
+    iter.position_ = iter.node_->position();
+    iter.node_ = iter.node_->parent();
+  }
+  res.update_generation();
+
+  // Adjust our return value. If we're pointing at the end of a node, advance
+  // the iterator.
+  if (res.position_ == res.node_->finish()) {
+    res.position_ = res.node_->finish() - 1;
+    ++res;
+  }
+
+  return res;
+}
+
+template <typename P>
+auto btree<P>::erase_range(iterator begin, iterator end)
+    -> std::pair<size_type, iterator> {
+  difference_type count = std::distance(begin, end);
+  assert(count >= 0);
+
+  if (count == 0) {
+    return {0, begin};
+  }
+
+  if (static_cast<size_type>(count) == size_) {
+    clear();
+    return {count, this->end()};
+  }
+
+  if (begin.node_ == end.node_) {
+    assert(end.position_ > begin.position_);
+    begin.node_->remove_values(begin.position_, end.position_ - begin.position_,
+                               mutable_allocator());
+    size_ -= count;
+    return {count, rebalance_after_delete(begin)};
+  }
+
+  const size_type target_size = size_ - count;
+  while (size_ > target_size) {
+    if (begin.node_->is_leaf()) {
+      const size_type remaining_to_erase = size_ - target_size;
+      const size_type remaining_in_node =
+          begin.node_->finish() - begin.position_;
+      const size_type to_erase =
+          (std::min)(remaining_to_erase, remaining_in_node);
+      begin.node_->remove_values(begin.position_, to_erase,
+                                 mutable_allocator());
+      size_ -= to_erase;
+      begin = rebalance_after_delete(begin);
+    } else {
+      begin = erase(begin);
+    }
+  }
+  begin.update_generation();
+  return {count, begin};
+}
+
+template <typename P>
+void btree<P>::clear() {
+  if (!empty()) {
+    node_type::clear_and_delete(root(), mutable_allocator());
+  }
+  mutable_root() = mutable_rightmost() = EmptyNode();
+  size_ = 0;
+}
+
+template <typename P>
+void btree<P>::swap(btree &other) {
+  using std::swap;
+  if (absl::allocator_traits<
+          allocator_type>::propagate_on_container_swap::value) {
+    // Note: `rightmost_` also contains the allocator and the key comparator.
+    swap(rightmost_, other.rightmost_);
+  } else {
+    // It's undefined behavior if the allocators are unequal here.
+    assert(allocator() == other.allocator());
+    swap(mutable_rightmost(), other.mutable_rightmost());
+    swap(*mutable_key_comp(), *other.mutable_key_comp());
+  }
+  swap(mutable_root(), other.mutable_root());
+  swap(size_, other.size_);
+}
+
+template <typename P>
+void btree<P>::verify() const {
+  assert(root() != nullptr);
+  assert(leftmost() != nullptr);
+  assert(rightmost() != nullptr);
+  assert(empty() || size() == internal_verify(root(), nullptr, nullptr));
+  assert(leftmost() == (++const_iterator(root(), -1)).node_);
+  assert(rightmost() == (--const_iterator(root(), root()->finish())).node_);
+  assert(leftmost()->is_leaf());
+  assert(rightmost()->is_leaf());
+}
+
+template <typename P>
+void btree<P>::rebalance_or_split(iterator *iter) {
+  node_type *&node = iter->node_;
+  int &insert_position = iter->position_;
+  assert(node->count() == node->max_count());
+  assert(kNodeSlots == node->max_count());
+
+  // First try to make room on the node by rebalancing.
+  node_type *parent = node->parent();
+  if (node != root()) {
+    if (node->position() > parent->start()) {
+      // Try rebalancing with our left sibling.
+      node_type *left = parent->child(node->position() - 1);
+      assert(left->max_count() == kNodeSlots);
+      if (left->count() < kNodeSlots) {
+        // We bias rebalancing based on the position being inserted. If we're
+        // inserting at the end of the right node then we bias rebalancing to
+        // fill up the left node.
+        int to_move = (kNodeSlots - left->count()) /
+                      (1 + (insert_position < static_cast<int>(kNodeSlots)));
+        to_move = (std::max)(1, to_move);
+
+        if (insert_position - to_move >= node->start() ||
+            left->count() + to_move < static_cast<int>(kNodeSlots)) {
+          left->rebalance_right_to_left(to_move, node, mutable_allocator());
+
+          assert(node->max_count() - node->count() == to_move);
+          insert_position = insert_position - to_move;
+          if (insert_position < node->start()) {
+            insert_position = insert_position + left->count() + 1;
+            node = left;
+          }
+
+          assert(node->count() < node->max_count());
+          return;
+        }
+      }
+    }
+
+    if (node->position() < parent->finish()) {
+      // Try rebalancing with our right sibling.
+      node_type *right = parent->child(node->position() + 1);
+      assert(right->max_count() == kNodeSlots);
+      if (right->count() < kNodeSlots) {
+        // We bias rebalancing based on the position being inserted. If we're
+        // inserting at the beginning of the left node then we bias rebalancing
+        // to fill up the right node.
+        int to_move = (static_cast<int>(kNodeSlots) - right->count()) /
+                      (1 + (insert_position > node->start()));
+        to_move = (std::max)(1, to_move);
+
+        if (insert_position <= node->finish() - to_move ||
+            right->count() + to_move < static_cast<int>(kNodeSlots)) {
+          node->rebalance_left_to_right(to_move, right, mutable_allocator());
+
+          if (insert_position > node->finish()) {
+            insert_position = insert_position - node->count() - 1;
+            node = right;
+          }
+
+          assert(node->count() < node->max_count());
+          return;
+        }
+      }
+    }
+
+    // Rebalancing failed, make sure there is room on the parent node for a new
+    // value.
+    assert(parent->max_count() == kNodeSlots);
+    if (parent->count() == kNodeSlots) {
+      iterator parent_iter(node->parent(), node->position());
+      rebalance_or_split(&parent_iter);
+    }
+  } else {
+    // Rebalancing not possible because this is the root node.
+    // Create a new root node and set the current root node as the child of the
+    // new root.
+    parent = new_internal_node(parent);
+    parent->set_generation(root()->generation());
+    parent->init_child(parent->start(), root());
+    mutable_root() = parent;
+    // If the former root was a leaf node, then it's now the rightmost node.
+    assert(parent->start_child()->is_internal() ||
+           parent->start_child() == rightmost());
+  }
+
+  // Split the node.
+  node_type *split_node;
+  if (node->is_leaf()) {
+    split_node = new_leaf_node(parent);
+    node->split(insert_position, split_node, mutable_allocator());
+    if (rightmost() == node) mutable_rightmost() = split_node;
+  } else {
+    split_node = new_internal_node(parent);
+    node->split(insert_position, split_node, mutable_allocator());
+  }
+
+  if (insert_position > node->finish()) {
+    insert_position = insert_position - node->count() - 1;
+    node = split_node;
+  }
+}
+
+template <typename P>
+void btree<P>::merge_nodes(node_type *left, node_type *right) {
+  left->merge(right, mutable_allocator());
+  if (rightmost() == right) mutable_rightmost() = left;
+}
+
+template <typename P>
+bool btree<P>::try_merge_or_rebalance(iterator *iter) {
+  node_type *parent = iter->node_->parent();
+  if (iter->node_->position() > parent->start()) {
+    // Try merging with our left sibling.
+    node_type *left = parent->child(iter->node_->position() - 1);
+    assert(left->max_count() == kNodeSlots);
+    if (1U + left->count() + iter->node_->count() <= kNodeSlots) {
+      iter->position_ += 1 + left->count();
+      merge_nodes(left, iter->node_);
+      iter->node_ = left;
+      return true;
+    }
+  }
+  if (iter->node_->position() < parent->finish()) {
+    // Try merging with our right sibling.
+    node_type *right = parent->child(iter->node_->position() + 1);
+    assert(right->max_count() == kNodeSlots);
+    if (1U + iter->node_->count() + right->count() <= kNodeSlots) {
+      merge_nodes(iter->node_, right);
+      return true;
+    }
+    // Try rebalancing with our right sibling. We don't perform rebalancing if
+    // we deleted the first element from iter->node_ and the node is not
+    // empty. This is a small optimization for the common pattern of deleting
+    // from the front of the tree.
+    if (right->count() > kMinNodeValues &&
+        (iter->node_->count() == 0 || iter->position_ > iter->node_->start())) {
+      int to_move = (right->count() - iter->node_->count()) / 2;
+      to_move = (std::min)(to_move, right->count() - 1);
+      iter->node_->rebalance_right_to_left(to_move, right, mutable_allocator());
+      return false;
+    }
+  }
+  if (iter->node_->position() > parent->start()) {
+    // Try rebalancing with our left sibling. We don't perform rebalancing if
+    // we deleted the last element from iter->node_ and the node is not
+    // empty. This is a small optimization for the common pattern of deleting
+    // from the back of the tree.
+    node_type *left = parent->child(iter->node_->position() - 1);
+    if (left->count() > kMinNodeValues &&
+        (iter->node_->count() == 0 ||
+         iter->position_ < iter->node_->finish())) {
+      int to_move = (left->count() - iter->node_->count()) / 2;
+      to_move = (std::min)(to_move, left->count() - 1);
+      left->rebalance_left_to_right(to_move, iter->node_, mutable_allocator());
+      iter->position_ += to_move;
+      return false;
+    }
+  }
+  return false;
+}
+
+template <typename P>
+void btree<P>::try_shrink() {
+  node_type *orig_root = root();
+  if (orig_root->count() > 0) {
+    return;
+  }
+  // Deleted the last item on the root node, shrink the height of the tree.
+  if (orig_root->is_leaf()) {
+    assert(size() == 0);
+    mutable_root() = mutable_rightmost() = EmptyNode();
+  } else {
+    node_type *child = orig_root->start_child();
+    child->make_root();
+    mutable_root() = child;
+  }
+  node_type::clear_and_delete(orig_root, mutable_allocator());
+}
+
+template <typename P>
+template <typename IterType>
+inline IterType btree<P>::internal_last(IterType iter) {
+  assert(iter.node_ != nullptr);
+  while (iter.position_ == iter.node_->finish()) {
+    iter.position_ = iter.node_->position();
+    iter.node_ = iter.node_->parent();
+    if (iter.node_->is_leaf()) {
+      iter.node_ = nullptr;
+      break;
+    }
+  }
+  iter.update_generation();
+  return iter;
+}
+
+template <typename P>
+template <typename... Args>
+inline auto btree<P>::internal_emplace(iterator iter, Args &&... args)
+    -> iterator {
+  if (iter.node_->is_internal()) {
+    // We can't insert on an internal node. Instead, we'll insert after the
+    // previous value which is guaranteed to be on a leaf node.
+    --iter;
+    ++iter.position_;
+  }
+  const field_type max_count = iter.node_->max_count();
+  allocator_type *alloc = mutable_allocator();
+  if (iter.node_->count() == max_count) {
+    // Make room in the leaf for the new item.
+    if (max_count < kNodeSlots) {
+      // Insertion into the root where the root is smaller than the full node
+      // size. Simply grow the size of the root node.
+      assert(iter.node_ == root());
+      iter.node_ =
+          new_leaf_root_node((std::min<int>)(kNodeSlots, 2 * max_count));
+      // Transfer the values from the old root to the new root.
+      node_type *old_root = root();
+      node_type *new_root = iter.node_;
+      new_root->transfer_n(old_root->count(), new_root->start(),
+                           old_root->start(), old_root, alloc);
+      new_root->set_finish(old_root->finish());
+      old_root->set_finish(old_root->start());
+      new_root->set_generation(old_root->generation());
+      node_type::clear_and_delete(old_root, alloc);
+      mutable_root() = mutable_rightmost() = new_root;
+    } else {
+      rebalance_or_split(&iter);
+    }
+  }
+  iter.node_->emplace_value(iter.position_, alloc, std::forward<Args>(args)...);
+  ++size_;
+  iter.update_generation();
+  return iter;
+}
+
+template <typename P>
+template <typename K>
+inline auto btree<P>::internal_locate(const K &key) const
+    -> SearchResult<iterator, is_key_compare_to::value> {
+  iterator iter(const_cast<node_type *>(root()));
+  for (;;) {
+    SearchResult<int, is_key_compare_to::value> res =
+        iter.node_->lower_bound(key, key_comp());
+    iter.position_ = res.value;
+    if (res.IsEq()) {
+      return {iter, MatchKind::kEq};
+    }
+    // Note: in the non-key-compare-to case, we don't need to walk all the way
+    // down the tree if the keys are equal, but determining equality would
+    // require doing an extra comparison on each node on the way down, and we
+    // will need to go all the way to the leaf node in the expected case.
+    if (iter.node_->is_leaf()) {
+      break;
+    }
+    iter.node_ = iter.node_->child(iter.position_);
+  }
+  // Note: in the non-key-compare-to case, the key may actually be equivalent
+  // here (and the MatchKind::kNe is ignored).
+  return {iter, MatchKind::kNe};
+}
+
+template <typename P>
+template <typename K>
+auto btree<P>::internal_lower_bound(const K &key) const
+    -> SearchResult<iterator, is_key_compare_to::value> {
+  if (!params_type::template can_have_multiple_equivalent_keys<K>()) {
+    SearchResult<iterator, is_key_compare_to::value> ret = internal_locate(key);
+    ret.value = internal_last(ret.value);
+    return ret;
+  }
+  iterator iter(const_cast<node_type *>(root()));
+  SearchResult<int, is_key_compare_to::value> res;
+  bool seen_eq = false;
+  for (;;) {
+    res = iter.node_->lower_bound(key, key_comp());
+    iter.position_ = res.value;
+    if (iter.node_->is_leaf()) {
+      break;
+    }
+    seen_eq = seen_eq || res.IsEq();
+    iter.node_ = iter.node_->child(iter.position_);
+  }
+  if (res.IsEq()) return {iter, MatchKind::kEq};
+  return {internal_last(iter), seen_eq ? MatchKind::kEq : MatchKind::kNe};
+}
+
+template <typename P>
+template <typename K>
+auto btree<P>::internal_upper_bound(const K &key) const -> iterator {
+  iterator iter(const_cast<node_type *>(root()));
+  for (;;) {
+    iter.position_ = iter.node_->upper_bound(key, key_comp());
+    if (iter.node_->is_leaf()) {
+      break;
+    }
+    iter.node_ = iter.node_->child(iter.position_);
+  }
+  return internal_last(iter);
+}
+
+template <typename P>
+template <typename K>
+auto btree<P>::internal_find(const K &key) const -> iterator {
+  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
+  if (res.HasMatch()) {
+    if (res.IsEq()) {
+      return res.value;
+    }
+  } else {
+    const iterator iter = internal_last(res.value);
+    if (iter.node_ != nullptr && !compare_keys(key, iter.key())) {
+      return iter;
+    }
+  }
+  return {nullptr, 0};
+}
+
+template <typename P>
+int btree<P>::internal_verify(const node_type *node, const key_type *lo,
+                              const key_type *hi) const {
+  assert(node->count() > 0);
+  assert(node->count() <= node->max_count());
+  if (lo) {
+    assert(!compare_keys(node->key(node->start()), *lo));
+  }
+  if (hi) {
+    assert(!compare_keys(*hi, node->key(node->finish() - 1)));
+  }
+  for (int i = node->start() + 1; i < node->finish(); ++i) {
+    assert(!compare_keys(node->key(i), node->key(i - 1)));
+  }
+  int count = node->count();
+  if (node->is_internal()) {
+    for (int i = node->start(); i <= node->finish(); ++i) {
+      assert(node->child(i) != nullptr);
+      assert(node->child(i)->parent() == node);
+      assert(node->child(i)->position() == i);
+      count += internal_verify(node->child(i),
+                               i == node->start() ? lo : &node->key(i - 1),
+                               i == node->finish() ? hi : &node->key(i));
+    }
+  }
+  return count;
+}
+
+struct btree_access {
+  template <typename BtreeContainer, typename Pred>
+  static auto erase_if(BtreeContainer &container, Pred pred)
+      -> typename BtreeContainer::size_type {
+    const auto initial_size = container.size();
+    auto &tree = container.tree_;
+    auto *alloc = tree.mutable_allocator();
+    for (auto it = container.begin(); it != container.end();) {
+      if (!pred(*it)) {
+        ++it;
+        continue;
+      }
+      auto *node = it.node_;
+      if (node->is_internal()) {
+        // Handle internal nodes normally.
+        it = container.erase(it);
+        continue;
+      }
+      // If this is a leaf node, then we do all the erases from this node
+      // at once before doing rebalancing.
+
+      // The current position to transfer slots to.
+      int to_pos = it.position_;
+      node->value_destroy(it.position_, alloc);
+      while (++it.position_ < node->finish()) {
+        it.update_generation();
+        if (pred(*it)) {
+          node->value_destroy(it.position_, alloc);
+        } else {
+          node->transfer(node->slot(to_pos++), node->slot(it.position_), alloc);
+        }
+      }
+      const int num_deleted = node->finish() - to_pos;
+      tree.size_ -= num_deleted;
+      node->set_finish(to_pos);
+      it.position_ = to_pos;
+      it = tree.rebalance_after_delete(it);
+    }
+    return initial_size - container.size();
+  }
+};
+
+#undef ABSL_BTREE_ENABLE_GENERATIONS
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_BTREE_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/btree_container.h b/CAPI/cpp/grpc/include/absl/container/internal/btree_container.h
new file mode 100644
index 0000000..fc2f740
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/btree_container.h
@@ -0,0 +1,699 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
+#define ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
+
+#include <algorithm>
+#include <initializer_list>
+#include <iterator>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/container/internal/btree.h"  // IWYU pragma: export
+#include "absl/container/internal/common.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// A common base class for btree_set, btree_map, btree_multiset, and
+// btree_multimap.
+template <typename Tree>
+class btree_container {
+  using params_type = typename Tree::params_type;
+
+ protected:
+  // Alias used for heterogeneous lookup functions.
+  // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+  // `key_type` otherwise. It permits template argument deduction on `K` for the
+  // transparent case.
+  template <class K>
+  using key_arg =
+      typename KeyArg<params_type::kIsKeyCompareTransparent>::template type<
+          K, typename Tree::key_type>;
+
+ public:
+  using key_type = typename Tree::key_type;
+  using value_type = typename Tree::value_type;
+  using size_type = typename Tree::size_type;
+  using difference_type = typename Tree::difference_type;
+  using key_compare = typename Tree::original_key_compare;
+  using value_compare = typename Tree::value_compare;
+  using allocator_type = typename Tree::allocator_type;
+  using reference = typename Tree::reference;
+  using const_reference = typename Tree::const_reference;
+  using pointer = typename Tree::pointer;
+  using const_pointer = typename Tree::const_pointer;
+  using iterator = typename Tree::iterator;
+  using const_iterator = typename Tree::const_iterator;
+  using reverse_iterator = typename Tree::reverse_iterator;
+  using const_reverse_iterator = typename Tree::const_reverse_iterator;
+  using node_type = typename Tree::node_handle_type;
+
+  // Constructors/assignments.
+  btree_container() : tree_(key_compare(), allocator_type()) {}
+  explicit btree_container(const key_compare &comp,
+                           const allocator_type &alloc = allocator_type())
+      : tree_(comp, alloc) {}
+  explicit btree_container(const allocator_type &alloc)
+      : tree_(key_compare(), alloc) {}
+
+  btree_container(const btree_container &other)
+      : btree_container(other, absl::allocator_traits<allocator_type>::
+                                   select_on_container_copy_construction(
+                                       other.get_allocator())) {}
+  btree_container(const btree_container &other, const allocator_type &alloc)
+      : tree_(other.tree_, alloc) {}
+
+  btree_container(btree_container &&other) noexcept(
+      std::is_nothrow_move_constructible<Tree>::value) = default;
+  btree_container(btree_container &&other, const allocator_type &alloc)
+      : tree_(std::move(other.tree_), alloc) {}
+
+  btree_container &operator=(const btree_container &other) = default;
+  btree_container &operator=(btree_container &&other) noexcept(
+      std::is_nothrow_move_assignable<Tree>::value) = default;
+
+  // Iterator routines.
+  iterator begin() { return tree_.begin(); }
+  const_iterator begin() const { return tree_.begin(); }
+  const_iterator cbegin() const { return tree_.begin(); }
+  iterator end() { return tree_.end(); }
+  const_iterator end() const { return tree_.end(); }
+  const_iterator cend() const { return tree_.end(); }
+  reverse_iterator rbegin() { return tree_.rbegin(); }
+  const_reverse_iterator rbegin() const { return tree_.rbegin(); }
+  const_reverse_iterator crbegin() const { return tree_.rbegin(); }
+  reverse_iterator rend() { return tree_.rend(); }
+  const_reverse_iterator rend() const { return tree_.rend(); }
+  const_reverse_iterator crend() const { return tree_.rend(); }
+
+  // Lookup routines.
+  template <typename K = key_type>
+  size_type count(const key_arg<K> &key) const {
+    auto equal_range = this->equal_range(key);
+    return std::distance(equal_range.first, equal_range.second);
+  }
+  template <typename K = key_type>
+  iterator find(const key_arg<K> &key) {
+    return tree_.find(key);
+  }
+  template <typename K = key_type>
+  const_iterator find(const key_arg<K> &key) const {
+    return tree_.find(key);
+  }
+  template <typename K = key_type>
+  bool contains(const key_arg<K> &key) const {
+    return find(key) != end();
+  }
+  template <typename K = key_type>
+  iterator lower_bound(const key_arg<K> &key) {
+    return tree_.lower_bound(key);
+  }
+  template <typename K = key_type>
+  const_iterator lower_bound(const key_arg<K> &key) const {
+    return tree_.lower_bound(key);
+  }
+  template <typename K = key_type>
+  iterator upper_bound(const key_arg<K> &key) {
+    return tree_.upper_bound(key);
+  }
+  template <typename K = key_type>
+  const_iterator upper_bound(const key_arg<K> &key) const {
+    return tree_.upper_bound(key);
+  }
+  template <typename K = key_type>
+  std::pair<iterator, iterator> equal_range(const key_arg<K> &key) {
+    return tree_.equal_range(key);
+  }
+  template <typename K = key_type>
+  std::pair<const_iterator, const_iterator> equal_range(
+      const key_arg<K> &key) const {
+    return tree_.equal_range(key);
+  }
+
+  // Deletion routines. Note that there is also a deletion routine that is
+  // specific to btree_set_container/btree_multiset_container.
+
+  // Erase the specified iterator from the btree. The iterator must be valid
+  // (i.e. not equal to end()).  Return an iterator pointing to the node after
+  // the one that was erased (or end() if none exists).
+  iterator erase(const_iterator iter) { return tree_.erase(iterator(iter)); }
+  iterator erase(iterator iter) { return tree_.erase(iter); }
+  iterator erase(const_iterator first, const_iterator last) {
+    return tree_.erase_range(iterator(first), iterator(last)).second;
+  }
+  template <typename K = key_type>
+  size_type erase(const key_arg<K> &key) {
+    auto equal_range = this->equal_range(key);
+    return tree_.erase_range(equal_range.first, equal_range.second).first;
+  }
+
+  // Extract routines.
+  node_type extract(iterator position) {
+    // Use Construct instead of Transfer because the rebalancing code will
+    // destroy the slot later.
+    auto node =
+        CommonAccess::Construct<node_type>(get_allocator(), position.slot());
+    erase(position);
+    return node;
+  }
+  node_type extract(const_iterator position) {
+    return extract(iterator(position));
+  }
+
+  // Utility routines.
+  ABSL_ATTRIBUTE_REINITIALIZES void clear() { tree_.clear(); }
+  void swap(btree_container &other) { tree_.swap(other.tree_); }
+  void verify() const { tree_.verify(); }
+
+  // Size routines.
+  size_type size() const { return tree_.size(); }
+  size_type max_size() const { return tree_.max_size(); }
+  bool empty() const { return tree_.empty(); }
+
+  friend bool operator==(const btree_container &x, const btree_container &y) {
+    if (x.size() != y.size()) return false;
+    return std::equal(x.begin(), x.end(), y.begin());
+  }
+
+  friend bool operator!=(const btree_container &x, const btree_container &y) {
+    return !(x == y);
+  }
+
+  friend bool operator<(const btree_container &x, const btree_container &y) {
+    return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
+  }
+
+  friend bool operator>(const btree_container &x, const btree_container &y) {
+    return y < x;
+  }
+
+  friend bool operator<=(const btree_container &x, const btree_container &y) {
+    return !(y < x);
+  }
+
+  friend bool operator>=(const btree_container &x, const btree_container &y) {
+    return !(x < y);
+  }
+
+  // The allocator used by the btree.
+  allocator_type get_allocator() const { return tree_.get_allocator(); }
+
+  // The key comparator used by the btree.
+  key_compare key_comp() const { return key_compare(tree_.key_comp()); }
+  value_compare value_comp() const { return tree_.value_comp(); }
+
+  // Support absl::Hash.
+  template <typename State>
+  friend State AbslHashValue(State h, const btree_container &b) {
+    for (const auto &v : b) {
+      h = State::combine(std::move(h), v);
+    }
+    return State::combine(std::move(h), b.size());
+  }
+
+ protected:
+  friend struct btree_access;
+  Tree tree_;
+};
+
+// A common base class for btree_set and btree_map.
+template <typename Tree>
+class btree_set_container : public btree_container<Tree> {
+  using super_type = btree_container<Tree>;
+  using params_type = typename Tree::params_type;
+  using init_type = typename params_type::init_type;
+  using is_key_compare_to = typename params_type::is_key_compare_to;
+  friend class BtreeNodePeer;
+
+ protected:
+  template <class K>
+  using key_arg = typename super_type::template key_arg<K>;
+
+ public:
+  using key_type = typename Tree::key_type;
+  using value_type = typename Tree::value_type;
+  using size_type = typename Tree::size_type;
+  using key_compare = typename Tree::original_key_compare;
+  using allocator_type = typename Tree::allocator_type;
+  using iterator = typename Tree::iterator;
+  using const_iterator = typename Tree::const_iterator;
+  using node_type = typename super_type::node_type;
+  using insert_return_type = InsertReturnType<iterator, node_type>;
+
+  // Inherit constructors.
+  using super_type::super_type;
+  btree_set_container() {}
+
+  // Range constructors.
+  template <class InputIterator>
+  btree_set_container(InputIterator b, InputIterator e,
+                      const key_compare &comp = key_compare(),
+                      const allocator_type &alloc = allocator_type())
+      : super_type(comp, alloc) {
+    insert(b, e);
+  }
+  template <class InputIterator>
+  btree_set_container(InputIterator b, InputIterator e,
+                      const allocator_type &alloc)
+      : btree_set_container(b, e, key_compare(), alloc) {}
+
+  // Initializer list constructors.
+  btree_set_container(std::initializer_list<init_type> init,
+                      const key_compare &comp = key_compare(),
+                      const allocator_type &alloc = allocator_type())
+      : btree_set_container(init.begin(), init.end(), comp, alloc) {}
+  btree_set_container(std::initializer_list<init_type> init,
+                      const allocator_type &alloc)
+      : btree_set_container(init.begin(), init.end(), alloc) {}
+
+  // Insertion routines.
+  std::pair<iterator, bool> insert(const value_type &v) {
+    return this->tree_.insert_unique(params_type::key(v), v);
+  }
+  std::pair<iterator, bool> insert(value_type &&v) {
+    return this->tree_.insert_unique(params_type::key(v), std::move(v));
+  }
+  template <typename... Args>
+  std::pair<iterator, bool> emplace(Args &&... args) {
+    // Use a node handle to manage a temp slot.
+    auto node = CommonAccess::Construct<node_type>(this->get_allocator(),
+                                                   std::forward<Args>(args)...);
+    auto *slot = CommonAccess::GetSlot(node);
+    return this->tree_.insert_unique(params_type::key(slot), slot);
+  }
+  iterator insert(const_iterator hint, const value_type &v) {
+    return this->tree_
+        .insert_hint_unique(iterator(hint), params_type::key(v), v)
+        .first;
+  }
+  iterator insert(const_iterator hint, value_type &&v) {
+    return this->tree_
+        .insert_hint_unique(iterator(hint), params_type::key(v), std::move(v))
+        .first;
+  }
+  template <typename... Args>
+  iterator emplace_hint(const_iterator hint, Args &&... args) {
+    // Use a node handle to manage a temp slot.
+    auto node = CommonAccess::Construct<node_type>(this->get_allocator(),
+                                                   std::forward<Args>(args)...);
+    auto *slot = CommonAccess::GetSlot(node);
+    return this->tree_
+        .insert_hint_unique(iterator(hint), params_type::key(slot), slot)
+        .first;
+  }
+  template <typename InputIterator>
+  void insert(InputIterator b, InputIterator e) {
+    this->tree_.insert_iterator_unique(b, e, 0);
+  }
+  void insert(std::initializer_list<init_type> init) {
+    this->tree_.insert_iterator_unique(init.begin(), init.end(), 0);
+  }
+  insert_return_type insert(node_type &&node) {
+    if (!node) return {this->end(), false, node_type()};
+    std::pair<iterator, bool> res =
+        this->tree_.insert_unique(params_type::key(CommonAccess::GetSlot(node)),
+                                  CommonAccess::GetSlot(node));
+    if (res.second) {
+      CommonAccess::Destroy(&node);
+      return {res.first, true, node_type()};
+    } else {
+      return {res.first, false, std::move(node)};
+    }
+  }
+  iterator insert(const_iterator hint, node_type &&node) {
+    if (!node) return this->end();
+    std::pair<iterator, bool> res = this->tree_.insert_hint_unique(
+        iterator(hint), params_type::key(CommonAccess::GetSlot(node)),
+        CommonAccess::GetSlot(node));
+    if (res.second) CommonAccess::Destroy(&node);
+    return res.first;
+  }
+
+  // Node extraction routines.
+  template <typename K = key_type>
+  node_type extract(const key_arg<K> &key) {
+    const std::pair<iterator, bool> lower_and_equal =
+        this->tree_.lower_bound_equal(key);
+    return lower_and_equal.second ? extract(lower_and_equal.first)
+                                  : node_type();
+  }
+  using super_type::extract;
+
+  // Merge routines.
+  // Moves elements from `src` into `this`. If the element already exists in
+  // `this`, it is left unmodified in `src`.
+  template <
+      typename T,
+      typename absl::enable_if_t<
+          absl::conjunction<
+              std::is_same<value_type, typename T::value_type>,
+              std::is_same<allocator_type, typename T::allocator_type>,
+              std::is_same<typename params_type::is_map_container,
+                           typename T::params_type::is_map_container>>::value,
+          int> = 0>
+  void merge(btree_container<T> &src) {  // NOLINT
+    for (auto src_it = src.begin(); src_it != src.end();) {
+      if (insert(std::move(params_type::element(src_it.slot()))).second) {
+        src_it = src.erase(src_it);
+      } else {
+        ++src_it;
+      }
+    }
+  }
+
+  template <
+      typename T,
+      typename absl::enable_if_t<
+          absl::conjunction<
+              std::is_same<value_type, typename T::value_type>,
+              std::is_same<allocator_type, typename T::allocator_type>,
+              std::is_same<typename params_type::is_map_container,
+                           typename T::params_type::is_map_container>>::value,
+          int> = 0>
+  void merge(btree_container<T> &&src) {
+    merge(src);
+  }
+};
+
+// Base class for btree_map.
+template <typename Tree>
+class btree_map_container : public btree_set_container<Tree> {
+  using super_type = btree_set_container<Tree>;
+  using params_type = typename Tree::params_type;
+  friend class BtreeNodePeer;
+
+ private:
+  template <class K>
+  using key_arg = typename super_type::template key_arg<K>;
+
+ public:
+  using key_type = typename Tree::key_type;
+  using mapped_type = typename params_type::mapped_type;
+  using value_type = typename Tree::value_type;
+  using key_compare = typename Tree::original_key_compare;
+  using allocator_type = typename Tree::allocator_type;
+  using iterator = typename Tree::iterator;
+  using const_iterator = typename Tree::const_iterator;
+
+  // Inherit constructors.
+  using super_type::super_type;
+  btree_map_container() {}
+
+  // Insertion routines.
+  // Note: the nullptr template arguments and extra `const M&` overloads allow
+  // for supporting bitfield arguments.
+  template <typename K = key_type, class M>
+  std::pair<iterator, bool> insert_or_assign(const key_arg<K> &k,
+                                             const M &obj) {
+    return insert_or_assign_impl(k, obj);
+  }
+  template <typename K = key_type, class M, K * = nullptr>
+  std::pair<iterator, bool> insert_or_assign(key_arg<K> &&k, const M &obj) {
+    return insert_or_assign_impl(std::forward<K>(k), obj);
+  }
+  template <typename K = key_type, class M, M * = nullptr>
+  std::pair<iterator, bool> insert_or_assign(const key_arg<K> &k, M &&obj) {
+    return insert_or_assign_impl(k, std::forward<M>(obj));
+  }
+  template <typename K = key_type, class M, K * = nullptr, M * = nullptr>
+  std::pair<iterator, bool> insert_or_assign(key_arg<K> &&k, M &&obj) {
+    return insert_or_assign_impl(std::forward<K>(k), std::forward<M>(obj));
+  }
+  template <typename K = key_type, class M>
+  iterator insert_or_assign(const_iterator hint, const key_arg<K> &k,
+                            const M &obj) {
+    return insert_or_assign_hint_impl(hint, k, obj);
+  }
+  template <typename K = key_type, class M, K * = nullptr>
+  iterator insert_or_assign(const_iterator hint, key_arg<K> &&k, const M &obj) {
+    return insert_or_assign_hint_impl(hint, std::forward<K>(k), obj);
+  }
+  template <typename K = key_type, class M, M * = nullptr>
+  iterator insert_or_assign(const_iterator hint, const key_arg<K> &k, M &&obj) {
+    return insert_or_assign_hint_impl(hint, k, std::forward<M>(obj));
+  }
+  template <typename K = key_type, class M, K * = nullptr, M * = nullptr>
+  iterator insert_or_assign(const_iterator hint, key_arg<K> &&k, M &&obj) {
+    return insert_or_assign_hint_impl(hint, std::forward<K>(k),
+                                      std::forward<M>(obj));
+  }
+
+  template <typename K = key_type, typename... Args,
+            typename absl::enable_if_t<
+                !std::is_convertible<K, const_iterator>::value, int> = 0>
+  std::pair<iterator, bool> try_emplace(const key_arg<K> &k, Args &&... args) {
+    return try_emplace_impl(k, std::forward<Args>(args)...);
+  }
+  template <typename K = key_type, typename... Args,
+            typename absl::enable_if_t<
+                !std::is_convertible<K, const_iterator>::value, int> = 0>
+  std::pair<iterator, bool> try_emplace(key_arg<K> &&k, Args &&... args) {
+    return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+  }
+  template <typename K = key_type, typename... Args>
+  iterator try_emplace(const_iterator hint, const key_arg<K> &k,
+                       Args &&... args) {
+    return try_emplace_hint_impl(hint, k, std::forward<Args>(args)...);
+  }
+  template <typename K = key_type, typename... Args>
+  iterator try_emplace(const_iterator hint, key_arg<K> &&k, Args &&... args) {
+    return try_emplace_hint_impl(hint, std::forward<K>(k),
+                                 std::forward<Args>(args)...);
+  }
+
+  template <typename K = key_type>
+  mapped_type &operator[](const key_arg<K> &k) {
+    return try_emplace(k).first->second;
+  }
+  template <typename K = key_type>
+  mapped_type &operator[](key_arg<K> &&k) {
+    return try_emplace(std::forward<K>(k)).first->second;
+  }
+
+  template <typename K = key_type>
+  mapped_type &at(const key_arg<K> &key) {
+    auto it = this->find(key);
+    if (it == this->end())
+      base_internal::ThrowStdOutOfRange("absl::btree_map::at");
+    return it->second;
+  }
+  template <typename K = key_type>
+  const mapped_type &at(const key_arg<K> &key) const {
+    auto it = this->find(key);
+    if (it == this->end())
+      base_internal::ThrowStdOutOfRange("absl::btree_map::at");
+    return it->second;
+  }
+
+ private:
+  // Note: when we call `std::forward<M>(obj)` twice, it's safe because
+  // insert_unique/insert_hint_unique are guaranteed to not consume `obj` when
+  // `ret.second` is false.
+  template <class K, class M>
+  std::pair<iterator, bool> insert_or_assign_impl(K &&k, M &&obj) {
+    const std::pair<iterator, bool> ret =
+        this->tree_.insert_unique(k, std::forward<K>(k), std::forward<M>(obj));
+    if (!ret.second) ret.first->second = std::forward<M>(obj);
+    return ret;
+  }
+  template <class K, class M>
+  iterator insert_or_assign_hint_impl(const_iterator hint, K &&k, M &&obj) {
+    const std::pair<iterator, bool> ret = this->tree_.insert_hint_unique(
+        iterator(hint), k, std::forward<K>(k), std::forward<M>(obj));
+    if (!ret.second) ret.first->second = std::forward<M>(obj);
+    return ret.first;
+  }
+
+  template <class K, class... Args>
+  std::pair<iterator, bool> try_emplace_impl(K &&k, Args &&... args) {
+    return this->tree_.insert_unique(
+        k, std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)),
+        std::forward_as_tuple(std::forward<Args>(args)...));
+  }
+  template <class K, class... Args>
+  iterator try_emplace_hint_impl(const_iterator hint, K &&k, Args &&... args) {
+    return this->tree_
+        .insert_hint_unique(iterator(hint), k, std::piecewise_construct,
+                            std::forward_as_tuple(std::forward<K>(k)),
+                            std::forward_as_tuple(std::forward<Args>(args)...))
+        .first;
+  }
+};
+
+// A common base class for btree_multiset and btree_multimap.
+template <typename Tree>
+class btree_multiset_container : public btree_container<Tree> {
+  using super_type = btree_container<Tree>;
+  using params_type = typename Tree::params_type;
+  using init_type = typename params_type::init_type;
+  using is_key_compare_to = typename params_type::is_key_compare_to;
+  friend class BtreeNodePeer;
+
+  template <class K>
+  using key_arg = typename super_type::template key_arg<K>;
+
+ public:
+  using key_type = typename Tree::key_type;
+  using value_type = typename Tree::value_type;
+  using size_type = typename Tree::size_type;
+  using key_compare = typename Tree::original_key_compare;
+  using allocator_type = typename Tree::allocator_type;
+  using iterator = typename Tree::iterator;
+  using const_iterator = typename Tree::const_iterator;
+  using node_type = typename super_type::node_type;
+
+  // Inherit constructors.
+  using super_type::super_type;
+  btree_multiset_container() {}
+
+  // Range constructors.
+  template <class InputIterator>
+  btree_multiset_container(InputIterator b, InputIterator e,
+                           const key_compare &comp = key_compare(),
+                           const allocator_type &alloc = allocator_type())
+      : super_type(comp, alloc) {
+    insert(b, e);
+  }
+  template <class InputIterator>
+  btree_multiset_container(InputIterator b, InputIterator e,
+                           const allocator_type &alloc)
+      : btree_multiset_container(b, e, key_compare(), alloc) {}
+
+  // Initializer list constructors.
+  btree_multiset_container(std::initializer_list<init_type> init,
+                           const key_compare &comp = key_compare(),
+                           const allocator_type &alloc = allocator_type())
+      : btree_multiset_container(init.begin(), init.end(), comp, alloc) {}
+  btree_multiset_container(std::initializer_list<init_type> init,
+                           const allocator_type &alloc)
+      : btree_multiset_container(init.begin(), init.end(), alloc) {}
+
+  // Insertion routines.
+  iterator insert(const value_type &v) { return this->tree_.insert_multi(v); }
+  iterator insert(value_type &&v) {
+    return this->tree_.insert_multi(std::move(v));
+  }
+  iterator insert(const_iterator hint, const value_type &v) {
+    return this->tree_.insert_hint_multi(iterator(hint), v);
+  }
+  iterator insert(const_iterator hint, value_type &&v) {
+    return this->tree_.insert_hint_multi(iterator(hint), std::move(v));
+  }
+  template <typename InputIterator>
+  void insert(InputIterator b, InputIterator e) {
+    this->tree_.insert_iterator_multi(b, e);
+  }
+  void insert(std::initializer_list<init_type> init) {
+    this->tree_.insert_iterator_multi(init.begin(), init.end());
+  }
+  template <typename... Args>
+  iterator emplace(Args &&... args) {
+    // Use a node handle to manage a temp slot.
+    auto node = CommonAccess::Construct<node_type>(this->get_allocator(),
+                                                   std::forward<Args>(args)...);
+    return this->tree_.insert_multi(CommonAccess::GetSlot(node));
+  }
+  template <typename... Args>
+  iterator emplace_hint(const_iterator hint, Args &&... args) {
+    // Use a node handle to manage a temp slot.
+    auto node = CommonAccess::Construct<node_type>(this->get_allocator(),
+                                                   std::forward<Args>(args)...);
+    return this->tree_.insert_hint_multi(iterator(hint),
+                                         CommonAccess::GetSlot(node));
+  }
+  iterator insert(node_type &&node) {
+    if (!node) return this->end();
+    iterator res =
+        this->tree_.insert_multi(params_type::key(CommonAccess::GetSlot(node)),
+                                 CommonAccess::GetSlot(node));
+    CommonAccess::Destroy(&node);
+    return res;
+  }
+  iterator insert(const_iterator hint, node_type &&node) {
+    if (!node) return this->end();
+    iterator res = this->tree_.insert_hint_multi(
+        iterator(hint),
+        std::move(params_type::element(CommonAccess::GetSlot(node))));
+    CommonAccess::Destroy(&node);
+    return res;
+  }
+
+  // Node extraction routines.
+  template <typename K = key_type>
+  node_type extract(const key_arg<K> &key) {
+    const std::pair<iterator, bool> lower_and_equal =
+        this->tree_.lower_bound_equal(key);
+    return lower_and_equal.second ? extract(lower_and_equal.first)
+                                  : node_type();
+  }
+  using super_type::extract;
+
+  // Merge routines.
+  // Moves all elements from `src` into `this`.
+  template <
+      typename T,
+      typename absl::enable_if_t<
+          absl::conjunction<
+              std::is_same<value_type, typename T::value_type>,
+              std::is_same<allocator_type, typename T::allocator_type>,
+              std::is_same<typename params_type::is_map_container,
+                           typename T::params_type::is_map_container>>::value,
+          int> = 0>
+  void merge(btree_container<T> &src) {  // NOLINT
+    for (auto src_it = src.begin(), end = src.end(); src_it != end; ++src_it) {
+      insert(std::move(params_type::element(src_it.slot())));
+    }
+    src.clear();
+  }
+
+  template <
+      typename T,
+      typename absl::enable_if_t<
+          absl::conjunction<
+              std::is_same<value_type, typename T::value_type>,
+              std::is_same<allocator_type, typename T::allocator_type>,
+              std::is_same<typename params_type::is_map_container,
+                           typename T::params_type::is_map_container>>::value,
+          int> = 0>
+  void merge(btree_container<T> &&src) {
+    merge(src);
+  }
+};
+
+// A base class for btree_multimap.
+template <typename Tree>
+class btree_multimap_container : public btree_multiset_container<Tree> {
+  using super_type = btree_multiset_container<Tree>;
+  using params_type = typename Tree::params_type;
+  friend class BtreeNodePeer;
+
+ public:
+  using mapped_type = typename params_type::mapped_type;
+
+  // Inherit constructors.
+  using super_type::super_type;
+  btree_multimap_container() {}
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/common.h b/CAPI/cpp/grpc/include/absl/container/internal/common.h
new file mode 100644
index 0000000..416d9aa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/common.h
@@ -0,0 +1,207 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_CONTAINER_H_
+#define ABSL_CONTAINER_INTERNAL_CONTAINER_H_
+
+#include <cassert>
+#include <type_traits>
+
+#include "absl/meta/type_traits.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class, class = void>
+struct IsTransparent : std::false_type {};
+template <class T>
+struct IsTransparent<T, absl::void_t<typename T::is_transparent>>
+    : std::true_type {};
+
+template <bool is_transparent>
+struct KeyArg {
+  // Transparent. Forward `K`.
+  template <typename K, typename key_type>
+  using type = K;
+};
+
+template <>
+struct KeyArg<false> {
+  // Not transparent. Always use `key_type`.
+  template <typename K, typename key_type>
+  using type = key_type;
+};
+
+// The node_handle concept from C++17.
+// We specialize node_handle for sets and maps. node_handle_base holds the
+// common API of both.
+template <typename PolicyTraits, typename Alloc>
+class node_handle_base {
+ protected:
+  using slot_type = typename PolicyTraits::slot_type;
+
+ public:
+  using allocator_type = Alloc;
+
+  constexpr node_handle_base() = default;
+  node_handle_base(node_handle_base&& other) noexcept {
+    *this = std::move(other);
+  }
+  ~node_handle_base() { destroy(); }
+  node_handle_base& operator=(node_handle_base&& other) noexcept {
+    destroy();
+    if (!other.empty()) {
+      alloc_ = other.alloc_;
+      PolicyTraits::transfer(alloc(), slot(), other.slot());
+      other.reset();
+    }
+    return *this;
+  }
+
+  bool empty() const noexcept { return !alloc_; }
+  explicit operator bool() const noexcept { return !empty(); }
+  allocator_type get_allocator() const { return *alloc_; }
+
+ protected:
+  friend struct CommonAccess;
+
+  struct transfer_tag_t {};
+  node_handle_base(transfer_tag_t, const allocator_type& a, slot_type* s)
+      : alloc_(a) {
+    PolicyTraits::transfer(alloc(), slot(), s);
+  }
+
+  struct construct_tag_t {};
+  template <typename... Args>
+  node_handle_base(construct_tag_t, const allocator_type& a, Args&&... args)
+      : alloc_(a) {
+    PolicyTraits::construct(alloc(), slot(), std::forward<Args>(args)...);
+  }
+
+  void destroy() {
+    if (!empty()) {
+      PolicyTraits::destroy(alloc(), slot());
+      reset();
+    }
+  }
+
+  void reset() {
+    assert(alloc_.has_value());
+    alloc_ = absl::nullopt;
+  }
+
+  slot_type* slot() const {
+    assert(!empty());
+    return reinterpret_cast<slot_type*>(std::addressof(slot_space_));
+  }
+  allocator_type* alloc() { return std::addressof(*alloc_); }
+
+ private:
+  absl::optional<allocator_type> alloc_ = {};
+  alignas(slot_type) mutable unsigned char slot_space_[sizeof(slot_type)] = {};
+};
+
+// For sets.
+template <typename Policy, typename PolicyTraits, typename Alloc,
+          typename = void>
+class node_handle : public node_handle_base<PolicyTraits, Alloc> {
+  using Base = node_handle_base<PolicyTraits, Alloc>;
+
+ public:
+  using value_type = typename PolicyTraits::value_type;
+
+  constexpr node_handle() {}
+
+  value_type& value() const { return PolicyTraits::element(this->slot()); }
+
+ private:
+  friend struct CommonAccess;
+
+  using Base::Base;
+};
+
+// For maps.
+template <typename Policy, typename PolicyTraits, typename Alloc>
+class node_handle<Policy, PolicyTraits, Alloc,
+                  absl::void_t<typename Policy::mapped_type>>
+    : public node_handle_base<PolicyTraits, Alloc> {
+  using Base = node_handle_base<PolicyTraits, Alloc>;
+  using slot_type = typename PolicyTraits::slot_type;
+
+ public:
+  using key_type = typename Policy::key_type;
+  using mapped_type = typename Policy::mapped_type;
+
+  constexpr node_handle() {}
+
+  // When C++17 is available, we can use std::launder to provide mutable
+  // access to the key. Otherwise, we provide const access.
+  auto key() const
+      -> decltype(PolicyTraits::mutable_key(std::declval<slot_type*>())) {
+    return PolicyTraits::mutable_key(this->slot());
+  }
+
+  mapped_type& mapped() const {
+    return PolicyTraits::value(&PolicyTraits::element(this->slot()));
+  }
+
+ private:
+  friend struct CommonAccess;
+
+  using Base::Base;
+};
+
+// Provide access to non-public node-handle functions.
+struct CommonAccess {
+  template <typename Node>
+  static auto GetSlot(const Node& node) -> decltype(node.slot()) {
+    return node.slot();
+  }
+
+  template <typename Node>
+  static void Destroy(Node* node) {
+    node->destroy();
+  }
+
+  template <typename Node>
+  static void Reset(Node* node) {
+    node->reset();
+  }
+
+  template <typename T, typename... Args>
+  static T Transfer(Args&&... args) {
+    return T(typename T::transfer_tag_t{}, std::forward<Args>(args)...);
+  }
+
+  template <typename T, typename... Args>
+  static T Construct(Args&&... args) {
+    return T(typename T::construct_tag_t{}, std::forward<Args>(args)...);
+  }
+};
+
+// Implement the insert_return_type<> concept of C++17.
+template <class Iterator, class NodeType>
+struct InsertReturnType {
+  Iterator position;
+  bool inserted;
+  NodeType node;
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_CONTAINER_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/compressed_tuple.h b/CAPI/cpp/grpc/include/absl/container/internal/compressed_tuple.h
new file mode 100644
index 0000000..5ebe164
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/compressed_tuple.h
@@ -0,0 +1,290 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Helper class to perform the Empty Base Optimization.
+// Ts can contain classes and non-classes, empty or not. For the ones that
+// are empty classes, we perform the optimization. If all types in Ts are empty
+// classes, then CompressedTuple<Ts...> is itself an empty class.
+//
+// To access the members, use member get<N>() function.
+//
+// Eg:
+//   absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
+//                                                                    t3);
+//   assert(value.get<0>() == 7);
+//   T1& t1 = value.get<1>();
+//   const T2& t2 = value.get<2>();
+//   ...
+//
+// https://en.cppreference.com/w/cpp/language/ebo
+
+#ifndef ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+#define ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+
+#include <initializer_list>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/utility/utility.h"
+
+#if defined(_MSC_VER) && !defined(__NVCC__)
+// We need to mark these classes with this declspec to ensure that
+// CompressedTuple happens.
+#define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
+#else
+#define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <typename... Ts>
+class CompressedTuple;
+
+namespace internal_compressed_tuple {
+
+template <typename D, size_t I>
+struct Elem;
+template <typename... B, size_t I>
+struct Elem<CompressedTuple<B...>, I>
+    : std::tuple_element<I, std::tuple<B...>> {};
+template <typename D, size_t I>
+using ElemT = typename Elem<D, I>::type;
+
+// Use the __is_final intrinsic if available. Where it's not available, classes
+// declared with the 'final' specifier cannot be used as CompressedTuple
+// elements.
+// TODO(sbenza): Replace this with std::is_final in C++14.
+template <typename T>
+constexpr bool IsFinal() {
+#if defined(__clang__) || defined(__GNUC__)
+  return __is_final(T);
+#else
+  return false;
+#endif
+}
+
+// We can't use EBCO on other CompressedTuples because that would mean that we
+// derive from multiple Storage<> instantiations with the same I parameter,
+// and potentially from multiple identical Storage<> instantiations.  So anytime
+// we use type inheritance rather than encapsulation, we mark
+// CompressedTupleImpl, to make this easy to detect.
+struct uses_inheritance {};
+
+template <typename T>
+constexpr bool ShouldUseBase() {
+  return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>() &&
+         !std::is_base_of<uses_inheritance, T>::value;
+}
+
+// The storage class provides two specializations:
+//  - For empty classes, it stores T as a base class.
+//  - For everything else, it stores T as a member.
+template <typename T, size_t I,
+#if defined(_MSC_VER)
+          bool UseBase =
+              ShouldUseBase<typename std::enable_if<true, T>::type>()>
+#else
+          bool UseBase = ShouldUseBase<T>()>
+#endif
+struct Storage {
+  T value;
+  constexpr Storage() = default;
+  template <typename V>
+  explicit constexpr Storage(absl::in_place_t, V&& v)
+      : value(absl::forward<V>(v)) {}
+  constexpr const T& get() const& { return value; }
+  T& get() & { return value; }
+  constexpr const T&& get() const&& { return absl::move(*this).value; }
+  T&& get() && { return std::move(*this).value; }
+};
+
+template <typename T, size_t I>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T {
+  constexpr Storage() = default;
+
+  template <typename V>
+  explicit constexpr Storage(absl::in_place_t, V&& v)
+      : T(absl::forward<V>(v)) {}
+
+  constexpr const T& get() const& { return *this; }
+  T& get() & { return *this; }
+  constexpr const T&& get() const&& { return absl::move(*this); }
+  T&& get() && { return std::move(*this); }
+};
+
+template <typename D, typename I, bool ShouldAnyUseBase>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
+
+template <typename... Ts, size_t... I, bool ShouldAnyUseBase>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
+    CompressedTuple<Ts...>, absl::index_sequence<I...>, ShouldAnyUseBase>
+    // We use the dummy identity function through std::integral_constant to
+    // convince MSVC of accepting and expanding I in that context. Without it
+    // you would get:
+    //   error C3548: 'I': parameter pack cannot be used in this context
+    : uses_inheritance,
+      Storage<Ts, std::integral_constant<size_t, I>::value>... {
+  constexpr CompressedTupleImpl() = default;
+  template <typename... Vs>
+  explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args)
+      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
+  friend CompressedTuple<Ts...>;
+};
+
+template <typename... Ts, size_t... I>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
+    CompressedTuple<Ts...>, absl::index_sequence<I...>, false>
+    // We use the dummy identity function as above...
+    : Storage<Ts, std::integral_constant<size_t, I>::value, false>... {
+  constexpr CompressedTupleImpl() = default;
+  template <typename... Vs>
+  explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args)
+      : Storage<Ts, I, false>(absl::in_place, absl::forward<Vs>(args))... {}
+  friend CompressedTuple<Ts...>;
+};
+
+std::false_type Or(std::initializer_list<std::false_type>);
+std::true_type Or(std::initializer_list<bool>);
+
+// MSVC requires this to be done separately rather than within the declaration
+// of CompressedTuple below.
+template <typename... Ts>
+constexpr bool ShouldAnyUseBase() {
+  return decltype(
+      Or({std::integral_constant<bool, ShouldUseBase<Ts>()>()...})){};
+}
+
+template <typename T, typename V>
+using TupleElementMoveConstructible =
+    typename std::conditional<std::is_reference<T>::value,
+                              std::is_convertible<V, T>,
+                              std::is_constructible<T, V&&>>::type;
+
+template <bool SizeMatches, class T, class... Vs>
+struct TupleMoveConstructible : std::false_type {};
+
+template <class... Ts, class... Vs>
+struct TupleMoveConstructible<true, CompressedTuple<Ts...>, Vs...>
+    : std::integral_constant<
+          bool, absl::conjunction<
+                    TupleElementMoveConstructible<Ts, Vs&&>...>::value> {};
+
+template <typename T>
+struct compressed_tuple_size;
+
+template <typename... Es>
+struct compressed_tuple_size<CompressedTuple<Es...>>
+    : public std::integral_constant<std::size_t, sizeof...(Es)> {};
+
+template <class T, class... Vs>
+struct TupleItemsMoveConstructible
+    : std::integral_constant<
+          bool, TupleMoveConstructible<compressed_tuple_size<T>::value ==
+                                           sizeof...(Vs),
+                                       T, Vs...>::value> {};
+
+}  // namespace internal_compressed_tuple
+
+// Helper class to perform the Empty Base Class Optimization.
+// Ts can contain classes and non-classes, empty or not. For the ones that
+// are empty classes, we perform the CompressedTuple. If all types in Ts are
+// empty classes, then CompressedTuple<Ts...> is itself an empty class.  (This
+// does not apply when one or more of those empty classes is itself an empty
+// CompressedTuple.)
+//
+// To access the members, use member .get<N>() function.
+//
+// Eg:
+//   absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
+//                                                                    t3);
+//   assert(value.get<0>() == 7);
+//   T1& t1 = value.get<1>();
+//   const T2& t2 = value.get<2>();
+//   ...
+//
+// https://en.cppreference.com/w/cpp/language/ebo
+template <typename... Ts>
+class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
+    : private internal_compressed_tuple::CompressedTupleImpl<
+          CompressedTuple<Ts...>, absl::index_sequence_for<Ts...>,
+          internal_compressed_tuple::ShouldAnyUseBase<Ts...>()> {
+ private:
+  template <int I>
+  using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
+
+  template <int I>
+  using StorageT = internal_compressed_tuple::Storage<ElemT<I>, I>;
+
+ public:
+  // There seems to be a bug in MSVC dealing in which using '=default' here will
+  // cause the compiler to ignore the body of other constructors. The work-
+  // around is to explicitly implement the default constructor.
+#if defined(_MSC_VER)
+  constexpr CompressedTuple() : CompressedTuple::CompressedTupleImpl() {}
+#else
+  constexpr CompressedTuple() = default;
+#endif
+  explicit constexpr CompressedTuple(const Ts&... base)
+      : CompressedTuple::CompressedTupleImpl(absl::in_place, base...) {}
+
+  template <typename First, typename... Vs,
+            absl::enable_if_t<
+                absl::conjunction<
+                    // Ensure we are not hiding default copy/move constructors.
+                    absl::negation<std::is_same<void(CompressedTuple),
+                                                void(absl::decay_t<First>)>>,
+                    internal_compressed_tuple::TupleItemsMoveConstructible<
+                        CompressedTuple<Ts...>, First, Vs...>>::value,
+                bool> = true>
+  explicit constexpr CompressedTuple(First&& first, Vs&&... base)
+      : CompressedTuple::CompressedTupleImpl(absl::in_place,
+                                             absl::forward<First>(first),
+                                             absl::forward<Vs>(base)...) {}
+
+  template <int I>
+  ElemT<I>& get() & {
+    return StorageT<I>::get();
+  }
+
+  template <int I>
+  constexpr const ElemT<I>& get() const& {
+    return StorageT<I>::get();
+  }
+
+  template <int I>
+  ElemT<I>&& get() && {
+    return std::move(*this).StorageT<I>::get();
+  }
+
+  template <int I>
+  constexpr const ElemT<I>&& get() const&& {
+    return absl::move(*this).StorageT<I>::get();
+  }
+};
+
+// Explicit specialization for a zero-element tuple
+// (needed to avoid ambiguous overloads for the default constructor).
+template <>
+class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#undef ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+
+#endif  // ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/container_memory.h b/CAPI/cpp/grpc/include/absl/container/internal/container_memory.h
new file mode 100644
index 0000000..00e9f6d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/container_memory.h
@@ -0,0 +1,442 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
+#define ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
+
+#include <cassert>
+#include <cstddef>
+#include <memory>
+#include <new>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#include <sanitizer/asan_interface.h>
+#endif
+
+#ifdef ABSL_HAVE_MEMORY_SANITIZER
+#include <sanitizer/msan_interface.h>
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <size_t Alignment>
+struct alignas(Alignment) AlignedType {};
+
+// Allocates at least n bytes aligned to the specified alignment.
+// Alignment must be a power of 2. It must be positive.
+//
+// Note that many allocators don't honor alignment requirements above certain
+// threshold (usually either alignof(std::max_align_t) or alignof(void*)).
+// Allocate() doesn't apply alignment corrections. If the underlying allocator
+// returns insufficiently alignment pointer, that's what you are going to get.
+template <size_t Alignment, class Alloc>
+void* Allocate(Alloc* alloc, size_t n) {
+  static_assert(Alignment > 0, "");
+  assert(n && "n must be positive");
+  using M = AlignedType<Alignment>;
+  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
+  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
+  // On macOS, "mem_alloc" is a #define with one argument defined in
+  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
+  // with the "foo(bar)" syntax.
+  A my_mem_alloc(*alloc);
+  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
+  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
+         "allocator does not respect alignment");
+  return p;
+}
+
+// The pointer must have been previously obtained by calling
+// Allocate<Alignment>(alloc, n).
+template <size_t Alignment, class Alloc>
+void Deallocate(Alloc* alloc, void* p, size_t n) {
+  static_assert(Alignment > 0, "");
+  assert(n && "n must be positive");
+  using M = AlignedType<Alignment>;
+  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
+  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
+  // On macOS, "mem_alloc" is a #define with one argument defined in
+  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
+  // with the "foo(bar)" syntax.
+  A my_mem_alloc(*alloc);
+  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
+                 (n + sizeof(M) - 1) / sizeof(M));
+}
+
+namespace memory_internal {
+
+// Constructs T into uninitialized storage pointed by `ptr` using the args
+// specified in the tuple.
+template <class Alloc, class T, class Tuple, size_t... I>
+void ConstructFromTupleImpl(Alloc* alloc, T* ptr, Tuple&& t,
+                            absl::index_sequence<I...>) {
+  absl::allocator_traits<Alloc>::construct(
+      *alloc, ptr, std::get<I>(std::forward<Tuple>(t))...);
+}
+
+template <class T, class F>
+struct WithConstructedImplF {
+  template <class... Args>
+  decltype(std::declval<F>()(std::declval<T>())) operator()(
+      Args&&... args) const {
+    return std::forward<F>(f)(T(std::forward<Args>(args)...));
+  }
+  F&& f;
+};
+
+template <class T, class Tuple, size_t... Is, class F>
+decltype(std::declval<F>()(std::declval<T>())) WithConstructedImpl(
+    Tuple&& t, absl::index_sequence<Is...>, F&& f) {
+  return WithConstructedImplF<T, F>{std::forward<F>(f)}(
+      std::get<Is>(std::forward<Tuple>(t))...);
+}
+
+template <class T, size_t... Is>
+auto TupleRefImpl(T&& t, absl::index_sequence<Is...>)
+    -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...)) {
+  return std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...);
+}
+
+// Returns a tuple of references to the elements of the input tuple. T must be a
+// tuple.
+template <class T>
+auto TupleRef(T&& t) -> decltype(
+    TupleRefImpl(std::forward<T>(t),
+                 absl::make_index_sequence<
+                     std::tuple_size<typename std::decay<T>::type>::value>())) {
+  return TupleRefImpl(
+      std::forward<T>(t),
+      absl::make_index_sequence<
+          std::tuple_size<typename std::decay<T>::type>::value>());
+}
+
+template <class F, class K, class V>
+decltype(std::declval<F>()(std::declval<const K&>(), std::piecewise_construct,
+                           std::declval<std::tuple<K>>(), std::declval<V>()))
+DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
+  const auto& key = std::get<0>(p.first);
+  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
+                            std::move(p.second));
+}
+
+}  // namespace memory_internal
+
+// Constructs T into uninitialized storage pointed by `ptr` using the args
+// specified in the tuple.
+template <class Alloc, class T, class Tuple>
+void ConstructFromTuple(Alloc* alloc, T* ptr, Tuple&& t) {
+  memory_internal::ConstructFromTupleImpl(
+      alloc, ptr, std::forward<Tuple>(t),
+      absl::make_index_sequence<
+          std::tuple_size<typename std::decay<Tuple>::type>::value>());
+}
+
+// Constructs T using the args specified in the tuple and calls F with the
+// constructed value.
+template <class T, class Tuple, class F>
+decltype(std::declval<F>()(std::declval<T>())) WithConstructed(
+    Tuple&& t, F&& f) {
+  return memory_internal::WithConstructedImpl<T>(
+      std::forward<Tuple>(t),
+      absl::make_index_sequence<
+          std::tuple_size<typename std::decay<Tuple>::type>::value>(),
+      std::forward<F>(f));
+}
+
+// Given arguments of an std::pair's consructor, PairArgs() returns a pair of
+// tuples with references to the passed arguments. The tuples contain
+// constructor arguments for the first and the second elements of the pair.
+//
+// The following two snippets are equivalent.
+//
+// 1. std::pair<F, S> p(args...);
+//
+// 2. auto a = PairArgs(args...);
+//    std::pair<F, S> p(std::piecewise_construct,
+//                      std::move(a.first), std::move(a.second));
+inline std::pair<std::tuple<>, std::tuple<>> PairArgs() { return {}; }
+template <class F, class S>
+std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
+  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
+          std::forward_as_tuple(std::forward<S>(s))};
+}
+template <class F, class S>
+std::pair<std::tuple<const F&>, std::tuple<const S&>> PairArgs(
+    const std::pair<F, S>& p) {
+  return PairArgs(p.first, p.second);
+}
+template <class F, class S>
+std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
+  return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
+}
+template <class F, class S>
+auto PairArgs(std::piecewise_construct_t, F&& f, S&& s)
+    -> decltype(std::make_pair(memory_internal::TupleRef(std::forward<F>(f)),
+                               memory_internal::TupleRef(std::forward<S>(s)))) {
+  return std::make_pair(memory_internal::TupleRef(std::forward<F>(f)),
+                        memory_internal::TupleRef(std::forward<S>(s)));
+}
+
+// A helper function for implementing apply() in map policies.
+template <class F, class... Args>
+auto DecomposePair(F&& f, Args&&... args)
+    -> decltype(memory_internal::DecomposePairImpl(
+        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
+  return memory_internal::DecomposePairImpl(
+      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
+}
+
+// A helper function for implementing apply() in set policies.
+template <class F, class Arg>
+decltype(std::declval<F>()(std::declval<const Arg&>(), std::declval<Arg>()))
+DecomposeValue(F&& f, Arg&& arg) {
+  const auto& key = arg;
+  return std::forward<F>(f)(key, std::forward<Arg>(arg));
+}
+
+// Helper functions for asan and msan.
+inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+  ASAN_POISON_MEMORY_REGION(m, s);
+#endif
+#ifdef ABSL_HAVE_MEMORY_SANITIZER
+  __msan_poison(m, s);
+#endif
+  (void)m;
+  (void)s;
+}
+
+inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+  ASAN_UNPOISON_MEMORY_REGION(m, s);
+#endif
+#ifdef ABSL_HAVE_MEMORY_SANITIZER
+  __msan_unpoison(m, s);
+#endif
+  (void)m;
+  (void)s;
+}
+
+template <typename T>
+inline void SanitizerPoisonObject(const T* object) {
+  SanitizerPoisonMemoryRegion(object, sizeof(T));
+}
+
+template <typename T>
+inline void SanitizerUnpoisonObject(const T* object) {
+  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
+}
+
+namespace memory_internal {
+
+// If Pair is a standard-layout type, OffsetOf<Pair>::kFirst and
+// OffsetOf<Pair>::kSecond are equivalent to offsetof(Pair, first) and
+// offsetof(Pair, second) respectively. Otherwise they are -1.
+//
+// The purpose of OffsetOf is to avoid calling offsetof() on non-standard-layout
+// type, which is non-portable.
+template <class Pair, class = std::true_type>
+struct OffsetOf {
+  static constexpr size_t kFirst = static_cast<size_t>(-1);
+  static constexpr size_t kSecond = static_cast<size_t>(-1);
+};
+
+template <class Pair>
+struct OffsetOf<Pair, typename std::is_standard_layout<Pair>::type> {
+  static constexpr size_t kFirst = offsetof(Pair, first);
+  static constexpr size_t kSecond = offsetof(Pair, second);
+};
+
+template <class K, class V>
+struct IsLayoutCompatible {
+ private:
+  struct Pair {
+    K first;
+    V second;
+  };
+
+  // Is P layout-compatible with Pair?
+  template <class P>
+  static constexpr bool LayoutCompatible() {
+    return std::is_standard_layout<P>() && sizeof(P) == sizeof(Pair) &&
+           alignof(P) == alignof(Pair) &&
+           memory_internal::OffsetOf<P>::kFirst ==
+               memory_internal::OffsetOf<Pair>::kFirst &&
+           memory_internal::OffsetOf<P>::kSecond ==
+               memory_internal::OffsetOf<Pair>::kSecond;
+  }
+
+ public:
+  // Whether pair<const K, V> and pair<K, V> are layout-compatible. If they are,
+  // then it is safe to store them in a union and read from either.
+  static constexpr bool value = std::is_standard_layout<K>() &&
+                                std::is_standard_layout<Pair>() &&
+                                memory_internal::OffsetOf<Pair>::kFirst == 0 &&
+                                LayoutCompatible<std::pair<K, V>>() &&
+                                LayoutCompatible<std::pair<const K, V>>();
+};
+
+}  // namespace memory_internal
+
+// The internal storage type for key-value containers like flat_hash_map.
+//
+// It is convenient for the value_type of a flat_hash_map<K, V> to be
+// pair<const K, V>; the "const K" prevents accidental modification of the key
+// when dealing with the reference returned from find() and similar methods.
+// However, this creates other problems; we want to be able to emplace(K, V)
+// efficiently with move operations, and similarly be able to move a
+// pair<K, V> in insert().
+//
+// The solution is this union, which aliases the const and non-const versions
+// of the pair. This also allows flat_hash_map<const K, V> to work, even though
+// that has the same efficiency issues with move in emplace() and insert() -
+// but people do it anyway.
+//
+// If kMutableKeys is false, only the value member can be accessed.
+//
+// If kMutableKeys is true, key can be accessed through all slots while value
+// and mutable_value must be accessed only via INITIALIZED slots. Slots are
+// created and destroyed via mutable_value so that the key can be moved later.
+//
+// Accessing one of the union fields while the other is active is safe as
+// long as they are layout-compatible, which is guaranteed by the definition of
+// kMutableKeys. For C++11, the relevant section of the standard is
+// https://timsong-cpp.github.io/cppwp/n3337/class.mem#19 (9.2.19)
+template <class K, class V>
+union map_slot_type {
+  map_slot_type() {}
+  ~map_slot_type() = delete;
+  using value_type = std::pair<const K, V>;
+  using mutable_value_type =
+      std::pair<absl::remove_const_t<K>, absl::remove_const_t<V>>;
+
+  value_type value;
+  mutable_value_type mutable_value;
+  absl::remove_const_t<K> key;
+};
+
+template <class K, class V>
+struct map_slot_policy {
+  using slot_type = map_slot_type<K, V>;
+  using value_type = std::pair<const K, V>;
+  using mutable_value_type = std::pair<K, V>;
+
+ private:
+  static void emplace(slot_type* slot) {
+    // The construction of union doesn't do anything at runtime but it allows us
+    // to access its members without violating aliasing rules.
+    new (slot) slot_type;
+  }
+  // If pair<const K, V> and pair<K, V> are layout-compatible, we can accept one
+  // or the other via slot_type. We are also free to access the key via
+  // slot_type::key in this case.
+  using kMutableKeys = memory_internal::IsLayoutCompatible<K, V>;
+
+ public:
+  static value_type& element(slot_type* slot) { return slot->value; }
+  static const value_type& element(const slot_type* slot) {
+    return slot->value;
+  }
+
+  // When C++17 is available, we can use std::launder to provide mutable
+  // access to the key for use in node handle.
+#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
+  static K& mutable_key(slot_type* slot) {
+    // Still check for kMutableKeys so that we can avoid calling std::launder
+    // unless necessary because it can interfere with optimizations.
+    return kMutableKeys::value ? slot->key
+                               : *std::launder(const_cast<K*>(
+                                     std::addressof(slot->value.first)));
+  }
+#else  // !(defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606)
+  static const K& mutable_key(slot_type* slot) { return key(slot); }
+#endif
+
+  static const K& key(const slot_type* slot) {
+    return kMutableKeys::value ? slot->key : slot->value.first;
+  }
+
+  template <class Allocator, class... Args>
+  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
+    emplace(slot);
+    if (kMutableKeys::value) {
+      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
+                                                   std::forward<Args>(args)...);
+    } else {
+      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                   std::forward<Args>(args)...);
+    }
+  }
+
+  // Construct this slot by moving from another slot.
+  template <class Allocator>
+  static void construct(Allocator* alloc, slot_type* slot, slot_type* other) {
+    emplace(slot);
+    if (kMutableKeys::value) {
+      absl::allocator_traits<Allocator>::construct(
+          *alloc, &slot->mutable_value, std::move(other->mutable_value));
+    } else {
+      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                   std::move(other->value));
+    }
+  }
+
+  // Construct this slot by copying from another slot.
+  template <class Allocator>
+  static void construct(Allocator* alloc, slot_type* slot,
+                        const slot_type* other) {
+    emplace(slot);
+    absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
+                                                 other->value);
+  }
+
+  template <class Allocator>
+  static void destroy(Allocator* alloc, slot_type* slot) {
+    if (kMutableKeys::value) {
+      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
+    } else {
+      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
+    }
+  }
+
+  template <class Allocator>
+  static void transfer(Allocator* alloc, slot_type* new_slot,
+                       slot_type* old_slot) {
+    emplace(new_slot);
+    if (kMutableKeys::value) {
+      absl::allocator_traits<Allocator>::construct(
+          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
+    } else {
+      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
+                                                   std::move(old_slot->value));
+    }
+    destroy(alloc, old_slot);
+  }
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/counting_allocator.h b/CAPI/cpp/grpc/include/absl/container/internal/counting_allocator.h
new file mode 100644
index 0000000..66068a5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/counting_allocator.h
@@ -0,0 +1,122 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
+#define ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
+
+#include <cstdint>
+#include <memory>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// This is a stateful allocator, but the state lives outside of the
+// allocator (in whatever test is using the allocator). This is odd
+// but helps in tests where the allocator is propagated into nested
+// containers - that chain of allocators uses the same state and is
+// thus easier to query for aggregate allocation information.
+template <typename T>
+class CountingAllocator {
+ public:
+  using Allocator = std::allocator<T>;
+  using AllocatorTraits = std::allocator_traits<Allocator>;
+  using value_type = typename AllocatorTraits::value_type;
+  using pointer = typename AllocatorTraits::pointer;
+  using const_pointer = typename AllocatorTraits::const_pointer;
+  using size_type = typename AllocatorTraits::size_type;
+  using difference_type = typename AllocatorTraits::difference_type;
+
+  CountingAllocator() = default;
+  explicit CountingAllocator(int64_t* bytes_used) : bytes_used_(bytes_used) {}
+  CountingAllocator(int64_t* bytes_used, int64_t* instance_count)
+      : bytes_used_(bytes_used), instance_count_(instance_count) {}
+
+  template <typename U>
+  CountingAllocator(const CountingAllocator<U>& x)
+      : bytes_used_(x.bytes_used_), instance_count_(x.instance_count_) {}
+
+  pointer allocate(
+      size_type n,
+      typename AllocatorTraits::const_void_pointer hint = nullptr) {
+    Allocator allocator;
+    pointer ptr = AllocatorTraits::allocate(allocator, n, hint);
+    if (bytes_used_ != nullptr) {
+      *bytes_used_ += n * sizeof(T);
+    }
+    return ptr;
+  }
+
+  void deallocate(pointer p, size_type n) {
+    Allocator allocator;
+    AllocatorTraits::deallocate(allocator, p, n);
+    if (bytes_used_ != nullptr) {
+      *bytes_used_ -= n * sizeof(T);
+    }
+  }
+
+  template <typename U, typename... Args>
+  void construct(U* p, Args&&... args) {
+    Allocator allocator;
+    AllocatorTraits::construct(allocator, p, std::forward<Args>(args)...);
+    if (instance_count_ != nullptr) {
+      *instance_count_ += 1;
+    }
+  }
+
+  template <typename U>
+  void destroy(U* p) {
+    Allocator allocator;
+    // Ignore GCC warning bug.
+#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuse-after-free"
+#endif
+    AllocatorTraits::destroy(allocator, p);
+#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
+#pragma GCC diagnostic pop
+#endif
+    if (instance_count_ != nullptr) {
+      *instance_count_ -= 1;
+    }
+  }
+
+  template <typename U>
+  class rebind {
+   public:
+    using other = CountingAllocator<U>;
+  };
+
+  friend bool operator==(const CountingAllocator& a,
+                         const CountingAllocator& b) {
+    return a.bytes_used_ == b.bytes_used_ &&
+           a.instance_count_ == b.instance_count_;
+  }
+
+  friend bool operator!=(const CountingAllocator& a,
+                         const CountingAllocator& b) {
+    return !(a == b);
+  }
+
+  int64_t* bytes_used_ = nullptr;
+  int64_t* instance_count_ = nullptr;
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hash_function_defaults.h b/CAPI/cpp/grpc/include/absl/container/internal/hash_function_defaults.h
new file mode 100644
index 0000000..250e662
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hash_function_defaults.h
@@ -0,0 +1,163 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Define the default Hash and Eq functions for SwissTable containers.
+//
+// std::hash<T> and std::equal_to<T> are not appropriate hash and equal
+// functions for SwissTable containers. There are two reasons for this.
+//
+// SwissTable containers are power of 2 sized containers:
+//
+// This means they use the lower bits of the hash value to find the slot for
+// each entry. The typical hash function for integral types is the identity.
+// This is a very weak hash function for SwissTable and any power of 2 sized
+// hashtable implementation which will lead to excessive collisions. For
+// SwissTable we use murmur3 style mixing to reduce collisions to a minimum.
+//
+// SwissTable containers support heterogeneous lookup:
+//
+// In order to make heterogeneous lookup work, hash and equal functions must be
+// polymorphic. At the same time they have to satisfy the same requirements the
+// C++ standard imposes on hash functions and equality operators. That is:
+//
+//   if hash_default_eq<T>(a, b) returns true for any a and b of type T, then
+//   hash_default_hash<T>(a) must equal hash_default_hash<T>(b)
+//
+// For SwissTable containers this requirement is relaxed to allow a and b of
+// any and possibly different types. Note that like the standard the hash and
+// equal functions are still bound to T. This is important because some type U
+// can be hashed by/tested for equality differently depending on T. A notable
+// example is `const char*`. `const char*` is treated as a c-style string when
+// the hash function is hash<std::string> but as a pointer when the hash
+// function is hash<void*>.
+//
+#ifndef ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
+#define ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
+
+#include <stdint.h>
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/hash/hash.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// The hash of an object of type T is computed by using absl::Hash.
+template <class T, class E = void>
+struct HashEq {
+  using Hash = absl::Hash<T>;
+  using Eq = std::equal_to<T>;
+};
+
+struct StringHash {
+  using is_transparent = void;
+
+  size_t operator()(absl::string_view v) const {
+    return absl::Hash<absl::string_view>{}(v);
+  }
+  size_t operator()(const absl::Cord& v) const {
+    return absl::Hash<absl::Cord>{}(v);
+  }
+};
+
+struct StringEq {
+  using is_transparent = void;
+  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
+    return lhs == rhs;
+  }
+  bool operator()(const absl::Cord& lhs, const absl::Cord& rhs) const {
+    return lhs == rhs;
+  }
+  bool operator()(const absl::Cord& lhs, absl::string_view rhs) const {
+    return lhs == rhs;
+  }
+  bool operator()(absl::string_view lhs, const absl::Cord& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+// Supports heterogeneous lookup for string-like elements.
+struct StringHashEq {
+  using Hash = StringHash;
+  using Eq = StringEq;
+};
+
+template <>
+struct HashEq<std::string> : StringHashEq {};
+template <>
+struct HashEq<absl::string_view> : StringHashEq {};
+template <>
+struct HashEq<absl::Cord> : StringHashEq {};
+
+// Supports heterogeneous lookup for pointers and smart pointers.
+template <class T>
+struct HashEq<T*> {
+  struct Hash {
+    using is_transparent = void;
+    template <class U>
+    size_t operator()(const U& ptr) const {
+      return absl::Hash<const T*>{}(HashEq::ToPtr(ptr));
+    }
+  };
+  struct Eq {
+    using is_transparent = void;
+    template <class A, class B>
+    bool operator()(const A& a, const B& b) const {
+      return HashEq::ToPtr(a) == HashEq::ToPtr(b);
+    }
+  };
+
+ private:
+  static const T* ToPtr(const T* ptr) { return ptr; }
+  template <class U, class D>
+  static const T* ToPtr(const std::unique_ptr<U, D>& ptr) {
+    return ptr.get();
+  }
+  template <class U>
+  static const T* ToPtr(const std::shared_ptr<U>& ptr) {
+    return ptr.get();
+  }
+};
+
+template <class T, class D>
+struct HashEq<std::unique_ptr<T, D>> : HashEq<T*> {};
+template <class T>
+struct HashEq<std::shared_ptr<T>> : HashEq<T*> {};
+
+// This header's visibility is restricted.  If you need to access the default
+// hasher please use the container's ::hasher alias instead.
+//
+// Example: typename Hash = typename absl::flat_hash_map<K, V>::hasher
+template <class T>
+using hash_default_hash = typename container_internal::HashEq<T>::Hash;
+
+// This header's visibility is restricted.  If you need to access the default
+// key equal please use the container's ::key_equal alias instead.
+//
+// Example: typename Eq = typename absl::flat_hash_map<K, V, Hash>::key_equal
+template <class T>
+using hash_default_eq = typename container_internal::HashEq<T>::Eq;
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hash_generator_testing.h b/CAPI/cpp/grpc/include/absl/container/internal/hash_generator_testing.h
new file mode 100644
index 0000000..f1f555a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hash_generator_testing.h
@@ -0,0 +1,182 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Generates random values for testing. Specialized only for the few types we
+// care about.
+
+#ifndef ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
+#define ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <cassert>
+#include <iosfwd>
+#include <random>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/container/internal/hash_policy_testing.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+namespace hash_internal {
+namespace generator_internal {
+
+template <class Container, class = void>
+struct IsMap : std::false_type {};
+
+template <class Map>
+struct IsMap<Map, absl::void_t<typename Map::mapped_type>> : std::true_type {};
+
+}  // namespace generator_internal
+
+std::mt19937_64* GetSharedRng();
+
+enum Enum {
+  kEnumEmpty,
+  kEnumDeleted,
+};
+
+enum class EnumClass : uint64_t {
+  kEmpty,
+  kDeleted,
+};
+
+inline std::ostream& operator<<(std::ostream& o, const EnumClass& ec) {
+  return o << static_cast<uint64_t>(ec);
+}
+
+template <class T, class E = void>
+struct Generator;
+
+template <class T>
+struct Generator<T, typename std::enable_if<std::is_integral<T>::value>::type> {
+  T operator()() const {
+    std::uniform_int_distribution<T> dist;
+    return dist(*GetSharedRng());
+  }
+};
+
+template <>
+struct Generator<Enum> {
+  Enum operator()() const {
+    std::uniform_int_distribution<typename std::underlying_type<Enum>::type>
+        dist;
+    while (true) {
+      auto variate = dist(*GetSharedRng());
+      if (variate != kEnumEmpty && variate != kEnumDeleted)
+        return static_cast<Enum>(variate);
+    }
+  }
+};
+
+template <>
+struct Generator<EnumClass> {
+  EnumClass operator()() const {
+    std::uniform_int_distribution<
+        typename std::underlying_type<EnumClass>::type>
+        dist;
+    while (true) {
+      EnumClass variate = static_cast<EnumClass>(dist(*GetSharedRng()));
+      if (variate != EnumClass::kEmpty && variate != EnumClass::kDeleted)
+        return static_cast<EnumClass>(variate);
+    }
+  }
+};
+
+template <>
+struct Generator<std::string> {
+  std::string operator()() const;
+};
+
+template <>
+struct Generator<absl::string_view> {
+  absl::string_view operator()() const;
+};
+
+template <>
+struct Generator<NonStandardLayout> {
+  NonStandardLayout operator()() const {
+    return NonStandardLayout(Generator<std::string>()());
+  }
+};
+
+template <class K, class V>
+struct Generator<std::pair<K, V>> {
+  std::pair<K, V> operator()() const {
+    return std::pair<K, V>(Generator<typename std::decay<K>::type>()(),
+                           Generator<typename std::decay<V>::type>()());
+  }
+};
+
+template <class... Ts>
+struct Generator<std::tuple<Ts...>> {
+  std::tuple<Ts...> operator()() const {
+    return std::tuple<Ts...>(Generator<typename std::decay<Ts>::type>()()...);
+  }
+};
+
+template <class T>
+struct Generator<std::unique_ptr<T>> {
+  std::unique_ptr<T> operator()() const {
+    return absl::make_unique<T>(Generator<T>()());
+  }
+};
+
+template <class U>
+struct Generator<U, absl::void_t<decltype(std::declval<U&>().key()),
+                                decltype(std::declval<U&>().value())>>
+    : Generator<std::pair<
+          typename std::decay<decltype(std::declval<U&>().key())>::type,
+          typename std::decay<decltype(std::declval<U&>().value())>::type>> {};
+
+template <class Container>
+using GeneratedType = decltype(
+    std::declval<const Generator<
+        typename std::conditional<generator_internal::IsMap<Container>::value,
+                                  typename Container::value_type,
+                                  typename Container::key_type>::type>&>()());
+
+// Naive wrapper that performs a linear search of previous values.
+// Beware this is O(SQR), which is reasonable for smaller kMaxValues.
+template <class T, size_t kMaxValues = 64, class E = void>
+struct UniqueGenerator {
+  Generator<T, E> gen;
+  std::vector<T> values;
+
+  T operator()() {
+    assert(values.size() < kMaxValues);
+    for (;;) {
+      T value = gen();
+      if (std::find(values.begin(), values.end(), value) == values.end()) {
+        values.push_back(value);
+        return value;
+      }
+    }
+  }
+};
+
+}  // namespace hash_internal
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_testing.h b/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_testing.h
new file mode 100644
index 0000000..01c40d2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_testing.h
@@ -0,0 +1,184 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Utilities to help tests verify that hash tables properly handle stateful
+// allocators and hash functions.
+
+#ifndef ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
+#define ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
+
+#include <cstdlib>
+#include <limits>
+#include <memory>
+#include <ostream>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/hash/hash.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+namespace hash_testing_internal {
+
+template <class Derived>
+struct WithId {
+  WithId() : id_(next_id<Derived>()) {}
+  WithId(const WithId& that) : id_(that.id_) {}
+  WithId(WithId&& that) : id_(that.id_) { that.id_ = 0; }
+  WithId& operator=(const WithId& that) {
+    id_ = that.id_;
+    return *this;
+  }
+  WithId& operator=(WithId&& that) {
+    id_ = that.id_;
+    that.id_ = 0;
+    return *this;
+  }
+
+  size_t id() const { return id_; }
+
+  friend bool operator==(const WithId& a, const WithId& b) {
+    return a.id_ == b.id_;
+  }
+  friend bool operator!=(const WithId& a, const WithId& b) { return !(a == b); }
+
+ protected:
+  explicit WithId(size_t id) : id_(id) {}
+
+ private:
+  size_t id_;
+
+  template <class T>
+  static size_t next_id() {
+    // 0 is reserved for moved from state.
+    static size_t gId = 1;
+    return gId++;
+  }
+};
+
+}  // namespace hash_testing_internal
+
+struct NonStandardLayout {
+  NonStandardLayout() {}
+  explicit NonStandardLayout(std::string s) : value(std::move(s)) {}
+  virtual ~NonStandardLayout() {}
+
+  friend bool operator==(const NonStandardLayout& a,
+                         const NonStandardLayout& b) {
+    return a.value == b.value;
+  }
+  friend bool operator!=(const NonStandardLayout& a,
+                         const NonStandardLayout& b) {
+    return a.value != b.value;
+  }
+
+  template <typename H>
+  friend H AbslHashValue(H h, const NonStandardLayout& v) {
+    return H::combine(std::move(h), v.value);
+  }
+
+  std::string value;
+};
+
+struct StatefulTestingHash
+    : absl::container_internal::hash_testing_internal::WithId<
+          StatefulTestingHash> {
+  template <class T>
+  size_t operator()(const T& t) const {
+    return absl::Hash<T>{}(t);
+  }
+};
+
+struct StatefulTestingEqual
+    : absl::container_internal::hash_testing_internal::WithId<
+          StatefulTestingEqual> {
+  template <class T, class U>
+  bool operator()(const T& t, const U& u) const {
+    return t == u;
+  }
+};
+
+// It is expected that Alloc() == Alloc() for all allocators so we cannot use
+// WithId base. We need to explicitly assign ids.
+template <class T = int>
+struct Alloc : std::allocator<T> {
+  using propagate_on_container_swap = std::true_type;
+
+  // Using old paradigm for this to ensure compatibility.
+  explicit Alloc(size_t id = 0) : id_(id) {}
+
+  Alloc(const Alloc&) = default;
+  Alloc& operator=(const Alloc&) = default;
+
+  template <class U>
+  Alloc(const Alloc<U>& that) : std::allocator<T>(that), id_(that.id()) {}
+
+  template <class U>
+  struct rebind {
+    using other = Alloc<U>;
+  };
+
+  size_t id() const { return id_; }
+
+  friend bool operator==(const Alloc& a, const Alloc& b) {
+    return a.id_ == b.id_;
+  }
+  friend bool operator!=(const Alloc& a, const Alloc& b) { return !(a == b); }
+
+ private:
+  size_t id_ = (std::numeric_limits<size_t>::max)();
+};
+
+template <class Map>
+auto items(const Map& m) -> std::vector<
+    std::pair<typename Map::key_type, typename Map::mapped_type>> {
+  using std::get;
+  std::vector<std::pair<typename Map::key_type, typename Map::mapped_type>> res;
+  res.reserve(m.size());
+  for (const auto& v : m) res.emplace_back(get<0>(v), get<1>(v));
+  return res;
+}
+
+template <class Set>
+auto keys(const Set& s)
+    -> std::vector<typename std::decay<typename Set::key_type>::type> {
+  std::vector<typename std::decay<typename Set::key_type>::type> res;
+  res.reserve(s.size());
+  for (const auto& v : s) res.emplace_back(v);
+  return res;
+}
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS is false for glibcxx versions
+// where the unordered containers are missing certain constructors that
+// take allocator arguments. This test is defined ad-hoc for the platforms
+// we care about (notably Crosstool 17) because libstdcxx's useless
+// versioning scheme precludes a more principled solution.
+// From GCC-4.9 Changelog: (src: https://gcc.gnu.org/gcc-4.9/changes.html)
+// "the unordered associative containers in <unordered_map> and <unordered_set>
+// meet the allocator-aware container requirements;"
+#if (defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425 ) || \
+( __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9 ))
+#define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 0
+#else
+#define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 1
+#endif
+
+#endif  // ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_traits.h b/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_traits.h
new file mode 100644
index 0000000..46c97b1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_traits.h
@@ -0,0 +1,208 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
+#define ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
+
+#include <cstddef>
+#include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// Defines how slots are initialized/destroyed/moved.
+template <class Policy, class = void>
+struct hash_policy_traits {
+  // The type of the keys stored in the hashtable.
+  using key_type = typename Policy::key_type;
+
+ private:
+  struct ReturnKey {
+    // When C++17 is available, we can use std::launder to provide mutable
+    // access to the key for use in node handle.
+#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
+    template <class Key,
+              absl::enable_if_t<std::is_lvalue_reference<Key>::value, int> = 0>
+    static key_type& Impl(Key&& k, int) {
+      return *std::launder(
+          const_cast<key_type*>(std::addressof(std::forward<Key>(k))));
+    }
+#endif
+
+    template <class Key>
+    static Key Impl(Key&& k, char) {
+      return std::forward<Key>(k);
+    }
+
+    // When Key=T&, we forward the lvalue reference.
+    // When Key=T, we return by value to avoid a dangling reference.
+    // eg, for string_hash_map.
+    template <class Key, class... Args>
+    auto operator()(Key&& k, const Args&...) const
+        -> decltype(Impl(std::forward<Key>(k), 0)) {
+      return Impl(std::forward<Key>(k), 0);
+    }
+  };
+
+  template <class P = Policy, class = void>
+  struct ConstantIteratorsImpl : std::false_type {};
+
+  template <class P>
+  struct ConstantIteratorsImpl<P, absl::void_t<typename P::constant_iterators>>
+      : P::constant_iterators {};
+
+ public:
+  // The actual object stored in the hash table.
+  using slot_type = typename Policy::slot_type;
+
+  // The argument type for insertions into the hashtable. This is different
+  // from value_type for increased performance. See initializer_list constructor
+  // and insert() member functions for more details.
+  using init_type = typename Policy::init_type;
+
+  using reference = decltype(Policy::element(std::declval<slot_type*>()));
+  using pointer = typename std::remove_reference<reference>::type*;
+  using value_type = typename std::remove_reference<reference>::type;
+
+  // Policies can set this variable to tell raw_hash_set that all iterators
+  // should be constant, even `iterator`. This is useful for set-like
+  // containers.
+  // Defaults to false if not provided by the policy.
+  using constant_iterators = ConstantIteratorsImpl<>;
+
+  // PRECONDITION: `slot` is UNINITIALIZED
+  // POSTCONDITION: `slot` is INITIALIZED
+  template <class Alloc, class... Args>
+  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
+    Policy::construct(alloc, slot, std::forward<Args>(args)...);
+  }
+
+  // PRECONDITION: `slot` is INITIALIZED
+  // POSTCONDITION: `slot` is UNINITIALIZED
+  template <class Alloc>
+  static void destroy(Alloc* alloc, slot_type* slot) {
+    Policy::destroy(alloc, slot);
+  }
+
+  // Transfers the `old_slot` to `new_slot`. Any memory allocated by the
+  // allocator inside `old_slot` to `new_slot` can be transferred.
+  //
+  // OPTIONAL: defaults to:
+  //
+  //     clone(new_slot, std::move(*old_slot));
+  //     destroy(old_slot);
+  //
+  // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED
+  // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is
+  //                UNINITIALIZED
+  template <class Alloc>
+  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
+    transfer_impl(alloc, new_slot, old_slot, 0);
+  }
+
+  // PRECONDITION: `slot` is INITIALIZED
+  // POSTCONDITION: `slot` is INITIALIZED
+  template <class P = Policy>
+  static auto element(slot_type* slot) -> decltype(P::element(slot)) {
+    return P::element(slot);
+  }
+
+  // Returns the amount of memory owned by `slot`, exclusive of `sizeof(*slot)`.
+  //
+  // If `slot` is nullptr, returns the constant amount of memory owned by any
+  // full slot or -1 if slots own variable amounts of memory.
+  //
+  // PRECONDITION: `slot` is INITIALIZED or nullptr
+  template <class P = Policy>
+  static size_t space_used(const slot_type* slot) {
+    return P::space_used(slot);
+  }
+
+  // Provides generalized access to the key for elements, both for elements in
+  // the table and for elements that have not yet been inserted (or even
+  // constructed).  We would like an API that allows us to say: `key(args...)`
+  // but we cannot do that for all cases, so we use this more general API that
+  // can be used for many things, including the following:
+  //
+  //   - Given an element in a table, get its key.
+  //   - Given an element initializer, get its key.
+  //   - Given `emplace()` arguments, get the element key.
+  //
+  // Implementations of this must adhere to a very strict technical
+  // specification around aliasing and consuming arguments:
+  //
+  // Let `value_type` be the result type of `element()` without ref- and
+  // cv-qualifiers. The first argument is a functor, the rest are constructor
+  // arguments for `value_type`. Returns `std::forward<F>(f)(k, xs...)`, where
+  // `k` is the element key, and `xs...` are the new constructor arguments for
+  // `value_type`. It's allowed for `k` to alias `xs...`, and for both to alias
+  // `ts...`. The key won't be touched once `xs...` are used to construct an
+  // element; `ts...` won't be touched at all, which allows `apply()` to consume
+  // any rvalues among them.
+  //
+  // If `value_type` is constructible from `Ts&&...`, `Policy::apply()` must not
+  // trigger a hard compile error unless it originates from `f`. In other words,
+  // `Policy::apply()` must be SFINAE-friendly. If `value_type` is not
+  // constructible from `Ts&&...`, either SFINAE or a hard compile error is OK.
+  //
+  // If `Ts...` is `[cv] value_type[&]` or `[cv] init_type[&]`,
+  // `Policy::apply()` must work. A compile error is not allowed, SFINAE or not.
+  template <class F, class... Ts, class P = Policy>
+  static auto apply(F&& f, Ts&&... ts)
+      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
+    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
+  }
+
+  // Returns the "key" portion of the slot.
+  // Used for node handle manipulation.
+  template <class P = Policy>
+  static auto mutable_key(slot_type* slot)
+      -> decltype(P::apply(ReturnKey(), element(slot))) {
+    return P::apply(ReturnKey(), element(slot));
+  }
+
+  // Returns the "value" (as opposed to the "key") portion of the element. Used
+  // by maps to implement `operator[]`, `at()` and `insert_or_assign()`.
+  template <class T, class P = Policy>
+  static auto value(T* elem) -> decltype(P::value(elem)) {
+    return P::value(elem);
+  }
+
+ private:
+  // Use auto -> decltype as an enabler.
+  template <class Alloc, class P = Policy>
+  static auto transfer_impl(Alloc* alloc, slot_type* new_slot,
+                            slot_type* old_slot, int)
+      -> decltype((void)P::transfer(alloc, new_slot, old_slot)) {
+    P::transfer(alloc, new_slot, old_slot);
+  }
+  template <class Alloc>
+  static void transfer_impl(Alloc* alloc, slot_type* new_slot,
+                            slot_type* old_slot, char) {
+    construct(alloc, new_slot, std::move(element(old_slot)));
+    destroy(alloc, old_slot);
+  }
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug.h b/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug.h
new file mode 100644
index 0000000..19d5212
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug.h
@@ -0,0 +1,110 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This library provides APIs to debug the probing behavior of hash tables.
+//
+// In general, the probing behavior is a black box for users and only the
+// side effects can be measured in the form of performance differences.
+// These APIs give a glimpse on the actual behavior of the probing algorithms in
+// these hashtables given a specified hash function and a set of elements.
+//
+// The probe count distribution can be used to assess the quality of the hash
+// function for that particular hash table. Note that a hash function that
+// performs well in one hash table implementation does not necessarily performs
+// well in a different one.
+//
+// This library supports std::unordered_{set,map}, dense_hash_{set,map} and
+// absl::{flat,node,string}_hash_{set,map}.
+
+#ifndef ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
+#define ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
+
+#include <cstddef>
+#include <algorithm>
+#include <type_traits>
+#include <vector>
+
+#include "absl/container/internal/hashtable_debug_hooks.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// Returns the number of probes required to lookup `key`.  Returns 0 for a
+// search with no collisions.  Higher values mean more hash collisions occurred;
+// however, the exact meaning of this number varies according to the container
+// type.
+template <typename C>
+size_t GetHashtableDebugNumProbes(
+    const C& c, const typename C::key_type& key) {
+  return absl::container_internal::hashtable_debug_internal::
+      HashtableDebugAccess<C>::GetNumProbes(c, key);
+}
+
+// Gets a histogram of the number of probes for each elements in the container.
+// The sum of all the values in the vector is equal to container.size().
+template <typename C>
+std::vector<size_t> GetHashtableDebugNumProbesHistogram(const C& container) {
+  std::vector<size_t> v;
+  for (auto it = container.begin(); it != container.end(); ++it) {
+    size_t num_probes = GetHashtableDebugNumProbes(
+        container,
+        absl::container_internal::hashtable_debug_internal::GetKey<C>(*it, 0));
+    v.resize((std::max)(v.size(), num_probes + 1));
+    v[num_probes]++;
+  }
+  return v;
+}
+
+struct HashtableDebugProbeSummary {
+  size_t total_elements;
+  size_t total_num_probes;
+  double mean;
+};
+
+// Gets a summary of the probe count distribution for the elements in the
+// container.
+template <typename C>
+HashtableDebugProbeSummary GetHashtableDebugProbeSummary(const C& container) {
+  auto probes = GetHashtableDebugNumProbesHistogram(container);
+  HashtableDebugProbeSummary summary = {};
+  for (size_t i = 0; i < probes.size(); ++i) {
+    summary.total_elements += probes[i];
+    summary.total_num_probes += probes[i] * i;
+  }
+  summary.mean = 1.0 * summary.total_num_probes / summary.total_elements;
+  return summary;
+}
+
+// Returns the number of bytes requested from the allocator by the container
+// and not freed.
+template <typename C>
+size_t AllocatedByteSize(const C& c) {
+  return absl::container_internal::hashtable_debug_internal::
+      HashtableDebugAccess<C>::AllocatedByteSize(c);
+}
+
+// Returns a tight lower bound for AllocatedByteSize(c) where `c` is of type `C`
+// and `c.size()` is equal to `num_elements`.
+template <typename C>
+size_t LowerBoundAllocatedByteSize(size_t num_elements) {
+  return absl::container_internal::hashtable_debug_internal::
+      HashtableDebugAccess<C>::LowerBoundAllocatedByteSize(num_elements);
+}
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug_hooks.h b/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug_hooks.h
new file mode 100644
index 0000000..3e9ea59
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug_hooks.h
@@ -0,0 +1,85 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Provides the internal API for hashtable_debug.h.
+
+#ifndef ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
+#define ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
+
+#include <cstddef>
+
+#include <algorithm>
+#include <type_traits>
+#include <vector>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+namespace hashtable_debug_internal {
+
+// If it is a map, call get<0>().
+using std::get;
+template <typename T, typename = typename T::mapped_type>
+auto GetKey(const typename T::value_type& pair, int) -> decltype(get<0>(pair)) {
+  return get<0>(pair);
+}
+
+// If it is not a map, return the value directly.
+template <typename T>
+const typename T::key_type& GetKey(const typename T::key_type& key, char) {
+  return key;
+}
+
+// Containers should specialize this to provide debug information for that
+// container.
+template <class Container, typename Enabler = void>
+struct HashtableDebugAccess {
+  // Returns the number of probes required to find `key` in `c`.  The "number of
+  // probes" is a concept that can vary by container.  Implementations should
+  // return 0 when `key` was found in the minimum number of operations and
+  // should increment the result for each non-trivial operation required to find
+  // `key`.
+  //
+  // The default implementation uses the bucket api from the standard and thus
+  // works for `std::unordered_*` containers.
+  static size_t GetNumProbes(const Container& c,
+                             const typename Container::key_type& key) {
+    if (!c.bucket_count()) return {};
+    size_t num_probes = 0;
+    size_t bucket = c.bucket(key);
+    for (auto it = c.begin(bucket), e = c.end(bucket);; ++it, ++num_probes) {
+      if (it == e) return num_probes;
+      if (c.key_eq()(key, GetKey<Container>(*it, 0))) return num_probes;
+    }
+  }
+
+  // Returns the number of bytes requested from the allocator by the container
+  // and not freed.
+  //
+  // static size_t AllocatedByteSize(const Container& c);
+
+  // Returns a tight lower bound for AllocatedByteSize(c) where `c` is of type
+  // `Container` and `c.size()` is equal to `num_elements`.
+  //
+  // static size_t LowerBoundAllocatedByteSize(size_t num_elements);
+};
+
+}  // namespace hashtable_debug_internal
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hashtablez_sampler.h b/CAPI/cpp/grpc/include/absl/container/internal/hashtablez_sampler.h
new file mode 100644
index 0000000..d4016d8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hashtablez_sampler.h
@@ -0,0 +1,299 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: hashtablez_sampler.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the API for a low level library to sample hashtables
+// and collect runtime statistics about them.
+//
+// `HashtablezSampler` controls the lifecycle of `HashtablezInfo` objects which
+// store information about a single sample.
+//
+// `Record*` methods store information into samples.
+// `Sample()` and `Unsample()` make use of a single global sampler with
+// properties controlled by the flags hashtablez_enabled,
+// hashtablez_sample_rate, and hashtablez_max_samples.
+//
+// WARNING
+//
+// Using this sampling API may cause sampled Swiss tables to use the global
+// allocator (operator `new`) in addition to any custom allocator.  If you
+// are using a table in an unusual circumstance where allocation or calling a
+// linux syscall is unacceptable, this could interfere.
+//
+// This utility is internal-only. Use at your own risk.
+
+#ifndef ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
+#define ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/per_thread_tls.h"
+#include "absl/base/optimization.h"
+#include "absl/profiling/internal/sample_recorder.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// Stores information about a sampled hashtable.  All mutations to this *must*
+// be made through `Record*` functions below.  All reads from this *must* only
+// occur in the callback to `HashtablezSampler::Iterate`.
+struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
+  // Constructs the object but does not fill in any fields.
+  HashtablezInfo();
+  ~HashtablezInfo();
+  HashtablezInfo(const HashtablezInfo&) = delete;
+  HashtablezInfo& operator=(const HashtablezInfo&) = delete;
+
+  // Puts the object into a clean state, fills in the logically `const` members,
+  // blocking for any readers that are currently sampling the object.
+  void PrepareForSampling(int64_t stride, size_t inline_element_size_value)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
+
+  // These fields are mutated by the various Record* APIs and need to be
+  // thread-safe.
+  std::atomic<size_t> capacity;
+  std::atomic<size_t> size;
+  std::atomic<size_t> num_erases;
+  std::atomic<size_t> num_rehashes;
+  std::atomic<size_t> max_probe_length;
+  std::atomic<size_t> total_probe_length;
+  std::atomic<size_t> hashes_bitwise_or;
+  std::atomic<size_t> hashes_bitwise_and;
+  std::atomic<size_t> hashes_bitwise_xor;
+  std::atomic<size_t> max_reserve;
+
+  // All of the fields below are set by `PrepareForSampling`, they must not be
+  // mutated in `Record*` functions.  They are logically `const` in that sense.
+  // These are guarded by init_mu, but that is not externalized to clients,
+  // which can read them only during `SampleRecorder::Iterate` which will hold
+  // the lock.
+  static constexpr int kMaxStackDepth = 64;
+  absl::Time create_time;
+  int32_t depth;
+  void* stack[kMaxStackDepth];
+  size_t inline_element_size;  // How big is the slot?
+};
+
+inline void RecordRehashSlow(HashtablezInfo* info, size_t total_probe_length) {
+#ifdef ABSL_INTERNAL_HAVE_SSE2
+  total_probe_length /= 16;
+#else
+  total_probe_length /= 8;
+#endif
+  info->total_probe_length.store(total_probe_length, std::memory_order_relaxed);
+  info->num_erases.store(0, std::memory_order_relaxed);
+  // There is only one concurrent writer, so `load` then `store` is sufficient
+  // instead of using `fetch_add`.
+  info->num_rehashes.store(
+      1 + info->num_rehashes.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+}
+
+inline void RecordReservationSlow(HashtablezInfo* info,
+                                  size_t target_capacity) {
+  info->max_reserve.store(
+      (std::max)(info->max_reserve.load(std::memory_order_relaxed),
+                 target_capacity),
+      std::memory_order_relaxed);
+}
+
+inline void RecordClearedReservationSlow(HashtablezInfo* info) {
+  info->max_reserve.store(0, std::memory_order_relaxed);
+}
+
+inline void RecordStorageChangedSlow(HashtablezInfo* info, size_t size,
+                                     size_t capacity) {
+  info->size.store(size, std::memory_order_relaxed);
+  info->capacity.store(capacity, std::memory_order_relaxed);
+  if (size == 0) {
+    // This is a clear, reset the total/num_erases too.
+    info->total_probe_length.store(0, std::memory_order_relaxed);
+    info->num_erases.store(0, std::memory_order_relaxed);
+  }
+}
+
+void RecordInsertSlow(HashtablezInfo* info, size_t hash,
+                      size_t distance_from_desired);
+
+inline void RecordEraseSlow(HashtablezInfo* info) {
+  info->size.fetch_sub(1, std::memory_order_relaxed);
+  // There is only one concurrent writer, so `load` then `store` is sufficient
+  // instead of using `fetch_add`.
+  info->num_erases.store(
+      1 + info->num_erases.load(std::memory_order_relaxed),
+      std::memory_order_relaxed);
+}
+
+struct SamplingState {
+  int64_t next_sample;
+  // When we make a sampling decision, we record that distance so we can weight
+  // each sample.
+  int64_t sample_stride;
+};
+
+HashtablezInfo* SampleSlow(SamplingState& next_sample,
+                           size_t inline_element_size);
+void UnsampleSlow(HashtablezInfo* info);
+
+#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#error ABSL_INTERNAL_HASHTABLEZ_SAMPLE cannot be directly set
+#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+
+#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+class HashtablezInfoHandle {
+ public:
+  explicit HashtablezInfoHandle() : info_(nullptr) {}
+  explicit HashtablezInfoHandle(HashtablezInfo* info) : info_(info) {}
+  ~HashtablezInfoHandle() {
+    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    UnsampleSlow(info_);
+  }
+
+  HashtablezInfoHandle(const HashtablezInfoHandle&) = delete;
+  HashtablezInfoHandle& operator=(const HashtablezInfoHandle&) = delete;
+
+  HashtablezInfoHandle(HashtablezInfoHandle&& o) noexcept
+      : info_(absl::exchange(o.info_, nullptr)) {}
+  HashtablezInfoHandle& operator=(HashtablezInfoHandle&& o) noexcept {
+    if (ABSL_PREDICT_FALSE(info_ != nullptr)) {
+      UnsampleSlow(info_);
+    }
+    info_ = absl::exchange(o.info_, nullptr);
+    return *this;
+  }
+
+  inline void RecordStorageChanged(size_t size, size_t capacity) {
+    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    RecordStorageChangedSlow(info_, size, capacity);
+  }
+
+  inline void RecordRehash(size_t total_probe_length) {
+    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    RecordRehashSlow(info_, total_probe_length);
+  }
+
+  inline void RecordReservation(size_t target_capacity) {
+    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    RecordReservationSlow(info_, target_capacity);
+  }
+
+  inline void RecordClearedReservation() {
+    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    RecordClearedReservationSlow(info_);
+  }
+
+  inline void RecordInsert(size_t hash, size_t distance_from_desired) {
+    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    RecordInsertSlow(info_, hash, distance_from_desired);
+  }
+
+  inline void RecordErase() {
+    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    RecordEraseSlow(info_);
+  }
+
+  friend inline void swap(HashtablezInfoHandle& lhs,
+                          HashtablezInfoHandle& rhs) {
+    std::swap(lhs.info_, rhs.info_);
+  }
+
+ private:
+  friend class HashtablezInfoHandlePeer;
+  HashtablezInfo* info_;
+};
+#else
+// Ensure that when Hashtablez is turned off at compile time, HashtablezInfo can
+// be removed by the linker, in order to reduce the binary size.
+class HashtablezInfoHandle {
+ public:
+  explicit HashtablezInfoHandle() = default;
+  explicit HashtablezInfoHandle(std::nullptr_t) {}
+
+  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
+  inline void RecordRehash(size_t /*total_probe_length*/) {}
+  inline void RecordReservation(size_t /*target_capacity*/) {}
+  inline void RecordClearedReservation() {}
+  inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {}
+  inline void RecordErase() {}
+
+  friend inline void swap(HashtablezInfoHandle& /*lhs*/,
+                          HashtablezInfoHandle& /*rhs*/) {}
+};
+#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+
+#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+extern ABSL_PER_THREAD_TLS_KEYWORD SamplingState global_next_sample;
+#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+
+// Returns an RAII sampling handle that manages registration and unregistation
+// with the global sampler.
+inline HashtablezInfoHandle Sample(
+    size_t inline_element_size ABSL_ATTRIBUTE_UNUSED) {
+#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
+    return HashtablezInfoHandle(nullptr);
+  }
+  return HashtablezInfoHandle(
+      SampleSlow(global_next_sample, inline_element_size));
+#else
+  return HashtablezInfoHandle(nullptr);
+#endif  // !ABSL_PER_THREAD_TLS
+}
+
+using HashtablezSampler =
+    ::absl::profiling_internal::SampleRecorder<HashtablezInfo>;
+
+// Returns a global Sampler.
+HashtablezSampler& GlobalHashtablezSampler();
+
+using HashtablezConfigListener = void (*)();
+void SetHashtablezConfigListener(HashtablezConfigListener l);
+
+// Enables or disables sampling for Swiss tables.
+bool IsHashtablezEnabled();
+void SetHashtablezEnabled(bool enabled);
+void SetHashtablezEnabledInternal(bool enabled);
+
+// Sets the rate at which Swiss tables will be sampled.
+int32_t GetHashtablezSampleParameter();
+void SetHashtablezSampleParameter(int32_t rate);
+void SetHashtablezSampleParameterInternal(int32_t rate);
+
+// Sets a soft max for the number of samples that will be kept.
+int32_t GetHashtablezMaxSamples();
+void SetHashtablezMaxSamples(int32_t max);
+void SetHashtablezMaxSamplesInternal(int32_t max);
+
+// Configuration override.
+// This allows process-wide sampling without depending on order of
+// initialization of static storage duration objects.
+// The definition of this constant is weak, which allows us to inject a
+// different value for it at link time.
+extern "C" bool ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)();
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/inlined_vector.h b/CAPI/cpp/grpc/include/absl/container/internal/inlined_vector.h
new file mode 100644
index 0000000..54c92a0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/inlined_vector.h
@@ -0,0 +1,953 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
+#define ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/macros.h"
+#include "absl/container/internal/compressed_tuple.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace inlined_vector_internal {
+
+// GCC does not deal very well with the below code
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+
+template <typename A>
+using AllocatorTraits = std::allocator_traits<A>;
+template <typename A>
+using ValueType = typename AllocatorTraits<A>::value_type;
+template <typename A>
+using SizeType = typename AllocatorTraits<A>::size_type;
+template <typename A>
+using Pointer = typename AllocatorTraits<A>::pointer;
+template <typename A>
+using ConstPointer = typename AllocatorTraits<A>::const_pointer;
+template <typename A>
+using SizeType = typename AllocatorTraits<A>::size_type;
+template <typename A>
+using DifferenceType = typename AllocatorTraits<A>::difference_type;
+template <typename A>
+using Reference = ValueType<A>&;
+template <typename A>
+using ConstReference = const ValueType<A>&;
+template <typename A>
+using Iterator = Pointer<A>;
+template <typename A>
+using ConstIterator = ConstPointer<A>;
+template <typename A>
+using ReverseIterator = typename std::reverse_iterator<Iterator<A>>;
+template <typename A>
+using ConstReverseIterator = typename std::reverse_iterator<ConstIterator<A>>;
+template <typename A>
+using MoveIterator = typename std::move_iterator<Iterator<A>>;
+
+template <typename Iterator>
+using IsAtLeastForwardIterator = std::is_convertible<
+    typename std::iterator_traits<Iterator>::iterator_category,
+    std::forward_iterator_tag>;
+
+template <typename A>
+using IsMemcpyOk =
+    absl::conjunction<std::is_same<A, std::allocator<ValueType<A>>>,
+                      absl::is_trivially_copy_constructible<ValueType<A>>,
+                      absl::is_trivially_copy_assignable<ValueType<A>>,
+                      absl::is_trivially_destructible<ValueType<A>>>;
+
+template <typename T>
+struct TypeIdentity {
+  using type = T;
+};
+
+// Used for function arguments in template functions to prevent ADL by forcing
+// callers to explicitly specify the template parameter.
+template <typename T>
+using NoTypeDeduction = typename TypeIdentity<T>::type;
+
+template <typename A, bool IsTriviallyDestructible =
+                          absl::is_trivially_destructible<ValueType<A>>::value>
+struct DestroyAdapter;
+
+template <typename A>
+struct DestroyAdapter<A, /* IsTriviallyDestructible */ false> {
+  static void DestroyElements(A& allocator, Pointer<A> destroy_first,
+                              SizeType<A> destroy_size) {
+    for (SizeType<A> i = destroy_size; i != 0;) {
+      --i;
+      AllocatorTraits<A>::destroy(allocator, destroy_first + i);
+    }
+  }
+};
+
+template <typename A>
+struct DestroyAdapter<A, /* IsTriviallyDestructible */ true> {
+  static void DestroyElements(A& allocator, Pointer<A> destroy_first,
+                              SizeType<A> destroy_size) {
+    static_cast<void>(allocator);
+    static_cast<void>(destroy_first);
+    static_cast<void>(destroy_size);
+  }
+};
+
+template <typename A>
+struct Allocation {
+  Pointer<A> data;
+  SizeType<A> capacity;
+};
+
+template <typename A,
+          bool IsOverAligned =
+              (alignof(ValueType<A>) > ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT)>
+struct MallocAdapter {
+  static Allocation<A> Allocate(A& allocator, SizeType<A> requested_capacity) {
+    return {AllocatorTraits<A>::allocate(allocator, requested_capacity),
+            requested_capacity};
+  }
+
+  static void Deallocate(A& allocator, Pointer<A> pointer,
+                         SizeType<A> capacity) {
+    AllocatorTraits<A>::deallocate(allocator, pointer, capacity);
+  }
+};
+
+template <typename A, typename ValueAdapter>
+void ConstructElements(NoTypeDeduction<A>& allocator,
+                       Pointer<A> construct_first, ValueAdapter& values,
+                       SizeType<A> construct_size) {
+  for (SizeType<A> i = 0; i < construct_size; ++i) {
+    ABSL_INTERNAL_TRY { values.ConstructNext(allocator, construct_first + i); }
+    ABSL_INTERNAL_CATCH_ANY {
+      DestroyAdapter<A>::DestroyElements(allocator, construct_first, i);
+      ABSL_INTERNAL_RETHROW;
+    }
+  }
+}
+
+template <typename A, typename ValueAdapter>
+void AssignElements(Pointer<A> assign_first, ValueAdapter& values,
+                    SizeType<A> assign_size) {
+  for (SizeType<A> i = 0; i < assign_size; ++i) {
+    values.AssignNext(assign_first + i);
+  }
+}
+
+template <typename A>
+struct StorageView {
+  Pointer<A> data;
+  SizeType<A> size;
+  SizeType<A> capacity;
+};
+
+template <typename A, typename Iterator>
+class IteratorValueAdapter {
+ public:
+  explicit IteratorValueAdapter(const Iterator& it) : it_(it) {}
+
+  void ConstructNext(A& allocator, Pointer<A> construct_at) {
+    AllocatorTraits<A>::construct(allocator, construct_at, *it_);
+    ++it_;
+  }
+
+  void AssignNext(Pointer<A> assign_at) {
+    *assign_at = *it_;
+    ++it_;
+  }
+
+ private:
+  Iterator it_;
+};
+
+template <typename A>
+class CopyValueAdapter {
+ public:
+  explicit CopyValueAdapter(ConstPointer<A> p) : ptr_(p) {}
+
+  void ConstructNext(A& allocator, Pointer<A> construct_at) {
+    AllocatorTraits<A>::construct(allocator, construct_at, *ptr_);
+  }
+
+  void AssignNext(Pointer<A> assign_at) { *assign_at = *ptr_; }
+
+ private:
+  ConstPointer<A> ptr_;
+};
+
+template <typename A>
+class DefaultValueAdapter {
+ public:
+  explicit DefaultValueAdapter() {}
+
+  void ConstructNext(A& allocator, Pointer<A> construct_at) {
+    AllocatorTraits<A>::construct(allocator, construct_at);
+  }
+
+  void AssignNext(Pointer<A> assign_at) { *assign_at = ValueType<A>(); }
+};
+
+template <typename A>
+class AllocationTransaction {
+ public:
+  explicit AllocationTransaction(A& allocator)
+      : allocator_data_(allocator, nullptr), capacity_(0) {}
+
+  ~AllocationTransaction() {
+    if (DidAllocate()) {
+      MallocAdapter<A>::Deallocate(GetAllocator(), GetData(), GetCapacity());
+    }
+  }
+
+  AllocationTransaction(const AllocationTransaction&) = delete;
+  void operator=(const AllocationTransaction&) = delete;
+
+  A& GetAllocator() { return allocator_data_.template get<0>(); }
+  Pointer<A>& GetData() { return allocator_data_.template get<1>(); }
+  SizeType<A>& GetCapacity() { return capacity_; }
+
+  bool DidAllocate() { return GetData() != nullptr; }
+
+  Pointer<A> Allocate(SizeType<A> requested_capacity) {
+    Allocation<A> result =
+        MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
+    GetData() = result.data;
+    GetCapacity() = result.capacity;
+    return result.data;
+  }
+
+  ABSL_MUST_USE_RESULT Allocation<A> Release() && {
+    Allocation<A> result = {GetData(), GetCapacity()};
+    Reset();
+    return result;
+  }
+
+ private:
+  void Reset() {
+    GetData() = nullptr;
+    GetCapacity() = 0;
+  }
+
+  container_internal::CompressedTuple<A, Pointer<A>> allocator_data_;
+  SizeType<A> capacity_;
+};
+
+template <typename A>
+class ConstructionTransaction {
+ public:
+  explicit ConstructionTransaction(A& allocator)
+      : allocator_data_(allocator, nullptr), size_(0) {}
+
+  ~ConstructionTransaction() {
+    if (DidConstruct()) {
+      DestroyAdapter<A>::DestroyElements(GetAllocator(), GetData(), GetSize());
+    }
+  }
+
+  ConstructionTransaction(const ConstructionTransaction&) = delete;
+  void operator=(const ConstructionTransaction&) = delete;
+
+  A& GetAllocator() { return allocator_data_.template get<0>(); }
+  Pointer<A>& GetData() { return allocator_data_.template get<1>(); }
+  SizeType<A>& GetSize() { return size_; }
+
+  bool DidConstruct() { return GetData() != nullptr; }
+  template <typename ValueAdapter>
+  void Construct(Pointer<A> data, ValueAdapter& values, SizeType<A> size) {
+    ConstructElements<A>(GetAllocator(), data, values, size);
+    GetData() = data;
+    GetSize() = size;
+  }
+  void Commit() && {
+    GetData() = nullptr;
+    GetSize() = 0;
+  }
+
+ private:
+  container_internal::CompressedTuple<A, Pointer<A>> allocator_data_;
+  SizeType<A> size_;
+};
+
+template <typename T, size_t N, typename A>
+class Storage {
+ public:
+  static SizeType<A> NextCapacity(SizeType<A> current_capacity) {
+    return current_capacity * 2;
+  }
+
+  static SizeType<A> ComputeCapacity(SizeType<A> current_capacity,
+                                     SizeType<A> requested_capacity) {
+    return (std::max)(NextCapacity(current_capacity), requested_capacity);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Storage Constructors and Destructor
+  // ---------------------------------------------------------------------------
+
+  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
+
+  explicit Storage(const A& allocator)
+      : metadata_(allocator, /* size and is_allocated */ 0u) {}
+
+  ~Storage() {
+    if (GetSizeAndIsAllocated() == 0) {
+      // Empty and not allocated; nothing to do.
+    } else if (IsMemcpyOk<A>::value) {
+      // No destructors need to be run; just deallocate if necessary.
+      DeallocateIfAllocated();
+    } else {
+      DestroyContents();
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Storage Member Accessors
+  // ---------------------------------------------------------------------------
+
+  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
+
+  const SizeType<A>& GetSizeAndIsAllocated() const {
+    return metadata_.template get<1>();
+  }
+
+  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
+
+  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
+
+  Pointer<A> GetAllocatedData() { return data_.allocated.allocated_data; }
+
+  ConstPointer<A> GetAllocatedData() const {
+    return data_.allocated.allocated_data;
+  }
+
+  Pointer<A> GetInlinedData() {
+    return reinterpret_cast<Pointer<A>>(
+        std::addressof(data_.inlined.inlined_data[0]));
+  }
+
+  ConstPointer<A> GetInlinedData() const {
+    return reinterpret_cast<ConstPointer<A>>(
+        std::addressof(data_.inlined.inlined_data[0]));
+  }
+
+  SizeType<A> GetAllocatedCapacity() const {
+    return data_.allocated.allocated_capacity;
+  }
+
+  SizeType<A> GetInlinedCapacity() const { return static_cast<SizeType<A>>(N); }
+
+  StorageView<A> MakeStorageView() {
+    return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(),
+                                             GetAllocatedCapacity()}
+                            : StorageView<A>{GetInlinedData(), GetSize(),
+                                             GetInlinedCapacity()};
+  }
+
+  A& GetAllocator() { return metadata_.template get<0>(); }
+
+  const A& GetAllocator() const { return metadata_.template get<0>(); }
+
+  // ---------------------------------------------------------------------------
+  // Storage Member Mutators
+  // ---------------------------------------------------------------------------
+
+  ABSL_ATTRIBUTE_NOINLINE void InitFrom(const Storage& other);
+
+  template <typename ValueAdapter>
+  void Initialize(ValueAdapter values, SizeType<A> new_size);
+
+  template <typename ValueAdapter>
+  void Assign(ValueAdapter values, SizeType<A> new_size);
+
+  template <typename ValueAdapter>
+  void Resize(ValueAdapter values, SizeType<A> new_size);
+
+  template <typename ValueAdapter>
+  Iterator<A> Insert(ConstIterator<A> pos, ValueAdapter values,
+                     SizeType<A> insert_count);
+
+  template <typename... Args>
+  Reference<A> EmplaceBack(Args&&... args);
+
+  Iterator<A> Erase(ConstIterator<A> from, ConstIterator<A> to);
+
+  void Reserve(SizeType<A> requested_capacity);
+
+  void ShrinkToFit();
+
+  void Swap(Storage* other_storage_ptr);
+
+  void SetIsAllocated() {
+    GetSizeAndIsAllocated() |= static_cast<SizeType<A>>(1);
+  }
+
+  void UnsetIsAllocated() {
+    GetSizeAndIsAllocated() &= ((std::numeric_limits<SizeType<A>>::max)() - 1);
+  }
+
+  void SetSize(SizeType<A> size) {
+    GetSizeAndIsAllocated() =
+        (size << 1) | static_cast<SizeType<A>>(GetIsAllocated());
+  }
+
+  void SetAllocatedSize(SizeType<A> size) {
+    GetSizeAndIsAllocated() = (size << 1) | static_cast<SizeType<A>>(1);
+  }
+
+  void SetInlinedSize(SizeType<A> size) {
+    GetSizeAndIsAllocated() = size << static_cast<SizeType<A>>(1);
+  }
+
+  void AddSize(SizeType<A> count) {
+    GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
+  }
+
+  void SubtractSize(SizeType<A> count) {
+    ABSL_HARDENING_ASSERT(count <= GetSize());
+
+    GetSizeAndIsAllocated() -= count << static_cast<SizeType<A>>(1);
+  }
+
+  void SetAllocation(Allocation<A> allocation) {
+    data_.allocated.allocated_data = allocation.data;
+    data_.allocated.allocated_capacity = allocation.capacity;
+  }
+
+  void MemcpyFrom(const Storage& other_storage) {
+    ABSL_HARDENING_ASSERT(IsMemcpyOk<A>::value ||
+                          other_storage.GetIsAllocated());
+
+    GetSizeAndIsAllocated() = other_storage.GetSizeAndIsAllocated();
+    data_ = other_storage.data_;
+  }
+
+  void DeallocateIfAllocated() {
+    if (GetIsAllocated()) {
+      MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(),
+                                   GetAllocatedCapacity());
+    }
+  }
+
+ private:
+  ABSL_ATTRIBUTE_NOINLINE void DestroyContents();
+
+  using Metadata = container_internal::CompressedTuple<A, SizeType<A>>;
+
+  struct Allocated {
+    Pointer<A> allocated_data;
+    SizeType<A> allocated_capacity;
+  };
+
+  struct Inlined {
+    alignas(ValueType<A>) char inlined_data[sizeof(ValueType<A>[N])];
+  };
+
+  union Data {
+    Allocated allocated;
+    Inlined inlined;
+  };
+
+  template <typename... Args>
+  ABSL_ATTRIBUTE_NOINLINE Reference<A> EmplaceBackSlow(Args&&... args);
+
+  Metadata metadata_;
+  Data data_;
+};
+
+template <typename T, size_t N, typename A>
+void Storage<T, N, A>::DestroyContents() {
+  Pointer<A> data = GetIsAllocated() ? GetAllocatedData() : GetInlinedData();
+  DestroyAdapter<A>::DestroyElements(GetAllocator(), data, GetSize());
+  DeallocateIfAllocated();
+}
+
+template <typename T, size_t N, typename A>
+void Storage<T, N, A>::InitFrom(const Storage& other) {
+  const SizeType<A> n = other.GetSize();
+  ABSL_HARDENING_ASSERT(n > 0);  // Empty sources handled handled in caller.
+  ConstPointer<A> src;
+  Pointer<A> dst;
+  if (!other.GetIsAllocated()) {
+    dst = GetInlinedData();
+    src = other.GetInlinedData();
+  } else {
+    // Because this is only called from the `InlinedVector` constructors, it's
+    // safe to take on the allocation with size `0`. If `ConstructElements(...)`
+    // throws, deallocation will be automatically handled by `~Storage()`.
+    SizeType<A> requested_capacity = ComputeCapacity(GetInlinedCapacity(), n);
+    Allocation<A> allocation =
+        MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
+    SetAllocation(allocation);
+    dst = allocation.data;
+    src = other.GetAllocatedData();
+  }
+  if (IsMemcpyOk<A>::value) {
+    std::memcpy(reinterpret_cast<char*>(dst),
+                reinterpret_cast<const char*>(src), n * sizeof(ValueType<A>));
+  } else {
+    auto values = IteratorValueAdapter<A, ConstPointer<A>>(src);
+    ConstructElements<A>(GetAllocator(), dst, values, n);
+  }
+  GetSizeAndIsAllocated() = other.GetSizeAndIsAllocated();
+}
+
+template <typename T, size_t N, typename A>
+template <typename ValueAdapter>
+auto Storage<T, N, A>::Initialize(ValueAdapter values, SizeType<A> new_size)
+    -> void {
+  // Only callable from constructors!
+  ABSL_HARDENING_ASSERT(!GetIsAllocated());
+  ABSL_HARDENING_ASSERT(GetSize() == 0);
+
+  Pointer<A> construct_data;
+  if (new_size > GetInlinedCapacity()) {
+    // Because this is only called from the `InlinedVector` constructors, it's
+    // safe to take on the allocation with size `0`. If `ConstructElements(...)`
+    // throws, deallocation will be automatically handled by `~Storage()`.
+    SizeType<A> requested_capacity =
+        ComputeCapacity(GetInlinedCapacity(), new_size);
+    Allocation<A> allocation =
+        MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
+    construct_data = allocation.data;
+    SetAllocation(allocation);
+    SetIsAllocated();
+  } else {
+    construct_data = GetInlinedData();
+  }
+
+  ConstructElements<A>(GetAllocator(), construct_data, values, new_size);
+
+  // Since the initial size was guaranteed to be `0` and the allocated bit is
+  // already correct for either case, *adding* `new_size` gives us the correct
+  // result faster than setting it directly.
+  AddSize(new_size);
+}
+
+template <typename T, size_t N, typename A>
+template <typename ValueAdapter>
+auto Storage<T, N, A>::Assign(ValueAdapter values, SizeType<A> new_size)
+    -> void {
+  StorageView<A> storage_view = MakeStorageView();
+
+  AllocationTransaction<A> allocation_tx(GetAllocator());
+
+  absl::Span<ValueType<A>> assign_loop;
+  absl::Span<ValueType<A>> construct_loop;
+  absl::Span<ValueType<A>> destroy_loop;
+
+  if (new_size > storage_view.capacity) {
+    SizeType<A> requested_capacity =
+        ComputeCapacity(storage_view.capacity, new_size);
+    construct_loop = {allocation_tx.Allocate(requested_capacity), new_size};
+    destroy_loop = {storage_view.data, storage_view.size};
+  } else if (new_size > storage_view.size) {
+    assign_loop = {storage_view.data, storage_view.size};
+    construct_loop = {storage_view.data + storage_view.size,
+                      new_size - storage_view.size};
+  } else {
+    assign_loop = {storage_view.data, new_size};
+    destroy_loop = {storage_view.data + new_size, storage_view.size - new_size};
+  }
+
+  AssignElements<A>(assign_loop.data(), values, assign_loop.size());
+
+  ConstructElements<A>(GetAllocator(), construct_loop.data(), values,
+                       construct_loop.size());
+
+  DestroyAdapter<A>::DestroyElements(GetAllocator(), destroy_loop.data(),
+                                     destroy_loop.size());
+
+  if (allocation_tx.DidAllocate()) {
+    DeallocateIfAllocated();
+    SetAllocation(std::move(allocation_tx).Release());
+    SetIsAllocated();
+  }
+
+  SetSize(new_size);
+}
+
+template <typename T, size_t N, typename A>
+template <typename ValueAdapter>
+auto Storage<T, N, A>::Resize(ValueAdapter values, SizeType<A> new_size)
+    -> void {
+  StorageView<A> storage_view = MakeStorageView();
+  Pointer<A> const base = storage_view.data;
+  const SizeType<A> size = storage_view.size;
+  A& alloc = GetAllocator();
+  if (new_size <= size) {
+    // Destroy extra old elements.
+    DestroyAdapter<A>::DestroyElements(alloc, base + new_size, size - new_size);
+  } else if (new_size <= storage_view.capacity) {
+    // Construct new elements in place.
+    ConstructElements<A>(alloc, base + size, values, new_size - size);
+  } else {
+    // Steps:
+    //  a. Allocate new backing store.
+    //  b. Construct new elements in new backing store.
+    //  c. Move existing elements from old backing store to new backing store.
+    //  d. Destroy all elements in old backing store.
+    // Use transactional wrappers for the first two steps so we can roll
+    // back if necessary due to exceptions.
+    AllocationTransaction<A> allocation_tx(alloc);
+    SizeType<A> requested_capacity =
+        ComputeCapacity(storage_view.capacity, new_size);
+    Pointer<A> new_data = allocation_tx.Allocate(requested_capacity);
+
+    ConstructionTransaction<A> construction_tx(alloc);
+    construction_tx.Construct(new_data + size, values, new_size - size);
+
+    IteratorValueAdapter<A, MoveIterator<A>> move_values(
+        (MoveIterator<A>(base)));
+    ConstructElements<A>(alloc, new_data, move_values, size);
+
+    DestroyAdapter<A>::DestroyElements(alloc, base, size);
+    std::move(construction_tx).Commit();
+    DeallocateIfAllocated();
+    SetAllocation(std::move(allocation_tx).Release());
+    SetIsAllocated();
+  }
+  SetSize(new_size);
+}
+
+template <typename T, size_t N, typename A>
+template <typename ValueAdapter>
+auto Storage<T, N, A>::Insert(ConstIterator<A> pos, ValueAdapter values,
+                              SizeType<A> insert_count) -> Iterator<A> {
+  StorageView<A> storage_view = MakeStorageView();
+
+  SizeType<A> insert_index =
+      std::distance(ConstIterator<A>(storage_view.data), pos);
+  SizeType<A> insert_end_index = insert_index + insert_count;
+  SizeType<A> new_size = storage_view.size + insert_count;
+
+  if (new_size > storage_view.capacity) {
+    AllocationTransaction<A> allocation_tx(GetAllocator());
+    ConstructionTransaction<A> construction_tx(GetAllocator());
+    ConstructionTransaction<A> move_construction_tx(GetAllocator());
+
+    IteratorValueAdapter<A, MoveIterator<A>> move_values(
+        MoveIterator<A>(storage_view.data));
+
+    SizeType<A> requested_capacity =
+        ComputeCapacity(storage_view.capacity, new_size);
+    Pointer<A> new_data = allocation_tx.Allocate(requested_capacity);
+
+    construction_tx.Construct(new_data + insert_index, values, insert_count);
+
+    move_construction_tx.Construct(new_data, move_values, insert_index);
+
+    ConstructElements<A>(GetAllocator(), new_data + insert_end_index,
+                         move_values, storage_view.size - insert_index);
+
+    DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
+                                       storage_view.size);
+
+    std::move(construction_tx).Commit();
+    std::move(move_construction_tx).Commit();
+    DeallocateIfAllocated();
+    SetAllocation(std::move(allocation_tx).Release());
+
+    SetAllocatedSize(new_size);
+    return Iterator<A>(new_data + insert_index);
+  } else {
+    SizeType<A> move_construction_destination_index =
+        (std::max)(insert_end_index, storage_view.size);
+
+    ConstructionTransaction<A> move_construction_tx(GetAllocator());
+
+    IteratorValueAdapter<A, MoveIterator<A>> move_construction_values(
+        MoveIterator<A>(storage_view.data +
+                        (move_construction_destination_index - insert_count)));
+    absl::Span<ValueType<A>> move_construction = {
+        storage_view.data + move_construction_destination_index,
+        new_size - move_construction_destination_index};
+
+    Pointer<A> move_assignment_values = storage_view.data + insert_index;
+    absl::Span<ValueType<A>> move_assignment = {
+        storage_view.data + insert_end_index,
+        move_construction_destination_index - insert_end_index};
+
+    absl::Span<ValueType<A>> insert_assignment = {move_assignment_values,
+                                                  move_construction.size()};
+
+    absl::Span<ValueType<A>> insert_construction = {
+        insert_assignment.data() + insert_assignment.size(),
+        insert_count - insert_assignment.size()};
+
+    move_construction_tx.Construct(move_construction.data(),
+                                   move_construction_values,
+                                   move_construction.size());
+
+    for (Pointer<A>
+             destination = move_assignment.data() + move_assignment.size(),
+             last_destination = move_assignment.data(),
+             source = move_assignment_values + move_assignment.size();
+         ;) {
+      --destination;
+      --source;
+      if (destination < last_destination) break;
+      *destination = std::move(*source);
+    }
+
+    AssignElements<A>(insert_assignment.data(), values,
+                      insert_assignment.size());
+
+    ConstructElements<A>(GetAllocator(), insert_construction.data(), values,
+                         insert_construction.size());
+
+    std::move(move_construction_tx).Commit();
+
+    AddSize(insert_count);
+    return Iterator<A>(storage_view.data + insert_index);
+  }
+}
+
+template <typename T, size_t N, typename A>
+template <typename... Args>
+auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
+  StorageView<A> storage_view = MakeStorageView();
+  const SizeType<A> n = storage_view.size;
+  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
+    // Fast path; new element fits.
+    Pointer<A> last_ptr = storage_view.data + n;
+    AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
+                                  std::forward<Args>(args)...);
+    AddSize(1);
+    return *last_ptr;
+  }
+  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
+  return EmplaceBackSlow(std::forward<Args>(args)...);
+}
+
+template <typename T, size_t N, typename A>
+template <typename... Args>
+auto Storage<T, N, A>::EmplaceBackSlow(Args&&... args) -> Reference<A> {
+  StorageView<A> storage_view = MakeStorageView();
+  AllocationTransaction<A> allocation_tx(GetAllocator());
+  IteratorValueAdapter<A, MoveIterator<A>> move_values(
+      MoveIterator<A>(storage_view.data));
+  SizeType<A> requested_capacity = NextCapacity(storage_view.capacity);
+  Pointer<A> construct_data = allocation_tx.Allocate(requested_capacity);
+  Pointer<A> last_ptr = construct_data + storage_view.size;
+
+  // Construct new element.
+  AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
+                                std::forward<Args>(args)...);
+  // Move elements from old backing store to new backing store.
+  ABSL_INTERNAL_TRY {
+    ConstructElements<A>(GetAllocator(), allocation_tx.GetData(), move_values,
+                         storage_view.size);
+  }
+  ABSL_INTERNAL_CATCH_ANY {
+    AllocatorTraits<A>::destroy(GetAllocator(), last_ptr);
+    ABSL_INTERNAL_RETHROW;
+  }
+  // Destroy elements in old backing store.
+  DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
+                                     storage_view.size);
+
+  DeallocateIfAllocated();
+  SetAllocation(std::move(allocation_tx).Release());
+  SetIsAllocated();
+  AddSize(1);
+  return *last_ptr;
+}
+
+template <typename T, size_t N, typename A>
+auto Storage<T, N, A>::Erase(ConstIterator<A> from, ConstIterator<A> to)
+    -> Iterator<A> {
+  StorageView<A> storage_view = MakeStorageView();
+
+  SizeType<A> erase_size = std::distance(from, to);
+  SizeType<A> erase_index =
+      std::distance(ConstIterator<A>(storage_view.data), from);
+  SizeType<A> erase_end_index = erase_index + erase_size;
+
+  IteratorValueAdapter<A, MoveIterator<A>> move_values(
+      MoveIterator<A>(storage_view.data + erase_end_index));
+
+  AssignElements<A>(storage_view.data + erase_index, move_values,
+                    storage_view.size - erase_end_index);
+
+  DestroyAdapter<A>::DestroyElements(
+      GetAllocator(), storage_view.data + (storage_view.size - erase_size),
+      erase_size);
+
+  SubtractSize(erase_size);
+  return Iterator<A>(storage_view.data + erase_index);
+}
+
+template <typename T, size_t N, typename A>
+auto Storage<T, N, A>::Reserve(SizeType<A> requested_capacity) -> void {
+  StorageView<A> storage_view = MakeStorageView();
+
+  if (ABSL_PREDICT_FALSE(requested_capacity <= storage_view.capacity)) return;
+
+  AllocationTransaction<A> allocation_tx(GetAllocator());
+
+  IteratorValueAdapter<A, MoveIterator<A>> move_values(
+      MoveIterator<A>(storage_view.data));
+
+  SizeType<A> new_requested_capacity =
+      ComputeCapacity(storage_view.capacity, requested_capacity);
+  Pointer<A> new_data = allocation_tx.Allocate(new_requested_capacity);
+
+  ConstructElements<A>(GetAllocator(), new_data, move_values,
+                       storage_view.size);
+
+  DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
+                                     storage_view.size);
+
+  DeallocateIfAllocated();
+  SetAllocation(std::move(allocation_tx).Release());
+  SetIsAllocated();
+}
+
+template <typename T, size_t N, typename A>
+auto Storage<T, N, A>::ShrinkToFit() -> void {
+  // May only be called on allocated instances!
+  ABSL_HARDENING_ASSERT(GetIsAllocated());
+
+  StorageView<A> storage_view{GetAllocatedData(), GetSize(),
+                              GetAllocatedCapacity()};
+
+  if (ABSL_PREDICT_FALSE(storage_view.size == storage_view.capacity)) return;
+
+  AllocationTransaction<A> allocation_tx(GetAllocator());
+
+  IteratorValueAdapter<A, MoveIterator<A>> move_values(
+      MoveIterator<A>(storage_view.data));
+
+  Pointer<A> construct_data;
+  if (storage_view.size > GetInlinedCapacity()) {
+    SizeType<A> requested_capacity = storage_view.size;
+    construct_data = allocation_tx.Allocate(requested_capacity);
+    if (allocation_tx.GetCapacity() >= storage_view.capacity) {
+      // Already using the smallest available heap allocation.
+      return;
+    }
+  } else {
+    construct_data = GetInlinedData();
+  }
+
+  ABSL_INTERNAL_TRY {
+    ConstructElements<A>(GetAllocator(), construct_data, move_values,
+                         storage_view.size);
+  }
+  ABSL_INTERNAL_CATCH_ANY {
+    SetAllocation({storage_view.data, storage_view.capacity});
+    ABSL_INTERNAL_RETHROW;
+  }
+
+  DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
+                                     storage_view.size);
+
+  MallocAdapter<A>::Deallocate(GetAllocator(), storage_view.data,
+                               storage_view.capacity);
+
+  if (allocation_tx.DidAllocate()) {
+    SetAllocation(std::move(allocation_tx).Release());
+  } else {
+    UnsetIsAllocated();
+  }
+}
+
+template <typename T, size_t N, typename A>
+auto Storage<T, N, A>::Swap(Storage* other_storage_ptr) -> void {
+  using std::swap;
+  ABSL_HARDENING_ASSERT(this != other_storage_ptr);
+
+  if (GetIsAllocated() && other_storage_ptr->GetIsAllocated()) {
+    swap(data_.allocated, other_storage_ptr->data_.allocated);
+  } else if (!GetIsAllocated() && !other_storage_ptr->GetIsAllocated()) {
+    Storage* small_ptr = this;
+    Storage* large_ptr = other_storage_ptr;
+    if (small_ptr->GetSize() > large_ptr->GetSize()) swap(small_ptr, large_ptr);
+
+    for (SizeType<A> i = 0; i < small_ptr->GetSize(); ++i) {
+      swap(small_ptr->GetInlinedData()[i], large_ptr->GetInlinedData()[i]);
+    }
+
+    IteratorValueAdapter<A, MoveIterator<A>> move_values(
+        MoveIterator<A>(large_ptr->GetInlinedData() + small_ptr->GetSize()));
+
+    ConstructElements<A>(large_ptr->GetAllocator(),
+                         small_ptr->GetInlinedData() + small_ptr->GetSize(),
+                         move_values,
+                         large_ptr->GetSize() - small_ptr->GetSize());
+
+    DestroyAdapter<A>::DestroyElements(
+        large_ptr->GetAllocator(),
+        large_ptr->GetInlinedData() + small_ptr->GetSize(),
+        large_ptr->GetSize() - small_ptr->GetSize());
+  } else {
+    Storage* allocated_ptr = this;
+    Storage* inlined_ptr = other_storage_ptr;
+    if (!allocated_ptr->GetIsAllocated()) swap(allocated_ptr, inlined_ptr);
+
+    StorageView<A> allocated_storage_view{
+        allocated_ptr->GetAllocatedData(), allocated_ptr->GetSize(),
+        allocated_ptr->GetAllocatedCapacity()};
+
+    IteratorValueAdapter<A, MoveIterator<A>> move_values(
+        MoveIterator<A>(inlined_ptr->GetInlinedData()));
+
+    ABSL_INTERNAL_TRY {
+      ConstructElements<A>(inlined_ptr->GetAllocator(),
+                           allocated_ptr->GetInlinedData(), move_values,
+                           inlined_ptr->GetSize());
+    }
+    ABSL_INTERNAL_CATCH_ANY {
+      allocated_ptr->SetAllocation(Allocation<A>{
+          allocated_storage_view.data, allocated_storage_view.capacity});
+      ABSL_INTERNAL_RETHROW;
+    }
+
+    DestroyAdapter<A>::DestroyElements(inlined_ptr->GetAllocator(),
+                                       inlined_ptr->GetInlinedData(),
+                                       inlined_ptr->GetSize());
+
+    inlined_ptr->SetAllocation(Allocation<A>{allocated_storage_view.data,
+                                             allocated_storage_view.capacity});
+  }
+
+  swap(GetSizeAndIsAllocated(), other_storage_ptr->GetSizeAndIsAllocated());
+  swap(GetAllocator(), other_storage_ptr->GetAllocator());
+}
+
+// End ignore "array-bounds"
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+}  // namespace inlined_vector_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/layout.h b/CAPI/cpp/grpc/include/absl/container/internal/layout.h
new file mode 100644
index 0000000..a59a243
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/layout.h
@@ -0,0 +1,743 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+//                           MOTIVATION AND TUTORIAL
+//
+// If you want to put in a single heap allocation N doubles followed by M ints,
+// it's easy if N and M are known at compile time.
+//
+//   struct S {
+//     double a[N];
+//     int b[M];
+//   };
+//
+//   S* p = new S;
+//
+// But what if N and M are known only in run time? Class template Layout to the
+// rescue! It's a portable generalization of the technique known as struct hack.
+//
+//   // This object will tell us everything we need to know about the memory
+//   // layout of double[N] followed by int[M]. It's structurally identical to
+//   // size_t[2] that stores N and M. It's very cheap to create.
+//   const Layout<double, int> layout(N, M);
+//
+//   // Allocate enough memory for both arrays. `AllocSize()` tells us how much
+//   // memory is needed. We are free to use any allocation function we want as
+//   // long as it returns aligned memory.
+//   std::unique_ptr<unsigned char[]> p(new unsigned char[layout.AllocSize()]);
+//
+//   // Obtain the pointer to the array of doubles.
+//   // Equivalent to `reinterpret_cast<double*>(p.get())`.
+//   //
+//   // We could have written layout.Pointer<0>(p) instead. If all the types are
+//   // unique you can use either form, but if some types are repeated you must
+//   // use the index form.
+//   double* a = layout.Pointer<double>(p.get());
+//
+//   // Obtain the pointer to the array of ints.
+//   // Equivalent to `reinterpret_cast<int*>(p.get() + N * 8)`.
+//   int* b = layout.Pointer<int>(p);
+//
+// If we are unable to specify sizes of all fields, we can pass as many sizes as
+// we can to `Partial()`. In return, it'll allow us to access the fields whose
+// locations and sizes can be computed from the provided information.
+// `Partial()` comes in handy when the array sizes are embedded into the
+// allocation.
+//
+//   // size_t[1] containing N, size_t[1] containing M, double[N], int[M].
+//   using L = Layout<size_t, size_t, double, int>;
+//
+//   unsigned char* Allocate(size_t n, size_t m) {
+//     const L layout(1, 1, n, m);
+//     unsigned char* p = new unsigned char[layout.AllocSize()];
+//     *layout.Pointer<0>(p) = n;
+//     *layout.Pointer<1>(p) = m;
+//     return p;
+//   }
+//
+//   void Use(unsigned char* p) {
+//     // First, extract N and M.
+//     // Specify that the first array has only one element. Using `prefix` we
+//     // can access the first two arrays but not more.
+//     constexpr auto prefix = L::Partial(1);
+//     size_t n = *prefix.Pointer<0>(p);
+//     size_t m = *prefix.Pointer<1>(p);
+//
+//     // Now we can get pointers to the payload.
+//     const L layout(1, 1, n, m);
+//     double* a = layout.Pointer<double>(p);
+//     int* b = layout.Pointer<int>(p);
+//   }
+//
+// The layout we used above combines fixed-size with dynamically-sized fields.
+// This is quite common. Layout is optimized for this use case and generates
+// optimal code. All computations that can be performed at compile time are
+// indeed performed at compile time.
+//
+// Efficiency tip: The order of fields matters. In `Layout<T1, ..., TN>` try to
+// ensure that `alignof(T1) >= ... >= alignof(TN)`. This way you'll have no
+// padding in between arrays.
+//
+// You can manually override the alignment of an array by wrapping the type in
+// `Aligned<T, N>`. `Layout<..., Aligned<T, N>, ...>` has exactly the same API
+// and behavior as `Layout<..., T, ...>` except that the first element of the
+// array of `T` is aligned to `N` (the rest of the elements follow without
+// padding). `N` cannot be less than `alignof(T)`.
+//
+// `AllocSize()` and `Pointer()` are the most basic methods for dealing with
+// memory layouts. Check out the reference or code below to discover more.
+//
+//                            EXAMPLE
+//
+//   // Immutable move-only string with sizeof equal to sizeof(void*). The
+//   // string size and the characters are kept in the same heap allocation.
+//   class CompactString {
+//    public:
+//     CompactString(const char* s = "") {
+//       const size_t size = strlen(s);
+//       // size_t[1] followed by char[size + 1].
+//       const L layout(1, size + 1);
+//       p_.reset(new unsigned char[layout.AllocSize()]);
+//       // If running under ASAN, mark the padding bytes, if any, to catch
+//       // memory errors.
+//       layout.PoisonPadding(p_.get());
+//       // Store the size in the allocation.
+//       *layout.Pointer<size_t>(p_.get()) = size;
+//       // Store the characters in the allocation.
+//       memcpy(layout.Pointer<char>(p_.get()), s, size + 1);
+//     }
+//
+//     size_t size() const {
+//       // Equivalent to reinterpret_cast<size_t&>(*p).
+//       return *L::Partial().Pointer<size_t>(p_.get());
+//     }
+//
+//     const char* c_str() const {
+//       // Equivalent to reinterpret_cast<char*>(p.get() + sizeof(size_t)).
+//       // The argument in Partial(1) specifies that we have size_t[1] in front
+//       // of the characters.
+//       return L::Partial(1).Pointer<char>(p_.get());
+//     }
+//
+//    private:
+//     // Our heap allocation contains a size_t followed by an array of chars.
+//     using L = Layout<size_t, char>;
+//     std::unique_ptr<unsigned char[]> p_;
+//   };
+//
+//   int main() {
+//     CompactString s = "hello";
+//     assert(s.size() == 5);
+//     assert(strcmp(s.c_str(), "hello") == 0);
+//   }
+//
+//                               DOCUMENTATION
+//
+// The interface exported by this file consists of:
+// - class `Layout<>` and its public members.
+// - The public members of class `internal_layout::LayoutImpl<>`. That class
+//   isn't intended to be used directly, and its name and template parameter
+//   list are internal implementation details, but the class itself provides
+//   most of the functionality in this file. See comments on its members for
+//   detailed documentation.
+//
+// `Layout<T1,... Tn>::Partial(count1,..., countm)` (where `m` <= `n`) returns a
+// `LayoutImpl<>` object. `Layout<T1,..., Tn> layout(count1,..., countn)`
+// creates a `Layout` object, which exposes the same functionality by inheriting
+// from `LayoutImpl<>`.
+
+#ifndef ABSL_CONTAINER_INTERNAL_LAYOUT_H_
+#define ABSL_CONTAINER_INTERNAL_LAYOUT_H_
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <ostream>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/str_cat.h"
+#include "absl/types/span.h"
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#include <sanitizer/asan_interface.h>
+#endif
+
+#if defined(__GXX_RTTI)
+#define ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#endif
+
+#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#include <cxxabi.h>
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// A type wrapper that instructs `Layout` to use the specific alignment for the
+// array. `Layout<..., Aligned<T, N>, ...>` has exactly the same API
+// and behavior as `Layout<..., T, ...>` except that the first element of the
+// array of `T` is aligned to `N` (the rest of the elements follow without
+// padding).
+//
+// Requires: `N >= alignof(T)` and `N` is a power of 2.
+template <class T, size_t N>
+struct Aligned;
+
+namespace internal_layout {
+
+template <class T>
+struct NotAligned {};
+
+template <class T, size_t N>
+struct NotAligned<const Aligned<T, N>> {
+  static_assert(sizeof(T) == 0, "Aligned<T, N> cannot be const-qualified");
+};
+
+template <size_t>
+using IntToSize = size_t;
+
+template <class>
+using TypeToSize = size_t;
+
+template <class T>
+struct Type : NotAligned<T> {
+  using type = T;
+};
+
+template <class T, size_t N>
+struct Type<Aligned<T, N>> {
+  using type = T;
+};
+
+template <class T>
+struct SizeOf : NotAligned<T>, std::integral_constant<size_t, sizeof(T)> {};
+
+template <class T, size_t N>
+struct SizeOf<Aligned<T, N>> : std::integral_constant<size_t, sizeof(T)> {};
+
+// Note: workaround for https://gcc.gnu.org/PR88115
+template <class T>
+struct AlignOf : NotAligned<T> {
+  static constexpr size_t value = alignof(T);
+};
+
+template <class T, size_t N>
+struct AlignOf<Aligned<T, N>> {
+  static_assert(N % alignof(T) == 0,
+                "Custom alignment can't be lower than the type's alignment");
+  static constexpr size_t value = N;
+};
+
+// Does `Ts...` contain `T`?
+template <class T, class... Ts>
+using Contains = absl::disjunction<std::is_same<T, Ts>...>;
+
+template <class From, class To>
+using CopyConst =
+    typename std::conditional<std::is_const<From>::value, const To, To>::type;
+
+// Note: We're not qualifying this with absl:: because it doesn't compile under
+// MSVC.
+template <class T>
+using SliceType = Span<T>;
+
+// This namespace contains no types. It prevents functions defined in it from
+// being found by ADL.
+namespace adl_barrier {
+
+template <class Needle, class... Ts>
+constexpr size_t Find(Needle, Needle, Ts...) {
+  static_assert(!Contains<Needle, Ts...>(), "Duplicate element type");
+  return 0;
+}
+
+template <class Needle, class T, class... Ts>
+constexpr size_t Find(Needle, T, Ts...) {
+  return adl_barrier::Find(Needle(), Ts()...) + 1;
+}
+
+constexpr bool IsPow2(size_t n) { return !(n & (n - 1)); }
+
+// Returns `q * m` for the smallest `q` such that `q * m >= n`.
+// Requires: `m` is a power of two. It's enforced by IsLegalElementType below.
+constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
+
+constexpr size_t Min(size_t a, size_t b) { return b < a ? b : a; }
+
+constexpr size_t Max(size_t a) { return a; }
+
+template <class... Ts>
+constexpr size_t Max(size_t a, size_t b, Ts... rest) {
+  return adl_barrier::Max(b < a ? a : b, rest...);
+}
+
+template <class T>
+std::string TypeName() {
+  std::string out;
+  int status = 0;
+  char* demangled = nullptr;
+#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
+  demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
+#endif
+  if (status == 0 && demangled != nullptr) {  // Demangling succeeded.
+    absl::StrAppend(&out, "<", demangled, ">");
+    free(demangled);
+  } else {
+#if defined(__GXX_RTTI) || defined(_CPPRTTI)
+    absl::StrAppend(&out, "<", typeid(T).name(), ">");
+#endif
+  }
+  return out;
+}
+
+}  // namespace adl_barrier
+
+template <bool C>
+using EnableIf = typename std::enable_if<C, int>::type;
+
+// Can `T` be a template argument of `Layout`?
+template <class T>
+using IsLegalElementType = std::integral_constant<
+    bool, !std::is_reference<T>::value && !std::is_volatile<T>::value &&
+              !std::is_reference<typename Type<T>::type>::value &&
+              !std::is_volatile<typename Type<T>::type>::value &&
+              adl_barrier::IsPow2(AlignOf<T>::value)>;
+
+template <class Elements, class SizeSeq, class OffsetSeq>
+class LayoutImpl;
+
+// Public base class of `Layout` and the result type of `Layout::Partial()`.
+//
+// `Elements...` contains all template arguments of `Layout` that created this
+// instance.
+//
+// `SizeSeq...` is `[0, NumSizes)` where `NumSizes` is the number of arguments
+// passed to `Layout::Partial()` or `Layout::Layout()`.
+//
+// `OffsetSeq...` is `[0, NumOffsets)` where `NumOffsets` is
+// `Min(sizeof...(Elements), NumSizes + 1)` (the number of arrays for which we
+// can compute offsets).
+template <class... Elements, size_t... SizeSeq, size_t... OffsetSeq>
+class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
+                 absl::index_sequence<OffsetSeq...>> {
+ private:
+  static_assert(sizeof...(Elements) > 0, "At least one field is required");
+  static_assert(absl::conjunction<IsLegalElementType<Elements>...>::value,
+                "Invalid element type (see IsLegalElementType)");
+
+  enum {
+    NumTypes = sizeof...(Elements),
+    NumSizes = sizeof...(SizeSeq),
+    NumOffsets = sizeof...(OffsetSeq),
+  };
+
+  // These are guaranteed by `Layout`.
+  static_assert(NumOffsets == adl_barrier::Min(NumTypes, NumSizes + 1),
+                "Internal error");
+  static_assert(NumTypes > 0, "Internal error");
+
+  // Returns the index of `T` in `Elements...`. Results in a compilation error
+  // if `Elements...` doesn't contain exactly one instance of `T`.
+  template <class T>
+  static constexpr size_t ElementIndex() {
+    static_assert(Contains<Type<T>, Type<typename Type<Elements>::type>...>(),
+                  "Type not found");
+    return adl_barrier::Find(Type<T>(),
+                             Type<typename Type<Elements>::type>()...);
+  }
+
+  template <size_t N>
+  using ElementAlignment =
+      AlignOf<typename std::tuple_element<N, std::tuple<Elements...>>::type>;
+
+ public:
+  // Element types of all arrays packed in a tuple.
+  using ElementTypes = std::tuple<typename Type<Elements>::type...>;
+
+  // Element type of the Nth array.
+  template <size_t N>
+  using ElementType = typename std::tuple_element<N, ElementTypes>::type;
+
+  constexpr explicit LayoutImpl(IntToSize<SizeSeq>... sizes)
+      : size_{sizes...} {}
+
+  // Alignment of the layout, equal to the strictest alignment of all elements.
+  // All pointers passed to the methods of layout must be aligned to this value.
+  static constexpr size_t Alignment() {
+    return adl_barrier::Max(AlignOf<Elements>::value...);
+  }
+
+  // Offset in bytes of the Nth array.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   assert(x.Offset<0>() == 0);   // The ints starts from 0.
+  //   assert(x.Offset<1>() == 16);  // The doubles starts from 16.
+  //
+  // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
+  template <size_t N, EnableIf<N == 0> = 0>
+  constexpr size_t Offset() const {
+    return 0;
+  }
+
+  template <size_t N, EnableIf<N != 0> = 0>
+  constexpr size_t Offset() const {
+    static_assert(N < NumOffsets, "Index out of bounds");
+    return adl_barrier::Align(
+        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
+        ElementAlignment<N>::value);
+  }
+
+  // Offset in bytes of the array with the specified element type. There must
+  // be exactly one such array and its zero-based index must be at most
+  // `NumSizes`.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   assert(x.Offset<int>() == 0);      // The ints starts from 0.
+  //   assert(x.Offset<double>() == 16);  // The doubles starts from 16.
+  template <class T>
+  constexpr size_t Offset() const {
+    return Offset<ElementIndex<T>()>();
+  }
+
+  // Offsets in bytes of all arrays for which the offsets are known.
+  constexpr std::array<size_t, NumOffsets> Offsets() const {
+    return {{Offset<OffsetSeq>()...}};
+  }
+
+  // The number of elements in the Nth array. This is the Nth argument of
+  // `Layout::Partial()` or `Layout::Layout()` (zero-based).
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   assert(x.Size<0>() == 3);
+  //   assert(x.Size<1>() == 4);
+  //
+  // Requires: `N < NumSizes`.
+  template <size_t N>
+  constexpr size_t Size() const {
+    static_assert(N < NumSizes, "Index out of bounds");
+    return size_[N];
+  }
+
+  // The number of elements in the array with the specified element type.
+  // There must be exactly one such array and its zero-based index must be
+  // at most `NumSizes`.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   assert(x.Size<int>() == 3);
+  //   assert(x.Size<double>() == 4);
+  template <class T>
+  constexpr size_t Size() const {
+    return Size<ElementIndex<T>()>();
+  }
+
+  // The number of elements of all arrays for which they are known.
+  constexpr std::array<size_t, NumSizes> Sizes() const {
+    return {{Size<SizeSeq>()...}};
+  }
+
+  // Pointer to the beginning of the Nth array.
+  //
+  // `Char` must be `[const] [signed|unsigned] char`.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   unsigned char* p = new unsigned char[x.AllocSize()];
+  //   int* ints = x.Pointer<0>(p);
+  //   double* doubles = x.Pointer<1>(p);
+  //
+  // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
+  // Requires: `p` is aligned to `Alignment()`.
+  template <size_t N, class Char>
+  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
+    using C = typename std::remove_const<Char>::type;
+    static_assert(
+        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
+            std::is_same<C, signed char>(),
+        "The argument must be a pointer to [const] [signed|unsigned] char");
+    constexpr size_t alignment = Alignment();
+    (void)alignment;
+    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
+    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
+  }
+
+  // Pointer to the beginning of the array with the specified element type.
+  // There must be exactly one such array and its zero-based index must be at
+  // most `NumSizes`.
+  //
+  // `Char` must be `[const] [signed|unsigned] char`.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   unsigned char* p = new unsigned char[x.AllocSize()];
+  //   int* ints = x.Pointer<int>(p);
+  //   double* doubles = x.Pointer<double>(p);
+  //
+  // Requires: `p` is aligned to `Alignment()`.
+  template <class T, class Char>
+  CopyConst<Char, T>* Pointer(Char* p) const {
+    return Pointer<ElementIndex<T>()>(p);
+  }
+
+  // Pointers to all arrays for which pointers are known.
+  //
+  // `Char` must be `[const] [signed|unsigned] char`.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   unsigned char* p = new unsigned char[x.AllocSize()];
+  //
+  //   int* ints;
+  //   double* doubles;
+  //   std::tie(ints, doubles) = x.Pointers(p);
+  //
+  // Requires: `p` is aligned to `Alignment()`.
+  //
+  // Note: We're not using ElementType alias here because it does not compile
+  // under MSVC.
+  template <class Char>
+  std::tuple<CopyConst<
+      Char, typename std::tuple_element<OffsetSeq, ElementTypes>::type>*...>
+  Pointers(Char* p) const {
+    return std::tuple<CopyConst<Char, ElementType<OffsetSeq>>*...>(
+        Pointer<OffsetSeq>(p)...);
+  }
+
+  // The Nth array.
+  //
+  // `Char` must be `[const] [signed|unsigned] char`.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   unsigned char* p = new unsigned char[x.AllocSize()];
+  //   Span<int> ints = x.Slice<0>(p);
+  //   Span<double> doubles = x.Slice<1>(p);
+  //
+  // Requires: `N < NumSizes`.
+  // Requires: `p` is aligned to `Alignment()`.
+  template <size_t N, class Char>
+  SliceType<CopyConst<Char, ElementType<N>>> Slice(Char* p) const {
+    return SliceType<CopyConst<Char, ElementType<N>>>(Pointer<N>(p), Size<N>());
+  }
+
+  // The array with the specified element type. There must be exactly one
+  // such array and its zero-based index must be less than `NumSizes`.
+  //
+  // `Char` must be `[const] [signed|unsigned] char`.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   unsigned char* p = new unsigned char[x.AllocSize()];
+  //   Span<int> ints = x.Slice<int>(p);
+  //   Span<double> doubles = x.Slice<double>(p);
+  //
+  // Requires: `p` is aligned to `Alignment()`.
+  template <class T, class Char>
+  SliceType<CopyConst<Char, T>> Slice(Char* p) const {
+    return Slice<ElementIndex<T>()>(p);
+  }
+
+  // All arrays with known sizes.
+  //
+  // `Char` must be `[const] [signed|unsigned] char`.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   unsigned char* p = new unsigned char[x.AllocSize()];
+  //
+  //   Span<int> ints;
+  //   Span<double> doubles;
+  //   std::tie(ints, doubles) = x.Slices(p);
+  //
+  // Requires: `p` is aligned to `Alignment()`.
+  //
+  // Note: We're not using ElementType alias here because it does not compile
+  // under MSVC.
+  template <class Char>
+  std::tuple<SliceType<CopyConst<
+      Char, typename std::tuple_element<SizeSeq, ElementTypes>::type>>...>
+  Slices(Char* p) const {
+    // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63875 (fixed
+    // in 6.1).
+    (void)p;
+    return std::tuple<SliceType<CopyConst<Char, ElementType<SizeSeq>>>...>(
+        Slice<SizeSeq>(p)...);
+  }
+
+  // The size of the allocation that fits all arrays.
+  //
+  //   // int[3], 4 bytes of padding, double[4].
+  //   Layout<int, double> x(3, 4);
+  //   unsigned char* p = new unsigned char[x.AllocSize()];  // 48 bytes
+  //
+  // Requires: `NumSizes == sizeof...(Ts)`.
+  constexpr size_t AllocSize() const {
+    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
+    return Offset<NumTypes - 1>() +
+        SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1];
+  }
+
+  // If built with --config=asan, poisons padding bytes (if any) in the
+  // allocation. The pointer must point to a memory block at least
+  // `AllocSize()` bytes in length.
+  //
+  // `Char` must be `[const] [signed|unsigned] char`.
+  //
+  // Requires: `p` is aligned to `Alignment()`.
+  template <class Char, size_t N = NumOffsets - 1, EnableIf<N == 0> = 0>
+  void PoisonPadding(const Char* p) const {
+    Pointer<0>(p);  // verify the requirements on `Char` and `p`
+  }
+
+  template <class Char, size_t N = NumOffsets - 1, EnableIf<N != 0> = 0>
+  void PoisonPadding(const Char* p) const {
+    static_assert(N < NumOffsets, "Index out of bounds");
+    (void)p;
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+    PoisonPadding<Char, N - 1>(p);
+    // The `if` is an optimization. It doesn't affect the observable behaviour.
+    if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value) {
+      size_t start =
+          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1];
+      ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start);
+    }
+#endif
+  }
+
+  // Human-readable description of the memory layout. Useful for debugging.
+  // Slow.
+  //
+  //   // char[5], 3 bytes of padding, int[3], 4 bytes of padding, followed
+  //   // by an unknown number of doubles.
+  //   auto x = Layout<char, int, double>::Partial(5, 3);
+  //   assert(x.DebugString() ==
+  //          "@0<char>(1)[5]; @8<int>(4)[3]; @24<double>(8)");
+  //
+  // Each field is in the following format: @offset<type>(sizeof)[size] (<type>
+  // may be missing depending on the target platform). For example,
+  // @8<int>(4)[3] means that at offset 8 we have an array of ints, where each
+  // int is 4 bytes, and we have 3 of those ints. The size of the last field may
+  // be missing (as in the example above). Only fields with known offsets are
+  // described. Type names may differ across platforms: one compiler might
+  // produce "unsigned*" where another produces "unsigned int *".
+  std::string DebugString() const {
+    const auto offsets = Offsets();
+    const size_t sizes[] = {SizeOf<ElementType<OffsetSeq>>::value...};
+    const std::string types[] = {
+        adl_barrier::TypeName<ElementType<OffsetSeq>>()...};
+    std::string res = absl::StrCat("@0", types[0], "(", sizes[0], ")");
+    for (size_t i = 0; i != NumOffsets - 1; ++i) {
+      absl::StrAppend(&res, "[", size_[i], "]; @", offsets[i + 1], types[i + 1],
+                      "(", sizes[i + 1], ")");
+    }
+    // NumSizes is a constant that may be zero. Some compilers cannot see that
+    // inside the if statement "size_[NumSizes - 1]" must be valid.
+    int last = static_cast<int>(NumSizes) - 1;
+    if (NumTypes == NumSizes && last >= 0) {
+      absl::StrAppend(&res, "[", size_[last], "]");
+    }
+    return res;
+  }
+
+ private:
+  // Arguments of `Layout::Partial()` or `Layout::Layout()`.
+  size_t size_[NumSizes > 0 ? NumSizes : 1];
+};
+
+template <size_t NumSizes, class... Ts>
+using LayoutType = LayoutImpl<
+    std::tuple<Ts...>, absl::make_index_sequence<NumSizes>,
+    absl::make_index_sequence<adl_barrier::Min(sizeof...(Ts), NumSizes + 1)>>;
+
+}  // namespace internal_layout
+
+// Descriptor of arrays of various types and sizes laid out in memory one after
+// another. See the top of the file for documentation.
+//
+// Check out the public API of internal_layout::LayoutImpl above. The type is
+// internal to the library but its methods are public, and they are inherited
+// by `Layout`.
+template <class... Ts>
+class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> {
+ public:
+  static_assert(sizeof...(Ts) > 0, "At least one field is required");
+  static_assert(
+      absl::conjunction<internal_layout::IsLegalElementType<Ts>...>::value,
+      "Invalid element type (see IsLegalElementType)");
+
+  // The result type of `Partial()` with `NumSizes` arguments.
+  template <size_t NumSizes>
+  using PartialType = internal_layout::LayoutType<NumSizes, Ts...>;
+
+  // `Layout` knows the element types of the arrays we want to lay out in
+  // memory but not the number of elements in each array.
+  // `Partial(size1, ..., sizeN)` allows us to specify the latter. The
+  // resulting immutable object can be used to obtain pointers to the
+  // individual arrays.
+  //
+  // It's allowed to pass fewer array sizes than the number of arrays. E.g.,
+  // if all you need is to the offset of the second array, you only need to
+  // pass one argument -- the number of elements in the first array.
+  //
+  //   // int[3] followed by 4 bytes of padding and an unknown number of
+  //   // doubles.
+  //   auto x = Layout<int, double>::Partial(3);
+  //   // doubles start at byte 16.
+  //   assert(x.Offset<1>() == 16);
+  //
+  // If you know the number of elements in all arrays, you can still call
+  // `Partial()` but it's more convenient to use the constructor of `Layout`.
+  //
+  //   Layout<int, double> x(3, 5);
+  //
+  // Note: The sizes of the arrays must be specified in number of elements,
+  // not in bytes.
+  //
+  // Requires: `sizeof...(Sizes) <= sizeof...(Ts)`.
+  // Requires: all arguments are convertible to `size_t`.
+  template <class... Sizes>
+  static constexpr PartialType<sizeof...(Sizes)> Partial(Sizes&&... sizes) {
+    static_assert(sizeof...(Sizes) <= sizeof...(Ts), "");
+    return PartialType<sizeof...(Sizes)>(absl::forward<Sizes>(sizes)...);
+  }
+
+  // Creates a layout with the sizes of all arrays specified. If you know
+  // only the sizes of the first N arrays (where N can be zero), you can use
+  // `Partial()` defined above. The constructor is essentially equivalent to
+  // calling `Partial()` and passing in all array sizes; the constructor is
+  // provided as a convenient abbreviation.
+  //
+  // Note: The sizes of the arrays must be specified in number of elements,
+  // not in bytes.
+  constexpr explicit Layout(internal_layout::TypeToSize<Ts>... sizes)
+      : internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_LAYOUT_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/node_slot_policy.h b/CAPI/cpp/grpc/include/absl/container/internal/node_slot_policy.h
new file mode 100644
index 0000000..baba574
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/node_slot_policy.h
@@ -0,0 +1,92 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Adapts a policy for nodes.
+//
+// The node policy should model:
+//
+// struct Policy {
+//   // Returns a new node allocated and constructed using the allocator, using
+//   // the specified arguments.
+//   template <class Alloc, class... Args>
+//   value_type* new_element(Alloc* alloc, Args&&... args) const;
+//
+//   // Destroys and deallocates node using the allocator.
+//   template <class Alloc>
+//   void delete_element(Alloc* alloc, value_type* node) const;
+// };
+//
+// It may also optionally define `value()` and `apply()`. For documentation on
+// these, see hash_policy_traits.h.
+
+#ifndef ABSL_CONTAINER_INTERNAL_NODE_SLOT_POLICY_H_
+#define ABSL_CONTAINER_INTERNAL_NODE_SLOT_POLICY_H_
+
+#include <cassert>
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class Reference, class Policy>
+struct node_slot_policy {
+  static_assert(std::is_lvalue_reference<Reference>::value, "");
+
+  using slot_type = typename std::remove_cv<
+      typename std::remove_reference<Reference>::type>::type*;
+
+  template <class Alloc, class... Args>
+  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
+    *slot = Policy::new_element(alloc, std::forward<Args>(args)...);
+  }
+
+  template <class Alloc>
+  static void destroy(Alloc* alloc, slot_type* slot) {
+    Policy::delete_element(alloc, *slot);
+  }
+
+  template <class Alloc>
+  static void transfer(Alloc*, slot_type* new_slot, slot_type* old_slot) {
+    *new_slot = *old_slot;
+  }
+
+  static size_t space_used(const slot_type* slot) {
+    if (slot == nullptr) return Policy::element_space_used(nullptr);
+    return Policy::element_space_used(*slot);
+  }
+
+  static Reference element(slot_type* slot) { return **slot; }
+
+  template <class T, class P = Policy>
+  static auto value(T* elem) -> decltype(P::value(elem)) {
+    return P::value(elem);
+  }
+
+  template <class... Ts, class P = Policy>
+  static auto apply(Ts&&... ts) -> decltype(P::apply(std::forward<Ts>(ts)...)) {
+    return P::apply(std::forward<Ts>(ts)...);
+  }
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_NODE_SLOT_POLICY_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_map.h b/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_map.h
new file mode 100644
index 0000000..c7df2ef
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_map.h
@@ -0,0 +1,198 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
+#define ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/container/internal/container_memory.h"
+#include "absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
+  // P is Policy. It's passed as a template argument to support maps that have
+  // incomplete types as values, as in unordered_map<K, IncompleteType>.
+  // MappedReference<> may be a non-reference type.
+  template <class P>
+  using MappedReference = decltype(P::value(
+      std::addressof(std::declval<typename raw_hash_map::reference>())));
+
+  // MappedConstReference<> may be a non-reference type.
+  template <class P>
+  using MappedConstReference = decltype(P::value(
+      std::addressof(std::declval<typename raw_hash_map::const_reference>())));
+
+  using KeyArgImpl =
+      KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+ public:
+  using key_type = typename Policy::key_type;
+  using mapped_type = typename Policy::mapped_type;
+  template <class K>
+  using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+  static_assert(!std::is_reference<key_type>::value, "");
+
+  // TODO(b/187807849): Evaluate whether to support reference mapped_type and
+  // remove this assertion if/when it is supported.
+  static_assert(!std::is_reference<mapped_type>::value, "");
+
+  using iterator = typename raw_hash_map::raw_hash_set::iterator;
+  using const_iterator = typename raw_hash_map::raw_hash_set::const_iterator;
+
+  raw_hash_map() {}
+  using raw_hash_map::raw_hash_set::raw_hash_set;
+
+  // The last two template parameters ensure that both arguments are rvalues
+  // (lvalue arguments are handled by the overloads below). This is necessary
+  // for supporting bitfield arguments.
+  //
+  //   union { int n : 1; };
+  //   flat_hash_map<int, int> m;
+  //   m.insert_or_assign(n, n);
+  template <class K = key_type, class V = mapped_type, K* = nullptr,
+            V* = nullptr>
+  std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, V&& v) {
+    return insert_or_assign_impl(std::forward<K>(k), std::forward<V>(v));
+  }
+
+  template <class K = key_type, class V = mapped_type, K* = nullptr>
+  std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const V& v) {
+    return insert_or_assign_impl(std::forward<K>(k), v);
+  }
+
+  template <class K = key_type, class V = mapped_type, V* = nullptr>
+  std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, V&& v) {
+    return insert_or_assign_impl(k, std::forward<V>(v));
+  }
+
+  template <class K = key_type, class V = mapped_type>
+  std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const V& v) {
+    return insert_or_assign_impl(k, v);
+  }
+
+  template <class K = key_type, class V = mapped_type, K* = nullptr,
+            V* = nullptr>
+  iterator insert_or_assign(const_iterator, key_arg<K>&& k, V&& v) {
+    return insert_or_assign(std::forward<K>(k), std::forward<V>(v)).first;
+  }
+
+  template <class K = key_type, class V = mapped_type, K* = nullptr>
+  iterator insert_or_assign(const_iterator, key_arg<K>&& k, const V& v) {
+    return insert_or_assign(std::forward<K>(k), v).first;
+  }
+
+  template <class K = key_type, class V = mapped_type, V* = nullptr>
+  iterator insert_or_assign(const_iterator, const key_arg<K>& k, V&& v) {
+    return insert_or_assign(k, std::forward<V>(v)).first;
+  }
+
+  template <class K = key_type, class V = mapped_type>
+  iterator insert_or_assign(const_iterator, const key_arg<K>& k, const V& v) {
+    return insert_or_assign(k, v).first;
+  }
+
+  // All `try_emplace()` overloads make the same guarantees regarding rvalue
+  // arguments as `std::unordered_map::try_emplace()`, namely that these
+  // functions will not move from rvalue arguments if insertions do not happen.
+  template <class K = key_type, class... Args,
+            typename std::enable_if<
+                !std::is_convertible<K, const_iterator>::value, int>::type = 0,
+            K* = nullptr>
+  std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args) {
+    return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+  }
+
+  template <class K = key_type, class... Args,
+            typename std::enable_if<
+                !std::is_convertible<K, const_iterator>::value, int>::type = 0>
+  std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args) {
+    return try_emplace_impl(k, std::forward<Args>(args)...);
+  }
+
+  template <class K = key_type, class... Args, K* = nullptr>
+  iterator try_emplace(const_iterator, key_arg<K>&& k, Args&&... args) {
+    return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
+  }
+
+  template <class K = key_type, class... Args>
+  iterator try_emplace(const_iterator, const key_arg<K>& k, Args&&... args) {
+    return try_emplace(k, std::forward<Args>(args)...).first;
+  }
+
+  template <class K = key_type, class P = Policy>
+  MappedReference<P> at(const key_arg<K>& key) {
+    auto it = this->find(key);
+    if (it == this->end()) {
+      base_internal::ThrowStdOutOfRange(
+          "absl::container_internal::raw_hash_map<>::at");
+    }
+    return Policy::value(&*it);
+  }
+
+  template <class K = key_type, class P = Policy>
+  MappedConstReference<P> at(const key_arg<K>& key) const {
+    auto it = this->find(key);
+    if (it == this->end()) {
+      base_internal::ThrowStdOutOfRange(
+          "absl::container_internal::raw_hash_map<>::at");
+    }
+    return Policy::value(&*it);
+  }
+
+  template <class K = key_type, class P = Policy, K* = nullptr>
+  MappedReference<P> operator[](key_arg<K>&& key) {
+    return Policy::value(&*try_emplace(std::forward<K>(key)).first);
+  }
+
+  template <class K = key_type, class P = Policy>
+  MappedReference<P> operator[](const key_arg<K>& key) {
+    return Policy::value(&*try_emplace(key).first);
+  }
+
+ private:
+  template <class K, class V>
+  std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v) {
+    auto res = this->find_or_prepare_insert(k);
+    if (res.second)
+      this->emplace_at(res.first, std::forward<K>(k), std::forward<V>(v));
+    else
+      Policy::value(&*this->iterator_at(res.first)) = std::forward<V>(v);
+    return {this->iterator_at(res.first), res.second};
+  }
+
+  template <class K = key_type, class... Args>
+  std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
+    auto res = this->find_or_prepare_insert(k);
+    if (res.second)
+      this->emplace_at(res.first, std::piecewise_construct,
+                       std::forward_as_tuple(std::forward<K>(k)),
+                       std::forward_as_tuple(std::forward<Args>(args)...));
+    return {this->iterator_at(res.first), res.second};
+  }
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_set.h b/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_set.h
new file mode 100644
index 0000000..ea912f8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_set.h
@@ -0,0 +1,2365 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// An open-addressing
+// hashtable with quadratic probing.
+//
+// This is a low level hashtable on top of which different interfaces can be
+// implemented, like flat_hash_set, node_hash_set, string_hash_set, etc.
+//
+// The table interface is similar to that of std::unordered_set. Notable
+// differences are that most member functions support heterogeneous keys when
+// BOTH the hash and eq functions are marked as transparent. They do so by
+// providing a typedef called `is_transparent`.
+//
+// When heterogeneous lookup is enabled, functions that take key_type act as if
+// they have an overload set like:
+//
+//   iterator find(const key_type& key);
+//   template <class K>
+//   iterator find(const K& key);
+//
+//   size_type erase(const key_type& key);
+//   template <class K>
+//   size_type erase(const K& key);
+//
+//   std::pair<iterator, iterator> equal_range(const key_type& key);
+//   template <class K>
+//   std::pair<iterator, iterator> equal_range(const K& key);
+//
+// When heterogeneous lookup is disabled, only the explicit `key_type` overloads
+// exist.
+//
+// find() also supports passing the hash explicitly:
+//
+//   iterator find(const key_type& key, size_t hash);
+//   template <class U>
+//   iterator find(const U& key, size_t hash);
+//
+// In addition the pointer to element and iterator stability guarantees are
+// weaker: all iterators and pointers are invalidated after a new element is
+// inserted.
+//
+// IMPLEMENTATION DETAILS
+//
+// # Table Layout
+//
+// A raw_hash_set's backing array consists of control bytes followed by slots
+// that may or may not contain objects.
+//
+// The layout of the backing array, for `capacity` slots, is thus, as a
+// pseudo-struct:
+//
+//   struct BackingArray {
+//     // Control bytes for the "real" slots.
+//     ctrl_t ctrl[capacity];
+//     // Always `ctrl_t::kSentinel`. This is used by iterators to find when to
+//     // stop and serves no other purpose.
+//     ctrl_t sentinel;
+//     // A copy of the first `kWidth - 1` elements of `ctrl`. This is used so
+//     // that if a probe sequence picks a value near the end of `ctrl`,
+//     // `Group` will have valid control bytes to look at.
+//     ctrl_t clones[kWidth - 1];
+//     // The actual slot data.
+//     slot_type slots[capacity];
+//   };
+//
+// The length of this array is computed by `AllocSize()` below.
+//
+// Control bytes (`ctrl_t`) are bytes (collected into groups of a
+// platform-specific size) that define the state of the corresponding slot in
+// the slot array. Group manipulation is tightly optimized to be as efficient
+// as possible: SSE and friends on x86, clever bit operations on other arches.
+//
+//      Group 1         Group 2        Group 3
+// +---------------+---------------+---------------+
+// | | | | | | | | | | | | | | | | | | | | | | | | |
+// +---------------+---------------+---------------+
+//
+// Each control byte is either a special value for empty slots, deleted slots
+// (sometimes called *tombstones*), and a special end-of-table marker used by
+// iterators, or, if occupied, seven bits (H2) from the hash of the value in the
+// corresponding slot.
+//
+// Storing control bytes in a separate array also has beneficial cache effects,
+// since more logical slots will fit into a cache line.
+//
+// # Hashing
+//
+// We compute two separate hashes, `H1` and `H2`, from the hash of an object.
+// `H1(hash(x))` is an index into `slots`, and essentially the starting point
+// for the probe sequence. `H2(hash(x))` is a 7-bit value used to filter out
+// objects that cannot possibly be the one we are looking for.
+//
+// # Table operations.
+//
+// The key operations are `insert`, `find`, and `erase`.
+//
+// Since `insert` and `erase` are implemented in terms of `find`, we describe
+// `find` first. To `find` a value `x`, we compute `hash(x)`. From
+// `H1(hash(x))` and the capacity, we construct a `probe_seq` that visits every
+// group of slots in some interesting order.
+//
+// We now walk through these indices. At each index, we select the entire group
+// starting with that index and extract potential candidates: occupied slots
+// with a control byte equal to `H2(hash(x))`. If we find an empty slot in the
+// group, we stop and return an error. Each candidate slot `y` is compared with
+// `x`; if `x == y`, we are done and return `&y`; otherwise we contine to the
+// next probe index. Tombstones effectively behave like full slots that never
+// match the value we're looking for.
+//
+// The `H2` bits ensure when we compare a slot to an object with `==`, we are
+// likely to have actually found the object.  That is, the chance is low that
+// `==` is called and returns `false`.  Thus, when we search for an object, we
+// are unlikely to call `==` many times.  This likelyhood can be analyzed as
+// follows (assuming that H2 is a random enough hash function).
+//
+// Let's assume that there are `k` "wrong" objects that must be examined in a
+// probe sequence.  For example, when doing a `find` on an object that is in the
+// table, `k` is the number of objects between the start of the probe sequence
+// and the final found object (not including the final found object).  The
+// expected number of objects with an H2 match is then `k/128`.  Measurements
+// and analysis indicate that even at high load factors, `k` is less than 32,
+// meaning that the number of "false positive" comparisons we must perform is
+// less than 1/8 per `find`.
+
+// `insert` is implemented in terms of `unchecked_insert`, which inserts a
+// value presumed to not be in the table (violating this requirement will cause
+// the table to behave erratically). Given `x` and its hash `hash(x)`, to insert
+// it, we construct a `probe_seq` once again, and use it to find the first
+// group with an unoccupied (empty *or* deleted) slot. We place `x` into the
+// first such slot in the group and mark it as full with `x`'s H2.
+//
+// To `insert`, we compose `unchecked_insert` with `find`. We compute `h(x)` and
+// perform a `find` to see if it's already present; if it is, we're done. If
+// it's not, we may decide the table is getting overcrowded (i.e. the load
+// factor is greater than 7/8 for big tables; `is_small()` tables use a max load
+// factor of 1); in this case, we allocate a bigger array, `unchecked_insert`
+// each element of the table into the new array (we know that no insertion here
+// will insert an already-present value), and discard the old backing array. At
+// this point, we may `unchecked_insert` the value `x`.
+//
+// Below, `unchecked_insert` is partly implemented by `prepare_insert`, which
+// presents a viable, initialized slot pointee to the caller.
+//
+// `erase` is implemented in terms of `erase_at`, which takes an index to a
+// slot. Given an offset, we simply create a tombstone and destroy its contents.
+// If we can prove that the slot would not appear in a probe sequence, we can
+// make the slot as empty, instead. We can prove this by observing that if a
+// group has any empty slots, it has never been full (assuming we never create
+// an empty slot in a group with no empties, which this heuristic guarantees we
+// never do) and find would stop at this group anyways (since it does not probe
+// beyond groups with empties).
+//
+// `erase` is `erase_at` composed with `find`: if we
+// have a value `x`, we can perform a `find`, and then `erase_at` the resulting
+// slot.
+//
+// To iterate, we simply traverse the array, skipping empty and deleted slots
+// and stopping when we hit a `kSentinel`.
+
+#ifndef ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
+#define ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/endian.h"
+#include "absl/base/internal/prefetch.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+#include "absl/container/internal/common.h"
+#include "absl/container/internal/compressed_tuple.h"
+#include "absl/container/internal/container_memory.h"
+#include "absl/container/internal/hash_policy_traits.h"
+#include "absl/container/internal/hashtable_debug_hooks.h"
+#include "absl/container/internal/hashtablez_sampler.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/numeric/bits.h"
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_INTERNAL_HAVE_SSE2
+#include <emmintrin.h>
+#endif
+
+#ifdef ABSL_INTERNAL_HAVE_SSSE3
+#include <tmmintrin.h>
+#endif
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+#ifdef ABSL_INTERNAL_HAVE_ARM_NEON
+#include <arm_neon.h>
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <typename AllocType>
+void SwapAlloc(AllocType& lhs, AllocType& rhs,
+               std::true_type /* propagate_on_container_swap */) {
+  using std::swap;
+  swap(lhs, rhs);
+}
+template <typename AllocType>
+void SwapAlloc(AllocType& /*lhs*/, AllocType& /*rhs*/,
+               std::false_type /* propagate_on_container_swap */) {}
+
+// The state for a probe sequence.
+//
+// Currently, the sequence is a triangular progression of the form
+//
+//   p(i) := Width * (i^2 + i)/2 + hash (mod mask + 1)
+//
+// The use of `Width` ensures that each probe step does not overlap groups;
+// the sequence effectively outputs the addresses of *groups* (although not
+// necessarily aligned to any boundary). The `Group` machinery allows us
+// to check an entire group with minimal branching.
+//
+// Wrapping around at `mask + 1` is important, but not for the obvious reason.
+// As described above, the first few entries of the control byte array
+// are mirrored at the end of the array, which `Group` will find and use
+// for selecting candidates. However, when those candidates' slots are
+// actually inspected, there are no corresponding slots for the cloned bytes,
+// so we need to make sure we've treated those offsets as "wrapping around".
+//
+// It turns out that this probe sequence visits every group exactly once if the
+// number of groups is a power of two, since (i^2+i)/2 is a bijection in
+// Z/(2^m). See https://en.wikipedia.org/wiki/Quadratic_probing
+template <size_t Width>
+class probe_seq {
+ public:
+  // Creates a new probe sequence using `hash` as the initial value of the
+  // sequence and `mask` (usually the capacity of the table) as the mask to
+  // apply to each value in the progression.
+  probe_seq(size_t hash, size_t mask) {
+    assert(((mask + 1) & mask) == 0 && "not a mask");
+    mask_ = mask;
+    offset_ = hash & mask_;
+  }
+
+  // The offset within the table, i.e., the value `p(i)` above.
+  size_t offset() const { return offset_; }
+  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
+
+  void next() {
+    index_ += Width;
+    offset_ += index_;
+    offset_ &= mask_;
+  }
+  // 0-based probe index, a multiple of `Width`.
+  size_t index() const { return index_; }
+
+ private:
+  size_t mask_;
+  size_t offset_;
+  size_t index_ = 0;
+};
+
+template <class ContainerKey, class Hash, class Eq>
+struct RequireUsableKey {
+  template <class PassedKey, class... Args>
+  std::pair<
+      decltype(std::declval<const Hash&>()(std::declval<const PassedKey&>())),
+      decltype(std::declval<const Eq&>()(std::declval<const ContainerKey&>(),
+                                         std::declval<const PassedKey&>()))>*
+  operator()(const PassedKey&, const Args&...) const;
+};
+
+template <class E, class Policy, class Hash, class Eq, class... Ts>
+struct IsDecomposable : std::false_type {};
+
+template <class Policy, class Hash, class Eq, class... Ts>
+struct IsDecomposable<
+    absl::void_t<decltype(Policy::apply(
+        RequireUsableKey<typename Policy::key_type, Hash, Eq>(),
+        std::declval<Ts>()...))>,
+    Policy, Hash, Eq, Ts...> : std::true_type {};
+
+// TODO(alkis): Switch to std::is_nothrow_swappable when gcc/clang supports it.
+template <class T>
+constexpr bool IsNoThrowSwappable(std::true_type = {} /* is_swappable */) {
+  using std::swap;
+  return noexcept(swap(std::declval<T&>(), std::declval<T&>()));
+}
+template <class T>
+constexpr bool IsNoThrowSwappable(std::false_type /* is_swappable */) {
+  return false;
+}
+
+template <typename T>
+uint32_t TrailingZeros(T x) {
+  ABSL_ASSUME(x != 0);
+  return static_cast<uint32_t>(countr_zero(x));
+}
+
+// An abstract bitmask, such as that emitted by a SIMD instruction.
+//
+// Specifically, this type implements a simple bitset whose representation is
+// controlled by `SignificantBits` and `Shift`. `SignificantBits` is the number
+// of abstract bits in the bitset, while `Shift` is the log-base-two of the
+// width of an abstract bit in the representation.
+// This mask provides operations for any number of real bits set in an abstract
+// bit. To add iteration on top of that, implementation must guarantee no more
+// than one real bit is set in an abstract bit.
+template <class T, int SignificantBits, int Shift = 0>
+class NonIterableBitMask {
+ public:
+  explicit NonIterableBitMask(T mask) : mask_(mask) {}
+
+  explicit operator bool() const { return this->mask_ != 0; }
+
+  // Returns the index of the lowest *abstract* bit set in `self`.
+  uint32_t LowestBitSet() const {
+    return container_internal::TrailingZeros(mask_) >> Shift;
+  }
+
+  // Returns the index of the highest *abstract* bit set in `self`.
+  uint32_t HighestBitSet() const {
+    return static_cast<uint32_t>((bit_width(mask_) - 1) >> Shift);
+  }
+
+  // Return the number of trailing zero *abstract* bits.
+  uint32_t TrailingZeros() const {
+    return container_internal::TrailingZeros(mask_) >> Shift;
+  }
+
+  // Return the number of leading zero *abstract* bits.
+  uint32_t LeadingZeros() const {
+    constexpr int total_significant_bits = SignificantBits << Shift;
+    constexpr int extra_bits = sizeof(T) * 8 - total_significant_bits;
+    return static_cast<uint32_t>(countl_zero(mask_ << extra_bits)) >> Shift;
+  }
+
+  T mask_;
+};
+
+// Mask that can be iterable
+//
+// For example, when `SignificantBits` is 16 and `Shift` is zero, this is just
+// an ordinary 16-bit bitset occupying the low 16 bits of `mask`. When
+// `SignificantBits` is 8 and `Shift` is 3, abstract bits are represented as
+// the bytes `0x00` and `0x80`, and it occupies all 64 bits of the bitmask.
+//
+// For example:
+//   for (int i : BitMask<uint32_t, 16>(0b101)) -> yields 0, 2
+//   for (int i : BitMask<uint64_t, 8, 3>(0x0000000080800000)) -> yields 2, 3
+template <class T, int SignificantBits, int Shift = 0>
+class BitMask : public NonIterableBitMask<T, SignificantBits, Shift> {
+  using Base = NonIterableBitMask<T, SignificantBits, Shift>;
+  static_assert(std::is_unsigned<T>::value, "");
+  static_assert(Shift == 0 || Shift == 3, "");
+
+ public:
+  explicit BitMask(T mask) : Base(mask) {}
+  // BitMask is an iterator over the indices of its abstract bits.
+  using value_type = int;
+  using iterator = BitMask;
+  using const_iterator = BitMask;
+
+  BitMask& operator++() {
+    this->mask_ &= (this->mask_ - 1);
+    return *this;
+  }
+
+  uint32_t operator*() const { return Base::LowestBitSet(); }
+
+  BitMask begin() const { return *this; }
+  BitMask end() const { return BitMask(0); }
+
+ private:
+  friend bool operator==(const BitMask& a, const BitMask& b) {
+    return a.mask_ == b.mask_;
+  }
+  friend bool operator!=(const BitMask& a, const BitMask& b) {
+    return a.mask_ != b.mask_;
+  }
+};
+
+using h2_t = uint8_t;
+
+// The values here are selected for maximum performance. See the static asserts
+// below for details.
+
+// A `ctrl_t` is a single control byte, which can have one of four
+// states: empty, deleted, full (which has an associated seven-bit h2_t value)
+// and the sentinel. They have the following bit patterns:
+//
+//      empty: 1 0 0 0 0 0 0 0
+//    deleted: 1 1 1 1 1 1 1 0
+//       full: 0 h h h h h h h  // h represents the hash bits.
+//   sentinel: 1 1 1 1 1 1 1 1
+//
+// These values are specifically tuned for SSE-flavored SIMD.
+// The static_asserts below detail the source of these choices.
+//
+// We use an enum class so that when strict aliasing is enabled, the compiler
+// knows ctrl_t doesn't alias other types.
+enum class ctrl_t : int8_t {
+  kEmpty = -128,   // 0b10000000
+  kDeleted = -2,   // 0b11111110
+  kSentinel = -1,  // 0b11111111
+};
+static_assert(
+    (static_cast<int8_t>(ctrl_t::kEmpty) &
+     static_cast<int8_t>(ctrl_t::kDeleted) &
+     static_cast<int8_t>(ctrl_t::kSentinel) & 0x80) != 0,
+    "Special markers need to have the MSB to make checking for them efficient");
+static_assert(
+    ctrl_t::kEmpty < ctrl_t::kSentinel && ctrl_t::kDeleted < ctrl_t::kSentinel,
+    "ctrl_t::kEmpty and ctrl_t::kDeleted must be smaller than "
+    "ctrl_t::kSentinel to make the SIMD test of IsEmptyOrDeleted() efficient");
+static_assert(
+    ctrl_t::kSentinel == static_cast<ctrl_t>(-1),
+    "ctrl_t::kSentinel must be -1 to elide loading it from memory into SIMD "
+    "registers (pcmpeqd xmm, xmm)");
+static_assert(ctrl_t::kEmpty == static_cast<ctrl_t>(-128),
+              "ctrl_t::kEmpty must be -128 to make the SIMD check for its "
+              "existence efficient (psignb xmm, xmm)");
+static_assert(
+    (~static_cast<int8_t>(ctrl_t::kEmpty) &
+     ~static_cast<int8_t>(ctrl_t::kDeleted) &
+     static_cast<int8_t>(ctrl_t::kSentinel) & 0x7F) != 0,
+    "ctrl_t::kEmpty and ctrl_t::kDeleted must share an unset bit that is not "
+    "shared by ctrl_t::kSentinel to make the scalar test for "
+    "MaskEmptyOrDeleted() efficient");
+static_assert(ctrl_t::kDeleted == static_cast<ctrl_t>(-2),
+              "ctrl_t::kDeleted must be -2 to make the implementation of "
+              "ConvertSpecialToEmptyAndFullToDeleted efficient");
+
+ABSL_DLL extern const ctrl_t kEmptyGroup[16];
+
+// Returns a pointer to a control byte group that can be used by empty tables.
+inline ctrl_t* EmptyGroup() {
+  // Const must be cast away here; no uses of this function will actually write
+  // to it, because it is only used for empty tables.
+  return const_cast<ctrl_t*>(kEmptyGroup);
+}
+
+// Mixes a randomly generated per-process seed with `hash` and `ctrl` to
+// randomize insertion order within groups.
+bool ShouldInsertBackwards(size_t hash, const ctrl_t* ctrl);
+
+// Returns a per-table, hash salt, which changes on resize. This gets mixed into
+// H1 to randomize iteration order per-table.
+//
+// The seed consists of the ctrl_ pointer, which adds enough entropy to ensure
+// non-determinism of iteration order in most cases.
+inline size_t PerTableSalt(const ctrl_t* ctrl) {
+  // The low bits of the pointer have little or no entropy because of
+  // alignment. We shift the pointer to try to use higher entropy bits. A
+  // good number seems to be 12 bits, because that aligns with page size.
+  return reinterpret_cast<uintptr_t>(ctrl) >> 12;
+}
+// Extracts the H1 portion of a hash: 57 bits mixed with a per-table salt.
+inline size_t H1(size_t hash, const ctrl_t* ctrl) {
+  return (hash >> 7) ^ PerTableSalt(ctrl);
+}
+
+// Extracts the H2 portion of a hash: the 7 bits not used for H1.
+//
+// These are used as an occupied control byte.
+inline h2_t H2(size_t hash) { return hash & 0x7F; }
+
+// Helpers for checking the state of a control byte.
+inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
+inline bool IsFull(ctrl_t c) { return c >= static_cast<ctrl_t>(0); }
+inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
+inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
+
+#ifdef ABSL_INTERNAL_HAVE_SSE2
+// Quick reference guide for intrinsics used below:
+//
+// * __m128i: An XMM (128-bit) word.
+//
+// * _mm_setzero_si128: Returns a zero vector.
+// * _mm_set1_epi8:     Returns a vector with the same i8 in each lane.
+//
+// * _mm_subs_epi8:    Saturating-subtracts two i8 vectors.
+// * _mm_and_si128:    Ands two i128s together.
+// * _mm_or_si128:     Ors two i128s together.
+// * _mm_andnot_si128: And-nots two i128s together.
+//
+// * _mm_cmpeq_epi8: Component-wise compares two i8 vectors for equality,
+//                   filling each lane with 0x00 or 0xff.
+// * _mm_cmpgt_epi8: Same as above, but using > rather than ==.
+//
+// * _mm_loadu_si128:  Performs an unaligned load of an i128.
+// * _mm_storeu_si128: Performs an unaligned store of an i128.
+//
+// * _mm_sign_epi8:     Retains, negates, or zeroes each i8 lane of the first
+//                      argument if the corresponding lane of the second
+//                      argument is positive, negative, or zero, respectively.
+// * _mm_movemask_epi8: Selects the sign bit out of each i8 lane and produces a
+//                      bitmask consisting of those bits.
+// * _mm_shuffle_epi8:  Selects i8s from the first argument, using the low
+//                      four bits of each i8 lane in the second argument as
+//                      indices.
+
+// https://github.com/abseil/abseil-cpp/issues/209
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87853
+// _mm_cmpgt_epi8 is broken under GCC with -funsigned-char
+// Work around this by using the portable implementation of Group
+// when using -funsigned-char under GCC.
+inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
+#if defined(__GNUC__) && !defined(__clang__)
+  if (std::is_unsigned<char>::value) {
+    const __m128i mask = _mm_set1_epi8(0x80);
+    const __m128i diff = _mm_subs_epi8(b, a);
+    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
+  }
+#endif
+  return _mm_cmpgt_epi8(a, b);
+}
+
+struct GroupSse2Impl {
+  static constexpr size_t kWidth = 16;  // the number of slots per group
+
+  explicit GroupSse2Impl(const ctrl_t* pos) {
+    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
+  }
+
+  // Returns a bitmask representing the positions of slots that match hash.
+  BitMask<uint32_t, kWidth> Match(h2_t hash) const {
+    auto match = _mm_set1_epi8(hash);
+    return BitMask<uint32_t, kWidth>(
+        static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
+  }
+
+  // Returns a bitmask representing the positions of empty slots.
+  NonIterableBitMask<uint32_t, kWidth> MaskEmpty() const {
+#ifdef ABSL_INTERNAL_HAVE_SSSE3
+    // This only works because ctrl_t::kEmpty is -128.
+    return NonIterableBitMask<uint32_t, kWidth>(
+        static_cast<uint32_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
+#else
+    auto match = _mm_set1_epi8(static_cast<h2_t>(ctrl_t::kEmpty));
+    return NonIterableBitMask<uint32_t, kWidth>(
+        static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
+#endif
+  }
+
+  // Returns a bitmask representing the positions of empty or deleted slots.
+  NonIterableBitMask<uint32_t, kWidth> MaskEmptyOrDeleted() const {
+    auto special = _mm_set1_epi8(static_cast<uint8_t>(ctrl_t::kSentinel));
+    return NonIterableBitMask<uint32_t, kWidth>(static_cast<uint32_t>(
+        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
+  }
+
+  // Returns the number of trailing empty or deleted elements in the group.
+  uint32_t CountLeadingEmptyOrDeleted() const {
+    auto special = _mm_set1_epi8(static_cast<uint8_t>(ctrl_t::kSentinel));
+    return TrailingZeros(static_cast<uint32_t>(
+        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
+  }
+
+  void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
+    auto msbs = _mm_set1_epi8(static_cast<char>(-128));
+    auto x126 = _mm_set1_epi8(126);
+#ifdef ABSL_INTERNAL_HAVE_SSSE3
+    auto res = _mm_or_si128(_mm_shuffle_epi8(x126, ctrl), msbs);
+#else
+    auto zero = _mm_setzero_si128();
+    auto special_mask = _mm_cmpgt_epi8_fixed(zero, ctrl);
+    auto res = _mm_or_si128(msbs, _mm_andnot_si128(special_mask, x126));
+#endif
+    _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
+  }
+
+  __m128i ctrl;
+};
+#endif  // ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+
+#if defined(ABSL_INTERNAL_HAVE_ARM_NEON) && defined(ABSL_IS_LITTLE_ENDIAN)
+struct GroupAArch64Impl {
+  static constexpr size_t kWidth = 8;
+
+  explicit GroupAArch64Impl(const ctrl_t* pos) {
+    ctrl = vld1_u8(reinterpret_cast<const uint8_t*>(pos));
+  }
+
+  BitMask<uint64_t, kWidth, 3> Match(h2_t hash) const {
+    uint8x8_t dup = vdup_n_u8(hash);
+    auto mask = vceq_u8(ctrl, dup);
+    constexpr uint64_t msbs = 0x8080808080808080ULL;
+    return BitMask<uint64_t, kWidth, 3>(
+        vget_lane_u64(vreinterpret_u64_u8(mask), 0) & msbs);
+  }
+
+  NonIterableBitMask<uint64_t, kWidth, 3> MaskEmpty() const {
+    uint64_t mask =
+        vget_lane_u64(vreinterpret_u64_u8(
+                          vceq_s8(vdup_n_s8(static_cast<h2_t>(ctrl_t::kEmpty)),
+                                  vreinterpret_s8_u8(ctrl))),
+                      0);
+    return NonIterableBitMask<uint64_t, kWidth, 3>(mask);
+  }
+
+  NonIterableBitMask<uint64_t, kWidth, 3> MaskEmptyOrDeleted() const {
+    uint64_t mask =
+        vget_lane_u64(vreinterpret_u64_u8(vcgt_s8(
+                          vdup_n_s8(static_cast<int8_t>(ctrl_t::kSentinel)),
+                          vreinterpret_s8_u8(ctrl))),
+                      0);
+    return NonIterableBitMask<uint64_t, kWidth, 3>(mask);
+  }
+
+  uint32_t CountLeadingEmptyOrDeleted() const {
+    uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(ctrl), 0);
+    // ctrl | ~(ctrl >> 7) will have the lowest bit set to zero for kEmpty and
+    // kDeleted. We lower all other bits and count number of trailing zeros.
+    // Clang and GCC optimize countr_zero to rbit+clz without any check for 0,
+    // so we should be fine.
+    constexpr uint64_t bits = 0x0101010101010101ULL;
+    return countr_zero((mask | ~(mask >> 7)) & bits) >> 3;
+  }
+
+  void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
+    uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(ctrl), 0);
+    constexpr uint64_t msbs = 0x8080808080808080ULL;
+    constexpr uint64_t lsbs = 0x0101010101010101ULL;
+    auto x = mask & msbs;
+    auto res = (~x + (x >> 7)) & ~lsbs;
+    little_endian::Store64(dst, res);
+  }
+
+  uint8x8_t ctrl;
+};
+#endif  // ABSL_INTERNAL_HAVE_ARM_NEON && ABSL_IS_LITTLE_ENDIAN
+
+struct GroupPortableImpl {
+  static constexpr size_t kWidth = 8;
+
+  explicit GroupPortableImpl(const ctrl_t* pos)
+      : ctrl(little_endian::Load64(pos)) {}
+
+  BitMask<uint64_t, kWidth, 3> Match(h2_t hash) const {
+    // For the technique, see:
+    // http://graphics.stanford.edu/~seander/bithacks.html##ValueInWord
+    // (Determine if a word has a byte equal to n).
+    //
+    // Caveat: there are false positives but:
+    // - they only occur if there is a real match
+    // - they never occur on ctrl_t::kEmpty, ctrl_t::kDeleted, ctrl_t::kSentinel
+    // - they will be handled gracefully by subsequent checks in code
+    //
+    // Example:
+    //   v = 0x1716151413121110
+    //   hash = 0x12
+    //   retval = (v - lsbs) & ~v & msbs = 0x0000000080800000
+    constexpr uint64_t msbs = 0x8080808080808080ULL;
+    constexpr uint64_t lsbs = 0x0101010101010101ULL;
+    auto x = ctrl ^ (lsbs * hash);
+    return BitMask<uint64_t, kWidth, 3>((x - lsbs) & ~x & msbs);
+  }
+
+  NonIterableBitMask<uint64_t, kWidth, 3> MaskEmpty() const {
+    constexpr uint64_t msbs = 0x8080808080808080ULL;
+    return NonIterableBitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 6)) &
+                                                   msbs);
+  }
+
+  NonIterableBitMask<uint64_t, kWidth, 3> MaskEmptyOrDeleted() const {
+    constexpr uint64_t msbs = 0x8080808080808080ULL;
+    return NonIterableBitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 7)) &
+                                                   msbs);
+  }
+
+  uint32_t CountLeadingEmptyOrDeleted() const {
+    // ctrl | ~(ctrl >> 7) will have the lowest bit set to zero for kEmpty and
+    // kDeleted. We lower all other bits and count number of trailing zeros.
+    constexpr uint64_t bits = 0x0101010101010101ULL;
+    return countr_zero((ctrl | ~(ctrl >> 7)) & bits) >> 3;
+  }
+
+  void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
+    constexpr uint64_t msbs = 0x8080808080808080ULL;
+    constexpr uint64_t lsbs = 0x0101010101010101ULL;
+    auto x = ctrl & msbs;
+    auto res = (~x + (x >> 7)) & ~lsbs;
+    little_endian::Store64(dst, res);
+  }
+
+  uint64_t ctrl;
+};
+
+#ifdef ABSL_INTERNAL_HAVE_SSE2
+using Group = GroupSse2Impl;
+#elif defined(ABSL_INTERNAL_HAVE_ARM_NEON) && defined(ABSL_IS_LITTLE_ENDIAN)
+using Group = GroupAArch64Impl;
+#else
+using Group = GroupPortableImpl;
+#endif
+
+// Returns he number of "cloned control bytes".
+//
+// This is the number of control bytes that are present both at the beginning
+// of the control byte array and at the end, such that we can create a
+// `Group::kWidth`-width probe window starting from any control byte.
+constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
+
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_set;
+
+// Returns whether `n` is a valid capacity (i.e., number of slots).
+//
+// A valid capacity is a non-zero integer `2^m - 1`.
+inline bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
+
+// Applies the following mapping to every byte in the control array:
+//   * kDeleted -> kEmpty
+//   * kEmpty -> kEmpty
+//   * _ -> kDeleted
+// PRECONDITION:
+//   IsValidCapacity(capacity)
+//   ctrl[capacity] == ctrl_t::kSentinel
+//   ctrl[i] != ctrl_t::kSentinel for all i < capacity
+void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity);
+
+// Converts `n` into the next valid capacity, per `IsValidCapacity`.
+inline size_t NormalizeCapacity(size_t n) {
+  return n ? ~size_t{} >> countl_zero(n) : 1;
+}
+
+// General notes on capacity/growth methods below:
+// - We use 7/8th as maximum load factor. For 16-wide groups, that gives an
+//   average of two empty slots per group.
+// - For (capacity+1) >= Group::kWidth, growth is 7/8*capacity.
+// - For (capacity+1) < Group::kWidth, growth == capacity. In this case, we
+//   never need to probe (the whole table fits in one group) so we don't need a
+//   load factor less than 1.
+
+// Given `capacity`, applies the load factor; i.e., it returns the maximum
+// number of values we should put into the table before a resizing rehash.
+inline size_t CapacityToGrowth(size_t capacity) {
+  assert(IsValidCapacity(capacity));
+  // `capacity*7/8`
+  if (Group::kWidth == 8 && capacity == 7) {
+    // x-x/8 does not work when x==7.
+    return 6;
+  }
+  return capacity - capacity / 8;
+}
+
+// Given `growth`, "unapplies" the load factor to find how large the capacity
+// should be to stay within the load factor.
+//
+// This might not be a valid capacity and `NormalizeCapacity()` should be
+// called on this.
+inline size_t GrowthToLowerboundCapacity(size_t growth) {
+  // `growth*8/7`
+  if (Group::kWidth == 8 && growth == 7) {
+    // x+(x-1)/7 does not work when x==7.
+    return 8;
+  }
+  return growth + static_cast<size_t>((static_cast<int64_t>(growth) - 1) / 7);
+}
+
+template <class InputIter>
+size_t SelectBucketCountForIterRange(InputIter first, InputIter last,
+                                     size_t bucket_count) {
+  if (bucket_count != 0) {
+    return bucket_count;
+  }
+  using InputIterCategory =
+      typename std::iterator_traits<InputIter>::iterator_category;
+  if (std::is_base_of<std::random_access_iterator_tag,
+                      InputIterCategory>::value) {
+    return GrowthToLowerboundCapacity(
+        static_cast<size_t>(std::distance(first, last)));
+  }
+  return 0;
+}
+
+#define ABSL_INTERNAL_ASSERT_IS_FULL(ctrl, msg) \
+  ABSL_HARDENING_ASSERT((ctrl != nullptr && IsFull(*ctrl)) && msg)
+
+inline void AssertIsValid(ctrl_t* ctrl) {
+  ABSL_HARDENING_ASSERT(
+      (ctrl == nullptr || IsFull(*ctrl)) &&
+      "Invalid operation on iterator. The element might have "
+      "been erased, the table might have rehashed, or this may "
+      "be an end() iterator.");
+}
+
+struct FindInfo {
+  size_t offset;
+  size_t probe_length;
+};
+
+// Whether a table is "small". A small table fits entirely into a probing
+// group, i.e., has a capacity < `Group::kWidth`.
+//
+// In small mode we are able to use the whole capacity. The extra control
+// bytes give us at least one "empty" control byte to stop the iteration.
+// This is important to make 1 a valid capacity.
+//
+// In small mode only the first `capacity` control bytes after the sentinel
+// are valid. The rest contain dummy ctrl_t::kEmpty values that do not
+// represent a real slot. This is important to take into account on
+// `find_first_non_full()`, where we never try
+// `ShouldInsertBackwards()` for small tables.
+inline bool is_small(size_t capacity) { return capacity < Group::kWidth - 1; }
+
+// Begins a probing operation on `ctrl`, using `hash`.
+inline probe_seq<Group::kWidth> probe(const ctrl_t* ctrl, size_t hash,
+                                      size_t capacity) {
+  return probe_seq<Group::kWidth>(H1(hash, ctrl), capacity);
+}
+
+// Probes an array of control bits using a probe sequence derived from `hash`,
+// and returns the offset corresponding to the first deleted or empty slot.
+//
+// Behavior when the entire table is full is undefined.
+//
+// NOTE: this function must work with tables having both empty and deleted
+// slots in the same group. Such tables appear during `erase()`.
+template <typename = void>
+inline FindInfo find_first_non_full(const ctrl_t* ctrl, size_t hash,
+                                    size_t capacity) {
+  auto seq = probe(ctrl, hash, capacity);
+  while (true) {
+    Group g{ctrl + seq.offset()};
+    auto mask = g.MaskEmptyOrDeleted();
+    if (mask) {
+#if !defined(NDEBUG)
+      // We want to add entropy even when ASLR is not enabled.
+      // In debug build we will randomly insert in either the front or back of
+      // the group.
+      // TODO(kfm,sbenza): revisit after we do unconditional mixing
+      if (!is_small(capacity) && ShouldInsertBackwards(hash, ctrl)) {
+        return {seq.offset(mask.HighestBitSet()), seq.index()};
+      }
+#endif
+      return {seq.offset(mask.LowestBitSet()), seq.index()};
+    }
+    seq.next();
+    assert(seq.index() <= capacity && "full table!");
+  }
+}
+
+// Extern template for inline function keep possibility of inlining.
+// When compiler decided to not inline, no symbols will be added to the
+// corresponding translation unit.
+extern template FindInfo find_first_non_full(const ctrl_t*, size_t, size_t);
+
+// Sets `ctrl` to `{kEmpty, kSentinel, ..., kEmpty}`, marking the entire
+// array as marked as empty.
+inline void ResetCtrl(size_t capacity, ctrl_t* ctrl, const void* slot,
+                      size_t slot_size) {
+  std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
+              capacity + 1 + NumClonedBytes());
+  ctrl[capacity] = ctrl_t::kSentinel;
+  SanitizerPoisonMemoryRegion(slot, slot_size * capacity);
+}
+
+// Sets `ctrl[i]` to `h`.
+//
+// Unlike setting it directly, this function will perform bounds checks and
+// mirror the value to the cloned tail if necessary.
+inline void SetCtrl(size_t i, ctrl_t h, size_t capacity, ctrl_t* ctrl,
+                    const void* slot, size_t slot_size) {
+  assert(i < capacity);
+
+  auto* slot_i = static_cast<const char*>(slot) + i * slot_size;
+  if (IsFull(h)) {
+    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
+  } else {
+    SanitizerPoisonMemoryRegion(slot_i, slot_size);
+  }
+
+  ctrl[i] = h;
+  ctrl[((i - NumClonedBytes()) & capacity) + (NumClonedBytes() & capacity)] = h;
+}
+
+// Overload for setting to an occupied `h2_t` rather than a special `ctrl_t`.
+inline void SetCtrl(size_t i, h2_t h, size_t capacity, ctrl_t* ctrl,
+                    const void* slot, size_t slot_size) {
+  SetCtrl(i, static_cast<ctrl_t>(h), capacity, ctrl, slot, slot_size);
+}
+
+// Given the capacity of a table, computes the offset (from the start of the
+// backing allocation) at which the slots begin.
+inline size_t SlotOffset(size_t capacity, size_t slot_align) {
+  assert(IsValidCapacity(capacity));
+  const size_t num_control_bytes = capacity + 1 + NumClonedBytes();
+  return (num_control_bytes + slot_align - 1) & (~slot_align + 1);
+}
+
+// Given the capacity of a table, computes the total size of the backing
+// array.
+inline size_t AllocSize(size_t capacity, size_t slot_size, size_t slot_align) {
+  return SlotOffset(capacity, slot_align) + capacity * slot_size;
+}
+
+// A SwissTable.
+//
+// Policy: a policy defines how to perform different operations on
+// the slots of the hashtable (see hash_policy_traits.h for the full interface
+// of policy).
+//
+// Hash: a (possibly polymorphic) functor that hashes keys of the hashtable. The
+// functor should accept a key and return size_t as hash. For best performance
+// it is important that the hash function provides high entropy across all bits
+// of the hash.
+//
+// Eq: a (possibly polymorphic) functor that compares two keys for equality. It
+// should accept two (of possibly different type) keys and return a bool: true
+// if they are equal, false if they are not. If two keys compare equal, then
+// their hash values as defined by Hash MUST be equal.
+//
+// Allocator: an Allocator
+// [https://en.cppreference.com/w/cpp/named_req/Allocator] with which
+// the storage of the hashtable will be allocated and the elements will be
+// constructed and destroyed.
+template <class Policy, class Hash, class Eq, class Alloc>
+class raw_hash_set {
+  using PolicyTraits = hash_policy_traits<Policy>;
+  using KeyArgImpl =
+      KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+ public:
+  using init_type = typename PolicyTraits::init_type;
+  using key_type = typename PolicyTraits::key_type;
+  // TODO(sbenza): Hide slot_type as it is an implementation detail. Needs user
+  // code fixes!
+  using slot_type = typename PolicyTraits::slot_type;
+  using allocator_type = Alloc;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using hasher = Hash;
+  using key_equal = Eq;
+  using policy_type = Policy;
+  using value_type = typename PolicyTraits::value_type;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = typename absl::allocator_traits<
+      allocator_type>::template rebind_traits<value_type>::pointer;
+  using const_pointer = typename absl::allocator_traits<
+      allocator_type>::template rebind_traits<value_type>::const_pointer;
+
+  // Alias used for heterogeneous lookup functions.
+  // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+  // `key_type` otherwise. It permits template argument deduction on `K` for the
+  // transparent case.
+  template <class K>
+  using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+ private:
+  // Give an early error when key_type is not hashable/eq.
+  auto KeyTypeCanBeHashed(const Hash& h, const key_type& k) -> decltype(h(k));
+  auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k));
+
+  using AllocTraits = absl::allocator_traits<allocator_type>;
+  using SlotAlloc = typename absl::allocator_traits<
+      allocator_type>::template rebind_alloc<slot_type>;
+  using SlotAllocTraits = typename absl::allocator_traits<
+      allocator_type>::template rebind_traits<slot_type>;
+
+  static_assert(std::is_lvalue_reference<reference>::value,
+                "Policy::element() must return a reference");
+
+  template <typename T>
+  struct SameAsElementReference
+      : std::is_same<typename std::remove_cv<
+                         typename std::remove_reference<reference>::type>::type,
+                     typename std::remove_cv<
+                         typename std::remove_reference<T>::type>::type> {};
+
+  // An enabler for insert(T&&): T must be convertible to init_type or be the
+  // same as [cv] value_type [ref].
+  // Note: we separate SameAsElementReference into its own type to avoid using
+  // reference unless we need to. MSVC doesn't seem to like it in some
+  // cases.
+  template <class T>
+  using RequiresInsertable = typename std::enable_if<
+      absl::disjunction<std::is_convertible<T, init_type>,
+                        SameAsElementReference<T>>::value,
+      int>::type;
+
+  // RequiresNotInit is a workaround for gcc prior to 7.1.
+  // See https://godbolt.org/g/Y4xsUh.
+  template <class T>
+  using RequiresNotInit =
+      typename std::enable_if<!std::is_same<T, init_type>::value, int>::type;
+
+  template <class... Ts>
+  using IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>;
+
+ public:
+  static_assert(std::is_same<pointer, value_type*>::value,
+                "Allocators with custom pointer types are not supported");
+  static_assert(std::is_same<const_pointer, const value_type*>::value,
+                "Allocators with custom pointer types are not supported");
+
+  class iterator {
+    friend class raw_hash_set;
+
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = typename raw_hash_set::value_type;
+    using reference =
+        absl::conditional_t<PolicyTraits::constant_iterators::value,
+                            const value_type&, value_type&>;
+    using pointer = absl::remove_reference_t<reference>*;
+    using difference_type = typename raw_hash_set::difference_type;
+
+    iterator() {}
+
+    // PRECONDITION: not an end() iterator.
+    reference operator*() const {
+      ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_,
+                                   "operator*() called on invalid iterator.");
+      return PolicyTraits::element(slot_);
+    }
+
+    // PRECONDITION: not an end() iterator.
+    pointer operator->() const {
+      ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_,
+                                   "operator-> called on invalid iterator.");
+      return &operator*();
+    }
+
+    // PRECONDITION: not an end() iterator.
+    iterator& operator++() {
+      ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_,
+                                   "operator++ called on invalid iterator.");
+      ++ctrl_;
+      ++slot_;
+      skip_empty_or_deleted();
+      return *this;
+    }
+    // PRECONDITION: not an end() iterator.
+    iterator operator++(int) {
+      auto tmp = *this;
+      ++*this;
+      return tmp;
+    }
+
+    friend bool operator==(const iterator& a, const iterator& b) {
+      AssertIsValid(a.ctrl_);
+      AssertIsValid(b.ctrl_);
+      return a.ctrl_ == b.ctrl_;
+    }
+    friend bool operator!=(const iterator& a, const iterator& b) {
+      return !(a == b);
+    }
+
+   private:
+    iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {
+      // This assumption helps the compiler know that any non-end iterator is
+      // not equal to any end iterator.
+      ABSL_ASSUME(ctrl != nullptr);
+    }
+
+    // Fixes up `ctrl_` to point to a full by advancing it and `slot_` until
+    // they reach one.
+    //
+    // If a sentinel is reached, we null both of them out instead.
+    void skip_empty_or_deleted() {
+      while (IsEmptyOrDeleted(*ctrl_)) {
+        uint32_t shift = Group{ctrl_}.CountLeadingEmptyOrDeleted();
+        ctrl_ += shift;
+        slot_ += shift;
+      }
+      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
+    }
+
+    ctrl_t* ctrl_ = nullptr;
+    // To avoid uninitialized member warnings, put slot_ in an anonymous union.
+    // The member is not initialized on singleton and end iterators.
+    union {
+      slot_type* slot_;
+    };
+  };
+
+  class const_iterator {
+    friend class raw_hash_set;
+
+   public:
+    using iterator_category = typename iterator::iterator_category;
+    using value_type = typename raw_hash_set::value_type;
+    using reference = typename raw_hash_set::const_reference;
+    using pointer = typename raw_hash_set::const_pointer;
+    using difference_type = typename raw_hash_set::difference_type;
+
+    const_iterator() {}
+    // Implicit construction from iterator.
+    const_iterator(iterator i) : inner_(std::move(i)) {}
+
+    reference operator*() const { return *inner_; }
+    pointer operator->() const { return inner_.operator->(); }
+
+    const_iterator& operator++() {
+      ++inner_;
+      return *this;
+    }
+    const_iterator operator++(int) { return inner_++; }
+
+    friend bool operator==(const const_iterator& a, const const_iterator& b) {
+      return a.inner_ == b.inner_;
+    }
+    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
+      return !(a == b);
+    }
+
+   private:
+    const_iterator(const ctrl_t* ctrl, const slot_type* slot)
+        : inner_(const_cast<ctrl_t*>(ctrl), const_cast<slot_type*>(slot)) {}
+
+    iterator inner_;
+  };
+
+  using node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>;
+  using insert_return_type = InsertReturnType<iterator, node_type>;
+
+  raw_hash_set() noexcept(
+      std::is_nothrow_default_constructible<hasher>::value&&
+          std::is_nothrow_default_constructible<key_equal>::value&&
+              std::is_nothrow_default_constructible<allocator_type>::value) {}
+
+  explicit raw_hash_set(size_t bucket_count, const hasher& hash = hasher(),
+                        const key_equal& eq = key_equal(),
+                        const allocator_type& alloc = allocator_type())
+      : ctrl_(EmptyGroup()),
+        settings_(0, HashtablezInfoHandle(), hash, eq, alloc) {
+    if (bucket_count) {
+      capacity_ = NormalizeCapacity(bucket_count);
+      initialize_slots();
+    }
+  }
+
+  raw_hash_set(size_t bucket_count, const hasher& hash,
+               const allocator_type& alloc)
+      : raw_hash_set(bucket_count, hash, key_equal(), alloc) {}
+
+  raw_hash_set(size_t bucket_count, const allocator_type& alloc)
+      : raw_hash_set(bucket_count, hasher(), key_equal(), alloc) {}
+
+  explicit raw_hash_set(const allocator_type& alloc)
+      : raw_hash_set(0, hasher(), key_equal(), alloc) {}
+
+  template <class InputIter>
+  raw_hash_set(InputIter first, InputIter last, size_t bucket_count = 0,
+               const hasher& hash = hasher(), const key_equal& eq = key_equal(),
+               const allocator_type& alloc = allocator_type())
+      : raw_hash_set(SelectBucketCountForIterRange(first, last, bucket_count),
+                     hash, eq, alloc) {
+    insert(first, last);
+  }
+
+  template <class InputIter>
+  raw_hash_set(InputIter first, InputIter last, size_t bucket_count,
+               const hasher& hash, const allocator_type& alloc)
+      : raw_hash_set(first, last, bucket_count, hash, key_equal(), alloc) {}
+
+  template <class InputIter>
+  raw_hash_set(InputIter first, InputIter last, size_t bucket_count,
+               const allocator_type& alloc)
+      : raw_hash_set(first, last, bucket_count, hasher(), key_equal(), alloc) {}
+
+  template <class InputIter>
+  raw_hash_set(InputIter first, InputIter last, const allocator_type& alloc)
+      : raw_hash_set(first, last, 0, hasher(), key_equal(), alloc) {}
+
+  // Instead of accepting std::initializer_list<value_type> as the first
+  // argument like std::unordered_set<value_type> does, we have two overloads
+  // that accept std::initializer_list<T> and std::initializer_list<init_type>.
+  // This is advantageous for performance.
+  //
+  //   // Turns {"abc", "def"} into std::initializer_list<std::string>, then
+  //   // copies the strings into the set.
+  //   std::unordered_set<std::string> s = {"abc", "def"};
+  //
+  //   // Turns {"abc", "def"} into std::initializer_list<const char*>, then
+  //   // copies the strings into the set.
+  //   absl::flat_hash_set<std::string> s = {"abc", "def"};
+  //
+  // The same trick is used in insert().
+  //
+  // The enabler is necessary to prevent this constructor from triggering where
+  // the copy constructor is meant to be called.
+  //
+  //   absl::flat_hash_set<int> a, b{a};
+  //
+  // RequiresNotInit<T> is a workaround for gcc prior to 7.1.
+  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+  raw_hash_set(std::initializer_list<T> init, size_t bucket_count = 0,
+               const hasher& hash = hasher(), const key_equal& eq = key_equal(),
+               const allocator_type& alloc = allocator_type())
+      : raw_hash_set(init.begin(), init.end(), bucket_count, hash, eq, alloc) {}
+
+  raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count = 0,
+               const hasher& hash = hasher(), const key_equal& eq = key_equal(),
+               const allocator_type& alloc = allocator_type())
+      : raw_hash_set(init.begin(), init.end(), bucket_count, hash, eq, alloc) {}
+
+  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+  raw_hash_set(std::initializer_list<T> init, size_t bucket_count,
+               const hasher& hash, const allocator_type& alloc)
+      : raw_hash_set(init, bucket_count, hash, key_equal(), alloc) {}
+
+  raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count,
+               const hasher& hash, const allocator_type& alloc)
+      : raw_hash_set(init, bucket_count, hash, key_equal(), alloc) {}
+
+  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+  raw_hash_set(std::initializer_list<T> init, size_t bucket_count,
+               const allocator_type& alloc)
+      : raw_hash_set(init, bucket_count, hasher(), key_equal(), alloc) {}
+
+  raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count,
+               const allocator_type& alloc)
+      : raw_hash_set(init, bucket_count, hasher(), key_equal(), alloc) {}
+
+  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+  raw_hash_set(std::initializer_list<T> init, const allocator_type& alloc)
+      : raw_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+
+  raw_hash_set(std::initializer_list<init_type> init,
+               const allocator_type& alloc)
+      : raw_hash_set(init, 0, hasher(), key_equal(), alloc) {}
+
+  raw_hash_set(const raw_hash_set& that)
+      : raw_hash_set(that, AllocTraits::select_on_container_copy_construction(
+                               that.alloc_ref())) {}
+
+  raw_hash_set(const raw_hash_set& that, const allocator_type& a)
+      : raw_hash_set(0, that.hash_ref(), that.eq_ref(), a) {
+    reserve(that.size());
+    // Because the table is guaranteed to be empty, we can do something faster
+    // than a full `insert`.
+    for (const auto& v : that) {
+      const size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, v);
+      auto target = find_first_non_full(ctrl_, hash, capacity_);
+      SetCtrl(target.offset, H2(hash), capacity_, ctrl_, slots_,
+              sizeof(slot_type));
+      emplace_at(target.offset, v);
+      infoz().RecordInsert(hash, target.probe_length);
+    }
+    size_ = that.size();
+    growth_left() -= that.size();
+  }
+
+  raw_hash_set(raw_hash_set&& that) noexcept(
+      std::is_nothrow_copy_constructible<hasher>::value&&
+          std::is_nothrow_copy_constructible<key_equal>::value&&
+              std::is_nothrow_copy_constructible<allocator_type>::value)
+      : ctrl_(absl::exchange(that.ctrl_, EmptyGroup())),
+        slots_(absl::exchange(that.slots_, nullptr)),
+        size_(absl::exchange(that.size_, 0)),
+        capacity_(absl::exchange(that.capacity_, 0)),
+        // Hash, equality and allocator are copied instead of moved because
+        // `that` must be left valid. If Hash is std::function<Key>, moving it
+        // would create a nullptr functor that cannot be called.
+        settings_(absl::exchange(that.growth_left(), 0),
+                  absl::exchange(that.infoz(), HashtablezInfoHandle()),
+                  that.hash_ref(), that.eq_ref(), that.alloc_ref()) {}
+
+  raw_hash_set(raw_hash_set&& that, const allocator_type& a)
+      : ctrl_(EmptyGroup()),
+        slots_(nullptr),
+        size_(0),
+        capacity_(0),
+        settings_(0, HashtablezInfoHandle(), that.hash_ref(), that.eq_ref(),
+                  a) {
+    if (a == that.alloc_ref()) {
+      std::swap(ctrl_, that.ctrl_);
+      std::swap(slots_, that.slots_);
+      std::swap(size_, that.size_);
+      std::swap(capacity_, that.capacity_);
+      std::swap(growth_left(), that.growth_left());
+      std::swap(infoz(), that.infoz());
+    } else {
+      reserve(that.size());
+      // Note: this will copy elements of dense_set and unordered_set instead of
+      // moving them. This can be fixed if it ever becomes an issue.
+      for (auto& elem : that) insert(std::move(elem));
+    }
+  }
+
+  raw_hash_set& operator=(const raw_hash_set& that) {
+    raw_hash_set tmp(that,
+                     AllocTraits::propagate_on_container_copy_assignment::value
+                         ? that.alloc_ref()
+                         : alloc_ref());
+    swap(tmp);
+    return *this;
+  }
+
+  raw_hash_set& operator=(raw_hash_set&& that) noexcept(
+      absl::allocator_traits<allocator_type>::is_always_equal::value&&
+          std::is_nothrow_move_assignable<hasher>::value&&
+              std::is_nothrow_move_assignable<key_equal>::value) {
+    // TODO(sbenza): We should only use the operations from the noexcept clause
+    // to make sure we actually adhere to that contract.
+    return move_assign(
+        std::move(that),
+        typename AllocTraits::propagate_on_container_move_assignment());
+  }
+
+  ~raw_hash_set() { destroy_slots(); }
+
+  iterator begin() {
+    auto it = iterator_at(0);
+    it.skip_empty_or_deleted();
+    return it;
+  }
+  iterator end() { return {}; }
+
+  const_iterator begin() const {
+    return const_cast<raw_hash_set*>(this)->begin();
+  }
+  const_iterator end() const { return {}; }
+  const_iterator cbegin() const { return begin(); }
+  const_iterator cend() const { return end(); }
+
+  bool empty() const { return !size(); }
+  size_t size() const { return size_; }
+  size_t capacity() const { return capacity_; }
+  size_t max_size() const { return (std::numeric_limits<size_t>::max)(); }
+
+  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
+    // Iterating over this container is O(bucket_count()). When bucket_count()
+    // is much greater than size(), iteration becomes prohibitively expensive.
+    // For clear() it is more important to reuse the allocated array when the
+    // container is small because allocation takes comparatively long time
+    // compared to destruction of the elements of the container. So we pick the
+    // largest bucket_count() threshold for which iteration is still fast and
+    // past that we simply deallocate the array.
+    if (capacity_ > 127) {
+      destroy_slots();
+
+      infoz().RecordClearedReservation();
+    } else if (capacity_) {
+      for (size_t i = 0; i != capacity_; ++i) {
+        if (IsFull(ctrl_[i])) {
+          PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+        }
+      }
+      size_ = 0;
+      ResetCtrl(capacity_, ctrl_, slots_, sizeof(slot_type));
+      reset_growth_left();
+    }
+    assert(empty());
+    infoz().RecordStorageChanged(0, capacity_);
+  }
+
+  // This overload kicks in when the argument is an rvalue of insertable and
+  // decomposable type other than init_type.
+  //
+  //   flat_hash_map<std::string, int> m;
+  //   m.insert(std::make_pair("abc", 42));
+  // TODO(cheshire): A type alias T2 is introduced as a workaround for the nvcc
+  // bug.
+  template <class T, RequiresInsertable<T> = 0, class T2 = T,
+            typename std::enable_if<IsDecomposable<T2>::value, int>::type = 0,
+            T* = nullptr>
+  std::pair<iterator, bool> insert(T&& value) {
+    return emplace(std::forward<T>(value));
+  }
+
+  // This overload kicks in when the argument is a bitfield or an lvalue of
+  // insertable and decomposable type.
+  //
+  //   union { int n : 1; };
+  //   flat_hash_set<int> s;
+  //   s.insert(n);
+  //
+  //   flat_hash_set<std::string> s;
+  //   const char* p = "hello";
+  //   s.insert(p);
+  //
+  // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+  // RequiresInsertable<T> with RequiresInsertable<const T&>.
+  // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+  template <
+      class T, RequiresInsertable<T> = 0,
+      typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+  std::pair<iterator, bool> insert(const T& value) {
+    return emplace(value);
+  }
+
+  // This overload kicks in when the argument is an rvalue of init_type. Its
+  // purpose is to handle brace-init-list arguments.
+  //
+  //   flat_hash_map<std::string, int> s;
+  //   s.insert({"abc", 42});
+  std::pair<iterator, bool> insert(init_type&& value) {
+    return emplace(std::move(value));
+  }
+
+  // TODO(cheshire): A type alias T2 is introduced as a workaround for the nvcc
+  // bug.
+  template <class T, RequiresInsertable<T> = 0, class T2 = T,
+            typename std::enable_if<IsDecomposable<T2>::value, int>::type = 0,
+            T* = nullptr>
+  iterator insert(const_iterator, T&& value) {
+    return insert(std::forward<T>(value)).first;
+  }
+
+  // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+  // RequiresInsertable<T> with RequiresInsertable<const T&>.
+  // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+  template <
+      class T, RequiresInsertable<T> = 0,
+      typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+  iterator insert(const_iterator, const T& value) {
+    return insert(value).first;
+  }
+
+  iterator insert(const_iterator, init_type&& value) {
+    return insert(std::move(value)).first;
+  }
+
+  template <class InputIt>
+  void insert(InputIt first, InputIt last) {
+    for (; first != last; ++first) emplace(*first);
+  }
+
+  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<const T&> = 0>
+  void insert(std::initializer_list<T> ilist) {
+    insert(ilist.begin(), ilist.end());
+  }
+
+  void insert(std::initializer_list<init_type> ilist) {
+    insert(ilist.begin(), ilist.end());
+  }
+
+  insert_return_type insert(node_type&& node) {
+    if (!node) return {end(), false, node_type()};
+    const auto& elem = PolicyTraits::element(CommonAccess::GetSlot(node));
+    auto res = PolicyTraits::apply(
+        InsertSlot<false>{*this, std::move(*CommonAccess::GetSlot(node))},
+        elem);
+    if (res.second) {
+      CommonAccess::Reset(&node);
+      return {res.first, true, node_type()};
+    } else {
+      return {res.first, false, std::move(node)};
+    }
+  }
+
+  iterator insert(const_iterator, node_type&& node) {
+    auto res = insert(std::move(node));
+    node = std::move(res.node);
+    return res.position;
+  }
+
+  // This overload kicks in if we can deduce the key from args. This enables us
+  // to avoid constructing value_type if an entry with the same key already
+  // exists.
+  //
+  // For example:
+  //
+  //   flat_hash_map<std::string, std::string> m = {{"abc", "def"}};
+  //   // Creates no std::string copies and makes no heap allocations.
+  //   m.emplace("abc", "xyz");
+  template <class... Args, typename std::enable_if<
+                               IsDecomposable<Args...>::value, int>::type = 0>
+  std::pair<iterator, bool> emplace(Args&&... args) {
+    return PolicyTraits::apply(EmplaceDecomposable{*this},
+                               std::forward<Args>(args)...);
+  }
+
+  // This overload kicks in if we cannot deduce the key from args. It constructs
+  // value_type unconditionally and then either moves it into the table or
+  // destroys.
+  template <class... Args, typename std::enable_if<
+                               !IsDecomposable<Args...>::value, int>::type = 0>
+  std::pair<iterator, bool> emplace(Args&&... args) {
+    alignas(slot_type) unsigned char raw[sizeof(slot_type)];
+    slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+
+    PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
+    const auto& elem = PolicyTraits::element(slot);
+    return PolicyTraits::apply(InsertSlot<true>{*this, std::move(*slot)}, elem);
+  }
+
+  template <class... Args>
+  iterator emplace_hint(const_iterator, Args&&... args) {
+    return emplace(std::forward<Args>(args)...).first;
+  }
+
+  // Extension API: support for lazy emplace.
+  //
+  // Looks up key in the table. If found, returns the iterator to the element.
+  // Otherwise calls `f` with one argument of type `raw_hash_set::constructor`.
+  //
+  // `f` must abide by several restrictions:
+  //  - it MUST call `raw_hash_set::constructor` with arguments as if a
+  //    `raw_hash_set::value_type` is constructed,
+  //  - it MUST NOT access the container before the call to
+  //    `raw_hash_set::constructor`, and
+  //  - it MUST NOT erase the lazily emplaced element.
+  // Doing any of these is undefined behavior.
+  //
+  // For example:
+  //
+  //   std::unordered_set<ArenaString> s;
+  //   // Makes ArenaStr even if "abc" is in the map.
+  //   s.insert(ArenaString(&arena, "abc"));
+  //
+  //   flat_hash_set<ArenaStr> s;
+  //   // Makes ArenaStr only if "abc" is not in the map.
+  //   s.lazy_emplace("abc", [&](const constructor& ctor) {
+  //     ctor(&arena, "abc");
+  //   });
+  //
+  // WARNING: This API is currently experimental. If there is a way to implement
+  // the same thing with the rest of the API, prefer that.
+  class constructor {
+    friend class raw_hash_set;
+
+   public:
+    template <class... Args>
+    void operator()(Args&&... args) const {
+      assert(*slot_);
+      PolicyTraits::construct(alloc_, *slot_, std::forward<Args>(args)...);
+      *slot_ = nullptr;
+    }
+
+   private:
+    constructor(allocator_type* a, slot_type** slot) : alloc_(a), slot_(slot) {}
+
+    allocator_type* alloc_;
+    slot_type** slot_;
+  };
+
+  template <class K = key_type, class F>
+  iterator lazy_emplace(const key_arg<K>& key, F&& f) {
+    auto res = find_or_prepare_insert(key);
+    if (res.second) {
+      slot_type* slot = slots_ + res.first;
+      std::forward<F>(f)(constructor(&alloc_ref(), &slot));
+      assert(!slot);
+    }
+    return iterator_at(res.first);
+  }
+
+  // Extension API: support for heterogeneous keys.
+  //
+  //   std::unordered_set<std::string> s;
+  //   // Turns "abc" into std::string.
+  //   s.erase("abc");
+  //
+  //   flat_hash_set<std::string> s;
+  //   // Uses "abc" directly without copying it into std::string.
+  //   s.erase("abc");
+  template <class K = key_type>
+  size_type erase(const key_arg<K>& key) {
+    auto it = find(key);
+    if (it == end()) return 0;
+    erase(it);
+    return 1;
+  }
+
+  // Erases the element pointed to by `it`.  Unlike `std::unordered_set::erase`,
+  // this method returns void to reduce algorithmic complexity to O(1).  The
+  // iterator is invalidated, so any increment should be done before calling
+  // erase.  In order to erase while iterating across a map, use the following
+  // idiom (which also works for standard containers):
+  //
+  // for (auto it = m.begin(), end = m.end(); it != end;) {
+  //   // `erase()` will invalidate `it`, so advance `it` first.
+  //   auto copy_it = it++;
+  //   if (<pred>) {
+  //     m.erase(copy_it);
+  //   }
+  // }
+  void erase(const_iterator cit) { erase(cit.inner_); }
+
+  // This overload is necessary because otherwise erase<K>(const K&) would be
+  // a better match if non-const iterator is passed as an argument.
+  void erase(iterator it) {
+    ABSL_INTERNAL_ASSERT_IS_FULL(it.ctrl_,
+                                 "erase() called on invalid iterator.");
+    PolicyTraits::destroy(&alloc_ref(), it.slot_);
+    erase_meta_only(it);
+  }
+
+  iterator erase(const_iterator first, const_iterator last) {
+    while (first != last) {
+      erase(first++);
+    }
+    return last.inner_;
+  }
+
+  // Moves elements from `src` into `this`.
+  // If the element already exists in `this`, it is left unmodified in `src`.
+  template <typename H, typename E>
+  void merge(raw_hash_set<Policy, H, E, Alloc>& src) {  // NOLINT
+    assert(this != &src);
+    for (auto it = src.begin(), e = src.end(); it != e;) {
+      auto next = std::next(it);
+      if (PolicyTraits::apply(InsertSlot<false>{*this, std::move(*it.slot_)},
+                              PolicyTraits::element(it.slot_))
+              .second) {
+        src.erase_meta_only(it);
+      }
+      it = next;
+    }
+  }
+
+  template <typename H, typename E>
+  void merge(raw_hash_set<Policy, H, E, Alloc>&& src) {
+    merge(src);
+  }
+
+  node_type extract(const_iterator position) {
+    ABSL_INTERNAL_ASSERT_IS_FULL(position.inner_.ctrl_,
+                                 "extract() called on invalid iterator.");
+    auto node =
+        CommonAccess::Transfer<node_type>(alloc_ref(), position.inner_.slot_);
+    erase_meta_only(position);
+    return node;
+  }
+
+  template <
+      class K = key_type,
+      typename std::enable_if<!std::is_same<K, iterator>::value, int>::type = 0>
+  node_type extract(const key_arg<K>& key) {
+    auto it = find(key);
+    return it == end() ? node_type() : extract(const_iterator{it});
+  }
+
+  void swap(raw_hash_set& that) noexcept(
+      IsNoThrowSwappable<hasher>() && IsNoThrowSwappable<key_equal>() &&
+      IsNoThrowSwappable<allocator_type>(
+          typename AllocTraits::propagate_on_container_swap{})) {
+    using std::swap;
+    swap(ctrl_, that.ctrl_);
+    swap(slots_, that.slots_);
+    swap(size_, that.size_);
+    swap(capacity_, that.capacity_);
+    swap(growth_left(), that.growth_left());
+    swap(hash_ref(), that.hash_ref());
+    swap(eq_ref(), that.eq_ref());
+    swap(infoz(), that.infoz());
+    SwapAlloc(alloc_ref(), that.alloc_ref(),
+              typename AllocTraits::propagate_on_container_swap{});
+  }
+
+  void rehash(size_t n) {
+    if (n == 0 && capacity_ == 0) return;
+    if (n == 0 && size_ == 0) {
+      destroy_slots();
+      infoz().RecordStorageChanged(0, 0);
+      infoz().RecordClearedReservation();
+      return;
+    }
+
+    // bitor is a faster way of doing `max` here. We will round up to the next
+    // power-of-2-minus-1, so bitor is good enough.
+    auto m = NormalizeCapacity(n | GrowthToLowerboundCapacity(size()));
+    // n == 0 unconditionally rehashes as per the standard.
+    if (n == 0 || m > capacity_) {
+      resize(m);
+
+      // This is after resize, to ensure that we have completed the allocation
+      // and have potentially sampled the hashtable.
+      infoz().RecordReservation(n);
+    }
+  }
+
+  void reserve(size_t n) {
+    if (n > size() + growth_left()) {
+      size_t m = GrowthToLowerboundCapacity(n);
+      resize(NormalizeCapacity(m));
+
+      // This is after resize, to ensure that we have completed the allocation
+      // and have potentially sampled the hashtable.
+      infoz().RecordReservation(n);
+    }
+  }
+
+  // Extension API: support for heterogeneous keys.
+  //
+  //   std::unordered_set<std::string> s;
+  //   // Turns "abc" into std::string.
+  //   s.count("abc");
+  //
+  //   ch_set<std::string> s;
+  //   // Uses "abc" directly without copying it into std::string.
+  //   s.count("abc");
+  template <class K = key_type>
+  size_t count(const key_arg<K>& key) const {
+    return find(key) == end() ? 0 : 1;
+  }
+
+  // Issues CPU prefetch instructions for the memory needed to find or insert
+  // a key.  Like all lookup functions, this support heterogeneous keys.
+  //
+  // NOTE: This is a very low level operation and should not be used without
+  // specific benchmarks indicating its importance.
+  template <class K = key_type>
+  void prefetch(const key_arg<K>& key) const {
+    (void)key;
+    // Avoid probing if we won't be able to prefetch the addresses received.
+#ifdef ABSL_INTERNAL_HAVE_PREFETCH
+    prefetch_heap_block();
+    auto seq = probe(ctrl_, hash_ref()(key), capacity_);
+    base_internal::PrefetchT0(ctrl_ + seq.offset());
+    base_internal::PrefetchT0(slots_ + seq.offset());
+#endif  // ABSL_INTERNAL_HAVE_PREFETCH
+  }
+
+  // The API of find() has two extensions.
+  //
+  // 1. The hash can be passed by the user. It must be equal to the hash of the
+  // key.
+  //
+  // 2. The type of the key argument doesn't have to be key_type. This is so
+  // called heterogeneous key support.
+  template <class K = key_type>
+  iterator find(const key_arg<K>& key, size_t hash) {
+    auto seq = probe(ctrl_, hash, capacity_);
+    while (true) {
+      Group g{ctrl_ + seq.offset()};
+      for (uint32_t i : g.Match(H2(hash))) {
+        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
+                EqualElement<K>{key, eq_ref()},
+                PolicyTraits::element(slots_ + seq.offset(i)))))
+          return iterator_at(seq.offset(i));
+      }
+      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
+      seq.next();
+      assert(seq.index() <= capacity_ && "full table!");
+    }
+  }
+  template <class K = key_type>
+  iterator find(const key_arg<K>& key) {
+    prefetch_heap_block();
+    return find(key, hash_ref()(key));
+  }
+
+  template <class K = key_type>
+  const_iterator find(const key_arg<K>& key, size_t hash) const {
+    return const_cast<raw_hash_set*>(this)->find(key, hash);
+  }
+  template <class K = key_type>
+  const_iterator find(const key_arg<K>& key) const {
+    prefetch_heap_block();
+    return find(key, hash_ref()(key));
+  }
+
+  template <class K = key_type>
+  bool contains(const key_arg<K>& key) const {
+    return find(key) != end();
+  }
+
+  template <class K = key_type>
+  std::pair<iterator, iterator> equal_range(const key_arg<K>& key) {
+    auto it = find(key);
+    if (it != end()) return {it, std::next(it)};
+    return {it, it};
+  }
+  template <class K = key_type>
+  std::pair<const_iterator, const_iterator> equal_range(
+      const key_arg<K>& key) const {
+    auto it = find(key);
+    if (it != end()) return {it, std::next(it)};
+    return {it, it};
+  }
+
+  size_t bucket_count() const { return capacity_; }
+  float load_factor() const {
+    return capacity_ ? static_cast<double>(size()) / capacity_ : 0.0;
+  }
+  float max_load_factor() const { return 1.0f; }
+  void max_load_factor(float) {
+    // Does nothing.
+  }
+
+  hasher hash_function() const { return hash_ref(); }
+  key_equal key_eq() const { return eq_ref(); }
+  allocator_type get_allocator() const { return alloc_ref(); }
+
+  friend bool operator==(const raw_hash_set& a, const raw_hash_set& b) {
+    if (a.size() != b.size()) return false;
+    const raw_hash_set* outer = &a;
+    const raw_hash_set* inner = &b;
+    if (outer->capacity() > inner->capacity()) std::swap(outer, inner);
+    for (const value_type& elem : *outer)
+      if (!inner->has_element(elem)) return false;
+    return true;
+  }
+
+  friend bool operator!=(const raw_hash_set& a, const raw_hash_set& b) {
+    return !(a == b);
+  }
+
+  template <typename H>
+  friend typename std::enable_if<H::template is_hashable<value_type>::value,
+                                 H>::type
+  AbslHashValue(H h, const raw_hash_set& s) {
+    return H::combine(H::combine_unordered(std::move(h), s.begin(), s.end()),
+                      s.size());
+  }
+
+  friend void swap(raw_hash_set& a,
+                   raw_hash_set& b) noexcept(noexcept(a.swap(b))) {
+    a.swap(b);
+  }
+
+ private:
+  template <class Container, typename Enabler>
+  friend struct absl::container_internal::hashtable_debug_internal::
+      HashtableDebugAccess;
+
+  struct FindElement {
+    template <class K, class... Args>
+    const_iterator operator()(const K& key, Args&&...) const {
+      return s.find(key);
+    }
+    const raw_hash_set& s;
+  };
+
+  struct HashElement {
+    template <class K, class... Args>
+    size_t operator()(const K& key, Args&&...) const {
+      return h(key);
+    }
+    const hasher& h;
+  };
+
+  template <class K1>
+  struct EqualElement {
+    template <class K2, class... Args>
+    bool operator()(const K2& lhs, Args&&...) const {
+      return eq(lhs, rhs);
+    }
+    const K1& rhs;
+    const key_equal& eq;
+  };
+
+  struct EmplaceDecomposable {
+    template <class K, class... Args>
+    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
+      auto res = s.find_or_prepare_insert(key);
+      if (res.second) {
+        s.emplace_at(res.first, std::forward<Args>(args)...);
+      }
+      return {s.iterator_at(res.first), res.second};
+    }
+    raw_hash_set& s;
+  };
+
+  template <bool do_destroy>
+  struct InsertSlot {
+    template <class K, class... Args>
+    std::pair<iterator, bool> operator()(const K& key, Args&&...) && {
+      auto res = s.find_or_prepare_insert(key);
+      if (res.second) {
+        PolicyTraits::transfer(&s.alloc_ref(), s.slots_ + res.first, &slot);
+      } else if (do_destroy) {
+        PolicyTraits::destroy(&s.alloc_ref(), &slot);
+      }
+      return {s.iterator_at(res.first), res.second};
+    }
+    raw_hash_set& s;
+    // Constructed slot. Either moved into place or destroyed.
+    slot_type&& slot;
+  };
+
+  // Erases, but does not destroy, the value pointed to by `it`.
+  //
+  // This merely updates the pertinent control byte. This can be used in
+  // conjunction with Policy::transfer to move the object to another place.
+  void erase_meta_only(const_iterator it) {
+    assert(IsFull(*it.inner_.ctrl_) && "erasing a dangling iterator");
+    --size_;
+    const size_t index = static_cast<size_t>(it.inner_.ctrl_ - ctrl_);
+    const size_t index_before = (index - Group::kWidth) & capacity_;
+    const auto empty_after = Group(it.inner_.ctrl_).MaskEmpty();
+    const auto empty_before = Group(ctrl_ + index_before).MaskEmpty();
+
+    // We count how many consecutive non empties we have to the right and to the
+    // left of `it`. If the sum is >= kWidth then there is at least one probe
+    // window that might have seen a full group.
+    bool was_never_full =
+        empty_before && empty_after &&
+        static_cast<size_t>(empty_after.TrailingZeros() +
+                            empty_before.LeadingZeros()) < Group::kWidth;
+
+    SetCtrl(index, was_never_full ? ctrl_t::kEmpty : ctrl_t::kDeleted,
+            capacity_, ctrl_, slots_, sizeof(slot_type));
+    growth_left() += was_never_full;
+    infoz().RecordErase();
+  }
+
+  // Allocates a backing array for `self` and initializes its control bytes.
+  // This reads `capacity_` and updates all other fields based on the result of
+  // the allocation.
+  //
+  // This does not free the currently held array; `capacity_` must be nonzero.
+  void initialize_slots() {
+    assert(capacity_);
+    // Folks with custom allocators often make unwarranted assumptions about the
+    // behavior of their classes vis-a-vis trivial destructability and what
+    // calls they will or wont make.  Avoid sampling for people with custom
+    // allocators to get us out of this mess.  This is not a hard guarantee but
+    // a workaround while we plan the exact guarantee we want to provide.
+    //
+    // People are often sloppy with the exact type of their allocator (sometimes
+    // it has an extra const or is missing the pair, but rebinds made it work
+    // anyway).  To avoid the ambiguity, we work off SlotAlloc which we have
+    // bound more carefully.
+    if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value &&
+        slots_ == nullptr) {
+      infoz() = Sample(sizeof(slot_type));
+    }
+
+    char* mem = static_cast<char*>(Allocate<alignof(slot_type)>(
+        &alloc_ref(),
+        AllocSize(capacity_, sizeof(slot_type), alignof(slot_type))));
+    ctrl_ = reinterpret_cast<ctrl_t*>(mem);
+    slots_ = reinterpret_cast<slot_type*>(
+        mem + SlotOffset(capacity_, alignof(slot_type)));
+    ResetCtrl(capacity_, ctrl_, slots_, sizeof(slot_type));
+    reset_growth_left();
+    infoz().RecordStorageChanged(size_, capacity_);
+  }
+
+  // Destroys all slots in the backing array, frees the backing array, and
+  // clears all top-level book-keeping data.
+  //
+  // This essentially implements `map = raw_hash_set();`.
+  void destroy_slots() {
+    if (!capacity_) return;
+    for (size_t i = 0; i != capacity_; ++i) {
+      if (IsFull(ctrl_[i])) {
+        PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+      }
+    }
+
+    // Unpoison before returning the memory to the allocator.
+    SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
+    Deallocate<alignof(slot_type)>(
+        &alloc_ref(), ctrl_,
+        AllocSize(capacity_, sizeof(slot_type), alignof(slot_type)));
+    ctrl_ = EmptyGroup();
+    slots_ = nullptr;
+    size_ = 0;
+    capacity_ = 0;
+    growth_left() = 0;
+  }
+
+  void resize(size_t new_capacity) {
+    assert(IsValidCapacity(new_capacity));
+    auto* old_ctrl = ctrl_;
+    auto* old_slots = slots_;
+    const size_t old_capacity = capacity_;
+    capacity_ = new_capacity;
+    initialize_slots();
+
+    size_t total_probe_length = 0;
+    for (size_t i = 0; i != old_capacity; ++i) {
+      if (IsFull(old_ctrl[i])) {
+        size_t hash = PolicyTraits::apply(HashElement{hash_ref()},
+                                          PolicyTraits::element(old_slots + i));
+        auto target = find_first_non_full(ctrl_, hash, capacity_);
+        size_t new_i = target.offset;
+        total_probe_length += target.probe_length;
+        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, old_slots + i);
+      }
+    }
+    if (old_capacity) {
+      SanitizerUnpoisonMemoryRegion(old_slots,
+                                    sizeof(slot_type) * old_capacity);
+      Deallocate<alignof(slot_type)>(
+          &alloc_ref(), old_ctrl,
+          AllocSize(old_capacity, sizeof(slot_type), alignof(slot_type)));
+    }
+    infoz().RecordRehash(total_probe_length);
+  }
+
+  // Prunes control bytes to remove as many tombstones as possible.
+  //
+  // See the comment on `rehash_and_grow_if_necessary()`.
+  void drop_deletes_without_resize() ABSL_ATTRIBUTE_NOINLINE {
+    assert(IsValidCapacity(capacity_));
+    assert(!is_small(capacity_));
+    // Algorithm:
+    // - mark all DELETED slots as EMPTY
+    // - mark all FULL slots as DELETED
+    // - for each slot marked as DELETED
+    //     hash = Hash(element)
+    //     target = find_first_non_full(hash)
+    //     if target is in the same group
+    //       mark slot as FULL
+    //     else if target is EMPTY
+    //       transfer element to target
+    //       mark slot as EMPTY
+    //       mark target as FULL
+    //     else if target is DELETED
+    //       swap current element with target element
+    //       mark target as FULL
+    //       repeat procedure for current slot with moved from element (target)
+    ConvertDeletedToEmptyAndFullToDeleted(ctrl_, capacity_);
+    alignas(slot_type) unsigned char raw[sizeof(slot_type)];
+    size_t total_probe_length = 0;
+    slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+    for (size_t i = 0; i != capacity_; ++i) {
+      if (!IsDeleted(ctrl_[i])) continue;
+      const size_t hash = PolicyTraits::apply(
+          HashElement{hash_ref()}, PolicyTraits::element(slots_ + i));
+      const FindInfo target = find_first_non_full(ctrl_, hash, capacity_);
+      const size_t new_i = target.offset;
+      total_probe_length += target.probe_length;
+
+      // Verify if the old and new i fall within the same group wrt the hash.
+      // If they do, we don't need to move the object as it falls already in the
+      // best probe we can.
+      const size_t probe_offset = probe(ctrl_, hash, capacity_).offset();
+      const auto probe_index = [probe_offset, this](size_t pos) {
+        return ((pos - probe_offset) & capacity_) / Group::kWidth;
+      };
+
+      // Element doesn't move.
+      if (ABSL_PREDICT_TRUE(probe_index(new_i) == probe_index(i))) {
+        SetCtrl(i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+        continue;
+      }
+      if (IsEmpty(ctrl_[new_i])) {
+        // Transfer element to the empty spot.
+        // SetCtrl poisons/unpoisons the slots so we have to call it at the
+        // right time.
+        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slots_ + i);
+        SetCtrl(i, ctrl_t::kEmpty, capacity_, ctrl_, slots_, sizeof(slot_type));
+      } else {
+        assert(IsDeleted(ctrl_[new_i]));
+        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+        // Until we are done rehashing, DELETED marks previously FULL slots.
+        // Swap i and new_i elements.
+        PolicyTraits::transfer(&alloc_ref(), slot, slots_ + i);
+        PolicyTraits::transfer(&alloc_ref(), slots_ + i, slots_ + new_i);
+        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slot);
+        --i;  // repeat
+      }
+    }
+    reset_growth_left();
+    infoz().RecordRehash(total_probe_length);
+  }
+
+  // Called whenever the table *might* need to conditionally grow.
+  //
+  // This function is an optimization opportunity to perform a rehash even when
+  // growth is unnecessary, because vacating tombstones is beneficial for
+  // performance in the long-run.
+  void rehash_and_grow_if_necessary() {
+    if (capacity_ == 0) {
+      resize(1);
+    } else if (capacity_ > Group::kWidth &&
+               // Do these calcuations in 64-bit to avoid overflow.
+               size() * uint64_t{32} <= capacity_ * uint64_t{25}) {
+      // Squash DELETED without growing if there is enough capacity.
+      //
+      // Rehash in place if the current size is <= 25/32 of capacity_.
+      // Rationale for such a high factor: 1) drop_deletes_without_resize() is
+      // faster than resize, and 2) it takes quite a bit of work to add
+      // tombstones.  In the worst case, seems to take approximately 4
+      // insert/erase pairs to create a single tombstone and so if we are
+      // rehashing because of tombstones, we can afford to rehash-in-place as
+      // long as we are reclaiming at least 1/8 the capacity without doing more
+      // than 2X the work.  (Where "work" is defined to be size() for rehashing
+      // or rehashing in place, and 1 for an insert or erase.)  But rehashing in
+      // place is faster per operation than inserting or even doubling the size
+      // of the table, so we actually afford to reclaim even less space from a
+      // resize-in-place.  The decision is to rehash in place if we can reclaim
+      // at about 1/8th of the usable capacity (specifically 3/28 of the
+      // capacity) which means that the total cost of rehashing will be a small
+      // fraction of the total work.
+      //
+      // Here is output of an experiment using the BM_CacheInSteadyState
+      // benchmark running the old case (where we rehash-in-place only if we can
+      // reclaim at least 7/16*capacity_) vs. this code (which rehashes in place
+      // if we can recover 3/32*capacity_).
+      //
+      // Note that although in the worst-case number of rehashes jumped up from
+      // 15 to 190, but the number of operations per second is almost the same.
+      //
+      // Abridged output of running BM_CacheInSteadyState benchmark from
+      // raw_hash_set_benchmark.   N is the number of insert/erase operations.
+      //
+      //      | OLD (recover >= 7/16        | NEW (recover >= 3/32)
+      // size |    N/s LoadFactor NRehashes |    N/s LoadFactor NRehashes
+      //  448 | 145284       0.44        18 | 140118       0.44        19
+      //  493 | 152546       0.24        11 | 151417       0.48        28
+      //  538 | 151439       0.26        11 | 151152       0.53        38
+      //  583 | 151765       0.28        11 | 150572       0.57        50
+      //  628 | 150241       0.31        11 | 150853       0.61        66
+      //  672 | 149602       0.33        12 | 150110       0.66        90
+      //  717 | 149998       0.35        12 | 149531       0.70       129
+      //  762 | 149836       0.37        13 | 148559       0.74       190
+      //  807 | 149736       0.39        14 | 151107       0.39        14
+      //  852 | 150204       0.42        15 | 151019       0.42        15
+      drop_deletes_without_resize();
+    } else {
+      // Otherwise grow the container.
+      resize(capacity_ * 2 + 1);
+    }
+  }
+
+  bool has_element(const value_type& elem) const {
+    size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, elem);
+    auto seq = probe(ctrl_, hash, capacity_);
+    while (true) {
+      Group g{ctrl_ + seq.offset()};
+      for (uint32_t i : g.Match(H2(hash))) {
+        if (ABSL_PREDICT_TRUE(PolicyTraits::element(slots_ + seq.offset(i)) ==
+                              elem))
+          return true;
+      }
+      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return false;
+      seq.next();
+      assert(seq.index() <= capacity_ && "full table!");
+    }
+    return false;
+  }
+
+  // TODO(alkis): Optimize this assuming *this and that don't overlap.
+  raw_hash_set& move_assign(raw_hash_set&& that, std::true_type) {
+    raw_hash_set tmp(std::move(that));
+    swap(tmp);
+    return *this;
+  }
+  raw_hash_set& move_assign(raw_hash_set&& that, std::false_type) {
+    raw_hash_set tmp(std::move(that), alloc_ref());
+    swap(tmp);
+    return *this;
+  }
+
+ protected:
+  // Attempts to find `key` in the table; if it isn't found, returns a slot that
+  // the value can be inserted into, with the control byte already set to
+  // `key`'s H2.
+  template <class K>
+  std::pair<size_t, bool> find_or_prepare_insert(const K& key) {
+    prefetch_heap_block();
+    auto hash = hash_ref()(key);
+    auto seq = probe(ctrl_, hash, capacity_);
+    while (true) {
+      Group g{ctrl_ + seq.offset()};
+      for (uint32_t i : g.Match(H2(hash))) {
+        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
+                EqualElement<K>{key, eq_ref()},
+                PolicyTraits::element(slots_ + seq.offset(i)))))
+          return {seq.offset(i), false};
+      }
+      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) break;
+      seq.next();
+      assert(seq.index() <= capacity_ && "full table!");
+    }
+    return {prepare_insert(hash), true};
+  }
+
+  // Given the hash of a value not currently in the table, finds the next
+  // viable slot index to insert it at.
+  //
+  // REQUIRES: At least one non-full slot available.
+  size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE {
+    auto target = find_first_non_full(ctrl_, hash, capacity_);
+    if (ABSL_PREDICT_FALSE(growth_left() == 0 &&
+                           !IsDeleted(ctrl_[target.offset]))) {
+      rehash_and_grow_if_necessary();
+      target = find_first_non_full(ctrl_, hash, capacity_);
+    }
+    ++size_;
+    growth_left() -= IsEmpty(ctrl_[target.offset]);
+    SetCtrl(target.offset, H2(hash), capacity_, ctrl_, slots_,
+            sizeof(slot_type));
+    infoz().RecordInsert(hash, target.probe_length);
+    return target.offset;
+  }
+
+  // Constructs the value in the space pointed by the iterator. This only works
+  // after an unsuccessful find_or_prepare_insert() and before any other
+  // modifications happen in the raw_hash_set.
+  //
+  // PRECONDITION: i is an index returned from find_or_prepare_insert(k), where
+  // k is the key decomposed from `forward<Args>(args)...`, and the bool
+  // returned by find_or_prepare_insert(k) was true.
+  // POSTCONDITION: *m.iterator_at(i) == value_type(forward<Args>(args)...).
+  template <class... Args>
+  void emplace_at(size_t i, Args&&... args) {
+    PolicyTraits::construct(&alloc_ref(), slots_ + i,
+                            std::forward<Args>(args)...);
+
+    assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
+               iterator_at(i) &&
+           "constructed value does not match the lookup key");
+  }
+
+  iterator iterator_at(size_t i) { return {ctrl_ + i, slots_ + i}; }
+  const_iterator iterator_at(size_t i) const { return {ctrl_ + i, slots_ + i}; }
+
+ private:
+  friend struct RawHashSetTestOnlyAccess;
+
+  void reset_growth_left() {
+    growth_left() = CapacityToGrowth(capacity()) - size_;
+  }
+
+  // The number of slots we can still fill without needing to rehash.
+  //
+  // This is stored separately due to tombstones: we do not include tombstones
+  // in the growth capacity, because we'd like to rehash when the table is
+  // otherwise filled with tombstones: otherwise, probe sequences might get
+  // unacceptably long without triggering a rehash. Callers can also force a
+  // rehash via the standard `rehash(0)`, which will recompute this value as a
+  // side-effect.
+  //
+  // See `CapacityToGrowth()`.
+  size_t& growth_left() { return settings_.template get<0>(); }
+
+  // Prefetch the heap-allocated memory region to resolve potential TLB misses.
+  // This is intended to overlap with execution of calculating the hash for a
+  // key.
+  void prefetch_heap_block() const {
+    base_internal::PrefetchT2(ctrl_);
+  }
+
+  HashtablezInfoHandle& infoz() { return settings_.template get<1>(); }
+
+  hasher& hash_ref() { return settings_.template get<2>(); }
+  const hasher& hash_ref() const { return settings_.template get<2>(); }
+  key_equal& eq_ref() { return settings_.template get<3>(); }
+  const key_equal& eq_ref() const { return settings_.template get<3>(); }
+  allocator_type& alloc_ref() { return settings_.template get<4>(); }
+  const allocator_type& alloc_ref() const {
+    return settings_.template get<4>();
+  }
+
+  // TODO(alkis): Investigate removing some of these fields:
+  // - ctrl/slots can be derived from each other
+  // - size can be moved into the slot array
+
+  // The control bytes (and, also, a pointer to the base of the backing array).
+  //
+  // This contains `capacity_ + 1 + NumClonedBytes()` entries, even
+  // when the table is empty (hence EmptyGroup).
+  ctrl_t* ctrl_ = EmptyGroup();
+  // The beginning of the slots, located at `SlotOffset()` bytes after
+  // `ctrl_`. May be null for empty tables.
+  slot_type* slots_ = nullptr;
+
+  // The number of filled slots.
+  size_t size_ = 0;
+
+  // The total number of available slots.
+  size_t capacity_ = 0;
+  absl::container_internal::CompressedTuple<size_t /* growth_left */,
+                                            HashtablezInfoHandle, hasher,
+                                            key_equal, allocator_type>
+      settings_{0u, HashtablezInfoHandle{}, hasher{}, key_equal{},
+                allocator_type{}};
+};
+
+// Erases all elements that satisfy the predicate `pred` from the container `c`.
+template <typename P, typename H, typename E, typename A, typename Predicate>
+typename raw_hash_set<P, H, E, A>::size_type EraseIf(
+    Predicate& pred, raw_hash_set<P, H, E, A>* c) {
+  const auto initial_size = c->size();
+  for (auto it = c->begin(), last = c->end(); it != last;) {
+    if (pred(*it)) {
+      c->erase(it++);
+    } else {
+      ++it;
+    }
+  }
+  return initial_size - c->size();
+}
+
+namespace hashtable_debug_internal {
+template <typename Set>
+struct HashtableDebugAccess<Set, absl::void_t<typename Set::raw_hash_set>> {
+  using Traits = typename Set::PolicyTraits;
+  using Slot = typename Traits::slot_type;
+
+  static size_t GetNumProbes(const Set& set,
+                             const typename Set::key_type& key) {
+    size_t num_probes = 0;
+    size_t hash = set.hash_ref()(key);
+    auto seq = probe(set.ctrl_, hash, set.capacity_);
+    while (true) {
+      container_internal::Group g{set.ctrl_ + seq.offset()};
+      for (uint32_t i : g.Match(container_internal::H2(hash))) {
+        if (Traits::apply(
+                typename Set::template EqualElement<typename Set::key_type>{
+                    key, set.eq_ref()},
+                Traits::element(set.slots_ + seq.offset(i))))
+          return num_probes;
+        ++num_probes;
+      }
+      if (g.MaskEmpty()) return num_probes;
+      seq.next();
+      ++num_probes;
+    }
+  }
+
+  static size_t AllocatedByteSize(const Set& c) {
+    size_t capacity = c.capacity_;
+    if (capacity == 0) return 0;
+    size_t m = AllocSize(capacity, sizeof(Slot), alignof(Slot));
+
+    size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
+    if (per_slot != ~size_t{}) {
+      m += per_slot * c.size();
+    } else {
+      for (size_t i = 0; i != capacity; ++i) {
+        if (container_internal::IsFull(c.ctrl_[i])) {
+          m += Traits::space_used(c.slots_ + i);
+        }
+      }
+    }
+    return m;
+  }
+
+  static size_t LowerBoundAllocatedByteSize(size_t size) {
+    size_t capacity = GrowthToLowerboundCapacity(size);
+    if (capacity == 0) return 0;
+    size_t m =
+        AllocSize(NormalizeCapacity(capacity), sizeof(Slot), alignof(Slot));
+    size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
+    if (per_slot != ~size_t{}) {
+      m += per_slot * size;
+    }
+    return m;
+  }
+};
+
+}  // namespace hashtable_debug_internal
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#undef ABSL_INTERNAL_ASSERT_IS_FULL
+
+#endif  // ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/test_instance_tracker.h b/CAPI/cpp/grpc/include/absl/container/internal/test_instance_tracker.h
new file mode 100644
index 0000000..5ff6fd7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/test_instance_tracker.h
@@ -0,0 +1,274 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
+#define ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
+
+#include <cstdlib>
+#include <ostream>
+
+#include "absl/types/compare.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace test_internal {
+
+// A type that counts number of occurrences of the type, the live occurrences of
+// the type, as well as the number of copies, moves, swaps, and comparisons that
+// have occurred on the type. This is used as a base class for the copyable,
+// copyable+movable, and movable types below that are used in actual tests. Use
+// InstanceTracker in tests to track the number of instances.
+class BaseCountedInstance {
+ public:
+  explicit BaseCountedInstance(int x) : value_(x) {
+    ++num_instances_;
+    ++num_live_instances_;
+  }
+  BaseCountedInstance(const BaseCountedInstance& x)
+      : value_(x.value_), is_live_(x.is_live_) {
+    ++num_instances_;
+    if (is_live_) ++num_live_instances_;
+    ++num_copies_;
+  }
+  BaseCountedInstance(BaseCountedInstance&& x)
+      : value_(x.value_), is_live_(x.is_live_) {
+    x.is_live_ = false;
+    ++num_instances_;
+    ++num_moves_;
+  }
+  ~BaseCountedInstance() {
+    --num_instances_;
+    if (is_live_) --num_live_instances_;
+  }
+
+  BaseCountedInstance& operator=(const BaseCountedInstance& x) {
+    value_ = x.value_;
+    if (is_live_) --num_live_instances_;
+    is_live_ = x.is_live_;
+    if (is_live_) ++num_live_instances_;
+    ++num_copies_;
+    return *this;
+  }
+  BaseCountedInstance& operator=(BaseCountedInstance&& x) {
+    value_ = x.value_;
+    if (is_live_) --num_live_instances_;
+    is_live_ = x.is_live_;
+    x.is_live_ = false;
+    ++num_moves_;
+    return *this;
+  }
+
+  bool operator==(const BaseCountedInstance& x) const {
+    ++num_comparisons_;
+    return value_ == x.value_;
+  }
+
+  bool operator!=(const BaseCountedInstance& x) const {
+    ++num_comparisons_;
+    return value_ != x.value_;
+  }
+
+  bool operator<(const BaseCountedInstance& x) const {
+    ++num_comparisons_;
+    return value_ < x.value_;
+  }
+
+  bool operator>(const BaseCountedInstance& x) const {
+    ++num_comparisons_;
+    return value_ > x.value_;
+  }
+
+  bool operator<=(const BaseCountedInstance& x) const {
+    ++num_comparisons_;
+    return value_ <= x.value_;
+  }
+
+  bool operator>=(const BaseCountedInstance& x) const {
+    ++num_comparisons_;
+    return value_ >= x.value_;
+  }
+
+  absl::weak_ordering compare(const BaseCountedInstance& x) const {
+    ++num_comparisons_;
+    return value_ < x.value_
+               ? absl::weak_ordering::less
+               : value_ == x.value_ ? absl::weak_ordering::equivalent
+                                    : absl::weak_ordering::greater;
+  }
+
+  int value() const {
+    if (!is_live_) std::abort();
+    return value_;
+  }
+
+  friend std::ostream& operator<<(std::ostream& o,
+                                  const BaseCountedInstance& v) {
+    return o << "[value:" << v.value() << "]";
+  }
+
+  // Implementation of efficient swap() that counts swaps.
+  static void SwapImpl(
+      BaseCountedInstance& lhs,    // NOLINT(runtime/references)
+      BaseCountedInstance& rhs) {  // NOLINT(runtime/references)
+    using std::swap;
+    swap(lhs.value_, rhs.value_);
+    swap(lhs.is_live_, rhs.is_live_);
+    ++BaseCountedInstance::num_swaps_;
+  }
+
+ private:
+  friend class InstanceTracker;
+
+  int value_;
+
+  // Indicates if the value is live, ie it hasn't been moved away from.
+  bool is_live_ = true;
+
+  // Number of instances.
+  static int num_instances_;
+
+  // Number of live instances (those that have not been moved away from.)
+  static int num_live_instances_;
+
+  // Number of times that BaseCountedInstance objects were moved.
+  static int num_moves_;
+
+  // Number of times that BaseCountedInstance objects were copied.
+  static int num_copies_;
+
+  // Number of times that BaseCountedInstance objects were swapped.
+  static int num_swaps_;
+
+  // Number of times that BaseCountedInstance objects were compared.
+  static int num_comparisons_;
+};
+
+// Helper to track the BaseCountedInstance instance counters. Expects that the
+// number of instances and live_instances are the same when it is constructed
+// and when it is destructed.
+class InstanceTracker {
+ public:
+  InstanceTracker()
+      : start_instances_(BaseCountedInstance::num_instances_),
+        start_live_instances_(BaseCountedInstance::num_live_instances_) {
+    ResetCopiesMovesSwaps();
+  }
+  ~InstanceTracker() {
+    if (instances() != 0) std::abort();
+    if (live_instances() != 0) std::abort();
+  }
+
+  // Returns the number of BaseCountedInstance instances both containing valid
+  // values and those moved away from compared to when the InstanceTracker was
+  // constructed
+  int instances() const {
+    return BaseCountedInstance::num_instances_ - start_instances_;
+  }
+
+  // Returns the number of live BaseCountedInstance instances compared to when
+  // the InstanceTracker was constructed
+  int live_instances() const {
+    return BaseCountedInstance::num_live_instances_ - start_live_instances_;
+  }
+
+  // Returns the number of moves on BaseCountedInstance objects since
+  // construction or since the last call to ResetCopiesMovesSwaps().
+  int moves() const { return BaseCountedInstance::num_moves_ - start_moves_; }
+
+  // Returns the number of copies on BaseCountedInstance objects since
+  // construction or the last call to ResetCopiesMovesSwaps().
+  int copies() const {
+    return BaseCountedInstance::num_copies_ - start_copies_;
+  }
+
+  // Returns the number of swaps on BaseCountedInstance objects since
+  // construction or the last call to ResetCopiesMovesSwaps().
+  int swaps() const { return BaseCountedInstance::num_swaps_ - start_swaps_; }
+
+  // Returns the number of comparisons on BaseCountedInstance objects since
+  // construction or the last call to ResetCopiesMovesSwaps().
+  int comparisons() const {
+    return BaseCountedInstance::num_comparisons_ - start_comparisons_;
+  }
+
+  // Resets the base values for moves, copies, comparisons, and swaps to the
+  // current values, so that subsequent Get*() calls for moves, copies,
+  // comparisons, and swaps will compare to the situation at the point of this
+  // call.
+  void ResetCopiesMovesSwaps() {
+    start_moves_ = BaseCountedInstance::num_moves_;
+    start_copies_ = BaseCountedInstance::num_copies_;
+    start_swaps_ = BaseCountedInstance::num_swaps_;
+    start_comparisons_ = BaseCountedInstance::num_comparisons_;
+  }
+
+ private:
+  int start_instances_;
+  int start_live_instances_;
+  int start_moves_;
+  int start_copies_;
+  int start_swaps_;
+  int start_comparisons_;
+};
+
+// Copyable, not movable.
+class CopyableOnlyInstance : public BaseCountedInstance {
+ public:
+  explicit CopyableOnlyInstance(int x) : BaseCountedInstance(x) {}
+  CopyableOnlyInstance(const CopyableOnlyInstance& rhs) = default;
+  CopyableOnlyInstance& operator=(const CopyableOnlyInstance& rhs) = default;
+
+  friend void swap(CopyableOnlyInstance& lhs, CopyableOnlyInstance& rhs) {
+    BaseCountedInstance::SwapImpl(lhs, rhs);
+  }
+
+  static bool supports_move() { return false; }
+};
+
+// Copyable and movable.
+class CopyableMovableInstance : public BaseCountedInstance {
+ public:
+  explicit CopyableMovableInstance(int x) : BaseCountedInstance(x) {}
+  CopyableMovableInstance(const CopyableMovableInstance& rhs) = default;
+  CopyableMovableInstance(CopyableMovableInstance&& rhs) = default;
+  CopyableMovableInstance& operator=(const CopyableMovableInstance& rhs) =
+      default;
+  CopyableMovableInstance& operator=(CopyableMovableInstance&& rhs) = default;
+
+  friend void swap(CopyableMovableInstance& lhs, CopyableMovableInstance& rhs) {
+    BaseCountedInstance::SwapImpl(lhs, rhs);
+  }
+
+  static bool supports_move() { return true; }
+};
+
+// Only movable, not default-constructible.
+class MovableOnlyInstance : public BaseCountedInstance {
+ public:
+  explicit MovableOnlyInstance(int x) : BaseCountedInstance(x) {}
+  MovableOnlyInstance(MovableOnlyInstance&& other) = default;
+  MovableOnlyInstance& operator=(MovableOnlyInstance&& other) = default;
+
+  friend void swap(MovableOnlyInstance& lhs, MovableOnlyInstance& rhs) {
+    BaseCountedInstance::SwapImpl(lhs, rhs);
+  }
+
+  static bool supports_move() { return true; }
+};
+
+}  // namespace test_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/tracked.h b/CAPI/cpp/grpc/include/absl/container/internal/tracked.h
new file mode 100644
index 0000000..29f5829
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/tracked.h
@@ -0,0 +1,83 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_TRACKED_H_
+#define ABSL_CONTAINER_INTERNAL_TRACKED_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <utility>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// A class that tracks its copies and moves so that it can be queried in tests.
+template <class T>
+class Tracked {
+ public:
+  Tracked() {}
+  // NOLINTNEXTLINE(runtime/explicit)
+  Tracked(const T& val) : val_(val) {}
+  Tracked(const Tracked& that)
+      : val_(that.val_),
+        num_moves_(that.num_moves_),
+        num_copies_(that.num_copies_) {
+    ++(*num_copies_);
+  }
+  Tracked(Tracked&& that)
+      : val_(std::move(that.val_)),
+        num_moves_(std::move(that.num_moves_)),
+        num_copies_(std::move(that.num_copies_)) {
+    ++(*num_moves_);
+  }
+  Tracked& operator=(const Tracked& that) {
+    val_ = that.val_;
+    num_moves_ = that.num_moves_;
+    num_copies_ = that.num_copies_;
+    ++(*num_copies_);
+  }
+  Tracked& operator=(Tracked&& that) {
+    val_ = std::move(that.val_);
+    num_moves_ = std::move(that.num_moves_);
+    num_copies_ = std::move(that.num_copies_);
+    ++(*num_moves_);
+  }
+
+  const T& val() const { return val_; }
+
+  friend bool operator==(const Tracked& a, const Tracked& b) {
+    return a.val_ == b.val_;
+  }
+  friend bool operator!=(const Tracked& a, const Tracked& b) {
+    return !(a == b);
+  }
+
+  size_t num_copies() { return *num_copies_; }
+  size_t num_moves() { return *num_moves_; }
+
+ private:
+  T val_;
+  std::shared_ptr<size_t> num_moves_ = std::make_shared<size_t>(0);
+  std::shared_ptr<size_t> num_copies_ = std::make_shared<size_t>(0);
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_TRACKED_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_constructor_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_constructor_test.h
new file mode 100644
index 0000000..7e84dc2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_constructor_test.h
@@ -0,0 +1,494 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
+#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
+
+#include <algorithm>
+#include <unordered_map>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/container/internal/hash_generator_testing.h"
+#include "absl/container/internal/hash_policy_testing.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class UnordMap>
+class ConstructorTest : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(ConstructorTest);
+
+TYPED_TEST_P(ConstructorTest, NoArgs) {
+  TypeParam m;
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCount) {
+  TypeParam m(123);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountHash) {
+  using H = typename TypeParam::hasher;
+  H hasher;
+  TypeParam m(123, hasher);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountHashEqual) {
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  H hasher;
+  E equal;
+  TypeParam m(123, hasher, equal);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.key_eq(), equal);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountHashEqualAlloc) {
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  TypeParam m(123, hasher, equal, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.key_eq(), equal);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+template <typename T>
+struct is_std_unordered_map : std::false_type {};
+
+template <typename... T>
+struct is_std_unordered_map<std::unordered_map<T...>> : std::true_type {};
+
+#if defined(UNORDERED_MAP_CXX14) || defined(UNORDERED_MAP_CXX17)
+using has_cxx14_std_apis = std::true_type;
+#else
+using has_cxx14_std_apis = std::false_type;
+#endif
+
+template <typename T>
+using expect_cxx14_apis =
+    absl::disjunction<absl::negation<is_std_unordered_map<T>>,
+                      has_cxx14_std_apis>;
+
+template <typename TypeParam>
+void BucketCountAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void BucketCountAllocTest(std::true_type) {
+  using A = typename TypeParam::allocator_type;
+  A alloc(0);
+  TypeParam m(123, alloc);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountAlloc) {
+  BucketCountAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+template <typename TypeParam>
+void BucketCountHashAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void BucketCountHashAllocTest(std::true_type) {
+  using H = typename TypeParam::hasher;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  A alloc(0);
+  TypeParam m(123, hasher, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc) {
+  BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+#if ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
+using has_alloc_std_constructors = std::true_type;
+#else
+using has_alloc_std_constructors = std::false_type;
+#endif
+
+template <typename T>
+using expect_alloc_constructors =
+    absl::disjunction<absl::negation<is_std_unordered_map<T>>,
+                      has_alloc_std_constructors>;
+
+template <typename TypeParam>
+void AllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void AllocTest(std::true_type) {
+  using A = typename TypeParam::allocator_type;
+  A alloc(0);
+  TypeParam m(alloc);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+}
+
+TYPED_TEST_P(ConstructorTest, Alloc) {
+  AllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+}
+
+TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashEqualAlloc) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::UniqueGenerator<T>());
+  TypeParam m(values.begin(), values.end(), 123, hasher, equal, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.key_eq(), equal);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+template <typename TypeParam>
+void InputIteratorBucketAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void InputIteratorBucketAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using A = typename TypeParam::allocator_type;
+  A alloc(0);
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::UniqueGenerator<T>());
+  TypeParam m(values.begin(), values.end(), 123, alloc);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, InputIteratorBucketAlloc) {
+  InputIteratorBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+template <typename TypeParam>
+void InputIteratorBucketHashAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void InputIteratorBucketHashAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  A alloc(0);
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::UniqueGenerator<T>());
+  TypeParam m(values.begin(), values.end(), 123, hasher, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashAlloc) {
+  InputIteratorBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+TYPED_TEST_P(ConstructorTest, CopyConstructor) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  hash_internal::UniqueGenerator<T> gen;
+  TypeParam m(123, hasher, equal, alloc);
+  for (size_t i = 0; i != 10; ++i) m.insert(gen());
+  TypeParam n(m);
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_EQ(m.get_allocator(), n.get_allocator());
+  EXPECT_EQ(m, n);
+}
+
+template <typename TypeParam>
+void CopyConstructorAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void CopyConstructorAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  hash_internal::UniqueGenerator<T> gen;
+  TypeParam m(123, hasher, equal, alloc);
+  for (size_t i = 0; i != 10; ++i) m.insert(gen());
+  TypeParam n(m, A(11));
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_NE(m.get_allocator(), n.get_allocator());
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, CopyConstructorAlloc) {
+  CopyConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+}
+
+// TODO(alkis): Test non-propagating allocators on copy constructors.
+
+TYPED_TEST_P(ConstructorTest, MoveConstructor) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  hash_internal::UniqueGenerator<T> gen;
+  TypeParam m(123, hasher, equal, alloc);
+  for (size_t i = 0; i != 10; ++i) m.insert(gen());
+  TypeParam t(m);
+  TypeParam n(std::move(t));
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_EQ(m.get_allocator(), n.get_allocator());
+  EXPECT_EQ(m, n);
+}
+
+template <typename TypeParam>
+void MoveConstructorAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void MoveConstructorAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  hash_internal::UniqueGenerator<T> gen;
+  TypeParam m(123, hasher, equal, alloc);
+  for (size_t i = 0; i != 10; ++i) m.insert(gen());
+  TypeParam t(m);
+  TypeParam n(std::move(t), A(1));
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_NE(m.get_allocator(), n.get_allocator());
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, MoveConstructorAlloc) {
+  MoveConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+}
+
+// TODO(alkis): Test non-propagating allocators on move constructors.
+
+TYPED_TEST_P(ConstructorTest, InitializerListBucketHashEqualAlloc) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::UniqueGenerator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  TypeParam m(values, 123, hasher, equal, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.key_eq(), equal);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+template <typename TypeParam>
+void InitializerListBucketAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void InitializerListBucketAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using A = typename TypeParam::allocator_type;
+  hash_internal::UniqueGenerator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  A alloc(0);
+  TypeParam m(values, 123, alloc);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, InitializerListBucketAlloc) {
+  InitializerListBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+template <typename TypeParam>
+void InitializerListBucketHashAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void InitializerListBucketHashAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  A alloc(0);
+  hash_internal::UniqueGenerator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  TypeParam m(values, 123, hasher, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, InitializerListBucketHashAlloc) {
+  InitializerListBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+TYPED_TEST_P(ConstructorTest, Assignment) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  hash_internal::UniqueGenerator<T> gen;
+  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
+  TypeParam n;
+  n = m;
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_EQ(m, n);
+}
+
+// TODO(alkis): Test [non-]propagating allocators on move/copy assignments
+// (it depends on traits).
+
+TYPED_TEST_P(ConstructorTest, MoveAssignment) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  hash_internal::UniqueGenerator<T> gen;
+  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
+  TypeParam t(m);
+  TypeParam n;
+  n = std::move(t);
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::UniqueGenerator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  TypeParam m;
+  m = values;
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+}
+
+TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::UniqueGenerator<T> gen;
+  TypeParam m({gen(), gen(), gen()});
+  TypeParam n({gen()});
+  n = m;
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, MoveAssignmentOverwritesExisting) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::UniqueGenerator<T> gen;
+  TypeParam m({gen(), gen(), gen()});
+  TypeParam t(m);
+  TypeParam n({gen()});
+  n = std::move(t);
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerListOverwritesExisting) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::UniqueGenerator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  TypeParam m;
+  m = values;
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+}
+
+TYPED_TEST_P(ConstructorTest, AssignmentOnSelf) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::UniqueGenerator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  TypeParam m(values);
+  m = *&m;  // Avoid -Wself-assign
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+}
+
+// We cannot test self move as standard states that it leaves standard
+// containers in unspecified state (and in practice in causes memory-leak
+// according to heap-checker!).
+
+REGISTER_TYPED_TEST_SUITE_P(
+    ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
+    BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
+    InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,
+    InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc,
+    MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc,
+    InitializerListBucketAlloc, InitializerListBucketHashAlloc, Assignment,
+    MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting,
+    MoveAssignmentOverwritesExisting,
+    AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf);
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_lookup_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_lookup_test.h
new file mode 100644
index 0000000..3713cd9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_lookup_test.h
@@ -0,0 +1,117 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
+#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/container/internal/hash_generator_testing.h"
+#include "absl/container/internal/hash_policy_testing.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class UnordMap>
+class LookupTest : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(LookupTest);
+
+TYPED_TEST_P(LookupTest, At) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  for (const auto& p : values) {
+    const auto& val = m.at(p.first);
+    EXPECT_EQ(p.second, val) << ::testing::PrintToString(p.first);
+  }
+}
+
+TYPED_TEST_P(LookupTest, OperatorBracket) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  for (const auto& p : values) {
+    auto& val = m[p.first];
+    EXPECT_EQ(V(), val) << ::testing::PrintToString(p.first);
+    val = p.second;
+  }
+  for (const auto& p : values)
+    EXPECT_EQ(p.second, m[p.first]) << ::testing::PrintToString(p.first);
+}
+
+TYPED_TEST_P(LookupTest, Count) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  for (const auto& p : values)
+    EXPECT_EQ(0, m.count(p.first)) << ::testing::PrintToString(p.first);
+  m.insert(values.begin(), values.end());
+  for (const auto& p : values)
+    EXPECT_EQ(1, m.count(p.first)) << ::testing::PrintToString(p.first);
+}
+
+TYPED_TEST_P(LookupTest, Find) {
+  using std::get;
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  for (const auto& p : values)
+    EXPECT_TRUE(m.end() == m.find(p.first))
+        << ::testing::PrintToString(p.first);
+  m.insert(values.begin(), values.end());
+  for (const auto& p : values) {
+    auto it = m.find(p.first);
+    EXPECT_TRUE(m.end() != it) << ::testing::PrintToString(p.first);
+    EXPECT_EQ(p.second, get<1>(*it)) << ::testing::PrintToString(p.first);
+  }
+}
+
+TYPED_TEST_P(LookupTest, EqualRange) {
+  using std::get;
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  for (const auto& p : values) {
+    auto r = m.equal_range(p.first);
+    ASSERT_EQ(0, std::distance(r.first, r.second));
+  }
+  m.insert(values.begin(), values.end());
+  for (const auto& p : values) {
+    auto r = m.equal_range(p.first);
+    ASSERT_EQ(1, std::distance(r.first, r.second));
+    EXPECT_EQ(p.second, get<1>(*r.first)) << ::testing::PrintToString(p.first);
+  }
+}
+
+REGISTER_TYPED_TEST_SUITE_P(LookupTest, At, OperatorBracket, Count, Find,
+                            EqualRange);
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_members_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_members_test.h
new file mode 100644
index 0000000..7d48cdb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_members_test.h
@@ -0,0 +1,87 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
+#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
+
+#include <type_traits>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class UnordMap>
+class MembersTest : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(MembersTest);
+
+template <typename T>
+void UseType() {}
+
+TYPED_TEST_P(MembersTest, Typedefs) {
+  EXPECT_TRUE((std::is_same<std::pair<const typename TypeParam::key_type,
+                                      typename TypeParam::mapped_type>,
+                            typename TypeParam::value_type>()));
+  EXPECT_TRUE((absl::conjunction<
+               absl::negation<std::is_signed<typename TypeParam::size_type>>,
+               std::is_integral<typename TypeParam::size_type>>()));
+  EXPECT_TRUE((absl::conjunction<
+               std::is_signed<typename TypeParam::difference_type>,
+               std::is_integral<typename TypeParam::difference_type>>()));
+  EXPECT_TRUE((std::is_convertible<
+               decltype(std::declval<const typename TypeParam::hasher&>()(
+                   std::declval<const typename TypeParam::key_type&>())),
+               size_t>()));
+  EXPECT_TRUE((std::is_convertible<
+               decltype(std::declval<const typename TypeParam::key_equal&>()(
+                   std::declval<const typename TypeParam::key_type&>(),
+                   std::declval<const typename TypeParam::key_type&>())),
+               bool>()));
+  EXPECT_TRUE((std::is_same<typename TypeParam::allocator_type::value_type,
+                            typename TypeParam::value_type>()));
+  EXPECT_TRUE((std::is_same<typename TypeParam::value_type&,
+                            typename TypeParam::reference>()));
+  EXPECT_TRUE((std::is_same<const typename TypeParam::value_type&,
+                            typename TypeParam::const_reference>()));
+  EXPECT_TRUE((std::is_same<typename std::allocator_traits<
+                                typename TypeParam::allocator_type>::pointer,
+                            typename TypeParam::pointer>()));
+  EXPECT_TRUE(
+      (std::is_same<typename std::allocator_traits<
+                        typename TypeParam::allocator_type>::const_pointer,
+                    typename TypeParam::const_pointer>()));
+}
+
+TYPED_TEST_P(MembersTest, SimpleFunctions) {
+  EXPECT_GT(TypeParam().max_size(), 0);
+}
+
+TYPED_TEST_P(MembersTest, BeginEnd) {
+  TypeParam t = {typename TypeParam::value_type{}};
+  EXPECT_EQ(t.begin(), t.cbegin());
+  EXPECT_EQ(t.end(), t.cend());
+  EXPECT_NE(t.begin(), t.end());
+  EXPECT_NE(t.cbegin(), t.cend());
+}
+
+REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_modifiers_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_modifiers_test.h
new file mode 100644
index 0000000..4d9ab30
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_modifiers_test.h
@@ -0,0 +1,352 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
+#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
+
+#include <memory>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/container/internal/hash_generator_testing.h"
+#include "absl/container/internal/hash_policy_testing.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class UnordMap>
+class ModifiersTest : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(ModifiersTest);
+
+TYPED_TEST_P(ModifiersTest, Clear) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  m.clear();
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAre());
+  EXPECT_TRUE(m.empty());
+}
+
+TYPED_TEST_P(ModifiersTest, Insert) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  auto p = m.insert(val);
+  EXPECT_TRUE(p.second);
+  EXPECT_EQ(val, *p.first);
+  T val2 = {val.first, hash_internal::Generator<V>()()};
+  p = m.insert(val2);
+  EXPECT_FALSE(p.second);
+  EXPECT_EQ(val, *p.first);
+}
+
+TYPED_TEST_P(ModifiersTest, InsertHint) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  auto it = m.insert(m.end(), val);
+  EXPECT_TRUE(it != m.end());
+  EXPECT_EQ(val, *it);
+  T val2 = {val.first, hash_internal::Generator<V>()()};
+  it = m.insert(it, val2);
+  EXPECT_TRUE(it != m.end());
+  EXPECT_EQ(val, *it);
+}
+
+TYPED_TEST_P(ModifiersTest, InsertRange) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  m.insert(values.begin(), values.end());
+  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+}
+
+TYPED_TEST_P(ModifiersTest, InsertWithinCapacity) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  m.reserve(10);
+  const size_t original_capacity = m.bucket_count();
+  m.insert(val);
+  EXPECT_EQ(m.bucket_count(), original_capacity);
+  T val2 = {val.first, hash_internal::Generator<V>()()};
+  m.insert(val2);
+  EXPECT_EQ(m.bucket_count(), original_capacity);
+}
+
+TYPED_TEST_P(ModifiersTest, InsertRangeWithinCapacity) {
+#if !defined(__GLIBCXX__)
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> base_values;
+  std::generate_n(std::back_inserter(base_values), 10,
+                  hash_internal::Generator<T>());
+  std::vector<T> values;
+  while (values.size() != 100) {
+    std::copy_n(base_values.begin(), 10, std::back_inserter(values));
+  }
+  TypeParam m;
+  m.reserve(10);
+  const size_t original_capacity = m.bucket_count();
+  m.insert(values.begin(), values.end());
+  EXPECT_EQ(m.bucket_count(), original_capacity);
+#endif
+}
+
+TYPED_TEST_P(ModifiersTest, InsertOrAssign) {
+#ifdef UNORDERED_MAP_CXX17
+  using std::get;
+  using K = typename TypeParam::key_type;
+  using V = typename TypeParam::mapped_type;
+  K k = hash_internal::Generator<K>()();
+  V val = hash_internal::Generator<V>()();
+  TypeParam m;
+  auto p = m.insert_or_assign(k, val);
+  EXPECT_TRUE(p.second);
+  EXPECT_EQ(k, get<0>(*p.first));
+  EXPECT_EQ(val, get<1>(*p.first));
+  V val2 = hash_internal::Generator<V>()();
+  p = m.insert_or_assign(k, val2);
+  EXPECT_FALSE(p.second);
+  EXPECT_EQ(k, get<0>(*p.first));
+  EXPECT_EQ(val2, get<1>(*p.first));
+#endif
+}
+
+TYPED_TEST_P(ModifiersTest, InsertOrAssignHint) {
+#ifdef UNORDERED_MAP_CXX17
+  using std::get;
+  using K = typename TypeParam::key_type;
+  using V = typename TypeParam::mapped_type;
+  K k = hash_internal::Generator<K>()();
+  V val = hash_internal::Generator<V>()();
+  TypeParam m;
+  auto it = m.insert_or_assign(m.end(), k, val);
+  EXPECT_TRUE(it != m.end());
+  EXPECT_EQ(k, get<0>(*it));
+  EXPECT_EQ(val, get<1>(*it));
+  V val2 = hash_internal::Generator<V>()();
+  it = m.insert_or_assign(it, k, val2);
+  EXPECT_EQ(k, get<0>(*it));
+  EXPECT_EQ(val2, get<1>(*it));
+#endif
+}
+
+TYPED_TEST_P(ModifiersTest, Emplace) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+  // with test traits/policy.
+  auto p = m.emplace(val);
+  EXPECT_TRUE(p.second);
+  EXPECT_EQ(val, *p.first);
+  T val2 = {val.first, hash_internal::Generator<V>()()};
+  p = m.emplace(val2);
+  EXPECT_FALSE(p.second);
+  EXPECT_EQ(val, *p.first);
+}
+
+TYPED_TEST_P(ModifiersTest, EmplaceHint) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+  // with test traits/policy.
+  auto it = m.emplace_hint(m.end(), val);
+  EXPECT_EQ(val, *it);
+  T val2 = {val.first, hash_internal::Generator<V>()()};
+  it = m.emplace_hint(it, val2);
+  EXPECT_EQ(val, *it);
+}
+
+TYPED_TEST_P(ModifiersTest, TryEmplace) {
+#ifdef UNORDERED_MAP_CXX17
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+  // with test traits/policy.
+  auto p = m.try_emplace(val.first, val.second);
+  EXPECT_TRUE(p.second);
+  EXPECT_EQ(val, *p.first);
+  T val2 = {val.first, hash_internal::Generator<V>()()};
+  p = m.try_emplace(val2.first, val2.second);
+  EXPECT_FALSE(p.second);
+  EXPECT_EQ(val, *p.first);
+#endif
+}
+
+TYPED_TEST_P(ModifiersTest, TryEmplaceHint) {
+#ifdef UNORDERED_MAP_CXX17
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+  // with test traits/policy.
+  auto it = m.try_emplace(m.end(), val.first, val.second);
+  EXPECT_EQ(val, *it);
+  T val2 = {val.first, hash_internal::Generator<V>()()};
+  it = m.try_emplace(it, val2.first, val2.second);
+  EXPECT_EQ(val, *it);
+#endif
+}
+
+template <class V>
+using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
+
+// In openmap we chose not to return the iterator from erase because that's
+// more expensive. As such we adapt erase to return an iterator here.
+struct EraseFirst {
+  template <class Map>
+  auto operator()(Map* m, int) const
+      -> IfNotVoid<decltype(m->erase(m->begin()))> {
+    return m->erase(m->begin());
+  }
+  template <class Map>
+  typename Map::iterator operator()(Map* m, ...) const {
+    auto it = m->begin();
+    m->erase(it++);
+    return it;
+  }
+};
+
+TYPED_TEST_P(ModifiersTest, Erase) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using std::get;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  auto& first = *m.begin();
+  std::vector<T> values2;
+  for (const auto& val : values)
+    if (get<0>(val) != get<0>(first)) values2.push_back(val);
+  auto it = EraseFirst()(&m, 0);
+  ASSERT_TRUE(it != m.end());
+  EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values2.begin(),
+                                                             values2.end()));
+}
+
+TYPED_TEST_P(ModifiersTest, EraseRange) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  auto it = m.erase(m.begin(), m.end());
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAre());
+  EXPECT_TRUE(it == m.end());
+}
+
+TYPED_TEST_P(ModifiersTest, EraseKey) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_EQ(1, m.erase(values[0].first));
+  EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
+  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values.begin() + 1,
+                                                             values.end()));
+}
+
+TYPED_TEST_P(ModifiersTest, Swap) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> v1;
+  std::vector<T> v2;
+  std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
+  std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
+  TypeParam m1(v1.begin(), v1.end());
+  TypeParam m2(v2.begin(), v2.end());
+  EXPECT_THAT(items(m1), ::testing::UnorderedElementsAreArray(v1));
+  EXPECT_THAT(items(m2), ::testing::UnorderedElementsAreArray(v2));
+  m1.swap(m2);
+  EXPECT_THAT(items(m1), ::testing::UnorderedElementsAreArray(v2));
+  EXPECT_THAT(items(m2), ::testing::UnorderedElementsAreArray(v1));
+}
+
+// TODO(alkis): Write tests for extract.
+// TODO(alkis): Write tests for merge.
+
+REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint,
+                            InsertRange, InsertWithinCapacity,
+                            InsertRangeWithinCapacity, InsertOrAssign,
+                            InsertOrAssignHint, Emplace, EmplaceHint,
+                            TryEmplace, TryEmplaceHint, Erase, EraseRange,
+                            EraseKey, Swap);
+
+template <typename Type>
+struct is_unique_ptr : std::false_type {};
+
+template <typename Type>
+struct is_unique_ptr<std::unique_ptr<Type>> : std::true_type {};
+
+template <class UnordMap>
+class UniquePtrModifiersTest : public ::testing::Test {
+ protected:
+  UniquePtrModifiersTest() {
+    static_assert(is_unique_ptr<typename UnordMap::mapped_type>::value,
+                  "UniquePtrModifiersTyest may only be called with a "
+                  "std::unique_ptr value type.");
+  }
+};
+
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UniquePtrModifiersTest);
+
+TYPED_TEST_SUITE_P(UniquePtrModifiersTest);
+
+// Test that we do not move from rvalue arguments if an insertion does not
+// happen.
+TYPED_TEST_P(UniquePtrModifiersTest, TryEmplace) {
+#ifdef UNORDERED_MAP_CXX17
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using V = typename TypeParam::mapped_type;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  auto p = m.try_emplace(val.first, std::move(val.second));
+  EXPECT_TRUE(p.second);
+  // A moved from std::unique_ptr is guaranteed to be nullptr.
+  EXPECT_EQ(val.second, nullptr);
+  T val2 = {val.first, hash_internal::Generator<V>()()};
+  p = m.try_emplace(val2.first, std::move(val2.second));
+  EXPECT_FALSE(p.second);
+  EXPECT_NE(val2.second, nullptr);
+#endif
+}
+
+REGISTER_TYPED_TEST_SUITE_P(UniquePtrModifiersTest, TryEmplace);
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_constructor_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_constructor_test.h
new file mode 100644
index 0000000..af1116e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_constructor_test.h
@@ -0,0 +1,496 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
+#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
+
+#include <algorithm>
+#include <unordered_set>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/container/internal/hash_generator_testing.h"
+#include "absl/container/internal/hash_policy_testing.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class UnordMap>
+class ConstructorTest : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(ConstructorTest);
+
+TYPED_TEST_P(ConstructorTest, NoArgs) {
+  TypeParam m;
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCount) {
+  TypeParam m(123);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountHash) {
+  using H = typename TypeParam::hasher;
+  H hasher;
+  TypeParam m(123, hasher);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountHashEqual) {
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  H hasher;
+  E equal;
+  TypeParam m(123, hasher, equal);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.key_eq(), equal);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountHashEqualAlloc) {
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  TypeParam m(123, hasher, equal, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.key_eq(), equal);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+
+  const auto& cm = m;
+  EXPECT_EQ(cm.hash_function(), hasher);
+  EXPECT_EQ(cm.key_eq(), equal);
+  EXPECT_EQ(cm.get_allocator(), alloc);
+  EXPECT_TRUE(cm.empty());
+  EXPECT_THAT(keys(cm), ::testing::UnorderedElementsAre());
+  EXPECT_GE(cm.bucket_count(), 123);
+}
+
+template <typename T>
+struct is_std_unordered_set : std::false_type {};
+
+template <typename... T>
+struct is_std_unordered_set<std::unordered_set<T...>> : std::true_type {};
+
+#if defined(UNORDERED_SET_CXX14) || defined(UNORDERED_SET_CXX17)
+using has_cxx14_std_apis = std::true_type;
+#else
+using has_cxx14_std_apis = std::false_type;
+#endif
+
+template <typename T>
+using expect_cxx14_apis =
+    absl::disjunction<absl::negation<is_std_unordered_set<T>>,
+                      has_cxx14_std_apis>;
+
+template <typename TypeParam>
+void BucketCountAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void BucketCountAllocTest(std::true_type) {
+  using A = typename TypeParam::allocator_type;
+  A alloc(0);
+  TypeParam m(123, alloc);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountAlloc) {
+  BucketCountAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+template <typename TypeParam>
+void BucketCountHashAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void BucketCountHashAllocTest(std::true_type) {
+  using H = typename TypeParam::hasher;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  A alloc(0);
+  TypeParam m(123, hasher, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc) {
+  BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+#if ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
+using has_alloc_std_constructors = std::true_type;
+#else
+using has_alloc_std_constructors = std::false_type;
+#endif
+
+template <typename T>
+using expect_alloc_constructors =
+    absl::disjunction<absl::negation<is_std_unordered_set<T>>,
+                      has_alloc_std_constructors>;
+
+template <typename TypeParam>
+void AllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void AllocTest(std::true_type) {
+  using A = typename TypeParam::allocator_type;
+  A alloc(0);
+  TypeParam m(alloc);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_TRUE(m.empty());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+}
+
+TYPED_TEST_P(ConstructorTest, Alloc) {
+  AllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+}
+
+TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashEqualAlloc) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  std::vector<T> values;
+  for (size_t i = 0; i != 10; ++i)
+    values.push_back(hash_internal::Generator<T>()());
+  TypeParam m(values.begin(), values.end(), 123, hasher, equal, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.key_eq(), equal);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+template <typename TypeParam>
+void InputIteratorBucketAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void InputIteratorBucketAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using A = typename TypeParam::allocator_type;
+  A alloc(0);
+  std::vector<T> values;
+  for (size_t i = 0; i != 10; ++i)
+    values.push_back(hash_internal::Generator<T>()());
+  TypeParam m(values.begin(), values.end(), 123, alloc);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, InputIteratorBucketAlloc) {
+  InputIteratorBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+template <typename TypeParam>
+void InputIteratorBucketHashAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void InputIteratorBucketHashAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  A alloc(0);
+  std::vector<T> values;
+  for (size_t i = 0; i != 10; ++i)
+    values.push_back(hash_internal::Generator<T>()());
+  TypeParam m(values.begin(), values.end(), 123, hasher, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashAlloc) {
+  InputIteratorBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+TYPED_TEST_P(ConstructorTest, CopyConstructor) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  TypeParam m(123, hasher, equal, alloc);
+  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
+  TypeParam n(m);
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_EQ(m.get_allocator(), n.get_allocator());
+  EXPECT_EQ(m, n);
+  EXPECT_NE(TypeParam(0, hasher, equal, alloc), n);
+}
+
+template <typename TypeParam>
+void CopyConstructorAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void CopyConstructorAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  TypeParam m(123, hasher, equal, alloc);
+  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
+  TypeParam n(m, A(11));
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_NE(m.get_allocator(), n.get_allocator());
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, CopyConstructorAlloc) {
+  CopyConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+}
+
+// TODO(alkis): Test non-propagating allocators on copy constructors.
+
+TYPED_TEST_P(ConstructorTest, MoveConstructor) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  TypeParam m(123, hasher, equal, alloc);
+  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
+  TypeParam t(m);
+  TypeParam n(std::move(t));
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_EQ(m.get_allocator(), n.get_allocator());
+  EXPECT_EQ(m, n);
+}
+
+template <typename TypeParam>
+void MoveConstructorAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void MoveConstructorAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  TypeParam m(123, hasher, equal, alloc);
+  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
+  TypeParam t(m);
+  TypeParam n(std::move(t), A(1));
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_NE(m.get_allocator(), n.get_allocator());
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, MoveConstructorAlloc) {
+  MoveConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+}
+
+// TODO(alkis): Test non-propagating allocators on move constructors.
+
+TYPED_TEST_P(ConstructorTest, InitializerListBucketHashEqualAlloc) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::Generator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  TypeParam m(values, 123, hasher, equal, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.key_eq(), equal);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+template <typename TypeParam>
+void InitializerListBucketAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void InitializerListBucketAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using A = typename TypeParam::allocator_type;
+  hash_internal::Generator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  A alloc(0);
+  TypeParam m(values, 123, alloc);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, InitializerListBucketAlloc) {
+  InitializerListBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+template <typename TypeParam>
+void InitializerListBucketHashAllocTest(std::false_type) {}
+
+template <typename TypeParam>
+void InitializerListBucketHashAllocTest(std::true_type) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  A alloc(0);
+  hash_internal::Generator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  TypeParam m(values, 123, hasher, alloc);
+  EXPECT_EQ(m.hash_function(), hasher);
+  EXPECT_EQ(m.get_allocator(), alloc);
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_GE(m.bucket_count(), 123);
+}
+
+TYPED_TEST_P(ConstructorTest, InitializerListBucketHashAlloc) {
+  InitializerListBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+}
+
+TYPED_TEST_P(ConstructorTest, CopyAssignment) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  hash_internal::Generator<T> gen;
+  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
+  TypeParam n;
+  n = m;
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_EQ(m, n);
+}
+
+// TODO(alkis): Test [non-]propagating allocators on move/copy assignments
+// (it depends on traits).
+
+TYPED_TEST_P(ConstructorTest, MoveAssignment) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  using H = typename TypeParam::hasher;
+  using E = typename TypeParam::key_equal;
+  using A = typename TypeParam::allocator_type;
+  H hasher;
+  E equal;
+  A alloc(0);
+  hash_internal::Generator<T> gen;
+  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
+  TypeParam t(m);
+  TypeParam n;
+  n = std::move(t);
+  EXPECT_EQ(m.hash_function(), n.hash_function());
+  EXPECT_EQ(m.key_eq(), n.key_eq());
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::Generator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  TypeParam m;
+  m = values;
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+}
+
+TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::Generator<T> gen;
+  TypeParam m({gen(), gen(), gen()});
+  TypeParam n({gen()});
+  n = m;
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, MoveAssignmentOverwritesExisting) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::Generator<T> gen;
+  TypeParam m({gen(), gen(), gen()});
+  TypeParam t(m);
+  TypeParam n({gen()});
+  n = std::move(t);
+  EXPECT_EQ(m, n);
+}
+
+TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerListOverwritesExisting) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::Generator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  TypeParam m;
+  m = values;
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+}
+
+TYPED_TEST_P(ConstructorTest, AssignmentOnSelf) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  hash_internal::Generator<T> gen;
+  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+  TypeParam m(values);
+  m = *&m;  // Avoid -Wself-assign.
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+}
+
+REGISTER_TYPED_TEST_SUITE_P(
+    ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
+    BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
+    InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,
+    InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc,
+    MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc,
+    InitializerListBucketAlloc, InitializerListBucketHashAlloc, CopyAssignment,
+    MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting,
+    MoveAssignmentOverwritesExisting,
+    AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf);
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_lookup_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_lookup_test.h
new file mode 100644
index 0000000..b35f766
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_lookup_test.h
@@ -0,0 +1,91 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
+#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/container/internal/hash_generator_testing.h"
+#include "absl/container/internal/hash_policy_testing.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class UnordSet>
+class LookupTest : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(LookupTest);
+
+TYPED_TEST_P(LookupTest, Count) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  for (const auto& v : values)
+    EXPECT_EQ(0, m.count(v)) << ::testing::PrintToString(v);
+  m.insert(values.begin(), values.end());
+  for (const auto& v : values)
+    EXPECT_EQ(1, m.count(v)) << ::testing::PrintToString(v);
+}
+
+TYPED_TEST_P(LookupTest, Find) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  for (const auto& v : values)
+    EXPECT_TRUE(m.end() == m.find(v)) << ::testing::PrintToString(v);
+  m.insert(values.begin(), values.end());
+  for (const auto& v : values) {
+    typename TypeParam::iterator it = m.find(v);
+    static_assert(std::is_same<const typename TypeParam::value_type&,
+                               decltype(*it)>::value,
+                  "");
+    static_assert(std::is_same<const typename TypeParam::value_type*,
+                               decltype(it.operator->())>::value,
+                  "");
+    EXPECT_TRUE(m.end() != it) << ::testing::PrintToString(v);
+    EXPECT_EQ(v, *it) << ::testing::PrintToString(v);
+  }
+}
+
+TYPED_TEST_P(LookupTest, EqualRange) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  for (const auto& v : values) {
+    auto r = m.equal_range(v);
+    ASSERT_EQ(0, std::distance(r.first, r.second));
+  }
+  m.insert(values.begin(), values.end());
+  for (const auto& v : values) {
+    auto r = m.equal_range(v);
+    ASSERT_EQ(1, std::distance(r.first, r.second));
+    EXPECT_EQ(v, *r.first);
+  }
+}
+
+REGISTER_TYPED_TEST_SUITE_P(LookupTest, Count, Find, EqualRange);
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_members_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_members_test.h
new file mode 100644
index 0000000..4c5e104
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_members_test.h
@@ -0,0 +1,86 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
+#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
+
+#include <type_traits>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class UnordSet>
+class MembersTest : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(MembersTest);
+
+template <typename T>
+void UseType() {}
+
+TYPED_TEST_P(MembersTest, Typedefs) {
+  EXPECT_TRUE((std::is_same<typename TypeParam::key_type,
+                            typename TypeParam::value_type>()));
+  EXPECT_TRUE((absl::conjunction<
+               absl::negation<std::is_signed<typename TypeParam::size_type>>,
+               std::is_integral<typename TypeParam::size_type>>()));
+  EXPECT_TRUE((absl::conjunction<
+               std::is_signed<typename TypeParam::difference_type>,
+               std::is_integral<typename TypeParam::difference_type>>()));
+  EXPECT_TRUE((std::is_convertible<
+               decltype(std::declval<const typename TypeParam::hasher&>()(
+                   std::declval<const typename TypeParam::key_type&>())),
+               size_t>()));
+  EXPECT_TRUE((std::is_convertible<
+               decltype(std::declval<const typename TypeParam::key_equal&>()(
+                   std::declval<const typename TypeParam::key_type&>(),
+                   std::declval<const typename TypeParam::key_type&>())),
+               bool>()));
+  EXPECT_TRUE((std::is_same<typename TypeParam::allocator_type::value_type,
+                            typename TypeParam::value_type>()));
+  EXPECT_TRUE((std::is_same<typename TypeParam::value_type&,
+                            typename TypeParam::reference>()));
+  EXPECT_TRUE((std::is_same<const typename TypeParam::value_type&,
+                            typename TypeParam::const_reference>()));
+  EXPECT_TRUE((std::is_same<typename std::allocator_traits<
+                                typename TypeParam::allocator_type>::pointer,
+                            typename TypeParam::pointer>()));
+  EXPECT_TRUE(
+      (std::is_same<typename std::allocator_traits<
+                        typename TypeParam::allocator_type>::const_pointer,
+                    typename TypeParam::const_pointer>()));
+}
+
+TYPED_TEST_P(MembersTest, SimpleFunctions) {
+  EXPECT_GT(TypeParam().max_size(), 0);
+}
+
+TYPED_TEST_P(MembersTest, BeginEnd) {
+  TypeParam t = {typename TypeParam::value_type{}};
+  EXPECT_EQ(t.begin(), t.cbegin());
+  EXPECT_EQ(t.end(), t.cend());
+  EXPECT_NE(t.begin(), t.end());
+  EXPECT_NE(t.cbegin(), t.cend());
+}
+
+REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_modifiers_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_modifiers_test.h
new file mode 100644
index 0000000..d8864bb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_modifiers_test.h
@@ -0,0 +1,221 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
+#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/container/internal/hash_generator_testing.h"
+#include "absl/container/internal/hash_policy_testing.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+template <class UnordSet>
+class ModifiersTest : public ::testing::Test {};
+
+TYPED_TEST_SUITE_P(ModifiersTest);
+
+TYPED_TEST_P(ModifiersTest, Clear) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  m.clear();
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+  EXPECT_TRUE(m.empty());
+}
+
+TYPED_TEST_P(ModifiersTest, Insert) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  auto p = m.insert(val);
+  EXPECT_TRUE(p.second);
+  EXPECT_EQ(val, *p.first);
+  p = m.insert(val);
+  EXPECT_FALSE(p.second);
+}
+
+TYPED_TEST_P(ModifiersTest, InsertHint) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  auto it = m.insert(m.end(), val);
+  EXPECT_TRUE(it != m.end());
+  EXPECT_EQ(val, *it);
+  it = m.insert(it, val);
+  EXPECT_TRUE(it != m.end());
+  EXPECT_EQ(val, *it);
+}
+
+TYPED_TEST_P(ModifiersTest, InsertRange) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m;
+  m.insert(values.begin(), values.end());
+  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+}
+
+TYPED_TEST_P(ModifiersTest, InsertWithinCapacity) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  m.reserve(10);
+  const size_t original_capacity = m.bucket_count();
+  m.insert(val);
+  EXPECT_EQ(m.bucket_count(), original_capacity);
+  m.insert(val);
+  EXPECT_EQ(m.bucket_count(), original_capacity);
+}
+
+TYPED_TEST_P(ModifiersTest, InsertRangeWithinCapacity) {
+#if !defined(__GLIBCXX__)
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> base_values;
+  std::generate_n(std::back_inserter(base_values), 10,
+                  hash_internal::Generator<T>());
+  std::vector<T> values;
+  while (values.size() != 100) {
+    values.insert(values.end(), base_values.begin(), base_values.end());
+  }
+  TypeParam m;
+  m.reserve(10);
+  const size_t original_capacity = m.bucket_count();
+  m.insert(values.begin(), values.end());
+  EXPECT_EQ(m.bucket_count(), original_capacity);
+#endif
+}
+
+TYPED_TEST_P(ModifiersTest, Emplace) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+  // with test traits/policy.
+  auto p = m.emplace(val);
+  EXPECT_TRUE(p.second);
+  EXPECT_EQ(val, *p.first);
+  p = m.emplace(val);
+  EXPECT_FALSE(p.second);
+  EXPECT_EQ(val, *p.first);
+}
+
+TYPED_TEST_P(ModifiersTest, EmplaceHint) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  T val = hash_internal::Generator<T>()();
+  TypeParam m;
+  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+  // with test traits/policy.
+  auto it = m.emplace_hint(m.end(), val);
+  EXPECT_EQ(val, *it);
+  it = m.emplace_hint(it, val);
+  EXPECT_EQ(val, *it);
+}
+
+template <class V>
+using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
+
+// In openmap we chose not to return the iterator from erase because that's
+// more expensive. As such we adapt erase to return an iterator here.
+struct EraseFirst {
+  template <class Map>
+  auto operator()(Map* m, int) const
+      -> IfNotVoid<decltype(m->erase(m->begin()))> {
+    return m->erase(m->begin());
+  }
+  template <class Map>
+  typename Map::iterator operator()(Map* m, ...) const {
+    auto it = m->begin();
+    m->erase(it++);
+    return it;
+  }
+};
+
+TYPED_TEST_P(ModifiersTest, Erase) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  std::vector<T> values2;
+  for (const auto& val : values)
+    if (val != *m.begin()) values2.push_back(val);
+  auto it = EraseFirst()(&m, 0);
+  ASSERT_TRUE(it != m.end());
+  EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values2.begin(),
+                                                            values2.end()));
+}
+
+TYPED_TEST_P(ModifiersTest, EraseRange) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  auto it = m.erase(m.begin(), m.end());
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+  EXPECT_TRUE(it == m.end());
+}
+
+TYPED_TEST_P(ModifiersTest, EraseKey) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> values;
+  std::generate_n(std::back_inserter(values), 10,
+                  hash_internal::Generator<T>());
+  TypeParam m(values.begin(), values.end());
+  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+  EXPECT_EQ(1, m.erase(values[0]));
+  EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
+  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values.begin() + 1,
+                                                            values.end()));
+}
+
+TYPED_TEST_P(ModifiersTest, Swap) {
+  using T = hash_internal::GeneratedType<TypeParam>;
+  std::vector<T> v1;
+  std::vector<T> v2;
+  std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
+  std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
+  TypeParam m1(v1.begin(), v1.end());
+  TypeParam m2(v2.begin(), v2.end());
+  EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v1));
+  EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v2));
+  m1.swap(m2);
+  EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v2));
+  EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v1));
+}
+
+// TODO(alkis): Write tests for extract.
+// TODO(alkis): Write tests for merge.
+
+REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint,
+                            InsertRange, InsertWithinCapacity,
+                            InsertRangeWithinCapacity, Emplace, EmplaceHint,
+                            Erase, EraseRange, EraseKey, Swap);
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/node_hash_map.h b/CAPI/cpp/grpc/include/absl/container/node_hash_map.h
new file mode 100644
index 0000000..6868e63
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/node_hash_map.h
@@ -0,0 +1,604 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: node_hash_map.h
+// -----------------------------------------------------------------------------
+//
+// An `absl::node_hash_map<K, V>` is an unordered associative container of
+// unique keys and associated values designed to be a more efficient replacement
+// for `std::unordered_map`. Like `unordered_map`, search, insertion, and
+// deletion of map elements can be done as an `O(1)` operation. However,
+// `node_hash_map` (and other unordered associative containers known as the
+// collection of Abseil "Swiss tables") contain other optimizations that result
+// in both memory and computation advantages.
+//
+// In most cases, your default choice for a hash map should be a map of type
+// `flat_hash_map`. However, if you need pointer stability and cannot store
+// a `flat_hash_map` with `unique_ptr` elements, a `node_hash_map` may be a
+// valid alternative. As well, if you are migrating your code from using
+// `std::unordered_map`, a `node_hash_map` provides a more straightforward
+// migration, because it guarantees pointer stability. Consider migrating to
+// `node_hash_map` and perhaps converting to a more efficient `flat_hash_map`
+// upon further review.
+
+#ifndef ABSL_CONTAINER_NODE_HASH_MAP_H_
+#define ABSL_CONTAINER_NODE_HASH_MAP_H_
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/algorithm/container.h"
+#include "absl/base/macros.h"
+#include "absl/container/internal/container_memory.h"
+#include "absl/container/internal/hash_function_defaults.h"  // IWYU pragma: export
+#include "absl/container/internal/node_slot_policy.h"
+#include "absl/container/internal/raw_hash_map.h"  // IWYU pragma: export
+#include "absl/memory/memory.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+template <class Key, class Value>
+class NodeHashMapPolicy;
+}  // namespace container_internal
+
+// -----------------------------------------------------------------------------
+// absl::node_hash_map
+// -----------------------------------------------------------------------------
+//
+// An `absl::node_hash_map<K, V>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_map<K, V>` with
+// the following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the map is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash map.
+// * Returns `void` from the `erase(iterator)` overload.
+//
+// By default, `node_hash_map` uses the `absl::Hash` hashing framework.
+// All fundamental and Abseil types that support the `absl::Hash` framework have
+// a compatible equality operator for comparing insertions into `node_hash_map`.
+// If your type is not yet supported by the `absl::Hash` framework, see
+// absl/hash/hash.h for information on extending Abseil hashing to user-defined
+// types.
+//
+// Using `absl::node_hash_map` at interface boundaries in dynamically loaded
+// libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
+// be randomized across dynamically loaded libraries.
+//
+// Example:
+//
+//   // Create a node hash map of three strings (that map to strings)
+//   absl::node_hash_map<std::string, std::string> ducks =
+//     {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}};
+//
+//  // Insert a new element into the node hash map
+//  ducks.insert({"d", "donald"}};
+//
+//  // Force a rehash of the node hash map
+//  ducks.rehash(0);
+//
+//  // Find the element with the key "b"
+//  std::string search_key = "b";
+//  auto result = ducks.find(search_key);
+//  if (result != ducks.end()) {
+//    std::cout << "Result: " << result->second << std::endl;
+//  }
+template <class Key, class Value,
+          class Hash = absl::container_internal::hash_default_hash<Key>,
+          class Eq = absl::container_internal::hash_default_eq<Key>,
+          class Alloc = std::allocator<std::pair<const Key, Value>>>
+class node_hash_map
+    : public absl::container_internal::raw_hash_map<
+          absl::container_internal::NodeHashMapPolicy<Key, Value>, Hash, Eq,
+          Alloc> {
+  using Base = typename node_hash_map::raw_hash_map;
+
+ public:
+  // Constructors and Assignment Operators
+  //
+  // A node_hash_map supports the same overload set as `std::unordered_map`
+  // for construction and assignment:
+  //
+  // *  Default constructor
+  //
+  //    // No allocation for the table's elements is made.
+  //    absl::node_hash_map<int, std::string> map1;
+  //
+  // * Initializer List constructor
+  //
+  //   absl::node_hash_map<int, std::string> map2 =
+  //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
+  //
+  // * Copy constructor
+  //
+  //   absl::node_hash_map<int, std::string> map3(map2);
+  //
+  // * Copy assignment operator
+  //
+  //  // Hash functor and Comparator are copied as well
+  //  absl::node_hash_map<int, std::string> map4;
+  //  map4 = map3;
+  //
+  // * Move constructor
+  //
+  //   // Move is guaranteed efficient
+  //   absl::node_hash_map<int, std::string> map5(std::move(map4));
+  //
+  // * Move assignment operator
+  //
+  //   // May be efficient if allocators are compatible
+  //   absl::node_hash_map<int, std::string> map6;
+  //   map6 = std::move(map5);
+  //
+  // * Range constructor
+  //
+  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+  //   absl::node_hash_map<int, std::string> map7(v.begin(), v.end());
+  node_hash_map() {}
+  using Base::Base;
+
+  // node_hash_map::begin()
+  //
+  // Returns an iterator to the beginning of the `node_hash_map`.
+  using Base::begin;
+
+  // node_hash_map::cbegin()
+  //
+  // Returns a const iterator to the beginning of the `node_hash_map`.
+  using Base::cbegin;
+
+  // node_hash_map::cend()
+  //
+  // Returns a const iterator to the end of the `node_hash_map`.
+  using Base::cend;
+
+  // node_hash_map::end()
+  //
+  // Returns an iterator to the end of the `node_hash_map`.
+  using Base::end;
+
+  // node_hash_map::capacity()
+  //
+  // Returns the number of element slots (assigned, deleted, and empty)
+  // available within the `node_hash_map`.
+  //
+  // NOTE: this member function is particular to `absl::node_hash_map` and is
+  // not provided in the `std::unordered_map` API.
+  using Base::capacity;
+
+  // node_hash_map::empty()
+  //
+  // Returns whether or not the `node_hash_map` is empty.
+  using Base::empty;
+
+  // node_hash_map::max_size()
+  //
+  // Returns the largest theoretical possible number of elements within a
+  // `node_hash_map` under current memory constraints. This value can be thought
+  // of as the largest value of `std::distance(begin(), end())` for a
+  // `node_hash_map<K, V>`.
+  using Base::max_size;
+
+  // node_hash_map::size()
+  //
+  // Returns the number of elements currently within the `node_hash_map`.
+  using Base::size;
+
+  // node_hash_map::clear()
+  //
+  // Removes all elements from the `node_hash_map`. Invalidates any references,
+  // pointers, or iterators referring to contained elements.
+  //
+  // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
+  // the underlying buffer call `erase(begin(), end())`.
+  using Base::clear;
+
+  // node_hash_map::erase()
+  //
+  // Erases elements within the `node_hash_map`. Erasing does not trigger a
+  // rehash. Overloads are listed below.
+  //
+  // void erase(const_iterator pos):
+  //
+  //   Erases the element at `position` of the `node_hash_map`, returning
+  //   `void`.
+  //
+  //   NOTE: this return behavior is different than that of STL containers in
+  //   general and `std::unordered_map` in particular.
+  //
+  // iterator erase(const_iterator first, const_iterator last):
+  //
+  //   Erases the elements in the open interval [`first`, `last`), returning an
+  //   iterator pointing to `last`.
+  //
+  // size_type erase(const key_type& key):
+  //
+  //   Erases the element with the matching key, if it exists, returning the
+  //   number of elements erased (0 or 1).
+  using Base::erase;
+
+  // node_hash_map::insert()
+  //
+  // Inserts an element of the specified value into the `node_hash_map`,
+  // returning an iterator pointing to the newly inserted element, provided that
+  // an element with the given key does not already exist. If rehashing occurs
+  // due to the insertion, all iterators are invalidated. Overloads are listed
+  // below.
+  //
+  // std::pair<iterator,bool> insert(const init_type& value):
+  //
+  //   Inserts a value into the `node_hash_map`. Returns a pair consisting of an
+  //   iterator to the inserted element (or to the element that prevented the
+  //   insertion) and a `bool` denoting whether the insertion took place.
+  //
+  // std::pair<iterator,bool> insert(T&& value):
+  // std::pair<iterator,bool> insert(init_type&& value):
+  //
+  //   Inserts a moveable value into the `node_hash_map`. Returns a `std::pair`
+  //   consisting of an iterator to the inserted element (or to the element that
+  //   prevented the insertion) and a `bool` denoting whether the insertion took
+  //   place.
+  //
+  // iterator insert(const_iterator hint, const init_type& value):
+  // iterator insert(const_iterator hint, T&& value):
+  // iterator insert(const_iterator hint, init_type&& value);
+  //
+  //   Inserts a value, using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search. Returns an iterator to the
+  //   inserted element, or to the existing element that prevented the
+  //   insertion.
+  //
+  // void insert(InputIterator first, InputIterator last):
+  //
+  //   Inserts a range of values [`first`, `last`).
+  //
+  //   NOTE: Although the STL does not specify which element may be inserted if
+  //   multiple keys compare equivalently, for `node_hash_map` we guarantee the
+  //   first match is inserted.
+  //
+  // void insert(std::initializer_list<init_type> ilist):
+  //
+  //   Inserts the elements within the initializer list `ilist`.
+  //
+  //   NOTE: Although the STL does not specify which element may be inserted if
+  //   multiple keys compare equivalently within the initializer list, for
+  //   `node_hash_map` we guarantee the first match is inserted.
+  using Base::insert;
+
+  // node_hash_map::insert_or_assign()
+  //
+  // Inserts an element of the specified value into the `node_hash_map` provided
+  // that a value with the given key does not already exist, or replaces it with
+  // the element value if a key for that value already exists, returning an
+  // iterator pointing to the newly inserted element. If rehashing occurs due to
+  // the insertion, all iterators are invalidated. Overloads are listed
+  // below.
+  //
+  // std::pair<iterator, bool> insert_or_assign(const init_type& k, T&& obj):
+  // std::pair<iterator, bool> insert_or_assign(init_type&& k, T&& obj):
+  //
+  //   Inserts/Assigns (or moves) the element of the specified key into the
+  //   `node_hash_map`.
+  //
+  // iterator insert_or_assign(const_iterator hint,
+  //                           const init_type& k, T&& obj):
+  // iterator insert_or_assign(const_iterator hint, init_type&& k, T&& obj):
+  //
+  //   Inserts/Assigns (or moves) the element of the specified key into the
+  //   `node_hash_map` using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search.
+  using Base::insert_or_assign;
+
+  // node_hash_map::emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `node_hash_map`, provided that no element with the given key
+  // already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately. Prefer `try_emplace()` unless your key is not
+  // copyable or moveable.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  using Base::emplace;
+
+  // node_hash_map::emplace_hint()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `node_hash_map`, using the position of `hint` as a non-binding
+  // suggestion for where to begin the insertion search, and only inserts
+  // provided that no element with the given key already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately. Prefer `try_emplace()` unless your key is not
+  // copyable or moveable.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  using Base::emplace_hint;
+
+  // node_hash_map::try_emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `node_hash_map`, provided that no element with the given key
+  // already exists. Unlike `emplace()`, if an element with the given key
+  // already exists, we guarantee that no element is constructed.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  // Overloads are listed below.
+  //
+  //   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
+  //   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
+  //
+  // Inserts (via copy or move) the element of the specified key into the
+  // `node_hash_map`.
+  //
+  //   iterator try_emplace(const_iterator hint,
+  //                        const key_type& k, Args&&... args):
+  //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
+  //
+  // Inserts (via copy or move) the element of the specified key into the
+  // `node_hash_map` using the position of `hint` as a non-binding suggestion
+  // for where to begin the insertion search.
+  //
+  // All `try_emplace()` overloads make the same guarantees regarding rvalue
+  // arguments as `std::unordered_map::try_emplace()`, namely that these
+  // functions will not move from rvalue arguments if insertions do not happen.
+  using Base::try_emplace;
+
+  // node_hash_map::extract()
+  //
+  // Extracts the indicated element, erasing it in the process, and returns it
+  // as a C++17-compatible node handle. Overloads are listed below.
+  //
+  // node_type extract(const_iterator position):
+  //
+  //   Extracts the key,value pair of the element at the indicated position and
+  //   returns a node handle owning that extracted data.
+  //
+  // node_type extract(const key_type& x):
+  //
+  //   Extracts the key,value pair of the element with a key matching the passed
+  //   key value and returns a node handle owning that extracted data. If the
+  //   `node_hash_map` does not contain an element with a matching key, this
+  //   function returns an empty node handle.
+  //
+  // NOTE: when compiled in an earlier version of C++ than C++17,
+  // `node_type::key()` returns a const reference to the key instead of a
+  // mutable reference. We cannot safely return a mutable reference without
+  // std::launder (which is not available before C++17).
+  using Base::extract;
+
+  // node_hash_map::merge()
+  //
+  // Extracts elements from a given `source` node hash map into this
+  // `node_hash_map`. If the destination `node_hash_map` already contains an
+  // element with an equivalent key, that element is not extracted.
+  using Base::merge;
+
+  // node_hash_map::swap(node_hash_map& other)
+  //
+  // Exchanges the contents of this `node_hash_map` with those of the `other`
+  // node hash map, avoiding invocation of any move, copy, or swap operations on
+  // individual elements.
+  //
+  // All iterators and references on the `node_hash_map` remain valid, excepting
+  // for the past-the-end iterator, which is invalidated.
+  //
+  // `swap()` requires that the node hash map's hashing and key equivalence
+  // functions be Swappable, and are exchaged using unqualified calls to
+  // non-member `swap()`. If the map's allocator has
+  // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
+  // set to `true`, the allocators are also exchanged using an unqualified call
+  // to non-member `swap()`; otherwise, the allocators are not swapped.
+  using Base::swap;
+
+  // node_hash_map::rehash(count)
+  //
+  // Rehashes the `node_hash_map`, setting the number of slots to be at least
+  // the passed value. If the new number of slots increases the load factor more
+  // than the current maximum load factor
+  // (`count` < `size()` / `max_load_factor()`), then the new number of slots
+  // will be at least `size()` / `max_load_factor()`.
+  //
+  // To force a rehash, pass rehash(0).
+  using Base::rehash;
+
+  // node_hash_map::reserve(count)
+  //
+  // Sets the number of slots in the `node_hash_map` to the number needed to
+  // accommodate at least `count` total elements without exceeding the current
+  // maximum load factor, and may rehash the container if needed.
+  using Base::reserve;
+
+  // node_hash_map::at()
+  //
+  // Returns a reference to the mapped value of the element with key equivalent
+  // to the passed key.
+  using Base::at;
+
+  // node_hash_map::contains()
+  //
+  // Determines whether an element with a key comparing equal to the given `key`
+  // exists within the `node_hash_map`, returning `true` if so or `false`
+  // otherwise.
+  using Base::contains;
+
+  // node_hash_map::count(const Key& key) const
+  //
+  // Returns the number of elements with a key comparing equal to the given
+  // `key` within the `node_hash_map`. note that this function will return
+  // either `1` or `0` since duplicate keys are not allowed within a
+  // `node_hash_map`.
+  using Base::count;
+
+  // node_hash_map::equal_range()
+  //
+  // Returns a closed range [first, last], defined by a `std::pair` of two
+  // iterators, containing all elements with the passed key in the
+  // `node_hash_map`.
+  using Base::equal_range;
+
+  // node_hash_map::find()
+  //
+  // Finds an element with the passed `key` within the `node_hash_map`.
+  using Base::find;
+
+  // node_hash_map::operator[]()
+  //
+  // Returns a reference to the value mapped to the passed key within the
+  // `node_hash_map`, performing an `insert()` if the key does not already
+  // exist. If an insertion occurs and results in a rehashing of the container,
+  // all iterators are invalidated. Otherwise iterators are not affected and
+  // references are not invalidated. Overloads are listed below.
+  //
+  // T& operator[](const Key& key):
+  //
+  //   Inserts an init_type object constructed in-place if the element with the
+  //   given key does not exist.
+  //
+  // T& operator[](Key&& key):
+  //
+  //   Inserts an init_type object constructed in-place provided that an element
+  //   with the given key does not exist.
+  using Base::operator[];
+
+  // node_hash_map::bucket_count()
+  //
+  // Returns the number of "buckets" within the `node_hash_map`.
+  using Base::bucket_count;
+
+  // node_hash_map::load_factor()
+  //
+  // Returns the current load factor of the `node_hash_map` (the average number
+  // of slots occupied with a value within the hash map).
+  using Base::load_factor;
+
+  // node_hash_map::max_load_factor()
+  //
+  // Manages the maximum load factor of the `node_hash_map`. Overloads are
+  // listed below.
+  //
+  // float node_hash_map::max_load_factor()
+  //
+  //   Returns the current maximum load factor of the `node_hash_map`.
+  //
+  // void node_hash_map::max_load_factor(float ml)
+  //
+  //   Sets the maximum load factor of the `node_hash_map` to the passed value.
+  //
+  //   NOTE: This overload is provided only for API compatibility with the STL;
+  //   `node_hash_map` will ignore any set load factor and manage its rehashing
+  //   internally as an implementation detail.
+  using Base::max_load_factor;
+
+  // node_hash_map::get_allocator()
+  //
+  // Returns the allocator function associated with this `node_hash_map`.
+  using Base::get_allocator;
+
+  // node_hash_map::hash_function()
+  //
+  // Returns the hashing function used to hash the keys within this
+  // `node_hash_map`.
+  using Base::hash_function;
+
+  // node_hash_map::key_eq()
+  //
+  // Returns the function used for comparing keys equality.
+  using Base::key_eq;
+};
+
+// erase_if(node_hash_map<>, Pred)
+//
+// Erases all elements that satisfy the predicate `pred` from the container `c`.
+// Returns the number of erased elements.
+template <typename K, typename V, typename H, typename E, typename A,
+          typename Predicate>
+typename node_hash_map<K, V, H, E, A>::size_type erase_if(
+    node_hash_map<K, V, H, E, A>& c, Predicate pred) {
+  return container_internal::EraseIf(pred, &c);
+}
+
+namespace container_internal {
+
+template <class Key, class Value>
+class NodeHashMapPolicy
+    : public absl::container_internal::node_slot_policy<
+          std::pair<const Key, Value>&, NodeHashMapPolicy<Key, Value>> {
+  using value_type = std::pair<const Key, Value>;
+
+ public:
+  using key_type = Key;
+  using mapped_type = Value;
+  using init_type = std::pair</*non const*/ key_type, mapped_type>;
+
+  template <class Allocator, class... Args>
+  static value_type* new_element(Allocator* alloc, Args&&... args) {
+    using PairAlloc = typename absl::allocator_traits<
+        Allocator>::template rebind_alloc<value_type>;
+    PairAlloc pair_alloc(*alloc);
+    value_type* res =
+        absl::allocator_traits<PairAlloc>::allocate(pair_alloc, 1);
+    absl::allocator_traits<PairAlloc>::construct(pair_alloc, res,
+                                                 std::forward<Args>(args)...);
+    return res;
+  }
+
+  template <class Allocator>
+  static void delete_element(Allocator* alloc, value_type* pair) {
+    using PairAlloc = typename absl::allocator_traits<
+        Allocator>::template rebind_alloc<value_type>;
+    PairAlloc pair_alloc(*alloc);
+    absl::allocator_traits<PairAlloc>::destroy(pair_alloc, pair);
+    absl::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1);
+  }
+
+  template <class F, class... Args>
+  static decltype(absl::container_internal::DecomposePair(
+      std::declval<F>(), std::declval<Args>()...))
+  apply(F&& f, Args&&... args) {
+    return absl::container_internal::DecomposePair(std::forward<F>(f),
+                                                   std::forward<Args>(args)...);
+  }
+
+  static size_t element_space_used(const value_type*) {
+    return sizeof(value_type);
+  }
+
+  static Value& value(value_type* elem) { return elem->second; }
+  static const Value& value(const value_type* elem) { return elem->second; }
+};
+}  // namespace container_internal
+
+namespace container_algorithm_internal {
+
+// Specialization of trait in absl/algorithm/container.h
+template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+struct IsUnorderedContainer<
+    absl::node_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {};
+
+}  // namespace container_algorithm_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_NODE_HASH_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/node_hash_set.h b/CAPI/cpp/grpc/include/absl/container/node_hash_set.h
new file mode 100644
index 0000000..f2cc70c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/container/node_hash_set.h
@@ -0,0 +1,500 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: node_hash_set.h
+// -----------------------------------------------------------------------------
+//
+// An `absl::node_hash_set<T>` is an unordered associative container designed to
+// be a more efficient replacement for `std::unordered_set`. Like
+// `unordered_set`, search, insertion, and deletion of set elements can be done
+// as an `O(1)` operation. However, `node_hash_set` (and other unordered
+// associative containers known as the collection of Abseil "Swiss tables")
+// contain other optimizations that result in both memory and computation
+// advantages.
+//
+// In most cases, your default choice for a hash table should be a map of type
+// `flat_hash_map` or a set of type `flat_hash_set`. However, if you need
+// pointer stability, a `node_hash_set` should be your preferred choice. As
+// well, if you are migrating your code from using `std::unordered_set`, a
+// `node_hash_set` should be an easy migration. Consider migrating to
+// `node_hash_set` and perhaps converting to a more efficient `flat_hash_set`
+// upon further review.
+
+#ifndef ABSL_CONTAINER_NODE_HASH_SET_H_
+#define ABSL_CONTAINER_NODE_HASH_SET_H_
+
+#include <type_traits>
+
+#include "absl/algorithm/container.h"
+#include "absl/base/macros.h"
+#include "absl/container/internal/hash_function_defaults.h"  // IWYU pragma: export
+#include "absl/container/internal/node_slot_policy.h"
+#include "absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
+#include "absl/memory/memory.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+template <typename T>
+struct NodeHashSetPolicy;
+}  // namespace container_internal
+
+// -----------------------------------------------------------------------------
+// absl::node_hash_set
+// -----------------------------------------------------------------------------
+//
+// An `absl::node_hash_set<T>` is an unordered associative container which
+// has been optimized for both speed and memory footprint in most common use
+// cases. Its interface is similar to that of `std::unordered_set<T>` with the
+// following notable differences:
+//
+// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+//   `insert()`, provided that the set is provided a compatible heterogeneous
+//   hashing function and equality operator.
+// * Contains a `capacity()` member function indicating the number of element
+//   slots (open, deleted, and empty) within the hash set.
+// * Returns `void` from the `erase(iterator)` overload.
+//
+// By default, `node_hash_set` uses the `absl::Hash` hashing framework.
+// All fundamental and Abseil types that support the `absl::Hash` framework have
+// a compatible equality operator for comparing insertions into `node_hash_set`.
+// If your type is not yet supported by the `absl::Hash` framework, see
+// absl/hash/hash.h for information on extending Abseil hashing to user-defined
+// types.
+//
+// Using `absl::node_hash_set` at interface boundaries in dynamically loaded
+// libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
+// be randomized across dynamically loaded libraries.
+//
+// Example:
+//
+//   // Create a node hash set of three strings
+//   absl::node_hash_set<std::string> ducks =
+//     {"huey", "dewey", "louie"};
+//
+//  // Insert a new element into the node hash set
+//  ducks.insert("donald");
+//
+//  // Force a rehash of the node hash set
+//  ducks.rehash(0);
+//
+//  // See if "dewey" is present
+//  if (ducks.contains("dewey")) {
+//    std::cout << "We found dewey!" << std::endl;
+//  }
+template <class T, class Hash = absl::container_internal::hash_default_hash<T>,
+          class Eq = absl::container_internal::hash_default_eq<T>,
+          class Alloc = std::allocator<T>>
+class node_hash_set
+    : public absl::container_internal::raw_hash_set<
+          absl::container_internal::NodeHashSetPolicy<T>, Hash, Eq, Alloc> {
+  using Base = typename node_hash_set::raw_hash_set;
+
+ public:
+  // Constructors and Assignment Operators
+  //
+  // A node_hash_set supports the same overload set as `std::unordered_set`
+  // for construction and assignment:
+  //
+  // *  Default constructor
+  //
+  //    // No allocation for the table's elements is made.
+  //    absl::node_hash_set<std::string> set1;
+  //
+  // * Initializer List constructor
+  //
+  //   absl::node_hash_set<std::string> set2 =
+  //       {{"huey"}, {"dewey"}, {"louie"}};
+  //
+  // * Copy constructor
+  //
+  //   absl::node_hash_set<std::string> set3(set2);
+  //
+  // * Copy assignment operator
+  //
+  //  // Hash functor and Comparator are copied as well
+  //  absl::node_hash_set<std::string> set4;
+  //  set4 = set3;
+  //
+  // * Move constructor
+  //
+  //   // Move is guaranteed efficient
+  //   absl::node_hash_set<std::string> set5(std::move(set4));
+  //
+  // * Move assignment operator
+  //
+  //   // May be efficient if allocators are compatible
+  //   absl::node_hash_set<std::string> set6;
+  //   set6 = std::move(set5);
+  //
+  // * Range constructor
+  //
+  //   std::vector<std::string> v = {"a", "b"};
+  //   absl::node_hash_set<std::string> set7(v.begin(), v.end());
+  node_hash_set() {}
+  using Base::Base;
+
+  // node_hash_set::begin()
+  //
+  // Returns an iterator to the beginning of the `node_hash_set`.
+  using Base::begin;
+
+  // node_hash_set::cbegin()
+  //
+  // Returns a const iterator to the beginning of the `node_hash_set`.
+  using Base::cbegin;
+
+  // node_hash_set::cend()
+  //
+  // Returns a const iterator to the end of the `node_hash_set`.
+  using Base::cend;
+
+  // node_hash_set::end()
+  //
+  // Returns an iterator to the end of the `node_hash_set`.
+  using Base::end;
+
+  // node_hash_set::capacity()
+  //
+  // Returns the number of element slots (assigned, deleted, and empty)
+  // available within the `node_hash_set`.
+  //
+  // NOTE: this member function is particular to `absl::node_hash_set` and is
+  // not provided in the `std::unordered_set` API.
+  using Base::capacity;
+
+  // node_hash_set::empty()
+  //
+  // Returns whether or not the `node_hash_set` is empty.
+  using Base::empty;
+
+  // node_hash_set::max_size()
+  //
+  // Returns the largest theoretical possible number of elements within a
+  // `node_hash_set` under current memory constraints. This value can be thought
+  // of the largest value of `std::distance(begin(), end())` for a
+  // `node_hash_set<T>`.
+  using Base::max_size;
+
+  // node_hash_set::size()
+  //
+  // Returns the number of elements currently within the `node_hash_set`.
+  using Base::size;
+
+  // node_hash_set::clear()
+  //
+  // Removes all elements from the `node_hash_set`. Invalidates any references,
+  // pointers, or iterators referring to contained elements.
+  //
+  // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
+  // the underlying buffer call `erase(begin(), end())`.
+  using Base::clear;
+
+  // node_hash_set::erase()
+  //
+  // Erases elements within the `node_hash_set`. Erasing does not trigger a
+  // rehash. Overloads are listed below.
+  //
+  // void erase(const_iterator pos):
+  //
+  //   Erases the element at `position` of the `node_hash_set`, returning
+  //   `void`.
+  //
+  //   NOTE: this return behavior is different than that of STL containers in
+  //   general and `std::unordered_set` in particular.
+  //
+  // iterator erase(const_iterator first, const_iterator last):
+  //
+  //   Erases the elements in the open interval [`first`, `last`), returning an
+  //   iterator pointing to `last`.
+  //
+  // size_type erase(const key_type& key):
+  //
+  //   Erases the element with the matching key, if it exists, returning the
+  //   number of elements erased (0 or 1).
+  using Base::erase;
+
+  // node_hash_set::insert()
+  //
+  // Inserts an element of the specified value into the `node_hash_set`,
+  // returning an iterator pointing to the newly inserted element, provided that
+  // an element with the given key does not already exist. If rehashing occurs
+  // due to the insertion, all iterators are invalidated. Overloads are listed
+  // below.
+  //
+  // std::pair<iterator,bool> insert(const T& value):
+  //
+  //   Inserts a value into the `node_hash_set`. Returns a pair consisting of an
+  //   iterator to the inserted element (or to the element that prevented the
+  //   insertion) and a bool denoting whether the insertion took place.
+  //
+  // std::pair<iterator,bool> insert(T&& value):
+  //
+  //   Inserts a moveable value into the `node_hash_set`. Returns a pair
+  //   consisting of an iterator to the inserted element (or to the element that
+  //   prevented the insertion) and a bool denoting whether the insertion took
+  //   place.
+  //
+  // iterator insert(const_iterator hint, const T& value):
+  // iterator insert(const_iterator hint, T&& value):
+  //
+  //   Inserts a value, using the position of `hint` as a non-binding suggestion
+  //   for where to begin the insertion search. Returns an iterator to the
+  //   inserted element, or to the existing element that prevented the
+  //   insertion.
+  //
+  // void insert(InputIterator first, InputIterator last):
+  //
+  //   Inserts a range of values [`first`, `last`).
+  //
+  //   NOTE: Although the STL does not specify which element may be inserted if
+  //   multiple keys compare equivalently, for `node_hash_set` we guarantee the
+  //   first match is inserted.
+  //
+  // void insert(std::initializer_list<T> ilist):
+  //
+  //   Inserts the elements within the initializer list `ilist`.
+  //
+  //   NOTE: Although the STL does not specify which element may be inserted if
+  //   multiple keys compare equivalently within the initializer list, for
+  //   `node_hash_set` we guarantee the first match is inserted.
+  using Base::insert;
+
+  // node_hash_set::emplace()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `node_hash_set`, provided that no element with the given key
+  // already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  using Base::emplace;
+
+  // node_hash_set::emplace_hint()
+  //
+  // Inserts an element of the specified value by constructing it in-place
+  // within the `node_hash_set`, using the position of `hint` as a non-binding
+  // suggestion for where to begin the insertion search, and only inserts
+  // provided that no element with the given key already exists.
+  //
+  // The element may be constructed even if there already is an element with the
+  // key in the container, in which case the newly constructed element will be
+  // destroyed immediately.
+  //
+  // If rehashing occurs due to the insertion, all iterators are invalidated.
+  using Base::emplace_hint;
+
+  // node_hash_set::extract()
+  //
+  // Extracts the indicated element, erasing it in the process, and returns it
+  // as a C++17-compatible node handle. Overloads are listed below.
+  //
+  // node_type extract(const_iterator position):
+  //
+  //   Extracts the element at the indicated position and returns a node handle
+  //   owning that extracted data.
+  //
+  // node_type extract(const key_type& x):
+  //
+  //   Extracts the element with the key matching the passed key value and
+  //   returns a node handle owning that extracted data. If the `node_hash_set`
+  //   does not contain an element with a matching key, this function returns an
+  // empty node handle.
+  using Base::extract;
+
+  // node_hash_set::merge()
+  //
+  // Extracts elements from a given `source` node hash set into this
+  // `node_hash_set`. If the destination `node_hash_set` already contains an
+  // element with an equivalent key, that element is not extracted.
+  using Base::merge;
+
+  // node_hash_set::swap(node_hash_set& other)
+  //
+  // Exchanges the contents of this `node_hash_set` with those of the `other`
+  // node hash set, avoiding invocation of any move, copy, or swap operations on
+  // individual elements.
+  //
+  // All iterators and references on the `node_hash_set` remain valid, excepting
+  // for the past-the-end iterator, which is invalidated.
+  //
+  // `swap()` requires that the node hash set's hashing and key equivalence
+  // functions be Swappable, and are exchaged using unqualified calls to
+  // non-member `swap()`. If the set's allocator has
+  // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
+  // set to `true`, the allocators are also exchanged using an unqualified call
+  // to non-member `swap()`; otherwise, the allocators are not swapped.
+  using Base::swap;
+
+  // node_hash_set::rehash(count)
+  //
+  // Rehashes the `node_hash_set`, setting the number of slots to be at least
+  // the passed value. If the new number of slots increases the load factor more
+  // than the current maximum load factor
+  // (`count` < `size()` / `max_load_factor()`), then the new number of slots
+  // will be at least `size()` / `max_load_factor()`.
+  //
+  // To force a rehash, pass rehash(0).
+  //
+  // NOTE: unlike behavior in `std::unordered_set`, references are also
+  // invalidated upon a `rehash()`.
+  using Base::rehash;
+
+  // node_hash_set::reserve(count)
+  //
+  // Sets the number of slots in the `node_hash_set` to the number needed to
+  // accommodate at least `count` total elements without exceeding the current
+  // maximum load factor, and may rehash the container if needed.
+  using Base::reserve;
+
+  // node_hash_set::contains()
+  //
+  // Determines whether an element comparing equal to the given `key` exists
+  // within the `node_hash_set`, returning `true` if so or `false` otherwise.
+  using Base::contains;
+
+  // node_hash_set::count(const Key& key) const
+  //
+  // Returns the number of elements comparing equal to the given `key` within
+  // the `node_hash_set`. note that this function will return either `1` or `0`
+  // since duplicate elements are not allowed within a `node_hash_set`.
+  using Base::count;
+
+  // node_hash_set::equal_range()
+  //
+  // Returns a closed range [first, last], defined by a `std::pair` of two
+  // iterators, containing all elements with the passed key in the
+  // `node_hash_set`.
+  using Base::equal_range;
+
+  // node_hash_set::find()
+  //
+  // Finds an element with the passed `key` within the `node_hash_set`.
+  using Base::find;
+
+  // node_hash_set::bucket_count()
+  //
+  // Returns the number of "buckets" within the `node_hash_set`. Note that
+  // because a node hash set contains all elements within its internal storage,
+  // this value simply equals the current capacity of the `node_hash_set`.
+  using Base::bucket_count;
+
+  // node_hash_set::load_factor()
+  //
+  // Returns the current load factor of the `node_hash_set` (the average number
+  // of slots occupied with a value within the hash set).
+  using Base::load_factor;
+
+  // node_hash_set::max_load_factor()
+  //
+  // Manages the maximum load factor of the `node_hash_set`. Overloads are
+  // listed below.
+  //
+  // float node_hash_set::max_load_factor()
+  //
+  //   Returns the current maximum load factor of the `node_hash_set`.
+  //
+  // void node_hash_set::max_load_factor(float ml)
+  //
+  //   Sets the maximum load factor of the `node_hash_set` to the passed value.
+  //
+  //   NOTE: This overload is provided only for API compatibility with the STL;
+  //   `node_hash_set` will ignore any set load factor and manage its rehashing
+  //   internally as an implementation detail.
+  using Base::max_load_factor;
+
+  // node_hash_set::get_allocator()
+  //
+  // Returns the allocator function associated with this `node_hash_set`.
+  using Base::get_allocator;
+
+  // node_hash_set::hash_function()
+  //
+  // Returns the hashing function used to hash the keys within this
+  // `node_hash_set`.
+  using Base::hash_function;
+
+  // node_hash_set::key_eq()
+  //
+  // Returns the function used for comparing keys equality.
+  using Base::key_eq;
+};
+
+// erase_if(node_hash_set<>, Pred)
+//
+// Erases all elements that satisfy the predicate `pred` from the container `c`.
+// Returns the number of erased elements.
+template <typename T, typename H, typename E, typename A, typename Predicate>
+typename node_hash_set<T, H, E, A>::size_type erase_if(
+    node_hash_set<T, H, E, A>& c, Predicate pred) {
+  return container_internal::EraseIf(pred, &c);
+}
+
+namespace container_internal {
+
+template <class T>
+struct NodeHashSetPolicy
+    : absl::container_internal::node_slot_policy<T&, NodeHashSetPolicy<T>> {
+  using key_type = T;
+  using init_type = T;
+  using constant_iterators = std::true_type;
+
+  template <class Allocator, class... Args>
+  static T* new_element(Allocator* alloc, Args&&... args) {
+    using ValueAlloc =
+        typename absl::allocator_traits<Allocator>::template rebind_alloc<T>;
+    ValueAlloc value_alloc(*alloc);
+    T* res = absl::allocator_traits<ValueAlloc>::allocate(value_alloc, 1);
+    absl::allocator_traits<ValueAlloc>::construct(value_alloc, res,
+                                                  std::forward<Args>(args)...);
+    return res;
+  }
+
+  template <class Allocator>
+  static void delete_element(Allocator* alloc, T* elem) {
+    using ValueAlloc =
+        typename absl::allocator_traits<Allocator>::template rebind_alloc<T>;
+    ValueAlloc value_alloc(*alloc);
+    absl::allocator_traits<ValueAlloc>::destroy(value_alloc, elem);
+    absl::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1);
+  }
+
+  template <class F, class... Args>
+  static decltype(absl::container_internal::DecomposeValue(
+      std::declval<F>(), std::declval<Args>()...))
+  apply(F&& f, Args&&... args) {
+    return absl::container_internal::DecomposeValue(
+        std::forward<F>(f), std::forward<Args>(args)...);
+  }
+
+  static size_t element_space_used(const T*) { return sizeof(T); }
+};
+}  // namespace container_internal
+
+namespace container_algorithm_internal {
+
+// Specialization of trait in absl/algorithm/container.h
+template <class Key, class Hash, class KeyEqual, class Allocator>
+struct IsUnorderedContainer<absl::node_hash_set<Key, Hash, KeyEqual, Allocator>>
+    : std::true_type {};
+
+}  // namespace container_algorithm_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_NODE_HASH_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/failure_signal_handler.h b/CAPI/cpp/grpc/include/absl/debugging/failure_signal_handler.h
new file mode 100644
index 0000000..500115c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/failure_signal_handler.h
@@ -0,0 +1,121 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: failure_signal_handler.h
+// -----------------------------------------------------------------------------
+//
+// This file configures the Abseil *failure signal handler* to capture and dump
+// useful debugging information (such as a stacktrace) upon program failure.
+//
+// To use the failure signal handler, call `absl::InstallFailureSignalHandler()`
+// very early in your program, usually in the first few lines of main():
+//
+// int main(int argc, char** argv) {
+//   // Initialize the symbolizer to get a human-readable stack trace
+//   absl::InitializeSymbolizer(argv[0]);
+//
+//   absl::FailureSignalHandlerOptions options;
+//   absl::InstallFailureSignalHandler(options);
+//   DoSomethingInteresting();
+//   return 0;
+// }
+//
+// Any program that raises a fatal signal (such as `SIGSEGV`, `SIGILL`,
+// `SIGFPE`, `SIGABRT`, `SIGTERM`, `SIGBUG`, and `SIGTRAP`) will call the
+// installed failure signal handler and provide debugging information to stderr.
+//
+// Note that you should *not* install the Abseil failure signal handler more
+// than once. You may, of course, have another (non-Abseil) failure signal
+// handler installed (which would be triggered if Abseil's failure signal
+// handler sets `call_previous_handler` to `true`).
+
+#ifndef ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
+#define ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// FailureSignalHandlerOptions
+//
+// Struct for holding `absl::InstallFailureSignalHandler()` configuration
+// options.
+struct FailureSignalHandlerOptions {
+  // If true, try to symbolize the stacktrace emitted on failure, provided that
+  // you have initialized a symbolizer for that purpose. (See symbolize.h for
+  // more information.)
+  bool symbolize_stacktrace = true;
+
+  // If true, try to run signal handlers on an alternate stack (if supported on
+  // the given platform). An alternate stack is useful for program crashes due
+  // to a stack overflow; by running on a alternate stack, the signal handler
+  // may run even when normal stack space has been exausted. The downside of
+  // using an alternate stack is that extra memory for the alternate stack needs
+  // to be pre-allocated.
+  bool use_alternate_stack = true;
+
+  // If positive, indicates the number of seconds after which the failure signal
+  // handler is invoked to abort the program. Setting such an alarm is useful in
+  // cases where the failure signal handler itself may become hung or
+  // deadlocked.
+  int alarm_on_failure_secs = 3;
+
+  // If true, call the previously registered signal handler for the signal that
+  // was received (if one was registered) after the existing signal handler
+  // runs. This mechanism can be used to chain signal handlers together.
+  //
+  // If false, the signal is raised to the default handler for that signal
+  // (which normally terminates the program).
+  //
+  // IMPORTANT: If true, the chained fatal signal handlers must not try to
+  // recover from the fatal signal. Instead, they should terminate the program
+  // via some mechanism, like raising the default handler for the signal, or by
+  // calling `_exit()`. Note that the failure signal handler may put parts of
+  // the Abseil library into a state from which they cannot recover.
+  bool call_previous_handler = false;
+
+  // If non-null, indicates a pointer to a callback function that will be called
+  // upon failure, with a string argument containing failure data. This function
+  // may be used as a hook to write failure data to a secondary location, such
+  // as a log file. This function will also be called with null data, as a hint
+  // to flush any buffered data before the program may be terminated. Consider
+  // flushing any buffered data in all calls to this function.
+  //
+  // Since this function runs within a signal handler, it should be
+  // async-signal-safe if possible.
+  // See http://man7.org/linux/man-pages/man7/signal-safety.7.html
+  void (*writerfn)(const char*) = nullptr;
+};
+
+// InstallFailureSignalHandler()
+//
+// Installs a signal handler for the common failure signals `SIGSEGV`, `SIGILL`,
+// `SIGFPE`, `SIGABRT`, `SIGTERM`, `SIGBUG`, and `SIGTRAP` (provided they exist
+// on the given platform). The failure signal handler dumps program failure data
+// useful for debugging in an unspecified format to stderr. This data may
+// include the program counter, a stacktrace, and register information on some
+// systems; do not rely on an exact format for the output, as it is subject to
+// change.
+void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options);
+
+namespace debugging_internal {
+const char* FailureSignalToString(int signo);
+}  // namespace debugging_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/address_is_readable.h b/CAPI/cpp/grpc/include/absl/debugging/internal/address_is_readable.h
new file mode 100644
index 0000000..4bbaf4d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/address_is_readable.h
@@ -0,0 +1,32 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
+#define ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// Return whether the byte at *addr is readable, without faulting.
+// Save and restores errno.
+bool AddressIsReadable(const void *addr);
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/demangle.h b/CAPI/cpp/grpc/include/absl/debugging/internal/demangle.h
new file mode 100644
index 0000000..c314d9b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/demangle.h
@@ -0,0 +1,71 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// An async-signal-safe and thread-safe demangler for Itanium C++ ABI
+// (aka G++ V3 ABI).
+//
+// The demangler is implemented to be used in async signal handlers to
+// symbolize stack traces.  We cannot use libstdc++'s
+// abi::__cxa_demangle() in such signal handlers since it's not async
+// signal safe (it uses malloc() internally).
+//
+// Note that this demangler doesn't support full demangling.  More
+// specifically, it doesn't print types of function parameters and
+// types of template arguments.  It just skips them.  However, it's
+// still very useful to extract basic information such as class,
+// function, constructor, destructor, and operator names.
+//
+// See the implementation note in demangle.cc if you are interested.
+//
+// Example:
+//
+// | Mangled Name  | The Demangler | abi::__cxa_demangle()
+// |---------------|---------------|-----------------------
+// | _Z1fv         | f()           | f()
+// | _Z1fi         | f()           | f(int)
+// | _Z3foo3bar    | foo()         | foo(bar)
+// | _Z1fIiEvi     | f<>()         | void f<int>(int)
+// | _ZN1N1fE      | N::f          | N::f
+// | _ZN3Foo3BarEv | Foo::Bar()    | Foo::Bar()
+// | _Zrm1XS_"     | operator%()   | operator%(X, X)
+// | _ZN3FooC1Ev   | Foo::Foo()    | Foo::Foo()
+// | _Z1fSs        | f()           | f(std::basic_string<char,
+// |               |               |   std::char_traits<char>,
+// |               |               |   std::allocator<char> >)
+//
+// See the unit test for more examples.
+//
+// Note: we might want to write demanglers for ABIs other than Itanium
+// C++ ABI in the future.
+//
+
+#ifndef ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
+#define ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// Demangle `mangled`.  On success, return true and write the
+// demangled symbol name to `out`.  Otherwise, return false.
+// `out` is modified even if demangling is unsuccessful.
+bool Demangle(const char *mangled, char *out, int out_size);
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/elf_mem_image.h b/CAPI/cpp/grpc/include/absl/debugging/internal/elf_mem_image.h
new file mode 100644
index 0000000..113071a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/elf_mem_image.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2017 The Abseil Authors.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+
+// Allow dynamic symbol lookup for in-memory Elf images.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
+#define ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
+
+// Including this will define the __GLIBC__ macro if glibc is being
+// used.
+#include <climits>
+
+#include "absl/base/config.h"
+
+// Maybe one day we can rewrite this file not to require the elf
+// symbol extensions in glibc, but for right now we need them.
+#ifdef ABSL_HAVE_ELF_MEM_IMAGE
+#error ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set
+#endif
+
+#if defined(__ELF__) && !defined(__OpenBSD__) && !defined(__QNX__) && \
+    !defined(__native_client__) && !defined(__asmjs__) &&             \
+    !defined(__wasm__) && !defined(__HAIKU__)
+#define ABSL_HAVE_ELF_MEM_IMAGE 1
+#endif
+
+#ifdef ABSL_HAVE_ELF_MEM_IMAGE
+
+#include <link.h>  // for ElfW
+
+#if defined(__FreeBSD__) && !defined(ElfW)
+#define ElfW(x) __ElfN(x)
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// An in-memory ELF image (may not exist on disk).
+class ElfMemImage {
+ private:
+  // Sentinel: there could never be an elf image at &kInvalidBaseSentinel.
+  static const int kInvalidBaseSentinel;
+
+ public:
+  // Sentinel: there could never be an elf image at this address.
+  static constexpr const void *const kInvalidBase =
+    static_cast<const void*>(&kInvalidBaseSentinel);
+
+  // Information about a single vdso symbol.
+  // All pointers are into .dynsym, .dynstr, or .text of the VDSO.
+  // Do not free() them or modify through them.
+  struct SymbolInfo {
+    const char      *name;      // E.g. "__vdso_getcpu"
+    const char      *version;   // E.g. "LINUX_2.6", could be ""
+                                // for unversioned symbol.
+    const void      *address;   // Relocated symbol address.
+    const ElfW(Sym) *symbol;    // Symbol in the dynamic symbol table.
+  };
+
+  // Supports iteration over all dynamic symbols.
+  class SymbolIterator {
+   public:
+    friend class ElfMemImage;
+    const SymbolInfo *operator->() const;
+    const SymbolInfo &operator*() const;
+    SymbolIterator& operator++();
+    bool operator!=(const SymbolIterator &rhs) const;
+    bool operator==(const SymbolIterator &rhs) const;
+   private:
+    SymbolIterator(const void *const image, int index);
+    void Update(int incr);
+    SymbolInfo info_;
+    int index_;
+    const void *const image_;
+  };
+
+
+  explicit ElfMemImage(const void *base);
+  void                 Init(const void *base);
+  bool                 IsPresent() const { return ehdr_ != nullptr; }
+  const ElfW(Phdr)*    GetPhdr(int index) const;
+  const ElfW(Sym)*     GetDynsym(int index) const;
+  const ElfW(Versym)*  GetVersym(int index) const;
+  const ElfW(Verdef)*  GetVerdef(int index) const;
+  const ElfW(Verdaux)* GetVerdefAux(const ElfW(Verdef) *verdef) const;
+  const char*          GetDynstr(ElfW(Word) offset) const;
+  const void*          GetSymAddr(const ElfW(Sym) *sym) const;
+  const char*          GetVerstr(ElfW(Word) offset) const;
+  int                  GetNumSymbols() const;
+
+  SymbolIterator begin() const;
+  SymbolIterator end() const;
+
+  // Look up versioned dynamic symbol in the image.
+  // Returns false if image is not present, or doesn't contain given
+  // symbol/version/type combination.
+  // If info_out is non-null, additional details are filled in.
+  bool LookupSymbol(const char *name, const char *version,
+                    int symbol_type, SymbolInfo *info_out) const;
+
+  // Find info about symbol (if any) which overlaps given address.
+  // Returns true if symbol was found; false if image isn't present
+  // or doesn't have a symbol overlapping given address.
+  // If info_out is non-null, additional details are filled in.
+  bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const;
+
+ private:
+  const ElfW(Ehdr) *ehdr_;
+  const ElfW(Sym) *dynsym_;
+  const ElfW(Versym) *versym_;
+  const ElfW(Verdef) *verdef_;
+  const ElfW(Word) *hash_;
+  const char *dynstr_;
+  size_t strsize_;
+  size_t verdefnum_;
+  ElfW(Addr) link_base_;     // Link-time base (p_vaddr of first PT_LOAD).
+};
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_HAVE_ELF_MEM_IMAGE
+
+#endif  // ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/examine_stack.h b/CAPI/cpp/grpc/include/absl/debugging/internal/examine_stack.h
new file mode 100644
index 0000000..190af87
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/examine_stack.h
@@ -0,0 +1,64 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
+#define ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// Type of function used for printing in stack trace dumping, etc.
+// We avoid closures to keep things simple.
+typedef void OutputWriter(const char*, void*);
+
+// RegisterDebugStackTraceHook() allows to register a single routine
+// `hook` that is called each time DumpStackTrace() is called.
+// `hook` may be called from a signal handler.
+typedef void (*SymbolizeUrlEmitter)(void* const stack[], int depth,
+                                    OutputWriter* writer, void* writer_arg);
+
+// Registration of SymbolizeUrlEmitter for use inside of a signal handler.
+// This is inherently unsafe and must be signal safe code.
+void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook);
+SymbolizeUrlEmitter GetDebugStackTraceHook();
+
+// Returns the program counter from signal context, or nullptr if
+// unknown. `vuc` is a ucontext_t*. We use void* to avoid the use of
+// ucontext_t on non-POSIX systems.
+void* GetProgramCounter(void* const vuc);
+
+// Uses `writer` to dump the program counter, stack trace, and stack
+// frame sizes.
+void DumpPCAndFrameSizesAndStackTrace(void* const pc, void* const stack[],
+                                      int frame_sizes[], int depth,
+                                      int min_dropped_frames,
+                                      bool symbolize_stacktrace,
+                                      OutputWriter* writer, void* writer_arg);
+
+// Dump current stack trace omitting the topmost `min_dropped_frames` stack
+// frames.
+void DumpStackTrace(int min_dropped_frames, int max_num_frames,
+                    bool symbolize_stacktrace, OutputWriter* writer,
+                    void* writer_arg);
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stack_consumption.h b/CAPI/cpp/grpc/include/absl/debugging/internal/stack_consumption.h
new file mode 100644
index 0000000..f41b64c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stack_consumption.h
@@ -0,0 +1,50 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// Helper function for measuring stack consumption of signal handlers.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
+#define ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
+
+#include "absl/base/config.h"
+
+// The code in this module is not portable.
+// Use this feature test macro to detect its availability.
+#ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+#error ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION cannot be set directly
+#elif !defined(__APPLE__) && !defined(_WIN32) &&                     \
+    (defined(__i386__) || defined(__x86_64__) || defined(__ppc__) || \
+     defined(__aarch64__) || defined(__riscv))
+#define ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// Returns the stack consumption in bytes for the code exercised by
+// signal_handler.  To measure stack consumption, signal_handler is registered
+// as a signal handler, so the code that it exercises must be async-signal
+// safe.  The argument of signal_handler is an implementation detail of signal
+// handlers and should ignored by the code for signal_handler.  Use global
+// variables to pass information between your test code and signal_handler.
+int GetSignalHandlerStackConsumption(void (*signal_handler)(int));
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_aarch64-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_aarch64-inl.inc
new file mode 100644
index 0000000..4f9db9d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_aarch64-inl.inc
@@ -0,0 +1,204 @@
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
+
+// Generate stack tracer for aarch64
+
+#if defined(__linux__)
+#include <sys/mman.h>
+#include <ucontext.h>
+#include <unistd.h>
+#endif
+
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+#include <iostream>
+
+#include "absl/base/attributes.h"
+#include "absl/debugging/internal/address_is_readable.h"
+#include "absl/debugging/internal/vdso_support.h"  // a no-op on non-elf or non-glibc systems
+#include "absl/debugging/stacktrace.h"
+
+static const uintptr_t kUnknownFrameSize = 0;
+
+#if defined(__linux__)
+// Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
+static const unsigned char* GetKernelRtSigreturnAddress() {
+  constexpr uintptr_t kImpossibleAddress = 1;
+  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized{kImpossibleAddress};
+  uintptr_t address = memoized.load(std::memory_order_relaxed);
+  if (address != kImpossibleAddress) {
+    return reinterpret_cast<const unsigned char*>(address);
+  }
+
+  address = reinterpret_cast<uintptr_t>(nullptr);
+
+#ifdef ABSL_HAVE_VDSO_SUPPORT
+  absl::debugging_internal::VDSOSupport vdso;
+  if (vdso.IsPresent()) {
+    absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
+    auto lookup = [&](int type) {
+      return vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.6.39", type,
+                               &symbol_info);
+    };
+    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) ||
+        symbol_info.address == nullptr) {
+      // Unexpected: VDSO is present, yet the expected symbol is missing
+      // or null.
+      assert(false && "VDSO is present, but doesn't have expected symbol");
+    } else {
+      if (reinterpret_cast<uintptr_t>(symbol_info.address) !=
+          kImpossibleAddress) {
+        address = reinterpret_cast<uintptr_t>(symbol_info.address);
+      } else {
+        assert(false && "VDSO returned invalid address");
+      }
+    }
+  }
+#endif
+
+  memoized.store(address, std::memory_order_relaxed);
+  return reinterpret_cast<const unsigned char*>(address);
+}
+#endif  // __linux__
+
+// Compute the size of a stack frame in [low..high).  We assume that
+// low < high.  Return size of kUnknownFrameSize.
+template<typename T>
+static inline uintptr_t ComputeStackFrameSize(const T* low,
+                                              const T* high) {
+  const char* low_char_ptr = reinterpret_cast<const char *>(low);
+  const char* high_char_ptr = reinterpret_cast<const char *>(high);
+  return low < high ? high_char_ptr - low_char_ptr : kUnknownFrameSize;
+}
+
+// Given a pointer to a stack frame, locate and return the calling
+// stackframe, or return null if no stackframe can be found. Perform sanity
+// checks (the strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template<bool STRICT_UNWINDING, bool WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+static void **NextStackFrame(void **old_frame_pointer, const void *uc) {
+  void **new_frame_pointer = reinterpret_cast<void**>(*old_frame_pointer);
+  bool check_frame_size = true;
+
+#if defined(__linux__)
+  if (WITH_CONTEXT && uc != nullptr) {
+    // Check to see if next frame's return address is __kernel_rt_sigreturn.
+    if (old_frame_pointer[1] == GetKernelRtSigreturnAddress()) {
+      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
+      // old_frame_pointer[0] is not suitable for unwinding, look at
+      // ucontext to discover frame pointer before signal.
+      void **const pre_signal_frame_pointer =
+          reinterpret_cast<void **>(ucv->uc_mcontext.regs[29]);
+
+      // Check that alleged frame pointer is actually readable. This is to
+      // prevent "double fault" in case we hit the first fault due to e.g.
+      // stack corruption.
+      if (!absl::debugging_internal::AddressIsReadable(
+              pre_signal_frame_pointer))
+        return nullptr;
+
+      // Alleged frame pointer is readable, use it for further unwinding.
+      new_frame_pointer = pre_signal_frame_pointer;
+
+      // Skip frame size check if we return from a signal. We may be using a
+      // an alternate stack for signals.
+      check_frame_size = false;
+    }
+  }
+#endif
+
+  // aarch64 ABI requires stack pointer to be 16-byte-aligned.
+  if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0)
+    return nullptr;
+
+  // Check frame size.  In strict mode, we assume frames to be under
+  // 100,000 bytes.  In non-strict mode, we relax the limit to 1MB.
+  if (check_frame_size) {
+    const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000;
+    const uintptr_t frame_size =
+        ComputeStackFrameSize(old_frame_pointer, new_frame_pointer);
+    if (frame_size == kUnknownFrameSize || frame_size > max_size)
+      return nullptr;
+  }
+
+  return new_frame_pointer;
+}
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+                      const void *ucp, int *min_dropped_frames) {
+#ifdef __GNUC__
+  void **frame_pointer = reinterpret_cast<void**>(__builtin_frame_address(0));
+#else
+# error reading stack point not yet supported on this platform.
+#endif
+
+  skip_count++;    // Skip the frame for this function.
+  int n = 0;
+
+  // The frame pointer points to low address of a frame.  The first 64-bit
+  // word of a frame points to the next frame up the call chain, which normally
+  // is just after the high address of the current frame.  The second word of
+  // a frame contains return adress of to the caller.   To find a pc value
+  // associated with the current frame, we need to go down a level in the call
+  // chain.  So we remember return the address of the last frame seen.  This
+  // does not work for the first stack frame, which belongs to UnwindImp() but
+  // we skip the frame for UnwindImp() anyway.
+  void* prev_return_address = nullptr;
+
+  while (frame_pointer && n < max_depth) {
+    // The absl::GetStackFrames routine is called when we are in some
+    // informational context (the failure signal handler for example).
+    // Use the non-strict unwinding rules to produce a stack trace
+    // that is as complete as possible (even if it contains a few bogus
+    // entries in some rare cases).
+    void **next_frame_pointer =
+        NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
+
+    if (skip_count > 0) {
+      skip_count--;
+    } else {
+      result[n] = prev_return_address;
+      if (IS_STACK_FRAMES) {
+        sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer);
+      }
+      n++;
+    }
+    prev_return_address = frame_pointer[1];
+    frame_pointer = next_frame_pointer;
+  }
+  if (min_dropped_frames != nullptr) {
+    // Implementation detail: we clamp the max of frames we are willing to
+    // count, so as not to spend too much time in the loop below.
+    const int kMaxUnwind = 200;
+    int num_dropped_frames = 0;
+    for (int j = 0; frame_pointer != nullptr && j < kMaxUnwind; j++) {
+      if (skip_count > 0) {
+        skip_count--;
+      } else {
+        num_dropped_frames++;
+      }
+      frame_pointer =
+          NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
+    }
+    *min_dropped_frames = num_dropped_frames;
+  }
+  return n;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+  return true;
+}
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_arm-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_arm-inl.inc
new file mode 100644
index 0000000..102a2a1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_arm-inl.inc
@@ -0,0 +1,139 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This is inspired by Craig Silverstein's PowerPC stacktrace code.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
+
+#include <cstdint>
+
+#include "absl/debugging/stacktrace.h"
+
+// WARNING:
+// This only works if all your code is in either ARM or THUMB mode.  With
+// interworking, the frame pointer of the caller can either be in r11 (ARM
+// mode) or r7 (THUMB mode).  A callee only saves the frame pointer of its
+// mode in a fixed location on its stack frame.  If the caller is a different
+// mode, there is no easy way to find the frame pointer.  It can either be
+// still in the designated register or saved on stack along with other callee
+// saved registers.
+
+// Given a pointer to a stack frame, locate and return the calling
+// stackframe, or return nullptr if no stackframe can be found. Perform sanity
+// checks (the strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template<bool STRICT_UNWINDING>
+static void **NextStackFrame(void **old_sp) {
+  void **new_sp = (void**) old_sp[-1];
+
+  // Check that the transition from frame pointer old_sp to frame
+  // pointer new_sp isn't clearly bogus
+  if (STRICT_UNWINDING) {
+    // With the stack growing downwards, older stack frame must be
+    // at a greater address that the current one.
+    if (new_sp <= old_sp) return nullptr;
+    // Assume stack frames larger than 100,000 bytes are bogus.
+    if ((uintptr_t)new_sp - (uintptr_t)old_sp > 100000) return nullptr;
+  } else {
+    // In the non-strict mode, allow discontiguous stack frames.
+    // (alternate-signal-stacks for example).
+    if (new_sp == old_sp) return nullptr;
+    // And allow frames upto about 1MB.
+    if ((new_sp > old_sp)
+        && ((uintptr_t)new_sp - (uintptr_t)old_sp > 1000000)) return nullptr;
+  }
+  if ((uintptr_t)new_sp & (sizeof(void *) - 1)) return nullptr;
+  return new_sp;
+}
+
+// This ensures that absl::GetStackTrace sets up the Link Register properly.
+#ifdef __GNUC__
+void StacktraceArmDummyFunction() __attribute__((noinline));
+void StacktraceArmDummyFunction() { __asm__ volatile(""); }
+#else
+# error StacktraceArmDummyFunction() needs to be ported to this platform.
+#endif
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+                      const void * /* ucp */, int *min_dropped_frames) {
+#ifdef __GNUC__
+  void **sp = reinterpret_cast<void**>(__builtin_frame_address(0));
+#else
+# error reading stack point not yet supported on this platform.
+#endif
+
+  // On ARM, the return address is stored in the link register (r14).
+  // This is not saved on the stack frame of a leaf function.  To
+  // simplify code that reads return addresses, we call a dummy
+  // function so that the return address of this function is also
+  // stored in the stack frame.  This works at least for gcc.
+  StacktraceArmDummyFunction();
+
+  int n = 0;
+  while (sp && n < max_depth) {
+    // The absl::GetStackFrames routine is called when we are in some
+    // informational context (the failure signal handler for example).
+    // Use the non-strict unwinding rules to produce a stack trace
+    // that is as complete as possible (even if it contains a few bogus
+    // entries in some rare cases).
+    void **next_sp = NextStackFrame<!IS_STACK_FRAMES>(sp);
+
+    if (skip_count > 0) {
+      skip_count--;
+    } else {
+      result[n] = *sp;
+
+      if (IS_STACK_FRAMES) {
+        if (next_sp > sp) {
+          sizes[n] = (uintptr_t)next_sp - (uintptr_t)sp;
+        } else {
+          // A frame-size of 0 is used to indicate unknown frame size.
+          sizes[n] = 0;
+        }
+      }
+      n++;
+    }
+    sp = next_sp;
+  }
+  if (min_dropped_frames != nullptr) {
+    // Implementation detail: we clamp the max of frames we are willing to
+    // count, so as not to spend too much time in the loop below.
+    const int kMaxUnwind = 200;
+    int num_dropped_frames = 0;
+    for (int j = 0; sp != nullptr && j < kMaxUnwind; j++) {
+      if (skip_count > 0) {
+        skip_count--;
+      } else {
+        num_dropped_frames++;
+      }
+      sp = NextStackFrame<!IS_STACK_FRAMES>(sp);
+    }
+    *min_dropped_frames = num_dropped_frames;
+  }
+  return n;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+  return false;
+}
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_config.h b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_config.h
new file mode 100644
index 0000000..3929b1b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_config.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2017 The Abseil Authors.
+ *
+ * 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
+ *
+ *      https://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.
+
+ * Defines ABSL_STACKTRACE_INL_HEADER to the *-inl.h containing
+ * actual unwinder implementation.
+ * This header is "private" to stacktrace.cc.
+ * DO NOT include it into any other files.
+*/
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
+
+#include "absl/base/config.h"
+
+#if defined(ABSL_STACKTRACE_INL_HEADER)
+#error ABSL_STACKTRACE_INL_HEADER cannot be directly set
+
+#elif defined(_WIN32)
+#define ABSL_STACKTRACE_INL_HEADER \
+    "absl/debugging/internal/stacktrace_win32-inl.inc"
+
+#elif defined(__APPLE__)
+#ifdef ABSL_HAVE_THREAD_LOCAL
+// Thread local support required for UnwindImpl.
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_generic-inl.inc"
+#endif  // defined(ABSL_HAVE_THREAD_LOCAL)
+
+// Emscripten stacktraces rely on JS. Do not use them in standalone mode.
+#elif defined(__EMSCRIPTEN__) && !defined(STANDALONE_WASM)
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_emscripten-inl.inc"
+
+#elif defined(__linux__) && !defined(__ANDROID__)
+
+#if defined(NO_FRAME_POINTER) && \
+    (defined(__i386__) || defined(__x86_64__) || defined(__aarch64__))
+// Note: The libunwind-based implementation is not available to open-source
+// users.
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_libunwind-inl.inc"
+#define STACKTRACE_USES_LIBUNWIND 1
+#elif defined(NO_FRAME_POINTER) && defined(__has_include)
+#if __has_include(<execinfo.h>)
+// Note: When using glibc this may require -funwind-tables to function properly.
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_generic-inl.inc"
+#endif  // __has_include(<execinfo.h>)
+#elif defined(__i386__) || defined(__x86_64__)
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_x86-inl.inc"
+#elif defined(__ppc__) || defined(__PPC__)
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_powerpc-inl.inc"
+#elif defined(__aarch64__)
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_aarch64-inl.inc"
+#elif defined(__riscv)
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_riscv-inl.inc"
+#elif defined(__has_include)
+#if __has_include(<execinfo.h>)
+// Note: When using glibc this may require -funwind-tables to function properly.
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_generic-inl.inc"
+#endif  // __has_include(<execinfo.h>)
+#endif  // defined(__has_include)
+
+#endif  // defined(__linux__) && !defined(__ANDROID__)
+
+// Fallback to the empty implementation.
+#if !defined(ABSL_STACKTRACE_INL_HEADER)
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+#endif
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_emscripten-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_emscripten-inl.inc
new file mode 100644
index 0000000..0f44451
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_emscripten-inl.inc
@@ -0,0 +1,110 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Portable implementation - just use glibc
+//
+// Note:  The glibc implementation may cause a call to malloc.
+// This can cause a deadlock in HeapProfiler.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
+
+#include <emscripten.h>
+
+#include <atomic>
+#include <cstring>
+
+#include "absl/base/attributes.h"
+#include "absl/debugging/stacktrace.h"
+
+extern "C" {
+uintptr_t emscripten_stack_snapshot();
+uint32_t emscripten_stack_unwind_buffer(uintptr_t pc, void *buffer,
+                                        uint32_t depth);
+}
+
+// Sometimes, we can try to get a stack trace from within a stack
+// trace, which can cause a self-deadlock.
+// Protect against such reentrant call by failing to get a stack trace.
+//
+// We use __thread here because the code here is extremely low level -- it is
+// called while collecting stack traces from within malloc and mmap, and thus
+// can not call anything which might call malloc or mmap itself.
+static __thread int recursive = 0;
+
+// The stack trace function might be invoked very early in the program's
+// execution (e.g. from the very first malloc).
+// As such, we suppress usage of backtrace during this early stage of execution.
+static std::atomic<bool> disable_stacktraces(true);  // Disabled until healthy.
+// Waiting until static initializers run seems to be late enough.
+// This file is included into stacktrace.cc so this will only run once.
+ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
+  // Check if we can even create stacktraces. If not, bail early and leave
+  // disable_stacktraces set as-is.
+  // clang-format off
+  if (!EM_ASM_INT({ return (typeof wasmOffsetConverter !== 'undefined'); })) {
+    return 0;
+  }
+  // clang-format on
+  disable_stacktraces.store(false, std::memory_order_relaxed);
+  return 0;
+}();
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
+                      const void *ucp, int *min_dropped_frames) {
+  if (recursive || disable_stacktraces.load(std::memory_order_relaxed)) {
+    return 0;
+  }
+  ++recursive;
+
+  static_cast<void>(ucp);  // Unused.
+  constexpr int kStackLength = 64;
+  void *stack[kStackLength];
+
+  int size;
+  uintptr_t pc = emscripten_stack_snapshot();
+  size = emscripten_stack_unwind_buffer(pc, stack, kStackLength);
+
+  int result_count = size - skip_count;
+  if (result_count < 0) result_count = 0;
+  if (result_count > max_depth) result_count = max_depth;
+  for (int i = 0; i < result_count; i++) result[i] = stack[i + skip_count];
+
+  if (IS_STACK_FRAMES) {
+    // No implementation for finding out the stack frame sizes yet.
+    memset(sizes, 0, sizeof(*sizes) * result_count);
+  }
+  if (min_dropped_frames != nullptr) {
+    if (size - skip_count - max_depth > 0) {
+      *min_dropped_frames = size - skip_count - max_depth;
+    } else {
+      *min_dropped_frames = 0;
+    }
+  }
+
+  --recursive;
+
+  return result_count;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() { return true; }
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_generic-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_generic-inl.inc
new file mode 100644
index 0000000..b2792a1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_generic-inl.inc
@@ -0,0 +1,108 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Portable implementation - just use glibc
+//
+// Note:  The glibc implementation may cause a call to malloc.
+// This can cause a deadlock in HeapProfiler.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
+
+#include <execinfo.h>
+#include <atomic>
+#include <cstring>
+
+#include "absl/debugging/stacktrace.h"
+#include "absl/base/attributes.h"
+
+// Sometimes, we can try to get a stack trace from within a stack
+// trace, because we don't block signals inside this code (which would be too
+// expensive: the two extra system calls per stack trace do matter here).
+// That can cause a self-deadlock.
+// Protect against such reentrant call by failing to get a stack trace.
+//
+// We use __thread here because the code here is extremely low level -- it is
+// called while collecting stack traces from within malloc and mmap, and thus
+// can not call anything which might call malloc or mmap itself.
+static __thread int recursive = 0;
+
+// The stack trace function might be invoked very early in the program's
+// execution (e.g. from the very first malloc if using tcmalloc). Also, the
+// glibc implementation itself will trigger malloc the first time it is called.
+// As such, we suppress usage of backtrace during this early stage of execution.
+static std::atomic<bool> disable_stacktraces(true);  // Disabled until healthy.
+// Waiting until static initializers run seems to be late enough.
+// This file is included into stacktrace.cc so this will only run once.
+ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
+  void* unused_stack[1];
+  // Force the first backtrace to happen early to get the one-time shared lib
+  // loading (allocation) out of the way. After the first call it is much safer
+  // to use backtrace from a signal handler if we crash somewhere later.
+  backtrace(unused_stack, 1);
+  disable_stacktraces.store(false, std::memory_order_relaxed);
+  return 0;
+}();
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+                      const void *ucp, int *min_dropped_frames) {
+  if (recursive || disable_stacktraces.load(std::memory_order_relaxed)) {
+    return 0;
+  }
+  ++recursive;
+
+  static_cast<void>(ucp);  // Unused.
+  static const int kStackLength = 64;
+  void * stack[kStackLength];
+  int size;
+
+  size = backtrace(stack, kStackLength);
+  skip_count++;  // we want to skip the current frame as well
+  int result_count = size - skip_count;
+  if (result_count < 0)
+    result_count = 0;
+  if (result_count > max_depth)
+    result_count = max_depth;
+  for (int i = 0; i < result_count; i++)
+    result[i] = stack[i + skip_count];
+
+  if (IS_STACK_FRAMES) {
+    // No implementation for finding out the stack frame sizes yet.
+    memset(sizes, 0, sizeof(*sizes) * result_count);
+  }
+  if (min_dropped_frames != nullptr) {
+    if (size - skip_count - max_depth > 0) {
+      *min_dropped_frames = size - skip_count - max_depth;
+    } else {
+      *min_dropped_frames = 0;
+    }
+  }
+
+  --recursive;
+
+  return result_count;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+  return true;
+}
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_powerpc-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_powerpc-inl.inc
new file mode 100644
index 0000000..085cef6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_powerpc-inl.inc
@@ -0,0 +1,258 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Produce stack trace.  I'm guessing (hoping!) the code is much like
+// for x86.  For apple machines, at least, it seems to be; see
+//    https://developer.apple.com/documentation/mac/runtimehtml/RTArch-59.html
+//    https://www.linux-foundation.org/spec/ELF/ppc64/PPC-elf64abi-1.9.html#STACK
+// Linux has similar code: http://patchwork.ozlabs.org/linuxppc/patch?id=8882
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
+
+#if defined(__linux__)
+#include <asm/ptrace.h>   // for PT_NIP.
+#include <ucontext.h>     // for ucontext_t
+#endif
+
+#include <unistd.h>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+
+#include "absl/base/attributes.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+#include "absl/debugging/stacktrace.h"
+#include "absl/debugging/internal/address_is_readable.h"
+#include "absl/debugging/internal/vdso_support.h"  // a no-op on non-elf or non-glibc systems
+
+// Given a stack pointer, return the saved link register value.
+// Note that this is the link register for a callee.
+static inline void *StacktracePowerPCGetLR(void **sp) {
+  // PowerPC has 3 main ABIs, which say where in the stack the
+  // Link Register is.  For DARWIN and AIX (used by apple and
+  // linux ppc64), it's in sp[2].  For SYSV (used by linux ppc),
+  // it's in sp[1].
+#if defined(_CALL_AIX) || defined(_CALL_DARWIN)
+  return *(sp+2);
+#elif defined(_CALL_SYSV)
+  return *(sp+1);
+#elif defined(__APPLE__) || defined(__FreeBSD__) || \
+    (defined(__linux__) && defined(__PPC64__))
+  // This check is in case the compiler doesn't define _CALL_AIX/etc.
+  return *(sp+2);
+#elif defined(__linux)
+  // This check is in case the compiler doesn't define _CALL_SYSV.
+  return *(sp+1);
+#else
+#error Need to specify the PPC ABI for your archiecture.
+#endif
+}
+
+// Given a pointer to a stack frame, locate and return the calling
+// stackframe, or return null if no stackframe can be found. Perform sanity
+// checks (the strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template<bool STRICT_UNWINDING, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+static void **NextStackFrame(void **old_sp, const void *uc) {
+  void **new_sp = (void **) *old_sp;
+  enum { kStackAlignment = 16 };
+
+  // Check that the transition from frame pointer old_sp to frame
+  // pointer new_sp isn't clearly bogus
+  if (STRICT_UNWINDING) {
+    // With the stack growing downwards, older stack frame must be
+    // at a greater address that the current one.
+    if (new_sp <= old_sp) return nullptr;
+    // Assume stack frames larger than 100,000 bytes are bogus.
+    if ((uintptr_t)new_sp - (uintptr_t)old_sp > 100000) return nullptr;
+  } else {
+    // In the non-strict mode, allow discontiguous stack frames.
+    // (alternate-signal-stacks for example).
+    if (new_sp == old_sp) return nullptr;
+    // And allow frames upto about 1MB.
+    if ((new_sp > old_sp)
+        && ((uintptr_t)new_sp - (uintptr_t)old_sp > 1000000)) return nullptr;
+  }
+  if ((uintptr_t)new_sp % kStackAlignment != 0) return nullptr;
+
+#if defined(__linux__)
+  enum StackTraceKernelSymbolStatus {
+      kNotInitialized = 0, kAddressValid, kAddressInvalid };
+
+  if (IS_WITH_CONTEXT && uc != nullptr) {
+    static StackTraceKernelSymbolStatus kernel_symbol_status =
+        kNotInitialized;  // Sentinel: not computed yet.
+    // Initialize with sentinel value: __kernel_rt_sigtramp_rt64 can not
+    // possibly be there.
+    static const unsigned char *kernel_sigtramp_rt64_address = nullptr;
+    if (kernel_symbol_status == kNotInitialized) {
+      absl::debugging_internal::VDSOSupport vdso;
+      if (vdso.IsPresent()) {
+        absl::debugging_internal::VDSOSupport::SymbolInfo
+            sigtramp_rt64_symbol_info;
+        if (!vdso.LookupSymbol(
+                "__kernel_sigtramp_rt64", "LINUX_2.6.15",
+                absl::debugging_internal::VDSOSupport::kVDSOSymbolType,
+                &sigtramp_rt64_symbol_info) ||
+            sigtramp_rt64_symbol_info.address == nullptr) {
+          // Unexpected: VDSO is present, yet the expected symbol is missing
+          // or null.
+          assert(false && "VDSO is present, but doesn't have expected symbol");
+          kernel_symbol_status = kAddressInvalid;
+        } else {
+          kernel_sigtramp_rt64_address =
+              reinterpret_cast<const unsigned char *>(
+                  sigtramp_rt64_symbol_info.address);
+          kernel_symbol_status = kAddressValid;
+        }
+      } else {
+        kernel_symbol_status = kAddressInvalid;
+      }
+    }
+
+    if (new_sp != nullptr &&
+        kernel_symbol_status == kAddressValid &&
+        StacktracePowerPCGetLR(new_sp) == kernel_sigtramp_rt64_address) {
+      const ucontext_t* signal_context =
+          reinterpret_cast<const ucontext_t*>(uc);
+      void **const sp_before_signal =
+#if defined(__PPC64__)
+          reinterpret_cast<void **>(signal_context->uc_mcontext.gp_regs[PT_R1]);
+#else
+          reinterpret_cast<void **>(
+              signal_context->uc_mcontext.uc_regs->gregs[PT_R1]);
+#endif
+      // Check that alleged sp before signal is nonnull and is reasonably
+      // aligned.
+      if (sp_before_signal != nullptr &&
+          ((uintptr_t)sp_before_signal % kStackAlignment) == 0) {
+        // Check that alleged stack pointer is actually readable. This is to
+        // prevent a "double fault" in case we hit the first fault due to e.g.
+        // a stack corruption.
+        if (absl::debugging_internal::AddressIsReadable(sp_before_signal)) {
+          // Alleged stack pointer is readable, use it for further unwinding.
+          new_sp = sp_before_signal;
+        }
+      }
+    }
+  }
+#endif
+
+  return new_sp;
+}
+
+// This ensures that absl::GetStackTrace sets up the Link Register properly.
+ABSL_ATTRIBUTE_NOINLINE static void AbslStacktracePowerPCDummyFunction() {
+  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+}
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+                      const void *ucp, int *min_dropped_frames) {
+  void **sp;
+  // Apple macOS uses an old version of gnu as -- both Darwin 7.9.0 (Panther)
+  // and Darwin 8.8.1 (Tiger) use as 1.38.  This means we have to use a
+  // different asm syntax.  I don't know quite the best way to discriminate
+  // systems using the old as from the new one; I've gone with __APPLE__.
+#ifdef __APPLE__
+  __asm__ volatile ("mr %0,r1" : "=r" (sp));
+#else
+  __asm__ volatile ("mr %0,1" : "=r" (sp));
+#endif
+
+  // On PowerPC, the "Link Register" or "Link Record" (LR), is a stack
+  // entry that holds the return address of the subroutine call (what
+  // instruction we run after our function finishes).  This is the
+  // same as the stack-pointer of our parent routine, which is what we
+  // want here.  While the compiler will always(?) set up LR for
+  // subroutine calls, it may not for leaf functions (such as this one).
+  // This routine forces the compiler (at least gcc) to push it anyway.
+  AbslStacktracePowerPCDummyFunction();
+
+  // The LR save area is used by the callee, so the top entry is bogus.
+  skip_count++;
+
+  int n = 0;
+
+  // Unlike ABIs of X86 and ARM, PowerPC ABIs say that return address (in
+  // the link register) of a function call is stored in the caller's stack
+  // frame instead of the callee's.  When we look for the return address
+  // associated with a stack frame, we need to make sure that there is a
+  // caller frame before it.  So we call NextStackFrame before entering the
+  // loop below and check next_sp instead of sp for loop termination.
+  // The outermost frame is set up by runtimes and it does not have a
+  // caller frame, so it is skipped.
+
+  // The absl::GetStackFrames routine is called when we are in some
+  // informational context (the failure signal handler for example).
+  // Use the non-strict unwinding rules to produce a stack trace
+  // that is as complete as possible (even if it contains a few
+  // bogus entries in some rare cases).
+  void **next_sp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(sp, ucp);
+
+  while (next_sp && n < max_depth) {
+    if (skip_count > 0) {
+      skip_count--;
+    } else {
+      result[n] = StacktracePowerPCGetLR(sp);
+      if (IS_STACK_FRAMES) {
+        if (next_sp > sp) {
+          sizes[n] = (uintptr_t)next_sp - (uintptr_t)sp;
+        } else {
+          // A frame-size of 0 is used to indicate unknown frame size.
+          sizes[n] = 0;
+        }
+      }
+      n++;
+    }
+
+    sp = next_sp;
+    next_sp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(sp, ucp);
+  }
+
+  if (min_dropped_frames != nullptr) {
+    // Implementation detail: we clamp the max of frames we are willing to
+    // count, so as not to spend too much time in the loop below.
+    const int kMaxUnwind = 1000;
+    int num_dropped_frames = 0;
+    for (int j = 0; next_sp != nullptr && j < kMaxUnwind; j++) {
+      if (skip_count > 0) {
+        skip_count--;
+      } else {
+        num_dropped_frames++;
+      }
+      next_sp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(next_sp, ucp);
+    }
+    *min_dropped_frames = num_dropped_frames;
+  }
+  return n;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+  return true;
+}
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_riscv-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_riscv-inl.inc
new file mode 100644
index 0000000..7123b71
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_riscv-inl.inc
@@ -0,0 +1,236 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
+
+// Generate stack trace for riscv
+
+#include <sys/ucontext.h>
+
+#include "absl/base/config.h"
+#if defined(__linux__)
+#include <sys/mman.h>
+#include <ucontext.h>
+#include <unistd.h>
+#endif
+
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+#include <iostream>
+
+#include "absl/base/attributes.h"
+#include "absl/debugging/internal/address_is_readable.h"
+#include "absl/debugging/internal/vdso_support.h"
+#include "absl/debugging/stacktrace.h"
+
+static const uintptr_t kUnknownFrameSize = 0;
+
+#if defined(__linux__)
+// Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
+static const unsigned char *GetKernelRtSigreturnAddress() {
+  constexpr uintptr_t kImpossibleAddress = 0;
+  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress);
+  uintptr_t address = memoized.load(std::memory_order_relaxed);
+  if (address != kImpossibleAddress) {
+    return reinterpret_cast<const unsigned char *>(address);
+  }
+
+  address = reinterpret_cast<uintptr_t>(nullptr);
+
+#if ABSL_HAVE_VDSO_SUPPORT
+  absl::debugging_internal::VDSOSupport vdso;
+  if (vdso.IsPresent()) {
+    absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
+    // Symbol versioning pulled from arch/riscv/kernel/vdso/vdso.lds at v5.10.
+    auto lookup = [&](int type) {
+      return vdso.LookupSymbol("__vdso_rt_sigreturn", "LINUX_4.15", type,
+                               &symbol_info);
+    };
+    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) ||
+        symbol_info.address == nullptr) {
+      // Unexpected: VDSO is present, yet the expected symbol is missing or
+      // null.
+      assert(false && "VDSO is present, but doesn't have expected symbol");
+    } else {
+      if (reinterpret_cast<uintptr_t>(symbol_info.address) !=
+          kImpossibleAddress) {
+        address = reinterpret_cast<uintptr_t>(symbol_info.address);
+      } else {
+        assert(false && "VDSO returned invalid address");
+      }
+    }
+  }
+#endif
+
+  memoized.store(address, std::memory_order_relaxed);
+  return reinterpret_cast<const unsigned char *>(address);
+}
+#endif  // __linux__
+
+// Compute the size of a stack frame in [low..high).  We assume that low < high.
+// Return size of kUnknownFrameSize.
+template <typename T>
+static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) {
+  const char *low_char_ptr = reinterpret_cast<const char *>(low);
+  const char *high_char_ptr = reinterpret_cast<const char *>(high);
+  return low < high ? high_char_ptr - low_char_ptr : kUnknownFrameSize;
+}
+
+// Given a pointer to a stack frame, locate and return the calling stackframe,
+// or return null if no stackframe can be found. Perform sanity checks (the
+// strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+static void ** NextStackFrame(void **old_frame_pointer, const void *uc) {
+  //               .
+  //               .
+  //               .
+  //   +-> +----------------+
+  //   |   | return address |
+  //   |   |   previous fp  |
+  //   |   |      ...       |
+  //   |   +----------------+ <-+
+  //   |   | return address |   |
+  //   +---|-  previous fp  |   |
+  //       |      ...       |   |
+  // $fp ->|----------------+   |
+  //       | return address |   |
+  //       |   previous fp -|---+
+  // $sp ->|      ...       |
+  //       +----------------+
+  void **new_frame_pointer = reinterpret_cast<void **>(old_frame_pointer[-2]);
+  bool check_frame_size = true;
+
+#if defined(__linux__)
+  if (WITH_CONTEXT && uc != nullptr) {
+    // Check to see if next frame's return address is __kernel_rt_sigreturn.
+    if (old_frame_pointer[-1] == GetKernelRtSigreturnAddress()) {
+      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
+      // old_frame_pointer is not suitable for unwinding, look at ucontext to
+      // discover frame pointer before signal.
+      //
+      // RISCV ELF psABI has the frame pointer at x8/fp/s0.
+      // -- RISCV psABI Table 18.2
+      void **const pre_signal_frame_pointer =
+          reinterpret_cast<void **>(ucv->uc_mcontext.__gregs[8]);
+
+      // Check the alleged frame pointer is actually readable. This is to
+      // prevent "double fault" in case we hit the first fault due to stack
+      // corruption.
+      if (!absl::debugging_internal::AddressIsReadable(
+              pre_signal_frame_pointer))
+        return nullptr;
+
+      // Alleged frame pointer is readable, use it for further unwinding.
+      new_frame_pointer = pre_signal_frame_pointer;
+
+      // Skip frame size check if we return from a signal.  We may be using an
+      // alterate stack for signals.
+      check_frame_size = false;
+    }
+  }
+#endif
+
+  // The RISCV ELF psABI mandates that the stack pointer is always 16-byte
+  // aligned.
+  // FIXME(abdulras) this doesn't hold for ILP32E which only mandates a 4-byte
+  // alignment.
+  if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0)
+    return nullptr;
+
+  // Check frame size.  In strict mode, we assume frames to be under 100,000
+  // bytes.  In non-strict mode, we relax the limit to 1MB.
+  if (check_frame_size) {
+    const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000;
+    const uintptr_t frame_size =
+        ComputeStackFrameSize(old_frame_pointer, new_frame_pointer);
+    if (frame_size == kUnknownFrameSize || frame_size > max_size)
+      return nullptr;
+  }
+
+  return new_frame_pointer;
+}
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
+                      const void *ucp, int *min_dropped_frames) {
+  // The `frame_pointer` that is computed here points to the top of the frame.
+  // The two words preceding the address are the return address and the previous
+  // frame pointer.
+#if defined(__GNUC__)
+  void **frame_pointer = reinterpret_cast<void **>(__builtin_frame_address(0));
+#else
+#error reading stack pointer not yet supported on this platform
+#endif
+
+  int n = 0;
+  void *return_address = nullptr;
+  while (frame_pointer && n < max_depth) {
+    return_address = frame_pointer[-1];
+
+    // The absl::GetStackFrames routine is called when we are in some
+    // informational context (the failure signal handler for example).  Use the
+    // non-strict unwinding rules to produce a stack trace that is as complete
+    // as possible (even if it contains a few bogus entries in some rare cases).
+    void **next_frame_pointer =
+        NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
+
+    if (skip_count > 0) {
+      skip_count--;
+    } else {
+      result[n] = return_address;
+      if (IS_STACK_FRAMES) {
+        sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer);
+      }
+      n++;
+    }
+
+    frame_pointer = next_frame_pointer;
+  }
+
+  if (min_dropped_frames != nullptr) {
+    // Implementation detail: we clamp the max of frames we are willing to
+    // count, so as not to spend too much time in the loop below.
+    const int kMaxUnwind = 200;
+    int num_dropped_frames = 0;
+    for (int j = 0; frame_pointer != nullptr && j < kMaxUnwind; j++) {
+      if (skip_count > 0) {
+        skip_count--;
+      } else {
+        num_dropped_frames++;
+      }
+      frame_pointer =
+          NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
+    }
+    *min_dropped_frames = num_dropped_frames;
+  }
+
+  return n;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() { return true; }
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_unimplemented-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_unimplemented-inl.inc
new file mode 100644
index 0000000..5b8fb19
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_unimplemented-inl.inc
@@ -0,0 +1,24 @@
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** /* result */, int* /* sizes */,
+                      int /* max_depth */, int /* skip_count */,
+                      const void* /* ucp */, int *min_dropped_frames) {
+  if (min_dropped_frames != nullptr) {
+    *min_dropped_frames = 0;
+  }
+  return 0;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+  return false;
+}
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_win32-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_win32-inl.inc
new file mode 100644
index 0000000..1c666c8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_win32-inl.inc
@@ -0,0 +1,93 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Produces a stack trace for Windows.  Normally, one could use
+// stacktrace_x86-inl.h or stacktrace_x86_64-inl.h -- and indeed, that
+// should work for binaries compiled using MSVC in "debug" mode.
+// However, in "release" mode, Windows uses frame-pointer
+// optimization, which makes getting a stack trace very difficult.
+//
+// There are several approaches one can take.  One is to use Windows
+// intrinsics like StackWalk64.  These can work, but have restrictions
+// on how successful they can be.  Another attempt is to write a
+// version of stacktrace_x86-inl.h that has heuristic support for
+// dealing with FPO, similar to what WinDbg does (see
+// http://www.nynaeve.net/?p=97).  There are (non-working) examples of
+// these approaches, complete with TODOs, in stacktrace_win32-inl.h#1
+//
+// The solution we've ended up doing is to call the undocumented
+// windows function RtlCaptureStackBackTrace, which probably doesn't
+// work with FPO but at least is fast, and doesn't require a symbol
+// server.
+//
+// This code is inspired by a patch from David Vitek:
+//   https://code.google.com/p/google-perftools/issues/detail?id=83
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
+
+#include <windows.h>    // for GetProcAddress and GetModuleHandle
+#include <cassert>
+
+typedef USHORT NTAPI RtlCaptureStackBackTrace_Function(
+    IN ULONG frames_to_skip,
+    IN ULONG frames_to_capture,
+    OUT PVOID *backtrace,
+    OUT PULONG backtrace_hash);
+
+// It is not possible to load RtlCaptureStackBackTrace at static init time in
+// UWP. CaptureStackBackTrace is the public version of RtlCaptureStackBackTrace
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \
+    !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+static RtlCaptureStackBackTrace_Function* const RtlCaptureStackBackTrace_fn =
+    &::CaptureStackBackTrace;
+#else
+// Load the function we need at static init time, where we don't have
+// to worry about someone else holding the loader's lock.
+static RtlCaptureStackBackTrace_Function* const RtlCaptureStackBackTrace_fn =
+    (RtlCaptureStackBackTrace_Function*)GetProcAddress(
+        GetModuleHandleA("ntdll.dll"), "RtlCaptureStackBackTrace");
+#endif  // WINAPI_PARTITION_APP && !WINAPI_PARTITION_DESKTOP
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+                      const void*, int* min_dropped_frames) {
+  int n = 0;
+  if (!RtlCaptureStackBackTrace_fn) {
+    // can't find a stacktrace with no function to call
+  } else {
+    n = (int)RtlCaptureStackBackTrace_fn(skip_count + 2, max_depth, result, 0);
+  }
+  if (IS_STACK_FRAMES) {
+    // No implementation for finding out the stack frame sizes yet.
+    memset(sizes, 0, sizeof(*sizes) * n);
+  }
+  if (min_dropped_frames != nullptr) {
+    // Not implemented.
+    *min_dropped_frames = 0;
+  }
+  return n;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+  return false;
+}
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_x86-inl.inc b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_x86-inl.inc
new file mode 100644
index 0000000..1b5d823
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_x86-inl.inc
@@ -0,0 +1,369 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Produce stack trace
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
+
+#if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
+#include <ucontext.h>  // for ucontext_t
+#endif
+
+#if !defined(_WIN32)
+#include <unistd.h>
+#endif
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/debugging/internal/address_is_readable.h"
+#include "absl/debugging/internal/vdso_support.h"  // a no-op on non-elf or non-glibc systems
+#include "absl/debugging/stacktrace.h"
+
+#include "absl/base/internal/raw_logging.h"
+
+using absl::debugging_internal::AddressIsReadable;
+
+#if defined(__linux__) && defined(__i386__)
+// Count "push %reg" instructions in VDSO __kernel_vsyscall(),
+// preceeding "syscall" or "sysenter".
+// If __kernel_vsyscall uses frame pointer, answer 0.
+//
+// kMaxBytes tells how many instruction bytes of __kernel_vsyscall
+// to analyze before giving up. Up to kMaxBytes+1 bytes of
+// instructions could be accessed.
+//
+// Here are known __kernel_vsyscall instruction sequences:
+//
+// SYSENTER (linux-2.6.26/arch/x86/vdso/vdso32/sysenter.S).
+// Used on Intel.
+//  0xffffe400 <__kernel_vsyscall+0>:       push   %ecx
+//  0xffffe401 <__kernel_vsyscall+1>:       push   %edx
+//  0xffffe402 <__kernel_vsyscall+2>:       push   %ebp
+//  0xffffe403 <__kernel_vsyscall+3>:       mov    %esp,%ebp
+//  0xffffe405 <__kernel_vsyscall+5>:       sysenter
+//
+// SYSCALL (see linux-2.6.26/arch/x86/vdso/vdso32/syscall.S).
+// Used on AMD.
+//  0xffffe400 <__kernel_vsyscall+0>:       push   %ebp
+//  0xffffe401 <__kernel_vsyscall+1>:       mov    %ecx,%ebp
+//  0xffffe403 <__kernel_vsyscall+3>:       syscall
+//
+
+// The sequence below isn't actually expected in Google fleet,
+// here only for completeness. Remove this comment from OSS release.
+
+// i386 (see linux-2.6.26/arch/x86/vdso/vdso32/int80.S)
+//  0xffffe400 <__kernel_vsyscall+0>:       int $0x80
+//  0xffffe401 <__kernel_vsyscall+1>:       ret
+//
+static const int kMaxBytes = 10;
+
+// We use assert()s instead of DCHECK()s -- this is too low level
+// for DCHECK().
+
+static int CountPushInstructions(const unsigned char *const addr) {
+  int result = 0;
+  for (int i = 0; i < kMaxBytes; ++i) {
+    if (addr[i] == 0x89) {
+      // "mov reg,reg"
+      if (addr[i + 1] == 0xE5) {
+        // Found "mov %esp,%ebp".
+        return 0;
+      }
+      ++i;  // Skip register encoding byte.
+    } else if (addr[i] == 0x0F &&
+               (addr[i + 1] == 0x34 || addr[i + 1] == 0x05)) {
+      // Found "sysenter" or "syscall".
+      return result;
+    } else if ((addr[i] & 0xF0) == 0x50) {
+      // Found "push %reg".
+      ++result;
+    } else if (addr[i] == 0xCD && addr[i + 1] == 0x80) {
+      // Found "int $0x80"
+      assert(result == 0);
+      return 0;
+    } else {
+      // Unexpected instruction.
+      assert(false && "unexpected instruction in __kernel_vsyscall");
+      return 0;
+    }
+  }
+  // Unexpected: didn't find SYSENTER or SYSCALL in
+  // [__kernel_vsyscall, __kernel_vsyscall + kMaxBytes) interval.
+  assert(false && "did not find SYSENTER or SYSCALL in __kernel_vsyscall");
+  return 0;
+}
+#endif
+
+// Assume stack frames larger than 100,000 bytes are bogus.
+static const int kMaxFrameBytes = 100000;
+
+// Returns the stack frame pointer from signal context, 0 if unknown.
+// vuc is a ucontext_t *.  We use void* to avoid the use
+// of ucontext_t on non-POSIX systems.
+static uintptr_t GetFP(const void *vuc) {
+#if !defined(__linux__)
+  static_cast<void>(vuc);  // Avoid an unused argument compiler warning.
+#else
+  if (vuc != nullptr) {
+    auto *uc = reinterpret_cast<const ucontext_t *>(vuc);
+#if defined(__i386__)
+    const auto bp = uc->uc_mcontext.gregs[REG_EBP];
+    const auto sp = uc->uc_mcontext.gregs[REG_ESP];
+#elif defined(__x86_64__)
+    const auto bp = uc->uc_mcontext.gregs[REG_RBP];
+    const auto sp = uc->uc_mcontext.gregs[REG_RSP];
+#else
+    const uintptr_t bp = 0;
+    const uintptr_t sp = 0;
+#endif
+    // Sanity-check that the base pointer is valid. It's possible that some
+    // code in the process is compiled with --copt=-fomit-frame-pointer or
+    // --copt=-momit-leaf-frame-pointer.
+    //
+    // TODO(bcmills): -momit-leaf-frame-pointer is currently the default
+    // behavior when building with clang.  Talk to the C++ toolchain team about
+    // fixing that.
+    if (bp >= sp && bp - sp <= kMaxFrameBytes) return bp;
+
+    // If bp isn't a plausible frame pointer, return the stack pointer instead.
+    // If we're lucky, it points to the start of a stack frame; otherwise, we'll
+    // get one frame of garbage in the stack trace and fail the sanity check on
+    // the next iteration.
+    return sp;
+  }
+#endif
+  return 0;
+}
+
+// Given a pointer to a stack frame, locate and return the calling
+// stackframe, or return null if no stackframe can be found. Perform sanity
+// checks (the strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+static void **NextStackFrame(void **old_fp, const void *uc,
+                             size_t stack_low, size_t stack_high) {
+  void **new_fp = (void **)*old_fp;
+
+#if defined(__linux__) && defined(__i386__)
+  if (WITH_CONTEXT && uc != nullptr) {
+    // How many "push %reg" instructions are there at __kernel_vsyscall?
+    // This is constant for a given kernel and processor, so compute
+    // it only once.
+    static int num_push_instructions = -1;  // Sentinel: not computed yet.
+    // Initialize with sentinel value: __kernel_rt_sigreturn can not possibly
+    // be there.
+    static const unsigned char *kernel_rt_sigreturn_address = nullptr;
+    static const unsigned char *kernel_vsyscall_address = nullptr;
+    if (num_push_instructions == -1) {
+#ifdef ABSL_HAVE_VDSO_SUPPORT
+      absl::debugging_internal::VDSOSupport vdso;
+      if (vdso.IsPresent()) {
+        absl::debugging_internal::VDSOSupport::SymbolInfo
+            rt_sigreturn_symbol_info;
+        absl::debugging_internal::VDSOSupport::SymbolInfo vsyscall_symbol_info;
+        if (!vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.5", STT_FUNC,
+                               &rt_sigreturn_symbol_info) ||
+            !vdso.LookupSymbol("__kernel_vsyscall", "LINUX_2.5", STT_FUNC,
+                               &vsyscall_symbol_info) ||
+            rt_sigreturn_symbol_info.address == nullptr ||
+            vsyscall_symbol_info.address == nullptr) {
+          // Unexpected: 32-bit VDSO is present, yet one of the expected
+          // symbols is missing or null.
+          assert(false && "VDSO is present, but doesn't have expected symbols");
+          num_push_instructions = 0;
+        } else {
+          kernel_rt_sigreturn_address =
+              reinterpret_cast<const unsigned char *>(
+                  rt_sigreturn_symbol_info.address);
+          kernel_vsyscall_address =
+              reinterpret_cast<const unsigned char *>(
+                  vsyscall_symbol_info.address);
+          num_push_instructions =
+              CountPushInstructions(kernel_vsyscall_address);
+        }
+      } else {
+        num_push_instructions = 0;
+      }
+#else  // ABSL_HAVE_VDSO_SUPPORT
+      num_push_instructions = 0;
+#endif  // ABSL_HAVE_VDSO_SUPPORT
+    }
+    if (num_push_instructions != 0 && kernel_rt_sigreturn_address != nullptr &&
+        old_fp[1] == kernel_rt_sigreturn_address) {
+      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
+      // This kernel does not use frame pointer in its VDSO code,
+      // and so %ebp is not suitable for unwinding.
+      void **const reg_ebp =
+          reinterpret_cast<void **>(ucv->uc_mcontext.gregs[REG_EBP]);
+      const unsigned char *const reg_eip =
+          reinterpret_cast<unsigned char *>(ucv->uc_mcontext.gregs[REG_EIP]);
+      if (new_fp == reg_ebp && kernel_vsyscall_address <= reg_eip &&
+          reg_eip - kernel_vsyscall_address < kMaxBytes) {
+        // We "stepped up" to __kernel_vsyscall, but %ebp is not usable.
+        // Restore from 'ucv' instead.
+        void **const reg_esp =
+            reinterpret_cast<void **>(ucv->uc_mcontext.gregs[REG_ESP]);
+        // Check that alleged %esp is not null and is reasonably aligned.
+        if (reg_esp &&
+            ((uintptr_t)reg_esp & (sizeof(reg_esp) - 1)) == 0) {
+          // Check that alleged %esp is actually readable. This is to prevent
+          // "double fault" in case we hit the first fault due to e.g. stack
+          // corruption.
+          void *const reg_esp2 = reg_esp[num_push_instructions - 1];
+          if (AddressIsReadable(reg_esp2)) {
+            // Alleged %esp is readable, use it for further unwinding.
+            new_fp = reinterpret_cast<void **>(reg_esp2);
+          }
+        }
+      }
+    }
+  }
+#endif
+
+  const uintptr_t old_fp_u = reinterpret_cast<uintptr_t>(old_fp);
+  const uintptr_t new_fp_u = reinterpret_cast<uintptr_t>(new_fp);
+
+  // Check that the transition from frame pointer old_fp to frame
+  // pointer new_fp isn't clearly bogus.  Skip the checks if new_fp
+  // matches the signal context, so that we don't skip out early when
+  // using an alternate signal stack.
+  //
+  // TODO(bcmills): The GetFP call should be completely unnecessary when
+  // ENABLE_COMBINED_UNWINDER is set (because we should be back in the thread's
+  // stack by this point), but it is empirically still needed (e.g. when the
+  // stack includes a call to abort).  unw_get_reg returns UNW_EBADREG for some
+  // frames.  Figure out why GetValidFrameAddr and/or libunwind isn't doing what
+  // it's supposed to.
+  if (STRICT_UNWINDING &&
+      (!WITH_CONTEXT || uc == nullptr || new_fp_u != GetFP(uc))) {
+    // With the stack growing downwards, older stack frame must be
+    // at a greater address that the current one.
+    if (new_fp_u <= old_fp_u) return nullptr;
+    if (new_fp_u - old_fp_u > kMaxFrameBytes) return nullptr;
+
+    if (stack_low < old_fp_u && old_fp_u <= stack_high) {
+      // Old BP was in the expected stack region...
+      if (!(stack_low < new_fp_u && new_fp_u <= stack_high)) {
+        // ... but new BP is outside of expected stack region.
+        // It is most likely bogus.
+        return nullptr;
+      }
+    } else {
+      // We may be here if we are executing in a co-routine with a
+      // separate stack. We can't do safety checks in this case.
+    }
+  } else {
+    if (new_fp == nullptr) return nullptr;  // skip AddressIsReadable() below
+    // In the non-strict mode, allow discontiguous stack frames.
+    // (alternate-signal-stacks for example).
+    if (new_fp == old_fp) return nullptr;
+  }
+
+  if (new_fp_u & (sizeof(void *) - 1)) return nullptr;
+#ifdef __i386__
+  // On 32-bit machines, the stack pointer can be very close to
+  // 0xffffffff, so we explicitly check for a pointer into the
+  // last two pages in the address space
+  if (new_fp_u >= 0xffffe000) return nullptr;
+#endif
+#if !defined(_WIN32)
+  if (!STRICT_UNWINDING) {
+    // Lax sanity checks cause a crash in 32-bit tcmalloc/crash_reason_test
+    // on AMD-based machines with VDSO-enabled kernels.
+    // Make an extra sanity check to insure new_fp is readable.
+    // Note: NextStackFrame<false>() is only called while the program
+    //       is already on its last leg, so it's ok to be slow here.
+
+    if (!AddressIsReadable(new_fp)) {
+      return nullptr;
+    }
+  }
+#endif
+  return new_fp;
+}
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+ABSL_ATTRIBUTE_NOINLINE
+static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
+                      const void *ucp, int *min_dropped_frames) {
+  int n = 0;
+  void **fp = reinterpret_cast<void **>(__builtin_frame_address(0));
+
+  size_t stack_low = getpagesize();  // Assume that the first page is not stack.
+  size_t stack_high = std::numeric_limits<size_t>::max() - sizeof(void *);
+
+  while (fp && n < max_depth) {
+    if (*(fp + 1) == reinterpret_cast<void *>(0)) {
+      // In 64-bit code, we often see a frame that
+      // points to itself and has a return address of 0.
+      break;
+    }
+    void **next_fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(
+        fp, ucp, stack_low, stack_high);
+    if (skip_count > 0) {
+      skip_count--;
+    } else {
+      result[n] = *(fp + 1);
+      if (IS_STACK_FRAMES) {
+        if (next_fp > fp) {
+          sizes[n] = (uintptr_t)next_fp - (uintptr_t)fp;
+        } else {
+          // A frame-size of 0 is used to indicate unknown frame size.
+          sizes[n] = 0;
+        }
+      }
+      n++;
+    }
+    fp = next_fp;
+  }
+  if (min_dropped_frames != nullptr) {
+    // Implementation detail: we clamp the max of frames we are willing to
+    // count, so as not to spend too much time in the loop below.
+    const int kMaxUnwind = 1000;
+    int num_dropped_frames = 0;
+    for (int j = 0; fp != nullptr && j < kMaxUnwind; j++) {
+      if (skip_count > 0) {
+        skip_count--;
+      } else {
+        num_dropped_frames++;
+      }
+      fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(fp, ucp, stack_low,
+                                                             stack_high);
+    }
+    *min_dropped_frames = num_dropped_frames;
+  }
+  return n;
+}
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+  return true;
+}
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/symbolize.h b/CAPI/cpp/grpc/include/absl/debugging/internal/symbolize.h
new file mode 100644
index 0000000..27d5e65
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/symbolize.h
@@ -0,0 +1,153 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// This file contains internal parts of the Abseil symbolizer.
+// Do not depend on the anything in this file, it may change at anytime.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
+#define ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
+
+#ifdef __cplusplus
+
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/strings/string_view.h"
+
+#ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
+#error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
+#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) \
+      && !defined(__asmjs__) && !defined(__wasm__)
+#define ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1
+
+#include <elf.h>
+#include <link.h>  // For ElfW() macro.
+#include <functional>
+#include <string>
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// Iterates over all sections, invoking callback on each with the section name
+// and the section header.
+//
+// Returns true on success; otherwise returns false in case of errors.
+//
+// This is not async-signal-safe.
+bool ForEachSection(int fd,
+                    const std::function<bool(absl::string_view name,
+                                             const ElfW(Shdr) &)>& callback);
+
+// Gets the section header for the given name, if it exists. Returns true on
+// success. Otherwise, returns false.
+bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
+                            ElfW(Shdr) *out);
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
+
+#ifdef ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE
+#error ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE cannot be directly set
+#elif defined(__APPLE__)
+#define ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 1
+#endif
+
+#ifdef ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE
+#error ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE cannot be directly set
+#elif defined(__EMSCRIPTEN__)
+#define ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+struct SymbolDecoratorArgs {
+  // The program counter we are getting symbolic name for.
+  const void *pc;
+  // 0 for main executable, load address for shared libraries.
+  ptrdiff_t relocation;
+  // Read-only file descriptor for ELF image covering "pc",
+  // or -1 if no such ELF image exists in /proc/self/maps.
+  int fd;
+  // Output buffer, size.
+  // Note: the buffer may not be empty -- default symbolizer may have already
+  // produced some output, and earlier decorators may have adorned it in
+  // some way. You are free to replace or augment the contents (within the
+  // symbol_buf_size limit).
+  char *const symbol_buf;
+  size_t symbol_buf_size;
+  // Temporary scratch space, size.
+  // Use that space in preference to allocating your own stack buffer to
+  // conserve stack.
+  char *const tmp_buf;
+  size_t tmp_buf_size;
+  // User-provided argument
+  void* arg;
+};
+using SymbolDecorator = void (*)(const SymbolDecoratorArgs *);
+
+// Installs a function-pointer as a decorator. Returns a value less than zero
+// if the system cannot install the decorator. Otherwise, returns a unique
+// identifier corresponding to the decorator. This identifier can be used to
+// uninstall the decorator - See RemoveSymbolDecorator() below.
+int InstallSymbolDecorator(SymbolDecorator decorator, void* arg);
+
+// Removes a previously installed function-pointer decorator. Parameter "ticket"
+// is the return-value from calling InstallSymbolDecorator().
+bool RemoveSymbolDecorator(int ticket);
+
+// Remove all installed decorators.  Returns true if successful, false if
+// symbolization is currently in progress.
+bool RemoveAllSymbolDecorators(void);
+
+// Registers an address range to a file mapping.
+//
+// Preconditions:
+//   start <= end
+//   filename != nullptr
+//
+// Returns true if the file was successfully registered.
+bool RegisterFileMappingHint(const void* start, const void* end,
+                             uint64_t offset, const char* filename);
+
+// Looks up the file mapping registered by RegisterFileMappingHint for an
+// address range. If there is one, the file name is stored in *filename and
+// *start and *end are modified to reflect the registered mapping. Returns
+// whether any hint was found.
+bool GetFileMappingHint(const void** start, const void** end, uint64_t* offset,
+                        const char** filename);
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // __cplusplus
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C"
+#endif  // __cplusplus
+
+    bool
+    AbslInternalGetFileMappingHint(const void** start, const void** end,
+                                   uint64_t* offset, const char** filename);
+
+#endif  // ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/vdso_support.h b/CAPI/cpp/grpc/include/absl/debugging/internal/vdso_support.h
new file mode 100644
index 0000000..6562c6c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/vdso_support.h
@@ -0,0 +1,158 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+// Allow dynamic symbol lookup in the kernel VDSO page.
+//
+// VDSO stands for "Virtual Dynamic Shared Object" -- a page of
+// executable code, which looks like a shared library, but doesn't
+// necessarily exist anywhere on disk, and which gets mmap()ed into
+// every process by kernels which support VDSO, such as 2.6.x for 32-bit
+// executables, and 2.6.24 and above for 64-bit executables.
+//
+// More details could be found here:
+// http://www.trilithium.com/johan/2005/08/linux-gate/
+//
+// VDSOSupport -- a class representing kernel VDSO (if present).
+//
+// Example usage:
+//  VDSOSupport vdso;
+//  VDSOSupport::SymbolInfo info;
+//  typedef (*FN)(unsigned *, void *, void *);
+//  FN fn = nullptr;
+//  if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) {
+//     fn = reinterpret_cast<FN>(info.address);
+//  }
+
+#ifndef ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
+#define ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
+
+#include <atomic>
+
+#include "absl/base/attributes.h"
+#include "absl/debugging/internal/elf_mem_image.h"
+
+#ifdef ABSL_HAVE_ELF_MEM_IMAGE
+
+#ifdef ABSL_HAVE_VDSO_SUPPORT
+#error ABSL_HAVE_VDSO_SUPPORT cannot be directly set
+#else
+#define ABSL_HAVE_VDSO_SUPPORT 1
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace debugging_internal {
+
+// NOTE: this class may be used from within tcmalloc, and can not
+// use any memory allocation routines.
+class VDSOSupport {
+ public:
+  VDSOSupport();
+
+  typedef ElfMemImage::SymbolInfo SymbolInfo;
+  typedef ElfMemImage::SymbolIterator SymbolIterator;
+
+  // On PowerPC64 VDSO symbols can either be of type STT_FUNC or STT_NOTYPE
+  // depending on how the kernel is built.  The kernel is normally built with
+  // STT_NOTYPE type VDSO symbols.  Let's make things simpler first by using a
+  // compile-time constant.
+#ifdef __powerpc64__
+  enum { kVDSOSymbolType = STT_NOTYPE };
+#else
+  enum { kVDSOSymbolType = STT_FUNC };
+#endif
+
+  // Answers whether we have a vdso at all.
+  bool IsPresent() const { return image_.IsPresent(); }
+
+  // Allow to iterate over all VDSO symbols.
+  SymbolIterator begin() const { return image_.begin(); }
+  SymbolIterator end() const { return image_.end(); }
+
+  // Look up versioned dynamic symbol in the kernel VDSO.
+  // Returns false if VDSO is not present, or doesn't contain given
+  // symbol/version/type combination.
+  // If info_out != nullptr, additional details are filled in.
+  bool LookupSymbol(const char *name, const char *version,
+                    int symbol_type, SymbolInfo *info_out) const;
+
+  // Find info about symbol (if any) which overlaps given address.
+  // Returns true if symbol was found; false if VDSO isn't present
+  // or doesn't have a symbol overlapping given address.
+  // If info_out != nullptr, additional details are filled in.
+  bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const;
+
+  // Used only for testing. Replace real VDSO base with a mock.
+  // Returns previous value of vdso_base_. After you are done testing,
+  // you are expected to call SetBase() with previous value, in order to
+  // reset state to the way it was.
+  const void *SetBase(const void *s);
+
+  // Computes vdso_base_ and returns it. Should be called as early as
+  // possible; before any thread creation, chroot or setuid.
+  static const void *Init();
+
+ private:
+  // image_ represents VDSO ELF image in memory.
+  // image_.ehdr_ == nullptr implies there is no VDSO.
+  ElfMemImage image_;
+
+  // Cached value of auxv AT_SYSINFO_EHDR, computed once.
+  // This is a tri-state:
+  //   kInvalidBase   => value hasn't been determined yet.
+  //              0   => there is no VDSO.
+  //           else   => vma of VDSO Elf{32,64}_Ehdr.
+  //
+  // When testing with mock VDSO, low bit is set.
+  // The low bit is always available because vdso_base_ is
+  // page-aligned.
+  static std::atomic<const void *> vdso_base_;
+
+  // NOLINT on 'long' because these routines mimic kernel api.
+  // The 'cache' parameter may be used by some versions of the kernel,
+  // and should be nullptr or point to a static buffer containing at
+  // least two 'long's.
+  static long InitAndGetCPU(unsigned *cpu, void *cache,     // NOLINT 'long'.
+                            void *unused);
+  static long GetCPUViaSyscall(unsigned *cpu, void *cache,  // NOLINT 'long'.
+                               void *unused);
+  typedef long (*GetCpuFn)(unsigned *cpu, void *cache,      // NOLINT 'long'.
+                           void *unused);
+
+  // This function pointer may point to InitAndGetCPU,
+  // GetCPUViaSyscall, or __vdso_getcpu at different stages of initialization.
+  ABSL_CONST_INIT static std::atomic<GetCpuFn> getcpu_fn_;
+
+  friend int GetCPU(void);  // Needs access to getcpu_fn_.
+
+  VDSOSupport(const VDSOSupport&) = delete;
+  VDSOSupport& operator=(const VDSOSupport&) = delete;
+};
+
+// Same as sched_getcpu() on later glibc versions.
+// Return current CPU, using (fast) __vdso_getcpu@LINUX_2.6 if present,
+// otherwise use syscall(SYS_getcpu,...).
+// May return -1 with errno == ENOSYS if the kernel doesn't
+// support SYS_getcpu.
+int GetCPU();
+
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_HAVE_ELF_MEM_IMAGE
+
+#endif  // ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/leak_check.h b/CAPI/cpp/grpc/include/absl/debugging/leak_check.h
new file mode 100644
index 0000000..eff162f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/leak_check.h
@@ -0,0 +1,150 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: leak_check.h
+// -----------------------------------------------------------------------------
+//
+// This file contains functions that affect leak checking behavior within
+// targets built with the LeakSanitizer (LSan), a memory leak detector that is
+// integrated within the AddressSanitizer (ASan) as an additional component, or
+// which can be used standalone. LSan and ASan are included (or can be provided)
+// as additional components for most compilers such as Clang, gcc and MSVC.
+// Note: this leak checking API is not yet supported in MSVC.
+// Leak checking is enabled by default in all ASan builds.
+//
+// https://clang.llvm.org/docs/LeakSanitizer.html
+// https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer
+//
+// GCC and Clang both automatically enable LeakSanitizer when AddressSanitizer
+// is enabled. To use the mode, simply pass `-fsanitize=address` to both the
+// compiler and linker. An example Bazel command could be
+//
+//   $ bazel test --copt=-fsanitize=address --linkopt=-fsanitize=address ...
+//
+// GCC and Clang auto support a standalone LeakSanitizer mode (a mode which does
+// not also use AddressSanitizer). To use the mode, simply pass
+// `-fsanitize=leak` to both the compiler and linker. Since GCC does not
+// currently provide a way of detecting this mode at compile-time, GCC users
+// must also pass -DLEAK_SANIITIZER to the compiler. An example Bazel command
+// could be
+//
+//   $ bazel test --copt=-DLEAK_SANITIZER --copt=-fsanitize=leak
+//     --linkopt=-fsanitize=leak ...
+//
+// -----------------------------------------------------------------------------
+#ifndef ABSL_DEBUGGING_LEAK_CHECK_H_
+#define ABSL_DEBUGGING_LEAK_CHECK_H_
+
+#include <cstddef>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// HaveLeakSanitizer()
+//
+// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
+// currently built into this target.
+bool HaveLeakSanitizer();
+
+// LeakCheckerIsActive()
+//
+// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
+// currently built into this target and is turned on.
+bool LeakCheckerIsActive();
+
+// DoIgnoreLeak()
+//
+// Implements `IgnoreLeak()` below. This function should usually
+// not be called directly; calling `IgnoreLeak()` is preferred.
+void DoIgnoreLeak(const void* ptr);
+
+// IgnoreLeak()
+//
+// Instruct the leak sanitizer to ignore leak warnings on the object referenced
+// by the passed pointer, as well as all heap objects transitively referenced
+// by it. The passed object pointer can point to either the beginning of the
+// object or anywhere within it.
+//
+// Example:
+//
+//   static T* obj = IgnoreLeak(new T(...));
+//
+// If the passed `ptr` does not point to an actively allocated object at the
+// time `IgnoreLeak()` is called, the call is a no-op; if it is actively
+// allocated, leak sanitizer will assume this object is referenced even if
+// there is no actual reference in user memory.
+//
+template <typename T>
+T* IgnoreLeak(T* ptr) {
+  DoIgnoreLeak(ptr);
+  return ptr;
+}
+
+// FindAndReportLeaks()
+//
+// If any leaks are detected, prints a leak report and returns true.  This
+// function may be called repeatedly, and does not affect end-of-process leak
+// checking.
+//
+// Example:
+// if (FindAndReportLeaks()) {
+//   ... diagnostic already printed. Exit with failure code.
+//   exit(1)
+// }
+bool FindAndReportLeaks();
+
+// LeakCheckDisabler
+//
+// This helper class indicates that any heap allocations done in the code block
+// covered by the scoped object, which should be allocated on the stack, will
+// not be reported as leaks. Leak check disabling will occur within the code
+// block and any nested function calls within the code block.
+//
+// Example:
+//
+//   void Foo() {
+//     LeakCheckDisabler disabler;
+//     ... code that allocates objects whose leaks should be ignored ...
+//   }
+//
+// REQUIRES: Destructor runs in same thread as constructor
+class LeakCheckDisabler {
+ public:
+  LeakCheckDisabler();
+  LeakCheckDisabler(const LeakCheckDisabler&) = delete;
+  LeakCheckDisabler& operator=(const LeakCheckDisabler&) = delete;
+  ~LeakCheckDisabler();
+};
+
+// RegisterLivePointers()
+//
+// Registers `ptr[0,size-1]` as pointers to memory that is still actively being
+// referenced and for which leak checking should be ignored. This function is
+// useful if you store pointers in mapped memory, for memory ranges that we know
+// are correct but for which normal analysis would flag as leaked code.
+void RegisterLivePointers(const void* ptr, size_t size);
+
+// UnRegisterLivePointers()
+//
+// Deregisters the pointers previously marked as active in
+// `RegisterLivePointers()`, enabling leak checking of those pointers.
+void UnRegisterLivePointers(const void* ptr, size_t size);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_LEAK_CHECK_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/stacktrace.h b/CAPI/cpp/grpc/include/absl/debugging/stacktrace.h
new file mode 100644
index 0000000..0ec0ffd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/stacktrace.h
@@ -0,0 +1,231 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: stacktrace.h
+// -----------------------------------------------------------------------------
+//
+// This file contains routines to extract the current stack trace and associated
+// stack frames. These functions are thread-safe and async-signal-safe.
+//
+// Note that stack trace functionality is platform dependent and requires
+// additional support from the compiler/build system in most cases. (That is,
+// this functionality generally only works on platforms/builds that have been
+// specifically configured to support it.)
+//
+// Note: stack traces in Abseil that do not utilize a symbolizer will result in
+// frames consisting of function addresses rather than human-readable function
+// names. (See symbolize.h for information on symbolizing these values.)
+
+#ifndef ABSL_DEBUGGING_STACKTRACE_H_
+#define ABSL_DEBUGGING_STACKTRACE_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// GetStackFrames()
+//
+// Records program counter values for up to `max_depth` frames, skipping the
+// most recent `skip_count` stack frames, stores their corresponding values
+// and sizes in `results` and `sizes` buffers, and returns the number of frames
+// stored. (Note that the frame generated for the `absl::GetStackFrames()`
+// routine itself is also skipped.)
+//
+// Example:
+//
+//      main() { foo(); }
+//      foo() { bar(); }
+//      bar() {
+//        void* result[10];
+//        int sizes[10];
+//        int depth = absl::GetStackFrames(result, sizes, 10, 1);
+//      }
+//
+// The current stack frame would consist of three function calls: `bar()`,
+// `foo()`, and then `main()`; however, since the `GetStackFrames()` call sets
+// `skip_count` to `1`, it will skip the frame for `bar()`, the most recently
+// invoked function call. It will therefore return 2 and fill `result` with
+// program counters within the following functions:
+//
+//      result[0]       foo()
+//      result[1]       main()
+//
+// (Note: in practice, a few more entries after `main()` may be added to account
+// for startup processes.)
+//
+// Corresponding stack frame sizes will also be recorded:
+//
+//    sizes[0]       16
+//    sizes[1]       16
+//
+// (Stack frame sizes of `16` above are just for illustration purposes.)
+//
+// Stack frame sizes of 0 or less indicate that those frame sizes couldn't
+// be identified.
+//
+// This routine may return fewer stack frame entries than are
+// available. Also note that `result` and `sizes` must both be non-null.
+extern int GetStackFrames(void** result, int* sizes, int max_depth,
+                          int skip_count);
+
+// GetStackFramesWithContext()
+//
+// Records program counter values obtained from a signal handler. Records
+// program counter values for up to `max_depth` frames, skipping the most recent
+// `skip_count` stack frames, stores their corresponding values and sizes in
+// `results` and `sizes` buffers, and returns the number of frames stored. (Note
+// that the frame generated for the `absl::GetStackFramesWithContext()` routine
+// itself is also skipped.)
+//
+// The `uc` parameter, if non-null, should be a pointer to a `ucontext_t` value
+// passed to a signal handler registered via the `sa_sigaction` field of a
+// `sigaction` struct. (See
+// http://man7.org/linux/man-pages/man2/sigaction.2.html.) The `uc` value may
+// help a stack unwinder to provide a better stack trace under certain
+// conditions. `uc` may safely be null.
+//
+// The `min_dropped_frames` output parameter, if non-null, points to the
+// location to note any dropped stack frames, if any, due to buffer limitations
+// or other reasons. (This value will be set to `0` if no frames were dropped.)
+// The number of total stack frames is guaranteed to be >= skip_count +
+// max_depth + *min_dropped_frames.
+extern int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
+                                     int skip_count, const void* uc,
+                                     int* min_dropped_frames);
+
+// GetStackTrace()
+//
+// Records program counter values for up to `max_depth` frames, skipping the
+// most recent `skip_count` stack frames, stores their corresponding values
+// in `results`, and returns the number of frames
+// stored. Note that this function is similar to `absl::GetStackFrames()`
+// except that it returns the stack trace only, and not stack frame sizes.
+//
+// Example:
+//
+//      main() { foo(); }
+//      foo() { bar(); }
+//      bar() {
+//        void* result[10];
+//        int depth = absl::GetStackTrace(result, 10, 1);
+//      }
+//
+// This produces:
+//
+//      result[0]       foo
+//      result[1]       main
+//           ....       ...
+//
+// `result` must not be null.
+extern int GetStackTrace(void** result, int max_depth, int skip_count);
+
+// GetStackTraceWithContext()
+//
+// Records program counter values obtained from a signal handler. Records
+// program counter values for up to `max_depth` frames, skipping the most recent
+// `skip_count` stack frames, stores their corresponding values in `results`,
+// and returns the number of frames stored. (Note that the frame generated for
+// the `absl::GetStackFramesWithContext()` routine itself is also skipped.)
+//
+// The `uc` parameter, if non-null, should be a pointer to a `ucontext_t` value
+// passed to a signal handler registered via the `sa_sigaction` field of a
+// `sigaction` struct. (See
+// http://man7.org/linux/man-pages/man2/sigaction.2.html.) The `uc` value may
+// help a stack unwinder to provide a better stack trace under certain
+// conditions. `uc` may safely be null.
+//
+// The `min_dropped_frames` output parameter, if non-null, points to the
+// location to note any dropped stack frames, if any, due to buffer limitations
+// or other reasons. (This value will be set to `0` if no frames were dropped.)
+// The number of total stack frames is guaranteed to be >= skip_count +
+// max_depth + *min_dropped_frames.
+extern int GetStackTraceWithContext(void** result, int max_depth,
+                                    int skip_count, const void* uc,
+                                    int* min_dropped_frames);
+
+// SetStackUnwinder()
+//
+// Provides a custom function for unwinding stack frames that will be used in
+// place of the default stack unwinder when invoking the static
+// GetStack{Frames,Trace}{,WithContext}() functions above.
+//
+// The arguments passed to the unwinder function will match the
+// arguments passed to `absl::GetStackFramesWithContext()` except that sizes
+// will be non-null iff the caller is interested in frame sizes.
+//
+// If unwinder is set to null, we revert to the default stack-tracing behavior.
+//
+// *****************************************************************************
+// WARNING
+// *****************************************************************************
+//
+// absl::SetStackUnwinder is not suitable for general purpose use.  It is
+// provided for custom runtimes.
+// Some things to watch out for when calling `absl::SetStackUnwinder()`:
+//
+// (a) The unwinder may be called from within signal handlers and
+// therefore must be async-signal-safe.
+//
+// (b) Even after a custom stack unwinder has been unregistered, other
+// threads may still be in the process of using that unwinder.
+// Therefore do not clean up any state that may be needed by an old
+// unwinder.
+// *****************************************************************************
+extern void SetStackUnwinder(int (*unwinder)(void** pcs, int* sizes,
+                                             int max_depth, int skip_count,
+                                             const void* uc,
+                                             int* min_dropped_frames));
+
+// DefaultStackUnwinder()
+//
+// Records program counter values of up to `max_depth` frames, skipping the most
+// recent `skip_count` stack frames, and stores their corresponding values in
+// `pcs`. (Note that the frame generated for this call itself is also skipped.)
+// This function acts as a generic stack-unwinder; prefer usage of the more
+// specific `GetStack{Trace,Frames}{,WithContext}()` functions above.
+//
+// If you have set your own stack unwinder (with the `SetStackUnwinder()`
+// function above, you can still get the default stack unwinder by calling
+// `DefaultStackUnwinder()`, which will ignore any previously set stack unwinder
+// and use the default one instead.
+//
+// Because this function is generic, only `pcs` is guaranteed to be non-null
+// upon return. It is legal for `sizes`, `uc`, and `min_dropped_frames` to all
+// be null when called.
+//
+// The semantics are the same as the corresponding `GetStack*()` function in the
+// case where `absl::SetStackUnwinder()` was never called. Equivalents are:
+//
+//                       null sizes         |        non-nullptr sizes
+//             |==========================================================|
+//     null uc | GetStackTrace()            | GetStackFrames()            |
+// non-null uc | GetStackTraceWithContext() | GetStackFramesWithContext() |
+//             |==========================================================|
+extern int DefaultStackUnwinder(void** pcs, int* sizes, int max_depth,
+                                int skip_count, const void* uc,
+                                int* min_dropped_frames);
+
+namespace debugging_internal {
+// Returns true for platforms which are expected to have functioning stack trace
+// implementations. Intended to be used for tests which want to exclude
+// verification of logic known to be broken because stack traces are not
+// working.
+extern bool StackTraceWorksForTest();
+}  // namespace debugging_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_STACKTRACE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/symbolize.h b/CAPI/cpp/grpc/include/absl/debugging/symbolize.h
new file mode 100644
index 0000000..43d93a8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/symbolize.h
@@ -0,0 +1,99 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: symbolize.h
+// -----------------------------------------------------------------------------
+//
+// This file configures the Abseil symbolizer for use in converting instruction
+// pointer addresses (program counters) into human-readable names (function
+// calls, etc.) within Abseil code.
+//
+// The symbolizer may be invoked from several sources:
+//
+//   * Implicitly, through the installation of an Abseil failure signal handler.
+//     (See failure_signal_handler.h for more information.)
+//   * By calling `Symbolize()` directly on a program counter you obtain through
+//     `absl::GetStackTrace()` or `absl::GetStackFrames()`. (See stacktrace.h
+//     for more information.
+//   * By calling `Symbolize()` directly on a program counter you obtain through
+//     other means (which would be platform-dependent).
+//
+// In all of the above cases, the symbolizer must first be initialized before
+// any program counter values can be symbolized. If you are installing a failure
+// signal handler, initialize the symbolizer before you do so.
+//
+// Example:
+//
+//   int main(int argc, char** argv) {
+//     // Initialize the Symbolizer before installing the failure signal handler
+//     absl::InitializeSymbolizer(argv[0]);
+//
+//     // Now you may install the failure signal handler
+//     absl::FailureSignalHandlerOptions options;
+//     absl::InstallFailureSignalHandler(options);
+//
+//     // Start running your main program
+//     ...
+//     return 0;
+//  }
+//
+#ifndef ABSL_DEBUGGING_SYMBOLIZE_H_
+#define ABSL_DEBUGGING_SYMBOLIZE_H_
+
+#include "absl/debugging/internal/symbolize.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// InitializeSymbolizer()
+//
+// Initializes the program counter symbolizer, given the path of the program
+// (typically obtained through `main()`s `argv[0]`). The Abseil symbolizer
+// allows you to read program counters (instruction pointer values) using their
+// human-readable names within output such as stack traces.
+//
+// Example:
+//
+// int main(int argc, char *argv[]) {
+//   absl::InitializeSymbolizer(argv[0]);
+//   // Now you can use the symbolizer
+// }
+void InitializeSymbolizer(const char* argv0);
+//
+// Symbolize()
+//
+// Symbolizes a program counter (instruction pointer value) `pc` and, on
+// success, writes the name to `out`. The symbol name is demangled, if possible.
+// Note that the symbolized name may be truncated and will be NUL-terminated.
+// Demangling is supported for symbols generated by GCC 3.x or newer). Returns
+// `false` on failure.
+//
+// Example:
+//
+//   // Print a program counter and its symbol name.
+//   static void DumpPCAndSymbol(void *pc) {
+//     char tmp[1024];
+//     const char *symbol = "(unknown)";
+//     if (absl::Symbolize(pc, tmp, sizeof(tmp))) {
+//       symbol = tmp;
+//     }
+//     absl::PrintF("%p  %s\n", pc, symbol);
+//  }
+bool Symbolize(const void *pc, char *out, int out_size);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_DEBUGGING_SYMBOLIZE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/symbolize_darwin.inc b/CAPI/cpp/grpc/include/absl/debugging/symbolize_darwin.inc
new file mode 100644
index 0000000..443ce9e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/symbolize_darwin.inc
@@ -0,0 +1,101 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#include <cxxabi.h>
+#include <execinfo.h>
+
+#include <algorithm>
+#include <cstring>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/debugging/internal/demangle.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+void InitializeSymbolizer(const char*) {}
+
+namespace debugging_internal {
+namespace {
+
+static std::string GetSymbolString(absl::string_view backtrace_line) {
+  // Example Backtrace lines:
+  // 0   libimaging_shared.dylib             0x018c152a
+  // _ZNSt11_Deque_baseIN3nik7mediadb4PageESaIS2_EE17_M_initialize_mapEm + 3478
+  //
+  // or
+  // 0   libimaging_shared.dylib             0x0000000001895c39
+  // _ZN3nik4util19register_shared_ptrINS_3gpu7TextureEEEvPKvS5_ + 39
+  //
+  // or
+  // 0   mysterious_app                      0x0124000120120009 main + 17
+  auto address_pos = backtrace_line.find(" 0x");
+  if (address_pos == absl::string_view::npos) return std::string();
+  absl::string_view symbol_view = backtrace_line.substr(address_pos + 1);
+
+  auto space_pos = symbol_view.find(" ");
+  if (space_pos == absl::string_view::npos) return std::string();
+  symbol_view = symbol_view.substr(space_pos + 1);  // to mangled symbol
+
+  auto plus_pos = symbol_view.find(" + ");
+  if (plus_pos == absl::string_view::npos) return std::string();
+  symbol_view = symbol_view.substr(0, plus_pos);  // strip remainng
+
+  return std::string(symbol_view);
+}
+
+}  // namespace
+}  // namespace debugging_internal
+
+bool Symbolize(const void* pc, char* out, int out_size) {
+  if (out_size <= 0 || pc == nullptr) {
+    out = nullptr;
+    return false;
+  }
+
+  // This allocates a char* array.
+  char** frame_strings = backtrace_symbols(const_cast<void**>(&pc), 1);
+
+  if (frame_strings == nullptr) return false;
+
+  std::string symbol = debugging_internal::GetSymbolString(frame_strings[0]);
+  free(frame_strings);
+
+  char tmp_buf[1024];
+  if (debugging_internal::Demangle(symbol.c_str(), tmp_buf, sizeof(tmp_buf))) {
+    size_t len = strlen(tmp_buf);
+    if (len + 1 <= static_cast<size_t>(out_size)) {  // +1 for '\0'
+      assert(len < sizeof(tmp_buf));
+      memmove(out, tmp_buf, len + 1);
+    }
+  } else {
+    strncpy(out, symbol.c_str(), out_size);
+  }
+
+  if (out[out_size - 1] != '\0') {
+    // strncpy() does not '\0' terminate when it truncates.
+    static constexpr char kEllipsis[] = "...";
+    int ellipsis_size = std::min<int>(sizeof(kEllipsis) - 1, out_size - 1);
+    memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size);
+    out[out_size - 1] = '\0';
+  }
+
+  return true;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/CAPI/cpp/grpc/include/absl/debugging/symbolize_elf.inc b/CAPI/cpp/grpc/include/absl/debugging/symbolize_elf.inc
new file mode 100644
index 0000000..9bfdd91
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/symbolize_elf.inc
@@ -0,0 +1,1613 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// This library provides Symbolize() function that symbolizes program
+// counters to their corresponding symbol names on linux platforms.
+// This library has a minimal implementation of an ELF symbol table
+// reader (i.e. it doesn't depend on libelf, etc.).
+//
+// The algorithm used in Symbolize() is as follows.
+//
+//   1. Go through a list of maps in /proc/self/maps and find the map
+//   containing the program counter.
+//
+//   2. Open the mapped file and find a regular symbol table inside.
+//   Iterate over symbols in the symbol table and look for the symbol
+//   containing the program counter.  If such a symbol is found,
+//   obtain the symbol name, and demangle the symbol if possible.
+//   If the symbol isn't found in the regular symbol table (binary is
+//   stripped), try the same thing with a dynamic symbol table.
+//
+// Note that Symbolize() is originally implemented to be used in
+// signal handlers, hence it doesn't use malloc() and other unsafe
+// operations.  It should be both thread-safe and async-signal-safe.
+//
+// Implementation note:
+//
+// We don't use heaps but only use stacks.  We want to reduce the
+// stack consumption so that the symbolizer can run on small stacks.
+//
+// Here are some numbers collected with GCC 4.1.0 on x86:
+// - sizeof(Elf32_Sym)  = 16
+// - sizeof(Elf32_Shdr) = 40
+// - sizeof(Elf64_Sym)  = 24
+// - sizeof(Elf64_Shdr) = 64
+//
+// This implementation is intended to be async-signal-safe but uses some
+// functions which are not guaranteed to be so, such as memchr() and
+// memmove().  We assume they are async-signal-safe.
+
+#include <dlfcn.h>
+#include <elf.h>
+#include <fcntl.h>
+#include <link.h>  // For ElfW() macro.
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cerrno>
+#include <cinttypes>
+#include <climits>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "absl/base/casts.h"
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/low_level_alloc.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/port.h"
+#include "absl/debugging/internal/demangle.h"
+#include "absl/debugging/internal/vdso_support.h"
+#include "absl/strings/string_view.h"
+
+#if defined(__FreeBSD__) && !defined(ElfW)
+#define ElfW(x) __ElfN(x)
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Value of argv[0]. Used by MaybeInitializeObjFile().
+static char *argv0_value = nullptr;
+
+void InitializeSymbolizer(const char *argv0) {
+#ifdef ABSL_HAVE_VDSO_SUPPORT
+  // We need to make sure VDSOSupport::Init() is called before any setuid or
+  // chroot calls, so InitializeSymbolizer() should be called very early in the
+  // life of a program.
+  absl::debugging_internal::VDSOSupport::Init();
+#endif
+  if (argv0_value != nullptr) {
+    free(argv0_value);
+    argv0_value = nullptr;
+  }
+  if (argv0 != nullptr && argv0[0] != '\0') {
+    argv0_value = strdup(argv0);
+  }
+}
+
+namespace debugging_internal {
+namespace {
+
+// Re-runs fn until it doesn't cause EINTR.
+#define NO_INTR(fn) \
+  do {              \
+  } while ((fn) < 0 && errno == EINTR)
+
+// On Linux, ELF_ST_* are defined in <linux/elf.h>.  To make this portable
+// we define our own ELF_ST_BIND and ELF_ST_TYPE if not available.
+#ifndef ELF_ST_BIND
+#define ELF_ST_BIND(info) (((unsigned char)(info)) >> 4)
+#endif
+
+#ifndef ELF_ST_TYPE
+#define ELF_ST_TYPE(info) (((unsigned char)(info)) & 0xF)
+#endif
+
+// Some platforms use a special .opd section to store function pointers.
+const char kOpdSectionName[] = ".opd";
+
+#if (defined(__powerpc__) && !(_CALL_ELF > 1)) || defined(__ia64)
+// Use opd section for function descriptors on these platforms, the function
+// address is the first word of the descriptor.
+enum { kPlatformUsesOPDSections = 1 };
+#else  // not PPC or IA64
+enum { kPlatformUsesOPDSections = 0 };
+#endif
+
+// This works for PowerPC & IA64 only.  A function descriptor consist of two
+// pointers and the first one is the function's entry.
+const size_t kFunctionDescriptorSize = sizeof(void *) * 2;
+
+const int kMaxDecorators = 10;  // Seems like a reasonable upper limit.
+
+struct InstalledSymbolDecorator {
+  SymbolDecorator fn;
+  void *arg;
+  int ticket;
+};
+
+int g_num_decorators;
+InstalledSymbolDecorator g_decorators[kMaxDecorators];
+
+struct FileMappingHint {
+  const void *start;
+  const void *end;
+  uint64_t offset;
+  const char *filename;
+};
+
+// Protects g_decorators.
+// We are using SpinLock and not a Mutex here, because we may be called
+// from inside Mutex::Lock itself, and it prohibits recursive calls.
+// This happens in e.g. base/stacktrace_syscall_unittest.
+// Moreover, we are using only TryLock(), if the decorator list
+// is being modified (is busy), we skip all decorators, and possibly
+// loose some info. Sorry, that's the best we could do.
+ABSL_CONST_INIT absl::base_internal::SpinLock g_decorators_mu(
+    absl::kConstInit, absl::base_internal::SCHEDULE_KERNEL_ONLY);
+
+const int kMaxFileMappingHints = 8;
+int g_num_file_mapping_hints;
+FileMappingHint g_file_mapping_hints[kMaxFileMappingHints];
+// Protects g_file_mapping_hints.
+ABSL_CONST_INIT absl::base_internal::SpinLock g_file_mapping_mu(
+    absl::kConstInit, absl::base_internal::SCHEDULE_KERNEL_ONLY);
+
+// Async-signal-safe function to zero a buffer.
+// memset() is not guaranteed to be async-signal-safe.
+static void SafeMemZero(void* p, size_t size) {
+  unsigned char *c = static_cast<unsigned char *>(p);
+  while (size--) {
+    *c++ = 0;
+  }
+}
+
+struct ObjFile {
+  ObjFile()
+      : filename(nullptr),
+        start_addr(nullptr),
+        end_addr(nullptr),
+        offset(0),
+        fd(-1),
+        elf_type(-1) {
+    SafeMemZero(&elf_header, sizeof(elf_header));
+    SafeMemZero(&phdr[0], sizeof(phdr));
+  }
+
+  char *filename;
+  const void *start_addr;
+  const void *end_addr;
+  uint64_t offset;
+
+  // The following fields are initialized on the first access to the
+  // object file.
+  int fd;
+  int elf_type;
+  ElfW(Ehdr) elf_header;
+
+  // PT_LOAD program header describing executable code.
+  // Normally we expect just one, but SWIFT binaries have two.
+  std::array<ElfW(Phdr), 2> phdr;
+};
+
+// Build 4-way associative cache for symbols. Within each cache line, symbols
+// are replaced in LRU order.
+enum {
+  ASSOCIATIVITY = 4,
+};
+struct SymbolCacheLine {
+  const void *pc[ASSOCIATIVITY];
+  char *name[ASSOCIATIVITY];
+
+  // age[i] is incremented when a line is accessed. it's reset to zero if the
+  // i'th entry is read.
+  uint32_t age[ASSOCIATIVITY];
+};
+
+// ---------------------------------------------------------------
+// An async-signal-safe arena for LowLevelAlloc
+static std::atomic<base_internal::LowLevelAlloc::Arena *> g_sig_safe_arena;
+
+static base_internal::LowLevelAlloc::Arena *SigSafeArena() {
+  return g_sig_safe_arena.load(std::memory_order_acquire);
+}
+
+static void InitSigSafeArena() {
+  if (SigSafeArena() == nullptr) {
+    base_internal::LowLevelAlloc::Arena *new_arena =
+        base_internal::LowLevelAlloc::NewArena(
+            base_internal::LowLevelAlloc::kAsyncSignalSafe);
+    base_internal::LowLevelAlloc::Arena *old_value = nullptr;
+    if (!g_sig_safe_arena.compare_exchange_strong(old_value, new_arena,
+                                                  std::memory_order_release,
+                                                  std::memory_order_relaxed)) {
+      // We lost a race to allocate an arena; deallocate.
+      base_internal::LowLevelAlloc::DeleteArena(new_arena);
+    }
+  }
+}
+
+// ---------------------------------------------------------------
+// An AddrMap is a vector of ObjFile, using SigSafeArena() for allocation.
+
+class AddrMap {
+ public:
+  AddrMap() : size_(0), allocated_(0), obj_(nullptr) {}
+  ~AddrMap() { base_internal::LowLevelAlloc::Free(obj_); }
+  int Size() const { return size_; }
+  ObjFile *At(int i) { return &obj_[i]; }
+  ObjFile *Add();
+  void Clear();
+
+ private:
+  int size_;       // count of valid elements (<= allocated_)
+  int allocated_;  // count of allocated elements
+  ObjFile *obj_;   // array of allocated_ elements
+  AddrMap(const AddrMap &) = delete;
+  AddrMap &operator=(const AddrMap &) = delete;
+};
+
+void AddrMap::Clear() {
+  for (int i = 0; i != size_; i++) {
+    At(i)->~ObjFile();
+  }
+  size_ = 0;
+}
+
+ObjFile *AddrMap::Add() {
+  if (size_ == allocated_) {
+    int new_allocated = allocated_ * 2 + 50;
+    ObjFile *new_obj_ =
+        static_cast<ObjFile *>(base_internal::LowLevelAlloc::AllocWithArena(
+            new_allocated * sizeof(*new_obj_), SigSafeArena()));
+    if (obj_) {
+      memcpy(new_obj_, obj_, allocated_ * sizeof(*new_obj_));
+      base_internal::LowLevelAlloc::Free(obj_);
+    }
+    obj_ = new_obj_;
+    allocated_ = new_allocated;
+  }
+  return new (&obj_[size_++]) ObjFile;
+}
+
+// ---------------------------------------------------------------
+
+enum FindSymbolResult { SYMBOL_NOT_FOUND = 1, SYMBOL_TRUNCATED, SYMBOL_FOUND };
+
+class Symbolizer {
+ public:
+  Symbolizer();
+  ~Symbolizer();
+  const char *GetSymbol(const void *const pc);
+
+ private:
+  char *CopyString(const char *s) {
+    int len = strlen(s);
+    char *dst = static_cast<char *>(
+        base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
+    ABSL_RAW_CHECK(dst != nullptr, "out of memory");
+    memcpy(dst, s, len + 1);
+    return dst;
+  }
+  ObjFile *FindObjFile(const void *const start,
+                       size_t size) ABSL_ATTRIBUTE_NOINLINE;
+  static bool RegisterObjFile(const char *filename,
+                              const void *const start_addr,
+                              const void *const end_addr, uint64_t offset,
+                              void *arg);
+  SymbolCacheLine *GetCacheLine(const void *const pc);
+  const char *FindSymbolInCache(const void *const pc);
+  const char *InsertSymbolInCache(const void *const pc, const char *name);
+  void AgeSymbols(SymbolCacheLine *line);
+  void ClearAddrMap();
+  FindSymbolResult GetSymbolFromObjectFile(const ObjFile &obj,
+                                           const void *const pc,
+                                           const ptrdiff_t relocation,
+                                           char *out, int out_size,
+                                           char *tmp_buf, int tmp_buf_size);
+  const char *GetUncachedSymbol(const void *pc);
+
+  enum {
+    SYMBOL_BUF_SIZE = 3072,
+    TMP_BUF_SIZE = 1024,
+    SYMBOL_CACHE_LINES = 128,
+  };
+
+  AddrMap addr_map_;
+
+  bool ok_;
+  bool addr_map_read_;
+
+  char symbol_buf_[SYMBOL_BUF_SIZE];
+
+  // tmp_buf_ will be used to store arrays of ElfW(Shdr) and ElfW(Sym)
+  // so we ensure that tmp_buf_ is properly aligned to store either.
+  alignas(16) char tmp_buf_[TMP_BUF_SIZE];
+  static_assert(alignof(ElfW(Shdr)) <= 16,
+                "alignment of tmp buf too small for Shdr");
+  static_assert(alignof(ElfW(Sym)) <= 16,
+                "alignment of tmp buf too small for Sym");
+
+  SymbolCacheLine symbol_cache_[SYMBOL_CACHE_LINES];
+};
+
+static std::atomic<Symbolizer *> g_cached_symbolizer;
+
+}  // namespace
+
+static int SymbolizerSize() {
+#if defined(__wasm__) || defined(__asmjs__)
+  int pagesize = getpagesize();
+#else
+  int pagesize = sysconf(_SC_PAGESIZE);
+#endif
+  return ((sizeof(Symbolizer) - 1) / pagesize + 1) * pagesize;
+}
+
+// Return (and set null) g_cached_symbolized_state if it is not null.
+// Otherwise return a new symbolizer.
+static Symbolizer *AllocateSymbolizer() {
+  InitSigSafeArena();
+  Symbolizer *symbolizer =
+      g_cached_symbolizer.exchange(nullptr, std::memory_order_acquire);
+  if (symbolizer != nullptr) {
+    return symbolizer;
+  }
+  return new (base_internal::LowLevelAlloc::AllocWithArena(
+      SymbolizerSize(), SigSafeArena())) Symbolizer();
+}
+
+// Set g_cached_symbolize_state to s if it is null, otherwise
+// delete s.
+static void FreeSymbolizer(Symbolizer *s) {
+  Symbolizer *old_cached_symbolizer = nullptr;
+  if (!g_cached_symbolizer.compare_exchange_strong(old_cached_symbolizer, s,
+                                                   std::memory_order_release,
+                                                   std::memory_order_relaxed)) {
+    s->~Symbolizer();
+    base_internal::LowLevelAlloc::Free(s);
+  }
+}
+
+Symbolizer::Symbolizer() : ok_(true), addr_map_read_(false) {
+  for (SymbolCacheLine &symbol_cache_line : symbol_cache_) {
+    for (size_t j = 0; j < ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) {
+      symbol_cache_line.pc[j] = nullptr;
+      symbol_cache_line.name[j] = nullptr;
+      symbol_cache_line.age[j] = 0;
+    }
+  }
+}
+
+Symbolizer::~Symbolizer() {
+  for (SymbolCacheLine &symbol_cache_line : symbol_cache_) {
+    for (char *s : symbol_cache_line.name) {
+      base_internal::LowLevelAlloc::Free(s);
+    }
+  }
+  ClearAddrMap();
+}
+
+// We don't use assert() since it's not guaranteed to be
+// async-signal-safe.  Instead we define a minimal assertion
+// macro. So far, we don't need pretty printing for __FILE__, etc.
+#define SAFE_ASSERT(expr) ((expr) ? static_cast<void>(0) : abort())
+
+// Read up to "count" bytes from file descriptor "fd" into the buffer
+// starting at "buf" while handling short reads and EINTR.  On
+// success, return the number of bytes read.  Otherwise, return -1.
+static ssize_t ReadPersistent(int fd, void *buf, size_t count) {
+  SAFE_ASSERT(fd >= 0);
+  SAFE_ASSERT(count <= SSIZE_MAX);
+  char *buf0 = reinterpret_cast<char *>(buf);
+  size_t num_bytes = 0;
+  while (num_bytes < count) {
+    ssize_t len;
+    NO_INTR(len = read(fd, buf0 + num_bytes, count - num_bytes));
+    if (len < 0) {  // There was an error other than EINTR.
+      ABSL_RAW_LOG(WARNING, "read failed: errno=%d", errno);
+      return -1;
+    }
+    if (len == 0) {  // Reached EOF.
+      break;
+    }
+    num_bytes += len;
+  }
+  SAFE_ASSERT(num_bytes <= count);
+  return static_cast<ssize_t>(num_bytes);
+}
+
+// Read up to "count" bytes from "offset" in the file pointed by file
+// descriptor "fd" into the buffer starting at "buf".  On success,
+// return the number of bytes read.  Otherwise, return -1.
+static ssize_t ReadFromOffset(const int fd, void *buf, const size_t count,
+                              const off_t offset) {
+  off_t off = lseek(fd, offset, SEEK_SET);
+  if (off == (off_t)-1) {
+    ABSL_RAW_LOG(WARNING, "lseek(%d, %ju, SEEK_SET) failed: errno=%d", fd,
+                 static_cast<uintmax_t>(offset), errno);
+    return -1;
+  }
+  return ReadPersistent(fd, buf, count);
+}
+
+// Try reading exactly "count" bytes from "offset" bytes in a file
+// pointed by "fd" into the buffer starting at "buf" while handling
+// short reads and EINTR.  On success, return true. Otherwise, return
+// false.
+static bool ReadFromOffsetExact(const int fd, void *buf, const size_t count,
+                                const off_t offset) {
+  ssize_t len = ReadFromOffset(fd, buf, count, offset);
+  return len >= 0 && static_cast<size_t>(len) == count;
+}
+
+// Returns elf_header.e_type if the file pointed by fd is an ELF binary.
+static int FileGetElfType(const int fd) {
+  ElfW(Ehdr) elf_header;
+  if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
+    return -1;
+  }
+  if (memcmp(elf_header.e_ident, ELFMAG, SELFMAG) != 0) {
+    return -1;
+  }
+  return elf_header.e_type;
+}
+
+// Read the section headers in the given ELF binary, and if a section
+// of the specified type is found, set the output to this section header
+// and return true.  Otherwise, return false.
+// To keep stack consumption low, we would like this function to not get
+// inlined.
+static ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(
+    const int fd, ElfW(Half) sh_num, const off_t sh_offset, ElfW(Word) type,
+    ElfW(Shdr) * out, char *tmp_buf, int tmp_buf_size) {
+  ElfW(Shdr) *buf = reinterpret_cast<ElfW(Shdr) *>(tmp_buf);
+  const int buf_entries = tmp_buf_size / sizeof(buf[0]);
+  const int buf_bytes = buf_entries * sizeof(buf[0]);
+
+  for (int i = 0; i < sh_num;) {
+    const ssize_t num_bytes_left = (sh_num - i) * sizeof(buf[0]);
+    const ssize_t num_bytes_to_read =
+        (buf_bytes > num_bytes_left) ? num_bytes_left : buf_bytes;
+    const off_t offset = sh_offset + i * sizeof(buf[0]);
+    const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read, offset);
+    if (len % sizeof(buf[0]) != 0) {
+      ABSL_RAW_LOG(
+          WARNING,
+          "Reading %zd bytes from offset %ju returned %zd which is not a "
+          "multiple of %zu.",
+          num_bytes_to_read, static_cast<uintmax_t>(offset), len,
+          sizeof(buf[0]));
+      return false;
+    }
+    const ssize_t num_headers_in_buf = len / sizeof(buf[0]);
+    SAFE_ASSERT(num_headers_in_buf <= buf_entries);
+    for (int j = 0; j < num_headers_in_buf; ++j) {
+      if (buf[j].sh_type == type) {
+        *out = buf[j];
+        return true;
+      }
+    }
+    i += num_headers_in_buf;
+  }
+  return false;
+}
+
+// There is no particular reason to limit section name to 63 characters,
+// but there has (as yet) been no need for anything longer either.
+const int kMaxSectionNameLen = 64;
+
+bool ForEachSection(int fd,
+                    const std::function<bool(absl::string_view name,
+                                             const ElfW(Shdr) &)> &callback) {
+  ElfW(Ehdr) elf_header;
+  if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
+    return false;
+  }
+
+  ElfW(Shdr) shstrtab;
+  off_t shstrtab_offset =
+      (elf_header.e_shoff + elf_header.e_shentsize * elf_header.e_shstrndx);
+  if (!ReadFromOffsetExact(fd, &shstrtab, sizeof(shstrtab), shstrtab_offset)) {
+    return false;
+  }
+
+  for (int i = 0; i < elf_header.e_shnum; ++i) {
+    ElfW(Shdr) out;
+    off_t section_header_offset =
+        (elf_header.e_shoff + elf_header.e_shentsize * i);
+    if (!ReadFromOffsetExact(fd, &out, sizeof(out), section_header_offset)) {
+      return false;
+    }
+    off_t name_offset = shstrtab.sh_offset + out.sh_name;
+    char header_name[kMaxSectionNameLen];
+    ssize_t n_read =
+        ReadFromOffset(fd, &header_name, kMaxSectionNameLen, name_offset);
+    if (n_read == -1) {
+      return false;
+    } else if (n_read > kMaxSectionNameLen) {
+      // Long read?
+      return false;
+    }
+
+    absl::string_view name(header_name, strnlen(header_name, n_read));
+    if (!callback(name, out)) {
+      break;
+    }
+  }
+  return true;
+}
+
+// name_len should include terminating '\0'.
+bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
+                            ElfW(Shdr) * out) {
+  char header_name[kMaxSectionNameLen];
+  if (sizeof(header_name) < name_len) {
+    ABSL_RAW_LOG(WARNING,
+                 "Section name '%s' is too long (%zu); "
+                 "section will not be found (even if present).",
+                 name, name_len);
+    // No point in even trying.
+    return false;
+  }
+
+  ElfW(Ehdr) elf_header;
+  if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
+    return false;
+  }
+
+  ElfW(Shdr) shstrtab;
+  off_t shstrtab_offset =
+      (elf_header.e_shoff + elf_header.e_shentsize * elf_header.e_shstrndx);
+  if (!ReadFromOffsetExact(fd, &shstrtab, sizeof(shstrtab), shstrtab_offset)) {
+    return false;
+  }
+
+  for (int i = 0; i < elf_header.e_shnum; ++i) {
+    off_t section_header_offset =
+        (elf_header.e_shoff + elf_header.e_shentsize * i);
+    if (!ReadFromOffsetExact(fd, out, sizeof(*out), section_header_offset)) {
+      return false;
+    }
+    off_t name_offset = shstrtab.sh_offset + out->sh_name;
+    ssize_t n_read = ReadFromOffset(fd, &header_name, name_len, name_offset);
+    if (n_read < 0) {
+      return false;
+    } else if (static_cast<size_t>(n_read) != name_len) {
+      // Short read -- name could be at end of file.
+      continue;
+    }
+    if (memcmp(header_name, name, name_len) == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Compare symbols at in the same address.
+// Return true if we should pick symbol1.
+static bool ShouldPickFirstSymbol(const ElfW(Sym) & symbol1,
+                                  const ElfW(Sym) & symbol2) {
+  // If one of the symbols is weak and the other is not, pick the one
+  // this is not a weak symbol.
+  char bind1 = ELF_ST_BIND(symbol1.st_info);
+  char bind2 = ELF_ST_BIND(symbol1.st_info);
+  if (bind1 == STB_WEAK && bind2 != STB_WEAK) return false;
+  if (bind2 == STB_WEAK && bind1 != STB_WEAK) return true;
+
+  // If one of the symbols has zero size and the other is not, pick the
+  // one that has non-zero size.
+  if (symbol1.st_size != 0 && symbol2.st_size == 0) {
+    return true;
+  }
+  if (symbol1.st_size == 0 && symbol2.st_size != 0) {
+    return false;
+  }
+
+  // If one of the symbols has no type and the other is not, pick the
+  // one that has a type.
+  char type1 = ELF_ST_TYPE(symbol1.st_info);
+  char type2 = ELF_ST_TYPE(symbol1.st_info);
+  if (type1 != STT_NOTYPE && type2 == STT_NOTYPE) {
+    return true;
+  }
+  if (type1 == STT_NOTYPE && type2 != STT_NOTYPE) {
+    return false;
+  }
+
+  // Pick the first one, if we still cannot decide.
+  return true;
+}
+
+// Return true if an address is inside a section.
+static bool InSection(const void *address, const ElfW(Shdr) * section) {
+  const char *start = reinterpret_cast<const char *>(section->sh_addr);
+  size_t size = static_cast<size_t>(section->sh_size);
+  return start <= address && address < (start + size);
+}
+
+static const char *ComputeOffset(const char *base, ptrdiff_t offset) {
+  // Note: cast to uintptr_t to avoid undefined behavior when base evaluates to
+  // zero and offset is non-zero.
+  return reinterpret_cast<const char *>(
+      reinterpret_cast<uintptr_t>(base) + offset);
+}
+
+// Read a symbol table and look for the symbol containing the
+// pc. Iterate over symbols in a symbol table and look for the symbol
+// containing "pc".  If the symbol is found, and its name fits in
+// out_size, the name is written into out and SYMBOL_FOUND is returned.
+// If the name does not fit, truncated name is written into out,
+// and SYMBOL_TRUNCATED is returned. Out is NUL-terminated.
+// If the symbol is not found, SYMBOL_NOT_FOUND is returned;
+// To keep stack consumption low, we would like this function to not get
+// inlined.
+static ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol(
+    const void *const pc, const int fd, char *out, int out_size,
+    ptrdiff_t relocation, const ElfW(Shdr) * strtab, const ElfW(Shdr) * symtab,
+    const ElfW(Shdr) * opd, char *tmp_buf, int tmp_buf_size) {
+  if (symtab == nullptr) {
+    return SYMBOL_NOT_FOUND;
+  }
+
+  // Read multiple symbols at once to save read() calls.
+  ElfW(Sym) *buf = reinterpret_cast<ElfW(Sym) *>(tmp_buf);
+  const int buf_entries = tmp_buf_size / sizeof(buf[0]);
+
+  const int num_symbols = symtab->sh_size / symtab->sh_entsize;
+
+  // On platforms using an .opd section (PowerPC & IA64), a function symbol
+  // has the address of a function descriptor, which contains the real
+  // starting address.  However, we do not always want to use the real
+  // starting address because we sometimes want to symbolize a function
+  // pointer into the .opd section, e.g. FindSymbol(&foo,...).
+  const bool pc_in_opd =
+      kPlatformUsesOPDSections && opd != nullptr && InSection(pc, opd);
+  const bool deref_function_descriptor_pointer =
+      kPlatformUsesOPDSections && opd != nullptr && !pc_in_opd;
+
+  ElfW(Sym) best_match;
+  SafeMemZero(&best_match, sizeof(best_match));
+  bool found_match = false;
+  for (int i = 0; i < num_symbols;) {
+    off_t offset = symtab->sh_offset + i * symtab->sh_entsize;
+    const int num_remaining_symbols = num_symbols - i;
+    const int entries_in_chunk = std::min(num_remaining_symbols, buf_entries);
+    const int bytes_in_chunk = entries_in_chunk * sizeof(buf[0]);
+    const ssize_t len = ReadFromOffset(fd, buf, bytes_in_chunk, offset);
+    SAFE_ASSERT(len % sizeof(buf[0]) == 0);
+    const ssize_t num_symbols_in_buf = len / sizeof(buf[0]);
+    SAFE_ASSERT(num_symbols_in_buf <= entries_in_chunk);
+    for (int j = 0; j < num_symbols_in_buf; ++j) {
+      const ElfW(Sym) &symbol = buf[j];
+
+      // For a DSO, a symbol address is relocated by the loading address.
+      // We keep the original address for opd redirection below.
+      const char *const original_start_address =
+          reinterpret_cast<const char *>(symbol.st_value);
+      const char *start_address =
+          ComputeOffset(original_start_address, relocation);
+
+#ifdef __arm__
+      // ARM functions are always aligned to multiples of two bytes; the
+      // lowest-order bit in start_address is ignored by the CPU and indicates
+      // whether the function contains ARM (0) or Thumb (1) code. We don't care
+      // about what encoding is being used; we just want the real start address
+      // of the function.
+      start_address = reinterpret_cast<const char *>(
+          reinterpret_cast<uintptr_t>(start_address) & ~1);
+#endif
+
+      if (deref_function_descriptor_pointer &&
+          InSection(original_start_address, opd)) {
+        // The opd section is mapped into memory.  Just dereference
+        // start_address to get the first double word, which points to the
+        // function entry.
+        start_address = *reinterpret_cast<const char *const *>(start_address);
+      }
+
+      // If pc is inside the .opd section, it points to a function descriptor.
+      const size_t size = pc_in_opd ? kFunctionDescriptorSize : symbol.st_size;
+      const void *const end_address = ComputeOffset(start_address, size);
+      if (symbol.st_value != 0 &&  // Skip null value symbols.
+          symbol.st_shndx != 0 &&  // Skip undefined symbols.
+#ifdef STT_TLS
+          ELF_ST_TYPE(symbol.st_info) != STT_TLS &&  // Skip thread-local data.
+#endif                                               // STT_TLS
+          ((start_address <= pc && pc < end_address) ||
+           (start_address == pc && pc == end_address))) {
+        if (!found_match || ShouldPickFirstSymbol(symbol, best_match)) {
+          found_match = true;
+          best_match = symbol;
+        }
+      }
+    }
+    i += num_symbols_in_buf;
+  }
+
+  if (found_match) {
+    const size_t off = strtab->sh_offset + best_match.st_name;
+    const ssize_t n_read = ReadFromOffset(fd, out, out_size, off);
+    if (n_read <= 0) {
+      // This should never happen.
+      ABSL_RAW_LOG(WARNING,
+                   "Unable to read from fd %d at offset %zu: n_read = %zd", fd,
+                   off, n_read);
+      return SYMBOL_NOT_FOUND;
+    }
+    ABSL_RAW_CHECK(n_read <= out_size, "ReadFromOffset read too much data.");
+
+    // strtab->sh_offset points into .strtab-like section that contains
+    // NUL-terminated strings: '\0foo\0barbaz\0...".
+    //
+    // sh_offset+st_name points to the start of symbol name, but we don't know
+    // how long the symbol is, so we try to read as much as we have space for,
+    // and usually over-read (i.e. there is a NUL somewhere before n_read).
+    if (memchr(out, '\0', n_read) == nullptr) {
+      // Either out_size was too small (n_read == out_size and no NUL), or
+      // we tried to read past the EOF (n_read < out_size) and .strtab is
+      // corrupt (missing terminating NUL; should never happen for valid ELF).
+      out[n_read - 1] = '\0';
+      return SYMBOL_TRUNCATED;
+    }
+    return SYMBOL_FOUND;
+  }
+
+  return SYMBOL_NOT_FOUND;
+}
+
+// Get the symbol name of "pc" from the file pointed by "fd".  Process
+// both regular and dynamic symbol tables if necessary.
+// See FindSymbol() comment for description of return value.
+FindSymbolResult Symbolizer::GetSymbolFromObjectFile(
+    const ObjFile &obj, const void *const pc, const ptrdiff_t relocation,
+    char *out, int out_size, char *tmp_buf, int tmp_buf_size) {
+  ElfW(Shdr) symtab;
+  ElfW(Shdr) strtab;
+  ElfW(Shdr) opd;
+  ElfW(Shdr) *opd_ptr = nullptr;
+
+  // On platforms using an .opd sections for function descriptor, read
+  // the section header.  The .opd section is in data segment and should be
+  // loaded but we check that it is mapped just to be extra careful.
+  if (kPlatformUsesOPDSections) {
+    if (GetSectionHeaderByName(obj.fd, kOpdSectionName,
+                               sizeof(kOpdSectionName) - 1, &opd) &&
+        FindObjFile(reinterpret_cast<const char *>(opd.sh_addr) + relocation,
+                    opd.sh_size) != nullptr) {
+      opd_ptr = &opd;
+    } else {
+      return SYMBOL_NOT_FOUND;
+    }
+  }
+
+  // Consult a regular symbol table, then fall back to the dynamic symbol table.
+  for (const auto symbol_table_type : {SHT_SYMTAB, SHT_DYNSYM}) {
+    if (!GetSectionHeaderByType(obj.fd, obj.elf_header.e_shnum,
+                                obj.elf_header.e_shoff, symbol_table_type,
+                                &symtab, tmp_buf, tmp_buf_size)) {
+      continue;
+    }
+    if (!ReadFromOffsetExact(
+            obj.fd, &strtab, sizeof(strtab),
+            obj.elf_header.e_shoff + symtab.sh_link * sizeof(symtab))) {
+      continue;
+    }
+    const FindSymbolResult rc =
+        FindSymbol(pc, obj.fd, out, out_size, relocation, &strtab, &symtab,
+                   opd_ptr, tmp_buf, tmp_buf_size);
+    if (rc != SYMBOL_NOT_FOUND) {
+      return rc;
+    }
+  }
+
+  return SYMBOL_NOT_FOUND;
+}
+
+namespace {
+// Thin wrapper around a file descriptor so that the file descriptor
+// gets closed for sure.
+class FileDescriptor {
+ public:
+  explicit FileDescriptor(int fd) : fd_(fd) {}
+  FileDescriptor(const FileDescriptor &) = delete;
+  FileDescriptor &operator=(const FileDescriptor &) = delete;
+
+  ~FileDescriptor() {
+    if (fd_ >= 0) {
+      NO_INTR(close(fd_));
+    }
+  }
+
+  int get() const { return fd_; }
+
+ private:
+  const int fd_;
+};
+
+// Helper class for reading lines from file.
+//
+// Note: we don't use ProcMapsIterator since the object is big (it has
+// a 5k array member) and uses async-unsafe functions such as sscanf()
+// and snprintf().
+class LineReader {
+ public:
+  explicit LineReader(int fd, char *buf, int buf_len)
+      : fd_(fd),
+        buf_len_(buf_len),
+        buf_(buf),
+        bol_(buf),
+        eol_(buf),
+        eod_(buf) {}
+
+  LineReader(const LineReader &) = delete;
+  LineReader &operator=(const LineReader &) = delete;
+
+  // Read '\n'-terminated line from file.  On success, modify "bol"
+  // and "eol", then return true.  Otherwise, return false.
+  //
+  // Note: if the last line doesn't end with '\n', the line will be
+  // dropped.  It's an intentional behavior to make the code simple.
+  bool ReadLine(const char **bol, const char **eol) {
+    if (BufferIsEmpty()) {  // First time.
+      const ssize_t num_bytes = ReadPersistent(fd_, buf_, buf_len_);
+      if (num_bytes <= 0) {  // EOF or error.
+        return false;
+      }
+      eod_ = buf_ + num_bytes;
+      bol_ = buf_;
+    } else {
+      bol_ = eol_ + 1;            // Advance to the next line in the buffer.
+      SAFE_ASSERT(bol_ <= eod_);  // "bol_" can point to "eod_".
+      if (!HasCompleteLine()) {
+        const int incomplete_line_length = eod_ - bol_;
+        // Move the trailing incomplete line to the beginning.
+        memmove(buf_, bol_, incomplete_line_length);
+        // Read text from file and append it.
+        char *const append_pos = buf_ + incomplete_line_length;
+        const int capacity_left = buf_len_ - incomplete_line_length;
+        const ssize_t num_bytes =
+            ReadPersistent(fd_, append_pos, capacity_left);
+        if (num_bytes <= 0) {  // EOF or error.
+          return false;
+        }
+        eod_ = append_pos + num_bytes;
+        bol_ = buf_;
+      }
+    }
+    eol_ = FindLineFeed();
+    if (eol_ == nullptr) {  // '\n' not found.  Malformed line.
+      return false;
+    }
+    *eol_ = '\0';  // Replace '\n' with '\0'.
+
+    *bol = bol_;
+    *eol = eol_;
+    return true;
+  }
+
+ private:
+  char *FindLineFeed() const {
+    return reinterpret_cast<char *>(memchr(bol_, '\n', eod_ - bol_));
+  }
+
+  bool BufferIsEmpty() const { return buf_ == eod_; }
+
+  bool HasCompleteLine() const {
+    return !BufferIsEmpty() && FindLineFeed() != nullptr;
+  }
+
+  const int fd_;
+  const int buf_len_;
+  char *const buf_;
+  char *bol_;
+  char *eol_;
+  const char *eod_;  // End of data in "buf_".
+};
+}  // namespace
+
+// Place the hex number read from "start" into "*hex".  The pointer to
+// the first non-hex character or "end" is returned.
+static const char *GetHex(const char *start, const char *end,
+                          uint64_t *const value) {
+  uint64_t hex = 0;
+  const char *p;
+  for (p = start; p < end; ++p) {
+    int ch = *p;
+    if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') ||
+        (ch >= 'a' && ch <= 'f')) {
+      hex = (hex << 4) | (ch < 'A' ? ch - '0' : (ch & 0xF) + 9);
+    } else {  // Encountered the first non-hex character.
+      break;
+    }
+  }
+  SAFE_ASSERT(p <= end);
+  *value = hex;
+  return p;
+}
+
+static const char *GetHex(const char *start, const char *end,
+                          const void **const addr) {
+  uint64_t hex = 0;
+  const char *p = GetHex(start, end, &hex);
+  *addr = reinterpret_cast<void *>(hex);
+  return p;
+}
+
+// Normally we are only interested in "r?x" maps.
+// On the PowerPC, function pointers point to descriptors in the .opd
+// section.  The descriptors themselves are not executable code, so
+// we need to relax the check below to "r??".
+static bool ShouldUseMapping(const char *const flags) {
+  return flags[0] == 'r' && (kPlatformUsesOPDSections || flags[2] == 'x');
+}
+
+// Read /proc/self/maps and run "callback" for each mmapped file found.  If
+// "callback" returns false, stop scanning and return true. Else continue
+// scanning /proc/self/maps. Return true if no parse error is found.
+static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap(
+    bool (*callback)(const char *filename, const void *const start_addr,
+                     const void *const end_addr, uint64_t offset, void *arg),
+    void *arg, void *tmp_buf, int tmp_buf_size) {
+  // Use /proc/self/task/<pid>/maps instead of /proc/self/maps. The latter
+  // requires kernel to stop all threads, and is significantly slower when there
+  // are 1000s of threads.
+  char maps_path[80];
+  snprintf(maps_path, sizeof(maps_path), "/proc/self/task/%d/maps", getpid());
+
+  int maps_fd;
+  NO_INTR(maps_fd = open(maps_path, O_RDONLY));
+  FileDescriptor wrapped_maps_fd(maps_fd);
+  if (wrapped_maps_fd.get() < 0) {
+    ABSL_RAW_LOG(WARNING, "%s: errno=%d", maps_path, errno);
+    return false;
+  }
+
+  // Iterate over maps and look for the map containing the pc.  Then
+  // look into the symbol tables inside.
+  LineReader reader(wrapped_maps_fd.get(), static_cast<char *>(tmp_buf),
+                    tmp_buf_size);
+  while (true) {
+    const char *cursor;
+    const char *eol;
+    if (!reader.ReadLine(&cursor, &eol)) {  // EOF or malformed line.
+      break;
+    }
+
+    const char *line = cursor;
+    const void *start_address;
+    // Start parsing line in /proc/self/maps.  Here is an example:
+    //
+    // 08048000-0804c000 r-xp 00000000 08:01 2142121    /bin/cat
+    //
+    // We want start address (08048000), end address (0804c000), flags
+    // (r-xp) and file name (/bin/cat).
+
+    // Read start address.
+    cursor = GetHex(cursor, eol, &start_address);
+    if (cursor == eol || *cursor != '-') {
+      ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line);
+      return false;
+    }
+    ++cursor;  // Skip '-'.
+
+    // Read end address.
+    const void *end_address;
+    cursor = GetHex(cursor, eol, &end_address);
+    if (cursor == eol || *cursor != ' ') {
+      ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line);
+      return false;
+    }
+    ++cursor;  // Skip ' '.
+
+    // Read flags.  Skip flags until we encounter a space or eol.
+    const char *const flags_start = cursor;
+    while (cursor < eol && *cursor != ' ') {
+      ++cursor;
+    }
+    // We expect at least four letters for flags (ex. "r-xp").
+    if (cursor == eol || cursor < flags_start + 4) {
+      ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps: %s", line);
+      return false;
+    }
+
+    // Check flags.
+    if (!ShouldUseMapping(flags_start)) {
+      continue;  // We skip this map.
+    }
+    ++cursor;  // Skip ' '.
+
+    // Read file offset.
+    uint64_t offset;
+    cursor = GetHex(cursor, eol, &offset);
+    ++cursor;  // Skip ' '.
+
+    // Skip to file name.  "cursor" now points to dev.  We need to skip at least
+    // two spaces for dev and inode.
+    int num_spaces = 0;
+    while (cursor < eol) {
+      if (*cursor == ' ') {
+        ++num_spaces;
+      } else if (num_spaces >= 2) {
+        // The first non-space character after  skipping two spaces
+        // is the beginning of the file name.
+        break;
+      }
+      ++cursor;
+    }
+
+    // Check whether this entry corresponds to our hint table for the true
+    // filename.
+    bool hinted =
+        GetFileMappingHint(&start_address, &end_address, &offset, &cursor);
+    if (!hinted && (cursor == eol || cursor[0] == '[')) {
+      // not an object file, typically [vdso] or [vsyscall]
+      continue;
+    }
+    if (!callback(cursor, start_address, end_address, offset, arg)) break;
+  }
+  return true;
+}
+
+// Find the objfile mapped in address region containing [addr, addr + len).
+ObjFile *Symbolizer::FindObjFile(const void *const addr, size_t len) {
+  for (int i = 0; i < 2; ++i) {
+    if (!ok_) return nullptr;
+
+    // Read /proc/self/maps if necessary
+    if (!addr_map_read_) {
+      addr_map_read_ = true;
+      if (!ReadAddrMap(RegisterObjFile, this, tmp_buf_, TMP_BUF_SIZE)) {
+        ok_ = false;
+        return nullptr;
+      }
+    }
+
+    int lo = 0;
+    int hi = addr_map_.Size();
+    while (lo < hi) {
+      int mid = (lo + hi) / 2;
+      if (addr < addr_map_.At(mid)->end_addr) {
+        hi = mid;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    if (lo != addr_map_.Size()) {
+      ObjFile *obj = addr_map_.At(lo);
+      SAFE_ASSERT(obj->end_addr > addr);
+      if (addr >= obj->start_addr &&
+          reinterpret_cast<const char *>(addr) + len <= obj->end_addr)
+        return obj;
+    }
+
+    // The address mapping may have changed since it was last read.  Retry.
+    ClearAddrMap();
+  }
+  return nullptr;
+}
+
+void Symbolizer::ClearAddrMap() {
+  for (int i = 0; i != addr_map_.Size(); i++) {
+    ObjFile *o = addr_map_.At(i);
+    base_internal::LowLevelAlloc::Free(o->filename);
+    if (o->fd >= 0) {
+      NO_INTR(close(o->fd));
+    }
+  }
+  addr_map_.Clear();
+  addr_map_read_ = false;
+}
+
+// Callback for ReadAddrMap to register objfiles in an in-memory table.
+bool Symbolizer::RegisterObjFile(const char *filename,
+                                 const void *const start_addr,
+                                 const void *const end_addr, uint64_t offset,
+                                 void *arg) {
+  Symbolizer *impl = static_cast<Symbolizer *>(arg);
+
+  // Files are supposed to be added in the increasing address order.  Make
+  // sure that's the case.
+  int addr_map_size = impl->addr_map_.Size();
+  if (addr_map_size != 0) {
+    ObjFile *old = impl->addr_map_.At(addr_map_size - 1);
+    if (old->end_addr > end_addr) {
+      ABSL_RAW_LOG(ERROR,
+                   "Unsorted addr map entry: 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR
+                   ": %s",
+                   reinterpret_cast<uintptr_t>(end_addr), filename,
+                   reinterpret_cast<uintptr_t>(old->end_addr), old->filename);
+      return true;
+    } else if (old->end_addr == end_addr) {
+      // The same entry appears twice. This sometimes happens for [vdso].
+      if (old->start_addr != start_addr ||
+          strcmp(old->filename, filename) != 0) {
+        ABSL_RAW_LOG(ERROR,
+                     "Duplicate addr 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR ": %s",
+                     reinterpret_cast<uintptr_t>(end_addr), filename,
+                     reinterpret_cast<uintptr_t>(old->end_addr), old->filename);
+      }
+      return true;
+    } else if (old->end_addr == start_addr &&
+               reinterpret_cast<uintptr_t>(old->start_addr) - old->offset ==
+                   reinterpret_cast<uintptr_t>(start_addr) - offset &&
+               strcmp(old->filename, filename) == 0) {
+      // Two contiguous map entries that span a contiguous region of the file,
+      // perhaps because some part of the file was mlock()ed. Combine them.
+      old->end_addr = end_addr;
+      return true;
+    }
+  }
+  ObjFile *obj = impl->addr_map_.Add();
+  obj->filename = impl->CopyString(filename);
+  obj->start_addr = start_addr;
+  obj->end_addr = end_addr;
+  obj->offset = offset;
+  obj->elf_type = -1;  // filled on demand
+  obj->fd = -1;        // opened on demand
+  return true;
+}
+
+// This function wraps the Demangle function to provide an interface
+// where the input symbol is demangled in-place.
+// To keep stack consumption low, we would like this function to not
+// get inlined.
+static ABSL_ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size,
+                                                    char *tmp_buf,
+                                                    int tmp_buf_size) {
+  if (Demangle(out, tmp_buf, tmp_buf_size)) {
+    // Demangling succeeded. Copy to out if the space allows.
+    int len = strlen(tmp_buf);
+    if (len + 1 <= out_size) {  // +1 for '\0'.
+      SAFE_ASSERT(len < tmp_buf_size);
+      memmove(out, tmp_buf, len + 1);
+    }
+  }
+}
+
+SymbolCacheLine *Symbolizer::GetCacheLine(const void *const pc) {
+  uintptr_t pc0 = reinterpret_cast<uintptr_t>(pc);
+  pc0 >>= 3;  // drop the low 3 bits
+
+  // Shuffle bits.
+  pc0 ^= (pc0 >> 6) ^ (pc0 >> 12) ^ (pc0 >> 18);
+  return &symbol_cache_[pc0 % SYMBOL_CACHE_LINES];
+}
+
+void Symbolizer::AgeSymbols(SymbolCacheLine *line) {
+  for (uint32_t &age : line->age) {
+    ++age;
+  }
+}
+
+const char *Symbolizer::FindSymbolInCache(const void *const pc) {
+  if (pc == nullptr) return nullptr;
+
+  SymbolCacheLine *line = GetCacheLine(pc);
+  for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) {
+    if (line->pc[i] == pc) {
+      AgeSymbols(line);
+      line->age[i] = 0;
+      return line->name[i];
+    }
+  }
+  return nullptr;
+}
+
+const char *Symbolizer::InsertSymbolInCache(const void *const pc,
+                                            const char *name) {
+  SAFE_ASSERT(pc != nullptr);
+
+  SymbolCacheLine *line = GetCacheLine(pc);
+  uint32_t max_age = 0;
+  int oldest_index = -1;
+  for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) {
+    if (line->pc[i] == nullptr) {
+      AgeSymbols(line);
+      line->pc[i] = pc;
+      line->name[i] = CopyString(name);
+      line->age[i] = 0;
+      return line->name[i];
+    }
+    if (line->age[i] >= max_age) {
+      max_age = line->age[i];
+      oldest_index = i;
+    }
+  }
+
+  AgeSymbols(line);
+  ABSL_RAW_CHECK(oldest_index >= 0, "Corrupt cache");
+  base_internal::LowLevelAlloc::Free(line->name[oldest_index]);
+  line->pc[oldest_index] = pc;
+  line->name[oldest_index] = CopyString(name);
+  line->age[oldest_index] = 0;
+  return line->name[oldest_index];
+}
+
+static void MaybeOpenFdFromSelfExe(ObjFile *obj) {
+  if (memcmp(obj->start_addr, ELFMAG, SELFMAG) != 0) {
+    return;
+  }
+  int fd = open("/proc/self/exe", O_RDONLY);
+  if (fd == -1) {
+    return;
+  }
+  // Verify that contents of /proc/self/exe matches in-memory image of
+  // the binary. This can fail if the "deleted" binary is in fact not
+  // the main executable, or for binaries that have the first PT_LOAD
+  // segment smaller than 4K. We do it in four steps so that the
+  // buffer is smaller and we don't consume too much stack space.
+  const char *mem = reinterpret_cast<const char *>(obj->start_addr);
+  for (int i = 0; i < 4; ++i) {
+    char buf[1024];
+    ssize_t n = read(fd, buf, sizeof(buf));
+    if (n != sizeof(buf) || memcmp(buf, mem, sizeof(buf)) != 0) {
+      close(fd);
+      return;
+    }
+    mem += sizeof(buf);
+  }
+  obj->fd = fd;
+}
+
+static bool MaybeInitializeObjFile(ObjFile *obj) {
+  if (obj->fd < 0) {
+    obj->fd = open(obj->filename, O_RDONLY);
+
+    if (obj->fd < 0) {
+      // Getting /proc/self/exe here means that we were hinted.
+      if (strcmp(obj->filename, "/proc/self/exe") == 0) {
+        // /proc/self/exe may be inaccessible (due to setuid, etc.), so try
+        // accessing the binary via argv0.
+        if (argv0_value != nullptr) {
+          obj->fd = open(argv0_value, O_RDONLY);
+        }
+      } else {
+        MaybeOpenFdFromSelfExe(obj);
+      }
+    }
+
+    if (obj->fd < 0) {
+      ABSL_RAW_LOG(WARNING, "%s: open failed: errno=%d", obj->filename, errno);
+      return false;
+    }
+    obj->elf_type = FileGetElfType(obj->fd);
+    if (obj->elf_type < 0) {
+      ABSL_RAW_LOG(WARNING, "%s: wrong elf type: %d", obj->filename,
+                   obj->elf_type);
+      return false;
+    }
+
+    if (!ReadFromOffsetExact(obj->fd, &obj->elf_header, sizeof(obj->elf_header),
+                             0)) {
+      ABSL_RAW_LOG(WARNING, "%s: failed to read elf header", obj->filename);
+      return false;
+    }
+    const int phnum = obj->elf_header.e_phnum;
+    const int phentsize = obj->elf_header.e_phentsize;
+    size_t phoff = obj->elf_header.e_phoff;
+    size_t num_executable_load_segments = 0;
+    for (int j = 0; j < phnum; j++) {
+      ElfW(Phdr) phdr;
+      if (!ReadFromOffsetExact(obj->fd, &phdr, sizeof(phdr), phoff)) {
+        ABSL_RAW_LOG(WARNING, "%s: failed to read program header %d",
+                     obj->filename, j);
+        return false;
+      }
+      phoff += phentsize;
+      constexpr int rx = PF_X | PF_R;
+      if (phdr.p_type != PT_LOAD || (phdr.p_flags & rx) != rx) {
+        // Not a LOAD segment, or not executable code.
+        continue;
+      }
+      if (num_executable_load_segments < obj->phdr.size()) {
+        memcpy(&obj->phdr[num_executable_load_segments++], &phdr, sizeof(phdr));
+      } else {
+        ABSL_RAW_LOG(WARNING, "%s: too many executable LOAD segments",
+                     obj->filename);
+        break;
+      }
+    }
+    if (num_executable_load_segments == 0) {
+      // This object has no "r-x" LOAD segments. That's unexpected.
+      ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename);
+      return false;
+    }
+  }
+  return true;
+}
+
+// The implementation of our symbolization routine.  If it
+// successfully finds the symbol containing "pc" and obtains the
+// symbol name, returns pointer to that symbol. Otherwise, returns nullptr.
+// If any symbol decorators have been installed via InstallSymbolDecorator(),
+// they are called here as well.
+// To keep stack consumption low, we would like this function to not
+// get inlined.
+const char *Symbolizer::GetUncachedSymbol(const void *pc) {
+  ObjFile *const obj = FindObjFile(pc, 1);
+  ptrdiff_t relocation = 0;
+  int fd = -1;
+  if (obj != nullptr) {
+    if (MaybeInitializeObjFile(obj)) {
+      const size_t start_addr = reinterpret_cast<size_t>(obj->start_addr);
+      if (obj->elf_type == ET_DYN && start_addr >= obj->offset) {
+        // This object was relocated.
+        //
+        // For obj->offset > 0, adjust the relocation since a mapping at offset
+        // X in the file will have a start address of [true relocation]+X.
+        relocation = start_addr - obj->offset;
+
+        // Note: some binaries have multiple "rx" LOAD segments. We must
+        // find the right one.
+        ElfW(Phdr) *phdr = nullptr;
+        for (size_t j = 0; j < obj->phdr.size(); j++) {
+          ElfW(Phdr) &p = obj->phdr[j];
+          if (p.p_type != PT_LOAD) {
+            // We only expect PT_LOADs. This must be PT_NULL that we didn't
+            // write over (i.e. we exhausted all interesting PT_LOADs).
+            ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type");
+            break;
+          }
+          if (pc < reinterpret_cast<void *>(start_addr + p.p_memsz)) {
+            phdr = &p;
+            break;
+          }
+        }
+        if (phdr == nullptr) {
+          // That's unexpected. Hope for the best.
+          ABSL_RAW_LOG(
+              WARNING,
+              "%s: unable to find LOAD segment for pc: %p, start_addr: %zx",
+              obj->filename, pc, start_addr);
+        } else {
+          // Adjust relocation in case phdr.p_vaddr != 0.
+          // This happens for binaries linked with `lld --rosegment`, and for
+          // binaries linked with BFD `ld -z separate-code`.
+          relocation -= phdr->p_vaddr - phdr->p_offset;
+        }
+      }
+
+      fd = obj->fd;
+      if (GetSymbolFromObjectFile(*obj, pc, relocation, symbol_buf_,
+                                  sizeof(symbol_buf_), tmp_buf_,
+                                  sizeof(tmp_buf_)) == SYMBOL_FOUND) {
+        // Only try to demangle the symbol name if it fit into symbol_buf_.
+        DemangleInplace(symbol_buf_, sizeof(symbol_buf_), tmp_buf_,
+                        sizeof(tmp_buf_));
+      }
+    }
+  } else {
+#if ABSL_HAVE_VDSO_SUPPORT
+    VDSOSupport vdso;
+    if (vdso.IsPresent()) {
+      VDSOSupport::SymbolInfo symbol_info;
+      if (vdso.LookupSymbolByAddress(pc, &symbol_info)) {
+        // All VDSO symbols are known to be short.
+        size_t len = strlen(symbol_info.name);
+        ABSL_RAW_CHECK(len + 1 < sizeof(symbol_buf_),
+                       "VDSO symbol unexpectedly long");
+        memcpy(symbol_buf_, symbol_info.name, len + 1);
+      }
+    }
+#endif
+  }
+
+  if (g_decorators_mu.TryLock()) {
+    if (g_num_decorators > 0) {
+      SymbolDecoratorArgs decorator_args = {
+          pc,       relocation,       fd,     symbol_buf_, sizeof(symbol_buf_),
+          tmp_buf_, sizeof(tmp_buf_), nullptr};
+      for (int i = 0; i < g_num_decorators; ++i) {
+        decorator_args.arg = g_decorators[i].arg;
+        g_decorators[i].fn(&decorator_args);
+      }
+    }
+    g_decorators_mu.Unlock();
+  }
+  if (symbol_buf_[0] == '\0') {
+    return nullptr;
+  }
+  symbol_buf_[sizeof(symbol_buf_) - 1] = '\0';  // Paranoia.
+  return InsertSymbolInCache(pc, symbol_buf_);
+}
+
+const char *Symbolizer::GetSymbol(const void *pc) {
+  const char *entry = FindSymbolInCache(pc);
+  if (entry != nullptr) {
+    return entry;
+  }
+  symbol_buf_[0] = '\0';
+
+#ifdef __hppa__
+  {
+    // In some contexts (e.g., return addresses), PA-RISC uses the lowest two
+    // bits of the address to indicate the privilege level. Clear those bits
+    // before trying to symbolize.
+    const auto pc_bits = reinterpret_cast<uintptr_t>(pc);
+    const auto address = pc_bits & ~0x3;
+    entry = GetUncachedSymbol(reinterpret_cast<const void *>(address));
+    if (entry != nullptr) {
+      return entry;
+    }
+
+    // In some contexts, PA-RISC also uses bit 1 of the address to indicate that
+    // this is a cross-DSO function pointer. Such function pointers actually
+    // point to a procedure label, a struct whose first 32-bit (pointer) element
+    // actually points to the function text. With no symbol found for this
+    // address so far, try interpreting it as a cross-DSO function pointer and
+    // see how that goes.
+    if (pc_bits & 0x2) {
+      return GetUncachedSymbol(*reinterpret_cast<const void *const *>(address));
+    }
+
+    return nullptr;
+  }
+#else
+  return GetUncachedSymbol(pc);
+#endif
+}
+
+bool RemoveAllSymbolDecorators(void) {
+  if (!g_decorators_mu.TryLock()) {
+    // Someone else is using decorators. Get out.
+    return false;
+  }
+  g_num_decorators = 0;
+  g_decorators_mu.Unlock();
+  return true;
+}
+
+bool RemoveSymbolDecorator(int ticket) {
+  if (!g_decorators_mu.TryLock()) {
+    // Someone else is using decorators. Get out.
+    return false;
+  }
+  for (int i = 0; i < g_num_decorators; ++i) {
+    if (g_decorators[i].ticket == ticket) {
+      while (i < g_num_decorators - 1) {
+        g_decorators[i] = g_decorators[i + 1];
+        ++i;
+      }
+      g_num_decorators = i;
+      break;
+    }
+  }
+  g_decorators_mu.Unlock();
+  return true;  // Decorator is known to be removed.
+}
+
+int InstallSymbolDecorator(SymbolDecorator decorator, void *arg) {
+  static int ticket = 0;
+
+  if (!g_decorators_mu.TryLock()) {
+    // Someone else is using decorators. Get out.
+    return -2;
+  }
+  int ret = ticket;
+  if (g_num_decorators >= kMaxDecorators) {
+    ret = -1;
+  } else {
+    g_decorators[g_num_decorators] = {decorator, arg, ticket++};
+    ++g_num_decorators;
+  }
+  g_decorators_mu.Unlock();
+  return ret;
+}
+
+bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset,
+                             const char *filename) {
+  SAFE_ASSERT(start <= end);
+  SAFE_ASSERT(filename != nullptr);
+
+  InitSigSafeArena();
+
+  if (!g_file_mapping_mu.TryLock()) {
+    return false;
+  }
+
+  bool ret = true;
+  if (g_num_file_mapping_hints >= kMaxFileMappingHints) {
+    ret = false;
+  } else {
+    // TODO(ckennelly): Move this into a string copy routine.
+    int len = strlen(filename);
+    char *dst = static_cast<char *>(
+        base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
+    ABSL_RAW_CHECK(dst != nullptr, "out of memory");
+    memcpy(dst, filename, len + 1);
+
+    auto &hint = g_file_mapping_hints[g_num_file_mapping_hints++];
+    hint.start = start;
+    hint.end = end;
+    hint.offset = offset;
+    hint.filename = dst;
+  }
+
+  g_file_mapping_mu.Unlock();
+  return ret;
+}
+
+bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset,
+                        const char **filename) {
+  if (!g_file_mapping_mu.TryLock()) {
+    return false;
+  }
+  bool found = false;
+  for (int i = 0; i < g_num_file_mapping_hints; i++) {
+    if (g_file_mapping_hints[i].start <= *start &&
+        *end <= g_file_mapping_hints[i].end) {
+      // We assume that the start_address for the mapping is the base
+      // address of the ELF section, but when [start_address,end_address) is
+      // not strictly equal to [hint.start, hint.end), that assumption is
+      // invalid.
+      //
+      // This uses the hint's start address (even though hint.start is not
+      // necessarily equal to start_address) to ensure the correct
+      // relocation is computed later.
+      *start = g_file_mapping_hints[i].start;
+      *end = g_file_mapping_hints[i].end;
+      *offset = g_file_mapping_hints[i].offset;
+      *filename = g_file_mapping_hints[i].filename;
+      found = true;
+      break;
+    }
+  }
+  g_file_mapping_mu.Unlock();
+  return found;
+}
+
+}  // namespace debugging_internal
+
+bool Symbolize(const void *pc, char *out, int out_size) {
+  // Symbolization is very slow under tsan.
+  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
+  SAFE_ASSERT(out_size >= 0);
+  debugging_internal::Symbolizer *s = debugging_internal::AllocateSymbolizer();
+  const char *name = s->GetSymbol(pc);
+  bool ok = false;
+  if (name != nullptr && out_size > 0) {
+    strncpy(out, name, out_size);
+    ok = true;
+    if (out[out_size - 1] != '\0') {
+      // strncpy() does not '\0' terminate when it truncates.  Do so, with
+      // trailing ellipsis.
+      static constexpr char kEllipsis[] = "...";
+      int ellipsis_size =
+          std::min(implicit_cast<int>(strlen(kEllipsis)), out_size - 1);
+      memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size);
+      out[out_size - 1] = '\0';
+    }
+  }
+  debugging_internal::FreeSymbolizer(s);
+  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
+  return ok;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+extern "C" bool AbslInternalGetFileMappingHint(const void **start,
+                                               const void **end, uint64_t *offset,
+                                               const char **filename) {
+  return absl::debugging_internal::GetFileMappingHint(start, end, offset,
+                                                      filename);
+}
diff --git a/CAPI/cpp/grpc/include/absl/debugging/symbolize_emscripten.inc b/CAPI/cpp/grpc/include/absl/debugging/symbolize_emscripten.inc
new file mode 100644
index 0000000..c226c45
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/symbolize_emscripten.inc
@@ -0,0 +1,72 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#include <cxxabi.h>
+#include <emscripten.h>
+
+#include <algorithm>
+#include <cstring>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/debugging/internal/demangle.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+extern "C" {
+const char* emscripten_pc_get_function(const void* pc);
+}
+
+// clang-format off
+EM_JS(bool, HaveOffsetConverter, (),
+      { return typeof wasmOffsetConverter !== 'undefined'; });
+// clang-format on
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+void InitializeSymbolizer(const char*) {
+  if (!HaveOffsetConverter()) {
+    ABSL_RAW_LOG(INFO,
+                 "Symbolization unavailable. Rebuild with -sWASM=1 "
+                 "and -sUSE_OFFSET_CONVERTER=1.");
+  }
+}
+
+bool Symbolize(const void* pc, char* out, int out_size) {
+  // Check if we have the offset converter necessary for pc_get_function.
+  // Without it, the program will abort().
+  if (!HaveOffsetConverter()) {
+    return false;
+  }
+  const char* func_name = emscripten_pc_get_function(pc);
+  if (func_name == nullptr) {
+    return false;
+  }
+
+  strncpy(out, func_name, out_size);
+
+  if (out[out_size - 1] != '\0') {
+    // strncpy() does not '\0' terminate when it truncates.
+    static constexpr char kEllipsis[] = "...";
+    int ellipsis_size = std::min<int>(sizeof(kEllipsis) - 1, out_size - 1);
+    memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size);
+    out[out_size - 1] = '\0';
+  }
+
+  return true;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/CAPI/cpp/grpc/include/absl/debugging/symbolize_unimplemented.inc b/CAPI/cpp/grpc/include/absl/debugging/symbolize_unimplemented.inc
new file mode 100644
index 0000000..db24456
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/symbolize_unimplemented.inc
@@ -0,0 +1,40 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#include <cstdint>
+
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace debugging_internal {
+
+int InstallSymbolDecorator(SymbolDecorator, void*) { return -1; }
+bool RemoveSymbolDecorator(int) { return false; }
+bool RemoveAllSymbolDecorators(void) { return false; }
+bool RegisterFileMappingHint(const void *, const void *, uint64_t, const char *) {
+  return false;
+}
+bool GetFileMappingHint(const void **, const void **, uint64_t *, const char **) {
+  return false;
+}
+
+}  // namespace debugging_internal
+
+void InitializeSymbolizer(const char*) {}
+bool Symbolize(const void *, char *, int) { return false; }
+
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/CAPI/cpp/grpc/include/absl/debugging/symbolize_win32.inc b/CAPI/cpp/grpc/include/absl/debugging/symbolize_win32.inc
new file mode 100644
index 0000000..c3df46f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/debugging/symbolize_win32.inc
@@ -0,0 +1,81 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// See "Retrieving Symbol Information by Address":
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms680578(v=vs.85).aspx
+
+#include <windows.h>
+
+// MSVC header dbghelp.h has a warning for an ignored typedef.
+#pragma warning(push)
+#pragma warning(disable:4091)
+#include <dbghelp.h>
+#pragma warning(pop)
+
+#pragma comment(lib, "dbghelp.lib")
+
+#include <algorithm>
+#include <cstring>
+
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+static HANDLE process = NULL;
+
+void InitializeSymbolizer(const char*) {
+  if (process != nullptr) {
+    return;
+  }
+  process = GetCurrentProcess();
+
+  // Symbols are not loaded until a reference is made requiring the
+  // symbols be loaded. This is the fastest, most efficient way to use
+  // the symbol handler.
+  SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME);
+  if (!SymInitialize(process, nullptr, true)) {
+    // GetLastError() returns a Win32 DWORD, but we assign to
+    // unsigned long long to simplify the ABSL_RAW_LOG case below.  The uniform
+    // initialization guarantees this is not a narrowing conversion.
+    const unsigned long long error{GetLastError()};  // NOLINT(runtime/int)
+    ABSL_RAW_LOG(FATAL, "SymInitialize() failed: %llu", error);
+  }
+}
+
+bool Symbolize(const void* pc, char* out, int out_size) {
+  if (out_size <= 0) {
+    return false;
+  }
+  alignas(SYMBOL_INFO) char buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
+  SYMBOL_INFO* symbol = reinterpret_cast<SYMBOL_INFO*>(buf);
+  symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+  symbol->MaxNameLen = MAX_SYM_NAME;
+  if (!SymFromAddr(process, reinterpret_cast<DWORD64>(pc), nullptr, symbol)) {
+    return false;
+  }
+  strncpy(out, symbol->Name, out_size);
+  if (out[out_size - 1] != '\0') {
+    // strncpy() does not '\0' terminate when it truncates.
+    static constexpr char kEllipsis[] = "...";
+    int ellipsis_size =
+        std::min<int>(sizeof(kEllipsis) - 1, out_size - 1);
+    memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size);
+    out[out_size - 1] = '\0';
+  }
+  return true;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/CAPI/cpp/grpc/include/absl/flags/commandlineflag.h b/CAPI/cpp/grpc/include/absl/flags/commandlineflag.h
new file mode 100644
index 0000000..f2fa089
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/commandlineflag.h
@@ -0,0 +1,200 @@
+//
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: commandlineflag.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `CommandLineFlag`, which acts as a type-erased
+// handle for accessing metadata about the Abseil Flag in question.
+//
+// Because an actual Abseil flag is of an unspecified type, you should not
+// manipulate or interact directly with objects of that type. Instead, use the
+// CommandLineFlag type as an intermediary.
+#ifndef ABSL_FLAGS_COMMANDLINEFLAG_H_
+#define ABSL_FLAGS_COMMANDLINEFLAG_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/fast_type_id.h"
+#include "absl/flags/internal/commandlineflag.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+class PrivateHandleAccessor;
+}  // namespace flags_internal
+
+// CommandLineFlag
+//
+// This type acts as a type-erased handle for an instance of an Abseil Flag and
+// holds reflection information pertaining to that flag. Use CommandLineFlag to
+// access a flag's name, location, help string etc.
+//
+// To obtain an absl::CommandLineFlag, invoke `absl::FindCommandLineFlag()`
+// passing it the flag name string.
+//
+// Example:
+//
+//   // Obtain reflection handle for a flag named "flagname".
+//   const absl::CommandLineFlag* my_flag_data =
+//        absl::FindCommandLineFlag("flagname");
+//
+//   // Now you can get flag info from that reflection handle.
+//   std::string flag_location = my_flag_data->Filename();
+//   ...
+class CommandLineFlag {
+ public:
+  constexpr CommandLineFlag() = default;
+
+  // Not copyable/assignable.
+  CommandLineFlag(const CommandLineFlag&) = delete;
+  CommandLineFlag& operator=(const CommandLineFlag&) = delete;
+
+  // absl::CommandLineFlag::IsOfType()
+  //
+  // Return true iff flag has type T.
+  template <typename T>
+  inline bool IsOfType() const {
+    return TypeId() == base_internal::FastTypeId<T>();
+  }
+
+  // absl::CommandLineFlag::TryGet()
+  //
+  // Attempts to retrieve the flag value. Returns value on success,
+  // absl::nullopt otherwise.
+  template <typename T>
+  absl::optional<T> TryGet() const {
+    if (IsRetired() || !IsOfType<T>()) {
+      return absl::nullopt;
+    }
+
+    // Implementation notes:
+    //
+    // We are wrapping a union around the value of `T` to serve three purposes:
+    //
+    //  1. `U.value` has correct size and alignment for a value of type `T`
+    //  2. The `U.value` constructor is not invoked since U's constructor does
+    //     not do it explicitly.
+    //  3. The `U.value` destructor is invoked since U's destructor does it
+    //     explicitly. This makes `U` a kind of RAII wrapper around non default
+    //     constructible value of T, which is destructed when we leave the
+    //     scope. We do need to destroy U.value, which is constructed by
+    //     CommandLineFlag::Read even though we left it in a moved-from state
+    //     after std::move.
+    //
+    // All of this serves to avoid requiring `T` being default constructible.
+    union U {
+      T value;
+      U() {}
+      ~U() { value.~T(); }
+    };
+    U u;
+
+    Read(&u.value);
+    // allow retired flags to be "read", so we can report invalid access.
+    if (IsRetired()) {
+      return absl::nullopt;
+    }
+    return std::move(u.value);
+  }
+
+  // absl::CommandLineFlag::Name()
+  //
+  // Returns name of this flag.
+  virtual absl::string_view Name() const = 0;
+
+  // absl::CommandLineFlag::Filename()
+  //
+  // Returns name of the file where this flag is defined.
+  virtual std::string Filename() const = 0;
+
+  // absl::CommandLineFlag::Help()
+  //
+  // Returns help message associated with this flag.
+  virtual std::string Help() const = 0;
+
+  // absl::CommandLineFlag::IsRetired()
+  //
+  // Returns true iff this object corresponds to retired flag.
+  virtual bool IsRetired() const;
+
+  // absl::CommandLineFlag::DefaultValue()
+  //
+  // Returns the default value for this flag.
+  virtual std::string DefaultValue() const = 0;
+
+  // absl::CommandLineFlag::CurrentValue()
+  //
+  // Returns the current value for this flag.
+  virtual std::string CurrentValue() const = 0;
+
+  // absl::CommandLineFlag::ParseFrom()
+  //
+  // Sets the value of the flag based on specified string `value`. If the flag
+  // was successfully set to new value, it returns true. Otherwise, sets `error`
+  // to indicate the error, leaves the flag unchanged, and returns false.
+  bool ParseFrom(absl::string_view value, std::string* error);
+
+ protected:
+  ~CommandLineFlag() = default;
+
+ private:
+  friend class flags_internal::PrivateHandleAccessor;
+
+  // Sets the value of the flag based on specified string `value`. If the flag
+  // was successfully set to new value, it returns true. Otherwise, sets `error`
+  // to indicate the error, leaves the flag unchanged, and returns false. There
+  // are three ways to set the flag's value:
+  //  * Update the current flag value
+  //  * Update the flag's default value
+  //  * Update the current flag value if it was never set before
+  // The mode is selected based on `set_mode` parameter.
+  virtual bool ParseFrom(absl::string_view value,
+                         flags_internal::FlagSettingMode set_mode,
+                         flags_internal::ValueSource source,
+                         std::string& error) = 0;
+
+  // Returns id of the flag's value type.
+  virtual flags_internal::FlagFastTypeId TypeId() const = 0;
+
+  // Interface to save flag to some persistent state. Returns current flag state
+  // or nullptr if flag does not support saving and restoring a state.
+  virtual std::unique_ptr<flags_internal::FlagStateInterface> SaveState() = 0;
+
+  // Copy-construct a new value of the flag's type in a memory referenced by
+  // the dst based on the current flag's value.
+  virtual void Read(void* dst) const = 0;
+
+  // To be deleted. Used to return true if flag's current value originated from
+  // command line.
+  virtual bool IsSpecifiedOnCommandLine() const = 0;
+
+  // Validates supplied value usign validator or parseflag routine
+  virtual bool ValidateInputValue(absl::string_view value) const = 0;
+
+  // Checks that flags default value can be converted to string and back to the
+  // flag's value type.
+  virtual void CheckDefaultValueParsingRoundtrip() const = 0;
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_COMMANDLINEFLAG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/config.h b/CAPI/cpp/grpc/include/absl/flags/config.h
new file mode 100644
index 0000000..14c4235
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/config.h
@@ -0,0 +1,68 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_CONFIG_H_
+#define ABSL_FLAGS_CONFIG_H_
+
+// Determine if we should strip string literals from the Flag objects.
+// By default we strip string literals on mobile platforms.
+#if !defined(ABSL_FLAGS_STRIP_NAMES)
+
+#if defined(__ANDROID__)
+#define ABSL_FLAGS_STRIP_NAMES 1
+
+#elif defined(__APPLE__)
+#include <TargetConditionals.h>
+#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+#define ABSL_FLAGS_STRIP_NAMES 1
+#elif defined(TARGET_OS_EMBEDDED) && TARGET_OS_EMBEDDED
+#define ABSL_FLAGS_STRIP_NAMES 1
+#endif  // TARGET_OS_*
+#endif
+
+#endif  // !defined(ABSL_FLAGS_STRIP_NAMES)
+
+#if !defined(ABSL_FLAGS_STRIP_NAMES)
+// If ABSL_FLAGS_STRIP_NAMES wasn't set on the command line or above,
+// the default is not to strip.
+#define ABSL_FLAGS_STRIP_NAMES 0
+#endif
+
+#if !defined(ABSL_FLAGS_STRIP_HELP)
+// By default, if we strip names, we also strip help.
+#define ABSL_FLAGS_STRIP_HELP ABSL_FLAGS_STRIP_NAMES
+#endif
+
+// These macros represent the "source of truth" for the list of supported
+// built-in types.
+#define ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A) \
+  A(bool, bool)                              \
+  A(short, short)                            \
+  A(unsigned short, unsigned_short)          \
+  A(int, int)                                \
+  A(unsigned int, unsigned_int)              \
+  A(long, long)                              \
+  A(unsigned long, unsigned_long)            \
+  A(long long, long_long)                    \
+  A(unsigned long long, unsigned_long_long)  \
+  A(double, double)                          \
+  A(float, float)
+
+#define ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(A) \
+  ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A)         \
+  A(std::string, std_string)                   \
+  A(std::vector<std::string>, std_vector_of_string)
+
+#endif  // ABSL_FLAGS_CONFIG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/declare.h b/CAPI/cpp/grpc/include/absl/flags/declare.h
new file mode 100644
index 0000000..d1437bb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/declare.h
@@ -0,0 +1,73 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: declare.h
+// -----------------------------------------------------------------------------
+//
+// This file defines the ABSL_DECLARE_FLAG macro, allowing you to declare an
+// `absl::Flag` for use within a translation unit. You should place this
+// declaration within the header file associated with the .cc file that defines
+// and owns the `Flag`.
+
+#ifndef ABSL_FLAGS_DECLARE_H_
+#define ABSL_FLAGS_DECLARE_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+// absl::Flag<T> represents a flag of type 'T' created by ABSL_FLAG.
+template <typename T>
+class Flag;
+
+}  // namespace flags_internal
+
+// Flag
+//
+// Forward declaration of the `absl::Flag` type for use in defining the macro.
+#if defined(_MSC_VER) && !defined(__clang__)
+template <typename T>
+class Flag;
+#else
+template <typename T>
+using Flag = flags_internal::Flag<T>;
+#endif
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// ABSL_DECLARE_FLAG()
+//
+// This macro is a convenience for declaring use of an `absl::Flag` within a
+// translation unit. This macro should be used within a header file to
+// declare usage of the flag within any .cc file including that header file.
+//
+// The ABSL_DECLARE_FLAG(type, name) macro expands to:
+//
+//   extern absl::Flag<type> FLAGS_name;
+#define ABSL_DECLARE_FLAG(type, name) ABSL_DECLARE_FLAG_INTERNAL(type, name)
+
+// Internal implementation of ABSL_DECLARE_FLAG to allow macro expansion of its
+// arguments. Clients must use ABSL_DECLARE_FLAG instead.
+#define ABSL_DECLARE_FLAG_INTERNAL(type, name)               \
+  extern absl::Flag<type> FLAGS_##name;                      \
+  namespace absl /* block flags in namespaces */ {}          \
+  /* second redeclaration is to allow applying attributes */ \
+  extern absl::Flag<type> FLAGS_##name
+
+#endif  // ABSL_FLAGS_DECLARE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/flag.h b/CAPI/cpp/grpc/include/absl/flags/flag.h
new file mode 100644
index 0000000..b7f94be
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/flag.h
@@ -0,0 +1,310 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: flag.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::Flag<T>` type for holding command-line
+// flag data, and abstractions to create, get and set such flag data.
+//
+// It is important to note that this type is **unspecified** (an implementation
+// detail) and you do not construct or manipulate actual `absl::Flag<T>`
+// instances. Instead, you define and declare flags using the
+// `ABSL_FLAG()` and `ABSL_DECLARE_FLAG()` macros, and get and set flag values
+// using the `absl::GetFlag()` and `absl::SetFlag()` functions.
+
+#ifndef ABSL_FLAGS_FLAG_H_
+#define ABSL_FLAGS_FLAG_H_
+
+#include <string>
+#include <type_traits>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+#include "absl/flags/config.h"
+#include "absl/flags/internal/flag.h"
+#include "absl/flags/internal/registry.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Flag
+//
+// An `absl::Flag` holds a command-line flag value, providing a runtime
+// parameter to a binary. Such flags should be defined in the global namespace
+// and (preferably) in the module containing the binary's `main()` function.
+//
+// You should not construct and cannot use the `absl::Flag` type directly;
+// instead, you should declare flags using the `ABSL_DECLARE_FLAG()` macro
+// within a header file, and define your flag using `ABSL_FLAG()` within your
+// header's associated `.cc` file. Such flags will be named `FLAGS_name`.
+//
+// Example:
+//
+//    .h file
+//
+//      // Declares usage of a flag named "FLAGS_count"
+//      ABSL_DECLARE_FLAG(int, count);
+//
+//    .cc file
+//
+//      // Defines a flag named "FLAGS_count" with a default `int` value of 0.
+//      ABSL_FLAG(int, count, 0, "Count of items to process");
+//
+// No public methods of `absl::Flag<T>` are part of the Abseil Flags API.
+//
+// For type support of Abseil Flags, see the marshalling.h header file, which
+// discusses supported standard types, optional flags, and additional Abseil
+// type support.
+#if !defined(_MSC_VER) || defined(__clang__)
+template <typename T>
+using Flag = flags_internal::Flag<T>;
+#else
+#include "absl/flags/internal/flag_msvc.inc"
+#endif
+
+// GetFlag()
+//
+// Returns the value (of type `T`) of an `absl::Flag<T>` instance, by value. Do
+// not construct an `absl::Flag<T>` directly and call `absl::GetFlag()`;
+// instead, refer to flag's constructed variable name (e.g. `FLAGS_name`).
+// Because this function returns by value and not by reference, it is
+// thread-safe, but note that the operation may be expensive; as a result, avoid
+// `absl::GetFlag()` within any tight loops.
+//
+// Example:
+//
+//   // FLAGS_count is a Flag of type `int`
+//   int my_count = absl::GetFlag(FLAGS_count);
+//
+//   // FLAGS_firstname is a Flag of type `std::string`
+//   std::string first_name = absl::GetFlag(FLAGS_firstname);
+template <typename T>
+ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
+  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
+}
+
+// SetFlag()
+//
+// Sets the value of an `absl::Flag` to the value `v`. Do not construct an
+// `absl::Flag<T>` directly and call `absl::SetFlag()`; instead, use the
+// flag's variable name (e.g. `FLAGS_name`). This function is
+// thread-safe, but is potentially expensive. Avoid setting flags in general,
+// but especially within performance-critical code.
+template <typename T>
+void SetFlag(absl::Flag<T>* flag, const T& v) {
+  flags_internal::FlagImplPeer::InvokeSet(*flag, v);
+}
+
+// Overload of `SetFlag()` to allow callers to pass in a value that is
+// convertible to `T`. E.g., use this overload to pass a "const char*" when `T`
+// is `std::string`.
+template <typename T, typename V>
+void SetFlag(absl::Flag<T>* flag, const V& v) {
+  T value(v);
+  flags_internal::FlagImplPeer::InvokeSet(*flag, value);
+}
+
+// GetFlagReflectionHandle()
+//
+// Returns the reflection handle corresponding to specified Abseil Flag
+// instance. Use this handle to access flag's reflection information, like name,
+// location, default value etc.
+//
+// Example:
+//
+//   std::string = absl::GetFlagReflectionHandle(FLAGS_count).DefaultValue();
+
+template <typename T>
+const CommandLineFlag& GetFlagReflectionHandle(const absl::Flag<T>& f) {
+  return flags_internal::FlagImplPeer::InvokeReflect(f);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+
+// ABSL_FLAG()
+//
+// This macro defines an `absl::Flag<T>` instance of a specified type `T`:
+//
+//   ABSL_FLAG(T, name, default_value, help);
+//
+// where:
+//
+//   * `T` is a supported flag type (see the list of types in `marshalling.h`),
+//   * `name` designates the name of the flag (as a global variable
+//     `FLAGS_name`),
+//   * `default_value` is an expression holding the default value for this flag
+//     (which must be implicitly convertible to `T`),
+//   * `help` is the help text, which can also be an expression.
+//
+// This macro expands to a flag named 'FLAGS_name' of type 'T':
+//
+//   absl::Flag<T> FLAGS_name = ...;
+//
+// Note that all such instances are created as global variables.
+//
+// For `ABSL_FLAG()` values that you wish to expose to other translation units,
+// it is recommended to define those flags within the `.cc` file associated with
+// the header where the flag is declared.
+//
+// Note: do not construct objects of type `absl::Flag<T>` directly. Only use the
+// `ABSL_FLAG()` macro for such construction.
+#define ABSL_FLAG(Type, name, default_value, help) \
+  ABSL_FLAG_IMPL(Type, name, default_value, help)
+
+// ABSL_FLAG().OnUpdate()
+//
+// Defines a flag of type `T` with a callback attached:
+//
+//   ABSL_FLAG(T, name, default_value, help).OnUpdate(callback);
+//
+// `callback` should be convertible to `void (*)()`.
+//
+// After any setting of the flag value, the callback will be called at least
+// once. A rapid sequence of changes may be merged together into the same
+// callback. No concurrent calls to the callback will be made for the same
+// flag. Callbacks are allowed to read the current value of the flag but must
+// not mutate that flag.
+//
+// The update mechanism guarantees "eventual consistency"; if the callback
+// derives an auxiliary data structure from the flag value, it is guaranteed
+// that eventually the flag value and the derived data structure will be
+// consistent.
+//
+// Note: ABSL_FLAG.OnUpdate() does not have a public definition. Hence, this
+// comment serves as its API documentation.
+
+// -----------------------------------------------------------------------------
+// Implementation details below this section
+// -----------------------------------------------------------------------------
+
+// ABSL_FLAG_IMPL macro definition conditional on ABSL_FLAGS_STRIP_NAMES
+#if !defined(_MSC_VER) || defined(__clang__)
+#define ABSL_FLAG_IMPL_FLAG_PTR(flag) flag
+#define ABSL_FLAG_IMPL_HELP_ARG(name)                      \
+  absl::flags_internal::HelpArg<AbslFlagHelpGenFor##name>( \
+      FLAGS_help_storage_##name)
+#define ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name) \
+  absl::flags_internal::DefaultArg<Type, AbslFlagDefaultGenFor##name>(0)
+#else
+#define ABSL_FLAG_IMPL_FLAG_PTR(flag) flag.GetImpl()
+#define ABSL_FLAG_IMPL_HELP_ARG(name) &AbslFlagHelpGenFor##name::NonConst
+#define ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name) &AbslFlagDefaultGenFor##name::Gen
+#endif
+
+#if ABSL_FLAGS_STRIP_NAMES
+#define ABSL_FLAG_IMPL_FLAGNAME(txt) ""
+#define ABSL_FLAG_IMPL_FILENAME() ""
+#define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                      \
+  absl::flags_internal::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
+                                                nullptr)
+#else
+#define ABSL_FLAG_IMPL_FLAGNAME(txt) txt
+#define ABSL_FLAG_IMPL_FILENAME() __FILE__
+#define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                     \
+  absl::flags_internal::FlagRegistrar<T, true>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
+                                               __FILE__)
+#endif
+
+// ABSL_FLAG_IMPL macro definition conditional on ABSL_FLAGS_STRIP_HELP
+
+#if ABSL_FLAGS_STRIP_HELP
+#define ABSL_FLAG_IMPL_FLAGHELP(txt) absl::flags_internal::kStrippedFlagHelp
+#else
+#define ABSL_FLAG_IMPL_FLAGHELP(txt) txt
+#endif
+
+// AbslFlagHelpGenFor##name is used to encapsulate both immediate (method Const)
+// and lazy (method NonConst) evaluation of help message expression. We choose
+// between the two via the call to HelpArg in absl::Flag instantiation below.
+// If help message expression is constexpr evaluable compiler will optimize
+// away this whole struct.
+// TODO(rogeeff): place these generated structs into local namespace and apply
+// ABSL_INTERNAL_UNIQUE_SHORT_NAME.
+// TODO(rogeeff): Apply __attribute__((nodebug)) to FLAGS_help_storage_##name
+#define ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, txt)                       \
+  struct AbslFlagHelpGenFor##name {                                          \
+    /* The expression is run in the caller as part of the   */               \
+    /* default value argument. That keeps temporaries alive */               \
+    /* long enough for NonConst to work correctly.          */               \
+    static constexpr absl::string_view Value(                                \
+        absl::string_view absl_flag_help = ABSL_FLAG_IMPL_FLAGHELP(txt)) {   \
+      return absl_flag_help;                                                 \
+    }                                                                        \
+    static std::string NonConst() { return std::string(Value()); }           \
+  };                                                                         \
+  constexpr auto FLAGS_help_storage_##name ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
+      ABSL_ATTRIBUTE_SECTION_VARIABLE(flags_help_cold) =                     \
+          absl::flags_internal::HelpStringAsArray<AbslFlagHelpGenFor##name>( \
+              0);
+
+#define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)     \
+  struct AbslFlagDefaultGenFor##name {                                        \
+    Type value = absl::flags_internal::InitDefaultValue<Type>(default_value); \
+    static void Gen(void* absl_flag_default_loc) {                            \
+      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
+    }                                                                         \
+  };
+
+// ABSL_FLAG_IMPL
+//
+// Note: Name of registrar object is not arbitrary. It is used to "grab"
+// global name for FLAGS_no<flag_name> symbol, thus preventing the possibility
+// of defining two flags with names foo and nofoo.
+#define ABSL_FLAG_IMPL(Type, name, default_value, help)                       \
+  extern ::absl::Flag<Type> FLAGS_##name;                                     \
+  namespace absl /* block flags in namespaces */ {}                           \
+  ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)           \
+  ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help)                             \
+  ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{                              \
+      ABSL_FLAG_IMPL_FLAGNAME(#name), ABSL_FLAG_IMPL_FILENAME(),              \
+      ABSL_FLAG_IMPL_HELP_ARG(name), ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name)}; \
+  extern absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name;             \
+  absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name =                   \
+      ABSL_FLAG_IMPL_REGISTRAR(Type, FLAGS_##name)
+
+// ABSL_RETIRED_FLAG
+//
+// Designates the flag (which is usually pre-existing) as "retired." A retired
+// flag is a flag that is now unused by the program, but may still be passed on
+// the command line, usually by production scripts. A retired flag is ignored
+// and code can't access it at runtime.
+//
+// This macro registers a retired flag with given name and type, with a name
+// identical to the name of the original flag you are retiring. The retired
+// flag's type can change over time, so that you can retire code to support a
+// custom flag type.
+//
+// This macro has the same signature as `ABSL_FLAG`. To retire a flag, simply
+// replace an `ABSL_FLAG` definition with `ABSL_RETIRED_FLAG`, leaving the
+// arguments unchanged (unless of course you actually want to retire the flag
+// type at this time as well).
+//
+// `default_value` is only used as a double check on the type. `explanation` is
+// unused.
+// TODO(rogeeff): replace RETIRED_FLAGS with FLAGS once forward declarations of
+// retired flags are cleaned up.
+#define ABSL_RETIRED_FLAG(type, name, default_value, explanation)      \
+  static absl::flags_internal::RetiredFlag<type> RETIRED_FLAGS_##name; \
+  ABSL_ATTRIBUTE_UNUSED static const auto RETIRED_FLAGS_REG_##name =   \
+      (RETIRED_FLAGS_##name.Retire(#name),                             \
+       ::absl::flags_internal::FlagRegistrarEmpty{})
+
+#endif  // ABSL_FLAGS_FLAG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/commandlineflag.h b/CAPI/cpp/grpc/include/absl/flags/internal/commandlineflag.h
new file mode 100644
index 0000000..ebfe81b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/commandlineflag.h
@@ -0,0 +1,68 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
+#define ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
+
+#include "absl/base/config.h"
+#include "absl/base/internal/fast_type_id.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+// An alias for flag fast type id. This value identifies the flag value type
+// similarly to typeid(T), without relying on RTTI being available. In most
+// cases this id is enough to uniquely identify the flag's value type. In a few
+// cases we'll have to resort to using actual RTTI implementation if it is
+// available.
+using FlagFastTypeId = absl::base_internal::FastTypeIdType;
+
+// Options that control SetCommandLineOptionWithMode.
+enum FlagSettingMode {
+  // update the flag's value unconditionally (can call this multiple times).
+  SET_FLAGS_VALUE,
+  // update the flag's value, but *only if* it has not yet been updated
+  // with SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef".
+  SET_FLAG_IF_DEFAULT,
+  // set the flag's default value to this.  If the flag has not been updated
+  // yet (via SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef")
+  // change the flag's current value to the new default value as well.
+  SET_FLAGS_DEFAULT
+};
+
+// Options that control ParseFrom: Source of a value.
+enum ValueSource {
+  // Flag is being set by value specified on a command line.
+  kCommandLine,
+  // Flag is being set by value specified in the code.
+  kProgrammaticChange,
+};
+
+// Handle to FlagState objects. Specific flag state objects will restore state
+// of a flag produced this flag state from method CommandLineFlag::SaveState().
+class FlagStateInterface {
+ public:
+  virtual ~FlagStateInterface();
+
+  // Restores the flag originated this object to the saved state.
+  virtual void Restore() const = 0;
+};
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/flag.h b/CAPI/cpp/grpc/include/absl/flags/internal/flag.h
new file mode 100644
index 0000000..6154638
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/flag.h
@@ -0,0 +1,800 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_FLAG_H_
+#define ABSL_FLAGS_INTERNAL_FLAG_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <atomic>
+#include <cstring>
+#include <memory>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+
+#include "absl/base/attributes.h"
+#include "absl/base/call_once.h"
+#include "absl/base/casts.h"
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/flags/commandlineflag.h"
+#include "absl/flags/config.h"
+#include "absl/flags/internal/commandlineflag.h"
+#include "absl/flags/internal/registry.h"
+#include "absl/flags/internal/sequence_lock.h"
+#include "absl/flags/marshalling.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Forward declaration of absl::Flag<T> public API.
+namespace flags_internal {
+template <typename T>
+class Flag;
+}  // namespace flags_internal
+
+#if defined(_MSC_VER) && !defined(__clang__)
+template <typename T>
+class Flag;
+#else
+template <typename T>
+using Flag = flags_internal::Flag<T>;
+#endif
+
+template <typename T>
+ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag);
+
+template <typename T>
+void SetFlag(absl::Flag<T>* flag, const T& v);
+
+template <typename T, typename V>
+void SetFlag(absl::Flag<T>* flag, const V& v);
+
+template <typename U>
+const CommandLineFlag& GetFlagReflectionHandle(const absl::Flag<U>& f);
+
+///////////////////////////////////////////////////////////////////////////////
+// Flag value type operations, eg., parsing, copying, etc. are provided
+// by function specific to that type with a signature matching FlagOpFn.
+
+namespace flags_internal {
+
+enum class FlagOp {
+  kAlloc,
+  kDelete,
+  kCopy,
+  kCopyConstruct,
+  kSizeof,
+  kFastTypeId,
+  kRuntimeTypeId,
+  kParse,
+  kUnparse,
+  kValueOffset,
+};
+using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*);
+
+// Forward declaration for Flag value specific operations.
+template <typename T>
+void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3);
+
+// Allocate aligned memory for a flag value.
+inline void* Alloc(FlagOpFn op) {
+  return op(FlagOp::kAlloc, nullptr, nullptr, nullptr);
+}
+// Deletes memory interpreting obj as flag value type pointer.
+inline void Delete(FlagOpFn op, void* obj) {
+  op(FlagOp::kDelete, nullptr, obj, nullptr);
+}
+// Copies src to dst interpreting as flag value type pointers.
+inline void Copy(FlagOpFn op, const void* src, void* dst) {
+  op(FlagOp::kCopy, src, dst, nullptr);
+}
+// Construct a copy of flag value in a location pointed by dst
+// based on src - pointer to the flag's value.
+inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) {
+  op(FlagOp::kCopyConstruct, src, dst, nullptr);
+}
+// Makes a copy of flag value pointed by obj.
+inline void* Clone(FlagOpFn op, const void* obj) {
+  void* res = flags_internal::Alloc(op);
+  flags_internal::CopyConstruct(op, obj, res);
+  return res;
+}
+// Returns true if parsing of input text is successfull.
+inline bool Parse(FlagOpFn op, absl::string_view text, void* dst,
+                  std::string* error) {
+  return op(FlagOp::kParse, &text, dst, error) != nullptr;
+}
+// Returns string representing supplied value.
+inline std::string Unparse(FlagOpFn op, const void* val) {
+  std::string result;
+  op(FlagOp::kUnparse, val, &result, nullptr);
+  return result;
+}
+// Returns size of flag value type.
+inline size_t Sizeof(FlagOpFn op) {
+  // This sequence of casts reverses the sequence from
+  // `flags_internal::FlagOps()`
+  return static_cast<size_t>(reinterpret_cast<intptr_t>(
+      op(FlagOp::kSizeof, nullptr, nullptr, nullptr)));
+}
+// Returns fast type id coresponding to the value type.
+inline FlagFastTypeId FastTypeId(FlagOpFn op) {
+  return reinterpret_cast<FlagFastTypeId>(
+      op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr));
+}
+// Returns fast type id coresponding to the value type.
+inline const std::type_info* RuntimeTypeId(FlagOpFn op) {
+  return reinterpret_cast<const std::type_info*>(
+      op(FlagOp::kRuntimeTypeId, nullptr, nullptr, nullptr));
+}
+// Returns offset of the field value_ from the field impl_ inside of
+// absl::Flag<T> data. Given FlagImpl pointer p you can get the
+// location of the corresponding value as:
+//      reinterpret_cast<char*>(p) + ValueOffset().
+inline ptrdiff_t ValueOffset(FlagOpFn op) {
+  // This sequence of casts reverses the sequence from
+  // `flags_internal::FlagOps()`
+  return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
+      op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
+}
+
+// Returns an address of RTTI's typeid(T).
+template <typename T>
+inline const std::type_info* GenRuntimeTypeId() {
+#ifdef ABSL_INTERNAL_HAS_RTTI
+  return &typeid(T);
+#else
+  return nullptr;
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Flag help auxiliary structs.
+
+// This is help argument for absl::Flag encapsulating the string literal pointer
+// or pointer to function generating it as well as enum descriminating two
+// cases.
+using HelpGenFunc = std::string (*)();
+
+template <size_t N>
+struct FixedCharArray {
+  char value[N];
+
+  template <size_t... I>
+  static constexpr FixedCharArray<N> FromLiteralString(
+      absl::string_view str, absl::index_sequence<I...>) {
+    return (void)str, FixedCharArray<N>({{str[I]..., '\0'}});
+  }
+};
+
+template <typename Gen, size_t N = Gen::Value().size()>
+constexpr FixedCharArray<N + 1> HelpStringAsArray(int) {
+  return FixedCharArray<N + 1>::FromLiteralString(
+      Gen::Value(), absl::make_index_sequence<N>{});
+}
+
+template <typename Gen>
+constexpr std::false_type HelpStringAsArray(char) {
+  return std::false_type{};
+}
+
+union FlagHelpMsg {
+  constexpr explicit FlagHelpMsg(const char* help_msg) : literal(help_msg) {}
+  constexpr explicit FlagHelpMsg(HelpGenFunc help_gen) : gen_func(help_gen) {}
+
+  const char* literal;
+  HelpGenFunc gen_func;
+};
+
+enum class FlagHelpKind : uint8_t { kLiteral = 0, kGenFunc = 1 };
+
+struct FlagHelpArg {
+  FlagHelpMsg source;
+  FlagHelpKind kind;
+};
+
+extern const char kStrippedFlagHelp[];
+
+// These two HelpArg overloads allows us to select at compile time one of two
+// way to pass Help argument to absl::Flag. We'll be passing
+// AbslFlagHelpGenFor##name as Gen and integer 0 as a single argument to prefer
+// first overload if possible. If help message is evaluatable on constexpr
+// context We'll be able to make FixedCharArray out of it and we'll choose first
+// overload. In this case the help message expression is immediately evaluated
+// and is used to construct the absl::Flag. No additionl code is generated by
+// ABSL_FLAG Otherwise SFINAE kicks in and first overload is dropped from the
+// consideration, in which case the second overload will be used. The second
+// overload does not attempt to evaluate the help message expression
+// immediately and instead delays the evaluation by returing the function
+// pointer (&T::NonConst) genering the help message when necessary. This is
+// evaluatable in constexpr context, but the cost is an extra function being
+// generated in the ABSL_FLAG code.
+template <typename Gen, size_t N>
+constexpr FlagHelpArg HelpArg(const FixedCharArray<N>& value) {
+  return {FlagHelpMsg(value.value), FlagHelpKind::kLiteral};
+}
+
+template <typename Gen>
+constexpr FlagHelpArg HelpArg(std::false_type) {
+  return {FlagHelpMsg(&Gen::NonConst), FlagHelpKind::kGenFunc};
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Flag default value auxiliary structs.
+
+// Signature for the function generating the initial flag value (usually
+// based on default value supplied in flag's definition)
+using FlagDfltGenFunc = void (*)(void*);
+
+union FlagDefaultSrc {
+  constexpr explicit FlagDefaultSrc(FlagDfltGenFunc gen_func_arg)
+      : gen_func(gen_func_arg) {}
+
+#define ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE(T, name) \
+  T name##_value;                                  \
+  constexpr explicit FlagDefaultSrc(T value) : name##_value(value) {}  // NOLINT
+  ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE)
+#undef ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE
+
+  void* dynamic_value;
+  FlagDfltGenFunc gen_func;
+};
+
+enum class FlagDefaultKind : uint8_t {
+  kDynamicValue = 0,
+  kGenFunc = 1,
+  kOneWord = 2  // for default values UP to one word in size
+};
+
+struct FlagDefaultArg {
+  FlagDefaultSrc source;
+  FlagDefaultKind kind;
+};
+
+// This struct and corresponding overload to InitDefaultValue are used to
+// facilitate usage of {} as default value in ABSL_FLAG macro.
+// TODO(rogeeff): Fix handling types with explicit constructors.
+struct EmptyBraces {};
+
+template <typename T>
+constexpr T InitDefaultValue(T t) {
+  return t;
+}
+
+template <typename T>
+constexpr T InitDefaultValue(EmptyBraces) {
+  return T{};
+}
+
+template <typename ValueT, typename GenT,
+          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
+              ((void)GenT{}, 0)>
+constexpr FlagDefaultArg DefaultArg(int) {
+  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
+}
+
+template <typename ValueT, typename GenT>
+constexpr FlagDefaultArg DefaultArg(char) {
+  return {FlagDefaultSrc(&GenT::Gen), FlagDefaultKind::kGenFunc};
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Flag current value auxiliary structs.
+
+constexpr int64_t UninitializedFlagValue() {
+  return static_cast<int64_t>(0xababababababababll);
+}
+
+template <typename T>
+using FlagUseValueAndInitBitStorage = std::integral_constant<
+    bool, absl::type_traits_internal::is_trivially_copyable<T>::value &&
+              std::is_default_constructible<T>::value && (sizeof(T) < 8)>;
+
+template <typename T>
+using FlagUseOneWordStorage = std::integral_constant<
+    bool, absl::type_traits_internal::is_trivially_copyable<T>::value &&
+              (sizeof(T) <= 8)>;
+
+template <class T>
+using FlagUseSequenceLockStorage = std::integral_constant<
+    bool, absl::type_traits_internal::is_trivially_copyable<T>::value &&
+              (sizeof(T) > 8)>;
+
+enum class FlagValueStorageKind : uint8_t {
+  kValueAndInitBit = 0,
+  kOneWordAtomic = 1,
+  kSequenceLocked = 2,
+  kAlignedBuffer = 3,
+};
+
+template <typename T>
+static constexpr FlagValueStorageKind StorageKind() {
+  return FlagUseValueAndInitBitStorage<T>::value
+             ? FlagValueStorageKind::kValueAndInitBit
+         : FlagUseOneWordStorage<T>::value
+             ? FlagValueStorageKind::kOneWordAtomic
+         : FlagUseSequenceLockStorage<T>::value
+             ? FlagValueStorageKind::kSequenceLocked
+             : FlagValueStorageKind::kAlignedBuffer;
+}
+
+struct FlagOneWordValue {
+  constexpr explicit FlagOneWordValue(int64_t v) : value(v) {}
+  std::atomic<int64_t> value;
+};
+
+template <typename T>
+struct alignas(8) FlagValueAndInitBit {
+  T value;
+  // Use an int instead of a bool to guarantee that a non-zero value has
+  // a bit set.
+  uint8_t init;
+};
+
+template <typename T,
+          FlagValueStorageKind Kind = flags_internal::StorageKind<T>()>
+struct FlagValue;
+
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kValueAndInitBit> : FlagOneWordValue {
+  constexpr FlagValue() : FlagOneWordValue(0) {}
+  bool Get(const SequenceLock&, T& dst) const {
+    int64_t storage = value.load(std::memory_order_acquire);
+    if (ABSL_PREDICT_FALSE(storage == 0)) {
+      return false;
+    }
+    dst = absl::bit_cast<FlagValueAndInitBit<T>>(storage).value;
+    return true;
+  }
+};
+
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kOneWordAtomic> : FlagOneWordValue {
+  constexpr FlagValue() : FlagOneWordValue(UninitializedFlagValue()) {}
+  bool Get(const SequenceLock&, T& dst) const {
+    int64_t one_word_val = value.load(std::memory_order_acquire);
+    if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
+      return false;
+    }
+    std::memcpy(&dst, static_cast<const void*>(&one_word_val), sizeof(T));
+    return true;
+  }
+};
+
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kSequenceLocked> {
+  bool Get(const SequenceLock& lock, T& dst) const {
+    return lock.TryRead(&dst, value_words, sizeof(T));
+  }
+
+  static constexpr int kNumWords =
+      flags_internal::AlignUp(sizeof(T), sizeof(uint64_t)) / sizeof(uint64_t);
+
+  alignas(T) alignas(
+      std::atomic<uint64_t>) std::atomic<uint64_t> value_words[kNumWords];
+};
+
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kAlignedBuffer> {
+  bool Get(const SequenceLock&, T&) const { return false; }
+
+  alignas(T) char value[sizeof(T)];
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Flag callback auxiliary structs.
+
+// Signature for the mutation callback used by watched Flags
+// The callback is noexcept.
+// TODO(rogeeff): add noexcept after C++17 support is added.
+using FlagCallbackFunc = void (*)();
+
+struct FlagCallback {
+  FlagCallbackFunc func;
+  absl::Mutex guard;  // Guard for concurrent callback invocations.
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Flag implementation, which does not depend on flag value type.
+// The class encapsulates the Flag's data and access to it.
+
+struct DynValueDeleter {
+  explicit DynValueDeleter(FlagOpFn op_arg = nullptr);
+  void operator()(void* ptr) const;
+
+  FlagOpFn op;
+};
+
+class FlagState;
+
+class FlagImpl final : public CommandLineFlag {
+ public:
+  constexpr FlagImpl(const char* name, const char* filename, FlagOpFn op,
+                     FlagHelpArg help, FlagValueStorageKind value_kind,
+                     FlagDefaultArg default_arg)
+      : name_(name),
+        filename_(filename),
+        op_(op),
+        help_(help.source),
+        help_source_kind_(static_cast<uint8_t>(help.kind)),
+        value_storage_kind_(static_cast<uint8_t>(value_kind)),
+        def_kind_(static_cast<uint8_t>(default_arg.kind)),
+        modified_(false),
+        on_command_line_(false),
+        callback_(nullptr),
+        default_value_(default_arg.source),
+        data_guard_{} {}
+
+  // Constant access methods
+  int64_t ReadOneWord() const ABSL_LOCKS_EXCLUDED(*DataGuard());
+  bool ReadOneBool() const ABSL_LOCKS_EXCLUDED(*DataGuard());
+  void Read(void* dst) const override ABSL_LOCKS_EXCLUDED(*DataGuard());
+  void Read(bool* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
+    *value = ReadOneBool();
+  }
+  template <typename T,
+            absl::enable_if_t<flags_internal::StorageKind<T>() ==
+                                  FlagValueStorageKind::kOneWordAtomic,
+                              int> = 0>
+  void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
+    int64_t v = ReadOneWord();
+    std::memcpy(value, static_cast<const void*>(&v), sizeof(T));
+  }
+  template <typename T,
+            typename std::enable_if<flags_internal::StorageKind<T>() ==
+                                        FlagValueStorageKind::kValueAndInitBit,
+                                    int>::type = 0>
+  void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
+    *value = absl::bit_cast<FlagValueAndInitBit<T>>(ReadOneWord()).value;
+  }
+
+  // Mutating access methods
+  void Write(const void* src) ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+  // Interfaces to operate on callbacks.
+  void SetCallback(const FlagCallbackFunc mutation_callback)
+      ABSL_LOCKS_EXCLUDED(*DataGuard());
+  void InvokeCallback() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+
+  // Used in read/write operations to validate source/target has correct type.
+  // For example if flag is declared as absl::Flag<int> FLAGS_foo, a call to
+  // absl::GetFlag(FLAGS_foo) validates that the type of FLAGS_foo is indeed
+  // int. To do that we pass the "assumed" type id (which is deduced from type
+  // int) as an argument `type_id`, which is in turn is validated against the
+  // type id stored in flag object by flag definition statement.
+  void AssertValidType(FlagFastTypeId type_id,
+                       const std::type_info* (*gen_rtti)()) const;
+
+ private:
+  template <typename T>
+  friend class Flag;
+  friend class FlagState;
+
+  // Ensures that `data_guard_` is initialized and returns it.
+  absl::Mutex* DataGuard() const
+      ABSL_LOCK_RETURNED(reinterpret_cast<absl::Mutex*>(data_guard_));
+  // Returns heap allocated value of type T initialized with default value.
+  std::unique_ptr<void, DynValueDeleter> MakeInitValue() const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+  // Flag initialization called via absl::call_once.
+  void Init();
+
+  // Offset value access methods. One per storage kind. These methods to not
+  // respect const correctness, so be very carefull using them.
+
+  // This is a shared helper routine which encapsulates most of the magic. Since
+  // it is only used inside the three routines below, which are defined in
+  // flag.cc, we can define it in that file as well.
+  template <typename StorageT>
+  StorageT* OffsetValue() const;
+  // This is an accessor for a value stored in an aligned buffer storage
+  // used for non-trivially-copyable data types.
+  // Returns a mutable pointer to the start of a buffer.
+  void* AlignedBufferValue() const;
+
+  // The same as above, but used for sequencelock-protected storage.
+  std::atomic<uint64_t>* AtomicBufferValue() const;
+
+  // This is an accessor for a value stored as one word atomic. Returns a
+  // mutable reference to an atomic value.
+  std::atomic<int64_t>& OneWordValue() const;
+
+  // Attempts to parse supplied `value` string. If parsing is successful,
+  // returns new value. Otherwise returns nullptr.
+  std::unique_ptr<void, DynValueDeleter> TryParse(absl::string_view value,
+                                                  std::string& err) const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+  // Stores the flag value based on the pointer to the source.
+  void StoreValue(const void* src) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+
+  // Copy the flag data, protected by `seq_lock_` into `dst`.
+  //
+  // REQUIRES: ValueStorageKind() == kSequenceLocked.
+  void ReadSequenceLockedData(void* dst) const
+      ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+  FlagHelpKind HelpSourceKind() const {
+    return static_cast<FlagHelpKind>(help_source_kind_);
+  }
+  FlagValueStorageKind ValueStorageKind() const {
+    return static_cast<FlagValueStorageKind>(value_storage_kind_);
+  }
+  FlagDefaultKind DefaultKind() const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()) {
+    return static_cast<FlagDefaultKind>(def_kind_);
+  }
+
+  // CommandLineFlag interface implementation
+  absl::string_view Name() const override;
+  std::string Filename() const override;
+  std::string Help() const override;
+  FlagFastTypeId TypeId() const override;
+  bool IsSpecifiedOnCommandLine() const override
+      ABSL_LOCKS_EXCLUDED(*DataGuard());
+  std::string DefaultValue() const override ABSL_LOCKS_EXCLUDED(*DataGuard());
+  std::string CurrentValue() const override ABSL_LOCKS_EXCLUDED(*DataGuard());
+  bool ValidateInputValue(absl::string_view value) const override
+      ABSL_LOCKS_EXCLUDED(*DataGuard());
+  void CheckDefaultValueParsingRoundtrip() const override
+      ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+  int64_t ModificationCount() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+
+  // Interfaces to save and restore flags to/from persistent state.
+  // Returns current flag state or nullptr if flag does not support
+  // saving and restoring a state.
+  std::unique_ptr<FlagStateInterface> SaveState() override
+      ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+  // Restores the flag state to the supplied state object. If there is
+  // nothing to restore returns false. Otherwise returns true.
+  bool RestoreState(const FlagState& flag_state)
+      ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+  bool ParseFrom(absl::string_view value, FlagSettingMode set_mode,
+                 ValueSource source, std::string& error) override
+      ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+  // Immutable flag's state.
+
+  // Flags name passed to ABSL_FLAG as second arg.
+  const char* const name_;
+  // The file name where ABSL_FLAG resides.
+  const char* const filename_;
+  // Type-specific operations "vtable".
+  const FlagOpFn op_;
+  // Help message literal or function to generate it.
+  const FlagHelpMsg help_;
+  // Indicates if help message was supplied as literal or generator func.
+  const uint8_t help_source_kind_ : 1;
+  // Kind of storage this flag is using for the flag's value.
+  const uint8_t value_storage_kind_ : 2;
+
+  uint8_t : 0;  // The bytes containing the const bitfields must not be
+                // shared with bytes containing the mutable bitfields.
+
+  // Mutable flag's state (guarded by `data_guard_`).
+
+  // def_kind_ is not guard by DataGuard() since it is accessed in Init without
+  // locks.
+  uint8_t def_kind_ : 2;
+  // Has this flag's value been modified?
+  bool modified_ : 1 ABSL_GUARDED_BY(*DataGuard());
+  // Has this flag been specified on command line.
+  bool on_command_line_ : 1 ABSL_GUARDED_BY(*DataGuard());
+
+  // Unique tag for absl::call_once call to initialize this flag.
+  absl::once_flag init_control_;
+
+  // Sequence lock / mutation counter.
+  flags_internal::SequenceLock seq_lock_;
+
+  // Optional flag's callback and absl::Mutex to guard the invocations.
+  FlagCallback* callback_ ABSL_GUARDED_BY(*DataGuard());
+  // Either a pointer to the function generating the default value based on the
+  // value specified in ABSL_FLAG or pointer to the dynamically set default
+  // value via SetCommandLineOptionWithMode. def_kind_ is used to distinguish
+  // these two cases.
+  FlagDefaultSrc default_value_;
+
+  // This is reserved space for an absl::Mutex to guard flag data. It will be
+  // initialized in FlagImpl::Init via placement new.
+  // We can't use "absl::Mutex data_guard_", since this class is not literal.
+  // We do not want to use "absl::Mutex* data_guard_", since this would require
+  // heap allocation during initialization, which is both slows program startup
+  // and can fail. Using reserved space + placement new allows us to avoid both
+  // problems.
+  alignas(absl::Mutex) mutable char data_guard_[sizeof(absl::Mutex)];
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// The Flag object parameterized by the flag's value type. This class implements
+// flag reflection handle interface.
+
+template <typename T>
+class Flag {
+ public:
+  constexpr Flag(const char* name, const char* filename, FlagHelpArg help,
+                 const FlagDefaultArg default_arg)
+      : impl_(name, filename, &FlagOps<T>, help,
+              flags_internal::StorageKind<T>(), default_arg),
+        value_() {}
+
+  // CommandLineFlag interface
+  absl::string_view Name() const { return impl_.Name(); }
+  std::string Filename() const { return impl_.Filename(); }
+  std::string Help() const { return impl_.Help(); }
+  // Do not use. To be removed.
+  bool IsSpecifiedOnCommandLine() const {
+    return impl_.IsSpecifiedOnCommandLine();
+  }
+  std::string DefaultValue() const { return impl_.DefaultValue(); }
+  std::string CurrentValue() const { return impl_.CurrentValue(); }
+
+ private:
+  template <typename, bool>
+  friend class FlagRegistrar;
+  friend class FlagImplPeer;
+
+  T Get() const {
+    // See implementation notes in CommandLineFlag::Get().
+    union U {
+      T value;
+      U() {}
+      ~U() { value.~T(); }
+    };
+    U u;
+
+#if !defined(NDEBUG)
+    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+#endif
+
+    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
+      impl_.Read(&u.value);
+    }
+    return std::move(u.value);
+  }
+  void Set(const T& v) {
+    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+    impl_.Write(&v);
+  }
+
+  // Access to the reflection.
+  const CommandLineFlag& Reflect() const { return impl_; }
+
+  // Flag's data
+  // The implementation depends on value_ field to be placed exactly after the
+  // impl_ field, so that impl_ can figure out the offset to the value and
+  // access it.
+  FlagImpl impl_;
+  FlagValue<T> value_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Trampoline for friend access
+
+class FlagImplPeer {
+ public:
+  template <typename T, typename FlagType>
+  static T InvokeGet(const FlagType& flag) {
+    return flag.Get();
+  }
+  template <typename FlagType, typename T>
+  static void InvokeSet(FlagType& flag, const T& v) {
+    flag.Set(v);
+  }
+  template <typename FlagType>
+  static const CommandLineFlag& InvokeReflect(const FlagType& f) {
+    return f.Reflect();
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Implementation of Flag value specific operations routine.
+template <typename T>
+void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
+  switch (op) {
+    case FlagOp::kAlloc: {
+      std::allocator<T> alloc;
+      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
+    }
+    case FlagOp::kDelete: {
+      T* p = static_cast<T*>(v2);
+      p->~T();
+      std::allocator<T> alloc;
+      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
+      return nullptr;
+    }
+    case FlagOp::kCopy:
+      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
+      return nullptr;
+    case FlagOp::kCopyConstruct:
+      new (v2) T(*static_cast<const T*>(v1));
+      return nullptr;
+    case FlagOp::kSizeof:
+      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
+    case FlagOp::kFastTypeId:
+      return const_cast<void*>(base_internal::FastTypeId<T>());
+    case FlagOp::kRuntimeTypeId:
+      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
+    case FlagOp::kParse: {
+      // Initialize the temporary instance of type T based on current value in
+      // destination (which is going to be flag's default value).
+      T temp(*static_cast<T*>(v2));
+      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
+                              static_cast<std::string*>(v3))) {
+        return nullptr;
+      }
+      *static_cast<T*>(v2) = std::move(temp);
+      return v2;
+    }
+    case FlagOp::kUnparse:
+      *static_cast<std::string*>(v2) =
+          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
+      return nullptr;
+    case FlagOp::kValueOffset: {
+      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
+      // offset of the data.
+      size_t round_to = alignof(FlagValue<T>);
+      size_t offset =
+          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
+      return reinterpret_cast<void*>(offset);
+    }
+  }
+  return nullptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// This class facilitates Flag object registration and tail expression-based
+// flag definition, for example:
+// ABSL_FLAG(int, foo, 42, "Foo help").OnUpdate(NotifyFooWatcher);
+struct FlagRegistrarEmpty {};
+template <typename T, bool do_register>
+class FlagRegistrar {
+ public:
+  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
+    if (do_register)
+      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
+  }
+
+  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
+    flag_.impl_.SetCallback(cb);
+    return *this;
+  }
+
+  // Make the registrar "die" gracefully as an empty struct on a line where
+  // registration happens. Registrar objects are intended to live only as
+  // temporary.
+  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
+
+ private:
+  Flag<T>& flag_;  // Flag being registered (not owned).
+};
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_FLAG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/flag_msvc.inc b/CAPI/cpp/grpc/include/absl/flags/internal/flag_msvc.inc
new file mode 100644
index 0000000..c31bd27
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/flag_msvc.inc
@@ -0,0 +1,116 @@
+//
+//  Copyright 2021 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// Do not include this file directly.
+// Include absl/flags/flag.h instead.
+
+// MSVC debug builds do not implement initialization with constexpr constructors
+// correctly. To work around this we add a level of indirection, so that the
+// class `absl::Flag` contains an `internal::Flag*` (instead of being an alias
+// to that class) and dynamically allocates an instance when necessary. We also
+// forward all calls to internal::Flag methods via trampoline methods. In this
+// setup the `absl::Flag` class does not have constructor and virtual methods,
+// all the data members are public and thus MSVC is able to initialize it at
+// link time. To deal with multiple threads accessing the flag for the first
+// time concurrently we use an atomic boolean indicating if flag object is
+// initialized. We also employ the double-checked locking pattern where the
+// second level of protection is a global Mutex, so if two threads attempt to
+// construct the flag concurrently only one wins.
+//
+// This solution is based on a recomendation here:
+// https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html?childToView=648454#comment-648454
+
+namespace flags_internal {
+absl::Mutex* GetGlobalConstructionGuard();
+}  // namespace flags_internal
+
+// Public methods of `absl::Flag<T>` are NOT part of the Abseil Flags API.
+// See https://abseil.io/docs/cpp/guides/flags
+template <typename T>
+class Flag {
+ public:
+  // No constructor and destructor to ensure this is an aggregate type.
+  // Visual Studio 2015 still requires the constructor for class to be
+  // constexpr initializable.
+#if _MSC_VER <= 1900
+  constexpr Flag(const char* name, const char* filename,
+                 const flags_internal::HelpGenFunc help_gen,
+                 const flags_internal::FlagDfltGenFunc default_value_gen)
+      : name_(name),
+        filename_(filename),
+        help_gen_(help_gen),
+        default_value_gen_(default_value_gen),
+        inited_(false),
+        impl_(nullptr) {}
+#endif
+
+  flags_internal::Flag<T>& GetImpl() const {
+    if (!inited_.load(std::memory_order_acquire)) {
+      absl::MutexLock l(flags_internal::GetGlobalConstructionGuard());
+
+      if (inited_.load(std::memory_order_acquire)) {
+        return *impl_;
+      }
+
+      impl_ = new flags_internal::Flag<T>(
+          name_, filename_,
+          {flags_internal::FlagHelpMsg(help_gen_),
+           flags_internal::FlagHelpKind::kGenFunc},
+          {flags_internal::FlagDefaultSrc(default_value_gen_),
+           flags_internal::FlagDefaultKind::kGenFunc});
+      inited_.store(true, std::memory_order_release);
+    }
+
+    return *impl_;
+  }
+
+  // Public methods of `absl::Flag<T>` are NOT part of the Abseil Flags API.
+  // See https://abseil.io/docs/cpp/guides/flags
+  bool IsRetired() const { return GetImpl().IsRetired(); }
+  absl::string_view Name() const { return GetImpl().Name(); }
+  std::string Help() const { return GetImpl().Help(); }
+  bool IsModified() const { return GetImpl().IsModified(); }
+  bool IsSpecifiedOnCommandLine() const {
+    return GetImpl().IsSpecifiedOnCommandLine();
+  }
+  std::string Filename() const { return GetImpl().Filename(); }
+  std::string DefaultValue() const { return GetImpl().DefaultValue(); }
+  std::string CurrentValue() const { return GetImpl().CurrentValue(); }
+  template <typename U>
+  inline bool IsOfType() const {
+    return GetImpl().template IsOfType<U>();
+  }
+  T Get() const {
+    return flags_internal::FlagImplPeer::InvokeGet<T>(GetImpl());
+  }
+  void Set(const T& v) {
+    flags_internal::FlagImplPeer::InvokeSet(GetImpl(), v);
+  }
+  void InvokeCallback() { GetImpl().InvokeCallback(); }
+
+  const CommandLineFlag& Reflect() const {
+    return flags_internal::FlagImplPeer::InvokeReflect(GetImpl());
+  }
+
+  // The data members are logically private, but they need to be public for
+  // this to be an aggregate type.
+  const char* name_;
+  const char* filename_;
+  const flags_internal::HelpGenFunc help_gen_;
+  const flags_internal::FlagDfltGenFunc default_value_gen_;
+
+  mutable std::atomic<bool> inited_;
+  mutable flags_internal::Flag<T>* impl_;
+};
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/parse.h b/CAPI/cpp/grpc/include/absl/flags/internal/parse.h
new file mode 100644
index 0000000..de706c8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/parse.h
@@ -0,0 +1,59 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_PARSE_H_
+#define ABSL_FLAGS_INTERNAL_PARSE_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/flags/declare.h"
+#include "absl/strings/string_view.h"
+
+ABSL_DECLARE_FLAG(std::vector<std::string>, flagfile);
+ABSL_DECLARE_FLAG(std::vector<std::string>, fromenv);
+ABSL_DECLARE_FLAG(std::vector<std::string>, tryfromenv);
+ABSL_DECLARE_FLAG(std::vector<std::string>, undefok);
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+enum class ArgvListAction { kRemoveParsedArgs, kKeepParsedArgs };
+enum class UsageFlagsAction { kHandleUsage, kIgnoreUsage };
+enum class OnUndefinedFlag {
+  kIgnoreUndefined,
+  kReportUndefined,
+  kAbortIfUndefined
+};
+
+std::vector<char*> ParseCommandLineImpl(int argc, char* argv[],
+                                        ArgvListAction arg_list_act,
+                                        UsageFlagsAction usage_flag_act,
+                                        OnUndefinedFlag on_undef_flag);
+
+// --------------------------------------------------------------------
+// Inspect original command line
+
+// Returns true if flag with specified name was either present on the original
+// command line or specified in flag file present on the original command line.
+bool WasPresentOnCommandLine(absl::string_view flag_name);
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_PARSE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/path_util.h b/CAPI/cpp/grpc/include/absl/flags/internal/path_util.h
new file mode 100644
index 0000000..a6594d3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/path_util.h
@@ -0,0 +1,62 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_PATH_UTIL_H_
+#define ABSL_FLAGS_INTERNAL_PATH_UTIL_H_
+
+#include "absl/base/config.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+// A portable interface that returns the basename of the filename passed as an
+// argument. It is similar to basename(3)
+// <https://linux.die.net/man/3/basename>.
+// For example:
+//     flags_internal::Basename("a/b/prog/file.cc")
+// returns "file.cc"
+//     flags_internal::Basename("file.cc")
+// returns "file.cc"
+inline absl::string_view Basename(absl::string_view filename) {
+  auto last_slash_pos = filename.find_last_of("/\\");
+
+  return last_slash_pos == absl::string_view::npos
+             ? filename
+             : filename.substr(last_slash_pos + 1);
+}
+
+// A portable interface that returns the directory name of the filename
+// passed as an argument, including the trailing slash.
+// Returns the empty string if a slash is not found in the input file name.
+// For example:
+//      flags_internal::Package("a/b/prog/file.cc")
+// returns "a/b/prog/"
+//      flags_internal::Package("file.cc")
+// returns ""
+inline absl::string_view Package(absl::string_view filename) {
+  auto last_slash_pos = filename.find_last_of("/\\");
+
+  return last_slash_pos == absl::string_view::npos
+             ? absl::string_view()
+             : filename.substr(0, last_slash_pos + 1);
+}
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_PATH_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/private_handle_accessor.h b/CAPI/cpp/grpc/include/absl/flags/internal/private_handle_accessor.h
new file mode 100644
index 0000000..c64435c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/private_handle_accessor.h
@@ -0,0 +1,61 @@
+//
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
+#define ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/flags/commandlineflag.h"
+#include "absl/flags/internal/commandlineflag.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+// This class serves as a trampoline to access private methods of
+// CommandLineFlag. This class is intended for use exclusively internally inside
+// of the Abseil Flags implementation.
+class PrivateHandleAccessor {
+ public:
+  // Access to CommandLineFlag::TypeId.
+  static FlagFastTypeId TypeId(const CommandLineFlag& flag);
+
+  // Access to CommandLineFlag::SaveState.
+  static std::unique_ptr<FlagStateInterface> SaveState(CommandLineFlag& flag);
+
+  // Access to CommandLineFlag::IsSpecifiedOnCommandLine.
+  static bool IsSpecifiedOnCommandLine(const CommandLineFlag& flag);
+
+  // Access to CommandLineFlag::ValidateInputValue.
+  static bool ValidateInputValue(const CommandLineFlag& flag,
+                                 absl::string_view value);
+
+  // Access to CommandLineFlag::CheckDefaultValueParsingRoundtrip.
+  static void CheckDefaultValueParsingRoundtrip(const CommandLineFlag& flag);
+
+  static bool ParseFrom(CommandLineFlag& flag, absl::string_view value,
+                        flags_internal::FlagSettingMode set_mode,
+                        flags_internal::ValueSource source, std::string& error);
+};
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/program_name.h b/CAPI/cpp/grpc/include/absl/flags/internal/program_name.h
new file mode 100644
index 0000000..b99b94f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/program_name.h
@@ -0,0 +1,50 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_PROGRAM_NAME_H_
+#define ABSL_FLAGS_INTERNAL_PROGRAM_NAME_H_
+
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/strings/string_view.h"
+
+// --------------------------------------------------------------------
+// Program name
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+// Returns program invocation name or "UNKNOWN" if `SetProgramInvocationName()`
+// is never called. At the moment this is always set to argv[0] as part of
+// library initialization.
+std::string ProgramInvocationName();
+
+// Returns base name for program invocation name. For example, if
+//   ProgramInvocationName() == "a/b/mybinary"
+// then
+//   ShortProgramInvocationName() == "mybinary"
+std::string ShortProgramInvocationName();
+
+// Sets program invocation name to a new value. Should only be called once
+// during program initialization, before any threads are spawned.
+void SetProgramInvocationName(absl::string_view prog_name_str);
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_PROGRAM_NAME_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/registry.h b/CAPI/cpp/grpc/include/absl/flags/internal/registry.h
new file mode 100644
index 0000000..4b68c85
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/registry.h
@@ -0,0 +1,97 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_REGISTRY_H_
+#define ABSL_FLAGS_INTERNAL_REGISTRY_H_
+
+#include <functional>
+
+#include "absl/base/config.h"
+#include "absl/flags/commandlineflag.h"
+#include "absl/flags/internal/commandlineflag.h"
+#include "absl/strings/string_view.h"
+
+// --------------------------------------------------------------------
+// Global flags registry API.
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+// Executes specified visitor for each non-retired flag in the registry. While
+// callback are executed, the registry is locked and can't be changed.
+void ForEachFlag(std::function<void(CommandLineFlag&)> visitor);
+
+//-----------------------------------------------------------------------------
+
+bool RegisterCommandLineFlag(CommandLineFlag&, const char* filename);
+
+void FinalizeRegistry();
+
+//-----------------------------------------------------------------------------
+// Retired registrations:
+//
+// Retired flag registrations are treated specially. A 'retired' flag is
+// provided only for compatibility with automated invocations that still
+// name it.  A 'retired' flag:
+//   - is not bound to a C++ FLAGS_ reference.
+//   - has a type and a value, but that value is intentionally inaccessible.
+//   - does not appear in --help messages.
+//   - is fully supported by _all_ flag parsing routines.
+//   - consumes args normally, and complains about type mismatches in its
+//     argument.
+//   - emits a complaint but does not die (e.g. LOG(ERROR)) if it is
+//     accessed by name through the flags API for parsing or otherwise.
+//
+// The registrations for a flag happen in an unspecified order as the
+// initializers for the namespace-scope objects of a program are run.
+// Any number of weak registrations for a flag can weakly define the flag.
+// One non-weak registration will upgrade the flag from weak to non-weak.
+// Further weak registrations of a non-weak flag are ignored.
+//
+// This mechanism is designed to support moving dead flags into a
+// 'graveyard' library.  An example migration:
+//
+//   0: Remove references to this FLAGS_flagname in the C++ codebase.
+//   1: Register as 'retired' in old_lib.
+//   2: Make old_lib depend on graveyard.
+//   3: Add a redundant 'retired' registration to graveyard.
+//   4: Remove the old_lib 'retired' registration.
+//   5: Eventually delete the graveyard registration entirely.
+//
+
+// Retire flag with name "name" and type indicated by ops.
+void Retire(const char* name, FlagFastTypeId type_id, char* buf);
+
+constexpr size_t kRetiredFlagObjSize = 3 * sizeof(void*);
+constexpr size_t kRetiredFlagObjAlignment = alignof(void*);
+
+// Registered a retired flag with name 'flag_name' and type 'T'.
+template <typename T>
+class RetiredFlag {
+ public:
+  void Retire(const char* flag_name) {
+    flags_internal::Retire(flag_name, base_internal::FastTypeId<T>(), buf_);
+  }
+
+ private:
+  alignas(kRetiredFlagObjAlignment) char buf_[kRetiredFlagObjSize];
+};
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_REGISTRY_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/sequence_lock.h b/CAPI/cpp/grpc/include/absl/flags/internal/sequence_lock.h
new file mode 100644
index 0000000..36318ab
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/sequence_lock.h
@@ -0,0 +1,187 @@
+//
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
+#define ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <atomic>
+#include <cassert>
+#include <cstring>
+
+#include "absl/base/optimization.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+// Align 'x' up to the nearest 'align' bytes.
+inline constexpr size_t AlignUp(size_t x, size_t align) {
+  return align * ((x + align - 1) / align);
+}
+
+// A SequenceLock implements lock-free reads. A sequence counter is incremented
+// before and after each write, and readers access the counter before and after
+// accessing the protected data. If the counter is verified to not change during
+// the access, and the sequence counter value was even, then the reader knows
+// that the read was race-free and valid. Otherwise, the reader must fall back
+// to a Mutex-based code path.
+//
+// This particular SequenceLock starts in an "uninitialized" state in which
+// TryRead() returns false. It must be enabled by calling MarkInitialized().
+// This serves as a marker that the associated flag value has not yet been
+// initialized and a slow path needs to be taken.
+//
+// The memory reads and writes protected by this lock must use the provided
+// `TryRead()` and `Write()` functions. These functions behave similarly to
+// `memcpy()`, with one oddity: the protected data must be an array of
+// `std::atomic<uint64>`. This is to comply with the C++ standard, which
+// considers data races on non-atomic objects to be undefined behavior. See "Can
+// Seqlocks Get Along With Programming Language Memory Models?"[1] by Hans J.
+// Boehm for more details.
+//
+// [1] https://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf
+class SequenceLock {
+ public:
+  constexpr SequenceLock() : lock_(kUninitialized) {}
+
+  // Mark that this lock is ready for use.
+  void MarkInitialized() {
+    assert(lock_.load(std::memory_order_relaxed) == kUninitialized);
+    lock_.store(0, std::memory_order_release);
+  }
+
+  // Copy "size" bytes of data from "src" to "dst", protected as a read-side
+  // critical section of the sequence lock.
+  //
+  // Unlike traditional sequence lock implementations which loop until getting a
+  // clean read, this implementation returns false in the case of concurrent
+  // calls to `Write`. In such a case, the caller should fall back to a
+  // locking-based slow path.
+  //
+  // Returns false if the sequence lock was not yet marked as initialized.
+  //
+  // NOTE: If this returns false, "dst" may be overwritten with undefined
+  // (potentially uninitialized) data.
+  bool TryRead(void* dst, const std::atomic<uint64_t>* src, size_t size) const {
+    // Acquire barrier ensures that no loads done by f() are reordered
+    // above the first load of the sequence counter.
+    int64_t seq_before = lock_.load(std::memory_order_acquire);
+    if (ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false;
+    RelaxedCopyFromAtomic(dst, src, size);
+    // Another acquire fence ensures that the load of 'lock_' below is
+    // strictly ordered after the RelaxedCopyToAtomic call above.
+    std::atomic_thread_fence(std::memory_order_acquire);
+    int64_t seq_after = lock_.load(std::memory_order_relaxed);
+    return ABSL_PREDICT_TRUE(seq_before == seq_after);
+  }
+
+  // Copy "size" bytes from "src" to "dst" as a write-side critical section
+  // of the sequence lock. Any concurrent readers will be forced to retry
+  // until they get a read that does not conflict with this write.
+  //
+  // This call must be externally synchronized against other calls to Write,
+  // but may proceed concurrently with reads.
+  void Write(std::atomic<uint64_t>* dst, const void* src, size_t size) {
+    // We can use relaxed instructions to increment the counter since we
+    // are extenally synchronized. The std::atomic_thread_fence below
+    // ensures that the counter updates don't get interleaved with the
+    // copy to the data.
+    int64_t orig_seq = lock_.load(std::memory_order_relaxed);
+    assert((orig_seq & 1) == 0);  // Must be initially unlocked.
+    lock_.store(orig_seq + 1, std::memory_order_relaxed);
+
+    // We put a release fence between update to lock_ and writes to shared data.
+    // Thus all stores to shared data are effectively release operations and
+    // update to lock_ above cannot be re-ordered past any of them. Note that
+    // this barrier is not for the fetch_add above.  A release barrier for the
+    // fetch_add would be before it, not after.
+    std::atomic_thread_fence(std::memory_order_release);
+    RelaxedCopyToAtomic(dst, src, size);
+    // "Release" semantics ensure that none of the writes done by
+    // RelaxedCopyToAtomic() can be reordered after the following modification.
+    lock_.store(orig_seq + 2, std::memory_order_release);
+  }
+
+  // Return the number of times that Write() has been called.
+  //
+  // REQUIRES: This must be externally synchronized against concurrent calls to
+  // `Write()` or `IncrementModificationCount()`.
+  // REQUIRES: `MarkInitialized()` must have been previously called.
+  int64_t ModificationCount() const {
+    int64_t val = lock_.load(std::memory_order_relaxed);
+    assert(val != kUninitialized && (val & 1) == 0);
+    return val / 2;
+  }
+
+  // REQUIRES: This must be externally synchronized against concurrent calls to
+  // `Write()` or `ModificationCount()`.
+  // REQUIRES: `MarkInitialized()` must have been previously called.
+  void IncrementModificationCount() {
+    int64_t val = lock_.load(std::memory_order_relaxed);
+    assert(val != kUninitialized);
+    lock_.store(val + 2, std::memory_order_relaxed);
+  }
+
+ private:
+  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
+  // atomics.
+  static void RelaxedCopyFromAtomic(void* dst, const std::atomic<uint64_t>* src,
+                                    size_t size) {
+    char* dst_byte = static_cast<char*>(dst);
+    while (size >= sizeof(uint64_t)) {
+      uint64_t word = src->load(std::memory_order_relaxed);
+      std::memcpy(dst_byte, &word, sizeof(word));
+      dst_byte += sizeof(word);
+      src++;
+      size -= sizeof(word);
+    }
+    if (size > 0) {
+      uint64_t word = src->load(std::memory_order_relaxed);
+      std::memcpy(dst_byte, &word, size);
+    }
+  }
+
+  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
+  // atomics.
+  static void RelaxedCopyToAtomic(std::atomic<uint64_t>* dst, const void* src,
+                                  size_t size) {
+    const char* src_byte = static_cast<const char*>(src);
+    while (size >= sizeof(uint64_t)) {
+      uint64_t word;
+      std::memcpy(&word, src_byte, sizeof(word));
+      dst->store(word, std::memory_order_relaxed);
+      src_byte += sizeof(word);
+      dst++;
+      size -= sizeof(word);
+    }
+    if (size > 0) {
+      uint64_t word = 0;
+      std::memcpy(&word, src_byte, size);
+      dst->store(word, std::memory_order_relaxed);
+    }
+  }
+
+  static constexpr int64_t kUninitialized = -1;
+  std::atomic<int64_t> lock_;
+};
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/usage.h b/CAPI/cpp/grpc/include/absl/flags/internal/usage.h
new file mode 100644
index 0000000..c0bcac5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/usage.h
@@ -0,0 +1,104 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_INTERNAL_USAGE_H_
+#define ABSL_FLAGS_INTERNAL_USAGE_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/flags/commandlineflag.h"
+#include "absl/flags/declare.h"
+#include "absl/strings/string_view.h"
+
+// --------------------------------------------------------------------
+// Usage reporting interfaces
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+
+// The format to report the help messages in.
+enum class HelpFormat {
+  kHumanReadable,
+};
+
+// Streams the help message describing `flag` to `out`.
+// The default value for `flag` is included in the output.
+void FlagHelp(std::ostream& out, const CommandLineFlag& flag,
+              HelpFormat format = HelpFormat::kHumanReadable);
+
+// Produces the help messages for all flags matching the filter. A flag matches
+// the filter if it is defined in a file with a filename which includes
+// filter string as a substring. You can use '/' and '.' to restrict the
+// matching to a specific file names. For example:
+//   FlagsHelp(out, "/path/to/file.");
+// restricts help to only flags which resides in files named like:
+//  .../path/to/file.<ext>
+// for any extension 'ext'. If the filter is empty this function produces help
+// messages for all flags.
+void FlagsHelp(std::ostream& out, absl::string_view filter,
+               HelpFormat format, absl::string_view program_usage_message);
+
+// --------------------------------------------------------------------
+
+// If any of the 'usage' related command line flags (listed on the bottom of
+// this file) has been set this routine produces corresponding help message in
+// the specified output stream and returns:
+//  0 - if "version" or "only_check_flags" flags were set and handled.
+//  1 - if some other 'usage' related flag was set and handled.
+// -1 - if no usage flags were set on a commmand line.
+// Non negative return values are expected to be used as an exit code for a
+// binary.
+int HandleUsageFlags(std::ostream& out,
+                     absl::string_view program_usage_message);
+
+// --------------------------------------------------------------------
+// Globals representing usage reporting flags
+
+enum class HelpMode {
+  kNone,
+  kImportant,
+  kShort,
+  kFull,
+  kPackage,
+  kMatch,
+  kVersion,
+  kOnlyCheckArgs
+};
+
+// Returns substring to filter help output (--help=substr argument)
+std::string GetFlagsHelpMatchSubstr();
+// Returns the requested help mode.
+HelpMode GetFlagsHelpMode();
+// Returns the requested help format.
+HelpFormat GetFlagsHelpFormat();
+
+// These are corresponding setters to the attributes above.
+void SetFlagsHelpMatchSubstr(absl::string_view);
+void SetFlagsHelpMode(HelpMode);
+void SetFlagsHelpFormat(HelpFormat);
+
+// Deduces usage flags from the input argument in a form --name=value or
+// --name. argument is already split into name and value before we call this
+// function.
+bool DeduceUsageFlags(absl::string_view name, absl::string_view value);
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_INTERNAL_USAGE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/marshalling.h b/CAPI/cpp/grpc/include/absl/flags/marshalling.h
new file mode 100644
index 0000000..b1e2ffa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/marshalling.h
@@ -0,0 +1,356 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: marshalling.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the API for extending Abseil flag support to
+// custom types, and defines the set of overloads for fundamental types.
+//
+// Out of the box, the Abseil flags library supports the following types:
+//
+// * `bool`
+// * `int16_t`
+// * `uint16_t`
+// * `int32_t`
+// * `uint32_t`
+// * `int64_t`
+// * `uint64_t`
+// * `float`
+// * `double`
+// * `std::string`
+// * `std::vector<std::string>`
+// * `std::optional<T>`
+// * `absl::LogSeverity` (provided natively for layering reasons)
+//
+// Note that support for integral types is implemented using overloads for
+// variable-width fundamental types (`short`, `int`, `long`, etc.). However,
+// you should prefer the fixed-width integral types (`int32_t`, `uint64_t`,
+// etc.) we've noted above within flag definitions.
+//
+// In addition, several Abseil libraries provide their own custom support for
+// Abseil flags. Documentation for these formats is provided in the type's
+// `AbslParseFlag()` definition.
+//
+// The Abseil time library provides the following support for civil time values:
+//
+// * `absl::CivilSecond`
+// * `absl::CivilMinute`
+// * `absl::CivilHour`
+// * `absl::CivilDay`
+// * `absl::CivilMonth`
+// * `absl::CivilYear`
+//
+// and also provides support for the following absolute time values:
+//
+// * `absl::Duration`
+// * `absl::Time`
+//
+// Additional support for Abseil types will be noted here as it is added.
+//
+// You can also provide your own custom flags by adding overloads for
+// `AbslParseFlag()` and `AbslUnparseFlag()` to your type definitions. (See
+// below.)
+//
+// -----------------------------------------------------------------------------
+// Optional Flags
+// -----------------------------------------------------------------------------
+//
+// The Abseil flags library supports flags of type `std::optional<T>` where
+// `T` is a type of one of the supported flags. We refer to this flag type as
+// an "optional flag." An optional flag is either "valueless", holding no value
+// of type `T` (indicating that the flag has not been set) or a value of type
+// `T`. The valueless state in C++ code is represented by a value of
+// `std::nullopt` for the optional flag.
+//
+// Using `std::nullopt` as an optional flag's default value allows you to check
+// whether such a flag was ever specified on the command line:
+//
+//   if (absl::GetFlag(FLAGS_foo).has_value()) {
+//     // flag was set on command line
+//   } else {
+//     // flag was not passed on command line
+//   }
+//
+// Using an optional flag in this manner avoids common workarounds for
+// indicating such an unset flag (such as using sentinal values to indicate this
+// state).
+//
+// An optional flag also allows a developer to pass a flag in an "unset"
+// valueless state on the command line, allowing the flag to later be set in
+// binary logic. An optional flag's valueless state is indicated by the special
+// notation of passing the value as an empty string through the syntax `--flag=`
+// or `--flag ""`.
+//
+//   $ binary_with_optional --flag_in_unset_state=
+//   $ binary_with_optional --flag_in_unset_state ""
+//
+// Note: as a result of the above syntax requirements, an optional flag cannot
+// be set to a `T` of any value which unparses to the empty string.
+//
+// -----------------------------------------------------------------------------
+// Adding Type Support for Abseil Flags
+// -----------------------------------------------------------------------------
+//
+// To add support for your user-defined type, add overloads of `AbslParseFlag()`
+// and `AbslUnparseFlag()` as free (non-member) functions to your type. If `T`
+// is a class type, these functions can be friend function definitions. These
+// overloads must be added to the same namespace where the type is defined, so
+// that they can be discovered by Argument-Dependent Lookup (ADL).
+//
+// Example:
+//
+//   namespace foo {
+//
+//   enum OutputMode { kPlainText, kHtml };
+//
+//   // AbslParseFlag converts from a string to OutputMode.
+//   // Must be in same namespace as OutputMode.
+//
+//   // Parses an OutputMode from the command line flag value `text`. Returns
+//   // `true` and sets `*mode` on success; returns `false` and sets `*error`
+//   // on failure.
+//   bool AbslParseFlag(absl::string_view text,
+//                      OutputMode* mode,
+//                      std::string* error) {
+//     if (text == "plaintext") {
+//       *mode = kPlainText;
+//       return true;
+//     }
+//     if (text == "html") {
+//       *mode = kHtml;
+//      return true;
+//     }
+//     *error = "unknown value for enumeration";
+//     return false;
+//  }
+//
+//  // AbslUnparseFlag converts from an OutputMode to a string.
+//  // Must be in same namespace as OutputMode.
+//
+//  // Returns a textual flag value corresponding to the OutputMode `mode`.
+//  std::string AbslUnparseFlag(OutputMode mode) {
+//    switch (mode) {
+//      case kPlainText: return "plaintext";
+//      case kHtml: return "html";
+//    }
+//    return absl::StrCat(mode);
+//  }
+//
+// Notice that neither `AbslParseFlag()` nor `AbslUnparseFlag()` are class
+// members, but free functions. `AbslParseFlag/AbslUnparseFlag()` overloads
+// for a type should only be declared in the same file and namespace as said
+// type. The proper `AbslParseFlag/AbslUnparseFlag()` implementations for a
+// given type will be discovered via Argument-Dependent Lookup (ADL).
+//
+// `AbslParseFlag()` may need, in turn, to parse simpler constituent types
+// using `absl::ParseFlag()`. For example, a custom struct `MyFlagType`
+// consisting of a `std::pair<int, std::string>` would add an `AbslParseFlag()`
+// overload for its `MyFlagType` like so:
+//
+// Example:
+//
+//   namespace my_flag_type {
+//
+//   struct MyFlagType {
+//     std::pair<int, std::string> my_flag_data;
+//   };
+//
+//   bool AbslParseFlag(absl::string_view text, MyFlagType* flag,
+//                      std::string* err);
+//
+//   std::string AbslUnparseFlag(const MyFlagType&);
+//
+//   // Within the implementation, `AbslParseFlag()` will, in turn invoke
+//   // `absl::ParseFlag()` on its constituent `int` and `std::string` types
+//   // (which have built-in Abseil flag support).
+//
+//   bool AbslParseFlag(absl::string_view text, MyFlagType* flag,
+//                      std::string* err) {
+//     std::pair<absl::string_view, absl::string_view> tokens =
+//         absl::StrSplit(text, ',');
+//     if (!absl::ParseFlag(tokens.first, &flag->my_flag_data.first, err))
+//         return false;
+//     if (!absl::ParseFlag(tokens.second, &flag->my_flag_data.second, err))
+//         return false;
+//     return true;
+//   }
+//
+//   // Similarly, for unparsing, we can simply invoke `absl::UnparseFlag()` on
+//   // the constituent types.
+//   std::string AbslUnparseFlag(const MyFlagType& flag) {
+//     return absl::StrCat(absl::UnparseFlag(flag.my_flag_data.first),
+//                         ",",
+//                         absl::UnparseFlag(flag.my_flag_data.second));
+//   }
+#ifndef ABSL_FLAGS_MARSHALLING_H_
+#define ABSL_FLAGS_MARSHALLING_H_
+
+#include "absl/base/config.h"
+
+#if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
+#include <optional>
+#endif
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Forward declaration to be used inside composable flag parse/unparse
+// implementations
+template <typename T>
+inline bool ParseFlag(absl::string_view input, T* dst, std::string* error);
+template <typename T>
+inline std::string UnparseFlag(const T& v);
+
+namespace flags_internal {
+
+// Overloads of `AbslParseFlag()` and `AbslUnparseFlag()` for fundamental types.
+bool AbslParseFlag(absl::string_view, bool*, std::string*);
+bool AbslParseFlag(absl::string_view, short*, std::string*);           // NOLINT
+bool AbslParseFlag(absl::string_view, unsigned short*, std::string*);  // NOLINT
+bool AbslParseFlag(absl::string_view, int*, std::string*);             // NOLINT
+bool AbslParseFlag(absl::string_view, unsigned int*, std::string*);    // NOLINT
+bool AbslParseFlag(absl::string_view, long*, std::string*);            // NOLINT
+bool AbslParseFlag(absl::string_view, unsigned long*, std::string*);   // NOLINT
+bool AbslParseFlag(absl::string_view, long long*, std::string*);       // NOLINT
+bool AbslParseFlag(absl::string_view, unsigned long long*,             // NOLINT
+                   std::string*);
+bool AbslParseFlag(absl::string_view, float*, std::string*);
+bool AbslParseFlag(absl::string_view, double*, std::string*);
+bool AbslParseFlag(absl::string_view, std::string*, std::string*);
+bool AbslParseFlag(absl::string_view, std::vector<std::string>*, std::string*);
+
+template <typename T>
+bool AbslParseFlag(absl::string_view text, absl::optional<T>* f,
+                   std::string* err) {
+  if (text.empty()) {
+    *f = absl::nullopt;
+    return true;
+  }
+  T value;
+  if (!absl::ParseFlag(text, &value, err)) return false;
+
+  *f = std::move(value);
+  return true;
+}
+
+#if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
+template <typename T>
+bool AbslParseFlag(absl::string_view text, std::optional<T>* f,
+                   std::string* err) {
+  if (text.empty()) {
+    *f = std::nullopt;
+    return true;
+  }
+  T value;
+  if (!absl::ParseFlag(text, &value, err)) return false;
+
+  *f = std::move(value);
+  return true;
+}
+#endif
+
+template <typename T>
+bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) {
+  // Comment on next line provides a good compiler error message if T
+  // does not have AbslParseFlag(absl::string_view, T*, std::string*).
+  return AbslParseFlag(input, dst, err);  // Is T missing AbslParseFlag?
+}
+
+// Strings and std:: containers do not have the same overload resolution
+// considerations as fundamental types. Naming these 'AbslUnparseFlag' means we
+// can avoid the need for additional specializations of Unparse (below).
+std::string AbslUnparseFlag(absl::string_view v);
+std::string AbslUnparseFlag(const std::vector<std::string>&);
+
+template <typename T>
+std::string AbslUnparseFlag(const absl::optional<T>& f) {
+  return f.has_value() ? absl::UnparseFlag(*f) : "";
+}
+
+#if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
+template <typename T>
+std::string AbslUnparseFlag(const std::optional<T>& f) {
+  return f.has_value() ? absl::UnparseFlag(*f) : "";
+}
+#endif
+
+template <typename T>
+std::string Unparse(const T& v) {
+  // Comment on next line provides a good compiler error message if T does not
+  // have UnparseFlag.
+  return AbslUnparseFlag(v);  // Is T missing AbslUnparseFlag?
+}
+
+// Overloads for builtin types.
+std::string Unparse(bool v);
+std::string Unparse(short v);               // NOLINT
+std::string Unparse(unsigned short v);      // NOLINT
+std::string Unparse(int v);                 // NOLINT
+std::string Unparse(unsigned int v);        // NOLINT
+std::string Unparse(long v);                // NOLINT
+std::string Unparse(unsigned long v);       // NOLINT
+std::string Unparse(long long v);           // NOLINT
+std::string Unparse(unsigned long long v);  // NOLINT
+std::string Unparse(float v);
+std::string Unparse(double v);
+
+}  // namespace flags_internal
+
+// ParseFlag()
+//
+// Parses a string value into a flag value of type `T`. Do not add overloads of
+// this function for your type directly; instead, add an `AbslParseFlag()`
+// free function as documented above.
+//
+// Some implementations of `AbslParseFlag()` for types which consist of other,
+// constituent types which already have Abseil flag support, may need to call
+// `absl::ParseFlag()` on those consituent string values. (See above.)
+template <typename T>
+inline bool ParseFlag(absl::string_view input, T* dst, std::string* error) {
+  return flags_internal::InvokeParseFlag(input, dst, error);
+}
+
+// UnparseFlag()
+//
+// Unparses a flag value of type `T` into a string value. Do not add overloads
+// of this function for your type directly; instead, add an `AbslUnparseFlag()`
+// free function as documented above.
+//
+// Some implementations of `AbslUnparseFlag()` for types which consist of other,
+// constituent types which already have Abseil flag support, may want to call
+// `absl::UnparseFlag()` on those constituent types. (See above.)
+template <typename T>
+inline std::string UnparseFlag(const T& v) {
+  return flags_internal::Unparse(v);
+}
+
+// Overloads for `absl::LogSeverity` can't (easily) appear alongside that type's
+// definition because it is layered below flags.  See proper documentation in
+// base/log_severity.h.
+enum class LogSeverity : int;
+bool AbslParseFlag(absl::string_view, absl::LogSeverity*, std::string*);
+std::string AbslUnparseFlag(absl::LogSeverity);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_MARSHALLING_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/parse.h b/CAPI/cpp/grpc/include/absl/flags/parse.h
new file mode 100644
index 0000000..929de2c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/parse.h
@@ -0,0 +1,60 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: parse.h
+// -----------------------------------------------------------------------------
+//
+// This file defines the main parsing function for Abseil flags:
+// `absl::ParseCommandLine()`.
+
+#ifndef ABSL_FLAGS_PARSE_H_
+#define ABSL_FLAGS_PARSE_H_
+
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/flags/internal/parse.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// ParseCommandLine()
+//
+// Parses the set of command-line arguments passed in the `argc` (argument
+// count) and `argv[]` (argument vector) parameters from `main()`, assigning
+// values to any defined Abseil flags. (Any arguments passed after the
+// flag-terminating delimiter (`--`) are treated as positional arguments and
+// ignored.)
+//
+// Any command-line flags (and arguments to those flags) are parsed into Abseil
+// Flag values, if those flags are defined. Any undefined flags will either
+// return an error, or be ignored if that flag is designated using `undefok` to
+// indicate "undefined is OK."
+//
+// Any command-line positional arguments not part of any command-line flag (or
+// arguments to a flag) are returned in a vector, with the program invocation
+// name at position 0 of that vector. (Note that this includes positional
+// arguments after the flag-terminating delimiter `--`.)
+//
+// After all flags and flag arguments are parsed, this function looks for any
+// built-in usage flags (e.g. `--help`), and if any were specified, it reports
+// help messages and then exits the program.
+std::vector<char*> ParseCommandLine(int argc, char* argv[]);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_PARSE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/reflection.h b/CAPI/cpp/grpc/include/absl/flags/reflection.h
new file mode 100644
index 0000000..e6baf5d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/reflection.h
@@ -0,0 +1,90 @@
+//
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: reflection.h
+// -----------------------------------------------------------------------------
+//
+// This file defines the routines to access and operate on an Abseil Flag's
+// reflection handle.
+
+#ifndef ABSL_FLAGS_REFLECTION_H_
+#define ABSL_FLAGS_REFLECTION_H_
+
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/flags/commandlineflag.h"
+#include "absl/flags/internal/commandlineflag.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace flags_internal {
+class FlagSaverImpl;
+}  // namespace flags_internal
+
+// FindCommandLineFlag()
+//
+// Returns the reflection handle of an Abseil flag of the specified name, or
+// `nullptr` if not found. This function will emit a warning if the name of a
+// 'retired' flag is specified.
+absl::CommandLineFlag* FindCommandLineFlag(absl::string_view name);
+
+// Returns current state of the Flags registry in a form of mapping from flag
+// name to a flag reflection handle.
+absl::flat_hash_map<absl::string_view, absl::CommandLineFlag*> GetAllFlags();
+
+//------------------------------------------------------------------------------
+// FlagSaver
+//------------------------------------------------------------------------------
+//
+// A FlagSaver object stores the state of flags in the scope where the FlagSaver
+// is defined, allowing modification of those flags within that scope and
+// automatic restoration of the flags to their previous state upon leaving the
+// scope.
+//
+// A FlagSaver can be used within tests to temporarily change the test
+// environment and restore the test case to its previous state.
+//
+// Example:
+//
+//   void MyFunc() {
+//    absl::FlagSaver fs;
+//    ...
+//    absl::SetFlag(&FLAGS_myFlag, otherValue);
+//    ...
+//  } // scope of FlagSaver left, flags return to previous state
+//
+// This class is thread-safe.
+
+class FlagSaver {
+ public:
+  FlagSaver();
+  ~FlagSaver();
+
+  FlagSaver(const FlagSaver&) = delete;
+  void operator=(const FlagSaver&) = delete;
+
+ private:
+  flags_internal::FlagSaverImpl* impl_;
+};
+
+//-----------------------------------------------------------------------------
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_REFLECTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/usage.h b/CAPI/cpp/grpc/include/absl/flags/usage.h
new file mode 100644
index 0000000..ad12ab7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/usage.h
@@ -0,0 +1,43 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FLAGS_USAGE_H_
+#define ABSL_FLAGS_USAGE_H_
+
+#include "absl/base/config.h"
+#include "absl/strings/string_view.h"
+
+// --------------------------------------------------------------------
+// Usage reporting interfaces
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Sets the "usage" message to be used by help reporting routines.
+// For example:
+//  absl::SetProgramUsageMessage(
+//      absl::StrCat("This program does nothing.  Sample usage:\n", argv[0],
+//                   " <uselessarg1> <uselessarg2>"));
+// Do not include commandline flags in the usage: we do that for you!
+// Note: Calling SetProgramUsageMessage twice will trigger a call to std::exit.
+void SetProgramUsageMessage(absl::string_view new_usage_message);
+
+// Returns the usage message set by SetProgramUsageMessage().
+absl::string_view ProgramUsageMessage();
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FLAGS_USAGE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/usage_config.h b/CAPI/cpp/grpc/include/absl/flags/usage_config.h
new file mode 100644
index 0000000..ded7030
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/flags/usage_config.h
@@ -0,0 +1,135 @@
+//
+//  Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: usage_config.h
+// -----------------------------------------------------------------------------
+//
+// This file defines the main usage reporting configuration interfaces and
+// documents Abseil's supported built-in usage flags. If these flags are found
+// when parsing a command-line, Abseil will exit the program and display
+// appropriate help messages.
+#ifndef ABSL_FLAGS_USAGE_CONFIG_H_
+#define ABSL_FLAGS_USAGE_CONFIG_H_
+
+#include <functional>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/strings/string_view.h"
+
+// -----------------------------------------------------------------------------
+// Built-in Usage Flags
+// -----------------------------------------------------------------------------
+//
+// Abseil supports the following built-in usage flags. When passed, these flags
+// exit the program and :
+//
+// * --help
+//     Shows help on important flags for this binary
+// * --helpfull
+//     Shows help on all flags
+// * --helpshort
+//     Shows help on only the main module for this program
+// * --helppackage
+//     Shows help on all modules in the main package
+// * --version
+//     Shows the version and build info for this binary and exits
+// * --only_check_args
+//     Exits after checking all flags
+// * --helpon
+//     Shows help on the modules named by this flag value
+// * --helpmatch
+//     Shows help on modules whose name contains the specified substring
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace flags_internal {
+using FlagKindFilter = std::function<bool (absl::string_view)>;
+}  // namespace flags_internal
+
+// FlagsUsageConfig
+//
+// This structure contains the collection of callbacks for changing the behavior
+// of the usage reporting routines in Abseil Flags.
+struct FlagsUsageConfig {
+  // Returns true if flags defined in the given source code file should be
+  // reported with --helpshort flag. For example, if the file
+  // "path/to/my/code.cc" defines the flag "--my_flag", and
+  // contains_helpshort_flags("path/to/my/code.cc") returns true, invoking the
+  // program with --helpshort will include information about --my_flag in the
+  // program output.
+  flags_internal::FlagKindFilter contains_helpshort_flags;
+
+  // Returns true if flags defined in the filename should be reported with
+  // --help flag. For example, if the file
+  // "path/to/my/code.cc" defines the flag "--my_flag", and
+  // contains_help_flags("path/to/my/code.cc") returns true, invoking the
+  // program with --help will include information about --my_flag in the
+  // program output.
+  flags_internal::FlagKindFilter contains_help_flags;
+
+  // Returns true if flags defined in the filename should be reported with
+  // --helppackage flag. For example, if the file
+  // "path/to/my/code.cc" defines the flag "--my_flag", and
+  // contains_helppackage_flags("path/to/my/code.cc") returns true, invoking the
+  // program with --helppackage will include information about --my_flag in the
+  // program output.
+  flags_internal::FlagKindFilter contains_helppackage_flags;
+
+  // Generates string containing program version. This is the string reported
+  // when user specifies --version in a command line.
+  std::function<std::string()> version_string;
+
+  // Normalizes the filename specific to the build system/filesystem used. This
+  // routine is used when we report the information about the flag definition
+  // location. For instance, if your build resides at some location you do not
+  // want to expose in the usage output, you can trim it to show only relevant
+  // part.
+  // For example:
+  //   normalize_filename("/my_company/some_long_path/src/project/file.cc")
+  // might produce
+  //   "project/file.cc".
+  std::function<std::string(absl::string_view)> normalize_filename;
+};
+
+// SetFlagsUsageConfig()
+//
+// Sets the usage reporting configuration callbacks. If any of the callbacks are
+// not set in usage_config instance, then the default value of the callback is
+// used.
+void SetFlagsUsageConfig(FlagsUsageConfig usage_config);
+
+namespace flags_internal {
+
+FlagsUsageConfig GetUsageConfig();
+
+void ReportUsageError(absl::string_view msg, bool is_fatal);
+
+}  // namespace flags_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+extern "C" {
+
+// Additional report of fatal usage error message before we std::exit. Error is
+// fatal if is_fatal argument to ReportUsageError is true.
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)(
+    absl::string_view);
+
+}  // extern "C"
+
+#endif  // ABSL_FLAGS_USAGE_CONFIG_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/any_invocable.h b/CAPI/cpp/grpc/include/absl/functional/any_invocable.h
new file mode 100644
index 0000000..0c5faca
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/functional/any_invocable.h
@@ -0,0 +1,313 @@
+// Copyright 2022 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: any_invocable.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines an `absl::AnyInvocable` type that assumes ownership
+// and wraps an object of an invocable type. (Invocable types adhere to the
+// concept specified in https://en.cppreference.com/w/cpp/concepts/invocable.)
+//
+// In general, prefer `absl::AnyInvocable` when you need a type-erased
+// function parameter that needs to take ownership of the type.
+//
+// NOTE: `absl::AnyInvocable` is similar to the C++23 `std::move_only_function`
+// abstraction, but has a slightly different API and is not designed to be a
+// drop-in replacement or C++11-compatible backfill of that type.
+
+#ifndef ABSL_FUNCTIONAL_ANY_INVOCABLE_H_
+#define ABSL_FUNCTIONAL_ANY_INVOCABLE_H_
+
+#include <cstddef>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/functional/internal/any_invocable.h"
+#include "absl/meta/type_traits.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::AnyInvocable
+//
+// `absl::AnyInvocable` is a functional wrapper type, like `std::function`, that
+// assumes ownership of an invocable object. Unlike `std::function`, an
+// `absl::AnyInvocable` is more type-safe and provides the following additional
+// benefits:
+//
+// * Properly adheres to const correctness of the underlying type
+// * Is move-only so avoids concurrency problems with copied invocables and
+//   unnecessary copies in general.
+// * Supports reference qualifiers allowing it to perform unique actions (noted
+//   below).
+//
+// `absl::AnyInvocable` is a template, and an `absl::AnyInvocable` instantiation
+// may wrap any invocable object with a compatible function signature, e.g.
+// having arguments and return types convertible to types matching the
+// `absl::AnyInvocable` signature, and also matching any stated reference
+// qualifiers, as long as that type is moveable. It therefore provides broad
+// type erasure for functional objects.
+//
+// An `absl::AnyInvocable` is typically used as a type-erased function parameter
+// for accepting various functional objects:
+//
+// // Define a function taking an AnyInvocable parameter.
+// void my_func(absl::AnyInvocable<int()> f) {
+//   ...
+// };
+//
+// // That function can accept any invocable type:
+//
+// // Accept a function reference. We don't need to move a reference.
+// int func1() { return 0; };
+// my_func(func1);
+//
+// // Accept a lambda. We use std::move here because otherwise my_func would
+// // copy the lambda.
+// auto lambda = []() { return 0; };
+// my_func(std::move(lambda));
+//
+// // Accept a function pointer. We don't need to move a function pointer.
+// func2 = &func1;
+// my_func(func2);
+//
+// // Accept an std::function by moving it. Note that the lambda is copyable
+// // (satisfying std::function requirements) and moveable (satisfying
+// // absl::AnyInvocable requirements).
+// std::function<int()> func6 = []() { return 0; };
+// my_func(std::move(func6));
+//
+// `AnyInvocable` also properly respects `const` qualifiers, reference
+// qualifiers, and the `noexcept` specification (only in C++ 17 and beyond) as
+// part of the user-specified function type (e.g.
+// `AnyInvocable<void()&& const noexcept>`). These qualifiers will be applied to
+// the `AnyInvocable` object's `operator()`, and the underlying invocable must
+// be compatible with those qualifiers.
+//
+// Comparison of const and non-const function types:
+//
+//   // Store a closure inside of `func` with the function type `int()`.
+//   // Note that we have made `func` itself `const`.
+//   const AnyInvocable<int()> func = [](){ return 0; };
+//
+//   func();  // Compile-error: the passed type `int()` isn't `const`.
+//
+//   // Store a closure inside of `const_func` with the function type
+//   // `int() const`.
+//   // Note that we have also made `const_func` itself `const`.
+//   const AnyInvocable<int() const> const_func = [](){ return 0; };
+//
+//   const_func();  // Fine: `int() const` is `const`.
+//
+// In the above example, the call `func()` would have compiled if
+// `std::function` were used even though the types are not const compatible.
+// This is a bug, and using `absl::AnyInvocable` properly detects that bug.
+//
+// In addition to affecting the signature of `operator()`, the `const` and
+// reference qualifiers of the function type also appropriately constrain which
+// kinds of invocable objects you are allowed to place into the `AnyInvocable`
+// instance. If you specify a function type that is const-qualified, then
+// anything that you attempt to put into the `AnyInvocable` must be callable on
+// a `const` instance of that type.
+//
+// Constraint example:
+//
+//   // Fine because the lambda is callable when `const`.
+//   AnyInvocable<int() const> func = [=](){ return 0; };
+//
+//   // This is a compile-error because the lambda isn't callable when `const`.
+//   AnyInvocable<int() const> error = [=]() mutable { return 0; };
+//
+// An `&&` qualifier can be used to express that an `absl::AnyInvocable`
+// instance should be invoked at most once:
+//
+//   // Invokes `continuation` with the logical result of an operation when
+//   // that operation completes (common in asynchronous code).
+//   void CallOnCompletion(AnyInvocable<void(int)&&> continuation) {
+//     int result_of_foo = foo();
+//
+//     // `std::move` is required because the `operator()` of `continuation` is
+//     // rvalue-reference qualified.
+//     std::move(continuation)(result_of_foo);
+//   }
+//
+// Credits to Matt Calabrese (https://github.com/mattcalabrese) for the original
+// implementation.
+template <class Sig>
+class AnyInvocable : private internal_any_invocable::Impl<Sig> {
+ private:
+  static_assert(
+      std::is_function<Sig>::value,
+      "The template argument of AnyInvocable must be a function type.");
+
+  using Impl = internal_any_invocable::Impl<Sig>;
+
+ public:
+  // The return type of Sig
+  using result_type = typename Impl::result_type;
+
+  // Constructors
+
+  // Constructs the `AnyInvocable` in an empty state.
+  AnyInvocable() noexcept = default;
+  AnyInvocable(std::nullptr_t) noexcept {}  // NOLINT
+
+  // Constructs the `AnyInvocable` from an existing `AnyInvocable` by a move.
+  // Note that `f` is not guaranteed to be empty after move-construction,
+  // although it may be.
+  AnyInvocable(AnyInvocable&& /*f*/) noexcept = default;
+
+  // Constructs an `AnyInvocable` from an invocable object.
+  //
+  // Upon construction, `*this` is only empty if `f` is a function pointer or
+  // member pointer type and is null, or if `f` is an `AnyInvocable` that is
+  // empty.
+  template <class F, typename = absl::enable_if_t<
+                         internal_any_invocable::CanConvert<Sig, F>::value>>
+  AnyInvocable(F&& f)  // NOLINT
+      : Impl(internal_any_invocable::ConversionConstruct(),
+             std::forward<F>(f)) {}
+
+  // Constructs an `AnyInvocable` that holds an invocable object of type `T`,
+  // which is constructed in-place from the given arguments.
+  //
+  // Example:
+  //
+  //   AnyInvocable<int(int)> func(
+  //       absl::in_place_type<PossiblyImmovableType>, arg1, arg2);
+  //
+  template <class T, class... Args,
+            typename = absl::enable_if_t<
+                internal_any_invocable::CanEmplace<Sig, T, Args...>::value>>
+  explicit AnyInvocable(absl::in_place_type_t<T>, Args&&... args)
+      : Impl(absl::in_place_type<absl::decay_t<T>>,
+             std::forward<Args>(args)...) {
+    static_assert(std::is_same<T, absl::decay_t<T>>::value,
+                  "The explicit template argument of in_place_type is required "
+                  "to be an unqualified object type.");
+  }
+
+  // Overload of the above constructor to support list-initialization.
+  template <class T, class U, class... Args,
+            typename = absl::enable_if_t<internal_any_invocable::CanEmplace<
+                Sig, T, std::initializer_list<U>&, Args...>::value>>
+  explicit AnyInvocable(absl::in_place_type_t<T>,
+                        std::initializer_list<U> ilist, Args&&... args)
+      : Impl(absl::in_place_type<absl::decay_t<T>>, ilist,
+             std::forward<Args>(args)...) {
+    static_assert(std::is_same<T, absl::decay_t<T>>::value,
+                  "The explicit template argument of in_place_type is required "
+                  "to be an unqualified object type.");
+  }
+
+  // Assignment Operators
+
+  // Assigns an `AnyInvocable` through move-assignment.
+  // Note that `f` is not guaranteed to be empty after move-assignment
+  // although it may be.
+  AnyInvocable& operator=(AnyInvocable&& /*f*/) noexcept = default;
+
+  // Assigns an `AnyInvocable` from a nullptr, clearing the `AnyInvocable`. If
+  // not empty, destroys the target, putting `*this` into an empty state.
+  AnyInvocable& operator=(std::nullptr_t) noexcept {
+    this->Clear();
+    return *this;
+  }
+
+  // Assigns an `AnyInvocable` from an existing `AnyInvocable` instance.
+  //
+  // Upon assignment, `*this` is only empty if `f` is a function pointer or
+  // member pointer type and is null, or if `f` is an `AnyInvocable` that is
+  // empty.
+  template <class F, typename = absl::enable_if_t<
+                         internal_any_invocable::CanAssign<Sig, F>::value>>
+  AnyInvocable& operator=(F&& f) {
+    *this = AnyInvocable(std::forward<F>(f));
+    return *this;
+  }
+
+  // Assigns an `AnyInvocable` from a reference to an invocable object.
+  // Upon assignment, stores a reference to the invocable object in the
+  // `AnyInvocable` instance.
+  template <
+      class F,
+      typename = absl::enable_if_t<
+          internal_any_invocable::CanAssignReferenceWrapper<Sig, F>::value>>
+  AnyInvocable& operator=(std::reference_wrapper<F> f) noexcept {
+    *this = AnyInvocable(f);
+    return *this;
+  }
+
+  // Destructor
+
+  // If not empty, destroys the target.
+  ~AnyInvocable() = default;
+
+  // absl::AnyInvocable::swap()
+  //
+  // Exchanges the targets of `*this` and `other`.
+  void swap(AnyInvocable& other) noexcept { std::swap(*this, other); }
+
+  // abl::AnyInvocable::operator bool()
+  //
+  // Returns `true` if `*this` is not empty.
+  explicit operator bool() const noexcept { return this->HasValue(); }
+
+  // Invokes the target object of `*this`. `*this` must not be empty.
+  //
+  // Note: The signature of this function call operator is the same as the
+  //       template parameter `Sig`.
+  using Impl::operator();
+
+  // Equality operators
+
+  // Returns `true` if `*this` is empty.
+  friend bool operator==(const AnyInvocable& f, std::nullptr_t) noexcept {
+    return !f.HasValue();
+  }
+
+  // Returns `true` if `*this` is empty.
+  friend bool operator==(std::nullptr_t, const AnyInvocable& f) noexcept {
+    return !f.HasValue();
+  }
+
+  // Returns `false` if `*this` is empty.
+  friend bool operator!=(const AnyInvocable& f, std::nullptr_t) noexcept {
+    return f.HasValue();
+  }
+
+  // Returns `false` if `*this` is empty.
+  friend bool operator!=(std::nullptr_t, const AnyInvocable& f) noexcept {
+    return f.HasValue();
+  }
+
+  // swap()
+  //
+  // Exchanges the targets of `f1` and `f2`.
+  friend void swap(AnyInvocable& f1, AnyInvocable& f2) noexcept { f1.swap(f2); }
+
+ private:
+  // Friending other instantiations is necessary for conversions.
+  template <bool /*SigIsNoexcept*/, class /*ReturnType*/, class... /*P*/>
+  friend class internal_any_invocable::CoreImpl;
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FUNCTIONAL_ANY_INVOCABLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/bind_front.h b/CAPI/cpp/grpc/include/absl/functional/bind_front.h
new file mode 100644
index 0000000..f9075bd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/functional/bind_front.h
@@ -0,0 +1,193 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: bind_front.h
+// -----------------------------------------------------------------------------
+//
+// `absl::bind_front()` returns a functor by binding a number of arguments to
+// the front of a provided (usually more generic) functor. Unlike `std::bind`,
+// it does not require the use of argument placeholders. The simpler syntax of
+// `absl::bind_front()` allows you to avoid known misuses with `std::bind()`.
+//
+// `absl::bind_front()` is meant as a drop-in replacement for C++20's upcoming
+// `std::bind_front()`, which similarly resolves these issues with
+// `std::bind()`. Both `bind_front()` alternatives, unlike `std::bind()`, allow
+// partial function application. (See
+// https://en.wikipedia.org/wiki/Partial_application).
+
+#ifndef ABSL_FUNCTIONAL_BIND_FRONT_H_
+#define ABSL_FUNCTIONAL_BIND_FRONT_H_
+
+#if defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
+#include <functional>  // For std::bind_front.
+#endif  // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
+
+#include "absl/functional/internal/front_binder.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// bind_front()
+//
+// Binds the first N arguments of an invocable object and stores them by value.
+//
+// Like `std::bind()`, `absl::bind_front()` is implicitly convertible to
+// `std::function`.  In particular, it may be used as a simpler replacement for
+// `std::bind()` in most cases, as it does not require  placeholders to be
+// specified. More importantly, it provides more reliable correctness guarantees
+// than `std::bind()`; while `std::bind()` will silently ignore passing more
+// parameters than expected, for example, `absl::bind_front()` will report such
+// mis-uses as errors. In C++20, `absl::bind_front` is replaced by
+// `std::bind_front`.
+//
+// absl::bind_front(a...) can be seen as storing the results of
+// std::make_tuple(a...).
+//
+// Example: Binding a free function.
+//
+//   int Minus(int a, int b) { return a - b; }
+//
+//   assert(absl::bind_front(Minus)(3, 2) == 3 - 2);
+//   assert(absl::bind_front(Minus, 3)(2) == 3 - 2);
+//   assert(absl::bind_front(Minus, 3, 2)() == 3 - 2);
+//
+// Example: Binding a member function.
+//
+//   struct Math {
+//     int Double(int a) const { return 2 * a; }
+//   };
+//
+//   Math math;
+//
+//   assert(absl::bind_front(&Math::Double)(&math, 3) == 2 * 3);
+//   // Stores a pointer to math inside the functor.
+//   assert(absl::bind_front(&Math::Double, &math)(3) == 2 * 3);
+//   // Stores a copy of math inside the functor.
+//   assert(absl::bind_front(&Math::Double, math)(3) == 2 * 3);
+//   // Stores std::unique_ptr<Math> inside the functor.
+//   assert(absl::bind_front(&Math::Double,
+//                           std::unique_ptr<Math>(new Math))(3) == 2 * 3);
+//
+// Example: Using `absl::bind_front()`, instead of `std::bind()`, with
+//          `std::function`.
+//
+//   class FileReader {
+//    public:
+//     void ReadFileAsync(const std::string& filename, std::string* content,
+//                        const std::function<void()>& done) {
+//       // Calls Executor::Schedule(std::function<void()>).
+//       Executor::DefaultExecutor()->Schedule(
+//           absl::bind_front(&FileReader::BlockingRead, this,
+//                            filename, content, done));
+//     }
+//
+//    private:
+//     void BlockingRead(const std::string& filename, std::string* content,
+//                       const std::function<void()>& done) {
+//       CHECK_OK(file::GetContents(filename, content, {}));
+//       done();
+//     }
+//   };
+//
+// `absl::bind_front()` stores bound arguments explicitly using the type passed
+// rather than implicitly based on the type accepted by its functor.
+//
+// Example: Binding arguments explicitly.
+//
+//   void LogStringView(absl::string_view sv) {
+//     LOG(INFO) << sv;
+//   }
+//
+//   Executor* e = Executor::DefaultExecutor();
+//   std::string s = "hello";
+//   absl::string_view sv = s;
+//
+//   // absl::bind_front(LogStringView, arg) makes a copy of arg and stores it.
+//   e->Schedule(absl::bind_front(LogStringView, sv)); // ERROR: dangling
+//                                                     // string_view.
+//
+//   e->Schedule(absl::bind_front(LogStringView, s));  // OK: stores a copy of
+//                                                     // s.
+//
+// To store some of the arguments passed to `absl::bind_front()` by reference,
+//  use std::ref()` and `std::cref()`.
+//
+// Example: Storing some of the bound arguments by reference.
+//
+//   class Service {
+//    public:
+//     void Serve(const Request& req, std::function<void()>* done) {
+//       // The request protocol buffer won't be deleted until done is called.
+//       // It's safe to store a reference to it inside the functor.
+//       Executor::DefaultExecutor()->Schedule(
+//           absl::bind_front(&Service::BlockingServe, this, std::cref(req),
+//           done));
+//     }
+//
+//    private:
+//     void BlockingServe(const Request& req, std::function<void()>* done);
+//   };
+//
+// Example: Storing bound arguments by reference.
+//
+//   void Print(const std::string& a, const std::string& b) {
+//     std::cerr << a << b;
+//   }
+//
+//   std::string hi = "Hello, ";
+//   std::vector<std::string> names = {"Chuk", "Gek"};
+//   // Doesn't copy hi.
+//   for_each(names.begin(), names.end(),
+//            absl::bind_front(Print, std::ref(hi)));
+//
+//   // DO NOT DO THIS: the functor may outlive "hi", resulting in
+//   // dangling references.
+//   foo->DoInFuture(absl::bind_front(Print, std::ref(hi), "Guest"));  // BAD!
+//   auto f = absl::bind_front(Print, std::ref(hi), "Guest"); // BAD!
+//
+// Example: Storing reference-like types.
+//
+//   void Print(absl::string_view a, const std::string& b) {
+//     std::cerr << a << b;
+//   }
+//
+//   std::string hi = "Hello, ";
+//   // Copies "hi".
+//   absl::bind_front(Print, hi)("Chuk");
+//
+//   // Compile error: std::reference_wrapper<const string> is not implicitly
+//   // convertible to string_view.
+//   // absl::bind_front(Print, std::cref(hi))("Chuk");
+//
+//   // Doesn't copy "hi".
+//   absl::bind_front(Print, absl::string_view(hi))("Chuk");
+//
+#if defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
+using std::bind_front;
+#else   // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
+template <class F, class... BoundArgs>
+constexpr functional_internal::bind_front_t<F, BoundArgs...> bind_front(
+    F&& func, BoundArgs&&... args) {
+  return functional_internal::bind_front_t<F, BoundArgs...>(
+      absl::in_place, absl::forward<F>(func),
+      absl::forward<BoundArgs>(args)...);
+}
+#endif  // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FUNCTIONAL_BIND_FRONT_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/function_ref.h b/CAPI/cpp/grpc/include/absl/functional/function_ref.h
new file mode 100644
index 0000000..f977960
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/functional/function_ref.h
@@ -0,0 +1,143 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: function_ref.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::FunctionRef` type for holding a
+// non-owning reference to an object of any invocable type. This function
+// reference is typically most useful as a type-erased argument type for
+// accepting function types that neither take ownership nor copy the type; using
+// the reference type in this case avoids a copy and an allocation. Best
+// practices of other non-owning reference-like objects (such as
+// `absl::string_view`) apply here.
+//
+//  An `absl::FunctionRef` is similar in usage to a `std::function` but has the
+//  following differences:
+//
+//  * It doesn't own the underlying object.
+//  * It doesn't have a null or empty state.
+//  * It never performs deep copies or allocations.
+//  * It's much faster and cheaper to construct.
+//  * It's trivially copyable and destructable.
+//
+// Generally, `absl::FunctionRef` should not be used as a return value, data
+// member, or to initialize a `std::function`. Such usages will often lead to
+// problematic lifetime issues. Once you convert something to an
+// `absl::FunctionRef` you cannot make a deep copy later.
+//
+// This class is suitable for use wherever a "const std::function<>&"
+// would be used without making a copy. ForEach functions and other versions of
+// the visitor pattern are a good example of when this class should be used.
+//
+// This class is trivial to copy and should be passed by value.
+#ifndef ABSL_FUNCTIONAL_FUNCTION_REF_H_
+#define ABSL_FUNCTIONAL_FUNCTION_REF_H_
+
+#include <cassert>
+#include <functional>
+#include <type_traits>
+
+#include "absl/base/attributes.h"
+#include "absl/functional/internal/function_ref.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// FunctionRef
+//
+// Dummy class declaration to allow the partial specialization based on function
+// types below.
+template <typename T>
+class FunctionRef;
+
+// FunctionRef
+//
+// An `absl::FunctionRef` is a lightweight wrapper to any invokable object with
+// a compatible signature. Generally, an `absl::FunctionRef` should only be used
+// as an argument type and should be preferred as an argument over a const
+// reference to a `std::function`. `absl::FunctionRef` itself does not allocate,
+// although the wrapped invokable may.
+//
+// Example:
+//
+//   // The following function takes a function callback by const reference
+//   bool Visitor(const std::function<void(my_proto&,
+//                                         absl::string_view)>& callback);
+//
+//   // Assuming that the function is not stored or otherwise copied, it can be
+//   // replaced by an `absl::FunctionRef`:
+//   bool Visitor(absl::FunctionRef<void(my_proto&, absl::string_view)>
+//                  callback);
+//
+// Note: the assignment operator within an `absl::FunctionRef` is intentionally
+// deleted to prevent misuse; because the `absl::FunctionRef` does not own the
+// underlying type, assignment likely indicates misuse.
+template <typename R, typename... Args>
+class FunctionRef<R(Args...)> {
+ private:
+  // Used to disable constructors for objects that are not compatible with the
+  // signature of this FunctionRef.
+  template <typename F,
+            typename FR = absl::base_internal::invoke_result_t<F, Args&&...>>
+  using EnableIfCompatible =
+      typename std::enable_if<std::is_void<R>::value ||
+                              std::is_convertible<FR, R>::value>::type;
+
+ public:
+  // Constructs a FunctionRef from any invokable type.
+  template <typename F, typename = EnableIfCompatible<const F&>>
+  // NOLINTNEXTLINE(runtime/explicit)
+  FunctionRef(const F& f ABSL_ATTRIBUTE_LIFETIME_BOUND)
+      : invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) {
+    absl::functional_internal::AssertNonNull(f);
+    ptr_.obj = &f;
+  }
+
+  // Overload for function pointers. This eliminates a level of indirection that
+  // would happen if the above overload was used (it lets us store the pointer
+  // instead of a pointer to a pointer).
+  //
+  // This overload is also used for references to functions, since references to
+  // functions can decay to function pointers implicitly.
+  template <
+      typename F, typename = EnableIfCompatible<F*>,
+      absl::functional_internal::EnableIf<absl::is_function<F>::value> = 0>
+  FunctionRef(F* f)  // NOLINT(runtime/explicit)
+      : invoker_(&absl::functional_internal::InvokeFunction<F*, R, Args...>) {
+    assert(f != nullptr);
+    ptr_.fun = reinterpret_cast<decltype(ptr_.fun)>(f);
+  }
+
+  // To help prevent subtle lifetime bugs, FunctionRef is not assignable.
+  // Typically, it should only be used as an argument type.
+  FunctionRef& operator=(const FunctionRef& rhs) = delete;
+  FunctionRef(const FunctionRef& rhs) = default;
+
+  // Call the underlying object.
+  R operator()(Args... args) const {
+    return invoker_(ptr_, std::forward<Args>(args)...);
+  }
+
+ private:
+  absl::functional_internal::VoidPtr ptr_;
+  absl::functional_internal::Invoker<R, Args...> invoker_;
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FUNCTIONAL_FUNCTION_REF_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h b/CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h
new file mode 100644
index 0000000..f353139
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h
@@ -0,0 +1,857 @@
+// Copyright 2022 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Implementation details for `absl::AnyInvocable`
+
+#ifndef ABSL_FUNCTIONAL_INTERNAL_ANY_INVOCABLE_H_
+#define ABSL_FUNCTIONAL_INTERNAL_ANY_INVOCABLE_H_
+
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// This implementation of the proposed `any_invocable` uses an approach that  //
+// chooses between local storage and remote storage for the contained target  //
+// object based on the target object's size, alignment requirements, and      //
+// whether or not it has a nothrow move constructor. Additional optimizations //
+// are performed when the object is a trivially copyable type [basic.types].  //
+//                                                                            //
+// There are three datamembers per `AnyInvocable` instance                    //
+//                                                                            //
+// 1) A union containing either                                               //
+//        - A pointer to the target object referred to via a void*, or        //
+//        - the target object, emplaced into a raw char buffer                //
+//                                                                            //
+// 2) A function pointer to a "manager" function operation that takes a       //
+//    discriminator and logically branches to either perform a move operation //
+//    or destroy operation based on that discriminator.                       //
+//                                                                            //
+// 3) A function pointer to an "invoker" function operation that invokes the  //
+//    target object, directly returning the result.                           //
+//                                                                            //
+// When in the logically empty state, the manager function is an empty        //
+// function and the invoker function is one that would be undefined-behavior  //
+// to call.                                                                   //
+//                                                                            //
+// An additional optimization is performed when converting from one           //
+// AnyInvocable to another where only the noexcept specification and/or the   //
+// cv/ref qualifiers of the function type differ. In these cases, the         //
+// conversion works by "moving the guts", similar to if they were the same    //
+// exact type, as opposed to having to perform an additional layer of         //
+// wrapping through remote storage.                                           //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+// IWYU pragma: private, include "absl/functional/any_invocable.h"
+
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/invoke.h"
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Helper macro used to prevent spelling `noexcept` in language versions older
+// than C++17, where it is not part of the type system, in order to avoid
+// compilation failures and internal compiler errors.
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#define ABSL_INTERNAL_NOEXCEPT_SPEC(noex) noexcept(noex)
+#else
+#define ABSL_INTERNAL_NOEXCEPT_SPEC(noex)
+#endif
+
+// Defined in functional/any_invocable.h
+template <class Sig>
+class AnyInvocable;
+
+namespace internal_any_invocable {
+
+// Constants relating to the small-object-storage for AnyInvocable
+enum StorageProperty : std::size_t {
+  kAlignment = alignof(std::max_align_t),  // The alignment of the storage
+  kStorageSize = sizeof(void*) * 2         // The size of the storage
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction for checking if a type is an AnyInvocable instantiation.
+// This is used during conversion operations.
+template <class T>
+struct IsAnyInvocable : std::false_type {};
+
+template <class Sig>
+struct IsAnyInvocable<AnyInvocable<Sig>> : std::true_type {};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// A type trait that tells us whether or not a target function type should be
+// stored locally in the small object optimization storage
+template <class T>
+using IsStoredLocally = std::integral_constant<
+    bool, sizeof(T) <= kStorageSize && alignof(T) <= kAlignment &&
+              kAlignment % alignof(T) == 0 &&
+              std::is_nothrow_move_constructible<T>::value>;
+
+// An implementation of std::remove_cvref_t of C++20.
+template <class T>
+using RemoveCVRef =
+    typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// An implementation of the C++ standard INVOKE<R> pseudo-macro, operation is
+// equivalent to std::invoke except that it forces an implicit conversion to the
+// specified return type. If "R" is void, the function is executed and the
+// return value is simply ignored.
+template <class ReturnType, class F, class... P,
+          typename = absl::enable_if_t<std::is_void<ReturnType>::value>>
+void InvokeR(F&& f, P&&... args) {
+  absl::base_internal::invoke(std::forward<F>(f), std::forward<P>(args)...);
+}
+
+template <class ReturnType, class F, class... P,
+          absl::enable_if_t<!std::is_void<ReturnType>::value, int> = 0>
+ReturnType InvokeR(F&& f, P&&... args) {
+  return absl::base_internal::invoke(std::forward<F>(f),
+                                     std::forward<P>(args)...);
+}
+
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+///
+// A metafunction that takes a "T" corresponding to a parameter type of the
+// user's specified function type, and yields the parameter type to use for the
+// type-erased invoker. In order to prevent observable moves, this must be
+// either a reference or, if the type is trivial, the original parameter type
+// itself. Since the parameter type may be incomplete at the point that this
+// metafunction is used, we can only do this optimization for scalar types
+// rather than for any trivial type.
+template <typename T>
+T ForwardImpl(std::true_type);
+
+template <typename T>
+T&& ForwardImpl(std::false_type);
+
+// NOTE: We deliberately use an intermediate struct instead of a direct alias,
+// as a workaround for b/206991861 on MSVC versions < 1924.
+template <class T>
+struct ForwardedParameter {
+  using type = decltype((
+      ForwardImpl<T>)(std::integral_constant<bool,
+                                             std::is_scalar<T>::value>()));
+};
+
+template <class T>
+using ForwardedParameterType = typename ForwardedParameter<T>::type;
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// A discriminator when calling the "manager" function that describes operation
+// type-erased operation should be invoked.
+//
+// "relocate_from_to" specifies that the manager should perform a move.
+//
+// "dispose" specifies that the manager should perform a destroy.
+enum class FunctionToCall : bool { relocate_from_to, dispose };
+
+// The portion of `AnyInvocable` state that contains either a pointer to the
+// target object or the object itself in local storage
+union TypeErasedState {
+  struct {
+    // A pointer to the type-erased object when remotely stored
+    void* target;
+    // The size of the object for `RemoteManagerTrivial`
+    std::size_t size;
+  } remote;
+
+  // Local-storage for the type-erased object when small and trivial enough
+  alignas(kAlignment) char storage[kStorageSize];
+};
+
+// A typed accessor for the object in `TypeErasedState` storage
+template <class T>
+T& ObjectInLocalStorage(TypeErasedState* const state) {
+  // We launder here because the storage may be reused with the same type.
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
+  return *std::launder(reinterpret_cast<T*>(&state->storage));
+#elif ABSL_HAVE_BUILTIN(__builtin_launder)
+  return *__builtin_launder(reinterpret_cast<T*>(&state->storage));
+#else
+
+  // When `std::launder` or equivalent are not available, we rely on undefined
+  // behavior, which works as intended on Abseil's officially supported
+  // platforms as of Q2 2022.
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#endif
+  return *reinterpret_cast<T*>(&state->storage);
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+#endif
+}
+
+// The type for functions issuing lifetime-related operations: move and dispose
+// A pointer to such a function is contained in each `AnyInvocable` instance.
+// NOTE: When specifying `FunctionToCall::`dispose, the same state must be
+// passed as both "from" and "to".
+using ManagerType = void(FunctionToCall /*operation*/,
+                         TypeErasedState* /*from*/, TypeErasedState* /*to*/)
+    ABSL_INTERNAL_NOEXCEPT_SPEC(true);
+
+// The type for functions issuing the actual invocation of the object
+// A pointer to such a function is contained in each AnyInvocable instance.
+template <bool SigIsNoexcept, class ReturnType, class... P>
+using InvokerType = ReturnType(TypeErasedState*, ForwardedParameterType<P>...)
+    ABSL_INTERNAL_NOEXCEPT_SPEC(SigIsNoexcept);
+
+// The manager that is used when AnyInvocable is empty
+inline void EmptyManager(FunctionToCall /*operation*/,
+                         TypeErasedState* /*from*/,
+                         TypeErasedState* /*to*/) noexcept {}
+
+// The manager that is used when a target function is in local storage and is
+// a trivially copyable type.
+inline void LocalManagerTrivial(FunctionToCall /*operation*/,
+                                TypeErasedState* const from,
+                                TypeErasedState* const to) noexcept {
+  // This single statement without branching handles both possible operations.
+  //
+  // For FunctionToCall::dispose, "from" and "to" point to the same state, and
+  // so this assignment logically would do nothing.
+  //
+  // Note: Correctness here relies on http://wg21.link/p0593, which has only
+  // become standard in C++20, though implementations do not break it in
+  // practice for earlier versions of C++.
+  //
+  // The correct way to do this without that paper is to first placement-new a
+  // default-constructed T in "to->storage" prior to the memmove, but doing so
+  // requires a different function to be created for each T that is stored
+  // locally, which can cause unnecessary bloat and be less cache friendly.
+  *to = *from;
+
+  // Note: Because the type is trivially copyable, the destructor does not need
+  // to be called ("trivially copyable" requires a trivial destructor).
+}
+
+// The manager that is used when a target function is in local storage and is
+// not a trivially copyable type.
+template <class T>
+void LocalManagerNontrivial(FunctionToCall operation,
+                            TypeErasedState* const from,
+                            TypeErasedState* const to) noexcept {
+  static_assert(IsStoredLocally<T>::value,
+                "Local storage must only be used for supported types.");
+  static_assert(!std::is_trivially_copyable<T>::value,
+                "Locally stored types must be trivially copyable.");
+
+  T& from_object = (ObjectInLocalStorage<T>)(from);
+
+  switch (operation) {
+    case FunctionToCall::relocate_from_to:
+      // NOTE: Requires that the left-hand operand is already empty.
+      ::new (static_cast<void*>(&to->storage)) T(std::move(from_object));
+      ABSL_FALLTHROUGH_INTENDED;
+    case FunctionToCall::dispose:
+      from_object.~T();  // Must not throw. // NOLINT
+      return;
+  }
+  ABSL_INTERNAL_UNREACHABLE;
+}
+
+// The invoker that is used when a target function is in local storage
+// Note: QualTRef here is the target function type along with cv and reference
+// qualifiers that must be used when calling the function.
+template <bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
+ReturnType LocalInvoker(
+    TypeErasedState* const state,
+    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
+  using RawT = RemoveCVRef<QualTRef>;
+  static_assert(
+      IsStoredLocally<RawT>::value,
+      "Target object must be in local storage in order to be invoked from it.");
+
+  auto& f = (ObjectInLocalStorage<RawT>)(state);
+  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
+                               static_cast<ForwardedParameterType<P>>(args)...);
+}
+
+// The manager that is used when a target function is in remote storage and it
+// has a trivial destructor
+inline void RemoteManagerTrivial(FunctionToCall operation,
+                                 TypeErasedState* const from,
+                                 TypeErasedState* const to) noexcept {
+  switch (operation) {
+    case FunctionToCall::relocate_from_to:
+      // NOTE: Requires that the left-hand operand is already empty.
+      to->remote = from->remote;
+      return;
+    case FunctionToCall::dispose:
+#if defined(__cpp_sized_deallocation)
+      ::operator delete(from->remote.target, from->remote.size);
+#else   // __cpp_sized_deallocation
+      ::operator delete(from->remote.target);
+#endif  // __cpp_sized_deallocation
+      return;
+  }
+  ABSL_INTERNAL_UNREACHABLE;
+}
+
+// The manager that is used when a target function is in remote storage and the
+// destructor of the type is not trivial
+template <class T>
+void RemoteManagerNontrivial(FunctionToCall operation,
+                             TypeErasedState* const from,
+                             TypeErasedState* const to) noexcept {
+  static_assert(!IsStoredLocally<T>::value,
+                "Remote storage must only be used for types that do not "
+                "qualify for local storage.");
+
+  switch (operation) {
+    case FunctionToCall::relocate_from_to:
+      // NOTE: Requires that the left-hand operand is already empty.
+      to->remote.target = from->remote.target;
+      return;
+    case FunctionToCall::dispose:
+      ::delete static_cast<T*>(from->remote.target);  // Must not throw.
+      return;
+  }
+  ABSL_INTERNAL_UNREACHABLE;
+}
+
+// The invoker that is used when a target function is in remote storage
+template <bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
+ReturnType RemoteInvoker(
+    TypeErasedState* const state,
+    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
+  using RawT = RemoveCVRef<QualTRef>;
+  static_assert(!IsStoredLocally<RawT>::value,
+                "Target object must be in remote storage in order to be "
+                "invoked from it.");
+
+  auto& f = *static_cast<RawT*>(state->remote.target);
+  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
+                               static_cast<ForwardedParameterType<P>>(args)...);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction that checks if a type T is an instantiation of
+// absl::in_place_type_t (needed for constructor constraints of AnyInvocable).
+template <class T>
+struct IsInPlaceType : std::false_type {};
+
+template <class T>
+struct IsInPlaceType<absl::in_place_type_t<T>> : std::true_type {};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// A constructor name-tag used with CoreImpl (below) to request the
+// conversion-constructor. QualDecayedTRef is the decayed-type of the object to
+// wrap, along with the cv and reference qualifiers that must be applied when
+// performing an invocation of the wrapped object.
+template <class QualDecayedTRef>
+struct TypedConversionConstruct {};
+
+// A helper base class for all core operations of AnyInvocable. Most notably,
+// this class creates the function call operator and constraint-checkers so that
+// the top-level class does not have to be a series of partial specializations.
+//
+// Note: This definition exists (as opposed to being a declaration) so that if
+// the user of the top-level template accidentally passes a template argument
+// that is not a function type, they will get a static_assert in AnyInvocable's
+// class body rather than an error stating that Impl is not defined.
+template <class Sig>
+class Impl {};  // Note: This is partially-specialized later.
+
+// A std::unique_ptr deleter that deletes memory allocated via ::operator new.
+#if defined(__cpp_sized_deallocation)
+class TrivialDeleter {
+ public:
+  explicit TrivialDeleter(std::size_t size) : size_(size) {}
+
+  void operator()(void* target) const {
+    ::operator delete(target, size_);
+  }
+
+ private:
+  std::size_t size_;
+};
+#else   // __cpp_sized_deallocation
+class TrivialDeleter {
+ public:
+  explicit TrivialDeleter(std::size_t) {}
+
+  void operator()(void* target) const { ::operator delete(target); }
+};
+#endif  // __cpp_sized_deallocation
+
+template <bool SigIsNoexcept, class ReturnType, class... P>
+class CoreImpl;
+
+constexpr bool IsCompatibleConversion(void*, void*) { return false; }
+template <bool NoExceptSrc, bool NoExceptDest, class... T>
+constexpr bool IsCompatibleConversion(CoreImpl<NoExceptSrc, T...>*,
+                                      CoreImpl<NoExceptDest, T...>*) {
+  return !NoExceptDest || NoExceptSrc;
+}
+
+// A helper base class for all core operations of AnyInvocable that do not
+// depend on the cv/ref qualifiers of the function type.
+template <bool SigIsNoexcept, class ReturnType, class... P>
+class CoreImpl {
+ public:
+  using result_type = ReturnType;
+
+  CoreImpl() noexcept : manager_(EmptyManager), invoker_(nullptr) {}
+
+  enum class TargetType : int {
+    kPointer = 0,
+    kCompatibleAnyInvocable = 1,
+    kIncompatibleAnyInvocable = 2,
+    kOther = 3,
+  };
+
+  // Note: QualDecayedTRef here includes the cv-ref qualifiers associated with
+  // the invocation of the Invocable. The unqualified type is the target object
+  // type to be stored.
+  template <class QualDecayedTRef, class F>
+  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
+    using DecayedT = RemoveCVRef<QualDecayedTRef>;
+
+    constexpr TargetType kTargetType =
+        (std::is_pointer<DecayedT>::value ||
+         std::is_member_pointer<DecayedT>::value)
+            ? TargetType::kPointer
+        : IsCompatibleAnyInvocable<DecayedT>::value
+            ? TargetType::kCompatibleAnyInvocable
+        : IsAnyInvocable<DecayedT>::value
+            ? TargetType::kIncompatibleAnyInvocable
+            : TargetType::kOther;
+    // NOTE: We only use integers instead of enums as template parameters in
+    // order to work around a bug on C++14 under MSVC 2017.
+    // See b/236131881.
+    Initialize<static_cast<int>(kTargetType), QualDecayedTRef>(
+        std::forward<F>(f));
+  }
+
+  // Note: QualTRef here includes the cv-ref qualifiers associated with the
+  // invocation of the Invocable. The unqualified type is the target object
+  // type to be stored.
+  template <class QualTRef, class... Args>
+  explicit CoreImpl(absl::in_place_type_t<QualTRef>, Args&&... args) {
+    InitializeStorage<QualTRef>(std::forward<Args>(args)...);
+  }
+
+  CoreImpl(CoreImpl&& other) noexcept {
+    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
+    manager_ = other.manager_;
+    invoker_ = other.invoker_;
+    other.manager_ = EmptyManager;
+    other.invoker_ = nullptr;
+  }
+
+  CoreImpl& operator=(CoreImpl&& other) noexcept {
+    // Put the left-hand operand in an empty state.
+    //
+    // Note: A full reset that leaves us with an object that has its invariants
+    // intact is necessary in order to handle self-move. This is required by
+    // types that are used with certain operations of the standard library, such
+    // as the default definition of std::swap when both operands target the same
+    // object.
+    Clear();
+
+    // Perform the actual move/destory operation on the target function.
+    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
+    manager_ = other.manager_;
+    invoker_ = other.invoker_;
+    other.manager_ = EmptyManager;
+    other.invoker_ = nullptr;
+
+    return *this;
+  }
+
+  ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); }
+
+  // Check whether or not the AnyInvocable is in the empty state.
+  bool HasValue() const { return invoker_ != nullptr; }
+
+  // Effects: Puts the object into its empty state.
+  void Clear() {
+    manager_(FunctionToCall::dispose, &state_, &state_);
+    manager_ = EmptyManager;
+    invoker_ = nullptr;
+  }
+
+  template <int target_type, class QualDecayedTRef, class F,
+            absl::enable_if_t<target_type == 0, int> = 0>
+  void Initialize(F&& f) {
+// This condition handles types that decay into pointers, which includes
+// function references. Since function references cannot be null, GCC warns
+// against comparing their decayed form with nullptr.
+// Since this is template-heavy code, we prefer to disable these warnings
+// locally instead of adding yet another overload of this function.
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Waddress"
+#pragma GCC diagnostic ignored "-Wnonnull-compare"
+#pragma GCC diagnostic push
+#endif
+    if (static_cast<RemoveCVRef<QualDecayedTRef>>(f) == nullptr) {
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+      manager_ = EmptyManager;
+      invoker_ = nullptr;
+      return;
+    }
+    InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
+  }
+
+  template <int target_type, class QualDecayedTRef, class F,
+            absl::enable_if_t<target_type == 1, int> = 0>
+  void Initialize(F&& f) {
+    // In this case we can "steal the guts" of the other AnyInvocable.
+    f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
+    manager_ = f.manager_;
+    invoker_ = f.invoker_;
+
+    f.manager_ = EmptyManager;
+    f.invoker_ = nullptr;
+  }
+
+  template <int target_type, class QualDecayedTRef, class F,
+            absl::enable_if_t<target_type == 2, int> = 0>
+  void Initialize(F&& f) {
+    if (f.HasValue()) {
+      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
+    } else {
+      manager_ = EmptyManager;
+      invoker_ = nullptr;
+    }
+  }
+
+  template <int target_type, class QualDecayedTRef, class F,
+            typename = absl::enable_if_t<target_type == 3>>
+  void Initialize(F&& f) {
+    InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
+  }
+
+  // Use local (inline) storage for applicable target object types.
+  template <class QualTRef, class... Args,
+            typename = absl::enable_if_t<
+                IsStoredLocally<RemoveCVRef<QualTRef>>::value>>
+  void InitializeStorage(Args&&... args) {
+    using RawT = RemoveCVRef<QualTRef>;
+    ::new (static_cast<void*>(&state_.storage))
+        RawT(std::forward<Args>(args)...);
+
+    invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
+    // We can simplify our manager if we know the type is trivially copyable.
+    InitializeLocalManager<RawT>();
+  }
+
+  // Use remote storage for target objects that cannot be stored locally.
+  template <class QualTRef, class... Args,
+            absl::enable_if_t<!IsStoredLocally<RemoveCVRef<QualTRef>>::value,
+                              int> = 0>
+  void InitializeStorage(Args&&... args) {
+    InitializeRemoteManager<RemoveCVRef<QualTRef>>(std::forward<Args>(args)...);
+    // This is set after everything else in case an exception is thrown in an
+    // earlier step of the initialization.
+    invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
+  }
+
+  template <class T,
+            typename = absl::enable_if_t<std::is_trivially_copyable<T>::value>>
+  void InitializeLocalManager() {
+    manager_ = LocalManagerTrivial;
+  }
+
+  template <class T,
+            absl::enable_if_t<!std::is_trivially_copyable<T>::value, int> = 0>
+  void InitializeLocalManager() {
+    manager_ = LocalManagerNontrivial<T>;
+  }
+
+  template <class T>
+  using HasTrivialRemoteStorage =
+      std::integral_constant<bool, std::is_trivially_destructible<T>::value &&
+                                       alignof(T) <=
+                                           ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT>;
+
+  template <class T, class... Args,
+            typename = absl::enable_if_t<HasTrivialRemoteStorage<T>::value>>
+  void InitializeRemoteManager(Args&&... args) {
+    // unique_ptr is used for exception-safety in case construction throws.
+    std::unique_ptr<void, TrivialDeleter> uninitialized_target(
+        ::operator new(sizeof(T)), TrivialDeleter(sizeof(T)));
+    ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
+    state_.remote.target = uninitialized_target.release();
+    state_.remote.size = sizeof(T);
+    manager_ = RemoteManagerTrivial;
+  }
+
+  template <class T, class... Args,
+            absl::enable_if_t<!HasTrivialRemoteStorage<T>::value, int> = 0>
+  void InitializeRemoteManager(Args&&... args) {
+    state_.remote.target = ::new T(std::forward<Args>(args)...);
+    manager_ = RemoteManagerNontrivial<T>;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  //
+  // Type trait to determine if the template argument is an AnyInvocable whose
+  // function type is compatible enough with ours such that we can
+  // "move the guts" out of it when moving, rather than having to place a new
+  // object into remote storage.
+
+  template <typename Other>
+  struct IsCompatibleAnyInvocable {
+    static constexpr bool value = false;
+  };
+
+  template <typename Sig>
+  struct IsCompatibleAnyInvocable<AnyInvocable<Sig>> {
+    static constexpr bool value =
+        (IsCompatibleConversion)(static_cast<
+                                     typename AnyInvocable<Sig>::CoreImpl*>(
+                                     nullptr),
+                                 static_cast<CoreImpl*>(nullptr));
+  };
+
+  //
+  //////////////////////////////////////////////////////////////////////////////
+
+  TypeErasedState state_;
+  ManagerType* manager_;
+  InvokerType<SigIsNoexcept, ReturnType, P...>* invoker_;
+};
+
+// A constructor name-tag used with Impl to request the
+// conversion-constructor
+struct ConversionConstruct {};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction that is normally an identity metafunction except that when
+// given a std::reference_wrapper<T>, it yields T&. This is necessary because
+// currently std::reference_wrapper's operator() is not conditionally noexcept,
+// so when checking if such an Invocable is nothrow-invocable, we must pull out
+// the underlying type.
+template <class T>
+struct UnwrapStdReferenceWrapperImpl {
+  using type = T;
+};
+
+template <class T>
+struct UnwrapStdReferenceWrapperImpl<std::reference_wrapper<T>> {
+  using type = T&;
+};
+
+template <class T>
+using UnwrapStdReferenceWrapper =
+    typename UnwrapStdReferenceWrapperImpl<T>::type;
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// An alias that always yields std::true_type (used with constraints) where
+// substitution failures happen when forming the template arguments.
+template <class... T>
+using True =
+    std::integral_constant<bool, sizeof(absl::void_t<T...>*) != 0>;
+
+/*SFINAE constraints for the conversion-constructor.*/
+template <class Sig, class F,
+          class = absl::enable_if_t<
+              !std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
+using CanConvert =
+    True<absl::enable_if_t<!IsInPlaceType<RemoveCVRef<F>>::value>,
+         absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
+         absl::enable_if_t<
+             Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
+         absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;
+
+/*SFINAE constraints for the std::in_place constructors.*/
+template <class Sig, class F, class... Args>
+using CanEmplace = True<
+    absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
+    absl::enable_if_t<
+        Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
+    absl::enable_if_t<std::is_constructible<absl::decay_t<F>, Args...>::value>>;
+
+/*SFINAE constraints for the conversion-assign operator.*/
+template <class Sig, class F,
+          class = absl::enable_if_t<
+              !std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
+using CanAssign =
+    True<absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
+         absl::enable_if_t<
+             Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
+         absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;
+
+/*SFINAE constraints for the reference-wrapper conversion-assign operator.*/
+template <class Sig, class F>
+using CanAssignReferenceWrapper =
+    True<absl::enable_if_t<
+             Impl<Sig>::template CallIsValid<std::reference_wrapper<F>>::value>,
+         absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<
+             std::reference_wrapper<F>>::value>>;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// The constraint for checking whether or not a call meets the noexcept
+// callability requirements. This is a preprocessor macro because specifying it
+// this way as opposed to a disjunction/branch can improve the user-side error
+// messages and avoids an instantiation of std::is_nothrow_invocable_r in the
+// cases where the user did not specify a noexcept function type.
+//
+#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT(inv_quals, noex) \
+  ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_##noex(inv_quals)
+
+// The disjunction below is because we can't rely on std::is_nothrow_invocable_r
+// to give the right result when ReturnType is non-moveable in toolchains that
+// don't treat non-moveable result types correctly. For example this was the
+// case in libc++ before commit c3a24882 (2022-05).
+#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true(inv_quals)      \
+  absl::enable_if_t<absl::disjunction<                                       \
+      std::is_nothrow_invocable_r<                                           \
+          ReturnType, UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, \
+          P...>,                                                             \
+      std::conjunction<                                                      \
+          std::is_nothrow_invocable<                                         \
+              UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, P...>,  \
+          std::is_same<                                                      \
+              ReturnType,                                                    \
+              absl::base_internal::invoke_result_t<                          \
+                  UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals,     \
+                  P...>>>>::value>
+
+#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false(inv_quals)
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// A macro to generate partial specializations of Impl with the different
+// combinations of supported cv/reference qualifiers and noexcept specifier.
+//
+// Here, `cv` are the cv-qualifiers if any, `ref` is the ref-qualifier if any,
+// inv_quals is the reference type to be used when invoking the target, and
+// noex is "true" if the function type is noexcept, or false if it is not.
+//
+// The CallIsValid condition is more complicated than simply using
+// absl::base_internal::is_invocable_r because we can't rely on it to give the
+// right result when ReturnType is non-moveable in toolchains that don't treat
+// non-moveable result types correctly. For example this was the case in libc++
+// before commit c3a24882 (2022-05).
+#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, noex)            \
+  template <class ReturnType, class... P>                                      \
+  class Impl<ReturnType(P...) cv ref ABSL_INTERNAL_NOEXCEPT_SPEC(noex)>        \
+      : public CoreImpl<noex, ReturnType, P...> {                              \
+   public:                                                                     \
+    /*The base class, which contains the datamembers and core operations*/     \
+    using Core = CoreImpl<noex, ReturnType, P...>;                             \
+                                                                               \
+    /*SFINAE constraint to check if F is invocable with the proper signature*/ \
+    template <class F>                                                         \
+    using CallIsValid = True<absl::enable_if_t<absl::disjunction<              \
+        absl::base_internal::is_invocable_r<ReturnType,                        \
+                                            absl::decay_t<F> inv_quals, P...>, \
+        std::is_same<ReturnType,                                               \
+                     absl::base_internal::invoke_result_t<                     \
+                         absl::decay_t<F> inv_quals, P...>>>::value>>;         \
+                                                                               \
+    /*SFINAE constraint to check if F is nothrow-invocable when necessary*/    \
+    template <class F>                                                         \
+    using CallIsNoexceptIfSigIsNoexcept =                                      \
+        True<ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT(inv_quals,        \
+                                                             noex)>;           \
+                                                                               \
+    /*Put the AnyInvocable into an empty state.*/                              \
+    Impl() = default;                                                          \
+                                                                               \
+    /*The implementation of a conversion-constructor from "f*/                 \
+    /*This forwards to Core, attaching inv_quals so that the base class*/      \
+    /*knows how to properly type-erase the invocation.*/                       \
+    template <class F>                                                         \
+    explicit Impl(ConversionConstruct, F&& f)                                  \
+        : Core(TypedConversionConstruct<                                       \
+                   typename std::decay<F>::type inv_quals>(),                  \
+               std::forward<F>(f)) {}                                          \
+                                                                               \
+    /*Forward along the in-place construction parameters.*/                    \
+    template <class T, class... Args>                                          \
+    explicit Impl(absl::in_place_type_t<T>, Args&&... args)                    \
+        : Core(absl::in_place_type<absl::decay_t<T> inv_quals>,                \
+               std::forward<Args>(args)...) {}                                 \
+                                                                               \
+    /*The actual invocation operation with the proper signature*/              \
+    ReturnType operator()(P... args) cv ref noexcept(noex) {                   \
+      assert(this->invoker_ != nullptr);                                       \
+      return this->invoker_(const_cast<TypeErasedState*>(&this->state_),       \
+                            static_cast<ForwardedParameterType<P>>(args)...);  \
+    }                                                                          \
+  }
+
+// Define the `noexcept(true)` specialization only for C++17 and beyond, when
+// `noexcept` is part of the type system.
+#if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
+// A convenience macro that defines specializations for the noexcept(true) and
+// noexcept(false) forms, given the other properties.
+#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL(cv, ref, inv_quals)    \
+  ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false); \
+  ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, true)
+#else
+#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL(cv, ref, inv_quals) \
+  ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false)
+#endif
+
+// Non-ref-qualified partial specializations
+ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, , &);
+ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, , const&);
+
+// Lvalue-ref-qualified partial specializations
+ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, &, &);
+ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &, const&);
+
+// Rvalue-ref-qualified partial specializations
+ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, &&, &&);
+ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &&, const&&);
+
+// Undef the detail-only macros.
+#undef ABSL_INTERNAL_ANY_INVOCABLE_IMPL
+#undef ABSL_INTERNAL_ANY_INVOCABLE_IMPL_
+#undef ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false
+#undef ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true
+#undef ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT
+#undef ABSL_INTERNAL_NOEXCEPT_SPEC
+
+}  // namespace internal_any_invocable
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FUNCTIONAL_INTERNAL_ANY_INVOCABLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/internal/front_binder.h b/CAPI/cpp/grpc/include/absl/functional/internal/front_binder.h
new file mode 100644
index 0000000..45f52de
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/functional/internal/front_binder.h
@@ -0,0 +1,95 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// Implementation details for `absl::bind_front()`.
+
+#ifndef ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
+#define ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/invoke.h"
+#include "absl/container/internal/compressed_tuple.h"
+#include "absl/meta/type_traits.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace functional_internal {
+
+// Invoke the method, expanding the tuple of bound arguments.
+template <class R, class Tuple, size_t... Idx, class... Args>
+R Apply(Tuple&& bound, absl::index_sequence<Idx...>, Args&&... free) {
+  return base_internal::invoke(
+      absl::forward<Tuple>(bound).template get<Idx>()...,
+      absl::forward<Args>(free)...);
+}
+
+template <class F, class... BoundArgs>
+class FrontBinder {
+  using BoundArgsT = absl::container_internal::CompressedTuple<F, BoundArgs...>;
+  using Idx = absl::make_index_sequence<sizeof...(BoundArgs) + 1>;
+
+  BoundArgsT bound_args_;
+
+ public:
+  template <class... Ts>
+  constexpr explicit FrontBinder(absl::in_place_t, Ts&&... ts)
+      : bound_args_(absl::forward<Ts>(ts)...) {}
+
+  template <class... FreeArgs, class R = base_internal::invoke_result_t<
+                                   F&, BoundArgs&..., FreeArgs&&...>>
+  R operator()(FreeArgs&&... free_args) & {
+    return functional_internal::Apply<R>(bound_args_, Idx(),
+                                         absl::forward<FreeArgs>(free_args)...);
+  }
+
+  template <class... FreeArgs,
+            class R = base_internal::invoke_result_t<
+                const F&, const BoundArgs&..., FreeArgs&&...>>
+  R operator()(FreeArgs&&... free_args) const& {
+    return functional_internal::Apply<R>(bound_args_, Idx(),
+                                         absl::forward<FreeArgs>(free_args)...);
+  }
+
+  template <class... FreeArgs, class R = base_internal::invoke_result_t<
+                                   F&&, BoundArgs&&..., FreeArgs&&...>>
+  R operator()(FreeArgs&&... free_args) && {
+    // This overload is called when *this is an rvalue. If some of the bound
+    // arguments are stored by value or rvalue reference, we move them.
+    return functional_internal::Apply<R>(absl::move(bound_args_), Idx(),
+                                         absl::forward<FreeArgs>(free_args)...);
+  }
+
+  template <class... FreeArgs,
+            class R = base_internal::invoke_result_t<
+                const F&&, const BoundArgs&&..., FreeArgs&&...>>
+  R operator()(FreeArgs&&... free_args) const&& {
+    // This overload is called when *this is an rvalue. If some of the bound
+    // arguments are stored by value or rvalue reference, we move them.
+    return functional_internal::Apply<R>(absl::move(bound_args_), Idx(),
+                                         absl::forward<FreeArgs>(free_args)...);
+  }
+};
+
+template <class F, class... BoundArgs>
+using bind_front_t = FrontBinder<decay_t<F>, absl::decay_t<BoundArgs>...>;
+
+}  // namespace functional_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/internal/function_ref.h b/CAPI/cpp/grpc/include/absl/functional/internal/function_ref.h
new file mode 100644
index 0000000..b5bb8b4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/functional/internal/function_ref.h
@@ -0,0 +1,106 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
+#define ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
+
+#include <cassert>
+#include <functional>
+#include <type_traits>
+
+#include "absl/base/internal/invoke.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace functional_internal {
+
+// Like a void* that can handle function pointers as well. The standard does not
+// allow function pointers to round-trip through void*, but void(*)() is fine.
+//
+// Note: It's important that this class remains trivial and is the same size as
+// a pointer, since this allows the compiler to perform tail-call optimizations
+// when the underlying function is a callable object with a matching signature.
+union VoidPtr {
+  const void* obj;
+  void (*fun)();
+};
+
+// Chooses the best type for passing T as an argument.
+// Attempt to be close to SystemV AMD64 ABI. Objects with trivial copy ctor are
+// passed by value.
+template <typename T>
+constexpr bool PassByValue() {
+  return !std::is_lvalue_reference<T>::value &&
+         absl::is_trivially_copy_constructible<T>::value &&
+         absl::is_trivially_copy_assignable<
+             typename std::remove_cv<T>::type>::value &&
+         std::is_trivially_destructible<T>::value &&
+         sizeof(T) <= 2 * sizeof(void*);
+}
+
+template <typename T>
+struct ForwardT : std::conditional<PassByValue<T>(), T, T&&> {};
+
+// An Invoker takes a pointer to the type-erased invokable object, followed by
+// the arguments that the invokable object expects.
+//
+// Note: The order of arguments here is an optimization, since member functions
+// have an implicit "this" pointer as their first argument, putting VoidPtr
+// first allows the compiler to perform tail-call optimization in many cases.
+template <typename R, typename... Args>
+using Invoker = R (*)(VoidPtr, typename ForwardT<Args>::type...);
+
+//
+// InvokeObject and InvokeFunction provide static "Invoke" functions that can be
+// used as Invokers for objects or functions respectively.
+//
+// static_cast<R> handles the case the return type is void.
+template <typename Obj, typename R, typename... Args>
+R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
+  auto o = static_cast<const Obj*>(ptr.obj);
+  return static_cast<R>(
+      absl::base_internal::invoke(*o, std::forward<Args>(args)...));
+}
+
+template <typename Fun, typename R, typename... Args>
+R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
+  auto f = reinterpret_cast<Fun>(ptr.fun);
+  return static_cast<R>(
+      absl::base_internal::invoke(f, std::forward<Args>(args)...));
+}
+
+template <typename Sig>
+void AssertNonNull(const std::function<Sig>& f) {
+  assert(f != nullptr);
+  (void)f;
+}
+
+template <typename F>
+void AssertNonNull(const F&) {}
+
+template <typename F, typename C>
+void AssertNonNull(F C::*f) {
+  assert(f != nullptr);
+  (void)f;
+}
+
+template <bool C>
+using EnableIf = typename ::std::enable_if<C, int>::type;
+
+}  // namespace functional_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/hash.h b/CAPI/cpp/grpc/include/absl/hash/hash.h
new file mode 100644
index 0000000..74e2d7c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/hash/hash.h
@@ -0,0 +1,421 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: hash.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the Abseil `hash` library and the Abseil hashing
+// framework. This framework consists of the following:
+//
+//   * The `absl::Hash` functor, which is used to invoke the hasher within the
+//     Abseil hashing framework. `absl::Hash<T>` supports most basic types and
+//     a number of Abseil types out of the box.
+//   * `AbslHashValue`, an extension point that allows you to extend types to
+//     support Abseil hashing without requiring you to define a hashing
+//     algorithm.
+//   * `HashState`, a type-erased class which implements the manipulation of the
+//     hash state (H) itself; contains member functions `combine()`,
+//     `combine_contiguous()`, and `combine_unordered()`; and which you can use
+//     to contribute to an existing hash state when hashing your types.
+//
+// Unlike `std::hash` or other hashing frameworks, the Abseil hashing framework
+// provides most of its utility by abstracting away the hash algorithm (and its
+// implementation) entirely. Instead, a type invokes the Abseil hashing
+// framework by simply combining its state with the state of known, hashable
+// types. Hashing of that combined state is separately done by `absl::Hash`.
+//
+// One should assume that a hash algorithm is chosen randomly at the start of
+// each process.  E.g., `absl::Hash<int>{}(9)` in one process and
+// `absl::Hash<int>{}(9)` in another process are likely to differ.
+//
+// `absl::Hash` may also produce different values from different dynamically
+// loaded libraries. For this reason, `absl::Hash` values must never cross
+// boundries in dynamically loaded libraries (including when used in types like
+// hash containers.)
+//
+// `absl::Hash` is intended to strongly mix input bits with a target of passing
+// an [Avalanche Test](https://en.wikipedia.org/wiki/Avalanche_effect).
+//
+// Example:
+//
+//   // Suppose we have a class `Circle` for which we want to add hashing:
+//   class Circle {
+//    public:
+//     ...
+//    private:
+//     std::pair<int, int> center_;
+//     int radius_;
+//   };
+//
+//   // To add hashing support to `Circle`, we simply need to add a free
+//   // (non-member) function `AbslHashValue()`, and return the combined hash
+//   // state of the existing hash state and the class state. You can add such a
+//   // free function using a friend declaration within the body of the class:
+//   class Circle {
+//    public:
+//     ...
+//     template <typename H>
+//     friend H AbslHashValue(H h, const Circle& c) {
+//       return H::combine(std::move(h), c.center_, c.radius_);
+//     }
+//     ...
+//   };
+//
+// For more information, see Adding Type Support to `absl::Hash` below.
+//
+#ifndef ABSL_HASH_HASH_H_
+#define ABSL_HASH_HASH_H_
+
+#include <tuple>
+#include <utility>
+
+#include "absl/functional/function_ref.h"
+#include "absl/hash/internal/hash.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// `absl::Hash`
+// -----------------------------------------------------------------------------
+//
+// `absl::Hash<T>` is a convenient general-purpose hash functor for any type `T`
+// satisfying any of the following conditions (in order):
+//
+//  * T is an arithmetic or pointer type
+//  * T defines an overload for `AbslHashValue(H, const T&)` for an arbitrary
+//    hash state `H`.
+//  - T defines a specialization of `std::hash<T>`
+//
+// `absl::Hash` intrinsically supports the following types:
+//
+//   * All integral types (including bool)
+//   * All enum types
+//   * All floating-point types (although hashing them is discouraged)
+//   * All pointer types, including nullptr_t
+//   * std::pair<T1, T2>, if T1 and T2 are hashable
+//   * std::tuple<Ts...>, if all the Ts... are hashable
+//   * std::unique_ptr and std::shared_ptr
+//   * All string-like types including:
+//     * absl::Cord
+//     * std::string
+//     * std::string_view (as well as any instance of std::basic_string that
+//       uses char and std::char_traits)
+//  * All the standard sequence containers (provided the elements are hashable)
+//  * All the standard associative containers (provided the elements are
+//    hashable)
+//  * absl types such as the following:
+//    * absl::string_view
+//    * absl::uint128
+//    * absl::Time, absl::Duration, and absl::TimeZone
+//  * absl containers (provided the elements are hashable) such as the
+//    following:
+//    * absl::flat_hash_set, absl::node_hash_set, absl::btree_set
+//    * absl::flat_hash_map, absl::node_hash_map, absl::btree_map
+//    * absl::btree_multiset, absl::btree_multimap
+//    * absl::InlinedVector
+//    * absl::FixedArray
+//
+// When absl::Hash is used to hash an unordered container with a custom hash
+// functor, the elements are hashed using default absl::Hash semantics, not
+// the custom hash functor.  This is consistent with the behavior of
+// operator==() on unordered containers, which compares elements pairwise with
+// operator==() rather than the custom equality functor.  It is usually a
+// mistake to use either operator==() or absl::Hash on unordered collections
+// that use functors incompatible with operator==() equality.
+//
+// Note: the list above is not meant to be exhaustive. Additional type support
+// may be added, in which case the above list will be updated.
+//
+// -----------------------------------------------------------------------------
+// absl::Hash Invocation Evaluation
+// -----------------------------------------------------------------------------
+//
+// When invoked, `absl::Hash<T>` searches for supplied hash functions in the
+// following order:
+//
+//   * Natively supported types out of the box (see above)
+//   * Types for which an `AbslHashValue()` overload is provided (such as
+//     user-defined types). See "Adding Type Support to `absl::Hash`" below.
+//   * Types which define a `std::hash<T>` specialization
+//
+// The fallback to legacy hash functions exists mainly for backwards
+// compatibility. If you have a choice, prefer defining an `AbslHashValue`
+// overload instead of specializing any legacy hash functors.
+//
+// -----------------------------------------------------------------------------
+// The Hash State Concept, and using `HashState` for Type Erasure
+// -----------------------------------------------------------------------------
+//
+// The `absl::Hash` framework relies on the Concept of a "hash state." Such a
+// hash state is used in several places:
+//
+// * Within existing implementations of `absl::Hash<T>` to store the hashed
+//   state of an object. Note that it is up to the implementation how it stores
+//   such state. A hash table, for example, may mix the state to produce an
+//   integer value; a testing framework may simply hold a vector of that state.
+// * Within implementations of `AbslHashValue()` used to extend user-defined
+//   types. (See "Adding Type Support to absl::Hash" below.)
+// * Inside a `HashState`, providing type erasure for the concept of a hash
+//   state, which you can use to extend the `absl::Hash` framework for types
+//   that are otherwise difficult to extend using `AbslHashValue()`. (See the
+//   `HashState` class below.)
+//
+// The "hash state" concept contains three member functions for mixing hash
+// state:
+//
+// * `H::combine(state, values...)`
+//
+//   Combines an arbitrary number of values into a hash state, returning the
+//   updated state. Note that the existing hash state is move-only and must be
+//   passed by value.
+//
+//   Each of the value types T must be hashable by H.
+//
+//   NOTE:
+//
+//     state = H::combine(std::move(state), value1, value2, value3);
+//
+//   must be guaranteed to produce the same hash expansion as
+//
+//     state = H::combine(std::move(state), value1);
+//     state = H::combine(std::move(state), value2);
+//     state = H::combine(std::move(state), value3);
+//
+// * `H::combine_contiguous(state, data, size)`
+//
+//    Combines a contiguous array of `size` elements into a hash state,
+//    returning the updated state. Note that the existing hash state is
+//    move-only and must be passed by value.
+//
+//    NOTE:
+//
+//      state = H::combine_contiguous(std::move(state), data, size);
+//
+//    need NOT be guaranteed to produce the same hash expansion as a loop
+//    (it may perform internal optimizations). If you need this guarantee, use a
+//    loop instead.
+//
+// * `H::combine_unordered(state, begin, end)`
+//
+//    Combines a set of elements denoted by an iterator pair into a hash
+//    state, returning the updated state.  Note that the existing hash
+//    state is move-only and must be passed by value.
+//
+//    Unlike the other two methods, the hashing is order-independent.
+//    This can be used to hash unordered collections.
+//
+// -----------------------------------------------------------------------------
+// Adding Type Support to `absl::Hash`
+// -----------------------------------------------------------------------------
+//
+// To add support for your user-defined type, add a proper `AbslHashValue()`
+// overload as a free (non-member) function. The overload will take an
+// existing hash state and should combine that state with state from the type.
+//
+// Example:
+//
+//   template <typename H>
+//   H AbslHashValue(H state, const MyType& v) {
+//     return H::combine(std::move(state), v.field1, ..., v.fieldN);
+//   }
+//
+// where `(field1, ..., fieldN)` are the members you would use on your
+// `operator==` to define equality.
+//
+// Notice that `AbslHashValue` is not a class member, but an ordinary function.
+// An `AbslHashValue` overload for a type should only be declared in the same
+// file and namespace as said type. The proper `AbslHashValue` implementation
+// for a given type will be discovered via ADL.
+//
+// Note: unlike `std::hash', `absl::Hash` should never be specialized. It must
+// only be extended by adding `AbslHashValue()` overloads.
+//
+template <typename T>
+using Hash = absl::hash_internal::Hash<T>;
+
+// HashOf
+//
+// absl::HashOf() is a helper that generates a hash from the values of its
+// arguments.  It dispatches to absl::Hash directly, as follows:
+//  * HashOf(t) == absl::Hash<T>{}(t)
+//  * HashOf(a, b, c) == HashOf(std::make_tuple(a, b, c))
+//
+// HashOf(a1, a2, ...) == HashOf(b1, b2, ...) is guaranteed when
+//  * The argument lists have pairwise identical C++ types
+//  * a1 == b1 && a2 == b2 && ...
+//
+// The requirement that the arguments match in both type and value is critical.
+// It means that `a == b` does not necessarily imply `HashOf(a) == HashOf(b)` if
+// `a` and `b` have different types. For example, `HashOf(2) != HashOf(2.0)`.
+template <int&... ExplicitArgumentBarrier, typename... Types>
+size_t HashOf(const Types&... values) {
+  auto tuple = std::tie(values...);
+  return absl::Hash<decltype(tuple)>{}(tuple);
+}
+
+// HashState
+//
+// A type erased version of the hash state concept, for use in user-defined
+// `AbslHashValue` implementations that can't use templates (such as PImpl
+// classes, virtual functions, etc.). The type erasure adds overhead so it
+// should be avoided unless necessary.
+//
+// Note: This wrapper will only erase calls to
+//     combine_contiguous(H, const unsigned char*, size_t)
+//     RunCombineUnordered(H, CombinerF)
+//
+// All other calls will be handled internally and will not invoke overloads
+// provided by the wrapped class.
+//
+// Users of this class should still define a template `AbslHashValue` function,
+// but can use `absl::HashState::Create(&state)` to erase the type of the hash
+// state and dispatch to their private hashing logic.
+//
+// This state can be used like any other hash state. In particular, you can call
+// `HashState::combine()` and `HashState::combine_contiguous()` on it.
+//
+// Example:
+//
+//   class Interface {
+//    public:
+//     template <typename H>
+//     friend H AbslHashValue(H state, const Interface& value) {
+//       state = H::combine(std::move(state), std::type_index(typeid(*this)));
+//       value.HashValue(absl::HashState::Create(&state));
+//       return state;
+//     }
+//    private:
+//     virtual void HashValue(absl::HashState state) const = 0;
+//   };
+//
+//   class Impl : Interface {
+//    private:
+//     void HashValue(absl::HashState state) const override {
+//       absl::HashState::combine(std::move(state), v1_, v2_);
+//     }
+//     int v1_;
+//     std::string v2_;
+//   };
+class HashState : public hash_internal::HashStateBase<HashState> {
+ public:
+  // HashState::Create()
+  //
+  // Create a new `HashState` instance that wraps `state`. All calls to
+  // `combine()` and `combine_contiguous()` on the new instance will be
+  // redirected to the original `state` object. The `state` object must outlive
+  // the `HashState` instance.
+  template <typename T>
+  static HashState Create(T* state) {
+    HashState s;
+    s.Init(state);
+    return s;
+  }
+
+  HashState(const HashState&) = delete;
+  HashState& operator=(const HashState&) = delete;
+  HashState(HashState&&) = default;
+  HashState& operator=(HashState&&) = default;
+
+  // HashState::combine()
+  //
+  // Combines an arbitrary number of values into a hash state, returning the
+  // updated state.
+  using HashState::HashStateBase::combine;
+
+  // HashState::combine_contiguous()
+  //
+  // Combines a contiguous array of `size` elements into a hash state, returning
+  // the updated state.
+  static HashState combine_contiguous(HashState hash_state,
+                                      const unsigned char* first, size_t size) {
+    hash_state.combine_contiguous_(hash_state.state_, first, size);
+    return hash_state;
+  }
+  using HashState::HashStateBase::combine_contiguous;
+
+ private:
+  HashState() = default;
+
+  friend class HashState::HashStateBase;
+
+  template <typename T>
+  static void CombineContiguousImpl(void* p, const unsigned char* first,
+                                    size_t size) {
+    T& state = *static_cast<T*>(p);
+    state = T::combine_contiguous(std::move(state), first, size);
+  }
+
+  template <typename T>
+  void Init(T* state) {
+    state_ = state;
+    combine_contiguous_ = &CombineContiguousImpl<T>;
+    run_combine_unordered_ = &RunCombineUnorderedImpl<T>;
+  }
+
+  template <typename HS>
+  struct CombineUnorderedInvoker {
+    template <typename T, typename ConsumerT>
+    void operator()(T inner_state, ConsumerT inner_cb) {
+      f(HashState::Create(&inner_state),
+        [&](HashState& inner_erased) { inner_cb(inner_erased.Real<T>()); });
+    }
+
+    absl::FunctionRef<void(HS, absl::FunctionRef<void(HS&)>)> f;
+  };
+
+  template <typename T>
+  static HashState RunCombineUnorderedImpl(
+      HashState state,
+      absl::FunctionRef<void(HashState, absl::FunctionRef<void(HashState&)>)>
+          f) {
+    // Note that this implementation assumes that inner_state and outer_state
+    // are the same type.  This isn't true in the SpyHash case, but SpyHash
+    // types are move-convertible to each other, so this still works.
+    T& real_state = state.Real<T>();
+    real_state = T::RunCombineUnordered(
+        std::move(real_state), CombineUnorderedInvoker<HashState>{f});
+    return state;
+  }
+
+  template <typename CombinerT>
+  static HashState RunCombineUnordered(HashState state, CombinerT combiner) {
+    auto* run = state.run_combine_unordered_;
+    return run(std::move(state), std::ref(combiner));
+  }
+
+  // Do not erase an already erased state.
+  void Init(HashState* state) {
+    state_ = state->state_;
+    combine_contiguous_ = state->combine_contiguous_;
+    run_combine_unordered_ = state->run_combine_unordered_;
+  }
+
+  template <typename T>
+  T& Real() {
+    return *static_cast<T*>(state_);
+  }
+
+  void* state_;
+  void (*combine_contiguous_)(void*, const unsigned char*, size_t);
+  HashState (*run_combine_unordered_)(
+      HashState state,
+      absl::FunctionRef<void(HashState, absl::FunctionRef<void(HashState&)>)>);
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_HASH_HASH_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/hash_testing.h b/CAPI/cpp/grpc/include/absl/hash/hash_testing.h
new file mode 100644
index 0000000..1e1c574
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/hash/hash_testing.h
@@ -0,0 +1,378 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_HASH_HASH_TESTING_H_
+#define ABSL_HASH_HASH_TESTING_H_
+
+#include <initializer_list>
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/hash/internal/spy_hash_state.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/str_cat.h"
+#include "absl/types/variant.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Run the absl::Hash algorithm over all the elements passed in and verify that
+// their hash expansion is congruent with their `==` operator.
+//
+// It is used in conjunction with EXPECT_TRUE. Failures will output information
+// on what requirement failed and on which objects.
+//
+// Users should pass a collection of types as either an initializer list or a
+// container of cases.
+//
+//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
+//       {v1, v2, ..., vN}));
+//
+//   std::vector<MyType> cases;
+//   // Fill cases...
+//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(cases));
+//
+// Users can pass a variety of types for testing heterogeneous lookup with
+// `std::make_tuple`:
+//
+//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
+//       std::make_tuple(v1, v2, ..., vN)));
+//
+//
+// Ideally, the values passed should provide enough coverage of the `==`
+// operator and the AbslHashValue implementations.
+// For dynamically sized types, the empty state should usually be included in
+// the values.
+//
+// The function accepts an optional comparator function, in case that `==` is
+// not enough for the values provided.
+//
+// Usage:
+//
+//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
+//       std::make_tuple(v1, v2, ..., vN), MyCustomEq{}));
+//
+// It checks the following requirements:
+//   1. The expansion for a value is deterministic.
+//   2. For any two objects `a` and `b` in the sequence, if `a == b` evaluates
+//      to true, then their hash expansion must be equal.
+//   3. If `a == b` evaluates to false their hash expansion must be unequal.
+//   4. If `a == b` evaluates to false neither hash expansion can be a
+//      suffix of the other.
+//   5. AbslHashValue overloads should not be called by the user. They are only
+//      meant to be called by the framework. Users should call H::combine() and
+//      H::combine_contiguous().
+//   6. No moved-from instance of the hash state is used in the implementation
+//      of AbslHashValue.
+//
+// The values do not have to have the same type. This can be useful for
+// equivalent types that support heterogeneous lookup.
+//
+// A possible reason for breaking (2) is combining state in the hash expansion
+// that was not used in `==`.
+// For example:
+//
+// struct Bad2 {
+//   int a, b;
+//   template <typename H>
+//   friend H AbslHashValue(H state, Bad2 x) {
+//     // Uses a and b.
+//     return H::combine(std::move(state), x.a, x.b);
+//   }
+//   friend bool operator==(Bad2 x, Bad2 y) {
+//     // Only uses a.
+//     return x.a == y.a;
+//   }
+// };
+//
+// As for (3), breaking this usually means that there is state being passed to
+// the `==` operator that is not used in the hash expansion.
+// For example:
+//
+// struct Bad3 {
+//   int a, b;
+//   template <typename H>
+//   friend H AbslHashValue(H state, Bad3 x) {
+//     // Only uses a.
+//     return H::combine(std::move(state), x.a);
+//   }
+//   friend bool operator==(Bad3 x, Bad3 y) {
+//     // Uses a and b.
+//     return x.a == y.a && x.b == y.b;
+//   }
+// };
+//
+// Finally, a common way to break 4 is by combining dynamic ranges without
+// combining the size of the range.
+// For example:
+//
+// struct Bad4 {
+//   int *p, size;
+//   template <typename H>
+//   friend H AbslHashValue(H state, Bad4 x) {
+//     return H::combine_contiguous(std::move(state), x.p, x.p + x.size);
+//   }
+//   friend bool operator==(Bad4 x, Bad4 y) {
+//    // Compare two ranges for equality. C++14 code can instead use std::equal.
+//     return absl::equal(x.p, x.p + x.size, y.p, y.p + y.size);
+//   }
+// };
+//
+// An easy solution to this is to combine the size after combining the range,
+// like so:
+// template <typename H>
+// friend H AbslHashValue(H state, Bad4 x) {
+//   return H::combine(
+//       H::combine_contiguous(std::move(state), x.p, x.p + x.size), x.size);
+// }
+//
+template <int&... ExplicitBarrier, typename Container>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(const Container& values);
+
+template <int&... ExplicitBarrier, typename Container, typename Eq>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals);
+
+template <int&..., typename T>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values);
+
+template <int&..., typename T, typename Eq>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
+                                      Eq equals);
+
+namespace hash_internal {
+
+struct PrintVisitor {
+  size_t index;
+  template <typename T>
+  std::string operator()(const T* value) const {
+    return absl::StrCat("#", index, "(", testing::PrintToString(*value), ")");
+  }
+};
+
+template <typename Eq>
+struct EqVisitor {
+  Eq eq;
+  template <typename T, typename U>
+  bool operator()(const T* t, const U* u) const {
+    return eq(*t, *u);
+  }
+};
+
+struct ExpandVisitor {
+  template <typename T>
+  SpyHashState operator()(const T* value) const {
+    return SpyHashState::combine(SpyHashState(), *value);
+  }
+};
+
+template <typename Container, typename Eq>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
+  using V = typename Container::value_type;
+
+  struct Info {
+    const V& value;
+    size_t index;
+    std::string ToString() const {
+      return absl::visit(PrintVisitor{index}, value);
+    }
+    SpyHashState expand() const { return absl::visit(ExpandVisitor{}, value); }
+  };
+
+  using EqClass = std::vector<Info>;
+  std::vector<EqClass> classes;
+
+  // Gather the values in equivalence classes.
+  size_t i = 0;
+  for (const auto& value : values) {
+    EqClass* c = nullptr;
+    for (auto& eqclass : classes) {
+      if (absl::visit(EqVisitor<Eq>{equals}, value, eqclass[0].value)) {
+        c = &eqclass;
+        break;
+      }
+    }
+    if (c == nullptr) {
+      classes.emplace_back();
+      c = &classes.back();
+    }
+    c->push_back({value, i});
+    ++i;
+
+    // Verify potential errors captured by SpyHashState.
+    if (auto error = c->back().expand().error()) {
+      return testing::AssertionFailure() << *error;
+    }
+  }
+
+  if (classes.size() < 2) {
+    return testing::AssertionFailure()
+           << "At least two equivalence classes are expected.";
+  }
+
+  // We assume that equality is correctly implemented.
+  // Now we verify that AbslHashValue is also correctly implemented.
+
+  for (const auto& c : classes) {
+    // All elements of the equivalence class must have the same hash
+    // expansion.
+    const SpyHashState expected = c[0].expand();
+    for (const Info& v : c) {
+      if (v.expand() != v.expand()) {
+        return testing::AssertionFailure()
+               << "Hash expansion for " << v.ToString()
+               << " is non-deterministic.";
+      }
+      if (v.expand() != expected) {
+        return testing::AssertionFailure()
+               << "Values " << c[0].ToString() << " and " << v.ToString()
+               << " evaluate as equal but have an unequal hash expansion.";
+      }
+    }
+
+    // Elements from other classes must have different hash expansion.
+    for (const auto& c2 : classes) {
+      if (&c == &c2) continue;
+      const SpyHashState c2_hash = c2[0].expand();
+      switch (SpyHashState::Compare(expected, c2_hash)) {
+        case SpyHashState::CompareResult::kEqual:
+          return testing::AssertionFailure()
+                 << "Values " << c[0].ToString() << " and " << c2[0].ToString()
+                 << " evaluate as unequal but have an equal hash expansion.";
+        case SpyHashState::CompareResult::kBSuffixA:
+          return testing::AssertionFailure()
+                 << "Hash expansion of " << c2[0].ToString()
+                 << " is a suffix of the hash expansion of " << c[0].ToString()
+                 << ".";
+        case SpyHashState::CompareResult::kASuffixB:
+          return testing::AssertionFailure()
+                 << "Hash expansion of " << c[0].ToString()
+                 << " is a suffix of the hash expansion of " << c2[0].ToString()
+                 << ".";
+        case SpyHashState::CompareResult::kUnequal:
+          break;
+      }
+    }
+  }
+  return testing::AssertionSuccess();
+}
+
+template <typename... T>
+struct TypeSet {
+  template <typename U, bool = disjunction<std::is_same<T, U>...>::value>
+  struct Insert {
+    using type = TypeSet<U, T...>;
+  };
+  template <typename U>
+  struct Insert<U, true> {
+    using type = TypeSet;
+  };
+
+  template <template <typename...> class C>
+  using apply = C<T...>;
+};
+
+template <typename... T>
+struct MakeTypeSet : TypeSet<> {};
+template <typename T, typename... Ts>
+struct MakeTypeSet<T, Ts...> : MakeTypeSet<Ts...>::template Insert<T>::type {};
+
+template <typename... T>
+using VariantForTypes = typename MakeTypeSet<
+    const typename std::decay<T>::type*...>::template apply<absl::variant>;
+
+template <typename Container>
+struct ContainerAsVector {
+  using V = absl::variant<const typename Container::value_type*>;
+  using Out = std::vector<V>;
+
+  static Out Do(const Container& values) {
+    Out out;
+    for (const auto& v : values) out.push_back(&v);
+    return out;
+  }
+};
+
+template <typename... T>
+struct ContainerAsVector<std::tuple<T...>> {
+  using V = VariantForTypes<T...>;
+  using Out = std::vector<V>;
+
+  template <size_t... I>
+  static Out DoImpl(const std::tuple<T...>& tuple, absl::index_sequence<I...>) {
+    return Out{&std::get<I>(tuple)...};
+  }
+
+  static Out Do(const std::tuple<T...>& values) {
+    return DoImpl(values, absl::index_sequence_for<T...>());
+  }
+};
+
+template <>
+struct ContainerAsVector<std::tuple<>> {
+  static std::vector<VariantForTypes<int>> Do(std::tuple<>) { return {}; }
+};
+
+struct DefaultEquals {
+  template <typename T, typename U>
+  bool operator()(const T& t, const U& u) const {
+    return t == u;
+  }
+};
+
+}  // namespace hash_internal
+
+template <int&..., typename Container>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(const Container& values) {
+  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
+      hash_internal::ContainerAsVector<Container>::Do(values),
+      hash_internal::DefaultEquals{});
+}
+
+template <int&..., typename Container, typename Eq>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
+  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
+      hash_internal::ContainerAsVector<Container>::Do(values), equals);
+}
+
+template <int&..., typename T>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values) {
+  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
+      hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
+      hash_internal::DefaultEquals{});
+}
+
+template <int&..., typename T, typename Eq>
+ABSL_MUST_USE_RESULT testing::AssertionResult
+VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
+                                      Eq equals) {
+  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
+      hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
+      equals);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_HASH_HASH_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/internal/city.h b/CAPI/cpp/grpc/include/absl/hash/internal/city.h
new file mode 100644
index 0000000..393da0b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/hash/internal/city.h
@@ -0,0 +1,78 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// https://code.google.com/p/cityhash/
+//
+// This file provides a few functions for hashing strings.  All of them are
+// high-quality functions in the sense that they pass standard tests such
+// as Austin Appleby's SMHasher.  They are also fast.
+//
+// For 64-bit x86 code, on short strings, we don't know of anything faster than
+// CityHash64 that is of comparable quality.  We believe our nearest competitor
+// is Murmur3.  For 64-bit x86 code, CityHash64 is an excellent choice for hash
+// tables and most other hashing (excluding cryptography).
+//
+// For 32-bit x86 code, we don't know of anything faster than CityHash32 that
+// is of comparable quality.  We believe our nearest competitor is Murmur3A.
+// (On 64-bit CPUs, it is typically faster to use the other CityHash variants.)
+//
+// Functions in the CityHash family are not suitable for cryptography.
+//
+// Please see CityHash's README file for more details on our performance
+// measurements and so on.
+//
+// WARNING: This code has been only lightly tested on big-endian platforms!
+// It is known to work well on little-endian platforms that have a small penalty
+// for unaligned reads, such as current Intel and AMD moderate-to-high-end CPUs.
+// It should work on all 32-bit and 64-bit platforms that allow unaligned reads;
+// bug reports are welcome.
+//
+// By the way, for some hash functions, given strings a and b, the hash
+// of a+b is easily derived from the hashes of a and b.  This property
+// doesn't hold for any hash functions in this file.
+
+#ifndef ABSL_HASH_INTERNAL_CITY_H_
+#define ABSL_HASH_INTERNAL_CITY_H_
+
+#include <stdint.h>
+#include <stdlib.h>  // for size_t.
+
+#include <utility>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace hash_internal {
+
+// Hash function for a byte array.
+uint64_t CityHash64(const char *s, size_t len);
+
+// Hash function for a byte array.  For convenience, a 64-bit seed is also
+// hashed into the result.
+uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed);
+
+// Hash function for a byte array.  For convenience, two seeds are also
+// hashed into the result.
+uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
+                             uint64_t seed1);
+
+// Hash function for a byte array.  Most useful in 32-bit binaries.
+uint32_t CityHash32(const char *s, size_t len);
+
+}  // namespace hash_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_HASH_INTERNAL_CITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/internal/hash.h b/CAPI/cpp/grpc/include/absl/hash/internal/hash.h
new file mode 100644
index 0000000..45dfdd4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/hash/internal/hash.h
@@ -0,0 +1,1291 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: hash.h
+// -----------------------------------------------------------------------------
+//
+#ifndef ABSL_HASH_INTERNAL_HASH_H_
+#define ABSL_HASH_INTERNAL_HASH_H_
+
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <cmath>
+#include <cstddef>
+#include <cstring>
+#include <deque>
+#include <forward_list>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/unaligned_access.h"
+#include "absl/base/port.h"
+#include "absl/container/fixed_array.h"
+#include "absl/hash/internal/city.h"
+#include "absl/hash/internal/low_level_hash.h"
+#include "absl/meta/type_traits.h"
+#include "absl/numeric/int128.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class HashState;
+
+namespace hash_internal {
+
+// Internal detail: Large buffers are hashed in smaller chunks.  This function
+// returns the size of these chunks.
+constexpr size_t PiecewiseChunkSize() { return 1024; }
+
+// PiecewiseCombiner
+//
+// PiecewiseCombiner is an internal-only helper class for hashing a piecewise
+// buffer of `char` or `unsigned char` as though it were contiguous.  This class
+// provides two methods:
+//
+//   H add_buffer(state, data, size)
+//   H finalize(state)
+//
+// `add_buffer` can be called zero or more times, followed by a single call to
+// `finalize`.  This will produce the same hash expansion as concatenating each
+// buffer piece into a single contiguous buffer, and passing this to
+// `H::combine_contiguous`.
+//
+//  Example usage:
+//    PiecewiseCombiner combiner;
+//    for (const auto& piece : pieces) {
+//      state = combiner.add_buffer(std::move(state), piece.data, piece.size);
+//    }
+//    return combiner.finalize(std::move(state));
+class PiecewiseCombiner {
+ public:
+  PiecewiseCombiner() : position_(0) {}
+  PiecewiseCombiner(const PiecewiseCombiner&) = delete;
+  PiecewiseCombiner& operator=(const PiecewiseCombiner&) = delete;
+
+  // PiecewiseCombiner::add_buffer()
+  //
+  // Appends the given range of bytes to the sequence to be hashed, which may
+  // modify the provided hash state.
+  template <typename H>
+  H add_buffer(H state, const unsigned char* data, size_t size);
+  template <typename H>
+  H add_buffer(H state, const char* data, size_t size) {
+    return add_buffer(std::move(state),
+                      reinterpret_cast<const unsigned char*>(data), size);
+  }
+
+  // PiecewiseCombiner::finalize()
+  //
+  // Finishes combining the hash sequence, which may may modify the provided
+  // hash state.
+  //
+  // Once finalize() is called, add_buffer() may no longer be called. The
+  // resulting hash state will be the same as if the pieces passed to
+  // add_buffer() were concatenated into a single flat buffer, and then provided
+  // to H::combine_contiguous().
+  template <typename H>
+  H finalize(H state);
+
+ private:
+  unsigned char buf_[PiecewiseChunkSize()];
+  size_t position_;
+};
+
+// is_hashable()
+//
+// Trait class which returns true if T is hashable by the absl::Hash framework.
+// Used for the AbslHashValue implementations for composite types below.
+template <typename T>
+struct is_hashable;
+
+// HashStateBase
+//
+// An internal implementation detail that contains common implementation details
+// for all of the "hash state objects" objects generated by Abseil.  This is not
+// a public API; users should not create classes that inherit from this.
+//
+// A hash state object is the template argument `H` passed to `AbslHashValue`.
+// It represents an intermediate state in the computation of an unspecified hash
+// algorithm. `HashStateBase` provides a CRTP style base class for hash state
+// implementations. Developers adding type support for `absl::Hash` should not
+// rely on any parts of the state object other than the following member
+// functions:
+//
+//   * HashStateBase::combine()
+//   * HashStateBase::combine_contiguous()
+//   * HashStateBase::combine_unordered()
+//
+// A derived hash state class of type `H` must provide a public member function
+// with a signature similar to the following:
+//
+//    `static H combine_contiguous(H state, const unsigned char*, size_t)`.
+//
+// It must also provide a private template method named RunCombineUnordered.
+//
+// A "consumer" is a 1-arg functor returning void.  Its argument is a reference
+// to an inner hash state object, and it may be called multiple times.  When
+// called, the functor consumes the entropy from the provided state object,
+// and resets that object to its empty state.
+//
+// A "combiner" is a stateless 2-arg functor returning void.  Its arguments are
+// an inner hash state object and an ElementStateConsumer functor.  A combiner
+// uses the provided inner hash state object to hash each element of the
+// container, passing the inner hash state object to the consumer after hashing
+// each element.
+//
+// Given these definitions, a derived hash state class of type H
+// must provide a private template method with a signature similar to the
+// following:
+//
+//    `template <typename CombinerT>`
+//    `static H RunCombineUnordered(H outer_state, CombinerT combiner)`
+//
+// This function is responsible for constructing the inner state object and
+// providing a consumer to the combiner.  It uses side effects of the consumer
+// and combiner to mix the state of each element in an order-independent manner,
+// and uses this to return an updated value of `outer_state`.
+//
+// This inside-out approach generates efficient object code in the normal case,
+// but allows us to use stack storage to implement the absl::HashState type
+// erasure mechanism (avoiding heap allocations while hashing).
+//
+// `HashStateBase` will provide a complete implementation for a hash state
+// object in terms of these two methods.
+//
+// Example:
+//
+//   // Use CRTP to define your derived class.
+//   struct MyHashState : HashStateBase<MyHashState> {
+//       static H combine_contiguous(H state, const unsigned char*, size_t);
+//       using MyHashState::HashStateBase::combine;
+//       using MyHashState::HashStateBase::combine_contiguous;
+//       using MyHashState::HashStateBase::combine_unordered;
+//     private:
+//       template <typename CombinerT>
+//       static H RunCombineUnordered(H state, CombinerT combiner);
+//   };
+template <typename H>
+class HashStateBase {
+ public:
+  // HashStateBase::combine()
+  //
+  // Combines an arbitrary number of values into a hash state, returning the
+  // updated state.
+  //
+  // Each of the value types `T` must be separately hashable by the Abseil
+  // hashing framework.
+  //
+  // NOTE:
+  //
+  //   state = H::combine(std::move(state), value1, value2, value3);
+  //
+  // is guaranteed to produce the same hash expansion as:
+  //
+  //   state = H::combine(std::move(state), value1);
+  //   state = H::combine(std::move(state), value2);
+  //   state = H::combine(std::move(state), value3);
+  template <typename T, typename... Ts>
+  static H combine(H state, const T& value, const Ts&... values);
+  static H combine(H state) { return state; }
+
+  // HashStateBase::combine_contiguous()
+  //
+  // Combines a contiguous array of `size` elements into a hash state, returning
+  // the updated state.
+  //
+  // NOTE:
+  //
+  //   state = H::combine_contiguous(std::move(state), data, size);
+  //
+  // is NOT guaranteed to produce the same hash expansion as a for-loop (it may
+  // perform internal optimizations).  If you need this guarantee, use the
+  // for-loop instead.
+  template <typename T>
+  static H combine_contiguous(H state, const T* data, size_t size);
+
+  template <typename I>
+  static H combine_unordered(H state, I begin, I end);
+
+  using AbslInternalPiecewiseCombiner = PiecewiseCombiner;
+
+  template <typename T>
+  using is_hashable = absl::hash_internal::is_hashable<T>;
+
+ private:
+  // Common implementation of the iteration step of a "combiner", as described
+  // above.
+  template <typename I>
+  struct CombineUnorderedCallback {
+    I begin;
+    I end;
+
+    template <typename InnerH, typename ElementStateConsumer>
+    void operator()(InnerH inner_state, ElementStateConsumer cb) {
+      for (; begin != end; ++begin) {
+        inner_state = H::combine(std::move(inner_state), *begin);
+        cb(inner_state);
+      }
+    }
+  };
+};
+
+// is_uniquely_represented
+//
+// `is_uniquely_represented<T>` is a trait class that indicates whether `T`
+// is uniquely represented.
+//
+// A type is "uniquely represented" if two equal values of that type are
+// guaranteed to have the same bytes in their underlying storage. In other
+// words, if `a == b`, then `memcmp(&a, &b, sizeof(T))` is guaranteed to be
+// zero. This property cannot be detected automatically, so this trait is false
+// by default, but can be specialized by types that wish to assert that they are
+// uniquely represented. This makes them eligible for certain optimizations.
+//
+// If you have any doubt whatsoever, do not specialize this template.
+// The default is completely safe, and merely disables some optimizations
+// that will not matter for most types. Specializing this template,
+// on the other hand, can be very hazardous.
+//
+// To be uniquely represented, a type must not have multiple ways of
+// representing the same value; for example, float and double are not
+// uniquely represented, because they have distinct representations for
+// +0 and -0. Furthermore, the type's byte representation must consist
+// solely of user-controlled data, with no padding bits and no compiler-
+// controlled data such as vptrs or sanitizer metadata. This is usually
+// very difficult to guarantee, because in most cases the compiler can
+// insert data and padding bits at its own discretion.
+//
+// If you specialize this template for a type `T`, you must do so in the file
+// that defines that type (or in this file). If you define that specialization
+// anywhere else, `is_uniquely_represented<T>` could have different meanings
+// in different places.
+//
+// The Enable parameter is meaningless; it is provided as a convenience,
+// to support certain SFINAE techniques when defining specializations.
+template <typename T, typename Enable = void>
+struct is_uniquely_represented : std::false_type {};
+
+// is_uniquely_represented<unsigned char>
+//
+// unsigned char is a synonym for "byte", so it is guaranteed to be
+// uniquely represented.
+template <>
+struct is_uniquely_represented<unsigned char> : std::true_type {};
+
+// is_uniquely_represented for non-standard integral types
+//
+// Integral types other than bool should be uniquely represented on any
+// platform that this will plausibly be ported to.
+template <typename Integral>
+struct is_uniquely_represented<
+    Integral, typename std::enable_if<std::is_integral<Integral>::value>::type>
+    : std::true_type {};
+
+// is_uniquely_represented<bool>
+//
+//
+template <>
+struct is_uniquely_represented<bool> : std::false_type {};
+
+// hash_bytes()
+//
+// Convenience function that combines `hash_state` with the byte representation
+// of `value`.
+template <typename H, typename T>
+H hash_bytes(H hash_state, const T& value) {
+  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
+  return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
+}
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for Basic Types
+// -----------------------------------------------------------------------------
+
+// Note: Default `AbslHashValue` implementations live in `hash_internal`. This
+// allows us to block lexical scope lookup when doing an unqualified call to
+// `AbslHashValue` below. User-defined implementations of `AbslHashValue` can
+// only be found via ADL.
+
+// AbslHashValue() for hashing bool values
+//
+// We use SFINAE to ensure that this overload only accepts bool, not types that
+// are convertible to bool.
+template <typename H, typename B>
+typename std::enable_if<std::is_same<B, bool>::value, H>::type AbslHashValue(
+    H hash_state, B value) {
+  return H::combine(std::move(hash_state),
+                    static_cast<unsigned char>(value ? 1 : 0));
+}
+
+// AbslHashValue() for hashing enum values
+template <typename H, typename Enum>
+typename std::enable_if<std::is_enum<Enum>::value, H>::type AbslHashValue(
+    H hash_state, Enum e) {
+  // In practice, we could almost certainly just invoke hash_bytes directly,
+  // but it's possible that a sanitizer might one day want to
+  // store data in the unused bits of an enum. To avoid that risk, we
+  // convert to the underlying type before hashing. Hopefully this will get
+  // optimized away; if not, we can reopen discussion with c-toolchain-team.
+  return H::combine(std::move(hash_state),
+                    static_cast<typename std::underlying_type<Enum>::type>(e));
+}
+// AbslHashValue() for hashing floating-point values
+template <typename H, typename Float>
+typename std::enable_if<std::is_same<Float, float>::value ||
+                            std::is_same<Float, double>::value,
+                        H>::type
+AbslHashValue(H hash_state, Float value) {
+  return hash_internal::hash_bytes(std::move(hash_state),
+                                   value == 0 ? 0 : value);
+}
+
+// Long double has the property that it might have extra unused bytes in it.
+// For example, in x86 sizeof(long double)==16 but it only really uses 80-bits
+// of it. This means we can't use hash_bytes on a long double and have to
+// convert it to something else first.
+template <typename H, typename LongDouble>
+typename std::enable_if<std::is_same<LongDouble, long double>::value, H>::type
+AbslHashValue(H hash_state, LongDouble value) {
+  const int category = std::fpclassify(value);
+  switch (category) {
+    case FP_INFINITE:
+      // Add the sign bit to differentiate between +Inf and -Inf
+      hash_state = H::combine(std::move(hash_state), std::signbit(value));
+      break;
+
+    case FP_NAN:
+    case FP_ZERO:
+    default:
+      // Category is enough for these.
+      break;
+
+    case FP_NORMAL:
+    case FP_SUBNORMAL:
+      // We can't convert `value` directly to double because this would have
+      // undefined behavior if the value is out of range.
+      // std::frexp gives us a value in the range (-1, -.5] or [.5, 1) that is
+      // guaranteed to be in range for `double`. The truncation is
+      // implementation defined, but that works as long as it is deterministic.
+      int exp;
+      auto mantissa = static_cast<double>(std::frexp(value, &exp));
+      hash_state = H::combine(std::move(hash_state), mantissa, exp);
+  }
+
+  return H::combine(std::move(hash_state), category);
+}
+
+// AbslHashValue() for hashing pointers
+template <typename H, typename T>
+H AbslHashValue(H hash_state, T* ptr) {
+  auto v = reinterpret_cast<uintptr_t>(ptr);
+  // Due to alignment, pointers tend to have low bits as zero, and the next few
+  // bits follow a pattern since they are also multiples of some base value.
+  // Mixing the pointer twice helps prevent stuck low bits for certain alignment
+  // values.
+  return H::combine(std::move(hash_state), v, v);
+}
+
+// AbslHashValue() for hashing nullptr_t
+template <typename H>
+H AbslHashValue(H hash_state, std::nullptr_t) {
+  return H::combine(std::move(hash_state), static_cast<void*>(nullptr));
+}
+
+// AbslHashValue() for hashing pointers-to-member
+template <typename H, typename T, typename C>
+H AbslHashValue(H hash_state, T C::* ptr) {
+  auto salient_ptm_size = [](std::size_t n) -> std::size_t {
+#if defined(_MSC_VER)
+    // Pointers-to-member-function on MSVC consist of one pointer plus 0, 1, 2,
+    // or 3 ints. In 64-bit mode, they are 8-byte aligned and thus can contain
+    // padding (namely when they have 1 or 3 ints). The value below is a lower
+    // bound on the number of salient, non-padding bytes that we use for
+    // hashing.
+    if (alignof(T C::*) == alignof(int)) {
+      // No padding when all subobjects have the same size as the total
+      // alignment. This happens in 32-bit mode.
+      return n;
+    } else {
+      // Padding for 1 int (size 16) or 3 ints (size 24).
+      // With 2 ints, the size is 16 with no padding, which we pessimize.
+      return n == 24 ? 20 : n == 16 ? 12 : n;
+    }
+#else
+    // On other platforms, we assume that pointers-to-members do not have
+    // padding.
+#ifdef __cpp_lib_has_unique_object_representations
+    static_assert(std::has_unique_object_representations_v<T C::*>);
+#endif  // __cpp_lib_has_unique_object_representations
+    return n;
+#endif
+  };
+  return H::combine_contiguous(std::move(hash_state),
+                               reinterpret_cast<unsigned char*>(&ptr),
+                               salient_ptm_size(sizeof ptr));
+}
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for Composite Types
+// -----------------------------------------------------------------------------
+
+// AbslHashValue() for hashing pairs
+template <typename H, typename T1, typename T2>
+typename std::enable_if<is_hashable<T1>::value && is_hashable<T2>::value,
+                        H>::type
+AbslHashValue(H hash_state, const std::pair<T1, T2>& p) {
+  return H::combine(std::move(hash_state), p.first, p.second);
+}
+
+// hash_tuple()
+//
+// Helper function for hashing a tuple. The third argument should
+// be an index_sequence running from 0 to tuple_size<Tuple> - 1.
+template <typename H, typename Tuple, size_t... Is>
+H hash_tuple(H hash_state, const Tuple& t, absl::index_sequence<Is...>) {
+  return H::combine(std::move(hash_state), std::get<Is>(t)...);
+}
+
+// AbslHashValue for hashing tuples
+template <typename H, typename... Ts>
+#if defined(_MSC_VER)
+// This SFINAE gets MSVC confused under some conditions. Let's just disable it
+// for now.
+H
+#else   // _MSC_VER
+typename std::enable_if<absl::conjunction<is_hashable<Ts>...>::value, H>::type
+#endif  // _MSC_VER
+AbslHashValue(H hash_state, const std::tuple<Ts...>& t) {
+  return hash_internal::hash_tuple(std::move(hash_state), t,
+                                   absl::make_index_sequence<sizeof...(Ts)>());
+}
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for Pointers
+// -----------------------------------------------------------------------------
+
+// AbslHashValue for hashing unique_ptr
+template <typename H, typename T, typename D>
+H AbslHashValue(H hash_state, const std::unique_ptr<T, D>& ptr) {
+  return H::combine(std::move(hash_state), ptr.get());
+}
+
+// AbslHashValue for hashing shared_ptr
+template <typename H, typename T>
+H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr) {
+  return H::combine(std::move(hash_state), ptr.get());
+}
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for String-Like Types
+// -----------------------------------------------------------------------------
+
+// AbslHashValue for hashing strings
+//
+// All the string-like types supported here provide the same hash expansion for
+// the same character sequence. These types are:
+//
+//  - `absl::Cord`
+//  - `std::string` (and std::basic_string<char, std::char_traits<char>, A> for
+//      any allocator A)
+//  - `absl::string_view` and `std::string_view`
+//
+// For simplicity, we currently support only `char` strings. This support may
+// be broadened, if necessary, but with some caution - this overload would
+// misbehave in cases where the traits' `eq()` member isn't equivalent to `==`
+// on the underlying character type.
+template <typename H>
+H AbslHashValue(H hash_state, absl::string_view str) {
+  return H::combine(
+      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
+      str.size());
+}
+
+// Support std::wstring, std::u16string and std::u32string.
+template <typename Char, typename Alloc, typename H,
+          typename = absl::enable_if_t<std::is_same<Char, wchar_t>::value ||
+                                       std::is_same<Char, char16_t>::value ||
+                                       std::is_same<Char, char32_t>::value>>
+H AbslHashValue(
+    H hash_state,
+    const std::basic_string<Char, std::char_traits<Char>, Alloc>& str) {
+  return H::combine(
+      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
+      str.size());
+}
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for Sequence Containers
+// -----------------------------------------------------------------------------
+
+// AbslHashValue for hashing std::array
+template <typename H, typename T, size_t N>
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+    H hash_state, const std::array<T, N>& array) {
+  return H::combine_contiguous(std::move(hash_state), array.data(),
+                               array.size());
+}
+
+// AbslHashValue for hashing std::deque
+template <typename H, typename T, typename Allocator>
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+    H hash_state, const std::deque<T, Allocator>& deque) {
+  // TODO(gromer): investigate a more efficient implementation taking
+  // advantage of the chunk structure.
+  for (const auto& t : deque) {
+    hash_state = H::combine(std::move(hash_state), t);
+  }
+  return H::combine(std::move(hash_state), deque.size());
+}
+
+// AbslHashValue for hashing std::forward_list
+template <typename H, typename T, typename Allocator>
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+    H hash_state, const std::forward_list<T, Allocator>& list) {
+  size_t size = 0;
+  for (const T& t : list) {
+    hash_state = H::combine(std::move(hash_state), t);
+    ++size;
+  }
+  return H::combine(std::move(hash_state), size);
+}
+
+// AbslHashValue for hashing std::list
+template <typename H, typename T, typename Allocator>
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+    H hash_state, const std::list<T, Allocator>& list) {
+  for (const auto& t : list) {
+    hash_state = H::combine(std::move(hash_state), t);
+  }
+  return H::combine(std::move(hash_state), list.size());
+}
+
+// AbslHashValue for hashing std::vector
+//
+// Do not use this for vector<bool> on platforms that have a working
+// implementation of std::hash. It does not have a .data(), and a fallback for
+// std::hash<> is most likely faster.
+template <typename H, typename T, typename Allocator>
+typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value,
+                        H>::type
+AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
+  return H::combine(H::combine_contiguous(std::move(hash_state), vector.data(),
+                                          vector.size()),
+                    vector.size());
+}
+
+// AbslHashValue special cases for hashing std::vector<bool>
+
+#if defined(ABSL_IS_BIG_ENDIAN) && \
+    (defined(__GLIBCXX__) || defined(__GLIBCPP__))
+
+// std::hash in libstdc++ does not work correctly with vector<bool> on Big
+// Endian platforms therefore we need to implement a custom AbslHashValue for
+// it. More details on the bug:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
+template <typename H, typename T, typename Allocator>
+typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value,
+                        H>::type
+AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
+  typename H::AbslInternalPiecewiseCombiner combiner;
+  for (const auto& i : vector) {
+    unsigned char c = static_cast<unsigned char>(i);
+    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
+  }
+  return H::combine(combiner.finalize(std::move(hash_state)), vector.size());
+}
+#else
+// When not working around the libstdc++ bug above, we still have to contend
+// with the fact that std::hash<vector<bool>> is often poor quality, hashing
+// directly on the internal words and on no other state.  On these platforms,
+// vector<bool>{1, 1} and vector<bool>{1, 1, 0} hash to the same value.
+//
+// Mixing in the size (as we do in our other vector<> implementations) on top
+// of the library-provided hash implementation avoids this QOI issue.
+template <typename H, typename T, typename Allocator>
+typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value,
+                        H>::type
+AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
+  return H::combine(std::move(hash_state),
+                    std::hash<std::vector<T, Allocator>>{}(vector),
+                    vector.size());
+}
+#endif
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for Ordered Associative Containers
+// -----------------------------------------------------------------------------
+
+// AbslHashValue for hashing std::map
+template <typename H, typename Key, typename T, typename Compare,
+          typename Allocator>
+typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
+                        H>::type
+AbslHashValue(H hash_state, const std::map<Key, T, Compare, Allocator>& map) {
+  for (const auto& t : map) {
+    hash_state = H::combine(std::move(hash_state), t);
+  }
+  return H::combine(std::move(hash_state), map.size());
+}
+
+// AbslHashValue for hashing std::multimap
+template <typename H, typename Key, typename T, typename Compare,
+          typename Allocator>
+typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
+                        H>::type
+AbslHashValue(H hash_state,
+              const std::multimap<Key, T, Compare, Allocator>& map) {
+  for (const auto& t : map) {
+    hash_state = H::combine(std::move(hash_state), t);
+  }
+  return H::combine(std::move(hash_state), map.size());
+}
+
+// AbslHashValue for hashing std::set
+template <typename H, typename Key, typename Compare, typename Allocator>
+typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
+    H hash_state, const std::set<Key, Compare, Allocator>& set) {
+  for (const auto& t : set) {
+    hash_state = H::combine(std::move(hash_state), t);
+  }
+  return H::combine(std::move(hash_state), set.size());
+}
+
+// AbslHashValue for hashing std::multiset
+template <typename H, typename Key, typename Compare, typename Allocator>
+typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
+    H hash_state, const std::multiset<Key, Compare, Allocator>& set) {
+  for (const auto& t : set) {
+    hash_state = H::combine(std::move(hash_state), t);
+  }
+  return H::combine(std::move(hash_state), set.size());
+}
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for Unordered Associative Containers
+// -----------------------------------------------------------------------------
+
+// AbslHashValue for hashing std::unordered_set
+template <typename H, typename Key, typename Hash, typename KeyEqual,
+          typename Alloc>
+typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
+    H hash_state, const std::unordered_set<Key, Hash, KeyEqual, Alloc>& s) {
+  return H::combine(
+      H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
+      s.size());
+}
+
+// AbslHashValue for hashing std::unordered_multiset
+template <typename H, typename Key, typename Hash, typename KeyEqual,
+          typename Alloc>
+typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
+    H hash_state,
+    const std::unordered_multiset<Key, Hash, KeyEqual, Alloc>& s) {
+  return H::combine(
+      H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
+      s.size());
+}
+
+// AbslHashValue for hashing std::unordered_set
+template <typename H, typename Key, typename T, typename Hash,
+          typename KeyEqual, typename Alloc>
+typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
+                        H>::type
+AbslHashValue(H hash_state,
+              const std::unordered_map<Key, T, Hash, KeyEqual, Alloc>& s) {
+  return H::combine(
+      H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
+      s.size());
+}
+
+// AbslHashValue for hashing std::unordered_multiset
+template <typename H, typename Key, typename T, typename Hash,
+          typename KeyEqual, typename Alloc>
+typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
+                        H>::type
+AbslHashValue(H hash_state,
+              const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& s) {
+  return H::combine(
+      H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
+      s.size());
+}
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for Wrapper Types
+// -----------------------------------------------------------------------------
+
+// AbslHashValue for hashing std::reference_wrapper
+template <typename H, typename T>
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+    H hash_state, std::reference_wrapper<T> opt) {
+  return H::combine(std::move(hash_state), opt.get());
+}
+
+// AbslHashValue for hashing absl::optional
+template <typename H, typename T>
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+    H hash_state, const absl::optional<T>& opt) {
+  if (opt) hash_state = H::combine(std::move(hash_state), *opt);
+  return H::combine(std::move(hash_state), opt.has_value());
+}
+
+// VariantVisitor
+template <typename H>
+struct VariantVisitor {
+  H&& hash_state;
+  template <typename T>
+  H operator()(const T& t) const {
+    return H::combine(std::move(hash_state), t);
+  }
+};
+
+// AbslHashValue for hashing absl::variant
+template <typename H, typename... T>
+typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type
+AbslHashValue(H hash_state, const absl::variant<T...>& v) {
+  if (!v.valueless_by_exception()) {
+    hash_state = absl::visit(VariantVisitor<H>{std::move(hash_state)}, v);
+  }
+  return H::combine(std::move(hash_state), v.index());
+}
+
+// -----------------------------------------------------------------------------
+// AbslHashValue for Other Types
+// -----------------------------------------------------------------------------
+
+// AbslHashValue for hashing std::bitset is not defined on Little Endian
+// platforms, for the same reason as for vector<bool> (see std::vector above):
+// It does not expose the raw bytes, and a fallback to std::hash<> is most
+// likely faster.
+
+#if defined(ABSL_IS_BIG_ENDIAN) && \
+    (defined(__GLIBCXX__) || defined(__GLIBCPP__))
+// AbslHashValue for hashing std::bitset
+//
+// std::hash in libstdc++ does not work correctly with std::bitset on Big Endian
+// platforms therefore we need to implement a custom AbslHashValue for it. More
+// details on the bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
+template <typename H, size_t N>
+H AbslHashValue(H hash_state, const std::bitset<N>& set) {
+  typename H::AbslInternalPiecewiseCombiner combiner;
+  for (int i = 0; i < N; i++) {
+    unsigned char c = static_cast<unsigned char>(set[i]);
+    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
+  }
+  return H::combine(combiner.finalize(std::move(hash_state)), N);
+}
+#endif
+
+// -----------------------------------------------------------------------------
+
+// hash_range_or_bytes()
+//
+// Mixes all values in the range [data, data+size) into the hash state.
+// This overload accepts only uniquely-represented types, and hashes them by
+// hashing the entire range of bytes.
+template <typename H, typename T>
+typename std::enable_if<is_uniquely_represented<T>::value, H>::type
+hash_range_or_bytes(H hash_state, const T* data, size_t size) {
+  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
+  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
+}
+
+// hash_range_or_bytes()
+template <typename H, typename T>
+typename std::enable_if<!is_uniquely_represented<T>::value, H>::type
+hash_range_or_bytes(H hash_state, const T* data, size_t size) {
+  for (const auto end = data + size; data < end; ++data) {
+    hash_state = H::combine(std::move(hash_state), *data);
+  }
+  return hash_state;
+}
+
+#if defined(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE) && \
+    ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 1
+#else
+#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 0
+#endif
+
+// HashSelect
+//
+// Type trait to select the appropriate hash implementation to use.
+// HashSelect::type<T> will give the proper hash implementation, to be invoked
+// as:
+//   HashSelect::type<T>::Invoke(state, value)
+// Also, HashSelect::type<T>::value is a boolean equal to `true` if there is a
+// valid `Invoke` function. Types that are not hashable will have a ::value of
+// `false`.
+struct HashSelect {
+ private:
+  struct State : HashStateBase<State> {
+    static State combine_contiguous(State hash_state, const unsigned char*,
+                                    size_t);
+    using State::HashStateBase::combine_contiguous;
+  };
+
+  struct UniquelyRepresentedProbe {
+    template <typename H, typename T>
+    static auto Invoke(H state, const T& value)
+        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
+      return hash_internal::hash_bytes(std::move(state), value);
+    }
+  };
+
+  struct HashValueProbe {
+    template <typename H, typename T>
+    static auto Invoke(H state, const T& value) -> absl::enable_if_t<
+        std::is_same<H,
+                     decltype(AbslHashValue(std::move(state), value))>::value,
+        H> {
+      return AbslHashValue(std::move(state), value);
+    }
+  };
+
+  struct LegacyHashProbe {
+#if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
+    template <typename H, typename T>
+    static auto Invoke(H state, const T& value) -> absl::enable_if_t<
+        std::is_convertible<
+            decltype(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>()(value)),
+            size_t>::value,
+        H> {
+      return hash_internal::hash_bytes(
+          std::move(state),
+          ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>{}(value));
+    }
+#endif  // ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
+  };
+
+  struct StdHashProbe {
+    template <typename H, typename T>
+    static auto Invoke(H state, const T& value)
+        -> absl::enable_if_t<type_traits_internal::IsHashable<T>::value, H> {
+      return hash_internal::hash_bytes(std::move(state), std::hash<T>{}(value));
+    }
+  };
+
+  template <typename Hash, typename T>
+  struct Probe : Hash {
+   private:
+    template <typename H, typename = decltype(H::Invoke(
+                              std::declval<State>(), std::declval<const T&>()))>
+    static std::true_type Test(int);
+    template <typename U>
+    static std::false_type Test(char);
+
+   public:
+    static constexpr bool value = decltype(Test<Hash>(0))::value;
+  };
+
+ public:
+  // Probe each implementation in order.
+  // disjunction provides short circuiting wrt instantiation.
+  template <typename T>
+  using Apply = absl::disjunction<         //
+      Probe<UniquelyRepresentedProbe, T>,  //
+      Probe<HashValueProbe, T>,            //
+      Probe<LegacyHashProbe, T>,           //
+      Probe<StdHashProbe, T>,              //
+      std::false_type>;
+};
+
+template <typename T>
+struct is_hashable
+    : std::integral_constant<bool, HashSelect::template Apply<T>::value> {};
+
+// MixingHashState
+class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
+  // absl::uint128 is not an alias or a thin wrapper around the intrinsic.
+  // We use the intrinsic when available to improve performance.
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  using uint128 = __uint128_t;
+#else   // ABSL_HAVE_INTRINSIC_INT128
+  using uint128 = absl::uint128;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+  static constexpr uint64_t kMul =
+      sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51}
+                          : uint64_t{0x9ddfea08eb382d69};
+
+  template <typename T>
+  using IntegralFastPath =
+      conjunction<std::is_integral<T>, is_uniquely_represented<T>>;
+
+ public:
+  // Move only
+  MixingHashState(MixingHashState&&) = default;
+  MixingHashState& operator=(MixingHashState&&) = default;
+
+  // MixingHashState::combine_contiguous()
+  //
+  // Fundamental base case for hash recursion: mixes the given range of bytes
+  // into the hash state.
+  static MixingHashState combine_contiguous(MixingHashState hash_state,
+                                            const unsigned char* first,
+                                            size_t size) {
+    return MixingHashState(
+        CombineContiguousImpl(hash_state.state_, first, size,
+                              std::integral_constant<int, sizeof(size_t)>{}));
+  }
+  using MixingHashState::HashStateBase::combine_contiguous;
+
+  // MixingHashState::hash()
+  //
+  // For performance reasons in non-opt mode, we specialize this for
+  // integral types.
+  // Otherwise we would be instantiating and calling dozens of functions for
+  // something that is just one multiplication and a couple xor's.
+  // The result should be the same as running the whole algorithm, but faster.
+  template <typename T, absl::enable_if_t<IntegralFastPath<T>::value, int> = 0>
+  static size_t hash(T value) {
+    return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value)));
+  }
+
+  // Overload of MixingHashState::hash()
+  template <typename T, absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0>
+  static size_t hash(const T& value) {
+    return static_cast<size_t>(combine(MixingHashState{}, value).state_);
+  }
+
+ private:
+  // Invoked only once for a given argument; that plus the fact that this is
+  // move-only ensures that there is only one non-moved-from object.
+  MixingHashState() : state_(Seed()) {}
+
+  friend class MixingHashState::HashStateBase;
+
+  template <typename CombinerT>
+  static MixingHashState RunCombineUnordered(MixingHashState state,
+                                             CombinerT combiner) {
+    uint64_t unordered_state = 0;
+    combiner(MixingHashState{}, [&](MixingHashState& inner_state) {
+      // Add the hash state of the element to the running total, but mix the
+      // carry bit back into the low bit.  This in intended to avoid losing
+      // entropy to overflow, especially when unordered_multisets contain
+      // multiple copies of the same value.
+      auto element_state = inner_state.state_;
+      unordered_state += element_state;
+      if (unordered_state < element_state) {
+        ++unordered_state;
+      }
+      inner_state = MixingHashState{};
+    });
+    return MixingHashState::combine(std::move(state), unordered_state);
+  }
+
+  // Allow the HashState type-erasure implementation to invoke
+  // RunCombinedUnordered() directly.
+  friend class absl::HashState;
+
+  // Workaround for MSVC bug.
+  // We make the type copyable to fix the calling convention, even though we
+  // never actually copy it. Keep it private to not affect the public API of the
+  // type.
+  MixingHashState(const MixingHashState&) = default;
+
+  explicit MixingHashState(uint64_t state) : state_(state) {}
+
+  // Implementation of the base case for combine_contiguous where we actually
+  // mix the bytes into the state.
+  // Dispatch to different implementations of the combine_contiguous depending
+  // on the value of `sizeof(size_t)`.
+  static uint64_t CombineContiguousImpl(uint64_t state,
+                                        const unsigned char* first, size_t len,
+                                        std::integral_constant<int, 4>
+                                        /* sizeof_size_t */);
+  static uint64_t CombineContiguousImpl(uint64_t state,
+                                        const unsigned char* first, size_t len,
+                                        std::integral_constant<int, 8>
+                                        /* sizeof_size_t */);
+
+  // Slow dispatch path for calls to CombineContiguousImpl with a size argument
+  // larger than PiecewiseChunkSize().  Has the same effect as calling
+  // CombineContiguousImpl() repeatedly with the chunk stride size.
+  static uint64_t CombineLargeContiguousImpl32(uint64_t state,
+                                               const unsigned char* first,
+                                               size_t len);
+  static uint64_t CombineLargeContiguousImpl64(uint64_t state,
+                                               const unsigned char* first,
+                                               size_t len);
+
+  // Reads 9 to 16 bytes from p.
+  // The least significant 8 bytes are in .first, the rest (zero padded) bytes
+  // are in .second.
+  static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
+                                                 size_t len) {
+    uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
+    uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
+#ifdef ABSL_IS_LITTLE_ENDIAN
+    uint64_t most_significant = high_mem;
+    uint64_t least_significant = low_mem;
+#else
+    uint64_t most_significant = low_mem;
+    uint64_t least_significant = high_mem;
+#endif
+    return {least_significant, most_significant >> (128 - len * 8)};
+  }
+
+  // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
+  static uint64_t Read4To8(const unsigned char* p, size_t len) {
+    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
+    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
+#ifdef ABSL_IS_LITTLE_ENDIAN
+    uint32_t most_significant = high_mem;
+    uint32_t least_significant = low_mem;
+#else
+    uint32_t most_significant = low_mem;
+    uint32_t least_significant = high_mem;
+#endif
+    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
+           least_significant;
+  }
+
+  // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
+  static uint32_t Read1To3(const unsigned char* p, size_t len) {
+    unsigned char mem0 = p[0];
+    unsigned char mem1 = p[len / 2];
+    unsigned char mem2 = p[len - 1];
+#ifdef ABSL_IS_LITTLE_ENDIAN
+    unsigned char significant2 = mem2;
+    unsigned char significant1 = mem1;
+    unsigned char significant0 = mem0;
+#else
+    unsigned char significant2 = mem0;
+    unsigned char significant1 = mem1;
+    unsigned char significant0 = mem2;
+#endif
+    return static_cast<uint32_t>(significant0 |                     //
+                                 (significant1 << (len / 2 * 8)) |  //
+                                 (significant2 << ((len - 1) * 8)));
+  }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
+    // Though the 128-bit product on AArch64 needs two instructions, it is
+    // still a good balance between speed and hash quality.
+    using MultType =
+        absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
+    // We do the addition in 64-bit space to make sure the 128-bit
+    // multiplication is fast. If we were to do it as MultType the compiler has
+    // to assume that the high word is non-zero and needs to perform 2
+    // multiplications instead of one.
+    MultType m = state + v;
+    m *= kMul;
+    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
+  }
+
+  // An extern to avoid bloat on a direct call to LowLevelHash() with fixed
+  // values for both the seed and salt parameters.
+  static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data,
+                                                      size_t len) {
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+    return LowLevelHashImpl(data, len);
+#else
+    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
+#endif
+  }
+
+  // Seed()
+  //
+  // A non-deterministic seed.
+  //
+  // The current purpose of this seed is to generate non-deterministic results
+  // and prevent having users depend on the particular hash values.
+  // It is not meant as a security feature right now, but it leaves the door
+  // open to upgrade it to a true per-process random seed. A true random seed
+  // costs more and we don't need to pay for that right now.
+  //
+  // On platforms with ASLR, we take advantage of it to make a per-process
+  // random value.
+  // See https://en.wikipedia.org/wiki/Address_space_layout_randomization
+  //
+  // On other platforms this is still going to be non-deterministic but most
+  // probably per-build and not per-process.
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
+#if (!defined(__clang__) || __clang_major__ > 11) && \
+    !defined(__apple_build_version__)
+    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
+#else
+    // Workaround the absence of
+    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
+    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
+#endif
+  }
+  static const void* const kSeed;
+
+  uint64_t state_;
+};
+
+// MixingHashState::CombineContiguousImpl()
+inline uint64_t MixingHashState::CombineContiguousImpl(
+    uint64_t state, const unsigned char* first, size_t len,
+    std::integral_constant<int, 4> /* sizeof_size_t */) {
+  // For large values we use CityHash, for small ones we just use a
+  // multiplicative hash.
+  uint64_t v;
+  if (len > 8) {
+    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
+      return CombineLargeContiguousImpl32(state, first, len);
+    }
+    v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
+  } else if (len >= 4) {
+    v = Read4To8(first, len);
+  } else if (len > 0) {
+    v = Read1To3(first, len);
+  } else {
+    // Empty ranges have no effect.
+    return state;
+  }
+  return Mix(state, v);
+}
+
+// Overload of MixingHashState::CombineContiguousImpl()
+inline uint64_t MixingHashState::CombineContiguousImpl(
+    uint64_t state, const unsigned char* first, size_t len,
+    std::integral_constant<int, 8> /* sizeof_size_t */) {
+  // For large values we use LowLevelHash or CityHash depending on the platform,
+  // for small ones we just use a multiplicative hash.
+  uint64_t v;
+  if (len > 16) {
+    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
+      return CombineLargeContiguousImpl64(state, first, len);
+    }
+    v = Hash64(first, len);
+  } else if (len > 8) {
+    auto p = Read9To16(first, len);
+    state = Mix(state, p.first);
+    v = p.second;
+  } else if (len >= 4) {
+    v = Read4To8(first, len);
+  } else if (len > 0) {
+    v = Read1To3(first, len);
+  } else {
+    // Empty ranges have no effect.
+    return state;
+  }
+  return Mix(state, v);
+}
+
+struct AggregateBarrier {};
+
+// HashImpl
+
+// Add a private base class to make sure this type is not an aggregate.
+// Aggregates can be aggregate initialized even if the default constructor is
+// deleted.
+struct PoisonedHash : private AggregateBarrier {
+  PoisonedHash() = delete;
+  PoisonedHash(const PoisonedHash&) = delete;
+  PoisonedHash& operator=(const PoisonedHash&) = delete;
+};
+
+template <typename T>
+struct HashImpl {
+  size_t operator()(const T& value) const {
+    return MixingHashState::hash(value);
+  }
+};
+
+template <typename T>
+struct Hash
+    : absl::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash> {};
+
+template <typename H>
+template <typename T, typename... Ts>
+H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
+  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
+                        std::move(state), value),
+                    values...);
+}
+
+// HashStateBase::combine_contiguous()
+template <typename H>
+template <typename T>
+H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
+  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
+}
+
+// HashStateBase::combine_unordered()
+template <typename H>
+template <typename I>
+H HashStateBase<H>::combine_unordered(H state, I begin, I end) {
+  return H::RunCombineUnordered(std::move(state),
+                                CombineUnorderedCallback<I>{begin, end});
+}
+
+// HashStateBase::PiecewiseCombiner::add_buffer()
+template <typename H>
+H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
+                                size_t size) {
+  if (position_ + size < PiecewiseChunkSize()) {
+    // This partial chunk does not fill our existing buffer
+    memcpy(buf_ + position_, data, size);
+    position_ += size;
+    return state;
+  }
+
+  // If the buffer is partially filled we need to complete the buffer
+  // and hash it.
+  if (position_ != 0) {
+    const size_t bytes_needed = PiecewiseChunkSize() - position_;
+    memcpy(buf_ + position_, data, bytes_needed);
+    state = H::combine_contiguous(std::move(state), buf_, PiecewiseChunkSize());
+    data += bytes_needed;
+    size -= bytes_needed;
+  }
+
+  // Hash whatever chunks we can without copying
+  while (size >= PiecewiseChunkSize()) {
+    state = H::combine_contiguous(std::move(state), data, PiecewiseChunkSize());
+    data += PiecewiseChunkSize();
+    size -= PiecewiseChunkSize();
+  }
+  // Fill the buffer with the remainder
+  memcpy(buf_, data, size);
+  position_ = size;
+  return state;
+}
+
+// HashStateBase::PiecewiseCombiner::finalize()
+template <typename H>
+H PiecewiseCombiner::finalize(H state) {
+  // Hash the remainder left in the buffer, which may be empty
+  return H::combine_contiguous(std::move(state), buf_, position_);
+}
+
+}  // namespace hash_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_HASH_INTERNAL_HASH_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/internal/low_level_hash.h b/CAPI/cpp/grpc/include/absl/hash/internal/low_level_hash.h
new file mode 100644
index 0000000..439968a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/hash/internal/low_level_hash.h
@@ -0,0 +1,50 @@
+// Copyright 2020 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+//
+// This file provides the Google-internal implementation of LowLevelHash.
+//
+// LowLevelHash is a fast hash function for hash tables, the fastest we've
+// currently (late 2020) found that passes the SMHasher tests. The algorithm
+// relies on intrinsic 128-bit multiplication for speed. This is not meant to be
+// secure - just fast.
+//
+// It is closely based on a version of wyhash, but does not maintain or
+// guarantee future compatibility with it.
+
+#ifndef ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
+#define ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace hash_internal {
+
+// Hash function for a byte array. A 64-bit seed and a set of five 64-bit
+// integers are hashed into the result.
+//
+// To allow all hashable types (including string_view and Span) to depend on
+// this algorithm, we keep the API low-level, with as few dependencies as
+// possible.
+uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
+                      const uint64_t salt[5]);
+
+}  // namespace hash_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/internal/spy_hash_state.h b/CAPI/cpp/grpc/include/absl/hash/internal/spy_hash_state.h
new file mode 100644
index 0000000..0972826
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/hash/internal/spy_hash_state.h
@@ -0,0 +1,266 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
+#define ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
+
+#include <algorithm>
+#include <ostream>
+#include <string>
+#include <vector>
+
+#include "absl/hash/hash.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace hash_internal {
+
+// SpyHashState is an implementation of the HashState API that simply
+// accumulates all input bytes in an internal buffer. This makes it useful
+// for testing AbslHashValue overloads (so long as they are templated on the
+// HashState parameter), since it can report the exact hash representation
+// that the AbslHashValue overload produces.
+//
+// Sample usage:
+// EXPECT_EQ(SpyHashState::combine(SpyHashState(), foo),
+//           SpyHashState::combine(SpyHashState(), bar));
+template <typename T>
+class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> {
+ public:
+  SpyHashStateImpl() : error_(std::make_shared<absl::optional<std::string>>()) {
+    static_assert(std::is_void<T>::value, "");
+  }
+
+  // Move-only
+  SpyHashStateImpl(const SpyHashStateImpl&) = delete;
+  SpyHashStateImpl& operator=(const SpyHashStateImpl&) = delete;
+
+  SpyHashStateImpl(SpyHashStateImpl&& other) noexcept {
+    *this = std::move(other);
+  }
+
+  SpyHashStateImpl& operator=(SpyHashStateImpl&& other) noexcept {
+    hash_representation_ = std::move(other.hash_representation_);
+    error_ = other.error_;
+    moved_from_ = other.moved_from_;
+    other.moved_from_ = true;
+    return *this;
+  }
+
+  template <typename U>
+  SpyHashStateImpl(SpyHashStateImpl<U>&& other) {  // NOLINT
+    hash_representation_ = std::move(other.hash_representation_);
+    error_ = other.error_;
+    moved_from_ = other.moved_from_;
+    other.moved_from_ = true;
+  }
+
+  template <typename A, typename... Args>
+  static SpyHashStateImpl combine(SpyHashStateImpl s, const A& a,
+                                  const Args&... args) {
+    // Pass an instance of SpyHashStateImpl<A> when trying to combine `A`. This
+    // allows us to test that the user only uses this instance for combine calls
+    // and does not call AbslHashValue directly.
+    // See AbslHashValue implementation at the bottom.
+    s = SpyHashStateImpl<A>::HashStateBase::combine(std::move(s), a);
+    return SpyHashStateImpl::combine(std::move(s), args...);
+  }
+  static SpyHashStateImpl combine(SpyHashStateImpl s) {
+    if (direct_absl_hash_value_error_) {
+      *s.error_ = "AbslHashValue should not be invoked directly.";
+    } else if (s.moved_from_) {
+      *s.error_ = "Used moved-from instance of the hash state object.";
+    }
+    return s;
+  }
+
+  static void SetDirectAbslHashValueError() {
+    direct_absl_hash_value_error_ = true;
+  }
+
+  // Two SpyHashStateImpl objects are equal if they hold equal hash
+  // representations.
+  friend bool operator==(const SpyHashStateImpl& lhs,
+                         const SpyHashStateImpl& rhs) {
+    return lhs.hash_representation_ == rhs.hash_representation_;
+  }
+
+  friend bool operator!=(const SpyHashStateImpl& lhs,
+                         const SpyHashStateImpl& rhs) {
+    return !(lhs == rhs);
+  }
+
+  enum class CompareResult {
+    kEqual,
+    kASuffixB,
+    kBSuffixA,
+    kUnequal,
+  };
+
+  static CompareResult Compare(const SpyHashStateImpl& a,
+                               const SpyHashStateImpl& b) {
+    const std::string a_flat = absl::StrJoin(a.hash_representation_, "");
+    const std::string b_flat = absl::StrJoin(b.hash_representation_, "");
+    if (a_flat == b_flat) return CompareResult::kEqual;
+    if (absl::EndsWith(a_flat, b_flat)) return CompareResult::kBSuffixA;
+    if (absl::EndsWith(b_flat, a_flat)) return CompareResult::kASuffixB;
+    return CompareResult::kUnequal;
+  }
+
+  // operator<< prints the hash representation as a hex and ASCII dump, to
+  // facilitate debugging.
+  friend std::ostream& operator<<(std::ostream& out,
+                                  const SpyHashStateImpl& hash_state) {
+    out << "[\n";
+    for (auto& s : hash_state.hash_representation_) {
+      size_t offset = 0;
+      for (char c : s) {
+        if (offset % 16 == 0) {
+          out << absl::StreamFormat("\n0x%04x: ", offset);
+        }
+        if (offset % 2 == 0) {
+          out << " ";
+        }
+        out << absl::StreamFormat("%02x", c);
+        ++offset;
+      }
+      out << "\n";
+    }
+    return out << "]";
+  }
+
+  // The base case of the combine recursion, which writes raw bytes into the
+  // internal buffer.
+  static SpyHashStateImpl combine_contiguous(SpyHashStateImpl hash_state,
+                                             const unsigned char* begin,
+                                             size_t size) {
+    const size_t large_chunk_stride = PiecewiseChunkSize();
+    if (size > large_chunk_stride) {
+      // Combining a large contiguous buffer must have the same effect as
+      // doing it piecewise by the stride length, followed by the (possibly
+      // empty) remainder.
+      while (size >= large_chunk_stride) {
+        hash_state = SpyHashStateImpl::combine_contiguous(
+            std::move(hash_state), begin, large_chunk_stride);
+        begin += large_chunk_stride;
+        size -= large_chunk_stride;
+      }
+    }
+
+    hash_state.hash_representation_.emplace_back(
+        reinterpret_cast<const char*>(begin), size);
+    return hash_state;
+  }
+
+  using SpyHashStateImpl::HashStateBase::combine_contiguous;
+
+  template <typename CombinerT>
+  static SpyHashStateImpl RunCombineUnordered(SpyHashStateImpl state,
+                                              CombinerT combiner) {
+    UnorderedCombinerCallback cb;
+
+    combiner(SpyHashStateImpl<void>{}, std::ref(cb));
+
+    std::sort(cb.element_hash_representations.begin(),
+              cb.element_hash_representations.end());
+    state.hash_representation_.insert(state.hash_representation_.end(),
+                                      cb.element_hash_representations.begin(),
+                                      cb.element_hash_representations.end());
+    if (cb.error && cb.error->has_value()) {
+      state.error_ = std::move(cb.error);
+    }
+    return state;
+  }
+
+  absl::optional<std::string> error() const {
+    if (moved_from_) {
+      return "Returned a moved-from instance of the hash state object.";
+    }
+    return *error_;
+  }
+
+ private:
+  template <typename U>
+  friend class SpyHashStateImpl;
+
+  struct UnorderedCombinerCallback {
+    std::vector<std::string> element_hash_representations;
+    std::shared_ptr<absl::optional<std::string>> error;
+
+    // The inner spy can have a different type.
+    template <typename U>
+    void operator()(SpyHashStateImpl<U>& inner) {
+      element_hash_representations.push_back(
+          absl::StrJoin(inner.hash_representation_, ""));
+      if (inner.error_->has_value()) {
+        error = std::move(inner.error_);
+      }
+      inner = SpyHashStateImpl<void>{};
+    }
+  };
+
+  // This is true if SpyHashStateImpl<T> has been passed to a call of
+  // AbslHashValue with the wrong type. This detects that the user called
+  // AbslHashValue directly (because the hash state type does not match).
+  static bool direct_absl_hash_value_error_;
+
+  std::vector<std::string> hash_representation_;
+  // This is a shared_ptr because we want all instances of the particular
+  // SpyHashState run to share the field. This way we can set the error for
+  // use-after-move and all the copies will see it.
+  std::shared_ptr<absl::optional<std::string>> error_;
+  bool moved_from_ = false;
+};
+
+template <typename T>
+bool SpyHashStateImpl<T>::direct_absl_hash_value_error_;
+
+template <bool& B>
+struct OdrUse {
+  constexpr OdrUse() {}
+  bool& b = B;
+};
+
+template <void (*)()>
+struct RunOnStartup {
+  static bool run;
+  static constexpr OdrUse<run> kOdrUse{};
+};
+
+template <void (*f)()>
+bool RunOnStartup<f>::run = (f(), true);
+
+template <
+    typename T, typename U,
+    // Only trigger for when (T != U),
+    typename = absl::enable_if_t<!std::is_same<T, U>::value>,
+    // This statement works in two ways:
+    //  - First, it instantiates RunOnStartup and forces the initialization of
+    //    `run`, which set the global variable.
+    //  - Second, it triggers a SFINAE error disabling the overload to prevent
+    //    compile time errors. If we didn't disable the overload we would get
+    //    ambiguous overload errors, which we don't want.
+    int = RunOnStartup<SpyHashStateImpl<T>::SetDirectAbslHashValueError>::run>
+void AbslHashValue(SpyHashStateImpl<T>, const U&);
+
+using SpyHashState = SpyHashStateImpl<void>;
+
+}  // namespace hash_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
diff --git a/CAPI/cpp/grpc/include/absl/memory/memory.h b/CAPI/cpp/grpc/include/absl/memory/memory.h
new file mode 100644
index 0000000..d633260
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/memory/memory.h
@@ -0,0 +1,699 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: memory.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains utility functions for managing the creation and
+// conversion of smart pointers. This file is an extension to the C++
+// standard <memory> library header file.
+
+#ifndef ABSL_MEMORY_MEMORY_H_
+#define ABSL_MEMORY_MEMORY_H_
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// Function Template: WrapUnique()
+// -----------------------------------------------------------------------------
+//
+// Adopts ownership from a raw pointer and transfers it to the returned
+// `std::unique_ptr`, whose type is deduced. Because of this deduction, *do not*
+// specify the template type `T` when calling `WrapUnique`.
+//
+// Example:
+//   X* NewX(int, int);
+//   auto x = WrapUnique(NewX(1, 2));  // 'x' is std::unique_ptr<X>.
+//
+// Do not call WrapUnique with an explicit type, as in
+// `WrapUnique<X>(NewX(1, 2))`.  The purpose of WrapUnique is to automatically
+// deduce the pointer type. If you wish to make the type explicit, just use
+// `std::unique_ptr` directly.
+//
+//   auto x = std::unique_ptr<X>(NewX(1, 2));
+//                  - or -
+//   std::unique_ptr<X> x(NewX(1, 2));
+//
+// While `absl::WrapUnique` is useful for capturing the output of a raw
+// pointer factory, prefer 'absl::make_unique<T>(args...)' over
+// 'absl::WrapUnique(new T(args...))'.
+//
+//   auto x = WrapUnique(new X(1, 2));  // works, but nonideal.
+//   auto x = make_unique<X>(1, 2);     // safer, standard, avoids raw 'new'.
+//
+// Note that `absl::WrapUnique(p)` is valid only if `delete p` is a valid
+// expression. In particular, `absl::WrapUnique()` cannot wrap pointers to
+// arrays, functions or void, and it must not be used to capture pointers
+// obtained from array-new expressions (even though that would compile!).
+template <typename T>
+std::unique_ptr<T> WrapUnique(T* ptr) {
+  static_assert(!std::is_array<T>::value, "array types are unsupported");
+  static_assert(std::is_object<T>::value, "non-object types are unsupported");
+  return std::unique_ptr<T>(ptr);
+}
+
+namespace memory_internal {
+
+// Traits to select proper overload and return type for `absl::make_unique<>`.
+template <typename T>
+struct MakeUniqueResult {
+  using scalar = std::unique_ptr<T>;
+};
+template <typename T>
+struct MakeUniqueResult<T[]> {
+  using array = std::unique_ptr<T[]>;
+};
+template <typename T, size_t N>
+struct MakeUniqueResult<T[N]> {
+  using invalid = void;
+};
+
+}  // namespace memory_internal
+
+// gcc 4.8 has __cplusplus at 201301 but the libstdc++ shipped with it doesn't
+// define make_unique.  Other supported compilers either just define __cplusplus
+// as 201103 but have make_unique (msvc), or have make_unique whenever
+// __cplusplus > 201103 (clang).
+#if (__cplusplus > 201103L || defined(_MSC_VER)) && \
+    !(defined(__GLIBCXX__) && !defined(__cpp_lib_make_unique))
+using std::make_unique;
+#else
+// -----------------------------------------------------------------------------
+// Function Template: make_unique<T>()
+// -----------------------------------------------------------------------------
+//
+// Creates a `std::unique_ptr<>`, while avoiding issues creating temporaries
+// during the construction process. `absl::make_unique<>` also avoids redundant
+// type declarations, by avoiding the need to explicitly use the `new` operator.
+//
+// This implementation of `absl::make_unique<>` is designed for C++11 code and
+// will be replaced in C++14 by the equivalent `std::make_unique<>` abstraction.
+// `absl::make_unique<>` is designed to be 100% compatible with
+// `std::make_unique<>` so that the eventual migration will involve a simple
+// rename operation.
+//
+// For more background on why `std::unique_ptr<T>(new T(a,b))` is problematic,
+// see Herb Sutter's explanation on
+// (Exception-Safe Function Calls)[https://herbsutter.com/gotw/_102/].
+// (In general, reviewers should treat `new T(a,b)` with scrutiny.)
+//
+// Example usage:
+//
+//    auto p = make_unique<X>(args...);  // 'p'  is a std::unique_ptr<X>
+//    auto pa = make_unique<X[]>(5);     // 'pa' is a std::unique_ptr<X[]>
+//
+// Three overloads of `absl::make_unique` are required:
+//
+//   - For non-array T:
+//
+//       Allocates a T with `new T(std::forward<Args> args...)`,
+//       forwarding all `args` to T's constructor.
+//       Returns a `std::unique_ptr<T>` owning that object.
+//
+//   - For an array of unknown bounds T[]:
+//
+//       `absl::make_unique<>` will allocate an array T of type U[] with
+//       `new U[n]()` and return a `std::unique_ptr<U[]>` owning that array.
+//
+//       Note that 'U[n]()' is different from 'U[n]', and elements will be
+//       value-initialized. Note as well that `std::unique_ptr` will perform its
+//       own destruction of the array elements upon leaving scope, even though
+//       the array [] does not have a default destructor.
+//
+//       NOTE: an array of unknown bounds T[] may still be (and often will be)
+//       initialized to have a size, and will still use this overload. E.g:
+//
+//         auto my_array = absl::make_unique<int[]>(10);
+//
+//   - For an array of known bounds T[N]:
+//
+//       `absl::make_unique<>` is deleted (like with `std::make_unique<>`) as
+//       this overload is not useful.
+//
+//       NOTE: an array of known bounds T[N] is not considered a useful
+//       construction, and may cause undefined behavior in templates. E.g:
+//
+//         auto my_array = absl::make_unique<int[10]>();
+//
+//       In those cases, of course, you can still use the overload above and
+//       simply initialize it to its desired size:
+//
+//         auto my_array = absl::make_unique<int[]>(10);
+
+// `absl::make_unique` overload for non-array types.
+template <typename T, typename... Args>
+typename memory_internal::MakeUniqueResult<T>::scalar make_unique(
+    Args&&... args) {
+  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
+// `absl::make_unique` overload for an array T[] of unknown bounds.
+// The array allocation needs to use the `new T[size]` form and cannot take
+// element constructor arguments. The `std::unique_ptr` will manage destructing
+// these array elements.
+template <typename T>
+typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n) {
+  return std::unique_ptr<T>(new typename absl::remove_extent_t<T>[n]());
+}
+
+// `absl::make_unique` overload for an array T[N] of known bounds.
+// This construction will be rejected.
+template <typename T, typename... Args>
+typename memory_internal::MakeUniqueResult<T>::invalid make_unique(
+    Args&&... /* args */) = delete;
+#endif
+
+// -----------------------------------------------------------------------------
+// Function Template: RawPtr()
+// -----------------------------------------------------------------------------
+//
+// Extracts the raw pointer from a pointer-like value `ptr`. `absl::RawPtr` is
+// useful within templates that need to handle a complement of raw pointers,
+// `std::nullptr_t`, and smart pointers.
+template <typename T>
+auto RawPtr(T&& ptr) -> decltype(std::addressof(*ptr)) {
+  // ptr is a forwarding reference to support Ts with non-const operators.
+  return (ptr != nullptr) ? std::addressof(*ptr) : nullptr;
+}
+inline std::nullptr_t RawPtr(std::nullptr_t) { return nullptr; }
+
+// -----------------------------------------------------------------------------
+// Function Template: ShareUniquePtr()
+// -----------------------------------------------------------------------------
+//
+// Adopts a `std::unique_ptr` rvalue and returns a `std::shared_ptr` of deduced
+// type. Ownership (if any) of the held value is transferred to the returned
+// shared pointer.
+//
+// Example:
+//
+//     auto up = absl::make_unique<int>(10);
+//     auto sp = absl::ShareUniquePtr(std::move(up));  // shared_ptr<int>
+//     CHECK_EQ(*sp, 10);
+//     CHECK(up == nullptr);
+//
+// Note that this conversion is correct even when T is an array type, and more
+// generally it works for *any* deleter of the `unique_ptr` (single-object
+// deleter, array deleter, or any custom deleter), since the deleter is adopted
+// by the shared pointer as well. The deleter is copied (unless it is a
+// reference).
+//
+// Implements the resolution of [LWG 2415](http://wg21.link/lwg2415), by which a
+// null shared pointer does not attempt to call the deleter.
+template <typename T, typename D>
+std::shared_ptr<T> ShareUniquePtr(std::unique_ptr<T, D>&& ptr) {
+  return ptr ? std::shared_ptr<T>(std::move(ptr)) : std::shared_ptr<T>();
+}
+
+// -----------------------------------------------------------------------------
+// Function Template: WeakenPtr()
+// -----------------------------------------------------------------------------
+//
+// Creates a weak pointer associated with a given shared pointer. The returned
+// value is a `std::weak_ptr` of deduced type.
+//
+// Example:
+//
+//    auto sp = std::make_shared<int>(10);
+//    auto wp = absl::WeakenPtr(sp);
+//    CHECK_EQ(sp.get(), wp.lock().get());
+//    sp.reset();
+//    CHECK(wp.lock() == nullptr);
+//
+template <typename T>
+std::weak_ptr<T> WeakenPtr(const std::shared_ptr<T>& ptr) {
+  return std::weak_ptr<T>(ptr);
+}
+
+namespace memory_internal {
+
+// ExtractOr<E, O, D>::type evaluates to E<O> if possible. Otherwise, D.
+template <template <typename> class Extract, typename Obj, typename Default,
+          typename>
+struct ExtractOr {
+  using type = Default;
+};
+
+template <template <typename> class Extract, typename Obj, typename Default>
+struct ExtractOr<Extract, Obj, Default, void_t<Extract<Obj>>> {
+  using type = Extract<Obj>;
+};
+
+template <template <typename> class Extract, typename Obj, typename Default>
+using ExtractOrT = typename ExtractOr<Extract, Obj, Default, void>::type;
+
+// Extractors for the features of allocators.
+template <typename T>
+using GetPointer = typename T::pointer;
+
+template <typename T>
+using GetConstPointer = typename T::const_pointer;
+
+template <typename T>
+using GetVoidPointer = typename T::void_pointer;
+
+template <typename T>
+using GetConstVoidPointer = typename T::const_void_pointer;
+
+template <typename T>
+using GetDifferenceType = typename T::difference_type;
+
+template <typename T>
+using GetSizeType = typename T::size_type;
+
+template <typename T>
+using GetPropagateOnContainerCopyAssignment =
+    typename T::propagate_on_container_copy_assignment;
+
+template <typename T>
+using GetPropagateOnContainerMoveAssignment =
+    typename T::propagate_on_container_move_assignment;
+
+template <typename T>
+using GetPropagateOnContainerSwap = typename T::propagate_on_container_swap;
+
+template <typename T>
+using GetIsAlwaysEqual = typename T::is_always_equal;
+
+template <typename T>
+struct GetFirstArg;
+
+template <template <typename...> class Class, typename T, typename... Args>
+struct GetFirstArg<Class<T, Args...>> {
+  using type = T;
+};
+
+template <typename Ptr, typename = void>
+struct ElementType {
+  using type = typename GetFirstArg<Ptr>::type;
+};
+
+template <typename T>
+struct ElementType<T, void_t<typename T::element_type>> {
+  using type = typename T::element_type;
+};
+
+template <typename T, typename U>
+struct RebindFirstArg;
+
+template <template <typename...> class Class, typename T, typename... Args,
+          typename U>
+struct RebindFirstArg<Class<T, Args...>, U> {
+  using type = Class<U, Args...>;
+};
+
+template <typename T, typename U, typename = void>
+struct RebindPtr {
+  using type = typename RebindFirstArg<T, U>::type;
+};
+
+template <typename T, typename U>
+struct RebindPtr<T, U, void_t<typename T::template rebind<U>>> {
+  using type = typename T::template rebind<U>;
+};
+
+template <typename T, typename U>
+constexpr bool HasRebindAlloc(...) {
+  return false;
+}
+
+template <typename T, typename U>
+constexpr bool HasRebindAlloc(typename T::template rebind<U>::other*) {
+  return true;
+}
+
+template <typename T, typename U, bool = HasRebindAlloc<T, U>(nullptr)>
+struct RebindAlloc {
+  using type = typename RebindFirstArg<T, U>::type;
+};
+
+template <typename T, typename U>
+struct RebindAlloc<T, U, true> {
+  using type = typename T::template rebind<U>::other;
+};
+
+}  // namespace memory_internal
+
+// -----------------------------------------------------------------------------
+// Class Template: pointer_traits
+// -----------------------------------------------------------------------------
+//
+// An implementation of C++11's std::pointer_traits.
+//
+// Provided for portability on toolchains that have a working C++11 compiler,
+// but the standard library is lacking in C++11 support. For example, some
+// version of the Android NDK.
+//
+
+template <typename Ptr>
+struct pointer_traits {
+  using pointer = Ptr;
+
+  // element_type:
+  // Ptr::element_type if present. Otherwise T if Ptr is a template
+  // instantiation Template<T, Args...>
+  using element_type = typename memory_internal::ElementType<Ptr>::type;
+
+  // difference_type:
+  // Ptr::difference_type if present, otherwise std::ptrdiff_t
+  using difference_type =
+      memory_internal::ExtractOrT<memory_internal::GetDifferenceType, Ptr,
+                                  std::ptrdiff_t>;
+
+  // rebind:
+  // Ptr::rebind<U> if exists, otherwise Template<U, Args...> if Ptr is a
+  // template instantiation Template<T, Args...>
+  template <typename U>
+  using rebind = typename memory_internal::RebindPtr<Ptr, U>::type;
+
+  // pointer_to:
+  // Calls Ptr::pointer_to(r)
+  static pointer pointer_to(element_type& r) {  // NOLINT(runtime/references)
+    return Ptr::pointer_to(r);
+  }
+};
+
+// Specialization for T*.
+template <typename T>
+struct pointer_traits<T*> {
+  using pointer = T*;
+  using element_type = T;
+  using difference_type = std::ptrdiff_t;
+
+  template <typename U>
+  using rebind = U*;
+
+  // pointer_to:
+  // Calls std::addressof(r)
+  static pointer pointer_to(
+      element_type& r) noexcept {  // NOLINT(runtime/references)
+    return std::addressof(r);
+  }
+};
+
+// -----------------------------------------------------------------------------
+// Class Template: allocator_traits
+// -----------------------------------------------------------------------------
+//
+// A C++11 compatible implementation of C++17's std::allocator_traits.
+//
+#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+using std::allocator_traits;
+#else  // __cplusplus >= 201703L
+template <typename Alloc>
+struct allocator_traits {
+  using allocator_type = Alloc;
+
+  // value_type:
+  // Alloc::value_type
+  using value_type = typename Alloc::value_type;
+
+  // pointer:
+  // Alloc::pointer if present, otherwise value_type*
+  using pointer = memory_internal::ExtractOrT<memory_internal::GetPointer,
+                                              Alloc, value_type*>;
+
+  // const_pointer:
+  // Alloc::const_pointer if present, otherwise
+  // absl::pointer_traits<pointer>::rebind<const value_type>
+  using const_pointer =
+      memory_internal::ExtractOrT<memory_internal::GetConstPointer, Alloc,
+                                  typename absl::pointer_traits<pointer>::
+                                      template rebind<const value_type>>;
+
+  // void_pointer:
+  // Alloc::void_pointer if present, otherwise
+  // absl::pointer_traits<pointer>::rebind<void>
+  using void_pointer = memory_internal::ExtractOrT<
+      memory_internal::GetVoidPointer, Alloc,
+      typename absl::pointer_traits<pointer>::template rebind<void>>;
+
+  // const_void_pointer:
+  // Alloc::const_void_pointer if present, otherwise
+  // absl::pointer_traits<pointer>::rebind<const void>
+  using const_void_pointer = memory_internal::ExtractOrT<
+      memory_internal::GetConstVoidPointer, Alloc,
+      typename absl::pointer_traits<pointer>::template rebind<const void>>;
+
+  // difference_type:
+  // Alloc::difference_type if present, otherwise
+  // absl::pointer_traits<pointer>::difference_type
+  using difference_type = memory_internal::ExtractOrT<
+      memory_internal::GetDifferenceType, Alloc,
+      typename absl::pointer_traits<pointer>::difference_type>;
+
+  // size_type:
+  // Alloc::size_type if present, otherwise
+  // std::make_unsigned<difference_type>::type
+  using size_type = memory_internal::ExtractOrT<
+      memory_internal::GetSizeType, Alloc,
+      typename std::make_unsigned<difference_type>::type>;
+
+  // propagate_on_container_copy_assignment:
+  // Alloc::propagate_on_container_copy_assignment if present, otherwise
+  // std::false_type
+  using propagate_on_container_copy_assignment = memory_internal::ExtractOrT<
+      memory_internal::GetPropagateOnContainerCopyAssignment, Alloc,
+      std::false_type>;
+
+  // propagate_on_container_move_assignment:
+  // Alloc::propagate_on_container_move_assignment if present, otherwise
+  // std::false_type
+  using propagate_on_container_move_assignment = memory_internal::ExtractOrT<
+      memory_internal::GetPropagateOnContainerMoveAssignment, Alloc,
+      std::false_type>;
+
+  // propagate_on_container_swap:
+  // Alloc::propagate_on_container_swap if present, otherwise std::false_type
+  using propagate_on_container_swap =
+      memory_internal::ExtractOrT<memory_internal::GetPropagateOnContainerSwap,
+                                  Alloc, std::false_type>;
+
+  // is_always_equal:
+  // Alloc::is_always_equal if present, otherwise std::is_empty<Alloc>::type
+  using is_always_equal =
+      memory_internal::ExtractOrT<memory_internal::GetIsAlwaysEqual, Alloc,
+                                  typename std::is_empty<Alloc>::type>;
+
+  // rebind_alloc:
+  // Alloc::rebind<T>::other if present, otherwise Alloc<T, Args> if this Alloc
+  // is Alloc<U, Args>
+  template <typename T>
+  using rebind_alloc = typename memory_internal::RebindAlloc<Alloc, T>::type;
+
+  // rebind_traits:
+  // absl::allocator_traits<rebind_alloc<T>>
+  template <typename T>
+  using rebind_traits = absl::allocator_traits<rebind_alloc<T>>;
+
+  // allocate(Alloc& a, size_type n):
+  // Calls a.allocate(n)
+  static pointer allocate(Alloc& a,  // NOLINT(runtime/references)
+                          size_type n) {
+    return a.allocate(n);
+  }
+
+  // allocate(Alloc& a, size_type n, const_void_pointer hint):
+  // Calls a.allocate(n, hint) if possible.
+  // If not possible, calls a.allocate(n)
+  static pointer allocate(Alloc& a, size_type n,  // NOLINT(runtime/references)
+                          const_void_pointer hint) {
+    return allocate_impl(0, a, n, hint);
+  }
+
+  // deallocate(Alloc& a, pointer p, size_type n):
+  // Calls a.deallocate(p, n)
+  static void deallocate(Alloc& a, pointer p,  // NOLINT(runtime/references)
+                         size_type n) {
+    a.deallocate(p, n);
+  }
+
+  // construct(Alloc& a, T* p, Args&&... args):
+  // Calls a.construct(p, std::forward<Args>(args)...) if possible.
+  // If not possible, calls
+  //   ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)
+  template <typename T, typename... Args>
+  static void construct(Alloc& a, T* p,  // NOLINT(runtime/references)
+                        Args&&... args) {
+    construct_impl(0, a, p, std::forward<Args>(args)...);
+  }
+
+  // destroy(Alloc& a, T* p):
+  // Calls a.destroy(p) if possible. If not possible, calls p->~T().
+  template <typename T>
+  static void destroy(Alloc& a, T* p) {  // NOLINT(runtime/references)
+    destroy_impl(0, a, p);
+  }
+
+  // max_size(const Alloc& a):
+  // Returns a.max_size() if possible. If not possible, returns
+  //   std::numeric_limits<size_type>::max() / sizeof(value_type)
+  static size_type max_size(const Alloc& a) { return max_size_impl(0, a); }
+
+  // select_on_container_copy_construction(const Alloc& a):
+  // Returns a.select_on_container_copy_construction() if possible.
+  // If not possible, returns a.
+  static Alloc select_on_container_copy_construction(const Alloc& a) {
+    return select_on_container_copy_construction_impl(0, a);
+  }
+
+ private:
+  template <typename A>
+  static auto allocate_impl(int, A& a,  // NOLINT(runtime/references)
+                            size_type n, const_void_pointer hint)
+      -> decltype(a.allocate(n, hint)) {
+    return a.allocate(n, hint);
+  }
+  static pointer allocate_impl(char, Alloc& a,  // NOLINT(runtime/references)
+                               size_type n, const_void_pointer) {
+    return a.allocate(n);
+  }
+
+  template <typename A, typename... Args>
+  static auto construct_impl(int, A& a,  // NOLINT(runtime/references)
+                             Args&&... args)
+      -> decltype(a.construct(std::forward<Args>(args)...)) {
+    a.construct(std::forward<Args>(args)...);
+  }
+
+  template <typename T, typename... Args>
+  static void construct_impl(char, Alloc&, T* p, Args&&... args) {
+    ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+  }
+
+  template <typename A, typename T>
+  static auto destroy_impl(int, A& a,  // NOLINT(runtime/references)
+                           T* p) -> decltype(a.destroy(p)) {
+    a.destroy(p);
+  }
+  template <typename T>
+  static void destroy_impl(char, Alloc&, T* p) {
+    p->~T();
+  }
+
+  template <typename A>
+  static auto max_size_impl(int, const A& a) -> decltype(a.max_size()) {
+    return a.max_size();
+  }
+  static size_type max_size_impl(char, const Alloc&) {
+    return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
+  }
+
+  template <typename A>
+  static auto select_on_container_copy_construction_impl(int, const A& a)
+      -> decltype(a.select_on_container_copy_construction()) {
+    return a.select_on_container_copy_construction();
+  }
+  static Alloc select_on_container_copy_construction_impl(char,
+                                                          const Alloc& a) {
+    return a;
+  }
+};
+#endif  // __cplusplus >= 201703L
+
+namespace memory_internal {
+
+// This template alias transforms Alloc::is_nothrow into a metafunction with
+// Alloc as a parameter so it can be used with ExtractOrT<>.
+template <typename Alloc>
+using GetIsNothrow = typename Alloc::is_nothrow;
+
+}  // namespace memory_internal
+
+// ABSL_ALLOCATOR_NOTHROW is a build time configuration macro for user to
+// specify whether the default allocation function can throw or never throws.
+// If the allocation function never throws, user should define it to a non-zero
+// value (e.g. via `-DABSL_ALLOCATOR_NOTHROW`).
+// If the allocation function can throw, user should leave it undefined or
+// define it to zero.
+//
+// allocator_is_nothrow<Alloc> is a traits class that derives from
+// Alloc::is_nothrow if present, otherwise std::false_type. It's specialized
+// for Alloc = std::allocator<T> for any type T according to the state of
+// ABSL_ALLOCATOR_NOTHROW.
+//
+// default_allocator_is_nothrow is a class that derives from std::true_type
+// when the default allocator (global operator new) never throws, and
+// std::false_type when it can throw. It is a convenience shorthand for writing
+// allocator_is_nothrow<std::allocator<T>> (T can be any type).
+// NOTE: allocator_is_nothrow<std::allocator<T>> is guaranteed to derive from
+// the same type for all T, because users should specialize neither
+// allocator_is_nothrow nor std::allocator.
+template <typename Alloc>
+struct allocator_is_nothrow
+    : memory_internal::ExtractOrT<memory_internal::GetIsNothrow, Alloc,
+                                  std::false_type> {};
+
+#if defined(ABSL_ALLOCATOR_NOTHROW) && ABSL_ALLOCATOR_NOTHROW
+template <typename T>
+struct allocator_is_nothrow<std::allocator<T>> : std::true_type {};
+struct default_allocator_is_nothrow : std::true_type {};
+#else
+struct default_allocator_is_nothrow : std::false_type {};
+#endif
+
+namespace memory_internal {
+template <typename Allocator, typename Iterator, typename... Args>
+void ConstructRange(Allocator& alloc, Iterator first, Iterator last,
+                    const Args&... args) {
+  for (Iterator cur = first; cur != last; ++cur) {
+    ABSL_INTERNAL_TRY {
+      std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
+                                                  args...);
+    }
+    ABSL_INTERNAL_CATCH_ANY {
+      while (cur != first) {
+        --cur;
+        std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
+      }
+      ABSL_INTERNAL_RETHROW;
+    }
+  }
+}
+
+template <typename Allocator, typename Iterator, typename InputIterator>
+void CopyRange(Allocator& alloc, Iterator destination, InputIterator first,
+               InputIterator last) {
+  for (Iterator cur = destination; first != last;
+       static_cast<void>(++cur), static_cast<void>(++first)) {
+    ABSL_INTERNAL_TRY {
+      std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
+                                                  *first);
+    }
+    ABSL_INTERNAL_CATCH_ANY {
+      while (cur != destination) {
+        --cur;
+        std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
+      }
+      ABSL_INTERNAL_RETHROW;
+    }
+  }
+}
+}  // namespace memory_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_MEMORY_MEMORY_H_
diff --git a/CAPI/cpp/grpc/include/absl/meta/type_traits.h b/CAPI/cpp/grpc/include/absl/meta/type_traits.h
new file mode 100644
index 0000000..d886cb3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/meta/type_traits.h
@@ -0,0 +1,797 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// type_traits.h
+// -----------------------------------------------------------------------------
+//
+// This file contains C++11-compatible versions of standard <type_traits> API
+// functions for determining the characteristics of types. Such traits can
+// support type inference, classification, and transformation, as well as
+// make it easier to write templates based on generic type behavior.
+//
+// See https://en.cppreference.com/w/cpp/header/type_traits
+//
+// WARNING: use of many of the constructs in this header will count as "complex
+// template metaprogramming", so before proceeding, please carefully consider
+// https://google.github.io/styleguide/cppguide.html#Template_metaprogramming
+//
+// WARNING: using template metaprogramming to detect or depend on API
+// features is brittle and not guaranteed. Neither the standard library nor
+// Abseil provides any guarantee that APIs are stable in the face of template
+// metaprogramming. Use with caution.
+#ifndef ABSL_META_TYPE_TRAITS_H_
+#define ABSL_META_TYPE_TRAITS_H_
+
+#include <cstddef>
+#include <functional>
+#include <type_traits>
+
+#include "absl/base/config.h"
+
+// MSVC constructibility traits do not detect destructor properties and so our
+// implementations should not use them as a source-of-truth.
+#if defined(_MSC_VER) && !defined(__clang__) && !defined(__GNUC__)
+#define ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION 1
+#endif
+
+// Defines the default alignment. `__STDCPP_DEFAULT_NEW_ALIGNMENT__` is a C++17
+// feature.
+#if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
+#define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT __STDCPP_DEFAULT_NEW_ALIGNMENT__
+#else  // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
+#define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT alignof(std::max_align_t)
+#endif  // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Defined and documented later on in this file.
+template <typename T>
+struct is_trivially_destructible;
+
+// Defined and documented later on in this file.
+template <typename T>
+struct is_trivially_move_assignable;
+
+namespace type_traits_internal {
+
+// Silence MSVC warnings about the destructor being defined as deleted.
+#if defined(_MSC_VER) && !defined(__GNUC__)
+#pragma warning(push)
+#pragma warning(disable : 4624)
+#endif  // defined(_MSC_VER) && !defined(__GNUC__)
+
+template <class T>
+union SingleMemberUnion {
+  T t;
+};
+
+// Restore the state of the destructor warning that was silenced above.
+#if defined(_MSC_VER) && !defined(__GNUC__)
+#pragma warning(pop)
+#endif  // defined(_MSC_VER) && !defined(__GNUC__)
+
+template <class T>
+struct IsTriviallyMoveConstructibleObject
+    : std::integral_constant<
+          bool, std::is_move_constructible<
+                    type_traits_internal::SingleMemberUnion<T>>::value &&
+                    absl::is_trivially_destructible<T>::value> {};
+
+template <class T>
+struct IsTriviallyCopyConstructibleObject
+    : std::integral_constant<
+          bool, std::is_copy_constructible<
+                    type_traits_internal::SingleMemberUnion<T>>::value &&
+                    absl::is_trivially_destructible<T>::value> {};
+
+template <class T>
+struct IsTriviallyMoveAssignableReference : std::false_type {};
+
+template <class T>
+struct IsTriviallyMoveAssignableReference<T&>
+    : absl::is_trivially_move_assignable<T>::type {};
+
+template <class T>
+struct IsTriviallyMoveAssignableReference<T&&>
+    : absl::is_trivially_move_assignable<T>::type {};
+
+template <typename... Ts>
+struct VoidTImpl {
+  using type = void;
+};
+
+// This trick to retrieve a default alignment is necessary for our
+// implementation of aligned_storage_t to be consistent with any implementation
+// of std::aligned_storage.
+template <size_t Len, typename T = std::aligned_storage<Len>>
+struct default_alignment_of_aligned_storage;
+
+template <size_t Len, size_t Align>
+struct default_alignment_of_aligned_storage<Len,
+                                            std::aligned_storage<Len, Align>> {
+  static constexpr size_t value = Align;
+};
+
+////////////////////////////////
+// Library Fundamentals V2 TS //
+////////////////////////////////
+
+// NOTE: The `is_detected` family of templates here differ from the library
+// fundamentals specification in that for library fundamentals, `Op<Args...>` is
+// evaluated as soon as the type `is_detected<Op, Args...>` undergoes
+// substitution, regardless of whether or not the `::value` is accessed. That
+// is inconsistent with all other standard traits and prevents lazy evaluation
+// in larger contexts (such as if the `is_detected` check is a trailing argument
+// of a `conjunction`. This implementation opts to instead be lazy in the same
+// way that the standard traits are (this "defect" of the detection idiom
+// specifications has been reported).
+
+template <class Enabler, template <class...> class Op, class... Args>
+struct is_detected_impl {
+  using type = std::false_type;
+};
+
+template <template <class...> class Op, class... Args>
+struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...> {
+  using type = std::true_type;
+};
+
+template <template <class...> class Op, class... Args>
+struct is_detected : is_detected_impl<void, Op, Args...>::type {};
+
+template <class Enabler, class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl {
+  using type = std::false_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl<
+    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
+    To, Op, Args...> {
+  using type = std::true_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible
+    : is_detected_convertible_impl<void, To, Op, Args...>::type {};
+
+template <typename T>
+using IsCopyAssignableImpl =
+    decltype(std::declval<T&>() = std::declval<const T&>());
+
+template <typename T>
+using IsMoveAssignableImpl = decltype(std::declval<T&>() = std::declval<T&&>());
+
+}  // namespace type_traits_internal
+
+// MSVC 19.20 has a regression that causes our workarounds to fail, but their
+// std forms now appear to be compliant.
+#if defined(_MSC_VER) && !defined(__clang__) && (_MSC_VER >= 1920)
+
+template <typename T>
+using is_copy_assignable = std::is_copy_assignable<T>;
+
+template <typename T>
+using is_move_assignable = std::is_move_assignable<T>;
+
+#else
+
+template <typename T>
+struct is_copy_assignable : type_traits_internal::is_detected<
+                                type_traits_internal::IsCopyAssignableImpl, T> {
+};
+
+template <typename T>
+struct is_move_assignable : type_traits_internal::is_detected<
+                                type_traits_internal::IsMoveAssignableImpl, T> {
+};
+
+#endif
+
+// void_t()
+//
+// Ignores the type of any its arguments and returns `void`. In general, this
+// metafunction allows you to create a general case that maps to `void` while
+// allowing specializations that map to specific types.
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::void_t` metafunction.
+//
+// NOTE: `absl::void_t` does not use the standard-specified implementation so
+// that it can remain compatible with gcc < 5.1. This can introduce slightly
+// different behavior, such as when ordering partial specializations.
+template <typename... Ts>
+using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
+
+// conjunction
+//
+// Performs a compile-time logical AND operation on the passed types (which
+// must have  `::value` members convertible to `bool`. Short-circuits if it
+// encounters any `false` members (and does not compare the `::value` members
+// of any remaining arguments).
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::conjunction` metafunction.
+template <typename... Ts>
+struct conjunction : std::true_type {};
+
+template <typename T, typename... Ts>
+struct conjunction<T, Ts...>
+    : std::conditional<T::value, conjunction<Ts...>, T>::type {};
+
+template <typename T>
+struct conjunction<T> : T {};
+
+// disjunction
+//
+// Performs a compile-time logical OR operation on the passed types (which
+// must have  `::value` members convertible to `bool`. Short-circuits if it
+// encounters any `true` members (and does not compare the `::value` members
+// of any remaining arguments).
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::disjunction` metafunction.
+template <typename... Ts>
+struct disjunction : std::false_type {};
+
+template <typename T, typename... Ts>
+struct disjunction<T, Ts...> :
+      std::conditional<T::value, T, disjunction<Ts...>>::type {};
+
+template <typename T>
+struct disjunction<T> : T {};
+
+// negation
+//
+// Performs a compile-time logical NOT operation on the passed type (which
+// must have  `::value` members convertible to `bool`.
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::negation` metafunction.
+template <typename T>
+struct negation : std::integral_constant<bool, !T::value> {};
+
+// is_function()
+//
+// Determines whether the passed type `T` is a function type.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_function()` metafunction for platforms that have incomplete C++11
+// support (such as libstdc++ 4.x).
+//
+// This metafunction works because appending `const` to a type does nothing to
+// function types and reference types (and forms a const-qualified type
+// otherwise).
+template <typename T>
+struct is_function
+    : std::integral_constant<
+          bool, !(std::is_reference<T>::value ||
+                  std::is_const<typename std::add_const<T>::type>::value)> {};
+
+// is_trivially_destructible()
+//
+// Determines whether the passed type `T` is trivially destructible.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_destructible()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
+//
+// NOTE: the extensions (__has_trivial_xxx) are implemented in gcc (version >=
+// 4.3) and clang. Since we are supporting libstdc++ > 4.7, they should always
+// be present. These  extensions are documented at
+// https://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html#Type-Traits.
+template <typename T>
+struct is_trivially_destructible
+    : std::integral_constant<bool, __has_trivial_destructor(T) &&
+                                   std::is_destructible<T>::value> {
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+ private:
+  static constexpr bool compliant = std::is_trivially_destructible<T>::value ==
+                                    is_trivially_destructible::value;
+  static_assert(compliant || std::is_trivially_destructible<T>::value,
+                "Not compliant with std::is_trivially_destructible; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_destructible<T>::value,
+                "Not compliant with std::is_trivially_destructible; "
+                "Standard: true, Implementation: false");
+#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+};
+
+// is_trivially_default_constructible()
+//
+// Determines whether the passed type `T` is trivially default constructible.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_default_constructible()` metafunction for platforms that
+// have incomplete C++11 support (such as libstdc++ 4.x). On any platforms that
+// do fully support C++11, we check whether this yields the same result as the
+// std implementation.
+//
+// NOTE: according to the C++ standard, Section: 20.15.4.3 [meta.unary.prop]
+// "The predicate condition for a template specialization is_constructible<T,
+// Args...> shall be satisfied if and only if the following variable
+// definition would be well-formed for some invented variable t:
+//
+// T t(declval<Args>()...);
+//
+// is_trivially_constructible<T, Args...> additionally requires that the
+// variable definition does not call any operation that is not trivial.
+// For the purposes of this check, the call to std::declval is considered
+// trivial."
+//
+// Notes from https://en.cppreference.com/w/cpp/types/is_constructible:
+// In many implementations, is_nothrow_constructible also checks if the
+// destructor throws because it is effectively noexcept(T(arg)). Same
+// applies to is_trivially_constructible, which, in these implementations, also
+// requires that the destructor is trivial.
+// GCC bug 51452: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452
+// LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116.
+//
+// "T obj();" need to be well-formed and not call any nontrivial operation.
+// Nontrivially destructible types will cause the expression to be nontrivial.
+template <typename T>
+struct is_trivially_default_constructible
+    : std::integral_constant<bool, __has_trivial_constructor(T) &&
+                                   std::is_default_constructible<T>::value &&
+                                   is_trivially_destructible<T>::value> {
+#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
+    !defined(                                            \
+        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
+ private:
+  static constexpr bool compliant =
+      std::is_trivially_default_constructible<T>::value ==
+      is_trivially_default_constructible::value;
+  static_assert(compliant || std::is_trivially_default_constructible<T>::value,
+                "Not compliant with std::is_trivially_default_constructible; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_default_constructible<T>::value,
+                "Not compliant with std::is_trivially_default_constructible; "
+                "Standard: true, Implementation: false");
+#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+};
+
+// is_trivially_move_constructible()
+//
+// Determines whether the passed type `T` is trivially move constructible.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_move_constructible()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
+//
+// NOTE: `T obj(declval<T>());` needs to be well-formed and not call any
+// nontrivial operation.  Nontrivially destructible types will cause the
+// expression to be nontrivial.
+template <typename T>
+struct is_trivially_move_constructible
+    : std::conditional<
+          std::is_object<T>::value && !std::is_array<T>::value,
+          type_traits_internal::IsTriviallyMoveConstructibleObject<T>,
+          std::is_reference<T>>::type::type {
+#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
+    !defined(                                            \
+        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
+ private:
+  static constexpr bool compliant =
+      std::is_trivially_move_constructible<T>::value ==
+      is_trivially_move_constructible::value;
+  static_assert(compliant || std::is_trivially_move_constructible<T>::value,
+                "Not compliant with std::is_trivially_move_constructible; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_move_constructible<T>::value,
+                "Not compliant with std::is_trivially_move_constructible; "
+                "Standard: true, Implementation: false");
+#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+};
+
+// is_trivially_copy_constructible()
+//
+// Determines whether the passed type `T` is trivially copy constructible.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_copy_constructible()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
+//
+// NOTE: `T obj(declval<const T&>());` needs to be well-formed and not call any
+// nontrivial operation.  Nontrivially destructible types will cause the
+// expression to be nontrivial.
+template <typename T>
+struct is_trivially_copy_constructible
+    : std::conditional<
+          std::is_object<T>::value && !std::is_array<T>::value,
+          type_traits_internal::IsTriviallyCopyConstructibleObject<T>,
+          std::is_lvalue_reference<T>>::type::type {
+#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
+    !defined(                                            \
+        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
+ private:
+  static constexpr bool compliant =
+      std::is_trivially_copy_constructible<T>::value ==
+      is_trivially_copy_constructible::value;
+  static_assert(compliant || std::is_trivially_copy_constructible<T>::value,
+                "Not compliant with std::is_trivially_copy_constructible; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_copy_constructible<T>::value,
+                "Not compliant with std::is_trivially_copy_constructible; "
+                "Standard: true, Implementation: false");
+#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+};
+
+// is_trivially_move_assignable()
+//
+// Determines whether the passed type `T` is trivially move assignable.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_move_assignable()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
+//
+// NOTE: `is_assignable<T, U>::value` is `true` if the expression
+// `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
+// operand. `is_trivially_assignable<T, U>` requires the assignment to call no
+// operation that is not trivial. `is_trivially_copy_assignable<T>` is simply
+// `is_trivially_assignable<T&, T>`.
+template <typename T>
+struct is_trivially_move_assignable
+    : std::conditional<
+          std::is_object<T>::value && !std::is_array<T>::value &&
+              std::is_move_assignable<T>::value,
+          std::is_move_assignable<type_traits_internal::SingleMemberUnion<T>>,
+          type_traits_internal::IsTriviallyMoveAssignableReference<T>>::type::
+          type {
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+ private:
+  static constexpr bool compliant =
+      std::is_trivially_move_assignable<T>::value ==
+      is_trivially_move_assignable::value;
+  static_assert(compliant || std::is_trivially_move_assignable<T>::value,
+                "Not compliant with std::is_trivially_move_assignable; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_move_assignable<T>::value,
+                "Not compliant with std::is_trivially_move_assignable; "
+                "Standard: true, Implementation: false");
+#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+};
+
+// is_trivially_copy_assignable()
+//
+// Determines whether the passed type `T` is trivially copy assignable.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_copy_assignable()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
+//
+// NOTE: `is_assignable<T, U>::value` is `true` if the expression
+// `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
+// operand. `is_trivially_assignable<T, U>` requires the assignment to call no
+// operation that is not trivial. `is_trivially_copy_assignable<T>` is simply
+// `is_trivially_assignable<T&, const T&>`.
+template <typename T>
+struct is_trivially_copy_assignable
+    : std::integral_constant<
+          bool, __has_trivial_assign(typename std::remove_reference<T>::type) &&
+                    absl::is_copy_assignable<T>::value> {
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+ private:
+  static constexpr bool compliant =
+      std::is_trivially_copy_assignable<T>::value ==
+      is_trivially_copy_assignable::value;
+  static_assert(compliant || std::is_trivially_copy_assignable<T>::value,
+                "Not compliant with std::is_trivially_copy_assignable; "
+                "Standard: false, Implementation: true");
+  static_assert(compliant || !std::is_trivially_copy_assignable<T>::value,
+                "Not compliant with std::is_trivially_copy_assignable; "
+                "Standard: true, Implementation: false");
+#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+};
+
+#if defined(__cpp_lib_remove_cvref) && __cpp_lib_remove_cvref >= 201711L
+template <typename T>
+using remove_cvref = std::remove_cvref<T>;
+
+template <typename T>
+using remove_cvref_t = typename std::remove_cvref<T>::type;
+#else
+// remove_cvref()
+//
+// C++11 compatible implementation of std::remove_cvref which was added in
+// C++20.
+template <typename T>
+struct remove_cvref {
+  using type =
+      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+};
+
+template <typename T>
+using remove_cvref_t = typename remove_cvref<T>::type;
+#endif
+
+namespace type_traits_internal {
+// is_trivially_copyable()
+//
+// Determines whether the passed type `T` is trivially copyable.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_copyable()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). We use the C++17 definition
+// of TriviallyCopyable.
+//
+// NOTE: `is_trivially_copyable<T>::value` is `true` if all of T's copy/move
+// constructors/assignment operators are trivial or deleted, T has at least
+// one non-deleted copy/move constructor/assignment operator, and T is trivially
+// destructible. Arrays of trivially copyable types are trivially copyable.
+//
+// We expose this metafunction only for internal use within absl.
+template <typename T>
+class is_trivially_copyable_impl {
+  using ExtentsRemoved = typename std::remove_all_extents<T>::type;
+  static constexpr bool kIsCopyOrMoveConstructible =
+      std::is_copy_constructible<ExtentsRemoved>::value ||
+      std::is_move_constructible<ExtentsRemoved>::value;
+  static constexpr bool kIsCopyOrMoveAssignable =
+      absl::is_copy_assignable<ExtentsRemoved>::value ||
+      absl::is_move_assignable<ExtentsRemoved>::value;
+
+ public:
+  static constexpr bool kValue =
+      (__has_trivial_copy(ExtentsRemoved) || !kIsCopyOrMoveConstructible) &&
+      (__has_trivial_assign(ExtentsRemoved) || !kIsCopyOrMoveAssignable) &&
+      (kIsCopyOrMoveConstructible || kIsCopyOrMoveAssignable) &&
+      is_trivially_destructible<ExtentsRemoved>::value &&
+      // We need to check for this explicitly because otherwise we'll say
+      // references are trivial copyable when compiled by MSVC.
+      !std::is_reference<ExtentsRemoved>::value;
+};
+
+template <typename T>
+struct is_trivially_copyable
+    : std::integral_constant<
+          bool, type_traits_internal::is_trivially_copyable_impl<T>::kValue> {};
+}  // namespace type_traits_internal
+
+// -----------------------------------------------------------------------------
+// C++14 "_t" trait aliases
+// -----------------------------------------------------------------------------
+
+template <typename T>
+using remove_cv_t = typename std::remove_cv<T>::type;
+
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+
+template <typename T>
+using remove_volatile_t = typename std::remove_volatile<T>::type;
+
+template <typename T>
+using add_cv_t = typename std::add_cv<T>::type;
+
+template <typename T>
+using add_const_t = typename std::add_const<T>::type;
+
+template <typename T>
+using add_volatile_t = typename std::add_volatile<T>::type;
+
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+
+template <typename T>
+using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
+
+template <typename T>
+using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
+
+template <typename T>
+using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+template <typename T>
+using add_pointer_t = typename std::add_pointer<T>::type;
+
+template <typename T>
+using make_signed_t = typename std::make_signed<T>::type;
+
+template <typename T>
+using make_unsigned_t = typename std::make_unsigned<T>::type;
+
+template <typename T>
+using remove_extent_t = typename std::remove_extent<T>::type;
+
+template <typename T>
+using remove_all_extents_t = typename std::remove_all_extents<T>::type;
+
+template <size_t Len, size_t Align = type_traits_internal::
+                          default_alignment_of_aligned_storage<Len>::value>
+using aligned_storage_t = typename std::aligned_storage<Len, Align>::type;
+
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template <bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+template <typename... T>
+using common_type_t = typename std::common_type<T...>::type;
+
+template <typename T>
+using underlying_type_t = typename std::underlying_type<T>::type;
+
+
+namespace type_traits_internal {
+
+#if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \
+    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+// std::result_of is deprecated (C++17) or removed (C++20)
+template<typename> struct result_of;
+template<typename F, typename... Args>
+struct result_of<F(Args...)> : std::invoke_result<F, Args...> {};
+#else
+template<typename F> using result_of = std::result_of<F>;
+#endif
+
+}  // namespace type_traits_internal
+
+template<typename F>
+using result_of_t = typename type_traits_internal::result_of<F>::type;
+
+namespace type_traits_internal {
+// In MSVC we can't probe std::hash or stdext::hash because it triggers a
+// static_assert instead of failing substitution. Libc++ prior to 4.0
+// also used a static_assert.
+//
+#if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \
+                          _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
+#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
+#else
+#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
+#endif
+
+#if !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+template <typename Key, typename = size_t>
+struct IsHashable : std::true_type {};
+#else   // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+template <typename Key, typename = void>
+struct IsHashable : std::false_type {};
+
+template <typename Key>
+struct IsHashable<
+    Key,
+    absl::enable_if_t<std::is_convertible<
+        decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
+        std::size_t>::value>> : std::true_type {};
+#endif  // !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+
+struct AssertHashEnabledHelper {
+ private:
+  static void Sink(...) {}
+  struct NAT {};
+
+  template <class Key>
+  static auto GetReturnType(int)
+      -> decltype(std::declval<std::hash<Key>>()(std::declval<Key const&>()));
+  template <class Key>
+  static NAT GetReturnType(...);
+
+  template <class Key>
+  static std::nullptr_t DoIt() {
+    static_assert(IsHashable<Key>::value,
+                  "std::hash<Key> does not provide a call operator");
+    static_assert(
+        std::is_default_constructible<std::hash<Key>>::value,
+        "std::hash<Key> must be default constructible when it is enabled");
+    static_assert(
+        std::is_copy_constructible<std::hash<Key>>::value,
+        "std::hash<Key> must be copy constructible when it is enabled");
+    static_assert(absl::is_copy_assignable<std::hash<Key>>::value,
+                  "std::hash<Key> must be copy assignable when it is enabled");
+    // is_destructible is unchecked as it's implied by each of the
+    // is_constructible checks.
+    using ReturnType = decltype(GetReturnType<Key>(0));
+    static_assert(std::is_same<ReturnType, NAT>::value ||
+                      std::is_same<ReturnType, size_t>::value,
+                  "std::hash<Key> must return size_t");
+    return nullptr;
+  }
+
+  template <class... Ts>
+  friend void AssertHashEnabled();
+};
+
+template <class... Ts>
+inline void AssertHashEnabled() {
+  using Helper = AssertHashEnabledHelper;
+  Helper::Sink(Helper::DoIt<Ts>()...);
+}
+
+}  // namespace type_traits_internal
+
+// An internal namespace that is required to implement the C++17 swap traits.
+// It is not further nested in type_traits_internal to avoid long symbol names.
+namespace swap_internal {
+
+// Necessary for the traits.
+using std::swap;
+
+// This declaration prevents global `swap` and `absl::swap` overloads from being
+// considered unless ADL picks them up.
+void swap();
+
+template <class T>
+using IsSwappableImpl = decltype(swap(std::declval<T&>(), std::declval<T&>()));
+
+// NOTE: This dance with the default template parameter is for MSVC.
+template <class T,
+          class IsNoexcept = std::integral_constant<
+              bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>>
+using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type;
+
+// IsSwappable
+//
+// Determines whether the standard swap idiom is a valid expression for
+// arguments of type `T`.
+template <class T>
+struct IsSwappable
+    : absl::type_traits_internal::is_detected<IsSwappableImpl, T> {};
+
+// IsNothrowSwappable
+//
+// Determines whether the standard swap idiom is a valid expression for
+// arguments of type `T` and is noexcept.
+template <class T>
+struct IsNothrowSwappable
+    : absl::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {};
+
+// Swap()
+//
+// Performs the swap idiom from a namespace where valid candidates may only be
+// found in `std` or via ADL.
+template <class T, absl::enable_if_t<IsSwappable<T>::value, int> = 0>
+void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) {
+  swap(lhs, rhs);
+}
+
+// StdSwapIsUnconstrained
+//
+// Some standard library implementations are broken in that they do not
+// constrain `std::swap`. This will effectively tell us if we are dealing with
+// one of those implementations.
+using StdSwapIsUnconstrained = IsSwappable<void()>;
+
+}  // namespace swap_internal
+
+namespace type_traits_internal {
+
+// Make the swap-related traits/function accessible from this namespace.
+using swap_internal::IsNothrowSwappable;
+using swap_internal::IsSwappable;
+using swap_internal::Swap;
+using swap_internal::StdSwapIsUnconstrained;
+
+}  // namespace type_traits_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_META_TYPE_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/numeric/bits.h b/CAPI/cpp/grpc/include/absl/numeric/bits.h
new file mode 100644
index 0000000..628cdf5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/numeric/bits.h
@@ -0,0 +1,178 @@
+// Copyright 2020 The Abseil Authors
+//
+// 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
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: bits.h
+// -----------------------------------------------------------------------------
+//
+// This file contains implementations of C++20's bitwise math functions, as
+// defined by:
+//
+// P0553R4:
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0553r4.html
+// P0556R3:
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0556r3.html
+// P1355R2:
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1355r2.html
+// P1956R1:
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1956r1.pdf
+//
+// When using a standard library that implements these functions, we use the
+// standard library's implementation.
+
+#ifndef ABSL_NUMERIC_BITS_H_
+#define ABSL_NUMERIC_BITS_H_
+
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#if (defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L) || \
+    (defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L)
+#include <bit>
+#endif
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/numeric/internal/bits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+#if !(defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L)
+// rotating
+template <class T>
+ABSL_MUST_USE_RESULT constexpr
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type
+    rotl(T x, int s) noexcept {
+  return numeric_internal::RotateLeft(x, s);
+}
+
+template <class T>
+ABSL_MUST_USE_RESULT constexpr
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type
+    rotr(T x, int s) noexcept {
+  return numeric_internal::RotateRight(x, s);
+}
+
+// Counting functions
+//
+// While these functions are typically constexpr, on some platforms, they may
+// not be marked as constexpr due to constraints of the compiler/available
+// intrinsics.
+template <class T>
+ABSL_INTERNAL_CONSTEXPR_CLZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type
+    countl_zero(T x) noexcept {
+  return numeric_internal::CountLeadingZeroes(x);
+}
+
+template <class T>
+ABSL_INTERNAL_CONSTEXPR_CLZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type
+    countl_one(T x) noexcept {
+  // Avoid integer promotion to a wider type
+  return countl_zero(static_cast<T>(~x));
+}
+
+template <class T>
+ABSL_INTERNAL_CONSTEXPR_CTZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type
+    countr_zero(T x) noexcept {
+  return numeric_internal::CountTrailingZeroes(x);
+}
+
+template <class T>
+ABSL_INTERNAL_CONSTEXPR_CTZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type
+    countr_one(T x) noexcept {
+  // Avoid integer promotion to a wider type
+  return countr_zero(static_cast<T>(~x));
+}
+
+template <class T>
+ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type
+    popcount(T x) noexcept {
+  return numeric_internal::Popcount(x);
+}
+#else  // defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L
+
+using std::countl_one;
+using std::countl_zero;
+using std::countr_one;
+using std::countr_zero;
+using std::popcount;
+using std::rotl;
+using std::rotr;
+
+#endif
+
+#if !(defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L)
+// Returns: true if x is an integral power of two; false otherwise.
+template <class T>
+constexpr inline typename std::enable_if<std::is_unsigned<T>::value, bool>::type
+has_single_bit(T x) noexcept {
+  return x != 0 && (x & (x - 1)) == 0;
+}
+
+// Returns: If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any
+// fractional part discarded.
+template <class T>
+ABSL_INTERNAL_CONSTEXPR_CLZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type
+    bit_width(T x) noexcept {
+  return std::numeric_limits<T>::digits -
+         static_cast<unsigned int>(countl_zero(x));
+}
+
+// Returns: If x == 0, 0; otherwise the maximal value y such that
+// has_single_bit(y) is true and y <= x.
+template <class T>
+ABSL_INTERNAL_CONSTEXPR_CLZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type
+    bit_floor(T x) noexcept {
+  return x == 0 ? 0 : T{1} << (bit_width(x) - 1);
+}
+
+// Returns: N, where N is the smallest power of 2 greater than or equal to x.
+//
+// Preconditions: N is representable as a value of type T.
+template <class T>
+ABSL_INTERNAL_CONSTEXPR_CLZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type
+    bit_ceil(T x) {
+  // If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
+  // want to force it to wraparound so that bit_ceil of an invalid value are not
+  // core constant expressions.
+  //
+  // BitCeilNonPowerOf2 triggers an overflow in constexpr contexts if we would
+  // undergo promotion to unsigned but not fit the result into T without
+  // truncation.
+  return has_single_bit(x) ? T{1} << (bit_width(x) - 1)
+                           : numeric_internal::BitCeilNonPowerOf2(x);
+}
+#else  // defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L
+
+using std::bit_ceil;
+using std::bit_floor;
+using std::bit_width;
+using std::has_single_bit;
+
+#endif
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_NUMERIC_BITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/numeric/int128.h b/CAPI/cpp/grpc/include/absl/numeric/int128.h
new file mode 100644
index 0000000..7a899ee
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/numeric/int128.h
@@ -0,0 +1,1165 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: int128.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines 128-bit integer types, `uint128` and `int128`.
+//
+// TODO(absl-team): This module is inconsistent as many inline `uint128` methods
+// are defined in this file, while many inline `int128` methods are defined in
+// the `int128_*_intrinsic.inc` files.
+
+#ifndef ABSL_NUMERIC_INT128_H_
+#define ABSL_NUMERIC_INT128_H_
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <limits>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+#if defined(_MSC_VER)
+// In very old versions of MSVC and when the /Zc:wchar_t flag is off, wchar_t is
+// a typedef for unsigned short.  Otherwise wchar_t is mapped to the __wchar_t
+// builtin type.  We need to make sure not to define operator wchar_t()
+// alongside operator unsigned short() in these instances.
+#define ABSL_INTERNAL_WCHAR_T __wchar_t
+#if defined(_M_X64) && !defined(_M_ARM64EC)
+#include <intrin.h>
+#pragma intrinsic(_umul128)
+#endif  // defined(_M_X64)
+#else   // defined(_MSC_VER)
+#define ABSL_INTERNAL_WCHAR_T wchar_t
+#endif  // defined(_MSC_VER)
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class int128;
+
+// uint128
+//
+// An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type
+// as closely as is practical, including exhibiting undefined behavior in
+// analogous cases (e.g. division by zero). This type is intended to be a
+// drop-in replacement once C++ supports an intrinsic `uint128_t` type; when
+// that occurs, existing well-behaved uses of `uint128` will continue to work
+// using that new type.
+//
+// Note: code written with this type will continue to compile once `uint128_t`
+// is introduced, provided the replacement helper functions
+// `Uint128(Low|High)64()` and `MakeUint128()` are made.
+//
+// A `uint128` supports the following:
+//
+//   * Implicit construction from integral types
+//   * Explicit conversion to integral types
+//
+// Additionally, if your compiler supports `__int128`, `uint128` is
+// interoperable with that type. (Abseil checks for this compatibility through
+// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+//
+// However, a `uint128` differs from intrinsic integral types in the following
+// ways:
+//
+//   * Errors on implicit conversions that do not preserve value (such as
+//     loss of precision when converting to float values).
+//   * Requires explicit construction from and conversion to floating point
+//     types.
+//   * Conversion to integral types requires an explicit static_cast() to
+//     mimic use of the `-Wnarrowing` compiler flag.
+//   * The alignment requirement of `uint128` may differ from that of an
+//     intrinsic 128-bit integer type depending on platform and build
+//     configuration.
+//
+// Example:
+//
+//     float y = absl::Uint128Max();  // Error. uint128 cannot be implicitly
+//                                    // converted to float.
+//
+//     absl::uint128 v;
+//     uint64_t i = v;                         // Error
+//     uint64_t i = static_cast<uint64_t>(v);  // OK
+//
+class
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+    alignas(unsigned __int128)
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+        uint128 {
+ public:
+  uint128() = default;
+
+  // Constructors from arithmetic types
+  constexpr uint128(int v);                 // NOLINT(runtime/explicit)
+  constexpr uint128(unsigned int v);        // NOLINT(runtime/explicit)
+  constexpr uint128(long v);                // NOLINT(runtime/int)
+  constexpr uint128(unsigned long v);       // NOLINT(runtime/int)
+  constexpr uint128(long long v);           // NOLINT(runtime/int)
+  constexpr uint128(unsigned long long v);  // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr uint128(__int128 v);           // NOLINT(runtime/explicit)
+  constexpr uint128(unsigned __int128 v);  // NOLINT(runtime/explicit)
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  constexpr uint128(int128 v);  // NOLINT(runtime/explicit)
+  explicit uint128(float v);
+  explicit uint128(double v);
+  explicit uint128(long double v);
+
+  // Assignment operators from arithmetic types
+  uint128& operator=(int v);
+  uint128& operator=(unsigned int v);
+  uint128& operator=(long v);                // NOLINT(runtime/int)
+  uint128& operator=(unsigned long v);       // NOLINT(runtime/int)
+  uint128& operator=(long long v);           // NOLINT(runtime/int)
+  uint128& operator=(unsigned long long v);  // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  uint128& operator=(__int128 v);
+  uint128& operator=(unsigned __int128 v);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  uint128& operator=(int128 v);
+
+  // Conversion operators to other arithmetic types
+  constexpr explicit operator bool() const;
+  constexpr explicit operator char() const;
+  constexpr explicit operator signed char() const;
+  constexpr explicit operator unsigned char() const;
+  constexpr explicit operator char16_t() const;
+  constexpr explicit operator char32_t() const;
+  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
+  constexpr explicit operator short() const;  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned short() const;
+  constexpr explicit operator int() const;
+  constexpr explicit operator unsigned int() const;
+  constexpr explicit operator long() const;  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned long() const;
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator long long() const;
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned long long() const;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr explicit operator __int128() const;
+  constexpr explicit operator unsigned __int128() const;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  explicit operator float() const;
+  explicit operator double() const;
+  explicit operator long double() const;
+
+  // Trivial copy constructor, assignment operator and destructor.
+
+  // Arithmetic operators.
+  uint128& operator+=(uint128 other);
+  uint128& operator-=(uint128 other);
+  uint128& operator*=(uint128 other);
+  // Long division/modulo for uint128.
+  uint128& operator/=(uint128 other);
+  uint128& operator%=(uint128 other);
+  uint128 operator++(int);
+  uint128 operator--(int);
+  uint128& operator<<=(int);
+  uint128& operator>>=(int);
+  uint128& operator&=(uint128 other);
+  uint128& operator|=(uint128 other);
+  uint128& operator^=(uint128 other);
+  uint128& operator++();
+  uint128& operator--();
+
+  // Uint128Low64()
+  //
+  // Returns the lower 64-bit value of a `uint128` value.
+  friend constexpr uint64_t Uint128Low64(uint128 v);
+
+  // Uint128High64()
+  //
+  // Returns the higher 64-bit value of a `uint128` value.
+  friend constexpr uint64_t Uint128High64(uint128 v);
+
+  // MakeUInt128()
+  //
+  // Constructs a `uint128` numeric value from two 64-bit unsigned integers.
+  // Note that this factory function is the only way to construct a `uint128`
+  // from integer values greater than 2^64.
+  //
+  // Example:
+  //
+  //   absl::uint128 big = absl::MakeUint128(1, 0);
+  friend constexpr uint128 MakeUint128(uint64_t high, uint64_t low);
+
+  // Uint128Max()
+  //
+  // Returns the highest value for a 128-bit unsigned integer.
+  friend constexpr uint128 Uint128Max();
+
+  // Support for absl::Hash.
+  template <typename H>
+  friend H AbslHashValue(H h, uint128 v) {
+    return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v));
+  }
+
+ private:
+  constexpr uint128(uint64_t high, uint64_t low);
+
+  // TODO(strel) Update implementation to use __int128 once all users of
+  // uint128 are fixed to not depend on alignof(uint128) == 8. Also add
+  // alignas(16) to class definition to keep alignment consistent across
+  // platforms.
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+  uint64_t lo_;
+  uint64_t hi_;
+#elif defined(ABSL_IS_BIG_ENDIAN)
+  uint64_t hi_;
+  uint64_t lo_;
+#else  // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif  // byte order
+};
+
+// Prefer to use the constexpr `Uint128Max()`.
+//
+// TODO(absl-team) deprecate kuint128max once migration tool is released.
+ABSL_DLL extern const uint128 kuint128max;
+
+// allow uint128 to be logged
+std::ostream& operator<<(std::ostream& os, uint128 v);
+
+// TODO(strel) add operator>>(std::istream&, uint128)
+
+constexpr uint128 Uint128Max() {
+  return uint128((std::numeric_limits<uint64_t>::max)(),
+                 (std::numeric_limits<uint64_t>::max)());
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// Specialized numeric_limits for uint128.
+namespace std {
+template <>
+class numeric_limits<absl::uint128> {
+ public:
+  static constexpr bool is_specialized = true;
+  static constexpr bool is_signed = false;
+  static constexpr bool is_integer = true;
+  static constexpr bool is_exact = true;
+  static constexpr bool has_infinity = false;
+  static constexpr bool has_quiet_NaN = false;
+  static constexpr bool has_signaling_NaN = false;
+  static constexpr float_denorm_style has_denorm = denorm_absent;
+  static constexpr bool has_denorm_loss = false;
+  static constexpr float_round_style round_style = round_toward_zero;
+  static constexpr bool is_iec559 = false;
+  static constexpr bool is_bounded = true;
+  static constexpr bool is_modulo = true;
+  static constexpr int digits = 128;
+  static constexpr int digits10 = 38;
+  static constexpr int max_digits10 = 0;
+  static constexpr int radix = 2;
+  static constexpr int min_exponent = 0;
+  static constexpr int min_exponent10 = 0;
+  static constexpr int max_exponent = 0;
+  static constexpr int max_exponent10 = 0;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool traps = numeric_limits<unsigned __int128>::traps;
+#else   // ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool traps = numeric_limits<uint64_t>::traps;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool tinyness_before = false;
+
+  static constexpr absl::uint128 (min)() { return 0; }
+  static constexpr absl::uint128 lowest() { return 0; }
+  static constexpr absl::uint128 (max)() { return absl::Uint128Max(); }
+  static constexpr absl::uint128 epsilon() { return 0; }
+  static constexpr absl::uint128 round_error() { return 0; }
+  static constexpr absl::uint128 infinity() { return 0; }
+  static constexpr absl::uint128 quiet_NaN() { return 0; }
+  static constexpr absl::uint128 signaling_NaN() { return 0; }
+  static constexpr absl::uint128 denorm_min() { return 0; }
+};
+}  // namespace std
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// int128
+//
+// A signed 128-bit integer type. The API is meant to mimic an intrinsic
+// integral type as closely as is practical, including exhibiting undefined
+// behavior in analogous cases (e.g. division by zero).
+//
+// An `int128` supports the following:
+//
+//   * Implicit construction from integral types
+//   * Explicit conversion to integral types
+//
+// However, an `int128` differs from intrinsic integral types in the following
+// ways:
+//
+//   * It is not implicitly convertible to other integral types.
+//   * Requires explicit construction from and conversion to floating point
+//     types.
+
+// Additionally, if your compiler supports `__int128`, `int128` is
+// interoperable with that type. (Abseil checks for this compatibility through
+// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+//
+// The design goal for `int128` is that it will be compatible with a future
+// `int128_t`, if that type becomes a part of the standard.
+//
+// Example:
+//
+//     float y = absl::int128(17);  // Error. int128 cannot be implicitly
+//                                  // converted to float.
+//
+//     absl::int128 v;
+//     int64_t i = v;                        // Error
+//     int64_t i = static_cast<int64_t>(v);  // OK
+//
+class int128 {
+ public:
+  int128() = default;
+
+  // Constructors from arithmetic types
+  constexpr int128(int v);                 // NOLINT(runtime/explicit)
+  constexpr int128(unsigned int v);        // NOLINT(runtime/explicit)
+  constexpr int128(long v);                // NOLINT(runtime/int)
+  constexpr int128(unsigned long v);       // NOLINT(runtime/int)
+  constexpr int128(long long v);           // NOLINT(runtime/int)
+  constexpr int128(unsigned long long v);  // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr int128(__int128 v);  // NOLINT(runtime/explicit)
+  constexpr explicit int128(unsigned __int128 v);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  constexpr explicit int128(uint128 v);
+  explicit int128(float v);
+  explicit int128(double v);
+  explicit int128(long double v);
+
+  // Assignment operators from arithmetic types
+  int128& operator=(int v);
+  int128& operator=(unsigned int v);
+  int128& operator=(long v);                // NOLINT(runtime/int)
+  int128& operator=(unsigned long v);       // NOLINT(runtime/int)
+  int128& operator=(long long v);           // NOLINT(runtime/int)
+  int128& operator=(unsigned long long v);  // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  int128& operator=(__int128 v);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+  // Conversion operators to other arithmetic types
+  constexpr explicit operator bool() const;
+  constexpr explicit operator char() const;
+  constexpr explicit operator signed char() const;
+  constexpr explicit operator unsigned char() const;
+  constexpr explicit operator char16_t() const;
+  constexpr explicit operator char32_t() const;
+  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
+  constexpr explicit operator short() const;  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned short() const;
+  constexpr explicit operator int() const;
+  constexpr explicit operator unsigned int() const;
+  constexpr explicit operator long() const;  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned long() const;
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator long long() const;
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned long long() const;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr explicit operator __int128() const;
+  constexpr explicit operator unsigned __int128() const;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  explicit operator float() const;
+  explicit operator double() const;
+  explicit operator long double() const;
+
+  // Trivial copy constructor, assignment operator and destructor.
+
+  // Arithmetic operators
+  int128& operator+=(int128 other);
+  int128& operator-=(int128 other);
+  int128& operator*=(int128 other);
+  int128& operator/=(int128 other);
+  int128& operator%=(int128 other);
+  int128 operator++(int);  // postfix increment: i++
+  int128 operator--(int);  // postfix decrement: i--
+  int128& operator++();    // prefix increment:  ++i
+  int128& operator--();    // prefix decrement:  --i
+  int128& operator&=(int128 other);
+  int128& operator|=(int128 other);
+  int128& operator^=(int128 other);
+  int128& operator<<=(int amount);
+  int128& operator>>=(int amount);
+
+  // Int128Low64()
+  //
+  // Returns the lower 64-bit value of a `int128` value.
+  friend constexpr uint64_t Int128Low64(int128 v);
+
+  // Int128High64()
+  //
+  // Returns the higher 64-bit value of a `int128` value.
+  friend constexpr int64_t Int128High64(int128 v);
+
+  // MakeInt128()
+  //
+  // Constructs a `int128` numeric value from two 64-bit integers. Note that
+  // signedness is conveyed in the upper `high` value.
+  //
+  //   (absl::int128(1) << 64) * high + low
+  //
+  // Note that this factory function is the only way to construct a `int128`
+  // from integer values greater than 2^64 or less than -2^64.
+  //
+  // Example:
+  //
+  //   absl::int128 big = absl::MakeInt128(1, 0);
+  //   absl::int128 big_n = absl::MakeInt128(-1, 0);
+  friend constexpr int128 MakeInt128(int64_t high, uint64_t low);
+
+  // Int128Max()
+  //
+  // Returns the maximum value for a 128-bit signed integer.
+  friend constexpr int128 Int128Max();
+
+  // Int128Min()
+  //
+  // Returns the minimum value for a 128-bit signed integer.
+  friend constexpr int128 Int128Min();
+
+  // Support for absl::Hash.
+  template <typename H>
+  friend H AbslHashValue(H h, int128 v) {
+    return H::combine(std::move(h), Int128High64(v), Int128Low64(v));
+  }
+
+ private:
+  constexpr int128(int64_t high, uint64_t low);
+
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  __int128 v_;
+#else  // ABSL_HAVE_INTRINSIC_INT128
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+  uint64_t lo_;
+  int64_t hi_;
+#elif defined(ABSL_IS_BIG_ENDIAN)
+  int64_t hi_;
+  uint64_t lo_;
+#else  // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif  // byte order
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+};
+
+std::ostream& operator<<(std::ostream& os, int128 v);
+
+// TODO(absl-team) add operator>>(std::istream&, int128)
+
+constexpr int128 Int128Max() {
+  return int128((std::numeric_limits<int64_t>::max)(),
+                (std::numeric_limits<uint64_t>::max)());
+}
+
+constexpr int128 Int128Min() {
+  return int128((std::numeric_limits<int64_t>::min)(), 0);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// Specialized numeric_limits for int128.
+namespace std {
+template <>
+class numeric_limits<absl::int128> {
+ public:
+  static constexpr bool is_specialized = true;
+  static constexpr bool is_signed = true;
+  static constexpr bool is_integer = true;
+  static constexpr bool is_exact = true;
+  static constexpr bool has_infinity = false;
+  static constexpr bool has_quiet_NaN = false;
+  static constexpr bool has_signaling_NaN = false;
+  static constexpr float_denorm_style has_denorm = denorm_absent;
+  static constexpr bool has_denorm_loss = false;
+  static constexpr float_round_style round_style = round_toward_zero;
+  static constexpr bool is_iec559 = false;
+  static constexpr bool is_bounded = true;
+  static constexpr bool is_modulo = false;
+  static constexpr int digits = 127;
+  static constexpr int digits10 = 38;
+  static constexpr int max_digits10 = 0;
+  static constexpr int radix = 2;
+  static constexpr int min_exponent = 0;
+  static constexpr int min_exponent10 = 0;
+  static constexpr int max_exponent = 0;
+  static constexpr int max_exponent10 = 0;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool traps = numeric_limits<__int128>::traps;
+#else   // ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool traps = numeric_limits<uint64_t>::traps;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool tinyness_before = false;
+
+  static constexpr absl::int128 (min)() { return absl::Int128Min(); }
+  static constexpr absl::int128 lowest() { return absl::Int128Min(); }
+  static constexpr absl::int128 (max)() { return absl::Int128Max(); }
+  static constexpr absl::int128 epsilon() { return 0; }
+  static constexpr absl::int128 round_error() { return 0; }
+  static constexpr absl::int128 infinity() { return 0; }
+  static constexpr absl::int128 quiet_NaN() { return 0; }
+  static constexpr absl::int128 signaling_NaN() { return 0; }
+  static constexpr absl::int128 denorm_min() { return 0; }
+};
+}  // namespace std
+
+// --------------------------------------------------------------------------
+//                      Implementation details follow
+// --------------------------------------------------------------------------
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+constexpr uint128 MakeUint128(uint64_t high, uint64_t low) {
+  return uint128(high, low);
+}
+
+// Assignment from integer types.
+
+inline uint128& uint128::operator=(int v) { return *this = uint128(v); }
+
+inline uint128& uint128::operator=(unsigned int v) {
+  return *this = uint128(v);
+}
+
+inline uint128& uint128::operator=(long v) {  // NOLINT(runtime/int)
+  return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(unsigned long v) {
+  return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(long long v) {
+  return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(unsigned long long v) {
+  return *this = uint128(v);
+}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+inline uint128& uint128::operator=(__int128 v) {
+  return *this = uint128(v);
+}
+
+inline uint128& uint128::operator=(unsigned __int128 v) {
+  return *this = uint128(v);
+}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+inline uint128& uint128::operator=(int128 v) {
+  return *this = uint128(v);
+}
+
+// Arithmetic operators.
+
+constexpr uint128 operator<<(uint128 lhs, int amount);
+constexpr uint128 operator>>(uint128 lhs, int amount);
+constexpr uint128 operator+(uint128 lhs, uint128 rhs);
+constexpr uint128 operator-(uint128 lhs, uint128 rhs);
+uint128 operator*(uint128 lhs, uint128 rhs);
+uint128 operator/(uint128 lhs, uint128 rhs);
+uint128 operator%(uint128 lhs, uint128 rhs);
+
+inline uint128& uint128::operator<<=(int amount) {
+  *this = *this << amount;
+  return *this;
+}
+
+inline uint128& uint128::operator>>=(int amount) {
+  *this = *this >> amount;
+  return *this;
+}
+
+inline uint128& uint128::operator+=(uint128 other) {
+  *this = *this + other;
+  return *this;
+}
+
+inline uint128& uint128::operator-=(uint128 other) {
+  *this = *this - other;
+  return *this;
+}
+
+inline uint128& uint128::operator*=(uint128 other) {
+  *this = *this * other;
+  return *this;
+}
+
+inline uint128& uint128::operator/=(uint128 other) {
+  *this = *this / other;
+  return *this;
+}
+
+inline uint128& uint128::operator%=(uint128 other) {
+  *this = *this % other;
+  return *this;
+}
+
+constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
+
+constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
+
+// Constructors from integer types.
+
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+
+constexpr uint128::uint128(uint64_t high, uint64_t low)
+    : lo_{low}, hi_{high} {}
+
+constexpr uint128::uint128(int v)
+    : lo_{static_cast<uint64_t>(v)},
+      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
+constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
+    : lo_{static_cast<uint64_t>(v)},
+      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
+constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
+    : lo_{static_cast<uint64_t>(v)},
+      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
+
+constexpr uint128::uint128(unsigned int v) : lo_{v}, hi_{0} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long long v) : lo_{v}, hi_{0} {}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::uint128(__int128 v)
+    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
+      hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)} {}
+constexpr uint128::uint128(unsigned __int128 v)
+    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
+      hi_{static_cast<uint64_t>(v >> 64)} {}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+constexpr uint128::uint128(int128 v)
+    : lo_{Int128Low64(v)}, hi_{static_cast<uint64_t>(Int128High64(v))} {}
+
+#elif defined(ABSL_IS_BIG_ENDIAN)
+
+constexpr uint128::uint128(uint64_t high, uint64_t low)
+    : hi_{high}, lo_{low} {}
+
+constexpr uint128::uint128(int v)
+    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+      lo_{static_cast<uint64_t>(v)} {}
+constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
+    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+      lo_{static_cast<uint64_t>(v)} {}
+constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
+    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+      lo_{static_cast<uint64_t>(v)} {}
+
+constexpr uint128::uint128(unsigned int v) : hi_{0}, lo_{v} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long v) : hi_{0}, lo_{v} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long long v) : hi_{0}, lo_{v} {}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::uint128(__int128 v)
+    : hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)},
+      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
+constexpr uint128::uint128(unsigned __int128 v)
+    : hi_{static_cast<uint64_t>(v >> 64)},
+      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+constexpr uint128::uint128(int128 v)
+    : hi_{static_cast<uint64_t>(Int128High64(v))}, lo_{Int128Low64(v)} {}
+
+#else  // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif  // byte order
+
+// Conversion operators to integer types.
+
+constexpr uint128::operator bool() const { return lo_ || hi_; }
+
+constexpr uint128::operator char() const { return static_cast<char>(lo_); }
+
+constexpr uint128::operator signed char() const {
+  return static_cast<signed char>(lo_);
+}
+
+constexpr uint128::operator unsigned char() const {
+  return static_cast<unsigned char>(lo_);
+}
+
+constexpr uint128::operator char16_t() const {
+  return static_cast<char16_t>(lo_);
+}
+
+constexpr uint128::operator char32_t() const {
+  return static_cast<char32_t>(lo_);
+}
+
+constexpr uint128::operator ABSL_INTERNAL_WCHAR_T() const {
+  return static_cast<ABSL_INTERNAL_WCHAR_T>(lo_);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::operator short() const { return static_cast<short>(lo_); }
+
+constexpr uint128::operator unsigned short() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned short>(lo_);            // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator int() const { return static_cast<int>(lo_); }
+
+constexpr uint128::operator unsigned int() const {
+  return static_cast<unsigned int>(lo_);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::operator long() const { return static_cast<long>(lo_); }
+
+constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator long long() const {  // NOLINT(runtime/int)
+  return static_cast<long long>(lo_);            // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator unsigned long long() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned long long>(lo_);            // NOLINT(runtime/int)
+}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::operator __int128() const {
+  return (static_cast<__int128>(hi_) << 64) + lo_;
+}
+
+constexpr uint128::operator unsigned __int128() const {
+  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
+}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+// Conversion operators to floating point types.
+
+inline uint128::operator float() const {
+  return static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64);
+}
+
+inline uint128::operator double() const {
+  return static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64);
+}
+
+inline uint128::operator long double() const {
+  return static_cast<long double>(lo_) +
+         std::ldexp(static_cast<long double>(hi_), 64);
+}
+
+// Comparison operators.
+
+constexpr bool operator==(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return static_cast<unsigned __int128>(lhs) ==
+         static_cast<unsigned __int128>(rhs);
+#else
+  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
+          Uint128High64(lhs) == Uint128High64(rhs));
+#endif
+}
+
+constexpr bool operator!=(uint128 lhs, uint128 rhs) { return !(lhs == rhs); }
+
+constexpr bool operator<(uint128 lhs, uint128 rhs) {
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  return static_cast<unsigned __int128>(lhs) <
+         static_cast<unsigned __int128>(rhs);
+#else
+  return (Uint128High64(lhs) == Uint128High64(rhs))
+             ? (Uint128Low64(lhs) < Uint128Low64(rhs))
+             : (Uint128High64(lhs) < Uint128High64(rhs));
+#endif
+}
+
+constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
+
+constexpr bool operator<=(uint128 lhs, uint128 rhs) { return !(rhs < lhs); }
+
+constexpr bool operator>=(uint128 lhs, uint128 rhs) { return !(lhs < rhs); }
+
+// Unary operators.
+
+constexpr inline uint128 operator+(uint128 val) {
+  return val;
+}
+
+constexpr inline int128 operator+(int128 val) {
+  return val;
+}
+
+constexpr uint128 operator-(uint128 val) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return -static_cast<unsigned __int128>(val);
+#else
+  return MakeUint128(
+      ~Uint128High64(val) + static_cast<unsigned long>(Uint128Low64(val) == 0),
+      ~Uint128Low64(val) + 1);
+#endif
+}
+
+constexpr inline bool operator!(uint128 val) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return !static_cast<unsigned __int128>(val);
+#else
+  return !Uint128High64(val) && !Uint128Low64(val);
+#endif
+}
+
+// Logical operators.
+
+constexpr inline uint128 operator~(uint128 val) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return ~static_cast<unsigned __int128>(val);
+#else
+  return MakeUint128(~Uint128High64(val), ~Uint128Low64(val));
+#endif
+}
+
+constexpr inline uint128 operator|(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return static_cast<unsigned __int128>(lhs) |
+         static_cast<unsigned __int128>(rhs);
+#else
+  return MakeUint128(Uint128High64(lhs) | Uint128High64(rhs),
+                     Uint128Low64(lhs) | Uint128Low64(rhs));
+#endif
+}
+
+constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return static_cast<unsigned __int128>(lhs) &
+         static_cast<unsigned __int128>(rhs);
+#else
+  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
+                     Uint128Low64(lhs) & Uint128Low64(rhs));
+#endif
+}
+
+constexpr inline uint128 operator^(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return static_cast<unsigned __int128>(lhs) ^
+         static_cast<unsigned __int128>(rhs);
+#else
+  return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
+                     Uint128Low64(lhs) ^ Uint128Low64(rhs));
+#endif
+}
+
+inline uint128& uint128::operator|=(uint128 other) {
+  *this = *this | other;
+  return *this;
+}
+
+inline uint128& uint128::operator&=(uint128 other) {
+  *this = *this & other;
+  return *this;
+}
+
+inline uint128& uint128::operator^=(uint128 other) {
+  *this = *this ^ other;
+  return *this;
+}
+
+// Arithmetic operators.
+
+constexpr uint128 operator<<(uint128 lhs, int amount) {
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  return static_cast<unsigned __int128>(lhs) << amount;
+#else
+  // uint64_t shifts of >= 64 are undefined, so we will need some
+  // special-casing.
+  return amount >= 64 ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
+         : amount == 0 ? lhs
+                       : MakeUint128((Uint128High64(lhs) << amount) |
+                                         (Uint128Low64(lhs) >> (64 - amount)),
+                                     Uint128Low64(lhs) << amount);
+#endif
+}
+
+constexpr uint128 operator>>(uint128 lhs, int amount) {
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  return static_cast<unsigned __int128>(lhs) >> amount;
+#else
+  // uint64_t shifts of >= 64 are undefined, so we will need some
+  // special-casing.
+  return amount >= 64 ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
+         : amount == 0 ? lhs
+                       : MakeUint128(Uint128High64(lhs) >> amount,
+                                     (Uint128Low64(lhs) >> amount) |
+                                         (Uint128High64(lhs) << (64 - amount)));
+#endif
+}
+
+#if !defined(ABSL_HAVE_INTRINSIC_INT128)
+namespace int128_internal {
+constexpr uint128 AddResult(uint128 result, uint128 lhs) {
+  // check for carry
+  return (Uint128Low64(result) < Uint128Low64(lhs))
+             ? MakeUint128(Uint128High64(result) + 1, Uint128Low64(result))
+             : result;
+}
+}  // namespace int128_internal
+#endif
+
+constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return static_cast<unsigned __int128>(lhs) +
+         static_cast<unsigned __int128>(rhs);
+#else
+  return int128_internal::AddResult(
+      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
+                  Uint128Low64(lhs) + Uint128Low64(rhs)),
+      lhs);
+#endif
+}
+
+#if !defined(ABSL_HAVE_INTRINSIC_INT128)
+namespace int128_internal {
+constexpr uint128 SubstructResult(uint128 result, uint128 lhs, uint128 rhs) {
+  // check for carry
+  return (Uint128Low64(lhs) < Uint128Low64(rhs))
+             ? MakeUint128(Uint128High64(result) - 1, Uint128Low64(result))
+             : result;
+}
+}  // namespace int128_internal
+#endif
+
+constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  return static_cast<unsigned __int128>(lhs) -
+         static_cast<unsigned __int128>(rhs);
+#else
+  return int128_internal::SubstructResult(
+      MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
+                  Uint128Low64(lhs) - Uint128Low64(rhs)),
+      lhs, rhs);
+#endif
+}
+
+inline uint128 operator*(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
+  // can be used for uint128 storage.
+  return static_cast<unsigned __int128>(lhs) *
+         static_cast<unsigned __int128>(rhs);
+#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
+  uint64_t carry;
+  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
+  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
+                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
+                     low);
+#else   // ABSL_HAVE_INTRINSIC128
+  uint64_t a32 = Uint128Low64(lhs) >> 32;
+  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
+  uint64_t b32 = Uint128Low64(rhs) >> 32;
+  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
+  uint128 result =
+      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
+                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
+                  a00 * b00);
+  result += uint128(a32 * b00) << 32;
+  result += uint128(a00 * b32) << 32;
+  return result;
+#endif  // ABSL_HAVE_INTRINSIC128
+}
+
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+inline uint128 operator/(uint128 lhs, uint128 rhs) {
+  return static_cast<unsigned __int128>(lhs) /
+         static_cast<unsigned __int128>(rhs);
+}
+
+inline uint128 operator%(uint128 lhs, uint128 rhs) {
+  return static_cast<unsigned __int128>(lhs) %
+         static_cast<unsigned __int128>(rhs);
+}
+#endif
+
+// Increment/decrement operators.
+
+inline uint128 uint128::operator++(int) {
+  uint128 tmp(*this);
+  *this += 1;
+  return tmp;
+}
+
+inline uint128 uint128::operator--(int) {
+  uint128 tmp(*this);
+  *this -= 1;
+  return tmp;
+}
+
+inline uint128& uint128::operator++() {
+  *this += 1;
+  return *this;
+}
+
+inline uint128& uint128::operator--() {
+  *this -= 1;
+  return *this;
+}
+
+constexpr int128 MakeInt128(int64_t high, uint64_t low) {
+  return int128(high, low);
+}
+
+// Assignment from integer types.
+inline int128& int128::operator=(int v) {
+  return *this = int128(v);
+}
+
+inline int128& int128::operator=(unsigned int v) {
+  return *this = int128(v);
+}
+
+inline int128& int128::operator=(long v) {  // NOLINT(runtime/int)
+  return *this = int128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline int128& int128::operator=(unsigned long v) {
+  return *this = int128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline int128& int128::operator=(long long v) {
+  return *this = int128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline int128& int128::operator=(unsigned long long v) {
+  return *this = int128(v);
+}
+
+// Arithmetic operators.
+constexpr int128 operator-(int128 v);
+constexpr int128 operator+(int128 lhs, int128 rhs);
+constexpr int128 operator-(int128 lhs, int128 rhs);
+int128 operator*(int128 lhs, int128 rhs);
+int128 operator/(int128 lhs, int128 rhs);
+int128 operator%(int128 lhs, int128 rhs);
+constexpr int128 operator|(int128 lhs, int128 rhs);
+constexpr int128 operator&(int128 lhs, int128 rhs);
+constexpr int128 operator^(int128 lhs, int128 rhs);
+constexpr int128 operator<<(int128 lhs, int amount);
+constexpr int128 operator>>(int128 lhs, int amount);
+
+inline int128& int128::operator+=(int128 other) {
+  *this = *this + other;
+  return *this;
+}
+
+inline int128& int128::operator-=(int128 other) {
+  *this = *this - other;
+  return *this;
+}
+
+inline int128& int128::operator*=(int128 other) {
+  *this = *this * other;
+  return *this;
+}
+
+inline int128& int128::operator/=(int128 other) {
+  *this = *this / other;
+  return *this;
+}
+
+inline int128& int128::operator%=(int128 other) {
+  *this = *this % other;
+  return *this;
+}
+
+inline int128& int128::operator|=(int128 other) {
+  *this = *this | other;
+  return *this;
+}
+
+inline int128& int128::operator&=(int128 other) {
+  *this = *this & other;
+  return *this;
+}
+
+inline int128& int128::operator^=(int128 other) {
+  *this = *this ^ other;
+  return *this;
+}
+
+inline int128& int128::operator<<=(int amount) {
+  *this = *this << amount;
+  return *this;
+}
+
+inline int128& int128::operator>>=(int amount) {
+  *this = *this >> amount;
+  return *this;
+}
+
+// Forward declaration for comparison operators.
+constexpr bool operator!=(int128 lhs, int128 rhs);
+
+namespace int128_internal {
+
+// Casts from unsigned to signed while preserving the underlying binary
+// representation.
+constexpr int64_t BitCastToSigned(uint64_t v) {
+  // Casting an unsigned integer to a signed integer of the same
+  // width is implementation defined behavior if the source value would not fit
+  // in the destination type. We step around it with a roundtrip bitwise not
+  // operation to make sure this function remains constexpr. Clang, GCC, and
+  // MSVC optimize this to a no-op on x86-64.
+  return v & (uint64_t{1} << 63) ? ~static_cast<int64_t>(~v)
+                                 : static_cast<int64_t>(v);
+}
+
+}  // namespace int128_internal
+
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#include "absl/numeric/int128_have_intrinsic.inc"  // IWYU pragma: export
+#else  // ABSL_HAVE_INTRINSIC_INT128
+#include "absl/numeric/int128_no_intrinsic.inc"  // IWYU pragma: export
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#undef ABSL_INTERNAL_WCHAR_T
+
+#endif  // ABSL_NUMERIC_INT128_H_
diff --git a/CAPI/cpp/grpc/include/absl/numeric/int128_have_intrinsic.inc b/CAPI/cpp/grpc/include/absl/numeric/int128_have_intrinsic.inc
new file mode 100644
index 0000000..3945fa2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/numeric/int128_have_intrinsic.inc
@@ -0,0 +1,296 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// This file contains :int128 implementation details that depend on internal
+// representation when ABSL_HAVE_INTRINSIC_INT128 is defined. This file is
+// included by int128.h and relies on ABSL_INTERNAL_WCHAR_T being defined.
+
+namespace int128_internal {
+
+// Casts from unsigned to signed while preserving the underlying binary
+// representation.
+constexpr __int128 BitCastToSigned(unsigned __int128 v) {
+  // Casting an unsigned integer to a signed integer of the same
+  // width is implementation defined behavior if the source value would not fit
+  // in the destination type. We step around it with a roundtrip bitwise not
+  // operation to make sure this function remains constexpr. Clang and GCC
+  // optimize this to a no-op on x86-64.
+  return v & (static_cast<unsigned __int128>(1) << 127)
+             ? ~static_cast<__int128>(~v)
+             : static_cast<__int128>(v);
+}
+
+}  // namespace int128_internal
+
+inline int128& int128::operator=(__int128 v) {
+  v_ = v;
+  return *this;
+}
+
+constexpr uint64_t Int128Low64(int128 v) {
+  return static_cast<uint64_t>(v.v_ & ~uint64_t{0});
+}
+
+constexpr int64_t Int128High64(int128 v) {
+  // Initially cast to unsigned to prevent a right shift on a negative value.
+  return int128_internal::BitCastToSigned(
+      static_cast<uint64_t>(static_cast<unsigned __int128>(v.v_) >> 64));
+}
+
+constexpr int128::int128(int64_t high, uint64_t low)
+    // Initially cast to unsigned to prevent a left shift that overflows.
+    : v_(int128_internal::BitCastToSigned(static_cast<unsigned __int128>(high)
+                                           << 64) |
+         low) {}
+
+
+constexpr int128::int128(int v) : v_{v} {}
+
+constexpr int128::int128(long v) : v_{v} {}       // NOLINT(runtime/int)
+
+constexpr int128::int128(long long v) : v_{v} {}  // NOLINT(runtime/int)
+
+constexpr int128::int128(__int128 v) : v_{v} {}
+
+constexpr int128::int128(unsigned int v) : v_{v} {}
+
+constexpr int128::int128(unsigned long v) : v_{v} {}  // NOLINT(runtime/int)
+
+// NOLINTNEXTLINE(runtime/int)
+constexpr int128::int128(unsigned long long v) : v_{v} {}
+
+constexpr int128::int128(unsigned __int128 v) : v_{static_cast<__int128>(v)} {}
+
+inline int128::int128(float v) {
+  v_ = static_cast<__int128>(v);
+}
+
+inline int128::int128(double v) {
+  v_ = static_cast<__int128>(v);
+}
+
+inline int128::int128(long double v) {
+  v_ = static_cast<__int128>(v);
+}
+
+constexpr int128::int128(uint128 v) : v_{static_cast<__int128>(v)} {}
+
+constexpr int128::operator bool() const { return static_cast<bool>(v_); }
+
+constexpr int128::operator char() const { return static_cast<char>(v_); }
+
+constexpr int128::operator signed char() const {
+  return static_cast<signed char>(v_);
+}
+
+constexpr int128::operator unsigned char() const {
+  return static_cast<unsigned char>(v_);
+}
+
+constexpr int128::operator char16_t() const {
+  return static_cast<char16_t>(v_);
+}
+
+constexpr int128::operator char32_t() const {
+  return static_cast<char32_t>(v_);
+}
+
+constexpr int128::operator ABSL_INTERNAL_WCHAR_T() const {
+  return static_cast<ABSL_INTERNAL_WCHAR_T>(v_);
+}
+
+constexpr int128::operator short() const {  // NOLINT(runtime/int)
+  return static_cast<short>(v_);            // NOLINT(runtime/int)
+}
+
+constexpr int128::operator unsigned short() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned short>(v_);            // NOLINT(runtime/int)
+}
+
+constexpr int128::operator int() const {
+  return static_cast<int>(v_);
+}
+
+constexpr int128::operator unsigned int() const {
+  return static_cast<unsigned int>(v_);
+}
+
+constexpr int128::operator long() const {  // NOLINT(runtime/int)
+  return static_cast<long>(v_);            // NOLINT(runtime/int)
+}
+
+constexpr int128::operator unsigned long() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned long>(v_);            // NOLINT(runtime/int)
+}
+
+constexpr int128::operator long long() const {  // NOLINT(runtime/int)
+  return static_cast<long long>(v_);            // NOLINT(runtime/int)
+}
+
+constexpr int128::operator unsigned long long() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned long long>(v_);            // NOLINT(runtime/int)
+}
+
+constexpr int128::operator __int128() const { return v_; }
+
+constexpr int128::operator unsigned __int128() const {
+  return static_cast<unsigned __int128>(v_);
+}
+
+// Clang on PowerPC sometimes produces incorrect __int128 to floating point
+// conversions. In that case, we do the conversion with a similar implementation
+// to the conversion operators in int128_no_intrinsic.inc.
+#if defined(__clang__) && !defined(__ppc64__)
+inline int128::operator float() const { return static_cast<float>(v_); }
+
+inline int128::operator double() const { return static_cast<double>(v_); }
+
+inline int128::operator long double() const {
+  return static_cast<long double>(v_);
+}
+
+#else  // Clang on PowerPC
+// Forward declaration for conversion operators to floating point types.
+constexpr int128 operator-(int128 v);
+constexpr bool operator!=(int128 lhs, int128 rhs);
+
+inline int128::operator float() const {
+  // We must convert the absolute value and then negate as needed, because
+  // floating point types are typically sign-magnitude. Otherwise, the
+  // difference between the high and low 64 bits when interpreted as two's
+  // complement overwhelms the precision of the mantissa.
+  //
+  // Also check to make sure we don't negate Int128Min()
+  return v_ < 0 && *this != Int128Min()
+             ? -static_cast<float>(-*this)
+             : static_cast<float>(Int128Low64(*this)) +
+                   std::ldexp(static_cast<float>(Int128High64(*this)), 64);
+}
+
+inline int128::operator double() const {
+  // See comment in int128::operator float() above.
+  return v_ < 0 && *this != Int128Min()
+             ? -static_cast<double>(-*this)
+             : static_cast<double>(Int128Low64(*this)) +
+                   std::ldexp(static_cast<double>(Int128High64(*this)), 64);
+}
+
+inline int128::operator long double() const {
+  // See comment in int128::operator float() above.
+  return v_ < 0 && *this != Int128Min()
+             ? -static_cast<long double>(-*this)
+             : static_cast<long double>(Int128Low64(*this)) +
+                   std::ldexp(static_cast<long double>(Int128High64(*this)),
+                              64);
+}
+#endif  // Clang on PowerPC
+
+// Comparison operators.
+
+constexpr bool operator==(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) == static_cast<__int128>(rhs);
+}
+
+constexpr bool operator!=(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) != static_cast<__int128>(rhs);
+}
+
+constexpr bool operator<(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) < static_cast<__int128>(rhs);
+}
+
+constexpr bool operator>(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) > static_cast<__int128>(rhs);
+}
+
+constexpr bool operator<=(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) <= static_cast<__int128>(rhs);
+}
+
+constexpr bool operator>=(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) >= static_cast<__int128>(rhs);
+}
+
+// Unary operators.
+
+constexpr int128 operator-(int128 v) { return -static_cast<__int128>(v); }
+
+constexpr bool operator!(int128 v) { return !static_cast<__int128>(v); }
+
+constexpr int128 operator~(int128 val) { return ~static_cast<__int128>(val); }
+
+// Arithmetic operators.
+
+constexpr int128 operator+(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) + static_cast<__int128>(rhs);
+}
+
+constexpr int128 operator-(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) - static_cast<__int128>(rhs);
+}
+
+inline int128 operator*(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) * static_cast<__int128>(rhs);
+}
+
+inline int128 operator/(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) / static_cast<__int128>(rhs);
+}
+
+inline int128 operator%(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) % static_cast<__int128>(rhs);
+}
+
+inline int128 int128::operator++(int) {
+  int128 tmp(*this);
+  ++v_;
+  return tmp;
+}
+
+inline int128 int128::operator--(int) {
+  int128 tmp(*this);
+  --v_;
+  return tmp;
+}
+
+inline int128& int128::operator++() {
+  ++v_;
+  return *this;
+}
+
+inline int128& int128::operator--() {
+  --v_;
+  return *this;
+}
+
+constexpr int128 operator|(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) | static_cast<__int128>(rhs);
+}
+
+constexpr int128 operator&(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) & static_cast<__int128>(rhs);
+}
+
+constexpr int128 operator^(int128 lhs, int128 rhs) {
+  return static_cast<__int128>(lhs) ^ static_cast<__int128>(rhs);
+}
+
+constexpr int128 operator<<(int128 lhs, int amount) {
+  return static_cast<__int128>(lhs) << amount;
+}
+
+constexpr int128 operator>>(int128 lhs, int amount) {
+  return static_cast<__int128>(lhs) >> amount;
+}
diff --git a/CAPI/cpp/grpc/include/absl/numeric/int128_no_intrinsic.inc b/CAPI/cpp/grpc/include/absl/numeric/int128_no_intrinsic.inc
new file mode 100644
index 0000000..8834804
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/numeric/int128_no_intrinsic.inc
@@ -0,0 +1,311 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+// This file contains :int128 implementation details that depend on internal
+// representation when ABSL_HAVE_INTRINSIC_INT128 is *not* defined. This file
+// is included by int128.h and relies on ABSL_INTERNAL_WCHAR_T being defined.
+
+constexpr uint64_t Int128Low64(int128 v) { return v.lo_; }
+
+constexpr int64_t Int128High64(int128 v) { return v.hi_; }
+
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+
+constexpr int128::int128(int64_t high, uint64_t low) :
+    lo_(low), hi_(high) {}
+
+constexpr int128::int128(int v)
+    : lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
+constexpr int128::int128(long v)  // NOLINT(runtime/int)
+    : lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
+constexpr int128::int128(long long v)  // NOLINT(runtime/int)
+    : lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
+
+constexpr int128::int128(unsigned int v) : lo_{v}, hi_{0} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr int128::int128(unsigned long v) : lo_{v}, hi_{0} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr int128::int128(unsigned long long v) : lo_{v}, hi_{0} {}
+
+constexpr int128::int128(uint128 v)
+    : lo_{Uint128Low64(v)}, hi_{static_cast<int64_t>(Uint128High64(v))} {}
+
+#elif defined(ABSL_IS_BIG_ENDIAN)
+
+constexpr int128::int128(int64_t high, uint64_t low) :
+    hi_{high}, lo_{low} {}
+
+constexpr int128::int128(int v)
+    : hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
+constexpr int128::int128(long v)  // NOLINT(runtime/int)
+    : hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
+constexpr int128::int128(long long v)  // NOLINT(runtime/int)
+    : hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
+
+constexpr int128::int128(unsigned int v) : hi_{0}, lo_{v} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr int128::int128(unsigned long v) : hi_{0}, lo_{v} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr int128::int128(unsigned long long v) : hi_{0}, lo_{v} {}
+
+constexpr int128::int128(uint128 v)
+    : hi_{static_cast<int64_t>(Uint128High64(v))}, lo_{Uint128Low64(v)} {}
+
+#else  // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif  // byte order
+
+constexpr int128::operator bool() const { return lo_ || hi_; }
+
+constexpr int128::operator char() const {
+  // NOLINTNEXTLINE(runtime/int)
+  return static_cast<char>(static_cast<long long>(*this));
+}
+
+constexpr int128::operator signed char() const {
+  // NOLINTNEXTLINE(runtime/int)
+  return static_cast<signed char>(static_cast<long long>(*this));
+}
+
+constexpr int128::operator unsigned char() const {
+  return static_cast<unsigned char>(lo_);
+}
+
+constexpr int128::operator char16_t() const {
+  return static_cast<char16_t>(lo_);
+}
+
+constexpr int128::operator char32_t() const {
+  return static_cast<char32_t>(lo_);
+}
+
+constexpr int128::operator ABSL_INTERNAL_WCHAR_T() const {
+  // NOLINTNEXTLINE(runtime/int)
+  return static_cast<ABSL_INTERNAL_WCHAR_T>(static_cast<long long>(*this));
+}
+
+constexpr int128::operator short() const {  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  return static_cast<short>(static_cast<long long>(*this));
+}
+
+constexpr int128::operator unsigned short() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned short>(lo_);           // NOLINT(runtime/int)
+}
+
+constexpr int128::operator int() const {
+  // NOLINTNEXTLINE(runtime/int)
+  return static_cast<int>(static_cast<long long>(*this));
+}
+
+constexpr int128::operator unsigned int() const {
+  return static_cast<unsigned int>(lo_);
+}
+
+constexpr int128::operator long() const {  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  return static_cast<long>(static_cast<long long>(*this));
+}
+
+constexpr int128::operator unsigned long() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned long>(lo_);           // NOLINT(runtime/int)
+}
+
+constexpr int128::operator long long() const {  // NOLINT(runtime/int)
+  // We don't bother checking the value of hi_. If *this < 0, lo_'s high bit
+  // must be set in order for the value to fit into a long long. Conversely, if
+  // lo_'s high bit is set, *this must be < 0 for the value to fit.
+  return int128_internal::BitCastToSigned(lo_);
+}
+
+constexpr int128::operator unsigned long long() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned long long>(lo_);           // NOLINT(runtime/int)
+}
+
+inline int128::operator float() const {
+  // We must convert the absolute value and then negate as needed, because
+  // floating point types are typically sign-magnitude. Otherwise, the
+  // difference between the high and low 64 bits when interpreted as two's
+  // complement overwhelms the precision of the mantissa.
+  //
+  // Also check to make sure we don't negate Int128Min()
+  return hi_ < 0 && *this != Int128Min()
+             ? -static_cast<float>(-*this)
+             : static_cast<float>(lo_) +
+                   std::ldexp(static_cast<float>(hi_), 64);
+}
+
+inline int128::operator double() const {
+  // See comment in int128::operator float() above.
+  return hi_ < 0 && *this != Int128Min()
+             ? -static_cast<double>(-*this)
+             : static_cast<double>(lo_) +
+                   std::ldexp(static_cast<double>(hi_), 64);
+}
+
+inline int128::operator long double() const {
+  // See comment in int128::operator float() above.
+  return hi_ < 0 && *this != Int128Min()
+             ? -static_cast<long double>(-*this)
+             : static_cast<long double>(lo_) +
+                   std::ldexp(static_cast<long double>(hi_), 64);
+}
+
+// Comparison operators.
+
+constexpr bool operator==(int128 lhs, int128 rhs) {
+  return (Int128Low64(lhs) == Int128Low64(rhs) &&
+          Int128High64(lhs) == Int128High64(rhs));
+}
+
+constexpr bool operator!=(int128 lhs, int128 rhs) { return !(lhs == rhs); }
+
+constexpr bool operator<(int128 lhs, int128 rhs) {
+  return (Int128High64(lhs) == Int128High64(rhs))
+             ? (Int128Low64(lhs) < Int128Low64(rhs))
+             : (Int128High64(lhs) < Int128High64(rhs));
+}
+
+constexpr bool operator>(int128 lhs, int128 rhs) {
+  return (Int128High64(lhs) == Int128High64(rhs))
+             ? (Int128Low64(lhs) > Int128Low64(rhs))
+             : (Int128High64(lhs) > Int128High64(rhs));
+}
+
+constexpr bool operator<=(int128 lhs, int128 rhs) { return !(lhs > rhs); }
+
+constexpr bool operator>=(int128 lhs, int128 rhs) { return !(lhs < rhs); }
+
+// Unary operators.
+
+constexpr int128 operator-(int128 v) {
+  return MakeInt128(~Int128High64(v) + (Int128Low64(v) == 0),
+                    ~Int128Low64(v) + 1);
+}
+
+constexpr bool operator!(int128 v) {
+  return !Int128Low64(v) && !Int128High64(v);
+}
+
+constexpr int128 operator~(int128 val) {
+  return MakeInt128(~Int128High64(val), ~Int128Low64(val));
+}
+
+// Arithmetic operators.
+
+namespace int128_internal {
+constexpr int128 SignedAddResult(int128 result, int128 lhs) {
+  // check for carry
+  return (Int128Low64(result) < Int128Low64(lhs))
+             ? MakeInt128(Int128High64(result) + 1, Int128Low64(result))
+             : result;
+}
+}  // namespace int128_internal
+constexpr int128 operator+(int128 lhs, int128 rhs) {
+  return int128_internal::SignedAddResult(
+      MakeInt128(Int128High64(lhs) + Int128High64(rhs),
+                 Int128Low64(lhs) + Int128Low64(rhs)),
+      lhs);
+}
+
+namespace int128_internal {
+constexpr int128 SignedSubstructResult(int128 result, int128 lhs, int128 rhs) {
+  // check for carry
+  return (Int128Low64(lhs) < Int128Low64(rhs))
+             ? MakeInt128(Int128High64(result) - 1, Int128Low64(result))
+             : result;
+}
+}  // namespace int128_internal
+constexpr int128 operator-(int128 lhs, int128 rhs) {
+  return int128_internal::SignedSubstructResult(
+      MakeInt128(Int128High64(lhs) - Int128High64(rhs),
+                 Int128Low64(lhs) - Int128Low64(rhs)),
+      lhs, rhs);
+}
+
+inline int128 operator*(int128 lhs, int128 rhs) {
+  return MakeInt128(
+      int128_internal::BitCastToSigned(Uint128High64(uint128(lhs) * rhs)),
+      Uint128Low64(uint128(lhs) * rhs));
+}
+
+inline int128 int128::operator++(int) {
+  int128 tmp(*this);
+  *this += 1;
+  return tmp;
+}
+
+inline int128 int128::operator--(int) {
+  int128 tmp(*this);
+  *this -= 1;
+  return tmp;
+}
+
+inline int128& int128::operator++() {
+  *this += 1;
+  return *this;
+}
+
+inline int128& int128::operator--() {
+  *this -= 1;
+  return *this;
+}
+
+constexpr int128 operator|(int128 lhs, int128 rhs) {
+  return MakeInt128(Int128High64(lhs) | Int128High64(rhs),
+                    Int128Low64(lhs) | Int128Low64(rhs));
+}
+
+constexpr int128 operator&(int128 lhs, int128 rhs) {
+  return MakeInt128(Int128High64(lhs) & Int128High64(rhs),
+                    Int128Low64(lhs) & Int128Low64(rhs));
+}
+
+constexpr int128 operator^(int128 lhs, int128 rhs) {
+  return MakeInt128(Int128High64(lhs) ^ Int128High64(rhs),
+                    Int128Low64(lhs) ^ Int128Low64(rhs));
+}
+
+constexpr int128 operator<<(int128 lhs, int amount) {
+  // int64_t shifts of >= 64 are undefined, so we need some special-casing.
+  return amount >= 64
+             ? MakeInt128(
+                   static_cast<int64_t>(Int128Low64(lhs) << (amount - 64)), 0)
+         : amount == 0
+             ? lhs
+             : MakeInt128(
+                   (Int128High64(lhs) << amount) |
+                       static_cast<int64_t>(Int128Low64(lhs) >> (64 - amount)),
+                   Int128Low64(lhs) << amount);
+}
+
+constexpr int128 operator>>(int128 lhs, int amount) {
+  // int64_t shifts of >= 64 are undefined, so we need some special-casing.
+  // The (Int128High64(lhs) >> 32) >> 32 "trick" causes the the most significant
+  // int64 to be inititialized with all zeros or all ones correctly. It takes
+  // into account whether the number is negative or positive, and whether the
+  // current architecture does arithmetic or logical right shifts for negative
+  // numbers.
+  return amount >= 64
+             ? MakeInt128(
+                   (Int128High64(lhs) >> 32) >> 32,
+                   static_cast<uint64_t>(Int128High64(lhs) >> (amount - 64)))
+         : amount == 0
+             ? lhs
+             : MakeInt128(Int128High64(lhs) >> amount,
+                          (Int128Low64(lhs) >> amount) |
+                              (static_cast<uint64_t>(Int128High64(lhs))
+                               << (64 - amount)));
+}
diff --git a/CAPI/cpp/grpc/include/absl/numeric/internal/bits.h b/CAPI/cpp/grpc/include/absl/numeric/internal/bits.h
new file mode 100644
index 0000000..bfef06b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/numeric/internal/bits.h
@@ -0,0 +1,358 @@
+// Copyright 2020 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_NUMERIC_INTERNAL_BITS_H_
+#define ABSL_NUMERIC_INTERNAL_BITS_H_
+
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+// Clang on Windows has __builtin_clzll; otherwise we need to use the
+// windows intrinsic functions.
+#if defined(_MSC_VER) && !defined(__clang__)
+#include <intrin.h>
+#endif
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+
+#if defined(__GNUC__) && !defined(__clang__)
+// GCC
+#define ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) 1
+#else
+#define ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) ABSL_HAVE_BUILTIN(x)
+#endif
+
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountl) && \
+    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
+#define ABSL_INTERNAL_CONSTEXPR_POPCOUNT constexpr
+#define ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 1
+#else
+#define ABSL_INTERNAL_CONSTEXPR_POPCOUNT
+#define ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 0
+#endif
+
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz) && \
+    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
+#define ABSL_INTERNAL_CONSTEXPR_CLZ constexpr
+#define ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 1
+#else
+#define ABSL_INTERNAL_CONSTEXPR_CLZ
+#define ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 0
+#endif
+
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz) && \
+    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
+#define ABSL_INTERNAL_CONSTEXPR_CTZ constexpr
+#define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 1
+#else
+#define ABSL_INTERNAL_CONSTEXPR_CTZ
+#define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 0
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace numeric_internal {
+
+constexpr bool IsPowerOf2(unsigned int x) noexcept {
+  return x != 0 && (x & (x - 1)) == 0;
+}
+
+template <class T>
+ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
+    T x, int s) noexcept {
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
+                "T must have a power-of-2 size");
+
+  return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) |
+         static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1)));
+}
+
+template <class T>
+ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
+    T x, int s) noexcept {
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
+                "T must have a power-of-2 size");
+
+  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
+         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+Popcount32(uint32_t x) noexcept {
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcount)
+  static_assert(sizeof(unsigned int) == sizeof(x),
+                "__builtin_popcount does not take 32-bit arg");
+  return __builtin_popcount(x);
+#else
+  x -= ((x >> 1) & 0x55555555);
+  x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
+  return static_cast<int>((((x + (x >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24);
+#endif
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+Popcount64(uint64_t x) noexcept {
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
+  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
+                "__builtin_popcount does not take 64-bit arg");
+  return __builtin_popcountll(x);
+#else
+  x -= (x >> 1) & 0x5555555555555555ULL;
+  x = ((x >> 2) & 0x3333333333333333ULL) + (x & 0x3333333333333333ULL);
+  return static_cast<int>(
+      (((x + (x >> 4)) & 0xF0F0F0F0F0F0F0FULL) * 0x101010101010101ULL) >> 56);
+#endif
+}
+
+template <class T>
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+Popcount(T x) noexcept {
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
+                "T must have a power-of-2 size");
+  static_assert(sizeof(x) <= sizeof(uint64_t), "T is too large");
+  return sizeof(x) <= sizeof(uint32_t) ? Popcount32(x) : Popcount64(x);
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+CountLeadingZeroes32(uint32_t x) {
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz)
+  // Use __builtin_clz, which uses the following instructions:
+  //  x86: bsr, lzcnt
+  //  ARM64: clz
+  //  PPC: cntlzd
+
+  static_assert(sizeof(unsigned int) == sizeof(x),
+                "__builtin_clz does not take 32-bit arg");
+  // Handle 0 as a special case because __builtin_clz(0) is undefined.
+  return x == 0 ? 32 : __builtin_clz(x);
+#elif defined(_MSC_VER) && !defined(__clang__)
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  if (_BitScanReverse(&result, x)) {
+    return 31 - result;
+  }
+  return 32;
+#else
+  int zeroes = 28;
+  if (x >> 16) {
+    zeroes -= 16;
+    x >>= 16;
+  }
+  if (x >> 8) {
+    zeroes -= 8;
+    x >>= 8;
+  }
+  if (x >> 4) {
+    zeroes -= 4;
+    x >>= 4;
+  }
+  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
+#endif
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+CountLeadingZeroes16(uint16_t x) {
+#if ABSL_HAVE_BUILTIN(__builtin_clzs)
+  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
+                "__builtin_clzs does not take 16-bit arg");
+  return x == 0 ? 16 : __builtin_clzs(x);
+#else
+  return CountLeadingZeroes32(x) - 16;
+#endif
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+CountLeadingZeroes64(uint64_t x) {
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
+  // Use __builtin_clzll, which uses the following instructions:
+  //  x86: bsr, lzcnt
+  //  ARM64: clz
+  //  PPC: cntlzd
+  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
+                "__builtin_clzll does not take 64-bit arg");
+
+  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
+  return x == 0 ? 64 : __builtin_clzll(x);
+#elif defined(_MSC_VER) && !defined(__clang__) && \
+    (defined(_M_X64) || defined(_M_ARM64))
+  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  if (_BitScanReverse64(&result, x)) {
+    return 63 - result;
+  }
+  return 64;
+#elif defined(_MSC_VER) && !defined(__clang__)
+  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  if ((x >> 32) &&
+      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
+    return 31 - result;
+  }
+  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
+    return 63 - result;
+  }
+  return 64;
+#else
+  int zeroes = 60;
+  if (x >> 32) {
+    zeroes -= 32;
+    x >>= 32;
+  }
+  if (x >> 16) {
+    zeroes -= 16;
+    x >>= 16;
+  }
+  if (x >> 8) {
+    zeroes -= 8;
+    x >>= 8;
+  }
+  if (x >> 4) {
+    zeroes -= 4;
+    x >>= 4;
+  }
+  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
+#endif
+}
+
+template <typename T>
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+CountLeadingZeroes(T x) {
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
+                "T must have a power-of-2 size");
+  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
+  return sizeof(T) <= sizeof(uint16_t)
+             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
+                   (std::numeric_limits<uint16_t>::digits -
+                    std::numeric_limits<T>::digits)
+             : (sizeof(T) <= sizeof(uint32_t)
+                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
+                          (std::numeric_limits<uint32_t>::digits -
+                           std::numeric_limits<T>::digits)
+                    : CountLeadingZeroes64(x));
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+CountTrailingZeroesNonzero32(uint32_t x) {
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
+  static_assert(sizeof(unsigned int) == sizeof(x),
+                "__builtin_ctz does not take 32-bit arg");
+  return __builtin_ctz(x);
+#elif defined(_MSC_VER) && !defined(__clang__)
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  _BitScanForward(&result, x);
+  return result;
+#else
+  int c = 31;
+  x &= ~x + 1;
+  if (x & 0x0000FFFF) c -= 16;
+  if (x & 0x00FF00FF) c -= 8;
+  if (x & 0x0F0F0F0F) c -= 4;
+  if (x & 0x33333333) c -= 2;
+  if (x & 0x55555555) c -= 1;
+  return c;
+#endif
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+CountTrailingZeroesNonzero64(uint64_t x) {
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
+  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
+                "__builtin_ctzll does not take 64-bit arg");
+  return __builtin_ctzll(x);
+#elif defined(_MSC_VER) && !defined(__clang__) && \
+    (defined(_M_X64) || defined(_M_ARM64))
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  _BitScanForward64(&result, x);
+  return result;
+#elif defined(_MSC_VER) && !defined(__clang__)
+  unsigned long result = 0;  // NOLINT(runtime/int)
+  if (static_cast<uint32_t>(x) == 0) {
+    _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
+    return result + 32;
+  }
+  _BitScanForward(&result, static_cast<unsigned long>(x));
+  return result;
+#else
+  int c = 63;
+  x &= ~x + 1;
+  if (x & 0x00000000FFFFFFFF) c -= 32;
+  if (x & 0x0000FFFF0000FFFF) c -= 16;
+  if (x & 0x00FF00FF00FF00FF) c -= 8;
+  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4;
+  if (x & 0x3333333333333333) c -= 2;
+  if (x & 0x5555555555555555) c -= 1;
+  return c;
+#endif
+}
+
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+CountTrailingZeroesNonzero16(uint16_t x) {
+#if ABSL_HAVE_BUILTIN(__builtin_ctzs)
+  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
+                "__builtin_ctzs does not take 16-bit arg");
+  return __builtin_ctzs(x);
+#else
+  return CountTrailingZeroesNonzero32(x);
+#endif
+}
+
+template <class T>
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+CountTrailingZeroes(T x) noexcept {
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
+                "T must have a power-of-2 size");
+  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
+  return x == 0 ? std::numeric_limits<T>::digits
+                : (sizeof(T) <= sizeof(uint16_t)
+                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
+                       : (sizeof(T) <= sizeof(uint32_t)
+                              ? CountTrailingZeroesNonzero32(
+                                    static_cast<uint32_t>(x))
+                              : CountTrailingZeroesNonzero64(x)));
+}
+
+// If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
+// want to force it to wraparound so that bit_ceil of an invalid value are not
+// core constant expressions.
+template <class T>
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type
+    BitCeilPromotionHelper(T x, T promotion) {
+  return (T{1} << (x + promotion)) >> promotion;
+}
+
+template <class T>
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type
+    BitCeilNonPowerOf2(T x) {
+  // If T is narrower than unsigned, it undergoes promotion to unsigned when we
+  // shift.  We calculate the number of bits added by the wider type.
+  return BitCeilPromotionHelper(
+      static_cast<T>(std::numeric_limits<T>::digits - CountLeadingZeroes(x)),
+      T{sizeof(T) >= sizeof(unsigned) ? 0
+                                      : std::numeric_limits<unsigned>::digits -
+                                            std::numeric_limits<T>::digits});
+}
+
+}  // namespace numeric_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_NUMERIC_INTERNAL_BITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/numeric/internal/representation.h b/CAPI/cpp/grpc/include/absl/numeric/internal/representation.h
new file mode 100644
index 0000000..82d332f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/numeric/internal/representation.h
@@ -0,0 +1,55 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
+#define ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
+
+#include <limits>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace numeric_internal {
+
+// Returns true iff long double is represented as a pair of doubles added
+// together.
+inline constexpr bool IsDoubleDouble() {
+  // A double-double value always has exactly twice the precision of a double
+  // value--one double carries the high digits and one double carries the low
+  // digits. This property is not shared with any other common floating-point
+  // representation, so this test won't trigger false positives. For reference,
+  // this table gives the number of bits of precision of each common
+  // floating-point representation:
+  //
+  //                type     precision
+  //         IEEE single          24 b
+  //         IEEE double          53
+  //     x86 long double          64
+  //       double-double         106
+  //      IEEE quadruple         113
+  //
+  // Note in particular that a quadruple-precision float has greater precision
+  // than a double-double float despite taking up the same amount of memory; the
+  // quad has more of its bits allocated to the mantissa than the double-double
+  // has.
+  return std::numeric_limits<long double>::digits ==
+         2 * std::numeric_limits<double>::digits;
+}
+
+}  // namespace numeric_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
diff --git a/CAPI/cpp/grpc/include/absl/profiling/internal/exponential_biased.h b/CAPI/cpp/grpc/include/absl/profiling/internal/exponential_biased.h
new file mode 100644
index 0000000..d31f778
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/profiling/internal/exponential_biased.h
@@ -0,0 +1,130 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
+#define ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
+
+#include <stdint.h>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace profiling_internal {
+
+// ExponentialBiased provides a small and fast random number generator for a
+// rounded exponential distribution. This generator manages very little state,
+// and imposes no synchronization overhead. This makes it useful in specialized
+// scenarios requiring minimum overhead, such as stride based periodic sampling.
+//
+// ExponentialBiased provides two closely related functions, GetSkipCount() and
+// GetStride(), both returning a rounded integer defining a number of events
+// required before some event with a given mean probability occurs.
+//
+// The distribution is useful to generate a random wait time or some periodic
+// event with a given mean probability. For example, if an action is supposed to
+// happen on average once every 'N' events, then we can get a random 'stride'
+// counting down how long before the event to happen. For example, if we'd want
+// to sample one in every 1000 'Frobber' calls, our code could look like this:
+//
+//   Frobber::Frobber() {
+//     stride_ = exponential_biased_.GetStride(1000);
+//   }
+//
+//   void Frobber::Frob(int arg) {
+//     if (--stride == 0) {
+//       SampleFrob(arg);
+//       stride_ = exponential_biased_.GetStride(1000);
+//     }
+//     ...
+//   }
+//
+// The rounding of the return value creates a bias, especially for smaller means
+// where the distribution of the fraction is not evenly distributed. We correct
+// this bias by tracking the fraction we rounded up or down on each iteration,
+// effectively tracking the distance between the cumulative value, and the
+// rounded cumulative value. For example, given a mean of 2:
+//
+//   raw = 1.63076, cumulative = 1.63076, rounded = 2, bias = -0.36923
+//   raw = 0.14624, cumulative = 1.77701, rounded = 2, bias =  0.14624
+//   raw = 4.93194, cumulative = 6.70895, rounded = 7, bias = -0.06805
+//   raw = 0.24206, cumulative = 6.95101, rounded = 7, bias =  0.24206
+//   etc...
+//
+// Adjusting with rounding bias is relatively trivial:
+//
+//    double value = bias_ + exponential_distribution(mean)();
+//    double rounded_value = std::rint(value);
+//    bias_ = value - rounded_value;
+//    return rounded_value;
+//
+// This class is thread-compatible.
+class ExponentialBiased {
+ public:
+  // The number of bits set by NextRandom.
+  static constexpr int kPrngNumBits = 48;
+
+  // `GetSkipCount()` returns the number of events to skip before some chosen
+  // event happens. For example, randomly tossing a coin, we will on average
+  // throw heads once before we get tails. We can simulate random coin tosses
+  // using GetSkipCount() as:
+  //
+  //   ExponentialBiased eb;
+  //   for (...) {
+  //     int number_of_heads_before_tail = eb.GetSkipCount(1);
+  //     for (int flips = 0; flips < number_of_heads_before_tail; ++flips) {
+  //       printf("head...");
+  //     }
+  //     printf("tail\n");
+  //   }
+  //
+  int64_t GetSkipCount(int64_t mean);
+
+  // GetStride() returns the number of events required for a specific event to
+  // happen. See the class comments for a usage example. `GetStride()` is
+  // equivalent to `GetSkipCount(mean - 1) + 1`. When to use `GetStride()` or
+  // `GetSkipCount()` depends mostly on what best fits the use case.
+  int64_t GetStride(int64_t mean);
+
+  // Computes a random number in the range [0, 1<<(kPrngNumBits+1) - 1]
+  //
+  // This is public to enable testing.
+  static uint64_t NextRandom(uint64_t rnd);
+
+ private:
+  void Initialize();
+
+  uint64_t rng_{0};
+  double bias_{0};
+  bool initialized_{false};
+};
+
+// Returns the next prng value.
+// pRNG is: aX+b mod c with a = 0x5DEECE66D, b =  0xB, c = 1<<48
+// This is the lrand64 generator.
+inline uint64_t ExponentialBiased::NextRandom(uint64_t rnd) {
+  const uint64_t prng_mult = uint64_t{0x5DEECE66D};
+  const uint64_t prng_add = 0xB;
+  const uint64_t prng_mod_power = 48;
+  const uint64_t prng_mod_mask =
+      ~((~static_cast<uint64_t>(0)) << prng_mod_power);
+  return (prng_mult * rnd + prng_add) & prng_mod_mask;
+}
+
+}  // namespace profiling_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
diff --git a/CAPI/cpp/grpc/include/absl/profiling/internal/periodic_sampler.h b/CAPI/cpp/grpc/include/absl/profiling/internal/periodic_sampler.h
new file mode 100644
index 0000000..54f0af4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/profiling/internal/periodic_sampler.h
@@ -0,0 +1,211 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
+#define ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
+
+#include <stdint.h>
+
+#include <atomic>
+
+#include "absl/base/optimization.h"
+#include "absl/profiling/internal/exponential_biased.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace profiling_internal {
+
+// PeriodicSamplerBase provides the basic period sampler implementation.
+//
+// This is the base class for the templated PeriodicSampler class, which holds
+// a global std::atomic value identified by a user defined tag, such that
+// each specific PeriodSampler implementation holds its own global period.
+//
+// PeriodicSamplerBase is thread-compatible except where stated otherwise.
+class PeriodicSamplerBase {
+ public:
+  // PeriodicSamplerBase is trivial / copyable / movable / destructible.
+  PeriodicSamplerBase() = default;
+  PeriodicSamplerBase(PeriodicSamplerBase&&) = default;
+  PeriodicSamplerBase(const PeriodicSamplerBase&) = default;
+
+  // Returns true roughly once every `period` calls. This is established by a
+  // randomly picked `stride` that is counted down on each call to `Sample`.
+  // This stride is picked such that the probability of `Sample()` returning
+  // true is 1 in `period`.
+  inline bool Sample() noexcept;
+
+  // The below methods are intended for optimized use cases where the
+  // size of the inlined fast path code is highly important. Applications
+  // should use the `Sample()` method unless they have proof that their
+  // specific use case requires the optimizations offered by these methods.
+  //
+  // An example of such a use case is SwissTable sampling. All sampling checks
+  // are in inlined SwissTable methods, and the number of call sites is huge.
+  // In this case, the inlined code size added to each translation unit calling
+  // SwissTable methods is non-trivial.
+  //
+  // The `SubtleMaybeSample()` function spuriously returns true even if the
+  // function should not be sampled, applications MUST match each call to
+  // 'SubtleMaybeSample()' returning true with a `SubtleConfirmSample()` call,
+  // and use the result of the latter as the sampling decision.
+  // In other words: the code should logically be equivalent to:
+  //
+  //    if (SubtleMaybeSample() && SubtleConfirmSample()) {
+  //      // Sample this call
+  //    }
+  //
+  // In the 'inline-size' optimized case, the `SubtleConfirmSample()` call can
+  // be placed out of line, for example, the typical use case looks as follows:
+  //
+  //   // --- frobber.h -----------
+  //   void FrobberSampled();
+  //
+  //   inline void FrobberImpl() {
+  //     // ...
+  //   }
+  //
+  //   inline void Frobber() {
+  //     if (ABSL_PREDICT_FALSE(sampler.SubtleMaybeSample())) {
+  //       FrobberSampled();
+  //     } else {
+  //       FrobberImpl();
+  //     }
+  //   }
+  //
+  //   // --- frobber.cc -----------
+  //   void FrobberSampled() {
+  //     if (!sampler.SubtleConfirmSample())) {
+  //       // Spurious false positive
+  //       FrobberImpl();
+  //       return;
+  //     }
+  //
+  //     // Sampled execution
+  //     // ...
+  //   }
+  inline bool SubtleMaybeSample() noexcept;
+  bool SubtleConfirmSample() noexcept;
+
+ protected:
+  // We explicitly don't use a virtual destructor as this class is never
+  // virtually destroyed, and it keeps the class trivial, which avoids TLS
+  // prologue and epilogue code for our TLS instances.
+  ~PeriodicSamplerBase() = default;
+
+  // Returns the next stride for our sampler.
+  // This function is virtual for testing purposes only.
+  virtual int64_t GetExponentialBiased(int period) noexcept;
+
+ private:
+  // Returns the current period of this sampler. Thread-safe.
+  virtual int period() const noexcept = 0;
+
+  // Keep and decrement stride_ as an unsigned integer, but compare the value
+  // to zero casted as a signed int. clang and msvc do not create optimum code
+  // if we use signed for the combined decrement and sign comparison.
+  //
+  // Below 3 alternative options, all compiles generate the best code
+  // using the unsigned increment <---> signed int comparison option.
+  //
+  // Option 1:
+  //   int64_t stride_;
+  //   if (ABSL_PREDICT_TRUE(++stride_ < 0)) { ... }
+  //
+  //   GCC   x64 (OK) : https://gcc.godbolt.org/z/R5MzzA
+  //   GCC   ppc (OK) : https://gcc.godbolt.org/z/z7NZAt
+  //   Clang x64 (BAD): https://gcc.godbolt.org/z/t4gPsd
+  //   ICC   x64 (OK) : https://gcc.godbolt.org/z/rE6s8W
+  //   MSVC  x64 (OK) : https://gcc.godbolt.org/z/ARMXqS
+  //
+  // Option 2:
+  //   int64_t stride_ = 0;
+  //   if (ABSL_PREDICT_TRUE(--stride_ >= 0)) { ... }
+  //
+  //   GCC   x64 (OK) : https://gcc.godbolt.org/z/jSQxYK
+  //   GCC   ppc (OK) : https://gcc.godbolt.org/z/VJdYaA
+  //   Clang x64 (BAD): https://gcc.godbolt.org/z/Xm4NjX
+  //   ICC   x64 (OK) : https://gcc.godbolt.org/z/4snaFd
+  //   MSVC  x64 (BAD): https://gcc.godbolt.org/z/BgnEKE
+  //
+  // Option 3:
+  //   uint64_t stride_;
+  //   if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) { ... }
+  //
+  //   GCC   x64 (OK) : https://gcc.godbolt.org/z/bFbfPy
+  //   GCC   ppc (OK) : https://gcc.godbolt.org/z/S9KkUE
+  //   Clang x64 (OK) : https://gcc.godbolt.org/z/UYzRb4
+  //   ICC   x64 (OK) : https://gcc.godbolt.org/z/ptTNfD
+  //   MSVC  x64 (OK) : https://gcc.godbolt.org/z/76j4-5
+  uint64_t stride_ = 0;
+  absl::profiling_internal::ExponentialBiased rng_;
+};
+
+inline bool PeriodicSamplerBase::SubtleMaybeSample() noexcept {
+  // See comments on `stride_` for the unsigned increment / signed compare.
+  if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) {
+    return false;
+  }
+  return true;
+}
+
+inline bool PeriodicSamplerBase::Sample() noexcept {
+  return ABSL_PREDICT_FALSE(SubtleMaybeSample()) ? SubtleConfirmSample()
+                                                 : false;
+}
+
+// PeriodicSampler is a concreted periodic sampler implementation.
+// The user provided Tag identifies the implementation, and is required to
+// isolate the global state of this instance from other instances.
+//
+// Typical use case:
+//
+//   struct HashTablezTag {};
+//   thread_local PeriodicSampler sampler;
+//
+//   void HashTableSamplingLogic(...) {
+//     if (sampler.Sample()) {
+//       HashTableSlowSamplePath(...);
+//     }
+//   }
+//
+template <typename Tag, int default_period = 0>
+class PeriodicSampler final : public PeriodicSamplerBase {
+ public:
+  ~PeriodicSampler() = default;
+
+  int period() const noexcept final {
+    return period_.load(std::memory_order_relaxed);
+  }
+
+  // Sets the global period for this sampler. Thread-safe.
+  // Setting a period of 0 disables the sampler, i.e., every call to Sample()
+  // will return false. Setting a period of 1 puts the sampler in 'always on'
+  // mode, i.e., every call to Sample() returns true.
+  static void SetGlobalPeriod(int period) {
+    period_.store(period, std::memory_order_relaxed);
+  }
+
+ private:
+  static std::atomic<int> period_;
+};
+
+template <typename Tag, int default_period>
+std::atomic<int> PeriodicSampler<Tag, default_period>::period_(default_period);
+
+}  // namespace profiling_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
diff --git a/CAPI/cpp/grpc/include/absl/profiling/internal/sample_recorder.h b/CAPI/cpp/grpc/include/absl/profiling/internal/sample_recorder.h
new file mode 100644
index 0000000..5f65983
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/profiling/internal/sample_recorder.h
@@ -0,0 +1,245 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: sample_recorder.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a lock-free linked list for recording samples
+// collected from a random/stochastic process.
+//
+// This utility is internal-only. Use at your own risk.
+
+#ifndef ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
+#define ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
+
+#include <atomic>
+#include <cstddef>
+#include <functional>
+
+#include "absl/base/config.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace profiling_internal {
+
+// Sample<T> that has members required for linking samples in the linked list of
+// samples maintained by the SampleRecorder.  Type T defines the sampled data.
+template <typename T>
+struct Sample {
+  // Guards the ability to restore the sample to a pristine state.  This
+  // prevents races with sampling and resurrecting an object.
+  absl::Mutex init_mu;
+  T* next = nullptr;
+  T* dead ABSL_GUARDED_BY(init_mu) = nullptr;
+  int64_t weight;  // How many sampling events were required to sample this one.
+};
+
+// Holds samples and their associated stack traces with a soft limit of
+// `SetHashtablezMaxSamples()`.
+//
+// Thread safe.
+template <typename T>
+class SampleRecorder {
+ public:
+  SampleRecorder();
+  ~SampleRecorder();
+
+  // Registers for sampling.  Returns an opaque registration info.
+  template <typename... Targs>
+  T* Register(Targs&&... args);
+
+  // Unregisters the sample.
+  void Unregister(T* sample);
+
+  // The dispose callback will be called on all samples the moment they are
+  // being unregistered. Only affects samples that are unregistered after the
+  // callback has been set.
+  // Returns the previous callback.
+  using DisposeCallback = void (*)(const T&);
+  DisposeCallback SetDisposeCallback(DisposeCallback f);
+
+  // Iterates over all the registered `StackInfo`s.  Returning the number of
+  // samples that have been dropped.
+  int64_t Iterate(const std::function<void(const T& stack)>& f);
+
+  int32_t GetMaxSamples() const;
+  void SetMaxSamples(int32_t max);
+
+ private:
+  void PushNew(T* sample);
+  void PushDead(T* sample);
+  template <typename... Targs>
+  T* PopDead(Targs... args);
+
+  std::atomic<size_t> dropped_samples_;
+  std::atomic<size_t> size_estimate_;
+  std::atomic<int32_t> max_samples_{1 << 20};
+
+  // Intrusive lock free linked lists for tracking samples.
+  //
+  // `all_` records all samples (they are never removed from this list) and is
+  // terminated with a `nullptr`.
+  //
+  // `graveyard_.dead` is a circular linked list.  When it is empty,
+  // `graveyard_.dead == &graveyard`.  The list is circular so that
+  // every item on it (even the last) has a non-null dead pointer.  This allows
+  // `Iterate` to determine if a given sample is live or dead using only
+  // information on the sample itself.
+  //
+  // For example, nodes [A, B, C, D, E] with [A, C, E] alive and [B, D] dead
+  // looks like this (G is the Graveyard):
+  //
+  //           +---+    +---+    +---+    +---+    +---+
+  //    all -->| A |--->| B |--->| C |--->| D |--->| E |
+  //           |   |    |   |    |   |    |   |    |   |
+  //   +---+   |   | +->|   |-+  |   | +->|   |-+  |   |
+  //   | G |   +---+ |  +---+ |  +---+ |  +---+ |  +---+
+  //   |   |         |        |        |        |
+  //   |   | --------+        +--------+        |
+  //   +---+                                    |
+  //     ^                                      |
+  //     +--------------------------------------+
+  //
+  std::atomic<T*> all_;
+  T graveyard_;
+
+  std::atomic<DisposeCallback> dispose_;
+};
+
+template <typename T>
+typename SampleRecorder<T>::DisposeCallback
+SampleRecorder<T>::SetDisposeCallback(DisposeCallback f) {
+  return dispose_.exchange(f, std::memory_order_relaxed);
+}
+
+template <typename T>
+SampleRecorder<T>::SampleRecorder()
+    : dropped_samples_(0), size_estimate_(0), all_(nullptr), dispose_(nullptr) {
+  absl::MutexLock l(&graveyard_.init_mu);
+  graveyard_.dead = &graveyard_;
+}
+
+template <typename T>
+SampleRecorder<T>::~SampleRecorder() {
+  T* s = all_.load(std::memory_order_acquire);
+  while (s != nullptr) {
+    T* next = s->next;
+    delete s;
+    s = next;
+  }
+}
+
+template <typename T>
+void SampleRecorder<T>::PushNew(T* sample) {
+  sample->next = all_.load(std::memory_order_relaxed);
+  while (!all_.compare_exchange_weak(sample->next, sample,
+                                     std::memory_order_release,
+                                     std::memory_order_relaxed)) {
+  }
+}
+
+template <typename T>
+void SampleRecorder<T>::PushDead(T* sample) {
+  if (auto* dispose = dispose_.load(std::memory_order_relaxed)) {
+    dispose(*sample);
+  }
+
+  absl::MutexLock graveyard_lock(&graveyard_.init_mu);
+  absl::MutexLock sample_lock(&sample->init_mu);
+  sample->dead = graveyard_.dead;
+  graveyard_.dead = sample;
+}
+
+template <typename T>
+template <typename... Targs>
+T* SampleRecorder<T>::PopDead(Targs... args) {
+  absl::MutexLock graveyard_lock(&graveyard_.init_mu);
+
+  // The list is circular, so eventually it collapses down to
+  //   graveyard_.dead == &graveyard_
+  // when it is empty.
+  T* sample = graveyard_.dead;
+  if (sample == &graveyard_) return nullptr;
+
+  absl::MutexLock sample_lock(&sample->init_mu);
+  graveyard_.dead = sample->dead;
+  sample->dead = nullptr;
+  sample->PrepareForSampling(std::forward<Targs>(args)...);
+  return sample;
+}
+
+template <typename T>
+template <typename... Targs>
+T* SampleRecorder<T>::Register(Targs&&... args) {
+  int64_t size = size_estimate_.fetch_add(1, std::memory_order_relaxed);
+  if (size > max_samples_.load(std::memory_order_relaxed)) {
+    size_estimate_.fetch_sub(1, std::memory_order_relaxed);
+    dropped_samples_.fetch_add(1, std::memory_order_relaxed);
+    return nullptr;
+  }
+
+  T* sample = PopDead(args...);
+  if (sample == nullptr) {
+    // Resurrection failed.  Hire a new warlock.
+    sample = new T();
+    {
+      absl::MutexLock sample_lock(&sample->init_mu);
+      sample->PrepareForSampling(std::forward<Targs>(args)...);
+    }
+    PushNew(sample);
+  }
+
+  return sample;
+}
+
+template <typename T>
+void SampleRecorder<T>::Unregister(T* sample) {
+  PushDead(sample);
+  size_estimate_.fetch_sub(1, std::memory_order_relaxed);
+}
+
+template <typename T>
+int64_t SampleRecorder<T>::Iterate(
+    const std::function<void(const T& stack)>& f) {
+  T* s = all_.load(std::memory_order_acquire);
+  while (s != nullptr) {
+    absl::MutexLock l(&s->init_mu);
+    if (s->dead == nullptr) {
+      f(*s);
+    }
+    s = s->next;
+  }
+
+  return dropped_samples_.load(std::memory_order_relaxed);
+}
+
+template <typename T>
+void SampleRecorder<T>::SetMaxSamples(int32_t max) {
+  max_samples_.store(max, std::memory_order_release);
+}
+
+template <typename T>
+int32_t SampleRecorder<T>::GetMaxSamples() const {
+  return max_samples_.load(std::memory_order_acquire);
+}
+
+}  // namespace profiling_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/bernoulli_distribution.h b/CAPI/cpp/grpc/include/absl/random/bernoulli_distribution.h
new file mode 100644
index 0000000..d81b6ae
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/bernoulli_distribution.h
@@ -0,0 +1,200 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_BERNOULLI_DISTRIBUTION_H_
+#define ABSL_RANDOM_BERNOULLI_DISTRIBUTION_H_
+
+#include <cstdint>
+#include <istream>
+#include <limits>
+
+#include "absl/base/optimization.h"
+#include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/iostream_state_saver.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::bernoulli_distribution is a drop in replacement for
+// std::bernoulli_distribution. It guarantees that (given a perfect
+// UniformRandomBitGenerator) the acceptance probability is *exactly* equal to
+// the given double.
+//
+// The implementation assumes that double is IEEE754
+class bernoulli_distribution {
+ public:
+  using result_type = bool;
+
+  class param_type {
+   public:
+    using distribution_type = bernoulli_distribution;
+
+    explicit param_type(double p = 0.5) : prob_(p) {
+      assert(p >= 0.0 && p <= 1.0);
+    }
+
+    double p() const { return prob_; }
+
+    friend bool operator==(const param_type& p1, const param_type& p2) {
+      return p1.p() == p2.p();
+    }
+    friend bool operator!=(const param_type& p1, const param_type& p2) {
+      return p1.p() != p2.p();
+    }
+
+   private:
+    double prob_;
+  };
+
+  bernoulli_distribution() : bernoulli_distribution(0.5) {}
+
+  explicit bernoulli_distribution(double p) : param_(p) {}
+
+  explicit bernoulli_distribution(param_type p) : param_(p) {}
+
+  // no-op
+  void reset() {}
+
+  template <typename URBG>
+  bool operator()(URBG& g) {  // NOLINT(runtime/references)
+    return Generate(param_.p(), g);
+  }
+
+  template <typename URBG>
+  bool operator()(URBG& g,  // NOLINT(runtime/references)
+                  const param_type& param) {
+    return Generate(param.p(), g);
+  }
+
+  param_type param() const { return param_; }
+  void param(const param_type& param) { param_ = param; }
+
+  double p() const { return param_.p(); }
+
+  result_type(min)() const { return false; }
+  result_type(max)() const { return true; }
+
+  friend bool operator==(const bernoulli_distribution& d1,
+                         const bernoulli_distribution& d2) {
+    return d1.param_ == d2.param_;
+  }
+
+  friend bool operator!=(const bernoulli_distribution& d1,
+                         const bernoulli_distribution& d2) {
+    return d1.param_ != d2.param_;
+  }
+
+ private:
+  static constexpr uint64_t kP32 = static_cast<uint64_t>(1) << 32;
+
+  template <typename URBG>
+  static bool Generate(double p, URBG& g);  // NOLINT(runtime/references)
+
+  param_type param_;
+};
+
+template <typename CharT, typename Traits>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const bernoulli_distribution& x) {
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os.precision(random_internal::stream_precision_helper<double>::kPrecision);
+  os << x.p();
+  return os;
+}
+
+template <typename CharT, typename Traits>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+    bernoulli_distribution& x) {            // NOLINT(runtime/references)
+  auto saver = random_internal::make_istream_state_saver(is);
+  auto p = random_internal::read_floating_point<double>(is);
+  if (!is.fail()) {
+    x.param(bernoulli_distribution::param_type(p));
+  }
+  return is;
+}
+
+template <typename URBG>
+bool bernoulli_distribution::Generate(double p,
+                                      URBG& g) {  // NOLINT(runtime/references)
+  random_internal::FastUniformBits<uint32_t> fast_u32;
+
+  while (true) {
+    // There are two aspects of the definition of `c` below that are worth
+    // commenting on.  First, because `p` is in the range [0, 1], `c` is in the
+    // range [0, 2^32] which does not fit in a uint32_t and therefore requires
+    // 64 bits.
+    //
+    // Second, `c` is constructed by first casting explicitly to a signed
+    // integer and then casting explicitly to an unsigned integer of the same
+    // size.  This is done because the hardware conversion instructions produce
+    // signed integers from double; if taken as a uint64_t the conversion would
+    // be wrong for doubles greater than 2^63 (not relevant in this use-case).
+    // If converted directly to an unsigned integer, the compiler would end up
+    // emitting code to handle such large values that are not relevant due to
+    // the known bounds on `c`.  To avoid these extra instructions this
+    // implementation converts first to the signed type and then convert to
+    // unsigned (which is a no-op).
+    const uint64_t c = static_cast<uint64_t>(static_cast<int64_t>(p * kP32));
+    const uint32_t v = fast_u32(g);
+    // FAST PATH: this path fails with probability 1/2^32.  Note that simply
+    // returning v <= c would approximate P very well (up to an absolute error
+    // of 1/2^32); the slow path (taken in that range of possible error, in the
+    // case of equality) eliminates the remaining error.
+    if (ABSL_PREDICT_TRUE(v != c)) return v < c;
+
+    // It is guaranteed that `q` is strictly less than 1, because if `q` were
+    // greater than or equal to 1, the same would be true for `p`. Certainly `p`
+    // cannot be greater than 1, and if `p == 1`, then the fast path would
+    // necessary have been taken already.
+    const double q = static_cast<double>(c) / kP32;
+
+    // The probability of acceptance on the fast path is `q` and so the
+    // probability of acceptance here should be `p - q`.
+    //
+    // Note that `q` is obtained from `p` via some shifts and conversions, the
+    // upshot of which is that `q` is simply `p` with some of the
+    // least-significant bits of its mantissa set to zero. This means that the
+    // difference `p - q` will not have any rounding errors. To see why, pretend
+    // that double has 10 bits of resolution and q is obtained from `p` in such
+    // a way that the 4 least-significant bits of its mantissa are set to zero.
+    // For example:
+    //   p   = 1.1100111011 * 2^-1
+    //   q   = 1.1100110000 * 2^-1
+    // p - q = 1.011        * 2^-8
+    // The difference `p - q` has exactly the nonzero mantissa bits that were
+    // "lost" in `q` producing a number which is certainly representable in a
+    // double.
+    const double left = p - q;
+
+    // By construction, the probability of being on this slow path is 1/2^32, so
+    // P(accept in slow path) = P(accept| in slow path) * P(slow path),
+    // which means the probability of acceptance here is `1 / (left * kP32)`:
+    const double here = left * kP32;
+
+    // The simplest way to compute the result of this trial is to repeat the
+    // whole algorithm with the new probability. This terminates because even
+    // given  arbitrarily unfriendly "random" bits, each iteration either
+    // multiplies a tiny probability by 2^32 (if c == 0) or strips off some
+    // number of nonzero mantissa bits. That process is bounded.
+    if (here == 0) return false;
+    p = here;
+  }
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_BERNOULLI_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/beta_distribution.h b/CAPI/cpp/grpc/include/absl/random/beta_distribution.h
new file mode 100644
index 0000000..c154066
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/beta_distribution.h
@@ -0,0 +1,427 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_BETA_DISTRIBUTION_H_
+#define ABSL_RANDOM_BETA_DISTRIBUTION_H_
+
+#include <cassert>
+#include <cmath>
+#include <istream>
+#include <limits>
+#include <ostream>
+#include <type_traits>
+
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/generate_real.h"
+#include "absl/random/internal/iostream_state_saver.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::beta_distribution:
+// Generate a floating-point variate conforming to a Beta distribution:
+//   pdf(x) \propto x^(alpha-1) * (1-x)^(beta-1),
+// where the params alpha and beta are both strictly positive real values.
+//
+// The support is the open interval (0, 1), but the return value might be equal
+// to 0 or 1, due to numerical errors when alpha and beta are very different.
+//
+// Usage note: One usage is that alpha and beta are counts of number of
+// successes and failures. When the total number of trials are large, consider
+// approximating a beta distribution with a Gaussian distribution with the same
+// mean and variance. One could use the skewness, which depends only on the
+// smaller of alpha and beta when the number of trials are sufficiently large,
+// to quantify how far a beta distribution is from the normal distribution.
+template <typename RealType = double>
+class beta_distribution {
+ public:
+  using result_type = RealType;
+
+  class param_type {
+   public:
+    using distribution_type = beta_distribution;
+
+    explicit param_type(result_type alpha, result_type beta)
+        : alpha_(alpha), beta_(beta) {
+      assert(alpha >= 0);
+      assert(beta >= 0);
+      assert(alpha <= (std::numeric_limits<result_type>::max)());
+      assert(beta <= (std::numeric_limits<result_type>::max)());
+      if (alpha == 0 || beta == 0) {
+        method_ = DEGENERATE_SMALL;
+        x_ = (alpha >= beta) ? 1 : 0;
+        return;
+      }
+      // a_ = min(beta, alpha), b_ = max(beta, alpha).
+      if (beta < alpha) {
+        inverted_ = true;
+        a_ = beta;
+        b_ = alpha;
+      } else {
+        inverted_ = false;
+        a_ = alpha;
+        b_ = beta;
+      }
+      if (a_ <= 1 && b_ >= ThresholdForLargeA()) {
+        method_ = DEGENERATE_SMALL;
+        x_ = inverted_ ? result_type(1) : result_type(0);
+        return;
+      }
+      // For threshold values, see also:
+      // Evaluation of Beta Generation Algorithms, Ying-Chao Hung, et. al.
+      // February, 2009.
+      if ((b_ < 1.0 && a_ + b_ <= 1.2) || a_ <= ThresholdForSmallA()) {
+        // Choose Joehnk over Cheng when it's faster or when Cheng encounters
+        // numerical issues.
+        method_ = JOEHNK;
+        a_ = result_type(1) / alpha_;
+        b_ = result_type(1) / beta_;
+        if (std::isinf(a_) || std::isinf(b_)) {
+          method_ = DEGENERATE_SMALL;
+          x_ = inverted_ ? result_type(1) : result_type(0);
+        }
+        return;
+      }
+      if (a_ >= ThresholdForLargeA()) {
+        method_ = DEGENERATE_LARGE;
+        // Note: on PPC for long double, evaluating
+        // `std::numeric_limits::max() / ThresholdForLargeA` results in NaN.
+        result_type r = a_ / b_;
+        x_ = (inverted_ ? result_type(1) : r) / (1 + r);
+        return;
+      }
+      x_ = a_ + b_;
+      log_x_ = std::log(x_);
+      if (a_ <= 1) {
+        method_ = CHENG_BA;
+        y_ = result_type(1) / a_;
+        gamma_ = a_ + a_;
+        return;
+      }
+      method_ = CHENG_BB;
+      result_type r = (a_ - 1) / (b_ - 1);
+      y_ = std::sqrt((1 + r) / (b_ * r * 2 - r + 1));
+      gamma_ = a_ + result_type(1) / y_;
+    }
+
+    result_type alpha() const { return alpha_; }
+    result_type beta() const { return beta_; }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.alpha_ == b.alpha_ && a.beta_ == b.beta_;
+    }
+
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class beta_distribution;
+
+#ifdef _MSC_VER
+    // MSVC does not have constexpr implementations for std::log and std::exp
+    // so they are computed at runtime.
+#define ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR
+#else
+#define ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR constexpr
+#endif
+
+    // The threshold for whether std::exp(1/a) is finite.
+    // Note that this value is quite large, and a smaller a_ is NOT abnormal.
+    static ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR result_type
+    ThresholdForSmallA() {
+      return result_type(1) /
+             std::log((std::numeric_limits<result_type>::max)());
+    }
+
+    // The threshold for whether a * std::log(a) is finite.
+    static ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR result_type
+    ThresholdForLargeA() {
+      return std::exp(
+          std::log((std::numeric_limits<result_type>::max)()) -
+          std::log(std::log((std::numeric_limits<result_type>::max)())) -
+          ThresholdPadding());
+    }
+
+#undef ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR
+
+    // Pad the threshold for large A for long double on PPC. This is done via a
+    // template specialization below.
+    static constexpr result_type ThresholdPadding() { return 0; }
+
+    enum Method {
+      JOEHNK,    // Uses algorithm Joehnk
+      CHENG_BA,  // Uses algorithm BA in Cheng
+      CHENG_BB,  // Uses algorithm BB in Cheng
+
+      // Note: See also:
+      //   Hung et al. Evaluation of beta generation algorithms. Communications
+      //   in Statistics-Simulation and Computation 38.4 (2009): 750-770.
+      // especially:
+      //   Zechner, Heinz, and Ernst Stadlober. Generating beta variates via
+      //   patchwork rejection. Computing 50.1 (1993): 1-18.
+
+      DEGENERATE_SMALL,  // a_ is abnormally small.
+      DEGENERATE_LARGE,  // a_ is abnormally large.
+    };
+
+    result_type alpha_;
+    result_type beta_;
+
+    result_type a_;  // the smaller of {alpha, beta}, or 1.0/alpha_ in JOEHNK
+    result_type b_;  // the larger of {alpha, beta}, or 1.0/beta_ in JOEHNK
+    result_type x_;  // alpha + beta, or the result in degenerate cases
+    result_type log_x_;  // log(x_)
+    result_type y_;      // "beta" in Cheng
+    result_type gamma_;  // "gamma" in Cheng
+
+    Method method_;
+
+    // Placing this last for optimal alignment.
+    // Whether alpha_ != a_, i.e. true iff alpha_ > beta_.
+    bool inverted_;
+
+    static_assert(std::is_floating_point<RealType>::value,
+                  "Class-template absl::beta_distribution<> must be "
+                  "parameterized using a floating-point type.");
+  };
+
+  beta_distribution() : beta_distribution(1) {}
+
+  explicit beta_distribution(result_type alpha, result_type beta = 1)
+      : param_(alpha, beta) {}
+
+  explicit beta_distribution(const param_type& p) : param_(p) {}
+
+  void reset() {}
+
+  // Generating functions
+  template <typename URBG>
+  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
+    return (*this)(g, param_);
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                         const param_type& p);
+
+  param_type param() const { return param_; }
+  void param(const param_type& p) { param_ = p; }
+
+  result_type(min)() const { return 0; }
+  result_type(max)() const { return 1; }
+
+  result_type alpha() const { return param_.alpha(); }
+  result_type beta() const { return param_.beta(); }
+
+  friend bool operator==(const beta_distribution& a,
+                         const beta_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const beta_distribution& a,
+                         const beta_distribution& b) {
+    return a.param_ != b.param_;
+  }
+
+ private:
+  template <typename URBG>
+  result_type AlgorithmJoehnk(URBG& g,  // NOLINT(runtime/references)
+                              const param_type& p);
+
+  template <typename URBG>
+  result_type AlgorithmCheng(URBG& g,  // NOLINT(runtime/references)
+                             const param_type& p);
+
+  template <typename URBG>
+  result_type DegenerateCase(URBG& g,  // NOLINT(runtime/references)
+                             const param_type& p) {
+    if (p.method_ == param_type::DEGENERATE_SMALL && p.alpha_ == p.beta_) {
+      // Returns 0 or 1 with equal probability.
+      random_internal::FastUniformBits<uint8_t> fast_u8;
+      return static_cast<result_type>((fast_u8(g) & 0x10) !=
+                                      0);  // pick any single bit.
+    }
+    return p.x_;
+  }
+
+  param_type param_;
+  random_internal::FastUniformBits<uint64_t> fast_u64_;
+};
+
+#if defined(__powerpc64__) || defined(__PPC64__) || defined(__powerpc__) || \
+    defined(__ppc__) || defined(__PPC__)
+// PPC needs a more stringent boundary for long double.
+template <>
+constexpr long double
+beta_distribution<long double>::param_type::ThresholdPadding() {
+  return 10;
+}
+#endif
+
+template <typename RealType>
+template <typename URBG>
+typename beta_distribution<RealType>::result_type
+beta_distribution<RealType>::AlgorithmJoehnk(
+    URBG& g,  // NOLINT(runtime/references)
+    const param_type& p) {
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using real_type =
+      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+  // Based on Joehnk, M. D. Erzeugung von betaverteilten und gammaverteilten
+  // Zufallszahlen. Metrika 8.1 (1964): 5-15.
+  // This method is described in Knuth, Vol 2 (Third Edition), pp 134.
+
+  result_type u, v, x, y, z;
+  for (;;) {
+    u = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+        fast_u64_(g));
+    v = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+        fast_u64_(g));
+
+    // Direct method. std::pow is slow for float, so rely on the optimizer to
+    // remove the std::pow() path for that case.
+    if (!std::is_same<float, result_type>::value) {
+      x = std::pow(u, p.a_);
+      y = std::pow(v, p.b_);
+      z = x + y;
+      if (z > 1) {
+        // Reject if and only if `x + y > 1.0`
+        continue;
+      }
+      if (z > 0) {
+        // When both alpha and beta are small, x and y are both close to 0, so
+        // divide by (x+y) directly may result in nan.
+        return x / z;
+      }
+    }
+
+    // Log transform.
+    // x = log( pow(u, p.a_) ), y = log( pow(v, p.b_) )
+    // since u, v <= 1.0,  x, y < 0.
+    x = std::log(u) * p.a_;
+    y = std::log(v) * p.b_;
+    if (!std::isfinite(x) || !std::isfinite(y)) {
+      continue;
+    }
+    // z = log( pow(u, a) + pow(v, b) )
+    z = x > y ? (x + std::log(1 + std::exp(y - x)))
+              : (y + std::log(1 + std::exp(x - y)));
+    // Reject iff log(x+y) > 0.
+    if (z > 0) {
+      continue;
+    }
+    return std::exp(x - z);
+  }
+}
+
+template <typename RealType>
+template <typename URBG>
+typename beta_distribution<RealType>::result_type
+beta_distribution<RealType>::AlgorithmCheng(
+    URBG& g,  // NOLINT(runtime/references)
+    const param_type& p) {
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using real_type =
+      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+  // Based on Cheng, Russell CH. Generating beta variates with nonintegral
+  // shape parameters. Communications of the ACM 21.4 (1978): 317-322.
+  // (https://dl.acm.org/citation.cfm?id=359482).
+  static constexpr result_type kLogFour =
+      result_type(1.3862943611198906188344642429163531361);  // log(4)
+  static constexpr result_type kS =
+      result_type(2.6094379124341003746007593332261876);  // 1+log(5)
+
+  const bool use_algorithm_ba = (p.method_ == param_type::CHENG_BA);
+  result_type u1, u2, v, w, z, r, s, t, bw_inv, lhs;
+  for (;;) {
+    u1 = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+        fast_u64_(g));
+    u2 = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+        fast_u64_(g));
+    v = p.y_ * std::log(u1 / (1 - u1));
+    w = p.a_ * std::exp(v);
+    bw_inv = result_type(1) / (p.b_ + w);
+    r = p.gamma_ * v - kLogFour;
+    s = p.a_ + r - w;
+    z = u1 * u1 * u2;
+    if (!use_algorithm_ba && s + kS >= 5 * z) {
+      break;
+    }
+    t = std::log(z);
+    if (!use_algorithm_ba && s >= t) {
+      break;
+    }
+    lhs = p.x_ * (p.log_x_ + std::log(bw_inv)) + r;
+    if (lhs >= t) {
+      break;
+    }
+  }
+  return p.inverted_ ? (1 - w * bw_inv) : w * bw_inv;
+}
+
+template <typename RealType>
+template <typename URBG>
+typename beta_distribution<RealType>::result_type
+beta_distribution<RealType>::operator()(URBG& g,  // NOLINT(runtime/references)
+                                        const param_type& p) {
+  switch (p.method_) {
+    case param_type::JOEHNK:
+      return AlgorithmJoehnk(g, p);
+    case param_type::CHENG_BA:
+      ABSL_FALLTHROUGH_INTENDED;
+    case param_type::CHENG_BB:
+      return AlgorithmCheng(g, p);
+    default:
+      return DegenerateCase(g, p);
+  }
+}
+
+template <typename CharT, typename Traits, typename RealType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const beta_distribution<RealType>& x) {
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
+  os << x.alpha() << os.fill() << x.beta();
+  return os;
+}
+
+template <typename CharT, typename Traits, typename RealType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+    beta_distribution<RealType>& x) {       // NOLINT(runtime/references)
+  using result_type = typename beta_distribution<RealType>::result_type;
+  using param_type = typename beta_distribution<RealType>::param_type;
+  result_type alpha, beta;
+
+  auto saver = random_internal::make_istream_state_saver(is);
+  alpha = random_internal::read_floating_point<result_type>(is);
+  if (is.fail()) return is;
+  beta = random_internal::read_floating_point<result_type>(is);
+  if (!is.fail()) {
+    x.param(param_type(alpha, beta));
+  }
+  return is;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_BETA_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/bit_gen_ref.h b/CAPI/cpp/grpc/include/absl/random/bit_gen_ref.h
new file mode 100644
index 0000000..e475221
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/bit_gen_ref.h
@@ -0,0 +1,185 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: bit_gen_ref.h
+// -----------------------------------------------------------------------------
+//
+// This header defines a bit generator "reference" class, for use in interfaces
+// that take both Abseil (e.g. `absl::BitGen`) and standard library (e.g.
+// `std::mt19937`) bit generators.
+
+#ifndef ABSL_RANDOM_BIT_GEN_REF_H_
+#define ABSL_RANDOM_BIT_GEN_REF_H_
+
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/fast_type_id.h"
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/distribution_caller.h"
+#include "absl/random/internal/fast_uniform_bits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+template <typename URBG, typename = void, typename = void, typename = void>
+struct is_urbg : std::false_type {};
+
+template <typename URBG>
+struct is_urbg<
+    URBG,
+    absl::enable_if_t<std::is_same<
+        typename URBG::result_type,
+        typename std::decay<decltype((URBG::min)())>::type>::value>,
+    absl::enable_if_t<std::is_same<
+        typename URBG::result_type,
+        typename std::decay<decltype((URBG::max)())>::type>::value>,
+    absl::enable_if_t<std::is_same<
+        typename URBG::result_type,
+        typename std::decay<decltype(std::declval<URBG>()())>::type>::value>>
+    : std::true_type {};
+
+template <typename>
+struct DistributionCaller;
+class MockHelpers;
+
+}  // namespace random_internal
+
+// -----------------------------------------------------------------------------
+// absl::BitGenRef
+// -----------------------------------------------------------------------------
+//
+// `absl::BitGenRef` is a type-erasing class that provides a generator-agnostic
+// non-owning "reference" interface for use in place of any specific uniform
+// random bit generator (URBG). This class may be used for both Abseil
+// (e.g. `absl::BitGen`, `absl::InsecureBitGen`) and Standard library (e.g
+// `std::mt19937`, `std::minstd_rand`) bit generators.
+//
+// Like other reference classes, `absl::BitGenRef` does not own the
+// underlying bit generator, and the underlying instance must outlive the
+// `absl::BitGenRef`.
+//
+// `absl::BitGenRef` is particularly useful when used with an
+// `absl::MockingBitGen` to test specific paths in functions which use random
+// values.
+//
+// Example:
+//    void TakesBitGenRef(absl::BitGenRef gen) {
+//      int x = absl::Uniform<int>(gen, 0, 1000);
+//    }
+//
+class BitGenRef {
+  // SFINAE to detect whether the URBG type includes a member matching
+  // bool InvokeMock(base_internal::FastTypeIdType, void*, void*).
+  //
+  // These live inside BitGenRef so that they have friend access
+  // to MockingBitGen. (see similar methods in DistributionCaller).
+  template <template <class...> class Trait, class AlwaysVoid, class... Args>
+  struct detector : std::false_type {};
+  template <template <class...> class Trait, class... Args>
+  struct detector<Trait, absl::void_t<Trait<Args...>>, Args...>
+      : std::true_type {};
+
+  template <class T>
+  using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
+      std::declval<base_internal::FastTypeIdType>(), std::declval<void*>(),
+      std::declval<void*>()));
+
+  template <typename T>
+  using HasInvokeMock = typename detector<invoke_mock_t, void, T>::type;
+
+ public:
+  BitGenRef(const BitGenRef&) = default;
+  BitGenRef(BitGenRef&&) = default;
+  BitGenRef& operator=(const BitGenRef&) = default;
+  BitGenRef& operator=(BitGenRef&&) = default;
+
+  template <typename URBG, typename absl::enable_if_t<
+                               (!std::is_same<URBG, BitGenRef>::value &&
+                                random_internal::is_urbg<URBG>::value &&
+                                !HasInvokeMock<URBG>::value)>* = nullptr>
+  BitGenRef(URBG& gen)  // NOLINT
+      : t_erased_gen_ptr_(reinterpret_cast<uintptr_t>(&gen)),
+        mock_call_(NotAMock),
+        generate_impl_fn_(ImplFn<URBG>) {}
+
+  template <typename URBG,
+            typename absl::enable_if_t<(!std::is_same<URBG, BitGenRef>::value &&
+                                        random_internal::is_urbg<URBG>::value &&
+                                        HasInvokeMock<URBG>::value)>* = nullptr>
+  BitGenRef(URBG& gen)  // NOLINT
+      : t_erased_gen_ptr_(reinterpret_cast<uintptr_t>(&gen)),
+        mock_call_(&MockCall<URBG>),
+        generate_impl_fn_(ImplFn<URBG>) {}
+
+  using result_type = uint64_t;
+
+  static constexpr result_type(min)() {
+    return (std::numeric_limits<result_type>::min)();
+  }
+
+  static constexpr result_type(max)() {
+    return (std::numeric_limits<result_type>::max)();
+  }
+
+  result_type operator()() { return generate_impl_fn_(t_erased_gen_ptr_); }
+
+ private:
+  using impl_fn = result_type (*)(uintptr_t);
+  using mock_call_fn = bool (*)(uintptr_t, base_internal::FastTypeIdType, void*,
+                                void*);
+
+  template <typename URBG>
+  static result_type ImplFn(uintptr_t ptr) {
+    // Ensure that the return values from operator() fill the entire
+    // range promised by result_type, min() and max().
+    absl::random_internal::FastUniformBits<result_type> fast_uniform_bits;
+    return fast_uniform_bits(*reinterpret_cast<URBG*>(ptr));
+  }
+
+  // Get a type-erased InvokeMock pointer.
+  template <typename URBG>
+  static bool MockCall(uintptr_t gen_ptr, base_internal::FastTypeIdType type,
+                       void* result, void* arg_tuple) {
+    return reinterpret_cast<URBG*>(gen_ptr)->InvokeMock(type, result,
+                                                        arg_tuple);
+  }
+  static bool NotAMock(uintptr_t, base_internal::FastTypeIdType, void*, void*) {
+    return false;
+  }
+
+  inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple,
+                         void* result) {
+    if (mock_call_ == NotAMock) return false;  // avoids an indirect call.
+    return mock_call_(t_erased_gen_ptr_, type, args_tuple, result);
+  }
+
+  uintptr_t t_erased_gen_ptr_;
+  mock_call_fn mock_call_;
+  impl_fn generate_impl_fn_;
+
+  template <typename>
+  friend struct ::absl::random_internal::DistributionCaller;  // for InvokeMock
+  friend class ::absl::random_internal::MockHelpers;          // for InvokeMock
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_BIT_GEN_REF_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/discrete_distribution.h b/CAPI/cpp/grpc/include/absl/random/discrete_distribution.h
new file mode 100644
index 0000000..171aa11
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/discrete_distribution.h
@@ -0,0 +1,247 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_DISCRETE_DISTRIBUTION_H_
+#define ABSL_RANDOM_DISCRETE_DISTRIBUTION_H_
+
+#include <cassert>
+#include <cmath>
+#include <istream>
+#include <limits>
+#include <numeric>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/random/bernoulli_distribution.h"
+#include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/uniform_int_distribution.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::discrete_distribution
+//
+// A discrete distribution produces random integers i, where 0 <= i < n
+// distributed according to the discrete probability function:
+//
+//     P(i|p0,...,pn−1)=pi
+//
+// This class is an implementation of discrete_distribution (see
+// [rand.dist.samp.discrete]).
+//
+// The algorithm used is Walker's Aliasing algorithm, described in Knuth, Vol 2.
+// absl::discrete_distribution takes O(N) time to precompute the probabilities
+// (where N is the number of possible outcomes in the distribution) at
+// construction, and then takes O(1) time for each variate generation.  Many
+// other implementations also take O(N) time to construct an ordered sequence of
+// partial sums, plus O(log N) time per variate to binary search.
+//
+template <typename IntType = int>
+class discrete_distribution {
+ public:
+  using result_type = IntType;
+
+  class param_type {
+   public:
+    using distribution_type = discrete_distribution;
+
+    param_type() { init(); }
+
+    template <typename InputIterator>
+    explicit param_type(InputIterator begin, InputIterator end)
+        : p_(begin, end) {
+      init();
+    }
+
+    explicit param_type(std::initializer_list<double> weights) : p_(weights) {
+      init();
+    }
+
+    template <class UnaryOperation>
+    explicit param_type(size_t nw, double xmin, double xmax,
+                        UnaryOperation fw) {
+      if (nw > 0) {
+        p_.reserve(nw);
+        double delta = (xmax - xmin) / static_cast<double>(nw);
+        assert(delta > 0);
+        double t = delta * 0.5;
+        for (size_t i = 0; i < nw; ++i) {
+          p_.push_back(fw(xmin + i * delta + t));
+        }
+      }
+      init();
+    }
+
+    const std::vector<double>& probabilities() const { return p_; }
+    size_t n() const { return p_.size() - 1; }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.probabilities() == b.probabilities();
+    }
+
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class discrete_distribution;
+
+    void init();
+
+    std::vector<double> p_;                     // normalized probabilities
+    std::vector<std::pair<double, size_t>> q_;  // (acceptance, alternate) pairs
+
+    static_assert(std::is_integral<result_type>::value,
+                  "Class-template absl::discrete_distribution<> must be "
+                  "parameterized using an integral type.");
+  };
+
+  discrete_distribution() : param_() {}
+
+  explicit discrete_distribution(const param_type& p) : param_(p) {}
+
+  template <typename InputIterator>
+  explicit discrete_distribution(InputIterator begin, InputIterator end)
+      : param_(begin, end) {}
+
+  explicit discrete_distribution(std::initializer_list<double> weights)
+      : param_(weights) {}
+
+  template <class UnaryOperation>
+  explicit discrete_distribution(size_t nw, double xmin, double xmax,
+                                 UnaryOperation fw)
+      : param_(nw, xmin, xmax, std::move(fw)) {}
+
+  void reset() {}
+
+  // generating functions
+  template <typename URBG>
+  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
+    return (*this)(g, param_);
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                         const param_type& p);
+
+  const param_type& param() const { return param_; }
+  void param(const param_type& p) { param_ = p; }
+
+  result_type(min)() const { return 0; }
+  result_type(max)() const {
+    return static_cast<result_type>(param_.n());
+  }  // inclusive
+
+  // NOTE [rand.dist.sample.discrete] returns a std::vector<double> not a
+  // const std::vector<double>&.
+  const std::vector<double>& probabilities() const {
+    return param_.probabilities();
+  }
+
+  friend bool operator==(const discrete_distribution& a,
+                         const discrete_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const discrete_distribution& a,
+                         const discrete_distribution& b) {
+    return a.param_ != b.param_;
+  }
+
+ private:
+  param_type param_;
+};
+
+// --------------------------------------------------------------------------
+// Implementation details only below
+// --------------------------------------------------------------------------
+
+namespace random_internal {
+
+// Using the vector `*probabilities`, whose values are the weights or
+// probabilities of an element being selected, constructs the proportional
+// probabilities used by the discrete distribution.  `*probabilities` will be
+// scaled, if necessary, so that its entries sum to a value sufficiently close
+// to 1.0.
+std::vector<std::pair<double, size_t>> InitDiscreteDistribution(
+    std::vector<double>* probabilities);
+
+}  // namespace random_internal
+
+template <typename IntType>
+void discrete_distribution<IntType>::param_type::init() {
+  if (p_.empty()) {
+    p_.push_back(1.0);
+    q_.emplace_back(1.0, 0);
+  } else {
+    assert(n() <= (std::numeric_limits<IntType>::max)());
+    q_ = random_internal::InitDiscreteDistribution(&p_);
+  }
+}
+
+template <typename IntType>
+template <typename URBG>
+typename discrete_distribution<IntType>::result_type
+discrete_distribution<IntType>::operator()(
+    URBG& g,  // NOLINT(runtime/references)
+    const param_type& p) {
+  const auto idx = absl::uniform_int_distribution<result_type>(0, p.n())(g);
+  const auto& q = p.q_[idx];
+  const bool selected = absl::bernoulli_distribution(q.first)(g);
+  return selected ? idx : static_cast<result_type>(q.second);
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const discrete_distribution<IntType>& x) {
+  auto saver = random_internal::make_ostream_state_saver(os);
+  const auto& probabilities = x.param().probabilities();
+  os << probabilities.size();
+
+  os.precision(random_internal::stream_precision_helper<double>::kPrecision);
+  for (const auto& p : probabilities) {
+    os << os.fill() << p;
+  }
+  return os;
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+    discrete_distribution<IntType>& x) {    // NOLINT(runtime/references)
+  using param_type = typename discrete_distribution<IntType>::param_type;
+  auto saver = random_internal::make_istream_state_saver(is);
+
+  size_t n;
+  std::vector<double> p;
+
+  is >> n;
+  if (is.fail()) return is;
+  if (n > 0) {
+    p.reserve(n);
+    for (IntType i = 0; i < n && !is.fail(); ++i) {
+      auto tmp = random_internal::read_floating_point<double>(is);
+      if (is.fail()) return is;
+      p.push_back(tmp);
+    }
+  }
+  x.param(param_type(p.begin(), p.end()));
+  return is;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_DISCRETE_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/distributions.h b/CAPI/cpp/grpc/include/absl/random/distributions.h
new file mode 100644
index 0000000..37fc3aa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/distributions.h
@@ -0,0 +1,452 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: distributions.h
+// -----------------------------------------------------------------------------
+//
+// This header defines functions representing distributions, which you use in
+// combination with an Abseil random bit generator to produce random values
+// according to the rules of that distribution.
+//
+// The Abseil random library defines the following distributions within this
+// file:
+//
+//   * `absl::Uniform` for uniform (constant) distributions having constant
+//     probability
+//   * `absl::Bernoulli` for discrete distributions having exactly two outcomes
+//   * `absl::Beta` for continuous distributions parameterized through two
+//     free parameters
+//   * `absl::Exponential` for discrete distributions of events occurring
+//     continuously and independently at a constant average rate
+//   * `absl::Gaussian` (also known as "normal distributions") for continuous
+//     distributions using an associated quadratic function
+//   * `absl::LogUniform` for continuous uniform distributions where the log
+//     to the given base of all values is uniform
+//   * `absl::Poisson` for discrete probability distributions that express the
+//     probability of a given number of events occurring within a fixed interval
+//   * `absl::Zipf` for discrete probability distributions commonly used for
+//     modelling of rare events
+//
+// Prefer use of these distribution function classes over manual construction of
+// your own distribution classes, as it allows library maintainers greater
+// flexibility to change the underlying implementation in the future.
+
+#ifndef ABSL_RANDOM_DISTRIBUTIONS_H_
+#define ABSL_RANDOM_DISTRIBUTIONS_H_
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <random>
+#include <type_traits>
+
+#include "absl/base/internal/inline_variable.h"
+#include "absl/random/bernoulli_distribution.h"
+#include "absl/random/beta_distribution.h"
+#include "absl/random/exponential_distribution.h"
+#include "absl/random/gaussian_distribution.h"
+#include "absl/random/internal/distribution_caller.h"  // IWYU pragma: export
+#include "absl/random/internal/uniform_helper.h"  // IWYU pragma: export
+#include "absl/random/log_uniform_int_distribution.h"
+#include "absl/random/poisson_distribution.h"
+#include "absl/random/uniform_int_distribution.h"
+#include "absl/random/uniform_real_distribution.h"
+#include "absl/random/zipf_distribution.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedClosedTag, IntervalClosedClosed,
+                               {});
+ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedClosedTag, IntervalClosed, {});
+ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedOpenTag, IntervalClosedOpen, {});
+ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenOpenTag, IntervalOpenOpen, {});
+ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenOpenTag, IntervalOpen, {});
+ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenClosedTag, IntervalOpenClosed, {});
+
+// -----------------------------------------------------------------------------
+// absl::Uniform<T>(tag, bitgen, lo, hi)
+// -----------------------------------------------------------------------------
+//
+// `absl::Uniform()` produces random values of type `T` uniformly distributed in
+// a defined interval {lo, hi}. The interval `tag` defines the type of interval
+// which should be one of the following possible values:
+//
+//   * `absl::IntervalOpenOpen`
+//   * `absl::IntervalOpenClosed`
+//   * `absl::IntervalClosedOpen`
+//   * `absl::IntervalClosedClosed`
+//
+// where "open" refers to an exclusive value (excluded) from the output, while
+// "closed" refers to an inclusive value (included) from the output.
+//
+// In the absence of an explicit return type `T`, `absl::Uniform()` will deduce
+// the return type based on the provided endpoint arguments {A lo, B hi}.
+// Given these endpoints, one of {A, B} will be chosen as the return type, if
+// a type can be implicitly converted into the other in a lossless way. The
+// lack of any such implicit conversion between {A, B} will produce a
+// compile-time error
+//
+// See https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+//
+// Example:
+//
+//   absl::BitGen bitgen;
+//
+//   // Produce a random float value between 0.0 and 1.0, inclusive
+//   auto x = absl::Uniform(absl::IntervalClosedClosed, bitgen, 0.0f, 1.0f);
+//
+//   // The most common interval of `absl::IntervalClosedOpen` is available by
+//   // default:
+//
+//   auto x = absl::Uniform(bitgen, 0.0f, 1.0f);
+//
+//   // Return-types are typically inferred from the arguments, however callers
+//   // can optionally provide an explicit return-type to the template.
+//
+//   auto x = absl::Uniform<float>(bitgen, 0, 1);
+//
+template <typename R = void, typename TagType, typename URBG>
+typename absl::enable_if_t<!std::is_same<R, void>::value, R>  //
+Uniform(TagType tag,
+        URBG&& urbg,  // NOLINT(runtime/references)
+        R lo, R hi) {
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = random_internal::UniformDistributionWrapper<R>;
+
+  auto a = random_internal::uniform_lower_bound(tag, lo, hi);
+  auto b = random_internal::uniform_upper_bound(tag, lo, hi);
+  if (!random_internal::is_uniform_range_valid(a, b)) return lo;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, tag, lo, hi);
+}
+
+// absl::Uniform<T>(bitgen, lo, hi)
+//
+// Overload of `Uniform()` using the default closed-open interval of [lo, hi),
+// and returning values of type `T`
+template <typename R = void, typename URBG>
+typename absl::enable_if_t<!std::is_same<R, void>::value, R>  //
+Uniform(URBG&& urbg,  // NOLINT(runtime/references)
+        R lo, R hi) {
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = random_internal::UniformDistributionWrapper<R>;
+  constexpr auto tag = absl::IntervalClosedOpen;
+
+  auto a = random_internal::uniform_lower_bound(tag, lo, hi);
+  auto b = random_internal::uniform_upper_bound(tag, lo, hi);
+  if (!random_internal::is_uniform_range_valid(a, b)) return lo;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, lo, hi);
+}
+
+// absl::Uniform(tag, bitgen, lo, hi)
+//
+// Overload of `Uniform()` using different (but compatible) lo, hi types. Note
+// that a compile-error will result if the return type cannot be deduced
+// correctly from the passed types.
+template <typename R = void, typename TagType, typename URBG, typename A,
+          typename B>
+typename absl::enable_if_t<std::is_same<R, void>::value,
+                           random_internal::uniform_inferred_return_t<A, B>>
+Uniform(TagType tag,
+        URBG&& urbg,  // NOLINT(runtime/references)
+        A lo, B hi) {
+  using gen_t = absl::decay_t<URBG>;
+  using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
+  using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
+
+  auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
+  auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
+  if (!random_internal::is_uniform_range_valid(a, b)) return lo;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, tag, static_cast<return_t>(lo),
+                                static_cast<return_t>(hi));
+}
+
+// absl::Uniform(bitgen, lo, hi)
+//
+// Overload of `Uniform()` using different (but compatible) lo, hi types and the
+// default closed-open interval of [lo, hi). Note that a compile-error will
+// result if the return type cannot be deduced correctly from the passed types.
+template <typename R = void, typename URBG, typename A, typename B>
+typename absl::enable_if_t<std::is_same<R, void>::value,
+                           random_internal::uniform_inferred_return_t<A, B>>
+Uniform(URBG&& urbg,  // NOLINT(runtime/references)
+        A lo, B hi) {
+  using gen_t = absl::decay_t<URBG>;
+  using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
+  using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
+
+  constexpr auto tag = absl::IntervalClosedOpen;
+  auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
+  auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
+  if (!random_internal::is_uniform_range_valid(a, b)) return lo;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, static_cast<return_t>(lo),
+                                static_cast<return_t>(hi));
+}
+
+// absl::Uniform<unsigned T>(bitgen)
+//
+// Overload of Uniform() using the minimum and maximum values of a given type
+// `T` (which must be unsigned), returning a value of type `unsigned T`
+template <typename R, typename URBG>
+typename absl::enable_if_t<!std::is_signed<R>::value, R>  //
+Uniform(URBG&& urbg) {  // NOLINT(runtime/references)
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = random_internal::UniformDistributionWrapper<R>;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg);
+}
+
+// -----------------------------------------------------------------------------
+// absl::Bernoulli(bitgen, p)
+// -----------------------------------------------------------------------------
+//
+// `absl::Bernoulli` produces a random boolean value, with probability `p`
+// (where 0.0 <= p <= 1.0) equaling `true`.
+//
+// Prefer `absl::Bernoulli` to produce boolean values over other alternatives
+// such as comparing an `absl::Uniform()` value to a specific output.
+//
+// See https://en.wikipedia.org/wiki/Bernoulli_distribution
+//
+// Example:
+//
+//   absl::BitGen bitgen;
+//   ...
+//   if (absl::Bernoulli(bitgen, 1.0/3721.0)) {
+//     std::cout << "Asteroid field navigation successful.";
+//   }
+//
+template <typename URBG>
+bool Bernoulli(URBG&& urbg,  // NOLINT(runtime/references)
+               double p) {
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = absl::bernoulli_distribution;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, p);
+}
+
+// -----------------------------------------------------------------------------
+// absl::Beta<T>(bitgen, alpha, beta)
+// -----------------------------------------------------------------------------
+//
+// `absl::Beta` produces a floating point number distributed in the closed
+// interval [0,1] and parameterized by two values `alpha` and `beta` as per a
+// Beta distribution. `T` must be a floating point type, but may be inferred
+// from the types of `alpha` and `beta`.
+//
+// See https://en.wikipedia.org/wiki/Beta_distribution.
+//
+// Example:
+//
+//   absl::BitGen bitgen;
+//   ...
+//   double sample = absl::Beta(bitgen, 3.0, 2.0);
+//
+template <typename RealType, typename URBG>
+RealType Beta(URBG&& urbg,  // NOLINT(runtime/references)
+              RealType alpha, RealType beta) {
+  static_assert(
+      std::is_floating_point<RealType>::value,
+      "Template-argument 'RealType' must be a floating-point type, in "
+      "absl::Beta<RealType, URBG>(...)");
+
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = typename absl::beta_distribution<RealType>;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, alpha, beta);
+}
+
+// -----------------------------------------------------------------------------
+// absl::Exponential<T>(bitgen, lambda = 1)
+// -----------------------------------------------------------------------------
+//
+// `absl::Exponential` produces a floating point number representing the
+// distance (time) between two consecutive events in a point process of events
+// occurring continuously and independently at a constant average rate. `T` must
+// be a floating point type, but may be inferred from the type of `lambda`.
+//
+// See https://en.wikipedia.org/wiki/Exponential_distribution.
+//
+// Example:
+//
+//   absl::BitGen bitgen;
+//   ...
+//   double call_length = absl::Exponential(bitgen, 7.0);
+//
+template <typename RealType, typename URBG>
+RealType Exponential(URBG&& urbg,  // NOLINT(runtime/references)
+                     RealType lambda = 1) {
+  static_assert(
+      std::is_floating_point<RealType>::value,
+      "Template-argument 'RealType' must be a floating-point type, in "
+      "absl::Exponential<RealType, URBG>(...)");
+
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = typename absl::exponential_distribution<RealType>;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, lambda);
+}
+
+// -----------------------------------------------------------------------------
+// absl::Gaussian<T>(bitgen, mean = 0, stddev = 1)
+// -----------------------------------------------------------------------------
+//
+// `absl::Gaussian` produces a floating point number selected from the Gaussian
+// (ie. "Normal") distribution. `T` must be a floating point type, but may be
+// inferred from the types of `mean` and `stddev`.
+//
+// See https://en.wikipedia.org/wiki/Normal_distribution
+//
+// Example:
+//
+//   absl::BitGen bitgen;
+//   ...
+//   double giraffe_height = absl::Gaussian(bitgen, 16.3, 3.3);
+//
+template <typename RealType, typename URBG>
+RealType Gaussian(URBG&& urbg,  // NOLINT(runtime/references)
+                  RealType mean = 0, RealType stddev = 1) {
+  static_assert(
+      std::is_floating_point<RealType>::value,
+      "Template-argument 'RealType' must be a floating-point type, in "
+      "absl::Gaussian<RealType, URBG>(...)");
+
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = typename absl::gaussian_distribution<RealType>;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, mean, stddev);
+}
+
+// -----------------------------------------------------------------------------
+// absl::LogUniform<T>(bitgen, lo, hi, base = 2)
+// -----------------------------------------------------------------------------
+//
+// `absl::LogUniform` produces random values distributed where the log to a
+// given base of all values is uniform in a closed interval [lo, hi]. `T` must
+// be an integral type, but may be inferred from the types of `lo` and `hi`.
+//
+// I.e., `LogUniform(0, n, b)` is uniformly distributed across buckets
+// [0], [1, b-1], [b, b^2-1] .. [b^(k-1), (b^k)-1] .. [b^floor(log(n, b)), n]
+// and is uniformly distributed within each bucket.
+//
+// The resulting probability density is inversely related to bucket size, though
+// values in the final bucket may be more likely than previous values. (In the
+// extreme case where n = b^i the final value will be tied with zero as the most
+// probable result.
+//
+// If `lo` is nonzero then this distribution is shifted to the desired interval,
+// so LogUniform(lo, hi, b) is equivalent to LogUniform(0, hi-lo, b)+lo.
+//
+// See http://ecolego.facilia.se/ecolego/show/Log-Uniform%20Distribution
+//
+// Example:
+//
+//   absl::BitGen bitgen;
+//   ...
+//   int v = absl::LogUniform(bitgen, 0, 1000);
+//
+template <typename IntType, typename URBG>
+IntType LogUniform(URBG&& urbg,  // NOLINT(runtime/references)
+                   IntType lo, IntType hi, IntType base = 2) {
+  static_assert(random_internal::IsIntegral<IntType>::value,
+                "Template-argument 'IntType' must be an integral type, in "
+                "absl::LogUniform<IntType, URBG>(...)");
+
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = typename absl::log_uniform_int_distribution<IntType>;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, lo, hi, base);
+}
+
+// -----------------------------------------------------------------------------
+// absl::Poisson<T>(bitgen, mean = 1)
+// -----------------------------------------------------------------------------
+//
+// `absl::Poisson` produces discrete probabilities for a given number of events
+// occurring within a fixed interval within the closed interval [0, max]. `T`
+// must be an integral type.
+//
+// See https://en.wikipedia.org/wiki/Poisson_distribution
+//
+// Example:
+//
+//   absl::BitGen bitgen;
+//   ...
+//   int requests_per_minute = absl::Poisson<int>(bitgen, 3.2);
+//
+template <typename IntType, typename URBG>
+IntType Poisson(URBG&& urbg,  // NOLINT(runtime/references)
+                double mean = 1.0) {
+  static_assert(random_internal::IsIntegral<IntType>::value,
+                "Template-argument 'IntType' must be an integral type, in "
+                "absl::Poisson<IntType, URBG>(...)");
+
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = typename absl::poisson_distribution<IntType>;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, mean);
+}
+
+// -----------------------------------------------------------------------------
+// absl::Zipf<T>(bitgen, hi = max, q = 2, v = 1)
+// -----------------------------------------------------------------------------
+//
+// `absl::Zipf` produces discrete probabilities commonly used for modelling of
+// rare events over the closed interval [0, hi]. The parameters `v` and `q`
+// determine the skew of the distribution. `T`  must be an integral type, but
+// may be inferred from the type of `hi`.
+//
+// See http://mathworld.wolfram.com/ZipfDistribution.html
+//
+// Example:
+//
+//   absl::BitGen bitgen;
+//   ...
+//   int term_rank = absl::Zipf<int>(bitgen);
+//
+template <typename IntType, typename URBG>
+IntType Zipf(URBG&& urbg,  // NOLINT(runtime/references)
+             IntType hi = (std::numeric_limits<IntType>::max)(), double q = 2.0,
+             double v = 1.0) {
+  static_assert(random_internal::IsIntegral<IntType>::value,
+                "Template-argument 'IntType' must be an integral type, in "
+                "absl::Zipf<IntType, URBG>(...)");
+
+  using gen_t = absl::decay_t<URBG>;
+  using distribution_t = typename absl::zipf_distribution<IntType>;
+
+  return random_internal::DistributionCaller<gen_t>::template Call<
+      distribution_t>(&urbg, hi, q, v);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_DISTRIBUTIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/exponential_distribution.h b/CAPI/cpp/grpc/include/absl/random/exponential_distribution.h
new file mode 100644
index 0000000..b5caf8a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/exponential_distribution.h
@@ -0,0 +1,165 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_
+#define ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_
+
+#include <cassert>
+#include <cmath>
+#include <istream>
+#include <limits>
+#include <type_traits>
+
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/generate_real.h"
+#include "absl/random/internal/iostream_state_saver.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::exponential_distribution:
+// Generates a number conforming to an exponential distribution and is
+// equivalent to the standard [rand.dist.pois.exp] distribution.
+template <typename RealType = double>
+class exponential_distribution {
+ public:
+  using result_type = RealType;
+
+  class param_type {
+   public:
+    using distribution_type = exponential_distribution;
+
+    explicit param_type(result_type lambda = 1) : lambda_(lambda) {
+      assert(lambda > 0);
+      neg_inv_lambda_ = -result_type(1) / lambda_;
+    }
+
+    result_type lambda() const { return lambda_; }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.lambda_ == b.lambda_;
+    }
+
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class exponential_distribution;
+
+    result_type lambda_;
+    result_type neg_inv_lambda_;
+
+    static_assert(
+        std::is_floating_point<RealType>::value,
+        "Class-template absl::exponential_distribution<> must be parameterized "
+        "using a floating-point type.");
+  };
+
+  exponential_distribution() : exponential_distribution(1) {}
+
+  explicit exponential_distribution(result_type lambda) : param_(lambda) {}
+
+  explicit exponential_distribution(const param_type& p) : param_(p) {}
+
+  void reset() {}
+
+  // Generating functions
+  template <typename URBG>
+  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
+    return (*this)(g, param_);
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                         const param_type& p);
+
+  param_type param() const { return param_; }
+  void param(const param_type& p) { param_ = p; }
+
+  result_type(min)() const { return 0; }
+  result_type(max)() const {
+    return std::numeric_limits<result_type>::infinity();
+  }
+
+  result_type lambda() const { return param_.lambda(); }
+
+  friend bool operator==(const exponential_distribution& a,
+                         const exponential_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const exponential_distribution& a,
+                         const exponential_distribution& b) {
+    return a.param_ != b.param_;
+  }
+
+ private:
+  param_type param_;
+  random_internal::FastUniformBits<uint64_t> fast_u64_;
+};
+
+// --------------------------------------------------------------------------
+// Implementation details follow
+// --------------------------------------------------------------------------
+
+template <typename RealType>
+template <typename URBG>
+typename exponential_distribution<RealType>::result_type
+exponential_distribution<RealType>::operator()(
+    URBG& g,  // NOLINT(runtime/references)
+    const param_type& p) {
+  using random_internal::GenerateNegativeTag;
+  using random_internal::GenerateRealFromBits;
+  using real_type =
+      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+  const result_type u = GenerateRealFromBits<real_type, GenerateNegativeTag,
+                                             false>(fast_u64_(g));  // U(-1, 0)
+
+  // log1p(-x) is mathematically equivalent to log(1 - x) but has more
+  // accuracy for x near zero.
+  return p.neg_inv_lambda_ * std::log1p(u);
+}
+
+template <typename CharT, typename Traits, typename RealType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const exponential_distribution<RealType>& x) {
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
+  os << x.lambda();
+  return os;
+}
+
+template <typename CharT, typename Traits, typename RealType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,    // NOLINT(runtime/references)
+    exponential_distribution<RealType>& x) {  // NOLINT(runtime/references)
+  using result_type = typename exponential_distribution<RealType>::result_type;
+  using param_type = typename exponential_distribution<RealType>::param_type;
+  result_type lambda;
+
+  auto saver = random_internal::make_istream_state_saver(is);
+  lambda = random_internal::read_floating_point<result_type>(is);
+  if (!is.fail()) {
+    x.param(param_type(lambda));
+  }
+  return is;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/gaussian_distribution.h b/CAPI/cpp/grpc/include/absl/random/gaussian_distribution.h
new file mode 100644
index 0000000..4b07a5c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/gaussian_distribution.h
@@ -0,0 +1,275 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_GAUSSIAN_DISTRIBUTION_H_
+#define ABSL_RANDOM_GAUSSIAN_DISTRIBUTION_H_
+
+// absl::gaussian_distribution implements the Ziggurat algorithm
+// for generating random gaussian numbers.
+//
+// Implementation based on "The Ziggurat Method for Generating Random Variables"
+// by George Marsaglia and Wai Wan Tsang: http://www.jstatsoft.org/v05/i08/
+//
+
+#include <cmath>
+#include <cstdint>
+#include <istream>
+#include <limits>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/generate_real.h"
+#include "absl/random/internal/iostream_state_saver.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// absl::gaussian_distribution_base implements the underlying ziggurat algorithm
+// using the ziggurat tables generated by the gaussian_distribution_gentables
+// binary.
+//
+// The specific algorithm has some of the improvements suggested by the
+// 2005 paper, "An Improved Ziggurat Method to Generate Normal Random Samples",
+// Jurgen A Doornik.  (https://www.doornik.com/research/ziggurat.pdf)
+class ABSL_DLL gaussian_distribution_base {
+ public:
+  template <typename URBG>
+  inline double zignor(URBG& g);  // NOLINT(runtime/references)
+
+ private:
+  friend class TableGenerator;
+
+  template <typename URBG>
+  inline double zignor_fallback(URBG& g,  // NOLINT(runtime/references)
+                                bool neg);
+
+  // Constants used for the gaussian distribution.
+  static constexpr double kR = 3.442619855899;  // Start of the tail.
+  static constexpr double kRInv = 0.29047645161474317;  // ~= (1.0 / kR) .
+  static constexpr double kV = 9.91256303526217e-3;
+  static constexpr uint64_t kMask = 0x07f;
+
+  // The ziggurat tables store the pdf(f) and inverse-pdf(x) for equal-area
+  // points on one-half of the normal distribution, where the pdf function,
+  // pdf = e ^ (-1/2 *x^2), assumes that the mean = 0 & stddev = 1.
+  //
+  // These tables are just over 2kb in size; larger tables might improve the
+  // distributions, but also lead to more cache pollution.
+  //
+  // x = {3.71308, 3.44261, 3.22308, ..., 0}
+  // f = {0.00101, 0.00266, 0.00554, ..., 1}
+  struct Tables {
+    double x[kMask + 2];
+    double f[kMask + 2];
+  };
+  static const Tables zg_;
+  random_internal::FastUniformBits<uint64_t> fast_u64_;
+};
+
+}  // namespace random_internal
+
+// absl::gaussian_distribution:
+// Generates a number conforming to a Gaussian distribution.
+template <typename RealType = double>
+class gaussian_distribution : random_internal::gaussian_distribution_base {
+ public:
+  using result_type = RealType;
+
+  class param_type {
+   public:
+    using distribution_type = gaussian_distribution;
+
+    explicit param_type(result_type mean = 0, result_type stddev = 1)
+        : mean_(mean), stddev_(stddev) {}
+
+    // Returns the mean distribution parameter.  The mean specifies the location
+    // of the peak.  The default value is 0.0.
+    result_type mean() const { return mean_; }
+
+    // Returns the deviation distribution parameter.  The default value is 1.0.
+    result_type stddev() const { return stddev_; }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.mean_ == b.mean_ && a.stddev_ == b.stddev_;
+    }
+
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    result_type mean_;
+    result_type stddev_;
+
+    static_assert(
+        std::is_floating_point<RealType>::value,
+        "Class-template absl::gaussian_distribution<> must be parameterized "
+        "using a floating-point type.");
+  };
+
+  gaussian_distribution() : gaussian_distribution(0) {}
+
+  explicit gaussian_distribution(result_type mean, result_type stddev = 1)
+      : param_(mean, stddev) {}
+
+  explicit gaussian_distribution(const param_type& p) : param_(p) {}
+
+  void reset() {}
+
+  // Generating functions
+  template <typename URBG>
+  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
+    return (*this)(g, param_);
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                         const param_type& p);
+
+  param_type param() const { return param_; }
+  void param(const param_type& p) { param_ = p; }
+
+  result_type(min)() const {
+    return -std::numeric_limits<result_type>::infinity();
+  }
+  result_type(max)() const {
+    return std::numeric_limits<result_type>::infinity();
+  }
+
+  result_type mean() const { return param_.mean(); }
+  result_type stddev() const { return param_.stddev(); }
+
+  friend bool operator==(const gaussian_distribution& a,
+                         const gaussian_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const gaussian_distribution& a,
+                         const gaussian_distribution& b) {
+    return a.param_ != b.param_;
+  }
+
+ private:
+  param_type param_;
+};
+
+// --------------------------------------------------------------------------
+// Implementation details only below
+// --------------------------------------------------------------------------
+
+template <typename RealType>
+template <typename URBG>
+typename gaussian_distribution<RealType>::result_type
+gaussian_distribution<RealType>::operator()(
+    URBG& g,  // NOLINT(runtime/references)
+    const param_type& p) {
+  return p.mean() + p.stddev() * static_cast<result_type>(zignor(g));
+}
+
+template <typename CharT, typename Traits, typename RealType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const gaussian_distribution<RealType>& x) {
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
+  os << x.mean() << os.fill() << x.stddev();
+  return os;
+}
+
+template <typename CharT, typename Traits, typename RealType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+    gaussian_distribution<RealType>& x) {   // NOLINT(runtime/references)
+  using result_type = typename gaussian_distribution<RealType>::result_type;
+  using param_type = typename gaussian_distribution<RealType>::param_type;
+
+  auto saver = random_internal::make_istream_state_saver(is);
+  auto mean = random_internal::read_floating_point<result_type>(is);
+  if (is.fail()) return is;
+  auto stddev = random_internal::read_floating_point<result_type>(is);
+  if (!is.fail()) {
+    x.param(param_type(mean, stddev));
+  }
+  return is;
+}
+
+namespace random_internal {
+
+template <typename URBG>
+inline double gaussian_distribution_base::zignor_fallback(URBG& g, bool neg) {
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+
+  // This fallback path happens approximately 0.05% of the time.
+  double x, y;
+  do {
+    // kRInv = 1/r, U(0, 1)
+    x = kRInv *
+        std::log(GenerateRealFromBits<double, GeneratePositiveTag, false>(
+            fast_u64_(g)));
+    y = -std::log(
+        GenerateRealFromBits<double, GeneratePositiveTag, false>(fast_u64_(g)));
+  } while ((y + y) < (x * x));
+  return neg ? (x - kR) : (kR - x);
+}
+
+template <typename URBG>
+inline double gaussian_distribution_base::zignor(
+    URBG& g) {  // NOLINT(runtime/references)
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using random_internal::GenerateSignedTag;
+
+  while (true) {
+    // We use a single uint64_t to generate both a double and a strip.
+    // These bits are unused when the generated double is > 1/2^5.
+    // This may introduce some bias from the duplicated low bits of small
+    // values (those smaller than 1/2^5, which all end up on the left tail).
+    uint64_t bits = fast_u64_(g);
+    int i = static_cast<int>(bits & kMask);  // pick a random strip
+    double j = GenerateRealFromBits<double, GenerateSignedTag, false>(
+        bits);  // U(-1, 1)
+    const double x = j * zg_.x[i];
+
+    // Retangular box. Handles >97% of all cases.
+    // For any given box, this handles between 75% and 99% of values.
+    // Equivalent to U(01) < (x[i+1] / x[i]), and when i == 0, ~93.5%
+    if (std::abs(x) < zg_.x[i + 1]) {
+      return x;
+    }
+
+    // i == 0: Base box. Sample using a ratio of uniforms.
+    if (i == 0) {
+      // This path happens about 0.05% of the time.
+      return zignor_fallback(g, j < 0);
+    }
+
+    // i > 0: Wedge samples using precomputed values.
+    double v = GenerateRealFromBits<double, GeneratePositiveTag, false>(
+        fast_u64_(g));  // U(0, 1)
+    if ((zg_.f[i + 1] + v * (zg_.f[i] - zg_.f[i + 1])) <
+        std::exp(-0.5 * x * x)) {
+      return x;
+    }
+
+    // The wedge was missed; reject the value and try again.
+  }
+}
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_GAUSSIAN_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/chi_square.h b/CAPI/cpp/grpc/include/absl/random/internal/chi_square.h
new file mode 100644
index 0000000..07f4fbe
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/chi_square.h
@@ -0,0 +1,89 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_CHI_SQUARE_H_
+#define ABSL_RANDOM_INTERNAL_CHI_SQUARE_H_
+
+// The chi-square statistic.
+//
+// Useful for evaluating if `D` independent random variables are behaving as
+// expected, or if two distributions are similar.  (`D` is the degrees of
+// freedom).
+//
+// Each bucket should have an expected count of 10 or more for the chi square to
+// be meaningful.
+
+#include <cassert>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+constexpr const char kChiSquared[] = "chi-squared";
+
+// Returns the measured chi square value, using a single expected value.  This
+// assumes that the values in [begin, end) are uniformly distributed.
+template <typename Iterator>
+double ChiSquareWithExpected(Iterator begin, Iterator end, double expected) {
+  // Compute the sum and the number of buckets.
+  assert(expected >= 10);  // require at least 10 samples per bucket.
+  double chi_square = 0;
+  for (auto it = begin; it != end; it++) {
+    double d = static_cast<double>(*it) - expected;
+    chi_square += d * d;
+  }
+  chi_square = chi_square / expected;
+  return chi_square;
+}
+
+// Returns the measured chi square value, taking the actual value of each bucket
+// from the first set of iterators, and the expected value of each bucket from
+// the second set of iterators.
+template <typename Iterator, typename Expected>
+double ChiSquare(Iterator it, Iterator end, Expected eit, Expected eend) {
+  double chi_square = 0;
+  for (; it != end && eit != eend; ++it, ++eit) {
+    if (*it > 0) {
+      assert(*eit > 0);
+    }
+    double e = static_cast<double>(*eit);
+    double d = static_cast<double>(*it - *eit);
+    if (d != 0) {
+      assert(e > 0);
+      chi_square += (d * d) / e;
+    }
+  }
+  assert(it == end && eit == eend);
+  return chi_square;
+}
+
+// ======================================================================
+// The following methods can be used for an arbitrary significance level.
+//
+
+// Calculates critical chi-square values to produce the given p-value using a
+// bisection search for a value within epsilon, relying on the monotonicity of
+// ChiSquarePValue().
+double ChiSquareValue(int dof, double p);
+
+// Calculates the p-value (probability) of a given chi-square value.
+double ChiSquarePValue(double chi_square, int dof);
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_CHI_SQUARE_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/distribution_caller.h b/CAPI/cpp/grpc/include/absl/random/internal/distribution_caller.h
new file mode 100644
index 0000000..0f162a4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/distribution_caller.h
@@ -0,0 +1,95 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_RANDOM_INTERNAL_DISTRIBUTION_CALLER_H_
+#define ABSL_RANDOM_INTERNAL_DISTRIBUTION_CALLER_H_
+
+#include <utility>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/fast_type_id.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// DistributionCaller provides an opportunity to overload the general
+// mechanism for calling a distribution, allowing for mock-RNG classes
+// to intercept such calls.
+template <typename URBG>
+struct DistributionCaller {
+  static_assert(!std::is_pointer<URBG>::value,
+                "You must pass a reference, not a pointer.");
+  // SFINAE to detect whether the URBG type includes a member matching
+  // bool InvokeMock(base_internal::FastTypeIdType, void*, void*).
+  //
+  // These live inside BitGenRef so that they have friend access
+  // to MockingBitGen. (see similar methods in DistributionCaller).
+  template <template <class...> class Trait, class AlwaysVoid, class... Args>
+  struct detector : std::false_type {};
+  template <template <class...> class Trait, class... Args>
+  struct detector<Trait, absl::void_t<Trait<Args...>>, Args...>
+      : std::true_type {};
+
+  template <class T>
+  using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
+      std::declval<::absl::base_internal::FastTypeIdType>(),
+      std::declval<void*>(), std::declval<void*>()));
+
+  using HasInvokeMock = typename detector<invoke_mock_t, void, URBG>::type;
+
+  // Default implementation of distribution caller.
+  template <typename DistrT, typename... Args>
+  static typename DistrT::result_type Impl(std::false_type, URBG* urbg,
+                                           Args&&... args) {
+    DistrT dist(std::forward<Args>(args)...);
+    return dist(*urbg);
+  }
+
+  // Mock implementation of distribution caller.
+  // The underlying KeyT must match the KeyT constructed by MockOverloadSet.
+  template <typename DistrT, typename... Args>
+  static typename DistrT::result_type Impl(std::true_type, URBG* urbg,
+                                           Args&&... args) {
+    using ResultT = typename DistrT::result_type;
+    using ArgTupleT = std::tuple<absl::decay_t<Args>...>;
+    using KeyT = ResultT(DistrT, ArgTupleT);
+
+    ArgTupleT arg_tuple(std::forward<Args>(args)...);
+    ResultT result;
+    if (!urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple,
+                          &result)) {
+      auto dist = absl::make_from_tuple<DistrT>(arg_tuple);
+      result = dist(*urbg);
+    }
+    return result;
+  }
+
+  // Default implementation of distribution caller.
+  template <typename DistrT, typename... Args>
+  static typename DistrT::result_type Call(URBG* urbg, Args&&... args) {
+    return Impl<DistrT, Args...>(HasInvokeMock{}, urbg,
+                                 std::forward<Args>(args)...);
+  }
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_DISTRIBUTION_CALLER_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/distribution_test_util.h b/CAPI/cpp/grpc/include/absl/random/internal/distribution_test_util.h
new file mode 100644
index 0000000..6d94cf6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/distribution_test_util.h
@@ -0,0 +1,113 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_DISTRIBUTION_TEST_UTIL_H_
+#define ABSL_RANDOM_INTERNAL_DISTRIBUTION_TEST_UTIL_H_
+
+#include <cstddef>
+#include <iostream>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+
+// NOTE: The functions in this file are test only, and are should not be used in
+// non-test code.
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// http://webspace.ship.edu/pgmarr/Geo441/Lectures/Lec%205%20-%20Normality%20Testing.pdf
+
+// Compute the 1st to 4th standard moments:
+// mean, variance, skewness, and kurtosis.
+// http://www.itl.nist.gov/div898/handbook/eda/section3/eda35b.htm
+struct DistributionMoments {
+  size_t n = 0;
+  double mean = 0.0;
+  double variance = 0.0;
+  double skewness = 0.0;
+  double kurtosis = 0.0;
+};
+DistributionMoments ComputeDistributionMoments(
+    absl::Span<const double> data_points);
+
+std::ostream& operator<<(std::ostream& os, const DistributionMoments& moments);
+
+// Computes the Z-score for a set of data with the given distribution moments
+// compared against `expected_mean`.
+double ZScore(double expected_mean, const DistributionMoments& moments);
+
+// Returns the probability of success required for a single trial to ensure that
+// after `num_trials` trials, the probability of at least one failure is no more
+// than `p_fail`.
+double RequiredSuccessProbability(double p_fail, int num_trials);
+
+// Computes the maximum distance from the mean tolerable, for Z-Tests that are
+// expected to pass with `acceptance_probability`. Will terminate if the
+// resulting tolerance is zero (due to passing in 0.0 for
+// `acceptance_probability` or rounding errors).
+//
+// For example,
+// MaxErrorTolerance(0.001) = 0.0
+// MaxErrorTolerance(0.5) = ~0.47
+// MaxErrorTolerance(1.0) = inf
+double MaxErrorTolerance(double acceptance_probability);
+
+// Approximation to inverse of the Error Function in double precision.
+// (http://people.maths.ox.ac.uk/gilesm/files/gems_erfinv.pdf)
+double erfinv(double x);
+
+// Beta(p, q) = Gamma(p) * Gamma(q) / Gamma(p+q)
+double beta(double p, double q);
+
+// The inverse of the normal survival function.
+double InverseNormalSurvival(double x);
+
+// Returns whether actual is "near" expected, based on the bound.
+bool Near(absl::string_view msg, double actual, double expected, double bound);
+
+// Implements the incomplete regularized beta function, AS63, BETAIN.
+//    https://www.jstor.org/stable/2346797
+//
+// BetaIncomplete(x, p, q), where
+//   `x` is the value of the upper limit
+//   `p` is beta parameter p, `q` is beta parameter q.
+//
+// NOTE: This is a test-only function which is only accurate to within, at most,
+// 1e-13 of the actual value.
+//
+double BetaIncomplete(double x, double p, double q);
+
+// Implements the inverse of the incomplete regularized beta function, AS109,
+// XINBTA.
+//   https://www.jstor.org/stable/2346798
+//   https://www.jstor.org/stable/2346887
+//
+// BetaIncompleteInv(p, q, beta, alhpa)
+//   `p` is beta parameter p, `q` is beta parameter q.
+//   `alpha` is the value of the lower tail area.
+//
+// NOTE: This is a test-only function and, when successful, is only accurate to
+// within ~1e-6 of the actual value; there are some cases where it diverges from
+// the actual value by much more than that.  The function uses Newton's method,
+// and thus the runtime is highly variable.
+double BetaIncompleteInv(double p, double q, double alpha);
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_DISTRIBUTION_TEST_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/explicit_seed_seq.h b/CAPI/cpp/grpc/include/absl/random/internal/explicit_seed_seq.h
new file mode 100644
index 0000000..25f7915
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/explicit_seed_seq.h
@@ -0,0 +1,92 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_EXPLICIT_SEED_SEQ_H_
+#define ABSL_RANDOM_INTERNAL_EXPLICIT_SEED_SEQ_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <iterator>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/endian.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// This class conforms to the C++ Standard "Seed Sequence" concept
+// [rand.req.seedseq].
+//
+// An "ExplicitSeedSeq" is meant to provide a conformant interface for
+// forwarding pre-computed seed material to the constructor of a class
+// conforming to the "Uniform Random Bit Generator" concept. This class makes no
+// attempt to mutate the state provided by its constructor, and returns it
+// directly via ExplicitSeedSeq::generate().
+//
+// If this class is asked to generate more seed material than was provided to
+// the constructor, then the remaining bytes will be filled with deterministic,
+// nonrandom data.
+class ExplicitSeedSeq {
+ public:
+  using result_type = uint32_t;
+
+  ExplicitSeedSeq() : state_() {}
+
+  // Copy and move both allowed.
+  ExplicitSeedSeq(const ExplicitSeedSeq& other) = default;
+  ExplicitSeedSeq& operator=(const ExplicitSeedSeq& other) = default;
+  ExplicitSeedSeq(ExplicitSeedSeq&& other) = default;
+  ExplicitSeedSeq& operator=(ExplicitSeedSeq&& other) = default;
+
+  template <typename Iterator>
+  ExplicitSeedSeq(Iterator begin, Iterator end) {
+    for (auto it = begin; it != end; it++) {
+      state_.push_back(*it & 0xffffffff);
+    }
+  }
+
+  template <typename T>
+  ExplicitSeedSeq(std::initializer_list<T> il)
+      : ExplicitSeedSeq(il.begin(), il.end()) {}
+
+  size_t size() const { return state_.size(); }
+
+  template <typename OutIterator>
+  void param(OutIterator out) const {
+    std::copy(std::begin(state_), std::end(state_), out);
+  }
+
+  template <typename OutIterator>
+  void generate(OutIterator begin, OutIterator end) {
+    for (size_t index = 0; begin != end; begin++) {
+      *begin = state_.empty() ? 0 : state_[index++];
+      if (index >= state_.size()) {
+        index = 0;
+      }
+    }
+  }
+
+ protected:
+  std::vector<uint32_t> state_;
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_EXPLICIT_SEED_SEQ_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/fast_uniform_bits.h b/CAPI/cpp/grpc/include/absl/random/internal/fast_uniform_bits.h
new file mode 100644
index 0000000..f3a5c00
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/fast_uniform_bits.h
@@ -0,0 +1,269 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_FAST_UNIFORM_BITS_H_
+#define ABSL_RANDOM_INTERNAL_FAST_UNIFORM_BITS_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+// Returns true if the input value is zero or a power of two. Useful for
+// determining if the range of output values in a URBG
+template <typename UIntType>
+constexpr bool IsPowerOfTwoOrZero(UIntType n) {
+  return (n == 0) || ((n & (n - 1)) == 0);
+}
+
+// Computes the length of the range of values producible by the URBG, or returns
+// zero if that would encompass the entire range of representable values in
+// URBG::result_type.
+template <typename URBG>
+constexpr typename URBG::result_type RangeSize() {
+  using result_type = typename URBG::result_type;
+  static_assert((URBG::max)() != (URBG::min)(), "URBG range cannot be 0.");
+  return ((URBG::max)() == (std::numeric_limits<result_type>::max)() &&
+          (URBG::min)() == std::numeric_limits<result_type>::lowest())
+             ? result_type{0}
+             : ((URBG::max)() - (URBG::min)() + result_type{1});
+}
+
+// Computes the floor of the log. (i.e., std::floor(std::log2(N));
+template <typename UIntType>
+constexpr UIntType IntegerLog2(UIntType n) {
+  return (n <= 1) ? 0 : 1 + IntegerLog2(n >> 1);
+}
+
+// Returns the number of bits of randomness returned through
+// `PowerOfTwoVariate(urbg)`.
+template <typename URBG>
+constexpr size_t NumBits() {
+  return RangeSize<URBG>() == 0
+             ? std::numeric_limits<typename URBG::result_type>::digits
+             : IntegerLog2(RangeSize<URBG>());
+}
+
+// Given a shift value `n`, constructs a mask with exactly the low `n` bits set.
+// If `n == 0`, all bits are set.
+template <typename UIntType>
+constexpr UIntType MaskFromShift(size_t n) {
+  return ((n % std::numeric_limits<UIntType>::digits) == 0)
+             ? ~UIntType{0}
+             : (UIntType{1} << n) - UIntType{1};
+}
+
+// Tags used to dispatch FastUniformBits::generate to the simple or more complex
+// entropy extraction algorithm.
+struct SimplifiedLoopTag {};
+struct RejectionLoopTag {};
+
+// FastUniformBits implements a fast path to acquire uniform independent bits
+// from a type which conforms to the [rand.req.urbg] concept.
+// Parameterized by:
+//  `UIntType`: the result (output) type
+//
+// The std::independent_bits_engine [rand.adapt.ibits] adaptor can be
+// instantiated from an existing generator through a copy or a move. It does
+// not, however, facilitate the production of pseudorandom bits from an un-owned
+// generator that will outlive the std::independent_bits_engine instance.
+template <typename UIntType = uint64_t>
+class FastUniformBits {
+ public:
+  using result_type = UIntType;
+
+  static constexpr result_type(min)() { return 0; }
+  static constexpr result_type(max)() {
+    return (std::numeric_limits<result_type>::max)();
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& g);  // NOLINT(runtime/references)
+
+ private:
+  static_assert(IsUnsigned<UIntType>::value,
+                "Class-template FastUniformBits<> must be parameterized using "
+                "an unsigned type.");
+
+  // Generate() generates a random value, dispatched on whether
+  // the underlying URBG must use rejection sampling to generate a value,
+  // or whether a simplified loop will suffice.
+  template <typename URBG>
+  result_type Generate(URBG& g,  // NOLINT(runtime/references)
+                       SimplifiedLoopTag);
+
+  template <typename URBG>
+  result_type Generate(URBG& g,  // NOLINT(runtime/references)
+                       RejectionLoopTag);
+};
+
+template <typename UIntType>
+template <typename URBG>
+typename FastUniformBits<UIntType>::result_type
+FastUniformBits<UIntType>::operator()(URBG& g) {  // NOLINT(runtime/references)
+  // kRangeMask is the mask used when sampling variates from the URBG when the
+  // width of the URBG range is not a power of 2.
+  // Y = (2 ^ kRange) - 1
+  static_assert((URBG::max)() > (URBG::min)(),
+                "URBG::max and URBG::min may not be equal.");
+
+  using tag = absl::conditional_t<IsPowerOfTwoOrZero(RangeSize<URBG>()),
+                                  SimplifiedLoopTag, RejectionLoopTag>;
+  return Generate(g, tag{});
+}
+
+template <typename UIntType>
+template <typename URBG>
+typename FastUniformBits<UIntType>::result_type
+FastUniformBits<UIntType>::Generate(URBG& g,  // NOLINT(runtime/references)
+                                    SimplifiedLoopTag) {
+  // The simplified version of FastUniformBits works only on URBGs that have
+  // a range that is a power of 2. In this case we simply loop and shift without
+  // attempting to balance the bits across calls.
+  static_assert(IsPowerOfTwoOrZero(RangeSize<URBG>()),
+                "incorrect Generate tag for URBG instance");
+
+  static constexpr size_t kResultBits =
+      std::numeric_limits<result_type>::digits;
+  static constexpr size_t kUrbgBits = NumBits<URBG>();
+  static constexpr size_t kIters =
+      (kResultBits / kUrbgBits) + (kResultBits % kUrbgBits != 0);
+  static constexpr size_t kShift = (kIters == 1) ? 0 : kUrbgBits;
+  static constexpr auto kMin = (URBG::min)();
+
+  result_type r = static_cast<result_type>(g() - kMin);
+  for (size_t n = 1; n < kIters; ++n) {
+    r = (r << kShift) + static_cast<result_type>(g() - kMin);
+  }
+  return r;
+}
+
+template <typename UIntType>
+template <typename URBG>
+typename FastUniformBits<UIntType>::result_type
+FastUniformBits<UIntType>::Generate(URBG& g,  // NOLINT(runtime/references)
+                                    RejectionLoopTag) {
+  static_assert(!IsPowerOfTwoOrZero(RangeSize<URBG>()),
+                "incorrect Generate tag for URBG instance");
+  using urbg_result_type = typename URBG::result_type;
+
+  // See [rand.adapt.ibits] for more details on the constants calculated below.
+  //
+  // It is preferable to use roughly the same number of bits from each generator
+  // call, however this is only possible when the number of bits provided by the
+  // URBG is a divisor of the number of bits in `result_type`. In all other
+  // cases, the number of bits used cannot always be the same, but it can be
+  // guaranteed to be off by at most 1. Thus we run two loops, one with a
+  // smaller bit-width size (`kSmallWidth`) and one with a larger width size
+  // (satisfying `kLargeWidth == kSmallWidth + 1`). The loops are run
+  // `kSmallIters` and `kLargeIters` times respectively such
+  // that
+  //
+  //    `kResultBits == kSmallIters * kSmallBits
+  //                    + kLargeIters * kLargeBits`
+  //
+  // where `kResultBits` is the total number of bits in `result_type`.
+  //
+  static constexpr size_t kResultBits =
+      std::numeric_limits<result_type>::digits;                      // w
+  static constexpr urbg_result_type kUrbgRange = RangeSize<URBG>();  // R
+  static constexpr size_t kUrbgBits = NumBits<URBG>();               // m
+
+  // compute the initial estimate of the bits used.
+  // [rand.adapt.ibits] 2 (c)
+  static constexpr size_t kA =  // ceil(w/m)
+      (kResultBits / kUrbgBits) + ((kResultBits % kUrbgBits) != 0);  // n'
+
+  static constexpr size_t kABits = kResultBits / kA;  // w0'
+  static constexpr urbg_result_type kARejection =
+      ((kUrbgRange >> kABits) << kABits);  // y0'
+
+  // refine the selection to reduce the rejection frequency.
+  static constexpr size_t kTotalIters =
+      ((kUrbgRange - kARejection) <= (kARejection / kA)) ? kA : (kA + 1);  // n
+
+  // [rand.adapt.ibits] 2 (b)
+  static constexpr size_t kSmallIters =
+      kTotalIters - (kResultBits % kTotalIters);                   // n0
+  static constexpr size_t kSmallBits = kResultBits / kTotalIters;  // w0
+  static constexpr urbg_result_type kSmallRejection =
+      ((kUrbgRange >> kSmallBits) << kSmallBits);  // y0
+
+  static constexpr size_t kLargeBits = kSmallBits + 1;  // w0+1
+  static constexpr urbg_result_type kLargeRejection =
+      ((kUrbgRange >> kLargeBits) << kLargeBits);  // y1
+
+  //
+  // Because `kLargeBits == kSmallBits + 1`, it follows that
+  //
+  //     `kResultBits == kSmallIters * kSmallBits + kLargeIters`
+  //
+  // and therefore
+  //
+  //     `kLargeIters == kTotalWidth % kSmallWidth`
+  //
+  // Intuitively, each iteration with the large width accounts for one unit
+  // of the remainder when `kTotalWidth` is divided by `kSmallWidth`. As
+  // mentioned above, if the URBG width is a divisor of `kTotalWidth`, then
+  // there would be no need for any large iterations (i.e., one loop would
+  // suffice), and indeed, in this case, `kLargeIters` would be zero.
+  static_assert(kResultBits == kSmallIters * kSmallBits +
+                                   (kTotalIters - kSmallIters) * kLargeBits,
+                "Error in looping constant calculations.");
+
+  // The small shift is essentially small bits, but due to the potential
+  // of generating a smaller result_type from a larger urbg type, the actual
+  // shift might be 0.
+  static constexpr size_t kSmallShift = kSmallBits % kResultBits;
+  static constexpr auto kSmallMask =
+      MaskFromShift<urbg_result_type>(kSmallShift);
+  static constexpr size_t kLargeShift = kLargeBits % kResultBits;
+  static constexpr auto kLargeMask =
+      MaskFromShift<urbg_result_type>(kLargeShift);
+
+  static constexpr auto kMin = (URBG::min)();
+
+  result_type s = 0;
+  for (size_t n = 0; n < kSmallIters; ++n) {
+    urbg_result_type v;
+    do {
+      v = g() - kMin;
+    } while (v >= kSmallRejection);
+
+    s = (s << kSmallShift) + static_cast<result_type>(v & kSmallMask);
+  }
+
+  for (size_t n = kSmallIters; n < kTotalIters; ++n) {
+    urbg_result_type v;
+    do {
+      v = g() - kMin;
+    } while (v >= kLargeRejection);
+
+    s = (s << kLargeShift) + static_cast<result_type>(v & kLargeMask);
+  }
+  return s;
+}
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_FAST_UNIFORM_BITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/fastmath.h b/CAPI/cpp/grpc/include/absl/random/internal/fastmath.h
new file mode 100644
index 0000000..963b769
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/fastmath.h
@@ -0,0 +1,57 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_FASTMATH_H_
+#define ABSL_RANDOM_INTERNAL_FASTMATH_H_
+
+// This file contains fast math functions (bitwise ops as well as some others)
+// which are implementation details of various absl random number distributions.
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+
+#include "absl/numeric/bits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// Compute log2(n) using integer operations.
+// While std::log2 is more accurate than std::log(n) / std::log(2), for
+// very large numbers--those close to std::numeric_limits<uint64_t>::max() - 2,
+// for instance--std::log2 rounds up rather than down, which introduces
+// definite skew in the results.
+inline int IntLog2Floor(uint64_t n) {
+  return (n <= 1) ? 0 : (63 - countl_zero(n));
+}
+inline int IntLog2Ceil(uint64_t n) {
+  return (n <= 1) ? 0 : (64 - countl_zero(n - 1));
+}
+
+inline double StirlingLogFactorial(double n) {
+  assert(n >= 1);
+  // Using Stirling's approximation.
+  constexpr double kLog2PI = 1.83787706640934548356;
+  const double logn = std::log(n);
+  const double ninv = 1.0 / static_cast<double>(n);
+  return n * logn - n + 0.5 * (kLog2PI + logn) + (1.0 / 12.0) * ninv -
+         (1.0 / 360.0) * ninv * ninv * ninv;
+}
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_FASTMATH_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/generate_real.h b/CAPI/cpp/grpc/include/absl/random/internal/generate_real.h
new file mode 100644
index 0000000..b569450
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/generate_real.h
@@ -0,0 +1,144 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
+#define ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
+
+// This file contains some implementation details which are used by one or more
+// of the absl random number distributions.
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+
+#include "absl/meta/type_traits.h"
+#include "absl/numeric/bits.h"
+#include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// Tristate tag types controlling the output of GenerateRealFromBits.
+struct GeneratePositiveTag {};
+struct GenerateNegativeTag {};
+struct GenerateSignedTag {};
+
+// GenerateRealFromBits generates a single real value from a single 64-bit
+// `bits` with template fields controlling the output.
+//
+// The `SignedTag` parameter controls whether positive, negative,
+// or either signed/unsigned may be returned.
+//   When SignedTag == GeneratePositiveTag, range is U(0, 1)
+//   When SignedTag == GenerateNegativeTag, range is U(-1, 0)
+//   When SignedTag == GenerateSignedTag, range is U(-1, 1)
+//
+// When the `IncludeZero` parameter is true, the function may return 0 for some
+// inputs, otherwise it never returns 0.
+//
+// When a value in U(0,1) is required, use:
+//   GenerateRealFromBits<double, PositiveValueT, true>;
+//
+// When a value in U(-1,1) is required, use:
+//   GenerateRealFromBits<double, SignedValueT, false>;
+//
+//   This generates more distinct values than the mathematical equivalent
+//   `U(0, 1) * 2.0 - 1.0`.
+//
+// Scaling the result by powers of 2 (and avoiding a multiply) is also possible:
+//   GenerateRealFromBits<double>(..., -1);  => U(0, 0.5)
+//   GenerateRealFromBits<double>(..., 1);   => U(0, 2)
+//
+template <typename RealType,  // Real type, either float or double.
+          typename SignedTag = GeneratePositiveTag,  // Whether a positive,
+                                                     // negative, or signed
+                                                     // value is generated.
+          bool IncludeZero = true>
+inline RealType GenerateRealFromBits(uint64_t bits, int exp_bias = 0) {
+  using real_type = RealType;
+  using uint_type = absl::conditional_t<std::is_same<real_type, float>::value,
+                                        uint32_t, uint64_t>;
+
+  static_assert(
+      (std::is_same<double, real_type>::value ||
+       std::is_same<float, real_type>::value),
+      "GenerateRealFromBits must be parameterized by either float or double.");
+
+  static_assert(sizeof(uint_type) == sizeof(real_type),
+                "Mismatched unsinged and real types.");
+
+  static_assert((std::numeric_limits<real_type>::is_iec559 &&
+                 std::numeric_limits<real_type>::radix == 2),
+                "RealType representation is not IEEE 754 binary.");
+
+  static_assert((std::is_same<SignedTag, GeneratePositiveTag>::value ||
+                 std::is_same<SignedTag, GenerateNegativeTag>::value ||
+                 std::is_same<SignedTag, GenerateSignedTag>::value),
+                "");
+
+  static constexpr int kExp = std::numeric_limits<real_type>::digits - 1;
+  static constexpr uint_type kMask = (static_cast<uint_type>(1) << kExp) - 1u;
+  static constexpr int kUintBits = sizeof(uint_type) * 8;
+
+  int exp = exp_bias + int{std::numeric_limits<real_type>::max_exponent - 2};
+
+  // Determine the sign bit.
+  // Depending on the SignedTag, this may use the left-most bit
+  // or it may be a constant value.
+  uint_type sign = std::is_same<SignedTag, GenerateNegativeTag>::value
+                       ? (static_cast<uint_type>(1) << (kUintBits - 1))
+                       : 0;
+  if (std::is_same<SignedTag, GenerateSignedTag>::value) {
+    if (std::is_same<uint_type, uint64_t>::value) {
+      sign = bits & uint64_t{0x8000000000000000};
+    }
+    if (std::is_same<uint_type, uint32_t>::value) {
+      const uint64_t tmp = bits & uint64_t{0x8000000000000000};
+      sign = static_cast<uint32_t>(tmp >> 32);
+    }
+    // adjust the bits and the exponent to account for removing
+    // the leading bit.
+    bits = bits & uint64_t{0x7FFFFFFFFFFFFFFF};
+    exp++;
+  }
+  if (IncludeZero) {
+    if (bits == 0u) return 0;
+  }
+
+  // Number of leading zeros is mapped to the exponent: 2^-clz
+  // bits is 0..01xxxxxx. After shifting, we're left with 1xxx...0..0
+  int clz = countl_zero(bits);
+  bits <<= (IncludeZero ? clz : (clz & 63));  // remove 0-bits.
+  exp -= clz;                                 // set the exponent.
+  bits >>= (63 - kExp);
+
+  // Construct the 32-bit or 64-bit IEEE 754 floating-point value from
+  // the individual fields: sign, exp, mantissa(bits).
+  uint_type val = sign | (static_cast<uint_type>(exp) << kExp) |
+                  (static_cast<uint_type>(bits) & kMask);
+
+  // bit_cast to the output-type
+  real_type result;
+  memcpy(static_cast<void*>(&result), static_cast<const void*>(&val),
+         sizeof(result));
+  return result;
+}
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/iostream_state_saver.h b/CAPI/cpp/grpc/include/absl/random/internal/iostream_state_saver.h
new file mode 100644
index 0000000..e6e242e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/iostream_state_saver.h
@@ -0,0 +1,245 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_IOSTREAM_STATE_SAVER_H_
+#define ABSL_RANDOM_INTERNAL_IOSTREAM_STATE_SAVER_H_
+
+#include <cmath>
+#include <iostream>
+#include <limits>
+#include <type_traits>
+
+#include "absl/meta/type_traits.h"
+#include "absl/numeric/int128.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// The null_state_saver does nothing.
+template <typename T>
+class null_state_saver {
+ public:
+  using stream_type = T;
+  using flags_type = std::ios_base::fmtflags;
+
+  null_state_saver(T&, flags_type) {}
+  ~null_state_saver() {}
+};
+
+// ostream_state_saver is a RAII object to save and restore the common
+// basic_ostream flags used when implementing `operator <<()` on any of
+// the absl random distributions.
+template <typename OStream>
+class ostream_state_saver {
+ public:
+  using ostream_type = OStream;
+  using flags_type = std::ios_base::fmtflags;
+  using fill_type = typename ostream_type::char_type;
+  using precision_type = std::streamsize;
+
+  ostream_state_saver(ostream_type& os,  // NOLINT(runtime/references)
+                      flags_type flags, fill_type fill)
+      : os_(os),
+        flags_(os.flags(flags)),
+        fill_(os.fill(fill)),
+        precision_(os.precision()) {
+    // Save state in initialized variables.
+  }
+
+  ~ostream_state_saver() {
+    // Restore saved state.
+    os_.precision(precision_);
+    os_.fill(fill_);
+    os_.flags(flags_);
+  }
+
+ private:
+  ostream_type& os_;
+  const flags_type flags_;
+  const fill_type fill_;
+  const precision_type precision_;
+};
+
+#if defined(__NDK_MAJOR__) && __NDK_MAJOR__ < 16
+#define ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT 1
+#else
+#define ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT 0
+#endif
+
+template <typename CharT, typename Traits>
+ostream_state_saver<std::basic_ostream<CharT, Traits>> make_ostream_state_saver(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    std::ios_base::fmtflags flags = std::ios_base::dec | std::ios_base::left |
+#if ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT
+                                    std::ios_base::fixed |
+#endif
+                                    std::ios_base::scientific) {
+  using result_type = ostream_state_saver<std::basic_ostream<CharT, Traits>>;
+  return result_type(os, flags, os.widen(' '));
+}
+
+template <typename T>
+typename absl::enable_if_t<!std::is_base_of<std::ios_base, T>::value,
+                           null_state_saver<T>>
+make_ostream_state_saver(T& is,  // NOLINT(runtime/references)
+                         std::ios_base::fmtflags flags = std::ios_base::dec) {
+  std::cerr << "null_state_saver";
+  using result_type = null_state_saver<T>;
+  return result_type(is, flags);
+}
+
+// stream_precision_helper<type>::kPrecision returns the base 10 precision
+// required to stream and reconstruct a real type exact binary value through
+// a binary->decimal->binary transition.
+template <typename T>
+struct stream_precision_helper {
+  // max_digits10 may be 0 on MSVC; if so, use digits10 + 3.
+  static constexpr int kPrecision =
+      (std::numeric_limits<T>::max_digits10 > std::numeric_limits<T>::digits10)
+          ? std::numeric_limits<T>::max_digits10
+          : (std::numeric_limits<T>::digits10 + 3);
+};
+
+template <>
+struct stream_precision_helper<float> {
+  static constexpr int kPrecision = 9;
+};
+template <>
+struct stream_precision_helper<double> {
+  static constexpr int kPrecision = 17;
+};
+template <>
+struct stream_precision_helper<long double> {
+  static constexpr int kPrecision = 36;  // assuming fp128
+};
+
+// istream_state_saver is a RAII object to save and restore the common
+// std::basic_istream<> flags used when implementing `operator >>()` on any of
+// the absl random distributions.
+template <typename IStream>
+class istream_state_saver {
+ public:
+  using istream_type = IStream;
+  using flags_type = std::ios_base::fmtflags;
+
+  istream_state_saver(istream_type& is,  // NOLINT(runtime/references)
+                      flags_type flags)
+      : is_(is), flags_(is.flags(flags)) {}
+
+  ~istream_state_saver() { is_.flags(flags_); }
+
+ private:
+  istream_type& is_;
+  flags_type flags_;
+};
+
+template <typename CharT, typename Traits>
+istream_state_saver<std::basic_istream<CharT, Traits>> make_istream_state_saver(
+    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+    std::ios_base::fmtflags flags = std::ios_base::dec |
+                                    std::ios_base::scientific |
+                                    std::ios_base::skipws) {
+  using result_type = istream_state_saver<std::basic_istream<CharT, Traits>>;
+  return result_type(is, flags);
+}
+
+template <typename T>
+typename absl::enable_if_t<!std::is_base_of<std::ios_base, T>::value,
+                           null_state_saver<T>>
+make_istream_state_saver(T& is,  // NOLINT(runtime/references)
+                         std::ios_base::fmtflags flags = std::ios_base::dec) {
+  using result_type = null_state_saver<T>;
+  return result_type(is, flags);
+}
+
+// stream_format_type<T> is a helper struct to convert types which
+// basic_iostream cannot output as decimal numbers into types which
+// basic_iostream can output as decimal numbers. Specifically:
+// * signed/unsigned char-width types are converted to int.
+// * TODO(lar): __int128 => uint128, except there is no operator << yet.
+//
+template <typename T>
+struct stream_format_type
+    : public std::conditional<(sizeof(T) == sizeof(char)), int, T> {};
+
+// stream_u128_helper allows us to write out either absl::uint128 or
+// __uint128_t types in the same way, which enables their use as internal
+// state of PRNG engines.
+template <typename T>
+struct stream_u128_helper;
+
+template <>
+struct stream_u128_helper<absl::uint128> {
+  template <typename IStream>
+  inline absl::uint128 read(IStream& in) {
+    uint64_t h = 0;
+    uint64_t l = 0;
+    in >> h >> l;
+    return absl::MakeUint128(h, l);
+  }
+
+  template <typename OStream>
+  inline void write(absl::uint128 val, OStream& out) {
+    uint64_t h = absl::Uint128High64(val);
+    uint64_t l = absl::Uint128Low64(val);
+    out << h << out.fill() << l;
+  }
+};
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+template <>
+struct stream_u128_helper<__uint128_t> {
+  template <typename IStream>
+  inline __uint128_t read(IStream& in) {
+    uint64_t h = 0;
+    uint64_t l = 0;
+    in >> h >> l;
+    return (static_cast<__uint128_t>(h) << 64) | l;
+  }
+
+  template <typename OStream>
+  inline void write(__uint128_t val, OStream& out) {
+    uint64_t h = static_cast<uint64_t>(val >> 64u);
+    uint64_t l = static_cast<uint64_t>(val);
+    out << h << out.fill() << l;
+  }
+};
+#endif
+
+template <typename FloatType, typename IStream>
+inline FloatType read_floating_point(IStream& is) {
+  static_assert(std::is_floating_point<FloatType>::value, "");
+  FloatType dest;
+  is >> dest;
+  // Parsing a double value may report a subnormal value as an error
+  // despite being able to represent it.
+  // See https://stackoverflow.com/q/52410931/3286653
+  // It may also report an underflow when parsing DOUBLE_MIN as an
+  // ERANGE error, as the parsed value may be smaller than DOUBLE_MIN
+  // and rounded up.
+  // See: https://stackoverflow.com/q/42005462
+  if (is.fail() &&
+      (std::fabs(dest) == (std::numeric_limits<FloatType>::min)() ||
+       std::fpclassify(dest) == FP_SUBNORMAL)) {
+    is.clear(is.rdstate() & (~std::ios_base::failbit));
+  }
+  return dest;
+}
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_IOSTREAM_STATE_SAVER_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/mock_helpers.h b/CAPI/cpp/grpc/include/absl/random/internal/mock_helpers.h
new file mode 100644
index 0000000..882b051
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/mock_helpers.h
@@ -0,0 +1,135 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_MOCK_HELPERS_H_
+#define ABSL_RANDOM_INTERNAL_MOCK_HELPERS_H_
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/fast_type_id.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// MockHelpers works in conjunction with MockOverloadSet, MockingBitGen, and
+// BitGenRef to enable the mocking capability for absl distribution functions.
+//
+// MockingBitGen registers mocks based on the typeid of a mock signature, KeyT,
+// which is used to generate a unique id.
+//
+// KeyT is a signature of the form:
+//   result_type(discriminator_type, std::tuple<args...>)
+// The mocked function signature will be composed from KeyT as:
+//   result_type(args...)
+//
+class MockHelpers {
+  using IdType = ::absl::base_internal::FastTypeIdType;
+
+  // Given a key signature type used to index the mock, extract the components.
+  // KeyT is expected to have the form:
+  //   result_type(discriminator_type, arg_tuple_type)
+  template <typename KeyT>
+  struct KeySignature;
+
+  template <typename ResultT, typename DiscriminatorT, typename ArgTupleT>
+  struct KeySignature<ResultT(DiscriminatorT, ArgTupleT)> {
+    using result_type = ResultT;
+    using discriminator_type = DiscriminatorT;
+    using arg_tuple_type = ArgTupleT;
+  };
+
+  // Detector for InvokeMock.
+  template <class T>
+  using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
+      std::declval<IdType>(), std::declval<void*>(), std::declval<void*>()));
+
+  // Empty implementation of InvokeMock.
+  template <typename KeyT, typename ReturnT, typename ArgTupleT, typename URBG,
+            typename... Args>
+  static absl::optional<ReturnT> InvokeMockImpl(char, URBG*, Args&&...) {
+    return absl::nullopt;
+  }
+
+  // Non-empty implementation of InvokeMock.
+  template <typename KeyT, typename ReturnT, typename ArgTupleT, typename URBG,
+            typename = invoke_mock_t<URBG>, typename... Args>
+  static absl::optional<ReturnT> InvokeMockImpl(int, URBG* urbg,
+                                                Args&&... args) {
+    ArgTupleT arg_tuple(std::forward<Args>(args)...);
+    ReturnT result;
+    if (urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple,
+                         &result)) {
+      return result;
+    }
+    return absl::nullopt;
+  }
+
+ public:
+  // InvokeMock is private; this provides access for some specialized use cases.
+  template <typename URBG>
+  static inline bool PrivateInvokeMock(URBG* urbg, IdType type,
+                                       void* args_tuple, void* result) {
+    return urbg->InvokeMock(type, args_tuple, result);
+  }
+
+  // Invoke a mock for the KeyT (may or may not be a signature).
+  //
+  // KeyT is used to generate a typeid-based lookup key for the mock.
+  // KeyT is a signature of the form:
+  //   result_type(discriminator_type, std::tuple<args...>)
+  // The mocked function signature will be composed from KeyT as:
+  //   result_type(args...)
+  //
+  // An instance of arg_tuple_type must be constructable from Args..., since
+  // the underlying mechanism requires a pointer to an argument tuple.
+  template <typename KeyT, typename URBG, typename... Args>
+  static auto MaybeInvokeMock(URBG* urbg, Args&&... args)
+      -> absl::optional<typename KeySignature<KeyT>::result_type> {
+    // Use function overloading to dispatch to the implemenation since
+    // more modern patterns (e.g. require + constexpr) are not supported in all
+    // compiler configurations.
+    return InvokeMockImpl<KeyT, typename KeySignature<KeyT>::result_type,
+                          typename KeySignature<KeyT>::arg_tuple_type, URBG>(
+        0, urbg, std::forward<Args>(args)...);
+  }
+
+  // Acquire a mock for the KeyT (may or may not be a signature).
+  //
+  // KeyT is used to generate a typeid-based lookup for the mock.
+  // KeyT is a signature of the form:
+  //   result_type(discriminator_type, std::tuple<args...>)
+  // The mocked function signature will be composed from KeyT as:
+  //   result_type(args...)
+  template <typename KeyT, typename MockURBG>
+  static auto MockFor(MockURBG& m)
+      -> decltype(m.template RegisterMock<
+                  typename KeySignature<KeyT>::result_type,
+                  typename KeySignature<KeyT>::arg_tuple_type>(
+          m, std::declval<IdType>())) {
+    return m.template RegisterMock<typename KeySignature<KeyT>::result_type,
+                                   typename KeySignature<KeyT>::arg_tuple_type>(
+        m, ::absl::base_internal::FastTypeId<KeyT>());
+  }
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_MOCK_HELPERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/mock_overload_set.h b/CAPI/cpp/grpc/include/absl/random/internal/mock_overload_set.h
new file mode 100644
index 0000000..0d9c6c1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/mock_overload_set.h
@@ -0,0 +1,100 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_MOCK_OVERLOAD_SET_H_
+#define ABSL_RANDOM_INTERNAL_MOCK_OVERLOAD_SET_H_
+
+#include <type_traits>
+
+#include "gmock/gmock.h"
+#include "absl/random/internal/mock_helpers.h"
+#include "absl/random/mocking_bit_gen.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+template <typename DistrT, typename Fn>
+struct MockSingleOverload;
+
+// MockSingleOverload
+//
+// MockSingleOverload hooks in to gMock's `ON_CALL` and `EXPECT_CALL` macros.
+// EXPECT_CALL(mock_single_overload, Call(...))` will expand to a call to
+// `mock_single_overload.gmock_Call(...)`. Because expectations are stored on
+// the MockingBitGen (an argument passed inside `Call(...)`), this forwards to
+// arguments to MockingBitGen::Register.
+//
+// The underlying KeyT must match the KeyT constructed by DistributionCaller.
+template <typename DistrT, typename Ret, typename... Args>
+struct MockSingleOverload<DistrT, Ret(MockingBitGen&, Args...)> {
+  static_assert(std::is_same<typename DistrT::result_type, Ret>::value,
+                "Overload signature must have return type matching the "
+                "distribution result_type.");
+  using KeyT = Ret(DistrT, std::tuple<Args...>);
+
+  template <typename MockURBG>
+  auto gmock_Call(MockURBG& gen, const ::testing::Matcher<Args>&... matchers)
+      -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...)) {
+    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
+                  "Mocking requires an absl::MockingBitGen");
+    return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...);
+  }
+};
+
+template <typename DistrT, typename Ret, typename Arg, typename... Args>
+struct MockSingleOverload<DistrT, Ret(Arg, MockingBitGen&, Args...)> {
+  static_assert(std::is_same<typename DistrT::result_type, Ret>::value,
+                "Overload signature must have return type matching the "
+                "distribution result_type.");
+  using KeyT = Ret(DistrT, std::tuple<Arg, Args...>);
+
+  template <typename MockURBG>
+  auto gmock_Call(const ::testing::Matcher<Arg>& matcher, MockURBG& gen,
+                  const ::testing::Matcher<Args>&... matchers)
+      -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher,
+                                                             matchers...)) {
+    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
+                  "Mocking requires an absl::MockingBitGen");
+    return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, matchers...);
+  }
+};
+
+// MockOverloadSet
+//
+// MockOverloadSet takes a distribution and a collection of signatures and
+// performs overload resolution amongst all the overloads. This makes
+// `EXPECT_CALL(mock_overload_set, Call(...))` expand and do overload resolution
+// correctly.
+template <typename DistrT, typename... Signatures>
+struct MockOverloadSet;
+
+template <typename DistrT, typename Sig>
+struct MockOverloadSet<DistrT, Sig> : public MockSingleOverload<DistrT, Sig> {
+  using MockSingleOverload<DistrT, Sig>::gmock_Call;
+};
+
+template <typename DistrT, typename FirstSig, typename... Rest>
+struct MockOverloadSet<DistrT, FirstSig, Rest...>
+    : public MockSingleOverload<DistrT, FirstSig>,
+      public MockOverloadSet<DistrT, Rest...> {
+  using MockSingleOverload<DistrT, FirstSig>::gmock_Call;
+  using MockOverloadSet<DistrT, Rest...>::gmock_Call;
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // ABSL_RANDOM_INTERNAL_MOCK_OVERLOAD_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/nanobenchmark.h b/CAPI/cpp/grpc/include/absl/random/internal/nanobenchmark.h
new file mode 100644
index 0000000..a5097ba
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/nanobenchmark.h
@@ -0,0 +1,172 @@
+// Copyright 2017 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_NANOBENCHMARK_H_
+#define ABSL_RANDOM_INTERNAL_NANOBENCHMARK_H_
+
+// Benchmarks functions of a single integer argument with realistic branch
+// prediction hit rates. Uses a robust estimator to summarize the measurements.
+// The precision is about 0.2%.
+//
+// Examples: see nanobenchmark_test.cc.
+//
+// Background: Microbenchmarks such as http://github.com/google/benchmark
+// can measure elapsed times on the order of a microsecond. Shorter functions
+// are typically measured by repeating them thousands of times and dividing
+// the total elapsed time by this count. Unfortunately, repetition (especially
+// with the same input parameter!) influences the runtime. In time-critical
+// code, it is reasonable to expect warm instruction/data caches and TLBs,
+// but a perfect record of which branches will be taken is unrealistic.
+// Unless the application also repeatedly invokes the measured function with
+// the same parameter, the benchmark is measuring something very different -
+// a best-case result, almost as if the parameter were made a compile-time
+// constant. This may lead to erroneous conclusions about branch-heavy
+// algorithms outperforming branch-free alternatives.
+//
+// Our approach differs in three ways. Adding fences to the timer functions
+// reduces variability due to instruction reordering, improving the timer
+// resolution to about 40 CPU cycles. However, shorter functions must still
+// be invoked repeatedly. For more realistic branch prediction performance,
+// we vary the input parameter according to a user-specified distribution.
+// Thus, instead of VaryInputs(Measure(Repeat(func))), we change the
+// loop nesting to Measure(Repeat(VaryInputs(func))). We also estimate the
+// central tendency of the measurement samples with the "half sample mode",
+// which is more robust to outliers and skewed data than the mean or median.
+
+// NOTE: for compatibility with multiple translation units compiled with
+// distinct flags, avoid #including headers that define functions.
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal_nanobenchmark {
+
+// Input influencing the function being measured (e.g. number of bytes to copy).
+using FuncInput = size_t;
+
+// "Proof of work" returned by Func to ensure the compiler does not elide it.
+using FuncOutput = uint64_t;
+
+// Function to measure: either 1) a captureless lambda or function with two
+// arguments or 2) a lambda with capture, in which case the first argument
+// is reserved for use by MeasureClosure.
+using Func = FuncOutput (*)(const void*, FuncInput);
+
+// Internal parameters that determine precision/resolution/measuring time.
+struct Params {
+  // For measuring timer overhead/resolution. Used in a nested loop =>
+  // quadratic time, acceptable because we know timer overhead is "low".
+  // constexpr because this is used to define array bounds.
+  static constexpr size_t kTimerSamples = 256;
+
+  // Best-case precision, expressed as a divisor of the timer resolution.
+  // Larger => more calls to Func and higher precision.
+  size_t precision_divisor = 1024;
+
+  // Ratio between full and subset input distribution sizes. Cannot be less
+  // than 2; larger values increase measurement time but more faithfully
+  // model the given input distribution.
+  size_t subset_ratio = 2;
+
+  // Together with the estimated Func duration, determines how many times to
+  // call Func before checking the sample variability. Larger values increase
+  // measurement time, memory/cache use and precision.
+  double seconds_per_eval = 4E-3;
+
+  // The minimum number of samples before estimating the central tendency.
+  size_t min_samples_per_eval = 7;
+
+  // The mode is better than median for estimating the central tendency of
+  // skewed/fat-tailed distributions, but it requires sufficient samples
+  // relative to the width of half-ranges.
+  size_t min_mode_samples = 64;
+
+  // Maximum permissible variability (= median absolute deviation / center).
+  double target_rel_mad = 0.002;
+
+  // Abort after this many evals without reaching target_rel_mad. This
+  // prevents infinite loops.
+  size_t max_evals = 9;
+
+  // Retry the measure loop up to this many times.
+  size_t max_measure_retries = 2;
+
+  // Whether to print additional statistics to stdout.
+  bool verbose = true;
+};
+
+// Measurement result for each unique input.
+struct Result {
+  FuncInput input;
+
+  // Robust estimate (mode or median) of duration.
+  float ticks;
+
+  // Measure of variability (median absolute deviation relative to "ticks").
+  float variability;
+};
+
+// Ensures the thread is running on the specified cpu, and no others.
+// Reduces noise due to desynchronized socket RDTSC and context switches.
+// If "cpu" is negative, pin to the currently running core.
+void PinThreadToCPU(const int cpu = -1);
+
+// Returns tick rate, useful for converting measurements to seconds. Invariant
+// means the tick counter frequency is independent of CPU throttling or sleep.
+// This call may be expensive, callers should cache the result.
+double InvariantTicksPerSecond();
+
+// Precisely measures the number of ticks elapsed when calling "func" with the
+// given inputs, shuffled to ensure realistic branch prediction hit rates.
+//
+// "func" returns a 'proof of work' to ensure its computations are not elided.
+// "arg" is passed to Func, or reserved for internal use by MeasureClosure.
+// "inputs" is an array of "num_inputs" (not necessarily unique) arguments to
+//   "func". The values should be chosen to maximize coverage of "func". This
+//   represents a distribution, so a value's frequency should reflect its
+//   probability in the real application. Order does not matter; for example, a
+//   uniform distribution over [0, 4) could be represented as {3,0,2,1}.
+// Returns how many Result were written to "results": one per unique input, or
+//   zero if the measurement failed (an error message goes to stderr).
+size_t Measure(const Func func, const void* arg, const FuncInput* inputs,
+               const size_t num_inputs, Result* results,
+               const Params& p = Params());
+
+// Calls operator() of the given closure (lambda function).
+template <class Closure>
+static FuncOutput CallClosure(const void* f, const FuncInput input) {
+  return (*reinterpret_cast<const Closure*>(f))(input);
+}
+
+// Same as Measure, except "closure" is typically a lambda function of
+// FuncInput -> FuncOutput with a capture list.
+template <class Closure>
+static inline size_t MeasureClosure(const Closure& closure,
+                                    const FuncInput* inputs,
+                                    const size_t num_inputs, Result* results,
+                                    const Params& p = Params()) {
+  return Measure(reinterpret_cast<Func>(&CallClosure<Closure>),
+                 reinterpret_cast<const void*>(&closure), inputs, num_inputs,
+                 results, p);
+}
+
+}  // namespace random_internal_nanobenchmark
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_NANOBENCHMARK_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/nonsecure_base.h b/CAPI/cpp/grpc/include/absl/random/internal/nonsecure_base.h
new file mode 100644
index 0000000..c7d7fa4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/nonsecure_base.h
@@ -0,0 +1,161 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_NONSECURE_BASE_H_
+#define ABSL_RANDOM_INTERNAL_NONSECURE_BASE_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/pool_urbg.h"
+#include "absl/random/internal/salted_seed_seq.h"
+#include "absl/random/internal/seed_material.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// RandenPoolSeedSeq is a custom seed sequence type where generate() fills the
+// provided buffer via the RandenPool entropy source.
+class RandenPoolSeedSeq {
+ private:
+  struct ContiguousTag {};
+  struct BufferTag {};
+
+  // Generate random unsigned values directly into the buffer.
+  template <typename Contiguous>
+  void generate_impl(ContiguousTag, Contiguous begin, Contiguous end) {
+    const size_t n = std::distance(begin, end);
+    auto* a = &(*begin);
+    RandenPool<uint8_t>::Fill(
+        absl::MakeSpan(reinterpret_cast<uint8_t*>(a), sizeof(*a) * n));
+  }
+
+  // Construct a buffer of size n and fill it with values, then copy
+  // those values into the seed iterators.
+  template <typename RandomAccessIterator>
+  void generate_impl(BufferTag, RandomAccessIterator begin,
+                     RandomAccessIterator end) {
+    const size_t n = std::distance(begin, end);
+    absl::InlinedVector<uint32_t, 8> data(n, 0);
+    RandenPool<uint32_t>::Fill(absl::MakeSpan(data.begin(), data.end()));
+    std::copy(std::begin(data), std::end(data), begin);
+  }
+
+ public:
+  using result_type = uint32_t;
+
+  size_t size() { return 0; }
+
+  template <typename OutIterator>
+  void param(OutIterator) const {}
+
+  template <typename RandomAccessIterator>
+  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
+    // RandomAccessIterator must be assignable from uint32_t
+    if (begin != end) {
+      using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
+      // ContiguousTag indicates the common case of a known contiguous buffer,
+      // which allows directly filling the buffer. In C++20,
+      // std::contiguous_iterator_tag provides a mechanism for testing this
+      // capability, however until Abseil's support requirements allow us to
+      // assume C++20, limit checks to a few common cases.
+      using TagType = absl::conditional_t<
+          (std::is_pointer<RandomAccessIterator>::value ||
+           std::is_same<RandomAccessIterator,
+                        typename std::vector<U>::iterator>::value),
+          ContiguousTag, BufferTag>;
+
+      generate_impl(TagType{}, begin, end);
+    }
+  }
+};
+
+// Each instance of NonsecureURBGBase<URBG> will be seeded by variates produced
+// by a thread-unique URBG-instance.
+template <typename URBG, typename Seeder = RandenPoolSeedSeq>
+class NonsecureURBGBase {
+ public:
+  using result_type = typename URBG::result_type;
+
+  // Default constructor
+  NonsecureURBGBase() : urbg_(ConstructURBG()) {}
+
+  // Copy disallowed, move allowed.
+  NonsecureURBGBase(const NonsecureURBGBase&) = delete;
+  NonsecureURBGBase& operator=(const NonsecureURBGBase&) = delete;
+  NonsecureURBGBase(NonsecureURBGBase&&) = default;
+  NonsecureURBGBase& operator=(NonsecureURBGBase&&) = default;
+
+  // Constructor using a seed
+  template <class SSeq, typename = typename absl::enable_if_t<
+                            !std::is_same<SSeq, NonsecureURBGBase>::value>>
+  explicit NonsecureURBGBase(SSeq&& seq)
+      : urbg_(ConstructURBG(std::forward<SSeq>(seq))) {}
+
+  // Note: on MSVC, min() or max() can be interpreted as MIN() or MAX(), so we
+  // enclose min() or max() in parens as (min)() and (max)().
+  // Additionally, clang-format requires no space before this construction.
+
+  // NonsecureURBGBase::min()
+  static constexpr result_type(min)() { return (URBG::min)(); }
+
+  // NonsecureURBGBase::max()
+  static constexpr result_type(max)() { return (URBG::max)(); }
+
+  // NonsecureURBGBase::operator()()
+  result_type operator()() { return urbg_(); }
+
+  // NonsecureURBGBase::discard()
+  void discard(unsigned long long values) {  // NOLINT(runtime/int)
+    urbg_.discard(values);
+  }
+
+  bool operator==(const NonsecureURBGBase& other) const {
+    return urbg_ == other.urbg_;
+  }
+
+  bool operator!=(const NonsecureURBGBase& other) const {
+    return !(urbg_ == other.urbg_);
+  }
+
+ private:
+  static URBG ConstructURBG() {
+    Seeder seeder;
+    return URBG(seeder);
+  }
+
+  template <typename SSeq>
+  static URBG ConstructURBG(SSeq&& seq) {  // NOLINT(runtime/references)
+    auto salted_seq =
+        random_internal::MakeSaltedSeedSeq(std::forward<SSeq>(seq));
+    return URBG(salted_seq);
+  }
+
+  URBG urbg_;
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_NONSECURE_BASE_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/pcg_engine.h b/CAPI/cpp/grpc/include/absl/random/internal/pcg_engine.h
new file mode 100644
index 0000000..4ab44c9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/pcg_engine.h
@@ -0,0 +1,308 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_PCG_ENGINE_H_
+#define ABSL_RANDOM_INTERNAL_PCG_ENGINE_H_
+
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/meta/type_traits.h"
+#include "absl/numeric/bits.h"
+#include "absl/numeric/int128.h"
+#include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/iostream_state_saver.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// pcg_engine is a simplified implementation of Melissa O'Neil's PCG engine in
+// C++.  PCG combines a linear congruential generator (LCG) with output state
+// mixing functions to generate each random variate.  pcg_engine supports only a
+// single sequence (oneseq), and does not support streams.
+//
+// pcg_engine is parameterized by two types:
+//   Params, which provides the multiplier and increment values;
+//   Mix, which mixes the state into the result.
+//
+template <typename Params, typename Mix>
+class pcg_engine {
+  static_assert(std::is_same<typename Params::state_type,
+                             typename Mix::state_type>::value,
+                "Class-template absl::pcg_engine must be parameterized by "
+                "Params and Mix with identical state_type");
+
+  static_assert(std::is_unsigned<typename Mix::result_type>::value,
+                "Class-template absl::pcg_engine must be parameterized by "
+                "an unsigned Mix::result_type");
+
+  using params_type = Params;
+  using mix_type = Mix;
+  using state_type = typename Mix::state_type;
+
+ public:
+  // C++11 URBG interface:
+  using result_type = typename Mix::result_type;
+
+  static constexpr result_type(min)() {
+    return (std::numeric_limits<result_type>::min)();
+  }
+
+  static constexpr result_type(max)() {
+    return (std::numeric_limits<result_type>::max)();
+  }
+
+  explicit pcg_engine(uint64_t seed_value = 0) { seed(seed_value); }
+
+  template <class SeedSequence,
+            typename = typename absl::enable_if_t<
+                !std::is_same<SeedSequence, pcg_engine>::value>>
+  explicit pcg_engine(SeedSequence&& seq) {
+    seed(seq);
+  }
+
+  pcg_engine(const pcg_engine&) = default;
+  pcg_engine& operator=(const pcg_engine&) = default;
+  pcg_engine(pcg_engine&&) = default;
+  pcg_engine& operator=(pcg_engine&&) = default;
+
+  result_type operator()() {
+    // Advance the LCG state, always using the new value to generate the output.
+    state_ = lcg(state_);
+    return Mix{}(state_);
+  }
+
+  void seed(uint64_t seed_value = 0) {
+    state_type tmp = seed_value;
+    state_ = lcg(tmp + Params::increment());
+  }
+
+  template <class SeedSequence>
+  typename absl::enable_if_t<
+      !std::is_convertible<SeedSequence, uint64_t>::value, void>
+  seed(SeedSequence&& seq) {
+    reseed(seq);
+  }
+
+  void discard(uint64_t count) { state_ = advance(state_, count); }
+
+  bool operator==(const pcg_engine& other) const {
+    return state_ == other.state_;
+  }
+
+  bool operator!=(const pcg_engine& other) const { return !(*this == other); }
+
+  template <class CharT, class Traits>
+  friend typename absl::enable_if_t<(sizeof(state_type) == 16),
+                                    std::basic_ostream<CharT, Traits>&>
+  operator<<(
+      std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+      const pcg_engine& engine) {
+    auto saver = random_internal::make_ostream_state_saver(os);
+    random_internal::stream_u128_helper<state_type> helper;
+    helper.write(pcg_engine::params_type::multiplier(), os);
+    os << os.fill();
+    helper.write(pcg_engine::params_type::increment(), os);
+    os << os.fill();
+    helper.write(engine.state_, os);
+    return os;
+  }
+
+  template <class CharT, class Traits>
+  friend typename absl::enable_if_t<(sizeof(state_type) <= 8),
+                                    std::basic_ostream<CharT, Traits>&>
+  operator<<(
+      std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+      const pcg_engine& engine) {
+    auto saver = random_internal::make_ostream_state_saver(os);
+    os << pcg_engine::params_type::multiplier() << os.fill();
+    os << pcg_engine::params_type::increment() << os.fill();
+    os << engine.state_;
+    return os;
+  }
+
+  template <class CharT, class Traits>
+  friend typename absl::enable_if_t<(sizeof(state_type) == 16),
+                                    std::basic_istream<CharT, Traits>&>
+  operator>>(
+      std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+      pcg_engine& engine) {                   // NOLINT(runtime/references)
+    random_internal::stream_u128_helper<state_type> helper;
+    auto mult = helper.read(is);
+    auto inc = helper.read(is);
+    auto tmp = helper.read(is);
+    if (mult != pcg_engine::params_type::multiplier() ||
+        inc != pcg_engine::params_type::increment()) {
+      // signal failure by setting the failbit.
+      is.setstate(is.rdstate() | std::ios_base::failbit);
+    }
+    if (!is.fail()) {
+      engine.state_ = tmp;
+    }
+    return is;
+  }
+
+  template <class CharT, class Traits>
+  friend typename absl::enable_if_t<(sizeof(state_type) <= 8),
+                                    std::basic_istream<CharT, Traits>&>
+  operator>>(
+      std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+      pcg_engine& engine) {                   // NOLINT(runtime/references)
+    state_type mult{}, inc{}, tmp{};
+    is >> mult >> inc >> tmp;
+    if (mult != pcg_engine::params_type::multiplier() ||
+        inc != pcg_engine::params_type::increment()) {
+      // signal failure by setting the failbit.
+      is.setstate(is.rdstate() | std::ios_base::failbit);
+    }
+    if (!is.fail()) {
+      engine.state_ = tmp;
+    }
+    return is;
+  }
+
+ private:
+  state_type state_;
+
+  // Returns the linear-congruential generator next state.
+  static inline constexpr state_type lcg(state_type s) {
+    return s * Params::multiplier() + Params::increment();
+  }
+
+  // Returns the linear-congruential arbitrary seek state.
+  inline state_type advance(state_type s, uint64_t n) const {
+    state_type mult = Params::multiplier();
+    state_type inc = Params::increment();
+    state_type m = 1;
+    state_type i = 0;
+    while (n > 0) {
+      if (n & 1) {
+        m *= mult;
+        i = i * mult + inc;
+      }
+      inc = (mult + 1) * inc;
+      mult *= mult;
+      n >>= 1;
+    }
+    return m * s + i;
+  }
+
+  template <class SeedSequence>
+  void reseed(SeedSequence& seq) {
+    using sequence_result_type = typename SeedSequence::result_type;
+    constexpr size_t kBufferSize =
+        sizeof(state_type) / sizeof(sequence_result_type);
+    sequence_result_type buffer[kBufferSize];
+    seq.generate(std::begin(buffer), std::end(buffer));
+    // Convert the seed output to a single state value.
+    state_type tmp = buffer[0];
+    for (size_t i = 1; i < kBufferSize; i++) {
+      tmp <<= (sizeof(sequence_result_type) * 8);
+      tmp |= buffer[i];
+    }
+    state_ = lcg(tmp + params_type::increment());
+  }
+};
+
+// Parameterized implementation of the PCG 128-bit oneseq state.
+// This provides state_type, multiplier, and increment for pcg_engine.
+template <uint64_t kMultA, uint64_t kMultB, uint64_t kIncA, uint64_t kIncB>
+class pcg128_params {
+ public:
+#if ABSL_HAVE_INTRINSIC_INT128
+  using state_type = __uint128_t;
+  static inline constexpr state_type make_u128(uint64_t a, uint64_t b) {
+    return (static_cast<__uint128_t>(a) << 64) | b;
+  }
+#else
+  using state_type = absl::uint128;
+  static inline constexpr state_type make_u128(uint64_t a, uint64_t b) {
+    return absl::MakeUint128(a, b);
+  }
+#endif
+
+  static inline constexpr state_type multiplier() {
+    return make_u128(kMultA, kMultB);
+  }
+  static inline constexpr state_type increment() {
+    return make_u128(kIncA, kIncB);
+  }
+};
+
+// Implementation of the PCG xsl_rr_128_64 128-bit mixing function, which
+// accepts an input of state_type and mixes it into an output of result_type.
+struct pcg_xsl_rr_128_64 {
+#if ABSL_HAVE_INTRINSIC_INT128
+  using state_type = __uint128_t;
+#else
+  using state_type = absl::uint128;
+#endif
+  using result_type = uint64_t;
+
+  inline uint64_t operator()(state_type state) {
+    // This is equivalent to the xsl_rr_128_64 mixing function.
+#if ABSL_HAVE_INTRINSIC_INT128
+    uint64_t rotate = static_cast<uint64_t>(state >> 122u);
+    state ^= state >> 64;
+    uint64_t s = static_cast<uint64_t>(state);
+#else
+    uint64_t h = Uint128High64(state);
+    uint64_t rotate = h >> 58u;
+    uint64_t s = Uint128Low64(state) ^ h;
+#endif
+    return rotr(s, static_cast<int>(rotate));
+  }
+};
+
+// Parameterized implementation of the PCG 64-bit oneseq state.
+// This provides state_type, multiplier, and increment for pcg_engine.
+template <uint64_t kMult, uint64_t kInc>
+class pcg64_params {
+ public:
+  using state_type = uint64_t;
+  static inline constexpr state_type multiplier() { return kMult; }
+  static inline constexpr state_type increment() { return kInc; }
+};
+
+// Implementation of the PCG xsh_rr_64_32 64-bit mixing function, which accepts
+// an input of state_type and mixes it into an output of result_type.
+struct pcg_xsh_rr_64_32 {
+  using state_type = uint64_t;
+  using result_type = uint32_t;
+  inline uint32_t operator()(uint64_t state) {
+    return rotr(static_cast<uint32_t>(((state >> 18) ^ state) >> 27),
+                state >> 59);
+  }
+};
+
+// Stable pcg_engine implementations:
+// This is a 64-bit generator using 128-bits of state.
+// The output sequence is equivalent to Melissa O'Neil's pcg64_oneseq.
+using pcg64_2018_engine = pcg_engine<
+    random_internal::pcg128_params<0x2360ed051fc65da4ull, 0x4385df649fccf645ull,
+                                   0x5851f42d4c957f2d, 0x14057b7ef767814f>,
+    random_internal::pcg_xsl_rr_128_64>;
+
+// This is a 32-bit generator using 64-bits of state.
+// This is equivalent to Melissa O'Neil's pcg32_oneseq.
+using pcg32_2018_engine = pcg_engine<
+    random_internal::pcg64_params<0x5851f42d4c957f2dull, 0x14057b7ef767814full>,
+    random_internal::pcg_xsh_rr_64_32>;
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_PCG_ENGINE_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/platform.h b/CAPI/cpp/grpc/include/absl/random/internal/platform.h
new file mode 100644
index 0000000..bbdb4e6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/platform.h
@@ -0,0 +1,171 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_PLATFORM_H_
+#define ABSL_RANDOM_INTERNAL_PLATFORM_H_
+
+// HERMETIC NOTE: The randen_hwaes target must not introduce duplicate
+// symbols from arbitrary system and other headers, since it may be built
+// with different flags from other targets, using different levels of
+// optimization, potentially introducing ODR violations.
+
+// -----------------------------------------------------------------------------
+// Platform Feature Checks
+// -----------------------------------------------------------------------------
+
+// Currently supported operating systems and associated preprocessor
+// symbols:
+//
+//   Linux and Linux-derived           __linux__
+//   Android                           __ANDROID__ (implies __linux__)
+//   Linux (non-Android)               __linux__ && !__ANDROID__
+//   Darwin (macOS and iOS)            __APPLE__
+//   Akaros (http://akaros.org)        __ros__
+//   Windows                           _WIN32
+//   NaCL                              __native_client__
+//   AsmJS                             __asmjs__
+//   WebAssembly                       __wasm__
+//   Fuchsia                           __Fuchsia__
+//
+// Note that since Android defines both __ANDROID__ and __linux__, one
+// may probe for either Linux or Android by simply testing for __linux__.
+//
+// NOTE: For __APPLE__ platforms, we use #include <TargetConditionals.h>
+// to distinguish os variants.
+//
+// http://nadeausoftware.com/articles/2012/01/c_c_tip_how_use_compiler_predefined_macros_detect_operating_system
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+// -----------------------------------------------------------------------------
+// Architecture Checks
+// -----------------------------------------------------------------------------
+
+// These preprocessor directives are trying to determine CPU architecture,
+// including necessary headers to support hardware AES.
+//
+// ABSL_ARCH_{X86/PPC/ARM} macros determine the platform.
+#if defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64) || \
+    defined(_M_X64)
+#define ABSL_ARCH_X86_64
+#elif defined(__i386) || defined(_M_IX86)
+#define ABSL_ARCH_X86_32
+#elif defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64)
+#define ABSL_ARCH_AARCH64
+#elif defined(__arm__) || defined(__ARMEL__) || defined(_M_ARM)
+#define ABSL_ARCH_ARM
+#elif defined(__powerpc64__) || defined(__PPC64__) || defined(__powerpc__) || \
+    defined(__ppc__) || defined(__PPC__)
+#define ABSL_ARCH_PPC
+#else
+// Unsupported architecture.
+//  * https://sourceforge.net/p/predef/wiki/Architectures/
+//  * https://msdn.microsoft.com/en-us/library/b0084kay.aspx
+//  * for gcc, clang: "echo | gcc -E -dM -"
+#endif
+
+// -----------------------------------------------------------------------------
+// Attribute Checks
+// -----------------------------------------------------------------------------
+
+// ABSL_RANDOM_INTERNAL_RESTRICT annotates whether pointers may be considered
+// to be unaliased.
+#if defined(__clang__) || defined(__GNUC__)
+#define ABSL_RANDOM_INTERNAL_RESTRICT __restrict__
+#elif defined(_MSC_VER)
+#define ABSL_RANDOM_INTERNAL_RESTRICT __restrict
+#else
+#define ABSL_RANDOM_INTERNAL_RESTRICT
+#endif
+
+// ABSL_HAVE_ACCELERATED_AES indicates whether the currently active compiler
+// flags (e.g. -maes) allow using hardware accelerated AES instructions, which
+// implies us assuming that the target platform supports them.
+#define ABSL_HAVE_ACCELERATED_AES 0
+
+#if defined(ABSL_ARCH_X86_64)
+
+#if defined(__AES__) || defined(__AVX__)
+#undef ABSL_HAVE_ACCELERATED_AES
+#define ABSL_HAVE_ACCELERATED_AES 1
+#endif
+
+#elif defined(ABSL_ARCH_PPC)
+
+// Rely on VSX and CRYPTO extensions for vcipher on PowerPC.
+#if (defined(__VEC__) || defined(__ALTIVEC__)) && defined(__VSX__) && \
+    defined(__CRYPTO__)
+#undef ABSL_HAVE_ACCELERATED_AES
+#define ABSL_HAVE_ACCELERATED_AES 1
+#endif
+
+#elif defined(ABSL_ARCH_ARM) || defined(ABSL_ARCH_AARCH64)
+
+// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0053c/IHI0053C_acle_2_0.pdf
+// Rely on NEON+CRYPTO extensions for ARM.
+#if defined(__ARM_NEON) && defined(__ARM_FEATURE_CRYPTO)
+#undef ABSL_HAVE_ACCELERATED_AES
+#define ABSL_HAVE_ACCELERATED_AES 1
+#endif
+
+#endif
+
+// NaCl does not allow AES.
+#if defined(__native_client__)
+#undef ABSL_HAVE_ACCELERATED_AES
+#define ABSL_HAVE_ACCELERATED_AES 0
+#endif
+
+// ABSL_RANDOM_INTERNAL_AES_DISPATCH indicates whether the currently active
+// platform has, or should use run-time dispatch for selecting the
+// acclerated Randen implementation.
+#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 0
+
+#if defined(ABSL_ARCH_X86_64)
+// Dispatch is available on x86_64
+#undef ABSL_RANDOM_INTERNAL_AES_DISPATCH
+#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 1
+#elif defined(__linux__) && defined(ABSL_ARCH_PPC)
+// Or when running linux PPC
+#undef ABSL_RANDOM_INTERNAL_AES_DISPATCH
+#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 1
+#elif defined(__linux__) && defined(ABSL_ARCH_AARCH64)
+// Or when running linux AArch64
+#undef ABSL_RANDOM_INTERNAL_AES_DISPATCH
+#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 1
+#elif defined(__linux__) && defined(ABSL_ARCH_ARM) && (__ARM_ARCH >= 8)
+// Or when running linux ARM v8 or higher.
+// (This captures a lot of Android configurations.)
+#undef ABSL_RANDOM_INTERNAL_AES_DISPATCH
+#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 1
+#endif
+
+// NaCl does not allow dispatch.
+#if defined(__native_client__)
+#undef ABSL_RANDOM_INTERNAL_AES_DISPATCH
+#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 0
+#endif
+
+// iOS does not support dispatch, even on x86, since applications
+// should be bundled as fat binaries, with a different build tailored for
+// each specific supported platform/architecture.
+#if (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE) || \
+    (defined(TARGET_OS_IPHONE_SIMULATOR) && TARGET_OS_IPHONE_SIMULATOR)
+#undef ABSL_RANDOM_INTERNAL_AES_DISPATCH
+#define ABSL_RANDOM_INTERNAL_AES_DISPATCH 0
+#endif
+
+#endif  // ABSL_RANDOM_INTERNAL_PLATFORM_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/pool_urbg.h b/CAPI/cpp/grpc/include/absl/random/internal/pool_urbg.h
new file mode 100644
index 0000000..0572192
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/pool_urbg.h
@@ -0,0 +1,131 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_POOL_URBG_H_
+#define ABSL_RANDOM_INTERNAL_POOL_URBG_H_
+
+#include <cinttypes>
+#include <limits>
+
+#include "absl/random/internal/traits.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// RandenPool is a thread-safe random number generator [random.req.urbg] that
+// uses an underlying pool of Randen generators to generate values.  Each thread
+// has affinity to one instance of the underlying pool generators.  Concurrent
+// access is guarded by a spin-lock.
+template <typename T>
+class RandenPool {
+ public:
+  using result_type = T;
+  static_assert(std::is_unsigned<result_type>::value,
+                "RandenPool template argument must be a built-in unsigned "
+                "integer type");
+
+  static constexpr result_type(min)() {
+    return (std::numeric_limits<result_type>::min)();
+  }
+
+  static constexpr result_type(max)() {
+    return (std::numeric_limits<result_type>::max)();
+  }
+
+  RandenPool() {}
+
+  // Returns a single value.
+  inline result_type operator()() { return Generate(); }
+
+  // Fill data with random values.
+  static void Fill(absl::Span<result_type> data);
+
+ protected:
+  // Generate returns a single value.
+  static result_type Generate();
+};
+
+extern template class RandenPool<uint8_t>;
+extern template class RandenPool<uint16_t>;
+extern template class RandenPool<uint32_t>;
+extern template class RandenPool<uint64_t>;
+
+// PoolURBG uses an underlying pool of random generators to implement a
+// thread-compatible [random.req.urbg] interface with an internal cache of
+// values.
+template <typename T, size_t kBufferSize>
+class PoolURBG {
+  // Inheritance to access the protected static members of RandenPool.
+  using unsigned_type = typename make_unsigned_bits<T>::type;
+  using PoolType = RandenPool<unsigned_type>;
+  using SpanType = absl::Span<unsigned_type>;
+
+  static constexpr size_t kInitialBuffer = kBufferSize + 1;
+  static constexpr size_t kHalfBuffer = kBufferSize / 2;
+
+ public:
+  using result_type = T;
+
+  static_assert(std::is_unsigned<result_type>::value,
+                "PoolURBG must be parameterized by an unsigned integer type");
+
+  static_assert(kBufferSize > 1,
+                "PoolURBG must be parameterized by a buffer-size > 1");
+
+  static_assert(kBufferSize <= 256,
+                "PoolURBG must be parameterized by a buffer-size <= 256");
+
+  static constexpr result_type(min)() {
+    return (std::numeric_limits<result_type>::min)();
+  }
+
+  static constexpr result_type(max)() {
+    return (std::numeric_limits<result_type>::max)();
+  }
+
+  PoolURBG() : next_(kInitialBuffer) {}
+
+  // copy-constructor does not copy cache.
+  PoolURBG(const PoolURBG&) : next_(kInitialBuffer) {}
+  const PoolURBG& operator=(const PoolURBG&) {
+    next_ = kInitialBuffer;
+    return *this;
+  }
+
+  // move-constructor does move cache.
+  PoolURBG(PoolURBG&&) = default;
+  PoolURBG& operator=(PoolURBG&&) = default;
+
+  inline result_type operator()() {
+    if (next_ >= kBufferSize) {
+      next_ = (kBufferSize > 2 && next_ > kBufferSize) ? kHalfBuffer : 0;
+      PoolType::Fill(SpanType(reinterpret_cast<unsigned_type*>(state_ + next_),
+                              kBufferSize - next_));
+    }
+    return state_[next_++];
+  }
+
+ private:
+  // Buffer size.
+  size_t next_;  // index within state_
+  result_type state_[kBufferSize];
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_POOL_URBG_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen.h b/CAPI/cpp/grpc/include/absl/random/internal/randen.h
new file mode 100644
index 0000000..9ff4a7a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen.h
@@ -0,0 +1,96 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_RANDEN_H_
+#define ABSL_RANDOM_INTERNAL_RANDEN_H_
+
+#include <cstddef>
+
+#include "absl/random/internal/platform.h"
+#include "absl/random/internal/randen_hwaes.h"
+#include "absl/random/internal/randen_slow.h"
+#include "absl/random/internal/randen_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// RANDen = RANDom generator or beetroots in Swiss High German.
+// 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
+// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
+//
+// Randen implements the basic state manipulation methods.
+class Randen {
+ public:
+  static constexpr size_t kStateBytes = RandenTraits::kStateBytes;
+  static constexpr size_t kCapacityBytes = RandenTraits::kCapacityBytes;
+  static constexpr size_t kSeedBytes = RandenTraits::kSeedBytes;
+
+  ~Randen() = default;
+
+  Randen();
+
+  // Generate updates the randen sponge. The outer portion of the sponge
+  // (kCapacityBytes .. kStateBytes) may be consumed as PRNG state.
+  // REQUIRES: state points to kStateBytes of state.
+  inline void Generate(void* state) const {
+#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
+    // HW AES Dispatch.
+    if (has_crypto_) {
+      RandenHwAes::Generate(keys_, state);
+    } else {
+      RandenSlow::Generate(keys_, state);
+    }
+#elif ABSL_HAVE_ACCELERATED_AES
+    // HW AES is enabled.
+    RandenHwAes::Generate(keys_, state);
+#else
+    // HW AES is disabled.
+    RandenSlow::Generate(keys_, state);
+#endif
+  }
+
+  // Absorb incorporates additional seed material into the randen sponge.  After
+  // absorb returns, Generate must be called before the state may be consumed.
+  // REQUIRES: seed points to kSeedBytes of seed.
+  // REQUIRES: state points to kStateBytes of state.
+  inline void Absorb(const void* seed, void* state) const {
+#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
+    // HW AES Dispatch.
+    if (has_crypto_) {
+      RandenHwAes::Absorb(seed, state);
+    } else {
+      RandenSlow::Absorb(seed, state);
+    }
+#elif ABSL_HAVE_ACCELERATED_AES
+    // HW AES is enabled.
+    RandenHwAes::Absorb(seed, state);
+#else
+    // HW AES is disabled.
+    RandenSlow::Absorb(seed, state);
+#endif
+  }
+
+ private:
+  const void* keys_;
+#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
+  bool has_crypto_;
+#endif
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_RANDEN_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_detect.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_detect.h
new file mode 100644
index 0000000..f283f43
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_detect.h
@@ -0,0 +1,33 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_RANDEN_DETECT_H_
+#define ABSL_RANDOM_INTERNAL_RANDEN_DETECT_H_
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// Returns whether the current CPU supports RandenHwAes implementation.
+// This typically involves supporting cryptographic extensions on whichever
+// platform is currently running.
+bool CPUSupportsRandenHwAes();
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_RANDEN_DETECT_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_engine.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_engine.h
new file mode 100644
index 0000000..b470866
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_engine.h
@@ -0,0 +1,264 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_RANDEN_ENGINE_H_
+#define ABSL_RANDOM_INTERNAL_RANDEN_ENGINE_H_
+
+#include <algorithm>
+#include <cinttypes>
+#include <cstdlib>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <type_traits>
+
+#include "absl/base/internal/endian.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/internal/randen.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// Deterministic pseudorandom byte generator with backtracking resistance
+// (leaking the state does not compromise prior outputs). Based on Reverie
+// (see "A Robust and Sponge-Like PRNG with Improved Efficiency") instantiated
+// with an improved Simpira-like permutation.
+// Returns values of type "T" (must be a built-in unsigned integer type).
+//
+// RANDen = RANDom generator or beetroots in Swiss High German.
+// 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
+// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
+template <typename T>
+class alignas(8) randen_engine {
+ public:
+  // C++11 URBG interface:
+  using result_type = T;
+  static_assert(std::is_unsigned<result_type>::value,
+                "randen_engine template argument must be a built-in unsigned "
+                "integer type");
+
+  static constexpr result_type(min)() {
+    return (std::numeric_limits<result_type>::min)();
+  }
+
+  static constexpr result_type(max)() {
+    return (std::numeric_limits<result_type>::max)();
+  }
+
+  randen_engine() : randen_engine(0) {}
+  explicit randen_engine(result_type seed_value) { seed(seed_value); }
+
+  template <class SeedSequence,
+            typename = typename absl::enable_if_t<
+                !std::is_same<SeedSequence, randen_engine>::value>>
+  explicit randen_engine(SeedSequence&& seq) {
+    seed(seq);
+  }
+
+  // alignment requirements dictate custom copy and move constructors.
+  randen_engine(const randen_engine& other)
+      : next_(other.next_), impl_(other.impl_) {
+    std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type));
+  }
+  randen_engine& operator=(const randen_engine& other) {
+    next_ = other.next_;
+    impl_ = other.impl_;
+    std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type));
+    return *this;
+  }
+
+  // Returns random bits from the buffer in units of result_type.
+  result_type operator()() {
+    // Refill the buffer if needed (unlikely).
+    auto* begin = state();
+    if (next_ >= kStateSizeT) {
+      next_ = kCapacityT;
+      impl_.Generate(begin);
+    }
+    return little_endian::ToHost(begin[next_++]);
+  }
+
+  template <class SeedSequence>
+  typename absl::enable_if_t<
+      !std::is_convertible<SeedSequence, result_type>::value>
+  seed(SeedSequence&& seq) {
+    // Zeroes the state.
+    seed();
+    reseed(seq);
+  }
+
+  void seed(result_type seed_value = 0) {
+    next_ = kStateSizeT;
+    // Zeroes the inner state and fills the outer state with seed_value to
+    // mimic the behaviour of reseed
+    auto* begin = state();
+    std::fill(begin, begin + kCapacityT, 0);
+    std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value);
+  }
+
+  // Inserts entropy into (part of) the state. Calling this periodically with
+  // sufficient entropy ensures prediction resistance (attackers cannot predict
+  // future outputs even if state is compromised).
+  template <class SeedSequence>
+  void reseed(SeedSequence& seq) {
+    using sequence_result_type = typename SeedSequence::result_type;
+    static_assert(sizeof(sequence_result_type) == 4,
+                  "SeedSequence::result_type must be 32-bit");
+    constexpr size_t kBufferSize =
+        Randen::kSeedBytes / sizeof(sequence_result_type);
+    alignas(16) sequence_result_type buffer[kBufferSize];
+
+    // Randen::Absorb XORs the seed into state, which is then mixed by a call
+    // to Randen::Generate. Seeding with only the provided entropy is preferred
+    // to using an arbitrary generate() call, so use [rand.req.seed_seq]
+    // size as a proxy for the number of entropy units that can be generated
+    // without relying on seed sequence mixing...
+    const size_t entropy_size = seq.size();
+    if (entropy_size < kBufferSize) {
+      // ... and only request that many values, or 256-bits, when unspecified.
+      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
+      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
+      seq.generate(buffer, buffer + requested_entropy);
+#ifdef ABSL_IS_BIG_ENDIAN
+      // Randen expects the seed buffer to be in Little Endian; reverse it on
+      // Big Endian platforms.
+      for (sequence_result_type& e : buffer) {
+        e = absl::little_endian::FromHost(e);
+      }
+#endif
+      // The Randen paper suggests preferentially initializing even-numbered
+      // 128-bit vectors of the randen state (there are 16 such vectors).
+      // The seed data is merged into the state offset by 128-bits, which
+      // implies prefering seed bytes [16..31, ..., 208..223]. Since the
+      // buffer is 32-bit values, we swap the corresponding buffer positions in
+      // 128-bit chunks.
+      size_t dst = kBufferSize;
+      while (dst > 7) {
+        // leave the odd bucket as-is.
+        dst -= 4;
+        size_t src = dst >> 1;
+        // swap 128-bits into the even bucket
+        std::swap(buffer[--dst], buffer[--src]);
+        std::swap(buffer[--dst], buffer[--src]);
+        std::swap(buffer[--dst], buffer[--src]);
+        std::swap(buffer[--dst], buffer[--src]);
+      }
+    } else {
+      seq.generate(buffer, buffer + kBufferSize);
+    }
+    impl_.Absorb(buffer, state());
+
+    // Generate will be called when operator() is called
+    next_ = kStateSizeT;
+  }
+
+  void discard(uint64_t count) {
+    uint64_t step = std::min<uint64_t>(kStateSizeT - next_, count);
+    count -= step;
+
+    constexpr uint64_t kRateT = kStateSizeT - kCapacityT;
+    auto* begin = state();
+    while (count > 0) {
+      next_ = kCapacityT;
+      impl_.Generate(*reinterpret_cast<result_type(*)[kStateSizeT]>(begin));
+      step = std::min<uint64_t>(kRateT, count);
+      count -= step;
+    }
+    next_ += step;
+  }
+
+  bool operator==(const randen_engine& other) const {
+    const auto* begin = state();
+    return next_ == other.next_ &&
+           std::equal(begin, begin + kStateSizeT, other.state());
+  }
+
+  bool operator!=(const randen_engine& other) const {
+    return !(*this == other);
+  }
+
+  template <class CharT, class Traits>
+  friend std::basic_ostream<CharT, Traits>& operator<<(
+      std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+      const randen_engine<T>& engine) {       // NOLINT(runtime/references)
+    using numeric_type =
+        typename random_internal::stream_format_type<result_type>::type;
+    auto saver = random_internal::make_ostream_state_saver(os);
+    auto* it = engine.state();
+    for (auto* end = it + kStateSizeT; it < end; ++it) {
+      // In the case that `elem` is `uint8_t`, it must be cast to something
+      // larger so that it prints as an integer rather than a character. For
+      // simplicity, apply the cast all circumstances.
+      os << static_cast<numeric_type>(little_endian::FromHost(*it))
+         << os.fill();
+    }
+    os << engine.next_;
+    return os;
+  }
+
+  template <class CharT, class Traits>
+  friend std::basic_istream<CharT, Traits>& operator>>(
+      std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+      randen_engine<T>& engine) {             // NOLINT(runtime/references)
+    using numeric_type =
+        typename random_internal::stream_format_type<result_type>::type;
+    result_type state[kStateSizeT];
+    size_t next;
+    for (auto& elem : state) {
+      // It is not possible to read uint8_t from wide streams, so it is
+      // necessary to read a wider type and then cast it to uint8_t.
+      numeric_type value;
+      is >> value;
+      elem = little_endian::ToHost(static_cast<result_type>(value));
+    }
+    is >> next;
+    if (is.fail()) {
+      return is;
+    }
+    std::memcpy(engine.state(), state, sizeof(state));
+    engine.next_ = next;
+    return is;
+  }
+
+ private:
+  static constexpr size_t kStateSizeT =
+      Randen::kStateBytes / sizeof(result_type);
+  static constexpr size_t kCapacityT =
+      Randen::kCapacityBytes / sizeof(result_type);
+
+  // Returns the state array pointer, which is aligned to 16 bytes.
+  // The first kCapacityT are the `inner' sponge; the remainder are available.
+  result_type* state() {
+    return reinterpret_cast<result_type*>(
+        (reinterpret_cast<uintptr_t>(&raw_state_) & 0xf) ? (raw_state_ + 8)
+                                                         : raw_state_);
+  }
+  const result_type* state() const {
+    return const_cast<randen_engine*>(this)->state();
+  }
+
+  // raw state array, manually aligned in state(). This overallocates
+  // by 8 bytes since C++ does not guarantee extended heap alignment.
+  alignas(8) char raw_state_[Randen::kStateBytes + 8];
+  size_t next_;  // index within state()
+  Randen impl_;
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_RANDEN_ENGINE_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_hwaes.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_hwaes.h
new file mode 100644
index 0000000..71a7f69
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_hwaes.h
@@ -0,0 +1,50 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_RANDEN_HWAES_H_
+#define ABSL_RANDOM_INTERNAL_RANDEN_HWAES_H_
+
+#include "absl/base/config.h"
+
+// HERMETIC NOTE: The randen_hwaes target must not introduce duplicate
+// symbols from arbitrary system and other headers, since it may be built
+// with different flags from other targets, using different levels of
+// optimization, potentially introducing ODR violations.
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// RANDen = RANDom generator or beetroots in Swiss High German.
+// 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
+// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
+//
+// RandenHwAes implements the basic state manipulation methods.
+class RandenHwAes {
+ public:
+  static void Generate(const void* keys, void* state_void);
+  static void Absorb(const void* seed_void, void* state_void);
+  static const void* GetKeys();
+};
+
+// HasRandenHwAesImplementation returns true when there is an accelerated
+// implementation, and false otherwise.  If there is no implementation,
+// then attempting to use it will abort the program.
+bool HasRandenHwAesImplementation();
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_RANDEN_HWAES_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_slow.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_slow.h
new file mode 100644
index 0000000..532c3a8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_slow.h
@@ -0,0 +1,40 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_RANDEN_SLOW_H_
+#define ABSL_RANDOM_INTERNAL_RANDEN_SLOW_H_
+
+#include <cstddef>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// RANDen = RANDom generator or beetroots in Swiss High German.
+// RandenSlow implements the basic state manipulation methods for
+// architectures lacking AES hardware acceleration intrinsics.
+class RandenSlow {
+ public:
+  static void Generate(const void* keys, void* state_void);
+  static void Absorb(const void* seed_void, void* state_void);
+  static const void* GetKeys();
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_RANDEN_SLOW_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_traits.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_traits.h
new file mode 100644
index 0000000..120022c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_traits.h
@@ -0,0 +1,88 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_RANDEN_TRAITS_H_
+#define ABSL_RANDOM_INTERNAL_RANDEN_TRAITS_H_
+
+// HERMETIC NOTE: The randen_hwaes target must not introduce duplicate
+// symbols from arbitrary system and other headers, since it may be built
+// with different flags from other targets, using different levels of
+// optimization, potentially introducing ODR violations.
+
+#include <cstddef>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// RANDen = RANDom generator or beetroots in Swiss High German.
+// 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
+// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
+//
+// High-level summary:
+// 1) Reverie (see "A Robust and Sponge-Like PRNG with Improved Efficiency") is
+//    a sponge-like random generator that requires a cryptographic permutation.
+//    It improves upon "Provably Robust Sponge-Based PRNGs and KDFs" by
+//    achieving backtracking resistance with only one Permute() per buffer.
+//
+// 2) "Simpira v2: A Family of Efficient Permutations Using the AES Round
+//    Function" constructs up to 1024-bit permutations using an improved
+//    Generalized Feistel network with 2-round AES-128 functions. This Feistel
+//    block shuffle achieves diffusion faster and is less vulnerable to
+//    sliced-biclique attacks than the Type-2 cyclic shuffle.
+//
+// 3) "Improving the Generalized Feistel" and "New criterion for diffusion
+//    property" extends the same kind of improved Feistel block shuffle to 16
+//    branches, which enables a 2048-bit permutation.
+//
+// Combine these three ideas and also change Simpira's subround keys from
+// structured/low-entropy counters to digits of Pi (or other random source).
+
+// RandenTraits contains the basic algorithm traits, such as the size of the
+// state, seed, sponge, etc.
+struct RandenTraits {
+  // Size of the entire sponge / state for the randen PRNG.
+  static constexpr size_t kStateBytes = 256;  // 2048-bit
+
+  // Size of the 'inner' (inaccessible) part of the sponge. Larger values would
+  // require more frequent calls to RandenGenerate.
+  static constexpr size_t kCapacityBytes = 16;  // 128-bit
+
+  // Size of the default seed consumed by the sponge.
+  static constexpr size_t kSeedBytes = kStateBytes - kCapacityBytes;
+
+  // Assuming 128-bit blocks, the number of blocks in the state.
+  // Largest size for which security proofs are known.
+  static constexpr size_t kFeistelBlocks = 16;
+
+  // Ensures SPRP security and two full subblock diffusions.
+  // Must be > 4 * log2(kFeistelBlocks).
+  static constexpr size_t kFeistelRounds = 16 + 1;
+
+  // Size of the key. A 128-bit key block is used for every-other
+  // feistel block (Type-2 generalized Feistel network) in each round.
+  static constexpr size_t kKeyBytes = 16 * kFeistelRounds * kFeistelBlocks / 2;
+};
+
+// Randen key arrays. In randen_round_keys.cc
+extern const unsigned char kRandenRoundKeys[RandenTraits::kKeyBytes];
+extern const unsigned char kRandenRoundKeysBE[RandenTraits::kKeyBytes];
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_RANDEN_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/salted_seed_seq.h b/CAPI/cpp/grpc/include/absl/random/internal/salted_seed_seq.h
new file mode 100644
index 0000000..0629186
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/salted_seed_seq.h
@@ -0,0 +1,165 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
+#define ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
+
+#include <cstdint>
+#include <cstdlib>
+#include <initializer_list>
+#include <iterator>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/seed_material.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// This class conforms to the C++ Standard "Seed Sequence" concept
+// [rand.req.seedseq].
+//
+// A `SaltedSeedSeq` is meant to wrap an existing seed sequence and modify
+// generated sequence by mixing with extra entropy. This entropy may be
+// build-dependent or process-dependent. The implementation may change to be
+// have either or both kinds of entropy. If salt is not available sequence is
+// not modified.
+template <typename SSeq>
+class SaltedSeedSeq {
+ public:
+  using inner_sequence_type = SSeq;
+  using result_type = typename SSeq::result_type;
+
+  SaltedSeedSeq() : seq_(absl::make_unique<SSeq>()) {}
+
+  template <typename Iterator>
+  SaltedSeedSeq(Iterator begin, Iterator end)
+      : seq_(absl::make_unique<SSeq>(begin, end)) {}
+
+  template <typename T>
+  SaltedSeedSeq(std::initializer_list<T> il)
+      : SaltedSeedSeq(il.begin(), il.end()) {}
+
+  SaltedSeedSeq(const SaltedSeedSeq&) = delete;
+  SaltedSeedSeq& operator=(const SaltedSeedSeq&) = delete;
+
+  SaltedSeedSeq(SaltedSeedSeq&&) = default;
+  SaltedSeedSeq& operator=(SaltedSeedSeq&&) = default;
+
+  template <typename RandomAccessIterator>
+  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
+    using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
+
+    // The common case is that generate is called with ContiguousIterators
+    // to uint arrays. Such contiguous memory regions may be optimized,
+    // which we detect here.
+    using TagType = absl::conditional_t<
+        (std::is_same<U, uint32_t>::value &&
+         (std::is_pointer<RandomAccessIterator>::value ||
+          std::is_same<RandomAccessIterator,
+                       typename std::vector<U>::iterator>::value)),
+        ContiguousAndUint32Tag, DefaultTag>;
+    if (begin != end) {
+      generate_impl(TagType{}, begin, end, std::distance(begin, end));
+    }
+  }
+
+  template <typename OutIterator>
+  void param(OutIterator out) const {
+    seq_->param(out);
+  }
+
+  size_t size() const { return seq_->size(); }
+
+ private:
+  struct ContiguousAndUint32Tag {};
+  struct DefaultTag {};
+
+  // Generate which requires the iterators are contiguous pointers to uint32_t.
+  // Fills the initial seed buffer the underlying SSeq::generate() call,
+  // then mixes in the salt material.
+  template <typename Contiguous>
+  void generate_impl(ContiguousAndUint32Tag, Contiguous begin, Contiguous end,
+                     size_t n) {
+    seq_->generate(begin, end);
+    const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
+    auto span = absl::Span<uint32_t>(&*begin, n);
+    MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), span);
+  }
+
+  // The uncommon case for generate is that it is called with iterators over
+  // some other buffer type which is assignable from a 32-bit value. In this
+  // case we allocate a temporary 32-bit buffer and then copy-assign back
+  // to the initial inputs.
+  template <typename RandomAccessIterator>
+  void generate_impl(DefaultTag, RandomAccessIterator begin,
+                     RandomAccessIterator, size_t n) {
+    // Allocates a seed buffer of `n` elements, generates the seed, then
+    // copies the result into the `out` iterator.
+    absl::InlinedVector<uint32_t, 8> data(n, 0);
+    generate_impl(ContiguousAndUint32Tag{}, data.begin(), data.end(), n);
+    std::copy(data.begin(), data.end(), begin);
+  }
+
+  // Because [rand.req.seedseq] is not required to be copy-constructible,
+  // copy-assignable nor movable, we wrap it with unique pointer to be able
+  // to move SaltedSeedSeq.
+  std::unique_ptr<SSeq> seq_;
+};
+
+// is_salted_seed_seq indicates whether the type is a SaltedSeedSeq.
+template <typename T, typename = void>
+struct is_salted_seed_seq : public std::false_type {};
+
+template <typename T>
+struct is_salted_seed_seq<
+    T, typename std::enable_if<std::is_same<
+           T, SaltedSeedSeq<typename T::inner_sequence_type>>::value>::type>
+    : public std::true_type {};
+
+// MakeSaltedSeedSeq returns a salted variant of the seed sequence.
+// When provided with an existing SaltedSeedSeq, returns the input parameter,
+// otherwise constructs a new SaltedSeedSeq which embodies the original
+// non-salted seed parameters.
+template <
+    typename SSeq,  //
+    typename EnableIf = absl::enable_if_t<is_salted_seed_seq<SSeq>::value>>
+SSeq MakeSaltedSeedSeq(SSeq&& seq) {
+  return SSeq(std::forward<SSeq>(seq));
+}
+
+template <
+    typename SSeq,  //
+    typename EnableIf = absl::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
+SaltedSeedSeq<typename std::decay<SSeq>::type> MakeSaltedSeedSeq(SSeq&& seq) {
+  using sseq_type = typename std::decay<SSeq>::type;
+  using result_type = typename sseq_type::result_type;
+
+  absl::InlinedVector<result_type, 8> data;
+  seq.param(std::back_inserter(data));
+  return SaltedSeedSeq<sseq_type>(data.begin(), data.end());
+}
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/seed_material.h b/CAPI/cpp/grpc/include/absl/random/internal/seed_material.h
new file mode 100644
index 0000000..4be10e9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/seed_material.h
@@ -0,0 +1,104 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_SEED_MATERIAL_H_
+#define ABSL_RANDOM_INTERNAL_SEED_MATERIAL_H_
+
+#include <cassert>
+#include <cstdint>
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+#include "absl/base/attributes.h"
+#include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// Returns the number of 32-bit blocks needed to contain the given number of
+// bits.
+constexpr size_t SeedBitsToBlocks(size_t seed_size) {
+  return (seed_size + 31) / 32;
+}
+
+// Amount of entropy (measured in bits) used to instantiate a Seed Sequence,
+// with which to create a URBG.
+constexpr size_t kEntropyBitsNeeded = 256;
+
+// Amount of entropy (measured in 32-bit blocks) used to instantiate a Seed
+// Sequence, with which to create a URBG.
+constexpr size_t kEntropyBlocksNeeded =
+    random_internal::SeedBitsToBlocks(kEntropyBitsNeeded);
+
+static_assert(kEntropyBlocksNeeded > 0,
+              "Entropy used to seed URBGs must be nonzero.");
+
+// Attempts to fill a span of uint32_t-values using an OS-provided source of
+// true entropy (eg. /dev/urandom) into an array of uint32_t blocks of data. The
+// resulting array may be used to initialize an instance of a class conforming
+// to the C++ Standard "Seed Sequence" concept [rand.req.seedseq].
+//
+// If values.data() == nullptr, the behavior is undefined.
+ABSL_MUST_USE_RESULT
+bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values);
+
+// Attempts to fill a span of uint32_t-values using variates generated by an
+// existing instance of a class conforming to the C++ Standard "Uniform Random
+// Bit Generator" concept [rand.req.urng]. The resulting data may be used to
+// initialize an instance of a class conforming to the C++ Standard
+// "Seed Sequence" concept [rand.req.seedseq].
+//
+// If urbg == nullptr or values.data() == nullptr, the behavior is undefined.
+template <typename URBG>
+ABSL_MUST_USE_RESULT bool ReadSeedMaterialFromURBG(
+    URBG* urbg, absl::Span<uint32_t> values) {
+  random_internal::FastUniformBits<uint32_t> distr;
+
+  assert(urbg != nullptr && values.data() != nullptr);
+  if (urbg == nullptr || values.data() == nullptr) {
+    return false;
+  }
+
+  for (uint32_t& seed_value : values) {
+    seed_value = distr(*urbg);
+  }
+  return true;
+}
+
+// Mixes given sequence of values with into given sequence of seed material.
+// Time complexity of this function is O(sequence.size() *
+// seed_material.size()).
+//
+// Algorithm is based on code available at
+// https://gist.github.com/imneme/540829265469e673d045
+// by Melissa O'Neill.
+void MixIntoSeedMaterial(absl::Span<const uint32_t> sequence,
+                         absl::Span<uint32_t> seed_material);
+
+// Returns salt value.
+//
+// Salt is obtained only once and stored in static variable.
+//
+// May return empty value if optaining the salt was not possible.
+absl::optional<uint32_t> GetSaltMaterial();
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_SEED_MATERIAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/sequence_urbg.h b/CAPI/cpp/grpc/include/absl/random/internal/sequence_urbg.h
new file mode 100644
index 0000000..bc96a12
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/sequence_urbg.h
@@ -0,0 +1,60 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_SEQUENCE_URBG_H_
+#define ABSL_RANDOM_INTERNAL_SEQUENCE_URBG_H_
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <type_traits>
+#include <vector>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// `sequence_urbg` is a simple random number generator which meets the
+// requirements of [rand.req.urbg], and is solely for testing absl
+// distributions.
+class sequence_urbg {
+ public:
+  using result_type = uint64_t;
+
+  static constexpr result_type(min)() {
+    return (std::numeric_limits<result_type>::min)();
+  }
+  static constexpr result_type(max)() {
+    return (std::numeric_limits<result_type>::max)();
+  }
+
+  sequence_urbg(std::initializer_list<result_type> data) : i_(0), data_(data) {}
+  void reset() { i_ = 0; }
+
+  result_type operator()() { return data_[i_++ % data_.size()]; }
+
+  size_t invocations() const { return i_; }
+
+ private:
+  size_t i_;
+  std::vector<result_type> data_;
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_SEQUENCE_URBG_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/traits.h b/CAPI/cpp/grpc/include/absl/random/internal/traits.h
new file mode 100644
index 0000000..f874a0f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/traits.h
@@ -0,0 +1,149 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_TRAITS_H_
+#define ABSL_RANDOM_INTERNAL_TRAITS_H_
+
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/numeric/bits.h"
+#include "absl/numeric/int128.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// random_internal::is_widening_convertible<A, B>
+//
+// Returns whether a type A is widening-convertible to a type B.
+//
+// A is widening-convertible to B means:
+//   A a = <any number>;
+//   B b = a;
+//   A c = b;
+//   EXPECT_EQ(a, c);
+template <typename A, typename B>
+class is_widening_convertible {
+  // As long as there are enough bits in the exact part of a number:
+  // - unsigned can fit in float, signed, unsigned
+  // - signed can fit in float, signed
+  // - float can fit in float
+  // So we define rank to be:
+  // - rank(float) -> 2
+  // - rank(signed) -> 1
+  // - rank(unsigned) -> 0
+  template <class T>
+  static constexpr int rank() {
+    return !std::numeric_limits<T>::is_integer +
+           std::numeric_limits<T>::is_signed;
+  }
+
+ public:
+  // If an arithmetic-type B can represent at least as many digits as a type A,
+  // and B belongs to a rank no lower than A, then A can be safely represented
+  // by B through a widening-conversion.
+  static constexpr bool value =
+      std::numeric_limits<A>::digits <= std::numeric_limits<B>::digits &&
+      rank<A>() <= rank<B>();
+};
+
+template <typename T>
+struct IsIntegral : std::is_integral<T> {};
+template <>
+struct IsIntegral<absl::int128> : std::true_type {};
+template <>
+struct IsIntegral<absl::uint128> : std::true_type {};
+
+template <typename T>
+struct MakeUnsigned : std::make_unsigned<T> {};
+template <>
+struct MakeUnsigned<absl::int128> {
+  using type = absl::uint128;
+};
+template <>
+struct MakeUnsigned<absl::uint128> {
+  using type = absl::uint128;
+};
+
+template <typename T>
+struct IsUnsigned : std::is_unsigned<T> {};
+template <>
+struct IsUnsigned<absl::int128> : std::false_type {};
+template <>
+struct IsUnsigned<absl::uint128> : std::true_type {};
+
+// unsigned_bits<N>::type returns the unsigned int type with the indicated
+// number of bits.
+template <size_t N>
+struct unsigned_bits;
+
+template <>
+struct unsigned_bits<8> {
+  using type = uint8_t;
+};
+template <>
+struct unsigned_bits<16> {
+  using type = uint16_t;
+};
+template <>
+struct unsigned_bits<32> {
+  using type = uint32_t;
+};
+template <>
+struct unsigned_bits<64> {
+  using type = uint64_t;
+};
+
+template <>
+struct unsigned_bits<128> {
+  using type = absl::uint128;
+};
+
+// 256-bit wrapper for wide multiplications.
+struct U256 {
+  uint128 hi;
+  uint128 lo;
+};
+template <>
+struct unsigned_bits<256> {
+  using type = U256;
+};
+
+template <typename IntType>
+struct make_unsigned_bits {
+  using type = typename unsigned_bits<
+      std::numeric_limits<typename MakeUnsigned<IntType>::type>::digits>::type;
+};
+
+template <typename T>
+int BitWidth(T v) {
+  // Workaround for bit_width not supporting int128.
+  // Don't hardcode `64` to make sure this code does not trigger compiler
+  // warnings in smaller types.
+  constexpr int half_bits = sizeof(T) * 8 / 2;
+  if (sizeof(T) == 16 && (v >> half_bits) != 0) {
+    return bit_width(static_cast<uint64_t>(v >> half_bits)) + half_bits;
+  } else {
+    return bit_width(static_cast<uint64_t>(v));
+  }
+}
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/uniform_helper.h b/CAPI/cpp/grpc/include/absl/random/internal/uniform_helper.h
new file mode 100644
index 0000000..e68b82e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/uniform_helper.h
@@ -0,0 +1,244 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+#ifndef ABSL_RANDOM_INTERNAL_UNIFORM_HELPER_H_
+#define ABSL_RANDOM_INTERNAL_UNIFORM_HELPER_H_
+
+#include <cmath>
+#include <limits>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+template <typename IntType>
+class uniform_int_distribution;
+
+template <typename RealType>
+class uniform_real_distribution;
+
+// Interval tag types which specify whether the interval is open or closed
+// on either boundary.
+
+namespace random_internal {
+template <typename T>
+struct TagTypeCompare {};
+
+template <typename T>
+constexpr bool operator==(TagTypeCompare<T>, TagTypeCompare<T>) {
+  // Tags are mono-states. They always compare equal.
+  return true;
+}
+template <typename T>
+constexpr bool operator!=(TagTypeCompare<T>, TagTypeCompare<T>) {
+  return false;
+}
+
+}  // namespace random_internal
+
+struct IntervalClosedClosedTag
+    : public random_internal::TagTypeCompare<IntervalClosedClosedTag> {};
+struct IntervalClosedOpenTag
+    : public random_internal::TagTypeCompare<IntervalClosedOpenTag> {};
+struct IntervalOpenClosedTag
+    : public random_internal::TagTypeCompare<IntervalOpenClosedTag> {};
+struct IntervalOpenOpenTag
+    : public random_internal::TagTypeCompare<IntervalOpenOpenTag> {};
+
+namespace random_internal {
+
+// In the absence of an explicitly provided return-type, the template
+// "uniform_inferred_return_t<A, B>" is used to derive a suitable type, based on
+// the data-types of the endpoint-arguments {A lo, B hi}.
+//
+// Given endpoints {A lo, B hi}, one of {A, B} will be chosen as the
+// return-type, if one type can be implicitly converted into the other, in a
+// lossless way. The template "is_widening_convertible" implements the
+// compile-time logic for deciding if such a conversion is possible.
+//
+// If no such conversion between {A, B} exists, then the overload for
+// absl::Uniform() will be discarded, and the call will be ill-formed.
+// Return-type for absl::Uniform() when the return-type is inferred.
+template <typename A, typename B>
+using uniform_inferred_return_t =
+    absl::enable_if_t<absl::disjunction<is_widening_convertible<A, B>,
+                                        is_widening_convertible<B, A>>::value,
+                      typename std::conditional<
+                          is_widening_convertible<A, B>::value, B, A>::type>;
+
+// The functions
+//    uniform_lower_bound(tag, a, b)
+// and
+//    uniform_upper_bound(tag, a, b)
+// are used as implementation-details for absl::Uniform().
+//
+// Conceptually,
+//    [a, b] == [uniform_lower_bound(IntervalClosedClosed, a, b),
+//               uniform_upper_bound(IntervalClosedClosed, a, b)]
+//    (a, b) == [uniform_lower_bound(IntervalOpenOpen, a, b),
+//               uniform_upper_bound(IntervalOpenOpen, a, b)]
+//    [a, b) == [uniform_lower_bound(IntervalClosedOpen, a, b),
+//               uniform_upper_bound(IntervalClosedOpen, a, b)]
+//    (a, b] == [uniform_lower_bound(IntervalOpenClosed, a, b),
+//               uniform_upper_bound(IntervalOpenClosed, a, b)]
+//
+template <typename IntType, typename Tag>
+typename absl::enable_if_t<
+    absl::conjunction<
+        IsIntegral<IntType>,
+        absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
+                          std::is_same<Tag, IntervalOpenOpenTag>>>::value,
+    IntType>
+uniform_lower_bound(Tag, IntType a, IntType) {
+  return a < (std::numeric_limits<IntType>::max)() ? (a + 1) : a;
+}
+
+template <typename FloatType, typename Tag>
+typename absl::enable_if_t<
+    absl::conjunction<
+        std::is_floating_point<FloatType>,
+        absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
+                          std::is_same<Tag, IntervalOpenOpenTag>>>::value,
+    FloatType>
+uniform_lower_bound(Tag, FloatType a, FloatType b) {
+  return std::nextafter(a, b);
+}
+
+template <typename NumType, typename Tag>
+typename absl::enable_if_t<
+    absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
+                      std::is_same<Tag, IntervalClosedOpenTag>>::value,
+    NumType>
+uniform_lower_bound(Tag, NumType a, NumType) {
+  return a;
+}
+
+template <typename IntType, typename Tag>
+typename absl::enable_if_t<
+    absl::conjunction<
+        IsIntegral<IntType>,
+        absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
+                          std::is_same<Tag, IntervalOpenOpenTag>>>::value,
+    IntType>
+uniform_upper_bound(Tag, IntType, IntType b) {
+  return b > (std::numeric_limits<IntType>::min)() ? (b - 1) : b;
+}
+
+template <typename FloatType, typename Tag>
+typename absl::enable_if_t<
+    absl::conjunction<
+        std::is_floating_point<FloatType>,
+        absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
+                          std::is_same<Tag, IntervalOpenOpenTag>>>::value,
+    FloatType>
+uniform_upper_bound(Tag, FloatType, FloatType b) {
+  return b;
+}
+
+template <typename IntType, typename Tag>
+typename absl::enable_if_t<
+    absl::conjunction<
+        IsIntegral<IntType>,
+        absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
+                          std::is_same<Tag, IntervalOpenClosedTag>>>::value,
+    IntType>
+uniform_upper_bound(Tag, IntType, IntType b) {
+  return b;
+}
+
+template <typename FloatType, typename Tag>
+typename absl::enable_if_t<
+    absl::conjunction<
+        std::is_floating_point<FloatType>,
+        absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
+                          std::is_same<Tag, IntervalOpenClosedTag>>>::value,
+    FloatType>
+uniform_upper_bound(Tag, FloatType, FloatType b) {
+  return std::nextafter(b, (std::numeric_limits<FloatType>::max)());
+}
+
+// Returns whether the bounds are valid for the underlying distribution.
+// Inputs must have already been resolved via uniform_*_bound calls.
+//
+// The c++ standard constraints in [rand.dist.uni.int] are listed as:
+//    requires: lo <= hi.
+//
+// In the uniform_int_distrubtion, {lo, hi} are closed, closed. Thus:
+// [0, 0] is legal.
+// [0, 0) is not legal, but [0, 1) is, which translates to [0, 0].
+// (0, 1) is not legal, but (0, 2) is, which translates to [1, 1].
+// (0, 0] is not legal, but (0, 1] is, which translates to [1, 1].
+//
+// The c++ standard constraints in [rand.dist.uni.real] are listed as:
+//    requires: lo <= hi.
+//    requires: (hi - lo) <= numeric_limits<T>::max()
+//
+// In the uniform_real_distribution, {lo, hi} are closed, open, Thus:
+// [0, 0] is legal, which is [0, 0+epsilon).
+// [0, 0) is legal.
+// (0, 0) is not legal, but (0-epsilon, 0+epsilon) is.
+// (0, 0] is not legal, but (0, 0+epsilon] is.
+//
+template <typename FloatType>
+absl::enable_if_t<std::is_floating_point<FloatType>::value, bool>
+is_uniform_range_valid(FloatType a, FloatType b) {
+  return a <= b && std::isfinite(b - a);
+}
+
+template <typename IntType>
+absl::enable_if_t<IsIntegral<IntType>::value, bool>
+is_uniform_range_valid(IntType a, IntType b) {
+  return a <= b;
+}
+
+// UniformDistribution selects either absl::uniform_int_distribution
+// or absl::uniform_real_distribution depending on the NumType parameter.
+template <typename NumType>
+using UniformDistribution =
+    typename std::conditional<IsIntegral<NumType>::value,
+                              absl::uniform_int_distribution<NumType>,
+                              absl::uniform_real_distribution<NumType>>::type;
+
+// UniformDistributionWrapper is used as the underlying distribution type
+// by the absl::Uniform template function. It selects the proper Abseil
+// uniform distribution and provides constructor overloads that match the
+// expected parameter order as well as adjusting distribtuion bounds based
+// on the tag.
+template <typename NumType>
+struct UniformDistributionWrapper : public UniformDistribution<NumType> {
+  template <typename TagType>
+  explicit UniformDistributionWrapper(TagType, NumType lo, NumType hi)
+      : UniformDistribution<NumType>(
+            uniform_lower_bound<NumType>(TagType{}, lo, hi),
+            uniform_upper_bound<NumType>(TagType{}, lo, hi)) {}
+
+  explicit UniformDistributionWrapper(NumType lo, NumType hi)
+      : UniformDistribution<NumType>(
+            uniform_lower_bound<NumType>(IntervalClosedOpenTag(), lo, hi),
+            uniform_upper_bound<NumType>(IntervalClosedOpenTag(), lo, hi)) {}
+
+  explicit UniformDistributionWrapper()
+      : UniformDistribution<NumType>(std::numeric_limits<NumType>::lowest(),
+                                     (std::numeric_limits<NumType>::max)()) {}
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_UNIFORM_HELPER_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/wide_multiply.h b/CAPI/cpp/grpc/include/absl/random/internal/wide_multiply.h
new file mode 100644
index 0000000..891e363
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/internal/wide_multiply.h
@@ -0,0 +1,96 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_INTERNAL_WIDE_MULTIPLY_H_
+#define ABSL_RANDOM_INTERNAL_WIDE_MULTIPLY_H_
+
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#if (defined(_WIN32) || defined(_WIN64)) && defined(_M_IA64)
+#include <intrin.h>  // NOLINT(build/include_order)
+#pragma intrinsic(_umul128)
+#define ABSL_INTERNAL_USE_UMUL128 1
+#endif
+
+#include "absl/base/config.h"
+#include "absl/numeric/bits.h"
+#include "absl/numeric/int128.h"
+#include "absl/random/internal/traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// wide_multiply<T> multiplies two N-bit values to a 2N-bit result.
+template <typename UIntType>
+struct wide_multiply {
+  static constexpr size_t kN = std::numeric_limits<UIntType>::digits;
+  using input_type = UIntType;
+  using result_type = typename random_internal::unsigned_bits<kN * 2>::type;
+
+  static result_type multiply(input_type a, input_type b) {
+    return static_cast<result_type>(a) * b;
+  }
+
+  static input_type hi(result_type r) {
+    return static_cast<input_type>(r >> kN);
+  }
+  static input_type lo(result_type r) { return static_cast<input_type>(r); }
+
+  static_assert(std::is_unsigned<UIntType>::value,
+                "Class-template wide_multiply<> argument must be unsigned.");
+};
+
+// MultiplyU128ToU256 multiplies two 128-bit values to a 256-bit value.
+inline U256 MultiplyU128ToU256(uint128 a, uint128 b) {
+  const uint128 a00 = static_cast<uint64_t>(a);
+  const uint128 a64 = a >> 64;
+  const uint128 b00 = static_cast<uint64_t>(b);
+  const uint128 b64 = b >> 64;
+
+  const uint128 c00 = a00 * b00;
+  const uint128 c64a = a00 * b64;
+  const uint128 c64b = a64 * b00;
+  const uint128 c128 = a64 * b64;
+
+  const uint64_t carry =
+      static_cast<uint64_t>(((c00 >> 64) + static_cast<uint64_t>(c64a) +
+                             static_cast<uint64_t>(c64b)) >>
+                            64);
+
+  return {c128 + (c64a >> 64) + (c64b >> 64) + carry,
+          c00 + (c64a << 64) + (c64b << 64)};
+}
+
+
+template <>
+struct wide_multiply<uint128> {
+  using input_type = uint128;
+  using result_type = U256;
+
+  static result_type multiply(input_type a, input_type b) {
+    return MultiplyU128ToU256(a, b);
+  }
+
+  static input_type hi(result_type r) { return r.hi; }
+  static input_type lo(result_type r) { return r.lo; }
+};
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_INTERNAL_WIDE_MULTIPLY_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/log_uniform_int_distribution.h b/CAPI/cpp/grpc/include/absl/random/log_uniform_int_distribution.h
new file mode 100644
index 0000000..4afff8f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/log_uniform_int_distribution.h
@@ -0,0 +1,256 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_LOG_UNIFORM_INT_DISTRIBUTION_H_
+#define ABSL_RANDOM_LOG_UNIFORM_INT_DISTRIBUTION_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <istream>
+#include <limits>
+#include <ostream>
+#include <type_traits>
+
+#include "absl/numeric/bits.h"
+#include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/generate_real.h"
+#include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/internal/traits.h"
+#include "absl/random/uniform_int_distribution.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// log_uniform_int_distribution:
+//
+// Returns a random variate R in range [min, max] such that
+// floor(log(R-min, base)) is uniformly distributed.
+// We ensure uniformity by discretization using the
+// boundary sets [0, 1, base, base * base, ... min(base*n, max)]
+//
+template <typename IntType = int>
+class log_uniform_int_distribution {
+ private:
+  using unsigned_type =
+      typename random_internal::make_unsigned_bits<IntType>::type;
+
+ public:
+  using result_type = IntType;
+
+  class param_type {
+   public:
+    using distribution_type = log_uniform_int_distribution;
+
+    explicit param_type(
+        result_type min = 0,
+        result_type max = (std::numeric_limits<result_type>::max)(),
+        result_type base = 2)
+        : min_(min),
+          max_(max),
+          base_(base),
+          range_(static_cast<unsigned_type>(max_) -
+                 static_cast<unsigned_type>(min_)),
+          log_range_(0) {
+      assert(max_ >= min_);
+      assert(base_ > 1);
+
+      if (base_ == 2) {
+        // Determine where the first set bit is on range(), giving a log2(range)
+        // value which can be used to construct bounds.
+        log_range_ = (std::min)(random_internal::BitWidth(range()),
+                                std::numeric_limits<unsigned_type>::digits);
+      } else {
+        // NOTE: Computing the logN(x) introduces error from 2 sources:
+        // 1. Conversion of int to double loses precision for values >=
+        // 2^53, which may cause some log() computations to operate on
+        // different values.
+        // 2. The error introduced by the division will cause the result
+        // to differ from the expected value.
+        //
+        // Thus a result which should equal K may equal K +/- epsilon,
+        // which can eliminate some values depending on where the bounds fall.
+        const double inv_log_base = 1.0 / std::log(static_cast<double>(base_));
+        const double log_range = std::log(static_cast<double>(range()) + 0.5);
+        log_range_ = static_cast<int>(std::ceil(inv_log_base * log_range));
+      }
+    }
+
+    result_type(min)() const { return min_; }
+    result_type(max)() const { return max_; }
+    result_type base() const { return base_; }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.min_ == b.min_ && a.max_ == b.max_ && a.base_ == b.base_;
+    }
+
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class log_uniform_int_distribution;
+
+    int log_range() const { return log_range_; }
+    unsigned_type range() const { return range_; }
+
+    result_type min_;
+    result_type max_;
+    result_type base_;
+    unsigned_type range_;  // max - min
+    int log_range_;        // ceil(logN(range_))
+
+    static_assert(random_internal::IsIntegral<IntType>::value,
+                  "Class-template absl::log_uniform_int_distribution<> must be "
+                  "parameterized using an integral type.");
+  };
+
+  log_uniform_int_distribution() : log_uniform_int_distribution(0) {}
+
+  explicit log_uniform_int_distribution(
+      result_type min,
+      result_type max = (std::numeric_limits<result_type>::max)(),
+      result_type base = 2)
+      : param_(min, max, base) {}
+
+  explicit log_uniform_int_distribution(const param_type& p) : param_(p) {}
+
+  void reset() {}
+
+  // generating functions
+  template <typename URBG>
+  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
+    return (*this)(g, param_);
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                         const param_type& p) {
+    return static_cast<result_type>((p.min)() + Generate(g, p));
+  }
+
+  result_type(min)() const { return (param_.min)(); }
+  result_type(max)() const { return (param_.max)(); }
+  result_type base() const { return param_.base(); }
+
+  param_type param() const { return param_; }
+  void param(const param_type& p) { param_ = p; }
+
+  friend bool operator==(const log_uniform_int_distribution& a,
+                         const log_uniform_int_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const log_uniform_int_distribution& a,
+                         const log_uniform_int_distribution& b) {
+    return a.param_ != b.param_;
+  }
+
+ private:
+  // Returns a log-uniform variate in the range [0, p.range()]. The caller
+  // should add min() to shift the result to the correct range.
+  template <typename URNG>
+  unsigned_type Generate(URNG& g,  // NOLINT(runtime/references)
+                         const param_type& p);
+
+  param_type param_;
+};
+
+template <typename IntType>
+template <typename URBG>
+typename log_uniform_int_distribution<IntType>::unsigned_type
+log_uniform_int_distribution<IntType>::Generate(
+    URBG& g,  // NOLINT(runtime/references)
+    const param_type& p) {
+  // sample e over [0, log_range]. Map the results of e to this:
+  // 0 => 0
+  // 1 => [1, b-1]
+  // 2 => [b, (b^2)-1]
+  // n => [b^(n-1)..(b^n)-1]
+  const int e = absl::uniform_int_distribution<int>(0, p.log_range())(g);
+  if (e == 0) {
+    return 0;
+  }
+  const int d = e - 1;
+
+  unsigned_type base_e, top_e;
+  if (p.base() == 2) {
+    base_e = static_cast<unsigned_type>(1) << d;
+
+    top_e = (e >= std::numeric_limits<unsigned_type>::digits)
+                ? (std::numeric_limits<unsigned_type>::max)()
+                : (static_cast<unsigned_type>(1) << e) - 1;
+  } else {
+    const double r = std::pow(static_cast<double>(p.base()), d);
+    const double s = (r * static_cast<double>(p.base())) - 1.0;
+
+    base_e =
+        (r > static_cast<double>((std::numeric_limits<unsigned_type>::max)()))
+            ? (std::numeric_limits<unsigned_type>::max)()
+            : static_cast<unsigned_type>(r);
+
+    top_e =
+        (s > static_cast<double>((std::numeric_limits<unsigned_type>::max)()))
+            ? (std::numeric_limits<unsigned_type>::max)()
+            : static_cast<unsigned_type>(s);
+  }
+
+  const unsigned_type lo = (base_e >= p.range()) ? p.range() : base_e;
+  const unsigned_type hi = (top_e >= p.range()) ? p.range() : top_e;
+
+  // choose uniformly over [lo, hi]
+  return absl::uniform_int_distribution<result_type>(
+      static_cast<result_type>(lo), static_cast<result_type>(hi))(g);
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const log_uniform_int_distribution<IntType>& x) {
+  using stream_type =
+      typename random_internal::stream_format_type<IntType>::type;
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os << static_cast<stream_type>((x.min)()) << os.fill()
+     << static_cast<stream_type>((x.max)()) << os.fill()
+     << static_cast<stream_type>(x.base());
+  return os;
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,       // NOLINT(runtime/references)
+    log_uniform_int_distribution<IntType>& x) {  // NOLINT(runtime/references)
+  using param_type = typename log_uniform_int_distribution<IntType>::param_type;
+  using result_type =
+      typename log_uniform_int_distribution<IntType>::result_type;
+  using stream_type =
+      typename random_internal::stream_format_type<IntType>::type;
+
+  stream_type min;
+  stream_type max;
+  stream_type base;
+
+  auto saver = random_internal::make_istream_state_saver(is);
+  is >> min >> max >> base;
+  if (!is.fail()) {
+    x.param(param_type(static_cast<result_type>(min),
+                       static_cast<result_type>(max),
+                       static_cast<result_type>(base)));
+  }
+  return is;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_LOG_UNIFORM_INT_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/mock_distributions.h b/CAPI/cpp/grpc/include/absl/random/mock_distributions.h
new file mode 100644
index 0000000..764ab37
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/mock_distributions.h
@@ -0,0 +1,266 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: mock_distributions.h
+// -----------------------------------------------------------------------------
+//
+// This file contains mock distribution functions for use alongside an
+// `absl::MockingBitGen` object within the Googletest testing framework. Such
+// mocks are useful to provide deterministic values as return values within
+// (otherwise random) Abseil distribution functions.
+//
+// The return type of each function is a mock expectation object which
+// is used to set the match result.
+//
+// More information about the Googletest testing framework is available at
+// https://github.com/google/googletest
+//
+// EXPECT_CALL and ON_CALL need to be made within the same DLL component as
+// the call to absl::Uniform and related methods, otherwise mocking will fail
+// since the  underlying implementation creates a type-specific pointer which
+// will be distinct across different DLL boundaries.
+//
+// Example:
+//
+//   absl::MockingBitGen mock;
+//   EXPECT_CALL(absl::MockUniform<int>(), Call(mock, 1, 1000))
+//     .WillRepeatedly(testing::ReturnRoundRobin({20, 40}));
+//
+//   EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 20);
+//   EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 40);
+//   EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 20);
+//   EXPECT_EQ(absl::Uniform<int>(gen, 1, 1000), 40);
+
+#ifndef ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
+#define ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
+
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/distributions.h"
+#include "absl/random/internal/mock_overload_set.h"
+#include "absl/random/mocking_bit_gen.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// absl::MockUniform
+// -----------------------------------------------------------------------------
+//
+// Matches calls to absl::Uniform.
+//
+// `absl::MockUniform` is a class template used in conjunction with Googletest's
+// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
+// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
+// same way one would define mocks on a Googletest `MockFunction()`.
+//
+// Example:
+//
+//  absl::MockingBitGen mock;
+//  EXPECT_CALL(absl::MockUniform<uint32_t>(), Call(mock))
+//     .WillOnce(Return(123456));
+//  auto x = absl::Uniform<uint32_t>(mock);
+//  assert(x == 123456)
+//
+template <typename R>
+using MockUniform = random_internal::MockOverloadSet<
+    random_internal::UniformDistributionWrapper<R>,
+    R(IntervalClosedOpenTag, MockingBitGen&, R, R),
+    R(IntervalClosedClosedTag, MockingBitGen&, R, R),
+    R(IntervalOpenOpenTag, MockingBitGen&, R, R),
+    R(IntervalOpenClosedTag, MockingBitGen&, R, R), R(MockingBitGen&, R, R),
+    R(MockingBitGen&)>;
+
+// -----------------------------------------------------------------------------
+// absl::MockBernoulli
+// -----------------------------------------------------------------------------
+//
+// Matches calls to absl::Bernoulli.
+//
+// `absl::MockBernoulli` is a class used in conjunction with Googletest's
+// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
+// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
+// same way one would define mocks on a Googletest `MockFunction()`.
+//
+// Example:
+//
+//  absl::MockingBitGen mock;
+//  EXPECT_CALL(absl::MockBernoulli(), Call(mock, testing::_))
+//     .WillOnce(Return(false));
+//  assert(absl::Bernoulli(mock, 0.5) == false);
+//
+using MockBernoulli =
+    random_internal::MockOverloadSet<absl::bernoulli_distribution,
+                                     bool(MockingBitGen&, double)>;
+
+// -----------------------------------------------------------------------------
+// absl::MockBeta
+// -----------------------------------------------------------------------------
+//
+// Matches calls to absl::Beta.
+//
+// `absl::MockBeta` is a class used in conjunction with Googletest's `ON_CALL()`
+// and `EXPECT_CALL()` macros. To use it, default-construct an instance of it
+// inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the same way one
+// would define mocks on a Googletest `MockFunction()`.
+//
+// Example:
+//
+//  absl::MockingBitGen mock;
+//  EXPECT_CALL(absl::MockBeta(), Call(mock, 3.0, 2.0))
+//     .WillOnce(Return(0.567));
+//  auto x = absl::Beta<double>(mock, 3.0, 2.0);
+//  assert(x == 0.567);
+//
+template <typename RealType>
+using MockBeta =
+    random_internal::MockOverloadSet<absl::beta_distribution<RealType>,
+                                     RealType(MockingBitGen&, RealType,
+                                              RealType)>;
+
+// -----------------------------------------------------------------------------
+// absl::MockExponential
+// -----------------------------------------------------------------------------
+//
+// Matches calls to absl::Exponential.
+//
+// `absl::MockExponential` is a class template used in conjunction with
+// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
+// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
+// and use `Call(...)` the same way one would define mocks on a
+// Googletest `MockFunction()`.
+//
+// Example:
+//
+//  absl::MockingBitGen mock;
+//  EXPECT_CALL(absl::MockExponential<double>(), Call(mock, 0.5))
+//     .WillOnce(Return(12.3456789));
+//  auto x = absl::Exponential<double>(mock, 0.5);
+//  assert(x == 12.3456789)
+//
+template <typename RealType>
+using MockExponential =
+    random_internal::MockOverloadSet<absl::exponential_distribution<RealType>,
+                                     RealType(MockingBitGen&, RealType)>;
+
+// -----------------------------------------------------------------------------
+// absl::MockGaussian
+// -----------------------------------------------------------------------------
+//
+// Matches calls to absl::Gaussian.
+//
+// `absl::MockGaussian` is a class template used in conjunction with
+// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
+// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
+// and use `Call(...)` the same way one would define mocks on a
+// Googletest `MockFunction()`.
+//
+// Example:
+//
+//  absl::MockingBitGen mock;
+//  EXPECT_CALL(absl::MockGaussian<double>(), Call(mock, 16.3, 3.3))
+//     .WillOnce(Return(12.3456789));
+//  auto x = absl::Gaussian<double>(mock, 16.3, 3.3);
+//  assert(x == 12.3456789)
+//
+template <typename RealType>
+using MockGaussian =
+    random_internal::MockOverloadSet<absl::gaussian_distribution<RealType>,
+                                     RealType(MockingBitGen&, RealType,
+                                              RealType)>;
+
+// -----------------------------------------------------------------------------
+// absl::MockLogUniform
+// -----------------------------------------------------------------------------
+//
+// Matches calls to absl::LogUniform.
+//
+// `absl::MockLogUniform` is a class template used in conjunction with
+// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
+// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
+// and use `Call(...)` the same way one would define mocks on a
+// Googletest `MockFunction()`.
+//
+// Example:
+//
+//  absl::MockingBitGen mock;
+//  EXPECT_CALL(absl::MockLogUniform<int>(), Call(mock, 10, 10000, 10))
+//     .WillOnce(Return(1221));
+//  auto x = absl::LogUniform<int>(mock, 10, 10000, 10);
+//  assert(x == 1221)
+//
+template <typename IntType>
+using MockLogUniform = random_internal::MockOverloadSet<
+    absl::log_uniform_int_distribution<IntType>,
+    IntType(MockingBitGen&, IntType, IntType, IntType)>;
+
+// -----------------------------------------------------------------------------
+// absl::MockPoisson
+// -----------------------------------------------------------------------------
+//
+// Matches calls to absl::Poisson.
+//
+// `absl::MockPoisson` is a class template used in conjunction with Googletest's
+// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
+// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
+// same way one would define mocks on a Googletest `MockFunction()`.
+//
+// Example:
+//
+//  absl::MockingBitGen mock;
+//  EXPECT_CALL(absl::MockPoisson<int>(), Call(mock, 2.0))
+//     .WillOnce(Return(1221));
+//  auto x = absl::Poisson<int>(mock, 2.0);
+//  assert(x == 1221)
+//
+template <typename IntType>
+using MockPoisson =
+    random_internal::MockOverloadSet<absl::poisson_distribution<IntType>,
+                                     IntType(MockingBitGen&, double)>;
+
+// -----------------------------------------------------------------------------
+// absl::MockZipf
+// -----------------------------------------------------------------------------
+//
+// Matches calls to absl::Zipf.
+//
+// `absl::MockZipf` is a class template used in conjunction with Googletest's
+// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
+// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
+// same way one would define mocks on a Googletest `MockFunction()`.
+//
+// Example:
+//
+//  absl::MockingBitGen mock;
+//  EXPECT_CALL(absl::MockZipf<int>(), Call(mock, 1000000, 2.0, 1.0))
+//     .WillOnce(Return(1221));
+//  auto x = absl::Zipf<int>(mock, 1000000, 2.0, 1.0);
+//  assert(x == 1221)
+//
+template <typename IntType>
+using MockZipf =
+    random_internal::MockOverloadSet<absl::zipf_distribution<IntType>,
+                                     IntType(MockingBitGen&, IntType, double,
+                                             double)>;
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/mocking_bit_gen.h b/CAPI/cpp/grpc/include/absl/random/mocking_bit_gen.h
new file mode 100644
index 0000000..89fa5a4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/mocking_bit_gen.h
@@ -0,0 +1,240 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// mocking_bit_gen.h
+// -----------------------------------------------------------------------------
+//
+// This file includes an `absl::MockingBitGen` class to use as a mock within the
+// Googletest testing framework. Such a mock is useful to provide deterministic
+// values as return values within (otherwise random) Abseil distribution
+// functions. Such determinism within a mock is useful within testing frameworks
+// to test otherwise indeterminate APIs.
+//
+// More information about the Googletest testing framework is available at
+// https://github.com/google/googletest
+
+#ifndef ABSL_RANDOM_MOCKING_BIT_GEN_H_
+#define ABSL_RANDOM_MOCKING_BIT_GEN_H_
+
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/internal/fast_type_id.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/meta/type_traits.h"
+#include "absl/random/distributions.h"
+#include "absl/random/internal/distribution_caller.h"
+#include "absl/random/random.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace random_internal {
+template <typename>
+struct DistributionCaller;
+class MockHelpers;
+
+}  // namespace random_internal
+class BitGenRef;
+
+// MockingBitGen
+//
+// `absl::MockingBitGen` is a mock Uniform Random Bit Generator (URBG) class
+// which can act in place of an `absl::BitGen` URBG within tests using the
+// Googletest testing framework.
+//
+// Usage:
+//
+// Use an `absl::MockingBitGen` along with a mock distribution object (within
+// mock_distributions.h) inside Googletest constructs such as ON_CALL(),
+// EXPECT_TRUE(), etc. to produce deterministic results conforming to the
+// distribution's API contract.
+//
+// Example:
+//
+//  // Mock a call to an `absl::Bernoulli` distribution using Googletest
+//   absl::MockingBitGen bitgen;
+//
+//   ON_CALL(absl::MockBernoulli(), Call(bitgen, 0.5))
+//       .WillByDefault(testing::Return(true));
+//   EXPECT_TRUE(absl::Bernoulli(bitgen, 0.5));
+//
+//  // Mock a call to an `absl::Uniform` distribution within Googletest
+//  absl::MockingBitGen bitgen;
+//
+//   ON_CALL(absl::MockUniform<int>(), Call(bitgen, testing::_, testing::_))
+//       .WillByDefault([] (int low, int high) {
+//           return low + (high - low) / 2;
+//       });
+//
+//   EXPECT_EQ(absl::Uniform<int>(gen, 0, 10), 5);
+//   EXPECT_EQ(absl::Uniform<int>(gen, 30, 40), 35);
+//
+// At this time, only mock distributions supplied within the Abseil random
+// library are officially supported.
+//
+// EXPECT_CALL and ON_CALL need to be made within the same DLL component as
+// the call to absl::Uniform and related methods, otherwise mocking will fail
+// since the  underlying implementation creates a type-specific pointer which
+// will be distinct across different DLL boundaries.
+//
+class MockingBitGen {
+ public:
+  MockingBitGen() = default;
+  ~MockingBitGen() = default;
+
+  // URBG interface
+  using result_type = absl::BitGen::result_type;
+
+  static constexpr result_type(min)() { return (absl::BitGen::min)(); }
+  static constexpr result_type(max)() { return (absl::BitGen::max)(); }
+  result_type operator()() { return gen_(); }
+
+ private:
+  // GetMockFnType returns the testing::MockFunction for a result and tuple.
+  // This method only exists for type deduction and is otherwise unimplemented.
+  template <typename ResultT, typename... Args>
+  static auto GetMockFnType(ResultT, std::tuple<Args...>)
+      -> ::testing::MockFunction<ResultT(Args...)>;
+
+  // MockFnCaller is a helper method for use with absl::apply to
+  // apply an ArgTupleT to a compatible MockFunction.
+  // NOTE: MockFnCaller is essentially equivalent to the lambda:
+  // [fn](auto... args) { return fn->Call(std::move(args)...)}
+  // however that fails to build on some supported platforms.
+  template <typename MockFnType, typename ResultT, typename Tuple>
+  struct MockFnCaller;
+
+  // specialization for std::tuple.
+  template <typename MockFnType, typename ResultT, typename... Args>
+  struct MockFnCaller<MockFnType, ResultT, std::tuple<Args...>> {
+    MockFnType* fn;
+    inline ResultT operator()(Args... args) {
+      return fn->Call(std::move(args)...);
+    }
+  };
+
+  // FunctionHolder owns a particular ::testing::MockFunction associated with
+  // a mocked type signature, and implement the type-erased Apply call, which
+  // applies type-erased arguments to the mock.
+  class FunctionHolder {
+   public:
+    virtual ~FunctionHolder() = default;
+
+    // Call is a dispatch function which converts the
+    // generic type-erased parameters into a specific mock invocation call.
+    virtual void Apply(/*ArgTupleT*/ void* args_tuple,
+                       /*ResultT*/ void* result) = 0;
+  };
+
+  template <typename MockFnType, typename ResultT, typename ArgTupleT>
+  class FunctionHolderImpl final : public FunctionHolder {
+   public:
+    void Apply(void* args_tuple, void* result) override {
+      // Requires tuple_args to point to a ArgTupleT, which is a
+      // std::tuple<Args...> used to invoke the mock function. Requires result
+      // to point to a ResultT, which is the result of the call.
+      *static_cast<ResultT*>(result) =
+          absl::apply(MockFnCaller<MockFnType, ResultT, ArgTupleT>{&mock_fn_},
+                      *static_cast<ArgTupleT*>(args_tuple));
+    }
+
+    MockFnType mock_fn_;
+  };
+
+  // MockingBitGen::RegisterMock
+  //
+  // RegisterMock<ResultT, ArgTupleT>(FastTypeIdType) is the main extension
+  // point for extending the MockingBitGen framework. It provides a mechanism to
+  // install a mock expectation for a function like ResultT(Args...) keyed by
+  // type_idex onto the MockingBitGen context. The key is that the type_index
+  // used to register must match the type index used to call the mock.
+  //
+  // The returned MockFunction<...> type can be used to setup additional
+  // distribution parameters of the expectation.
+  template <typename ResultT, typename ArgTupleT, typename SelfT>
+  auto RegisterMock(SelfT&, base_internal::FastTypeIdType type)
+      -> decltype(GetMockFnType(std::declval<ResultT>(),
+                                std::declval<ArgTupleT>()))& {
+    using MockFnType = decltype(GetMockFnType(std::declval<ResultT>(),
+                                              std::declval<ArgTupleT>()));
+
+    using WrappedFnType = absl::conditional_t<
+        std::is_same<SelfT, ::testing::NiceMock<absl::MockingBitGen>>::value,
+        ::testing::NiceMock<MockFnType>,
+        absl::conditional_t<
+            std::is_same<SelfT,
+                         ::testing::NaggyMock<absl::MockingBitGen>>::value,
+            ::testing::NaggyMock<MockFnType>,
+            absl::conditional_t<
+                std::is_same<SelfT,
+                             ::testing::StrictMock<absl::MockingBitGen>>::value,
+                ::testing::StrictMock<MockFnType>, MockFnType>>>;
+
+    using ImplT = FunctionHolderImpl<WrappedFnType, ResultT, ArgTupleT>;
+    auto& mock = mocks_[type];
+    if (!mock) {
+      mock = absl::make_unique<ImplT>();
+    }
+    return static_cast<ImplT*>(mock.get())->mock_fn_;
+  }
+
+  // MockingBitGen::InvokeMock
+  //
+  // InvokeMock(FastTypeIdType, args, result) is the entrypoint for invoking
+  // mocks registered on MockingBitGen.
+  //
+  // When no mocks are registered on the provided FastTypeIdType, returns false.
+  // Otherwise attempts to invoke the mock function ResultT(Args...) that
+  // was previously registered via the type_index.
+  // Requires tuple_args to point to a ArgTupleT, which is a std::tuple<Args...>
+  // used to invoke the mock function.
+  // Requires result to point to a ResultT, which is the result of the call.
+  inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple,
+                         void* result) {
+    // Trigger a mock, if there exists one that matches `param`.
+    auto it = mocks_.find(type);
+    if (it == mocks_.end()) return false;
+    it->second->Apply(args_tuple, result);
+    return true;
+  }
+
+  absl::flat_hash_map<base_internal::FastTypeIdType,
+                      std::unique_ptr<FunctionHolder>>
+      mocks_;
+  absl::BitGen gen_;
+
+  template <typename>
+  friend struct ::absl::random_internal::DistributionCaller;  // for InvokeMock
+  friend class ::absl::BitGenRef;                             // for InvokeMock
+  friend class ::absl::random_internal::MockHelpers;  // for RegisterMock,
+                                                      // InvokeMock
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_MOCKING_BIT_GEN_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/poisson_distribution.h b/CAPI/cpp/grpc/include/absl/random/poisson_distribution.h
new file mode 100644
index 0000000..f457308
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/poisson_distribution.h
@@ -0,0 +1,261 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_POISSON_DISTRIBUTION_H_
+#define ABSL_RANDOM_POISSON_DISTRIBUTION_H_
+
+#include <cassert>
+#include <cmath>
+#include <istream>
+#include <limits>
+#include <ostream>
+#include <type_traits>
+
+#include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/fastmath.h"
+#include "absl/random/internal/generate_real.h"
+#include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/internal/traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::poisson_distribution:
+// Generates discrete variates conforming to a Poisson distribution.
+//   p(n) = (mean^n / n!) exp(-mean)
+//
+// Depending on the parameter, the distribution selects one of the following
+// algorithms:
+// * The standard algorithm, attributed to Knuth, extended using a split method
+// for larger values
+// * The "Ratio of Uniforms as a convenient method for sampling from classical
+// discrete distributions", Stadlober, 1989.
+// http://www.sciencedirect.com/science/article/pii/0377042790903495
+//
+// NOTE: param_type.mean() is a double, which permits values larger than
+// poisson_distribution<IntType>::max(), however this should be avoided and
+// the distribution results are limited to the max() value.
+//
+// The goals of this implementation are to provide good performance while still
+// beig thread-safe: This limits the implementation to not using lgamma provided
+// by <math.h>.
+//
+template <typename IntType = int>
+class poisson_distribution {
+ public:
+  using result_type = IntType;
+
+  class param_type {
+   public:
+    using distribution_type = poisson_distribution;
+    explicit param_type(double mean = 1.0);
+
+    double mean() const { return mean_; }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.mean_ == b.mean_;
+    }
+
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class poisson_distribution;
+
+    double mean_;
+    double emu_;  // e ^ -mean_
+    double lmu_;  // ln(mean_)
+    double s_;
+    double log_k_;
+    int split_;
+
+    static_assert(random_internal::IsIntegral<IntType>::value,
+                  "Class-template absl::poisson_distribution<> must be "
+                  "parameterized using an integral type.");
+  };
+
+  poisson_distribution() : poisson_distribution(1.0) {}
+
+  explicit poisson_distribution(double mean) : param_(mean) {}
+
+  explicit poisson_distribution(const param_type& p) : param_(p) {}
+
+  void reset() {}
+
+  // generating functions
+  template <typename URBG>
+  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
+    return (*this)(g, param_);
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                         const param_type& p);
+
+  param_type param() const { return param_; }
+  void param(const param_type& p) { param_ = p; }
+
+  result_type(min)() const { return 0; }
+  result_type(max)() const { return (std::numeric_limits<result_type>::max)(); }
+
+  double mean() const { return param_.mean(); }
+
+  friend bool operator==(const poisson_distribution& a,
+                         const poisson_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const poisson_distribution& a,
+                         const poisson_distribution& b) {
+    return a.param_ != b.param_;
+  }
+
+ private:
+  param_type param_;
+  random_internal::FastUniformBits<uint64_t> fast_u64_;
+};
+
+// -----------------------------------------------------------------------------
+// Implementation details follow
+// -----------------------------------------------------------------------------
+
+template <typename IntType>
+poisson_distribution<IntType>::param_type::param_type(double mean)
+    : mean_(mean), split_(0) {
+  assert(mean >= 0);
+  assert(mean <=
+         static_cast<double>((std::numeric_limits<result_type>::max)()));
+  // As a defensive measure, avoid large values of the mean.  The rejection
+  // algorithm used does not support very large values well.  It my be worth
+  // changing algorithms to better deal with these cases.
+  assert(mean <= 1e10);
+  if (mean_ < 10) {
+    // For small lambda, use the knuth method.
+    split_ = 1;
+    emu_ = std::exp(-mean_);
+  } else if (mean_ <= 50) {
+    // Use split-knuth method.
+    split_ = 1 + static_cast<int>(mean_ / 10.0);
+    emu_ = std::exp(-mean_ / static_cast<double>(split_));
+  } else {
+    // Use ratio of uniforms method.
+    constexpr double k2E = 0.7357588823428846;
+    constexpr double kSA = 0.4494580810294493;
+
+    lmu_ = std::log(mean_);
+    double a = mean_ + 0.5;
+    s_ = kSA + std::sqrt(k2E * a);
+    const double mode = std::ceil(mean_) - 1;
+    log_k_ = lmu_ * mode - absl::random_internal::StirlingLogFactorial(mode);
+  }
+}
+
+template <typename IntType>
+template <typename URBG>
+typename poisson_distribution<IntType>::result_type
+poisson_distribution<IntType>::operator()(
+    URBG& g,  // NOLINT(runtime/references)
+    const param_type& p) {
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using random_internal::GenerateSignedTag;
+
+  if (p.split_ != 0) {
+    // Use Knuth's algorithm with range splitting to avoid floating-point
+    // errors. Knuth's algorithm is: Ui is a sequence of uniform variates on
+    // (0,1); return the number of variates required for product(Ui) <
+    // exp(-lambda).
+    //
+    // The expected number of variates required for Knuth's method can be
+    // computed as follows:
+    // The expected value of U is 0.5, so solving for 0.5^n < exp(-lambda) gives
+    // the expected number of uniform variates
+    // required for a given lambda, which is:
+    //  lambda = [2, 5,  9, 10, 11, 12, 13, 14, 15, 16, 17]
+    //  n      = [3, 8, 13, 15, 16, 18, 19, 21, 22, 24, 25]
+    //
+    result_type n = 0;
+    for (int split = p.split_; split > 0; --split) {
+      double r = 1.0;
+      do {
+        r *= GenerateRealFromBits<double, GeneratePositiveTag, true>(
+            fast_u64_(g));  // U(-1, 0)
+        ++n;
+      } while (r > p.emu_);
+      --n;
+    }
+    return n;
+  }
+
+  // Use ratio of uniforms method.
+  //
+  // Let u ~ Uniform(0, 1), v ~ Uniform(-1, 1),
+  //     a = lambda + 1/2,
+  //     s = 1.5 - sqrt(3/e) + sqrt(2(lambda + 1/2)/e),
+  //     x = s * v/u + a.
+  // P(floor(x) = k | u^2 < f(floor(x))/k), where
+  // f(m) = lambda^m exp(-lambda)/ m!, for 0 <= m, and f(m) = 0 otherwise,
+  // and k = max(f).
+  const double a = p.mean_ + 0.5;
+  for (;;) {
+    const double u = GenerateRealFromBits<double, GeneratePositiveTag, false>(
+        fast_u64_(g));  // U(0, 1)
+    const double v = GenerateRealFromBits<double, GenerateSignedTag, false>(
+        fast_u64_(g));  // U(-1, 1)
+
+    const double x = std::floor(p.s_ * v / u + a);
+    if (x < 0) continue;  // f(negative) = 0
+    const double rhs = x * p.lmu_;
+    // clang-format off
+    double s = (x <= 1.0) ? 0.0
+             : (x == 2.0) ? 0.693147180559945
+             : absl::random_internal::StirlingLogFactorial(x);
+    // clang-format on
+    const double lhs = 2.0 * std::log(u) + p.log_k_ + s;
+    if (lhs < rhs) {
+      return x > static_cast<double>((max)())
+                 ? (max)()
+                 : static_cast<result_type>(x);  // f(x)/k >= u^2
+    }
+  }
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const poisson_distribution<IntType>& x) {
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os.precision(random_internal::stream_precision_helper<double>::kPrecision);
+  os << x.mean();
+  return os;
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+    poisson_distribution<IntType>& x) {     // NOLINT(runtime/references)
+  using param_type = typename poisson_distribution<IntType>::param_type;
+
+  auto saver = random_internal::make_istream_state_saver(is);
+  double mean = random_internal::read_floating_point<double>(is);
+  if (!is.fail()) {
+    x.param(param_type(mean));
+  }
+  return is;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_POISSON_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/random.h b/CAPI/cpp/grpc/include/absl/random/random.h
new file mode 100644
index 0000000..71b6309
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/random.h
@@ -0,0 +1,189 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: random.h
+// -----------------------------------------------------------------------------
+//
+// This header defines the recommended Uniform Random Bit Generator (URBG)
+// types for use within the Abseil Random library. These types are not
+// suitable for security-related use-cases, but should suffice for most other
+// uses of generating random values.
+//
+// The Abseil random library provides the following URBG types:
+//
+//   * BitGen, a good general-purpose bit generator, optimized for generating
+//     random (but not cryptographically secure) values
+//   * InsecureBitGen, a slightly faster, though less random, bit generator, for
+//     cases where the existing BitGen is a drag on performance.
+
+#ifndef ABSL_RANDOM_RANDOM_H_
+#define ABSL_RANDOM_RANDOM_H_
+
+#include <random>
+
+#include "absl/random/distributions.h"  // IWYU pragma: export
+#include "absl/random/internal/nonsecure_base.h"  // IWYU pragma: export
+#include "absl/random/internal/pcg_engine.h"  // IWYU pragma: export
+#include "absl/random/internal/pool_urbg.h"
+#include "absl/random/internal/randen_engine.h"
+#include "absl/random/seed_sequences.h"  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// absl::BitGen
+// -----------------------------------------------------------------------------
+//
+// `absl::BitGen` is a general-purpose random bit generator for generating
+// random values for use within the Abseil random library. Typically, you use a
+// bit generator in combination with a distribution to provide random values.
+//
+// Example:
+//
+//   // Create an absl::BitGen. There is no need to seed this bit generator.
+//   absl::BitGen gen;
+//
+//   // Generate an integer value in the closed interval [1,6]
+//   int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
+//
+// `absl::BitGen` is seeded by default with non-deterministic data to produce
+// different sequences of random values across different instances, including
+// different binary invocations. This behavior is different than the standard
+// library bit generators, which use golden values as their seeds. Default
+// construction intentionally provides no stability guarantees, to avoid
+// accidental dependence on such a property.
+//
+// `absl::BitGen` may be constructed with an optional seed sequence type,
+// conforming to [rand.req.seed_seq], which will be mixed with additional
+// non-deterministic data.
+//
+// Example:
+//
+//  // Create an absl::BitGen using an std::seed_seq seed sequence
+//  std::seed_seq seq{1,2,3};
+//  absl::BitGen gen_with_seed(seq);
+//
+//  // Generate an integer value in the closed interval [1,6]
+//  int die_roll2 = absl::uniform_int_distribution<int>(1, 6)(gen_with_seed);
+//
+// `absl::BitGen` meets the requirements of the Uniform Random Bit Generator
+// (URBG) concept as per the C++17 standard [rand.req.urng] though differs
+// slightly with [rand.req.eng]. Like its standard library equivalents (e.g.
+// `std::mersenne_twister_engine`) `absl::BitGen` is not cryptographically
+// secure.
+//
+// Constructing two `absl::BitGen`s with the same seed sequence in the same
+// binary will produce the same sequence of variates within the same binary, but
+// need not do so across multiple binary invocations.
+//
+// This type has been optimized to perform better than Mersenne Twister
+// (https://en.wikipedia.org/wiki/Mersenne_Twister) and many other complex URBG
+// types on modern x86, ARM, and PPC architectures.
+//
+// This type is thread-compatible, but not thread-safe.
+
+// ---------------------------------------------------------------------------
+// absl::BitGen member functions
+// ---------------------------------------------------------------------------
+
+// absl::BitGen::operator()()
+//
+// Calls the BitGen, returning a generated value.
+
+// absl::BitGen::min()
+//
+// Returns the smallest possible value from this bit generator.
+
+// absl::BitGen::max()
+//
+// Returns the largest possible value from this bit generator.
+
+// absl::BitGen::discard(num)
+//
+// Advances the internal state of this bit generator by `num` times, and
+// discards the intermediate results.
+// ---------------------------------------------------------------------------
+
+using BitGen = random_internal::NonsecureURBGBase<
+    random_internal::randen_engine<uint64_t>>;
+
+// -----------------------------------------------------------------------------
+// absl::InsecureBitGen
+// -----------------------------------------------------------------------------
+//
+// `absl::InsecureBitGen` is an efficient random bit generator for generating
+// random values, recommended only for performance-sensitive use cases where
+// `absl::BitGen` is not satisfactory when compute-bounded by bit generation
+// costs.
+//
+// Example:
+//
+//   // Create an absl::InsecureBitGen
+//   absl::InsecureBitGen gen;
+//   for (size_t i = 0; i < 1000000; i++) {
+//
+//     // Generate a bunch of random values from some complex distribution
+//     auto my_rnd = some_distribution(gen, 1, 1000);
+//   }
+//
+// Like `absl::BitGen`, `absl::InsecureBitGen` is seeded by default with
+// non-deterministic data to produce different sequences of random values across
+// different instances, including different binary invocations. (This behavior
+// is different than the standard library bit generators, which use golden
+// values as their seeds.)
+//
+// `absl::InsecureBitGen` may be constructed with an optional seed sequence
+// type, conforming to [rand.req.seed_seq], which will be mixed with additional
+// non-deterministic data. (See std_seed_seq.h for more information.)
+//
+// `absl::InsecureBitGen` meets the requirements of the Uniform Random Bit
+// Generator (URBG) concept as per the C++17 standard [rand.req.urng] though
+// its implementation differs slightly with [rand.req.eng]. Like its standard
+// library equivalents (e.g. `std::mersenne_twister_engine`)
+// `absl::InsecureBitGen` is not cryptographically secure.
+//
+// Prefer `absl::BitGen` over `absl::InsecureBitGen` as the general type is
+// often fast enough for the vast majority of applications.
+
+using InsecureBitGen =
+    random_internal::NonsecureURBGBase<random_internal::pcg64_2018_engine>;
+
+// ---------------------------------------------------------------------------
+// absl::InsecureBitGen member functions
+// ---------------------------------------------------------------------------
+
+// absl::InsecureBitGen::operator()()
+//
+// Calls the InsecureBitGen, returning a generated value.
+
+// absl::InsecureBitGen::min()
+//
+// Returns the smallest possible value from this bit generator.
+
+// absl::InsecureBitGen::max()
+//
+// Returns the largest possible value from this bit generator.
+
+// absl::InsecureBitGen::discard(num)
+//
+// Advances the internal state of this bit generator by `num` times, and
+// discards the intermediate results.
+// ---------------------------------------------------------------------------
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_RANDOM_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/seed_gen_exception.h b/CAPI/cpp/grpc/include/absl/random/seed_gen_exception.h
new file mode 100644
index 0000000..5353900
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/seed_gen_exception.h
@@ -0,0 +1,55 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: seed_gen_exception.h
+// -----------------------------------------------------------------------------
+//
+// This header defines an exception class which may be thrown if unpredictable
+// events prevent the derivation of suitable seed-material for constructing a
+// bit generator conforming to [rand.req.urng] (eg. entropy cannot be read from
+// /dev/urandom on a Unix-based system).
+//
+// Note: if exceptions are disabled, `std::terminate()` is called instead.
+
+#ifndef ABSL_RANDOM_SEED_GEN_EXCEPTION_H_
+#define ABSL_RANDOM_SEED_GEN_EXCEPTION_H_
+
+#include <exception>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+//------------------------------------------------------------------------------
+// SeedGenException
+//------------------------------------------------------------------------------
+class SeedGenException : public std::exception {
+ public:
+  SeedGenException() = default;
+  ~SeedGenException() override;
+  const char* what() const noexcept override;
+};
+
+namespace random_internal {
+
+// throw delegator
+[[noreturn]] void ThrowSeedGenException();
+
+}  // namespace random_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_SEED_GEN_EXCEPTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/seed_sequences.h b/CAPI/cpp/grpc/include/absl/random/seed_sequences.h
new file mode 100644
index 0000000..c3af4b0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/seed_sequences.h
@@ -0,0 +1,111 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: seed_sequences.h
+// -----------------------------------------------------------------------------
+//
+// This header contains utilities for creating and working with seed sequences
+// conforming to [rand.req.seedseq]. In general, direct construction of seed
+// sequences is discouraged, but use-cases for construction of identical bit
+// generators (using the same seed sequence) may be helpful (e.g. replaying a
+// simulation whose state is derived from variates of a bit generator).
+
+#ifndef ABSL_RANDOM_SEED_SEQUENCES_H_
+#define ABSL_RANDOM_SEED_SEQUENCES_H_
+
+#include <iterator>
+#include <random>
+
+#include "absl/base/config.h"
+#include "absl/random/internal/salted_seed_seq.h"
+#include "absl/random/internal/seed_material.h"
+#include "absl/random/seed_gen_exception.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// absl::SeedSeq
+// -----------------------------------------------------------------------------
+//
+// `absl::SeedSeq` constructs a seed sequence according to [rand.req.seedseq]
+// for use within bit generators. `absl::SeedSeq`, unlike `std::seed_seq`
+// additionally salts the generated seeds with extra implementation-defined
+// entropy. For that reason, you can use `absl::SeedSeq` in combination with
+// standard library bit generators (e.g. `std::mt19937`) to introduce
+// non-determinism in your seeds.
+//
+// Example:
+//
+//   absl::SeedSeq my_seed_seq({a, b, c});
+//   std::mt19937 my_bitgen(my_seed_seq);
+//
+using SeedSeq = random_internal::SaltedSeedSeq<std::seed_seq>;
+
+// -----------------------------------------------------------------------------
+// absl::CreateSeedSeqFrom(bitgen*)
+// -----------------------------------------------------------------------------
+//
+// Constructs a seed sequence conforming to [rand.req.seedseq] using variates
+// produced by a provided bit generator.
+//
+// You should generally avoid direct construction of seed sequences, but
+// use-cases for reuse of a seed sequence to construct identical bit generators
+// may be helpful (eg. replaying a simulation whose state is derived from bit
+// generator values).
+//
+// If bitgen == nullptr, then behavior is undefined.
+//
+// Example:
+//
+//   absl::BitGen my_bitgen;
+//   auto seed_seq = absl::CreateSeedSeqFrom(&my_bitgen);
+//   absl::BitGen new_engine(seed_seq); // derived from my_bitgen, but not
+//                                      // correlated.
+//
+template <typename URBG>
+SeedSeq CreateSeedSeqFrom(URBG* urbg) {
+  SeedSeq::result_type
+      seed_material[random_internal::kEntropyBlocksNeeded];
+
+  if (!random_internal::ReadSeedMaterialFromURBG(
+          urbg, absl::MakeSpan(seed_material))) {
+    random_internal::ThrowSeedGenException();
+  }
+  return SeedSeq(std::begin(seed_material), std::end(seed_material));
+}
+
+// -----------------------------------------------------------------------------
+// absl::MakeSeedSeq()
+// -----------------------------------------------------------------------------
+//
+// Constructs an `absl::SeedSeq` salting the generated values using
+// implementation-defined entropy. The returned sequence can be used to create
+// equivalent bit generators correlated using this sequence.
+//
+// Example:
+//
+//   auto my_seed_seq = absl::MakeSeedSeq();
+//   std::mt19937 rng1(my_seed_seq);
+//   std::mt19937 rng2(my_seed_seq);
+//   EXPECT_EQ(rng1(), rng2());
+//
+SeedSeq MakeSeedSeq();
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_SEED_SEQUENCES_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/uniform_int_distribution.h b/CAPI/cpp/grpc/include/absl/random/uniform_int_distribution.h
new file mode 100644
index 0000000..fae8025
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/uniform_int_distribution.h
@@ -0,0 +1,275 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: uniform_int_distribution.h
+// -----------------------------------------------------------------------------
+//
+// This header defines a class for representing a uniform integer distribution
+// over the closed (inclusive) interval [a,b]. You use this distribution in
+// combination with an Abseil random bit generator to produce random values
+// according to the rules of the distribution.
+//
+// `absl::uniform_int_distribution` is a drop-in replacement for the C++11
+// `std::uniform_int_distribution` [rand.dist.uni.int] but is considerably
+// faster than the libstdc++ implementation.
+
+#ifndef ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
+#define ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
+
+#include <cassert>
+#include <istream>
+#include <limits>
+#include <type_traits>
+
+#include "absl/base/optimization.h"
+#include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/internal/traits.h"
+#include "absl/random/internal/wide_multiply.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::uniform_int_distribution<T>
+//
+// This distribution produces random integer values uniformly distributed in the
+// closed (inclusive) interval [a, b].
+//
+// Example:
+//
+//   absl::BitGen gen;
+//
+//   // Use the distribution to produce a value between 1 and 6, inclusive.
+//   int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
+//
+template <typename IntType = int>
+class uniform_int_distribution {
+ private:
+  using unsigned_type =
+      typename random_internal::make_unsigned_bits<IntType>::type;
+
+ public:
+  using result_type = IntType;
+
+  class param_type {
+   public:
+    using distribution_type = uniform_int_distribution;
+
+    explicit param_type(
+        result_type lo = 0,
+        result_type hi = (std::numeric_limits<result_type>::max)())
+        : lo_(lo),
+          range_(static_cast<unsigned_type>(hi) -
+                 static_cast<unsigned_type>(lo)) {
+      // [rand.dist.uni.int] precondition 2
+      assert(lo <= hi);
+    }
+
+    result_type a() const { return lo_; }
+    result_type b() const {
+      return static_cast<result_type>(static_cast<unsigned_type>(lo_) + range_);
+    }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.lo_ == b.lo_ && a.range_ == b.range_;
+    }
+
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class uniform_int_distribution;
+    unsigned_type range() const { return range_; }
+
+    result_type lo_;
+    unsigned_type range_;
+
+    static_assert(random_internal::IsIntegral<result_type>::value,
+                  "Class-template absl::uniform_int_distribution<> must be "
+                  "parameterized using an integral type.");
+  };  // param_type
+
+  uniform_int_distribution() : uniform_int_distribution(0) {}
+
+  explicit uniform_int_distribution(
+      result_type lo,
+      result_type hi = (std::numeric_limits<result_type>::max)())
+      : param_(lo, hi) {}
+
+  explicit uniform_int_distribution(const param_type& param) : param_(param) {}
+
+  // uniform_int_distribution<T>::reset()
+  //
+  // Resets the uniform int distribution. Note that this function has no effect
+  // because the distribution already produces independent values.
+  void reset() {}
+
+  template <typename URBG>
+  result_type operator()(URBG& gen) {  // NOLINT(runtime/references)
+    return (*this)(gen, param());
+  }
+
+  template <typename URBG>
+  result_type operator()(
+      URBG& gen, const param_type& param) {  // NOLINT(runtime/references)
+    return static_cast<result_type>(param.a() + Generate(gen, param.range()));
+  }
+
+  result_type a() const { return param_.a(); }
+  result_type b() const { return param_.b(); }
+
+  param_type param() const { return param_; }
+  void param(const param_type& params) { param_ = params; }
+
+  result_type(min)() const { return a(); }
+  result_type(max)() const { return b(); }
+
+  friend bool operator==(const uniform_int_distribution& a,
+                         const uniform_int_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const uniform_int_distribution& a,
+                         const uniform_int_distribution& b) {
+    return !(a == b);
+  }
+
+ private:
+  // Generates a value in the *closed* interval [0, R]
+  template <typename URBG>
+  unsigned_type Generate(URBG& g,  // NOLINT(runtime/references)
+                         unsigned_type R);
+  param_type param_;
+};
+
+// -----------------------------------------------------------------------------
+// Implementation details follow
+// -----------------------------------------------------------------------------
+template <typename CharT, typename Traits, typename IntType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,
+    const uniform_int_distribution<IntType>& x) {
+  using stream_type =
+      typename random_internal::stream_format_type<IntType>::type;
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os << static_cast<stream_type>(x.a()) << os.fill()
+     << static_cast<stream_type>(x.b());
+  return os;
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,
+    uniform_int_distribution<IntType>& x) {
+  using param_type = typename uniform_int_distribution<IntType>::param_type;
+  using result_type = typename uniform_int_distribution<IntType>::result_type;
+  using stream_type =
+      typename random_internal::stream_format_type<IntType>::type;
+
+  stream_type a;
+  stream_type b;
+
+  auto saver = random_internal::make_istream_state_saver(is);
+  is >> a >> b;
+  if (!is.fail()) {
+    x.param(
+        param_type(static_cast<result_type>(a), static_cast<result_type>(b)));
+  }
+  return is;
+}
+
+template <typename IntType>
+template <typename URBG>
+typename random_internal::make_unsigned_bits<IntType>::type
+uniform_int_distribution<IntType>::Generate(
+    URBG& g,  // NOLINT(runtime/references)
+    typename random_internal::make_unsigned_bits<IntType>::type R) {
+  random_internal::FastUniformBits<unsigned_type> fast_bits;
+  unsigned_type bits = fast_bits(g);
+  const unsigned_type Lim = R + 1;
+  if ((R & Lim) == 0) {
+    // If the interval's length is a power of two range, just take the low bits.
+    return bits & R;
+  }
+
+  // Generates a uniform variate on [0, Lim) using fixed-point multiplication.
+  // The above fast-path guarantees that Lim is representable in unsigned_type.
+  //
+  // Algorithm adapted from
+  // http://lemire.me/blog/2016/06/30/fast-random-shuffling/, with added
+  // explanation.
+  //
+  // The algorithm creates a uniform variate `bits` in the interval [0, 2^N),
+  // and treats it as the fractional part of a fixed-point real value in [0, 1),
+  // multiplied by 2^N.  For example, 0.25 would be represented as 2^(N - 2),
+  // because 2^N * 0.25 == 2^(N - 2).
+  //
+  // Next, `bits` and `Lim` are multiplied with a wide-multiply to bring the
+  // value into the range [0, Lim).  The integral part (the high word of the
+  // multiplication result) is then very nearly the desired result.  However,
+  // this is not quite accurate; viewing the multiplication result as one
+  // double-width integer, the resulting values for the sample are mapped as
+  // follows:
+  //
+  // If the result lies in this interval:       Return this value:
+  //        [0, 2^N)                                    0
+  //        [2^N, 2 * 2^N)                              1
+  //        ...                                         ...
+  //        [K * 2^N, (K + 1) * 2^N)                    K
+  //        ...                                         ...
+  //        [(Lim - 1) * 2^N, Lim * 2^N)                Lim - 1
+  //
+  // While all of these intervals have the same size, the result of `bits * Lim`
+  // must be a multiple of `Lim`, and not all of these intervals contain the
+  // same number of multiples of `Lim`.  In particular, some contain
+  // `F = floor(2^N / Lim)` and some contain `F + 1 = ceil(2^N / Lim)`.  This
+  // difference produces a small nonuniformity, which is corrected by applying
+  // rejection sampling to one of the values in the "larger intervals" (i.e.,
+  // the intervals containing `F + 1` multiples of `Lim`.
+  //
+  // An interval contains `F + 1` multiples of `Lim` if and only if its smallest
+  // value modulo 2^N is less than `2^N % Lim`.  The unique value satisfying
+  // this property is used as the one for rejection.  That is, a value of
+  // `bits * Lim` is rejected if `(bit * Lim) % 2^N < (2^N % Lim)`.
+
+  using helper = random_internal::wide_multiply<unsigned_type>;
+  auto product = helper::multiply(bits, Lim);
+
+  // Two optimizations here:
+  // * Rejection occurs with some probability less than 1/2, and for reasonable
+  //   ranges considerably less (in particular, less than 1/(F+1)), so
+  //   ABSL_PREDICT_FALSE is apt.
+  // * `Lim` is an overestimate of `threshold`, and doesn't require a divide.
+  if (ABSL_PREDICT_FALSE(helper::lo(product) < Lim)) {
+    // This quantity is exactly equal to `2^N % Lim`, but does not require high
+    // precision calculations: `2^N % Lim` is congruent to `(2^N - Lim) % Lim`.
+    // Ideally this could be expressed simply as `-X` rather than `2^N - X`, but
+    // for types smaller than int, this calculation is incorrect due to integer
+    // promotion rules.
+    const unsigned_type threshold =
+        ((std::numeric_limits<unsigned_type>::max)() - Lim + 1) % Lim;
+    while (helper::lo(product) < threshold) {
+      bits = fast_bits(g);
+      product = helper::multiply(bits, Lim);
+    }
+  }
+
+  return helper::hi(product);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/uniform_real_distribution.h b/CAPI/cpp/grpc/include/absl/random/uniform_real_distribution.h
new file mode 100644
index 0000000..1968334
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/uniform_real_distribution.h
@@ -0,0 +1,202 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: uniform_real_distribution.h
+// -----------------------------------------------------------------------------
+//
+// This header defines a class for representing a uniform floating-point
+// distribution over a half-open interval [a,b). You use this distribution in
+// combination with an Abseil random bit generator to produce random values
+// according to the rules of the distribution.
+//
+// `absl::uniform_real_distribution` is a drop-in replacement for the C++11
+// `std::uniform_real_distribution` [rand.dist.uni.real] but is considerably
+// faster than the libstdc++ implementation.
+//
+// Note: the standard-library version may occasionally return `1.0` when
+// default-initialized. See https://bugs.llvm.org//show_bug.cgi?id=18767
+// `absl::uniform_real_distribution` does not exhibit this behavior.
+
+#ifndef ABSL_RANDOM_UNIFORM_REAL_DISTRIBUTION_H_
+#define ABSL_RANDOM_UNIFORM_REAL_DISTRIBUTION_H_
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <istream>
+#include <limits>
+#include <type_traits>
+
+#include "absl/meta/type_traits.h"
+#include "absl/random/internal/fast_uniform_bits.h"
+#include "absl/random/internal/generate_real.h"
+#include "absl/random/internal/iostream_state_saver.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::uniform_real_distribution<T>
+//
+// This distribution produces random floating-point values uniformly distributed
+// over the half-open interval [a, b).
+//
+// Example:
+//
+//   absl::BitGen gen;
+//
+//   // Use the distribution to produce a value between 0.0 (inclusive)
+//   // and 1.0 (exclusive).
+//   double value = absl::uniform_real_distribution<double>(0, 1)(gen);
+//
+template <typename RealType = double>
+class uniform_real_distribution {
+ public:
+  using result_type = RealType;
+
+  class param_type {
+   public:
+    using distribution_type = uniform_real_distribution;
+
+    explicit param_type(result_type lo = 0, result_type hi = 1)
+        : lo_(lo), hi_(hi), range_(hi - lo) {
+      // [rand.dist.uni.real] preconditions 2 & 3
+      assert(lo <= hi);
+
+      // NOTE: For integral types, we can promote the range to an unsigned type,
+      // which gives full width of the range. However for real (fp) types, this
+      // is not possible, so value generation cannot use the full range of the
+      // real type.
+      assert(range_ <= (std::numeric_limits<result_type>::max)());
+    }
+
+    result_type a() const { return lo_; }
+    result_type b() const { return hi_; }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.lo_ == b.lo_ && a.hi_ == b.hi_;
+    }
+
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class uniform_real_distribution;
+    result_type lo_, hi_, range_;
+
+    static_assert(std::is_floating_point<RealType>::value,
+                  "Class-template absl::uniform_real_distribution<> must be "
+                  "parameterized using a floating-point type.");
+  };
+
+  uniform_real_distribution() : uniform_real_distribution(0) {}
+
+  explicit uniform_real_distribution(result_type lo, result_type hi = 1)
+      : param_(lo, hi) {}
+
+  explicit uniform_real_distribution(const param_type& param) : param_(param) {}
+
+  // uniform_real_distribution<T>::reset()
+  //
+  // Resets the uniform real distribution. Note that this function has no effect
+  // because the distribution already produces independent values.
+  void reset() {}
+
+  template <typename URBG>
+  result_type operator()(URBG& gen) {  // NOLINT(runtime/references)
+    return operator()(gen, param_);
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& gen,  // NOLINT(runtime/references)
+                         const param_type& p);
+
+  result_type a() const { return param_.a(); }
+  result_type b() const { return param_.b(); }
+
+  param_type param() const { return param_; }
+  void param(const param_type& params) { param_ = params; }
+
+  result_type(min)() const { return a(); }
+  result_type(max)() const { return b(); }
+
+  friend bool operator==(const uniform_real_distribution& a,
+                         const uniform_real_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const uniform_real_distribution& a,
+                         const uniform_real_distribution& b) {
+    return a.param_ != b.param_;
+  }
+
+ private:
+  param_type param_;
+  random_internal::FastUniformBits<uint64_t> fast_u64_;
+};
+
+// -----------------------------------------------------------------------------
+// Implementation details follow
+// -----------------------------------------------------------------------------
+template <typename RealType>
+template <typename URBG>
+typename uniform_real_distribution<RealType>::result_type
+uniform_real_distribution<RealType>::operator()(
+    URBG& gen, const param_type& p) {  // NOLINT(runtime/references)
+  using random_internal::GeneratePositiveTag;
+  using random_internal::GenerateRealFromBits;
+  using real_type =
+      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+  while (true) {
+    const result_type sample =
+        GenerateRealFromBits<real_type, GeneratePositiveTag, true>(
+            fast_u64_(gen));
+    const result_type res = p.a() + (sample * p.range_);
+    if (res < p.b() || p.range_ <= 0 || !std::isfinite(p.range_)) {
+      return res;
+    }
+    // else sample rejected, try again.
+  }
+}
+
+template <typename CharT, typename Traits, typename RealType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const uniform_real_distribution<RealType>& x) {
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
+  os << x.a() << os.fill() << x.b();
+  return os;
+}
+
+template <typename CharT, typename Traits, typename RealType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,     // NOLINT(runtime/references)
+    uniform_real_distribution<RealType>& x) {  // NOLINT(runtime/references)
+  using param_type = typename uniform_real_distribution<RealType>::param_type;
+  using result_type = typename uniform_real_distribution<RealType>::result_type;
+  auto saver = random_internal::make_istream_state_saver(is);
+  auto a = random_internal::read_floating_point<result_type>(is);
+  if (is.fail()) return is;
+  auto b = random_internal::read_floating_point<result_type>(is);
+  if (!is.fail()) {
+    x.param(param_type(a, b));
+  }
+  return is;
+}
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_UNIFORM_REAL_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/zipf_distribution.h b/CAPI/cpp/grpc/include/absl/random/zipf_distribution.h
new file mode 100644
index 0000000..03497b1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/random/zipf_distribution.h
@@ -0,0 +1,272 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_RANDOM_ZIPF_DISTRIBUTION_H_
+#define ABSL_RANDOM_ZIPF_DISTRIBUTION_H_
+
+#include <cassert>
+#include <cmath>
+#include <istream>
+#include <limits>
+#include <ostream>
+#include <type_traits>
+
+#include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/internal/traits.h"
+#include "absl/random/uniform_real_distribution.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::zipf_distribution produces random integer-values in the range [0, k],
+// distributed according to the unnormalized discrete probability function:
+//
+//  P(x) = (v + x) ^ -q
+//
+// The parameter `v` must be greater than 0 and the parameter `q` must be
+// greater than 1. If either of these parameters take invalid values then the
+// behavior is undefined.
+//
+// IntType is the result_type generated by the generator. It must be of integral
+// type; a static_assert ensures this is the case.
+//
+// The implementation is based on W.Hormann, G.Derflinger:
+//
+// "Rejection-Inversion to Generate Variates from Monotone Discrete
+// Distributions"
+//
+// http://eeyore.wu-wien.ac.at/papers/96-04-04.wh-der.ps.gz
+//
+template <typename IntType = int>
+class zipf_distribution {
+ public:
+  using result_type = IntType;
+
+  class param_type {
+   public:
+    using distribution_type = zipf_distribution;
+
+    // Preconditions: k > 0, v > 0, q > 1
+    // The precondidtions are validated when NDEBUG is not defined via
+    // a pair of assert() directives.
+    // If NDEBUG is defined and either or both of these parameters take invalid
+    // values, the behavior of the class is undefined.
+    explicit param_type(result_type k = (std::numeric_limits<IntType>::max)(),
+                        double q = 2.0, double v = 1.0);
+
+    result_type k() const { return k_; }
+    double q() const { return q_; }
+    double v() const { return v_; }
+
+    friend bool operator==(const param_type& a, const param_type& b) {
+      return a.k_ == b.k_ && a.q_ == b.q_ && a.v_ == b.v_;
+    }
+    friend bool operator!=(const param_type& a, const param_type& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class zipf_distribution;
+    inline double h(double x) const;
+    inline double hinv(double x) const;
+    inline double compute_s() const;
+    inline double pow_negative_q(double x) const;
+
+    // Parameters here are exactly the same as the parameters of Algorithm ZRI
+    // in the paper.
+    IntType k_;
+    double q_;
+    double v_;
+
+    double one_minus_q_;  // 1-q
+    double s_;
+    double one_minus_q_inv_;  // 1 / 1-q
+    double hxm_;              // h(k + 0.5)
+    double hx0_minus_hxm_;    // h(x0) - h(k + 0.5)
+
+    static_assert(random_internal::IsIntegral<IntType>::value,
+                  "Class-template absl::zipf_distribution<> must be "
+                  "parameterized using an integral type.");
+  };
+
+  zipf_distribution()
+      : zipf_distribution((std::numeric_limits<IntType>::max)()) {}
+
+  explicit zipf_distribution(result_type k, double q = 2.0, double v = 1.0)
+      : param_(k, q, v) {}
+
+  explicit zipf_distribution(const param_type& p) : param_(p) {}
+
+  void reset() {}
+
+  template <typename URBG>
+  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
+    return (*this)(g, param_);
+  }
+
+  template <typename URBG>
+  result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                         const param_type& p);
+
+  result_type k() const { return param_.k(); }
+  double q() const { return param_.q(); }
+  double v() const { return param_.v(); }
+
+  param_type param() const { return param_; }
+  void param(const param_type& p) { param_ = p; }
+
+  result_type(min)() const { return 0; }
+  result_type(max)() const { return k(); }
+
+  friend bool operator==(const zipf_distribution& a,
+                         const zipf_distribution& b) {
+    return a.param_ == b.param_;
+  }
+  friend bool operator!=(const zipf_distribution& a,
+                         const zipf_distribution& b) {
+    return a.param_ != b.param_;
+  }
+
+ private:
+  param_type param_;
+};
+
+// --------------------------------------------------------------------------
+// Implementation details follow
+// --------------------------------------------------------------------------
+
+template <typename IntType>
+zipf_distribution<IntType>::param_type::param_type(
+    typename zipf_distribution<IntType>::result_type k, double q, double v)
+    : k_(k), q_(q), v_(v), one_minus_q_(1 - q) {
+  assert(q > 1);
+  assert(v > 0);
+  assert(k > 0);
+  one_minus_q_inv_ = 1 / one_minus_q_;
+
+  // Setup for the ZRI algorithm (pg 17 of the paper).
+  // Compute: h(i max) => h(k + 0.5)
+  constexpr double kMax = 18446744073709549568.0;
+  double kd = static_cast<double>(k);
+  // TODO(absl-team): Determine if this check is needed, and if so, add a test
+  // that fails for k > kMax
+  if (kd > kMax) {
+    // Ensure that our maximum value is capped to a value which will
+    // round-trip back through double.
+    kd = kMax;
+  }
+  hxm_ = h(kd + 0.5);
+
+  // Compute: h(0)
+  const bool use_precomputed = (v == 1.0 && q == 2.0);
+  const double h0x5 = use_precomputed ? (-1.0 / 1.5)  // exp(-log(1.5))
+                                      : h(0.5);
+  const double elogv_q = (v_ == 1.0) ? 1 : pow_negative_q(v_);
+
+  // h(0) = h(0.5) - exp(log(v) * -q)
+  hx0_minus_hxm_ = (h0x5 - elogv_q) - hxm_;
+
+  // And s
+  s_ = use_precomputed ? 0.46153846153846123 : compute_s();
+}
+
+template <typename IntType>
+double zipf_distribution<IntType>::param_type::h(double x) const {
+  // std::exp(one_minus_q_ * std::log(v_ + x)) * one_minus_q_inv_;
+  x += v_;
+  return (one_minus_q_ == -1.0)
+             ? (-1.0 / x)  // -exp(-log(x))
+             : (std::exp(std::log(x) * one_minus_q_) * one_minus_q_inv_);
+}
+
+template <typename IntType>
+double zipf_distribution<IntType>::param_type::hinv(double x) const {
+  // std::exp(one_minus_q_inv_ * std::log(one_minus_q_ * x)) - v_;
+  return -v_ + ((one_minus_q_ == -1.0)
+                    ? (-1.0 / x)  // exp(-log(-x))
+                    : std::exp(one_minus_q_inv_ * std::log(one_minus_q_ * x)));
+}
+
+template <typename IntType>
+double zipf_distribution<IntType>::param_type::compute_s() const {
+  // 1 - hinv(h(1.5) - std::exp(std::log(v_ + 1) * -q_));
+  return 1.0 - hinv(h(1.5) - pow_negative_q(v_ + 1.0));
+}
+
+template <typename IntType>
+double zipf_distribution<IntType>::param_type::pow_negative_q(double x) const {
+  // std::exp(std::log(x) * -q_);
+  return q_ == 2.0 ? (1.0 / (x * x)) : std::exp(std::log(x) * -q_);
+}
+
+template <typename IntType>
+template <typename URBG>
+typename zipf_distribution<IntType>::result_type
+zipf_distribution<IntType>::operator()(
+    URBG& g, const param_type& p) {  // NOLINT(runtime/references)
+  absl::uniform_real_distribution<double> uniform_double;
+  double k;
+  for (;;) {
+    const double v = uniform_double(g);
+    const double u = p.hxm_ + v * p.hx0_minus_hxm_;
+    const double x = p.hinv(u);
+    k = rint(x);              // std::floor(x + 0.5);
+    if (k > static_cast<double>(p.k())) continue;  // reject k > max_k
+    if (k - x <= p.s_) break;
+    const double h = p.h(k + 0.5);
+    const double r = p.pow_negative_q(p.v_ + k);
+    if (u >= h - r) break;
+  }
+  IntType ki = static_cast<IntType>(k);
+  assert(ki <= p.k_);
+  return ki;
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+    const zipf_distribution<IntType>& x) {
+  using stream_type =
+      typename random_internal::stream_format_type<IntType>::type;
+  auto saver = random_internal::make_ostream_state_saver(os);
+  os.precision(random_internal::stream_precision_helper<double>::kPrecision);
+  os << static_cast<stream_type>(x.k()) << os.fill() << x.q() << os.fill()
+     << x.v();
+  return os;
+}
+
+template <typename CharT, typename Traits, typename IntType>
+std::basic_istream<CharT, Traits>& operator>>(
+    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+    zipf_distribution<IntType>& x) {        // NOLINT(runtime/references)
+  using result_type = typename zipf_distribution<IntType>::result_type;
+  using param_type = typename zipf_distribution<IntType>::param_type;
+  using stream_type =
+      typename random_internal::stream_format_type<IntType>::type;
+  stream_type k;
+  double q;
+  double v;
+
+  auto saver = random_internal::make_istream_state_saver(is);
+  is >> k >> q >> v;
+  if (!is.fail()) {
+    x.param(param_type(static_cast<result_type>(k), q, v));
+  }
+  return is;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_ZIPF_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/internal/status_internal.h b/CAPI/cpp/grpc/include/absl/status/internal/status_internal.h
new file mode 100644
index 0000000..19a4a7a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/status/internal/status_internal.h
@@ -0,0 +1,86 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+#ifndef ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
+#define ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
+
+#include <string>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/cord.h"
+
+#ifndef SWIG
+// Disabled for SWIG as it doesn't parse attributes correctly.
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+// Returned Status objects may not be ignored. Codesearch doesn't handle ifdefs
+// as part of a class definitions (b/6995610), so we use a forward declaration.
+//
+// TODO(b/176172494): ABSL_MUST_USE_RESULT should expand to the more strict
+// [[nodiscard]]. For now, just use [[nodiscard]] directly when it is available.
+#if ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
+class [[nodiscard]] Status;
+#else
+class ABSL_MUST_USE_RESULT Status;
+#endif
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // !SWIG
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+enum class StatusCode : int;
+
+namespace status_internal {
+
+// Container for status payloads.
+struct Payload {
+  std::string type_url;
+  absl::Cord payload;
+};
+
+using Payloads = absl::InlinedVector<Payload, 1>;
+
+// Reference-counted representation of Status data.
+struct StatusRep {
+  StatusRep(absl::StatusCode code_arg, absl::string_view message_arg,
+            std::unique_ptr<status_internal::Payloads> payloads_arg)
+      : ref(int32_t{1}),
+        code(code_arg),
+        message(message_arg),
+        payloads(std::move(payloads_arg)) {}
+
+  std::atomic<int32_t> ref;
+  absl::StatusCode code;
+  std::string message;
+  std::unique_ptr<status_internal::Payloads> payloads;
+};
+
+absl::StatusCode MapToLocalCode(int value);
+
+// Returns a pointer to a newly-allocated string with the given `prefix`,
+// suitable for output as an error message in assertion/`CHECK()` failures.
+//
+// This is an internal implementation detail for Abseil logging.
+std::string* MakeCheckFailString(const absl::Status* status,
+                                 const char* prefix);
+
+}  // namespace status_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/internal/statusor_internal.h b/CAPI/cpp/grpc/include/absl/status/internal/statusor_internal.h
new file mode 100644
index 0000000..eaac2c0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/status/internal/statusor_internal.h
@@ -0,0 +1,396 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+#ifndef ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
+#define ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
+
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+template <typename T>
+class ABSL_MUST_USE_RESULT StatusOr;
+
+namespace internal_statusor {
+
+// Detects whether `U` has conversion operator to `StatusOr<T>`, i.e. `operator
+// StatusOr<T>()`.
+template <typename T, typename U, typename = void>
+struct HasConversionOperatorToStatusOr : std::false_type {};
+
+template <typename T, typename U>
+void test(char (*)[sizeof(std::declval<U>().operator absl::StatusOr<T>())]);
+
+template <typename T, typename U>
+struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))>
+    : std::true_type {};
+
+// Detects whether `T` is constructible or convertible from `StatusOr<U>`.
+template <typename T, typename U>
+using IsConstructibleOrConvertibleFromStatusOr =
+    absl::disjunction<std::is_constructible<T, StatusOr<U>&>,
+                      std::is_constructible<T, const StatusOr<U>&>,
+                      std::is_constructible<T, StatusOr<U>&&>,
+                      std::is_constructible<T, const StatusOr<U>&&>,
+                      std::is_convertible<StatusOr<U>&, T>,
+                      std::is_convertible<const StatusOr<U>&, T>,
+                      std::is_convertible<StatusOr<U>&&, T>,
+                      std::is_convertible<const StatusOr<U>&&, T>>;
+
+// Detects whether `T` is constructible or convertible or assignable from
+// `StatusOr<U>`.
+template <typename T, typename U>
+using IsConstructibleOrConvertibleOrAssignableFromStatusOr =
+    absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>,
+                      std::is_assignable<T&, StatusOr<U>&>,
+                      std::is_assignable<T&, const StatusOr<U>&>,
+                      std::is_assignable<T&, StatusOr<U>&&>,
+                      std::is_assignable<T&, const StatusOr<U>&&>>;
+
+// Detects whether direct initializing `StatusOr<T>` from `U` is ambiguous, i.e.
+// when `U` is `StatusOr<V>` and `T` is constructible or convertible from `V`.
+template <typename T, typename U>
+struct IsDirectInitializationAmbiguous
+    : public absl::conditional_t<
+          std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>,
+                       U>::value,
+          std::false_type,
+          IsDirectInitializationAmbiguous<
+              T, absl::remove_cv_t<absl::remove_reference_t<U>>>> {};
+
+template <typename T, typename V>
+struct IsDirectInitializationAmbiguous<T, absl::StatusOr<V>>
+    : public IsConstructibleOrConvertibleFromStatusOr<T, V> {};
+
+// Checks against the constraints of the direction initialization, i.e. when
+// `StatusOr<T>::StatusOr(U&&)` should participate in overload resolution.
+template <typename T, typename U>
+using IsDirectInitializationValid = absl::disjunction<
+    // Short circuits if T is basically U.
+    std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+    absl::negation<absl::disjunction<
+        std::is_same<absl::StatusOr<T>,
+                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
+        std::is_same<absl::Status,
+                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
+        std::is_same<absl::in_place_t,
+                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
+        IsDirectInitializationAmbiguous<T, U>>>>;
+
+// This trait detects whether `StatusOr<T>::operator=(U&&)` is ambiguous, which
+// is equivalent to whether all the following conditions are met:
+// 1. `U` is `StatusOr<V>`.
+// 2. `T` is constructible and assignable from `V`.
+// 3. `T` is constructible and assignable from `U` (i.e. `StatusOr<V>`).
+// For example, the following code is considered ambiguous:
+// (`T` is `bool`, `U` is `StatusOr<bool>`, `V` is `bool`)
+//   StatusOr<bool> s1 = true;  // s1.ok() && s1.ValueOrDie() == true
+//   StatusOr<bool> s2 = false;  // s2.ok() && s2.ValueOrDie() == false
+//   s1 = s2;  // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`?
+template <typename T, typename U>
+struct IsForwardingAssignmentAmbiguous
+    : public absl::conditional_t<
+          std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>,
+                       U>::value,
+          std::false_type,
+          IsForwardingAssignmentAmbiguous<
+              T, absl::remove_cv_t<absl::remove_reference_t<U>>>> {};
+
+template <typename T, typename U>
+struct IsForwardingAssignmentAmbiguous<T, absl::StatusOr<U>>
+    : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U> {};
+
+// Checks against the constraints of the forwarding assignment, i.e. whether
+// `StatusOr<T>::operator(U&&)` should participate in overload resolution.
+template <typename T, typename U>
+using IsForwardingAssignmentValid = absl::disjunction<
+    // Short circuits if T is basically U.
+    std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+    absl::negation<absl::disjunction<
+        std::is_same<absl::StatusOr<T>,
+                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
+        std::is_same<absl::Status,
+                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
+        std::is_same<absl::in_place_t,
+                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
+        IsForwardingAssignmentAmbiguous<T, U>>>>;
+
+class Helper {
+ public:
+  // Move type-agnostic error handling to the .cc.
+  static void HandleInvalidStatusCtorArg(Status*);
+  ABSL_ATTRIBUTE_NORETURN static void Crash(const absl::Status& status);
+};
+
+// Construct an instance of T in `p` through placement new, passing Args... to
+// the constructor.
+// This abstraction is here mostly for the gcc performance fix.
+template <typename T, typename... Args>
+ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* p, Args&&... args) {
+  new (p) T(std::forward<Args>(args)...);
+}
+
+// Helper base class to hold the data and all operations.
+// We move all this to a base class to allow mixing with the appropriate
+// TraitsBase specialization.
+template <typename T>
+class StatusOrData {
+  template <typename U>
+  friend class StatusOrData;
+
+ public:
+  StatusOrData() = delete;
+
+  StatusOrData(const StatusOrData& other) {
+    if (other.ok()) {
+      MakeValue(other.data_);
+      MakeStatus();
+    } else {
+      MakeStatus(other.status_);
+    }
+  }
+
+  StatusOrData(StatusOrData&& other) noexcept {
+    if (other.ok()) {
+      MakeValue(std::move(other.data_));
+      MakeStatus();
+    } else {
+      MakeStatus(std::move(other.status_));
+    }
+  }
+
+  template <typename U>
+  explicit StatusOrData(const StatusOrData<U>& other) {
+    if (other.ok()) {
+      MakeValue(other.data_);
+      MakeStatus();
+    } else {
+      MakeStatus(other.status_);
+    }
+  }
+
+  template <typename U>
+  explicit StatusOrData(StatusOrData<U>&& other) {
+    if (other.ok()) {
+      MakeValue(std::move(other.data_));
+      MakeStatus();
+    } else {
+      MakeStatus(std::move(other.status_));
+    }
+  }
+
+  template <typename... Args>
+  explicit StatusOrData(absl::in_place_t, Args&&... args)
+      : data_(std::forward<Args>(args)...) {
+    MakeStatus();
+  }
+
+  explicit StatusOrData(const T& value) : data_(value) {
+    MakeStatus();
+  }
+  explicit StatusOrData(T&& value) : data_(std::move(value)) {
+    MakeStatus();
+  }
+
+  template <typename U,
+            absl::enable_if_t<std::is_constructible<absl::Status, U&&>::value,
+                              int> = 0>
+  explicit StatusOrData(U&& v) : status_(std::forward<U>(v)) {
+    EnsureNotOk();
+  }
+
+  StatusOrData& operator=(const StatusOrData& other) {
+    if (this == &other) return *this;
+    if (other.ok())
+      Assign(other.data_);
+    else
+      AssignStatus(other.status_);
+    return *this;
+  }
+
+  StatusOrData& operator=(StatusOrData&& other) {
+    if (this == &other) return *this;
+    if (other.ok())
+      Assign(std::move(other.data_));
+    else
+      AssignStatus(std::move(other.status_));
+    return *this;
+  }
+
+  ~StatusOrData() {
+    if (ok()) {
+      status_.~Status();
+      data_.~T();
+    } else {
+      status_.~Status();
+    }
+  }
+
+  template <typename U>
+  void Assign(U&& value) {
+    if (ok()) {
+      data_ = std::forward<U>(value);
+    } else {
+      MakeValue(std::forward<U>(value));
+      status_ = OkStatus();
+    }
+  }
+
+  template <typename U>
+  void AssignStatus(U&& v) {
+    Clear();
+    status_ = static_cast<absl::Status>(std::forward<U>(v));
+    EnsureNotOk();
+  }
+
+  bool ok() const { return status_.ok(); }
+
+ protected:
+  // status_ will always be active after the constructor.
+  // We make it a union to be able to initialize exactly how we need without
+  // waste.
+  // Eg. in the copy constructor we use the default constructor of Status in
+  // the ok() path to avoid an extra Ref call.
+  union {
+    Status status_;
+  };
+
+  // data_ is active iff status_.ok()==true
+  struct Dummy {};
+  union {
+    // When T is const, we need some non-const object we can cast to void* for
+    // the placement new. dummy_ is that object.
+    Dummy dummy_;
+    T data_;
+  };
+
+  void Clear() {
+    if (ok()) data_.~T();
+  }
+
+  void EnsureOk() const {
+    if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_);
+  }
+
+  void EnsureNotOk() {
+    if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_);
+  }
+
+  // Construct the value (ie. data_) through placement new with the passed
+  // argument.
+  template <typename... Arg>
+  void MakeValue(Arg&&... arg) {
+    internal_statusor::PlacementNew<T>(&dummy_, std::forward<Arg>(arg)...);
+  }
+
+  // Construct the status (ie. status_) through placement new with the passed
+  // argument.
+  template <typename... Args>
+  void MakeStatus(Args&&... args) {
+    internal_statusor::PlacementNew<Status>(&status_,
+                                            std::forward<Args>(args)...);
+  }
+};
+
+// Helper base classes to allow implicitly deleted constructors and assignment
+// operators in `StatusOr`. For example, `CopyCtorBase` will explicitly delete
+// the copy constructor when T is not copy constructible and `StatusOr` will
+// inherit that behavior implicitly.
+template <typename T, bool = std::is_copy_constructible<T>::value>
+struct CopyCtorBase {
+  CopyCtorBase() = default;
+  CopyCtorBase(const CopyCtorBase&) = default;
+  CopyCtorBase(CopyCtorBase&&) = default;
+  CopyCtorBase& operator=(const CopyCtorBase&) = default;
+  CopyCtorBase& operator=(CopyCtorBase&&) = default;
+};
+
+template <typename T>
+struct CopyCtorBase<T, false> {
+  CopyCtorBase() = default;
+  CopyCtorBase(const CopyCtorBase&) = delete;
+  CopyCtorBase(CopyCtorBase&&) = default;
+  CopyCtorBase& operator=(const CopyCtorBase&) = default;
+  CopyCtorBase& operator=(CopyCtorBase&&) = default;
+};
+
+template <typename T, bool = std::is_move_constructible<T>::value>
+struct MoveCtorBase {
+  MoveCtorBase() = default;
+  MoveCtorBase(const MoveCtorBase&) = default;
+  MoveCtorBase(MoveCtorBase&&) = default;
+  MoveCtorBase& operator=(const MoveCtorBase&) = default;
+  MoveCtorBase& operator=(MoveCtorBase&&) = default;
+};
+
+template <typename T>
+struct MoveCtorBase<T, false> {
+  MoveCtorBase() = default;
+  MoveCtorBase(const MoveCtorBase&) = default;
+  MoveCtorBase(MoveCtorBase&&) = delete;
+  MoveCtorBase& operator=(const MoveCtorBase&) = default;
+  MoveCtorBase& operator=(MoveCtorBase&&) = default;
+};
+
+template <typename T, bool = std::is_copy_constructible<T>::value&&
+                          std::is_copy_assignable<T>::value>
+struct CopyAssignBase {
+  CopyAssignBase() = default;
+  CopyAssignBase(const CopyAssignBase&) = default;
+  CopyAssignBase(CopyAssignBase&&) = default;
+  CopyAssignBase& operator=(const CopyAssignBase&) = default;
+  CopyAssignBase& operator=(CopyAssignBase&&) = default;
+};
+
+template <typename T>
+struct CopyAssignBase<T, false> {
+  CopyAssignBase() = default;
+  CopyAssignBase(const CopyAssignBase&) = default;
+  CopyAssignBase(CopyAssignBase&&) = default;
+  CopyAssignBase& operator=(const CopyAssignBase&) = delete;
+  CopyAssignBase& operator=(CopyAssignBase&&) = default;
+};
+
+template <typename T, bool = std::is_move_constructible<T>::value&&
+                          std::is_move_assignable<T>::value>
+struct MoveAssignBase {
+  MoveAssignBase() = default;
+  MoveAssignBase(const MoveAssignBase&) = default;
+  MoveAssignBase(MoveAssignBase&&) = default;
+  MoveAssignBase& operator=(const MoveAssignBase&) = default;
+  MoveAssignBase& operator=(MoveAssignBase&&) = default;
+};
+
+template <typename T>
+struct MoveAssignBase<T, false> {
+  MoveAssignBase() = default;
+  MoveAssignBase(const MoveAssignBase&) = default;
+  MoveAssignBase(MoveAssignBase&&) = default;
+  MoveAssignBase& operator=(const MoveAssignBase&) = default;
+  MoveAssignBase& operator=(MoveAssignBase&&) = delete;
+};
+
+ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(absl::Status status);
+
+}  // namespace internal_statusor
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/status.h b/CAPI/cpp/grpc/include/absl/status/status.h
new file mode 100644
index 0000000..9292b83
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/status/status.h
@@ -0,0 +1,892 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: status.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the Abseil `status` library, consisting of:
+//
+//   * An `absl::Status` class for holding error handling information
+//   * A set of canonical `absl::StatusCode` error codes, and associated
+//     utilities for generating and propagating status codes.
+//   * A set of helper functions for creating status codes and checking their
+//     values
+//
+// Within Google, `absl::Status` is the primary mechanism for communicating
+// errors in C++, and is used to represent error state in both in-process
+// library calls as well as RPC calls. Some of these errors may be recoverable,
+// but others may not. Most functions that can produce a recoverable error
+// should be designed to return an `absl::Status` (or `absl::StatusOr`).
+//
+// Example:
+//
+// absl::Status myFunction(absl::string_view fname, ...) {
+//   ...
+//   // encounter error
+//   if (error condition) {
+//     return absl::InvalidArgumentError("bad mode");
+//   }
+//   // else, return OK
+//   return absl::OkStatus();
+// }
+//
+// An `absl::Status` is designed to either return "OK" or one of a number of
+// different error codes, corresponding to typical error conditions.
+// In almost all cases, when using `absl::Status` you should use the canonical
+// error codes (of type `absl::StatusCode`) enumerated in this header file.
+// These canonical codes are understood across the codebase and will be
+// accepted across all API and RPC boundaries.
+#ifndef ABSL_STATUS_STATUS_H_
+#define ABSL_STATUS_STATUS_H_
+
+#include <iostream>
+#include <string>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/functional/function_ref.h"
+#include "absl/status/internal/status_internal.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::StatusCode
+//
+// An `absl::StatusCode` is an enumerated type indicating either no error ("OK")
+// or an error condition. In most cases, an `absl::Status` indicates a
+// recoverable error, and the purpose of signalling an error is to indicate what
+// action to take in response to that error. These error codes map to the proto
+// RPC error codes indicated in https://cloud.google.com/apis/design/errors.
+//
+// The errors listed below are the canonical errors associated with
+// `absl::Status` and are used throughout the codebase. As a result, these
+// error codes are somewhat generic.
+//
+// In general, try to return the most specific error that applies if more than
+// one error may pertain. For example, prefer `kOutOfRange` over
+// `kFailedPrecondition` if both codes apply. Similarly prefer `kNotFound` or
+// `kAlreadyExists` over `kFailedPrecondition`.
+//
+// Because these errors may cross RPC boundaries, these codes are tied to the
+// `google.rpc.Code` definitions within
+// https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
+// The string value of these RPC codes is denoted within each enum below.
+//
+// If your error handling code requires more context, you can attach payloads
+// to your status. See `absl::Status::SetPayload()` and
+// `absl::Status::GetPayload()` below.
+enum class StatusCode : int {
+  // StatusCode::kOk
+  //
+  // kOK (gRPC code "OK") does not indicate an error; this value is returned on
+  // success. It is typical to check for this value before proceeding on any
+  // given call across an API or RPC boundary. To check this value, use the
+  // `absl::Status::ok()` member function rather than inspecting the raw code.
+  kOk = 0,
+
+  // StatusCode::kCancelled
+  //
+  // kCancelled (gRPC code "CANCELLED") indicates the operation was cancelled,
+  // typically by the caller.
+  kCancelled = 1,
+
+  // StatusCode::kUnknown
+  //
+  // kUnknown (gRPC code "UNKNOWN") indicates an unknown error occurred. In
+  // general, more specific errors should be raised, if possible. Errors raised
+  // by APIs that do not return enough error information may be converted to
+  // this error.
+  kUnknown = 2,
+
+  // StatusCode::kInvalidArgument
+  //
+  // kInvalidArgument (gRPC code "INVALID_ARGUMENT") indicates the caller
+  // specified an invalid argument, such as a malformed filename. Note that use
+  // of such errors should be narrowly limited to indicate the invalid nature of
+  // the arguments themselves. Errors with validly formed arguments that may
+  // cause errors with the state of the receiving system should be denoted with
+  // `kFailedPrecondition` instead.
+  kInvalidArgument = 3,
+
+  // StatusCode::kDeadlineExceeded
+  //
+  // kDeadlineExceeded (gRPC code "DEADLINE_EXCEEDED") indicates a deadline
+  // expired before the operation could complete. For operations that may change
+  // state within a system, this error may be returned even if the operation has
+  // completed successfully. For example, a successful response from a server
+  // could have been delayed long enough for the deadline to expire.
+  kDeadlineExceeded = 4,
+
+  // StatusCode::kNotFound
+  //
+  // kNotFound (gRPC code "NOT_FOUND") indicates some requested entity (such as
+  // a file or directory) was not found.
+  //
+  // `kNotFound` is useful if a request should be denied for an entire class of
+  // users, such as during a gradual feature rollout or undocumented allow list.
+  // If a request should be denied for specific sets of users, such as through
+  // user-based access control, use `kPermissionDenied` instead.
+  kNotFound = 5,
+
+  // StatusCode::kAlreadyExists
+  //
+  // kAlreadyExists (gRPC code "ALREADY_EXISTS") indicates that the entity a
+  // caller attempted to create (such as a file or directory) is already
+  // present.
+  kAlreadyExists = 6,
+
+  // StatusCode::kPermissionDenied
+  //
+  // kPermissionDenied (gRPC code "PERMISSION_DENIED") indicates that the caller
+  // does not have permission to execute the specified operation. Note that this
+  // error is different than an error due to an *un*authenticated user. This
+  // error code does not imply the request is valid or the requested entity
+  // exists or satisfies any other pre-conditions.
+  //
+  // `kPermissionDenied` must not be used for rejections caused by exhausting
+  // some resource. Instead, use `kResourceExhausted` for those errors.
+  // `kPermissionDenied` must not be used if the caller cannot be identified.
+  // Instead, use `kUnauthenticated` for those errors.
+  kPermissionDenied = 7,
+
+  // StatusCode::kResourceExhausted
+  //
+  // kResourceExhausted (gRPC code "RESOURCE_EXHAUSTED") indicates some resource
+  // has been exhausted, perhaps a per-user quota, or perhaps the entire file
+  // system is out of space.
+  kResourceExhausted = 8,
+
+  // StatusCode::kFailedPrecondition
+  //
+  // kFailedPrecondition (gRPC code "FAILED_PRECONDITION") indicates that the
+  // operation was rejected because the system is not in a state required for
+  // the operation's execution. For example, a directory to be deleted may be
+  // non-empty, an "rmdir" operation is applied to a non-directory, etc.
+  //
+  // Some guidelines that may help a service implementer in deciding between
+  // `kFailedPrecondition`, `kAborted`, and `kUnavailable`:
+  //
+  //  (a) Use `kUnavailable` if the client can retry just the failing call.
+  //  (b) Use `kAborted` if the client should retry at a higher transaction
+  //      level (such as when a client-specified test-and-set fails, indicating
+  //      the client should restart a read-modify-write sequence).
+  //  (c) Use `kFailedPrecondition` if the client should not retry until
+  //      the system state has been explicitly fixed. For example, if a "rmdir"
+  //      fails because the directory is non-empty, `kFailedPrecondition`
+  //      should be returned since the client should not retry unless
+  //      the files are deleted from the directory.
+  kFailedPrecondition = 9,
+
+  // StatusCode::kAborted
+  //
+  // kAborted (gRPC code "ABORTED") indicates the operation was aborted,
+  // typically due to a concurrency issue such as a sequencer check failure or a
+  // failed transaction.
+  //
+  // See the guidelines above for deciding between `kFailedPrecondition`,
+  // `kAborted`, and `kUnavailable`.
+  kAborted = 10,
+
+  // StatusCode::kOutOfRange
+  //
+  // kOutOfRange (gRPC code "OUT_OF_RANGE") indicates the operation was
+  // attempted past the valid range, such as seeking or reading past an
+  // end-of-file.
+  //
+  // Unlike `kInvalidArgument`, this error indicates a problem that may
+  // be fixed if the system state changes. For example, a 32-bit file
+  // system will generate `kInvalidArgument` if asked to read at an
+  // offset that is not in the range [0,2^32-1], but it will generate
+  // `kOutOfRange` if asked to read from an offset past the current
+  // file size.
+  //
+  // There is a fair bit of overlap between `kFailedPrecondition` and
+  // `kOutOfRange`.  We recommend using `kOutOfRange` (the more specific
+  // error) when it applies so that callers who are iterating through
+  // a space can easily look for an `kOutOfRange` error to detect when
+  // they are done.
+  kOutOfRange = 11,
+
+  // StatusCode::kUnimplemented
+  //
+  // kUnimplemented (gRPC code "UNIMPLEMENTED") indicates the operation is not
+  // implemented or supported in this service. In this case, the operation
+  // should not be re-attempted.
+  kUnimplemented = 12,
+
+  // StatusCode::kInternal
+  //
+  // kInternal (gRPC code "INTERNAL") indicates an internal error has occurred
+  // and some invariants expected by the underlying system have not been
+  // satisfied. This error code is reserved for serious errors.
+  kInternal = 13,
+
+  // StatusCode::kUnavailable
+  //
+  // kUnavailable (gRPC code "UNAVAILABLE") indicates the service is currently
+  // unavailable and that this is most likely a transient condition. An error
+  // such as this can be corrected by retrying with a backoff scheme. Note that
+  // it is not always safe to retry non-idempotent operations.
+  //
+  // See the guidelines above for deciding between `kFailedPrecondition`,
+  // `kAborted`, and `kUnavailable`.
+  kUnavailable = 14,
+
+  // StatusCode::kDataLoss
+  //
+  // kDataLoss (gRPC code "DATA_LOSS") indicates that unrecoverable data loss or
+  // corruption has occurred. As this error is serious, proper alerting should
+  // be attached to errors such as this.
+  kDataLoss = 15,
+
+  // StatusCode::kUnauthenticated
+  //
+  // kUnauthenticated (gRPC code "UNAUTHENTICATED") indicates that the request
+  // does not have valid authentication credentials for the operation. Correct
+  // the authentication and try again.
+  kUnauthenticated = 16,
+
+  // StatusCode::DoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_
+  //
+  // NOTE: this error code entry should not be used and you should not rely on
+  // its value, which may change.
+  //
+  // The purpose of this enumerated value is to force people who handle status
+  // codes with `switch()` statements to *not* simply enumerate all possible
+  // values, but instead provide a "default:" case. Providing such a default
+  // case ensures that code will compile when new codes are added.
+  kDoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ = 20
+};
+
+// StatusCodeToString()
+//
+// Returns the name for the status code, or "" if it is an unknown value.
+std::string StatusCodeToString(StatusCode code);
+
+// operator<<
+//
+// Streams StatusCodeToString(code) to `os`.
+std::ostream& operator<<(std::ostream& os, StatusCode code);
+
+// absl::StatusToStringMode
+//
+// An `absl::StatusToStringMode` is an enumerated type indicating how
+// `absl::Status::ToString()` should construct the output string for a non-ok
+// status.
+enum class StatusToStringMode : int {
+  // ToString will not contain any extra data (such as payloads). It will only
+  // contain the error code and message, if any.
+  kWithNoExtraData = 0,
+  // ToString will contain the payloads.
+  kWithPayload = 1 << 0,
+  // ToString will include all the extra data this Status has.
+  kWithEverything = ~kWithNoExtraData,
+  // Default mode used by ToString. Its exact value might change in the future.
+  kDefault = kWithPayload,
+};
+
+// absl::StatusToStringMode is specified as a bitmask type, which means the
+// following operations must be provided:
+inline constexpr StatusToStringMode operator&(StatusToStringMode lhs,
+                                              StatusToStringMode rhs) {
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) &
+                                         static_cast<int>(rhs));
+}
+inline constexpr StatusToStringMode operator|(StatusToStringMode lhs,
+                                              StatusToStringMode rhs) {
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) |
+                                         static_cast<int>(rhs));
+}
+inline constexpr StatusToStringMode operator^(StatusToStringMode lhs,
+                                              StatusToStringMode rhs) {
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) ^
+                                         static_cast<int>(rhs));
+}
+inline constexpr StatusToStringMode operator~(StatusToStringMode arg) {
+  return static_cast<StatusToStringMode>(~static_cast<int>(arg));
+}
+inline StatusToStringMode& operator&=(StatusToStringMode& lhs,
+                                      StatusToStringMode rhs) {
+  lhs = lhs & rhs;
+  return lhs;
+}
+inline StatusToStringMode& operator|=(StatusToStringMode& lhs,
+                                      StatusToStringMode rhs) {
+  lhs = lhs | rhs;
+  return lhs;
+}
+inline StatusToStringMode& operator^=(StatusToStringMode& lhs,
+                                      StatusToStringMode rhs) {
+  lhs = lhs ^ rhs;
+  return lhs;
+}
+
+// absl::Status
+//
+// The `absl::Status` class is generally used to gracefully handle errors
+// across API boundaries (and in particular across RPC boundaries). Some of
+// these errors may be recoverable, but others may not. Most
+// functions which can produce a recoverable error should be designed to return
+// either an `absl::Status` (or the similar `absl::StatusOr<T>`, which holds
+// either an object of type `T` or an error).
+//
+// API developers should construct their functions to return `absl::OkStatus()`
+// upon success, or an `absl::StatusCode` upon another type of error (e.g
+// an `absl::StatusCode::kInvalidArgument` error). The API provides convenience
+// functions to construct each status code.
+//
+// Example:
+//
+// absl::Status myFunction(absl::string_view fname, ...) {
+//   ...
+//   // encounter error
+//   if (error condition) {
+//     // Construct an absl::StatusCode::kInvalidArgument error
+//     return absl::InvalidArgumentError("bad mode");
+//   }
+//   // else, return OK
+//   return absl::OkStatus();
+// }
+//
+// Users handling status error codes should prefer checking for an OK status
+// using the `ok()` member function. Handling multiple error codes may justify
+// use of switch statement, but only check for error codes you know how to
+// handle; do not try to exhaustively match against all canonical error codes.
+// Errors that cannot be handled should be logged and/or propagated for higher
+// levels to deal with. If you do use a switch statement, make sure that you
+// also provide a `default:` switch case, so that code does not break as other
+// canonical codes are added to the API.
+//
+// Example:
+//
+//   absl::Status result = DoSomething();
+//   if (!result.ok()) {
+//     LOG(ERROR) << result;
+//   }
+//
+//   // Provide a default if switching on multiple error codes
+//   switch (result.code()) {
+//     // The user hasn't authenticated. Ask them to reauth
+//     case absl::StatusCode::kUnauthenticated:
+//       DoReAuth();
+//       break;
+//     // The user does not have permission. Log an error.
+//     case absl::StatusCode::kPermissionDenied:
+//       LOG(ERROR) << result;
+//       break;
+//     // Propagate the error otherwise.
+//     default:
+//       return true;
+//   }
+//
+// An `absl::Status` can optionally include a payload with more information
+// about the error. Typically, this payload serves one of several purposes:
+//
+//   * It may provide more fine-grained semantic information about the error to
+//     facilitate actionable remedies.
+//   * It may provide human-readable contexual information that is more
+//     appropriate to display to an end user.
+//
+// Example:
+//
+//   absl::Status result = DoSomething();
+//   // Inform user to retry after 30 seconds
+//   // See more error details in googleapis/google/rpc/error_details.proto
+//   if (absl::IsResourceExhausted(result)) {
+//     google::rpc::RetryInfo info;
+//     info.retry_delay().seconds() = 30;
+//     // Payloads require a unique key (a URL to ensure no collisions with
+//     // other payloads), and an `absl::Cord` to hold the encoded data.
+//     absl::string_view url = "type.googleapis.com/google.rpc.RetryInfo";
+//     result.SetPayload(url, info.SerializeAsCord());
+//     return result;
+//   }
+//
+// For documentation see https://abseil.io/docs/cpp/guides/status.
+//
+// Returned Status objects may not be ignored. status_internal.h has a forward
+// declaration of the form
+// class ABSL_MUST_USE_RESULT Status;
+class Status final {
+ public:
+  // Constructors
+
+  // This default constructor creates an OK status with no message or payload.
+  // Avoid this constructor and prefer explicit construction of an OK status
+  // with `absl::OkStatus()`.
+  Status();
+
+  // Creates a status in the canonical error space with the specified
+  // `absl::StatusCode` and error message.  If `code == absl::StatusCode::kOk`,  // NOLINT
+  // `msg` is ignored and an object identical to an OK status is constructed.
+  //
+  // The `msg` string must be in UTF-8. The implementation may complain (e.g.,  // NOLINT
+  // by printing a warning) if it is not.
+  Status(absl::StatusCode code, absl::string_view msg);
+
+  Status(const Status&);
+  Status& operator=(const Status& x);
+
+  // Move operators
+
+  // The moved-from state is valid but unspecified.
+  Status(Status&&) noexcept;
+  Status& operator=(Status&&);
+
+  ~Status();
+
+  // Status::Update()
+  //
+  // Updates the existing status with `new_status` provided that `this->ok()`.
+  // If the existing status already contains a non-OK error, this update has no
+  // effect and preserves the current data. Note that this behavior may change
+  // in the future to augment a current non-ok status with additional
+  // information about `new_status`.
+  //
+  // `Update()` provides a convenient way of keeping track of the first error
+  // encountered.
+  //
+  // Example:
+  //   // Instead of "if (overall_status.ok()) overall_status = new_status"
+  //   overall_status.Update(new_status);
+  //
+  void Update(const Status& new_status);
+  void Update(Status&& new_status);
+
+  // Status::ok()
+  //
+  // Returns `true` if `this->code()` == `absl::StatusCode::kOk`,
+  // indicating the absence of an error.
+  // Prefer checking for an OK status using this member function.
+  ABSL_MUST_USE_RESULT bool ok() const;
+
+  // Status::code()
+  //
+  // Returns the canonical error code of type `absl::StatusCode` of this status.
+  absl::StatusCode code() const;
+
+  // Status::raw_code()
+  //
+  // Returns a raw (canonical) error code corresponding to the enum value of
+  // `google.rpc.Code` definitions within
+  // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto.
+  // These values could be out of the range of canonical `absl::StatusCode`
+  // enum values.
+  //
+  // NOTE: This function should only be called when converting to an associated
+  // wire format. Use `Status::code()` for error handling.
+  int raw_code() const;
+
+  // Status::message()
+  //
+  // Returns the error message associated with this error code, if available.
+  // Note that this message rarely describes the error code.  It is not unusual
+  // for the error message to be the empty string. As a result, prefer
+  // `operator<<` or `Status::ToString()` for debug logging.
+  absl::string_view message() const;
+
+  friend bool operator==(const Status&, const Status&);
+  friend bool operator!=(const Status&, const Status&);
+
+  // Status::ToString()
+  //
+  // Returns a string based on the `mode`. By default, it returns combination of
+  // the error code name, the message and any associated payload messages. This
+  // string is designed simply to be human readable and its exact format should
+  // not be load bearing. Do not depend on the exact format of the result of
+  // `ToString()` which is subject to change.
+  //
+  // The printed code name and the message are generally substrings of the
+  // result, and the payloads to be printed use the status payload printer
+  // mechanism (which is internal).
+  std::string ToString(
+      StatusToStringMode mode = StatusToStringMode::kDefault) const;
+
+  // Status::IgnoreError()
+  //
+  // Ignores any errors. This method does nothing except potentially suppress
+  // complaints from any tools that are checking that errors are not dropped on
+  // the floor.
+  void IgnoreError() const;
+
+  // swap()
+  //
+  // Swap the contents of one status with another.
+  friend void swap(Status& a, Status& b);
+
+  //----------------------------------------------------------------------------
+  // Payload Management APIs
+  //----------------------------------------------------------------------------
+
+  // A payload may be attached to a status to provide additional context to an
+  // error that may not be satisfied by an existing `absl::StatusCode`.
+  // Typically, this payload serves one of several purposes:
+  //
+  //   * It may provide more fine-grained semantic information about the error
+  //     to facilitate actionable remedies.
+  //   * It may provide human-readable contexual information that is more
+  //     appropriate to display to an end user.
+  //
+  // A payload consists of a [key,value] pair, where the key is a string
+  // referring to a unique "type URL" and the value is an object of type
+  // `absl::Cord` to hold the contextual data.
+  //
+  // The "type URL" should be unique and follow the format of a URL
+  // (https://en.wikipedia.org/wiki/URL) and, ideally, provide some
+  // documentation or schema on how to interpret its associated data. For
+  // example, the default type URL for a protobuf message type is
+  // "type.googleapis.com/packagename.messagename". Other custom wire formats
+  // should define the format of type URL in a similar practice so as to
+  // minimize the chance of conflict between type URLs.
+  // Users should ensure that the type URL can be mapped to a concrete
+  // C++ type if they want to deserialize the payload and read it effectively.
+  //
+  // To attach a payload to a status object, call `Status::SetPayload()`,
+  // passing it the type URL and an `absl::Cord` of associated data. Similarly,
+  // to extract the payload from a status, call `Status::GetPayload()`. You
+  // may attach multiple payloads (with differing type URLs) to any given
+  // status object, provided that the status is currently exhibiting an error
+  // code (i.e. is not OK).
+
+  // Status::GetPayload()
+  //
+  // Gets the payload of a status given its unique `type_url` key, if present.
+  absl::optional<absl::Cord> GetPayload(absl::string_view type_url) const;
+
+  // Status::SetPayload()
+  //
+  // Sets the payload for a non-ok status using a `type_url` key, overwriting
+  // any existing payload for that `type_url`.
+  //
+  // NOTE: This function does nothing if the Status is ok.
+  void SetPayload(absl::string_view type_url, absl::Cord payload);
+
+  // Status::ErasePayload()
+  //
+  // Erases the payload corresponding to the `type_url` key.  Returns `true` if
+  // the payload was present.
+  bool ErasePayload(absl::string_view type_url);
+
+  // Status::ForEachPayload()
+  //
+  // Iterates over the stored payloads and calls the
+  // `visitor(type_key, payload)` callable for each one.
+  //
+  // NOTE: The order of calls to `visitor()` is not specified and may change at
+  // any time.
+  //
+  // NOTE: Any mutation on the same 'absl::Status' object during visitation is
+  // forbidden and could result in undefined behavior.
+  void ForEachPayload(
+      absl::FunctionRef<void(absl::string_view, const absl::Cord&)> visitor)
+      const;
+
+ private:
+  friend Status CancelledError();
+
+  // Creates a status in the canonical error space with the specified
+  // code, and an empty error message.
+  explicit Status(absl::StatusCode code);
+
+  static void UnrefNonInlined(uintptr_t rep);
+  static void Ref(uintptr_t rep);
+  static void Unref(uintptr_t rep);
+
+  // REQUIRES: !ok()
+  // Ensures rep_ is not shared with any other Status.
+  void PrepareToModify();
+
+  const status_internal::Payloads* GetPayloads() const;
+  status_internal::Payloads* GetPayloads();
+
+  static bool EqualsSlow(const absl::Status& a, const absl::Status& b);
+
+  // MSVC 14.0 limitation requires the const.
+  static constexpr const char kMovedFromString[] =
+      "Status accessed after move.";
+
+  static const std::string* EmptyString();
+  static const std::string* MovedFromString();
+
+  // Returns whether rep contains an inlined representation.
+  // See rep_ for details.
+  static bool IsInlined(uintptr_t rep);
+
+  // Indicates whether this Status was the rhs of a move operation. See rep_
+  // for details.
+  static bool IsMovedFrom(uintptr_t rep);
+  static uintptr_t MovedFromRep();
+
+  // Convert between error::Code and the inlined uintptr_t representation used
+  // by rep_. See rep_ for details.
+  static uintptr_t CodeToInlinedRep(absl::StatusCode code);
+  static absl::StatusCode InlinedRepToCode(uintptr_t rep);
+
+  // Converts between StatusRep* and the external uintptr_t representation used
+  // by rep_. See rep_ for details.
+  static uintptr_t PointerToRep(status_internal::StatusRep* r);
+  static status_internal::StatusRep* RepToPointer(uintptr_t r);
+
+  std::string ToStringSlow(StatusToStringMode mode) const;
+
+  // Status supports two different representations.
+  //  - When the low bit is off it is an inlined representation.
+  //    It uses the canonical error space, no message or payload.
+  //    The error code is (rep_ >> 2).
+  //    The (rep_ & 2) bit is the "moved from" indicator, used in IsMovedFrom().
+  //  - When the low bit is on it is an external representation.
+  //    In this case all the data comes from a heap allocated Rep object.
+  //    (rep_ - 1) is a status_internal::StatusRep* pointer to that structure.
+  uintptr_t rep_;
+};
+
+// OkStatus()
+//
+// Returns an OK status, equivalent to a default constructed instance. Prefer
+// usage of `absl::OkStatus()` when constructing such an OK status.
+Status OkStatus();
+
+// operator<<()
+//
+// Prints a human-readable representation of `x` to `os`.
+std::ostream& operator<<(std::ostream& os, const Status& x);
+
+// IsAborted()
+// IsAlreadyExists()
+// IsCancelled()
+// IsDataLoss()
+// IsDeadlineExceeded()
+// IsFailedPrecondition()
+// IsInternal()
+// IsInvalidArgument()
+// IsNotFound()
+// IsOutOfRange()
+// IsPermissionDenied()
+// IsResourceExhausted()
+// IsUnauthenticated()
+// IsUnavailable()
+// IsUnimplemented()
+// IsUnknown()
+//
+// These convenience functions return `true` if a given status matches the
+// `absl::StatusCode` error code of its associated function.
+ABSL_MUST_USE_RESULT bool IsAborted(const Status& status);
+ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status);
+ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status);
+ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status);
+ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status);
+ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status);
+ABSL_MUST_USE_RESULT bool IsInternal(const Status& status);
+ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status);
+ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status);
+ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status);
+ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status);
+ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status);
+ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status);
+ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status);
+ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status);
+ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status);
+
+// AbortedError()
+// AlreadyExistsError()
+// CancelledError()
+// DataLossError()
+// DeadlineExceededError()
+// FailedPreconditionError()
+// InternalError()
+// InvalidArgumentError()
+// NotFoundError()
+// OutOfRangeError()
+// PermissionDeniedError()
+// ResourceExhaustedError()
+// UnauthenticatedError()
+// UnavailableError()
+// UnimplementedError()
+// UnknownError()
+//
+// These convenience functions create an `absl::Status` object with an error
+// code as indicated by the associated function name, using the error message
+// passed in `message`.
+Status AbortedError(absl::string_view message);
+Status AlreadyExistsError(absl::string_view message);
+Status CancelledError(absl::string_view message);
+Status DataLossError(absl::string_view message);
+Status DeadlineExceededError(absl::string_view message);
+Status FailedPreconditionError(absl::string_view message);
+Status InternalError(absl::string_view message);
+Status InvalidArgumentError(absl::string_view message);
+Status NotFoundError(absl::string_view message);
+Status OutOfRangeError(absl::string_view message);
+Status PermissionDeniedError(absl::string_view message);
+Status ResourceExhaustedError(absl::string_view message);
+Status UnauthenticatedError(absl::string_view message);
+Status UnavailableError(absl::string_view message);
+Status UnimplementedError(absl::string_view message);
+Status UnknownError(absl::string_view message);
+
+// ErrnoToStatusCode()
+//
+// Returns the StatusCode for `error_number`, which should be an `errno` value.
+// See https://en.cppreference.com/w/cpp/error/errno_macros and similar
+// references.
+absl::StatusCode ErrnoToStatusCode(int error_number);
+
+// ErrnoToStatus()
+//
+// Convenience function that creates a `absl::Status` using an `error_number`,
+// which should be an `errno` value.
+Status ErrnoToStatus(int error_number, absl::string_view message);
+
+//------------------------------------------------------------------------------
+// Implementation details follow
+//------------------------------------------------------------------------------
+
+inline Status::Status() : rep_(CodeToInlinedRep(absl::StatusCode::kOk)) {}
+
+inline Status::Status(absl::StatusCode code) : rep_(CodeToInlinedRep(code)) {}
+
+inline Status::Status(const Status& x) : rep_(x.rep_) { Ref(rep_); }
+
+inline Status& Status::operator=(const Status& x) {
+  uintptr_t old_rep = rep_;
+  if (x.rep_ != old_rep) {
+    Ref(x.rep_);
+    rep_ = x.rep_;
+    Unref(old_rep);
+  }
+  return *this;
+}
+
+inline Status::Status(Status&& x) noexcept : rep_(x.rep_) {
+  x.rep_ = MovedFromRep();
+}
+
+inline Status& Status::operator=(Status&& x) {
+  uintptr_t old_rep = rep_;
+  if (x.rep_ != old_rep) {
+    rep_ = x.rep_;
+    x.rep_ = MovedFromRep();
+    Unref(old_rep);
+  }
+  return *this;
+}
+
+inline void Status::Update(const Status& new_status) {
+  if (ok()) {
+    *this = new_status;
+  }
+}
+
+inline void Status::Update(Status&& new_status) {
+  if (ok()) {
+    *this = std::move(new_status);
+  }
+}
+
+inline Status::~Status() { Unref(rep_); }
+
+inline bool Status::ok() const {
+  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
+}
+
+inline absl::string_view Status::message() const {
+  return !IsInlined(rep_)
+             ? RepToPointer(rep_)->message
+             : (IsMovedFrom(rep_) ? absl::string_view(kMovedFromString)
+                                  : absl::string_view());
+}
+
+inline bool operator==(const Status& lhs, const Status& rhs) {
+  return lhs.rep_ == rhs.rep_ || Status::EqualsSlow(lhs, rhs);
+}
+
+inline bool operator!=(const Status& lhs, const Status& rhs) {
+  return !(lhs == rhs);
+}
+
+inline std::string Status::ToString(StatusToStringMode mode) const {
+  return ok() ? "OK" : ToStringSlow(mode);
+}
+
+inline void Status::IgnoreError() const {
+  // no-op
+}
+
+inline void swap(absl::Status& a, absl::Status& b) {
+  using std::swap;
+  swap(a.rep_, b.rep_);
+}
+
+inline const status_internal::Payloads* Status::GetPayloads() const {
+  return IsInlined(rep_) ? nullptr : RepToPointer(rep_)->payloads.get();
+}
+
+inline status_internal::Payloads* Status::GetPayloads() {
+  return IsInlined(rep_) ? nullptr : RepToPointer(rep_)->payloads.get();
+}
+
+inline bool Status::IsInlined(uintptr_t rep) { return (rep & 1) == 0; }
+
+inline bool Status::IsMovedFrom(uintptr_t rep) {
+  return IsInlined(rep) && (rep & 2) != 0;
+}
+
+inline uintptr_t Status::MovedFromRep() {
+  return CodeToInlinedRep(absl::StatusCode::kInternal) | 2;
+}
+
+inline uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
+  return static_cast<uintptr_t>(code) << 2;
+}
+
+inline absl::StatusCode Status::InlinedRepToCode(uintptr_t rep) {
+  assert(IsInlined(rep));
+  return static_cast<absl::StatusCode>(rep >> 2);
+}
+
+inline status_internal::StatusRep* Status::RepToPointer(uintptr_t rep) {
+  assert(!IsInlined(rep));
+  return reinterpret_cast<status_internal::StatusRep*>(rep - 1);
+}
+
+inline uintptr_t Status::PointerToRep(status_internal::StatusRep* rep) {
+  return reinterpret_cast<uintptr_t>(rep) + 1;
+}
+
+inline void Status::Ref(uintptr_t rep) {
+  if (!IsInlined(rep)) {
+    RepToPointer(rep)->ref.fetch_add(1, std::memory_order_relaxed);
+  }
+}
+
+inline void Status::Unref(uintptr_t rep) {
+  if (!IsInlined(rep)) {
+    UnrefNonInlined(rep);
+  }
+}
+
+inline Status OkStatus() { return Status(); }
+
+// Creates a `Status` object with the `absl::StatusCode::kCancelled` error code
+// and an empty message. It is provided only for efficiency, given that
+// message-less kCancelled errors are common in the infrastructure.
+inline Status CancelledError() { return Status(absl::StatusCode::kCancelled); }
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STATUS_STATUS_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/status_payload_printer.h b/CAPI/cpp/grpc/include/absl/status/status_payload_printer.h
new file mode 100644
index 0000000..5e0937f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/status/status_payload_printer.h
@@ -0,0 +1,51 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+#ifndef ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
+#define ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
+
+#include <string>
+
+#include "absl/strings/cord.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace status_internal {
+
+// By default, `Status::ToString` and `operator<<(Status)` print a payload by
+// dumping the type URL and the raw bytes. To help debugging, we provide an
+// extension point, which is a global printer function that can be set by users
+// to specify how to print payloads. The function takes the type URL and the
+// payload as input, and should return a valid human-readable string on success
+// or `absl::nullopt` on failure (in which case it falls back to the default
+// approach of printing the raw bytes).
+// NOTE: This is an internal API and the design is subject to change in the
+// future in a non-backward-compatible way. Since it's only meant for debugging
+// purpose, you should not rely on it in any critical logic.
+using StatusPayloadPrinter = absl::optional<std::string> (*)(absl::string_view,
+                                                             const absl::Cord&);
+
+// Sets the global payload printer. Only one printer should be set per process.
+// If multiple printers are set, it's undefined which one will be used.
+void SetStatusPayloadPrinter(StatusPayloadPrinter);
+
+// Returns the global payload printer if previously set, otherwise `nullptr`.
+StatusPayloadPrinter GetStatusPayloadPrinter();
+
+}  // namespace status_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/statusor.h b/CAPI/cpp/grpc/include/absl/status/statusor.h
new file mode 100644
index 0000000..a76e720
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/status/statusor.h
@@ -0,0 +1,776 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: statusor.h
+// -----------------------------------------------------------------------------
+//
+// An `absl::StatusOr<T>` represents a union of an `absl::Status` object
+// and an object of type `T`. The `absl::StatusOr<T>` will either contain an
+// object of type `T` (indicating a successful operation), or an error (of type
+// `absl::Status`) explaining why such a value is not present.
+//
+// In general, check the success of an operation returning an
+// `absl::StatusOr<T>` like you would an `absl::Status` by using the `ok()`
+// member function.
+//
+// Example:
+//
+//   StatusOr<Foo> result = Calculation();
+//   if (result.ok()) {
+//     result->DoSomethingCool();
+//   } else {
+//     LOG(ERROR) << result.status();
+//   }
+#ifndef ABSL_STATUS_STATUSOR_H_
+#define ABSL_STATUS_STATUSOR_H_
+
+#include <exception>
+#include <initializer_list>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/call_once.h"
+#include "absl/meta/type_traits.h"
+#include "absl/status/internal/statusor_internal.h"
+#include "absl/status/status.h"
+#include "absl/types/variant.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// BadStatusOrAccess
+//
+// This class defines the type of object to throw (if exceptions are enabled),
+// when accessing the value of an `absl::StatusOr<T>` object that does not
+// contain a value. This behavior is analogous to that of
+// `std::bad_optional_access` in the case of accessing an invalid
+// `std::optional` value.
+//
+// Example:
+//
+// try {
+//   absl::StatusOr<int> v = FetchInt();
+//   DoWork(v.value());  // Accessing value() when not "OK" may throw
+// } catch (absl::BadStatusOrAccess& ex) {
+//   LOG(ERROR) << ex.status();
+// }
+class BadStatusOrAccess : public std::exception {
+ public:
+  explicit BadStatusOrAccess(absl::Status status);
+  ~BadStatusOrAccess() override = default;
+
+  BadStatusOrAccess(const BadStatusOrAccess& other);
+  BadStatusOrAccess& operator=(const BadStatusOrAccess& other);
+  BadStatusOrAccess(BadStatusOrAccess&& other);
+  BadStatusOrAccess& operator=(BadStatusOrAccess&& other);
+
+  // BadStatusOrAccess::what()
+  //
+  // Returns the associated explanatory string of the `absl::StatusOr<T>`
+  // object's error code. This function contains information about the failing
+  // status, but its exact formatting may change and should not be depended on.
+  //
+  // The pointer of this string is guaranteed to be valid until any non-const
+  // function is invoked on the exception object.
+  const char* what() const noexcept override;
+
+  // BadStatusOrAccess::status()
+  //
+  // Returns the associated `absl::Status` of the `absl::StatusOr<T>` object's
+  // error.
+  const absl::Status& status() const;
+
+ private:
+  void InitWhat() const;
+
+  absl::Status status_;
+  mutable absl::once_flag init_what_;
+  mutable std::string what_;
+};
+
+// Returned StatusOr objects may not be ignored.
+template <typename T>
+#if ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
+// TODO(b/176172494): ABSL_MUST_USE_RESULT should expand to the more strict
+// [[nodiscard]]. For now, just use [[nodiscard]] directly when it is available.
+class [[nodiscard]] StatusOr;
+#else
+class ABSL_MUST_USE_RESULT StatusOr;
+#endif  // ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
+
+// absl::StatusOr<T>
+//
+// The `absl::StatusOr<T>` class template is a union of an `absl::Status` object
+// and an object of type `T`. The `absl::StatusOr<T>` models an object that is
+// either a usable object, or an error (of type `absl::Status`) explaining why
+// such an object is not present. An `absl::StatusOr<T>` is typically the return
+// value of a function which may fail.
+//
+// An `absl::StatusOr<T>` can never hold an "OK" status (an
+// `absl::StatusCode::kOk` value); instead, the presence of an object of type
+// `T` indicates success. Instead of checking for a `kOk` value, use the
+// `absl::StatusOr<T>::ok()` member function. (It is for this reason, and code
+// readability, that using the `ok()` function is preferred for `absl::Status`
+// as well.)
+//
+// Example:
+//
+//   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
+//   if (result.ok()) {
+//     result->DoSomethingCool();
+//   } else {
+//     LOG(ERROR) << result.status();
+//   }
+//
+// Accessing the object held by an `absl::StatusOr<T>` should be performed via
+// `operator*` or `operator->`, after a call to `ok()` confirms that the
+// `absl::StatusOr<T>` holds an object of type `T`:
+//
+// Example:
+//
+//   absl::StatusOr<int> i = GetCount();
+//   if (i.ok()) {
+//     updated_total += *i
+//   }
+//
+// NOTE: using `absl::StatusOr<T>::value()` when no valid value is present will
+// throw an exception if exceptions are enabled or terminate the process when
+// exceptions are not enabled.
+//
+// Example:
+//
+//   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
+//   const Foo& foo = result.value();    // Crash/exception if no value present
+//   foo.DoSomethingCool();
+//
+// A `absl::StatusOr<T*>` can be constructed from a null pointer like any other
+// pointer value, and the result will be that `ok()` returns `true` and
+// `value()` returns `nullptr`. Checking the value of pointer in an
+// `absl::StatusOr<T*>` generally requires a bit more care, to ensure both that
+// a value is present and that value is not null:
+//
+//  StatusOr<std::unique_ptr<Foo>> result = FooFactory::MakeNewFoo(arg);
+//  if (!result.ok()) {
+//    LOG(ERROR) << result.status();
+//  } else if (*result == nullptr) {
+//    LOG(ERROR) << "Unexpected null pointer";
+//  } else {
+//    (*result)->DoSomethingCool();
+//  }
+//
+// Example factory implementation returning StatusOr<T>:
+//
+//  StatusOr<Foo> FooFactory::MakeFoo(int arg) {
+//    if (arg <= 0) {
+//      return absl::Status(absl::StatusCode::kInvalidArgument,
+//                          "Arg must be positive");
+//    }
+//    return Foo(arg);
+//  }
+template <typename T>
+class StatusOr : private internal_statusor::StatusOrData<T>,
+                 private internal_statusor::CopyCtorBase<T>,
+                 private internal_statusor::MoveCtorBase<T>,
+                 private internal_statusor::CopyAssignBase<T>,
+                 private internal_statusor::MoveAssignBase<T> {
+  template <typename U>
+  friend class StatusOr;
+
+  typedef internal_statusor::StatusOrData<T> Base;
+
+ public:
+  // StatusOr<T>::value_type
+  //
+  // This instance data provides a generic `value_type` member for use within
+  // generic programming. This usage is analogous to that of
+  // `optional::value_type` in the case of `std::optional`.
+  typedef T value_type;
+
+  // Constructors
+
+  // Constructs a new `absl::StatusOr` with an `absl::StatusCode::kUnknown`
+  // status. This constructor is marked 'explicit' to prevent usages in return
+  // values such as 'return {};', under the misconception that
+  // `absl::StatusOr<std::vector<int>>` will be initialized with an empty
+  // vector, instead of an `absl::StatusCode::kUnknown` error code.
+  explicit StatusOr();
+
+  // `StatusOr<T>` is copy constructible if `T` is copy constructible.
+  StatusOr(const StatusOr&) = default;
+  // `StatusOr<T>` is copy assignable if `T` is copy constructible and copy
+  // assignable.
+  StatusOr& operator=(const StatusOr&) = default;
+
+  // `StatusOr<T>` is move constructible if `T` is move constructible.
+  StatusOr(StatusOr&&) = default;
+  // `StatusOr<T>` is moveAssignable if `T` is move constructible and move
+  // assignable.
+  StatusOr& operator=(StatusOr&&) = default;
+
+  // Converting Constructors
+
+  // Constructs a new `absl::StatusOr<T>` from an `absl::StatusOr<U>`, when `T`
+  // is constructible from `U`. To avoid ambiguity, these constructors are
+  // disabled if `T` is also constructible from `StatusOr<U>.`. This constructor
+  // is explicit if and only if the corresponding construction of `T` from `U`
+  // is explicit. (This constructor inherits its explicitness from the
+  // underlying constructor.)
+  template <
+      typename U,
+      absl::enable_if_t<
+          absl::conjunction<
+              absl::negation<std::is_same<T, U>>,
+              std::is_constructible<T, const U&>,
+              std::is_convertible<const U&, T>,
+              absl::negation<
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
+                      T, U>>>::value,
+          int> = 0>
+  StatusOr(const StatusOr<U>& other)  // NOLINT
+      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
+  template <
+      typename U,
+      absl::enable_if_t<
+          absl::conjunction<
+              absl::negation<std::is_same<T, U>>,
+              std::is_constructible<T, const U&>,
+              absl::negation<std::is_convertible<const U&, T>>,
+              absl::negation<
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
+                      T, U>>>::value,
+          int> = 0>
+  explicit StatusOr(const StatusOr<U>& other)
+      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
+
+  template <
+      typename U,
+      absl::enable_if_t<
+          absl::conjunction<
+              absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+              std::is_convertible<U&&, T>,
+              absl::negation<
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
+                      T, U>>>::value,
+          int> = 0>
+  StatusOr(StatusOr<U>&& other)  // NOLINT
+      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
+  template <
+      typename U,
+      absl::enable_if_t<
+          absl::conjunction<
+              absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+              absl::negation<std::is_convertible<U&&, T>>,
+              absl::negation<
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
+                      T, U>>>::value,
+          int> = 0>
+  explicit StatusOr(StatusOr<U>&& other)
+      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
+
+  // Converting Assignment Operators
+
+  // Creates an `absl::StatusOr<T>` through assignment from an
+  // `absl::StatusOr<U>` when:
+  //
+  //   * Both `absl::StatusOr<T>` and `absl::StatusOr<U>` are OK by assigning
+  //     `U` to `T` directly.
+  //   * `absl::StatusOr<T>` is OK and `absl::StatusOr<U>` contains an error
+  //      code by destroying `absl::StatusOr<T>`'s value and assigning from
+  //      `absl::StatusOr<U>'
+  //   * `absl::StatusOr<T>` contains an error code and `absl::StatusOr<U>` is
+  //      OK by directly initializing `T` from `U`.
+  //   * Both `absl::StatusOr<T>` and `absl::StatusOr<U>` contain an error
+  //     code by assigning the `Status` in `absl::StatusOr<U>` to
+  //     `absl::StatusOr<T>`
+  //
+  // These overloads only apply if `absl::StatusOr<T>` is constructible and
+  // assignable from `absl::StatusOr<U>` and `StatusOr<T>` cannot be directly
+  // assigned from `StatusOr<U>`.
+  template <
+      typename U,
+      absl::enable_if_t<
+          absl::conjunction<
+              absl::negation<std::is_same<T, U>>,
+              std::is_constructible<T, const U&>,
+              std::is_assignable<T, const U&>,
+              absl::negation<
+                  internal_statusor::
+                      IsConstructibleOrConvertibleOrAssignableFromStatusOr<
+                          T, U>>>::value,
+          int> = 0>
+  StatusOr& operator=(const StatusOr<U>& other) {
+    this->Assign(other);
+    return *this;
+  }
+  template <
+      typename U,
+      absl::enable_if_t<
+          absl::conjunction<
+              absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+              std::is_assignable<T, U&&>,
+              absl::negation<
+                  internal_statusor::
+                      IsConstructibleOrConvertibleOrAssignableFromStatusOr<
+                          T, U>>>::value,
+          int> = 0>
+  StatusOr& operator=(StatusOr<U>&& other) {
+    this->Assign(std::move(other));
+    return *this;
+  }
+
+  // Constructs a new `absl::StatusOr<T>` with a non-ok status. After calling
+  // this constructor, `this->ok()` will be `false` and calls to `value()` will
+  // crash, or produce an exception if exceptions are enabled.
+  //
+  // The constructor also takes any type `U` that is convertible to
+  // `absl::Status`. This constructor is explicit if an only if `U` is not of
+  // type `absl::Status` and the conversion from `U` to `Status` is explicit.
+  //
+  // REQUIRES: !Status(std::forward<U>(v)).ok(). This requirement is DCHECKed.
+  // In optimized builds, passing absl::OkStatus() here will have the effect
+  // of passing absl::StatusCode::kInternal as a fallback.
+  template <
+      typename U = absl::Status,
+      absl::enable_if_t<
+          absl::conjunction<
+              std::is_convertible<U&&, absl::Status>,
+              std::is_constructible<absl::Status, U&&>,
+              absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
+              absl::negation<std::is_same<absl::decay_t<U>, T>>,
+              absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
+              absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
+                  T, U&&>>>::value,
+          int> = 0>
+  StatusOr(U&& v) : Base(std::forward<U>(v)) {}
+
+  template <
+      typename U = absl::Status,
+      absl::enable_if_t<
+          absl::conjunction<
+              absl::negation<std::is_convertible<U&&, absl::Status>>,
+              std::is_constructible<absl::Status, U&&>,
+              absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
+              absl::negation<std::is_same<absl::decay_t<U>, T>>,
+              absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
+              absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
+                  T, U&&>>>::value,
+          int> = 0>
+  explicit StatusOr(U&& v) : Base(std::forward<U>(v)) {}
+
+  template <
+      typename U = absl::Status,
+      absl::enable_if_t<
+          absl::conjunction<
+              std::is_convertible<U&&, absl::Status>,
+              std::is_constructible<absl::Status, U&&>,
+              absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
+              absl::negation<std::is_same<absl::decay_t<U>, T>>,
+              absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
+              absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
+                  T, U&&>>>::value,
+          int> = 0>
+  StatusOr& operator=(U&& v) {
+    this->AssignStatus(std::forward<U>(v));
+    return *this;
+  }
+
+  // Perfect-forwarding value assignment operator.
+
+  // If `*this` contains a `T` value before the call, the contained value is
+  // assigned from `std::forward<U>(v)`; Otherwise, it is directly-initialized
+  // from `std::forward<U>(v)`.
+  // This function does not participate in overload unless:
+  // 1. `std::is_constructible_v<T, U>` is true,
+  // 2. `std::is_assignable_v<T&, U>` is true.
+  // 3. `std::is_same_v<StatusOr<T>, std::remove_cvref_t<U>>` is false.
+  // 4. Assigning `U` to `T` is not ambiguous:
+  //  If `U` is `StatusOr<V>` and `T` is constructible and assignable from
+  //  both `StatusOr<V>` and `V`, the assignment is considered bug-prone and
+  //  ambiguous thus will fail to compile. For example:
+  //    StatusOr<bool> s1 = true;  // s1.ok() && *s1 == true
+  //    StatusOr<bool> s2 = false;  // s2.ok() && *s2 == false
+  //    s1 = s2;  // ambiguous, `s1 = *s2` or `s1 = bool(s2)`?
+  template <
+      typename U = T,
+      typename = typename std::enable_if<absl::conjunction<
+          std::is_constructible<T, U&&>, std::is_assignable<T&, U&&>,
+          absl::disjunction<
+              std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, T>,
+              absl::conjunction<
+                  absl::negation<std::is_convertible<U&&, absl::Status>>,
+                  absl::negation<internal_statusor::
+                                     HasConversionOperatorToStatusOr<T, U&&>>>>,
+          internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>::type>
+  StatusOr& operator=(U&& v) {
+    this->Assign(std::forward<U>(v));
+    return *this;
+  }
+
+  // Constructs the inner value `T` in-place using the provided args, using the
+  // `T(args...)` constructor.
+  template <typename... Args>
+  explicit StatusOr(absl::in_place_t, Args&&... args);
+  template <typename U, typename... Args>
+  explicit StatusOr(absl::in_place_t, std::initializer_list<U> ilist,
+                    Args&&... args);
+
+  // Constructs the inner value `T` in-place using the provided args, using the
+  // `T(U)` (direct-initialization) constructor. This constructor is only valid
+  // if `T` can be constructed from a `U`. Can accept move or copy constructors.
+  //
+  // This constructor is explicit if `U` is not convertible to `T`. To avoid
+  // ambiguity, this constructor is disabled if `U` is a `StatusOr<J>`, where
+  // `J` is convertible to `T`.
+  template <
+      typename U = T,
+      absl::enable_if_t<
+          absl::conjunction<
+              internal_statusor::IsDirectInitializationValid<T, U&&>,
+              std::is_constructible<T, U&&>, std::is_convertible<U&&, T>,
+              absl::disjunction<
+                  std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>,
+                               T>,
+                  absl::conjunction<
+                      absl::negation<std::is_convertible<U&&, absl::Status>>,
+                      absl::negation<
+                          internal_statusor::HasConversionOperatorToStatusOr<
+                              T, U&&>>>>>::value,
+          int> = 0>
+  StatusOr(U&& u)  // NOLINT
+      : StatusOr(absl::in_place, std::forward<U>(u)) {}
+
+  template <
+      typename U = T,
+      absl::enable_if_t<
+          absl::conjunction<
+              internal_statusor::IsDirectInitializationValid<T, U&&>,
+              absl::disjunction<
+                  std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>,
+                               T>,
+                  absl::conjunction<
+                      absl::negation<std::is_constructible<absl::Status, U&&>>,
+                      absl::negation<
+                          internal_statusor::HasConversionOperatorToStatusOr<
+                              T, U&&>>>>,
+              std::is_constructible<T, U&&>,
+              absl::negation<std::is_convertible<U&&, T>>>::value,
+          int> = 0>
+  explicit StatusOr(U&& u)  // NOLINT
+      : StatusOr(absl::in_place, std::forward<U>(u)) {}
+
+  // StatusOr<T>::ok()
+  //
+  // Returns whether or not this `absl::StatusOr<T>` holds a `T` value. This
+  // member function is analogous to `absl::Status::ok()` and should be used
+  // similarly to check the status of return values.
+  //
+  // Example:
+  //
+  // StatusOr<Foo> result = DoBigCalculationThatCouldFail();
+  // if (result.ok()) {
+  //    // Handle result
+  // else {
+  //    // Handle error
+  // }
+  ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); }
+
+  // StatusOr<T>::status()
+  //
+  // Returns a reference to the current `absl::Status` contained within the
+  // `absl::StatusOr<T>`. If `absl::StatusOr<T>` contains a `T`, then this
+  // function returns `absl::OkStatus()`.
+  const Status& status() const&;
+  Status status() &&;
+
+  // StatusOr<T>::value()
+  //
+  // Returns a reference to the held value if `this->ok()`. Otherwise, throws
+  // `absl::BadStatusOrAccess` if exceptions are enabled, or is guaranteed to
+  // terminate the process if exceptions are disabled.
+  //
+  // If you have already checked the status using `this->ok()`, you probably
+  // want to use `operator*()` or `operator->()` to access the value instead of
+  // `value`.
+  //
+  // Note: for value types that are cheap to copy, prefer simple code:
+  //
+  //   T value = statusor.value();
+  //
+  // Otherwise, if the value type is expensive to copy, but can be left
+  // in the StatusOr, simply assign to a reference:
+  //
+  //   T& value = statusor.value();  // or `const T&`
+  //
+  // Otherwise, if the value type supports an efficient move, it can be
+  // used as follows:
+  //
+  //   T value = std::move(statusor).value();
+  //
+  // The `std::move` on statusor instead of on the whole expression enables
+  // warnings about possible uses of the statusor object after the move.
+  const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  const T&& value() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  // StatusOr<T>:: operator*()
+  //
+  // Returns a reference to the current value.
+  //
+  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
+  //
+  // Use `this->ok()` to verify that there is a current value within the
+  // `absl::StatusOr<T>`. Alternatively, see the `value()` member function for a
+  // similar API that guarantees crashing or throwing an exception if there is
+  // no current value.
+  const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  // StatusOr<T>::operator->()
+  //
+  // Returns a pointer to the current value.
+  //
+  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
+  //
+  // Use `this->ok()` to verify that there is a current value.
+  const T* operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T* operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+  // StatusOr<T>::value_or()
+  //
+  // Returns the current value if `this->ok() == true`. Otherwise constructs a
+  // value using the provided `default_value`.
+  //
+  // Unlike `value`, this function returns by value, copying the current value
+  // if necessary. If the value type supports an efficient move, it can be used
+  // as follows:
+  //
+  //   T value = std::move(statusor).value_or(def);
+  //
+  // Unlike with `value`, calling `std::move()` on the result of `value_or` will
+  // still trigger a copy.
+  template <typename U>
+  T value_or(U&& default_value) const&;
+  template <typename U>
+  T value_or(U&& default_value) &&;
+
+  // StatusOr<T>::IgnoreError()
+  //
+  // Ignores any errors. This method does nothing except potentially suppress
+  // complaints from any tools that are checking that errors are not dropped on
+  // the floor.
+  void IgnoreError() const;
+
+  // StatusOr<T>::emplace()
+  //
+  // Reconstructs the inner value T in-place using the provided args, using the
+  // T(args...) constructor. Returns reference to the reconstructed `T`.
+  template <typename... Args>
+  T& emplace(Args&&... args) {
+    if (ok()) {
+      this->Clear();
+      this->MakeValue(std::forward<Args>(args)...);
+    } else {
+      this->MakeValue(std::forward<Args>(args)...);
+      this->status_ = absl::OkStatus();
+    }
+    return this->data_;
+  }
+
+  template <
+      typename U, typename... Args,
+      absl::enable_if_t<
+          std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
+          int> = 0>
+  T& emplace(std::initializer_list<U> ilist, Args&&... args) {
+    if (ok()) {
+      this->Clear();
+      this->MakeValue(ilist, std::forward<Args>(args)...);
+    } else {
+      this->MakeValue(ilist, std::forward<Args>(args)...);
+      this->status_ = absl::OkStatus();
+    }
+    return this->data_;
+  }
+
+ private:
+  using internal_statusor::StatusOrData<T>::Assign;
+  template <typename U>
+  void Assign(const absl::StatusOr<U>& other);
+  template <typename U>
+  void Assign(absl::StatusOr<U>&& other);
+};
+
+// operator==()
+//
+// This operator checks the equality of two `absl::StatusOr<T>` objects.
+template <typename T>
+bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
+  if (lhs.ok() && rhs.ok()) return *lhs == *rhs;
+  return lhs.status() == rhs.status();
+}
+
+// operator!=()
+//
+// This operator checks the inequality of two `absl::StatusOr<T>` objects.
+template <typename T>
+bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
+  return !(lhs == rhs);
+}
+
+//------------------------------------------------------------------------------
+// Implementation details for StatusOr<T>
+//------------------------------------------------------------------------------
+
+// TODO(sbenza): avoid the string here completely.
+template <typename T>
+StatusOr<T>::StatusOr() : Base(Status(absl::StatusCode::kUnknown, "")) {}
+
+template <typename T>
+template <typename U>
+inline void StatusOr<T>::Assign(const StatusOr<U>& other) {
+  if (other.ok()) {
+    this->Assign(*other);
+  } else {
+    this->AssignStatus(other.status());
+  }
+}
+
+template <typename T>
+template <typename U>
+inline void StatusOr<T>::Assign(StatusOr<U>&& other) {
+  if (other.ok()) {
+    this->Assign(*std::move(other));
+  } else {
+    this->AssignStatus(std::move(other).status());
+  }
+}
+template <typename T>
+template <typename... Args>
+StatusOr<T>::StatusOr(absl::in_place_t, Args&&... args)
+    : Base(absl::in_place, std::forward<Args>(args)...) {}
+
+template <typename T>
+template <typename U, typename... Args>
+StatusOr<T>::StatusOr(absl::in_place_t, std::initializer_list<U> ilist,
+                      Args&&... args)
+    : Base(absl::in_place, ilist, std::forward<Args>(args)...) {}
+
+template <typename T>
+const Status& StatusOr<T>::status() const& {
+  return this->status_;
+}
+template <typename T>
+Status StatusOr<T>::status() && {
+  return ok() ? OkStatus() : std::move(this->status_);
+}
+
+template <typename T>
+const T& StatusOr<T>::value() const& {
+  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
+  return this->data_;
+}
+
+template <typename T>
+T& StatusOr<T>::value() & {
+  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
+  return this->data_;
+}
+
+template <typename T>
+const T&& StatusOr<T>::value() const&& {
+  if (!this->ok()) {
+    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
+  }
+  return std::move(this->data_);
+}
+
+template <typename T>
+T&& StatusOr<T>::value() && {
+  if (!this->ok()) {
+    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
+  }
+  return std::move(this->data_);
+}
+
+template <typename T>
+const T& StatusOr<T>::operator*() const& {
+  this->EnsureOk();
+  return this->data_;
+}
+
+template <typename T>
+T& StatusOr<T>::operator*() & {
+  this->EnsureOk();
+  return this->data_;
+}
+
+template <typename T>
+const T&& StatusOr<T>::operator*() const&& {
+  this->EnsureOk();
+  return std::move(this->data_);
+}
+
+template <typename T>
+T&& StatusOr<T>::operator*() && {
+  this->EnsureOk();
+  return std::move(this->data_);
+}
+
+template <typename T>
+const T* StatusOr<T>::operator->() const {
+  this->EnsureOk();
+  return &this->data_;
+}
+
+template <typename T>
+T* StatusOr<T>::operator->() {
+  this->EnsureOk();
+  return &this->data_;
+}
+
+template <typename T>
+template <typename U>
+T StatusOr<T>::value_or(U&& default_value) const& {
+  if (ok()) {
+    return this->data_;
+  }
+  return std::forward<U>(default_value);
+}
+
+template <typename T>
+template <typename U>
+T StatusOr<T>::value_or(U&& default_value) && {
+  if (ok()) {
+    return std::move(this->data_);
+  }
+  return std::forward<U>(default_value);
+}
+
+template <typename T>
+void StatusOr<T>::IgnoreError() const {
+  // no-op
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STATUS_STATUSOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/ascii.h b/CAPI/cpp/grpc/include/absl/strings/ascii.h
new file mode 100644
index 0000000..42eadae
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/ascii.h
@@ -0,0 +1,242 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: ascii.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions operating on characters and strings
+// restricted to standard ASCII. These include character classification
+// functions analogous to those found in the ANSI C Standard Library <ctype.h>
+// header file.
+//
+// C++ implementations provide <ctype.h> functionality based on their
+// C environment locale. In general, reliance on such a locale is not ideal, as
+// the locale standard is problematic (and may not return invariant information
+// for the same character set, for example). These `ascii_*()` functions are
+// hard-wired for standard ASCII, much faster, and guaranteed to behave
+// consistently.  They will never be overloaded, nor will their function
+// signature change.
+//
+// `ascii_isalnum()`, `ascii_isalpha()`, `ascii_isascii()`, `ascii_isblank()`,
+// `ascii_iscntrl()`, `ascii_isdigit()`, `ascii_isgraph()`, `ascii_islower()`,
+// `ascii_isprint()`, `ascii_ispunct()`, `ascii_isspace()`, `ascii_isupper()`,
+// `ascii_isxdigit()`
+//   Analogous to the <ctype.h> functions with similar names, these
+//   functions take an unsigned char and return a bool, based on whether the
+//   character matches the condition specified.
+//
+//   If the input character has a numerical value greater than 127, these
+//   functions return `false`.
+//
+// `ascii_tolower()`, `ascii_toupper()`
+//   Analogous to the <ctype.h> functions with similar names, these functions
+//   take an unsigned char and return a char.
+//
+//   If the input character is not an ASCII {lower,upper}-case letter (including
+//   numerical values greater than 127) then the functions return the same value
+//   as the input character.
+
+#ifndef ABSL_STRINGS_ASCII_H_
+#define ABSL_STRINGS_ASCII_H_
+
+#include <algorithm>
+#include <string>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace ascii_internal {
+
+// Declaration for an array of bitfields holding character information.
+ABSL_DLL extern const unsigned char kPropertyBits[256];
+
+// Declaration for the array of characters to upper-case characters.
+ABSL_DLL extern const char kToUpper[256];
+
+// Declaration for the array of characters to lower-case characters.
+ABSL_DLL extern const char kToLower[256];
+
+}  // namespace ascii_internal
+
+// ascii_isalpha()
+//
+// Determines whether the given character is an alphabetic character.
+inline bool ascii_isalpha(unsigned char c) {
+  return (ascii_internal::kPropertyBits[c] & 0x01) != 0;
+}
+
+// ascii_isalnum()
+//
+// Determines whether the given character is an alphanumeric character.
+inline bool ascii_isalnum(unsigned char c) {
+  return (ascii_internal::kPropertyBits[c] & 0x04) != 0;
+}
+
+// ascii_isspace()
+//
+// Determines whether the given character is a whitespace character (space,
+// tab, vertical tab, formfeed, linefeed, or carriage return).
+inline bool ascii_isspace(unsigned char c) {
+  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
+}
+
+// ascii_ispunct()
+//
+// Determines whether the given character is a punctuation character.
+inline bool ascii_ispunct(unsigned char c) {
+  return (ascii_internal::kPropertyBits[c] & 0x10) != 0;
+}
+
+// ascii_isblank()
+//
+// Determines whether the given character is a blank character (tab or space).
+inline bool ascii_isblank(unsigned char c) {
+  return (ascii_internal::kPropertyBits[c] & 0x20) != 0;
+}
+
+// ascii_iscntrl()
+//
+// Determines whether the given character is a control character.
+inline bool ascii_iscntrl(unsigned char c) {
+  return (ascii_internal::kPropertyBits[c] & 0x40) != 0;
+}
+
+// ascii_isxdigit()
+//
+// Determines whether the given character can be represented as a hexadecimal
+// digit character (i.e. {0-9} or {A-F}).
+inline bool ascii_isxdigit(unsigned char c) {
+  return (ascii_internal::kPropertyBits[c] & 0x80) != 0;
+}
+
+// ascii_isdigit()
+//
+// Determines whether the given character can be represented as a decimal
+// digit character (i.e. {0-9}).
+inline bool ascii_isdigit(unsigned char c) { return c >= '0' && c <= '9'; }
+
+// ascii_isprint()
+//
+// Determines whether the given character is printable, including spaces.
+inline bool ascii_isprint(unsigned char c) { return c >= 32 && c < 127; }
+
+// ascii_isgraph()
+//
+// Determines whether the given character has a graphical representation.
+inline bool ascii_isgraph(unsigned char c) { return c > 32 && c < 127; }
+
+// ascii_isupper()
+//
+// Determines whether the given character is uppercase.
+inline bool ascii_isupper(unsigned char c) { return c >= 'A' && c <= 'Z'; }
+
+// ascii_islower()
+//
+// Determines whether the given character is lowercase.
+inline bool ascii_islower(unsigned char c) { return c >= 'a' && c <= 'z'; }
+
+// ascii_isascii()
+//
+// Determines whether the given character is ASCII.
+inline bool ascii_isascii(unsigned char c) { return c < 128; }
+
+// ascii_tolower()
+//
+// Returns an ASCII character, converting to lowercase if uppercase is
+// passed. Note that character values > 127 are simply returned.
+inline char ascii_tolower(unsigned char c) {
+  return ascii_internal::kToLower[c];
+}
+
+// Converts the characters in `s` to lowercase, changing the contents of `s`.
+void AsciiStrToLower(std::string* s);
+
+// Creates a lowercase string from a given absl::string_view.
+ABSL_MUST_USE_RESULT inline std::string AsciiStrToLower(absl::string_view s) {
+  std::string result(s);
+  absl::AsciiStrToLower(&result);
+  return result;
+}
+
+// ascii_toupper()
+//
+// Returns the ASCII character, converting to upper-case if lower-case is
+// passed. Note that characters values > 127 are simply returned.
+inline char ascii_toupper(unsigned char c) {
+  return ascii_internal::kToUpper[c];
+}
+
+// Converts the characters in `s` to uppercase, changing the contents of `s`.
+void AsciiStrToUpper(std::string* s);
+
+// Creates an uppercase string from a given absl::string_view.
+ABSL_MUST_USE_RESULT inline std::string AsciiStrToUpper(absl::string_view s) {
+  std::string result(s);
+  absl::AsciiStrToUpper(&result);
+  return result;
+}
+
+// Returns absl::string_view with whitespace stripped from the beginning of the
+// given string_view.
+ABSL_MUST_USE_RESULT inline absl::string_view StripLeadingAsciiWhitespace(
+    absl::string_view str) {
+  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
+  return str.substr(static_cast<size_t>(it - str.begin()));
+}
+
+// Strips in place whitespace from the beginning of the given string.
+inline void StripLeadingAsciiWhitespace(std::string* str) {
+  auto it = std::find_if_not(str->begin(), str->end(), absl::ascii_isspace);
+  str->erase(str->begin(), it);
+}
+
+// Returns absl::string_view with whitespace stripped from the end of the given
+// string_view.
+ABSL_MUST_USE_RESULT inline absl::string_view StripTrailingAsciiWhitespace(
+    absl::string_view str) {
+  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
+  return str.substr(0, static_cast<size_t>(str.rend() - it));
+}
+
+// Strips in place whitespace from the end of the given string
+inline void StripTrailingAsciiWhitespace(std::string* str) {
+  auto it = std::find_if_not(str->rbegin(), str->rend(), absl::ascii_isspace);
+  str->erase(static_cast<size_t>(str->rend() - it));
+}
+
+// Returns absl::string_view with whitespace stripped from both ends of the
+// given string_view.
+ABSL_MUST_USE_RESULT inline absl::string_view StripAsciiWhitespace(
+    absl::string_view str) {
+  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
+}
+
+// Strips in place whitespace from both ends of the given string
+inline void StripAsciiWhitespace(std::string* str) {
+  StripTrailingAsciiWhitespace(str);
+  StripLeadingAsciiWhitespace(str);
+}
+
+// Removes leading, trailing, and consecutive internal whitespace.
+void RemoveExtraAsciiWhitespace(std::string*);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_ASCII_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/charconv.h b/CAPI/cpp/grpc/include/absl/strings/charconv.h
new file mode 100644
index 0000000..7c50981
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/charconv.h
@@ -0,0 +1,120 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_CHARCONV_H_
+#define ABSL_STRINGS_CHARCONV_H_
+
+#include <system_error>  // NOLINT(build/c++11)
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Workalike compatibilty version of std::chars_format from C++17.
+//
+// This is an bitfield enumerator which can be passed to absl::from_chars to
+// configure the string-to-float conversion.
+enum class chars_format {
+  scientific = 1,
+  fixed = 2,
+  hex = 4,
+  general = fixed | scientific,
+};
+
+// The return result of a string-to-number conversion.
+//
+// `ec` will be set to `invalid_argument` if a well-formed number was not found
+// at the start of the input range, `result_out_of_range` if a well-formed
+// number was found, but it was out of the representable range of the requested
+// type, or to std::errc() otherwise.
+//
+// If a well-formed number was found, `ptr` is set to one past the sequence of
+// characters that were successfully parsed.  If none was found, `ptr` is set
+// to the `first` argument to from_chars.
+struct from_chars_result {
+  const char* ptr;
+  std::errc ec;
+};
+
+// Workalike compatibilty version of std::from_chars from C++17.  Currently
+// this only supports the `double` and `float` types.
+//
+// This interface incorporates the proposed resolutions for library issues
+// DR 3080 and DR 3081.  If these are adopted with different wording,
+// Abseil's behavior will change to match the standard.  (The behavior most
+// likely to change is for DR 3081, which says what `value` will be set to in
+// the case of overflow and underflow.  Code that wants to avoid possible
+// breaking changes in this area should not depend on `value` when the returned
+// from_chars_result indicates a range error.)
+//
+// Searches the range [first, last) for the longest matching pattern beginning
+// at `first` that represents a floating point number.  If one is found, store
+// the result in `value`.
+//
+// The matching pattern format is almost the same as that of strtod(), except
+// that (1) C locale is not respected, (2) an initial '+' character in the
+// input range will never be matched, and (3) leading whitespaces are not
+// ignored.
+//
+// If `fmt` is set, it must be one of the enumerator values of the chars_format.
+// (This is despite the fact that chars_format is a bitmask type.)  If set to
+// `scientific`, a matching number must contain an exponent.  If set to `fixed`,
+// then an exponent will never match.  (For example, the string "1e5" will be
+// parsed as "1".)  If set to `hex`, then a hexadecimal float is parsed in the
+// format that strtod() accepts, except that a "0x" prefix is NOT matched.
+// (In particular, in `hex` mode, the input "0xff" results in the largest
+// matching pattern "0".)
+absl::from_chars_result from_chars(const char* first, const char* last,
+                                   double& value,  // NOLINT
+                                   chars_format fmt = chars_format::general);
+
+absl::from_chars_result from_chars(const char* first, const char* last,
+                                   float& value,  // NOLINT
+                                   chars_format fmt = chars_format::general);
+
+// std::chars_format is specified as a bitmask type, which means the following
+// operations must be provided:
+inline constexpr chars_format operator&(chars_format lhs, chars_format rhs) {
+  return static_cast<chars_format>(static_cast<int>(lhs) &
+                                   static_cast<int>(rhs));
+}
+inline constexpr chars_format operator|(chars_format lhs, chars_format rhs) {
+  return static_cast<chars_format>(static_cast<int>(lhs) |
+                                   static_cast<int>(rhs));
+}
+inline constexpr chars_format operator^(chars_format lhs, chars_format rhs) {
+  return static_cast<chars_format>(static_cast<int>(lhs) ^
+                                   static_cast<int>(rhs));
+}
+inline constexpr chars_format operator~(chars_format arg) {
+  return static_cast<chars_format>(~static_cast<int>(arg));
+}
+inline chars_format& operator&=(chars_format& lhs, chars_format rhs) {
+  lhs = lhs & rhs;
+  return lhs;
+}
+inline chars_format& operator|=(chars_format& lhs, chars_format rhs) {
+  lhs = lhs | rhs;
+  return lhs;
+}
+inline chars_format& operator^=(chars_format& lhs, chars_format rhs) {
+  lhs = lhs ^ rhs;
+  return lhs;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CHARCONV_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cord.h b/CAPI/cpp/grpc/include/absl/strings/cord.h
new file mode 100644
index 0000000..18d6ab8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/cord.h
@@ -0,0 +1,1642 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: cord.h
+// -----------------------------------------------------------------------------
+//
+// This file defines the `absl::Cord` data structure and operations on that data
+// structure. A Cord is a string-like sequence of characters optimized for
+// specific use cases. Unlike a `std::string`, which stores an array of
+// contiguous characters, Cord data is stored in a structure consisting of
+// separate, reference-counted "chunks." (Currently, this implementation is a
+// tree structure, though that implementation may change.)
+//
+// Because a Cord consists of these chunks, data can be added to or removed from
+// a Cord during its lifetime. Chunks may also be shared between Cords. Unlike a
+// `std::string`, a Cord can therefore accommodate data that changes over its
+// lifetime, though it's not quite "mutable"; it can change only in the
+// attachment, detachment, or rearrangement of chunks of its constituent data.
+//
+// A Cord provides some benefit over `std::string` under the following (albeit
+// narrow) circumstances:
+//
+//   * Cord data is designed to grow and shrink over a Cord's lifetime. Cord
+//     provides efficient insertions and deletions at the start and end of the
+//     character sequences, avoiding copies in those cases. Static data should
+//     generally be stored as strings.
+//   * External memory consisting of string-like data can be directly added to
+//     a Cord without requiring copies or allocations.
+//   * Cord data may be shared and copied cheaply. Cord provides a copy-on-write
+//     implementation and cheap sub-Cord operations. Copying a Cord is an O(1)
+//     operation.
+//
+// As a consequence to the above, Cord data is generally large. Small data
+// should generally use strings, as construction of a Cord requires some
+// overhead. Small Cords (<= 15 bytes) are represented inline, but most small
+// Cords are expected to grow over their lifetimes.
+//
+// Note that because a Cord is made up of separate chunked data, random access
+// to character data within a Cord is slower than within a `std::string`.
+//
+// Thread Safety
+//
+// Cord has the same thread-safety properties as many other types like
+// std::string, std::vector<>, int, etc -- it is thread-compatible. In
+// particular, if threads do not call non-const methods, then it is safe to call
+// const methods without synchronization. Copying a Cord produces a new instance
+// that can be used concurrently with the original in arbitrary ways.
+
+#ifndef ABSL_STRINGS_CORD_H_
+#define ABSL_STRINGS_CORD_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <iterator>
+#include <string>
+#include <type_traits>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/endian.h"
+#include "absl/base/internal/per_thread_tls.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/functional/function_ref.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/cord_analysis.h"
+#include "absl/strings/cord_buffer.h"
+#include "absl/strings/internal/cord_data_edge.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_btree.h"
+#include "absl/strings/internal/cord_rep_btree_reader.h"
+#include "absl/strings/internal/cord_rep_crc.h"
+#include "absl/strings/internal/cord_rep_ring.h"
+#include "absl/strings/internal/cordz_functions.h"
+#include "absl/strings/internal/cordz_info.h"
+#include "absl/strings/internal/cordz_statistics.h"
+#include "absl/strings/internal/cordz_update_scope.h"
+#include "absl/strings/internal/cordz_update_tracker.h"
+#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/internal/string_constant.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+class Cord;
+class CordTestPeer;
+template <typename Releaser>
+Cord MakeCordFromExternal(absl::string_view, Releaser&&);
+void CopyCordToString(const Cord& src, std::string* dst);
+
+// Cord memory accounting modes
+enum class CordMemoryAccounting {
+  // Counts the *approximate* number of bytes held in full or in part by this
+  // Cord (which may not remain the same between invocations). Cords that share
+  // memory could each be "charged" independently for the same shared memory.
+  kTotal,
+
+  // Counts the *approximate* number of bytes held in full or in part by this
+  // Cord weighted by the sharing ratio of that data. For example, if some data
+  // edge is shared by 4 different Cords, then each cord is attributed 1/4th of
+  // the total memory usage as a 'fair share' of the total memory usage.
+  kFairShare,
+};
+
+// Cord
+//
+// A Cord is a sequence of characters, designed to be more efficient than a
+// `std::string` in certain circumstances: namely, large string data that needs
+// to change over its lifetime or shared, especially when such data is shared
+// across API boundaries.
+//
+// A Cord stores its character data in a structure that allows efficient prepend
+// and append operations. This makes a Cord useful for large string data sent
+// over in a wire format that may need to be prepended or appended at some point
+// during the data exchange (e.g. HTTP, protocol buffers). For example, a
+// Cord is useful for storing an HTTP request, and prepending an HTTP header to
+// such a request.
+//
+// Cords should not be used for storing general string data, however. They
+// require overhead to construct and are slower than strings for random access.
+//
+// The Cord API provides the following common API operations:
+//
+// * Create or assign Cords out of existing string data, memory, or other Cords
+// * Append and prepend data to an existing Cord
+// * Create new Sub-Cords from existing Cord data
+// * Swap Cord data and compare Cord equality
+// * Write out Cord data by constructing a `std::string`
+//
+// Additionally, the API provides iterator utilities to iterate through Cord
+// data via chunks or character bytes.
+//
+class Cord {
+ private:
+  template <typename T>
+  using EnableIfString =
+      absl::enable_if_t<std::is_same<T, std::string>::value, int>;
+
+ public:
+  // Cord::Cord() Constructors.
+
+  // Creates an empty Cord.
+  constexpr Cord() noexcept;
+
+  // Creates a Cord from an existing Cord. Cord is copyable and efficiently
+  // movable. The moved-from state is valid but unspecified.
+  Cord(const Cord& src);
+  Cord(Cord&& src) noexcept;
+  Cord& operator=(const Cord& x);
+  Cord& operator=(Cord&& x) noexcept;
+
+  // Creates a Cord from a `src` string. This constructor is marked explicit to
+  // prevent implicit Cord constructions from arguments convertible to an
+  // `absl::string_view`.
+  explicit Cord(absl::string_view src);
+  Cord& operator=(absl::string_view src);
+
+  // Creates a Cord from a `std::string&&` rvalue. These constructors are
+  // templated to avoid ambiguities for types that are convertible to both
+  // `absl::string_view` and `std::string`, such as `const char*`.
+  template <typename T, EnableIfString<T> = 0>
+  explicit Cord(T&& src);
+  template <typename T, EnableIfString<T> = 0>
+  Cord& operator=(T&& src);
+
+  // Cord::~Cord()
+  //
+  // Destructs the Cord.
+  ~Cord() {
+    if (contents_.is_tree()) DestroyCordSlow();
+  }
+
+  // MakeCordFromExternal()
+  //
+  // Creates a Cord that takes ownership of external string memory. The
+  // contents of `data` are not copied to the Cord; instead, the external
+  // memory is added to the Cord and reference-counted. This data may not be
+  // changed for the life of the Cord, though it may be prepended or appended
+  // to.
+  //
+  // `MakeCordFromExternal()` takes a callable "releaser" that is invoked when
+  // the reference count for `data` reaches zero. As noted above, this data must
+  // remain live until the releaser is invoked. The callable releaser also must:
+  //
+  //   * be move constructible
+  //   * support `void operator()(absl::string_view) const` or `void operator()`
+  //
+  // Example:
+  //
+  // Cord MakeCord(BlockPool* pool) {
+  //   Block* block = pool->NewBlock();
+  //   FillBlock(block);
+  //   return absl::MakeCordFromExternal(
+  //       block->ToStringView(),
+  //       [pool, block](absl::string_view v) {
+  //         pool->FreeBlock(block, v);
+  //       });
+  // }
+  //
+  // WARNING: Because a Cord can be reference-counted, it's likely a bug if your
+  // releaser doesn't do anything. For example, consider the following:
+  //
+  // void Foo(const char* buffer, int len) {
+  //   auto c = absl::MakeCordFromExternal(absl::string_view(buffer, len),
+  //                                       [](absl::string_view) {});
+  //
+  //   // BUG: If Bar() copies its cord for any reason, including keeping a
+  //   // substring of it, the lifetime of buffer might be extended beyond
+  //   // when Foo() returns.
+  //   Bar(c);
+  // }
+  template <typename Releaser>
+  friend Cord MakeCordFromExternal(absl::string_view data, Releaser&& releaser);
+
+  // Cord::Clear()
+  //
+  // Releases the Cord data. Any nodes that share data with other Cords, if
+  // applicable, will have their reference counts reduced by 1.
+  ABSL_ATTRIBUTE_REINITIALIZES void Clear();
+
+  // Cord::Append()
+  //
+  // Appends data to the Cord, which may come from another Cord or other string
+  // data.
+  void Append(const Cord& src);
+  void Append(Cord&& src);
+  void Append(absl::string_view src);
+  template <typename T, EnableIfString<T> = 0>
+  void Append(T&& src);
+
+  // Appends `buffer` to this cord, unless `buffer` has a zero length in which
+  // case this method has no effect on this cord instance.
+  // This method is guaranteed to consume `buffer`.
+  void Append(CordBuffer buffer);
+
+  // Returns a CordBuffer, re-using potential existing capacity in this cord.
+  //
+  // Cord instances may have additional unused capacity in the last (or first)
+  // nodes of the underlying tree to facilitate amortized growth. This method
+  // allows applications to explicitly use this spare capacity if available,
+  // or create a new CordBuffer instance otherwise.
+  // If this cord has a final non-shared node with at least `min_capacity`
+  // available, then this method will return that buffer including its data
+  // contents. I.e.; the returned buffer will have a non-zero length, and
+  // a capacity of at least `buffer.length + min_capacity`. Otherwise, this
+  // method will return `CordBuffer::CreateWithDefaultLimit(capacity)`.
+  //
+  // Below an example of using GetAppendBuffer. Notice that in this example we
+  // use `GetAppendBuffer()` only on the first iteration. As we know nothing
+  // about any initial extra capacity in `cord`, we may be able to use the extra
+  // capacity. But as we add new buffers with fully utilized contents after that
+  // we avoid calling `GetAppendBuffer()` on subsequent iterations: while this
+  // works fine, it results in an unnecessary inspection of cord contents:
+  //
+  //   void AppendRandomDataToCord(absl::Cord &cord, size_t n) {
+  //     bool first = true;
+  //     while (n > 0) {
+  //       CordBuffer buffer = first ? cord.GetAppendBuffer(n)
+  //                                 : CordBuffer::CreateWithDefaultLimit(n);
+  //       absl::Span<char> data = buffer.available_up_to(n);
+  //       FillRandomValues(data.data(), data.size());
+  //       buffer.IncreaseLengthBy(data.size());
+  //       cord.Append(std::move(buffer));
+  //       n -= data.size();
+  //       first = false;
+  //     }
+  //   }
+  CordBuffer GetAppendBuffer(size_t capacity, size_t min_capacity = 16);
+
+  // Cord::Prepend()
+  //
+  // Prepends data to the Cord, which may come from another Cord or other string
+  // data.
+  void Prepend(const Cord& src);
+  void Prepend(absl::string_view src);
+  template <typename T, EnableIfString<T> = 0>
+  void Prepend(T&& src);
+
+  // Prepends `buffer` to this cord, unless `buffer` has a zero length in which
+  // case this method has no effect on this cord instance.
+  // This method is guaranteed to consume `buffer`.
+  void Prepend(CordBuffer buffer);
+
+  // Cord::RemovePrefix()
+  //
+  // Removes the first `n` bytes of a Cord.
+  void RemovePrefix(size_t n);
+  void RemoveSuffix(size_t n);
+
+  // Cord::Subcord()
+  //
+  // Returns a new Cord representing the subrange [pos, pos + new_size) of
+  // *this. If pos >= size(), the result is empty(). If
+  // (pos + new_size) >= size(), the result is the subrange [pos, size()).
+  Cord Subcord(size_t pos, size_t new_size) const;
+
+  // Cord::swap()
+  //
+  // Swaps the contents of the Cord with `other`.
+  void swap(Cord& other) noexcept;
+
+  // swap()
+  //
+  // Swaps the contents of two Cords.
+  friend void swap(Cord& x, Cord& y) noexcept { x.swap(y); }
+
+  // Cord::size()
+  //
+  // Returns the size of the Cord.
+  size_t size() const;
+
+  // Cord::empty()
+  //
+  // Determines whether the given Cord is empty, returning `true` is so.
+  bool empty() const;
+
+  // Cord::EstimatedMemoryUsage()
+  //
+  // Returns the *approximate* number of bytes held by this cord.
+  // See CordMemoryAccounting for more information on the accounting method.
+  size_t EstimatedMemoryUsage(CordMemoryAccounting accounting_method =
+                                  CordMemoryAccounting::kTotal) const;
+
+  // Cord::Compare()
+  //
+  // Compares 'this' Cord with rhs. This function and its relatives treat Cords
+  // as sequences of unsigned bytes. The comparison is a straightforward
+  // lexicographic comparison. `Cord::Compare()` returns values as follows:
+  //
+  //   -1  'this' Cord is smaller
+  //    0  two Cords are equal
+  //    1  'this' Cord is larger
+  int Compare(absl::string_view rhs) const;
+  int Compare(const Cord& rhs) const;
+
+  // Cord::StartsWith()
+  //
+  // Determines whether the Cord starts with the passed string data `rhs`.
+  bool StartsWith(const Cord& rhs) const;
+  bool StartsWith(absl::string_view rhs) const;
+
+  // Cord::EndsWith()
+  //
+  // Determines whether the Cord ends with the passed string data `rhs`.
+  bool EndsWith(absl::string_view rhs) const;
+  bool EndsWith(const Cord& rhs) const;
+
+  // Cord::operator std::string()
+  //
+  // Converts a Cord into a `std::string()`. This operator is marked explicit to
+  // prevent unintended Cord usage in functions that take a string.
+  explicit operator std::string() const;
+
+  // CopyCordToString()
+  //
+  // Copies the contents of a `src` Cord into a `*dst` string.
+  //
+  // This function optimizes the case of reusing the destination string since it
+  // can reuse previously allocated capacity. However, this function does not
+  // guarantee that pointers previously returned by `dst->data()` remain valid
+  // even if `*dst` had enough capacity to hold `src`. If `*dst` is a new
+  // object, prefer to simply use the conversion operator to `std::string`.
+  friend void CopyCordToString(const Cord& src, std::string* dst);
+
+  class CharIterator;
+
+  //----------------------------------------------------------------------------
+  // Cord::ChunkIterator
+  //----------------------------------------------------------------------------
+  //
+  // A `Cord::ChunkIterator` allows iteration over the constituent chunks of its
+  // Cord. Such iteration allows you to perform non-const operations on the data
+  // of a Cord without modifying it.
+  //
+  // Generally, you do not instantiate a `Cord::ChunkIterator` directly;
+  // instead, you create one implicitly through use of the `Cord::Chunks()`
+  // member function.
+  //
+  // The `Cord::ChunkIterator` has the following properties:
+  //
+  //   * The iterator is invalidated after any non-const operation on the
+  //     Cord object over which it iterates.
+  //   * The `string_view` returned by dereferencing a valid, non-`end()`
+  //     iterator is guaranteed to be non-empty.
+  //   * Two `ChunkIterator` objects can be compared equal if and only if they
+  //     remain valid and iterate over the same Cord.
+  //   * The iterator in this case is a proxy iterator; the `string_view`
+  //     returned by the iterator does not live inside the Cord, and its
+  //     lifetime is limited to the lifetime of the iterator itself. To help
+  //     prevent lifetime issues, `ChunkIterator::reference` is not a true
+  //     reference type and is equivalent to `value_type`.
+  //   * The iterator keeps state that can grow for Cords that contain many
+  //     nodes and are imbalanced due to sharing. Prefer to pass this type by
+  //     const reference instead of by value.
+  class ChunkIterator {
+   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = absl::string_view;
+    using difference_type = ptrdiff_t;
+    using pointer = const value_type*;
+    using reference = value_type;
+
+    ChunkIterator() = default;
+
+    ChunkIterator& operator++();
+    ChunkIterator operator++(int);
+    bool operator==(const ChunkIterator& other) const;
+    bool operator!=(const ChunkIterator& other) const;
+    reference operator*() const;
+    pointer operator->() const;
+
+    friend class Cord;
+    friend class CharIterator;
+
+   private:
+    using CordRep = absl::cord_internal::CordRep;
+    using CordRepBtree = absl::cord_internal::CordRepBtree;
+    using CordRepBtreeReader = absl::cord_internal::CordRepBtreeReader;
+
+    // Constructs a `begin()` iterator from `tree`. `tree` must not be null.
+    explicit ChunkIterator(cord_internal::CordRep* tree);
+
+    // Constructs a `begin()` iterator from `cord`.
+    explicit ChunkIterator(const Cord* cord);
+
+    // Initializes this instance from a tree. Invoked by constructors.
+    void InitTree(cord_internal::CordRep* tree);
+
+    // Removes `n` bytes from `current_chunk_`. Expects `n` to be smaller than
+    // `current_chunk_.size()`.
+    void RemoveChunkPrefix(size_t n);
+    Cord AdvanceAndReadBytes(size_t n);
+    void AdvanceBytes(size_t n);
+
+    // Btree specific operator++
+    ChunkIterator& AdvanceBtree();
+    void AdvanceBytesBtree(size_t n);
+
+    // A view into bytes of the current `CordRep`. It may only be a view to a
+    // suffix of bytes if this is being used by `CharIterator`.
+    absl::string_view current_chunk_;
+    // The current leaf, or `nullptr` if the iterator points to short data.
+    // If the current chunk is a substring node, current_leaf_ points to the
+    // underlying flat or external node.
+    absl::cord_internal::CordRep* current_leaf_ = nullptr;
+    // The number of bytes left in the `Cord` over which we are iterating.
+    size_t bytes_remaining_ = 0;
+
+    // Cord reader for cord btrees. Empty if not traversing a btree.
+    CordRepBtreeReader btree_reader_;
+  };
+
+  // Cord::chunk_begin()
+  //
+  // Returns an iterator to the first chunk of the `Cord`.
+  //
+  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
+  // iterating over the chunks of a Cord. This method may be useful for getting
+  // a `ChunkIterator` where range-based for-loops are not useful.
+  //
+  // Example:
+  //
+  //   absl::Cord::ChunkIterator FindAsChunk(const absl::Cord& c,
+  //                                         absl::string_view s) {
+  //     return std::find(c.chunk_begin(), c.chunk_end(), s);
+  //   }
+  ChunkIterator chunk_begin() const;
+
+  // Cord::chunk_end()
+  //
+  // Returns an iterator one increment past the last chunk of the `Cord`.
+  //
+  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
+  // iterating over the chunks of a Cord. This method may be useful for getting
+  // a `ChunkIterator` where range-based for-loops may not be available.
+  ChunkIterator chunk_end() const;
+
+  //----------------------------------------------------------------------------
+  // Cord::ChunkRange
+  //----------------------------------------------------------------------------
+  //
+  // `ChunkRange` is a helper class for iterating over the chunks of the `Cord`,
+  // producing an iterator which can be used within a range-based for loop.
+  // Construction of a `ChunkRange` will return an iterator pointing to the
+  // first chunk of the Cord. Generally, do not construct a `ChunkRange`
+  // directly; instead, prefer to use the `Cord::Chunks()` method.
+  //
+  // Implementation note: `ChunkRange` is simply a convenience wrapper over
+  // `Cord::chunk_begin()` and `Cord::chunk_end()`.
+  class ChunkRange {
+   public:
+    // Fulfill minimum c++ container requirements [container.requirements]
+    // These (partial) container type definitions allow ChunkRange to be used
+    // in various utilities expecting a subset of [container.requirements].
+    // For example, the below enables using `::testing::ElementsAre(...)`
+    using value_type = absl::string_view;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using iterator = ChunkIterator;
+    using const_iterator = ChunkIterator;
+
+    explicit ChunkRange(const Cord* cord) : cord_(cord) {}
+
+    ChunkIterator begin() const;
+    ChunkIterator end() const;
+
+   private:
+    const Cord* cord_;
+  };
+
+  // Cord::Chunks()
+  //
+  // Returns a `Cord::ChunkRange` for iterating over the chunks of a `Cord` with
+  // a range-based for-loop. For most iteration tasks on a Cord, use
+  // `Cord::Chunks()` to retrieve this iterator.
+  //
+  // Example:
+  //
+  //   void ProcessChunks(const Cord& cord) {
+  //     for (absl::string_view chunk : cord.Chunks()) { ... }
+  //   }
+  //
+  // Note that the ordinary caveats of temporary lifetime extension apply:
+  //
+  //   void Process() {
+  //     for (absl::string_view chunk : CordFactory().Chunks()) {
+  //       // The temporary Cord returned by CordFactory has been destroyed!
+  //     }
+  //   }
+  ChunkRange Chunks() const;
+
+  //----------------------------------------------------------------------------
+  // Cord::CharIterator
+  //----------------------------------------------------------------------------
+  //
+  // A `Cord::CharIterator` allows iteration over the constituent characters of
+  // a `Cord`.
+  //
+  // Generally, you do not instantiate a `Cord::CharIterator` directly; instead,
+  // you create one implicitly through use of the `Cord::Chars()` member
+  // function.
+  //
+  // A `Cord::CharIterator` has the following properties:
+  //
+  //   * The iterator is invalidated after any non-const operation on the
+  //     Cord object over which it iterates.
+  //   * Two `CharIterator` objects can be compared equal if and only if they
+  //     remain valid and iterate over the same Cord.
+  //   * The iterator keeps state that can grow for Cords that contain many
+  //     nodes and are imbalanced due to sharing. Prefer to pass this type by
+  //     const reference instead of by value.
+  //   * This type cannot act as a forward iterator because a `Cord` can reuse
+  //     sections of memory. This fact violates the requirement for forward
+  //     iterators to compare equal if dereferencing them returns the same
+  //     object.
+  class CharIterator {
+   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = char;
+    using difference_type = ptrdiff_t;
+    using pointer = const char*;
+    using reference = const char&;
+
+    CharIterator() = default;
+
+    CharIterator& operator++();
+    CharIterator operator++(int);
+    bool operator==(const CharIterator& other) const;
+    bool operator!=(const CharIterator& other) const;
+    reference operator*() const;
+    pointer operator->() const;
+
+    friend Cord;
+
+   private:
+    explicit CharIterator(const Cord* cord) : chunk_iterator_(cord) {}
+
+    ChunkIterator chunk_iterator_;
+  };
+
+  // Cord::AdvanceAndRead()
+  //
+  // Advances the `Cord::CharIterator` by `n_bytes` and returns the bytes
+  // advanced as a separate `Cord`. `n_bytes` must be less than or equal to the
+  // number of bytes within the Cord; otherwise, behavior is undefined. It is
+  // valid to pass `char_end()` and `0`.
+  static Cord AdvanceAndRead(CharIterator* it, size_t n_bytes);
+
+  // Cord::Advance()
+  //
+  // Advances the `Cord::CharIterator` by `n_bytes`. `n_bytes` must be less than
+  // or equal to the number of bytes remaining within the Cord; otherwise,
+  // behavior is undefined. It is valid to pass `char_end()` and `0`.
+  static void Advance(CharIterator* it, size_t n_bytes);
+
+  // Cord::ChunkRemaining()
+  //
+  // Returns the longest contiguous view starting at the iterator's position.
+  //
+  // `it` must be dereferenceable.
+  static absl::string_view ChunkRemaining(const CharIterator& it);
+
+  // Cord::char_begin()
+  //
+  // Returns an iterator to the first character of the `Cord`.
+  //
+  // Generally, prefer using `Cord::Chars()` within a range-based for loop for
+  // iterating over the chunks of a Cord. This method may be useful for getting
+  // a `CharIterator` where range-based for-loops may not be available.
+  CharIterator char_begin() const;
+
+  // Cord::char_end()
+  //
+  // Returns an iterator to one past the last character of the `Cord`.
+  //
+  // Generally, prefer using `Cord::Chars()` within a range-based for loop for
+  // iterating over the chunks of a Cord. This method may be useful for getting
+  // a `CharIterator` where range-based for-loops are not useful.
+  CharIterator char_end() const;
+
+  // Cord::CharRange
+  //
+  // `CharRange` is a helper class for iterating over the characters of a
+  // producing an iterator which can be used within a range-based for loop.
+  // Construction of a `CharRange` will return an iterator pointing to the first
+  // character of the Cord. Generally, do not construct a `CharRange` directly;
+  // instead, prefer to use the `Cord::Chars()` method shown below.
+  //
+  // Implementation note: `CharRange` is simply a convenience wrapper over
+  // `Cord::char_begin()` and `Cord::char_end()`.
+  class CharRange {
+   public:
+    // Fulfill minimum c++ container requirements [container.requirements]
+    // Theses (partial) container type definitions allow CharRange to be used
+    // in various utilities expecting a subset of [container.requirements].
+    // For example, the below enables using `::testing::ElementsAre(...)`
+    using value_type = char;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using iterator = CharIterator;
+    using const_iterator = CharIterator;
+
+    explicit CharRange(const Cord* cord) : cord_(cord) {}
+
+    CharIterator begin() const;
+    CharIterator end() const;
+
+   private:
+    const Cord* cord_;
+  };
+
+  // Cord::Chars()
+  //
+  // Returns a `Cord::CharRange` for iterating over the characters of a `Cord`
+  // with a range-based for-loop. For most character-based iteration tasks on a
+  // Cord, use `Cord::Chars()` to retrieve this iterator.
+  //
+  // Example:
+  //
+  //   void ProcessCord(const Cord& cord) {
+  //     for (char c : cord.Chars()) { ... }
+  //   }
+  //
+  // Note that the ordinary caveats of temporary lifetime extension apply:
+  //
+  //   void Process() {
+  //     for (char c : CordFactory().Chars()) {
+  //       // The temporary Cord returned by CordFactory has been destroyed!
+  //     }
+  //   }
+  CharRange Chars() const;
+
+  // Cord::operator[]
+  //
+  // Gets the "i"th character of the Cord and returns it, provided that
+  // 0 <= i < Cord.size().
+  //
+  // NOTE: This routine is reasonably efficient. It is roughly
+  // logarithmic based on the number of chunks that make up the cord. Still,
+  // if you need to iterate over the contents of a cord, you should
+  // use a CharIterator/ChunkIterator rather than call operator[] or Get()
+  // repeatedly in a loop.
+  char operator[](size_t i) const;
+
+  // Cord::TryFlat()
+  //
+  // If this cord's representation is a single flat array, returns a
+  // string_view referencing that array.  Otherwise returns nullopt.
+  absl::optional<absl::string_view> TryFlat() const;
+
+  // Cord::Flatten()
+  //
+  // Flattens the cord into a single array and returns a view of the data.
+  //
+  // If the cord was already flat, the contents are not modified.
+  absl::string_view Flatten();
+
+  // Supports absl::Cord as a sink object for absl::Format().
+  friend void AbslFormatFlush(absl::Cord* cord, absl::string_view part) {
+    cord->Append(part);
+  }
+
+  // Cord::SetExpectedChecksum()
+  //
+  // Stores a checksum value with this non-empty cord instance, for later
+  // retrieval.
+  //
+  // The expected checksum is a number stored out-of-band, alongside the data.
+  // It is preserved across copies and assignments, but any mutations to a cord
+  // will cause it to lose its expected checksum.
+  //
+  // The expected checksum is not part of a Cord's value, and does not affect
+  // operations such as equality or hashing.
+  //
+  // This field is intended to store a CRC32C checksum for later validation, to
+  // help support end-to-end checksum workflows.  However, the Cord API itself
+  // does no CRC validation, and assigns no meaning to this number.
+  //
+  // This call has no effect if this cord is empty.
+  void SetExpectedChecksum(uint32_t crc);
+
+  // Returns this cord's expected checksum, if it has one.  Otherwise, returns
+  // nullopt.
+  absl::optional<uint32_t> ExpectedChecksum() const;
+
+  template <typename H>
+  friend H AbslHashValue(H hash_state, const absl::Cord& c) {
+    absl::optional<absl::string_view> maybe_flat = c.TryFlat();
+    if (maybe_flat.has_value()) {
+      return H::combine(std::move(hash_state), *maybe_flat);
+    }
+    return c.HashFragmented(std::move(hash_state));
+  }
+
+  // Create a Cord with the contents of StringConstant<T>::value.
+  // No allocations will be done and no data will be copied.
+  // This is an INTERNAL API and subject to change or removal. This API can only
+  // be used by spelling absl::strings_internal::MakeStringConstant, which is
+  // also an internal API.
+  template <typename T>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  constexpr Cord(strings_internal::StringConstant<T>);
+
+ private:
+  using CordRep = absl::cord_internal::CordRep;
+  using CordRepFlat = absl::cord_internal::CordRepFlat;
+  using CordzInfo = cord_internal::CordzInfo;
+  using CordzUpdateScope = cord_internal::CordzUpdateScope;
+  using CordzUpdateTracker = cord_internal::CordzUpdateTracker;
+  using InlineData = cord_internal::InlineData;
+  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
+
+  // Creates a cord instance with `method` representing the originating
+  // public API call causing the cord to be created.
+  explicit Cord(absl::string_view src, MethodIdentifier method);
+
+  friend class CordTestPeer;
+  friend bool operator==(const Cord& lhs, const Cord& rhs);
+  friend bool operator==(const Cord& lhs, absl::string_view rhs);
+
+  friend const CordzInfo* GetCordzInfoForTesting(const Cord& cord);
+
+  // Calls the provided function once for each cord chunk, in order.  Unlike
+  // Chunks(), this API will not allocate memory.
+  void ForEachChunk(absl::FunctionRef<void(absl::string_view)>) const;
+
+  // Allocates new contiguous storage for the contents of the cord. This is
+  // called by Flatten() when the cord was not already flat.
+  absl::string_view FlattenSlowPath();
+
+  // Actual cord contents are hidden inside the following simple
+  // class so that we can isolate the bulk of cord.cc from changes
+  // to the representation.
+  //
+  // InlineRep holds either a tree pointer, or an array of kMaxInline bytes.
+  class InlineRep {
+   public:
+    static constexpr unsigned char kMaxInline = cord_internal::kMaxInline;
+    static_assert(kMaxInline >= sizeof(absl::cord_internal::CordRep*), "");
+
+    constexpr InlineRep() : data_() {}
+    explicit InlineRep(InlineData::DefaultInitType init) : data_(init) {}
+    InlineRep(const InlineRep& src);
+    InlineRep(InlineRep&& src);
+    InlineRep& operator=(const InlineRep& src);
+    InlineRep& operator=(InlineRep&& src) noexcept;
+
+    explicit constexpr InlineRep(cord_internal::InlineData data);
+
+    void Swap(InlineRep* rhs);
+    bool empty() const;
+    size_t size() const;
+    const char* data() const;  // Returns nullptr if holding pointer
+    void set_data(const char* data, size_t n);  // Discards pointer, if any
+    char* set_data(size_t n);                   // Write data to the result
+    // Returns nullptr if holding bytes
+    absl::cord_internal::CordRep* tree() const;
+    absl::cord_internal::CordRep* as_tree() const;
+    const char* as_chars() const;
+    // Returns non-null iff was holding a pointer
+    absl::cord_internal::CordRep* clear();
+    // Converts to pointer if necessary.
+    void reduce_size(size_t n);    // REQUIRES: holding data
+    void remove_prefix(size_t n);  // REQUIRES: holding data
+    void AppendArray(absl::string_view src, MethodIdentifier method);
+    absl::string_view FindFlatStartPiece() const;
+
+    // Creates a CordRepFlat instance from the current inlined data with `extra'
+    // bytes of desired additional capacity.
+    CordRepFlat* MakeFlatWithExtraCapacity(size_t extra);
+
+    // Sets the tree value for this instance. `rep` must not be null.
+    // Requires the current instance to hold a tree, and a lock to be held on
+    // any CordzInfo referenced by this instance. The latter is enforced through
+    // the CordzUpdateScope argument. If the current instance is sampled, then
+    // the CordzInfo instance is updated to reference the new `rep` value.
+    void SetTree(CordRep* rep, const CordzUpdateScope& scope);
+
+    // Identical to SetTree(), except that `rep` is allowed to be null, in
+    // which case the current instance is reset to an empty value.
+    void SetTreeOrEmpty(CordRep* rep, const CordzUpdateScope& scope);
+
+    // Sets the tree value for this instance, and randomly samples this cord.
+    // This function disregards existing contents in `data_`, and should be
+    // called when a Cord is 'promoted' from an 'uninitialized' or 'inlined'
+    // value to a non-inlined (tree / ring) value.
+    void EmplaceTree(CordRep* rep, MethodIdentifier method);
+
+    // Identical to EmplaceTree, except that it copies the parent stack from
+    // the provided `parent` data if the parent is sampled.
+    void EmplaceTree(CordRep* rep, const InlineData& parent,
+                     MethodIdentifier method);
+
+    // Commits the change of a newly created, or updated `rep` root value into
+    // this cord. `old_rep` indicates the old (inlined or tree) value of the
+    // cord, and determines if the commit invokes SetTree() or EmplaceTree().
+    void CommitTree(const CordRep* old_rep, CordRep* rep,
+                    const CordzUpdateScope& scope, MethodIdentifier method);
+
+    void AppendTreeToInlined(CordRep* tree, MethodIdentifier method);
+    void AppendTreeToTree(CordRep* tree, MethodIdentifier method);
+    void AppendTree(CordRep* tree, MethodIdentifier method);
+    void PrependTreeToInlined(CordRep* tree, MethodIdentifier method);
+    void PrependTreeToTree(CordRep* tree, MethodIdentifier method);
+    void PrependTree(CordRep* tree, MethodIdentifier method);
+
+    template <bool has_length>
+    void GetAppendRegion(char** region, size_t* size, size_t length);
+
+    bool IsSame(const InlineRep& other) const {
+      return memcmp(&data_, &other.data_, sizeof(data_)) == 0;
+    }
+    int BitwiseCompare(const InlineRep& other) const {
+      uint64_t x, y;
+      // Use memcpy to avoid aliasing issues.
+      memcpy(&x, &data_, sizeof(x));
+      memcpy(&y, &other.data_, sizeof(y));
+      if (x == y) {
+        memcpy(&x, reinterpret_cast<const char*>(&data_) + 8, sizeof(x));
+        memcpy(&y, reinterpret_cast<const char*>(&other.data_) + 8, sizeof(y));
+        if (x == y) return 0;
+      }
+      return absl::big_endian::FromHost64(x) < absl::big_endian::FromHost64(y)
+                 ? -1
+                 : 1;
+    }
+    void CopyTo(std::string* dst) const {
+      // memcpy is much faster when operating on a known size. On most supported
+      // platforms, the small string optimization is large enough that resizing
+      // to 15 bytes does not cause a memory allocation.
+      absl::strings_internal::STLStringResizeUninitialized(dst,
+                                                           sizeof(data_) - 1);
+      memcpy(&(*dst)[0], &data_, sizeof(data_) - 1);
+      // erase is faster than resize because the logic for memory allocation is
+      // not needed.
+      dst->erase(inline_size());
+    }
+
+    // Copies the inline contents into `dst`. Assumes the cord is not empty.
+    void CopyToArray(char* dst) const;
+
+    bool is_tree() const { return data_.is_tree(); }
+
+    // Returns true if the Cord is being profiled by cordz.
+    bool is_profiled() const { return data_.is_tree() && data_.is_profiled(); }
+
+    // Returns the available inlined capacity, or 0 if is_tree() == true.
+    size_t remaining_inline_capacity() const {
+      return data_.is_tree() ? 0 : kMaxInline - data_.inline_size();
+    }
+
+    // Returns the profiled CordzInfo, or nullptr if not sampled.
+    absl::cord_internal::CordzInfo* cordz_info() const {
+      return data_.cordz_info();
+    }
+
+    // Sets the profiled CordzInfo. `cordz_info` must not be null.
+    void set_cordz_info(cord_internal::CordzInfo* cordz_info) {
+      assert(cordz_info != nullptr);
+      data_.set_cordz_info(cordz_info);
+    }
+
+    // Resets the current cordz_info to null / empty.
+    void clear_cordz_info() { data_.clear_cordz_info(); }
+
+   private:
+    friend class Cord;
+
+    void AssignSlow(const InlineRep& src);
+    // Unrefs the tree and stops profiling.
+    void UnrefTree();
+
+    void ResetToEmpty() { data_ = {}; }
+
+    void set_inline_size(size_t size) { data_.set_inline_size(size); }
+    size_t inline_size() const { return data_.inline_size(); }
+
+    cord_internal::InlineData data_;
+  };
+  InlineRep contents_;
+
+  // Helper for GetFlat() and TryFlat().
+  static bool GetFlatAux(absl::cord_internal::CordRep* rep,
+                         absl::string_view* fragment);
+
+  // Helper for ForEachChunk().
+  static void ForEachChunkAux(
+      absl::cord_internal::CordRep* rep,
+      absl::FunctionRef<void(absl::string_view)> callback);
+
+  // The destructor for non-empty Cords.
+  void DestroyCordSlow();
+
+  // Out-of-line implementation of slower parts of logic.
+  void CopyToArraySlowPath(char* dst) const;
+  int CompareSlowPath(absl::string_view rhs, size_t compared_size,
+                      size_t size_to_compare) const;
+  int CompareSlowPath(const Cord& rhs, size_t compared_size,
+                      size_t size_to_compare) const;
+  bool EqualsImpl(absl::string_view rhs, size_t size_to_compare) const;
+  bool EqualsImpl(const Cord& rhs, size_t size_to_compare) const;
+  int CompareImpl(const Cord& rhs) const;
+
+  template <typename ResultType, typename RHS>
+  friend ResultType GenericCompare(const Cord& lhs, const RHS& rhs,
+                                   size_t size_to_compare);
+  static absl::string_view GetFirstChunk(const Cord& c);
+  static absl::string_view GetFirstChunk(absl::string_view sv);
+
+  // Returns a new reference to contents_.tree(), or steals an existing
+  // reference if called on an rvalue.
+  absl::cord_internal::CordRep* TakeRep() const&;
+  absl::cord_internal::CordRep* TakeRep() &&;
+
+  // Helper for Append().
+  template <typename C>
+  void AppendImpl(C&& src);
+
+  // Appends / Prepends `src` to this instance, using precise sizing.
+  // This method does explicitly not attempt to use any spare capacity
+  // in any pending last added private owned flat.
+  // Requires `src` to be <= kMaxFlatLength.
+  void AppendPrecise(absl::string_view src, MethodIdentifier method);
+  void PrependPrecise(absl::string_view src, MethodIdentifier method);
+
+  CordBuffer GetAppendBufferSlowPath(size_t capacity, size_t min_capacity);
+
+  // Prepends the provided data to this instance. `method` contains the public
+  // API method for this action which is tracked for Cordz sampling purposes.
+  void PrependArray(absl::string_view src, MethodIdentifier method);
+
+  // Assigns the value in 'src' to this instance, 'stealing' its contents.
+  // Requires src.length() > kMaxBytesToCopy.
+  Cord& AssignLargeString(std::string&& src);
+
+  // Helper for AbslHashValue().
+  template <typename H>
+  H HashFragmented(H hash_state) const {
+    typename H::AbslInternalPiecewiseCombiner combiner;
+    ForEachChunk([&combiner, &hash_state](absl::string_view chunk) {
+      hash_state = combiner.add_buffer(std::move(hash_state), chunk.data(),
+                                       chunk.size());
+    });
+    return H::combine(combiner.finalize(std::move(hash_state)), size());
+  }
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// allow a Cord to be logged
+extern std::ostream& operator<<(std::ostream& out, const Cord& cord);
+
+// ------------------------------------------------------------------
+// Internal details follow.  Clients should ignore.
+
+namespace cord_internal {
+
+// Fast implementation of memmove for up to 15 bytes. This implementation is
+// safe for overlapping regions. If nullify_tail is true, the destination is
+// padded with '\0' up to 16 bytes.
+template <bool nullify_tail = false>
+inline void SmallMemmove(char* dst, const char* src, size_t n) {
+  if (n >= 8) {
+    assert(n <= 16);
+    uint64_t buf1;
+    uint64_t buf2;
+    memcpy(&buf1, src, 8);
+    memcpy(&buf2, src + n - 8, 8);
+    if (nullify_tail) {
+      memset(dst + 8, 0, 8);
+    }
+    memcpy(dst, &buf1, 8);
+    memcpy(dst + n - 8, &buf2, 8);
+  } else if (n >= 4) {
+    uint32_t buf1;
+    uint32_t buf2;
+    memcpy(&buf1, src, 4);
+    memcpy(&buf2, src + n - 4, 4);
+    if (nullify_tail) {
+      memset(dst + 4, 0, 4);
+      memset(dst + 8, 0, 8);
+    }
+    memcpy(dst, &buf1, 4);
+    memcpy(dst + n - 4, &buf2, 4);
+  } else {
+    if (n != 0) {
+      dst[0] = src[0];
+      dst[n / 2] = src[n / 2];
+      dst[n - 1] = src[n - 1];
+    }
+    if (nullify_tail) {
+      memset(dst + 8, 0, 8);
+      memset(dst + n, 0, 8);
+    }
+  }
+}
+
+// Does non-template-specific `CordRepExternal` initialization.
+// Requires `data` to be non-empty.
+void InitializeCordRepExternal(absl::string_view data, CordRepExternal* rep);
+
+// Creates a new `CordRep` that owns `data` and `releaser` and returns a pointer
+// to it. Requires `data` to be non-empty.
+template <typename Releaser>
+// NOLINTNEXTLINE - suppress clang-tidy raw pointer return.
+CordRep* NewExternalRep(absl::string_view data, Releaser&& releaser) {
+  assert(!data.empty());
+  using ReleaserType = absl::decay_t<Releaser>;
+  CordRepExternal* rep = new CordRepExternalImpl<ReleaserType>(
+      std::forward<Releaser>(releaser), 0);
+  InitializeCordRepExternal(data, rep);
+  return rep;
+}
+
+// Overload for function reference types that dispatches using a function
+// pointer because there are no `alignof()` or `sizeof()` a function reference.
+// NOLINTNEXTLINE - suppress clang-tidy raw pointer return.
+inline CordRep* NewExternalRep(absl::string_view data,
+                               void (&releaser)(absl::string_view)) {
+  return NewExternalRep(data, &releaser);
+}
+
+}  // namespace cord_internal
+
+template <typename Releaser>
+Cord MakeCordFromExternal(absl::string_view data, Releaser&& releaser) {
+  Cord cord;
+  if (ABSL_PREDICT_TRUE(!data.empty())) {
+    cord.contents_.EmplaceTree(::absl::cord_internal::NewExternalRep(
+                                   data, std::forward<Releaser>(releaser)),
+                               Cord::MethodIdentifier::kMakeCordFromExternal);
+  } else {
+    using ReleaserType = absl::decay_t<Releaser>;
+    cord_internal::InvokeReleaser(
+        cord_internal::Rank0{}, ReleaserType(std::forward<Releaser>(releaser)),
+        data);
+  }
+  return cord;
+}
+
+constexpr Cord::InlineRep::InlineRep(cord_internal::InlineData data)
+    : data_(data) {}
+
+inline Cord::InlineRep::InlineRep(const Cord::InlineRep& src)
+    : data_(InlineData::kDefaultInit) {
+  if (CordRep* tree = src.tree()) {
+    EmplaceTree(CordRep::Ref(tree), src.data_,
+                CordzUpdateTracker::kConstructorCord);
+  } else {
+    data_ = src.data_;
+  }
+}
+
+inline Cord::InlineRep::InlineRep(Cord::InlineRep&& src) : data_(src.data_) {
+  src.ResetToEmpty();
+}
+
+inline Cord::InlineRep& Cord::InlineRep::operator=(const Cord::InlineRep& src) {
+  if (this == &src) {
+    return *this;
+  }
+  if (!is_tree() && !src.is_tree()) {
+    data_ = src.data_;
+    return *this;
+  }
+  AssignSlow(src);
+  return *this;
+}
+
+inline Cord::InlineRep& Cord::InlineRep::operator=(
+    Cord::InlineRep&& src) noexcept {
+  if (is_tree()) {
+    UnrefTree();
+  }
+  data_ = src.data_;
+  src.ResetToEmpty();
+  return *this;
+}
+
+inline void Cord::InlineRep::Swap(Cord::InlineRep* rhs) {
+  if (rhs == this) {
+    return;
+  }
+  std::swap(data_, rhs->data_);
+}
+
+inline const char* Cord::InlineRep::data() const {
+  return is_tree() ? nullptr : data_.as_chars();
+}
+
+inline const char* Cord::InlineRep::as_chars() const {
+  assert(!data_.is_tree());
+  return data_.as_chars();
+}
+
+inline absl::cord_internal::CordRep* Cord::InlineRep::as_tree() const {
+  assert(data_.is_tree());
+  return data_.as_tree();
+}
+
+inline absl::cord_internal::CordRep* Cord::InlineRep::tree() const {
+  if (is_tree()) {
+    return as_tree();
+  } else {
+    return nullptr;
+  }
+}
+
+inline bool Cord::InlineRep::empty() const { return data_.is_empty(); }
+
+inline size_t Cord::InlineRep::size() const {
+  return is_tree() ? as_tree()->length : inline_size();
+}
+
+inline cord_internal::CordRepFlat* Cord::InlineRep::MakeFlatWithExtraCapacity(
+    size_t extra) {
+  static_assert(cord_internal::kMinFlatLength >= sizeof(data_), "");
+  size_t len = data_.inline_size();
+  auto* result = CordRepFlat::New(len + extra);
+  result->length = len;
+  memcpy(result->Data(), data_.as_chars(), sizeof(data_));
+  return result;
+}
+
+inline void Cord::InlineRep::EmplaceTree(CordRep* rep,
+                                         MethodIdentifier method) {
+  assert(rep);
+  data_.make_tree(rep);
+  CordzInfo::MaybeTrackCord(data_, method);
+}
+
+inline void Cord::InlineRep::EmplaceTree(CordRep* rep, const InlineData& parent,
+                                         MethodIdentifier method) {
+  data_.make_tree(rep);
+  CordzInfo::MaybeTrackCord(data_, parent, method);
+}
+
+inline void Cord::InlineRep::SetTree(CordRep* rep,
+                                     const CordzUpdateScope& scope) {
+  assert(rep);
+  assert(data_.is_tree());
+  data_.set_tree(rep);
+  scope.SetCordRep(rep);
+}
+
+inline void Cord::InlineRep::SetTreeOrEmpty(CordRep* rep,
+                                            const CordzUpdateScope& scope) {
+  assert(data_.is_tree());
+  if (rep) {
+    data_.set_tree(rep);
+  } else {
+    data_ = {};
+  }
+  scope.SetCordRep(rep);
+}
+
+inline void Cord::InlineRep::CommitTree(const CordRep* old_rep, CordRep* rep,
+                                        const CordzUpdateScope& scope,
+                                        MethodIdentifier method) {
+  if (old_rep) {
+    SetTree(rep, scope);
+  } else {
+    EmplaceTree(rep, method);
+  }
+}
+
+inline absl::cord_internal::CordRep* Cord::InlineRep::clear() {
+  if (is_tree()) {
+    CordzInfo::MaybeUntrackCord(cordz_info());
+  }
+  absl::cord_internal::CordRep* result = tree();
+  ResetToEmpty();
+  return result;
+}
+
+inline void Cord::InlineRep::CopyToArray(char* dst) const {
+  assert(!is_tree());
+  size_t n = inline_size();
+  assert(n != 0);
+  cord_internal::SmallMemmove(dst, data_.as_chars(), n);
+}
+
+constexpr inline Cord::Cord() noexcept {}
+
+inline Cord::Cord(absl::string_view src)
+    : Cord(src, CordzUpdateTracker::kConstructorString) {}
+
+template <typename T>
+constexpr Cord::Cord(strings_internal::StringConstant<T>)
+    : contents_(strings_internal::StringConstant<T>::value.size() <=
+                        cord_internal::kMaxInline
+                    ? cord_internal::InlineData(
+                          strings_internal::StringConstant<T>::value)
+                    : cord_internal::InlineData(
+                          &cord_internal::ConstInitExternalStorage<
+                              strings_internal::StringConstant<T>>::value)) {}
+
+inline Cord& Cord::operator=(const Cord& x) {
+  contents_ = x.contents_;
+  return *this;
+}
+
+template <typename T, Cord::EnableIfString<T>>
+Cord& Cord::operator=(T&& src) {
+  if (src.size() <= cord_internal::kMaxBytesToCopy) {
+    return operator=(absl::string_view(src));
+  } else {
+    return AssignLargeString(std::forward<T>(src));
+  }
+}
+
+inline Cord::Cord(const Cord& src) : contents_(src.contents_) {}
+
+inline Cord::Cord(Cord&& src) noexcept : contents_(std::move(src.contents_)) {}
+
+inline void Cord::swap(Cord& other) noexcept {
+  contents_.Swap(&other.contents_);
+}
+
+inline Cord& Cord::operator=(Cord&& x) noexcept {
+  contents_ = std::move(x.contents_);
+  return *this;
+}
+
+extern template Cord::Cord(std::string&& src);
+
+inline size_t Cord::size() const {
+  // Length is 1st field in str.rep_
+  return contents_.size();
+}
+
+inline bool Cord::empty() const { return contents_.empty(); }
+
+inline size_t Cord::EstimatedMemoryUsage(
+    CordMemoryAccounting accounting_method) const {
+  size_t result = sizeof(Cord);
+  if (const absl::cord_internal::CordRep* rep = contents_.tree()) {
+    if (accounting_method == CordMemoryAccounting::kFairShare) {
+      result += cord_internal::GetEstimatedFairShareMemoryUsage(rep);
+    } else {
+      result += cord_internal::GetEstimatedMemoryUsage(rep);
+    }
+  }
+  return result;
+}
+
+inline absl::optional<absl::string_view> Cord::TryFlat() const {
+  absl::cord_internal::CordRep* rep = contents_.tree();
+  if (rep == nullptr) {
+    return absl::string_view(contents_.data(), contents_.size());
+  }
+  absl::string_view fragment;
+  if (GetFlatAux(rep, &fragment)) {
+    return fragment;
+  }
+  return absl::nullopt;
+}
+
+inline absl::string_view Cord::Flatten() {
+  absl::cord_internal::CordRep* rep = contents_.tree();
+  if (rep == nullptr) {
+    return absl::string_view(contents_.data(), contents_.size());
+  } else {
+    absl::string_view already_flat_contents;
+    if (GetFlatAux(rep, &already_flat_contents)) {
+      return already_flat_contents;
+    }
+  }
+  return FlattenSlowPath();
+}
+
+inline void Cord::Append(absl::string_view src) {
+  contents_.AppendArray(src, CordzUpdateTracker::kAppendString);
+}
+
+inline void Cord::Prepend(absl::string_view src) {
+  PrependArray(src, CordzUpdateTracker::kPrependString);
+}
+
+inline void Cord::Append(CordBuffer buffer) {
+  if (ABSL_PREDICT_FALSE(buffer.length() == 0)) return;
+  absl::string_view short_value;
+  if (CordRep* rep = buffer.ConsumeValue(short_value)) {
+    contents_.AppendTree(rep, CordzUpdateTracker::kAppendCordBuffer);
+  } else {
+    AppendPrecise(short_value, CordzUpdateTracker::kAppendCordBuffer);
+  }
+}
+
+inline void Cord::Prepend(CordBuffer buffer) {
+  if (ABSL_PREDICT_FALSE(buffer.length() == 0)) return;
+  absl::string_view short_value;
+  if (CordRep* rep = buffer.ConsumeValue(short_value)) {
+    contents_.PrependTree(rep, CordzUpdateTracker::kPrependCordBuffer);
+  } else {
+    PrependPrecise(short_value, CordzUpdateTracker::kPrependCordBuffer);
+  }
+}
+
+inline CordBuffer Cord::GetAppendBuffer(size_t capacity, size_t min_capacity) {
+  if (empty()) return CordBuffer::CreateWithDefaultLimit(capacity);
+  return GetAppendBufferSlowPath(capacity, min_capacity);
+}
+
+extern template void Cord::Append(std::string&& src);
+extern template void Cord::Prepend(std::string&& src);
+
+inline int Cord::Compare(const Cord& rhs) const {
+  if (!contents_.is_tree() && !rhs.contents_.is_tree()) {
+    return contents_.BitwiseCompare(rhs.contents_);
+  }
+
+  return CompareImpl(rhs);
+}
+
+// Does 'this' cord start/end with rhs
+inline bool Cord::StartsWith(const Cord& rhs) const {
+  if (contents_.IsSame(rhs.contents_)) return true;
+  size_t rhs_size = rhs.size();
+  if (size() < rhs_size) return false;
+  return EqualsImpl(rhs, rhs_size);
+}
+
+inline bool Cord::StartsWith(absl::string_view rhs) const {
+  size_t rhs_size = rhs.size();
+  if (size() < rhs_size) return false;
+  return EqualsImpl(rhs, rhs_size);
+}
+
+inline void Cord::ChunkIterator::InitTree(cord_internal::CordRep* tree) {
+  tree = cord_internal::SkipCrcNode(tree);
+  if (tree->tag == cord_internal::BTREE) {
+    current_chunk_ = btree_reader_.Init(tree->btree());
+  } else {
+    current_leaf_ = tree;
+    current_chunk_ = cord_internal::EdgeData(tree);
+  }
+}
+
+inline Cord::ChunkIterator::ChunkIterator(cord_internal::CordRep* tree) {
+  bytes_remaining_ = tree->length;
+  InitTree(tree);
+}
+
+inline Cord::ChunkIterator::ChunkIterator(const Cord* cord) {
+  if (CordRep* tree = cord->contents_.tree()) {
+    bytes_remaining_ = tree->length;
+    InitTree(tree);
+  } else {
+    bytes_remaining_ = cord->contents_.inline_size();
+    current_chunk_ = {cord->contents_.data(), bytes_remaining_};
+  }
+}
+
+inline Cord::ChunkIterator& Cord::ChunkIterator::AdvanceBtree() {
+  current_chunk_ = btree_reader_.Next();
+  return *this;
+}
+
+inline void Cord::ChunkIterator::AdvanceBytesBtree(size_t n) {
+  assert(n >= current_chunk_.size());
+  bytes_remaining_ -= n;
+  if (bytes_remaining_) {
+    if (n == current_chunk_.size()) {
+      current_chunk_ = btree_reader_.Next();
+    } else {
+      size_t offset = btree_reader_.length() - bytes_remaining_;
+      current_chunk_ = btree_reader_.Seek(offset);
+    }
+  } else {
+    current_chunk_ = {};
+  }
+}
+
+inline Cord::ChunkIterator& Cord::ChunkIterator::operator++() {
+  ABSL_HARDENING_ASSERT(bytes_remaining_ > 0 &&
+                        "Attempted to iterate past `end()`");
+  assert(bytes_remaining_ >= current_chunk_.size());
+  bytes_remaining_ -= current_chunk_.size();
+  if (bytes_remaining_ > 0) {
+    if (btree_reader_) {
+      return AdvanceBtree();
+    } else {
+      assert(!current_chunk_.empty());  // Called on invalid iterator.
+    }
+    current_chunk_ = {};
+  }
+  return *this;
+}
+
+inline Cord::ChunkIterator Cord::ChunkIterator::operator++(int) {
+  ChunkIterator tmp(*this);
+  operator++();
+  return tmp;
+}
+
+inline bool Cord::ChunkIterator::operator==(const ChunkIterator& other) const {
+  return bytes_remaining_ == other.bytes_remaining_;
+}
+
+inline bool Cord::ChunkIterator::operator!=(const ChunkIterator& other) const {
+  return !(*this == other);
+}
+
+inline Cord::ChunkIterator::reference Cord::ChunkIterator::operator*() const {
+  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
+  return current_chunk_;
+}
+
+inline Cord::ChunkIterator::pointer Cord::ChunkIterator::operator->() const {
+  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
+  return &current_chunk_;
+}
+
+inline void Cord::ChunkIterator::RemoveChunkPrefix(size_t n) {
+  assert(n < current_chunk_.size());
+  current_chunk_.remove_prefix(n);
+  bytes_remaining_ -= n;
+}
+
+inline void Cord::ChunkIterator::AdvanceBytes(size_t n) {
+  assert(bytes_remaining_ >= n);
+  if (ABSL_PREDICT_TRUE(n < current_chunk_.size())) {
+    RemoveChunkPrefix(n);
+  } else if (n != 0) {
+    if (btree_reader_) {
+      AdvanceBytesBtree(n);
+    } else {
+      bytes_remaining_ = 0;
+    }
+  }
+}
+
+inline Cord::ChunkIterator Cord::chunk_begin() const {
+  return ChunkIterator(this);
+}
+
+inline Cord::ChunkIterator Cord::chunk_end() const { return ChunkIterator(); }
+
+inline Cord::ChunkIterator Cord::ChunkRange::begin() const {
+  return cord_->chunk_begin();
+}
+
+inline Cord::ChunkIterator Cord::ChunkRange::end() const {
+  return cord_->chunk_end();
+}
+
+inline Cord::ChunkRange Cord::Chunks() const { return ChunkRange(this); }
+
+inline Cord::CharIterator& Cord::CharIterator::operator++() {
+  if (ABSL_PREDICT_TRUE(chunk_iterator_->size() > 1)) {
+    chunk_iterator_.RemoveChunkPrefix(1);
+  } else {
+    ++chunk_iterator_;
+  }
+  return *this;
+}
+
+inline Cord::CharIterator Cord::CharIterator::operator++(int) {
+  CharIterator tmp(*this);
+  operator++();
+  return tmp;
+}
+
+inline bool Cord::CharIterator::operator==(const CharIterator& other) const {
+  return chunk_iterator_ == other.chunk_iterator_;
+}
+
+inline bool Cord::CharIterator::operator!=(const CharIterator& other) const {
+  return !(*this == other);
+}
+
+inline Cord::CharIterator::reference Cord::CharIterator::operator*() const {
+  return *chunk_iterator_->data();
+}
+
+inline Cord::CharIterator::pointer Cord::CharIterator::operator->() const {
+  return chunk_iterator_->data();
+}
+
+inline Cord Cord::AdvanceAndRead(CharIterator* it, size_t n_bytes) {
+  assert(it != nullptr);
+  return it->chunk_iterator_.AdvanceAndReadBytes(n_bytes);
+}
+
+inline void Cord::Advance(CharIterator* it, size_t n_bytes) {
+  assert(it != nullptr);
+  it->chunk_iterator_.AdvanceBytes(n_bytes);
+}
+
+inline absl::string_view Cord::ChunkRemaining(const CharIterator& it) {
+  return *it.chunk_iterator_;
+}
+
+inline Cord::CharIterator Cord::char_begin() const {
+  return CharIterator(this);
+}
+
+inline Cord::CharIterator Cord::char_end() const { return CharIterator(); }
+
+inline Cord::CharIterator Cord::CharRange::begin() const {
+  return cord_->char_begin();
+}
+
+inline Cord::CharIterator Cord::CharRange::end() const {
+  return cord_->char_end();
+}
+
+inline Cord::CharRange Cord::Chars() const { return CharRange(this); }
+
+inline void Cord::ForEachChunk(
+    absl::FunctionRef<void(absl::string_view)> callback) const {
+  absl::cord_internal::CordRep* rep = contents_.tree();
+  if (rep == nullptr) {
+    callback(absl::string_view(contents_.data(), contents_.size()));
+  } else {
+    return ForEachChunkAux(rep, callback);
+  }
+}
+
+// Nonmember Cord-to-Cord relational operators.
+inline bool operator==(const Cord& lhs, const Cord& rhs) {
+  if (lhs.contents_.IsSame(rhs.contents_)) return true;
+  size_t rhs_size = rhs.size();
+  if (lhs.size() != rhs_size) return false;
+  return lhs.EqualsImpl(rhs, rhs_size);
+}
+
+inline bool operator!=(const Cord& x, const Cord& y) { return !(x == y); }
+inline bool operator<(const Cord& x, const Cord& y) { return x.Compare(y) < 0; }
+inline bool operator>(const Cord& x, const Cord& y) { return x.Compare(y) > 0; }
+inline bool operator<=(const Cord& x, const Cord& y) {
+  return x.Compare(y) <= 0;
+}
+inline bool operator>=(const Cord& x, const Cord& y) {
+  return x.Compare(y) >= 0;
+}
+
+// Nonmember Cord-to-absl::string_view relational operators.
+//
+// Due to implicit conversions, these also enable comparisons of Cord with
+// with std::string, ::string, and const char*.
+inline bool operator==(const Cord& lhs, absl::string_view rhs) {
+  size_t lhs_size = lhs.size();
+  size_t rhs_size = rhs.size();
+  if (lhs_size != rhs_size) return false;
+  return lhs.EqualsImpl(rhs, rhs_size);
+}
+
+inline bool operator==(absl::string_view x, const Cord& y) { return y == x; }
+inline bool operator!=(const Cord& x, absl::string_view y) { return !(x == y); }
+inline bool operator!=(absl::string_view x, const Cord& y) { return !(x == y); }
+inline bool operator<(const Cord& x, absl::string_view y) {
+  return x.Compare(y) < 0;
+}
+inline bool operator<(absl::string_view x, const Cord& y) {
+  return y.Compare(x) > 0;
+}
+inline bool operator>(const Cord& x, absl::string_view y) { return y < x; }
+inline bool operator>(absl::string_view x, const Cord& y) { return y < x; }
+inline bool operator<=(const Cord& x, absl::string_view y) { return !(y < x); }
+inline bool operator<=(absl::string_view x, const Cord& y) { return !(y < x); }
+inline bool operator>=(const Cord& x, absl::string_view y) { return !(x < y); }
+inline bool operator>=(absl::string_view x, const Cord& y) { return !(x < y); }
+
+// Some internals exposed to test code.
+namespace strings_internal {
+class CordTestAccess {
+ public:
+  static size_t FlatOverhead();
+  static size_t MaxFlatLength();
+  static size_t SizeofCordRepExternal();
+  static size_t SizeofCordRepSubstring();
+  static size_t FlatTagToLength(uint8_t tag);
+  static uint8_t LengthToTag(size_t s);
+};
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CORD_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cord_analysis.h b/CAPI/cpp/grpc/include/absl/strings/cord_analysis.h
new file mode 100644
index 0000000..7041ad1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/cord_analysis.h
@@ -0,0 +1,44 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_CORD_ANALYSIS_H_
+#define ABSL_STRINGS_CORD_ANALYSIS_H_
+
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/strings/internal/cord_internal.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// Returns the *approximate* number of bytes held in full or in part by this
+// Cord (which may not remain the same between invocations). Cords that share
+// memory could each be "charged" independently for the same shared memory.
+size_t GetEstimatedMemoryUsage(const CordRep* rep);
+
+// Returns the *approximate* number of bytes held in full or in part by this
+// CordRep weighted by the sharing ratio of that data. For example, if some data
+// edge is shared by 4 different Cords, then each cord is attribute 1/4th of
+// the total memory usage as a 'fair share' of the total memory usage.
+size_t GetEstimatedFairShareMemoryUsage(const CordRep* rep);
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+
+#endif  // ABSL_STRINGS_CORD_ANALYSIS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cord_buffer.h b/CAPI/cpp/grpc/include/absl/strings/cord_buffer.h
new file mode 100644
index 0000000..56a6ce6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/cord_buffer.h
@@ -0,0 +1,572 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: cord_buffer.h
+// -----------------------------------------------------------------------------
+//
+// This file defines an `absl::CordBuffer` data structure to hold data for
+// eventual inclusion within an existing `Cord` data structure. Cord buffers are
+// useful for building large Cords that may require custom allocation of its
+// associated memory.
+//
+#ifndef ABSL_STRINGS_CORD_BUFFER_H_
+#define ABSL_STRINGS_CORD_BUFFER_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/numeric/bits.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_flat.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class Cord;
+class CordBufferTestPeer;
+
+// CordBuffer
+//
+// CordBuffer manages memory buffers for purposes such as zero-copy APIs as well
+// as applications building cords with large data requiring granular control
+// over the allocation and size of cord data. For example, a function creating
+// a cord of random data could use a CordBuffer as follows:
+//
+//   absl::Cord CreateRandomCord(size_t length) {
+//     absl::Cord cord;
+//     while (length > 0) {
+//       CordBuffer buffer = CordBuffer::CreateWithDefaultLimit(length);
+//       absl::Span<char> data = buffer.available_up_to(length);
+//       FillRandomValues(data.data(), data.size());
+//       buffer.IncreaseLengthBy(data.size());
+//       cord.Append(std::move(buffer));
+//       length -= data.size();
+//     }
+//     return cord;
+//   }
+//
+// CordBuffer instances are by default limited to a capacity of `kDefaultLimit`
+// bytes. `kDefaultLimit` is currently just under 4KiB, but this default may
+// change in the future and/or for specific architectures. The default limit is
+// aimed to provide a good trade-off between performance and memory overhead.
+// Smaller buffers typically incur more compute cost while larger buffers are
+// more CPU efficient but create significant memory overhead because of such
+// allocations being less granular. Using larger buffers may also increase the
+// risk of memory fragmentation.
+//
+// Applications create a buffer using one of the `CreateWithDefaultLimit()` or
+// `CreateWithCustomLimit()` methods. The returned instance will have a non-zero
+// capacity and a zero length. Applications use the `data()` method to set the
+// contents of the managed memory, and once done filling the buffer, use the
+// `IncreaseLengthBy()` or 'SetLength()' method to specify the length of the
+// initialized data before adding the buffer to a Cord.
+//
+// The `CreateWithCustomLimit()` method is intended for applications needing
+// larger buffers than the default memory limit, allowing the allocation of up
+// to a capacity of `kCustomLimit` bytes minus some minimum internal overhead.
+// The usage of `CreateWithCustomLimit()` should be limited to only those use
+// cases where the distribution of the input is relatively well known, and/or
+// where the trade-off between the efficiency gains outweigh the risk of memory
+// fragmentation. See the documentation for `CreateWithCustomLimit()` for more
+// information on using larger custom limits.
+//
+// The capacity of a `CordBuffer` returned by one of the `Create` methods may
+// be larger than the requested capacity due to rounding, alignment and
+// granularity of the memory allocator. Applications should use the `capacity`
+// method to obtain the effective capacity of the returned instance as
+// demonstrated in the provided example above.
+//
+// CordBuffer is a move-only class. All references into the managed memory are
+// invalidated when an instance is moved into either another CordBuffer instance
+// or a Cord. Writing to a location obtained by a previous call to `data()`
+// after an instance was moved will lead to undefined behavior.
+//
+// A `moved from` CordBuffer instance will have a valid, but empty state.
+// CordBuffer is thread compatible.
+class CordBuffer {
+ public:
+  // kDefaultLimit
+  //
+  // Default capacity limits of allocated CordBuffers.
+  // See the class comments for more information on allocation limits.
+  static constexpr size_t kDefaultLimit = cord_internal::kMaxFlatLength;
+
+  // kCustomLimit
+  //
+  // Maximum size for CreateWithCustomLimit() allocated buffers.
+  // Note that the effective capacity may be slightly less
+  // because of internal overhead of internal cord buffers.
+  static constexpr size_t kCustomLimit = 64U << 10;
+
+  // Constructors, Destructors and Assignment Operators
+
+  // Creates an empty CordBuffer.
+  CordBuffer() = default;
+
+  // Destroys this CordBuffer instance and, if not empty, releases any memory
+  // managed by this instance, invalidating previously returned references.
+  ~CordBuffer();
+
+  // CordBuffer is move-only
+  CordBuffer(CordBuffer&& rhs) noexcept;
+  CordBuffer& operator=(CordBuffer&&) noexcept;
+  CordBuffer(const CordBuffer&) = delete;
+  CordBuffer& operator=(const CordBuffer&) = delete;
+
+  // CordBuffer::MaximumPayload()
+  //
+  // Returns the guaranteed maximum payload for a CordBuffer returned by the
+  // `CreateWithDefaultLimit()` method. While small, each internal buffer inside
+  // a Cord incurs an overhead to manage the length, type and reference count
+  // for the buffer managed inside the cord tree. Applications can use this
+  // method to get approximate number of buffers required for a given byte
+  // size, etc.
+  //
+  // For example:
+  //   const size_t payload = absl::CordBuffer::MaximumPayload();
+  //   const size_t buffer_count = (total_size + payload - 1) / payload;
+  //   buffers.reserve(buffer_count);
+  static constexpr size_t MaximumPayload();
+
+  // Overload to the above `MaximumPayload()` except that it returns the
+  // maximum payload for a CordBuffer returned by the `CreateWithCustomLimit()`
+  // method given the provided `block_size`.
+  static constexpr size_t MaximumPayload(size_t block_size);
+
+  // CordBuffer::CreateWithDefaultLimit()
+  //
+  // Creates a CordBuffer instance of the desired `capacity`, capped at the
+  // default limit `kDefaultLimit`. The returned buffer has a guaranteed
+  // capacity of at least `min(kDefaultLimit, capacity)`. See the class comments
+  // for more information on buffer capacities and intended usage.
+  static CordBuffer CreateWithDefaultLimit(size_t capacity);
+
+
+  // CordBuffer::CreateWithCustomLimit()
+  //
+  // Creates a CordBuffer instance of the desired `capacity` rounded to an
+  // appropriate power of 2 size less than, or equal to `block_size`.
+  // Requires `block_size` to be a power of 2.
+  //
+  // If `capacity` is less than or equal to `kDefaultLimit`, then this method
+  // behaves identical to `CreateWithDefaultLimit`, which means that the caller
+  // is guaranteed to get a buffer of at least the requested capacity.
+  //
+  // If `capacity` is greater than or equal to `block_size`, then this method
+  // returns a buffer with an `allocated size` of `block_size` bytes. Otherwise,
+  // this methods returns a buffer with a suitable smaller power of 2 block size
+  // to satisfy the request. The actual size depends on a number of factors, and
+  // is typically (but not necessarily) the highest or second highest power of 2
+  // value less than or equal to `capacity`.
+  //
+  // The 'allocated size' includes a small amount of overhead required for
+  // internal state, which is currently 13 bytes on 64-bit platforms. For
+  // example: a buffer created with `block_size` and `capacity' set to 8KiB
+  // will have an allocated size of 8KiB, and an effective internal `capacity`
+  // of 8KiB - 13 = 8179 bytes.
+  //
+  // To demonstrate this in practice, let's assume we want to read data from
+  // somewhat larger files using approximately 64KiB buffers:
+  //
+  //   absl::Cord ReadFromFile(int fd, size_t n) {
+  //     absl::Cord cord;
+  //     while (n > 0) {
+  //       CordBuffer buffer = CordBuffer::CreateWithCustomLimit(64 << 10, n);
+  //       absl::Span<char> data = buffer.available_up_to(n);
+  //       ReadFileDataOrDie(fd, data.data(), data.size());
+  //       buffer.IncreaseLengthBy(data.size());
+  //       cord.Append(std::move(buffer));
+  //       n -= data.size();
+  //     }
+  //     return cord;
+  //   }
+  //
+  // If we'd use this function to read a file of 659KiB, we may get the
+  // following pattern of allocated cord buffer sizes:
+  //
+  //   CreateWithCustomLimit(64KiB, 674816) --> ~64KiB (65523)
+  //   CreateWithCustomLimit(64KiB, 674816) --> ~64KiB (65523)
+  //   ...
+  //   CreateWithCustomLimit(64KiB,  19586) --> ~16KiB (16371)
+  //   CreateWithCustomLimit(64KiB,   3215) -->   3215 (at least 3215)
+  //
+  // The reason the method returns a 16K buffer instead of a roughly 19K buffer
+  // is to reduce memory overhead and fragmentation risks. Using carefully
+  // chosen power of 2 values reduces the entropy of allocated memory sizes.
+  //
+  // Additionally, let's assume we'd use the above function on files that are
+  // generally smaller than 64K. If we'd use 'precise' sized buffers for such
+  // files, than we'd get a very wide distribution of allocated memory sizes
+  // rounded to 4K page sizes, and we'd end up with a lot of unused capacity.
+  //
+  // In general, application should only use custom sizes if the data they are
+  // consuming or storing is expected to be many times the chosen block size,
+  // and be based on objective data and performance metrics. For example, a
+  // compress function may work faster and consume less CPU when using larger
+  // buffers. Such an application should pick a size offering a reasonable
+  // trade-off between expected data size, compute savings with larger buffers,
+  // and the cost or fragmentation effect of larger buffers.
+  // Applications must pick a reasonable spot on that curve, and make sure their
+  // data meets their expectations in size distributions such as "mostly large".
+  static CordBuffer CreateWithCustomLimit(size_t block_size, size_t capacity);
+
+  // CordBuffer::available()
+  //
+  // Returns the span delineating the available capacity in this buffer
+  // which is defined as `{ data() + length(), capacity() - length() }`.
+  absl::Span<char> available();
+
+  // CordBuffer::available_up_to()
+  //
+  // Returns the span delineating the available capacity in this buffer limited
+  // to `size` bytes. This is equivalent to `available().subspan(0, size)`.
+  absl::Span<char> available_up_to(size_t size);
+
+  // CordBuffer::data()
+  //
+  // Returns a non-null reference to the data managed by this instance.
+  // Applications are allowed to write up to `capacity` bytes of instance data.
+  // CordBuffer data is uninitialized by default. Reading data from an instance
+  // that has not yet been initialized will lead to undefined behavior.
+  char* data();
+  const char* data() const;
+
+  // CordBuffer::length()
+  //
+  // Returns the length of this instance. The default length of a CordBuffer is
+  // 0, indicating an 'empty' CordBuffer. Applications must specify the length
+  // of the data in a CordBuffer before adding it to a Cord.
+  size_t length() const;
+
+  // CordBuffer::capacity()
+  //
+  // Returns the capacity of this instance. All instances have a non-zero
+  // capacity: default and `moved from` instances have a small internal buffer.
+  size_t capacity() const;
+
+  // CordBuffer::IncreaseLengthBy()
+  //
+  // Increases the length of this buffer by the specified 'n' bytes.
+  // Applications must make sure all data in this buffer up to the new length
+  // has been initialized before adding a CordBuffer to a Cord: failure to do so
+  // will lead to undefined behavior.  Requires `length() + n <= capacity()`.
+  // Typically, applications will use 'available_up_to()` to get a span of the
+  // desired capacity, and use `span.size()` to increase the length as in:
+  //   absl::Span<char> span = buffer.available_up_to(desired);
+  //   buffer.IncreaseLengthBy(span.size());
+  //   memcpy(span.data(), src, span.size());
+  //   etc...
+  void IncreaseLengthBy(size_t n);
+
+  // CordBuffer::SetLength()
+  //
+  // Sets the data length of this instance. Applications must make sure all data
+  // of the specified length has been initialized before adding a CordBuffer to
+  // a Cord: failure to do so will lead to undefined behavior.
+  // Setting the length to a small value or zero does not release any memory
+  // held by this CordBuffer instance. Requires `length <= capacity()`.
+  // Applications should preferably use the `IncreaseLengthBy()` method above
+  // in combination with the 'available()` or `available_up_to()` methods.
+  void SetLength(size_t length);
+
+ private:
+  // Make sure we don't accidentally over promise.
+  static_assert(kCustomLimit <= cord_internal::kMaxLargeFlatSize, "");
+
+  // Assume the cost of an 'uprounded' allocation to CeilPow2(size) versus
+  // the cost of allocating at least 1 extra flat <= 4KB:
+  // - Flat overhead = 13 bytes
+  // - Btree amortized cost / node =~ 13 bytes
+  // - 64 byte granularity of tcmalloc at 4K =~ 32 byte average
+  // CPU cost and efficiency requires we should at least 'save' something by
+  // splitting, as a poor man's measure, we say the slop needs to be
+  // at least double the cost offset to make it worth splitting: ~128 bytes.
+  static constexpr size_t kMaxPageSlop = 128;
+
+  // Overhead for allocation a flat.
+  static constexpr size_t kOverhead = cord_internal::kFlatOverhead;
+
+  using CordRepFlat = cord_internal::CordRepFlat;
+
+  // `Rep` is the internal data representation of a CordBuffer. The internal
+  // representation has an internal small size optimization similar to
+  // std::string (SSO).
+  struct Rep {
+    // Inline SSO size of a CordBuffer
+    static constexpr size_t kInlineCapacity = sizeof(intptr_t) * 2 - 1;
+
+    // Creates a default instance with kInlineCapacity.
+    Rep() : short_rep{} {}
+
+    // Creates an instance managing an allocated non zero CordRep.
+    explicit Rep(cord_internal::CordRepFlat* rep) : long_rep{rep} {
+      assert(rep != nullptr);
+    }
+
+    // Returns true if this instance manages the SSO internal buffer.
+    bool is_short() const {
+      constexpr size_t offset = offsetof(Short, raw_size);
+      return (reinterpret_cast<const char*>(this)[offset] & 1) != 0;
+    }
+
+    // Returns the available area of the internal SSO data
+    absl::Span<char> short_available() {
+      assert(is_short());
+      const size_t length = (short_rep.raw_size >> 1);
+      return absl::Span<char>(short_rep.data + length,
+                              kInlineCapacity - length);
+    }
+
+    // Returns the available area of the internal SSO data
+    absl::Span<char> long_available() {
+      assert(!is_short());
+      const size_t length = long_rep.rep->length;
+      return absl::Span<char>(long_rep.rep->Data() + length,
+                              long_rep.rep->Capacity() - length);
+    }
+
+    // Returns the length of the internal SSO data.
+    size_t short_length() const {
+      assert(is_short());
+      return short_rep.raw_size >> 1;
+    }
+
+    // Sets the length of the internal SSO data.
+    // Disregards any previously set CordRep instance.
+    void set_short_length(size_t length) {
+      short_rep.raw_size = static_cast<char>((length << 1) + 1);
+    }
+
+    // Adds `n` to the current short length.
+    void add_short_length(size_t n) {
+      assert(is_short());
+      short_rep.raw_size += static_cast<char>(n << 1);
+    }
+
+    // Returns reference to the internal SSO data buffer.
+    char* data() {
+      assert(is_short());
+      return short_rep.data;
+    }
+    const char* data() const {
+      assert(is_short());
+      return short_rep.data;
+    }
+
+    // Returns a pointer the external CordRep managed by this instance.
+    cord_internal::CordRepFlat* rep() const {
+      assert(!is_short());
+      return long_rep.rep;
+    }
+
+    // The internal representation takes advantage of the fact that allocated
+    // memory is always on an even address, and uses the least significant bit
+    // of the first or last byte (depending on endianness) as the inline size
+    // indicator overlapping with the least significant byte of the CordRep*.
+#if defined(ABSL_IS_BIG_ENDIAN)
+    struct Long {
+      explicit Long(cord_internal::CordRepFlat* rep_arg) : rep(rep_arg) {}
+      void* padding;
+      cord_internal::CordRepFlat* rep;
+    };
+    struct Short {
+      char data[sizeof(Long) - 1];
+      char raw_size = 1;
+    };
+#else
+    struct Long {
+      explicit Long(cord_internal::CordRepFlat* rep_arg) : rep(rep_arg) {}
+      cord_internal::CordRepFlat* rep;
+      void* padding;
+    };
+    struct Short {
+      char raw_size = 1;
+      char data[sizeof(Long) - 1];
+    };
+#endif
+
+    union {
+      Long long_rep;
+      Short short_rep;
+    };
+  };
+
+  // Power2 functions
+  static bool IsPow2(size_t size) { return absl::has_single_bit(size); }
+  static size_t Log2Floor(size_t size) { return absl::bit_width(size) - 1; }
+  static size_t Log2Ceil(size_t size) { return absl::bit_width(size - 1); }
+
+  // Implementation of `CreateWithCustomLimit()`.
+  // This implementation allows for future memory allocation hints to
+  // be passed down into the CordRepFlat allocation function.
+  template <typename... AllocationHints>
+  static CordBuffer CreateWithCustomLimitImpl(size_t block_size,
+                                              size_t capacity,
+                                              AllocationHints... hints);
+
+  // Consumes the value contained in this instance and resets the instance.
+  // This method returns a non-null Cordrep* if the current instances manages a
+  // CordRep*, and resets the instance to an empty SSO instance. If the current
+  // instance is an SSO instance, then this method returns nullptr and sets
+  // `short_value` to the inlined data value. In either case, the current
+  // instance length is reset to zero.
+  // This method is intended to be used by Cord internal functions only.
+  cord_internal::CordRep* ConsumeValue(absl::string_view& short_value) {
+    cord_internal::CordRep* rep = nullptr;
+    if (rep_.is_short()) {
+      short_value = absl::string_view(rep_.data(), rep_.short_length());
+    } else {
+      rep = rep_.rep();
+    }
+    rep_.set_short_length(0);
+    return rep;
+  }
+
+  // Internal constructor.
+  explicit CordBuffer(cord_internal::CordRepFlat* rep) : rep_(rep) {
+    assert(rep != nullptr);
+  }
+
+  Rep rep_;
+
+  friend class Cord;
+  friend class CordBufferTestPeer;
+};
+
+inline constexpr size_t CordBuffer::MaximumPayload() {
+  return cord_internal::kMaxFlatLength;
+}
+
+inline constexpr size_t CordBuffer::MaximumPayload(size_t block_size) {
+  // TODO(absl-team): Use std::min when C++11 support is dropped.
+  return (kCustomLimit < block_size ? kCustomLimit : block_size) -
+         cord_internal::kFlatOverhead;
+}
+
+inline CordBuffer CordBuffer::CreateWithDefaultLimit(size_t capacity) {
+  if (capacity > Rep::kInlineCapacity) {
+    auto* rep = cord_internal::CordRepFlat::New(capacity);
+    rep->length = 0;
+    return CordBuffer(rep);
+  }
+  return CordBuffer();
+}
+
+template <typename... AllocationHints>
+inline CordBuffer CordBuffer::CreateWithCustomLimitImpl(
+    size_t block_size, size_t capacity, AllocationHints... hints) {
+  assert(IsPow2(block_size));
+  capacity = (std::min)(capacity, kCustomLimit);
+  block_size = (std::min)(block_size, kCustomLimit);
+  if (capacity + kOverhead >= block_size) {
+    capacity = block_size;
+  } else if (capacity <= kDefaultLimit) {
+    capacity = capacity + kOverhead;
+  } else if (!IsPow2(capacity)) {
+    // Check if rounded up to next power 2 is a good enough fit
+    // with limited waste making it an acceptable direct fit.
+    const size_t rounded_up = size_t{1} << Log2Ceil(capacity);
+    const size_t slop = rounded_up - capacity;
+    if (slop >= kOverhead && slop <= kMaxPageSlop + kOverhead) {
+      capacity = rounded_up;
+    } else {
+      // Round down to highest power of 2 <= capacity.
+      // Consider a more aggressive step down if that may reduce the
+      // risk of fragmentation where 'people are holding it wrong'.
+      const size_t rounded_down = size_t{1} << Log2Floor(capacity);
+      capacity = rounded_down;
+    }
+  }
+  const size_t length = capacity - kOverhead;
+  auto* rep = CordRepFlat::New(CordRepFlat::Large(), length, hints...);
+  rep->length = 0;
+  return CordBuffer(rep);
+}
+
+inline CordBuffer CordBuffer::CreateWithCustomLimit(size_t block_size,
+                                                    size_t capacity) {
+  return CreateWithCustomLimitImpl(block_size, capacity);
+}
+
+inline CordBuffer::~CordBuffer() {
+  if (!rep_.is_short()) {
+    cord_internal::CordRepFlat::Delete(rep_.rep());
+  }
+}
+
+inline CordBuffer::CordBuffer(CordBuffer&& rhs) noexcept : rep_(rhs.rep_) {
+  rhs.rep_.set_short_length(0);
+}
+
+inline CordBuffer& CordBuffer::operator=(CordBuffer&& rhs) noexcept {
+  if (!rep_.is_short()) cord_internal::CordRepFlat::Delete(rep_.rep());
+  rep_ = rhs.rep_;
+  rhs.rep_.set_short_length(0);
+  return *this;
+}
+
+inline absl::Span<char> CordBuffer::available() {
+  return rep_.is_short() ? rep_.short_available() : rep_.long_available();
+}
+
+inline absl::Span<char> CordBuffer::available_up_to(size_t size) {
+  return available().subspan(0, size);
+}
+
+inline char* CordBuffer::data() {
+  return rep_.is_short() ? rep_.data() : rep_.rep()->Data();
+}
+
+inline const char* CordBuffer::data() const {
+  return rep_.is_short() ? rep_.data() : rep_.rep()->Data();
+}
+
+inline size_t CordBuffer::capacity() const {
+  return rep_.is_short() ? Rep::kInlineCapacity : rep_.rep()->Capacity();
+}
+
+inline size_t CordBuffer::length() const {
+  return rep_.is_short() ? rep_.short_length() : rep_.rep()->length;
+}
+
+inline void CordBuffer::SetLength(size_t length) {
+  ABSL_HARDENING_ASSERT(length <= capacity());
+  if (rep_.is_short()) {
+    rep_.set_short_length(length);
+  } else {
+    rep_.rep()->length = length;
+  }
+}
+
+inline void CordBuffer::IncreaseLengthBy(size_t n) {
+  ABSL_HARDENING_ASSERT(n <= capacity() && length() + n <= capacity());
+  if (rep_.is_short()) {
+    rep_.add_short_length(n);
+  } else {
+    rep_.rep()->length += n;
+  }
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CORD_BUFFER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cord_test_helpers.h b/CAPI/cpp/grpc/include/absl/strings/cord_test_helpers.h
new file mode 100644
index 0000000..31a1dc8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/cord_test_helpers.h
@@ -0,0 +1,122 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_STRINGS_CORD_TEST_HELPERS_H_
+#define ABSL_STRINGS_CORD_TEST_HELPERS_H_
+
+#include <cstdint>
+#include <iostream>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Cord sizes relevant for testing
+enum class TestCordSize {
+  // An empty value
+  kEmpty = 0,
+
+  // An inlined string value
+  kInlined = cord_internal::kMaxInline / 2 + 1,
+
+  // 'Well known' SSO lengths (excluding terminating zero).
+  // libstdcxx has a maximum SSO of 15, libc++ has a maximum SSO of 22.
+  kStringSso1 = 15,
+  kStringSso2 = 22,
+
+  // A string value which is too large to fit in inlined data, but small enough
+  // such that Cord prefers copying the value if possible, i.e.: not stealing
+  // std::string inputs, or referencing existing CordReps on Append, etc.
+  kSmall = cord_internal::kMaxBytesToCopy / 2 + 1,
+
+  // A string value large enough that Cord prefers to reference or steal from
+  // existing inputs rather than copying contents of the input.
+  kMedium = cord_internal::kMaxFlatLength / 2 + 1,
+
+  // A string value large enough to cause it to be stored in mutliple flats.
+  kLarge = cord_internal::kMaxFlatLength * 4
+};
+
+// To string helper
+inline absl::string_view ToString(TestCordSize size) {
+  switch (size) {
+    case TestCordSize::kEmpty:
+      return "Empty";
+    case TestCordSize::kInlined:
+      return "Inlined";
+    case TestCordSize::kSmall:
+      return "Small";
+    case TestCordSize::kStringSso1:
+      return "StringSso1";
+    case TestCordSize::kStringSso2:
+      return "StringSso2";
+    case TestCordSize::kMedium:
+      return "Medium";
+    case TestCordSize::kLarge:
+      return "Large";
+  }
+  return "???";
+}
+
+// Returns the length matching the specified size
+inline size_t Length(TestCordSize size) { return static_cast<size_t>(size); }
+
+// Stream output helper
+inline std::ostream& operator<<(std::ostream& stream, TestCordSize size) {
+  return stream << ToString(size);
+}
+
+// Creates a multi-segment Cord from an iterable container of strings.  The
+// resulting Cord is guaranteed to have one segment for every string in the
+// container.  This allows code to be unit tested with multi-segment Cord
+// inputs.
+//
+// Example:
+//
+//   absl::Cord c = absl::MakeFragmentedCord({"A ", "fragmented ", "Cord"});
+//   EXPECT_FALSE(c.GetFlat(&unused));
+//
+// The mechanism by which this Cord is created is an implementation detail.  Any
+// implementation that produces a multi-segment Cord may produce a flat Cord in
+// the future as new optimizations are added to the Cord class.
+// MakeFragmentedCord will, however, always be updated to return a multi-segment
+// Cord.
+template <typename Container>
+Cord MakeFragmentedCord(const Container& c) {
+  Cord result;
+  for (const auto& s : c) {
+    auto* external = new std::string(s);
+    Cord tmp = absl::MakeCordFromExternal(
+        *external, [external](absl::string_view) { delete external; });
+    tmp.Prepend(result);
+    result = tmp;
+  }
+  return result;
+}
+
+inline Cord MakeFragmentedCord(std::initializer_list<absl::string_view> list) {
+  return MakeFragmentedCord<std::initializer_list<absl::string_view>>(list);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CORD_TEST_HELPERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cordz_test_helpers.h b/CAPI/cpp/grpc/include/absl/strings/cordz_test_helpers.h
new file mode 100644
index 0000000..e410eec
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/cordz_test_helpers.h
@@ -0,0 +1,151 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
+#define ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
+
+#include <utility>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cordz_info.h"
+#include "absl/strings/internal/cordz_sample_token.h"
+#include "absl/strings/internal/cordz_statistics.h"
+#include "absl/strings/internal/cordz_update_tracker.h"
+#include "absl/strings/str_cat.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Returns the CordzInfo for the cord, or nullptr if the cord is not sampled.
+inline const cord_internal::CordzInfo* GetCordzInfoForTesting(
+    const Cord& cord) {
+  if (!cord.contents_.is_tree()) return nullptr;
+  return cord.contents_.cordz_info();
+}
+
+// Returns true if the provided cordz_info is in the list of sampled cords.
+inline bool CordzInfoIsListed(const cord_internal::CordzInfo* cordz_info,
+                              cord_internal::CordzSampleToken token = {}) {
+  for (const cord_internal::CordzInfo& info : token) {
+    if (cordz_info == &info) return true;
+  }
+  return false;
+}
+
+// Matcher on Cord that verifies all of:
+// - the cord is sampled
+// - the CordzInfo of the cord is listed / discoverable.
+// - the reported CordzStatistics match the cord's actual properties
+// - the cord has an (initial) UpdateTracker count of 1 for `method`
+MATCHER_P(HasValidCordzInfoOf, method, "CordzInfo matches cord") {
+  const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
+  if (cord_info == nullptr) {
+    *result_listener << "cord is not sampled";
+    return false;
+  }
+  if (!CordzInfoIsListed(cord_info)) {
+    *result_listener << "cord is sampled, but not listed";
+    return false;
+  }
+  cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
+  if (stat.size != arg.size()) {
+    *result_listener << "cordz size " << stat.size
+                     << " does not match cord size " << arg.size();
+    return false;
+  }
+  if (stat.update_tracker.Value(method) != 1) {
+    *result_listener << "Expected method count 1 for " << method << ", found "
+                     << stat.update_tracker.Value(method);
+    return false;
+  }
+  return true;
+}
+
+// Matcher on Cord that verifies that the cord is sampled and that the CordzInfo
+// update tracker has 'method' with a call count of 'n'
+MATCHER_P2(CordzMethodCountEq, method, n,
+           absl::StrCat("CordzInfo method count equals ", n)) {
+  const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
+  if (cord_info == nullptr) {
+    *result_listener << "cord is not sampled";
+    return false;
+  }
+  cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
+  if (stat.update_tracker.Value(method) != n) {
+    *result_listener << "Expected method count " << n << " for " << method
+                     << ", found " << stat.update_tracker.Value(method);
+    return false;
+  }
+  return true;
+}
+
+// Cordz will only update with a new rate once the previously scheduled event
+// has fired. When we disable Cordz, a long delay takes place where we won't
+// consider profiling new Cords. CordzSampleIntervalHelper will burn through
+// that interval and allow for testing that assumes that the average sampling
+// interval is a particular value.
+class CordzSamplingIntervalHelper {
+ public:
+  explicit CordzSamplingIntervalHelper(int32_t interval)
+      : orig_mean_interval_(absl::cord_internal::get_cordz_mean_interval()) {
+    absl::cord_internal::set_cordz_mean_interval(interval);
+    absl::cord_internal::cordz_set_next_sample_for_testing(interval);
+  }
+
+  ~CordzSamplingIntervalHelper() {
+    absl::cord_internal::set_cordz_mean_interval(orig_mean_interval_);
+    absl::cord_internal::cordz_set_next_sample_for_testing(orig_mean_interval_);
+  }
+
+ private:
+  int32_t orig_mean_interval_;
+};
+
+// Wrapper struct managing a small CordRep `rep`
+struct TestCordRep {
+  cord_internal::CordRepFlat* rep;
+
+  TestCordRep() {
+    rep = cord_internal::CordRepFlat::New(100);
+    rep->length = 100;
+    memset(rep->Data(), 1, 100);
+  }
+  ~TestCordRep() { cord_internal::CordRep::Unref(rep); }
+};
+
+// Wrapper struct managing a small CordRep `rep`, and
+// an InlineData `data` initialized with that CordRep.
+struct TestCordData {
+  TestCordRep rep;
+  cord_internal::InlineData data{rep.rep};
+};
+
+// Creates a Cord that is not sampled
+template <typename... Args>
+Cord UnsampledCord(Args... args) {
+  CordzSamplingIntervalHelper never(9999);
+  Cord cord(std::forward<Args>(args)...);
+  ABSL_ASSERT(GetCordzInfoForTesting(cord) == nullptr);
+  return cord;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/escaping.h b/CAPI/cpp/grpc/include/absl/strings/escaping.h
new file mode 100644
index 0000000..f5ca26c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/escaping.h
@@ -0,0 +1,164 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: escaping.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains string utilities involved in escaping and
+// unescaping strings in various ways.
+
+#ifndef ABSL_STRINGS_ESCAPING_H_
+#define ABSL_STRINGS_ESCAPING_H_
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// CUnescape()
+//
+// Unescapes a `source` string and copies it into `dest`, rewriting C-style
+// escape sequences (https://en.cppreference.com/w/cpp/language/escape) into
+// their proper code point equivalents, returning `true` if successful.
+//
+// The following unescape sequences can be handled:
+//
+//   * ASCII escape sequences ('\n','\r','\\', etc.) to their ASCII equivalents
+//   * Octal escape sequences ('\nnn') to byte nnn. The unescaped value must
+//     resolve to a single byte or an error will occur. E.g. values greater than
+//     0xff will produce an error.
+//   * Hexadecimal escape sequences ('\xnn') to byte nn. While an arbitrary
+//     number of following digits are allowed, the unescaped value must resolve
+//     to a single byte or an error will occur. E.g. '\x0045' is equivalent to
+//     '\x45', but '\x1234' will produce an error.
+//   * Unicode escape sequences ('\unnnn' for exactly four hex digits or
+//     '\Unnnnnnnn' for exactly eight hex digits, which will be encoded in
+//     UTF-8. (E.g., `\u2019` unescapes to the three bytes 0xE2, 0x80, and
+//     0x99).
+//
+// If any errors are encountered, this function returns `false`, leaving the
+// `dest` output parameter in an unspecified state, and stores the first
+// encountered error in `error`. To disable error reporting, set `error` to
+// `nullptr` or use the overload with no error reporting below.
+//
+// Example:
+//
+//   std::string s = "foo\\rbar\\nbaz\\t";
+//   std::string unescaped_s;
+//   if (!absl::CUnescape(s, &unescaped_s) {
+//     ...
+//   }
+//   EXPECT_EQ(unescaped_s, "foo\rbar\nbaz\t");
+bool CUnescape(absl::string_view source, std::string* dest, std::string* error);
+
+// Overload of `CUnescape()` with no error reporting.
+inline bool CUnescape(absl::string_view source, std::string* dest) {
+  return CUnescape(source, dest, nullptr);
+}
+
+// CEscape()
+//
+// Escapes a 'src' string using C-style escapes sequences
+// (https://en.cppreference.com/w/cpp/language/escape), escaping other
+// non-printable/non-whitespace bytes as octal sequences (e.g. "\377").
+//
+// Example:
+//
+//   std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
+//   std::string escaped_s = absl::CEscape(s);
+//   EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\010\\t\\n\\013\\014\\r\\n");
+std::string CEscape(absl::string_view src);
+
+// CHexEscape()
+//
+// Escapes a 'src' string using C-style escape sequences, escaping
+// other non-printable/non-whitespace bytes as hexadecimal sequences (e.g.
+// "\xFF").
+//
+// Example:
+//
+//   std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
+//   std::string escaped_s = absl::CHexEscape(s);
+//   EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\x08\\t\\n\\x0b\\x0c\\r\\n");
+std::string CHexEscape(absl::string_view src);
+
+// Utf8SafeCEscape()
+//
+// Escapes a 'src' string using C-style escape sequences, escaping bytes as
+// octal sequences, and passing through UTF-8 characters without conversion.
+// I.e., when encountering any bytes with their high bit set, this function
+// will not escape those values, whether or not they are valid UTF-8.
+std::string Utf8SafeCEscape(absl::string_view src);
+
+// Utf8SafeCHexEscape()
+//
+// Escapes a 'src' string using C-style escape sequences, escaping bytes as
+// hexadecimal sequences, and passing through UTF-8 characters without
+// conversion.
+std::string Utf8SafeCHexEscape(absl::string_view src);
+
+// Base64Unescape()
+//
+// Converts a `src` string encoded in Base64 to its binary equivalent, writing
+// it to a `dest` buffer, returning `true` on success. If `src` contains invalid
+// characters, `dest` is cleared and returns `false`.
+bool Base64Unescape(absl::string_view src, std::string* dest);
+
+// WebSafeBase64Unescape()
+//
+// Converts a `src` string encoded in Base64 to its binary equivalent, writing
+// it to a `dest` buffer, but using '-' instead of '+', and '_' instead of '/'.
+// If `src` contains invalid characters, `dest` is cleared and returns `false`.
+bool WebSafeBase64Unescape(absl::string_view src, std::string* dest);
+
+// Base64Escape()
+//
+// Encodes a `src` string into a base64-encoded string, with padding characters.
+// This function conforms with RFC 4648 section 4 (base64).
+void Base64Escape(absl::string_view src, std::string* dest);
+std::string Base64Escape(absl::string_view src);
+
+// WebSafeBase64Escape()
+//
+// Encodes a `src` string into a base64-like string, using '-' instead of '+'
+// and '_' instead of '/', and without padding. This function conforms with RFC
+// 4648 section 5 (base64url).
+void WebSafeBase64Escape(absl::string_view src, std::string* dest);
+std::string WebSafeBase64Escape(absl::string_view src);
+
+// HexStringToBytes()
+//
+// Converts an ASCII hex string into bytes, returning binary data of length
+// `from.size()/2`.
+std::string HexStringToBytes(absl::string_view from);
+
+// BytesToHexString()
+//
+// Converts binary data into an ASCII text string, returning a string of size
+// `2*from.size()`.
+std::string BytesToHexString(absl::string_view from);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_ESCAPING_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/char_map.h b/CAPI/cpp/grpc/include/absl/strings/internal/char_map.h
new file mode 100644
index 0000000..61484de
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/char_map.h
@@ -0,0 +1,156 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Character Map Class
+//
+// A fast, bit-vector map for 8-bit unsigned characters.
+// This class is useful for non-character purposes as well.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+#define ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+class Charmap {
+ public:
+  constexpr Charmap() : m_() {}
+
+  // Initializes with a given char*.  Note that NUL is not treated as
+  // a terminator, but rather a char to be flicked.
+  Charmap(const char* str, int len) : m_() {
+    while (len--) SetChar(*str++);
+  }
+
+  // Initializes with a given char*.  NUL is treated as a terminator
+  // and will not be in the charmap.
+  explicit Charmap(const char* str) : m_() {
+    while (*str) SetChar(*str++);
+  }
+
+  constexpr bool contains(unsigned char c) const {
+    return (m_[c / 64] >> (c % 64)) & 0x1;
+  }
+
+  // Returns true if and only if a character exists in both maps.
+  bool IntersectsWith(const Charmap& c) const {
+    for (size_t i = 0; i < ABSL_ARRAYSIZE(m_); ++i) {
+      if ((m_[i] & c.m_[i]) != 0) return true;
+    }
+    return false;
+  }
+
+  bool IsZero() const {
+    for (uint64_t c : m_) {
+      if (c != 0) return false;
+    }
+    return true;
+  }
+
+  // Containing only a single specified char.
+  static constexpr Charmap Char(char x) {
+    return Charmap(CharMaskForWord(x, 0), CharMaskForWord(x, 1),
+                   CharMaskForWord(x, 2), CharMaskForWord(x, 3));
+  }
+
+  // Containing all the chars in the C-string 's'.
+  // Note that this is expensively recursive because of the C++11 constexpr
+  // formulation. Use only in constexpr initializers.
+  static constexpr Charmap FromString(const char* s) {
+    return *s == 0 ? Charmap() : (Char(*s) | FromString(s + 1));
+  }
+
+  // Containing all the chars in the closed interval [lo,hi].
+  static constexpr Charmap Range(char lo, char hi) {
+    return Charmap(RangeForWord(lo, hi, 0), RangeForWord(lo, hi, 1),
+                   RangeForWord(lo, hi, 2), RangeForWord(lo, hi, 3));
+  }
+
+  friend constexpr Charmap operator&(const Charmap& a, const Charmap& b) {
+    return Charmap(a.m_[0] & b.m_[0], a.m_[1] & b.m_[1], a.m_[2] & b.m_[2],
+                   a.m_[3] & b.m_[3]);
+  }
+
+  friend constexpr Charmap operator|(const Charmap& a, const Charmap& b) {
+    return Charmap(a.m_[0] | b.m_[0], a.m_[1] | b.m_[1], a.m_[2] | b.m_[2],
+                   a.m_[3] | b.m_[3]);
+  }
+
+  friend constexpr Charmap operator~(const Charmap& a) {
+    return Charmap(~a.m_[0], ~a.m_[1], ~a.m_[2], ~a.m_[3]);
+  }
+
+ private:
+  constexpr Charmap(uint64_t b0, uint64_t b1, uint64_t b2, uint64_t b3)
+      : m_{b0, b1, b2, b3} {}
+
+  static constexpr uint64_t RangeForWord(unsigned char lo, unsigned char hi,
+                                         uint64_t word) {
+    return OpenRangeFromZeroForWord(hi + 1, word) &
+           ~OpenRangeFromZeroForWord(lo, word);
+  }
+
+  // All the chars in the specified word of the range [0, upper).
+  static constexpr uint64_t OpenRangeFromZeroForWord(uint64_t upper,
+                                                     uint64_t word) {
+    return (upper <= 64 * word)
+               ? 0
+               : (upper >= 64 * (word + 1))
+                     ? ~static_cast<uint64_t>(0)
+                     : (~static_cast<uint64_t>(0) >> (64 - upper % 64));
+  }
+
+  static constexpr uint64_t CharMaskForWord(unsigned char x, uint64_t word) {
+    return (x / 64 == word) ? (static_cast<uint64_t>(1) << (x % 64)) : 0;
+  }
+
+ private:
+  void SetChar(unsigned char c) {
+    m_[c / 64] |= static_cast<uint64_t>(1) << (c % 64);
+  }
+
+  uint64_t m_[4];
+};
+
+// Mirror the char-classifying predicates in <cctype>
+constexpr Charmap UpperCharmap() { return Charmap::Range('A', 'Z'); }
+constexpr Charmap LowerCharmap() { return Charmap::Range('a', 'z'); }
+constexpr Charmap DigitCharmap() { return Charmap::Range('0', '9'); }
+constexpr Charmap AlphaCharmap() { return LowerCharmap() | UpperCharmap(); }
+constexpr Charmap AlnumCharmap() { return DigitCharmap() | AlphaCharmap(); }
+constexpr Charmap XDigitCharmap() {
+  return DigitCharmap() | Charmap::Range('A', 'F') | Charmap::Range('a', 'f');
+}
+constexpr Charmap PrintCharmap() { return Charmap::Range(0x20, 0x7e); }
+constexpr Charmap SpaceCharmap() { return Charmap::FromString("\t\n\v\f\r "); }
+constexpr Charmap CntrlCharmap() {
+  return Charmap::Range(0, 0x7f) & ~PrintCharmap();
+}
+constexpr Charmap BlankCharmap() { return Charmap::FromString("\t "); }
+constexpr Charmap GraphCharmap() { return PrintCharmap() & ~SpaceCharmap(); }
+constexpr Charmap PunctCharmap() { return GraphCharmap() & ~AlnumCharmap(); }
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/charconv_bigint.h b/CAPI/cpp/grpc/include/absl/strings/internal/charconv_bigint.h
new file mode 100644
index 0000000..8f70297
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/charconv_bigint.h
@@ -0,0 +1,423 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+#define ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/internal/charconv_parse.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// The largest power that 5 that can be raised to, and still fit in a uint32_t.
+constexpr int kMaxSmallPowerOfFive = 13;
+// The largest power that 10 that can be raised to, and still fit in a uint32_t.
+constexpr int kMaxSmallPowerOfTen = 9;
+
+ABSL_DLL extern const uint32_t
+    kFiveToNth[kMaxSmallPowerOfFive + 1];
+ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
+
+// Large, fixed-width unsigned integer.
+//
+// Exact rounding for decimal-to-binary floating point conversion requires very
+// large integer math, but a design goal of absl::from_chars is to avoid
+// allocating memory.  The integer precision needed for decimal-to-binary
+// conversions is large but bounded, so a huge fixed-width integer class
+// suffices.
+//
+// This is an intentionally limited big integer class.  Only needed operations
+// are implemented.  All storage lives in an array data member, and all
+// arithmetic is done in-place, to avoid requiring separate storage for operand
+// and result.
+//
+// This is an internal class.  Some methods live in the .cc file, and are
+// instantiated only for the values of max_words we need.
+template <int max_words>
+class BigUnsigned {
+ public:
+  static_assert(max_words == 4 || max_words == 84,
+                "unsupported max_words value");
+
+  BigUnsigned() : size_(0), words_{} {}
+  explicit constexpr BigUnsigned(uint64_t v)
+      : size_((v >> 32) ? 2 : v ? 1 : 0),
+        words_{static_cast<uint32_t>(v & 0xffffffffu),
+               static_cast<uint32_t>(v >> 32)} {}
+
+  // Constructs a BigUnsigned from the given string_view containing a decimal
+  // value.  If the input string is not a decimal integer, constructs a 0
+  // instead.
+  explicit BigUnsigned(absl::string_view sv) : size_(0), words_{} {
+    // Check for valid input, returning a 0 otherwise.  This is reasonable
+    // behavior only because this constructor is for unit tests.
+    if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() ||
+        sv.empty()) {
+      return;
+    }
+    int exponent_adjust =
+        ReadDigits(sv.data(), sv.data() + sv.size(), Digits10() + 1);
+    if (exponent_adjust > 0) {
+      MultiplyByTenToTheNth(exponent_adjust);
+    }
+  }
+
+  // Loads the mantissa value of a previously-parsed float.
+  //
+  // Returns the associated decimal exponent.  The value of the parsed float is
+  // exactly *this * 10**exponent.
+  int ReadFloatMantissa(const ParsedFloat& fp, int significant_digits);
+
+  // Returns the number of decimal digits of precision this type provides.  All
+  // numbers with this many decimal digits or fewer are representable by this
+  // type.
+  //
+  // Analagous to std::numeric_limits<BigUnsigned>::digits10.
+  static constexpr int Digits10() {
+    // 9975007/1035508 is very slightly less than log10(2**32).
+    return static_cast<uint64_t>(max_words) * 9975007 / 1035508;
+  }
+
+  // Shifts left by the given number of bits.
+  void ShiftLeft(int count) {
+    if (count > 0) {
+      const int word_shift = count / 32;
+      if (word_shift >= max_words) {
+        SetToZero();
+        return;
+      }
+      size_ = (std::min)(size_ + word_shift, max_words);
+      count %= 32;
+      if (count == 0) {
+        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
+      } else {
+        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
+          words_[i] = (words_[i - word_shift] << count) |
+                      (words_[i - word_shift - 1] >> (32 - count));
+        }
+        words_[word_shift] = words_[0] << count;
+        // Grow size_ if necessary.
+        if (size_ < max_words && words_[size_]) {
+          ++size_;
+        }
+      }
+      std::fill(words_, words_ + word_shift, 0u);
+    }
+  }
+
+
+  // Multiplies by v in-place.
+  void MultiplyBy(uint32_t v) {
+    if (size_ == 0 || v == 1) {
+      return;
+    }
+    if (v == 0) {
+      SetToZero();
+      return;
+    }
+    const uint64_t factor = v;
+    uint64_t window = 0;
+    for (int i = 0; i < size_; ++i) {
+      window += factor * words_[i];
+      words_[i] = window & 0xffffffff;
+      window >>= 32;
+    }
+    // If carry bits remain and there's space for them, grow size_.
+    if (window && size_ < max_words) {
+      words_[size_] = window & 0xffffffff;
+      ++size_;
+    }
+  }
+
+  void MultiplyBy(uint64_t v) {
+    uint32_t words[2];
+    words[0] = static_cast<uint32_t>(v);
+    words[1] = static_cast<uint32_t>(v >> 32);
+    if (words[1] == 0) {
+      MultiplyBy(words[0]);
+    } else {
+      MultiplyBy(2, words);
+    }
+  }
+
+  // Multiplies in place by 5 to the power of n.  n must be non-negative.
+  void MultiplyByFiveToTheNth(int n) {
+    while (n >= kMaxSmallPowerOfFive) {
+      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
+      n -= kMaxSmallPowerOfFive;
+    }
+    if (n > 0) {
+      MultiplyBy(kFiveToNth[n]);
+    }
+  }
+
+  // Multiplies in place by 10 to the power of n.  n must be non-negative.
+  void MultiplyByTenToTheNth(int n) {
+    if (n > kMaxSmallPowerOfTen) {
+      // For large n, raise to a power of 5, then shift left by the same amount.
+      // (10**n == 5**n * 2**n.)  This requires fewer multiplications overall.
+      MultiplyByFiveToTheNth(n);
+      ShiftLeft(n);
+    } else if (n > 0) {
+      // We can do this more quickly for very small N by using a single
+      // multiplication.
+      MultiplyBy(kTenToNth[n]);
+    }
+  }
+
+  // Returns the value of 5**n, for non-negative n.  This implementation uses
+  // a lookup table, and is faster then seeding a BigUnsigned with 1 and calling
+  // MultiplyByFiveToTheNth().
+  static BigUnsigned FiveToTheNth(int n);
+
+  // Multiplies by another BigUnsigned, in-place.
+  template <int M>
+  void MultiplyBy(const BigUnsigned<M>& other) {
+    MultiplyBy(other.size(), other.words());
+  }
+
+  void SetToZero() {
+    std::fill(words_, words_ + size_, 0u);
+    size_ = 0;
+  }
+
+  // Returns the value of the nth word of this BigUnsigned.  This is
+  // range-checked, and returns 0 on out-of-bounds accesses.
+  uint32_t GetWord(int index) const {
+    if (index < 0 || index >= size_) {
+      return 0;
+    }
+    return words_[index];
+  }
+
+  // Returns this integer as a decimal string.  This is not used in the decimal-
+  // to-binary conversion; it is intended to aid in testing.
+  std::string ToString() const;
+
+  int size() const { return size_; }
+  const uint32_t* words() const { return words_; }
+
+ private:
+  // Reads the number between [begin, end), possibly containing a decimal point,
+  // into this BigUnsigned.
+  //
+  // Callers are required to ensure [begin, end) contains a valid number, with
+  // one or more decimal digits and at most one decimal point.  This routine
+  // will behave unpredictably if these preconditions are not met.
+  //
+  // Only the first `significant_digits` digits are read.  Digits beyond this
+  // limit are "sticky": If the final significant digit is 0 or 5, and if any
+  // dropped digit is nonzero, then that final significant digit is adjusted up
+  // to 1 or 6.  This adjustment allows for precise rounding.
+  //
+  // Returns `exponent_adjustment`, a power-of-ten exponent adjustment to
+  // account for the decimal point and for dropped significant digits.  After
+  // this function returns,
+  //   actual_value_of_parsed_string ~= *this * 10**exponent_adjustment.
+  int ReadDigits(const char* begin, const char* end, int significant_digits);
+
+  // Performs a step of big integer multiplication.  This computes the full
+  // (64-bit-wide) values that should be added at the given index (step), and
+  // adds to that location in-place.
+  //
+  // Because our math all occurs in place, we must multiply starting from the
+  // highest word working downward.  (This is a bit more expensive due to the
+  // extra carries involved.)
+  //
+  // This must be called in steps, for each word to be calculated, starting from
+  // the high end and working down to 0.  The first value of `step` should be
+  //   `std::min(original_size + other.size_ - 2, max_words - 1)`.
+  // The reason for this expression is that multiplying the i'th word from one
+  // multiplicand and the j'th word of another multiplicand creates a
+  // two-word-wide value to be stored at the (i+j)'th element.  The highest
+  // word indices we will access are `original_size - 1` from this object, and
+  // `other.size_ - 1` from our operand.  Therefore,
+  // `original_size + other.size_ - 2` is the first step we should calculate,
+  // but limited on an upper bound by max_words.
+
+  // Working from high-to-low ensures that we do not overwrite the portions of
+  // the initial value of *this which are still needed for later steps.
+  //
+  // Once called with step == 0, *this contains the result of the
+  // multiplication.
+  //
+  // `original_size` is the size_ of *this before the first call to
+  // MultiplyStep().  `other_words` and `other_size` are the contents of our
+  // operand.  `step` is the step to perform, as described above.
+  void MultiplyStep(int original_size, const uint32_t* other_words,
+                    int other_size, int step);
+
+  void MultiplyBy(int other_size, const uint32_t* other_words) {
+    const int original_size = size_;
+    const int first_step =
+        (std::min)(original_size + other_size - 2, max_words - 1);
+    for (int step = first_step; step >= 0; --step) {
+      MultiplyStep(original_size, other_words, other_size, step);
+    }
+  }
+
+  // Adds a 32-bit value to the index'th word, with carry.
+  void AddWithCarry(int index, uint32_t value) {
+    if (value) {
+      while (index < max_words && value > 0) {
+        words_[index] += value;
+        // carry if we overflowed in this word:
+        if (value > words_[index]) {
+          value = 1;
+          ++index;
+        } else {
+          value = 0;
+        }
+      }
+      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
+    }
+  }
+
+  void AddWithCarry(int index, uint64_t value) {
+    if (value && index < max_words) {
+      uint32_t high = value >> 32;
+      uint32_t low = value & 0xffffffff;
+      words_[index] += low;
+      if (words_[index] < low) {
+        ++high;
+        if (high == 0) {
+          // Carry from the low word caused our high word to overflow.
+          // Short circuit here to do the right thing.
+          AddWithCarry(index + 2, static_cast<uint32_t>(1));
+          return;
+        }
+      }
+      if (high > 0) {
+        AddWithCarry(index + 1, high);
+      } else {
+        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
+        // it when `high` is 0, do it ourselves here.
+        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
+      }
+    }
+  }
+
+  // Divide this in place by a constant divisor.  Returns the remainder of the
+  // division.
+  template <uint32_t divisor>
+  uint32_t DivMod() {
+    uint64_t accumulator = 0;
+    for (int i = size_ - 1; i >= 0; --i) {
+      accumulator <<= 32;
+      accumulator += words_[i];
+      // accumulator / divisor will never overflow an int32_t in this loop
+      words_[i] = static_cast<uint32_t>(accumulator / divisor);
+      accumulator = accumulator % divisor;
+    }
+    while (size_ > 0 && words_[size_ - 1] == 0) {
+      --size_;
+    }
+    return static_cast<uint32_t>(accumulator);
+  }
+
+  // The number of elements in words_ that may carry significant values.
+  // All elements beyond this point are 0.
+  //
+  // When size_ is 0, this BigUnsigned stores the value 0.
+  // When size_ is nonzero, is *not* guaranteed that words_[size_ - 1] is
+  // nonzero.  This can occur due to overflow truncation.
+  // In particular, x.size_ != y.size_ does *not* imply x != y.
+  int size_;
+  uint32_t words_[max_words];
+};
+
+// Compares two big integer instances.
+//
+// Returns -1 if lhs < rhs, 0 if lhs == rhs, and 1 if lhs > rhs.
+template <int N, int M>
+int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  int limit = (std::max)(lhs.size(), rhs.size());
+  for (int i = limit - 1; i >= 0; --i) {
+    const uint32_t lhs_word = lhs.GetWord(i);
+    const uint32_t rhs_word = rhs.GetWord(i);
+    if (lhs_word < rhs_word) {
+      return -1;
+    } else if (lhs_word > rhs_word) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+template <int N, int M>
+bool operator==(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  int limit = (std::max)(lhs.size(), rhs.size());
+  for (int i = 0; i < limit; ++i) {
+    if (lhs.GetWord(i) != rhs.GetWord(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <int N, int M>
+bool operator!=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(lhs == rhs);
+}
+
+template <int N, int M>
+bool operator<(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return Compare(lhs, rhs) == -1;
+}
+
+template <int N, int M>
+bool operator>(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return rhs < lhs;
+}
+template <int N, int M>
+bool operator<=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(rhs < lhs);
+}
+template <int N, int M>
+bool operator>=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(lhs < rhs);
+}
+
+// Output operator for BigUnsigned, for testing purposes only.
+template <int N>
+std::ostream& operator<<(std::ostream& os, const BigUnsigned<N>& num) {
+  return os << num.ToString();
+}
+
+// Explicit instantiation declarations for the sizes of BigUnsigned that we
+// are using.
+//
+// For now, the choices of 4 and 84 are arbitrary; 4 is a small value that is
+// still bigger than an int128, and 84 is a large value we will want to use
+// in the from_chars implementation.
+//
+// Comments justifying the use of 84 belong in the from_chars implementation,
+// and will be added in a follow-up CL.
+extern template class BigUnsigned<4>;
+extern template class BigUnsigned<84>;
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/charconv_parse.h b/CAPI/cpp/grpc/include/absl/strings/internal/charconv_parse.h
new file mode 100644
index 0000000..505998b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/charconv_parse.h
@@ -0,0 +1,99 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+#define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/strings/charconv.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// Enum indicating whether a parsed float is a number or special value.
+enum class FloatType { kNumber, kInfinity, kNan };
+
+// The decomposed parts of a parsed `float` or `double`.
+struct ParsedFloat {
+  // Representation of the parsed mantissa, with the decimal point adjusted to
+  // make it an integer.
+  //
+  // During decimal scanning, this contains 19 significant digits worth of
+  // mantissa value.  If digits beyond this point are found, they
+  // are truncated, and if any of these dropped digits are nonzero, then
+  // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
+  // subrange_end).
+  //
+  // During hexadecimal scanning, this contains 15 significant hex digits worth
+  // of mantissa value.  Digits beyond this point are sticky -- they are
+  // truncated, but if any dropped digits are nonzero, the low bit of mantissa
+  // will be set.  (This allows for precise rounding, and avoids the need
+  // to store the full mantissa in [subrange_begin, subrange_end).)
+  uint64_t mantissa = 0;
+
+  // Floating point expontent.  This reflects any decimal point adjustments and
+  // any truncated digits from the mantissa.  The absolute value of the parsed
+  // number is represented by mantissa * (base ** exponent), where base==10 for
+  // decimal floats, and base==2 for hexadecimal floats.
+  int exponent = 0;
+
+  // The literal exponent value scanned from the input, or 0 if none was
+  // present.  This does not reflect any adjustments applied to mantissa.
+  int literal_exponent = 0;
+
+  // The type of number scanned.
+  FloatType type = FloatType::kNumber;
+
+  // When non-null, [subrange_begin, subrange_end) marks a range of characters
+  // that require further processing.  The meaning is dependent on float type.
+  // If type == kNumber and this is set, this is a "wide input": the input
+  // mantissa contained more than 19 digits.  The range contains the full
+  // mantissa.  It plus `literal_exponent` need to be examined to find the best
+  // floating point match.
+  // If type == kNan and this is set, the range marks the contents of a
+  // matched parenthesized character region after the NaN.
+  const char* subrange_begin = nullptr;
+  const char* subrange_end = nullptr;
+
+  // One-past-the-end of the successfully parsed region, or nullptr if no
+  // matching pattern was found.
+  const char* end = nullptr;
+};
+
+// Read the floating point number in the provided range, and populate
+// ParsedFloat accordingly.
+//
+// format_flags is a bitmask value specifying what patterns this API will match.
+// `scientific` and `fixed`  are honored per std::from_chars rules
+// ([utility.from.chars], C++17): if exactly one of these bits is set, then an
+// exponent is required, or dislallowed, respectively.
+//
+// Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is
+// *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat.
+template <int base>
+ParsedFloat ParseFloat(const char* begin, const char* end,
+                       absl::chars_format format_flags);
+
+extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
+                                           absl::chars_format format_flags);
+extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
+                                           absl::chars_format format_flags);
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_data_edge.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_data_edge.h
new file mode 100644
index 0000000..e18b33e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_data_edge.h
@@ -0,0 +1,63 @@
+// Copyright 2022 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_DATA_EDGE_H_
+#define ABSL_STRINGS_INTERNAL_CORD_DATA_EDGE_H_
+
+#include <cassert>
+#include <cstddef>
+
+#include "absl/base/config.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_flat.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// Returns true if the provided rep is a FLAT, EXTERNAL or a SUBSTRING node
+// holding a FLAT or EXTERNAL child rep. Requires `rep != nullptr`.
+inline bool IsDataEdge(const CordRep* edge) {
+  assert(edge != nullptr);
+
+  // The fast path is that `edge` is an EXTERNAL or FLAT node, making the below
+  // if a single, well predicted branch. We then repeat the FLAT or EXTERNAL
+  // check in the slow path of the SUBSTRING check to optimize for the hot path.
+  if (edge->tag == EXTERNAL || edge->tag >= FLAT) return true;
+  if (edge->tag == SUBSTRING) edge = edge->substring()->child;
+  return edge->tag == EXTERNAL || edge->tag >= FLAT;
+}
+
+// Returns the `absl::string_view` data reference for the provided data edge.
+// Requires 'IsDataEdge(edge) == true`.
+inline absl::string_view EdgeData(const CordRep* edge) {
+  assert(IsDataEdge(edge));
+
+  size_t offset = 0;
+  const size_t length = edge->length;
+  if (edge->IsSubstring()) {
+    offset = edge->substring()->start;
+    edge = edge->substring()->child;
+  }
+  return edge->tag >= FLAT
+             ? absl::string_view{edge->flat()->Data() + offset, length}
+             : absl::string_view{edge->external()->base + offset, length};
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_DATA_EDGE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_internal.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_internal.h
new file mode 100644
index 0000000..b50fb79
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_internal.h
@@ -0,0 +1,655 @@
+// Copyright 2021 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
+
+#include <atomic>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/endian.h"
+#include "absl/base/internal/invoke.h"
+#include "absl/base/optimization.h"
+#include "absl/container/internal/compressed_tuple.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// The overhead of a vtable is too much for Cord, so we roll our own subclasses
+// using only a single byte to differentiate classes from each other - the "tag"
+// byte.  Define the subclasses first so we can provide downcasting helper
+// functions in the base class.
+struct CordRep;
+struct CordRepConcat;
+struct CordRepExternal;
+struct CordRepFlat;
+struct CordRepSubstring;
+struct CordRepCrc;
+class CordRepRing;
+class CordRepBtree;
+
+class CordzInfo;
+
+// Default feature enable states for cord ring buffers
+enum CordFeatureDefaults {
+  kCordEnableRingBufferDefault = false,
+  kCordShallowSubcordsDefault = false
+};
+
+extern std::atomic<bool> cord_ring_buffer_enabled;
+extern std::atomic<bool> shallow_subcords_enabled;
+
+// `cord_btree_exhaustive_validation` can be set to force exhaustive validation
+// in debug assertions, and code that calls `IsValid()` explicitly. By default,
+// assertions should be relatively cheap and AssertValid() can easily lead to
+// O(n^2) complexity as recursive / full tree validation is O(n).
+extern std::atomic<bool> cord_btree_exhaustive_validation;
+
+inline void enable_cord_ring_buffer(bool enable) {
+  cord_ring_buffer_enabled.store(enable, std::memory_order_relaxed);
+}
+
+inline void enable_shallow_subcords(bool enable) {
+  shallow_subcords_enabled.store(enable, std::memory_order_relaxed);
+}
+
+enum Constants {
+  // The inlined size to use with absl::InlinedVector.
+  //
+  // Note: The InlinedVectors in this file (and in cord.h) do not need to use
+  // the same value for their inlined size. The fact that they do is historical.
+  // It may be desirable for each to use a different inlined size optimized for
+  // that InlinedVector's usage.
+  //
+  // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for
+  // the inlined vector size (47 exists for backward compatibility).
+  kInlinedVectorSize = 47,
+
+  // Prefer copying blocks of at most this size, otherwise reference count.
+  kMaxBytesToCopy = 511
+};
+
+// Emits a fatal error "Unexpected node type: xyz" and aborts the program.
+ABSL_ATTRIBUTE_NORETURN void LogFatalNodeType(CordRep* rep);
+
+// Compact class for tracking the reference count and state flags for CordRep
+// instances.  Data is stored in an atomic int32_t for compactness and speed.
+class RefcountAndFlags {
+ public:
+  constexpr RefcountAndFlags() : count_{kRefIncrement} {}
+  struct Immortal {};
+  explicit constexpr RefcountAndFlags(Immortal) : count_(kImmortalFlag) {}
+
+  // Increments the reference count. Imposes no memory ordering.
+  inline void Increment() {
+    count_.fetch_add(kRefIncrement, std::memory_order_relaxed);
+  }
+
+  // Asserts that the current refcount is greater than 0. If the refcount is
+  // greater than 1, decrements the reference count.
+  //
+  // Returns false if there are no references outstanding; true otherwise.
+  // Inserts barriers to ensure that state written before this method returns
+  // false will be visible to a thread that just observed this method returning
+  // false.  Always returns false when the immortal bit is set.
+  inline bool Decrement() {
+    int32_t refcount = count_.load(std::memory_order_acquire) & kRefcountMask;
+    assert(refcount > 0 || refcount & kImmortalFlag);
+    return refcount != kRefIncrement &&
+           (count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
+            kRefcountMask) != kRefIncrement;
+  }
+
+  // Same as Decrement but expect that refcount is greater than 1.
+  inline bool DecrementExpectHighRefcount() {
+    int32_t refcount =
+        count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
+        kRefcountMask;
+    assert(refcount > 0 || refcount & kImmortalFlag);
+    return refcount != kRefIncrement;
+  }
+
+  // Returns the current reference count using acquire semantics.
+  inline int32_t Get() const {
+    return count_.load(std::memory_order_acquire) >> kNumFlags;
+  }
+
+  // Returns whether the atomic integer is 1.
+  // If the reference count is used in the conventional way, a
+  // reference count of 1 implies that the current thread owns the
+  // reference and no other thread shares it.
+  // This call performs the test for a reference count of one, and
+  // performs the memory barrier needed for the owning thread
+  // to act on the object, knowing that it has exclusive access to the
+  // object.  Always returns false when the immortal bit is set.
+  inline bool IsOne() {
+    return (count_.load(std::memory_order_acquire) & kRefcountMask) ==
+           kRefIncrement;
+  }
+
+  bool IsImmortal() const {
+    return (count_.load(std::memory_order_relaxed) & kImmortalFlag) != 0;
+  }
+
+ private:
+  // We reserve the bottom bits for flags.
+  // kImmortalBit indicates that this entity should never be collected; it is
+  // used for the StringConstant constructor to avoid collecting immutable
+  // constant cords.
+  // kReservedFlag is reserved for future use.
+  enum Flags {
+    kNumFlags = 2,
+
+    kImmortalFlag = 0x1,
+    kReservedFlag = 0x2,
+    kRefIncrement = (1 << kNumFlags),
+
+    // Bitmask to use when checking refcount by equality.  This masks out
+    // all flags except kImmortalFlag, which is part of the refcount for
+    // purposes of equality.  (A refcount of 0 or 1 does not count as 0 or 1
+    // if the immortal bit is set.)
+    kRefcountMask = ~kReservedFlag,
+  };
+
+  std::atomic<int32_t> count_;
+};
+
+// Various representations that we allow
+enum CordRepKind {
+  UNUSED_0 = 0,
+  SUBSTRING = 1,
+  CRC = 2,
+  BTREE = 3,
+  RING = 4,
+  EXTERNAL = 5,
+
+  // We have different tags for different sized flat arrays,
+  // starting with FLAT, and limited to MAX_FLAT_TAG. The below values map to an
+  // allocated range of 32 bytes to 256 KB. The current granularity is:
+  // - 8 byte granularity for flat sizes in [32 - 512]
+  // - 64 byte granularity for flat sizes in (512 - 8KiB]
+  // - 4KiB byte granularity for flat sizes in (8KiB, 256 KiB]
+  // If a new tag is needed in the future, then 'FLAT' and 'MAX_FLAT_TAG' should
+  // be adjusted as well as the Tag <---> Size mapping logic so that FLAT still
+  // represents the minimum flat allocation size. (32 bytes as of now).
+  FLAT = 6,
+  MAX_FLAT_TAG = 248
+};
+
+// There are various locations where we want to check if some rep is a 'plain'
+// data edge, i.e. an external or flat rep. By having FLAT == EXTERNAL + 1, we
+// can perform this check in a single branch as 'tag >= EXTERNAL'
+// Likewise, we have some locations where we check for 'ring or external/flat',
+// so likewise align RING to EXTERNAL.
+// Note that we can leave this optimization to the compiler. The compiler will
+// DTRT when it sees a condition like `tag == EXTERNAL || tag >= FLAT`.
+static_assert(RING == BTREE + 1, "BTREE and RING not consecutive");
+static_assert(EXTERNAL == RING + 1, "BTREE and EXTERNAL not consecutive");
+static_assert(FLAT == EXTERNAL + 1, "EXTERNAL and FLAT not consecutive");
+
+struct CordRep {
+  // Result from an `extract edge` operation. Contains the (possibly changed)
+  // tree node as well as the extracted edge, or {tree, nullptr} if no edge
+  // could be extracted.
+  // On success, the returned `tree` value is null if `extracted` was the only
+  // data edge inside the tree, a data edge if there were only two data edges in
+  // the tree, or the (possibly new / smaller) remaining tree with the extracted
+  // data edge removed.
+  struct ExtractResult {
+    CordRep* tree;
+    CordRep* extracted;
+  };
+
+  CordRep() = default;
+  constexpr CordRep(RefcountAndFlags::Immortal immortal, size_t l)
+      : length(l), refcount(immortal), tag(EXTERNAL), storage{} {}
+
+  // The following three fields have to be less than 32 bytes since
+  // that is the smallest supported flat node size.
+  size_t length;
+  RefcountAndFlags refcount;
+  // If tag < FLAT, it represents CordRepKind and indicates the type of node.
+  // Otherwise, the node type is CordRepFlat and the tag is the encoded size.
+  uint8_t tag;
+
+  // `storage` provides two main purposes:
+  // - the starting point for FlatCordRep.Data() [flexible-array-member]
+  // - 3 bytes of additional storage for use by derived classes.
+  // The latter is used by CordrepConcat and CordRepBtree. CordRepConcat stores
+  // a 'depth' value in storage[0], and the (future) CordRepBtree class stores
+  // `height`, `begin` and `end` in the 3 entries. Otherwise we would need to
+  // allocate room for these in the derived class, as not all compilers reuse
+  // padding space from the base class (clang and gcc do, MSVC does not, etc)
+  uint8_t storage[3];
+
+  // Returns true if this instance's tag matches the requested type.
+  constexpr bool IsRing() const { return tag == RING; }
+  constexpr bool IsSubstring() const { return tag == SUBSTRING; }
+  constexpr bool IsCrc() const { return tag == CRC; }
+  constexpr bool IsExternal() const { return tag == EXTERNAL; }
+  constexpr bool IsFlat() const { return tag >= FLAT; }
+  constexpr bool IsBtree() const { return tag == BTREE; }
+
+  inline CordRepRing* ring();
+  inline const CordRepRing* ring() const;
+  inline CordRepSubstring* substring();
+  inline const CordRepSubstring* substring() const;
+  inline CordRepCrc* crc();
+  inline const CordRepCrc* crc() const;
+  inline CordRepExternal* external();
+  inline const CordRepExternal* external() const;
+  inline CordRepFlat* flat();
+  inline const CordRepFlat* flat() const;
+  inline CordRepBtree* btree();
+  inline const CordRepBtree* btree() const;
+
+  // --------------------------------------------------------------------
+  // Memory management
+
+  // Destroys the provided `rep`.
+  static void Destroy(CordRep* rep);
+
+  // Increments the reference count of `rep`.
+  // Requires `rep` to be a non-null pointer value.
+  static inline CordRep* Ref(CordRep* rep);
+
+  // Decrements the reference count of `rep`. Destroys rep if count reaches
+  // zero. Requires `rep` to be a non-null pointer value.
+  static inline void Unref(CordRep* rep);
+};
+
+struct CordRepSubstring : public CordRep {
+  size_t start;  // Starting offset of substring in child
+  CordRep* child;
+
+  // Creates a substring on `child`, adopting a reference on `child`.
+  // Requires `child` to be either a flat or external node, and `pos` and `n` to
+  // form a non-empty partial sub range of `'child`, i.e.:
+  // `n > 0 && n < length && n + pos <= length`
+  static inline CordRepSubstring* Create(CordRep* child, size_t pos, size_t n);
+
+  // Creates a substring of `rep`. Does not adopt a reference on `rep`.
+  // Requires `IsDataEdge(rep) && n > 0 && pos + n <= rep->length`.
+  // If `n == rep->length` then this method returns `CordRep::Ref(rep)`
+  // If `rep` is a substring of a flat or external node, then this method will
+  // return a new substring of that flat or external node with `pos` adjusted
+  // with the original `start` position.
+  static inline CordRep* Substring(CordRep* rep, size_t pos, size_t n);
+};
+
+// Type for function pointer that will invoke the releaser function and also
+// delete the `CordRepExternalImpl` corresponding to the passed in
+// `CordRepExternal`.
+using ExternalReleaserInvoker = void (*)(CordRepExternal*);
+
+// External CordReps are allocated together with a type erased releaser. The
+// releaser is stored in the memory directly following the CordRepExternal.
+struct CordRepExternal : public CordRep {
+  CordRepExternal() = default;
+  explicit constexpr CordRepExternal(absl::string_view str)
+      : CordRep(RefcountAndFlags::Immortal{}, str.size()),
+        base(str.data()),
+        releaser_invoker(nullptr) {}
+
+  const char* base;
+  // Pointer to function that knows how to call and destroy the releaser.
+  ExternalReleaserInvoker releaser_invoker;
+
+  // Deletes (releases) the external rep.
+  // Requires rep != nullptr and rep->IsExternal()
+  static void Delete(CordRep* rep);
+};
+
+struct Rank1 {};
+struct Rank0 : Rank1 {};
+
+template <typename Releaser, typename = ::absl::base_internal::invoke_result_t<
+                                 Releaser, absl::string_view>>
+void InvokeReleaser(Rank0, Releaser&& releaser, absl::string_view data) {
+  ::absl::base_internal::invoke(std::forward<Releaser>(releaser), data);
+}
+
+template <typename Releaser,
+          typename = ::absl::base_internal::invoke_result_t<Releaser>>
+void InvokeReleaser(Rank1, Releaser&& releaser, absl::string_view) {
+  ::absl::base_internal::invoke(std::forward<Releaser>(releaser));
+}
+
+// We use CompressedTuple so that we can benefit from EBCO.
+template <typename Releaser>
+struct CordRepExternalImpl
+    : public CordRepExternal,
+      public ::absl::container_internal::CompressedTuple<Releaser> {
+  // The extra int arg is so that we can avoid interfering with copy/move
+  // constructors while still benefitting from perfect forwarding.
+  template <typename T>
+  CordRepExternalImpl(T&& releaser, int)
+      : CordRepExternalImpl::CompressedTuple(std::forward<T>(releaser)) {
+    this->releaser_invoker = &Release;
+  }
+
+  ~CordRepExternalImpl() {
+    InvokeReleaser(Rank0{}, std::move(this->template get<0>()),
+                   absl::string_view(base, length));
+  }
+
+  static void Release(CordRepExternal* rep) {
+    delete static_cast<CordRepExternalImpl*>(rep);
+  }
+};
+
+inline CordRepSubstring* CordRepSubstring::Create(CordRep* child, size_t pos,
+                                                  size_t n) {
+  assert(child != nullptr);
+  assert(n > 0);
+  assert(n < child->length);
+  assert(pos < child->length);
+  assert(n <= child->length - pos);
+
+  // TODO(b/217376272): Harden internal logic.
+  // Move to strategical places inside the Cord logic and make this an assert.
+  if (ABSL_PREDICT_FALSE(!(child->IsExternal() || child->IsFlat()))) {
+    LogFatalNodeType(child);
+  }
+
+  CordRepSubstring* rep = new CordRepSubstring();
+  rep->length = n;
+  rep->tag = SUBSTRING;
+  rep->start = pos;
+  rep->child = child;
+  return rep;
+}
+
+inline CordRep* CordRepSubstring::Substring(CordRep* rep, size_t pos,
+                                            size_t n) {
+  assert(rep != nullptr);
+  assert(n != 0);
+  assert(pos < rep->length);
+  assert(n <= rep->length - pos);
+  if (n == rep->length) return CordRep::Ref(rep);
+  if (rep->IsSubstring()) {
+    pos += rep->substring()->start;
+    rep = rep->substring()->child;
+  }
+  CordRepSubstring* substr = new CordRepSubstring();
+  substr->length = n;
+  substr->tag = SUBSTRING;
+  substr->start = pos;
+  substr->child = CordRep::Ref(rep);
+  return substr;
+}
+
+inline void CordRepExternal::Delete(CordRep* rep) {
+  assert(rep != nullptr && rep->IsExternal());
+  auto* rep_external = static_cast<CordRepExternal*>(rep);
+  assert(rep_external->releaser_invoker != nullptr);
+  rep_external->releaser_invoker(rep_external);
+}
+
+template <typename Str>
+struct ConstInitExternalStorage {
+  ABSL_CONST_INIT static CordRepExternal value;
+};
+
+template <typename Str>
+ABSL_CONST_INIT CordRepExternal
+    ConstInitExternalStorage<Str>::value(Str::value);
+
+enum {
+  kMaxInline = 15,
+};
+
+constexpr char GetOrNull(absl::string_view data, size_t pos) {
+  return pos < data.size() ? data[pos] : '\0';
+}
+
+// We store cordz_info as 64 bit pointer value in big endian format. This
+// guarantees that the least significant byte of cordz_info matches the last
+// byte of the inline data representation in as_chars_, which holds the inlined
+// size or the 'is_tree' bit.
+using cordz_info_t = int64_t;
+
+// Assert that the `cordz_info` pointer value perfectly overlaps the last half
+// of `as_chars_` and can hold a pointer value.
+static_assert(sizeof(cordz_info_t) * 2 == kMaxInline + 1, "");
+static_assert(sizeof(cordz_info_t) >= sizeof(intptr_t), "");
+
+// BigEndianByte() creates a big endian representation of 'value', i.e.: a big
+// endian value where the last byte in the host's representation holds 'value`,
+// with all other bytes being 0.
+static constexpr cordz_info_t BigEndianByte(unsigned char value) {
+#if defined(ABSL_IS_BIG_ENDIAN)
+  return value;
+#else
+  return static_cast<cordz_info_t>(value) << ((sizeof(cordz_info_t) - 1) * 8);
+#endif
+}
+
+class InlineData {
+ public:
+  // DefaultInitType forces the use of the default initialization constructor.
+  enum DefaultInitType { kDefaultInit };
+
+  // kNullCordzInfo holds the big endian representation of intptr_t(1)
+  // This is the 'null' / initial value of 'cordz_info'. The null value
+  // is specifically big endian 1 as with 64-bit pointers, the last
+  // byte of cordz_info overlaps with the last byte holding the tag.
+  static constexpr cordz_info_t kNullCordzInfo = BigEndianByte(1);
+
+  constexpr InlineData() : as_chars_{0} {}
+  explicit InlineData(DefaultInitType) {}
+  explicit constexpr InlineData(CordRep* rep) : as_tree_(rep) {}
+  explicit constexpr InlineData(absl::string_view chars)
+      : as_chars_{
+            GetOrNull(chars, 0),  GetOrNull(chars, 1),
+            GetOrNull(chars, 2),  GetOrNull(chars, 3),
+            GetOrNull(chars, 4),  GetOrNull(chars, 5),
+            GetOrNull(chars, 6),  GetOrNull(chars, 7),
+            GetOrNull(chars, 8),  GetOrNull(chars, 9),
+            GetOrNull(chars, 10), GetOrNull(chars, 11),
+            GetOrNull(chars, 12), GetOrNull(chars, 13),
+            GetOrNull(chars, 14), static_cast<char>((chars.size() << 1))} {}
+
+  // Returns true if the current instance is empty.
+  // The 'empty value' is an inlined data value of zero length.
+  bool is_empty() const { return tag() == 0; }
+
+  // Returns true if the current instance holds a tree value.
+  bool is_tree() const { return (tag() & 1) != 0; }
+
+  // Returns true if the current instance holds a cordz_info value.
+  // Requires the current instance to hold a tree value.
+  bool is_profiled() const {
+    assert(is_tree());
+    return as_tree_.cordz_info != kNullCordzInfo;
+  }
+
+  // Returns true if either of the provided instances hold a cordz_info value.
+  // This method is more efficient than the equivalent `data1.is_profiled() ||
+  // data2.is_profiled()`. Requires both arguments to hold a tree.
+  static bool is_either_profiled(const InlineData& data1,
+                                 const InlineData& data2) {
+    assert(data1.is_tree() && data2.is_tree());
+    return (data1.as_tree_.cordz_info | data2.as_tree_.cordz_info) !=
+           kNullCordzInfo;
+  }
+
+  // Returns the cordz_info sampling instance for this instance, or nullptr
+  // if the current instance is not sampled and does not have CordzInfo data.
+  // Requires the current instance to hold a tree value.
+  CordzInfo* cordz_info() const {
+    assert(is_tree());
+    intptr_t info = static_cast<intptr_t>(
+        absl::big_endian::ToHost64(static_cast<uint64_t>(as_tree_.cordz_info)));
+    assert(info & 1);
+    return reinterpret_cast<CordzInfo*>(info - 1);
+  }
+
+  // Sets the current cordz_info sampling instance for this instance, or nullptr
+  // if the current instance is not sampled and does not have CordzInfo data.
+  // Requires the current instance to hold a tree value.
+  void set_cordz_info(CordzInfo* cordz_info) {
+    assert(is_tree());
+    uintptr_t info = reinterpret_cast<uintptr_t>(cordz_info) | 1;
+    as_tree_.cordz_info =
+        static_cast<cordz_info_t>(absl::big_endian::FromHost64(info));
+  }
+
+  // Resets the current cordz_info to null / empty.
+  void clear_cordz_info() {
+    assert(is_tree());
+    as_tree_.cordz_info = kNullCordzInfo;
+  }
+
+  // Returns a read only pointer to the character data inside this instance.
+  // Requires the current instance to hold inline data.
+  const char* as_chars() const {
+    assert(!is_tree());
+    return as_chars_;
+  }
+
+  // Returns a mutable pointer to the character data inside this instance.
+  // Should be used for 'write only' operations setting an inlined value.
+  // Applications can set the value of inlined data either before or after
+  // setting the inlined size, i.e., both of the below are valid:
+  //
+  //   // Set inlined data and inline size
+  //   memcpy(data_.as_chars(), data, size);
+  //   data_.set_inline_size(size);
+  //
+  //   // Set inlined size and inline data
+  //   data_.set_inline_size(size);
+  //   memcpy(data_.as_chars(), data, size);
+  //
+  // It's an error to read from the returned pointer without a preceding write
+  // if the current instance does not hold inline data, i.e.: is_tree() == true.
+  char* as_chars() { return as_chars_; }
+
+  // Returns the tree value of this value.
+  // Requires the current instance to hold a tree value.
+  CordRep* as_tree() const {
+    assert(is_tree());
+    return as_tree_.rep;
+  }
+
+  // Initialize this instance to holding the tree value `rep`,
+  // initializing the cordz_info to null, i.e.: 'not profiled'.
+  void make_tree(CordRep* rep) {
+    as_tree_.rep = rep;
+    as_tree_.cordz_info = kNullCordzInfo;
+  }
+
+  // Set the tree value of this instance to 'rep`.
+  // Requires the current instance to already hold a tree value.
+  // Does not affect the value of cordz_info.
+  void set_tree(CordRep* rep) {
+    assert(is_tree());
+    as_tree_.rep = rep;
+  }
+
+  // Returns the size of the inlined character data inside this instance.
+  // Requires the current instance to hold inline data.
+  size_t inline_size() const {
+    assert(!is_tree());
+    return tag() >> 1;
+  }
+
+  // Sets the size of the inlined character data inside this instance.
+  // Requires `size` to be <= kMaxInline.
+  // See the documentation on 'as_chars()' for more information and examples.
+  void set_inline_size(size_t size) {
+    ABSL_ASSERT(size <= kMaxInline);
+    tag() = static_cast<char>(size << 1);
+  }
+
+ private:
+  // See cordz_info_t for forced alignment and size of `cordz_info` details.
+  struct AsTree {
+    explicit constexpr AsTree(absl::cord_internal::CordRep* tree)
+        : rep(tree), cordz_info(kNullCordzInfo) {}
+    // This union uses up extra space so that whether rep is 32 or 64 bits,
+    // cordz_info will still start at the eighth byte, and the last
+    // byte of cordz_info will still be the last byte of InlineData.
+    union {
+      absl::cord_internal::CordRep* rep;
+      cordz_info_t unused_aligner;
+    };
+    cordz_info_t cordz_info;
+  };
+
+  char& tag() { return reinterpret_cast<char*>(this)[kMaxInline]; }
+  char tag() const { return reinterpret_cast<const char*>(this)[kMaxInline]; }
+
+  // If the data has length <= kMaxInline, we store it in `as_chars_`, and
+  // store the size in the last char of `as_chars_` shifted left + 1.
+  // Else we store it in a tree and store a pointer to that tree in
+  // `as_tree_.rep` and store a tag in `tagged_size`.
+  union {
+    char as_chars_[kMaxInline + 1];
+    AsTree as_tree_;
+  };
+};
+
+static_assert(sizeof(InlineData) == kMaxInline + 1, "");
+
+inline CordRepSubstring* CordRep::substring() {
+  assert(IsSubstring());
+  return static_cast<CordRepSubstring*>(this);
+}
+
+inline const CordRepSubstring* CordRep::substring() const {
+  assert(IsSubstring());
+  return static_cast<const CordRepSubstring*>(this);
+}
+
+inline CordRepExternal* CordRep::external() {
+  assert(IsExternal());
+  return static_cast<CordRepExternal*>(this);
+}
+
+inline const CordRepExternal* CordRep::external() const {
+  assert(IsExternal());
+  return static_cast<const CordRepExternal*>(this);
+}
+
+inline CordRep* CordRep::Ref(CordRep* rep) {
+  // ABSL_ASSUME is a workaround for
+  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105585
+  ABSL_ASSUME(rep != nullptr);
+  rep->refcount.Increment();
+  return rep;
+}
+
+inline void CordRep::Unref(CordRep* rep) {
+  assert(rep != nullptr);
+  // Expect refcount to be 0. Avoiding the cost of an atomic decrement should
+  // typically outweigh the cost of an extra branch checking for ref == 1.
+  if (ABSL_PREDICT_FALSE(!rep->refcount.DecrementExpectHighRefcount())) {
+    Destroy(rep);
+  }
+}
+
+}  // namespace cord_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree.h
new file mode 100644
index 0000000..2cbc09e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree.h
@@ -0,0 +1,924 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
+
+#include <cassert>
+#include <cstdint>
+#include <iosfwd>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/optimization.h"
+#include "absl/strings/internal/cord_data_edge.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_flat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+class CordRepBtreeNavigator;
+
+// CordRepBtree is as the name implies a btree implementation of a Cordrep tree.
+// Data is stored at the leaf level only, non leaf nodes contain down pointers
+// only. Allowed types of data edges are FLAT, EXTERNAL and SUBSTRINGs of FLAT
+// or EXTERNAL nodes. The implementation allows for data to be added to either
+// end of the tree only, it does not provide any 'insert' logic. This has the
+// benefit that we can expect good fill ratios: all nodes except the outer
+// 'legs' will have 100% fill ratios for trees built using Append/Prepend
+// methods. Merged trees will typically have a fill ratio well above 50% as in a
+// similar fashion, one side of the merged tree will typically have a 100% fill
+// ratio, and the 'open' end will average 50%. All operations are O(log(n)) or
+// better, and the tree never needs balancing.
+//
+// All methods accepting a CordRep* or CordRepBtree* adopt a reference on that
+// input unless explicitly stated otherwise. All functions returning a CordRep*
+// or CordRepBtree* instance transfer a reference back to the caller.
+// Simplified, callers both 'donate' and 'consume' a reference count on each
+// call, simplifying the API. An example of building a tree:
+//
+//   CordRepBtree* tree = CordRepBtree::Create(MakeFlat("Hello"));
+//   tree = CordRepBtree::Append(tree, MakeFlat("world"));
+//
+// In the above example, all inputs are consumed, making each call affecting
+// `tree` reference count neutral. The returned `tree` value can be different
+// from the input if the input is shared with other threads, or if the tree
+// grows in height, but callers typically never have to concern themselves with
+// that and trust that all methods DTRT at all times.
+class CordRepBtree : public CordRep {
+ public:
+  // EdgeType identifies `front` and `back` enum values.
+  // Various implementations in CordRepBtree such as `Add` and `Edge` are
+  // generic and templated on operating on either of the boundary edges.
+  // For more information on the possible edges contained in a CordRepBtree
+  // instance see the documentation for `edges_`.
+  enum class EdgeType { kFront, kBack };
+
+  // Convenience constants into `EdgeType`
+  static constexpr EdgeType kFront = EdgeType::kFront;
+  static constexpr EdgeType kBack = EdgeType::kBack;
+
+  // Maximum number of edges: based on experiments and performance data, we can
+  // pick suitable values resulting in optimum cacheline aligned values. The
+  // preferred values are based on 64-bit systems where we aim to align this
+  // class onto 64 bytes, i.e.:  6 = 64 bytes, 14 = 128 bytes, etc.
+  // TODO(b/192061034): experiment with alternative sizes.
+  static constexpr size_t kMaxCapacity = 6;
+
+  // Reasonable maximum height of the btree. We can expect a fill ratio of at
+  // least 50%: trees are always expanded at the front or back. Concatenating
+  // trees will then typically fold at the top most node, where the lower nodes
+  // are at least at capacity on one side of joined inputs. At a lower fill
+  // rate of 4 edges per node, we have capacity for ~16 million leaf nodes.
+  // We will fail / abort if an application ever exceeds this height, which
+  // should be extremely rare (near impossible) and be an indication of an
+  // application error: we do not assume it reasonable for any application to
+  // operate correctly with such monster trees.
+  // Another compelling reason for the number `12` is that any contextual stack
+  // required for navigation or insertion requires 12 words and 12 bytes, which
+  // fits inside 2 cache lines with some room to spare, and is reasonable as a
+  // local stack variable compared to Cord's current near 400 bytes stack use.
+  // The maximum `height` value of a node is then `kMaxDepth - 1` as node height
+  // values start with a value of 0 for leaf nodes.
+  static constexpr int kMaxDepth = 12;
+  static constexpr int kMaxHeight = kMaxDepth - 1;
+
+  // `Action` defines the action for unwinding changes done at the btree's leaf
+  // level that need to be propagated up to the parent node(s). Each operation
+  // on a node has an effect / action defined as follows:
+  // - kSelf
+  //   The operation (add / update, etc) was performed directly on the node as
+  //   the node is private to the current thread (i.e.: not shared directly or
+  //   indirectly through a refcount > 1). Changes can be propagated directly to
+  //   all parent nodes as all parent nodes are also then private to the current
+  //   thread.
+  // - kCopied
+  //   The operation (add / update, etc) was performed on a copy of the original
+  //   node, as the node is (potentially) directly or indirectly shared with
+  //   other threads. Changes need to be propagated into the parent nodes where
+  //   the old down pointer must be unreffed and replaced with this new copy.
+  //   Such changes to parent nodes may themselves require a copy if the parent
+  //   node is also shared. A kCopied action can propagate all the way to the
+  //   top node where we then must unref the `tree` input provided by the
+  //   caller, and return the new copy.
+  // - kPopped
+  //   The operation (typically add) could not be satisfied due to insufficient
+  //   capacity in the targeted node, and a new 'leg' was created that needs to
+  //   be added into the parent node. For example, adding a FLAT inside a leaf
+  //   node that is at capacity will create a new leaf node containing that
+  //   FLAT, that needs to be 'popped' up the btree. Such 'pop' actions can
+  //   cascade up the tree if parent nodes are also at capacity. A 'Popped'
+  //   action propagating all the way to the top of the tree will result in
+  //   the tree becoming one level higher than the current tree through a final
+  //   `CordRepBtree::New(tree, popped)` call, resulting in a new top node
+  //   referencing the old tree and the new (fully popped upwards) 'leg'.
+  enum Action { kSelf, kCopied, kPopped };
+
+  // Result of an operation on a node. See the `Action` enum for details.
+  struct OpResult {
+    CordRepBtree* tree;
+    Action action;
+  };
+
+  // Return value of the CopyPrefix and CopySuffix methods which can
+  // return a node or data edge at any height inside the tree.
+  // A height of 0 defines the lowest (leaf) node, a height of -1 identifies
+  // `edge` as being a plain data node: EXTERNAL / FLAT or SUBSTRING thereof.
+  struct CopyResult {
+    CordRep* edge;
+    int height;
+  };
+
+  // Logical position inside a node:
+  // - index: index of the edge.
+  // - n: size or offset value depending on context.
+  struct Position {
+    size_t index;
+    size_t n;
+  };
+
+  // Creates a btree from the given input. Adopts a ref of `rep`.
+  // If the input `rep` is itself a btree, i.e., `IsBtree()`, then this
+  // function immediately returns `rep->btree()`. If the input is a valid data
+  // edge (see IsDataEdge()), then a new leaf node is returned containing `rep`
+  // as the sole data edge. Else, the input is assumed to be a (legacy) concat
+  // tree, and the input is consumed and transformed into a btree().
+  static CordRepBtree* Create(CordRep* rep);
+
+  // Destroys the provided tree. Should only be called by cord internal API's,
+  // typically after a ref_count.Decrement() on the last reference count.
+  static void Destroy(CordRepBtree* tree);
+
+  // Destruction
+  static void Delete(CordRepBtree* tree) { delete tree; }
+
+  // Use CordRep::Unref() as we overload for absl::Span<CordRep* const>.
+  using CordRep::Unref;
+
+  // Unrefs all edges in `edges` which are assumed to be 'likely one'.
+  static void Unref(absl::Span<CordRep* const> edges);
+
+  // Appends / Prepends an existing CordRep instance to this tree.
+  // The below methods accept three types of input:
+  // 1) `rep` is a data node (See `IsDataNode` for valid data edges).
+  // `rep` is appended or prepended to this tree 'as is'.
+  // 2) `rep` is a BTREE.
+  // `rep` is merged into `tree` respecting the Append/Prepend order.
+  // 3) `rep` is some other (legacy) type.
+  // `rep` is converted in place and added to `tree`
+  // Requires `tree` and `rep` to be not null.
+  static CordRepBtree* Append(CordRepBtree* tree, CordRep* rep);
+  static CordRepBtree* Prepend(CordRepBtree* tree, CordRep* rep);
+
+  // Append/Prepend the data in `data` to this tree.
+  // The `extra` parameter defines how much extra capacity should be allocated
+  // for any additional FLAT being allocated. This is an optimization hint from
+  // the caller. For example, a caller may need to add 2 string_views of data
+  // "abc" and "defghi" which are not consecutive. The caller can in this case
+  // invoke `AddData(tree, "abc", 6)`, and any newly added flat is allocated
+  // where possible with at least 6 bytes of extra capacity beyond `length`.
+  // This helps avoiding data getting fragmented over multiple flats.
+  // There is no limit on the size of `data`. If `data` can not be stored inside
+  // a single flat, then the function will iteratively add flats until all data
+  // has been consumed and appended or prepended to the tree.
+  static CordRepBtree* Append(CordRepBtree* tree, string_view data,
+                              size_t extra = 0);
+  static CordRepBtree* Prepend(CordRepBtree* tree, string_view data,
+                               size_t extra = 0);
+
+  // Returns a new tree, containing `n` bytes of data from this instance
+  // starting at offset `offset`. Where possible, the returned tree shares
+  // (re-uses) data edges and nodes with this instance to minimize the
+  // combined memory footprint of both trees.
+  // Requires `offset + n <= length`. Returns `nullptr` if `n` is zero.
+  CordRep* SubTree(size_t offset, size_t n);
+
+  // Removes `n` trailing bytes from `tree`, and returns the resulting tree
+  // or data edge. Returns `tree` if n is zero, and nullptr if n == length.
+  // This function is logically identical to:
+  //   result = tree->SubTree(0, tree->length - n);
+  //   Unref(tree);
+  //   return result;
+  // However, the actual implementation will as much as possible perform 'in
+  // place' modifications on the tree on all nodes and edges that are mutable.
+  // For example, in a fully privately owned tree with the last edge being a
+  // flat of length 12, RemoveSuffix(1) will simply set the length of that data
+  // edge to 11, and reduce the length of all nodes on the edge path by 1.
+  static CordRep* RemoveSuffix(CordRepBtree* tree, size_t n);
+
+  // Returns the character at the given offset.
+  char GetCharacter(size_t offset) const;
+
+  // Returns true if this node holds a single data edge, and if so, sets
+  // `fragment` to reference the contained data. `fragment` is an optional
+  // output parameter and allowed to be null.
+  bool IsFlat(absl::string_view* fragment) const;
+
+  // Returns true if the data of `n` bytes starting at offset `offset`
+  // is contained in a single data edge, and if so, sets fragment to reference
+  // the contained data. `fragment` is an optional output parameter and allowed
+  // to be null.
+  bool IsFlat(size_t offset, size_t n, absl::string_view* fragment) const;
+
+  // Returns a span (mutable range of bytes) of up to `size` bytes into the
+  // last FLAT data edge inside this tree under the following conditions:
+  // - none of the nodes down into the FLAT node are shared.
+  // - the last data edge in this tree is a non-shared FLAT.
+  // - the referenced FLAT has additional capacity available.
+  // If all these conditions are met, a non-empty span is returned, and the
+  // length of the flat node and involved tree nodes have been increased by
+  // `span.length()`. The caller is responsible for immediately assigning values
+  // to all uninitialized data reference by the returned span.
+  // Requires `this->refcount.IsOne()`: this function forces the caller to do
+  // this fast path check on the top level node, as this is the most commonly
+  // shared node of a cord tree.
+  Span<char> GetAppendBuffer(size_t size);
+
+  // Extracts the right-most data edge from this tree iff:
+  // - the tree and all internal edges to the right-most node are not shared.
+  // - the right-most node is a FLAT node and not shared.
+  // - the right-most node has at least the desired extra capacity.
+  //
+  // Returns {tree, nullptr} if any of the above conditions are not met.
+  // This method effectively removes data from the tree. The intent of this
+  // method is to allow applications appending small string data to use
+  // pre-existing capacity, and add the modified rep back to the tree.
+  //
+  // Simplified such code would look similar to this:
+  //   void MyTreeBuilder::Append(string_view data) {
+  //     ExtractResult result = CordRepBtree::ExtractAppendBuffer(tree_, 1);
+  //     if (CordRep* rep = result.extracted) {
+  //       size_t available = rep->Capacity() - rep->length;
+  //       size_t n = std::min(data.size(), n);
+  //       memcpy(rep->Data(), data.data(), n);
+  //       rep->length += n;
+  //       data.remove_prefix(n);
+  //       if (!result.tree->IsBtree()) {
+  //         tree_ = CordRepBtree::Create(result.tree);
+  //       }
+  //       tree_ = CordRepBtree::Append(tree_, rep);
+  //     }
+  //     ...
+  //     // Remaining edge in `result.tree`.
+  //   }
+  static ExtractResult ExtractAppendBuffer(CordRepBtree* tree,
+                                           size_t extra_capacity = 1);
+
+  // Returns the `height` of the tree. The height of a tree is limited to
+  // kMaxHeight. `height` is implemented as an `int` as in some places we
+  // use negative (-1) values for 'data edges'.
+  int height() const { return static_cast<int>(storage[0]); }
+
+  // Properties: begin, back, end, front/back boundary indexes.
+  size_t begin() const { return static_cast<size_t>(storage[1]); }
+  size_t back() const { return static_cast<size_t>(storage[2]) - 1; }
+  size_t end() const { return static_cast<size_t>(storage[2]); }
+  size_t index(EdgeType edge) const {
+    return edge == kFront ? begin() : back();
+  }
+
+  // Properties: size and capacity.
+  // `capacity` contains the current capacity of this instance, where
+  // `kMaxCapacity` contains the maximum capacity of a btree node.
+  // For now, `capacity` and `kMaxCapacity` return the same value, but this may
+  // change in the future if we see benefit in dynamically sizing 'small' nodes
+  // to 'large' nodes for large data trees.
+  size_t size() const { return end() - begin(); }
+  size_t capacity() const { return kMaxCapacity; }
+
+  // Edge access
+  inline CordRep* Edge(size_t index) const;
+  inline CordRep* Edge(EdgeType edge_type) const;
+  inline absl::Span<CordRep* const> Edges() const;
+  inline absl::Span<CordRep* const> Edges(size_t begin, size_t end) const;
+
+  // Returns reference to the data edge at `index`.
+  // Requires this instance to be a leaf node, and `index` to be valid index.
+  inline absl::string_view Data(size_t index) const;
+
+  // Diagnostics: returns true if `tree` is valid and internally consistent.
+  // If `shallow` is false, then the provided top level node and all child nodes
+  // below it are recursively checked. If `shallow` is true, only the provided
+  // node in `tree` and the cumulative length, type and height of the direct
+  // child nodes of `tree` are checked. The value of `shallow` is ignored if the
+  // internal `cord_btree_exhaustive_validation` diagnostics variable is true,
+  // in which case the performed validations works as if `shallow` were false.
+  // This function is intended for debugging and testing purposes only.
+  static bool IsValid(const CordRepBtree* tree, bool shallow = false);
+
+  // Diagnostics: asserts that the provided tree is valid.
+  // `AssertValid()` performs a shallow validation by default. `shallow` can be
+  // set to false in which case an exhaustive validation is performed. This
+  // function is implemented in terms of calling `IsValid()` and asserting the
+  // return value to be true. See `IsValid()` for more information.
+  // This function is intended for debugging and testing purposes only.
+  static CordRepBtree* AssertValid(CordRepBtree* tree, bool shallow = true);
+  static const CordRepBtree* AssertValid(const CordRepBtree* tree,
+                                         bool shallow = true);
+
+  // Diagnostics: dump the contents of this tree to `stream`.
+  // This function is intended for debugging and testing purposes only.
+  static void Dump(const CordRep* rep, std::ostream& stream);
+  static void Dump(const CordRep* rep, absl::string_view label,
+                   std::ostream& stream);
+  static void Dump(const CordRep* rep, absl::string_view label,
+                   bool include_contents, std::ostream& stream);
+
+  // Adds the edge `edge` to this node if possible. `owned` indicates if the
+  // current node is potentially shared or not with other threads. Returns:
+  // - {kSelf, <this>}
+  //   The edge was directly added to this node.
+  // - {kCopied, <node>}
+  //   The edge was added to a copy of this node.
+  // - {kPopped, New(edge, height())}
+  //   A new leg with the edge was created as this node has no extra capacity.
+  template <EdgeType edge_type>
+  inline OpResult AddEdge(bool owned, CordRep* edge, size_t delta);
+
+  // Replaces the front or back edge with the provided new edge. Returns:
+  // - {kSelf, <this>}
+  //   The edge was directly set in this node. The old edge is unreffed.
+  // - {kCopied, <node>}
+  //   A copy of this node was created with the new edge value.
+  // In both cases, the function adopts a reference on `edge`.
+  template <EdgeType edge_type>
+  OpResult SetEdge(bool owned, CordRep* edge, size_t delta);
+
+  // Creates a new empty node at the specified height.
+  static CordRepBtree* New(int height = 0);
+
+  // Creates a new node containing `rep`, with the height being computed
+  // automatically based on the type of `rep`.
+  static CordRepBtree* New(CordRep* rep);
+
+  // Creates a new node containing both `front` and `back` at height
+  // `front.height() + 1`. Requires `back.height() == front.height()`.
+  static CordRepBtree* New(CordRepBtree* front, CordRepBtree* back);
+
+  // Creates a fully balanced tree from the provided tree by rebuilding a new
+  // tree from all data edges in the input. This function is automatically
+  // invoked internally when the tree exceeds the maximum height.
+  static CordRepBtree* Rebuild(CordRepBtree* tree);
+
+ private:
+  CordRepBtree() = default;
+  ~CordRepBtree() = default;
+
+  // Initializes the main properties `tag`, `begin`, `end`, `height`.
+  inline void InitInstance(int height, size_t begin = 0, size_t end = 0);
+
+  // Direct property access begin / end
+  void set_begin(size_t begin) { storage[1] = static_cast<uint8_t>(begin); }
+  void set_end(size_t end) { storage[2] = static_cast<uint8_t>(end); }
+
+  // Decreases the value of `begin` by `n`, and returns the new value. Notice
+  // how this returns the new value unlike atomic::fetch_add which returns the
+  // old value. This is because this is used to prepend edges at 'begin - 1'.
+  size_t sub_fetch_begin(size_t n) {
+    storage[1] -= static_cast<uint8_t>(n);
+    return storage[1];
+  }
+
+  // Increases the value of `end` by `n`, and returns the previous value. This
+  // function is typically used to append edges at 'end'.
+  size_t fetch_add_end(size_t n) {
+    const uint8_t current = storage[2];
+    storage[2] = static_cast<uint8_t>(current + n);
+    return current;
+  }
+
+  // Returns the index of the last edge starting on, or before `offset`, with
+  // `n` containing the relative offset of `offset` inside that edge.
+  // Requires `offset` < length.
+  Position IndexOf(size_t offset) const;
+
+  // Returns the index of the last edge starting before `offset`, with `n`
+  // containing the relative offset of `offset` inside that edge.
+  // This function is useful to find the edges for some span of bytes ending at
+  // `offset` (i.e., `n` bytes). For example:
+  //
+  //   Position pos = IndexBefore(n)
+  //   edges = Edges(begin(), pos.index)     // All full edges (may be empty)
+  //   last = Sub(Edge(pos.index), 0, pos.n) // Last partial edge (may be empty)
+  //
+  // Requires 0 < `offset` <= length.
+  Position IndexBefore(size_t offset) const;
+
+  // Returns the index of the edge ending at (or on) length `length`, and the
+  // number of bytes inside that edge up to `length`. For example, if we have a
+  // Node with 2 edges, one of 10 and one of 20 long, then IndexOfLength(27)
+  // will return {1, 17}, and IndexOfLength(10) will return {0, 10}.
+  Position IndexOfLength(size_t n) const;
+
+  // Identical to the above function except starting from the position `front`.
+  // This function is equivalent to `IndexBefore(front.n + offset)`, with
+  // the difference that this function is optimized to start at `front.index`.
+  Position IndexBefore(Position front, size_t offset) const;
+
+  // Returns the index of the edge directly beyond the edge containing offset
+  // `offset`, with `n` containing the distance of that edge from `offset`.
+  // This function is useful for iteratively finding suffix nodes and remaining
+  // partial bytes in left-most suffix nodes as for example in CopySuffix.
+  // Requires `offset` < length.
+  Position IndexBeyond(size_t offset) const;
+
+  // Creates a new leaf node containing as much data as possible from `data`.
+  // The data is added either forwards or reversed depending on `edge_type`.
+  // Callers must check the length of the returned node to determine if all data
+  // was copied or not.
+  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
+  template <EdgeType edge_type>
+  static CordRepBtree* NewLeaf(absl::string_view data, size_t extra);
+
+  // Creates a raw copy of this Btree node, copying all properties, but
+  // without adding any references to existing edges.
+  CordRepBtree* CopyRaw() const;
+
+  // Creates a full copy of this Btree node, adding a reference on all edges.
+  CordRepBtree* Copy() const;
+
+  // Creates a partial copy of this Btree node, copying all edges up to `end`,
+  // adding a reference on each copied edge, and sets the length of the newly
+  // created copy to `new_length`.
+  CordRepBtree* CopyBeginTo(size_t end, size_t new_length) const;
+
+  // Returns a tree containing the edges [tree->begin(), end) and length
+  // of `new_length`. This method consumes a reference on the provided
+  // tree, and logically performs the following operation:
+  //   result = tree->CopyBeginTo(end, new_length);
+  //   CordRep::Unref(tree);
+  //   return result;
+  static CordRepBtree* ConsumeBeginTo(CordRepBtree* tree, size_t end,
+                                      size_t new_length);
+
+  // Creates a partial copy of this Btree node, copying all edges starting at
+  // `begin`, adding a reference on each copied edge, and sets the length of
+  // the newly created copy to `new_length`.
+  CordRepBtree* CopyToEndFrom(size_t begin, size_t new_length) const;
+
+  // Extracts and returns the front edge from the provided tree.
+  // This method consumes a reference on the provided tree, and logically
+  // performs the following operation:
+  //   edge = CordRep::Ref(tree->Edge(kFront));
+  //   CordRep::Unref(tree);
+  //   return edge;
+  static CordRep* ExtractFront(CordRepBtree* tree);
+
+  // Returns a tree containing the result of appending `right` to `left`.
+  static CordRepBtree* MergeTrees(CordRepBtree* left, CordRepBtree* right);
+
+  // Fallback functions for `Create()`, `Append()` and `Prepend()` which
+  // deal with legacy / non conforming input, i.e.: CONCAT trees.
+  static CordRepBtree* CreateSlow(CordRep* rep);
+  static CordRepBtree* AppendSlow(CordRepBtree*, CordRep* rep);
+  static CordRepBtree* PrependSlow(CordRepBtree*, CordRep* rep);
+
+  // Recursively rebuilds `tree` into `stack`. If 'consume` is set to true, the
+  // function will consume a reference on `tree`. `stack` is a null terminated
+  // array containing the new tree's state, with the current leaf node at
+  // stack[0], and parent nodes above that, or null for 'top of tree'.
+  static void Rebuild(CordRepBtree** stack, CordRepBtree* tree, bool consume);
+
+  // Aligns existing edges to start at index 0, to allow for a new edge to be
+  // added to the back of the current edges.
+  inline void AlignBegin();
+
+  // Aligns existing edges to end at `capacity`, to allow for a new edge to be
+  // added in front of the current edges.
+  inline void AlignEnd();
+
+  // Adds the provided edge to this node.
+  // Requires this node to have capacity for the edge. Realigns / moves
+  // existing edges as needed to prepend or append the new edge.
+  template <EdgeType edge_type>
+  inline void Add(CordRep* rep);
+
+  // Adds the provided edges to this node.
+  // Requires this node to have capacity for the edges. Realigns / moves
+  // existing edges as needed to prepend or append the new edges.
+  template <EdgeType edge_type>
+  inline void Add(absl::Span<CordRep* const>);
+
+  // Adds data from `data` to this node until either all data has been consumed,
+  // or there is no more capacity for additional flat nodes inside this node.
+  // Requires the current node to be a leaf node, data to be non empty, and the
+  // current node to have capacity for at least one more data edge.
+  // Returns any remaining data from `data` that was not added, which is
+  // depending on the edge type (front / back) either the remaining prefix of
+  // suffix of the input.
+  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
+  template <EdgeType edge_type>
+  absl::string_view AddData(absl::string_view data, size_t extra);
+
+  // Replace the front or back edge with the provided value.
+  // Adopts a reference on `edge` and unrefs the old edge.
+  template <EdgeType edge_type>
+  inline void SetEdge(CordRep* edge);
+
+  // Returns a partial copy of the current tree containing the first `n` bytes
+  // of data. `CopyResult` contains both the resulting edge and its height. The
+  // resulting tree may be less high than the current tree, or even be a single
+  // matching data edge if `allow_folding` is set to true.
+  // For example, if `n == 1`, then the result will be the single data edge, and
+  // height will be set to -1 (one below the owning leaf node). If n == 0, this
+  // function returns null. Requires `n <= length`
+  CopyResult CopyPrefix(size_t n, bool allow_folding = true);
+
+  // Returns a partial copy of the current tree containing all data starting
+  // after `offset`. `CopyResult` contains both the resulting edge and its
+  // height. The resulting tree may be less high than the current tree, or even
+  // be a single matching data edge. For example, if `n == length - 1`, then the
+  // result will be a single data edge, and height will be set to -1 (one below
+  // the owning leaf node).
+  // Requires `offset < length`
+  CopyResult CopySuffix(size_t offset);
+
+  // Returns a OpResult value of {this, kSelf} or {Copy(), kCopied}
+  // depending on the value of `owned`.
+  inline OpResult ToOpResult(bool owned);
+
+  // Adds `rep` to the specified tree, returning the modified tree.
+  template <EdgeType edge_type>
+  static CordRepBtree* AddCordRep(CordRepBtree* tree, CordRep* rep);
+
+  // Adds `data` to the specified tree, returning the modified tree.
+  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
+  template <EdgeType edge_type>
+  static CordRepBtree* AddData(CordRepBtree* tree, absl::string_view data,
+                               size_t extra = 0);
+
+  // Merges `src` into `dst` with `src` being added either before (kFront) or
+  // after (kBack) `dst`. Requires the height of `dst` to be greater than or
+  // equal to the height of `src`.
+  template <EdgeType edge_type>
+  static CordRepBtree* Merge(CordRepBtree* dst, CordRepBtree* src);
+
+  // Fallback version of GetAppendBuffer for large trees: GetAppendBuffer()
+  // implements an inlined version for trees of limited height (3 levels),
+  // GetAppendBufferSlow implements the logic for large trees.
+  Span<char> GetAppendBufferSlow(size_t size);
+
+  // `edges_` contains all edges starting from this instance.
+  // These are explicitly `child` edges only, a cord btree (or any cord tree in
+  // that respect) does not store `parent` pointers anywhere: multiple trees /
+  // parents can reference the same shared child edge. The type of these edges
+  // depends on the height of the node. `Leaf nodes` (height == 0) contain `data
+  // edges` (external or flat nodes, or sub-strings thereof). All other nodes
+  // (height > 0) contain pointers to BTREE nodes with a height of `height - 1`.
+  CordRep* edges_[kMaxCapacity];
+
+  friend class CordRepBtreeTestPeer;
+  friend class CordRepBtreeNavigator;
+};
+
+inline CordRepBtree* CordRep::btree() {
+  assert(IsBtree());
+  return static_cast<CordRepBtree*>(this);
+}
+
+inline const CordRepBtree* CordRep::btree() const {
+  assert(IsBtree());
+  return static_cast<const CordRepBtree*>(this);
+}
+
+inline void CordRepBtree::InitInstance(int height, size_t begin, size_t end) {
+  tag = BTREE;
+  storage[0] = static_cast<uint8_t>(height);
+  storage[1] = static_cast<uint8_t>(begin);
+  storage[2] = static_cast<uint8_t>(end);
+}
+
+inline CordRep* CordRepBtree::Edge(size_t index) const {
+  assert(index >= begin());
+  assert(index < end());
+  return edges_[index];
+}
+
+inline CordRep* CordRepBtree::Edge(EdgeType edge_type) const {
+  return edges_[edge_type == kFront ? begin() : back()];
+}
+
+inline absl::Span<CordRep* const> CordRepBtree::Edges() const {
+  return {edges_ + begin(), size()};
+}
+
+inline absl::Span<CordRep* const> CordRepBtree::Edges(size_t begin,
+                                                      size_t end) const {
+  assert(begin <= end);
+  assert(begin >= this->begin());
+  assert(end <= this->end());
+  return {edges_ + begin, static_cast<size_t>(end - begin)};
+}
+
+inline absl::string_view CordRepBtree::Data(size_t index) const {
+  assert(height() == 0);
+  return EdgeData(Edge(index));
+}
+
+inline CordRepBtree* CordRepBtree::New(int height) {
+  CordRepBtree* tree = new CordRepBtree;
+  tree->length = 0;
+  tree->InitInstance(height);
+  return tree;
+}
+
+inline CordRepBtree* CordRepBtree::New(CordRep* rep) {
+  CordRepBtree* tree = new CordRepBtree;
+  int height = rep->IsBtree() ? rep->btree()->height() + 1 : 0;
+  tree->length = rep->length;
+  tree->InitInstance(height, /*begin=*/0, /*end=*/1);
+  tree->edges_[0] = rep;
+  return tree;
+}
+
+inline CordRepBtree* CordRepBtree::New(CordRepBtree* front,
+                                       CordRepBtree* back) {
+  assert(front->height() == back->height());
+  CordRepBtree* tree = new CordRepBtree;
+  tree->length = front->length + back->length;
+  tree->InitInstance(front->height() + 1, /*begin=*/0, /*end=*/2);
+  tree->edges_[0] = front;
+  tree->edges_[1] = back;
+  return tree;
+}
+
+inline void CordRepBtree::Unref(absl::Span<CordRep* const> edges) {
+  for (CordRep* edge : edges) {
+    if (ABSL_PREDICT_FALSE(!edge->refcount.Decrement())) {
+      CordRep::Destroy(edge);
+    }
+  }
+}
+
+inline CordRepBtree* CordRepBtree::CopyRaw() const {
+  auto* tree = static_cast<CordRepBtree*>(::operator new(sizeof(CordRepBtree)));
+  memcpy(static_cast<void*>(tree), this, sizeof(CordRepBtree));
+  new (&tree->refcount) RefcountAndFlags;
+  return tree;
+}
+
+inline CordRepBtree* CordRepBtree::Copy() const {
+  CordRepBtree* tree = CopyRaw();
+  for (CordRep* rep : Edges()) CordRep::Ref(rep);
+  return tree;
+}
+
+inline CordRepBtree* CordRepBtree::CopyToEndFrom(size_t begin,
+                                                 size_t new_length) const {
+  assert(begin >= this->begin());
+  assert(begin <= this->end());
+  CordRepBtree* tree = CopyRaw();
+  tree->length = new_length;
+  tree->set_begin(begin);
+  for (CordRep* edge : tree->Edges()) CordRep::Ref(edge);
+  return tree;
+}
+
+inline CordRepBtree* CordRepBtree::CopyBeginTo(size_t end,
+                                               size_t new_length) const {
+  assert(end <= capacity());
+  assert(end >= this->begin());
+  CordRepBtree* tree = CopyRaw();
+  tree->length = new_length;
+  tree->set_end(end);
+  for (CordRep* edge : tree->Edges()) CordRep::Ref(edge);
+  return tree;
+}
+
+inline void CordRepBtree::AlignBegin() {
+  // The below code itself does not need to be fast as typically we have
+  // mono-directional append/prepend calls, and `begin` / `end` are typically
+  // adjusted no more than once. But we want to avoid potential register clobber
+  // effects, making the compiler emit register save/store/spills, and minimize
+  // the size of code.
+  const size_t delta = begin();
+  if (ABSL_PREDICT_FALSE(delta != 0)) {
+    const size_t new_end = end() - delta;
+    set_begin(0);
+    set_end(new_end);
+    // TODO(mvels): we can write this using 2 loads / 2 stores depending on
+    // total size for the kMaxCapacity = 6 case. I.e., we can branch (switch) on
+    // size, and then do overlapping load/store of up to 4 pointers (inlined as
+    // XMM, YMM or ZMM load/store) and up to 2 pointers (XMM / YMM), which is a)
+    // compact and b) not clobbering any registers.
+    ABSL_ASSUME(new_end <= kMaxCapacity);
+#ifdef __clang__
+#pragma unroll 1
+#endif
+    for (size_t i = 0; i < new_end; ++i) {
+      edges_[i] = edges_[i + delta];
+    }
+  }
+}
+
+inline void CordRepBtree::AlignEnd() {
+  // See comments in `AlignBegin` for motivation on the hand-rolled for loops.
+  const size_t delta = capacity() - end();
+  if (delta != 0) {
+    const size_t new_begin = begin() + delta;
+    const size_t new_end = end() + delta;
+    set_begin(new_begin);
+    set_end(new_end);
+    ABSL_ASSUME(new_end <= kMaxCapacity);
+#ifdef __clang__
+#pragma unroll 1
+#endif
+    for (size_t i = new_end - 1; i >= new_begin; --i) {
+      edges_[i] = edges_[i - delta];
+    }
+  }
+}
+
+template <>
+inline void CordRepBtree::Add<CordRepBtree::kBack>(CordRep* rep) {
+  AlignBegin();
+  edges_[fetch_add_end(1)] = rep;
+}
+
+template <>
+inline void CordRepBtree::Add<CordRepBtree::kBack>(
+    absl::Span<CordRep* const> edges) {
+  AlignBegin();
+  size_t new_end = end();
+  for (CordRep* edge : edges) edges_[new_end++] = edge;
+  set_end(new_end);
+}
+
+template <>
+inline void CordRepBtree::Add<CordRepBtree::kFront>(CordRep* rep) {
+  AlignEnd();
+  edges_[sub_fetch_begin(1)] = rep;
+}
+
+template <>
+inline void CordRepBtree::Add<CordRepBtree::kFront>(
+    absl::Span<CordRep* const> edges) {
+  AlignEnd();
+  size_t new_begin = begin() - edges.size();
+  set_begin(new_begin);
+  for (CordRep* edge : edges) edges_[new_begin++] = edge;
+}
+
+template <CordRepBtree::EdgeType edge_type>
+inline void CordRepBtree::SetEdge(CordRep* edge) {
+  const int idx = edge_type == kFront ? begin() : back();
+  CordRep::Unref(edges_[idx]);
+  edges_[idx] = edge;
+}
+
+inline CordRepBtree::OpResult CordRepBtree::ToOpResult(bool owned) {
+  return owned ? OpResult{this, kSelf} : OpResult{Copy(), kCopied};
+}
+
+inline CordRepBtree::Position CordRepBtree::IndexOf(size_t offset) const {
+  assert(offset < length);
+  size_t index = begin();
+  while (offset >= edges_[index]->length) offset -= edges_[index++]->length;
+  return {index, offset};
+}
+
+inline CordRepBtree::Position CordRepBtree::IndexBefore(size_t offset) const {
+  assert(offset > 0);
+  assert(offset <= length);
+  size_t index = begin();
+  while (offset > edges_[index]->length) offset -= edges_[index++]->length;
+  return {index, offset};
+}
+
+inline CordRepBtree::Position CordRepBtree::IndexBefore(Position front,
+                                                        size_t offset) const {
+  size_t index = front.index;
+  offset = offset + front.n;
+  while (offset > edges_[index]->length) offset -= edges_[index++]->length;
+  return {index, offset};
+}
+
+inline CordRepBtree::Position CordRepBtree::IndexOfLength(size_t n) const {
+  assert(n <= length);
+  size_t index = back();
+  size_t strip = length - n;
+  while (strip >= edges_[index]->length) strip -= edges_[index--]->length;
+  return {index, edges_[index]->length - strip};
+}
+
+inline CordRepBtree::Position CordRepBtree::IndexBeyond(
+    const size_t offset) const {
+  // We need to find the edge which `starting offset` is beyond (>=)`offset`.
+  // For this we can't use the `offset -= length` logic of IndexOf. Instead, we
+  // track the offset of the `current edge` in `off`, which we increase as we
+  // iterate over the edges until we find the matching edge.
+  size_t off = 0;
+  size_t index = begin();
+  while (offset > off) off += edges_[index++]->length;
+  return {index, off - offset};
+}
+
+inline CordRepBtree* CordRepBtree::Create(CordRep* rep) {
+  if (IsDataEdge(rep)) return New(rep);
+  return CreateSlow(rep);
+}
+
+inline Span<char> CordRepBtree::GetAppendBuffer(size_t size) {
+  assert(refcount.IsOne());
+  CordRepBtree* tree = this;
+  const int height = this->height();
+  CordRepBtree* n1 = tree;
+  CordRepBtree* n2 = tree;
+  CordRepBtree* n3 = tree;
+  switch (height) {
+    case 3:
+      tree = tree->Edge(kBack)->btree();
+      if (!tree->refcount.IsOne()) return {};
+      n2 = tree;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 2:
+      tree = tree->Edge(kBack)->btree();
+      if (!tree->refcount.IsOne()) return {};
+      n1 = tree;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 1:
+      tree = tree->Edge(kBack)->btree();
+      if (!tree->refcount.IsOne()) return {};
+      ABSL_FALLTHROUGH_INTENDED;
+    case 0:
+      CordRep* edge = tree->Edge(kBack);
+      if (!edge->refcount.IsOne()) return {};
+      if (edge->tag < FLAT) return {};
+      size_t avail = edge->flat()->Capacity() - edge->length;
+      if (avail == 0) return {};
+      size_t delta = (std::min)(size, avail);
+      Span<char> span = {edge->flat()->Data() + edge->length, delta};
+      edge->length += delta;
+      switch (height) {
+        case 3:
+          n3->length += delta;
+          ABSL_FALLTHROUGH_INTENDED;
+        case 2:
+          n2->length += delta;
+          ABSL_FALLTHROUGH_INTENDED;
+        case 1:
+          n1->length += delta;
+          ABSL_FALLTHROUGH_INTENDED;
+        case 0:
+          tree->length += delta;
+          return span;
+      }
+      break;
+  }
+  return GetAppendBufferSlow(size);
+}
+
+extern template CordRepBtree* CordRepBtree::AddCordRep<CordRepBtree::kBack>(
+    CordRepBtree* tree, CordRep* rep);
+
+extern template CordRepBtree* CordRepBtree::AddCordRep<CordRepBtree::kFront>(
+    CordRepBtree* tree, CordRep* rep);
+
+inline CordRepBtree* CordRepBtree::Append(CordRepBtree* tree, CordRep* rep) {
+  if (ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
+    return CordRepBtree::AddCordRep<kBack>(tree, rep);
+  }
+  return AppendSlow(tree, rep);
+}
+
+inline CordRepBtree* CordRepBtree::Prepend(CordRepBtree* tree, CordRep* rep) {
+  if (ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
+    return CordRepBtree::AddCordRep<kFront>(tree, rep);
+  }
+  return PrependSlow(tree, rep);
+}
+
+#ifdef NDEBUG
+
+inline CordRepBtree* CordRepBtree::AssertValid(CordRepBtree* tree,
+                                               bool /* shallow */) {
+  return tree;
+}
+
+inline const CordRepBtree* CordRepBtree::AssertValid(const CordRepBtree* tree,
+                                                     bool /* shallow */) {
+  return tree;
+}
+
+#endif
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_navigator.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_navigator.h
new file mode 100644
index 0000000..3d581c8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_navigator.h
@@ -0,0 +1,267 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
+
+#include <cassert>
+#include <iostream>
+
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_btree.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordRepBtreeNavigator is a bi-directional navigator allowing callers to
+// navigate all the (leaf) data edges in a CordRepBtree instance.
+//
+// A CordRepBtreeNavigator instance is by default empty. Callers initialize a
+// navigator instance by calling one of `InitFirst()`, `InitLast()` or
+// `InitOffset()`, which establishes a current position. Callers can then
+// navigate using the `Next`, `Previous`, `Skip` and `Seek` methods.
+//
+// The navigator instance does not take or adopt a reference on the provided
+// `tree` on any of the initialization calls. Callers are responsible for
+// guaranteeing the lifecycle of the provided tree. A navigator instance can
+// be reset to the empty state by calling `Reset`.
+//
+// A navigator only keeps positional state on the 'current data edge', it does
+// explicitly not keep any 'offset' state. The class does accept and return
+// offsets in the `Read()`, `Skip()` and 'Seek()` methods as these would
+// otherwise put a big burden on callers. Callers are expected to maintain
+// (returned) offset info if they require such granular state.
+class CordRepBtreeNavigator {
+ public:
+  // The logical position as returned by the Seek() and Skip() functions.
+  // Returns the current leaf edge for the desired seek or skip position and
+  // the offset of that position inside that edge.
+  struct Position {
+    CordRep* edge;
+    size_t offset;
+  };
+
+  // The read result as returned by the Read() function.
+  // `tree` contains the resulting tree which is identical to the result
+  // of calling CordRepBtree::SubTree(...) on the tree being navigated.
+  // `n` contains the number of bytes used from the last navigated to
+  // edge of the tree.
+  struct ReadResult {
+    CordRep* tree;
+    size_t n;
+  };
+
+  // Returns true if this instance is not empty.
+  explicit operator bool() const;
+
+  // Returns the tree for this instance or nullptr if empty.
+  CordRepBtree* btree() const;
+
+  // Returns the data edge of the current position.
+  // Requires this instance to not be empty.
+  CordRep* Current() const;
+
+  // Resets this navigator to `tree`, returning the first data edge in the tree.
+  CordRep* InitFirst(CordRepBtree* tree);
+
+  // Resets this navigator to `tree`, returning the last data edge in the tree.
+  CordRep* InitLast(CordRepBtree* tree);
+
+  // Resets this navigator to `tree` returning the data edge at position
+  // `offset` and the relative offset of `offset` into that data edge.
+  // Returns `Position.edge = nullptr` if the provided offset is greater
+  // than or equal to the length of the tree, in which case the state of
+  // the navigator instance remains unchanged.
+  Position InitOffset(CordRepBtree* tree, size_t offset);
+
+  // Navigates to the next data edge.
+  // Returns the next data edge or nullptr if there is no next data edge, in
+  // which case the current position remains unchanged.
+  CordRep* Next();
+
+  // Navigates to the previous data edge.
+  // Returns the previous data edge or nullptr if there is no previous data
+  // edge, in which case the current position remains unchanged.
+  CordRep* Previous();
+
+  // Navigates to the data edge at position `offset`. Returns the navigated to
+  // data edge in `Position.edge` and the relative offset of `offset` into that
+  // data edge in `Position.offset`. Returns `Position.edge = nullptr` if the
+  // provide offset is greater than or equal to the tree's length.
+  Position Seek(size_t offset);
+
+  // Reads `n` bytes of data starting at offset `edge_offset` of the current
+  // data edge, and returns the result in `ReadResult.tree`. `ReadResult.n`
+  // contains the 'bytes used` from the last / current data edge in the tree.
+  // This allows users that mix regular navigation (using string views) and
+  // 'read into cord' navigation to keep track of the current state, and which
+  // bytes have been consumed from a navigator.
+  // This function returns `ReadResult.tree = nullptr` if the requested length
+  // exceeds the length of the tree starting at the current data edge.
+  ReadResult Read(size_t edge_offset, size_t n);
+
+  // Skips `n` bytes forward from the current data edge, returning the navigated
+  // to data edge in `Position.edge` and `Position.offset` containing the offset
+  // inside that data edge. Note that the state of the navigator is left
+  // unchanged if `n` is smaller than the length of the current data edge.
+  Position Skip(size_t n);
+
+  // Resets this instance to the default / empty state.
+  void Reset();
+
+ private:
+  // Slow path for Next() if Next() reached the end of a leaf node. Backtracks
+  // up the stack until it finds a node that has a 'next' position available,
+  // and then does a 'front dive' towards the next leaf node.
+  CordRep* NextUp();
+
+  // Slow path for Previous() if Previous() reached the beginning of a leaf
+  // node. Backtracks up the stack until it finds a node that has a 'previous'
+  // position available, and then does a 'back dive' towards the previous leaf
+  // node.
+  CordRep* PreviousUp();
+
+  // Generic implementation of InitFirst() and InitLast().
+  template <CordRepBtree::EdgeType edge_type>
+  CordRep* Init(CordRepBtree* tree);
+
+  // `height_` contains the height of the current tree, or -1 if empty.
+  int height_ = -1;
+
+  // `index_` and `node_` contain the navigation state as the 'path' to the
+  // current data edge which is at `node_[0]->Edge(index_[0])`. The contents
+  // of these are undefined until the instance is initialized (`height_ >= 0`).
+  uint8_t index_[CordRepBtree::kMaxDepth];
+  CordRepBtree* node_[CordRepBtree::kMaxDepth];
+};
+
+// Returns true if this instance is not empty.
+inline CordRepBtreeNavigator::operator bool() const { return height_ >= 0; }
+
+inline CordRepBtree* CordRepBtreeNavigator::btree() const {
+  return height_ >= 0 ? node_[height_] : nullptr;
+}
+
+inline CordRep* CordRepBtreeNavigator::Current() const {
+  assert(height_ >= 0);
+  return node_[0]->Edge(index_[0]);
+}
+
+inline void CordRepBtreeNavigator::Reset() { height_ = -1; }
+
+inline CordRep* CordRepBtreeNavigator::InitFirst(CordRepBtree* tree) {
+  return Init<CordRepBtree::kFront>(tree);
+}
+
+inline CordRep* CordRepBtreeNavigator::InitLast(CordRepBtree* tree) {
+  return Init<CordRepBtree::kBack>(tree);
+}
+
+template <CordRepBtree::EdgeType edge_type>
+inline CordRep* CordRepBtreeNavigator::Init(CordRepBtree* tree) {
+  assert(tree != nullptr);
+  assert(tree->size() > 0);
+  assert(tree->height() <= CordRepBtree::kMaxHeight);
+  int height = height_ = tree->height();
+  size_t index = tree->index(edge_type);
+  node_[height] = tree;
+  index_[height] = static_cast<uint8_t>(index);
+  while (--height >= 0) {
+    tree = tree->Edge(index)->btree();
+    node_[height] = tree;
+    index = tree->index(edge_type);
+    index_[height] = static_cast<uint8_t>(index);
+  }
+  return node_[0]->Edge(index);
+}
+
+inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::Seek(
+    size_t offset) {
+  assert(btree() != nullptr);
+  int height = height_;
+  CordRepBtree* edge = node_[height];
+  if (ABSL_PREDICT_FALSE(offset >= edge->length)) return {nullptr, 0};
+  CordRepBtree::Position index = edge->IndexOf(offset);
+  index_[height] = static_cast<uint8_t>(index.index);
+  while (--height >= 0) {
+    edge = edge->Edge(index.index)->btree();
+    node_[height] = edge;
+    index = edge->IndexOf(index.n);
+    index_[height] = static_cast<uint8_t>(index.index);
+  }
+  return {edge->Edge(index.index), index.n};
+}
+
+inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::InitOffset(
+    CordRepBtree* tree, size_t offset) {
+  assert(tree != nullptr);
+  assert(tree->height() <= CordRepBtree::kMaxHeight);
+  if (ABSL_PREDICT_FALSE(offset >= tree->length)) return {nullptr, 0};
+  height_ = tree->height();
+  node_[height_] = tree;
+  return Seek(offset);
+}
+
+inline CordRep* CordRepBtreeNavigator::Next() {
+  CordRepBtree* edge = node_[0];
+  return index_[0] == edge->back() ? NextUp() : edge->Edge(++index_[0]);
+}
+
+inline CordRep* CordRepBtreeNavigator::Previous() {
+  CordRepBtree* edge = node_[0];
+  return index_[0] == edge->begin() ? PreviousUp() : edge->Edge(--index_[0]);
+}
+
+inline CordRep* CordRepBtreeNavigator::NextUp() {
+  assert(index_[0] == node_[0]->back());
+  CordRepBtree* edge;
+  size_t index;
+  int height = 0;
+  do {
+    if (++height > height_) return nullptr;
+    edge = node_[height];
+    index = index_[height] + 1;
+  } while (index == edge->end());
+  index_[height] = static_cast<uint8_t>(index);
+  do {
+    node_[--height] = edge = edge->Edge(index)->btree();
+    index_[height] = static_cast<uint8_t>(index = edge->begin());
+  } while (height > 0);
+  return edge->Edge(index);
+}
+
+inline CordRep* CordRepBtreeNavigator::PreviousUp() {
+  assert(index_[0] == node_[0]->begin());
+  CordRepBtree* edge;
+  size_t index;
+  int height = 0;
+  do {
+    if (++height > height_) return nullptr;
+    edge = node_[height];
+    index = index_[height];
+  } while (index == edge->begin());
+  index_[height] = static_cast<uint8_t>(--index);
+  do {
+    node_[--height] = edge = edge->Edge(index)->btree();
+    index_[height] = static_cast<uint8_t>(index = edge->back());
+  } while (height > 0);
+  return edge->Edge(index);
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_reader.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_reader.h
new file mode 100644
index 0000000..8db8f8d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_reader.h
@@ -0,0 +1,212 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
+
+#include <cassert>
+
+#include "absl/base/config.h"
+#include "absl/strings/internal/cord_data_edge.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_btree.h"
+#include "absl/strings/internal/cord_rep_btree_navigator.h"
+#include "absl/strings/internal/cord_rep_flat.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordRepBtreeReader implements logic to iterate over cord btrees.
+// References to the underlying data are returned as absl::string_view values.
+// The most typical use case is a forward only iteration over tree data.
+// The class also provides `Skip()`, `Seek()` and `Read()` methods similar to
+// CordRepBtreeNavigator that allow more advanced navigation.
+//
+// Example: iterate over all data inside a cord btree:
+//
+//   CordRepBtreeReader reader;
+//   for (string_view sv = reader.Init(tree); !sv.Empty(); sv = sv.Next()) {
+//     DoSomethingWithDataIn(sv);
+//   }
+//
+// All navigation methods always return the next 'chunk' of data. The class
+// assumes that all data is directly 'consumed' by the caller. For example:
+// invoking `Skip()` will skip the desired number of bytes, and directly
+// read and return the next chunk of data directly after the skipped bytes.
+//
+// Example: iterate over all data inside a btree skipping the first 100 bytes:
+//
+//   CordRepBtreeReader reader;
+//   absl::string_view sv = reader.Init(tree);
+//   if (sv.length() > 100) {
+//     sv.RemovePrefix(100);
+//   } else {
+//     sv = reader.Skip(100 - sv.length());
+//   }
+//   while (!sv.empty()) {
+//     DoSomethingWithDataIn(sv);
+//     absl::string_view sv = reader.Next();
+//   }
+//
+// It is important to notice that `remaining` is based on the end position of
+// the last data edge returned to the caller, not the cumulative data returned
+// to the caller which can be less in cases of skipping or seeking over data.
+//
+// For example, consider a cord btree with five data edges: "abc", "def", "ghi",
+// "jkl" and "mno":
+//
+//   absl::string_view sv;
+//   CordRepBtreeReader reader;
+//
+//   sv = reader.Init(tree); // sv = "abc", remaining = 12
+//   sv = reader.Skip(4);    // sv = "hi",  remaining = 6
+//   sv = reader.Skip(2);    // sv = "l",   remaining = 3
+//   sv = reader.Next();     // sv = "mno", remaining = 0
+//   sv = reader.Seek(1);    // sv = "bc", remaining = 12
+//
+class CordRepBtreeReader {
+ public:
+  using ReadResult = CordRepBtreeNavigator::ReadResult;
+  using Position = CordRepBtreeNavigator::Position;
+
+  // Returns true if this instance is not empty.
+  explicit operator bool() const { return navigator_.btree() != nullptr; }
+
+  // Returns the tree referenced by this instance or nullptr if empty.
+  CordRepBtree* btree() const { return navigator_.btree(); }
+
+  // Returns the current data edge inside the referenced btree.
+  // Requires that the current instance is not empty.
+  CordRep* node() const { return navigator_.Current(); }
+
+  // Returns the length of the referenced tree.
+  // Requires that the current instance is not empty.
+  size_t length() const;
+
+  // Returns the number of remaining bytes available for iteration, which is the
+  // number of bytes directly following the end of the last chunk returned.
+  // This value will be zero if we iterated over the last edge in the bound
+  // tree, in which case any call to Next() or Skip() will return an empty
+  // string_view reflecting the EOF state.
+  // Note that a call to `Seek()` resets `remaining` to a value based on the
+  // end position of the chunk returned by that call.
+  size_t remaining() const { return remaining_; }
+
+  // Resets this instance to an empty value.
+  void Reset() { navigator_.Reset(); }
+
+  // Initializes this instance with `tree`. `tree` must not be null.
+  // Returns a reference to the first data edge of the provided tree.
+  absl::string_view Init(CordRepBtree* tree);
+
+  // Navigates to and returns the next data edge of the referenced tree.
+  // Returns an empty string_view if an attempt is made to read beyond the end
+  // of the tree, i.e.: if `remaining()` is zero indicating an EOF condition.
+  // Requires that the current instance is not empty.
+  absl::string_view Next();
+
+  // Skips the provided amount of bytes and returns a reference to the data
+  // directly following the skipped bytes.
+  absl::string_view Skip(size_t skip);
+
+  // Reads `n` bytes into `tree`.
+  // If `chunk_size` is zero, starts reading at the next data edge. If
+  // `chunk_size` is non zero, the read starts at the last `chunk_size` bytes of
+  // the last returned data edge. Effectively, this means that the read starts
+  // at offset `consumed() - chunk_size`.
+  // Requires that `chunk_size` is less than or equal to the length of the
+  // last returned data edge. The purpose of `chunk_size` is to simplify code
+  // partially consuming a returned chunk and wanting to include the remaining
+  // bytes in the Read call. For example, the below code will read 1000 bytes of
+  // data into a cord tree if the first chunk starts with "big:":
+  //
+  //   CordRepBtreeReader reader;
+  //   absl::string_view sv = reader.Init(tree);
+  //   if (absl::StartsWith(sv, "big:")) {
+  //     CordRepBtree tree;
+  //     sv = reader.Read(1000, sv.size() - 4 /* "big:" */, &tree);
+  //   }
+  //
+  // This method will return an empty string view if all remaining data was
+  // read. If `n` exceeded the amount of remaining data this function will
+  // return an empty string view and `tree` will be set to nullptr.
+  // In both cases, `consumed` will be set to `length`.
+  absl::string_view Read(size_t n, size_t chunk_size, CordRep*& tree);
+
+  // Navigates to the chunk at offset `offset`.
+  // Returns a reference into the navigated to chunk, adjusted for the relative
+  // position of `offset` into that chunk. For example, calling `Seek(13)` on a
+  // cord tree containing 2 chunks of 10 and 20 bytes respectively will return
+  // a string view into the second chunk starting at offset 3 with a size of 17.
+  // Returns an empty string view if `offset` is equal to or greater than the
+  // length of the referenced tree.
+  absl::string_view Seek(size_t offset);
+
+ private:
+  size_t remaining_ = 0;
+  CordRepBtreeNavigator navigator_;
+};
+
+inline size_t CordRepBtreeReader::length() const {
+  assert(btree() != nullptr);
+  return btree()->length;
+}
+
+inline absl::string_view CordRepBtreeReader::Init(CordRepBtree* tree) {
+  assert(tree != nullptr);
+  const CordRep* edge = navigator_.InitFirst(tree);
+  remaining_ = tree->length - edge->length;
+  return EdgeData(edge);
+}
+
+inline absl::string_view CordRepBtreeReader::Next() {
+  if (remaining_ == 0) return {};
+  const CordRep* edge = navigator_.Next();
+  assert(edge != nullptr);
+  remaining_ -= edge->length;
+  return EdgeData(edge);
+}
+
+inline absl::string_view CordRepBtreeReader::Skip(size_t skip) {
+  // As we are always positioned on the last 'consumed' edge, we
+  // need to skip the current edge as well as `skip`.
+  const size_t edge_length = navigator_.Current()->length;
+  CordRepBtreeNavigator::Position pos = navigator_.Skip(skip + edge_length);
+  if (ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
+    remaining_ = 0;
+    return {};
+  }
+  // The combined length of all edges skipped before `pos.edge` is `skip -
+  // pos.offset`, all of which are 'consumed', as well as the current edge.
+  remaining_ -= skip - pos.offset + pos.edge->length;
+  return EdgeData(pos.edge).substr(pos.offset);
+}
+
+inline absl::string_view CordRepBtreeReader::Seek(size_t offset) {
+  const CordRepBtreeNavigator::Position pos = navigator_.Seek(offset);
+  if (ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
+    remaining_ = 0;
+    return {};
+  }
+  absl::string_view chunk = EdgeData(pos.edge).substr(pos.offset);
+  remaining_ = length() - offset - chunk.length();
+  return chunk;
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_consume.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_consume.h
new file mode 100644
index 0000000..d46fca2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_consume.h
@@ -0,0 +1,50 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
+
+#include <functional>
+
+#include "absl/functional/function_ref.h"
+#include "absl/strings/internal/cord_internal.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// Functor for the Consume() and ReverseConsume() functions:
+//   void ConsumeFunc(CordRep* rep, size_t offset, size_t length);
+// See the Consume() and ReverseConsume() function comments for documentation.
+using ConsumeFn = FunctionRef<void(CordRep*, size_t, size_t)>;
+
+// Consume() and ReverseConsume() consume CONCAT based trees and invoke the
+// provided functor with the contained nodes in the proper forward or reverse
+// order, which is used to convert CONCAT trees into other tree or cord data.
+// All CONCAT and SUBSTRING nodes are processed internally. The 'offset`
+// parameter of the functor is non-zero for any nodes below SUBSTRING nodes.
+// It's up to the caller to form these back into SUBSTRING nodes or otherwise
+// store offset / prefix information. These functions are intended to be used
+// only for migration / transitional code where due to factors such as ODR
+// violations, we can not 100% guarantee that all code respects 'new format'
+// settings and flags, so we need to be able to parse old data on the fly until
+// all old code is deprecated / no longer the default format.
+void Consume(CordRep* rep, ConsumeFn consume_fn);
+void ReverseConsume(CordRep* rep, ConsumeFn consume_fn);
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_crc.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_crc.h
new file mode 100644
index 0000000..5294b0d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_crc.h
@@ -0,0 +1,102 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+#include "absl/strings/internal/cord_internal.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordRepCrc is a CordRep node intended only to appear at the top level of a
+// cord tree.  It associates an "expected CRC" with the contained data, to allow
+// for easy passage of checksum data in Cord data flows.
+//
+// From Cord's perspective, the crc value has no semantics; any validation of
+// the contained checksum is the user's responsibility.
+struct CordRepCrc : public CordRep {
+  CordRep* child;
+  uint32_t crc;
+
+  // Consumes `child` and returns a CordRepCrc prefixed tree containing `child`.
+  // If the specified `child` is itself a CordRepCrc node, then this method
+  // either replaces the existing node, or directly updates the crc value in it
+  // depending on the node being shared or not, i.e.: refcount.IsOne().
+  // `child` must not be null. Never returns null.
+  static CordRepCrc* New(CordRep* child, uint32_t crc);
+
+  // Destroys (deletes) the provided node. `node` must not be null.
+  static void Destroy(CordRepCrc* node);
+};
+
+// Consumes `rep` and returns a CordRep* with any outer CordRepCrc wrapper
+// removed.  This is usually a no-op (returning `rep`), but this will remove and
+// unref an outer CordRepCrc node.
+inline CordRep* RemoveCrcNode(CordRep* rep) {
+  assert(rep != nullptr);
+  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
+    CordRep* child = rep->crc()->child;
+    if (rep->refcount.IsOne()) {
+      delete rep->crc();
+    } else {
+      CordRep::Ref(child);
+      CordRep::Unref(rep);
+    }
+    return child;
+  }
+  return rep;
+}
+
+// Returns `rep` if it is not a CordRepCrc node, or its child if it is.
+// Does not consume or create a reference on `rep` or the returned value.
+inline CordRep* SkipCrcNode(CordRep* rep) {
+  assert(rep != nullptr);
+  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
+    return rep->crc()->child;
+  } else {
+    return rep;
+  }
+}
+
+inline const CordRep* SkipCrcNode(const CordRep* rep) {
+  assert(rep != nullptr);
+  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
+    return rep->crc()->child;
+  } else {
+    return rep;
+  }
+}
+
+inline CordRepCrc* CordRep::crc() {
+  assert(IsCrc());
+  return static_cast<CordRepCrc*>(this);
+}
+
+inline const CordRepCrc* CordRep::crc() const {
+  assert(IsCrc());
+  return static_cast<const CordRepCrc*>(this);
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_flat.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_flat.h
new file mode 100644
index 0000000..e3e27fc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_flat.h
@@ -0,0 +1,187 @@
+// Copyright 2020 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/strings/internal/cord_internal.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// Note: all constants below are never ODR used and internal to cord, we define
+// these as static constexpr to avoid 'in struct' definition and usage clutter.
+
+// Largest and smallest flat node lengths we are willing to allocate
+// Flat allocation size is stored in tag, which currently can encode sizes up
+// to 4K, encoded as multiple of either 8 or 32 bytes.
+// If we allow for larger sizes, we need to change this to 8/64, 16/128, etc.
+// kMinFlatSize is bounded by tag needing to be at least FLAT * 8 bytes, and
+// ideally a 'nice' size aligning with allocation and cacheline sizes like 32.
+// kMaxFlatSize is bounded by the size resulting in a computed tag no greater
+// than MAX_FLAT_TAG. MAX_FLAT_TAG provides for additional 'high' tag values.
+static constexpr size_t kFlatOverhead = offsetof(CordRep, storage);
+static constexpr size_t kMinFlatSize = 32;
+static constexpr size_t kMaxFlatSize = 4096;
+static constexpr size_t kMaxFlatLength = kMaxFlatSize - kFlatOverhead;
+static constexpr size_t kMinFlatLength = kMinFlatSize - kFlatOverhead;
+static constexpr size_t kMaxLargeFlatSize = 256 * 1024;
+static constexpr size_t kMaxLargeFlatLength = kMaxLargeFlatSize - kFlatOverhead;
+
+// kTagBase should make the Size <--> Tag computation resilient
+// against changes to the value of FLAT when we add a new tag..
+static constexpr uint8_t kTagBase = FLAT - 4;
+
+// Converts the provided rounded size to the corresponding tag
+constexpr uint8_t AllocatedSizeToTagUnchecked(size_t size) {
+  return static_cast<uint8_t>(size <= 512 ? kTagBase + size / 8
+                              : size <= 8192
+                                  ? kTagBase + 512 / 8 + size / 64 - 512 / 64
+                                  : kTagBase + 512 / 8 + ((8192 - 512) / 64) +
+                                        size / 4096 - 8192 / 4096);
+}
+
+// Converts the provided tag to the corresponding allocated size
+constexpr size_t TagToAllocatedSize(uint8_t tag) {
+  return (tag <= kTagBase + 512 / 8) ? tag * 8 - kTagBase * 8
+         : (tag <= kTagBase + (512 / 8) + ((8192 - 512) / 64))
+             ? 512 + tag * 64 - kTagBase * 64 - 512 / 8 * 64
+             : 8192 + tag * 4096 - kTagBase * 4096 -
+                   ((512 / 8) + ((8192 - 512) / 64)) * 4096;
+}
+
+static_assert(AllocatedSizeToTagUnchecked(kMinFlatSize) == FLAT, "");
+static_assert(AllocatedSizeToTagUnchecked(kMaxLargeFlatSize) == MAX_FLAT_TAG,
+              "");
+
+// RoundUp logically performs `((n + m - 1) / m) * m` to round up to the nearest
+// multiple of `m`, optimized for the invariant that `m` is a power of 2.
+constexpr size_t RoundUp(size_t n, size_t m) {
+  return (n + m - 1) & (0 - m);
+}
+
+// Returns the size to the nearest equal or larger value that can be
+// expressed exactly as a tag value.
+inline size_t RoundUpForTag(size_t size) {
+  return RoundUp(size, (size <= 512) ? 8 : (size <= 8192 ? 64 : 4096));
+}
+
+// Converts the allocated size to a tag, rounding down if the size
+// does not exactly match a 'tag expressible' size value. The result is
+// undefined if the size exceeds the maximum size that can be encoded in
+// a tag, i.e., if size is larger than TagToAllocatedSize(<max tag>).
+inline uint8_t AllocatedSizeToTag(size_t size) {
+  const uint8_t tag = AllocatedSizeToTagUnchecked(size);
+  assert(tag <= MAX_FLAT_TAG);
+  return tag;
+}
+
+// Converts the provided tag to the corresponding available data length
+constexpr size_t TagToLength(uint8_t tag) {
+  return TagToAllocatedSize(tag) - kFlatOverhead;
+}
+
+// Enforce that kMaxFlatSize maps to a well-known exact tag value.
+static_assert(TagToAllocatedSize(MAX_FLAT_TAG) == kMaxLargeFlatSize,
+              "Bad tag logic");
+
+struct CordRepFlat : public CordRep {
+  // Tag for explicit 'large flat' allocation
+  struct Large {};
+
+  // Creates a new flat node.
+  template <size_t max_flat_size, typename... Args>
+  static CordRepFlat* NewImpl(size_t len, Args... args ABSL_ATTRIBUTE_UNUSED) {
+    if (len <= kMinFlatLength) {
+      len = kMinFlatLength;
+    } else if (len > max_flat_size - kFlatOverhead) {
+      len = max_flat_size - kFlatOverhead;
+    }
+
+    // Round size up so it matches a size we can exactly express in a tag.
+    const size_t size = RoundUpForTag(len + kFlatOverhead);
+    void* const raw_rep = ::operator new(size);
+    CordRepFlat* rep = new (raw_rep) CordRepFlat();
+    rep->tag = AllocatedSizeToTag(size);
+    return rep;
+  }
+
+  static CordRepFlat* New(size_t len) { return NewImpl<kMaxFlatSize>(len); }
+
+  static CordRepFlat* New(Large, size_t len) {
+    return NewImpl<kMaxLargeFlatSize>(len);
+  }
+
+  // Deletes a CordRepFlat instance created previously through a call to New().
+  // Flat CordReps are allocated and constructed with raw ::operator new and
+  // placement new, and must be destructed and deallocated accordingly.
+  static void Delete(CordRep*rep) {
+    assert(rep->tag >= FLAT && rep->tag <= MAX_FLAT_TAG);
+
+#if defined(__cpp_sized_deallocation)
+    size_t size = TagToAllocatedSize(rep->tag);
+    rep->~CordRep();
+    ::operator delete(rep, size);
+#else
+    rep->~CordRep();
+    ::operator delete(rep);
+#endif
+  }
+
+  // Create a CordRepFlat containing `data`, with an optional additional
+  // extra capacity of up to `extra` bytes. Requires that `data.size()`
+  // is less than kMaxFlatLength.
+  static CordRepFlat* Create(absl::string_view data, size_t extra = 0) {
+    assert(data.size() <= kMaxFlatLength);
+    CordRepFlat* flat = New(data.size() + (std::min)(extra, kMaxFlatLength));
+    memcpy(flat->Data(), data.data(), data.size());
+    flat->length = data.size();
+    return flat;
+  }
+
+  // Returns a pointer to the data inside this flat rep.
+  char* Data() { return reinterpret_cast<char*>(storage); }
+  const char* Data() const { return reinterpret_cast<const char*>(storage); }
+
+  // Returns the maximum capacity (payload size) of this instance.
+  size_t Capacity() const { return TagToLength(tag); }
+
+  // Returns the allocated size (payload + overhead) of this instance.
+  size_t AllocatedSize() const { return TagToAllocatedSize(tag); }
+};
+
+// Now that CordRepFlat is defined, we can define CordRep's helper casts:
+inline CordRepFlat* CordRep::flat() {
+  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
+  return reinterpret_cast<CordRepFlat*>(this);
+}
+
+inline const CordRepFlat* CordRep::flat() const {
+  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
+  return reinterpret_cast<const CordRepFlat*>(this);
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring.h
new file mode 100644
index 0000000..2000e21
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring.h
@@ -0,0 +1,607 @@
+// Copyright 2020 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <limits>
+#include <memory>
+
+#include "absl/container/internal/layout.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_flat.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// All operations modifying a ring buffer are implemented as static methods
+// requiring a CordRepRing instance with a reference adopted by the method.
+//
+// The methods return the modified ring buffer, which may be equal to the input
+// if the input was not shared, and having large enough capacity to accommodate
+// any newly added node(s). Otherwise, a copy of the input rep with the new
+// node(s) added is returned.
+//
+// Any modification on non shared ring buffers with enough capacity will then
+// require minimum atomic operations. Caller should where possible provide
+// reasonable `extra` hints for both anticipated extra `flat` byte space, as
+// well as anticipated extra nodes required for complex operations.
+//
+// Example of code creating a ring buffer, adding some data to it,
+// and discarding the buffer when done:
+//
+//   void FunWithRings() {
+//     // Create ring with 3 flats
+//     CordRep* flat = CreateFlat("Hello");
+//     CordRepRing* ring = CordRepRing::Create(flat, 2);
+//     ring = CordRepRing::Append(ring, CreateFlat(" "));
+//     ring = CordRepRing::Append(ring, CreateFlat("world"));
+//     DoSomethingWithRing(ring);
+//     CordRep::Unref(ring);
+//   }
+//
+// Example of code Copying an existing ring buffer and modifying it:
+//
+//   void MoreFunWithRings(CordRepRing* src) {
+//     CordRepRing* ring = CordRep::Ref(src)->ring();
+//     ring = CordRepRing::Append(ring, CreateFlat("Hello"));
+//     ring = CordRepRing::Append(ring, CreateFlat(" "));
+//     ring = CordRepRing::Append(ring, CreateFlat("world"));
+//     DoSomethingWithRing(ring);
+//     CordRep::Unref(ring);
+//   }
+//
+class CordRepRing : public CordRep {
+ public:
+  // `pos_type` represents a 'logical position'. A CordRepRing instance has a
+  // `begin_pos` (default 0), and each node inside the buffer will have an
+  // `end_pos` which is the `end_pos` of the previous node (or `begin_pos`) plus
+  // this node's length. The purpose is to allow for a binary search on this
+  // position, while allowing O(1) prepend and append operations.
+  using pos_type = size_t;
+
+  // `index_type` is the type for the `head`, `tail` and `capacity` indexes.
+  // Ring buffers are limited to having no more than four billion entries.
+  using index_type = uint32_t;
+
+  // `offset_type` is the type for the data offset inside a child rep's data.
+  using offset_type = uint32_t;
+
+  // Position holds the node index and relative offset into the node for
+  // some physical offset in the contained data as returned by the Find()
+  // and FindTail() methods.
+  struct Position {
+    index_type index;
+    size_t offset;
+  };
+
+  // The maximum # of child nodes that can be hosted inside a CordRepRing.
+  static constexpr size_t kMaxCapacity = (std::numeric_limits<uint32_t>::max)();
+
+  // CordRepring can not be default constructed, moved, copied or assigned.
+  CordRepRing() = delete;
+  CordRepRing(const CordRepRing&) = delete;
+  CordRepRing& operator=(const CordRepRing&) = delete;
+
+  // Returns true if this instance is valid, false if some or all of the
+  // invariants are broken. Intended for debug purposes only.
+  // `output` receives an explanation of the broken invariants.
+  bool IsValid(std::ostream& output) const;
+
+  // Returns the size in bytes for a CordRepRing with `capacity' entries.
+  static constexpr size_t AllocSize(size_t capacity);
+
+  // Returns the distance in bytes from `pos` to `end_pos`.
+  static constexpr size_t Distance(pos_type pos, pos_type end_pos);
+
+  // Creates a new ring buffer from the provided `rep`. Adopts a reference
+  // on `rep`. The returned ring buffer has a capacity of at least `extra + 1`
+  static CordRepRing* Create(CordRep* child, size_t extra = 0);
+
+  // `head`, `tail` and `capacity` indexes defining the ring buffer boundaries.
+  index_type head() const { return head_; }
+  index_type tail() const { return tail_; }
+  index_type capacity() const { return capacity_; }
+
+  // Returns the number of entries in this instance.
+  index_type entries() const { return entries(head_, tail_); }
+
+  // Returns the logical begin position of this instance.
+  pos_type begin_pos() const { return begin_pos_; }
+
+  // Returns the number of entries for a given head-tail range.
+  // Requires `head` and `tail` values to be less than `capacity()`.
+  index_type entries(index_type head, index_type tail) const {
+    assert(head < capacity_ && tail < capacity_);
+    return tail - head + ((tail > head) ? 0 : capacity_);
+  }
+
+  // Returns the logical end position of entry `index`.
+  pos_type const& entry_end_pos(index_type index) const {
+    assert(IsValidIndex(index));
+    return Layout::Partial().Pointer<0>(data_)[index];
+  }
+
+  // Returns the child pointer of entry `index`.
+  CordRep* const& entry_child(index_type index) const {
+    assert(IsValidIndex(index));
+    return Layout::Partial(capacity()).Pointer<1>(data_)[index];
+  }
+
+  // Returns the data offset of entry `index`
+  offset_type const& entry_data_offset(index_type index) const {
+    assert(IsValidIndex(index));
+    return Layout::Partial(capacity(), capacity()).Pointer<2>(data_)[index];
+  }
+
+  // Appends the provided child node to the `rep` instance.
+  // Adopts a reference from `rep` and `child` which may not be null.
+  // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node
+  // containing a FLAT or EXTERNAL node, then flat or external the node is added
+  // 'as is', with an offset added for the SUBSTRING case.
+  // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING or
+  // CONCAT tree, then all child nodes not excluded by any start offset or
+  // length values are added recursively.
+  static CordRepRing* Append(CordRepRing* rep, CordRep* child);
+
+  // Appends the provided string data to the `rep` instance.
+  // This function will attempt to utilize any remaining capacity in the last
+  // node of the input if that node is not shared (directly or indirectly), and
+  // of type FLAT. Remaining data will be added as one or more FLAT nodes.
+  // Any last node added to the ring buffer will be allocated with up to
+  // `extra` bytes of capacity for (anticipated) subsequent append actions.
+  static CordRepRing* Append(CordRepRing* rep, string_view data,
+                             size_t extra = 0);
+
+  // Prepends the provided child node to the `rep` instance.
+  // Adopts a reference from `rep` and `child` which may not be null.
+  // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node
+  // containing a FLAT or EXTERNAL node, then flat or external the node is
+  // prepended 'as is', with an optional offset added for the SUBSTRING case.
+  // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING
+  // or CONCAT tree, then all child nodes not excluded by any start offset or
+  // length values are added recursively.
+  static CordRepRing* Prepend(CordRepRing* rep, CordRep* child);
+
+  // Prepends the provided string data to the `rep` instance.
+  // This function will attempt to utilize any remaining capacity in the first
+  // node of the input if that node is not shared (directly or indirectly), and
+  // of type FLAT. Remaining data will be added as one or more FLAT nodes.
+  // Any first node prepnded to the ring buffer will be allocated with up to
+  // `extra` bytes of capacity for (anticipated) subsequent prepend actions.
+  static CordRepRing* Prepend(CordRepRing* rep, string_view data,
+                              size_t extra = 0);
+
+  // Returns a span referencing potentially unused capacity in the last node.
+  // The returned span may be empty if no such capacity is available, or if the
+  // current instance is shared. Else, a span of size `n <= size` is returned.
+  // If non empty, the ring buffer is adjusted to the new length, with the newly
+  // added capacity left uninitialized. Callers should assign a value to the
+  // entire span before any other operations on this instance.
+  Span<char> GetAppendBuffer(size_t size);
+
+  // Returns a span referencing potentially unused capacity in the first node.
+  // This function is identical to GetAppendBuffer except that it returns a span
+  // referencing up to `size` capacity directly before the existing data.
+  Span<char> GetPrependBuffer(size_t size);
+
+  // Returns a cord ring buffer containing `len` bytes of data starting at
+  // `offset`. If the input is not shared, this function will remove all head
+  // and tail child nodes outside of the requested range, and adjust the new
+  // head and tail nodes as required. If the input is shared, this function
+  // returns a new instance sharing some or all of the nodes from the input.
+  static CordRepRing* SubRing(CordRepRing* r, size_t offset, size_t len,
+                              size_t extra = 0);
+
+  // Returns a cord ring buffer with the first `len` bytes removed.
+  // If the input is not shared, this function will remove all head child nodes
+  // fully inside the first `length` bytes, and adjust the new head as required.
+  // If the input is shared, this function returns a new instance sharing some
+  // or all of the nodes from the input.
+  static CordRepRing* RemoveSuffix(CordRepRing* r, size_t len,
+                                   size_t extra = 0);
+
+  // Returns a cord ring buffer with the last `len` bytes removed.
+  // If the input is not shared, this function will remove all head child nodes
+  // fully inside the first `length` bytes, and adjust the new head as required.
+  // If the input is shared, this function returns a new instance sharing some
+  // or all of the nodes from the input.
+  static CordRepRing* RemovePrefix(CordRepRing* r, size_t len,
+                                   size_t extra = 0);
+
+  // Returns the character at `offset`. Requires that `offset < length`.
+  char GetCharacter(size_t offset) const;
+
+  // Returns true if this instance manages a single contiguous buffer, in which
+  // case the (optional) output parameter `fragment` is set. Otherwise, the
+  // function returns false, and `fragment` is left unchanged.
+  bool IsFlat(absl::string_view* fragment) const;
+
+  // Returns true if the data starting at `offset` with length `len` is
+  // managed by this instance inside a single contiguous buffer, in which case
+  // the (optional) output parameter `fragment` is set to the contiguous memory
+  // starting at offset `offset` with length `length`. Otherwise, the function
+  // returns false, and `fragment` is left unchanged.
+  bool IsFlat(size_t offset, size_t len, absl::string_view* fragment) const;
+
+  // Testing only: set capacity to requested capacity.
+  void SetCapacityForTesting(size_t capacity);
+
+  // Returns the CordRep data pointer for the provided CordRep.
+  // Requires that the provided `rep` is either a FLAT or EXTERNAL CordRep.
+  static const char* GetLeafData(const CordRep* rep);
+
+  // Returns the CordRep data pointer for the provided CordRep.
+  // Requires that `rep` is either a FLAT, EXTERNAL, or SUBSTRING CordRep.
+  static const char* GetRepData(const CordRep* rep);
+
+  // Advances the provided position, wrapping around capacity as needed.
+  // Requires `index` < capacity()
+  inline index_type advance(index_type index) const;
+
+  // Advances the provided position by 'n`, wrapping around capacity as needed.
+  // Requires `index` < capacity() and `n` <= capacity.
+  inline index_type advance(index_type index, index_type n) const;
+
+  // Retreats the provided position, wrapping around 0 as needed.
+  // Requires `index` < capacity()
+  inline index_type retreat(index_type index) const;
+
+  // Retreats the provided position by 'n', wrapping around 0 as needed.
+  // Requires `index` < capacity()
+  inline index_type retreat(index_type index, index_type n) const;
+
+  // Returns the logical begin position of entry `index`
+  pos_type const& entry_begin_pos(index_type index) const {
+    return (index == head_) ? begin_pos_ : entry_end_pos(retreat(index));
+  }
+
+  // Returns the physical start offset of entry `index`
+  size_t entry_start_offset(index_type index) const {
+    return Distance(begin_pos_, entry_begin_pos(index));
+  }
+
+  // Returns the physical end offset of entry `index`
+  size_t entry_end_offset(index_type index) const {
+    return Distance(begin_pos_, entry_end_pos(index));
+  }
+
+  // Returns the data length for entry `index`
+  size_t entry_length(index_type index) const {
+    return Distance(entry_begin_pos(index), entry_end_pos(index));
+  }
+
+  // Returns the data for entry `index`
+  absl::string_view entry_data(index_type index) const;
+
+  // Returns the position for `offset` as {index, prefix}. `index` holds the
+  // index of the entry at the specified offset and `prefix` holds the relative
+  // offset inside that entry.
+  // Requires `offset` < length.
+  //
+  // For example we can implement GetCharacter(offset) as:
+  //   char GetCharacter(size_t offset) {
+  //     Position pos = this->Find(offset);
+  //     return this->entry_data(pos.pos)[pos.offset];
+  //   }
+  inline Position Find(size_t offset) const;
+
+  // Find starting at `head`
+  inline Position Find(index_type head, size_t offset) const;
+
+  // Returns the tail position for `offset` as {tail index, suffix}.
+  // `tail index` holds holds the index of the entry holding the offset directly
+  // before 'offset` advanced by one. 'suffix` holds the relative offset from
+  // that relative offset in the entry to the end of the entry.
+  // For example, FindTail(length) will return {tail(), 0}, FindTail(length - 5)
+  // will return {retreat(tail), 5)} provided the preceding entry contains at
+  // least 5 bytes of data.
+  // Requires offset >= 1 && offset <= length.
+  //
+  // This function is very useful in functions that need to clip the end of some
+  // ring buffer such as 'RemovePrefix'.
+  // For example, we could implement RemovePrefix for non shared instances as:
+  //   void RemoveSuffix(size_t n) {
+  //     Position pos = FindTail(length - n);
+  //     UnrefEntries(pos.pos, this->tail_);
+  //     this->tail_ = pos.pos;
+  //     entry(retreat(pos.pos)).end_pos -= pos.offset;
+  //   }
+  inline Position FindTail(size_t offset) const;
+
+  // Find tail starting at `head`
+  inline Position FindTail(index_type head, size_t offset) const;
+
+  // Invokes f(index_type index) for each entry inside the range [head, tail>
+  template <typename F>
+  void ForEach(index_type head, index_type tail, F&& f) const {
+    index_type n1 = (tail > head) ? tail : capacity_;
+    for (index_type i = head; i < n1; ++i) f(i);
+    if (tail <= head) {
+      for (index_type i = 0; i < tail; ++i) f(i);
+    }
+  }
+
+  // Invokes f(index_type index) for each entry inside this instance.
+  template <typename F>
+  void ForEach(F&& f) const {
+    ForEach(head_, tail_, std::forward<F>(f));
+  }
+
+  // Dump this instance's data tp stream `s` in human readable format, excluding
+  // the actual data content itself. Intended for debug purposes only.
+  friend std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
+
+ private:
+  enum class AddMode { kAppend, kPrepend };
+
+  using Layout = container_internal::Layout<pos_type, CordRep*, offset_type>;
+
+  class Filler;
+  class Transaction;
+  class CreateTransaction;
+
+  static constexpr size_t kLayoutAlignment = Layout::Partial().Alignment();
+
+  // Creates a new CordRepRing.
+  explicit CordRepRing(index_type capacity) : capacity_(capacity) {}
+
+  // Returns true if `index` is a valid index into this instance.
+  bool IsValidIndex(index_type index) const;
+
+  // Debug use only: validates the provided CordRepRing invariants.
+  // Verification of all CordRepRing methods can be enabled by defining
+  // EXTRA_CORD_RING_VALIDATION, i.e.: `--copts=-DEXTRA_CORD_RING_VALIDATION`
+  // Verification is VERY expensive, so only do it for debugging purposes.
+  static CordRepRing* Validate(CordRepRing* rep, const char* file = nullptr,
+                               int line = 0);
+
+  // Allocates a CordRepRing large enough to hold `capacity + extra' entries.
+  // The returned capacity may be larger if the allocated memory allows for it.
+  // The maximum capacity of a CordRepRing is capped at kMaxCapacity.
+  // Throws `std::length_error` if `capacity + extra' exceeds kMaxCapacity.
+  static CordRepRing* New(size_t capacity, size_t extra);
+
+  // Deallocates (but does not destroy) the provided ring buffer.
+  static void Delete(CordRepRing* rep);
+
+  // Destroys the provided ring buffer, decrementing the reference count of all
+  // contained child CordReps. The provided 1\`rep` should have a ref count of
+  // one (pre decrement destroy call observing `refcount.IsOne()`) or zero
+  // (post decrement destroy call observing `!refcount.Decrement()`).
+  static void Destroy(CordRepRing* rep);
+
+  // Returns a mutable reference to the logical end position array.
+  pos_type* entry_end_pos() {
+    return Layout::Partial().Pointer<0>(data_);
+  }
+
+  // Returns a mutable reference to the child pointer array.
+  CordRep** entry_child() {
+    return Layout::Partial(capacity()).Pointer<1>(data_);
+  }
+
+  // Returns a mutable reference to the data offset array.
+  offset_type* entry_data_offset() {
+    return Layout::Partial(capacity(), capacity()).Pointer<2>(data_);
+  }
+
+  // Find implementations for the non fast path 0 / length cases.
+  Position FindSlow(index_type head, size_t offset) const;
+  Position FindTailSlow(index_type head, size_t offset) const;
+
+  // Finds the index of the first node that is inside a reasonable distance
+  // of the node at `offset` from which we can continue with a linear search.
+  template <bool wrap>
+  index_type FindBinary(index_type head, index_type tail, size_t offset) const;
+
+  // Fills the current (initialized) instance from the provided source, copying
+  // entries [head, tail). Adds a reference to copied entries if `ref` is true.
+  template <bool ref>
+  void Fill(const CordRepRing* src, index_type head, index_type tail);
+
+  // Create a copy of 'rep', copying all entries [head, tail), allocating room
+  // for `extra` entries. Adds a reference on all copied entries.
+  static CordRepRing* Copy(CordRepRing* rep, index_type head, index_type tail,
+                           size_t extra = 0);
+
+  // Returns a Mutable CordRepRing reference from `rep` with room for at least
+  // `extra` additional nodes. Adopts a reference count from `rep`.
+  // This function will return `rep` if, and only if:
+  // - rep.entries + extra <= rep.capacity
+  // - rep.refcount == 1
+  // Otherwise, this function will create a new copy of `rep` with additional
+  // capacity to satisfy `extra` extra nodes, and unref the old `rep` instance.
+  //
+  // If a new CordRepRing can not be allocated, or the new capacity would exceed
+  // the maxmimum capacity, then the input is consumed only, and an exception is
+  // thrown.
+  static CordRepRing* Mutable(CordRepRing* rep, size_t extra);
+
+  // Slow path for Append(CordRepRing* rep, CordRep* child). This function is
+  // exercised if the provided `child` in Append() is not a leaf node, i.e., a
+  // ring buffer or old (concat) cord tree.
+  static CordRepRing* AppendSlow(CordRepRing* rep, CordRep* child);
+
+  // Appends the provided leaf node. Requires `child` to be FLAT or EXTERNAL.
+  static CordRepRing* AppendLeaf(CordRepRing* rep, CordRep* child,
+                                 size_t offset, size_t length);
+
+  // Prepends the provided leaf node. Requires `child` to be FLAT or EXTERNAL.
+  static CordRepRing* PrependLeaf(CordRepRing* rep, CordRep* child,
+                                  size_t offset, size_t length);
+
+  // Slow path for Prepend(CordRepRing* rep, CordRep* child). This function is
+  // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a
+  // ring buffer or old (concat) cord tree.
+  static CordRepRing* PrependSlow(CordRepRing* rep, CordRep* child);
+
+  // Slow path for Create(CordRep* child, size_t extra). This function is
+  // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a
+  // ring buffer or old (concat) cord tree.
+  static CordRepRing* CreateSlow(CordRep* child, size_t extra);
+
+  // Creates a new ring buffer from the provided `child` leaf node. Requires
+  // `child` to be FLAT or EXTERNAL. on `rep`.
+  // The returned ring buffer has a capacity of at least `1 + extra`
+  static CordRepRing* CreateFromLeaf(CordRep* child, size_t offset,
+                                     size_t length, size_t extra);
+
+  // Appends or prepends (depending on AddMode) the ring buffer in `ring' to
+  // `rep` starting at `offset` with length `len`.
+  template <AddMode mode>
+  static CordRepRing* AddRing(CordRepRing* rep, CordRepRing* ring,
+                              size_t offset, size_t len);
+
+  // Increases the data offset for entry `index` by `n`.
+  void AddDataOffset(index_type index, size_t n);
+
+  // Descreases the length for entry `index` by `n`.
+  void SubLength(index_type index, size_t n);
+
+  index_type head_;
+  index_type tail_;
+  index_type capacity_;
+  pos_type begin_pos_;
+
+  alignas(kLayoutAlignment) char data_[kLayoutAlignment];
+
+  friend struct CordRep;
+};
+
+constexpr size_t CordRepRing::AllocSize(size_t capacity) {
+  return sizeof(CordRepRing) - sizeof(data_) +
+         Layout(capacity, capacity, capacity).AllocSize();
+}
+
+inline constexpr size_t CordRepRing::Distance(pos_type pos, pos_type end_pos) {
+  return (end_pos - pos);
+}
+
+inline const char* CordRepRing::GetLeafData(const CordRep* rep) {
+  return rep->tag != EXTERNAL ? rep->flat()->Data() : rep->external()->base;
+}
+
+inline const char* CordRepRing::GetRepData(const CordRep* rep) {
+  if (rep->tag >= FLAT) return rep->flat()->Data();
+  if (rep->tag == EXTERNAL) return rep->external()->base;
+  return GetLeafData(rep->substring()->child) + rep->substring()->start;
+}
+
+inline CordRepRing::index_type CordRepRing::advance(index_type index) const {
+  assert(index < capacity_);
+  return ++index == capacity_ ? 0 : index;
+}
+
+inline CordRepRing::index_type CordRepRing::advance(index_type index,
+                                                    index_type n) const {
+  assert(index < capacity_ && n <= capacity_);
+  return (index += n) >= capacity_ ? index - capacity_ : index;
+}
+
+inline CordRepRing::index_type CordRepRing::retreat(index_type index) const {
+  assert(index < capacity_);
+  return (index > 0 ? index : capacity_) - 1;
+}
+
+inline CordRepRing::index_type CordRepRing::retreat(index_type index,
+                                                    index_type n) const {
+  assert(index < capacity_ && n <= capacity_);
+  return index >= n ? index - n : capacity_ - n + index;
+}
+
+inline absl::string_view CordRepRing::entry_data(index_type index) const {
+  size_t data_offset = entry_data_offset(index);
+  return {GetRepData(entry_child(index)) + data_offset, entry_length(index)};
+}
+
+inline bool CordRepRing::IsValidIndex(index_type index) const {
+  if (index >= capacity_) return false;
+  return (tail_ > head_) ? (index >= head_ && index < tail_)
+                         : (index >= head_ || index < tail_);
+}
+
+#ifndef EXTRA_CORD_RING_VALIDATION
+inline CordRepRing* CordRepRing::Validate(CordRepRing* rep,
+                                          const char* /*file*/, int /*line*/) {
+  return rep;
+}
+#endif
+
+inline CordRepRing::Position CordRepRing::Find(size_t offset) const {
+  assert(offset < length);
+  return (offset == 0) ? Position{head_, 0} : FindSlow(head_, offset);
+}
+
+inline CordRepRing::Position CordRepRing::Find(index_type head,
+                                               size_t offset) const {
+  assert(offset < length);
+  assert(IsValidIndex(head) && offset >= entry_start_offset(head));
+  return (offset == 0) ? Position{head_, 0} : FindSlow(head, offset);
+}
+
+inline CordRepRing::Position CordRepRing::FindTail(size_t offset) const {
+  assert(offset > 0 && offset <= length);
+  return (offset == length) ? Position{tail_, 0} : FindTailSlow(head_, offset);
+}
+
+inline CordRepRing::Position CordRepRing::FindTail(index_type head,
+                                                   size_t offset) const {
+  assert(offset > 0 && offset <= length);
+  assert(IsValidIndex(head) && offset >= entry_start_offset(head) + 1);
+  return (offset == length) ? Position{tail_, 0} : FindTailSlow(head, offset);
+}
+
+// Now that CordRepRing is defined, we can define CordRep's helper casts:
+inline CordRepRing* CordRep::ring() {
+  assert(IsRing());
+  return static_cast<CordRepRing*>(this);
+}
+
+inline const CordRepRing* CordRep::ring() const {
+  assert(IsRing());
+  return static_cast<const CordRepRing*>(this);
+}
+
+inline bool CordRepRing::IsFlat(absl::string_view* fragment) const {
+  if (entries() == 1) {
+    if (fragment) *fragment = entry_data(head());
+    return true;
+  }
+  return false;
+}
+
+inline bool CordRepRing::IsFlat(size_t offset, size_t len,
+                                absl::string_view* fragment) const {
+  const Position pos = Find(offset);
+  const absl::string_view data = entry_data(pos.index);
+  if (data.length() >= len && data.length() - len >= pos.offset) {
+    if (fragment) *fragment = data.substr(pos.offset, len);
+    return true;
+  }
+  return false;
+}
+
+std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring_reader.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring_reader.h
new file mode 100644
index 0000000..7ceeaa0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring_reader.h
@@ -0,0 +1,118 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_ring.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordRepRingReader provides basic navigation over CordRepRing data.
+class CordRepRingReader {
+ public:
+  // Returns true if this instance is not empty.
+  explicit operator bool() const { return ring_ != nullptr; }
+
+  // Returns the ring buffer reference for this instance, or nullptr if empty.
+  CordRepRing* ring() const { return ring_; }
+
+  // Returns the current node index inside the ring buffer for this instance.
+  // The returned value is undefined if this instance is empty.
+  CordRepRing::index_type index() const { return index_; }
+
+  // Returns the current node inside the ring buffer for this instance.
+  // The returned value is undefined if this instance is empty.
+  CordRep* node() const { return ring_->entry_child(index_); }
+
+  // Returns the length of the referenced ring buffer.
+  // Requires the current instance to be non empty.
+  size_t length() const {
+    assert(ring_);
+    return ring_->length;
+  }
+
+  // Returns the end offset of the last navigated-to chunk, which represents the
+  // total bytes 'consumed' relative to the start of the ring. The returned
+  // value is never zero. For example, initializing a reader with a ring buffer
+  // with a first chunk of 19 bytes will return consumed() = 19.
+  // Requires the current instance to be non empty.
+  size_t consumed() const {
+    assert(ring_);
+    return ring_->entry_end_offset(index_);
+  }
+
+  // Returns the number of bytes remaining beyond the last navigated-to chunk.
+  // Requires the current instance to be non empty.
+  size_t remaining() const {
+    assert(ring_);
+    return length() - consumed();
+  }
+
+  // Resets this instance to an empty value
+  void Reset() { ring_ = nullptr; }
+
+  // Resets this instance to the start of `ring`. `ring` must not be null.
+  // Returns a reference into the first chunk of the provided ring.
+  absl::string_view Reset(CordRepRing* ring) {
+    assert(ring);
+    ring_ = ring;
+    index_ = ring_->head();
+    return ring_->entry_data(index_);
+  }
+
+  // Navigates to the next chunk inside the reference ring buffer.
+  // Returns a reference into the navigated-to chunk.
+  // Requires remaining() to be non zero.
+  absl::string_view Next() {
+    assert(remaining());
+    index_ = ring_->advance(index_);
+    return ring_->entry_data(index_);
+  }
+
+  // Navigates to the chunk at offset `offset`.
+  // Returns a reference into the navigated-to chunk, adjusted for the relative
+  // position of `offset` into that chunk. For example, calling Seek(13) on a
+  // ring buffer containing 2 chunks of 10 and 20 bytes respectively will return
+  // a string view into the second chunk starting at offset 3 with a size of 17.
+  // Requires `offset` to be less than `length()`
+  absl::string_view Seek(size_t offset) {
+    assert(offset < length());
+    size_t current = ring_->entry_end_offset(index_);
+    CordRepRing::index_type hint = (offset >= current) ? index_ : ring_->head();
+    const CordRepRing::Position head = ring_->Find(hint, offset);
+    index_ = head.index;
+    auto data = ring_->entry_data(head.index);
+    data.remove_prefix(head.offset);
+    return data;
+  }
+
+ private:
+  CordRepRing* ring_ = nullptr;
+  CordRepRing::index_type index_;
+};
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_test_util.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_test_util.h
new file mode 100644
index 0000000..18a0a19
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_test_util.h
@@ -0,0 +1,205 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
+
+#include <cassert>
+#include <memory>
+#include <random>
+#include <string>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_btree.h"
+#include "absl/strings/internal/cord_rep_flat.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cordrep_testing {
+
+inline cord_internal::CordRepSubstring* MakeSubstring(
+    size_t start, size_t len, cord_internal::CordRep* rep) {
+  auto* sub = new cord_internal::CordRepSubstring;
+  sub->tag = cord_internal::SUBSTRING;
+  sub->start = start;
+  sub->length = len <= 0 ? rep->length - start + len : len;
+  sub->child = rep;
+  return sub;
+}
+
+inline cord_internal::CordRepFlat* MakeFlat(absl::string_view value) {
+  assert(value.length() <= cord_internal::kMaxFlatLength);
+  auto* flat = cord_internal::CordRepFlat::New(value.length());
+  flat->length = value.length();
+  memcpy(flat->Data(), value.data(), value.length());
+  return flat;
+}
+
+// Creates an external node for testing
+inline cord_internal::CordRepExternal* MakeExternal(absl::string_view s) {
+  struct Rep : public cord_internal::CordRepExternal {
+    std::string s;
+    explicit Rep(absl::string_view sv) : s(sv) {
+      this->tag = cord_internal::EXTERNAL;
+      this->base = s.data();
+      this->length = s.length();
+      this->releaser_invoker = [](cord_internal::CordRepExternal* self) {
+        delete static_cast<Rep*>(self);
+      };
+    }
+  };
+  return new Rep(s);
+}
+
+inline std::string CreateRandomString(size_t n) {
+  absl::string_view data =
+      "abcdefghijklmnopqrstuvwxyz"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "0123456789~!@#$%^&*()_+=-<>?:\"{}[]|";
+  std::minstd_rand rnd;
+  std::uniform_int_distribution<size_t> dist(0, data.size() - 1);
+  std::string s(n, ' ');
+  for (size_t i = 0; i < n; ++i) {
+    s[i] = data[dist(rnd)];
+  }
+  return s;
+}
+
+// Creates an array of flats from the provided string, chopping
+// the provided string up into flats of size `chunk_size` characters
+// resulting in roughly `data.size() / chunk_size` total flats.
+inline std::vector<cord_internal::CordRep*> CreateFlatsFromString(
+    absl::string_view data, size_t chunk_size) {
+  assert(chunk_size > 0);
+  std::vector<cord_internal::CordRep*> flats;
+  for (absl::string_view s = data; !s.empty(); s.remove_prefix(chunk_size)) {
+    flats.push_back(MakeFlat(s.substr(0, chunk_size)));
+  }
+  return flats;
+}
+
+inline cord_internal::CordRepBtree* CordRepBtreeFromFlats(
+    absl::Span<cord_internal::CordRep* const> flats) {
+  assert(!flats.empty());
+  auto* node = cord_internal::CordRepBtree::Create(flats[0]);
+  for (size_t i = 1; i < flats.size(); ++i) {
+    node = cord_internal::CordRepBtree::Append(node, flats[i]);
+  }
+  return node;
+}
+
+template <typename Fn>
+inline void CordVisitReps(cord_internal::CordRep* rep, Fn&& fn) {
+  fn(rep);
+  while (rep->tag == cord_internal::SUBSTRING) {
+    rep = rep->substring()->child;
+    fn(rep);
+  }
+  if (rep->tag == cord_internal::BTREE) {
+    for (cord_internal::CordRep* edge : rep->btree()->Edges()) {
+      CordVisitReps(edge, fn);
+    }
+  }
+}
+
+template <typename Predicate>
+inline std::vector<cord_internal::CordRep*> CordCollectRepsIf(
+    Predicate&& predicate, cord_internal::CordRep* rep) {
+  std::vector<cord_internal::CordRep*> reps;
+  CordVisitReps(rep, [&reps, &predicate](cord_internal::CordRep* rep) {
+    if (predicate(rep)) reps.push_back(rep);
+  });
+  return reps;
+}
+
+inline std::vector<cord_internal::CordRep*> CordCollectReps(
+    cord_internal::CordRep* rep) {
+  std::vector<cord_internal::CordRep*> reps;
+  auto fn = [&reps](cord_internal::CordRep* rep) { reps.push_back(rep); };
+  CordVisitReps(rep, fn);
+  return reps;
+}
+
+inline void CordToString(cord_internal::CordRep* rep, std::string& s) {
+  size_t offset = 0;
+  size_t length = rep->length;
+  while (rep->tag == cord_internal::SUBSTRING) {
+    offset += rep->substring()->start;
+    rep = rep->substring()->child;
+  }
+  if (rep->tag == cord_internal::BTREE) {
+    for (cord_internal::CordRep* edge : rep->btree()->Edges()) {
+      CordToString(edge, s);
+    }
+  } else if (rep->tag >= cord_internal::FLAT) {
+    s.append(rep->flat()->Data() + offset, length);
+  } else if (rep->tag == cord_internal::EXTERNAL) {
+    s.append(rep->external()->base + offset, length);
+  } else {
+    ABSL_RAW_LOG(FATAL, "Unsupported tag %d", rep->tag);
+  }
+}
+
+inline std::string CordToString(cord_internal::CordRep* rep) {
+  std::string s;
+  s.reserve(rep->length);
+  CordToString(rep, s);
+  return s;
+}
+
+// RAII Helper class to automatically unref reps on destruction.
+class AutoUnref {
+ public:
+  ~AutoUnref() {
+    for (CordRep* rep : unrefs_) CordRep::Unref(rep);
+  }
+
+  // Adds `rep` to the list of reps to be unreffed at destruction.
+  template <typename CordRepType>
+  CordRepType* Add(CordRepType* rep) {
+    unrefs_.push_back(rep);
+    return rep;
+  }
+
+  // Increments the reference count of `rep` by one, and adds it to
+  // the list of reps to be unreffed at destruction.
+  template <typename CordRepType>
+  CordRepType* Ref(CordRepType* rep) {
+    unrefs_.push_back(CordRep::Ref(rep));
+    return rep;
+  }
+
+  // Increments the reference count of `rep` by one if `condition` is true,
+  // and adds it to the list of reps to be unreffed at destruction.
+  template <typename CordRepType>
+  CordRepType* RefIf(bool condition, CordRepType* rep) {
+    if (condition) unrefs_.push_back(CordRep::Ref(rep));
+    return rep;
+  }
+
+ private:
+  using CordRep = absl::cord_internal::CordRep;
+
+  std::vector<CordRep*> unrefs_;
+};
+
+}  // namespace cordrep_testing
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_functions.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_functions.h
new file mode 100644
index 0000000..c9ba145
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_functions.h
@@ -0,0 +1,85 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_CORDZ_FUNCTIONS_H_
+#define ABSL_STRINGS_CORDZ_FUNCTIONS_H_
+
+#include <stdint.h>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// Returns the current sample rate. This represents the average interval
+// between samples.
+int32_t get_cordz_mean_interval();
+
+// Sets the sample rate with the average interval between samples.
+void set_cordz_mean_interval(int32_t mean_interval);
+
+// Enable cordz unless any of the following applies:
+// - no thread local support
+// - MSVC build
+// - Android build
+// - Apple build
+// - DLL build
+// Hashtablez is turned off completely in opensource builds.
+// MSVC's static atomics are dynamically initialized in debug mode, which breaks
+// sampling.
+#if defined(ABSL_HAVE_THREAD_LOCAL) && !defined(_MSC_VER)  && \
+    !defined(ABSL_BUILD_DLL) && !defined(ABSL_CONSUME_DLL) && \
+    !defined(__ANDROID__) && !defined(__APPLE__)
+#define ABSL_INTERNAL_CORDZ_ENABLED 1
+#endif
+
+#ifdef ABSL_INTERNAL_CORDZ_ENABLED
+
+// cordz_next_sample is the number of events until the next sample event. If
+// the value is 1 or less, the code will check on the next event if cordz is
+// enabled, and if so, will sample the Cord. cordz is only enabled when we can
+// use thread locals.
+ABSL_CONST_INIT extern thread_local int64_t cordz_next_sample;
+
+// Determines if the next sample should be profiled. If it is, the value pointed
+// at by next_sample will be set with the interval until the next sample.
+bool cordz_should_profile_slow();
+
+// Returns true if the next cord should be sampled.
+inline bool cordz_should_profile() {
+  if (ABSL_PREDICT_TRUE(cordz_next_sample > 1)) {
+    cordz_next_sample--;
+    return false;
+  }
+  return cordz_should_profile_slow();
+}
+
+// Sets the interval until the next sample (for testing only)
+void cordz_set_next_sample_for_testing(int64_t next_sample);
+
+#else  // ABSL_INTERNAL_CORDZ_ENABLED
+
+inline bool cordz_should_profile() { return false; }
+inline void cordz_set_next_sample_for_testing(int64_t) {}
+
+#endif  // ABSL_INTERNAL_CORDZ_ENABLED
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CORDZ_FUNCTIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_handle.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_handle.h
new file mode 100644
index 0000000..5df53c7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_handle.h
@@ -0,0 +1,131 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_CORDZ_HANDLE_H_
+#define ABSL_STRINGS_CORDZ_HANDLE_H_
+
+#include <atomic>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// This base class allows multiple types of object (CordzInfo and
+// CordzSampleToken) to exist simultaneously on the delete queue (pointed to by
+// global_dq_tail and traversed using dq_prev_ and dq_next_). The
+// delete queue guarantees that once a profiler creates a CordzSampleToken and
+// has gained visibility into a CordzInfo object, that CordzInfo object will not
+// be deleted prematurely. This allows the profiler to inspect all CordzInfo
+// objects that are alive without needing to hold a global lock.
+class CordzHandle {
+ public:
+  CordzHandle() : CordzHandle(false) {}
+
+  bool is_snapshot() const { return is_snapshot_; }
+
+  // Returns true if this instance is safe to be deleted because it is either a
+  // snapshot, which is always safe to delete, or not included in the global
+  // delete queue and thus not included in any snapshot.
+  // Callers are responsible for making sure this instance can not be newly
+  // discovered by other threads. For example, CordzInfo instances first de-list
+  // themselves from the global CordzInfo list before determining if they are
+  // safe to be deleted directly.
+  // If SafeToDelete returns false, callers MUST use the Delete() method to
+  // safely queue CordzHandle instances for deletion.
+  bool SafeToDelete() const;
+
+  // Deletes the provided instance, or puts it on the delete queue to be deleted
+  // once there are no more sample tokens (snapshot) instances potentially
+  // referencing the instance. `handle` should not be null.
+  static void Delete(CordzHandle* handle);
+
+  // Returns the current entries in the delete queue in LIFO order.
+  static std::vector<const CordzHandle*> DiagnosticsGetDeleteQueue();
+
+  // Returns true if the provided handle is nullptr or guarded by this handle.
+  // Since the CordzSnapshot token is itself a CordzHandle, this method will
+  // allow tests to check if that token is keeping an arbitrary CordzHandle
+  // alive.
+  bool DiagnosticsHandleIsSafeToInspect(const CordzHandle* handle) const;
+
+  // Returns the current entries in the delete queue, in LIFO order, that are
+  // protected by this. CordzHandle objects are only placed on the delete queue
+  // after CordzHandle::Delete is called with them as an argument. Only
+  // CordzHandle objects that are not also CordzSnapshot objects will be
+  // included in the return vector. For each of the handles in the return
+  // vector, the earliest that their memory can be freed is when this
+  // CordzSnapshot object is deleted.
+  std::vector<const CordzHandle*> DiagnosticsGetSafeToInspectDeletedHandles();
+
+ protected:
+  explicit CordzHandle(bool is_snapshot);
+  virtual ~CordzHandle();
+
+ private:
+  // Global queue data. CordzHandle stores a pointer to the global queue
+  // instance to harden against ODR violations.
+  struct Queue {
+    constexpr explicit Queue(absl::ConstInitType)
+        : mutex(absl::kConstInit,
+                absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL) {}
+
+    absl::base_internal::SpinLock mutex;
+    std::atomic<CordzHandle*> dq_tail ABSL_GUARDED_BY(mutex){nullptr};
+
+    // Returns true if this delete queue is empty. This method does not acquire
+    // the lock, but does a 'load acquire' observation on the delete queue tail.
+    // It is used inside Delete() to check for the presence of a delete queue
+    // without holding the lock. The assumption is that the caller is in the
+    // state of 'being deleted', and can not be newly discovered by a concurrent
+    // 'being constructed' snapshot instance. Practically, this means that any
+    // such discovery (`find`, 'first' or 'next', etc) must have proper 'happens
+    // before / after' semantics and atomic fences.
+    bool IsEmpty() const ABSL_NO_THREAD_SAFETY_ANALYSIS {
+      return dq_tail.load(std::memory_order_acquire) == nullptr;
+    }
+  };
+
+  void ODRCheck() const {
+#ifndef NDEBUG
+    ABSL_RAW_CHECK(queue_ == &global_queue_, "ODR violation in Cord");
+#endif
+  }
+
+  ABSL_CONST_INIT static Queue global_queue_;
+  Queue* const queue_ = &global_queue_;
+  const bool is_snapshot_;
+
+  // dq_prev_ and dq_next_ require the global queue mutex to be held.
+  // Unfortunately we can't use thread annotations such that the thread safety
+  // analysis understands that queue_ and global_queue_ are one and the same.
+  CordzHandle* dq_prev_  = nullptr;
+  CordzHandle* dq_next_ = nullptr;
+};
+
+class CordzSnapshot : public CordzHandle {
+ public:
+  CordzSnapshot() : CordzHandle(true) {}
+};
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CORDZ_HANDLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_info.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_info.h
new file mode 100644
index 0000000..026d5b9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_info.h
@@ -0,0 +1,298 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_CORDZ_INFO_H_
+#define ABSL_STRINGS_CORDZ_INFO_H_
+
+#include <atomic>
+#include <cstdint>
+#include <functional>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cordz_functions.h"
+#include "absl/strings/internal/cordz_handle.h"
+#include "absl/strings/internal/cordz_statistics.h"
+#include "absl/strings/internal/cordz_update_tracker.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordzInfo tracks a profiled Cord. Each of these objects can be in two places.
+// If a Cord is alive, the CordzInfo will be in the global_cordz_infos map, and
+// can also be retrieved via the linked list starting with
+// global_cordz_infos_head and continued via the cordz_info_next() method. When
+// a Cord has reached the end of its lifespan, the CordzInfo object will be
+// migrated out of the global_cordz_infos list and the global_cordz_infos_map,
+// and will either be deleted or appended to the global_delete_queue. If it is
+// placed on the global_delete_queue, the CordzInfo object will be cleaned in
+// the destructor of a CordzSampleToken object.
+class ABSL_LOCKABLE CordzInfo : public CordzHandle {
+ public:
+  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
+
+  // TrackCord creates a CordzInfo instance which tracks important metrics of
+  // a sampled cord, and stores the created CordzInfo instance into `cord'. All
+  // CordzInfo instances are placed in a global list which is used to discover
+  // and snapshot all actively tracked cords. Callers are responsible for
+  // calling UntrackCord() before the tracked Cord instance is deleted, or to
+  // stop tracking the sampled Cord. Callers are also responsible for guarding
+  // changes to the 'tree' value of a Cord (InlineData.tree) through the Lock()
+  // and Unlock() calls. Any change resulting in a new tree value for the cord
+  // requires a call to SetCordRep() before the old tree has been unreffed
+  // and/or deleted. `method` identifies the Cord public API method initiating
+  // the cord to be sampled.
+  // Requires `cord` to hold a tree, and `cord.cordz_info()` to be null.
+  static void TrackCord(InlineData& cord, MethodIdentifier method);
+
+  // Identical to TrackCord(), except that this function fills the
+  // `parent_stack` and `parent_method` properties of the returned CordzInfo
+  // instance from the provided `src` instance if `src` is sampled.
+  // This function should be used for sampling 'copy constructed' and 'copy
+  // assigned' cords. This function allows 'cord` to be already sampled, in
+  // which case the CordzInfo will be newly created from `src`.
+  static void TrackCord(InlineData& cord, const InlineData& src,
+                        MethodIdentifier method);
+
+  // Maybe sample the cord identified by 'cord' for method 'method'.
+  // Uses `cordz_should_profile` to randomly pick cords to be sampled, and if
+  // so, invokes `TrackCord` to start sampling `cord`.
+  static void MaybeTrackCord(InlineData& cord, MethodIdentifier method);
+
+  // Maybe sample the cord identified by 'cord' for method 'method'.
+  // `src` identifies a 'parent' cord which is assigned to `cord`, typically the
+  // input cord for a copy constructor, or an assign method such as `operator=`
+  // `cord` will be sampled if (and only if) `src` is sampled.
+  // If `cord` is currently being sampled and `src` is not being sampled, then
+  // this function will stop sampling the cord and reset the cord's cordz_info.
+  //
+  // Previously this function defined that `cord` will be sampled if either
+  // `src` is sampled, or if `cord` is randomly picked for sampling. However,
+  // this can cause issues, as there may be paths where some cord is assigned an
+  // indirect copy of it's own value. As such a 'string of copies' would then
+  // remain sampled (`src.is_profiled`), then assigning such a cord back to
+  // 'itself' creates a cycle where the cord will converge to 'always sampled`.
+  //
+  // For example:
+  //
+  //   Cord x;
+  //   for (...) {
+  //     // Copy ctor --> y.is_profiled := x.is_profiled | random(...)
+  //     Cord y = x;
+  //     ...
+  //     // Assign x = y --> x.is_profiled = y.is_profiled | random(...)
+  //     //              ==> x.is_profiled |= random(...)
+  //     //              ==> x converges to 'always profiled'
+  //     x = y;
+  //   }
+  static void MaybeTrackCord(InlineData& cord, const InlineData& src,
+                             MethodIdentifier method);
+
+  // Stops tracking changes for a sampled cord, and deletes the provided info.
+  // This function must be called before the sampled cord instance is deleted,
+  // and before the root cordrep of the sampled cord is unreffed.
+  // This function may extend the lifetime of the cordrep in cases where the
+  // CordInfo instance is being held by a concurrent collection thread.
+  void Untrack();
+
+  // Invokes UntrackCord() on `info` if `info` is not null.
+  static void MaybeUntrackCord(CordzInfo* info);
+
+  CordzInfo() = delete;
+  CordzInfo(const CordzInfo&) = delete;
+  CordzInfo& operator=(const CordzInfo&) = delete;
+
+  // Retrieves the oldest existing CordzInfo.
+  static CordzInfo* Head(const CordzSnapshot& snapshot)
+      ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+  // Retrieves the next oldest existing CordzInfo older than 'this' instance.
+  CordzInfo* Next(const CordzSnapshot& snapshot) const
+      ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+  // Locks this instance for the update identified by `method`.
+  // Increases the count for `method` in `update_tracker`.
+  void Lock(MethodIdentifier method) ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_);
+
+  // Unlocks this instance. If the contained `rep` has been set to null
+  // indicating the Cord has been cleared or is otherwise no longer sampled,
+  // then this method will delete this CordzInfo instance.
+  void Unlock() ABSL_UNLOCK_FUNCTION(mutex_);
+
+  // Asserts that this CordzInfo instance is locked.
+  void AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_);
+
+  // Updates the `rep` property of this instance. This methods is invoked by
+  // Cord logic each time the root node of a sampled Cord changes, and before
+  // the old root reference count is deleted. This guarantees that collection
+  // code can always safely take a reference on the tracked cord.
+  // Requires a lock to be held through the `Lock()` method.
+  // TODO(b/117940323): annotate with ABSL_EXCLUSIVE_LOCKS_REQUIRED once all
+  // Cord code is in a state where this can be proven true by the compiler.
+  void SetCordRep(CordRep* rep);
+
+  // Returns the current `rep` property of this instance with a reference
+  // added, or null if this instance represents a cord that has since been
+  // deleted or untracked.
+  CordRep* RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns the current value of `rep_` for testing purposes only.
+  CordRep* GetCordRepForTesting() const ABSL_NO_THREAD_SAFETY_ANALYSIS {
+    return rep_;
+  }
+
+  // Sets the current value of `rep_` for testing purposes only.
+  void SetCordRepForTesting(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+    rep_ = rep;
+  }
+
+  // Returns the stack trace for where the cord was first sampled. Cords are
+  // potentially sampled when they promote from an inlined cord to a tree or
+  // ring representation, which is not necessarily the location where the cord
+  // was first created. Some cords are created as inlined cords, and only as
+  // data is added do they become a non-inlined cord. However, typically the
+  // location represents reasonably well where the cord is 'created'.
+  absl::Span<void* const> GetStack() const;
+
+  // Returns the stack trace for a sampled cord's 'parent stack trace'. This
+  // value may be set if the cord is sampled (promoted) after being created
+  // from, or being assigned the value of an existing (sampled) cord.
+  absl::Span<void* const> GetParentStack() const;
+
+  // Retrieves the CordzStatistics associated with this Cord. The statistics
+  // are only updated when a Cord goes through a mutation, such as an Append
+  // or RemovePrefix.
+  CordzStatistics GetCordzStatistics() const;
+
+ private:
+  using SpinLock = absl::base_internal::SpinLock;
+  using SpinLockHolder = ::absl::base_internal::SpinLockHolder;
+
+  // Global cordz info list. CordzInfo stores a pointer to the global list
+  // instance to harden against ODR violations.
+  struct List {
+    constexpr explicit List(absl::ConstInitType)
+        : mutex(absl::kConstInit,
+                absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL) {}
+
+    SpinLock mutex;
+    std::atomic<CordzInfo*> head ABSL_GUARDED_BY(mutex){nullptr};
+  };
+
+  static constexpr int kMaxStackDepth = 64;
+
+  explicit CordzInfo(CordRep* rep, const CordzInfo* src,
+                     MethodIdentifier method);
+  ~CordzInfo() override;
+
+  // Sets `rep_` without holding a lock.
+  void UnsafeSetCordRep(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+  void Track();
+
+  // Returns the parent method from `src`, which is either `parent_method_` or
+  // `method_` depending on `parent_method_` being kUnknown.
+  // Returns kUnknown if `src` is null.
+  static MethodIdentifier GetParentMethod(const CordzInfo* src);
+
+  // Fills the provided stack from `src`, copying either `parent_stack_` or
+  // `stack_` depending on `parent_stack_` being empty, returning the size of
+  // the parent stack.
+  // Returns 0 if `src` is null.
+  static int FillParentStack(const CordzInfo* src, void** stack);
+
+  void ODRCheck() const {
+#ifndef NDEBUG
+    ABSL_RAW_CHECK(list_ == &global_list_, "ODR violation in Cord");
+#endif
+  }
+
+  // Non-inlined implementation of `MaybeTrackCord`, which is executed if
+  // either `src` is sampled or `cord` is sampled, and either untracks or
+  // tracks `cord` as documented per `MaybeTrackCord`.
+  static void MaybeTrackCordImpl(InlineData& cord, const InlineData& src,
+                                 MethodIdentifier method);
+
+  ABSL_CONST_INIT static List global_list_;
+  List* const list_ = &global_list_;
+
+  // ci_prev_ and ci_next_ require the global list mutex to be held.
+  // Unfortunately we can't use thread annotations such that the thread safety
+  // analysis understands that list_ and global_list_ are one and the same.
+  std::atomic<CordzInfo*> ci_prev_{nullptr};
+  std::atomic<CordzInfo*> ci_next_{nullptr};
+
+  mutable absl::Mutex mutex_;
+  CordRep* rep_ ABSL_GUARDED_BY(mutex_);
+
+  void* stack_[kMaxStackDepth];
+  void* parent_stack_[kMaxStackDepth];
+  const int stack_depth_;
+  const int parent_stack_depth_;
+  const MethodIdentifier method_;
+  const MethodIdentifier parent_method_;
+  CordzUpdateTracker update_tracker_;
+  const absl::Time create_time_;
+};
+
+inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
+    InlineData& cord, MethodIdentifier method) {
+  if (ABSL_PREDICT_FALSE(cordz_should_profile())) {
+    TrackCord(cord, method);
+  }
+}
+
+inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
+    InlineData& cord, const InlineData& src, MethodIdentifier method) {
+  if (ABSL_PREDICT_FALSE(InlineData::is_either_profiled(cord, src))) {
+    MaybeTrackCordImpl(cord, src, method);
+  }
+}
+
+inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeUntrackCord(
+    CordzInfo* info) {
+  if (ABSL_PREDICT_FALSE(info)) {
+    info->Untrack();
+  }
+}
+
+inline void CordzInfo::AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_) {
+#ifndef NDEBUG
+  mutex_.AssertHeld();
+#endif
+}
+
+inline void CordzInfo::SetCordRep(CordRep* rep) {
+  AssertHeld();
+  rep_ = rep;
+}
+
+inline void CordzInfo::UnsafeSetCordRep(CordRep* rep) { rep_ = rep; }
+
+inline CordRep* CordzInfo::RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_) {
+  MutexLock lock(&mutex_);
+  return rep_ ? CordRep::Ref(rep_) : nullptr;
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CORDZ_INFO_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_sample_token.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_sample_token.h
new file mode 100644
index 0000000..28a1d70
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_sample_token.h
@@ -0,0 +1,97 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#include "absl/base/config.h"
+#include "absl/strings/internal/cordz_handle.h"
+#include "absl/strings/internal/cordz_info.h"
+
+#ifndef ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
+#define ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// The existence of a CordzSampleToken guarantees that a reader can traverse the
+// global_cordz_infos_head linked-list without needing to hold a mutex. When a
+// CordzSampleToken exists, all CordzInfo objects that would be destroyed are
+// instead appended to a deletion queue. When the CordzSampleToken is destroyed,
+// it will also clean up any of these CordzInfo objects.
+//
+// E.g., ST are CordzSampleToken objects and CH are CordzHandle objects.
+//   ST1 <- CH1 <- CH2 <- ST2 <- CH3 <- global_delete_queue_tail
+//
+// This list tracks that CH1 and CH2 were created after ST1, so the thread
+// holding ST1 might have a referece to CH1, CH2, ST2, and CH3. However, ST2 was
+// created later, so the thread holding the ST2 token cannot have a reference to
+// ST1, CH1, or CH2. If ST1 is cleaned up first, that thread will delete ST1,
+// CH1, and CH2. If instead ST2 is cleaned up first, that thread will only
+// delete ST2.
+//
+// If ST1 is cleaned up first, the new list will be:
+//   ST2 <- CH3 <- global_delete_queue_tail
+//
+// If ST2 is cleaned up first, the new list will be:
+//   ST1 <- CH1 <- CH2 <- CH3 <- global_delete_queue_tail
+//
+// All new CordzHandle objects are appended to the list, so if a new thread
+// comes along before either ST1 or ST2 are cleaned up, the new list will be:
+//   ST1 <- CH1 <- CH2 <- ST2 <- CH3 <- ST3 <- global_delete_queue_tail
+//
+// A thread must hold the global_delete_queue_mu mutex whenever it's altering
+// this list.
+//
+// It is safe for thread that holds a CordzSampleToken to read
+// global_cordz_infos at any time since the objects it is able to retrieve will
+// not be deleted while the CordzSampleToken exists.
+class CordzSampleToken : public CordzSnapshot {
+ public:
+  class Iterator {
+   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = const CordzInfo&;
+    using difference_type = ptrdiff_t;
+    using pointer = const CordzInfo*;
+    using reference = value_type;
+
+    Iterator() = default;
+
+    Iterator& operator++();
+    Iterator operator++(int);
+    friend bool operator==(const Iterator& lhs, const Iterator& rhs);
+    friend bool operator!=(const Iterator& lhs, const Iterator& rhs);
+    reference operator*() const;
+    pointer operator->() const;
+
+   private:
+    friend class CordzSampleToken;
+    explicit Iterator(const CordzSampleToken* token);
+
+    const CordzSampleToken* token_ = nullptr;
+    pointer current_ = nullptr;
+  };
+
+  CordzSampleToken() = default;
+  CordzSampleToken(const CordzSampleToken&) = delete;
+  CordzSampleToken& operator=(const CordzSampleToken&) = delete;
+
+  Iterator begin() { return Iterator(this); }
+  Iterator end() { return Iterator(); }
+};
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_statistics.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_statistics.h
new file mode 100644
index 0000000..5707190
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_statistics.h
@@ -0,0 +1,88 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
+#define ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
+
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/strings/internal/cordz_update_tracker.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordzStatistics captures some meta information about a Cord's shape.
+struct CordzStatistics {
+  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
+
+  // Node counts information
+  struct NodeCounts {
+    size_t flat = 0;       // #flats
+    size_t flat_64 = 0;    // #flats up to 64 bytes
+    size_t flat_128 = 0;   // #flats up to 128 bytes
+    size_t flat_256 = 0;   // #flats up to 256 bytes
+    size_t flat_512 = 0;   // #flats up to 512 bytes
+    size_t flat_1k = 0;    // #flats up to 1K bytes
+    size_t external = 0;   // #external reps
+    size_t substring = 0;  // #substring reps
+    size_t concat = 0;     // #concat reps
+    size_t ring = 0;       // #ring buffer reps
+    size_t btree = 0;      // #btree reps
+    size_t crc = 0;        // #crc reps
+  };
+
+  // The size of the cord in bytes. This matches the result of Cord::size().
+  int64_t size = 0;
+
+  // The estimated memory used by the sampled cord. This value matches the
+  // value as reported by Cord::EstimatedMemoryUsage().
+  // A value of 0 implies the property has not been recorded.
+  int64_t estimated_memory_usage = 0;
+
+  // The effective memory used by the sampled cord, inversely weighted by the
+  // effective indegree of each allocated node. This is a representation of the
+  // fair share of memory usage that should be attributed to the sampled cord.
+  // This value is more useful for cases where one or more nodes are referenced
+  // by multiple Cord instances, and for cases where a Cord includes the same
+  // node multiple times (either directly or indirectly).
+  // A value of 0 implies the property has not been recorded.
+  int64_t estimated_fair_share_memory_usage = 0;
+
+  // The total number of nodes referenced by this cord.
+  // For ring buffer Cords, this includes the 'ring buffer' node.
+  // For btree Cords, this includes all 'CordRepBtree' tree nodes as well as all
+  // the substring, flat and external nodes referenced by the tree.
+  // A value of 0 implies the property has not been recorded.
+  int64_t node_count = 0;
+
+  // Detailed node counts per type
+  NodeCounts node_counts;
+
+  // The cord method responsible for sampling the cord.
+  MethodIdentifier method = MethodIdentifier::kUnknown;
+
+  // The cord method responsible for sampling the parent cord if applicable.
+  MethodIdentifier parent_method = MethodIdentifier::kUnknown;
+
+  // Update tracker tracking invocation count per cord method.
+  CordzUpdateTracker update_tracker;
+};
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_scope.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_scope.h
new file mode 100644
index 0000000..57ba75d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_scope.h
@@ -0,0 +1,71 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
+#define ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
+
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cordz_info.h"
+#include "absl/strings/internal/cordz_update_tracker.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordzUpdateScope scopes an update to the provided CordzInfo.
+// The class invokes `info->Lock(method)` and `info->Unlock()` to guard
+// cordrep updates. This class does nothing if `info` is null.
+// See also the 'Lock`, `Unlock` and `SetCordRep` methods in `CordzInfo`.
+class ABSL_SCOPED_LOCKABLE CordzUpdateScope {
+ public:
+  CordzUpdateScope(CordzInfo* info, CordzUpdateTracker::MethodIdentifier method)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(info)
+      : info_(info) {
+    if (ABSL_PREDICT_FALSE(info_)) {
+      info->Lock(method);
+    }
+  }
+
+  // CordzUpdateScope can not be copied or assigned to.
+  CordzUpdateScope(CordzUpdateScope&& rhs) = delete;
+  CordzUpdateScope(const CordzUpdateScope&) = delete;
+  CordzUpdateScope& operator=(CordzUpdateScope&& rhs) = delete;
+  CordzUpdateScope& operator=(const CordzUpdateScope&) = delete;
+
+  ~CordzUpdateScope() ABSL_UNLOCK_FUNCTION() {
+    if (ABSL_PREDICT_FALSE(info_)) {
+      info_->Unlock();
+    }
+  }
+
+  void SetCordRep(CordRep* rep) const {
+    if (ABSL_PREDICT_FALSE(info_)) {
+      info_->SetCordRep(rep);
+    }
+  }
+
+  CordzInfo* info() const { return info_; }
+
+ private:
+  CordzInfo* info_;
+};
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_tracker.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_tracker.h
new file mode 100644
index 0000000..c517066
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_tracker.h
@@ -0,0 +1,123 @@
+// Copyright 2021 The Abseil Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
+#define ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
+
+#include <atomic>
+#include <cstdint>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordzUpdateTracker tracks counters for Cord update methods.
+//
+// The purpose of CordzUpdateTracker is to track the number of calls to methods
+// updating Cord data for sampled cords. The class internally uses 'lossy'
+// atomic operations: Cord is thread-compatible, so there is no need to
+// synchronize updates. However, Cordz collection threads may call 'Value()' at
+// any point, so the class needs to provide thread safe access.
+//
+// This class is thread-safe. But as per above comments, all non-const methods
+// should be used single-threaded only: updates are thread-safe but lossy.
+class CordzUpdateTracker {
+ public:
+  // Tracked update methods.
+  enum MethodIdentifier {
+    kUnknown,
+    kAppendCord,
+    kAppendCordBuffer,
+    kAppendExternalMemory,
+    kAppendString,
+    kAssignCord,
+    kAssignString,
+    kClear,
+    kConstructorCord,
+    kConstructorString,
+    kCordReader,
+    kFlatten,
+    kGetAppendBuffer,
+    kGetAppendRegion,
+    kMakeCordFromExternal,
+    kMoveAppendCord,
+    kMoveAssignCord,
+    kMovePrependCord,
+    kPrependCord,
+    kPrependCordBuffer,
+    kPrependString,
+    kRemovePrefix,
+    kRemoveSuffix,
+    kSetExpectedChecksum,
+    kSubCord,
+
+    // kNumMethods defines the number of entries: must be the last entry.
+    kNumMethods,
+  };
+
+  // Constructs a new instance. All counters are zero-initialized.
+  constexpr CordzUpdateTracker() noexcept : values_{} {}
+
+  // Copy constructs a new instance.
+  CordzUpdateTracker(const CordzUpdateTracker& rhs) noexcept { *this = rhs; }
+
+  // Assigns the provided value to this instance.
+  CordzUpdateTracker& operator=(const CordzUpdateTracker& rhs) noexcept {
+    for (int i = 0; i < kNumMethods; ++i) {
+      values_[i].store(rhs.values_[i].load(std::memory_order_relaxed),
+                       std::memory_order_relaxed);
+    }
+    return *this;
+  }
+
+  // Returns the value for the specified method.
+  int64_t Value(MethodIdentifier method) const {
+    return values_[method].load(std::memory_order_relaxed);
+  }
+
+  // Increases the value for the specified method by `n`
+  void LossyAdd(MethodIdentifier method, int64_t n = 1) {
+    auto& value = values_[method];
+    value.store(value.load(std::memory_order_relaxed) + n,
+                std::memory_order_relaxed);
+  }
+
+  // Adds all the values from `src` to this instance
+  void LossyAdd(const CordzUpdateTracker& src) {
+    for (int i = 0; i < kNumMethods; ++i) {
+      MethodIdentifier method = static_cast<MethodIdentifier>(i);
+      if (int64_t value = src.Value(method)) {
+        LossyAdd(method, value);
+      }
+    }
+  }
+
+ private:
+  // Until C++20 std::atomic is not constexpr default-constructible, so we need
+  // a wrapper for this class to be constexpr constructible.
+  class Counter : public std::atomic<int64_t> {
+   public:
+    constexpr Counter() noexcept : std::atomic<int64_t>(0) {}
+  };
+
+  Counter values_[kNumMethods];
+};
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/escaping.h b/CAPI/cpp/grpc/include/absl/strings/internal/escaping.h
new file mode 100644
index 0000000..6a9ce60
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/escaping.h
@@ -0,0 +1,58 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_ESCAPING_H_
+#define ABSL_STRINGS_INTERNAL_ESCAPING_H_
+
+#include <cassert>
+
+#include "absl/strings/internal/resize_uninitialized.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+ABSL_CONST_INIT extern const char kBase64Chars[];
+
+// Calculates how long a string will be when it is base64 encoded given its
+// length and whether or not the result should be padded.
+size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding);
+
+// Base64-encodes `src` using the alphabet provided in `base64` and writes the
+// result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars
+// until its length is a multiple of 3. Returns the length of `dest`.
+size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
+                            size_t szdest, const char* base64, bool do_padding);
+
+// Base64-encodes `src` using the alphabet provided in `base64` and writes the
+// result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars
+// until its length is a multiple of 3.
+template <typename String>
+void Base64EscapeInternal(const unsigned char* src, size_t szsrc, String* dest,
+                          bool do_padding, const char* base64_chars) {
+  const size_t calc_escaped_size =
+      CalculateBase64EscapedLenInternal(szsrc, do_padding);
+  STLStringResizeUninitialized(dest, calc_escaped_size);
+
+  const size_t escaped_len = Base64EscapeInternal(
+      src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding);
+  assert(calc_escaped_size == escaped_len);
+  dest->erase(escaped_len);
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_ESCAPING_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/escaping_test_common.h b/CAPI/cpp/grpc/include/absl/strings/internal/escaping_test_common.h
new file mode 100644
index 0000000..7b18017
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/escaping_test_common.h
@@ -0,0 +1,133 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This test contains common things needed by both escaping_test.cc and
+// escaping_benchmark.cc.
+
+#ifndef ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
+#define ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
+
+#include <array>
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+struct base64_testcase {
+  absl::string_view plaintext;
+  absl::string_view cyphertext;
+};
+
+inline const std::array<base64_testcase, 5>& base64_strings() {
+  static const std::array<base64_testcase, 5> testcase{{
+      // Some google quotes
+      // Cyphertext created with "uuencode (GNU sharutils) 4.6.3"
+      // (Note that we're testing the websafe encoding, though, so if
+      // you add messages, be sure to run "tr -- '+/' '-_'" on the output)
+      { "I was always good at math and science, and I never realized "
+        "that was unusual or somehow undesirable. So one of the things "
+        "I care a lot about is helping to remove that stigma, "
+        "to show girls that you can be feminine, you can like the things "
+        "that girls like, but you can also be really good at technology. "
+        "You can be really good at building things."
+        " - Marissa Meyer, Newsweek, 2010-12-22" "\n",
+
+        "SSB3YXMgYWx3YXlzIGdvb2QgYXQgbWF0aCBhbmQgc2NpZW5jZSwgYW5kIEkg"
+        "bmV2ZXIgcmVhbGl6ZWQgdGhhdCB3YXMgdW51c3VhbCBvciBzb21laG93IHVu"
+        "ZGVzaXJhYmxlLiBTbyBvbmUgb2YgdGhlIHRoaW5ncyBJIGNhcmUgYSBsb3Qg"
+        "YWJvdXQgaXMgaGVscGluZyB0byByZW1vdmUgdGhhdCBzdGlnbWEsIHRvIHNo"
+        "b3cgZ2lybHMgdGhhdCB5b3UgY2FuIGJlIGZlbWluaW5lLCB5b3UgY2FuIGxp"
+        "a2UgdGhlIHRoaW5ncyB0aGF0IGdpcmxzIGxpa2UsIGJ1dCB5b3UgY2FuIGFs"
+        "c28gYmUgcmVhbGx5IGdvb2QgYXQgdGVjaG5vbG9neS4gWW91IGNhbiBiZSBy"
+        "ZWFsbHkgZ29vZCBhdCBidWlsZGluZyB0aGluZ3MuIC0gTWFyaXNzYSBNZXll"
+        "ciwgTmV3c3dlZWssIDIwMTAtMTItMjIK" },
+
+      { "Typical first year for a new cluster: "
+        "~0.5 overheating "
+        "~1 PDU failure "
+        "~1 rack-move "
+        "~1 network rewiring "
+        "~20 rack failures "
+        "~5 racks go wonky "
+        "~8 network maintenances "
+        "~12 router reloads "
+        "~3 router failures "
+        "~dozens of minor 30-second blips for dns "
+        "~1000 individual machine failures "
+        "~thousands of hard drive failures "
+        "slow disks, bad memory, misconfigured machines, flaky machines, etc."
+        " - Jeff Dean, The Joys of Real Hardware" "\n",
+
+        "VHlwaWNhbCBmaXJzdCB5ZWFyIGZvciBhIG5ldyBjbHVzdGVyOiB-MC41IG92"
+        "ZXJoZWF0aW5nIH4xIFBEVSBmYWlsdXJlIH4xIHJhY2stbW92ZSB-MSBuZXR3"
+        "b3JrIHJld2lyaW5nIH4yMCByYWNrIGZhaWx1cmVzIH41IHJhY2tzIGdvIHdv"
+        "bmt5IH44IG5ldHdvcmsgbWFpbnRlbmFuY2VzIH4xMiByb3V0ZXIgcmVsb2Fk"
+        "cyB-MyByb3V0ZXIgZmFpbHVyZXMgfmRvemVucyBvZiBtaW5vciAzMC1zZWNv"
+        "bmQgYmxpcHMgZm9yIGRucyB-MTAwMCBpbmRpdmlkdWFsIG1hY2hpbmUgZmFp"
+        "bHVyZXMgfnRob3VzYW5kcyBvZiBoYXJkIGRyaXZlIGZhaWx1cmVzIHNsb3cg"
+        "ZGlza3MsIGJhZCBtZW1vcnksIG1pc2NvbmZpZ3VyZWQgbWFjaGluZXMsIGZs"
+        "YWt5IG1hY2hpbmVzLCBldGMuIC0gSmVmZiBEZWFuLCBUaGUgSm95cyBvZiBS"
+        "ZWFsIEhhcmR3YXJlCg" },
+
+      { "I'm the head of the webspam team at Google.  "
+        "That means that if you type your name into Google and get porn back, "
+        "it's my fault. Unless you're a porn star, in which case porn is a "
+        "completely reasonable response."
+        " - Matt Cutts, Google Plus" "\n",
+
+        "SSdtIHRoZSBoZWFkIG9mIHRoZSB3ZWJzcGFtIHRlYW0gYXQgR29vZ2xlLiAg"
+        "VGhhdCBtZWFucyB0aGF0IGlmIHlvdSB0eXBlIHlvdXIgbmFtZSBpbnRvIEdv"
+        "b2dsZSBhbmQgZ2V0IHBvcm4gYmFjaywgaXQncyBteSBmYXVsdC4gVW5sZXNz"
+        "IHlvdSdyZSBhIHBvcm4gc3RhciwgaW4gd2hpY2ggY2FzZSBwb3JuIGlzIGEg"
+        "Y29tcGxldGVseSByZWFzb25hYmxlIHJlc3BvbnNlLiAtIE1hdHQgQ3V0dHMs"
+        "IEdvb2dsZSBQbHVzCg" },
+
+      { "It will still be a long time before machines approach human "
+        "intelligence. "
+        "But luckily, machines don't actually have to be intelligent; "
+        "they just have to fake it. Access to a wealth of information, "
+        "combined with a rudimentary decision-making capacity, "
+        "can often be almost as useful. Of course, the results are better yet "
+        "when coupled with intelligence. A reference librarian with access to "
+        "a good search engine is a formidable tool."
+        " - Craig Silverstein, Siemens Pictures of the Future, Spring 2004"
+        "\n",
+
+        "SXQgd2lsbCBzdGlsbCBiZSBhIGxvbmcgdGltZSBiZWZvcmUgbWFjaGluZXMg"
+        "YXBwcm9hY2ggaHVtYW4gaW50ZWxsaWdlbmNlLiBCdXQgbHVja2lseSwgbWFj"
+        "aGluZXMgZG9uJ3QgYWN0dWFsbHkgaGF2ZSB0byBiZSBpbnRlbGxpZ2VudDsg"
+        "dGhleSBqdXN0IGhhdmUgdG8gZmFrZSBpdC4gQWNjZXNzIHRvIGEgd2VhbHRo"
+        "IG9mIGluZm9ybWF0aW9uLCBjb21iaW5lZCB3aXRoIGEgcnVkaW1lbnRhcnkg"
+        "ZGVjaXNpb24tbWFraW5nIGNhcGFjaXR5LCBjYW4gb2Z0ZW4gYmUgYWxtb3N0"
+        "IGFzIHVzZWZ1bC4gT2YgY291cnNlLCB0aGUgcmVzdWx0cyBhcmUgYmV0dGVy"
+        "IHlldCB3aGVuIGNvdXBsZWQgd2l0aCBpbnRlbGxpZ2VuY2UuIEEgcmVmZXJl"
+        "bmNlIGxpYnJhcmlhbiB3aXRoIGFjY2VzcyB0byBhIGdvb2Qgc2VhcmNoIGVu"
+        "Z2luZSBpcyBhIGZvcm1pZGFibGUgdG9vbC4gLSBDcmFpZyBTaWx2ZXJzdGVp"
+        "biwgU2llbWVucyBQaWN0dXJlcyBvZiB0aGUgRnV0dXJlLCBTcHJpbmcgMjAw"
+        "NAo" },
+
+      // Degenerate edge case
+      { "",
+        "" },
+  }};
+
+  return testcase;
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/memutil.h b/CAPI/cpp/grpc/include/absl/strings/internal/memutil.h
new file mode 100644
index 0000000..9ad0535
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/memutil.h
@@ -0,0 +1,148 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+// These routines provide mem versions of standard C string routines,
+// such as strpbrk.  They function exactly the same as the str versions,
+// so if you wonder what they are, replace the word "mem" by
+// "str" and check out the man page.  I could return void*, as the
+// strutil.h mem*() routines tend to do, but I return char* instead
+// since this is by far the most common way these functions are called.
+//
+// The difference between the mem and str versions is the mem version
+// takes a pointer and a length, rather than a '\0'-terminated string.
+// The memcase* routines defined here assume the locale is "C"
+// (they use absl::ascii_tolower instead of tolower).
+//
+// These routines are based on the BSD library.
+//
+// Here's a list of routines from string.h, and their mem analogues.
+// Functions in lowercase are defined in string.h; those in UPPERCASE
+// are defined here:
+//
+// strlen                  --
+// strcat strncat          MEMCAT
+// strcpy strncpy          memcpy
+// --                      memccpy   (very cool function, btw)
+// --                      memmove
+// --                      memset
+// strcmp strncmp          memcmp
+// strcasecmp strncasecmp  MEMCASECMP
+// strchr                  memchr
+// strcoll                 --
+// strxfrm                 --
+// strdup strndup          MEMDUP
+// strrchr                 MEMRCHR
+// strspn                  MEMSPN
+// strcspn                 MEMCSPN
+// strpbrk                 MEMPBRK
+// strstr                  MEMSTR MEMMEM
+// (g)strcasestr           MEMCASESTR MEMCASEMEM
+// strtok                  --
+// strprefix               MEMPREFIX      (strprefix is from strutil.h)
+// strcaseprefix           MEMCASEPREFIX  (strcaseprefix is from strutil.h)
+// strsuffix               MEMSUFFIX      (strsuffix is from strutil.h)
+// strcasesuffix           MEMCASESUFFIX  (strcasesuffix is from strutil.h)
+// --                      MEMIS
+// --                      MEMCASEIS
+// strcount                MEMCOUNT       (strcount is from strutil.h)
+
+#ifndef ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+#define ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+
+#include <cstddef>
+#include <cstring>
+
+#include "absl/base/port.h"  // disable some warnings on Windows
+#include "absl/strings/ascii.h"  // for absl::ascii_tolower
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+inline char* memcat(char* dest, size_t destlen, const char* src,
+                    size_t srclen) {
+  return reinterpret_cast<char*>(memcpy(dest + destlen, src, srclen));
+}
+
+int memcasecmp(const char* s1, const char* s2, size_t len);
+char* memdup(const char* s, size_t slen);
+char* memrchr(const char* s, int c, size_t slen);
+size_t memspn(const char* s, size_t slen, const char* accept);
+size_t memcspn(const char* s, size_t slen, const char* reject);
+char* mempbrk(const char* s, size_t slen, const char* accept);
+
+// This is for internal use only.  Don't call this directly
+template <bool case_sensitive>
+const char* int_memmatch(const char* haystack, size_t haylen,
+                         const char* needle, size_t neelen) {
+  if (0 == neelen) {
+    return haystack;  // even if haylen is 0
+  }
+  const char* hayend = haystack + haylen;
+  const char* needlestart = needle;
+  const char* needleend = needlestart + neelen;
+
+  for (; haystack < hayend; ++haystack) {
+    char hay = case_sensitive
+                   ? *haystack
+                   : absl::ascii_tolower(static_cast<unsigned char>(*haystack));
+    char nee = case_sensitive
+                   ? *needle
+                   : absl::ascii_tolower(static_cast<unsigned char>(*needle));
+    if (hay == nee) {
+      if (++needle == needleend) {
+        return haystack + 1 - neelen;
+      }
+    } else if (needle != needlestart) {
+      // must back up haystack in case a prefix matched (find "aab" in "aaab")
+      haystack -= needle - needlestart;  // for loop will advance one more
+      needle = needlestart;
+    }
+  }
+  return nullptr;
+}
+
+// These are the guys you can call directly
+inline const char* memstr(const char* phaystack, size_t haylen,
+                          const char* pneedle) {
+  return int_memmatch<true>(phaystack, haylen, pneedle, strlen(pneedle));
+}
+
+inline const char* memcasestr(const char* phaystack, size_t haylen,
+                              const char* pneedle) {
+  return int_memmatch<false>(phaystack, haylen, pneedle, strlen(pneedle));
+}
+
+inline const char* memmem(const char* phaystack, size_t haylen,
+                          const char* pneedle, size_t needlelen) {
+  return int_memmatch<true>(phaystack, haylen, pneedle, needlelen);
+}
+
+inline const char* memcasemem(const char* phaystack, size_t haylen,
+                              const char* pneedle, size_t needlelen) {
+  return int_memmatch<false>(phaystack, haylen, pneedle, needlelen);
+}
+
+// This is significantly faster for case-sensitive matches with very
+// few possible matches.  See unit test for benchmarks.
+const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
+                     size_t neelen);
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_MEMUTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/numbers_test_common.h b/CAPI/cpp/grpc/include/absl/strings/internal/numbers_test_common.h
new file mode 100644
index 0000000..eaa88a8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/numbers_test_common.h
@@ -0,0 +1,184 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This file contains common things needed by numbers_test.cc,
+// numbers_legacy_test.cc and numbers_benchmark.cc.
+
+#ifndef ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
+#define ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
+
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+template <typename IntType>
+inline bool Itoa(IntType value, int base, std::string* destination) {
+  destination->clear();
+  if (base <= 1 || base > 36) {
+    return false;
+  }
+
+  if (value == 0) {
+    destination->push_back('0');
+    return true;
+  }
+
+  bool negative = value < 0;
+  while (value != 0) {
+    const IntType next_value = value / base;
+    // Can't use std::abs here because of problems when IntType is unsigned.
+    int remainder =
+        static_cast<int>(value > next_value * base ? value - next_value * base
+                                                   : next_value * base - value);
+    char c = remainder < 10 ? '0' + remainder : 'A' + remainder - 10;
+    destination->insert(0, 1, c);
+    value = next_value;
+  }
+
+  if (negative) {
+    destination->insert(0, 1, '-');
+  }
+  return true;
+}
+
+struct uint32_test_case {
+  const char* str;
+  bool expect_ok;
+  int base;  // base to pass to the conversion function
+  uint32_t expected;
+};
+
+inline const std::array<uint32_test_case, 27>& strtouint32_test_cases() {
+  static const std::array<uint32_test_case, 27> test_cases{{
+      {"0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
+      {"0x34234324", true, 16, 0x34234324},
+      {"34234324", true, 16, 0x34234324},
+      {"0", true, 16, 0},
+      {" \t\n 0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
+      {" \f\v 46", true, 10, 46},  // must accept weird whitespace
+      {" \t\n 72717222", true, 8, 072717222},
+      {" \t\n 072717222", true, 8, 072717222},
+      {" \t\n 072717228", false, 8, 07271722},
+      {"0", true, 0, 0},
+
+      // Base-10 version.
+      {"34234324", true, 0, 34234324},
+      {"4294967295", true, 0, (std::numeric_limits<uint32_t>::max)()},
+      {"34234324 \n\t", true, 10, 34234324},
+
+      // Unusual base
+      {"0", true, 3, 0},
+      {"2", true, 3, 2},
+      {"11", true, 3, 4},
+
+      // Invalid uints.
+      {"", false, 0, 0},
+      {"  ", false, 0, 0},
+      {"abc", false, 0, 0},  // would be valid hex, but prefix is missing
+      {"34234324a", false, 0, 34234324},
+      {"34234.3", false, 0, 34234},
+      {"-1", false, 0, 0},
+      {"   -123", false, 0, 0},
+      {" \t\n -123", false, 0, 0},
+
+      // Out of bounds.
+      {"4294967296", false, 0, (std::numeric_limits<uint32_t>::max)()},
+      {"0x100000000", false, 0, (std::numeric_limits<uint32_t>::max)()},
+      {nullptr, false, 0, 0},
+  }};
+  return test_cases;
+}
+
+struct uint64_test_case {
+  const char* str;
+  bool expect_ok;
+  int base;
+  uint64_t expected;
+};
+
+inline const std::array<uint64_test_case, 34>& strtouint64_test_cases() {
+  static const std::array<uint64_test_case, 34> test_cases{{
+      {"0x3423432448783446", true, 16, int64_t{0x3423432448783446}},
+      {"3423432448783446", true, 16, int64_t{0x3423432448783446}},
+
+      {"0", true, 16, 0},
+      {"000", true, 0, 0},
+      {"0", true, 0, 0},
+      {" \t\n 0xffffffffffffffff", true, 16,
+       (std::numeric_limits<uint64_t>::max)()},
+
+      {"012345670123456701234", true, 8, int64_t{012345670123456701234}},
+      {"12345670123456701234", true, 8, int64_t{012345670123456701234}},
+
+      {"12845670123456701234", false, 8, 0},
+
+      // Base-10 version.
+      {"34234324487834466", true, 0, int64_t{34234324487834466}},
+
+      {" \t\n 18446744073709551615", true, 0,
+       (std::numeric_limits<uint64_t>::max)()},
+
+      {"34234324487834466 \n\t ", true, 0, int64_t{34234324487834466}},
+
+      {" \f\v 46", true, 10, 46},  // must accept weird whitespace
+
+      // Unusual base
+      {"0", true, 3, 0},
+      {"2", true, 3, 2},
+      {"11", true, 3, 4},
+
+      {"0", true, 0, 0},
+
+      // Invalid uints.
+      {"", false, 0, 0},
+      {"  ", false, 0, 0},
+      {"abc", false, 0, 0},
+      {"34234324487834466a", false, 0, 0},
+      {"34234487834466.3", false, 0, 0},
+      {"-1", false, 0, 0},
+      {"   -123", false, 0, 0},
+      {" \t\n -123", false, 0, 0},
+
+      // Out of bounds.
+      {"18446744073709551616", false, 10, 0},
+      {"18446744073709551616", false, 0, 0},
+      {"0x10000000000000000", false, 16,
+       (std::numeric_limits<uint64_t>::max)()},
+      {"0X10000000000000000", false, 16,
+       (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x.
+      {"0x10000000000000000", false, 0, (std::numeric_limits<uint64_t>::max)()},
+      {"0X10000000000000000", false, 0,
+       (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x.
+
+      {"0x1234", true, 16, 0x1234},
+
+      // Base-10 string version.
+      {"1234", true, 0, 1234},
+      {nullptr, false, 0, 0},
+  }};
+  return test_cases;
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/ostringstream.h b/CAPI/cpp/grpc/include/absl/strings/internal/ostringstream.h
new file mode 100644
index 0000000..d25d604
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/ostringstream.h
@@ -0,0 +1,89 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
+#define ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
+
+#include <cassert>
+#include <ostream>
+#include <streambuf>
+#include <string>
+
+#include "absl/base/port.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// The same as std::ostringstream but appends to a user-specified std::string,
+// and is faster. It is ~70% faster to create, ~50% faster to write to, and
+// completely free to extract the result std::string.
+//
+//   std::string s;
+//   OStringStream strm(&s);
+//   strm << 42 << ' ' << 3.14;  // appends to `s`
+//
+// The stream object doesn't have to be named. Starting from C++11 operator<<
+// works with rvalues of std::ostream.
+//
+//   std::string s;
+//   OStringStream(&s) << 42 << ' ' << 3.14;  // appends to `s`
+//
+// OStringStream is faster to create than std::ostringstream but it's still
+// relatively slow. Avoid creating multiple streams where a single stream will
+// do.
+//
+// Creates unnecessary instances of OStringStream: slow.
+//
+//   std::string s;
+//   OStringStream(&s) << 42;
+//   OStringStream(&s) << ' ';
+//   OStringStream(&s) << 3.14;
+//
+// Creates a single instance of OStringStream and reuses it: fast.
+//
+//   std::string s;
+//   OStringStream strm(&s);
+//   strm << 42;
+//   strm << ' ';
+//   strm << 3.14;
+//
+// Note: flush() has no effect. No reason to call it.
+class OStringStream : private std::basic_streambuf<char>, public std::ostream {
+ public:
+  // The argument can be null, in which case you'll need to call str(p) with a
+  // non-null argument before you can write to the stream.
+  //
+  // The destructor of OStringStream doesn't use the std::string. It's OK to
+  // destroy the std::string before the stream.
+  explicit OStringStream(std::string* s) : std::ostream(this), s_(s) {}
+
+  std::string* str() { return s_; }
+  const std::string* str() const { return s_; }
+  void str(std::string* s) { s_ = s; }
+
+ private:
+  using Buf = std::basic_streambuf<char>;
+
+  Buf::int_type overflow(int c) override;
+  std::streamsize xsputn(const char* s, std::streamsize n) override;
+
+  std::string* s_;
+};
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/pow10_helper.h b/CAPI/cpp/grpc/include/absl/strings/internal/pow10_helper.h
new file mode 100644
index 0000000..c37c2c3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/pow10_helper.h
@@ -0,0 +1,40 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This test helper library contains a table of powers of 10, to guarantee
+// precise values are computed across the full range of doubles. We can't rely
+// on the pow() function, because not all standard libraries ship a version
+// that is precise.
+#ifndef ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
+#define ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
+
+#include <vector>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// Computes the precise value of 10^exp. (I.e. the nearest representable
+// double to the exact value, rounding to nearest-even in the (single) case of
+// being exactly halfway between.)
+double Pow10(int exp);
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/resize_uninitialized.h b/CAPI/cpp/grpc/include/absl/strings/internal/resize_uninitialized.h
new file mode 100644
index 0000000..49859dc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/resize_uninitialized.h
@@ -0,0 +1,119 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
+#define ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
+
+#include <algorithm>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h"  //  for void_t
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// In this type trait, we look for a __resize_default_init member function, and
+// we use it if available, otherwise, we use resize. We provide HasMember to
+// indicate whether __resize_default_init is present.
+template <typename string_type, typename = void>
+struct ResizeUninitializedTraits {
+  using HasMember = std::false_type;
+  static void Resize(string_type* s, size_t new_size) { s->resize(new_size); }
+};
+
+// __resize_default_init is provided by libc++ >= 8.0
+template <typename string_type>
+struct ResizeUninitializedTraits<
+    string_type, absl::void_t<decltype(std::declval<string_type&>()
+                                           .__resize_default_init(237))> > {
+  using HasMember = std::true_type;
+  static void Resize(string_type* s, size_t new_size) {
+    s->__resize_default_init(new_size);
+  }
+};
+
+// Returns true if the std::string implementation supports a resize where
+// the new characters added to the std::string are left untouched.
+//
+// (A better name might be "STLStringSupportsUninitializedResize", alluding to
+// the previous function.)
+template <typename string_type>
+inline constexpr bool STLStringSupportsNontrashingResize(string_type*) {
+  return ResizeUninitializedTraits<string_type>::HasMember::value;
+}
+
+// Like str->resize(new_size), except any new characters added to "*str" as a
+// result of resizing may be left uninitialized, rather than being filled with
+// '0' bytes. Typically used when code is then going to overwrite the backing
+// store of the std::string with known data.
+template <typename string_type, typename = void>
+inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
+  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
+}
+
+// Used to ensure exponential growth so that the amortized complexity of
+// increasing the string size by a small amount is O(1), in contrast to
+// O(str->size()) in the case of precise growth.
+template <typename string_type>
+void STLStringReserveAmortized(string_type* s, size_t new_size) {
+  const size_t cap = s->capacity();
+  if (new_size > cap) {
+    // Make sure to always grow by at least a factor of 2x.
+    s->reserve((std::max)(new_size, 2 * cap));
+  }
+}
+
+// In this type trait, we look for an __append_default_init member function, and
+// we use it if available, otherwise, we use append.
+template <typename string_type, typename = void>
+struct AppendUninitializedTraits {
+  static void Append(string_type* s, size_t n) {
+    s->append(n, typename string_type::value_type());
+  }
+};
+
+template <typename string_type>
+struct AppendUninitializedTraits<
+    string_type, absl::void_t<decltype(std::declval<string_type&>()
+                                           .__append_default_init(237))> > {
+  static void Append(string_type* s, size_t n) {
+    s->__append_default_init(n);
+  }
+};
+
+// Like STLStringResizeUninitialized(str, new_size), except guaranteed to use
+// exponential growth so that the amortized complexity of increasing the string
+// size by a small amount is O(1), in contrast to O(str->size()) in the case of
+// precise growth.
+template <typename string_type>
+void STLStringResizeUninitializedAmortized(string_type* s, size_t new_size) {
+  const size_t size = s->size();
+  if (new_size > size) {
+    AppendUninitializedTraits<string_type>::Append(s, new_size - size);
+  } else {
+    s->erase(new_size);
+  }
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/stl_type_traits.h b/CAPI/cpp/grpc/include/absl/strings/internal/stl_type_traits.h
new file mode 100644
index 0000000..6035ca4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/stl_type_traits.h
@@ -0,0 +1,248 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+// Thie file provides the IsStrictlyBaseOfAndConvertibleToSTLContainer type
+// trait metafunction to assist in working with the _GLIBCXX_DEBUG debug
+// wrappers of STL containers.
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
+// absl/strings/str_split.h.
+//
+// IWYU pragma: private, include "absl/strings/str_split.h"
+
+#ifndef ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+#define ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+
+#include <array>
+#include <bitset>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+template <typename C, template <typename...> class T>
+struct IsSpecializationImpl : std::false_type {};
+template <template <typename...> class T, typename... Args>
+struct IsSpecializationImpl<T<Args...>, T> : std::true_type {};
+template <typename C, template <typename...> class T>
+using IsSpecialization = IsSpecializationImpl<absl::decay_t<C>, T>;
+
+template <typename C>
+struct IsArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>> {};
+template <typename C>
+using IsArray = IsArrayImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>> {};
+template <typename C>
+using IsBitset = IsBitsetImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsSTLContainer
+    : absl::disjunction<
+          IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>,
+          IsSpecialization<C, std::forward_list>,
+          IsSpecialization<C, std::list>, IsSpecialization<C, std::map>,
+          IsSpecialization<C, std::multimap>, IsSpecialization<C, std::set>,
+          IsSpecialization<C, std::multiset>,
+          IsSpecialization<C, std::unordered_map>,
+          IsSpecialization<C, std::unordered_multimap>,
+          IsSpecialization<C, std::unordered_set>,
+          IsSpecialization<C, std::unordered_multiset>,
+          IsSpecialization<C, std::vector>> {};
+
+template <typename C, template <typename...> class T, typename = void>
+struct IsBaseOfSpecializationImpl : std::false_type {};
+// IsBaseOfSpecializationImpl needs multiple partial specializations to SFINAE
+// on the existence of container dependent types and plug them into the STL
+// template.
+template <typename C, template <typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
+    : std::is_base_of<C,
+                      T<typename C::value_type, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::key_compare,
+                 typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::key_compare,
+                           typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::mapped_type,
+                 typename C::key_compare, typename C::allocator_type>>
+    : std::is_base_of<C,
+                      T<typename C::key_type, typename C::mapped_type,
+                        typename C::key_compare, typename C::allocator_type>> {
+};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::hasher,
+                 typename C::key_equal, typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::hasher,
+                           typename C::key_equal, typename C::allocator_type>> {
+};
+template <typename C,
+          template <typename, typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::mapped_type,
+                 typename C::hasher, typename C::key_equal,
+                 typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type,
+                           typename C::hasher, typename C::key_equal,
+                           typename C::allocator_type>> {};
+template <typename C, template <typename...> class T>
+using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<absl::decay_t<C>, T>;
+
+template <typename C>
+struct IsBaseOfArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>> {
+};
+template <typename C>
+using IsBaseOfArray = IsBaseOfArrayImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsBaseOfBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>> {};
+template <typename C>
+using IsBaseOfBitset = IsBaseOfBitsetImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsBaseOfSTLContainer
+    : absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>,
+                        IsBaseOfSpecialization<C, std::deque>,
+                        IsBaseOfSpecialization<C, std::forward_list>,
+                        IsBaseOfSpecialization<C, std::list>,
+                        IsBaseOfSpecialization<C, std::map>,
+                        IsBaseOfSpecialization<C, std::multimap>,
+                        IsBaseOfSpecialization<C, std::set>,
+                        IsBaseOfSpecialization<C, std::multiset>,
+                        IsBaseOfSpecialization<C, std::unordered_map>,
+                        IsBaseOfSpecialization<C, std::unordered_multimap>,
+                        IsBaseOfSpecialization<C, std::unordered_set>,
+                        IsBaseOfSpecialization<C, std::unordered_multiset>,
+                        IsBaseOfSpecialization<C, std::vector>> {};
+
+template <typename C, template <typename...> class T, typename = void>
+struct IsConvertibleToSpecializationImpl : std::false_type {};
+// IsConvertibleToSpecializationImpl needs multiple partial specializations to
+// SFINAE on the existence of container dependent types and plug them into the
+// STL template.
+template <typename C, template <typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
+    : std::is_convertible<
+          C, T<typename C::value_type, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::key_compare,
+                 typename C::allocator_type>>
+    : std::is_convertible<C, T<typename C::key_type, typename C::key_compare,
+                               typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::mapped_type,
+                 typename C::key_compare, typename C::allocator_type>>
+    : std::is_convertible<
+          C, T<typename C::key_type, typename C::mapped_type,
+               typename C::key_compare, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::hasher,
+                 typename C::key_equal, typename C::allocator_type>>
+    : std::is_convertible<
+          C, T<typename C::key_type, typename C::hasher, typename C::key_equal,
+               typename C::allocator_type>> {};
+template <typename C,
+          template <typename, typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
+    absl::void_t<typename C::key_type, typename C::mapped_type,
+                 typename C::hasher, typename C::key_equal,
+                 typename C::allocator_type>>
+    : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type,
+                               typename C::hasher, typename C::key_equal,
+                               typename C::allocator_type>> {};
+template <typename C, template <typename...> class T>
+using IsConvertibleToSpecialization =
+    IsConvertibleToSpecializationImpl<absl::decay_t<C>, T>;
+
+template <typename C>
+struct IsConvertibleToArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsConvertibleToArrayImpl<A<T, N>>
+    : std::is_convertible<A<T, N>, std::array<T, N>> {};
+template <typename C>
+using IsConvertibleToArray = IsConvertibleToArrayImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsConvertibleToBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsConvertibleToBitsetImpl<B<N>>
+    : std::is_convertible<B<N>, std::bitset<N>> {};
+template <typename C>
+using IsConvertibleToBitset = IsConvertibleToBitsetImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsConvertibleToSTLContainer
+    : absl::disjunction<
+          IsConvertibleToArray<C>, IsConvertibleToBitset<C>,
+          IsConvertibleToSpecialization<C, std::deque>,
+          IsConvertibleToSpecialization<C, std::forward_list>,
+          IsConvertibleToSpecialization<C, std::list>,
+          IsConvertibleToSpecialization<C, std::map>,
+          IsConvertibleToSpecialization<C, std::multimap>,
+          IsConvertibleToSpecialization<C, std::set>,
+          IsConvertibleToSpecialization<C, std::multiset>,
+          IsConvertibleToSpecialization<C, std::unordered_map>,
+          IsConvertibleToSpecialization<C, std::unordered_multimap>,
+          IsConvertibleToSpecialization<C, std::unordered_set>,
+          IsConvertibleToSpecialization<C, std::unordered_multiset>,
+          IsConvertibleToSpecialization<C, std::vector>> {};
+
+template <typename C>
+struct IsStrictlyBaseOfAndConvertibleToSTLContainer
+    : absl::conjunction<absl::negation<IsSTLContainer<C>>,
+                        IsBaseOfSTLContainer<C>,
+                        IsConvertibleToSTLContainer<C>> {};
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/arg.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/arg.h
new file mode 100644
index 0000000..b9dda90
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/arg.h
@@ -0,0 +1,526 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
+
+#include <string.h>
+#include <wchar.h>
+
+#include <cstdio>
+#include <iomanip>
+#include <limits>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h"
+#include "absl/numeric/int128.h"
+#include "absl/strings/internal/str_format/extension.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class Cord;
+class FormatCountCapture;
+class FormatSink;
+
+template <absl::FormatConversionCharSet C>
+struct FormatConvertResult;
+class FormatConversionSpec;
+
+namespace str_format_internal {
+
+template <typename T, typename = void>
+struct HasUserDefinedConvert : std::false_type {};
+
+template <typename T>
+struct HasUserDefinedConvert<T, void_t<decltype(AbslFormatConvert(
+                                    std::declval<const T&>(),
+                                    std::declval<const FormatConversionSpec&>(),
+                                    std::declval<FormatSink*>()))>>
+    : std::true_type {};
+
+void AbslFormatConvert();  // Stops the lexical name lookup
+template <typename T>
+auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv,
+                       FormatSinkImpl* sink)
+    -> decltype(AbslFormatConvert(v,
+                                  std::declval<const FormatConversionSpec&>(),
+                                  std::declval<FormatSink*>())) {
+  using FormatConversionSpecT =
+      absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatConversionSpec>;
+  using FormatSinkT =
+      absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
+  auto fcs = conv.Wrap<FormatConversionSpecT>();
+  auto fs = sink->Wrap<FormatSinkT>();
+  return AbslFormatConvert(v, fcs, &fs);
+}
+
+template <typename T>
+class StreamedWrapper;
+
+// If 'v' can be converted (in the printf sense) according to 'conv',
+// then convert it, appending to `sink` and return `true`.
+// Otherwise fail and return `false`.
+
+// AbslFormatConvert(v, conv, sink) is intended to be found by ADL on 'v'
+// as an extension mechanism. These FormatConvertImpl functions are the default
+// implementations.
+// The ADL search is augmented via the 'Sink*' parameter, which also
+// serves as a disambiguator to reject possible unintended 'AbslFormatConvert'
+// functions in the namespaces associated with 'v'.
+
+// Raw pointers.
+struct VoidPtr {
+  VoidPtr() = default;
+  template <typename T,
+            decltype(reinterpret_cast<uintptr_t>(std::declval<T*>())) = 0>
+  VoidPtr(T* ptr)  // NOLINT
+      : value(ptr ? reinterpret_cast<uintptr_t>(ptr) : 0) {}
+  uintptr_t value;
+};
+
+template <FormatConversionCharSet C>
+struct ArgConvertResult {
+  bool value;
+};
+
+template <FormatConversionCharSet C>
+constexpr FormatConversionCharSet ExtractCharSet(FormatConvertResult<C>) {
+  return C;
+}
+
+template <FormatConversionCharSet C>
+constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
+  return C;
+}
+
+using StringConvertResult =
+    ArgConvertResult<FormatConversionCharSetInternal::s>;
+ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
+    VoidPtr v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+
+// Strings.
+StringConvertResult FormatConvertImpl(const std::string& v,
+                                      FormatConversionSpecImpl conv,
+                                      FormatSinkImpl* sink);
+StringConvertResult FormatConvertImpl(string_view v,
+                                      FormatConversionSpecImpl conv,
+                                      FormatSinkImpl* sink);
+#if defined(ABSL_HAVE_STD_STRING_VIEW) && !defined(ABSL_USES_STD_STRING_VIEW)
+inline StringConvertResult FormatConvertImpl(std::string_view v,
+                                             FormatConversionSpecImpl conv,
+                                             FormatSinkImpl* sink) {
+  return FormatConvertImpl(absl::string_view(v.data(), v.size()), conv, sink);
+}
+#endif  // ABSL_HAVE_STD_STRING_VIEW && !ABSL_USES_STD_STRING_VIEW
+
+ArgConvertResult<FormatConversionCharSetUnion(
+    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>
+FormatConvertImpl(const char* v, const FormatConversionSpecImpl conv,
+                  FormatSinkImpl* sink);
+
+template <class AbslCord, typename std::enable_if<std::is_same<
+                              AbslCord, absl::Cord>::value>::type* = nullptr>
+StringConvertResult FormatConvertImpl(const AbslCord& value,
+                                      FormatConversionSpecImpl conv,
+                                      FormatSinkImpl* sink) {
+  bool is_left = conv.has_left_flag();
+  size_t space_remaining = 0;
+
+  int width = conv.width();
+  if (width >= 0) space_remaining = static_cast<size_t>(width);
+
+  size_t to_write = value.size();
+
+  int precision = conv.precision();
+  if (precision >= 0)
+    to_write = (std::min)(to_write, static_cast<size_t>(precision));
+
+  space_remaining = Excess(to_write, space_remaining);
+
+  if (space_remaining > 0 && !is_left) sink->Append(space_remaining, ' ');
+
+  for (string_view piece : value.Chunks()) {
+    if (piece.size() > to_write) {
+      piece.remove_suffix(piece.size() - to_write);
+      to_write = 0;
+    } else {
+      to_write -= piece.size();
+    }
+    sink->Append(piece);
+    if (to_write == 0) {
+      break;
+    }
+  }
+
+  if (space_remaining > 0 && is_left) sink->Append(space_remaining, ' ');
+  return {true};
+}
+
+using IntegralConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
+    FormatConversionCharSetInternal::c,
+    FormatConversionCharSetInternal::kNumeric,
+    FormatConversionCharSetInternal::kStar)>;
+using FloatingConvertResult =
+    ArgConvertResult<FormatConversionCharSetInternal::kFloating>;
+
+// Floats.
+FloatingConvertResult FormatConvertImpl(float v, FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+FloatingConvertResult FormatConvertImpl(double v, FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+FloatingConvertResult FormatConvertImpl(long double v,
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+
+// Chars.
+IntegralConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(signed char v,
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned char v,
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+
+// Ints.
+IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(int v, FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned v,
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(long v,  // NOLINT
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(int128 v, FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(uint128 v,
+                                        FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink);
+template <typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0>
+IntegralConvertResult FormatConvertImpl(T v, FormatConversionSpecImpl conv,
+                                        FormatSinkImpl* sink) {
+  return FormatConvertImpl(static_cast<int>(v), conv, sink);
+}
+
+// We provide this function to help the checker, but it is never defined.
+// FormatArgImpl will use the underlying Convert functions instead.
+template <typename T>
+typename std::enable_if<std::is_enum<T>::value &&
+                            !HasUserDefinedConvert<T>::value,
+                        IntegralConvertResult>::type
+FormatConvertImpl(T v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+
+template <typename T>
+StringConvertResult FormatConvertImpl(const StreamedWrapper<T>& v,
+                                      FormatConversionSpecImpl conv,
+                                      FormatSinkImpl* out) {
+  std::ostringstream oss;
+  oss << v.v_;
+  if (!oss) return {false};
+  return str_format_internal::FormatConvertImpl(oss.str(), conv, out);
+}
+
+// Use templates and dependent types to delay evaluation of the function
+// until after FormatCountCapture is fully defined.
+struct FormatCountCaptureHelper {
+  template <class T = int>
+  static ArgConvertResult<FormatConversionCharSetInternal::n> ConvertHelper(
+      const FormatCountCapture& v, FormatConversionSpecImpl conv,
+      FormatSinkImpl* sink) {
+    const absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
+
+    if (conv.conversion_char() !=
+        str_format_internal::FormatConversionCharInternal::n) {
+      return {false};
+    }
+    *v2.p_ = static_cast<int>(sink->size());
+    return {true};
+  }
+};
+
+template <class T = int>
+ArgConvertResult<FormatConversionCharSetInternal::n> FormatConvertImpl(
+    const FormatCountCapture& v, FormatConversionSpecImpl conv,
+    FormatSinkImpl* sink) {
+  return FormatCountCaptureHelper::ConvertHelper(v, conv, sink);
+}
+
+// Helper friend struct to hide implementation details from the public API of
+// FormatArgImpl.
+struct FormatArgImplFriend {
+  template <typename Arg>
+  static bool ToInt(Arg arg, int* out) {
+    // A value initialized FormatConversionSpecImpl has a `none` conv, which
+    // tells the dispatcher to run the `int` conversion.
+    return arg.dispatcher_(arg.data_, {}, out);
+  }
+
+  template <typename Arg>
+  static bool Convert(Arg arg, FormatConversionSpecImpl conv,
+                      FormatSinkImpl* out) {
+    return arg.dispatcher_(arg.data_, conv, out);
+  }
+
+  template <typename Arg>
+  static typename Arg::Dispatcher GetVTablePtrForTest(Arg arg) {
+    return arg.dispatcher_;
+  }
+};
+
+template <typename Arg>
+constexpr FormatConversionCharSet ArgumentToConv() {
+  return absl::str_format_internal::ExtractCharSet(
+      decltype(str_format_internal::FormatConvertImpl(
+          std::declval<const Arg&>(),
+          std::declval<const FormatConversionSpecImpl&>(),
+          std::declval<FormatSinkImpl*>())){});
+}
+
+// A type-erased handle to a format argument.
+class FormatArgImpl {
+ private:
+  enum { kInlinedSpace = 8 };
+
+  using VoidPtr = str_format_internal::VoidPtr;
+
+  union Data {
+    const void* ptr;
+    const volatile void* volatile_ptr;
+    char buf[kInlinedSpace];
+  };
+
+  using Dispatcher = bool (*)(Data, FormatConversionSpecImpl, void* out);
+
+  template <typename T>
+  struct store_by_value
+      : std::integral_constant<bool, (sizeof(T) <= kInlinedSpace) &&
+                                         (std::is_integral<T>::value ||
+                                          std::is_floating_point<T>::value ||
+                                          std::is_pointer<T>::value ||
+                                          std::is_same<VoidPtr, T>::value)> {};
+
+  enum StoragePolicy { ByPointer, ByVolatilePointer, ByValue };
+  template <typename T>
+  struct storage_policy
+      : std::integral_constant<StoragePolicy,
+                               (std::is_volatile<T>::value
+                                    ? ByVolatilePointer
+                                    : (store_by_value<T>::value ? ByValue
+                                                                : ByPointer))> {
+  };
+
+  // To reduce the number of vtables we will decay values before hand.
+  // Anything with a user-defined Convert will get its own vtable.
+  // For everything else:
+  //   - Decay char* and char arrays into `const char*`
+  //   - Decay any other pointer to `const void*`
+  //   - Decay all enums to their underlying type.
+  //   - Decay function pointers to void*.
+  template <typename T, typename = void>
+  struct DecayType {
+    static constexpr bool kHasUserDefined =
+        str_format_internal::HasUserDefinedConvert<T>::value;
+    using type = typename std::conditional<
+        !kHasUserDefined && std::is_convertible<T, const char*>::value,
+        const char*,
+        typename std::conditional<!kHasUserDefined &&
+                                      std::is_convertible<T, VoidPtr>::value,
+                                  VoidPtr, const T&>::type>::type;
+  };
+  template <typename T>
+  struct DecayType<T,
+                   typename std::enable_if<
+                       !str_format_internal::HasUserDefinedConvert<T>::value &&
+                       std::is_enum<T>::value>::type> {
+    using type = typename std::underlying_type<T>::type;
+  };
+
+ public:
+  template <typename T>
+  explicit FormatArgImpl(const T& value) {
+    using D = typename DecayType<T>::type;
+    static_assert(
+        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
+        "Decayed types must be stored by value");
+    Init(static_cast<D>(value));
+  }
+
+ private:
+  friend struct str_format_internal::FormatArgImplFriend;
+  template <typename T, StoragePolicy = storage_policy<T>::value>
+  struct Manager;
+
+  template <typename T>
+  struct Manager<T, ByPointer> {
+    static Data SetValue(const T& value) {
+      Data data;
+      data.ptr = std::addressof(value);
+      return data;
+    }
+
+    static const T& Value(Data arg) { return *static_cast<const T*>(arg.ptr); }
+  };
+
+  template <typename T>
+  struct Manager<T, ByVolatilePointer> {
+    static Data SetValue(const T& value) {
+      Data data;
+      data.volatile_ptr = &value;
+      return data;
+    }
+
+    static const T& Value(Data arg) {
+      return *static_cast<const T*>(arg.volatile_ptr);
+    }
+  };
+
+  template <typename T>
+  struct Manager<T, ByValue> {
+    static Data SetValue(const T& value) {
+      Data data;
+      memcpy(data.buf, &value, sizeof(value));
+      return data;
+    }
+
+    static T Value(Data arg) {
+      T value;
+      memcpy(&value, arg.buf, sizeof(T));
+      return value;
+    }
+  };
+
+  template <typename T>
+  void Init(const T& value) {
+    data_ = Manager<T>::SetValue(value);
+    dispatcher_ = &Dispatch<T>;
+  }
+
+  template <typename T>
+  static int ToIntVal(const T& val) {
+    using CommonType = typename std::conditional<std::is_signed<T>::value,
+                                                 int64_t, uint64_t>::type;
+    if (static_cast<CommonType>(val) >
+        static_cast<CommonType>((std::numeric_limits<int>::max)())) {
+      return (std::numeric_limits<int>::max)();
+    } else if (std::is_signed<T>::value &&
+               static_cast<CommonType>(val) <
+                   static_cast<CommonType>((std::numeric_limits<int>::min)())) {
+      return (std::numeric_limits<int>::min)();
+    }
+    return static_cast<int>(val);
+  }
+
+  template <typename T>
+  static bool ToInt(Data arg, int* out, std::true_type /* is_integral */,
+                    std::false_type) {
+    *out = ToIntVal(Manager<T>::Value(arg));
+    return true;
+  }
+
+  template <typename T>
+  static bool ToInt(Data arg, int* out, std::false_type,
+                    std::true_type /* is_enum */) {
+    *out = ToIntVal(static_cast<typename std::underlying_type<T>::type>(
+        Manager<T>::Value(arg)));
+    return true;
+  }
+
+  template <typename T>
+  static bool ToInt(Data, int*, std::false_type, std::false_type) {
+    return false;
+  }
+
+  template <typename T>
+  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
+    // A `none` conv indicates that we want the `int` conversion.
+    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
+                           FormatConversionCharInternal::kNone)) {
+      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
+                      std::is_enum<T>());
+    }
+    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
+                                     spec.conversion_char()))) {
+      return false;
+    }
+    return str_format_internal::FormatConvertImpl(
+               Manager<T>::Value(arg), spec,
+               static_cast<FormatSinkImpl*>(out))
+        .value;
+  }
+
+  Data data_;
+  Dispatcher dispatcher_;
+};
+
+#define ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E)                     \
+  E template bool FormatArgImpl::Dispatch<T>(Data, FormatConversionSpecImpl, \
+                                             void*)
+
+#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr,     \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(bool, __VA_ARGS__);               \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(char, __VA_ARGS__);               \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(signed char, __VA_ARGS__);        \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned char, __VA_ARGS__);      \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(short, __VA_ARGS__); /* NOLINT */ \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned short,      /* NOLINT */ \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int, __VA_ARGS__);                \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned int, __VA_ARGS__);       \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long, __VA_ARGS__); /* NOLINT */  \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long,      /* NOLINT */  \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long long, /* NOLINT */           \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */  \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__);             \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__);            \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__);              \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__);             \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__);        \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char*, __VA_ARGS__);        \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(std::string, __VA_ARGS__);        \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__)
+
+ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
+
+
+}  // namespace str_format_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/bind.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/bind.h
new file mode 100644
index 0000000..80f2965
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/bind.h
@@ -0,0 +1,248 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
+
+#include <array>
+#include <cstdio>
+#include <sstream>
+#include <string>
+
+#include "absl/base/port.h"
+#include "absl/strings/internal/str_format/arg.h"
+#include "absl/strings/internal/str_format/checker.h"
+#include "absl/strings/internal/str_format/parser.h"
+#include "absl/types/span.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class UntypedFormatSpec;
+
+namespace str_format_internal {
+
+class BoundConversion : public FormatConversionSpecImpl {
+ public:
+  const FormatArgImpl* arg() const { return arg_; }
+  void set_arg(const FormatArgImpl* a) { arg_ = a; }
+
+ private:
+  const FormatArgImpl* arg_;
+};
+
+// This is the type-erased class that the implementation uses.
+class UntypedFormatSpecImpl {
+ public:
+  UntypedFormatSpecImpl() = delete;
+
+  explicit UntypedFormatSpecImpl(string_view s)
+      : data_(s.data()), size_(s.size()) {}
+  explicit UntypedFormatSpecImpl(
+      const str_format_internal::ParsedFormatBase* pc)
+      : data_(pc), size_(~size_t{}) {}
+
+  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
+
+  string_view str() const {
+    assert(!has_parsed_conversion());
+    return string_view(static_cast<const char*>(data_), size_);
+  }
+  const str_format_internal::ParsedFormatBase* parsed_conversion() const {
+    assert(has_parsed_conversion());
+    return static_cast<const str_format_internal::ParsedFormatBase*>(data_);
+  }
+
+  template <typename T>
+  static const UntypedFormatSpecImpl& Extract(const T& s) {
+    return s.spec_;
+  }
+
+ private:
+  const void* data_;
+  size_t size_;
+};
+
+template <typename T, FormatConversionCharSet...>
+struct MakeDependent {
+  using type = T;
+};
+
+// Implicitly convertible from `const char*`, `string_view`, and the
+// `ExtendedParsedFormat` type. This abstraction allows all format functions to
+// operate on any without providing too many overloads.
+template <FormatConversionCharSet... Args>
+class FormatSpecTemplate
+    : public MakeDependent<UntypedFormatSpec, Args...>::type {
+  using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type;
+
+  template <bool res>
+  struct ErrorMaker {
+    constexpr bool operator()(int) const { return res; }
+  };
+
+  template <int i, int j>
+  static constexpr bool CheckArity(ErrorMaker<true> SpecifierCount = {},
+                                   ErrorMaker<i == j> ParametersPassed = {}) {
+    static_assert(SpecifierCount(i) == ParametersPassed(j),
+                  "Number of arguments passed must match the number of "
+                  "conversion specifiers.");
+    return true;
+  }
+
+  template <FormatConversionCharSet specified, FormatConversionCharSet passed,
+            int arg>
+  static constexpr bool CheckMatch(
+      ErrorMaker<Contains(specified, passed)> MismatchedArgumentNumber = {}) {
+    static_assert(MismatchedArgumentNumber(arg),
+                  "Passed argument must match specified format.");
+    return true;
+  }
+
+  template <FormatConversionCharSet... C, size_t... I>
+  static bool CheckMatches(absl::index_sequence<I...>) {
+    bool res[] = {true, CheckMatch<Args, C, I + 1>()...};
+    (void)res;
+    return true;
+  }
+
+ public:
+#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+  // Honeypot overload for when the string is not constexpr.
+  // We use the 'unavailable' attribute to give a better compiler error than
+  // just 'method is deleted'.
+  FormatSpecTemplate(...)  // NOLINT
+      __attribute__((unavailable("Format string is not constexpr.")));
+
+  // Honeypot overload for when the format is constexpr and invalid.
+  // We use the 'unavailable' attribute to give a better compiler error than
+  // just 'method is deleted'.
+  // To avoid checking the format twice, we just check that the format is
+  // constexpr. If it is valid, then the overload below will kick in.
+  // We add the template here to make this overload have lower priority.
+  template <typename = void>
+  FormatSpecTemplate(const char* s)  // NOLINT
+      __attribute__((
+          enable_if(str_format_internal::EnsureConstexpr(s), "constexpr trap"),
+          unavailable(
+              "Format specified does not match the arguments passed.")));
+
+  template <typename T = void>
+  FormatSpecTemplate(string_view s)  // NOLINT
+      __attribute__((enable_if(str_format_internal::EnsureConstexpr(s),
+                               "constexpr trap")))
+      : Base("to avoid noise in the compiler error") {
+    static_assert(sizeof(T*) == 0,
+                  "Format specified does not match the arguments passed.");
+  }
+
+  // Good format overload.
+  FormatSpecTemplate(const char* s)  // NOLINT
+      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
+      : Base(s) {}
+
+  FormatSpecTemplate(string_view s)  // NOLINT
+      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
+      : Base(s) {}
+
+#else  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+  FormatSpecTemplate(const char* s) : Base(s) {}  // NOLINT
+  FormatSpecTemplate(string_view s) : Base(s) {}  // NOLINT
+
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+  template <FormatConversionCharSet... C>
+  FormatSpecTemplate(const ExtendedParsedFormat<C...>& pc)  // NOLINT
+      : Base(&pc) {
+    CheckArity<sizeof...(C), sizeof...(Args)>();
+    CheckMatches<C...>(absl::make_index_sequence<sizeof...(C)>{});
+  }
+};
+
+class Streamable {
+ public:
+  Streamable(const UntypedFormatSpecImpl& format,
+             absl::Span<const FormatArgImpl> args)
+      : format_(format) {
+    if (args.size() <= ABSL_ARRAYSIZE(few_args_)) {
+      for (size_t i = 0; i < args.size(); ++i) {
+        few_args_[i] = args[i];
+      }
+      args_ = absl::MakeSpan(few_args_, args.size());
+    } else {
+      many_args_.assign(args.begin(), args.end());
+      args_ = many_args_;
+    }
+  }
+
+  std::ostream& Print(std::ostream& os) const;
+
+  friend std::ostream& operator<<(std::ostream& os, const Streamable& l) {
+    return l.Print(os);
+  }
+
+ private:
+  const UntypedFormatSpecImpl& format_;
+  absl::Span<const FormatArgImpl> args_;
+  // if args_.size() is 4 or less:
+  FormatArgImpl few_args_[4] = {FormatArgImpl(0), FormatArgImpl(0),
+                                FormatArgImpl(0), FormatArgImpl(0)};
+  // if args_.size() is more than 4:
+  std::vector<FormatArgImpl> many_args_;
+};
+
+// for testing
+std::string Summarize(UntypedFormatSpecImpl format,
+                      absl::Span<const FormatArgImpl> args);
+bool BindWithPack(const UnboundConversion* props,
+                  absl::Span<const FormatArgImpl> pack, BoundConversion* bound);
+
+bool FormatUntyped(FormatRawSinkImpl raw_sink,
+                   UntypedFormatSpecImpl format,
+                   absl::Span<const FormatArgImpl> args);
+
+std::string& AppendPack(std::string* out, UntypedFormatSpecImpl format,
+                        absl::Span<const FormatArgImpl> args);
+
+std::string FormatPack(const UntypedFormatSpecImpl format,
+                       absl::Span<const FormatArgImpl> args);
+
+int FprintF(std::FILE* output, UntypedFormatSpecImpl format,
+            absl::Span<const FormatArgImpl> args);
+int SnprintF(char* output, size_t size, UntypedFormatSpecImpl format,
+             absl::Span<const FormatArgImpl> args);
+
+// Returned by Streamed(v). Converts via '%s' to the std::string created
+// by std::ostream << v.
+template <typename T>
+class StreamedWrapper {
+ public:
+  explicit StreamedWrapper(const T& v) : v_(v) { }
+
+ private:
+  template <typename S>
+  friend ArgConvertResult<FormatConversionCharSetInternal::s> FormatConvertImpl(
+      const StreamedWrapper<S>& v, FormatConversionSpecImpl conv,
+      FormatSinkImpl* out);
+  const T& v_;
+};
+
+}  // namespace str_format_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/checker.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/checker.h
new file mode 100644
index 0000000..4fd19d1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/checker.h
@@ -0,0 +1,338 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
+
+#include "absl/base/attributes.h"
+#include "absl/strings/internal/str_format/arg.h"
+#include "absl/strings/internal/str_format/extension.h"
+
+// Compile time check support for entry points.
+
+#ifndef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+// We disable format checker under vscode intellisense compilation.
+// See https://github.com/microsoft/vscode-cpptools/issues/3683 for
+// more details.
+#if ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__) && \
+    !defined(__INTELLISENSE__)
+#define ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 1
+#endif  // ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__) &&
+        // !defined(__INTELLISENSE__)
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace str_format_internal {
+
+constexpr bool AllOf() { return true; }
+
+template <typename... T>
+constexpr bool AllOf(bool b, T... t) {
+  return b && AllOf(t...);
+}
+
+#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+constexpr bool ContainsChar(const char* chars, char c) {
+  return *chars == c || (*chars && ContainsChar(chars + 1, c));
+}
+
+// A constexpr compatible list of Convs.
+struct ConvList {
+  const FormatConversionCharSet* array;
+  int count;
+
+  // We do the bound check here to avoid having to do it on the callers.
+  // Returning an empty FormatConversionCharSet has the same effect as
+  // short circuiting because it will never match any conversion.
+  constexpr FormatConversionCharSet operator[](int i) const {
+    return i < count ? array[i] : FormatConversionCharSet{};
+  }
+
+  constexpr ConvList without_front() const {
+    return count != 0 ? ConvList{array + 1, count - 1} : *this;
+  }
+};
+
+template <size_t count>
+struct ConvListT {
+  // Make sure the array has size > 0.
+  FormatConversionCharSet list[count ? count : 1];
+};
+
+constexpr char GetChar(string_view str, size_t index) {
+  return index < str.size() ? str[index] : char{};
+}
+
+constexpr string_view ConsumeFront(string_view str, size_t len = 1) {
+  return len <= str.size() ? string_view(str.data() + len, str.size() - len)
+                           : string_view();
+}
+
+constexpr string_view ConsumeAnyOf(string_view format, const char* chars) {
+  return ContainsChar(chars, GetChar(format, 0))
+             ? ConsumeAnyOf(ConsumeFront(format), chars)
+             : format;
+}
+
+constexpr bool IsDigit(char c) { return c >= '0' && c <= '9'; }
+
+// Helper class for the ParseDigits function.
+// It encapsulates the two return values we need there.
+struct Integer {
+  string_view format;
+  int value;
+
+  // If the next character is a '$', consume it.
+  // Otherwise, make `this` an invalid positional argument.
+  constexpr Integer ConsumePositionalDollar() const {
+    return GetChar(format, 0) == '$' ? Integer{ConsumeFront(format), value}
+                                     : Integer{format, 0};
+  }
+};
+
+constexpr Integer ParseDigits(string_view format, int value = 0) {
+  return IsDigit(GetChar(format, 0))
+             ? ParseDigits(ConsumeFront(format),
+                           10 * value + GetChar(format, 0) - '0')
+             : Integer{format, value};
+}
+
+// Parse digits for a positional argument.
+// The parsing also consumes the '$'.
+constexpr Integer ParsePositional(string_view format) {
+  return ParseDigits(format).ConsumePositionalDollar();
+}
+
+// Parses a single conversion specifier.
+// See ConvParser::Run() for post conditions.
+class ConvParser {
+  constexpr ConvParser SetFormat(string_view format) const {
+    return ConvParser(format, args_, error_, arg_position_, is_positional_);
+  }
+
+  constexpr ConvParser SetArgs(ConvList args) const {
+    return ConvParser(format_, args, error_, arg_position_, is_positional_);
+  }
+
+  constexpr ConvParser SetError(bool error) const {
+    return ConvParser(format_, args_, error_ || error, arg_position_,
+                      is_positional_);
+  }
+
+  constexpr ConvParser SetArgPosition(int arg_position) const {
+    return ConvParser(format_, args_, error_, arg_position, is_positional_);
+  }
+
+  // Consumes the next arg and verifies that it matches `conv`.
+  // `error_` is set if there is no next arg or if it doesn't match `conv`.
+  constexpr ConvParser ConsumeNextArg(char conv) const {
+    return SetArgs(args_.without_front()).SetError(!Contains(args_[0], conv));
+  }
+
+  // Verify that positional argument `i.value` matches `conv`.
+  // `error_` is set if `i.value` is not a valid argument or if it doesn't
+  // match.
+  constexpr ConvParser VerifyPositional(Integer i, char conv) const {
+    return SetFormat(i.format).SetError(!Contains(args_[i.value - 1], conv));
+  }
+
+  // Parse the position of the arg and store it in `arg_position_`.
+  constexpr ConvParser ParseArgPosition(Integer arg) const {
+    return SetFormat(arg.format).SetArgPosition(arg.value);
+  }
+
+  // Consume the flags.
+  constexpr ConvParser ParseFlags() const {
+    return SetFormat(ConsumeAnyOf(format_, "-+ #0"));
+  }
+
+  // Consume the width.
+  // If it is '*', we verify that it matches `args_`. `error_` is set if it
+  // doesn't match.
+  constexpr ConvParser ParseWidth() const {
+    return IsDigit(GetChar(format_, 0))
+               ? SetFormat(ParseDigits(format_).format)
+               : GetChar(format_, 0) == '*'
+                     ? is_positional_
+                           ? VerifyPositional(
+                                 ParsePositional(ConsumeFront(format_)), '*')
+                           : SetFormat(ConsumeFront(format_))
+                                 .ConsumeNextArg('*')
+                     : *this;
+  }
+
+  // Consume the precision.
+  // If it is '*', we verify that it matches `args_`. `error_` is set if it
+  // doesn't match.
+  constexpr ConvParser ParsePrecision() const {
+    return GetChar(format_, 0) != '.'
+               ? *this
+               : GetChar(format_, 1) == '*'
+                     ? is_positional_
+                           ? VerifyPositional(
+                                 ParsePositional(ConsumeFront(format_, 2)), '*')
+                           : SetFormat(ConsumeFront(format_, 2))
+                                 .ConsumeNextArg('*')
+                     : SetFormat(ParseDigits(ConsumeFront(format_)).format);
+  }
+
+  // Consume the length characters.
+  constexpr ConvParser ParseLength() const {
+    return SetFormat(ConsumeAnyOf(format_, "lLhjztq"));
+  }
+
+  // Consume the conversion character and verify that it matches `args_`.
+  // `error_` is set if it doesn't match.
+  constexpr ConvParser ParseConversion() const {
+    return is_positional_
+               ? VerifyPositional({ConsumeFront(format_), arg_position_},
+                                  GetChar(format_, 0))
+               : ConsumeNextArg(GetChar(format_, 0))
+                     .SetFormat(ConsumeFront(format_));
+  }
+
+  constexpr ConvParser(string_view format, ConvList args, bool error,
+                       int arg_position, bool is_positional)
+      : format_(format),
+        args_(args),
+        error_(error),
+        arg_position_(arg_position),
+        is_positional_(is_positional) {}
+
+ public:
+  constexpr ConvParser(string_view format, ConvList args, bool is_positional)
+      : format_(format),
+        args_(args),
+        error_(false),
+        arg_position_(0),
+        is_positional_(is_positional) {}
+
+  // Consume the whole conversion specifier.
+  // `format()` will be set to the character after the conversion character.
+  // `error()` will be set if any of the arguments do not match.
+  constexpr ConvParser Run() const {
+    return (is_positional_ ? ParseArgPosition(ParsePositional(format_)) : *this)
+        .ParseFlags()
+        .ParseWidth()
+        .ParsePrecision()
+        .ParseLength()
+        .ParseConversion();
+  }
+
+  constexpr string_view format() const { return format_; }
+  constexpr ConvList args() const { return args_; }
+  constexpr bool error() const { return error_; }
+  constexpr bool is_positional() const { return is_positional_; }
+
+ private:
+  string_view format_;
+  // Current list of arguments. If we are not in positional mode we will consume
+  // from the front.
+  ConvList args_;
+  bool error_;
+  // Holds the argument position of the conversion character, if we are in
+  // positional mode. Otherwise, it is unspecified.
+  int arg_position_;
+  // Whether we are in positional mode.
+  // It changes the behavior of '*' and where to find the converted argument.
+  bool is_positional_;
+};
+
+// Parses a whole format expression.
+// See FormatParser::Run().
+class FormatParser {
+  static constexpr bool FoundPercent(string_view format) {
+    return format.empty() ||
+           (GetChar(format, 0) == '%' && GetChar(format, 1) != '%');
+  }
+
+  // We use an inner function to increase the recursion limit.
+  // The inner function consumes up to `limit` characters on every run.
+  // This increases the limit from 512 to ~512*limit.
+  static constexpr string_view ConsumeNonPercentInner(string_view format,
+                                                      int limit = 20) {
+    return FoundPercent(format) || !limit
+               ? format
+               : ConsumeNonPercentInner(
+                     ConsumeFront(format, GetChar(format, 0) == '%' &&
+                                                  GetChar(format, 1) == '%'
+                                              ? 2
+                                              : 1),
+                     limit - 1);
+  }
+
+  // Consume characters until the next conversion spec %.
+  // It skips %%.
+  static constexpr string_view ConsumeNonPercent(string_view format) {
+    return FoundPercent(format)
+               ? format
+               : ConsumeNonPercent(ConsumeNonPercentInner(format));
+  }
+
+  static constexpr bool IsPositional(string_view format) {
+    return IsDigit(GetChar(format, 0)) ? IsPositional(ConsumeFront(format))
+                                       : GetChar(format, 0) == '$';
+  }
+
+  constexpr bool RunImpl(bool is_positional) const {
+    // In non-positional mode we require all arguments to be consumed.
+    // In positional mode just reaching the end of the format without errors is
+    // enough.
+    return (format_.empty() && (is_positional || args_.count == 0)) ||
+           (!format_.empty() &&
+            ValidateArg(
+                ConvParser(ConsumeFront(format_), args_, is_positional).Run()));
+  }
+
+  constexpr bool ValidateArg(ConvParser conv) const {
+    return !conv.error() && FormatParser(conv.format(), conv.args())
+                                .RunImpl(conv.is_positional());
+  }
+
+ public:
+  constexpr FormatParser(string_view format, ConvList args)
+      : format_(ConsumeNonPercent(format)), args_(args) {}
+
+  // Runs the parser for `format` and `args`.
+  // It verifies that the format is valid and that all conversion specifiers
+  // match the arguments passed.
+  // In non-positional mode it also verfies that all arguments are consumed.
+  constexpr bool Run() const {
+    return RunImpl(!format_.empty() && IsPositional(ConsumeFront(format_)));
+  }
+
+ private:
+  string_view format_;
+  // Current list of arguments.
+  // If we are not in positional mode we will consume from the front and will
+  // have to be empty in the end.
+  ConvList args_;
+};
+
+template <FormatConversionCharSet... C>
+constexpr bool ValidFormatImpl(string_view format) {
+  return FormatParser(format,
+                      {ConvListT<sizeof...(C)>{{C...}}.list, sizeof...(C)})
+      .Run();
+}
+
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+}  // namespace str_format_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/extension.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/extension.h
new file mode 100644
index 0000000..55e8ac8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/extension.h
@@ -0,0 +1,448 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
+
+#include <limits.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <ostream>
+
+#include "absl/base/config.h"
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/internal/str_format/output.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+enum class FormatConversionChar : uint8_t;
+enum class FormatConversionCharSet : uint64_t;
+
+namespace str_format_internal {
+
+class FormatRawSinkImpl {
+ public:
+  // Implicitly convert from any type that provides the hook function as
+  // described above.
+  template <typename T, decltype(str_format_internal::InvokeFlush(
+                            std::declval<T*>(), string_view()))* = nullptr>
+  FormatRawSinkImpl(T* raw)  // NOLINT
+      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
+
+  void Write(string_view s) { write_(sink_, s); }
+
+  template <typename T>
+  static FormatRawSinkImpl Extract(T s) {
+    return s.sink_;
+  }
+
+ private:
+  template <typename T>
+  static void Flush(void* r, string_view s) {
+    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
+  }
+
+  void* sink_;
+  void (*write_)(void*, string_view);
+};
+
+// An abstraction to which conversions write their string data.
+class FormatSinkImpl {
+ public:
+  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
+
+  ~FormatSinkImpl() { Flush(); }
+
+  void Flush() {
+    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
+    pos_ = buf_;
+  }
+
+  void Append(size_t n, char c) {
+    if (n == 0) return;
+    size_ += n;
+    auto raw_append = [&](size_t count) {
+      memset(pos_, c, count);
+      pos_ += count;
+    };
+    while (n > Avail()) {
+      n -= Avail();
+      if (Avail() > 0) {
+        raw_append(Avail());
+      }
+      Flush();
+    }
+    raw_append(n);
+  }
+
+  void Append(string_view v) {
+    size_t n = v.size();
+    if (n == 0) return;
+    size_ += n;
+    if (n >= Avail()) {
+      Flush();
+      raw_.Write(v);
+      return;
+    }
+    memcpy(pos_, v.data(), n);
+    pos_ += n;
+  }
+
+  size_t size() const { return size_; }
+
+  // Put 'v' to 'sink' with specified width, precision, and left flag.
+  bool PutPaddedString(string_view v, int width, int precision, bool left);
+
+  template <typename T>
+  T Wrap() {
+    return T(this);
+  }
+
+  template <typename T>
+  static FormatSinkImpl* Extract(T* s) {
+    return s->sink_;
+  }
+
+ private:
+  size_t Avail() const {
+    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
+  }
+
+  FormatRawSinkImpl raw_;
+  size_t size_ = 0;
+  char* pos_ = buf_;
+  char buf_[1024];
+};
+
+enum class Flags : uint8_t {
+  kBasic = 0,
+  kLeft = 1 << 0,
+  kShowPos = 1 << 1,
+  kSignCol = 1 << 2,
+  kAlt = 1 << 3,
+  kZero = 1 << 4,
+  // This is not a real flag. It just exists to turn off kBasic when no other
+  // flags are set. This is for when width/precision are specified.
+  kNonBasic = 1 << 5,
+};
+
+constexpr Flags operator|(Flags a, Flags b) {
+  return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
+}
+
+constexpr bool FlagsContains(Flags haystack, Flags needle) {
+  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
+         static_cast<uint8_t>(needle);
+}
+
+std::string FlagsToString(Flags v);
+
+inline std::ostream& operator<<(std::ostream& os, Flags v) {
+  return os << FlagsToString(v);
+}
+
+// clang-format off
+#define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
+  /* text */ \
+  X_VAL(c) X_SEP X_VAL(s) X_SEP \
+  /* ints */ \
+  X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \
+  X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \
+  /* floats */ \
+  X_VAL(f) X_SEP X_VAL(F) X_SEP X_VAL(e) X_SEP X_VAL(E) X_SEP \
+  X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
+  /* misc */ \
+  X_VAL(n) X_SEP X_VAL(p)
+// clang-format on
+
+// This type should not be referenced, it exists only to provide labels
+// internally that match the values declared in FormatConversionChar in
+// str_format.h. This is meant to allow internal libraries to use the same
+// declared interface type as the public interface
+// (absl::StrFormatConversionChar) while keeping the definition in a public
+// header.
+// Internal libraries should use the form
+// `FormatConversionCharInternal::c`, `FormatConversionCharInternal::kNone` for
+// comparisons.  Use in switch statements is not recommended due to a bug in how
+// gcc 4.9 -Wswitch handles declared but undefined enums.
+struct FormatConversionCharInternal {
+  FormatConversionCharInternal() = delete;
+
+ private:
+  // clang-format off
+  enum class Enum : uint8_t {
+    c, s,                    // text
+    d, i, o, u, x, X,        // int
+    f, F, e, E, g, G, a, A,  // float
+    n, p,                    // misc
+    kNone
+  };
+  // clang-format on
+ public:
+#define ABSL_INTERNAL_X_VAL(id)              \
+  static constexpr FormatConversionChar id = \
+      static_cast<FormatConversionChar>(Enum::id);
+  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
+#undef ABSL_INTERNAL_X_VAL
+  static constexpr FormatConversionChar kNone =
+      static_cast<FormatConversionChar>(Enum::kNone);
+};
+// clang-format on
+
+inline FormatConversionChar FormatConversionCharFromChar(char c) {
+  switch (c) {
+#define ABSL_INTERNAL_X_VAL(id) \
+  case #id[0]:                  \
+    return FormatConversionCharInternal::id;
+    ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
+#undef ABSL_INTERNAL_X_VAL
+  }
+  return FormatConversionCharInternal::kNone;
+}
+
+inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
+  if (c == FormatConversionCharInternal::X ||
+      c == FormatConversionCharInternal::F ||
+      c == FormatConversionCharInternal::E ||
+      c == FormatConversionCharInternal::G ||
+      c == FormatConversionCharInternal::A) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
+  if (c == FormatConversionCharInternal::a ||
+      c == FormatConversionCharInternal::e ||
+      c == FormatConversionCharInternal::f ||
+      c == FormatConversionCharInternal::g ||
+      c == FormatConversionCharInternal::A ||
+      c == FormatConversionCharInternal::E ||
+      c == FormatConversionCharInternal::F ||
+      c == FormatConversionCharInternal::G) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+inline char FormatConversionCharToChar(FormatConversionChar c) {
+  if (c == FormatConversionCharInternal::kNone) {
+    return '\0';
+
+#define ABSL_INTERNAL_X_VAL(e)                       \
+  } else if (c == FormatConversionCharInternal::e) { \
+    return #e[0];
+#define ABSL_INTERNAL_X_SEP
+  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
+                                         ABSL_INTERNAL_X_SEP)
+  } else {
+    return '\0';
+  }
+
+#undef ABSL_INTERNAL_X_VAL
+#undef ABSL_INTERNAL_X_SEP
+}
+
+// The associated char.
+inline std::ostream& operator<<(std::ostream& os, FormatConversionChar v) {
+  char c = FormatConversionCharToChar(v);
+  if (!c) c = '?';
+  return os << c;
+}
+
+struct FormatConversionSpecImplFriend;
+
+class FormatConversionSpecImpl {
+ public:
+  // Width and precison are not specified, no flags are set.
+  bool is_basic() const { return flags_ == Flags::kBasic; }
+  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
+  bool has_show_pos_flag() const {
+    return FlagsContains(flags_, Flags::kShowPos);
+  }
+  bool has_sign_col_flag() const {
+    return FlagsContains(flags_, Flags::kSignCol);
+  }
+  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
+  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
+
+  FormatConversionChar conversion_char() const {
+    // Keep this field first in the struct . It generates better code when
+    // accessing it when ConversionSpec is passed by value in registers.
+    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
+    return conv_;
+  }
+
+  // Returns the specified width. If width is unspecfied, it returns a negative
+  // value.
+  int width() const { return width_; }
+  // Returns the specified precision. If precision is unspecfied, it returns a
+  // negative value.
+  int precision() const { return precision_; }
+
+  template <typename T>
+  T Wrap() {
+    return T(*this);
+  }
+
+ private:
+  friend struct str_format_internal::FormatConversionSpecImplFriend;
+  FormatConversionChar conv_ = FormatConversionCharInternal::kNone;
+  Flags flags_;
+  int width_;
+  int precision_;
+};
+
+struct FormatConversionSpecImplFriend final {
+  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
+    conv->flags_ = f;
+  }
+  static void SetConversionChar(FormatConversionChar c,
+                                FormatConversionSpecImpl* conv) {
+    conv->conv_ = c;
+  }
+  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
+    conv->width_ = w;
+  }
+  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
+    conv->precision_ = p;
+  }
+  static std::string FlagsToString(const FormatConversionSpecImpl& spec) {
+    return str_format_internal::FlagsToString(spec.flags_);
+  }
+};
+
+// Type safe OR operator.
+// We need this for two reasons:
+//  1. operator| on enums makes them decay to integers and the result is an
+//     integer. We need the result to stay as an enum.
+//  2. We use "enum class" which would not work even if we accepted the decay.
+constexpr FormatConversionCharSet FormatConversionCharSetUnion(
+    FormatConversionCharSet a) {
+  return a;
+}
+
+template <typename... CharSet>
+constexpr FormatConversionCharSet FormatConversionCharSetUnion(
+    FormatConversionCharSet a, CharSet... rest) {
+  return static_cast<FormatConversionCharSet>(
+      static_cast<uint64_t>(a) |
+      static_cast<uint64_t>(FormatConversionCharSetUnion(rest...)));
+}
+
+constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
+  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
+}
+
+constexpr uint64_t FormatConversionCharToConvInt(char conv) {
+  return
+#define ABSL_INTERNAL_CHAR_SET_CASE(c)                                 \
+  conv == #c[0]                                                        \
+      ? FormatConversionCharToConvInt(FormatConversionCharInternal::c) \
+      :
+      ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
+#undef ABSL_INTERNAL_CHAR_SET_CASE
+                  conv == '*'
+          ? 1
+          : 0;
+}
+
+constexpr FormatConversionCharSet FormatConversionCharToConvValue(char conv) {
+  return static_cast<FormatConversionCharSet>(
+      FormatConversionCharToConvInt(conv));
+}
+
+struct FormatConversionCharSetInternal {
+#define ABSL_INTERNAL_CHAR_SET_CASE(c)         \
+  static constexpr FormatConversionCharSet c = \
+      FormatConversionCharToConvValue(#c[0]);
+  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
+#undef ABSL_INTERNAL_CHAR_SET_CASE
+
+  // Used for width/precision '*' specification.
+  static constexpr FormatConversionCharSet kStar =
+      FormatConversionCharToConvValue('*');
+
+  static constexpr FormatConversionCharSet kIntegral =
+      FormatConversionCharSetUnion(d, i, u, o, x, X);
+  static constexpr FormatConversionCharSet kFloating =
+      FormatConversionCharSetUnion(a, e, f, g, A, E, F, G);
+  static constexpr FormatConversionCharSet kNumeric =
+      FormatConversionCharSetUnion(kIntegral, kFloating);
+  static constexpr FormatConversionCharSet kPointer = p;
+};
+
+// Type safe OR operator.
+// We need this for two reasons:
+//  1. operator| on enums makes them decay to integers and the result is an
+//     integer. We need the result to stay as an enum.
+//  2. We use "enum class" which would not work even if we accepted the decay.
+constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
+                                            FormatConversionCharSet b) {
+  return FormatConversionCharSetUnion(a, b);
+}
+
+// Overloaded conversion functions to support absl::ParsedFormat.
+// Get a conversion with a single character in it.
+constexpr FormatConversionCharSet ToFormatConversionCharSet(char c) {
+  return static_cast<FormatConversionCharSet>(
+      FormatConversionCharToConvValue(c));
+}
+
+// Get a conversion with a single character in it.
+constexpr FormatConversionCharSet ToFormatConversionCharSet(
+    FormatConversionCharSet c) {
+  return c;
+}
+
+template <typename T>
+void ToFormatConversionCharSet(T) = delete;
+
+// Checks whether `c` exists in `set`.
+constexpr bool Contains(FormatConversionCharSet set, char c) {
+  return (static_cast<uint64_t>(set) &
+          static_cast<uint64_t>(FormatConversionCharToConvValue(c))) != 0;
+}
+
+// Checks whether all the characters in `c` are contained in `set`
+constexpr bool Contains(FormatConversionCharSet set,
+                        FormatConversionCharSet c) {
+  return (static_cast<uint64_t>(set) & static_cast<uint64_t>(c)) ==
+         static_cast<uint64_t>(c);
+}
+
+// Checks whether all the characters in `c` are contained in `set`
+constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
+  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
+}
+
+// Return capacity - used, clipped to a minimum of 0.
+inline size_t Excess(size_t used, size_t capacity) {
+  return used < capacity ? capacity - used : 0;
+}
+
+}  // namespace str_format_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/float_conversion.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/float_conversion.h
new file mode 100644
index 0000000..71100e7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/float_conversion.h
@@ -0,0 +1,37 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
+
+#include "absl/strings/internal/str_format/extension.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace str_format_internal {
+
+bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
+                      FormatSinkImpl *sink);
+
+bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
+                      FormatSinkImpl *sink);
+
+bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
+                      FormatSinkImpl *sink);
+
+}  // namespace str_format_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/output.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/output.h
new file mode 100644
index 0000000..15e751a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/output.h
@@ -0,0 +1,97 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Output extension hooks for the Format library.
+// `internal::InvokeFlush` calls the appropriate flush function for the
+// specified output argument.
+// `BufferRawSink` is a simple output sink for a char buffer. Used by SnprintF.
+// `FILERawSink` is a std::FILE* based sink. Used by PrintF and FprintF.
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
+
+#include <cstdio>
+#include <ios>
+#include <ostream>
+#include <string>
+
+#include "absl/base/port.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace str_format_internal {
+
+// RawSink implementation that writes into a char* buffer.
+// It will not overflow the buffer, but will keep the total count of chars
+// that would have been written.
+class BufferRawSink {
+ public:
+  BufferRawSink(char* buffer, size_t size) : buffer_(buffer), size_(size) {}
+
+  size_t total_written() const { return total_written_; }
+  void Write(string_view v);
+
+ private:
+  char* buffer_;
+  size_t size_;
+  size_t total_written_ = 0;
+};
+
+// RawSink implementation that writes into a FILE*.
+// It keeps track of the total number of bytes written and any error encountered
+// during the writes.
+class FILERawSink {
+ public:
+  explicit FILERawSink(std::FILE* output) : output_(output) {}
+
+  void Write(string_view v);
+
+  size_t count() const { return count_; }
+  int error() const { return error_; }
+
+ private:
+  std::FILE* output_;
+  int error_ = 0;
+  size_t count_ = 0;
+};
+
+// Provide RawSink integration with common types from the STL.
+inline void AbslFormatFlush(std::string* out, string_view s) {
+  out->append(s.data(), s.size());
+}
+inline void AbslFormatFlush(std::ostream* out, string_view s) {
+  out->write(s.data(), static_cast<std::streamsize>(s.size()));
+}
+
+inline void AbslFormatFlush(FILERawSink* sink, string_view v) {
+  sink->Write(v);
+}
+
+inline void AbslFormatFlush(BufferRawSink* sink, string_view v) {
+  sink->Write(v);
+}
+
+// This is a SFINAE to get a better compiler error message when the type
+// is not supported.
+template <typename T>
+auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
+  AbslFormatFlush(out, s);
+}
+
+}  // namespace str_format_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/parser.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/parser.h
new file mode 100644
index 0000000..32b91d0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/parser.h
@@ -0,0 +1,359 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#include <cassert>
+#include <cstdint>
+#include <initializer_list>
+#include <iosfwd>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/internal/str_format/checker.h"
+#include "absl/strings/internal/str_format/extension.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace str_format_internal {
+
+enum class LengthMod : std::uint8_t { h, hh, l, ll, L, j, z, t, q, none };
+
+std::string LengthModToString(LengthMod v);
+
+// The analyzed properties of a single specified conversion.
+struct UnboundConversion {
+  UnboundConversion() {}
+
+  class InputValue {
+   public:
+    void set_value(int value) {
+      assert(value >= 0);
+      value_ = value;
+    }
+    int value() const { return value_; }
+
+    // Marks the value as "from arg". aka the '*' format.
+    // Requires `value >= 1`.
+    // When set, is_from_arg() return true and get_from_arg() returns the
+    // original value.
+    // `value()`'s return value is unspecfied in this state.
+    void set_from_arg(int value) {
+      assert(value > 0);
+      value_ = -value - 1;
+    }
+    bool is_from_arg() const { return value_ < -1; }
+    int get_from_arg() const {
+      assert(is_from_arg());
+      return -value_ - 1;
+    }
+
+   private:
+    int value_ = -1;
+  };
+
+  // No need to initialize. It will always be set in the parser.
+  int arg_position;
+
+  InputValue width;
+  InputValue precision;
+
+  Flags flags = Flags::kBasic;
+  LengthMod length_mod = LengthMod::none;
+  FormatConversionChar conv = FormatConversionCharInternal::kNone;
+};
+
+// Consume conversion spec prefix (not including '%') of [p, end) if valid.
+// Examples of valid specs would be e.g.: "s", "d", "-12.6f".
+// If valid, it returns the first character following the conversion spec,
+// and the spec part is broken down and returned in 'conv'.
+// If invalid, returns nullptr.
+const char* ConsumeUnboundConversion(const char* p, const char* end,
+                                     UnboundConversion* conv, int* next_arg);
+
+// Helper tag class for the table below.
+// It allows fast `char -> ConversionChar/LengthMod/Flags` checking and
+// conversions.
+class ConvTag {
+ public:
+  constexpr ConvTag(FormatConversionChar conversion_char)  // NOLINT
+      : tag_(static_cast<uint8_t>(conversion_char)) {}
+  constexpr ConvTag(LengthMod length_mod)  // NOLINT
+      : tag_(0x80 | static_cast<uint8_t>(length_mod)) {}
+  constexpr ConvTag(Flags flags)  // NOLINT
+      : tag_(0xc0 | static_cast<uint8_t>(flags)) {}
+  constexpr ConvTag() : tag_(0xFF) {}
+
+  bool is_conv() const { return (tag_ & 0x80) == 0; }
+  bool is_length() const { return (tag_ & 0xC0) == 0x80; }
+  bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
+
+  FormatConversionChar as_conv() const {
+    assert(is_conv());
+    assert(!is_length());
+    assert(!is_flags());
+    return static_cast<FormatConversionChar>(tag_);
+  }
+  LengthMod as_length() const {
+    assert(!is_conv());
+    assert(is_length());
+    assert(!is_flags());
+    return static_cast<LengthMod>(tag_ & 0x3F);
+  }
+  Flags as_flags() const {
+    assert(!is_conv());
+    assert(!is_length());
+    assert(is_flags());
+    return static_cast<Flags>(tag_ & 0x1F);
+  }
+
+ private:
+  uint8_t tag_;
+};
+
+extern const ConvTag kTags[256];
+// Keep a single table for all the conversion chars and length modifiers.
+inline ConvTag GetTagForChar(char c) {
+  return kTags[static_cast<unsigned char>(c)];
+}
+
+// Parse the format string provided in 'src' and pass the identified items into
+// 'consumer'.
+// Text runs will be passed by calling
+//   Consumer::Append(string_view);
+// ConversionItems will be passed by calling
+//   Consumer::ConvertOne(UnboundConversion, string_view);
+// In the case of ConvertOne, the string_view that is passed is the
+// portion of the format string corresponding to the conversion, not including
+// the leading %. On success, it returns true. On failure, it stops and returns
+// false.
+template <typename Consumer>
+bool ParseFormatString(string_view src, Consumer consumer) {
+  int next_arg = 0;
+  const char* p = src.data();
+  const char* const end = p + src.size();
+  while (p != end) {
+    const char* percent =
+        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
+    if (!percent) {
+      // We found the last substring.
+      return consumer.Append(string_view(p, end - p));
+    }
+    // We found a percent, so push the text run then process the percent.
+    if (ABSL_PREDICT_FALSE(!consumer.Append(string_view(p, percent - p)))) {
+      return false;
+    }
+    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
+
+    auto tag = GetTagForChar(percent[1]);
+    if (tag.is_conv()) {
+      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
+        // This indicates an error in the format string.
+        // The only way to get `next_arg < 0` here is to have a positional
+        // argument first which sets next_arg to -1 and then a non-positional
+        // argument.
+        return false;
+      }
+      p = percent + 2;
+
+      // Keep this case separate from the one below.
+      // ConvertOne is more efficient when the compiler can see that the `basic`
+      // flag is set.
+      UnboundConversion conv;
+      conv.conv = tag.as_conv();
+      conv.arg_position = ++next_arg;
+      if (ABSL_PREDICT_FALSE(
+              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
+        return false;
+      }
+    } else if (percent[1] != '%') {
+      UnboundConversion conv;
+      p = ConsumeUnboundConversion(percent + 1, end, &conv, &next_arg);
+      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
+      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
+          conv, string_view(percent + 1, p - (percent + 1))))) {
+        return false;
+      }
+    } else {
+      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
+      p = percent + 2;
+      continue;
+    }
+  }
+  return true;
+}
+
+// Always returns true, or fails to compile in a constexpr context if s does not
+// point to a constexpr char array.
+constexpr bool EnsureConstexpr(string_view s) {
+  return s.empty() || s[0] == s[0];
+}
+
+class ParsedFormatBase {
+ public:
+  explicit ParsedFormatBase(
+      string_view format, bool allow_ignored,
+      std::initializer_list<FormatConversionCharSet> convs);
+
+  ParsedFormatBase(const ParsedFormatBase& other) { *this = other; }
+
+  ParsedFormatBase(ParsedFormatBase&& other) { *this = std::move(other); }
+
+  ParsedFormatBase& operator=(const ParsedFormatBase& other) {
+    if (this == &other) return *this;
+    has_error_ = other.has_error_;
+    items_ = other.items_;
+    size_t text_size = items_.empty() ? 0 : items_.back().text_end;
+    data_.reset(new char[text_size]);
+    memcpy(data_.get(), other.data_.get(), text_size);
+    return *this;
+  }
+
+  ParsedFormatBase& operator=(ParsedFormatBase&& other) {
+    if (this == &other) return *this;
+    has_error_ = other.has_error_;
+    data_ = std::move(other.data_);
+    items_ = std::move(other.items_);
+    // Reset the vector to make sure the invariants hold.
+    other.items_.clear();
+    return *this;
+  }
+
+  template <typename Consumer>
+  bool ProcessFormat(Consumer consumer) const {
+    const char* const base = data_.get();
+    string_view text(base, 0);
+    for (const auto& item : items_) {
+      const char* const end = text.data() + text.size();
+      text =
+          string_view(end, static_cast<size_t>((base + item.text_end) - end));
+      if (item.is_conversion) {
+        if (!consumer.ConvertOne(item.conv, text)) return false;
+      } else {
+        if (!consumer.Append(text)) return false;
+      }
+    }
+    return !has_error_;
+  }
+
+  bool has_error() const { return has_error_; }
+
+ private:
+  // Returns whether the conversions match and if !allow_ignored it verifies
+  // that all conversions are used by the format.
+  bool MatchesConversions(
+      bool allow_ignored,
+      std::initializer_list<FormatConversionCharSet> convs) const;
+
+  struct ParsedFormatConsumer;
+
+  struct ConversionItem {
+    bool is_conversion;
+    // Points to the past-the-end location of this element in the data_ array.
+    size_t text_end;
+    UnboundConversion conv;
+  };
+
+  bool has_error_;
+  std::unique_ptr<char[]> data_;
+  std::vector<ConversionItem> items_;
+};
+
+
+// A value type representing a preparsed format.  These can be created, copied
+// around, and reused to speed up formatting loops.
+// The user must specify through the template arguments the conversion
+// characters used in the format. This will be checked at compile time.
+//
+// This class uses Conv enum values to specify each argument.
+// This allows for more flexibility as you can specify multiple possible
+// conversion characters for each argument.
+// ParsedFormat<char...> is a simplified alias for when the user only
+// needs to specify a single conversion character for each argument.
+//
+// Example:
+//   // Extended format supports multiple characters per argument:
+//   using MyFormat = ExtendedParsedFormat<Conv::d | Conv::x>;
+//   MyFormat GetFormat(bool use_hex) {
+//     if (use_hex) return MyFormat("foo %x bar");
+//     return MyFormat("foo %d bar");
+//   }
+//   // 'format' can be used with any value that supports 'd' and 'x',
+//   // like `int`.
+//   auto format = GetFormat(use_hex);
+//   value = StringF(format, i);
+//
+// This class also supports runtime format checking with the ::New() and
+// ::NewAllowIgnored() factory functions.
+// This is the only API that allows the user to pass a runtime specified format
+// string. These factory functions will return NULL if the format does not match
+// the conversions requested by the user.
+template <FormatConversionCharSet... C>
+class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
+ public:
+  explicit ExtendedParsedFormat(string_view format)
+#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+      __attribute__((
+          enable_if(str_format_internal::EnsureConstexpr(format),
+                    "Format string is not constexpr."),
+          enable_if(str_format_internal::ValidFormatImpl<C...>(format),
+                    "Format specified does not match the template arguments.")))
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+      : ExtendedParsedFormat(format, false) {
+  }
+
+  // ExtendedParsedFormat factory function.
+  // The user still has to specify the conversion characters, but they will not
+  // be checked at compile time. Instead, it will be checked at runtime.
+  // This delays the checking to runtime, but allows the user to pass
+  // dynamically sourced formats.
+  // It returns NULL if the format does not match the conversion characters.
+  // The user is responsible for checking the return value before using it.
+  //
+  // The 'New' variant will check that all the specified arguments are being
+  // consumed by the format and return NULL if any argument is being ignored.
+  // The 'NewAllowIgnored' variant will not verify this and will allow formats
+  // that ignore arguments.
+  static std::unique_ptr<ExtendedParsedFormat> New(string_view format) {
+    return New(format, false);
+  }
+  static std::unique_ptr<ExtendedParsedFormat> NewAllowIgnored(
+      string_view format) {
+    return New(format, true);
+  }
+
+ private:
+  static std::unique_ptr<ExtendedParsedFormat> New(string_view format,
+                                                   bool allow_ignored) {
+    std::unique_ptr<ExtendedParsedFormat> conv(
+        new ExtendedParsedFormat(format, allow_ignored));
+    if (conv->has_error()) return nullptr;
+    return conv;
+  }
+
+  ExtendedParsedFormat(string_view s, bool allow_ignored)
+      : ParsedFormatBase(s, allow_ignored, {C...}) {}
+};
+}  // namespace str_format_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_join_internal.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_join_internal.h
new file mode 100644
index 0000000..d97d503
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_join_internal.h
@@ -0,0 +1,317 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+// This file declares INTERNAL parts of the Join API that are inlined/templated
+// or otherwise need to be available at compile time. The main abstractions
+// defined in this file are:
+//
+//   - A handful of default Formatters
+//   - JoinAlgorithm() overloads
+//   - JoinRange() overloads
+//   - JoinTuple()
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
+// absl/strings/str_join.h
+//
+// IWYU pragma: private, include "absl/strings/str_join.h"
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+
+#include <cstring>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/strings/internal/ostringstream.h"
+#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/str_cat.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+//
+// Formatter objects
+//
+// The following are implementation classes for standard Formatter objects. The
+// factory functions that users will call to create and use these formatters are
+// defined and documented in strings/join.h.
+//
+
+// The default formatter. Converts alpha-numeric types to strings.
+struct AlphaNumFormatterImpl {
+  // This template is needed in order to support passing in a dereferenced
+  // vector<bool>::iterator
+  template <typename T>
+  void operator()(std::string* out, const T& t) const {
+    StrAppend(out, AlphaNum(t));
+  }
+
+  void operator()(std::string* out, const AlphaNum& t) const {
+    StrAppend(out, t);
+  }
+};
+
+// A type that's used to overload the JoinAlgorithm() function (defined below)
+// for ranges that do not require additional formatting (e.g., a range of
+// strings).
+
+struct NoFormatter : public AlphaNumFormatterImpl {};
+
+// Formats types to strings using the << operator.
+class StreamFormatterImpl {
+ public:
+  // The method isn't const because it mutates state. Making it const will
+  // render StreamFormatterImpl thread-hostile.
+  template <typename T>
+  void operator()(std::string* out, const T& t) {
+    // The stream is created lazily to avoid paying the relatively high cost
+    // of its construction when joining an empty range.
+    if (strm_) {
+      strm_->clear();  // clear the bad, fail and eof bits in case they were set
+      strm_->str(out);
+    } else {
+      strm_.reset(new strings_internal::OStringStream(out));
+    }
+    *strm_ << t;
+  }
+
+ private:
+  std::unique_ptr<strings_internal::OStringStream> strm_;
+};
+
+// Formats a std::pair<>. The 'first' member is formatted using f1_ and the
+// 'second' member is formatted using f2_. sep_ is the separator.
+template <typename F1, typename F2>
+class PairFormatterImpl {
+ public:
+  PairFormatterImpl(F1 f1, absl::string_view sep, F2 f2)
+      : f1_(std::move(f1)), sep_(sep), f2_(std::move(f2)) {}
+
+  template <typename T>
+  void operator()(std::string* out, const T& p) {
+    f1_(out, p.first);
+    out->append(sep_);
+    f2_(out, p.second);
+  }
+
+  template <typename T>
+  void operator()(std::string* out, const T& p) const {
+    f1_(out, p.first);
+    out->append(sep_);
+    f2_(out, p.second);
+  }
+
+ private:
+  F1 f1_;
+  std::string sep_;
+  F2 f2_;
+};
+
+// Wraps another formatter and dereferences the argument to operator() then
+// passes the dereferenced argument to the wrapped formatter. This can be
+// useful, for example, to join a std::vector<int*>.
+template <typename Formatter>
+class DereferenceFormatterImpl {
+ public:
+  DereferenceFormatterImpl() : f_() {}
+  explicit DereferenceFormatterImpl(Formatter&& f)
+      : f_(std::forward<Formatter>(f)) {}
+
+  template <typename T>
+  void operator()(std::string* out, const T& t) {
+    f_(out, *t);
+  }
+
+  template <typename T>
+  void operator()(std::string* out, const T& t) const {
+    f_(out, *t);
+  }
+
+ private:
+  Formatter f_;
+};
+
+// DefaultFormatter<T> is a traits class that selects a default Formatter to use
+// for the given type T. The ::Type member names the Formatter to use. This is
+// used by the strings::Join() functions that do NOT take a Formatter argument,
+// in which case a default Formatter must be chosen.
+//
+// AlphaNumFormatterImpl is the default in the base template, followed by
+// specializations for other types.
+template <typename ValueType>
+struct DefaultFormatter {
+  typedef AlphaNumFormatterImpl Type;
+};
+template <>
+struct DefaultFormatter<const char*> {
+  typedef AlphaNumFormatterImpl Type;
+};
+template <>
+struct DefaultFormatter<char*> {
+  typedef AlphaNumFormatterImpl Type;
+};
+template <>
+struct DefaultFormatter<std::string> {
+  typedef NoFormatter Type;
+};
+template <>
+struct DefaultFormatter<absl::string_view> {
+  typedef NoFormatter Type;
+};
+template <typename ValueType>
+struct DefaultFormatter<ValueType*> {
+  typedef DereferenceFormatterImpl<typename DefaultFormatter<ValueType>::Type>
+      Type;
+};
+
+template <typename ValueType>
+struct DefaultFormatter<std::unique_ptr<ValueType>>
+    : public DefaultFormatter<ValueType*> {};
+
+//
+// JoinAlgorithm() functions
+//
+
+// The main joining algorithm. This simply joins the elements in the given
+// iterator range, each separated by the given separator, into an output string,
+// and formats each element using the provided Formatter object.
+template <typename Iterator, typename Formatter>
+std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
+                          Formatter&& f) {
+  std::string result;
+  absl::string_view sep("");
+  for (Iterator it = start; it != end; ++it) {
+    result.append(sep.data(), sep.size());
+    f(&result, *it);
+    sep = s;
+  }
+  return result;
+}
+
+// A joining algorithm that's optimized for a forward iterator range of
+// string-like objects that do not need any additional formatting. This is to
+// optimize the common case of joining, say, a std::vector<string> or a
+// std::vector<absl::string_view>.
+//
+// This is an overload of the previous JoinAlgorithm() function. Here the
+// Formatter argument is of type NoFormatter. Since NoFormatter is an internal
+// type, this overload is only invoked when strings::Join() is called with a
+// range of string-like objects (e.g., std::string, absl::string_view), and an
+// explicit Formatter argument was NOT specified.
+//
+// The optimization is that the needed space will be reserved in the output
+// string to avoid the need to resize while appending. To do this, the iterator
+// range will be traversed twice: once to calculate the total needed size, and
+// then again to copy the elements and delimiters to the output string.
+template <typename Iterator,
+          typename = typename std::enable_if<std::is_convertible<
+              typename std::iterator_traits<Iterator>::iterator_category,
+              std::forward_iterator_tag>::value>::type>
+std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
+                          NoFormatter) {
+  std::string result;
+  if (start != end) {
+    // Sums size
+    auto&& start_value = *start;
+    size_t result_size = start_value.size();
+    for (Iterator it = start; ++it != end;) {
+      result_size += s.size();
+      result_size += (*it).size();
+    }
+
+    if (result_size > 0) {
+      STLStringResizeUninitialized(&result, result_size);
+
+      // Joins strings
+      char* result_buf = &*result.begin();
+
+      memcpy(result_buf, start_value.data(), start_value.size());
+      result_buf += start_value.size();
+      for (Iterator it = start; ++it != end;) {
+        memcpy(result_buf, s.data(), s.size());
+        result_buf += s.size();
+        auto&& value = *it;
+        memcpy(result_buf, value.data(), value.size());
+        result_buf += value.size();
+      }
+    }
+  }
+
+  return result;
+}
+
+// JoinTupleLoop implements a loop over the elements of a std::tuple, which
+// are heterogeneous. The primary template matches the tuple interior case. It
+// continues the iteration after appending a separator (for nonzero indices)
+// and formatting an element of the tuple. The specialization for the I=N case
+// matches the end-of-tuple, and terminates the iteration.
+template <size_t I, size_t N>
+struct JoinTupleLoop {
+  template <typename Tup, typename Formatter>
+  void operator()(std::string* out, const Tup& tup, absl::string_view sep,
+                  Formatter&& fmt) {
+    if (I > 0) out->append(sep.data(), sep.size());
+    fmt(out, std::get<I>(tup));
+    JoinTupleLoop<I + 1, N>()(out, tup, sep, fmt);
+  }
+};
+template <size_t N>
+struct JoinTupleLoop<N, N> {
+  template <typename Tup, typename Formatter>
+  void operator()(std::string*, const Tup&, absl::string_view, Formatter&&) {}
+};
+
+template <typename... T, typename Formatter>
+std::string JoinAlgorithm(const std::tuple<T...>& tup, absl::string_view sep,
+                          Formatter&& fmt) {
+  std::string result;
+  JoinTupleLoop<0, sizeof...(T)>()(&result, tup, sep, fmt);
+  return result;
+}
+
+template <typename Iterator>
+std::string JoinRange(Iterator first, Iterator last,
+                      absl::string_view separator) {
+  // No formatter was explicitly given, so a default must be chosen.
+  typedef typename std::iterator_traits<Iterator>::value_type ValueType;
+  typedef typename DefaultFormatter<ValueType>::Type Formatter;
+  return JoinAlgorithm(first, last, separator, Formatter());
+}
+
+template <typename Range, typename Formatter>
+std::string JoinRange(const Range& range, absl::string_view separator,
+                      Formatter&& fmt) {
+  using std::begin;
+  using std::end;
+  return JoinAlgorithm(begin(range), end(range), separator, fmt);
+}
+
+template <typename Range>
+std::string JoinRange(const Range& range, absl::string_view separator) {
+  using std::begin;
+  using std::end;
+  return JoinRange(begin(range), end(range), separator);
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_split_internal.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_split_internal.h
new file mode 100644
index 0000000..e766421
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_split_internal.h
@@ -0,0 +1,430 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+// This file declares INTERNAL parts of the Split API that are inline/templated
+// or otherwise need to be available at compile time. The main abstractions
+// defined in here are
+//
+//   - ConvertibleToStringView
+//   - SplitIterator<>
+//   - Splitter<>
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
+// absl/strings/str_split.h.
+//
+// IWYU pragma: private, include "absl/strings/str_split.h"
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+
+#include <array>
+#include <initializer_list>
+#include <iterator>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+
+#ifdef _GLIBCXX_DEBUG
+#include "absl/strings/internal/stl_type_traits.h"
+#endif  // _GLIBCXX_DEBUG
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// This class is implicitly constructible from everything that absl::string_view
+// is implicitly constructible from, except for rvalue strings.  This means it
+// can be used as a function parameter in places where passing a temporary
+// string might cause memory lifetime issues.
+class ConvertibleToStringView {
+ public:
+  ConvertibleToStringView(const char* s)  // NOLINT(runtime/explicit)
+      : value_(s) {}
+  ConvertibleToStringView(char* s) : value_(s) {}  // NOLINT(runtime/explicit)
+  ConvertibleToStringView(absl::string_view s)     // NOLINT(runtime/explicit)
+      : value_(s) {}
+  ConvertibleToStringView(const std::string& s)  // NOLINT(runtime/explicit)
+      : value_(s) {}
+
+  // Disable conversion from rvalue strings.
+  ConvertibleToStringView(std::string&& s) = delete;
+  ConvertibleToStringView(const std::string&& s) = delete;
+
+  absl::string_view value() const { return value_; }
+
+ private:
+  absl::string_view value_;
+};
+
+// An iterator that enumerates the parts of a string from a Splitter. The text
+// to be split, the Delimiter, and the Predicate are all taken from the given
+// Splitter object. Iterators may only be compared if they refer to the same
+// Splitter instance.
+//
+// This class is NOT part of the public splitting API.
+template <typename Splitter>
+class SplitIterator {
+ public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = absl::string_view;
+  using difference_type = ptrdiff_t;
+  using pointer = const value_type*;
+  using reference = const value_type&;
+
+  enum State { kInitState, kLastState, kEndState };
+  SplitIterator(State state, const Splitter* splitter)
+      : pos_(0),
+        state_(state),
+        splitter_(splitter),
+        delimiter_(splitter->delimiter()),
+        predicate_(splitter->predicate()) {
+    // Hack to maintain backward compatibility. This one block makes it so an
+    // empty absl::string_view whose .data() happens to be nullptr behaves
+    // *differently* from an otherwise empty absl::string_view whose .data() is
+    // not nullptr. This is an undesirable difference in general, but this
+    // behavior is maintained to avoid breaking existing code that happens to
+    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
+    // difference in behavior is as follows:
+    //   Split(absl::string_view(""), '-');  // {""}
+    //   Split(absl::string_view(), '-');    // {}
+    if (splitter_->text().data() == nullptr) {
+      state_ = kEndState;
+      pos_ = splitter_->text().size();
+      return;
+    }
+
+    if (state_ == kEndState) {
+      pos_ = splitter_->text().size();
+    } else {
+      ++(*this);
+    }
+  }
+
+  bool at_end() const { return state_ == kEndState; }
+
+  reference operator*() const { return curr_; }
+  pointer operator->() const { return &curr_; }
+
+  SplitIterator& operator++() {
+    do {
+      if (state_ == kLastState) {
+        state_ = kEndState;
+        return *this;
+      }
+      const absl::string_view text = splitter_->text();
+      const absl::string_view d = delimiter_.Find(text, pos_);
+      if (d.data() == text.data() + text.size()) state_ = kLastState;
+      curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
+      pos_ += curr_.size() + d.size();
+    } while (!predicate_(curr_));
+    return *this;
+  }
+
+  SplitIterator operator++(int) {
+    SplitIterator old(*this);
+    ++(*this);
+    return old;
+  }
+
+  friend bool operator==(const SplitIterator& a, const SplitIterator& b) {
+    return a.state_ == b.state_ && a.pos_ == b.pos_;
+  }
+
+  friend bool operator!=(const SplitIterator& a, const SplitIterator& b) {
+    return !(a == b);
+  }
+
+ private:
+  size_t pos_;
+  State state_;
+  absl::string_view curr_;
+  const Splitter* splitter_;
+  typename Splitter::DelimiterType delimiter_;
+  typename Splitter::PredicateType predicate_;
+};
+
+// HasMappedType<T>::value is true iff there exists a type T::mapped_type.
+template <typename T, typename = void>
+struct HasMappedType : std::false_type {};
+template <typename T>
+struct HasMappedType<T, absl::void_t<typename T::mapped_type>>
+    : std::true_type {};
+
+// HasValueType<T>::value is true iff there exists a type T::value_type.
+template <typename T, typename = void>
+struct HasValueType : std::false_type {};
+template <typename T>
+struct HasValueType<T, absl::void_t<typename T::value_type>> : std::true_type {
+};
+
+// HasConstIterator<T>::value is true iff there exists a type T::const_iterator.
+template <typename T, typename = void>
+struct HasConstIterator : std::false_type {};
+template <typename T>
+struct HasConstIterator<T, absl::void_t<typename T::const_iterator>>
+    : std::true_type {};
+
+// HasEmplace<T>::value is true iff there exists a method T::emplace().
+template <typename T, typename = void>
+struct HasEmplace : std::false_type {};
+template <typename T>
+struct HasEmplace<T, absl::void_t<decltype(std::declval<T>().emplace())>>
+    : std::true_type {};
+
+// IsInitializerList<T>::value is true iff T is an std::initializer_list. More
+// details below in Splitter<> where this is used.
+std::false_type IsInitializerListDispatch(...);  // default: No
+template <typename T>
+std::true_type IsInitializerListDispatch(std::initializer_list<T>*);
+template <typename T>
+struct IsInitializerList
+    : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr))) {};
+
+// A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition
+// is true for type 'C'.
+//
+// Restricts conversion to container-like types (by testing for the presence of
+// a const_iterator member type) and also to disable conversion to an
+// std::initializer_list (which also has a const_iterator). Otherwise, code
+// compiled in C++11 will get an error due to ambiguous conversion paths (in
+// C++11 std::vector<T>::operator= is overloaded to take either a std::vector<T>
+// or an std::initializer_list<T>).
+
+template <typename C, bool has_value_type, bool has_mapped_type>
+struct SplitterIsConvertibleToImpl : std::false_type {};
+
+template <typename C>
+struct SplitterIsConvertibleToImpl<C, true, false>
+    : std::is_constructible<typename C::value_type, absl::string_view> {};
+
+template <typename C>
+struct SplitterIsConvertibleToImpl<C, true, true>
+    : absl::conjunction<
+          std::is_constructible<typename C::key_type, absl::string_view>,
+          std::is_constructible<typename C::mapped_type, absl::string_view>> {};
+
+template <typename C>
+struct SplitterIsConvertibleTo
+    : SplitterIsConvertibleToImpl<
+          C,
+#ifdef _GLIBCXX_DEBUG
+          !IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value &&
+#endif  // _GLIBCXX_DEBUG
+              !IsInitializerList<
+                  typename std::remove_reference<C>::type>::value &&
+              HasValueType<C>::value && HasConstIterator<C>::value,
+          HasMappedType<C>::value> {
+};
+
+// This class implements the range that is returned by absl::StrSplit(). This
+// class has templated conversion operators that allow it to be implicitly
+// converted to a variety of types that the caller may have specified on the
+// left-hand side of an assignment.
+//
+// The main interface for interacting with this class is through its implicit
+// conversion operators. However, this class may also be used like a container
+// in that it has .begin() and .end() member functions. It may also be used
+// within a range-for loop.
+//
+// Output containers can be collections of any type that is constructible from
+// an absl::string_view.
+//
+// An Predicate functor may be supplied. This predicate will be used to filter
+// the split strings: only strings for which the predicate returns true will be
+// kept. A Predicate object is any unary functor that takes an absl::string_view
+// and returns bool.
+//
+// The StringType parameter can be either string_view or string, depending on
+// whether the Splitter refers to a string stored elsewhere, or if the string
+// resides inside the Splitter itself.
+template <typename Delimiter, typename Predicate, typename StringType>
+class Splitter {
+ public:
+  using DelimiterType = Delimiter;
+  using PredicateType = Predicate;
+  using const_iterator = strings_internal::SplitIterator<Splitter>;
+  using value_type = typename std::iterator_traits<const_iterator>::value_type;
+
+  Splitter(StringType input_text, Delimiter d, Predicate p)
+      : text_(std::move(input_text)),
+        delimiter_(std::move(d)),
+        predicate_(std::move(p)) {}
+
+  absl::string_view text() const { return text_; }
+  const Delimiter& delimiter() const { return delimiter_; }
+  const Predicate& predicate() const { return predicate_; }
+
+  // Range functions that iterate the split substrings as absl::string_view
+  // objects. These methods enable a Splitter to be used in a range-based for
+  // loop.
+  const_iterator begin() const { return {const_iterator::kInitState, this}; }
+  const_iterator end() const { return {const_iterator::kEndState, this}; }
+
+  // An implicit conversion operator that is restricted to only those containers
+  // that the splitter is convertible to.
+  template <typename Container,
+            typename = typename std::enable_if<
+                SplitterIsConvertibleTo<Container>::value>::type>
+  operator Container() const {  // NOLINT(runtime/explicit)
+    return ConvertToContainer<Container, typename Container::value_type,
+                              HasMappedType<Container>::value>()(*this);
+  }
+
+  // Returns a pair with its .first and .second members set to the first two
+  // strings returned by the begin() iterator. Either/both of .first and .second
+  // will be constructed with empty strings if the iterator doesn't have a
+  // corresponding value.
+  template <typename First, typename Second>
+  operator std::pair<First, Second>() const {  // NOLINT(runtime/explicit)
+    absl::string_view first, second;
+    auto it = begin();
+    if (it != end()) {
+      first = *it;
+      if (++it != end()) {
+        second = *it;
+      }
+    }
+    return {First(first), Second(second)};
+  }
+
+ private:
+  // ConvertToContainer is a functor converting a Splitter to the requested
+  // Container of ValueType. It is specialized below to optimize splitting to
+  // certain combinations of Container and ValueType.
+  //
+  // This base template handles the generic case of storing the split results in
+  // the requested non-map-like container and converting the split substrings to
+  // the requested type.
+  template <typename Container, typename ValueType, bool is_map = false>
+  struct ConvertToContainer {
+    Container operator()(const Splitter& splitter) const {
+      Container c;
+      auto it = std::inserter(c, c.end());
+      for (const auto& sp : splitter) {
+        *it++ = ValueType(sp);
+      }
+      return c;
+    }
+  };
+
+  // Partial specialization for a std::vector<absl::string_view>.
+  //
+  // Optimized for the common case of splitting to a
+  // std::vector<absl::string_view>. In this case we first split the results to
+  // a small array of absl::string_view on the stack, to reduce reallocations.
+  template <typename A>
+  struct ConvertToContainer<std::vector<absl::string_view, A>,
+                            absl::string_view, false> {
+    std::vector<absl::string_view, A> operator()(
+        const Splitter& splitter) const {
+      struct raw_view {
+        const char* data;
+        size_t size;
+        operator absl::string_view() const {  // NOLINT(runtime/explicit)
+          return {data, size};
+        }
+      };
+      std::vector<absl::string_view, A> v;
+      std::array<raw_view, 16> ar;
+      for (auto it = splitter.begin(); !it.at_end();) {
+        size_t index = 0;
+        do {
+          ar[index].data = it->data();
+          ar[index].size = it->size();
+          ++it;
+        } while (++index != ar.size() && !it.at_end());
+        v.insert(v.end(), ar.begin(), ar.begin() + index);
+      }
+      return v;
+    }
+  };
+
+  // Partial specialization for a std::vector<std::string>.
+  //
+  // Optimized for the common case of splitting to a std::vector<std::string>.
+  // In this case we first split the results to a std::vector<absl::string_view>
+  // so the returned std::vector<std::string> can have space reserved to avoid
+  // std::string moves.
+  template <typename A>
+  struct ConvertToContainer<std::vector<std::string, A>, std::string, false> {
+    std::vector<std::string, A> operator()(const Splitter& splitter) const {
+      const std::vector<absl::string_view> v = splitter;
+      return std::vector<std::string, A>(v.begin(), v.end());
+    }
+  };
+
+  // Partial specialization for containers of pairs (e.g., maps).
+  //
+  // The algorithm is to insert a new pair into the map for each even-numbered
+  // item, with the even-numbered item as the key with a default-constructed
+  // value. Each odd-numbered item will then be assigned to the last pair's
+  // value.
+  template <typename Container, typename First, typename Second>
+  struct ConvertToContainer<Container, std::pair<const First, Second>, true> {
+    using iterator = typename Container::iterator;
+
+    Container operator()(const Splitter& splitter) const {
+      Container m;
+      iterator it;
+      bool insert = true;
+      for (const absl::string_view sv : splitter) {
+        if (insert) {
+          it = InsertOrEmplace(&m, sv);
+        } else {
+          it->second = Second(sv);
+        }
+        insert = !insert;
+      }
+      return m;
+    }
+
+    // Inserts the key and an empty value into the map, returning an iterator to
+    // the inserted item. We use emplace() if available, otherwise insert().
+    template <typename M>
+    static absl::enable_if_t<HasEmplace<M>::value, iterator> InsertOrEmplace(
+        M* m, absl::string_view key) {
+      // Use piecewise_construct to support old versions of gcc in which pair
+      // constructor can't otherwise construct string from string_view.
+      return ToIter(m->emplace(std::piecewise_construct, std::make_tuple(key),
+                               std::tuple<>()));
+    }
+    template <typename M>
+    static absl::enable_if_t<!HasEmplace<M>::value, iterator> InsertOrEmplace(
+        M* m, absl::string_view key) {
+      return ToIter(m->insert(std::make_pair(First(key), Second(""))));
+    }
+
+    static iterator ToIter(std::pair<iterator, bool> pair) {
+      return pair.first;
+    }
+    static iterator ToIter(iterator iter) { return iter; }
+  };
+
+  StringType text_;
+  Delimiter delimiter_;
+  Predicate predicate_;
+};
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/string_constant.h b/CAPI/cpp/grpc/include/absl/strings/internal/string_constant.h
new file mode 100644
index 0000000..f68b17d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/string_constant.h
@@ -0,0 +1,72 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
+#define ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
+
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// StringConstant<T> represents a compile time string constant.
+// It can be accessed via its `absl::string_view value` static member.
+// It is guaranteed that the `string_view` returned has constant `.data()`,
+// constant `.size()` and constant `value[i]` for all `0 <= i < .size()`
+//
+// The `T` is an opaque type. It is guaranteed that different string constants
+// will have different values of `T`. This allows users to associate the string
+// constant with other static state at compile time.
+//
+// Instances should be made using the `MakeStringConstant()` factory function
+// below.
+template <typename T>
+struct StringConstant {
+ private:
+  static constexpr bool TryConstexprEval(absl::string_view view) {
+    return view.empty() || 2 * view[0] != 1;
+  }
+
+ public:
+  static constexpr absl::string_view value = T{}();
+  constexpr absl::string_view operator()() const { return value; }
+
+  // Check to be sure `view` points to constant data.
+  // Otherwise, it can't be constant evaluated.
+  static_assert(TryConstexprEval(value),
+                "The input string_view must point to constant data.");
+};
+
+#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+template <typename T>
+constexpr absl::string_view StringConstant<T>::value;
+#endif
+
+// Factory function for `StringConstant` instances.
+// It supports callables that have a constexpr default constructor and a
+// constexpr operator().
+// It must return an `absl::string_view` or `const char*` pointing to constant
+// data. This is validated at compile time.
+template <typename T>
+constexpr StringConstant<T> MakeStringConstant(T) {
+  return {};
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/utf8.h b/CAPI/cpp/grpc/include/absl/strings/internal/utf8.h
new file mode 100644
index 0000000..32fb109
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/utf8.h
@@ -0,0 +1,50 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// UTF8 utilities, implemented to reduce dependencies.
+
+#ifndef ABSL_STRINGS_INTERNAL_UTF8_H_
+#define ABSL_STRINGS_INTERNAL_UTF8_H_
+
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
+// out the UTF-8 encoding into buffer, and returns the number of chars
+// it wrote.
+//
+// As described in https://tools.ietf.org/html/rfc3629#section-3 , the encodings
+// are:
+//    00 -     7F : 0xxxxxxx
+//    80 -    7FF : 110xxxxx 10xxxxxx
+//   800 -   FFFF : 1110xxxx 10xxxxxx 10xxxxxx
+// 10000 - 10FFFF : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+//
+// Values greater than 0x10FFFF are not supported and may or may not write
+// characters into buffer, however never will more than kMaxEncodedUTF8Size
+// bytes be written, regardless of the value of utf8_char.
+enum { kMaxEncodedUTF8Size = 4 };
+size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_UTF8_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/match.h b/CAPI/cpp/grpc/include/absl/strings/match.h
new file mode 100644
index 0000000..038cbb3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/match.h
@@ -0,0 +1,100 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: match.h
+// -----------------------------------------------------------------------------
+//
+// This file contains simple utilities for performing string matching checks.
+// All of these function parameters are specified as `absl::string_view`,
+// meaning that these functions can accept `std::string`, `absl::string_view` or
+// NUL-terminated C-style strings.
+//
+// Examples:
+//   std::string s = "foo";
+//   absl::string_view sv = "f";
+//   assert(absl::StrContains(s, sv));
+//
+// Note: The order of parameters in these functions is designed to mimic the
+// order an equivalent member function would exhibit;
+// e.g. `s.Contains(x)` ==> `absl::StrContains(s, x).
+#ifndef ABSL_STRINGS_MATCH_H_
+#define ABSL_STRINGS_MATCH_H_
+
+#include <cstring>
+
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// StrContains()
+//
+// Returns whether a given string `haystack` contains the substring `needle`.
+inline bool StrContains(absl::string_view haystack,
+                        absl::string_view needle) noexcept {
+  return haystack.find(needle, 0) != haystack.npos;
+}
+
+inline bool StrContains(absl::string_view haystack, char needle) noexcept {
+  return haystack.find(needle) != haystack.npos;
+}
+
+// StartsWith()
+//
+// Returns whether a given string `text` begins with `prefix`.
+inline bool StartsWith(absl::string_view text,
+                       absl::string_view prefix) noexcept {
+  return prefix.empty() ||
+         (text.size() >= prefix.size() &&
+          memcmp(text.data(), prefix.data(), prefix.size()) == 0);
+}
+
+// EndsWith()
+//
+// Returns whether a given string `text` ends with `suffix`.
+inline bool EndsWith(absl::string_view text,
+                     absl::string_view suffix) noexcept {
+  return suffix.empty() ||
+         (text.size() >= suffix.size() &&
+          memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
+                 suffix.size()) == 0);
+}
+
+// EqualsIgnoreCase()
+//
+// Returns whether given ASCII strings `piece1` and `piece2` are equal, ignoring
+// case in the comparison.
+bool EqualsIgnoreCase(absl::string_view piece1,
+                      absl::string_view piece2) noexcept;
+
+// StartsWithIgnoreCase()
+//
+// Returns whether a given ASCII string `text` starts with `prefix`,
+// ignoring case in the comparison.
+bool StartsWithIgnoreCase(absl::string_view text,
+                          absl::string_view prefix) noexcept;
+
+// EndsWithIgnoreCase()
+//
+// Returns whether a given ASCII string `text` ends with `suffix`, ignoring
+// case in the comparison.
+bool EndsWithIgnoreCase(absl::string_view text,
+                        absl::string_view suffix) noexcept;
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_MATCH_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/numbers.h b/CAPI/cpp/grpc/include/absl/strings/numbers.h
new file mode 100644
index 0000000..86c84ed
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/numbers.h
@@ -0,0 +1,303 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: numbers.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions for converting strings to numbers. For
+// converting numbers to strings, use `StrCat()` or `StrAppend()` in str_cat.h,
+// which automatically detect and convert most number values appropriately.
+
+#ifndef ABSL_STRINGS_NUMBERS_H_
+#define ABSL_STRINGS_NUMBERS_H_
+
+#ifdef __SSSE3__
+#include <tmmintrin.h>
+#endif
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <limits>
+#include <string>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/endian.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/numeric/bits.h"
+#include "absl/numeric/int128.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// SimpleAtoi()
+//
+// Converts the given string (optionally followed or preceded by ASCII
+// whitespace) into an integer value, returning `true` if successful. The string
+// must reflect a base-10 integer whose value falls within the range of the
+// integer type (optionally preceded by a `+` or `-`). If any errors are
+// encountered, this function returns `false`, leaving `out` in an unspecified
+// state.
+template <typename int_type>
+ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out);
+
+// SimpleAtof()
+//
+// Converts the given string (optionally followed or preceded by ASCII
+// whitespace) into a float, which may be rounded on overflow or underflow,
+// returning `true` if successful.
+// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
+// allowed formats for `str`, except SimpleAtof() is locale-independent and will
+// always use the "C" locale. If any errors are encountered, this function
+// returns `false`, leaving `out` in an unspecified state.
+ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str, float* out);
+
+// SimpleAtod()
+//
+// Converts the given string (optionally followed or preceded by ASCII
+// whitespace) into a double, which may be rounded on overflow or underflow,
+// returning `true` if successful.
+// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
+// allowed formats for `str`, except SimpleAtod is locale-independent and will
+// always use the "C" locale. If any errors are encountered, this function
+// returns `false`, leaving `out` in an unspecified state.
+ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str, double* out);
+
+// SimpleAtob()
+//
+// Converts the given string into a boolean, returning `true` if successful.
+// The following case-insensitive strings are interpreted as boolean `true`:
+// "true", "t", "yes", "y", "1". The following case-insensitive strings
+// are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any
+// errors are encountered, this function returns `false`, leaving `out` in an
+// unspecified state.
+ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str, bool* out);
+
+// SimpleHexAtoi()
+//
+// Converts a hexadecimal string (optionally followed or preceded by ASCII
+// whitespace) to an integer, returning `true` if successful. Only valid base-16
+// hexadecimal integers whose value falls within the range of the integer type
+// (optionally preceded by a `+` or `-`) can be converted. A valid hexadecimal
+// value may include both upper and lowercase character symbols, and may
+// optionally include a leading "0x" (or "0X") number prefix, which is ignored
+// by this function. If any errors are encountered, this function returns
+// `false`, leaving `out` in an unspecified state.
+template <typename int_type>
+ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str, int_type* out);
+
+// Overloads of SimpleHexAtoi() for 128 bit integers.
+ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
+                                               absl::int128* out);
+ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
+                                               absl::uint128* out);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// End of public API.  Implementation details follow.
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace numbers_internal {
+
+// Digit conversion.
+ABSL_DLL extern const char kHexChar[17];  // 0123456789abcdef
+ABSL_DLL extern const char
+    kHexTable[513];  // 000102030405060708090a0b0c0d0e0f1011...
+ABSL_DLL extern const char
+    two_ASCII_digits[100][2];  // 00, 01, 02, 03...
+
+// Writes a two-character representation of 'i' to 'buf'. 'i' must be in the
+// range 0 <= i < 100, and buf must have space for two characters. Example:
+//   char buf[2];
+//   PutTwoDigits(42, buf);
+//   // buf[0] == '4'
+//   // buf[1] == '2'
+inline void PutTwoDigits(size_t i, char* buf) {
+  assert(i < 100);
+  memcpy(buf, two_ASCII_digits[i], 2);
+}
+
+// safe_strto?() functions for implementing SimpleAtoi()
+
+bool safe_strto32_base(absl::string_view text, int32_t* value, int base);
+bool safe_strto64_base(absl::string_view text, int64_t* value, int base);
+bool safe_strto128_base(absl::string_view text, absl::int128* value,
+                         int base);
+bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base);
+bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base);
+bool safe_strtou128_base(absl::string_view text, absl::uint128* value,
+                         int base);
+
+static const int kFastToBufferSize = 32;
+static const int kSixDigitsToBufferSize = 16;
+
+// Helper function for fast formatting of floating-point values.
+// The result is the same as printf's "%g", a.k.a. "%.6g"; that is, six
+// significant digits are returned, trailing zeros are removed, and numbers
+// outside the range 0.0001-999999 are output using scientific notation
+// (1.23456e+06). This routine is heavily optimized.
+// Required buffer size is `kSixDigitsToBufferSize`.
+size_t SixDigitsToBuffer(double d, char* buffer);
+
+// These functions are intended for speed. All functions take an output buffer
+// as an argument and return a pointer to the last byte they wrote, which is the
+// terminating '\0'. At most `kFastToBufferSize` bytes are written.
+char* FastIntToBuffer(int32_t, char*);
+char* FastIntToBuffer(uint32_t, char*);
+char* FastIntToBuffer(int64_t, char*);
+char* FastIntToBuffer(uint64_t, char*);
+
+// For enums and integer types that are not an exact match for the types above,
+// use templates to call the appropriate one of the four overloads above.
+template <typename int_type>
+char* FastIntToBuffer(int_type i, char* buffer) {
+  static_assert(sizeof(i) <= 64 / 8,
+                "FastIntToBuffer works only with 64-bit-or-less integers.");
+  // TODO(jorg): This signed-ness check is used because it works correctly
+  // with enums, and it also serves to check that int_type is not a pointer.
+  // If one day something like std::is_signed<enum E> works, switch to it.
+  // These conditions are constexpr bools to suppress MSVC warning C4127.
+  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
+  constexpr bool kUse64Bit = sizeof(i) > 32 / 8;
+  if (kIsSigned) {
+    if (kUse64Bit) {
+      return FastIntToBuffer(static_cast<int64_t>(i), buffer);
+    } else {
+      return FastIntToBuffer(static_cast<int32_t>(i), buffer);
+    }
+  } else {
+    if (kUse64Bit) {
+      return FastIntToBuffer(static_cast<uint64_t>(i), buffer);
+    } else {
+      return FastIntToBuffer(static_cast<uint32_t>(i), buffer);
+    }
+  }
+}
+
+// Implementation of SimpleAtoi, generalized to support arbitrary base (used
+// with base different from 10 elsewhere in Abseil implementation).
+template <typename int_type>
+ABSL_MUST_USE_RESULT bool safe_strtoi_base(absl::string_view s, int_type* out,
+                                           int base) {
+  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
+                "SimpleAtoi works only with 32-bit or 64-bit integers.");
+  static_assert(!std::is_floating_point<int_type>::value,
+                "Use SimpleAtof or SimpleAtod instead.");
+  bool parsed;
+  // TODO(jorg): This signed-ness check is used because it works correctly
+  // with enums, and it also serves to check that int_type is not a pointer.
+  // If one day something like std::is_signed<enum E> works, switch to it.
+  // These conditions are constexpr bools to suppress MSVC warning C4127.
+  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
+  constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
+  if (kIsSigned) {
+    if (kUse64Bit) {
+      int64_t val;
+      parsed = numbers_internal::safe_strto64_base(s, &val, base);
+      *out = static_cast<int_type>(val);
+    } else {
+      int32_t val;
+      parsed = numbers_internal::safe_strto32_base(s, &val, base);
+      *out = static_cast<int_type>(val);
+    }
+  } else {
+    if (kUse64Bit) {
+      uint64_t val;
+      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
+      *out = static_cast<int_type>(val);
+    } else {
+      uint32_t val;
+      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
+      *out = static_cast<int_type>(val);
+    }
+  }
+  return parsed;
+}
+
+// FastHexToBufferZeroPad16()
+//
+// Outputs `val` into `out` as if by `snprintf(out, 17, "%016x", val)` but
+// without the terminating null character. Thus `out` must be of length >= 16.
+// Returns the number of non-pad digits of the output (it can never be zero
+// since 0 has one digit).
+inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) {
+#ifdef ABSL_INTERNAL_HAVE_SSSE3
+  uint64_t be = absl::big_endian::FromHost64(val);
+  const auto kNibbleMask = _mm_set1_epi8(0xf);
+  const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7',
+                                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
+  auto v = _mm_loadl_epi64(reinterpret_cast<__m128i*>(&be));  // load lo dword
+  auto v4 = _mm_srli_epi64(v, 4);                            // shift 4 right
+  auto il = _mm_unpacklo_epi8(v4, v);                        // interleave bytes
+  auto m = _mm_and_si128(il, kNibbleMask);                   // mask out nibbles
+  auto hexchars = _mm_shuffle_epi8(kHexDigits, m);           // hex chars
+  _mm_storeu_si128(reinterpret_cast<__m128i*>(out), hexchars);
+#else
+  for (int i = 0; i < 8; ++i) {
+    auto byte = (val >> (56 - 8 * i)) & 0xFF;
+    auto* hex = &absl::numbers_internal::kHexTable[byte * 2];
+    std::memcpy(out + 2 * i, hex, 2);
+  }
+#endif
+  // | 0x1 so that even 0 has 1 digit.
+  return 16 - static_cast<size_t>(countl_zero(val | 0x1) / 4);
+}
+
+}  // namespace numbers_internal
+
+template <typename int_type>
+ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out) {
+  return numbers_internal::safe_strtoi_base(str, out, 10);
+}
+
+ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
+                                            absl::int128* out) {
+  return numbers_internal::safe_strto128_base(str, out, 10);
+}
+
+ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
+                                            absl::uint128* out) {
+  return numbers_internal::safe_strtou128_base(str, out, 10);
+}
+
+template <typename int_type>
+ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str, int_type* out) {
+  return numbers_internal::safe_strtoi_base(str, out, 16);
+}
+
+ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
+                                               absl::int128* out) {
+  return numbers_internal::safe_strto128_base(str, out, 16);
+}
+
+ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
+                                               absl::uint128* out) {
+  return numbers_internal::safe_strtou128_base(str, out, 16);
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_NUMBERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_cat.h b/CAPI/cpp/grpc/include/absl/strings/str_cat.h
new file mode 100644
index 0000000..a94bc5d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/str_cat.h
@@ -0,0 +1,415 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_cat.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions for efficiently concatenating and appending
+// strings: `StrCat()` and `StrAppend()`. Most of the work within these routines
+// is actually handled through use of a special AlphaNum type, which was
+// designed to be used as a parameter type that efficiently manages conversion
+// to strings and avoids copies in the above operations.
+//
+// Any routine accepting either a string or a number may accept `AlphaNum`.
+// The basic idea is that by accepting a `const AlphaNum &` as an argument
+// to your function, your callers will automagically convert bools, integers,
+// and floating point values to strings for you.
+//
+// NOTE: Use of `AlphaNum` outside of the //absl/strings package is unsupported
+// except for the specific case of function parameters of type `AlphaNum` or
+// `const AlphaNum &`. In particular, instantiating `AlphaNum` directly as a
+// stack variable is not supported.
+//
+// Conversion from 8-bit values is not accepted because, if it were, then an
+// attempt to pass ':' instead of ":" might result in a 58 ending up in your
+// result.
+//
+// Bools convert to "0" or "1". Pointers to types other than `char *` are not
+// valid inputs. No output is generated for null `char *` pointers.
+//
+// Floating point numbers are formatted with six-digit precision, which is
+// the default for "std::cout <<" or printf "%g" (the same as "%.6g").
+//
+// You can convert to hexadecimal output rather than decimal output using the
+// `Hex` type contained here. To do so, pass `Hex(my_int)` as a parameter to
+// `StrCat()` or `StrAppend()`. You may specify a minimum hex field width using
+// a `PadSpec` enum.
+//
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_STRINGS_STR_CAT_H_
+#define ABSL_STRINGS_STR_CAT_H_
+
+#include <array>
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "absl/base/port.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace strings_internal {
+// AlphaNumBuffer allows a way to pass a string to StrCat without having to do
+// memory allocation.  It is simply a pair of a fixed-size character array, and
+// a size.  Please don't use outside of absl, yet.
+template <size_t max_size>
+struct AlphaNumBuffer {
+  std::array<char, max_size> data;
+  size_t size;
+};
+
+}  // namespace strings_internal
+
+// Enum that specifies the number of significant digits to return in a `Hex` or
+// `Dec` conversion and fill character to use. A `kZeroPad2` value, for example,
+// would produce hexadecimal strings such as "0a","0f" and a 'kSpacePad5' value
+// would produce hexadecimal strings such as "    a","    f".
+enum PadSpec : uint8_t {
+  kNoPad = 1,
+  kZeroPad2,
+  kZeroPad3,
+  kZeroPad4,
+  kZeroPad5,
+  kZeroPad6,
+  kZeroPad7,
+  kZeroPad8,
+  kZeroPad9,
+  kZeroPad10,
+  kZeroPad11,
+  kZeroPad12,
+  kZeroPad13,
+  kZeroPad14,
+  kZeroPad15,
+  kZeroPad16,
+  kZeroPad17,
+  kZeroPad18,
+  kZeroPad19,
+  kZeroPad20,
+
+  kSpacePad2 = kZeroPad2 + 64,
+  kSpacePad3,
+  kSpacePad4,
+  kSpacePad5,
+  kSpacePad6,
+  kSpacePad7,
+  kSpacePad8,
+  kSpacePad9,
+  kSpacePad10,
+  kSpacePad11,
+  kSpacePad12,
+  kSpacePad13,
+  kSpacePad14,
+  kSpacePad15,
+  kSpacePad16,
+  kSpacePad17,
+  kSpacePad18,
+  kSpacePad19,
+  kSpacePad20,
+};
+
+// -----------------------------------------------------------------------------
+// Hex
+// -----------------------------------------------------------------------------
+//
+// `Hex` stores a set of hexadecimal string conversion parameters for use
+// within `AlphaNum` string conversions.
+struct Hex {
+  uint64_t value;
+  uint8_t width;
+  char fill;
+
+  template <typename Int>
+  explicit Hex(
+      Int v, PadSpec spec = absl::kNoPad,
+      typename std::enable_if<sizeof(Int) == 1 &&
+                              !std::is_pointer<Int>::value>::type* = nullptr)
+      : Hex(spec, static_cast<uint8_t>(v)) {}
+  template <typename Int>
+  explicit Hex(
+      Int v, PadSpec spec = absl::kNoPad,
+      typename std::enable_if<sizeof(Int) == 2 &&
+                              !std::is_pointer<Int>::value>::type* = nullptr)
+      : Hex(spec, static_cast<uint16_t>(v)) {}
+  template <typename Int>
+  explicit Hex(
+      Int v, PadSpec spec = absl::kNoPad,
+      typename std::enable_if<sizeof(Int) == 4 &&
+                              !std::is_pointer<Int>::value>::type* = nullptr)
+      : Hex(spec, static_cast<uint32_t>(v)) {}
+  template <typename Int>
+  explicit Hex(
+      Int v, PadSpec spec = absl::kNoPad,
+      typename std::enable_if<sizeof(Int) == 8 &&
+                              !std::is_pointer<Int>::value>::type* = nullptr)
+      : Hex(spec, static_cast<uint64_t>(v)) {}
+  template <typename Pointee>
+  explicit Hex(Pointee* v, PadSpec spec = absl::kNoPad)
+      : Hex(spec, reinterpret_cast<uintptr_t>(v)) {}
+
+ private:
+  Hex(PadSpec spec, uint64_t v)
+      : value(v),
+        width(spec == absl::kNoPad
+                  ? 1
+                  : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2
+                                             : spec - absl::kZeroPad2 + 2),
+        fill(spec >= absl::kSpacePad2 ? ' ' : '0') {}
+};
+
+// -----------------------------------------------------------------------------
+// Dec
+// -----------------------------------------------------------------------------
+//
+// `Dec` stores a set of decimal string conversion parameters for use
+// within `AlphaNum` string conversions.  Dec is slower than the default
+// integer conversion, so use it only if you need padding.
+struct Dec {
+  uint64_t value;
+  uint8_t width;
+  char fill;
+  bool neg;
+
+  template <typename Int>
+  explicit Dec(Int v, PadSpec spec = absl::kNoPad,
+               typename std::enable_if<(sizeof(Int) <= 8)>::type* = nullptr)
+      : value(v >= 0 ? static_cast<uint64_t>(v)
+                     : uint64_t{0} - static_cast<uint64_t>(v)),
+        width(spec == absl::kNoPad
+                  ? 1
+                  : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2
+                                             : spec - absl::kZeroPad2 + 2),
+        fill(spec >= absl::kSpacePad2 ? ' ' : '0'),
+        neg(v < 0) {}
+};
+
+// -----------------------------------------------------------------------------
+// AlphaNum
+// -----------------------------------------------------------------------------
+//
+// The `AlphaNum` class acts as the main parameter type for `StrCat()` and
+// `StrAppend()`, providing efficient conversion of numeric, boolean, and
+// hexadecimal values (through the `Hex` type) into strings.
+
+class AlphaNum {
+ public:
+  // No bool ctor -- bools convert to an integral type.
+  // A bool ctor would also convert incoming pointers (bletch).
+
+  AlphaNum(int x)  // NOLINT(runtime/explicit)
+      : piece_(digits_, static_cast<size_t>(
+                            numbers_internal::FastIntToBuffer(x, digits_) -
+                            &digits_[0])) {}
+  AlphaNum(unsigned int x)  // NOLINT(runtime/explicit)
+      : piece_(digits_, static_cast<size_t>(
+                            numbers_internal::FastIntToBuffer(x, digits_) -
+                            &digits_[0])) {}
+  AlphaNum(long x)  // NOLINT(*)
+      : piece_(digits_, static_cast<size_t>(
+                            numbers_internal::FastIntToBuffer(x, digits_) -
+                            &digits_[0])) {}
+  AlphaNum(unsigned long x)  // NOLINT(*)
+      : piece_(digits_, static_cast<size_t>(
+                            numbers_internal::FastIntToBuffer(x, digits_) -
+                            &digits_[0])) {}
+  AlphaNum(long long x)  // NOLINT(*)
+      : piece_(digits_, static_cast<size_t>(
+                            numbers_internal::FastIntToBuffer(x, digits_) -
+                            &digits_[0])) {}
+  AlphaNum(unsigned long long x)  // NOLINT(*)
+      : piece_(digits_, static_cast<size_t>(
+                            numbers_internal::FastIntToBuffer(x, digits_) -
+                            &digits_[0])) {}
+
+  AlphaNum(float f)  // NOLINT(runtime/explicit)
+      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
+  AlphaNum(double f)  // NOLINT(runtime/explicit)
+      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
+
+  AlphaNum(Hex hex);  // NOLINT(runtime/explicit)
+  AlphaNum(Dec dec);  // NOLINT(runtime/explicit)
+
+  template <size_t size>
+  AlphaNum(  // NOLINT(runtime/explicit)
+      const strings_internal::AlphaNumBuffer<size>& buf)
+      : piece_(&buf.data[0], buf.size) {}
+
+  AlphaNum(const char* c_str)                     // NOLINT(runtime/explicit)
+      : piece_(NullSafeStringView(c_str)) {}      // NOLINT(runtime/explicit)
+  AlphaNum(absl::string_view pc) : piece_(pc) {}  // NOLINT(runtime/explicit)
+
+  template <typename Allocator>
+  AlphaNum(  // NOLINT(runtime/explicit)
+      const std::basic_string<char, std::char_traits<char>, Allocator>& str)
+      : piece_(str) {}
+
+  // Use string literals ":" instead of character literals ':'.
+  AlphaNum(char c) = delete;  // NOLINT(runtime/explicit)
+
+  AlphaNum(const AlphaNum&) = delete;
+  AlphaNum& operator=(const AlphaNum&) = delete;
+
+  absl::string_view::size_type size() const { return piece_.size(); }
+  const char* data() const { return piece_.data(); }
+  absl::string_view Piece() const { return piece_; }
+
+  // Normal enums are already handled by the integer formatters.
+  // This overload matches only scoped enums.
+  template <typename T,
+            typename = typename std::enable_if<
+                std::is_enum<T>{} && !std::is_convertible<T, int>{}>::type>
+  AlphaNum(T e)  // NOLINT(runtime/explicit)
+      : AlphaNum(static_cast<typename std::underlying_type<T>::type>(e)) {}
+
+  // vector<bool>::reference and const_reference require special help to
+  // convert to `AlphaNum` because it requires two user defined conversions.
+  template <
+      typename T,
+      typename std::enable_if<
+          std::is_class<T>::value &&
+          (std::is_same<T, std::vector<bool>::reference>::value ||
+           std::is_same<T, std::vector<bool>::const_reference>::value)>::type* =
+          nullptr>
+  AlphaNum(T e) : AlphaNum(static_cast<bool>(e)) {}  // NOLINT(runtime/explicit)
+
+ private:
+  absl::string_view piece_;
+  char digits_[numbers_internal::kFastToBufferSize];
+};
+
+// -----------------------------------------------------------------------------
+// StrCat()
+// -----------------------------------------------------------------------------
+//
+// Merges given strings or numbers, using no delimiter(s), returning the merged
+// result as a string.
+//
+// `StrCat()` is designed to be the fastest possible way to construct a string
+// out of a mix of raw C strings, string_views, strings, bool values,
+// and numeric values.
+//
+// Don't use `StrCat()` for user-visible strings. The localization process
+// works poorly on strings built up out of fragments.
+//
+// For clarity and performance, don't use `StrCat()` when appending to a
+// string. Use `StrAppend()` instead. In particular, avoid using any of these
+// (anti-)patterns:
+//
+//   str.append(StrCat(...))
+//   str += StrCat(...)
+//   str = StrCat(str, ...)
+//
+// The last case is the worst, with a potential to change a loop
+// from a linear time operation with O(1) dynamic allocations into a
+// quadratic time operation with O(n) dynamic allocations.
+//
+// See `StrAppend()` below for more information.
+
+namespace strings_internal {
+
+// Do not call directly - this is not part of the public API.
+std::string CatPieces(std::initializer_list<absl::string_view> pieces);
+void AppendPieces(std::string* dest,
+                  std::initializer_list<absl::string_view> pieces);
+
+}  // namespace strings_internal
+
+ABSL_MUST_USE_RESULT inline std::string StrCat() { return std::string(); }
+
+ABSL_MUST_USE_RESULT inline std::string StrCat(const AlphaNum& a) {
+  return std::string(a.data(), a.size());
+}
+
+ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b);
+ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                        const AlphaNum& c);
+ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                        const AlphaNum& c, const AlphaNum& d);
+
+// Support 5 or more arguments
+template <typename... AV>
+ABSL_MUST_USE_RESULT inline std::string StrCat(
+    const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d,
+    const AlphaNum& e, const AV&... args) {
+  return strings_internal::CatPieces(
+      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
+       static_cast<const AlphaNum&>(args).Piece()...});
+}
+
+// -----------------------------------------------------------------------------
+// StrAppend()
+// -----------------------------------------------------------------------------
+//
+// Appends a string or set of strings to an existing string, in a similar
+// fashion to `StrCat()`.
+//
+// WARNING: `StrAppend(&str, a, b, c, ...)` requires that none of the
+// a, b, c, parameters be a reference into str. For speed, `StrAppend()` does
+// not try to check each of its input arguments to be sure that they are not
+// a subset of the string being appended to. That is, while this will work:
+//
+//   std::string s = "foo";
+//   s += s;
+//
+// This output is undefined:
+//
+//   std::string s = "foo";
+//   StrAppend(&s, s);
+//
+// This output is undefined as well, since `absl::string_view` does not own its
+// data:
+//
+//   std::string s = "foobar";
+//   absl::string_view p = s;
+//   StrAppend(&s, p);
+
+inline void StrAppend(std::string*) {}
+void StrAppend(std::string* dest, const AlphaNum& a);
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b);
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
+               const AlphaNum& c);
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
+               const AlphaNum& c, const AlphaNum& d);
+
+// Support 5 or more arguments
+template <typename... AV>
+inline void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
+                      const AlphaNum& c, const AlphaNum& d, const AlphaNum& e,
+                      const AV&... args) {
+  strings_internal::AppendPieces(
+      dest, {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
+             static_cast<const AlphaNum&>(args).Piece()...});
+}
+
+// Helper function for the future StrCat default floating-point format, %.6g
+// This is fast.
+inline strings_internal::AlphaNumBuffer<
+    numbers_internal::kSixDigitsToBufferSize>
+SixDigits(double d) {
+  strings_internal::AlphaNumBuffer<numbers_internal::kSixDigitsToBufferSize>
+      result;
+  result.size = numbers_internal::SixDigitsToBuffer(d, &result.data[0]);
+  return result;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_STR_CAT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_format.h b/CAPI/cpp/grpc/include/absl/strings/str_format.h
new file mode 100644
index 0000000..4b05c70
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/str_format.h
@@ -0,0 +1,812 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_format.h
+// -----------------------------------------------------------------------------
+//
+// The `str_format` library is a typesafe replacement for the family of
+// `printf()` string formatting routines within the `<cstdio>` standard library
+// header. Like the `printf` family, `str_format` uses a "format string" to
+// perform argument substitutions based on types. See the `FormatSpec` section
+// below for format string documentation.
+//
+// Example:
+//
+//   std::string s = absl::StrFormat(
+//                      "%s %s You have $%d!", "Hello", name, dollars);
+//
+// The library consists of the following basic utilities:
+//
+//   * `absl::StrFormat()`, a type-safe replacement for `std::sprintf()`, to
+//     write a format string to a `string` value.
+//   * `absl::StrAppendFormat()` to append a format string to a `string`
+//   * `absl::StreamFormat()` to more efficiently write a format string to a
+//     stream, such as`std::cout`.
+//   * `absl::PrintF()`, `absl::FPrintF()` and `absl::SNPrintF()` as
+//     replacements for `std::printf()`, `std::fprintf()` and `std::snprintf()`.
+//
+//     Note: a version of `std::sprintf()` is not supported as it is
+//     generally unsafe due to buffer overflows.
+//
+// Additionally, you can provide a format string (and its associated arguments)
+// using one of the following abstractions:
+//
+//   * A `FormatSpec` class template fully encapsulates a format string and its
+//     type arguments and is usually provided to `str_format` functions as a
+//     variadic argument of type `FormatSpec<Arg...>`. The `FormatSpec<Args...>`
+//     template is evaluated at compile-time, providing type safety.
+//   * A `ParsedFormat` instance, which encapsulates a specific, pre-compiled
+//     format string for a specific set of type(s), and which can be passed
+//     between API boundaries. (The `FormatSpec` type should not be used
+//     directly except as an argument type for wrapper functions.)
+//
+// The `str_format` library provides the ability to output its format strings to
+// arbitrary sink types:
+//
+//   * A generic `Format()` function to write outputs to arbitrary sink types,
+//     which must implement a `FormatRawSink` interface.
+//
+//   * A `FormatUntyped()` function that is similar to `Format()` except it is
+//     loosely typed. `FormatUntyped()` is not a template and does not perform
+//     any compile-time checking of the format string; instead, it returns a
+//     boolean from a runtime check.
+//
+// In addition, the `str_format` library provides extension points for
+// augmenting formatting to new types.  See "StrFormat Extensions" below.
+
+#ifndef ABSL_STRINGS_STR_FORMAT_H_
+#define ABSL_STRINGS_STR_FORMAT_H_
+
+#include <cstdio>
+#include <string>
+
+#include "absl/strings/internal/str_format/arg.h"  // IWYU pragma: export
+#include "absl/strings/internal/str_format/bind.h"  // IWYU pragma: export
+#include "absl/strings/internal/str_format/checker.h"  // IWYU pragma: export
+#include "absl/strings/internal/str_format/extension.h"  // IWYU pragma: export
+#include "absl/strings/internal/str_format/parser.h"  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// UntypedFormatSpec
+//
+// A type-erased class that can be used directly within untyped API entry
+// points. An `UntypedFormatSpec` is specifically used as an argument to
+// `FormatUntyped()`.
+//
+// Example:
+//
+//   absl::UntypedFormatSpec format("%d");
+//   std::string out;
+//   CHECK(absl::FormatUntyped(&out, format, {absl::FormatArg(1)}));
+class UntypedFormatSpec {
+ public:
+  UntypedFormatSpec() = delete;
+  UntypedFormatSpec(const UntypedFormatSpec&) = delete;
+  UntypedFormatSpec& operator=(const UntypedFormatSpec&) = delete;
+
+  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
+
+ protected:
+  explicit UntypedFormatSpec(const str_format_internal::ParsedFormatBase* pc)
+      : spec_(pc) {}
+
+ private:
+  friend str_format_internal::UntypedFormatSpecImpl;
+  str_format_internal::UntypedFormatSpecImpl spec_;
+};
+
+// FormatStreamed()
+//
+// Takes a streamable argument and returns an object that can print it
+// with '%s'. Allows printing of types that have an `operator<<` but no
+// intrinsic type support within `StrFormat()` itself.
+//
+// Example:
+//
+//   absl::StrFormat("%s", absl::FormatStreamed(obj));
+template <typename T>
+str_format_internal::StreamedWrapper<T> FormatStreamed(const T& v) {
+  return str_format_internal::StreamedWrapper<T>(v);
+}
+
+// FormatCountCapture
+//
+// This class provides a way to safely wrap `StrFormat()` captures of `%n`
+// conversions, which denote the number of characters written by a formatting
+// operation to this point, into an integer value.
+//
+// This wrapper is designed to allow safe usage of `%n` within `StrFormat(); in
+// the `printf()` family of functions, `%n` is not safe to use, as the `int *`
+// buffer can be used to capture arbitrary data.
+//
+// Example:
+//
+//   int n = 0;
+//   std::string s = absl::StrFormat("%s%d%n", "hello", 123,
+//                       absl::FormatCountCapture(&n));
+//   EXPECT_EQ(8, n);
+class FormatCountCapture {
+ public:
+  explicit FormatCountCapture(int* p) : p_(p) {}
+
+ private:
+  // FormatCountCaptureHelper is used to define FormatConvertImpl() for this
+  // class.
+  friend struct str_format_internal::FormatCountCaptureHelper;
+  // Unused() is here because of the false positive from -Wunused-private-field
+  // p_ is used in the templated function of the friend FormatCountCaptureHelper
+  // class.
+  int* Unused() { return p_; }
+  int* p_;
+};
+
+// FormatSpec
+//
+// The `FormatSpec` type defines the makeup of a format string within the
+// `str_format` library. It is a variadic class template that is evaluated at
+// compile-time, according to the format string and arguments that are passed to
+// it.
+//
+// You should not need to manipulate this type directly. You should only name it
+// if you are writing wrapper functions which accept format arguments that will
+// be provided unmodified to functions in this library. Such a wrapper function
+// might be a class method that provides format arguments and/or internally uses
+// the result of formatting.
+//
+// For a `FormatSpec` to be valid at compile-time, it must be provided as
+// either:
+//
+// * A `constexpr` literal or `absl::string_view`, which is how it most often
+//   used.
+// * A `ParsedFormat` instantiation, which ensures the format string is
+//   valid before use. (See below.)
+//
+// Example:
+//
+//   // Provided as a string literal.
+//   absl::StrFormat("Welcome to %s, Number %d!", "The Village", 6);
+//
+//   // Provided as a constexpr absl::string_view.
+//   constexpr absl::string_view formatString = "Welcome to %s, Number %d!";
+//   absl::StrFormat(formatString, "The Village", 6);
+//
+//   // Provided as a pre-compiled ParsedFormat object.
+//   // Note that this example is useful only for illustration purposes.
+//   absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
+//   absl::StrFormat(formatString, "TheVillage", 6);
+//
+// A format string generally follows the POSIX syntax as used within the POSIX
+// `printf` specification.
+//
+// (See http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html.)
+//
+// In specific, the `FormatSpec` supports the following type specifiers:
+//   * `c` for characters
+//   * `s` for strings
+//   * `d` or `i` for integers
+//   * `o` for unsigned integer conversions into octal
+//   * `x` or `X` for unsigned integer conversions into hex
+//   * `u` for unsigned integers
+//   * `f` or `F` for floating point values into decimal notation
+//   * `e` or `E` for floating point values into exponential notation
+//   * `a` or `A` for floating point values into hex exponential notation
+//   * `g` or `G` for floating point values into decimal or exponential
+//     notation based on their precision
+//   * `p` for pointer address values
+//   * `n` for the special case of writing out the number of characters
+//     written to this point. The resulting value must be captured within an
+//     `absl::FormatCountCapture` type.
+//
+// Implementation-defined behavior:
+//   * A null pointer provided to "%s" or "%p" is output as "(nil)".
+//   * A non-null pointer provided to "%p" is output in hex as if by %#x or
+//     %#lx.
+//
+// NOTE: `o`, `x\X` and `u` will convert signed values to their unsigned
+// counterpart before formatting.
+//
+// Examples:
+//     "%c", 'a'                -> "a"
+//     "%c", 32                 -> " "
+//     "%s", "C"                -> "C"
+//     "%s", std::string("C++") -> "C++"
+//     "%d", -10                -> "-10"
+//     "%o", 10                 -> "12"
+//     "%x", 16                 -> "10"
+//     "%f", 123456789          -> "123456789.000000"
+//     "%e", .01                -> "1.00000e-2"
+//     "%a", -3.0               -> "-0x1.8p+1"
+//     "%g", .01                -> "1e-2"
+//     "%p", (void*)&value      -> "0x7ffdeb6ad2a4"
+//
+//     int n = 0;
+//     std::string s = absl::StrFormat(
+//         "%s%d%n", "hello", 123, absl::FormatCountCapture(&n));
+//     EXPECT_EQ(8, n);
+//
+// The `FormatSpec` intrinsically supports all of these fundamental C++ types:
+//
+// *   Characters: `char`, `signed char`, `unsigned char`
+// *   Integers: `int`, `short`, `unsigned short`, `unsigned`, `long`,
+//         `unsigned long`, `long long`, `unsigned long long`
+// *   Floating-point: `float`, `double`, `long double`
+//
+// However, in the `str_format` library, a format conversion specifies a broader
+// C++ conceptual category instead of an exact type. For example, `%s` binds to
+// any string-like argument, so `std::string`, `absl::string_view`, and
+// `const char*` are all accepted. Likewise, `%d` accepts any integer-like
+// argument, etc.
+
+template <typename... Args>
+using FormatSpec = str_format_internal::FormatSpecTemplate<
+    str_format_internal::ArgumentToConv<Args>()...>;
+
+// ParsedFormat
+//
+// A `ParsedFormat` is a class template representing a preparsed `FormatSpec`,
+// with template arguments specifying the conversion characters used within the
+// format string. Such characters must be valid format type specifiers, and
+// these type specifiers are checked at compile-time.
+//
+// Instances of `ParsedFormat` can be created, copied, and reused to speed up
+// formatting loops. A `ParsedFormat` may either be constructed statically, or
+// dynamically through its `New()` factory function, which only constructs a
+// runtime object if the format is valid at that time.
+//
+// Example:
+//
+//   // Verified at compile time.
+//   absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
+//   absl::StrFormat(formatString, "TheVillage", 6);
+//
+//   // Verified at runtime.
+//   auto format_runtime = absl::ParsedFormat<'d'>::New(format_string);
+//   if (format_runtime) {
+//     value = absl::StrFormat(*format_runtime, i);
+//   } else {
+//     ... error case ...
+//   }
+
+#if defined(__cpp_nontype_template_parameter_auto)
+// If C++17 is available, an 'extended' format is also allowed that can specify
+// multiple conversion characters per format argument, using a combination of
+// `absl::FormatConversionCharSet` enum values (logically a set union)
+//  via the `|` operator. (Single character-based arguments are still accepted,
+// but cannot be combined). Some common conversions also have predefined enum
+// values, such as `absl::FormatConversionCharSet::kIntegral`.
+//
+// Example:
+//   // Extended format supports multiple conversion characters per argument,
+//   // specified via a combination of `FormatConversionCharSet` enums.
+//   using MyFormat = absl::ParsedFormat<absl::FormatConversionCharSet::d |
+//                                       absl::FormatConversionCharSet::x>;
+//   MyFormat GetFormat(bool use_hex) {
+//     if (use_hex) return MyFormat("foo %x bar");
+//     return MyFormat("foo %d bar");
+//   }
+//   // `format` can be used with any value that supports 'd' and 'x',
+//   // like `int`.
+//   auto format = GetFormat(use_hex);
+//   value = StringF(format, i);
+template <auto... Conv>
+using ParsedFormat = absl::str_format_internal::ExtendedParsedFormat<
+    absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
+#else
+template <char... Conv>
+using ParsedFormat = str_format_internal::ExtendedParsedFormat<
+    absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
+#endif  // defined(__cpp_nontype_template_parameter_auto)
+
+// StrFormat()
+//
+// Returns a `string` given a `printf()`-style format string and zero or more
+// additional arguments. Use it as you would `sprintf()`. `StrFormat()` is the
+// primary formatting function within the `str_format` library, and should be
+// used in most cases where you need type-safe conversion of types into
+// formatted strings.
+//
+// The format string generally consists of ordinary character data along with
+// one or more format conversion specifiers (denoted by the `%` character).
+// Ordinary character data is returned unchanged into the result string, while
+// each conversion specification performs a type substitution from
+// `StrFormat()`'s other arguments. See the comments for `FormatSpec` for full
+// information on the makeup of this format string.
+//
+// Example:
+//
+//   std::string s = absl::StrFormat(
+//       "Welcome to %s, Number %d!", "The Village", 6);
+//   EXPECT_EQ("Welcome to The Village, Number 6!", s);
+//
+// Returns an empty string in case of error.
+template <typename... Args>
+ABSL_MUST_USE_RESULT std::string StrFormat(const FormatSpec<Args...>& format,
+                                           const Args&... args) {
+  return str_format_internal::FormatPack(
+      str_format_internal::UntypedFormatSpecImpl::Extract(format),
+      {str_format_internal::FormatArgImpl(args)...});
+}
+
+// StrAppendFormat()
+//
+// Appends to a `dst` string given a format string, and zero or more additional
+// arguments, returning `*dst` as a convenience for chaining purposes. Appends
+// nothing in case of error (but possibly alters its capacity).
+//
+// Example:
+//
+//   std::string orig("For example PI is approximately ");
+//   std::cout << StrAppendFormat(&orig, "%12.6f", 3.14);
+template <typename... Args>
+std::string& StrAppendFormat(std::string* dst,
+                             const FormatSpec<Args...>& format,
+                             const Args&... args) {
+  return str_format_internal::AppendPack(
+      dst, str_format_internal::UntypedFormatSpecImpl::Extract(format),
+      {str_format_internal::FormatArgImpl(args)...});
+}
+
+// StreamFormat()
+//
+// Writes to an output stream given a format string and zero or more arguments,
+// generally in a manner that is more efficient than streaming the result of
+// `absl:: StrFormat()`. The returned object must be streamed before the full
+// expression ends.
+//
+// Example:
+//
+//   std::cout << StreamFormat("%12.6f", 3.14);
+template <typename... Args>
+ABSL_MUST_USE_RESULT str_format_internal::Streamable StreamFormat(
+    const FormatSpec<Args...>& format, const Args&... args) {
+  return str_format_internal::Streamable(
+      str_format_internal::UntypedFormatSpecImpl::Extract(format),
+      {str_format_internal::FormatArgImpl(args)...});
+}
+
+// PrintF()
+//
+// Writes to stdout given a format string and zero or more arguments. This
+// function is functionally equivalent to `std::printf()` (and type-safe);
+// prefer `absl::PrintF()` over `std::printf()`.
+//
+// Example:
+//
+//   std::string_view s = "Ulaanbaatar";
+//   absl::PrintF("The capital of Mongolia is %s", s);
+//
+//   Outputs: "The capital of Mongolia is Ulaanbaatar"
+//
+template <typename... Args>
+int PrintF(const FormatSpec<Args...>& format, const Args&... args) {
+  return str_format_internal::FprintF(
+      stdout, str_format_internal::UntypedFormatSpecImpl::Extract(format),
+      {str_format_internal::FormatArgImpl(args)...});
+}
+
+// FPrintF()
+//
+// Writes to a file given a format string and zero or more arguments. This
+// function is functionally equivalent to `std::fprintf()` (and type-safe);
+// prefer `absl::FPrintF()` over `std::fprintf()`.
+//
+// Example:
+//
+//   std::string_view s = "Ulaanbaatar";
+//   absl::FPrintF(stdout, "The capital of Mongolia is %s", s);
+//
+//   Outputs: "The capital of Mongolia is Ulaanbaatar"
+//
+template <typename... Args>
+int FPrintF(std::FILE* output, const FormatSpec<Args...>& format,
+            const Args&... args) {
+  return str_format_internal::FprintF(
+      output, str_format_internal::UntypedFormatSpecImpl::Extract(format),
+      {str_format_internal::FormatArgImpl(args)...});
+}
+
+// SNPrintF()
+//
+// Writes to a sized buffer given a format string and zero or more arguments.
+// This function is functionally equivalent to `std::snprintf()` (and
+// type-safe); prefer `absl::SNPrintF()` over `std::snprintf()`.
+//
+// In particular, a successful call to `absl::SNPrintF()` writes at most `size`
+// bytes of the formatted output to `output`, including a NUL-terminator, and
+// returns the number of bytes that would have been written if truncation did
+// not occur. In the event of an error, a negative value is returned and `errno`
+// is set.
+//
+// Example:
+//
+//   std::string_view s = "Ulaanbaatar";
+//   char output[128];
+//   absl::SNPrintF(output, sizeof(output),
+//                  "The capital of Mongolia is %s", s);
+//
+//   Post-condition: output == "The capital of Mongolia is Ulaanbaatar"
+//
+template <typename... Args>
+int SNPrintF(char* output, std::size_t size, const FormatSpec<Args...>& format,
+             const Args&... args) {
+  return str_format_internal::SnprintF(
+      output, size, str_format_internal::UntypedFormatSpecImpl::Extract(format),
+      {str_format_internal::FormatArgImpl(args)...});
+}
+
+// -----------------------------------------------------------------------------
+// Custom Output Formatting Functions
+// -----------------------------------------------------------------------------
+
+// FormatRawSink
+//
+// FormatRawSink is a type erased wrapper around arbitrary sink objects
+// specifically used as an argument to `Format()`.
+//
+// All the object has to do define an overload of `AbslFormatFlush()` for the
+// sink, usually by adding a ADL-based free function in the same namespace as
+// the sink:
+//
+//   void AbslFormatFlush(MySink* dest, absl::string_view part);
+//
+// where `dest` is the pointer passed to `absl::Format()`. The function should
+// append `part` to `dest`.
+//
+// FormatRawSink does not own the passed sink object. The passed object must
+// outlive the FormatRawSink.
+class FormatRawSink {
+ public:
+  // Implicitly convert from any type that provides the hook function as
+  // described above.
+  template <typename T,
+            typename = typename std::enable_if<std::is_constructible<
+                str_format_internal::FormatRawSinkImpl, T*>::value>::type>
+  FormatRawSink(T* raw)  // NOLINT
+      : sink_(raw) {}
+
+ private:
+  friend str_format_internal::FormatRawSinkImpl;
+  str_format_internal::FormatRawSinkImpl sink_;
+};
+
+// Format()
+//
+// Writes a formatted string to an arbitrary sink object (implementing the
+// `absl::FormatRawSink` interface), using a format string and zero or more
+// additional arguments.
+//
+// By default, `std::string`, `std::ostream`, and `absl::Cord` are supported as
+// destination objects. If a `std::string` is used the formatted string is
+// appended to it.
+//
+// `absl::Format()` is a generic version of `absl::StrAppendFormat()`, for
+// custom sinks. The format string, like format strings for `StrFormat()`, is
+// checked at compile-time.
+//
+// On failure, this function returns `false` and the state of the sink is
+// unspecified.
+template <typename... Args>
+bool Format(FormatRawSink raw_sink, const FormatSpec<Args...>& format,
+            const Args&... args) {
+  return str_format_internal::FormatUntyped(
+      str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
+      str_format_internal::UntypedFormatSpecImpl::Extract(format),
+      {str_format_internal::FormatArgImpl(args)...});
+}
+
+// FormatArg
+//
+// A type-erased handle to a format argument specifically used as an argument to
+// `FormatUntyped()`. You may construct `FormatArg` by passing
+// reference-to-const of any printable type. `FormatArg` is both copyable and
+// assignable. The source data must outlive the `FormatArg` instance. See
+// example below.
+//
+using FormatArg = str_format_internal::FormatArgImpl;
+
+// FormatUntyped()
+//
+// Writes a formatted string to an arbitrary sink object (implementing the
+// `absl::FormatRawSink` interface), using an `UntypedFormatSpec` and zero or
+// more additional arguments.
+//
+// This function acts as the most generic formatting function in the
+// `str_format` library. The caller provides a raw sink, an unchecked format
+// string, and (usually) a runtime specified list of arguments; no compile-time
+// checking of formatting is performed within this function. As a result, a
+// caller should check the return value to verify that no error occurred.
+// On failure, this function returns `false` and the state of the sink is
+// unspecified.
+//
+// The arguments are provided in an `absl::Span<const absl::FormatArg>`.
+// Each `absl::FormatArg` object binds to a single argument and keeps a
+// reference to it. The values used to create the `FormatArg` objects must
+// outlive this function call.
+//
+// Example:
+//
+//   std::optional<std::string> FormatDynamic(
+//       const std::string& in_format,
+//       const vector<std::string>& in_args) {
+//     std::string out;
+//     std::vector<absl::FormatArg> args;
+//     for (const auto& v : in_args) {
+//       // It is important that 'v' is a reference to the objects in in_args.
+//       // The values we pass to FormatArg must outlive the call to
+//       // FormatUntyped.
+//       args.emplace_back(v);
+//     }
+//     absl::UntypedFormatSpec format(in_format);
+//     if (!absl::FormatUntyped(&out, format, args)) {
+//       return std::nullopt;
+//     }
+//     return std::move(out);
+//   }
+//
+ABSL_MUST_USE_RESULT inline bool FormatUntyped(
+    FormatRawSink raw_sink, const UntypedFormatSpec& format,
+    absl::Span<const FormatArg> args) {
+  return str_format_internal::FormatUntyped(
+      str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
+      str_format_internal::UntypedFormatSpecImpl::Extract(format), args);
+}
+
+//------------------------------------------------------------------------------
+// StrFormat Extensions
+//------------------------------------------------------------------------------
+//
+// AbslFormatConvert()
+//
+// The StrFormat library provides a customization API for formatting
+// user-defined types using absl::StrFormat(). The API relies on detecting an
+// overload in the user-defined type's namespace of a free (non-member)
+// `AbslFormatConvert()` function, usually as a friend definition with the
+// following signature:
+//
+// absl::FormatConvertResult<...> AbslFormatConvert(
+//     const X& value,
+//     const absl::FormatConversionSpec& spec,
+//     absl::FormatSink *sink);
+//
+// An `AbslFormatConvert()` overload for a type should only be declared in the
+// same file and namespace as said type.
+//
+// The abstractions within this definition include:
+//
+// * An `absl::FormatConversionSpec` to specify the fields to pull from a
+//   user-defined type's format string
+// * An `absl::FormatSink` to hold the converted string data during the
+//   conversion process.
+// * An `absl::FormatConvertResult` to hold the status of the returned
+//   formatting operation
+//
+// The return type encodes all the conversion characters that your
+// AbslFormatConvert() routine accepts.  The return value should be {true}.
+// A return value of {false} will result in `StrFormat()` returning
+// an empty string.  This result will be propagated to the result of
+// `FormatUntyped`.
+//
+// Example:
+//
+// struct Point {
+//   // To add formatting support to `Point`, we simply need to add a free
+//   // (non-member) function `AbslFormatConvert()`.  This method interprets
+//   // `spec` to print in the request format. The allowed conversion characters
+//   // can be restricted via the type of the result, in this example
+//   // string and integral formatting are allowed (but not, for instance
+//   // floating point characters like "%f").  You can add such a free function
+//   // using a friend declaration within the body of the class:
+//   friend absl::FormatConvertResult<absl::FormatConversionCharSet::kString |
+//                                    absl::FormatConversionCharSet::kIntegral>
+//   AbslFormatConvert(const Point& p, const absl::FormatConversionSpec& spec,
+//                     absl::FormatSink* s) {
+//     if (spec.conversion_char() == absl::FormatConversionChar::s) {
+//       s->Append(absl::StrCat("x=", p.x, " y=", p.y));
+//     } else {
+//       s->Append(absl::StrCat(p.x, ",", p.y));
+//     }
+//     return {true};
+//   }
+//
+//   int x;
+//   int y;
+// };
+
+// clang-format off
+
+// FormatConversionChar
+//
+// Specifies the formatting character provided in the format string
+// passed to `StrFormat()`.
+enum class FormatConversionChar : uint8_t {
+  c, s,                    // text
+  d, i, o, u, x, X,        // int
+  f, F, e, E, g, G, a, A,  // float
+  n, p                     // misc
+};
+// clang-format on
+
+// FormatConversionSpec
+//
+// Specifies modifications to the conversion of the format string, through use
+// of one or more format flags in the source format string.
+class FormatConversionSpec {
+ public:
+  // FormatConversionSpec::is_basic()
+  //
+  // Indicates that width and precision are not specified, and no additional
+  // flags are set for this conversion character in the format string.
+  bool is_basic() const { return impl_.is_basic(); }
+
+  // FormatConversionSpec::has_left_flag()
+  //
+  // Indicates whether the result should be left justified for this conversion
+  // character in the format string. This flag is set through use of a '-'
+  // character in the format string. E.g. "%-s"
+  bool has_left_flag() const { return impl_.has_left_flag(); }
+
+  // FormatConversionSpec::has_show_pos_flag()
+  //
+  // Indicates whether a sign column is prepended to the result for this
+  // conversion character in the format string, even if the result is positive.
+  // This flag is set through use of a '+' character in the format string.
+  // E.g. "%+d"
+  bool has_show_pos_flag() const { return impl_.has_show_pos_flag(); }
+
+  // FormatConversionSpec::has_sign_col_flag()
+  //
+  // Indicates whether a mandatory sign column is added to the result for this
+  // conversion character. This flag is set through use of a space character
+  // (' ') in the format string. E.g. "% i"
+  bool has_sign_col_flag() const { return impl_.has_sign_col_flag(); }
+
+  // FormatConversionSpec::has_alt_flag()
+  //
+  // Indicates whether an "alternate" format is applied to the result for this
+  // conversion character. Alternative forms depend on the type of conversion
+  // character, and unallowed alternatives are undefined. This flag is set
+  // through use of a '#' character in the format string. E.g. "%#h"
+  bool has_alt_flag() const { return impl_.has_alt_flag(); }
+
+  // FormatConversionSpec::has_zero_flag()
+  //
+  // Indicates whether zeroes should be prepended to the result for this
+  // conversion character instead of spaces. This flag is set through use of the
+  // '0' character in the format string. E.g. "%0f"
+  bool has_zero_flag() const { return impl_.has_zero_flag(); }
+
+  // FormatConversionSpec::conversion_char()
+  //
+  // Returns the underlying conversion character.
+  FormatConversionChar conversion_char() const {
+    return impl_.conversion_char();
+  }
+
+  // FormatConversionSpec::width()
+  //
+  // Returns the specified width (indicated through use of a non-zero integer
+  // value or '*' character) of the conversion character. If width is
+  // unspecified, it returns a negative value.
+  int width() const { return impl_.width(); }
+
+  // FormatConversionSpec::precision()
+  //
+  // Returns the specified precision (through use of the '.' character followed
+  // by a non-zero integer value or '*' character) of the conversion character.
+  // If precision is unspecified, it returns a negative value.
+  int precision() const { return impl_.precision(); }
+
+ private:
+  explicit FormatConversionSpec(
+      str_format_internal::FormatConversionSpecImpl impl)
+      : impl_(impl) {}
+
+  friend str_format_internal::FormatConversionSpecImpl;
+
+  absl::str_format_internal::FormatConversionSpecImpl impl_;
+};
+
+// Type safe OR operator for FormatConversionCharSet to allow accepting multiple
+// conversion chars in custom format converters.
+constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
+                                            FormatConversionCharSet b) {
+  return static_cast<FormatConversionCharSet>(static_cast<uint64_t>(a) |
+                                              static_cast<uint64_t>(b));
+}
+
+// FormatConversionCharSet
+//
+// Specifies the _accepted_ conversion types as a template parameter to
+// FormatConvertResult for custom implementations of `AbslFormatConvert`.
+// Note the helper predefined alias definitions (kIntegral, etc.) below.
+enum class FormatConversionCharSet : uint64_t {
+  // text
+  c = str_format_internal::FormatConversionCharToConvInt('c'),
+  s = str_format_internal::FormatConversionCharToConvInt('s'),
+  // integer
+  d = str_format_internal::FormatConversionCharToConvInt('d'),
+  i = str_format_internal::FormatConversionCharToConvInt('i'),
+  o = str_format_internal::FormatConversionCharToConvInt('o'),
+  u = str_format_internal::FormatConversionCharToConvInt('u'),
+  x = str_format_internal::FormatConversionCharToConvInt('x'),
+  X = str_format_internal::FormatConversionCharToConvInt('X'),
+  // Float
+  f = str_format_internal::FormatConversionCharToConvInt('f'),
+  F = str_format_internal::FormatConversionCharToConvInt('F'),
+  e = str_format_internal::FormatConversionCharToConvInt('e'),
+  E = str_format_internal::FormatConversionCharToConvInt('E'),
+  g = str_format_internal::FormatConversionCharToConvInt('g'),
+  G = str_format_internal::FormatConversionCharToConvInt('G'),
+  a = str_format_internal::FormatConversionCharToConvInt('a'),
+  A = str_format_internal::FormatConversionCharToConvInt('A'),
+  // misc
+  n = str_format_internal::FormatConversionCharToConvInt('n'),
+  p = str_format_internal::FormatConversionCharToConvInt('p'),
+
+  // Used for width/precision '*' specification.
+  kStar = static_cast<uint64_t>(
+      absl::str_format_internal::FormatConversionCharSetInternal::kStar),
+  // Some predefined values:
+  kIntegral = d | i | u | o | x | X,
+  kFloating = a | e | f | g | A | E | F | G,
+  kNumeric = kIntegral | kFloating,
+  kString = s,
+  kPointer = p,
+};
+
+// FormatSink
+//
+// An abstraction to which conversions write their string data.
+//
+class FormatSink {
+ public:
+  // Appends `count` copies of `ch`.
+  void Append(size_t count, char ch) { sink_->Append(count, ch); }
+
+  void Append(string_view v) { sink_->Append(v); }
+
+  // Appends the first `precision` bytes of `v`. If this is less than
+  // `width`, spaces will be appended first (if `left` is false), or
+  // after (if `left` is true) to ensure the total amount appended is
+  // at least `width`.
+  bool PutPaddedString(string_view v, int width, int precision, bool left) {
+    return sink_->PutPaddedString(v, width, precision, left);
+  }
+
+ private:
+  friend str_format_internal::FormatSinkImpl;
+  explicit FormatSink(str_format_internal::FormatSinkImpl* s) : sink_(s) {}
+  str_format_internal::FormatSinkImpl* sink_;
+};
+
+// FormatConvertResult
+//
+// Indicates whether a call to AbslFormatConvert() was successful.
+// This return type informs the StrFormat extension framework (through
+// ADL but using the return type) of what conversion characters are supported.
+// It is strongly discouraged to return {false}, as this will result in an
+// empty string in StrFormat.
+template <FormatConversionCharSet C>
+struct FormatConvertResult {
+  bool value;
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_STR_FORMAT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_join.h b/CAPI/cpp/grpc/include/absl/strings/str_join.h
new file mode 100644
index 0000000..ee5ae7e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/str_join.h
@@ -0,0 +1,287 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_join.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains functions for joining a range of elements and
+// returning the result as a std::string. StrJoin operations are specified by
+// passing a range, a separator string to use between the elements joined, and
+// an optional Formatter responsible for converting each argument in the range
+// to a string. If omitted, a default `AlphaNumFormatter()` is called on the
+// elements to be joined, using the same formatting that `absl::StrCat()` uses.
+// This package defines a number of default formatters, and you can define your
+// own implementations.
+//
+// Ranges are specified by passing a container with `std::begin()` and
+// `std::end()` iterators, container-specific `begin()` and `end()` iterators, a
+// brace-initialized `std::initializer_list`, or a `std::tuple` of heterogeneous
+// objects. The separator string is specified as an `absl::string_view`.
+//
+// Because the default formatter uses the `absl::AlphaNum` class,
+// `absl::StrJoin()`, like `absl::StrCat()`, will work out-of-the-box on
+// collections of strings, ints, floats, doubles, etc.
+//
+// Example:
+//
+//   std::vector<std::string> v = {"foo", "bar", "baz"};
+//   std::string s = absl::StrJoin(v, "-");
+//   EXPECT_EQ("foo-bar-baz", s);
+//
+// See comments on the `absl::StrJoin()` function for more examples.
+
+#ifndef ABSL_STRINGS_STR_JOIN_H_
+#define ABSL_STRINGS_STR_JOIN_H_
+
+#include <cstdio>
+#include <cstring>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/strings/internal/str_join_internal.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// Concept: Formatter
+// -----------------------------------------------------------------------------
+//
+// A Formatter is a function object that is responsible for formatting its
+// argument as a string and appending it to a given output std::string.
+// Formatters may be implemented as function objects, lambdas, or normal
+// functions. You may provide your own Formatter to enable `absl::StrJoin()` to
+// work with arbitrary types.
+//
+// The following is an example of a custom Formatter that uses
+// `absl::FormatDuration` to join a list of `absl::Duration`s.
+//
+//   std::vector<absl::Duration> v = {absl::Seconds(1), absl::Milliseconds(10)};
+//   std::string s =
+//       absl::StrJoin(v, ", ", [](std::string* out, absl::Duration dur) {
+//         absl::StrAppend(out, absl::FormatDuration(dur));
+//       });
+//   EXPECT_EQ("1s, 10ms", s);
+//
+// The following standard formatters are provided within this file:
+//
+// - `AlphaNumFormatter()` (the default)
+// - `StreamFormatter()`
+// - `PairFormatter()`
+// - `DereferenceFormatter()`
+
+// AlphaNumFormatter()
+//
+// Default formatter used if none is specified. Uses `absl::AlphaNum` to convert
+// numeric arguments to strings.
+inline strings_internal::AlphaNumFormatterImpl AlphaNumFormatter() {
+  return strings_internal::AlphaNumFormatterImpl();
+}
+
+// StreamFormatter()
+//
+// Formats its argument using the << operator.
+inline strings_internal::StreamFormatterImpl StreamFormatter() {
+  return strings_internal::StreamFormatterImpl();
+}
+
+// Function Template: PairFormatter(Formatter, absl::string_view, Formatter)
+//
+// Formats a `std::pair` by putting a given separator between the pair's
+// `.first` and `.second` members. This formatter allows you to specify
+// custom Formatters for both the first and second member of each pair.
+template <typename FirstFormatter, typename SecondFormatter>
+inline strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>
+PairFormatter(FirstFormatter f1, absl::string_view sep, SecondFormatter f2) {
+  return strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>(
+      std::move(f1), sep, std::move(f2));
+}
+
+// Function overload of PairFormatter() for using a default
+// `AlphaNumFormatter()` for each Formatter in the pair.
+inline strings_internal::PairFormatterImpl<
+    strings_internal::AlphaNumFormatterImpl,
+    strings_internal::AlphaNumFormatterImpl>
+PairFormatter(absl::string_view sep) {
+  return PairFormatter(AlphaNumFormatter(), sep, AlphaNumFormatter());
+}
+
+// Function Template: DereferenceFormatter(Formatter)
+//
+// Formats its argument by dereferencing it and then applying the given
+// formatter. This formatter is useful for formatting a container of
+// pointer-to-T. This pattern often shows up when joining repeated fields in
+// protocol buffers.
+template <typename Formatter>
+strings_internal::DereferenceFormatterImpl<Formatter> DereferenceFormatter(
+    Formatter&& f) {
+  return strings_internal::DereferenceFormatterImpl<Formatter>(
+      std::forward<Formatter>(f));
+}
+
+// Function overload of `DereferenceFormatter()` for using a default
+// `AlphaNumFormatter()`.
+inline strings_internal::DereferenceFormatterImpl<
+    strings_internal::AlphaNumFormatterImpl>
+DereferenceFormatter() {
+  return strings_internal::DereferenceFormatterImpl<
+      strings_internal::AlphaNumFormatterImpl>(AlphaNumFormatter());
+}
+
+// -----------------------------------------------------------------------------
+// StrJoin()
+// -----------------------------------------------------------------------------
+//
+// Joins a range of elements and returns the result as a std::string.
+// `absl::StrJoin()` takes a range, a separator string to use between the
+// elements joined, and an optional Formatter responsible for converting each
+// argument in the range to a string.
+//
+// If omitted, the default `AlphaNumFormatter()` is called on the elements to be
+// joined.
+//
+// Example 1:
+//   // Joins a collection of strings. This pattern also works with a collection
+//   // of `absl::string_view` or even `const char*`.
+//   std::vector<std::string> v = {"foo", "bar", "baz"};
+//   std::string s = absl::StrJoin(v, "-");
+//   EXPECT_EQ("foo-bar-baz", s);
+//
+// Example 2:
+//   // Joins the values in the given `std::initializer_list<>` specified using
+//   // brace initialization. This pattern also works with an initializer_list
+//   // of ints or `absl::string_view` -- any `AlphaNum`-compatible type.
+//   std::string s = absl::StrJoin({"foo", "bar", "baz"}, "-");
+//   EXPECT_EQ("foo-bar-baz", s);
+//
+// Example 3:
+//   // Joins a collection of ints. This pattern also works with floats,
+//   // doubles, int64s -- any `StrCat()`-compatible type.
+//   std::vector<int> v = {1, 2, 3, -4};
+//   std::string s = absl::StrJoin(v, "-");
+//   EXPECT_EQ("1-2-3--4", s);
+//
+// Example 4:
+//   // Joins a collection of pointer-to-int. By default, pointers are
+//   // dereferenced and the pointee is formatted using the default format for
+//   // that type; such dereferencing occurs for all levels of indirection, so
+//   // this pattern works just as well for `std::vector<int**>` as for
+//   // `std::vector<int*>`.
+//   int x = 1, y = 2, z = 3;
+//   std::vector<int*> v = {&x, &y, &z};
+//   std::string s = absl::StrJoin(v, "-");
+//   EXPECT_EQ("1-2-3", s);
+//
+// Example 5:
+//   // Dereferencing of `std::unique_ptr<>` is also supported:
+//   std::vector<std::unique_ptr<int>> v
+//   v.emplace_back(new int(1));
+//   v.emplace_back(new int(2));
+//   v.emplace_back(new int(3));
+//   std::string s = absl::StrJoin(v, "-");
+//   EXPECT_EQ("1-2-3", s);
+//
+// Example 6:
+//   // Joins a `std::map`, with each key-value pair separated by an equals
+//   // sign. This pattern would also work with, say, a
+//   // `std::vector<std::pair<>>`.
+//   std::map<std::string, int> m = {
+//       std::make_pair("a", 1),
+//       std::make_pair("b", 2),
+//       std::make_pair("c", 3)};
+//   std::string s = absl::StrJoin(m, ",", absl::PairFormatter("="));
+//   EXPECT_EQ("a=1,b=2,c=3", s);
+//
+// Example 7:
+//   // These examples show how `absl::StrJoin()` handles a few common edge
+//   // cases:
+//   std::vector<std::string> v_empty;
+//   EXPECT_EQ("", absl::StrJoin(v_empty, "-"));
+//
+//   std::vector<std::string> v_one_item = {"foo"};
+//   EXPECT_EQ("foo", absl::StrJoin(v_one_item, "-"));
+//
+//   std::vector<std::string> v_empty_string = {""};
+//   EXPECT_EQ("", absl::StrJoin(v_empty_string, "-"));
+//
+//   std::vector<std::string> v_one_item_empty_string = {"a", ""};
+//   EXPECT_EQ("a-", absl::StrJoin(v_one_item_empty_string, "-"));
+//
+//   std::vector<std::string> v_two_empty_string = {"", ""};
+//   EXPECT_EQ("-", absl::StrJoin(v_two_empty_string, "-"));
+//
+// Example 8:
+//   // Joins a `std::tuple<T...>` of heterogeneous types, converting each to
+//   // a std::string using the `absl::AlphaNum` class.
+//   std::string s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-");
+//   EXPECT_EQ("123-abc-0.456", s);
+
+template <typename Iterator, typename Formatter>
+std::string StrJoin(Iterator start, Iterator end, absl::string_view sep,
+                    Formatter&& fmt) {
+  return strings_internal::JoinAlgorithm(start, end, sep, fmt);
+}
+
+template <typename Range, typename Formatter>
+std::string StrJoin(const Range& range, absl::string_view separator,
+                    Formatter&& fmt) {
+  return strings_internal::JoinRange(range, separator, fmt);
+}
+
+template <typename T, typename Formatter>
+std::string StrJoin(std::initializer_list<T> il, absl::string_view separator,
+                    Formatter&& fmt) {
+  return strings_internal::JoinRange(il, separator, fmt);
+}
+
+template <typename... T, typename Formatter>
+std::string StrJoin(const std::tuple<T...>& value, absl::string_view separator,
+                    Formatter&& fmt) {
+  return strings_internal::JoinAlgorithm(value, separator, fmt);
+}
+
+template <typename Iterator>
+std::string StrJoin(Iterator start, Iterator end, absl::string_view separator) {
+  return strings_internal::JoinRange(start, end, separator);
+}
+
+template <typename Range>
+std::string StrJoin(const Range& range, absl::string_view separator) {
+  return strings_internal::JoinRange(range, separator);
+}
+
+template <typename T>
+std::string StrJoin(std::initializer_list<T> il,
+                    absl::string_view separator) {
+  return strings_internal::JoinRange(il, separator);
+}
+
+template <typename... T>
+std::string StrJoin(const std::tuple<T...>& value,
+                    absl::string_view separator) {
+  return strings_internal::JoinAlgorithm(value, separator, AlphaNumFormatter());
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_STR_JOIN_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_replace.h b/CAPI/cpp/grpc/include/absl/strings/str_replace.h
new file mode 100644
index 0000000..273c707
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/str_replace.h
@@ -0,0 +1,219 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_replace.h
+// -----------------------------------------------------------------------------
+//
+// This file defines `absl::StrReplaceAll()`, a general-purpose string
+// replacement function designed for large, arbitrary text substitutions,
+// especially on strings which you are receiving from some other system for
+// further processing (e.g. processing regular expressions, escaping HTML
+// entities, etc.). `StrReplaceAll` is designed to be efficient even when only
+// one substitution is being performed, or when substitution is rare.
+//
+// If the string being modified is known at compile-time, and the substitutions
+// vary, `absl::Substitute()` may be a better choice.
+//
+// Example:
+//
+// std::string html_escaped = absl::StrReplaceAll(user_input, {
+//                                                {"&", "&amp;"},
+//                                                {"<", "&lt;"},
+//                                                {">", "&gt;"},
+//                                                {"\"", "&quot;"},
+//                                                {"'", "&#39;"}});
+#ifndef ABSL_STRINGS_STR_REPLACE_H_
+#define ABSL_STRINGS_STR_REPLACE_H_
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/attributes.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// StrReplaceAll()
+//
+// Replaces character sequences within a given string with replacements provided
+// within an initializer list of key/value pairs. Candidate replacements are
+// considered in order as they occur within the string, with earlier matches
+// taking precedence, and longer matches taking precedence for candidates
+// starting at the same position in the string. Once a substitution is made, the
+// replaced text is not considered for any further substitutions.
+//
+// Example:
+//
+//   std::string s = absl::StrReplaceAll(
+//       "$who bought $count #Noun. Thanks $who!",
+//       {{"$count", absl::StrCat(5)},
+//        {"$who", "Bob"},
+//        {"#Noun", "Apples"}});
+//   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+ABSL_MUST_USE_RESULT std::string StrReplaceAll(
+    absl::string_view s,
+    std::initializer_list<std::pair<absl::string_view, absl::string_view>>
+        replacements);
+
+// Overload of `StrReplaceAll()` to accept a container of key/value replacement
+// pairs (typically either an associative map or a `std::vector` of `std::pair`
+// elements). A vector of pairs is generally more efficient.
+//
+// Examples:
+//
+//   std::map<const absl::string_view, const absl::string_view> replacements;
+//   replacements["$who"] = "Bob";
+//   replacements["$count"] = "5";
+//   replacements["#Noun"] = "Apples";
+//   std::string s = absl::StrReplaceAll(
+//       "$who bought $count #Noun. Thanks $who!",
+//       replacements);
+//   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+//
+//   // A std::vector of std::pair elements can be more efficient.
+//   std::vector<std::pair<const absl::string_view, std::string>> replacements;
+//   replacements.push_back({"&", "&amp;"});
+//   replacements.push_back({"<", "&lt;"});
+//   replacements.push_back({">", "&gt;"});
+//   std::string s = absl::StrReplaceAll("if (ptr < &foo)",
+//                                  replacements);
+//   EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
+template <typename StrToStrMapping>
+std::string StrReplaceAll(absl::string_view s,
+                          const StrToStrMapping& replacements);
+
+// Overload of `StrReplaceAll()` to replace character sequences within a given
+// output string *in place* with replacements provided within an initializer
+// list of key/value pairs, returning the number of substitutions that occurred.
+//
+// Example:
+//
+//   std::string s = std::string("$who bought $count #Noun. Thanks $who!");
+//   int count;
+//   count = absl::StrReplaceAll({{"$count", absl::StrCat(5)},
+//                               {"$who", "Bob"},
+//                               {"#Noun", "Apples"}}, &s);
+//  EXPECT_EQ(count, 4);
+//  EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+int StrReplaceAll(
+    std::initializer_list<std::pair<absl::string_view, absl::string_view>>
+        replacements,
+    std::string* target);
+
+// Overload of `StrReplaceAll()` to replace patterns within a given output
+// string *in place* with replacements provided within a container of key/value
+// pairs.
+//
+// Example:
+//
+//   std::string s = std::string("if (ptr < &foo)");
+//   int count = absl::StrReplaceAll({{"&", "&amp;"},
+//                                    {"<", "&lt;"},
+//                                    {">", "&gt;"}}, &s);
+//  EXPECT_EQ(count, 2);
+//  EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
+template <typename StrToStrMapping>
+int StrReplaceAll(const StrToStrMapping& replacements, std::string* target);
+
+// Implementation details only, past this point.
+namespace strings_internal {
+
+struct ViableSubstitution {
+  absl::string_view old;
+  absl::string_view replacement;
+  size_t offset;
+
+  ViableSubstitution(absl::string_view old_str,
+                     absl::string_view replacement_str, size_t offset_val)
+      : old(old_str), replacement(replacement_str), offset(offset_val) {}
+
+  // One substitution occurs "before" another (takes priority) if either
+  // it has the lowest offset, or it has the same offset but a larger size.
+  bool OccursBefore(const ViableSubstitution& y) const {
+    if (offset != y.offset) return offset < y.offset;
+    return old.size() > y.old.size();
+  }
+};
+
+// Build a vector of ViableSubstitutions based on the given list of
+// replacements. subs can be implemented as a priority_queue. However, it turns
+// out that most callers have small enough a list of substitutions that the
+// overhead of such a queue isn't worth it.
+template <typename StrToStrMapping>
+std::vector<ViableSubstitution> FindSubstitutions(
+    absl::string_view s, const StrToStrMapping& replacements) {
+  std::vector<ViableSubstitution> subs;
+  subs.reserve(replacements.size());
+
+  for (const auto& rep : replacements) {
+    using std::get;
+    absl::string_view old(get<0>(rep));
+
+    size_t pos = s.find(old);
+    if (pos == s.npos) continue;
+
+    // Ignore attempts to replace "". This condition is almost never true,
+    // but above condition is frequently true. That's why we test for this
+    // now and not before.
+    if (old.empty()) continue;
+
+    subs.emplace_back(old, get<1>(rep), pos);
+
+    // Insertion sort to ensure the last ViableSubstitution comes before
+    // all the others.
+    size_t index = subs.size();
+    while (--index && subs[index - 1].OccursBefore(subs[index])) {
+      std::swap(subs[index], subs[index - 1]);
+    }
+  }
+  return subs;
+}
+
+int ApplySubstitutions(absl::string_view s,
+                       std::vector<ViableSubstitution>* subs_ptr,
+                       std::string* result_ptr);
+
+}  // namespace strings_internal
+
+template <typename StrToStrMapping>
+std::string StrReplaceAll(absl::string_view s,
+                          const StrToStrMapping& replacements) {
+  auto subs = strings_internal::FindSubstitutions(s, replacements);
+  std::string result;
+  result.reserve(s.size());
+  strings_internal::ApplySubstitutions(s, &subs, &result);
+  return result;
+}
+
+template <typename StrToStrMapping>
+int StrReplaceAll(const StrToStrMapping& replacements, std::string* target) {
+  auto subs = strings_internal::FindSubstitutions(*target, replacements);
+  if (subs.empty()) return 0;
+
+  std::string result;
+  result.reserve(target->size());
+  int substitutions =
+      strings_internal::ApplySubstitutions(*target, &subs, &result);
+  target->swap(result);
+  return substitutions;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_STR_REPLACE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_split.h b/CAPI/cpp/grpc/include/absl/strings/str_split.h
new file mode 100644
index 0000000..7bbb68a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/str_split.h
@@ -0,0 +1,547 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_split.h
+// -----------------------------------------------------------------------------
+//
+// This file contains functions for splitting strings. It defines the main
+// `StrSplit()` function, several delimiters for determining the boundaries on
+// which to split the string, and predicates for filtering delimited results.
+// `StrSplit()` adapts the returned collection to the type specified by the
+// caller.
+//
+// Example:
+//
+//   // Splits the given string on commas. Returns the results in a
+//   // vector of strings.
+//   std::vector<std::string> v = absl::StrSplit("a,b,c", ',');
+//   // Can also use ","
+//   // v[0] == "a", v[1] == "b", v[2] == "c"
+//
+// See StrSplit() below for more information.
+#ifndef ABSL_STRINGS_STR_SPLIT_H_
+#define ABSL_STRINGS_STR_SPLIT_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/macros.h"
+#include "absl/strings/internal/str_split_internal.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+//------------------------------------------------------------------------------
+// Delimiters
+//------------------------------------------------------------------------------
+//
+// `StrSplit()` uses delimiters to define the boundaries between elements in the
+// provided input. Several `Delimiter` types are defined below. If a string
+// (`const char*`, `std::string`, or `absl::string_view`) is passed in place of
+// an explicit `Delimiter` object, `StrSplit()` treats it the same way as if it
+// were passed a `ByString` delimiter.
+//
+// A `Delimiter` is an object with a `Find()` function that knows how to find
+// the first occurrence of itself in a given `absl::string_view`.
+//
+// The following `Delimiter` types are available for use within `StrSplit()`:
+//
+//   - `ByString` (default for string arguments)
+//   - `ByChar` (default for a char argument)
+//   - `ByAnyChar`
+//   - `ByLength`
+//   - `MaxSplits`
+//
+// A Delimiter's `Find()` member function will be passed an input `text` that is
+// to be split and a position (`pos`) to begin searching for the next delimiter
+// in `text`. The returned absl::string_view should refer to the next occurrence
+// (after `pos`) of the represented delimiter; this returned absl::string_view
+// represents the next location where the input `text` should be broken.
+//
+// The returned absl::string_view may be zero-length if the Delimiter does not
+// represent a part of the string (e.g., a fixed-length delimiter). If no
+// delimiter is found in the input `text`, a zero-length absl::string_view
+// referring to `text.end()` should be returned (e.g.,
+// `text.substr(text.size())`). It is important that the returned
+// absl::string_view always be within the bounds of the input `text` given as an
+// argument--it must not refer to a string that is physically located outside of
+// the given string.
+//
+// The following example is a simple Delimiter object that is created with a
+// single char and will look for that char in the text passed to the `Find()`
+// function:
+//
+//   struct SimpleDelimiter {
+//     const char c_;
+//     explicit SimpleDelimiter(char c) : c_(c) {}
+//     absl::string_view Find(absl::string_view text, size_t pos) {
+//       auto found = text.find(c_, pos);
+//       if (found == absl::string_view::npos)
+//         return text.substr(text.size());
+//
+//       return text.substr(found, 1);
+//     }
+//   };
+
+// ByString
+//
+// A sub-string delimiter. If `StrSplit()` is passed a string in place of a
+// `Delimiter` object, the string will be implicitly converted into a
+// `ByString` delimiter.
+//
+// Example:
+//
+//   // Because a string literal is converted to an `absl::ByString`,
+//   // the following two splits are equivalent.
+//
+//   std::vector<std::string> v1 = absl::StrSplit("a, b, c", ", ");
+//
+//   using absl::ByString;
+//   std::vector<std::string> v2 = absl::StrSplit("a, b, c",
+//                                                ByString(", "));
+//   // v[0] == "a", v[1] == "b", v[2] == "c"
+class ByString {
+ public:
+  explicit ByString(absl::string_view sp);
+  absl::string_view Find(absl::string_view text, size_t pos) const;
+
+ private:
+  const std::string delimiter_;
+};
+
+// ByChar
+//
+// A single character delimiter. `ByChar` is functionally equivalent to a
+// 1-char string within a `ByString` delimiter, but slightly more efficient.
+//
+// Example:
+//
+//   // Because a char literal is converted to a absl::ByChar,
+//   // the following two splits are equivalent.
+//   std::vector<std::string> v1 = absl::StrSplit("a,b,c", ',');
+//   using absl::ByChar;
+//   std::vector<std::string> v2 = absl::StrSplit("a,b,c", ByChar(','));
+//   // v[0] == "a", v[1] == "b", v[2] == "c"
+//
+// `ByChar` is also the default delimiter if a single character is given
+// as the delimiter to `StrSplit()`. For example, the following calls are
+// equivalent:
+//
+//   std::vector<std::string> v = absl::StrSplit("a-b", '-');
+//
+//   using absl::ByChar;
+//   std::vector<std::string> v = absl::StrSplit("a-b", ByChar('-'));
+//
+class ByChar {
+ public:
+  explicit ByChar(char c) : c_(c) {}
+  absl::string_view Find(absl::string_view text, size_t pos) const;
+
+ private:
+  char c_;
+};
+
+// ByAnyChar
+//
+// A delimiter that will match any of the given byte-sized characters within
+// its provided string.
+//
+// Note: this delimiter works with single-byte string data, but does not work
+// with variable-width encodings, such as UTF-8.
+//
+// Example:
+//
+//   using absl::ByAnyChar;
+//   std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
+//   // v[0] == "a", v[1] == "b", v[2] == "c"
+//
+// If `ByAnyChar` is given the empty string, it behaves exactly like
+// `ByString` and matches each individual character in the input string.
+//
+class ByAnyChar {
+ public:
+  explicit ByAnyChar(absl::string_view sp);
+  absl::string_view Find(absl::string_view text, size_t pos) const;
+
+ private:
+  const std::string delimiters_;
+};
+
+// ByLength
+//
+// A delimiter for splitting into equal-length strings. The length argument to
+// the constructor must be greater than 0.
+//
+// Note: this delimiter works with single-byte string data, but does not work
+// with variable-width encodings, such as UTF-8.
+//
+// Example:
+//
+//   using absl::ByLength;
+//   std::vector<std::string> v = absl::StrSplit("123456789", ByLength(3));
+
+//   // v[0] == "123", v[1] == "456", v[2] == "789"
+//
+// Note that the string does not have to be a multiple of the fixed split
+// length. In such a case, the last substring will be shorter.
+//
+//   using absl::ByLength;
+//   std::vector<std::string> v = absl::StrSplit("12345", ByLength(2));
+//
+//   // v[0] == "12", v[1] == "34", v[2] == "5"
+class ByLength {
+ public:
+  explicit ByLength(ptrdiff_t length);
+  absl::string_view Find(absl::string_view text, size_t pos) const;
+
+ private:
+  const ptrdiff_t length_;
+};
+
+namespace strings_internal {
+
+// A traits-like metafunction for selecting the default Delimiter object type
+// for a particular Delimiter type. The base case simply exposes type Delimiter
+// itself as the delimiter's Type. However, there are specializations for
+// string-like objects that map them to the ByString delimiter object.
+// This allows functions like absl::StrSplit() and absl::MaxSplits() to accept
+// string-like objects (e.g., ',') as delimiter arguments but they will be
+// treated as if a ByString delimiter was given.
+template <typename Delimiter>
+struct SelectDelimiter {
+  using type = Delimiter;
+};
+
+template <>
+struct SelectDelimiter<char> {
+  using type = ByChar;
+};
+template <>
+struct SelectDelimiter<char*> {
+  using type = ByString;
+};
+template <>
+struct SelectDelimiter<const char*> {
+  using type = ByString;
+};
+template <>
+struct SelectDelimiter<absl::string_view> {
+  using type = ByString;
+};
+template <>
+struct SelectDelimiter<std::string> {
+  using type = ByString;
+};
+
+// Wraps another delimiter and sets a max number of matches for that delimiter.
+template <typename Delimiter>
+class MaxSplitsImpl {
+ public:
+  MaxSplitsImpl(Delimiter delimiter, int limit)
+      : delimiter_(delimiter), limit_(limit), count_(0) {}
+  absl::string_view Find(absl::string_view text, size_t pos) {
+    if (count_++ == limit_) {
+      return absl::string_view(text.data() + text.size(),
+                               0);  // No more matches.
+    }
+    return delimiter_.Find(text, pos);
+  }
+
+ private:
+  Delimiter delimiter_;
+  const int limit_;
+  int count_;
+};
+
+}  // namespace strings_internal
+
+// MaxSplits()
+//
+// A delimiter that limits the number of matches which can occur to the passed
+// `limit`. The last element in the returned collection will contain all
+// remaining unsplit pieces, which may contain instances of the delimiter.
+// The collection will contain at most `limit` + 1 elements.
+// Example:
+//
+//   using absl::MaxSplits;
+//   std::vector<std::string> v = absl::StrSplit("a,b,c", MaxSplits(',', 1));
+//
+//   // v[0] == "a", v[1] == "b,c"
+template <typename Delimiter>
+inline strings_internal::MaxSplitsImpl<
+    typename strings_internal::SelectDelimiter<Delimiter>::type>
+MaxSplits(Delimiter delimiter, int limit) {
+  typedef
+      typename strings_internal::SelectDelimiter<Delimiter>::type DelimiterType;
+  return strings_internal::MaxSplitsImpl<DelimiterType>(
+      DelimiterType(delimiter), limit);
+}
+
+//------------------------------------------------------------------------------
+// Predicates
+//------------------------------------------------------------------------------
+//
+// Predicates filter the results of a `StrSplit()` by determining whether or not
+// a resultant element is included in the result set. A predicate may be passed
+// as an optional third argument to the `StrSplit()` function.
+//
+// Predicates are unary functions (or functors) that take a single
+// `absl::string_view` argument and return a bool indicating whether the
+// argument should be included (`true`) or excluded (`false`).
+//
+// Predicates are useful when filtering out empty substrings. By default, empty
+// substrings may be returned by `StrSplit()`, which is similar to the way split
+// functions work in other programming languages.
+
+// AllowEmpty()
+//
+// Always returns `true`, indicating that all strings--including empty
+// strings--should be included in the split output. This predicate is not
+// strictly needed because this is the default behavior of `StrSplit()`;
+// however, it might be useful at some call sites to make the intent explicit.
+//
+// Example:
+//
+//  std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', AllowEmpty());
+//
+//  // v[0] == " a ", v[1] == " ", v[2] == "", v[3] = "b", v[4] == ""
+struct AllowEmpty {
+  bool operator()(absl::string_view) const { return true; }
+};
+
+// SkipEmpty()
+//
+// Returns `false` if the given `absl::string_view` is empty, indicating that
+// `StrSplit()` should omit the empty string.
+//
+// Example:
+//
+//   std::vector<std::string> v = absl::StrSplit(",a,,b,", ',', SkipEmpty());
+//
+//   // v[0] == "a", v[1] == "b"
+//
+// Note: `SkipEmpty()` does not consider a string containing only whitespace
+// to be empty. To skip such whitespace as well, use the `SkipWhitespace()`
+// predicate.
+struct SkipEmpty {
+  bool operator()(absl::string_view sp) const { return !sp.empty(); }
+};
+
+// SkipWhitespace()
+//
+// Returns `false` if the given `absl::string_view` is empty *or* contains only
+// whitespace, indicating that `StrSplit()` should omit the string.
+//
+// Example:
+//
+//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
+//                                               ',', SkipWhitespace());
+//   // v[0] == " a ", v[1] == "b"
+//
+//   // SkipEmpty() would return whitespace elements
+//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', SkipEmpty());
+//   // v[0] == " a ", v[1] == " ", v[2] == "b"
+struct SkipWhitespace {
+  bool operator()(absl::string_view sp) const {
+    sp = absl::StripAsciiWhitespace(sp);
+    return !sp.empty();
+  }
+};
+
+template <typename T>
+using EnableSplitIfString =
+    typename std::enable_if<std::is_same<T, std::string>::value ||
+                            std::is_same<T, const std::string>::value,
+                            int>::type;
+
+//------------------------------------------------------------------------------
+//                                  StrSplit()
+//------------------------------------------------------------------------------
+
+// StrSplit()
+//
+// Splits a given string based on the provided `Delimiter` object, returning the
+// elements within the type specified by the caller. Optionally, you may pass a
+// `Predicate` to `StrSplit()` indicating whether to include or exclude the
+// resulting element within the final result set. (See the overviews for
+// Delimiters and Predicates above.)
+//
+// Example:
+//
+//   std::vector<std::string> v = absl::StrSplit("a,b,c,d", ',');
+//   // v[0] == "a", v[1] == "b", v[2] == "c", v[3] == "d"
+//
+// You can also provide an explicit `Delimiter` object:
+//
+// Example:
+//
+//   using absl::ByAnyChar;
+//   std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
+//   // v[0] == "a", v[1] == "b", v[2] == "c"
+//
+// See above for more information on delimiters.
+//
+// By default, empty strings are included in the result set. You can optionally
+// include a third `Predicate` argument to apply a test for whether the
+// resultant element should be included in the result set:
+//
+// Example:
+//
+//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
+//                                               ',', SkipWhitespace());
+//   // v[0] == " a ", v[1] == "b"
+//
+// See above for more information on predicates.
+//
+//------------------------------------------------------------------------------
+// StrSplit() Return Types
+//------------------------------------------------------------------------------
+//
+// The `StrSplit()` function adapts the returned collection to the collection
+// specified by the caller (e.g. `std::vector` above). The returned collections
+// may contain `std::string`, `absl::string_view` (in which case the original
+// string being split must ensure that it outlives the collection), or any
+// object that can be explicitly created from an `absl::string_view`. This
+// behavior works for:
+//
+// 1) All standard STL containers including `std::vector`, `std::list`,
+//    `std::deque`, `std::set`,`std::multiset`, 'std::map`, and `std::multimap`
+// 2) `std::pair` (which is not actually a container). See below.
+//
+// Example:
+//
+//   // The results are returned as `absl::string_view` objects. Note that we
+//   // have to ensure that the input string outlives any results.
+//   std::vector<absl::string_view> v = absl::StrSplit("a,b,c", ',');
+//
+//   // Stores results in a std::set<std::string>, which also performs
+//   // de-duplication and orders the elements in ascending order.
+//   std::set<std::string> a = absl::StrSplit("b,a,c,a,b", ',');
+//   // v[0] == "a", v[1] == "b", v[2] = "c"
+//
+//   // `StrSplit()` can be used within a range-based for loop, in which case
+//   // each element will be of type `absl::string_view`.
+//   std::vector<std::string> v;
+//   for (const auto sv : absl::StrSplit("a,b,c", ',')) {
+//     if (sv != "b") v.emplace_back(sv);
+//   }
+//   // v[0] == "a", v[1] == "c"
+//
+//   // Stores results in a map. The map implementation assumes that the input
+//   // is provided as a series of key/value pairs. For example, the 0th element
+//   // resulting from the split will be stored as a key to the 1st element. If
+//   // an odd number of elements are resolved, the last element is paired with
+//   // a default-constructed value (e.g., empty string).
+//   std::map<std::string, std::string> m = absl::StrSplit("a,b,c", ',');
+//   // m["a"] == "b", m["c"] == ""     // last component value equals ""
+//
+// Splitting to `std::pair` is an interesting case because it can hold only two
+// elements and is not a collection type. When splitting to a `std::pair` the
+// first two split strings become the `std::pair` `.first` and `.second`
+// members, respectively. The remaining split substrings are discarded. If there
+// are less than two split substrings, the empty string is used for the
+// corresponding `std::pair` member.
+//
+// Example:
+//
+//   // Stores first two split strings as the members in a std::pair.
+//   std::pair<std::string, std::string> p = absl::StrSplit("a,b,c", ',');
+//   // p.first == "a", p.second == "b"       // "c" is omitted.
+//
+// The `StrSplit()` function can be used multiple times to perform more
+// complicated splitting logic, such as intelligently parsing key-value pairs.
+//
+// Example:
+//
+//   // The input string "a=b=c,d=e,f=,g" becomes
+//   // { "a" => "b=c", "d" => "e", "f" => "", "g" => "" }
+//   std::map<std::string, std::string> m;
+//   for (absl::string_view sp : absl::StrSplit("a=b=c,d=e,f=,g", ',')) {
+//     m.insert(absl::StrSplit(sp, absl::MaxSplits('=', 1)));
+//   }
+//   EXPECT_EQ("b=c", m.find("a")->second);
+//   EXPECT_EQ("e", m.find("d")->second);
+//   EXPECT_EQ("", m.find("f")->second);
+//   EXPECT_EQ("", m.find("g")->second);
+//
+// WARNING: Due to a legacy bug that is maintained for backward compatibility,
+// splitting the following empty string_views produces different results:
+//
+//   absl::StrSplit(absl::string_view(""), '-');  // {""}
+//   absl::StrSplit(absl::string_view(), '-');    // {}, but should be {""}
+//
+// Try not to depend on this distinction because the bug may one day be fixed.
+template <typename Delimiter>
+strings_internal::Splitter<
+    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty,
+    absl::string_view>
+StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
+  using DelimiterType =
+      typename strings_internal::SelectDelimiter<Delimiter>::type;
+  return strings_internal::Splitter<DelimiterType, AllowEmpty,
+                                    absl::string_view>(
+      text.value(), DelimiterType(d), AllowEmpty());
+}
+
+template <typename Delimiter, typename StringType,
+          EnableSplitIfString<StringType> = 0>
+strings_internal::Splitter<
+    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty,
+    std::string>
+StrSplit(StringType&& text, Delimiter d) {
+  using DelimiterType =
+      typename strings_internal::SelectDelimiter<Delimiter>::type;
+  return strings_internal::Splitter<DelimiterType, AllowEmpty, std::string>(
+      std::move(text), DelimiterType(d), AllowEmpty());
+}
+
+template <typename Delimiter, typename Predicate>
+strings_internal::Splitter<
+    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
+    absl::string_view>
+StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d,
+         Predicate p) {
+  using DelimiterType =
+      typename strings_internal::SelectDelimiter<Delimiter>::type;
+  return strings_internal::Splitter<DelimiterType, Predicate,
+                                    absl::string_view>(
+      text.value(), DelimiterType(d), std::move(p));
+}
+
+template <typename Delimiter, typename Predicate, typename StringType,
+          EnableSplitIfString<StringType> = 0>
+strings_internal::Splitter<
+    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
+    std::string>
+StrSplit(StringType&& text, Delimiter d, Predicate p) {
+  using DelimiterType =
+      typename strings_internal::SelectDelimiter<Delimiter>::type;
+  return strings_internal::Splitter<DelimiterType, Predicate, std::string>(
+      std::move(text), DelimiterType(d), std::move(p));
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_STR_SPLIT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/string_view.h b/CAPI/cpp/grpc/include/absl/strings/string_view.h
new file mode 100644
index 0000000..e3239f5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/string_view.h
@@ -0,0 +1,711 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: string_view.h
+// -----------------------------------------------------------------------------
+//
+// This file contains the definition of the `absl::string_view` class. A
+// `string_view` points to a contiguous span of characters, often part or all of
+// another `std::string`, double-quoted string literal, character array, or even
+// another `string_view`.
+//
+// This `absl::string_view` abstraction is designed to be a drop-in
+// replacement for the C++17 `std::string_view` abstraction.
+#ifndef ABSL_STRINGS_STRING_VIEW_H_
+#define ABSL_STRINGS_STRING_VIEW_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <iosfwd>
+#include <iterator>
+#include <limits>
+#include <string>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+
+#ifdef ABSL_USES_STD_STRING_VIEW
+
+#include <string_view>  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using string_view = std::string_view;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_USES_STD_STRING_VIEW
+
+#if ABSL_HAVE_BUILTIN(__builtin_memcmp) ||        \
+    (defined(__GNUC__) && !defined(__clang__)) || \
+    (defined(_MSC_VER) && _MSC_VER >= 1928)
+#define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
+#else  // ABSL_HAVE_BUILTIN(__builtin_memcmp)
+#define ABSL_INTERNAL_STRING_VIEW_MEMCMP memcmp
+#endif  // ABSL_HAVE_BUILTIN(__builtin_memcmp)
+
+#if defined(__cplusplus) && __cplusplus >= 201402L
+#define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR constexpr
+#else
+#define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// absl::string_view
+//
+// A `string_view` provides a lightweight view into the string data provided by
+// a `std::string`, double-quoted string literal, character array, or even
+// another `string_view`. A `string_view` does *not* own the string to which it
+// points, and that data cannot be modified through the view.
+//
+// You can use `string_view` as a function or method parameter anywhere a
+// parameter can receive a double-quoted string literal, `const char*`,
+// `std::string`, or another `absl::string_view` argument with no need to copy
+// the string data. Systematic use of `string_view` within function arguments
+// reduces data copies and `strlen()` calls.
+//
+// Because of its small size, prefer passing `string_view` by value:
+//
+//   void MyFunction(absl::string_view arg);
+//
+// If circumstances require, you may also pass one by const reference:
+//
+//   void MyFunction(const absl::string_view& arg);  // not preferred
+//
+// Passing by value generates slightly smaller code for many architectures.
+//
+// In either case, the source data of the `string_view` must outlive the
+// `string_view` itself.
+//
+// A `string_view` is also suitable for local variables if you know that the
+// lifetime of the underlying object is longer than the lifetime of your
+// `string_view` variable. However, beware of binding a `string_view` to a
+// temporary value:
+//
+//   // BAD use of string_view: lifetime problem
+//   absl::string_view sv = obj.ReturnAString();
+//
+//   // GOOD use of string_view: str outlives sv
+//   std::string str = obj.ReturnAString();
+//   absl::string_view sv = str;
+//
+// Due to lifetime issues, a `string_view` is sometimes a poor choice for a
+// return value and usually a poor choice for a data member. If you do use a
+// `string_view` this way, it is your responsibility to ensure that the object
+// pointed to by the `string_view` outlives the `string_view`.
+//
+// A `string_view` may represent a whole string or just part of a string. For
+// example, when splitting a string, `std::vector<absl::string_view>` is a
+// natural data type for the output.
+//
+// For another example, a Cord is a non-contiguous, potentially very
+// long string-like object.  The Cord class has an interface that iteratively
+// provides string_view objects that point to the successive pieces of a Cord
+// object.
+//
+// When constructed from a source which is NUL-terminated, the `string_view`
+// itself will not include the NUL-terminator unless a specific size (including
+// the NUL) is passed to the constructor. As a result, common idioms that work
+// on NUL-terminated strings do not work on `string_view` objects. If you write
+// code that scans a `string_view`, you must check its length rather than test
+// for nul, for example. Note, however, that nuls may still be embedded within
+// a `string_view` explicitly.
+//
+// You may create a null `string_view` in two ways:
+//
+//   absl::string_view sv;
+//   absl::string_view sv(nullptr, 0);
+//
+// For the above, `sv.data() == nullptr`, `sv.length() == 0`, and
+// `sv.empty() == true`. Also, if you create a `string_view` with a non-null
+// pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to
+// signal an undefined value that is different from other `string_view` values
+// in a similar fashion to how `const char* p1 = nullptr;` is different from
+// `const char* p2 = "";`. However, in practice, it is not recommended to rely
+// on this behavior.
+//
+// Be careful not to confuse a null `string_view` with an empty one. A null
+// `string_view` is an empty `string_view`, but some empty `string_view`s are
+// not null. Prefer checking for emptiness over checking for null.
+//
+// There are many ways to create an empty string_view:
+//
+//   const char* nullcp = nullptr;
+//   // string_view.size() will return 0 in all cases.
+//   absl::string_view();
+//   absl::string_view(nullcp, 0);
+//   absl::string_view("");
+//   absl::string_view("", 0);
+//   absl::string_view("abcdef", 0);
+//   absl::string_view("abcdef" + 6, 0);
+//
+// All empty `string_view` objects whether null or not, are equal:
+//
+//   absl::string_view() == absl::string_view("", 0)
+//   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
+class string_view {
+ public:
+  using traits_type = std::char_traits<char>;
+  using value_type = char;
+  using pointer = char*;
+  using const_pointer = const char*;
+  using reference = char&;
+  using const_reference = const char&;
+  using const_iterator = const char*;
+  using iterator = const_iterator;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  using reverse_iterator = const_reverse_iterator;
+  using size_type = size_t;
+  using difference_type = std::ptrdiff_t;
+
+  static constexpr size_type npos = static_cast<size_type>(-1);
+
+  // Null `string_view` constructor
+  constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
+
+  // Implicit constructors
+
+  template <typename Allocator>
+  string_view(  // NOLINT(runtime/explicit)
+      const std::basic_string<char, std::char_traits<char>, Allocator>& str
+          ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+      // This is implemented in terms of `string_view(p, n)` so `str.size()`
+      // doesn't need to be reevaluated after `ptr_` is set.
+      // The length check is also skipped since it is unnecessary and causes
+      // code bloat.
+      : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
+
+  // Implicit constructor of a `string_view` from NUL-terminated `str`. When
+  // accepting possibly null strings, use `absl::NullSafeStringView(str)`
+  // instead (see below).
+  // The length check is skipped since it is unnecessary and causes code bloat.
+  constexpr string_view(const char* str)  // NOLINT(runtime/explicit)
+      : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
+
+  // Implicit constructor of a `string_view` from a `const char*` and length.
+  constexpr string_view(const char* data, size_type len)
+      : ptr_(data), length_(CheckLengthInternal(len)) {}
+
+  // NOTE: Harmlessly omitted to work around gdb bug.
+  //   constexpr string_view(const string_view&) noexcept = default;
+  //   string_view& operator=(const string_view&) noexcept = default;
+
+  // Iterators
+
+  // string_view::begin()
+  //
+  // Returns an iterator pointing to the first character at the beginning of the
+  // `string_view`, or `end()` if the `string_view` is empty.
+  constexpr const_iterator begin() const noexcept { return ptr_; }
+
+  // string_view::end()
+  //
+  // Returns an iterator pointing just beyond the last character at the end of
+  // the `string_view`. This iterator acts as a placeholder; attempting to
+  // access it results in undefined behavior.
+  constexpr const_iterator end() const noexcept { return ptr_ + length_; }
+
+  // string_view::cbegin()
+  //
+  // Returns a const iterator pointing to the first character at the beginning
+  // of the `string_view`, or `end()` if the `string_view` is empty.
+  constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+  // string_view::cend()
+  //
+  // Returns a const iterator pointing just beyond the last character at the end
+  // of the `string_view`. This pointer acts as a placeholder; attempting to
+  // access its element results in undefined behavior.
+  constexpr const_iterator cend() const noexcept { return end(); }
+
+  // string_view::rbegin()
+  //
+  // Returns a reverse iterator pointing to the last character at the end of the
+  // `string_view`, or `rend()` if the `string_view` is empty.
+  const_reverse_iterator rbegin() const noexcept {
+    return const_reverse_iterator(end());
+  }
+
+  // string_view::rend()
+  //
+  // Returns a reverse iterator pointing just before the first character at the
+  // beginning of the `string_view`. This pointer acts as a placeholder;
+  // attempting to access its element results in undefined behavior.
+  const_reverse_iterator rend() const noexcept {
+    return const_reverse_iterator(begin());
+  }
+
+  // string_view::crbegin()
+  //
+  // Returns a const reverse iterator pointing to the last character at the end
+  // of the `string_view`, or `crend()` if the `string_view` is empty.
+  const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+  // string_view::crend()
+  //
+  // Returns a const reverse iterator pointing just before the first character
+  // at the beginning of the `string_view`. This pointer acts as a placeholder;
+  // attempting to access its element results in undefined behavior.
+  const_reverse_iterator crend() const noexcept { return rend(); }
+
+  // Capacity Utilities
+
+  // string_view::size()
+  //
+  // Returns the number of characters in the `string_view`.
+  constexpr size_type size() const noexcept { return length_; }
+
+  // string_view::length()
+  //
+  // Returns the number of characters in the `string_view`. Alias for `size()`.
+  constexpr size_type length() const noexcept { return size(); }
+
+  // string_view::max_size()
+  //
+  // Returns the maximum number of characters the `string_view` can hold.
+  constexpr size_type max_size() const noexcept { return kMaxSize; }
+
+  // string_view::empty()
+  //
+  // Checks if the `string_view` is empty (refers to no characters).
+  constexpr bool empty() const noexcept { return length_ == 0; }
+
+  // string_view::operator[]
+  //
+  // Returns the ith element of the `string_view` using the array operator.
+  // Note that this operator does not perform any bounds checking.
+  constexpr const_reference operator[](size_type i) const {
+    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
+  }
+
+  // string_view::at()
+  //
+  // Returns the ith element of the `string_view`. Bounds checking is performed,
+  // and an exception of type `std::out_of_range` will be thrown on invalid
+  // access.
+  constexpr const_reference at(size_type i) const {
+    return ABSL_PREDICT_TRUE(i < size())
+               ? ptr_[i]
+               : ((void)base_internal::ThrowStdOutOfRange(
+                      "absl::string_view::at"),
+                  ptr_[i]);
+  }
+
+  // string_view::front()
+  //
+  // Returns the first element of a `string_view`.
+  constexpr const_reference front() const {
+    return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
+  }
+
+  // string_view::back()
+  //
+  // Returns the last element of a `string_view`.
+  constexpr const_reference back() const {
+    return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
+  }
+
+  // string_view::data()
+  //
+  // Returns a pointer to the underlying character array (which is of course
+  // stored elsewhere). Note that `string_view::data()` may contain embedded nul
+  // characters, but the returned buffer may or may not be NUL-terminated;
+  // therefore, do not pass `data()` to a routine that expects a NUL-terminated
+  // string.
+  constexpr const_pointer data() const noexcept { return ptr_; }
+
+  // Modifiers
+
+  // string_view::remove_prefix()
+  //
+  // Removes the first `n` characters from the `string_view`. Note that the
+  // underlying string is not changed, only the view.
+  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_prefix(size_type n) {
+    ABSL_HARDENING_ASSERT(n <= length_);
+    ptr_ += n;
+    length_ -= n;
+  }
+
+  // string_view::remove_suffix()
+  //
+  // Removes the last `n` characters from the `string_view`. Note that the
+  // underlying string is not changed, only the view.
+  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_suffix(size_type n) {
+    ABSL_HARDENING_ASSERT(n <= length_);
+    length_ -= n;
+  }
+
+  // string_view::swap()
+  //
+  // Swaps this `string_view` with another `string_view`.
+  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void swap(string_view& s) noexcept {
+    auto t = *this;
+    *this = s;
+    s = t;
+  }
+
+  // Explicit conversion operators
+
+  // Converts to `std::basic_string`.
+  template <typename A>
+  explicit operator std::basic_string<char, traits_type, A>() const {
+    if (!data()) return {};
+    return std::basic_string<char, traits_type, A>(data(), size());
+  }
+
+  // string_view::copy()
+  //
+  // Copies the contents of the `string_view` at offset `pos` and length `n`
+  // into `buf`.
+  size_type copy(char* buf, size_type n, size_type pos = 0) const {
+    if (ABSL_PREDICT_FALSE(pos > length_)) {
+      base_internal::ThrowStdOutOfRange("absl::string_view::copy");
+    }
+    size_type rlen = (std::min)(length_ - pos, n);
+    if (rlen > 0) {
+      const char* start = ptr_ + pos;
+      traits_type::copy(buf, start, rlen);
+    }
+    return rlen;
+  }
+
+  // string_view::substr()
+  //
+  // Returns a "substring" of the `string_view` (at offset `pos` and length
+  // `n`) as another string_view. This function throws `std::out_of_bounds` if
+  // `pos > size`.
+  // Use absl::ClippedSubstr if you need a truncating substr operation.
+  constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
+    return ABSL_PREDICT_FALSE(pos > length_)
+               ? (base_internal::ThrowStdOutOfRange(
+                      "absl::string_view::substr"),
+                  string_view())
+               : string_view(ptr_ + pos, Min(n, length_ - pos));
+  }
+
+  // string_view::compare()
+  //
+  // Performs a lexicographical comparison between this `string_view` and
+  // another `string_view` `x`, returning a negative value if `*this` is less
+  // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this`
+  // is greater than `x`.
+  constexpr int compare(string_view x) const noexcept {
+    return CompareImpl(length_, x.length_,
+                       Min(length_, x.length_) == 0
+                           ? 0
+                           : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
+                                 ptr_, x.ptr_, Min(length_, x.length_)));
+  }
+
+  // Overload of `string_view::compare()` for comparing a substring of the
+  // 'string_view` and another `absl::string_view`.
+  constexpr int compare(size_type pos1, size_type count1, string_view v) const {
+    return substr(pos1, count1).compare(v);
+  }
+
+  // Overload of `string_view::compare()` for comparing a substring of the
+  // `string_view` and a substring of another `absl::string_view`.
+  constexpr int compare(size_type pos1, size_type count1, string_view v,
+                        size_type pos2, size_type count2) const {
+    return substr(pos1, count1).compare(v.substr(pos2, count2));
+  }
+
+  // Overload of `string_view::compare()` for comparing a `string_view` and a
+  // a different C-style string `s`.
+  constexpr int compare(const char* s) const { return compare(string_view(s)); }
+
+  // Overload of `string_view::compare()` for comparing a substring of the
+  // `string_view` and a different string C-style string `s`.
+  constexpr int compare(size_type pos1, size_type count1, const char* s) const {
+    return substr(pos1, count1).compare(string_view(s));
+  }
+
+  // Overload of `string_view::compare()` for comparing a substring of the
+  // `string_view` and a substring of a different C-style string `s`.
+  constexpr int compare(size_type pos1, size_type count1, const char* s,
+                        size_type count2) const {
+    return substr(pos1, count1).compare(string_view(s, count2));
+  }
+
+  // Find Utilities
+
+  // string_view::find()
+  //
+  // Finds the first occurrence of the substring `s` within the `string_view`,
+  // returning the position of the first character's match, or `npos` if no
+  // match was found.
+  size_type find(string_view s, size_type pos = 0) const noexcept;
+
+  // Overload of `string_view::find()` for finding the given character `c`
+  // within the `string_view`.
+  size_type find(char c, size_type pos = 0) const noexcept;
+
+  // Overload of `string_view::find()` for finding a substring of a different
+  // C-style string `s` within the `string_view`.
+  size_type find(const char* s, size_type pos, size_type count) const {
+    return find(string_view(s, count), pos);
+  }
+
+  // Overload of `string_view::find()` for finding a different C-style string
+  // `s` within the `string_view`.
+  size_type find(const char* s, size_type pos = 0) const {
+    return find(string_view(s), pos);
+  }
+
+  // string_view::rfind()
+  //
+  // Finds the last occurrence of a substring `s` within the `string_view`,
+  // returning the position of the first character's match, or `npos` if no
+  // match was found.
+  size_type rfind(string_view s, size_type pos = npos) const noexcept;
+
+  // Overload of `string_view::rfind()` for finding the last given character `c`
+  // within the `string_view`.
+  size_type rfind(char c, size_type pos = npos) const noexcept;
+
+  // Overload of `string_view::rfind()` for finding a substring of a different
+  // C-style string `s` within the `string_view`.
+  size_type rfind(const char* s, size_type pos, size_type count) const {
+    return rfind(string_view(s, count), pos);
+  }
+
+  // Overload of `string_view::rfind()` for finding a different C-style string
+  // `s` within the `string_view`.
+  size_type rfind(const char* s, size_type pos = npos) const {
+    return rfind(string_view(s), pos);
+  }
+
+  // string_view::find_first_of()
+  //
+  // Finds the first occurrence of any of the characters in `s` within the
+  // `string_view`, returning the start position of the match, or `npos` if no
+  // match was found.
+  size_type find_first_of(string_view s, size_type pos = 0) const noexcept;
+
+  // Overload of `string_view::find_first_of()` for finding a character `c`
+  // within the `string_view`.
+  size_type find_first_of(char c, size_type pos = 0) const noexcept {
+    return find(c, pos);
+  }
+
+  // Overload of `string_view::find_first_of()` for finding a substring of a
+  // different C-style string `s` within the `string_view`.
+  size_type find_first_of(const char* s, size_type pos,
+                                    size_type count) const {
+    return find_first_of(string_view(s, count), pos);
+  }
+
+  // Overload of `string_view::find_first_of()` for finding a different C-style
+  // string `s` within the `string_view`.
+  size_type find_first_of(const char* s, size_type pos = 0) const {
+    return find_first_of(string_view(s), pos);
+  }
+
+  // string_view::find_last_of()
+  //
+  // Finds the last occurrence of any of the characters in `s` within the
+  // `string_view`, returning the start position of the match, or `npos` if no
+  // match was found.
+  size_type find_last_of(string_view s, size_type pos = npos) const noexcept;
+
+  // Overload of `string_view::find_last_of()` for finding a character `c`
+  // within the `string_view`.
+  size_type find_last_of(char c, size_type pos = npos) const noexcept {
+    return rfind(c, pos);
+  }
+
+  // Overload of `string_view::find_last_of()` for finding a substring of a
+  // different C-style string `s` within the `string_view`.
+  size_type find_last_of(const char* s, size_type pos, size_type count) const {
+    return find_last_of(string_view(s, count), pos);
+  }
+
+  // Overload of `string_view::find_last_of()` for finding a different C-style
+  // string `s` within the `string_view`.
+  size_type find_last_of(const char* s, size_type pos = npos) const {
+    return find_last_of(string_view(s), pos);
+  }
+
+  // string_view::find_first_not_of()
+  //
+  // Finds the first occurrence of any of the characters not in `s` within the
+  // `string_view`, returning the start position of the first non-match, or
+  // `npos` if no non-match was found.
+  size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;
+
+  // Overload of `string_view::find_first_not_of()` for finding a character
+  // that is not `c` within the `string_view`.
+  size_type find_first_not_of(char c, size_type pos = 0) const noexcept;
+
+  // Overload of `string_view::find_first_not_of()` for finding a substring of a
+  // different C-style string `s` within the `string_view`.
+  size_type find_first_not_of(const char* s, size_type pos,
+                              size_type count) const {
+    return find_first_not_of(string_view(s, count), pos);
+  }
+
+  // Overload of `string_view::find_first_not_of()` for finding a different
+  // C-style string `s` within the `string_view`.
+  size_type find_first_not_of(const char* s, size_type pos = 0) const {
+    return find_first_not_of(string_view(s), pos);
+  }
+
+  // string_view::find_last_not_of()
+  //
+  // Finds the last occurrence of any of the characters not in `s` within the
+  // `string_view`, returning the start position of the last non-match, or
+  // `npos` if no non-match was found.
+  size_type find_last_not_of(string_view s,
+                             size_type pos = npos) const noexcept;
+
+  // Overload of `string_view::find_last_not_of()` for finding a character
+  // that is not `c` within the `string_view`.
+  size_type find_last_not_of(char c, size_type pos = npos) const noexcept;
+
+  // Overload of `string_view::find_last_not_of()` for finding a substring of a
+  // different C-style string `s` within the `string_view`.
+  size_type find_last_not_of(const char* s, size_type pos,
+                             size_type count) const {
+    return find_last_not_of(string_view(s, count), pos);
+  }
+
+  // Overload of `string_view::find_last_not_of()` for finding a different
+  // C-style string `s` within the `string_view`.
+  size_type find_last_not_of(const char* s, size_type pos = npos) const {
+    return find_last_not_of(string_view(s), pos);
+  }
+
+ private:
+  // The constructor from std::string delegates to this constructor.
+  // See the comment on that constructor for the rationale.
+  struct SkipCheckLengthTag {};
+  string_view(const char* data, size_type len, SkipCheckLengthTag) noexcept
+      : ptr_(data), length_(len) {}
+
+  static constexpr size_type kMaxSize =
+      (std::numeric_limits<difference_type>::max)();
+
+  static constexpr size_type CheckLengthInternal(size_type len) {
+    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
+  }
+
+  static constexpr size_type StrlenInternal(const char* str) {
+#if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__)
+    // MSVC 2017+ can evaluate this at compile-time.
+    const char* begin = str;
+    while (*str != '\0') ++str;
+    return str - begin;
+#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    // GCC has __builtin_strlen according to
+    // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
+    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
+    // __builtin_strlen is constexpr.
+    return __builtin_strlen(str);
+#else
+    return str ? strlen(str) : 0;
+#endif
+  }
+
+  static constexpr size_t Min(size_type length_a, size_type length_b) {
+    return length_a < length_b ? length_a : length_b;
+  }
+
+  static constexpr int CompareImpl(size_type length_a, size_type length_b,
+                                   int compare_result) {
+    return compare_result == 0 ? static_cast<int>(length_a > length_b) -
+                                     static_cast<int>(length_a < length_b)
+                               : (compare_result < 0 ? -1 : 1);
+  }
+
+  const char* ptr_;
+  size_type length_;
+};
+
+// This large function is defined inline so that in a fairly common case where
+// one of the arguments is a literal, the compiler can elide a lot of the
+// following comparisons.
+constexpr bool operator==(string_view x, string_view y) noexcept {
+  return x.size() == y.size() &&
+         (x.empty() ||
+          ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
+}
+
+constexpr bool operator!=(string_view x, string_view y) noexcept {
+  return !(x == y);
+}
+
+constexpr bool operator<(string_view x, string_view y) noexcept {
+  return x.compare(y) < 0;
+}
+
+constexpr bool operator>(string_view x, string_view y) noexcept {
+  return y < x;
+}
+
+constexpr bool operator<=(string_view x, string_view y) noexcept {
+  return !(y < x);
+}
+
+constexpr bool operator>=(string_view x, string_view y) noexcept {
+  return !(x < y);
+}
+
+// IO Insertion Operator
+std::ostream& operator<<(std::ostream& o, string_view piece);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#undef ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
+#undef ABSL_INTERNAL_STRING_VIEW_MEMCMP
+
+#endif  // ABSL_USES_STD_STRING_VIEW
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// ClippedSubstr()
+//
+// Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
+// Provided because std::string_view::substr throws if `pos > size()`
+inline string_view ClippedSubstr(string_view s, size_t pos,
+                                 size_t n = string_view::npos) {
+  pos = (std::min)(pos, static_cast<size_t>(s.size()));
+  return s.substr(pos, n);
+}
+
+// NullSafeStringView()
+//
+// Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
+// This function should be used where an `absl::string_view` can be created from
+// a possibly-null pointer.
+constexpr string_view NullSafeStringView(const char* p) {
+  return p ? string_view(p) : string_view();
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_STRING_VIEW_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/strip.h b/CAPI/cpp/grpc/include/absl/strings/strip.h
new file mode 100644
index 0000000..341e66f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/strip.h
@@ -0,0 +1,93 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: strip.h
+// -----------------------------------------------------------------------------
+//
+// This file contains various functions for stripping substrings from a string.
+#ifndef ABSL_STRINGS_STRIP_H_
+#define ABSL_STRINGS_STRIP_H_
+
+#include <cstddef>
+#include <string>
+
+#include "absl/base/macros.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// ConsumePrefix()
+//
+// Strips the `expected` prefix, if found, from the start of `str`.
+// If the operation succeeded, `true` is returned.  If not, `false`
+// is returned and `str` is not modified.
+//
+// Example:
+//
+//   absl::string_view input("abc");
+//   EXPECT_TRUE(absl::ConsumePrefix(&input, "a"));
+//   EXPECT_EQ(input, "bc");
+inline bool ConsumePrefix(absl::string_view* str, absl::string_view expected) {
+  if (!absl::StartsWith(*str, expected)) return false;
+  str->remove_prefix(expected.size());
+  return true;
+}
+// ConsumeSuffix()
+//
+// Strips the `expected` suffix, if found, from the end of `str`.
+// If the operation succeeded, `true` is returned.  If not, `false`
+// is returned and `str` is not modified.
+//
+// Example:
+//
+//   absl::string_view input("abcdef");
+//   EXPECT_TRUE(absl::ConsumeSuffix(&input, "def"));
+//   EXPECT_EQ(input, "abc");
+inline bool ConsumeSuffix(absl::string_view* str, absl::string_view expected) {
+  if (!absl::EndsWith(*str, expected)) return false;
+  str->remove_suffix(expected.size());
+  return true;
+}
+
+// StripPrefix()
+//
+// Returns a view into the input string `str` with the given `prefix` removed,
+// but leaving the original string intact. If the prefix does not match at the
+// start of the string, returns the original string instead.
+ABSL_MUST_USE_RESULT inline absl::string_view StripPrefix(
+    absl::string_view str, absl::string_view prefix) {
+  if (absl::StartsWith(str, prefix)) str.remove_prefix(prefix.size());
+  return str;
+}
+
+// StripSuffix()
+//
+// Returns a view into the input string `str` with the given `suffix` removed,
+// but leaving the original string intact. If the suffix does not match at the
+// end of the string, returns the original string instead.
+ABSL_MUST_USE_RESULT inline absl::string_view StripSuffix(
+    absl::string_view str, absl::string_view suffix) {
+  if (absl::EndsWith(str, suffix)) str.remove_suffix(suffix.size());
+  return str;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_STRIP_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/substitute.h b/CAPI/cpp/grpc/include/absl/strings/substitute.h
new file mode 100644
index 0000000..6d2b08a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/strings/substitute.h
@@ -0,0 +1,729 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: substitute.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions for efficiently performing string
+// substitutions using a format string with positional notation:
+// `Substitute()` and `SubstituteAndAppend()`.
+//
+// Unlike printf-style format specifiers, `Substitute()` functions do not need
+// to specify the type of the substitution arguments. Supported arguments
+// following the format string, such as strings, string_views, ints,
+// floats, and bools, are automatically converted to strings during the
+// substitution process. (See below for a full list of supported types.)
+//
+// `Substitute()` does not allow you to specify *how* to format a value, beyond
+// the default conversion to string. For example, you cannot format an integer
+// in hex.
+//
+// The format string uses positional identifiers indicated by a dollar sign ($)
+// and single digit positional ids to indicate which substitution arguments to
+// use at that location within the format string.
+//
+// A '$$' sequence in the format string causes a literal '$' character to be
+// output.
+//
+// Example 1:
+//   std::string s = Substitute("$1 purchased $0 $2 for $$10. Thanks $1!",
+//                              5, "Bob", "Apples");
+//   EXPECT_EQ("Bob purchased 5 Apples for $10. Thanks Bob!", s);
+//
+// Example 2:
+//   std::string s = "Hi. ";
+//   SubstituteAndAppend(&s, "My name is $0 and I am $1 years old.", "Bob", 5);
+//   EXPECT_EQ("Hi. My name is Bob and I am 5 years old.", s);
+//
+// Supported types:
+//   * absl::string_view, std::string, const char* (null is equivalent to "")
+//   * int32_t, int64_t, uint32_t, uint64_t
+//   * float, double
+//   * bool (Printed as "true" or "false")
+//   * pointer types other than char* (Printed as "0x<lower case hex string>",
+//     except that null is printed as "NULL")
+//
+// If an invalid format string is provided, Substitute returns an empty string
+// and SubstituteAndAppend does not change the provided output string.
+// A format string is invalid if it:
+//   * ends in an unescaped $ character,
+//     e.g. "Hello $", or
+//   * calls for a position argument which is not provided,
+//     e.g. Substitute("Hello $2", "world"), or
+//   * specifies a non-digit, non-$ character after an unescaped $ character,
+//     e.g. "Hello $f".
+// In debug mode, i.e. #ifndef NDEBUG, such errors terminate the program.
+
+#ifndef ABSL_STRINGS_SUBSTITUTE_H_
+#define ABSL_STRINGS_SUBSTITUTE_H_
+
+#include <cstring>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace substitute_internal {
+
+// Arg
+//
+// This class provides an argument type for `absl::Substitute()` and
+// `absl::SubstituteAndAppend()`. `Arg` handles implicit conversion of various
+// types to a string. (`Arg` is very similar to the `AlphaNum` class in
+// `StrCat()`.)
+//
+// This class has implicit constructors.
+class Arg {
+ public:
+  // Overloads for string-y things
+  //
+  // Explicitly overload `const char*` so the compiler doesn't cast to `bool`.
+  Arg(const char* value)  // NOLINT(runtime/explicit)
+      : piece_(absl::NullSafeStringView(value)) {}
+  template <typename Allocator>
+  Arg(  // NOLINT
+      const std::basic_string<char, std::char_traits<char>, Allocator>&
+          value) noexcept
+      : piece_(value) {}
+  Arg(absl::string_view value)  // NOLINT(runtime/explicit)
+      : piece_(value) {}
+
+  // Overloads for primitives
+  //
+  // No overloads are available for signed and unsigned char because if people
+  // are explicitly declaring their chars as signed or unsigned then they are
+  // probably using them as 8-bit integers and would probably prefer an integer
+  // representation. However, we can't really know, so we make the caller decide
+  // what to do.
+  Arg(char value)  // NOLINT(runtime/explicit)
+      : piece_(scratch_, 1) {
+    scratch_[0] = value;
+  }
+  Arg(short value)  // NOLINT(*)
+      : piece_(scratch_,
+               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+  Arg(unsigned short value)  // NOLINT(*)
+      : piece_(scratch_,
+               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+  Arg(int value)  // NOLINT(runtime/explicit)
+      : piece_(scratch_,
+               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+  Arg(unsigned int value)  // NOLINT(runtime/explicit)
+      : piece_(scratch_,
+               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+  Arg(long value)  // NOLINT(*)
+      : piece_(scratch_,
+               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+  Arg(unsigned long value)  // NOLINT(*)
+      : piece_(scratch_,
+               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+  Arg(long long value)  // NOLINT(*)
+      : piece_(scratch_,
+               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+  Arg(unsigned long long value)  // NOLINT(*)
+      : piece_(scratch_,
+               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+  Arg(float value)  // NOLINT(runtime/explicit)
+      : piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
+  }
+  Arg(double value)  // NOLINT(runtime/explicit)
+      : piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
+  }
+  Arg(bool value)  // NOLINT(runtime/explicit)
+      : piece_(value ? "true" : "false") {}
+
+  Arg(Hex hex);  // NOLINT(runtime/explicit)
+  Arg(Dec dec);  // NOLINT(runtime/explicit)
+
+  // vector<bool>::reference and const_reference require special help to convert
+  // to `Arg` because it requires two user defined conversions.
+  template <typename T,
+            absl::enable_if_t<
+                std::is_class<T>::value &&
+                (std::is_same<T, std::vector<bool>::reference>::value ||
+                 std::is_same<T, std::vector<bool>::const_reference>::value)>* =
+                nullptr>
+  Arg(T value)  // NOLINT(google-explicit-constructor)
+      : Arg(static_cast<bool>(value)) {}
+
+  // `void*` values, with the exception of `char*`, are printed as
+  // "0x<hex value>". However, in the case of `nullptr`, "NULL" is printed.
+  Arg(const void* value);  // NOLINT(runtime/explicit)
+
+  // Normal enums are already handled by the integer formatters.
+  // This overload matches only scoped enums.
+  template <typename T,
+            typename = typename std::enable_if<
+                std::is_enum<T>{} && !std::is_convertible<T, int>{}>::type>
+  Arg(T value)  // NOLINT(google-explicit-constructor)
+      : Arg(static_cast<typename std::underlying_type<T>::type>(value)) {}
+
+  Arg(const Arg&) = delete;
+  Arg& operator=(const Arg&) = delete;
+
+  absl::string_view piece() const { return piece_; }
+
+ private:
+  absl::string_view piece_;
+  char scratch_[numbers_internal::kFastToBufferSize];
+};
+
+// Internal helper function. Don't call this from outside this implementation.
+// This interface may change without notice.
+void SubstituteAndAppendArray(std::string* output, absl::string_view format,
+                              const absl::string_view* args_array,
+                              size_t num_args);
+
+#if defined(ABSL_BAD_CALL_IF)
+constexpr int CalculateOneBit(const char* format) {
+  // Returns:
+  // * 2^N for '$N' when N is in [0-9]
+  // * 0 for correct '$' escaping: '$$'.
+  // * -1 otherwise.
+  return (*format < '0' || *format > '9') ? (*format == '$' ? 0 : -1)
+                                          : (1 << (*format - '0'));
+}
+
+constexpr const char* SkipNumber(const char* format) {
+  return !*format ? format : (format + 1);
+}
+
+constexpr int PlaceholderBitmask(const char* format) {
+  return !*format
+             ? 0
+             : *format != '$' ? PlaceholderBitmask(format + 1)
+                              : (CalculateOneBit(format + 1) |
+                                 PlaceholderBitmask(SkipNumber(format + 1)));
+}
+#endif  // ABSL_BAD_CALL_IF
+
+}  // namespace substitute_internal
+
+//
+// PUBLIC API
+//
+
+// SubstituteAndAppend()
+//
+// Substitutes variables into a given format string and appends to a given
+// output string. See file comments above for usage.
+//
+// The declarations of `SubstituteAndAppend()` below consist of overloads
+// for passing 0 to 10 arguments, respectively.
+//
+// NOTE: A zero-argument `SubstituteAndAppend()` may be used within variadic
+// templates to allow a variable number of arguments.
+//
+// Example:
+//  template <typename... Args>
+//  void VarMsg(std::string* boilerplate, absl::string_view format,
+//      const Args&... args) {
+//    absl::SubstituteAndAppend(boilerplate, format, args...);
+//  }
+//
+inline void SubstituteAndAppend(std::string* output, absl::string_view format) {
+  substitute_internal::SubstituteAndAppendArray(output, format, nullptr, 0);
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+                                const substitute_internal::Arg& a0) {
+  const absl::string_view args[] = {a0.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+                                const substitute_internal::Arg& a0,
+                                const substitute_internal::Arg& a1) {
+  const absl::string_view args[] = {a0.piece(), a1.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+                                const substitute_internal::Arg& a0,
+                                const substitute_internal::Arg& a1,
+                                const substitute_internal::Arg& a2) {
+  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+                                const substitute_internal::Arg& a0,
+                                const substitute_internal::Arg& a1,
+                                const substitute_internal::Arg& a2,
+                                const substitute_internal::Arg& a3) {
+  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+                                    a3.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+                                const substitute_internal::Arg& a0,
+                                const substitute_internal::Arg& a1,
+                                const substitute_internal::Arg& a2,
+                                const substitute_internal::Arg& a3,
+                                const substitute_internal::Arg& a4) {
+  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+                                    a3.piece(), a4.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+                                const substitute_internal::Arg& a0,
+                                const substitute_internal::Arg& a1,
+                                const substitute_internal::Arg& a2,
+                                const substitute_internal::Arg& a3,
+                                const substitute_internal::Arg& a4,
+                                const substitute_internal::Arg& a5) {
+  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+                                    a3.piece(), a4.piece(), a5.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+                                const substitute_internal::Arg& a0,
+                                const substitute_internal::Arg& a1,
+                                const substitute_internal::Arg& a2,
+                                const substitute_internal::Arg& a3,
+                                const substitute_internal::Arg& a4,
+                                const substitute_internal::Arg& a5,
+                                const substitute_internal::Arg& a6) {
+  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+                                    a3.piece(), a4.piece(), a5.piece(),
+                                    a6.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(
+    std::string* output, absl::string_view format,
+    const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
+    const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
+    const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
+    const substitute_internal::Arg& a6, const substitute_internal::Arg& a7) {
+  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+                                    a3.piece(), a4.piece(), a5.piece(),
+                                    a6.piece(), a7.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(
+    std::string* output, absl::string_view format,
+    const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
+    const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
+    const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
+    const substitute_internal::Arg& a6, const substitute_internal::Arg& a7,
+    const substitute_internal::Arg& a8) {
+  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+                                    a3.piece(), a4.piece(), a5.piece(),
+                                    a6.piece(), a7.piece(), a8.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(
+    std::string* output, absl::string_view format,
+    const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
+    const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
+    const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
+    const substitute_internal::Arg& a6, const substitute_internal::Arg& a7,
+    const substitute_internal::Arg& a8, const substitute_internal::Arg& a9) {
+  const absl::string_view args[] = {
+      a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(),
+      a5.piece(), a6.piece(), a7.piece(), a8.piece(), a9.piece()};
+  substitute_internal::SubstituteAndAppendArray(output, format, args,
+                                                ABSL_ARRAYSIZE(args));
+}
+
+#if defined(ABSL_BAD_CALL_IF)
+// This body of functions catches cases where the number of placeholders
+// doesn't match the number of data arguments.
+void SubstituteAndAppend(std::string* output, const char* format)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 0,
+        "There were no substitution arguments "
+        "but this format string either has a $[0-9] in it or contains "
+        "an unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+                         const substitute_internal::Arg& a0)
+    ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1,
+                     "There was 1 substitution argument given, but "
+                     "this format string is missing its $0, contains "
+                     "one of $1-$9, or contains an unescaped $ character (use "
+                     "$$ instead)");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+                         const substitute_internal::Arg& a0,
+                         const substitute_internal::Arg& a1)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 3,
+        "There were 2 substitution arguments given, but this format string is "
+        "missing its $0/$1, contains one of $2-$9, or contains an "
+        "unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+                         const substitute_internal::Arg& a0,
+                         const substitute_internal::Arg& a1,
+                         const substitute_internal::Arg& a2)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 7,
+        "There were 3 substitution arguments given, but "
+        "this format string is missing its $0/$1/$2, contains one of "
+        "$3-$9, or contains an unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+                         const substitute_internal::Arg& a0,
+                         const substitute_internal::Arg& a1,
+                         const substitute_internal::Arg& a2,
+                         const substitute_internal::Arg& a3)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 15,
+        "There were 4 substitution arguments given, but "
+        "this format string is missing its $0-$3, contains one of "
+        "$4-$9, or contains an unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+                         const substitute_internal::Arg& a0,
+                         const substitute_internal::Arg& a1,
+                         const substitute_internal::Arg& a2,
+                         const substitute_internal::Arg& a3,
+                         const substitute_internal::Arg& a4)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 31,
+        "There were 5 substitution arguments given, but "
+        "this format string is missing its $0-$4, contains one of "
+        "$5-$9, or contains an unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+                         const substitute_internal::Arg& a0,
+                         const substitute_internal::Arg& a1,
+                         const substitute_internal::Arg& a2,
+                         const substitute_internal::Arg& a3,
+                         const substitute_internal::Arg& a4,
+                         const substitute_internal::Arg& a5)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 63,
+        "There were 6 substitution arguments given, but "
+        "this format string is missing its $0-$5, contains one of "
+        "$6-$9, or contains an unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(
+    std::string* output, const char* format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 127,
+        "There were 7 substitution arguments given, but "
+        "this format string is missing its $0-$6, contains one of "
+        "$7-$9, or contains an unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(
+    std::string* output, const char* format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+    const substitute_internal::Arg& a7)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 255,
+        "There were 8 substitution arguments given, but "
+        "this format string is missing its $0-$7, contains one of "
+        "$8-$9, or contains an unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(
+    std::string* output, const char* format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 511,
+        "There were 9 substitution arguments given, but "
+        "this format string is missing its $0-$8, contains a $9, or "
+        "contains an unescaped $ character (use $$ instead)");
+
+void SubstituteAndAppend(
+    std::string* output, const char* format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
+    const substitute_internal::Arg& a9)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 1023,
+        "There were 10 substitution arguments given, but this "
+        "format string either doesn't contain all of $0 through $9 or "
+        "contains an unescaped $ character (use $$ instead)");
+#endif  // ABSL_BAD_CALL_IF
+
+// Substitute()
+//
+// Substitutes variables into a given format string. See file comments above
+// for usage.
+//
+// The declarations of `Substitute()` below consist of overloads for passing 0
+// to 10 arguments, respectively.
+//
+// NOTE: A zero-argument `Substitute()` may be used within variadic templates to
+// allow a variable number of arguments.
+//
+// Example:
+//  template <typename... Args>
+//  void VarMsg(absl::string_view format, const Args&... args) {
+//    std::string s = absl::Substitute(format, args...);
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(absl::string_view format) {
+  std::string result;
+  SubstituteAndAppend(&result, format);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1, a2);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1, a2, a3);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+    const substitute_internal::Arg& a7) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8);
+  return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+    absl::string_view format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
+    const substitute_internal::Arg& a9) {
+  std::string result;
+  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+  return result;
+}
+
+#if defined(ABSL_BAD_CALL_IF)
+// This body of functions catches cases where the number of placeholders
+// doesn't match the number of data arguments.
+std::string Substitute(const char* format)
+    ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0,
+                     "There were no substitution arguments "
+                     "but this format string either has a $[0-9] in it or "
+                     "contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 1,
+        "There was 1 substitution argument given, but "
+        "this format string is missing its $0, contains one of $1-$9, "
+        "or contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+                       const substitute_internal::Arg& a1)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 3,
+        "There were 2 substitution arguments given, but "
+        "this format string is missing its $0/$1, contains one of "
+        "$2-$9, or contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+                       const substitute_internal::Arg& a1,
+                       const substitute_internal::Arg& a2)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 7,
+        "There were 3 substitution arguments given, but "
+        "this format string is missing its $0/$1/$2, contains one of "
+        "$3-$9, or contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+                       const substitute_internal::Arg& a1,
+                       const substitute_internal::Arg& a2,
+                       const substitute_internal::Arg& a3)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 15,
+        "There were 4 substitution arguments given, but "
+        "this format string is missing its $0-$3, contains one of "
+        "$4-$9, or contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+                       const substitute_internal::Arg& a1,
+                       const substitute_internal::Arg& a2,
+                       const substitute_internal::Arg& a3,
+                       const substitute_internal::Arg& a4)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 31,
+        "There were 5 substitution arguments given, but "
+        "this format string is missing its $0-$4, contains one of "
+        "$5-$9, or contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+                       const substitute_internal::Arg& a1,
+                       const substitute_internal::Arg& a2,
+                       const substitute_internal::Arg& a3,
+                       const substitute_internal::Arg& a4,
+                       const substitute_internal::Arg& a5)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 63,
+        "There were 6 substitution arguments given, but "
+        "this format string is missing its $0-$5, contains one of "
+        "$6-$9, or contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+                       const substitute_internal::Arg& a1,
+                       const substitute_internal::Arg& a2,
+                       const substitute_internal::Arg& a3,
+                       const substitute_internal::Arg& a4,
+                       const substitute_internal::Arg& a5,
+                       const substitute_internal::Arg& a6)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 127,
+        "There were 7 substitution arguments given, but "
+        "this format string is missing its $0-$6, contains one of "
+        "$7-$9, or contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+                       const substitute_internal::Arg& a1,
+                       const substitute_internal::Arg& a2,
+                       const substitute_internal::Arg& a3,
+                       const substitute_internal::Arg& a4,
+                       const substitute_internal::Arg& a5,
+                       const substitute_internal::Arg& a6,
+                       const substitute_internal::Arg& a7)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 255,
+        "There were 8 substitution arguments given, but "
+        "this format string is missing its $0-$7, contains one of "
+        "$8-$9, or contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(
+    const char* format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 511,
+        "There were 9 substitution arguments given, but "
+        "this format string is missing its $0-$8, contains a $9, or "
+        "contains an unescaped $ character (use $$ instead)");
+
+std::string Substitute(
+    const char* format, const substitute_internal::Arg& a0,
+    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
+    const substitute_internal::Arg& a9)
+    ABSL_BAD_CALL_IF(
+        substitute_internal::PlaceholderBitmask(format) != 1023,
+        "There were 10 substitution arguments given, but this "
+        "format string either doesn't contain all of $0 through $9 or "
+        "contains an unescaped $ character (use $$ instead)");
+#endif  // ABSL_BAD_CALL_IF
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_SUBSTITUTE_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/barrier.h b/CAPI/cpp/grpc/include/absl/synchronization/barrier.h
new file mode 100644
index 0000000..d8e7544
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/barrier.h
@@ -0,0 +1,79 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// barrier.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_SYNCHRONIZATION_BARRIER_H_
+#define ABSL_SYNCHRONIZATION_BARRIER_H_
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Barrier
+//
+// This class creates a barrier which blocks threads until a prespecified
+// threshold of threads (`num_threads`) utilizes the barrier. A thread utilizes
+// the `Barrier` by calling `Block()` on the barrier, which will block that
+// thread; no call to `Block()` will return until `num_threads` threads have
+// called it.
+//
+// Exactly one call to `Block()` will return `true`, which is then responsible
+// for destroying the barrier; because stack allocation will cause the barrier
+// to be deleted when it is out of scope, barriers should not be stack
+// allocated.
+//
+// Example:
+//
+//   // Main thread creates a `Barrier`:
+//   barrier = new Barrier(num_threads);
+//
+//   // Each participating thread could then call:
+//   if (barrier->Block()) delete barrier;  // Exactly one call to `Block()`
+//                                          // returns `true`; that call
+//                                          // deletes the barrier.
+class Barrier {
+ public:
+  // `num_threads` is the number of threads that will participate in the barrier
+  explicit Barrier(int num_threads)
+      : num_to_block_(num_threads), num_to_exit_(num_threads) {}
+
+  Barrier(const Barrier&) = delete;
+  Barrier& operator=(const Barrier&) = delete;
+
+  // Barrier::Block()
+  //
+  // Blocks the current thread, and returns only when the `num_threads`
+  // threshold of threads utilizing this barrier has been reached. `Block()`
+  // returns `true` for precisely one caller, which may then destroy the
+  // barrier.
+  //
+  // Memory ordering: For any threads X and Y, any action taken by X
+  // before X calls `Block()` will be visible to Y after Y returns from
+  // `Block()`.
+  bool Block();
+
+ private:
+  Mutex lock_;
+  int num_to_block_ ABSL_GUARDED_BY(lock_);
+  int num_to_exit_ ABSL_GUARDED_BY(lock_);
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // ABSL_SYNCHRONIZATION_BARRIER_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/blocking_counter.h b/CAPI/cpp/grpc/include/absl/synchronization/blocking_counter.h
new file mode 100644
index 0000000..1908fdb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/blocking_counter.h
@@ -0,0 +1,101 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// blocking_counter.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
+#define ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
+
+#include <atomic>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// BlockingCounter
+//
+// This class allows a thread to block for a pre-specified number of actions.
+// `BlockingCounter` maintains a single non-negative abstract integer "count"
+// with an initial value `initial_count`. A thread can then call `Wait()` on
+// this blocking counter to block until the specified number of events occur;
+// worker threads then call 'DecrementCount()` on the counter upon completion of
+// their work. Once the counter's internal "count" reaches zero, the blocked
+// thread unblocks.
+//
+// A `BlockingCounter` requires the following:
+//     - its `initial_count` is non-negative.
+//     - the number of calls to `DecrementCount()` on it is at most
+//       `initial_count`.
+//     - `Wait()` is called at most once on it.
+//
+// Given the above requirements, a `BlockingCounter` provides the following
+// guarantees:
+//     - Once its internal "count" reaches zero, no legal action on the object
+//       can further change the value of "count".
+//     - When `Wait()` returns, it is legal to destroy the `BlockingCounter`.
+//     - When `Wait()` returns, the number of calls to `DecrementCount()` on
+//       this blocking counter exactly equals `initial_count`.
+//
+// Example:
+//     BlockingCounter bcount(N);         // there are N items of work
+//     ... Allow worker threads to start.
+//     ... On completing each work item, workers do:
+//     ... bcount.DecrementCount();      // an item of work has been completed
+//
+//     bcount.Wait();                    // wait for all work to be complete
+//
+class BlockingCounter {
+ public:
+  explicit BlockingCounter(int initial_count);
+
+  BlockingCounter(const BlockingCounter&) = delete;
+  BlockingCounter& operator=(const BlockingCounter&) = delete;
+
+  // BlockingCounter::DecrementCount()
+  //
+  // Decrements the counter's "count" by one, and return "count == 0". This
+  // function requires that "count != 0" when it is called.
+  //
+  // Memory ordering: For any threads X and Y, any action taken by X
+  // before it calls `DecrementCount()` is visible to thread Y after
+  // Y's call to `DecrementCount()`, provided Y's call returns `true`.
+  bool DecrementCount();
+
+  // BlockingCounter::Wait()
+  //
+  // Blocks until the counter reaches zero. This function may be called at most
+  // once. On return, `DecrementCount()` will have been called "initial_count"
+  // times and the blocking counter may be destroyed.
+  //
+  // Memory ordering: For any threads X and Y, any action taken by X
+  // before X calls `DecrementCount()` is visible to Y after Y returns
+  // from `Wait()`.
+  void Wait();
+
+ private:
+  Mutex lock_;
+  std::atomic<int> count_;
+  int num_waiting_ ABSL_GUARDED_BY(lock_);
+  bool done_ ABSL_GUARDED_BY(lock_);
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/create_thread_identity.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/create_thread_identity.h
new file mode 100644
index 0000000..4cfde09
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/create_thread_identity.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2017 The Abseil Authors.
+ *
+ * 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
+ *
+ *      https://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.
+ */
+
+// Interface for getting the current ThreadIdentity, creating one if necessary.
+// See thread_identity.h.
+//
+// This file is separate from thread_identity.h because creating a new
+// ThreadIdentity requires slightly higher level libraries (per_thread_sem
+// and low_level_alloc) than accessing an existing one.  This separation allows
+// us to have a smaller //absl/base:base.
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
+
+#include "absl/base/internal/thread_identity.h"
+#include "absl/base/port.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace synchronization_internal {
+
+// Allocates and attaches a ThreadIdentity object for the calling thread.
+// For private use only.
+base_internal::ThreadIdentity* CreateThreadIdentity();
+
+// Returns the ThreadIdentity object representing the calling thread; guaranteed
+// to be unique for its lifetime.  The returned object will remain valid for the
+// program's lifetime; although it may be re-assigned to a subsequent thread.
+// If one does not exist for the calling thread, allocate it now.
+inline base_internal::ThreadIdentity* GetOrCreateCurrentThreadIdentity() {
+  base_internal::ThreadIdentity* identity =
+      base_internal::CurrentThreadIdentityIfPresent();
+  if (ABSL_PREDICT_FALSE(identity == nullptr)) {
+    return CreateThreadIdentity();
+  }
+  return identity;
+}
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/futex.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/futex.h
new file mode 100644
index 0000000..06fbd6d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/futex.h
@@ -0,0 +1,154 @@
+// Copyright 2020 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
+
+#include "absl/base/config.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/time.h>
+#include <unistd.h>
+#endif
+
+#ifdef __linux__
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <atomic>
+#include <cstdint>
+
+#include "absl/base/optimization.h"
+#include "absl/synchronization/internal/kernel_timeout.h"
+
+#ifdef ABSL_INTERNAL_HAVE_FUTEX
+#error ABSL_INTERNAL_HAVE_FUTEX may not be set on the command line
+#elif defined(__BIONIC__)
+// Bionic supports all the futex operations we need even when some of the futex
+// definitions are missing.
+#define ABSL_INTERNAL_HAVE_FUTEX
+#elif defined(__linux__) && defined(FUTEX_CLOCK_REALTIME)
+// FUTEX_CLOCK_REALTIME requires Linux >= 2.6.28.
+#define ABSL_INTERNAL_HAVE_FUTEX
+#endif
+
+#ifdef ABSL_INTERNAL_HAVE_FUTEX
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace synchronization_internal {
+
+// Some Android headers are missing these definitions even though they
+// support these futex operations.
+#ifdef __BIONIC__
+#ifndef SYS_futex
+#define SYS_futex __NR_futex
+#endif
+#ifndef FUTEX_WAIT_BITSET
+#define FUTEX_WAIT_BITSET 9
+#endif
+#ifndef FUTEX_PRIVATE_FLAG
+#define FUTEX_PRIVATE_FLAG 128
+#endif
+#ifndef FUTEX_CLOCK_REALTIME
+#define FUTEX_CLOCK_REALTIME 256
+#endif
+#ifndef FUTEX_BITSET_MATCH_ANY
+#define FUTEX_BITSET_MATCH_ANY 0xFFFFFFFF
+#endif
+#endif
+
+#if defined(__NR_futex_time64) && !defined(SYS_futex_time64)
+#define SYS_futex_time64 __NR_futex_time64
+#endif
+
+#if defined(SYS_futex_time64) && !defined(SYS_futex)
+#define SYS_futex SYS_futex_time64
+#endif
+
+class FutexImpl {
+ public:
+  static int WaitUntil(std::atomic<int32_t> *v, int32_t val,
+                       KernelTimeout t) {
+    int err = 0;
+    if (t.has_timeout()) {
+      // https://locklessinc.com/articles/futex_cheat_sheet/
+      // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET uses absolute time.
+      struct timespec abs_timeout = t.MakeAbsTimespec();
+      // Atomically check that the futex value is still 0, and if it
+      // is, sleep until abs_timeout or until woken by FUTEX_WAKE.
+      err = syscall(
+          SYS_futex, reinterpret_cast<int32_t *>(v),
+          FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME, val,
+          &abs_timeout, nullptr, FUTEX_BITSET_MATCH_ANY);
+    } else {
+      // Atomically check that the futex value is still 0, and if it
+      // is, sleep until woken by FUTEX_WAKE.
+      err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
+                    FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, nullptr);
+    }
+    if (ABSL_PREDICT_FALSE(err != 0)) {
+      err = -errno;
+    }
+    return err;
+  }
+
+  static int WaitBitsetAbsoluteTimeout(std::atomic<int32_t> *v, int32_t val,
+                                       int32_t bits,
+                                       const struct timespec *abstime) {
+    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
+                      FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG, val, abstime,
+                      nullptr, bits);
+    if (ABSL_PREDICT_FALSE(err != 0)) {
+      err = -errno;
+    }
+    return err;
+  }
+
+  static int Wake(std::atomic<int32_t> *v, int32_t count) {
+    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
+                      FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count);
+    if (ABSL_PREDICT_FALSE(err < 0)) {
+      err = -errno;
+    }
+    return err;
+  }
+
+  // FUTEX_WAKE_BITSET
+  static int WakeBitset(std::atomic<int32_t> *v, int32_t count, int32_t bits) {
+    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
+                      FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, count, nullptr,
+                      nullptr, bits);
+    if (ABSL_PREDICT_FALSE(err < 0)) {
+      err = -errno;
+    }
+    return err;
+  }
+};
+
+class Futex : public FutexImpl {};
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_INTERNAL_HAVE_FUTEX
+
+#endif  // ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/graphcycles.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/graphcycles.h
new file mode 100644
index 0000000..ceba33e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/graphcycles.h
@@ -0,0 +1,141 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_GRAPHCYCLES_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_GRAPHCYCLES_H_
+
+// GraphCycles detects the introduction of a cycle into a directed
+// graph that is being built up incrementally.
+//
+// Nodes are identified by small integers.  It is not possible to
+// record multiple edges with the same (source, destination) pair;
+// requests to add an edge where one already exists are silently
+// ignored.
+//
+// It is also not possible to introduce a cycle; an attempt to insert
+// an edge that would introduce a cycle fails and returns false.
+//
+// GraphCycles uses no internal locking; calls into it should be
+// serialized externally.
+
+// Performance considerations:
+//   Works well on sparse graphs, poorly on dense graphs.
+//   Extra information is maintained incrementally to detect cycles quickly.
+//   InsertEdge() is very fast when the edge already exists, and reasonably fast
+//   otherwise.
+//   FindPath() is linear in the size of the graph.
+// The current implementation uses O(|V|+|E|) space.
+
+#include <cstdint>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace synchronization_internal {
+
+// Opaque identifier for a graph node.
+struct GraphId {
+  uint64_t handle;
+
+  bool operator==(const GraphId& x) const { return handle == x.handle; }
+  bool operator!=(const GraphId& x) const { return handle != x.handle; }
+};
+
+// Return an invalid graph id that will never be assigned by GraphCycles.
+inline GraphId InvalidGraphId() {
+  return GraphId{0};
+}
+
+class GraphCycles {
+ public:
+  GraphCycles();
+  ~GraphCycles();
+
+  // Return the id to use for ptr, assigning one if necessary.
+  // Subsequent calls with the same ptr value will return the same id
+  // until Remove().
+  GraphId GetId(void* ptr);
+
+  // Remove "ptr" from the graph.  Its corresponding node and all
+  // edges to and from it are removed.
+  void RemoveNode(void* ptr);
+
+  // Return the pointer associated with id, or nullptr if id is not
+  // currently in the graph.
+  void* Ptr(GraphId id);
+
+  // Attempt to insert an edge from source_node to dest_node.  If the
+  // edge would introduce a cycle, return false without making any
+  // changes. Otherwise add the edge and return true.
+  bool InsertEdge(GraphId source_node, GraphId dest_node);
+
+  // Remove any edge that exists from source_node to dest_node.
+  void RemoveEdge(GraphId source_node, GraphId dest_node);
+
+  // Return whether node exists in the graph.
+  bool HasNode(GraphId node);
+
+  // Return whether there is an edge directly from source_node to dest_node.
+  bool HasEdge(GraphId source_node, GraphId dest_node) const;
+
+  // Return whether dest_node is reachable from source_node
+  // by following edges.
+  bool IsReachable(GraphId source_node, GraphId dest_node) const;
+
+  // Find a path from "source" to "dest".  If such a path exists,
+  // place the nodes on the path in the array path[], and return
+  // the number of nodes on the path.  If the path is longer than
+  // max_path_len nodes, only the first max_path_len nodes are placed
+  // in path[].  The client should compare the return value with
+  // max_path_len" to see when this occurs.  If no path exists, return
+  // 0.  Any valid path stored in path[] will start with "source" and
+  // end with "dest".  There is no guarantee that the path is the
+  // shortest, but no node will appear twice in the path, except the
+  // source and destination node if they are identical; therefore, the
+  // return value is at most one greater than the number of nodes in
+  // the graph.
+  int FindPath(GraphId source, GraphId dest, int max_path_len,
+               GraphId path[]) const;
+
+  // Update the stack trace recorded for id with the current stack
+  // trace if the last time it was updated had a smaller priority
+  // than the priority passed on this call.
+  //
+  // *get_stack_trace is called to get the stack trace.
+  void UpdateStackTrace(GraphId id, int priority,
+                        int (*get_stack_trace)(void**, int));
+
+  // Set *ptr to the beginning of the array that holds the recorded
+  // stack trace for id and return the depth of the stack trace.
+  int GetStackTrace(GraphId id, void*** ptr);
+
+  // Check internal invariants. Crashes on failure, returns true on success.
+  // Expensive: should only be called from graphcycles_test.cc.
+  bool CheckInvariants() const;
+
+  // ----------------------------------------------------
+  struct Rep;
+ private:
+  Rep *rep_;      // opaque representation
+  GraphCycles(const GraphCycles&) = delete;
+  GraphCycles& operator=(const GraphCycles&) = delete;
+};
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h
new file mode 100644
index 0000000..bbd4d2d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h
@@ -0,0 +1,156 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+// An optional absolute timeout, with nanosecond granularity,
+// compatible with absl::Time. Suitable for in-register
+// parameter-passing (e.g. syscalls.)
+// Constructible from a absl::Time (for a timeout to be respected) or {}
+// (for "no timeout".)
+// This is a private low-level API for use by a handful of low-level
+// components that are friends of this class. Higher-level components
+// should build APIs based on absl::Time and absl::Duration.
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
+
+#include <time.h>
+
+#include <algorithm>
+#include <limits>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace synchronization_internal {
+
+class Futex;
+class Waiter;
+
+class KernelTimeout {
+ public:
+  // A timeout that should expire at <t>.  Any value, in the full
+  // InfinitePast() to InfiniteFuture() range, is valid here and will be
+  // respected.
+  explicit KernelTimeout(absl::Time t) : ns_(MakeNs(t)) {}
+  // No timeout.
+  KernelTimeout() : ns_(0) {}
+
+  // A more explicit factory for those who prefer it.  Equivalent to {}.
+  static KernelTimeout Never() { return {}; }
+
+  // We explicitly do not support other custom formats: timespec, int64_t nanos.
+  // Unify on this and absl::Time, please.
+
+  bool has_timeout() const { return ns_ != 0; }
+
+  // Convert to parameter for sem_timedwait/futex/similar.  Only for approved
+  // users.  Do not call if !has_timeout.
+  struct timespec MakeAbsTimespec();
+
+ private:
+  // internal rep, not user visible: ns after unix epoch.
+  // zero = no timeout.
+  // Negative we treat as an unlikely (and certainly expired!) but valid
+  // timeout.
+  int64_t ns_;
+
+  static int64_t MakeNs(absl::Time t) {
+    // optimization--InfiniteFuture is common "no timeout" value
+    // and cheaper to compare than convert.
+    if (t == absl::InfiniteFuture()) return 0;
+    int64_t x = ToUnixNanos(t);
+
+    // A timeout that lands exactly on the epoch (x=0) needs to be respected,
+    // so we alter it unnoticably to 1.  Negative timeouts are in
+    // theory supported, but handled poorly by the kernel (long
+    // delays) so push them forward too; since all such times have
+    // already passed, it's indistinguishable.
+    if (x <= 0) x = 1;
+    // A time larger than what can be represented to the kernel is treated
+    // as no timeout.
+    if (x == (std::numeric_limits<int64_t>::max)()) x = 0;
+    return x;
+  }
+
+#ifdef _WIN32
+  // Converts to milliseconds from now, or INFINITE when
+  // !has_timeout(). For use by SleepConditionVariableSRW on
+  // Windows. Callers should recognize that the return value is a
+  // relative duration (it should be recomputed by calling this method
+  // in the case of a spurious wakeup).
+  // This header file may be included transitively by public header files,
+  // so we define our own DWORD and INFINITE instead of getting them from
+  // <intsafe.h> and <WinBase.h>.
+  typedef unsigned long DWord;  // NOLINT
+  DWord InMillisecondsFromNow() const {
+    constexpr DWord kInfinite = (std::numeric_limits<DWord>::max)();
+    if (!has_timeout()) {
+      return kInfinite;
+    }
+    // The use of absl::Now() to convert from absolute time to
+    // relative time means that absl::Now() cannot use anything that
+    // depends on KernelTimeout (for example, Mutex) on Windows.
+    int64_t now = ToUnixNanos(absl::Now());
+    if (ns_ >= now) {
+      // Round up so that Now() + ms_from_now >= ns_.
+      constexpr uint64_t max_nanos =
+          (std::numeric_limits<int64_t>::max)() - 999999u;
+      uint64_t ms_from_now =
+          (std::min<uint64_t>(max_nanos, ns_ - now) + 999999u) / 1000000u;
+      if (ms_from_now > kInfinite) {
+        return kInfinite;
+      }
+      return static_cast<DWord>(ms_from_now);
+    }
+    return 0;
+  }
+#endif
+
+  friend class Futex;
+  friend class Waiter;
+};
+
+inline struct timespec KernelTimeout::MakeAbsTimespec() {
+  int64_t n = ns_;
+  static const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
+  if (n == 0) {
+    ABSL_RAW_LOG(
+        ERROR, "Tried to create a timespec from a non-timeout; never do this.");
+    // But we'll try to continue sanely.  no-timeout ~= saturated timeout.
+    n = (std::numeric_limits<int64_t>::max)();
+  }
+
+  // Kernel APIs validate timespecs as being at or after the epoch,
+  // despite the kernel time type being signed.  However, no one can
+  // tell the difference between a timeout at or before the epoch (since
+  // all such timeouts have expired!)
+  if (n < 0) n = 0;
+
+  struct timespec abstime;
+  int64_t seconds = (std::min)(n / kNanosPerSecond,
+                               int64_t{(std::numeric_limits<time_t>::max)()});
+  abstime.tv_sec = static_cast<time_t>(seconds);
+  abstime.tv_nsec = static_cast<decltype(abstime.tv_nsec)>(n % kNanosPerSecond);
+  return abstime;
+}
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/per_thread_sem.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/per_thread_sem.h
new file mode 100644
index 0000000..90a8880
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/per_thread_sem.h
@@ -0,0 +1,110 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+// PerThreadSem is a low-level synchronization primitive controlling the
+// runnability of a single thread, used internally by Mutex and CondVar.
+//
+// This is NOT a general-purpose synchronization mechanism, and should not be
+// used directly by applications.  Applications should use Mutex and CondVar.
+//
+// The semantics of PerThreadSem are the same as that of a counting semaphore.
+// Each thread maintains an abstract "count" value associated with its identity.
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
+
+#include <atomic>
+
+#include "absl/base/internal/thread_identity.h"
+#include "absl/synchronization/internal/create_thread_identity.h"
+#include "absl/synchronization/internal/kernel_timeout.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class Mutex;
+
+namespace synchronization_internal {
+
+class PerThreadSem {
+ public:
+  PerThreadSem() = delete;
+  PerThreadSem(const PerThreadSem&) = delete;
+  PerThreadSem& operator=(const PerThreadSem&) = delete;
+
+  // Routine invoked periodically (once a second) by a background thread.
+  // Has no effect on user-visible state.
+  static void Tick(base_internal::ThreadIdentity* identity);
+
+  // ---------------------------------------------------------------------------
+  // Routines used by autosizing threadpools to detect when threads are
+  // blocked.  Each thread has a counter pointer, initially zero.  If non-zero,
+  // the implementation atomically increments the counter when it blocks on a
+  // semaphore, a decrements it again when it wakes.  This allows a threadpool
+  // to keep track of how many of its threads are blocked.
+  // SetThreadBlockedCounter() should be used only by threadpool
+  // implementations.  GetThreadBlockedCounter() should be used by modules that
+  // block threads; if the pointer returned is non-zero, the location should be
+  // incremented before the thread blocks, and decremented after it wakes.
+  static void SetThreadBlockedCounter(std::atomic<int> *counter);
+  static std::atomic<int> *GetThreadBlockedCounter();
+
+ private:
+  // Create the PerThreadSem associated with "identity".  Initializes count=0.
+  // REQUIRES: May only be called by ThreadIdentity.
+  static void Init(base_internal::ThreadIdentity* identity);
+
+  // Increments "identity"'s count.
+  static inline void Post(base_internal::ThreadIdentity* identity);
+
+  // Waits until either our count > 0 or t has expired.
+  // If count > 0, decrements count and returns true.  Otherwise returns false.
+  // !t.has_timeout() => Wait(t) will return true.
+  static inline bool Wait(KernelTimeout t);
+
+  // Permitted callers.
+  friend class PerThreadSemTest;
+  friend class absl::Mutex;
+  friend void OneTimeInitThreadIdentity(absl::base_internal::ThreadIdentity*);
+};
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// In some build configurations we pass --detect-odr-violations to the
+// gold linker.  This causes it to flag weak symbol overrides as ODR
+// violations.  Because ODR only applies to C++ and not C,
+// --detect-odr-violations ignores symbols not mangled with C++ names.
+// By changing our extension points to be extern "C", we dodge this
+// check.
+extern "C" {
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
+    absl::base_internal::ThreadIdentity* identity);
+bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
+    absl::synchronization_internal::KernelTimeout t);
+}  // extern "C"
+
+void absl::synchronization_internal::PerThreadSem::Post(
+    absl::base_internal::ThreadIdentity* identity) {
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity);
+}
+
+bool absl::synchronization_internal::PerThreadSem::Wait(
+    absl::synchronization_internal::KernelTimeout t) {
+  return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t);
+}
+
+#endif  // ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/thread_pool.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/thread_pool.h
new file mode 100644
index 0000000..0cb96da
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/thread_pool.h
@@ -0,0 +1,93 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
+
+#include <cassert>
+#include <cstddef>
+#include <functional>
+#include <queue>
+#include <thread>  // NOLINT(build/c++11)
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace synchronization_internal {
+
+// A simple ThreadPool implementation for tests.
+class ThreadPool {
+ public:
+  explicit ThreadPool(int num_threads) {
+    for (int i = 0; i < num_threads; ++i) {
+      threads_.push_back(std::thread(&ThreadPool::WorkLoop, this));
+    }
+  }
+
+  ThreadPool(const ThreadPool &) = delete;
+  ThreadPool &operator=(const ThreadPool &) = delete;
+
+  ~ThreadPool() {
+    {
+      absl::MutexLock l(&mu_);
+      for (size_t i = 0; i < threads_.size(); i++) {
+        queue_.push(nullptr);  // Shutdown signal.
+      }
+    }
+    for (auto &t : threads_) {
+      t.join();
+    }
+  }
+
+  // Schedule a function to be run on a ThreadPool thread immediately.
+  void Schedule(std::function<void()> func) {
+    assert(func != nullptr);
+    absl::MutexLock l(&mu_);
+    queue_.push(std::move(func));
+  }
+
+ private:
+  bool WorkAvailable() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    return !queue_.empty();
+  }
+
+  void WorkLoop() {
+    while (true) {
+      std::function<void()> func;
+      {
+        absl::MutexLock l(&mu_);
+        mu_.Await(absl::Condition(this, &ThreadPool::WorkAvailable));
+        func = std::move(queue_.front());
+        queue_.pop();
+      }
+      if (func == nullptr) {  // Shutdown signal.
+        break;
+      }
+      func();
+    }
+  }
+
+  absl::Mutex mu_;
+  std::queue<std::function<void()>> queue_ ABSL_GUARDED_BY(mu_);
+  std::vector<std::thread> threads_;
+};
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/waiter.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/waiter.h
new file mode 100644
index 0000000..b8adfeb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/waiter.h
@@ -0,0 +1,161 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
+
+#include "absl/base/config.h"
+
+#ifdef _WIN32
+#include <sdkddkver.h>
+#else
+#include <pthread.h>
+#endif
+
+#ifdef __linux__
+#include <linux/futex.h>
+#endif
+
+#ifdef ABSL_HAVE_SEMAPHORE_H
+#include <semaphore.h>
+#endif
+
+#include <atomic>
+#include <cstdint>
+
+#include "absl/base/internal/thread_identity.h"
+#include "absl/synchronization/internal/futex.h"
+#include "absl/synchronization/internal/kernel_timeout.h"
+
+// May be chosen at compile time via -DABSL_FORCE_WAITER_MODE=<index>
+#define ABSL_WAITER_MODE_FUTEX 0
+#define ABSL_WAITER_MODE_SEM 1
+#define ABSL_WAITER_MODE_CONDVAR 2
+#define ABSL_WAITER_MODE_WIN32 3
+
+#if defined(ABSL_FORCE_WAITER_MODE)
+#define ABSL_WAITER_MODE ABSL_FORCE_WAITER_MODE
+#elif defined(_WIN32) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
+#define ABSL_WAITER_MODE ABSL_WAITER_MODE_WIN32
+#elif defined(ABSL_INTERNAL_HAVE_FUTEX)
+#define ABSL_WAITER_MODE ABSL_WAITER_MODE_FUTEX
+#elif defined(ABSL_HAVE_SEMAPHORE_H)
+#define ABSL_WAITER_MODE ABSL_WAITER_MODE_SEM
+#else
+#define ABSL_WAITER_MODE ABSL_WAITER_MODE_CONDVAR
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace synchronization_internal {
+
+// Waiter is an OS-specific semaphore.
+class Waiter {
+ public:
+  // Prepare any data to track waits.
+  Waiter();
+
+  // Not copyable or movable
+  Waiter(const Waiter&) = delete;
+  Waiter& operator=(const Waiter&) = delete;
+
+  // Blocks the calling thread until a matching call to `Post()` or
+  // `t` has passed. Returns `true` if woken (`Post()` called),
+  // `false` on timeout.
+  bool Wait(KernelTimeout t);
+
+  // Restart the caller of `Wait()` as with a normal semaphore.
+  void Post();
+
+  // If anyone is waiting, wake them up temporarily and cause them to
+  // call `MaybeBecomeIdle()`. They will then return to waiting for a
+  // `Post()` or timeout.
+  void Poke();
+
+  // Returns the Waiter associated with the identity.
+  static Waiter* GetWaiter(base_internal::ThreadIdentity* identity) {
+    static_assert(
+        sizeof(Waiter) <= sizeof(base_internal::ThreadIdentity::WaiterState),
+        "Insufficient space for Waiter");
+    return reinterpret_cast<Waiter*>(identity->waiter_state.data);
+  }
+
+  // How many periods to remain idle before releasing resources
+#ifndef ABSL_HAVE_THREAD_SANITIZER
+  static constexpr int kIdlePeriods = 60;
+#else
+  // Memory consumption under ThreadSanitizer is a serious concern,
+  // so we release resources sooner. The value of 1 leads to 1 to 2 second
+  // delay before marking a thread as idle.
+  static const int kIdlePeriods = 1;
+#endif
+
+ private:
+  // The destructor must not be called since Mutex/CondVar
+  // can use PerThreadSem/Waiter after the thread exits.
+  // Waiter objects are embedded in ThreadIdentity objects,
+  // which are reused via a freelist and are never destroyed.
+  ~Waiter() = delete;
+
+#if ABSL_WAITER_MODE == ABSL_WAITER_MODE_FUTEX
+  // Futexes are defined by specification to be 32-bits.
+  // Thus std::atomic<int32_t> must be just an int32_t with lockfree methods.
+  std::atomic<int32_t> futex_;
+  static_assert(sizeof(int32_t) == sizeof(futex_), "Wrong size for futex");
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_CONDVAR
+  // REQUIRES: mu_ must be held.
+  void InternalCondVarPoke();
+
+  pthread_mutex_t mu_;
+  pthread_cond_t cv_;
+  int waiter_count_;
+  int wakeup_count_;  // Unclaimed wakeups.
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_SEM
+  sem_t sem_;
+  // This seems superfluous, but for Poke() we need to cause spurious
+  // wakeups on the semaphore. Hence we can't actually use the
+  // semaphore's count.
+  std::atomic<int> wakeups_;
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_WIN32
+  // WinHelper - Used to define utilities for accessing the lock and
+  // condition variable storage once the types are complete.
+  class WinHelper;
+
+  // REQUIRES: WinHelper::GetLock(this) must be held.
+  void InternalCondVarPoke();
+
+  // We can't include Windows.h in our headers, so we use aligned character
+  // buffers to define the storage of SRWLOCK and CONDITION_VARIABLE.
+  // SRW locks and condition variables do not need to be explicitly destroyed.
+  // https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-initializesrwlock
+  // https://stackoverflow.com/questions/28975958/why-does-windows-have-no-deleteconditionvariable-function-to-go-together-with
+  alignas(void*) unsigned char mu_storage_[sizeof(void*)];
+  alignas(void*) unsigned char cv_storage_[sizeof(void*)];
+  int waiter_count_;
+  int wakeup_count_;
+
+#else
+  #error Unknown ABSL_WAITER_MODE
+#endif
+};
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/mutex.h b/CAPI/cpp/grpc/include/absl/synchronization/mutex.h
new file mode 100644
index 0000000..b69b708
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/mutex.h
@@ -0,0 +1,1090 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// mutex.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a `Mutex` -- a mutually exclusive lock -- and the
+// most common type of synchronization primitive for facilitating locks on
+// shared resources. A mutex is used to prevent multiple threads from accessing
+// and/or writing to a shared resource concurrently.
+//
+// Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
+// features:
+//   * Conditional predicates intrinsic to the `Mutex` object
+//   * Shared/reader locks, in addition to standard exclusive/writer locks
+//   * Deadlock detection and debug support.
+//
+// The following helper classes are also defined within this file:
+//
+//  MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
+//              write access within the current scope.
+//
+//  ReaderMutexLock
+//            - An RAII wrapper to acquire and release a `Mutex` for shared/read
+//              access within the current scope.
+//
+//  WriterMutexLock
+//            - Effectively an alias for `MutexLock` above, designed for use in
+//              distinguishing reader and writer locks within code.
+//
+// In addition to simple mutex locks, this file also defines ways to perform
+// locking under certain conditions.
+//
+//  Condition - (Preferred) Used to wait for a particular predicate that
+//              depends on state protected by the `Mutex` to become true.
+//  CondVar   - A lower-level variant of `Condition` that relies on
+//              application code to explicitly signal the `CondVar` when
+//              a condition has been met.
+//
+// See below for more information on using `Condition` or `CondVar`.
+//
+// Mutexes and mutex behavior can be quite complicated. The information within
+// this header file is limited, as a result. Please consult the Mutex guide for
+// more complete information and examples.
+
+#ifndef ABSL_SYNCHRONIZATION_MUTEX_H_
+#define ABSL_SYNCHRONIZATION_MUTEX_H_
+
+#include <atomic>
+#include <cstdint>
+#include <string>
+
+#include "absl/base/const_init.h"
+#include "absl/base/internal/identity.h"
+#include "absl/base/internal/low_level_alloc.h"
+#include "absl/base/internal/thread_identity.h"
+#include "absl/base/internal/tsan_mutex_interface.h"
+#include "absl/base/port.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/internal/kernel_timeout.h"
+#include "absl/synchronization/internal/per_thread_sem.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class Condition;
+struct SynchWaitParams;
+
+// -----------------------------------------------------------------------------
+// Mutex
+// -----------------------------------------------------------------------------
+//
+// A `Mutex` is a non-reentrant (aka non-recursive) Mutually Exclusive lock
+// on some resource, typically a variable or data structure with associated
+// invariants. Proper usage of mutexes prevents concurrent access by different
+// threads to the same resource.
+//
+// A `Mutex` has two basic operations: `Mutex::Lock()` and `Mutex::Unlock()`.
+// The `Lock()` operation *acquires* a `Mutex` (in a state known as an
+// *exclusive* -- or write -- lock), while the `Unlock()` operation *releases* a
+// Mutex. During the span of time between the Lock() and Unlock() operations,
+// a mutex is said to be *held*. By design all mutexes support exclusive/write
+// locks, as this is the most common way to use a mutex.
+//
+// The `Mutex` state machine for basic lock/unlock operations is quite simple:
+//
+// |                | Lock()     | Unlock() |
+// |----------------+------------+----------|
+// | Free           | Exclusive  | invalid  |
+// | Exclusive      | blocks     | Free     |
+//
+// Attempts to `Unlock()` must originate from the thread that performed the
+// corresponding `Lock()` operation.
+//
+// An "invalid" operation is disallowed by the API. The `Mutex` implementation
+// is allowed to do anything on an invalid call, including but not limited to
+// crashing with a useful error message, silently succeeding, or corrupting
+// data structures. In debug mode, the implementation attempts to crash with a
+// useful error message.
+//
+// `Mutex` is not guaranteed to be "fair" in prioritizing waiting threads; it
+// is, however, approximately fair over long periods, and starvation-free for
+// threads at the same priority.
+//
+// The lock/unlock primitives are now annotated with lock annotations
+// defined in (base/thread_annotations.h). When writing multi-threaded code,
+// you should use lock annotations whenever possible to document your lock
+// synchronization policy. Besides acting as documentation, these annotations
+// also help compilers or static analysis tools to identify and warn about
+// issues that could potentially result in race conditions and deadlocks.
+//
+// For more information about the lock annotations, please see
+// [Thread Safety Analysis](http://clang.llvm.org/docs/ThreadSafetyAnalysis.html)
+// in the Clang documentation.
+//
+// See also `MutexLock`, below, for scoped `Mutex` acquisition.
+
+class ABSL_LOCKABLE Mutex {
+ public:
+  // Creates a `Mutex` that is not held by anyone. This constructor is
+  // typically used for Mutexes allocated on the heap or the stack.
+  //
+  // To create `Mutex` instances with static storage duration
+  // (e.g. a namespace-scoped or global variable), see
+  // `Mutex::Mutex(absl::kConstInit)` below instead.
+  Mutex();
+
+  // Creates a mutex with static storage duration.  A global variable
+  // constructed this way avoids the lifetime issues that can occur on program
+  // startup and shutdown.  (See absl/base/const_init.h.)
+  //
+  // For Mutexes allocated on the heap and stack, instead use the default
+  // constructor, which can interact more fully with the thread sanitizer.
+  //
+  // Example usage:
+  //   namespace foo {
+  //   ABSL_CONST_INIT absl::Mutex mu(absl::kConstInit);
+  //   }
+  explicit constexpr Mutex(absl::ConstInitType);
+
+  ~Mutex();
+
+  // Mutex::Lock()
+  //
+  // Blocks the calling thread, if necessary, until this `Mutex` is free, and
+  // then acquires it exclusively. (This lock is also known as a "write lock.")
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION();
+
+  // Mutex::Unlock()
+  //
+  // Releases this `Mutex` and returns it from the exclusive/write state to the
+  // free state. Calling thread must hold the `Mutex` exclusively.
+  void Unlock() ABSL_UNLOCK_FUNCTION();
+
+  // Mutex::TryLock()
+  //
+  // If the mutex can be acquired without blocking, does so exclusively and
+  // returns `true`. Otherwise, returns `false`. Returns `true` with high
+  // probability if the `Mutex` was free.
+  bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true);
+
+  // Mutex::AssertHeld()
+  //
+  // Require that the mutex be held exclusively (write mode) by this thread.
+  //
+  // If the mutex is not currently held by this thread, this function may report
+  // an error (typically by crashing with a diagnostic) or it may do nothing.
+  // This function is intended only as a tool to assist debugging; it doesn't
+  // guarantee correctness.
+  void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK();
+
+  // ---------------------------------------------------------------------------
+  // Reader-Writer Locking
+  // ---------------------------------------------------------------------------
+
+  // A Mutex can also be used as a starvation-free reader-writer lock.
+  // Neither read-locks nor write-locks are reentrant/recursive to avoid
+  // potential client programming errors.
+  //
+  // The Mutex API provides `Writer*()` aliases for the existing `Lock()`,
+  // `Unlock()` and `TryLock()` methods for use within applications mixing
+  // reader/writer locks. Using `Reader*()` and `Writer*()` operations in this
+  // manner can make locking behavior clearer when mixing read and write modes.
+  //
+  // Introducing reader locks necessarily complicates the `Mutex` state
+  // machine somewhat. The table below illustrates the allowed state transitions
+  // of a mutex in such cases. Note that ReaderLock() may block even if the lock
+  // is held in shared mode; this occurs when another thread is blocked on a
+  // call to WriterLock().
+  //
+  // ---------------------------------------------------------------------------
+  //     Operation: WriterLock() Unlock()  ReaderLock()           ReaderUnlock()
+  // ---------------------------------------------------------------------------
+  // State
+  // ---------------------------------------------------------------------------
+  // Free           Exclusive    invalid   Shared(1)              invalid
+  // Shared(1)      blocks       invalid   Shared(2) or blocks    Free
+  // Shared(n) n>1  blocks       invalid   Shared(n+1) or blocks  Shared(n-1)
+  // Exclusive      blocks       Free      blocks                 invalid
+  // ---------------------------------------------------------------------------
+  //
+  // In comments below, "shared" refers to a state of Shared(n) for any n > 0.
+
+  // Mutex::ReaderLock()
+  //
+  // Blocks the calling thread, if necessary, until this `Mutex` is either free,
+  // or in shared mode, and then acquires a share of it. Note that
+  // `ReaderLock()` will block if some other thread has an exclusive/writer lock
+  // on the mutex.
+
+  void ReaderLock() ABSL_SHARED_LOCK_FUNCTION();
+
+  // Mutex::ReaderUnlock()
+  //
+  // Releases a read share of this `Mutex`. `ReaderUnlock` may return a mutex to
+  // the free state if this thread holds the last reader lock on the mutex. Note
+  // that you cannot call `ReaderUnlock()` on a mutex held in write mode.
+  void ReaderUnlock() ABSL_UNLOCK_FUNCTION();
+
+  // Mutex::ReaderTryLock()
+  //
+  // If the mutex can be acquired without blocking, acquires this mutex for
+  // shared access and returns `true`. Otherwise, returns `false`. Returns
+  // `true` with high probability if the `Mutex` was free or shared.
+  bool ReaderTryLock() ABSL_SHARED_TRYLOCK_FUNCTION(true);
+
+  // Mutex::AssertReaderHeld()
+  //
+  // Require that the mutex be held at least in shared mode (read mode) by this
+  // thread.
+  //
+  // If the mutex is not currently held by this thread, this function may report
+  // an error (typically by crashing with a diagnostic) or it may do nothing.
+  // This function is intended only as a tool to assist debugging; it doesn't
+  // guarantee correctness.
+  void AssertReaderHeld() const ABSL_ASSERT_SHARED_LOCK();
+
+  // Mutex::WriterLock()
+  // Mutex::WriterUnlock()
+  // Mutex::WriterTryLock()
+  //
+  // Aliases for `Mutex::Lock()`, `Mutex::Unlock()`, and `Mutex::TryLock()`.
+  //
+  // These methods may be used (along with the complementary `Reader*()`
+  // methods) to distingish simple exclusive `Mutex` usage (`Lock()`,
+  // etc.) from reader/writer lock usage.
+  void WriterLock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { this->Lock(); }
+
+  void WriterUnlock() ABSL_UNLOCK_FUNCTION() { this->Unlock(); }
+
+  bool WriterTryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    return this->TryLock();
+  }
+
+  // ---------------------------------------------------------------------------
+  // Conditional Critical Regions
+  // ---------------------------------------------------------------------------
+
+  // Conditional usage of a `Mutex` can occur using two distinct paradigms:
+  //
+  //   * Use of `Mutex` member functions with `Condition` objects.
+  //   * Use of the separate `CondVar` abstraction.
+  //
+  // In general, prefer use of `Condition` and the `Mutex` member functions
+  // listed below over `CondVar`. When there are multiple threads waiting on
+  // distinctly different conditions, however, a battery of `CondVar`s may be
+  // more efficient. This section discusses use of `Condition` objects.
+  //
+  // `Mutex` contains member functions for performing lock operations only under
+  // certain conditions, of class `Condition`. For correctness, the `Condition`
+  // must return a boolean that is a pure function, only of state protected by
+  // the `Mutex`. The condition must be invariant w.r.t. environmental state
+  // such as thread, cpu id, or time, and must be `noexcept`. The condition will
+  // always be invoked with the mutex held in at least read mode, so you should
+  // not block it for long periods or sleep it on a timer.
+  //
+  // Since a condition must not depend directly on the current time, use
+  // `*WithTimeout()` member function variants to make your condition
+  // effectively true after a given duration, or `*WithDeadline()` variants to
+  // make your condition effectively true after a given time.
+  //
+  // The condition function should have no side-effects aside from debug
+  // logging; as a special exception, the function may acquire other mutexes
+  // provided it releases all those that it acquires.  (This exception was
+  // required to allow logging.)
+
+  // Mutex::Await()
+  //
+  // Unlocks this `Mutex` and blocks until simultaneously both `cond` is `true`
+  // and this `Mutex` can be reacquired, then reacquires this `Mutex` in the
+  // same mode in which it was previously held. If the condition is initially
+  // `true`, `Await()` *may* skip the release/re-acquire step.
+  //
+  // `Await()` requires that this thread holds this `Mutex` in some mode.
+  void Await(const Condition &cond);
+
+  // Mutex::LockWhen()
+  // Mutex::ReaderLockWhen()
+  // Mutex::WriterLockWhen()
+  //
+  // Blocks until simultaneously both `cond` is `true` and this `Mutex` can
+  // be acquired, then atomically acquires this `Mutex`. `LockWhen()` is
+  // logically equivalent to `*Lock(); Await();` though they may have different
+  // performance characteristics.
+  void LockWhen(const Condition &cond) ABSL_EXCLUSIVE_LOCK_FUNCTION();
+
+  void ReaderLockWhen(const Condition &cond) ABSL_SHARED_LOCK_FUNCTION();
+
+  void WriterLockWhen(const Condition &cond) ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    this->LockWhen(cond);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mutex Variants with Timeouts/Deadlines
+  // ---------------------------------------------------------------------------
+
+  // Mutex::AwaitWithTimeout()
+  // Mutex::AwaitWithDeadline()
+  //
+  // Unlocks this `Mutex` and blocks until simultaneously:
+  //   - either `cond` is true or the {timeout has expired, deadline has passed}
+  //     and
+  //   - this `Mutex` can be reacquired,
+  // then reacquire this `Mutex` in the same mode in which it was previously
+  // held, returning `true` iff `cond` is `true` on return.
+  //
+  // If the condition is initially `true`, the implementation *may* skip the
+  // release/re-acquire step and return immediately.
+  //
+  // Deadlines in the past are equivalent to an immediate deadline.
+  // Negative timeouts are equivalent to a zero timeout.
+  //
+  // This method requires that this thread holds this `Mutex` in some mode.
+  bool AwaitWithTimeout(const Condition &cond, absl::Duration timeout);
+
+  bool AwaitWithDeadline(const Condition &cond, absl::Time deadline);
+
+  // Mutex::LockWhenWithTimeout()
+  // Mutex::ReaderLockWhenWithTimeout()
+  // Mutex::WriterLockWhenWithTimeout()
+  //
+  // Blocks until simultaneously both:
+  //   - either `cond` is `true` or the timeout has expired, and
+  //   - this `Mutex` can be acquired,
+  // then atomically acquires this `Mutex`, returning `true` iff `cond` is
+  // `true` on return.
+  //
+  // Negative timeouts are equivalent to a zero timeout.
+  bool LockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION();
+  bool ReaderLockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
+      ABSL_SHARED_LOCK_FUNCTION();
+  bool WriterLockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    return this->LockWhenWithTimeout(cond, timeout);
+  }
+
+  // Mutex::LockWhenWithDeadline()
+  // Mutex::ReaderLockWhenWithDeadline()
+  // Mutex::WriterLockWhenWithDeadline()
+  //
+  // Blocks until simultaneously both:
+  //   - either `cond` is `true` or the deadline has been passed, and
+  //   - this `Mutex` can be acquired,
+  // then atomically acquires this Mutex, returning `true` iff `cond` is `true`
+  // on return.
+  //
+  // Deadlines in the past are equivalent to an immediate deadline.
+  bool LockWhenWithDeadline(const Condition &cond, absl::Time deadline)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION();
+  bool ReaderLockWhenWithDeadline(const Condition &cond, absl::Time deadline)
+      ABSL_SHARED_LOCK_FUNCTION();
+  bool WriterLockWhenWithDeadline(const Condition &cond, absl::Time deadline)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    return this->LockWhenWithDeadline(cond, deadline);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Debug Support: Invariant Checking, Deadlock Detection, Logging.
+  // ---------------------------------------------------------------------------
+
+  // Mutex::EnableInvariantDebugging()
+  //
+  // If `invariant`!=null and if invariant debugging has been enabled globally,
+  // cause `(*invariant)(arg)` to be called at moments when the invariant for
+  // this `Mutex` should hold (for example: just after acquire, just before
+  // release).
+  //
+  // The routine `invariant` should have no side-effects since it is not
+  // guaranteed how many times it will be called; it should check the invariant
+  // and crash if it does not hold. Enabling global invariant debugging may
+  // substantially reduce `Mutex` performance; it should be set only for
+  // non-production runs.  Optimization options may also disable invariant
+  // checks.
+  void EnableInvariantDebugging(void (*invariant)(void *), void *arg);
+
+  // Mutex::EnableDebugLog()
+  //
+  // Cause all subsequent uses of this `Mutex` to be logged via
+  // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if no previous
+  // call to `EnableInvariantDebugging()` or `EnableDebugLog()` has been made.
+  //
+  // Note: This method substantially reduces `Mutex` performance.
+  void EnableDebugLog(const char *name);
+
+  // Deadlock detection
+
+  // Mutex::ForgetDeadlockInfo()
+  //
+  // Forget any deadlock-detection information previously gathered
+  // about this `Mutex`. Call this method in debug mode when the lock ordering
+  // of a `Mutex` changes.
+  void ForgetDeadlockInfo();
+
+  // Mutex::AssertNotHeld()
+  //
+  // Return immediately if this thread does not hold this `Mutex` in any
+  // mode; otherwise, may report an error (typically by crashing with a
+  // diagnostic), or may return immediately.
+  //
+  // Currently this check is performed only if all of:
+  //    - in debug mode
+  //    - SetMutexDeadlockDetectionMode() has been set to kReport or kAbort
+  //    - number of locks concurrently held by this thread is not large.
+  // are true.
+  void AssertNotHeld() const;
+
+  // Special cases.
+
+  // A `MuHow` is a constant that indicates how a lock should be acquired.
+  // Internal implementation detail.  Clients should ignore.
+  typedef const struct MuHowS *MuHow;
+
+  // Mutex::InternalAttemptToUseMutexInFatalSignalHandler()
+  //
+  // Causes the `Mutex` implementation to prepare itself for re-entry caused by
+  // future use of `Mutex` within a fatal signal handler. This method is
+  // intended for use only for last-ditch attempts to log crash information.
+  // It does not guarantee that attempts to use Mutexes within the handler will
+  // not deadlock; it merely makes other faults less likely.
+  //
+  // WARNING:  This routine must be invoked from a signal handler, and the
+  // signal handler must either loop forever or terminate the process.
+  // Attempts to return from (or `longjmp` out of) the signal handler once this
+  // call has been made may cause arbitrary program behaviour including
+  // crashes and deadlocks.
+  static void InternalAttemptToUseMutexInFatalSignalHandler();
+
+ private:
+  std::atomic<intptr_t> mu_;  // The Mutex state.
+
+  // Post()/Wait() versus associated PerThreadSem; in class for required
+  // friendship with PerThreadSem.
+  static void IncrementSynchSem(Mutex *mu, base_internal::PerThreadSynch *w);
+  static bool DecrementSynchSem(Mutex *mu, base_internal::PerThreadSynch *w,
+                                synchronization_internal::KernelTimeout t);
+
+  // slow path acquire
+  void LockSlowLoop(SynchWaitParams *waitp, int flags);
+  // wrappers around LockSlowLoop()
+  bool LockSlowWithDeadline(MuHow how, const Condition *cond,
+                            synchronization_internal::KernelTimeout t,
+                            int flags);
+  void LockSlow(MuHow how, const Condition *cond,
+                int flags) ABSL_ATTRIBUTE_COLD;
+  // slow path release
+  void UnlockSlow(SynchWaitParams *waitp) ABSL_ATTRIBUTE_COLD;
+  // Common code between Await() and AwaitWithTimeout/Deadline()
+  bool AwaitCommon(const Condition &cond,
+                   synchronization_internal::KernelTimeout t);
+  // Attempt to remove thread s from queue.
+  void TryRemove(base_internal::PerThreadSynch *s);
+  // Block a thread on mutex.
+  void Block(base_internal::PerThreadSynch *s);
+  // Wake a thread; return successor.
+  base_internal::PerThreadSynch *Wakeup(base_internal::PerThreadSynch *w);
+
+  friend class CondVar;   // for access to Trans()/Fer().
+  void Trans(MuHow how);  // used for CondVar->Mutex transfer
+  void Fer(
+      base_internal::PerThreadSynch *w);  // used for CondVar->Mutex transfer
+
+  // Catch the error of writing Mutex when intending MutexLock.
+  Mutex(const volatile Mutex * /*ignored*/) {}  // NOLINT(runtime/explicit)
+
+  Mutex(const Mutex&) = delete;
+  Mutex& operator=(const Mutex&) = delete;
+};
+
+// -----------------------------------------------------------------------------
+// Mutex RAII Wrappers
+// -----------------------------------------------------------------------------
+
+// MutexLock
+//
+// `MutexLock` is a helper class, which acquires and releases a `Mutex` via
+// RAII.
+//
+// Example:
+//
+// Class Foo {
+//  public:
+//   Foo::Bar* Baz() {
+//     MutexLock lock(&mu_);
+//     ...
+//     return bar;
+//   }
+//
+// private:
+//   Mutex mu_;
+// };
+class ABSL_SCOPED_LOCKABLE MutexLock {
+ public:
+  // Constructors
+
+  // Calls `mu->Lock()` and returns when that call returns. That is, `*mu` is
+  // guaranteed to be locked when this object is constructed. Requires that
+  // `mu` be dereferenceable.
+  explicit MutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+    this->mu_->Lock();
+  }
+
+  // Like above, but calls `mu->LockWhen(cond)` instead. That is, in addition to
+  // the above, the condition given by `cond` is also guaranteed to hold when
+  // this object is constructed.
+  explicit MutexLock(Mutex *mu, const Condition &cond)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    this->mu_->LockWhen(cond);
+  }
+
+  MutexLock(const MutexLock &) = delete;  // NOLINT(runtime/mutex)
+  MutexLock(MutexLock&&) = delete;  // NOLINT(runtime/mutex)
+  MutexLock& operator=(const MutexLock&) = delete;
+  MutexLock& operator=(MutexLock&&) = delete;
+
+  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->Unlock(); }
+
+ private:
+  Mutex *const mu_;
+};
+
+// ReaderMutexLock
+//
+// The `ReaderMutexLock` is a helper class, like `MutexLock`, which acquires and
+// releases a shared lock on a `Mutex` via RAII.
+class ABSL_SCOPED_LOCKABLE ReaderMutexLock {
+ public:
+  explicit ReaderMutexLock(Mutex *mu) ABSL_SHARED_LOCK_FUNCTION(mu) : mu_(mu) {
+    mu->ReaderLock();
+  }
+
+  explicit ReaderMutexLock(Mutex *mu, const Condition &cond)
+      ABSL_SHARED_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu->ReaderLockWhen(cond);
+  }
+
+  ReaderMutexLock(const ReaderMutexLock&) = delete;
+  ReaderMutexLock(ReaderMutexLock&&) = delete;
+  ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
+  ReaderMutexLock& operator=(ReaderMutexLock&&) = delete;
+
+  ~ReaderMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->ReaderUnlock(); }
+
+ private:
+  Mutex *const mu_;
+};
+
+// WriterMutexLock
+//
+// The `WriterMutexLock` is a helper class, like `MutexLock`, which acquires and
+// releases a write (exclusive) lock on a `Mutex` via RAII.
+class ABSL_SCOPED_LOCKABLE WriterMutexLock {
+ public:
+  explicit WriterMutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu->WriterLock();
+  }
+
+  explicit WriterMutexLock(Mutex *mu, const Condition &cond)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu->WriterLockWhen(cond);
+  }
+
+  WriterMutexLock(const WriterMutexLock&) = delete;
+  WriterMutexLock(WriterMutexLock&&) = delete;
+  WriterMutexLock& operator=(const WriterMutexLock&) = delete;
+  WriterMutexLock& operator=(WriterMutexLock&&) = delete;
+
+  ~WriterMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->WriterUnlock(); }
+
+ private:
+  Mutex *const mu_;
+};
+
+// -----------------------------------------------------------------------------
+// Condition
+// -----------------------------------------------------------------------------
+//
+// As noted above, `Mutex` contains a number of member functions which take a
+// `Condition` as an argument; clients can wait for conditions to become `true`
+// before attempting to acquire the mutex. These sections are known as
+// "condition critical" sections. To use a `Condition`, you simply need to
+// construct it, and use within an appropriate `Mutex` member function;
+// everything else in the `Condition` class is an implementation detail.
+//
+// A `Condition` is specified as a function pointer which returns a boolean.
+// `Condition` functions should be pure functions -- their results should depend
+// only on passed arguments, should not consult any external state (such as
+// clocks), and should have no side-effects, aside from debug logging. Any
+// objects that the function may access should be limited to those which are
+// constant while the mutex is blocked on the condition (e.g. a stack variable),
+// or objects of state protected explicitly by the mutex.
+//
+// No matter which construction is used for `Condition`, the underlying
+// function pointer / functor / callable must not throw any
+// exceptions. Correctness of `Mutex` / `Condition` is not guaranteed in
+// the face of a throwing `Condition`. (When Abseil is allowed to depend
+// on C++17, these function pointers will be explicitly marked
+// `noexcept`; until then this requirement cannot be enforced in the
+// type system.)
+//
+// Note: to use a `Condition`, you need only construct it and pass it to a
+// suitable `Mutex' member function, such as `Mutex::Await()`, or to the
+// constructor of one of the scope guard classes.
+//
+// Example using LockWhen/Unlock:
+//
+//   // assume count_ is not internal reference count
+//   int count_ ABSL_GUARDED_BY(mu_);
+//   Condition count_is_zero(+[](int *count) { return *count == 0; }, &count_);
+//
+//   mu_.LockWhen(count_is_zero);
+//   // ...
+//   mu_.Unlock();
+//
+// Example using a scope guard:
+//
+//   {
+//     MutexLock lock(&mu_, count_is_zero);
+//     // ...
+//   }
+//
+// When multiple threads are waiting on exactly the same condition, make sure
+// that they are constructed with the same parameters (same pointer to function
+// + arg, or same pointer to object + method), so that the mutex implementation
+// can avoid redundantly evaluating the same condition for each thread.
+class Condition {
+ public:
+  // A Condition that returns the result of "(*func)(arg)"
+  Condition(bool (*func)(void *), void *arg);
+
+  // Templated version for people who are averse to casts.
+  //
+  // To use a lambda, prepend it with unary plus, which converts the lambda
+  // into a function pointer:
+  //     Condition(+[](T* t) { return ...; }, arg).
+  //
+  // Note: lambdas in this case must contain no bound variables.
+  //
+  // See class comment for performance advice.
+  template<typename T>
+  Condition(bool (*func)(T *), T *arg);
+
+  // Templated version for invoking a method that returns a `bool`.
+  //
+  // `Condition(object, &Class::Method)` constructs a `Condition` that evaluates
+  // `object->Method()`.
+  //
+  // Implementation Note: `absl::internal::identity` is used to allow methods to
+  // come from base classes. A simpler signature like
+  // `Condition(T*, bool (T::*)())` does not suffice.
+  template<typename T>
+  Condition(T *object, bool (absl::internal::identity<T>::type::* method)());
+
+  // Same as above, for const members
+  template<typename T>
+  Condition(const T *object,
+            bool (absl::internal::identity<T>::type::* method)() const);
+
+  // A Condition that returns the value of `*cond`
+  explicit Condition(const bool *cond);
+
+  // Templated version for invoking a functor that returns a `bool`.
+  // This approach accepts pointers to non-mutable lambdas, `std::function`,
+  // the result of` std::bind` and user-defined functors that define
+  // `bool F::operator()() const`.
+  //
+  // Example:
+  //
+  //   auto reached = [this, current]() {
+  //     mu_.AssertReaderHeld();                // For annotalysis.
+  //     return processed_ >= current;
+  //   };
+  //   mu_.Await(Condition(&reached));
+  //
+  // NOTE: never use "mu_.AssertHeld()" instead of "mu_.AssertReaderHeld()" in
+  // the lambda as it may be called when the mutex is being unlocked from a
+  // scope holding only a reader lock, which will make the assertion not
+  // fulfilled and crash the binary.
+
+  // See class comment for performance advice. In particular, if there
+  // might be more than one waiter for the same condition, make sure
+  // that all waiters construct the condition with the same pointers.
+
+  // Implementation note: The second template parameter ensures that this
+  // constructor doesn't participate in overload resolution if T doesn't have
+  // `bool operator() const`.
+  template <typename T, typename E = decltype(
+      static_cast<bool (T::*)() const>(&T::operator()))>
+  explicit Condition(const T *obj)
+      : Condition(obj, static_cast<bool (T::*)() const>(&T::operator())) {}
+
+  // A Condition that always returns `true`.
+  static const Condition kTrue;
+
+  // Evaluates the condition.
+  bool Eval() const;
+
+  // Returns `true` if the two conditions are guaranteed to return the same
+  // value if evaluated at the same time, `false` if the evaluation *may* return
+  // different results.
+  //
+  // Two `Condition` values are guaranteed equal if both their `func` and `arg`
+  // components are the same. A null pointer is equivalent to a `true`
+  // condition.
+  static bool GuaranteedEqual(const Condition *a, const Condition *b);
+
+ private:
+  typedef bool (*InternalFunctionType)(void * arg);
+  typedef bool (Condition::*InternalMethodType)();
+  typedef bool (*InternalMethodCallerType)(void * arg,
+                                           InternalMethodType internal_method);
+
+  bool (*eval_)(const Condition*);  // Actual evaluator
+  InternalFunctionType function_;   // function taking pointer returning bool
+  InternalMethodType method_;       // method returning bool
+  void *arg_;                       // arg of function_ or object of method_
+
+  Condition();        // null constructor used only to create kTrue
+
+  // Various functions eval_ can point to:
+  static bool CallVoidPtrFunction(const Condition*);
+  template <typename T> static bool CastAndCallFunction(const Condition* c);
+  template <typename T> static bool CastAndCallMethod(const Condition* c);
+};
+
+// -----------------------------------------------------------------------------
+// CondVar
+// -----------------------------------------------------------------------------
+//
+// A condition variable, reflecting state evaluated separately outside of the
+// `Mutex` object, which can be signaled to wake callers.
+// This class is not normally needed; use `Mutex` member functions such as
+// `Mutex::Await()` and intrinsic `Condition` abstractions. In rare cases
+// with many threads and many conditions, `CondVar` may be faster.
+//
+// The implementation may deliver signals to any condition variable at
+// any time, even when no call to `Signal()` or `SignalAll()` is made; as a
+// result, upon being awoken, you must check the logical condition you have
+// been waiting upon.
+//
+// Examples:
+//
+// Usage for a thread waiting for some condition C protected by mutex mu:
+//       mu.Lock();
+//       while (!C) { cv->Wait(&mu); }        // releases and reacquires mu
+//       //  C holds; process data
+//       mu.Unlock();
+//
+// Usage to wake T is:
+//       mu.Lock();
+//       // process data, possibly establishing C
+//       if (C) { cv->Signal(); }
+//       mu.Unlock();
+//
+// If C may be useful to more than one waiter, use `SignalAll()` instead of
+// `Signal()`.
+//
+// With this implementation it is efficient to use `Signal()/SignalAll()` inside
+// the locked region; this usage can make reasoning about your program easier.
+//
+class CondVar {
+ public:
+  // A `CondVar` allocated on the heap or on the stack can use the this
+  // constructor.
+  CondVar();
+  ~CondVar();
+
+  // CondVar::Wait()
+  //
+  // Atomically releases a `Mutex` and blocks on this condition variable.
+  // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+  // spurious wakeup), then reacquires the `Mutex` and returns.
+  //
+  // Requires and ensures that the current thread holds the `Mutex`.
+  void Wait(Mutex *mu);
+
+  // CondVar::WaitWithTimeout()
+  //
+  // Atomically releases a `Mutex` and blocks on this condition variable.
+  // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+  // spurious wakeup), or until the timeout has expired, then reacquires
+  // the `Mutex` and returns.
+  //
+  // Returns true if the timeout has expired without this `CondVar`
+  // being signalled in any manner. If both the timeout has expired
+  // and this `CondVar` has been signalled, the implementation is free
+  // to return `true` or `false`.
+  //
+  // Requires and ensures that the current thread holds the `Mutex`.
+  bool WaitWithTimeout(Mutex *mu, absl::Duration timeout);
+
+  // CondVar::WaitWithDeadline()
+  //
+  // Atomically releases a `Mutex` and blocks on this condition variable.
+  // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+  // spurious wakeup), or until the deadline has passed, then reacquires
+  // the `Mutex` and returns.
+  //
+  // Deadlines in the past are equivalent to an immediate deadline.
+  //
+  // Returns true if the deadline has passed without this `CondVar`
+  // being signalled in any manner. If both the deadline has passed
+  // and this `CondVar` has been signalled, the implementation is free
+  // to return `true` or `false`.
+  //
+  // Requires and ensures that the current thread holds the `Mutex`.
+  bool WaitWithDeadline(Mutex *mu, absl::Time deadline);
+
+  // CondVar::Signal()
+  //
+  // Signal this `CondVar`; wake at least one waiter if one exists.
+  void Signal();
+
+  // CondVar::SignalAll()
+  //
+  // Signal this `CondVar`; wake all waiters.
+  void SignalAll();
+
+  // CondVar::EnableDebugLog()
+  //
+  // Causes all subsequent uses of this `CondVar` to be logged via
+  // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if `name != 0`.
+  // Note: this method substantially reduces `CondVar` performance.
+  void EnableDebugLog(const char *name);
+
+ private:
+  bool WaitCommon(Mutex *mutex, synchronization_internal::KernelTimeout t);
+  void Remove(base_internal::PerThreadSynch *s);
+  void Wakeup(base_internal::PerThreadSynch *w);
+  std::atomic<intptr_t> cv_;  // Condition variable state.
+  CondVar(const CondVar&) = delete;
+  CondVar& operator=(const CondVar&) = delete;
+};
+
+
+// Variants of MutexLock.
+//
+// If you find yourself using one of these, consider instead using
+// Mutex::Unlock() and/or if-statements for clarity.
+
+// MutexLockMaybe
+//
+// MutexLockMaybe is like MutexLock, but is a no-op when mu is null.
+class ABSL_SCOPED_LOCKABLE MutexLockMaybe {
+ public:
+  explicit MutexLockMaybe(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    if (this->mu_ != nullptr) {
+      this->mu_->Lock();
+    }
+  }
+
+  explicit MutexLockMaybe(Mutex *mu, const Condition &cond)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    if (this->mu_ != nullptr) {
+      this->mu_->LockWhen(cond);
+    }
+  }
+
+  ~MutexLockMaybe() ABSL_UNLOCK_FUNCTION() {
+    if (this->mu_ != nullptr) { this->mu_->Unlock(); }
+  }
+
+ private:
+  Mutex *const mu_;
+  MutexLockMaybe(const MutexLockMaybe&) = delete;
+  MutexLockMaybe(MutexLockMaybe&&) = delete;
+  MutexLockMaybe& operator=(const MutexLockMaybe&) = delete;
+  MutexLockMaybe& operator=(MutexLockMaybe&&) = delete;
+};
+
+// ReleasableMutexLock
+//
+// ReleasableMutexLock is like MutexLock, but permits `Release()` of its
+// mutex before destruction. `Release()` may be called at most once.
+class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
+ public:
+  explicit ReleasableMutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    this->mu_->Lock();
+  }
+
+  explicit ReleasableMutexLock(Mutex *mu, const Condition &cond)
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    this->mu_->LockWhen(cond);
+  }
+
+  ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+    if (this->mu_ != nullptr) { this->mu_->Unlock(); }
+  }
+
+  void Release() ABSL_UNLOCK_FUNCTION();
+
+ private:
+  Mutex *mu_;
+  ReleasableMutexLock(const ReleasableMutexLock&) = delete;
+  ReleasableMutexLock(ReleasableMutexLock&&) = delete;
+  ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
+  ReleasableMutexLock& operator=(ReleasableMutexLock&&) = delete;
+};
+
+inline Mutex::Mutex() : mu_(0) {
+  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+}
+
+inline constexpr Mutex::Mutex(absl::ConstInitType) : mu_(0) {}
+
+inline CondVar::CondVar() : cv_(0) {}
+
+// static
+template <typename T>
+bool Condition::CastAndCallMethod(const Condition *c) {
+  typedef bool (T::*MemberType)();
+  MemberType rm = reinterpret_cast<MemberType>(c->method_);
+  T *x = static_cast<T *>(c->arg_);
+  return (x->*rm)();
+}
+
+// static
+template <typename T>
+bool Condition::CastAndCallFunction(const Condition *c) {
+  typedef bool (*FuncType)(T *);
+  FuncType fn = reinterpret_cast<FuncType>(c->function_);
+  T *x = static_cast<T *>(c->arg_);
+  return (*fn)(x);
+}
+
+template <typename T>
+inline Condition::Condition(bool (*func)(T *), T *arg)
+    : eval_(&CastAndCallFunction<T>),
+      function_(reinterpret_cast<InternalFunctionType>(func)),
+      method_(nullptr),
+      arg_(const_cast<void *>(static_cast<const void *>(arg))) {}
+
+template <typename T>
+inline Condition::Condition(T *object,
+                            bool (absl::internal::identity<T>::type::*method)())
+    : eval_(&CastAndCallMethod<T>),
+      function_(nullptr),
+      method_(reinterpret_cast<InternalMethodType>(method)),
+      arg_(object) {}
+
+template <typename T>
+inline Condition::Condition(const T *object,
+                            bool (absl::internal::identity<T>::type::*method)()
+                                const)
+    : eval_(&CastAndCallMethod<T>),
+      function_(nullptr),
+      method_(reinterpret_cast<InternalMethodType>(method)),
+      arg_(reinterpret_cast<void *>(const_cast<T *>(object))) {}
+
+// Register a hook for profiling support.
+//
+// The function pointer registered here will be called whenever a mutex is
+// contended.  The callback is given the cycles for which waiting happened (as
+// measured by //absl/base/internal/cycleclock.h, and which may not
+// be real "cycle" counts.)
+//
+// Calls to this function do not race or block, but there is no ordering
+// guaranteed between calls to this function and call to the provided hook.
+// In particular, the previously registered hook may still be called for some
+// time after this function returns.
+void RegisterMutexProfiler(void (*fn)(int64_t wait_cycles));
+
+// Register a hook for Mutex tracing.
+//
+// The function pointer registered here will be called whenever a mutex is
+// contended.  The callback is given an opaque handle to the contended mutex,
+// an event name, and the number of wait cycles (as measured by
+// //absl/base/internal/cycleclock.h, and which may not be real
+// "cycle" counts.)
+//
+// The only event name currently sent is "slow release".
+//
+// This has the same memory ordering concerns as RegisterMutexProfiler() above.
+void RegisterMutexTracer(void (*fn)(const char *msg, const void *obj,
+                                    int64_t wait_cycles));
+
+// TODO(gfalcon): Combine RegisterMutexProfiler() and RegisterMutexTracer()
+// into a single interface, since they are only ever called in pairs.
+
+// Register a hook for CondVar tracing.
+//
+// The function pointer registered here will be called here on various CondVar
+// events.  The callback is given an opaque handle to the CondVar object and
+// a string identifying the event.  This is thread-safe, but only a single
+// tracer can be registered.
+//
+// Events that can be sent are "Wait", "Unwait", "Signal wakeup", and
+// "SignalAll wakeup".
+//
+// This has the same memory ordering concerns as RegisterMutexProfiler() above.
+void RegisterCondVarTracer(void (*fn)(const char *msg, const void *cv));
+
+// Register a hook for symbolizing stack traces in deadlock detector reports.
+//
+// 'pc' is the program counter being symbolized, 'out' is the buffer to write
+// into, and 'out_size' is the size of the buffer.  This function can return
+// false if symbolizing failed, or true if a NUL-terminated symbol was written
+// to 'out.'
+//
+// This has the same memory ordering concerns as RegisterMutexProfiler() above.
+//
+// DEPRECATED: The default symbolizer function is absl::Symbolize() and the
+// ability to register a different hook for symbolizing stack traces will be
+// removed on or after 2023-05-01.
+ABSL_DEPRECATED("absl::RegisterSymbolizer() is deprecated and will be removed "
+                "on or after 2023-05-01")
+void RegisterSymbolizer(bool (*fn)(const void *pc, char *out, int out_size));
+
+// EnableMutexInvariantDebugging()
+//
+// Enable or disable global support for Mutex invariant debugging.  If enabled,
+// then invariant predicates can be registered per-Mutex for debug checking.
+// See Mutex::EnableInvariantDebugging().
+void EnableMutexInvariantDebugging(bool enabled);
+
+// When in debug mode, and when the feature has been enabled globally, the
+// implementation will keep track of lock ordering and complain (or optionally
+// crash) if a cycle is detected in the acquired-before graph.
+
+// Possible modes of operation for the deadlock detector in debug mode.
+enum class OnDeadlockCycle {
+  kIgnore,  // Neither report on nor attempt to track cycles in lock ordering
+  kReport,  // Report lock cycles to stderr when detected
+  kAbort,  // Report lock cycles to stderr when detected, then abort
+};
+
+// SetMutexDeadlockDetectionMode()
+//
+// Enable or disable global support for detection of potential deadlocks
+// due to Mutex lock ordering inversions.  When set to 'kIgnore', tracking of
+// lock ordering is disabled.  Otherwise, in debug builds, a lock ordering graph
+// will be maintained internally, and detected cycles will be reported in
+// the manner chosen here.
+void SetMutexDeadlockDetectionMode(OnDeadlockCycle mode);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// In some build configurations we pass --detect-odr-violations to the
+// gold linker.  This causes it to flag weak symbol overrides as ODR
+// violations.  Because ODR only applies to C++ and not C,
+// --detect-odr-violations ignores symbols not mangled with C++ names.
+// By changing our extension points to be extern "C", we dodge this
+// check.
+extern "C" {
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
+}  // extern "C"
+
+#endif  // ABSL_SYNCHRONIZATION_MUTEX_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/notification.h b/CAPI/cpp/grpc/include/absl/synchronization/notification.h
new file mode 100644
index 0000000..4bec268
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/synchronization/notification.h
@@ -0,0 +1,124 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// notification.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a `Notification` abstraction, which allows threads
+// to receive notification of a single occurrence of a single event.
+//
+// The `Notification` object maintains a private boolean "notified" state that
+// transitions to `true` at most once. The `Notification` class provides the
+// following primary member functions:
+//   * `HasBeenNotified()` to query its state
+//   * `WaitForNotification*()` to have threads wait until the "notified" state
+//      is `true`.
+//   * `Notify()` to set the notification's "notified" state to `true` and
+//     notify all waiting threads that the event has occurred.
+//     This method may only be called once.
+//
+// Note that while `Notify()` may only be called once, it is perfectly valid to
+// call any of the `WaitForNotification*()` methods multiple times, from
+// multiple threads -- even after the notification's "notified" state has been
+// set -- in which case those methods will immediately return.
+//
+// Note that the lifetime of a `Notification` requires careful consideration;
+// it might not be safe to destroy a notification after calling `Notify()` since
+// it is still legal for other threads to call `WaitForNotification*()` methods
+// on the notification. However, observers responding to a "notified" state of
+// `true` can safely delete the notification without interfering with the call
+// to `Notify()` in the other thread.
+//
+// Memory ordering: For any threads X and Y, if X calls `Notify()`, then any
+// action taken by X before it calls `Notify()` is visible to thread Y after:
+//  * Y returns from `WaitForNotification()`, or
+//  * Y receives a `true` return value from either `HasBeenNotified()` or
+//    `WaitForNotificationWithTimeout()`.
+
+#ifndef ABSL_SYNCHRONIZATION_NOTIFICATION_H_
+#define ABSL_SYNCHRONIZATION_NOTIFICATION_H_
+
+#include <atomic>
+
+#include "absl/base/attributes.h"
+#include "absl/base/macros.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// Notification
+// -----------------------------------------------------------------------------
+class Notification {
+ public:
+  // Initializes the "notified" state to unnotified.
+  Notification() : notified_yet_(false) {}
+  explicit Notification(bool prenotify) : notified_yet_(prenotify) {}
+  Notification(const Notification&) = delete;
+  Notification& operator=(const Notification&) = delete;
+  ~Notification();
+
+  // Notification::HasBeenNotified()
+  //
+  // Returns the value of the notification's internal "notified" state.
+  ABSL_MUST_USE_RESULT bool HasBeenNotified() const {
+    return HasBeenNotifiedInternal(&this->notified_yet_);
+  }
+
+  // Notification::WaitForNotification()
+  //
+  // Blocks the calling thread until the notification's "notified" state is
+  // `true`. Note that if `Notify()` has been previously called on this
+  // notification, this function will immediately return.
+  void WaitForNotification() const;
+
+  // Notification::WaitForNotificationWithTimeout()
+  //
+  // Blocks until either the notification's "notified" state is `true` (which
+  // may occur immediately) or the timeout has elapsed, returning the value of
+  // its "notified" state in either case.
+  bool WaitForNotificationWithTimeout(absl::Duration timeout) const;
+
+  // Notification::WaitForNotificationWithDeadline()
+  //
+  // Blocks until either the notification's "notified" state is `true` (which
+  // may occur immediately) or the deadline has expired, returning the value of
+  // its "notified" state in either case.
+  bool WaitForNotificationWithDeadline(absl::Time deadline) const;
+
+  // Notification::Notify()
+  //
+  // Sets the "notified" state of this notification to `true` and wakes waiting
+  // threads. Note: do not call `Notify()` multiple times on the same
+  // `Notification`; calling `Notify()` more than once on the same notification
+  // results in undefined behavior.
+  void Notify();
+
+ private:
+  static inline bool HasBeenNotifiedInternal(
+      const std::atomic<bool>* notified_yet) {
+    return notified_yet->load(std::memory_order_acquire);
+  }
+
+  mutable Mutex mutex_;
+  std::atomic<bool> notified_yet_;  // written under mutex_
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_SYNCHRONIZATION_NOTIFICATION_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/civil_time.h b/CAPI/cpp/grpc/include/absl/time/civil_time.h
new file mode 100644
index 0000000..bb46004
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/civil_time.h
@@ -0,0 +1,538 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: civil_time.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines abstractions for computing with "civil time".
+// The term "civil time" refers to the legally recognized human-scale time
+// that is represented by the six fields `YYYY-MM-DD hh:mm:ss`. A "date"
+// is perhaps the most common example of a civil time (represented here as
+// an `absl::CivilDay`).
+//
+// Modern-day civil time follows the Gregorian Calendar and is a
+// time-zone-independent concept: a civil time of "2015-06-01 12:00:00", for
+// example, is not tied to a time zone. Put another way, a civil time does not
+// map to a unique point in time; a civil time must be mapped to an absolute
+// time *through* a time zone.
+//
+// Because a civil time is what most people think of as "time," it is common to
+// map absolute times to civil times to present to users.
+//
+// Time zones define the relationship between absolute and civil times. Given an
+// absolute or civil time and a time zone, you can compute the other time:
+//
+//   Civil Time = F(Absolute Time, Time Zone)
+//   Absolute Time = G(Civil Time, Time Zone)
+//
+// The Abseil time library allows you to construct such civil times from
+// absolute times; consult time.h for such functionality.
+//
+// This library provides six classes for constructing civil-time objects, and
+// provides several helper functions for rounding, iterating, and performing
+// arithmetic on civil-time objects, while avoiding complications like
+// daylight-saving time (DST):
+//
+//   * `absl::CivilSecond`
+//   * `absl::CivilMinute`
+//   * `absl::CivilHour`
+//   * `absl::CivilDay`
+//   * `absl::CivilMonth`
+//   * `absl::CivilYear`
+//
+// Example:
+//
+//   // Construct a civil-time object for a specific day
+//   const absl::CivilDay cd(1969, 07, 20);
+//
+//   // Construct a civil-time object for a specific second
+//   const absl::CivilSecond cd(2018, 8, 1, 12, 0, 1);
+//
+// Note: In C++14 and later, this library is usable in a constexpr context.
+//
+// Example:
+//
+//   // Valid in C++14
+//   constexpr absl::CivilDay cd(1969, 07, 20);
+
+#ifndef ABSL_TIME_CIVIL_TIME_H_
+#define ABSL_TIME_CIVIL_TIME_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace time_internal {
+struct second_tag : cctz::detail::second_tag {};
+struct minute_tag : second_tag, cctz::detail::minute_tag {};
+struct hour_tag : minute_tag, cctz::detail::hour_tag {};
+struct day_tag : hour_tag, cctz::detail::day_tag {};
+struct month_tag : day_tag, cctz::detail::month_tag {};
+struct year_tag : month_tag, cctz::detail::year_tag {};
+}  // namespace time_internal
+
+// -----------------------------------------------------------------------------
+// CivilSecond, CivilMinute, CivilHour, CivilDay, CivilMonth, CivilYear
+// -----------------------------------------------------------------------------
+//
+// Each of these civil-time types is a simple value type with the same
+// interface for construction and the same six accessors for each of the civil
+// time fields (year, month, day, hour, minute, and second, aka YMDHMS). These
+// classes differ only in their alignment, which is indicated by the type name
+// and specifies the field on which arithmetic operates.
+//
+// CONSTRUCTION
+//
+// Each of the civil-time types can be constructed in two ways: by directly
+// passing to the constructor up to six integers representing the YMDHMS fields,
+// or by copying the YMDHMS fields from a differently aligned civil-time type.
+// Omitted fields are assigned their minimum valid value. Hours, minutes, and
+// seconds will be set to 0, month and day will be set to 1. Since there is no
+// minimum year, the default is 1970.
+//
+// Examples:
+//
+//   absl::CivilDay default_value;               // 1970-01-01 00:00:00
+//
+//   absl::CivilDay a(2015, 2, 3);               // 2015-02-03 00:00:00
+//   absl::CivilDay b(2015, 2, 3, 4, 5, 6);      // 2015-02-03 00:00:00
+//   absl::CivilDay c(2015);                     // 2015-01-01 00:00:00
+//
+//   absl::CivilSecond ss(2015, 2, 3, 4, 5, 6);  // 2015-02-03 04:05:06
+//   absl::CivilMinute mm(ss);                   // 2015-02-03 04:05:00
+//   absl::CivilHour hh(mm);                     // 2015-02-03 04:00:00
+//   absl::CivilDay d(hh);                       // 2015-02-03 00:00:00
+//   absl::CivilMonth m(d);                      // 2015-02-01 00:00:00
+//   absl::CivilYear y(m);                       // 2015-01-01 00:00:00
+//
+//   m = absl::CivilMonth(y);                    // 2015-01-01 00:00:00
+//   d = absl::CivilDay(m);                      // 2015-01-01 00:00:00
+//   hh = absl::CivilHour(d);                    // 2015-01-01 00:00:00
+//   mm = absl::CivilMinute(hh);                 // 2015-01-01 00:00:00
+//   ss = absl::CivilSecond(mm);                 // 2015-01-01 00:00:00
+//
+// Each civil-time class is aligned to the civil-time field indicated in the
+// class's name after normalization. Alignment is performed by setting all the
+// inferior fields to their minimum valid value (as described above). The
+// following are examples of how each of the six types would align the fields
+// representing November 22, 2015 at 12:34:56 in the afternoon. (Note: the
+// string format used here is not important; it's just a shorthand way of
+// showing the six YMDHMS fields.)
+//
+//   absl::CivilSecond   : 2015-11-22 12:34:56
+//   absl::CivilMinute   : 2015-11-22 12:34:00
+//   absl::CivilHour     : 2015-11-22 12:00:00
+//   absl::CivilDay      : 2015-11-22 00:00:00
+//   absl::CivilMonth    : 2015-11-01 00:00:00
+//   absl::CivilYear     : 2015-01-01 00:00:00
+//
+// Each civil-time type performs arithmetic on the field to which it is
+// aligned. This means that adding 1 to an absl::CivilDay increments the day
+// field (normalizing as necessary), and subtracting 7 from an absl::CivilMonth
+// operates on the month field (normalizing as necessary). All arithmetic
+// produces a valid civil time. Difference requires two similarly aligned
+// civil-time objects and returns the scalar answer in units of the objects'
+// alignment. For example, the difference between two absl::CivilHour objects
+// will give an answer in units of civil hours.
+//
+// ALIGNMENT CONVERSION
+//
+// The alignment of a civil-time object cannot change, but the object may be
+// used to construct a new object with a different alignment. This is referred
+// to as "realigning". When realigning to a type with the same or more
+// precision (e.g., absl::CivilDay -> absl::CivilSecond), the conversion may be
+// performed implicitly since no information is lost. However, if information
+// could be discarded (e.g., CivilSecond -> CivilDay), the conversion must
+// be explicit at the call site.
+//
+// Examples:
+//
+//   void UseDay(absl::CivilDay day);
+//
+//   absl::CivilSecond cs;
+//   UseDay(cs);                  // Won't compile because data may be discarded
+//   UseDay(absl::CivilDay(cs));  // OK: explicit conversion
+//
+//   absl::CivilDay cd;
+//   UseDay(cd);                  // OK: no conversion needed
+//
+//   absl::CivilMonth cm;
+//   UseDay(cm);                  // OK: implicit conversion to absl::CivilDay
+//
+// NORMALIZATION
+//
+// Normalization takes invalid values and adjusts them to produce valid values.
+// Within the civil-time library, integer arguments passed to the Civil*
+// constructors may be out-of-range, in which case they are normalized by
+// carrying overflow into a field of courser granularity to produce valid
+// civil-time objects. This normalization enables natural arithmetic on
+// constructor arguments without worrying about the field's range.
+//
+// Examples:
+//
+//   // Out-of-range; normalized to 2016-11-01
+//   absl::CivilDay d(2016, 10, 32);
+//   // Out-of-range, negative: normalized to 2016-10-30T23
+//   absl::CivilHour h1(2016, 10, 31, -1);
+//   // Normalization is cumulative: normalized to 2016-10-30T23
+//   absl::CivilHour h2(2016, 10, 32, -25);
+//
+// Note: If normalization is undesired, you can signal an error by comparing
+// the constructor arguments to the normalized values returned by the YMDHMS
+// properties.
+//
+// COMPARISON
+//
+// Comparison between civil-time objects considers all six YMDHMS fields,
+// regardless of the type's alignment. Comparison between differently aligned
+// civil-time types is allowed.
+//
+// Examples:
+//
+//   absl::CivilDay feb_3(2015, 2, 3);  // 2015-02-03 00:00:00
+//   absl::CivilDay mar_4(2015, 3, 4);  // 2015-03-04 00:00:00
+//   // feb_3 < mar_4
+//   // absl::CivilYear(feb_3) == absl::CivilYear(mar_4)
+//
+//   absl::CivilSecond feb_3_noon(2015, 2, 3, 12, 0, 0);  // 2015-02-03 12:00:00
+//   // feb_3 < feb_3_noon
+//   // feb_3 == absl::CivilDay(feb_3_noon)
+//
+//   // Iterates all the days of February 2015.
+//   for (absl::CivilDay d(2015, 2, 1); d < absl::CivilMonth(2015, 3); ++d) {
+//     // ...
+//   }
+//
+// ARITHMETIC
+//
+// Civil-time types support natural arithmetic operators such as addition,
+// subtraction, and difference. Arithmetic operates on the civil-time field
+// indicated in the type's name. Difference operators require arguments with
+// the same alignment and return the answer in units of the alignment.
+//
+// Example:
+//
+//   absl::CivilDay a(2015, 2, 3);
+//   ++a;                              // 2015-02-04 00:00:00
+//   --a;                              // 2015-02-03 00:00:00
+//   absl::CivilDay b = a + 1;         // 2015-02-04 00:00:00
+//   absl::CivilDay c = 1 + b;         // 2015-02-05 00:00:00
+//   int n = c - a;                    // n = 2 (civil days)
+//   int m = c - absl::CivilMonth(c);  // Won't compile: different types.
+//
+// ACCESSORS
+//
+// Each civil-time type has accessors for all six of the civil-time fields:
+// year, month, day, hour, minute, and second.
+//
+// civil_year_t year()
+// int          month()
+// int          day()
+// int          hour()
+// int          minute()
+// int          second()
+//
+// Recall that fields inferior to the type's alignment will be set to their
+// minimum valid value.
+//
+// Example:
+//
+//   absl::CivilDay d(2015, 6, 28);
+//   // d.year() == 2015
+//   // d.month() == 6
+//   // d.day() == 28
+//   // d.hour() == 0
+//   // d.minute() == 0
+//   // d.second() == 0
+//
+// CASE STUDY: Adding a month to January 31.
+//
+// One of the classic questions that arises when considering a civil time
+// library (or a date library or a date/time library) is this:
+//   "What is the result of adding a month to January 31?"
+// This is an interesting question because it is unclear what is meant by a
+// "month", and several different answers are possible, depending on context:
+//
+//   1. March 3 (or 2 if a leap year), if "add a month" means to add a month to
+//      the current month, and adjust the date to overflow the extra days into
+//      March. In this case the result of "February 31" would be normalized as
+//      within the civil-time library.
+//   2. February 28 (or 29 if a leap year), if "add a month" means to add a
+//      month, and adjust the date while holding the resulting month constant.
+//      In this case, the result of "February 31" would be truncated to the last
+//      day in February.
+//   3. An error. The caller may get some error, an exception, an invalid date
+//      object, or perhaps return `false`. This may make sense because there is
+//      no single unambiguously correct answer to the question.
+//
+// Practically speaking, any answer that is not what the programmer intended
+// is the wrong answer.
+//
+// The Abseil time library avoids this problem by making it impossible to
+// ask ambiguous questions. All civil-time objects are aligned to a particular
+// civil-field boundary (such as aligned to a year, month, day, hour, minute,
+// or second), and arithmetic operates on the field to which the object is
+// aligned. This means that in order to "add a month" the object must first be
+// aligned to a month boundary, which is equivalent to the first day of that
+// month.
+//
+// Of course, there are ways to compute an answer the question at hand using
+// this Abseil time library, but they require the programmer to be explicit
+// about the answer they expect. To illustrate, let's see how to compute all
+// three of the above possible answers to the question of "Jan 31 plus 1
+// month":
+//
+// Example:
+//
+//   const absl::CivilDay d(2015, 1, 31);
+//
+//   // Answer 1:
+//   // Add 1 to the month field in the constructor, and rely on normalization.
+//   const auto normalized = absl::CivilDay(d.year(), d.month() + 1, d.day());
+//   // normalized == 2015-03-03 (aka Feb 31)
+//
+//   // Answer 2:
+//   // Add 1 to month field, capping to the end of next month.
+//   const auto next_month = absl::CivilMonth(d) + 1;
+//   const auto last_day_of_next_month = absl::CivilDay(next_month + 1) - 1;
+//   const auto capped = std::min(normalized, last_day_of_next_month);
+//   // capped == 2015-02-28
+//
+//   // Answer 3:
+//   // Signal an error if the normalized answer is not in next month.
+//   if (absl::CivilMonth(normalized) != next_month) {
+//     // error, month overflow
+//   }
+//
+using CivilSecond =
+    time_internal::cctz::detail::civil_time<time_internal::second_tag>;
+using CivilMinute =
+    time_internal::cctz::detail::civil_time<time_internal::minute_tag>;
+using CivilHour =
+    time_internal::cctz::detail::civil_time<time_internal::hour_tag>;
+using CivilDay =
+    time_internal::cctz::detail::civil_time<time_internal::day_tag>;
+using CivilMonth =
+    time_internal::cctz::detail::civil_time<time_internal::month_tag>;
+using CivilYear =
+    time_internal::cctz::detail::civil_time<time_internal::year_tag>;
+
+// civil_year_t
+//
+// Type alias of a civil-time year value. This type is guaranteed to (at least)
+// support any year value supported by `time_t`.
+//
+// Example:
+//
+//   absl::CivilSecond cs = ...;
+//   absl::civil_year_t y = cs.year();
+//   cs = absl::CivilSecond(y, 1, 1, 0, 0, 0);  // CivilSecond(CivilYear(cs))
+//
+using civil_year_t = time_internal::cctz::year_t;
+
+// civil_diff_t
+//
+// Type alias of the difference between two civil-time values.
+// This type is used to indicate arguments that are not
+// normalized (such as parameters to the civil-time constructors), the results
+// of civil-time subtraction, or the operand to civil-time addition.
+//
+// Example:
+//
+//   absl::civil_diff_t n_sec = cs1 - cs2;             // cs1 == cs2 + n_sec;
+//
+using civil_diff_t = time_internal::cctz::diff_t;
+
+// Weekday::monday, Weekday::tuesday, Weekday::wednesday, Weekday::thursday,
+// Weekday::friday, Weekday::saturday, Weekday::sunday
+//
+// The Weekday enum class represents the civil-time concept of a "weekday" with
+// members for all days of the week.
+//
+//   absl::Weekday wd = absl::Weekday::thursday;
+//
+using Weekday = time_internal::cctz::weekday;
+
+// GetWeekday()
+//
+// Returns the absl::Weekday for the given (realigned) civil-time value.
+//
+// Example:
+//
+//   absl::CivilDay a(2015, 8, 13);
+//   absl::Weekday wd = absl::GetWeekday(a);  // wd == absl::Weekday::thursday
+//
+inline Weekday GetWeekday(CivilSecond cs) {
+  return time_internal::cctz::get_weekday(cs);
+}
+
+// NextWeekday()
+// PrevWeekday()
+//
+// Returns the absl::CivilDay that strictly follows or precedes a given
+// absl::CivilDay, and that falls on the given absl::Weekday.
+//
+// Example, given the following month:
+//
+//       August 2015
+//   Su Mo Tu We Th Fr Sa
+//                      1
+//    2  3  4  5  6  7  8
+//    9 10 11 12 13 14 15
+//   16 17 18 19 20 21 22
+//   23 24 25 26 27 28 29
+//   30 31
+//
+//   absl::CivilDay a(2015, 8, 13);
+//   // absl::GetWeekday(a) == absl::Weekday::thursday
+//   absl::CivilDay b = absl::NextWeekday(a, absl::Weekday::thursday);
+//   // b = 2015-08-20
+//   absl::CivilDay c = absl::PrevWeekday(a, absl::Weekday::thursday);
+//   // c = 2015-08-06
+//
+//   absl::CivilDay d = ...
+//   // Gets the following Thursday if d is not already Thursday
+//   absl::CivilDay thurs1 = absl::NextWeekday(d - 1, absl::Weekday::thursday);
+//   // Gets the previous Thursday if d is not already Thursday
+//   absl::CivilDay thurs2 = absl::PrevWeekday(d + 1, absl::Weekday::thursday);
+//
+inline CivilDay NextWeekday(CivilDay cd, Weekday wd) {
+  return CivilDay(time_internal::cctz::next_weekday(cd, wd));
+}
+inline CivilDay PrevWeekday(CivilDay cd, Weekday wd) {
+  return CivilDay(time_internal::cctz::prev_weekday(cd, wd));
+}
+
+// GetYearDay()
+//
+// Returns the day-of-year for the given (realigned) civil-time value.
+//
+// Example:
+//
+//   absl::CivilDay a(2015, 1, 1);
+//   int yd_jan_1 = absl::GetYearDay(a);   // yd_jan_1 = 1
+//   absl::CivilDay b(2015, 12, 31);
+//   int yd_dec_31 = absl::GetYearDay(b);  // yd_dec_31 = 365
+//
+inline int GetYearDay(CivilSecond cs) {
+  return time_internal::cctz::get_yearday(cs);
+}
+
+// FormatCivilTime()
+//
+// Formats the given civil-time value into a string value of the following
+// format:
+//
+//  Type        | Format
+//  ---------------------------------
+//  CivilSecond | YYYY-MM-DDTHH:MM:SS
+//  CivilMinute | YYYY-MM-DDTHH:MM
+//  CivilHour   | YYYY-MM-DDTHH
+//  CivilDay    | YYYY-MM-DD
+//  CivilMonth  | YYYY-MM
+//  CivilYear   | YYYY
+//
+// Example:
+//
+//   absl::CivilDay d = absl::CivilDay(1969, 7, 20);
+//   std::string day_string = absl::FormatCivilTime(d);  // "1969-07-20"
+//
+std::string FormatCivilTime(CivilSecond c);
+std::string FormatCivilTime(CivilMinute c);
+std::string FormatCivilTime(CivilHour c);
+std::string FormatCivilTime(CivilDay c);
+std::string FormatCivilTime(CivilMonth c);
+std::string FormatCivilTime(CivilYear c);
+
+// absl::ParseCivilTime()
+//
+// Parses a civil-time value from the specified `absl::string_view` into the
+// passed output parameter. Returns `true` upon successful parsing.
+//
+// The expected form of the input string is as follows:
+//
+//  Type        | Format
+//  ---------------------------------
+//  CivilSecond | YYYY-MM-DDTHH:MM:SS
+//  CivilMinute | YYYY-MM-DDTHH:MM
+//  CivilHour   | YYYY-MM-DDTHH
+//  CivilDay    | YYYY-MM-DD
+//  CivilMonth  | YYYY-MM
+//  CivilYear   | YYYY
+//
+// Example:
+//
+//   absl::CivilDay d;
+//   bool ok = absl::ParseCivilTime("2018-01-02", &d); // OK
+//
+// Note that parsing will fail if the string's format does not match the
+// expected type exactly. `ParseLenientCivilTime()` below is more lenient.
+//
+bool ParseCivilTime(absl::string_view s, CivilSecond* c);
+bool ParseCivilTime(absl::string_view s, CivilMinute* c);
+bool ParseCivilTime(absl::string_view s, CivilHour* c);
+bool ParseCivilTime(absl::string_view s, CivilDay* c);
+bool ParseCivilTime(absl::string_view s, CivilMonth* c);
+bool ParseCivilTime(absl::string_view s, CivilYear* c);
+
+// ParseLenientCivilTime()
+//
+// Parses any of the formats accepted by `absl::ParseCivilTime()`, but is more
+// lenient if the format of the string does not exactly match the associated
+// type.
+//
+// Example:
+//
+//   absl::CivilDay d;
+//   bool ok = absl::ParseLenientCivilTime("1969-07-20", &d); // OK
+//   ok = absl::ParseLenientCivilTime("1969-07-20T10", &d);   // OK: T10 floored
+//   ok = absl::ParseLenientCivilTime("1969-07", &d);   // OK: day defaults to 1
+//
+bool ParseLenientCivilTime(absl::string_view s, CivilSecond* c);
+bool ParseLenientCivilTime(absl::string_view s, CivilMinute* c);
+bool ParseLenientCivilTime(absl::string_view s, CivilHour* c);
+bool ParseLenientCivilTime(absl::string_view s, CivilDay* c);
+bool ParseLenientCivilTime(absl::string_view s, CivilMonth* c);
+bool ParseLenientCivilTime(absl::string_view s, CivilYear* c);
+
+namespace time_internal {  // For functions found via ADL on civil-time tags.
+
+// Streaming Operators
+//
+// Each civil-time type may be sent to an output stream using operator<<().
+// The result matches the string produced by `FormatCivilTime()`.
+//
+// Example:
+//
+//   absl::CivilDay d = absl::CivilDay(1969, 7, 20);
+//   std::cout << "Date is: " << d << "\n";
+//
+std::ostream& operator<<(std::ostream& os, CivilYear y);
+std::ostream& operator<<(std::ostream& os, CivilMonth m);
+std::ostream& operator<<(std::ostream& os, CivilDay d);
+std::ostream& operator<<(std::ostream& os, CivilHour h);
+std::ostream& operator<<(std::ostream& os, CivilMinute m);
+std::ostream& operator<<(std::ostream& os, CivilSecond s);
+
+}  // namespace time_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_CIVIL_TIME_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/clock.h b/CAPI/cpp/grpc/include/absl/time/clock.h
new file mode 100644
index 0000000..5fe244d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/clock.h
@@ -0,0 +1,74 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: clock.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains utility functions for working with the system-wide
+// realtime clock. For descriptions of the main time abstractions used within
+// this header file, consult the time.h header file.
+#ifndef ABSL_TIME_CLOCK_H_
+#define ABSL_TIME_CLOCK_H_
+
+#include "absl/base/macros.h"
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Now()
+//
+// Returns the current time, expressed as an `absl::Time` absolute time value.
+absl::Time Now();
+
+// GetCurrentTimeNanos()
+//
+// Returns the current time, expressed as a count of nanoseconds since the Unix
+// Epoch (https://en.wikipedia.org/wiki/Unix_time). Prefer `absl::Now()` instead
+// for all but the most performance-sensitive cases (i.e. when you are calling
+// this function hundreds of thousands of times per second).
+int64_t GetCurrentTimeNanos();
+
+// SleepFor()
+//
+// Sleeps for the specified duration, expressed as an `absl::Duration`.
+//
+// Notes:
+// * Signal interruptions will not reduce the sleep duration.
+// * Returns immediately when passed a nonpositive duration.
+void SleepFor(absl::Duration duration);
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+// -----------------------------------------------------------------------------
+// Implementation Details
+// -----------------------------------------------------------------------------
+
+// In some build configurations we pass --detect-odr-violations to the
+// gold linker.  This causes it to flag weak symbol overrides as ODR
+// violations.  Because ODR only applies to C++ and not C,
+// --detect-odr-violations ignores symbols not mangled with C++ names.
+// By changing our extension points to be extern "C", we dodge this
+// check.
+extern "C" {
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(absl::Duration duration);
+}  // extern "C"
+
+inline void absl::SleepFor(absl::Duration duration) {
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration);
+}
+
+#endif  // ABSL_TIME_CLOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time.h
new file mode 100644
index 0000000..d47ff86
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time.h
@@ -0,0 +1,332 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
+#define ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
+
+#include "absl/base/config.h"
+#include "absl/time/internal/cctz/include/cctz/civil_time_detail.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// The term "civil time" refers to the legally recognized human-scale time
+// that is represented by the six fields YYYY-MM-DD hh:mm:ss. Modern-day civil
+// time follows the Gregorian Calendar and is a time-zone-independent concept.
+// A "date" is perhaps the most common example of a civil time (represented in
+// this library as cctz::civil_day). This library provides six classes and a
+// handful of functions that help with rounding, iterating, and arithmetic on
+// civil times while avoiding complications like daylight-saving time (DST).
+//
+// The following six classes form the core of this civil-time library:
+//
+//   * civil_second
+//   * civil_minute
+//   * civil_hour
+//   * civil_day
+//   * civil_month
+//   * civil_year
+//
+// Each class is a simple value type with the same interface for construction
+// and the same six accessors for each of the civil fields (year, month, day,
+// hour, minute, and second, aka YMDHMS). These classes differ only in their
+// alignment, which is indicated by the type name and specifies the field on
+// which arithmetic operates.
+//
+// Each class can be constructed by passing up to six optional integer
+// arguments representing the YMDHMS fields (in that order) to the
+// constructor. Omitted fields are assigned their minimum valid value. Hours,
+// minutes, and seconds will be set to 0, month and day will be set to 1, and
+// since there is no minimum valid year, it will be set to 1970. So, a
+// default-constructed civil-time object will have YMDHMS fields representing
+// "1970-01-01 00:00:00". Fields that are out-of-range are normalized (e.g.,
+// October 32 -> November 1) so that all civil-time objects represent valid
+// values.
+//
+// Each civil-time class is aligned to the civil-time field indicated in the
+// class's name after normalization. Alignment is performed by setting all the
+// inferior fields to their minimum valid value (as described above). The
+// following are examples of how each of the six types would align the fields
+// representing November 22, 2015 at 12:34:56 in the afternoon. (Note: the
+// string format used here is not important; it's just a shorthand way of
+// showing the six YMDHMS fields.)
+//
+//   civil_second  2015-11-22 12:34:56
+//   civil_minute  2015-11-22 12:34:00
+//   civil_hour    2015-11-22 12:00:00
+//   civil_day     2015-11-22 00:00:00
+//   civil_month   2015-11-01 00:00:00
+//   civil_year    2015-01-01 00:00:00
+//
+// Each civil-time type performs arithmetic on the field to which it is
+// aligned. This means that adding 1 to a civil_day increments the day field
+// (normalizing as necessary), and subtracting 7 from a civil_month operates
+// on the month field (normalizing as necessary). All arithmetic produces a
+// valid civil time. Difference requires two similarly aligned civil-time
+// objects and returns the scalar answer in units of the objects' alignment.
+// For example, the difference between two civil_hour objects will give an
+// answer in units of civil hours.
+//
+// In addition to the six civil-time types just described, there are
+// a handful of helper functions and algorithms for performing common
+// calculations. These are described below.
+//
+// Note: In C++14 and later, this library is usable in a constexpr context.
+//
+// CONSTRUCTION:
+//
+// Each of the civil-time types can be constructed in two ways: by directly
+// passing to the constructor up to six (optional) integers representing the
+// YMDHMS fields, or by copying the YMDHMS fields from a differently aligned
+// civil-time type.
+//
+//   civil_day default_value;  // 1970-01-01 00:00:00
+//
+//   civil_day a(2015, 2, 3);           // 2015-02-03 00:00:00
+//   civil_day b(2015, 2, 3, 4, 5, 6);  // 2015-02-03 00:00:00
+//   civil_day c(2015);                 // 2015-01-01 00:00:00
+//
+//   civil_second ss(2015, 2, 3, 4, 5, 6);  // 2015-02-03 04:05:06
+//   civil_minute mm(ss);                   // 2015-02-03 04:05:00
+//   civil_hour hh(mm);                     // 2015-02-03 04:00:00
+//   civil_day d(hh);                       // 2015-02-03 00:00:00
+//   civil_month m(d);                      // 2015-02-01 00:00:00
+//   civil_year y(m);                       // 2015-01-01 00:00:00
+//
+//   m = civil_month(y);     // 2015-01-01 00:00:00
+//   d = civil_day(m);       // 2015-01-01 00:00:00
+//   hh = civil_hour(d);     // 2015-01-01 00:00:00
+//   mm = civil_minute(hh);  // 2015-01-01 00:00:00
+//   ss = civil_second(mm);  // 2015-01-01 00:00:00
+//
+// ALIGNMENT CONVERSION:
+//
+// The alignment of a civil-time object cannot change, but the object may be
+// used to construct a new object with a different alignment. This is referred
+// to as "realigning". When realigning to a type with the same or more
+// precision (e.g., civil_day -> civil_second), the conversion may be
+// performed implicitly since no information is lost. However, if information
+// could be discarded (e.g., civil_second -> civil_day), the conversion must
+// be explicit at the call site.
+//
+//   void fun(const civil_day& day);
+//
+//   civil_second cs;
+//   fun(cs);  // Won't compile because data may be discarded
+//   fun(civil_day(cs));  // OK: explicit conversion
+//
+//   civil_day cd;
+//   fun(cd);  // OK: no conversion needed
+//
+//   civil_month cm;
+//   fun(cm);  // OK: implicit conversion to civil_day
+//
+// NORMALIZATION:
+//
+// Integer arguments passed to the constructor may be out-of-range, in which
+// case they are normalized to produce a valid civil-time object. This enables
+// natural arithmetic on constructor arguments without worrying about the
+// field's range. Normalization guarantees that there are no invalid
+// civil-time objects.
+//
+//   civil_day d(2016, 10, 32);  // Out-of-range day; normalized to 2016-11-01
+//
+// Note: If normalization is undesired, you can signal an error by comparing
+// the constructor arguments to the normalized values returned by the YMDHMS
+// properties.
+//
+// PROPERTIES:
+//
+// All civil-time types have accessors for all six of the civil-time fields:
+// year, month, day, hour, minute, and second. Recall that fields inferior to
+// the type's alignment will be set to their minimum valid value.
+//
+//   civil_day d(2015, 6, 28);
+//   // d.year() == 2015
+//   // d.month() == 6
+//   // d.day() == 28
+//   // d.hour() == 0
+//   // d.minute() == 0
+//   // d.second() == 0
+//
+// COMPARISON:
+//
+// Comparison always considers all six YMDHMS fields, regardless of the type's
+// alignment. Comparison between differently aligned civil-time types is
+// allowed.
+//
+//   civil_day feb_3(2015, 2, 3);  // 2015-02-03 00:00:00
+//   civil_day mar_4(2015, 3, 4);  // 2015-03-04 00:00:00
+//   // feb_3 < mar_4
+//   // civil_year(feb_3) == civil_year(mar_4)
+//
+//   civil_second feb_3_noon(2015, 2, 3, 12, 0, 0);  // 2015-02-03 12:00:00
+//   // feb_3 < feb_3_noon
+//   // feb_3 == civil_day(feb_3_noon)
+//
+//   // Iterates all the days of February 2015.
+//   for (civil_day d(2015, 2, 1); d < civil_month(2015, 3); ++d) {
+//     // ...
+//   }
+//
+// STREAMING:
+//
+// Each civil-time type may be sent to an output stream using operator<<().
+// The output format follows the pattern "YYYY-MM-DDThh:mm:ss" where fields
+// inferior to the type's alignment are omitted.
+//
+//   civil_second cs(2015, 2, 3, 4, 5, 6);
+//   std::cout << cs << "\n";  // Outputs: 2015-02-03T04:05:06
+//
+//   civil_day cd(cs);
+//   std::cout << cd << "\n";  // Outputs: 2015-02-03
+//
+//   civil_year cy(cs);
+//   std::cout << cy << "\n";  // Outputs: 2015
+//
+// ARITHMETIC:
+//
+// Civil-time types support natural arithmetic operators such as addition,
+// subtraction, and difference. Arithmetic operates on the civil-time field
+// indicated in the type's name. Difference requires arguments with the same
+// alignment and returns the answer in units of the alignment.
+//
+//   civil_day a(2015, 2, 3);
+//   ++a;                         // 2015-02-04 00:00:00
+//   --a;                         // 2015-02-03 00:00:00
+//   civil_day b = a + 1;         // 2015-02-04 00:00:00
+//   civil_day c = 1 + b;         // 2015-02-05 00:00:00
+//   int n = c - a;               // n = 2 (civil days)
+//   int m = c - civil_month(c);  // Won't compile: different types.
+//
+// EXAMPLE: Adding a month to January 31.
+//
+// One of the classic questions that arises when considering a civil-time
+// library (or a date library or a date/time library) is this: "What happens
+// when you add a month to January 31?" This is an interesting question
+// because there could be a number of possible answers:
+//
+//   1. March 3 (or 2 if a leap year). This may make sense if the operation
+//      wants the equivalent of February 31.
+//   2. February 28 (or 29 if a leap year). This may make sense if the operation
+//      wants the last day of January to go to the last day of February.
+//   3. Error. The caller may get some error, an exception, an invalid date
+//      object, or maybe false is returned. This may make sense because there is
+//      no single unambiguously correct answer to the question.
+//
+// Practically speaking, any answer that is not what the programmer intended
+// is the wrong answer.
+//
+// This civil-time library avoids the problem by making it impossible to ask
+// ambiguous questions. All civil-time objects are aligned to a particular
+// civil-field boundary (such as aligned to a year, month, day, hour, minute,
+// or second), and arithmetic operates on the field to which the object is
+// aligned. This means that in order to "add a month" the object must first be
+// aligned to a month boundary, which is equivalent to the first day of that
+// month.
+//
+// Of course, there are ways to compute an answer the question at hand using
+// this civil-time library, but they require the programmer to be explicit
+// about the answer they expect. To illustrate, let's see how to compute all
+// three of the above possible answers to the question of "Jan 31 plus 1
+// month":
+//
+//   const civil_day d(2015, 1, 31);
+//
+//   // Answer 1:
+//   // Add 1 to the month field in the constructor, and rely on normalization.
+//   const auto ans_normalized = civil_day(d.year(), d.month() + 1, d.day());
+//   // ans_normalized == 2015-03-03 (aka Feb 31)
+//
+//   // Answer 2:
+//   // Add 1 to month field, capping to the end of next month.
+//   const auto next_month = civil_month(d) + 1;
+//   const auto last_day_of_next_month = civil_day(next_month + 1) - 1;
+//   const auto ans_capped = std::min(ans_normalized, last_day_of_next_month);
+//   // ans_capped == 2015-02-28
+//
+//   // Answer 3:
+//   // Signal an error if the normalized answer is not in next month.
+//   if (civil_month(ans_normalized) != next_month) {
+//     // error, month overflow
+//   }
+//
+using civil_year = detail::civil_year;
+using civil_month = detail::civil_month;
+using civil_day = detail::civil_day;
+using civil_hour = detail::civil_hour;
+using civil_minute = detail::civil_minute;
+using civil_second = detail::civil_second;
+
+// An enum class with members monday, tuesday, wednesday, thursday, friday,
+// saturday, and sunday. These enum values may be sent to an output stream
+// using operator<<(). The result is the full weekday name in English with a
+// leading capital letter.
+//
+//   weekday wd = weekday::thursday;
+//   std::cout << wd << "\n";  // Outputs: Thursday
+//
+using detail::weekday;
+
+// Returns the weekday for the given civil-time value.
+//
+//   civil_day a(2015, 8, 13);
+//   weekday wd = get_weekday(a);  // wd == weekday::thursday
+//
+using detail::get_weekday;
+
+// Returns the civil_day that strictly follows or precedes the given
+// civil_day, and that falls on the given weekday.
+//
+// For example, given:
+//
+//     August 2015
+// Su Mo Tu We Th Fr Sa
+//                    1
+//  2  3  4  5  6  7  8
+//  9 10 11 12 13 14 15
+// 16 17 18 19 20 21 22
+// 23 24 25 26 27 28 29
+// 30 31
+//
+//   civil_day a(2015, 8, 13);  // get_weekday(a) == weekday::thursday
+//   civil_day b = next_weekday(a, weekday::thursday);  // b = 2015-08-20
+//   civil_day c = prev_weekday(a, weekday::thursday);  // c = 2015-08-06
+//
+//   civil_day d = ...
+//   // Gets the following Thursday if d is not already Thursday
+//   civil_day thurs1 = next_weekday(d - 1, weekday::thursday);
+//   // Gets the previous Thursday if d is not already Thursday
+//   civil_day thurs2 = prev_weekday(d + 1, weekday::thursday);
+//
+using detail::next_weekday;
+using detail::prev_weekday;
+
+// Returns the day-of-year for the given civil-time value.
+//
+//   civil_day a(2015, 1, 1);
+//   int yd_jan_1 = get_yearday(a);   // yd_jan_1 = 1
+//   civil_day b(2015, 12, 31);
+//   int yd_dec_31 = get_yearday(b);  // yd_dec_31 = 365
+//
+using detail::get_yearday;
+
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time_detail.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time_detail.h
new file mode 100644
index 0000000..a5b084e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time_detail.h
@@ -0,0 +1,632 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
+#define ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
+
+#include <cstdint>
+#include <limits>
+#include <ostream>
+#include <type_traits>
+
+#include "absl/base/config.h"
+
+// Disable constexpr support unless we are in C++14 mode.
+#if __cpp_constexpr >= 201304 || (defined(_MSC_VER) && _MSC_VER >= 1910)
+#define CONSTEXPR_D constexpr  // data
+#define CONSTEXPR_F constexpr  // function
+#define CONSTEXPR_M constexpr  // member
+#else
+#define CONSTEXPR_D const
+#define CONSTEXPR_F inline
+#define CONSTEXPR_M
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// Support years that at least span the range of 64-bit time_t values.
+using year_t = std::int_fast64_t;
+
+// Type alias that indicates an argument is not normalized (e.g., the
+// constructor parameters and operands/results of addition/subtraction).
+using diff_t = std::int_fast64_t;
+
+namespace detail {
+
+// Type aliases that indicate normalized argument values.
+using month_t = std::int_fast8_t;   // [1:12]
+using day_t = std::int_fast8_t;     // [1:31]
+using hour_t = std::int_fast8_t;    // [0:23]
+using minute_t = std::int_fast8_t;  // [0:59]
+using second_t = std::int_fast8_t;  // [0:59]
+
+// Normalized civil-time fields: Y-M-D HH:MM:SS.
+struct fields {
+  CONSTEXPR_M fields(year_t year, month_t month, day_t day, hour_t hour,
+                     minute_t minute, second_t second)
+      : y(year), m(month), d(day), hh(hour), mm(minute), ss(second) {}
+  std::int_least64_t y;
+  std::int_least8_t m;
+  std::int_least8_t d;
+  std::int_least8_t hh;
+  std::int_least8_t mm;
+  std::int_least8_t ss;
+};
+
+struct second_tag {};
+struct minute_tag : second_tag {};
+struct hour_tag : minute_tag {};
+struct day_tag : hour_tag {};
+struct month_tag : day_tag {};
+struct year_tag : month_tag {};
+
+////////////////////////////////////////////////////////////////////////
+
+// Field normalization (without avoidable overflow).
+
+namespace impl {
+
+CONSTEXPR_F bool is_leap_year(year_t y) noexcept {
+  return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
+}
+CONSTEXPR_F int year_index(year_t y, month_t m) noexcept {
+  const int yi = static_cast<int>((y + (m > 2)) % 400);
+  return yi < 0 ? yi + 400 : yi;
+}
+CONSTEXPR_F int days_per_century(int yi) noexcept {
+  return 36524 + (yi == 0 || yi > 300);
+}
+CONSTEXPR_F int days_per_4years(int yi) noexcept {
+  return 1460 + (yi == 0 || yi > 300 || (yi - 1) % 100 < 96);
+}
+CONSTEXPR_F int days_per_year(year_t y, month_t m) noexcept {
+  return is_leap_year(y + (m > 2)) ? 366 : 365;
+}
+CONSTEXPR_F int days_per_month(year_t y, month_t m) noexcept {
+  CONSTEXPR_D int k_days_per_month[1 + 12] = {
+      -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // non leap year
+  };
+  return k_days_per_month[m] + (m == 2 && is_leap_year(y));
+}
+
+CONSTEXPR_F fields n_day(year_t y, month_t m, diff_t d, diff_t cd, hour_t hh,
+                         minute_t mm, second_t ss) noexcept {
+  year_t ey = y % 400;
+  const year_t oey = ey;
+  ey += (cd / 146097) * 400;
+  cd %= 146097;
+  if (cd < 0) {
+    ey -= 400;
+    cd += 146097;
+  }
+  ey += (d / 146097) * 400;
+  d = d % 146097 + cd;
+  if (d > 0) {
+    if (d > 146097) {
+      ey += 400;
+      d -= 146097;
+    }
+  } else {
+    if (d > -365) {
+      // We often hit the previous year when stepping a civil time backwards,
+      // so special case it to avoid counting up by 100/4/1-year chunks.
+      ey -= 1;
+      d += days_per_year(ey, m);
+    } else {
+      ey -= 400;
+      d += 146097;
+    }
+  }
+  if (d > 365) {
+    int yi = year_index(ey, m);  // Index into Gregorian 400 year cycle.
+    for (;;) {
+      int n = days_per_century(yi);
+      if (d <= n) break;
+      d -= n;
+      ey += 100;
+      yi += 100;
+      if (yi >= 400) yi -= 400;
+    }
+    for (;;) {
+      int n = days_per_4years(yi);
+      if (d <= n) break;
+      d -= n;
+      ey += 4;
+      yi += 4;
+      if (yi >= 400) yi -= 400;
+    }
+    for (;;) {
+      int n = days_per_year(ey, m);
+      if (d <= n) break;
+      d -= n;
+      ++ey;
+    }
+  }
+  if (d > 28) {
+    for (;;) {
+      int n = days_per_month(ey, m);
+      if (d <= n) break;
+      d -= n;
+      if (++m > 12) {
+        ++ey;
+        m = 1;
+      }
+    }
+  }
+  return fields(y + (ey - oey), m, static_cast<day_t>(d), hh, mm, ss);
+}
+CONSTEXPR_F fields n_mon(year_t y, diff_t m, diff_t d, diff_t cd, hour_t hh,
+                         minute_t mm, second_t ss) noexcept {
+  if (m != 12) {
+    y += m / 12;
+    m %= 12;
+    if (m <= 0) {
+      y -= 1;
+      m += 12;
+    }
+  }
+  return n_day(y, static_cast<month_t>(m), d, cd, hh, mm, ss);
+}
+CONSTEXPR_F fields n_hour(year_t y, diff_t m, diff_t d, diff_t cd, diff_t hh,
+                          minute_t mm, second_t ss) noexcept {
+  cd += hh / 24;
+  hh %= 24;
+  if (hh < 0) {
+    cd -= 1;
+    hh += 24;
+  }
+  return n_mon(y, m, d, cd, static_cast<hour_t>(hh), mm, ss);
+}
+CONSTEXPR_F fields n_min(year_t y, diff_t m, diff_t d, diff_t hh, diff_t ch,
+                         diff_t mm, second_t ss) noexcept {
+  ch += mm / 60;
+  mm %= 60;
+  if (mm < 0) {
+    ch -= 1;
+    mm += 60;
+  }
+  return n_hour(y, m, d, hh / 24 + ch / 24, hh % 24 + ch % 24,
+                static_cast<minute_t>(mm), ss);
+}
+CONSTEXPR_F fields n_sec(year_t y, diff_t m, diff_t d, diff_t hh, diff_t mm,
+                         diff_t ss) noexcept {
+  // Optimization for when (non-constexpr) fields are already normalized.
+  if (0 <= ss && ss < 60) {
+    const second_t nss = static_cast<second_t>(ss);
+    if (0 <= mm && mm < 60) {
+      const minute_t nmm = static_cast<minute_t>(mm);
+      if (0 <= hh && hh < 24) {
+        const hour_t nhh = static_cast<hour_t>(hh);
+        if (1 <= d && d <= 28 && 1 <= m && m <= 12) {
+          const day_t nd = static_cast<day_t>(d);
+          const month_t nm = static_cast<month_t>(m);
+          return fields(y, nm, nd, nhh, nmm, nss);
+        }
+        return n_mon(y, m, d, 0, nhh, nmm, nss);
+      }
+      return n_hour(y, m, d, hh / 24, hh % 24, nmm, nss);
+    }
+    return n_min(y, m, d, hh, mm / 60, mm % 60, nss);
+  }
+  diff_t cm = ss / 60;
+  ss %= 60;
+  if (ss < 0) {
+    cm -= 1;
+    ss += 60;
+  }
+  return n_min(y, m, d, hh, mm / 60 + cm / 60, mm % 60 + cm % 60,
+               static_cast<second_t>(ss));
+}
+
+}  // namespace impl
+
+////////////////////////////////////////////////////////////////////////
+
+// Increments the indicated (normalized) field by "n".
+CONSTEXPR_F fields step(second_tag, fields f, diff_t n) noexcept {
+  return impl::n_sec(f.y, f.m, f.d, f.hh, f.mm + n / 60, f.ss + n % 60);
+}
+CONSTEXPR_F fields step(minute_tag, fields f, diff_t n) noexcept {
+  return impl::n_min(f.y, f.m, f.d, f.hh + n / 60, 0, f.mm + n % 60, f.ss);
+}
+CONSTEXPR_F fields step(hour_tag, fields f, diff_t n) noexcept {
+  return impl::n_hour(f.y, f.m, f.d + n / 24, 0, f.hh + n % 24, f.mm, f.ss);
+}
+CONSTEXPR_F fields step(day_tag, fields f, diff_t n) noexcept {
+  return impl::n_day(f.y, f.m, f.d, n, f.hh, f.mm, f.ss);
+}
+CONSTEXPR_F fields step(month_tag, fields f, diff_t n) noexcept {
+  return impl::n_mon(f.y + n / 12, f.m + n % 12, f.d, 0, f.hh, f.mm, f.ss);
+}
+CONSTEXPR_F fields step(year_tag, fields f, diff_t n) noexcept {
+  return fields(f.y + n, f.m, f.d, f.hh, f.mm, f.ss);
+}
+
+////////////////////////////////////////////////////////////////////////
+
+namespace impl {
+
+// Returns (v * f + a) but avoiding intermediate overflow when possible.
+CONSTEXPR_F diff_t scale_add(diff_t v, diff_t f, diff_t a) noexcept {
+  return (v < 0) ? ((v + 1) * f + a) - f : ((v - 1) * f + a) + f;
+}
+
+// Map a (normalized) Y/M/D to the number of days before/after 1970-01-01.
+// Probably overflows for years outside [-292277022656:292277026595].
+CONSTEXPR_F diff_t ymd_ord(year_t y, month_t m, day_t d) noexcept {
+  const diff_t eyear = (m <= 2) ? y - 1 : y;
+  const diff_t era = (eyear >= 0 ? eyear : eyear - 399) / 400;
+  const diff_t yoe = eyear - era * 400;
+  const diff_t doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
+  const diff_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+  return era * 146097 + doe - 719468;
+}
+
+// Returns the difference in days between two normalized Y-M-D tuples.
+// ymd_ord() will encounter integer overflow given extreme year values,
+// yet the difference between two such extreme values may actually be
+// small, so we take a little care to avoid overflow when possible by
+// exploiting the 146097-day cycle.
+CONSTEXPR_F diff_t day_difference(year_t y1, month_t m1, day_t d1, year_t y2,
+                                  month_t m2, day_t d2) noexcept {
+  const diff_t a_c4_off = y1 % 400;
+  const diff_t b_c4_off = y2 % 400;
+  diff_t c4_diff = (y1 - a_c4_off) - (y2 - b_c4_off);
+  diff_t delta = ymd_ord(a_c4_off, m1, d1) - ymd_ord(b_c4_off, m2, d2);
+  if (c4_diff > 0 && delta < 0) {
+    delta += 2 * 146097;
+    c4_diff -= 2 * 400;
+  } else if (c4_diff < 0 && delta > 0) {
+    delta -= 2 * 146097;
+    c4_diff += 2 * 400;
+  }
+  return (c4_diff / 400 * 146097) + delta;
+}
+
+}  // namespace impl
+
+// Returns the difference between fields structs using the indicated unit.
+CONSTEXPR_F diff_t difference(year_tag, fields f1, fields f2) noexcept {
+  return f1.y - f2.y;
+}
+CONSTEXPR_F diff_t difference(month_tag, fields f1, fields f2) noexcept {
+  return impl::scale_add(difference(year_tag{}, f1, f2), 12, (f1.m - f2.m));
+}
+CONSTEXPR_F diff_t difference(day_tag, fields f1, fields f2) noexcept {
+  return impl::day_difference(f1.y, f1.m, f1.d, f2.y, f2.m, f2.d);
+}
+CONSTEXPR_F diff_t difference(hour_tag, fields f1, fields f2) noexcept {
+  return impl::scale_add(difference(day_tag{}, f1, f2), 24, (f1.hh - f2.hh));
+}
+CONSTEXPR_F diff_t difference(minute_tag, fields f1, fields f2) noexcept {
+  return impl::scale_add(difference(hour_tag{}, f1, f2), 60, (f1.mm - f2.mm));
+}
+CONSTEXPR_F diff_t difference(second_tag, fields f1, fields f2) noexcept {
+  return impl::scale_add(difference(minute_tag{}, f1, f2), 60, f1.ss - f2.ss);
+}
+
+////////////////////////////////////////////////////////////////////////
+
+// Aligns the (normalized) fields struct to the indicated field.
+CONSTEXPR_F fields align(second_tag, fields f) noexcept { return f; }
+CONSTEXPR_F fields align(minute_tag, fields f) noexcept {
+  return fields{f.y, f.m, f.d, f.hh, f.mm, 0};
+}
+CONSTEXPR_F fields align(hour_tag, fields f) noexcept {
+  return fields{f.y, f.m, f.d, f.hh, 0, 0};
+}
+CONSTEXPR_F fields align(day_tag, fields f) noexcept {
+  return fields{f.y, f.m, f.d, 0, 0, 0};
+}
+CONSTEXPR_F fields align(month_tag, fields f) noexcept {
+  return fields{f.y, f.m, 1, 0, 0, 0};
+}
+CONSTEXPR_F fields align(year_tag, fields f) noexcept {
+  return fields{f.y, 1, 1, 0, 0, 0};
+}
+
+////////////////////////////////////////////////////////////////////////
+
+namespace impl {
+
+template <typename H>
+H AbslHashValueImpl(second_tag, H h, fields f) {
+  return H::combine(std::move(h), f.y, f.m, f.d, f.hh, f.mm, f.ss);
+}
+template <typename H>
+H AbslHashValueImpl(minute_tag, H h, fields f) {
+  return H::combine(std::move(h), f.y, f.m, f.d, f.hh, f.mm);
+}
+template <typename H>
+H AbslHashValueImpl(hour_tag, H h, fields f) {
+  return H::combine(std::move(h), f.y, f.m, f.d, f.hh);
+}
+template <typename H>
+H AbslHashValueImpl(day_tag, H h, fields f) {
+  return H::combine(std::move(h), f.y, f.m, f.d);
+}
+template <typename H>
+H AbslHashValueImpl(month_tag, H h, fields f) {
+  return H::combine(std::move(h), f.y, f.m);
+}
+template <typename H>
+H AbslHashValueImpl(year_tag, H h, fields f) {
+  return H::combine(std::move(h), f.y);
+}
+
+}  // namespace impl
+
+////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+class civil_time {
+ public:
+  explicit CONSTEXPR_M civil_time(year_t y, diff_t m = 1, diff_t d = 1,
+                                  diff_t hh = 0, diff_t mm = 0,
+                                  diff_t ss = 0) noexcept
+      : civil_time(impl::n_sec(y, m, d, hh, mm, ss)) {}
+
+  CONSTEXPR_M civil_time() noexcept : f_{1970, 1, 1, 0, 0, 0} {}
+  civil_time(const civil_time&) = default;
+  civil_time& operator=(const civil_time&) = default;
+
+  // Conversion between civil times of different alignment. Conversion to
+  // a more precise alignment is allowed implicitly (e.g., day -> hour),
+  // but conversion where information is discarded must be explicit
+  // (e.g., second -> minute).
+  template <typename U, typename S>
+  using preserves_data =
+      typename std::enable_if<std::is_base_of<U, S>::value>::type;
+  template <typename U>
+  CONSTEXPR_M civil_time(const civil_time<U>& ct,
+                         preserves_data<T, U>* = nullptr) noexcept
+      : civil_time(ct.f_) {}
+  template <typename U>
+  explicit CONSTEXPR_M civil_time(const civil_time<U>& ct,
+                                  preserves_data<U, T>* = nullptr) noexcept
+      : civil_time(ct.f_) {}
+
+  // Factories for the maximum/minimum representable civil_time.
+  static CONSTEXPR_F civil_time(max)() {
+    const auto max_year = (std::numeric_limits<std::int_least64_t>::max)();
+    return civil_time(max_year, 12, 31, 23, 59, 59);
+  }
+  static CONSTEXPR_F civil_time(min)() {
+    const auto min_year = (std::numeric_limits<std::int_least64_t>::min)();
+    return civil_time(min_year, 1, 1, 0, 0, 0);
+  }
+
+  // Field accessors.  Note: All but year() return an int.
+  CONSTEXPR_M year_t year() const noexcept { return f_.y; }
+  CONSTEXPR_M int month() const noexcept { return f_.m; }
+  CONSTEXPR_M int day() const noexcept { return f_.d; }
+  CONSTEXPR_M int hour() const noexcept { return f_.hh; }
+  CONSTEXPR_M int minute() const noexcept { return f_.mm; }
+  CONSTEXPR_M int second() const noexcept { return f_.ss; }
+
+  // Assigning arithmetic.
+  CONSTEXPR_M civil_time& operator+=(diff_t n) noexcept {
+    return *this = *this + n;
+  }
+  CONSTEXPR_M civil_time& operator-=(diff_t n) noexcept {
+    return *this = *this - n;
+  }
+  CONSTEXPR_M civil_time& operator++() noexcept { return *this += 1; }
+  CONSTEXPR_M civil_time operator++(int) noexcept {
+    const civil_time a = *this;
+    ++*this;
+    return a;
+  }
+  CONSTEXPR_M civil_time& operator--() noexcept { return *this -= 1; }
+  CONSTEXPR_M civil_time operator--(int) noexcept {
+    const civil_time a = *this;
+    --*this;
+    return a;
+  }
+
+  // Binary arithmetic operators.
+  friend CONSTEXPR_F civil_time operator+(civil_time a, diff_t n) noexcept {
+    return civil_time(step(T{}, a.f_, n));
+  }
+  friend CONSTEXPR_F civil_time operator+(diff_t n, civil_time a) noexcept {
+    return a + n;
+  }
+  friend CONSTEXPR_F civil_time operator-(civil_time a, diff_t n) noexcept {
+    return n != (std::numeric_limits<diff_t>::min)()
+               ? civil_time(step(T{}, a.f_, -n))
+               : civil_time(step(T{}, step(T{}, a.f_, -(n + 1)), 1));
+  }
+  friend CONSTEXPR_F diff_t operator-(civil_time lhs, civil_time rhs) noexcept {
+    return difference(T{}, lhs.f_, rhs.f_);
+  }
+
+  template <typename H>
+  friend H AbslHashValue(H h, civil_time a) {
+    return impl::AbslHashValueImpl(T{}, std::move(h), a.f_);
+  }
+
+ private:
+  // All instantiations of this template are allowed to call the following
+  // private constructor and access the private fields member.
+  template <typename U>
+  friend class civil_time;
+
+  // The designated constructor that all others eventually call.
+  explicit CONSTEXPR_M civil_time(fields f) noexcept : f_(align(T{}, f)) {}
+
+  fields f_;
+};
+
+// Disallows difference between differently aligned types.
+// auto n = civil_day(...) - civil_hour(...);  // would be confusing.
+template <typename T, typename U>
+CONSTEXPR_F diff_t operator-(civil_time<T>, civil_time<U>) = delete;
+
+using civil_year = civil_time<year_tag>;
+using civil_month = civil_time<month_tag>;
+using civil_day = civil_time<day_tag>;
+using civil_hour = civil_time<hour_tag>;
+using civil_minute = civil_time<minute_tag>;
+using civil_second = civil_time<second_tag>;
+
+////////////////////////////////////////////////////////////////////////
+
+// Relational operators that work with differently aligned objects.
+// Always compares all six fields.
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator<(const civil_time<T1>& lhs,
+                           const civil_time<T2>& rhs) noexcept {
+  return (
+      lhs.year() < rhs.year() ||
+      (lhs.year() == rhs.year() &&
+       (lhs.month() < rhs.month() ||
+        (lhs.month() == rhs.month() &&
+         (lhs.day() < rhs.day() || (lhs.day() == rhs.day() &&
+                                    (lhs.hour() < rhs.hour() ||
+                                     (lhs.hour() == rhs.hour() &&
+                                      (lhs.minute() < rhs.minute() ||
+                                       (lhs.minute() == rhs.minute() &&
+                                        (lhs.second() < rhs.second())))))))))));
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator<=(const civil_time<T1>& lhs,
+                            const civil_time<T2>& rhs) noexcept {
+  return !(rhs < lhs);
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator>=(const civil_time<T1>& lhs,
+                            const civil_time<T2>& rhs) noexcept {
+  return !(lhs < rhs);
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator>(const civil_time<T1>& lhs,
+                           const civil_time<T2>& rhs) noexcept {
+  return rhs < lhs;
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator==(const civil_time<T1>& lhs,
+                            const civil_time<T2>& rhs) noexcept {
+  return lhs.year() == rhs.year() && lhs.month() == rhs.month() &&
+         lhs.day() == rhs.day() && lhs.hour() == rhs.hour() &&
+         lhs.minute() == rhs.minute() && lhs.second() == rhs.second();
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator!=(const civil_time<T1>& lhs,
+                            const civil_time<T2>& rhs) noexcept {
+  return !(lhs == rhs);
+}
+
+////////////////////////////////////////////////////////////////////////
+
+enum class weekday {
+  monday,
+  tuesday,
+  wednesday,
+  thursday,
+  friday,
+  saturday,
+  sunday,
+};
+
+CONSTEXPR_F weekday get_weekday(const civil_second& cs) noexcept {
+  CONSTEXPR_D weekday k_weekday_by_mon_off[13] = {
+      weekday::monday,    weekday::tuesday,  weekday::wednesday,
+      weekday::thursday,  weekday::friday,   weekday::saturday,
+      weekday::sunday,    weekday::monday,   weekday::tuesday,
+      weekday::wednesday, weekday::thursday, weekday::friday,
+      weekday::saturday,
+  };
+  CONSTEXPR_D int k_weekday_offsets[1 + 12] = {
+      -1, 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4,
+  };
+  year_t wd = 2400 + (cs.year() % 400) - (cs.month() < 3);
+  wd += wd / 4 - wd / 100 + wd / 400;
+  wd += k_weekday_offsets[cs.month()] + cs.day();
+  return k_weekday_by_mon_off[wd % 7 + 6];
+}
+
+////////////////////////////////////////////////////////////////////////
+
+CONSTEXPR_F civil_day next_weekday(civil_day cd, weekday wd) noexcept {
+  CONSTEXPR_D weekday k_weekdays_forw[14] = {
+      weekday::monday,    weekday::tuesday,  weekday::wednesday,
+      weekday::thursday,  weekday::friday,   weekday::saturday,
+      weekday::sunday,    weekday::monday,   weekday::tuesday,
+      weekday::wednesday, weekday::thursday, weekday::friday,
+      weekday::saturday,  weekday::sunday,
+  };
+  weekday base = get_weekday(cd);
+  for (int i = 0;; ++i) {
+    if (base == k_weekdays_forw[i]) {
+      for (int j = i + 1;; ++j) {
+        if (wd == k_weekdays_forw[j]) {
+          return cd + (j - i);
+        }
+      }
+    }
+  }
+}
+
+CONSTEXPR_F civil_day prev_weekday(civil_day cd, weekday wd) noexcept {
+  CONSTEXPR_D weekday k_weekdays_back[14] = {
+      weekday::sunday,   weekday::saturday,  weekday::friday,
+      weekday::thursday, weekday::wednesday, weekday::tuesday,
+      weekday::monday,   weekday::sunday,    weekday::saturday,
+      weekday::friday,   weekday::thursday,  weekday::wednesday,
+      weekday::tuesday,  weekday::monday,
+  };
+  weekday base = get_weekday(cd);
+  for (int i = 0;; ++i) {
+    if (base == k_weekdays_back[i]) {
+      for (int j = i + 1;; ++j) {
+        if (wd == k_weekdays_back[j]) {
+          return cd - (j - i);
+        }
+      }
+    }
+  }
+}
+
+CONSTEXPR_F int get_yearday(const civil_second& cs) noexcept {
+  CONSTEXPR_D int k_month_offsets[1 + 12] = {
+      -1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
+  };
+  const int feb29 = (cs.month() > 2 && impl::is_leap_year(cs.year()));
+  return k_month_offsets[cs.month()] + feb29 + cs.day();
+}
+
+////////////////////////////////////////////////////////////////////////
+
+std::ostream& operator<<(std::ostream& os, const civil_year& y);
+std::ostream& operator<<(std::ostream& os, const civil_month& m);
+std::ostream& operator<<(std::ostream& os, const civil_day& d);
+std::ostream& operator<<(std::ostream& os, const civil_hour& h);
+std::ostream& operator<<(std::ostream& os, const civil_minute& m);
+std::ostream& operator<<(std::ostream& os, const civil_second& s);
+std::ostream& operator<<(std::ostream& os, weekday wd);
+
+}  // namespace detail
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#undef CONSTEXPR_M
+#undef CONSTEXPR_F
+#undef CONSTEXPR_D
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/time_zone.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/time_zone.h
new file mode 100644
index 0000000..6e382dc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/time_zone.h
@@ -0,0 +1,459 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+// A library for translating between absolute times (represented by
+// std::chrono::time_points of the std::chrono::system_clock) and civil
+// times (represented by cctz::civil_second) using the rules defined by
+// a time zone (cctz::time_zone).
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
+
+#include <chrono>
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// Convenience aliases. Not intended as public API points.
+template <typename D>
+using time_point = std::chrono::time_point<std::chrono::system_clock, D>;
+using seconds = std::chrono::duration<std::int_fast64_t>;
+using sys_seconds = seconds;  // Deprecated.  Use cctz::seconds instead.
+
+namespace detail {
+template <typename D>
+std::pair<time_point<seconds>, D> split_seconds(const time_point<D>& tp);
+std::pair<time_point<seconds>, seconds> split_seconds(
+    const time_point<seconds>& tp);
+}  // namespace detail
+
+// cctz::time_zone is an opaque, small, value-type class representing a
+// geo-political region within which particular rules are used for mapping
+// between absolute and civil times. Time zones are named using the TZ
+// identifiers from the IANA Time Zone Database, such as "America/Los_Angeles"
+// or "Australia/Sydney". Time zones are created from factory functions such
+// as load_time_zone(). Note: strings like "PST" and "EDT" are not valid TZ
+// identifiers.
+//
+// Example:
+//   cctz::time_zone utc = cctz::utc_time_zone();
+//   cctz::time_zone pst = cctz::fixed_time_zone(std::chrono::hours(-8));
+//   cctz::time_zone loc = cctz::local_time_zone();
+//   cctz::time_zone lax;
+//   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+//
+// See also:
+// - http://www.iana.org/time-zones
+// - https://en.wikipedia.org/wiki/Zoneinfo
+class time_zone {
+ public:
+  time_zone() : time_zone(nullptr) {}  // Equivalent to UTC
+  time_zone(const time_zone&) = default;
+  time_zone& operator=(const time_zone&) = default;
+
+  std::string name() const;
+
+  // An absolute_lookup represents the civil time (cctz::civil_second) within
+  // this time_zone at the given absolute time (time_point). There are
+  // additionally a few other fields that may be useful when working with
+  // older APIs, such as std::tm.
+  //
+  // Example:
+  //   const cctz::time_zone tz = ...
+  //   const auto tp = std::chrono::system_clock::now();
+  //   const cctz::time_zone::absolute_lookup al = tz.lookup(tp);
+  struct absolute_lookup {
+    civil_second cs;
+    // Note: The following fields exist for backward compatibility with older
+    // APIs. Accessing these fields directly is a sign of imprudent logic in
+    // the calling code. Modern time-related code should only access this data
+    // indirectly by way of cctz::format().
+    int offset;        // civil seconds east of UTC
+    bool is_dst;       // is offset non-standard?
+    const char* abbr;  // time-zone abbreviation (e.g., "PST")
+  };
+  absolute_lookup lookup(const time_point<seconds>& tp) const;
+  template <typename D>
+  absolute_lookup lookup(const time_point<D>& tp) const {
+    return lookup(detail::split_seconds(tp).first);
+  }
+
+  // A civil_lookup represents the absolute time(s) (time_point) that
+  // correspond to the given civil time (cctz::civil_second) within this
+  // time_zone. Usually the given civil time represents a unique instant
+  // in time, in which case the conversion is unambiguous. However,
+  // within this time zone, the given civil time may be skipped (e.g.,
+  // during a positive UTC offset shift), or repeated (e.g., during a
+  // negative UTC offset shift). To account for these possibilities,
+  // civil_lookup is richer than just a single time_point.
+  //
+  // In all cases the civil_lookup::kind enum will indicate the nature
+  // of the given civil-time argument, and the pre, trans, and post
+  // members will give the absolute time answers using the pre-transition
+  // offset, the transition point itself, and the post-transition offset,
+  // respectively (all three times are equal if kind == UNIQUE). If any
+  // of these three absolute times is outside the representable range of a
+  // time_point<seconds> the field is set to its maximum/minimum value.
+  //
+  // Example:
+  //   cctz::time_zone lax;
+  //   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+  //
+  //   // A unique civil time.
+  //   auto jan01 = lax.lookup(cctz::civil_second(2011, 1, 1, 0, 0, 0));
+  //   // jan01.kind == cctz::time_zone::civil_lookup::UNIQUE
+  //   // jan01.pre    is 2011/01/01 00:00:00 -0800
+  //   // jan01.trans  is 2011/01/01 00:00:00 -0800
+  //   // jan01.post   is 2011/01/01 00:00:00 -0800
+  //
+  //   // A Spring DST transition, when there is a gap in civil time.
+  //   auto mar13 = lax.lookup(cctz::civil_second(2011, 3, 13, 2, 15, 0));
+  //   // mar13.kind == cctz::time_zone::civil_lookup::SKIPPED
+  //   // mar13.pre   is 2011/03/13 03:15:00 -0700
+  //   // mar13.trans is 2011/03/13 03:00:00 -0700
+  //   // mar13.post  is 2011/03/13 01:15:00 -0800
+  //
+  //   // A Fall DST transition, when civil times are repeated.
+  //   auto nov06 = lax.lookup(cctz::civil_second(2011, 11, 6, 1, 15, 0));
+  //   // nov06.kind == cctz::time_zone::civil_lookup::REPEATED
+  //   // nov06.pre   is 2011/11/06 01:15:00 -0700
+  //   // nov06.trans is 2011/11/06 01:00:00 -0800
+  //   // nov06.post  is 2011/11/06 01:15:00 -0800
+  struct civil_lookup {
+    enum civil_kind {
+      UNIQUE,    // the civil time was singular (pre == trans == post)
+      SKIPPED,   // the civil time did not exist (pre >= trans > post)
+      REPEATED,  // the civil time was ambiguous (pre < trans <= post)
+    } kind;
+    time_point<seconds> pre;    // uses the pre-transition offset
+    time_point<seconds> trans;  // instant of civil-offset change
+    time_point<seconds> post;   // uses the post-transition offset
+  };
+  civil_lookup lookup(const civil_second& cs) const;
+
+  // Finds the time of the next/previous offset change in this time zone.
+  //
+  // By definition, next_transition(tp, &trans) returns false when tp has
+  // its maximum value, and prev_transition(tp, &trans) returns false
+  // when tp has its minimum value. If the zone has no transitions, the
+  // result will also be false no matter what the argument.
+  //
+  // Otherwise, when tp has its minimum value, next_transition(tp, &trans)
+  // returns true and sets trans to the first recorded transition. Chains
+  // of calls to next_transition()/prev_transition() will eventually return
+  // false, but it is unspecified exactly when next_transition(tp, &trans)
+  // jumps to false, or what time is set by prev_transition(tp, &trans) for
+  // a very distant tp.
+  //
+  // Note: Enumeration of time-zone transitions is for informational purposes
+  // only. Modern time-related code should not care about when offset changes
+  // occur.
+  //
+  // Example:
+  //   cctz::time_zone nyc;
+  //   if (!cctz::load_time_zone("America/New_York", &nyc)) { ... }
+  //   const auto now = std::chrono::system_clock::now();
+  //   auto tp = cctz::time_point<cctz::seconds>::min();
+  //   cctz::time_zone::civil_transition trans;
+  //   while (tp <= now && nyc.next_transition(tp, &trans)) {
+  //     // transition: trans.from -> trans.to
+  //     tp = nyc.lookup(trans.to).trans;
+  //   }
+  struct civil_transition {
+    civil_second from;  // the civil time we jump from
+    civil_second to;    // the civil time we jump to
+  };
+  bool next_transition(const time_point<seconds>& tp,
+                       civil_transition* trans) const;
+  template <typename D>
+  bool next_transition(const time_point<D>& tp, civil_transition* trans) const {
+    return next_transition(detail::split_seconds(tp).first, trans);
+  }
+  bool prev_transition(const time_point<seconds>& tp,
+                       civil_transition* trans) const;
+  template <typename D>
+  bool prev_transition(const time_point<D>& tp, civil_transition* trans) const {
+    return prev_transition(detail::split_seconds(tp).first, trans);
+  }
+
+  // version() and description() provide additional information about the
+  // time zone. The content of each of the returned strings is unspecified,
+  // however, when the IANA Time Zone Database is the underlying data source
+  // the version() string will be in the familar form (e.g, "2018e") or
+  // empty when unavailable.
+  //
+  // Note: These functions are for informational or testing purposes only.
+  std::string version() const;  // empty when unknown
+  std::string description() const;
+
+  // Relational operators.
+  friend bool operator==(time_zone lhs, time_zone rhs) {
+    return &lhs.effective_impl() == &rhs.effective_impl();
+  }
+  friend bool operator!=(time_zone lhs, time_zone rhs) { return !(lhs == rhs); }
+
+  template <typename H>
+  friend H AbslHashValue(H h, time_zone tz) {
+    return H::combine(std::move(h), &tz.effective_impl());
+  }
+
+  class Impl;
+
+ private:
+  explicit time_zone(const Impl* impl) : impl_(impl) {}
+  const Impl& effective_impl() const;  // handles implicit UTC
+  const Impl* impl_;
+};
+
+// Loads the named time zone. May perform I/O on the initial load.
+// If the name is invalid, or some other kind of error occurs, returns
+// false and "*tz" is set to the UTC time zone.
+bool load_time_zone(const std::string& name, time_zone* tz);
+
+// Returns a time_zone representing UTC. Cannot fail.
+time_zone utc_time_zone();
+
+// Returns a time zone that is a fixed offset (seconds east) from UTC.
+// Note: If the absolute value of the offset is greater than 24 hours
+// you'll get UTC (i.e., zero offset) instead.
+time_zone fixed_time_zone(const seconds& offset);
+
+// Returns a time zone representing the local time zone. Falls back to UTC.
+// Note: local_time_zone.name() may only be something like "localtime".
+time_zone local_time_zone();
+
+// Returns the civil time (cctz::civil_second) within the given time zone at
+// the given absolute time (time_point). Since the additional fields provided
+// by the time_zone::absolute_lookup struct should rarely be needed in modern
+// code, this convert() function is simpler and should be preferred.
+template <typename D>
+inline civil_second convert(const time_point<D>& tp, const time_zone& tz) {
+  return tz.lookup(tp).cs;
+}
+
+// Returns the absolute time (time_point) that corresponds to the given civil
+// time within the given time zone. If the civil time is not unique (i.e., if
+// it was either repeated or non-existent), then the returned time_point is
+// the best estimate that preserves relative order. That is, this function
+// guarantees that if cs1 < cs2, then convert(cs1, tz) <= convert(cs2, tz).
+inline time_point<seconds> convert(const civil_second& cs,
+                                   const time_zone& tz) {
+  const time_zone::civil_lookup cl = tz.lookup(cs);
+  if (cl.kind == time_zone::civil_lookup::SKIPPED) return cl.trans;
+  return cl.pre;
+}
+
+namespace detail {
+using femtoseconds = std::chrono::duration<std::int_fast64_t, std::femto>;
+std::string format(const std::string&, const time_point<seconds>&,
+                   const femtoseconds&, const time_zone&);
+bool parse(const std::string&, const std::string&, const time_zone&,
+           time_point<seconds>*, femtoseconds*, std::string* err = nullptr);
+template <typename Rep, std::intmax_t Denom>
+bool join_seconds(
+    const time_point<seconds>& sec, const femtoseconds& fs,
+    time_point<std::chrono::duration<Rep, std::ratio<1, Denom>>>* tpp);
+template <typename Rep, std::intmax_t Num>
+bool join_seconds(
+    const time_point<seconds>& sec, const femtoseconds& fs,
+    time_point<std::chrono::duration<Rep, std::ratio<Num, 1>>>* tpp);
+template <typename Rep>
+bool join_seconds(
+    const time_point<seconds>& sec, const femtoseconds& fs,
+    time_point<std::chrono::duration<Rep, std::ratio<1, 1>>>* tpp);
+bool join_seconds(const time_point<seconds>& sec, const femtoseconds&,
+                  time_point<seconds>* tpp);
+}  // namespace detail
+
+// Formats the given time_point in the given cctz::time_zone according to
+// the provided format string. Uses strftime()-like formatting options,
+// with the following extensions:
+//
+//   - %Ez  - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
+//   - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
+//   - %E#S - Seconds with # digits of fractional precision
+//   - %E*S - Seconds with full fractional precision (a literal '*')
+//   - %E#f - Fractional seconds with # digits of precision
+//   - %E*f - Fractional seconds with full precision (a literal '*')
+//   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
+//   - %ET  - The RFC3339 "date-time" separator "T"
+//
+// Note that %E0S behaves like %S, and %E0f produces no characters. In
+// contrast %E*f always produces at least one digit, which may be '0'.
+//
+// Note that %Y produces as many characters as it takes to fully render the
+// year. A year outside of [-999:9999] when formatted with %E4Y will produce
+// more than four characters, just like %Y.
+//
+// Tip: Format strings should include the UTC offset (e.g., %z, %Ez, or %E*z)
+// so that the resulting string uniquely identifies an absolute time.
+//
+// Example:
+//   cctz::time_zone lax;
+//   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+//   auto tp = cctz::convert(cctz::civil_second(2013, 1, 2, 3, 4, 5), lax);
+//   std::string f = cctz::format("%H:%M:%S", tp, lax);  // "03:04:05"
+//   f = cctz::format("%H:%M:%E3S", tp, lax);            // "03:04:05.000"
+template <typename D>
+inline std::string format(const std::string& fmt, const time_point<D>& tp,
+                          const time_zone& tz) {
+  const auto p = detail::split_seconds(tp);
+  const auto n = std::chrono::duration_cast<detail::femtoseconds>(p.second);
+  return detail::format(fmt, p.first, n, tz);
+}
+
+// Parses an input string according to the provided format string and
+// returns the corresponding time_point. Uses strftime()-like formatting
+// options, with the same extensions as cctz::format(), but with the
+// exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez
+// and %E*z also accept the same inputs, which (along with %z) includes
+// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
+//
+// %Y consumes as many numeric characters as it can, so the matching data
+// should always be terminated with a non-numeric. %E4Y always consumes
+// exactly four characters, including any sign.
+//
+// Unspecified fields are taken from the default date and time of ...
+//
+//   "1970-01-01 00:00:00.0 +0000"
+//
+// For example, parsing a string of "15:45" (%H:%M) will return a time_point
+// that represents "1970-01-01 15:45:00.0 +0000".
+//
+// Note that parse() returns time instants, so it makes most sense to parse
+// fully-specified date/time strings that include a UTC offset (%z, %Ez, or
+// %E*z).
+//
+// Note also that parse() only heeds the fields year, month, day, hour,
+// minute, (fractional) second, and UTC offset. Other fields, like weekday (%a
+// or %A), while parsed for syntactic validity, are ignored in the conversion.
+//
+// Date and time fields that are out-of-range will be treated as errors rather
+// than normalizing them like cctz::civil_second() would do. For example, it
+// is an error to parse the date "Oct 32, 2013" because 32 is out of range.
+//
+// A second of ":60" is normalized to ":00" of the following minute with
+// fractional seconds discarded. The following table shows how the given
+// seconds and subseconds will be parsed:
+//
+//   "59.x" -> 59.x  // exact
+//   "60.x" -> 00.0  // normalized
+//   "00.x" -> 00.x  // exact
+//
+// Errors are indicated by returning false.
+//
+// Example:
+//   const cctz::time_zone tz = ...
+//   std::chrono::system_clock::time_point tp;
+//   if (cctz::parse("%Y-%m-%d", "2015-10-09", tz, &tp)) {
+//     ...
+//   }
+template <typename D>
+inline bool parse(const std::string& fmt, const std::string& input,
+                  const time_zone& tz, time_point<D>* tpp) {
+  time_point<seconds> sec;
+  detail::femtoseconds fs;
+  return detail::parse(fmt, input, tz, &sec, &fs) &&
+         detail::join_seconds(sec, fs, tpp);
+}
+
+namespace detail {
+
+// Split a time_point<D> into a time_point<seconds> and a D subseconds.
+// Undefined behavior if time_point<seconds> is not of sufficient range.
+// Note that this means it is UB to call cctz::time_zone::lookup(tp) or
+// cctz::format(fmt, tp, tz) with a time_point that is outside the range
+// of a 64-bit std::time_t.
+template <typename D>
+std::pair<time_point<seconds>, D> split_seconds(const time_point<D>& tp) {
+  auto sec = std::chrono::time_point_cast<seconds>(tp);
+  auto sub = tp - sec;
+  if (sub.count() < 0) {
+    sec -= seconds(1);
+    sub += seconds(1);
+  }
+  return {sec, std::chrono::duration_cast<D>(sub)};
+}
+
+inline std::pair<time_point<seconds>, seconds> split_seconds(
+    const time_point<seconds>& tp) {
+  return {tp, seconds::zero()};
+}
+
+// Join a time_point<seconds> and femto subseconds into a time_point<D>.
+// Floors to the resolution of time_point<D>. Returns false if time_point<D>
+// is not of sufficient range.
+template <typename Rep, std::intmax_t Denom>
+bool join_seconds(
+    const time_point<seconds>& sec, const femtoseconds& fs,
+    time_point<std::chrono::duration<Rep, std::ratio<1, Denom>>>* tpp) {
+  using D = std::chrono::duration<Rep, std::ratio<1, Denom>>;
+  // TODO(#199): Return false if result unrepresentable as a time_point<D>.
+  *tpp = std::chrono::time_point_cast<D>(sec);
+  *tpp += std::chrono::duration_cast<D>(fs);
+  return true;
+}
+
+template <typename Rep, std::intmax_t Num>
+bool join_seconds(
+    const time_point<seconds>& sec, const femtoseconds&,
+    time_point<std::chrono::duration<Rep, std::ratio<Num, 1>>>* tpp) {
+  using D = std::chrono::duration<Rep, std::ratio<Num, 1>>;
+  auto count = sec.time_since_epoch().count();
+  if (count >= 0 || count % Num == 0) {
+    count /= Num;
+  } else {
+    count /= Num;
+    count -= 1;
+  }
+  if (count > (std::numeric_limits<Rep>::max)()) return false;
+  if (count < (std::numeric_limits<Rep>::min)()) return false;
+  *tpp = time_point<D>() + D{static_cast<Rep>(count)};
+  return true;
+}
+
+template <typename Rep>
+bool join_seconds(
+    const time_point<seconds>& sec, const femtoseconds&,
+    time_point<std::chrono::duration<Rep, std::ratio<1, 1>>>* tpp) {
+  using D = std::chrono::duration<Rep, std::ratio<1, 1>>;
+  auto count = sec.time_since_epoch().count();
+  if (count > (std::numeric_limits<Rep>::max)()) return false;
+  if (count < (std::numeric_limits<Rep>::min)()) return false;
+  *tpp = time_point<D>() + D{static_cast<Rep>(count)};
+  return true;
+}
+
+inline bool join_seconds(const time_point<seconds>& sec, const femtoseconds&,
+                         time_point<seconds>* tpp) {
+  *tpp = sec;
+  return true;
+}
+
+}  // namespace detail
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/zone_info_source.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/zone_info_source.h
new file mode 100644
index 0000000..012eb4e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/zone_info_source.h
@@ -0,0 +1,102 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
+#define ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// A stdio-like interface for providing zoneinfo data for a particular zone.
+class ZoneInfoSource {
+ public:
+  virtual ~ZoneInfoSource();
+
+  virtual std::size_t Read(void* ptr, std::size_t size) = 0;  // like fread()
+  virtual int Skip(std::size_t offset) = 0;                   // like fseek()
+
+  // Until the zoneinfo data supports versioning information, we provide
+  // a way for a ZoneInfoSource to indicate it out-of-band.  The default
+  // implementation returns an empty string.
+  virtual std::string Version() const;
+};
+
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz_extension {
+
+// A function-pointer type for a factory that returns a ZoneInfoSource
+// given the name of a time zone and a fallback factory.  Returns null
+// when the data for the named zone cannot be found.
+using ZoneInfoSourceFactory =
+    std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource> (*)(
+        const std::string&,
+        const std::function<std::unique_ptr<
+            absl::time_internal::cctz::ZoneInfoSource>(const std::string&)>&);
+
+// The user can control the mapping of zone names to zoneinfo data by
+// providing a definition for cctz_extension::zone_info_source_factory.
+// For example, given functions my_factory() and my_other_factory() that
+// can return a ZoneInfoSource for a named zone, we could inject them into
+// cctz::load_time_zone() with:
+//
+//   namespace cctz_extension {
+//   namespace {
+//   std::unique_ptr<cctz::ZoneInfoSource> CustomFactory(
+//       const std::string& name,
+//       const std::function<std::unique_ptr<cctz::ZoneInfoSource>(
+//           const std::string& name)>& fallback_factory) {
+//     if (auto zip = my_factory(name)) return zip;
+//     if (auto zip = fallback_factory(name)) return zip;
+//     if (auto zip = my_other_factory(name)) return zip;
+//     return nullptr;
+//   }
+//   }  // namespace
+//   ZoneInfoSourceFactory zone_info_source_factory = CustomFactory;
+//   }  // namespace cctz_extension
+//
+// This might be used, say, to use zoneinfo data embedded in the program,
+// or read from a (possibly compressed) file archive, or both.
+//
+// cctz_extension::zone_info_source_factory() will be called:
+//   (1) from the same thread as the cctz::load_time_zone() call,
+//   (2) only once for any zone name, and
+//   (3) serially (i.e., no concurrent execution).
+//
+// The fallback factory obtains zoneinfo data by reading files in ${TZDIR},
+// and it is used automatically when no zone_info_source_factory definition
+// is linked into the program.
+extern ZoneInfoSourceFactory zone_info_source_factory;
+
+}  // namespace cctz_extension
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_fixed.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_fixed.h
new file mode 100644
index 0000000..e74a0bb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_fixed.h
@@ -0,0 +1,52 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
+
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// Helper functions for dealing with the names and abbreviations
+// of time zones that are a fixed offset (seconds east) from UTC.
+// FixedOffsetFromName() extracts the offset from a valid fixed-offset
+// name, while FixedOffsetToName() and FixedOffsetToAbbr() generate
+// the canonical zone name and abbreviation respectively for the given
+// offset.
+//
+// A fixed-offset name looks like "Fixed/UTC<+-><hours>:<mins>:<secs>".
+// Its abbreviation is of the form "UTC(<+->H?H(MM(SS)?)?)?" where the
+// optional pieces are omitted when their values are zero.  (Note that
+// the sign is the opposite of that used in a POSIX TZ specification.)
+//
+// Note: FixedOffsetFromName() fails on syntax errors or when the parsed
+// offset exceeds 24 hours.  FixedOffsetToName() and FixedOffsetToAbbr()
+// both produce "UTC" when the argument offset exceeds 24 hours.
+bool FixedOffsetFromName(const std::string& name, seconds* offset);
+std::string FixedOffsetToName(const seconds& offset);
+std::string FixedOffsetToAbbr(const seconds& offset);
+
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_if.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_if.h
new file mode 100644
index 0000000..7d3e42d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_if.h
@@ -0,0 +1,77 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
+
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// A simple interface used to hide time-zone complexities from time_zone::Impl.
+// Subclasses implement the functions for civil-time conversions in the zone.
+class TimeZoneIf {
+ public:
+  // A factory function for TimeZoneIf implementations.
+  static std::unique_ptr<TimeZoneIf> Load(const std::string& name);
+
+  virtual ~TimeZoneIf();
+
+  virtual time_zone::absolute_lookup BreakTime(
+      const time_point<seconds>& tp) const = 0;
+  virtual time_zone::civil_lookup MakeTime(const civil_second& cs) const = 0;
+
+  virtual bool NextTransition(const time_point<seconds>& tp,
+                              time_zone::civil_transition* trans) const = 0;
+  virtual bool PrevTransition(const time_point<seconds>& tp,
+                              time_zone::civil_transition* trans) const = 0;
+
+  virtual std::string Version() const = 0;
+  virtual std::string Description() const = 0;
+
+ protected:
+  TimeZoneIf() {}
+};
+
+// Convert between time_point<seconds> and a count of seconds since the
+// Unix epoch.  We assume that the std::chrono::system_clock and the
+// Unix clock are second aligned, and that the results are representable.
+// (That is, that they share an epoch, which is required since C++20.)
+inline std::int_fast64_t ToUnixSeconds(const time_point<seconds>& tp) {
+  return (tp - std::chrono::time_point_cast<seconds>(
+                   std::chrono::system_clock::from_time_t(0)))
+      .count();
+}
+inline time_point<seconds> FromUnixSeconds(std::int_fast64_t t) {
+  return std::chrono::time_point_cast<seconds>(
+             std::chrono::system_clock::from_time_t(0)) +
+         seconds(t);
+}
+
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_impl.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_impl.h
new file mode 100644
index 0000000..7d747ba
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_impl.h
@@ -0,0 +1,93 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/base/config.h"
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+#include "time_zone_if.h"
+#include "time_zone_info.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// time_zone::Impl is the internal object referenced by a cctz::time_zone.
+class time_zone::Impl {
+ public:
+  // The UTC time zone. Also used for other time zones that fail to load.
+  static time_zone UTC();
+
+  // Load a named time zone. Returns false if the name is invalid, or if
+  // some other kind of error occurs. Note that loading "UTC" never fails.
+  static bool LoadTimeZone(const std::string& name, time_zone* tz);
+
+  // Clears the map of cached time zones.  Primarily for use in benchmarks
+  // that gauge the performance of loading/parsing the time-zone data.
+  static void ClearTimeZoneMapTestOnly();
+
+  // The primary key is the time-zone ID (e.g., "America/New_York").
+  const std::string& Name() const {
+    // TODO: It would nice if the zoneinfo data included the zone name.
+    return name_;
+  }
+
+  // Breaks a time_point down to civil-time components in this time zone.
+  time_zone::absolute_lookup BreakTime(const time_point<seconds>& tp) const {
+    return zone_->BreakTime(tp);
+  }
+
+  // Converts the civil-time components in this time zone into a time_point.
+  // That is, the opposite of BreakTime(). The requested civil time may be
+  // ambiguous or illegal due to a change of UTC offset.
+  time_zone::civil_lookup MakeTime(const civil_second& cs) const {
+    return zone_->MakeTime(cs);
+  }
+
+  // Finds the time of the next/previous offset change in this time zone.
+  bool NextTransition(const time_point<seconds>& tp,
+                      time_zone::civil_transition* trans) const {
+    return zone_->NextTransition(tp, trans);
+  }
+  bool PrevTransition(const time_point<seconds>& tp,
+                      time_zone::civil_transition* trans) const {
+    return zone_->PrevTransition(tp, trans);
+  }
+
+  // Returns an implementation-defined version string for this time zone.
+  std::string Version() const { return zone_->Version(); }
+
+  // Returns an implementation-defined description of this time zone.
+  std::string Description() const { return zone_->Description(); }
+
+ private:
+  explicit Impl(const std::string& name);
+  static const Impl* UTCImpl();
+
+  const std::string name_;
+  std::unique_ptr<TimeZoneIf> zone_;
+};
+
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_info.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_info.h
new file mode 100644
index 0000000..2467ff5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_info.h
@@ -0,0 +1,137 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/base/config.h"
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+#include "absl/time/internal/cctz/include/cctz/zone_info_source.h"
+#include "time_zone_if.h"
+#include "tzfile.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// A transition to a new UTC offset.
+struct Transition {
+  std::int_least64_t unix_time;   // the instant of this transition
+  std::uint_least8_t type_index;  // index of the transition type
+  civil_second civil_sec;         // local civil time of transition
+  civil_second prev_civil_sec;    // local civil time one second earlier
+
+  struct ByUnixTime {
+    inline bool operator()(const Transition& lhs, const Transition& rhs) const {
+      return lhs.unix_time < rhs.unix_time;
+    }
+  };
+  struct ByCivilTime {
+    inline bool operator()(const Transition& lhs, const Transition& rhs) const {
+      return lhs.civil_sec < rhs.civil_sec;
+    }
+  };
+};
+
+// The characteristics of a particular transition.
+struct TransitionType {
+  std::int_least32_t utc_offset;  // the new prevailing UTC offset
+  civil_second civil_max;         // max convertible civil time for offset
+  civil_second civil_min;         // min convertible civil time for offset
+  bool is_dst;                    // did we move into daylight-saving time
+  std::uint_least8_t abbr_index;  // index of the new abbreviation
+};
+
+// A time zone backed by the IANA Time Zone Database (zoneinfo).
+class TimeZoneInfo : public TimeZoneIf {
+ public:
+  TimeZoneInfo() = default;
+  TimeZoneInfo(const TimeZoneInfo&) = delete;
+  TimeZoneInfo& operator=(const TimeZoneInfo&) = delete;
+
+  // Loads the zoneinfo for the given name, returning true if successful.
+  bool Load(const std::string& name);
+
+  // TimeZoneIf implementations.
+  time_zone::absolute_lookup BreakTime(
+      const time_point<seconds>& tp) const override;
+  time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
+  bool NextTransition(const time_point<seconds>& tp,
+                      time_zone::civil_transition* trans) const override;
+  bool PrevTransition(const time_point<seconds>& tp,
+                      time_zone::civil_transition* trans) const override;
+  std::string Version() const override;
+  std::string Description() const override;
+
+ private:
+  struct Header {            // counts of:
+    std::size_t timecnt;     // transition times
+    std::size_t typecnt;     // transition types
+    std::size_t charcnt;     // zone abbreviation characters
+    std::size_t leapcnt;     // leap seconds (we expect none)
+    std::size_t ttisstdcnt;  // UTC/local indicators (unused)
+    std::size_t ttisutcnt;   // standard/wall indicators (unused)
+
+    bool Build(const tzhead& tzh);
+    std::size_t DataLength(std::size_t time_len) const;
+  };
+
+  bool GetTransitionType(std::int_fast32_t utc_offset, bool is_dst,
+                         const std::string& abbr, std::uint_least8_t* index);
+  bool EquivTransitions(std::uint_fast8_t tt1_index,
+                        std::uint_fast8_t tt2_index) const;
+  bool ExtendTransitions();
+
+  bool ResetToBuiltinUTC(const seconds& offset);
+  bool Load(ZoneInfoSource* zip);
+
+  // Helpers for BreakTime() and MakeTime().
+  time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
+                                       const TransitionType& tt) const;
+  time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
+                                       const Transition& tr) const;
+  time_zone::civil_lookup TimeLocal(const civil_second& cs,
+                                    year_t c4_shift) const;
+
+  std::vector<Transition> transitions_;  // ordered by unix_time and civil_sec
+  std::vector<TransitionType> transition_types_;  // distinct transition types
+  std::uint_fast8_t default_transition_type_;     // for before first transition
+  std::string abbreviations_;  // all the NUL-terminated abbreviations
+
+  std::string version_;      // the tzdata version if available
+  std::string future_spec_;  // for after the last zic transition
+  bool extended_;            // future_spec_ was used to generate transitions
+  year_t last_year_;         // the final year of the generated transitions
+
+  // We remember the transitions found during the last BreakTime() and
+  // MakeTime() calls. If the next request is for the same transition we
+  // will avoid re-searching.
+  mutable std::atomic<std::size_t> local_time_hint_ = {};  // BreakTime() hint
+  mutable std::atomic<std::size_t> time_local_hint_ = {};  // MakeTime() hint
+};
+
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_libc.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_libc.h
new file mode 100644
index 0000000..1da9039
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_libc.h
@@ -0,0 +1,55 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
+
+#include <string>
+
+#include "absl/base/config.h"
+#include "time_zone_if.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// A time zone backed by gmtime_r(3), localtime_r(3), and mktime(3),
+// and which therefore only supports UTC and the local time zone.
+// TODO: Add support for fixed offsets from UTC.
+class TimeZoneLibC : public TimeZoneIf {
+ public:
+  explicit TimeZoneLibC(const std::string& name);
+
+  // TimeZoneIf implementations.
+  time_zone::absolute_lookup BreakTime(
+      const time_point<seconds>& tp) const override;
+  time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
+  bool NextTransition(const time_point<seconds>& tp,
+                      time_zone::civil_transition* trans) const override;
+  bool PrevTransition(const time_point<seconds>& tp,
+                      time_zone::civil_transition* trans) const override;
+  std::string Version() const override;
+  std::string Description() const override;
+
+ private:
+  const bool local_;  // localtime or UTC
+};
+
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_posix.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_posix.h
new file mode 100644
index 0000000..0cf2905
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_posix.h
@@ -0,0 +1,132 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+// Parsing of a POSIX zone spec as described in the TZ part of section 8.3 in
+// http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html.
+//
+// The current POSIX spec for America/Los_Angeles is "PST8PDT,M3.2.0,M11.1.0",
+// which would be broken down as ...
+//
+//   PosixTimeZone {
+//     std_abbr = "PST"
+//     std_offset = -28800
+//     dst_abbr = "PDT"
+//     dst_offset = -25200
+//     dst_start = PosixTransition {
+//       date {
+//         m {
+//           month = 3
+//           week = 2
+//           weekday = 0
+//         }
+//       }
+//       time {
+//         offset = 7200
+//       }
+//     }
+//     dst_end = PosixTransition {
+//       date {
+//         m {
+//           month = 11
+//           week = 1
+//           weekday = 0
+//         }
+//       }
+//       time {
+//         offset = 7200
+//       }
+//     }
+//   }
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
+
+#include <cstdint>
+#include <string>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+namespace cctz {
+
+// The date/time of the transition. The date is specified as either:
+// (J) the Nth day of the year (1 <= N <= 365), excluding leap days, or
+// (N) the Nth day of the year (0 <= N <= 365), including leap days, or
+// (M) the Nth weekday of a month (e.g., the 2nd Sunday in March).
+// The time, specified as a day offset, identifies the particular moment
+// of the transition, and may be negative or >= 24h, and in which case
+// it would take us to another day, and perhaps week, or even month.
+struct PosixTransition {
+  enum DateFormat { J, N, M };
+
+  struct Date {
+    struct NonLeapDay {
+      std::int_fast16_t day;  // day of non-leap year [1:365]
+    };
+    struct Day {
+      std::int_fast16_t day;  // day of year [0:365]
+    };
+    struct MonthWeekWeekday {
+      std::int_fast8_t month;    // month of year [1:12]
+      std::int_fast8_t week;     // week of month [1:5] (5==last)
+      std::int_fast8_t weekday;  // 0==Sun, ..., 6=Sat
+    };
+
+    DateFormat fmt;
+
+    union {
+      NonLeapDay j;
+      Day n;
+      MonthWeekWeekday m;
+    };
+  };
+
+  struct Time {
+    std::int_fast32_t offset;  // seconds before/after 00:00:00
+  };
+
+  Date date;
+  Time time;
+};
+
+// The entirety of a POSIX-string specified time-zone rule. The standard
+// abbreviation and offset are always given. If the time zone includes
+// daylight saving, then the daylight abbrevation is non-empty and the
+// remaining fields are also valid. Note that the start/end transitions
+// are not ordered---in the southern hemisphere the transition to end
+// daylight time occurs first in any particular year.
+struct PosixTimeZone {
+  std::string std_abbr;
+  std::int_fast32_t std_offset;
+
+  std::string dst_abbr;
+  std::int_fast32_t dst_offset;
+  PosixTransition dst_start;
+  PosixTransition dst_end;
+};
+
+// Breaks down a POSIX time-zone specification into its constituent pieces,
+// filling in any missing values (DST offset, or start/end transition times)
+// with the standard-defined defaults. Returns false if the specification
+// could not be parsed (although some fields of *res may have been altered).
+bool ParsePosixSpec(const std::string& spec, PosixTimeZone* res);
+
+}  // namespace cctz
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/tzfile.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/tzfile.h
new file mode 100644
index 0000000..31e8598
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/tzfile.h
@@ -0,0 +1,122 @@
+/* Layout and location of TZif files.  */
+
+#ifndef TZFILE_H
+
+#define TZFILE_H
+
+/*
+** This file is in the public domain, so clarified as of
+** 1996-06-05 by Arthur David Olson.
+*/
+
+/*
+** This header is for use ONLY with the time conversion code.
+** There is no guarantee that it will remain unchanged,
+** or that it will remain at all.
+** Do NOT copy it to any system include directory.
+** Thank you!
+*/
+
+/*
+** Information about time zone files.
+*/
+
+#ifndef TZDIR
+#define TZDIR "/usr/share/zoneinfo" /* Time zone object file directory */
+#endif                              /* !defined TZDIR */
+
+#ifndef TZDEFAULT
+#define TZDEFAULT "/etc/localtime"
+#endif /* !defined TZDEFAULT */
+
+#ifndef TZDEFRULES
+#define TZDEFRULES "posixrules"
+#endif /* !defined TZDEFRULES */
+
+/* See Internet RFC 8536 for more details about the following format.  */
+
+/*
+** Each file begins with. . .
+*/
+
+#define TZ_MAGIC "TZif"
+
+struct tzhead {
+  char tzh_magic[4];      /* TZ_MAGIC */
+  char tzh_version[1];    /* '\0' or '2'-'4' as of 2021 */
+  char tzh_reserved[15];  /* reserved; must be zero */
+  char tzh_ttisutcnt[4];  /* coded number of trans. time flags */
+  char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */
+  char tzh_leapcnt[4];    /* coded number of leap seconds */
+  char tzh_timecnt[4];    /* coded number of transition times */
+  char tzh_typecnt[4];    /* coded number of local time types */
+  char tzh_charcnt[4];    /* coded number of abbr. chars */
+};
+
+/*
+** . . .followed by. . .
+**
+**	tzh_timecnt (char [4])s		coded transition times a la time(2)
+**	tzh_timecnt (unsigned char)s	types of local time starting at above
+**	tzh_typecnt repetitions of
+**		one (char [4])		coded UT offset in seconds
+**		one (unsigned char)	used to set tm_isdst
+**		one (unsigned char)	that's an abbreviation list index
+**	tzh_charcnt (char)s		'\0'-terminated zone abbreviations
+**	tzh_leapcnt repetitions of
+**		one (char [4])		coded leap second transition times
+**		one (char [4])		total correction after above
+**	tzh_ttisstdcnt (char)s		indexed by type; if 1, transition
+**					time is standard time, if 0,
+**					transition time is local (wall clock)
+**					time; if absent, transition times are
+**					assumed to be local time
+**	tzh_ttisutcnt (char)s		indexed by type; if 1, transition
+**					time is UT, if 0, transition time is
+**					local time; if absent, transition
+**					times are assumed to be local time.
+**					When this is 1, the corresponding
+**					std/wall indicator must also be 1.
+*/
+
+/*
+** If tzh_version is '2' or greater, the above is followed by a second instance
+** of tzhead and a second instance of the data in which each coded transition
+** time uses 8 rather than 4 chars,
+** then a POSIX-TZ-environment-variable-style string for use in handling
+** instants after the last transition time stored in the file
+** (with nothing between the newlines if there is no POSIX representation for
+** such instants).
+**
+** If tz_version is '3' or greater, the above is extended as follows.
+** First, the POSIX TZ string's hour offset may range from -167
+** through 167 as compared to the POSIX-required 0 through 24.
+** Second, its DST start time may be January 1 at 00:00 and its stop
+** time December 31 at 24:00 plus the difference between DST and
+** standard time, indicating DST all year.
+*/
+
+/*
+** In the current implementation, "tzset()" refuses to deal with files that
+** exceed any of the limits below.
+*/
+
+#ifndef TZ_MAX_TIMES
+#define TZ_MAX_TIMES 2000
+#endif /* !defined TZ_MAX_TIMES */
+
+#ifndef TZ_MAX_TYPES
+/* This must be at least 17 for Europe/Samara and Europe/Vilnius.  */
+#define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */
+#endif                   /* !defined TZ_MAX_TYPES */
+
+#ifndef TZ_MAX_CHARS
+#define TZ_MAX_CHARS 50 /* Maximum number of abbreviation characters */
+                        /* (limited by what unsigned chars can hold) */
+#endif                  /* !defined TZ_MAX_CHARS */
+
+#ifndef TZ_MAX_LEAPS
+#define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */
+#endif                  /* !defined TZ_MAX_LEAPS */
+
+#endif /* !defined TZFILE_H */
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/get_current_time_chrono.inc b/CAPI/cpp/grpc/include/absl/time/internal/get_current_time_chrono.inc
new file mode 100644
index 0000000..5eeb640
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/get_current_time_chrono.inc
@@ -0,0 +1,31 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#include <chrono>
+#include <cstdint>
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+
+static int64_t GetCurrentTimeNanosFromSystem() {
+  return std::chrono::duration_cast<std::chrono::nanoseconds>(
+             std::chrono::system_clock::now() -
+             std::chrono::system_clock::from_time_t(0))
+      .count();
+}
+
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/get_current_time_posix.inc b/CAPI/cpp/grpc/include/absl/time/internal/get_current_time_posix.inc
new file mode 100644
index 0000000..4207200
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/get_current_time_posix.inc
@@ -0,0 +1,24 @@
+#include "absl/time/clock.h"
+
+#include <sys/time.h>
+#include <ctime>
+#include <cstdint>
+
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+
+static int64_t GetCurrentTimeNanosFromSystem() {
+  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
+  struct timespec ts;
+  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
+                 "Failed to read real-time clock.");
+  return (int64_t{ts.tv_sec} * kNanosPerSecond +
+          int64_t{ts.tv_nsec});
+}
+
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/test_util.h b/CAPI/cpp/grpc/include/absl/time/internal/test_util.h
new file mode 100644
index 0000000..5c4bf1f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/test_util.h
@@ -0,0 +1,33 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_TIME_INTERNAL_TEST_UTIL_H_
+#define ABSL_TIME_INTERNAL_TEST_UTIL_H_
+
+#include <string>
+
+#include "absl/time/time.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace time_internal {
+
+// Loads the named timezone, but dies on any failure.
+absl::TimeZone LoadTimeZone(const std::string& name);
+
+}  // namespace time_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_INTERNAL_TEST_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/zoneinfo.inc b/CAPI/cpp/grpc/include/absl/time/internal/zoneinfo.inc
new file mode 100644
index 0000000..7d8b3ff
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/internal/zoneinfo.inc
@@ -0,0 +1,724 @@
+unsigned char America_Los_Angeles[] = {
+  0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba,
+  0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0x80, 0x00, 0x00, 0x00,
+  0x9e, 0xa6, 0x48, 0xa0, 0x9f, 0xbb, 0x15, 0x90, 0xa0, 0x86, 0x2a, 0xa0,
+  0xa1, 0x9a, 0xf7, 0x90, 0xcb, 0x89, 0x1a, 0xa0, 0xd2, 0x23, 0xf4, 0x70,
+  0xd2, 0x61, 0x26, 0x10, 0xd6, 0xfe, 0x74, 0x5c, 0xd8, 0x80, 0xad, 0x90,
+  0xda, 0xfe, 0xc3, 0x90, 0xdb, 0xc0, 0x90, 0x10, 0xdc, 0xde, 0xa5, 0x90,
+  0xdd, 0xa9, 0xac, 0x90, 0xde, 0xbe, 0x87, 0x90, 0xdf, 0x89, 0x8e, 0x90,
+  0xe0, 0x9e, 0x69, 0x90, 0xe1, 0x69, 0x70, 0x90, 0xe2, 0x7e, 0x4b, 0x90,
+  0xe3, 0x49, 0x52, 0x90, 0xe4, 0x5e, 0x2d, 0x90, 0xe5, 0x29, 0x34, 0x90,
+  0xe6, 0x47, 0x4a, 0x10, 0xe7, 0x12, 0x51, 0x10, 0xe8, 0x27, 0x2c, 0x10,
+  0xe8, 0xf2, 0x33, 0x10, 0xea, 0x07, 0x0e, 0x10, 0xea, 0xd2, 0x15, 0x10,
+  0xeb, 0xe6, 0xf0, 0x10, 0xec, 0xb1, 0xf7, 0x10, 0xed, 0xc6, 0xd2, 0x10,
+  0xee, 0x91, 0xd9, 0x10, 0xef, 0xaf, 0xee, 0x90, 0xf0, 0x71, 0xbb, 0x10,
+  0xf1, 0x8f, 0xd0, 0x90, 0xf2, 0x7f, 0xc1, 0x90, 0xf3, 0x6f, 0xb2, 0x90,
+  0xf4, 0x5f, 0xa3, 0x90, 0xf5, 0x4f, 0x94, 0x90, 0xf6, 0x3f, 0x85, 0x90,
+  0xf7, 0x2f, 0x76, 0x90, 0xf8, 0x28, 0xa2, 0x10, 0xf9, 0x0f, 0x58, 0x90,
+  0xfa, 0x08, 0x84, 0x10, 0xfa, 0xf8, 0x83, 0x20, 0xfb, 0xe8, 0x66, 0x10,
+  0xfc, 0xd8, 0x65, 0x20, 0xfd, 0xc8, 0x48, 0x10, 0xfe, 0xb8, 0x47, 0x20,
+  0xff, 0xa8, 0x2a, 0x10, 0x00, 0x98, 0x29, 0x20, 0x01, 0x88, 0x0c, 0x10,
+  0x02, 0x78, 0x0b, 0x20, 0x03, 0x71, 0x28, 0x90, 0x04, 0x61, 0x27, 0xa0,
+  0x05, 0x51, 0x0a, 0x90, 0x06, 0x41, 0x09, 0xa0, 0x07, 0x30, 0xec, 0x90,
+  0x07, 0x8d, 0x43, 0xa0, 0x09, 0x10, 0xce, 0x90, 0x09, 0xad, 0xbf, 0x20,
+  0x0a, 0xf0, 0xb0, 0x90, 0x0b, 0xe0, 0xaf, 0xa0, 0x0c, 0xd9, 0xcd, 0x10,
+  0x0d, 0xc0, 0x91, 0xa0, 0x0e, 0xb9, 0xaf, 0x10, 0x0f, 0xa9, 0xae, 0x20,
+  0x10, 0x99, 0x91, 0x10, 0x11, 0x89, 0x90, 0x20, 0x12, 0x79, 0x73, 0x10,
+  0x13, 0x69, 0x72, 0x20, 0x14, 0x59, 0x55, 0x10, 0x15, 0x49, 0x54, 0x20,
+  0x16, 0x39, 0x37, 0x10, 0x17, 0x29, 0x36, 0x20, 0x18, 0x22, 0x53, 0x90,
+  0x19, 0x09, 0x18, 0x20, 0x1a, 0x02, 0x35, 0x90, 0x1a, 0xf2, 0x34, 0xa0,
+  0x1b, 0xe2, 0x17, 0x90, 0x1c, 0xd2, 0x16, 0xa0, 0x1d, 0xc1, 0xf9, 0x90,
+  0x1e, 0xb1, 0xf8, 0xa0, 0x1f, 0xa1, 0xdb, 0x90, 0x20, 0x76, 0x2b, 0x20,
+  0x21, 0x81, 0xbd, 0x90, 0x22, 0x56, 0x0d, 0x20, 0x23, 0x6a, 0xda, 0x10,
+  0x24, 0x35, 0xef, 0x20, 0x25, 0x4a, 0xbc, 0x10, 0x26, 0x15, 0xd1, 0x20,
+  0x27, 0x2a, 0x9e, 0x10, 0x27, 0xfe, 0xed, 0xa0, 0x29, 0x0a, 0x80, 0x10,
+  0x29, 0xde, 0xcf, 0xa0, 0x2a, 0xea, 0x62, 0x10, 0x2b, 0xbe, 0xb1, 0xa0,
+  0x2c, 0xd3, 0x7e, 0x90, 0x2d, 0x9e, 0x93, 0xa0, 0x2e, 0xb3, 0x60, 0x90,
+  0x2f, 0x7e, 0x75, 0xa0, 0x30, 0x93, 0x42, 0x90, 0x31, 0x67, 0x92, 0x20,
+  0x32, 0x73, 0x24, 0x90, 0x33, 0x47, 0x74, 0x20, 0x34, 0x53, 0x06, 0x90,
+  0x35, 0x27, 0x56, 0x20, 0x36, 0x32, 0xe8, 0x90, 0x37, 0x07, 0x38, 0x20,
+  0x38, 0x1c, 0x05, 0x10, 0x38, 0xe7, 0x1a, 0x20, 0x39, 0xfb, 0xe7, 0x10,
+  0x3a, 0xc6, 0xfc, 0x20, 0x3b, 0xdb, 0xc9, 0x10, 0x3c, 0xb0, 0x18, 0xa0,
+  0x3d, 0xbb, 0xab, 0x10, 0x3e, 0x8f, 0xfa, 0xa0, 0x3f, 0x9b, 0x8d, 0x10,
+  0x40, 0x6f, 0xdc, 0xa0, 0x41, 0x84, 0xa9, 0x90, 0x42, 0x4f, 0xbe, 0xa0,
+  0x43, 0x64, 0x8b, 0x90, 0x44, 0x2f, 0xa0, 0xa0, 0x45, 0x44, 0x6d, 0x90,
+  0x45, 0xf3, 0xd3, 0x20, 0x47, 0x2d, 0x8a, 0x10, 0x47, 0xd3, 0xb5, 0x20,
+  0x49, 0x0d, 0x6c, 0x10, 0x49, 0xb3, 0x97, 0x20, 0x4a, 0xed, 0x4e, 0x10,
+  0x4b, 0x9c, 0xb3, 0xa0, 0x4c, 0xd6, 0x6a, 0x90, 0x4d, 0x7c, 0x95, 0xa0,
+  0x4e, 0xb6, 0x4c, 0x90, 0x4f, 0x5c, 0x77, 0xa0, 0x50, 0x96, 0x2e, 0x90,
+  0x51, 0x3c, 0x59, 0xa0, 0x52, 0x76, 0x10, 0x90, 0x53, 0x1c, 0x3b, 0xa0,
+  0x54, 0x55, 0xf2, 0x90, 0x54, 0xfc, 0x1d, 0xa0, 0x56, 0x35, 0xd4, 0x90,
+  0x56, 0xe5, 0x3a, 0x20, 0x58, 0x1e, 0xf1, 0x10, 0x58, 0xc5, 0x1c, 0x20,
+  0x59, 0xfe, 0xd3, 0x10, 0x5a, 0xa4, 0xfe, 0x20, 0x5b, 0xde, 0xb5, 0x10,
+  0x5c, 0x84, 0xe0, 0x20, 0x5d, 0xbe, 0x97, 0x10, 0x5e, 0x64, 0xc2, 0x20,
+  0x5f, 0x9e, 0x79, 0x10, 0x60, 0x4d, 0xde, 0xa0, 0x61, 0x87, 0x95, 0x90,
+  0x62, 0x2d, 0xc0, 0xa0, 0x63, 0x67, 0x77, 0x90, 0x64, 0x0d, 0xa2, 0xa0,
+  0x65, 0x47, 0x59, 0x90, 0x65, 0xed, 0x84, 0xa0, 0x67, 0x27, 0x3b, 0x90,
+  0x67, 0xcd, 0x66, 0xa0, 0x69, 0x07, 0x1d, 0x90, 0x69, 0xad, 0x48, 0xa0,
+  0x6a, 0xe6, 0xff, 0x90, 0x6b, 0x96, 0x65, 0x20, 0x6c, 0xd0, 0x1c, 0x10,
+  0x6d, 0x76, 0x47, 0x20, 0x6e, 0xaf, 0xfe, 0x10, 0x6f, 0x56, 0x29, 0x20,
+  0x70, 0x8f, 0xe0, 0x10, 0x71, 0x36, 0x0b, 0x20, 0x72, 0x6f, 0xc2, 0x10,
+  0x73, 0x15, 0xed, 0x20, 0x74, 0x4f, 0xa4, 0x10, 0x74, 0xff, 0x09, 0xa0,
+  0x76, 0x38, 0xc0, 0x90, 0x76, 0xde, 0xeb, 0xa0, 0x78, 0x18, 0xa2, 0x90,
+  0x78, 0xbe, 0xcd, 0xa0, 0x79, 0xf8, 0x84, 0x90, 0x7a, 0x9e, 0xaf, 0xa0,
+  0x7b, 0xd8, 0x66, 0x90, 0x7c, 0x7e, 0x91, 0xa0, 0x7d, 0xb8, 0x48, 0x90,
+  0x7e, 0x5e, 0x73, 0xa0, 0x7f, 0x98, 0x2a, 0x90, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x03, 0x04, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0xff, 0xff, 0x91, 0x26, 0x00, 0x00, 0xff, 0xff, 0x9d, 0x90,
+  0x01, 0x04, 0xff, 0xff, 0x8f, 0x80, 0x00, 0x08, 0xff, 0xff, 0x9d, 0x90,
+  0x01, 0x0c, 0xff, 0xff, 0x9d, 0x90, 0x01, 0x10, 0x4c, 0x4d, 0x54, 0x00,
+  0x50, 0x44, 0x54, 0x00, 0x50, 0x53, 0x54, 0x00, 0x50, 0x57, 0x54, 0x00,
+  0x50, 0x50, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0xba, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff,
+  0xff, 0xff, 0x5e, 0x04, 0x1a, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xa6,
+  0x48, 0xa0, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xbb, 0x15, 0x90, 0xff, 0xff,
+  0xff, 0xff, 0xa0, 0x86, 0x2a, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x9a,
+  0xf7, 0x90, 0xff, 0xff, 0xff, 0xff, 0xcb, 0x89, 0x1a, 0xa0, 0xff, 0xff,
+  0xff, 0xff, 0xd2, 0x23, 0xf4, 0x70, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x61,
+  0x26, 0x10, 0xff, 0xff, 0xff, 0xff, 0xd6, 0xfe, 0x74, 0x5c, 0xff, 0xff,
+  0xff, 0xff, 0xd8, 0x80, 0xad, 0x90, 0xff, 0xff, 0xff, 0xff, 0xda, 0xfe,
+  0xc3, 0x90, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xc0, 0x90, 0x10, 0xff, 0xff,
+  0xff, 0xff, 0xdc, 0xde, 0xa5, 0x90, 0xff, 0xff, 0xff, 0xff, 0xdd, 0xa9,
+  0xac, 0x90, 0xff, 0xff, 0xff, 0xff, 0xde, 0xbe, 0x87, 0x90, 0xff, 0xff,
+  0xff, 0xff, 0xdf, 0x89, 0x8e, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x9e,
+  0x69, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x69, 0x70, 0x90, 0xff, 0xff,
+  0xff, 0xff, 0xe2, 0x7e, 0x4b, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x49,
+  0x52, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x5e, 0x2d, 0x90, 0xff, 0xff,
+  0xff, 0xff, 0xe5, 0x29, 0x34, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x47,
+  0x4a, 0x10, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x12, 0x51, 0x10, 0xff, 0xff,
+  0xff, 0xff, 0xe8, 0x27, 0x2c, 0x10, 0xff, 0xff, 0xff, 0xff, 0xe8, 0xf2,
+  0x33, 0x10, 0xff, 0xff, 0xff, 0xff, 0xea, 0x07, 0x0e, 0x10, 0xff, 0xff,
+  0xff, 0xff, 0xea, 0xd2, 0x15, 0x10, 0xff, 0xff, 0xff, 0xff, 0xeb, 0xe6,
+  0xf0, 0x10, 0xff, 0xff, 0xff, 0xff, 0xec, 0xb1, 0xf7, 0x10, 0xff, 0xff,
+  0xff, 0xff, 0xed, 0xc6, 0xd2, 0x10, 0xff, 0xff, 0xff, 0xff, 0xee, 0x91,
+  0xd9, 0x10, 0xff, 0xff, 0xff, 0xff, 0xef, 0xaf, 0xee, 0x90, 0xff, 0xff,
+  0xff, 0xff, 0xf0, 0x71, 0xbb, 0x10, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x8f,
+  0xd0, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x7f, 0xc1, 0x90, 0xff, 0xff,
+  0xff, 0xff, 0xf3, 0x6f, 0xb2, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x5f,
+  0xa3, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x4f, 0x94, 0x90, 0xff, 0xff,
+  0xff, 0xff, 0xf6, 0x3f, 0x85, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x2f,
+  0x76, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x28, 0xa2, 0x10, 0xff, 0xff,
+  0xff, 0xff, 0xf9, 0x0f, 0x58, 0x90, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x08,
+  0x84, 0x10, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xf8, 0x83, 0x20, 0xff, 0xff,
+  0xff, 0xff, 0xfb, 0xe8, 0x66, 0x10, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xd8,
+  0x65, 0x20, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xc8, 0x48, 0x10, 0xff, 0xff,
+  0xff, 0xff, 0xfe, 0xb8, 0x47, 0x20, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa8,
+  0x2a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, 0x29, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x01, 0x88, 0x0c, 0x10, 0x00, 0x00, 0x00, 0x00, 0x02, 0x78,
+  0x0b, 0x20, 0x00, 0x00, 0x00, 0x00, 0x03, 0x71, 0x28, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x04, 0x61, 0x27, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x05, 0x51,
+  0x0a, 0x90, 0x00, 0x00, 0x00, 0x00, 0x06, 0x41, 0x09, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x07, 0x30, 0xec, 0x90, 0x00, 0x00, 0x00, 0x00, 0x07, 0x8d,
+  0x43, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x09, 0x10, 0xce, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x09, 0xad, 0xbf, 0x20, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xf0,
+  0xb0, 0x90, 0x00, 0x00, 0x00, 0x00, 0x0b, 0xe0, 0xaf, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x0c, 0xd9, 0xcd, 0x10, 0x00, 0x00, 0x00, 0x00, 0x0d, 0xc0,
+  0x91, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xb9, 0xaf, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x0f, 0xa9, 0xae, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10, 0x99,
+  0x91, 0x10, 0x00, 0x00, 0x00, 0x00, 0x11, 0x89, 0x90, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x12, 0x79, 0x73, 0x10, 0x00, 0x00, 0x00, 0x00, 0x13, 0x69,
+  0x72, 0x20, 0x00, 0x00, 0x00, 0x00, 0x14, 0x59, 0x55, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x15, 0x49, 0x54, 0x20, 0x00, 0x00, 0x00, 0x00, 0x16, 0x39,
+  0x37, 0x10, 0x00, 0x00, 0x00, 0x00, 0x17, 0x29, 0x36, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x18, 0x22, 0x53, 0x90, 0x00, 0x00, 0x00, 0x00, 0x19, 0x09,
+  0x18, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x02, 0x35, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x1a, 0xf2, 0x34, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x1b, 0xe2,
+  0x17, 0x90, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xd2, 0x16, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x1d, 0xc1, 0xf9, 0x90, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xb1,
+  0xf8, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xa1, 0xdb, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x20, 0x76, 0x2b, 0x20, 0x00, 0x00, 0x00, 0x00, 0x21, 0x81,
+  0xbd, 0x90, 0x00, 0x00, 0x00, 0x00, 0x22, 0x56, 0x0d, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x23, 0x6a, 0xda, 0x10, 0x00, 0x00, 0x00, 0x00, 0x24, 0x35,
+  0xef, 0x20, 0x00, 0x00, 0x00, 0x00, 0x25, 0x4a, 0xbc, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x26, 0x15, 0xd1, 0x20, 0x00, 0x00, 0x00, 0x00, 0x27, 0x2a,
+  0x9e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x27, 0xfe, 0xed, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x29, 0x0a, 0x80, 0x10, 0x00, 0x00, 0x00, 0x00, 0x29, 0xde,
+  0xcf, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x2a, 0xea, 0x62, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x2b, 0xbe, 0xb1, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x2c, 0xd3,
+  0x7e, 0x90, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x9e, 0x93, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x2e, 0xb3, 0x60, 0x90, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x7e,
+  0x75, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x30, 0x93, 0x42, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x31, 0x67, 0x92, 0x20, 0x00, 0x00, 0x00, 0x00, 0x32, 0x73,
+  0x24, 0x90, 0x00, 0x00, 0x00, 0x00, 0x33, 0x47, 0x74, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x34, 0x53, 0x06, 0x90, 0x00, 0x00, 0x00, 0x00, 0x35, 0x27,
+  0x56, 0x20, 0x00, 0x00, 0x00, 0x00, 0x36, 0x32, 0xe8, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x37, 0x07, 0x38, 0x20, 0x00, 0x00, 0x00, 0x00, 0x38, 0x1c,
+  0x05, 0x10, 0x00, 0x00, 0x00, 0x00, 0x38, 0xe7, 0x1a, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x39, 0xfb, 0xe7, 0x10, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xc6,
+  0xfc, 0x20, 0x00, 0x00, 0x00, 0x00, 0x3b, 0xdb, 0xc9, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x3c, 0xb0, 0x18, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x3d, 0xbb,
+  0xab, 0x10, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x8f, 0xfa, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x3f, 0x9b, 0x8d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x40, 0x6f,
+  0xdc, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x41, 0x84, 0xa9, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x42, 0x4f, 0xbe, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x43, 0x64,
+  0x8b, 0x90, 0x00, 0x00, 0x00, 0x00, 0x44, 0x2f, 0xa0, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x45, 0x44, 0x6d, 0x90, 0x00, 0x00, 0x00, 0x00, 0x45, 0xf3,
+  0xd3, 0x20, 0x00, 0x00, 0x00, 0x00, 0x47, 0x2d, 0x8a, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x47, 0xd3, 0xb5, 0x20, 0x00, 0x00, 0x00, 0x00, 0x49, 0x0d,
+  0x6c, 0x10, 0x00, 0x00, 0x00, 0x00, 0x49, 0xb3, 0x97, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x4a, 0xed, 0x4e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x4b, 0x9c,
+  0xb3, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x4c, 0xd6, 0x6a, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x4d, 0x7c, 0x95, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xb6,
+  0x4c, 0x90, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x5c, 0x77, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x50, 0x96, 0x2e, 0x90, 0x00, 0x00, 0x00, 0x00, 0x51, 0x3c,
+  0x59, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x52, 0x76, 0x10, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x53, 0x1c, 0x3b, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x54, 0x55,
+  0xf2, 0x90, 0x00, 0x00, 0x00, 0x00, 0x54, 0xfc, 0x1d, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x56, 0x35, 0xd4, 0x90, 0x00, 0x00, 0x00, 0x00, 0x56, 0xe5,
+  0x3a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x58, 0x1e, 0xf1, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x58, 0xc5, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x59, 0xfe,
+  0xd3, 0x10, 0x00, 0x00, 0x00, 0x00, 0x5a, 0xa4, 0xfe, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x5b, 0xde, 0xb5, 0x10, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x84,
+  0xe0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x5d, 0xbe, 0x97, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x5e, 0x64, 0xc2, 0x20, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x9e,
+  0x79, 0x10, 0x00, 0x00, 0x00, 0x00, 0x60, 0x4d, 0xde, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x61, 0x87, 0x95, 0x90, 0x00, 0x00, 0x00, 0x00, 0x62, 0x2d,
+  0xc0, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x63, 0x67, 0x77, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x64, 0x0d, 0xa2, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x65, 0x47,
+  0x59, 0x90, 0x00, 0x00, 0x00, 0x00, 0x65, 0xed, 0x84, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x67, 0x27, 0x3b, 0x90, 0x00, 0x00, 0x00, 0x00, 0x67, 0xcd,
+  0x66, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x69, 0x07, 0x1d, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x69, 0xad, 0x48, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x6a, 0xe6,
+  0xff, 0x90, 0x00, 0x00, 0x00, 0x00, 0x6b, 0x96, 0x65, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x6c, 0xd0, 0x1c, 0x10, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x76,
+  0x47, 0x20, 0x00, 0x00, 0x00, 0x00, 0x6e, 0xaf, 0xfe, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x6f, 0x56, 0x29, 0x20, 0x00, 0x00, 0x00, 0x00, 0x70, 0x8f,
+  0xe0, 0x10, 0x00, 0x00, 0x00, 0x00, 0x71, 0x36, 0x0b, 0x20, 0x00, 0x00,
+  0x00, 0x00, 0x72, 0x6f, 0xc2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x73, 0x15,
+  0xed, 0x20, 0x00, 0x00, 0x00, 0x00, 0x74, 0x4f, 0xa4, 0x10, 0x00, 0x00,
+  0x00, 0x00, 0x74, 0xff, 0x09, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x76, 0x38,
+  0xc0, 0x90, 0x00, 0x00, 0x00, 0x00, 0x76, 0xde, 0xeb, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x78, 0x18, 0xa2, 0x90, 0x00, 0x00, 0x00, 0x00, 0x78, 0xbe,
+  0xcd, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x79, 0xf8, 0x84, 0x90, 0x00, 0x00,
+  0x00, 0x00, 0x7a, 0x9e, 0xaf, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x7b, 0xd8,
+  0x66, 0x90, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x7e, 0x91, 0xa0, 0x00, 0x00,
+  0x00, 0x00, 0x7d, 0xb8, 0x48, 0x90, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x5e,
+  0x73, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x98, 0x2a, 0x90, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x03, 0x04, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0xff, 0xff, 0x91, 0x26, 0x00, 0x00, 0xff, 0xff,
+  0x9d, 0x90, 0x01, 0x04, 0xff, 0xff, 0x8f, 0x80, 0x00, 0x08, 0xff, 0xff,
+  0x9d, 0x90, 0x01, 0x0c, 0xff, 0xff, 0x9d, 0x90, 0x01, 0x10, 0x4c, 0x4d,
+  0x54, 0x00, 0x50, 0x44, 0x54, 0x00, 0x50, 0x53, 0x54, 0x00, 0x50, 0x57,
+  0x54, 0x00, 0x50, 0x50, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x0a, 0x50, 0x53, 0x54, 0x38, 0x50, 0x44, 0x54,
+  0x2c, 0x4d, 0x33, 0x2e, 0x32, 0x2e, 0x30, 0x2c, 0x4d, 0x31, 0x31, 0x2e,
+  0x31, 0x2e, 0x30, 0x0a
+};
+unsigned int America_Los_Angeles_len = 2836;
+unsigned char America_New_York[] = {
+  0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec,
+  0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0x80, 0x00, 0x00, 0x00,
+  0x9e, 0xa6, 0x1e, 0x70, 0x9f, 0xba, 0xeb, 0x60, 0xa0, 0x86, 0x00, 0x70,
+  0xa1, 0x9a, 0xcd, 0x60, 0xa2, 0x65, 0xe2, 0x70, 0xa3, 0x83, 0xe9, 0xe0,
+  0xa4, 0x6a, 0xae, 0x70, 0xa5, 0x35, 0xa7, 0x60, 0xa6, 0x53, 0xca, 0xf0,
+  0xa7, 0x15, 0x89, 0x60, 0xa8, 0x33, 0xac, 0xf0, 0xa8, 0xfe, 0xa5, 0xe0,
+  0xaa, 0x13, 0x8e, 0xf0, 0xaa, 0xde, 0x87, 0xe0, 0xab, 0xf3, 0x70, 0xf0,
+  0xac, 0xbe, 0x69, 0xe0, 0xad, 0xd3, 0x52, 0xf0, 0xae, 0x9e, 0x4b, 0xe0,
+  0xaf, 0xb3, 0x34, 0xf0, 0xb0, 0x7e, 0x2d, 0xe0, 0xb1, 0x9c, 0x51, 0x70,
+  0xb2, 0x67, 0x4a, 0x60, 0xb3, 0x7c, 0x33, 0x70, 0xb4, 0x47, 0x2c, 0x60,
+  0xb5, 0x5c, 0x15, 0x70, 0xb6, 0x27, 0x0e, 0x60, 0xb7, 0x3b, 0xf7, 0x70,
+  0xb8, 0x06, 0xf0, 0x60, 0xb9, 0x1b, 0xd9, 0x70, 0xb9, 0xe6, 0xd2, 0x60,
+  0xbb, 0x04, 0xf5, 0xf0, 0xbb, 0xc6, 0xb4, 0x60, 0xbc, 0xe4, 0xd7, 0xf0,
+  0xbd, 0xaf, 0xd0, 0xe0, 0xbe, 0xc4, 0xb9, 0xf0, 0xbf, 0x8f, 0xb2, 0xe0,
+  0xc0, 0xa4, 0x9b, 0xf0, 0xc1, 0x6f, 0x94, 0xe0, 0xc2, 0x84, 0x7d, 0xf0,
+  0xc3, 0x4f, 0x76, 0xe0, 0xc4, 0x64, 0x5f, 0xf0, 0xc5, 0x2f, 0x58, 0xe0,
+  0xc6, 0x4d, 0x7c, 0x70, 0xc7, 0x0f, 0x3a, 0xe0, 0xc8, 0x2d, 0x5e, 0x70,
+  0xc8, 0xf8, 0x57, 0x60, 0xca, 0x0d, 0x40, 0x70, 0xca, 0xd8, 0x39, 0x60,
+  0xcb, 0x88, 0xf0, 0x70, 0xd2, 0x23, 0xf4, 0x70, 0xd2, 0x60, 0xfb, 0xe0,
+  0xd3, 0x75, 0xe4, 0xf0, 0xd4, 0x40, 0xdd, 0xe0, 0xd5, 0x55, 0xc6, 0xf0,
+  0xd6, 0x20, 0xbf, 0xe0, 0xd7, 0x35, 0xa8, 0xf0, 0xd8, 0x00, 0xa1, 0xe0,
+  0xd9, 0x15, 0x8a, 0xf0, 0xd9, 0xe0, 0x83, 0xe0, 0xda, 0xfe, 0xa7, 0x70,
+  0xdb, 0xc0, 0x65, 0xe0, 0xdc, 0xde, 0x89, 0x70, 0xdd, 0xa9, 0x82, 0x60,
+  0xde, 0xbe, 0x6b, 0x70, 0xdf, 0x89, 0x64, 0x60, 0xe0, 0x9e, 0x4d, 0x70,
+  0xe1, 0x69, 0x46, 0x60, 0xe2, 0x7e, 0x2f, 0x70, 0xe3, 0x49, 0x28, 0x60,
+  0xe4, 0x5e, 0x11, 0x70, 0xe5, 0x57, 0x2e, 0xe0, 0xe6, 0x47, 0x2d, 0xf0,
+  0xe7, 0x37, 0x10, 0xe0, 0xe8, 0x27, 0x0f, 0xf0, 0xe9, 0x16, 0xf2, 0xe0,
+  0xea, 0x06, 0xf1, 0xf0, 0xea, 0xf6, 0xd4, 0xe0, 0xeb, 0xe6, 0xd3, 0xf0,
+  0xec, 0xd6, 0xb6, 0xe0, 0xed, 0xc6, 0xb5, 0xf0, 0xee, 0xbf, 0xd3, 0x60,
+  0xef, 0xaf, 0xd2, 0x70, 0xf0, 0x9f, 0xb5, 0x60, 0xf1, 0x8f, 0xb4, 0x70,
+  0xf2, 0x7f, 0x97, 0x60, 0xf3, 0x6f, 0x96, 0x70, 0xf4, 0x5f, 0x79, 0x60,
+  0xf5, 0x4f, 0x78, 0x70, 0xf6, 0x3f, 0x5b, 0x60, 0xf7, 0x2f, 0x5a, 0x70,
+  0xf8, 0x28, 0x77, 0xe0, 0xf9, 0x0f, 0x3c, 0x70, 0xfa, 0x08, 0x59, 0xe0,
+  0xfa, 0xf8, 0x58, 0xf0, 0xfb, 0xe8, 0x3b, 0xe0, 0xfc, 0xd8, 0x3a, 0xf0,
+  0xfd, 0xc8, 0x1d, 0xe0, 0xfe, 0xb8, 0x1c, 0xf0, 0xff, 0xa7, 0xff, 0xe0,
+  0x00, 0x97, 0xfe, 0xf0, 0x01, 0x87, 0xe1, 0xe0, 0x02, 0x77, 0xe0, 0xf0,
+  0x03, 0x70, 0xfe, 0x60, 0x04, 0x60, 0xfd, 0x70, 0x05, 0x50, 0xe0, 0x60,
+  0x06, 0x40, 0xdf, 0x70, 0x07, 0x30, 0xc2, 0x60, 0x07, 0x8d, 0x19, 0x70,
+  0x09, 0x10, 0xa4, 0x60, 0x09, 0xad, 0x94, 0xf0, 0x0a, 0xf0, 0x86, 0x60,
+  0x0b, 0xe0, 0x85, 0x70, 0x0c, 0xd9, 0xa2, 0xe0, 0x0d, 0xc0, 0x67, 0x70,
+  0x0e, 0xb9, 0x84, 0xe0, 0x0f, 0xa9, 0x83, 0xf0, 0x10, 0x99, 0x66, 0xe0,
+  0x11, 0x89, 0x65, 0xf0, 0x12, 0x79, 0x48, 0xe0, 0x13, 0x69, 0x47, 0xf0,
+  0x14, 0x59, 0x2a, 0xe0, 0x15, 0x49, 0x29, 0xf0, 0x16, 0x39, 0x0c, 0xe0,
+  0x17, 0x29, 0x0b, 0xf0, 0x18, 0x22, 0x29, 0x60, 0x19, 0x08, 0xed, 0xf0,
+  0x1a, 0x02, 0x0b, 0x60, 0x1a, 0xf2, 0x0a, 0x70, 0x1b, 0xe1, 0xed, 0x60,
+  0x1c, 0xd1, 0xec, 0x70, 0x1d, 0xc1, 0xcf, 0x60, 0x1e, 0xb1, 0xce, 0x70,
+  0x1f, 0xa1, 0xb1, 0x60, 0x20, 0x76, 0x00, 0xf0, 0x21, 0x81, 0x93, 0x60,
+  0x22, 0x55, 0xe2, 0xf0, 0x23, 0x6a, 0xaf, 0xe0, 0x24, 0x35, 0xc4, 0xf0,
+  0x25, 0x4a, 0x91, 0xe0, 0x26, 0x15, 0xa6, 0xf0, 0x27, 0x2a, 0x73, 0xe0,
+  0x27, 0xfe, 0xc3, 0x70, 0x29, 0x0a, 0x55, 0xe0, 0x29, 0xde, 0xa5, 0x70,
+  0x2a, 0xea, 0x37, 0xe0, 0x2b, 0xbe, 0x87, 0x70, 0x2c, 0xd3, 0x54, 0x60,
+  0x2d, 0x9e, 0x69, 0x70, 0x2e, 0xb3, 0x36, 0x60, 0x2f, 0x7e, 0x4b, 0x70,
+  0x30, 0x93, 0x18, 0x60, 0x31, 0x67, 0x67, 0xf0, 0x32, 0x72, 0xfa, 0x60,
+  0x33, 0x47, 0x49, 0xf0, 0x34, 0x52, 0xdc, 0x60, 0x35, 0x27, 0x2b, 0xf0,
+  0x36, 0x32, 0xbe, 0x60, 0x37, 0x07, 0x0d, 0xf0, 0x38, 0x1b, 0xda, 0xe0,
+  0x38, 0xe6, 0xef, 0xf0, 0x39, 0xfb, 0xbc, 0xe0, 0x3a, 0xc6, 0xd1, 0xf0,
+  0x3b, 0xdb, 0x9e, 0xe0, 0x3c, 0xaf, 0xee, 0x70, 0x3d, 0xbb, 0x80, 0xe0,
+  0x3e, 0x8f, 0xd0, 0x70, 0x3f, 0x9b, 0x62, 0xe0, 0x40, 0x6f, 0xb2, 0x70,
+  0x41, 0x84, 0x7f, 0x60, 0x42, 0x4f, 0x94, 0x70, 0x43, 0x64, 0x61, 0x60,
+  0x44, 0x2f, 0x76, 0x70, 0x45, 0x44, 0x43, 0x60, 0x45, 0xf3, 0xa8, 0xf0,
+  0x47, 0x2d, 0x5f, 0xe0, 0x47, 0xd3, 0x8a, 0xf0, 0x49, 0x0d, 0x41, 0xe0,
+  0x49, 0xb3, 0x6c, 0xf0, 0x4a, 0xed, 0x23, 0xe0, 0x4b, 0x9c, 0x89, 0x70,
+  0x4c, 0xd6, 0x40, 0x60, 0x4d, 0x7c, 0x6b, 0x70, 0x4e, 0xb6, 0x22, 0x60,
+  0x4f, 0x5c, 0x4d, 0x70, 0x50, 0x96, 0x04, 0x60, 0x51, 0x3c, 0x2f, 0x70,
+  0x52, 0x75, 0xe6, 0x60, 0x53, 0x1c, 0x11, 0x70, 0x54, 0x55, 0xc8, 0x60,
+  0x54, 0xfb, 0xf3, 0x70, 0x56, 0x35, 0xaa, 0x60, 0x56, 0xe5, 0x0f, 0xf0,
+  0x58, 0x1e, 0xc6, 0xe0, 0x58, 0xc4, 0xf1, 0xf0, 0x59, 0xfe, 0xa8, 0xe0,
+  0x5a, 0xa4, 0xd3, 0xf0, 0x5b, 0xde, 0x8a, 0xe0, 0x5c, 0x84, 0xb5, 0xf0,
+  0x5d, 0xbe, 0x6c, 0xe0, 0x5e, 0x64, 0x97, 0xf0, 0x5f, 0x9e, 0x4e, 0xe0,
+  0x60, 0x4d, 0xb4, 0x70, 0x61, 0x87, 0x6b, 0x60, 0x62, 0x2d, 0x96, 0x70,
+  0x63, 0x67, 0x4d, 0x60, 0x64, 0x0d, 0x78, 0x70, 0x65, 0x47, 0x2f, 0x60,
+  0x65, 0xed, 0x5a, 0x70, 0x67, 0x27, 0x11, 0x60, 0x67, 0xcd, 0x3c, 0x70,
+  0x69, 0x06, 0xf3, 0x60, 0x69, 0xad, 0x1e, 0x70, 0x6a, 0xe6, 0xd5, 0x60,
+  0x6b, 0x96, 0x3a, 0xf0, 0x6c, 0xcf, 0xf1, 0xe0, 0x6d, 0x76, 0x1c, 0xf0,
+  0x6e, 0xaf, 0xd3, 0xe0, 0x6f, 0x55, 0xfe, 0xf0, 0x70, 0x8f, 0xb5, 0xe0,
+  0x71, 0x35, 0xe0, 0xf0, 0x72, 0x6f, 0x97, 0xe0, 0x73, 0x15, 0xc2, 0xf0,
+  0x74, 0x4f, 0x79, 0xe0, 0x74, 0xfe, 0xdf, 0x70, 0x76, 0x38, 0x96, 0x60,
+  0x76, 0xde, 0xc1, 0x70, 0x78, 0x18, 0x78, 0x60, 0x78, 0xbe, 0xa3, 0x70,
+  0x79, 0xf8, 0x5a, 0x60, 0x7a, 0x9e, 0x85, 0x70, 0x7b, 0xd8, 0x3c, 0x60,
+  0x7c, 0x7e, 0x67, 0x70, 0x7d, 0xb8, 0x1e, 0x60, 0x7e, 0x5e, 0x49, 0x70,
+  0x7f, 0x98, 0x00, 0x60, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x03, 0x04, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0xff, 0xff, 0xba, 0x9e, 0x00, 0x00, 0xff, 0xff, 0xc7, 0xc0, 0x01, 0x04,
+  0xff, 0xff, 0xb9, 0xb0, 0x00, 0x08, 0xff, 0xff, 0xc7, 0xc0, 0x01, 0x0c,
+  0xff, 0xff, 0xc7, 0xc0, 0x01, 0x10, 0x4c, 0x4d, 0x54, 0x00, 0x45, 0x44,
+  0x54, 0x00, 0x45, 0x53, 0x54, 0x00, 0x45, 0x57, 0x54, 0x00, 0x45, 0x50,
+  0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01,
+  0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+  0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec,
+  0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff, 0xff,
+  0x5e, 0x03, 0xf0, 0x90, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xa6, 0x1e, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0x9f, 0xba, 0xeb, 0x60, 0xff, 0xff, 0xff, 0xff,
+  0xa0, 0x86, 0x00, 0x70, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x9a, 0xcd, 0x60,
+  0xff, 0xff, 0xff, 0xff, 0xa2, 0x65, 0xe2, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xa3, 0x83, 0xe9, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xa4, 0x6a, 0xae, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0xa5, 0x35, 0xa7, 0x60, 0xff, 0xff, 0xff, 0xff,
+  0xa6, 0x53, 0xca, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xa7, 0x15, 0x89, 0x60,
+  0xff, 0xff, 0xff, 0xff, 0xa8, 0x33, 0xac, 0xf0, 0xff, 0xff, 0xff, 0xff,
+  0xa8, 0xfe, 0xa5, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xaa, 0x13, 0x8e, 0xf0,
+  0xff, 0xff, 0xff, 0xff, 0xaa, 0xde, 0x87, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xab, 0xf3, 0x70, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbe, 0x69, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xad, 0xd3, 0x52, 0xf0, 0xff, 0xff, 0xff, 0xff,
+  0xae, 0x9e, 0x4b, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xb3, 0x34, 0xf0,
+  0xff, 0xff, 0xff, 0xff, 0xb0, 0x7e, 0x2d, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xb1, 0x9c, 0x51, 0x70, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x67, 0x4a, 0x60,
+  0xff, 0xff, 0xff, 0xff, 0xb3, 0x7c, 0x33, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xb4, 0x47, 0x2c, 0x60, 0xff, 0xff, 0xff, 0xff, 0xb5, 0x5c, 0x15, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0xb6, 0x27, 0x0e, 0x60, 0xff, 0xff, 0xff, 0xff,
+  0xb7, 0x3b, 0xf7, 0x70, 0xff, 0xff, 0xff, 0xff, 0xb8, 0x06, 0xf0, 0x60,
+  0xff, 0xff, 0xff, 0xff, 0xb9, 0x1b, 0xd9, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xb9, 0xe6, 0xd2, 0x60, 0xff, 0xff, 0xff, 0xff, 0xbb, 0x04, 0xf5, 0xf0,
+  0xff, 0xff, 0xff, 0xff, 0xbb, 0xc6, 0xb4, 0x60, 0xff, 0xff, 0xff, 0xff,
+  0xbc, 0xe4, 0xd7, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xbd, 0xaf, 0xd0, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xbe, 0xc4, 0xb9, 0xf0, 0xff, 0xff, 0xff, 0xff,
+  0xbf, 0x8f, 0xb2, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xc0, 0xa4, 0x9b, 0xf0,
+  0xff, 0xff, 0xff, 0xff, 0xc1, 0x6f, 0x94, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xc2, 0x84, 0x7d, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x4f, 0x76, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xc4, 0x64, 0x5f, 0xf0, 0xff, 0xff, 0xff, 0xff,
+  0xc5, 0x2f, 0x58, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x4d, 0x7c, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0xc7, 0x0f, 0x3a, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xc8, 0x2d, 0x5e, 0x70, 0xff, 0xff, 0xff, 0xff, 0xc8, 0xf8, 0x57, 0x60,
+  0xff, 0xff, 0xff, 0xff, 0xca, 0x0d, 0x40, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xca, 0xd8, 0x39, 0x60, 0xff, 0xff, 0xff, 0xff, 0xcb, 0x88, 0xf0, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0xd2, 0x23, 0xf4, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xd2, 0x60, 0xfb, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xd3, 0x75, 0xe4, 0xf0,
+  0xff, 0xff, 0xff, 0xff, 0xd4, 0x40, 0xdd, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xd5, 0x55, 0xc6, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x20, 0xbf, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xd7, 0x35, 0xa8, 0xf0, 0xff, 0xff, 0xff, 0xff,
+  0xd8, 0x00, 0xa1, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xd9, 0x15, 0x8a, 0xf0,
+  0xff, 0xff, 0xff, 0xff, 0xd9, 0xe0, 0x83, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xda, 0xfe, 0xa7, 0x70, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xc0, 0x65, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xdc, 0xde, 0x89, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xdd, 0xa9, 0x82, 0x60, 0xff, 0xff, 0xff, 0xff, 0xde, 0xbe, 0x6b, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0xdf, 0x89, 0x64, 0x60, 0xff, 0xff, 0xff, 0xff,
+  0xe0, 0x9e, 0x4d, 0x70, 0xff, 0xff, 0xff, 0xff, 0xe1, 0x69, 0x46, 0x60,
+  0xff, 0xff, 0xff, 0xff, 0xe2, 0x7e, 0x2f, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xe3, 0x49, 0x28, 0x60, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x5e, 0x11, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0xe5, 0x57, 0x2e, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xe6, 0x47, 0x2d, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x37, 0x10, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xe8, 0x27, 0x0f, 0xf0, 0xff, 0xff, 0xff, 0xff,
+  0xe9, 0x16, 0xf2, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xea, 0x06, 0xf1, 0xf0,
+  0xff, 0xff, 0xff, 0xff, 0xea, 0xf6, 0xd4, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xeb, 0xe6, 0xd3, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xec, 0xd6, 0xb6, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xed, 0xc6, 0xb5, 0xf0, 0xff, 0xff, 0xff, 0xff,
+  0xee, 0xbf, 0xd3, 0x60, 0xff, 0xff, 0xff, 0xff, 0xef, 0xaf, 0xd2, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0xf0, 0x9f, 0xb5, 0x60, 0xff, 0xff, 0xff, 0xff,
+  0xf1, 0x8f, 0xb4, 0x70, 0xff, 0xff, 0xff, 0xff, 0xf2, 0x7f, 0x97, 0x60,
+  0xff, 0xff, 0xff, 0xff, 0xf3, 0x6f, 0x96, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xf4, 0x5f, 0x79, 0x60, 0xff, 0xff, 0xff, 0xff, 0xf5, 0x4f, 0x78, 0x70,
+  0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f, 0x5b, 0x60, 0xff, 0xff, 0xff, 0xff,
+  0xf7, 0x2f, 0x5a, 0x70, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x28, 0x77, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xf9, 0x0f, 0x3c, 0x70, 0xff, 0xff, 0xff, 0xff,
+  0xfa, 0x08, 0x59, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xf8, 0x58, 0xf0,
+  0xff, 0xff, 0xff, 0xff, 0xfb, 0xe8, 0x3b, 0xe0, 0xff, 0xff, 0xff, 0xff,
+  0xfc, 0xd8, 0x3a, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xc8, 0x1d, 0xe0,
+  0xff, 0xff, 0xff, 0xff, 0xfe, 0xb8, 0x1c, 0xf0, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xa7, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x97, 0xfe, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x01, 0x87, 0xe1, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x02, 0x77, 0xe0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0x70, 0xfe, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x04, 0x60, 0xfd, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x05, 0x50, 0xe0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x06, 0x40, 0xdf, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x07, 0x30, 0xc2, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x07, 0x8d, 0x19, 0x70, 0x00, 0x00, 0x00, 0x00, 0x09, 0x10, 0xa4, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x09, 0xad, 0x94, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x0a, 0xf0, 0x86, 0x60, 0x00, 0x00, 0x00, 0x00, 0x0b, 0xe0, 0x85, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x0c, 0xd9, 0xa2, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x0d, 0xc0, 0x67, 0x70, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xb9, 0x84, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0xa9, 0x83, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x10, 0x99, 0x66, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x11, 0x89, 0x65, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x12, 0x79, 0x48, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x13, 0x69, 0x47, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x14, 0x59, 0x2a, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x15, 0x49, 0x29, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x16, 0x39, 0x0c, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x17, 0x29, 0x0b, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x18, 0x22, 0x29, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x19, 0x08, 0xed, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x02, 0x0b, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x1a, 0xf2, 0x0a, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x1b, 0xe1, 0xed, 0x60, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xd1, 0xec, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x1d, 0xc1, 0xcf, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x1e, 0xb1, 0xce, 0x70, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xa1, 0xb1, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x20, 0x76, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x21, 0x81, 0x93, 0x60, 0x00, 0x00, 0x00, 0x00, 0x22, 0x55, 0xe2, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x23, 0x6a, 0xaf, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x24, 0x35, 0xc4, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x25, 0x4a, 0x91, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x26, 0x15, 0xa6, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x27, 0x2a, 0x73, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x27, 0xfe, 0xc3, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x29, 0x0a, 0x55, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x29, 0xde, 0xa5, 0x70, 0x00, 0x00, 0x00, 0x00, 0x2a, 0xea, 0x37, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x2b, 0xbe, 0x87, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x2c, 0xd3, 0x54, 0x60, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x9e, 0x69, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x2e, 0xb3, 0x36, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x2f, 0x7e, 0x4b, 0x70, 0x00, 0x00, 0x00, 0x00, 0x30, 0x93, 0x18, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x31, 0x67, 0x67, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x32, 0x72, 0xfa, 0x60, 0x00, 0x00, 0x00, 0x00, 0x33, 0x47, 0x49, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x34, 0x52, 0xdc, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x35, 0x27, 0x2b, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x36, 0x32, 0xbe, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x37, 0x07, 0x0d, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x38, 0x1b, 0xda, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x38, 0xe6, 0xef, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x39, 0xfb, 0xbc, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x3a, 0xc6, 0xd1, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x3b, 0xdb, 0x9e, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x3c, 0xaf, 0xee, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x3d, 0xbb, 0x80, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x8f, 0xd0, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x3f, 0x9b, 0x62, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x40, 0x6f, 0xb2, 0x70, 0x00, 0x00, 0x00, 0x00, 0x41, 0x84, 0x7f, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x42, 0x4f, 0x94, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x43, 0x64, 0x61, 0x60, 0x00, 0x00, 0x00, 0x00, 0x44, 0x2f, 0x76, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x45, 0x44, 0x43, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x45, 0xf3, 0xa8, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x47, 0x2d, 0x5f, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x47, 0xd3, 0x8a, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x49, 0x0d, 0x41, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x49, 0xb3, 0x6c, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x4a, 0xed, 0x23, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x4b, 0x9c, 0x89, 0x70, 0x00, 0x00, 0x00, 0x00, 0x4c, 0xd6, 0x40, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x4d, 0x7c, 0x6b, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x4e, 0xb6, 0x22, 0x60, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x5c, 0x4d, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x50, 0x96, 0x04, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x51, 0x3c, 0x2f, 0x70, 0x00, 0x00, 0x00, 0x00, 0x52, 0x75, 0xe6, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x53, 0x1c, 0x11, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x54, 0x55, 0xc8, 0x60, 0x00, 0x00, 0x00, 0x00, 0x54, 0xfb, 0xf3, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x56, 0x35, 0xaa, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x56, 0xe5, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x58, 0x1e, 0xc6, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x58, 0xc4, 0xf1, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x59, 0xfe, 0xa8, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x5a, 0xa4, 0xd3, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x5b, 0xde, 0x8a, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x5c, 0x84, 0xb5, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x5d, 0xbe, 0x6c, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x5e, 0x64, 0x97, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x5f, 0x9e, 0x4e, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x60, 0x4d, 0xb4, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x61, 0x87, 0x6b, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x62, 0x2d, 0x96, 0x70, 0x00, 0x00, 0x00, 0x00, 0x63, 0x67, 0x4d, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x64, 0x0d, 0x78, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x65, 0x47, 0x2f, 0x60, 0x00, 0x00, 0x00, 0x00, 0x65, 0xed, 0x5a, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x67, 0x27, 0x11, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x67, 0xcd, 0x3c, 0x70, 0x00, 0x00, 0x00, 0x00, 0x69, 0x06, 0xf3, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x69, 0xad, 0x1e, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x6a, 0xe6, 0xd5, 0x60, 0x00, 0x00, 0x00, 0x00, 0x6b, 0x96, 0x3a, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x6c, 0xcf, 0xf1, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x6d, 0x76, 0x1c, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x6e, 0xaf, 0xd3, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x6f, 0x55, 0xfe, 0xf0, 0x00, 0x00, 0x00, 0x00,
+  0x70, 0x8f, 0xb5, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x71, 0x35, 0xe0, 0xf0,
+  0x00, 0x00, 0x00, 0x00, 0x72, 0x6f, 0x97, 0xe0, 0x00, 0x00, 0x00, 0x00,
+  0x73, 0x15, 0xc2, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x74, 0x4f, 0x79, 0xe0,
+  0x00, 0x00, 0x00, 0x00, 0x74, 0xfe, 0xdf, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x76, 0x38, 0x96, 0x60, 0x00, 0x00, 0x00, 0x00, 0x76, 0xde, 0xc1, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x78, 0x18, 0x78, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x78, 0xbe, 0xa3, 0x70, 0x00, 0x00, 0x00, 0x00, 0x79, 0xf8, 0x5a, 0x60,
+  0x00, 0x00, 0x00, 0x00, 0x7a, 0x9e, 0x85, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x7b, 0xd8, 0x3c, 0x60, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x7e, 0x67, 0x70,
+  0x00, 0x00, 0x00, 0x00, 0x7d, 0xb8, 0x1e, 0x60, 0x00, 0x00, 0x00, 0x00,
+  0x7e, 0x5e, 0x49, 0x70, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x98, 0x00, 0x60,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x03, 0x04, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+  0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0xff, 0xff, 0xba, 0x9e,
+  0x00, 0x00, 0xff, 0xff, 0xc7, 0xc0, 0x01, 0x04, 0xff, 0xff, 0xb9, 0xb0,
+  0x00, 0x08, 0xff, 0xff, 0xc7, 0xc0, 0x01, 0x0c, 0xff, 0xff, 0xc7, 0xc0,
+  0x01, 0x10, 0x4c, 0x4d, 0x54, 0x00, 0x45, 0x44, 0x54, 0x00, 0x45, 0x53,
+  0x54, 0x00, 0x45, 0x57, 0x54, 0x00, 0x45, 0x50, 0x54, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0a, 0x45, 0x53, 0x54,
+  0x35, 0x45, 0x44, 0x54, 0x2c, 0x4d, 0x33, 0x2e, 0x32, 0x2e, 0x30, 0x2c,
+  0x4d, 0x31, 0x31, 0x2e, 0x31, 0x2e, 0x30, 0x0a
+};
+unsigned int America_New_York_len = 3536;
+unsigned char Australia_Sydney[] = {
+  0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8e,
+  0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e, 0x80, 0x00, 0x00, 0x00,
+  0x9c, 0x4e, 0xc2, 0x80, 0x9c, 0xbc, 0x2f, 0x00, 0xcb, 0x54, 0xb3, 0x00,
+  0xcb, 0xc7, 0x65, 0x80, 0xcc, 0xb7, 0x56, 0x80, 0xcd, 0xa7, 0x47, 0x80,
+  0xce, 0xa0, 0x73, 0x00, 0xcf, 0x87, 0x29, 0x80, 0x03, 0x70, 0x39, 0x80,
+  0x04, 0x0d, 0x1c, 0x00, 0x05, 0x50, 0x1b, 0x80, 0x05, 0xf6, 0x38, 0x80,
+  0x07, 0x2f, 0xfd, 0x80, 0x07, 0xd6, 0x1a, 0x80, 0x09, 0x0f, 0xdf, 0x80,
+  0x09, 0xb5, 0xfc, 0x80, 0x0a, 0xef, 0xc1, 0x80, 0x0b, 0x9f, 0x19, 0x00,
+  0x0c, 0xd8, 0xde, 0x00, 0x0d, 0x7e, 0xfb, 0x00, 0x0e, 0xb8, 0xc0, 0x00,
+  0x0f, 0x5e, 0xdd, 0x00, 0x10, 0x98, 0xa2, 0x00, 0x11, 0x3e, 0xbf, 0x00,
+  0x12, 0x78, 0x84, 0x00, 0x13, 0x1e, 0xa1, 0x00, 0x14, 0x58, 0x66, 0x00,
+  0x14, 0xfe, 0x83, 0x00, 0x16, 0x38, 0x48, 0x00, 0x17, 0x0c, 0x89, 0x80,
+  0x18, 0x21, 0x64, 0x80, 0x18, 0xc7, 0x81, 0x80, 0x1a, 0x01, 0x46, 0x80,
+  0x1a, 0xa7, 0x63, 0x80, 0x1b, 0xe1, 0x28, 0x80, 0x1c, 0x87, 0x45, 0x80,
+  0x1d, 0xc1, 0x0a, 0x80, 0x1e, 0x79, 0x9c, 0x80, 0x1f, 0x97, 0xb2, 0x00,
+  0x20, 0x59, 0x7e, 0x80, 0x21, 0x80, 0xce, 0x80, 0x22, 0x42, 0x9b, 0x00,
+  0x23, 0x69, 0xeb, 0x00, 0x24, 0x22, 0x7d, 0x00, 0x25, 0x49, 0xcd, 0x00,
+  0x25, 0xef, 0xea, 0x00, 0x27, 0x29, 0xaf, 0x00, 0x27, 0xcf, 0xcc, 0x00,
+  0x29, 0x09, 0x91, 0x00, 0x29, 0xaf, 0xae, 0x00, 0x2a, 0xe9, 0x73, 0x00,
+  0x2b, 0x98, 0xca, 0x80, 0x2c, 0xd2, 0x8f, 0x80, 0x2d, 0x78, 0xac, 0x80,
+  0x2e, 0xb2, 0x71, 0x80, 0x2f, 0x58, 0x8e, 0x80, 0x30, 0x92, 0x53, 0x80,
+  0x31, 0x5d, 0x5a, 0x80, 0x32, 0x72, 0x35, 0x80, 0x33, 0x3d, 0x3c, 0x80,
+  0x34, 0x52, 0x17, 0x80, 0x35, 0x1d, 0x1e, 0x80, 0x36, 0x31, 0xf9, 0x80,
+  0x36, 0xfd, 0x00, 0x80, 0x38, 0x1b, 0x16, 0x00, 0x38, 0xdc, 0xe2, 0x80,
+  0x39, 0xa7, 0xe9, 0x80, 0x3a, 0xbc, 0xc4, 0x80, 0x3b, 0xda, 0xda, 0x00,
+  0x3c, 0xa5, 0xe1, 0x00, 0x3d, 0xba, 0xbc, 0x00, 0x3e, 0x85, 0xc3, 0x00,
+  0x3f, 0x9a, 0x9e, 0x00, 0x40, 0x65, 0xa5, 0x00, 0x41, 0x83, 0xba, 0x80,
+  0x42, 0x45, 0x87, 0x00, 0x43, 0x63, 0x9c, 0x80, 0x44, 0x2e, 0xa3, 0x80,
+  0x45, 0x43, 0x7e, 0x80, 0x46, 0x05, 0x4b, 0x00, 0x47, 0x23, 0x60, 0x80,
+  0x47, 0xf7, 0xa2, 0x00, 0x48, 0xe7, 0x93, 0x00, 0x49, 0xd7, 0x84, 0x00,
+  0x4a, 0xc7, 0x75, 0x00, 0x4b, 0xb7, 0x66, 0x00, 0x4c, 0xa7, 0x57, 0x00,
+  0x4d, 0x97, 0x48, 0x00, 0x4e, 0x87, 0x39, 0x00, 0x4f, 0x77, 0x2a, 0x00,
+  0x50, 0x70, 0x55, 0x80, 0x51, 0x60, 0x46, 0x80, 0x52, 0x50, 0x37, 0x80,
+  0x53, 0x40, 0x28, 0x80, 0x54, 0x30, 0x19, 0x80, 0x55, 0x20, 0x0a, 0x80,
+  0x56, 0x0f, 0xfb, 0x80, 0x56, 0xff, 0xec, 0x80, 0x57, 0xef, 0xdd, 0x80,
+  0x58, 0xdf, 0xce, 0x80, 0x59, 0xcf, 0xbf, 0x80, 0x5a, 0xbf, 0xb0, 0x80,
+  0x5b, 0xb8, 0xdc, 0x00, 0x5c, 0xa8, 0xcd, 0x00, 0x5d, 0x98, 0xbe, 0x00,
+  0x5e, 0x88, 0xaf, 0x00, 0x5f, 0x78, 0xa0, 0x00, 0x60, 0x68, 0x91, 0x00,
+  0x61, 0x58, 0x82, 0x00, 0x62, 0x48, 0x73, 0x00, 0x63, 0x38, 0x64, 0x00,
+  0x64, 0x28, 0x55, 0x00, 0x65, 0x18, 0x46, 0x00, 0x66, 0x11, 0x71, 0x80,
+  0x67, 0x01, 0x62, 0x80, 0x67, 0xf1, 0x53, 0x80, 0x68, 0xe1, 0x44, 0x80,
+  0x69, 0xd1, 0x35, 0x80, 0x6a, 0xc1, 0x26, 0x80, 0x6b, 0xb1, 0x17, 0x80,
+  0x6c, 0xa1, 0x08, 0x80, 0x6d, 0x90, 0xf9, 0x80, 0x6e, 0x80, 0xea, 0x80,
+  0x6f, 0x70, 0xdb, 0x80, 0x70, 0x6a, 0x07, 0x00, 0x71, 0x59, 0xf8, 0x00,
+  0x72, 0x49, 0xe9, 0x00, 0x73, 0x39, 0xda, 0x00, 0x74, 0x29, 0xcb, 0x00,
+  0x75, 0x19, 0xbc, 0x00, 0x76, 0x09, 0xad, 0x00, 0x76, 0xf9, 0x9e, 0x00,
+  0x77, 0xe9, 0x8f, 0x00, 0x78, 0xd9, 0x80, 0x00, 0x79, 0xc9, 0x71, 0x00,
+  0x7a, 0xb9, 0x62, 0x00, 0x7b, 0xb2, 0x8d, 0x80, 0x7c, 0xa2, 0x7e, 0x80,
+  0x7d, 0x92, 0x6f, 0x80, 0x7e, 0x82, 0x60, 0x80, 0x7f, 0x72, 0x51, 0x80,
+  0x03, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x00, 0x00,
+  0x8d, 0xc4, 0x00, 0x00, 0x00, 0x00, 0x9a, 0xb0, 0x01, 0x04, 0x00, 0x00,
+  0x8c, 0xa0, 0x00, 0x09, 0x00, 0x00, 0x8c, 0xa0, 0x00, 0x09, 0x4c, 0x4d,
+  0x54, 0x00, 0x41, 0x45, 0x44, 0x54, 0x00, 0x41, 0x45, 0x53, 0x54, 0x00,
+  0x00, 0x01, 0x01, 0x00, 0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e,
+  0xff, 0xff, 0xff, 0xff, 0x73, 0x16, 0x7f, 0x3c, 0xff, 0xff, 0xff, 0xff,
+  0x9c, 0x4e, 0xc2, 0x80, 0xff, 0xff, 0xff, 0xff, 0x9c, 0xbc, 0x2f, 0x00,
+  0xff, 0xff, 0xff, 0xff, 0xcb, 0x54, 0xb3, 0x00, 0xff, 0xff, 0xff, 0xff,
+  0xcb, 0xc7, 0x65, 0x80, 0xff, 0xff, 0xff, 0xff, 0xcc, 0xb7, 0x56, 0x80,
+  0xff, 0xff, 0xff, 0xff, 0xcd, 0xa7, 0x47, 0x80, 0xff, 0xff, 0xff, 0xff,
+  0xce, 0xa0, 0x73, 0x00, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x87, 0x29, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x03, 0x70, 0x39, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x04, 0x0d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x50, 0x1b, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x05, 0xf6, 0x38, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x07, 0x2f, 0xfd, 0x80, 0x00, 0x00, 0x00, 0x00, 0x07, 0xd6, 0x1a, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x09, 0x0f, 0xdf, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x09, 0xb5, 0xfc, 0x80, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xef, 0xc1, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x0b, 0x9f, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0c, 0xd8, 0xde, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x7e, 0xfb, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0e, 0xb8, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x5e, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x98, 0xa2, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x11, 0x3e, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x12, 0x78, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x1e, 0xa1, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x14, 0x58, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x14, 0xfe, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x38, 0x48, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x17, 0x0c, 0x89, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x18, 0x21, 0x64, 0x80, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc7, 0x81, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x1a, 0x01, 0x46, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x1a, 0xa7, 0x63, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1b, 0xe1, 0x28, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x1c, 0x87, 0x45, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x1d, 0xc1, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x79, 0x9c, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x1f, 0x97, 0xb2, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x20, 0x59, 0x7e, 0x80, 0x00, 0x00, 0x00, 0x00, 0x21, 0x80, 0xce, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x22, 0x42, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x23, 0x69, 0xeb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x22, 0x7d, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x25, 0x49, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x25, 0xef, 0xea, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x29, 0xaf, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x27, 0xcf, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x29, 0x09, 0x91, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0xaf, 0xae, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x2a, 0xe9, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x2b, 0x98, 0xca, 0x80, 0x00, 0x00, 0x00, 0x00, 0x2c, 0xd2, 0x8f, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x2d, 0x78, 0xac, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x2e, 0xb2, 0x71, 0x80, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x58, 0x8e, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x30, 0x92, 0x53, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x31, 0x5d, 0x5a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x32, 0x72, 0x35, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x33, 0x3d, 0x3c, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x34, 0x52, 0x17, 0x80, 0x00, 0x00, 0x00, 0x00, 0x35, 0x1d, 0x1e, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x36, 0x31, 0xf9, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x36, 0xfd, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x38, 0x1b, 0x16, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x38, 0xdc, 0xe2, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x39, 0xa7, 0xe9, 0x80, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xbc, 0xc4, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x3b, 0xda, 0xda, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3c, 0xa5, 0xe1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0xba, 0xbc, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x3e, 0x85, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3f, 0x9a, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x65, 0xa5, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x41, 0x83, 0xba, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x42, 0x45, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x63, 0x9c, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x44, 0x2e, 0xa3, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x45, 0x43, 0x7e, 0x80, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x4b, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x47, 0x23, 0x60, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x47, 0xf7, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0xe7, 0x93, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x49, 0xd7, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x4a, 0xc7, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4b, 0xb7, 0x66, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x4c, 0xa7, 0x57, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x4d, 0x97, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 0x87, 0x39, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x4f, 0x77, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x50, 0x70, 0x55, 0x80, 0x00, 0x00, 0x00, 0x00, 0x51, 0x60, 0x46, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x52, 0x50, 0x37, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x53, 0x40, 0x28, 0x80, 0x00, 0x00, 0x00, 0x00, 0x54, 0x30, 0x19, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x55, 0x20, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x56, 0x0f, 0xfb, 0x80, 0x00, 0x00, 0x00, 0x00, 0x56, 0xff, 0xec, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x57, 0xef, 0xdd, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x58, 0xdf, 0xce, 0x80, 0x00, 0x00, 0x00, 0x00, 0x59, 0xcf, 0xbf, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x5a, 0xbf, 0xb0, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x5b, 0xb8, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xa8, 0xcd, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x5d, 0x98, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x5e, 0x88, 0xaf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x78, 0xa0, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x60, 0x68, 0x91, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x61, 0x58, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x48, 0x73, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x63, 0x38, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x64, 0x28, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x18, 0x46, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x66, 0x11, 0x71, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x67, 0x01, 0x62, 0x80, 0x00, 0x00, 0x00, 0x00, 0x67, 0xf1, 0x53, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x68, 0xe1, 0x44, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x69, 0xd1, 0x35, 0x80, 0x00, 0x00, 0x00, 0x00, 0x6a, 0xc1, 0x26, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x6b, 0xb1, 0x17, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x6c, 0xa1, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x90, 0xf9, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x6e, 0x80, 0xea, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x6f, 0x70, 0xdb, 0x80, 0x00, 0x00, 0x00, 0x00, 0x70, 0x6a, 0x07, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x71, 0x59, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x72, 0x49, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73, 0x39, 0xda, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x74, 0x29, 0xcb, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x75, 0x19, 0xbc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x09, 0xad, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x76, 0xf9, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x77, 0xe9, 0x8f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xd9, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x79, 0xc9, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x7a, 0xb9, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7b, 0xb2, 0x8d, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x7c, 0xa2, 0x7e, 0x80, 0x00, 0x00, 0x00, 0x00,
+  0x7d, 0x92, 0x6f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x82, 0x60, 0x80,
+  0x00, 0x00, 0x00, 0x00, 0x7f, 0x72, 0x51, 0x80, 0x03, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+  0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x00, 0x00, 0x8d, 0xc4, 0x00, 0x00,
+  0x00, 0x00, 0x9a, 0xb0, 0x01, 0x04, 0x00, 0x00, 0x8c, 0xa0, 0x00, 0x09,
+  0x00, 0x00, 0x8c, 0xa0, 0x00, 0x09, 0x4c, 0x4d, 0x54, 0x00, 0x41, 0x45,
+  0x44, 0x54, 0x00, 0x41, 0x45, 0x53, 0x54, 0x00, 0x00, 0x01, 0x01, 0x00,
+  0x0a, 0x41, 0x45, 0x53, 0x54, 0x2d, 0x31, 0x30, 0x41, 0x45, 0x44, 0x54,
+  0x2c, 0x4d, 0x31, 0x30, 0x2e, 0x31, 0x2e, 0x30, 0x2c, 0x4d, 0x34, 0x2e,
+  0x31, 0x2e, 0x30, 0x2f, 0x33, 0x0a
+};
+unsigned int Australia_Sydney_len = 2190;
diff --git a/CAPI/cpp/grpc/include/absl/time/time.h b/CAPI/cpp/grpc/include/absl/time/time.h
new file mode 100644
index 0000000..bd01867
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/time/time.h
@@ -0,0 +1,1620 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: time.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines abstractions for computing with absolute points
+// in time, durations of time, and formatting and parsing time within a given
+// time zone. The following abstractions are defined:
+//
+//  * `absl::Time` defines an absolute, specific instance in time
+//  * `absl::Duration` defines a signed, fixed-length span of time
+//  * `absl::TimeZone` defines geopolitical time zone regions (as collected
+//     within the IANA Time Zone database (https://www.iana.org/time-zones)).
+//
+// Note: Absolute times are distinct from civil times, which refer to the
+// human-scale time commonly represented by `YYYY-MM-DD hh:mm:ss`. The mapping
+// between absolute and civil times can be specified by use of time zones
+// (`absl::TimeZone` within this API). That is:
+//
+//   Civil Time = F(Absolute Time, Time Zone)
+//   Absolute Time = G(Civil Time, Time Zone)
+//
+// See civil_time.h for abstractions related to constructing and manipulating
+// civil time.
+//
+// Example:
+//
+//   absl::TimeZone nyc;
+//   // LoadTimeZone() may fail so it's always better to check for success.
+//   if (!absl::LoadTimeZone("America/New_York", &nyc)) {
+//      // handle error case
+//   }
+//
+//   // My flight leaves NYC on Jan 2, 2017 at 03:04:05
+//   absl::CivilSecond cs(2017, 1, 2, 3, 4, 5);
+//   absl::Time takeoff = absl::FromCivil(cs, nyc);
+//
+//   absl::Duration flight_duration = absl::Hours(21) + absl::Minutes(35);
+//   absl::Time landing = takeoff + flight_duration;
+//
+//   absl::TimeZone syd;
+//   if (!absl::LoadTimeZone("Australia/Sydney", &syd)) {
+//      // handle error case
+//   }
+//   std::string s = absl::FormatTime(
+//       "My flight will land in Sydney on %Y-%m-%d at %H:%M:%S",
+//       landing, syd);
+
+#ifndef ABSL_TIME_TIME_H_
+#define ABSL_TIME_TIME_H_
+
+#if !defined(_MSC_VER)
+#include <sys/time.h>
+#else
+// We don't include `winsock2.h` because it drags in `windows.h` and friends,
+// and they define conflicting macros like OPAQUE, ERROR, and more. This has the
+// potential to break Abseil users.
+//
+// Instead we only forward declare `timeval` and require Windows users include
+// `winsock2.h` themselves. This is both inconsistent and troublesome, but so is
+// including 'windows.h' so we are picking the lesser of two evils here.
+struct timeval;
+#endif
+#include <chrono>  // NOLINT(build/c++11)
+#include <cmath>
+#include <cstdint>
+#include <ctime>
+#include <ostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class Duration;  // Defined below
+class Time;      // Defined below
+class TimeZone;  // Defined below
+
+namespace time_internal {
+int64_t IDivDuration(bool satq, Duration num, Duration den, Duration* rem);
+constexpr Time FromUnixDuration(Duration d);
+constexpr Duration ToUnixDuration(Time t);
+constexpr int64_t GetRepHi(Duration d);
+constexpr uint32_t GetRepLo(Duration d);
+constexpr Duration MakeDuration(int64_t hi, uint32_t lo);
+constexpr Duration MakeDuration(int64_t hi, int64_t lo);
+inline Duration MakePosDoubleDuration(double n);
+constexpr int64_t kTicksPerNanosecond = 4;
+constexpr int64_t kTicksPerSecond = 1000 * 1000 * 1000 * kTicksPerNanosecond;
+template <std::intmax_t N>
+constexpr Duration FromInt64(int64_t v, std::ratio<1, N>);
+constexpr Duration FromInt64(int64_t v, std::ratio<60>);
+constexpr Duration FromInt64(int64_t v, std::ratio<3600>);
+template <typename T>
+using EnableIfIntegral = typename std::enable_if<
+    std::is_integral<T>::value || std::is_enum<T>::value, int>::type;
+template <typename T>
+using EnableIfFloat =
+    typename std::enable_if<std::is_floating_point<T>::value, int>::type;
+}  // namespace time_internal
+
+// Duration
+//
+// The `absl::Duration` class represents a signed, fixed-length amount of time.
+// A `Duration` is generated using a unit-specific factory function, or is
+// the result of subtracting one `absl::Time` from another. Durations behave
+// like unit-safe integers and they support all the natural integer-like
+// arithmetic operations. Arithmetic overflows and saturates at +/- infinity.
+// `Duration` should be passed by value rather than const reference.
+//
+// Factory functions `Nanoseconds()`, `Microseconds()`, `Milliseconds()`,
+// `Seconds()`, `Minutes()`, `Hours()` and `InfiniteDuration()` allow for
+// creation of constexpr `Duration` values
+//
+// Examples:
+//
+//   constexpr absl::Duration ten_ns = absl::Nanoseconds(10);
+//   constexpr absl::Duration min = absl::Minutes(1);
+//   constexpr absl::Duration hour = absl::Hours(1);
+//   absl::Duration dur = 60 * min;  // dur == hour
+//   absl::Duration half_sec = absl::Milliseconds(500);
+//   absl::Duration quarter_sec = 0.25 * absl::Seconds(1);
+//
+// `Duration` values can be easily converted to an integral number of units
+// using the division operator.
+//
+// Example:
+//
+//   constexpr absl::Duration dur = absl::Milliseconds(1500);
+//   int64_t ns = dur / absl::Nanoseconds(1);   // ns == 1500000000
+//   int64_t ms = dur / absl::Milliseconds(1);  // ms == 1500
+//   int64_t sec = dur / absl::Seconds(1);    // sec == 1 (subseconds truncated)
+//   int64_t min = dur / absl::Minutes(1);    // min == 0
+//
+// See the `IDivDuration()` and `FDivDuration()` functions below for details on
+// how to access the fractional parts of the quotient.
+//
+// Alternatively, conversions can be performed using helpers such as
+// `ToInt64Microseconds()` and `ToDoubleSeconds()`.
+class Duration {
+ public:
+  // Value semantics.
+  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
+
+  // Copyable.
+#if !defined(__clang__) && defined(_MSC_VER) && _MSC_VER < 1930
+  // Explicitly defining the constexpr copy constructor avoids an MSVC bug.
+  constexpr Duration(const Duration& d)
+      : rep_hi_(d.rep_hi_), rep_lo_(d.rep_lo_) {}
+#else
+  constexpr Duration(const Duration& d) = default;
+#endif
+  Duration& operator=(const Duration& d) = default;
+
+  // Compound assignment operators.
+  Duration& operator+=(Duration d);
+  Duration& operator-=(Duration d);
+  Duration& operator*=(int64_t r);
+  Duration& operator*=(double r);
+  Duration& operator/=(int64_t r);
+  Duration& operator/=(double r);
+  Duration& operator%=(Duration rhs);
+
+  // Overloads that forward to either the int64_t or double overloads above.
+  // Integer operands must be representable as int64_t.
+  template <typename T, time_internal::EnableIfIntegral<T> = 0>
+  Duration& operator*=(T r) {
+    int64_t x = r;
+    return *this *= x;
+  }
+
+  template <typename T, time_internal::EnableIfIntegral<T> = 0>
+  Duration& operator/=(T r) {
+    int64_t x = r;
+    return *this /= x;
+  }
+
+  template <typename T, time_internal::EnableIfFloat<T> = 0>
+  Duration& operator*=(T r) {
+    double x = r;
+    return *this *= x;
+  }
+
+  template <typename T, time_internal::EnableIfFloat<T> = 0>
+  Duration& operator/=(T r) {
+    double x = r;
+    return *this /= x;
+  }
+
+  template <typename H>
+  friend H AbslHashValue(H h, Duration d) {
+    return H::combine(std::move(h), d.rep_hi_, d.rep_lo_);
+  }
+
+ private:
+  friend constexpr int64_t time_internal::GetRepHi(Duration d);
+  friend constexpr uint32_t time_internal::GetRepLo(Duration d);
+  friend constexpr Duration time_internal::MakeDuration(int64_t hi,
+                                                        uint32_t lo);
+  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
+  int64_t rep_hi_;
+  uint32_t rep_lo_;
+};
+
+// Relational Operators
+constexpr bool operator<(Duration lhs, Duration rhs);
+constexpr bool operator>(Duration lhs, Duration rhs) { return rhs < lhs; }
+constexpr bool operator>=(Duration lhs, Duration rhs) { return !(lhs < rhs); }
+constexpr bool operator<=(Duration lhs, Duration rhs) { return !(rhs < lhs); }
+constexpr bool operator==(Duration lhs, Duration rhs);
+constexpr bool operator!=(Duration lhs, Duration rhs) { return !(lhs == rhs); }
+
+// Additive Operators
+constexpr Duration operator-(Duration d);
+inline Duration operator+(Duration lhs, Duration rhs) { return lhs += rhs; }
+inline Duration operator-(Duration lhs, Duration rhs) { return lhs -= rhs; }
+
+// Multiplicative Operators
+// Integer operands must be representable as int64_t.
+template <typename T>
+Duration operator*(Duration lhs, T rhs) {
+  return lhs *= rhs;
+}
+template <typename T>
+Duration operator*(T lhs, Duration rhs) {
+  return rhs *= lhs;
+}
+template <typename T>
+Duration operator/(Duration lhs, T rhs) {
+  return lhs /= rhs;
+}
+inline int64_t operator/(Duration lhs, Duration rhs) {
+  return time_internal::IDivDuration(true, lhs, rhs,
+                                     &lhs);  // trunc towards zero
+}
+inline Duration operator%(Duration lhs, Duration rhs) { return lhs %= rhs; }
+
+// IDivDuration()
+//
+// Divides a numerator `Duration` by a denominator `Duration`, returning the
+// quotient and remainder. The remainder always has the same sign as the
+// numerator. The returned quotient and remainder respect the identity:
+//
+//   numerator = denominator * quotient + remainder
+//
+// Returned quotients are capped to the range of `int64_t`, with the difference
+// spilling into the remainder to uphold the above identity. This means that the
+// remainder returned could differ from the remainder returned by
+// `Duration::operator%` for huge quotients.
+//
+// See also the notes on `InfiniteDuration()` below regarding the behavior of
+// division involving zero and infinite durations.
+//
+// Example:
+//
+//   constexpr absl::Duration a =
+//       absl::Seconds(std::numeric_limits<int64_t>::max());  // big
+//   constexpr absl::Duration b = absl::Nanoseconds(1);       // small
+//
+//   absl::Duration rem = a % b;
+//   // rem == absl::ZeroDuration()
+//
+//   // Here, q would overflow int64_t, so rem accounts for the difference.
+//   int64_t q = absl::IDivDuration(a, b, &rem);
+//   // q == std::numeric_limits<int64_t>::max(), rem == a - b * q
+inline int64_t IDivDuration(Duration num, Duration den, Duration* rem) {
+  return time_internal::IDivDuration(true, num, den,
+                                     rem);  // trunc towards zero
+}
+
+// FDivDuration()
+//
+// Divides a `Duration` numerator into a fractional number of units of a
+// `Duration` denominator.
+//
+// See also the notes on `InfiniteDuration()` below regarding the behavior of
+// division involving zero and infinite durations.
+//
+// Example:
+//
+//   double d = absl::FDivDuration(absl::Milliseconds(1500), absl::Seconds(1));
+//   // d == 1.5
+double FDivDuration(Duration num, Duration den);
+
+// ZeroDuration()
+//
+// Returns a zero-length duration. This function behaves just like the default
+// constructor, but the name helps make the semantics clear at call sites.
+constexpr Duration ZeroDuration() { return Duration(); }
+
+// AbsDuration()
+//
+// Returns the absolute value of a duration.
+inline Duration AbsDuration(Duration d) {
+  return (d < ZeroDuration()) ? -d : d;
+}
+
+// Trunc()
+//
+// Truncates a duration (toward zero) to a multiple of a non-zero unit.
+//
+// Example:
+//
+//   absl::Duration d = absl::Nanoseconds(123456789);
+//   absl::Duration a = absl::Trunc(d, absl::Microseconds(1));  // 123456us
+Duration Trunc(Duration d, Duration unit);
+
+// Floor()
+//
+// Floors a duration using the passed duration unit to its largest value not
+// greater than the duration.
+//
+// Example:
+//
+//   absl::Duration d = absl::Nanoseconds(123456789);
+//   absl::Duration b = absl::Floor(d, absl::Microseconds(1));  // 123456us
+Duration Floor(Duration d, Duration unit);
+
+// Ceil()
+//
+// Returns the ceiling of a duration using the passed duration unit to its
+// smallest value not less than the duration.
+//
+// Example:
+//
+//   absl::Duration d = absl::Nanoseconds(123456789);
+//   absl::Duration c = absl::Ceil(d, absl::Microseconds(1));   // 123457us
+Duration Ceil(Duration d, Duration unit);
+
+// InfiniteDuration()
+//
+// Returns an infinite `Duration`.  To get a `Duration` representing negative
+// infinity, use `-InfiniteDuration()`.
+//
+// Duration arithmetic overflows to +/- infinity and saturates. In general,
+// arithmetic with `Duration` infinities is similar to IEEE 754 infinities
+// except where IEEE 754 NaN would be involved, in which case +/-
+// `InfiniteDuration()` is used in place of a "nan" Duration.
+//
+// Examples:
+//
+//   constexpr absl::Duration inf = absl::InfiniteDuration();
+//   const absl::Duration d = ... any finite duration ...
+//
+//   inf == inf + inf
+//   inf == inf + d
+//   inf == inf - inf
+//   -inf == d - inf
+//
+//   inf == d * 1e100
+//   inf == inf / 2
+//   0 == d / inf
+//   INT64_MAX == inf / d
+//
+//   d < inf
+//   -inf < d
+//
+//   // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
+//   inf == d / 0
+//   INT64_MAX == d / absl::ZeroDuration()
+//
+// The examples involving the `/` operator above also apply to `IDivDuration()`
+// and `FDivDuration()`.
+constexpr Duration InfiniteDuration();
+
+// Nanoseconds()
+// Microseconds()
+// Milliseconds()
+// Seconds()
+// Minutes()
+// Hours()
+//
+// Factory functions for constructing `Duration` values from an integral number
+// of the unit indicated by the factory function's name. The number must be
+// representable as int64_t.
+//
+// NOTE: no "Days()" factory function exists because "a day" is ambiguous.
+// Civil days are not always 24 hours long, and a 24-hour duration often does
+// not correspond with a civil day. If a 24-hour duration is needed, use
+// `absl::Hours(24)`. If you actually want a civil day, use absl::CivilDay
+// from civil_time.h.
+//
+// Example:
+//
+//   absl::Duration a = absl::Seconds(60);
+//   absl::Duration b = absl::Minutes(1);  // b == a
+template <typename T, time_internal::EnableIfIntegral<T> = 0>
+constexpr Duration Nanoseconds(T n) {
+  return time_internal::FromInt64(n, std::nano{});
+}
+template <typename T, time_internal::EnableIfIntegral<T> = 0>
+constexpr Duration Microseconds(T n) {
+  return time_internal::FromInt64(n, std::micro{});
+}
+template <typename T, time_internal::EnableIfIntegral<T> = 0>
+constexpr Duration Milliseconds(T n) {
+  return time_internal::FromInt64(n, std::milli{});
+}
+template <typename T, time_internal::EnableIfIntegral<T> = 0>
+constexpr Duration Seconds(T n) {
+  return time_internal::FromInt64(n, std::ratio<1>{});
+}
+template <typename T, time_internal::EnableIfIntegral<T> = 0>
+constexpr Duration Minutes(T n) {
+  return time_internal::FromInt64(n, std::ratio<60>{});
+}
+template <typename T, time_internal::EnableIfIntegral<T> = 0>
+constexpr Duration Hours(T n) {
+  return time_internal::FromInt64(n, std::ratio<3600>{});
+}
+
+// Factory overloads for constructing `Duration` values from a floating-point
+// number of the unit indicated by the factory function's name. These functions
+// exist for convenience, but they are not as efficient as the integral
+// factories, which should be preferred.
+//
+// Example:
+//
+//   auto a = absl::Seconds(1.5);        // OK
+//   auto b = absl::Milliseconds(1500);  // BETTER
+template <typename T, time_internal::EnableIfFloat<T> = 0>
+Duration Nanoseconds(T n) {
+  return n * Nanoseconds(1);
+}
+template <typename T, time_internal::EnableIfFloat<T> = 0>
+Duration Microseconds(T n) {
+  return n * Microseconds(1);
+}
+template <typename T, time_internal::EnableIfFloat<T> = 0>
+Duration Milliseconds(T n) {
+  return n * Milliseconds(1);
+}
+template <typename T, time_internal::EnableIfFloat<T> = 0>
+Duration Seconds(T n) {
+  if (n >= 0) {  // Note: `NaN >= 0` is false.
+    if (n >= static_cast<T>((std::numeric_limits<int64_t>::max)())) {
+      return InfiniteDuration();
+    }
+    return time_internal::MakePosDoubleDuration(n);
+  } else {
+    if (std::isnan(n))
+      return std::signbit(n) ? -InfiniteDuration() : InfiniteDuration();
+    if (n <= (std::numeric_limits<int64_t>::min)()) return -InfiniteDuration();
+    return -time_internal::MakePosDoubleDuration(-n);
+  }
+}
+template <typename T, time_internal::EnableIfFloat<T> = 0>
+Duration Minutes(T n) {
+  return n * Minutes(1);
+}
+template <typename T, time_internal::EnableIfFloat<T> = 0>
+Duration Hours(T n) {
+  return n * Hours(1);
+}
+
+// ToInt64Nanoseconds()
+// ToInt64Microseconds()
+// ToInt64Milliseconds()
+// ToInt64Seconds()
+// ToInt64Minutes()
+// ToInt64Hours()
+//
+// Helper functions that convert a Duration to an integral count of the
+// indicated unit. These return the same results as the `IDivDuration()`
+// function, though they usually do so more efficiently; see the
+// documentation of `IDivDuration()` for details about overflow, etc.
+//
+// Example:
+//
+//   absl::Duration d = absl::Milliseconds(1500);
+//   int64_t isec = absl::ToInt64Seconds(d);  // isec == 1
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Seconds(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Minutes(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
+
+// ToDoubleNanoSeconds()
+// ToDoubleMicroseconds()
+// ToDoubleMilliseconds()
+// ToDoubleSeconds()
+// ToDoubleMinutes()
+// ToDoubleHours()
+//
+// Helper functions that convert a Duration to a floating point count of the
+// indicated unit. These functions are shorthand for the `FDivDuration()`
+// function above; see its documentation for details about overflow, etc.
+//
+// Example:
+//
+//   absl::Duration d = absl::Milliseconds(1500);
+//   double dsec = absl::ToDoubleSeconds(d);  // dsec == 1.5
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleSeconds(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMinutes(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d);
+
+// FromChrono()
+//
+// Converts any of the pre-defined std::chrono durations to an absl::Duration.
+//
+// Example:
+//
+//   std::chrono::milliseconds ms(123);
+//   absl::Duration d = absl::FromChrono(ms);
+constexpr Duration FromChrono(const std::chrono::nanoseconds& d);
+constexpr Duration FromChrono(const std::chrono::microseconds& d);
+constexpr Duration FromChrono(const std::chrono::milliseconds& d);
+constexpr Duration FromChrono(const std::chrono::seconds& d);
+constexpr Duration FromChrono(const std::chrono::minutes& d);
+constexpr Duration FromChrono(const std::chrono::hours& d);
+
+// ToChronoNanoseconds()
+// ToChronoMicroseconds()
+// ToChronoMilliseconds()
+// ToChronoSeconds()
+// ToChronoMinutes()
+// ToChronoHours()
+//
+// Converts an absl::Duration to any of the pre-defined std::chrono durations.
+// If overflow would occur, the returned value will saturate at the min/max
+// chrono duration value instead.
+//
+// Example:
+//
+//   absl::Duration d = absl::Microseconds(123);
+//   auto x = absl::ToChronoMicroseconds(d);
+//   auto y = absl::ToChronoNanoseconds(d);  // x == y
+//   auto z = absl::ToChronoSeconds(absl::InfiniteDuration());
+//   // z == std::chrono::seconds::max()
+std::chrono::nanoseconds ToChronoNanoseconds(Duration d);
+std::chrono::microseconds ToChronoMicroseconds(Duration d);
+std::chrono::milliseconds ToChronoMilliseconds(Duration d);
+std::chrono::seconds ToChronoSeconds(Duration d);
+std::chrono::minutes ToChronoMinutes(Duration d);
+std::chrono::hours ToChronoHours(Duration d);
+
+// FormatDuration()
+//
+// Returns a string representing the duration in the form "72h3m0.5s".
+// Returns "inf" or "-inf" for +/- `InfiniteDuration()`.
+std::string FormatDuration(Duration d);
+
+// Output stream operator.
+inline std::ostream& operator<<(std::ostream& os, Duration d) {
+  return os << FormatDuration(d);
+}
+
+// ParseDuration()
+//
+// Parses a duration string consisting of a possibly signed sequence of
+// decimal numbers, each with an optional fractional part and a unit
+// suffix.  The valid suffixes are "ns", "us" "ms", "s", "m", and "h".
+// Simple examples include "300ms", "-1.5h", and "2h45m".  Parses "0" as
+// `ZeroDuration()`. Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
+bool ParseDuration(absl::string_view dur_string, Duration* d);
+
+// AbslParseFlag()
+//
+// Parses a command-line flag string representation `text` into a Duration
+// value. Duration flags must be specified in a format that is valid input for
+// `absl::ParseDuration()`.
+bool AbslParseFlag(absl::string_view text, Duration* dst, std::string* error);
+
+
+// AbslUnparseFlag()
+//
+// Unparses a Duration value into a command-line string representation using
+// the format specified by `absl::ParseDuration()`.
+std::string AbslUnparseFlag(Duration d);
+
+ABSL_DEPRECATED("Use AbslParseFlag() instead.")
+bool ParseFlag(const std::string& text, Duration* dst, std::string* error);
+ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
+std::string UnparseFlag(Duration d);
+
+// Time
+//
+// An `absl::Time` represents a specific instant in time. Arithmetic operators
+// are provided for naturally expressing time calculations. Instances are
+// created using `absl::Now()` and the `absl::From*()` factory functions that
+// accept the gamut of other time representations. Formatting and parsing
+// functions are provided for conversion to and from strings.  `absl::Time`
+// should be passed by value rather than const reference.
+//
+// `absl::Time` assumes there are 60 seconds in a minute, which means the
+// underlying time scales must be "smeared" to eliminate leap seconds.
+// See https://developers.google.com/time/smear.
+//
+// Even though `absl::Time` supports a wide range of timestamps, exercise
+// caution when using values in the distant past. `absl::Time` uses the
+// Proleptic Gregorian calendar, which extends the Gregorian calendar backward
+// to dates before its introduction in 1582.
+// See https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar
+// for more information. Use the ICU calendar classes to convert a date in
+// some other calendar (http://userguide.icu-project.org/datetime/calendar).
+//
+// Similarly, standardized time zones are a reasonably recent innovation, with
+// the Greenwich prime meridian being established in 1884. The TZ database
+// itself does not profess accurate offsets for timestamps prior to 1970. The
+// breakdown of future timestamps is subject to the whim of regional
+// governments.
+//
+// The `absl::Time` class represents an instant in time as a count of clock
+// ticks of some granularity (resolution) from some starting point (epoch).
+//
+// `absl::Time` uses a resolution that is high enough to avoid loss in
+// precision, and a range that is wide enough to avoid overflow, when
+// converting between tick counts in most Google time scales (i.e., resolution
+// of at least one nanosecond, and range +/-100 billion years).  Conversions
+// between the time scales are performed by truncating (towards negative
+// infinity) to the nearest representable point.
+//
+// Examples:
+//
+//   absl::Time t1 = ...;
+//   absl::Time t2 = t1 + absl::Minutes(2);
+//   absl::Duration d = t2 - t1;  // == absl::Minutes(2)
+//
+class Time {
+ public:
+  // Value semantics.
+
+  // Returns the Unix epoch.  However, those reading your code may not know
+  // or expect the Unix epoch as the default value, so make your code more
+  // readable by explicitly initializing all instances before use.
+  //
+  // Example:
+  //   absl::Time t = absl::UnixEpoch();
+  //   absl::Time t = absl::Now();
+  //   absl::Time t = absl::TimeFromTimeval(tv);
+  //   absl::Time t = absl::InfinitePast();
+  constexpr Time() = default;
+
+  // Copyable.
+  constexpr Time(const Time& t) = default;
+  Time& operator=(const Time& t) = default;
+
+  // Assignment operators.
+  Time& operator+=(Duration d) {
+    rep_ += d;
+    return *this;
+  }
+  Time& operator-=(Duration d) {
+    rep_ -= d;
+    return *this;
+  }
+
+  // Time::Breakdown
+  //
+  // The calendar and wall-clock (aka "civil time") components of an
+  // `absl::Time` in a certain `absl::TimeZone`. This struct is not
+  // intended to represent an instant in time. So, rather than passing
+  // a `Time::Breakdown` to a function, pass an `absl::Time` and an
+  // `absl::TimeZone`.
+  //
+  // Deprecated. Use `absl::TimeZone::CivilInfo`.
+  struct
+      Breakdown {
+    int64_t year;        // year (e.g., 2013)
+    int month;           // month of year [1:12]
+    int day;             // day of month [1:31]
+    int hour;            // hour of day [0:23]
+    int minute;          // minute of hour [0:59]
+    int second;          // second of minute [0:59]
+    Duration subsecond;  // [Seconds(0):Seconds(1)) if finite
+    int weekday;         // 1==Mon, ..., 7=Sun
+    int yearday;         // day of year [1:366]
+
+    // Note: The following fields exist for backward compatibility
+    // with older APIs.  Accessing these fields directly is a sign of
+    // imprudent logic in the calling code.  Modern time-related code
+    // should only access this data indirectly by way of FormatTime().
+    // These fields are undefined for InfiniteFuture() and InfinitePast().
+    int offset;             // seconds east of UTC
+    bool is_dst;            // is offset non-standard?
+    const char* zone_abbr;  // time-zone abbreviation (e.g., "PST")
+  };
+
+  // Time::In()
+  //
+  // Returns the breakdown of this instant in the given TimeZone.
+  //
+  // Deprecated. Use `absl::TimeZone::At(Time)`.
+  Breakdown In(TimeZone tz) const;
+
+  template <typename H>
+  friend H AbslHashValue(H h, Time t) {
+    return H::combine(std::move(h), t.rep_);
+  }
+
+ private:
+  friend constexpr Time time_internal::FromUnixDuration(Duration d);
+  friend constexpr Duration time_internal::ToUnixDuration(Time t);
+  friend constexpr bool operator<(Time lhs, Time rhs);
+  friend constexpr bool operator==(Time lhs, Time rhs);
+  friend Duration operator-(Time lhs, Time rhs);
+  friend constexpr Time UniversalEpoch();
+  friend constexpr Time InfiniteFuture();
+  friend constexpr Time InfinitePast();
+  constexpr explicit Time(Duration rep) : rep_(rep) {}
+  Duration rep_;
+};
+
+// Relational Operators
+constexpr bool operator<(Time lhs, Time rhs) { return lhs.rep_ < rhs.rep_; }
+constexpr bool operator>(Time lhs, Time rhs) { return rhs < lhs; }
+constexpr bool operator>=(Time lhs, Time rhs) { return !(lhs < rhs); }
+constexpr bool operator<=(Time lhs, Time rhs) { return !(rhs < lhs); }
+constexpr bool operator==(Time lhs, Time rhs) { return lhs.rep_ == rhs.rep_; }
+constexpr bool operator!=(Time lhs, Time rhs) { return !(lhs == rhs); }
+
+// Additive Operators
+inline Time operator+(Time lhs, Duration rhs) { return lhs += rhs; }
+inline Time operator+(Duration lhs, Time rhs) { return rhs += lhs; }
+inline Time operator-(Time lhs, Duration rhs) { return lhs -= rhs; }
+inline Duration operator-(Time lhs, Time rhs) { return lhs.rep_ - rhs.rep_; }
+
+// UnixEpoch()
+//
+// Returns the `absl::Time` representing "1970-01-01 00:00:00.0 +0000".
+constexpr Time UnixEpoch() { return Time(); }
+
+// UniversalEpoch()
+//
+// Returns the `absl::Time` representing "0001-01-01 00:00:00.0 +0000", the
+// epoch of the ICU Universal Time Scale.
+constexpr Time UniversalEpoch() {
+  // 719162 is the number of days from 0001-01-01 to 1970-01-01,
+  // assuming the Gregorian calendar.
+  return Time(
+      time_internal::MakeDuration(-24 * 719162 * int64_t{3600}, uint32_t{0}));
+}
+
+// InfiniteFuture()
+//
+// Returns an `absl::Time` that is infinitely far in the future.
+constexpr Time InfiniteFuture() {
+  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
+                                          ~uint32_t{0}));
+}
+
+// InfinitePast()
+//
+// Returns an `absl::Time` that is infinitely far in the past.
+constexpr Time InfinitePast() {
+  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::min)(),
+                                          ~uint32_t{0}));
+}
+
+// FromUnixNanos()
+// FromUnixMicros()
+// FromUnixMillis()
+// FromUnixSeconds()
+// FromTimeT()
+// FromUDate()
+// FromUniversal()
+//
+// Creates an `absl::Time` from a variety of other representations.
+constexpr Time FromUnixNanos(int64_t ns);
+constexpr Time FromUnixMicros(int64_t us);
+constexpr Time FromUnixMillis(int64_t ms);
+constexpr Time FromUnixSeconds(int64_t s);
+constexpr Time FromTimeT(time_t t);
+Time FromUDate(double udate);
+Time FromUniversal(int64_t universal);
+
+// ToUnixNanos()
+// ToUnixMicros()
+// ToUnixMillis()
+// ToUnixSeconds()
+// ToTimeT()
+// ToUDate()
+// ToUniversal()
+//
+// Converts an `absl::Time` to a variety of other representations.  Note that
+// these operations round down toward negative infinity where necessary to
+// adjust to the resolution of the result type.  Beware of possible time_t
+// over/underflow in ToTime{T,val,spec}() on 32-bit platforms.
+int64_t ToUnixNanos(Time t);
+int64_t ToUnixMicros(Time t);
+int64_t ToUnixMillis(Time t);
+int64_t ToUnixSeconds(Time t);
+time_t ToTimeT(Time t);
+double ToUDate(Time t);
+int64_t ToUniversal(Time t);
+
+// DurationFromTimespec()
+// DurationFromTimeval()
+// ToTimespec()
+// ToTimeval()
+// TimeFromTimespec()
+// TimeFromTimeval()
+// ToTimespec()
+// ToTimeval()
+//
+// Some APIs use a timespec or a timeval as a Duration (e.g., nanosleep(2)
+// and select(2)), while others use them as a Time (e.g. clock_gettime(2)
+// and gettimeofday(2)), so conversion functions are provided for both cases.
+// The "to timespec/val" direction is easily handled via overloading, but
+// for "from timespec/val" the desired type is part of the function name.
+Duration DurationFromTimespec(timespec ts);
+Duration DurationFromTimeval(timeval tv);
+timespec ToTimespec(Duration d);
+timeval ToTimeval(Duration d);
+Time TimeFromTimespec(timespec ts);
+Time TimeFromTimeval(timeval tv);
+timespec ToTimespec(Time t);
+timeval ToTimeval(Time t);
+
+// FromChrono()
+//
+// Converts a std::chrono::system_clock::time_point to an absl::Time.
+//
+// Example:
+//
+//   auto tp = std::chrono::system_clock::from_time_t(123);
+//   absl::Time t = absl::FromChrono(tp);
+//   // t == absl::FromTimeT(123)
+Time FromChrono(const std::chrono::system_clock::time_point& tp);
+
+// ToChronoTime()
+//
+// Converts an absl::Time to a std::chrono::system_clock::time_point. If
+// overflow would occur, the returned value will saturate at the min/max time
+// point value instead.
+//
+// Example:
+//
+//   absl::Time t = absl::FromTimeT(123);
+//   auto tp = absl::ToChronoTime(t);
+//   // tp == std::chrono::system_clock::from_time_t(123);
+std::chrono::system_clock::time_point ToChronoTime(Time);
+
+// AbslParseFlag()
+//
+// Parses the command-line flag string representation `text` into a Time value.
+// Time flags must be specified in a format that matches absl::RFC3339_full.
+//
+// For example:
+//
+//   --start_time=2016-01-02T03:04:05.678+08:00
+//
+// Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required.
+//
+// Additionally, if you'd like to specify a time as a count of
+// seconds/milliseconds/etc from the Unix epoch, use an absl::Duration flag
+// and add that duration to absl::UnixEpoch() to get an absl::Time.
+bool AbslParseFlag(absl::string_view text, Time* t, std::string* error);
+
+// AbslUnparseFlag()
+//
+// Unparses a Time value into a command-line string representation using
+// the format specified by `absl::ParseTime()`.
+std::string AbslUnparseFlag(Time t);
+
+ABSL_DEPRECATED("Use AbslParseFlag() instead.")
+bool ParseFlag(const std::string& text, Time* t, std::string* error);
+ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
+std::string UnparseFlag(Time t);
+
+// TimeZone
+//
+// The `absl::TimeZone` is an opaque, small, value-type class representing a
+// geo-political region within which particular rules are used for converting
+// between absolute and civil times (see https://git.io/v59Ly). `absl::TimeZone`
+// values are named using the TZ identifiers from the IANA Time Zone Database,
+// such as "America/Los_Angeles" or "Australia/Sydney". `absl::TimeZone` values
+// are created from factory functions such as `absl::LoadTimeZone()`. Note:
+// strings like "PST" and "EDT" are not valid TZ identifiers. Prefer to pass by
+// value rather than const reference.
+//
+// For more on the fundamental concepts of time zones, absolute times, and civil
+// times, see https://github.com/google/cctz#fundamental-concepts
+//
+// Examples:
+//
+//   absl::TimeZone utc = absl::UTCTimeZone();
+//   absl::TimeZone pst = absl::FixedTimeZone(-8 * 60 * 60);
+//   absl::TimeZone loc = absl::LocalTimeZone();
+//   absl::TimeZone lax;
+//   if (!absl::LoadTimeZone("America/Los_Angeles", &lax)) {
+//     // handle error case
+//   }
+//
+// See also:
+// - https://github.com/google/cctz
+// - https://www.iana.org/time-zones
+// - https://en.wikipedia.org/wiki/Zoneinfo
+class TimeZone {
+ public:
+  explicit TimeZone(time_internal::cctz::time_zone tz) : cz_(tz) {}
+  TimeZone() = default;  // UTC, but prefer UTCTimeZone() to be explicit.
+
+  // Copyable.
+  TimeZone(const TimeZone&) = default;
+  TimeZone& operator=(const TimeZone&) = default;
+
+  explicit operator time_internal::cctz::time_zone() const { return cz_; }
+
+  std::string name() const { return cz_.name(); }
+
+  // TimeZone::CivilInfo
+  //
+  // Information about the civil time corresponding to an absolute time.
+  // This struct is not intended to represent an instant in time. So, rather
+  // than passing a `TimeZone::CivilInfo` to a function, pass an `absl::Time`
+  // and an `absl::TimeZone`.
+  struct CivilInfo {
+    CivilSecond cs;
+    Duration subsecond;
+
+    // Note: The following fields exist for backward compatibility
+    // with older APIs.  Accessing these fields directly is a sign of
+    // imprudent logic in the calling code.  Modern time-related code
+    // should only access this data indirectly by way of FormatTime().
+    // These fields are undefined for InfiniteFuture() and InfinitePast().
+    int offset;             // seconds east of UTC
+    bool is_dst;            // is offset non-standard?
+    const char* zone_abbr;  // time-zone abbreviation (e.g., "PST")
+  };
+
+  // TimeZone::At(Time)
+  //
+  // Returns the civil time for this TimeZone at a certain `absl::Time`.
+  // If the input time is infinite, the output civil second will be set to
+  // CivilSecond::max() or min(), and the subsecond will be infinite.
+  //
+  // Example:
+  //
+  //   const auto epoch = lax.At(absl::UnixEpoch());
+  //   // epoch.cs == 1969-12-31 16:00:00
+  //   // epoch.subsecond == absl::ZeroDuration()
+  //   // epoch.offset == -28800
+  //   // epoch.is_dst == false
+  //   // epoch.abbr == "PST"
+  CivilInfo At(Time t) const;
+
+  // TimeZone::TimeInfo
+  //
+  // Information about the absolute times corresponding to a civil time.
+  // (Subseconds must be handled separately.)
+  //
+  // It is possible for a caller to pass a civil-time value that does
+  // not represent an actual or unique instant in time (due to a shift
+  // in UTC offset in the TimeZone, which results in a discontinuity in
+  // the civil-time components). For example, a daylight-saving-time
+  // transition skips or repeats civil times---in the United States,
+  // March 13, 2011 02:15 never occurred, while November 6, 2011 01:15
+  // occurred twice---so requests for such times are not well-defined.
+  // To account for these possibilities, `absl::TimeZone::TimeInfo` is
+  // richer than just a single `absl::Time`.
+  struct TimeInfo {
+    enum CivilKind {
+      UNIQUE,    // the civil time was singular (pre == trans == post)
+      SKIPPED,   // the civil time did not exist (pre >= trans > post)
+      REPEATED,  // the civil time was ambiguous (pre < trans <= post)
+    } kind;
+    Time pre;    // time calculated using the pre-transition offset
+    Time trans;  // when the civil-time discontinuity occurred
+    Time post;   // time calculated using the post-transition offset
+  };
+
+  // TimeZone::At(CivilSecond)
+  //
+  // Returns an `absl::TimeInfo` containing the absolute time(s) for this
+  // TimeZone at an `absl::CivilSecond`. When the civil time is skipped or
+  // repeated, returns times calculated using the pre-transition and post-
+  // transition UTC offsets, plus the transition time itself.
+  //
+  // Examples:
+  //
+  //   // A unique civil time
+  //   const auto jan01 = lax.At(absl::CivilSecond(2011, 1, 1, 0, 0, 0));
+  //   // jan01.kind == TimeZone::TimeInfo::UNIQUE
+  //   // jan01.pre    is 2011-01-01 00:00:00 -0800
+  //   // jan01.trans  is 2011-01-01 00:00:00 -0800
+  //   // jan01.post   is 2011-01-01 00:00:00 -0800
+  //
+  //   // A Spring DST transition, when there is a gap in civil time
+  //   const auto mar13 = lax.At(absl::CivilSecond(2011, 3, 13, 2, 15, 0));
+  //   // mar13.kind == TimeZone::TimeInfo::SKIPPED
+  //   // mar13.pre   is 2011-03-13 03:15:00 -0700
+  //   // mar13.trans is 2011-03-13 03:00:00 -0700
+  //   // mar13.post  is 2011-03-13 01:15:00 -0800
+  //
+  //   // A Fall DST transition, when civil times are repeated
+  //   const auto nov06 = lax.At(absl::CivilSecond(2011, 11, 6, 1, 15, 0));
+  //   // nov06.kind == TimeZone::TimeInfo::REPEATED
+  //   // nov06.pre   is 2011-11-06 01:15:00 -0700
+  //   // nov06.trans is 2011-11-06 01:00:00 -0800
+  //   // nov06.post  is 2011-11-06 01:15:00 -0800
+  TimeInfo At(CivilSecond ct) const;
+
+  // TimeZone::NextTransition()
+  // TimeZone::PrevTransition()
+  //
+  // Finds the time of the next/previous offset change in this time zone.
+  //
+  // By definition, `NextTransition(t, &trans)` returns false when `t` is
+  // `InfiniteFuture()`, and `PrevTransition(t, &trans)` returns false
+  // when `t` is `InfinitePast()`. If the zone has no transitions, the
+  // result will also be false no matter what the argument.
+  //
+  // Otherwise, when `t` is `InfinitePast()`, `NextTransition(t, &trans)`
+  // returns true and sets `trans` to the first recorded transition. Chains
+  // of calls to `NextTransition()/PrevTransition()` will eventually return
+  // false, but it is unspecified exactly when `NextTransition(t, &trans)`
+  // jumps to false, or what time is set by `PrevTransition(t, &trans)` for
+  // a very distant `t`.
+  //
+  // Note: Enumeration of time-zone transitions is for informational purposes
+  // only. Modern time-related code should not care about when offset changes
+  // occur.
+  //
+  // Example:
+  //   absl::TimeZone nyc;
+  //   if (!absl::LoadTimeZone("America/New_York", &nyc)) { ... }
+  //   const auto now = absl::Now();
+  //   auto t = absl::InfinitePast();
+  //   absl::TimeZone::CivilTransition trans;
+  //   while (t <= now && nyc.NextTransition(t, &trans)) {
+  //     // transition: trans.from -> trans.to
+  //     t = nyc.At(trans.to).trans;
+  //   }
+  struct CivilTransition {
+    CivilSecond from;  // the civil time we jump from
+    CivilSecond to;    // the civil time we jump to
+  };
+  bool NextTransition(Time t, CivilTransition* trans) const;
+  bool PrevTransition(Time t, CivilTransition* trans) const;
+
+  template <typename H>
+  friend H AbslHashValue(H h, TimeZone tz) {
+    return H::combine(std::move(h), tz.cz_);
+  }
+
+ private:
+  friend bool operator==(TimeZone a, TimeZone b) { return a.cz_ == b.cz_; }
+  friend bool operator!=(TimeZone a, TimeZone b) { return a.cz_ != b.cz_; }
+  friend std::ostream& operator<<(std::ostream& os, TimeZone tz) {
+    return os << tz.name();
+  }
+
+  time_internal::cctz::time_zone cz_;
+};
+
+// LoadTimeZone()
+//
+// Loads the named zone. May perform I/O on the initial load of the named
+// zone. If the name is invalid, or some other kind of error occurs, returns
+// `false` and `*tz` is set to the UTC time zone.
+inline bool LoadTimeZone(absl::string_view name, TimeZone* tz) {
+  if (name == "localtime") {
+    *tz = TimeZone(time_internal::cctz::local_time_zone());
+    return true;
+  }
+  time_internal::cctz::time_zone cz;
+  const bool b = time_internal::cctz::load_time_zone(std::string(name), &cz);
+  *tz = TimeZone(cz);
+  return b;
+}
+
+// FixedTimeZone()
+//
+// Returns a TimeZone that is a fixed offset (seconds east) from UTC.
+// Note: If the absolute value of the offset is greater than 24 hours
+// you'll get UTC (i.e., no offset) instead.
+inline TimeZone FixedTimeZone(int seconds) {
+  return TimeZone(
+      time_internal::cctz::fixed_time_zone(std::chrono::seconds(seconds)));
+}
+
+// UTCTimeZone()
+//
+// Convenience method returning the UTC time zone.
+inline TimeZone UTCTimeZone() {
+  return TimeZone(time_internal::cctz::utc_time_zone());
+}
+
+// LocalTimeZone()
+//
+// Convenience method returning the local time zone, or UTC if there is
+// no configured local zone.  Warning: Be wary of using LocalTimeZone(),
+// and particularly so in a server process, as the zone configured for the
+// local machine should be irrelevant.  Prefer an explicit zone name.
+inline TimeZone LocalTimeZone() {
+  return TimeZone(time_internal::cctz::local_time_zone());
+}
+
+// ToCivilSecond()
+// ToCivilMinute()
+// ToCivilHour()
+// ToCivilDay()
+// ToCivilMonth()
+// ToCivilYear()
+//
+// Helpers for TimeZone::At(Time) to return particularly aligned civil times.
+//
+// Example:
+//
+//   absl::Time t = ...;
+//   absl::TimeZone tz = ...;
+//   const auto cd = absl::ToCivilDay(t, tz);
+inline CivilSecond ToCivilSecond(Time t, TimeZone tz) {
+  return tz.At(t).cs;  // already a CivilSecond
+}
+inline CivilMinute ToCivilMinute(Time t, TimeZone tz) {
+  return CivilMinute(tz.At(t).cs);
+}
+inline CivilHour ToCivilHour(Time t, TimeZone tz) {
+  return CivilHour(tz.At(t).cs);
+}
+inline CivilDay ToCivilDay(Time t, TimeZone tz) {
+  return CivilDay(tz.At(t).cs);
+}
+inline CivilMonth ToCivilMonth(Time t, TimeZone tz) {
+  return CivilMonth(tz.At(t).cs);
+}
+inline CivilYear ToCivilYear(Time t, TimeZone tz) {
+  return CivilYear(tz.At(t).cs);
+}
+
+// FromCivil()
+//
+// Helper for TimeZone::At(CivilSecond) that provides "order-preserving
+// semantics." If the civil time maps to a unique time, that time is
+// returned. If the civil time is repeated in the given time zone, the
+// time using the pre-transition offset is returned. Otherwise, the
+// civil time is skipped in the given time zone, and the transition time
+// is returned. This means that for any two civil times, ct1 and ct2,
+// (ct1 < ct2) => (FromCivil(ct1) <= FromCivil(ct2)), the equal case
+// being when two non-existent civil times map to the same transition time.
+//
+// Note: Accepts civil times of any alignment.
+inline Time FromCivil(CivilSecond ct, TimeZone tz) {
+  const auto ti = tz.At(ct);
+  if (ti.kind == TimeZone::TimeInfo::SKIPPED) return ti.trans;
+  return ti.pre;
+}
+
+// TimeConversion
+//
+// An `absl::TimeConversion` represents the conversion of year, month, day,
+// hour, minute, and second values (i.e., a civil time), in a particular
+// `absl::TimeZone`, to a time instant (an absolute time), as returned by
+// `absl::ConvertDateTime()`. Legacy version of `absl::TimeZone::TimeInfo`.
+//
+// Deprecated. Use `absl::TimeZone::TimeInfo`.
+struct
+    TimeConversion {
+  Time pre;    // time calculated using the pre-transition offset
+  Time trans;  // when the civil-time discontinuity occurred
+  Time post;   // time calculated using the post-transition offset
+
+  enum Kind {
+    UNIQUE,    // the civil time was singular (pre == trans == post)
+    SKIPPED,   // the civil time did not exist
+    REPEATED,  // the civil time was ambiguous
+  };
+  Kind kind;
+
+  bool normalized;  // input values were outside their valid ranges
+};
+
+// ConvertDateTime()
+//
+// Legacy version of `absl::TimeZone::At(absl::CivilSecond)` that takes
+// the civil time as six, separate values (YMDHMS).
+//
+// The input month, day, hour, minute, and second values can be outside
+// of their valid ranges, in which case they will be "normalized" during
+// the conversion.
+//
+// Example:
+//
+//   // "October 32" normalizes to "November 1".
+//   absl::TimeConversion tc =
+//       absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, lax);
+//   // tc.kind == TimeConversion::UNIQUE && tc.normalized == true
+//   // absl::ToCivilDay(tc.pre, tz).month() == 11
+//   // absl::ToCivilDay(tc.pre, tz).day() == 1
+//
+// Deprecated. Use `absl::TimeZone::At(CivilSecond)`.
+TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour,
+                               int min, int sec, TimeZone tz);
+
+// FromDateTime()
+//
+// A convenience wrapper for `absl::ConvertDateTime()` that simply returns
+// the "pre" `absl::Time`.  That is, the unique result, or the instant that
+// is correct using the pre-transition offset (as if the transition never
+// happened).
+//
+// Example:
+//
+//   absl::Time t = absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax);
+//   // t = 2017-09-26 09:30:00 -0700
+//
+// Deprecated. Use `absl::FromCivil(CivilSecond, TimeZone)`. Note that the
+// behavior of `FromCivil()` differs from `FromDateTime()` for skipped civil
+// times. If you care about that see `absl::TimeZone::At(absl::CivilSecond)`.
+inline Time FromDateTime(int64_t year, int mon, int day, int hour,
+                         int min, int sec, TimeZone tz) {
+  return ConvertDateTime(year, mon, day, hour, min, sec, tz).pre;
+}
+
+// FromTM()
+//
+// Converts the `tm_year`, `tm_mon`, `tm_mday`, `tm_hour`, `tm_min`, and
+// `tm_sec` fields to an `absl::Time` using the given time zone. See ctime(3)
+// for a description of the expected values of the tm fields. If the civil time
+// is unique (see `absl::TimeZone::At(absl::CivilSecond)` above), the matching
+// time instant is returned.  Otherwise, the `tm_isdst` field is consulted to
+// choose between the possible results.  For a repeated civil time, `tm_isdst !=
+// 0` returns the matching DST instant, while `tm_isdst == 0` returns the
+// matching non-DST instant.  For a skipped civil time there is no matching
+// instant, so `tm_isdst != 0` returns the DST instant, and `tm_isdst == 0`
+// returns the non-DST instant, that would have matched if the transition never
+// happened.
+Time FromTM(const struct tm& tm, TimeZone tz);
+
+// ToTM()
+//
+// Converts the given `absl::Time` to a struct tm using the given time zone.
+// See ctime(3) for a description of the values of the tm fields.
+struct tm ToTM(Time t, TimeZone tz);
+
+// RFC3339_full
+// RFC3339_sec
+//
+// FormatTime()/ParseTime() format specifiers for RFC3339 date/time strings,
+// with trailing zeros trimmed or with fractional seconds omitted altogether.
+//
+// Note that RFC3339_sec[] matches an ISO 8601 extended format for date and
+// time with UTC offset.  Also note the use of "%Y": RFC3339 mandates that
+// years have exactly four digits, but we allow them to take their natural
+// width.
+ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez
+ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez
+
+// RFC1123_full
+// RFC1123_no_wday
+//
+// FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
+ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z
+ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
+
+// FormatTime()
+//
+// Formats the given `absl::Time` in the `absl::TimeZone` according to the
+// provided format string. Uses strftime()-like formatting options, with
+// the following extensions:
+//
+//   - %Ez  - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
+//   - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
+//   - %E#S - Seconds with # digits of fractional precision
+//   - %E*S - Seconds with full fractional precision (a literal '*')
+//   - %E#f - Fractional seconds with # digits of precision
+//   - %E*f - Fractional seconds with full precision (a literal '*')
+//   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
+//   - %ET  - The RFC3339 "date-time" separator "T"
+//
+// Note that %E0S behaves like %S, and %E0f produces no characters.  In
+// contrast %E*f always produces at least one digit, which may be '0'.
+//
+// Note that %Y produces as many characters as it takes to fully render the
+// year.  A year outside of [-999:9999] when formatted with %E4Y will produce
+// more than four characters, just like %Y.
+//
+// We recommend that format strings include the UTC offset (%z, %Ez, or %E*z)
+// so that the result uniquely identifies a time instant.
+//
+// Example:
+//
+//   absl::CivilSecond cs(2013, 1, 2, 3, 4, 5);
+//   absl::Time t = absl::FromCivil(cs, lax);
+//   std::string f = absl::FormatTime("%H:%M:%S", t, lax);  // "03:04:05"
+//   f = absl::FormatTime("%H:%M:%E3S", t, lax);  // "03:04:05.000"
+//
+// Note: If the given `absl::Time` is `absl::InfiniteFuture()`, the returned
+// string will be exactly "infinite-future". If the given `absl::Time` is
+// `absl::InfinitePast()`, the returned string will be exactly "infinite-past".
+// In both cases the given format string and `absl::TimeZone` are ignored.
+//
+std::string FormatTime(absl::string_view format, Time t, TimeZone tz);
+
+// Convenience functions that format the given time using the RFC3339_full
+// format.  The first overload uses the provided TimeZone, while the second
+// uses LocalTimeZone().
+std::string FormatTime(Time t, TimeZone tz);
+std::string FormatTime(Time t);
+
+// Output stream operator.
+inline std::ostream& operator<<(std::ostream& os, Time t) {
+  return os << FormatTime(t);
+}
+
+// ParseTime()
+//
+// Parses an input string according to the provided format string and
+// returns the corresponding `absl::Time`. Uses strftime()-like formatting
+// options, with the same extensions as FormatTime(), but with the
+// exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f.  %Ez
+// and %E*z also accept the same inputs, which (along with %z) includes
+// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
+//
+// %Y consumes as many numeric characters as it can, so the matching data
+// should always be terminated with a non-numeric.  %E4Y always consumes
+// exactly four characters, including any sign.
+//
+// Unspecified fields are taken from the default date and time of ...
+//
+//   "1970-01-01 00:00:00.0 +0000"
+//
+// For example, parsing a string of "15:45" (%H:%M) will return an absl::Time
+// that represents "1970-01-01 15:45:00.0 +0000".
+//
+// Note that since ParseTime() returns time instants, it makes the most sense
+// to parse fully-specified date/time strings that include a UTC offset (%z,
+// %Ez, or %E*z).
+//
+// Note also that `absl::ParseTime()` only heeds the fields year, month, day,
+// hour, minute, (fractional) second, and UTC offset.  Other fields, like
+// weekday (%a or %A), while parsed for syntactic validity, are ignored
+// in the conversion.
+//
+// Date and time fields that are out-of-range will be treated as errors
+// rather than normalizing them like `absl::CivilSecond` does.  For example,
+// it is an error to parse the date "Oct 32, 2013" because 32 is out of range.
+//
+// A leap second of ":60" is normalized to ":00" of the following minute
+// with fractional seconds discarded.  The following table shows how the
+// given seconds and subseconds will be parsed:
+//
+//   "59.x" -> 59.x  // exact
+//   "60.x" -> 00.0  // normalized
+//   "00.x" -> 00.x  // exact
+//
+// Errors are indicated by returning false and assigning an error message
+// to the "err" out param if it is non-null.
+//
+// Note: If the input string is exactly "infinite-future", the returned
+// `absl::Time` will be `absl::InfiniteFuture()` and `true` will be returned.
+// If the input string is "infinite-past", the returned `absl::Time` will be
+// `absl::InfinitePast()` and `true` will be returned.
+//
+bool ParseTime(absl::string_view format, absl::string_view input, Time* time,
+               std::string* err);
+
+// Like ParseTime() above, but if the format string does not contain a UTC
+// offset specification (%z/%Ez/%E*z) then the input is interpreted in the
+// given TimeZone.  This means that the input, by itself, does not identify a
+// unique instant.  Being time-zone dependent, it also admits the possibility
+// of ambiguity or non-existence, in which case the "pre" time (as defined
+// by TimeZone::TimeInfo) is returned.  For these reasons we recommend that
+// all date/time strings include a UTC offset so they're context independent.
+bool ParseTime(absl::string_view format, absl::string_view input, TimeZone tz,
+               Time* time, std::string* err);
+
+// ============================================================================
+// Implementation Details Follow
+// ============================================================================
+
+namespace time_internal {
+
+// Creates a Duration with a given representation.
+// REQUIRES: hi,lo is a valid representation of a Duration as specified
+// in time/duration.cc.
+constexpr Duration MakeDuration(int64_t hi, uint32_t lo = 0) {
+  return Duration(hi, lo);
+}
+
+constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
+  return MakeDuration(hi, static_cast<uint32_t>(lo));
+}
+
+// Make a Duration value from a floating-point number, as long as that number
+// is in the range [ 0 .. numeric_limits<int64_t>::max ), that is, as long as
+// it's positive and can be converted to int64_t without risk of UB.
+inline Duration MakePosDoubleDuration(double n) {
+  const int64_t int_secs = static_cast<int64_t>(n);
+  const uint32_t ticks = static_cast<uint32_t>(
+      std::round((n - static_cast<double>(int_secs)) * kTicksPerSecond));
+  return ticks < kTicksPerSecond
+             ? MakeDuration(int_secs, ticks)
+             : MakeDuration(int_secs + 1, ticks - kTicksPerSecond);
+}
+
+// Creates a normalized Duration from an almost-normalized (sec,ticks)
+// pair. sec may be positive or negative.  ticks must be in the range
+// -kTicksPerSecond < *ticks < kTicksPerSecond.  If ticks is negative it
+// will be normalized to a positive value in the resulting Duration.
+constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks) {
+  return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
+                     : MakeDuration(sec, ticks);
+}
+
+// Provide access to the Duration representation.
+constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; }
+constexpr uint32_t GetRepLo(Duration d) { return d.rep_lo_; }
+
+// Returns true iff d is positive or negative infinity.
+constexpr bool IsInfiniteDuration(Duration d) {
+  return GetRepLo(d) == ~uint32_t{0};
+}
+
+// Returns an infinite Duration with the opposite sign.
+// REQUIRES: IsInfiniteDuration(d)
+constexpr Duration OppositeInfinity(Duration d) {
+  return GetRepHi(d) < 0
+             ? MakeDuration((std::numeric_limits<int64_t>::max)(), ~uint32_t{0})
+             : MakeDuration((std::numeric_limits<int64_t>::min)(),
+                            ~uint32_t{0});
+}
+
+// Returns (-n)-1 (equivalently -(n+1)) without avoidable overflow.
+constexpr int64_t NegateAndSubtractOne(int64_t n) {
+  // Note: Good compilers will optimize this expression to ~n when using
+  // a two's-complement representation (which is required for int64_t).
+  return (n < 0) ? -(n + 1) : (-n) - 1;
+}
+
+// Map between a Time and a Duration since the Unix epoch.  Note that these
+// functions depend on the above mentioned choice of the Unix epoch for the
+// Time representation (and both need to be Time friends).  Without this
+// knowledge, we would need to add-in/subtract-out UnixEpoch() respectively.
+constexpr Time FromUnixDuration(Duration d) { return Time(d); }
+constexpr Duration ToUnixDuration(Time t) { return t.rep_; }
+
+template <std::intmax_t N>
+constexpr Duration FromInt64(int64_t v, std::ratio<1, N>) {
+  static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
+  // Subsecond ratios cannot overflow.
+  return MakeNormalizedDuration(
+      v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
+}
+constexpr Duration FromInt64(int64_t v, std::ratio<60>) {
+  return (v <= (std::numeric_limits<int64_t>::max)() / 60 &&
+          v >= (std::numeric_limits<int64_t>::min)() / 60)
+             ? MakeDuration(v * 60)
+             : v > 0 ? InfiniteDuration() : -InfiniteDuration();
+}
+constexpr Duration FromInt64(int64_t v, std::ratio<3600>) {
+  return (v <= (std::numeric_limits<int64_t>::max)() / 3600 &&
+          v >= (std::numeric_limits<int64_t>::min)() / 3600)
+             ? MakeDuration(v * 3600)
+             : v > 0 ? InfiniteDuration() : -InfiniteDuration();
+}
+
+// IsValidRep64<T>(0) is true if the expression `int64_t{std::declval<T>()}` is
+// valid. That is, if a T can be assigned to an int64_t without narrowing.
+template <typename T>
+constexpr auto IsValidRep64(int) -> decltype(int64_t{std::declval<T>()} == 0) {
+  return true;
+}
+template <typename T>
+constexpr auto IsValidRep64(char) -> bool {
+  return false;
+}
+
+// Converts a std::chrono::duration to an absl::Duration.
+template <typename Rep, typename Period>
+constexpr Duration FromChrono(const std::chrono::duration<Rep, Period>& d) {
+  static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
+  return FromInt64(int64_t{d.count()}, Period{});
+}
+
+template <typename Ratio>
+int64_t ToInt64(Duration d, Ratio) {
+  // Note: This may be used on MSVC, which may have a system_clock period of
+  // std::ratio<1, 10 * 1000 * 1000>
+  return ToInt64Seconds(d * Ratio::den / Ratio::num);
+}
+// Fastpath implementations for the 6 common duration units.
+inline int64_t ToInt64(Duration d, std::nano) {
+  return ToInt64Nanoseconds(d);
+}
+inline int64_t ToInt64(Duration d, std::micro) {
+  return ToInt64Microseconds(d);
+}
+inline int64_t ToInt64(Duration d, std::milli) {
+  return ToInt64Milliseconds(d);
+}
+inline int64_t ToInt64(Duration d, std::ratio<1>) {
+  return ToInt64Seconds(d);
+}
+inline int64_t ToInt64(Duration d, std::ratio<60>) {
+  return ToInt64Minutes(d);
+}
+inline int64_t ToInt64(Duration d, std::ratio<3600>) {
+  return ToInt64Hours(d);
+}
+
+// Converts an absl::Duration to a chrono duration of type T.
+template <typename T>
+T ToChronoDuration(Duration d) {
+  using Rep = typename T::rep;
+  using Period = typename T::period;
+  static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
+  if (time_internal::IsInfiniteDuration(d))
+    return d < ZeroDuration() ? (T::min)() : (T::max)();
+  const auto v = ToInt64(d, Period{});
+  if (v > (std::numeric_limits<Rep>::max)()) return (T::max)();
+  if (v < (std::numeric_limits<Rep>::min)()) return (T::min)();
+  return T{v};
+}
+
+}  // namespace time_internal
+
+constexpr bool operator<(Duration lhs, Duration rhs) {
+  return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
+             ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
+         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
+             ? time_internal::GetRepLo(lhs) + 1 <
+                   time_internal::GetRepLo(rhs) + 1
+             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
+}
+
+constexpr bool operator==(Duration lhs, Duration rhs) {
+  return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
+         time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
+}
+
+constexpr Duration operator-(Duration d) {
+  // This is a little interesting because of the special cases.
+  //
+  // If rep_lo_ is zero, we have it easy; it's safe to negate rep_hi_, we're
+  // dealing with an integral number of seconds, and the only special case is
+  // the maximum negative finite duration, which can't be negated.
+  //
+  // Infinities stay infinite, and just change direction.
+  //
+  // Finally we're in the case where rep_lo_ is non-zero, and we can borrow
+  // a second's worth of ticks and avoid overflow (as negating int64_t-min + 1
+  // is safe).
+  return time_internal::GetRepLo(d) == 0
+             ? time_internal::GetRepHi(d) ==
+                       (std::numeric_limits<int64_t>::min)()
+                   ? InfiniteDuration()
+                   : time_internal::MakeDuration(-time_internal::GetRepHi(d))
+             : time_internal::IsInfiniteDuration(d)
+                   ? time_internal::OppositeInfinity(d)
+                   : time_internal::MakeDuration(
+                         time_internal::NegateAndSubtractOne(
+                             time_internal::GetRepHi(d)),
+                         time_internal::kTicksPerSecond -
+                             time_internal::GetRepLo(d));
+}
+
+constexpr Duration InfiniteDuration() {
+  return time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
+                                     ~uint32_t{0});
+}
+
+constexpr Duration FromChrono(const std::chrono::nanoseconds& d) {
+  return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::microseconds& d) {
+  return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::milliseconds& d) {
+  return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::seconds& d) {
+  return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::minutes& d) {
+  return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::hours& d) {
+  return time_internal::FromChrono(d);
+}
+
+constexpr Time FromUnixNanos(int64_t ns) {
+  return time_internal::FromUnixDuration(Nanoseconds(ns));
+}
+
+constexpr Time FromUnixMicros(int64_t us) {
+  return time_internal::FromUnixDuration(Microseconds(us));
+}
+
+constexpr Time FromUnixMillis(int64_t ms) {
+  return time_internal::FromUnixDuration(Milliseconds(ms));
+}
+
+constexpr Time FromUnixSeconds(int64_t s) {
+  return time_internal::FromUnixDuration(Seconds(s));
+}
+
+constexpr Time FromTimeT(time_t t) {
+  return time_internal::FromUnixDuration(Seconds(t));
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TIME_TIME_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/any.h b/CAPI/cpp/grpc/include/absl/types/any.h
new file mode 100644
index 0000000..204da26
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/any.h
@@ -0,0 +1,517 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// any.h
+// -----------------------------------------------------------------------------
+//
+// This header file define the `absl::any` type for holding a type-safe value
+// of any type. The 'absl::any` type is useful for providing a way to hold
+// something that is, as yet, unspecified. Such unspecified types
+// traditionally are passed between API boundaries until they are later cast to
+// their "destination" types. To cast to such a destination type, use
+// `absl::any_cast()`. Note that when casting an `absl::any`, you must cast it
+// to an explicit type; implicit conversions will throw.
+//
+// Example:
+//
+//   auto a = absl::any(65);
+//   absl::any_cast<int>(a);         // 65
+//   absl::any_cast<char>(a);        // throws absl::bad_any_cast
+//   absl::any_cast<std::string>(a); // throws absl::bad_any_cast
+//
+// `absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction
+// and is designed to be a drop-in replacement for code compliant with C++17.
+//
+// Traditionally, the behavior of casting to a temporary unspecified type has
+// been accomplished with the `void *` paradigm, where the pointer was to some
+// other unspecified type. `absl::any` provides an "owning" version of `void *`
+// that avoids issues of pointer management.
+//
+// Note: just as in the case of `void *`, use of `absl::any` (and its C++17
+// version `std::any`) is a code smell indicating that your API might not be
+// constructed correctly. We have seen that most uses of `any` are unwarranted,
+// and `absl::any`, like `std::any`, is difficult to use properly. Before using
+// this abstraction, make sure that you should not instead be rewriting your
+// code to be more specific.
+//
+// Abseil has also released an `absl::variant` type (a C++11 compatible version
+// of the C++17 `std::variant`), which is generally preferred for use over
+// `absl::any`.
+#ifndef ABSL_TYPES_ANY_H_
+#define ABSL_TYPES_ANY_H_
+
+#include "absl/base/config.h"
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_USES_STD_ANY
+
+#include <any>  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using std::any;
+using std::any_cast;
+using std::bad_any_cast;
+using std::make_any;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_USES_STD_ANY
+
+#include <algorithm>
+#include <cstddef>
+#include <initializer_list>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+#include "absl/base/internal/fast_type_id.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/bad_any_cast.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+class any;
+
+// swap()
+//
+// Swaps two `absl::any` values. Equivalent to `x.swap(y) where `x` and `y` are
+// `absl::any` types.
+void swap(any& x, any& y) noexcept;
+
+// make_any()
+//
+// Constructs an `absl::any` of type `T` with the given arguments.
+template <typename T, typename... Args>
+any make_any(Args&&... args);
+
+// Overload of `absl::make_any()` for constructing an `absl::any` type from an
+// initializer list.
+template <typename T, typename U, typename... Args>
+any make_any(std::initializer_list<U> il, Args&&... args);
+
+// any_cast()
+//
+// Statically casts the value of a `const absl::any` type to the given type.
+// This function will throw `absl::bad_any_cast` if the stored value type of the
+// `absl::any` does not match the cast.
+//
+// `any_cast()` can also be used to get a reference to the internal storage iff
+// a reference type is passed as its `ValueType`:
+//
+// Example:
+//
+//   absl::any my_any = std::vector<int>();
+//   absl::any_cast<std::vector<int>&>(my_any).push_back(42);
+template <typename ValueType>
+ValueType any_cast(const any& operand);
+
+// Overload of `any_cast()` to statically cast the value of a non-const
+// `absl::any` type to the given type. This function will throw
+// `absl::bad_any_cast` if the stored value type of the `absl::any` does not
+// match the cast.
+template <typename ValueType>
+ValueType any_cast(any& operand);  // NOLINT(runtime/references)
+
+// Overload of `any_cast()` to statically cast the rvalue of an `absl::any`
+// type. This function will throw `absl::bad_any_cast` if the stored value type
+// of the `absl::any` does not match the cast.
+template <typename ValueType>
+ValueType any_cast(any&& operand);
+
+// Overload of `any_cast()` to statically cast the value of a const pointer
+// `absl::any` type to the given pointer type, or `nullptr` if the stored value
+// type of the `absl::any` does not match the cast.
+template <typename ValueType>
+const ValueType* any_cast(const any* operand) noexcept;
+
+// Overload of `any_cast()` to statically cast the value of a pointer
+// `absl::any` type to the given pointer type, or `nullptr` if the stored value
+// type of the `absl::any` does not match the cast.
+template <typename ValueType>
+ValueType* any_cast(any* operand) noexcept;
+
+// -----------------------------------------------------------------------------
+// absl::any
+// -----------------------------------------------------------------------------
+//
+// An `absl::any` object provides the facility to either store an instance of a
+// type, known as the "contained object", or no value. An `absl::any` is used to
+// store values of types that are unknown at compile time. The `absl::any`
+// object, when containing a value, must contain a value type; storing a
+// reference type is neither desired nor supported.
+//
+// An `absl::any` can only store a type that is copy-constructible; move-only
+// types are not allowed within an `any` object.
+//
+// Example:
+//
+//   auto a = absl::any(65);                 // Literal, copyable
+//   auto b = absl::any(std::vector<int>()); // Default-initialized, copyable
+//   std::unique_ptr<Foo> my_foo;
+//   auto c = absl::any(std::move(my_foo));  // Error, not copy-constructible
+//
+// Note that `absl::any` makes use of decayed types (`absl::decay_t` in this
+// context) to remove const-volatile qualifiers (known as "cv qualifiers"),
+// decay functions to function pointers, etc. We essentially "decay" a given
+// type into its essential type.
+//
+// `absl::any` makes use of decayed types when determining the basic type `T` of
+// the value to store in the any's contained object. In the documentation below,
+// we explicitly denote this by using the phrase "a decayed type of `T`".
+//
+// Example:
+//
+//   const int a = 4;
+//   absl::any foo(a);  // Decay ensures we store an "int", not a "const int&".
+//
+//   void my_function() {}
+//   absl::any bar(my_function);  // Decay ensures we store a function pointer.
+//
+// `absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction
+// and is designed to be a drop-in replacement for code compliant with C++17.
+class any {
+ private:
+  template <typename T>
+  struct IsInPlaceType;
+
+ public:
+  // Constructors
+
+  // Constructs an empty `absl::any` object (`any::has_value()` will return
+  // `false`).
+  constexpr any() noexcept;
+
+  // Copy constructs an `absl::any` object with a "contained object" of the
+  // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
+  // `false`.
+  any(const any& other)
+      : obj_(other.has_value() ? other.obj_->Clone()
+                               : std::unique_ptr<ObjInterface>()) {}
+
+  // Move constructs an `absl::any` object with a "contained object" of the
+  // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
+  // `false`).
+  any(any&& other) noexcept = default;
+
+  // Constructs an `absl::any` object with a "contained object" of the decayed
+  // type of `T`, which is initialized via `std::forward<T>(value)`.
+  //
+  // This constructor will not participate in overload resolution if the
+  // decayed type of `T` is not copy-constructible.
+  template <
+      typename T, typename VT = absl::decay_t<T>,
+      absl::enable_if_t<!absl::disjunction<
+          std::is_same<any, VT>, IsInPlaceType<VT>,
+          absl::negation<std::is_copy_constructible<VT> > >::value>* = nullptr>
+  any(T&& value) : obj_(new Obj<VT>(in_place, std::forward<T>(value))) {}
+
+  // Constructs an `absl::any` object with a "contained object" of the decayed
+  // type of `T`, which is initialized via `std::forward<T>(value)`.
+  template <typename T, typename... Args, typename VT = absl::decay_t<T>,
+            absl::enable_if_t<absl::conjunction<
+                std::is_copy_constructible<VT>,
+                std::is_constructible<VT, Args...>>::value>* = nullptr>
+  explicit any(in_place_type_t<T> /*tag*/, Args&&... args)
+      : obj_(new Obj<VT>(in_place, std::forward<Args>(args)...)) {}
+
+  // Constructs an `absl::any` object with a "contained object" of the passed
+  // type `VT` as a decayed type of `T`. `VT` is initialized as if
+  // direct-non-list-initializing an object of type `VT` with the arguments
+  // `initializer_list, std::forward<Args>(args)...`.
+  template <
+      typename T, typename U, typename... Args, typename VT = absl::decay_t<T>,
+      absl::enable_if_t<
+          absl::conjunction<std::is_copy_constructible<VT>,
+                            std::is_constructible<VT, std::initializer_list<U>&,
+                                                  Args...>>::value>* = nullptr>
+  explicit any(in_place_type_t<T> /*tag*/, std::initializer_list<U> ilist,
+               Args&&... args)
+      : obj_(new Obj<VT>(in_place, ilist, std::forward<Args>(args)...)) {}
+
+  // Assignment operators
+
+  // Copy assigns an `absl::any` object with a "contained object" of the
+  // passed type.
+  any& operator=(const any& rhs) {
+    any(rhs).swap(*this);
+    return *this;
+  }
+
+  // Move assigns an `absl::any` object with a "contained object" of the
+  // passed type. `rhs` is left in a valid but otherwise unspecified state.
+  any& operator=(any&& rhs) noexcept {
+    any(std::move(rhs)).swap(*this);
+    return *this;
+  }
+
+  // Assigns an `absl::any` object with a "contained object" of the passed type.
+  template <typename T, typename VT = absl::decay_t<T>,
+            absl::enable_if_t<absl::conjunction<
+                absl::negation<std::is_same<VT, any>>,
+                std::is_copy_constructible<VT>>::value>* = nullptr>
+  any& operator=(T&& rhs) {
+    any tmp(in_place_type_t<VT>(), std::forward<T>(rhs));
+    tmp.swap(*this);
+    return *this;
+  }
+
+  // Modifiers
+
+  // any::emplace()
+  //
+  // Emplaces a value within an `absl::any` object by calling `any::reset()`,
+  // initializing the contained value as if direct-non-list-initializing an
+  // object of type `VT` with the arguments `std::forward<Args>(args)...`, and
+  // returning a reference to the new contained value.
+  //
+  // Note: If an exception is thrown during the call to `VT`'s constructor,
+  // `*this` does not contain a value, and any previously contained value has
+  // been destroyed.
+  template <
+      typename T, typename... Args, typename VT = absl::decay_t<T>,
+      absl::enable_if_t<std::is_copy_constructible<VT>::value &&
+                        std::is_constructible<VT, Args...>::value>* = nullptr>
+  VT& emplace(Args&&... args) {
+    reset();  // NOTE: reset() is required here even in the world of exceptions.
+    Obj<VT>* const object_ptr =
+        new Obj<VT>(in_place, std::forward<Args>(args)...);
+    obj_ = std::unique_ptr<ObjInterface>(object_ptr);
+    return object_ptr->value;
+  }
+
+  // Overload of `any::emplace()` to emplace a value within an `absl::any`
+  // object by calling `any::reset()`, initializing the contained value as if
+  // direct-non-list-initializing an object of type `VT` with the arguments
+  // `initializer_list, std::forward<Args>(args)...`, and returning a reference
+  // to the new contained value.
+  //
+  // Note: If an exception is thrown during the call to `VT`'s constructor,
+  // `*this` does not contain a value, and any previously contained value has
+  // been destroyed. The function shall not participate in overload resolution
+  // unless `is_copy_constructible_v<VT>` is `true` and
+  // `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`.
+  template <
+      typename T, typename U, typename... Args, typename VT = absl::decay_t<T>,
+      absl::enable_if_t<std::is_copy_constructible<VT>::value &&
+                        std::is_constructible<VT, std::initializer_list<U>&,
+                                              Args...>::value>* = nullptr>
+  VT& emplace(std::initializer_list<U> ilist, Args&&... args) {
+    reset();  // NOTE: reset() is required here even in the world of exceptions.
+    Obj<VT>* const object_ptr =
+        new Obj<VT>(in_place, ilist, std::forward<Args>(args)...);
+    obj_ = std::unique_ptr<ObjInterface>(object_ptr);
+    return object_ptr->value;
+  }
+
+  // any::reset()
+  //
+  // Resets the state of the `absl::any` object, destroying the contained object
+  // if present.
+  void reset() noexcept { obj_ = nullptr; }
+
+  // any::swap()
+  //
+  // Swaps the passed value and the value of this `absl::any` object.
+  void swap(any& other) noexcept { obj_.swap(other.obj_); }
+
+  // Observers
+
+  // any::has_value()
+  //
+  // Returns `true` if the `any` object has a contained value, otherwise
+  // returns `false`.
+  bool has_value() const noexcept { return obj_ != nullptr; }
+
+#ifdef ABSL_INTERNAL_HAS_RTTI
+  // Returns: typeid(T) if *this has a contained object of type T, otherwise
+  // typeid(void).
+  const std::type_info& type() const noexcept {
+    if (has_value()) {
+      return obj_->Type();
+    }
+
+    return typeid(void);
+  }
+#endif  // ABSL_INTERNAL_HAS_RTTI
+
+ private:
+  // Tagged type-erased abstraction for holding a cloneable object.
+  class ObjInterface {
+   public:
+    virtual ~ObjInterface() = default;
+    virtual std::unique_ptr<ObjInterface> Clone() const = 0;
+    virtual const void* ObjTypeId() const noexcept = 0;
+#ifdef ABSL_INTERNAL_HAS_RTTI
+    virtual const std::type_info& Type() const noexcept = 0;
+#endif  // ABSL_INTERNAL_HAS_RTTI
+  };
+
+  // Hold a value of some queryable type, with an ability to Clone it.
+  template <typename T>
+  class Obj : public ObjInterface {
+   public:
+    template <typename... Args>
+    explicit Obj(in_place_t /*tag*/, Args&&... args)
+        : value(std::forward<Args>(args)...) {}
+
+    std::unique_ptr<ObjInterface> Clone() const final {
+      return std::unique_ptr<ObjInterface>(new Obj(in_place, value));
+    }
+
+    const void* ObjTypeId() const noexcept final { return IdForType<T>(); }
+
+#ifdef ABSL_INTERNAL_HAS_RTTI
+    const std::type_info& Type() const noexcept final { return typeid(T); }
+#endif  // ABSL_INTERNAL_HAS_RTTI
+
+    T value;
+  };
+
+  std::unique_ptr<ObjInterface> CloneObj() const {
+    if (!obj_) return nullptr;
+    return obj_->Clone();
+  }
+
+  template <typename T>
+  constexpr static const void* IdForType() {
+    // Note: This type dance is to make the behavior consistent with typeid.
+    using NormalizedType =
+        typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+    return base_internal::FastTypeId<NormalizedType>();
+  }
+
+  const void* GetObjTypeId() const {
+    return obj_ ? obj_->ObjTypeId() : base_internal::FastTypeId<void>();
+  }
+
+  // `absl::any` nonmember functions //
+
+  // Description at the declaration site (top of file).
+  template <typename ValueType>
+  friend ValueType any_cast(const any& operand);
+
+  // Description at the declaration site (top of file).
+  template <typename ValueType>
+  friend ValueType any_cast(any& operand);  // NOLINT(runtime/references)
+
+  // Description at the declaration site (top of file).
+  template <typename T>
+  friend const T* any_cast(const any* operand) noexcept;
+
+  // Description at the declaration site (top of file).
+  template <typename T>
+  friend T* any_cast(any* operand) noexcept;
+
+  std::unique_ptr<ObjInterface> obj_;
+};
+
+// -----------------------------------------------------------------------------
+// Implementation Details
+// -----------------------------------------------------------------------------
+
+constexpr any::any() noexcept = default;
+
+template <typename T>
+struct any::IsInPlaceType : std::false_type {};
+
+template <typename T>
+struct any::IsInPlaceType<in_place_type_t<T>> : std::true_type {};
+
+inline void swap(any& x, any& y) noexcept { x.swap(y); }
+
+// Description at the declaration site (top of file).
+template <typename T, typename... Args>
+any make_any(Args&&... args) {
+  return any(in_place_type_t<T>(), std::forward<Args>(args)...);
+}
+
+// Description at the declaration site (top of file).
+template <typename T, typename U, typename... Args>
+any make_any(std::initializer_list<U> il, Args&&... args) {
+  return any(in_place_type_t<T>(), il, std::forward<Args>(args)...);
+}
+
+// Description at the declaration site (top of file).
+template <typename ValueType>
+ValueType any_cast(const any& operand) {
+  using U = typename std::remove_cv<
+      typename std::remove_reference<ValueType>::type>::type;
+  static_assert(std::is_constructible<ValueType, const U&>::value,
+                "Invalid ValueType");
+  auto* const result = (any_cast<U>)(&operand);
+  if (result == nullptr) {
+    any_internal::ThrowBadAnyCast();
+  }
+  return static_cast<ValueType>(*result);
+}
+
+// Description at the declaration site (top of file).
+template <typename ValueType>
+ValueType any_cast(any& operand) {  // NOLINT(runtime/references)
+  using U = typename std::remove_cv<
+      typename std::remove_reference<ValueType>::type>::type;
+  static_assert(std::is_constructible<ValueType, U&>::value,
+                "Invalid ValueType");
+  auto* result = (any_cast<U>)(&operand);
+  if (result == nullptr) {
+    any_internal::ThrowBadAnyCast();
+  }
+  return static_cast<ValueType>(*result);
+}
+
+// Description at the declaration site (top of file).
+template <typename ValueType>
+ValueType any_cast(any&& operand) {
+  using U = typename std::remove_cv<
+      typename std::remove_reference<ValueType>::type>::type;
+  static_assert(std::is_constructible<ValueType, U>::value,
+                "Invalid ValueType");
+  return static_cast<ValueType>(std::move((any_cast<U&>)(operand)));
+}
+
+// Description at the declaration site (top of file).
+template <typename T>
+const T* any_cast(const any* operand) noexcept {
+  using U =
+      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+  return operand && operand->GetObjTypeId() == any::IdForType<U>()
+             ? std::addressof(
+                   static_cast<const any::Obj<U>*>(operand->obj_.get())->value)
+             : nullptr;
+}
+
+// Description at the declaration site (top of file).
+template <typename T>
+T* any_cast(any* operand) noexcept {
+  using U =
+      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+  return operand && operand->GetObjTypeId() == any::IdForType<U>()
+             ? std::addressof(
+                   static_cast<any::Obj<U>*>(operand->obj_.get())->value)
+             : nullptr;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_USES_STD_ANY
+
+#endif  // ABSL_TYPES_ANY_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/bad_any_cast.h b/CAPI/cpp/grpc/include/absl/types/bad_any_cast.h
new file mode 100644
index 0000000..114cef8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/bad_any_cast.h
@@ -0,0 +1,75 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// bad_any_cast.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::bad_any_cast` type.
+
+#ifndef ABSL_TYPES_BAD_ANY_CAST_H_
+#define ABSL_TYPES_BAD_ANY_CAST_H_
+
+#include <typeinfo>
+
+#include "absl/base/config.h"
+
+#ifdef ABSL_USES_STD_ANY
+
+#include <any>
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using std::bad_any_cast;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_USES_STD_ANY
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// bad_any_cast
+// -----------------------------------------------------------------------------
+//
+// An `absl::bad_any_cast` type is an exception type that is thrown when
+// failing to successfully cast the return value of an `absl::any` object.
+//
+// Example:
+//
+//   auto a = absl::any(65);
+//   absl::any_cast<int>(a);         // 65
+//   try {
+//     absl::any_cast<char>(a);
+//   } catch(const absl::bad_any_cast& e) {
+//     std::cout << "Bad any cast: " << e.what() << '\n';
+//   }
+class bad_any_cast : public std::bad_cast {
+ public:
+  ~bad_any_cast() override;
+  const char* what() const noexcept override;
+};
+
+namespace any_internal {
+
+[[noreturn]] void ThrowBadAnyCast();
+
+}  // namespace any_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_USES_STD_ANY
+
+#endif  // ABSL_TYPES_BAD_ANY_CAST_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/bad_optional_access.h b/CAPI/cpp/grpc/include/absl/types/bad_optional_access.h
new file mode 100644
index 0000000..049e72a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/bad_optional_access.h
@@ -0,0 +1,78 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// bad_optional_access.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::bad_optional_access` type.
+
+#ifndef ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
+#define ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
+
+#include <stdexcept>
+
+#include "absl/base/config.h"
+
+#ifdef ABSL_USES_STD_OPTIONAL
+
+#include <optional>
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using std::bad_optional_access;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_USES_STD_OPTIONAL
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// bad_optional_access
+// -----------------------------------------------------------------------------
+//
+// An `absl::bad_optional_access` type is an exception type that is thrown when
+// attempting to access an `absl::optional` object that does not contain a
+// value.
+//
+// Example:
+//
+//   absl::optional<int> o;
+//
+//   try {
+//     int n = o.value();
+//   } catch(const absl::bad_optional_access& e) {
+//     std::cout << "Bad optional access: " << e.what() << '\n';
+//   }
+class bad_optional_access : public std::exception {
+ public:
+  bad_optional_access() = default;
+  ~bad_optional_access() override;
+  const char* what() const noexcept override;
+};
+
+namespace optional_internal {
+
+// throw delegator
+[[noreturn]] ABSL_DLL void throw_bad_optional_access();
+
+}  // namespace optional_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_USES_STD_OPTIONAL
+
+#endif  // ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/bad_variant_access.h b/CAPI/cpp/grpc/include/absl/types/bad_variant_access.h
new file mode 100644
index 0000000..8ab215e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/bad_variant_access.h
@@ -0,0 +1,82 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// bad_variant_access.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::bad_variant_access` type.
+
+#ifndef ABSL_TYPES_BAD_VARIANT_ACCESS_H_
+#define ABSL_TYPES_BAD_VARIANT_ACCESS_H_
+
+#include <stdexcept>
+
+#include "absl/base/config.h"
+
+#ifdef ABSL_USES_STD_VARIANT
+
+#include <variant>
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using std::bad_variant_access;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_USES_STD_VARIANT
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// bad_variant_access
+// -----------------------------------------------------------------------------
+//
+// An `absl::bad_variant_access` type is an exception type that is thrown in
+// the following cases:
+//
+//   * Calling `absl::get(absl::variant) with an index or type that does not
+//     match the currently selected alternative type
+//   * Calling `absl::visit on an `absl::variant` that is in the
+//     `variant::valueless_by_exception` state.
+//
+// Example:
+//
+//   absl::variant<int, std::string> v;
+//   v = 1;
+//   try {
+//     absl::get<std::string>(v);
+//   } catch(const absl::bad_variant_access& e) {
+//     std::cout << "Bad variant access: " << e.what() << '\n';
+//   }
+class bad_variant_access : public std::exception {
+ public:
+  bad_variant_access() noexcept = default;
+  ~bad_variant_access() override;
+  const char* what() const noexcept override;
+};
+
+namespace variant_internal {
+
+[[noreturn]] ABSL_DLL void ThrowBadVariantAccess();
+[[noreturn]] ABSL_DLL void Rethrow();
+
+}  // namespace variant_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_USES_STD_VARIANT
+
+#endif  // ABSL_TYPES_BAD_VARIANT_ACCESS_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/compare.h b/CAPI/cpp/grpc/include/absl/types/compare.h
new file mode 100644
index 0000000..19b076e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/compare.h
@@ -0,0 +1,600 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// compare.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::weak_equality`, `absl::strong_equality`,
+// `absl::partial_ordering`, `absl::weak_ordering`, and `absl::strong_ordering`
+// types for storing the results of three way comparisons.
+//
+// Example:
+//   absl::weak_ordering compare(const std::string& a, const std::string& b);
+//
+// These are C++11 compatible versions of the C++20 corresponding types
+// (`std::weak_equality`, etc.) and are designed to be drop-in replacements
+// for code compliant with C++20.
+
+#ifndef ABSL_TYPES_COMPARE_H_
+#define ABSL_TYPES_COMPARE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <type_traits>
+
+#include "absl/base/attributes.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace compare_internal {
+
+using value_type = int8_t;
+
+template <typename T>
+struct Fail {
+  static_assert(sizeof(T) < 0, "Only literal `0` is allowed.");
+};
+
+// We need the NullPtrT template to avoid triggering the modernize-use-nullptr
+// ClangTidy warning in user code.
+template <typename NullPtrT = std::nullptr_t>
+struct OnlyLiteralZero {
+  constexpr OnlyLiteralZero(NullPtrT) noexcept {}  // NOLINT
+
+  // Fails compilation when `nullptr` or integral type arguments other than
+  // `int` are passed. This constructor doesn't accept `int` because literal `0`
+  // has type `int`. Literal `0` arguments will be implicitly converted to
+  // `std::nullptr_t` and accepted by the above constructor, while other `int`
+  // arguments will fail to be converted and cause compilation failure.
+  template <
+      typename T,
+      typename = typename std::enable_if<
+          std::is_same<T, std::nullptr_t>::value ||
+          (std::is_integral<T>::value && !std::is_same<T, int>::value)>::type,
+      typename = typename Fail<T>::type>
+  OnlyLiteralZero(T);  // NOLINT
+};
+
+enum class eq : value_type {
+  equal = 0,
+  equivalent = equal,
+  nonequal = 1,
+  nonequivalent = nonequal,
+};
+
+enum class ord : value_type { less = -1, greater = 1 };
+
+enum class ncmp : value_type { unordered = -127 };
+
+// Define macros to allow for creation or emulation of C++17 inline variables
+// based on whether the feature is supported. Note: we can't use
+// ABSL_INTERNAL_INLINE_CONSTEXPR here because the variables here are of
+// incomplete types so they need to be defined after the types are complete.
+#ifdef __cpp_inline_variables
+
+// A no-op expansion that can be followed by a semicolon at class level.
+#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) static_assert(true, "")
+
+#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) \
+  static const type name
+
+#define ABSL_COMPARE_INLINE_INIT(type, name, init) \
+  inline constexpr type type::name(init)
+
+#else  // __cpp_inline_variables
+
+#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) \
+  ABSL_CONST_INIT static const T name
+
+// A no-op expansion that can be followed by a semicolon at class level.
+#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) static_assert(true, "")
+
+#define ABSL_COMPARE_INLINE_INIT(type, name, init) \
+  template <typename T>                            \
+  const T compare_internal::type##_base<T>::name(init)
+
+#endif  // __cpp_inline_variables
+
+// These template base classes allow for defining the values of the constants
+// in the header file (for performance) without using inline variables (which
+// aren't available in C++11).
+template <typename T>
+struct weak_equality_base {
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
+};
+
+template <typename T>
+struct strong_equality_base {
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequal);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
+};
+
+template <typename T>
+struct partial_ordering_base {
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(unordered);
+};
+
+template <typename T>
+struct weak_ordering_base {
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+};
+
+template <typename T>
+struct strong_ordering_base {
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+};
+
+}  // namespace compare_internal
+
+class weak_equality
+    : public compare_internal::weak_equality_base<weak_equality> {
+  explicit constexpr weak_equality(compare_internal::eq v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  friend struct compare_internal::weak_equality_base<weak_equality>;
+
+ public:
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, equivalent);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, nonequivalent);
+
+  // Comparisons
+  friend constexpr bool operator==(
+      weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ == 0;
+  }
+  friend constexpr bool operator!=(
+      weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ != 0;
+  }
+  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                   weak_equality v) noexcept {
+    return 0 == v.value_;
+  }
+  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                   weak_equality v) noexcept {
+    return 0 != v.value_;
+  }
+  friend constexpr bool operator==(weak_equality v1,
+                                   weak_equality v2) noexcept {
+    return v1.value_ == v2.value_;
+  }
+  friend constexpr bool operator!=(weak_equality v1,
+                                   weak_equality v2) noexcept {
+    return v1.value_ != v2.value_;
+  }
+
+ private:
+  compare_internal::value_type value_;
+};
+ABSL_COMPARE_INLINE_INIT(weak_equality, equivalent,
+                         compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(weak_equality, nonequivalent,
+                         compare_internal::eq::nonequivalent);
+
+class strong_equality
+    : public compare_internal::strong_equality_base<strong_equality> {
+  explicit constexpr strong_equality(compare_internal::eq v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  friend struct compare_internal::strong_equality_base<strong_equality>;
+
+ public:
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equal);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequal);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equivalent);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequivalent);
+
+  // Conversion
+  constexpr operator weak_equality() const noexcept {  // NOLINT
+    return value_ == 0 ? weak_equality::equivalent
+                       : weak_equality::nonequivalent;
+  }
+  // Comparisons
+  friend constexpr bool operator==(
+      strong_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ == 0;
+  }
+  friend constexpr bool operator!=(
+      strong_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ != 0;
+  }
+  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                   strong_equality v) noexcept {
+    return 0 == v.value_;
+  }
+  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                   strong_equality v) noexcept {
+    return 0 != v.value_;
+  }
+  friend constexpr bool operator==(strong_equality v1,
+                                   strong_equality v2) noexcept {
+    return v1.value_ == v2.value_;
+  }
+  friend constexpr bool operator!=(strong_equality v1,
+                                   strong_equality v2) noexcept {
+    return v1.value_ != v2.value_;
+  }
+
+ private:
+  compare_internal::value_type value_;
+};
+ABSL_COMPARE_INLINE_INIT(strong_equality, equal, compare_internal::eq::equal);
+ABSL_COMPARE_INLINE_INIT(strong_equality, nonequal,
+                         compare_internal::eq::nonequal);
+ABSL_COMPARE_INLINE_INIT(strong_equality, equivalent,
+                         compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(strong_equality, nonequivalent,
+                         compare_internal::eq::nonequivalent);
+
+class partial_ordering
+    : public compare_internal::partial_ordering_base<partial_ordering> {
+  explicit constexpr partial_ordering(compare_internal::eq v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  explicit constexpr partial_ordering(compare_internal::ord v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  explicit constexpr partial_ordering(compare_internal::ncmp v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  friend struct compare_internal::partial_ordering_base<partial_ordering>;
+
+  constexpr bool is_ordered() const noexcept {
+    return value_ !=
+           compare_internal::value_type(compare_internal::ncmp::unordered);
+  }
+
+ public:
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered);
+
+  // Conversion
+  constexpr operator weak_equality() const noexcept {  // NOLINT
+    return value_ == 0 ? weak_equality::equivalent
+                       : weak_equality::nonequivalent;
+  }
+  // Comparisons
+  friend constexpr bool operator==(
+      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.is_ordered() && v.value_ == 0;
+  }
+  friend constexpr bool operator!=(
+      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return !v.is_ordered() || v.value_ != 0;
+  }
+  friend constexpr bool operator<(
+      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.is_ordered() && v.value_ < 0;
+  }
+  friend constexpr bool operator<=(
+      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.is_ordered() && v.value_ <= 0;
+  }
+  friend constexpr bool operator>(
+      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.is_ordered() && v.value_ > 0;
+  }
+  friend constexpr bool operator>=(
+      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.is_ordered() && v.value_ >= 0;
+  }
+  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                   partial_ordering v) noexcept {
+    return v.is_ordered() && 0 == v.value_;
+  }
+  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                   partial_ordering v) noexcept {
+    return !v.is_ordered() || 0 != v.value_;
+  }
+  friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                  partial_ordering v) noexcept {
+    return v.is_ordered() && 0 < v.value_;
+  }
+  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                   partial_ordering v) noexcept {
+    return v.is_ordered() && 0 <= v.value_;
+  }
+  friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                  partial_ordering v) noexcept {
+    return v.is_ordered() && 0 > v.value_;
+  }
+  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                   partial_ordering v) noexcept {
+    return v.is_ordered() && 0 >= v.value_;
+  }
+  friend constexpr bool operator==(partial_ordering v1,
+                                   partial_ordering v2) noexcept {
+    return v1.value_ == v2.value_;
+  }
+  friend constexpr bool operator!=(partial_ordering v1,
+                                   partial_ordering v2) noexcept {
+    return v1.value_ != v2.value_;
+  }
+
+ private:
+  compare_internal::value_type value_;
+};
+ABSL_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
+ABSL_COMPARE_INLINE_INIT(partial_ordering, equivalent,
+                         compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(partial_ordering, greater,
+                         compare_internal::ord::greater);
+ABSL_COMPARE_INLINE_INIT(partial_ordering, unordered,
+                         compare_internal::ncmp::unordered);
+
+class weak_ordering
+    : public compare_internal::weak_ordering_base<weak_ordering> {
+  explicit constexpr weak_ordering(compare_internal::eq v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  explicit constexpr weak_ordering(compare_internal::ord v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  friend struct compare_internal::weak_ordering_base<weak_ordering>;
+
+ public:
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater);
+
+  // Conversions
+  constexpr operator weak_equality() const noexcept {  // NOLINT
+    return value_ == 0 ? weak_equality::equivalent
+                       : weak_equality::nonequivalent;
+  }
+  constexpr operator partial_ordering() const noexcept {  // NOLINT
+    return value_ == 0 ? partial_ordering::equivalent
+                       : (value_ < 0 ? partial_ordering::less
+                                     : partial_ordering::greater);
+  }
+  // Comparisons
+  friend constexpr bool operator==(
+      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ == 0;
+  }
+  friend constexpr bool operator!=(
+      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ != 0;
+  }
+  friend constexpr bool operator<(
+      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ < 0;
+  }
+  friend constexpr bool operator<=(
+      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ <= 0;
+  }
+  friend constexpr bool operator>(
+      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ > 0;
+  }
+  friend constexpr bool operator>=(
+      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ >= 0;
+  }
+  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                   weak_ordering v) noexcept {
+    return 0 == v.value_;
+  }
+  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                   weak_ordering v) noexcept {
+    return 0 != v.value_;
+  }
+  friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                  weak_ordering v) noexcept {
+    return 0 < v.value_;
+  }
+  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                   weak_ordering v) noexcept {
+    return 0 <= v.value_;
+  }
+  friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                  weak_ordering v) noexcept {
+    return 0 > v.value_;
+  }
+  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                   weak_ordering v) noexcept {
+    return 0 >= v.value_;
+  }
+  friend constexpr bool operator==(weak_ordering v1,
+                                   weak_ordering v2) noexcept {
+    return v1.value_ == v2.value_;
+  }
+  friend constexpr bool operator!=(weak_ordering v1,
+                                   weak_ordering v2) noexcept {
+    return v1.value_ != v2.value_;
+  }
+
+ private:
+  compare_internal::value_type value_;
+};
+ABSL_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
+ABSL_COMPARE_INLINE_INIT(weak_ordering, equivalent,
+                         compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(weak_ordering, greater,
+                         compare_internal::ord::greater);
+
+class strong_ordering
+    : public compare_internal::strong_ordering_base<strong_ordering> {
+  explicit constexpr strong_ordering(compare_internal::eq v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  explicit constexpr strong_ordering(compare_internal::ord v) noexcept
+      : value_(static_cast<compare_internal::value_type>(v)) {}
+  friend struct compare_internal::strong_ordering_base<strong_ordering>;
+
+ public:
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent);
+  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater);
+
+  // Conversions
+  constexpr operator weak_equality() const noexcept {  // NOLINT
+    return value_ == 0 ? weak_equality::equivalent
+                       : weak_equality::nonequivalent;
+  }
+  constexpr operator strong_equality() const noexcept {  // NOLINT
+    return value_ == 0 ? strong_equality::equal : strong_equality::nonequal;
+  }
+  constexpr operator partial_ordering() const noexcept {  // NOLINT
+    return value_ == 0 ? partial_ordering::equivalent
+                       : (value_ < 0 ? partial_ordering::less
+                                     : partial_ordering::greater);
+  }
+  constexpr operator weak_ordering() const noexcept {  // NOLINT
+    return value_ == 0
+               ? weak_ordering::equivalent
+               : (value_ < 0 ? weak_ordering::less : weak_ordering::greater);
+  }
+  // Comparisons
+  friend constexpr bool operator==(
+      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ == 0;
+  }
+  friend constexpr bool operator!=(
+      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ != 0;
+  }
+  friend constexpr bool operator<(
+      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ < 0;
+  }
+  friend constexpr bool operator<=(
+      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ <= 0;
+  }
+  friend constexpr bool operator>(
+      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ > 0;
+  }
+  friend constexpr bool operator>=(
+      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
+    return v.value_ >= 0;
+  }
+  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
+                                   strong_ordering v) noexcept {
+    return 0 == v.value_;
+  }
+  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
+                                   strong_ordering v) noexcept {
+    return 0 != v.value_;
+  }
+  friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
+                                  strong_ordering v) noexcept {
+    return 0 < v.value_;
+  }
+  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
+                                   strong_ordering v) noexcept {
+    return 0 <= v.value_;
+  }
+  friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
+                                  strong_ordering v) noexcept {
+    return 0 > v.value_;
+  }
+  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
+                                   strong_ordering v) noexcept {
+    return 0 >= v.value_;
+  }
+  friend constexpr bool operator==(strong_ordering v1,
+                                   strong_ordering v2) noexcept {
+    return v1.value_ == v2.value_;
+  }
+  friend constexpr bool operator!=(strong_ordering v1,
+                                   strong_ordering v2) noexcept {
+    return v1.value_ != v2.value_;
+  }
+
+ private:
+  compare_internal::value_type value_;
+};
+ABSL_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
+ABSL_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
+ABSL_COMPARE_INLINE_INIT(strong_ordering, equivalent,
+                         compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(strong_ordering, greater,
+                         compare_internal::ord::greater);
+
+#undef ABSL_COMPARE_INLINE_BASECLASS_DECL
+#undef ABSL_COMPARE_INLINE_SUBCLASS_DECL
+#undef ABSL_COMPARE_INLINE_INIT
+
+namespace compare_internal {
+// We also provide these comparator adapter functions for internal absl use.
+
+// Helper functions to do a boolean comparison of two keys given a boolean
+// or three-way comparator.
+// SFINAE prevents implicit conversions to bool (such as from int).
+template <typename Bool,
+          absl::enable_if_t<std::is_same<bool, Bool>::value, int> = 0>
+constexpr bool compare_result_as_less_than(const Bool r) { return r; }
+constexpr bool compare_result_as_less_than(const absl::weak_ordering r) {
+  return r < 0;
+}
+
+template <typename Compare, typename K, typename LK>
+constexpr bool do_less_than_comparison(const Compare &compare, const K &x,
+                                       const LK &y) {
+  return compare_result_as_less_than(compare(x, y));
+}
+
+// Helper functions to do a three-way comparison of two keys given a boolean or
+// three-way comparator.
+// SFINAE prevents implicit conversions to int (such as from bool).
+template <typename Int,
+          absl::enable_if_t<std::is_same<int, Int>::value, int> = 0>
+constexpr absl::weak_ordering compare_result_as_ordering(const Int c) {
+  return c < 0 ? absl::weak_ordering::less
+               : c == 0 ? absl::weak_ordering::equivalent
+                        : absl::weak_ordering::greater;
+}
+constexpr absl::weak_ordering compare_result_as_ordering(
+    const absl::weak_ordering c) {
+  return c;
+}
+
+template <
+    typename Compare, typename K, typename LK,
+    absl::enable_if_t<!std::is_same<bool, absl::result_of_t<Compare(
+                                              const K &, const LK &)>>::value,
+                      int> = 0>
+constexpr absl::weak_ordering do_three_way_comparison(const Compare &compare,
+                                                      const K &x, const LK &y) {
+  return compare_result_as_ordering(compare(x, y));
+}
+template <
+    typename Compare, typename K, typename LK,
+    absl::enable_if_t<std::is_same<bool, absl::result_of_t<Compare(
+                                             const K &, const LK &)>>::value,
+                      int> = 0>
+constexpr absl::weak_ordering do_three_way_comparison(const Compare &compare,
+                                                      const K &x, const LK &y) {
+  return compare(x, y) ? absl::weak_ordering::less
+                       : compare(y, x) ? absl::weak_ordering::greater
+                                       : absl::weak_ordering::equivalent;
+}
+
+}  // namespace compare_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TYPES_COMPARE_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_aliases.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_aliases.h
new file mode 100644
index 0000000..0cc6884
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_aliases.h
@@ -0,0 +1,447 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// regularity_aliases.h
+// -----------------------------------------------------------------------------
+//
+// This file contains type aliases of common ConformanceProfiles and Archetypes
+// so that they can be directly used by name without creating them from scratch.
+
+#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
+#define ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
+
+#include "absl/types/internal/conformance_archetype.h"
+#include "absl/types/internal/conformance_profile.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace types_internal {
+
+// Creates both a Profile and a corresponding Archetype with root name "name".
+#define ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(name, ...)                \
+  struct name##Profile : __VA_ARGS__ {};                                    \
+                                                                            \
+  using name##Archetype = ::absl::types_internal::Archetype<name##Profile>; \
+                                                                            \
+  template <class AbslInternalProfileTag>                                   \
+  using name##Archetype##_ = ::absl::types_internal::Archetype<             \
+      ::absl::types_internal::StrongProfileTypedef<name##Profile,           \
+                                                   AbslInternalProfileTag>>
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasTrivialDefaultConstructor,
+    ConformanceProfile<default_constructible::trivial>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowDefaultConstructor,
+    ConformanceProfile<default_constructible::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasDefaultConstructor, ConformanceProfile<default_constructible::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasTrivialMoveConstructor, ConformanceProfile<default_constructible::maybe,
+                                                  move_constructible::trivial>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowMoveConstructor, ConformanceProfile<default_constructible::maybe,
+                                                  move_constructible::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasMoveConstructor,
+    ConformanceProfile<default_constructible::maybe, move_constructible::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasTrivialCopyConstructor,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::trivial>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowCopyConstructor,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasCopyConstructor,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasTrivialMoveAssign,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::trivial>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowMoveAssign,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasMoveAssign,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasTrivialCopyAssign,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::trivial>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowCopyAssign,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasCopyAssign,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasTrivialDestructor,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::trivial>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowDestructor,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasDestructor,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowEquality,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::maybe,
+                       equality_comparable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasEquality,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::maybe,
+                       equality_comparable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowInequality,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::maybe,
+                       equality_comparable::maybe,
+                       inequality_comparable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasInequality,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::maybe,
+                       equality_comparable::maybe, inequality_comparable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowLessThan,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::maybe,
+                       equality_comparable::maybe, inequality_comparable::maybe,
+                       less_than_comparable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasLessThan,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::maybe,
+                       equality_comparable::maybe, inequality_comparable::maybe,
+                       less_than_comparable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowLessEqual,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::maybe,
+                       equality_comparable::maybe, inequality_comparable::maybe,
+                       less_than_comparable::maybe,
+                       less_equal_comparable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasLessEqual,
+    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
+                       copy_constructible::maybe, move_assignable::maybe,
+                       copy_assignable::maybe, destructible::maybe,
+                       equality_comparable::maybe, inequality_comparable::maybe,
+                       less_than_comparable::maybe,
+                       less_equal_comparable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowGreaterEqual,
+    ConformanceProfile<
+        default_constructible::maybe, move_constructible::maybe,
+        copy_constructible::maybe, move_assignable::maybe,
+        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
+        inequality_comparable::maybe, less_than_comparable::maybe,
+        less_equal_comparable::maybe, greater_equal_comparable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasGreaterEqual,
+    ConformanceProfile<
+        default_constructible::maybe, move_constructible::maybe,
+        copy_constructible::maybe, move_assignable::maybe,
+        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
+        inequality_comparable::maybe, less_than_comparable::maybe,
+        less_equal_comparable::maybe, greater_equal_comparable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowGreaterThan,
+    ConformanceProfile<
+        default_constructible::maybe, move_constructible::maybe,
+        copy_constructible::maybe, move_assignable::maybe,
+        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
+        inequality_comparable::maybe, less_than_comparable::maybe,
+        less_equal_comparable::maybe, greater_equal_comparable::maybe,
+        greater_than_comparable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasGreaterThan,
+    ConformanceProfile<
+        default_constructible::maybe, move_constructible::maybe,
+        copy_constructible::maybe, move_assignable::maybe,
+        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
+        inequality_comparable::maybe, less_than_comparable::maybe,
+        less_equal_comparable::maybe, greater_equal_comparable::maybe,
+        greater_than_comparable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasNothrowSwap,
+    ConformanceProfile<
+        default_constructible::maybe, move_constructible::maybe,
+        copy_constructible::maybe, move_assignable::maybe,
+        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
+        inequality_comparable::maybe, less_than_comparable::maybe,
+        less_equal_comparable::maybe, greater_equal_comparable::maybe,
+        greater_than_comparable::maybe, swappable::nothrow>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasSwap,
+    ConformanceProfile<
+        default_constructible::maybe, move_constructible::maybe,
+        copy_constructible::maybe, move_assignable::maybe,
+        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
+        inequality_comparable::maybe, less_than_comparable::maybe,
+        less_equal_comparable::maybe, greater_equal_comparable::maybe,
+        greater_than_comparable::maybe, swappable::yes>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HasStdHashSpecialization,
+    ConformanceProfile<
+        default_constructible::maybe, move_constructible::maybe,
+        copy_constructible::maybe, move_assignable::maybe,
+        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
+        inequality_comparable::maybe, less_than_comparable::maybe,
+        less_equal_comparable::maybe, greater_equal_comparable::maybe,
+        greater_than_comparable::maybe, swappable::maybe, hashable::yes>);
+
+////////////////////////////////////////////////////////////////////////////////
+////     The remaining aliases are combinations of the previous aliases.    ////
+////////////////////////////////////////////////////////////////////////////////
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    Equatable, CombineProfiles<HasEqualityProfile, HasInequalityProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    Comparable,
+    CombineProfiles<EquatableProfile, HasLessThanProfile, HasLessEqualProfile,
+                    HasGreaterEqualProfile, HasGreaterThanProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    NothrowEquatable,
+    CombineProfiles<HasNothrowEqualityProfile, HasNothrowInequalityProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    NothrowComparable,
+    CombineProfiles<NothrowEquatableProfile, HasNothrowLessThanProfile,
+                    HasNothrowLessEqualProfile, HasNothrowGreaterEqualProfile,
+                    HasNothrowGreaterThanProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    Value,
+    CombineProfiles<HasNothrowMoveConstructorProfile, HasCopyConstructorProfile,
+                    HasNothrowMoveAssignProfile, HasCopyAssignProfile,
+                    HasNothrowDestructorProfile, HasNothrowSwapProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    EquatableValue, CombineProfiles<EquatableProfile, ValueProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    ComparableValue, CombineProfiles<ComparableProfile, ValueProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    DefaultConstructibleValue,
+    CombineProfiles<HasDefaultConstructorProfile, ValueProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    NothrowMoveConstructible, CombineProfiles<HasNothrowMoveConstructorProfile,
+                                              HasNothrowDestructorProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    EquatableNothrowMoveConstructible,
+    CombineProfiles<EquatableProfile, NothrowMoveConstructibleProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    ComparableNothrowMoveConstructible,
+    CombineProfiles<ComparableProfile, NothrowMoveConstructibleProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    DefaultConstructibleNothrowMoveConstructible,
+    CombineProfiles<HasDefaultConstructorProfile,
+                    NothrowMoveConstructibleProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    CopyConstructible,
+    CombineProfiles<HasNothrowMoveConstructorProfile, HasCopyConstructorProfile,
+                    HasNothrowDestructorProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    EquatableCopyConstructible,
+    CombineProfiles<EquatableProfile, CopyConstructibleProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    ComparableCopyConstructible,
+    CombineProfiles<ComparableProfile, CopyConstructibleProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    DefaultConstructibleCopyConstructible,
+    CombineProfiles<HasDefaultConstructorProfile, CopyConstructibleProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    NothrowMovable,
+    CombineProfiles<HasNothrowMoveConstructorProfile,
+                    HasNothrowMoveAssignProfile, HasNothrowDestructorProfile,
+                    HasNothrowSwapProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    EquatableNothrowMovable,
+    CombineProfiles<EquatableProfile, NothrowMovableProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    ComparableNothrowMovable,
+    CombineProfiles<ComparableProfile, NothrowMovableProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    DefaultConstructibleNothrowMovable,
+    CombineProfiles<HasDefaultConstructorProfile, NothrowMovableProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    TrivialSpecialMemberFunctions,
+    CombineProfiles<HasTrivialDefaultConstructorProfile,
+                    HasTrivialMoveConstructorProfile,
+                    HasTrivialCopyConstructorProfile,
+                    HasTrivialMoveAssignProfile, HasTrivialCopyAssignProfile,
+                    HasTrivialDestructorProfile, HasNothrowSwapProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    TriviallyComplete,
+    CombineProfiles<TrivialSpecialMemberFunctionsProfile, ComparableProfile,
+                    HasStdHashSpecializationProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HashableNothrowMoveConstructible,
+    CombineProfiles<HasStdHashSpecializationProfile,
+                    NothrowMoveConstructibleProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HashableCopyConstructible,
+    CombineProfiles<HasStdHashSpecializationProfile, CopyConstructibleProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HashableNothrowMovable,
+    CombineProfiles<HasStdHashSpecializationProfile, NothrowMovableProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    HashableValue,
+    CombineProfiles<HasStdHashSpecializationProfile, ValueProfile>);
+
+ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+    ComparableHashableValue,
+    CombineProfiles<HashableValueProfile, ComparableProfile>);
+
+// The "preferred" profiles that we support in Abseil.
+template <template <class...> class Receiver>
+using ExpandBasicProfiles =
+    Receiver<NothrowMoveConstructibleProfile, CopyConstructibleProfile,
+             NothrowMovableProfile, ValueProfile>;
+
+// The basic profiles except that they are also all Equatable.
+template <template <class...> class Receiver>
+using ExpandBasicEquatableProfiles =
+    Receiver<EquatableNothrowMoveConstructibleProfile,
+             EquatableCopyConstructibleProfile, EquatableNothrowMovableProfile,
+             EquatableValueProfile>;
+
+// The basic profiles except that they are also all Comparable.
+template <template <class...> class Receiver>
+using ExpandBasicComparableProfiles =
+    Receiver<ComparableNothrowMoveConstructibleProfile,
+             ComparableCopyConstructibleProfile,
+             ComparableNothrowMovableProfile, ComparableValueProfile>;
+
+// The basic profiles except that they are also all Hashable.
+template <template <class...> class Receiver>
+using ExpandBasicHashableProfiles =
+    Receiver<HashableNothrowMoveConstructibleProfile,
+             HashableCopyConstructibleProfile, HashableNothrowMovableProfile,
+             HashableValueProfile>;
+
+// The basic profiles except that they are also all DefaultConstructible.
+template <template <class...> class Receiver>
+using ExpandBasicDefaultConstructibleProfiles =
+    Receiver<DefaultConstructibleNothrowMoveConstructibleProfile,
+             DefaultConstructibleCopyConstructibleProfile,
+             DefaultConstructibleNothrowMovableProfile,
+             DefaultConstructibleValueProfile>;
+
+// The type profiles that we support in Abseil (all of the previous lists).
+template <template <class...> class Receiver>
+using ExpandSupportedProfiles = Receiver<
+    NothrowMoveConstructibleProfile, CopyConstructibleProfile,
+    NothrowMovableProfile, ValueProfile,
+    EquatableNothrowMoveConstructibleProfile, EquatableCopyConstructibleProfile,
+    EquatableNothrowMovableProfile, EquatableValueProfile,
+    ComparableNothrowMoveConstructibleProfile,
+    ComparableCopyConstructibleProfile, ComparableNothrowMovableProfile,
+    ComparableValueProfile, DefaultConstructibleNothrowMoveConstructibleProfile,
+    DefaultConstructibleCopyConstructibleProfile,
+    DefaultConstructibleNothrowMovableProfile, DefaultConstructibleValueProfile,
+    HashableNothrowMoveConstructibleProfile, HashableCopyConstructibleProfile,
+    HashableNothrowMovableProfile, HashableValueProfile>;
+
+// TODO(calabrese) Include types that have throwing move constructors, since in
+// practice we still need to support them because of standard library types with
+// (potentially) non-noexcept moves.
+
+}  // namespace types_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#undef ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS
+
+#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_archetype.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_archetype.h
new file mode 100644
index 0000000..2349e0f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_archetype.h
@@ -0,0 +1,978 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// conformance_archetype.h
+// -----------------------------------------------------------------------------
+//
+// This file contains a facility for generating "archetypes" of out of
+// "Conformance Profiles" (see "conformance_profiles.h" for more information
+// about Conformance Profiles). An archetype is a type that aims to support the
+// bare minimum requirements of a given Conformance Profile. For instance, an
+// archetype that corresponds to an ImmutableProfile has exactly a nothrow
+// move-constructor, a potentially-throwing copy constructor, a nothrow
+// destructor, with all other special-member-functions deleted. These archetypes
+// are useful for testing to make sure that templates are able to work with the
+// kinds of types that they claim to support (i.e. that they do not accidentally
+// under-constrain),
+//
+// The main type template in this file is the Archetype template, which takes
+// a Conformance Profile as a template argument and its instantiations are a
+// minimum-conforming model of that profile.
+
+#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
+#define ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
+
+#include <cstddef>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+#include "absl/types/internal/conformance_profile.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace types_internal {
+
+// A minimum-conforming implementation of a type with properties specified in
+// `Prof`, where `Prof` is a valid Conformance Profile.
+template <class Prof, class /*Enabler*/ = void>
+class Archetype;
+
+// Given an Archetype, obtain the properties of the profile associated with that
+// archetype.
+template <class Archetype>
+struct PropertiesOfArchetype;
+
+template <class Prof>
+struct PropertiesOfArchetype<Archetype<Prof>> {
+  using type = PropertiesOfT<Prof>;
+};
+
+template <class Archetype>
+using PropertiesOfArchetypeT = typename PropertiesOfArchetype<Archetype>::type;
+
+// A metafunction to determine if a type is an `Archetype`.
+template <class T>
+struct IsArchetype : std::false_type {};
+
+template <class Prof>
+struct IsArchetype<Archetype<Prof>> : std::true_type {};
+
+// A constructor tag type used when creating an Archetype with internal state.
+struct MakeArchetypeState {};
+
+// Data stored within an archetype that is copied/compared/hashed when the
+// corresponding operations are used.
+using ArchetypeState = std::size_t;
+
+////////////////////////////////////////////////////////////////////////////////
+//   This section of the file defines a chain of base classes for Archetype,  //
+//   where each base defines a specific special member function with the      //
+//   appropriate properties (deleted, noexcept(false), noexcept, or trivial). //
+////////////////////////////////////////////////////////////////////////////////
+
+// The bottom-most base, which contains the state and the default constructor.
+template <default_constructible DefaultConstructibleValue>
+struct ArchetypeStateBase {
+  static_assert(DefaultConstructibleValue == default_constructible::yes ||
+                    DefaultConstructibleValue == default_constructible::nothrow,
+                "");
+
+  ArchetypeStateBase() noexcept(
+      DefaultConstructibleValue ==
+      default_constructible::
+          nothrow) /*Vacuous archetype_state initialization*/ {}
+  explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
+      : archetype_state(state) {}
+
+  ArchetypeState archetype_state;
+};
+
+template <>
+struct ArchetypeStateBase<default_constructible::maybe> {
+  explicit ArchetypeStateBase() = delete;
+  explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
+      : archetype_state(state) {}
+
+  ArchetypeState archetype_state;
+};
+
+template <>
+struct ArchetypeStateBase<default_constructible::trivial> {
+  ArchetypeStateBase() = default;
+  explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
+      : archetype_state(state) {}
+
+  ArchetypeState archetype_state;
+};
+
+// The move-constructor base
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue>
+struct ArchetypeMoveConstructor
+    : ArchetypeStateBase<DefaultConstructibleValue> {
+  static_assert(MoveConstructibleValue == move_constructible::yes ||
+                    MoveConstructibleValue == move_constructible::nothrow,
+                "");
+
+  explicit ArchetypeMoveConstructor(MakeArchetypeState,
+                                    ArchetypeState state) noexcept
+      : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(),
+                                                      state) {}
+
+  ArchetypeMoveConstructor() = default;
+  ArchetypeMoveConstructor(ArchetypeMoveConstructor&& other) noexcept(
+      MoveConstructibleValue == move_constructible::nothrow)
+      : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(),
+                                                      other.archetype_state) {}
+  ArchetypeMoveConstructor(const ArchetypeMoveConstructor&) = default;
+  ArchetypeMoveConstructor& operator=(ArchetypeMoveConstructor&&) = default;
+  ArchetypeMoveConstructor& operator=(const ArchetypeMoveConstructor&) =
+      default;
+};
+
+template <default_constructible DefaultConstructibleValue>
+struct ArchetypeMoveConstructor<DefaultConstructibleValue,
+                                move_constructible::trivial>
+    : ArchetypeStateBase<DefaultConstructibleValue> {
+  explicit ArchetypeMoveConstructor(MakeArchetypeState,
+                                    ArchetypeState state) noexcept
+      : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(),
+                                                      state) {}
+
+  ArchetypeMoveConstructor() = default;
+};
+
+// The copy-constructor base
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue>
+struct ArchetypeCopyConstructor
+    : ArchetypeMoveConstructor<DefaultConstructibleValue,
+                               MoveConstructibleValue> {
+  static_assert(CopyConstructibleValue == copy_constructible::yes ||
+                    CopyConstructibleValue == copy_constructible::nothrow,
+                "");
+  explicit ArchetypeCopyConstructor(MakeArchetypeState,
+                                    ArchetypeState state) noexcept
+      : ArchetypeMoveConstructor<DefaultConstructibleValue,
+                                 MoveConstructibleValue>(MakeArchetypeState(),
+                                                         state) {}
+
+  ArchetypeCopyConstructor() = default;
+  ArchetypeCopyConstructor(ArchetypeCopyConstructor&&) = default;
+  ArchetypeCopyConstructor(const ArchetypeCopyConstructor& other) noexcept(
+      CopyConstructibleValue == copy_constructible::nothrow)
+      : ArchetypeMoveConstructor<DefaultConstructibleValue,
+                                 MoveConstructibleValue>(
+            MakeArchetypeState(), other.archetype_state) {}
+  ArchetypeCopyConstructor& operator=(ArchetypeCopyConstructor&&) = default;
+  ArchetypeCopyConstructor& operator=(const ArchetypeCopyConstructor&) =
+      default;
+};
+
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue>
+struct ArchetypeCopyConstructor<DefaultConstructibleValue,
+                                MoveConstructibleValue,
+                                copy_constructible::maybe>
+    : ArchetypeMoveConstructor<DefaultConstructibleValue,
+                               MoveConstructibleValue> {
+  explicit ArchetypeCopyConstructor(MakeArchetypeState,
+                                    ArchetypeState state) noexcept
+      : ArchetypeMoveConstructor<DefaultConstructibleValue,
+                                 MoveConstructibleValue>(MakeArchetypeState(),
+                                                         state) {}
+
+  ArchetypeCopyConstructor() = default;
+  ArchetypeCopyConstructor(ArchetypeCopyConstructor&&) = default;
+  ArchetypeCopyConstructor(const ArchetypeCopyConstructor&) = delete;
+  ArchetypeCopyConstructor& operator=(ArchetypeCopyConstructor&&) = default;
+  ArchetypeCopyConstructor& operator=(const ArchetypeCopyConstructor&) =
+      default;
+};
+
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue>
+struct ArchetypeCopyConstructor<DefaultConstructibleValue,
+                                MoveConstructibleValue,
+                                copy_constructible::trivial>
+    : ArchetypeMoveConstructor<DefaultConstructibleValue,
+                               MoveConstructibleValue> {
+  explicit ArchetypeCopyConstructor(MakeArchetypeState,
+                                    ArchetypeState state) noexcept
+      : ArchetypeMoveConstructor<DefaultConstructibleValue,
+                                 MoveConstructibleValue>(MakeArchetypeState(),
+                                                         state) {}
+
+  ArchetypeCopyConstructor() = default;
+};
+
+// The move-assign base
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue,
+          move_assignable MoveAssignableValue>
+struct ArchetypeMoveAssign
+    : ArchetypeCopyConstructor<DefaultConstructibleValue,
+                               MoveConstructibleValue, CopyConstructibleValue> {
+  static_assert(MoveAssignableValue == move_assignable::yes ||
+                    MoveAssignableValue == move_assignable::nothrow,
+                "");
+  explicit ArchetypeMoveAssign(MakeArchetypeState,
+                               ArchetypeState state) noexcept
+      : ArchetypeCopyConstructor<DefaultConstructibleValue,
+                                 MoveConstructibleValue,
+                                 CopyConstructibleValue>(MakeArchetypeState(),
+                                                         state) {}
+
+  ArchetypeMoveAssign() = default;
+  ArchetypeMoveAssign(ArchetypeMoveAssign&&) = default;
+  ArchetypeMoveAssign(const ArchetypeMoveAssign&) = default;
+  ArchetypeMoveAssign& operator=(ArchetypeMoveAssign&& other) noexcept(
+      MoveAssignableValue == move_assignable::nothrow) {
+    this->archetype_state = other.archetype_state;
+    return *this;
+  }
+
+  ArchetypeMoveAssign& operator=(const ArchetypeMoveAssign&) = default;
+};
+
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue>
+struct ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                           CopyConstructibleValue, move_assignable::trivial>
+    : ArchetypeCopyConstructor<DefaultConstructibleValue,
+                               MoveConstructibleValue, CopyConstructibleValue> {
+  explicit ArchetypeMoveAssign(MakeArchetypeState,
+                               ArchetypeState state) noexcept
+      : ArchetypeCopyConstructor<DefaultConstructibleValue,
+                                 MoveConstructibleValue,
+                                 CopyConstructibleValue>(MakeArchetypeState(),
+                                                         state) {}
+
+  ArchetypeMoveAssign() = default;
+};
+
+// The copy-assign base
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue,
+          move_assignable MoveAssignableValue,
+          copy_assignable CopyAssignableValue>
+struct ArchetypeCopyAssign
+    : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                          CopyConstructibleValue, MoveAssignableValue> {
+  static_assert(CopyAssignableValue == copy_assignable::yes ||
+                    CopyAssignableValue == copy_assignable::nothrow,
+                "");
+  explicit ArchetypeCopyAssign(MakeArchetypeState,
+                               ArchetypeState state) noexcept
+      : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                            CopyConstructibleValue, MoveAssignableValue>(
+            MakeArchetypeState(), state) {}
+
+  ArchetypeCopyAssign() = default;
+  ArchetypeCopyAssign(ArchetypeCopyAssign&&) = default;
+  ArchetypeCopyAssign(const ArchetypeCopyAssign&) = default;
+  ArchetypeCopyAssign& operator=(ArchetypeCopyAssign&&) = default;
+
+  ArchetypeCopyAssign& operator=(const ArchetypeCopyAssign& other) noexcept(
+      CopyAssignableValue == copy_assignable::nothrow) {
+    this->archetype_state = other.archetype_state;
+    return *this;
+  }
+};
+
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue,
+          move_assignable MoveAssignableValue>
+struct ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                           CopyConstructibleValue, MoveAssignableValue,
+                           copy_assignable::maybe>
+    : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                          CopyConstructibleValue, MoveAssignableValue> {
+  explicit ArchetypeCopyAssign(MakeArchetypeState,
+                               ArchetypeState state) noexcept
+      : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                            CopyConstructibleValue, MoveAssignableValue>(
+            MakeArchetypeState(), state) {}
+
+  ArchetypeCopyAssign() = default;
+  ArchetypeCopyAssign(ArchetypeCopyAssign&&) = default;
+  ArchetypeCopyAssign(const ArchetypeCopyAssign&) = default;
+  ArchetypeCopyAssign& operator=(ArchetypeCopyAssign&&) = default;
+  ArchetypeCopyAssign& operator=(const ArchetypeCopyAssign&) = delete;
+};
+
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue,
+          move_assignable MoveAssignableValue>
+struct ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                           CopyConstructibleValue, MoveAssignableValue,
+                           copy_assignable::trivial>
+    : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                          CopyConstructibleValue, MoveAssignableValue> {
+  explicit ArchetypeCopyAssign(MakeArchetypeState,
+                               ArchetypeState state) noexcept
+      : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                            CopyConstructibleValue, MoveAssignableValue>(
+            MakeArchetypeState(), state) {}
+
+  ArchetypeCopyAssign() = default;
+};
+
+// The destructor base
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue,
+          move_assignable MoveAssignableValue,
+          copy_assignable CopyAssignableValue, destructible DestructibleValue>
+struct ArchetypeDestructor
+    : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                          CopyConstructibleValue, MoveAssignableValue,
+                          CopyAssignableValue> {
+  static_assert(DestructibleValue == destructible::yes ||
+                    DestructibleValue == destructible::nothrow,
+                "");
+
+  explicit ArchetypeDestructor(MakeArchetypeState,
+                               ArchetypeState state) noexcept
+      : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                            CopyConstructibleValue, MoveAssignableValue,
+                            CopyAssignableValue>(MakeArchetypeState(), state) {}
+
+  ArchetypeDestructor() = default;
+  ArchetypeDestructor(ArchetypeDestructor&&) = default;
+  ArchetypeDestructor(const ArchetypeDestructor&) = default;
+  ArchetypeDestructor& operator=(ArchetypeDestructor&&) = default;
+  ArchetypeDestructor& operator=(const ArchetypeDestructor&) = default;
+  ~ArchetypeDestructor() noexcept(DestructibleValue == destructible::nothrow) {}
+};
+
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue,
+          move_assignable MoveAssignableValue,
+          copy_assignable CopyAssignableValue>
+struct ArchetypeDestructor<DefaultConstructibleValue, MoveConstructibleValue,
+                           CopyConstructibleValue, MoveAssignableValue,
+                           CopyAssignableValue, destructible::trivial>
+    : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                          CopyConstructibleValue, MoveAssignableValue,
+                          CopyAssignableValue> {
+  explicit ArchetypeDestructor(MakeArchetypeState,
+                               ArchetypeState state) noexcept
+      : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
+                            CopyConstructibleValue, MoveAssignableValue,
+                            CopyAssignableValue>(MakeArchetypeState(), state) {}
+
+  ArchetypeDestructor() = default;
+};
+
+// An alias to the top of the chain of bases for special-member functions.
+// NOTE: move_constructible::maybe, move_assignable::maybe, and
+// destructible::maybe are handled in the top-level type by way of SFINAE.
+// Because of this, we never instantiate the base classes with
+// move_constructible::maybe, move_assignable::maybe, or destructible::maybe so
+// that we minimize the number of different possible type-template
+// instantiations.
+template <default_constructible DefaultConstructibleValue,
+          move_constructible MoveConstructibleValue,
+          copy_constructible CopyConstructibleValue,
+          move_assignable MoveAssignableValue,
+          copy_assignable CopyAssignableValue, destructible DestructibleValue>
+using ArchetypeSpecialMembersBase = ArchetypeDestructor<
+    DefaultConstructibleValue,
+    MoveConstructibleValue != move_constructible::maybe
+        ? MoveConstructibleValue
+        : move_constructible::nothrow,
+    CopyConstructibleValue,
+    MoveAssignableValue != move_assignable::maybe ? MoveAssignableValue
+                                                  : move_assignable::nothrow,
+    CopyAssignableValue,
+    DestructibleValue != destructible::maybe ? DestructibleValue
+                                             : destructible::nothrow>;
+
+// A function that is used to create an archetype with some associated state.
+template <class Arch>
+Arch MakeArchetype(ArchetypeState state) noexcept {
+  static_assert(IsArchetype<Arch>::value,
+                "The explicit template argument to MakeArchetype is required "
+                "to be an Archetype.");
+  return Arch(MakeArchetypeState(), state);
+}
+
+// This is used to conditionally delete "copy" and "move" constructors in a way
+// that is consistent with what the ConformanceProfile requires and that also
+// strictly enforces the arguments to the copy/move to not come from implicit
+// conversions when dealing with the Archetype.
+template <class Prof, class T>
+constexpr bool ShouldDeleteConstructor() {
+  return !((PropertiesOfT<Prof>::move_constructible_support !=
+                move_constructible::maybe &&
+            std::is_same<T, Archetype<Prof>>::value) ||
+           (PropertiesOfT<Prof>::copy_constructible_support !=
+                copy_constructible::maybe &&
+            (std::is_same<T, const Archetype<Prof>&>::value ||
+             std::is_same<T, Archetype<Prof>&>::value ||
+             std::is_same<T, const Archetype<Prof>>::value)));
+}
+
+// This is used to conditionally delete "copy" and "move" assigns in a way
+// that is consistent with what the ConformanceProfile requires and that also
+// strictly enforces the arguments to the copy/move to not come from implicit
+// conversions when dealing with the Archetype.
+template <class Prof, class T>
+constexpr bool ShouldDeleteAssign() {
+  return !(
+      (PropertiesOfT<Prof>::move_assignable_support != move_assignable::maybe &&
+       std::is_same<T, Archetype<Prof>>::value) ||
+      (PropertiesOfT<Prof>::copy_assignable_support != copy_assignable::maybe &&
+       (std::is_same<T, const Archetype<Prof>&>::value ||
+        std::is_same<T, Archetype<Prof>&>::value ||
+        std::is_same<T, const Archetype<Prof>>::value)));
+}
+
+// TODO(calabrese) Inherit from a chain of secondary bases to pull in the
+// associated functions of other concepts.
+template <class Prof, class Enabler>
+class Archetype : ArchetypeSpecialMembersBase<
+                      PropertiesOfT<Prof>::default_constructible_support,
+                      PropertiesOfT<Prof>::move_constructible_support,
+                      PropertiesOfT<Prof>::copy_constructible_support,
+                      PropertiesOfT<Prof>::move_assignable_support,
+                      PropertiesOfT<Prof>::copy_assignable_support,
+                      PropertiesOfT<Prof>::destructible_support> {
+  static_assert(std::is_same<Enabler, void>::value,
+                "An explicit type must not be passed as the second template "
+                "argument to 'Archetype`.");
+
+  // The cases mentioned in these static_asserts are expected to be handled in
+  // the partial template specializations of Archetype that follow this
+  // definition.
+  static_assert(PropertiesOfT<Prof>::destructible_support !=
+                    destructible::maybe,
+                "");
+  static_assert(PropertiesOfT<Prof>::move_constructible_support !=
+                        move_constructible::maybe ||
+                    PropertiesOfT<Prof>::copy_constructible_support ==
+                        copy_constructible::maybe,
+                "");
+  static_assert(PropertiesOfT<Prof>::move_assignable_support !=
+                        move_assignable::maybe ||
+                    PropertiesOfT<Prof>::copy_assignable_support ==
+                        copy_assignable::maybe,
+                "");
+
+ public:
+  Archetype() = default;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+  Archetype(T&&) = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+  Archetype& operator=(T&&) = delete;
+
+  using ArchetypeSpecialMembersBase<
+      PropertiesOfT<Prof>::default_constructible_support,
+      PropertiesOfT<Prof>::move_constructible_support,
+      PropertiesOfT<Prof>::copy_constructible_support,
+      PropertiesOfT<Prof>::move_assignable_support,
+      PropertiesOfT<Prof>::copy_assignable_support,
+      PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+ private:
+  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+      : ArchetypeSpecialMembersBase<
+            PropertiesOfT<Prof>::default_constructible_support,
+            PropertiesOfT<Prof>::move_constructible_support,
+            PropertiesOfT<Prof>::copy_constructible_support,
+            PropertiesOfT<Prof>::move_assignable_support,
+            PropertiesOfT<Prof>::copy_assignable_support,
+            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
+                                                       state) {}
+
+  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+};
+
+template <class Prof>
+class Archetype<Prof, typename std::enable_if<
+                          PropertiesOfT<Prof>::move_constructible_support !=
+                              move_constructible::maybe &&
+                          PropertiesOfT<Prof>::move_assignable_support ==
+                              move_assignable::maybe &&
+                          PropertiesOfT<Prof>::destructible_support !=
+                              destructible::maybe>::type>
+    : ArchetypeSpecialMembersBase<
+          PropertiesOfT<Prof>::default_constructible_support,
+          PropertiesOfT<Prof>::move_constructible_support,
+          PropertiesOfT<Prof>::copy_constructible_support,
+          PropertiesOfT<Prof>::move_assignable_support,
+          PropertiesOfT<Prof>::copy_assignable_support,
+          PropertiesOfT<Prof>::destructible_support> {
+ public:
+  Archetype() = default;
+  Archetype(Archetype&&) = default;
+  Archetype(const Archetype&) = default;
+  Archetype& operator=(Archetype&&) = delete;
+  Archetype& operator=(const Archetype&) = default;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+  Archetype(T&&) = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+  Archetype& operator=(T&&) = delete;
+
+  using ArchetypeSpecialMembersBase<
+      PropertiesOfT<Prof>::default_constructible_support,
+      PropertiesOfT<Prof>::move_constructible_support,
+      PropertiesOfT<Prof>::copy_constructible_support,
+      PropertiesOfT<Prof>::move_assignable_support,
+      PropertiesOfT<Prof>::copy_assignable_support,
+      PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+ private:
+  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+      : ArchetypeSpecialMembersBase<
+            PropertiesOfT<Prof>::default_constructible_support,
+            PropertiesOfT<Prof>::move_constructible_support,
+            PropertiesOfT<Prof>::copy_constructible_support,
+            PropertiesOfT<Prof>::move_assignable_support,
+            PropertiesOfT<Prof>::copy_assignable_support,
+            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
+                                                       state) {}
+
+  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+};
+
+template <class Prof>
+class Archetype<Prof, typename std::enable_if<
+                          PropertiesOfT<Prof>::move_constructible_support ==
+                              move_constructible::maybe &&
+                          PropertiesOfT<Prof>::move_assignable_support ==
+                              move_assignable::maybe &&
+                          PropertiesOfT<Prof>::destructible_support !=
+                              destructible::maybe>::type>
+    : ArchetypeSpecialMembersBase<
+          PropertiesOfT<Prof>::default_constructible_support,
+          PropertiesOfT<Prof>::move_constructible_support,
+          PropertiesOfT<Prof>::copy_constructible_support,
+          PropertiesOfT<Prof>::move_assignable_support,
+          PropertiesOfT<Prof>::copy_assignable_support,
+          PropertiesOfT<Prof>::destructible_support> {
+ public:
+  Archetype() = default;
+  Archetype(Archetype&&) = delete;
+  Archetype(const Archetype&) = default;
+  Archetype& operator=(Archetype&&) = delete;
+  Archetype& operator=(const Archetype&) = default;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+  Archetype(T&&) = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+  Archetype& operator=(T&&) = delete;
+
+  using ArchetypeSpecialMembersBase<
+      PropertiesOfT<Prof>::default_constructible_support,
+      PropertiesOfT<Prof>::move_constructible_support,
+      PropertiesOfT<Prof>::copy_constructible_support,
+      PropertiesOfT<Prof>::move_assignable_support,
+      PropertiesOfT<Prof>::copy_assignable_support,
+      PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+ private:
+  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+      : ArchetypeSpecialMembersBase<
+            PropertiesOfT<Prof>::default_constructible_support,
+            PropertiesOfT<Prof>::move_constructible_support,
+            PropertiesOfT<Prof>::copy_constructible_support,
+            PropertiesOfT<Prof>::move_assignable_support,
+            PropertiesOfT<Prof>::copy_assignable_support,
+            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
+                                                       state) {}
+
+  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+};
+
+template <class Prof>
+class Archetype<Prof, typename std::enable_if<
+                          PropertiesOfT<Prof>::move_constructible_support ==
+                              move_constructible::maybe &&
+                          PropertiesOfT<Prof>::move_assignable_support !=
+                              move_assignable::maybe &&
+                          PropertiesOfT<Prof>::destructible_support !=
+                              destructible::maybe>::type>
+    : ArchetypeSpecialMembersBase<
+          PropertiesOfT<Prof>::default_constructible_support,
+          PropertiesOfT<Prof>::move_constructible_support,
+          PropertiesOfT<Prof>::copy_constructible_support,
+          PropertiesOfT<Prof>::move_assignable_support,
+          PropertiesOfT<Prof>::copy_assignable_support,
+          PropertiesOfT<Prof>::destructible_support> {
+ public:
+  Archetype() = default;
+  Archetype(Archetype&&) = delete;
+  Archetype(const Archetype&) = default;
+  Archetype& operator=(Archetype&&) = default;
+  Archetype& operator=(const Archetype&) = default;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+  Archetype(T&&) = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+  Archetype& operator=(T&&) = delete;
+
+  using ArchetypeSpecialMembersBase<
+      PropertiesOfT<Prof>::default_constructible_support,
+      PropertiesOfT<Prof>::move_constructible_support,
+      PropertiesOfT<Prof>::copy_constructible_support,
+      PropertiesOfT<Prof>::move_assignable_support,
+      PropertiesOfT<Prof>::copy_assignable_support,
+      PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+ private:
+  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+      : ArchetypeSpecialMembersBase<
+            PropertiesOfT<Prof>::default_constructible_support,
+            PropertiesOfT<Prof>::move_constructible_support,
+            PropertiesOfT<Prof>::copy_constructible_support,
+            PropertiesOfT<Prof>::move_assignable_support,
+            PropertiesOfT<Prof>::copy_assignable_support,
+            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
+                                                       state) {}
+
+  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+};
+
+template <class Prof>
+class Archetype<Prof, typename std::enable_if<
+                          PropertiesOfT<Prof>::move_constructible_support !=
+                              move_constructible::maybe &&
+                          PropertiesOfT<Prof>::move_assignable_support ==
+                              move_assignable::maybe &&
+                          PropertiesOfT<Prof>::destructible_support ==
+                              destructible::maybe>::type>
+    : ArchetypeSpecialMembersBase<
+          PropertiesOfT<Prof>::default_constructible_support,
+          PropertiesOfT<Prof>::move_constructible_support,
+          PropertiesOfT<Prof>::copy_constructible_support,
+          PropertiesOfT<Prof>::move_assignable_support,
+          PropertiesOfT<Prof>::copy_assignable_support,
+          PropertiesOfT<Prof>::destructible_support> {
+ public:
+  Archetype() = default;
+  Archetype(Archetype&&) = default;
+  Archetype(const Archetype&) = default;
+  Archetype& operator=(Archetype&&) = delete;
+  Archetype& operator=(const Archetype&) = default;
+  ~Archetype() = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+  Archetype(T&&) = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+  Archetype& operator=(T&&) = delete;
+
+  using ArchetypeSpecialMembersBase<
+      PropertiesOfT<Prof>::default_constructible_support,
+      PropertiesOfT<Prof>::move_constructible_support,
+      PropertiesOfT<Prof>::copy_constructible_support,
+      PropertiesOfT<Prof>::move_assignable_support,
+      PropertiesOfT<Prof>::copy_assignable_support,
+      PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+ private:
+  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+      : ArchetypeSpecialMembersBase<
+            PropertiesOfT<Prof>::default_constructible_support,
+            PropertiesOfT<Prof>::move_constructible_support,
+            PropertiesOfT<Prof>::copy_constructible_support,
+            PropertiesOfT<Prof>::move_assignable_support,
+            PropertiesOfT<Prof>::copy_assignable_support,
+            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
+                                                       state) {}
+
+  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+};
+
+template <class Prof>
+class Archetype<Prof, typename std::enable_if<
+                          PropertiesOfT<Prof>::move_constructible_support ==
+                              move_constructible::maybe &&
+                          PropertiesOfT<Prof>::move_assignable_support ==
+                              move_assignable::maybe &&
+                          PropertiesOfT<Prof>::destructible_support ==
+                              destructible::maybe>::type>
+    : ArchetypeSpecialMembersBase<
+          PropertiesOfT<Prof>::default_constructible_support,
+          PropertiesOfT<Prof>::move_constructible_support,
+          PropertiesOfT<Prof>::copy_constructible_support,
+          PropertiesOfT<Prof>::move_assignable_support,
+          PropertiesOfT<Prof>::copy_assignable_support,
+          PropertiesOfT<Prof>::destructible_support> {
+ public:
+  Archetype() = default;
+  Archetype(Archetype&&) = delete;
+  Archetype(const Archetype&) = default;
+  Archetype& operator=(Archetype&&) = delete;
+  Archetype& operator=(const Archetype&) = default;
+  ~Archetype() = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+  Archetype(T&&) = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+  Archetype& operator=(T&&) = delete;
+
+  using ArchetypeSpecialMembersBase<
+      PropertiesOfT<Prof>::default_constructible_support,
+      PropertiesOfT<Prof>::move_constructible_support,
+      PropertiesOfT<Prof>::copy_constructible_support,
+      PropertiesOfT<Prof>::move_assignable_support,
+      PropertiesOfT<Prof>::copy_assignable_support,
+      PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+ private:
+  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+      : ArchetypeSpecialMembersBase<
+            PropertiesOfT<Prof>::default_constructible_support,
+            PropertiesOfT<Prof>::move_constructible_support,
+            PropertiesOfT<Prof>::copy_constructible_support,
+            PropertiesOfT<Prof>::move_assignable_support,
+            PropertiesOfT<Prof>::copy_assignable_support,
+            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
+                                                       state) {}
+
+  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+};
+
+template <class Prof>
+class Archetype<Prof, typename std::enable_if<
+                          PropertiesOfT<Prof>::move_constructible_support ==
+                              move_constructible::maybe &&
+                          PropertiesOfT<Prof>::move_assignable_support !=
+                              move_assignable::maybe &&
+                          PropertiesOfT<Prof>::destructible_support ==
+                              destructible::maybe>::type>
+    : ArchetypeSpecialMembersBase<
+          PropertiesOfT<Prof>::default_constructible_support,
+          PropertiesOfT<Prof>::move_constructible_support,
+          PropertiesOfT<Prof>::copy_constructible_support,
+          PropertiesOfT<Prof>::move_assignable_support,
+          PropertiesOfT<Prof>::copy_assignable_support,
+          PropertiesOfT<Prof>::destructible_support> {
+ public:
+  Archetype() = default;
+  Archetype(Archetype&&) = delete;
+  Archetype(const Archetype&) = default;
+  Archetype& operator=(Archetype&&) = default;
+  Archetype& operator=(const Archetype&) = default;
+  ~Archetype() = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+  Archetype(T&&) = delete;
+
+  // Disallow moves when requested, and disallow implicit conversions.
+  template <class T, typename std::enable_if<
+                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+  Archetype& operator=(T&&) = delete;
+
+  using ArchetypeSpecialMembersBase<
+      PropertiesOfT<Prof>::default_constructible_support,
+      PropertiesOfT<Prof>::move_constructible_support,
+      PropertiesOfT<Prof>::copy_constructible_support,
+      PropertiesOfT<Prof>::move_assignable_support,
+      PropertiesOfT<Prof>::copy_assignable_support,
+      PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+ private:
+  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+      : ArchetypeSpecialMembersBase<
+            PropertiesOfT<Prof>::default_constructible_support,
+            PropertiesOfT<Prof>::move_constructible_support,
+            PropertiesOfT<Prof>::copy_constructible_support,
+            PropertiesOfT<Prof>::move_assignable_support,
+            PropertiesOfT<Prof>::copy_assignable_support,
+            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
+                                                       state) {}
+
+  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+};
+
+// Explicitly deleted swap for Archetype if the profile does not require swap.
+// It is important to delete it rather than simply leave it out so that the
+// "using std::swap;" idiom will result in this deleted overload being picked.
+template <class Prof,
+          absl::enable_if_t<!PropertiesOfT<Prof>::is_swappable, int> = 0>
+void swap(Archetype<Prof>&, Archetype<Prof>&) = delete;  // NOLINT
+
+// A conditionally-noexcept swap implementation for Archetype when the profile
+// supports swap.
+template <class Prof,
+          absl::enable_if_t<PropertiesOfT<Prof>::is_swappable, int> = 0>
+void swap(Archetype<Prof>& lhs, Archetype<Prof>& rhs)  // NOLINT
+    noexcept(PropertiesOfT<Prof>::swappable_support != swappable::yes) {
+  std::swap(lhs.archetype_state, rhs.archetype_state);
+}
+
+// A convertible-to-bool type that is used as the return type of comparison
+// operators since the standard doesn't always require exactly bool.
+struct NothrowBool {
+  explicit NothrowBool() = delete;
+  ~NothrowBool() = default;
+
+  // TODO(calabrese) Delete the copy constructor in C++17 mode since guaranteed
+  // elision makes it not required when returning from a function.
+  // NothrowBool(NothrowBool const&) = delete;
+
+  NothrowBool& operator=(NothrowBool const&) = delete;
+
+  explicit operator bool() const noexcept { return value; }
+
+  static NothrowBool make(bool const value) noexcept {
+    return NothrowBool(value);
+  }
+
+ private:
+  explicit NothrowBool(bool const value) noexcept : value(value) {}
+
+  bool value;
+};
+
+// A convertible-to-bool type that is used as the return type of comparison
+// operators since the standard doesn't always require exactly bool.
+// Note: ExceptionalBool has a conversion operator that is not noexcept, so
+// that even when a comparison operator is noexcept, that operation may still
+// potentially throw when converted to bool.
+struct ExceptionalBool {
+  explicit ExceptionalBool() = delete;
+  ~ExceptionalBool() = default;
+
+  // TODO(calabrese) Delete the copy constructor in C++17 mode since guaranteed
+  // elision makes it not required when returning from a function.
+  // ExceptionalBool(ExceptionalBool const&) = delete;
+
+  ExceptionalBool& operator=(ExceptionalBool const&) = delete;
+
+  explicit operator bool() const { return value; }  // NOLINT
+
+  static ExceptionalBool make(bool const value) noexcept {
+    return ExceptionalBool(value);
+  }
+
+ private:
+  explicit ExceptionalBool(bool const value) noexcept : value(value) {}
+
+  bool value;
+};
+
+// The following macro is only used as a helper in this file to stamp out
+// comparison operator definitions. It is undefined after usage.
+//
+// NOTE: Non-nothrow operators throw via their result's conversion to bool even
+// though the operation itself is noexcept.
+#define ABSL_TYPES_INTERNAL_OP(enum_name, op)                                \
+  template <class Prof>                                                      \
+  absl::enable_if_t<!PropertiesOfT<Prof>::is_##enum_name, bool> operator op( \
+      const Archetype<Prof>&, const Archetype<Prof>&) = delete;              \
+                                                                             \
+  template <class Prof>                                                      \
+  typename absl::enable_if_t<                                                \
+      PropertiesOfT<Prof>::is_##enum_name,                                   \
+      std::conditional<PropertiesOfT<Prof>::enum_name##_support ==           \
+                           enum_name::nothrow,                               \
+                       NothrowBool, ExceptionalBool>>::type                  \
+  operator op(const Archetype<Prof>& lhs,                                    \
+              const Archetype<Prof>& rhs) noexcept {                         \
+    return absl::conditional_t<                                              \
+        PropertiesOfT<Prof>::enum_name##_support == enum_name::nothrow,      \
+        NothrowBool, ExceptionalBool>::make(lhs.archetype_state op           \
+                                                rhs.archetype_state);        \
+  }
+
+ABSL_TYPES_INTERNAL_OP(equality_comparable, ==);
+ABSL_TYPES_INTERNAL_OP(inequality_comparable, !=);
+ABSL_TYPES_INTERNAL_OP(less_than_comparable, <);
+ABSL_TYPES_INTERNAL_OP(less_equal_comparable, <=);
+ABSL_TYPES_INTERNAL_OP(greater_equal_comparable, >=);
+ABSL_TYPES_INTERNAL_OP(greater_than_comparable, >);
+
+#undef ABSL_TYPES_INTERNAL_OP
+
+// Base class for std::hash specializations when an Archetype doesn't support
+// hashing.
+struct PoisonedHash {
+  PoisonedHash() = delete;
+  PoisonedHash(const PoisonedHash&) = delete;
+  PoisonedHash& operator=(const PoisonedHash&) = delete;
+};
+
+// Base class for std::hash specializations when an Archetype supports hashing.
+template <class Prof>
+struct EnabledHash {
+  using argument_type = Archetype<Prof>;
+  using result_type = std::size_t;
+  result_type operator()(const argument_type& arg) const {
+    return std::hash<ArchetypeState>()(arg.archetype_state);
+  }
+};
+
+}  // namespace types_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+namespace std {
+
+template <class Prof>  // NOLINT
+struct hash<::absl::types_internal::Archetype<Prof>>
+    : conditional<::absl::types_internal::PropertiesOfT<Prof>::is_hashable,
+                  ::absl::types_internal::EnabledHash<Prof>,
+                  ::absl::types_internal::PoisonedHash>::type {};
+
+}  // namespace std
+
+#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_profile.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_profile.h
new file mode 100644
index 0000000..37b017d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_profile.h
@@ -0,0 +1,933 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// conformance_profiles.h
+// -----------------------------------------------------------------------------
+//
+// This file contains templates for representing "Regularity Profiles" and
+// concisely-named versions of commonly used Regularity Profiles.
+//
+// A Regularity Profile is a compile-time description of the types of operations
+// that a given type supports, along with properties of those operations when
+// they do exist. For instance, a Regularity Profile may describe a type that
+// has a move-constructor that is noexcept and a copy constructor that is not
+// noexcept. This description can then be examined and passed around to other
+// templates for the purposes of asserting expectations on user-defined types
+// via a series trait checks, or for determining what kinds of run-time tests
+// are able to be performed.
+//
+// Regularity Profiles are also used when creating "archetypes," which are
+// minimum-conforming types that meet all of the requirements of a given
+// Regularity Profile. For more information regarding archetypes, see
+// "conformance_archetypes.h".
+
+#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
+#define ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
+
+#include <set>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/algorithm/container.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/internal/conformance_testing_helpers.h"
+#include "absl/utility/utility.h"
+
+// TODO(calabrese) Add support for extending profiles.
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace types_internal {
+
+// Converts an enum to its underlying integral value.
+template <typename Enum>
+constexpr absl::underlying_type_t<Enum> UnderlyingValue(Enum value) {
+  return static_cast<absl::underlying_type_t<Enum>>(value);
+}
+
+// A tag type used in place of a matcher when checking that an assertion result
+// does not actually contain any errors.
+struct NoError {};
+
+// -----------------------------------------------------------------------------
+// ConformanceErrors
+// -----------------------------------------------------------------------------
+class ConformanceErrors {
+ public:
+  // Setup the error reporting mechanism by seeding it with the name of the type
+  // that is being tested.
+  explicit ConformanceErrors(std::string type_name)
+      : assertion_result_(false), type_name_(std::move(type_name)) {
+    assertion_result_ << "\n\n"
+                         "Assuming the following type alias:\n"
+                         "\n"
+                         "  using _T = "
+                      << type_name_ << ";\n\n";
+    outputDivider();
+  }
+
+  // Adds the test name to the list of successfully run tests iff it was not
+  // previously reported as failing. This behavior is useful for tests that
+  // have multiple parts, where failures and successes are reported individually
+  // with the same test name.
+  void addTestSuccess(absl::string_view test_name) {
+    auto normalized_test_name = absl::AsciiStrToLower(test_name);
+
+    // If the test is already reported as failing, do not add it to the list of
+    // successes.
+    if (test_failures_.find(normalized_test_name) == test_failures_.end()) {
+      test_successes_.insert(std::move(normalized_test_name));
+    }
+  }
+
+  // Streams a single error description into the internal buffer (a visual
+  // divider is automatically inserted after the error so that multiple errors
+  // are visibly distinct).
+  //
+  // This function increases the error count by 1.
+  //
+  // TODO(calabrese) Determine desired behavior when if this function throws.
+  template <class... P>
+  void addTestFailure(absl::string_view test_name, const P&... args) {
+    // Output a message related to the test failure.
+    assertion_result_ << "\n\n"
+                         "Failed test: "
+                      << test_name << "\n\n";
+    addTestFailureImpl(args...);
+    assertion_result_ << "\n\n";
+    outputDivider();
+
+    auto normalized_test_name = absl::AsciiStrToLower(test_name);
+
+    // If previous parts of this test succeeded, remove it from that set.
+    test_successes_.erase(normalized_test_name);
+
+    // Add the test name to the list of failed tests.
+    test_failures_.insert(std::move(normalized_test_name));
+
+    has_error_ = true;
+  }
+
+  // Convert this object into a testing::AssertionResult instance such that it
+  // can be used with gtest.
+  ::testing::AssertionResult assertionResult() const {
+    return has_error_ ? assertion_result_ : ::testing::AssertionSuccess();
+  }
+
+  // Convert this object into a testing::AssertionResult instance such that it
+  // can be used with gtest. This overload expects errors, using the specified
+  // matcher.
+  ::testing::AssertionResult expectFailedTests(
+      const std::set<std::string>& test_names) const {
+    // Since we are expecting nonconformance, output an error message when the
+    // type actually conformed to the specified profile.
+    if (!has_error_) {
+      return ::testing::AssertionFailure()
+             << "Unexpected conformance of type:\n"
+                "    "
+             << type_name_ << "\n\n";
+    }
+
+    // Get a list of all expected failures that did not actually fail
+    // (or that were not run).
+    std::vector<std::string> nonfailing_tests;
+    absl::c_set_difference(test_names, test_failures_,
+                           std::back_inserter(nonfailing_tests));
+
+    // Get a list of all "expected failures" that were never actually run.
+    std::vector<std::string> unrun_tests;
+    absl::c_set_difference(nonfailing_tests, test_successes_,
+                           std::back_inserter(unrun_tests));
+
+    // Report when the user specified tests that were not run.
+    if (!unrun_tests.empty()) {
+      const bool tests_were_run =
+          !(test_failures_.empty() && test_successes_.empty());
+
+      // Prepare an assertion result used in the case that tests pass that were
+      // expected to fail.
+      ::testing::AssertionResult result = ::testing::AssertionFailure();
+      result << "When testing type:\n    " << type_name_
+             << "\n\nThe following tests were expected to fail but were not "
+                "run";
+
+      if (tests_were_run) result << " (was the test name spelled correctly?)";
+
+      result << ":\n\n";
+
+      // List all of the tests that unexpectedly passed.
+      for (const auto& test_name : unrun_tests) {
+        result << "    " << test_name << "\n";
+      }
+
+      if (!tests_were_run) result << "\nNo tests were run.";
+
+      if (!test_failures_.empty()) {
+        // List test failures
+        result << "\nThe tests that were run and failed are:\n\n";
+        for (const auto& test_name : test_failures_) {
+          result << "    " << test_name << "\n";
+        }
+      }
+
+      if (!test_successes_.empty()) {
+        // List test successes
+        result << "\nThe tests that were run and succeeded are:\n\n";
+        for (const auto& test_name : test_successes_) {
+          result << "    " << test_name << "\n";
+        }
+      }
+
+      return result;
+    }
+
+    // If some tests passed when they were expected to fail, alert the caller.
+    if (nonfailing_tests.empty()) return ::testing::AssertionSuccess();
+
+    // Prepare an assertion result used in the case that tests pass that were
+    // expected to fail.
+    ::testing::AssertionResult unexpected_successes =
+        ::testing::AssertionFailure();
+    unexpected_successes << "When testing type:\n    " << type_name_
+                         << "\n\nThe following tests passed when they were "
+                            "expected to fail:\n\n";
+
+    // List all of the tests that unexpectedly passed.
+    for (const auto& test_name : nonfailing_tests) {
+      unexpected_successes << "    " << test_name << "\n";
+    }
+
+    return unexpected_successes;
+  }
+
+ private:
+  void outputDivider() {
+    assertion_result_ << "========================================";
+  }
+
+  void addTestFailureImpl() {}
+
+  template <class H, class... T>
+  void addTestFailureImpl(const H& head, const T&... tail) {
+    assertion_result_ << head;
+    addTestFailureImpl(tail...);
+  }
+
+  ::testing::AssertionResult assertion_result_;
+  std::set<std::string> test_failures_;
+  std::set<std::string> test_successes_;
+  std::string type_name_;
+  bool has_error_ = false;
+};
+
+template <class T, class /*Enabler*/ = void>
+struct PropertiesOfImpl {};
+
+template <class T>
+struct PropertiesOfImpl<T, absl::void_t<typename T::properties>> {
+  using type = typename T::properties;
+};
+
+template <class T>
+struct PropertiesOfImpl<T, absl::void_t<typename T::profile_alias_of>> {
+  using type = typename PropertiesOfImpl<typename T::profile_alias_of>::type;
+};
+
+template <class T>
+struct PropertiesOf : PropertiesOfImpl<T> {};
+
+template <class T>
+using PropertiesOfT = typename PropertiesOf<T>::type;
+
+// NOTE: These enums use this naming convention to be consistent with the
+// standard trait names, which is useful since it allows us to match up each
+// enum name with a corresponding trait name in macro definitions.
+
+// An enum that describes the various expectations on an operations existence.
+enum class function_support { maybe, yes, nothrow, trivial };
+
+constexpr const char* PessimisticPropertyDescription(function_support v) {
+  return v == function_support::maybe
+             ? "no"
+             : v == function_support::yes
+                   ? "yes, potentially throwing"
+                   : v == function_support::nothrow ? "yes, nothrow"
+                                                    : "yes, trivial";
+}
+
+// Return a string that describes the kind of property support that was
+// expected.
+inline std::string ExpectedFunctionKindList(function_support min,
+                                            function_support max) {
+  if (min == max) {
+    std::string result =
+        absl::StrCat("Expected:\n  ",
+                     PessimisticPropertyDescription(
+                         static_cast<function_support>(UnderlyingValue(min))),
+                     "\n");
+    return result;
+  }
+
+  std::string result = "Expected one of:\n";
+  for (auto curr_support = UnderlyingValue(min);
+       curr_support <= UnderlyingValue(max); ++curr_support) {
+    absl::StrAppend(&result, "  ",
+                    PessimisticPropertyDescription(
+                        static_cast<function_support>(curr_support)),
+                    "\n");
+  }
+
+  return result;
+}
+
+template <class Enum>
+void ExpectModelOfImpl(ConformanceErrors* errors, Enum min_support,
+                       Enum max_support, Enum kind) {
+  const auto kind_value = UnderlyingValue(kind);
+  const auto min_support_value = UnderlyingValue(min_support);
+  const auto max_support_value = UnderlyingValue(max_support);
+
+  if (!(kind_value >= min_support_value && kind_value <= max_support_value)) {
+    errors->addTestFailure(
+        PropertyName(kind), "**Failed property expectation**\n\n",
+        ExpectedFunctionKindList(
+            static_cast<function_support>(min_support_value),
+            static_cast<function_support>(max_support_value)),
+        '\n', "Actual:\n  ",
+        PessimisticPropertyDescription(
+            static_cast<function_support>(kind_value)));
+  } else {
+    errors->addTestSuccess(PropertyName(kind));
+  }
+}
+
+#define ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM(description, name) \
+  enum class name { maybe, yes, nothrow, trivial };                   \
+                                                                      \
+  constexpr const char* PropertyName(name v) { return description; }  \
+  static_assert(true, "")  // Force a semicolon when using this macro.
+
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for default construction",
+                                           default_constructible);
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move construction",
+                                           move_constructible);
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy construction",
+                                           copy_constructible);
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move assignment",
+                                           move_assignable);
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy assignment",
+                                           copy_assignable);
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for destruction",
+                                           destructible);
+
+#undef ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM
+
+#define ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM(description, name)     \
+  enum class name { maybe, yes, nothrow };                           \
+                                                                     \
+  constexpr const char* PropertyName(name v) { return description; } \
+  static_assert(true, "")  // Force a semicolon when using this macro.
+
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for ==", equality_comparable);
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for !=", inequality_comparable);
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <", less_than_comparable);
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <=", less_equal_comparable);
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >=",
+                                      greater_equal_comparable);
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >", greater_than_comparable);
+
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for swap", swappable);
+
+#undef ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM
+
+enum class hashable { maybe, yes };
+
+constexpr const char* PropertyName(hashable v) {
+  return "support for std::hash";
+}
+
+template <class T>
+using AlwaysFalse = std::false_type;
+
+#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(name, property)   \
+  template <class T>                                                        \
+  constexpr property property##_support_of() {                              \
+    return std::is_##property<T>::value                                     \
+               ? std::is_nothrow_##property<T>::value                       \
+                     ? absl::is_trivially_##property<T>::value              \
+                           ? property::trivial                              \
+                           : property::nothrow                              \
+                     : property::yes                                        \
+               : property::maybe;                                           \
+  }                                                                         \
+                                                                            \
+  template <class T, class MinProf, class MaxProf>                          \
+  void ExpectModelOf##name(ConformanceErrors* errors) {                     \
+    (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support, \
+                        PropertiesOfT<MaxProf>::property##_support,         \
+                        property##_support_of<T>());                        \
+  }
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(DefaultConstructible,
+                                                  default_constructible);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveConstructible,
+                                                  move_constructible);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyConstructible,
+                                                  copy_constructible);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveAssignable,
+                                                  move_assignable);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyAssignable,
+                                                  copy_assignable);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(Destructible, destructible);
+
+#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER
+
+void BoolFunction(bool) noexcept;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction for checking if an operation exists through SFINAE.
+//
+// `T` is the type to test and Op is an alias containing the expression to test.
+template <class T, template <class...> class Op, class = void>
+struct IsOpableImpl : std::false_type {};
+
+template <class T, template <class...> class Op>
+struct IsOpableImpl<T, Op, absl::void_t<Op<T>>> : std::true_type {};
+
+template <template <class...> class Op>
+struct IsOpable {
+  template <class T>
+  using apply = typename IsOpableImpl<T, Op>::type;
+};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction for checking if an operation exists and is also noexcept
+// through SFINAE and the noexcept operator.
+///
+// `T` is the type to test and Op is an alias containing the expression to test.
+template <class T, template <class...> class Op, class = void>
+struct IsNothrowOpableImpl : std::false_type {};
+
+template <class T, template <class...> class Op>
+struct IsNothrowOpableImpl<T, Op, absl::enable_if_t<Op<T>::value>>
+    : std::true_type {};
+
+template <template <class...> class Op>
+struct IsNothrowOpable {
+  template <class T>
+  using apply = typename IsNothrowOpableImpl<T, Op>::type;
+};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A macro that produces the necessary function for reporting what kind of
+// support a specific comparison operation has and a function for reporting an
+// error if a given type's support for that operation does not meet the expected
+// requirements.
+#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(name, property, op)      \
+  template <class T,                                                           \
+            class Result = std::integral_constant<                             \
+                bool, noexcept((BoolFunction)(std::declval<const T&>() op      \
+                                                  std::declval<const T&>()))>> \
+  using name = Result;                                                         \
+                                                                               \
+  template <class T>                                                           \
+  constexpr property property##_support_of() {                                 \
+    return IsOpable<name>::apply<T>::value                                     \
+               ? IsNothrowOpable<name>::apply<T>::value ? property::nothrow    \
+                                                        : property::yes        \
+               : property::maybe;                                              \
+  }                                                                            \
+                                                                               \
+  template <class T, class MinProf, class MaxProf>                             \
+  void ExpectModelOf##name(ConformanceErrors* errors) {                        \
+    (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support,    \
+                        PropertiesOfT<MaxProf>::property##_support,            \
+                        property##_support_of<T>());                           \
+  }
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Generate the necessary support-checking and error reporting functions for
+// each of the comparison operators.
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(EqualityComparable,
+                                              equality_comparable, ==);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(InequalityComparable,
+                                              inequality_comparable, !=);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessThanComparable,
+                                              less_than_comparable, <);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessEqualComparable,
+                                              less_equal_comparable, <=);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterEqualComparable,
+                                              greater_equal_comparable, >=);
+
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterThanComparable,
+                                              greater_than_comparable, >);
+
+#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// The necessary support-checking and error-reporting functions for swap.
+template <class T>
+constexpr swappable swappable_support_of() {
+  return type_traits_internal::IsSwappable<T>::value
+             ? type_traits_internal::IsNothrowSwappable<T>::value
+                   ? swappable::nothrow
+                   : swappable::yes
+             : swappable::maybe;
+}
+
+template <class T, class MinProf, class MaxProf>
+void ExpectModelOfSwappable(ConformanceErrors* errors) {
+  (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::swappable_support,
+                      PropertiesOfT<MaxProf>::swappable_support,
+                      swappable_support_of<T>());
+}
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// The necessary support-checking and error-reporting functions for std::hash.
+template <class T>
+constexpr hashable hashable_support_of() {
+  return type_traits_internal::IsHashable<T>::value ? hashable::yes
+                                                    : hashable::maybe;
+}
+
+template <class T, class MinProf, class MaxProf>
+void ExpectModelOfHashable(ConformanceErrors* errors) {
+  (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::hashable_support,
+                      PropertiesOfT<MaxProf>::hashable_support,
+                      hashable_support_of<T>());
+}
+//
+////////////////////////////////////////////////////////////////////////////////
+
+template <
+    default_constructible DefaultConstructibleValue =
+        default_constructible::maybe,
+    move_constructible MoveConstructibleValue = move_constructible::maybe,
+    copy_constructible CopyConstructibleValue = copy_constructible::maybe,
+    move_assignable MoveAssignableValue = move_assignable::maybe,
+    copy_assignable CopyAssignableValue = copy_assignable::maybe,
+    destructible DestructibleValue = destructible::maybe,
+    equality_comparable EqualityComparableValue = equality_comparable::maybe,
+    inequality_comparable InequalityComparableValue =
+        inequality_comparable::maybe,
+    less_than_comparable LessThanComparableValue = less_than_comparable::maybe,
+    less_equal_comparable LessEqualComparableValue =
+        less_equal_comparable::maybe,
+    greater_equal_comparable GreaterEqualComparableValue =
+        greater_equal_comparable::maybe,
+    greater_than_comparable GreaterThanComparableValue =
+        greater_than_comparable::maybe,
+    swappable SwappableValue = swappable::maybe,
+    hashable HashableValue = hashable::maybe>
+struct ConformanceProfile {
+  using properties = ConformanceProfile;
+
+  static constexpr default_constructible
+      default_constructible_support =  // NOLINT
+      DefaultConstructibleValue;
+
+  static constexpr move_constructible move_constructible_support =  // NOLINT
+      MoveConstructibleValue;
+
+  static constexpr copy_constructible copy_constructible_support =  // NOLINT
+      CopyConstructibleValue;
+
+  static constexpr move_assignable move_assignable_support =  // NOLINT
+      MoveAssignableValue;
+
+  static constexpr copy_assignable copy_assignable_support =  // NOLINT
+      CopyAssignableValue;
+
+  static constexpr destructible destructible_support =  // NOLINT
+      DestructibleValue;
+
+  static constexpr equality_comparable equality_comparable_support =  // NOLINT
+      EqualityComparableValue;
+
+  static constexpr inequality_comparable
+      inequality_comparable_support =  // NOLINT
+      InequalityComparableValue;
+
+  static constexpr less_than_comparable
+      less_than_comparable_support =  // NOLINT
+      LessThanComparableValue;
+
+  static constexpr less_equal_comparable
+      less_equal_comparable_support =  // NOLINT
+      LessEqualComparableValue;
+
+  static constexpr greater_equal_comparable
+      greater_equal_comparable_support =  // NOLINT
+      GreaterEqualComparableValue;
+
+  static constexpr greater_than_comparable
+      greater_than_comparable_support =  // NOLINT
+      GreaterThanComparableValue;
+
+  static constexpr swappable swappable_support = SwappableValue;  // NOLINT
+
+  static constexpr hashable hashable_support = HashableValue;  // NOLINT
+
+  static constexpr bool is_default_constructible =  // NOLINT
+      DefaultConstructibleValue != default_constructible::maybe;
+
+  static constexpr bool is_move_constructible =  // NOLINT
+      MoveConstructibleValue != move_constructible::maybe;
+
+  static constexpr bool is_copy_constructible =  // NOLINT
+      CopyConstructibleValue != copy_constructible::maybe;
+
+  static constexpr bool is_move_assignable =  // NOLINT
+      MoveAssignableValue != move_assignable::maybe;
+
+  static constexpr bool is_copy_assignable =  // NOLINT
+      CopyAssignableValue != copy_assignable::maybe;
+
+  static constexpr bool is_destructible =  // NOLINT
+      DestructibleValue != destructible::maybe;
+
+  static constexpr bool is_equality_comparable =  // NOLINT
+      EqualityComparableValue != equality_comparable::maybe;
+
+  static constexpr bool is_inequality_comparable =  // NOLINT
+      InequalityComparableValue != inequality_comparable::maybe;
+
+  static constexpr bool is_less_than_comparable =  // NOLINT
+      LessThanComparableValue != less_than_comparable::maybe;
+
+  static constexpr bool is_less_equal_comparable =  // NOLINT
+      LessEqualComparableValue != less_equal_comparable::maybe;
+
+  static constexpr bool is_greater_equal_comparable =  // NOLINT
+      GreaterEqualComparableValue != greater_equal_comparable::maybe;
+
+  static constexpr bool is_greater_than_comparable =  // NOLINT
+      GreaterThanComparableValue != greater_than_comparable::maybe;
+
+  static constexpr bool is_swappable =  // NOLINT
+      SwappableValue != swappable::maybe;
+
+  static constexpr bool is_hashable =  // NOLINT
+      HashableValue != hashable::maybe;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Compliant SFINAE-friendliness is not always present on the standard library
+// implementations that we support. This helper-struct (and associated enum) is
+// used as a means to conditionally check the hashability support of a type.
+enum class CheckHashability { no, yes };
+
+template <class T, CheckHashability ShouldCheckHashability>
+struct conservative_hashable_support_of;
+
+template <class T>
+struct conservative_hashable_support_of<T, CheckHashability::no> {
+  static constexpr hashable Invoke() { return hashable::maybe; }
+};
+
+template <class T>
+struct conservative_hashable_support_of<T, CheckHashability::yes> {
+  static constexpr hashable Invoke() { return hashable_support_of<T>(); }
+};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// The ConformanceProfile that is expected based on introspection into the type
+// by way of trait checks.
+template <class T, CheckHashability ShouldCheckHashability>
+struct SyntacticConformanceProfileOf {
+  using properties = ConformanceProfile<
+      default_constructible_support_of<T>(), move_constructible_support_of<T>(),
+      copy_constructible_support_of<T>(), move_assignable_support_of<T>(),
+      copy_assignable_support_of<T>(), destructible_support_of<T>(),
+      equality_comparable_support_of<T>(),
+      inequality_comparable_support_of<T>(),
+      less_than_comparable_support_of<T>(),
+      less_equal_comparable_support_of<T>(),
+      greater_equal_comparable_support_of<T>(),
+      greater_than_comparable_support_of<T>(), swappable_support_of<T>(),
+      conservative_hashable_support_of<T, ShouldCheckHashability>::Invoke()>;
+};
+
+#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, name)     \
+  template <default_constructible DefaultConstructibleValue,                   \
+            move_constructible MoveConstructibleValue,                         \
+            copy_constructible CopyConstructibleValue,                         \
+            move_assignable MoveAssignableValue,                               \
+            copy_assignable CopyAssignableValue,                               \
+            destructible DestructibleValue,                                    \
+            equality_comparable EqualityComparableValue,                       \
+            inequality_comparable InequalityComparableValue,                   \
+            less_than_comparable LessThanComparableValue,                      \
+            less_equal_comparable LessEqualComparableValue,                    \
+            greater_equal_comparable GreaterEqualComparableValue,              \
+            greater_than_comparable GreaterThanComparableValue,                \
+            swappable SwappableValue, hashable HashableValue>                  \
+  constexpr type ConformanceProfile<                                           \
+      DefaultConstructibleValue, MoveConstructibleValue,                       \
+      CopyConstructibleValue, MoveAssignableValue, CopyAssignableValue,        \
+      DestructibleValue, EqualityComparableValue, InequalityComparableValue,   \
+      LessThanComparableValue, LessEqualComparableValue,                       \
+      GreaterEqualComparableValue, GreaterThanComparableValue, SwappableValue, \
+      HashableValue>::name
+
+#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(type)           \
+  ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type,            \
+                                                         type##_support); \
+  ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(bool, is_##type)
+
+#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(default_constructible);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_constructible);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_constructible);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_assignable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_assignable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(destructible);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(equality_comparable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(inequality_comparable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_than_comparable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_equal_comparable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_equal_comparable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_than_comparable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(swappable);
+ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(hashable);
+#endif
+
+#undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF
+#undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL
+
+// Retrieve the enum with the minimum underlying value.
+// Note: std::min is not constexpr in C++11, which is why this is necessary.
+template <class H>
+constexpr H MinEnum(H head) {
+  return head;
+}
+
+template <class H, class N, class... T>
+constexpr H MinEnum(H head, N next, T... tail) {
+  return (UnderlyingValue)(head) < (UnderlyingValue)(next)
+             ? (MinEnum)(head, tail...)
+             : (MinEnum)(next, tail...);
+}
+
+template <class... Profs>
+struct MinimalProfiles {
+  static constexpr default_constructible
+      default_constructible_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::default_constructible_support...);
+
+  static constexpr move_constructible move_constructible_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::move_constructible_support...);
+
+  static constexpr copy_constructible copy_constructible_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
+
+  static constexpr move_assignable move_assignable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::move_assignable_support...);
+
+  static constexpr copy_assignable copy_assignable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
+
+  static constexpr destructible destructible_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::destructible_support...);
+
+  static constexpr equality_comparable equality_comparable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
+
+  static constexpr inequality_comparable
+      inequality_comparable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
+
+  static constexpr less_than_comparable
+      less_than_comparable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
+
+  static constexpr less_equal_comparable
+      less_equal_comparable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
+
+  static constexpr greater_equal_comparable
+      greater_equal_comparable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
+
+  static constexpr greater_than_comparable
+      greater_than_comparable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
+
+  static constexpr swappable swappable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::swappable_support...);
+
+  static constexpr hashable hashable_support =  // NOLINT
+      (MinEnum)(PropertiesOfT<Profs>::hashable_support...);
+
+  using properties = ConformanceProfile<
+      default_constructible_support, move_constructible_support,
+      copy_constructible_support, move_assignable_support,
+      copy_assignable_support, destructible_support,
+      equality_comparable_support, inequality_comparable_support,
+      less_than_comparable_support, less_equal_comparable_support,
+      greater_equal_comparable_support, greater_than_comparable_support,
+      swappable_support, hashable_support>;
+};
+
+// Retrieve the enum with the greatest underlying value.
+// Note: std::max is not constexpr in C++11, which is why this is necessary.
+template <class H>
+constexpr H MaxEnum(H head) {
+  return head;
+}
+
+template <class H, class N, class... T>
+constexpr H MaxEnum(H head, N next, T... tail) {
+  return (UnderlyingValue)(next) < (UnderlyingValue)(head)
+             ? (MaxEnum)(head, tail...)
+             : (MaxEnum)(next, tail...);
+}
+
+template <class... Profs>
+struct CombineProfilesImpl {
+  static constexpr default_constructible
+      default_constructible_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::default_constructible_support...);
+
+  static constexpr move_constructible move_constructible_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::move_constructible_support...);
+
+  static constexpr copy_constructible copy_constructible_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
+
+  static constexpr move_assignable move_assignable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::move_assignable_support...);
+
+  static constexpr copy_assignable copy_assignable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
+
+  static constexpr destructible destructible_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::destructible_support...);
+
+  static constexpr equality_comparable equality_comparable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
+
+  static constexpr inequality_comparable
+      inequality_comparable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
+
+  static constexpr less_than_comparable
+      less_than_comparable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
+
+  static constexpr less_equal_comparable
+      less_equal_comparable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
+
+  static constexpr greater_equal_comparable
+      greater_equal_comparable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
+
+  static constexpr greater_than_comparable
+      greater_than_comparable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
+
+  static constexpr swappable swappable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::swappable_support...);
+
+  static constexpr hashable hashable_support =  // NOLINT
+      (MaxEnum)(PropertiesOfT<Profs>::hashable_support...);
+
+  using properties = ConformanceProfile<
+      default_constructible_support, move_constructible_support,
+      copy_constructible_support, move_assignable_support,
+      copy_assignable_support, destructible_support,
+      equality_comparable_support, inequality_comparable_support,
+      less_than_comparable_support, less_equal_comparable_support,
+      greater_equal_comparable_support, greater_than_comparable_support,
+      swappable_support, hashable_support>;
+};
+
+// NOTE: We use this as opposed to a direct alias of CombineProfilesImpl so that
+// when named aliases of CombineProfiles are created (such as in
+// conformance_aliases.h), we only pay for the combination algorithm on the
+// profiles that are actually used.
+template <class... Profs>
+struct CombineProfiles {
+  using profile_alias_of = CombineProfilesImpl<Profs...>;
+};
+
+template <>
+struct CombineProfiles<> {
+  using properties = ConformanceProfile<>;
+};
+
+template <class Profile, class Tag>
+struct StrongProfileTypedef {
+  using properties = PropertiesOfT<Profile>;
+};
+
+template <class T, class /*Enabler*/ = void>
+struct IsProfileImpl : std::false_type {};
+
+template <class T>
+struct IsProfileImpl<T, absl::void_t<PropertiesOfT<T>>> : std::true_type {};
+
+template <class T>
+struct IsProfile : IsProfileImpl<T>::type {};
+
+// A tag that describes which set of properties we will check when the user
+// requires a strict match in conformance (as opposed to a loose match which
+// allows more-refined support of any given operation).
+//
+// Currently only the RegularityDomain exists and it includes all operations
+// that the conformance testing suite knows about. The intent is that if the
+// suite is expanded to support extension, such as for checking conformance of
+// concepts like Iterators or Containers, additional corresponding domains can
+// be created.
+struct RegularityDomain {};
+
+}  // namespace types_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing.h
new file mode 100644
index 0000000..487b0f7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing.h
@@ -0,0 +1,1386 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// conformance_testing.h
+// -----------------------------------------------------------------------------
+//
+
+#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
+#define ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
+
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// Many templates in this file take a `T` and a `Prof` type as explicit       //
+// template arguments. These are a type to be checked and a                   //
+// "Regularity Profile" that describes what operations that type `T` is       //
+// expected to support. See "regularity_profiles.h" for more details          //
+// regarding Regularity Profiles.                                             //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+#include <cstddef>
+#include <set>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "gtest/gtest.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/internal/conformance_aliases.h"
+#include "absl/types/internal/conformance_archetype.h"
+#include "absl/types/internal/conformance_profile.h"
+#include "absl/types/internal/conformance_testing_helpers.h"
+#include "absl/types/internal/parentheses.h"
+#include "absl/types/internal/transform_args.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace types_internal {
+
+// Returns true if the compiler incorrectly greedily instantiates constexpr
+// templates in any unevaluated context.
+constexpr bool constexpr_instantiation_when_unevaluated() {
+#if defined(__apple_build_version__)  // TODO(calabrese) Make more specific
+  return true;
+#elif defined(__clang__)
+  return __clang_major__ < 4;
+#elif defined(__GNUC__)
+  // TODO(calabrese) Figure out why gcc 7 fails (seems like a different bug)
+  return __GNUC__ < 5 || (__GNUC__ == 5 && __GNUC_MINOR__ < 2) || __GNUC__ >= 7;
+#else
+  return false;
+#endif
+}
+
+// Returns true if the standard library being used incorrectly produces an error
+// when instantiating the definition of a poisoned std::hash specialization.
+constexpr bool poisoned_hash_fails_instantiation() {
+#if defined(_MSC_VER) && !defined(_LIBCPP_VERSION)
+  return _MSC_VER < 1914;
+#else
+  return false;
+#endif
+}
+
+template <class Fun>
+struct GeneratorType {
+  decltype(std::declval<const Fun&>()()) operator()() const
+      noexcept(noexcept(std::declval<const Fun&>()())) {
+    return fun();
+  }
+
+  Fun fun;
+  const char* description;
+};
+
+// A "make" function for the GeneratorType template that deduces the function
+// object type.
+template <class Fun,
+          absl::enable_if_t<IsNullaryCallable<Fun>::value>** = nullptr>
+GeneratorType<Fun> Generator(Fun fun, const char* description) {
+  return GeneratorType<Fun>{absl::move(fun), description};
+}
+
+// A type that contains a set of nullary function objects that each return an
+// instance of the same type and value (though possibly different
+// representations, such as +0 and -0 or two vectors with the same elements but
+// with different capacities).
+template <class... Funs>
+struct EquivalenceClassType {
+  std::tuple<GeneratorType<Funs>...> generators;
+};
+
+// A "make" function for the EquivalenceClassType template that deduces the
+// function object types and is constrained such that a user can only pass in
+// function objects that all have the same return type.
+template <class... Funs, absl::enable_if_t<AreGeneratorsWithTheSameReturnType<
+                             Funs...>::value>** = nullptr>
+EquivalenceClassType<Funs...> EquivalenceClass(GeneratorType<Funs>... funs) {
+  return {std::make_tuple(absl::move(funs)...)};
+}
+
+// A type that contains an ordered series of EquivalenceClassTypes, from
+// smallest value to largest value.
+template <class... EqClasses>
+struct OrderedEquivalenceClasses {
+  std::tuple<EqClasses...> eq_classes;
+};
+
+// An object containing the parts of a given (name, initialization expression),
+// and is capable of generating a string that describes the given.
+struct GivenDeclaration {
+  std::string outputDeclaration(std::size_t width) const {
+    const std::size_t indent_size = 2;
+    std::string result = absl::StrCat("  ", name);
+
+    if (!expression.empty()) {
+      // Indent
+      result.resize(indent_size + width, ' ');
+      absl::StrAppend(&result, " = ", expression, ";\n");
+    } else {
+      absl::StrAppend(&result, ";\n");
+    }
+
+    return result;
+  }
+
+  std::string name;
+  std::string expression;
+};
+
+// Produce a string that contains all of the givens of an error report.
+template <class... Decls>
+std::string PrepareGivenContext(const Decls&... decls) {
+  const std::size_t width = (std::max)({decls.name.size()...});
+  return absl::StrCat("Given:\n", decls.outputDeclaration(width)..., "\n");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Function objects that perform a check for each comparison operator         //
+////////////////////////////////////////////////////////////////////////////////
+
+#define ABSL_INTERNAL_EXPECT_OP(name, op)                                   \
+  struct Expect##name {                                                     \
+    template <class T>                                                      \
+    void operator()(absl::string_view test_name, absl::string_view context, \
+                    const T& lhs, const T& rhs, absl::string_view lhs_name, \
+                    absl::string_view rhs_name) const {                     \
+      if (!static_cast<bool>(lhs op rhs)) {                                 \
+        errors->addTestFailure(                                             \
+            test_name, absl::StrCat(context,                                \
+                                    "**Unexpected comparison result**\n"    \
+                                    "\n"                                    \
+                                    "Expression:\n"                         \
+                                    "  ",                                   \
+                                    lhs_name, " " #op " ", rhs_name,        \
+                                    "\n"                                    \
+                                    "\n"                                    \
+                                    "Expected: true\n"                      \
+                                    "  Actual: false"));                    \
+      } else {                                                              \
+        errors->addTestSuccess(test_name);                                  \
+      }                                                                     \
+    }                                                                       \
+                                                                            \
+    ConformanceErrors* errors;                                              \
+  };                                                                        \
+                                                                            \
+  struct ExpectNot##name {                                                  \
+    template <class T>                                                      \
+    void operator()(absl::string_view test_name, absl::string_view context, \
+                    const T& lhs, const T& rhs, absl::string_view lhs_name, \
+                    absl::string_view rhs_name) const {                     \
+      if (lhs op rhs) {                                                     \
+        errors->addTestFailure(                                             \
+            test_name, absl::StrCat(context,                                \
+                                    "**Unexpected comparison result**\n"    \
+                                    "\n"                                    \
+                                    "Expression:\n"                         \
+                                    "  ",                                   \
+                                    lhs_name, " " #op " ", rhs_name,        \
+                                    "\n"                                    \
+                                    "\n"                                    \
+                                    "Expected: false\n"                     \
+                                    "  Actual: true"));                     \
+      } else {                                                              \
+        errors->addTestSuccess(test_name);                                  \
+      }                                                                     \
+    }                                                                       \
+                                                                            \
+    ConformanceErrors* errors;                                              \
+  }
+
+ABSL_INTERNAL_EXPECT_OP(Eq, ==);
+ABSL_INTERNAL_EXPECT_OP(Ne, !=);
+ABSL_INTERNAL_EXPECT_OP(Lt, <);
+ABSL_INTERNAL_EXPECT_OP(Le, <=);
+ABSL_INTERNAL_EXPECT_OP(Ge, >=);
+ABSL_INTERNAL_EXPECT_OP(Gt, >);
+
+#undef ABSL_INTERNAL_EXPECT_OP
+
+// A function object that verifies that two objects hash to the same value by
+// way of the std::hash specialization.
+struct ExpectSameHash {
+  template <class T>
+  void operator()(absl::string_view test_name, absl::string_view context,
+                  const T& lhs, const T& rhs, absl::string_view lhs_name,
+                  absl::string_view rhs_name) const {
+    if (std::hash<T>()(lhs) != std::hash<T>()(rhs)) {
+      errors->addTestFailure(
+          test_name, absl::StrCat(context,
+                                  "**Unexpected hash result**\n"
+                                  "\n"
+                                  "Expression:\n"
+                                  "  std::hash<T>()(",
+                                  lhs_name, ") == std::hash<T>()(", rhs_name,
+                                  ")\n"
+                                  "\n"
+                                  "Expected: true\n"
+                                  "  Actual: false"));
+    } else {
+      errors->addTestSuccess(test_name);
+    }
+  }
+
+  ConformanceErrors* errors;
+};
+
+// A function template that takes two objects and verifies that each comparison
+// operator behaves in a way that is consistent with equality. It has "OneWay"
+// in the name because the first argument will always be the left-hand operand
+// of the corresponding comparison operator and the second argument will
+// always be the right-hand operand. It will never switch that order.
+// At a higher level in the test suite, the one-way form is called once for each
+// of the two possible orders whenever lhs and rhs are not the same initializer.
+template <class T, class Prof>
+void ExpectOneWayEquality(ConformanceErrors* errors,
+                          absl::string_view test_name,
+                          absl::string_view context, const T& lhs, const T& rhs,
+                          absl::string_view lhs_name,
+                          absl::string_view rhs_name) {
+  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
+      ExpectEq{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
+
+  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
+      ExpectNotNe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
+
+  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
+      ExpectNotLt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
+
+  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
+      ExpectLe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
+
+  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
+      ExpectGe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
+
+  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
+      ExpectNotGt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
+
+  If<PropertiesOfT<Prof>::is_hashable>::Invoke(
+      ExpectSameHash{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
+}
+
+// A function template that takes two objects and verifies that each comparison
+// operator behaves in a way that is consistent with equality. This function
+// differs from ExpectOneWayEquality in that this will do checks with argument
+// order reversed in addition to in-order.
+template <class T, class Prof>
+void ExpectEquality(ConformanceErrors* errors, absl::string_view test_name,
+                    absl::string_view context, const T& lhs, const T& rhs,
+                    absl::string_view lhs_name, absl::string_view rhs_name) {
+  (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, lhs, rhs,
+                                  lhs_name, rhs_name);
+  (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, rhs, lhs,
+                                  rhs_name, lhs_name);
+}
+
+// Given a generator, makes sure that a generated value and a moved-from
+// generated value are equal.
+template <class T, class Prof>
+struct ExpectMoveConstructOneGenerator {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    const T object = generator();
+    const T moved_object = absl::move(generator());  // Force no elision.
+
+    (ExpectEquality<T, Prof>)(errors, "Move construction",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"const _T object",
+                                                   generator.description},
+                                  GivenDeclaration{"const _T moved_object",
+                                                   std::string("std::move(") +
+                                                       generator.description +
+                                                       ")"}),
+                              object, moved_object, "object", "moved_object");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Given a generator, makes sure that a generated value and a copied-from
+// generated value are equal.
+template <class T, class Prof>
+struct ExpectCopyConstructOneGenerator {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    const T object = generator();
+    const T copied_object = static_cast<const T&>(generator());
+
+    (ExpectEquality<T, Prof>)(errors, "Copy construction",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"const _T object",
+                                                   generator.description},
+                                  GivenDeclaration{
+                                      "const _T copied_object",
+                                      std::string("static_cast<const _T&>(") +
+                                          generator.description + ")"}),
+                              object, copied_object, "object", "copied_object");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Default-construct and do nothing before destruction.
+//
+// This is useful in exercising the codepath of default construction followed by
+// destruction, but does not explicitly test anything. An example of where this
+// might fail is a default destructor that default-initializes a scalar and a
+// destructor reads the value of that member. Sanitizers can catch this as long
+// as our test attempts to execute such a case.
+template <class T>
+struct ExpectDefaultConstructWithDestruct {
+  void operator()() const {
+    // Scoped so that destructor gets called before reporting success.
+    {
+      T object;
+      static_cast<void>(object);
+    }
+
+    errors->addTestSuccess("Default construction");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Check move-assign into a default-constructed object.
+template <class T, class Prof>
+struct ExpectDefaultConstructWithMoveAssign {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    const T source_of_truth = generator();
+    T object;
+    object = generator();
+
+    (ExpectEquality<T, Prof>)(errors, "Move assignment",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"const _T object",
+                                                   generator.description},
+                                  GivenDeclaration{"_T object", ""},
+                                  GivenDeclaration{"object",
+                                                   generator.description}),
+                              object, source_of_truth, "std::as_const(object)",
+                              "source_of_truth");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Check copy-assign into a default-constructed object.
+template <class T, class Prof>
+struct ExpectDefaultConstructWithCopyAssign {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    const T source_of_truth = generator();
+    T object;
+    object = static_cast<const T&>(generator());
+
+    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"const _T source_of_truth",
+                                                   generator.description},
+                                  GivenDeclaration{"_T object", ""},
+                                  GivenDeclaration{
+                                      "object",
+                                      std::string("static_cast<const _T&>(") +
+                                          generator.description + ")"}),
+                              object, source_of_truth, "std::as_const(object)",
+                              "source_of_truth");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Perform a self move-assign.
+template <class T, class Prof>
+struct ExpectSelfMoveAssign {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    T object = generator();
+    object = absl::move(object);
+
+    // NOTE: Self move-assign results in a valid-but-unspecified state.
+
+    (ExpectEquality<T, Prof>)(errors, "Move assignment",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"_T object",
+                                                   generator.description},
+                                  GivenDeclaration{"object",
+                                                   "std::move(object)"}),
+                              object, object, "object", "object");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Perform a self copy-assign.
+template <class T, class Prof>
+struct ExpectSelfCopyAssign {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    const T source_of_truth = generator();
+    T object = generator();
+    const T& const_object = object;
+    object = const_object;
+
+    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"const _T source_of_truth",
+                                                   generator.description},
+                                  GivenDeclaration{"_T object",
+                                                   generator.description},
+                                  GivenDeclaration{"object",
+                                                   "std::as_const(object)"}),
+                              const_object, source_of_truth,
+                              "std::as_const(object)", "source_of_truth");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Perform a self-swap.
+template <class T, class Prof>
+struct ExpectSelfSwap {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    const T source_of_truth = generator();
+    T object = generator();
+
+    type_traits_internal::Swap(object, object);
+
+    std::string preliminary_info = absl::StrCat(
+        PrepareGivenContext(
+            GivenDeclaration{"const _T source_of_truth", generator.description},
+            GivenDeclaration{"_T object", generator.description}),
+        "After performing a self-swap:\n"
+        "  using std::swap;\n"
+        "  swap(object, object);\n"
+        "\n");
+
+    (ExpectEquality<T, Prof>)(errors, "Swap", std::move(preliminary_info),
+                              object, source_of_truth, "std::as_const(object)",
+                              "source_of_truth");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Perform each of the single-generator checks when necessary operations are
+// supported.
+template <class T, class Prof>
+struct ExpectSelfComparison {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    const T object = generator();
+    (ExpectOneWayEquality<T, Prof>)(errors, "Comparison",
+                                    PrepareGivenContext(GivenDeclaration{
+                                        "const _T object",
+                                        generator.description}),
+                                    object, object, "object", "object");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Perform each of the single-generator checks when necessary operations are
+// supported.
+template <class T, class Prof>
+struct ExpectConsistency {
+  template <class Fun>
+  void operator()(const Fun& generator) const {
+    If<PropertiesOfT<Prof>::is_move_constructible>::Invoke(
+        ExpectMoveConstructOneGenerator<T, Prof>{errors}, generator);
+
+    If<PropertiesOfT<Prof>::is_copy_constructible>::Invoke(
+        ExpectCopyConstructOneGenerator<T, Prof>{errors}, generator);
+
+    If<PropertiesOfT<Prof>::is_default_constructible &&
+       PropertiesOfT<Prof>::is_move_assignable>::
+        Invoke(ExpectDefaultConstructWithMoveAssign<T, Prof>{errors},
+               generator);
+
+    If<PropertiesOfT<Prof>::is_default_constructible &&
+       PropertiesOfT<Prof>::is_copy_assignable>::
+        Invoke(ExpectDefaultConstructWithCopyAssign<T, Prof>{errors},
+               generator);
+
+    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
+        ExpectSelfMoveAssign<T, Prof>{errors}, generator);
+
+    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
+        ExpectSelfCopyAssign<T, Prof>{errors}, generator);
+
+    If<PropertiesOfT<Prof>::is_swappable>::Invoke(
+        ExpectSelfSwap<T, Prof>{errors}, generator);
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Check move-assign with two different values.
+template <class T, class Prof>
+struct ExpectMoveAssign {
+  template <class Fun0, class Fun1>
+  void operator()(const Fun0& generator0, const Fun1& generator1) const {
+    const T source_of_truth1 = generator1();
+    T object = generator0();
+    object = generator1();
+
+    (ExpectEquality<T, Prof>)(errors, "Move assignment",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"const _T source_of_truth1",
+                                                   generator1.description},
+                                  GivenDeclaration{"_T object",
+                                                   generator0.description},
+                                  GivenDeclaration{"object",
+                                                   generator1.description}),
+                              object, source_of_truth1, "std::as_const(object)",
+                              "source_of_truth1");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Check copy-assign with two different values.
+template <class T, class Prof>
+struct ExpectCopyAssign {
+  template <class Fun0, class Fun1>
+  void operator()(const Fun0& generator0, const Fun1& generator1) const {
+    const T source_of_truth1 = generator1();
+    T object = generator0();
+    object = static_cast<const T&>(generator1());
+
+    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"const _T source_of_truth1",
+                                                   generator1.description},
+                                  GivenDeclaration{"_T object",
+                                                   generator0.description},
+                                  GivenDeclaration{
+                                      "object",
+                                      std::string("static_cast<const _T&>(") +
+                                          generator1.description + ")"}),
+                              object, source_of_truth1, "std::as_const(object)",
+                              "source_of_truth1");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Check swap with two different values.
+template <class T, class Prof>
+struct ExpectSwap {
+  template <class Fun0, class Fun1>
+  void operator()(const Fun0& generator0, const Fun1& generator1) const {
+    const T source_of_truth0 = generator0();
+    const T source_of_truth1 = generator1();
+    T object0 = generator0();
+    T object1 = generator1();
+
+    type_traits_internal::Swap(object0, object1);
+
+    const std::string context =
+        PrepareGivenContext(
+            GivenDeclaration{"const _T source_of_truth0",
+                             generator0.description},
+            GivenDeclaration{"const _T source_of_truth1",
+                             generator1.description},
+            GivenDeclaration{"_T object0", generator0.description},
+            GivenDeclaration{"_T object1", generator1.description}) +
+        "After performing a swap:\n"
+        "  using std::swap;\n"
+        "  swap(object0, object1);\n"
+        "\n";
+
+    (ExpectEquality<T, Prof>)(errors, "Swap", context, object0,
+                              source_of_truth1, "std::as_const(object0)",
+                              "source_of_truth1");
+    (ExpectEquality<T, Prof>)(errors, "Swap", context, object1,
+                              source_of_truth0, "std::as_const(object1)",
+                              "source_of_truth0");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Validate that `generator0` and `generator1` produce values that are equal.
+template <class T, class Prof>
+struct ExpectEquivalenceClassComparison {
+  template <class Fun0, class Fun1>
+  void operator()(const Fun0& generator0, const Fun1& generator1) const {
+    const T object0 = generator0();
+    const T object1 = generator1();
+
+    (ExpectEquality<T, Prof>)(errors, "Comparison",
+                              PrepareGivenContext(
+                                  GivenDeclaration{"const _T object0",
+                                                   generator0.description},
+                                  GivenDeclaration{"const _T object1",
+                                                   generator1.description}),
+                              object0, object1, "object0", "object1");
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Validate that all objects in the same equivalence-class have the same value.
+template <class T, class Prof>
+struct ExpectEquivalenceClassConsistency {
+  template <class Fun0, class Fun1>
+  void operator()(const Fun0& generator0, const Fun1& generator1) const {
+    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
+        ExpectMoveAssign<T, Prof>{errors}, generator0, generator1);
+
+    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
+        ExpectCopyAssign<T, Prof>{errors}, generator0, generator1);
+
+    If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors},
+                                                  generator0, generator1);
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Given a "lesser" object and a "greater" object, perform every combination of
+// comparison operators supported for the type, expecting consistent results.
+template <class T, class Prof>
+void ExpectOrdered(ConformanceErrors* errors, absl::string_view context,
+                   const T& small, const T& big, absl::string_view small_name,
+                   absl::string_view big_name) {
+  const absl::string_view test_name = "Comparison";
+
+  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
+      ExpectNotEq{errors}, test_name, context, small, big, small_name,
+      big_name);
+  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
+      ExpectNotEq{errors}, test_name, context, big, small, big_name,
+      small_name);
+
+  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
+      ExpectNe{errors}, test_name, context, small, big, small_name, big_name);
+  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
+      ExpectNe{errors}, test_name, context, big, small, big_name, small_name);
+
+  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
+      ExpectLt{errors}, test_name, context, small, big, small_name, big_name);
+  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
+      ExpectNotLt{errors}, test_name, context, big, small, big_name,
+      small_name);
+
+  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
+      ExpectLe{errors}, test_name, context, small, big, small_name, big_name);
+  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
+      ExpectNotLe{errors}, test_name, context, big, small, big_name,
+      small_name);
+
+  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
+      ExpectNotGe{errors}, test_name, context, small, big, small_name,
+      big_name);
+  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
+      ExpectGe{errors}, test_name, context, big, small, big_name, small_name);
+
+  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
+      ExpectNotGt{errors}, test_name, context, small, big, small_name,
+      big_name);
+  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
+      ExpectGt{errors}, test_name, context, big, small, big_name, small_name);
+}
+
+// For every two elements of an equivalence class, makes sure that those two
+// elements compare equal, including checks with the same argument passed as
+// both operands.
+template <class T, class Prof>
+struct ExpectEquivalenceClassComparisons {
+  template <class... Funs>
+  void operator()(EquivalenceClassType<Funs...> eq_class) const {
+    (ForEachTupleElement)(ExpectSelfComparison<T, Prof>{errors},
+                          eq_class.generators);
+
+    (ForEveryTwo)(ExpectEquivalenceClassComparison<T, Prof>{errors},
+                  eq_class.generators);
+  }
+
+  ConformanceErrors* errors;
+};
+
+// For every element of an equivalence class, makes sure that the element is
+// self-consistent (in other words, if any of move/copy/swap are defined,
+// perform those operations and make such that results and operands still
+// compare equal to known values whenever it is required for that operation.
+template <class T, class Prof>
+struct ExpectEquivalenceClass {
+  template <class... Funs>
+  void operator()(EquivalenceClassType<Funs...> eq_class) const {
+    (ForEachTupleElement)(ExpectConsistency<T, Prof>{errors},
+                          eq_class.generators);
+
+    (ForEveryTwo)(ExpectEquivalenceClassConsistency<T, Prof>{errors},
+                  eq_class.generators);
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Validate that the passed-in argument is a generator of a greater value than
+// the one produced by the "small_gen" datamember with respect to all of the
+// comparison operators that Prof requires, with both argument orders to test.
+template <class T, class Prof, class SmallGenerator>
+struct ExpectBiggerGeneratorThanComparisons {
+  template <class BigGenerator>
+  void operator()(BigGenerator big_gen) const {
+    const T small = small_gen();
+    const T big = big_gen();
+
+    (ExpectOrdered<T, Prof>)(errors,
+                             PrepareGivenContext(
+                                 GivenDeclaration{"const _T small",
+                                                  small_gen.description},
+                                 GivenDeclaration{"const _T big",
+                                                  big_gen.description}),
+                             small, big, "small", "big");
+  }
+
+  SmallGenerator small_gen;
+  ConformanceErrors* errors;
+};
+
+// Perform all of the move, copy, and swap checks on the value generated by
+// `small_gen` and the value generated by `big_gen`.
+template <class T, class Prof, class SmallGenerator>
+struct ExpectBiggerGeneratorThan {
+  template <class BigGenerator>
+  void operator()(BigGenerator big_gen) const {
+    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
+        ExpectMoveAssign<T, Prof>{errors}, small_gen, big_gen);
+    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
+        ExpectMoveAssign<T, Prof>{errors}, big_gen, small_gen);
+
+    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
+        ExpectCopyAssign<T, Prof>{errors}, small_gen, big_gen);
+    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
+        ExpectCopyAssign<T, Prof>{errors}, big_gen, small_gen);
+
+    If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors},
+                                                  small_gen, big_gen);
+  }
+
+  SmallGenerator small_gen;
+  ConformanceErrors* errors;
+};
+
+// Validate that the result of a generator is greater than the results of all
+// generators in an equivalence class with respect to comparisons.
+template <class T, class Prof, class SmallGenerator>
+struct ExpectBiggerGeneratorThanEqClassesComparisons {
+  template <class BigEqClass>
+  void operator()(BigEqClass big_eq_class) const {
+    (ForEachTupleElement)(
+        ExpectBiggerGeneratorThanComparisons<T, Prof, SmallGenerator>{small_gen,
+                                                                      errors},
+        big_eq_class.generators);
+  }
+
+  SmallGenerator small_gen;
+  ConformanceErrors* errors;
+};
+
+// Validate that the non-comparison binary operations required by Prof are
+// correct for the result of each generator of big_eq_class and a generator of
+// the logically smaller value returned by small_gen.
+template <class T, class Prof, class SmallGenerator>
+struct ExpectBiggerGeneratorThanEqClasses {
+  template <class BigEqClass>
+  void operator()(BigEqClass big_eq_class) const {
+    (ForEachTupleElement)(
+        ExpectBiggerGeneratorThan<T, Prof, SmallGenerator>{small_gen, errors},
+        big_eq_class.generators);
+  }
+
+  SmallGenerator small_gen;
+  ConformanceErrors* errors;
+};
+
+// Validate that each equivalence class that is passed is logically less than
+// the equivalence classes that comes later on in the argument list.
+template <class T, class Prof>
+struct ExpectOrderedEquivalenceClassesComparisons {
+  template <class... BigEqClasses>
+  struct Impl {
+    // Validate that the value produced by `small_gen` is less than all of the
+    // values generated by those of the logically larger equivalence classes.
+    template <class SmallGenerator>
+    void operator()(SmallGenerator small_gen) const {
+      (ForEachTupleElement)(ExpectBiggerGeneratorThanEqClassesComparisons<
+                                T, Prof, SmallGenerator>{small_gen, errors},
+                            big_eq_classes);
+    }
+
+    std::tuple<BigEqClasses...> big_eq_classes;
+    ConformanceErrors* errors;
+  };
+
+  // When given no equivalence classes, no validation is necessary.
+  void operator()() const {}
+
+  template <class SmallEqClass, class... BigEqClasses>
+  void operator()(SmallEqClass small_eq_class,
+                  BigEqClasses... big_eq_classes) const {
+    // For each generator in the first equivalence class, make sure that it is
+    // less than each of those in the logically greater equivalence classes.
+    (ForEachTupleElement)(
+        Impl<BigEqClasses...>{std::make_tuple(absl::move(big_eq_classes)...),
+                              errors},
+        small_eq_class.generators);
+
+    // Recurse so that all equivalence class combinations are checked.
+    (*this)(absl::move(big_eq_classes)...);
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Validate that the non-comparison binary operations required by Prof are
+// correct for the result of each generator of big_eq_classes and a generator of
+// the logically smaller value returned by small_gen.
+template <class T, class Prof>
+struct ExpectOrderedEquivalenceClasses {
+  template <class... BigEqClasses>
+  struct Impl {
+    template <class SmallGenerator>
+    void operator()(SmallGenerator small_gen) const {
+      (ForEachTupleElement)(
+          ExpectBiggerGeneratorThanEqClasses<T, Prof, SmallGenerator>{small_gen,
+                                                                      errors},
+          big_eq_classes);
+    }
+
+    std::tuple<BigEqClasses...> big_eq_classes;
+    ConformanceErrors* errors;
+  };
+
+  // Check that small_eq_class is logically consistent and also is logically
+  // less than all values in big_eq_classes.
+  template <class SmallEqClass, class... BigEqClasses>
+  void operator()(SmallEqClass small_eq_class,
+                  BigEqClasses... big_eq_classes) const {
+    (ForEachTupleElement)(
+        Impl<BigEqClasses...>{std::make_tuple(absl::move(big_eq_classes)...),
+                              errors},
+        small_eq_class.generators);
+
+    (*this)(absl::move(big_eq_classes)...);
+  }
+
+  // Terminating case of operator().
+  void operator()() const {}
+
+  ConformanceErrors* errors;
+};
+
+// Validate that a type meets the syntactic requirements of std::hash if the
+// range of profiles requires it.
+template <class T, class MinProf, class MaxProf>
+struct ExpectHashable {
+  void operator()() const {
+    ExpectModelOfHashable<T, MinProf, MaxProf>(errors);
+  }
+
+  ConformanceErrors* errors;
+};
+
+// Validate that the type `T` meets all of the requirements associated with
+// `MinProf` and without going beyond the syntactic properties of `MaxProf`.
+template <class T, class MinProf, class MaxProf>
+struct ExpectModels {
+  void operator()(ConformanceErrors* errors) const {
+    ExpectModelOfDefaultConstructible<T, MinProf, MaxProf>(errors);
+    ExpectModelOfMoveConstructible<T, MinProf, MaxProf>(errors);
+    ExpectModelOfCopyConstructible<T, MinProf, MaxProf>(errors);
+    ExpectModelOfMoveAssignable<T, MinProf, MaxProf>(errors);
+    ExpectModelOfCopyAssignable<T, MinProf, MaxProf>(errors);
+    ExpectModelOfDestructible<T, MinProf, MaxProf>(errors);
+    ExpectModelOfEqualityComparable<T, MinProf, MaxProf>(errors);
+    ExpectModelOfInequalityComparable<T, MinProf, MaxProf>(errors);
+    ExpectModelOfLessThanComparable<T, MinProf, MaxProf>(errors);
+    ExpectModelOfLessEqualComparable<T, MinProf, MaxProf>(errors);
+    ExpectModelOfGreaterEqualComparable<T, MinProf, MaxProf>(errors);
+    ExpectModelOfGreaterThanComparable<T, MinProf, MaxProf>(errors);
+    ExpectModelOfSwappable<T, MinProf, MaxProf>(errors);
+
+    // Only check hashability on compilers that have a compliant default-hash.
+    If<!poisoned_hash_fails_instantiation()>::Invoke(
+        ExpectHashable<T, MinProf, MaxProf>{errors});
+  }
+};
+
+// A metafunction that yields a Profile matching the set of properties that are
+// safe to be checked (lack-of-hashability is only checked on standard library
+// implementations that are standards compliant in that they provide a std::hash
+// primary template that is SFINAE-friendly)
+template <class LogicalProf, class T>
+struct MinimalCheckableProfile {
+  using type =
+      MinimalProfiles<PropertiesOfT<LogicalProf>,
+                      PropertiesOfT<SyntacticConformanceProfileOf<
+                          T, !PropertiesOfT<LogicalProf>::is_hashable &&
+                                     poisoned_hash_fails_instantiation()
+                                 ? CheckHashability::no
+                                 : CheckHashability::yes>>>;
+};
+
+// An identity metafunction
+template <class T>
+struct Always {
+  using type = T;
+};
+
+// Validate the T meets all of the necessary requirements of LogicalProf, with
+// syntactic requirements defined by the profile range [MinProf, MaxProf].
+template <class T, class LogicalProf, class MinProf, class MaxProf,
+          class... EqClasses>
+ConformanceErrors ExpectRegularityImpl(
+    OrderedEquivalenceClasses<EqClasses...> vals) {
+  ConformanceErrors errors((NameOf<T>()));
+
+  If<!constexpr_instantiation_when_unevaluated()>::Invoke(
+      ExpectModels<T, MinProf, MaxProf>(), &errors);
+
+  using minimal_profile = typename absl::conditional_t<
+      constexpr_instantiation_when_unevaluated(), Always<LogicalProf>,
+      MinimalCheckableProfile<LogicalProf, T>>::type;
+
+  If<PropertiesOfT<minimal_profile>::is_default_constructible>::Invoke(
+      ExpectDefaultConstructWithDestruct<T>{&errors});
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Perform all comparison checks first, since later checks depend on their
+  // correctness.
+  //
+  // Check all of the comparisons for all values in the same equivalence
+  // class (equal with respect to comparison operators and hash the same).
+  (ForEachTupleElement)(
+      ExpectEquivalenceClassComparisons<T, minimal_profile>{&errors},
+      vals.eq_classes);
+
+  // Check all of the comparisons for each combination of values that are in
+  // different equivalence classes (not equal with respect to comparison
+  // operators).
+  absl::apply(
+      ExpectOrderedEquivalenceClassesComparisons<T, minimal_profile>{&errors},
+      vals.eq_classes);
+  //
+  //////////////////////////////////////////////////////////////////////////////
+
+  // Perform remaining checks, relying on comparisons.
+  // TODO(calabrese) short circuit if any comparisons above failed.
+  (ForEachTupleElement)(ExpectEquivalenceClass<T, minimal_profile>{&errors},
+                        vals.eq_classes);
+
+  absl::apply(ExpectOrderedEquivalenceClasses<T, minimal_profile>{&errors},
+              vals.eq_classes);
+
+  return errors;
+}
+
+// A type that represents a range of profiles that are acceptable to be matched.
+//
+// `MinProf` is the minimum set of syntactic requirements that must be met.
+//
+// `MaxProf` is the maximum set of syntactic requirements that must be met.
+// This maximum is particularly useful for certain "strictness" checking. Some
+// examples for when this is useful:
+//
+// * Making sure that a type is move-only (rather than simply movable)
+//
+// * Making sure that a member function is *not* noexcept in cases where it
+//   cannot be noexcept, such as if a dependent datamember has certain
+//   operations that are not noexcept.
+//
+// * Making sure that a type tightly matches a spec, such as the standard.
+//
+// `LogicalProf` is the Profile for which run-time testing is to take place.
+//
+// Note: The reason for `LogicalProf` is because it is often the case, when
+// dealing with templates, that a declaration of a given operation is specified,
+// but whose body would fail to instantiate. Examples include the
+// copy-constructor of a standard container when the element-type is move-only,
+// or the comparison operators of a standard container when the element-type
+// does not have the necessary comparison operations defined. The `LogicalProf`
+// parameter allows us to capture the intent of what should be tested at
+// run-time, even in the cases where syntactically it might otherwise appear as
+// though the type undergoing testing supports more than it actually does.
+template <class LogicalProf, class MinProf = LogicalProf,
+          class MaxProf = MinProf>
+struct ProfileRange {
+  using logical_profile = LogicalProf;
+  using min_profile = MinProf;
+  using max_profile = MaxProf;
+};
+
+// Similar to ProfileRange except that it creates a profile range that is
+// coupled with a Domain and is used when testing that a type matches exactly
+// the "minimum" requirements of LogicalProf.
+template <class StrictnessDomain, class LogicalProf,
+          class MinProf = LogicalProf, class MaxProf = MinProf>
+struct StrictProfileRange {
+  // We do not yet support extension.
+  static_assert(
+      std::is_same<StrictnessDomain, RegularityDomain>::value,
+      "Currently, the only valid StrictnessDomain is RegularityDomain.");
+  using strictness_domain = StrictnessDomain;
+  using logical_profile = LogicalProf;
+  using min_profile = MinProf;
+  using max_profile = MaxProf;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction that creates a StrictProfileRange from a Domain and either a
+// Profile or ProfileRange.
+template <class StrictnessDomain, class ProfOrRange>
+struct MakeStrictProfileRange;
+
+template <class StrictnessDomain, class LogicalProf>
+struct MakeStrictProfileRange {
+  using type = StrictProfileRange<StrictnessDomain, LogicalProf>;
+};
+
+template <class StrictnessDomain, class LogicalProf, class MinProf,
+          class MaxProf>
+struct MakeStrictProfileRange<StrictnessDomain,
+                              ProfileRange<LogicalProf, MinProf, MaxProf>> {
+  using type =
+      StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>;
+};
+
+template <class StrictnessDomain, class ProfOrRange>
+using MakeStrictProfileRangeT =
+    typename MakeStrictProfileRange<StrictnessDomain, ProfOrRange>::type;
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// A profile in the RegularityDomain with the strongest possible requirements.
+using MostStrictProfile =
+    CombineProfiles<TriviallyCompleteProfile, NothrowComparableProfile>;
+
+// Forms a ProfileRange that treats the Profile as the bare minimum requirements
+// of a type.
+template <class LogicalProf, class MinProf = LogicalProf>
+using LooseProfileRange = StrictProfileRange<RegularityDomain, LogicalProf,
+                                             MinProf, MostStrictProfile>;
+
+template <class Prof>
+using MakeLooseProfileRangeT = Prof;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// The following classes implement the metafunction ProfileRangeOfT<T> that
+// takes either a Profile or ProfileRange and yields the ProfileRange to be
+// used during testing.
+//
+template <class T, class /*Enabler*/ = void>
+struct ProfileRangeOfImpl;
+
+template <class T>
+struct ProfileRangeOfImpl<T, absl::void_t<PropertiesOfT<T>>> {
+  using type = LooseProfileRange<T>;
+};
+
+template <class T>
+struct ProfileRangeOf : ProfileRangeOfImpl<T> {};
+
+template <class StrictnessDomain, class LogicalProf, class MinProf,
+          class MaxProf>
+struct ProfileRangeOf<
+    StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>> {
+  using type =
+      StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>;
+};
+
+template <class T>
+using ProfileRangeOfT = typename ProfileRangeOf<T>::type;
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// Extract the logical profile of a range (what will be runtime tested).
+template <class T>
+using LogicalProfileOfT = typename ProfileRangeOfT<T>::logical_profile;
+
+// Extract the minimal syntactic profile of a range (error if not at least).
+template <class T>
+using MinProfileOfT = typename ProfileRangeOfT<T>::min_profile;
+
+// Extract the maximum syntactic profile of a range (error if more than).
+template <class T>
+using MaxProfileOfT = typename ProfileRangeOfT<T>::max_profile;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+template <class T>
+struct IsProfileOrProfileRange : IsProfile<T>::type {};
+
+template <class StrictnessDomain, class LogicalProf, class MinProf,
+          class MaxProf>
+struct IsProfileOrProfileRange<
+    StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>>
+    : std::true_type {};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// TODO(calabrese): Consider naming the functions in this class the same as
+// the macros (defined later on) so that auto-complete leads to the correct name
+// and so that a user cannot accidentally call a function rather than the macro
+// form.
+template <bool ExpectSuccess, class T, class... EqClasses>
+struct ExpectConformanceOf {
+  // Add a value to be tested. Subsequent calls to this function on the same
+  // object must specify logically "larger" values with respect to the
+  // comparison operators of the type, if any.
+  //
+  // NOTE: This function should not be called directly. A stateless lambda is
+  // implicitly formed and passed when using the INITIALIZER macro at the bottom
+  // of this file.
+  template <class Fun,
+            absl::enable_if_t<std::is_same<
+                ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
+                                           EquivalenceClassType<Fun>>
+  initializer(GeneratorType<Fun> fun) && {
+    return {
+        {std::tuple_cat(absl::move(ordered_vals.eq_classes),
+                        std::make_tuple((EquivalenceClass)(absl::move(fun))))},
+        std::move(expected_failed_tests)};
+  }
+
+  template <class... TestNames,
+            absl::enable_if_t<!ExpectSuccess && sizeof...(EqClasses) == 0 &&
+                              absl::conjunction<std::is_convertible<
+                                  TestNames, absl::string_view>...>::value>** =
+                nullptr>
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
+  due_to(TestNames&&... test_names) && {
+    (InsertEach)(&expected_failed_tests,
+                 absl::AsciiStrToLower(absl::string_view(test_names))...);
+
+    return {absl::move(ordered_vals), std::move(expected_failed_tests)};
+  }
+
+  template <class... TestNames, int = 0,  // MSVC disambiguator
+            absl::enable_if_t<ExpectSuccess && sizeof...(EqClasses) == 0 &&
+                              absl::conjunction<std::is_convertible<
+                                  TestNames, absl::string_view>...>::value>** =
+                nullptr>
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
+  due_to(TestNames&&... test_names) && {
+    // TODO(calabrese) Instead have DUE_TO only exist via a CRTP base.
+    // This would produce better errors messages than the static_assert.
+    static_assert(!ExpectSuccess,
+                  "DUE_TO cannot be called when conformance is expected -- did "
+                  "you mean to use ASSERT_NONCONFORMANCE_OF?");
+  }
+
+  // Add a value to be tested. Subsequent calls to this function on the same
+  // object must specify logically "larger" values with respect to the
+  // comparison operators of the type, if any.
+  //
+  // NOTE: This function should not be called directly. A stateful lambda is
+  // implicitly formed and passed when using the INITIALIZER macro at the bottom
+  // of this file.
+  template <class Fun,
+            absl::enable_if_t<std::is_same<
+                ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
+                                           EquivalenceClassType<Fun>>
+  dont_class_directly_stateful_initializer(GeneratorType<Fun> fun) && {
+    return {
+        {std::tuple_cat(absl::move(ordered_vals.eq_classes),
+                        std::make_tuple((EquivalenceClass)(absl::move(fun))))},
+        std::move(expected_failed_tests)};
+  }
+
+  // Add a set of value to be tested, where each value is equal with respect to
+  // the comparison operators and std::hash specialization, if defined.
+  template <
+      class... Funs,
+      absl::void_t<absl::enable_if_t<std::is_same<
+          ResultOfGeneratorT<GeneratorType<Funs>>, T>::value>...>** = nullptr>
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
+                                           EquivalenceClassType<Funs...>>
+  equivalence_class(GeneratorType<Funs>... funs) && {
+    return {{std::tuple_cat(
+                absl::move(ordered_vals.eq_classes),
+                std::make_tuple((EquivalenceClass)(absl::move(funs)...)))},
+            std::move(expected_failed_tests)};
+  }
+
+  // Execute the tests for the captured set of values, strictly matching a range
+  // of expected profiles in a given domain.
+  template <
+      class ProfRange,
+      absl::enable_if_t<IsProfileOrProfileRange<ProfRange>::value>** = nullptr>
+  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_strict_profile(
+      ProfRange /*profile*/) {
+    ConformanceErrors test_result =
+        (ExpectRegularityImpl<
+            T, LogicalProfileOfT<ProfRange>, MinProfileOfT<ProfRange>,
+            MaxProfileOfT<ProfRange>>)(absl::move(ordered_vals));
+
+    return ExpectSuccess ? test_result.assertionResult()
+                         : test_result.expectFailedTests(expected_failed_tests);
+  }
+
+  // Execute the tests for the captured set of values, loosely matching a range
+  // of expected profiles (loose in that an interface is allowed to be more
+  // refined that a profile suggests, such as a type having a noexcept copy
+  // constructor when all that is required is that the copy constructor exists).
+  template <class Prof, absl::enable_if_t<IsProfile<Prof>::value>** = nullptr>
+  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_loose_profile(
+      Prof /*profile*/) {
+    ConformanceErrors test_result =
+        (ExpectRegularityImpl<
+            T, Prof, Prof,
+            CombineProfiles<TriviallyCompleteProfile,
+                            NothrowComparableProfile>>)(absl::
+                                                            move(ordered_vals));
+
+    return ExpectSuccess ? test_result.assertionResult()
+                         : test_result.expectFailedTests(expected_failed_tests);
+  }
+
+  OrderedEquivalenceClasses<EqClasses...> ordered_vals;
+  std::set<std::string> expected_failed_tests;
+};
+
+template <class T>
+using ExpectConformanceOfType = ExpectConformanceOf</*ExpectSuccess=*/true, T>;
+
+template <class T>
+using ExpectNonconformanceOfType =
+    ExpectConformanceOf</*ExpectSuccess=*/false, T>;
+
+struct EquivalenceClassMaker {
+  // TODO(calabrese) Constrain to callable
+  template <class Fun>
+  static GeneratorType<Fun> initializer(GeneratorType<Fun> fun) {
+    return fun;
+  }
+};
+
+// A top-level macro that begins the builder pattern.
+//
+// The argument here takes the datatype to be tested.
+#define ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(...)                            \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
+  if ABSL_INTERNAL_LPAREN                                                   \
+  const ::testing::AssertionResult gtest_ar =                               \
+      ABSL_INTERNAL_LPAREN ::absl::types_internal::ExpectConformanceOfType< \
+          __VA_ARGS__>()
+
+// Akin to ASSERT_CONFORMANCE_OF except that it expects failure and tries to
+// match text.
+#define ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(...)                            \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+  if ABSL_INTERNAL_LPAREN                                                      \
+  const ::testing::AssertionResult gtest_ar =                                  \
+      ABSL_INTERNAL_LPAREN ::absl::types_internal::ExpectNonconformanceOfType< \
+          __VA_ARGS__>()
+
+////////////////////////////////////////////////////////////////////////////////
+// NOTE: The following macros look like they are recursive, but are not (macros
+// cannot recurse). These actually refer to member functions of the same name.
+// This is done intentionally so that a user cannot accidentally invoke a
+// member function of the conformance-testing suite without going through the
+// macro.
+////////////////////////////////////////////////////////////////////////////////
+
+// Specify expected test failures as comma-separated strings.
+#define DUE_TO(...) due_to(__VA_ARGS__)
+
+// Specify a value to be tested.
+//
+// Note: Internally, this takes an expression and turns it into the return value
+// of lambda that captures no data. The expression is stringized during
+// preprocessing so that it can be used in error reports.
+#define INITIALIZER(...)                         \
+  initializer(::absl::types_internal::Generator( \
+      [] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
+
+// Specify a value to be tested.
+//
+// Note: Internally, this takes an expression and turns it into the return value
+// of lambda that captures data by reference. The expression is stringized
+// during preprocessing so that it can be used in error reports.
+#define STATEFUL_INITIALIZER(...)                         \
+  stateful_initializer(::absl::types_internal::Generator( \
+      [&] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
+
+// Used in the builder-pattern.
+//
+// Takes a series of INITIALIZER and/or STATEFUL_INITIALIZER invocations and
+// forwards them along to be tested, grouping them such that the testing suite
+// knows that they are supposed to represent the same logical value (the values
+// compare the same, hash the same, etc.).
+#define EQUIVALENCE_CLASS(...)                    \
+  equivalence_class(ABSL_INTERNAL_TRANSFORM_ARGS( \
+      ABSL_INTERNAL_PREPEND_EQ_MAKER, __VA_ARGS__))
+
+// An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern.
+// It takes a Profile as its argument.
+//
+// This executes the tests and allows types that are "more referined" than the
+// profile specifies, but not less. For instance, if the Profile specifies
+// noexcept copy-constructiblity, the test will fail if the copy-constructor is
+// not noexcept, however, it will succeed if the copy constructor is trivial.
+//
+// This is useful for testing that a type meets some minimum set of
+// requirements.
+#define WITH_LOOSE_PROFILE(...)                                      \
+  with_loose_profile(                                                \
+      ::absl::types_internal::MakeLooseProfileRangeT<__VA_ARGS__>()) \
+      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                     \
+  else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
+
+// An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern.
+// It takes a Domain and a Profile as its arguments.
+//
+// This executes the tests and disallows types that differ at all from the
+// properties of the Profile. For instance, if the Profile specifies noexcept
+// copy-constructiblity, the test will fail if the copy constructor is trivial.
+//
+// This is useful for testing that a type does not do anything more than a
+// specification requires, such as to minimize things like Hyrum's Law, or more
+// commonly, to prevent a type from being "accidentally" copy-constructible in
+// a way that may produce incorrect results, simply because the user forget to
+// delete that operation.
+#define WITH_STRICT_PROFILE(...)                                      \
+  with_strict_profile(                                                \
+      ::absl::types_internal::MakeStrictProfileRangeT<__VA_ARGS__>()) \
+      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                      \
+  else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
+
+// Internal macro that is used in the internals of the EDSL when forming
+// equivalence classes.
+#define ABSL_INTERNAL_PREPEND_EQ_MAKER(arg) \
+  ::absl::types_internal::EquivalenceClassMaker().arg
+
+}  // namespace types_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing_helpers.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing_helpers.h
new file mode 100644
index 0000000..00775f9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing_helpers.h
@@ -0,0 +1,391 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+
+#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
+#define ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
+
+// Checks to determine whether or not we can use abi::__cxa_demangle
+#if (defined(__ANDROID__) || defined(ANDROID)) && !defined(OS_ANDROID)
+#define ABSL_INTERNAL_OS_ANDROID
+#endif
+
+// We support certain compilers only.  See demangle.h for details.
+#if defined(OS_ANDROID) && (defined(__i386__) || defined(__x86_64__))
+#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0
+#elif (__GNUC__ >= 4 || (__GNUC__ >= 3 && __GNUC_MINOR__ >= 4)) && \
+    !defined(__mips__)
+#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1
+#elif defined(__clang__) && !defined(_MSC_VER)
+#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1
+#else
+#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0
+#endif
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+#include "absl/utility/utility.h"
+
+#if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
+#include <cxxabi.h>
+
+#include <cstdlib>
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace types_internal {
+
+// Return a readable name for type T.
+template <class T>
+absl::string_view NameOfImpl() {
+// TODO(calabrese) Investigate using debugging:internal_demangle as a fallback.
+#if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
+  int status = 0;
+  char* demangled_name = nullptr;
+
+  demangled_name =
+      abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
+
+  if (status == 0 && demangled_name != nullptr) {
+    return demangled_name;
+  } else {
+    return typeid(T).name();
+  }
+#else
+  return typeid(T).name();
+#endif
+  // NOTE: We intentionally leak demangled_name so that it remains valid
+  // throughout the remainder of the program.
+}
+
+// Given a type, returns as nice of a type name as we can produce (demangled).
+//
+// Note: This currently strips cv-qualifiers and references, but that is okay
+// because we only use this internally with unqualified object types.
+template <class T>
+std::string NameOf() {
+  static const absl::string_view result = NameOfImpl<T>();
+  return std::string(result);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Metafunction to check if a type is callable with no explicit arguments
+template <class Fun, class /*Enabler*/ = void>
+struct IsNullaryCallableImpl : std::false_type {};
+
+template <class Fun>
+struct IsNullaryCallableImpl<
+    Fun, absl::void_t<decltype(std::declval<const Fun&>()())>>
+    : std::true_type {
+  using result_type = decltype(std::declval<const Fun&>()());
+
+  template <class ValueType>
+  using for_type = std::is_same<ValueType, result_type>;
+
+  using void_if_true = void;
+};
+
+template <class Fun>
+struct IsNullaryCallable : IsNullaryCallableImpl<Fun> {};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// A type that contains a function object that returns an instance of a type
+// that is undergoing conformance testing. This function is required to always
+// return the same value upon invocation.
+template <class Fun>
+struct GeneratorType;
+
+// A type that contains a tuple of GeneratorType<Fun> where each Fun has the
+// same return type. The result of each of the different generators should all
+// be equal values, though the underlying object representation may differ (such
+// as if one returns 0.0 and another return -0.0, or if one returns an empty
+// vector and another returns an empty vector with a different capacity.
+template <class... Funs>
+struct EquivalenceClassType;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction to check if a type is a specialization of EquivalenceClassType
+template <class T>
+struct IsEquivalenceClass : std::false_type {};
+
+template <>
+struct IsEquivalenceClass<EquivalenceClassType<>> : std::true_type {
+  using self = IsEquivalenceClass;
+
+  // A metafunction to check if this EquivalenceClassType is a valid
+  // EquivalenceClassType for a type `ValueType` that is undergoing testing
+  template <class ValueType>
+  using for_type = std::true_type;
+};
+
+template <class Head, class... Tail>
+struct IsEquivalenceClass<EquivalenceClassType<Head, Tail...>>
+    : std::true_type {
+  using self = IsEquivalenceClass;
+
+  // The type undergoing conformance testing that this EquivalenceClass
+  // corresponds to
+  using result_type = typename IsNullaryCallable<Head>::result_type;
+
+  // A metafunction to check if this EquivalenceClassType is a valid
+  // EquivalenceClassType for a type `ValueType` that is undergoing testing
+  template <class ValueType>
+  using for_type = std::is_same<ValueType, result_type>;
+};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// A type that contains an ordered series of EquivalenceClassTypes, where the
+// the function object of each underlying GeneratorType has the same return type
+//
+// These equivalence classes are required to be in a logical ascending order
+// that is consistent with comparison operators that are defined for the return
+// type of each GeneratorType, if any.
+template <class... EqClasses>
+struct OrderedEquivalenceClasses;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction to determine the return type of the function object contained
+// in a GeneratorType specialization.
+template <class T>
+struct ResultOfGenerator {};
+
+template <class Fun>
+struct ResultOfGenerator<GeneratorType<Fun>> {
+  using type = decltype(std::declval<const Fun&>()());
+};
+
+template <class Fun>
+using ResultOfGeneratorT = typename ResultOfGenerator<GeneratorType<Fun>>::type;
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction that yields true iff each of Funs is a GeneratorType
+// specialization and they all contain functions with the same return type
+template <class /*Enabler*/, class... Funs>
+struct AreGeneratorsWithTheSameReturnTypeImpl : std::false_type {};
+
+template <>
+struct AreGeneratorsWithTheSameReturnTypeImpl<void> : std::true_type {};
+
+template <class Head, class... Tail>
+struct AreGeneratorsWithTheSameReturnTypeImpl<
+    typename std::enable_if<absl::conjunction<std::is_same<
+        ResultOfGeneratorT<Head>, ResultOfGeneratorT<Tail>>...>::value>::type,
+    Head, Tail...> : std::true_type {};
+
+template <class... Funs>
+struct AreGeneratorsWithTheSameReturnType
+    : AreGeneratorsWithTheSameReturnTypeImpl<void, Funs...>::type {};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// A metafunction that yields true iff each of Funs is an EquivalenceClassType
+// specialization and they all contain GeneratorType specializations that have
+// the same return type
+template <class... EqClasses>
+struct AreEquivalenceClassesOfTheSameType {
+  static_assert(sizeof...(EqClasses) != sizeof...(EqClasses), "");
+};
+
+template <>
+struct AreEquivalenceClassesOfTheSameType<> : std::true_type {
+  using self = AreEquivalenceClassesOfTheSameType;
+
+  // Metafunction to check that a type is the same as all of the equivalence
+  // classes, if any.
+  // Note: In this specialization there are no equivalence classes, so the
+  // value type is always compatible.
+  template <class /*ValueType*/>
+  using for_type = std::true_type;
+};
+
+template <class... Funs>
+struct AreEquivalenceClassesOfTheSameType<EquivalenceClassType<Funs...>>
+    : std::true_type {
+  using self = AreEquivalenceClassesOfTheSameType;
+
+  // Metafunction to check that a type is the same as all of the equivalence
+  // classes, if any.
+  template <class ValueType>
+  using for_type = typename IsEquivalenceClass<
+      EquivalenceClassType<Funs...>>::template for_type<ValueType>;
+};
+
+template <class... TailEqClasses>
+struct AreEquivalenceClassesOfTheSameType<
+    EquivalenceClassType<>, EquivalenceClassType<>, TailEqClasses...>
+    : AreEquivalenceClassesOfTheSameType<TailEqClasses...>::self {};
+
+template <class HeadNextFun, class... TailNextFuns, class... TailEqClasses>
+struct AreEquivalenceClassesOfTheSameType<
+    EquivalenceClassType<>, EquivalenceClassType<HeadNextFun, TailNextFuns...>,
+    TailEqClasses...>
+    : AreEquivalenceClassesOfTheSameType<
+          EquivalenceClassType<HeadNextFun, TailNextFuns...>,
+          TailEqClasses...>::self {};
+
+template <class HeadHeadFun, class... TailHeadFuns, class... TailEqClasses>
+struct AreEquivalenceClassesOfTheSameType<
+    EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, EquivalenceClassType<>,
+    TailEqClasses...>
+    : AreEquivalenceClassesOfTheSameType<
+          EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
+          TailEqClasses...>::self {};
+
+template <class HeadHeadFun, class... TailHeadFuns, class HeadNextFun,
+          class... TailNextFuns, class... TailEqClasses>
+struct AreEquivalenceClassesOfTheSameType<
+    EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
+    EquivalenceClassType<HeadNextFun, TailNextFuns...>, TailEqClasses...>
+    : absl::conditional_t<
+          IsNullaryCallable<HeadNextFun>::template for_type<
+              typename IsNullaryCallable<HeadHeadFun>::result_type>::value,
+          AreEquivalenceClassesOfTheSameType<
+              EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
+              TailEqClasses...>,
+          std::false_type> {};
+//
+////////////////////////////////////////////////////////////////////////////////
+
+// Execute a function for each passed-in parameter.
+template <class Fun, class... Cases>
+void ForEachParameter(const Fun& fun, const Cases&... cases) {
+  const std::initializer_list<bool> results = {
+      (static_cast<void>(fun(cases)), true)...};
+
+  (void)results;
+}
+
+// Execute a function on each passed-in parameter (using a bound function).
+template <class Fun>
+struct ForEachParameterFun {
+  template <class... T>
+  void operator()(const T&... cases) const {
+    (ForEachParameter)(fun, cases...);
+  }
+
+  Fun fun;
+};
+
+// Execute a function on each element of a tuple.
+template <class Fun, class Tup>
+void ForEachTupleElement(const Fun& fun, const Tup& tup) {
+  absl::apply(ForEachParameterFun<Fun>{fun}, tup);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Execute a function for each combination of two elements of a tuple, including
+// combinations of an element with itself.
+template <class Fun, class... T>
+struct ForEveryTwoImpl {
+  template <class Lhs>
+  struct WithBoundLhs {
+    template <class Rhs>
+    void operator()(const Rhs& rhs) const {
+      fun(lhs, rhs);
+    }
+
+    Fun fun;
+    Lhs lhs;
+  };
+
+  template <class Lhs>
+  void operator()(const Lhs& lhs) const {
+    (ForEachTupleElement)(WithBoundLhs<Lhs>{fun, lhs}, args);
+  }
+
+  Fun fun;
+  std::tuple<T...> args;
+};
+
+template <class Fun, class... T>
+void ForEveryTwo(const Fun& fun, std::tuple<T...> args) {
+  (ForEachTupleElement)(ForEveryTwoImpl<Fun, T...>{fun, args}, args);
+}
+//
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Insert all values into an associative container
+template<class Container>
+void InsertEach(Container* cont) {
+}
+
+template<class Container, class H, class... T>
+void InsertEach(Container* cont, H&& head, T&&... tail) {
+  cont->insert(head);
+  (InsertEach)(cont, tail...);
+}
+//
+////////////////////////////////////////////////////////////////////////////////
+// A template with a nested "Invoke" static-member-function that executes a
+// passed-in Callable when `Condition` is true, otherwise it ignores the
+// Callable. This is useful for executing a function object with a condition
+// that corresponds to whether or not the Callable can be safely instantiated.
+// It has some overlapping uses with C++17 `if constexpr`.
+template <bool Condition>
+struct If;
+
+template <>
+struct If</*Condition =*/false> {
+  template <class Fun, class... P>
+  static void Invoke(const Fun& /*fun*/, P&&... /*args*/) {}
+};
+
+template <>
+struct If</*Condition =*/true> {
+  template <class Fun, class... P>
+  static void Invoke(const Fun& fun, P&&... args) {
+    // TODO(calabrese) Use std::invoke equivalent instead of function-call.
+    fun(absl::forward<P>(args)...);
+  }
+};
+
+//
+// ABSL_INTERNAL_STRINGIZE(...)
+//
+// This variadic macro transforms its arguments into a c-string literal after
+// expansion.
+//
+// Example:
+//
+//   ABSL_INTERNAL_STRINGIZE(std::array<int, 10>)
+//
+// Results in:
+//
+//   "std::array<int, 10>"
+#define ABSL_INTERNAL_STRINGIZE(...) ABSL_INTERNAL_STRINGIZE_IMPL((__VA_ARGS__))
+#define ABSL_INTERNAL_STRINGIZE_IMPL(arg) ABSL_INTERNAL_STRINGIZE_IMPL2 arg
+#define ABSL_INTERNAL_STRINGIZE_IMPL2(...) #__VA_ARGS__
+
+}  // namespace types_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/optional.h b/CAPI/cpp/grpc/include/absl/types/internal/optional.h
new file mode 100644
index 0000000..6ed0c66
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/optional.h
@@ -0,0 +1,404 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+#ifndef ABSL_TYPES_INTERNAL_OPTIONAL_H_
+#define ABSL_TYPES_INTERNAL_OPTIONAL_H_
+
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/inline_variable.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/utility/utility.h"
+
+// ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+//
+// Inheriting constructors is supported in GCC 4.8+, Clang 3.3+ and MSVC 2015.
+// __cpp_inheriting_constructors is a predefined macro and a recommended way to
+// check for this language feature, but GCC doesn't support it until 5.0 and
+// Clang doesn't support it until 3.6.
+// Also, MSVC 2015 has a bug: it doesn't inherit the constexpr template
+// constructor. For example, the following code won't work on MSVC 2015 Update3:
+// struct Base {
+//   int t;
+//   template <typename T>
+//   constexpr Base(T t_) : t(t_) {}
+// };
+// struct Foo : Base {
+//   using Base::Base;
+// }
+// constexpr Foo foo(0);  // doesn't work on MSVC 2015
+#if defined(__clang__)
+#if __has_feature(cxx_inheriting_constructors)
+#define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+#endif
+#elif (defined(__GNUC__) &&                                       \
+       (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 8)) || \
+    (__cpp_inheriting_constructors >= 200802) ||                  \
+    (defined(_MSC_VER) && _MSC_VER >= 1910)
+#define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+#endif
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Forward declaration
+template <typename T>
+class optional;
+
+namespace optional_internal {
+
+// This tag type is used as a constructor parameter type for `nullopt_t`.
+struct init_t {
+  explicit init_t() = default;
+};
+
+struct empty_struct {};
+
+// This class stores the data in optional<T>.
+// It is specialized based on whether T is trivially destructible.
+// This is the specialization for non trivially destructible type.
+template <typename T, bool unused = std::is_trivially_destructible<T>::value>
+class optional_data_dtor_base {
+  struct dummy_type {
+    static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+    // Use an array to avoid GCC 6 placement-new warning.
+    empty_struct data[sizeof(T) / sizeof(empty_struct)];
+  };
+
+ protected:
+  // Whether there is data or not.
+  bool engaged_;
+  // Data storage
+  union {
+    T data_;
+    dummy_type dummy_;
+  };
+
+  void destruct() noexcept {
+    if (engaged_) {
+      // `data_` must be initialized if `engaged_` is true.
+#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+      data_.~T();
+#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
+#pragma GCC diagnostic pop
+#endif
+      engaged_ = false;
+    }
+  }
+
+  // dummy_ must be initialized for constexpr constructor.
+  constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
+
+  template <typename... Args>
+  constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
+      : engaged_(true), data_(absl::forward<Args>(args)...) {}
+
+  ~optional_data_dtor_base() { destruct(); }
+};
+
+// Specialization for trivially destructible type.
+template <typename T>
+class optional_data_dtor_base<T, true> {
+  struct dummy_type {
+    static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+    // Use array to avoid GCC 6 placement-new warning.
+    empty_struct data[sizeof(T) / sizeof(empty_struct)];
+  };
+
+ protected:
+  // Whether there is data or not.
+  bool engaged_;
+  // Data storage
+  union {
+    T data_;
+    dummy_type dummy_;
+  };
+  void destruct() noexcept { engaged_ = false; }
+
+  // dummy_ must be initialized for constexpr constructor.
+  constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
+
+  template <typename... Args>
+  constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
+      : engaged_(true), data_(absl::forward<Args>(args)...) {}
+};
+
+template <typename T>
+class optional_data_base : public optional_data_dtor_base<T> {
+ protected:
+  using base = optional_data_dtor_base<T>;
+#ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+  using base::base;
+#else
+  optional_data_base() = default;
+
+  template <typename... Args>
+  constexpr explicit optional_data_base(in_place_t t, Args&&... args)
+      : base(t, absl::forward<Args>(args)...) {}
+#endif
+
+  template <typename... Args>
+  void construct(Args&&... args) {
+    // Use dummy_'s address to work around casting cv-qualified T* to void*.
+    ::new (static_cast<void*>(&this->dummy_)) T(std::forward<Args>(args)...);
+    this->engaged_ = true;
+  }
+
+  template <typename U>
+  void assign(U&& u) {
+    if (this->engaged_) {
+      this->data_ = std::forward<U>(u);
+    } else {
+      construct(std::forward<U>(u));
+    }
+  }
+};
+
+// TODO(absl-team): Add another class using
+// std::is_trivially_move_constructible trait when available to match
+// http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that
+// have trivial move but nontrivial copy.
+// Also, we should be checking is_trivially_copyable here, which is not
+// supported now, so we use is_trivially_* traits instead.
+template <typename T,
+          bool unused = absl::is_trivially_copy_constructible<T>::value&&
+              absl::is_trivially_copy_assignable<typename std::remove_cv<
+                  T>::type>::value&& std::is_trivially_destructible<T>::value>
+class optional_data;
+
+// Trivially copyable types
+template <typename T>
+class optional_data<T, true> : public optional_data_base<T> {
+ protected:
+#ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+  using optional_data_base<T>::optional_data_base;
+#else
+  optional_data() = default;
+
+  template <typename... Args>
+  constexpr explicit optional_data(in_place_t t, Args&&... args)
+      : optional_data_base<T>(t, absl::forward<Args>(args)...) {}
+#endif
+};
+
+template <typename T>
+class optional_data<T, false> : public optional_data_base<T> {
+ protected:
+#ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+  using optional_data_base<T>::optional_data_base;
+#else
+  template <typename... Args>
+  constexpr explicit optional_data(in_place_t t, Args&&... args)
+      : optional_data_base<T>(t, absl::forward<Args>(args)...) {}
+#endif
+
+  optional_data() = default;
+
+  optional_data(const optional_data& rhs) : optional_data_base<T>() {
+    if (rhs.engaged_) {
+      this->construct(rhs.data_);
+    }
+  }
+
+  optional_data(optional_data&& rhs) noexcept(
+      absl::default_allocator_is_nothrow::value ||
+      std::is_nothrow_move_constructible<T>::value)
+      : optional_data_base<T>() {
+    if (rhs.engaged_) {
+      this->construct(std::move(rhs.data_));
+    }
+  }
+
+  optional_data& operator=(const optional_data& rhs) {
+    if (rhs.engaged_) {
+      this->assign(rhs.data_);
+    } else {
+      this->destruct();
+    }
+    return *this;
+  }
+
+  optional_data& operator=(optional_data&& rhs) noexcept(
+      std::is_nothrow_move_assignable<T>::value&&
+          std::is_nothrow_move_constructible<T>::value) {
+    if (rhs.engaged_) {
+      this->assign(std::move(rhs.data_));
+    } else {
+      this->destruct();
+    }
+    return *this;
+  }
+};
+
+// Ordered by level of restriction, from low to high.
+// Copyable implies movable.
+enum class copy_traits { copyable = 0, movable = 1, non_movable = 2 };
+
+// Base class for enabling/disabling copy/move constructor.
+template <copy_traits>
+class optional_ctor_base;
+
+template <>
+class optional_ctor_base<copy_traits::copyable> {
+ public:
+  constexpr optional_ctor_base() = default;
+  optional_ctor_base(const optional_ctor_base&) = default;
+  optional_ctor_base(optional_ctor_base&&) = default;
+  optional_ctor_base& operator=(const optional_ctor_base&) = default;
+  optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+template <>
+class optional_ctor_base<copy_traits::movable> {
+ public:
+  constexpr optional_ctor_base() = default;
+  optional_ctor_base(const optional_ctor_base&) = delete;
+  optional_ctor_base(optional_ctor_base&&) = default;
+  optional_ctor_base& operator=(const optional_ctor_base&) = default;
+  optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+template <>
+class optional_ctor_base<copy_traits::non_movable> {
+ public:
+  constexpr optional_ctor_base() = default;
+  optional_ctor_base(const optional_ctor_base&) = delete;
+  optional_ctor_base(optional_ctor_base&&) = delete;
+  optional_ctor_base& operator=(const optional_ctor_base&) = default;
+  optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+// Base class for enabling/disabling copy/move assignment.
+template <copy_traits>
+class optional_assign_base;
+
+template <>
+class optional_assign_base<copy_traits::copyable> {
+ public:
+  constexpr optional_assign_base() = default;
+  optional_assign_base(const optional_assign_base&) = default;
+  optional_assign_base(optional_assign_base&&) = default;
+  optional_assign_base& operator=(const optional_assign_base&) = default;
+  optional_assign_base& operator=(optional_assign_base&&) = default;
+};
+
+template <>
+class optional_assign_base<copy_traits::movable> {
+ public:
+  constexpr optional_assign_base() = default;
+  optional_assign_base(const optional_assign_base&) = default;
+  optional_assign_base(optional_assign_base&&) = default;
+  optional_assign_base& operator=(const optional_assign_base&) = delete;
+  optional_assign_base& operator=(optional_assign_base&&) = default;
+};
+
+template <>
+class optional_assign_base<copy_traits::non_movable> {
+ public:
+  constexpr optional_assign_base() = default;
+  optional_assign_base(const optional_assign_base&) = default;
+  optional_assign_base(optional_assign_base&&) = default;
+  optional_assign_base& operator=(const optional_assign_base&) = delete;
+  optional_assign_base& operator=(optional_assign_base&&) = delete;
+};
+
+template <typename T>
+struct ctor_copy_traits {
+  static constexpr copy_traits traits =
+      std::is_copy_constructible<T>::value
+          ? copy_traits::copyable
+          : std::is_move_constructible<T>::value ? copy_traits::movable
+                                                 : copy_traits::non_movable;
+};
+
+template <typename T>
+struct assign_copy_traits {
+  static constexpr copy_traits traits =
+      absl::is_copy_assignable<T>::value && std::is_copy_constructible<T>::value
+          ? copy_traits::copyable
+          : absl::is_move_assignable<T>::value &&
+                    std::is_move_constructible<T>::value
+                ? copy_traits::movable
+                : copy_traits::non_movable;
+};
+
+// Whether T is constructible or convertible from optional<U>.
+template <typename T, typename U>
+struct is_constructible_convertible_from_optional
+    : std::integral_constant<
+          bool, std::is_constructible<T, optional<U>&>::value ||
+                    std::is_constructible<T, optional<U>&&>::value ||
+                    std::is_constructible<T, const optional<U>&>::value ||
+                    std::is_constructible<T, const optional<U>&&>::value ||
+                    std::is_convertible<optional<U>&, T>::value ||
+                    std::is_convertible<optional<U>&&, T>::value ||
+                    std::is_convertible<const optional<U>&, T>::value ||
+                    std::is_convertible<const optional<U>&&, T>::value> {};
+
+// Whether T is constructible or convertible or assignable from optional<U>.
+template <typename T, typename U>
+struct is_constructible_convertible_assignable_from_optional
+    : std::integral_constant<
+          bool, is_constructible_convertible_from_optional<T, U>::value ||
+                    std::is_assignable<T&, optional<U>&>::value ||
+                    std::is_assignable<T&, optional<U>&&>::value ||
+                    std::is_assignable<T&, const optional<U>&>::value ||
+                    std::is_assignable<T&, const optional<U>&&>::value> {};
+
+// Helper function used by [optional.relops], [optional.comp_with_t],
+// for checking whether an expression is convertible to bool.
+bool convertible_to_bool(bool);
+
+// Base class for std::hash<absl::optional<T>>:
+// If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to
+// compute the hash; Otherwise, it is disabled.
+// Reference N4659 23.14.15 [unord.hash].
+template <typename T, typename = size_t>
+struct optional_hash_base {
+  optional_hash_base() = delete;
+  optional_hash_base(const optional_hash_base&) = delete;
+  optional_hash_base(optional_hash_base&&) = delete;
+  optional_hash_base& operator=(const optional_hash_base&) = delete;
+  optional_hash_base& operator=(optional_hash_base&&) = delete;
+};
+
+template <typename T>
+struct optional_hash_base<T, decltype(std::hash<absl::remove_const_t<T> >()(
+                                 std::declval<absl::remove_const_t<T> >()))> {
+  using argument_type = absl::optional<T>;
+  using result_type = size_t;
+  size_t operator()(const absl::optional<T>& opt) const {
+    absl::type_traits_internal::AssertHashEnabled<absl::remove_const_t<T>>();
+    if (opt) {
+      return std::hash<absl::remove_const_t<T> >()(*opt);
+    } else {
+      return static_cast<size_t>(0x297814aaad196e6dULL);
+    }
+  }
+};
+
+}  // namespace optional_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#undef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+
+#endif  // ABSL_TYPES_INTERNAL_OPTIONAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/parentheses.h b/CAPI/cpp/grpc/include/absl/types/internal/parentheses.h
new file mode 100644
index 0000000..5aebee8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/parentheses.h
@@ -0,0 +1,34 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// parentheses.h
+// -----------------------------------------------------------------------------
+//
+// This file contains macros that expand to a left parenthesis and a right
+// parenthesis. These are in their own file and are generated from macros
+// because otherwise clang-format gets confused and clang-format off directives
+// do not help.
+//
+// The parentheses macros are used when wanting to require a rescan before
+// expansion of parenthesized text appearing after a function-style macro name.
+
+#ifndef ABSL_TYPES_INTERNAL_PARENTHESES_H_
+#define ABSL_TYPES_INTERNAL_PARENTHESES_H_
+
+#define ABSL_INTERNAL_LPAREN (
+
+#define ABSL_INTERNAL_RPAREN )
+
+#endif  // ABSL_TYPES_INTERNAL_PARENTHESES_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/span.h b/CAPI/cpp/grpc/include/absl/types/internal/span.h
new file mode 100644
index 0000000..112612f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/span.h
@@ -0,0 +1,128 @@
+//
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+#ifndef ABSL_TYPES_INTERNAL_SPAN_H_
+#define ABSL_TYPES_INTERNAL_SPAN_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <string>
+#include <type_traits>
+
+#include "absl/algorithm/algorithm.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace span_internal {
+// A constexpr min function
+constexpr size_t Min(size_t a, size_t b) noexcept { return a < b ? a : b; }
+
+// Wrappers for access to container data pointers.
+template <typename C>
+constexpr auto GetDataImpl(C& c, char) noexcept  // NOLINT(runtime/references)
+    -> decltype(c.data()) {
+  return c.data();
+}
+
+// Before C++17, std::string::data returns a const char* in all cases.
+inline char* GetDataImpl(std::string& s,  // NOLINT(runtime/references)
+                         int) noexcept {
+  return &s[0];
+}
+
+template <typename C>
+constexpr auto GetData(C& c) noexcept  // NOLINT(runtime/references)
+    -> decltype(GetDataImpl(c, 0)) {
+  return GetDataImpl(c, 0);
+}
+
+// Detection idioms for size() and data().
+template <typename C>
+using HasSize =
+    std::is_integral<absl::decay_t<decltype(std::declval<C&>().size())>>;
+
+// We want to enable conversion from vector<T*> to Span<const T* const> but
+// disable conversion from vector<Derived> to Span<Base>. Here we use
+// the fact that U** is convertible to Q* const* if and only if Q is the same
+// type or a more cv-qualified version of U.  We also decay the result type of
+// data() to avoid problems with classes which have a member function data()
+// which returns a reference.
+template <typename T, typename C>
+using HasData =
+    std::is_convertible<absl::decay_t<decltype(GetData(std::declval<C&>()))>*,
+                        T* const*>;
+
+// Extracts value type from a Container
+template <typename C>
+struct ElementType {
+  using type = typename absl::remove_reference_t<C>::value_type;
+};
+
+template <typename T, size_t N>
+struct ElementType<T (&)[N]> {
+  using type = T;
+};
+
+template <typename C>
+using ElementT = typename ElementType<C>::type;
+
+template <typename T>
+using EnableIfMutable =
+    typename std::enable_if<!std::is_const<T>::value, int>::type;
+
+template <template <typename> class SpanT, typename T>
+bool EqualImpl(SpanT<T> a, SpanT<T> b) {
+  static_assert(std::is_const<T>::value, "");
+  return absl::equal(a.begin(), a.end(), b.begin(), b.end());
+}
+
+template <template <typename> class SpanT, typename T>
+bool LessThanImpl(SpanT<T> a, SpanT<T> b) {
+  // We can't use value_type since that is remove_cv_t<T>, so we go the long way
+  // around.
+  static_assert(std::is_const<T>::value, "");
+  return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+}
+
+// The `IsConvertible` classes here are needed because of the
+// `std::is_convertible` bug in libcxx when compiled with GCC. This build
+// configuration is used by Android NDK toolchain. Reference link:
+// https://bugs.llvm.org/show_bug.cgi?id=27538.
+template <typename From, typename To>
+struct IsConvertibleHelper {
+ private:
+  static std::true_type testval(To);
+  static std::false_type testval(...);
+
+ public:
+  using type = decltype(testval(std::declval<From>()));
+};
+
+template <typename From, typename To>
+struct IsConvertible : IsConvertibleHelper<From, To>::type {};
+
+// TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the
+// older version of libcxx is not supported.
+template <typename From, typename To>
+using EnableIfConvertibleTo =
+    typename std::enable_if<IsConvertible<From, To>::value>::type;
+}  // namespace span_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TYPES_INTERNAL_SPAN_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/transform_args.h b/CAPI/cpp/grpc/include/absl/types/internal/transform_args.h
new file mode 100644
index 0000000..4a0ab42
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/transform_args.h
@@ -0,0 +1,246 @@
+// Copyright 2019 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// transform_args.h
+// -----------------------------------------------------------------------------
+//
+// This file contains a higher-order macro that "transforms" each element of a
+// a variadic argument by a provided secondary macro.
+
+#ifndef ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
+#define ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
+
+//
+// ABSL_INTERNAL_CAT(a, b)
+//
+// This macro takes two arguments and concatenates them together via ## after
+// expansion.
+//
+// Example:
+//
+//   ABSL_INTERNAL_CAT(foo_, bar)
+//
+// Results in:
+//
+//   foo_bar
+#define ABSL_INTERNAL_CAT(a, b) ABSL_INTERNAL_CAT_IMPL(a, b)
+#define ABSL_INTERNAL_CAT_IMPL(a, b) a##b
+
+//
+// ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)
+//
+// This macro takes another macro as an argument followed by a trailing series
+// of additional parameters (up to 32 additional arguments). It invokes the
+// passed-in macro once for each of the additional arguments, with the
+// expansions separated by commas.
+//
+// Example:
+//
+//   ABSL_INTERNAL_TRANSFORM_ARGS(MY_MACRO, a, b, c)
+//
+// Results in:
+//
+//   MY_MACRO(a), MY_MACRO(b), MY_MACRO(c)
+//
+// TODO(calabrese) Handle no arguments as a special case.
+#define ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)             \
+  ABSL_INTERNAL_CAT(ABSL_INTERNAL_TRANSFORM_ARGS,        \
+                    ABSL_INTERNAL_NUM_ARGS(__VA_ARGS__)) \
+  (m, __VA_ARGS__)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS1(m, a0) m(a0)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS2(m, a0, a1) m(a0), m(a1)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS3(m, a0, a1, a2) m(a0), m(a1), m(a2)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS4(m, a0, a1, a2, a3) \
+  m(a0), m(a1), m(a2), m(a3)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS5(m, a0, a1, a2, a3, a4) \
+  m(a0), m(a1), m(a2), m(a3), m(a4)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS6(m, a0, a1, a2, a3, a4, a5) \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS7(m, a0, a1, a2, a3, a4, a5, a6) \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS8(m, a0, a1, a2, a3, a4, a5, a6, a7) \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS9(m, a0, a1, a2, a3, a4, a5, a6, a7, a8) \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS10(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9)                                    \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS11(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10)                               \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9), m(a10)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS12(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11)                          \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS13(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12)                     \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS14(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13)                \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS15(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14)           \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS16(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15)      \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS17(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15, a16) \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS18(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \
+                                       a17)                                   \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS19(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \
+                                       a17, a18)                              \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS20(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \
+                                       a17, a18, a19)                         \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS21(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \
+                                       a17, a18, a19, a20)                    \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS22(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \
+                                       a17, a18, a19, a20, a21)               \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20), m(a21)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS23(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \
+                                       a17, a18, a19, a20, a21, a22)          \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20), m(a21), m(a22)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS24(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \
+                                       a17, a18, a19, a20, a21, a22, a23)     \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20), m(a21), m(a22), m(a23)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS25(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
+                                       a9, a10, a11, a12, a13, a14, a15, a16,  \
+                                       a17, a18, a19, a20, a21, a22, a23, a24) \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS26(                                       \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)                         \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS27(                                       \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)                    \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS28(                                       \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)               \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS29(                                       \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)          \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \
+      m(a28)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS30(                                       \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)     \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \
+      m(a28), m(a29)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS31(                                        \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,   \
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \
+      m(a28), m(a29), m(a30)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS32(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
+                                       a9, a10, a11, a12, a13, a14, a15, a16,  \
+                                       a17, a18, a19, a20, a21, a22, a23, a24, \
+                                       a25, a26, a27, a28, a29, a30, a31)      \
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \
+      m(a28), m(a29), m(a30), m(a31)
+
+#define ABSL_INTERNAL_NUM_ARGS_IMPL(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,    \
+                                    a10, a11, a12, a13, a14, a15, a16, a17,    \
+                                    a18, a19, a20, a21, a22, a23, a24, a25,    \
+                                    a26, a27, a28, a29, a30, a31, result, ...) \
+  result
+
+#define ABSL_INTERNAL_FORCE_EXPANSION(...) __VA_ARGS__
+
+#define ABSL_INTERNAL_NUM_ARGS(...)                                            \
+  ABSL_INTERNAL_FORCE_EXPANSION(ABSL_INTERNAL_NUM_ARGS_IMPL(                   \
+      __VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, \
+      17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ))
+
+#endif  // ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/variant.h b/CAPI/cpp/grpc/include/absl/types/internal/variant.h
new file mode 100644
index 0000000..7c402ec
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/internal/variant.h
@@ -0,0 +1,1646 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// Implementation details of absl/types/variant.h, pulled into a
+// separate file to avoid cluttering the top of the API header with
+// implementation details.
+
+#ifndef ABSL_TYPES_VARIANT_INTERNAL_H_
+#define ABSL_TYPES_VARIANT_INTERNAL_H_
+
+#include <cassert>
+#include <cstddef>
+#include <cstdlib>
+#include <memory>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/identity.h"
+#include "absl/base/internal/inline_variable.h"
+#include "absl/base/internal/invoke.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/bad_variant_access.h"
+#include "absl/utility/utility.h"
+
+#if !defined(ABSL_USES_STD_VARIANT)
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+template <class... Types>
+class variant;
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1));
+
+template <class T>
+struct variant_size;
+
+template <std::size_t I, class T>
+struct variant_alternative;
+
+namespace variant_internal {
+
+// NOTE: See specializations below for details.
+template <std::size_t I, class T>
+struct VariantAlternativeSfinae {};
+
+// Requires: I < variant_size_v<T>.
+//
+// Value: The Ith type of Types...
+template <std::size_t I, class T0, class... Tn>
+struct VariantAlternativeSfinae<I, variant<T0, Tn...>>
+    : VariantAlternativeSfinae<I - 1, variant<Tn...>> {};
+
+// Value: T0
+template <class T0, class... Ts>
+struct VariantAlternativeSfinae<0, variant<T0, Ts...>> {
+  using type = T0;
+};
+
+template <std::size_t I, class T>
+using VariantAlternativeSfinaeT = typename VariantAlternativeSfinae<I, T>::type;
+
+// NOTE: Requires T to be a reference type.
+template <class T, class U>
+struct GiveQualsTo;
+
+template <class T, class U>
+struct GiveQualsTo<T&, U> {
+  using type = U&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<T&&, U> {
+  using type = U&&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<const T&, U> {
+  using type = const U&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<const T&&, U> {
+  using type = const U&&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<volatile T&, U> {
+  using type = volatile U&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<volatile T&&, U> {
+  using type = volatile U&&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<volatile const T&, U> {
+  using type = volatile const U&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<volatile const T&&, U> {
+  using type = volatile const U&&;
+};
+
+template <class T, class U>
+using GiveQualsToT = typename GiveQualsTo<T, U>::type;
+
+// Convenience alias, since size_t integral_constant is used a lot in this file.
+template <std::size_t I>
+using SizeT = std::integral_constant<std::size_t, I>;
+
+using NPos = SizeT<variant_npos>;
+
+template <class Variant, class T, class = void>
+struct IndexOfConstructedType {};
+
+template <std::size_t I, class Variant>
+struct VariantAccessResultImpl;
+
+template <std::size_t I, template <class...> class Variantemplate, class... T>
+struct VariantAccessResultImpl<I, Variantemplate<T...>&> {
+  using type = typename absl::variant_alternative<I, variant<T...>>::type&;
+};
+
+template <std::size_t I, template <class...> class Variantemplate, class... T>
+struct VariantAccessResultImpl<I, const Variantemplate<T...>&> {
+  using type =
+      const typename absl::variant_alternative<I, variant<T...>>::type&;
+};
+
+template <std::size_t I, template <class...> class Variantemplate, class... T>
+struct VariantAccessResultImpl<I, Variantemplate<T...>&&> {
+  using type = typename absl::variant_alternative<I, variant<T...>>::type&&;
+};
+
+template <std::size_t I, template <class...> class Variantemplate, class... T>
+struct VariantAccessResultImpl<I, const Variantemplate<T...>&&> {
+  using type =
+      const typename absl::variant_alternative<I, variant<T...>>::type&&;
+};
+
+template <std::size_t I, class Variant>
+using VariantAccessResult =
+    typename VariantAccessResultImpl<I, Variant&&>::type;
+
+// NOTE: This is used instead of std::array to reduce instantiation overhead.
+template <class T, std::size_t Size>
+struct SimpleArray {
+  static_assert(Size != 0, "");
+  T value[Size];
+};
+
+template <class T>
+struct AccessedType {
+  using type = T;
+};
+
+template <class T>
+using AccessedTypeT = typename AccessedType<T>::type;
+
+template <class T, std::size_t Size>
+struct AccessedType<SimpleArray<T, Size>> {
+  using type = AccessedTypeT<T>;
+};
+
+template <class T>
+constexpr T AccessSimpleArray(const T& value) {
+  return value;
+}
+
+template <class T, std::size_t Size, class... SizeT>
+constexpr AccessedTypeT<T> AccessSimpleArray(const SimpleArray<T, Size>& table,
+                                             std::size_t head_index,
+                                             SizeT... tail_indices) {
+  return AccessSimpleArray(table.value[head_index], tail_indices...);
+}
+
+// Note: Intentionally is an alias.
+template <class T>
+using AlwaysZero = SizeT<0>;
+
+template <class Op, class... Vs>
+struct VisitIndicesResultImpl {
+  using type = absl::result_of_t<Op(AlwaysZero<Vs>...)>;
+};
+
+template <class Op, class... Vs>
+using VisitIndicesResultT = typename VisitIndicesResultImpl<Op, Vs...>::type;
+
+template <class ReturnType, class FunctionObject, class EndIndices,
+          class BoundIndices>
+struct MakeVisitationMatrix;
+
+template <class ReturnType, class FunctionObject, std::size_t... Indices>
+constexpr ReturnType call_with_indices(FunctionObject&& function) {
+  static_assert(
+      std::is_same<ReturnType, decltype(std::declval<FunctionObject>()(
+                                   SizeT<Indices>()...))>::value,
+      "Not all visitation overloads have the same return type.");
+  return absl::forward<FunctionObject>(function)(SizeT<Indices>()...);
+}
+
+template <class ReturnType, class FunctionObject, std::size_t... BoundIndices>
+struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
+                            index_sequence<BoundIndices...>> {
+  using ResultType = ReturnType (*)(FunctionObject&&);
+  static constexpr ResultType Run() {
+    return &call_with_indices<ReturnType, FunctionObject,
+                              (BoundIndices - 1)...>;
+  }
+};
+
+template <typename Is, std::size_t J>
+struct AppendToIndexSequence;
+
+template <typename Is, std::size_t J>
+using AppendToIndexSequenceT = typename AppendToIndexSequence<Is, J>::type;
+
+template <std::size_t... Is, std::size_t J>
+struct AppendToIndexSequence<index_sequence<Is...>, J> {
+  using type = index_sequence<Is..., J>;
+};
+
+template <class ReturnType, class FunctionObject, class EndIndices,
+          class CurrIndices, class BoundIndices>
+struct MakeVisitationMatrixImpl;
+
+template <class ReturnType, class FunctionObject, class EndIndices,
+          std::size_t... CurrIndices, class BoundIndices>
+struct MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices,
+                                index_sequence<CurrIndices...>, BoundIndices> {
+  using ResultType = SimpleArray<
+      typename MakeVisitationMatrix<ReturnType, FunctionObject, EndIndices,
+                                    index_sequence<>>::ResultType,
+      sizeof...(CurrIndices)>;
+
+  static constexpr ResultType Run() {
+    return {{MakeVisitationMatrix<
+        ReturnType, FunctionObject, EndIndices,
+        AppendToIndexSequenceT<BoundIndices, CurrIndices>>::Run()...}};
+  }
+};
+
+template <class ReturnType, class FunctionObject, std::size_t HeadEndIndex,
+          std::size_t... TailEndIndices, std::size_t... BoundIndices>
+struct MakeVisitationMatrix<ReturnType, FunctionObject,
+                            index_sequence<HeadEndIndex, TailEndIndices...>,
+                            index_sequence<BoundIndices...>>
+    : MakeVisitationMatrixImpl<ReturnType, FunctionObject,
+                               index_sequence<TailEndIndices...>,
+                               absl::make_index_sequence<HeadEndIndex>,
+                               index_sequence<BoundIndices...>> {};
+
+struct UnreachableSwitchCase {
+  template <class Op>
+  [[noreturn]] static VisitIndicesResultT<Op, std::size_t> Run(
+      Op&& /*ignored*/) {
+#if ABSL_HAVE_BUILTIN(__builtin_unreachable) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    __builtin_unreachable();
+#elif defined(_MSC_VER)
+    __assume(false);
+#else
+    // Try to use assert of false being identified as an unreachable intrinsic.
+    // NOTE: We use assert directly to increase chances of exploiting an assume
+    //       intrinsic.
+    assert(false);  // NOLINT
+
+    // Hack to silence potential no return warning -- cause an infinite loop.
+    return Run(absl::forward<Op>(op));
+#endif  // Checks for __builtin_unreachable
+  }
+};
+
+template <class Op, std::size_t I>
+struct ReachableSwitchCase {
+  static VisitIndicesResultT<Op, std::size_t> Run(Op&& op) {
+    return absl::base_internal::invoke(absl::forward<Op>(op), SizeT<I>());
+  }
+};
+
+// The number 33 is just a guess at a reasonable maximum to our switch. It is
+// not based on any analysis. The reason it is a power of 2 plus 1 instead of a
+// power of 2 is because the number was picked to correspond to a power of 2
+// amount of "normal" alternatives, plus one for the possibility of the user
+// providing "monostate" in addition to the more natural alternatives.
+ABSL_INTERNAL_INLINE_CONSTEXPR(std::size_t, MaxUnrolledVisitCases, 33);
+
+// Note: The default-definition is for unreachable cases.
+template <bool IsReachable>
+struct PickCaseImpl {
+  template <class Op, std::size_t I>
+  using Apply = UnreachableSwitchCase;
+};
+
+template <>
+struct PickCaseImpl</*IsReachable =*/true> {
+  template <class Op, std::size_t I>
+  using Apply = ReachableSwitchCase<Op, I>;
+};
+
+// Note: This form of dance with template aliases is to make sure that we
+//       instantiate a number of templates proportional to the number of variant
+//       alternatives rather than a number of templates proportional to our
+//       maximum unrolled amount of visitation cases (aliases are effectively
+//       "free" whereas other template instantiations are costly).
+template <class Op, std::size_t I, std::size_t EndIndex>
+using PickCase = typename PickCaseImpl<(I < EndIndex)>::template Apply<Op, I>;
+
+template <class ReturnType>
+[[noreturn]] ReturnType TypedThrowBadVariantAccess() {
+  absl::variant_internal::ThrowBadVariantAccess();
+}
+
+// Given N variant sizes, determine the number of cases there would need to be
+// in a single switch-statement that would cover every possibility in the
+// corresponding N-ary visit operation.
+template <std::size_t... NumAlternatives>
+struct NumCasesOfSwitch;
+
+template <std::size_t HeadNumAlternatives, std::size_t... TailNumAlternatives>
+struct NumCasesOfSwitch<HeadNumAlternatives, TailNumAlternatives...> {
+  static constexpr std::size_t value =
+      (HeadNumAlternatives + 1) *
+      NumCasesOfSwitch<TailNumAlternatives...>::value;
+};
+
+template <>
+struct NumCasesOfSwitch<> {
+  static constexpr std::size_t value = 1;
+};
+
+// A switch statement optimizes better than the table of function pointers.
+template <std::size_t EndIndex>
+struct VisitIndicesSwitch {
+  static_assert(EndIndex <= MaxUnrolledVisitCases,
+                "Maximum unrolled switch size exceeded.");
+
+  template <class Op>
+  static VisitIndicesResultT<Op, std::size_t> Run(Op&& op, std::size_t i) {
+    switch (i) {
+      case 0:
+        return PickCase<Op, 0, EndIndex>::Run(absl::forward<Op>(op));
+      case 1:
+        return PickCase<Op, 1, EndIndex>::Run(absl::forward<Op>(op));
+      case 2:
+        return PickCase<Op, 2, EndIndex>::Run(absl::forward<Op>(op));
+      case 3:
+        return PickCase<Op, 3, EndIndex>::Run(absl::forward<Op>(op));
+      case 4:
+        return PickCase<Op, 4, EndIndex>::Run(absl::forward<Op>(op));
+      case 5:
+        return PickCase<Op, 5, EndIndex>::Run(absl::forward<Op>(op));
+      case 6:
+        return PickCase<Op, 6, EndIndex>::Run(absl::forward<Op>(op));
+      case 7:
+        return PickCase<Op, 7, EndIndex>::Run(absl::forward<Op>(op));
+      case 8:
+        return PickCase<Op, 8, EndIndex>::Run(absl::forward<Op>(op));
+      case 9:
+        return PickCase<Op, 9, EndIndex>::Run(absl::forward<Op>(op));
+      case 10:
+        return PickCase<Op, 10, EndIndex>::Run(absl::forward<Op>(op));
+      case 11:
+        return PickCase<Op, 11, EndIndex>::Run(absl::forward<Op>(op));
+      case 12:
+        return PickCase<Op, 12, EndIndex>::Run(absl::forward<Op>(op));
+      case 13:
+        return PickCase<Op, 13, EndIndex>::Run(absl::forward<Op>(op));
+      case 14:
+        return PickCase<Op, 14, EndIndex>::Run(absl::forward<Op>(op));
+      case 15:
+        return PickCase<Op, 15, EndIndex>::Run(absl::forward<Op>(op));
+      case 16:
+        return PickCase<Op, 16, EndIndex>::Run(absl::forward<Op>(op));
+      case 17:
+        return PickCase<Op, 17, EndIndex>::Run(absl::forward<Op>(op));
+      case 18:
+        return PickCase<Op, 18, EndIndex>::Run(absl::forward<Op>(op));
+      case 19:
+        return PickCase<Op, 19, EndIndex>::Run(absl::forward<Op>(op));
+      case 20:
+        return PickCase<Op, 20, EndIndex>::Run(absl::forward<Op>(op));
+      case 21:
+        return PickCase<Op, 21, EndIndex>::Run(absl::forward<Op>(op));
+      case 22:
+        return PickCase<Op, 22, EndIndex>::Run(absl::forward<Op>(op));
+      case 23:
+        return PickCase<Op, 23, EndIndex>::Run(absl::forward<Op>(op));
+      case 24:
+        return PickCase<Op, 24, EndIndex>::Run(absl::forward<Op>(op));
+      case 25:
+        return PickCase<Op, 25, EndIndex>::Run(absl::forward<Op>(op));
+      case 26:
+        return PickCase<Op, 26, EndIndex>::Run(absl::forward<Op>(op));
+      case 27:
+        return PickCase<Op, 27, EndIndex>::Run(absl::forward<Op>(op));
+      case 28:
+        return PickCase<Op, 28, EndIndex>::Run(absl::forward<Op>(op));
+      case 29:
+        return PickCase<Op, 29, EndIndex>::Run(absl::forward<Op>(op));
+      case 30:
+        return PickCase<Op, 30, EndIndex>::Run(absl::forward<Op>(op));
+      case 31:
+        return PickCase<Op, 31, EndIndex>::Run(absl::forward<Op>(op));
+      case 32:
+        return PickCase<Op, 32, EndIndex>::Run(absl::forward<Op>(op));
+      default:
+        ABSL_ASSERT(i == variant_npos);
+        return absl::base_internal::invoke(absl::forward<Op>(op), NPos());
+    }
+  }
+};
+
+template <std::size_t... EndIndices>
+struct VisitIndicesFallback {
+  template <class Op, class... SizeT>
+  static VisitIndicesResultT<Op, SizeT...> Run(Op&& op, SizeT... indices) {
+    return AccessSimpleArray(
+        MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op,
+                             index_sequence<(EndIndices + 1)...>,
+                             index_sequence<>>::Run(),
+        (indices + 1)...)(absl::forward<Op>(op));
+  }
+};
+
+// Take an N-dimensional series of indices and convert them into a single index
+// without loss of information. The purpose of this is to be able to convert an
+// N-ary visit operation into a single switch statement.
+template <std::size_t...>
+struct FlattenIndices;
+
+template <std::size_t HeadSize, std::size_t... TailSize>
+struct FlattenIndices<HeadSize, TailSize...> {
+  template<class... SizeType>
+  static constexpr std::size_t Run(std::size_t head, SizeType... tail) {
+    return head + HeadSize * FlattenIndices<TailSize...>::Run(tail...);
+  }
+};
+
+template <>
+struct FlattenIndices<> {
+  static constexpr std::size_t Run() { return 0; }
+};
+
+// Take a single "flattened" index (flattened by FlattenIndices) and determine
+// the value of the index of one of the logically represented dimensions.
+template <std::size_t I, std::size_t IndexToGet, std::size_t HeadSize,
+          std::size_t... TailSize>
+struct UnflattenIndex {
+  static constexpr std::size_t value =
+      UnflattenIndex<I / HeadSize, IndexToGet - 1, TailSize...>::value;
+};
+
+template <std::size_t I, std::size_t HeadSize, std::size_t... TailSize>
+struct UnflattenIndex<I, 0, HeadSize, TailSize...> {
+  static constexpr std::size_t value = (I % HeadSize);
+};
+
+// The backend for converting an N-ary visit operation into a unary visit.
+template <class IndexSequence, std::size_t... EndIndices>
+struct VisitIndicesVariadicImpl;
+
+template <std::size_t... N, std::size_t... EndIndices>
+struct VisitIndicesVariadicImpl<absl::index_sequence<N...>, EndIndices...> {
+  // A type that can take an N-ary function object and converts it to a unary
+  // function object that takes a single, flattened index, and "unflattens" it
+  // into its individual dimensions when forwarding to the wrapped object.
+  template <class Op>
+  struct FlattenedOp {
+    template <std::size_t I>
+    VisitIndicesResultT<Op, decltype(EndIndices)...> operator()(
+        SizeT<I> /*index*/) && {
+      return base_internal::invoke(
+          absl::forward<Op>(op),
+          SizeT<UnflattenIndex<I, N, (EndIndices + 1)...>::value -
+                std::size_t{1}>()...);
+    }
+
+    Op&& op;
+  };
+
+  template <class Op, class... SizeType>
+  static VisitIndicesResultT<Op, decltype(EndIndices)...> Run(
+      Op&& op, SizeType... i) {
+    return VisitIndicesSwitch<NumCasesOfSwitch<EndIndices...>::value>::Run(
+        FlattenedOp<Op>{absl::forward<Op>(op)},
+        FlattenIndices<(EndIndices + std::size_t{1})...>::Run(
+            (i + std::size_t{1})...));
+  }
+};
+
+template <std::size_t... EndIndices>
+struct VisitIndicesVariadic
+    : VisitIndicesVariadicImpl<absl::make_index_sequence<sizeof...(EndIndices)>,
+                               EndIndices...> {};
+
+// This implementation will flatten N-ary visit operations into a single switch
+// statement when the number of cases would be less than our maximum specified
+// switch-statement size.
+// TODO(calabrese)
+//   Based on benchmarks, determine whether the function table approach actually
+//   does optimize better than a chain of switch statements and possibly update
+//   the implementation accordingly. Also consider increasing the maximum switch
+//   size.
+template <std::size_t... EndIndices>
+struct VisitIndices
+    : absl::conditional_t<(NumCasesOfSwitch<EndIndices...>::value <=
+                           MaxUnrolledVisitCases),
+                          VisitIndicesVariadic<EndIndices...>,
+                          VisitIndicesFallback<EndIndices...>> {};
+
+template <std::size_t EndIndex>
+struct VisitIndices<EndIndex>
+    : absl::conditional_t<(EndIndex <= MaxUnrolledVisitCases),
+                          VisitIndicesSwitch<EndIndex>,
+                          VisitIndicesFallback<EndIndex>> {};
+
+// Suppress bogus warning on MSVC: MSVC complains that the `reinterpret_cast`
+// below is returning the address of a temporary or local object.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4172)
+#endif  // _MSC_VER
+
+// TODO(calabrese) std::launder
+// TODO(calabrese) constexpr
+// NOTE: DO NOT REMOVE the `inline` keyword as it is necessary to work around a
+// MSVC bug. See https://github.com/abseil/abseil-cpp/issues/129 for details.
+template <class Self, std::size_t I>
+inline VariantAccessResult<I, Self> AccessUnion(Self&& self, SizeT<I> /*i*/) {
+  return reinterpret_cast<VariantAccessResult<I, Self>>(self);
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
+
+template <class T>
+void DeducedDestroy(T& self) {  // NOLINT
+  self.~T();
+}
+
+// NOTE: This type exists as a single entity for variant and its bases to
+// befriend. It contains helper functionality that manipulates the state of the
+// variant, such as the implementation of things like assignment and emplace
+// operations.
+struct VariantCoreAccess {
+  template <class VariantType>
+  static typename VariantType::Variant& Derived(VariantType& self) {  // NOLINT
+    return static_cast<typename VariantType::Variant&>(self);
+  }
+
+  template <class VariantType>
+  static const typename VariantType::Variant& Derived(
+      const VariantType& self) {  // NOLINT
+    return static_cast<const typename VariantType::Variant&>(self);
+  }
+
+  template <class VariantType>
+  static void Destroy(VariantType& self) {  // NOLINT
+    Derived(self).destroy();
+    self.index_ = absl::variant_npos;
+  }
+
+  template <class Variant>
+  static void SetIndex(Variant& self, std::size_t i) {  // NOLINT
+    self.index_ = i;
+  }
+
+  template <class Variant>
+  static void InitFrom(Variant& self, Variant&& other) {  // NOLINT
+    VisitIndices<absl::variant_size<Variant>::value>::Run(
+        InitFromVisitor<Variant, Variant&&>{&self,
+                                            std::forward<Variant>(other)},
+        other.index());
+    self.index_ = other.index();
+  }
+
+  // Access a variant alternative, assuming the index is correct.
+  template <std::size_t I, class Variant>
+  static VariantAccessResult<I, Variant> Access(Variant&& self) {
+    // This cast instead of invocation of AccessUnion with an rvalue is a
+    // workaround for msvc. Without this there is a runtime failure when dealing
+    // with rvalues.
+    // TODO(calabrese) Reduce test case and find a simpler workaround.
+    return static_cast<VariantAccessResult<I, Variant>>(
+        variant_internal::AccessUnion(self.state_, SizeT<I>()));
+  }
+
+  // Access a variant alternative, throwing if the index is incorrect.
+  template <std::size_t I, class Variant>
+  static VariantAccessResult<I, Variant> CheckedAccess(Variant&& self) {
+    if (ABSL_PREDICT_FALSE(self.index_ != I)) {
+      TypedThrowBadVariantAccess<VariantAccessResult<I, Variant>>();
+    }
+
+    return Access<I>(absl::forward<Variant>(self));
+  }
+
+  // The implementation of the move-assignment operation for a variant.
+  template <class VType>
+  struct MoveAssignVisitor {
+    using DerivedType = typename VType::Variant;
+    template <std::size_t NewIndex>
+    void operator()(SizeT<NewIndex> /*new_i*/) const {
+      if (left->index_ == NewIndex) {
+        Access<NewIndex>(*left) = std::move(Access<NewIndex>(*right));
+      } else {
+        Derived(*left).template emplace<NewIndex>(
+            std::move(Access<NewIndex>(*right)));
+      }
+    }
+
+    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
+      Destroy(*left);
+    }
+
+    VType* left;
+    VType* right;
+  };
+
+  template <class VType>
+  static MoveAssignVisitor<VType> MakeMoveAssignVisitor(VType* left,
+                                                        VType* other) {
+    return {left, other};
+  }
+
+  // The implementation of the assignment operation for a variant.
+  template <class VType>
+  struct CopyAssignVisitor {
+    using DerivedType = typename VType::Variant;
+    template <std::size_t NewIndex>
+    void operator()(SizeT<NewIndex> /*new_i*/) const {
+      using New =
+          typename absl::variant_alternative<NewIndex, DerivedType>::type;
+
+      if (left->index_ == NewIndex) {
+        Access<NewIndex>(*left) = Access<NewIndex>(*right);
+      } else if (std::is_nothrow_copy_constructible<New>::value ||
+                 !std::is_nothrow_move_constructible<New>::value) {
+        Derived(*left).template emplace<NewIndex>(Access<NewIndex>(*right));
+      } else {
+        Derived(*left) = DerivedType(Derived(*right));
+      }
+    }
+
+    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
+      Destroy(*left);
+    }
+
+    VType* left;
+    const VType* right;
+  };
+
+  template <class VType>
+  static CopyAssignVisitor<VType> MakeCopyAssignVisitor(VType* left,
+                                                        const VType& other) {
+    return {left, &other};
+  }
+
+  // The implementation of conversion-assignment operations for variant.
+  template <class Left, class QualifiedNew>
+  struct ConversionAssignVisitor {
+    using NewIndex =
+        variant_internal::IndexOfConstructedType<Left, QualifiedNew>;
+
+    void operator()(SizeT<NewIndex::value> /*old_i*/
+                    ) const {
+      Access<NewIndex::value>(*left) = absl::forward<QualifiedNew>(other);
+    }
+
+    template <std::size_t OldIndex>
+    void operator()(SizeT<OldIndex> /*old_i*/
+                    ) const {
+      using New =
+          typename absl::variant_alternative<NewIndex::value, Left>::type;
+      if (std::is_nothrow_constructible<New, QualifiedNew>::value ||
+          !std::is_nothrow_move_constructible<New>::value) {
+        left->template emplace<NewIndex::value>(
+            absl::forward<QualifiedNew>(other));
+      } else {
+        // the standard says "equivalent to
+        // operator=(variant(std::forward<T>(t)))", but we use `emplace` here
+        // because the variant's move assignment operator could be deleted.
+        left->template emplace<NewIndex::value>(
+            New(absl::forward<QualifiedNew>(other)));
+      }
+    }
+
+    Left* left;
+    QualifiedNew&& other;
+  };
+
+  template <class Left, class QualifiedNew>
+  static ConversionAssignVisitor<Left, QualifiedNew>
+  MakeConversionAssignVisitor(Left* left, QualifiedNew&& qual) {
+    return {left, absl::forward<QualifiedNew>(qual)};
+  }
+
+  // Backend for operations for `emplace()` which destructs `*self` then
+  // construct a new alternative with `Args...`.
+  template <std::size_t NewIndex, class Self, class... Args>
+  static typename absl::variant_alternative<NewIndex, Self>::type& Replace(
+      Self* self, Args&&... args) {
+    Destroy(*self);
+    using New = typename absl::variant_alternative<NewIndex, Self>::type;
+    New* const result = ::new (static_cast<void*>(&self->state_))
+        New(absl::forward<Args>(args)...);
+    self->index_ = NewIndex;
+    return *result;
+  }
+
+  template <class LeftVariant, class QualifiedRightVariant>
+  struct InitFromVisitor {
+    template <std::size_t NewIndex>
+    void operator()(SizeT<NewIndex> /*new_i*/) const {
+      using Alternative =
+          typename variant_alternative<NewIndex, LeftVariant>::type;
+      ::new (static_cast<void*>(&left->state_)) Alternative(
+          Access<NewIndex>(std::forward<QualifiedRightVariant>(right)));
+    }
+
+    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
+      // This space intentionally left blank.
+    }
+    LeftVariant* left;
+    QualifiedRightVariant&& right;
+  };
+};
+
+template <class Expected, class... T>
+struct IndexOfImpl;
+
+template <class Expected>
+struct IndexOfImpl<Expected> {
+  using IndexFromEnd = SizeT<0>;
+  using MatchedIndexFromEnd = IndexFromEnd;
+  using MultipleMatches = std::false_type;
+};
+
+template <class Expected, class Head, class... Tail>
+struct IndexOfImpl<Expected, Head, Tail...> : IndexOfImpl<Expected, Tail...> {
+  using IndexFromEnd =
+      SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
+};
+
+template <class Expected, class... Tail>
+struct IndexOfImpl<Expected, Expected, Tail...>
+    : IndexOfImpl<Expected, Tail...> {
+  using IndexFromEnd =
+      SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
+  using MatchedIndexFromEnd = IndexFromEnd;
+  using MultipleMatches = std::integral_constant<
+      bool, IndexOfImpl<Expected, Tail...>::MatchedIndexFromEnd::value != 0>;
+};
+
+template <class Expected, class... Types>
+struct IndexOfMeta {
+  using Results = IndexOfImpl<Expected, Types...>;
+  static_assert(!Results::MultipleMatches::value,
+                "Attempted to access a variant by specifying a type that "
+                "matches more than one alternative.");
+  static_assert(Results::MatchedIndexFromEnd::value != 0,
+                "Attempted to access a variant by specifying a type that does "
+                "not match any alternative.");
+  using type = SizeT<sizeof...(Types) - Results::MatchedIndexFromEnd::value>;
+};
+
+template <class Expected, class... Types>
+using IndexOf = typename IndexOfMeta<Expected, Types...>::type;
+
+template <class Variant, class T, std::size_t CurrIndex>
+struct UnambiguousIndexOfImpl;
+
+// Terminating case encountered once we've checked all of the alternatives
+template <class T, std::size_t CurrIndex>
+struct UnambiguousIndexOfImpl<variant<>, T, CurrIndex> : SizeT<CurrIndex> {};
+
+// Case where T is not Head
+template <class Head, class... Tail, class T, std::size_t CurrIndex>
+struct UnambiguousIndexOfImpl<variant<Head, Tail...>, T, CurrIndex>
+    : UnambiguousIndexOfImpl<variant<Tail...>, T, CurrIndex + 1>::type {};
+
+// Case where T is Head
+template <class Head, class... Tail, std::size_t CurrIndex>
+struct UnambiguousIndexOfImpl<variant<Head, Tail...>, Head, CurrIndex>
+    : SizeT<UnambiguousIndexOfImpl<variant<Tail...>, Head, 0>::value ==
+                    sizeof...(Tail)
+                ? CurrIndex
+                : CurrIndex + sizeof...(Tail) + 1> {};
+
+template <class Variant, class T>
+struct UnambiguousIndexOf;
+
+struct NoMatch {
+  struct type {};
+};
+
+template <class... Alts, class T>
+struct UnambiguousIndexOf<variant<Alts...>, T>
+    : std::conditional<UnambiguousIndexOfImpl<variant<Alts...>, T, 0>::value !=
+                           sizeof...(Alts),
+                       UnambiguousIndexOfImpl<variant<Alts...>, T, 0>,
+                       NoMatch>::type::type {};
+
+template <class T, std::size_t /*Dummy*/>
+using UnambiguousTypeOfImpl = T;
+
+template <class Variant, class T>
+using UnambiguousTypeOfT =
+    UnambiguousTypeOfImpl<T, UnambiguousIndexOf<Variant, T>::value>;
+
+template <class H, class... T>
+class VariantStateBase;
+
+// This is an implementation of the "imaginary function" that is described in
+// [variant.ctor]
+// It is used in order to determine which alternative to construct during
+// initialization from some type T.
+template <class Variant, std::size_t I = 0>
+struct ImaginaryFun;
+
+template <std::size_t I>
+struct ImaginaryFun<variant<>, I> {
+  static void Run() = delete;
+};
+
+template <class H, class... T, std::size_t I>
+struct ImaginaryFun<variant<H, T...>, I> : ImaginaryFun<variant<T...>, I + 1> {
+  using ImaginaryFun<variant<T...>, I + 1>::Run;
+
+  // NOTE: const& and && are used instead of by-value due to lack of guaranteed
+  // move elision of C++17. This may have other minor differences, but tests
+  // pass.
+  static SizeT<I> Run(const H&, SizeT<I>);
+  static SizeT<I> Run(H&&, SizeT<I>);
+};
+
+// The following metafunctions are used in constructor and assignment
+// constraints.
+template <class Self, class T>
+struct IsNeitherSelfNorInPlace : std::true_type {};
+
+template <class Self>
+struct IsNeitherSelfNorInPlace<Self, Self> : std::false_type {};
+
+template <class Self, class T>
+struct IsNeitherSelfNorInPlace<Self, in_place_type_t<T>> : std::false_type {};
+
+template <class Self, std::size_t I>
+struct IsNeitherSelfNorInPlace<Self, in_place_index_t<I>> : std::false_type {};
+
+template <class Variant, class T, class = void>
+struct ConversionIsPossibleImpl : std::false_type {};
+
+template <class Variant, class T>
+struct ConversionIsPossibleImpl<
+    Variant, T,
+    void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>>
+    : std::true_type {};
+
+template <class Variant, class T>
+struct ConversionIsPossible : ConversionIsPossibleImpl<Variant, T>::type {};
+
+template <class Variant, class T>
+struct IndexOfConstructedType<
+    Variant, T,
+    void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>>
+    : decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {})) {};
+
+template <std::size_t... Is>
+struct ContainsVariantNPos
+    : absl::negation<std::is_same<  // NOLINT
+          absl::integer_sequence<bool, 0 <= Is...>,
+          absl::integer_sequence<bool, Is != absl::variant_npos...>>> {};
+
+template <class Op, class... QualifiedVariants>
+using RawVisitResult =
+    absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
+
+// NOTE: The spec requires that all return-paths yield the same type and is not
+// SFINAE-friendly, so we can deduce the return type by examining the first
+// result. If it's not callable, then we get an error, but are compliant and
+// fast to compile.
+// TODO(calabrese) Possibly rewrite in a way that yields better compile errors
+// at the cost of longer compile-times.
+template <class Op, class... QualifiedVariants>
+struct VisitResultImpl {
+  using type =
+      absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
+};
+
+// Done in two steps intentionally so that we don't cause substitution to fail.
+template <class Op, class... QualifiedVariants>
+using VisitResult = typename VisitResultImpl<Op, QualifiedVariants...>::type;
+
+template <class Op, class... QualifiedVariants>
+struct PerformVisitation {
+  using ReturnType = VisitResult<Op, QualifiedVariants...>;
+
+  template <std::size_t... Is>
+  constexpr ReturnType operator()(SizeT<Is>... indices) const {
+    return Run(typename ContainsVariantNPos<Is...>::type{},
+               absl::index_sequence_for<QualifiedVariants...>(), indices...);
+  }
+
+  template <std::size_t... TupIs, std::size_t... Is>
+  constexpr ReturnType Run(std::false_type /*has_valueless*/,
+                           index_sequence<TupIs...>, SizeT<Is>...) const {
+    static_assert(
+        std::is_same<ReturnType,
+                     absl::result_of_t<Op(VariantAccessResult<
+                                          Is, QualifiedVariants>...)>>::value,
+        "All visitation overloads must have the same return type.");
+    return absl::base_internal::invoke(
+        absl::forward<Op>(op),
+        VariantCoreAccess::Access<Is>(
+            absl::forward<QualifiedVariants>(std::get<TupIs>(variant_tup)))...);
+  }
+
+  template <std::size_t... TupIs, std::size_t... Is>
+  [[noreturn]] ReturnType Run(std::true_type /*has_valueless*/,
+                              index_sequence<TupIs...>, SizeT<Is>...) const {
+    absl::variant_internal::ThrowBadVariantAccess();
+  }
+
+  // TODO(calabrese) Avoid using a tuple, which causes lots of instantiations
+  // Attempts using lambda variadic captures fail on current GCC.
+  std::tuple<QualifiedVariants&&...> variant_tup;
+  Op&& op;
+};
+
+template <class... T>
+union Union;
+
+// We want to allow for variant<> to be trivial. For that, we need the default
+// constructor to be trivial, which means we can't define it ourselves.
+// Instead, we use a non-default constructor that takes NoopConstructorTag
+// that doesn't affect the triviality of the types.
+struct NoopConstructorTag {};
+
+template <std::size_t I>
+struct EmplaceTag {};
+
+template <>
+union Union<> {
+  constexpr explicit Union(NoopConstructorTag) noexcept {}
+};
+
+// Suppress bogus warning on MSVC: MSVC complains that Union<T...> has a defined
+// deleted destructor from the `std::is_destructible` check below.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4624)
+#endif  // _MSC_VER
+
+template <class Head, class... Tail>
+union Union<Head, Tail...> {
+  using TailUnion = Union<Tail...>;
+
+  explicit constexpr Union(NoopConstructorTag /*tag*/) noexcept
+      : tail(NoopConstructorTag()) {}
+
+  template <class... P>
+  explicit constexpr Union(EmplaceTag<0>, P&&... args)
+      : head(absl::forward<P>(args)...) {}
+
+  template <std::size_t I, class... P>
+  explicit constexpr Union(EmplaceTag<I>, P&&... args)
+      : tail(EmplaceTag<I - 1>{}, absl::forward<P>(args)...) {}
+
+  Head head;
+  TailUnion tail;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
+
+// TODO(calabrese) Just contain a Union in this union (certain configs fail).
+template <class... T>
+union DestructibleUnionImpl;
+
+template <>
+union DestructibleUnionImpl<> {
+  constexpr explicit DestructibleUnionImpl(NoopConstructorTag) noexcept {}
+};
+
+template <class Head, class... Tail>
+union DestructibleUnionImpl<Head, Tail...> {
+  using TailUnion = DestructibleUnionImpl<Tail...>;
+
+  explicit constexpr DestructibleUnionImpl(NoopConstructorTag /*tag*/) noexcept
+      : tail(NoopConstructorTag()) {}
+
+  template <class... P>
+  explicit constexpr DestructibleUnionImpl(EmplaceTag<0>, P&&... args)
+      : head(absl::forward<P>(args)...) {}
+
+  template <std::size_t I, class... P>
+  explicit constexpr DestructibleUnionImpl(EmplaceTag<I>, P&&... args)
+      : tail(EmplaceTag<I - 1>{}, absl::forward<P>(args)...) {}
+
+  ~DestructibleUnionImpl() {}
+
+  Head head;
+  TailUnion tail;
+};
+
+// This union type is destructible even if one or more T are not trivially
+// destructible. In the case that all T are trivially destructible, then so is
+// this resultant type.
+template <class... T>
+using DestructibleUnion =
+    absl::conditional_t<std::is_destructible<Union<T...>>::value, Union<T...>,
+                        DestructibleUnionImpl<T...>>;
+
+// Deepest base, containing the actual union and the discriminator
+template <class H, class... T>
+class VariantStateBase {
+ protected:
+  using Variant = variant<H, T...>;
+
+  template <class LazyH = H,
+            class ConstructibleH = absl::enable_if_t<
+                std::is_default_constructible<LazyH>::value, LazyH>>
+  constexpr VariantStateBase() noexcept(
+      std::is_nothrow_default_constructible<ConstructibleH>::value)
+      : state_(EmplaceTag<0>()), index_(0) {}
+
+  template <std::size_t I, class... P>
+  explicit constexpr VariantStateBase(EmplaceTag<I> tag, P&&... args)
+      : state_(tag, absl::forward<P>(args)...), index_(I) {}
+
+  explicit constexpr VariantStateBase(NoopConstructorTag)
+      : state_(NoopConstructorTag()), index_(variant_npos) {}
+
+  void destroy() {}  // Does nothing (shadowed in child if non-trivial)
+
+  DestructibleUnion<H, T...> state_;
+  std::size_t index_;
+};
+
+using absl::internal::identity;
+
+// OverloadSet::Overload() is a unary function which is overloaded to
+// take any of the element types of the variant, by reference-to-const.
+// The return type of the overload on T is identity<T>, so that you
+// can statically determine which overload was called.
+//
+// Overload() is not defined, so it can only be called in unevaluated
+// contexts.
+template <typename... Ts>
+struct OverloadSet;
+
+template <typename T, typename... Ts>
+struct OverloadSet<T, Ts...> : OverloadSet<Ts...> {
+  using Base = OverloadSet<Ts...>;
+  static identity<T> Overload(const T&);
+  using Base::Overload;
+};
+
+template <>
+struct OverloadSet<> {
+  // For any case not handled above.
+  static void Overload(...);
+};
+
+template <class T>
+using LessThanResult = decltype(std::declval<T>() < std::declval<T>());
+
+template <class T>
+using GreaterThanResult = decltype(std::declval<T>() > std::declval<T>());
+
+template <class T>
+using LessThanOrEqualResult = decltype(std::declval<T>() <= std::declval<T>());
+
+template <class T>
+using GreaterThanOrEqualResult =
+    decltype(std::declval<T>() >= std::declval<T>());
+
+template <class T>
+using EqualResult = decltype(std::declval<T>() == std::declval<T>());
+
+template <class T>
+using NotEqualResult = decltype(std::declval<T>() != std::declval<T>());
+
+using type_traits_internal::is_detected_convertible;
+
+template <class... T>
+using RequireAllHaveEqualT = absl::enable_if_t<
+    absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value,
+    bool>;
+
+template <class... T>
+using RequireAllHaveNotEqualT =
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, NotEqualResult, T>...>::value,
+                      bool>;
+
+template <class... T>
+using RequireAllHaveLessThanT =
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, LessThanResult, T>...>::value,
+                      bool>;
+
+template <class... T>
+using RequireAllHaveLessThanOrEqualT =
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, LessThanOrEqualResult, T>...>::value,
+                      bool>;
+
+template <class... T>
+using RequireAllHaveGreaterThanOrEqualT =
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, GreaterThanOrEqualResult, T>...>::value,
+                      bool>;
+
+template <class... T>
+using RequireAllHaveGreaterThanT =
+    absl::enable_if_t<absl::conjunction<is_detected_convertible<
+                          bool, GreaterThanResult, T>...>::value,
+                      bool>;
+
+// Helper template containing implementations details of variant that can't go
+// in the private section. For convenience, this takes the variant type as a
+// single template parameter.
+template <typename T>
+struct VariantHelper;
+
+template <typename... Ts>
+struct VariantHelper<variant<Ts...>> {
+  // Type metafunction which returns the element type selected if
+  // OverloadSet::Overload() is well-formed when called with argument type U.
+  template <typename U>
+  using BestMatch = decltype(
+      variant_internal::OverloadSet<Ts...>::Overload(std::declval<U>()));
+
+  // Type metafunction which returns true if OverloadSet::Overload() is
+  // well-formed when called with argument type U.
+  // CanAccept can't be just an alias because there is a MSVC bug on parameter
+  // pack expansion involving decltype.
+  template <typename U>
+  struct CanAccept :
+      std::integral_constant<bool, !std::is_void<BestMatch<U>>::value> {};
+
+  // Type metafunction which returns true if Other is an instantiation of
+  // variant, and variants's converting constructor from Other will be
+  // well-formed. We will use this to remove constructors that would be
+  // ill-formed from the overload set.
+  template <typename Other>
+  struct CanConvertFrom;
+
+  template <typename... Us>
+  struct CanConvertFrom<variant<Us...>>
+      : public absl::conjunction<CanAccept<Us>...> {};
+};
+
+// A type with nontrivial copy ctor and trivial move ctor.
+struct TrivialMoveOnly {
+  TrivialMoveOnly(TrivialMoveOnly&&) = default;
+};
+
+// Trait class to detect whether a type is trivially move constructible.
+// A union's defaulted copy/move constructor is deleted if any variant member's
+// copy/move constructor is nontrivial.
+template <typename T>
+struct IsTriviallyMoveConstructible:
+  std::is_move_constructible<Union<T, TrivialMoveOnly>> {};
+
+// To guarantee triviality of all special-member functions that can be trivial,
+// we use a chain of conditional bases for each one.
+// The order of inheritance of bases from child to base are logically:
+//
+// variant
+// VariantCopyAssignBase
+// VariantMoveAssignBase
+// VariantCopyBase
+// VariantMoveBase
+// VariantStateBaseDestructor
+// VariantStateBase
+//
+// Note that there is a separate branch at each base that is dependent on
+// whether or not that corresponding special-member-function can be trivial in
+// the resultant variant type.
+
+template <class... T>
+class VariantStateBaseDestructorNontrivial;
+
+template <class... T>
+class VariantMoveBaseNontrivial;
+
+template <class... T>
+class VariantCopyBaseNontrivial;
+
+template <class... T>
+class VariantMoveAssignBaseNontrivial;
+
+template <class... T>
+class VariantCopyAssignBaseNontrivial;
+
+// Base that is dependent on whether or not the destructor can be trivial.
+template <class... T>
+using VariantStateBaseDestructor =
+    absl::conditional_t<std::is_destructible<Union<T...>>::value,
+                        VariantStateBase<T...>,
+                        VariantStateBaseDestructorNontrivial<T...>>;
+
+// Base that is dependent on whether or not the move-constructor can be
+// implicitly generated by the compiler (trivial or deleted).
+// Previously we were using `std::is_move_constructible<Union<T...>>` to check
+// whether all Ts have trivial move constructor, but it ran into a GCC bug:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84866
+// So we have to use a different approach (i.e. `HasTrivialMoveConstructor`) to
+// work around the bug.
+template <class... T>
+using VariantMoveBase = absl::conditional_t<
+    absl::disjunction<
+        absl::negation<absl::conjunction<std::is_move_constructible<T>...>>,
+        absl::conjunction<IsTriviallyMoveConstructible<T>...>>::value,
+    VariantStateBaseDestructor<T...>, VariantMoveBaseNontrivial<T...>>;
+
+// Base that is dependent on whether or not the copy-constructor can be trivial.
+template <class... T>
+using VariantCopyBase = absl::conditional_t<
+    absl::disjunction<
+        absl::negation<absl::conjunction<std::is_copy_constructible<T>...>>,
+        std::is_copy_constructible<Union<T...>>>::value,
+    VariantMoveBase<T...>, VariantCopyBaseNontrivial<T...>>;
+
+// Base that is dependent on whether or not the move-assign can be trivial.
+template <class... T>
+using VariantMoveAssignBase = absl::conditional_t<
+    absl::disjunction<
+        absl::conjunction<absl::is_move_assignable<Union<T...>>,
+                          std::is_move_constructible<Union<T...>>,
+                          std::is_destructible<Union<T...>>>,
+        absl::negation<absl::conjunction<std::is_move_constructible<T>...,
+                                         // Note: We're not qualifying this with
+                                         // absl:: because it doesn't compile
+                                         // under MSVC.
+                                         is_move_assignable<T>...>>>::value,
+    VariantCopyBase<T...>, VariantMoveAssignBaseNontrivial<T...>>;
+
+// Base that is dependent on whether or not the copy-assign can be trivial.
+template <class... T>
+using VariantCopyAssignBase = absl::conditional_t<
+    absl::disjunction<
+        absl::conjunction<absl::is_copy_assignable<Union<T...>>,
+                          std::is_copy_constructible<Union<T...>>,
+                          std::is_destructible<Union<T...>>>,
+        absl::negation<absl::conjunction<std::is_copy_constructible<T>...,
+                                         // Note: We're not qualifying this with
+                                         // absl:: because it doesn't compile
+                                         // under MSVC.
+                                         is_copy_assignable<T>...>>>::value,
+    VariantMoveAssignBase<T...>, VariantCopyAssignBaseNontrivial<T...>>;
+
+template <class... T>
+using VariantBase = VariantCopyAssignBase<T...>;
+
+template <class... T>
+class VariantStateBaseDestructorNontrivial : protected VariantStateBase<T...> {
+ private:
+  using Base = VariantStateBase<T...>;
+
+ protected:
+  using Base::Base;
+
+  VariantStateBaseDestructorNontrivial() = default;
+  VariantStateBaseDestructorNontrivial(VariantStateBaseDestructorNontrivial&&) =
+      default;
+  VariantStateBaseDestructorNontrivial(
+      const VariantStateBaseDestructorNontrivial&) = default;
+  VariantStateBaseDestructorNontrivial& operator=(
+      VariantStateBaseDestructorNontrivial&&) = default;
+  VariantStateBaseDestructorNontrivial& operator=(
+      const VariantStateBaseDestructorNontrivial&) = default;
+
+  struct Destroyer {
+    template <std::size_t I>
+    void operator()(SizeT<I> i) const {
+      using Alternative =
+          typename absl::variant_alternative<I, variant<T...>>::type;
+      variant_internal::AccessUnion(self->state_, i).~Alternative();
+    }
+
+    void operator()(SizeT<absl::variant_npos> /*i*/) const {
+      // This space intentionally left blank
+    }
+
+    VariantStateBaseDestructorNontrivial* self;
+  };
+
+  void destroy() { VisitIndices<sizeof...(T)>::Run(Destroyer{this}, index_); }
+
+  ~VariantStateBaseDestructorNontrivial() { destroy(); }
+
+ protected:
+  using Base::index_;
+  using Base::state_;
+};
+
+template <class... T>
+class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...> {
+ private:
+  using Base = VariantStateBaseDestructor<T...>;
+
+ protected:
+  using Base::Base;
+
+  struct Construct {
+    template <std::size_t I>
+    void operator()(SizeT<I> i) const {
+      using Alternative =
+          typename absl::variant_alternative<I, variant<T...>>::type;
+      ::new (static_cast<void*>(&self->state_)) Alternative(
+          variant_internal::AccessUnion(absl::move(other->state_), i));
+    }
+
+    void operator()(SizeT<absl::variant_npos> /*i*/) const {}
+
+    VariantMoveBaseNontrivial* self;
+    VariantMoveBaseNontrivial* other;
+  };
+
+  VariantMoveBaseNontrivial() = default;
+  VariantMoveBaseNontrivial(VariantMoveBaseNontrivial&& other) noexcept(
+      absl::conjunction<std::is_nothrow_move_constructible<T>...>::value)
+      : Base(NoopConstructorTag()) {
+    VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
+    index_ = other.index_;
+  }
+
+  VariantMoveBaseNontrivial(VariantMoveBaseNontrivial const&) = default;
+
+  VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial&&) = default;
+  VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial const&) =
+      default;
+
+ protected:
+  using Base::index_;
+  using Base::state_;
+};
+
+template <class... T>
+class VariantCopyBaseNontrivial : protected VariantMoveBase<T...> {
+ private:
+  using Base = VariantMoveBase<T...>;
+
+ protected:
+  using Base::Base;
+
+  VariantCopyBaseNontrivial() = default;
+  VariantCopyBaseNontrivial(VariantCopyBaseNontrivial&&) = default;
+
+  struct Construct {
+    template <std::size_t I>
+    void operator()(SizeT<I> i) const {
+      using Alternative =
+          typename absl::variant_alternative<I, variant<T...>>::type;
+      ::new (static_cast<void*>(&self->state_))
+          Alternative(variant_internal::AccessUnion(other->state_, i));
+    }
+
+    void operator()(SizeT<absl::variant_npos> /*i*/) const {}
+
+    VariantCopyBaseNontrivial* self;
+    const VariantCopyBaseNontrivial* other;
+  };
+
+  VariantCopyBaseNontrivial(VariantCopyBaseNontrivial const& other)
+      : Base(NoopConstructorTag()) {
+    VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
+    index_ = other.index_;
+  }
+
+  VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial&&) = default;
+  VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial const&) =
+      default;
+
+ protected:
+  using Base::index_;
+  using Base::state_;
+};
+
+template <class... T>
+class VariantMoveAssignBaseNontrivial : protected VariantCopyBase<T...> {
+  friend struct VariantCoreAccess;
+
+ private:
+  using Base = VariantCopyBase<T...>;
+
+ protected:
+  using Base::Base;
+
+  VariantMoveAssignBaseNontrivial() = default;
+  VariantMoveAssignBaseNontrivial(VariantMoveAssignBaseNontrivial&&) = default;
+  VariantMoveAssignBaseNontrivial(const VariantMoveAssignBaseNontrivial&) =
+      default;
+  VariantMoveAssignBaseNontrivial& operator=(
+      VariantMoveAssignBaseNontrivial const&) = default;
+
+    VariantMoveAssignBaseNontrivial&
+    operator=(VariantMoveAssignBaseNontrivial&& other) noexcept(
+        absl::conjunction<std::is_nothrow_move_constructible<T>...,
+                          std::is_nothrow_move_assignable<T>...>::value) {
+      VisitIndices<sizeof...(T)>::Run(
+          VariantCoreAccess::MakeMoveAssignVisitor(this, &other), other.index_);
+      return *this;
+    }
+
+ protected:
+  using Base::index_;
+  using Base::state_;
+};
+
+template <class... T>
+class VariantCopyAssignBaseNontrivial : protected VariantMoveAssignBase<T...> {
+  friend struct VariantCoreAccess;
+
+ private:
+  using Base = VariantMoveAssignBase<T...>;
+
+ protected:
+  using Base::Base;
+
+  VariantCopyAssignBaseNontrivial() = default;
+  VariantCopyAssignBaseNontrivial(VariantCopyAssignBaseNontrivial&&) = default;
+  VariantCopyAssignBaseNontrivial(const VariantCopyAssignBaseNontrivial&) =
+      default;
+  VariantCopyAssignBaseNontrivial& operator=(
+      VariantCopyAssignBaseNontrivial&&) = default;
+
+    VariantCopyAssignBaseNontrivial& operator=(
+        const VariantCopyAssignBaseNontrivial& other) {
+      VisitIndices<sizeof...(T)>::Run(
+          VariantCoreAccess::MakeCopyAssignVisitor(this, other), other.index_);
+      return *this;
+    }
+
+ protected:
+  using Base::index_;
+  using Base::state_;
+};
+
+////////////////////////////////////////
+// Visitors for Comparison Operations //
+////////////////////////////////////////
+
+template <class... Types>
+struct EqualsOp {
+  const variant<Types...>* v;
+  const variant<Types...>* w;
+
+  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+    return true;
+  }
+
+  template <std::size_t I>
+  constexpr bool operator()(SizeT<I> /*v_i*/) const {
+    return VariantCoreAccess::Access<I>(*v) == VariantCoreAccess::Access<I>(*w);
+  }
+};
+
+template <class... Types>
+struct NotEqualsOp {
+  const variant<Types...>* v;
+  const variant<Types...>* w;
+
+  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+    return false;
+  }
+
+  template <std::size_t I>
+  constexpr bool operator()(SizeT<I> /*v_i*/) const {
+    return VariantCoreAccess::Access<I>(*v) != VariantCoreAccess::Access<I>(*w);
+  }
+};
+
+template <class... Types>
+struct LessThanOp {
+  const variant<Types...>* v;
+  const variant<Types...>* w;
+
+  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+    return false;
+  }
+
+  template <std::size_t I>
+  constexpr bool operator()(SizeT<I> /*v_i*/) const {
+    return VariantCoreAccess::Access<I>(*v) < VariantCoreAccess::Access<I>(*w);
+  }
+};
+
+template <class... Types>
+struct GreaterThanOp {
+  const variant<Types...>* v;
+  const variant<Types...>* w;
+
+  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+    return false;
+  }
+
+  template <std::size_t I>
+  constexpr bool operator()(SizeT<I> /*v_i*/) const {
+    return VariantCoreAccess::Access<I>(*v) > VariantCoreAccess::Access<I>(*w);
+  }
+};
+
+template <class... Types>
+struct LessThanOrEqualsOp {
+  const variant<Types...>* v;
+  const variant<Types...>* w;
+
+  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+    return true;
+  }
+
+  template <std::size_t I>
+  constexpr bool operator()(SizeT<I> /*v_i*/) const {
+    return VariantCoreAccess::Access<I>(*v) <= VariantCoreAccess::Access<I>(*w);
+  }
+};
+
+template <class... Types>
+struct GreaterThanOrEqualsOp {
+  const variant<Types...>* v;
+  const variant<Types...>* w;
+
+  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+    return true;
+  }
+
+  template <std::size_t I>
+  constexpr bool operator()(SizeT<I> /*v_i*/) const {
+    return VariantCoreAccess::Access<I>(*v) >= VariantCoreAccess::Access<I>(*w);
+  }
+};
+
+// Precondition: v.index() == w.index();
+template <class... Types>
+struct SwapSameIndex {
+  variant<Types...>* v;
+  variant<Types...>* w;
+  template <std::size_t I>
+  void operator()(SizeT<I>) const {
+    type_traits_internal::Swap(VariantCoreAccess::Access<I>(*v),
+                               VariantCoreAccess::Access<I>(*w));
+  }
+
+  void operator()(SizeT<variant_npos>) const {}
+};
+
+// TODO(calabrese) do this from a different namespace for proper adl usage
+template <class... Types>
+struct Swap {
+  variant<Types...>* v;
+  variant<Types...>* w;
+
+  void generic_swap() const {
+    variant<Types...> tmp(std::move(*w));
+    VariantCoreAccess::Destroy(*w);
+    VariantCoreAccess::InitFrom(*w, std::move(*v));
+    VariantCoreAccess::Destroy(*v);
+    VariantCoreAccess::InitFrom(*v, std::move(tmp));
+  }
+
+  void operator()(SizeT<absl::variant_npos> /*w_i*/) const {
+    if (!v->valueless_by_exception()) {
+      generic_swap();
+    }
+  }
+
+  template <std::size_t Wi>
+  void operator()(SizeT<Wi> /*w_i*/) {
+    if (v->index() == Wi) {
+      VisitIndices<sizeof...(Types)>::Run(SwapSameIndex<Types...>{v, w}, Wi);
+    } else {
+      generic_swap();
+    }
+  }
+};
+
+template <typename Variant, typename = void, typename... Ts>
+struct VariantHashBase {
+  VariantHashBase() = delete;
+  VariantHashBase(const VariantHashBase&) = delete;
+  VariantHashBase(VariantHashBase&&) = delete;
+  VariantHashBase& operator=(const VariantHashBase&) = delete;
+  VariantHashBase& operator=(VariantHashBase&&) = delete;
+};
+
+struct VariantHashVisitor {
+  template <typename T>
+  size_t operator()(const T& t) {
+    return std::hash<T>{}(t);
+  }
+};
+
+template <typename Variant, typename... Ts>
+struct VariantHashBase<Variant,
+                       absl::enable_if_t<absl::conjunction<
+                           type_traits_internal::IsHashable<Ts>...>::value>,
+                       Ts...> {
+  using argument_type = Variant;
+  using result_type = size_t;
+  size_t operator()(const Variant& var) const {
+    type_traits_internal::AssertHashEnabled<Ts...>();
+    if (var.valueless_by_exception()) {
+      return 239799884;
+    }
+    size_t result = VisitIndices<variant_size<Variant>::value>::Run(
+        PerformVisitation<VariantHashVisitor, const Variant&>{
+            std::forward_as_tuple(var), VariantHashVisitor{}},
+        var.index());
+    // Combine the index and the hash result in order to distinguish
+    // std::variant<int, int> holding the same value as different alternative.
+    return result ^ var.index();
+  }
+};
+
+}  // namespace variant_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // !defined(ABSL_USES_STD_VARIANT)
+#endif  // ABSL_TYPES_VARIANT_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/optional.h b/CAPI/cpp/grpc/include/absl/types/optional.h
new file mode 100644
index 0000000..134b2af
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/optional.h
@@ -0,0 +1,779 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// optional.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::optional` type for holding a value which
+// may or may not be present. This type is useful for providing value semantics
+// for operations that may either wish to return or hold "something-or-nothing".
+//
+// Example:
+//
+//   // A common way to signal operation failure is to provide an output
+//   // parameter and a bool return type:
+//   bool AcquireResource(const Input&, Resource * out);
+//
+//   // Providing an absl::optional return type provides a cleaner API:
+//   absl::optional<Resource> AcquireResource(const Input&);
+//
+// `absl::optional` is a C++11 compatible version of the C++17 `std::optional`
+// abstraction and is designed to be a drop-in replacement for code compliant
+// with C++17.
+#ifndef ABSL_TYPES_OPTIONAL_H_
+#define ABSL_TYPES_OPTIONAL_H_
+
+#include "absl/base/config.h"   // TODO(calabrese) IWYU removal?
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_USES_STD_OPTIONAL
+
+#include <optional>  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using std::bad_optional_access;
+using std::optional;
+using std::make_optional;
+using std::nullopt_t;
+using std::nullopt;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_USES_STD_OPTIONAL
+
+#include <cassert>
+#include <functional>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/inline_variable.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/bad_optional_access.h"
+#include "absl/types/internal/optional.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// nullopt_t
+//
+// Class type for `absl::nullopt` used to indicate an `absl::optional<T>` type
+// that does not contain a value.
+struct nullopt_t {
+  // It must not be default-constructible to avoid ambiguity for opt = {}.
+  explicit constexpr nullopt_t(optional_internal::init_t) noexcept {}
+};
+
+// nullopt
+//
+// A tag constant of type `absl::nullopt_t` used to indicate an empty
+// `absl::optional` in certain functions, such as construction or assignment.
+ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt,
+                               nullopt_t(optional_internal::init_t()));
+
+// -----------------------------------------------------------------------------
+// absl::optional
+// -----------------------------------------------------------------------------
+//
+// A value of type `absl::optional<T>` holds either a value of `T` or an
+// "empty" value.  When it holds a value of `T`, it stores it as a direct
+// sub-object, so `sizeof(optional<T>)` is approximately
+// `sizeof(T) + sizeof(bool)`.
+//
+// This implementation is based on the specification in the latest draft of the
+// C++17 `std::optional` specification as of May 2017, section 20.6.
+//
+// Differences between `absl::optional<T>` and `std::optional<T>` include:
+//
+//    * `constexpr` is not used for non-const member functions.
+//      (dependency on some differences between C++11 and C++14.)
+//    * `absl::nullopt` and `absl::in_place` are not declared `constexpr`. We
+//      need the inline variable support in C++17 for external linkage.
+//    * Throws `absl::bad_optional_access` instead of
+//      `std::bad_optional_access`.
+//    * `make_optional()` cannot be declared `constexpr` due to the absence of
+//      guaranteed copy elision.
+//    * The move constructor's `noexcept` specification is stronger, i.e. if the
+//      default allocator is non-throwing (via setting
+//      `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
+//      we assume
+//       a) move constructors should only throw due to allocation failure and
+//       b) if T's move constructor allocates, it uses the same allocation
+//          function as the default allocator.
+//
+template <typename T>
+class optional : private optional_internal::optional_data<T>,
+                 private optional_internal::optional_ctor_base<
+                     optional_internal::ctor_copy_traits<T>::traits>,
+                 private optional_internal::optional_assign_base<
+                     optional_internal::assign_copy_traits<T>::traits> {
+  using data_base = optional_internal::optional_data<T>;
+
+ public:
+  typedef T value_type;
+
+  // Constructors
+
+  // Constructs an `optional` holding an empty value, NOT a default constructed
+  // `T`.
+  constexpr optional() noexcept {}
+
+  // Constructs an `optional` initialized with `nullopt` to hold an empty value.
+  constexpr optional(nullopt_t) noexcept {}  // NOLINT(runtime/explicit)
+
+  // Copy constructor, standard semantics
+  optional(const optional&) = default;
+
+  // Move constructor, standard semantics
+  optional(optional&&) = default;
+
+  // Constructs a non-empty `optional` direct-initialized value of type `T` from
+  // the arguments `std::forward<Args>(args)...`  within the `optional`.
+  // (The `in_place_t` is a tag used to indicate that the contained object
+  // should be constructed in-place.)
+  template <typename InPlaceT, typename... Args,
+            absl::enable_if_t<absl::conjunction<
+                std::is_same<InPlaceT, in_place_t>,
+                std::is_constructible<T, Args&&...> >::value>* = nullptr>
+  constexpr explicit optional(InPlaceT, Args&&... args)
+      : data_base(in_place_t(), absl::forward<Args>(args)...) {}
+
+  // Constructs a non-empty `optional` direct-initialized value of type `T` from
+  // the arguments of an initializer_list and `std::forward<Args>(args)...`.
+  // (The `in_place_t` is a tag used to indicate that the contained object
+  // should be constructed in-place.)
+  template <typename U, typename... Args,
+            typename = typename std::enable_if<std::is_constructible<
+                T, std::initializer_list<U>&, Args&&...>::value>::type>
+  constexpr explicit optional(in_place_t, std::initializer_list<U> il,
+                              Args&&... args)
+      : data_base(in_place_t(), il, absl::forward<Args>(args)...) {
+  }
+
+  // Value constructor (implicit)
+  template <
+      typename U = T,
+      typename std::enable_if<
+          absl::conjunction<absl::negation<std::is_same<
+                                in_place_t, typename std::decay<U>::type> >,
+                            absl::negation<std::is_same<
+                                optional<T>, typename std::decay<U>::type> >,
+                            std::is_convertible<U&&, T>,
+                            std::is_constructible<T, U&&> >::value,
+          bool>::type = false>
+  constexpr optional(U&& v) : data_base(in_place_t(), absl::forward<U>(v)) {}
+
+  // Value constructor (explicit)
+  template <
+      typename U = T,
+      typename std::enable_if<
+          absl::conjunction<absl::negation<std::is_same<
+                                in_place_t, typename std::decay<U>::type>>,
+                            absl::negation<std::is_same<
+                                optional<T>, typename std::decay<U>::type>>,
+                            absl::negation<std::is_convertible<U&&, T>>,
+                            std::is_constructible<T, U&&>>::value,
+          bool>::type = false>
+  explicit constexpr optional(U&& v)
+      : data_base(in_place_t(), absl::forward<U>(v)) {}
+
+  // Converting copy constructor (implicit)
+  template <typename U,
+            typename std::enable_if<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U> >,
+                    std::is_constructible<T, const U&>,
+                    absl::negation<
+                        optional_internal::
+                            is_constructible_convertible_from_optional<T, U> >,
+                    std::is_convertible<const U&, T> >::value,
+                bool>::type = false>
+  optional(const optional<U>& rhs) {
+    if (rhs) {
+      this->construct(*rhs);
+    }
+  }
+
+  // Converting copy constructor (explicit)
+  template <typename U,
+            typename std::enable_if<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U>>,
+                    std::is_constructible<T, const U&>,
+                    absl::negation<
+                        optional_internal::
+                            is_constructible_convertible_from_optional<T, U>>,
+                    absl::negation<std::is_convertible<const U&, T>>>::value,
+                bool>::type = false>
+  explicit optional(const optional<U>& rhs) {
+    if (rhs) {
+      this->construct(*rhs);
+    }
+  }
+
+  // Converting move constructor (implicit)
+  template <typename U,
+            typename std::enable_if<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U> >,
+                    std::is_constructible<T, U&&>,
+                    absl::negation<
+                        optional_internal::
+                            is_constructible_convertible_from_optional<T, U> >,
+                    std::is_convertible<U&&, T> >::value,
+                bool>::type = false>
+  optional(optional<U>&& rhs) {
+    if (rhs) {
+      this->construct(std::move(*rhs));
+    }
+  }
+
+  // Converting move constructor (explicit)
+  template <
+      typename U,
+      typename std::enable_if<
+          absl::conjunction<
+              absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+              absl::negation<
+                  optional_internal::is_constructible_convertible_from_optional<
+                      T, U>>,
+              absl::negation<std::is_convertible<U&&, T>>>::value,
+          bool>::type = false>
+  explicit optional(optional<U>&& rhs) {
+    if (rhs) {
+      this->construct(std::move(*rhs));
+    }
+  }
+
+  // Destructor. Trivial if `T` is trivially destructible.
+  ~optional() = default;
+
+  // Assignment Operators
+
+  // Assignment from `nullopt`
+  //
+  // Example:
+  //
+  //   struct S { int value; };
+  //   optional<S> opt = absl::nullopt;  // Could also use opt = { };
+  optional& operator=(nullopt_t) noexcept {
+    this->destruct();
+    return *this;
+  }
+
+  // Copy assignment operator, standard semantics
+  optional& operator=(const optional& src) = default;
+
+  // Move assignment operator, standard semantics
+  optional& operator=(optional&& src) = default;
+
+  // Value assignment operators
+  template <typename U = T,
+            int&...,  // Workaround an internal compiler error in GCC 5 to 10.
+            typename = typename std::enable_if<absl::conjunction<
+                absl::negation<
+                    std::is_same<optional<T>, typename std::decay<U>::type> >,
+                absl::negation<absl::conjunction<
+                    std::is_scalar<T>,
+                    std::is_same<T, typename std::decay<U>::type> > >,
+                std::is_constructible<T, U>,
+                std::is_assignable<T&, U> >::value>::type>
+  optional& operator=(U&& v) {
+    this->assign(std::forward<U>(v));
+    return *this;
+  }
+
+  template <
+      typename U,
+      int&...,  // Workaround an internal compiler error in GCC 5 to 10.
+      typename = typename std::enable_if<absl::conjunction<
+          absl::negation<std::is_same<T, U> >,
+          std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>,
+          absl::negation<
+              optional_internal::
+                  is_constructible_convertible_assignable_from_optional<
+                      T, U> > >::value>::type>
+  optional& operator=(const optional<U>& rhs) {
+    if (rhs) {
+      this->assign(*rhs);
+    } else {
+      this->destruct();
+    }
+    return *this;
+  }
+
+  template <typename U,
+            int&...,  // Workaround an internal compiler error in GCC 5 to 10.
+            typename = typename std::enable_if<absl::conjunction<
+                absl::negation<std::is_same<T, U> >,
+                std::is_constructible<T, U>, std::is_assignable<T&, U>,
+                absl::negation<
+                    optional_internal::
+                        is_constructible_convertible_assignable_from_optional<
+                            T, U> > >::value>::type>
+  optional& operator=(optional<U>&& rhs) {
+    if (rhs) {
+      this->assign(std::move(*rhs));
+    } else {
+      this->destruct();
+    }
+    return *this;
+  }
+
+  // Modifiers
+
+  // optional::reset()
+  //
+  // Destroys the inner `T` value of an `absl::optional` if one is present.
+  ABSL_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
+
+  // optional::emplace()
+  //
+  // (Re)constructs the underlying `T` in-place with the given forwarded
+  // arguments.
+  //
+  // Example:
+  //
+  //   optional<Foo> opt;
+  //   opt.emplace(arg1,arg2,arg3);  // Constructs Foo(arg1,arg2,arg3)
+  //
+  // If the optional is non-empty, and the `args` refer to subobjects of the
+  // current object, then behaviour is undefined, because the current object
+  // will be destructed before the new object is constructed with `args`.
+  template <typename... Args,
+            typename = typename std::enable_if<
+                std::is_constructible<T, Args&&...>::value>::type>
+  T& emplace(Args&&... args) {
+    this->destruct();
+    this->construct(std::forward<Args>(args)...);
+    return reference();
+  }
+
+  // Emplace reconstruction overload for an initializer list and the given
+  // forwarded arguments.
+  //
+  // Example:
+  //
+  //   struct Foo {
+  //     Foo(std::initializer_list<int>);
+  //   };
+  //
+  //   optional<Foo> opt;
+  //   opt.emplace({1,2,3});  // Constructs Foo({1,2,3})
+  template <typename U, typename... Args,
+            typename = typename std::enable_if<std::is_constructible<
+                T, std::initializer_list<U>&, Args&&...>::value>::type>
+  T& emplace(std::initializer_list<U> il, Args&&... args) {
+    this->destruct();
+    this->construct(il, std::forward<Args>(args)...);
+    return reference();
+  }
+
+  // Swaps
+
+  // Swap, standard semantics
+  void swap(optional& rhs) noexcept(
+      std::is_nothrow_move_constructible<T>::value&&
+          type_traits_internal::IsNothrowSwappable<T>::value) {
+    if (*this) {
+      if (rhs) {
+        type_traits_internal::Swap(**this, *rhs);
+      } else {
+        rhs.construct(std::move(**this));
+        this->destruct();
+      }
+    } else {
+      if (rhs) {
+        this->construct(std::move(*rhs));
+        rhs.destruct();
+      } else {
+        // No effect (swap(disengaged, disengaged)).
+      }
+    }
+  }
+
+  // Observers
+
+  // optional::operator->()
+  //
+  // Accesses the underlying `T` value's member `m` of an `optional`. If the
+  // `optional` is empty, behavior is undefined.
+  //
+  // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
+  const T* operator->() const {
+    ABSL_HARDENING_ASSERT(this->engaged_);
+    return std::addressof(this->data_);
+  }
+  T* operator->() {
+    ABSL_HARDENING_ASSERT(this->engaged_);
+    return std::addressof(this->data_);
+  }
+
+  // optional::operator*()
+  //
+  // Accesses the underlying `T` value of an `optional`. If the `optional` is
+  // empty, behavior is undefined.
+  constexpr const T& operator*() const& {
+    return ABSL_HARDENING_ASSERT(this->engaged_), reference();
+  }
+  T& operator*() & {
+    ABSL_HARDENING_ASSERT(this->engaged_);
+    return reference();
+  }
+  constexpr const T&& operator*() const && {
+    return ABSL_HARDENING_ASSERT(this->engaged_), absl::move(reference());
+  }
+  T&& operator*() && {
+    ABSL_HARDENING_ASSERT(this->engaged_);
+    return std::move(reference());
+  }
+
+  // optional::operator bool()
+  //
+  // Returns false if and only if the `optional` is empty.
+  //
+  //   if (opt) {
+  //     // do something with *opt or opt->;
+  //   } else {
+  //     // opt is empty.
+  //   }
+  //
+  constexpr explicit operator bool() const noexcept { return this->engaged_; }
+
+  // optional::has_value()
+  //
+  // Determines whether the `optional` contains a value. Returns `false` if and
+  // only if `*this` is empty.
+  constexpr bool has_value() const noexcept { return this->engaged_; }
+
+// Suppress bogus warning on MSVC: MSVC complains call to reference() after
+// throw_bad_optional_access() is unreachable.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4702)
+#endif  // _MSC_VER
+  // optional::value()
+  //
+  // Returns a reference to an `optional`s underlying value. The constness
+  // and lvalue/rvalue-ness of the `optional` is preserved to the view of
+  // the `T` sub-object. Throws `absl::bad_optional_access` when the `optional`
+  // is empty.
+  constexpr const T& value() const & {
+    return static_cast<bool>(*this)
+               ? reference()
+               : (optional_internal::throw_bad_optional_access(), reference());
+  }
+  T& value() & {
+    return static_cast<bool>(*this)
+               ? reference()
+               : (optional_internal::throw_bad_optional_access(), reference());
+  }
+  T&& value() && {  // NOLINT(build/c++11)
+    return std::move(
+        static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference()));
+  }
+  constexpr const T&& value() const && {  // NOLINT(build/c++11)
+    return absl::move(
+        static_cast<bool>(*this)
+            ? reference()
+            : (optional_internal::throw_bad_optional_access(), reference()));
+  }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif  // _MSC_VER
+
+  // optional::value_or()
+  //
+  // Returns either the value of `T` or a passed default `v` if the `optional`
+  // is empty.
+  template <typename U>
+  constexpr T value_or(U&& v) const& {
+    static_assert(std::is_copy_constructible<value_type>::value,
+                  "optional<T>::value_or: T must be copy constructible");
+    static_assert(std::is_convertible<U&&, value_type>::value,
+                  "optional<T>::value_or: U must be convertible to T");
+    return static_cast<bool>(*this)
+               ? **this
+               : static_cast<T>(absl::forward<U>(v));
+  }
+  template <typename U>
+  T value_or(U&& v) && {  // NOLINT(build/c++11)
+    static_assert(std::is_move_constructible<value_type>::value,
+                  "optional<T>::value_or: T must be move constructible");
+    static_assert(std::is_convertible<U&&, value_type>::value,
+                  "optional<T>::value_or: U must be convertible to T");
+    return static_cast<bool>(*this) ? std::move(**this)
+                                    : static_cast<T>(std::forward<U>(v));
+  }
+
+ private:
+  // Private accessors for internal storage viewed as reference to T.
+  constexpr const T& reference() const { return this->data_; }
+  T& reference() { return this->data_; }
+
+  // T constraint checks.  You can't have an optional of nullopt_t, in_place_t
+  // or a reference.
+  static_assert(
+      !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
+      "optional<nullopt_t> is not allowed.");
+  static_assert(
+      !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
+      "optional<in_place_t> is not allowed.");
+  static_assert(!std::is_reference<T>::value,
+                "optional<reference> is not allowed.");
+};
+
+// Non-member functions
+
+// swap()
+//
+// Performs a swap between two `absl::optional` objects, using standard
+// semantics.
+template <typename T, typename std::enable_if<
+                          std::is_move_constructible<T>::value &&
+                              type_traits_internal::IsSwappable<T>::value,
+                          bool>::type = false>
+void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) {
+  a.swap(b);
+}
+
+// make_optional()
+//
+// Creates a non-empty `optional<T>` where the type of `T` is deduced. An
+// `absl::optional` can also be explicitly instantiated with
+// `make_optional<T>(v)`.
+//
+// Note: `make_optional()` constructions may be declared `constexpr` for
+// trivially copyable types `T`. Non-trivial types require copy elision
+// support in C++17 for `make_optional` to support `constexpr` on such
+// non-trivial types.
+//
+// Example:
+//
+//   constexpr absl::optional<int> opt = absl::make_optional(1);
+//   static_assert(opt.value() == 1, "");
+template <typename T>
+constexpr optional<typename std::decay<T>::type> make_optional(T&& v) {
+  return optional<typename std::decay<T>::type>(absl::forward<T>(v));
+}
+
+template <typename T, typename... Args>
+constexpr optional<T> make_optional(Args&&... args) {
+  return optional<T>(in_place_t(), absl::forward<Args>(args)...);
+}
+
+template <typename T, typename U, typename... Args>
+constexpr optional<T> make_optional(std::initializer_list<U> il,
+                                    Args&&... args) {
+  return optional<T>(in_place_t(), il,
+                     absl::forward<Args>(args)...);
+}
+
+// Relational operators [optional.relops]
+
+// Empty optionals are considered equal to each other and less than non-empty
+// optionals. Supports relations between optional<T> and optional<U>, between
+// optional<T> and U, and between optional<T> and nullopt.
+//
+// Note: We're careful to support T having non-bool relationals.
+
+// Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
+// shall be convertible to bool.
+// The C++17 (N4606) "Returns:" statements are translated into
+// code in an obvious way here, and the original text retained as function docs.
+// Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
+// otherwise *x == *y.
+template <typename T, typename U>
+constexpr auto operator==(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x == *y)) {
+  return static_cast<bool>(x) != static_cast<bool>(y)
+             ? false
+             : static_cast<bool>(x) == false ? true
+                                             : static_cast<bool>(*x == *y);
+}
+
+// Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
+// otherwise *x != *y.
+template <typename T, typename U>
+constexpr auto operator!=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x != *y)) {
+  return static_cast<bool>(x) != static_cast<bool>(y)
+             ? true
+             : static_cast<bool>(x) == false ? false
+                                             : static_cast<bool>(*x != *y);
+}
+// Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
+template <typename T, typename U>
+constexpr auto operator<(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x < *y)) {
+  return !y ? false : !x ? true : static_cast<bool>(*x < *y);
+}
+// Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
+template <typename T, typename U>
+constexpr auto operator>(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x > *y)) {
+  return !x ? false : !y ? true : static_cast<bool>(*x > *y);
+}
+// Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
+template <typename T, typename U>
+constexpr auto operator<=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x <= *y)) {
+  return !x ? true : !y ? false : static_cast<bool>(*x <= *y);
+}
+// Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
+template <typename T, typename U>
+constexpr auto operator>=(const optional<T>& x, const optional<U>& y)
+    -> decltype(optional_internal::convertible_to_bool(*x >= *y)) {
+  return !y ? true : !x ? false : static_cast<bool>(*x >= *y);
+}
+
+// Comparison with nullopt [optional.nullops]
+// The C++17 (N4606) "Returns:" statements are used directly here.
+template <typename T>
+constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept {
+  return !x;
+}
+template <typename T>
+constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept {
+  return !x;
+}
+template <typename T>
+constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept {
+  return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept {
+  return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+  return false;
+}
+template <typename T>
+constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept {
+  return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept {
+  return !x;
+}
+template <typename T>
+constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+  return true;
+}
+template <typename T>
+constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept {
+  return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+  return false;
+}
+template <typename T>
+constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+  return true;
+}
+template <typename T>
+constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept {
+  return !x;
+}
+
+// Comparison with T [optional.comp_with_t]
+
+// Requires: The expression, e.g. "*x == v" shall be well-formed and its result
+// shall be convertible to bool.
+// The C++17 (N4606) "Equivalent to:" statements are used directly here.
+template <typename T, typename U>
+constexpr auto operator==(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x == v)) {
+  return static_cast<bool>(x) ? static_cast<bool>(*x == v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator==(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v == *x)) {
+  return static_cast<bool>(x) ? static_cast<bool>(v == *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator!=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x != v)) {
+  return static_cast<bool>(x) ? static_cast<bool>(*x != v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator!=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v != *x)) {
+  return static_cast<bool>(x) ? static_cast<bool>(v != *x) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x < v)) {
+  return static_cast<bool>(x) ? static_cast<bool>(*x < v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v < *x)) {
+  return static_cast<bool>(x) ? static_cast<bool>(v < *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator<=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x <= v)) {
+  return static_cast<bool>(x) ? static_cast<bool>(*x <= v) : true;
+}
+template <typename T, typename U>
+constexpr auto operator<=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v <= *x)) {
+  return static_cast<bool>(x) ? static_cast<bool>(v <= *x) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x > v)) {
+  return static_cast<bool>(x) ? static_cast<bool>(*x > v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v > *x)) {
+  return static_cast<bool>(x) ? static_cast<bool>(v > *x) : true;
+}
+template <typename T, typename U>
+constexpr auto operator>=(const optional<T>& x, const U& v)
+    -> decltype(optional_internal::convertible_to_bool(*x >= v)) {
+  return static_cast<bool>(x) ? static_cast<bool>(*x >= v) : false;
+}
+template <typename T, typename U>
+constexpr auto operator>=(const U& v, const optional<T>& x)
+    -> decltype(optional_internal::convertible_to_bool(v >= *x)) {
+  return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+namespace std {
+
+// std::hash specialization for absl::optional.
+template <typename T>
+struct hash<absl::optional<T> >
+    : absl::optional_internal::optional_hash_base<T> {};
+
+}  // namespace std
+
+#undef ABSL_MSVC_CONSTEXPR_BUG_IN_UNION_LIKE_CLASS
+
+#endif  // ABSL_USES_STD_OPTIONAL
+
+#endif  // ABSL_TYPES_OPTIONAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/span.h b/CAPI/cpp/grpc/include/absl/types/span.h
new file mode 100644
index 0000000..fdfbd77
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/span.h
@@ -0,0 +1,727 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// span.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a `Span<T>` type for holding a reference to existing
+// array data. The `Span` object, much like the `absl::string_view` object,
+// does not own such data itself, and the data being referenced by the span must
+// outlive the span itself. Unlike `view` type references, a span can hold a
+// reference to mutable data (and can mutate it for underlying types of
+// non-const T.) A span provides a lightweight way to pass a reference to such
+// data.
+//
+// Additionally, this header file defines `MakeSpan()` and `MakeConstSpan()`
+// factory functions, for clearly creating spans of type `Span<T>` or read-only
+// `Span<const T>` when such types may be difficult to identify due to issues
+// with implicit conversion.
+//
+// The C++20 draft standard includes a `std::span` type. As of June 2020, the
+// differences between `absl::Span` and `std::span` are:
+//    * `absl::Span` has `operator==` (which is likely a design bug,
+//       per https://abseil.io/blog/20180531-regular-types)
+//    * `absl::Span` has the factory functions `MakeSpan()` and
+//      `MakeConstSpan()`
+//    * bounds-checked access to `absl::Span` is accomplished with `at()`
+//    * `absl::Span` has compiler-provided move and copy constructors and
+//      assignment. This is due to them being specified as `constexpr`, but that
+//      implies const in C++11.
+//    * A read-only `absl::Span<const T>` can be implicitly constructed from an
+//      initializer list.
+//    * `absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or
+//      `as_mutable_bytes()` methods
+//    * `absl::Span` has no static extent template parameter, nor constructors
+//      which exist only because of the static extent parameter.
+//    * `absl::Span` has an explicit mutable-reference constructor
+//
+// For more information, see the class comments below.
+#ifndef ABSL_TYPES_SPAN_H_
+#define ABSL_TYPES_SPAN_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"    // TODO(strel): remove this include
+#include "absl/meta/type_traits.h"
+#include "absl/types/internal/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+//------------------------------------------------------------------------------
+// Span
+//------------------------------------------------------------------------------
+//
+// A `Span` is an "array reference" type for holding a reference of contiguous
+// array data; the `Span` object does not and cannot own such data itself. A
+// span provides an easy way to provide overloads for anything operating on
+// contiguous sequences without needing to manage pointers and array lengths
+// manually.
+
+// A span is conceptually a pointer (ptr) and a length (size) into an already
+// existing array of contiguous memory; the array it represents references the
+// elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span`
+// instead of raw pointers avoids many issues related to index out of bounds
+// errors.
+//
+// Spans may also be constructed from containers holding contiguous sequences.
+// Such containers must supply `data()` and `size() const` methods (e.g
+// `std::vector<T>`, `absl::InlinedVector<T, N>`). All implicit conversions to
+// `absl::Span` from such containers will create spans of type `const T`;
+// spans which can mutate their values (of type `T`) must use explicit
+// constructors.
+//
+// A `Span<T>` is somewhat analogous to an `absl::string_view`, but for an array
+// of elements of type `T`, and unlike an `absl::string_view`, a span can hold a
+// reference to mutable data. A user of `Span` must ensure that the data being
+// pointed to outlives the `Span` itself.
+//
+// You can construct a `Span<T>` in several ways:
+//
+//   * Explicitly from a reference to a container type
+//   * Explicitly from a pointer and size
+//   * Implicitly from a container type (but only for spans of type `const T`)
+//   * Using the `MakeSpan()` or `MakeConstSpan()` factory functions.
+//
+// Examples:
+//
+//   // Construct a Span explicitly from a container:
+//   std::vector<int> v = {1, 2, 3, 4, 5};
+//   auto span = absl::Span<const int>(v);
+//
+//   // Construct a Span explicitly from a C-style array:
+//   int a[5] =  {1, 2, 3, 4, 5};
+//   auto span = absl::Span<const int>(a);
+//
+//   // Construct a Span implicitly from a container
+//   void MyRoutine(absl::Span<const int> a) {
+//     ...
+//   }
+//   std::vector v = {1,2,3,4,5};
+//   MyRoutine(v)                     // convert to Span<const T>
+//
+// Note that `Span` objects, in addition to requiring that the memory they
+// point to remains alive, must also ensure that such memory does not get
+// reallocated. Therefore, to avoid undefined behavior, containers with
+// associated spans should not invoke operations that may reallocate memory
+// (such as resizing) or invalidate iterators into the container.
+//
+// One common use for a `Span` is when passing arguments to a routine that can
+// accept a variety of array types (e.g. a `std::vector`, `absl::InlinedVector`,
+// a C-style array, etc.). Instead of creating overloads for each case, you
+// can simply specify a `Span` as the argument to such a routine.
+//
+// Example:
+//
+//   void MyRoutine(absl::Span<const int> a) {
+//     ...
+//   }
+//
+//   std::vector v = {1,2,3,4,5};
+//   MyRoutine(v);
+//
+//   absl::InlinedVector<int, 4> my_inline_vector;
+//   MyRoutine(my_inline_vector);
+//
+//   // Explicit constructor from pointer,size
+//   int* my_array = new int[10];
+//   MyRoutine(absl::Span<const int>(my_array, 10));
+template <typename T>
+class Span {
+ private:
+  // Used to determine whether a Span can be constructed from a container of
+  // type C.
+  template <typename C>
+  using EnableIfConvertibleFrom =
+      typename std::enable_if<span_internal::HasData<T, C>::value &&
+                              span_internal::HasSize<C>::value>::type;
+
+  // Used to SFINAE-enable a function when the slice elements are const.
+  template <typename U>
+  using EnableIfConstView =
+      typename std::enable_if<std::is_const<T>::value, U>::type;
+
+  // Used to SFINAE-enable a function when the slice elements are mutable.
+  template <typename U>
+  using EnableIfMutableView =
+      typename std::enable_if<!std::is_const<T>::value, U>::type;
+
+ public:
+  using element_type = T;
+  using value_type = absl::remove_cv_t<T>;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using iterator = pointer;
+  using const_iterator = const_pointer;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+
+  static const size_type npos = ~(size_type(0));
+
+  constexpr Span() noexcept : Span(nullptr, 0) {}
+  constexpr Span(pointer array, size_type length) noexcept
+      : ptr_(array), len_(length) {}
+
+  // Implicit conversion constructors
+  template <size_t N>
+  constexpr Span(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
+      : Span(a, N) {}
+
+  // Explicit reference constructor for a mutable `Span<T>` type. Can be
+  // replaced with MakeSpan() to infer the type parameter.
+  template <typename V, typename = EnableIfConvertibleFrom<V>,
+            typename = EnableIfMutableView<V>>
+  explicit Span(V& v) noexcept  // NOLINT(runtime/references)
+      : Span(span_internal::GetData(v), v.size()) {}
+
+  // Implicit reference constructor for a read-only `Span<const T>` type
+  template <typename V, typename = EnableIfConvertibleFrom<V>,
+            typename = EnableIfConstView<V>>
+  constexpr Span(const V& v) noexcept  // NOLINT(runtime/explicit)
+      : Span(span_internal::GetData(v), v.size()) {}
+
+  // Implicit constructor from an initializer list, making it possible to pass a
+  // brace-enclosed initializer list to a function expecting a `Span`. Such
+  // spans constructed from an initializer list must be of type `Span<const T>`.
+  //
+  //   void Process(absl::Span<const int> x);
+  //   Process({1, 2, 3});
+  //
+  // Note that as always the array referenced by the span must outlive the span.
+  // Since an initializer list constructor acts as if it is fed a temporary
+  // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this
+  // constructor only when the `std::initializer_list` itself outlives the span.
+  // In order to meet this requirement it's sufficient to ensure that neither
+  // the span nor a copy of it is used outside of the expression in which it's
+  // created:
+  //
+  //   // Assume that this function uses the array directly, not retaining any
+  //   // copy of the span or pointer to any of its elements.
+  //   void Process(absl::Span<const int> ints);
+  //
+  //   // Okay: the std::initializer_list<int> will reference a temporary array
+  //   // that isn't destroyed until after the call to Process returns.
+  //   Process({ 17, 19 });
+  //
+  //   // Not okay: the storage used by the std::initializer_list<int> is not
+  //   // allowed to be referenced after the first line.
+  //   absl::Span<const int> ints = { 17, 19 };
+  //   Process(ints);
+  //
+  //   // Not okay for the same reason as above: even when the elements of the
+  //   // initializer list expression are not temporaries the underlying array
+  //   // is, so the initializer list must still outlive the span.
+  //   const int foo = 17;
+  //   absl::Span<const int> ints = { foo };
+  //   Process(ints);
+  //
+  template <typename LazyT = T,
+            typename = EnableIfConstView<LazyT>>
+  Span(std::initializer_list<value_type> v
+           ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept  // NOLINT(runtime/explicit)
+      : Span(v.begin(), v.size()) {}
+
+  // Accessors
+
+  // Span::data()
+  //
+  // Returns a pointer to the span's underlying array of data (which is held
+  // outside the span).
+  constexpr pointer data() const noexcept { return ptr_; }
+
+  // Span::size()
+  //
+  // Returns the size of this span.
+  constexpr size_type size() const noexcept { return len_; }
+
+  // Span::length()
+  //
+  // Returns the length (size) of this span.
+  constexpr size_type length() const noexcept { return size(); }
+
+  // Span::empty()
+  //
+  // Returns a boolean indicating whether or not this span is considered empty.
+  constexpr bool empty() const noexcept { return size() == 0; }
+
+  // Span::operator[]
+  //
+  // Returns a reference to the i'th element of this span.
+  constexpr reference operator[](size_type i) const noexcept {
+    // MSVC 2015 accepts this as constexpr, but not ptr_[i]
+    return ABSL_HARDENING_ASSERT(i < size()), *(data() + i);
+  }
+
+  // Span::at()
+  //
+  // Returns a reference to the i'th element of this span.
+  constexpr reference at(size_type i) const {
+    return ABSL_PREDICT_TRUE(i < size())  //
+               ? *(data() + i)
+               : (base_internal::ThrowStdOutOfRange(
+                      "Span::at failed bounds check"),
+                  *(data() + i));
+  }
+
+  // Span::front()
+  //
+  // Returns a reference to the first element of this span. The span must not
+  // be empty.
+  constexpr reference front() const noexcept {
+    return ABSL_HARDENING_ASSERT(size() > 0), *data();
+  }
+
+  // Span::back()
+  //
+  // Returns a reference to the last element of this span. The span must not
+  // be empty.
+  constexpr reference back() const noexcept {
+    return ABSL_HARDENING_ASSERT(size() > 0), *(data() + size() - 1);
+  }
+
+  // Span::begin()
+  //
+  // Returns an iterator pointing to the first element of this span, or `end()`
+  // if the span is empty.
+  constexpr iterator begin() const noexcept { return data(); }
+
+  // Span::cbegin()
+  //
+  // Returns a const iterator pointing to the first element of this span, or
+  // `end()` if the span is empty.
+  constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+  // Span::end()
+  //
+  // Returns an iterator pointing just beyond the last element at the
+  // end of this span. This iterator acts as a placeholder; attempting to
+  // access it results in undefined behavior.
+  constexpr iterator end() const noexcept { return data() + size(); }
+
+  // Span::cend()
+  //
+  // Returns a const iterator pointing just beyond the last element at the
+  // end of this span. This iterator acts as a placeholder; attempting to
+  // access it results in undefined behavior.
+  constexpr const_iterator cend() const noexcept { return end(); }
+
+  // Span::rbegin()
+  //
+  // Returns a reverse iterator pointing to the last element at the end of this
+  // span, or `rend()` if the span is empty.
+  constexpr reverse_iterator rbegin() const noexcept {
+    return reverse_iterator(end());
+  }
+
+  // Span::crbegin()
+  //
+  // Returns a const reverse iterator pointing to the last element at the end of
+  // this span, or `crend()` if the span is empty.
+  constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+  // Span::rend()
+  //
+  // Returns a reverse iterator pointing just before the first element
+  // at the beginning of this span. This pointer acts as a placeholder;
+  // attempting to access its element results in undefined behavior.
+  constexpr reverse_iterator rend() const noexcept {
+    return reverse_iterator(begin());
+  }
+
+  // Span::crend()
+  //
+  // Returns a reverse const iterator pointing just before the first element
+  // at the beginning of this span. This pointer acts as a placeholder;
+  // attempting to access its element results in undefined behavior.
+  constexpr const_reverse_iterator crend() const noexcept { return rend(); }
+
+  // Span mutations
+
+  // Span::remove_prefix()
+  //
+  // Removes the first `n` elements from the span.
+  void remove_prefix(size_type n) noexcept {
+    ABSL_HARDENING_ASSERT(size() >= n);
+    ptr_ += n;
+    len_ -= n;
+  }
+
+  // Span::remove_suffix()
+  //
+  // Removes the last `n` elements from the span.
+  void remove_suffix(size_type n) noexcept {
+    ABSL_HARDENING_ASSERT(size() >= n);
+    len_ -= n;
+  }
+
+  // Span::subspan()
+  //
+  // Returns a `Span` starting at element `pos` and of length `len`. Both `pos`
+  // and `len` are of type `size_type` and thus non-negative. Parameter `pos`
+  // must be <= size(). Any `len` value that points past the end of the span
+  // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
+  // ensures the returned subspan continues until the end of the span.
+  //
+  // Examples:
+  //
+  //   std::vector<int> vec = {10, 11, 12, 13};
+  //   absl::MakeSpan(vec).subspan(1, 2);  // {11, 12}
+  //   absl::MakeSpan(vec).subspan(2, 8);  // {12, 13}
+  //   absl::MakeSpan(vec).subspan(1);     // {11, 12, 13}
+  //   absl::MakeSpan(vec).subspan(4);     // {}
+  //   absl::MakeSpan(vec).subspan(5);     // throws std::out_of_range
+  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
+    return (pos <= size())
+               ? Span(data() + pos, span_internal::Min(size() - pos, len))
+               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
+  }
+
+  // Span::first()
+  //
+  // Returns a `Span` containing first `len` elements. Parameter `len` is of
+  // type `size_type` and thus non-negative. `len` value must be <= size().
+  //
+  // Examples:
+  //
+  //   std::vector<int> vec = {10, 11, 12, 13};
+  //   absl::MakeSpan(vec).first(1);  // {10}
+  //   absl::MakeSpan(vec).first(3);  // {10, 11, 12}
+  //   absl::MakeSpan(vec).first(5);  // throws std::out_of_range
+  constexpr Span first(size_type len) const {
+    return (len <= size())
+               ? Span(data(), len)
+               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+  }
+
+  // Span::last()
+  //
+  // Returns a `Span` containing last `len` elements. Parameter `len` is of
+  // type `size_type` and thus non-negative. `len` value must be <= size().
+  //
+  // Examples:
+  //
+  //   std::vector<int> vec = {10, 11, 12, 13};
+  //   absl::MakeSpan(vec).last(1);  // {13}
+  //   absl::MakeSpan(vec).last(3);  // {11, 12, 13}
+  //   absl::MakeSpan(vec).last(5);  // throws std::out_of_range
+  constexpr Span last(size_type len) const {
+    return (len <= size())
+               ? Span(size() - len + data(), len)
+               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+  }
+
+  // Support for absl::Hash.
+  template <typename H>
+  friend H AbslHashValue(H h, Span v) {
+    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
+                      v.size());
+  }
+
+ private:
+  pointer ptr_;
+  size_type len_;
+};
+
+template <typename T>
+const typename Span<T>::size_type Span<T>::npos;
+
+// Span relationals
+
+// Equality is compared element-by-element, while ordering is lexicographical.
+// We provide three overloads for each operator to cover any combination on the
+// left or right hand side of mutable Span<T>, read-only Span<const T>, and
+// convertible-to-read-only Span<T>.
+// TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering
+// template functions, 5 overloads per operator is needed as a workaround. We
+// should update them to 3 overloads per operator using non-deduced context like
+// string_view, i.e.
+// - (Span<T>, Span<T>)
+// - (Span<T>, non_deduced<Span<const T>>)
+// - (non_deduced<Span<const T>>, Span<T>)
+
+// operator==
+template <typename T>
+bool operator==(Span<T> a, Span<T> b) {
+  return span_internal::EqualImpl<Span, const T>(a, b);
+}
+template <typename T>
+bool operator==(Span<const T> a, Span<T> b) {
+  return span_internal::EqualImpl<Span, const T>(a, b);
+}
+template <typename T>
+bool operator==(Span<T> a, Span<const T> b) {
+  return span_internal::EqualImpl<Span, const T>(a, b);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator==(const U& a, Span<T> b) {
+  return span_internal::EqualImpl<Span, const T>(a, b);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator==(Span<T> a, const U& b) {
+  return span_internal::EqualImpl<Span, const T>(a, b);
+}
+
+// operator!=
+template <typename T>
+bool operator!=(Span<T> a, Span<T> b) {
+  return !(a == b);
+}
+template <typename T>
+bool operator!=(Span<const T> a, Span<T> b) {
+  return !(a == b);
+}
+template <typename T>
+bool operator!=(Span<T> a, Span<const T> b) {
+  return !(a == b);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator!=(const U& a, Span<T> b) {
+  return !(a == b);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator!=(Span<T> a, const U& b) {
+  return !(a == b);
+}
+
+// operator<
+template <typename T>
+bool operator<(Span<T> a, Span<T> b) {
+  return span_internal::LessThanImpl<Span, const T>(a, b);
+}
+template <typename T>
+bool operator<(Span<const T> a, Span<T> b) {
+  return span_internal::LessThanImpl<Span, const T>(a, b);
+}
+template <typename T>
+bool operator<(Span<T> a, Span<const T> b) {
+  return span_internal::LessThanImpl<Span, const T>(a, b);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator<(const U& a, Span<T> b) {
+  return span_internal::LessThanImpl<Span, const T>(a, b);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator<(Span<T> a, const U& b) {
+  return span_internal::LessThanImpl<Span, const T>(a, b);
+}
+
+// operator>
+template <typename T>
+bool operator>(Span<T> a, Span<T> b) {
+  return b < a;
+}
+template <typename T>
+bool operator>(Span<const T> a, Span<T> b) {
+  return b < a;
+}
+template <typename T>
+bool operator>(Span<T> a, Span<const T> b) {
+  return b < a;
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator>(const U& a, Span<T> b) {
+  return b < a;
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator>(Span<T> a, const U& b) {
+  return b < a;
+}
+
+// operator<=
+template <typename T>
+bool operator<=(Span<T> a, Span<T> b) {
+  return !(b < a);
+}
+template <typename T>
+bool operator<=(Span<const T> a, Span<T> b) {
+  return !(b < a);
+}
+template <typename T>
+bool operator<=(Span<T> a, Span<const T> b) {
+  return !(b < a);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator<=(const U& a, Span<T> b) {
+  return !(b < a);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator<=(Span<T> a, const U& b) {
+  return !(b < a);
+}
+
+// operator>=
+template <typename T>
+bool operator>=(Span<T> a, Span<T> b) {
+  return !(a < b);
+}
+template <typename T>
+bool operator>=(Span<const T> a, Span<T> b) {
+  return !(a < b);
+}
+template <typename T>
+bool operator>=(Span<T> a, Span<const T> b) {
+  return !(a < b);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator>=(const U& a, Span<T> b) {
+  return !(a < b);
+}
+template <
+    typename T, typename U,
+    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+bool operator>=(Span<T> a, const U& b) {
+  return !(a < b);
+}
+
+// MakeSpan()
+//
+// Constructs a mutable `Span<T>`, deducing `T` automatically from either a
+// container or pointer+size.
+//
+// Because a read-only `Span<const T>` is implicitly constructed from container
+// types regardless of whether the container itself is a const container,
+// constructing mutable spans of type `Span<T>` from containers requires
+// explicit constructors. The container-accepting version of `MakeSpan()`
+// deduces the type of `T` by the constness of the pointer received from the
+// container's `data()` member. Similarly, the pointer-accepting version returns
+// a `Span<const T>` if `T` is `const`, and a `Span<T>` otherwise.
+//
+// Examples:
+//
+//   void MyRoutine(absl::Span<MyComplicatedType> a) {
+//     ...
+//   };
+//   // my_vector is a container of non-const types
+//   std::vector<MyComplicatedType> my_vector;
+//
+//   // Constructing a Span implicitly attempts to create a Span of type
+//   // `Span<const T>`
+//   MyRoutine(my_vector);                // error, type mismatch
+//
+//   // Explicitly constructing the Span is verbose
+//   MyRoutine(absl::Span<MyComplicatedType>(my_vector));
+//
+//   // Use MakeSpan() to make an absl::Span<T>
+//   MyRoutine(absl::MakeSpan(my_vector));
+//
+//   // Construct a span from an array ptr+size
+//   absl::Span<T> my_span() {
+//     return absl::MakeSpan(&array[0], num_elements_);
+//   }
+//
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept {
+  return Span<T>(ptr, size);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+Span<T> MakeSpan(T* begin, T* end) noexcept {
+  return ABSL_HARDENING_ASSERT(begin <= end),
+         Span<T>(begin, static_cast<size_t>(end - begin));
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeSpan(C& c) noexcept  // NOLINT(runtime/references)
+    -> decltype(absl::MakeSpan(span_internal::GetData(c), c.size())) {
+  return MakeSpan(span_internal::GetData(c), c.size());
+}
+
+template <int&... ExplicitArgumentBarrier, typename T, size_t N>
+constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
+  return Span<T>(array, N);
+}
+
+// MakeConstSpan()
+//
+// Constructs a `Span<const T>` as with `MakeSpan`, deducing `T` automatically,
+// but always returning a `Span<const T>`.
+//
+// Examples:
+//
+//   void ProcessInts(absl::Span<const int> some_ints);
+//
+//   // Call with a pointer and size.
+//   int array[3] = { 0, 0, 0 };
+//   ProcessInts(absl::MakeConstSpan(&array[0], 3));
+//
+//   // Call with a [begin, end) pair.
+//   ProcessInts(absl::MakeConstSpan(&array[0], &array[3]));
+//
+//   // Call directly with an array.
+//   ProcessInts(absl::MakeConstSpan(array));
+//
+//   // Call with a contiguous container.
+//   std::vector<int> some_ints = ...;
+//   ProcessInts(absl::MakeConstSpan(some_ints));
+//   ProcessInts(absl::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
+//
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept {
+  return Span<const T>(ptr, size);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+Span<const T> MakeConstSpan(T* begin, T* end) noexcept {
+  return ABSL_HARDENING_ASSERT(begin <= end), Span<const T>(begin, end - begin);
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeConstSpan(const C& c) noexcept -> decltype(MakeSpan(c)) {
+  return MakeSpan(c);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T, size_t N>
+constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
+  return Span<const T>(array, N);
+}
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // ABSL_TYPES_SPAN_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/variant.h b/CAPI/cpp/grpc/include/absl/types/variant.h
new file mode 100644
index 0000000..ac93464
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/types/variant.h
@@ -0,0 +1,866 @@
+// Copyright 2018 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// variant.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines an `absl::variant` type for holding a type-safe
+// value of some prescribed set of types (noted as alternative types), and
+// associated functions for managing variants.
+//
+// The `absl::variant` type is a form of type-safe union. An `absl::variant`
+// should always hold a value of one of its alternative types (except in the
+// "valueless by exception state" -- see below). A default-constructed
+// `absl::variant` will hold the value of its first alternative type, provided
+// it is default-constructible.
+//
+// In exceptional cases due to error, an `absl::variant` can hold no
+// value (known as a "valueless by exception" state), though this is not the
+// norm.
+//
+// As with `absl::optional`, an `absl::variant` -- when it holds a value --
+// allocates a value of that type directly within the `variant` itself; it
+// cannot hold a reference, array, or the type `void`; it can, however, hold a
+// pointer to externally managed memory.
+//
+// `absl::variant` is a C++11 compatible version of the C++17 `std::variant`
+// abstraction and is designed to be a drop-in replacement for code compliant
+// with C++17.
+
+#ifndef ABSL_TYPES_VARIANT_H_
+#define ABSL_TYPES_VARIANT_H_
+
+#include "absl/base/config.h"
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_USES_STD_VARIANT
+
+#include <variant>  // IWYU pragma: export
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using std::bad_variant_access;
+using std::get;
+using std::get_if;
+using std::holds_alternative;
+using std::monostate;
+using std::variant;
+using std::variant_alternative;
+using std::variant_alternative_t;
+using std::variant_npos;
+using std::variant_size;
+using std::variant_size_v;
+using std::visit;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_USES_STD_VARIANT
+
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/internal/variant.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// -----------------------------------------------------------------------------
+// absl::variant
+// -----------------------------------------------------------------------------
+//
+// An `absl::variant` type is a form of type-safe union. An `absl::variant` --
+// except in exceptional cases -- always holds a value of one of its alternative
+// types.
+//
+// Example:
+//
+//   // Construct a variant that holds either an integer or a std::string and
+//   // assign it to a std::string.
+//   absl::variant<int, std::string> v = std::string("abc");
+//
+//   // A default-constructed variant will hold a value-initialized value of
+//   // the first alternative type.
+//   auto a = absl::variant<int, std::string>();   // Holds an int of value '0'.
+//
+//   // variants are assignable.
+//
+//   // copy assignment
+//   auto v1 = absl::variant<int, std::string>("abc");
+//   auto v2 = absl::variant<int, std::string>(10);
+//   v2 = v1;  // copy assign
+//
+//   // move assignment
+//   auto v1 = absl::variant<int, std::string>("abc");
+//   v1 = absl::variant<int, std::string>(10);
+//
+//   // assignment through type conversion
+//   a = 128;         // variant contains int
+//   a = "128";       // variant contains std::string
+//
+// An `absl::variant` holding a value of one of its alternative types `T` holds
+// an allocation of `T` directly within the variant itself. An `absl::variant`
+// is not allowed to allocate additional storage, such as dynamic memory, to
+// allocate the contained value. The contained value shall be allocated in a
+// region of the variant storage suitably aligned for all alternative types.
+template <typename... Ts>
+class variant;
+
+// swap()
+//
+// Swaps two `absl::variant` values. This function is equivalent to `v.swap(w)`
+// where `v` and `w` are `absl::variant` types.
+//
+// Note that this function requires all alternative types to be both swappable
+// and move-constructible, because any two variants may refer to either the same
+// type (in which case, they will be swapped) or to two different types (in
+// which case the values will need to be moved).
+//
+template <
+    typename... Ts,
+    absl::enable_if_t<
+        absl::conjunction<std::is_move_constructible<Ts>...,
+                          type_traits_internal::IsSwappable<Ts>...>::value,
+        int> = 0>
+void swap(variant<Ts...>& v, variant<Ts...>& w) noexcept(noexcept(v.swap(w))) {
+  v.swap(w);
+}
+
+// variant_size
+//
+// Returns the number of alternative types available for a given `absl::variant`
+// type as a compile-time constant expression. As this is a class template, it
+// is not generally useful for accessing the number of alternative types of
+// any given `absl::variant` instance.
+//
+// Example:
+//
+//   auto a = absl::variant<int, std::string>;
+//   constexpr int num_types =
+//       absl::variant_size<absl::variant<int, std::string>>();
+//
+//   // You can also use the member constant `value`.
+//   constexpr int num_types =
+//       absl::variant_size<absl::variant<int, std::string>>::value;
+//
+//   // `absl::variant_size` is more valuable for use in generic code:
+//   template <typename Variant>
+//   constexpr bool IsVariantMultivalue() {
+//       return absl::variant_size<Variant>() > 1;
+//   }
+//
+// Note that the set of cv-qualified specializations of `variant_size` are
+// provided to ensure that those specializations compile (especially when passed
+// within template logic).
+template <class T>
+struct variant_size;
+
+template <class... Ts>
+struct variant_size<variant<Ts...>>
+    : std::integral_constant<std::size_t, sizeof...(Ts)> {};
+
+// Specialization of `variant_size` for const qualified variants.
+template <class T>
+struct variant_size<const T> : variant_size<T>::type {};
+
+// Specialization of `variant_size` for volatile qualified variants.
+template <class T>
+struct variant_size<volatile T> : variant_size<T>::type {};
+
+// Specialization of `variant_size` for const volatile qualified variants.
+template <class T>
+struct variant_size<const volatile T> : variant_size<T>::type {};
+
+// variant_alternative
+//
+// Returns the alternative type for a given `absl::variant` at the passed
+// index value as a compile-time constant expression. As this is a class
+// template resulting in a type, it is not useful for access of the run-time
+// value of any given `absl::variant` variable.
+//
+// Example:
+//
+//   // The type of the 0th alternative is "int".
+//   using alternative_type_0
+//     = absl::variant_alternative<0, absl::variant<int, std::string>>::type;
+//
+//   static_assert(std::is_same<alternative_type_0, int>::value, "");
+//
+//   // `absl::variant_alternative` is more valuable for use in generic code:
+//   template <typename Variant>
+//   constexpr bool IsFirstElementTrivial() {
+//       return std::is_trivial_v<variant_alternative<0, Variant>::type>;
+//   }
+//
+// Note that the set of cv-qualified specializations of `variant_alternative`
+// are provided to ensure that those specializations compile (especially when
+// passed within template logic).
+template <std::size_t I, class T>
+struct variant_alternative;
+
+template <std::size_t I, class... Types>
+struct variant_alternative<I, variant<Types...>> {
+  using type =
+      variant_internal::VariantAlternativeSfinaeT<I, variant<Types...>>;
+};
+
+// Specialization of `variant_alternative` for const qualified variants.
+template <std::size_t I, class T>
+struct variant_alternative<I, const T> {
+  using type = const typename variant_alternative<I, T>::type;
+};
+
+// Specialization of `variant_alternative` for volatile qualified variants.
+template <std::size_t I, class T>
+struct variant_alternative<I, volatile T> {
+  using type = volatile typename variant_alternative<I, T>::type;
+};
+
+// Specialization of `variant_alternative` for const volatile qualified
+// variants.
+template <std::size_t I, class T>
+struct variant_alternative<I, const volatile T> {
+  using type = const volatile typename variant_alternative<I, T>::type;
+};
+
+// Template type alias for variant_alternative<I, T>::type.
+//
+// Example:
+//
+//   using alternative_type_0
+//     = absl::variant_alternative_t<0, absl::variant<int, std::string>>;
+//   static_assert(std::is_same<alternative_type_0, int>::value, "");
+template <std::size_t I, class T>
+using variant_alternative_t = typename variant_alternative<I, T>::type;
+
+// holds_alternative()
+//
+// Checks whether the given variant currently holds a given alternative type,
+// returning `true` if so.
+//
+// Example:
+//
+//   absl::variant<int, std::string> foo = 42;
+//   if (absl::holds_alternative<int>(foo)) {
+//       std::cout << "The variant holds an integer";
+//   }
+template <class T, class... Types>
+constexpr bool holds_alternative(const variant<Types...>& v) noexcept {
+  static_assert(
+      variant_internal::UnambiguousIndexOfImpl<variant<Types...>, T,
+                                               0>::value != sizeof...(Types),
+      "The type T must occur exactly once in Types...");
+  return v.index() ==
+         variant_internal::UnambiguousIndexOf<variant<Types...>, T>::value;
+}
+
+// get()
+//
+// Returns a reference to the value currently within a given variant, using
+// either a unique alternative type amongst the variant's set of alternative
+// types, or the variant's index value. Attempting to get a variant's value
+// using a type that is not unique within the variant's set of alternative types
+// is a compile-time error. If the index of the alternative being specified is
+// different from the index of the alternative that is currently stored, throws
+// `absl::bad_variant_access`.
+//
+// Example:
+//
+//   auto a = absl::variant<int, std::string>;
+//
+//   // Get the value by type (if unique).
+//   int i = absl::get<int>(a);
+//
+//   auto b = absl::variant<int, int>;
+//
+//   // Getting the value by a type that is not unique is ill-formed.
+//   int j = absl::get<int>(b);     // Compile Error!
+//
+//   // Getting value by index not ambiguous and allowed.
+//   int k = absl::get<1>(b);
+
+// Overload for getting a variant's lvalue by type.
+template <class T, class... Types>
+constexpr T& get(variant<Types...>& v) {  // NOLINT
+  return variant_internal::VariantCoreAccess::CheckedAccess<
+      variant_internal::IndexOf<T, Types...>::value>(v);
+}
+
+// Overload for getting a variant's rvalue by type.
+// Note: `absl::move()` is required to allow use of constexpr in C++11.
+template <class T, class... Types>
+constexpr T&& get(variant<Types...>&& v) {
+  return variant_internal::VariantCoreAccess::CheckedAccess<
+      variant_internal::IndexOf<T, Types...>::value>(absl::move(v));
+}
+
+// Overload for getting a variant's const lvalue by type.
+template <class T, class... Types>
+constexpr const T& get(const variant<Types...>& v) {
+  return variant_internal::VariantCoreAccess::CheckedAccess<
+      variant_internal::IndexOf<T, Types...>::value>(v);
+}
+
+// Overload for getting a variant's const rvalue by type.
+// Note: `absl::move()` is required to allow use of constexpr in C++11.
+template <class T, class... Types>
+constexpr const T&& get(const variant<Types...>&& v) {
+  return variant_internal::VariantCoreAccess::CheckedAccess<
+      variant_internal::IndexOf<T, Types...>::value>(absl::move(v));
+}
+
+// Overload for getting a variant's lvalue by index.
+template <std::size_t I, class... Types>
+constexpr variant_alternative_t<I, variant<Types...>>& get(
+    variant<Types...>& v) {  // NOLINT
+  return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
+}
+
+// Overload for getting a variant's rvalue by index.
+// Note: `absl::move()` is required to allow use of constexpr in C++11.
+template <std::size_t I, class... Types>
+constexpr variant_alternative_t<I, variant<Types...>>&& get(
+    variant<Types...>&& v) {
+  return variant_internal::VariantCoreAccess::CheckedAccess<I>(absl::move(v));
+}
+
+// Overload for getting a variant's const lvalue by index.
+template <std::size_t I, class... Types>
+constexpr const variant_alternative_t<I, variant<Types...>>& get(
+    const variant<Types...>& v) {
+  return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
+}
+
+// Overload for getting a variant's const rvalue by index.
+// Note: `absl::move()` is required to allow use of constexpr in C++11.
+template <std::size_t I, class... Types>
+constexpr const variant_alternative_t<I, variant<Types...>>&& get(
+    const variant<Types...>&& v) {
+  return variant_internal::VariantCoreAccess::CheckedAccess<I>(absl::move(v));
+}
+
+// get_if()
+//
+// Returns a pointer to the value currently stored within a given variant, if
+// present, using either a unique alternative type amongst the variant's set of
+// alternative types, or the variant's index value. If such a value does not
+// exist, returns `nullptr`.
+//
+// As with `get`, attempting to get a variant's value using a type that is not
+// unique within the variant's set of alternative types is a compile-time error.
+
+// Overload for getting a pointer to the value stored in the given variant by
+// index.
+template <std::size_t I, class... Types>
+constexpr absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>>
+get_if(variant<Types...>* v) noexcept {
+  return (v != nullptr && v->index() == I)
+             ? std::addressof(
+                   variant_internal::VariantCoreAccess::Access<I>(*v))
+             : nullptr;
+}
+
+// Overload for getting a pointer to the const value stored in the given
+// variant by index.
+template <std::size_t I, class... Types>
+constexpr absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
+get_if(const variant<Types...>* v) noexcept {
+  return (v != nullptr && v->index() == I)
+             ? std::addressof(
+                   variant_internal::VariantCoreAccess::Access<I>(*v))
+             : nullptr;
+}
+
+// Overload for getting a pointer to the value stored in the given variant by
+// type.
+template <class T, class... Types>
+constexpr absl::add_pointer_t<T> get_if(variant<Types...>* v) noexcept {
+  return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
+}
+
+// Overload for getting a pointer to the const value stored in the given variant
+// by type.
+template <class T, class... Types>
+constexpr absl::add_pointer_t<const T> get_if(
+    const variant<Types...>* v) noexcept {
+  return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
+}
+
+// visit()
+//
+// Calls a provided functor on a given set of variants. `absl::visit()` is
+// commonly used to conditionally inspect the state of a given variant (or set
+// of variants).
+//
+// The functor must return the same type when called with any of the variants'
+// alternatives.
+//
+// Example:
+//
+//   // Define a visitor functor
+//   struct GetVariant {
+//       template<typename T>
+//       void operator()(const T& i) const {
+//         std::cout << "The variant's value is: " << i;
+//       }
+//   };
+//
+//   // Declare our variant, and call `absl::visit()` on it.
+//   // Note that `GetVariant()` returns void in either case.
+//   absl::variant<int, std::string> foo = std::string("foo");
+//   GetVariant visitor;
+//   absl::visit(visitor, foo);  // Prints `The variant's value is: foo'
+template <typename Visitor, typename... Variants>
+variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis,
+                                                          Variants&&... vars) {
+  return variant_internal::
+      VisitIndices<variant_size<absl::decay_t<Variants> >::value...>::Run(
+          variant_internal::PerformVisitation<Visitor, Variants...>{
+              std::forward_as_tuple(absl::forward<Variants>(vars)...),
+              absl::forward<Visitor>(vis)},
+          vars.index()...);
+}
+
+// monostate
+//
+// The monostate class serves as a first alternative type for a variant for
+// which the first variant type is otherwise not default-constructible.
+struct monostate {};
+
+// `absl::monostate` Relational Operators
+
+constexpr bool operator<(monostate, monostate) noexcept { return false; }
+constexpr bool operator>(monostate, monostate) noexcept { return false; }
+constexpr bool operator<=(monostate, monostate) noexcept { return true; }
+constexpr bool operator>=(monostate, monostate) noexcept { return true; }
+constexpr bool operator==(monostate, monostate) noexcept { return true; }
+constexpr bool operator!=(monostate, monostate) noexcept { return false; }
+
+
+//------------------------------------------------------------------------------
+// `absl::variant` Template Definition
+//------------------------------------------------------------------------------
+template <typename T0, typename... Tn>
+class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
+  static_assert(absl::conjunction<std::is_object<T0>,
+                                  std::is_object<Tn>...>::value,
+                "Attempted to instantiate a variant containing a non-object "
+                "type.");
+  // Intentionally not qualifying `negation` with `absl::` to work around a bug
+  // in MSVC 2015 with inline namespace and variadic template.
+  static_assert(absl::conjunction<negation<std::is_array<T0> >,
+                                  negation<std::is_array<Tn> >...>::value,
+                "Attempted to instantiate a variant containing an array type.");
+  static_assert(absl::conjunction<std::is_nothrow_destructible<T0>,
+                                  std::is_nothrow_destructible<Tn>...>::value,
+                "Attempted to instantiate a variant containing a non-nothrow "
+                "destructible type.");
+
+  friend struct variant_internal::VariantCoreAccess;
+
+ private:
+  using Base = variant_internal::VariantBase<T0, Tn...>;
+
+ public:
+  // Constructors
+
+  // Constructs a variant holding a default-initialized value of the first
+  // alternative type.
+  constexpr variant() /*noexcept(see 111above)*/ = default;
+
+  // Copy constructor, standard semantics
+  variant(const variant& other) = default;
+
+  // Move constructor, standard semantics
+  variant(variant&& other) /*noexcept(see above)*/ = default;
+
+  // Constructs a variant of an alternative type specified by overload
+  // resolution of the provided forwarding arguments through
+  // direct-initialization.
+  //
+  // Note: If the selected constructor is a constexpr constructor, this
+  // constructor shall be a constexpr constructor.
+  //
+  // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
+  // has been voted passed the design phase in the C++ standard meeting in Mar
+  // 2018. It will be implemented and integrated into `absl::variant`.
+  template <
+      class T,
+      std::size_t I = std::enable_if<
+          variant_internal::IsNeitherSelfNorInPlace<variant,
+                                                    absl::decay_t<T>>::value,
+          variant_internal::IndexOfConstructedType<variant, T>>::type::value,
+      class Tj = absl::variant_alternative_t<I, variant>,
+      absl::enable_if_t<std::is_constructible<Tj, T>::value>* =
+          nullptr>
+  constexpr variant(T&& t) noexcept(std::is_nothrow_constructible<Tj, T>::value)
+      : Base(variant_internal::EmplaceTag<I>(), absl::forward<T>(t)) {}
+
+  // Constructs a variant of an alternative type from the arguments through
+  // direct-initialization.
+  //
+  // Note: If the selected constructor is a constexpr constructor, this
+  // constructor shall be a constexpr constructor.
+  template <class T, class... Args,
+            typename std::enable_if<std::is_constructible<
+                variant_internal::UnambiguousTypeOfT<variant, T>,
+                Args...>::value>::type* = nullptr>
+  constexpr explicit variant(in_place_type_t<T>, Args&&... args)
+      : Base(variant_internal::EmplaceTag<
+                 variant_internal::UnambiguousIndexOf<variant, T>::value>(),
+             absl::forward<Args>(args)...) {}
+
+  // Constructs a variant of an alternative type from an initializer list
+  // and other arguments through direct-initialization.
+  //
+  // Note: If the selected constructor is a constexpr constructor, this
+  // constructor shall be a constexpr constructor.
+  template <class T, class U, class... Args,
+            typename std::enable_if<std::is_constructible<
+                variant_internal::UnambiguousTypeOfT<variant, T>,
+                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+  constexpr explicit variant(in_place_type_t<T>, std::initializer_list<U> il,
+                             Args&&... args)
+      : Base(variant_internal::EmplaceTag<
+                 variant_internal::UnambiguousIndexOf<variant, T>::value>(),
+             il, absl::forward<Args>(args)...) {}
+
+  // Constructs a variant of an alternative type from a provided index,
+  // through value-initialization using the provided forwarded arguments.
+  template <std::size_t I, class... Args,
+            typename std::enable_if<std::is_constructible<
+                variant_internal::VariantAlternativeSfinaeT<I, variant>,
+                Args...>::value>::type* = nullptr>
+  constexpr explicit variant(in_place_index_t<I>, Args&&... args)
+      : Base(variant_internal::EmplaceTag<I>(), absl::forward<Args>(args)...) {}
+
+  // Constructs a variant of an alternative type from a provided index,
+  // through value-initialization of an initializer list and the provided
+  // forwarded arguments.
+  template <std::size_t I, class U, class... Args,
+            typename std::enable_if<std::is_constructible<
+                variant_internal::VariantAlternativeSfinaeT<I, variant>,
+                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+  constexpr explicit variant(in_place_index_t<I>, std::initializer_list<U> il,
+                             Args&&... args)
+      : Base(variant_internal::EmplaceTag<I>(), il,
+             absl::forward<Args>(args)...) {}
+
+  // Destructors
+
+  // Destroys the variant's currently contained value, provided that
+  // `absl::valueless_by_exception()` is false.
+  ~variant() = default;
+
+  // Assignment Operators
+
+  // Copy assignment operator
+  variant& operator=(const variant& other) = default;
+
+  // Move assignment operator
+  variant& operator=(variant&& other) /*noexcept(see above)*/ = default;
+
+  // Converting assignment operator
+  //
+  // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
+  // has been voted passed the design phase in the C++ standard meeting in Mar
+  // 2018. It will be implemented and integrated into `absl::variant`.
+  template <
+      class T,
+      std::size_t I = std::enable_if<
+          !std::is_same<absl::decay_t<T>, variant>::value,
+          variant_internal::IndexOfConstructedType<variant, T>>::type::value,
+      class Tj = absl::variant_alternative_t<I, variant>,
+      typename std::enable_if<std::is_assignable<Tj&, T>::value &&
+                              std::is_constructible<Tj, T>::value>::type* =
+          nullptr>
+  variant& operator=(T&& t) noexcept(
+      std::is_nothrow_assignable<Tj&, T>::value&&
+          std::is_nothrow_constructible<Tj, T>::value) {
+    variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
+        variant_internal::VariantCoreAccess::MakeConversionAssignVisitor(
+            this, absl::forward<T>(t)),
+        index());
+
+    return *this;
+  }
+
+
+  // emplace() Functions
+
+  // Constructs a value of the given alternative type T within the variant. The
+  // existing value of the variant is destroyed first (provided that
+  // `absl::valueless_by_exception()` is false). Requires that T is unambiguous
+  // in the variant.
+  //
+  // Example:
+  //
+  //   absl::variant<std::vector<int>, int, std::string> v;
+  //   v.emplace<int>(99);
+  //   v.emplace<std::string>("abc");
+  template <
+      class T, class... Args,
+      typename std::enable_if<std::is_constructible<
+          absl::variant_alternative_t<
+              variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
+          Args...>::value>::type* = nullptr>
+  T& emplace(Args&&... args) {
+    return variant_internal::VariantCoreAccess::Replace<
+        variant_internal::UnambiguousIndexOf<variant, T>::value>(
+        this, absl::forward<Args>(args)...);
+  }
+
+  // Constructs a value of the given alternative type T within the variant using
+  // an initializer list. The existing value of the variant is destroyed first
+  // (provided that `absl::valueless_by_exception()` is false). Requires that T
+  // is unambiguous in the variant.
+  //
+  // Example:
+  //
+  //   absl::variant<std::vector<int>, int, std::string> v;
+  //   v.emplace<std::vector<int>>({0, 1, 2});
+  template <
+      class T, class U, class... Args,
+      typename std::enable_if<std::is_constructible<
+          absl::variant_alternative_t<
+              variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
+          std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+  T& emplace(std::initializer_list<U> il, Args&&... args) {
+    return variant_internal::VariantCoreAccess::Replace<
+        variant_internal::UnambiguousIndexOf<variant, T>::value>(
+        this, il, absl::forward<Args>(args)...);
+  }
+
+  // Destroys the current value of the variant (provided that
+  // `absl::valueless_by_exception()` is false) and constructs a new value at
+  // the given index.
+  //
+  // Example:
+  //
+  //   absl::variant<std::vector<int>, int, int> v;
+  //   v.emplace<1>(99);
+  //   v.emplace<2>(98);
+  //   v.emplace<int>(99);  // Won't compile. 'int' isn't a unique type.
+  template <std::size_t I, class... Args,
+            typename std::enable_if<
+                std::is_constructible<absl::variant_alternative_t<I, variant>,
+                                      Args...>::value>::type* = nullptr>
+  absl::variant_alternative_t<I, variant>& emplace(Args&&... args) {
+    return variant_internal::VariantCoreAccess::Replace<I>(
+        this, absl::forward<Args>(args)...);
+  }
+
+  // Destroys the current value of the variant (provided that
+  // `absl::valueless_by_exception()` is false) and constructs a new value at
+  // the given index using an initializer list and the provided arguments.
+  //
+  // Example:
+  //
+  //   absl::variant<std::vector<int>, int, int> v;
+  //   v.emplace<0>({0, 1, 2});
+  template <std::size_t I, class U, class... Args,
+            typename std::enable_if<std::is_constructible<
+                absl::variant_alternative_t<I, variant>,
+                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+  absl::variant_alternative_t<I, variant>& emplace(std::initializer_list<U> il,
+                                                   Args&&... args) {
+    return variant_internal::VariantCoreAccess::Replace<I>(
+        this, il, absl::forward<Args>(args)...);
+  }
+
+  // variant::valueless_by_exception()
+  //
+  // Returns false if and only if the variant currently holds a valid value.
+  constexpr bool valueless_by_exception() const noexcept {
+    return this->index_ == absl::variant_npos;
+  }
+
+  // variant::index()
+  //
+  // Returns the index value of the variant's currently selected alternative
+  // type.
+  constexpr std::size_t index() const noexcept { return this->index_; }
+
+  // variant::swap()
+  //
+  // Swaps the values of two variant objects.
+  //
+  void swap(variant& rhs) noexcept(
+      absl::conjunction<
+          std::is_nothrow_move_constructible<T0>,
+          std::is_nothrow_move_constructible<Tn>...,
+          type_traits_internal::IsNothrowSwappable<T0>,
+          type_traits_internal::IsNothrowSwappable<Tn>...>::value) {
+    return variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
+        variant_internal::Swap<T0, Tn...>{this, &rhs}, rhs.index());
+  }
+};
+
+// We need a valid declaration of variant<> for SFINAE and overload resolution
+// to work properly above, but we don't need a full declaration since this type
+// will never be constructed. This declaration, though incomplete, suffices.
+template <>
+class variant<>;
+
+//------------------------------------------------------------------------------
+// Relational Operators
+//------------------------------------------------------------------------------
+//
+// If neither operand is in the `variant::valueless_by_exception` state:
+//
+//   * If the index of both variants is the same, the relational operator
+//     returns the result of the corresponding relational operator for the
+//     corresponding alternative type.
+//   * If the index of both variants is not the same, the relational operator
+//     returns the result of that operation applied to the value of the left
+//     operand's index and the value of the right operand's index.
+//   * If at least one operand is in the valueless_by_exception state:
+//     - A variant in the valueless_by_exception state is only considered equal
+//       to another variant in the valueless_by_exception state.
+//     - If exactly one operand is in the valueless_by_exception state, the
+//       variant in the valueless_by_exception state is less than the variant
+//       that is not in the valueless_by_exception state.
+//
+// Note: The value 1 is added to each index in the relational comparisons such
+// that the index corresponding to the valueless_by_exception state wraps around
+// to 0 (the lowest value for the index type), and the remaining indices stay in
+// the same relative order.
+
+// Equal-to operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveEqualT<Types...> operator==(
+    const variant<Types...>& a, const variant<Types...>& b) {
+  return (a.index() == b.index()) &&
+         variant_internal::VisitIndices<sizeof...(Types)>::Run(
+             variant_internal::EqualsOp<Types...>{&a, &b}, a.index());
+}
+
+// Not equal operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveNotEqualT<Types...> operator!=(
+    const variant<Types...>& a, const variant<Types...>& b) {
+  return (a.index() != b.index()) ||
+         variant_internal::VisitIndices<sizeof...(Types)>::Run(
+             variant_internal::NotEqualsOp<Types...>{&a, &b}, a.index());
+}
+
+// Less-than operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveLessThanT<Types...> operator<(
+    const variant<Types...>& a, const variant<Types...>& b) {
+  return (a.index() != b.index())
+             ? (a.index() + 1) < (b.index() + 1)
+             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
+                   variant_internal::LessThanOp<Types...>{&a, &b}, a.index());
+}
+
+// Greater-than operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveGreaterThanT<Types...> operator>(
+    const variant<Types...>& a, const variant<Types...>& b) {
+  return (a.index() != b.index())
+             ? (a.index() + 1) > (b.index() + 1)
+             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
+                   variant_internal::GreaterThanOp<Types...>{&a, &b},
+                   a.index());
+}
+
+// Less-than or equal-to operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...> operator<=(
+    const variant<Types...>& a, const variant<Types...>& b) {
+  return (a.index() != b.index())
+             ? (a.index() + 1) < (b.index() + 1)
+             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
+                   variant_internal::LessThanOrEqualsOp<Types...>{&a, &b},
+                   a.index());
+}
+
+// Greater-than or equal-to operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...>
+operator>=(const variant<Types...>& a, const variant<Types...>& b) {
+  return (a.index() != b.index())
+             ? (a.index() + 1) > (b.index() + 1)
+             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
+                   variant_internal::GreaterThanOrEqualsOp<Types...>{&a, &b},
+                   a.index());
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+namespace std {
+
+// hash()
+template <>  // NOLINT
+struct hash<absl::monostate> {
+  std::size_t operator()(absl::monostate) const { return 0; }
+};
+
+template <class... T>  // NOLINT
+struct hash<absl::variant<T...>>
+    : absl::variant_internal::VariantHashBase<absl::variant<T...>, void,
+                                              absl::remove_const_t<T>...> {};
+
+}  // namespace std
+
+#endif  // ABSL_USES_STD_VARIANT
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace variant_internal {
+
+// Helper visitor for converting a variant<Ts...>` into another type (mostly
+// variant) that can be constructed from any type.
+template <typename To>
+struct ConversionVisitor {
+  template <typename T>
+  To operator()(T&& v) const {
+    return To(std::forward<T>(v));
+  }
+};
+
+}  // namespace variant_internal
+
+// ConvertVariantTo()
+//
+// Helper functions to convert an `absl::variant` to a variant of another set of
+// types, provided that the alternative type of the new variant type can be
+// converted from any type in the source variant.
+//
+// Example:
+//
+//   absl::variant<name1, name2, float> InternalReq(const Req&);
+//
+//   // name1 and name2 are convertible to name
+//   absl::variant<name, float> ExternalReq(const Req& req) {
+//     return absl::ConvertVariantTo<absl::variant<name, float>>(
+//              InternalReq(req));
+//   }
+template <typename To, typename Variant>
+To ConvertVariantTo(Variant&& variant) {
+  return absl::visit(variant_internal::ConversionVisitor<To>{},
+                     std::forward<Variant>(variant));
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_TYPES_VARIANT_H_
diff --git a/CAPI/cpp/grpc/include/absl/utility/utility.h b/CAPI/cpp/grpc/include/absl/utility/utility.h
new file mode 100644
index 0000000..bf92322
--- /dev/null
+++ b/CAPI/cpp/grpc/include/absl/utility/utility.h
@@ -0,0 +1,350 @@
+// Copyright 2017 The Abseil Authors.
+//
+// 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
+//
+//      https://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.
+//
+// This header file contains C++11 versions of standard <utility> header
+// abstractions available within C++14 and C++17, and are designed to be drop-in
+// replacement for code compliant with C++14 and C++17.
+//
+// The following abstractions are defined:
+//
+//   * integer_sequence<T, Ints...>  == std::integer_sequence<T, Ints...>
+//   * index_sequence<Ints...>       == std::index_sequence<Ints...>
+//   * make_integer_sequence<T, N>   == std::make_integer_sequence<T, N>
+//   * make_index_sequence<N>        == std::make_index_sequence<N>
+//   * index_sequence_for<Ts...>     == std::index_sequence_for<Ts...>
+//   * apply<Functor, Tuple>         == std::apply<Functor, Tuple>
+//   * exchange<T>                   == std::exchange<T>
+//   * make_from_tuple<T>            == std::make_from_tuple<T>
+//
+// This header file also provides the tag types `in_place_t`, `in_place_type_t`,
+// and `in_place_index_t`, as well as the constant `in_place`, and
+// `constexpr` `std::move()` and `std::forward()` implementations in C++11.
+//
+// References:
+//
+//  https://en.cppreference.com/w/cpp/utility/integer_sequence
+//  https://en.cppreference.com/w/cpp/utility/apply
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
+
+#ifndef ABSL_UTILITY_UTILITY_H_
+#define ABSL_UTILITY_UTILITY_H_
+
+#include <cstddef>
+#include <cstdlib>
+#include <tuple>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/inline_variable.h"
+#include "absl/base/internal/invoke.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `absl::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence {
+  using value_type = T;
+  static constexpr size_t size() noexcept { return sizeof...(Ints); }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal {
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0> {
+  using type = integer_sequence<T, Ints..., (Ints + SeqSize)...>;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1> {
+  using type = integer_sequence<T, Ints..., (Ints + SeqSize)..., 2 * SeqSize>;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen {
+  using type =
+      typename Extend<typename Gen<T, N / 2>::type, N / 2, N % 2>::type;
+};
+
+template <typename T>
+struct Gen<T, 0> {
+  using type = integer_sequence<T>;
+};
+
+template <typename T>
+struct InPlaceTypeTag {
+  explicit InPlaceTypeTag() = delete;
+  InPlaceTypeTag(const InPlaceTypeTag&) = delete;
+  InPlaceTypeTag& operator=(const InPlaceTypeTag&) = delete;
+};
+
+template <size_t I>
+struct InPlaceIndexTag {
+  explicit InPlaceIndexTag() = delete;
+  InPlaceIndexTag(const InPlaceIndexTag&) = delete;
+  InPlaceIndexTag& operator=(const InPlaceIndexTag&) = delete;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+// Tag types
+
+#ifdef ABSL_USES_STD_OPTIONAL
+
+using std::in_place_t;
+using std::in_place;
+
+#else  // ABSL_USES_STD_OPTIONAL
+
+// in_place_t
+//
+// Tag type used to specify in-place construction, such as with
+// `absl::optional`, designed to be a drop-in replacement for C++17's
+// `std::in_place_t`.
+struct in_place_t {};
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
+
+#endif  // ABSL_USES_STD_OPTIONAL
+
+#if defined(ABSL_USES_STD_ANY) || defined(ABSL_USES_STD_VARIANT)
+using std::in_place_type;
+using std::in_place_type_t;
+#else
+
+// in_place_type_t
+//
+// Tag type used for in-place construction when the type to construct needs to
+// be specified, such as with `absl::any`, designed to be a drop-in replacement
+// for C++17's `std::in_place_type_t`.
+template <typename T>
+using in_place_type_t = void (*)(utility_internal::InPlaceTypeTag<T>);
+
+template <typename T>
+void in_place_type(utility_internal::InPlaceTypeTag<T>) {}
+#endif  // ABSL_USES_STD_ANY || ABSL_USES_STD_VARIANT
+
+#ifdef ABSL_USES_STD_VARIANT
+using std::in_place_index;
+using std::in_place_index_t;
+#else
+
+// in_place_index_t
+//
+// Tag type used for in-place construction when the type to construct needs to
+// be specified, such as with `absl::any`, designed to be a drop-in replacement
+// for C++17's `std::in_place_index_t`.
+template <size_t I>
+using in_place_index_t = void (*)(utility_internal::InPlaceIndexTag<I>);
+
+template <size_t I>
+void in_place_index(utility_internal::InPlaceIndexTag<I>) {}
+#endif  // ABSL_USES_STD_VARIANT
+
+// Constexpr move and forward
+
+// move()
+//
+// A constexpr version of `std::move()`, designed to be a drop-in replacement
+// for C++14's `std::move()`.
+template <typename T>
+constexpr absl::remove_reference_t<T>&& move(T&& t) noexcept {
+  return static_cast<absl::remove_reference_t<T>&&>(t);
+}
+
+// forward()
+//
+// A constexpr version of `std::forward()`, designed to be a drop-in replacement
+// for C++14's `std::forward()`.
+template <typename T>
+constexpr T&& forward(
+    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
+  return static_cast<T&&>(t);
+}
+
+namespace utility_internal {
+// Helper method for expanding tuple into a called method.
+template <typename Functor, typename Tuple, std::size_t... Indexes>
+auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>)
+    -> decltype(absl::base_internal::invoke(
+        absl::forward<Functor>(functor),
+        std::get<Indexes>(absl::forward<Tuple>(t))...)) {
+  return absl::base_internal::invoke(
+      absl::forward<Functor>(functor),
+      std::get<Indexes>(absl::forward<Tuple>(t))...);
+}
+
+}  // namespace utility_internal
+
+// apply
+//
+// Invokes a Callable using elements of a tuple as its arguments.
+// Each element of the tuple corresponds to an argument of the call (in order).
+// Both the Callable argument and the tuple argument are perfect-forwarded.
+// For member-function Callables, the first tuple element acts as the `this`
+// pointer. `absl::apply` is designed to be a drop-in replacement for C++17's
+// `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`.
+//
+// Example:
+//
+//   class Foo {
+//    public:
+//     void Bar(int);
+//   };
+//   void user_function1(int, std::string);
+//   void user_function2(std::unique_ptr<Foo>);
+//   auto user_lambda = [](int, int) {};
+//
+//   int main()
+//   {
+//       std::tuple<int, std::string> tuple1(42, "bar");
+//       // Invokes the first user function on int, std::string.
+//       absl::apply(&user_function1, tuple1);
+//
+//       std::tuple<std::unique_ptr<Foo>> tuple2(absl::make_unique<Foo>());
+//       // Invokes the user function that takes ownership of the unique
+//       // pointer.
+//       absl::apply(&user_function2, std::move(tuple2));
+//
+//       auto foo = absl::make_unique<Foo>();
+//       std::tuple<Foo*, int> tuple3(foo.get(), 42);
+//       // Invokes the method Bar on foo with one argument, 42.
+//       absl::apply(&Foo::Bar, tuple3);
+//
+//       std::tuple<int, int> tuple4(8, 9);
+//       // Invokes a lambda.
+//       absl::apply(user_lambda, tuple4);
+//   }
+template <typename Functor, typename Tuple>
+auto apply(Functor&& functor, Tuple&& t)
+    -> decltype(utility_internal::apply_helper(
+        absl::forward<Functor>(functor), absl::forward<Tuple>(t),
+        absl::make_index_sequence<std::tuple_size<
+            typename std::remove_reference<Tuple>::type>::value>{})) {
+  return utility_internal::apply_helper(
+      absl::forward<Functor>(functor), absl::forward<Tuple>(t),
+      absl::make_index_sequence<std::tuple_size<
+          typename std::remove_reference<Tuple>::type>::value>{});
+}
+
+// exchange
+//
+// Replaces the value of `obj` with `new_value` and returns the old value of
+// `obj`.  `absl::exchange` is designed to be a drop-in replacement for C++14's
+// `std::exchange`.
+//
+// Example:
+//
+//   Foo& operator=(Foo&& other) {
+//     ptr1_ = absl::exchange(other.ptr1_, nullptr);
+//     int1_ = absl::exchange(other.int1_, -1);
+//     return *this;
+//   }
+template <typename T, typename U = T>
+T exchange(T& obj, U&& new_value) {
+  T old_value = absl::move(obj);
+  obj = absl::forward<U>(new_value);
+  return old_value;
+}
+
+namespace utility_internal {
+template <typename T, typename Tuple, size_t... I>
+T make_from_tuple_impl(Tuple&& tup, absl::index_sequence<I...>) {
+  return T(std::get<I>(std::forward<Tuple>(tup))...);
+}
+}  // namespace utility_internal
+
+// make_from_tuple
+//
+// Given the template parameter type `T` and a tuple of arguments
+// `std::tuple(arg0, arg1, ..., argN)` constructs an object of type `T` as if by
+// calling `T(arg0, arg1, ..., argN)`.
+//
+// Example:
+//
+//   std::tuple<const char*, size_t> args("hello world", 5);
+//   auto s = absl::make_from_tuple<std::string>(args);
+//   assert(s == "hello");
+//
+template <typename T, typename Tuple>
+constexpr T make_from_tuple(Tuple&& tup) {
+  return utility_internal::make_from_tuple_impl<T>(
+      std::forward<Tuple>(tup),
+      absl::make_index_sequence<
+          std::tuple_size<absl::decay_t<Tuple>>::value>{});
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_UTILITY_UTILITY_H_
diff --git a/CAPI/cpp/grpc/include/ares.h b/CAPI/cpp/grpc/include/ares.h
new file mode 100644
index 0000000..9831ff2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/ares.h
@@ -0,0 +1,755 @@
+
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ * Copyright (C) 2007-2013 by Daniel Stenberg
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#ifndef ARES__H
+#define ARES__H
+
+#include "ares_version.h"  /* c-ares version defines   */
+#include "ares_build.h"    /* c-ares build definitions */
+#include "ares_rules.h"    /* c-ares rules enforcement */
+
+/*
+ * Define WIN32 when build target is Win32 API
+ */
+
+#if (defined(_WIN32) || defined(__WIN32__)) && \
+   !defined(WIN32) && !defined(__SYMBIAN32__)
+#  define WIN32
+#endif
+
+#include <sys/types.h>
+
+/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish
+   libc5-based Linux systems. Only include it on system that are known to
+   require it! */
+#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \
+    defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \
+    defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \
+    defined(__QNXNTO__) || defined(__MVS__) || defined(__HAIKU__)
+#include <sys/select.h>
+#endif
+#if (defined(NETWARE) && !defined(__NOVELL_LIBC__))
+#include <sys/bsdskt.h>
+#endif
+
+#if defined(WATT32)
+#  include <netinet/in.h>
+#  include <sys/socket.h>
+#  include <tcp.h>
+#elif defined(_WIN32_WCE)
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  include <winsock.h>
+#elif defined(WIN32)
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#else
+#  include <sys/socket.h>
+#  include <netinet/in.h>
+#endif
+
+#if defined(ANDROID) || defined(__ANDROID__)
+#include <jni.h>
+#endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+** c-ares external API function linkage decorations.
+*/
+
+#if 1
+#  define CARES_EXTERN
+#elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)
+#  if defined(CARES_BUILDING_LIBRARY)
+#    define CARES_EXTERN  __declspec(dllexport)
+#  else
+#    define CARES_EXTERN  __declspec(dllimport)
+#  endif
+#elif defined(CARES_BUILDING_LIBRARY) && defined(CARES_SYMBOL_HIDING)
+#  define CARES_EXTERN CARES_SYMBOL_SCOPE_EXTERN
+#else
+#  define CARES_EXTERN
+#endif
+
+
+#define ARES_SUCCESS            0
+
+/* Server error codes (ARES_ENODATA indicates no relevant answer) */
+#define ARES_ENODATA            1
+#define ARES_EFORMERR           2
+#define ARES_ESERVFAIL          3
+#define ARES_ENOTFOUND          4
+#define ARES_ENOTIMP            5
+#define ARES_EREFUSED           6
+
+/* Locally generated error codes */
+#define ARES_EBADQUERY          7
+#define ARES_EBADNAME           8
+#define ARES_EBADFAMILY         9
+#define ARES_EBADRESP           10
+#define ARES_ECONNREFUSED       11
+#define ARES_ETIMEOUT           12
+#define ARES_EOF                13
+#define ARES_EFILE              14
+#define ARES_ENOMEM             15
+#define ARES_EDESTRUCTION       16
+#define ARES_EBADSTR            17
+
+/* ares_getnameinfo error codes */
+#define ARES_EBADFLAGS          18
+
+/* ares_getaddrinfo error codes */
+#define ARES_ENONAME            19
+#define ARES_EBADHINTS          20
+
+/* Uninitialized library error code */
+#define ARES_ENOTINITIALIZED    21          /* introduced in 1.7.0 */
+
+/* ares_library_init error codes */
+#define ARES_ELOADIPHLPAPI           22     /* introduced in 1.7.0 */
+#define ARES_EADDRGETNETWORKPARAMS   23     /* introduced in 1.7.0 */
+
+/* More error codes */
+#define ARES_ECANCELLED         24          /* introduced in 1.7.0 */
+
+/* More ares_getaddrinfo error codes */
+#define ARES_ESERVICE           25          /* introduced in 1.?.0 */
+
+/* Flag values */
+#define ARES_FLAG_USEVC         (1 << 0)
+#define ARES_FLAG_PRIMARY       (1 << 1)
+#define ARES_FLAG_IGNTC         (1 << 2)
+#define ARES_FLAG_NORECURSE     (1 << 3)
+#define ARES_FLAG_STAYOPEN      (1 << 4)
+#define ARES_FLAG_NOSEARCH      (1 << 5)
+#define ARES_FLAG_NOALIASES     (1 << 6)
+#define ARES_FLAG_NOCHECKRESP   (1 << 7)
+#define ARES_FLAG_EDNS          (1 << 8)
+
+/* Option mask values */
+#define ARES_OPT_FLAGS          (1 << 0)
+#define ARES_OPT_TIMEOUT        (1 << 1)
+#define ARES_OPT_TRIES          (1 << 2)
+#define ARES_OPT_NDOTS          (1 << 3)
+#define ARES_OPT_UDP_PORT       (1 << 4)
+#define ARES_OPT_TCP_PORT       (1 << 5)
+#define ARES_OPT_SERVERS        (1 << 6)
+#define ARES_OPT_DOMAINS        (1 << 7)
+#define ARES_OPT_LOOKUPS        (1 << 8)
+#define ARES_OPT_SOCK_STATE_CB  (1 << 9)
+#define ARES_OPT_SORTLIST       (1 << 10)
+#define ARES_OPT_SOCK_SNDBUF    (1 << 11)
+#define ARES_OPT_SOCK_RCVBUF    (1 << 12)
+#define ARES_OPT_TIMEOUTMS      (1 << 13)
+#define ARES_OPT_ROTATE         (1 << 14)
+#define ARES_OPT_EDNSPSZ        (1 << 15)
+#define ARES_OPT_NOROTATE       (1 << 16)
+#define ARES_OPT_RESOLVCONF     (1 << 17)
+
+/* Nameinfo flag values */
+#define ARES_NI_NOFQDN                  (1 << 0)
+#define ARES_NI_NUMERICHOST             (1 << 1)
+#define ARES_NI_NAMEREQD                (1 << 2)
+#define ARES_NI_NUMERICSERV             (1 << 3)
+#define ARES_NI_DGRAM                   (1 << 4)
+#define ARES_NI_TCP                     0
+#define ARES_NI_UDP                     ARES_NI_DGRAM
+#define ARES_NI_SCTP                    (1 << 5)
+#define ARES_NI_DCCP                    (1 << 6)
+#define ARES_NI_NUMERICSCOPE            (1 << 7)
+#define ARES_NI_LOOKUPHOST              (1 << 8)
+#define ARES_NI_LOOKUPSERVICE           (1 << 9)
+/* Reserved for future use */
+#define ARES_NI_IDN                     (1 << 10)
+#define ARES_NI_IDN_ALLOW_UNASSIGNED    (1 << 11)
+#define ARES_NI_IDN_USE_STD3_ASCII_RULES (1 << 12)
+
+/* Addrinfo flag values */
+#define ARES_AI_CANONNAME               (1 << 0)
+#define ARES_AI_NUMERICHOST             (1 << 1)
+#define ARES_AI_PASSIVE                 (1 << 2)
+#define ARES_AI_NUMERICSERV             (1 << 3)
+#define ARES_AI_V4MAPPED                (1 << 4)
+#define ARES_AI_ALL                     (1 << 5)
+#define ARES_AI_ADDRCONFIG              (1 << 6)
+#define ARES_AI_NOSORT                  (1 << 7)
+#define ARES_AI_ENVHOSTS                (1 << 8)
+/* Reserved for future use */
+#define ARES_AI_IDN                     (1 << 10)
+#define ARES_AI_IDN_ALLOW_UNASSIGNED    (1 << 11)
+#define ARES_AI_IDN_USE_STD3_ASCII_RULES (1 << 12)
+#define ARES_AI_CANONIDN                (1 << 13)
+
+#define ARES_AI_MASK (ARES_AI_CANONNAME|ARES_AI_NUMERICHOST|ARES_AI_PASSIVE| \
+                      ARES_AI_NUMERICSERV|ARES_AI_V4MAPPED|ARES_AI_ALL| \
+                      ARES_AI_ADDRCONFIG)
+#define ARES_GETSOCK_MAXNUM 16 /* ares_getsock() can return info about this
+                                  many sockets */
+#define ARES_GETSOCK_READABLE(bits,num) (bits & (1<< (num)))
+#define ARES_GETSOCK_WRITABLE(bits,num) (bits & (1 << ((num) + \
+                                         ARES_GETSOCK_MAXNUM)))
+
+/* c-ares library initialization flag values */
+#define ARES_LIB_INIT_NONE   (0)
+#define ARES_LIB_INIT_WIN32  (1 << 0)
+#define ARES_LIB_INIT_ALL    (ARES_LIB_INIT_WIN32)
+
+
+/*
+ * Typedef our socket type
+ */
+
+#ifndef ares_socket_typedef
+#ifdef WIN32
+typedef SOCKET ares_socket_t;
+#define ARES_SOCKET_BAD INVALID_SOCKET
+#else
+typedef int ares_socket_t;
+#define ARES_SOCKET_BAD -1
+#endif
+#define ares_socket_typedef
+#endif /* ares_socket_typedef */
+
+typedef void (*ares_sock_state_cb)(void *data,
+                                   ares_socket_t socket_fd,
+                                   int readable,
+                                   int writable);
+
+struct apattern;
+
+/* NOTE about the ares_options struct to users and developers.
+
+   This struct will remain looking like this. It will not be extended nor
+   shrunk in future releases, but all new options will be set by ares_set_*()
+   options instead of with the ares_init_options() function.
+
+   Eventually (in a galaxy far far away), all options will be settable by
+   ares_set_*() options and the ares_init_options() function will become
+   deprecated.
+
+   When new options are added to c-ares, they are not added to this
+   struct. And they are not "saved" with the ares_save_options() function but
+   instead we encourage the use of the ares_dup() function. Needless to say,
+   if you add config options to c-ares you need to make sure ares_dup()
+   duplicates this new option.
+
+ */
+struct ares_options {
+  int flags;
+  int timeout; /* in seconds or milliseconds, depending on options */
+  int tries;
+  int ndots;
+  unsigned short udp_port;
+  unsigned short tcp_port;
+  int socket_send_buffer_size;
+  int socket_receive_buffer_size;
+  struct in_addr *servers;
+  int nservers;
+  char **domains;
+  int ndomains;
+  char *lookups;
+  ares_sock_state_cb sock_state_cb;
+  void *sock_state_cb_data;
+  struct apattern *sortlist;
+  int nsort;
+  int ednspsz;
+  char *resolvconf_path;
+};
+
+struct hostent;
+struct timeval;
+struct sockaddr;
+struct ares_channeldata;
+struct ares_addrinfo;
+struct ares_addrinfo_hints;
+
+typedef struct ares_channeldata *ares_channel;
+
+typedef void (*ares_callback)(void *arg,
+                              int status,
+                              int timeouts,
+                              unsigned char *abuf,
+                              int alen);
+
+typedef void (*ares_host_callback)(void *arg,
+                                   int status,
+                                   int timeouts,
+                                   struct hostent *hostent);
+
+typedef void (*ares_nameinfo_callback)(void *arg,
+                                       int status,
+                                       int timeouts,
+                                       char *node,
+                                       char *service);
+
+typedef int  (*ares_sock_create_callback)(ares_socket_t socket_fd,
+                                          int type,
+                                          void *data);
+
+typedef int  (*ares_sock_config_callback)(ares_socket_t socket_fd,
+                                          int type,
+                                          void *data);
+
+typedef void (*ares_addrinfo_callback)(void *arg,
+                                   int status,
+                                   int timeouts,
+                                   struct ares_addrinfo *res);
+
+CARES_EXTERN int ares_library_init(int flags);
+
+CARES_EXTERN int ares_library_init_mem(int flags,
+                                       void *(*amalloc)(size_t size),
+                                       void (*afree)(void *ptr),
+                                       void *(*arealloc)(void *ptr, size_t size));
+
+#if defined(ANDROID) || defined(__ANDROID__)
+CARES_EXTERN void ares_library_init_jvm(JavaVM *jvm);
+CARES_EXTERN int ares_library_init_android(jobject connectivity_manager);
+CARES_EXTERN int ares_library_android_initialized(void);
+#endif
+
+CARES_EXTERN int ares_library_initialized(void);
+
+CARES_EXTERN void ares_library_cleanup(void);
+
+CARES_EXTERN const char *ares_version(int *version);
+
+CARES_EXTERN int ares_init(ares_channel *channelptr);
+
+CARES_EXTERN int ares_init_options(ares_channel *channelptr,
+                                   struct ares_options *options,
+                                   int optmask);
+
+CARES_EXTERN int ares_save_options(ares_channel channel,
+                                   struct ares_options *options,
+                                   int *optmask);
+
+CARES_EXTERN void ares_destroy_options(struct ares_options *options);
+
+CARES_EXTERN int ares_dup(ares_channel *dest,
+                          ares_channel src);
+
+CARES_EXTERN void ares_destroy(ares_channel channel);
+
+CARES_EXTERN void ares_cancel(ares_channel channel);
+
+/* These next 3 configure local binding for the out-going socket
+ * connection.  Use these to specify source IP and/or network device
+ * on multi-homed systems.
+ */
+CARES_EXTERN void ares_set_local_ip4(ares_channel channel, unsigned int local_ip);
+
+/* local_ip6 should be 16 bytes in length */
+CARES_EXTERN void ares_set_local_ip6(ares_channel channel,
+                                     const unsigned char* local_ip6);
+
+/* local_dev_name should be null terminated. */
+CARES_EXTERN void ares_set_local_dev(ares_channel channel,
+                                     const char* local_dev_name);
+
+CARES_EXTERN void ares_set_socket_callback(ares_channel channel,
+                                           ares_sock_create_callback callback,
+                                           void *user_data);
+
+CARES_EXTERN void ares_set_socket_configure_callback(ares_channel channel,
+                                                     ares_sock_config_callback callback,
+                                                     void *user_data);
+
+CARES_EXTERN int ares_set_sortlist(ares_channel channel,
+                                   const char *sortstr);
+
+CARES_EXTERN void ares_getaddrinfo(ares_channel channel,
+                                   const char* node,
+                                   const char* service,
+                                   const struct ares_addrinfo_hints* hints,
+                                   ares_addrinfo_callback callback,
+                                   void* arg);
+
+CARES_EXTERN void ares_freeaddrinfo(struct ares_addrinfo* ai);
+
+/*
+ * Virtual function set to have user-managed socket IO.
+ * Note that all functions need to be defined, and when
+ * set, the library will not do any bind nor set any
+ * socket options, assuming the client handles these
+ * through either socket creation or the
+ * ares_sock_config_callback call.
+ */
+struct iovec;
+struct ares_socket_functions {
+   ares_socket_t(*asocket)(int, int, int, void *);
+   int(*aclose)(ares_socket_t, void *);
+   int(*aconnect)(ares_socket_t, const struct sockaddr *, ares_socklen_t, void *);
+   ares_ssize_t(*arecvfrom)(ares_socket_t, void *, size_t, int, struct sockaddr *, ares_socklen_t *, void *);
+   ares_ssize_t(*asendv)(ares_socket_t, const struct iovec *, int, void *);
+};
+
+CARES_EXTERN void ares_set_socket_functions(ares_channel channel,
+					    const struct ares_socket_functions * funcs,
+					    void *user_data);
+
+CARES_EXTERN void ares_send(ares_channel channel,
+                            const unsigned char *qbuf,
+                            int qlen,
+                            ares_callback callback,
+                            void *arg);
+
+CARES_EXTERN void ares_query(ares_channel channel,
+                             const char *name,
+                             int dnsclass,
+                             int type,
+                             ares_callback callback,
+                             void *arg);
+
+CARES_EXTERN void ares_search(ares_channel channel,
+                              const char *name,
+                              int dnsclass,
+                              int type,
+                              ares_callback callback,
+                              void *arg);
+
+CARES_EXTERN void ares_gethostbyname(ares_channel channel,
+                                     const char *name,
+                                     int family,
+                                     ares_host_callback callback,
+                                     void *arg);
+
+CARES_EXTERN int ares_gethostbyname_file(ares_channel channel,
+                                         const char *name,
+                                         int family,
+                                         struct hostent **host);
+
+CARES_EXTERN void ares_gethostbyaddr(ares_channel channel,
+                                     const void *addr,
+                                     int addrlen,
+                                     int family,
+                                     ares_host_callback callback,
+                                     void *arg);
+
+CARES_EXTERN void ares_getnameinfo(ares_channel channel,
+                                   const struct sockaddr *sa,
+                                   ares_socklen_t salen,
+                                   int flags,
+                                   ares_nameinfo_callback callback,
+                                   void *arg);
+
+CARES_EXTERN int ares_fds(ares_channel channel,
+                          fd_set *read_fds,
+                          fd_set *write_fds);
+
+CARES_EXTERN int ares_getsock(ares_channel channel,
+                              ares_socket_t *socks,
+                              int numsocks);
+
+CARES_EXTERN struct timeval *ares_timeout(ares_channel channel,
+                                          struct timeval *maxtv,
+                                          struct timeval *tv);
+
+CARES_EXTERN void ares_process(ares_channel channel,
+                               fd_set *read_fds,
+                               fd_set *write_fds);
+
+CARES_EXTERN void ares_process_fd(ares_channel channel,
+                                  ares_socket_t read_fd,
+                                  ares_socket_t write_fd);
+
+CARES_EXTERN int ares_create_query(const char *name,
+                                   int dnsclass,
+                                   int type,
+                                   unsigned short id,
+                                   int rd,
+                                   unsigned char **buf,
+                                   int *buflen,
+                                   int max_udp_size);
+
+CARES_EXTERN int ares_mkquery(const char *name,
+                              int dnsclass,
+                              int type,
+                              unsigned short id,
+                              int rd,
+                              unsigned char **buf,
+                              int *buflen);
+
+CARES_EXTERN int ares_expand_name(const unsigned char *encoded,
+                                  const unsigned char *abuf,
+                                  int alen,
+                                  char **s,
+                                  long *enclen);
+
+CARES_EXTERN int ares_expand_string(const unsigned char *encoded,
+                                    const unsigned char *abuf,
+                                    int alen,
+                                    unsigned char **s,
+                                    long *enclen);
+
+/*
+ * NOTE: before c-ares 1.7.0 we would most often use the system in6_addr
+ * struct below when ares itself was built, but many apps would use this
+ * private version since the header checked a HAVE_* define for it. Starting
+ * with 1.7.0 we always declare and use our own to stop relying on the
+ * system's one.
+ */
+struct ares_in6_addr {
+  union {
+    unsigned char _S6_u8[16];
+  } _S6_un;
+};
+
+struct ares_addrttl {
+  struct in_addr ipaddr;
+  int            ttl;
+};
+
+struct ares_addr6ttl {
+  struct ares_in6_addr ip6addr;
+  int             ttl;
+};
+
+struct ares_caa_reply {
+  struct ares_caa_reply  *next;
+  int                     critical;
+  unsigned char          *property;
+  size_t                  plength;  /* plength excludes null termination */
+  unsigned char          *value;
+  size_t                  length;   /* length excludes null termination */
+};
+
+struct ares_srv_reply {
+  struct ares_srv_reply  *next;
+  char                   *host;
+  unsigned short          priority;
+  unsigned short          weight;
+  unsigned short          port;
+};
+
+struct ares_mx_reply {
+  struct ares_mx_reply   *next;
+  char                   *host;
+  unsigned short          priority;
+};
+
+struct ares_txt_reply {
+  struct ares_txt_reply  *next;
+  unsigned char          *txt;
+  size_t                  length;  /* length excludes null termination */
+};
+
+/* NOTE: This structure is a superset of ares_txt_reply
+ */
+struct ares_txt_ext {
+  struct ares_txt_ext      *next;
+  unsigned char            *txt;
+  size_t                   length;
+  /* 1 - if start of new record
+   * 0 - if a chunk in the same record */
+  unsigned char            record_start;
+};
+
+struct ares_naptr_reply {
+  struct ares_naptr_reply *next;
+  unsigned char           *flags;
+  unsigned char           *service;
+  unsigned char           *regexp;
+  char                    *replacement;
+  unsigned short           order;
+  unsigned short           preference;
+};
+
+struct ares_soa_reply {
+  char        *nsname;
+  char        *hostmaster;
+  unsigned int serial;
+  unsigned int refresh;
+  unsigned int retry;
+  unsigned int expire;
+  unsigned int minttl;
+};
+
+struct ares_uri_reply {
+  struct ares_uri_reply  *next;
+  unsigned short          priority;
+  unsigned short          weight;
+  char                   *uri;
+  int                     ttl;
+};
+
+/*
+ * Similar to addrinfo, but with extra ttl and missing canonname.
+ */
+struct ares_addrinfo_node {
+  int                        ai_ttl;
+  int                        ai_flags;
+  int                        ai_family;
+  int                        ai_socktype;
+  int                        ai_protocol;
+  ares_socklen_t             ai_addrlen;
+  struct sockaddr           *ai_addr;
+  struct ares_addrinfo_node *ai_next;
+};
+
+/*
+ * alias - label of the resource record.
+ * name - value (canonical name) of the resource record.
+ * See RFC2181 10.1.1. CNAME terminology.
+ */
+struct ares_addrinfo_cname {
+  int                         ttl;
+  char                       *alias;
+  char                       *name;
+  struct ares_addrinfo_cname *next;
+};
+
+struct ares_addrinfo {
+  struct ares_addrinfo_cname *cnames;
+  struct ares_addrinfo_node  *nodes;
+  char                       *name;
+};
+
+struct ares_addrinfo_hints {
+  int ai_flags;
+  int ai_family;
+  int ai_socktype;
+  int ai_protocol;
+};
+
+/*
+** Parse the buffer, starting at *abuf and of length alen bytes, previously
+** obtained from an ares_search call.  Put the results in *host, if nonnull.
+** Also, if addrttls is nonnull, put up to *naddrttls IPv4 addresses along with
+** their TTLs in that array, and set *naddrttls to the number of addresses
+** so written.
+*/
+
+CARES_EXTERN int ares_parse_a_reply(const unsigned char *abuf,
+                                    int alen,
+                                    struct hostent **host,
+                                    struct ares_addrttl *addrttls,
+                                    int *naddrttls);
+
+CARES_EXTERN int ares_parse_aaaa_reply(const unsigned char *abuf,
+                                       int alen,
+                                       struct hostent **host,
+                                       struct ares_addr6ttl *addrttls,
+                                       int *naddrttls);
+
+CARES_EXTERN int ares_parse_caa_reply(const unsigned char* abuf,
+				      int alen,
+				      struct ares_caa_reply** caa_out);
+
+CARES_EXTERN int ares_parse_ptr_reply(const unsigned char *abuf,
+                                      int alen,
+                                      const void *addr,
+                                      int addrlen,
+                                      int family,
+                                      struct hostent **host);
+
+CARES_EXTERN int ares_parse_ns_reply(const unsigned char *abuf,
+                                     int alen,
+                                     struct hostent **host);
+
+CARES_EXTERN int ares_parse_srv_reply(const unsigned char* abuf,
+                                      int alen,
+                                      struct ares_srv_reply** srv_out);
+
+CARES_EXTERN int ares_parse_mx_reply(const unsigned char* abuf,
+                                      int alen,
+                                      struct ares_mx_reply** mx_out);
+
+CARES_EXTERN int ares_parse_txt_reply(const unsigned char* abuf,
+                                      int alen,
+                                      struct ares_txt_reply** txt_out);
+
+CARES_EXTERN int ares_parse_txt_reply_ext(const unsigned char* abuf,
+                                          int alen,
+                                          struct ares_txt_ext** txt_out);
+
+CARES_EXTERN int ares_parse_naptr_reply(const unsigned char* abuf,
+                                        int alen,
+                                        struct ares_naptr_reply** naptr_out);
+
+CARES_EXTERN int ares_parse_soa_reply(const unsigned char* abuf,
+				      int alen,
+				      struct ares_soa_reply** soa_out);
+
+CARES_EXTERN int ares_parse_uri_reply(const unsigned char* abuf,
+                                      int alen,
+                                      struct ares_uri_reply** uri_out);
+
+CARES_EXTERN void ares_free_string(void *str);
+
+CARES_EXTERN void ares_free_hostent(struct hostent *host);
+
+CARES_EXTERN void ares_free_data(void *dataptr);
+
+CARES_EXTERN const char *ares_strerror(int code);
+
+struct ares_addr_node {
+  struct ares_addr_node *next;
+  int family;
+  union {
+    struct in_addr       addr4;
+    struct ares_in6_addr addr6;
+  } addr;
+};
+
+struct ares_addr_port_node {
+  struct ares_addr_port_node *next;
+  int family;
+  union {
+    struct in_addr       addr4;
+    struct ares_in6_addr addr6;
+  } addr;
+  int udp_port;
+  int tcp_port;
+};
+
+CARES_EXTERN int ares_set_servers(ares_channel channel,
+                                  struct ares_addr_node *servers);
+CARES_EXTERN int ares_set_servers_ports(ares_channel channel,
+                                        struct ares_addr_port_node *servers);
+
+/* Incomming string format: host[:port][,host[:port]]... */
+CARES_EXTERN int ares_set_servers_csv(ares_channel channel,
+                                      const char* servers);
+CARES_EXTERN int ares_set_servers_ports_csv(ares_channel channel,
+                                            const char* servers);
+
+CARES_EXTERN int ares_get_servers(ares_channel channel,
+                                  struct ares_addr_node **servers);
+CARES_EXTERN int ares_get_servers_ports(ares_channel channel,
+                                        struct ares_addr_port_node **servers);
+
+CARES_EXTERN const char *ares_inet_ntop(int af, const void *src, char *dst,
+                                        ares_socklen_t size);
+
+CARES_EXTERN int ares_inet_pton(int af, const char *src, void *dst);
+
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* ARES__H */
diff --git a/CAPI/cpp/grpc/include/ares_build.h b/CAPI/cpp/grpc/include/ares_build.h
new file mode 100644
index 0000000..c3b9a31
--- /dev/null
+++ b/CAPI/cpp/grpc/include/ares_build.h
@@ -0,0 +1,43 @@
+#ifndef __CARES_BUILD_H
+#define __CARES_BUILD_H
+
+#define CARES_TYPEOF_ARES_SOCKLEN_T socklen_t
+#define CARES_TYPEOF_ARES_SSIZE_T __int64
+
+/* Prefix names with CARES_ to make sure they don't conflict with other config.h
+ * files.  We need to include some dependent headers that may be system specific
+ * for C-Ares */
+#define CARES_HAVE_SYS_TYPES_H
+/* #undef CARES_HAVE_SYS_SOCKET_H */
+#define CARES_HAVE_WINDOWS_H
+#define CARES_HAVE_WS2TCPIP_H
+#define CARES_HAVE_WINSOCK2_H
+#define CARES_HAVE_WINDOWS_H
+/* #undef CARES_HAVE_ARPA_NAMESER_H */
+/* #undef CARES_HAVE_ARPA_NAMESER_COMPAT_H */
+
+#ifdef CARES_HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+#ifdef CARES_HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+#ifdef CARES_HAVE_WINSOCK2_H
+#  include <winsock2.h>
+#endif
+
+#ifdef CARES_HAVE_WS2TCPIP_H
+#  include <ws2tcpip.h>
+#endif
+
+#ifdef CARES_HAVE_WINDOWS_H
+#  include <windows.h>
+#endif
+
+
+typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;
+typedef CARES_TYPEOF_ARES_SSIZE_T ares_ssize_t;
+
+#endif /* __CARES_BUILD_H */
diff --git a/CAPI/cpp/grpc/include/ares_dns.h b/CAPI/cpp/grpc/include/ares_dns.h
new file mode 100644
index 0000000..bc8aa7b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/ares_dns.h
@@ -0,0 +1,112 @@
+#ifndef HEADER_CARES_DNS_H
+#define HEADER_CARES_DNS_H
+
+/* Copyright 1998, 2011 by the Massachusetts Institute of Technology.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+/*
+ * NOTE TO INTEGRATORS:
+ *
+ * This header is made public due to legacy projects relying on it.
+ * Please do not use the macros within this header, or include this
+ * header in your project as it may be removed in the future.
+ */
+
+
+/*
+ * Macro DNS__16BIT reads a network short (16 bit) given in network
+ * byte order, and returns its value as an unsigned short.
+ */
+#define DNS__16BIT(p)  ((unsigned short)((unsigned int) 0xffff & \
+                         (((unsigned int)((unsigned char)(p)[0]) << 8U) | \
+                          ((unsigned int)((unsigned char)(p)[1])))))
+
+/*
+ * Macro DNS__32BIT reads a network long (32 bit) given in network
+ * byte order, and returns its value as an unsigned int.
+ */
+#define DNS__32BIT(p)  ((unsigned int) \
+                         (((unsigned int)((unsigned char)(p)[0]) << 24U) | \
+                          ((unsigned int)((unsigned char)(p)[1]) << 16U) | \
+                          ((unsigned int)((unsigned char)(p)[2]) <<  8U) | \
+                          ((unsigned int)((unsigned char)(p)[3]))))
+
+#define DNS__SET16BIT(p, v)  (((p)[0] = (unsigned char)(((v) >> 8) & 0xff)), \
+                              ((p)[1] = (unsigned char)((v) & 0xff)))
+#define DNS__SET32BIT(p, v)  (((p)[0] = (unsigned char)(((v) >> 24) & 0xff)), \
+                              ((p)[1] = (unsigned char)(((v) >> 16) & 0xff)), \
+                              ((p)[2] = (unsigned char)(((v) >> 8) & 0xff)), \
+                              ((p)[3] = (unsigned char)((v) & 0xff)))
+
+#if 0
+/* we cannot use this approach on systems where we can't access 16/32 bit
+   data on un-aligned addresses */
+#define DNS__16BIT(p)                   ntohs(*(unsigned short*)(p))
+#define DNS__32BIT(p)                   ntohl(*(unsigned long*)(p))
+#define DNS__SET16BIT(p, v)             *(unsigned short*)(p) = htons(v)
+#define DNS__SET32BIT(p, v)             *(unsigned long*)(p) = htonl(v)
+#endif
+
+/* Macros for parsing a DNS header */
+#define DNS_HEADER_QID(h)               DNS__16BIT(h)
+#define DNS_HEADER_QR(h)                (((h)[2] >> 7) & 0x1)
+#define DNS_HEADER_OPCODE(h)            (((h)[2] >> 3) & 0xf)
+#define DNS_HEADER_AA(h)                (((h)[2] >> 2) & 0x1)
+#define DNS_HEADER_TC(h)                (((h)[2] >> 1) & 0x1)
+#define DNS_HEADER_RD(h)                ((h)[2] & 0x1)
+#define DNS_HEADER_RA(h)                (((h)[3] >> 7) & 0x1)
+#define DNS_HEADER_Z(h)                 (((h)[3] >> 4) & 0x7)
+#define DNS_HEADER_RCODE(h)             ((h)[3] & 0xf)
+#define DNS_HEADER_QDCOUNT(h)           DNS__16BIT((h) + 4)
+#define DNS_HEADER_ANCOUNT(h)           DNS__16BIT((h) + 6)
+#define DNS_HEADER_NSCOUNT(h)           DNS__16BIT((h) + 8)
+#define DNS_HEADER_ARCOUNT(h)           DNS__16BIT((h) + 10)
+
+/* Macros for constructing a DNS header */
+#define DNS_HEADER_SET_QID(h, v)      DNS__SET16BIT(h, v)
+#define DNS_HEADER_SET_QR(h, v)       ((h)[2] |= (unsigned char)(((v) & 0x1) << 7))
+#define DNS_HEADER_SET_OPCODE(h, v)   ((h)[2] |= (unsigned char)(((v) & 0xf) << 3))
+#define DNS_HEADER_SET_AA(h, v)       ((h)[2] |= (unsigned char)(((v) & 0x1) << 2))
+#define DNS_HEADER_SET_TC(h, v)       ((h)[2] |= (unsigned char)(((v) & 0x1) << 1))
+#define DNS_HEADER_SET_RD(h, v)       ((h)[2] |= (unsigned char)((v) & 0x1))
+#define DNS_HEADER_SET_RA(h, v)       ((h)[3] |= (unsigned char)(((v) & 0x1) << 7))
+#define DNS_HEADER_SET_Z(h, v)        ((h)[3] |= (unsigned char)(((v) & 0x7) << 4))
+#define DNS_HEADER_SET_RCODE(h, v)    ((h)[3] |= (unsigned char)((v) & 0xf))
+#define DNS_HEADER_SET_QDCOUNT(h, v)  DNS__SET16BIT((h) + 4, v)
+#define DNS_HEADER_SET_ANCOUNT(h, v)  DNS__SET16BIT((h) + 6, v)
+#define DNS_HEADER_SET_NSCOUNT(h, v)  DNS__SET16BIT((h) + 8, v)
+#define DNS_HEADER_SET_ARCOUNT(h, v)  DNS__SET16BIT((h) + 10, v)
+
+/* Macros for parsing the fixed part of a DNS question */
+#define DNS_QUESTION_TYPE(q)            DNS__16BIT(q)
+#define DNS_QUESTION_CLASS(q)           DNS__16BIT((q) + 2)
+
+/* Macros for constructing the fixed part of a DNS question */
+#define DNS_QUESTION_SET_TYPE(q, v)     DNS__SET16BIT(q, v)
+#define DNS_QUESTION_SET_CLASS(q, v)    DNS__SET16BIT((q) + 2, v)
+
+/* Macros for parsing the fixed part of a DNS resource record */
+#define DNS_RR_TYPE(r)                  DNS__16BIT(r)
+#define DNS_RR_CLASS(r)                 DNS__16BIT((r) + 2)
+#define DNS_RR_TTL(r)                   DNS__32BIT((r) + 4)
+#define DNS_RR_LEN(r)                   DNS__16BIT((r) + 8)
+
+/* Macros for constructing the fixed part of a DNS resource record */
+#define DNS_RR_SET_TYPE(r, v)           DNS__SET16BIT(r, v)
+#define DNS_RR_SET_CLASS(r, v)          DNS__SET16BIT((r) + 2, v)
+#define DNS_RR_SET_TTL(r, v)            DNS__SET32BIT((r) + 4, v)
+#define DNS_RR_SET_LEN(r, v)            DNS__SET16BIT((r) + 8, v)
+
+#endif /* HEADER_CARES_DNS_H */
diff --git a/CAPI/cpp/grpc/include/ares_nameser.h b/CAPI/cpp/grpc/include/ares_nameser.h
new file mode 100644
index 0000000..18a9e5a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/ares_nameser.h
@@ -0,0 +1,484 @@
+
+#ifndef ARES_NAMESER_H
+#define ARES_NAMESER_H
+
+#include "ares_build.h"
+
+#ifdef CARES_HAVE_ARPA_NAMESER_H
+#  include <arpa/nameser.h>
+#endif
+#ifdef CARES_HAVE_ARPA_NAMESER_COMPAT_H
+#  include <arpa/nameser_compat.h>
+#endif
+
+/* ============================================================================
+ * arpa/nameser.h may or may not provide ALL of the below defines, so check
+ * each one individually and set if not
+ * ============================================================================
+ */
+
+#ifndef NS_PACKETSZ
+#  define NS_PACKETSZ     512   /* maximum packet size */
+#endif
+
+#ifndef NS_MAXDNAME
+#  define NS_MAXDNAME     256   /* maximum domain name */
+#endif
+
+#ifndef NS_MAXCDNAME
+#  define NS_MAXCDNAME    255   /* maximum compressed domain name */
+#endif
+
+#ifndef NS_MAXLABEL
+#  define NS_MAXLABEL     63
+#endif
+
+#ifndef NS_HFIXEDSZ
+#  define NS_HFIXEDSZ     12    /* #/bytes of fixed data in header */
+#endif
+
+#ifndef NS_QFIXEDSZ
+#  define NS_QFIXEDSZ     4     /* #/bytes of fixed data in query */
+#endif
+
+#ifndef NS_RRFIXEDSZ
+#  define NS_RRFIXEDSZ    10    /* #/bytes of fixed data in r record */
+#endif
+
+#ifndef NS_INT16SZ
+#  define NS_INT16SZ      2
+#endif
+
+#ifndef NS_INADDRSZ
+#  define NS_INADDRSZ     4
+#endif
+
+#ifndef NS_IN6ADDRSZ
+#  define NS_IN6ADDRSZ    16
+#endif
+
+#ifndef NS_CMPRSFLGS
+#  define NS_CMPRSFLGS    0xc0  /* Flag bits indicating name compression. */
+#endif
+
+#ifndef NS_DEFAULTPORT
+#  define NS_DEFAULTPORT  53    /* For both TCP and UDP. */
+#endif
+
+/* ============================================================================
+ * arpa/nameser.h should provide these enumerations always, so if not found,
+ * provide them
+ * ============================================================================
+ */
+#ifndef CARES_HAVE_ARPA_NAMESER_H
+
+typedef enum __ns_class {
+    ns_c_invalid = 0,       /* Cookie. */
+    ns_c_in = 1,            /* Internet. */
+    ns_c_2 = 2,             /* unallocated/unsupported. */
+    ns_c_chaos = 3,         /* MIT Chaos-net. */
+    ns_c_hs = 4,            /* MIT Hesiod. */
+    /* Query class values which do not appear in resource records */
+    ns_c_none = 254,        /* for prereq. sections in update requests */
+    ns_c_any = 255,         /* Wildcard match. */
+    ns_c_max = 65536
+} ns_class;
+
+typedef enum __ns_type {
+    ns_t_invalid = 0,       /* Cookie. */
+    ns_t_a = 1,             /* Host address. */
+    ns_t_ns = 2,            /* Authoritative server. */
+    ns_t_md = 3,            /* Mail destination. */
+    ns_t_mf = 4,            /* Mail forwarder. */
+    ns_t_cname = 5,         /* Canonical name. */
+    ns_t_soa = 6,           /* Start of authority zone. */
+    ns_t_mb = 7,            /* Mailbox domain name. */
+    ns_t_mg = 8,            /* Mail group member. */
+    ns_t_mr = 9,            /* Mail rename name. */
+    ns_t_null = 10,         /* Null resource record. */
+    ns_t_wks = 11,          /* Well known service. */
+    ns_t_ptr = 12,          /* Domain name pointer. */
+    ns_t_hinfo = 13,        /* Host information. */
+    ns_t_minfo = 14,        /* Mailbox information. */
+    ns_t_mx = 15,           /* Mail routing information. */
+    ns_t_txt = 16,          /* Text strings. */
+    ns_t_rp = 17,           /* Responsible person. */
+    ns_t_afsdb = 18,        /* AFS cell database. */
+    ns_t_x25 = 19,          /* X_25 calling address. */
+    ns_t_isdn = 20,         /* ISDN calling address. */
+    ns_t_rt = 21,           /* Router. */
+    ns_t_nsap = 22,         /* NSAP address. */
+    ns_t_nsap_ptr = 23,     /* Reverse NSAP lookup (deprecated). */
+    ns_t_sig = 24,          /* Security signature. */
+    ns_t_key = 25,          /* Security key. */
+    ns_t_px = 26,           /* X.400 mail mapping. */
+    ns_t_gpos = 27,         /* Geographical position (withdrawn). */
+    ns_t_aaaa = 28,         /* Ip6 Address. */
+    ns_t_loc = 29,          /* Location Information. */
+    ns_t_nxt = 30,          /* Next domain (security). */
+    ns_t_eid = 31,          /* Endpoint identifier. */
+    ns_t_nimloc = 32,       /* Nimrod Locator. */
+    ns_t_srv = 33,          /* Server Selection. */
+    ns_t_atma = 34,         /* ATM Address */
+    ns_t_naptr = 35,        /* Naming Authority PoinTeR */
+    ns_t_kx = 36,           /* Key Exchange */
+    ns_t_cert = 37,         /* Certification record */
+    ns_t_a6 = 38,           /* IPv6 address (deprecates AAAA) */
+    ns_t_dname = 39,        /* Non-terminal DNAME (for IPv6) */
+    ns_t_sink = 40,         /* Kitchen sink (experimentatl) */
+    ns_t_opt = 41,          /* EDNS0 option (meta-RR) */
+    ns_t_apl = 42,          /* Address prefix list (RFC3123) */
+    ns_t_ds = 43,           /* Delegation Signer (RFC4034) */
+    ns_t_sshfp = 44,        /* SSH Key Fingerprint (RFC4255) */
+    ns_t_rrsig = 46,        /* Resource Record Signature (RFC4034) */
+    ns_t_nsec = 47,         /* Next Secure (RFC4034) */
+    ns_t_dnskey = 48,       /* DNS Public Key (RFC4034) */
+    ns_t_tkey = 249,        /* Transaction key */
+    ns_t_tsig = 250,        /* Transaction signature. */
+    ns_t_ixfr = 251,        /* Incremental zone transfer. */
+    ns_t_axfr = 252,        /* Transfer zone of authority. */
+    ns_t_mailb = 253,       /* Transfer mailbox records. */
+    ns_t_maila = 254,       /* Transfer mail agent records. */
+    ns_t_any = 255,         /* Wildcard match. */
+    ns_t_uri = 256,         /* Uniform Resource Identifier (RFC7553) */
+    ns_t_caa = 257,         /* Certification Authority Authorization. */
+    ns_t_max = 65536
+} ns_type;
+
+typedef enum __ns_opcode {
+    ns_o_query = 0,         /* Standard query. */
+    ns_o_iquery = 1,        /* Inverse query (deprecated/unsupported). */
+    ns_o_status = 2,        /* Name server status query (unsupported). */
+                                /* Opcode 3 is undefined/reserved. */
+    ns_o_notify = 4,        /* Zone change notification. */
+    ns_o_update = 5,        /* Zone update message. */
+    ns_o_max = 6
+} ns_opcode;
+
+typedef enum __ns_rcode {
+    ns_r_noerror = 0,       /* No error occurred. */
+    ns_r_formerr = 1,       /* Format error. */
+    ns_r_servfail = 2,      /* Server failure. */
+    ns_r_nxdomain = 3,      /* Name error. */
+    ns_r_notimpl = 4,       /* Unimplemented. */
+    ns_r_refused = 5,       /* Operation refused. */
+    /* these are for BIND_UPDATE */
+    ns_r_yxdomain = 6,      /* Name exists */
+    ns_r_yxrrset = 7,       /* RRset exists */
+    ns_r_nxrrset = 8,       /* RRset does not exist */
+    ns_r_notauth = 9,       /* Not authoritative for zone */
+    ns_r_notzone = 10,      /* Zone of record different from zone section */
+    ns_r_max = 11,
+    /* The following are TSIG extended errors */
+    ns_r_badsig = 16,
+    ns_r_badkey = 17,
+    ns_r_badtime = 18
+} ns_rcode;
+
+#endif /* CARES_HAVE_ARPA_NAMESER_H */
+
+
+/* ============================================================================
+ * arpa/nameser_compat.h typically sets these.  However on some systems
+ * arpa/nameser.h does, but may not set all of them.  Lets conditionally
+ * define each
+ * ============================================================================
+ */
+
+#ifndef PACKETSZ
+#  define PACKETSZ         NS_PACKETSZ
+#endif
+
+#ifndef MAXDNAME
+#  define MAXDNAME         NS_MAXDNAME
+#endif
+
+#ifndef MAXCDNAME
+#  define MAXCDNAME        NS_MAXCDNAME
+#endif
+
+#ifndef MAXLABEL
+#  define MAXLABEL         NS_MAXLABEL
+#endif
+
+#ifndef HFIXEDSZ
+#  define HFIXEDSZ         NS_HFIXEDSZ
+#endif
+
+#ifndef QFIXEDSZ
+#  define QFIXEDSZ         NS_QFIXEDSZ
+#endif
+
+#ifndef RRFIXEDSZ
+#  define RRFIXEDSZ        NS_RRFIXEDSZ
+#endif
+
+#ifndef INDIR_MASK
+#  define INDIR_MASK       NS_CMPRSFLGS
+#endif
+
+#ifndef NAMESERVER_PORT
+#  define NAMESERVER_PORT  NS_DEFAULTPORT
+#endif
+
+
+/* opcodes */
+#ifndef O_QUERY
+#  define O_QUERY 0  /* ns_o_query */
+#endif
+#ifndef O_IQUERY
+#  define O_IQUERY 1 /* ns_o_iquery */
+#endif
+#ifndef O_STATUS
+#  define O_STATUS 2 /* ns_o_status */
+#endif
+#ifndef O_NOTIFY
+#  define O_NOTIFY 4 /* ns_o_notify */
+#endif
+#ifndef O_UPDATE
+#  define O_UPDATE 5 /* ns_o_update */
+#endif
+
+
+/* response codes */
+#ifndef SERVFAIL
+#  define SERVFAIL        ns_r_servfail
+#endif
+#ifndef NOTIMP
+#  define NOTIMP          ns_r_notimpl
+#endif
+#ifndef REFUSED
+#  define REFUSED         ns_r_refused
+#endif
+#if defined(_WIN32) && !defined(HAVE_ARPA_NAMESER_COMPAT_H) && defined(NOERROR)
+#  undef NOERROR /* it seems this is already defined in winerror.h */
+#endif
+#ifndef NOERROR
+#  define NOERROR         ns_r_noerror
+#endif
+#ifndef FORMERR
+#  define FORMERR         ns_r_formerr
+#endif
+#ifndef NXDOMAIN
+#  define NXDOMAIN        ns_r_nxdomain
+#endif
+/* Non-standard response codes, use numeric values */
+#ifndef YXDOMAIN
+#  define YXDOMAIN        6 /* ns_r_yxdomain */
+#endif
+#ifndef YXRRSET
+#  define YXRRSET         7 /* ns_r_yxrrset */
+#endif
+#ifndef NXRRSET
+#  define NXRRSET         8 /* ns_r_nxrrset */
+#endif
+#ifndef NOTAUTH
+#  define NOTAUTH         9 /* ns_r_notauth */
+#endif
+#ifndef NOTZONE
+#  define NOTZONE         10 /* ns_r_notzone */
+#endif
+#ifndef TSIG_BADSIG
+#  define TSIG_BADSIG     16 /* ns_r_badsig */
+#endif
+#ifndef TSIG_BADKEY
+#  define TSIG_BADKEY     17 /* ns_r_badkey */
+#endif
+#ifndef TSIG_BADTIME
+#  define TSIG_BADTIME    18 /* ns_r_badtime */
+#endif
+
+
+/* classes */
+#ifndef C_IN
+#  define C_IN            1 /* ns_c_in */
+#endif
+#ifndef C_CHAOS
+#  define C_CHAOS         3 /* ns_c_chaos */
+#endif
+#ifndef C_HS
+#  define C_HS            4 /* ns_c_hs */
+#endif
+#ifndef C_NONE
+#  define C_NONE          254 /* ns_c_none */
+#endif
+#ifndef C_ANY
+#  define C_ANY           255 /*  ns_c_any */
+#endif
+
+
+/* types */
+#ifndef T_A
+#  define T_A             1   /* ns_t_a */
+#endif
+#ifndef T_NS
+#  define T_NS            2   /* ns_t_ns */
+#endif
+#ifndef T_MD
+#  define T_MD            3   /* ns_t_md */
+#endif
+#ifndef T_MF
+#  define T_MF            4   /* ns_t_mf */
+#endif
+#ifndef T_CNAME
+#  define T_CNAME         5   /* ns_t_cname */
+#endif
+#ifndef T_SOA
+#  define T_SOA           6   /* ns_t_soa */
+#endif
+#ifndef T_MB
+#  define T_MB            7   /* ns_t_mb */
+#endif
+#ifndef T_MG
+#  define T_MG            8   /* ns_t_mg */
+#endif
+#ifndef T_MR
+#  define T_MR            9   /* ns_t_mr */
+#endif
+#ifndef T_NULL
+#  define T_NULL          10  /* ns_t_null */
+#endif
+#ifndef T_WKS
+#  define T_WKS           11  /* ns_t_wks */
+#endif
+#ifndef T_PTR
+#  define T_PTR           12  /* ns_t_ptr */
+#endif
+#ifndef T_HINFO
+#  define T_HINFO         13  /* ns_t_hinfo */
+#endif
+#ifndef T_MINFO
+#  define T_MINFO         14  /* ns_t_minfo */
+#endif
+#ifndef T_MX
+#  define T_MX            15  /* ns_t_mx */
+#endif
+#ifndef T_TXT
+#  define T_TXT           16  /* ns_t_txt */
+#endif
+#ifndef T_RP
+#  define T_RP            17  /* ns_t_rp */
+#endif
+#ifndef T_AFSDB
+#  define T_AFSDB         18  /* ns_t_afsdb */
+#endif
+#ifndef T_X25
+#  define T_X25           19  /* ns_t_x25 */
+#endif
+#ifndef T_ISDN
+#  define T_ISDN          20  /* ns_t_isdn */
+#endif
+#ifndef T_RT
+#  define T_RT            21  /* ns_t_rt */
+#endif
+#ifndef T_NSAP
+#  define T_NSAP          22  /* ns_t_nsap */
+#endif
+#ifndef T_NSAP_PTR
+#  define T_NSAP_PTR      23  /* ns_t_nsap_ptr */
+#endif
+#ifndef T_SIG
+#  define T_SIG           24  /* ns_t_sig */
+#endif
+#ifndef T_KEY
+#  define T_KEY           25  /* ns_t_key */
+#endif
+#ifndef T_PX
+#  define T_PX            26  /* ns_t_px */
+#endif
+#ifndef T_GPOS
+#  define T_GPOS          27  /* ns_t_gpos */
+#endif
+#ifndef T_AAAA
+#  define T_AAAA          28  /* ns_t_aaaa */
+#endif
+#ifndef T_LOC
+#  define T_LOC           29  /* ns_t_loc */
+#endif
+#ifndef T_NXT
+#  define T_NXT           30  /* ns_t_nxt */
+#endif
+#ifndef T_EID
+#  define T_EID           31  /* ns_t_eid */
+#endif
+#ifndef T_NIMLOC
+#  define T_NIMLOC        32  /* ns_t_nimloc */
+#endif
+#ifndef T_SRV
+#  define T_SRV           33  /* ns_t_srv */
+#endif
+#ifndef T_ATMA
+#  define T_ATMA          34  /* ns_t_atma */
+#endif
+#ifndef T_NAPTR
+#  define T_NAPTR         35  /* ns_t_naptr */
+#endif
+#ifndef T_KX
+#  define T_KX            36  /* ns_t_kx */
+#endif
+#ifndef T_CERT
+#  define T_CERT          37  /* ns_t_cert */
+#endif
+#ifndef T_A6
+#  define T_A6            38  /* ns_t_a6 */
+#endif
+#ifndef T_DNAME
+#  define T_DNAME         39  /* ns_t_dname */
+#endif
+#ifndef T_SINK
+#  define T_SINK          40  /* ns_t_sink */
+#endif
+#ifndef T_OPT
+#  define T_OPT           41  /* ns_t_opt */
+#endif
+#ifndef T_APL
+#  define T_APL           42  /* ns_t_apl */
+#endif
+#ifndef T_DS
+#  define T_DS            43  /* ns_t_ds */
+#endif
+#ifndef T_SSHFP
+#  define T_SSHFP         44  /* ns_t_sshfp */
+#endif
+#ifndef T_RRSIG
+#  define T_RRSIG         46  /* ns_t_rrsig */
+#endif
+#ifndef T_NSEC
+#  define T_NSEC          47  /* ns_t_nsec */
+#endif
+#ifndef T_DNSKEY
+#  define T_DNSKEY        48  /* ns_t_dnskey */
+#endif
+#ifndef T_TKEY
+#  define T_TKEY          249 /* ns_t_tkey */
+#endif
+#ifndef T_TSIG
+#  define T_TSIG          250 /* ns_t_tsig */
+#endif
+#ifndef T_IXFR
+#  define T_IXFR          251 /* ns_t_ixfr */
+#endif
+#ifndef T_AXFR
+#  define T_AXFR          252 /* ns_t_axfr */
+#endif
+#ifndef T_MAILB
+#  define T_MAILB         253 /* ns_t_mailb */
+#endif
+#ifndef T_MAILA
+#  define T_MAILA         254 /* ns_t_maila */
+#endif
+#ifndef T_ANY
+#  define T_ANY           255 /* ns_t_any */
+#endif
+#ifndef T_URI
+#  define T_URI          256 /* ns_t_uri */
+#endif
+#ifndef T_CAA
+#  define T_CAA           257 /* ns_t_caa */
+#endif
+#ifndef T_MAX
+#  define T_MAX         65536 /* ns_t_max */
+#endif
+
+
+#endif /* ARES_NAMESER_H */
diff --git a/CAPI/cpp/grpc/include/ares_rules.h b/CAPI/cpp/grpc/include/ares_rules.h
new file mode 100644
index 0000000..1706ab7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/ares_rules.h
@@ -0,0 +1,125 @@
+#ifndef __CARES_RULES_H
+#define __CARES_RULES_H
+
+
+/* Copyright (C) 2009 - 2021 by Daniel Stenberg et al
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+/* ================================================================ */
+/*                    COMPILE TIME SANITY CHECKS                    */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * All checks done in this file are intentionally placed in a public
+ * header file which is pulled by ares.h when an application is
+ * being built using an already built c-ares library. Additionally
+ * this file is also included and used when building the library.
+ *
+ * If compilation fails on this file it is certainly sure that the
+ * problem is elsewhere. It could be a problem in the ares_build.h
+ * header file, or simply that you are using different compilation
+ * settings than those used to build the library.
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * c-ares library user nor by the c-ares library builder.
+ *
+ * Do not deactivate any check, these are done to make sure that the
+ * library is properly built and used.
+ *
+ * You can find further help on the c-ares development mailing list:
+ * http://lists.haxx.se/listinfo/c-ares/
+ *
+ * NOTE 2
+ * ------
+ *
+ * Some of the following compile time checks are based on the fact
+ * that the dimension of a constant array can not be a negative one.
+ * In this way if the compile time verification fails, the compilation
+ * will fail issuing an error. The error description wording is compiler
+ * dependent but it will be quite similar to one of the following:
+ *
+ *   "negative subscript or subscript is too large"
+ *   "array must have at least one element"
+ *   "-1 is an illegal array size"
+ *   "size of array is negative"
+ *
+ * If you are building an application which tries to use an already
+ * built c-ares library and you are getting this kind of errors on
+ * this file, it is a clear indication that there is a mismatch between
+ * how the library was built and how you are trying to use it for your
+ * application. Your already compiled or binary library provider is the
+ * only one who can give you the details you need to properly use it.
+ */
+
+/*
+ * Verify that some macros are actually defined.
+ */
+
+#ifndef CARES_TYPEOF_ARES_SOCKLEN_T
+#  error "CARES_TYPEOF_ARES_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CARES_TYPEOF_ARES_SOCKLEN_T_is_missing
+#endif
+
+/*
+ * Macros private to this header file.
+ */
+
+#define CareschkszEQ(t, s) sizeof(t) == s ? 1 : -1
+
+#define CareschkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1
+
+/*
+ * Verify that the size previously defined and expected for
+ * ares_socklen_t is actually the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __cares_rule_02__
+    [CareschkszEQ(ares_socklen_t, sizeof(CARES_TYPEOF_ARES_SOCKLEN_T))];
+
+/*
+ * Verify at compile time that the size of ares_socklen_t as reported
+ * by sizeof() is greater or equal than the one reported for int for
+ * the current compilation.
+ */
+
+typedef char
+  __cares_rule_03__
+    [CareschkszGE(ares_socklen_t, int)];
+
+/* ================================================================ */
+/*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */
+/* ================================================================ */
+
+/*
+ * Get rid of macros private to this header file.
+ */
+
+#undef CareschkszEQ
+#undef CareschkszGE
+
+/*
+ * Get rid of macros not intended to exist beyond this point.
+ */
+
+#undef CARES_PULL_WS2TCPIP_H
+#undef CARES_PULL_SYS_TYPES_H
+#undef CARES_PULL_SYS_SOCKET_H
+
+#undef CARES_TYPEOF_ARES_SOCKLEN_T
+
+#endif /* __CARES_RULES_H */
diff --git a/CAPI/cpp/grpc/include/ares_version.h b/CAPI/cpp/grpc/include/ares_version.h
new file mode 100644
index 0000000..22c6f62
--- /dev/null
+++ b/CAPI/cpp/grpc/include/ares_version.h
@@ -0,0 +1,24 @@
+
+#ifndef ARES__VERSION_H
+#define ARES__VERSION_H
+
+/* This is the global package copyright */
+#define ARES_COPYRIGHT "2004 - 2021 Daniel Stenberg, <daniel@haxx.se>."
+
+#define ARES_VERSION_MAJOR 1
+#define ARES_VERSION_MINOR 18
+#define ARES_VERSION_PATCH 1
+#define ARES_VERSION ((ARES_VERSION_MAJOR<<16)|\
+                       (ARES_VERSION_MINOR<<8)|\
+                       (ARES_VERSION_PATCH))
+#define ARES_VERSION_STR "1.18.1"
+
+#if (ARES_VERSION >= 0x010700)
+#  define CARES_HAVE_ARES_LIBRARY_INIT 1
+#  define CARES_HAVE_ARES_LIBRARY_CLEANUP 1
+#else
+#  undef CARES_HAVE_ARES_LIBRARY_INIT
+#  undef CARES_HAVE_ARES_LIBRARY_CLEANUP
+#endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/google/protobuf/any.h b/CAPI/cpp/grpc/include/google/protobuf/any.h
new file mode 100644
index 0000000..92ea2bb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/any.h
@@ -0,0 +1,157 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_ANY_H__
+#define GOOGLE_PROTOBUF_ANY_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/message_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class FieldDescriptor;
+class Message;
+
+namespace internal {
+
+extern const char kAnyFullTypeName[];          // "google.protobuf.Any".
+extern const char kTypeGoogleApisComPrefix[];  // "type.googleapis.com/".
+extern const char kTypeGoogleProdComPrefix[];  // "type.googleprod.com/".
+
+std::string GetTypeUrl(StringPiece message_name,
+                       StringPiece type_url_prefix);
+
+// Helper class used to implement google::protobuf::Any.
+class PROTOBUF_EXPORT AnyMetadata {
+  typedef ArenaStringPtr UrlType;
+  typedef ArenaStringPtr ValueType;
+ public:
+  // AnyMetadata does not take ownership of "type_url" and "value".
+  constexpr AnyMetadata(UrlType* type_url, ValueType* value)
+      : type_url_(type_url), value_(value) {}
+
+  // Packs a message using the default type URL prefix: "type.googleapis.com".
+  // The resulted type URL will be "type.googleapis.com/<message_full_name>".
+  // Returns false if serializing the message failed.
+  template <typename T>
+  bool PackFrom(Arena* arena, const T& message) {
+    return InternalPackFrom(arena, message, kTypeGoogleApisComPrefix,
+                            T::FullMessageName());
+  }
+
+  bool PackFrom(Arena* arena, const Message& message);
+
+  // Packs a message using the given type URL prefix. The type URL will be
+  // constructed by concatenating the message type's full name to the prefix
+  // with an optional "/" separator if the prefix doesn't already end with "/".
+  // For example, both PackFrom(message, "type.googleapis.com") and
+  // PackFrom(message, "type.googleapis.com/") yield the same result type
+  // URL: "type.googleapis.com/<message_full_name>".
+  // Returns false if serializing the message failed.
+  template <typename T>
+  bool PackFrom(Arena* arena, const T& message,
+                StringPiece type_url_prefix) {
+    return InternalPackFrom(arena, message, type_url_prefix,
+                            T::FullMessageName());
+  }
+
+  bool PackFrom(Arena* arena, const Message& message,
+                StringPiece type_url_prefix);
+
+  // Unpacks the payload into the given message. Returns false if the message's
+  // type doesn't match the type specified in the type URL (i.e., the full
+  // name after the last "/" of the type URL doesn't match the message's actual
+  // full name) or parsing the payload has failed.
+  template <typename T>
+  bool UnpackTo(T* message) const {
+    return InternalUnpackTo(T::FullMessageName(), message);
+  }
+
+  bool UnpackTo(Message* message) const;
+
+  // Checks whether the type specified in the type URL matches the given type.
+  // A type is considered matching if its full name matches the full name after
+  // the last "/" in the type URL.
+  template <typename T>
+  bool Is() const {
+    return InternalIs(T::FullMessageName());
+  }
+
+ private:
+  bool InternalPackFrom(Arena* arena, const MessageLite& message,
+                        StringPiece type_url_prefix,
+                        StringPiece type_name);
+  bool InternalUnpackTo(StringPiece type_name,
+                        MessageLite* message) const;
+  bool InternalIs(StringPiece type_name) const;
+
+  UrlType* type_url_;
+  ValueType* value_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AnyMetadata);
+};
+
+// Get the proto type name from Any::type_url value. For example, passing
+// "type.googleapis.com/rpc.QueryOrigin" will return "rpc.QueryOrigin" in
+// *full_type_name. Returns false if the type_url does not have a "/"
+// in the type url separating the full type name.
+//
+// NOTE: this function is available publicly as a static method on the
+// generated message type: google::protobuf::Any::ParseAnyTypeUrl()
+bool ParseAnyTypeUrl(StringPiece type_url, std::string* full_type_name);
+
+// Get the proto type name and prefix from Any::type_url value. For example,
+// passing "type.googleapis.com/rpc.QueryOrigin" will return
+// "type.googleapis.com/" in *url_prefix and "rpc.QueryOrigin" in
+// *full_type_name. Returns false if the type_url does not have a "/" in the
+// type url separating the full type name.
+bool ParseAnyTypeUrl(StringPiece type_url, std::string* url_prefix,
+                     std::string* full_type_name);
+
+// See if message is of type google.protobuf.Any, if so, return the descriptors
+// for "type_url" and "value" fields.
+bool GetAnyFieldDescriptors(const Message& message,
+                            const FieldDescriptor** type_url_field,
+                            const FieldDescriptor** value_field);
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_ANY_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/any.pb.h b/CAPI/cpp/grpc/include/google/protobuf/any.pb.h
new file mode 100644
index 0000000..ac51c9b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/any.pb.h
@@ -0,0 +1,384 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/any.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fany_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fany_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fany_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fany_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class Any;
+struct AnyDefaultTypeInternal;
+PROTOBUF_EXPORT extern AnyDefaultTypeInternal _Any_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Any* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+// ===================================================================
+
+class PROTOBUF_EXPORT Any final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ {
+ public:
+  inline Any() : Any(nullptr) {}
+  ~Any() override;
+  explicit PROTOBUF_CONSTEXPR Any(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Any(const Any& from);
+  Any(Any&& from) noexcept
+    : Any() {
+    *this = ::std::move(from);
+  }
+
+  inline Any& operator=(const Any& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Any& operator=(Any&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Any& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Any* internal_default_instance() {
+    return reinterpret_cast<const Any*>(
+               &_Any_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  // implements Any -----------------------------------------------
+
+  bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message) {
+    GOOGLE_DCHECK_NE(&message, this);
+    return _impl_._any_metadata_.PackFrom(GetArena(), message);
+  }
+  bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message,
+                ::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix) {
+    GOOGLE_DCHECK_NE(&message, this);
+    return _impl_._any_metadata_.PackFrom(GetArena(), message, type_url_prefix);
+  }
+  bool UnpackTo(::PROTOBUF_NAMESPACE_ID::Message* message) const {
+    return _impl_._any_metadata_.UnpackTo(message);
+  }
+  static bool GetAnyFieldDescriptors(
+      const ::PROTOBUF_NAMESPACE_ID::Message& message,
+      const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** type_url_field,
+      const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** value_field);
+  template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
+  bool PackFrom(const T& message) {
+    return _impl_._any_metadata_.PackFrom<T>(GetArena(), message);
+  }
+  template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
+  bool PackFrom(const T& message,
+                ::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix) {
+    return _impl_._any_metadata_.PackFrom<T>(GetArena(), message, type_url_prefix);}
+  template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
+  bool UnpackTo(T* message) const {
+    return _impl_._any_metadata_.UnpackTo<T>(message);
+  }
+  template<typename T> bool Is() const {
+    return _impl_._any_metadata_.Is<T>();
+  }
+  static bool ParseAnyTypeUrl(::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url,
+                              std::string* full_type_name);
+  friend void swap(Any& a, Any& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Any* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Any* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Any* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Any>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Any& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Any& from) {
+    Any::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Any* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Any";
+  }
+  protected:
+  explicit Any(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeUrlFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // string type_url = 1;
+  void clear_type_url();
+  const std::string& type_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_url();
+  PROTOBUF_NODISCARD std::string* release_type_url();
+  void set_allocated_type_url(std::string* type_url);
+  private:
+  const std::string& _internal_type_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_url(const std::string& value);
+  std::string* _internal_mutable_type_url();
+  public:
+
+  // bytes value = 2;
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Any)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata _any_metadata_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fany_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Any
+
+// string type_url = 1;
+inline void Any::clear_type_url() {
+  _impl_.type_url_.ClearToEmpty();
+}
+inline const std::string& Any::type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Any.type_url)
+  return _internal_type_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Any::set_type_url(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Any.type_url)
+}
+inline std::string* Any::mutable_type_url() {
+  std::string* _s = _internal_mutable_type_url();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Any.type_url)
+  return _s;
+}
+inline const std::string& Any::_internal_type_url() const {
+  return _impl_.type_url_.Get();
+}
+inline void Any::_internal_set_type_url(const std::string& value) {
+  
+  _impl_.type_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Any::_internal_mutable_type_url() {
+  
+  return _impl_.type_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Any::release_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Any.type_url)
+  return _impl_.type_url_.Release();
+}
+inline void Any::set_allocated_type_url(std::string* type_url) {
+  if (type_url != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_url_.SetAllocated(type_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_url_.IsDefault()) {
+    _impl_.type_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.type_url)
+}
+
+// bytes value = 2;
+inline void Any::clear_value() {
+  _impl_.value_.ClearToEmpty();
+}
+inline const std::string& Any::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Any.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Any::set_value(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Any.value)
+}
+inline std::string* Any::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Any.value)
+  return _s;
+}
+inline const std::string& Any::_internal_value() const {
+  return _impl_.value_.Get();
+}
+inline void Any::_internal_set_value(const std::string& value) {
+  
+  _impl_.value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Any::_internal_mutable_value() {
+  
+  return _impl_.value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Any::release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Any.value)
+  return _impl_.value_.Release();
+}
+inline void Any::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.value)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fany_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/any.proto b/CAPI/cpp/grpc/include/google/protobuf/any.proto
new file mode 100644
index 0000000..e2c2042
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/any.proto
@@ -0,0 +1,158 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "google.golang.org/protobuf/types/known/anypb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "AnyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+// Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+// Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := anypb.New(foo)
+//      if err != nil {
+//        ...
+//      }
+//      ...
+//      foo := &pb.Foo{}
+//      if err := any.UnmarshalTo(foo); err != nil {
+//        ...
+//      }
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+//
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+message Any {
+  // A URL/resource name that uniquely identifies the type of the serialized
+  // protocol buffer message. This string must contain at least
+  // one "/" character. The last segment of the URL's path must represent
+  // the fully qualified name of the type (as in
+  // `path/google.protobuf.Duration`). The name should be in a canonical form
+  // (e.g., leading "." is not accepted).
+  //
+  // In practice, teams usually precompile into the binary all types that they
+  // expect it to use in the context of Any. However, for URLs which use the
+  // scheme `http`, `https`, or no scheme, one can optionally set up a type
+  // server that maps type URLs to message definitions as follows:
+  //
+  // * If no scheme is provided, `https` is assumed.
+  // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+  //   value in binary format, or produce an error.
+  // * Applications are allowed to cache lookup results based on the
+  //   URL, or have them precompiled into a binary to avoid any
+  //   lookup. Therefore, binary compatibility needs to be preserved
+  //   on changes to types. (Use versioned type names to manage
+  //   breaking changes.)
+  //
+  // Note: this functionality is not currently available in the official
+  // protobuf release, and it is not used for type URLs beginning with
+  // type.googleapis.com.
+  //
+  // Schemes other than `http`, `https` (or the empty scheme) might be
+  // used with implementation specific semantics.
+  //
+  string type_url = 1;
+
+  // Must be a valid serialized protocol buffer of the above specified type.
+  bytes value = 2;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/api.pb.h b/CAPI/cpp/grpc/include/google/protobuf/api.pb.h
new file mode 100644
index 0000000..348bac8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/api.pb.h
@@ -0,0 +1,1437 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/api.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fapi_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fapi_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/source_context.pb.h>
+#include <google/protobuf/type.pb.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fapi_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fapi_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fapi_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class Api;
+struct ApiDefaultTypeInternal;
+PROTOBUF_EXPORT extern ApiDefaultTypeInternal _Api_default_instance_;
+class Method;
+struct MethodDefaultTypeInternal;
+PROTOBUF_EXPORT extern MethodDefaultTypeInternal _Method_default_instance_;
+class Mixin;
+struct MixinDefaultTypeInternal;
+PROTOBUF_EXPORT extern MixinDefaultTypeInternal _Mixin_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Api* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Api>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Method* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Method>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Mixin* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Mixin>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+// ===================================================================
+
+class PROTOBUF_EXPORT Api final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Api) */ {
+ public:
+  inline Api() : Api(nullptr) {}
+  ~Api() override;
+  explicit PROTOBUF_CONSTEXPR Api(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Api(const Api& from);
+  Api(Api&& from) noexcept
+    : Api() {
+    *this = ::std::move(from);
+  }
+
+  inline Api& operator=(const Api& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Api& operator=(Api&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Api& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Api* internal_default_instance() {
+    return reinterpret_cast<const Api*>(
+               &_Api_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Api& a, Api& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Api* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Api* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Api* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Api>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Api& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Api& from) {
+    Api::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Api* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Api";
+  }
+  protected:
+  explicit Api(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMethodsFieldNumber = 2,
+    kOptionsFieldNumber = 3,
+    kMixinsFieldNumber = 6,
+    kNameFieldNumber = 1,
+    kVersionFieldNumber = 4,
+    kSourceContextFieldNumber = 5,
+    kSyntaxFieldNumber = 7,
+  };
+  // repeated .google.protobuf.Method methods = 2;
+  int methods_size() const;
+  private:
+  int _internal_methods_size() const;
+  public:
+  void clear_methods();
+  ::PROTOBUF_NAMESPACE_ID::Method* mutable_methods(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >*
+      mutable_methods();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Method& _internal_methods(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Method* _internal_add_methods();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Method& methods(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Method* add_methods();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >&
+      methods() const;
+
+  // repeated .google.protobuf.Option options = 3;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+      mutable_options();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+      options() const;
+
+  // repeated .google.protobuf.Mixin mixins = 6;
+  int mixins_size() const;
+  private:
+  int _internal_mixins_size() const;
+  public:
+  void clear_mixins();
+  ::PROTOBUF_NAMESPACE_ID::Mixin* mutable_mixins(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >*
+      mutable_mixins();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Mixin& _internal_mixins(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Mixin* _internal_add_mixins();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Mixin& mixins(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Mixin* add_mixins();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >&
+      mixins() const;
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string version = 4;
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_NODISCARD std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // .google.protobuf.SourceContext source_context = 5;
+  bool has_source_context() const;
+  private:
+  bool _internal_has_source_context() const;
+  public:
+  void clear_source_context();
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
+  void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
+  public:
+  void unsafe_arena_set_allocated_source_context(
+      ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
+
+  // .google.protobuf.Syntax syntax = 7;
+  void clear_syntax();
+  ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
+  void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
+  void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Api)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method > methods_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin > mixins_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
+    int syntax_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Method final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Method) */ {
+ public:
+  inline Method() : Method(nullptr) {}
+  ~Method() override;
+  explicit PROTOBUF_CONSTEXPR Method(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Method(const Method& from);
+  Method(Method&& from) noexcept
+    : Method() {
+    *this = ::std::move(from);
+  }
+
+  inline Method& operator=(const Method& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Method& operator=(Method&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Method& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Method* internal_default_instance() {
+    return reinterpret_cast<const Method*>(
+               &_Method_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(Method& a, Method& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Method* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Method* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Method* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Method>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Method& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Method& from) {
+    Method::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Method* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Method";
+  }
+  protected:
+  explicit Method(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptionsFieldNumber = 6,
+    kNameFieldNumber = 1,
+    kRequestTypeUrlFieldNumber = 2,
+    kResponseTypeUrlFieldNumber = 4,
+    kRequestStreamingFieldNumber = 3,
+    kResponseStreamingFieldNumber = 5,
+    kSyntaxFieldNumber = 7,
+  };
+  // repeated .google.protobuf.Option options = 6;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+      mutable_options();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string request_type_url = 2;
+  void clear_request_type_url();
+  const std::string& request_type_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_type_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_type_url();
+  PROTOBUF_NODISCARD std::string* release_request_type_url();
+  void set_allocated_request_type_url(std::string* request_type_url);
+  private:
+  const std::string& _internal_request_type_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_type_url(const std::string& value);
+  std::string* _internal_mutable_request_type_url();
+  public:
+
+  // string response_type_url = 4;
+  void clear_response_type_url();
+  const std::string& response_type_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_response_type_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_response_type_url();
+  PROTOBUF_NODISCARD std::string* release_response_type_url();
+  void set_allocated_response_type_url(std::string* response_type_url);
+  private:
+  const std::string& _internal_response_type_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_response_type_url(const std::string& value);
+  std::string* _internal_mutable_response_type_url();
+  public:
+
+  // bool request_streaming = 3;
+  void clear_request_streaming();
+  bool request_streaming() const;
+  void set_request_streaming(bool value);
+  private:
+  bool _internal_request_streaming() const;
+  void _internal_set_request_streaming(bool value);
+  public:
+
+  // bool response_streaming = 5;
+  void clear_response_streaming();
+  bool response_streaming() const;
+  void set_response_streaming(bool value);
+  private:
+  bool _internal_response_streaming() const;
+  void _internal_set_response_streaming(bool value);
+  public:
+
+  // .google.protobuf.Syntax syntax = 7;
+  void clear_syntax();
+  ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
+  void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
+  void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Method)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_type_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_type_url_;
+    bool request_streaming_;
+    bool response_streaming_;
+    int syntax_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Mixin final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Mixin) */ {
+ public:
+  inline Mixin() : Mixin(nullptr) {}
+  ~Mixin() override;
+  explicit PROTOBUF_CONSTEXPR Mixin(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Mixin(const Mixin& from);
+  Mixin(Mixin&& from) noexcept
+    : Mixin() {
+    *this = ::std::move(from);
+  }
+
+  inline Mixin& operator=(const Mixin& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Mixin& operator=(Mixin&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Mixin& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Mixin* internal_default_instance() {
+    return reinterpret_cast<const Mixin*>(
+               &_Mixin_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(Mixin& a, Mixin& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Mixin* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Mixin* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Mixin* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Mixin>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Mixin& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Mixin& from) {
+    Mixin::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Mixin* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Mixin";
+  }
+  protected:
+  explicit Mixin(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kRootFieldNumber = 2,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string root = 2;
+  void clear_root();
+  const std::string& root() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_root(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_root();
+  PROTOBUF_NODISCARD std::string* release_root();
+  void set_allocated_root(std::string* root);
+  private:
+  const std::string& _internal_root() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_root(const std::string& value);
+  std::string* _internal_mutable_root();
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Mixin)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Api
+
+// string name = 1;
+inline void Api::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Api::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Api::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.name)
+}
+inline std::string* Api::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.name)
+  return _s;
+}
+inline const std::string& Api::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Api::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Api::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Api::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.name)
+  return _impl_.name_.Release();
+}
+inline void Api::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.name)
+}
+
+// repeated .google.protobuf.Method methods = 2;
+inline int Api::_internal_methods_size() const {
+  return _impl_.methods_.size();
+}
+inline int Api::methods_size() const {
+  return _internal_methods_size();
+}
+inline void Api::clear_methods() {
+  _impl_.methods_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Method* Api::mutable_methods(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.methods)
+  return _impl_.methods_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >*
+Api::mutable_methods() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.methods)
+  return &_impl_.methods_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Method& Api::_internal_methods(int index) const {
+  return _impl_.methods_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Method& Api::methods(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.methods)
+  return _internal_methods(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Method* Api::_internal_add_methods() {
+  return _impl_.methods_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Method* Api::add_methods() {
+  ::PROTOBUF_NAMESPACE_ID::Method* _add = _internal_add_methods();
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.methods)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >&
+Api::methods() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.methods)
+  return _impl_.methods_;
+}
+
+// repeated .google.protobuf.Option options = 3;
+inline int Api::_internal_options_size() const {
+  return _impl_.options_.size();
+}
+inline int Api::options_size() const {
+  return _internal_options_size();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Api::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.options)
+  return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+Api::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.options)
+  return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Api::_internal_options(int index) const {
+  return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Api::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.options)
+  return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Api::_internal_add_options() {
+  return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Api::add_options() {
+  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+Api::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.options)
+  return _impl_.options_;
+}
+
+// string version = 4;
+inline void Api::clear_version() {
+  _impl_.version_.ClearToEmpty();
+}
+inline const std::string& Api::version() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Api::set_version(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.version)
+}
+inline std::string* Api::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.version)
+  return _s;
+}
+inline const std::string& Api::_internal_version() const {
+  return _impl_.version_.Get();
+}
+inline void Api::_internal_set_version(const std::string& value) {
+  
+  _impl_.version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Api::_internal_mutable_version() {
+  
+  return _impl_.version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Api::release_version() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.version)
+  return _impl_.version_.Release();
+}
+inline void Api::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.version_.IsDefault()) {
+    _impl_.version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.version)
+}
+
+// .google.protobuf.SourceContext source_context = 5;
+inline bool Api::_internal_has_source_context() const {
+  return this != internal_default_instance() && _impl_.source_context_ != nullptr;
+}
+inline bool Api::has_source_context() const {
+  return _internal_has_source_context();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Api::_internal_source_context() const {
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(
+      ::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Api::source_context() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.source_context)
+  return _internal_source_context();
+}
+inline void Api::unsafe_arena_set_allocated_source_context(
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+  }
+  _impl_.source_context_ = source_context;
+  if (source_context) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Api.source_context)
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::release_source_context() {
+  
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+  _impl_.source_context_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::unsafe_arena_release_source_context() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.source_context)
+  
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+  _impl_.source_context_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::_internal_mutable_source_context() {
+  
+  if (_impl_.source_context_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
+    _impl_.source_context_ = p;
+  }
+  return _impl_.source_context_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::mutable_source_context() {
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.source_context)
+  return _msg;
+}
+inline void Api::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+  }
+  if (source_context) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context));
+    if (message_arena != submessage_arena) {
+      source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, source_context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.source_context_ = source_context;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.source_context)
+}
+
+// repeated .google.protobuf.Mixin mixins = 6;
+inline int Api::_internal_mixins_size() const {
+  return _impl_.mixins_.size();
+}
+inline int Api::mixins_size() const {
+  return _internal_mixins_size();
+}
+inline void Api::clear_mixins() {
+  _impl_.mixins_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::mutable_mixins(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.mixins)
+  return _impl_.mixins_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >*
+Api::mutable_mixins() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.mixins)
+  return &_impl_.mixins_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Mixin& Api::_internal_mixins(int index) const {
+  return _impl_.mixins_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Mixin& Api::mixins(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.mixins)
+  return _internal_mixins(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::_internal_add_mixins() {
+  return _impl_.mixins_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::add_mixins() {
+  ::PROTOBUF_NAMESPACE_ID::Mixin* _add = _internal_add_mixins();
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.mixins)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >&
+Api::mixins() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.mixins)
+  return _impl_.mixins_;
+}
+
+// .google.protobuf.Syntax syntax = 7;
+inline void Api::clear_syntax() {
+  _impl_.syntax_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::_internal_syntax() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.syntax)
+  return _internal_syntax();
+}
+inline void Api::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
+  
+  _impl_.syntax_ = value;
+}
+inline void Api::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
+  _internal_set_syntax(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// Method
+
+// string name = 1;
+inline void Method::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Method::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Method::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.name)
+}
+inline std::string* Method::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.name)
+  return _s;
+}
+inline const std::string& Method::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Method::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Method::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Method::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.name)
+  return _impl_.name_.Release();
+}
+inline void Method::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.name)
+}
+
+// string request_type_url = 2;
+inline void Method::clear_request_type_url() {
+  _impl_.request_type_url_.ClearToEmpty();
+}
+inline const std::string& Method::request_type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.request_type_url)
+  return _internal_request_type_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Method::set_request_type_url(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.request_type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.request_type_url)
+}
+inline std::string* Method::mutable_request_type_url() {
+  std::string* _s = _internal_mutable_request_type_url();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.request_type_url)
+  return _s;
+}
+inline const std::string& Method::_internal_request_type_url() const {
+  return _impl_.request_type_url_.Get();
+}
+inline void Method::_internal_set_request_type_url(const std::string& value) {
+  
+  _impl_.request_type_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Method::_internal_mutable_request_type_url() {
+  
+  return _impl_.request_type_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Method::release_request_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.request_type_url)
+  return _impl_.request_type_url_.Release();
+}
+inline void Method::set_allocated_request_type_url(std::string* request_type_url) {
+  if (request_type_url != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.request_type_url_.SetAllocated(request_type_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.request_type_url_.IsDefault()) {
+    _impl_.request_type_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.request_type_url)
+}
+
+// bool request_streaming = 3;
+inline void Method::clear_request_streaming() {
+  _impl_.request_streaming_ = false;
+}
+inline bool Method::_internal_request_streaming() const {
+  return _impl_.request_streaming_;
+}
+inline bool Method::request_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.request_streaming)
+  return _internal_request_streaming();
+}
+inline void Method::_internal_set_request_streaming(bool value) {
+  
+  _impl_.request_streaming_ = value;
+}
+inline void Method::set_request_streaming(bool value) {
+  _internal_set_request_streaming(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.request_streaming)
+}
+
+// string response_type_url = 4;
+inline void Method::clear_response_type_url() {
+  _impl_.response_type_url_.ClearToEmpty();
+}
+inline const std::string& Method::response_type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.response_type_url)
+  return _internal_response_type_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Method::set_response_type_url(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.response_type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.response_type_url)
+}
+inline std::string* Method::mutable_response_type_url() {
+  std::string* _s = _internal_mutable_response_type_url();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.response_type_url)
+  return _s;
+}
+inline const std::string& Method::_internal_response_type_url() const {
+  return _impl_.response_type_url_.Get();
+}
+inline void Method::_internal_set_response_type_url(const std::string& value) {
+  
+  _impl_.response_type_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Method::_internal_mutable_response_type_url() {
+  
+  return _impl_.response_type_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Method::release_response_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.response_type_url)
+  return _impl_.response_type_url_.Release();
+}
+inline void Method::set_allocated_response_type_url(std::string* response_type_url) {
+  if (response_type_url != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.response_type_url_.SetAllocated(response_type_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.response_type_url_.IsDefault()) {
+    _impl_.response_type_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.response_type_url)
+}
+
+// bool response_streaming = 5;
+inline void Method::clear_response_streaming() {
+  _impl_.response_streaming_ = false;
+}
+inline bool Method::_internal_response_streaming() const {
+  return _impl_.response_streaming_;
+}
+inline bool Method::response_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.response_streaming)
+  return _internal_response_streaming();
+}
+inline void Method::_internal_set_response_streaming(bool value) {
+  
+  _impl_.response_streaming_ = value;
+}
+inline void Method::set_response_streaming(bool value) {
+  _internal_set_response_streaming(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.response_streaming)
+}
+
+// repeated .google.protobuf.Option options = 6;
+inline int Method::_internal_options_size() const {
+  return _impl_.options_.size();
+}
+inline int Method::options_size() const {
+  return _internal_options_size();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Method::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.options)
+  return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+Method::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Method.options)
+  return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Method::_internal_options(int index) const {
+  return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Method::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.options)
+  return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Method::_internal_add_options() {
+  return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Method::add_options() {
+  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:google.protobuf.Method.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+Method::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Method.options)
+  return _impl_.options_;
+}
+
+// .google.protobuf.Syntax syntax = 7;
+inline void Method::clear_syntax() {
+  _impl_.syntax_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::_internal_syntax() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.syntax)
+  return _internal_syntax();
+}
+inline void Method::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
+  
+  _impl_.syntax_ = value;
+}
+inline void Method::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
+  _internal_set_syntax(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// Mixin
+
+// string name = 1;
+inline void Mixin::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Mixin::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Mixin.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Mixin::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Mixin.name)
+}
+inline std::string* Mixin::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.name)
+  return _s;
+}
+inline const std::string& Mixin::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Mixin::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Mixin::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Mixin::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Mixin.name)
+  return _impl_.name_.Release();
+}
+inline void Mixin::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.name)
+}
+
+// string root = 2;
+inline void Mixin::clear_root() {
+  _impl_.root_.ClearToEmpty();
+}
+inline const std::string& Mixin::root() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Mixin.root)
+  return _internal_root();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Mixin::set_root(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.root_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Mixin.root)
+}
+inline std::string* Mixin::mutable_root() {
+  std::string* _s = _internal_mutable_root();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.root)
+  return _s;
+}
+inline const std::string& Mixin::_internal_root() const {
+  return _impl_.root_.Get();
+}
+inline void Mixin::_internal_set_root(const std::string& value) {
+  
+  _impl_.root_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Mixin::_internal_mutable_root() {
+  
+  return _impl_.root_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Mixin::release_root() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Mixin.root)
+  return _impl_.root_.Release();
+}
+inline void Mixin::set_allocated_root(std::string* root) {
+  if (root != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.root_.SetAllocated(root, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.root_.IsDefault()) {
+    _impl_.root_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.root)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fapi_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/api.proto b/CAPI/cpp/grpc/include/google/protobuf/api.proto
new file mode 100644
index 0000000..3d598fc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/api.proto
@@ -0,0 +1,208 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+import "google/protobuf/source_context.proto";
+import "google/protobuf/type.proto";
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "ApiProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+option go_package = "google.golang.org/protobuf/types/known/apipb";
+
+// Api is a light-weight descriptor for an API Interface.
+//
+// Interfaces are also described as "protocol buffer services" in some contexts,
+// such as by the "service" keyword in a .proto file, but they are different
+// from API Services, which represent a concrete implementation of an interface
+// as opposed to simply a description of methods and bindings. They are also
+// sometimes simply referred to as "APIs" in other contexts, such as the name of
+// this message itself. See https://cloud.google.com/apis/design/glossary for
+// detailed terminology.
+message Api {
+  // The fully qualified name of this interface, including package name
+  // followed by the interface's simple name.
+  string name = 1;
+
+  // The methods of this interface, in unspecified order.
+  repeated Method methods = 2;
+
+  // Any metadata attached to the interface.
+  repeated Option options = 3;
+
+  // A version string for this interface. If specified, must have the form
+  // `major-version.minor-version`, as in `1.10`. If the minor version is
+  // omitted, it defaults to zero. If the entire version field is empty, the
+  // major version is derived from the package name, as outlined below. If the
+  // field is not empty, the version in the package name will be verified to be
+  // consistent with what is provided here.
+  //
+  // The versioning schema uses [semantic
+  // versioning](http://semver.org) where the major version number
+  // indicates a breaking change and the minor version an additive,
+  // non-breaking change. Both version numbers are signals to users
+  // what to expect from different versions, and should be carefully
+  // chosen based on the product plan.
+  //
+  // The major version is also reflected in the package name of the
+  // interface, which must end in `v<major-version>`, as in
+  // `google.feature.v1`. For major versions 0 and 1, the suffix can
+  // be omitted. Zero major versions must only be used for
+  // experimental, non-GA interfaces.
+  //
+  //
+  string version = 4;
+
+  // Source context for the protocol buffer service represented by this
+  // message.
+  SourceContext source_context = 5;
+
+  // Included interfaces. See [Mixin][].
+  repeated Mixin mixins = 6;
+
+  // The source syntax of the service.
+  Syntax syntax = 7;
+}
+
+// Method represents a method of an API interface.
+message Method {
+  // The simple name of this method.
+  string name = 1;
+
+  // A URL of the input message type.
+  string request_type_url = 2;
+
+  // If true, the request is streamed.
+  bool request_streaming = 3;
+
+  // The URL of the output message type.
+  string response_type_url = 4;
+
+  // If true, the response is streamed.
+  bool response_streaming = 5;
+
+  // Any metadata attached to the method.
+  repeated Option options = 6;
+
+  // The source syntax of this method.
+  Syntax syntax = 7;
+}
+
+// Declares an API Interface to be included in this interface. The including
+// interface must redeclare all the methods from the included interface, but
+// documentation and options are inherited as follows:
+//
+// - If after comment and whitespace stripping, the documentation
+//   string of the redeclared method is empty, it will be inherited
+//   from the original method.
+//
+// - Each annotation belonging to the service config (http,
+//   visibility) which is not set in the redeclared method will be
+//   inherited.
+//
+// - If an http annotation is inherited, the path pattern will be
+//   modified as follows. Any version prefix will be replaced by the
+//   version of the including interface plus the [root][] path if
+//   specified.
+//
+// Example of a simple mixin:
+//
+//     package google.acl.v1;
+//     service AccessControl {
+//       // Get the underlying ACL object.
+//       rpc GetAcl(GetAclRequest) returns (Acl) {
+//         option (google.api.http).get = "/v1/{resource=**}:getAcl";
+//       }
+//     }
+//
+//     package google.storage.v2;
+//     service Storage {
+//       rpc GetAcl(GetAclRequest) returns (Acl);
+//
+//       // Get a data record.
+//       rpc GetData(GetDataRequest) returns (Data) {
+//         option (google.api.http).get = "/v2/{resource=**}";
+//       }
+//     }
+//
+// Example of a mixin configuration:
+//
+//     apis:
+//     - name: google.storage.v2.Storage
+//       mixins:
+//       - name: google.acl.v1.AccessControl
+//
+// The mixin construct implies that all methods in `AccessControl` are
+// also declared with same name and request/response types in
+// `Storage`. A documentation generator or annotation processor will
+// see the effective `Storage.GetAcl` method after inheriting
+// documentation and annotations as follows:
+//
+//     service Storage {
+//       // Get the underlying ACL object.
+//       rpc GetAcl(GetAclRequest) returns (Acl) {
+//         option (google.api.http).get = "/v2/{resource=**}:getAcl";
+//       }
+//       ...
+//     }
+//
+// Note how the version in the path pattern changed from `v1` to `v2`.
+//
+// If the `root` field in the mixin is specified, it should be a
+// relative path under which inherited HTTP paths are placed. Example:
+//
+//     apis:
+//     - name: google.storage.v2.Storage
+//       mixins:
+//       - name: google.acl.v1.AccessControl
+//         root: acls
+//
+// This implies the following inherited HTTP annotation:
+//
+//     service Storage {
+//       // Get the underlying ACL object.
+//       rpc GetAcl(GetAclRequest) returns (Acl) {
+//         option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
+//       }
+//       ...
+//     }
+message Mixin {
+  // The fully qualified name of the interface which is included.
+  string name = 1;
+
+  // If non-empty specifies a path under which inherited HTTP paths
+  // are rooted.
+  string root = 2;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/arena.h b/CAPI/cpp/grpc/include/google/protobuf/arena.h
new file mode 100644
index 0000000..3b5f16c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/arena.h
@@ -0,0 +1,851 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines an Arena allocator for better allocation performance.
+
+#ifndef GOOGLE_PROTOBUF_ARENA_H__
+#define GOOGLE_PROTOBUF_ARENA_H__
+
+
+#include <limits>
+#include <type_traits>
+#include <utility>
+#if defined(_MSC_VER) && !defined(_LIBCPP_STD_VER) && !_HAS_EXCEPTIONS
+// Work around bugs in MSVC <typeinfo> header when _HAS_EXCEPTIONS=0.
+#include <exception>
+#include <typeinfo>
+namespace std {
+using type_info = ::type_info;
+}
+#else
+#include <typeinfo>
+#endif
+
+#include <type_traits>
+#include <google/protobuf/arena_impl.h>
+#include <google/protobuf/port.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+struct ArenaOptions;  // defined below
+class Arena;    // defined below
+class Message;  // defined in message.h
+class MessageLite;
+template <typename Key, typename T>
+class Map;
+
+namespace arena_metrics {
+
+void EnableArenaMetrics(ArenaOptions* options);
+
+}  // namespace arena_metrics
+
+namespace TestUtil {
+class ReflectionTester;  // defined in test_util.h
+}  // namespace TestUtil
+
+namespace internal {
+
+struct ArenaTestPeer;        // defined in arena_test_util.h
+class InternalMetadata;      // defined in metadata_lite.h
+class LazyField;             // defined in lazy_field.h
+class EpsCopyInputStream;    // defined in parse_context.h
+class RepeatedPtrFieldBase;  // defined in repeated_ptr_field.h
+
+template <typename Type>
+class GenericTypeHandler;  // defined in repeated_field.h
+
+inline PROTOBUF_ALWAYS_INLINE
+void* AlignTo(void* ptr, size_t align) {
+  return reinterpret_cast<void*>(
+      (reinterpret_cast<uintptr_t>(ptr) + align - 1) & (~align + 1));
+}
+
+// Templated cleanup methods.
+template <typename T>
+void arena_destruct_object(void* object) {
+  reinterpret_cast<T*>(object)->~T();
+}
+
+template <bool destructor_skippable, typename T>
+struct ObjectDestructor {
+  constexpr static void (*destructor)(void*) = &arena_destruct_object<T>;
+};
+
+template <typename T>
+struct ObjectDestructor<true, T> {
+  constexpr static void (*destructor)(void*) = nullptr;
+};
+
+template <typename T>
+void arena_delete_object(void* object) {
+  delete reinterpret_cast<T*>(object);
+}
+}  // namespace internal
+
+// ArenaOptions provides optional additional parameters to arena construction
+// that control its block-allocation behavior.
+struct ArenaOptions {
+  // This defines the size of the first block requested from the system malloc.
+  // Subsequent block sizes will increase in a geometric series up to a maximum.
+  size_t start_block_size;
+
+  // This defines the maximum block size requested from system malloc (unless an
+  // individual arena allocation request occurs with a size larger than this
+  // maximum). Requested block sizes increase up to this value, then remain
+  // here.
+  size_t max_block_size;
+
+  // An initial block of memory for the arena to use, or NULL for none. If
+  // provided, the block must live at least as long as the arena itself. The
+  // creator of the Arena retains ownership of the block after the Arena is
+  // destroyed.
+  char* initial_block;
+
+  // The size of the initial block, if provided.
+  size_t initial_block_size;
+
+  // A function pointer to an alloc method that returns memory blocks of size
+  // requested. By default, it contains a ptr to the malloc function.
+  //
+  // NOTE: block_alloc and dealloc functions are expected to behave like
+  // malloc and free, including Asan poisoning.
+  void* (*block_alloc)(size_t);
+  // A function pointer to a dealloc method that takes ownership of the blocks
+  // from the arena. By default, it contains a ptr to a wrapper function that
+  // calls free.
+  void (*block_dealloc)(void*, size_t);
+
+  ArenaOptions()
+      : start_block_size(internal::AllocationPolicy::kDefaultStartBlockSize),
+        max_block_size(internal::AllocationPolicy::kDefaultMaxBlockSize),
+        initial_block(NULL),
+        initial_block_size(0),
+        block_alloc(nullptr),
+        block_dealloc(nullptr),
+        make_metrics_collector(nullptr) {}
+
+ private:
+  // If make_metrics_collector is not nullptr, it will be called at Arena init
+  // time. It may return a pointer to a collector instance that will be notified
+  // of interesting events related to the arena.
+  internal::ArenaMetricsCollector* (*make_metrics_collector)();
+
+  internal::ArenaMetricsCollector* MetricsCollector() const {
+    return make_metrics_collector ? (*make_metrics_collector)() : nullptr;
+  }
+
+  internal::AllocationPolicy AllocationPolicy() const {
+    internal::AllocationPolicy res;
+    res.start_block_size = start_block_size;
+    res.max_block_size = max_block_size;
+    res.block_alloc = block_alloc;
+    res.block_dealloc = block_dealloc;
+    res.metrics_collector = MetricsCollector();
+    return res;
+  }
+
+  friend void arena_metrics::EnableArenaMetrics(ArenaOptions*);
+
+  friend class Arena;
+  friend class ArenaOptionsTestFriend;
+};
+
+// Support for non-RTTI environments. (The metrics hooks API uses type
+// information.)
+#if PROTOBUF_RTTI
+#define RTTI_TYPE_ID(type) (&typeid(type))
+#else
+#define RTTI_TYPE_ID(type) (NULL)
+#endif
+
+// Arena allocator. Arena allocation replaces ordinary (heap-based) allocation
+// with new/delete, and improves performance by aggregating allocations into
+// larger blocks and freeing allocations all at once. Protocol messages are
+// allocated on an arena by using Arena::CreateMessage<T>(Arena*), below, and
+// are automatically freed when the arena is destroyed.
+//
+// This is a thread-safe implementation: multiple threads may allocate from the
+// arena concurrently. Destruction is not thread-safe and the destructing
+// thread must synchronize with users of the arena first.
+//
+// An arena provides two allocation interfaces: CreateMessage<T>, which works
+// for arena-enabled proto2 message types as well as other types that satisfy
+// the appropriate protocol (described below), and Create<T>, which works for
+// any arbitrary type T. CreateMessage<T> is better when the type T supports it,
+// because this interface (i) passes the arena pointer to the created object so
+// that its sub-objects and internal allocations can use the arena too, and (ii)
+// elides the object's destructor call when possible. Create<T> does not place
+// any special requirements on the type T, and will invoke the object's
+// destructor when the arena is destroyed.
+//
+// The arena message allocation protocol, required by
+// CreateMessage<T>(Arena* arena, Args&&... args), is as follows:
+//
+// - The type T must have (at least) two constructors: a constructor callable
+//   with `args` (without `arena`), called when a T is allocated on the heap;
+//   and a constructor callable with `Arena* arena, Args&&... args`, called when
+//   a T is allocated on an arena. If the second constructor is called with a
+//   NULL arena pointer, it must be equivalent to invoking the first
+//   (`args`-only) constructor.
+//
+// - The type T must have a particular type trait: a nested type
+//   |InternalArenaConstructable_|. This is usually a typedef to |void|. If no
+//   such type trait exists, then the instantiation CreateMessage<T> will fail
+//   to compile.
+//
+// - The type T *may* have the type trait |DestructorSkippable_|. If this type
+//   trait is present in the type, then its destructor will not be called if and
+//   only if it was passed a non-NULL arena pointer. If this type trait is not
+//   present on the type, then its destructor is always called when the
+//   containing arena is destroyed.
+//
+// This protocol is implemented by all arena-enabled proto2 message classes as
+// well as protobuf container types like RepeatedPtrField and Map. The protocol
+// is internal to protobuf and is not guaranteed to be stable. Non-proto types
+// should not rely on this protocol.
+class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
+ public:
+  // Default constructor with sensible default options, tuned for average
+  // use-cases.
+  inline Arena() : impl_() {}
+
+  // Construct an arena with default options, except for the supplied
+  // initial block. It is more efficient to use this constructor
+  // instead of passing ArenaOptions if the only configuration needed
+  // by the caller is supplying an initial block.
+  inline Arena(char* initial_block, size_t initial_block_size)
+      : impl_(initial_block, initial_block_size) {}
+
+  // Arena constructor taking custom options. See ArenaOptions above for
+  // descriptions of the options available.
+  explicit Arena(const ArenaOptions& options)
+      : impl_(options.initial_block, options.initial_block_size,
+              options.AllocationPolicy()) {}
+
+  // Block overhead.  Use this as a guide for how much to over-allocate the
+  // initial block if you want an allocation of size N to fit inside it.
+  //
+  // WARNING: if you allocate multiple objects, it is difficult to guarantee
+  // that a series of allocations will fit in the initial block, especially if
+  // Arena changes its alignment guarantees in the future!
+  static const size_t kBlockOverhead =
+      internal::ThreadSafeArena::kBlockHeaderSize +
+      internal::ThreadSafeArena::kSerialArenaSize;
+
+  inline ~Arena() {}
+
+  // TODO(protobuf-team): Fix callers to use constructor and delete this method.
+  void Init(const ArenaOptions&) {}
+
+  // API to create proto2 message objects on the arena. If the arena passed in
+  // is NULL, then a heap allocated object is returned. Type T must be a message
+  // defined in a .proto file with cc_enable_arenas set to true, otherwise a
+  // compilation error will occur.
+  //
+  // RepeatedField and RepeatedPtrField may also be instantiated directly on an
+  // arena with this method.
+  //
+  // This function also accepts any type T that satisfies the arena message
+  // allocation protocol, documented above.
+  template <typename T, typename... Args>
+  PROTOBUF_ALWAYS_INLINE static T* CreateMessage(Arena* arena, Args&&... args) {
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+    // We must delegate to CreateMaybeMessage() and NOT CreateMessageInternal()
+    // because protobuf generated classes specialize CreateMaybeMessage() and we
+    // need to use that specialization for code size reasons.
+    return Arena::CreateMaybeMessage<T>(arena, static_cast<Args&&>(args)...);
+  }
+
+  // API to create any objects on the arena. Note that only the object will
+  // be created on the arena; the underlying ptrs (in case of a proto2 message)
+  // will be still heap allocated. Proto messages should usually be allocated
+  // with CreateMessage<T>() instead.
+  //
+  // Note that even if T satisfies the arena message construction protocol
+  // (InternalArenaConstructable_ trait and optional DestructorSkippable_
+  // trait), as described above, this function does not follow the protocol;
+  // instead, it treats T as a black-box type, just as if it did not have these
+  // traits. Specifically, T's constructor arguments will always be only those
+  // passed to Create<T>() -- no additional arena pointer is implicitly added.
+  // Furthermore, the destructor will always be called at arena destruction time
+  // (unless the destructor is trivial). Hence, from T's point of view, it is as
+  // if the object were allocated on the heap (except that the underlying memory
+  // is obtained from the arena).
+  template <typename T, typename... Args>
+  PROTOBUF_NDEBUG_INLINE static T* Create(Arena* arena, Args&&... args) {
+    return CreateInternal<T>(arena, std::is_convertible<T*, MessageLite*>(),
+                             static_cast<Args&&>(args)...);
+  }
+
+  // Allocates memory with the specific size and alignment.
+  void* AllocateAligned(size_t size, size_t align = 8) {
+    if (align <= 8) {
+      return AllocateAlignedNoHook(internal::AlignUpTo8(size));
+    } else {
+      // We are wasting space by over allocating align - 8 bytes. Compared
+      // to a dedicated function that takes current alignment in consideration.
+      // Such a scheme would only waste (align - 8)/2 bytes on average, but
+      // requires a dedicated function in the outline arena allocation
+      // functions. Possibly re-evaluate tradeoffs later.
+      return internal::AlignTo(AllocateAlignedNoHook(size + align - 8), align);
+    }
+  }
+
+  // Create an array of object type T on the arena *without* invoking the
+  // constructor of T. If `arena` is null, then the return value should be freed
+  // with `delete[] x;` (or `::operator delete[](x);`).
+  // To ensure safe uses, this function checks at compile time
+  // (when compiled as C++11) that T is trivially default-constructible and
+  // trivially destructible.
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE static T* CreateArray(Arena* arena,
+                                               size_t num_elements) {
+    static_assert(std::is_trivial<T>::value,
+                  "CreateArray requires a trivially constructible type");
+    static_assert(std::is_trivially_destructible<T>::value,
+                  "CreateArray requires a trivially destructible type");
+    GOOGLE_CHECK_LE(num_elements, std::numeric_limits<size_t>::max() / sizeof(T))
+        << "Requested size is too large to fit into size_t.";
+    if (arena == NULL) {
+      return static_cast<T*>(::operator new[](num_elements * sizeof(T)));
+    } else {
+      return arena->CreateInternalRawArray<T>(num_elements);
+    }
+  }
+
+  // The following are routines are for monitoring. They will approximate the
+  // total sum allocated and used memory, but the exact value is an
+  // implementation deal. For instance allocated space depends on growth
+  // policies. Do not use these in unit tests.
+  // Returns the total space allocated by the arena, which is the sum of the
+  // sizes of the underlying blocks.
+  uint64_t SpaceAllocated() const { return impl_.SpaceAllocated(); }
+  // Returns the total space used by the arena. Similar to SpaceAllocated but
+  // does not include free space and block overhead. The total space returned
+  // may not include space used by other threads executing concurrently with
+  // the call to this method.
+  uint64_t SpaceUsed() const { return impl_.SpaceUsed(); }
+
+  // Frees all storage allocated by this arena after calling destructors
+  // registered with OwnDestructor() and freeing objects registered with Own().
+  // Any objects allocated on this arena are unusable after this call. It also
+  // returns the total space used by the arena which is the sums of the sizes
+  // of the allocated blocks. This method is not thread-safe.
+  uint64_t Reset() { return impl_.Reset(); }
+
+  // Adds |object| to a list of heap-allocated objects to be freed with |delete|
+  // when the arena is destroyed or reset.
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE void Own(T* object) {
+    OwnInternal(object, std::is_convertible<T*, MessageLite*>());
+  }
+
+  // Adds |object| to a list of objects whose destructors will be manually
+  // called when the arena is destroyed or reset. This differs from Own() in
+  // that it does not free the underlying memory with |delete|; hence, it is
+  // normally only used for objects that are placement-newed into
+  // arena-allocated memory.
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE void OwnDestructor(T* object) {
+    if (object != NULL) {
+      impl_.AddCleanup(object, &internal::arena_destruct_object<T>);
+    }
+  }
+
+  // Adds a custom member function on an object to the list of destructors that
+  // will be manually called when the arena is destroyed or reset. This differs
+  // from OwnDestructor() in that any member function may be specified, not only
+  // the class destructor.
+  PROTOBUF_ALWAYS_INLINE void OwnCustomDestructor(void* object,
+                                                  void (*destruct)(void*)) {
+    impl_.AddCleanup(object, destruct);
+  }
+
+  // Retrieves the arena associated with |value| if |value| is an arena-capable
+  // message, or NULL otherwise. If possible, the call resolves at compile time.
+  // Note that we can often devirtualize calls to `value->GetArena()` so usually
+  // calling this method is unnecessary.
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE static Arena* GetArena(const T* value) {
+    return GetArenaInternal(value);
+  }
+
+  template <typename T>
+  class InternalHelper {
+   private:
+    // Provides access to protected GetOwningArena to generated messages.
+    static Arena* GetOwningArena(const T* p) { return p->GetOwningArena(); }
+
+    static void InternalSwap(T* a, T* b) { a->InternalSwap(b); }
+
+    static Arena* GetArenaForAllocationInternal(
+        const T* p, std::true_type /*is_derived_from<MessageLite>*/) {
+      return p->GetArenaForAllocation();
+    }
+
+    static Arena* GetArenaForAllocationInternal(
+        const T* p, std::false_type /*is_derived_from<MessageLite>*/) {
+      return GetArenaForAllocationForNonMessage(
+          p, typename is_arena_constructable::type());
+    }
+
+    static Arena* GetArenaForAllocationForNonMessage(
+        const T* p, std::true_type /*is_arena_constructible*/) {
+      return p->GetArena();
+    }
+
+    static Arena* GetArenaForAllocationForNonMessage(
+        const T* p, std::false_type /*is_arena_constructible*/) {
+      return GetArenaForAllocationForNonMessageNonArenaConstructible(
+          p, typename has_get_arena::type());
+    }
+
+    static Arena* GetArenaForAllocationForNonMessageNonArenaConstructible(
+        const T* p, std::true_type /*has_get_arena*/) {
+      return p->GetArena();
+    }
+
+    static Arena* GetArenaForAllocationForNonMessageNonArenaConstructible(
+        const T* /* p */, std::false_type /*has_get_arena*/) {
+      return nullptr;
+    }
+
+    template <typename U>
+    static char DestructorSkippable(const typename U::DestructorSkippable_*);
+    template <typename U>
+    static double DestructorSkippable(...);
+
+    typedef std::integral_constant<
+        bool, sizeof(DestructorSkippable<T>(static_cast<const T*>(0))) ==
+                      sizeof(char) ||
+                  std::is_trivially_destructible<T>::value>
+        is_destructor_skippable;
+
+    template <typename U>
+    static char ArenaConstructable(
+        const typename U::InternalArenaConstructable_*);
+    template <typename U>
+    static double ArenaConstructable(...);
+
+    typedef std::integral_constant<bool, sizeof(ArenaConstructable<T>(
+                                             static_cast<const T*>(0))) ==
+                                             sizeof(char)>
+        is_arena_constructable;
+
+    template <typename U,
+              typename std::enable_if<
+                  std::is_same<Arena*, decltype(std::declval<const U>()
+                                                    .GetArena())>::value,
+                  int>::type = 0>
+    static char HasGetArena(decltype(&U::GetArena));
+    template <typename U>
+    static double HasGetArena(...);
+
+    typedef std::integral_constant<bool, sizeof(HasGetArena<T>(nullptr)) ==
+                                             sizeof(char)>
+        has_get_arena;
+
+    template <typename... Args>
+    static T* Construct(void* ptr, Args&&... args) {
+      return new (ptr) T(static_cast<Args&&>(args)...);
+    }
+
+    static inline PROTOBUF_ALWAYS_INLINE T* New() {
+      return new T(nullptr);
+    }
+
+    static Arena* GetArena(const T* p) { return p->GetArena(); }
+
+    friend class Arena;
+    friend class TestUtil::ReflectionTester;
+  };
+
+  // Provides access to protected GetOwningArena to generated messages.  For
+  // internal use only.
+  template <typename T>
+  static Arena* InternalGetOwningArena(const T* p) {
+    return InternalHelper<T>::GetOwningArena(p);
+  }
+
+  // Provides access to protected GetArenaForAllocation to generated messages.
+  // For internal use only.
+  template <typename T>
+  static Arena* InternalGetArenaForAllocation(const T* p) {
+    return InternalHelper<T>::GetArenaForAllocationInternal(
+        p, std::is_convertible<T*, MessageLite*>());
+  }
+
+  // Creates message-owned arena.  For internal use only.
+  static Arena* InternalCreateMessageOwnedArena() {
+    return new Arena(internal::MessageOwned{});
+  }
+
+  // Checks whether this arena is message-owned.  For internal use only.
+  bool InternalIsMessageOwnedArena() { return IsMessageOwned(); }
+
+  // Helper typetraits that indicates support for arenas in a type T at compile
+  // time. This is public only to allow construction of higher-level templated
+  // utilities.
+  //
+  // is_arena_constructable<T>::value is true if the message type T has arena
+  // support enabled, and false otherwise.
+  //
+  // is_destructor_skippable<T>::value is true if the message type T has told
+  // the arena that it is safe to skip the destructor, and false otherwise.
+  //
+  // This is inside Arena because only Arena has the friend relationships
+  // necessary to see the underlying generated code traits.
+  template <typename T>
+  struct is_arena_constructable : InternalHelper<T>::is_arena_constructable {};
+  template <typename T>
+  struct is_destructor_skippable : InternalHelper<T>::is_destructor_skippable {
+  };
+
+ private:
+  internal::ThreadSafeArena impl_;
+
+  template <typename T>
+  struct has_get_arena : InternalHelper<T>::has_get_arena {};
+
+  // Constructor solely used by message-owned arena.
+  inline Arena(internal::MessageOwned) : impl_(internal::MessageOwned{}) {}
+
+  // Checks whether this arena is message-owned.
+  PROTOBUF_ALWAYS_INLINE bool IsMessageOwned() const {
+    return impl_.IsMessageOwned();
+  }
+
+  void ReturnArrayMemory(void* p, size_t size) {
+    impl_.ReturnArrayMemory(p, size);
+  }
+
+  template <typename T, typename... Args>
+  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena,
+                                                         Args&&... args) {
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+    if (arena == NULL) {
+      return new T(nullptr, static_cast<Args&&>(args)...);
+    } else {
+      return arena->DoCreateMessage<T>(static_cast<Args&&>(args)...);
+    }
+  }
+
+  // This specialization for no arguments is necessary, because its behavior is
+  // slightly different.  When the arena pointer is nullptr, it calls T()
+  // instead of T(nullptr).
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+    if (arena == NULL) {
+      // Generated arena constructor T(Arena*) is protected. Call via
+      // InternalHelper.
+      return InternalHelper<T>::New();
+    } else {
+      return arena->DoCreateMessage<T>();
+    }
+  }
+
+  // Allocate and also optionally call collector with the allocated type info
+  // when allocation recording is enabled.
+  PROTOBUF_NDEBUG_INLINE void* AllocateInternal(size_t size, size_t align,
+                                                void (*destructor)(void*),
+                                                const std::type_info* type) {
+    // Monitor allocation if needed.
+    if (destructor == nullptr) {
+      return AllocateAlignedWithHook(size, align, type);
+    } else {
+      if (align <= 8) {
+        auto res = AllocateAlignedWithCleanup(internal::AlignUpTo8(size), type);
+        res.second->elem = res.first;
+        res.second->cleanup = destructor;
+        return res.first;
+      } else {
+        auto res = AllocateAlignedWithCleanup(size + align - 8, type);
+        auto ptr = internal::AlignTo(res.first, align);
+        res.second->elem = ptr;
+        res.second->cleanup = destructor;
+        return ptr;
+      }
+    }
+  }
+
+  // CreateMessage<T> requires that T supports arenas, but this private method
+  // works whether or not T supports arenas. These are not exposed to user code
+  // as it can cause confusing API usages, and end up having double free in
+  // user code. These are used only internally from LazyField and Repeated
+  // fields, since they are designed to work in all mode combinations.
+  template <typename Msg, typename... Args>
+  PROTOBUF_ALWAYS_INLINE static Msg* DoCreateMaybeMessage(Arena* arena,
+                                                          std::true_type,
+                                                          Args&&... args) {
+    return CreateMessageInternal<Msg>(arena, std::forward<Args>(args)...);
+  }
+
+  template <typename T, typename... Args>
+  PROTOBUF_ALWAYS_INLINE static T* DoCreateMaybeMessage(Arena* arena,
+                                                        std::false_type,
+                                                        Args&&... args) {
+    return Create<T>(arena, std::forward<Args>(args)...);
+  }
+
+  template <typename T, typename... Args>
+  PROTOBUF_ALWAYS_INLINE static T* CreateMaybeMessage(Arena* arena,
+                                                      Args&&... args) {
+    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
+                                   std::forward<Args>(args)...);
+  }
+
+  // Just allocate the required size for the given type assuming the
+  // type has a trivial constructor.
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE T* CreateInternalRawArray(size_t num_elements) {
+    GOOGLE_CHECK_LE(num_elements, std::numeric_limits<size_t>::max() / sizeof(T))
+        << "Requested size is too large to fit into size_t.";
+    // We count on compiler to realize that if sizeof(T) is a multiple of
+    // 8 AlignUpTo can be elided.
+    const size_t n = sizeof(T) * num_elements;
+    return static_cast<T*>(
+        AllocateAlignedWithHookForArray(n, alignof(T), RTTI_TYPE_ID(T)));
+  }
+
+  template <typename T, typename... Args>
+  PROTOBUF_NDEBUG_INLINE T* DoCreateMessage(Args&&... args) {
+    return InternalHelper<T>::Construct(
+        AllocateInternal(sizeof(T), alignof(T),
+                         internal::ObjectDestructor<
+                             InternalHelper<T>::is_destructor_skippable::value,
+                             T>::destructor,
+                         RTTI_TYPE_ID(T)),
+        this, std::forward<Args>(args)...);
+  }
+
+  // CreateInArenaStorage is used to implement map field. Without it,
+  // Map need to call generated message's protected arena constructor,
+  // which needs to declare Map as friend of generated message.
+  template <typename T, typename... Args>
+  static void CreateInArenaStorage(T* ptr, Arena* arena, Args&&... args) {
+    CreateInArenaStorageInternal(ptr, arena,
+                                 typename is_arena_constructable<T>::type(),
+                                 std::forward<Args>(args)...);
+    if (arena != nullptr) {
+      RegisterDestructorInternal(
+          ptr, arena,
+          typename InternalHelper<T>::is_destructor_skippable::type());
+    }
+  }
+
+  template <typename T, typename... Args>
+  static void CreateInArenaStorageInternal(T* ptr, Arena* arena,
+                                           std::true_type, Args&&... args) {
+    InternalHelper<T>::Construct(ptr, arena, std::forward<Args>(args)...);
+  }
+  template <typename T, typename... Args>
+  static void CreateInArenaStorageInternal(T* ptr, Arena* /* arena */,
+                                           std::false_type, Args&&... args) {
+    new (ptr) T(std::forward<Args>(args)...);
+  }
+
+  template <typename T>
+  static void RegisterDestructorInternal(T* /* ptr */, Arena* /* arena */,
+                                         std::true_type) {}
+  template <typename T>
+  static void RegisterDestructorInternal(T* ptr, Arena* arena,
+                                         std::false_type) {
+    arena->OwnDestructor(ptr);
+  }
+
+  // These implement Create(). The second parameter has type 'true_type' if T is
+  // a subtype of Message and 'false_type' otherwise.
+  template <typename T, typename... Args>
+  PROTOBUF_ALWAYS_INLINE static T* CreateInternal(Arena* arena, std::true_type,
+                                                  Args&&... args) {
+    if (arena == nullptr) {
+      return new T(std::forward<Args>(args)...);
+    } else {
+      auto destructor =
+          internal::ObjectDestructor<std::is_trivially_destructible<T>::value,
+                                     T>::destructor;
+      T* result =
+          new (arena->AllocateInternal(sizeof(T), alignof(T), destructor,
+                                       RTTI_TYPE_ID(T)))
+          T(std::forward<Args>(args)...);
+      return result;
+    }
+  }
+  template <typename T, typename... Args>
+  PROTOBUF_ALWAYS_INLINE static T* CreateInternal(Arena* arena, std::false_type,
+                                                  Args&&... args) {
+    if (arena == nullptr) {
+      return new T(std::forward<Args>(args)...);
+    } else {
+      auto destructor =
+          internal::ObjectDestructor<std::is_trivially_destructible<T>::value,
+                                     T>::destructor;
+      return new (arena->AllocateInternal(sizeof(T), alignof(T), destructor,
+                                          RTTI_TYPE_ID(T)))
+          T(std::forward<Args>(args)...);
+    }
+  }
+
+  // These implement Own(), which registers an object for deletion (destructor
+  // call and operator delete()). The second parameter has type 'true_type' if T
+  // is a subtype of Message and 'false_type' otherwise. Collapsing
+  // all template instantiations to one for generic Message reduces code size,
+  // using the virtual destructor instead.
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE void OwnInternal(T* object, std::true_type) {
+    if (object != NULL) {
+      impl_.AddCleanup(object, &internal::arena_delete_object<MessageLite>);
+    }
+  }
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE void OwnInternal(T* object, std::false_type) {
+    if (object != NULL) {
+      impl_.AddCleanup(object, &internal::arena_delete_object<T>);
+    }
+  }
+
+  // Implementation for GetArena(). Only message objects with
+  // InternalArenaConstructable_ tags can be associated with an arena, and such
+  // objects must implement a GetArena() method.
+  template <typename T, typename std::enable_if<
+                            is_arena_constructable<T>::value, int>::type = 0>
+  PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) {
+    return InternalHelper<T>::GetArena(value);
+  }
+  template <typename T,
+            typename std::enable_if<!is_arena_constructable<T>::value &&
+                                        has_get_arena<T>::value,
+                                    int>::type = 0>
+  PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) {
+    return value->GetArena();
+  }
+  template <typename T,
+            typename std::enable_if<!is_arena_constructable<T>::value &&
+                                        !has_get_arena<T>::value,
+                                    int>::type = 0>
+  PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) {
+    (void)value;
+    return nullptr;
+  }
+
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArena(const T* value) {
+    return GetOwningArenaInternal(
+        value, std::is_convertible<T*, MessageLite*>());
+  }
+
+  // Implementation for GetOwningArena(). All and only message objects have
+  // GetOwningArena() method.
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArenaInternal(
+      const T* value, std::true_type) {
+    return InternalHelper<T>::GetOwningArena(value);
+  }
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArenaInternal(
+      const T* /* value */, std::false_type) {
+    return nullptr;
+  }
+
+  void* AllocateAlignedWithHookForArray(size_t n, size_t align,
+                                        const std::type_info* type) {
+    if (align <= 8) {
+      return AllocateAlignedWithHookForArray(internal::AlignUpTo8(n), type);
+    } else {
+      // We are wasting space by over allocating align - 8 bytes. Compared
+      // to a dedicated function that takes current alignment in consideration.
+      // Such a scheme would only waste (align - 8)/2 bytes on average, but
+      // requires a dedicated function in the outline arena allocation
+      // functions. Possibly re-evaluate tradeoffs later.
+      return internal::AlignTo(
+          AllocateAlignedWithHookForArray(n + align - 8, type), align);
+    }
+  }
+
+  void* AllocateAlignedWithHook(size_t n, size_t align,
+                                const std::type_info* type) {
+    if (align <= 8) {
+      return AllocateAlignedWithHook(internal::AlignUpTo8(n), type);
+    } else {
+      // We are wasting space by over allocating align - 8 bytes. Compared
+      // to a dedicated function that takes current alignment in consideration.
+      // Such a scheme would only waste (align - 8)/2 bytes on average, but
+      // requires a dedicated function in the outline arena allocation
+      // functions. Possibly re-evaluate tradeoffs later.
+      return internal::AlignTo(AllocateAlignedWithHook(n + align - 8, type),
+                               align);
+    }
+  }
+
+  void* AllocateAlignedNoHook(size_t n);
+  void* AllocateAlignedWithHook(size_t n, const std::type_info* type);
+  void* AllocateAlignedWithHookForArray(size_t n, const std::type_info* type);
+  std::pair<void*, internal::SerialArena::CleanupNode*>
+  AllocateAlignedWithCleanup(size_t n, const std::type_info* type);
+
+  template <typename Type>
+  friend class internal::GenericTypeHandler;
+  friend class internal::InternalMetadata;  // For user_arena().
+  friend class internal::LazyField;        // For CreateMaybeMessage.
+  friend class internal::EpsCopyInputStream;  // For parser performance
+  friend class MessageLite;
+  template <typename Key, typename T>
+  friend class Map;
+  template <typename>
+  friend class RepeatedField;                   // For ReturnArrayMemory
+  friend class internal::RepeatedPtrFieldBase;  // For ReturnArrayMemory
+  friend struct internal::ArenaTestPeer;
+};
+
+// Defined above for supporting environments without RTTI.
+#undef RTTI_TYPE_ID
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_ARENA_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/arena_impl.h b/CAPI/cpp/grpc/include/google/protobuf/arena_impl.h
new file mode 100644
index 0000000..7672768
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/arena_impl.h
@@ -0,0 +1,686 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines an Arena allocator for better allocation performance.
+
+#ifndef GOOGLE_PROTOBUF_ARENA_IMPL_H__
+#define GOOGLE_PROTOBUF_ARENA_IMPL_H__
+
+#include <atomic>
+#include <limits>
+#include <typeinfo>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/port.h>
+
+#ifdef ADDRESS_SANITIZER
+#include <sanitizer/asan_interface.h>
+#endif  // ADDRESS_SANITIZER
+
+#include <google/protobuf/arenaz_sampler.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// To prevent sharing cache lines between threads
+#ifdef __cpp_aligned_new
+enum { kCacheAlignment = 64 };
+#else
+enum { kCacheAlignment = alignof(max_align_t) };  // do the best we can
+#endif
+
+inline constexpr size_t AlignUpTo8(size_t n) {
+  // Align n to next multiple of 8 (from Hacker's Delight, Chapter 3.)
+  return (n + 7) & static_cast<size_t>(-8);
+}
+
+using LifecycleIdAtomic = uint64_t;
+
+// MetricsCollector collects stats for a particular arena.
+class PROTOBUF_EXPORT ArenaMetricsCollector {
+ public:
+  ArenaMetricsCollector(bool record_allocs) : record_allocs_(record_allocs) {}
+
+  // Invoked when the arena is about to be destroyed. This method will
+  // typically finalize any metric collection and delete the collector.
+  // space_allocated is the space used by the arena.
+  virtual void OnDestroy(uint64_t space_allocated) = 0;
+
+  // OnReset() is called when the associated arena is reset.
+  // space_allocated is the space used by the arena just before the reset.
+  virtual void OnReset(uint64_t space_allocated) = 0;
+
+  // OnAlloc is called when an allocation happens.
+  // type_info is promised to be static - its lifetime extends to
+  // match program's lifetime (It is given by typeid operator).
+  // Note: typeid(void) will be passed as allocated_type every time we
+  // intentionally want to avoid monitoring an allocation. (i.e. internal
+  // allocations for managing the arena)
+  virtual void OnAlloc(const std::type_info* allocated_type,
+                       uint64_t alloc_size) = 0;
+
+  // Does OnAlloc() need to be called?  If false, metric collection overhead
+  // will be reduced since we will not do extra work per allocation.
+  bool RecordAllocs() { return record_allocs_; }
+
+ protected:
+  // This class is destructed by the call to OnDestroy().
+  ~ArenaMetricsCollector() = default;
+  const bool record_allocs_;
+};
+
+struct AllocationPolicy {
+  static constexpr size_t kDefaultStartBlockSize = 256;
+  static constexpr size_t kDefaultMaxBlockSize = 8192;
+
+  size_t start_block_size = kDefaultStartBlockSize;
+  size_t max_block_size = kDefaultMaxBlockSize;
+  void* (*block_alloc)(size_t) = nullptr;
+  void (*block_dealloc)(void*, size_t) = nullptr;
+  ArenaMetricsCollector* metrics_collector = nullptr;
+
+  bool IsDefault() const {
+    return start_block_size == kDefaultMaxBlockSize &&
+           max_block_size == kDefaultMaxBlockSize && block_alloc == nullptr &&
+           block_dealloc == nullptr && metrics_collector == nullptr;
+  }
+};
+
+// Tagged pointer to an AllocationPolicy.
+class TaggedAllocationPolicyPtr {
+ public:
+  constexpr TaggedAllocationPolicyPtr() : policy_(0) {}
+
+  explicit TaggedAllocationPolicyPtr(AllocationPolicy* policy)
+      : policy_(reinterpret_cast<uintptr_t>(policy)) {}
+
+  void set_policy(AllocationPolicy* policy) {
+    auto bits = policy_ & kTagsMask;
+    policy_ = reinterpret_cast<uintptr_t>(policy) | bits;
+  }
+
+  AllocationPolicy* get() {
+    return reinterpret_cast<AllocationPolicy*>(policy_ & kPtrMask);
+  }
+  const AllocationPolicy* get() const {
+    return reinterpret_cast<const AllocationPolicy*>(policy_ & kPtrMask);
+  }
+
+  AllocationPolicy& operator*() { return *get(); }
+  const AllocationPolicy& operator*() const { return *get(); }
+
+  AllocationPolicy* operator->() { return get(); }
+  const AllocationPolicy* operator->() const { return get(); }
+
+  bool is_user_owned_initial_block() const {
+    return static_cast<bool>(get_mask<kUserOwnedInitialBlock>());
+  }
+  void set_is_user_owned_initial_block(bool v) {
+    set_mask<kUserOwnedInitialBlock>(v);
+  }
+
+  bool should_record_allocs() const {
+    return static_cast<bool>(get_mask<kRecordAllocs>());
+  }
+  void set_should_record_allocs(bool v) { set_mask<kRecordAllocs>(v); }
+
+  uintptr_t get_raw() const { return policy_; }
+
+  inline void RecordAlloc(const std::type_info* allocated_type,
+                          size_t n) const {
+    get()->metrics_collector->OnAlloc(allocated_type, n);
+  }
+
+ private:
+  enum : uintptr_t {
+    kUserOwnedInitialBlock = 1,
+    kRecordAllocs = 2,
+  };
+
+  static constexpr uintptr_t kTagsMask = 7;
+  static constexpr uintptr_t kPtrMask = ~kTagsMask;
+
+  template <uintptr_t kMask>
+  uintptr_t get_mask() const {
+    return policy_ & kMask;
+  }
+  template <uintptr_t kMask>
+  void set_mask(bool v) {
+    if (v) {
+      policy_ |= kMask;
+    } else {
+      policy_ &= ~kMask;
+    }
+  }
+  uintptr_t policy_;
+};
+
+enum class AllocationClient { kDefault, kArray };
+
+// A simple arena allocator. Calls to allocate functions must be properly
+// serialized by the caller, hence this class cannot be used as a general
+// purpose allocator in a multi-threaded program. It serves as a building block
+// for ThreadSafeArena, which provides a thread-safe arena allocator.
+//
+// This class manages
+// 1) Arena bump allocation + owning memory blocks.
+// 2) Maintaining a cleanup list.
+// It delagetes the actual memory allocation back to ThreadSafeArena, which
+// contains the information on block growth policy and backing memory allocation
+// used.
+class PROTOBUF_EXPORT SerialArena {
+ public:
+  struct Memory {
+    void* ptr;
+    size_t size;
+  };
+
+  // Node contains the ptr of the object to be cleaned up and the associated
+  // cleanup function ptr.
+  struct CleanupNode {
+    void* elem;              // Pointer to the object to be cleaned up.
+    void (*cleanup)(void*);  // Function pointer to the destructor or deleter.
+  };
+
+  void CleanupList();
+  uint64_t SpaceAllocated() const {
+    return space_allocated_.load(std::memory_order_relaxed);
+  }
+  uint64_t SpaceUsed() const;
+
+  bool HasSpace(size_t n) const {
+    return n <= static_cast<size_t>(limit_ - ptr_);
+  }
+
+  // See comments on `cached_blocks_` member for details.
+  PROTOBUF_ALWAYS_INLINE void* TryAllocateFromCachedBlock(size_t size) {
+    if (PROTOBUF_PREDICT_FALSE(size < 16)) return nullptr;
+    // We round up to the next larger block in case the memory doesn't match
+    // the pattern we are looking for.
+    const size_t index = Bits::Log2FloorNonZero64(size - 1) - 3;
+
+    if (index >= cached_block_length_) return nullptr;
+    auto& cached_head = cached_blocks_[index];
+    if (cached_head == nullptr) return nullptr;
+
+    void* ret = cached_head;
+#ifdef ADDRESS_SANITIZER
+    ASAN_UNPOISON_MEMORY_REGION(ret, size);
+#endif  // ADDRESS_SANITIZER
+    cached_head = cached_head->next;
+    return ret;
+  }
+
+  // In kArray mode we look through cached blocks.
+  // We do not do this by default because most non-array allocations will not
+  // have the right size and will fail to find an appropriate cached block.
+  //
+  // TODO(sbenza): Evaluate if we should use cached blocks for message types of
+  // the right size. We can statically know if the allocation size can benefit
+  // from it.
+  template <AllocationClient alloc_client = AllocationClient::kDefault>
+  void* AllocateAligned(size_t n, const AllocationPolicy* policy) {
+    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
+    GOOGLE_DCHECK_GE(limit_, ptr_);
+
+    if (alloc_client == AllocationClient::kArray) {
+      if (void* res = TryAllocateFromCachedBlock(n)) {
+        return res;
+      }
+    }
+
+    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n))) {
+      return AllocateAlignedFallback(n, policy);
+    }
+    return AllocateFromExisting(n);
+  }
+
+ private:
+  void* AllocateFromExisting(size_t n) {
+    void* ret = ptr_;
+    ptr_ += n;
+#ifdef ADDRESS_SANITIZER
+    ASAN_UNPOISON_MEMORY_REGION(ret, n);
+#endif  // ADDRESS_SANITIZER
+    return ret;
+  }
+
+  // See comments on `cached_blocks_` member for details.
+  void ReturnArrayMemory(void* p, size_t size) {
+    // We only need to check for 32-bit platforms.
+    // In 64-bit platforms the minimum allocation size from Repeated*Field will
+    // be 16 guaranteed.
+    if (sizeof(void*) < 8) {
+      if (PROTOBUF_PREDICT_FALSE(size < 16)) return;
+    } else {
+      GOOGLE_DCHECK(size >= 16);
+    }
+
+    // We round down to the next smaller block in case the memory doesn't match
+    // the pattern we are looking for. eg, someone might have called Reserve()
+    // on the repeated field.
+    const size_t index = Bits::Log2FloorNonZero64(size) - 4;
+
+    if (PROTOBUF_PREDICT_FALSE(index >= cached_block_length_)) {
+      // We can't put this object on the freelist so make this object the
+      // freelist. It is guaranteed it is larger than the one we have, and
+      // large enough to hold another allocation of `size`.
+      CachedBlock** new_list = static_cast<CachedBlock**>(p);
+      size_t new_size = size / sizeof(CachedBlock*);
+
+      std::copy(cached_blocks_, cached_blocks_ + cached_block_length_,
+                new_list);
+      std::fill(new_list + cached_block_length_, new_list + new_size, nullptr);
+      cached_blocks_ = new_list;
+      // Make the size fit in uint8_t. This is the power of two, so we don't
+      // need anything larger.
+      cached_block_length_ =
+          static_cast<uint8_t>(std::min(size_t{64}, new_size));
+
+      return;
+    }
+
+    auto& cached_head = cached_blocks_[index];
+    auto* new_node = static_cast<CachedBlock*>(p);
+    new_node->next = cached_head;
+    cached_head = new_node;
+#ifdef ADDRESS_SANITIZER
+    ASAN_POISON_MEMORY_REGION(p, size);
+#endif  // ADDRESS_SANITIZER
+  }
+
+ public:
+  // Allocate space if the current region provides enough space.
+  bool MaybeAllocateAligned(size_t n, void** out) {
+    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
+    GOOGLE_DCHECK_GE(limit_, ptr_);
+    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n))) return false;
+    *out = AllocateFromExisting(n);
+    return true;
+  }
+
+  std::pair<void*, CleanupNode*> AllocateAlignedWithCleanup(
+      size_t n, const AllocationPolicy* policy) {
+    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
+    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n + kCleanupSize))) {
+      return AllocateAlignedWithCleanupFallback(n, policy);
+    }
+    return AllocateFromExistingWithCleanupFallback(n);
+  }
+
+ private:
+  std::pair<void*, CleanupNode*> AllocateFromExistingWithCleanupFallback(
+      size_t n) {
+    void* ret = ptr_;
+    ptr_ += n;
+    limit_ -= kCleanupSize;
+#ifdef ADDRESS_SANITIZER
+    ASAN_UNPOISON_MEMORY_REGION(ret, n);
+    ASAN_UNPOISON_MEMORY_REGION(limit_, kCleanupSize);
+#endif  // ADDRESS_SANITIZER
+    return CreatePair(ret, reinterpret_cast<CleanupNode*>(limit_));
+  }
+
+ public:
+  void AddCleanup(void* elem, void (*cleanup)(void*),
+                  const AllocationPolicy* policy) {
+    auto res = AllocateAlignedWithCleanup(0, policy);
+    res.second->elem = elem;
+    res.second->cleanup = cleanup;
+  }
+
+  void* owner() const { return owner_; }
+  SerialArena* next() const { return next_; }
+  void set_next(SerialArena* next) { next_ = next; }
+
+ private:
+  friend class ThreadSafeArena;
+  friend class ArenaBenchmark;
+
+  // Creates a new SerialArena inside mem using the remaining memory as for
+  // future allocations.
+  static SerialArena* New(SerialArena::Memory mem, void* owner,
+                          ThreadSafeArenaStats* stats);
+  // Free SerialArena returning the memory passed in to New
+  template <typename Deallocator>
+  Memory Free(Deallocator deallocator);
+
+  // Blocks are variable length malloc-ed objects.  The following structure
+  // describes the common header for all blocks.
+  struct Block {
+    Block(Block* next, size_t size) : next(next), size(size), start(nullptr) {}
+
+    char* Pointer(size_t n) {
+      GOOGLE_DCHECK(n <= size);
+      return reinterpret_cast<char*>(this) + n;
+    }
+
+    Block* const next;
+    const size_t size;
+    CleanupNode* start;
+    // data follows
+  };
+
+  void* owner_;            // &ThreadCache of this thread;
+  Block* head_;            // Head of linked list of blocks.
+  SerialArena* next_;      // Next SerialArena in this linked list.
+  size_t space_used_ = 0;  // Necessary for metrics.
+  std::atomic<size_t> space_allocated_;
+
+  // Next pointer to allocate from.  Always 8-byte aligned.  Points inside
+  // head_ (and head_->pos will always be non-canonical).  We keep these
+  // here to reduce indirection.
+  char* ptr_;
+  // Limiting address up to which memory can be allocated from the head block.
+  char* limit_;
+  // For holding sampling information.  The pointer is owned by the
+  // ThreadSafeArena that holds this serial arena.
+  ThreadSafeArenaStats* arena_stats_;
+
+  // Repeated*Field and Arena play together to reduce memory consumption by
+  // reusing blocks. Currently, natural growth of the repeated field types makes
+  // them allocate blocks of size `8 + 2^N, N>=3`.
+  // When the repeated field grows returns the previous block and we put it in
+  // this free list.
+  // `cached_blocks_[i]` points to the free list for blocks of size `8+2^(i+3)`.
+  // The array of freelists is grown when needed in `ReturnArrayMemory()`.
+  struct CachedBlock {
+    // Simple linked list.
+    CachedBlock* next;
+  };
+  uint8_t cached_block_length_ = 0;
+  CachedBlock** cached_blocks_ = nullptr;
+
+  // Constructor is private as only New() should be used.
+  inline SerialArena(Block* b, void* owner, ThreadSafeArenaStats* stats);
+  void* AllocateAlignedFallback(size_t n, const AllocationPolicy* policy);
+  std::pair<void*, CleanupNode*> AllocateAlignedWithCleanupFallback(
+      size_t n, const AllocationPolicy* policy);
+  void AllocateNewBlock(size_t n, const AllocationPolicy* policy);
+
+  std::pair<void*, CleanupNode*> CreatePair(void* ptr, CleanupNode* node) {
+    return {ptr, node};
+  }
+
+ public:
+  static constexpr size_t kBlockHeaderSize = AlignUpTo8(sizeof(Block));
+  static constexpr size_t kCleanupSize = AlignUpTo8(sizeof(CleanupNode));
+};
+
+// Tag type used to invoke the constructor of message-owned arena.
+// Only message-owned arenas use this constructor for creation.
+// Such constructors are internal implementation details of the library.
+struct MessageOwned {
+  explicit MessageOwned() = default;
+};
+
+// This class provides the core Arena memory allocation library. Different
+// implementations only need to implement the public interface below.
+// Arena is not a template type as that would only be useful if all protos
+// in turn would be templates, which will/cannot happen. However separating
+// the memory allocation part from the cruft of the API users expect we can
+// use #ifdef the select the best implementation based on hardware / OS.
+class PROTOBUF_EXPORT ThreadSafeArena {
+ public:
+  ThreadSafeArena() { Init(); }
+
+  // Constructor solely used by message-owned arena.
+  ThreadSafeArena(internal::MessageOwned) : tag_and_id_(kMessageOwnedArena) {
+    Init();
+  }
+
+  ThreadSafeArena(char* mem, size_t size) { InitializeFrom(mem, size); }
+
+  explicit ThreadSafeArena(void* mem, size_t size,
+                           const AllocationPolicy& policy) {
+    InitializeWithPolicy(mem, size, policy);
+  }
+
+  // Destructor deletes all owned heap allocated objects, and destructs objects
+  // that have non-trivial destructors, except for proto2 message objects whose
+  // destructors can be skipped. Also, frees all blocks except the initial block
+  // if it was passed in.
+  ~ThreadSafeArena();
+
+  uint64_t Reset();
+
+  uint64_t SpaceAllocated() const;
+  uint64_t SpaceUsed() const;
+
+  template <AllocationClient alloc_client = AllocationClient::kDefault>
+  void* AllocateAligned(size_t n, const std::type_info* type) {
+    SerialArena* arena;
+    if (PROTOBUF_PREDICT_TRUE(!alloc_policy_.should_record_allocs() &&
+                              GetSerialArenaFast(&arena))) {
+      return arena->AllocateAligned<alloc_client>(n, AllocPolicy());
+    } else {
+      return AllocateAlignedFallback(n, type);
+    }
+  }
+
+  void ReturnArrayMemory(void* p, size_t size) {
+    SerialArena* arena;
+    if (PROTOBUF_PREDICT_TRUE(GetSerialArenaFast(&arena))) {
+      arena->ReturnArrayMemory(p, size);
+    }
+  }
+
+  // This function allocates n bytes if the common happy case is true and
+  // returns true. Otherwise does nothing and returns false. This strange
+  // semantics is necessary to allow callers to program functions that only
+  // have fallback function calls in tail position. This substantially improves
+  // code for the happy path.
+  PROTOBUF_NDEBUG_INLINE bool MaybeAllocateAligned(size_t n, void** out) {
+    SerialArena* arena;
+    if (PROTOBUF_PREDICT_TRUE(!alloc_policy_.should_record_allocs() &&
+                              GetSerialArenaFromThreadCache(&arena))) {
+      return arena->MaybeAllocateAligned(n, out);
+    }
+    return false;
+  }
+
+  std::pair<void*, SerialArena::CleanupNode*> AllocateAlignedWithCleanup(
+      size_t n, const std::type_info* type);
+
+  // Add object pointer and cleanup function pointer to the list.
+  void AddCleanup(void* elem, void (*cleanup)(void*));
+
+  // Checks whether this arena is message-owned.
+  PROTOBUF_ALWAYS_INLINE bool IsMessageOwned() const {
+    return tag_and_id_ & kMessageOwnedArena;
+  }
+
+ private:
+  // Unique for each arena. Changes on Reset().
+  uint64_t tag_and_id_ = 0;
+  // The LSB of tag_and_id_ indicates if the arena is message-owned.
+  enum : uint64_t { kMessageOwnedArena = 1 };
+
+  TaggedAllocationPolicyPtr alloc_policy_;  // Tagged pointer to AllocPolicy.
+
+  static_assert(std::is_trivially_destructible<SerialArena>{},
+                "SerialArena needs to be trivially destructible.");
+  // Pointer to a linked list of SerialArena.
+  std::atomic<SerialArena*> threads_;
+  std::atomic<SerialArena*> hint_;  // Fast thread-local block access
+
+  const AllocationPolicy* AllocPolicy() const { return alloc_policy_.get(); }
+  void InitializeFrom(void* mem, size_t size);
+  void InitializeWithPolicy(void* mem, size_t size, AllocationPolicy policy);
+  void* AllocateAlignedFallback(size_t n, const std::type_info* type);
+  std::pair<void*, SerialArena::CleanupNode*>
+  AllocateAlignedWithCleanupFallback(size_t n, const std::type_info* type);
+
+  void Init();
+  void SetInitialBlock(void* mem, size_t size);
+
+  // Delete or Destruct all objects owned by the arena.
+  void CleanupList();
+
+  inline uint64_t LifeCycleId() const {
+    return tag_and_id_ & ~kMessageOwnedArena;
+  }
+
+  inline void CacheSerialArena(SerialArena* serial) {
+    thread_cache().last_serial_arena = serial;
+    thread_cache().last_lifecycle_id_seen = tag_and_id_;
+    // TODO(haberman): evaluate whether we would gain efficiency by getting rid
+    // of hint_.  It's the only write we do to ThreadSafeArena in the allocation
+    // path, which will dirty the cache line.
+
+    hint_.store(serial, std::memory_order_release);
+  }
+
+  PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFast(SerialArena** arena) {
+    if (GetSerialArenaFromThreadCache(arena)) return true;
+
+    // Check whether we own the last accessed SerialArena on this arena.  This
+    // fast path optimizes the case where a single thread uses multiple arenas.
+    ThreadCache* tc = &thread_cache();
+    SerialArena* serial = hint_.load(std::memory_order_acquire);
+    if (PROTOBUF_PREDICT_TRUE(serial != nullptr && serial->owner() == tc)) {
+      *arena = serial;
+      return true;
+    }
+    return false;
+  }
+
+  PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFromThreadCache(
+      SerialArena** arena) {
+    // If this thread already owns a block in this arena then try to use that.
+    // This fast path optimizes the case where multiple threads allocate from
+    // the same arena.
+    ThreadCache* tc = &thread_cache();
+    if (PROTOBUF_PREDICT_TRUE(tc->last_lifecycle_id_seen == tag_and_id_)) {
+      *arena = tc->last_serial_arena;
+      return true;
+    }
+    return false;
+  }
+  SerialArena* GetSerialArenaFallback(void* me);
+
+  template <typename Functor>
+  void PerSerialArena(Functor fn) {
+    // By omitting an Acquire barrier we ensure that any user code that doesn't
+    // properly synchronize Reset() or the destructor will throw a TSAN warning.
+    SerialArena* serial = threads_.load(std::memory_order_relaxed);
+
+    for (; serial; serial = serial->next()) fn(serial);
+  }
+
+  // Releases all memory except the first block which it returns. The first
+  // block might be owned by the user and thus need some extra checks before
+  // deleting.
+  SerialArena::Memory Free(size_t* space_allocated);
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4324)
+#endif
+  struct alignas(kCacheAlignment) ThreadCache {
+#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
+    // If we are using the ThreadLocalStorage class to store the ThreadCache,
+    // then the ThreadCache's default constructor has to be responsible for
+    // initializing it.
+    ThreadCache()
+        : next_lifecycle_id(0),
+          last_lifecycle_id_seen(-1),
+          last_serial_arena(nullptr) {}
+#endif
+
+    // Number of per-thread lifecycle IDs to reserve. Must be power of two.
+    // To reduce contention on a global atomic, each thread reserves a batch of
+    // IDs.  The following number is calculated based on a stress test with
+    // ~6500 threads all frequently allocating a new arena.
+    static constexpr size_t kPerThreadIds = 256;
+    // Next lifecycle ID available to this thread. We need to reserve a new
+    // batch, if `next_lifecycle_id & (kPerThreadIds - 1) == 0`.
+    uint64_t next_lifecycle_id;
+    // The ThreadCache is considered valid as long as this matches the
+    // lifecycle_id of the arena being used.
+    uint64_t last_lifecycle_id_seen;
+    SerialArena* last_serial_arena;
+  };
+
+  // Lifecycle_id can be highly contended variable in a situation of lots of
+  // arena creation. Make sure that other global variables are not sharing the
+  // cacheline.
+#ifdef _MSC_VER
+#pragma warning(disable : 4324)
+#endif
+  struct alignas(kCacheAlignment) CacheAlignedLifecycleIdGenerator {
+    std::atomic<LifecycleIdAtomic> id;
+  };
+  static CacheAlignedLifecycleIdGenerator lifecycle_id_generator_;
+#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
+  // iOS does not support __thread keyword so we use a custom thread local
+  // storage class we implemented.
+  static ThreadCache& thread_cache();
+#elif defined(PROTOBUF_USE_DLLS)
+  // Thread local variables cannot be exposed through DLL interface but we can
+  // wrap them in static functions.
+  static ThreadCache& thread_cache();
+#else
+  static PROTOBUF_THREAD_LOCAL ThreadCache thread_cache_;
+  static ThreadCache& thread_cache() { return thread_cache_; }
+#endif
+
+  ThreadSafeArenaStatsHandle arena_stats_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadSafeArena);
+  // All protos have pointers back to the arena hence Arena must have
+  // pointer stability.
+  ThreadSafeArena(ThreadSafeArena&&) = delete;
+  ThreadSafeArena& operator=(ThreadSafeArena&&) = delete;
+
+ public:
+  // kBlockHeaderSize is sizeof(Block), aligned up to the nearest multiple of 8
+  // to protect the invariant that pos is always at a multiple of 8.
+  static constexpr size_t kBlockHeaderSize = SerialArena::kBlockHeaderSize;
+  static constexpr size_t kSerialArenaSize =
+      (sizeof(SerialArena) + 7) & static_cast<size_t>(-8);
+  static_assert(kBlockHeaderSize % 8 == 0,
+                "kBlockHeaderSize must be a multiple of 8.");
+  static_assert(kSerialArenaSize % 8 == 0,
+                "kSerialArenaSize must be a multiple of 8.");
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_ARENA_IMPL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/arenastring.h b/CAPI/cpp/grpc/include/google/protobuf/arenastring.h
new file mode 100644
index 0000000..6bc8395
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/arenastring.h
@@ -0,0 +1,480 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_ARENASTRING_H__
+#define GOOGLE_PROTOBUF_ARENASTRING_H__
+
+#include <algorithm>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/explicitly_constructed.h>
+
+// must be last:
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+
+namespace google {
+namespace protobuf {
+namespace internal {
+class EpsCopyInputStream;
+
+class SwapFieldHelper;
+
+// Declared in message_lite.h
+PROTOBUF_EXPORT extern ExplicitlyConstructedArenaString
+    fixed_address_empty_string;
+
+// Lazy string instance to support string fields with non-empty default.
+// These are initialized on the first call to .get().
+class PROTOBUF_EXPORT LazyString {
+ public:
+  // We explicitly make LazyString an aggregate so that MSVC can do constant
+  // initialization on it without marking it `constexpr`.
+  // We do not want to use `constexpr` because it makes it harder to have extern
+  // storage for it and causes library bloat.
+  struct InitValue {
+    const char* ptr;
+    size_t size;
+  };
+  // We keep a union of the initialization value and the std::string to save on
+  // space. We don't need the string array after Init() is done.
+  union {
+    mutable InitValue init_value_;
+    alignas(std::string) mutable char string_buf_[sizeof(std::string)];
+  };
+  mutable std::atomic<const std::string*> inited_;
+
+  const std::string& get() const {
+    // This check generates less code than a call-once invocation.
+    auto* res = inited_.load(std::memory_order_acquire);
+    if (PROTOBUF_PREDICT_FALSE(res == nullptr)) return Init();
+    return *res;
+  }
+
+ private:
+  // Initialize the string in `string_buf_`, update `inited_` and return it.
+  // We return it here to avoid having to read it again in the inlined code.
+  const std::string& Init() const;
+};
+
+class TaggedStringPtr {
+ public:
+  // Bit flags qualifying string properties. We can use 2 bits as
+  // ptr_ is guaranteed and enforced to be aligned on 4 byte boundaries.
+  enum Flags {
+    kArenaBit = 0x1,      // ptr is arena allocated
+    kMutableBit = 0x2,    // ptr contents are fully mutable
+    kMask = 0x3           // Bit mask
+  };
+
+  // Composed logical types
+  enum Type {
+    // Default strings are immutable and never owned.
+    kDefault = 0,
+
+    // Allocated strings are mutable and (as the name implies) owned.
+    // A heap allocated string must be deleted.
+    kAllocated = kMutableBit,
+
+    // Mutable arena strings are strings where the string instance is owned
+    // by the arena, but the string contents itself are owned by the string
+    // instance. Mutable arena string instances need to be destroyed which is
+    // typically done through a cleanup action added to the arena owning it.
+    kMutableArena = kArenaBit | kMutableBit,
+
+    // Fixed size arena strings are strings where both the string instance and
+    // the string contents are fully owned by the arena. Fixed size arena
+    // strings are a platform and c++ library specific customization. Fixed
+    // size arena strings are immutable, with the exception of custom internal
+    // updates to the content that fit inside the existing capacity.
+    // Fixed size arena strings must never be deleted or destroyed.
+    kFixedSizeArena = kArenaBit,
+  };
+
+  TaggedStringPtr() = default;
+  explicit constexpr TaggedStringPtr(ExplicitlyConstructedArenaString* ptr)
+      : ptr_(ptr) {}
+
+  // Sets the value to `p`, tagging the value as being a 'default' value.
+  // See documentation for kDefault for more info.
+  inline const std::string* SetDefault(const std::string* p) {
+    return TagAs(kDefault, const_cast<std::string*>(p));
+  }
+
+  // Sets the value to `p`, tagging the value as a heap allocated value.
+  // Allocated strings are mutable and (as the name implies) owned.
+  // `p` must not be null
+  inline std::string* SetAllocated(std::string* p) {
+    return TagAs(kAllocated, p);
+  }
+
+  // Sets the value to `p`, tagging the value as a fixed size arena string.
+  // See documentation for kFixedSizeArena for more info.
+  // `p` must not be null
+  inline std::string* SetFixedSizeArena(std::string* p) {
+    return TagAs(kFixedSizeArena, p);
+  }
+
+  // Sets the value to `p`, tagging the value as a mutable arena string.
+  // See documentation for kMutableArena for more info.
+  // `p` must not be null
+  inline std::string* SetMutableArena(std::string* p) {
+    return TagAs(kMutableArena, p);
+  }
+
+  // Returns true if the contents of the current string are fully mutable.
+  inline bool IsMutable() const { return as_int() & kMutableBit; }
+
+  // Returns true if the current string is an immutable default value.
+  inline bool IsDefault() const { return (as_int() & kMask) == kDefault; }
+
+  // If the current string is a heap-allocated mutable value, returns a pointer
+  // to it.  Returns nullptr otherwise.
+  inline std::string *GetIfAllocated() const {
+    auto allocated = as_int() ^ kAllocated;
+    if (allocated & kMask) return nullptr;
+
+    auto ptr = reinterpret_cast<std::string*>(allocated);
+    PROTOBUF_ASSUME(ptr != nullptr);
+    return ptr;
+  }
+
+  // Returns true if the current string is an arena allocated value.
+  // This means it's either a mutable or fixed size arena string.
+  inline bool IsArena() const { return as_int() & kArenaBit; }
+
+  // Returns true if the current string is a fixed size arena allocated value.
+  inline bool IsFixedSizeArena() const {
+    return (as_int() & kMask) == kFixedSizeArena;
+  }
+
+  // Returns the contained string pointer.
+  inline std::string* Get() const {
+    return reinterpret_cast<std::string*>(as_int() & ~kMask);
+  }
+
+  // Returns true if the contained pointer is null, indicating some error.
+  // The Null value is only used during parsing for temporary values.
+  // A persisted ArenaStringPtr value is never null.
+  inline bool IsNull() { return ptr_ == nullptr; }
+
+ private:
+  static inline void assert_aligned(const void* p) {
+    GOOGLE_DCHECK_EQ(reinterpret_cast<uintptr_t>(p) & kMask, 0UL);
+  }
+
+  inline std::string* TagAs(Type type, std::string* p) {
+    GOOGLE_DCHECK(p != nullptr);
+    assert_aligned(p);
+    ptr_ = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(p) | type);
+    return p;
+  }
+
+  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
+  void* ptr_;
+};
+
+static_assert(std::is_trivial<TaggedStringPtr>::value,
+              "TaggedStringPtr must be trivial");
+
+// This class encapsulates a pointer to a std::string with or without arena
+// owned contents, tagged by the bottom bits of the string pointer. It is a
+// high-level wrapper that almost directly corresponds to the interface required
+// by string fields in generated code. It replaces the old std::string* pointer
+// in such cases.
+//
+// The string pointer is tagged to be either a default, externally owned value,
+// a mutable heap allocated value, or an arena allocated value. The object uses
+// a single global instance of an empty string that is used as the initial
+// default value. Fields that have empty default values directly use this global
+// default. Fields that have non empty default values are supported through
+// lazily initialized default values managed by the LazyString class.
+//
+// Generated code and reflection code both ensure that ptr_ is never null.
+// Because ArenaStringPtr is used in oneof unions, its constructor is a NOP and
+// the field is always manually initialized via method calls.
+//
+// See TaggedStringPtr for more information about the types of string values
+// being held, and the mutable and ownership invariants for each type.
+struct PROTOBUF_EXPORT ArenaStringPtr {
+  ArenaStringPtr() = default;
+  constexpr ArenaStringPtr(ExplicitlyConstructedArenaString* default_value,
+                           ConstantInitialized)
+      : tagged_ptr_(default_value) {}
+
+  // Called from generated code / reflection runtime only. Resets value to point
+  // to a default string pointer, with the semantics that this ArenaStringPtr
+  // does not own the pointed-to memory. Disregards initial value of ptr_ (so
+  // this is the *ONLY* safe method to call after construction or when
+  // reinitializing after becoming the active field in a oneof union).
+  inline void InitDefault();
+
+  // Similar to `InitDefault` except that it allows the default value to be
+  // initialized to an externally owned string. This method is called from
+  // parsing code. `str` must not be null and outlive this instance.
+  inline void InitExternal(const std::string* str);
+
+  // Called from generated code / reflection runtime only. Resets the value of
+  // this instances to the heap allocated value in `str`. `str` must not be
+  // null. Invokes `arena->Own(str)` to transfer ownership into the arena if
+  // `arena` is not null, else, `str` will be owned by ArenaStringPtr. This
+  // function should only be used to initialize a ArenaStringPtr or on an
+  // instance known to not carry any heap allocated value.
+  inline void InitAllocated(std::string* str, Arena* arena);
+
+  void Set(ConstStringParam value, Arena* arena);
+  void Set(std::string&& value, Arena* arena);
+  void Set(const char* s, Arena* arena);
+  void Set(const char* s, size_t n, Arena* arena);
+
+  void SetBytes(ConstStringParam value, Arena* arena);
+  void SetBytes(std::string&& value, Arena* arena);
+  void SetBytes(const char* s, Arena* arena);
+  void SetBytes(const void* p, size_t n, Arena* arena);
+
+  template <typename RefWrappedType>
+  void Set(std::reference_wrapper<RefWrappedType> const_string_ref,
+           ::google::protobuf::Arena* arena) {
+    Set(const_string_ref.get(), arena);
+  }
+
+  // Returns a mutable std::string reference.
+  // The version accepting a `LazyString` value is used in the generated code to
+  // initialize mutable copies for fields with a non-empty default where the
+  // default value is lazily initialized.
+  std::string* Mutable(Arena* arena);
+  std::string* Mutable(const LazyString& default_value, Arena* arena);
+
+  // Gets a mutable pointer with unspecified contents.
+  // This function is identical to Mutable(), except it is optimized for the
+  // case where the caller is not interested in the current contents. For
+  // example, if the current field is not mutable, it will re-initialize the
+  // value with an empty string rather than a (non-empty) default value.
+  // Likewise, if the current value is a fixed size arena string with contents,
+  // it will be initialized into an empty mutable arena string.
+  std::string* MutableNoCopy(Arena* arena);
+
+  // Basic accessors.
+  PROTOBUF_NDEBUG_INLINE const std::string& Get() const {
+    // Unconditionally mask away the tag.
+    return *tagged_ptr_.Get();
+  }
+
+  // Returns a pointer to the stored contents for this instance.
+  // This method is for internal debugging and tracking purposes only.
+  PROTOBUF_NDEBUG_INLINE const std::string* UnsafeGetPointer() const
+      PROTOBUF_RETURNS_NONNULL {
+    return tagged_ptr_.Get();
+  }
+
+  // Release returns a std::string* instance that is heap-allocated and is not
+  // Own()'d by any arena. If the field is not set, this returns nullptr. The
+  // caller retains ownership. Clears this field back to the default state.
+  // Used to implement release_<field>() methods on generated classes.
+  PROTOBUF_NODISCARD std::string* Release();
+
+  // Takes a std::string that is heap-allocated, and takes ownership. The
+  // std::string's destructor is registered with the arena. Used to implement
+  // set_allocated_<field> in generated classes.
+  void SetAllocated(std::string* value, Arena* arena);
+
+  // Frees storage (if not on an arena).
+  void Destroy();
+
+  // Clears content, but keeps allocated std::string, to avoid the overhead of
+  // heap operations. After this returns, the content (as seen by the user) will
+  // always be the empty std::string. Assumes that |default_value| is an empty
+  // std::string.
+  void ClearToEmpty();
+
+  // Clears content, assuming that the current value is not the empty
+  // string default.
+  void ClearNonDefaultToEmpty();
+
+  // Clears content, but keeps allocated std::string if arena != nullptr, to
+  // avoid the overhead of heap operations. After this returns, the content
+  // (as seen by the user) will always be equal to |default_value|.
+  void ClearToDefault(const LazyString& default_value, ::google::protobuf::Arena* arena);
+
+  // Swaps internal pointers. Arena-safety semantics: this is guarded by the
+  // logic in Swap()/UnsafeArenaSwap() at the message level, so this method is
+  // 'unsafe' if called directly.
+  inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(ArenaStringPtr* rhs,
+                                                         Arena* rhs_arena,
+                                                         ArenaStringPtr* lhs,
+                                                         Arena* lhs_arena);
+
+  // Internal setter used only at parse time to directly set a donated string
+  // value.
+  void UnsafeSetTaggedPointer(TaggedStringPtr value) { tagged_ptr_ = value; }
+  // Generated code only! An optimization, in certain cases the generated
+  // code is certain we can obtain a std::string with no default checks and
+  // tag tests.
+  std::string* UnsafeMutablePointer() PROTOBUF_RETURNS_NONNULL;
+
+  // Returns true if this instances holds an immutable default value.
+  inline bool IsDefault() const { return tagged_ptr_.IsDefault(); }
+
+ private:
+  template <typename... Args>
+  inline std::string* NewString(Arena* arena, Args&&... args) {
+    if (arena == nullptr) {
+      auto* s = new std::string(std::forward<Args>(args)...);
+      return tagged_ptr_.SetAllocated(s);
+    } else {
+      auto* s = Arena::Create<std::string>(arena, std::forward<Args>(args)...);
+      return tagged_ptr_.SetMutableArena(s);
+    }
+  }
+
+  TaggedStringPtr tagged_ptr_;
+
+  bool IsFixedSizeArena() const { return false; }
+
+  // Swaps tagged pointer without debug hardening. This is to allow python
+  // protobuf to maintain pointer stability even in DEBUG builds.
+  inline PROTOBUF_NDEBUG_INLINE static void UnsafeShallowSwap(
+      ArenaStringPtr* rhs, ArenaStringPtr* lhs) {
+    std::swap(lhs->tagged_ptr_, rhs->tagged_ptr_);
+  }
+
+  friend class ::google::protobuf::internal::SwapFieldHelper;
+  friend class TcParser;
+
+  // Slow paths.
+
+  // MutableSlow requires that !IsString() || IsDefault
+  // Variadic to support 0 args for empty default and 1 arg for LazyString.
+  template <typename... Lazy>
+  std::string* MutableSlow(::google::protobuf::Arena* arena, const Lazy&... lazy_default);
+
+  friend class EpsCopyInputStream;
+};
+
+inline void ArenaStringPtr::InitDefault() {
+  tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string);
+}
+
+inline void ArenaStringPtr::InitExternal(const std::string* str) {
+  tagged_ptr_.SetDefault(str);
+}
+
+inline void ArenaStringPtr::InitAllocated(std::string* str, Arena* arena) {
+  if (arena != nullptr) {
+    tagged_ptr_.SetMutableArena(str);
+    arena->Own(str);
+  } else {
+    tagged_ptr_.SetAllocated(str);
+  }
+}
+
+inline void ArenaStringPtr::Set(const char* s, Arena* arena) {
+  Set(ConstStringParam{s}, arena);
+}
+
+inline void ArenaStringPtr::Set(const char* s, size_t n, Arena* arena) {
+  Set(ConstStringParam{s, n}, arena);
+}
+
+inline void ArenaStringPtr::SetBytes(ConstStringParam value, Arena* arena) {
+  Set(value, arena);
+}
+
+inline void ArenaStringPtr::SetBytes(std::string&& value, Arena* arena) {
+  Set(std::move(value), arena);
+}
+
+inline void ArenaStringPtr::SetBytes(const char* s, Arena* arena) {
+  Set(s, arena);
+}
+
+inline void ArenaStringPtr::SetBytes(const void* p, size_t n, Arena* arena) {
+  Set(ConstStringParam{static_cast<const char*>(p), n}, arena);
+}
+
+// Make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
+inline PROTOBUF_NDEBUG_INLINE void ArenaStringPtr::InternalSwap(  //
+    ArenaStringPtr* rhs, Arena* rhs_arena,                        //
+    ArenaStringPtr* lhs, Arena* lhs_arena) {
+  // Silence unused variable warnings in release buildls.
+  (void)rhs_arena;
+  (void)lhs_arena;
+  std::swap(lhs->tagged_ptr_, rhs->tagged_ptr_);
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+  auto force_realloc = [](ArenaStringPtr* p, Arena* arena) {
+    if (p->IsDefault()) return;
+    std::string* old_value = p->tagged_ptr_.Get();
+    std::string* new_value =
+        p->IsFixedSizeArena()
+            ? Arena::Create<std::string>(arena, *old_value)
+            : Arena::Create<std::string>(arena, std::move(*old_value));
+    if (arena == nullptr) {
+      delete old_value;
+      p->tagged_ptr_.SetAllocated(new_value);
+    } else {
+      p->tagged_ptr_.SetMutableArena(new_value);
+    }
+  };
+  // Because, at this point, tagged_ptr_ has been swapped, arena should also be
+  // swapped.
+  force_realloc(lhs, rhs_arena);
+  force_realloc(rhs, lhs_arena);
+#endif  // PROTOBUF_FORCE_COPY_IN_SWAP
+}
+
+inline void ArenaStringPtr::ClearNonDefaultToEmpty() {
+  // Unconditionally mask away the tag.
+  tagged_ptr_.Get()->clear();
+}
+
+inline std::string* ArenaStringPtr::UnsafeMutablePointer() {
+  GOOGLE_DCHECK(tagged_ptr_.IsMutable());
+  GOOGLE_DCHECK(tagged_ptr_.Get() != nullptr);
+  return tagged_ptr_.Get();
+}
+
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_ARENASTRING_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h b/CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h
new file mode 100644
index 0000000..b04b0cc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h
@@ -0,0 +1,207 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_SRC_GOOGLE_PROTOBUF_ARENAZ_SAMPLER_H__
+#define GOOGLE_PROTOBUF_SRC_GOOGLE_PROTOBUF_ARENAZ_SAMPLER_H__
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+#if defined(PROTOBUF_ARENAZ_SAMPLE)
+struct ThreadSafeArenaStats;
+void RecordResetSlow(ThreadSafeArenaStats* info);
+void RecordAllocateSlow(ThreadSafeArenaStats* info, size_t requested,
+                        size_t allocated, size_t wasted);
+// Stores information about a sampled thread safe arena.  All mutations to this
+// *must* be made through `Record*` functions below.  All reads from this *must*
+// only occur in the callback to `ThreadSafeArenazSampler::Iterate`.
+struct ThreadSafeArenaStats
+    : public absl::profiling_internal::Sample<ThreadSafeArenaStats> {
+  // Constructs the object but does not fill in any fields.
+  ThreadSafeArenaStats();
+  ~ThreadSafeArenaStats();
+
+  // Puts the object into a clean state, fills in the logically `const` members,
+  // blocking for any readers that are currently sampling the object.
+  void PrepareForSampling() ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
+
+  // These fields are mutated by the various Record* APIs and need to be
+  // thread-safe.
+  std::atomic<int> num_allocations;
+  std::atomic<int> num_resets;
+  std::atomic<size_t> bytes_requested;
+  std::atomic<size_t> bytes_allocated;
+  std::atomic<size_t> bytes_wasted;
+  // Records the largest size an arena ever had.  Maintained across resets.
+  std::atomic<size_t> max_bytes_allocated;
+  // Bit i when set to 1 indicates that a thread with tid % 63 = i accessed the
+  // underlying arena.  The field is maintained across resets.
+  std::atomic<uint64_t> thread_ids;
+
+  // All of the fields below are set by `PrepareForSampling`, they must not
+  // be mutated in `Record*` functions.  They are logically `const` in that
+  // sense. These are guarded by init_mu, but that is not externalized to
+  // clients, who can only read them during
+  // `ThreadSafeArenazSampler::Iterate` which will hold the lock.
+  static constexpr int kMaxStackDepth = 64;
+  int32_t depth;
+  void* stack[kMaxStackDepth];
+  static void RecordAllocateStats(ThreadSafeArenaStats* info, size_t requested,
+                                  size_t allocated, size_t wasted) {
+    if (PROTOBUF_PREDICT_TRUE(info == nullptr)) return;
+    RecordAllocateSlow(info, requested, allocated, wasted);
+  }
+};
+
+ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
+void UnsampleSlow(ThreadSafeArenaStats* info);
+
+class ThreadSafeArenaStatsHandle {
+ public:
+  explicit ThreadSafeArenaStatsHandle() = default;
+  explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats* info)
+      : info_(info) {}
+
+  ~ThreadSafeArenaStatsHandle() {
+    if (PROTOBUF_PREDICT_TRUE(info_ == nullptr)) return;
+    UnsampleSlow(info_);
+  }
+
+  ThreadSafeArenaStatsHandle(ThreadSafeArenaStatsHandle&& other) noexcept
+      : info_(absl::exchange(other.info_, nullptr)) {}
+
+  ThreadSafeArenaStatsHandle& operator=(
+      ThreadSafeArenaStatsHandle&& other) noexcept {
+    if (PROTOBUF_PREDICT_FALSE(info_ != nullptr)) {
+      UnsampleSlow(info_);
+    }
+    info_ = absl::exchange(other.info_, nullptr);
+    return *this;
+  }
+
+  void RecordReset() {
+    if (PROTOBUF_PREDICT_TRUE(info_ == nullptr)) return;
+    RecordResetSlow(info_);
+  }
+
+  ThreadSafeArenaStats* MutableStats() { return info_; }
+
+  friend void swap(ThreadSafeArenaStatsHandle& lhs,
+                   ThreadSafeArenaStatsHandle& rhs) {
+    std::swap(lhs.info_, rhs.info_);
+  }
+
+  friend class ThreadSafeArenaStatsHandlePeer;
+
+ private:
+  ThreadSafeArenaStats* info_ = nullptr;
+};
+
+using ThreadSafeArenazSampler =
+    ::absl::profiling_internal::SampleRecorder<ThreadSafeArenaStats>;
+
+extern PROTOBUF_THREAD_LOCAL int64_t global_next_sample;
+
+// Returns an RAII sampling handle that manages registration and unregistation
+// with the global sampler.
+inline ThreadSafeArenaStatsHandle Sample() {
+  if (PROTOBUF_PREDICT_TRUE(--global_next_sample > 0)) {
+    return ThreadSafeArenaStatsHandle(nullptr);
+  }
+  return ThreadSafeArenaStatsHandle(SampleSlow(&global_next_sample));
+}
+
+#else
+struct ThreadSafeArenaStats {
+  static void RecordAllocateStats(ThreadSafeArenaStats*, size_t /*requested*/,
+                                  size_t /*allocated*/, size_t /*wasted*/) {}
+};
+
+ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
+void UnsampleSlow(ThreadSafeArenaStats* info);
+
+class ThreadSafeArenaStatsHandle {
+ public:
+  explicit ThreadSafeArenaStatsHandle() = default;
+  explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats*) {}
+
+  void RecordReset() {}
+
+  ThreadSafeArenaStats* MutableStats() { return nullptr; }
+
+  friend void swap(ThreadSafeArenaStatsHandle&, ThreadSafeArenaStatsHandle&) {}
+
+ private:
+  friend class ThreadSafeArenaStatsHandlePeer;
+};
+
+class ThreadSafeArenazSampler {
+ public:
+  void Unregister(ThreadSafeArenaStats*) {}
+  void SetMaxSamples(int32_t) {}
+};
+
+// Returns an RAII sampling handle that manages registration and unregistation
+// with the global sampler.
+inline ThreadSafeArenaStatsHandle Sample() {
+  return ThreadSafeArenaStatsHandle(nullptr);
+}
+#endif  // defined(PROTOBUF_ARENAZ_SAMPLE)
+
+// Returns a global Sampler.
+ThreadSafeArenazSampler& GlobalThreadSafeArenazSampler();
+
+// Enables or disables sampling for thread safe arenas.
+void SetThreadSafeArenazEnabled(bool enabled);
+
+// Sets the rate at which thread safe arena will be sampled.
+void SetThreadSafeArenazSampleParameter(int32_t rate);
+
+// Sets a soft max for the number of samples that will be kept.
+void SetThreadSafeArenazMaxSamples(int32_t max);
+
+// Sets the current value for when arenas should be next sampled.
+void SetThreadSafeArenazGlobalNextSample(int64_t next_sample);
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_SRC_PROTOBUF_ARENAZ_SAMPLER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/code_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/code_generator.h
new file mode 100644
index 0000000..9c0b115
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/code_generator.h
@@ -0,0 +1,207 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines the abstract interface implemented by each of the language-specific
+// code generators.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
+
+#include <string>
+#include <utility>
+#include <vector>
+#include <google/protobuf/stubs/common.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+namespace io {
+class ZeroCopyOutputStream;
+}
+class FileDescriptor;
+class GeneratedCodeInfo;
+
+namespace compiler {
+class AccessInfoMap;
+
+class Version;
+
+// Defined in this file.
+class CodeGenerator;
+class GeneratorContext;
+
+// The abstract interface to a class which generates code implementing a
+// particular proto file in a particular language.  A number of these may
+// be registered with CommandLineInterface to support various languages.
+class PROTOC_EXPORT CodeGenerator {
+ public:
+  inline CodeGenerator() {}
+  virtual ~CodeGenerator();
+
+  // Generates code for the given proto file, generating one or more files in
+  // the given output directory.
+  //
+  // A parameter to be passed to the generator can be specified on the command
+  // line. This is intended to be used to pass generator specific parameters.
+  // It is empty if no parameter was given. ParseGeneratorParameter (below),
+  // can be used to accept multiple parameters within the single parameter
+  // command line flag.
+  //
+  // Returns true if successful.  Otherwise, sets *error to a description of
+  // the problem (e.g. "invalid parameter") and returns false.
+  virtual bool Generate(const FileDescriptor* file,
+                        const std::string& parameter,
+                        GeneratorContext* generator_context,
+                        std::string* error) const = 0;
+
+  // Generates code for all given proto files.
+  //
+  // WARNING: The canonical code generator design produces one or two output
+  // files per input .proto file, and we do not wish to encourage alternate
+  // designs.
+  //
+  // A parameter is given as passed on the command line, as in |Generate()|
+  // above.
+  //
+  // Returns true if successful.  Otherwise, sets *error to a description of
+  // the problem (e.g. "invalid parameter") and returns false.
+  virtual bool GenerateAll(const std::vector<const FileDescriptor*>& files,
+                           const std::string& parameter,
+                           GeneratorContext* generator_context,
+                           std::string* error) const;
+
+  // This must be kept in sync with plugin.proto. See that file for
+  // documentation on each value.
+  enum Feature {
+    FEATURE_PROTO3_OPTIONAL = 1,
+  };
+
+  // Implement this to indicate what features this code generator supports.
+  //
+  // This must be a bitwise OR of values from the Feature enum above (or zero).
+  virtual uint64_t GetSupportedFeatures() const { return 0; }
+
+  // This is no longer used, but this class is part of the opensource protobuf
+  // library, so it has to remain to keep vtables the same for the current
+  // version of the library. When protobufs does a api breaking change, the
+  // method can be removed.
+  virtual bool HasGenerateAll() const { return true; }
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodeGenerator);
+};
+
+// CodeGenerators generate one or more files in a given directory.  This
+// abstract interface represents the directory to which the CodeGenerator is
+// to write and other information about the context in which the Generator
+// runs.
+class PROTOC_EXPORT GeneratorContext {
+ public:
+  inline GeneratorContext() {
+  }
+  virtual ~GeneratorContext();
+
+  // Opens the given file, truncating it if it exists, and returns a
+  // ZeroCopyOutputStream that writes to the file.  The caller takes ownership
+  // of the returned object.  This method never fails (a dummy stream will be
+  // returned instead).
+  //
+  // The filename given should be relative to the root of the source tree.
+  // E.g. the C++ generator, when generating code for "foo/bar.proto", will
+  // generate the files "foo/bar.pb.h" and "foo/bar.pb.cc"; note that
+  // "foo/" is included in these filenames.  The filename is not allowed to
+  // contain "." or ".." components.
+  virtual io::ZeroCopyOutputStream* Open(const std::string& filename) = 0;
+
+  // Similar to Open() but the output will be appended to the file if exists
+  virtual io::ZeroCopyOutputStream* OpenForAppend(const std::string& filename);
+
+  // Creates a ZeroCopyOutputStream which will insert code into the given file
+  // at the given insertion point.  See plugin.proto (plugin.pb.h) for more
+  // information on insertion points.  The default implementation
+  // assert-fails -- it exists only for backwards-compatibility.
+  //
+  // WARNING:  This feature is currently EXPERIMENTAL and is subject to change.
+  virtual io::ZeroCopyOutputStream* OpenForInsert(
+      const std::string& filename, const std::string& insertion_point);
+
+  // Similar to OpenForInsert, but if `info` is non-empty, will open (or create)
+  // filename.pb.meta and insert info at the appropriate place with the
+  // necessary shifts. The default implementation ignores `info`.
+  //
+  // WARNING:  This feature will be REMOVED in the near future.
+  virtual io::ZeroCopyOutputStream* OpenForInsertWithGeneratedCodeInfo(
+      const std::string& filename, const std::string& insertion_point,
+      const google::protobuf::GeneratedCodeInfo& info);
+
+  // Returns a vector of FileDescriptors for all the files being compiled
+  // in this run.  Useful for languages, such as Go, that treat files
+  // differently when compiled as a set rather than individually.
+  virtual void ListParsedFiles(std::vector<const FileDescriptor*>* output);
+
+  // Retrieves the version number of the protocol compiler associated with
+  // this GeneratorContext.
+  virtual void GetCompilerVersion(Version* version) const;
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratorContext);
+};
+
+// The type GeneratorContext was once called OutputDirectory. This typedef
+// provides backward compatibility.
+typedef GeneratorContext OutputDirectory;
+
+// Several code generators treat the parameter argument as holding a
+// list of options separated by commas.  This helper function parses
+// a set of comma-delimited name/value pairs: e.g.,
+//   "foo=bar,baz,moo=corge"
+// parses to the pairs:
+//   ("foo", "bar"), ("baz", ""), ("moo", "corge")
+PROTOC_EXPORT void ParseGeneratorParameter(
+    const std::string&, std::vector<std::pair<std::string, std::string> >*);
+
+// Strips ".proto" or ".protodevel" from the end of a filename.
+PROTOC_EXPORT std::string StripProto(const std::string& filename);
+
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/command_line_interface.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/command_line_interface.h
new file mode 100644
index 0000000..e842550
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/command_line_interface.h
@@ -0,0 +1,464 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Implements the Protocol Compiler front-end such that it may be reused by
+// custom compilers written to support other languages.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
+#define GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;           // descriptor.h
+class DescriptorDatabase;   // descriptor_database.h
+class DescriptorPool;       // descriptor.h
+class FileDescriptor;       // descriptor.h
+class FileDescriptorSet;    // descriptor.h
+class FileDescriptorProto;  // descriptor.pb.h
+template <typename T>
+class RepeatedPtrField;          // repeated_field.h
+class SimpleDescriptorDatabase;  // descriptor_database.h
+
+namespace compiler {
+
+class CodeGenerator;     // code_generator.h
+class GeneratorContext;  // code_generator.h
+class DiskSourceTree;    // importer.h
+
+// This class implements the command-line interface to the protocol compiler.
+// It is designed to make it very easy to create a custom protocol compiler
+// supporting the languages of your choice.  For example, if you wanted to
+// create a custom protocol compiler binary which includes both the regular
+// C++ support plus support for your own custom output "Foo", you would
+// write a class "FooGenerator" which implements the CodeGenerator interface,
+// then write a main() procedure like this:
+//
+//   int main(int argc, char* argv[]) {
+//     google::protobuf::compiler::CommandLineInterface cli;
+//
+//     // Support generation of C++ source and headers.
+//     google::protobuf::compiler::cpp::CppGenerator cpp_generator;
+//     cli.RegisterGenerator("--cpp_out", &cpp_generator,
+//       "Generate C++ source and header.");
+//
+//     // Support generation of Foo code.
+//     FooGenerator foo_generator;
+//     cli.RegisterGenerator("--foo_out", &foo_generator,
+//       "Generate Foo file.");
+//
+//     return cli.Run(argc, argv);
+//   }
+//
+// The compiler is invoked with syntax like:
+//   protoc --cpp_out=outdir --foo_out=outdir --proto_path=src src/foo.proto
+//
+// The .proto file to compile can be specified on the command line using either
+// its physical file path, or a virtual path relative to a directory specified
+// in --proto_path. For example, for src/foo.proto, the following two protoc
+// invocations work the same way:
+//   1. protoc --proto_path=src src/foo.proto (physical file path)
+//   2. protoc --proto_path=src foo.proto (virtual path relative to src)
+//
+// If a file path can be interpreted both as a physical file path and as a
+// relative virtual path, the physical file path takes precedence.
+//
+// For a full description of the command-line syntax, invoke it with --help.
+class PROTOC_EXPORT CommandLineInterface {
+ public:
+  static const char* const kPathSeparator;
+
+  CommandLineInterface();
+  ~CommandLineInterface();
+
+  // Register a code generator for a language.
+  //
+  // Parameters:
+  // * flag_name: The command-line flag used to specify an output file of
+  //   this type.  The name must start with a '-'.  If the name is longer
+  //   than one letter, it must start with two '-'s.
+  // * generator: The CodeGenerator which will be called to generate files
+  //   of this type.
+  // * help_text: Text describing this flag in the --help output.
+  //
+  // Some generators accept extra parameters.  You can specify this parameter
+  // on the command-line by placing it before the output directory, separated
+  // by a colon:
+  //   protoc --foo_out=enable_bar:outdir
+  // The text before the colon is passed to CodeGenerator::Generate() as the
+  // "parameter".
+  void RegisterGenerator(const std::string& flag_name, CodeGenerator* generator,
+                         const std::string& help_text);
+
+  // Register a code generator for a language.
+  // Besides flag_name you can specify another option_flag_name that could be
+  // used to pass extra parameters to the registered code generator.
+  // Suppose you have registered a generator by calling:
+  //   command_line_interface.RegisterGenerator("--foo_out", "--foo_opt", ...)
+  // Then you could invoke the compiler with a command like:
+  //   protoc --foo_out=enable_bar:outdir --foo_opt=enable_baz
+  // This will pass "enable_bar,enable_baz" as the parameter to the generator.
+  void RegisterGenerator(const std::string& flag_name,
+                         const std::string& option_flag_name,
+                         CodeGenerator* generator,
+                         const std::string& help_text);
+
+  // Enables "plugins".  In this mode, if a command-line flag ends with "_out"
+  // but does not match any registered generator, the compiler will attempt to
+  // find a "plugin" to implement the generator.  Plugins are just executables.
+  // They should live somewhere in the PATH.
+  //
+  // The compiler determines the executable name to search for by concatenating
+  // exe_name_prefix with the unrecognized flag name, removing "_out".  So, for
+  // example, if exe_name_prefix is "protoc-" and you pass the flag --foo_out,
+  // the compiler will try to run the program "protoc-gen-foo".
+  //
+  // The plugin program should implement the following usage:
+  //   plugin [--out=OUTDIR] [--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS
+  // --out indicates the output directory (as passed to the --foo_out
+  // parameter); if omitted, the current directory should be used.  --parameter
+  // gives the generator parameter, if any was provided (see below).  The
+  // PROTO_FILES list the .proto files which were given on the compiler
+  // command-line; these are the files for which the plugin is expected to
+  // generate output code.  Finally, DESCRIPTORS is an encoded FileDescriptorSet
+  // (as defined in descriptor.proto).  This is piped to the plugin's stdin.
+  // The set will include descriptors for all the files listed in PROTO_FILES as
+  // well as all files that they import.  The plugin MUST NOT attempt to read
+  // the PROTO_FILES directly -- it must use the FileDescriptorSet.
+  //
+  // The plugin should generate whatever files are necessary, as code generators
+  // normally do.  It should write the names of all files it generates to
+  // stdout.  The names should be relative to the output directory, NOT absolute
+  // names or relative to the current directory.  If any errors occur, error
+  // messages should be written to stderr.  If an error is fatal, the plugin
+  // should exit with a non-zero exit code.
+  //
+  // Plugins can have generator parameters similar to normal built-in
+  // generators. Extra generator parameters can be passed in via a matching
+  // "_opt" parameter. For example:
+  //   protoc --plug_out=enable_bar:outdir --plug_opt=enable_baz
+  // This will pass "enable_bar,enable_baz" as the parameter to the plugin.
+  //
+  void AllowPlugins(const std::string& exe_name_prefix);
+
+  // Run the Protocol Compiler with the given command-line parameters.
+  // Returns the error code which should be returned by main().
+  //
+  // It may not be safe to call Run() in a multi-threaded environment because
+  // it calls strerror().  I'm not sure why you'd want to do this anyway.
+  int Run(int argc, const char* const argv[]);
+
+  // DEPRECATED. Calling this method has no effect. Protocol compiler now
+  // always try to find the .proto file relative to the current directory
+  // first and if the file is not found, it will then treat the input path
+  // as a virtual path.
+  void SetInputsAreProtoPathRelative(bool /* enable */) {}
+
+  // Provides some text which will be printed when the --version flag is
+  // used.  The version of libprotoc will also be printed on the next line
+  // after this text.
+  void SetVersionInfo(const std::string& text) { version_info_ = text; }
+
+
+ private:
+  // -----------------------------------------------------------------
+
+  class ErrorPrinter;
+  class GeneratorContextImpl;
+  class MemoryOutputStream;
+  typedef std::unordered_map<std::string, std::unique_ptr<GeneratorContextImpl>>
+      GeneratorContextMap;
+
+  // Clear state from previous Run().
+  void Clear();
+
+  // Remaps the proto file so that it is relative to one of the directories
+  // in proto_path_.  Returns false if an error occurred.
+  bool MakeProtoProtoPathRelative(DiskSourceTree* source_tree,
+                                  std::string* proto,
+                                  DescriptorDatabase* fallback_database);
+
+  // Remaps each file in input_files_ so that it is relative to one of the
+  // directories in proto_path_.  Returns false if an error occurred.
+  bool MakeInputsBeProtoPathRelative(DiskSourceTree* source_tree,
+                                     DescriptorDatabase* fallback_database);
+
+  // Fails if these files use proto3 optional and the code generator doesn't
+  // support it. This is a permanent check.
+  bool EnforceProto3OptionalSupport(
+      const std::string& codegen_name, uint64_t supported_features,
+      const std::vector<const FileDescriptor*>& parsed_files) const;
+
+
+  // Return status for ParseArguments() and InterpretArgument().
+  enum ParseArgumentStatus {
+    PARSE_ARGUMENT_DONE_AND_CONTINUE,
+    PARSE_ARGUMENT_DONE_AND_EXIT,
+    PARSE_ARGUMENT_FAIL
+  };
+
+  // Parse all command-line arguments.
+  ParseArgumentStatus ParseArguments(int argc, const char* const argv[]);
+
+  // Read an argument file and append the file's content to the list of
+  // arguments. Return false if the file cannot be read.
+  bool ExpandArgumentFile(const std::string& file,
+                          std::vector<std::string>* arguments);
+
+  // Parses a command-line argument into a name/value pair.  Returns
+  // true if the next argument in the argv should be used as the value,
+  // false otherwise.
+  //
+  // Examples:
+  //   "-Isrc/protos" ->
+  //     name = "-I", value = "src/protos"
+  //   "--cpp_out=src/foo.pb2.cc" ->
+  //     name = "--cpp_out", value = "src/foo.pb2.cc"
+  //   "foo.proto" ->
+  //     name = "", value = "foo.proto"
+  bool ParseArgument(const char* arg, std::string* name, std::string* value);
+
+  // Interprets arguments parsed with ParseArgument.
+  ParseArgumentStatus InterpretArgument(const std::string& name,
+                                        const std::string& value);
+
+  // Print the --help text to stderr.
+  void PrintHelpText();
+
+  // Loads proto_path_ into the provided source_tree.
+  bool InitializeDiskSourceTree(DiskSourceTree* source_tree,
+                                DescriptorDatabase* fallback_database);
+
+  // Verify that all the input files exist in the given database.
+  bool VerifyInputFilesInDescriptors(DescriptorDatabase* fallback_database);
+
+  // Parses input_files_ into parsed_files
+  bool ParseInputFiles(DescriptorPool* descriptor_pool,
+                       DiskSourceTree* source_tree,
+                       std::vector<const FileDescriptor*>* parsed_files);
+
+  // Generate the given output file from the given input.
+  struct OutputDirective;  // see below
+  bool GenerateOutput(const std::vector<const FileDescriptor*>& parsed_files,
+                      const OutputDirective& output_directive,
+                      GeneratorContext* generator_context);
+  bool GeneratePluginOutput(
+      const std::vector<const FileDescriptor*>& parsed_files,
+      const std::string& plugin_name, const std::string& parameter,
+      GeneratorContext* generator_context, std::string* error);
+
+  // Implements --encode and --decode.
+  bool EncodeOrDecode(const DescriptorPool* pool);
+
+  // Implements the --descriptor_set_out option.
+  bool WriteDescriptorSet(
+      const std::vector<const FileDescriptor*>& parsed_files);
+
+  // Implements the --dependency_out option
+  bool GenerateDependencyManifestFile(
+      const std::vector<const FileDescriptor*>& parsed_files,
+      const GeneratorContextMap& output_directories,
+      DiskSourceTree* source_tree);
+
+  // Get all transitive dependencies of the given file (including the file
+  // itself), adding them to the given list of FileDescriptorProtos.  The
+  // protos will be ordered such that every file is listed before any file that
+  // depends on it, so that you can call DescriptorPool::BuildFile() on them
+  // in order.  Any files in *already_seen will not be added, and each file
+  // added will be inserted into *already_seen.  If include_source_code_info is
+  // true then include the source code information in the FileDescriptorProtos.
+  // If include_json_name is true, populate the json_name field of
+  // FieldDescriptorProto for all fields.
+  static void GetTransitiveDependencies(
+      const FileDescriptor* file, bool include_json_name,
+      bool include_source_code_info,
+      std::set<const FileDescriptor*>* already_seen,
+      RepeatedPtrField<FileDescriptorProto>* output);
+
+  // Implements the --print_free_field_numbers. This function prints free field
+  // numbers into stdout for the message and it's nested message types in
+  // post-order, i.e. nested types first. Printed range are left-right
+  // inclusive, i.e. [a, b].
+  //
+  // Groups:
+  // For historical reasons, groups are considered to share the same
+  // field number space with the parent message, thus it will not print free
+  // field numbers for groups. The field numbers used in the groups are
+  // excluded in the free field numbers of the parent message.
+  //
+  // Extension Ranges:
+  // Extension ranges are considered ocuppied field numbers and they will not be
+  // listed as free numbers in the output.
+  void PrintFreeFieldNumbers(const Descriptor* descriptor);
+
+  // -----------------------------------------------------------------
+
+  // The name of the executable as invoked (i.e. argv[0]).
+  std::string executable_name_;
+
+  // Version info set with SetVersionInfo().
+  std::string version_info_;
+
+  // Registered generators.
+  struct GeneratorInfo {
+    std::string flag_name;
+    std::string option_flag_name;
+    CodeGenerator* generator;
+    std::string help_text;
+  };
+  typedef std::map<std::string, GeneratorInfo> GeneratorMap;
+  GeneratorMap generators_by_flag_name_;
+  GeneratorMap generators_by_option_name_;
+  // A map from generator names to the parameters specified using the option
+  // flag. For example, if the user invokes the compiler with:
+  //   protoc --foo_out=outputdir --foo_opt=enable_bar ...
+  // Then there will be an entry ("--foo_out", "enable_bar") in this map.
+  std::map<std::string, std::string> generator_parameters_;
+  // Similar to generator_parameters_, but stores the parameters for plugins.
+  std::map<std::string, std::string> plugin_parameters_;
+
+  // See AllowPlugins().  If this is empty, plugins aren't allowed.
+  std::string plugin_prefix_;
+
+  // Maps specific plugin names to files.  When executing a plugin, this map
+  // is searched first to find the plugin executable.  If not found here, the
+  // PATH (or other OS-specific search strategy) is searched.
+  std::map<std::string, std::string> plugins_;
+
+  // Stuff parsed from command line.
+  enum Mode {
+    MODE_COMPILE,  // Normal mode:  parse .proto files and compile them.
+    MODE_ENCODE,   // --encode:  read text from stdin, write binary to stdout.
+    MODE_DECODE,   // --decode:  read binary from stdin, write text to stdout.
+    MODE_PRINT,    // Print mode: print info of the given .proto files and exit.
+  };
+
+  Mode mode_ = MODE_COMPILE;
+
+  enum PrintMode {
+    PRINT_NONE,         // Not in MODE_PRINT
+    PRINT_FREE_FIELDS,  // --print_free_fields
+  };
+
+  PrintMode print_mode_ = PRINT_NONE;
+
+  enum ErrorFormat {
+    ERROR_FORMAT_GCC,  // GCC error output format (default).
+    ERROR_FORMAT_MSVS  // Visual Studio output (--error_format=msvs).
+  };
+
+  ErrorFormat error_format_ = ERROR_FORMAT_GCC;
+
+  // True if we should treat warnings as errors that fail the compilation.
+  bool fatal_warnings_ = false;
+
+  std::vector<std::pair<std::string, std::string> >
+      proto_path_;                        // Search path for proto files.
+  std::vector<std::string> input_files_;  // Names of the input proto files.
+
+  // Names of proto files which are allowed to be imported. Used by build
+  // systems to enforce depend-on-what-you-import.
+  std::set<std::string> direct_dependencies_;
+  bool direct_dependencies_explicitly_set_ = false;
+
+  // If there's a violation of depend-on-what-you-import, this string will be
+  // presented to the user. "%s" will be replaced with the violating import.
+  std::string direct_dependencies_violation_msg_;
+
+  // output_directives_ lists all the files we are supposed to output and what
+  // generator to use for each.
+  struct OutputDirective {
+    std::string name;          // E.g. "--foo_out"
+    CodeGenerator* generator;  // NULL for plugins
+    std::string parameter;
+    std::string output_location;
+  };
+  std::vector<OutputDirective> output_directives_;
+
+  // When using --encode or --decode, this names the type we are encoding or
+  // decoding.  (Empty string indicates --decode_raw.)
+  std::string codec_type_;
+
+  // If --descriptor_set_in was given, these are filenames containing
+  // parsed FileDescriptorSets to be used for loading protos.  Otherwise, empty.
+  std::vector<std::string> descriptor_set_in_names_;
+
+  // If --descriptor_set_out was given, this is the filename to which the
+  // FileDescriptorSet should be written.  Otherwise, empty.
+  std::string descriptor_set_out_name_;
+
+  // If --dependency_out was given, this is the path to the file where the
+  // dependency file will be written. Otherwise, empty.
+  std::string dependency_out_name_;
+
+  // True if --include_imports was given, meaning that we should
+  // write all transitive dependencies to the DescriptorSet.  Otherwise, only
+  // the .proto files listed on the command-line are added.
+  bool imports_in_descriptor_set_;
+
+  // True if --include_source_info was given, meaning that we should not strip
+  // SourceCodeInfo from the DescriptorSet.
+  bool source_info_in_descriptor_set_ = false;
+
+  // Was the --disallow_services flag used?
+  bool disallow_services_ = false;
+
+  // When using --encode, this will be passed to SetSerializationDeterministic.
+  bool deterministic_output_ = false;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CommandLineInterface);
+};
+
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/cpp_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/cpp_generator.h
new file mode 100644
index 0000000..1716ab2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/cpp_generator.h
@@ -0,0 +1,6 @@
+#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_CPP_GENERATOR_H_
+#define GOOGLE_PROTOBUF_COMPILER_CPP_CPP_GENERATOR_H_
+
+#include <google/protobuf/compiler/cpp/generator.h>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CPP_CPP_GENERATOR_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/file.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/file.h
new file mode 100644
index 0000000..ca05361
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/file.h
@@ -0,0 +1,209 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_FILE_H__
+#define GOOGLE_PROTOBUF_COMPILER_CPP_FILE_H__
+
+#include <algorithm>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/compiler/cpp/field.h>
+#include <google/protobuf/compiler/cpp/helpers.h>
+#include <google/protobuf/compiler/scc.h>
+#include <google/protobuf/compiler/cpp/options.h>
+
+namespace google {
+namespace protobuf {
+class FileDescriptor;  // descriptor.h
+namespace io {
+class Printer;  // printer.h
+}
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace cpp {
+
+class EnumGenerator;       // enum.h
+class MessageGenerator;    // message.h
+class ServiceGenerator;    // service.h
+class ExtensionGenerator;  // extension.h
+
+class FileGenerator {
+ public:
+  // See generator.cc for the meaning of dllexport_decl.
+  FileGenerator(const FileDescriptor* file, const Options& options);
+  ~FileGenerator();
+
+  // Shared code between the two header generators below.
+  void GenerateHeader(io::Printer* printer);
+
+  // info_path, if non-empty, should be the path (relative to printer's
+  // output) to the metadata file describing this proto header.
+  void GenerateProtoHeader(io::Printer* printer, const std::string& info_path);
+  // info_path, if non-empty, should be the path (relative to printer's
+  // output) to the metadata file describing this PB header.
+  void GeneratePBHeader(io::Printer* printer, const std::string& info_path);
+  void GenerateSource(io::Printer* printer);
+
+  // The following member functions are used when the lite_implicit_weak_fields
+  // option is set. In this mode the code is organized a bit differently to
+  // promote better linker stripping of unused code. In particular, we generate
+  // one .cc file per message, one .cc file per extension, and a main pb.cc file
+  // containing everything else.
+
+  int NumMessages() const { return message_generators_.size(); }
+  int NumExtensions() const { return extension_generators_.size(); }
+  // Generates the source file for one message.
+  void GenerateSourceForMessage(int idx, io::Printer* printer);
+  // Generates the source file for one extension.
+  void GenerateSourceForExtension(int idx, io::Printer* printer);
+  // Generates a source file containing everything except messages and
+  // extensions.
+  void GenerateGlobalSource(io::Printer* printer);
+
+ private:
+  // Internal type used by GenerateForwardDeclarations (defined in file.cc).
+  class ForwardDeclarations;
+  struct CrossFileReferences;
+
+  void IncludeFile(const std::string& google3_name, io::Printer* printer) {
+    DoIncludeFile(google3_name, false, printer);
+  }
+  void IncludeFileAndExport(const std::string& google3_name,
+                            io::Printer* printer) {
+    DoIncludeFile(google3_name, true, printer);
+  }
+  void DoIncludeFile(const std::string& google3_name, bool do_export,
+                     io::Printer* printer);
+
+  std::string CreateHeaderInclude(const std::string& basename,
+                                  const FileDescriptor* file);
+  void GetCrossFileReferencesForField(const FieldDescriptor* field,
+                                      CrossFileReferences* refs);
+  void GetCrossFileReferencesForFile(const FileDescriptor* file,
+                                     CrossFileReferences* refs);
+  void GenerateInternalForwardDeclarations(const CrossFileReferences& refs,
+                                           io::Printer* printer);
+  void GenerateSourceIncludes(io::Printer* printer);
+  void GenerateSourcePrelude(io::Printer* printer);
+  void GenerateSourceDefaultInstance(int idx, io::Printer* printer);
+
+  void GenerateInitForSCC(const SCC* scc, const CrossFileReferences& refs,
+                          io::Printer* printer);
+  void GenerateReflectionInitializationCode(io::Printer* printer);
+
+  // For other imports, generates their forward-declarations.
+  void GenerateForwardDeclarations(io::Printer* printer);
+
+  // Generates top or bottom of a header file.
+  void GenerateTopHeaderGuard(io::Printer* printer, bool pb_h);
+  void GenerateBottomHeaderGuard(io::Printer* printer, bool pb_h);
+
+  // Generates #include directives.
+  void GenerateLibraryIncludes(io::Printer* printer);
+  void GenerateDependencyIncludes(io::Printer* printer);
+
+  // Generate a pragma to pull in metadata using the given info_path (if
+  // non-empty). info_path should be relative to printer's output.
+  void GenerateMetadataPragma(io::Printer* printer,
+                              const std::string& info_path);
+
+  // Generates a couple of different pieces before definitions:
+  void GenerateGlobalStateFunctionDeclarations(io::Printer* printer);
+
+  // Generates types for classes.
+  void GenerateMessageDefinitions(io::Printer* printer);
+
+  void GenerateEnumDefinitions(io::Printer* printer);
+
+  // Generates generic service definitions.
+  void GenerateServiceDefinitions(io::Printer* printer);
+
+  // Generates extension identifiers.
+  void GenerateExtensionIdentifiers(io::Printer* printer);
+
+  // Generates inline function definitions.
+  void GenerateInlineFunctionDefinitions(io::Printer* printer);
+
+  void GenerateProto2NamespaceEnumSpecializations(io::Printer* printer);
+
+  // Sometimes the names we use in a .proto file happen to be defined as
+  // macros on some platforms (e.g., macro/minor used in plugin.proto are
+  // defined as macros in sys/types.h on FreeBSD and a few other platforms).
+  // To make the generated code compile on these platforms, we either have to
+  // undef the macro for these few platforms, or rename the field name for all
+  // platforms. Since these names are part of protobuf public API, renaming is
+  // generally a breaking change so we prefer the #undef approach.
+  void GenerateMacroUndefs(io::Printer* printer);
+
+  bool IsDepWeak(const FileDescriptor* dep) const {
+    if (weak_deps_.count(dep) != 0) {
+      GOOGLE_CHECK(!options_.opensource_runtime);
+      return true;
+    }
+    return false;
+  }
+
+  std::set<const FileDescriptor*> weak_deps_;
+
+  const FileDescriptor* file_;
+  const Options options_;
+
+  MessageSCCAnalyzer scc_analyzer_;
+
+  std::map<std::string, std::string> variables_;
+
+  // Contains the post-order walk of all the messages (and child messages) in
+  // this file. If you need a pre-order walk just reverse iterate.
+  std::vector<std::unique_ptr<MessageGenerator>> message_generators_;
+  std::vector<std::unique_ptr<EnumGenerator>> enum_generators_;
+  std::vector<std::unique_ptr<ServiceGenerator>> service_generators_;
+  std::vector<std::unique_ptr<ExtensionGenerator>> extension_generators_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileGenerator);
+};
+
+}  // namespace cpp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CPP_FILE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/generator.h
new file mode 100644
index 0000000..1a374b9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/generator.h
@@ -0,0 +1,107 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates C++ code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace cpp {
+
+// CodeGenerator implementation which generates a C++ source file and
+// header.  If you create your own protocol compiler binary and you want
+// it to support C++ output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class PROTOC_EXPORT CppGenerator : public CodeGenerator {
+ public:
+  CppGenerator();
+  ~CppGenerator() override;
+
+  enum class Runtime {
+    kGoogle3,     // Use the internal google3 runtime.
+    kOpensource,  // Use the open-source runtime.
+
+    // Use the open-source runtime with google3 #include paths.  We make these
+    // absolute to avoid ambiguity, so the runtime will be #included like:
+    //   #include "third_party/protobuf/.../google/protobuf/message.h"
+    kOpensourceGoogle3
+  };
+
+  void set_opensource_runtime(bool opensource) {
+    opensource_runtime_ = opensource;
+  }
+
+  // If set to a non-empty string, generated code will do:
+  //   #include "<BASE>/google/protobuf/message.h"
+  // instead of:
+  //   #include <google/protobuf/message.h>
+  // This has no effect if opensource_runtime = false.
+  void set_runtime_include_base(const std::string& base) {
+    runtime_include_base_ = base;
+  }
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file, const std::string& parameter,
+                GeneratorContext* generator_context,
+                std::string* error) const override;
+
+  uint64_t GetSupportedFeatures() const override {
+    // We don't fully support this yet, but this is needed to unblock the tests,
+    // and we will have full support before the experimental flag is removed.
+    return FEATURE_PROTO3_OPTIONAL;
+  }
+
+ private:
+  bool opensource_runtime_ = true;
+  std::string runtime_include_base_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CppGenerator);
+};
+
+}  // namespace cpp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/helpers.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/helpers.h
new file mode 100644
index 0000000..d8dcda7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/helpers.h
@@ -0,0 +1,1064 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__
+#define GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__
+
+#include <algorithm>
+#include <cstdint>
+#include <iterator>
+#include <map>
+#include <string>
+
+#include <google/protobuf/compiler/scc.h>
+#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/compiler/cpp/names.h>
+#include <google/protobuf/compiler/cpp/options.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/strutil.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace cpp {
+
+enum class ArenaDtorNeeds { kNone = 0, kOnDemand = 1, kRequired = 2 };
+
+inline std::string ProtobufNamespace(const Options& /* options */) {
+  return "PROTOBUF_NAMESPACE_ID";
+}
+
+inline std::string MacroPrefix(const Options& /* options */) {
+  return "GOOGLE_PROTOBUF";
+}
+
+inline std::string DeprecatedAttribute(const Options& /* options */,
+                                       const FieldDescriptor* d) {
+  return d->options().deprecated() ? "PROTOBUF_DEPRECATED " : "";
+}
+
+inline std::string DeprecatedAttribute(const Options& /* options */,
+                                       const EnumValueDescriptor* d) {
+  return d->options().deprecated() ? "PROTOBUF_DEPRECATED_ENUM " : "";
+}
+
+// Commonly-used separator comments.  Thick is a line of '=', thin is a line
+// of '-'.
+extern const char kThickSeparator[];
+extern const char kThinSeparator[];
+
+void SetCommonVars(const Options& options,
+                   std::map<std::string, std::string>* variables);
+
+// Variables to access message data from the message scope.
+void SetCommonMessageDataVariables(
+    const Descriptor* descriptor,
+    std::map<std::string, std::string>* variables);
+
+void SetUnknownFieldsVariable(const Descriptor* descriptor,
+                              const Options& options,
+                              std::map<std::string, std::string>* variables);
+
+bool GetBootstrapBasename(const Options& options, const std::string& basename,
+                          std::string* bootstrap_basename);
+bool MaybeBootstrap(const Options& options, GeneratorContext* generator_context,
+                    bool bootstrap_flag, std::string* basename);
+bool IsBootstrapProto(const Options& options, const FileDescriptor* file);
+
+// Name space of the proto file. This namespace is such that the string
+// "<namespace>::some_name" is the correct fully qualified namespace.
+// This means if the package is empty the namespace is "", and otherwise
+// the namespace is "::foo::bar::...::baz" without trailing semi-colons.
+std::string Namespace(const FileDescriptor* d, const Options& options);
+std::string Namespace(const Descriptor* d, const Options& options);
+std::string Namespace(const FieldDescriptor* d, const Options& options);
+std::string Namespace(const EnumDescriptor* d, const Options& options);
+
+// Returns true if it's safe to reset "field" to zero.
+bool CanInitializeByZeroing(const FieldDescriptor* field);
+
+std::string ClassName(const Descriptor* descriptor);
+std::string ClassName(const EnumDescriptor* enum_descriptor);
+
+std::string QualifiedClassName(const Descriptor* d, const Options& options);
+std::string QualifiedClassName(const EnumDescriptor* d, const Options& options);
+
+std::string QualifiedClassName(const Descriptor* d);
+std::string QualifiedClassName(const EnumDescriptor* d);
+
+// DEPRECATED just use ClassName or QualifiedClassName, a boolean is very
+// unreadable at the callsite.
+// Returns the non-nested type name for the given type.  If "qualified" is
+// true, prefix the type with the full namespace.  For example, if you had:
+//   package foo.bar;
+//   message Baz { message Moo {} }
+// Then the qualified ClassName for Moo would be:
+//   ::foo::bar::Baz_Moo
+// While the non-qualified version would be:
+//   Baz_Moo
+inline std::string ClassName(const Descriptor* descriptor, bool qualified) {
+  return qualified ? QualifiedClassName(descriptor, Options())
+                   : ClassName(descriptor);
+}
+
+inline std::string ClassName(const EnumDescriptor* descriptor, bool qualified) {
+  return qualified ? QualifiedClassName(descriptor, Options())
+                   : ClassName(descriptor);
+}
+
+// Returns the extension name prefixed with the class name if nested but without
+// the package name.
+std::string ExtensionName(const FieldDescriptor* d);
+
+std::string QualifiedExtensionName(const FieldDescriptor* d,
+                                   const Options& options);
+std::string QualifiedExtensionName(const FieldDescriptor* d);
+
+// Type name of default instance.
+std::string DefaultInstanceType(const Descriptor* descriptor,
+                                const Options& options, bool split = false);
+
+// Non-qualified name of the default_instance of this message.
+std::string DefaultInstanceName(const Descriptor* descriptor,
+                                const Options& options, bool split = false);
+
+// Non-qualified name of the default instance pointer. This is used only for
+// implicit weak fields, where we need an extra indirection.
+std::string DefaultInstancePtr(const Descriptor* descriptor,
+                               const Options& options, bool split = false);
+
+// Fully qualified name of the default_instance of this message.
+std::string QualifiedDefaultInstanceName(const Descriptor* descriptor,
+                                         const Options& options,
+                                         bool split = false);
+
+// Fully qualified name of the default instance pointer.
+std::string QualifiedDefaultInstancePtr(const Descriptor* descriptor,
+                                        const Options& options,
+                                        bool split = false);
+
+// DescriptorTable variable name.
+std::string DescriptorTableName(const FileDescriptor* file,
+                                const Options& options);
+
+// When declaring symbol externs from another file, this macro will supply the
+// dllexport needed for the target file, if any.
+std::string FileDllExport(const FileDescriptor* file, const Options& options);
+
+// Name of the base class: google::protobuf::Message or google::protobuf::MessageLite.
+std::string SuperClassName(const Descriptor* descriptor,
+                           const Options& options);
+
+// Adds an underscore if necessary to prevent conflicting with a keyword.
+std::string ResolveKeyword(const std::string& name);
+
+// Get the (unqualified) name that should be used for this field in C++ code.
+// The name is coerced to lower-case to emulate proto1 behavior.  People
+// should be using lowercase-with-underscores style for proto field names
+// anyway, so normally this just returns field->name().
+std::string FieldName(const FieldDescriptor* field);
+
+// Returns the (unqualified) private member name for this field in C++ code.
+std::string FieldMemberName(const FieldDescriptor* field, bool split);
+
+// Returns an estimate of the compiler's alignment for the field.  This
+// can't guarantee to be correct because the generated code could be compiled on
+// different systems with different alignment rules.  The estimates below assume
+// 64-bit pointers.
+int EstimateAlignmentSize(const FieldDescriptor* field);
+
+// Get the unqualified name that should be used for a field's field
+// number constant.
+std::string FieldConstantName(const FieldDescriptor* field);
+
+// Returns the scope where the field was defined (for extensions, this is
+// different from the message type to which the field applies).
+inline const Descriptor* FieldScope(const FieldDescriptor* field) {
+  return field->is_extension() ? field->extension_scope()
+                               : field->containing_type();
+}
+
+// Returns the fully-qualified type name field->message_type().  Usually this
+// is just ClassName(field->message_type(), true);
+std::string FieldMessageTypeName(const FieldDescriptor* field,
+                                 const Options& options);
+
+// Get the C++ type name for a primitive type (e.g. "double", "::google::protobuf::int32", etc.).
+const char* PrimitiveTypeName(FieldDescriptor::CppType type);
+std::string PrimitiveTypeName(const Options& options,
+                              FieldDescriptor::CppType type);
+
+// Get the declared type name in CamelCase format, as is used e.g. for the
+// methods of WireFormat.  For example, TYPE_INT32 becomes "Int32".
+const char* DeclaredTypeMethodName(FieldDescriptor::Type type);
+
+// Return the code that evaluates to the number when compiled.
+std::string Int32ToString(int number);
+
+// Get code that evaluates to the field's default value.
+std::string DefaultValue(const Options& options, const FieldDescriptor* field);
+
+// Compatibility function for callers outside proto2.
+std::string DefaultValue(const FieldDescriptor* field);
+
+// Convert a file name into a valid identifier.
+std::string FilenameIdentifier(const std::string& filename);
+
+// For each .proto file generates a unique name. To prevent collisions of
+// symbols in the global namespace
+std::string UniqueName(const std::string& name, const std::string& filename,
+                       const Options& options);
+inline std::string UniqueName(const std::string& name, const FileDescriptor* d,
+                              const Options& options) {
+  return UniqueName(name, d->name(), options);
+}
+inline std::string UniqueName(const std::string& name, const Descriptor* d,
+                              const Options& options) {
+  return UniqueName(name, d->file(), options);
+}
+inline std::string UniqueName(const std::string& name, const EnumDescriptor* d,
+                              const Options& options) {
+  return UniqueName(name, d->file(), options);
+}
+inline std::string UniqueName(const std::string& name,
+                              const ServiceDescriptor* d,
+                              const Options& options) {
+  return UniqueName(name, d->file(), options);
+}
+
+// Versions for call sites that only support the internal runtime (like proto1
+// support).
+inline Options InternalRuntimeOptions() {
+  Options options;
+  options.opensource_runtime = false;
+  return options;
+}
+inline std::string UniqueName(const std::string& name,
+                              const std::string& filename) {
+  return UniqueName(name, filename, InternalRuntimeOptions());
+}
+inline std::string UniqueName(const std::string& name,
+                              const FileDescriptor* d) {
+  return UniqueName(name, d->name(), InternalRuntimeOptions());
+}
+inline std::string UniqueName(const std::string& name, const Descriptor* d) {
+  return UniqueName(name, d->file(), InternalRuntimeOptions());
+}
+inline std::string UniqueName(const std::string& name,
+                              const EnumDescriptor* d) {
+  return UniqueName(name, d->file(), InternalRuntimeOptions());
+}
+inline std::string UniqueName(const std::string& name,
+                              const ServiceDescriptor* d) {
+  return UniqueName(name, d->file(), InternalRuntimeOptions());
+}
+
+// Return the qualified C++ name for a file level symbol.
+std::string QualifiedFileLevelSymbol(const FileDescriptor* file,
+                                     const std::string& name,
+                                     const Options& options);
+
+// Escape C++ trigraphs by escaping question marks to \?
+std::string EscapeTrigraphs(const std::string& to_escape);
+
+// Escaped function name to eliminate naming conflict.
+std::string SafeFunctionName(const Descriptor* descriptor,
+                             const FieldDescriptor* field,
+                             const std::string& prefix);
+
+// Returns true if generated messages have public unknown fields accessors
+inline bool PublicUnknownFieldsAccessors(const Descriptor* message) {
+  return message->file()->syntax() != FileDescriptor::SYNTAX_PROTO3;
+}
+
+// Returns the optimize mode for <file>, respecting <options.enforce_lite>.
+FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file,
+                                        const Options& options);
+
+// Determines whether unknown fields will be stored in an UnknownFieldSet or
+// a string.
+inline bool UseUnknownFieldSet(const FileDescriptor* file,
+                               const Options& options) {
+  return GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME;
+}
+
+inline bool IsWeak(const FieldDescriptor* field, const Options& options) {
+  if (field->options().weak()) {
+    GOOGLE_CHECK(!options.opensource_runtime);
+    return true;
+  }
+  return false;
+}
+
+bool IsStringInlined(const FieldDescriptor* descriptor, const Options& options);
+
+// For a string field, returns the effective ctype.  If the actual ctype is
+// not supported, returns the default of STRING.
+FieldOptions::CType EffectiveStringCType(const FieldDescriptor* field,
+                                         const Options& options);
+
+inline bool IsCord(const FieldDescriptor* field, const Options& options) {
+  return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
+         EffectiveStringCType(field, options) == FieldOptions::CORD;
+}
+
+inline bool IsString(const FieldDescriptor* field, const Options& options) {
+  return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
+         EffectiveStringCType(field, options) == FieldOptions::STRING;
+}
+
+inline bool IsStringPiece(const FieldDescriptor* field,
+                          const Options& options) {
+  return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
+         EffectiveStringCType(field, options) == FieldOptions::STRING_PIECE;
+}
+
+class MessageSCCAnalyzer;
+
+// Does the given FileDescriptor use lazy fields?
+bool HasLazyFields(const FileDescriptor* file, const Options& options,
+                   MessageSCCAnalyzer* scc_analyzer);
+
+// Is the given field a supported lazy field?
+bool IsLazy(const FieldDescriptor* field, const Options& options,
+            MessageSCCAnalyzer* scc_analyzer);
+
+// Is this an explicit (non-profile driven) lazy field, as denoted by
+// lazy/unverified_lazy in the descriptor?
+inline bool IsExplicitLazy(const FieldDescriptor* field) {
+  return field->options().lazy() || field->options().unverified_lazy();
+}
+
+bool IsEagerlyVerifiedLazy(const FieldDescriptor* field, const Options& options,
+                           MessageSCCAnalyzer* scc_analyzer);
+
+bool IsLazilyVerifiedLazy(const FieldDescriptor* field, const Options& options);
+
+// Is the given message being split (go/pdsplit)?
+bool ShouldSplit(const Descriptor* desc, const Options& options);
+
+// Is the given field being split out?
+bool ShouldSplit(const FieldDescriptor* field, const Options& options);
+
+inline bool IsFieldUsed(const FieldDescriptor* /* field */,
+                        const Options& /* options */) {
+  return true;
+}
+
+// Returns true if "field" is stripped.
+inline bool IsFieldStripped(const FieldDescriptor* /*field*/,
+                            const Options& /*options*/) {
+  return false;
+}
+
+// Does the file contain any definitions that need extension_set.h?
+bool HasExtensionsOrExtendableMessage(const FileDescriptor* file);
+
+// Does the file have any repeated fields, necessitating the file to include
+// repeated_field.h? This does not include repeated extensions, since those are
+// all stored internally in an ExtensionSet, not a separate RepeatedField*.
+bool HasRepeatedFields(const FileDescriptor* file);
+
+// Does the file have any string/bytes fields with ctype=STRING_PIECE? This
+// does not include extensions, since ctype is ignored for extensions.
+bool HasStringPieceFields(const FileDescriptor* file, const Options& options);
+
+// Does the file have any string/bytes fields with ctype=CORD? This does not
+// include extensions, since ctype is ignored for extensions.
+bool HasCordFields(const FileDescriptor* file, const Options& options);
+
+// Does the file have any map fields, necessitating the file to include
+// map_field_inl.h and map.h.
+bool HasMapFields(const FileDescriptor* file);
+
+// Does this file have any enum type definitions?
+bool HasEnumDefinitions(const FileDescriptor* file);
+
+// Does this file have generated parsing, serialization, and other
+// standard methods for which reflection-based fallback implementations exist?
+inline bool HasGeneratedMethods(const FileDescriptor* file,
+                                const Options& options) {
+  return GetOptimizeFor(file, options) != FileOptions::CODE_SIZE;
+}
+
+// Do message classes in this file have descriptor and reflection methods?
+inline bool HasDescriptorMethods(const FileDescriptor* file,
+                                 const Options& options) {
+  return GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME;
+}
+
+// Should we generate generic services for this file?
+inline bool HasGenericServices(const FileDescriptor* file,
+                               const Options& options) {
+  return file->service_count() > 0 &&
+         GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME &&
+         file->options().cc_generic_services();
+}
+
+inline bool IsProto2MessageSet(const Descriptor* descriptor,
+                               const Options& options) {
+  return !options.opensource_runtime &&
+         options.enforce_mode != EnforceOptimizeMode::kLiteRuntime &&
+         !options.lite_implicit_weak_fields &&
+         descriptor->options().message_set_wire_format() &&
+         descriptor->full_name() == "google.protobuf.bridge.MessageSet";
+}
+
+inline bool IsMapEntryMessage(const Descriptor* descriptor) {
+  return descriptor->options().map_entry();
+}
+
+// Returns true if the field's CPPTYPE is string or message.
+bool IsStringOrMessage(const FieldDescriptor* field);
+
+std::string UnderscoresToCamelCase(const std::string& input,
+                                   bool cap_next_letter);
+
+inline bool IsProto3(const FileDescriptor* file) {
+  return file->syntax() == FileDescriptor::SYNTAX_PROTO3;
+}
+
+inline bool HasHasbit(const FieldDescriptor* field) {
+  // This predicate includes proto3 message fields only if they have "optional".
+  //   Foo submsg1 = 1;           // HasHasbit() == false
+  //   optional Foo submsg2 = 2;  // HasHasbit() == true
+  // This is slightly odd, as adding "optional" to a singular proto3 field does
+  // not change the semantics or API. However whenever any field in a message
+  // has a hasbit, it forces reflection to include hasbit offsets for *all*
+  // fields, even if almost all of them are set to -1 (no hasbit). So to avoid
+  // causing a sudden size regression for ~all proto3 messages, we give proto3
+  // message fields a hasbit only if "optional" is present. If the user is
+  // explicitly writing "optional", it is likely they are writing it on
+  // primitive fields also.
+  return (field->has_optional_keyword() || field->is_required()) &&
+         !field->options().weak();
+}
+
+// Returns true if 'enum' semantics are such that unknown values are preserved
+// in the enum field itself, rather than going to the UnknownFieldSet.
+inline bool HasPreservingUnknownEnumSemantics(const FieldDescriptor* field) {
+  return field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3;
+}
+
+inline bool IsCrossFileMessage(const FieldDescriptor* field) {
+  return field->type() == FieldDescriptor::TYPE_MESSAGE &&
+         field->message_type()->file() != field->file();
+}
+
+inline std::string MakeDefaultName(const FieldDescriptor* field) {
+  return StrCat("_i_give_permission_to_break_this_code_default_",
+                      FieldName(field), "_");
+}
+
+// Semantically distinct from MakeDefaultName in that it gives the C++ code
+// referencing a default field from the message scope, rather than just the
+// variable name.
+// For example, declarations of default variables should always use just
+// MakeDefaultName to produce code like:
+//   Type _i_give_permission_to_break_this_code_default_field_;
+//
+// Code that references these should use MakeDefaultFieldName, in case the field
+// exists at some nested level like:
+//   internal_container_._i_give_permission_to_break_this_code_default_field_;
+inline std::string MakeDefaultFieldName(const FieldDescriptor* field) {
+  return StrCat("Impl_::", MakeDefaultName(field));
+}
+
+inline std::string MakeVarintCachedSizeName(const FieldDescriptor* field) {
+  return StrCat("_", FieldName(field), "_cached_byte_size_");
+}
+
+// Semantically distinct from MakeVarintCachedSizeName in that it gives the C++
+// code referencing the object from the message scope, rather than just the
+// variable name.
+// For example, declarations of default variables should always use just
+// MakeVarintCachedSizeName to produce code like:
+//   Type _field_cached_byte_size_;
+//
+// Code that references these variables should use
+// MakeVarintCachedSizeFieldName, in case the field exists at some nested level
+// like:
+//   internal_container_._field_cached_byte_size_;
+inline std::string MakeVarintCachedSizeFieldName(const FieldDescriptor* field,
+                                                 bool split) {
+  return StrCat("_impl_.", split ? "_split_->" : "", "_",
+                      FieldName(field), "_cached_byte_size_");
+}
+
+// Note: A lot of libraries detect Any protos based on Descriptor::full_name()
+// while the two functions below use FileDescriptor::name(). In a sane world the
+// two approaches should be equivalent. But if you are dealing with descriptors
+// from untrusted sources, you might need to match semantics across libraries.
+bool IsAnyMessage(const FileDescriptor* descriptor, const Options& options);
+bool IsAnyMessage(const Descriptor* descriptor, const Options& options);
+
+bool IsWellKnownMessage(const FileDescriptor* descriptor);
+
+inline std::string IncludeGuard(const FileDescriptor* file, bool pb_h,
+                                const Options& options) {
+  // If we are generating a .pb.h file and the proto_h option is enabled, then
+  // the .pb.h gets an extra suffix.
+  std::string filename_identifier = FilenameIdentifier(
+      file->name() + (pb_h && options.proto_h ? ".pb.h" : ""));
+
+  if (IsWellKnownMessage(file)) {
+    // For well-known messages we need third_party/protobuf and net/proto2 to
+    // have distinct include guards, because some source files include both and
+    // both need to be defined (the third_party copies will be in the
+    // google::protobuf_opensource namespace).
+    return MacroPrefix(options) + "_INCLUDED_" + filename_identifier;
+  } else {
+    // Ideally this case would use distinct include guards for opensource and
+    // google3 protos also.  (The behavior of "first #included wins" is not
+    // ideal).  But unfortunately some legacy code includes both and depends on
+    // the identical include guards to avoid compile errors.
+    //
+    // We should clean this up so that this case can be removed.
+    return "GOOGLE_PROTOBUF_INCLUDED_" + filename_identifier;
+  }
+}
+
+// Returns the OptimizeMode for this file, furthermore it updates a status
+// bool if has_opt_codesize_extension is non-null. If this status bool is true
+// it means this file contains an extension that itself is defined as
+// optimized_for = CODE_SIZE.
+FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file,
+                                        const Options& options,
+                                        bool* has_opt_codesize_extension);
+inline FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file,
+                                               const Options& options) {
+  return GetOptimizeFor(file, options, nullptr);
+}
+inline bool NeedsEagerDescriptorAssignment(const FileDescriptor* file,
+                                           const Options& options) {
+  bool has_opt_codesize_extension;
+  if (GetOptimizeFor(file, options, &has_opt_codesize_extension) ==
+          FileOptions::CODE_SIZE &&
+      has_opt_codesize_extension) {
+    // If this filedescriptor contains an extension from another file which
+    // is optimized_for = CODE_SIZE. We need to be careful in the ordering so
+    // we eagerly build the descriptors in the dependencies before building
+    // the descriptors of this file.
+    return true;
+  } else {
+    // If we have a generated code based parser we never need eager
+    // initialization of descriptors of our deps.
+    return false;
+  }
+}
+
+// This orders the messages in a .pb.cc as it's outputted by file.cc
+void FlattenMessagesInFile(const FileDescriptor* file,
+                           std::vector<const Descriptor*>* result);
+inline std::vector<const Descriptor*> FlattenMessagesInFile(
+    const FileDescriptor* file) {
+  std::vector<const Descriptor*> result;
+  FlattenMessagesInFile(file, &result);
+  return result;
+}
+
+template <typename F>
+void ForEachMessage(const Descriptor* descriptor, F&& func) {
+  for (int i = 0; i < descriptor->nested_type_count(); i++)
+    ForEachMessage(descriptor->nested_type(i), std::forward<F&&>(func));
+  func(descriptor);
+}
+
+template <typename F>
+void ForEachMessage(const FileDescriptor* descriptor, F&& func) {
+  for (int i = 0; i < descriptor->message_type_count(); i++)
+    ForEachMessage(descriptor->message_type(i), std::forward<F&&>(func));
+}
+
+bool HasWeakFields(const Descriptor* desc, const Options& options);
+bool HasWeakFields(const FileDescriptor* desc, const Options& options);
+
+// Returns true if the "required" restriction check should be ignored for the
+// given field.
+inline static bool ShouldIgnoreRequiredFieldCheck(const FieldDescriptor* field,
+                                                  const Options& options) {
+  // Do not check "required" for lazily verified lazy fields.
+  return IsLazilyVerifiedLazy(field, options);
+}
+
+struct MessageAnalysis {
+  bool is_recursive = false;
+  bool contains_cord = false;
+  bool contains_extension = false;
+  bool contains_required = false;
+  bool contains_weak = false;  // Implicit weak as well.
+};
+
+// This class is used in FileGenerator, to ensure linear instead of
+// quadratic performance, if we do this per message we would get O(V*(V+E)).
+// Logically this is just only used in message.cc, but in the header for
+// FileGenerator to help share it.
+class PROTOC_EXPORT MessageSCCAnalyzer {
+ public:
+  explicit MessageSCCAnalyzer(const Options& options) : options_(options) {}
+
+  MessageAnalysis GetSCCAnalysis(const SCC* scc);
+
+  bool HasRequiredFields(const Descriptor* descriptor) {
+    MessageAnalysis result = GetSCCAnalysis(GetSCC(descriptor));
+    return result.contains_required || result.contains_extension;
+  }
+  bool HasWeakField(const Descriptor* descriptor) {
+    MessageAnalysis result = GetSCCAnalysis(GetSCC(descriptor));
+    return result.contains_weak;
+  }
+  const SCC* GetSCC(const Descriptor* descriptor) {
+    return analyzer_.GetSCC(descriptor);
+  }
+
+ private:
+  struct DepsGenerator {
+    std::vector<const Descriptor*> operator()(const Descriptor* desc) const {
+      std::vector<const Descriptor*> deps;
+      for (int i = 0; i < desc->field_count(); i++) {
+        if (desc->field(i)->message_type()) {
+          deps.push_back(desc->field(i)->message_type());
+        }
+      }
+      return deps;
+    }
+  };
+  SCCAnalyzer<DepsGenerator> analyzer_;
+  Options options_;
+  std::map<const SCC*, MessageAnalysis> analysis_cache_;
+};
+
+void ListAllFields(const Descriptor* d,
+                   std::vector<const FieldDescriptor*>* fields);
+void ListAllFields(const FileDescriptor* d,
+                   std::vector<const FieldDescriptor*>* fields);
+
+template <class T>
+void ForEachField(const Descriptor* d, T&& func) {
+  for (int i = 0; i < d->nested_type_count(); i++) {
+    ForEachField(d->nested_type(i), std::forward<T&&>(func));
+  }
+  for (int i = 0; i < d->extension_count(); i++) {
+    func(d->extension(i));
+  }
+  for (int i = 0; i < d->field_count(); i++) {
+    func(d->field(i));
+  }
+}
+
+template <class T>
+void ForEachField(const FileDescriptor* d, T&& func) {
+  for (int i = 0; i < d->message_type_count(); i++) {
+    ForEachField(d->message_type(i), std::forward<T&&>(func));
+  }
+  for (int i = 0; i < d->extension_count(); i++) {
+    func(d->extension(i));
+  }
+}
+
+void ListAllTypesForServices(const FileDescriptor* fd,
+                             std::vector<const Descriptor*>* types);
+
+// Indicates whether we should use implicit weak fields for this file.
+bool UsingImplicitWeakFields(const FileDescriptor* file,
+                             const Options& options);
+
+// Indicates whether to treat this field as implicitly weak.
+bool IsImplicitWeakField(const FieldDescriptor* field, const Options& options,
+                         MessageSCCAnalyzer* scc_analyzer);
+
+inline bool HasSimpleBaseClass(const Descriptor* desc, const Options& options) {
+  if (!HasDescriptorMethods(desc->file(), options)) return false;
+  if (desc->extension_range_count() != 0) return false;
+  if (desc->field_count() == 0) return true;
+  // TODO(jorg): Support additional common message types with only one
+  // or two fields
+  return false;
+}
+
+inline bool HasSimpleBaseClasses(const FileDescriptor* file,
+                                 const Options& options) {
+  bool v = false;
+  ForEachMessage(file, [&v, &options](const Descriptor* desc) {
+    v |= HasSimpleBaseClass(desc, options);
+  });
+  return v;
+}
+
+inline std::string SimpleBaseClass(const Descriptor* desc,
+                                   const Options& options) {
+  if (!HasDescriptorMethods(desc->file(), options)) return "";
+  if (desc->extension_range_count() != 0) return "";
+  if (desc->field_count() == 0) {
+    return "ZeroFieldsBase";
+  }
+  // TODO(jorg): Support additional common message types with only one
+  // or two fields
+  return "";
+}
+
+// Returns true if this message has a _tracker_ field.
+inline bool HasTracker(const Descriptor* desc, const Options& options) {
+  return options.field_listener_options.inject_field_listener_events &&
+         desc->file()->options().optimize_for() !=
+             google::protobuf::FileOptions::LITE_RUNTIME;
+}
+
+// Returns true if this message needs an Impl_ struct for it's data.
+inline bool HasImplData(const Descriptor* desc, const Options& options) {
+  return !HasSimpleBaseClass(desc, options);
+}
+
+// Formatter is a functor class which acts as a closure around printer and
+// the variable map. It's much like printer->Print except it supports both named
+// variables that are substituted using a key value map and direct arguments. In
+// the format string $1$, $2$, etc... are substituted for the first, second, ...
+// direct argument respectively in the format call, it accepts both strings and
+// integers. The implementation verifies all arguments are used and are "first"
+// used in order of appearance in the argument list. For example,
+//
+// Format("return array[$1$];", 3) -> "return array[3];"
+// Format("array[$2$] = $1$;", "Bla", 3) -> FATAL error (wrong order)
+// Format("array[$1$] = $2$;", 3, "Bla") -> "array[3] = Bla;"
+//
+// The arguments can be used more than once like
+//
+// Format("array[$1$] = $2$;  // Index = $1$", 3, "Bla") ->
+//        "array[3] = Bla;  // Index = 3"
+//
+// If you use more arguments use the following style to help the reader,
+//
+// Format("int $1$() {\n"
+//        "  array[$2$] = $3$;\n"
+//        "  return $4$;"
+//        "}\n",
+//        funname, // 1
+//        idx,  // 2
+//        varname,  // 3
+//        retval);  // 4
+//
+// but consider using named variables. Named variables like $foo$, with some
+// identifier foo, are looked up in the map. One additional feature is that
+// spaces are accepted between the '$' delimiters, $ foo$ will
+// substitute to " bar" if foo stands for "bar", but in case it's empty
+// will substitute to "". Hence, for example,
+//
+// Format(vars, "$dllexport $void fun();") -> "void fun();"
+//                                            "__declspec(export) void fun();"
+//
+// which is convenient to prevent double, leading or trailing spaces.
+class PROTOC_EXPORT Formatter {
+ public:
+  explicit Formatter(io::Printer* printer) : printer_(printer) {}
+  Formatter(io::Printer* printer,
+            const std::map<std::string, std::string>& vars)
+      : printer_(printer), vars_(vars) {}
+
+  template <typename T>
+  void Set(const std::string& key, const T& value) {
+    vars_[key] = ToString(value);
+  }
+
+  void AddMap(const std::map<std::string, std::string>& vars) {
+    for (const auto& keyval : vars) vars_[keyval.first] = keyval.second;
+  }
+
+  template <typename... Args>
+  void operator()(const char* format, const Args&... args) const {
+    printer_->FormatInternal({ToString(args)...}, vars_, format);
+  }
+
+  void Indent() const { printer_->Indent(); }
+  void Outdent() const { printer_->Outdent(); }
+  io::Printer* printer() const { return printer_; }
+
+  class PROTOC_EXPORT ScopedIndenter {
+   public:
+    explicit ScopedIndenter(Formatter* format) : format_(format) {
+      format_->Indent();
+    }
+    ~ScopedIndenter() { format_->Outdent(); }
+
+   private:
+    Formatter* format_;
+  };
+
+  PROTOBUF_NODISCARD ScopedIndenter ScopedIndent() {
+    return ScopedIndenter(this);
+  }
+  template <typename... Args>
+  PROTOBUF_NODISCARD ScopedIndenter ScopedIndent(const char* format,
+                                                 const Args&&... args) {
+    (*this)(format, static_cast<Args&&>(args)...);
+    return ScopedIndenter(this);
+  }
+
+  class PROTOC_EXPORT SaveState {
+   public:
+    explicit SaveState(Formatter* format)
+        : format_(format), vars_(format->vars_) {}
+    ~SaveState() { format_->vars_.swap(vars_); }
+
+   private:
+    Formatter* format_;
+    std::map<std::string, std::string> vars_;
+  };
+
+ private:
+  io::Printer* printer_;
+  std::map<std::string, std::string> vars_;
+
+  // Convenience overloads to accept different types as arguments.
+  static std::string ToString(const std::string& s) { return s; }
+  template <typename I, typename = typename std::enable_if<
+                            std::is_integral<I>::value>::type>
+  static std::string ToString(I x) {
+    return StrCat(x);
+  }
+  static std::string ToString(strings::Hex x) { return StrCat(x); }
+  static std::string ToString(const FieldDescriptor* d) { return Payload(d); }
+  static std::string ToString(const Descriptor* d) { return Payload(d); }
+  static std::string ToString(const EnumDescriptor* d) { return Payload(d); }
+  static std::string ToString(const EnumValueDescriptor* d) {
+    return Payload(d);
+  }
+  static std::string ToString(const OneofDescriptor* d) { return Payload(d); }
+
+  template <typename Descriptor>
+  static std::string Payload(const Descriptor* descriptor) {
+    std::vector<int> path;
+    descriptor->GetLocationPath(&path);
+    GeneratedCodeInfo::Annotation annotation;
+    for (int index : path) {
+      annotation.add_path(index);
+    }
+    annotation.set_source_file(descriptor->file()->name());
+    return annotation.SerializeAsString();
+  }
+};
+
+template <class T>
+void PrintFieldComment(const Formatter& format, const T* field) {
+  // Print the field's (or oneof's) proto-syntax definition as a comment.
+  // We don't want to print group bodies so we cut off after the first
+  // line.
+  DebugStringOptions options;
+  options.elide_group_body = true;
+  options.elide_oneof_body = true;
+  std::string def = field->DebugStringWithOptions(options);
+  format("// $1$\n", def.substr(0, def.find_first_of('\n')));
+}
+
+class PROTOC_EXPORT NamespaceOpener {
+ public:
+  explicit NamespaceOpener(const Formatter& format)
+      : printer_(format.printer()) {}
+  NamespaceOpener(const std::string& name, const Formatter& format)
+      : NamespaceOpener(format) {
+    ChangeTo(name);
+  }
+  ~NamespaceOpener() { ChangeTo(""); }
+
+  void ChangeTo(const std::string& name) {
+    std::vector<std::string> new_stack_ =
+        Split(name, "::", true);
+    size_t len = std::min(name_stack_.size(), new_stack_.size());
+    size_t common_idx = 0;
+    while (common_idx < len) {
+      if (name_stack_[common_idx] != new_stack_[common_idx]) break;
+      common_idx++;
+    }
+    for (auto it = name_stack_.crbegin();
+         it != name_stack_.crend() - common_idx; ++it) {
+      if (*it == "PROTOBUF_NAMESPACE_ID") {
+        printer_->Print("PROTOBUF_NAMESPACE_CLOSE\n");
+      } else {
+        printer_->Print("}  // namespace $ns$\n", "ns", *it);
+      }
+    }
+    name_stack_.swap(new_stack_);
+    for (size_t i = common_idx; i < name_stack_.size(); ++i) {
+      if (name_stack_[i] == "PROTOBUF_NAMESPACE_ID") {
+        printer_->Print("PROTOBUF_NAMESPACE_OPEN\n");
+      } else {
+        printer_->Print("namespace $ns$ {\n", "ns", name_stack_[i]);
+      }
+    }
+  }
+
+ private:
+  io::Printer* printer_;
+  std::vector<std::string> name_stack_;
+};
+
+enum class Utf8CheckMode {
+  kStrict = 0,  // Parsing will fail if non UTF-8 data is in string fields.
+  kVerify = 1,  // Only log an error but parsing will succeed.
+  kNone = 2,    // No UTF-8 check.
+};
+
+Utf8CheckMode GetUtf8CheckMode(const FieldDescriptor* field,
+                               const Options& options);
+
+void GenerateUtf8CheckCodeForString(const FieldDescriptor* field,
+                                    const Options& options, bool for_parse,
+                                    const char* parameters,
+                                    const Formatter& format);
+
+void GenerateUtf8CheckCodeForCord(const FieldDescriptor* field,
+                                  const Options& options, bool for_parse,
+                                  const char* parameters,
+                                  const Formatter& format);
+
+template <typename T>
+struct FieldRangeImpl {
+  struct Iterator {
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = const FieldDescriptor*;
+    using difference_type = int;
+
+    value_type operator*() { return descriptor->field(idx); }
+
+    friend bool operator==(const Iterator& a, const Iterator& b) {
+      GOOGLE_DCHECK(a.descriptor == b.descriptor);
+      return a.idx == b.idx;
+    }
+    friend bool operator!=(const Iterator& a, const Iterator& b) {
+      return !(a == b);
+    }
+
+    Iterator& operator++() {
+      idx++;
+      return *this;
+    }
+
+    int idx;
+    const T* descriptor;
+  };
+
+  Iterator begin() const { return {0, descriptor}; }
+  Iterator end() const { return {descriptor->field_count(), descriptor}; }
+
+  const T* descriptor;
+};
+
+template <typename T>
+FieldRangeImpl<T> FieldRange(const T* desc) {
+  return {desc};
+}
+
+struct OneOfRangeImpl {
+  struct Iterator {
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = const OneofDescriptor*;
+    using difference_type = int;
+
+    value_type operator*() { return descriptor->oneof_decl(idx); }
+
+    friend bool operator==(const Iterator& a, const Iterator& b) {
+      GOOGLE_DCHECK(a.descriptor == b.descriptor);
+      return a.idx == b.idx;
+    }
+    friend bool operator!=(const Iterator& a, const Iterator& b) {
+      return !(a == b);
+    }
+
+    Iterator& operator++() {
+      idx++;
+      return *this;
+    }
+
+    int idx;
+    const Descriptor* descriptor;
+  };
+
+  Iterator begin() const { return {0, descriptor}; }
+  Iterator end() const {
+    return {descriptor->real_oneof_decl_count(), descriptor};
+  }
+
+  const Descriptor* descriptor;
+};
+
+inline OneOfRangeImpl OneOfRange(const Descriptor* desc) { return {desc}; }
+
+PROTOC_EXPORT std::string StripProto(const std::string& filename);
+
+bool EnableMessageOwnedArena(const Descriptor* desc, const Options& options);
+
+bool EnableMessageOwnedArenaTrial(const Descriptor* desc,
+                                  const Options& options);
+
+bool ShouldVerify(const Descriptor* descriptor, const Options& options,
+                  MessageSCCAnalyzer* scc_analyzer);
+bool ShouldVerify(const FileDescriptor* file, const Options& options,
+                  MessageSCCAnalyzer* scc_analyzer);
+
+// Indicates whether to use predefined verify methods for a given message. If a
+// message is "simple" and needs no special verification per field (e.g. message
+// field, repeated packed, UTF8 string, etc.), we can use either VerifySimple or
+// VerifySimpleAlwaysCheckInt32 methods as all verification can be done based on
+// the wire type.
+//
+// Otherwise, we need "custom" verify methods tailored to a message to pass
+// which field needs a special verification; i.e. InternalVerify.
+enum class VerifySimpleType {
+  kSimpleInt32Never,   // Use VerifySimple
+  kSimpleInt32Always,  // Use VerifySimpleAlwaysCheckInt32
+  kCustom,             // Use InternalVerify and check only for int32
+  kCustomInt32Never,   // Use InternalVerify but never check for int32
+  kCustomInt32Always,  // Use InternalVerify and always check for int32
+};
+
+// Returns VerifySimpleType if messages can be verified by predefined methods.
+VerifySimpleType ShouldVerifySimple(const Descriptor* descriptor);
+
+bool IsUtf8String(const FieldDescriptor* field);
+
+bool HasMessageFieldOrExtension(const Descriptor* desc);
+
+}  // namespace cpp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CPP_HELPERS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/names.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/names.h
new file mode 100644
index 0000000..7404ac5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/names.h
@@ -0,0 +1,97 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_NAMES_H__
+#define GOOGLE_PROTOBUF_COMPILER_CPP_NAMES_H__
+
+#include <string>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class EnumValueDescriptor;
+class FieldDescriptor;
+
+namespace compiler {
+namespace cpp {
+
+// Returns the unqualified C++ name.
+//
+// For example, if you had:
+//   package foo.bar;
+//   message Baz { message Moo {} }
+// Then the non-qualified version would be:
+//   Baz_Moo
+std::string ClassName(const Descriptor* descriptor);
+std::string ClassName(const EnumDescriptor* enum_descriptor);
+
+// Returns the fully qualified C++ name.
+//
+// For example, if you had:
+//   package foo.bar;
+//   message Baz { message Moo {} }
+// Then the qualified ClassName for Moo would be:
+//   ::foo::bar::Baz_Moo
+std::string QualifiedClassName(const Descriptor* d);
+std::string QualifiedClassName(const EnumDescriptor* d);
+std::string QualifiedExtensionName(const FieldDescriptor* d);
+
+// Get the (unqualified) name that should be used for this field in C++ code.
+// The name is coerced to lower-case to emulate proto1 behavior.  People
+// should be using lowercase-with-underscores style for proto field names
+// anyway, so normally this just returns field->name().
+std::string FieldName(const FieldDescriptor* field);
+
+// Requires that this field is in a oneof. Returns the (unqualified) case
+// constant for this field.
+std::string OneofCaseConstantName(const FieldDescriptor* field);
+// Returns the quafilied case constant for this field.
+std::string QualifiedOneofCaseConstantName(const FieldDescriptor* field);
+
+// Get the (unqualified) name that should be used for this enum value in C++
+// code.
+std::string EnumValueName(const EnumValueDescriptor* enum_value);
+
+// Strips ".proto" or ".protodevel" from the end of a filename.
+PROTOC_EXPORT std::string StripProto(const std::string& filename);
+
+}  // namespace cpp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CPP_NAMES_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_doc_comment.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_doc_comment.h
new file mode 100644
index 0000000..75eb0ea
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_doc_comment.h
@@ -0,0 +1,51 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_DOC_COMMENT_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_DOC_COMMENT_H__
+
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/descriptor.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace csharp {
+    void WriteMessageDocComment(io::Printer* printer, const Descriptor* message);
+    void WritePropertyDocComment(io::Printer* printer, const FieldDescriptor* field);
+    void WriteEnumDocComment(io::Printer* printer, const EnumDescriptor* enumDescriptor);
+    void WriteEnumValueDocComment(io::Printer* printer, const EnumValueDescriptor* value);
+    void WriteMethodDocComment(io::Printer* printer, const MethodDescriptor* method);
+}  // namespace csharp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_DOC_COMMENT_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_generator.h
new file mode 100644
index 0000000..f41f9b8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_generator.h
@@ -0,0 +1,70 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates C# code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__
+
+#include <string>
+
+#include <google/protobuf/compiler/code_generator.h>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace csharp {
+
+// CodeGenerator implementation which generates a C# source file and
+// header.  If you create your own protocol compiler binary and you want
+// it to support C# output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class PROTOC_EXPORT Generator : public CodeGenerator {
+ public:
+  Generator();
+  ~Generator();
+  bool Generate(
+    const FileDescriptor* file,
+    const std::string& parameter,
+    GeneratorContext* generator_context,
+    std::string* error) const override;
+  uint64_t GetSupportedFeatures() const override;
+};
+
+}  // namespace csharp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_names.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_names.h
new file mode 100644
index 0000000..67e53b6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_names.h
@@ -0,0 +1,109 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Provides a mechanism for mapping a descriptor to the
+// fully-qualified name of the corresponding C# class.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
+
+#include <string>
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/common.h>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class FileDescriptor;
+class ServiceDescriptor;
+
+namespace compiler {
+namespace csharp {
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The namespace to use for given file descriptor.
+std::string PROTOC_EXPORT GetFileNamespace(const FileDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified C# class name.
+std::string PROTOC_EXPORT GetClassName(const Descriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified name of the C# class that provides
+//   access to the file descriptor. Proto compiler generates
+//   such class for each .proto file processed.
+std::string PROTOC_EXPORT
+GetReflectionClassName(const FileDescriptor* descriptor);
+
+// Generates output file name for given file descriptor. If generate_directories
+// is true, the output file will be put under directory corresponding to file's
+// namespace. base_namespace can be used to strip some of the top level
+// directories. E.g. for file with namespace "Bar.Foo" and base_namespace="Bar",
+// the resulting file will be put under directory "Foo" (and not "Bar/Foo").
+//
+// Requires:
+//   descriptor != NULL
+//   error != NULL
+//
+//  Returns:
+//    The file name to use as output file for given file descriptor. In case
+//    of failure, this function will return empty string and error parameter
+//    will contain the error message.
+std::string PROTOC_EXPORT GetOutputFile(const FileDescriptor* descriptor,
+                                        const std::string file_extension,
+                                        const bool generate_directories,
+                                        const std::string base_namespace,
+                                        std::string* error);
+
+}  // namespace csharp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_options.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_options.h
new file mode 100644
index 0000000..42ff6d8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_options.h
@@ -0,0 +1,81 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_OPTIONS_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_OPTIONS_H__
+
+#include <string>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace csharp {
+
+// Generator options (used by csharp_generator.cc):
+struct Options {
+  Options() :
+      file_extension(".cs"),
+      base_namespace(""),
+      base_namespace_specified(false),
+      internal_access(false),
+      serializable(false) {
+  }
+  // Extension of the generated file. Defaults to ".cs"
+  std::string file_extension;
+  // Base namespace to use to create directory hierarchy. Defaults to "".
+  // This option allows the simple creation of a conventional C# file layout,
+  // where directories are created relative to a project-specific base
+  // namespace. For example, in a project with a base namespace of PetShop, a
+  // proto of user.proto with a C# namespace of PetShop.Model.Shared would
+  // generate Model/Shared/User.cs underneath the specified --csharp_out
+  // directory.
+  //
+  // If no base namespace is specified, all files are generated in the
+  // --csharp_out directory, with no subdirectories created automatically.
+  std::string base_namespace;
+  // Whether the base namespace has been explicitly specified by the user.
+  // This is required as the base namespace can be explicitly set to the empty
+  // string, meaning "create a full directory hierarchy, starting from the first
+  // segment of the namespace."
+  bool base_namespace_specified;
+  // Whether the generated classes should have accessibility level of "internal".
+  // Defaults to false that generates "public" classes.
+  bool internal_access;
+  // Whether the generated classes should have a global::System.Serializable attribute added
+  // Defaults to false
+  bool serializable;
+};
+
+}  // namespace csharp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_OPTIONS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/importer.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/importer.h
new file mode 100644
index 0000000..2fb88b9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/importer.h
@@ -0,0 +1,338 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file is the public interface to the .proto file parser.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
+#define GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
+
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <google/protobuf/compiler/parser.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor_database.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+namespace io {
+class ZeroCopyInputStream;
+}
+
+namespace compiler {
+
+// Defined in this file.
+class Importer;
+class MultiFileErrorCollector;
+class SourceTree;
+class DiskSourceTree;
+
+// TODO(kenton):  Move all SourceTree stuff to a separate file?
+
+// An implementation of DescriptorDatabase which loads files from a SourceTree
+// and parses them.
+//
+// Note:  This class is not thread-safe since it maintains a table of source
+//   code locations for error reporting.  However, when a DescriptorPool wraps
+//   a DescriptorDatabase, it uses mutex locking to make sure only one method
+//   of the database is called at a time, even if the DescriptorPool is used
+//   from multiple threads.  Therefore, there is only a problem if you create
+//   multiple DescriptorPools wrapping the same SourceTreeDescriptorDatabase
+//   and use them from multiple threads.
+//
+// Note:  This class does not implement FindFileContainingSymbol() or
+//   FindFileContainingExtension(); these will always return false.
+class PROTOBUF_EXPORT SourceTreeDescriptorDatabase : public DescriptorDatabase {
+ public:
+  SourceTreeDescriptorDatabase(SourceTree* source_tree);
+
+  // If non-NULL, fallback_database will be checked if a file doesn't exist in
+  // the specified source_tree.
+  SourceTreeDescriptorDatabase(SourceTree* source_tree,
+                               DescriptorDatabase* fallback_database);
+  ~SourceTreeDescriptorDatabase() override;
+
+  // Instructs the SourceTreeDescriptorDatabase to report any parse errors
+  // to the given MultiFileErrorCollector.  This should be called before
+  // parsing.  error_collector must remain valid until either this method
+  // is called again or the SourceTreeDescriptorDatabase is destroyed.
+  void RecordErrorsTo(MultiFileErrorCollector* error_collector) {
+    error_collector_ = error_collector;
+  }
+
+  // Gets a DescriptorPool::ErrorCollector which records errors to the
+  // MultiFileErrorCollector specified with RecordErrorsTo().  This collector
+  // has the ability to determine exact line and column numbers of errors
+  // from the information given to it by the DescriptorPool.
+  DescriptorPool::ErrorCollector* GetValidationErrorCollector() {
+    using_validation_error_collector_ = true;
+    return &validation_error_collector_;
+  }
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const std::string& filename,
+                      FileDescriptorProto* output) override;
+  bool FindFileContainingSymbol(const std::string& symbol_name,
+                                FileDescriptorProto* output) override;
+  bool FindFileContainingExtension(const std::string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output) override;
+
+ private:
+  class SingleFileErrorCollector;
+
+  SourceTree* source_tree_;
+  DescriptorDatabase* fallback_database_;
+  MultiFileErrorCollector* error_collector_;
+
+  class PROTOBUF_EXPORT ValidationErrorCollector
+      : public DescriptorPool::ErrorCollector {
+   public:
+    ValidationErrorCollector(SourceTreeDescriptorDatabase* owner);
+    ~ValidationErrorCollector() override;
+
+    // implements ErrorCollector ---------------------------------------
+    void AddError(const std::string& filename, const std::string& element_name,
+                  const Message* descriptor, ErrorLocation location,
+                  const std::string& message) override;
+
+    void AddWarning(const std::string& filename,
+                    const std::string& element_name, const Message* descriptor,
+                    ErrorLocation location,
+                    const std::string& message) override;
+
+   private:
+    SourceTreeDescriptorDatabase* owner_;
+  };
+  friend class ValidationErrorCollector;
+
+  bool using_validation_error_collector_;
+  SourceLocationTable source_locations_;
+  ValidationErrorCollector validation_error_collector_;
+};
+
+// Simple interface for parsing .proto files.  This wraps the process
+// of opening the file, parsing it with a Parser, recursively parsing all its
+// imports, and then cross-linking the results to produce a FileDescriptor.
+//
+// This is really just a thin wrapper around SourceTreeDescriptorDatabase.
+// You may find that SourceTreeDescriptorDatabase is more flexible.
+//
+// TODO(kenton):  I feel like this class is not well-named.
+class PROTOBUF_EXPORT Importer {
+ public:
+  Importer(SourceTree* source_tree, MultiFileErrorCollector* error_collector);
+  ~Importer();
+
+  // Import the given file and build a FileDescriptor representing it.  If
+  // the file is already in the DescriptorPool, the existing FileDescriptor
+  // will be returned.  The FileDescriptor is property of the DescriptorPool,
+  // and will remain valid until it is destroyed.  If any errors occur, they
+  // will be reported using the error collector and Import() will return NULL.
+  //
+  // A particular Importer object will only report errors for a particular
+  // file once.  All future attempts to import the same file will return NULL
+  // without reporting any errors.  The idea is that you might want to import
+  // a lot of files without seeing the same errors over and over again.  If
+  // you want to see errors for the same files repeatedly, you can use a
+  // separate Importer object to import each one (but use the same
+  // DescriptorPool so that they can be cross-linked).
+  const FileDescriptor* Import(const std::string& filename);
+
+  // The DescriptorPool in which all imported FileDescriptors and their
+  // contents are stored.
+  inline const DescriptorPool* pool() const { return &pool_; }
+
+  void AddUnusedImportTrackFile(const std::string& file_name,
+                                bool is_error = false);
+  void ClearUnusedImportTrackFiles();
+
+
+ private:
+  SourceTreeDescriptorDatabase database_;
+  DescriptorPool pool_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Importer);
+};
+
+// If the importer encounters problems while trying to import the proto files,
+// it reports them to a MultiFileErrorCollector.
+class PROTOBUF_EXPORT MultiFileErrorCollector {
+ public:
+  inline MultiFileErrorCollector() {}
+  virtual ~MultiFileErrorCollector();
+
+  // Line and column numbers are zero-based.  A line number of -1 indicates
+  // an error with the entire file (e.g. "not found").
+  virtual void AddError(const std::string& filename, int line, int column,
+                        const std::string& message) = 0;
+
+  virtual void AddWarning(const std::string& /* filename */, int /* line */,
+                          int /* column */, const std::string& /* message */) {}
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultiFileErrorCollector);
+};
+
+// Abstract interface which represents a directory tree containing proto files.
+// Used by the default implementation of Importer to resolve import statements
+// Most users will probably want to use the DiskSourceTree implementation,
+// below.
+class PROTOBUF_EXPORT SourceTree {
+ public:
+  inline SourceTree() {}
+  virtual ~SourceTree();
+
+  // Open the given file and return a stream that reads it, or NULL if not
+  // found.  The caller takes ownership of the returned object.  The filename
+  // must be a path relative to the root of the source tree and must not
+  // contain "." or ".." components.
+  virtual io::ZeroCopyInputStream* Open(const std::string& filename) = 0;
+
+  // If Open() returns NULL, calling this method immediately will return an
+  // description of the error.
+  // Subclasses should implement this method and return a meaningful value for
+  // better error reporting.
+  // TODO(xiaofeng): change this to a pure virtual function.
+  virtual std::string GetLastErrorMessage();
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SourceTree);
+};
+
+// An implementation of SourceTree which loads files from locations on disk.
+// Multiple mappings can be set up to map locations in the DiskSourceTree to
+// locations in the physical filesystem.
+class PROTOBUF_EXPORT DiskSourceTree : public SourceTree {
+ public:
+  DiskSourceTree();
+  ~DiskSourceTree() override;
+
+  // Map a path on disk to a location in the SourceTree.  The path may be
+  // either a file or a directory.  If it is a directory, the entire tree
+  // under it will be mapped to the given virtual location.  To map a directory
+  // to the root of the source tree, pass an empty string for virtual_path.
+  //
+  // If multiple mapped paths apply when opening a file, they will be searched
+  // in order.  For example, if you do:
+  //   MapPath("bar", "foo/bar");
+  //   MapPath("", "baz");
+  // and then you do:
+  //   Open("bar/qux");
+  // the DiskSourceTree will first try to open foo/bar/qux, then baz/bar/qux,
+  // returning the first one that opens successfully.
+  //
+  // disk_path may be an absolute path or relative to the current directory,
+  // just like a path you'd pass to open().
+  void MapPath(const std::string& virtual_path, const std::string& disk_path);
+
+  // Return type for DiskFileToVirtualFile().
+  enum DiskFileToVirtualFileResult {
+    SUCCESS,
+    SHADOWED,
+    CANNOT_OPEN,
+    NO_MAPPING
+  };
+
+  // Given a path to a file on disk, find a virtual path mapping to that
+  // file.  The first mapping created with MapPath() whose disk_path contains
+  // the filename is used.  However, that virtual path may not actually be
+  // usable to open the given file.  Possible return values are:
+  // * SUCCESS: The mapping was found.  *virtual_file is filled in so that
+  //   calling Open(*virtual_file) will open the file named by disk_file.
+  // * SHADOWED: A mapping was found, but using Open() to open this virtual
+  //   path will end up returning some different file.  This is because some
+  //   other mapping with a higher precedence also matches this virtual path
+  //   and maps it to a different file that exists on disk.  *virtual_file
+  //   is filled in as it would be in the SUCCESS case.  *shadowing_disk_file
+  //   is filled in with the disk path of the file which would be opened if
+  //   you were to call Open(*virtual_file).
+  // * CANNOT_OPEN: The mapping was found and was not shadowed, but the
+  //   file specified cannot be opened.  When this value is returned,
+  //   errno will indicate the reason the file cannot be opened.  *virtual_file
+  //   will be set to the virtual path as in the SUCCESS case, even though
+  //   it is not useful.
+  // * NO_MAPPING: Indicates that no mapping was found which contains this
+  //   file.
+  DiskFileToVirtualFileResult DiskFileToVirtualFile(
+      const std::string& disk_file, std::string* virtual_file,
+      std::string* shadowing_disk_file);
+
+  // Given a virtual path, find the path to the file on disk.
+  // Return true and update disk_file with the on-disk path if the file exists.
+  // Return false and leave disk_file untouched if the file doesn't exist.
+  bool VirtualFileToDiskFile(const std::string& virtual_file,
+                             std::string* disk_file);
+
+  // implements SourceTree -------------------------------------------
+  io::ZeroCopyInputStream* Open(const std::string& filename) override;
+
+  std::string GetLastErrorMessage() override;
+
+ private:
+  struct Mapping {
+    std::string virtual_path;
+    std::string disk_path;
+
+    inline Mapping(const std::string& virtual_path_param,
+                   const std::string& disk_path_param)
+        : virtual_path(virtual_path_param), disk_path(disk_path_param) {}
+  };
+  std::vector<Mapping> mappings_;
+  std::string last_error_message_;
+
+  // Like Open(), but returns the on-disk path in disk_file if disk_file is
+  // non-NULL and the file could be successfully opened.
+  io::ZeroCopyInputStream* OpenVirtualFile(const std::string& virtual_file,
+                                           std::string* disk_file);
+
+  // Like Open() but given the actual on-disk path.
+  io::ZeroCopyInputStream* OpenDiskFile(const std::string& filename);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DiskSourceTree);
+};
+
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/generator.h
new file mode 100644
index 0000000..bbc7170
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/generator.h
@@ -0,0 +1,77 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates Java code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace java {
+
+// CodeGenerator implementation which generates Java code.  If you create your
+// own protocol compiler binary and you want it to support Java output, you
+// can do so by registering an instance of this CodeGenerator with the
+// CommandLineInterface in your main() function.
+class PROTOC_EXPORT JavaGenerator : public CodeGenerator {
+ public:
+  JavaGenerator();
+  ~JavaGenerator() override;
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file, const std::string& parameter,
+                GeneratorContext* context, std::string* error) const override;
+
+  uint64_t GetSupportedFeatures() const override;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(JavaGenerator);
+};
+
+}  // namespace java
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/java_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/java_generator.h
new file mode 100644
index 0000000..294b1bd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/java_generator.h
@@ -0,0 +1,6 @@
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_JAVA_GENERATOR_H_
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_JAVA_GENERATOR_H_
+
+#include <google/protobuf/compiler/java/generator.h>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_JAVA_GENERATOR_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/kotlin_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/kotlin_generator.h
new file mode 100644
index 0000000..ccd9688
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/kotlin_generator.h
@@ -0,0 +1,74 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates Kotlin code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_KOTLIN_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_KOTLIN_GENERATOR_H__
+
+#include <string>
+
+#include <google/protobuf/compiler/code_generator.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace java {
+
+// CodeGenerator implementation which generates Kotlin code.  If you create your
+// own protocol compiler binary and you want it to support Kotlin output, you
+// can do so by registering an instance of this CodeGenerator with the
+// CommandLineInterface in your main() function.
+class PROTOC_EXPORT KotlinGenerator : public CodeGenerator {
+ public:
+  KotlinGenerator();
+  ~KotlinGenerator() override;
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file, const std::string& parameter,
+                GeneratorContext* context, std::string* error) const override;
+
+  uint64_t GetSupportedFeatures() const override;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(KotlinGenerator);
+};
+
+}  // namespace java
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_KOTLIN_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/names.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/names.h
new file mode 100644
index 0000000..313ace4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/names.h
@@ -0,0 +1,100 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Provides a mechanism for mapping a descriptor to the
+// fully-qualified name of the corresponding Java class.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
+
+#include <string>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class FileDescriptor;
+class FieldDescriptor;
+class ServiceDescriptor;
+
+namespace compiler {
+namespace java {
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+std::string ClassName(const Descriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+std::string ClassName(const EnumDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+std::string ClassName(const FileDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+std::string ClassName(const ServiceDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   Java package name.
+std::string FileJavaPackage(const FileDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+// Returns:
+//   Capitalized camel case name field name.
+std::string CapitalizedFieldName(const FieldDescriptor* descriptor);
+
+}  // namespace java
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_generator.h
new file mode 100644
index 0000000..1dbc666
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_generator.h
@@ -0,0 +1,79 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates ObjectiveC code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/descriptor.h>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace objectivec {
+
+// CodeGenerator implementation which generates a ObjectiveC source file and
+// header.  If you create your own protocol compiler binary and you want it to
+// support ObjectiveC output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class PROTOC_EXPORT ObjectiveCGenerator : public CodeGenerator {
+ public:
+  ObjectiveCGenerator();
+  ~ObjectiveCGenerator();
+
+  ObjectiveCGenerator(const ObjectiveCGenerator&) = delete;
+  ObjectiveCGenerator& operator=(const ObjectiveCGenerator&) = delete;
+
+  // implements CodeGenerator ----------------------------------------
+  bool HasGenerateAll() const override;
+  bool Generate(const FileDescriptor* file, const std::string& parameter,
+                GeneratorContext* context, std::string* error) const override;
+  bool GenerateAll(const std::vector<const FileDescriptor*>& files,
+                   const std::string& parameter, GeneratorContext* context,
+                   std::string* error) const override;
+
+  uint64_t GetSupportedFeatures() const override {
+    return FEATURE_PROTO3_OPTIONAL;
+  }
+};
+
+}  // namespace objectivec
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_helpers.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_helpers.h
new file mode 100644
index 0000000..d21fed2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_helpers.h
@@ -0,0 +1,353 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Helper functions for generating ObjectiveC code.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_HELPERS_H__
+#define GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_HELPERS_H__
+
+#include <string>
+#include <vector>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace objectivec {
+
+// Get/Set the path to a file to load for objc class prefix lookups.
+std::string PROTOC_EXPORT GetPackageToPrefixMappingsPath();
+void PROTOC_EXPORT SetPackageToPrefixMappingsPath(
+    const std::string& file_path);
+// Get/Set if the proto package should be used to make the default prefix for
+// symbols. This will then impact most of the type naming apis below. It is done
+// as a global to not break any other generator reusing the methods since they
+// are exported.
+bool PROTOC_EXPORT UseProtoPackageAsDefaultPrefix();
+void PROTOC_EXPORT SetUseProtoPackageAsDefaultPrefix(bool on_or_off);
+// Get/Set the path to a file to load as exceptions when
+// `UseProtoPackageAsDefaultPrefix()` is `true`. An empty string means there
+// should be no exceptions.
+std::string PROTOC_EXPORT GetProtoPackagePrefixExceptionList();
+void PROTOC_EXPORT SetProtoPackagePrefixExceptionList(
+    const std::string& file_path);
+
+// Generator Prefix Validation Options (see objectivec_generator.cc for a
+// description of each):
+struct Options {
+  Options();
+  std::string expected_prefixes_path;
+  std::vector<std::string> expected_prefixes_suppressions;
+  bool prefixes_must_be_registered;
+  bool require_prefixes;
+};
+
+// Escape C++ trigraphs by escaping question marks to "\?".
+std::string PROTOC_EXPORT EscapeTrigraphs(const std::string& to_escape);
+
+// Remove white space from either end of a StringPiece.
+void PROTOC_EXPORT TrimWhitespace(StringPiece* input);
+
+// Returns true if the name requires a ns_returns_not_retained attribute applied
+// to it.
+bool PROTOC_EXPORT IsRetainedName(const std::string& name);
+
+// Returns true if the name starts with "init" and will need to have special
+// handling under ARC.
+bool PROTOC_EXPORT IsInitName(const std::string& name);
+
+// Gets the objc_class_prefix or the prefix made from the proto package.
+std::string PROTOC_EXPORT FileClassPrefix(const FileDescriptor* file);
+
+// Gets the path of the file we're going to generate (sans the .pb.h
+// extension).  The path will be dependent on the objectivec package
+// declared in the proto package.
+std::string PROTOC_EXPORT FilePath(const FileDescriptor* file);
+
+// Just like FilePath(), but without the directory part.
+std::string PROTOC_EXPORT FilePathBasename(const FileDescriptor* file);
+
+// Gets the name of the root class we'll generate in the file.  This class
+// is not meant for external consumption, but instead contains helpers that
+// the rest of the classes need
+std::string PROTOC_EXPORT FileClassName(const FileDescriptor* file);
+
+// These return the fully-qualified class name corresponding to the given
+// descriptor.
+std::string PROTOC_EXPORT ClassName(const Descriptor* descriptor);
+std::string PROTOC_EXPORT ClassName(const Descriptor* descriptor,
+                                    std::string* out_suffix_added);
+std::string PROTOC_EXPORT EnumName(const EnumDescriptor* descriptor);
+
+// Returns the fully-qualified name of the enum value corresponding to the
+// the descriptor.
+std::string PROTOC_EXPORT EnumValueName(const EnumValueDescriptor* descriptor);
+
+// Returns the name of the enum value corresponding to the descriptor.
+std::string PROTOC_EXPORT EnumValueShortName(const EnumValueDescriptor* descriptor);
+
+// Reverse what an enum does.
+std::string PROTOC_EXPORT UnCamelCaseEnumShortName(const std::string& name);
+
+// Returns the name to use for the extension (used as the method off the file's
+// Root class).
+std::string PROTOC_EXPORT ExtensionMethodName(const FieldDescriptor* descriptor);
+
+// Returns the transformed field name.
+std::string PROTOC_EXPORT FieldName(const FieldDescriptor* field);
+std::string PROTOC_EXPORT FieldNameCapitalized(const FieldDescriptor* field);
+
+// Returns the transformed oneof name.
+std::string PROTOC_EXPORT OneofEnumName(const OneofDescriptor* descriptor);
+std::string PROTOC_EXPORT OneofName(const OneofDescriptor* descriptor);
+std::string PROTOC_EXPORT OneofNameCapitalized(const OneofDescriptor* descriptor);
+
+// Returns a symbol that can be used in C code to refer to an Objective C
+// class without initializing the class.
+std::string PROTOC_EXPORT ObjCClass(const std::string& class_name);
+
+// Declares an Objective C class without initializing the class so that it can
+// be refrerred to by ObjCClass.
+std::string PROTOC_EXPORT ObjCClassDeclaration(const std::string& class_name);
+
+inline bool HasPreservingUnknownEnumSemantics(const FileDescriptor* file) {
+  return file->syntax() == FileDescriptor::SYNTAX_PROTO3;
+}
+
+inline bool IsMapEntryMessage(const Descriptor* descriptor) {
+  return descriptor->options().map_entry();
+}
+
+// Reverse of the above.
+std::string PROTOC_EXPORT UnCamelCaseFieldName(const std::string& name,
+                                               const FieldDescriptor* field);
+
+enum ObjectiveCType {
+  OBJECTIVECTYPE_INT32,
+  OBJECTIVECTYPE_UINT32,
+  OBJECTIVECTYPE_INT64,
+  OBJECTIVECTYPE_UINT64,
+  OBJECTIVECTYPE_FLOAT,
+  OBJECTIVECTYPE_DOUBLE,
+  OBJECTIVECTYPE_BOOLEAN,
+  OBJECTIVECTYPE_STRING,
+  OBJECTIVECTYPE_DATA,
+  OBJECTIVECTYPE_ENUM,
+  OBJECTIVECTYPE_MESSAGE
+};
+
+enum FlagType {
+  FLAGTYPE_DESCRIPTOR_INITIALIZATION,
+  FLAGTYPE_EXTENSION,
+  FLAGTYPE_FIELD
+};
+
+template <class TDescriptor>
+std::string GetOptionalDeprecatedAttribute(const TDescriptor* descriptor,
+                                           const FileDescriptor* file = NULL,
+                                           bool preSpace = true,
+                                           bool postNewline = false) {
+  bool isDeprecated = descriptor->options().deprecated();
+  // The file is only passed when checking Messages & Enums, so those types
+  // get tagged. At the moment, it doesn't seem to make sense to tag every
+  // field or enum value with when the file is deprecated.
+  bool isFileLevelDeprecation = false;
+  if (!isDeprecated && file) {
+    isFileLevelDeprecation = file->options().deprecated();
+    isDeprecated = isFileLevelDeprecation;
+  }
+  if (isDeprecated) {
+    std::string message;
+    const FileDescriptor* sourceFile = descriptor->file();
+    if (isFileLevelDeprecation) {
+      message = sourceFile->name() + " is deprecated.";
+    } else {
+      message = descriptor->full_name() + " is deprecated (see " +
+                sourceFile->name() + ").";
+    }
+
+    std::string result = std::string("GPB_DEPRECATED_MSG(\"") + message + "\")";
+    if (preSpace) {
+      result.insert(0, " ");
+    }
+    if (postNewline) {
+      result.append("\n");
+    }
+    return result;
+  } else {
+    return "";
+  }
+}
+
+std::string PROTOC_EXPORT GetCapitalizedType(const FieldDescriptor* field);
+
+ObjectiveCType PROTOC_EXPORT
+GetObjectiveCType(FieldDescriptor::Type field_type);
+
+inline ObjectiveCType GetObjectiveCType(const FieldDescriptor* field) {
+  return GetObjectiveCType(field->type());
+}
+
+bool PROTOC_EXPORT IsPrimitiveType(const FieldDescriptor* field);
+bool PROTOC_EXPORT IsReferenceType(const FieldDescriptor* field);
+
+std::string PROTOC_EXPORT
+GPBGenericValueFieldName(const FieldDescriptor* field);
+std::string PROTOC_EXPORT DefaultValue(const FieldDescriptor* field);
+bool PROTOC_EXPORT HasNonZeroDefaultValue(const FieldDescriptor* field);
+
+std::string PROTOC_EXPORT
+BuildFlagsString(const FlagType type, const std::vector<std::string>& strings);
+
+// Builds HeaderDoc/appledoc style comments out of the comments in the .proto
+// file.
+std::string PROTOC_EXPORT BuildCommentsString(const SourceLocation& location,
+                                              bool prefer_single_line);
+
+// The name the commonly used by the library when built as a framework.
+// This lines up to the name used in the CocoaPod.
+extern PROTOC_EXPORT const char* const ProtobufLibraryFrameworkName;
+// Returns the CPP symbol name to use as the gate for framework style imports
+// for the given framework name to use.
+std::string PROTOC_EXPORT
+ProtobufFrameworkImportSymbol(const std::string& framework_name);
+
+// Checks if the file is one of the proto's bundled with the library.
+bool PROTOC_EXPORT
+IsProtobufLibraryBundledProtoFile(const FileDescriptor* file);
+
+// Checks the prefix for the given files and outputs any warnings as needed. If
+// there are flat out errors, then out_error is filled in with the first error
+// and the result is false.
+bool PROTOC_EXPORT ValidateObjCClassPrefixes(
+    const std::vector<const FileDescriptor*>& files,
+    const Options& validation_options, std::string* out_error);
+// Same was the other ValidateObjCClassPrefixes() calls, but the options all
+// come from the environment variables.
+bool PROTOC_EXPORT ValidateObjCClassPrefixes(
+    const std::vector<const FileDescriptor*>& files, std::string* out_error);
+
+// Generate decode data needed for ObjC's GPBDecodeTextFormatName() to transform
+// the input into the expected output.
+class PROTOC_EXPORT TextFormatDecodeData {
+ public:
+  TextFormatDecodeData();
+  ~TextFormatDecodeData();
+
+  TextFormatDecodeData(const TextFormatDecodeData&) = delete;
+  TextFormatDecodeData& operator=(const TextFormatDecodeData&) = delete;
+
+  void AddString(int32_t key, const std::string& input_for_decode,
+                 const std::string& desired_output);
+  size_t num_entries() const { return entries_.size(); }
+  std::string Data() const;
+
+  static std::string DecodeDataForString(const std::string& input_for_decode,
+                                         const std::string& desired_output);
+
+ private:
+  typedef std::pair<int32_t, std::string> DataEntry;
+  std::vector<DataEntry> entries_;
+};
+
+// Helper for parsing simple files.
+class PROTOC_EXPORT LineConsumer {
+ public:
+  LineConsumer();
+  virtual ~LineConsumer();
+  virtual bool ConsumeLine(const StringPiece& line, std::string* out_error) = 0;
+};
+
+bool PROTOC_EXPORT ParseSimpleFile(const std::string& path,
+                                   LineConsumer* line_consumer,
+                                   std::string* out_error);
+
+bool PROTOC_EXPORT ParseSimpleStream(io::ZeroCopyInputStream& input_stream,
+                                     const std::string& stream_name,
+                                     LineConsumer* line_consumer,
+                                     std::string* out_error);
+
+// Helper class for parsing framework import mappings and generating
+// import statements.
+class PROTOC_EXPORT ImportWriter {
+ public:
+  ImportWriter(const std::string& generate_for_named_framework,
+               const std::string& named_framework_to_proto_path_mappings_path,
+               const std::string& runtime_import_prefix,
+               bool include_wkt_imports);
+  ~ImportWriter();
+
+  void AddFile(const FileDescriptor* file, const std::string& header_extension);
+  void Print(io::Printer* printer) const;
+
+  static void PrintRuntimeImports(io::Printer* printer,
+                                  const std::vector<std::string>& header_to_import,
+                                  const std::string& runtime_import_prefix,
+                                  bool default_cpp_symbol = false);
+
+ private:
+  class ProtoFrameworkCollector : public LineConsumer {
+   public:
+    ProtoFrameworkCollector(std::map<std::string, std::string>* inout_proto_file_to_framework_name)
+        : map_(inout_proto_file_to_framework_name) {}
+
+    virtual bool ConsumeLine(const StringPiece& line, std::string* out_error) override;
+
+   private:
+    std::map<std::string, std::string>* map_;
+  };
+
+  void ParseFrameworkMappings();
+
+  const std::string generate_for_named_framework_;
+  const std::string named_framework_to_proto_path_mappings_path_;
+  const std::string runtime_import_prefix_;
+  const bool include_wkt_imports_;
+  std::map<std::string, std::string> proto_file_to_framework_name_;
+  bool need_to_parse_mapping_file_;
+
+  std::vector<std::string> protobuf_imports_;
+  std::vector<std::string> other_framework_imports_;
+  std::vector<std::string> other_imports_;
+};
+
+}  // namespace objectivec
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_HELPERS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/parser.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/parser.h
new file mode 100644
index 0000000..d4eb763
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/parser.h
@@ -0,0 +1,602 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Implements parsing of .proto files to FileDescriptorProtos.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PARSER_H__
+#define GOOGLE_PROTOBUF_COMPILER_PARSER_H__
+
+#include <cstdint>
+#include <map>
+#include <string>
+#include <utility>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/io/tokenizer.h>
+#include <google/protobuf/repeated_field.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class Message;
+
+namespace compiler {
+
+// Defined in this file.
+class Parser;
+class SourceLocationTable;
+
+// Implements parsing of protocol definitions (such as .proto files).
+//
+// Note that most users will be more interested in the Importer class.
+// Parser is a lower-level class which simply converts a single .proto file
+// to a FileDescriptorProto.  It does not resolve import directives or perform
+// many other kinds of validation needed to construct a complete
+// FileDescriptor.
+class PROTOBUF_EXPORT Parser {
+ public:
+  Parser();
+  ~Parser();
+
+  // Parse the entire input and construct a FileDescriptorProto representing
+  // it.  Returns true if no errors occurred, false otherwise.
+  bool Parse(io::Tokenizer* input, FileDescriptorProto* file);
+
+  // Optional features:
+
+  // DEPRECATED:  New code should use the SourceCodeInfo embedded in the
+  //   FileDescriptorProto.
+  //
+  // Requests that locations of certain definitions be recorded to the given
+  // SourceLocationTable while parsing.  This can be used to look up exact line
+  // and column numbers for errors reported by DescriptorPool during validation.
+  // Set to NULL (the default) to discard source location information.
+  void RecordSourceLocationsTo(SourceLocationTable* location_table) {
+    source_location_table_ = location_table;
+  }
+
+  // Requests that errors be recorded to the given ErrorCollector while
+  // parsing.  Set to NULL (the default) to discard error messages.
+  void RecordErrorsTo(io::ErrorCollector* error_collector) {
+    error_collector_ = error_collector;
+  }
+
+  // Returns the identifier used in the "syntax = " declaration, if one was
+  // seen during the last call to Parse(), or the empty string otherwise.
+  const std::string& GetSyntaxIdentifier() { return syntax_identifier_; }
+
+  // If set true, input files will be required to begin with a syntax
+  // identifier.  Otherwise, files may omit this.  If a syntax identifier
+  // is provided, it must be 'syntax = "proto2";' and must appear at the
+  // top of this file regardless of whether or not it was required.
+  void SetRequireSyntaxIdentifier(bool value) {
+    require_syntax_identifier_ = value;
+  }
+
+  // Call SetStopAfterSyntaxIdentifier(true) to tell the parser to stop
+  // parsing as soon as it has seen the syntax identifier, or lack thereof.
+  // This is useful for quickly identifying the syntax of the file without
+  // parsing the whole thing.  If this is enabled, no error will be recorded
+  // if the syntax identifier is something other than "proto2" (since
+  // presumably the caller intends to deal with that), but other kinds of
+  // errors (e.g. parse errors) will still be reported.  When this is enabled,
+  // you may pass a NULL FileDescriptorProto to Parse().
+  void SetStopAfterSyntaxIdentifier(bool value) {
+    stop_after_syntax_identifier_ = value;
+  }
+
+ private:
+  class LocationRecorder;
+  struct MapField;
+
+  // =================================================================
+  // Error recovery helpers
+
+  // Consume the rest of the current statement.  This consumes tokens
+  // until it sees one of:
+  //   ';'  Consumes the token and returns.
+  //   '{'  Consumes the brace then calls SkipRestOfBlock().
+  //   '}'  Returns without consuming.
+  //   EOF  Returns (can't consume).
+  // The Parser often calls SkipStatement() after encountering a syntax
+  // error.  This allows it to go on parsing the following lines, allowing
+  // it to report more than just one error in the file.
+  void SkipStatement();
+
+  // Consume the rest of the current block, including nested blocks,
+  // ending after the closing '}' is encountered and consumed, or at EOF.
+  void SkipRestOfBlock();
+
+  // -----------------------------------------------------------------
+  // Single-token consuming helpers
+  //
+  // These make parsing code more readable.
+
+  // True if the current token is TYPE_END.
+  inline bool AtEnd();
+
+  // True if the next token matches the given text.
+  inline bool LookingAt(const char* text);
+  // True if the next token is of the given type.
+  inline bool LookingAtType(io::Tokenizer::TokenType token_type);
+
+  // If the next token exactly matches the text given, consume it and return
+  // true.  Otherwise, return false without logging an error.
+  bool TryConsume(const char* text);
+
+  // These attempt to read some kind of token from the input.  If successful,
+  // they return true.  Otherwise they return false and add the given error
+  // to the error list.
+
+  // Consume a token with the exact text given.
+  bool Consume(const char* text, const char* error);
+  // Same as above, but automatically generates the error "Expected \"text\".",
+  // where "text" is the expected token text.
+  bool Consume(const char* text);
+  // Consume a token of type IDENTIFIER and store its text in "output".
+  bool ConsumeIdentifier(std::string* output, const char* error);
+  // Consume an integer and store its value in "output".
+  bool ConsumeInteger(int* output, const char* error);
+  // Consume a signed integer and store its value in "output".
+  bool ConsumeSignedInteger(int* output, const char* error);
+  // Consume a 64-bit integer and store its value in "output".  If the value
+  // is greater than max_value, an error will be reported.
+  bool ConsumeInteger64(uint64_t max_value, uint64_t* output,
+                        const char* error);
+  // Consume a number and store its value in "output".  This will accept
+  // tokens of either INTEGER or FLOAT type.
+  bool ConsumeNumber(double* output, const char* error);
+  // Consume a string literal and store its (unescaped) value in "output".
+  bool ConsumeString(std::string* output, const char* error);
+
+  // Consume a token representing the end of the statement.  Comments between
+  // this token and the next will be harvested for documentation.  The given
+  // LocationRecorder should refer to the declaration that was just parsed;
+  // it will be populated with these comments.
+  //
+  // TODO(kenton):  The LocationRecorder is const because historically locations
+  //   have been passed around by const reference, for no particularly good
+  //   reason.  We should probably go through and change them all to mutable
+  //   pointer to make this more intuitive.
+  bool TryConsumeEndOfDeclaration(const char* text,
+                                  const LocationRecorder* location);
+  bool TryConsumeEndOfDeclarationFinishScope(const char* text,
+                                             const LocationRecorder* location);
+
+  bool ConsumeEndOfDeclaration(const char* text,
+                               const LocationRecorder* location);
+
+  // -----------------------------------------------------------------
+  // Error logging helpers
+
+  // Invokes error_collector_->AddError(), if error_collector_ is not NULL.
+  void AddError(int line, int column, const std::string& error);
+
+  // Invokes error_collector_->AddError() with the line and column number
+  // of the current token.
+  void AddError(const std::string& error);
+
+  // Invokes error_collector_->AddWarning() with the line and column number
+  // of the current token.
+  void AddWarning(const std::string& warning);
+
+  // Records a location in the SourceCodeInfo.location table (see
+  // descriptor.proto).  We use RAII to ensure that the start and end locations
+  // are recorded -- the constructor records the start location and the
+  // destructor records the end location.  Since the parser is
+  // recursive-descent, this works out beautifully.
+  class PROTOBUF_EXPORT LocationRecorder {
+   public:
+    // Construct the file's "root" location.
+    LocationRecorder(Parser* parser);
+
+    // Construct a location that represents a declaration nested within the
+    // given parent.  E.g. a field's location is nested within the location
+    // for a message type.  The parent's path will be copied, so you should
+    // call AddPath() only to add the path components leading from the parent
+    // to the child (as opposed to leading from the root to the child).
+    LocationRecorder(const LocationRecorder& parent);
+
+    // Convenience constructors that call AddPath() one or two times.
+    LocationRecorder(const LocationRecorder& parent, int path1);
+    LocationRecorder(const LocationRecorder& parent, int path1, int path2);
+
+    // Creates a recorder that generates locations into given source code info.
+    LocationRecorder(const LocationRecorder& parent, int path1,
+                     SourceCodeInfo* source_code_info);
+
+    ~LocationRecorder();
+
+    // Add a path component.  See SourceCodeInfo.Location.path in
+    // descriptor.proto.
+    void AddPath(int path_component);
+
+    // By default the location is considered to start at the current token at
+    // the time the LocationRecorder is created.  StartAt() sets the start
+    // location to the given token instead.
+    void StartAt(const io::Tokenizer::Token& token);
+
+    // Start at the same location as some other LocationRecorder.
+    void StartAt(const LocationRecorder& other);
+
+    // By default the location is considered to end at the previous token at
+    // the time the LocationRecorder is destroyed.  EndAt() sets the end
+    // location to the given token instead.
+    void EndAt(const io::Tokenizer::Token& token);
+
+    // Records the start point of this location to the SourceLocationTable that
+    // was passed to RecordSourceLocationsTo(), if any.  SourceLocationTable
+    // is an older way of keeping track of source locations which is still
+    // used in some places.
+    void RecordLegacyLocation(
+        const Message* descriptor,
+        DescriptorPool::ErrorCollector::ErrorLocation location);
+    void RecordLegacyImportLocation(const Message* descriptor,
+                                    const std::string& name);
+
+    // Returns the number of path components in the recorder's current location.
+    int CurrentPathSize() const;
+
+    // Attaches leading and trailing comments to the location.  The two strings
+    // will be swapped into place, so after this is called *leading and
+    // *trailing will be empty.
+    //
+    // TODO(kenton):  See comment on TryConsumeEndOfDeclaration(), above, for
+    //   why this is const.
+    void AttachComments(std::string* leading, std::string* trailing,
+                        std::vector<std::string>* detached_comments) const;
+
+   private:
+    Parser* parser_;
+    SourceCodeInfo* source_code_info_;
+    SourceCodeInfo::Location* location_;
+
+    void Init(const LocationRecorder& parent, SourceCodeInfo* source_code_info);
+  };
+
+  // =================================================================
+  // Parsers for various language constructs
+
+  // Parses the "syntax = \"proto2\";" line at the top of the file.  Returns
+  // false if it failed to parse or if the syntax identifier was not
+  // recognized.
+  bool ParseSyntaxIdentifier(const LocationRecorder& parent);
+
+  // These methods parse various individual bits of code.  They return
+  // false if they completely fail to parse the construct.  In this case,
+  // it is probably necessary to skip the rest of the statement to recover.
+  // However, if these methods return true, it does NOT mean that there
+  // were no errors; only that there were no *syntax* errors.  For instance,
+  // if a service method is defined using proper syntax but uses a primitive
+  // type as its input or output, ParseMethodField() still returns true
+  // and only reports the error by calling AddError().  In practice, this
+  // makes logic much simpler for the caller.
+
+  // Parse a top-level message, enum, service, etc.
+  bool ParseTopLevelStatement(FileDescriptorProto* file,
+                              const LocationRecorder& root_location);
+
+  // Parse various language high-level language construrcts.
+  bool ParseMessageDefinition(DescriptorProto* message,
+                              const LocationRecorder& message_location,
+                              const FileDescriptorProto* containing_file);
+  bool ParseEnumDefinition(EnumDescriptorProto* enum_type,
+                           const LocationRecorder& enum_location,
+                           const FileDescriptorProto* containing_file);
+  bool ParseServiceDefinition(ServiceDescriptorProto* service,
+                              const LocationRecorder& service_location,
+                              const FileDescriptorProto* containing_file);
+  bool ParsePackage(FileDescriptorProto* file,
+                    const LocationRecorder& root_location,
+                    const FileDescriptorProto* containing_file);
+  bool ParseImport(RepeatedPtrField<std::string>* dependency,
+                   RepeatedField<int32_t>* public_dependency,
+                   RepeatedField<int32_t>* weak_dependency,
+                   const LocationRecorder& root_location,
+                   const FileDescriptorProto* containing_file);
+
+  // These methods parse the contents of a message, enum, or service type and
+  // add them to the given object.  They consume the entire block including
+  // the beginning and ending brace.
+  bool ParseMessageBlock(DescriptorProto* message,
+                         const LocationRecorder& message_location,
+                         const FileDescriptorProto* containing_file);
+  bool ParseEnumBlock(EnumDescriptorProto* enum_type,
+                      const LocationRecorder& enum_location,
+                      const FileDescriptorProto* containing_file);
+  bool ParseServiceBlock(ServiceDescriptorProto* service,
+                         const LocationRecorder& service_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Parse one statement within a message, enum, or service block, including
+  // final semicolon.
+  bool ParseMessageStatement(DescriptorProto* message,
+                             const LocationRecorder& message_location,
+                             const FileDescriptorProto* containing_file);
+  bool ParseEnumStatement(EnumDescriptorProto* message,
+                          const LocationRecorder& enum_location,
+                          const FileDescriptorProto* containing_file);
+  bool ParseServiceStatement(ServiceDescriptorProto* message,
+                             const LocationRecorder& service_location,
+                             const FileDescriptorProto* containing_file);
+
+  // Parse a field of a message.  If the field is a group, its type will be
+  // added to "messages".
+  //
+  // parent_location and location_field_number_for_nested_type are needed when
+  // parsing groups -- we need to generate a nested message type within the
+  // parent and record its location accordingly.  Since the parent could be
+  // either a FileDescriptorProto or a DescriptorProto, we must pass in the
+  // correct field number to use.
+  bool ParseMessageField(FieldDescriptorProto* field,
+                         RepeatedPtrField<DescriptorProto>* messages,
+                         const LocationRecorder& parent_location,
+                         int location_field_number_for_nested_type,
+                         const LocationRecorder& field_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Like ParseMessageField() but expects the label has already been filled in
+  // by the caller.
+  bool ParseMessageFieldNoLabel(FieldDescriptorProto* field,
+                                RepeatedPtrField<DescriptorProto>* messages,
+                                const LocationRecorder& parent_location,
+                                int location_field_number_for_nested_type,
+                                const LocationRecorder& field_location,
+                                const FileDescriptorProto* containing_file);
+
+  bool ParseMapType(MapField* map_field, FieldDescriptorProto* field,
+                    LocationRecorder& type_name_location);
+
+  // Parse an "extensions" declaration.
+  bool ParseExtensions(DescriptorProto* message,
+                       const LocationRecorder& extensions_location,
+                       const FileDescriptorProto* containing_file);
+
+  // Parse a "reserved" declaration.
+  bool ParseReserved(DescriptorProto* message,
+                     const LocationRecorder& message_location);
+  bool ParseReservedNames(DescriptorProto* message,
+                          const LocationRecorder& parent_location);
+  bool ParseReservedNumbers(DescriptorProto* message,
+                            const LocationRecorder& parent_location);
+  bool ParseReserved(EnumDescriptorProto* message,
+                     const LocationRecorder& message_location);
+  bool ParseReservedNames(EnumDescriptorProto* message,
+                          const LocationRecorder& parent_location);
+  bool ParseReservedNumbers(EnumDescriptorProto* message,
+                            const LocationRecorder& parent_location);
+
+  // Parse an "extend" declaration.  (See also comments for
+  // ParseMessageField().)
+  bool ParseExtend(RepeatedPtrField<FieldDescriptorProto>* extensions,
+                   RepeatedPtrField<DescriptorProto>* messages,
+                   const LocationRecorder& parent_location,
+                   int location_field_number_for_nested_type,
+                   const LocationRecorder& extend_location,
+                   const FileDescriptorProto* containing_file);
+
+  // Parse a "oneof" declaration.  The caller is responsible for setting
+  // oneof_decl->label() since it will have had to parse the label before it
+  // knew it was parsing a oneof.
+  bool ParseOneof(OneofDescriptorProto* oneof_decl,
+                  DescriptorProto* containing_type, int oneof_index,
+                  const LocationRecorder& oneof_location,
+                  const LocationRecorder& containing_type_location,
+                  const FileDescriptorProto* containing_file);
+
+  // Parse a single enum value within an enum block.
+  bool ParseEnumConstant(EnumValueDescriptorProto* enum_value,
+                         const LocationRecorder& enum_value_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Parse enum constant options, i.e. the list in square brackets at the end
+  // of the enum constant value definition.
+  bool ParseEnumConstantOptions(EnumValueDescriptorProto* value,
+                                const LocationRecorder& enum_value_location,
+                                const FileDescriptorProto* containing_file);
+
+  // Parse a single method within a service definition.
+  bool ParseServiceMethod(MethodDescriptorProto* method,
+                          const LocationRecorder& method_location,
+                          const FileDescriptorProto* containing_file);
+
+  // Parse options of a single method or stream.
+  bool ParseMethodOptions(const LocationRecorder& parent_location,
+                          const FileDescriptorProto* containing_file,
+                          const int optionsFieldNumber,
+                          Message* mutable_options);
+
+  // Parse "required", "optional", or "repeated" and fill in "label"
+  // with the value. Returns true if such a label is consumed.
+  bool ParseLabel(FieldDescriptorProto::Label* label,
+                  const LocationRecorder& field_location);
+
+  // Parse a type name and fill in "type" (if it is a primitive) or
+  // "type_name" (if it is not) with the type parsed.
+  bool ParseType(FieldDescriptorProto::Type* type, std::string* type_name);
+  // Parse a user-defined type and fill in "type_name" with the name.
+  // If a primitive type is named, it is treated as an error.
+  bool ParseUserDefinedType(std::string* type_name);
+
+  // Parses field options, i.e. the stuff in square brackets at the end
+  // of a field definition.  Also parses default value.
+  bool ParseFieldOptions(FieldDescriptorProto* field,
+                         const LocationRecorder& field_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Parse the "default" option.  This needs special handling because its
+  // type is the field's type.
+  bool ParseDefaultAssignment(FieldDescriptorProto* field,
+                              const LocationRecorder& field_location,
+                              const FileDescriptorProto* containing_file);
+
+  bool ParseJsonName(FieldDescriptorProto* field,
+                     const LocationRecorder& field_location,
+                     const FileDescriptorProto* containing_file);
+
+  enum OptionStyle {
+    OPTION_ASSIGNMENT,  // just "name = value"
+    OPTION_STATEMENT    // "option name = value;"
+  };
+
+  // Parse a single option name/value pair, e.g. "ctype = CORD".  The name
+  // identifies a field of the given Message, and the value of that field
+  // is set to the parsed value.
+  bool ParseOption(Message* options, const LocationRecorder& options_location,
+                   const FileDescriptorProto* containing_file,
+                   OptionStyle style);
+
+  // Parses a single part of a multipart option name. A multipart name consists
+  // of names separated by dots. Each name is either an identifier or a series
+  // of identifiers separated by dots and enclosed in parentheses. E.g.,
+  // "foo.(bar.baz).moo".
+  bool ParseOptionNamePart(UninterpretedOption* uninterpreted_option,
+                           const LocationRecorder& part_location,
+                           const FileDescriptorProto* containing_file);
+
+  // Parses a string surrounded by balanced braces.  Strips off the outer
+  // braces and stores the enclosed string in *value.
+  // E.g.,
+  //     { foo }                     *value gets 'foo'
+  //     { foo { bar: box } }        *value gets 'foo { bar: box }'
+  //     {}                          *value gets ''
+  //
+  // REQUIRES: LookingAt("{")
+  // When finished successfully, we are looking at the first token past
+  // the ending brace.
+  bool ParseUninterpretedBlock(std::string* value);
+
+  struct MapField {
+    // Whether the field is a map field.
+    bool is_map_field;
+    // The types of the key and value if they are primitive types.
+    FieldDescriptorProto::Type key_type;
+    FieldDescriptorProto::Type value_type;
+    // Or the type names string if the types are customized types.
+    std::string key_type_name;
+    std::string value_type_name;
+
+    MapField() : is_map_field(false) {}
+  };
+  // Desugar the map syntax to generate a nested map entry message.
+  void GenerateMapEntry(const MapField& map_field, FieldDescriptorProto* field,
+                        RepeatedPtrField<DescriptorProto>* messages);
+
+  // Whether fields without label default to optional fields.
+  bool DefaultToOptionalFields() const {
+    return syntax_identifier_ == "proto3";
+  }
+
+  bool ValidateEnum(const EnumDescriptorProto* proto);
+
+  // =================================================================
+
+  io::Tokenizer* input_;
+  io::ErrorCollector* error_collector_;
+  SourceCodeInfo* source_code_info_;
+  SourceLocationTable* source_location_table_;  // legacy
+  bool had_errors_;
+  bool require_syntax_identifier_;
+  bool stop_after_syntax_identifier_;
+  std::string syntax_identifier_;
+
+  // Leading doc comments for the next declaration.  These are not complete
+  // yet; use ConsumeEndOfDeclaration() to get the complete comments.
+  std::string upcoming_doc_comments_;
+
+  // Detached comments are not connected to any syntax entities. Elements in
+  // this vector are paragraphs of comments separated by empty lines. The
+  // detached comments will be put into the leading_detached_comments field for
+  // the next element (See SourceCodeInfo.Location in descriptor.proto), when
+  // ConsumeEndOfDeclaration() is called.
+  std::vector<std::string> upcoming_detached_comments_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Parser);
+};
+
+// A table mapping (descriptor, ErrorLocation) pairs -- as reported by
+// DescriptorPool when validating descriptors -- to line and column numbers
+// within the original source code.
+//
+// This is semi-obsolete:  FileDescriptorProto.source_code_info now contains
+// far more complete information about source locations.  However, as of this
+// writing you still need to use SourceLocationTable when integrating with
+// DescriptorPool.
+class PROTOBUF_EXPORT SourceLocationTable {
+ public:
+  SourceLocationTable();
+  ~SourceLocationTable();
+
+  // Finds the precise location of the given error and fills in *line and
+  // *column with the line and column numbers.  If not found, sets *line to
+  // -1 and *column to 0 (since line = -1 is used to mean "error has no exact
+  // location" in the ErrorCollector interface).  Returns true if found, false
+  // otherwise.
+  bool Find(const Message* descriptor,
+            DescriptorPool::ErrorCollector::ErrorLocation location, int* line,
+            int* column) const;
+  bool FindImport(const Message* descriptor, const std::string& name, int* line,
+                  int* column) const;
+
+  // Adds a location to the table.
+  void Add(const Message* descriptor,
+           DescriptorPool::ErrorCollector::ErrorLocation location, int line,
+           int column);
+  void AddImport(const Message* descriptor, const std::string& name, int line,
+                 int column);
+
+  // Clears the contents of the table.
+  void Clear();
+
+ private:
+  typedef std::map<
+      std::pair<const Message*, DescriptorPool::ErrorCollector::ErrorLocation>,
+      std::pair<int, int> >
+      LocationMap;
+  LocationMap location_map_;
+  std::map<std::pair<const Message*, std::string>, std::pair<int, int> >
+      import_location_map_;
+};
+
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_PARSER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/php/php_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/php/php_generator.h
new file mode 100644
index 0000000..17cb59c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/php/php_generator.h
@@ -0,0 +1,92 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PHP_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_PHP_GENERATOR_H__
+
+#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/descriptor.h>
+
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace php {
+
+struct Options;
+
+class PROTOC_EXPORT Generator : public CodeGenerator {
+ public:
+  virtual bool Generate(
+      const FileDescriptor* file,
+      const std::string& parameter,
+      GeneratorContext* generator_context,
+      std::string* error) const override;
+
+  bool GenerateAll(const std::vector<const FileDescriptor*>& files,
+                   const std::string& parameter,
+                   GeneratorContext* generator_context,
+                   std::string* error) const override;
+
+  uint64_t GetSupportedFeatures() const override {
+    return FEATURE_PROTO3_OPTIONAL;
+  }
+
+ private:
+  bool Generate(
+      const FileDescriptor* file,
+      const Options& options,
+      GeneratorContext* generator_context,
+      std::string* error) const;
+};
+
+// To skip reserved keywords in php, some generated classname are prefixed.
+// Other code generators may need following API to figure out the actual
+// classname.
+PROTOC_EXPORT std::string GeneratedClassName(const Descriptor* desc);
+PROTOC_EXPORT std::string GeneratedClassName(const EnumDescriptor* desc);
+PROTOC_EXPORT std::string GeneratedClassName(const ServiceDescriptor* desc);
+
+inline bool IsWrapperType(const FieldDescriptor* descriptor) {
+  return descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
+      descriptor->message_type()->file()->name() == "google/protobuf/wrappers.proto";
+}
+
+}  // namespace php
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_PHP_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.h
new file mode 100644
index 0000000..611713e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.h
@@ -0,0 +1,96 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//
+// Front-end for protoc code generator plugins written in C++.
+//
+// To implement a protoc plugin in C++, simply write an implementation of
+// CodeGenerator, then create a main() function like:
+//   int main(int argc, char* argv[]) {
+//     MyCodeGenerator generator;
+//     return google::protobuf::compiler::PluginMain(argc, argv, &generator);
+//   }
+// You must link your plugin against libprotobuf and libprotoc.
+//
+// The core part of PluginMain is to invoke the given CodeGenerator on a
+// CodeGeneratorRequest to generate a CodeGeneratorResponse. This part is
+// abstracted out and made into function GenerateCode so that it can be reused,
+// for example, to implement a variant of PluginMain that does some
+// preprocessing on the input CodeGeneratorRequest before feeding the request
+// to the given code generator.
+//
+// To get protoc to use the plugin, do one of the following:
+// * Place the plugin binary somewhere in the PATH and give it the name
+//   "protoc-gen-NAME" (replacing "NAME" with the name of your plugin).  If you
+//   then invoke protoc with the parameter --NAME_out=OUT_DIR (again, replace
+//   "NAME" with your plugin's name), protoc will invoke your plugin to generate
+//   the output, which will be placed in OUT_DIR.
+// * Place the plugin binary anywhere, with any name, and pass the --plugin
+//   parameter to protoc to direct it to your plugin like so:
+//     protoc --plugin=protoc-gen-NAME=path/to/mybinary --NAME_out=OUT_DIR
+//   On Windows, make sure to include the .exe suffix:
+//     protoc --plugin=protoc-gen-NAME=path/to/mybinary.exe --NAME_out=OUT_DIR
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PLUGIN_H__
+#define GOOGLE_PROTOBUF_COMPILER_PLUGIN_H__
+
+#include <string>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+
+class CodeGenerator;  // code_generator.h
+class CodeGeneratorRequest;
+class CodeGeneratorResponse;
+
+// Implements main() for a protoc plugin exposing the given code generator.
+PROTOC_EXPORT int PluginMain(int argc, char* argv[],
+                             const CodeGenerator* generator);
+
+
+// Generates code using the given code generator. Returns true if the code
+// generation is successful. If the code generation fails, error_msg may be
+// populated to describe the failure cause.
+bool GenerateCode(const CodeGeneratorRequest& request,
+                  const CodeGenerator& generator,
+                  CodeGeneratorResponse* response, std::string* error_msg);
+
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_PLUGIN_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.pb.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.pb.h
new file mode 100644
index 0000000..97bf2f0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.pb.h
@@ -0,0 +1,1901 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/compiler/plugin.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fplugin_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fplugin_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/descriptor.pb.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fcompiler_2fplugin_2eproto PROTOC_EXPORT
+#ifdef major
+#undef major
+#endif
+#ifdef minor
+#undef minor
+#endif
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOC_EXPORT TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOC_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+namespace compiler {
+class CodeGeneratorRequest;
+struct CodeGeneratorRequestDefaultTypeInternal;
+PROTOC_EXPORT extern CodeGeneratorRequestDefaultTypeInternal _CodeGeneratorRequest_default_instance_;
+class CodeGeneratorResponse;
+struct CodeGeneratorResponseDefaultTypeInternal;
+PROTOC_EXPORT extern CodeGeneratorResponseDefaultTypeInternal _CodeGeneratorResponse_default_instance_;
+class CodeGeneratorResponse_File;
+struct CodeGeneratorResponse_FileDefaultTypeInternal;
+PROTOC_EXPORT extern CodeGeneratorResponse_FileDefaultTypeInternal _CodeGeneratorResponse_File_default_instance_;
+class Version;
+struct VersionDefaultTypeInternal;
+PROTOC_EXPORT extern VersionDefaultTypeInternal _Version_default_instance_;
+}  // namespace compiler
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest>(Arena*);
+template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse>(Arena*);
+template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>(Arena*);
+template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::Version* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+namespace compiler {
+
+enum CodeGeneratorResponse_Feature : int {
+  CodeGeneratorResponse_Feature_FEATURE_NONE = 0,
+  CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL = 1
+};
+PROTOC_EXPORT bool CodeGeneratorResponse_Feature_IsValid(int value);
+constexpr CodeGeneratorResponse_Feature CodeGeneratorResponse_Feature_Feature_MIN = CodeGeneratorResponse_Feature_FEATURE_NONE;
+constexpr CodeGeneratorResponse_Feature CodeGeneratorResponse_Feature_Feature_MAX = CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL;
+constexpr int CodeGeneratorResponse_Feature_Feature_ARRAYSIZE = CodeGeneratorResponse_Feature_Feature_MAX + 1;
+
+PROTOC_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CodeGeneratorResponse_Feature_descriptor();
+template<typename T>
+inline const std::string& CodeGeneratorResponse_Feature_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, CodeGeneratorResponse_Feature>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function CodeGeneratorResponse_Feature_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    CodeGeneratorResponse_Feature_descriptor(), enum_t_value);
+}
+inline bool CodeGeneratorResponse_Feature_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CodeGeneratorResponse_Feature* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CodeGeneratorResponse_Feature>(
+    CodeGeneratorResponse_Feature_descriptor(), name, value);
+}
+// ===================================================================
+
+class PROTOC_EXPORT Version final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.Version) */ {
+ public:
+  inline Version() : Version(nullptr) {}
+  ~Version() override;
+  explicit PROTOBUF_CONSTEXPR Version(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Version(const Version& from);
+  Version(Version&& from) noexcept
+    : Version() {
+    *this = ::std::move(from);
+  }
+
+  inline Version& operator=(const Version& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Version& operator=(Version&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Version& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Version* internal_default_instance() {
+    return reinterpret_cast<const Version*>(
+               &_Version_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Version& a, Version& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Version* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Version* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Version* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Version>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Version& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Version& from) {
+    Version::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Version* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.compiler.Version";
+  }
+  protected:
+  explicit Version(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSuffixFieldNumber = 4,
+    kMajorFieldNumber = 1,
+    kMinorFieldNumber = 2,
+    kPatchFieldNumber = 3,
+  };
+  // optional string suffix = 4;
+  bool has_suffix() const;
+  private:
+  bool _internal_has_suffix() const;
+  public:
+  void clear_suffix();
+  const std::string& suffix() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_suffix(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_suffix();
+  PROTOBUF_NODISCARD std::string* release_suffix();
+  void set_allocated_suffix(std::string* suffix);
+  private:
+  const std::string& _internal_suffix() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_suffix(const std::string& value);
+  std::string* _internal_mutable_suffix();
+  public:
+
+  // optional int32 major = 1;
+  bool has_major() const;
+  private:
+  bool _internal_has_major() const;
+  public:
+  void clear_major();
+  int32_t major() const;
+  void set_major(int32_t value);
+  private:
+  int32_t _internal_major() const;
+  void _internal_set_major(int32_t value);
+  public:
+
+  // optional int32 minor = 2;
+  bool has_minor() const;
+  private:
+  bool _internal_has_minor() const;
+  public:
+  void clear_minor();
+  int32_t minor() const;
+  void set_minor(int32_t value);
+  private:
+  int32_t _internal_minor() const;
+  void _internal_set_minor(int32_t value);
+  public:
+
+  // optional int32 patch = 3;
+  bool has_patch() const;
+  private:
+  bool _internal_has_patch() const;
+  public:
+  void clear_patch();
+  int32_t patch() const;
+  void set_patch(int32_t value);
+  private:
+  int32_t _internal_patch() const;
+  void _internal_set_patch(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.Version)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr suffix_;
+    int32_t major_;
+    int32_t minor_;
+    int32_t patch_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOC_EXPORT CodeGeneratorRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorRequest) */ {
+ public:
+  inline CodeGeneratorRequest() : CodeGeneratorRequest(nullptr) {}
+  ~CodeGeneratorRequest() override;
+  explicit PROTOBUF_CONSTEXPR CodeGeneratorRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CodeGeneratorRequest(const CodeGeneratorRequest& from);
+  CodeGeneratorRequest(CodeGeneratorRequest&& from) noexcept
+    : CodeGeneratorRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline CodeGeneratorRequest& operator=(const CodeGeneratorRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CodeGeneratorRequest& operator=(CodeGeneratorRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CodeGeneratorRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CodeGeneratorRequest* internal_default_instance() {
+    return reinterpret_cast<const CodeGeneratorRequest*>(
+               &_CodeGeneratorRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(CodeGeneratorRequest& a, CodeGeneratorRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CodeGeneratorRequest* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CodeGeneratorRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CodeGeneratorRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CodeGeneratorRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CodeGeneratorRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CodeGeneratorRequest& from) {
+    CodeGeneratorRequest::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CodeGeneratorRequest* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.compiler.CodeGeneratorRequest";
+  }
+  protected:
+  explicit CodeGeneratorRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileToGenerateFieldNumber = 1,
+    kProtoFileFieldNumber = 15,
+    kParameterFieldNumber = 2,
+    kCompilerVersionFieldNumber = 3,
+  };
+  // repeated string file_to_generate = 1;
+  int file_to_generate_size() const;
+  private:
+  int _internal_file_to_generate_size() const;
+  public:
+  void clear_file_to_generate();
+  const std::string& file_to_generate(int index) const;
+  std::string* mutable_file_to_generate(int index);
+  void set_file_to_generate(int index, const std::string& value);
+  void set_file_to_generate(int index, std::string&& value);
+  void set_file_to_generate(int index, const char* value);
+  void set_file_to_generate(int index, const char* value, size_t size);
+  std::string* add_file_to_generate();
+  void add_file_to_generate(const std::string& value);
+  void add_file_to_generate(std::string&& value);
+  void add_file_to_generate(const char* value);
+  void add_file_to_generate(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& file_to_generate() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_file_to_generate();
+  private:
+  const std::string& _internal_file_to_generate(int index) const;
+  std::string* _internal_add_file_to_generate();
+  public:
+
+  // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
+  int proto_file_size() const;
+  private:
+  int _internal_proto_file_size() const;
+  public:
+  void clear_proto_file();
+  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* mutable_proto_file(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
+      mutable_proto_file();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& _internal_proto_file(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _internal_add_proto_file();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& proto_file(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* add_proto_file();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
+      proto_file() const;
+
+  // optional string parameter = 2;
+  bool has_parameter() const;
+  private:
+  bool _internal_has_parameter() const;
+  public:
+  void clear_parameter();
+  const std::string& parameter() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_parameter(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_parameter();
+  PROTOBUF_NODISCARD std::string* release_parameter();
+  void set_allocated_parameter(std::string* parameter);
+  private:
+  const std::string& _internal_parameter() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_parameter(const std::string& value);
+  std::string* _internal_mutable_parameter();
+  public:
+
+  // optional .google.protobuf.compiler.Version compiler_version = 3;
+  bool has_compiler_version() const;
+  private:
+  bool _internal_has_compiler_version() const;
+  public:
+  void clear_compiler_version();
+  const ::PROTOBUF_NAMESPACE_ID::compiler::Version& compiler_version() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::compiler::Version* release_compiler_version();
+  ::PROTOBUF_NAMESPACE_ID::compiler::Version* mutable_compiler_version();
+  void set_allocated_compiler_version(::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::compiler::Version& _internal_compiler_version() const;
+  ::PROTOBUF_NAMESPACE_ID::compiler::Version* _internal_mutable_compiler_version();
+  public:
+  void unsafe_arena_set_allocated_compiler_version(
+      ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version);
+  ::PROTOBUF_NAMESPACE_ID::compiler::Version* unsafe_arena_release_compiler_version();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> file_to_generate_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto > proto_file_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parameter_;
+    ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOC_EXPORT CodeGeneratorResponse_File final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse.File) */ {
+ public:
+  inline CodeGeneratorResponse_File() : CodeGeneratorResponse_File(nullptr) {}
+  ~CodeGeneratorResponse_File() override;
+  explicit PROTOBUF_CONSTEXPR CodeGeneratorResponse_File(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CodeGeneratorResponse_File(const CodeGeneratorResponse_File& from);
+  CodeGeneratorResponse_File(CodeGeneratorResponse_File&& from) noexcept
+    : CodeGeneratorResponse_File() {
+    *this = ::std::move(from);
+  }
+
+  inline CodeGeneratorResponse_File& operator=(const CodeGeneratorResponse_File& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CodeGeneratorResponse_File& operator=(CodeGeneratorResponse_File&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CodeGeneratorResponse_File& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CodeGeneratorResponse_File* internal_default_instance() {
+    return reinterpret_cast<const CodeGeneratorResponse_File*>(
+               &_CodeGeneratorResponse_File_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(CodeGeneratorResponse_File& a, CodeGeneratorResponse_File& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CodeGeneratorResponse_File* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CodeGeneratorResponse_File* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CodeGeneratorResponse_File* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CodeGeneratorResponse_File>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CodeGeneratorResponse_File& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CodeGeneratorResponse_File& from) {
+    CodeGeneratorResponse_File::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CodeGeneratorResponse_File* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.compiler.CodeGeneratorResponse.File";
+  }
+  protected:
+  explicit CodeGeneratorResponse_File(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kInsertionPointFieldNumber = 2,
+    kContentFieldNumber = 15,
+    kGeneratedCodeInfoFieldNumber = 16,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string insertion_point = 2;
+  bool has_insertion_point() const;
+  private:
+  bool _internal_has_insertion_point() const;
+  public:
+  void clear_insertion_point();
+  const std::string& insertion_point() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_insertion_point(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_insertion_point();
+  PROTOBUF_NODISCARD std::string* release_insertion_point();
+  void set_allocated_insertion_point(std::string* insertion_point);
+  private:
+  const std::string& _internal_insertion_point() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_insertion_point(const std::string& value);
+  std::string* _internal_mutable_insertion_point();
+  public:
+
+  // optional string content = 15;
+  bool has_content() const;
+  private:
+  bool _internal_has_content() const;
+  public:
+  void clear_content();
+  const std::string& content() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content();
+  PROTOBUF_NODISCARD std::string* release_content();
+  void set_allocated_content(std::string* content);
+  private:
+  const std::string& _internal_content() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
+  std::string* _internal_mutable_content();
+  public:
+
+  // optional .google.protobuf.GeneratedCodeInfo generated_code_info = 16;
+  bool has_generated_code_info() const;
+  private:
+  bool _internal_has_generated_code_info() const;
+  public:
+  void clear_generated_code_info();
+  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& generated_code_info() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* release_generated_code_info();
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* mutable_generated_code_info();
+  void set_allocated_generated_code_info(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& _internal_generated_code_info() const;
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* _internal_mutable_generated_code_info();
+  public:
+  void unsafe_arena_set_allocated_generated_code_info(
+      ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info);
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* unsafe_arena_release_generated_code_info();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr insertion_point_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
+    ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOC_EXPORT CodeGeneratorResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse) */ {
+ public:
+  inline CodeGeneratorResponse() : CodeGeneratorResponse(nullptr) {}
+  ~CodeGeneratorResponse() override;
+  explicit PROTOBUF_CONSTEXPR CodeGeneratorResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  CodeGeneratorResponse(const CodeGeneratorResponse& from);
+  CodeGeneratorResponse(CodeGeneratorResponse&& from) noexcept
+    : CodeGeneratorResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline CodeGeneratorResponse& operator=(const CodeGeneratorResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline CodeGeneratorResponse& operator=(CodeGeneratorResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const CodeGeneratorResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const CodeGeneratorResponse* internal_default_instance() {
+    return reinterpret_cast<const CodeGeneratorResponse*>(
+               &_CodeGeneratorResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(CodeGeneratorResponse& a, CodeGeneratorResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(CodeGeneratorResponse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(CodeGeneratorResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  CodeGeneratorResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<CodeGeneratorResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const CodeGeneratorResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const CodeGeneratorResponse& from) {
+    CodeGeneratorResponse::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(CodeGeneratorResponse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.compiler.CodeGeneratorResponse";
+  }
+  protected:
+  explicit CodeGeneratorResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef CodeGeneratorResponse_File File;
+
+  typedef CodeGeneratorResponse_Feature Feature;
+  static constexpr Feature FEATURE_NONE =
+    CodeGeneratorResponse_Feature_FEATURE_NONE;
+  static constexpr Feature FEATURE_PROTO3_OPTIONAL =
+    CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL;
+  static inline bool Feature_IsValid(int value) {
+    return CodeGeneratorResponse_Feature_IsValid(value);
+  }
+  static constexpr Feature Feature_MIN =
+    CodeGeneratorResponse_Feature_Feature_MIN;
+  static constexpr Feature Feature_MAX =
+    CodeGeneratorResponse_Feature_Feature_MAX;
+  static constexpr int Feature_ARRAYSIZE =
+    CodeGeneratorResponse_Feature_Feature_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Feature_descriptor() {
+    return CodeGeneratorResponse_Feature_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Feature_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Feature>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Feature_Name.");
+    return CodeGeneratorResponse_Feature_Name(enum_t_value);
+  }
+  static inline bool Feature_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Feature* value) {
+    return CodeGeneratorResponse_Feature_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileFieldNumber = 15,
+    kErrorFieldNumber = 1,
+    kSupportedFeaturesFieldNumber = 2,
+  };
+  // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
+  int file_size() const;
+  private:
+  int _internal_file_size() const;
+  public:
+  void clear_file();
+  ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* mutable_file(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >*
+      mutable_file();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& _internal_file(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* _internal_add_file();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& file(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* add_file();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >&
+      file() const;
+
+  // optional string error = 1;
+  bool has_error() const;
+  private:
+  bool _internal_has_error() const;
+  public:
+  void clear_error();
+  const std::string& error() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_error(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_error();
+  PROTOBUF_NODISCARD std::string* release_error();
+  void set_allocated_error(std::string* error);
+  private:
+  const std::string& _internal_error() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_error(const std::string& value);
+  std::string* _internal_mutable_error();
+  public:
+
+  // optional uint64 supported_features = 2;
+  bool has_supported_features() const;
+  private:
+  bool _internal_has_supported_features() const;
+  public:
+  void clear_supported_features();
+  uint64_t supported_features() const;
+  void set_supported_features(uint64_t value);
+  private:
+  uint64_t _internal_supported_features() const;
+  void _internal_set_supported_features(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File > file_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_;
+    uint64_t supported_features_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Version
+
+// optional int32 major = 1;
+inline bool Version::_internal_has_major() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool Version::has_major() const {
+  return _internal_has_major();
+}
+inline void Version::clear_major() {
+  _impl_.major_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t Version::_internal_major() const {
+  return _impl_.major_;
+}
+inline int32_t Version::major() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.major)
+  return _internal_major();
+}
+inline void Version::_internal_set_major(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.major_ = value;
+}
+inline void Version::set_major(int32_t value) {
+  _internal_set_major(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.major)
+}
+
+// optional int32 minor = 2;
+inline bool Version::_internal_has_minor() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool Version::has_minor() const {
+  return _internal_has_minor();
+}
+inline void Version::clear_minor() {
+  _impl_.minor_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t Version::_internal_minor() const {
+  return _impl_.minor_;
+}
+inline int32_t Version::minor() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.minor)
+  return _internal_minor();
+}
+inline void Version::_internal_set_minor(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.minor_ = value;
+}
+inline void Version::set_minor(int32_t value) {
+  _internal_set_minor(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.minor)
+}
+
+// optional int32 patch = 3;
+inline bool Version::_internal_has_patch() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool Version::has_patch() const {
+  return _internal_has_patch();
+}
+inline void Version::clear_patch() {
+  _impl_.patch_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline int32_t Version::_internal_patch() const {
+  return _impl_.patch_;
+}
+inline int32_t Version::patch() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.patch)
+  return _internal_patch();
+}
+inline void Version::_internal_set_patch(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.patch_ = value;
+}
+inline void Version::set_patch(int32_t value) {
+  _internal_set_patch(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.patch)
+}
+
+// optional string suffix = 4;
+inline bool Version::_internal_has_suffix() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool Version::has_suffix() const {
+  return _internal_has_suffix();
+}
+inline void Version::clear_suffix() {
+  _impl_.suffix_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& Version::suffix() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.suffix)
+  return _internal_suffix();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Version::set_suffix(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.suffix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.suffix)
+}
+inline std::string* Version::mutable_suffix() {
+  std::string* _s = _internal_mutable_suffix();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.Version.suffix)
+  return _s;
+}
+inline const std::string& Version::_internal_suffix() const {
+  return _impl_.suffix_.Get();
+}
+inline void Version::_internal_set_suffix(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.suffix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Version::_internal_mutable_suffix() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.suffix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Version::release_suffix() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.Version.suffix)
+  if (!_internal_has_suffix()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.suffix_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.suffix_.IsDefault()) {
+    _impl_.suffix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void Version::set_allocated_suffix(std::string* suffix) {
+  if (suffix != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.suffix_.SetAllocated(suffix, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.suffix_.IsDefault()) {
+    _impl_.suffix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.Version.suffix)
+}
+
+// -------------------------------------------------------------------
+
+// CodeGeneratorRequest
+
+// repeated string file_to_generate = 1;
+inline int CodeGeneratorRequest::_internal_file_to_generate_size() const {
+  return _impl_.file_to_generate_.size();
+}
+inline int CodeGeneratorRequest::file_to_generate_size() const {
+  return _internal_file_to_generate_size();
+}
+inline void CodeGeneratorRequest::clear_file_to_generate() {
+  _impl_.file_to_generate_.Clear();
+}
+inline std::string* CodeGeneratorRequest::add_file_to_generate() {
+  std::string* _s = _internal_add_file_to_generate();
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return _s;
+}
+inline const std::string& CodeGeneratorRequest::_internal_file_to_generate(int index) const {
+  return _impl_.file_to_generate_.Get(index);
+}
+inline const std::string& CodeGeneratorRequest::file_to_generate(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return _internal_file_to_generate(index);
+}
+inline std::string* CodeGeneratorRequest::mutable_file_to_generate(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return _impl_.file_to_generate_.Mutable(index);
+}
+inline void CodeGeneratorRequest::set_file_to_generate(int index, const std::string& value) {
+  _impl_.file_to_generate_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline void CodeGeneratorRequest::set_file_to_generate(int index, std::string&& value) {
+  _impl_.file_to_generate_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.file_to_generate_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value, size_t size) {
+  _impl_.file_to_generate_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline std::string* CodeGeneratorRequest::_internal_add_file_to_generate() {
+  return _impl_.file_to_generate_.Add();
+}
+inline void CodeGeneratorRequest::add_file_to_generate(const std::string& value) {
+  _impl_.file_to_generate_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline void CodeGeneratorRequest::add_file_to_generate(std::string&& value) {
+  _impl_.file_to_generate_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline void CodeGeneratorRequest::add_file_to_generate(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.file_to_generate_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline void CodeGeneratorRequest::add_file_to_generate(const char* value, size_t size) {
+  _impl_.file_to_generate_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+CodeGeneratorRequest::file_to_generate() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return _impl_.file_to_generate_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+CodeGeneratorRequest::mutable_file_to_generate() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return &_impl_.file_to_generate_;
+}
+
+// optional string parameter = 2;
+inline bool CodeGeneratorRequest::_internal_has_parameter() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CodeGeneratorRequest::has_parameter() const {
+  return _internal_has_parameter();
+}
+inline void CodeGeneratorRequest::clear_parameter() {
+  _impl_.parameter_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& CodeGeneratorRequest::parameter() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+  return _internal_parameter();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CodeGeneratorRequest::set_parameter(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.parameter_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+}
+inline std::string* CodeGeneratorRequest::mutable_parameter() {
+  std::string* _s = _internal_mutable_parameter();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+  return _s;
+}
+inline const std::string& CodeGeneratorRequest::_internal_parameter() const {
+  return _impl_.parameter_.Get();
+}
+inline void CodeGeneratorRequest::_internal_set_parameter(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.parameter_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorRequest::_internal_mutable_parameter() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.parameter_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorRequest::release_parameter() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+  if (!_internal_has_parameter()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.parameter_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.parameter_.IsDefault()) {
+    _impl_.parameter_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CodeGeneratorRequest::set_allocated_parameter(std::string* parameter) {
+  if (parameter != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.parameter_.SetAllocated(parameter, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.parameter_.IsDefault()) {
+    _impl_.parameter_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+}
+
+// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
+inline int CodeGeneratorRequest::_internal_proto_file_size() const {
+  return _impl_.proto_file_.size();
+}
+inline int CodeGeneratorRequest::proto_file_size() const {
+  return _internal_proto_file_size();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::mutable_proto_file(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return _impl_.proto_file_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
+CodeGeneratorRequest::mutable_proto_file() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return &_impl_.proto_file_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& CodeGeneratorRequest::_internal_proto_file(int index) const {
+  return _impl_.proto_file_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& CodeGeneratorRequest::proto_file(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return _internal_proto_file(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::_internal_add_proto_file() {
+  return _impl_.proto_file_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::add_proto_file() {
+  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _add = _internal_add_proto_file();
+  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
+CodeGeneratorRequest::proto_file() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return _impl_.proto_file_;
+}
+
+// optional .google.protobuf.compiler.Version compiler_version = 3;
+inline bool CodeGeneratorRequest::_internal_has_compiler_version() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.compiler_version_ != nullptr);
+  return value;
+}
+inline bool CodeGeneratorRequest::has_compiler_version() const {
+  return _internal_has_compiler_version();
+}
+inline void CodeGeneratorRequest::clear_compiler_version() {
+  if (_impl_.compiler_version_ != nullptr) _impl_.compiler_version_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::_internal_compiler_version() const {
+  const ::PROTOBUF_NAMESPACE_ID::compiler::Version* p = _impl_.compiler_version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::compiler::Version&>(
+      ::PROTOBUF_NAMESPACE_ID::compiler::_Version_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::compiler_version() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+  return _internal_compiler_version();
+}
+inline void CodeGeneratorRequest::unsafe_arena_set_allocated_compiler_version(
+    ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compiler_version_);
+  }
+  _impl_.compiler_version_ = compiler_version;
+  if (compiler_version) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+}
+inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::release_compiler_version() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::compiler::Version* temp = _impl_.compiler_version_;
+  _impl_.compiler_version_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::unsafe_arena_release_compiler_version() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::compiler::Version* temp = _impl_.compiler_version_;
+  _impl_.compiler_version_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::_internal_mutable_compiler_version() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.compiler_version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(GetArenaForAllocation());
+    _impl_.compiler_version_ = p;
+  }
+  return _impl_.compiler_version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::mutable_compiler_version() {
+  ::PROTOBUF_NAMESPACE_ID::compiler::Version* _msg = _internal_mutable_compiler_version();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+  return _msg;
+}
+inline void CodeGeneratorRequest::set_allocated_compiler_version(::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.compiler_version_;
+  }
+  if (compiler_version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compiler_version);
+    if (message_arena != submessage_arena) {
+      compiler_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, compiler_version, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.compiler_version_ = compiler_version;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+}
+
+// -------------------------------------------------------------------
+
+// CodeGeneratorResponse_File
+
+// optional string name = 1;
+inline bool CodeGeneratorResponse_File::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CodeGeneratorResponse_File::has_name() const {
+  return _internal_has_name();
+}
+inline void CodeGeneratorResponse_File::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& CodeGeneratorResponse_File::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CodeGeneratorResponse_File::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+}
+inline std::string* CodeGeneratorResponse_File::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+  return _s;
+}
+inline const std::string& CodeGeneratorResponse_File::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void CodeGeneratorResponse_File::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorResponse_File::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorResponse_File::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CodeGeneratorResponse_File::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+}
+
+// optional string insertion_point = 2;
+inline bool CodeGeneratorResponse_File::_internal_has_insertion_point() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CodeGeneratorResponse_File::has_insertion_point() const {
+  return _internal_has_insertion_point();
+}
+inline void CodeGeneratorResponse_File::clear_insertion_point() {
+  _impl_.insertion_point_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& CodeGeneratorResponse_File::insertion_point() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+  return _internal_insertion_point();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CodeGeneratorResponse_File::set_insertion_point(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.insertion_point_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+}
+inline std::string* CodeGeneratorResponse_File::mutable_insertion_point() {
+  std::string* _s = _internal_mutable_insertion_point();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+  return _s;
+}
+inline const std::string& CodeGeneratorResponse_File::_internal_insertion_point() const {
+  return _impl_.insertion_point_.Get();
+}
+inline void CodeGeneratorResponse_File::_internal_set_insertion_point(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.insertion_point_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorResponse_File::_internal_mutable_insertion_point() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.insertion_point_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorResponse_File::release_insertion_point() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+  if (!_internal_has_insertion_point()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.insertion_point_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.insertion_point_.IsDefault()) {
+    _impl_.insertion_point_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CodeGeneratorResponse_File::set_allocated_insertion_point(std::string* insertion_point) {
+  if (insertion_point != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.insertion_point_.SetAllocated(insertion_point, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.insertion_point_.IsDefault()) {
+    _impl_.insertion_point_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+}
+
+// optional string content = 15;
+inline bool CodeGeneratorResponse_File::_internal_has_content() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool CodeGeneratorResponse_File::has_content() const {
+  return _internal_has_content();
+}
+inline void CodeGeneratorResponse_File::clear_content() {
+  _impl_.content_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& CodeGeneratorResponse_File::content() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+  return _internal_content();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CodeGeneratorResponse_File::set_content(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.content_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+}
+inline std::string* CodeGeneratorResponse_File::mutable_content() {
+  std::string* _s = _internal_mutable_content();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+  return _s;
+}
+inline const std::string& CodeGeneratorResponse_File::_internal_content() const {
+  return _impl_.content_.Get();
+}
+inline void CodeGeneratorResponse_File::_internal_set_content(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.content_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorResponse_File::_internal_mutable_content() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.content_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorResponse_File::release_content() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+  if (!_internal_has_content()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.content_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.content_.IsDefault()) {
+    _impl_.content_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CodeGeneratorResponse_File::set_allocated_content(std::string* content) {
+  if (content != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.content_.SetAllocated(content, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.content_.IsDefault()) {
+    _impl_.content_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+}
+
+// optional .google.protobuf.GeneratedCodeInfo generated_code_info = 16;
+inline bool CodeGeneratorResponse_File::_internal_has_generated_code_info() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.generated_code_info_ != nullptr);
+  return value;
+}
+inline bool CodeGeneratorResponse_File::has_generated_code_info() const {
+  return _internal_has_generated_code_info();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& CodeGeneratorResponse_File::_internal_generated_code_info() const {
+  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* p = _impl_.generated_code_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo&>(
+      ::PROTOBUF_NAMESPACE_ID::_GeneratedCodeInfo_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& CodeGeneratorResponse_File::generated_code_info() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+  return _internal_generated_code_info();
+}
+inline void CodeGeneratorResponse_File::unsafe_arena_set_allocated_generated_code_info(
+    ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.generated_code_info_);
+  }
+  _impl_.generated_code_info_ = generated_code_info;
+  if (generated_code_info) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::release_generated_code_info() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* temp = _impl_.generated_code_info_;
+  _impl_.generated_code_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::unsafe_arena_release_generated_code_info() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* temp = _impl_.generated_code_info_;
+  _impl_.generated_code_info_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::_internal_mutable_generated_code_info() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.generated_code_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(GetArenaForAllocation());
+    _impl_.generated_code_info_ = p;
+  }
+  return _impl_.generated_code_info_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::mutable_generated_code_info() {
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* _msg = _internal_mutable_generated_code_info();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+  return _msg;
+}
+inline void CodeGeneratorResponse_File::set_allocated_generated_code_info(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.generated_code_info_);
+  }
+  if (generated_code_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(generated_code_info));
+    if (message_arena != submessage_arena) {
+      generated_code_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, generated_code_info, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.generated_code_info_ = generated_code_info;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+}
+
+// -------------------------------------------------------------------
+
+// CodeGeneratorResponse
+
+// optional string error = 1;
+inline bool CodeGeneratorResponse::_internal_has_error() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool CodeGeneratorResponse::has_error() const {
+  return _internal_has_error();
+}
+inline void CodeGeneratorResponse::clear_error() {
+  _impl_.error_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& CodeGeneratorResponse::error() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.error)
+  return _internal_error();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void CodeGeneratorResponse::set_error(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.error_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.error)
+}
+inline std::string* CodeGeneratorResponse::mutable_error() {
+  std::string* _s = _internal_mutable_error();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.error)
+  return _s;
+}
+inline const std::string& CodeGeneratorResponse::_internal_error() const {
+  return _impl_.error_.Get();
+}
+inline void CodeGeneratorResponse::_internal_set_error(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.error_.Set(value, GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorResponse::_internal_mutable_error() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.error_.Mutable(GetArenaForAllocation());
+}
+inline std::string* CodeGeneratorResponse::release_error() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.error)
+  if (!_internal_has_error()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.error_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.error_.IsDefault()) {
+    _impl_.error_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void CodeGeneratorResponse::set_allocated_error(std::string* error) {
+  if (error != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.error_.SetAllocated(error, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.error_.IsDefault()) {
+    _impl_.error_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.error)
+}
+
+// optional uint64 supported_features = 2;
+inline bool CodeGeneratorResponse::_internal_has_supported_features() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool CodeGeneratorResponse::has_supported_features() const {
+  return _internal_has_supported_features();
+}
+inline void CodeGeneratorResponse::clear_supported_features() {
+  _impl_.supported_features_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline uint64_t CodeGeneratorResponse::_internal_supported_features() const {
+  return _impl_.supported_features_;
+}
+inline uint64_t CodeGeneratorResponse::supported_features() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.supported_features)
+  return _internal_supported_features();
+}
+inline void CodeGeneratorResponse::_internal_set_supported_features(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.supported_features_ = value;
+}
+inline void CodeGeneratorResponse::set_supported_features(uint64_t value) {
+  _internal_set_supported_features(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.supported_features)
+}
+
+// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
+inline int CodeGeneratorResponse::_internal_file_size() const {
+  return _impl_.file_.size();
+}
+inline int CodeGeneratorResponse::file_size() const {
+  return _internal_file_size();
+}
+inline void CodeGeneratorResponse::clear_file() {
+  _impl_.file_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::mutable_file(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return _impl_.file_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >*
+CodeGeneratorResponse::mutable_file() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return &_impl_.file_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::_internal_file(int index) const {
+  return _impl_.file_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::file(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return _internal_file(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::_internal_add_file() {
+  return _impl_.file_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::add_file() {
+  ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* _add = _internal_add_file();
+  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >&
+CodeGeneratorResponse::file() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return _impl_.file_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace compiler
+PROTOBUF_NAMESPACE_CLOSE
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature>() {
+  return ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fplugin_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.proto b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.proto
new file mode 100644
index 0000000..9242aac
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.proto
@@ -0,0 +1,183 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//
+// WARNING:  The plugin interface is currently EXPERIMENTAL and is subject to
+//   change.
+//
+// protoc (aka the Protocol Compiler) can be extended via plugins.  A plugin is
+// just a program that reads a CodeGeneratorRequest from stdin and writes a
+// CodeGeneratorResponse to stdout.
+//
+// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
+// of dealing with the raw protocol defined here.
+//
+// A plugin executable needs only to be placed somewhere in the path.  The
+// plugin should be named "protoc-gen-$NAME", and will then be used when the
+// flag "--${NAME}_out" is passed to protoc.
+
+syntax = "proto2";
+
+package google.protobuf.compiler;
+option java_package = "com.google.protobuf.compiler";
+option java_outer_classname = "PluginProtos";
+
+option go_package = "google.golang.org/protobuf/types/pluginpb";
+
+import "google/protobuf/descriptor.proto";
+
+// The version number of protocol compiler.
+message Version {
+  optional int32 major = 1;
+  optional int32 minor = 2;
+  optional int32 patch = 3;
+  // A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
+  // be empty for mainline stable releases.
+  optional string suffix = 4;
+}
+
+// An encoded CodeGeneratorRequest is written to the plugin's stdin.
+message CodeGeneratorRequest {
+  // The .proto files that were explicitly listed on the command-line.  The
+  // code generator should generate code only for these files.  Each file's
+  // descriptor will be included in proto_file, below.
+  repeated string file_to_generate = 1;
+
+  // The generator parameter passed on the command-line.
+  optional string parameter = 2;
+
+  // FileDescriptorProtos for all files in files_to_generate and everything
+  // they import.  The files will appear in topological order, so each file
+  // appears before any file that imports it.
+  //
+  // protoc guarantees that all proto_files will be written after
+  // the fields above, even though this is not technically guaranteed by the
+  // protobuf wire format.  This theoretically could allow a plugin to stream
+  // in the FileDescriptorProtos and handle them one by one rather than read
+  // the entire set into memory at once.  However, as of this writing, this
+  // is not similarly optimized on protoc's end -- it will store all fields in
+  // memory at once before sending them to the plugin.
+  //
+  // Type names of fields and extensions in the FileDescriptorProto are always
+  // fully qualified.
+  repeated FileDescriptorProto proto_file = 15;
+
+  // The version number of protocol compiler.
+  optional Version compiler_version = 3;
+
+}
+
+// The plugin writes an encoded CodeGeneratorResponse to stdout.
+message CodeGeneratorResponse {
+  // Error message.  If non-empty, code generation failed.  The plugin process
+  // should exit with status code zero even if it reports an error in this way.
+  //
+  // This should be used to indicate errors in .proto files which prevent the
+  // code generator from generating correct code.  Errors which indicate a
+  // problem in protoc itself -- such as the input CodeGeneratorRequest being
+  // unparseable -- should be reported by writing a message to stderr and
+  // exiting with a non-zero status code.
+  optional string error = 1;
+
+  // A bitmask of supported features that the code generator supports.
+  // This is a bitwise "or" of values from the Feature enum.
+  optional uint64 supported_features = 2;
+
+  // Sync with code_generator.h.
+  enum Feature {
+    FEATURE_NONE = 0;
+    FEATURE_PROTO3_OPTIONAL = 1;
+  }
+
+  // Represents a single generated file.
+  message File {
+    // The file name, relative to the output directory.  The name must not
+    // contain "." or ".." components and must be relative, not be absolute (so,
+    // the file cannot lie outside the output directory).  "/" must be used as
+    // the path separator, not "\".
+    //
+    // If the name is omitted, the content will be appended to the previous
+    // file.  This allows the generator to break large files into small chunks,
+    // and allows the generated text to be streamed back to protoc so that large
+    // files need not reside completely in memory at one time.  Note that as of
+    // this writing protoc does not optimize for this -- it will read the entire
+    // CodeGeneratorResponse before writing files to disk.
+    optional string name = 1;
+
+    // If non-empty, indicates that the named file should already exist, and the
+    // content here is to be inserted into that file at a defined insertion
+    // point.  This feature allows a code generator to extend the output
+    // produced by another code generator.  The original generator may provide
+    // insertion points by placing special annotations in the file that look
+    // like:
+    //   @@protoc_insertion_point(NAME)
+    // The annotation can have arbitrary text before and after it on the line,
+    // which allows it to be placed in a comment.  NAME should be replaced with
+    // an identifier naming the point -- this is what other generators will use
+    // as the insertion_point.  Code inserted at this point will be placed
+    // immediately above the line containing the insertion point (thus multiple
+    // insertions to the same point will come out in the order they were added).
+    // The double-@ is intended to make it unlikely that the generated code
+    // could contain things that look like insertion points by accident.
+    //
+    // For example, the C++ code generator places the following line in the
+    // .pb.h files that it generates:
+    //   // @@protoc_insertion_point(namespace_scope)
+    // This line appears within the scope of the file's package namespace, but
+    // outside of any particular class.  Another plugin can then specify the
+    // insertion_point "namespace_scope" to generate additional classes or
+    // other declarations that should be placed in this scope.
+    //
+    // Note that if the line containing the insertion point begins with
+    // whitespace, the same whitespace will be added to every line of the
+    // inserted text.  This is useful for languages like Python, where
+    // indentation matters.  In these languages, the insertion point comment
+    // should be indented the same amount as any inserted code will need to be
+    // in order to work correctly in that context.
+    //
+    // The code generator that generates the initial file and the one which
+    // inserts into it must both run as part of a single invocation of protoc.
+    // Code generators are executed in the order in which they appear on the
+    // command line.
+    //
+    // If |insertion_point| is present, |name| must also be present.
+    optional string insertion_point = 2;
+
+    // The file contents.
+    optional string content = 15;
+
+    // Information describing the file content being inserted. If an insertion
+    // point is used, this information will be appropriately offset and inserted
+    // into the code generation metadata for the generated files.
+    optional GeneratedCodeInfo generated_code_info = 16;
+  }
+  repeated File file = 15;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/python/generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/generator.h
new file mode 100644
index 0000000..f1fecbc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/generator.h
@@ -0,0 +1,185 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: robinson@google.com (Will Robinson)
+//
+// Generates Python code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PYTHON_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_PYTHON_GENERATOR_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/compiler/code_generator.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class EnumValueDescriptor;
+class FieldDescriptor;
+class OneofDescriptor;
+class ServiceDescriptor;
+
+namespace io {
+class Printer;
+}
+
+namespace compiler {
+namespace python {
+
+// CodeGenerator implementation for generated Python protocol buffer classes.
+// If you create your own protocol compiler binary and you want it to support
+// Python output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class PROTOC_EXPORT Generator : public CodeGenerator {
+ public:
+  Generator();
+  ~Generator() override;
+
+  // CodeGenerator methods.
+  bool Generate(const FileDescriptor* file, const std::string& parameter,
+                GeneratorContext* generator_context,
+                std::string* error) const override;
+
+  uint64_t GetSupportedFeatures() const override;
+
+ private:
+  void PrintImports() const;
+  void PrintFileDescriptor() const;
+  void PrintAllNestedEnumsInFile() const;
+  void PrintNestedEnums(const Descriptor& descriptor) const;
+  void PrintEnum(const EnumDescriptor& enum_descriptor) const;
+
+  void PrintFieldDescriptor(const FieldDescriptor& field,
+                            bool is_extension) const;
+  void PrintFieldDescriptorsInDescriptor(
+      const Descriptor& message_descriptor, bool is_extension,
+      const std::string& list_variable_name, int (Descriptor::*CountFn)() const,
+      const FieldDescriptor* (Descriptor::*GetterFn)(int)const) const;
+  void PrintFieldsInDescriptor(const Descriptor& message_descriptor) const;
+  void PrintExtensionsInDescriptor(const Descriptor& message_descriptor) const;
+  void PrintMessageDescriptors() const;
+  void PrintDescriptor(const Descriptor& message_descriptor) const;
+  void PrintNestedDescriptors(const Descriptor& containing_descriptor) const;
+
+  void PrintMessages() const;
+  void PrintMessage(const Descriptor& message_descriptor,
+                    const std::string& prefix,
+                    std::vector<std::string>* to_register,
+                    bool is_nested) const;
+  void PrintNestedMessages(const Descriptor& containing_descriptor,
+                           const std::string& prefix,
+                           std::vector<std::string>* to_register) const;
+
+  void FixForeignFieldsInDescriptors() const;
+  void FixForeignFieldsInDescriptor(
+      const Descriptor& descriptor,
+      const Descriptor* containing_descriptor) const;
+  void FixForeignFieldsInField(const Descriptor* containing_type,
+                               const FieldDescriptor& field,
+                               const std::string& python_dict_name) const;
+  void AddMessageToFileDescriptor(const Descriptor& descriptor) const;
+  void AddEnumToFileDescriptor(const EnumDescriptor& descriptor) const;
+  void AddExtensionToFileDescriptor(const FieldDescriptor& descriptor) const;
+  void AddServiceToFileDescriptor(const ServiceDescriptor& descriptor) const;
+  std::string FieldReferencingExpression(
+      const Descriptor* containing_type, const FieldDescriptor& field,
+      const std::string& python_dict_name) const;
+  template <typename DescriptorT>
+  void FixContainingTypeInDescriptor(
+      const DescriptorT& descriptor,
+      const Descriptor* containing_descriptor) const;
+
+  void FixForeignFieldsInExtensions() const;
+  void FixForeignFieldsInExtension(
+      const FieldDescriptor& extension_field) const;
+  void FixForeignFieldsInNestedExtensions(const Descriptor& descriptor) const;
+
+  void PrintServices() const;
+  void PrintServiceDescriptors() const;
+  void PrintServiceDescriptor(const ServiceDescriptor& descriptor) const;
+  void PrintServiceClass(const ServiceDescriptor& descriptor) const;
+  void PrintServiceStub(const ServiceDescriptor& descriptor) const;
+  void PrintDescriptorKeyAndModuleName(
+      const ServiceDescriptor& descriptor) const;
+
+  void PrintEnumValueDescriptor(const EnumValueDescriptor& descriptor) const;
+  std::string OptionsValue(const std::string& serialized_options) const;
+  bool GeneratingDescriptorProto() const;
+
+  template <typename DescriptorT>
+  std::string ModuleLevelDescriptorName(const DescriptorT& descriptor) const;
+  std::string ModuleLevelMessageName(const Descriptor& descriptor) const;
+  std::string ModuleLevelServiceDescriptorName(
+      const ServiceDescriptor& descriptor) const;
+
+  template <typename DescriptorT, typename DescriptorProtoT>
+  void PrintSerializedPbInterval(const DescriptorT& descriptor,
+                                 DescriptorProtoT& proto,
+                                 const std::string& name) const;
+
+  void FixAllDescriptorOptions() const;
+  void FixOptionsForField(const FieldDescriptor& field) const;
+  void FixOptionsForOneof(const OneofDescriptor& oneof) const;
+  void FixOptionsForEnum(const EnumDescriptor& descriptor) const;
+  void FixOptionsForService(const ServiceDescriptor& descriptor) const;
+  void FixOptionsForMessage(const Descriptor& descriptor) const;
+
+  void SetSerializedPbInterval() const;
+  void SetMessagePbInterval(const Descriptor& descriptor) const;
+
+  void CopyPublicDependenciesAliases(const std::string& copy_from,
+                                     const FileDescriptor* file) const;
+
+  // Very coarse-grained lock to ensure that Generate() is reentrant.
+  // Guards file_, printer_ and file_descriptor_serialized_.
+  mutable Mutex mutex_;
+  mutable const FileDescriptor* file_;  // Set in Generate().  Under mutex_.
+  mutable std::string file_descriptor_serialized_;
+  mutable io::Printer* printer_;  // Set in Generate().  Under mutex_.
+  mutable bool pure_python_workable_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Generator);
+};
+
+}  // namespace python
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_PYTHON_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/python/pyi_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/pyi_generator.h
new file mode 100644
index 0000000..9611ed4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/pyi_generator.h
@@ -0,0 +1,120 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: jieluo@google.com (Jie Luo)
+//
+// Generates Python stub (.pyi) for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PYTHON_PYI_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_PYTHON_PYI_GENERATOR_H__
+
+#include <map>
+#include <set>
+#include <string>
+
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/compiler/code_generator.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+class Descriptor;
+class EnumDescriptor;
+class FieldDescriptor;
+class MethodDescriptor;
+class ServiceDescriptor;
+
+namespace io {
+class Printer;
+}
+
+namespace compiler {
+namespace python {
+
+class PROTOC_EXPORT PyiGenerator : public google::protobuf::compiler::CodeGenerator {
+ public:
+  PyiGenerator();
+  ~PyiGenerator() override;
+
+  // CodeGenerator methods.
+  uint64_t GetSupportedFeatures() const override {
+    // Code generators must explicitly support proto3 optional.
+    return CodeGenerator::FEATURE_PROTO3_OPTIONAL;
+  }
+  bool Generate(const FileDescriptor* file, const std::string& parameter,
+                GeneratorContext* generator_context,
+                std::string* error) const override;
+
+ private:
+  void PrintImportForDescriptor(const FileDescriptor& desc,
+                                std::map<std::string, std::string>* import_map,
+                                std::set<std::string>* seen_aliases) const;
+  void PrintImports(std::map<std::string, std::string>* item_map,
+                    std::map<std::string, std::string>* import_map) const;
+  void PrintEnum(const EnumDescriptor& enum_descriptor) const;
+  void AddEnumValue(const EnumDescriptor& enum_descriptor,
+                    std::map<std::string, std::string>* item_map,
+                    const std::map<std::string, std::string>& import_map) const;
+  void PrintTopLevelEnums() const;
+  template <typename DescriptorT>
+  void AddExtensions(const DescriptorT& descriptor,
+                     std::map<std::string, std::string>* item_map) const;
+  void PrintMessages(
+      const std::map<std::string, std::string>& import_map) const;
+  void PrintMessage(const Descriptor& message_descriptor, bool is_nested,
+                    const std::map<std::string, std::string>& import_map) const;
+  void PrintServices() const;
+  void PrintItemMap(const std::map<std::string, std::string>& item_map) const;
+  std::string GetFieldType(
+      const FieldDescriptor& field_des, const Descriptor& containing_des,
+      const std::map<std::string, std::string>& import_map) const;
+  template <typename DescriptorT>
+  std::string ModuleLevelName(
+      const DescriptorT& descriptor,
+      const std::map<std::string, std::string>& import_map) const;
+
+  // Very coarse-grained lock to ensure that Generate() is reentrant.
+  // Guards file_ and printer_.
+  mutable Mutex mutex_;
+  mutable const FileDescriptor* file_;  // Set in Generate().  Under mutex_.
+  mutable io::Printer* printer_;        // Set in Generate().  Under mutex_.
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PyiGenerator);
+};
+
+}  // namespace python
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_PYTHON_PYI_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/python/python_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/python_generator.h
new file mode 100644
index 0000000..21d48cd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/python_generator.h
@@ -0,0 +1,6 @@
+#ifndef GOOGLE_PROTOBUF_COMPILER_PYTHON_PYTHON_GENERATOR_H_
+#define GOOGLE_PROTOBUF_COMPILER_PYTHON_PYTHON_GENERATOR_H_
+
+#include <google/protobuf/compiler/python/generator.h>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_PYTHON_PYTHON_GENERATOR_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/ruby/ruby_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/ruby/ruby_generator.h
new file mode 100644
index 0000000..647bb83
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/ruby/ruby_generator.h
@@ -0,0 +1,67 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates Ruby code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_RUBY_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_RUBY_GENERATOR_H__
+
+#include <string>
+
+#include <google/protobuf/compiler/code_generator.h>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace ruby {
+
+// CodeGenerator implementation for generated Ruby protocol buffer classes.
+// If you create your own protocol compiler binary and you want it to support
+// Ruby output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class PROTOC_EXPORT Generator : public CodeGenerator {
+  bool Generate(const FileDescriptor* file, const std::string& parameter,
+                GeneratorContext* generator_context,
+                std::string* error) const override;
+  uint64_t GetSupportedFeatures() const override {
+    return FEATURE_PROTO3_OPTIONAL;
+  }
+};
+
+}  // namespace ruby
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_RUBY_GENERATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/descriptor.h b/CAPI/cpp/grpc/include/google/protobuf/descriptor.h
new file mode 100644
index 0000000..1b8728e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/descriptor.h
@@ -0,0 +1,2440 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains classes which describe a type of protocol message.
+// You can use a message's descriptor to learn at runtime what fields
+// it contains and what the types of those fields are.  The Message
+// interface also allows you to dynamically access and modify individual
+// fields by passing the FieldDescriptor of the field you are interested
+// in.
+//
+// Most users will not care about descriptors, because they will write
+// code specific to certain protocol types and will simply use the classes
+// generated by the protocol compiler directly.  Advanced users who want
+// to operate on arbitrary types (not known at compile time) may want to
+// read descriptors in order to learn about the contents of a message.
+// A very small number of users will want to construct their own
+// Descriptors, either because they are implementing Message manually or
+// because they are writing something like the protocol compiler.
+//
+// For an example of how you might use descriptors, see the code example
+// at the top of message.h.
+
+#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_H__
+#define GOOGLE_PROTOBUF_DESCRIPTOR_H__
+
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/port.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+// TYPE_BOOL is defined in the MacOS's ConditionalMacros.h.
+#ifdef TYPE_BOOL
+#undef TYPE_BOOL
+#endif  // TYPE_BOOL
+
+#ifdef SWIG
+#define PROTOBUF_EXPORT
+#endif
+
+
+namespace google {
+namespace protobuf {
+
+// Defined in this file.
+class Descriptor;
+class FieldDescriptor;
+class OneofDescriptor;
+class EnumDescriptor;
+class EnumValueDescriptor;
+class ServiceDescriptor;
+class MethodDescriptor;
+class FileDescriptor;
+class DescriptorDatabase;
+class DescriptorPool;
+
+// Defined in descriptor.proto
+class DescriptorProto;
+class DescriptorProto_ExtensionRange;
+class FieldDescriptorProto;
+class OneofDescriptorProto;
+class EnumDescriptorProto;
+class EnumValueDescriptorProto;
+class ServiceDescriptorProto;
+class MethodDescriptorProto;
+class FileDescriptorProto;
+class MessageOptions;
+class FieldOptions;
+class OneofOptions;
+class EnumOptions;
+class EnumValueOptions;
+class ExtensionRangeOptions;
+class ServiceOptions;
+class MethodOptions;
+class FileOptions;
+class UninterpretedOption;
+class SourceCodeInfo;
+
+// Defined in message.h
+class Message;
+class Reflection;
+
+// Defined in descriptor.cc
+class DescriptorBuilder;
+class FileDescriptorTables;
+class Symbol;
+
+// Defined in unknown_field_set.h.
+class UnknownField;
+
+// Defined in command_line_interface.cc
+namespace compiler {
+class CommandLineInterface;
+namespace cpp {
+// Defined in helpers.h
+class Formatter;
+}  // namespace cpp
+}  // namespace compiler
+
+namespace descriptor_unittest {
+class DescriptorTest;
+}  // namespace descriptor_unittest
+
+// Defined in printer.h
+namespace io {
+class Printer;
+}  // namespace io
+
+// NB, all indices are zero-based.
+struct SourceLocation {
+  int start_line;
+  int end_line;
+  int start_column;
+  int end_column;
+
+  // Doc comments found at the source location.
+  // See the comments in SourceCodeInfo.Location (descriptor.proto) for details.
+  std::string leading_comments;
+  std::string trailing_comments;
+  std::vector<std::string> leading_detached_comments;
+};
+
+// Options when generating machine-parsable output from a descriptor with
+// DebugString().
+struct DebugStringOptions {
+  // include original user comments as recorded in SourceLocation entries. N.B.
+  // that this must be |false| by default: several other pieces of code (for
+  // example, the C++ code generation for fields in the proto compiler) rely on
+  // DebugString() output being unobstructed by user comments.
+  bool include_comments;
+  // If true, elide the braced body in the debug string.
+  bool elide_group_body;
+  bool elide_oneof_body;
+
+  DebugStringOptions()
+      : include_comments(false),
+        elide_group_body(false),
+        elide_oneof_body(false) {
+  }
+};
+
+// A class to handle the simplest cases of a lazily linked descriptor
+// for a message type that isn't built at the time of cross linking,
+// which is needed when a pool has lazily_build_dependencies_ set.
+// Must be instantiated as mutable in a descriptor.
+namespace internal {
+
+// The classes in this file represent a significant memory footprint for the
+// library. We make sure we are not accidentally making them larger by
+// hardcoding the struct size for a specific platform. Use as:
+//
+//   PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(type, expected_size_in_x84-64);
+//
+
+#if !defined(PROTOBUF_INTERNAL_CHECK_CLASS_SIZE)
+#define PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(t, expected)
+#endif
+
+class FlatAllocator;
+
+class PROTOBUF_EXPORT LazyDescriptor {
+ public:
+  // Init function to be called at init time of a descriptor containing
+  // a LazyDescriptor.
+  void Init() {
+    descriptor_ = nullptr;
+    once_ = nullptr;
+  }
+
+  // Sets the value of the descriptor if it is known during the descriptor
+  // building process. Not thread safe, should only be called during the
+  // descriptor build process. Should not be called after SetLazy has been
+  // called.
+  void Set(const Descriptor* descriptor);
+
+  // Sets the information needed to lazily cross link the descriptor at a later
+  // time, SetLazy is not thread safe, should be called only once at descriptor
+  // build time if the symbol wasn't found and building of the file containing
+  // that type is delayed because lazily_build_dependencies_ is set on the pool.
+  // Should not be called after Set() has been called.
+  void SetLazy(StringPiece name, const FileDescriptor* file);
+
+  // Returns the current value of the descriptor, thread-safe. If SetLazy(...)
+  // has been called, will do a one-time cross link of the type specified,
+  // building the descriptor file that contains the type if necessary.
+  inline const Descriptor* Get(const ServiceDescriptor* service) {
+    Once(service);
+    return descriptor_;
+  }
+
+ private:
+  void Once(const ServiceDescriptor* service);
+
+  const Descriptor* descriptor_;
+  // The once_ flag is followed by a NUL terminated string for the type name.
+  internal::once_flag* once_;
+};
+
+class PROTOBUF_EXPORT SymbolBase {
+ private:
+  friend class google::protobuf::Symbol;
+  uint8_t symbol_type_;
+};
+
+// Some types have more than one SymbolBase because they have multiple
+// identities in the table. We can't have duplicate direct bases, so we use this
+// intermediate base to do so.
+// See BuildEnumValue for details.
+template <int N>
+class PROTOBUF_EXPORT SymbolBaseN : public SymbolBase {};
+
+}  // namespace internal
+
+// Describes a type of protocol message, or a particular group within a
+// message.  To obtain the Descriptor for a given message object, call
+// Message::GetDescriptor().  Generated message classes also have a
+// static method called descriptor() which returns the type's descriptor.
+// Use DescriptorPool to construct your own descriptors.
+class PROTOBUF_EXPORT Descriptor : private internal::SymbolBase {
+ public:
+  typedef DescriptorProto Proto;
+
+  // The name of the message type, not including its scope.
+  const std::string& name() const;
+
+  // The fully-qualified name of the message type, scope delimited by
+  // periods.  For example, message type "Foo" which is declared in package
+  // "bar" has full name "bar.Foo".  If a type "Baz" is nested within
+  // Foo, Baz's full_name is "bar.Foo.Baz".  To get only the part that
+  // comes after the last '.', use name().
+  const std::string& full_name() const;
+
+  // Index of this descriptor within the file or containing type's message
+  // type array.
+  int index() const;
+
+  // The .proto file in which this message type was defined.  Never nullptr.
+  const FileDescriptor* file() const;
+
+  // If this Descriptor describes a nested type, this returns the type
+  // in which it is nested.  Otherwise, returns nullptr.
+  const Descriptor* containing_type() const;
+
+  // Get options for this message type.  These are specified in the .proto file
+  // by placing lines like "option foo = 1234;" in the message definition.
+  // Allowed options are defined by MessageOptions in descriptor.proto, and any
+  // available extensions of that message.
+  const MessageOptions& options() const;
+
+  // Write the contents of this Descriptor into the given DescriptorProto.
+  // The target DescriptorProto must be clear before calling this; if it
+  // isn't, the result may be garbage.
+  void CopyTo(DescriptorProto* proto) const;
+
+  // Write the contents of this descriptor in a human-readable form. Output
+  // will be suitable for re-parsing.
+  std::string DebugString() const;
+
+  // Similar to DebugString(), but additionally takes options (e.g.,
+  // include original user comments in output).
+  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Returns true if this is a placeholder for an unknown type. This will
+  // only be the case if this descriptor comes from a DescriptorPool
+  // with AllowUnknownDependencies() set.
+  bool is_placeholder() const;
+
+  enum WellKnownType {
+    WELLKNOWNTYPE_UNSPECIFIED,  // Not a well-known type.
+
+    // Wrapper types.
+    WELLKNOWNTYPE_DOUBLEVALUE,  // google.protobuf.DoubleValue
+    WELLKNOWNTYPE_FLOATVALUE,   // google.protobuf.FloatValue
+    WELLKNOWNTYPE_INT64VALUE,   // google.protobuf.Int64Value
+    WELLKNOWNTYPE_UINT64VALUE,  // google.protobuf.UInt64Value
+    WELLKNOWNTYPE_INT32VALUE,   // google.protobuf.Int32Value
+    WELLKNOWNTYPE_UINT32VALUE,  // google.protobuf.UInt32Value
+    WELLKNOWNTYPE_STRINGVALUE,  // google.protobuf.StringValue
+    WELLKNOWNTYPE_BYTESVALUE,   // google.protobuf.BytesValue
+    WELLKNOWNTYPE_BOOLVALUE,    // google.protobuf.BoolValue
+
+    // Other well known types.
+    WELLKNOWNTYPE_ANY,        // google.protobuf.Any
+    WELLKNOWNTYPE_FIELDMASK,  // google.protobuf.FieldMask
+    WELLKNOWNTYPE_DURATION,   // google.protobuf.Duration
+    WELLKNOWNTYPE_TIMESTAMP,  // google.protobuf.Timestamp
+    WELLKNOWNTYPE_VALUE,      // google.protobuf.Value
+    WELLKNOWNTYPE_LISTVALUE,  // google.protobuf.ListValue
+    WELLKNOWNTYPE_STRUCT,     // google.protobuf.Struct
+
+    // New well-known types may be added in the future.
+    // Please make sure any switch() statements have a 'default' case.
+    __WELLKNOWNTYPE__DO_NOT_USE__ADD_DEFAULT_INSTEAD__,
+  };
+
+  WellKnownType well_known_type() const;
+
+  // Field stuff -----------------------------------------------------
+
+  // The number of fields in this message type.
+  int field_count() const;
+  // Gets a field by index, where 0 <= index < field_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FieldDescriptor* field(int index) const;
+
+  // Looks up a field by declared tag number.  Returns nullptr if no such field
+  // exists.
+  const FieldDescriptor* FindFieldByNumber(int number) const;
+  // Looks up a field by name.  Returns nullptr if no such field exists.
+  const FieldDescriptor* FindFieldByName(ConstStringParam name) const;
+
+  // Looks up a field by lowercased name (as returned by lowercase_name()).
+  // This lookup may be ambiguous if multiple field names differ only by case,
+  // in which case the field returned is chosen arbitrarily from the matches.
+  const FieldDescriptor* FindFieldByLowercaseName(
+      ConstStringParam lowercase_name) const;
+
+  // Looks up a field by camel-case name (as returned by camelcase_name()).
+  // This lookup may be ambiguous if multiple field names differ in a way that
+  // leads them to have identical camel-case names, in which case the field
+  // returned is chosen arbitrarily from the matches.
+  const FieldDescriptor* FindFieldByCamelcaseName(
+      ConstStringParam camelcase_name) const;
+
+  // The number of oneofs in this message type.
+  int oneof_decl_count() const;
+  // The number of oneofs in this message type, excluding synthetic oneofs.
+  // Real oneofs always come first, so iterating up to real_oneof_decl_cout()
+  // will yield all real oneofs.
+  int real_oneof_decl_count() const;
+  // Get a oneof by index, where 0 <= index < oneof_decl_count().
+  // These are returned in the order they were defined in the .proto file.
+  const OneofDescriptor* oneof_decl(int index) const;
+
+  // Looks up a oneof by name.  Returns nullptr if no such oneof exists.
+  const OneofDescriptor* FindOneofByName(ConstStringParam name) const;
+
+  // Nested type stuff -----------------------------------------------
+
+  // The number of nested types in this message type.
+  int nested_type_count() const;
+  // Gets a nested type by index, where 0 <= index < nested_type_count().
+  // These are returned in the order they were defined in the .proto file.
+  const Descriptor* nested_type(int index) const;
+
+  // Looks up a nested type by name.  Returns nullptr if no such nested type
+  // exists.
+  const Descriptor* FindNestedTypeByName(ConstStringParam name) const;
+
+  // Enum stuff ------------------------------------------------------
+
+  // The number of enum types in this message type.
+  int enum_type_count() const;
+  // Gets an enum type by index, where 0 <= index < enum_type_count().
+  // These are returned in the order they were defined in the .proto file.
+  const EnumDescriptor* enum_type(int index) const;
+
+  // Looks up an enum type by name.  Returns nullptr if no such enum type
+  // exists.
+  const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
+
+  // Looks up an enum value by name, among all enum types in this message.
+  // Returns nullptr if no such value exists.
+  const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
+
+  // Extensions ------------------------------------------------------
+
+  // A range of field numbers which are designated for third-party
+  // extensions.
+  struct ExtensionRange {
+    typedef DescriptorProto_ExtensionRange Proto;
+
+    typedef ExtensionRangeOptions OptionsType;
+
+    // See Descriptor::CopyTo().
+    void CopyTo(DescriptorProto_ExtensionRange* proto) const;
+
+    int start;  // inclusive
+    int end;    // exclusive
+
+    const ExtensionRangeOptions* options_;
+  };
+
+  // The number of extension ranges in this message type.
+  int extension_range_count() const;
+  // Gets an extension range by index, where 0 <= index <
+  // extension_range_count(). These are returned in the order they were defined
+  // in the .proto file.
+  const ExtensionRange* extension_range(int index) const;
+
+  // Returns true if the number is in one of the extension ranges.
+  bool IsExtensionNumber(int number) const;
+
+  // Returns nullptr if no extension range contains the given number.
+  const ExtensionRange* FindExtensionRangeContainingNumber(int number) const;
+
+  // The number of extensions defined nested within this message type's scope.
+  // See doc:
+  // https://developers.google.com/protocol-buffers/docs/proto#nested-extensions
+  //
+  // Note that the extensions may be extending *other* messages.
+  //
+  // For example:
+  // message M1 {
+  //   extensions 1 to max;
+  // }
+  //
+  // message M2 {
+  //   extend M1 {
+  //     optional int32 foo = 1;
+  //   }
+  // }
+  //
+  // In this case,
+  // DescriptorPool::generated_pool()
+  //     ->FindMessageTypeByName("M2")
+  //     ->extension(0)
+  // will return "foo", even though "foo" is an extension of M1.
+  // To find all known extensions of a given message, instead use
+  // DescriptorPool::FindAllExtensions.
+  int extension_count() const;
+  // Get an extension by index, where 0 <= index < extension_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FieldDescriptor* extension(int index) const;
+
+  // Looks up a named extension (which extends some *other* message type)
+  // defined within this message type's scope.
+  const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
+
+  // Similar to FindFieldByLowercaseName(), but finds extensions defined within
+  // this message type's scope.
+  const FieldDescriptor* FindExtensionByLowercaseName(
+      ConstStringParam name) const;
+
+  // Similar to FindFieldByCamelcaseName(), but finds extensions defined within
+  // this message type's scope.
+  const FieldDescriptor* FindExtensionByCamelcaseName(
+      ConstStringParam name) const;
+
+  // Reserved fields -------------------------------------------------
+
+  // A range of reserved field numbers.
+  struct ReservedRange {
+    int start;  // inclusive
+    int end;    // exclusive
+  };
+
+  // The number of reserved ranges in this message type.
+  int reserved_range_count() const;
+  // Gets an reserved range by index, where 0 <= index <
+  // reserved_range_count(). These are returned in the order they were defined
+  // in the .proto file.
+  const ReservedRange* reserved_range(int index) const;
+
+  // Returns true if the number is in one of the reserved ranges.
+  bool IsReservedNumber(int number) const;
+
+  // Returns nullptr if no reserved range contains the given number.
+  const ReservedRange* FindReservedRangeContainingNumber(int number) const;
+
+  // The number of reserved field names in this message type.
+  int reserved_name_count() const;
+
+  // Gets a reserved name by index, where 0 <= index < reserved_name_count().
+  const std::string& reserved_name(int index) const;
+
+  // Returns true if the field name is reserved.
+  bool IsReservedName(ConstStringParam name) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this message declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+  // Maps --------------------------------------------------------------
+
+  // Returns the FieldDescriptor for the "key" field. If this isn't a map entry
+  // field, returns nullptr.
+  const FieldDescriptor* map_key() const;
+
+  // Returns the FieldDescriptor for the "value" field. If this isn't a map
+  // entry field, returns nullptr.
+  const FieldDescriptor* map_value() const;
+
+ private:
+  friend class Symbol;
+  typedef MessageOptions OptionsType;
+
+  // Allows tests to test CopyTo(proto, true).
+  friend class descriptor_unittest::DescriptorTest;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class io::Printer;
+  friend class compiler::cpp::Formatter;
+
+  // Fill the json_name field of FieldDescriptorProto.
+  void CopyJsonNameTo(DescriptorProto* proto) const;
+
+  // Internal version of DebugString; controls the level of indenting for
+  // correct depth. Takes |options| to control debug-string options, and
+  // |include_opening_clause| to indicate whether the "message ... " part of the
+  // clause has already been generated (this varies depending on context).
+  void DebugString(int depth, std::string* contents,
+                   const DebugStringOptions& options,
+                   bool include_opening_clause) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  // True if this is a placeholder for an unknown type.
+  bool is_placeholder_ : 1;
+  // True if this is a placeholder and the type name wasn't fully-qualified.
+  bool is_unqualified_placeholder_ : 1;
+  // Well known type.  Stored like this to conserve space.
+  uint8_t well_known_type_ : 5;
+
+  // This points to the last field _number_ that is part of the sequence
+  // starting at 1, where
+  //     `desc->field(i)->number() == i + 1`
+  // A value of `0` means no field matches. That is, there are no fields or the
+  // first field is not field `1`.
+  // Uses 16-bit to avoid extra padding. Unlikely to have more than 2^16
+  // sequentially numbered fields in a message.
+  uint16_t sequential_field_limit_;
+
+  int field_count_;
+
+  // all_names_ = [name, full_name]
+  const std::string* all_names_;
+  const FileDescriptor* file_;
+  const Descriptor* containing_type_;
+  const MessageOptions* options_;
+
+  // These arrays are separated from their sizes to minimize padding on 64-bit.
+  FieldDescriptor* fields_;
+  OneofDescriptor* oneof_decls_;
+  Descriptor* nested_types_;
+  EnumDescriptor* enum_types_;
+  ExtensionRange* extension_ranges_;
+  FieldDescriptor* extensions_;
+  ReservedRange* reserved_ranges_;
+  const std::string** reserved_names_;
+
+  int oneof_decl_count_;
+  int real_oneof_decl_count_;
+  int nested_type_count_;
+  int enum_type_count_;
+  int extension_range_count_;
+  int extension_count_;
+  int reserved_range_count_;
+  int reserved_name_count_;
+
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<Descriptor>() and AllocateArray<Descriptor>() in descriptor.cc
+  // and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  Descriptor() {}
+  friend class DescriptorBuilder;
+  friend class DescriptorPool;
+  friend class EnumDescriptor;
+  friend class FieldDescriptor;
+  friend class FileDescriptorTables;
+  friend class OneofDescriptor;
+  friend class MethodDescriptor;
+  friend class FileDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Descriptor);
+};
+
+PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(Descriptor, 136);
+
+// Describes a single field of a message.  To get the descriptor for a given
+// field, first get the Descriptor for the message in which it is defined,
+// then call Descriptor::FindFieldByName().  To get a FieldDescriptor for
+// an extension, do one of the following:
+// - Get the Descriptor or FileDescriptor for its containing scope, then
+//   call Descriptor::FindExtensionByName() or
+//   FileDescriptor::FindExtensionByName().
+// - Given a DescriptorPool, call DescriptorPool::FindExtensionByNumber() or
+//   DescriptorPool::FindExtensionByPrintableName().
+// Use DescriptorPool to construct your own descriptors.
+class PROTOBUF_EXPORT FieldDescriptor : private internal::SymbolBase {
+ public:
+  typedef FieldDescriptorProto Proto;
+
+  // Identifies a field type.  0 is reserved for errors.  The order is weird
+  // for historical reasons.  Types 12 and up are new in proto2.
+  enum Type {
+    TYPE_DOUBLE = 1,    // double, exactly eight bytes on the wire.
+    TYPE_FLOAT = 2,     // float, exactly four bytes on the wire.
+    TYPE_INT64 = 3,     // int64, varint on the wire.  Negative numbers
+                        // take 10 bytes.  Use TYPE_SINT64 if negative
+                        // values are likely.
+    TYPE_UINT64 = 4,    // uint64, varint on the wire.
+    TYPE_INT32 = 5,     // int32, varint on the wire.  Negative numbers
+                        // take 10 bytes.  Use TYPE_SINT32 if negative
+                        // values are likely.
+    TYPE_FIXED64 = 6,   // uint64, exactly eight bytes on the wire.
+    TYPE_FIXED32 = 7,   // uint32, exactly four bytes on the wire.
+    TYPE_BOOL = 8,      // bool, varint on the wire.
+    TYPE_STRING = 9,    // UTF-8 text.
+    TYPE_GROUP = 10,    // Tag-delimited message.  Deprecated.
+    TYPE_MESSAGE = 11,  // Length-delimited message.
+
+    TYPE_BYTES = 12,     // Arbitrary byte array.
+    TYPE_UINT32 = 13,    // uint32, varint on the wire
+    TYPE_ENUM = 14,      // Enum, varint on the wire
+    TYPE_SFIXED32 = 15,  // int32, exactly four bytes on the wire
+    TYPE_SFIXED64 = 16,  // int64, exactly eight bytes on the wire
+    TYPE_SINT32 = 17,    // int32, ZigZag-encoded varint on the wire
+    TYPE_SINT64 = 18,    // int64, ZigZag-encoded varint on the wire
+
+    MAX_TYPE = 18,  // Constant useful for defining lookup tables
+                    // indexed by Type.
+  };
+
+  // Specifies the C++ data type used to represent the field.  There is a
+  // fixed mapping from Type to CppType where each Type maps to exactly one
+  // CppType.  0 is reserved for errors.
+  enum CppType {
+    CPPTYPE_INT32 = 1,     // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32
+    CPPTYPE_INT64 = 2,     // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64
+    CPPTYPE_UINT32 = 3,    // TYPE_UINT32, TYPE_FIXED32
+    CPPTYPE_UINT64 = 4,    // TYPE_UINT64, TYPE_FIXED64
+    CPPTYPE_DOUBLE = 5,    // TYPE_DOUBLE
+    CPPTYPE_FLOAT = 6,     // TYPE_FLOAT
+    CPPTYPE_BOOL = 7,      // TYPE_BOOL
+    CPPTYPE_ENUM = 8,      // TYPE_ENUM
+    CPPTYPE_STRING = 9,    // TYPE_STRING, TYPE_BYTES
+    CPPTYPE_MESSAGE = 10,  // TYPE_MESSAGE, TYPE_GROUP
+
+    MAX_CPPTYPE = 10,  // Constant useful for defining lookup tables
+                       // indexed by CppType.
+  };
+
+  // Identifies whether the field is optional, required, or repeated.  0 is
+  // reserved for errors.
+  enum Label {
+    LABEL_OPTIONAL = 1,  // optional
+    LABEL_REQUIRED = 2,  // required
+    LABEL_REPEATED = 3,  // repeated
+
+    MAX_LABEL = 3,  // Constant useful for defining lookup tables
+                    // indexed by Label.
+  };
+
+  // Valid field numbers are positive integers up to kMaxNumber.
+  static const int kMaxNumber = (1 << 29) - 1;
+
+  // First field number reserved for the protocol buffer library implementation.
+  // Users may not declare fields that use reserved numbers.
+  static const int kFirstReservedNumber = 19000;
+  // Last field number reserved for the protocol buffer library implementation.
+  // Users may not declare fields that use reserved numbers.
+  static const int kLastReservedNumber = 19999;
+
+  const std::string& name() const;  // Name of this field within the message.
+  const std::string& full_name() const;  // Fully-qualified name of the field.
+  const std::string& json_name() const;  // JSON name of this field.
+  const FileDescriptor* file() const;  // File in which this field was defined.
+  bool is_extension() const;           // Is this an extension field?
+  int number() const;                  // Declared tag number.
+
+  // Same as name() except converted to lower-case.  This (and especially the
+  // FindFieldByLowercaseName() method) can be useful when parsing formats
+  // which prefer to use lowercase naming style.  (Although, technically
+  // field names should be lowercased anyway according to the protobuf style
+  // guide, so this only makes a difference when dealing with old .proto files
+  // which do not follow the guide.)
+  const std::string& lowercase_name() const;
+
+  // Same as name() except converted to camel-case.  In this conversion, any
+  // time an underscore appears in the name, it is removed and the next
+  // letter is capitalized.  Furthermore, the first letter of the name is
+  // lower-cased.  Examples:
+  //   FooBar -> fooBar
+  //   foo_bar -> fooBar
+  //   fooBar -> fooBar
+  // This (and especially the FindFieldByCamelcaseName() method) can be useful
+  // when parsing formats which prefer to use camel-case naming style.
+  const std::string& camelcase_name() const;
+
+  Type type() const;                  // Declared type of this field.
+  const char* type_name() const;      // Name of the declared type.
+  CppType cpp_type() const;           // C++ type of this field.
+  const char* cpp_type_name() const;  // Name of the C++ type.
+  Label label() const;                // optional/required/repeated
+
+  bool is_required() const;  // shorthand for label() == LABEL_REQUIRED
+  bool is_optional() const;  // shorthand for label() == LABEL_OPTIONAL
+  bool is_repeated() const;  // shorthand for label() == LABEL_REPEATED
+  bool is_packable() const;  // shorthand for is_repeated() &&
+                             //               IsTypePackable(type())
+  bool is_packed() const;    // shorthand for is_packable() &&
+                             //               options().packed()
+  bool is_map() const;       // shorthand for type() == TYPE_MESSAGE &&
+                             // message_type()->options().map_entry()
+
+  // Returns true if this field was syntactically written with "optional" in the
+  // .proto file. Excludes singular proto3 fields that do not have a label.
+  bool has_optional_keyword() const;
+
+  // Returns true if this field tracks presence, ie. does the field
+  // distinguish between "unset" and "present with default value."
+  // This includes required, optional, and oneof fields. It excludes maps,
+  // repeated fields, and singular proto3 fields without "optional".
+  //
+  // For fields where has_presence() == true, the return value of
+  // Reflection::HasField() is semantically meaningful.
+  bool has_presence() const;
+
+  // Index of this field within the message's field array, or the file or
+  // extension scope's extensions array.
+  int index() const;
+
+  // Does this field have an explicitly-declared default value?
+  bool has_default_value() const;
+
+  // Whether the user has specified the json_name field option in the .proto
+  // file.
+  bool has_json_name() const;
+
+  // Get the field default value if cpp_type() == CPPTYPE_INT32.  If no
+  // explicit default was defined, the default is 0.
+  int32_t default_value_int32_t() const;
+  int32_t default_value_int32() const { return default_value_int32_t(); }
+  // Get the field default value if cpp_type() == CPPTYPE_INT64.  If no
+  // explicit default was defined, the default is 0.
+  int64_t default_value_int64_t() const;
+  int64_t default_value_int64() const { return default_value_int64_t(); }
+  // Get the field default value if cpp_type() == CPPTYPE_UINT32.  If no
+  // explicit default was defined, the default is 0.
+  uint32_t default_value_uint32_t() const;
+  uint32_t default_value_uint32() const { return default_value_uint32_t(); }
+  // Get the field default value if cpp_type() == CPPTYPE_UINT64.  If no
+  // explicit default was defined, the default is 0.
+  uint64_t default_value_uint64_t() const;
+  uint64_t default_value_uint64() const { return default_value_uint64_t(); }
+  // Get the field default value if cpp_type() == CPPTYPE_FLOAT.  If no
+  // explicit default was defined, the default is 0.0.
+  float default_value_float() const;
+  // Get the field default value if cpp_type() == CPPTYPE_DOUBLE.  If no
+  // explicit default was defined, the default is 0.0.
+  double default_value_double() const;
+  // Get the field default value if cpp_type() == CPPTYPE_BOOL.  If no
+  // explicit default was defined, the default is false.
+  bool default_value_bool() const;
+  // Get the field default value if cpp_type() == CPPTYPE_ENUM.  If no
+  // explicit default was defined, the default is the first value defined
+  // in the enum type (all enum types are required to have at least one value).
+  // This never returns nullptr.
+  const EnumValueDescriptor* default_value_enum() const;
+  // Get the field default value if cpp_type() == CPPTYPE_STRING.  If no
+  // explicit default was defined, the default is the empty string.
+  const std::string& default_value_string() const;
+
+  // The Descriptor for the message of which this is a field.  For extensions,
+  // this is the extended type.  Never nullptr.
+  const Descriptor* containing_type() const;
+
+  // If the field is a member of a oneof, this is the one, otherwise this is
+  // nullptr.
+  const OneofDescriptor* containing_oneof() const;
+
+  // If the field is a member of a non-synthetic oneof, returns the descriptor
+  // for the oneof, otherwise returns nullptr.
+  const OneofDescriptor* real_containing_oneof() const;
+
+  // If the field is a member of a oneof, returns the index in that oneof.
+  int index_in_oneof() const;
+
+  // An extension may be declared within the scope of another message.  If this
+  // field is an extension (is_extension() is true), then extension_scope()
+  // returns that message, or nullptr if the extension was declared at global
+  // scope.  If this is not an extension, extension_scope() is undefined (may
+  // assert-fail).
+  const Descriptor* extension_scope() const;
+
+  // If type is TYPE_MESSAGE or TYPE_GROUP, returns a descriptor for the
+  // message or the group type.  Otherwise, returns null.
+  const Descriptor* message_type() const;
+  // If type is TYPE_ENUM, returns a descriptor for the enum.  Otherwise,
+  // returns null.
+  const EnumDescriptor* enum_type() const;
+
+  // Get the FieldOptions for this field.  This includes things listed in
+  // square brackets after the field definition.  E.g., the field:
+  //   optional string text = 1 [ctype=CORD];
+  // has the "ctype" option set.  Allowed options are defined by FieldOptions in
+  // descriptor.proto, and any available extensions of that message.
+  const FieldOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(FieldDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  std::string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Helper method to get the CppType for a particular Type.
+  static CppType TypeToCppType(Type type);
+
+  // Helper method to get the name of a Type.
+  static const char* TypeName(Type type);
+
+  // Helper method to get the name of a CppType.
+  static const char* CppTypeName(CppType cpp_type);
+
+  // Return true iff [packed = true] is valid for fields of this type.
+  static inline bool IsTypePackable(Type field_type);
+
+  // Returns full_name() except if the field is a MessageSet extension,
+  // in which case it returns the full_name() of the containing message type
+  // for backwards compatibility with proto1.
+  //
+  // A MessageSet extension is defined as an optional message extension
+  // whose containing type has the message_set_wire_format option set.
+  // This should be true of extensions of google.protobuf.bridge.MessageSet;
+  // by convention, such extensions are named "message_set_extension".
+  //
+  // The opposite operation (looking up an extension's FieldDescriptor given
+  // its printable name) can be accomplished with
+  //     message->file()->pool()->FindExtensionByPrintableName(message, name)
+  // where the extension extends "message".
+  const std::string& PrintableNameForExtension() const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this field declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  friend class Symbol;
+  typedef FieldOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class io::Printer;
+  friend class compiler::cpp::Formatter;
+  friend class Reflection;
+
+  // Fill the json_name field of FieldDescriptorProto.
+  void CopyJsonNameTo(FieldDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, std::string* contents,
+                   const DebugStringOptions& options) const;
+
+  // formats the default value appropriately and returns it as a string.
+  // Must have a default value to call this. If quote_string_type is true, then
+  // types of CPPTYPE_STRING whill be surrounded by quotes and CEscaped.
+  std::string DefaultValueAsString(bool quote_string_type) const;
+
+  // Helper function that returns the field type name for DebugString.
+  std::string FieldTypeNameDebugString() const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  // Returns true if this is a map message type.
+  bool is_map_message_type() const;
+
+  bool has_default_value_ : 1;
+  bool proto3_optional_ : 1;
+  // Whether the user has specified the json_name field option in the .proto
+  // file.
+  bool has_json_name_ : 1;
+  bool is_extension_ : 1;
+  bool is_oneof_ : 1;
+
+  // Actually a `Label` but stored as uint8_t to save space.
+  uint8_t label_ : 2;
+
+  // Actually a `Type`, but stored as uint8_t to save space.
+  mutable uint8_t type_;
+
+  // Logically:
+  //   all_names_ = [name, full_name, lower, camel, json]
+  // However:
+  //   duplicates will be omitted, so lower/camel/json might be in the same
+  //   position.
+  // We store the true offset for each name here, and the bit width must be
+  // large enough to account for the worst case where all names are present.
+  uint8_t lowercase_name_index_ : 2;
+  uint8_t camelcase_name_index_ : 2;
+  uint8_t json_name_index_ : 3;
+  // Sadly, `number_` located here to reduce padding. Unrelated to all_names_
+  // and its indices above.
+  int number_;
+  const std::string* all_names_;
+  const FileDescriptor* file_;
+
+  // The once_flag is followed by a NUL terminated string for the type name and
+  // enum default value (or empty string if no default enum).
+  internal::once_flag* type_once_;
+  static void TypeOnceInit(const FieldDescriptor* to_init);
+  void InternalTypeOnceInit() const;
+  const Descriptor* containing_type_;
+  union {
+    const OneofDescriptor* containing_oneof;
+    const Descriptor* extension_scope;
+  } scope_;
+  union {
+    mutable const Descriptor* message_type;
+    mutable const EnumDescriptor* enum_type;
+  } type_descriptor_;
+  const FieldOptions* options_;
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<FieldDescriptor>() and AllocateArray<FieldDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  union {
+    int32_t default_value_int32_t_;
+    int64_t default_value_int64_t_;
+    uint32_t default_value_uint32_t_;
+    uint64_t default_value_uint64_t_;
+    float default_value_float_;
+    double default_value_double_;
+    bool default_value_bool_;
+
+    mutable const EnumValueDescriptor* default_value_enum_;
+    const std::string* default_value_string_;
+    mutable std::atomic<const Message*> default_generated_instance_;
+  };
+
+  static const CppType kTypeToCppTypeMap[MAX_TYPE + 1];
+
+  static const char* const kTypeToName[MAX_TYPE + 1];
+
+  static const char* const kCppTypeToName[MAX_CPPTYPE + 1];
+
+  static const char* const kLabelToName[MAX_LABEL + 1];
+
+  // Must be constructed using DescriptorPool.
+  FieldDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class FileDescriptor;
+  friend class Descriptor;
+  friend class OneofDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldDescriptor);
+};
+
+PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(FieldDescriptor, 72);
+
+// Describes a oneof defined in a message type.
+class PROTOBUF_EXPORT OneofDescriptor : private internal::SymbolBase {
+ public:
+  typedef OneofDescriptorProto Proto;
+
+  const std::string& name() const;       // Name of this oneof.
+  const std::string& full_name() const;  // Fully-qualified name of the oneof.
+
+  // Index of this oneof within the message's oneof array.
+  int index() const;
+
+  // Returns whether this oneof was inserted by the compiler to wrap a proto3
+  // optional field. If this returns true, code generators should *not* emit it.
+  bool is_synthetic() const;
+
+  // The .proto file in which this oneof was defined.  Never nullptr.
+  const FileDescriptor* file() const;
+  // The Descriptor for the message containing this oneof.
+  const Descriptor* containing_type() const;
+
+  // The number of (non-extension) fields which are members of this oneof.
+  int field_count() const;
+  // Get a member of this oneof, in the order in which they were declared in the
+  // .proto file.  Does not include extensions.
+  const FieldDescriptor* field(int index) const;
+
+  const OneofOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(OneofDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  std::string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this oneof declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  friend class Symbol;
+  typedef OneofOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class io::Printer;
+  friend class compiler::cpp::Formatter;
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, std::string* contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  int field_count_;
+
+  // all_names_ = [name, full_name]
+  const std::string* all_names_;
+  const Descriptor* containing_type_;
+  const OneofOptions* options_;
+  const FieldDescriptor* fields_;
+
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<OneofDescriptor>() and AllocateArray<OneofDescriptor>()
+  // in descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  OneofDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class Descriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OneofDescriptor);
+};
+
+PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(OneofDescriptor, 40);
+
+// Describes an enum type defined in a .proto file.  To get the EnumDescriptor
+// for a generated enum type, call TypeName_descriptor().  Use DescriptorPool
+// to construct your own descriptors.
+class PROTOBUF_EXPORT EnumDescriptor : private internal::SymbolBase {
+ public:
+  typedef EnumDescriptorProto Proto;
+
+  // The name of this enum type in the containing scope.
+  const std::string& name() const;
+
+  // The fully-qualified name of the enum type, scope delimited by periods.
+  const std::string& full_name() const;
+
+  // Index of this enum within the file or containing message's enum array.
+  int index() const;
+
+  // The .proto file in which this enum type was defined.  Never nullptr.
+  const FileDescriptor* file() const;
+
+  // The number of values for this EnumDescriptor.  Guaranteed to be greater
+  // than zero.
+  int value_count() const;
+  // Gets a value by index, where 0 <= index < value_count().
+  // These are returned in the order they were defined in the .proto file.
+  const EnumValueDescriptor* value(int index) const;
+
+  // Looks up a value by name.  Returns nullptr if no such value exists.
+  const EnumValueDescriptor* FindValueByName(ConstStringParam name) const;
+  // Looks up a value by number.  Returns nullptr if no such value exists.  If
+  // multiple values have this number, the first one defined is returned.
+  const EnumValueDescriptor* FindValueByNumber(int number) const;
+
+  // If this enum type is nested in a message type, this is that message type.
+  // Otherwise, nullptr.
+  const Descriptor* containing_type() const;
+
+  // Get options for this enum type.  These are specified in the .proto file by
+  // placing lines like "option foo = 1234;" in the enum definition.  Allowed
+  // options are defined by EnumOptions in descriptor.proto, and any available
+  // extensions of that message.
+  const EnumOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(EnumDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  std::string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Returns true if this is a placeholder for an unknown enum. This will
+  // only be the case if this descriptor comes from a DescriptorPool
+  // with AllowUnknownDependencies() set.
+  bool is_placeholder() const;
+
+  // Reserved fields -------------------------------------------------
+
+  // A range of reserved field numbers.
+  struct ReservedRange {
+    int start;  // inclusive
+    int end;    // inclusive
+  };
+
+  // The number of reserved ranges in this message type.
+  int reserved_range_count() const;
+  // Gets an reserved range by index, where 0 <= index <
+  // reserved_range_count(). These are returned in the order they were defined
+  // in the .proto file.
+  const EnumDescriptor::ReservedRange* reserved_range(int index) const;
+
+  // Returns true if the number is in one of the reserved ranges.
+  bool IsReservedNumber(int number) const;
+
+  // Returns nullptr if no reserved range contains the given number.
+  const EnumDescriptor::ReservedRange* FindReservedRangeContainingNumber(
+      int number) const;
+
+  // The number of reserved field names in this message type.
+  int reserved_name_count() const;
+
+  // Gets a reserved name by index, where 0 <= index < reserved_name_count().
+  const std::string& reserved_name(int index) const;
+
+  // Returns true if the field name is reserved.
+  bool IsReservedName(ConstStringParam name) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this enum declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  friend class Symbol;
+  typedef EnumOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class io::Printer;
+  friend class compiler::cpp::Formatter;
+
+  // Allow access to FindValueByNumberCreatingIfUnknown.
+  friend class descriptor_unittest::DescriptorTest;
+
+  // Looks up a value by number.  If the value does not exist, dynamically
+  // creates a new EnumValueDescriptor for that value, assuming that it was
+  // unknown. If a new descriptor is created, this is done in a thread-safe way,
+  // and future calls will return the same value descriptor pointer.
+  //
+  // This is private but is used by Reflection (which is friended below) to
+  // return a valid EnumValueDescriptor from GetEnum() when this feature is
+  // enabled.
+  const EnumValueDescriptor* FindValueByNumberCreatingIfUnknown(
+      int number) const;
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, std::string* contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  // True if this is a placeholder for an unknown type.
+  bool is_placeholder_ : 1;
+  // True if this is a placeholder and the type name wasn't fully-qualified.
+  bool is_unqualified_placeholder_ : 1;
+
+  // This points to the last value _index_ that is part of the sequence starting
+  // with the first label, where
+  //   `enum->value(i)->number() == enum->value(0)->number() + i`
+  // We measure relative to the first label to adapt to enum labels starting at
+  // 0 or 1.
+  // Uses 16-bit to avoid extra padding. Unlikely to have more than 2^15
+  // sequentially numbered labels in an enum.
+  int16_t sequential_value_limit_;
+
+  int value_count_;
+
+  // all_names_ = [name, full_name]
+  const std::string* all_names_;
+  const FileDescriptor* file_;
+  const Descriptor* containing_type_;
+  const EnumOptions* options_;
+  EnumValueDescriptor* values_;
+
+  int reserved_range_count_;
+  int reserved_name_count_;
+  EnumDescriptor::ReservedRange* reserved_ranges_;
+  const std::string** reserved_names_;
+
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<EnumDescriptor>() and AllocateArray<EnumDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  EnumDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class Descriptor;
+  friend class FieldDescriptor;
+  friend class FileDescriptorTables;
+  friend class EnumValueDescriptor;
+  friend class FileDescriptor;
+  friend class DescriptorPool;
+  friend class Reflection;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumDescriptor);
+};
+
+PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(EnumDescriptor, 72);
+
+// Describes an individual enum constant of a particular type.  To get the
+// EnumValueDescriptor for a given enum value, first get the EnumDescriptor
+// for its type, then use EnumDescriptor::FindValueByName() or
+// EnumDescriptor::FindValueByNumber().  Use DescriptorPool to construct
+// your own descriptors.
+class PROTOBUF_EXPORT EnumValueDescriptor : private internal::SymbolBaseN<0>,
+                                            private internal::SymbolBaseN<1> {
+ public:
+  typedef EnumValueDescriptorProto Proto;
+
+  const std::string& name() const;  // Name of this enum constant.
+  int index() const;                // Index within the enums's Descriptor.
+  int number() const;               // Numeric value of this enum constant.
+
+  // The full_name of an enum value is a sibling symbol of the enum type.
+  // e.g. the full name of FieldDescriptorProto::TYPE_INT32 is actually
+  // "google.protobuf.FieldDescriptorProto.TYPE_INT32", NOT
+  // "google.protobuf.FieldDescriptorProto.Type.TYPE_INT32".  This is to conform
+  // with C++ scoping rules for enums.
+  const std::string& full_name() const;
+
+  // The .proto file in which this value was defined.  Never nullptr.
+  const FileDescriptor* file() const;
+  // The type of this value.  Never nullptr.
+  const EnumDescriptor* type() const;
+
+  // Get options for this enum value.  These are specified in the .proto file by
+  // adding text like "[foo = 1234]" after an enum value definition.  Allowed
+  // options are defined by EnumValueOptions in descriptor.proto, and any
+  // available extensions of that message.
+  const EnumValueOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(EnumValueDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  std::string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this enum value declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  friend class Symbol;
+  typedef EnumValueOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class io::Printer;
+  friend class compiler::cpp::Formatter;
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, std::string* contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  int number_;
+  // all_names_ = [name, full_name]
+  const std::string* all_names_;
+  const EnumDescriptor* type_;
+  const EnumValueOptions* options_;
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<EnumValueDescriptor>() and AllocateArray<EnumValueDescriptor>()
+  // in descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  EnumValueDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class EnumDescriptor;
+  friend class DescriptorPool;
+  friend class FileDescriptorTables;
+  friend class Reflection;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumValueDescriptor);
+};
+
+PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(EnumValueDescriptor, 32);
+
+// Describes an RPC service. Use DescriptorPool to construct your own
+// descriptors.
+class PROTOBUF_EXPORT ServiceDescriptor : private internal::SymbolBase {
+ public:
+  typedef ServiceDescriptorProto Proto;
+
+  // The name of the service, not including its containing scope.
+  const std::string& name() const;
+  // The fully-qualified name of the service, scope delimited by periods.
+  const std::string& full_name() const;
+  // Index of this service within the file's services array.
+  int index() const;
+
+  // The .proto file in which this service was defined.  Never nullptr.
+  const FileDescriptor* file() const;
+
+  // Get options for this service type.  These are specified in the .proto file
+  // by placing lines like "option foo = 1234;" in the service definition.
+  // Allowed options are defined by ServiceOptions in descriptor.proto, and any
+  // available extensions of that message.
+  const ServiceOptions& options() const;
+
+  // The number of methods this service defines.
+  int method_count() const;
+  // Gets a MethodDescriptor by index, where 0 <= index < method_count().
+  // These are returned in the order they were defined in the .proto file.
+  const MethodDescriptor* method(int index) const;
+
+  // Look up a MethodDescriptor by name.
+  const MethodDescriptor* FindMethodByName(ConstStringParam name) const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(ServiceDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  std::string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this service declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  friend class Symbol;
+  typedef ServiceOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class io::Printer;
+  friend class compiler::cpp::Formatter;
+
+  // See Descriptor::DebugString().
+  void DebugString(std::string* contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  // all_names_ = [name, full_name]
+  const std::string* all_names_;
+  const FileDescriptor* file_;
+  const ServiceOptions* options_;
+  MethodDescriptor* methods_;
+  int method_count_;
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<ServiceDescriptor>() and AllocateArray<ServiceDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  ServiceDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class FileDescriptor;
+  friend class MethodDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ServiceDescriptor);
+};
+
+PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(ServiceDescriptor, 48);
+
+// Describes an individual service method.  To obtain a MethodDescriptor given
+// a service, first get its ServiceDescriptor, then call
+// ServiceDescriptor::FindMethodByName().  Use DescriptorPool to construct your
+// own descriptors.
+class PROTOBUF_EXPORT MethodDescriptor : private internal::SymbolBase {
+ public:
+  typedef MethodDescriptorProto Proto;
+
+  // Name of this method, not including containing scope.
+  const std::string& name() const;
+  // The fully-qualified name of the method, scope delimited by periods.
+  const std::string& full_name() const;
+  // Index within the service's Descriptor.
+  int index() const;
+
+  // The .proto file in which this method was defined.  Never nullptr.
+  const FileDescriptor* file() const;
+  // Gets the service to which this method belongs.  Never nullptr.
+  const ServiceDescriptor* service() const;
+
+  // Gets the type of protocol message which this method accepts as input.
+  const Descriptor* input_type() const;
+  // Gets the type of protocol message which this message produces as output.
+  const Descriptor* output_type() const;
+
+  // Gets whether the client streams multiple requests.
+  bool client_streaming() const;
+  // Gets whether the server streams multiple responses.
+  bool server_streaming() const;
+
+  // Get options for this method.  These are specified in the .proto file by
+  // placing lines like "option foo = 1234;" in curly-braces after a method
+  // declaration.  Allowed options are defined by MethodOptions in
+  // descriptor.proto, and any available extensions of that message.
+  const MethodOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(MethodDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  std::string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this method declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  friend class Symbol;
+  typedef MethodOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class io::Printer;
+  friend class compiler::cpp::Formatter;
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, std::string* contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  bool client_streaming_;
+  bool server_streaming_;
+  // all_names_ = [name, full_name]
+  const std::string* all_names_;
+  const ServiceDescriptor* service_;
+  mutable internal::LazyDescriptor input_type_;
+  mutable internal::LazyDescriptor output_type_;
+  const MethodOptions* options_;
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<MethodDescriptor>() and AllocateArray<MethodDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  MethodDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class ServiceDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MethodDescriptor);
+};
+
+PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(MethodDescriptor, 64);
+
+// Describes a whole .proto file.  To get the FileDescriptor for a compiled-in
+// file, get the descriptor for something defined in that file and call
+// descriptor->file().  Use DescriptorPool to construct your own descriptors.
+class PROTOBUF_EXPORT FileDescriptor : private internal::SymbolBase {
+ public:
+  typedef FileDescriptorProto Proto;
+
+  // The filename, relative to the source tree.
+  // e.g. "foo/bar/baz.proto"
+  const std::string& name() const;
+
+  // The package, e.g. "google.protobuf.compiler".
+  const std::string& package() const;
+
+  // The DescriptorPool in which this FileDescriptor and all its contents were
+  // allocated.  Never nullptr.
+  const DescriptorPool* pool() const;
+
+  // The number of files imported by this one.
+  int dependency_count() const;
+  // Gets an imported file by index, where 0 <= index < dependency_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FileDescriptor* dependency(int index) const;
+
+  // The number of files public imported by this one.
+  // The public dependency list is a subset of the dependency list.
+  int public_dependency_count() const;
+  // Gets a public imported file by index, where 0 <= index <
+  // public_dependency_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FileDescriptor* public_dependency(int index) const;
+
+  // The number of files that are imported for weak fields.
+  // The weak dependency list is a subset of the dependency list.
+  int weak_dependency_count() const;
+  // Gets a weak imported file by index, where 0 <= index <
+  // weak_dependency_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FileDescriptor* weak_dependency(int index) const;
+
+  // Number of top-level message types defined in this file.  (This does not
+  // include nested types.)
+  int message_type_count() const;
+  // Gets a top-level message type, where 0 <= index < message_type_count().
+  // These are returned in the order they were defined in the .proto file.
+  const Descriptor* message_type(int index) const;
+
+  // Number of top-level enum types defined in this file.  (This does not
+  // include nested types.)
+  int enum_type_count() const;
+  // Gets a top-level enum type, where 0 <= index < enum_type_count().
+  // These are returned in the order they were defined in the .proto file.
+  const EnumDescriptor* enum_type(int index) const;
+
+  // Number of services defined in this file.
+  int service_count() const;
+  // Gets a service, where 0 <= index < service_count().
+  // These are returned in the order they were defined in the .proto file.
+  const ServiceDescriptor* service(int index) const;
+
+  // Number of extensions defined at file scope.  (This does not include
+  // extensions nested within message types.)
+  int extension_count() const;
+  // Gets an extension's descriptor, where 0 <= index < extension_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FieldDescriptor* extension(int index) const;
+
+  // Get options for this file.  These are specified in the .proto file by
+  // placing lines like "option foo = 1234;" at the top level, outside of any
+  // other definitions.  Allowed options are defined by FileOptions in
+  // descriptor.proto, and any available extensions of that message.
+  const FileOptions& options() const;
+
+  // Syntax of this file.
+  enum Syntax {
+    SYNTAX_UNKNOWN = 0,
+    SYNTAX_PROTO2 = 2,
+    SYNTAX_PROTO3 = 3,
+  };
+  Syntax syntax() const;
+  static const char* SyntaxName(Syntax syntax);
+
+  // Find a top-level message type by name (not full_name).  Returns nullptr if
+  // not found.
+  const Descriptor* FindMessageTypeByName(ConstStringParam name) const;
+  // Find a top-level enum type by name.  Returns nullptr if not found.
+  const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
+  // Find an enum value defined in any top-level enum by name.  Returns nullptr
+  // if not found.
+  const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
+  // Find a service definition by name.  Returns nullptr if not found.
+  const ServiceDescriptor* FindServiceByName(ConstStringParam name) const;
+  // Find a top-level extension definition by name.  Returns nullptr if not
+  // found.
+  const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
+  // Similar to FindExtensionByName(), but searches by lowercased-name.  See
+  // Descriptor::FindFieldByLowercaseName().
+  const FieldDescriptor* FindExtensionByLowercaseName(
+      ConstStringParam name) const;
+  // Similar to FindExtensionByName(), but searches by camelcased-name.  See
+  // Descriptor::FindFieldByCamelcaseName().
+  const FieldDescriptor* FindExtensionByCamelcaseName(
+      ConstStringParam name) const;
+
+  // See Descriptor::CopyTo().
+  // Notes:
+  // - This method does NOT copy source code information since it is relatively
+  //   large and rarely needed.  See CopySourceCodeInfoTo() below.
+  void CopyTo(FileDescriptorProto* proto) const;
+  // Write the source code information of this FileDescriptor into the given
+  // FileDescriptorProto.  See CopyTo() above.
+  void CopySourceCodeInfoTo(FileDescriptorProto* proto) const;
+  // Fill the json_name field of FieldDescriptorProto for all fields. Can only
+  // be called after CopyTo().
+  void CopyJsonNameTo(FileDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  std::string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Returns true if this is a placeholder for an unknown file. This will
+  // only be the case if this descriptor comes from a DescriptorPool
+  // with AllowUnknownDependencies() set.
+  bool is_placeholder() const;
+
+  // Updates |*out_location| to the source location of the complete extent of
+  // this file declaration (namely, the empty path).
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of the declaration or declaration-part denoted by |path|.
+  // Returns false and leaves |*out_location| unchanged iff location
+  // information was not available.  (See SourceCodeInfo for
+  // description of path encoding.)
+  bool GetSourceLocation(const std::vector<int>& path,
+                         SourceLocation* out_location) const;
+
+ private:
+  friend class Symbol;
+  typedef FileOptions OptionsType;
+
+  bool is_placeholder_;
+  // Indicates the FileDescriptor is completed building. Used to verify
+  // that type accessor functions that can possibly build a dependent file
+  // aren't called during the process of building the file.
+  bool finished_building_;
+  // Actually a `Syntax` but stored as uint8_t to save space.
+  uint8_t syntax_;
+  // This one is here to fill the padding.
+  int extension_count_;
+
+  const std::string* name_;
+  const std::string* package_;
+  const DescriptorPool* pool_;
+
+  // dependencies_once_ contain a once_flag followed by N NUL terminated
+  // strings. Dependencies that do not need to be loaded will be empty. ie just
+  // {'\0'}
+  internal::once_flag* dependencies_once_;
+  static void DependenciesOnceInit(const FileDescriptor* to_init);
+  void InternalDependenciesOnceInit() const;
+
+  // These are arranged to minimize padding on 64-bit.
+  int dependency_count_;
+  int public_dependency_count_;
+  int weak_dependency_count_;
+  int message_type_count_;
+  int enum_type_count_;
+  int service_count_;
+
+  mutable const FileDescriptor** dependencies_;
+  int* public_dependencies_;
+  int* weak_dependencies_;
+  Descriptor* message_types_;
+  EnumDescriptor* enum_types_;
+  ServiceDescriptor* services_;
+  FieldDescriptor* extensions_;
+  const FileOptions* options_;
+
+  const FileDescriptorTables* tables_;
+  const SourceCodeInfo* source_code_info_;
+
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<FileDescriptor>() and AllocateArray<FileDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  FileDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class DescriptorPool;
+  friend class Descriptor;
+  friend class FieldDescriptor;
+  friend class internal::LazyDescriptor;
+  friend class OneofDescriptor;
+  friend class EnumDescriptor;
+  friend class EnumValueDescriptor;
+  friend class MethodDescriptor;
+  friend class ServiceDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileDescriptor);
+};
+
+PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(FileDescriptor, 144);
+
+// ===================================================================
+
+// Used to construct descriptors.
+//
+// Normally you won't want to build your own descriptors.  Message classes
+// constructed by the protocol compiler will provide them for you.  However,
+// if you are implementing Message on your own, or if you are writing a
+// program which can operate on totally arbitrary types and needs to load
+// them from some sort of database, you might need to.
+//
+// Since Descriptors are composed of a whole lot of cross-linked bits of
+// data that would be a pain to put together manually, the
+// DescriptorPool class is provided to make the process easier.  It can
+// take a FileDescriptorProto (defined in descriptor.proto), validate it,
+// and convert it to a set of nicely cross-linked Descriptors.
+//
+// DescriptorPool also helps with memory management.  Descriptors are
+// composed of many objects containing static data and pointers to each
+// other.  In all likelihood, when it comes time to delete this data,
+// you'll want to delete it all at once.  In fact, it is not uncommon to
+// have a whole pool of descriptors all cross-linked with each other which
+// you wish to delete all at once.  This class represents such a pool, and
+// handles the memory management for you.
+//
+// You can also search for descriptors within a DescriptorPool by name, and
+// extensions by number.
+class PROTOBUF_EXPORT DescriptorPool {
+ public:
+  // Create a normal, empty DescriptorPool.
+  DescriptorPool();
+
+  // Constructs a DescriptorPool that, when it can't find something among the
+  // descriptors already in the pool, looks for it in the given
+  // DescriptorDatabase.
+  // Notes:
+  // - If a DescriptorPool is constructed this way, its BuildFile*() methods
+  //   must not be called (they will assert-fail).  The only way to populate
+  //   the pool with descriptors is to call the Find*By*() methods.
+  // - The Find*By*() methods may block the calling thread if the
+  //   DescriptorDatabase blocks.  This in turn means that parsing messages
+  //   may block if they need to look up extensions.
+  // - The Find*By*() methods will use mutexes for thread-safety, thus making
+  //   them slower even when they don't have to fall back to the database.
+  //   In fact, even the Find*By*() methods of descriptor objects owned by
+  //   this pool will be slower, since they will have to obtain locks too.
+  // - An ErrorCollector may optionally be given to collect validation errors
+  //   in files loaded from the database.  If not given, errors will be printed
+  //   to GOOGLE_LOG(ERROR).  Remember that files are built on-demand, so this
+  //   ErrorCollector may be called from any thread that calls one of the
+  //   Find*By*() methods.
+  // - The DescriptorDatabase must not be mutated during the lifetime of
+  //   the DescriptorPool. Even if the client takes care to avoid data races,
+  //   changes to the content of the DescriptorDatabase may not be reflected
+  //   in subsequent lookups in the DescriptorPool.
+  class ErrorCollector;
+  explicit DescriptorPool(DescriptorDatabase* fallback_database,
+                          ErrorCollector* error_collector = nullptr);
+
+  ~DescriptorPool();
+
+  // Get a pointer to the generated pool.  Generated protocol message classes
+  // which are compiled into the binary will allocate their descriptors in
+  // this pool.  Do not add your own descriptors to this pool.
+  static const DescriptorPool* generated_pool();
+
+
+  // Find a FileDescriptor in the pool by file name.  Returns nullptr if not
+  // found.
+  const FileDescriptor* FindFileByName(ConstStringParam name) const;
+
+  // Find the FileDescriptor in the pool which defines the given symbol.
+  // If any of the Find*ByName() methods below would succeed, then this is
+  // equivalent to calling that method and calling the result's file() method.
+  // Otherwise this returns nullptr.
+  const FileDescriptor* FindFileContainingSymbol(
+      ConstStringParam symbol_name) const;
+
+  // Looking up descriptors ------------------------------------------
+  // These find descriptors by fully-qualified name.  These will find both
+  // top-level descriptors and nested descriptors.  They return nullptr if not
+  // found.
+
+  const Descriptor* FindMessageTypeByName(ConstStringParam name) const;
+  const FieldDescriptor* FindFieldByName(ConstStringParam name) const;
+  const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
+  const OneofDescriptor* FindOneofByName(ConstStringParam name) const;
+  const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
+  const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
+  const ServiceDescriptor* FindServiceByName(ConstStringParam name) const;
+  const MethodDescriptor* FindMethodByName(ConstStringParam name) const;
+
+  // Finds an extension of the given type by number.  The extendee must be
+  // a member of this DescriptorPool or one of its underlays.
+  const FieldDescriptor* FindExtensionByNumber(const Descriptor* extendee,
+                                               int number) const;
+
+  // Finds an extension of the given type by its printable name.
+  // See comments above PrintableNameForExtension() for the definition of
+  // "printable name".  The extendee must be a member of this DescriptorPool
+  // or one of its underlays.  Returns nullptr if there is no known message
+  // extension with the given printable name.
+  const FieldDescriptor* FindExtensionByPrintableName(
+      const Descriptor* extendee, ConstStringParam printable_name) const;
+
+  // Finds extensions of extendee. The extensions will be appended to
+  // out in an undefined order. Only extensions defined directly in
+  // this DescriptorPool or one of its underlays are guaranteed to be
+  // found: extensions defined in the fallback database might not be found
+  // depending on the database implementation.
+  void FindAllExtensions(const Descriptor* extendee,
+                         std::vector<const FieldDescriptor*>* out) const;
+
+  // Building descriptors --------------------------------------------
+
+  // When converting a FileDescriptorProto to a FileDescriptor, various
+  // errors might be detected in the input.  The caller may handle these
+  // programmatically by implementing an ErrorCollector.
+  class PROTOBUF_EXPORT ErrorCollector {
+   public:
+    inline ErrorCollector() {}
+    virtual ~ErrorCollector();
+
+    // These constants specify what exact part of the construct is broken.
+    // This is useful e.g. for mapping the error back to an exact location
+    // in a .proto file.
+    enum ErrorLocation {
+      NAME,           // the symbol name, or the package name for files
+      NUMBER,         // field or extension range number
+      TYPE,           // field type
+      EXTENDEE,       // field extendee
+      DEFAULT_VALUE,  // field default value
+      INPUT_TYPE,     // method input type
+      OUTPUT_TYPE,    // method output type
+      OPTION_NAME,    // name in assignment
+      OPTION_VALUE,   // value in option assignment
+      IMPORT,         // import error
+      OTHER           // some other problem
+    };
+
+    // Reports an error in the FileDescriptorProto. Use this function if the
+    // problem occurred should interrupt building the FileDescriptorProto.
+    virtual void AddError(
+        const std::string& filename,  // File name in which the error occurred.
+        const std::string& element_name,  // Full name of the erroneous element.
+        const Message* descriptor,  // Descriptor of the erroneous element.
+        ErrorLocation location,     // One of the location constants, above.
+        const std::string& message  // Human-readable error message.
+        ) = 0;
+
+    // Reports a warning in the FileDescriptorProto. Use this function if the
+    // problem occurred should NOT interrupt building the FileDescriptorProto.
+    virtual void AddWarning(
+        const std::string& /*filename*/,      // File name in which the error
+                                              // occurred.
+        const std::string& /*element_name*/,  // Full name of the erroneous
+                                              // element.
+        const Message* /*descriptor*/,  // Descriptor of the erroneous element.
+        ErrorLocation /*location*/,     // One of the location constants, above.
+        const std::string& /*message*/  // Human-readable error message.
+    ) {}
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
+  };
+
+  // Convert the FileDescriptorProto to real descriptors and place them in
+  // this DescriptorPool.  All dependencies of the file must already be in
+  // the pool.  Returns the resulting FileDescriptor, or nullptr if there were
+  // problems with the input (e.g. the message was invalid, or dependencies
+  // were missing).  Details about the errors are written to GOOGLE_LOG(ERROR).
+  const FileDescriptor* BuildFile(const FileDescriptorProto& proto);
+
+  // Same as BuildFile() except errors are sent to the given ErrorCollector.
+  const FileDescriptor* BuildFileCollectingErrors(
+      const FileDescriptorProto& proto, ErrorCollector* error_collector);
+
+  // By default, it is an error if a FileDescriptorProto contains references
+  // to types or other files that are not found in the DescriptorPool (or its
+  // backing DescriptorDatabase, if any).  If you call
+  // AllowUnknownDependencies(), however, then unknown types and files
+  // will be replaced by placeholder descriptors (which can be identified by
+  // the is_placeholder() method).  This can allow you to
+  // perform some useful operations with a .proto file even if you do not
+  // have access to other .proto files on which it depends.  However, some
+  // heuristics must be used to fill in the gaps in information, and these
+  // can lead to descriptors which are inaccurate.  For example, the
+  // DescriptorPool may be forced to guess whether an unknown type is a message
+  // or an enum, as well as what package it resides in.  Furthermore,
+  // placeholder types will not be discoverable via FindMessageTypeByName()
+  // and similar methods, which could confuse some descriptor-based algorithms.
+  // Generally, the results of this option should be handled with extreme care.
+  void AllowUnknownDependencies() { allow_unknown_ = true; }
+
+  // By default, weak imports are allowed to be missing, in which case we will
+  // use a placeholder for the dependency and convert the field to be an Empty
+  // message field. If you call EnforceWeakDependencies(true), however, the
+  // DescriptorPool will report a import not found error.
+  void EnforceWeakDependencies(bool enforce) { enforce_weak_ = enforce; }
+
+  // Internal stuff --------------------------------------------------
+  // These methods MUST NOT be called from outside the proto2 library.
+  // These methods may contain hidden pitfalls and may be removed in a
+  // future library version.
+
+  // Create a DescriptorPool which is overlaid on top of some other pool.
+  // If you search for a descriptor in the overlay and it is not found, the
+  // underlay will be searched as a backup.  If the underlay has its own
+  // underlay, that will be searched next, and so on.  This also means that
+  // files built in the overlay will be cross-linked with the underlay's
+  // descriptors if necessary.  The underlay remains property of the caller;
+  // it must remain valid for the lifetime of the newly-constructed pool.
+  //
+  // Example:  Say you want to parse a .proto file at runtime in order to use
+  // its type with a DynamicMessage.  Say this .proto file has dependencies,
+  // but you know that all the dependencies will be things that are already
+  // compiled into the binary.  For ease of use, you'd like to load the types
+  // right out of generated_pool() rather than have to parse redundant copies
+  // of all these .protos and runtime.  But, you don't want to add the parsed
+  // types directly into generated_pool(): this is not allowed, and would be
+  // bad design anyway.  So, instead, you could use generated_pool() as an
+  // underlay for a new DescriptorPool in which you add only the new file.
+  //
+  // WARNING:  Use of underlays can lead to many subtle gotchas.  Instead,
+  //   try to formulate what you want to do in terms of DescriptorDatabases.
+  explicit DescriptorPool(const DescriptorPool* underlay);
+
+  // Called by generated classes at init time to add their descriptors to
+  // generated_pool.  Do NOT call this in your own code!  filename must be a
+  // permanent string (e.g. a string literal).
+  static void InternalAddGeneratedFile(const void* encoded_file_descriptor,
+                                       int size);
+
+  // Disallow [enforce_utf8 = false] in .proto files.
+  void DisallowEnforceUtf8() { disallow_enforce_utf8_ = true; }
+
+
+  // For internal use only:  Gets a non-const pointer to the generated pool.
+  // This is called at static-initialization time only, so thread-safety is
+  // not a concern.  If both an underlay and a fallback database are present,
+  // the underlay takes precedence.
+  static DescriptorPool* internal_generated_pool();
+
+  // For internal use only:  Gets a non-const pointer to the generated
+  // descriptor database.
+  // Only used for testing.
+  static DescriptorDatabase* internal_generated_database();
+
+  // For internal use only:  Changes the behavior of BuildFile() such that it
+  // allows the file to make reference to message types declared in other files
+  // which it did not officially declare as dependencies.
+  void InternalDontEnforceDependencies();
+
+  // For internal use only: Enables lazy building of dependencies of a file.
+  // Delay the building of dependencies of a file descriptor until absolutely
+  // necessary, like when message_type() is called on a field that is defined
+  // in that dependency's file. This will cause functional issues if a proto
+  // or one of its dependencies has errors. Should only be enabled for the
+  // generated_pool_ (because no descriptor build errors are guaranteed by
+  // the compilation generation process), testing, or if a lack of descriptor
+  // build errors can be guaranteed for a pool.
+  void InternalSetLazilyBuildDependencies() {
+    lazily_build_dependencies_ = true;
+    // This needs to be set when lazily building dependencies, as it breaks
+    // dependency checking.
+    InternalDontEnforceDependencies();
+  }
+
+  // For internal use only.
+  void internal_set_underlay(const DescriptorPool* underlay) {
+    underlay_ = underlay;
+  }
+
+  // For internal (unit test) use only:  Returns true if a FileDescriptor has
+  // been constructed for the given file, false otherwise.  Useful for testing
+  // lazy descriptor initialization behavior.
+  bool InternalIsFileLoaded(ConstStringParam filename) const;
+
+  // Add a file to unused_import_track_files_. DescriptorBuilder will log
+  // warnings or errors for those files if there is any unused import.
+  void AddUnusedImportTrackFile(ConstStringParam file_name,
+                                bool is_error = false);
+  void ClearUnusedImportTrackFiles();
+
+ private:
+  friend class Descriptor;
+  friend class internal::LazyDescriptor;
+  friend class FieldDescriptor;
+  friend class EnumDescriptor;
+  friend class ServiceDescriptor;
+  friend class MethodDescriptor;
+  friend class FileDescriptor;
+  friend class DescriptorBuilder;
+  friend class FileDescriptorTables;
+
+  // Return true if the given name is a sub-symbol of any non-package
+  // descriptor that already exists in the descriptor pool.  (The full
+  // definition of such types is already known.)
+  bool IsSubSymbolOfBuiltType(StringPiece name) const;
+
+  // Tries to find something in the fallback database and link in the
+  // corresponding proto file.  Returns true if successful, in which case
+  // the caller should search for the thing again.  These are declared
+  // const because they are called by (semantically) const methods.
+  bool TryFindFileInFallbackDatabase(StringPiece name) const;
+  bool TryFindSymbolInFallbackDatabase(StringPiece name) const;
+  bool TryFindExtensionInFallbackDatabase(const Descriptor* containing_type,
+                                          int field_number) const;
+
+  // This internal find extension method only check with its table and underlay
+  // descriptor_pool's table. It does not check with fallback DB and no
+  // additional proto file will be build in this method.
+  const FieldDescriptor* InternalFindExtensionByNumberNoLock(
+      const Descriptor* extendee, int number) const;
+
+  // Like BuildFile() but called internally when the file has been loaded from
+  // fallback_database_.  Declared const because it is called by (semantically)
+  // const methods.
+  const FileDescriptor* BuildFileFromDatabase(
+      const FileDescriptorProto& proto) const;
+
+  // Helper for when lazily_build_dependencies_ is set, can look up a symbol
+  // after the file's descriptor is built, and can build the file where that
+  // symbol is defined if necessary. Will create a placeholder if the type
+  // doesn't exist in the fallback database, or the file doesn't build
+  // successfully.
+  Symbol CrossLinkOnDemandHelper(StringPiece name,
+                                 bool expecting_enum) const;
+
+  // Create a placeholder FileDescriptor of the specified name
+  FileDescriptor* NewPlaceholderFile(StringPiece name) const;
+  FileDescriptor* NewPlaceholderFileWithMutexHeld(
+      StringPiece name, internal::FlatAllocator& alloc) const;
+
+  enum PlaceholderType {
+    PLACEHOLDER_MESSAGE,
+    PLACEHOLDER_ENUM,
+    PLACEHOLDER_EXTENDABLE_MESSAGE
+  };
+  // Create a placeholder Descriptor of the specified name
+  Symbol NewPlaceholder(StringPiece name,
+                        PlaceholderType placeholder_type) const;
+  Symbol NewPlaceholderWithMutexHeld(StringPiece name,
+                                     PlaceholderType placeholder_type) const;
+
+  // If fallback_database_ is nullptr, this is nullptr.  Otherwise, this is a
+  // mutex which must be locked while accessing tables_.
+  internal::WrappedMutex* mutex_;
+
+  // See constructor.
+  DescriptorDatabase* fallback_database_;
+  ErrorCollector* default_error_collector_;
+  const DescriptorPool* underlay_;
+
+  // This class contains a lot of hash maps with complicated types that
+  // we'd like to keep out of the header.
+  class Tables;
+  std::unique_ptr<Tables> tables_;
+
+  bool enforce_dependencies_;
+  bool lazily_build_dependencies_;
+  bool allow_unknown_;
+  bool enforce_weak_;
+  bool disallow_enforce_utf8_;
+
+  // Set of files to track for unused imports. The bool value when true means
+  // unused imports are treated as errors (and as warnings when false).
+  std::map<std::string, bool> unused_import_track_files_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPool);
+};
+
+
+// inline methods ====================================================
+
+// These macros makes this repetitive code more readable.
+#define PROTOBUF_DEFINE_ACCESSOR(CLASS, FIELD, TYPE) \
+  inline TYPE CLASS::FIELD() const { return FIELD##_; }
+
+// Strings fields are stored as pointers but returned as const references.
+#define PROTOBUF_DEFINE_STRING_ACCESSOR(CLASS, FIELD) \
+  inline const std::string& CLASS::FIELD() const { return *FIELD##_; }
+
+// Name and full name are stored in a single array to save space.
+#define PROTOBUF_DEFINE_NAME_ACCESSOR(CLASS)                              \
+  inline const std::string& CLASS::name() const { return all_names_[0]; } \
+  inline const std::string& CLASS::full_name() const { return all_names_[1]; }
+
+// Arrays take an index parameter, obviously.
+#define PROTOBUF_DEFINE_ARRAY_ACCESSOR(CLASS, FIELD, TYPE) \
+  inline TYPE CLASS::FIELD(int index) const { return FIELD##s_ + index; }
+
+#define PROTOBUF_DEFINE_OPTIONS_ACCESSOR(CLASS, TYPE) \
+  inline const TYPE& CLASS::options() const { return *options_; }
+
+PROTOBUF_DEFINE_NAME_ACCESSOR(Descriptor)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, containing_type, const Descriptor*)
+
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, field_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, oneof_decl_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, real_oneof_decl_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, nested_type_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, enum_type_count, int)
+
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, field, const FieldDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, oneof_decl, const OneofDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, nested_type, const Descriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, enum_type, const EnumDescriptor*)
+
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_range_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension_range,
+                               const Descriptor::ExtensionRange*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension, const FieldDescriptor*)
+
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_range_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, reserved_range,
+                               const Descriptor::ReservedRange*)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_name_count, int)
+
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(Descriptor, MessageOptions)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, is_placeholder, bool)
+
+PROTOBUF_DEFINE_NAME_ACCESSOR(FieldDescriptor)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, file, const FileDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, number, int)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, is_extension, bool)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, containing_type, const Descriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FieldDescriptor, FieldOptions)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_default_value, bool)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_json_name, bool)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32_t, int32_t)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64_t, int64_t)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint32_t, uint32_t)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint64_t, uint64_t)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float, float)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_double, double)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool, bool)
+PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, default_value_string)
+
+PROTOBUF_DEFINE_NAME_ACCESSOR(OneofDescriptor)
+PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, containing_type, const Descriptor*)
+PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, field_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(OneofDescriptor, field, const FieldDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(OneofDescriptor, OneofOptions)
+
+PROTOBUF_DEFINE_NAME_ACCESSOR(EnumDescriptor)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, file, const FileDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, containing_type, const Descriptor*)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, value_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, value,
+                               const EnumValueDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumDescriptor, EnumOptions)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, is_placeholder, bool)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_range_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, reserved_range,
+                               const EnumDescriptor::ReservedRange*)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_name_count, int)
+
+PROTOBUF_DEFINE_NAME_ACCESSOR(EnumValueDescriptor)
+PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, number, int)
+PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, type, const EnumDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumValueDescriptor, EnumValueOptions)
+
+PROTOBUF_DEFINE_NAME_ACCESSOR(ServiceDescriptor)
+PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, file, const FileDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, method_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(ServiceDescriptor, method,
+                               const MethodDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(ServiceDescriptor, ServiceOptions)
+
+PROTOBUF_DEFINE_NAME_ACCESSOR(MethodDescriptor)
+PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, service, const ServiceDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(MethodDescriptor, MethodOptions)
+PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, client_streaming, bool)
+PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, server_streaming, bool)
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, package)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, pool, const DescriptorPool*)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, dependency_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, public_dependency_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, weak_dependency_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, message_type_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, enum_type_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, service_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, extension_count, int)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FileDescriptor, FileOptions)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, is_placeholder, bool)
+
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, message_type, const Descriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, enum_type, const EnumDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, service,
+                               const ServiceDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, extension,
+                               const FieldDescriptor*)
+
+#undef PROTOBUF_DEFINE_ACCESSOR
+#undef PROTOBUF_DEFINE_STRING_ACCESSOR
+#undef PROTOBUF_DEFINE_ARRAY_ACCESSOR
+
+// A few accessors differ from the macros...
+
+inline Descriptor::WellKnownType Descriptor::well_known_type() const {
+  return static_cast<Descriptor::WellKnownType>(well_known_type_);
+}
+
+inline bool Descriptor::IsExtensionNumber(int number) const {
+  return FindExtensionRangeContainingNumber(number) != nullptr;
+}
+
+inline bool Descriptor::IsReservedNumber(int number) const {
+  return FindReservedRangeContainingNumber(number) != nullptr;
+}
+
+inline bool Descriptor::IsReservedName(ConstStringParam name) const {
+  for (int i = 0; i < reserved_name_count(); i++) {
+    if (name == static_cast<ConstStringParam>(reserved_name(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
+// an array of pointers rather than the usual array of objects.
+inline const std::string& Descriptor::reserved_name(int index) const {
+  return *reserved_names_[index];
+}
+
+inline bool EnumDescriptor::IsReservedNumber(int number) const {
+  return FindReservedRangeContainingNumber(number) != nullptr;
+}
+
+inline bool EnumDescriptor::IsReservedName(ConstStringParam name) const {
+  for (int i = 0; i < reserved_name_count(); i++) {
+    if (name == static_cast<ConstStringParam>(reserved_name(i))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
+// an array of pointers rather than the usual array of objects.
+inline const std::string& EnumDescriptor::reserved_name(int index) const {
+  return *reserved_names_[index];
+}
+
+inline const std::string& FieldDescriptor::lowercase_name() const {
+  return all_names_[lowercase_name_index_];
+}
+
+inline const std::string& FieldDescriptor::camelcase_name() const {
+  return all_names_[camelcase_name_index_];
+}
+
+inline const std::string& FieldDescriptor::json_name() const {
+  return all_names_[json_name_index_];
+}
+
+inline const OneofDescriptor* FieldDescriptor::containing_oneof() const {
+  return is_oneof_ ? scope_.containing_oneof : nullptr;
+}
+
+inline int FieldDescriptor::index_in_oneof() const {
+  GOOGLE_DCHECK(is_oneof_);
+  return static_cast<int>(this - scope_.containing_oneof->field(0));
+}
+
+inline const Descriptor* FieldDescriptor::extension_scope() const {
+  GOOGLE_CHECK(is_extension_);
+  return scope_.extension_scope;
+}
+
+inline FieldDescriptor::Label FieldDescriptor::label() const {
+  return static_cast<Label>(label_);
+}
+
+inline FieldDescriptor::Type FieldDescriptor::type() const {
+  if (type_once_) {
+    internal::call_once(*type_once_, &FieldDescriptor::TypeOnceInit, this);
+  }
+  return static_cast<Type>(type_);
+}
+
+inline bool FieldDescriptor::is_required() const {
+  return label() == LABEL_REQUIRED;
+}
+
+inline bool FieldDescriptor::is_optional() const {
+  return label() == LABEL_OPTIONAL;
+}
+
+inline bool FieldDescriptor::is_repeated() const {
+  return label() == LABEL_REPEATED;
+}
+
+inline bool FieldDescriptor::is_packable() const {
+  return is_repeated() && IsTypePackable(type());
+}
+
+inline bool FieldDescriptor::is_map() const {
+  return type() == TYPE_MESSAGE && is_map_message_type();
+}
+
+inline bool FieldDescriptor::has_optional_keyword() const {
+  return proto3_optional_ ||
+         (file()->syntax() == FileDescriptor::SYNTAX_PROTO2 && is_optional() &&
+          !containing_oneof());
+}
+
+inline const OneofDescriptor* FieldDescriptor::real_containing_oneof() const {
+  auto* oneof = containing_oneof();
+  return oneof && !oneof->is_synthetic() ? oneof : nullptr;
+}
+
+inline bool FieldDescriptor::has_presence() const {
+  if (is_repeated()) return false;
+  return cpp_type() == CPPTYPE_MESSAGE || containing_oneof() ||
+         file()->syntax() == FileDescriptor::SYNTAX_PROTO2;
+}
+
+// To save space, index() is computed by looking at the descriptor's position
+// in the parent's array of children.
+inline int FieldDescriptor::index() const {
+  if (!is_extension_) {
+    return static_cast<int>(this - containing_type()->fields_);
+  } else if (extension_scope() != nullptr) {
+    return static_cast<int>(this - extension_scope()->extensions_);
+  } else {
+    return static_cast<int>(this - file_->extensions_);
+  }
+}
+
+inline int Descriptor::index() const {
+  if (containing_type_ == nullptr) {
+    return static_cast<int>(this - file_->message_types_);
+  } else {
+    return static_cast<int>(this - containing_type_->nested_types_);
+  }
+}
+
+inline const FileDescriptor* OneofDescriptor::file() const {
+  return containing_type()->file();
+}
+
+inline int OneofDescriptor::index() const {
+  return static_cast<int>(this - containing_type_->oneof_decls_);
+}
+
+inline bool OneofDescriptor::is_synthetic() const {
+  return field_count() == 1 && field(0)->proto3_optional_;
+}
+
+inline int EnumDescriptor::index() const {
+  if (containing_type_ == nullptr) {
+    return static_cast<int>(this - file_->enum_types_);
+  } else {
+    return static_cast<int>(this - containing_type_->enum_types_);
+  }
+}
+
+inline const FileDescriptor* EnumValueDescriptor::file() const {
+  return type()->file();
+}
+
+inline int EnumValueDescriptor::index() const {
+  return static_cast<int>(this - type_->values_);
+}
+
+inline int ServiceDescriptor::index() const {
+  return static_cast<int>(this - file_->services_);
+}
+
+inline const FileDescriptor* MethodDescriptor::file() const {
+  return service()->file();
+}
+
+inline int MethodDescriptor::index() const {
+  return static_cast<int>(this - service_->methods_);
+}
+
+inline const char* FieldDescriptor::type_name() const {
+  return kTypeToName[type()];
+}
+
+inline FieldDescriptor::CppType FieldDescriptor::cpp_type() const {
+  return kTypeToCppTypeMap[type()];
+}
+
+inline const char* FieldDescriptor::cpp_type_name() const {
+  return kCppTypeToName[kTypeToCppTypeMap[type()]];
+}
+
+inline FieldDescriptor::CppType FieldDescriptor::TypeToCppType(Type type) {
+  return kTypeToCppTypeMap[type];
+}
+
+inline const char* FieldDescriptor::TypeName(Type type) {
+  return kTypeToName[type];
+}
+
+inline const char* FieldDescriptor::CppTypeName(CppType cpp_type) {
+  return kCppTypeToName[cpp_type];
+}
+
+inline bool FieldDescriptor::IsTypePackable(Type field_type) {
+  return (field_type != FieldDescriptor::TYPE_STRING &&
+          field_type != FieldDescriptor::TYPE_GROUP &&
+          field_type != FieldDescriptor::TYPE_MESSAGE &&
+          field_type != FieldDescriptor::TYPE_BYTES);
+}
+
+inline const FileDescriptor* FileDescriptor::public_dependency(
+    int index) const {
+  return dependency(public_dependencies_[index]);
+}
+
+inline const FileDescriptor* FileDescriptor::weak_dependency(int index) const {
+  return dependency(weak_dependencies_[index]);
+}
+
+inline FileDescriptor::Syntax FileDescriptor::syntax() const {
+  return static_cast<Syntax>(syntax_);
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+#undef PROTOBUF_INTERNAL_CHECK_CLASS_SIZE
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_DESCRIPTOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/descriptor.pb.h b/CAPI/cpp/grpc/include/google/protobuf/descriptor.pb.h
new file mode 100644
index 0000000..2d9c790
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/descriptor.pb.h
@@ -0,0 +1,14821 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/descriptor.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fdescriptor_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fdescriptor_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fdescriptor_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fdescriptor_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fdescriptor_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class DescriptorProto;
+struct DescriptorProtoDefaultTypeInternal;
+PROTOBUF_EXPORT extern DescriptorProtoDefaultTypeInternal _DescriptorProto_default_instance_;
+class DescriptorProto_ExtensionRange;
+struct DescriptorProto_ExtensionRangeDefaultTypeInternal;
+PROTOBUF_EXPORT extern DescriptorProto_ExtensionRangeDefaultTypeInternal _DescriptorProto_ExtensionRange_default_instance_;
+class DescriptorProto_ReservedRange;
+struct DescriptorProto_ReservedRangeDefaultTypeInternal;
+PROTOBUF_EXPORT extern DescriptorProto_ReservedRangeDefaultTypeInternal _DescriptorProto_ReservedRange_default_instance_;
+class EnumDescriptorProto;
+struct EnumDescriptorProtoDefaultTypeInternal;
+PROTOBUF_EXPORT extern EnumDescriptorProtoDefaultTypeInternal _EnumDescriptorProto_default_instance_;
+class EnumDescriptorProto_EnumReservedRange;
+struct EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal;
+PROTOBUF_EXPORT extern EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal _EnumDescriptorProto_EnumReservedRange_default_instance_;
+class EnumOptions;
+struct EnumOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern EnumOptionsDefaultTypeInternal _EnumOptions_default_instance_;
+class EnumValueDescriptorProto;
+struct EnumValueDescriptorProtoDefaultTypeInternal;
+PROTOBUF_EXPORT extern EnumValueDescriptorProtoDefaultTypeInternal _EnumValueDescriptorProto_default_instance_;
+class EnumValueOptions;
+struct EnumValueOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern EnumValueOptionsDefaultTypeInternal _EnumValueOptions_default_instance_;
+class ExtensionRangeOptions;
+struct ExtensionRangeOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern ExtensionRangeOptionsDefaultTypeInternal _ExtensionRangeOptions_default_instance_;
+class FieldDescriptorProto;
+struct FieldDescriptorProtoDefaultTypeInternal;
+PROTOBUF_EXPORT extern FieldDescriptorProtoDefaultTypeInternal _FieldDescriptorProto_default_instance_;
+class FieldOptions;
+struct FieldOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern FieldOptionsDefaultTypeInternal _FieldOptions_default_instance_;
+class FileDescriptorProto;
+struct FileDescriptorProtoDefaultTypeInternal;
+PROTOBUF_EXPORT extern FileDescriptorProtoDefaultTypeInternal _FileDescriptorProto_default_instance_;
+class FileDescriptorSet;
+struct FileDescriptorSetDefaultTypeInternal;
+PROTOBUF_EXPORT extern FileDescriptorSetDefaultTypeInternal _FileDescriptorSet_default_instance_;
+class FileOptions;
+struct FileOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern FileOptionsDefaultTypeInternal _FileOptions_default_instance_;
+class GeneratedCodeInfo;
+struct GeneratedCodeInfoDefaultTypeInternal;
+PROTOBUF_EXPORT extern GeneratedCodeInfoDefaultTypeInternal _GeneratedCodeInfo_default_instance_;
+class GeneratedCodeInfo_Annotation;
+struct GeneratedCodeInfo_AnnotationDefaultTypeInternal;
+PROTOBUF_EXPORT extern GeneratedCodeInfo_AnnotationDefaultTypeInternal _GeneratedCodeInfo_Annotation_default_instance_;
+class MessageOptions;
+struct MessageOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern MessageOptionsDefaultTypeInternal _MessageOptions_default_instance_;
+class MethodDescriptorProto;
+struct MethodDescriptorProtoDefaultTypeInternal;
+PROTOBUF_EXPORT extern MethodDescriptorProtoDefaultTypeInternal _MethodDescriptorProto_default_instance_;
+class MethodOptions;
+struct MethodOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern MethodOptionsDefaultTypeInternal _MethodOptions_default_instance_;
+class OneofDescriptorProto;
+struct OneofDescriptorProtoDefaultTypeInternal;
+PROTOBUF_EXPORT extern OneofDescriptorProtoDefaultTypeInternal _OneofDescriptorProto_default_instance_;
+class OneofOptions;
+struct OneofOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern OneofOptionsDefaultTypeInternal _OneofOptions_default_instance_;
+class ServiceDescriptorProto;
+struct ServiceDescriptorProtoDefaultTypeInternal;
+PROTOBUF_EXPORT extern ServiceDescriptorProtoDefaultTypeInternal _ServiceDescriptorProto_default_instance_;
+class ServiceOptions;
+struct ServiceOptionsDefaultTypeInternal;
+PROTOBUF_EXPORT extern ServiceOptionsDefaultTypeInternal _ServiceOptions_default_instance_;
+class SourceCodeInfo;
+struct SourceCodeInfoDefaultTypeInternal;
+PROTOBUF_EXPORT extern SourceCodeInfoDefaultTypeInternal _SourceCodeInfo_default_instance_;
+class SourceCodeInfo_Location;
+struct SourceCodeInfo_LocationDefaultTypeInternal;
+PROTOBUF_EXPORT extern SourceCodeInfo_LocationDefaultTypeInternal _SourceCodeInfo_Location_default_instance_;
+class UninterpretedOption;
+struct UninterpretedOptionDefaultTypeInternal;
+PROTOBUF_EXPORT extern UninterpretedOptionDefaultTypeInternal _UninterpretedOption_default_instance_;
+class UninterpretedOption_NamePart;
+struct UninterpretedOption_NamePartDefaultTypeInternal;
+PROTOBUF_EXPORT extern UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorSet* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorSet>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MessageOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MessageOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceOptions>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+enum FieldDescriptorProto_Type : int {
+  FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
+  FieldDescriptorProto_Type_TYPE_FLOAT = 2,
+  FieldDescriptorProto_Type_TYPE_INT64 = 3,
+  FieldDescriptorProto_Type_TYPE_UINT64 = 4,
+  FieldDescriptorProto_Type_TYPE_INT32 = 5,
+  FieldDescriptorProto_Type_TYPE_FIXED64 = 6,
+  FieldDescriptorProto_Type_TYPE_FIXED32 = 7,
+  FieldDescriptorProto_Type_TYPE_BOOL = 8,
+  FieldDescriptorProto_Type_TYPE_STRING = 9,
+  FieldDescriptorProto_Type_TYPE_GROUP = 10,
+  FieldDescriptorProto_Type_TYPE_MESSAGE = 11,
+  FieldDescriptorProto_Type_TYPE_BYTES = 12,
+  FieldDescriptorProto_Type_TYPE_UINT32 = 13,
+  FieldDescriptorProto_Type_TYPE_ENUM = 14,
+  FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,
+  FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,
+  FieldDescriptorProto_Type_TYPE_SINT32 = 17,
+  FieldDescriptorProto_Type_TYPE_SINT64 = 18
+};
+PROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value);
+constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE;
+constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64;
+constexpr int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Type_descriptor();
+template<typename T>
+inline const std::string& FieldDescriptorProto_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FieldDescriptorProto_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FieldDescriptorProto_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FieldDescriptorProto_Type_descriptor(), enum_t_value);
+}
+inline bool FieldDescriptorProto_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Type>(
+    FieldDescriptorProto_Type_descriptor(), name, value);
+}
+enum FieldDescriptorProto_Label : int {
+  FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
+  FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
+  FieldDescriptorProto_Label_LABEL_REPEATED = 3
+};
+PROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value);
+constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL;
+constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED;
+constexpr int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Label_descriptor();
+template<typename T>
+inline const std::string& FieldDescriptorProto_Label_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FieldDescriptorProto_Label>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FieldDescriptorProto_Label_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FieldDescriptorProto_Label_descriptor(), enum_t_value);
+}
+inline bool FieldDescriptorProto_Label_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Label* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Label>(
+    FieldDescriptorProto_Label_descriptor(), name, value);
+}
+enum FileOptions_OptimizeMode : int {
+  FileOptions_OptimizeMode_SPEED = 1,
+  FileOptions_OptimizeMode_CODE_SIZE = 2,
+  FileOptions_OptimizeMode_LITE_RUNTIME = 3
+};
+PROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value);
+constexpr FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED;
+constexpr FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME;
+constexpr int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FileOptions_OptimizeMode_descriptor();
+template<typename T>
+inline const std::string& FileOptions_OptimizeMode_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FileOptions_OptimizeMode>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FileOptions_OptimizeMode_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FileOptions_OptimizeMode_descriptor(), enum_t_value);
+}
+inline bool FileOptions_OptimizeMode_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FileOptions_OptimizeMode* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FileOptions_OptimizeMode>(
+    FileOptions_OptimizeMode_descriptor(), name, value);
+}
+enum FieldOptions_CType : int {
+  FieldOptions_CType_STRING = 0,
+  FieldOptions_CType_CORD = 1,
+  FieldOptions_CType_STRING_PIECE = 2
+};
+PROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value);
+constexpr FieldOptions_CType FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING;
+constexpr FieldOptions_CType FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE;
+constexpr int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldOptions_CType_descriptor();
+template<typename T>
+inline const std::string& FieldOptions_CType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FieldOptions_CType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FieldOptions_CType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FieldOptions_CType_descriptor(), enum_t_value);
+}
+inline bool FieldOptions_CType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldOptions_CType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_CType>(
+    FieldOptions_CType_descriptor(), name, value);
+}
+enum FieldOptions_JSType : int {
+  FieldOptions_JSType_JS_NORMAL = 0,
+  FieldOptions_JSType_JS_STRING = 1,
+  FieldOptions_JSType_JS_NUMBER = 2
+};
+PROTOBUF_EXPORT bool FieldOptions_JSType_IsValid(int value);
+constexpr FieldOptions_JSType FieldOptions_JSType_JSType_MIN = FieldOptions_JSType_JS_NORMAL;
+constexpr FieldOptions_JSType FieldOptions_JSType_JSType_MAX = FieldOptions_JSType_JS_NUMBER;
+constexpr int FieldOptions_JSType_JSType_ARRAYSIZE = FieldOptions_JSType_JSType_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldOptions_JSType_descriptor();
+template<typename T>
+inline const std::string& FieldOptions_JSType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FieldOptions_JSType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FieldOptions_JSType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FieldOptions_JSType_descriptor(), enum_t_value);
+}
+inline bool FieldOptions_JSType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldOptions_JSType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_JSType>(
+    FieldOptions_JSType_descriptor(), name, value);
+}
+enum MethodOptions_IdempotencyLevel : int {
+  MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN = 0,
+  MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS = 1,
+  MethodOptions_IdempotencyLevel_IDEMPOTENT = 2
+};
+PROTOBUF_EXPORT bool MethodOptions_IdempotencyLevel_IsValid(int value);
+constexpr MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN = MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
+constexpr MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX = MethodOptions_IdempotencyLevel_IDEMPOTENT;
+constexpr int MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE = MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MethodOptions_IdempotencyLevel_descriptor();
+template<typename T>
+inline const std::string& MethodOptions_IdempotencyLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, MethodOptions_IdempotencyLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function MethodOptions_IdempotencyLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    MethodOptions_IdempotencyLevel_descriptor(), enum_t_value);
+}
+inline bool MethodOptions_IdempotencyLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MethodOptions_IdempotencyLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MethodOptions_IdempotencyLevel>(
+    MethodOptions_IdempotencyLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class PROTOBUF_EXPORT FileDescriptorSet final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorSet) */ {
+ public:
+  inline FileDescriptorSet() : FileDescriptorSet(nullptr) {}
+  ~FileDescriptorSet() override;
+  explicit PROTOBUF_CONSTEXPR FileDescriptorSet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FileDescriptorSet(const FileDescriptorSet& from);
+  FileDescriptorSet(FileDescriptorSet&& from) noexcept
+    : FileDescriptorSet() {
+    *this = ::std::move(from);
+  }
+
+  inline FileDescriptorSet& operator=(const FileDescriptorSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FileDescriptorSet& operator=(FileDescriptorSet&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FileDescriptorSet& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FileDescriptorSet* internal_default_instance() {
+    return reinterpret_cast<const FileDescriptorSet*>(
+               &_FileDescriptorSet_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(FileDescriptorSet& a, FileDescriptorSet& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FileDescriptorSet* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FileDescriptorSet* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FileDescriptorSet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FileDescriptorSet>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FileDescriptorSet& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FileDescriptorSet& from) {
+    FileDescriptorSet::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FileDescriptorSet* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.FileDescriptorSet";
+  }
+  protected:
+  explicit FileDescriptorSet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileFieldNumber = 1,
+  };
+  // repeated .google.protobuf.FileDescriptorProto file = 1;
+  int file_size() const;
+  private:
+  int _internal_file_size() const;
+  public:
+  void clear_file();
+  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* mutable_file(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
+      mutable_file();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& _internal_file(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _internal_add_file();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& file(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* add_file();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
+      file() const;
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorSet)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto > file_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT FileDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorProto) */ {
+ public:
+  inline FileDescriptorProto() : FileDescriptorProto(nullptr) {}
+  ~FileDescriptorProto() override;
+  explicit PROTOBUF_CONSTEXPR FileDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FileDescriptorProto(const FileDescriptorProto& from);
+  FileDescriptorProto(FileDescriptorProto&& from) noexcept
+    : FileDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline FileDescriptorProto& operator=(const FileDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FileDescriptorProto& operator=(FileDescriptorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FileDescriptorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FileDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const FileDescriptorProto*>(
+               &_FileDescriptorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(FileDescriptorProto& a, FileDescriptorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FileDescriptorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FileDescriptorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FileDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FileDescriptorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FileDescriptorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FileDescriptorProto& from) {
+    FileDescriptorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FileDescriptorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.FileDescriptorProto";
+  }
+  protected:
+  explicit FileDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDependencyFieldNumber = 3,
+    kMessageTypeFieldNumber = 4,
+    kEnumTypeFieldNumber = 5,
+    kServiceFieldNumber = 6,
+    kExtensionFieldNumber = 7,
+    kPublicDependencyFieldNumber = 10,
+    kWeakDependencyFieldNumber = 11,
+    kNameFieldNumber = 1,
+    kPackageFieldNumber = 2,
+    kSyntaxFieldNumber = 12,
+    kOptionsFieldNumber = 8,
+    kSourceCodeInfoFieldNumber = 9,
+  };
+  // repeated string dependency = 3;
+  int dependency_size() const;
+  private:
+  int _internal_dependency_size() const;
+  public:
+  void clear_dependency();
+  const std::string& dependency(int index) const;
+  std::string* mutable_dependency(int index);
+  void set_dependency(int index, const std::string& value);
+  void set_dependency(int index, std::string&& value);
+  void set_dependency(int index, const char* value);
+  void set_dependency(int index, const char* value, size_t size);
+  std::string* add_dependency();
+  void add_dependency(const std::string& value);
+  void add_dependency(std::string&& value);
+  void add_dependency(const char* value);
+  void add_dependency(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dependency() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dependency();
+  private:
+  const std::string& _internal_dependency(int index) const;
+  std::string* _internal_add_dependency();
+  public:
+
+  // repeated .google.protobuf.DescriptorProto message_type = 4;
+  int message_type_size() const;
+  private:
+  int _internal_message_type_size() const;
+  public:
+  void clear_message_type();
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* mutable_message_type(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >*
+      mutable_message_type();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& _internal_message_type(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _internal_add_message_type();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& message_type(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* add_message_type();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >&
+      message_type() const;
+
+  // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
+  int enum_type_size() const;
+  private:
+  int _internal_enum_type_size() const;
+  public:
+  void clear_enum_type();
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* mutable_enum_type(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
+      mutable_enum_type();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& _internal_enum_type(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _internal_add_enum_type();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& enum_type(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* add_enum_type();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
+      enum_type() const;
+
+  // repeated .google.protobuf.ServiceDescriptorProto service = 6;
+  int service_size() const;
+  private:
+  int _internal_service_size() const;
+  public:
+  void clear_service();
+  ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* mutable_service(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >*
+      mutable_service();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& _internal_service(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* _internal_add_service();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& service(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* add_service();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >&
+      service() const;
+
+  // repeated .google.protobuf.FieldDescriptorProto extension = 7;
+  int extension_size() const;
+  private:
+  int _internal_extension_size() const;
+  public:
+  void clear_extension();
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_extension(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
+      mutable_extension();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_extension(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_extension();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& extension(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_extension();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
+      extension() const;
+
+  // repeated int32 public_dependency = 10;
+  int public_dependency_size() const;
+  private:
+  int _internal_public_dependency_size() const;
+  public:
+  void clear_public_dependency();
+  private:
+  int32_t _internal_public_dependency(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_public_dependency() const;
+  void _internal_add_public_dependency(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_public_dependency();
+  public:
+  int32_t public_dependency(int index) const;
+  void set_public_dependency(int index, int32_t value);
+  void add_public_dependency(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      public_dependency() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_public_dependency();
+
+  // repeated int32 weak_dependency = 11;
+  int weak_dependency_size() const;
+  private:
+  int _internal_weak_dependency_size() const;
+  public:
+  void clear_weak_dependency();
+  private:
+  int32_t _internal_weak_dependency(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_weak_dependency() const;
+  void _internal_add_weak_dependency(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_weak_dependency();
+  public:
+  int32_t weak_dependency(int index) const;
+  void set_weak_dependency(int index, int32_t value);
+  void add_weak_dependency(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      weak_dependency() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_weak_dependency();
+
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string package = 2;
+  bool has_package() const;
+  private:
+  bool _internal_has_package() const;
+  public:
+  void clear_package();
+  const std::string& package() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_package(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_package();
+  PROTOBUF_NODISCARD std::string* release_package();
+  void set_allocated_package(std::string* package);
+  private:
+  const std::string& _internal_package() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_package(const std::string& value);
+  std::string* _internal_mutable_package();
+  public:
+
+  // optional string syntax = 12;
+  bool has_syntax() const;
+  private:
+  bool _internal_has_syntax() const;
+  public:
+  void clear_syntax();
+  const std::string& syntax() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_syntax(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_syntax();
+  PROTOBUF_NODISCARD std::string* release_syntax();
+  void set_allocated_syntax(std::string* syntax);
+  private:
+  const std::string& _internal_syntax() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_syntax(const std::string& value);
+  std::string* _internal_mutable_syntax();
+  public:
+
+  // optional .google.protobuf.FileOptions options = 8;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::FileOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FileOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::FileOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::FileOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::FileOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::FileOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::FileOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::FileOptions* unsafe_arena_release_options();
+
+  // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
+  bool has_source_code_info() const;
+  private:
+  bool _internal_has_source_code_info() const;
+  public:
+  void clear_source_code_info();
+  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& source_code_info() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* release_source_code_info();
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* mutable_source_code_info();
+  void set_allocated_source_code_info(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& _internal_source_code_info() const;
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* _internal_mutable_source_code_info();
+  public:
+  void unsafe_arena_set_allocated_source_code_info(
+      ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info);
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* unsafe_arena_release_source_code_info();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dependency_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto > message_type_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto > enum_type_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto > service_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > extension_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > public_dependency_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > weak_dependency_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr syntax_;
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* options_;
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT DescriptorProto_ExtensionRange final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ExtensionRange) */ {
+ public:
+  inline DescriptorProto_ExtensionRange() : DescriptorProto_ExtensionRange(nullptr) {}
+  ~DescriptorProto_ExtensionRange() override;
+  explicit PROTOBUF_CONSTEXPR DescriptorProto_ExtensionRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from);
+  DescriptorProto_ExtensionRange(DescriptorProto_ExtensionRange&& from) noexcept
+    : DescriptorProto_ExtensionRange() {
+    *this = ::std::move(from);
+  }
+
+  inline DescriptorProto_ExtensionRange& operator=(const DescriptorProto_ExtensionRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DescriptorProto_ExtensionRange& operator=(DescriptorProto_ExtensionRange&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DescriptorProto_ExtensionRange& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DescriptorProto_ExtensionRange* internal_default_instance() {
+    return reinterpret_cast<const DescriptorProto_ExtensionRange*>(
+               &_DescriptorProto_ExtensionRange_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DescriptorProto_ExtensionRange& a, DescriptorProto_ExtensionRange& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DescriptorProto_ExtensionRange* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DescriptorProto_ExtensionRange* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DescriptorProto_ExtensionRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DescriptorProto_ExtensionRange>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DescriptorProto_ExtensionRange& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DescriptorProto_ExtensionRange& from) {
+    DescriptorProto_ExtensionRange::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DescriptorProto_ExtensionRange* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.DescriptorProto.ExtensionRange";
+  }
+  protected:
+  explicit DescriptorProto_ExtensionRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptionsFieldNumber = 3,
+    kStartFieldNumber = 1,
+    kEndFieldNumber = 2,
+  };
+  // optional .google.protobuf.ExtensionRangeOptions options = 3;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* unsafe_arena_release_options();
+
+  // optional int32 start = 1;
+  bool has_start() const;
+  private:
+  bool _internal_has_start() const;
+  public:
+  void clear_start();
+  int32_t start() const;
+  void set_start(int32_t value);
+  private:
+  int32_t _internal_start() const;
+  void _internal_set_start(int32_t value);
+  public:
+
+  // optional int32 end = 2;
+  bool has_end() const;
+  private:
+  bool _internal_has_end() const;
+  public:
+  void clear_end();
+  int32_t end() const;
+  void set_end(int32_t value);
+  private:
+  int32_t _internal_end() const;
+  void _internal_set_end(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ExtensionRange)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options_;
+    int32_t start_;
+    int32_t end_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT DescriptorProto_ReservedRange final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ReservedRange) */ {
+ public:
+  inline DescriptorProto_ReservedRange() : DescriptorProto_ReservedRange(nullptr) {}
+  ~DescriptorProto_ReservedRange() override;
+  explicit PROTOBUF_CONSTEXPR DescriptorProto_ReservedRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange& from);
+  DescriptorProto_ReservedRange(DescriptorProto_ReservedRange&& from) noexcept
+    : DescriptorProto_ReservedRange() {
+    *this = ::std::move(from);
+  }
+
+  inline DescriptorProto_ReservedRange& operator=(const DescriptorProto_ReservedRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DescriptorProto_ReservedRange& operator=(DescriptorProto_ReservedRange&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DescriptorProto_ReservedRange& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DescriptorProto_ReservedRange* internal_default_instance() {
+    return reinterpret_cast<const DescriptorProto_ReservedRange*>(
+               &_DescriptorProto_ReservedRange_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DescriptorProto_ReservedRange& a, DescriptorProto_ReservedRange& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DescriptorProto_ReservedRange* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DescriptorProto_ReservedRange* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DescriptorProto_ReservedRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DescriptorProto_ReservedRange>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DescriptorProto_ReservedRange& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DescriptorProto_ReservedRange& from) {
+    DescriptorProto_ReservedRange::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DescriptorProto_ReservedRange* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.DescriptorProto.ReservedRange";
+  }
+  protected:
+  explicit DescriptorProto_ReservedRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStartFieldNumber = 1,
+    kEndFieldNumber = 2,
+  };
+  // optional int32 start = 1;
+  bool has_start() const;
+  private:
+  bool _internal_has_start() const;
+  public:
+  void clear_start();
+  int32_t start() const;
+  void set_start(int32_t value);
+  private:
+  int32_t _internal_start() const;
+  void _internal_set_start(int32_t value);
+  public:
+
+  // optional int32 end = 2;
+  bool has_end() const;
+  private:
+  bool _internal_has_end() const;
+  public:
+  void clear_end();
+  int32_t end() const;
+  void set_end(int32_t value);
+  private:
+  int32_t _internal_end() const;
+  void _internal_set_end(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ReservedRange)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int32_t start_;
+    int32_t end_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT DescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto) */ {
+ public:
+  inline DescriptorProto() : DescriptorProto(nullptr) {}
+  ~DescriptorProto() override;
+  explicit PROTOBUF_CONSTEXPR DescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DescriptorProto(const DescriptorProto& from);
+  DescriptorProto(DescriptorProto&& from) noexcept
+    : DescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline DescriptorProto& operator=(const DescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DescriptorProto& operator=(DescriptorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DescriptorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const DescriptorProto*>(
+               &_DescriptorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(DescriptorProto& a, DescriptorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DescriptorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DescriptorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DescriptorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DescriptorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DescriptorProto& from) {
+    DescriptorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DescriptorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.DescriptorProto";
+  }
+  protected:
+  explicit DescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DescriptorProto_ExtensionRange ExtensionRange;
+  typedef DescriptorProto_ReservedRange ReservedRange;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFieldFieldNumber = 2,
+    kNestedTypeFieldNumber = 3,
+    kEnumTypeFieldNumber = 4,
+    kExtensionRangeFieldNumber = 5,
+    kExtensionFieldNumber = 6,
+    kOneofDeclFieldNumber = 8,
+    kReservedRangeFieldNumber = 9,
+    kReservedNameFieldNumber = 10,
+    kNameFieldNumber = 1,
+    kOptionsFieldNumber = 7,
+  };
+  // repeated .google.protobuf.FieldDescriptorProto field = 2;
+  int field_size() const;
+  private:
+  int _internal_field_size() const;
+  public:
+  void clear_field();
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_field(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
+      mutable_field();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_field(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_field();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& field(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_field();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
+      field() const;
+
+  // repeated .google.protobuf.DescriptorProto nested_type = 3;
+  int nested_type_size() const;
+  private:
+  int _internal_nested_type_size() const;
+  public:
+  void clear_nested_type();
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* mutable_nested_type(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >*
+      mutable_nested_type();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& _internal_nested_type(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _internal_add_nested_type();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& nested_type(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* add_nested_type();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >&
+      nested_type() const;
+
+  // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
+  int enum_type_size() const;
+  private:
+  int _internal_enum_type_size() const;
+  public:
+  void clear_enum_type();
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* mutable_enum_type(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
+      mutable_enum_type();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& _internal_enum_type(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _internal_add_enum_type();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& enum_type(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* add_enum_type();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
+      enum_type() const;
+
+  // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
+  int extension_range_size() const;
+  private:
+  int _internal_extension_range_size() const;
+  public:
+  void clear_extension_range();
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* mutable_extension_range(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >*
+      mutable_extension_range();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& _internal_extension_range(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* _internal_add_extension_range();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& extension_range(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* add_extension_range();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >&
+      extension_range() const;
+
+  // repeated .google.protobuf.FieldDescriptorProto extension = 6;
+  int extension_size() const;
+  private:
+  int _internal_extension_size() const;
+  public:
+  void clear_extension();
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_extension(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
+      mutable_extension();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_extension(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_extension();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& extension(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_extension();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
+      extension() const;
+
+  // repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
+  int oneof_decl_size() const;
+  private:
+  int _internal_oneof_decl_size() const;
+  public:
+  void clear_oneof_decl();
+  ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* mutable_oneof_decl(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >*
+      mutable_oneof_decl();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& _internal_oneof_decl(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* _internal_add_oneof_decl();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& oneof_decl(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* add_oneof_decl();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >&
+      oneof_decl() const;
+
+  // repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
+  int reserved_range_size() const;
+  private:
+  int _internal_reserved_range_size() const;
+  public:
+  void clear_reserved_range();
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* mutable_reserved_range(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >*
+      mutable_reserved_range();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& _internal_reserved_range(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* _internal_add_reserved_range();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& reserved_range(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* add_reserved_range();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >&
+      reserved_range() const;
+
+  // repeated string reserved_name = 10;
+  int reserved_name_size() const;
+  private:
+  int _internal_reserved_name_size() const;
+  public:
+  void clear_reserved_name();
+  const std::string& reserved_name(int index) const;
+  std::string* mutable_reserved_name(int index);
+  void set_reserved_name(int index, const std::string& value);
+  void set_reserved_name(int index, std::string&& value);
+  void set_reserved_name(int index, const char* value);
+  void set_reserved_name(int index, const char* value, size_t size);
+  std::string* add_reserved_name();
+  void add_reserved_name(const std::string& value);
+  void add_reserved_name(std::string&& value);
+  void add_reserved_name(const char* value);
+  void add_reserved_name(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& reserved_name() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_reserved_name();
+  private:
+  const std::string& _internal_reserved_name(int index) const;
+  std::string* _internal_add_reserved_name();
+  public:
+
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional .google.protobuf.MessageOptions options = 7;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::MessageOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::MessageOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::MessageOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::MessageOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::MessageOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::MessageOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::MessageOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::MessageOptions* unsafe_arena_release_options();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > field_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto > nested_type_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto > enum_type_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange > extension_range_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > extension_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto > oneof_decl_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange > reserved_range_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> reserved_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* options_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT ExtensionRangeOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */ {
+ public:
+  inline ExtensionRangeOptions() : ExtensionRangeOptions(nullptr) {}
+  ~ExtensionRangeOptions() override;
+  explicit PROTOBUF_CONSTEXPR ExtensionRangeOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExtensionRangeOptions(const ExtensionRangeOptions& from);
+  ExtensionRangeOptions(ExtensionRangeOptions&& from) noexcept
+    : ExtensionRangeOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline ExtensionRangeOptions& operator=(const ExtensionRangeOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExtensionRangeOptions& operator=(ExtensionRangeOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExtensionRangeOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExtensionRangeOptions* internal_default_instance() {
+    return reinterpret_cast<const ExtensionRangeOptions*>(
+               &_ExtensionRangeOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ExtensionRangeOptions& a, ExtensionRangeOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExtensionRangeOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExtensionRangeOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ExtensionRangeOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ExtensionRangeOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExtensionRangeOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ExtensionRangeOptions& from) {
+    ExtensionRangeOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExtensionRangeOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.ExtensionRangeOptions";
+  }
+  protected:
+  explicit ExtensionRangeOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.ExtensionRangeOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT FieldDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldDescriptorProto) */ {
+ public:
+  inline FieldDescriptorProto() : FieldDescriptorProto(nullptr) {}
+  ~FieldDescriptorProto() override;
+  explicit PROTOBUF_CONSTEXPR FieldDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FieldDescriptorProto(const FieldDescriptorProto& from);
+  FieldDescriptorProto(FieldDescriptorProto&& from) noexcept
+    : FieldDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline FieldDescriptorProto& operator=(const FieldDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FieldDescriptorProto& operator=(FieldDescriptorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FieldDescriptorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FieldDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const FieldDescriptorProto*>(
+               &_FieldDescriptorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(FieldDescriptorProto& a, FieldDescriptorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FieldDescriptorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FieldDescriptorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FieldDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FieldDescriptorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FieldDescriptorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FieldDescriptorProto& from) {
+    FieldDescriptorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FieldDescriptorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.FieldDescriptorProto";
+  }
+  protected:
+  explicit FieldDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FieldDescriptorProto_Type Type;
+  static constexpr Type TYPE_DOUBLE =
+    FieldDescriptorProto_Type_TYPE_DOUBLE;
+  static constexpr Type TYPE_FLOAT =
+    FieldDescriptorProto_Type_TYPE_FLOAT;
+  static constexpr Type TYPE_INT64 =
+    FieldDescriptorProto_Type_TYPE_INT64;
+  static constexpr Type TYPE_UINT64 =
+    FieldDescriptorProto_Type_TYPE_UINT64;
+  static constexpr Type TYPE_INT32 =
+    FieldDescriptorProto_Type_TYPE_INT32;
+  static constexpr Type TYPE_FIXED64 =
+    FieldDescriptorProto_Type_TYPE_FIXED64;
+  static constexpr Type TYPE_FIXED32 =
+    FieldDescriptorProto_Type_TYPE_FIXED32;
+  static constexpr Type TYPE_BOOL =
+    FieldDescriptorProto_Type_TYPE_BOOL;
+  static constexpr Type TYPE_STRING =
+    FieldDescriptorProto_Type_TYPE_STRING;
+  static constexpr Type TYPE_GROUP =
+    FieldDescriptorProto_Type_TYPE_GROUP;
+  static constexpr Type TYPE_MESSAGE =
+    FieldDescriptorProto_Type_TYPE_MESSAGE;
+  static constexpr Type TYPE_BYTES =
+    FieldDescriptorProto_Type_TYPE_BYTES;
+  static constexpr Type TYPE_UINT32 =
+    FieldDescriptorProto_Type_TYPE_UINT32;
+  static constexpr Type TYPE_ENUM =
+    FieldDescriptorProto_Type_TYPE_ENUM;
+  static constexpr Type TYPE_SFIXED32 =
+    FieldDescriptorProto_Type_TYPE_SFIXED32;
+  static constexpr Type TYPE_SFIXED64 =
+    FieldDescriptorProto_Type_TYPE_SFIXED64;
+  static constexpr Type TYPE_SINT32 =
+    FieldDescriptorProto_Type_TYPE_SINT32;
+  static constexpr Type TYPE_SINT64 =
+    FieldDescriptorProto_Type_TYPE_SINT64;
+  static inline bool Type_IsValid(int value) {
+    return FieldDescriptorProto_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    FieldDescriptorProto_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    FieldDescriptorProto_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    FieldDescriptorProto_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return FieldDescriptorProto_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return FieldDescriptorProto_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return FieldDescriptorProto_Type_Parse(name, value);
+  }
+
+  typedef FieldDescriptorProto_Label Label;
+  static constexpr Label LABEL_OPTIONAL =
+    FieldDescriptorProto_Label_LABEL_OPTIONAL;
+  static constexpr Label LABEL_REQUIRED =
+    FieldDescriptorProto_Label_LABEL_REQUIRED;
+  static constexpr Label LABEL_REPEATED =
+    FieldDescriptorProto_Label_LABEL_REPEATED;
+  static inline bool Label_IsValid(int value) {
+    return FieldDescriptorProto_Label_IsValid(value);
+  }
+  static constexpr Label Label_MIN =
+    FieldDescriptorProto_Label_Label_MIN;
+  static constexpr Label Label_MAX =
+    FieldDescriptorProto_Label_Label_MAX;
+  static constexpr int Label_ARRAYSIZE =
+    FieldDescriptorProto_Label_Label_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Label_descriptor() {
+    return FieldDescriptorProto_Label_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Label_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Label>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Label_Name.");
+    return FieldDescriptorProto_Label_Name(enum_t_value);
+  }
+  static inline bool Label_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Label* value) {
+    return FieldDescriptorProto_Label_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kExtendeeFieldNumber = 2,
+    kTypeNameFieldNumber = 6,
+    kDefaultValueFieldNumber = 7,
+    kJsonNameFieldNumber = 10,
+    kOptionsFieldNumber = 8,
+    kNumberFieldNumber = 3,
+    kOneofIndexFieldNumber = 9,
+    kProto3OptionalFieldNumber = 17,
+    kLabelFieldNumber = 4,
+    kTypeFieldNumber = 5,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string extendee = 2;
+  bool has_extendee() const;
+  private:
+  bool _internal_has_extendee() const;
+  public:
+  void clear_extendee();
+  const std::string& extendee() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_extendee(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_extendee();
+  PROTOBUF_NODISCARD std::string* release_extendee();
+  void set_allocated_extendee(std::string* extendee);
+  private:
+  const std::string& _internal_extendee() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_extendee(const std::string& value);
+  std::string* _internal_mutable_extendee();
+  public:
+
+  // optional string type_name = 6;
+  bool has_type_name() const;
+  private:
+  bool _internal_has_type_name() const;
+  public:
+  void clear_type_name();
+  const std::string& type_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_name();
+  PROTOBUF_NODISCARD std::string* release_type_name();
+  void set_allocated_type_name(std::string* type_name);
+  private:
+  const std::string& _internal_type_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_name(const std::string& value);
+  std::string* _internal_mutable_type_name();
+  public:
+
+  // optional string default_value = 7;
+  bool has_default_value() const;
+  private:
+  bool _internal_has_default_value() const;
+  public:
+  void clear_default_value();
+  const std::string& default_value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_default_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_default_value();
+  PROTOBUF_NODISCARD std::string* release_default_value();
+  void set_allocated_default_value(std::string* default_value);
+  private:
+  const std::string& _internal_default_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_value(const std::string& value);
+  std::string* _internal_mutable_default_value();
+  public:
+
+  // optional string json_name = 10;
+  bool has_json_name() const;
+  private:
+  bool _internal_has_json_name() const;
+  public:
+  void clear_json_name();
+  const std::string& json_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_json_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_json_name();
+  PROTOBUF_NODISCARD std::string* release_json_name();
+  void set_allocated_json_name(std::string* json_name);
+  private:
+  const std::string& _internal_json_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_name(const std::string& value);
+  std::string* _internal_mutable_json_name();
+  public:
+
+  // optional .google.protobuf.FieldOptions options = 8;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::FieldOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FieldOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::FieldOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::FieldOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::FieldOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions* unsafe_arena_release_options();
+
+  // optional int32 number = 3;
+  bool has_number() const;
+  private:
+  bool _internal_has_number() const;
+  public:
+  void clear_number();
+  int32_t number() const;
+  void set_number(int32_t value);
+  private:
+  int32_t _internal_number() const;
+  void _internal_set_number(int32_t value);
+  public:
+
+  // optional int32 oneof_index = 9;
+  bool has_oneof_index() const;
+  private:
+  bool _internal_has_oneof_index() const;
+  public:
+  void clear_oneof_index();
+  int32_t oneof_index() const;
+  void set_oneof_index(int32_t value);
+  private:
+  int32_t _internal_oneof_index() const;
+  void _internal_set_oneof_index(int32_t value);
+  public:
+
+  // optional bool proto3_optional = 17;
+  bool has_proto3_optional() const;
+  private:
+  bool _internal_has_proto3_optional() const;
+  public:
+  void clear_proto3_optional();
+  bool proto3_optional() const;
+  void set_proto3_optional(bool value);
+  private:
+  bool _internal_proto3_optional() const;
+  void _internal_set_proto3_optional(bool value);
+  public:
+
+  // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
+  bool has_label() const;
+  private:
+  bool _internal_has_label() const;
+  public:
+  void clear_label();
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label label() const;
+  void set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label _internal_label() const;
+  void _internal_set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value);
+  public:
+
+  // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type type() const;
+  void set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type _internal_type() const;
+  void _internal_set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FieldDescriptorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extendee_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_name_;
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* options_;
+    int32_t number_;
+    int32_t oneof_index_;
+    bool proto3_optional_;
+    int label_;
+    int type_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT OneofDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofDescriptorProto) */ {
+ public:
+  inline OneofDescriptorProto() : OneofDescriptorProto(nullptr) {}
+  ~OneofDescriptorProto() override;
+  explicit PROTOBUF_CONSTEXPR OneofDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OneofDescriptorProto(const OneofDescriptorProto& from);
+  OneofDescriptorProto(OneofDescriptorProto&& from) noexcept
+    : OneofDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline OneofDescriptorProto& operator=(const OneofDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OneofDescriptorProto& operator=(OneofDescriptorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OneofDescriptorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OneofDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const OneofDescriptorProto*>(
+               &_OneofDescriptorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(OneofDescriptorProto& a, OneofDescriptorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OneofDescriptorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OneofDescriptorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OneofDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OneofDescriptorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OneofDescriptorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OneofDescriptorProto& from) {
+    OneofDescriptorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OneofDescriptorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.OneofDescriptorProto";
+  }
+  protected:
+  explicit OneofDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kOptionsFieldNumber = 2,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional .google.protobuf.OneofOptions options = 2;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::OneofOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::OneofOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::OneofOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::OneofOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::OneofOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::OneofOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::OneofOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::OneofOptions* unsafe_arena_release_options();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.OneofDescriptorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* options_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto.EnumReservedRange) */ {
+ public:
+  inline EnumDescriptorProto_EnumReservedRange() : EnumDescriptorProto_EnumReservedRange(nullptr) {}
+  ~EnumDescriptorProto_EnumReservedRange() override;
+  explicit PROTOBUF_CONSTEXPR EnumDescriptorProto_EnumReservedRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EnumDescriptorProto_EnumReservedRange(const EnumDescriptorProto_EnumReservedRange& from);
+  EnumDescriptorProto_EnumReservedRange(EnumDescriptorProto_EnumReservedRange&& from) noexcept
+    : EnumDescriptorProto_EnumReservedRange() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumDescriptorProto_EnumReservedRange& operator=(const EnumDescriptorProto_EnumReservedRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EnumDescriptorProto_EnumReservedRange& operator=(EnumDescriptorProto_EnumReservedRange&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EnumDescriptorProto_EnumReservedRange& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EnumDescriptorProto_EnumReservedRange* internal_default_instance() {
+    return reinterpret_cast<const EnumDescriptorProto_EnumReservedRange*>(
+               &_EnumDescriptorProto_EnumReservedRange_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(EnumDescriptorProto_EnumReservedRange& a, EnumDescriptorProto_EnumReservedRange& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EnumDescriptorProto_EnumReservedRange* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EnumDescriptorProto_EnumReservedRange* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EnumDescriptorProto_EnumReservedRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EnumDescriptorProto_EnumReservedRange>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EnumDescriptorProto_EnumReservedRange& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EnumDescriptorProto_EnumReservedRange& from) {
+    EnumDescriptorProto_EnumReservedRange::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EnumDescriptorProto_EnumReservedRange* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.EnumDescriptorProto.EnumReservedRange";
+  }
+  protected:
+  explicit EnumDescriptorProto_EnumReservedRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStartFieldNumber = 1,
+    kEndFieldNumber = 2,
+  };
+  // optional int32 start = 1;
+  bool has_start() const;
+  private:
+  bool _internal_has_start() const;
+  public:
+  void clear_start();
+  int32_t start() const;
+  void set_start(int32_t value);
+  private:
+  int32_t _internal_start() const;
+  void _internal_set_start(int32_t value);
+  public:
+
+  // optional int32 end = 2;
+  bool has_end() const;
+  private:
+  bool _internal_has_end() const;
+  public:
+  void clear_end();
+  int32_t end() const;
+  void set_end(int32_t value);
+  private:
+  int32_t _internal_end() const;
+  void _internal_set_end(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto.EnumReservedRange)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    int32_t start_;
+    int32_t end_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto) */ {
+ public:
+  inline EnumDescriptorProto() : EnumDescriptorProto(nullptr) {}
+  ~EnumDescriptorProto() override;
+  explicit PROTOBUF_CONSTEXPR EnumDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EnumDescriptorProto(const EnumDescriptorProto& from);
+  EnumDescriptorProto(EnumDescriptorProto&& from) noexcept
+    : EnumDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumDescriptorProto& operator=(const EnumDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EnumDescriptorProto& operator=(EnumDescriptorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EnumDescriptorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EnumDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const EnumDescriptorProto*>(
+               &_EnumDescriptorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(EnumDescriptorProto& a, EnumDescriptorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EnumDescriptorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EnumDescriptorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EnumDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EnumDescriptorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EnumDescriptorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EnumDescriptorProto& from) {
+    EnumDescriptorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EnumDescriptorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.EnumDescriptorProto";
+  }
+  protected:
+  explicit EnumDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef EnumDescriptorProto_EnumReservedRange EnumReservedRange;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 2,
+    kReservedRangeFieldNumber = 4,
+    kReservedNameFieldNumber = 5,
+    kNameFieldNumber = 1,
+    kOptionsFieldNumber = 3,
+  };
+  // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
+  int value_size() const;
+  private:
+  int _internal_value_size() const;
+  public:
+  void clear_value();
+  ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* mutable_value(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >*
+      mutable_value();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& _internal_value(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* _internal_add_value();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& value(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* add_value();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >&
+      value() const;
+
+  // repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
+  int reserved_range_size() const;
+  private:
+  int _internal_reserved_range_size() const;
+  public:
+  void clear_reserved_range();
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* mutable_reserved_range(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >*
+      mutable_reserved_range();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& _internal_reserved_range(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* _internal_add_reserved_range();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& reserved_range(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* add_reserved_range();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >&
+      reserved_range() const;
+
+  // repeated string reserved_name = 5;
+  int reserved_name_size() const;
+  private:
+  int _internal_reserved_name_size() const;
+  public:
+  void clear_reserved_name();
+  const std::string& reserved_name(int index) const;
+  std::string* mutable_reserved_name(int index);
+  void set_reserved_name(int index, const std::string& value);
+  void set_reserved_name(int index, std::string&& value);
+  void set_reserved_name(int index, const char* value);
+  void set_reserved_name(int index, const char* value, size_t size);
+  std::string* add_reserved_name();
+  void add_reserved_name(const std::string& value);
+  void add_reserved_name(std::string&& value);
+  void add_reserved_name(const char* value);
+  void add_reserved_name(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& reserved_name() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_reserved_name();
+  private:
+  const std::string& _internal_reserved_name(int index) const;
+  std::string* _internal_add_reserved_name();
+  public:
+
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional .google.protobuf.EnumOptions options = 3;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::EnumOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::EnumOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::EnumOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::EnumOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::EnumOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::EnumOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::EnumOptions* unsafe_arena_release_options();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto > value_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange > reserved_range_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> reserved_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* options_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumValueDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueDescriptorProto) */ {
+ public:
+  inline EnumValueDescriptorProto() : EnumValueDescriptorProto(nullptr) {}
+  ~EnumValueDescriptorProto() override;
+  explicit PROTOBUF_CONSTEXPR EnumValueDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EnumValueDescriptorProto(const EnumValueDescriptorProto& from);
+  EnumValueDescriptorProto(EnumValueDescriptorProto&& from) noexcept
+    : EnumValueDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EnumValueDescriptorProto& operator=(EnumValueDescriptorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EnumValueDescriptorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EnumValueDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const EnumValueDescriptorProto*>(
+               &_EnumValueDescriptorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(EnumValueDescriptorProto& a, EnumValueDescriptorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EnumValueDescriptorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EnumValueDescriptorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EnumValueDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EnumValueDescriptorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EnumValueDescriptorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EnumValueDescriptorProto& from) {
+    EnumValueDescriptorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EnumValueDescriptorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.EnumValueDescriptorProto";
+  }
+  protected:
+  explicit EnumValueDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kOptionsFieldNumber = 3,
+    kNumberFieldNumber = 2,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional .google.protobuf.EnumValueOptions options = 3;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* unsafe_arena_release_options();
+
+  // optional int32 number = 2;
+  bool has_number() const;
+  private:
+  bool _internal_has_number() const;
+  public:
+  void clear_number();
+  int32_t number() const;
+  void set_number(int32_t value);
+  private:
+  int32_t _internal_number() const;
+  void _internal_set_number(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueDescriptorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options_;
+    int32_t number_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT ServiceDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceDescriptorProto) */ {
+ public:
+  inline ServiceDescriptorProto() : ServiceDescriptorProto(nullptr) {}
+  ~ServiceDescriptorProto() override;
+  explicit PROTOBUF_CONSTEXPR ServiceDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ServiceDescriptorProto(const ServiceDescriptorProto& from);
+  ServiceDescriptorProto(ServiceDescriptorProto&& from) noexcept
+    : ServiceDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline ServiceDescriptorProto& operator=(const ServiceDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ServiceDescriptorProto& operator=(ServiceDescriptorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ServiceDescriptorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ServiceDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const ServiceDescriptorProto*>(
+               &_ServiceDescriptorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(ServiceDescriptorProto& a, ServiceDescriptorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ServiceDescriptorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ServiceDescriptorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ServiceDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ServiceDescriptorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ServiceDescriptorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ServiceDescriptorProto& from) {
+    ServiceDescriptorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ServiceDescriptorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.ServiceDescriptorProto";
+  }
+  protected:
+  explicit ServiceDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMethodFieldNumber = 2,
+    kNameFieldNumber = 1,
+    kOptionsFieldNumber = 3,
+  };
+  // repeated .google.protobuf.MethodDescriptorProto method = 2;
+  int method_size() const;
+  private:
+  int _internal_method_size() const;
+  public:
+  void clear_method();
+  ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* mutable_method(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >*
+      mutable_method();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& _internal_method(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* _internal_add_method();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& method(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* add_method();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >&
+      method() const;
+
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional .google.protobuf.ServiceOptions options = 3;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ServiceOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::ServiceOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* unsafe_arena_release_options();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.ServiceDescriptorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto > method_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT MethodDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodDescriptorProto) */ {
+ public:
+  inline MethodDescriptorProto() : MethodDescriptorProto(nullptr) {}
+  ~MethodDescriptorProto() override;
+  explicit PROTOBUF_CONSTEXPR MethodDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MethodDescriptorProto(const MethodDescriptorProto& from);
+  MethodDescriptorProto(MethodDescriptorProto&& from) noexcept
+    : MethodDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline MethodDescriptorProto& operator=(const MethodDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MethodDescriptorProto& operator=(MethodDescriptorProto&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MethodDescriptorProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MethodDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const MethodDescriptorProto*>(
+               &_MethodDescriptorProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(MethodDescriptorProto& a, MethodDescriptorProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MethodDescriptorProto* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MethodDescriptorProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MethodDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MethodDescriptorProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MethodDescriptorProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MethodDescriptorProto& from) {
+    MethodDescriptorProto::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MethodDescriptorProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.MethodDescriptorProto";
+  }
+  protected:
+  explicit MethodDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kInputTypeFieldNumber = 2,
+    kOutputTypeFieldNumber = 3,
+    kOptionsFieldNumber = 4,
+    kClientStreamingFieldNumber = 5,
+    kServerStreamingFieldNumber = 6,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string input_type = 2;
+  bool has_input_type() const;
+  private:
+  bool _internal_has_input_type() const;
+  public:
+  void clear_input_type();
+  const std::string& input_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_input_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_input_type();
+  PROTOBUF_NODISCARD std::string* release_input_type();
+  void set_allocated_input_type(std::string* input_type);
+  private:
+  const std::string& _internal_input_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_type(const std::string& value);
+  std::string* _internal_mutable_input_type();
+  public:
+
+  // optional string output_type = 3;
+  bool has_output_type() const;
+  private:
+  bool _internal_has_output_type() const;
+  public:
+  void clear_output_type();
+  const std::string& output_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_output_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_output_type();
+  PROTOBUF_NODISCARD std::string* release_output_type();
+  void set_allocated_output_type(std::string* output_type);
+  private:
+  const std::string& _internal_output_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_type(const std::string& value);
+  std::string* _internal_mutable_output_type();
+  public:
+
+  // optional .google.protobuf.MethodOptions options = 4;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::PROTOBUF_NAMESPACE_ID::MethodOptions& options() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::MethodOptions* release_options();
+  ::PROTOBUF_NAMESPACE_ID::MethodOptions* mutable_options();
+  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::MethodOptions* options);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::MethodOptions& _internal_options() const;
+  ::PROTOBUF_NAMESPACE_ID::MethodOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::PROTOBUF_NAMESPACE_ID::MethodOptions* options);
+  ::PROTOBUF_NAMESPACE_ID::MethodOptions* unsafe_arena_release_options();
+
+  // optional bool client_streaming = 5 [default = false];
+  bool has_client_streaming() const;
+  private:
+  bool _internal_has_client_streaming() const;
+  public:
+  void clear_client_streaming();
+  bool client_streaming() const;
+  void set_client_streaming(bool value);
+  private:
+  bool _internal_client_streaming() const;
+  void _internal_set_client_streaming(bool value);
+  public:
+
+  // optional bool server_streaming = 6 [default = false];
+  bool has_server_streaming() const;
+  private:
+  bool _internal_has_server_streaming() const;
+  public:
+  void clear_server_streaming();
+  bool server_streaming() const;
+  void set_server_streaming(bool value);
+  private:
+  bool _internal_server_streaming() const;
+  void _internal_set_server_streaming(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.MethodDescriptorProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_type_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_type_;
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* options_;
+    bool client_streaming_;
+    bool server_streaming_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT FileOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileOptions) */ {
+ public:
+  inline FileOptions() : FileOptions(nullptr) {}
+  ~FileOptions() override;
+  explicit PROTOBUF_CONSTEXPR FileOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FileOptions(const FileOptions& from);
+  FileOptions(FileOptions&& from) noexcept
+    : FileOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline FileOptions& operator=(const FileOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FileOptions& operator=(FileOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FileOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FileOptions* internal_default_instance() {
+    return reinterpret_cast<const FileOptions*>(
+               &_FileOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(FileOptions& a, FileOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FileOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FileOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FileOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FileOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FileOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FileOptions& from) {
+    FileOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FileOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.FileOptions";
+  }
+  protected:
+  explicit FileOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FileOptions_OptimizeMode OptimizeMode;
+  static constexpr OptimizeMode SPEED =
+    FileOptions_OptimizeMode_SPEED;
+  static constexpr OptimizeMode CODE_SIZE =
+    FileOptions_OptimizeMode_CODE_SIZE;
+  static constexpr OptimizeMode LITE_RUNTIME =
+    FileOptions_OptimizeMode_LITE_RUNTIME;
+  static inline bool OptimizeMode_IsValid(int value) {
+    return FileOptions_OptimizeMode_IsValid(value);
+  }
+  static constexpr OptimizeMode OptimizeMode_MIN =
+    FileOptions_OptimizeMode_OptimizeMode_MIN;
+  static constexpr OptimizeMode OptimizeMode_MAX =
+    FileOptions_OptimizeMode_OptimizeMode_MAX;
+  static constexpr int OptimizeMode_ARRAYSIZE =
+    FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  OptimizeMode_descriptor() {
+    return FileOptions_OptimizeMode_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& OptimizeMode_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, OptimizeMode>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function OptimizeMode_Name.");
+    return FileOptions_OptimizeMode_Name(enum_t_value);
+  }
+  static inline bool OptimizeMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      OptimizeMode* value) {
+    return FileOptions_OptimizeMode_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+    kJavaPackageFieldNumber = 1,
+    kJavaOuterClassnameFieldNumber = 8,
+    kGoPackageFieldNumber = 11,
+    kObjcClassPrefixFieldNumber = 36,
+    kCsharpNamespaceFieldNumber = 37,
+    kSwiftPrefixFieldNumber = 39,
+    kPhpClassPrefixFieldNumber = 40,
+    kPhpNamespaceFieldNumber = 41,
+    kPhpMetadataNamespaceFieldNumber = 44,
+    kRubyPackageFieldNumber = 45,
+    kJavaMultipleFilesFieldNumber = 10,
+    kJavaGenerateEqualsAndHashFieldNumber = 20,
+    kJavaStringCheckUtf8FieldNumber = 27,
+    kCcGenericServicesFieldNumber = 16,
+    kJavaGenericServicesFieldNumber = 17,
+    kPyGenericServicesFieldNumber = 18,
+    kPhpGenericServicesFieldNumber = 42,
+    kDeprecatedFieldNumber = 23,
+    kOptimizeForFieldNumber = 9,
+    kCcEnableArenasFieldNumber = 31,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional string java_package = 1;
+  bool has_java_package() const;
+  private:
+  bool _internal_has_java_package() const;
+  public:
+  void clear_java_package();
+  const std::string& java_package() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_java_package(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_java_package();
+  PROTOBUF_NODISCARD std::string* release_java_package();
+  void set_allocated_java_package(std::string* java_package);
+  private:
+  const std::string& _internal_java_package() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_java_package(const std::string& value);
+  std::string* _internal_mutable_java_package();
+  public:
+
+  // optional string java_outer_classname = 8;
+  bool has_java_outer_classname() const;
+  private:
+  bool _internal_has_java_outer_classname() const;
+  public:
+  void clear_java_outer_classname();
+  const std::string& java_outer_classname() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_java_outer_classname(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_java_outer_classname();
+  PROTOBUF_NODISCARD std::string* release_java_outer_classname();
+  void set_allocated_java_outer_classname(std::string* java_outer_classname);
+  private:
+  const std::string& _internal_java_outer_classname() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_java_outer_classname(const std::string& value);
+  std::string* _internal_mutable_java_outer_classname();
+  public:
+
+  // optional string go_package = 11;
+  bool has_go_package() const;
+  private:
+  bool _internal_has_go_package() const;
+  public:
+  void clear_go_package();
+  const std::string& go_package() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_go_package(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_go_package();
+  PROTOBUF_NODISCARD std::string* release_go_package();
+  void set_allocated_go_package(std::string* go_package);
+  private:
+  const std::string& _internal_go_package() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_go_package(const std::string& value);
+  std::string* _internal_mutable_go_package();
+  public:
+
+  // optional string objc_class_prefix = 36;
+  bool has_objc_class_prefix() const;
+  private:
+  bool _internal_has_objc_class_prefix() const;
+  public:
+  void clear_objc_class_prefix();
+  const std::string& objc_class_prefix() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_objc_class_prefix(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_objc_class_prefix();
+  PROTOBUF_NODISCARD std::string* release_objc_class_prefix();
+  void set_allocated_objc_class_prefix(std::string* objc_class_prefix);
+  private:
+  const std::string& _internal_objc_class_prefix() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_objc_class_prefix(const std::string& value);
+  std::string* _internal_mutable_objc_class_prefix();
+  public:
+
+  // optional string csharp_namespace = 37;
+  bool has_csharp_namespace() const;
+  private:
+  bool _internal_has_csharp_namespace() const;
+  public:
+  void clear_csharp_namespace();
+  const std::string& csharp_namespace() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_csharp_namespace(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_csharp_namespace();
+  PROTOBUF_NODISCARD std::string* release_csharp_namespace();
+  void set_allocated_csharp_namespace(std::string* csharp_namespace);
+  private:
+  const std::string& _internal_csharp_namespace() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_csharp_namespace(const std::string& value);
+  std::string* _internal_mutable_csharp_namespace();
+  public:
+
+  // optional string swift_prefix = 39;
+  bool has_swift_prefix() const;
+  private:
+  bool _internal_has_swift_prefix() const;
+  public:
+  void clear_swift_prefix();
+  const std::string& swift_prefix() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_swift_prefix(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_swift_prefix();
+  PROTOBUF_NODISCARD std::string* release_swift_prefix();
+  void set_allocated_swift_prefix(std::string* swift_prefix);
+  private:
+  const std::string& _internal_swift_prefix() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_swift_prefix(const std::string& value);
+  std::string* _internal_mutable_swift_prefix();
+  public:
+
+  // optional string php_class_prefix = 40;
+  bool has_php_class_prefix() const;
+  private:
+  bool _internal_has_php_class_prefix() const;
+  public:
+  void clear_php_class_prefix();
+  const std::string& php_class_prefix() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_php_class_prefix(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_php_class_prefix();
+  PROTOBUF_NODISCARD std::string* release_php_class_prefix();
+  void set_allocated_php_class_prefix(std::string* php_class_prefix);
+  private:
+  const std::string& _internal_php_class_prefix() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_class_prefix(const std::string& value);
+  std::string* _internal_mutable_php_class_prefix();
+  public:
+
+  // optional string php_namespace = 41;
+  bool has_php_namespace() const;
+  private:
+  bool _internal_has_php_namespace() const;
+  public:
+  void clear_php_namespace();
+  const std::string& php_namespace() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_php_namespace(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_php_namespace();
+  PROTOBUF_NODISCARD std::string* release_php_namespace();
+  void set_allocated_php_namespace(std::string* php_namespace);
+  private:
+  const std::string& _internal_php_namespace() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_namespace(const std::string& value);
+  std::string* _internal_mutable_php_namespace();
+  public:
+
+  // optional string php_metadata_namespace = 44;
+  bool has_php_metadata_namespace() const;
+  private:
+  bool _internal_has_php_metadata_namespace() const;
+  public:
+  void clear_php_metadata_namespace();
+  const std::string& php_metadata_namespace() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_php_metadata_namespace(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_php_metadata_namespace();
+  PROTOBUF_NODISCARD std::string* release_php_metadata_namespace();
+  void set_allocated_php_metadata_namespace(std::string* php_metadata_namespace);
+  private:
+  const std::string& _internal_php_metadata_namespace() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_metadata_namespace(const std::string& value);
+  std::string* _internal_mutable_php_metadata_namespace();
+  public:
+
+  // optional string ruby_package = 45;
+  bool has_ruby_package() const;
+  private:
+  bool _internal_has_ruby_package() const;
+  public:
+  void clear_ruby_package();
+  const std::string& ruby_package() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ruby_package(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ruby_package();
+  PROTOBUF_NODISCARD std::string* release_ruby_package();
+  void set_allocated_ruby_package(std::string* ruby_package);
+  private:
+  const std::string& _internal_ruby_package() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ruby_package(const std::string& value);
+  std::string* _internal_mutable_ruby_package();
+  public:
+
+  // optional bool java_multiple_files = 10 [default = false];
+  bool has_java_multiple_files() const;
+  private:
+  bool _internal_has_java_multiple_files() const;
+  public:
+  void clear_java_multiple_files();
+  bool java_multiple_files() const;
+  void set_java_multiple_files(bool value);
+  private:
+  bool _internal_java_multiple_files() const;
+  void _internal_set_java_multiple_files(bool value);
+  public:
+
+  // optional bool java_generate_equals_and_hash = 20 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_java_generate_equals_and_hash() const;
+  private:
+  bool _internal_has_java_generate_equals_and_hash() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_java_generate_equals_and_hash();
+  PROTOBUF_DEPRECATED bool java_generate_equals_and_hash() const;
+  PROTOBUF_DEPRECATED void set_java_generate_equals_and_hash(bool value);
+  private:
+  bool _internal_java_generate_equals_and_hash() const;
+  void _internal_set_java_generate_equals_and_hash(bool value);
+  public:
+
+  // optional bool java_string_check_utf8 = 27 [default = false];
+  bool has_java_string_check_utf8() const;
+  private:
+  bool _internal_has_java_string_check_utf8() const;
+  public:
+  void clear_java_string_check_utf8();
+  bool java_string_check_utf8() const;
+  void set_java_string_check_utf8(bool value);
+  private:
+  bool _internal_java_string_check_utf8() const;
+  void _internal_set_java_string_check_utf8(bool value);
+  public:
+
+  // optional bool cc_generic_services = 16 [default = false];
+  bool has_cc_generic_services() const;
+  private:
+  bool _internal_has_cc_generic_services() const;
+  public:
+  void clear_cc_generic_services();
+  bool cc_generic_services() const;
+  void set_cc_generic_services(bool value);
+  private:
+  bool _internal_cc_generic_services() const;
+  void _internal_set_cc_generic_services(bool value);
+  public:
+
+  // optional bool java_generic_services = 17 [default = false];
+  bool has_java_generic_services() const;
+  private:
+  bool _internal_has_java_generic_services() const;
+  public:
+  void clear_java_generic_services();
+  bool java_generic_services() const;
+  void set_java_generic_services(bool value);
+  private:
+  bool _internal_java_generic_services() const;
+  void _internal_set_java_generic_services(bool value);
+  public:
+
+  // optional bool py_generic_services = 18 [default = false];
+  bool has_py_generic_services() const;
+  private:
+  bool _internal_has_py_generic_services() const;
+  public:
+  void clear_py_generic_services();
+  bool py_generic_services() const;
+  void set_py_generic_services(bool value);
+  private:
+  bool _internal_py_generic_services() const;
+  void _internal_set_py_generic_services(bool value);
+  public:
+
+  // optional bool php_generic_services = 42 [default = false];
+  bool has_php_generic_services() const;
+  private:
+  bool _internal_has_php_generic_services() const;
+  public:
+  void clear_php_generic_services();
+  bool php_generic_services() const;
+  void set_php_generic_services(bool value);
+  private:
+  bool _internal_php_generic_services() const;
+  void _internal_set_php_generic_services(bool value);
+  public:
+
+  // optional bool deprecated = 23 [default = false];
+  bool has_deprecated() const;
+  private:
+  bool _internal_has_deprecated() const;
+  public:
+  void clear_deprecated();
+  bool deprecated() const;
+  void set_deprecated(bool value);
+  private:
+  bool _internal_deprecated() const;
+  void _internal_set_deprecated(bool value);
+  public:
+
+  // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
+  bool has_optimize_for() const;
+  private:
+  bool _internal_has_optimize_for() const;
+  public:
+  void clear_optimize_for();
+  ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode optimize_for() const;
+  void set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode _internal_optimize_for() const;
+  void _internal_set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value);
+  public:
+
+  // optional bool cc_enable_arenas = 31 [default = true];
+  bool has_cc_enable_arenas() const;
+  private:
+  bool _internal_has_cc_enable_arenas() const;
+  public:
+  void clear_cc_enable_arenas();
+  bool cc_enable_arenas() const;
+  void set_cc_enable_arenas(bool value);
+  private:
+  bool _internal_cc_enable_arenas() const;
+  void _internal_set_cc_enable_arenas(bool value);
+  public:
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FileOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr java_package_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr java_outer_classname_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr go_package_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr objc_class_prefix_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr csharp_namespace_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr swift_prefix_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_class_prefix_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_namespace_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_metadata_namespace_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ruby_package_;
+    bool java_multiple_files_;
+    bool java_generate_equals_and_hash_;
+    bool java_string_check_utf8_;
+    bool cc_generic_services_;
+    bool java_generic_services_;
+    bool py_generic_services_;
+    bool php_generic_services_;
+    bool deprecated_;
+    int optimize_for_;
+    bool cc_enable_arenas_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT MessageOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MessageOptions) */ {
+ public:
+  inline MessageOptions() : MessageOptions(nullptr) {}
+  ~MessageOptions() override;
+  explicit PROTOBUF_CONSTEXPR MessageOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MessageOptions(const MessageOptions& from);
+  MessageOptions(MessageOptions&& from) noexcept
+    : MessageOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline MessageOptions& operator=(const MessageOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MessageOptions& operator=(MessageOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MessageOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MessageOptions* internal_default_instance() {
+    return reinterpret_cast<const MessageOptions*>(
+               &_MessageOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(MessageOptions& a, MessageOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MessageOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MessageOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MessageOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MessageOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MessageOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MessageOptions& from) {
+    MessageOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MessageOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.MessageOptions";
+  }
+  protected:
+  explicit MessageOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+    kMessageSetWireFormatFieldNumber = 1,
+    kNoStandardDescriptorAccessorFieldNumber = 2,
+    kDeprecatedFieldNumber = 3,
+    kMapEntryFieldNumber = 7,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool message_set_wire_format = 1 [default = false];
+  bool has_message_set_wire_format() const;
+  private:
+  bool _internal_has_message_set_wire_format() const;
+  public:
+  void clear_message_set_wire_format();
+  bool message_set_wire_format() const;
+  void set_message_set_wire_format(bool value);
+  private:
+  bool _internal_message_set_wire_format() const;
+  void _internal_set_message_set_wire_format(bool value);
+  public:
+
+  // optional bool no_standard_descriptor_accessor = 2 [default = false];
+  bool has_no_standard_descriptor_accessor() const;
+  private:
+  bool _internal_has_no_standard_descriptor_accessor() const;
+  public:
+  void clear_no_standard_descriptor_accessor();
+  bool no_standard_descriptor_accessor() const;
+  void set_no_standard_descriptor_accessor(bool value);
+  private:
+  bool _internal_no_standard_descriptor_accessor() const;
+  void _internal_set_no_standard_descriptor_accessor(bool value);
+  public:
+
+  // optional bool deprecated = 3 [default = false];
+  bool has_deprecated() const;
+  private:
+  bool _internal_has_deprecated() const;
+  public:
+  void clear_deprecated();
+  bool deprecated() const;
+  void set_deprecated(bool value);
+  private:
+  bool _internal_deprecated() const;
+  void _internal_set_deprecated(bool value);
+  public:
+
+  // optional bool map_entry = 7;
+  bool has_map_entry() const;
+  private:
+  bool _internal_has_map_entry() const;
+  public:
+  void clear_map_entry();
+  bool map_entry() const;
+  void set_map_entry(bool value);
+  private:
+  bool _internal_map_entry() const;
+  void _internal_set_map_entry(bool value);
+  public:
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    bool message_set_wire_format_;
+    bool no_standard_descriptor_accessor_;
+    bool deprecated_;
+    bool map_entry_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT FieldOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldOptions) */ {
+ public:
+  inline FieldOptions() : FieldOptions(nullptr) {}
+  ~FieldOptions() override;
+  explicit PROTOBUF_CONSTEXPR FieldOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FieldOptions(const FieldOptions& from);
+  FieldOptions(FieldOptions&& from) noexcept
+    : FieldOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline FieldOptions& operator=(const FieldOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FieldOptions& operator=(FieldOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FieldOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FieldOptions* internal_default_instance() {
+    return reinterpret_cast<const FieldOptions*>(
+               &_FieldOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(FieldOptions& a, FieldOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FieldOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FieldOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FieldOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FieldOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FieldOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FieldOptions& from) {
+    FieldOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FieldOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.FieldOptions";
+  }
+  protected:
+  explicit FieldOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FieldOptions_CType CType;
+  static constexpr CType STRING =
+    FieldOptions_CType_STRING;
+  static constexpr CType CORD =
+    FieldOptions_CType_CORD;
+  static constexpr CType STRING_PIECE =
+    FieldOptions_CType_STRING_PIECE;
+  static inline bool CType_IsValid(int value) {
+    return FieldOptions_CType_IsValid(value);
+  }
+  static constexpr CType CType_MIN =
+    FieldOptions_CType_CType_MIN;
+  static constexpr CType CType_MAX =
+    FieldOptions_CType_CType_MAX;
+  static constexpr int CType_ARRAYSIZE =
+    FieldOptions_CType_CType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CType_descriptor() {
+    return FieldOptions_CType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CType_Name.");
+    return FieldOptions_CType_Name(enum_t_value);
+  }
+  static inline bool CType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CType* value) {
+    return FieldOptions_CType_Parse(name, value);
+  }
+
+  typedef FieldOptions_JSType JSType;
+  static constexpr JSType JS_NORMAL =
+    FieldOptions_JSType_JS_NORMAL;
+  static constexpr JSType JS_STRING =
+    FieldOptions_JSType_JS_STRING;
+  static constexpr JSType JS_NUMBER =
+    FieldOptions_JSType_JS_NUMBER;
+  static inline bool JSType_IsValid(int value) {
+    return FieldOptions_JSType_IsValid(value);
+  }
+  static constexpr JSType JSType_MIN =
+    FieldOptions_JSType_JSType_MIN;
+  static constexpr JSType JSType_MAX =
+    FieldOptions_JSType_JSType_MAX;
+  static constexpr int JSType_ARRAYSIZE =
+    FieldOptions_JSType_JSType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  JSType_descriptor() {
+    return FieldOptions_JSType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& JSType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, JSType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function JSType_Name.");
+    return FieldOptions_JSType_Name(enum_t_value);
+  }
+  static inline bool JSType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      JSType* value) {
+    return FieldOptions_JSType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+    kCtypeFieldNumber = 1,
+    kJstypeFieldNumber = 6,
+    kPackedFieldNumber = 2,
+    kLazyFieldNumber = 5,
+    kUnverifiedLazyFieldNumber = 15,
+    kDeprecatedFieldNumber = 3,
+    kWeakFieldNumber = 10,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
+  bool has_ctype() const;
+  private:
+  bool _internal_has_ctype() const;
+  public:
+  void clear_ctype();
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType ctype() const;
+  void set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType _internal_ctype() const;
+  void _internal_set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value);
+  public:
+
+  // optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
+  bool has_jstype() const;
+  private:
+  bool _internal_has_jstype() const;
+  public:
+  void clear_jstype();
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType jstype() const;
+  void set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType _internal_jstype() const;
+  void _internal_set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value);
+  public:
+
+  // optional bool packed = 2;
+  bool has_packed() const;
+  private:
+  bool _internal_has_packed() const;
+  public:
+  void clear_packed();
+  bool packed() const;
+  void set_packed(bool value);
+  private:
+  bool _internal_packed() const;
+  void _internal_set_packed(bool value);
+  public:
+
+  // optional bool lazy = 5 [default = false];
+  bool has_lazy() const;
+  private:
+  bool _internal_has_lazy() const;
+  public:
+  void clear_lazy();
+  bool lazy() const;
+  void set_lazy(bool value);
+  private:
+  bool _internal_lazy() const;
+  void _internal_set_lazy(bool value);
+  public:
+
+  // optional bool unverified_lazy = 15 [default = false];
+  bool has_unverified_lazy() const;
+  private:
+  bool _internal_has_unverified_lazy() const;
+  public:
+  void clear_unverified_lazy();
+  bool unverified_lazy() const;
+  void set_unverified_lazy(bool value);
+  private:
+  bool _internal_unverified_lazy() const;
+  void _internal_set_unverified_lazy(bool value);
+  public:
+
+  // optional bool deprecated = 3 [default = false];
+  bool has_deprecated() const;
+  private:
+  bool _internal_has_deprecated() const;
+  public:
+  void clear_deprecated();
+  bool deprecated() const;
+  void set_deprecated(bool value);
+  private:
+  bool _internal_deprecated() const;
+  void _internal_set_deprecated(bool value);
+  public:
+
+  // optional bool weak = 10 [default = false];
+  bool has_weak() const;
+  private:
+  bool _internal_has_weak() const;
+  public:
+  void clear_weak();
+  bool weak() const;
+  void set_weak(bool value);
+  private:
+  bool _internal_weak() const;
+  void _internal_set_weak(bool value);
+  public:
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    int ctype_;
+    int jstype_;
+    bool packed_;
+    bool lazy_;
+    bool unverified_lazy_;
+    bool deprecated_;
+    bool weak_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT OneofOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofOptions) */ {
+ public:
+  inline OneofOptions() : OneofOptions(nullptr) {}
+  ~OneofOptions() override;
+  explicit PROTOBUF_CONSTEXPR OneofOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OneofOptions(const OneofOptions& from);
+  OneofOptions(OneofOptions&& from) noexcept
+    : OneofOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline OneofOptions& operator=(const OneofOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OneofOptions& operator=(OneofOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OneofOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OneofOptions* internal_default_instance() {
+    return reinterpret_cast<const OneofOptions*>(
+               &_OneofOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(OneofOptions& a, OneofOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OneofOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OneofOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  OneofOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<OneofOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OneofOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const OneofOptions& from) {
+    OneofOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OneofOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.OneofOptions";
+  }
+  protected:
+  explicit OneofOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.OneofOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumOptions) */ {
+ public:
+  inline EnumOptions() : EnumOptions(nullptr) {}
+  ~EnumOptions() override;
+  explicit PROTOBUF_CONSTEXPR EnumOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EnumOptions(const EnumOptions& from);
+  EnumOptions(EnumOptions&& from) noexcept
+    : EnumOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumOptions& operator=(const EnumOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EnumOptions& operator=(EnumOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EnumOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EnumOptions* internal_default_instance() {
+    return reinterpret_cast<const EnumOptions*>(
+               &_EnumOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(EnumOptions& a, EnumOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EnumOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EnumOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EnumOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EnumOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EnumOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EnumOptions& from) {
+    EnumOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EnumOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.EnumOptions";
+  }
+  protected:
+  explicit EnumOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+    kAllowAliasFieldNumber = 2,
+    kDeprecatedFieldNumber = 3,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool allow_alias = 2;
+  bool has_allow_alias() const;
+  private:
+  bool _internal_has_allow_alias() const;
+  public:
+  void clear_allow_alias();
+  bool allow_alias() const;
+  void set_allow_alias(bool value);
+  private:
+  bool _internal_allow_alias() const;
+  void _internal_set_allow_alias(bool value);
+  public:
+
+  // optional bool deprecated = 3 [default = false];
+  bool has_deprecated() const;
+  private:
+  bool _internal_has_deprecated() const;
+  public:
+  void clear_deprecated();
+  bool deprecated() const;
+  void set_deprecated(bool value);
+  private:
+  bool _internal_deprecated() const;
+  void _internal_set_deprecated(bool value);
+  public:
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    bool allow_alias_;
+    bool deprecated_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumValueOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueOptions) */ {
+ public:
+  inline EnumValueOptions() : EnumValueOptions(nullptr) {}
+  ~EnumValueOptions() override;
+  explicit PROTOBUF_CONSTEXPR EnumValueOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EnumValueOptions(const EnumValueOptions& from);
+  EnumValueOptions(EnumValueOptions&& from) noexcept
+    : EnumValueOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumValueOptions& operator=(const EnumValueOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EnumValueOptions& operator=(EnumValueOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EnumValueOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EnumValueOptions* internal_default_instance() {
+    return reinterpret_cast<const EnumValueOptions*>(
+               &_EnumValueOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(EnumValueOptions& a, EnumValueOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EnumValueOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EnumValueOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EnumValueOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EnumValueOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EnumValueOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EnumValueOptions& from) {
+    EnumValueOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EnumValueOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.EnumValueOptions";
+  }
+  protected:
+  explicit EnumValueOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+    kDeprecatedFieldNumber = 1,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool deprecated = 1 [default = false];
+  bool has_deprecated() const;
+  private:
+  bool _internal_has_deprecated() const;
+  public:
+  void clear_deprecated();
+  bool deprecated() const;
+  void set_deprecated(bool value);
+  private:
+  bool _internal_deprecated() const;
+  void _internal_set_deprecated(bool value);
+  public:
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    bool deprecated_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT ServiceOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */ {
+ public:
+  inline ServiceOptions() : ServiceOptions(nullptr) {}
+  ~ServiceOptions() override;
+  explicit PROTOBUF_CONSTEXPR ServiceOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ServiceOptions(const ServiceOptions& from);
+  ServiceOptions(ServiceOptions&& from) noexcept
+    : ServiceOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline ServiceOptions& operator=(const ServiceOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ServiceOptions& operator=(ServiceOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ServiceOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ServiceOptions* internal_default_instance() {
+    return reinterpret_cast<const ServiceOptions*>(
+               &_ServiceOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(ServiceOptions& a, ServiceOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ServiceOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ServiceOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ServiceOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ServiceOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ServiceOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ServiceOptions& from) {
+    ServiceOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ServiceOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.ServiceOptions";
+  }
+  protected:
+  explicit ServiceOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+    kDeprecatedFieldNumber = 33,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool deprecated = 33 [default = false];
+  bool has_deprecated() const;
+  private:
+  bool _internal_has_deprecated() const;
+  public:
+  void clear_deprecated();
+  bool deprecated() const;
+  void set_deprecated(bool value);
+  private:
+  bool _internal_deprecated() const;
+  void _internal_set_deprecated(bool value);
+  public:
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    bool deprecated_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT MethodOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodOptions) */ {
+ public:
+  inline MethodOptions() : MethodOptions(nullptr) {}
+  ~MethodOptions() override;
+  explicit PROTOBUF_CONSTEXPR MethodOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MethodOptions(const MethodOptions& from);
+  MethodOptions(MethodOptions&& from) noexcept
+    : MethodOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline MethodOptions& operator=(const MethodOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MethodOptions& operator=(MethodOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MethodOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MethodOptions* internal_default_instance() {
+    return reinterpret_cast<const MethodOptions*>(
+               &_MethodOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(MethodOptions& a, MethodOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MethodOptions* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MethodOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  MethodOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<MethodOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MethodOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const MethodOptions& from) {
+    MethodOptions::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MethodOptions* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.MethodOptions";
+  }
+  protected:
+  explicit MethodOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef MethodOptions_IdempotencyLevel IdempotencyLevel;
+  static constexpr IdempotencyLevel IDEMPOTENCY_UNKNOWN =
+    MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
+  static constexpr IdempotencyLevel NO_SIDE_EFFECTS =
+    MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS;
+  static constexpr IdempotencyLevel IDEMPOTENT =
+    MethodOptions_IdempotencyLevel_IDEMPOTENT;
+  static inline bool IdempotencyLevel_IsValid(int value) {
+    return MethodOptions_IdempotencyLevel_IsValid(value);
+  }
+  static constexpr IdempotencyLevel IdempotencyLevel_MIN =
+    MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN;
+  static constexpr IdempotencyLevel IdempotencyLevel_MAX =
+    MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX;
+  static constexpr int IdempotencyLevel_ARRAYSIZE =
+    MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  IdempotencyLevel_descriptor() {
+    return MethodOptions_IdempotencyLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& IdempotencyLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, IdempotencyLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function IdempotencyLevel_Name.");
+    return MethodOptions_IdempotencyLevel_Name(enum_t_value);
+  }
+  static inline bool IdempotencyLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      IdempotencyLevel* value) {
+    return MethodOptions_IdempotencyLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUninterpretedOptionFieldNumber = 999,
+    kDeprecatedFieldNumber = 33,
+    kIdempotencyLevelFieldNumber = 34,
+  };
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  private:
+  int _internal_uninterpreted_option_size() const;
+  public:
+  void clear_uninterpreted_option();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool deprecated = 33 [default = false];
+  bool has_deprecated() const;
+  private:
+  bool _internal_has_deprecated() const;
+  public:
+  void clear_deprecated();
+  bool deprecated() const;
+  void set_deprecated(bool value);
+  private:
+  bool _internal_deprecated() const;
+  void _internal_set_deprecated(bool value);
+  public:
+
+  // optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
+  bool has_idempotency_level() const;
+  private:
+  bool _internal_has_idempotency_level() const;
+  public:
+  void clear_idempotency_level();
+  ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel idempotency_level() const;
+  void set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel _internal_idempotency_level() const;
+  void _internal_set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value);
+  public:
+
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline bool HasExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.Has(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void ClearExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    _impl_._extensions_.ClearExtension(id.number());
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline int ExtensionSize(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _impl_._extensions_.ExtensionSize(id.number());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
+                                  id.default_value());
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
+                                    &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void UnsafeArenaSetAllocatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Singular::MutableType value) {
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
+                                               value, &_impl_._extensions_);
+
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  PROTOBUF_NODISCARD inline
+      typename _proto_TypeTraits::Singular::MutableType
+      ReleaseExtension(
+          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+              MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::Release(id.number(), _field_type,
+                                      &_impl_._extensions_);
+  }
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Singular::MutableType
+  UnsafeArenaReleaseExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
+                                                 &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) const {
+
+    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index) {
+
+    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void SetExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+    typename _proto_TypeTraits::Repeated::MutableType to_add =
+        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+    return to_add;
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline void AddExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
+      typename _proto_TypeTraits::Repeated::ConstType value) {
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
+                           &_impl_._extensions_);
+
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+  GetRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
+
+    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+  }
+
+  template <typename _proto_TypeTraits,
+            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
+            bool _is_packed>
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+  MutableRepeatedExtension(
+      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
+
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
+                                              _is_packed, &_impl_._extensions_);
+  }
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
+    bool deprecated_;
+    int idempotency_level_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT UninterpretedOption_NamePart final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */ {
+ public:
+  inline UninterpretedOption_NamePart() : UninterpretedOption_NamePart(nullptr) {}
+  ~UninterpretedOption_NamePart() override;
+  explicit PROTOBUF_CONSTEXPR UninterpretedOption_NamePart(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from);
+  UninterpretedOption_NamePart(UninterpretedOption_NamePart&& from) noexcept
+    : UninterpretedOption_NamePart() {
+    *this = ::std::move(from);
+  }
+
+  inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline UninterpretedOption_NamePart& operator=(UninterpretedOption_NamePart&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const UninterpretedOption_NamePart& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const UninterpretedOption_NamePart* internal_default_instance() {
+    return reinterpret_cast<const UninterpretedOption_NamePart*>(
+               &_UninterpretedOption_NamePart_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(UninterpretedOption_NamePart& a, UninterpretedOption_NamePart& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(UninterpretedOption_NamePart* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(UninterpretedOption_NamePart* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  UninterpretedOption_NamePart* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<UninterpretedOption_NamePart>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const UninterpretedOption_NamePart& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const UninterpretedOption_NamePart& from) {
+    UninterpretedOption_NamePart::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(UninterpretedOption_NamePart* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.UninterpretedOption.NamePart";
+  }
+  protected:
+  explicit UninterpretedOption_NamePart(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNamePartFieldNumber = 1,
+    kIsExtensionFieldNumber = 2,
+  };
+  // required string name_part = 1;
+  bool has_name_part() const;
+  private:
+  bool _internal_has_name_part() const;
+  public:
+  void clear_name_part();
+  const std::string& name_part() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name_part(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name_part();
+  PROTOBUF_NODISCARD std::string* release_name_part();
+  void set_allocated_name_part(std::string* name_part);
+  private:
+  const std::string& _internal_name_part() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name_part(const std::string& value);
+  std::string* _internal_mutable_name_part();
+  public:
+
+  // required bool is_extension = 2;
+  bool has_is_extension() const;
+  private:
+  bool _internal_has_is_extension() const;
+  public:
+  void clear_is_extension();
+  bool is_extension() const;
+  void set_is_extension(bool value);
+  private:
+  bool _internal_is_extension() const;
+  void _internal_set_is_extension(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart)
+ private:
+  class _Internal;
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_part_;
+    bool is_extension_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT UninterpretedOption final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption) */ {
+ public:
+  inline UninterpretedOption() : UninterpretedOption(nullptr) {}
+  ~UninterpretedOption() override;
+  explicit PROTOBUF_CONSTEXPR UninterpretedOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  UninterpretedOption(const UninterpretedOption& from);
+  UninterpretedOption(UninterpretedOption&& from) noexcept
+    : UninterpretedOption() {
+    *this = ::std::move(from);
+  }
+
+  inline UninterpretedOption& operator=(const UninterpretedOption& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline UninterpretedOption& operator=(UninterpretedOption&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const UninterpretedOption& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const UninterpretedOption* internal_default_instance() {
+    return reinterpret_cast<const UninterpretedOption*>(
+               &_UninterpretedOption_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  friend void swap(UninterpretedOption& a, UninterpretedOption& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(UninterpretedOption* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(UninterpretedOption* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  UninterpretedOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<UninterpretedOption>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const UninterpretedOption& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const UninterpretedOption& from) {
+    UninterpretedOption::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(UninterpretedOption* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.UninterpretedOption";
+  }
+  protected:
+  explicit UninterpretedOption(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef UninterpretedOption_NamePart NamePart;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 2,
+    kIdentifierValueFieldNumber = 3,
+    kStringValueFieldNumber = 7,
+    kAggregateValueFieldNumber = 8,
+    kPositiveIntValueFieldNumber = 4,
+    kNegativeIntValueFieldNumber = 5,
+    kDoubleValueFieldNumber = 6,
+  };
+  // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
+  int name_size() const;
+  private:
+  int _internal_name_size() const;
+  public:
+  void clear_name();
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* mutable_name(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >*
+      mutable_name();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& _internal_name(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* _internal_add_name();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& name(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* add_name();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >&
+      name() const;
+
+  // optional string identifier_value = 3;
+  bool has_identifier_value() const;
+  private:
+  bool _internal_has_identifier_value() const;
+  public:
+  void clear_identifier_value();
+  const std::string& identifier_value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_identifier_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_identifier_value();
+  PROTOBUF_NODISCARD std::string* release_identifier_value();
+  void set_allocated_identifier_value(std::string* identifier_value);
+  private:
+  const std::string& _internal_identifier_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_identifier_value(const std::string& value);
+  std::string* _internal_mutable_identifier_value();
+  public:
+
+  // optional bytes string_value = 7;
+  bool has_string_value() const;
+  private:
+  bool _internal_has_string_value() const;
+  public:
+  void clear_string_value();
+  const std::string& string_value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_string_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_string_value();
+  PROTOBUF_NODISCARD std::string* release_string_value();
+  void set_allocated_string_value(std::string* string_value);
+  private:
+  const std::string& _internal_string_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
+  std::string* _internal_mutable_string_value();
+  public:
+
+  // optional string aggregate_value = 8;
+  bool has_aggregate_value() const;
+  private:
+  bool _internal_has_aggregate_value() const;
+  public:
+  void clear_aggregate_value();
+  const std::string& aggregate_value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_aggregate_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_aggregate_value();
+  PROTOBUF_NODISCARD std::string* release_aggregate_value();
+  void set_allocated_aggregate_value(std::string* aggregate_value);
+  private:
+  const std::string& _internal_aggregate_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregate_value(const std::string& value);
+  std::string* _internal_mutable_aggregate_value();
+  public:
+
+  // optional uint64 positive_int_value = 4;
+  bool has_positive_int_value() const;
+  private:
+  bool _internal_has_positive_int_value() const;
+  public:
+  void clear_positive_int_value();
+  uint64_t positive_int_value() const;
+  void set_positive_int_value(uint64_t value);
+  private:
+  uint64_t _internal_positive_int_value() const;
+  void _internal_set_positive_int_value(uint64_t value);
+  public:
+
+  // optional int64 negative_int_value = 5;
+  bool has_negative_int_value() const;
+  private:
+  bool _internal_has_negative_int_value() const;
+  public:
+  void clear_negative_int_value();
+  int64_t negative_int_value() const;
+  void set_negative_int_value(int64_t value);
+  private:
+  int64_t _internal_negative_int_value() const;
+  void _internal_set_negative_int_value(int64_t value);
+  public:
+
+  // optional double double_value = 6;
+  bool has_double_value() const;
+  private:
+  bool _internal_has_double_value() const;
+  public:
+  void clear_double_value();
+  double double_value() const;
+  void set_double_value(double value);
+  private:
+  double _internal_double_value() const;
+  void _internal_set_double_value(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart > name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identifier_value_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregate_value_;
+    uint64_t positive_int_value_;
+    int64_t negative_int_value_;
+    double double_value_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT SourceCodeInfo_Location final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */ {
+ public:
+  inline SourceCodeInfo_Location() : SourceCodeInfo_Location(nullptr) {}
+  ~SourceCodeInfo_Location() override;
+  explicit PROTOBUF_CONSTEXPR SourceCodeInfo_Location(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SourceCodeInfo_Location(const SourceCodeInfo_Location& from);
+  SourceCodeInfo_Location(SourceCodeInfo_Location&& from) noexcept
+    : SourceCodeInfo_Location() {
+    *this = ::std::move(from);
+  }
+
+  inline SourceCodeInfo_Location& operator=(const SourceCodeInfo_Location& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SourceCodeInfo_Location& operator=(SourceCodeInfo_Location&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SourceCodeInfo_Location& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SourceCodeInfo_Location* internal_default_instance() {
+    return reinterpret_cast<const SourceCodeInfo_Location*>(
+               &_SourceCodeInfo_Location_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  friend void swap(SourceCodeInfo_Location& a, SourceCodeInfo_Location& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SourceCodeInfo_Location* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SourceCodeInfo_Location* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SourceCodeInfo_Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SourceCodeInfo_Location>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SourceCodeInfo_Location& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SourceCodeInfo_Location& from) {
+    SourceCodeInfo_Location::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SourceCodeInfo_Location* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.SourceCodeInfo.Location";
+  }
+  protected:
+  explicit SourceCodeInfo_Location(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPathFieldNumber = 1,
+    kSpanFieldNumber = 2,
+    kLeadingDetachedCommentsFieldNumber = 6,
+    kLeadingCommentsFieldNumber = 3,
+    kTrailingCommentsFieldNumber = 4,
+  };
+  // repeated int32 path = 1 [packed = true];
+  int path_size() const;
+  private:
+  int _internal_path_size() const;
+  public:
+  void clear_path();
+  private:
+  int32_t _internal_path(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_path() const;
+  void _internal_add_path(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_path();
+  public:
+  int32_t path(int index) const;
+  void set_path(int index, int32_t value);
+  void add_path(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      path() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_path();
+
+  // repeated int32 span = 2 [packed = true];
+  int span_size() const;
+  private:
+  int _internal_span_size() const;
+  public:
+  void clear_span();
+  private:
+  int32_t _internal_span(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_span() const;
+  void _internal_add_span(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_span();
+  public:
+  int32_t span(int index) const;
+  void set_span(int index, int32_t value);
+  void add_span(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      span() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_span();
+
+  // repeated string leading_detached_comments = 6;
+  int leading_detached_comments_size() const;
+  private:
+  int _internal_leading_detached_comments_size() const;
+  public:
+  void clear_leading_detached_comments();
+  const std::string& leading_detached_comments(int index) const;
+  std::string* mutable_leading_detached_comments(int index);
+  void set_leading_detached_comments(int index, const std::string& value);
+  void set_leading_detached_comments(int index, std::string&& value);
+  void set_leading_detached_comments(int index, const char* value);
+  void set_leading_detached_comments(int index, const char* value, size_t size);
+  std::string* add_leading_detached_comments();
+  void add_leading_detached_comments(const std::string& value);
+  void add_leading_detached_comments(std::string&& value);
+  void add_leading_detached_comments(const char* value);
+  void add_leading_detached_comments(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& leading_detached_comments() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_leading_detached_comments();
+  private:
+  const std::string& _internal_leading_detached_comments(int index) const;
+  std::string* _internal_add_leading_detached_comments();
+  public:
+
+  // optional string leading_comments = 3;
+  bool has_leading_comments() const;
+  private:
+  bool _internal_has_leading_comments() const;
+  public:
+  void clear_leading_comments();
+  const std::string& leading_comments() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_leading_comments(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_leading_comments();
+  PROTOBUF_NODISCARD std::string* release_leading_comments();
+  void set_allocated_leading_comments(std::string* leading_comments);
+  private:
+  const std::string& _internal_leading_comments() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_leading_comments(const std::string& value);
+  std::string* _internal_mutable_leading_comments();
+  public:
+
+  // optional string trailing_comments = 4;
+  bool has_trailing_comments() const;
+  private:
+  bool _internal_has_trailing_comments() const;
+  public:
+  void clear_trailing_comments();
+  const std::string& trailing_comments() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_trailing_comments(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_trailing_comments();
+  PROTOBUF_NODISCARD std::string* release_trailing_comments();
+  void set_allocated_trailing_comments(std::string* trailing_comments);
+  private:
+  const std::string& _internal_trailing_comments() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_trailing_comments(const std::string& value);
+  std::string* _internal_mutable_trailing_comments();
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo.Location)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > path_;
+    mutable std::atomic<int> _path_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > span_;
+    mutable std::atomic<int> _span_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> leading_detached_comments_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr leading_comments_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trailing_comments_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT SourceCodeInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo) */ {
+ public:
+  inline SourceCodeInfo() : SourceCodeInfo(nullptr) {}
+  ~SourceCodeInfo() override;
+  explicit PROTOBUF_CONSTEXPR SourceCodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SourceCodeInfo(const SourceCodeInfo& from);
+  SourceCodeInfo(SourceCodeInfo&& from) noexcept
+    : SourceCodeInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SourceCodeInfo& operator=(const SourceCodeInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SourceCodeInfo& operator=(SourceCodeInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SourceCodeInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SourceCodeInfo* internal_default_instance() {
+    return reinterpret_cast<const SourceCodeInfo*>(
+               &_SourceCodeInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    24;
+
+  friend void swap(SourceCodeInfo& a, SourceCodeInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SourceCodeInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SourceCodeInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SourceCodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SourceCodeInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SourceCodeInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SourceCodeInfo& from) {
+    SourceCodeInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SourceCodeInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.SourceCodeInfo";
+  }
+  protected:
+  explicit SourceCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SourceCodeInfo_Location Location;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLocationFieldNumber = 1,
+  };
+  // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
+  int location_size() const;
+  private:
+  int _internal_location_size() const;
+  public:
+  void clear_location();
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* mutable_location(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >*
+      mutable_location();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& _internal_location(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* _internal_add_location();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& location(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* add_location();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >&
+      location() const;
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location > location_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo.Annotation) */ {
+ public:
+  inline GeneratedCodeInfo_Annotation() : GeneratedCodeInfo_Annotation(nullptr) {}
+  ~GeneratedCodeInfo_Annotation() override;
+  explicit PROTOBUF_CONSTEXPR GeneratedCodeInfo_Annotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GeneratedCodeInfo_Annotation(const GeneratedCodeInfo_Annotation& from);
+  GeneratedCodeInfo_Annotation(GeneratedCodeInfo_Annotation&& from) noexcept
+    : GeneratedCodeInfo_Annotation() {
+    *this = ::std::move(from);
+  }
+
+  inline GeneratedCodeInfo_Annotation& operator=(const GeneratedCodeInfo_Annotation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GeneratedCodeInfo_Annotation& operator=(GeneratedCodeInfo_Annotation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GeneratedCodeInfo_Annotation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GeneratedCodeInfo_Annotation* internal_default_instance() {
+    return reinterpret_cast<const GeneratedCodeInfo_Annotation*>(
+               &_GeneratedCodeInfo_Annotation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    25;
+
+  friend void swap(GeneratedCodeInfo_Annotation& a, GeneratedCodeInfo_Annotation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GeneratedCodeInfo_Annotation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GeneratedCodeInfo_Annotation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GeneratedCodeInfo_Annotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GeneratedCodeInfo_Annotation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GeneratedCodeInfo_Annotation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GeneratedCodeInfo_Annotation& from) {
+    GeneratedCodeInfo_Annotation::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GeneratedCodeInfo_Annotation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.GeneratedCodeInfo.Annotation";
+  }
+  protected:
+  explicit GeneratedCodeInfo_Annotation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPathFieldNumber = 1,
+    kSourceFileFieldNumber = 2,
+    kBeginFieldNumber = 3,
+    kEndFieldNumber = 4,
+  };
+  // repeated int32 path = 1 [packed = true];
+  int path_size() const;
+  private:
+  int _internal_path_size() const;
+  public:
+  void clear_path();
+  private:
+  int32_t _internal_path(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_path() const;
+  void _internal_add_path(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_path();
+  public:
+  int32_t path(int index) const;
+  void set_path(int index, int32_t value);
+  void add_path(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      path() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_path();
+
+  // optional string source_file = 2;
+  bool has_source_file() const;
+  private:
+  bool _internal_has_source_file() const;
+  public:
+  void clear_source_file();
+  const std::string& source_file() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_source_file(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_source_file();
+  PROTOBUF_NODISCARD std::string* release_source_file();
+  void set_allocated_source_file(std::string* source_file);
+  private:
+  const std::string& _internal_source_file() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source_file(const std::string& value);
+  std::string* _internal_mutable_source_file();
+  public:
+
+  // optional int32 begin = 3;
+  bool has_begin() const;
+  private:
+  bool _internal_has_begin() const;
+  public:
+  void clear_begin();
+  int32_t begin() const;
+  void set_begin(int32_t value);
+  private:
+  int32_t _internal_begin() const;
+  void _internal_set_begin(int32_t value);
+  public:
+
+  // optional int32 end = 4;
+  bool has_end() const;
+  private:
+  bool _internal_has_end() const;
+  public:
+  void clear_end();
+  int32_t end() const;
+  void set_end(int32_t value);
+  private:
+  int32_t _internal_end() const;
+  void _internal_set_end(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo.Annotation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > path_;
+    mutable std::atomic<int> _path_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_file_;
+    int32_t begin_;
+    int32_t end_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT GeneratedCodeInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo) */ {
+ public:
+  inline GeneratedCodeInfo() : GeneratedCodeInfo(nullptr) {}
+  ~GeneratedCodeInfo() override;
+  explicit PROTOBUF_CONSTEXPR GeneratedCodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  GeneratedCodeInfo(const GeneratedCodeInfo& from);
+  GeneratedCodeInfo(GeneratedCodeInfo&& from) noexcept
+    : GeneratedCodeInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GeneratedCodeInfo& operator=(const GeneratedCodeInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline GeneratedCodeInfo& operator=(GeneratedCodeInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const GeneratedCodeInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const GeneratedCodeInfo* internal_default_instance() {
+    return reinterpret_cast<const GeneratedCodeInfo*>(
+               &_GeneratedCodeInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    26;
+
+  friend void swap(GeneratedCodeInfo& a, GeneratedCodeInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(GeneratedCodeInfo* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(GeneratedCodeInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  GeneratedCodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<GeneratedCodeInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const GeneratedCodeInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const GeneratedCodeInfo& from) {
+    GeneratedCodeInfo::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(GeneratedCodeInfo* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.GeneratedCodeInfo";
+  }
+  protected:
+  explicit GeneratedCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef GeneratedCodeInfo_Annotation Annotation;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAnnotationFieldNumber = 1,
+  };
+  // repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
+  int annotation_size() const;
+  private:
+  int _internal_annotation_size() const;
+  public:
+  void clear_annotation();
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* mutable_annotation(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >*
+      mutable_annotation();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& _internal_annotation(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* _internal_add_annotation();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& annotation(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* add_annotation();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >&
+      annotation() const;
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation > annotation_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// FileDescriptorSet
+
+// repeated .google.protobuf.FileDescriptorProto file = 1;
+inline int FileDescriptorSet::_internal_file_size() const {
+  return _impl_.file_.size();
+}
+inline int FileDescriptorSet::file_size() const {
+  return _internal_file_size();
+}
+inline void FileDescriptorSet::clear_file() {
+  _impl_.file_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorSet.file)
+  return _impl_.file_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
+FileDescriptorSet::mutable_file() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorSet.file)
+  return &_impl_.file_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& FileDescriptorSet::_internal_file(int index) const {
+  return _impl_.file_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& FileDescriptorSet::file(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorSet.file)
+  return _internal_file(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::_internal_add_file() {
+  return _impl_.file_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::add_file() {
+  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _add = _internal_add_file();
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorSet.file)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
+FileDescriptorSet::file() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorSet.file)
+  return _impl_.file_;
+}
+
+// -------------------------------------------------------------------
+
+// FileDescriptorProto
+
+// optional string name = 1;
+inline bool FileDescriptorProto::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool FileDescriptorProto::has_name() const {
+  return _internal_has_name();
+}
+inline void FileDescriptorProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& FileDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.name)
+}
+inline std::string* FileDescriptorProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.name)
+  return _s;
+}
+inline const std::string& FileDescriptorProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void FileDescriptorProto::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileDescriptorProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.name)
+}
+
+// optional string package = 2;
+inline bool FileDescriptorProto::_internal_has_package() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool FileDescriptorProto::has_package() const {
+  return _internal_has_package();
+}
+inline void FileDescriptorProto::clear_package() {
+  _impl_.package_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& FileDescriptorProto::package() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.package)
+  return _internal_package();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileDescriptorProto::set_package(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.package)
+}
+inline std::string* FileDescriptorProto::mutable_package() {
+  std::string* _s = _internal_mutable_package();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.package)
+  return _s;
+}
+inline const std::string& FileDescriptorProto::_internal_package() const {
+  return _impl_.package_.Get();
+}
+inline void FileDescriptorProto::_internal_set_package(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.package_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::_internal_mutable_package() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.package_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::release_package() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.package)
+  if (!_internal_has_package()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.package_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.package_.IsDefault()) {
+    _impl_.package_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileDescriptorProto::set_allocated_package(std::string* package) {
+  if (package != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.package_.SetAllocated(package, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.package_.IsDefault()) {
+    _impl_.package_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.package)
+}
+
+// repeated string dependency = 3;
+inline int FileDescriptorProto::_internal_dependency_size() const {
+  return _impl_.dependency_.size();
+}
+inline int FileDescriptorProto::dependency_size() const {
+  return _internal_dependency_size();
+}
+inline void FileDescriptorProto::clear_dependency() {
+  _impl_.dependency_.Clear();
+}
+inline std::string* FileDescriptorProto::add_dependency() {
+  std::string* _s = _internal_add_dependency();
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.FileDescriptorProto.dependency)
+  return _s;
+}
+inline const std::string& FileDescriptorProto::_internal_dependency(int index) const {
+  return _impl_.dependency_.Get(index);
+}
+inline const std::string& FileDescriptorProto::dependency(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.dependency)
+  return _internal_dependency(index);
+}
+inline std::string* FileDescriptorProto::mutable_dependency(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.dependency)
+  return _impl_.dependency_.Mutable(index);
+}
+inline void FileDescriptorProto::set_dependency(int index, const std::string& value) {
+  _impl_.dependency_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::set_dependency(int index, std::string&& value) {
+  _impl_.dependency_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::set_dependency(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.dependency_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) {
+  _impl_.dependency_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.dependency)
+}
+inline std::string* FileDescriptorProto::_internal_add_dependency() {
+  return _impl_.dependency_.Add();
+}
+inline void FileDescriptorProto::add_dependency(const std::string& value) {
+  _impl_.dependency_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::add_dependency(std::string&& value) {
+  _impl_.dependency_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::add_dependency(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.dependency_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::add_dependency(const char* value, size_t size) {
+  _impl_.dependency_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.FileDescriptorProto.dependency)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+FileDescriptorProto::dependency() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.dependency)
+  return _impl_.dependency_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+FileDescriptorProto::mutable_dependency() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.dependency)
+  return &_impl_.dependency_;
+}
+
+// repeated int32 public_dependency = 10;
+inline int FileDescriptorProto::_internal_public_dependency_size() const {
+  return _impl_.public_dependency_.size();
+}
+inline int FileDescriptorProto::public_dependency_size() const {
+  return _internal_public_dependency_size();
+}
+inline void FileDescriptorProto::clear_public_dependency() {
+  _impl_.public_dependency_.Clear();
+}
+inline int32_t FileDescriptorProto::_internal_public_dependency(int index) const {
+  return _impl_.public_dependency_.Get(index);
+}
+inline int32_t FileDescriptorProto::public_dependency(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.public_dependency)
+  return _internal_public_dependency(index);
+}
+inline void FileDescriptorProto::set_public_dependency(int index, int32_t value) {
+  _impl_.public_dependency_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.public_dependency)
+}
+inline void FileDescriptorProto::_internal_add_public_dependency(int32_t value) {
+  _impl_.public_dependency_.Add(value);
+}
+inline void FileDescriptorProto::add_public_dependency(int32_t value) {
+  _internal_add_public_dependency(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.public_dependency)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+FileDescriptorProto::_internal_public_dependency() const {
+  return _impl_.public_dependency_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+FileDescriptorProto::public_dependency() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.public_dependency)
+  return _internal_public_dependency();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+FileDescriptorProto::_internal_mutable_public_dependency() {
+  return &_impl_.public_dependency_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+FileDescriptorProto::mutable_public_dependency() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.public_dependency)
+  return _internal_mutable_public_dependency();
+}
+
+// repeated int32 weak_dependency = 11;
+inline int FileDescriptorProto::_internal_weak_dependency_size() const {
+  return _impl_.weak_dependency_.size();
+}
+inline int FileDescriptorProto::weak_dependency_size() const {
+  return _internal_weak_dependency_size();
+}
+inline void FileDescriptorProto::clear_weak_dependency() {
+  _impl_.weak_dependency_.Clear();
+}
+inline int32_t FileDescriptorProto::_internal_weak_dependency(int index) const {
+  return _impl_.weak_dependency_.Get(index);
+}
+inline int32_t FileDescriptorProto::weak_dependency(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.weak_dependency)
+  return _internal_weak_dependency(index);
+}
+inline void FileDescriptorProto::set_weak_dependency(int index, int32_t value) {
+  _impl_.weak_dependency_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.weak_dependency)
+}
+inline void FileDescriptorProto::_internal_add_weak_dependency(int32_t value) {
+  _impl_.weak_dependency_.Add(value);
+}
+inline void FileDescriptorProto::add_weak_dependency(int32_t value) {
+  _internal_add_weak_dependency(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.weak_dependency)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+FileDescriptorProto::_internal_weak_dependency() const {
+  return _impl_.weak_dependency_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+FileDescriptorProto::weak_dependency() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.weak_dependency)
+  return _internal_weak_dependency();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+FileDescriptorProto::_internal_mutable_weak_dependency() {
+  return &_impl_.weak_dependency_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+FileDescriptorProto::mutable_weak_dependency() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.weak_dependency)
+  return _internal_mutable_weak_dependency();
+}
+
+// repeated .google.protobuf.DescriptorProto message_type = 4;
+inline int FileDescriptorProto::_internal_message_type_size() const {
+  return _impl_.message_type_.size();
+}
+inline int FileDescriptorProto::message_type_size() const {
+  return _internal_message_type_size();
+}
+inline void FileDescriptorProto::clear_message_type() {
+  _impl_.message_type_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.message_type)
+  return _impl_.message_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >*
+FileDescriptorProto::mutable_message_type() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.message_type)
+  return &_impl_.message_type_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& FileDescriptorProto::_internal_message_type(int index) const {
+  return _impl_.message_type_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& FileDescriptorProto::message_type(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.message_type)
+  return _internal_message_type(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::_internal_add_message_type() {
+  return _impl_.message_type_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::add_message_type() {
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _add = _internal_add_message_type();
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.message_type)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >&
+FileDescriptorProto::message_type() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.message_type)
+  return _impl_.message_type_;
+}
+
+// repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
+inline int FileDescriptorProto::_internal_enum_type_size() const {
+  return _impl_.enum_type_.size();
+}
+inline int FileDescriptorProto::enum_type_size() const {
+  return _internal_enum_type_size();
+}
+inline void FileDescriptorProto::clear_enum_type() {
+  _impl_.enum_type_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.enum_type)
+  return _impl_.enum_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
+FileDescriptorProto::mutable_enum_type() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.enum_type)
+  return &_impl_.enum_type_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& FileDescriptorProto::_internal_enum_type(int index) const {
+  return _impl_.enum_type_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.enum_type)
+  return _internal_enum_type(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::_internal_add_enum_type() {
+  return _impl_.enum_type_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::add_enum_type() {
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _add = _internal_add_enum_type();
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.enum_type)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
+FileDescriptorProto::enum_type() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.enum_type)
+  return _impl_.enum_type_;
+}
+
+// repeated .google.protobuf.ServiceDescriptorProto service = 6;
+inline int FileDescriptorProto::_internal_service_size() const {
+  return _impl_.service_.size();
+}
+inline int FileDescriptorProto::service_size() const {
+  return _internal_service_size();
+}
+inline void FileDescriptorProto::clear_service() {
+  _impl_.service_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.service)
+  return _impl_.service_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >*
+FileDescriptorProto::mutable_service() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.service)
+  return &_impl_.service_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& FileDescriptorProto::_internal_service(int index) const {
+  return _impl_.service_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& FileDescriptorProto::service(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.service)
+  return _internal_service(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::_internal_add_service() {
+  return _impl_.service_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::add_service() {
+  ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* _add = _internal_add_service();
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.service)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >&
+FileDescriptorProto::service() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.service)
+  return _impl_.service_;
+}
+
+// repeated .google.protobuf.FieldDescriptorProto extension = 7;
+inline int FileDescriptorProto::_internal_extension_size() const {
+  return _impl_.extension_.size();
+}
+inline int FileDescriptorProto::extension_size() const {
+  return _internal_extension_size();
+}
+inline void FileDescriptorProto::clear_extension() {
+  _impl_.extension_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.extension)
+  return _impl_.extension_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
+FileDescriptorProto::mutable_extension() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.extension)
+  return &_impl_.extension_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& FileDescriptorProto::_internal_extension(int index) const {
+  return _impl_.extension_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& FileDescriptorProto::extension(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.extension)
+  return _internal_extension(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::_internal_add_extension() {
+  return _impl_.extension_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::add_extension() {
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_extension();
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.extension)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
+FileDescriptorProto::extension() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.extension)
+  return _impl_.extension_;
+}
+
+// optional .google.protobuf.FileOptions options = 8;
+inline bool FileDescriptorProto::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool FileDescriptorProto::has_options() const {
+  return _internal_has_options();
+}
+inline void FileDescriptorProto::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FileOptions& FileDescriptorProto::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::FileOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FileOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_FileOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FileOptions& FileDescriptorProto::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.options)
+  return _internal_options();
+}
+inline void FileDescriptorProto::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::PROTOBUF_NAMESPACE_ID::FileOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.options)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::PROTOBUF_NAMESPACE_ID::FileOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::FileOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.options)
+  return _msg;
+}
+inline void FileDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::FileOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.options)
+}
+
+// optional .google.protobuf.SourceCodeInfo source_code_info = 9;
+inline bool FileDescriptorProto::_internal_has_source_code_info() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.source_code_info_ != nullptr);
+  return value;
+}
+inline bool FileDescriptorProto::has_source_code_info() const {
+  return _internal_has_source_code_info();
+}
+inline void FileDescriptorProto::clear_source_code_info() {
+  if (_impl_.source_code_info_ != nullptr) _impl_.source_code_info_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& FileDescriptorProto::_internal_source_code_info() const {
+  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* p = _impl_.source_code_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo&>(
+      ::PROTOBUF_NAMESPACE_ID::_SourceCodeInfo_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& FileDescriptorProto::source_code_info() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.source_code_info)
+  return _internal_source_code_info();
+}
+inline void FileDescriptorProto::unsafe_arena_set_allocated_source_code_info(
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_code_info_);
+  }
+  _impl_.source_code_info_ = source_code_info;
+  if (source_code_info) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::release_source_code_info() {
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* temp = _impl_.source_code_info_;
+  _impl_.source_code_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::unsafe_arena_release_source_code_info() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.source_code_info)
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* temp = _impl_.source_code_info_;
+  _impl_.source_code_info_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::_internal_mutable_source_code_info() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  if (_impl_.source_code_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(GetArenaForAllocation());
+    _impl_.source_code_info_ = p;
+  }
+  return _impl_.source_code_info_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::mutable_source_code_info() {
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* _msg = _internal_mutable_source_code_info();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.source_code_info)
+  return _msg;
+}
+inline void FileDescriptorProto::set_allocated_source_code_info(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.source_code_info_;
+  }
+  if (source_code_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(source_code_info);
+    if (message_arena != submessage_arena) {
+      source_code_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, source_code_info, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.source_code_info_ = source_code_info;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
+}
+
+// optional string syntax = 12;
+inline bool FileDescriptorProto::_internal_has_syntax() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool FileDescriptorProto::has_syntax() const {
+  return _internal_has_syntax();
+}
+inline void FileDescriptorProto::clear_syntax() {
+  _impl_.syntax_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& FileDescriptorProto::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.syntax)
+  return _internal_syntax();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileDescriptorProto::set_syntax(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.syntax_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.syntax)
+}
+inline std::string* FileDescriptorProto::mutable_syntax() {
+  std::string* _s = _internal_mutable_syntax();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.syntax)
+  return _s;
+}
+inline const std::string& FileDescriptorProto::_internal_syntax() const {
+  return _impl_.syntax_.Get();
+}
+inline void FileDescriptorProto::_internal_set_syntax(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.syntax_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::_internal_mutable_syntax() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.syntax_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::release_syntax() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.syntax)
+  if (!_internal_has_syntax()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.syntax_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.syntax_.IsDefault()) {
+    _impl_.syntax_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileDescriptorProto::set_allocated_syntax(std::string* syntax) {
+  if (syntax != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.syntax_.SetAllocated(syntax, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.syntax_.IsDefault()) {
+    _impl_.syntax_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// DescriptorProto_ExtensionRange
+
+// optional int32 start = 1;
+inline bool DescriptorProto_ExtensionRange::_internal_has_start() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DescriptorProto_ExtensionRange::has_start() const {
+  return _internal_has_start();
+}
+inline void DescriptorProto_ExtensionRange::clear_start() {
+  _impl_.start_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t DescriptorProto_ExtensionRange::_internal_start() const {
+  return _impl_.start_;
+}
+inline int32_t DescriptorProto_ExtensionRange::start() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.start)
+  return _internal_start();
+}
+inline void DescriptorProto_ExtensionRange::_internal_set_start(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.start_ = value;
+}
+inline void DescriptorProto_ExtensionRange::set_start(int32_t value) {
+  _internal_set_start(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.start)
+}
+
+// optional int32 end = 2;
+inline bool DescriptorProto_ExtensionRange::_internal_has_end() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool DescriptorProto_ExtensionRange::has_end() const {
+  return _internal_has_end();
+}
+inline void DescriptorProto_ExtensionRange::clear_end() {
+  _impl_.end_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t DescriptorProto_ExtensionRange::_internal_end() const {
+  return _impl_.end_;
+}
+inline int32_t DescriptorProto_ExtensionRange::end() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.end)
+  return _internal_end();
+}
+inline void DescriptorProto_ExtensionRange::_internal_set_end(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.end_ = value;
+}
+inline void DescriptorProto_ExtensionRange::set_end(int32_t value) {
+  _internal_set_end(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.end)
+}
+
+// optional .google.protobuf.ExtensionRangeOptions options = 3;
+inline bool DescriptorProto_ExtensionRange::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool DescriptorProto_ExtensionRange::has_options() const {
+  return _internal_has_options();
+}
+inline void DescriptorProto_ExtensionRange::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& DescriptorProto_ExtensionRange::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_ExtensionRangeOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& DescriptorProto_ExtensionRange::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.options)
+  return _internal_options();
+}
+inline void DescriptorProto_ExtensionRange::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.ExtensionRange.options)
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.ExtensionRange.options)
+  return _msg;
+}
+inline void DescriptorProto_ExtensionRange::set_allocated_options(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
+}
+
+// -------------------------------------------------------------------
+
+// DescriptorProto_ReservedRange
+
+// optional int32 start = 1;
+inline bool DescriptorProto_ReservedRange::_internal_has_start() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DescriptorProto_ReservedRange::has_start() const {
+  return _internal_has_start();
+}
+inline void DescriptorProto_ReservedRange::clear_start() {
+  _impl_.start_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int32_t DescriptorProto_ReservedRange::_internal_start() const {
+  return _impl_.start_;
+}
+inline int32_t DescriptorProto_ReservedRange::start() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.start)
+  return _internal_start();
+}
+inline void DescriptorProto_ReservedRange::_internal_set_start(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.start_ = value;
+}
+inline void DescriptorProto_ReservedRange::set_start(int32_t value) {
+  _internal_set_start(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.start)
+}
+
+// optional int32 end = 2;
+inline bool DescriptorProto_ReservedRange::_internal_has_end() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DescriptorProto_ReservedRange::has_end() const {
+  return _internal_has_end();
+}
+inline void DescriptorProto_ReservedRange::clear_end() {
+  _impl_.end_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t DescriptorProto_ReservedRange::_internal_end() const {
+  return _impl_.end_;
+}
+inline int32_t DescriptorProto_ReservedRange::end() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.end)
+  return _internal_end();
+}
+inline void DescriptorProto_ReservedRange::_internal_set_end(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.end_ = value;
+}
+inline void DescriptorProto_ReservedRange::set_end(int32_t value) {
+  _internal_set_end(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.end)
+}
+
+// -------------------------------------------------------------------
+
+// DescriptorProto
+
+// optional string name = 1;
+inline bool DescriptorProto::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DescriptorProto::has_name() const {
+  return _internal_has_name();
+}
+inline void DescriptorProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.name)
+}
+inline std::string* DescriptorProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.name)
+  return _s;
+}
+inline const std::string& DescriptorProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void DescriptorProto::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* DescriptorProto::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void DescriptorProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.name)
+}
+
+// repeated .google.protobuf.FieldDescriptorProto field = 2;
+inline int DescriptorProto::_internal_field_size() const {
+  return _impl_.field_.size();
+}
+inline int DescriptorProto::field_size() const {
+  return _internal_field_size();
+}
+inline void DescriptorProto::clear_field() {
+  _impl_.field_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::mutable_field(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.field)
+  return _impl_.field_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
+DescriptorProto::mutable_field() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.field)
+  return &_impl_.field_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::_internal_field(int index) const {
+  return _impl_.field_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::field(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.field)
+  return _internal_field(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::_internal_add_field() {
+  return _impl_.field_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::add_field() {
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_field();
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.field)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
+DescriptorProto::field() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.field)
+  return _impl_.field_;
+}
+
+// repeated .google.protobuf.FieldDescriptorProto extension = 6;
+inline int DescriptorProto::_internal_extension_size() const {
+  return _impl_.extension_.size();
+}
+inline int DescriptorProto::extension_size() const {
+  return _internal_extension_size();
+}
+inline void DescriptorProto::clear_extension() {
+  _impl_.extension_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension)
+  return _impl_.extension_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
+DescriptorProto::mutable_extension() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension)
+  return &_impl_.extension_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::_internal_extension(int index) const {
+  return _impl_.extension_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::extension(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension)
+  return _internal_extension(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::_internal_add_extension() {
+  return _impl_.extension_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::add_extension() {
+  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_extension();
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
+DescriptorProto::extension() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension)
+  return _impl_.extension_;
+}
+
+// repeated .google.protobuf.DescriptorProto nested_type = 3;
+inline int DescriptorProto::_internal_nested_type_size() const {
+  return _impl_.nested_type_.size();
+}
+inline int DescriptorProto::nested_type_size() const {
+  return _internal_nested_type_size();
+}
+inline void DescriptorProto::clear_nested_type() {
+  _impl_.nested_type_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::mutable_nested_type(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.nested_type)
+  return _impl_.nested_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >*
+DescriptorProto::mutable_nested_type() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.nested_type)
+  return &_impl_.nested_type_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& DescriptorProto::_internal_nested_type(int index) const {
+  return _impl_.nested_type_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& DescriptorProto::nested_type(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.nested_type)
+  return _internal_nested_type(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::_internal_add_nested_type() {
+  return _impl_.nested_type_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::add_nested_type() {
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _add = _internal_add_nested_type();
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.nested_type)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >&
+DescriptorProto::nested_type() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.nested_type)
+  return _impl_.nested_type_;
+}
+
+// repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
+inline int DescriptorProto::_internal_enum_type_size() const {
+  return _impl_.enum_type_.size();
+}
+inline int DescriptorProto::enum_type_size() const {
+  return _internal_enum_type_size();
+}
+inline void DescriptorProto::clear_enum_type() {
+  _impl_.enum_type_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.enum_type)
+  return _impl_.enum_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
+DescriptorProto::mutable_enum_type() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.enum_type)
+  return &_impl_.enum_type_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& DescriptorProto::_internal_enum_type(int index) const {
+  return _impl_.enum_type_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& DescriptorProto::enum_type(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.enum_type)
+  return _internal_enum_type(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::_internal_add_enum_type() {
+  return _impl_.enum_type_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::add_enum_type() {
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _add = _internal_add_enum_type();
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.enum_type)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
+DescriptorProto::enum_type() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.enum_type)
+  return _impl_.enum_type_;
+}
+
+// repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
+inline int DescriptorProto::_internal_extension_range_size() const {
+  return _impl_.extension_range_.size();
+}
+inline int DescriptorProto::extension_range_size() const {
+  return _internal_extension_range_size();
+}
+inline void DescriptorProto::clear_extension_range() {
+  _impl_.extension_range_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension_range)
+  return _impl_.extension_range_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >*
+DescriptorProto::mutable_extension_range() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension_range)
+  return &_impl_.extension_range_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& DescriptorProto::_internal_extension_range(int index) const {
+  return _impl_.extension_range_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension_range)
+  return _internal_extension_range(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::_internal_add_extension_range() {
+  return _impl_.extension_range_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() {
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* _add = _internal_add_extension_range();
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension_range)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >&
+DescriptorProto::extension_range() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension_range)
+  return _impl_.extension_range_;
+}
+
+// repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
+inline int DescriptorProto::_internal_oneof_decl_size() const {
+  return _impl_.oneof_decl_.size();
+}
+inline int DescriptorProto::oneof_decl_size() const {
+  return _internal_oneof_decl_size();
+}
+inline void DescriptorProto::clear_oneof_decl() {
+  _impl_.oneof_decl_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::mutable_oneof_decl(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.oneof_decl)
+  return _impl_.oneof_decl_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >*
+DescriptorProto::mutable_oneof_decl() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.oneof_decl)
+  return &_impl_.oneof_decl_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& DescriptorProto::_internal_oneof_decl(int index) const {
+  return _impl_.oneof_decl_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& DescriptorProto::oneof_decl(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.oneof_decl)
+  return _internal_oneof_decl(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::_internal_add_oneof_decl() {
+  return _impl_.oneof_decl_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::add_oneof_decl() {
+  ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* _add = _internal_add_oneof_decl();
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.oneof_decl)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >&
+DescriptorProto::oneof_decl() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.oneof_decl)
+  return _impl_.oneof_decl_;
+}
+
+// optional .google.protobuf.MessageOptions options = 7;
+inline bool DescriptorProto::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool DescriptorProto::has_options() const {
+  return _internal_has_options();
+}
+inline void DescriptorProto::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::MessageOptions& DescriptorProto::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::MessageOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::MessageOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_MessageOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::MessageOptions& DescriptorProto::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.options)
+  return _internal_options();
+}
+inline void DescriptorProto::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::MessageOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.options)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::MessageOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MessageOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::MessageOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.options)
+  return _msg;
+}
+inline void DescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::MessageOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.options)
+}
+
+// repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
+inline int DescriptorProto::_internal_reserved_range_size() const {
+  return _impl_.reserved_range_.size();
+}
+inline int DescriptorProto::reserved_range_size() const {
+  return _internal_reserved_range_size();
+}
+inline void DescriptorProto::clear_reserved_range() {
+  _impl_.reserved_range_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::mutable_reserved_range(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_range)
+  return _impl_.reserved_range_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >*
+DescriptorProto::mutable_reserved_range() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_range)
+  return &_impl_.reserved_range_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& DescriptorProto::_internal_reserved_range(int index) const {
+  return _impl_.reserved_range_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& DescriptorProto::reserved_range(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_range)
+  return _internal_reserved_range(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::_internal_add_reserved_range() {
+  return _impl_.reserved_range_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::add_reserved_range() {
+  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* _add = _internal_add_reserved_range();
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_range)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >&
+DescriptorProto::reserved_range() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_range)
+  return _impl_.reserved_range_;
+}
+
+// repeated string reserved_name = 10;
+inline int DescriptorProto::_internal_reserved_name_size() const {
+  return _impl_.reserved_name_.size();
+}
+inline int DescriptorProto::reserved_name_size() const {
+  return _internal_reserved_name_size();
+}
+inline void DescriptorProto::clear_reserved_name() {
+  _impl_.reserved_name_.Clear();
+}
+inline std::string* DescriptorProto::add_reserved_name() {
+  std::string* _s = _internal_add_reserved_name();
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.DescriptorProto.reserved_name)
+  return _s;
+}
+inline const std::string& DescriptorProto::_internal_reserved_name(int index) const {
+  return _impl_.reserved_name_.Get(index);
+}
+inline const std::string& DescriptorProto::reserved_name(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_name)
+  return _internal_reserved_name(index);
+}
+inline std::string* DescriptorProto::mutable_reserved_name(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_name)
+  return _impl_.reserved_name_.Mutable(index);
+}
+inline void DescriptorProto::set_reserved_name(int index, const std::string& value) {
+  _impl_.reserved_name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::set_reserved_name(int index, std::string&& value) {
+  _impl_.reserved_name_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::set_reserved_name(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.reserved_name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::set_reserved_name(int index, const char* value, size_t size) {
+  _impl_.reserved_name_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.DescriptorProto.reserved_name)
+}
+inline std::string* DescriptorProto::_internal_add_reserved_name() {
+  return _impl_.reserved_name_.Add();
+}
+inline void DescriptorProto::add_reserved_name(const std::string& value) {
+  _impl_.reserved_name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::add_reserved_name(std::string&& value) {
+  _impl_.reserved_name_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::add_reserved_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.reserved_name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::add_reserved_name(const char* value, size_t size) {
+  _impl_.reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.DescriptorProto.reserved_name)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+DescriptorProto::reserved_name() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_name)
+  return _impl_.reserved_name_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+DescriptorProto::mutable_reserved_name() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_name)
+  return &_impl_.reserved_name_;
+}
+
+// -------------------------------------------------------------------
+
+// ExtensionRangeOptions
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int ExtensionRangeOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int ExtensionRangeOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void ExtensionRangeOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+ExtensionRangeOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ExtensionRangeOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ExtensionRangeOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+ExtensionRangeOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// FieldDescriptorProto
+
+// optional string name = 1;
+inline bool FieldDescriptorProto::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_name() const {
+  return _internal_has_name();
+}
+inline void FieldDescriptorProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& FieldDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FieldDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.name)
+}
+inline std::string* FieldDescriptorProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.name)
+  return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FieldDescriptorProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.name)
+}
+
+// optional int32 number = 3;
+inline bool FieldDescriptorProto::_internal_has_number() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_number() const {
+  return _internal_has_number();
+}
+inline void FieldDescriptorProto::clear_number() {
+  _impl_.number_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline int32_t FieldDescriptorProto::_internal_number() const {
+  return _impl_.number_;
+}
+inline int32_t FieldDescriptorProto::number() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.number)
+  return _internal_number();
+}
+inline void FieldDescriptorProto::_internal_set_number(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.number_ = value;
+}
+inline void FieldDescriptorProto::set_number(int32_t value) {
+  _internal_set_number(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.number)
+}
+
+// optional .google.protobuf.FieldDescriptorProto.Label label = 4;
+inline bool FieldDescriptorProto::_internal_has_label() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_label() const {
+  return _internal_has_label();
+}
+inline void FieldDescriptorProto::clear_label() {
+  _impl_.label_ = 1;
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label FieldDescriptorProto::_internal_label() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label >(_impl_.label_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label FieldDescriptorProto::label() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.label)
+  return _internal_label();
+}
+inline void FieldDescriptorProto::_internal_set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value) {
+  assert(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.label_ = value;
+}
+inline void FieldDescriptorProto::set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value) {
+  _internal_set_label(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.label)
+}
+
+// optional .google.protobuf.FieldDescriptorProto.Type type = 5;
+inline bool FieldDescriptorProto::_internal_has_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_type() const {
+  return _internal_has_type();
+}
+inline void FieldDescriptorProto::clear_type() {
+  _impl_.type_ = 1;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type FieldDescriptorProto::_internal_type() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type >(_impl_.type_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type FieldDescriptorProto::type() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type)
+  return _internal_type();
+}
+inline void FieldDescriptorProto::_internal_set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value) {
+  assert(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.type_ = value;
+}
+inline void FieldDescriptorProto::set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type)
+}
+
+// optional string type_name = 6;
+inline bool FieldDescriptorProto::_internal_has_type_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_type_name() const {
+  return _internal_has_type_name();
+}
+inline void FieldDescriptorProto::clear_type_name() {
+  _impl_.type_name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& FieldDescriptorProto::type_name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type_name)
+  return _internal_type_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FieldDescriptorProto::set_type_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.type_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type_name)
+}
+inline std::string* FieldDescriptorProto::mutable_type_name() {
+  std::string* _s = _internal_mutable_type_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.type_name)
+  return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_type_name() const {
+  return _impl_.type_name_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_type_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.type_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_type_name() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.type_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_type_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.type_name)
+  if (!_internal_has_type_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.type_name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_name_.IsDefault()) {
+    _impl_.type_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FieldDescriptorProto::set_allocated_type_name(std::string* type_name) {
+  if (type_name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.type_name_.SetAllocated(type_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_name_.IsDefault()) {
+    _impl_.type_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.type_name)
+}
+
+// optional string extendee = 2;
+inline bool FieldDescriptorProto::_internal_has_extendee() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_extendee() const {
+  return _internal_has_extendee();
+}
+inline void FieldDescriptorProto::clear_extendee() {
+  _impl_.extendee_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& FieldDescriptorProto::extendee() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.extendee)
+  return _internal_extendee();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FieldDescriptorProto::set_extendee(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.extendee_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.extendee)
+}
+inline std::string* FieldDescriptorProto::mutable_extendee() {
+  std::string* _s = _internal_mutable_extendee();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.extendee)
+  return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_extendee() const {
+  return _impl_.extendee_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_extendee(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.extendee_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_extendee() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.extendee_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_extendee() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.extendee)
+  if (!_internal_has_extendee()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.extendee_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.extendee_.IsDefault()) {
+    _impl_.extendee_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FieldDescriptorProto::set_allocated_extendee(std::string* extendee) {
+  if (extendee != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.extendee_.SetAllocated(extendee, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.extendee_.IsDefault()) {
+    _impl_.extendee_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.extendee)
+}
+
+// optional string default_value = 7;
+inline bool FieldDescriptorProto::_internal_has_default_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_default_value() const {
+  return _internal_has_default_value();
+}
+inline void FieldDescriptorProto::clear_default_value() {
+  _impl_.default_value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& FieldDescriptorProto::default_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.default_value)
+  return _internal_default_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FieldDescriptorProto::set_default_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.default_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.default_value)
+}
+inline std::string* FieldDescriptorProto::mutable_default_value() {
+  std::string* _s = _internal_mutable_default_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.default_value)
+  return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_default_value() const {
+  return _impl_.default_value_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_default_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.default_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_default_value() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.default_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_default_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.default_value)
+  if (!_internal_has_default_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.default_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.default_value_.IsDefault()) {
+    _impl_.default_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FieldDescriptorProto::set_allocated_default_value(std::string* default_value) {
+  if (default_value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.default_value_.SetAllocated(default_value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.default_value_.IsDefault()) {
+    _impl_.default_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.default_value)
+}
+
+// optional int32 oneof_index = 9;
+inline bool FieldDescriptorProto::_internal_has_oneof_index() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_oneof_index() const {
+  return _internal_has_oneof_index();
+}
+inline void FieldDescriptorProto::clear_oneof_index() {
+  _impl_.oneof_index_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline int32_t FieldDescriptorProto::_internal_oneof_index() const {
+  return _impl_.oneof_index_;
+}
+inline int32_t FieldDescriptorProto::oneof_index() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.oneof_index)
+  return _internal_oneof_index();
+}
+inline void FieldDescriptorProto::_internal_set_oneof_index(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.oneof_index_ = value;
+}
+inline void FieldDescriptorProto::set_oneof_index(int32_t value) {
+  _internal_set_oneof_index(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.oneof_index)
+}
+
+// optional string json_name = 10;
+inline bool FieldDescriptorProto::_internal_has_json_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_json_name() const {
+  return _internal_has_json_name();
+}
+inline void FieldDescriptorProto::clear_json_name() {
+  _impl_.json_name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& FieldDescriptorProto::json_name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.json_name)
+  return _internal_json_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FieldDescriptorProto::set_json_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.json_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.json_name)
+}
+inline std::string* FieldDescriptorProto::mutable_json_name() {
+  std::string* _s = _internal_mutable_json_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.json_name)
+  return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_json_name() const {
+  return _impl_.json_name_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_json_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.json_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_json_name() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.json_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_json_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.json_name)
+  if (!_internal_has_json_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.json_name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.json_name_.IsDefault()) {
+    _impl_.json_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FieldDescriptorProto::set_allocated_json_name(std::string* json_name) {
+  if (json_name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.json_name_.SetAllocated(json_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.json_name_.IsDefault()) {
+    _impl_.json_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.json_name)
+}
+
+// optional .google.protobuf.FieldOptions options = 8;
+inline bool FieldDescriptorProto::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool FieldDescriptorProto::has_options() const {
+  return _internal_has_options();
+}
+inline void FieldDescriptorProto::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldOptions& FieldDescriptorProto::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::FieldOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FieldOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_FieldOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldOptions& FieldDescriptorProto::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.options)
+  return _internal_options();
+}
+inline void FieldDescriptorProto::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.options)
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::FieldOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.options)
+  return _msg;
+}
+inline void FieldDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::FieldOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.options)
+}
+
+// optional bool proto3_optional = 17;
+inline bool FieldDescriptorProto::_internal_has_proto3_optional() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool FieldDescriptorProto::has_proto3_optional() const {
+  return _internal_has_proto3_optional();
+}
+inline void FieldDescriptorProto::clear_proto3_optional() {
+  _impl_.proto3_optional_ = false;
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline bool FieldDescriptorProto::_internal_proto3_optional() const {
+  return _impl_.proto3_optional_;
+}
+inline bool FieldDescriptorProto::proto3_optional() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.proto3_optional)
+  return _internal_proto3_optional();
+}
+inline void FieldDescriptorProto::_internal_set_proto3_optional(bool value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.proto3_optional_ = value;
+}
+inline void FieldDescriptorProto::set_proto3_optional(bool value) {
+  _internal_set_proto3_optional(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.proto3_optional)
+}
+
+// -------------------------------------------------------------------
+
+// OneofDescriptorProto
+
+// optional string name = 1;
+inline bool OneofDescriptorProto::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool OneofDescriptorProto::has_name() const {
+  return _internal_has_name();
+}
+inline void OneofDescriptorProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& OneofDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OneofDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.OneofDescriptorProto.name)
+}
+inline std::string* OneofDescriptorProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.name)
+  return _s;
+}
+inline const std::string& OneofDescriptorProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void OneofDescriptorProto::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OneofDescriptorProto::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OneofDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void OneofDescriptorProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.name)
+}
+
+// optional .google.protobuf.OneofOptions options = 2;
+inline bool OneofDescriptorProto::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool OneofDescriptorProto::has_options() const {
+  return _internal_has_options();
+}
+inline void OneofDescriptorProto::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::OneofOptions& OneofDescriptorProto::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::OneofOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::OneofOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_OneofOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::OneofOptions& OneofDescriptorProto::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.options)
+  return _internal_options();
+}
+inline void OneofDescriptorProto::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.OneofDescriptorProto.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::OneofOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.options)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::OneofOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::OneofOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.options)
+  return _msg;
+}
+inline void OneofDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::OneofOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.options)
+}
+
+// -------------------------------------------------------------------
+
+// EnumDescriptorProto_EnumReservedRange
+
+// optional int32 start = 1;
+inline bool EnumDescriptorProto_EnumReservedRange::_internal_has_start() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EnumDescriptorProto_EnumReservedRange::has_start() const {
+  return _internal_has_start();
+}
+inline void EnumDescriptorProto_EnumReservedRange::clear_start() {
+  _impl_.start_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline int32_t EnumDescriptorProto_EnumReservedRange::_internal_start() const {
+  return _impl_.start_;
+}
+inline int32_t EnumDescriptorProto_EnumReservedRange::start() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
+  return _internal_start();
+}
+inline void EnumDescriptorProto_EnumReservedRange::_internal_set_start(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.start_ = value;
+}
+inline void EnumDescriptorProto_EnumReservedRange::set_start(int32_t value) {
+  _internal_set_start(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
+}
+
+// optional int32 end = 2;
+inline bool EnumDescriptorProto_EnumReservedRange::_internal_has_end() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool EnumDescriptorProto_EnumReservedRange::has_end() const {
+  return _internal_has_end();
+}
+inline void EnumDescriptorProto_EnumReservedRange::clear_end() {
+  _impl_.end_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t EnumDescriptorProto_EnumReservedRange::_internal_end() const {
+  return _impl_.end_;
+}
+inline int32_t EnumDescriptorProto_EnumReservedRange::end() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
+  return _internal_end();
+}
+inline void EnumDescriptorProto_EnumReservedRange::_internal_set_end(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.end_ = value;
+}
+inline void EnumDescriptorProto_EnumReservedRange::set_end(int32_t value) {
+  _internal_set_end(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
+}
+
+// -------------------------------------------------------------------
+
+// EnumDescriptorProto
+
+// optional string name = 1;
+inline bool EnumDescriptorProto::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EnumDescriptorProto::has_name() const {
+  return _internal_has_name();
+}
+inline void EnumDescriptorProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& EnumDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EnumDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.name)
+}
+inline std::string* EnumDescriptorProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.name)
+  return _s;
+}
+inline const std::string& EnumDescriptorProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void EnumDescriptorProto::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* EnumDescriptorProto::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* EnumDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void EnumDescriptorProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.name)
+}
+
+// repeated .google.protobuf.EnumValueDescriptorProto value = 2;
+inline int EnumDescriptorProto::_internal_value_size() const {
+  return _impl_.value_.size();
+}
+inline int EnumDescriptorProto::value_size() const {
+  return _internal_value_size();
+}
+inline void EnumDescriptorProto::clear_value() {
+  _impl_.value_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.value)
+  return _impl_.value_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >*
+EnumDescriptorProto::mutable_value() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.value)
+  return &_impl_.value_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& EnumDescriptorProto::_internal_value(int index) const {
+  return _impl_.value_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.value)
+  return _internal_value(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::_internal_add_value() {
+  return _impl_.value_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::add_value() {
+  ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* _add = _internal_add_value();
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.value)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >&
+EnumDescriptorProto::value() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.value)
+  return _impl_.value_;
+}
+
+// optional .google.protobuf.EnumOptions options = 3;
+inline bool EnumDescriptorProto::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool EnumDescriptorProto::has_options() const {
+  return _internal_has_options();
+}
+inline void EnumDescriptorProto::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumOptions& EnumDescriptorProto::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::EnumOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::EnumOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_EnumOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumOptions& EnumDescriptorProto::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.options)
+  return _internal_options();
+}
+inline void EnumDescriptorProto::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumDescriptorProto.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::EnumOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.options)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::EnumOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::EnumOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.options)
+  return _msg;
+}
+inline void EnumDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.options)
+}
+
+// repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
+inline int EnumDescriptorProto::_internal_reserved_range_size() const {
+  return _impl_.reserved_range_.size();
+}
+inline int EnumDescriptorProto::reserved_range_size() const {
+  return _internal_reserved_range_size();
+}
+inline void EnumDescriptorProto::clear_reserved_range() {
+  _impl_.reserved_range_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::mutable_reserved_range(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_range)
+  return _impl_.reserved_range_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >*
+EnumDescriptorProto::mutable_reserved_range() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_range)
+  return &_impl_.reserved_range_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::_internal_reserved_range(int index) const {
+  return _impl_.reserved_range_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::reserved_range(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_range)
+  return _internal_reserved_range(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::_internal_add_reserved_range() {
+  return _impl_.reserved_range_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::add_reserved_range() {
+  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* _add = _internal_add_reserved_range();
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_range)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >&
+EnumDescriptorProto::reserved_range() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_range)
+  return _impl_.reserved_range_;
+}
+
+// repeated string reserved_name = 5;
+inline int EnumDescriptorProto::_internal_reserved_name_size() const {
+  return _impl_.reserved_name_.size();
+}
+inline int EnumDescriptorProto::reserved_name_size() const {
+  return _internal_reserved_name_size();
+}
+inline void EnumDescriptorProto::clear_reserved_name() {
+  _impl_.reserved_name_.Clear();
+}
+inline std::string* EnumDescriptorProto::add_reserved_name() {
+  std::string* _s = _internal_add_reserved_name();
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
+  return _s;
+}
+inline const std::string& EnumDescriptorProto::_internal_reserved_name(int index) const {
+  return _impl_.reserved_name_.Get(index);
+}
+inline const std::string& EnumDescriptorProto::reserved_name(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_name)
+  return _internal_reserved_name(index);
+}
+inline std::string* EnumDescriptorProto::mutable_reserved_name(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
+  return _impl_.reserved_name_.Mutable(index);
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, const std::string& value) {
+  _impl_.reserved_name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, std::string&& value) {
+  _impl_.reserved_name_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.reserved_name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, const char* value, size_t size) {
+  _impl_.reserved_name_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline std::string* EnumDescriptorProto::_internal_add_reserved_name() {
+  return _impl_.reserved_name_.Add();
+}
+inline void EnumDescriptorProto::add_reserved_name(const std::string& value) {
+  _impl_.reserved_name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::add_reserved_name(std::string&& value) {
+  _impl_.reserved_name_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::add_reserved_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.reserved_name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::add_reserved_name(const char* value, size_t size) {
+  _impl_.reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+EnumDescriptorProto::reserved_name() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_name)
+  return _impl_.reserved_name_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+EnumDescriptorProto::mutable_reserved_name() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_name)
+  return &_impl_.reserved_name_;
+}
+
+// -------------------------------------------------------------------
+
+// EnumValueDescriptorProto
+
+// optional string name = 1;
+inline bool EnumValueDescriptorProto::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EnumValueDescriptorProto::has_name() const {
+  return _internal_has_name();
+}
+inline void EnumValueDescriptorProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& EnumValueDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EnumValueDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.name)
+}
+inline std::string* EnumValueDescriptorProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.name)
+  return _s;
+}
+inline const std::string& EnumValueDescriptorProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void EnumValueDescriptorProto::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* EnumValueDescriptorProto::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* EnumValueDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void EnumValueDescriptorProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.name)
+}
+
+// optional int32 number = 2;
+inline bool EnumValueDescriptorProto::_internal_has_number() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool EnumValueDescriptorProto::has_number() const {
+  return _internal_has_number();
+}
+inline void EnumValueDescriptorProto::clear_number() {
+  _impl_.number_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t EnumValueDescriptorProto::_internal_number() const {
+  return _impl_.number_;
+}
+inline int32_t EnumValueDescriptorProto::number() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.number)
+  return _internal_number();
+}
+inline void EnumValueDescriptorProto::_internal_set_number(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.number_ = value;
+}
+inline void EnumValueDescriptorProto::set_number(int32_t value) {
+  _internal_set_number(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.number)
+}
+
+// optional .google.protobuf.EnumValueOptions options = 3;
+inline bool EnumValueDescriptorProto::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool EnumValueDescriptorProto::has_options() const {
+  return _internal_has_options();
+}
+inline void EnumValueDescriptorProto::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& EnumValueDescriptorProto::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_EnumValueOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& EnumValueDescriptorProto::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.options)
+  return _internal_options();
+}
+inline void EnumValueDescriptorProto::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.options)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.options)
+  return _msg;
+}
+inline void EnumValueDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
+}
+
+// -------------------------------------------------------------------
+
+// ServiceDescriptorProto
+
+// optional string name = 1;
+inline bool ServiceDescriptorProto::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ServiceDescriptorProto::has_name() const {
+  return _internal_has_name();
+}
+inline void ServiceDescriptorProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ServiceDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ServiceDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.ServiceDescriptorProto.name)
+}
+inline std::string* ServiceDescriptorProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.name)
+  return _s;
+}
+inline const std::string& ServiceDescriptorProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void ServiceDescriptorProto::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* ServiceDescriptorProto::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ServiceDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void ServiceDescriptorProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.name)
+}
+
+// repeated .google.protobuf.MethodDescriptorProto method = 2;
+inline int ServiceDescriptorProto::_internal_method_size() const {
+  return _impl_.method_.size();
+}
+inline int ServiceDescriptorProto::method_size() const {
+  return _internal_method_size();
+}
+inline void ServiceDescriptorProto::clear_method() {
+  _impl_.method_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.method)
+  return _impl_.method_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >*
+ServiceDescriptorProto::mutable_method() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceDescriptorProto.method)
+  return &_impl_.method_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& ServiceDescriptorProto::_internal_method(int index) const {
+  return _impl_.method_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.method)
+  return _internal_method(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::_internal_add_method() {
+  return _impl_.method_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::add_method() {
+  ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* _add = _internal_add_method();
+  // @@protoc_insertion_point(field_add:google.protobuf.ServiceDescriptorProto.method)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >&
+ServiceDescriptorProto::method() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.ServiceDescriptorProto.method)
+  return _impl_.method_;
+}
+
+// optional .google.protobuf.ServiceOptions options = 3;
+inline bool ServiceDescriptorProto::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool ServiceDescriptorProto::has_options() const {
+  return _internal_has_options();
+}
+inline void ServiceDescriptorProto::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& ServiceDescriptorProto::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::ServiceOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::ServiceOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_ServiceOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& ServiceDescriptorProto::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.options)
+  return _internal_options();
+}
+inline void ServiceDescriptorProto::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.ServiceDescriptorProto.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.options)
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.options)
+  return _msg;
+}
+inline void ServiceDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::ServiceOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.options)
+}
+
+// -------------------------------------------------------------------
+
+// MethodDescriptorProto
+
+// optional string name = 1;
+inline bool MethodDescriptorProto::_internal_has_name() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MethodDescriptorProto::has_name() const {
+  return _internal_has_name();
+}
+inline void MethodDescriptorProto::clear_name() {
+  _impl_.name_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MethodDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MethodDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.name)
+}
+inline std::string* MethodDescriptorProto::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.name)
+  return _s;
+}
+inline const std::string& MethodDescriptorProto::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void MethodDescriptorProto::_internal_set_name(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::_internal_mutable_name() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MethodDescriptorProto::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.name)
+}
+
+// optional string input_type = 2;
+inline bool MethodDescriptorProto::_internal_has_input_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MethodDescriptorProto::has_input_type() const {
+  return _internal_has_input_type();
+}
+inline void MethodDescriptorProto::clear_input_type() {
+  _impl_.input_type_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& MethodDescriptorProto::input_type() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.input_type)
+  return _internal_input_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MethodDescriptorProto::set_input_type(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.input_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.input_type)
+}
+inline std::string* MethodDescriptorProto::mutable_input_type() {
+  std::string* _s = _internal_mutable_input_type();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.input_type)
+  return _s;
+}
+inline const std::string& MethodDescriptorProto::_internal_input_type() const {
+  return _impl_.input_type_.Get();
+}
+inline void MethodDescriptorProto::_internal_set_input_type(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.input_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::_internal_mutable_input_type() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.input_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::release_input_type() {
+  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.input_type)
+  if (!_internal_has_input_type()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.input_type_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.input_type_.IsDefault()) {
+    _impl_.input_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MethodDescriptorProto::set_allocated_input_type(std::string* input_type) {
+  if (input_type != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.input_type_.SetAllocated(input_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.input_type_.IsDefault()) {
+    _impl_.input_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.input_type)
+}
+
+// optional string output_type = 3;
+inline bool MethodDescriptorProto::_internal_has_output_type() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool MethodDescriptorProto::has_output_type() const {
+  return _internal_has_output_type();
+}
+inline void MethodDescriptorProto::clear_output_type() {
+  _impl_.output_type_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& MethodDescriptorProto::output_type() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.output_type)
+  return _internal_output_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MethodDescriptorProto::set_output_type(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.output_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.output_type)
+}
+inline std::string* MethodDescriptorProto::mutable_output_type() {
+  std::string* _s = _internal_mutable_output_type();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.output_type)
+  return _s;
+}
+inline const std::string& MethodDescriptorProto::_internal_output_type() const {
+  return _impl_.output_type_.Get();
+}
+inline void MethodDescriptorProto::_internal_set_output_type(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.output_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::_internal_mutable_output_type() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.output_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::release_output_type() {
+  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.output_type)
+  if (!_internal_has_output_type()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.output_type_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.output_type_.IsDefault()) {
+    _impl_.output_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void MethodDescriptorProto::set_allocated_output_type(std::string* output_type) {
+  if (output_type != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.output_type_.SetAllocated(output_type, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.output_type_.IsDefault()) {
+    _impl_.output_type_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.output_type)
+}
+
+// optional .google.protobuf.MethodOptions options = 4;
+inline bool MethodDescriptorProto::_internal_has_options() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+  return value;
+}
+inline bool MethodDescriptorProto::has_options() const {
+  return _internal_has_options();
+}
+inline void MethodDescriptorProto::clear_options() {
+  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::MethodOptions& MethodDescriptorProto::_internal_options() const {
+  const ::PROTOBUF_NAMESPACE_ID::MethodOptions* p = _impl_.options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::MethodOptions&>(
+      ::PROTOBUF_NAMESPACE_ID::_MethodOptions_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::MethodOptions& MethodDescriptorProto::options() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.options)
+  return _internal_options();
+}
+inline void MethodDescriptorProto::unsafe_arena_set_allocated_options(
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+  }
+  _impl_.options_ = options;
+  if (options) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.MethodDescriptorProto.options)
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::release_options() {
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::PROTOBUF_NAMESPACE_ID::MethodOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.options)
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  ::PROTOBUF_NAMESPACE_ID::MethodOptions* temp = _impl_.options_;
+  _impl_.options_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::_internal_mutable_options() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  if (_impl_.options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodOptions>(GetArenaForAllocation());
+    _impl_.options_ = p;
+  }
+  return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::mutable_options() {
+  ::PROTOBUF_NAMESPACE_ID::MethodOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.options)
+  return _msg;
+}
+inline void MethodDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::MethodOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete _impl_.options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.options)
+}
+
+// optional bool client_streaming = 5 [default = false];
+inline bool MethodDescriptorProto::_internal_has_client_streaming() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool MethodDescriptorProto::has_client_streaming() const {
+  return _internal_has_client_streaming();
+}
+inline void MethodDescriptorProto::clear_client_streaming() {
+  _impl_.client_streaming_ = false;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline bool MethodDescriptorProto::_internal_client_streaming() const {
+  return _impl_.client_streaming_;
+}
+inline bool MethodDescriptorProto::client_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.client_streaming)
+  return _internal_client_streaming();
+}
+inline void MethodDescriptorProto::_internal_set_client_streaming(bool value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.client_streaming_ = value;
+}
+inline void MethodDescriptorProto::set_client_streaming(bool value) {
+  _internal_set_client_streaming(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.client_streaming)
+}
+
+// optional bool server_streaming = 6 [default = false];
+inline bool MethodDescriptorProto::_internal_has_server_streaming() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool MethodDescriptorProto::has_server_streaming() const {
+  return _internal_has_server_streaming();
+}
+inline void MethodDescriptorProto::clear_server_streaming() {
+  _impl_.server_streaming_ = false;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline bool MethodDescriptorProto::_internal_server_streaming() const {
+  return _impl_.server_streaming_;
+}
+inline bool MethodDescriptorProto::server_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.server_streaming)
+  return _internal_server_streaming();
+}
+inline void MethodDescriptorProto::_internal_set_server_streaming(bool value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.server_streaming_ = value;
+}
+inline void MethodDescriptorProto::set_server_streaming(bool value) {
+  _internal_set_server_streaming(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.server_streaming)
+}
+
+// -------------------------------------------------------------------
+
+// FileOptions
+
+// optional string java_package = 1;
+inline bool FileOptions::_internal_has_java_package() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool FileOptions::has_java_package() const {
+  return _internal_has_java_package();
+}
+inline void FileOptions::clear_java_package() {
+  _impl_.java_package_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& FileOptions::java_package() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_package)
+  return _internal_java_package();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_java_package(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.java_package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_package)
+}
+inline std::string* FileOptions::mutable_java_package() {
+  std::string* _s = _internal_mutable_java_package();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_package)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_java_package() const {
+  return _impl_.java_package_.Get();
+}
+inline void FileOptions::_internal_set_java_package(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.java_package_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_java_package() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.java_package_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_java_package() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_package)
+  if (!_internal_has_java_package()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.java_package_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.java_package_.IsDefault()) {
+    _impl_.java_package_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_java_package(std::string* java_package) {
+  if (java_package != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.java_package_.SetAllocated(java_package, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.java_package_.IsDefault()) {
+    _impl_.java_package_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_package)
+}
+
+// optional string java_outer_classname = 8;
+inline bool FileOptions::_internal_has_java_outer_classname() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool FileOptions::has_java_outer_classname() const {
+  return _internal_has_java_outer_classname();
+}
+inline void FileOptions::clear_java_outer_classname() {
+  _impl_.java_outer_classname_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& FileOptions::java_outer_classname() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_outer_classname)
+  return _internal_java_outer_classname();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_java_outer_classname(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.java_outer_classname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_outer_classname)
+}
+inline std::string* FileOptions::mutable_java_outer_classname() {
+  std::string* _s = _internal_mutable_java_outer_classname();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_outer_classname)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_java_outer_classname() const {
+  return _impl_.java_outer_classname_.Get();
+}
+inline void FileOptions::_internal_set_java_outer_classname(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.java_outer_classname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_java_outer_classname() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.java_outer_classname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_java_outer_classname() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_outer_classname)
+  if (!_internal_has_java_outer_classname()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.java_outer_classname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.java_outer_classname_.IsDefault()) {
+    _impl_.java_outer_classname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_java_outer_classname(std::string* java_outer_classname) {
+  if (java_outer_classname != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.java_outer_classname_.SetAllocated(java_outer_classname, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.java_outer_classname_.IsDefault()) {
+    _impl_.java_outer_classname_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_outer_classname)
+}
+
+// optional bool java_multiple_files = 10 [default = false];
+inline bool FileOptions::_internal_has_java_multiple_files() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool FileOptions::has_java_multiple_files() const {
+  return _internal_has_java_multiple_files();
+}
+inline void FileOptions::clear_java_multiple_files() {
+  _impl_.java_multiple_files_ = false;
+  _impl_._has_bits_[0] &= ~0x00000400u;
+}
+inline bool FileOptions::_internal_java_multiple_files() const {
+  return _impl_.java_multiple_files_;
+}
+inline bool FileOptions::java_multiple_files() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_multiple_files)
+  return _internal_java_multiple_files();
+}
+inline void FileOptions::_internal_set_java_multiple_files(bool value) {
+  _impl_._has_bits_[0] |= 0x00000400u;
+  _impl_.java_multiple_files_ = value;
+}
+inline void FileOptions::set_java_multiple_files(bool value) {
+  _internal_set_java_multiple_files(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_multiple_files)
+}
+
+// optional bool java_generate_equals_and_hash = 20 [deprecated = true];
+inline bool FileOptions::_internal_has_java_generate_equals_and_hash() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool FileOptions::has_java_generate_equals_and_hash() const {
+  return _internal_has_java_generate_equals_and_hash();
+}
+inline void FileOptions::clear_java_generate_equals_and_hash() {
+  _impl_.java_generate_equals_and_hash_ = false;
+  _impl_._has_bits_[0] &= ~0x00000800u;
+}
+inline bool FileOptions::_internal_java_generate_equals_and_hash() const {
+  return _impl_.java_generate_equals_and_hash_;
+}
+inline bool FileOptions::java_generate_equals_and_hash() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generate_equals_and_hash)
+  return _internal_java_generate_equals_and_hash();
+}
+inline void FileOptions::_internal_set_java_generate_equals_and_hash(bool value) {
+  _impl_._has_bits_[0] |= 0x00000800u;
+  _impl_.java_generate_equals_and_hash_ = value;
+}
+inline void FileOptions::set_java_generate_equals_and_hash(bool value) {
+  _internal_set_java_generate_equals_and_hash(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generate_equals_and_hash)
+}
+
+// optional bool java_string_check_utf8 = 27 [default = false];
+inline bool FileOptions::_internal_has_java_string_check_utf8() const {
+  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool FileOptions::has_java_string_check_utf8() const {
+  return _internal_has_java_string_check_utf8();
+}
+inline void FileOptions::clear_java_string_check_utf8() {
+  _impl_.java_string_check_utf8_ = false;
+  _impl_._has_bits_[0] &= ~0x00001000u;
+}
+inline bool FileOptions::_internal_java_string_check_utf8() const {
+  return _impl_.java_string_check_utf8_;
+}
+inline bool FileOptions::java_string_check_utf8() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_string_check_utf8)
+  return _internal_java_string_check_utf8();
+}
+inline void FileOptions::_internal_set_java_string_check_utf8(bool value) {
+  _impl_._has_bits_[0] |= 0x00001000u;
+  _impl_.java_string_check_utf8_ = value;
+}
+inline void FileOptions::set_java_string_check_utf8(bool value) {
+  _internal_set_java_string_check_utf8(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_string_check_utf8)
+}
+
+// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
+inline bool FileOptions::_internal_has_optimize_for() const {
+  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+  return value;
+}
+inline bool FileOptions::has_optimize_for() const {
+  return _internal_has_optimize_for();
+}
+inline void FileOptions::clear_optimize_for() {
+  _impl_.optimize_for_ = 1;
+  _impl_._has_bits_[0] &= ~0x00040000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode FileOptions::_internal_optimize_for() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode >(_impl_.optimize_for_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode FileOptions::optimize_for() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.optimize_for)
+  return _internal_optimize_for();
+}
+inline void FileOptions::_internal_set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value) {
+  assert(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00040000u;
+  _impl_.optimize_for_ = value;
+}
+inline void FileOptions::set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value) {
+  _internal_set_optimize_for(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.optimize_for)
+}
+
+// optional string go_package = 11;
+inline bool FileOptions::_internal_has_go_package() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool FileOptions::has_go_package() const {
+  return _internal_has_go_package();
+}
+inline void FileOptions::clear_go_package() {
+  _impl_.go_package_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& FileOptions::go_package() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.go_package)
+  return _internal_go_package();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_go_package(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.go_package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.go_package)
+}
+inline std::string* FileOptions::mutable_go_package() {
+  std::string* _s = _internal_mutable_go_package();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.go_package)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_go_package() const {
+  return _impl_.go_package_.Get();
+}
+inline void FileOptions::_internal_set_go_package(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.go_package_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_go_package() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.go_package_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_go_package() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.go_package)
+  if (!_internal_has_go_package()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.go_package_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.go_package_.IsDefault()) {
+    _impl_.go_package_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_go_package(std::string* go_package) {
+  if (go_package != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.go_package_.SetAllocated(go_package, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.go_package_.IsDefault()) {
+    _impl_.go_package_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.go_package)
+}
+
+// optional bool cc_generic_services = 16 [default = false];
+inline bool FileOptions::_internal_has_cc_generic_services() const {
+  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool FileOptions::has_cc_generic_services() const {
+  return _internal_has_cc_generic_services();
+}
+inline void FileOptions::clear_cc_generic_services() {
+  _impl_.cc_generic_services_ = false;
+  _impl_._has_bits_[0] &= ~0x00002000u;
+}
+inline bool FileOptions::_internal_cc_generic_services() const {
+  return _impl_.cc_generic_services_;
+}
+inline bool FileOptions::cc_generic_services() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_generic_services)
+  return _internal_cc_generic_services();
+}
+inline void FileOptions::_internal_set_cc_generic_services(bool value) {
+  _impl_._has_bits_[0] |= 0x00002000u;
+  _impl_.cc_generic_services_ = value;
+}
+inline void FileOptions::set_cc_generic_services(bool value) {
+  _internal_set_cc_generic_services(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_generic_services)
+}
+
+// optional bool java_generic_services = 17 [default = false];
+inline bool FileOptions::_internal_has_java_generic_services() const {
+  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool FileOptions::has_java_generic_services() const {
+  return _internal_has_java_generic_services();
+}
+inline void FileOptions::clear_java_generic_services() {
+  _impl_.java_generic_services_ = false;
+  _impl_._has_bits_[0] &= ~0x00004000u;
+}
+inline bool FileOptions::_internal_java_generic_services() const {
+  return _impl_.java_generic_services_;
+}
+inline bool FileOptions::java_generic_services() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generic_services)
+  return _internal_java_generic_services();
+}
+inline void FileOptions::_internal_set_java_generic_services(bool value) {
+  _impl_._has_bits_[0] |= 0x00004000u;
+  _impl_.java_generic_services_ = value;
+}
+inline void FileOptions::set_java_generic_services(bool value) {
+  _internal_set_java_generic_services(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generic_services)
+}
+
+// optional bool py_generic_services = 18 [default = false];
+inline bool FileOptions::_internal_has_py_generic_services() const {
+  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool FileOptions::has_py_generic_services() const {
+  return _internal_has_py_generic_services();
+}
+inline void FileOptions::clear_py_generic_services() {
+  _impl_.py_generic_services_ = false;
+  _impl_._has_bits_[0] &= ~0x00008000u;
+}
+inline bool FileOptions::_internal_py_generic_services() const {
+  return _impl_.py_generic_services_;
+}
+inline bool FileOptions::py_generic_services() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.py_generic_services)
+  return _internal_py_generic_services();
+}
+inline void FileOptions::_internal_set_py_generic_services(bool value) {
+  _impl_._has_bits_[0] |= 0x00008000u;
+  _impl_.py_generic_services_ = value;
+}
+inline void FileOptions::set_py_generic_services(bool value) {
+  _internal_set_py_generic_services(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.py_generic_services)
+}
+
+// optional bool php_generic_services = 42 [default = false];
+inline bool FileOptions::_internal_has_php_generic_services() const {
+  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+  return value;
+}
+inline bool FileOptions::has_php_generic_services() const {
+  return _internal_has_php_generic_services();
+}
+inline void FileOptions::clear_php_generic_services() {
+  _impl_.php_generic_services_ = false;
+  _impl_._has_bits_[0] &= ~0x00010000u;
+}
+inline bool FileOptions::_internal_php_generic_services() const {
+  return _impl_.php_generic_services_;
+}
+inline bool FileOptions::php_generic_services() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_generic_services)
+  return _internal_php_generic_services();
+}
+inline void FileOptions::_internal_set_php_generic_services(bool value) {
+  _impl_._has_bits_[0] |= 0x00010000u;
+  _impl_.php_generic_services_ = value;
+}
+inline void FileOptions::set_php_generic_services(bool value) {
+  _internal_set_php_generic_services(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_generic_services)
+}
+
+// optional bool deprecated = 23 [default = false];
+inline bool FileOptions::_internal_has_deprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+  return value;
+}
+inline bool FileOptions::has_deprecated() const {
+  return _internal_has_deprecated();
+}
+inline void FileOptions::clear_deprecated() {
+  _impl_.deprecated_ = false;
+  _impl_._has_bits_[0] &= ~0x00020000u;
+}
+inline bool FileOptions::_internal_deprecated() const {
+  return _impl_.deprecated_;
+}
+inline bool FileOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.deprecated)
+  return _internal_deprecated();
+}
+inline void FileOptions::_internal_set_deprecated(bool value) {
+  _impl_._has_bits_[0] |= 0x00020000u;
+  _impl_.deprecated_ = value;
+}
+inline void FileOptions::set_deprecated(bool value) {
+  _internal_set_deprecated(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.deprecated)
+}
+
+// optional bool cc_enable_arenas = 31 [default = true];
+inline bool FileOptions::_internal_has_cc_enable_arenas() const {
+  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+  return value;
+}
+inline bool FileOptions::has_cc_enable_arenas() const {
+  return _internal_has_cc_enable_arenas();
+}
+inline void FileOptions::clear_cc_enable_arenas() {
+  _impl_.cc_enable_arenas_ = true;
+  _impl_._has_bits_[0] &= ~0x00080000u;
+}
+inline bool FileOptions::_internal_cc_enable_arenas() const {
+  return _impl_.cc_enable_arenas_;
+}
+inline bool FileOptions::cc_enable_arenas() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_enable_arenas)
+  return _internal_cc_enable_arenas();
+}
+inline void FileOptions::_internal_set_cc_enable_arenas(bool value) {
+  _impl_._has_bits_[0] |= 0x00080000u;
+  _impl_.cc_enable_arenas_ = value;
+}
+inline void FileOptions::set_cc_enable_arenas(bool value) {
+  _internal_set_cc_enable_arenas(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_enable_arenas)
+}
+
+// optional string objc_class_prefix = 36;
+inline bool FileOptions::_internal_has_objc_class_prefix() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool FileOptions::has_objc_class_prefix() const {
+  return _internal_has_objc_class_prefix();
+}
+inline void FileOptions::clear_objc_class_prefix() {
+  _impl_.objc_class_prefix_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& FileOptions::objc_class_prefix() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.objc_class_prefix)
+  return _internal_objc_class_prefix();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_objc_class_prefix(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000008u;
+ _impl_.objc_class_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.objc_class_prefix)
+}
+inline std::string* FileOptions::mutable_objc_class_prefix() {
+  std::string* _s = _internal_mutable_objc_class_prefix();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.objc_class_prefix)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_objc_class_prefix() const {
+  return _impl_.objc_class_prefix_.Get();
+}
+inline void FileOptions::_internal_set_objc_class_prefix(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.objc_class_prefix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_objc_class_prefix() {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  return _impl_.objc_class_prefix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_objc_class_prefix() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.objc_class_prefix)
+  if (!_internal_has_objc_class_prefix()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000008u;
+  auto* p = _impl_.objc_class_prefix_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.objc_class_prefix_.IsDefault()) {
+    _impl_.objc_class_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_objc_class_prefix(std::string* objc_class_prefix) {
+  if (objc_class_prefix != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000008u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000008u;
+  }
+  _impl_.objc_class_prefix_.SetAllocated(objc_class_prefix, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.objc_class_prefix_.IsDefault()) {
+    _impl_.objc_class_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.objc_class_prefix)
+}
+
+// optional string csharp_namespace = 37;
+inline bool FileOptions::_internal_has_csharp_namespace() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool FileOptions::has_csharp_namespace() const {
+  return _internal_has_csharp_namespace();
+}
+inline void FileOptions::clear_csharp_namespace() {
+  _impl_.csharp_namespace_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& FileOptions::csharp_namespace() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.csharp_namespace)
+  return _internal_csharp_namespace();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_csharp_namespace(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000010u;
+ _impl_.csharp_namespace_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.csharp_namespace)
+}
+inline std::string* FileOptions::mutable_csharp_namespace() {
+  std::string* _s = _internal_mutable_csharp_namespace();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.csharp_namespace)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_csharp_namespace() const {
+  return _impl_.csharp_namespace_.Get();
+}
+inline void FileOptions::_internal_set_csharp_namespace(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.csharp_namespace_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_csharp_namespace() {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  return _impl_.csharp_namespace_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_csharp_namespace() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.csharp_namespace)
+  if (!_internal_has_csharp_namespace()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000010u;
+  auto* p = _impl_.csharp_namespace_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.csharp_namespace_.IsDefault()) {
+    _impl_.csharp_namespace_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_csharp_namespace(std::string* csharp_namespace) {
+  if (csharp_namespace != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000010u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000010u;
+  }
+  _impl_.csharp_namespace_.SetAllocated(csharp_namespace, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.csharp_namespace_.IsDefault()) {
+    _impl_.csharp_namespace_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.csharp_namespace)
+}
+
+// optional string swift_prefix = 39;
+inline bool FileOptions::_internal_has_swift_prefix() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool FileOptions::has_swift_prefix() const {
+  return _internal_has_swift_prefix();
+}
+inline void FileOptions::clear_swift_prefix() {
+  _impl_.swift_prefix_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& FileOptions::swift_prefix() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.swift_prefix)
+  return _internal_swift_prefix();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_swift_prefix(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000020u;
+ _impl_.swift_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.swift_prefix)
+}
+inline std::string* FileOptions::mutable_swift_prefix() {
+  std::string* _s = _internal_mutable_swift_prefix();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.swift_prefix)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_swift_prefix() const {
+  return _impl_.swift_prefix_.Get();
+}
+inline void FileOptions::_internal_set_swift_prefix(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.swift_prefix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_swift_prefix() {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  return _impl_.swift_prefix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_swift_prefix() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.swift_prefix)
+  if (!_internal_has_swift_prefix()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000020u;
+  auto* p = _impl_.swift_prefix_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.swift_prefix_.IsDefault()) {
+    _impl_.swift_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_swift_prefix(std::string* swift_prefix) {
+  if (swift_prefix != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000020u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000020u;
+  }
+  _impl_.swift_prefix_.SetAllocated(swift_prefix, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.swift_prefix_.IsDefault()) {
+    _impl_.swift_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.swift_prefix)
+}
+
+// optional string php_class_prefix = 40;
+inline bool FileOptions::_internal_has_php_class_prefix() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool FileOptions::has_php_class_prefix() const {
+  return _internal_has_php_class_prefix();
+}
+inline void FileOptions::clear_php_class_prefix() {
+  _impl_.php_class_prefix_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& FileOptions::php_class_prefix() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_class_prefix)
+  return _internal_php_class_prefix();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_php_class_prefix(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000040u;
+ _impl_.php_class_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_class_prefix)
+}
+inline std::string* FileOptions::mutable_php_class_prefix() {
+  std::string* _s = _internal_mutable_php_class_prefix();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_class_prefix)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_php_class_prefix() const {
+  return _impl_.php_class_prefix_.Get();
+}
+inline void FileOptions::_internal_set_php_class_prefix(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.php_class_prefix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_php_class_prefix() {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  return _impl_.php_class_prefix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_php_class_prefix() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_class_prefix)
+  if (!_internal_has_php_class_prefix()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000040u;
+  auto* p = _impl_.php_class_prefix_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.php_class_prefix_.IsDefault()) {
+    _impl_.php_class_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_php_class_prefix(std::string* php_class_prefix) {
+  if (php_class_prefix != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000040u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000040u;
+  }
+  _impl_.php_class_prefix_.SetAllocated(php_class_prefix, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.php_class_prefix_.IsDefault()) {
+    _impl_.php_class_prefix_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_class_prefix)
+}
+
+// optional string php_namespace = 41;
+inline bool FileOptions::_internal_has_php_namespace() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool FileOptions::has_php_namespace() const {
+  return _internal_has_php_namespace();
+}
+inline void FileOptions::clear_php_namespace() {
+  _impl_.php_namespace_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& FileOptions::php_namespace() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_namespace)
+  return _internal_php_namespace();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_php_namespace(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000080u;
+ _impl_.php_namespace_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_namespace)
+}
+inline std::string* FileOptions::mutable_php_namespace() {
+  std::string* _s = _internal_mutable_php_namespace();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_namespace)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_php_namespace() const {
+  return _impl_.php_namespace_.Get();
+}
+inline void FileOptions::_internal_set_php_namespace(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  _impl_.php_namespace_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_php_namespace() {
+  _impl_._has_bits_[0] |= 0x00000080u;
+  return _impl_.php_namespace_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_php_namespace() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_namespace)
+  if (!_internal_has_php_namespace()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000080u;
+  auto* p = _impl_.php_namespace_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.php_namespace_.IsDefault()) {
+    _impl_.php_namespace_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_php_namespace(std::string* php_namespace) {
+  if (php_namespace != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000080u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000080u;
+  }
+  _impl_.php_namespace_.SetAllocated(php_namespace, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.php_namespace_.IsDefault()) {
+    _impl_.php_namespace_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_namespace)
+}
+
+// optional string php_metadata_namespace = 44;
+inline bool FileOptions::_internal_has_php_metadata_namespace() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool FileOptions::has_php_metadata_namespace() const {
+  return _internal_has_php_metadata_namespace();
+}
+inline void FileOptions::clear_php_metadata_namespace() {
+  _impl_.php_metadata_namespace_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& FileOptions::php_metadata_namespace() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_metadata_namespace)
+  return _internal_php_metadata_namespace();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_php_metadata_namespace(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000100u;
+ _impl_.php_metadata_namespace_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_metadata_namespace)
+}
+inline std::string* FileOptions::mutable_php_metadata_namespace() {
+  std::string* _s = _internal_mutable_php_metadata_namespace();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_metadata_namespace)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_php_metadata_namespace() const {
+  return _impl_.php_metadata_namespace_.Get();
+}
+inline void FileOptions::_internal_set_php_metadata_namespace(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  _impl_.php_metadata_namespace_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_php_metadata_namespace() {
+  _impl_._has_bits_[0] |= 0x00000100u;
+  return _impl_.php_metadata_namespace_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_php_metadata_namespace() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_metadata_namespace)
+  if (!_internal_has_php_metadata_namespace()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000100u;
+  auto* p = _impl_.php_metadata_namespace_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.php_metadata_namespace_.IsDefault()) {
+    _impl_.php_metadata_namespace_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_php_metadata_namespace(std::string* php_metadata_namespace) {
+  if (php_metadata_namespace != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000100u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000100u;
+  }
+  _impl_.php_metadata_namespace_.SetAllocated(php_metadata_namespace, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.php_metadata_namespace_.IsDefault()) {
+    _impl_.php_metadata_namespace_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_metadata_namespace)
+}
+
+// optional string ruby_package = 45;
+inline bool FileOptions::_internal_has_ruby_package() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool FileOptions::has_ruby_package() const {
+  return _internal_has_ruby_package();
+}
+inline void FileOptions::clear_ruby_package() {
+  _impl_.ruby_package_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000200u;
+}
+inline const std::string& FileOptions::ruby_package() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.ruby_package)
+  return _internal_ruby_package();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FileOptions::set_ruby_package(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000200u;
+ _impl_.ruby_package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.ruby_package)
+}
+inline std::string* FileOptions::mutable_ruby_package() {
+  std::string* _s = _internal_mutable_ruby_package();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.ruby_package)
+  return _s;
+}
+inline const std::string& FileOptions::_internal_ruby_package() const {
+  return _impl_.ruby_package_.Get();
+}
+inline void FileOptions::_internal_set_ruby_package(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  _impl_.ruby_package_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_ruby_package() {
+  _impl_._has_bits_[0] |= 0x00000200u;
+  return _impl_.ruby_package_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_ruby_package() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.ruby_package)
+  if (!_internal_has_ruby_package()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000200u;
+  auto* p = _impl_.ruby_package_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ruby_package_.IsDefault()) {
+    _impl_.ruby_package_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void FileOptions::set_allocated_ruby_package(std::string* ruby_package) {
+  if (ruby_package != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000200u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000200u;
+  }
+  _impl_.ruby_package_.SetAllocated(ruby_package, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.ruby_package_.IsDefault()) {
+    _impl_.ruby_package_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.ruby_package)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int FileOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int FileOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void FileOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+FileOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FileOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FileOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.FileOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+FileOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// MessageOptions
+
+// optional bool message_set_wire_format = 1 [default = false];
+inline bool MessageOptions::_internal_has_message_set_wire_format() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MessageOptions::has_message_set_wire_format() const {
+  return _internal_has_message_set_wire_format();
+}
+inline void MessageOptions::clear_message_set_wire_format() {
+  _impl_.message_set_wire_format_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool MessageOptions::_internal_message_set_wire_format() const {
+  return _impl_.message_set_wire_format_;
+}
+inline bool MessageOptions::message_set_wire_format() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.message_set_wire_format)
+  return _internal_message_set_wire_format();
+}
+inline void MessageOptions::_internal_set_message_set_wire_format(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.message_set_wire_format_ = value;
+}
+inline void MessageOptions::set_message_set_wire_format(bool value) {
+  _internal_set_message_set_wire_format(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.message_set_wire_format)
+}
+
+// optional bool no_standard_descriptor_accessor = 2 [default = false];
+inline bool MessageOptions::_internal_has_no_standard_descriptor_accessor() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MessageOptions::has_no_standard_descriptor_accessor() const {
+  return _internal_has_no_standard_descriptor_accessor();
+}
+inline void MessageOptions::clear_no_standard_descriptor_accessor() {
+  _impl_.no_standard_descriptor_accessor_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool MessageOptions::_internal_no_standard_descriptor_accessor() const {
+  return _impl_.no_standard_descriptor_accessor_;
+}
+inline bool MessageOptions::no_standard_descriptor_accessor() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
+  return _internal_no_standard_descriptor_accessor();
+}
+inline void MessageOptions::_internal_set_no_standard_descriptor_accessor(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.no_standard_descriptor_accessor_ = value;
+}
+inline void MessageOptions::set_no_standard_descriptor_accessor(bool value) {
+  _internal_set_no_standard_descriptor_accessor(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
+}
+
+// optional bool deprecated = 3 [default = false];
+inline bool MessageOptions::_internal_has_deprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool MessageOptions::has_deprecated() const {
+  return _internal_has_deprecated();
+}
+inline void MessageOptions::clear_deprecated() {
+  _impl_.deprecated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool MessageOptions::_internal_deprecated() const {
+  return _impl_.deprecated_;
+}
+inline bool MessageOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.deprecated)
+  return _internal_deprecated();
+}
+inline void MessageOptions::_internal_set_deprecated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.deprecated_ = value;
+}
+inline void MessageOptions::set_deprecated(bool value) {
+  _internal_set_deprecated(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.deprecated)
+}
+
+// optional bool map_entry = 7;
+inline bool MessageOptions::_internal_has_map_entry() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool MessageOptions::has_map_entry() const {
+  return _internal_has_map_entry();
+}
+inline void MessageOptions::clear_map_entry() {
+  _impl_.map_entry_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool MessageOptions::_internal_map_entry() const {
+  return _impl_.map_entry_;
+}
+inline bool MessageOptions::map_entry() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.map_entry)
+  return _internal_map_entry();
+}
+inline void MessageOptions::_internal_set_map_entry(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.map_entry_ = value;
+}
+inline void MessageOptions::set_map_entry(bool value) {
+  _internal_set_map_entry(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.map_entry)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int MessageOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int MessageOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void MessageOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MessageOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+MessageOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.MessageOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MessageOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.MessageOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+MessageOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.MessageOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// FieldOptions
+
+// optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
+inline bool FieldOptions::_internal_has_ctype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool FieldOptions::has_ctype() const {
+  return _internal_has_ctype();
+}
+inline void FieldOptions::clear_ctype() {
+  _impl_.ctype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType FieldOptions::_internal_ctype() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType >(_impl_.ctype_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType FieldOptions::ctype() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.ctype)
+  return _internal_ctype();
+}
+inline void FieldOptions::_internal_set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value) {
+  assert(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.ctype_ = value;
+}
+inline void FieldOptions::set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value) {
+  _internal_set_ctype(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.ctype)
+}
+
+// optional bool packed = 2;
+inline bool FieldOptions::_internal_has_packed() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool FieldOptions::has_packed() const {
+  return _internal_has_packed();
+}
+inline void FieldOptions::clear_packed() {
+  _impl_.packed_ = false;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline bool FieldOptions::_internal_packed() const {
+  return _impl_.packed_;
+}
+inline bool FieldOptions::packed() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.packed)
+  return _internal_packed();
+}
+inline void FieldOptions::_internal_set_packed(bool value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.packed_ = value;
+}
+inline void FieldOptions::set_packed(bool value) {
+  _internal_set_packed(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.packed)
+}
+
+// optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
+inline bool FieldOptions::_internal_has_jstype() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool FieldOptions::has_jstype() const {
+  return _internal_has_jstype();
+}
+inline void FieldOptions::clear_jstype() {
+  _impl_.jstype_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType FieldOptions::_internal_jstype() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType >(_impl_.jstype_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType FieldOptions::jstype() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.jstype)
+  return _internal_jstype();
+}
+inline void FieldOptions::_internal_set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value) {
+  assert(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.jstype_ = value;
+}
+inline void FieldOptions::set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value) {
+  _internal_set_jstype(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.jstype)
+}
+
+// optional bool lazy = 5 [default = false];
+inline bool FieldOptions::_internal_has_lazy() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool FieldOptions::has_lazy() const {
+  return _internal_has_lazy();
+}
+inline void FieldOptions::clear_lazy() {
+  _impl_.lazy_ = false;
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline bool FieldOptions::_internal_lazy() const {
+  return _impl_.lazy_;
+}
+inline bool FieldOptions::lazy() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.lazy)
+  return _internal_lazy();
+}
+inline void FieldOptions::_internal_set_lazy(bool value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.lazy_ = value;
+}
+inline void FieldOptions::set_lazy(bool value) {
+  _internal_set_lazy(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.lazy)
+}
+
+// optional bool unverified_lazy = 15 [default = false];
+inline bool FieldOptions::_internal_has_unverified_lazy() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool FieldOptions::has_unverified_lazy() const {
+  return _internal_has_unverified_lazy();
+}
+inline void FieldOptions::clear_unverified_lazy() {
+  _impl_.unverified_lazy_ = false;
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline bool FieldOptions::_internal_unverified_lazy() const {
+  return _impl_.unverified_lazy_;
+}
+inline bool FieldOptions::unverified_lazy() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.unverified_lazy)
+  return _internal_unverified_lazy();
+}
+inline void FieldOptions::_internal_set_unverified_lazy(bool value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.unverified_lazy_ = value;
+}
+inline void FieldOptions::set_unverified_lazy(bool value) {
+  _internal_set_unverified_lazy(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.unverified_lazy)
+}
+
+// optional bool deprecated = 3 [default = false];
+inline bool FieldOptions::_internal_has_deprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool FieldOptions::has_deprecated() const {
+  return _internal_has_deprecated();
+}
+inline void FieldOptions::clear_deprecated() {
+  _impl_.deprecated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline bool FieldOptions::_internal_deprecated() const {
+  return _impl_.deprecated_;
+}
+inline bool FieldOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.deprecated)
+  return _internal_deprecated();
+}
+inline void FieldOptions::_internal_set_deprecated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.deprecated_ = value;
+}
+inline void FieldOptions::set_deprecated(bool value) {
+  _internal_set_deprecated(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.deprecated)
+}
+
+// optional bool weak = 10 [default = false];
+inline bool FieldOptions::_internal_has_weak() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool FieldOptions::has_weak() const {
+  return _internal_has_weak();
+}
+inline void FieldOptions::clear_weak() {
+  _impl_.weak_ = false;
+  _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline bool FieldOptions::_internal_weak() const {
+  return _impl_.weak_;
+}
+inline bool FieldOptions::weak() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.weak)
+  return _internal_weak();
+}
+inline void FieldOptions::_internal_set_weak(bool value) {
+  _impl_._has_bits_[0] |= 0x00000040u;
+  _impl_.weak_ = value;
+}
+inline void FieldOptions::set_weak(bool value) {
+  _internal_set_weak(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.weak)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int FieldOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int FieldOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void FieldOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+FieldOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FieldOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.FieldOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+FieldOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FieldOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// OneofOptions
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int OneofOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int OneofOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void OneofOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+OneofOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.OneofOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& OneofOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& OneofOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.OneofOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.OneofOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+OneofOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.OneofOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// EnumOptions
+
+// optional bool allow_alias = 2;
+inline bool EnumOptions::_internal_has_allow_alias() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EnumOptions::has_allow_alias() const {
+  return _internal_has_allow_alias();
+}
+inline void EnumOptions::clear_allow_alias() {
+  _impl_.allow_alias_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool EnumOptions::_internal_allow_alias() const {
+  return _impl_.allow_alias_;
+}
+inline bool EnumOptions::allow_alias() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.allow_alias)
+  return _internal_allow_alias();
+}
+inline void EnumOptions::_internal_set_allow_alias(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.allow_alias_ = value;
+}
+inline void EnumOptions::set_allow_alias(bool value) {
+  _internal_set_allow_alias(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.allow_alias)
+}
+
+// optional bool deprecated = 3 [default = false];
+inline bool EnumOptions::_internal_has_deprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool EnumOptions::has_deprecated() const {
+  return _internal_has_deprecated();
+}
+inline void EnumOptions::clear_deprecated() {
+  _impl_.deprecated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool EnumOptions::_internal_deprecated() const {
+  return _impl_.deprecated_;
+}
+inline bool EnumOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.deprecated)
+  return _internal_deprecated();
+}
+inline void EnumOptions::_internal_set_deprecated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.deprecated_ = value;
+}
+inline void EnumOptions::set_deprecated(bool value) {
+  _internal_set_deprecated(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.deprecated)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int EnumOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int EnumOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void EnumOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+EnumOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+EnumOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// EnumValueOptions
+
+// optional bool deprecated = 1 [default = false];
+inline bool EnumValueOptions::_internal_has_deprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EnumValueOptions::has_deprecated() const {
+  return _internal_has_deprecated();
+}
+inline void EnumValueOptions::clear_deprecated() {
+  _impl_.deprecated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool EnumValueOptions::_internal_deprecated() const {
+  return _impl_.deprecated_;
+}
+inline bool EnumValueOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.deprecated)
+  return _internal_deprecated();
+}
+inline void EnumValueOptions::_internal_set_deprecated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.deprecated_ = value;
+}
+inline void EnumValueOptions::set_deprecated(bool value) {
+  _internal_set_deprecated(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueOptions.deprecated)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int EnumValueOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int EnumValueOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void EnumValueOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+EnumValueOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumValueOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+EnumValueOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// ServiceOptions
+
+// optional bool deprecated = 33 [default = false];
+inline bool ServiceOptions::_internal_has_deprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ServiceOptions::has_deprecated() const {
+  return _internal_has_deprecated();
+}
+inline void ServiceOptions::clear_deprecated() {
+  _impl_.deprecated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool ServiceOptions::_internal_deprecated() const {
+  return _impl_.deprecated_;
+}
+inline bool ServiceOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.deprecated)
+  return _internal_deprecated();
+}
+inline void ServiceOptions::_internal_set_deprecated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.deprecated_ = value;
+}
+inline void ServiceOptions::set_deprecated(bool value) {
+  _internal_set_deprecated(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.ServiceOptions.deprecated)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int ServiceOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int ServiceOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void ServiceOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+ServiceOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ServiceOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.ServiceOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+ServiceOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.ServiceOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// MethodOptions
+
+// optional bool deprecated = 33 [default = false];
+inline bool MethodOptions::_internal_has_deprecated() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MethodOptions::has_deprecated() const {
+  return _internal_has_deprecated();
+}
+inline void MethodOptions::clear_deprecated() {
+  _impl_.deprecated_ = false;
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline bool MethodOptions::_internal_deprecated() const {
+  return _impl_.deprecated_;
+}
+inline bool MethodOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.deprecated)
+  return _internal_deprecated();
+}
+inline void MethodOptions::_internal_set_deprecated(bool value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.deprecated_ = value;
+}
+inline void MethodOptions::set_deprecated(bool value) {
+  _internal_set_deprecated(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.deprecated)
+}
+
+// optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
+inline bool MethodOptions::_internal_has_idempotency_level() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MethodOptions::has_idempotency_level() const {
+  return _internal_has_idempotency_level();
+}
+inline void MethodOptions::clear_idempotency_level() {
+  _impl_.idempotency_level_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel MethodOptions::_internal_idempotency_level() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel >(_impl_.idempotency_level_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel MethodOptions::idempotency_level() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.idempotency_level)
+  return _internal_idempotency_level();
+}
+inline void MethodOptions::_internal_set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value) {
+  assert(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_IsValid(value));
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.idempotency_level_ = value;
+}
+inline void MethodOptions::set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value) {
+  _internal_set_idempotency_level(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.idempotency_level)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int MethodOptions::_internal_uninterpreted_option_size() const {
+  return _impl_.uninterpreted_option_.size();
+}
+inline int MethodOptions::uninterpreted_option_size() const {
+  return _internal_uninterpreted_option_size();
+}
+inline void MethodOptions::clear_uninterpreted_option() {
+  _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
+MethodOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.MethodOptions.uninterpreted_option)
+  return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MethodOptions::_internal_uninterpreted_option(int index) const {
+  return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.uninterpreted_option)
+  return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::_internal_add_uninterpreted_option() {
+  return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::add_uninterpreted_option() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+  // @@protoc_insertion_point(field_add:google.protobuf.MethodOptions.uninterpreted_option)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
+MethodOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.MethodOptions.uninterpreted_option)
+  return _impl_.uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// UninterpretedOption_NamePart
+
+// required string name_part = 1;
+inline bool UninterpretedOption_NamePart::_internal_has_name_part() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool UninterpretedOption_NamePart::has_name_part() const {
+  return _internal_has_name_part();
+}
+inline void UninterpretedOption_NamePart::clear_name_part() {
+  _impl_.name_part_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& UninterpretedOption_NamePart::name_part() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.name_part)
+  return _internal_name_part();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void UninterpretedOption_NamePart::set_name_part(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.name_part_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+inline std::string* UninterpretedOption_NamePart::mutable_name_part() {
+  std::string* _s = _internal_mutable_name_part();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.NamePart.name_part)
+  return _s;
+}
+inline const std::string& UninterpretedOption_NamePart::_internal_name_part() const {
+  return _impl_.name_part_.Get();
+}
+inline void UninterpretedOption_NamePart::_internal_set_name_part(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.name_part_.Set(value, GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption_NamePart::_internal_mutable_name_part() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.name_part_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption_NamePart::release_name_part() {
+  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.NamePart.name_part)
+  if (!_internal_has_name_part()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.name_part_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_part_.IsDefault()) {
+    _impl_.name_part_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void UninterpretedOption_NamePart::set_allocated_name_part(std::string* name_part) {
+  if (name_part != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.name_part_.SetAllocated(name_part, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_part_.IsDefault()) {
+    _impl_.name_part_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+
+// required bool is_extension = 2;
+inline bool UninterpretedOption_NamePart::_internal_has_is_extension() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool UninterpretedOption_NamePart::has_is_extension() const {
+  return _internal_has_is_extension();
+}
+inline void UninterpretedOption_NamePart::clear_is_extension() {
+  _impl_.is_extension_ = false;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline bool UninterpretedOption_NamePart::_internal_is_extension() const {
+  return _impl_.is_extension_;
+}
+inline bool UninterpretedOption_NamePart::is_extension() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.is_extension)
+  return _internal_is_extension();
+}
+inline void UninterpretedOption_NamePart::_internal_set_is_extension(bool value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.is_extension_ = value;
+}
+inline void UninterpretedOption_NamePart::set_is_extension(bool value) {
+  _internal_set_is_extension(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.is_extension)
+}
+
+// -------------------------------------------------------------------
+
+// UninterpretedOption
+
+// repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
+inline int UninterpretedOption::_internal_name_size() const {
+  return _impl_.name_.size();
+}
+inline int UninterpretedOption::name_size() const {
+  return _internal_name_size();
+}
+inline void UninterpretedOption::clear_name() {
+  _impl_.name_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.name)
+  return _impl_.name_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >*
+UninterpretedOption::mutable_name() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.UninterpretedOption.name)
+  return &_impl_.name_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& UninterpretedOption::_internal_name(int index) const {
+  return _impl_.name_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.name)
+  return _internal_name(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::_internal_add_name() {
+  return _impl_.name_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::add_name() {
+  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* _add = _internal_add_name();
+  // @@protoc_insertion_point(field_add:google.protobuf.UninterpretedOption.name)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >&
+UninterpretedOption::name() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.UninterpretedOption.name)
+  return _impl_.name_;
+}
+
+// optional string identifier_value = 3;
+inline bool UninterpretedOption::_internal_has_identifier_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool UninterpretedOption::has_identifier_value() const {
+  return _internal_has_identifier_value();
+}
+inline void UninterpretedOption::clear_identifier_value() {
+  _impl_.identifier_value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& UninterpretedOption::identifier_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.identifier_value)
+  return _internal_identifier_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void UninterpretedOption::set_identifier_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.identifier_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.identifier_value)
+}
+inline std::string* UninterpretedOption::mutable_identifier_value() {
+  std::string* _s = _internal_mutable_identifier_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.identifier_value)
+  return _s;
+}
+inline const std::string& UninterpretedOption::_internal_identifier_value() const {
+  return _impl_.identifier_value_.Get();
+}
+inline void UninterpretedOption::_internal_set_identifier_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.identifier_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::_internal_mutable_identifier_value() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.identifier_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::release_identifier_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.identifier_value)
+  if (!_internal_has_identifier_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.identifier_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.identifier_value_.IsDefault()) {
+    _impl_.identifier_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void UninterpretedOption::set_allocated_identifier_value(std::string* identifier_value) {
+  if (identifier_value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.identifier_value_.SetAllocated(identifier_value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.identifier_value_.IsDefault()) {
+    _impl_.identifier_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.identifier_value)
+}
+
+// optional uint64 positive_int_value = 4;
+inline bool UninterpretedOption::_internal_has_positive_int_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool UninterpretedOption::has_positive_int_value() const {
+  return _internal_has_positive_int_value();
+}
+inline void UninterpretedOption::clear_positive_int_value() {
+  _impl_.positive_int_value_ = uint64_t{0u};
+  _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline uint64_t UninterpretedOption::_internal_positive_int_value() const {
+  return _impl_.positive_int_value_;
+}
+inline uint64_t UninterpretedOption::positive_int_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.positive_int_value)
+  return _internal_positive_int_value();
+}
+inline void UninterpretedOption::_internal_set_positive_int_value(uint64_t value) {
+  _impl_._has_bits_[0] |= 0x00000008u;
+  _impl_.positive_int_value_ = value;
+}
+inline void UninterpretedOption::set_positive_int_value(uint64_t value) {
+  _internal_set_positive_int_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.positive_int_value)
+}
+
+// optional int64 negative_int_value = 5;
+inline bool UninterpretedOption::_internal_has_negative_int_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool UninterpretedOption::has_negative_int_value() const {
+  return _internal_has_negative_int_value();
+}
+inline void UninterpretedOption::clear_negative_int_value() {
+  _impl_.negative_int_value_ = int64_t{0};
+  _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline int64_t UninterpretedOption::_internal_negative_int_value() const {
+  return _impl_.negative_int_value_;
+}
+inline int64_t UninterpretedOption::negative_int_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.negative_int_value)
+  return _internal_negative_int_value();
+}
+inline void UninterpretedOption::_internal_set_negative_int_value(int64_t value) {
+  _impl_._has_bits_[0] |= 0x00000010u;
+  _impl_.negative_int_value_ = value;
+}
+inline void UninterpretedOption::set_negative_int_value(int64_t value) {
+  _internal_set_negative_int_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.negative_int_value)
+}
+
+// optional double double_value = 6;
+inline bool UninterpretedOption::_internal_has_double_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool UninterpretedOption::has_double_value() const {
+  return _internal_has_double_value();
+}
+inline void UninterpretedOption::clear_double_value() {
+  _impl_.double_value_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline double UninterpretedOption::_internal_double_value() const {
+  return _impl_.double_value_;
+}
+inline double UninterpretedOption::double_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.double_value)
+  return _internal_double_value();
+}
+inline void UninterpretedOption::_internal_set_double_value(double value) {
+  _impl_._has_bits_[0] |= 0x00000020u;
+  _impl_.double_value_ = value;
+}
+inline void UninterpretedOption::set_double_value(double value) {
+  _internal_set_double_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.double_value)
+}
+
+// optional bytes string_value = 7;
+inline bool UninterpretedOption::_internal_has_string_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool UninterpretedOption::has_string_value() const {
+  return _internal_has_string_value();
+}
+inline void UninterpretedOption::clear_string_value() {
+  _impl_.string_value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& UninterpretedOption::string_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.string_value)
+  return _internal_string_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void UninterpretedOption::set_string_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.string_value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.string_value)
+}
+inline std::string* UninterpretedOption::mutable_string_value() {
+  std::string* _s = _internal_mutable_string_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.string_value)
+  return _s;
+}
+inline const std::string& UninterpretedOption::_internal_string_value() const {
+  return _impl_.string_value_.Get();
+}
+inline void UninterpretedOption::_internal_set_string_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.string_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::_internal_mutable_string_value() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.string_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::release_string_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.string_value)
+  if (!_internal_has_string_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.string_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.string_value_.IsDefault()) {
+    _impl_.string_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void UninterpretedOption::set_allocated_string_value(std::string* string_value) {
+  if (string_value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.string_value_.SetAllocated(string_value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.string_value_.IsDefault()) {
+    _impl_.string_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.string_value)
+}
+
+// optional string aggregate_value = 8;
+inline bool UninterpretedOption::_internal_has_aggregate_value() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool UninterpretedOption::has_aggregate_value() const {
+  return _internal_has_aggregate_value();
+}
+inline void UninterpretedOption::clear_aggregate_value() {
+  _impl_.aggregate_value_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& UninterpretedOption::aggregate_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.aggregate_value)
+  return _internal_aggregate_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void UninterpretedOption::set_aggregate_value(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000004u;
+ _impl_.aggregate_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.aggregate_value)
+}
+inline std::string* UninterpretedOption::mutable_aggregate_value() {
+  std::string* _s = _internal_mutable_aggregate_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.aggregate_value)
+  return _s;
+}
+inline const std::string& UninterpretedOption::_internal_aggregate_value() const {
+  return _impl_.aggregate_value_.Get();
+}
+inline void UninterpretedOption::_internal_set_aggregate_value(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.aggregate_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::_internal_mutable_aggregate_value() {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  return _impl_.aggregate_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::release_aggregate_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.aggregate_value)
+  if (!_internal_has_aggregate_value()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000004u;
+  auto* p = _impl_.aggregate_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.aggregate_value_.IsDefault()) {
+    _impl_.aggregate_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void UninterpretedOption::set_allocated_aggregate_value(std::string* aggregate_value) {
+  if (aggregate_value != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000004u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000004u;
+  }
+  _impl_.aggregate_value_.SetAllocated(aggregate_value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.aggregate_value_.IsDefault()) {
+    _impl_.aggregate_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.aggregate_value)
+}
+
+// -------------------------------------------------------------------
+
+// SourceCodeInfo_Location
+
+// repeated int32 path = 1 [packed = true];
+inline int SourceCodeInfo_Location::_internal_path_size() const {
+  return _impl_.path_.size();
+}
+inline int SourceCodeInfo_Location::path_size() const {
+  return _internal_path_size();
+}
+inline void SourceCodeInfo_Location::clear_path() {
+  _impl_.path_.Clear();
+}
+inline int32_t SourceCodeInfo_Location::_internal_path(int index) const {
+  return _impl_.path_.Get(index);
+}
+inline int32_t SourceCodeInfo_Location::path(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.path)
+  return _internal_path(index);
+}
+inline void SourceCodeInfo_Location::set_path(int index, int32_t value) {
+  _impl_.path_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.path)
+}
+inline void SourceCodeInfo_Location::_internal_add_path(int32_t value) {
+  _impl_.path_.Add(value);
+}
+inline void SourceCodeInfo_Location::add_path(int32_t value) {
+  _internal_add_path(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.path)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+SourceCodeInfo_Location::_internal_path() const {
+  return _impl_.path_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+SourceCodeInfo_Location::path() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.path)
+  return _internal_path();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+SourceCodeInfo_Location::_internal_mutable_path() {
+  return &_impl_.path_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+SourceCodeInfo_Location::mutable_path() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.path)
+  return _internal_mutable_path();
+}
+
+// repeated int32 span = 2 [packed = true];
+inline int SourceCodeInfo_Location::_internal_span_size() const {
+  return _impl_.span_.size();
+}
+inline int SourceCodeInfo_Location::span_size() const {
+  return _internal_span_size();
+}
+inline void SourceCodeInfo_Location::clear_span() {
+  _impl_.span_.Clear();
+}
+inline int32_t SourceCodeInfo_Location::_internal_span(int index) const {
+  return _impl_.span_.Get(index);
+}
+inline int32_t SourceCodeInfo_Location::span(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.span)
+  return _internal_span(index);
+}
+inline void SourceCodeInfo_Location::set_span(int index, int32_t value) {
+  _impl_.span_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.span)
+}
+inline void SourceCodeInfo_Location::_internal_add_span(int32_t value) {
+  _impl_.span_.Add(value);
+}
+inline void SourceCodeInfo_Location::add_span(int32_t value) {
+  _internal_add_span(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.span)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+SourceCodeInfo_Location::_internal_span() const {
+  return _impl_.span_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+SourceCodeInfo_Location::span() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.span)
+  return _internal_span();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+SourceCodeInfo_Location::_internal_mutable_span() {
+  return &_impl_.span_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+SourceCodeInfo_Location::mutable_span() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.span)
+  return _internal_mutable_span();
+}
+
+// optional string leading_comments = 3;
+inline bool SourceCodeInfo_Location::_internal_has_leading_comments() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SourceCodeInfo_Location::has_leading_comments() const {
+  return _internal_has_leading_comments();
+}
+inline void SourceCodeInfo_Location::clear_leading_comments() {
+  _impl_.leading_comments_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SourceCodeInfo_Location::leading_comments() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_comments)
+  return _internal_leading_comments();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SourceCodeInfo_Location::set_leading_comments(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.leading_comments_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_comments)
+}
+inline std::string* SourceCodeInfo_Location::mutable_leading_comments() {
+  std::string* _s = _internal_mutable_leading_comments();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_comments)
+  return _s;
+}
+inline const std::string& SourceCodeInfo_Location::_internal_leading_comments() const {
+  return _impl_.leading_comments_.Get();
+}
+inline void SourceCodeInfo_Location::_internal_set_leading_comments(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.leading_comments_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SourceCodeInfo_Location::_internal_mutable_leading_comments() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.leading_comments_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SourceCodeInfo_Location::release_leading_comments() {
+  // @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.leading_comments)
+  if (!_internal_has_leading_comments()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.leading_comments_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.leading_comments_.IsDefault()) {
+    _impl_.leading_comments_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SourceCodeInfo_Location::set_allocated_leading_comments(std::string* leading_comments) {
+  if (leading_comments != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.leading_comments_.SetAllocated(leading_comments, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.leading_comments_.IsDefault()) {
+    _impl_.leading_comments_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.leading_comments)
+}
+
+// optional string trailing_comments = 4;
+inline bool SourceCodeInfo_Location::_internal_has_trailing_comments() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SourceCodeInfo_Location::has_trailing_comments() const {
+  return _internal_has_trailing_comments();
+}
+inline void SourceCodeInfo_Location::clear_trailing_comments() {
+  _impl_.trailing_comments_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SourceCodeInfo_Location::trailing_comments() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+  return _internal_trailing_comments();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SourceCodeInfo_Location::set_trailing_comments(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000002u;
+ _impl_.trailing_comments_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+}
+inline std::string* SourceCodeInfo_Location::mutable_trailing_comments() {
+  std::string* _s = _internal_mutable_trailing_comments();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+  return _s;
+}
+inline const std::string& SourceCodeInfo_Location::_internal_trailing_comments() const {
+  return _impl_.trailing_comments_.Get();
+}
+inline void SourceCodeInfo_Location::_internal_set_trailing_comments(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.trailing_comments_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SourceCodeInfo_Location::_internal_mutable_trailing_comments() {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  return _impl_.trailing_comments_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SourceCodeInfo_Location::release_trailing_comments() {
+  // @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+  if (!_internal_has_trailing_comments()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000002u;
+  auto* p = _impl_.trailing_comments_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.trailing_comments_.IsDefault()) {
+    _impl_.trailing_comments_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void SourceCodeInfo_Location::set_allocated_trailing_comments(std::string* trailing_comments) {
+  if (trailing_comments != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000002u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000002u;
+  }
+  _impl_.trailing_comments_.SetAllocated(trailing_comments, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.trailing_comments_.IsDefault()) {
+    _impl_.trailing_comments_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+}
+
+// repeated string leading_detached_comments = 6;
+inline int SourceCodeInfo_Location::_internal_leading_detached_comments_size() const {
+  return _impl_.leading_detached_comments_.size();
+}
+inline int SourceCodeInfo_Location::leading_detached_comments_size() const {
+  return _internal_leading_detached_comments_size();
+}
+inline void SourceCodeInfo_Location::clear_leading_detached_comments() {
+  _impl_.leading_detached_comments_.Clear();
+}
+inline std::string* SourceCodeInfo_Location::add_leading_detached_comments() {
+  std::string* _s = _internal_add_leading_detached_comments();
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return _s;
+}
+inline const std::string& SourceCodeInfo_Location::_internal_leading_detached_comments(int index) const {
+  return _impl_.leading_detached_comments_.Get(index);
+}
+inline const std::string& SourceCodeInfo_Location::leading_detached_comments(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return _internal_leading_detached_comments(index);
+}
+inline std::string* SourceCodeInfo_Location::mutable_leading_detached_comments(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return _impl_.leading_detached_comments_.Mutable(index);
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const std::string& value) {
+  _impl_.leading_detached_comments_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, std::string&& value) {
+  _impl_.leading_detached_comments_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.leading_detached_comments_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value, size_t size) {
+  _impl_.leading_detached_comments_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline std::string* SourceCodeInfo_Location::_internal_add_leading_detached_comments() {
+  return _impl_.leading_detached_comments_.Add();
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const std::string& value) {
+  _impl_.leading_detached_comments_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(std::string&& value) {
+  _impl_.leading_detached_comments_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.leading_detached_comments_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value, size_t size) {
+  _impl_.leading_detached_comments_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+SourceCodeInfo_Location::leading_detached_comments() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return _impl_.leading_detached_comments_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+SourceCodeInfo_Location::mutable_leading_detached_comments() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return &_impl_.leading_detached_comments_;
+}
+
+// -------------------------------------------------------------------
+
+// SourceCodeInfo
+
+// repeated .google.protobuf.SourceCodeInfo.Location location = 1;
+inline int SourceCodeInfo::_internal_location_size() const {
+  return _impl_.location_.size();
+}
+inline int SourceCodeInfo::location_size() const {
+  return _internal_location_size();
+}
+inline void SourceCodeInfo::clear_location() {
+  _impl_.location_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::mutable_location(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.location)
+  return _impl_.location_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >*
+SourceCodeInfo::mutable_location() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.location)
+  return &_impl_.location_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& SourceCodeInfo::_internal_location(int index) const {
+  return _impl_.location_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& SourceCodeInfo::location(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.location)
+  return _internal_location(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::_internal_add_location() {
+  return _impl_.location_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::add_location() {
+  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* _add = _internal_add_location();
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.location)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >&
+SourceCodeInfo::location() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.location)
+  return _impl_.location_;
+}
+
+// -------------------------------------------------------------------
+
+// GeneratedCodeInfo_Annotation
+
+// repeated int32 path = 1 [packed = true];
+inline int GeneratedCodeInfo_Annotation::_internal_path_size() const {
+  return _impl_.path_.size();
+}
+inline int GeneratedCodeInfo_Annotation::path_size() const {
+  return _internal_path_size();
+}
+inline void GeneratedCodeInfo_Annotation::clear_path() {
+  _impl_.path_.Clear();
+}
+inline int32_t GeneratedCodeInfo_Annotation::_internal_path(int index) const {
+  return _impl_.path_.Get(index);
+}
+inline int32_t GeneratedCodeInfo_Annotation::path(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.path)
+  return _internal_path(index);
+}
+inline void GeneratedCodeInfo_Annotation::set_path(int index, int32_t value) {
+  _impl_.path_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.path)
+}
+inline void GeneratedCodeInfo_Annotation::_internal_add_path(int32_t value) {
+  _impl_.path_.Add(value);
+}
+inline void GeneratedCodeInfo_Annotation::add_path(int32_t value) {
+  _internal_add_path(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.Annotation.path)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+GeneratedCodeInfo_Annotation::_internal_path() const {
+  return _impl_.path_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+GeneratedCodeInfo_Annotation::path() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
+  return _internal_path();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+GeneratedCodeInfo_Annotation::_internal_mutable_path() {
+  return &_impl_.path_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+GeneratedCodeInfo_Annotation::mutable_path() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
+  return _internal_mutable_path();
+}
+
+// optional string source_file = 2;
+inline bool GeneratedCodeInfo_Annotation::_internal_has_source_file() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool GeneratedCodeInfo_Annotation::has_source_file() const {
+  return _internal_has_source_file();
+}
+inline void GeneratedCodeInfo_Annotation::clear_source_file() {
+  _impl_.source_file_.ClearToEmpty();
+  _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& GeneratedCodeInfo_Annotation::source_file() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+  return _internal_source_file();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void GeneratedCodeInfo_Annotation::set_source_file(ArgT0&& arg0, ArgT... args) {
+ _impl_._has_bits_[0] |= 0x00000001u;
+ _impl_.source_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+}
+inline std::string* GeneratedCodeInfo_Annotation::mutable_source_file() {
+  std::string* _s = _internal_mutable_source_file();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+  return _s;
+}
+inline const std::string& GeneratedCodeInfo_Annotation::_internal_source_file() const {
+  return _impl_.source_file_.Get();
+}
+inline void GeneratedCodeInfo_Annotation::_internal_set_source_file(const std::string& value) {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  _impl_.source_file_.Set(value, GetArenaForAllocation());
+}
+inline std::string* GeneratedCodeInfo_Annotation::_internal_mutable_source_file() {
+  _impl_._has_bits_[0] |= 0x00000001u;
+  return _impl_.source_file_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GeneratedCodeInfo_Annotation::release_source_file() {
+  // @@protoc_insertion_point(field_release:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+  if (!_internal_has_source_file()) {
+    return nullptr;
+  }
+  _impl_._has_bits_[0] &= ~0x00000001u;
+  auto* p = _impl_.source_file_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.source_file_.IsDefault()) {
+    _impl_.source_file_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  return p;
+}
+inline void GeneratedCodeInfo_Annotation::set_allocated_source_file(std::string* source_file) {
+  if (source_file != nullptr) {
+    _impl_._has_bits_[0] |= 0x00000001u;
+  } else {
+    _impl_._has_bits_[0] &= ~0x00000001u;
+  }
+  _impl_.source_file_.SetAllocated(source_file, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.source_file_.IsDefault()) {
+    _impl_.source_file_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+}
+
+// optional int32 begin = 3;
+inline bool GeneratedCodeInfo_Annotation::_internal_has_begin() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool GeneratedCodeInfo_Annotation::has_begin() const {
+  return _internal_has_begin();
+}
+inline void GeneratedCodeInfo_Annotation::clear_begin() {
+  _impl_.begin_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline int32_t GeneratedCodeInfo_Annotation::_internal_begin() const {
+  return _impl_.begin_;
+}
+inline int32_t GeneratedCodeInfo_Annotation::begin() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.begin)
+  return _internal_begin();
+}
+inline void GeneratedCodeInfo_Annotation::_internal_set_begin(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000002u;
+  _impl_.begin_ = value;
+}
+inline void GeneratedCodeInfo_Annotation::set_begin(int32_t value) {
+  _internal_set_begin(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.begin)
+}
+
+// optional int32 end = 4;
+inline bool GeneratedCodeInfo_Annotation::_internal_has_end() const {
+  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool GeneratedCodeInfo_Annotation::has_end() const {
+  return _internal_has_end();
+}
+inline void GeneratedCodeInfo_Annotation::clear_end() {
+  _impl_.end_ = 0;
+  _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline int32_t GeneratedCodeInfo_Annotation::_internal_end() const {
+  return _impl_.end_;
+}
+inline int32_t GeneratedCodeInfo_Annotation::end() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.end)
+  return _internal_end();
+}
+inline void GeneratedCodeInfo_Annotation::_internal_set_end(int32_t value) {
+  _impl_._has_bits_[0] |= 0x00000004u;
+  _impl_.end_ = value;
+}
+inline void GeneratedCodeInfo_Annotation::set_end(int32_t value) {
+  _internal_set_end(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.end)
+}
+
+// -------------------------------------------------------------------
+
+// GeneratedCodeInfo
+
+// repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
+inline int GeneratedCodeInfo::_internal_annotation_size() const {
+  return _impl_.annotation_.size();
+}
+inline int GeneratedCodeInfo::annotation_size() const {
+  return _internal_annotation_size();
+}
+inline void GeneratedCodeInfo::clear_annotation() {
+  _impl_.annotation_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::mutable_annotation(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.annotation)
+  return _impl_.annotation_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >*
+GeneratedCodeInfo::mutable_annotation() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.annotation)
+  return &_impl_.annotation_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::_internal_annotation(int index) const {
+  return _impl_.annotation_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::annotation(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.annotation)
+  return _internal_annotation(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::_internal_add_annotation() {
+  return _impl_.annotation_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::add_annotation() {
+  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* _add = _internal_add_annotation();
+  // @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.annotation)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >&
+GeneratedCodeInfo::annotation() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.annotation)
+  return _impl_.annotation_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type>() {
+  return ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_descriptor();
+}
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label>() {
+  return ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_descriptor();
+}
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode>() {
+  return ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_descriptor();
+}
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType>() {
+  return ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType_descriptor();
+}
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType>() {
+  return ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_descriptor();
+}
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel>() {
+  return ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fdescriptor_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/descriptor.proto b/CAPI/cpp/grpc/include/google/protobuf/descriptor.proto
new file mode 100644
index 0000000..f8eb216
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/descriptor.proto
@@ -0,0 +1,921 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+
+
+syntax = "proto2";
+
+package google.protobuf;
+
+option go_package = "google.golang.org/protobuf/types/descriptorpb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DescriptorProtos";
+option csharp_namespace = "Google.Protobuf.Reflection";
+option objc_class_prefix = "GPB";
+option cc_enable_arenas = true;
+
+// descriptor.proto must be optimized for speed because reflection-based
+// algorithms don't work during bootstrapping.
+option optimize_for = SPEED;
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+message FileDescriptorSet {
+  repeated FileDescriptorProto file = 1;
+}
+
+// Describes a complete .proto file.
+message FileDescriptorProto {
+  optional string name = 1;     // file name, relative to root of source tree
+  optional string package = 2;  // e.g. "foo", "foo.bar", etc.
+
+  // Names of files imported by this file.
+  repeated string dependency = 3;
+  // Indexes of the public imported files in the dependency list above.
+  repeated int32 public_dependency = 10;
+  // Indexes of the weak imported files in the dependency list.
+  // For Google-internal migration only. Do not use.
+  repeated int32 weak_dependency = 11;
+
+  // All top-level definitions in this file.
+  repeated DescriptorProto message_type = 4;
+  repeated EnumDescriptorProto enum_type = 5;
+  repeated ServiceDescriptorProto service = 6;
+  repeated FieldDescriptorProto extension = 7;
+
+  optional FileOptions options = 8;
+
+  // This field contains optional information about the original source code.
+  // You may safely remove this entire field without harming runtime
+  // functionality of the descriptors -- the information is needed only by
+  // development tools.
+  optional SourceCodeInfo source_code_info = 9;
+
+  // The syntax of the proto file.
+  // The supported values are "proto2" and "proto3".
+  optional string syntax = 12;
+}
+
+// Describes a message type.
+message DescriptorProto {
+  optional string name = 1;
+
+  repeated FieldDescriptorProto field = 2;
+  repeated FieldDescriptorProto extension = 6;
+
+  repeated DescriptorProto nested_type = 3;
+  repeated EnumDescriptorProto enum_type = 4;
+
+  message ExtensionRange {
+    optional int32 start = 1;  // Inclusive.
+    optional int32 end = 2;    // Exclusive.
+
+    optional ExtensionRangeOptions options = 3;
+  }
+  repeated ExtensionRange extension_range = 5;
+
+  repeated OneofDescriptorProto oneof_decl = 8;
+
+  optional MessageOptions options = 7;
+
+  // Range of reserved tag numbers. Reserved tag numbers may not be used by
+  // fields or extension ranges in the same message. Reserved ranges may
+  // not overlap.
+  message ReservedRange {
+    optional int32 start = 1;  // Inclusive.
+    optional int32 end = 2;    // Exclusive.
+  }
+  repeated ReservedRange reserved_range = 9;
+  // Reserved field names, which may not be used by fields in the same message.
+  // A given name may only be reserved once.
+  repeated string reserved_name = 10;
+}
+
+message ExtensionRangeOptions {
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+// Describes a field within a message.
+message FieldDescriptorProto {
+  enum Type {
+    // 0 is reserved for errors.
+    // Order is weird for historical reasons.
+    TYPE_DOUBLE = 1;
+    TYPE_FLOAT = 2;
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+    // negative values are likely.
+    TYPE_INT64 = 3;
+    TYPE_UINT64 = 4;
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+    // negative values are likely.
+    TYPE_INT32 = 5;
+    TYPE_FIXED64 = 6;
+    TYPE_FIXED32 = 7;
+    TYPE_BOOL = 8;
+    TYPE_STRING = 9;
+    // Tag-delimited aggregate.
+    // Group type is deprecated and not supported in proto3. However, Proto3
+    // implementations should still be able to parse the group wire format and
+    // treat group fields as unknown fields.
+    TYPE_GROUP = 10;
+    TYPE_MESSAGE = 11;  // Length-delimited aggregate.
+
+    // New in version 2.
+    TYPE_BYTES = 12;
+    TYPE_UINT32 = 13;
+    TYPE_ENUM = 14;
+    TYPE_SFIXED32 = 15;
+    TYPE_SFIXED64 = 16;
+    TYPE_SINT32 = 17;  // Uses ZigZag encoding.
+    TYPE_SINT64 = 18;  // Uses ZigZag encoding.
+  }
+
+  enum Label {
+    // 0 is reserved for errors
+    LABEL_OPTIONAL = 1;
+    LABEL_REQUIRED = 2;
+    LABEL_REPEATED = 3;
+  }
+
+  optional string name = 1;
+  optional int32 number = 3;
+  optional Label label = 4;
+
+  // If type_name is set, this need not be set.  If both this and type_name
+  // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+  optional Type type = 5;
+
+  // For message and enum types, this is the name of the type.  If the name
+  // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+  // rules are used to find the type (i.e. first the nested types within this
+  // message are searched, then within the parent, on up to the root
+  // namespace).
+  optional string type_name = 6;
+
+  // For extensions, this is the name of the type being extended.  It is
+  // resolved in the same manner as type_name.
+  optional string extendee = 2;
+
+  // For numeric types, contains the original text representation of the value.
+  // For booleans, "true" or "false".
+  // For strings, contains the default text contents (not escaped in any way).
+  // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+  optional string default_value = 7;
+
+  // If set, gives the index of a oneof in the containing type's oneof_decl
+  // list.  This field is a member of that oneof.
+  optional int32 oneof_index = 9;
+
+  // JSON name of this field. The value is set by protocol compiler. If the
+  // user has set a "json_name" option on this field, that option's value
+  // will be used. Otherwise, it's deduced from the field's name by converting
+  // it to camelCase.
+  optional string json_name = 10;
+
+  optional FieldOptions options = 8;
+
+  // If true, this is a proto3 "optional". When a proto3 field is optional, it
+  // tracks presence regardless of field type.
+  //
+  // When proto3_optional is true, this field must be belong to a oneof to
+  // signal to old proto3 clients that presence is tracked for this field. This
+  // oneof is known as a "synthetic" oneof, and this field must be its sole
+  // member (each proto3 optional field gets its own synthetic oneof). Synthetic
+  // oneofs exist in the descriptor only, and do not generate any API. Synthetic
+  // oneofs must be ordered after all "real" oneofs.
+  //
+  // For message fields, proto3_optional doesn't create any semantic change,
+  // since non-repeated message fields always track presence. However it still
+  // indicates the semantic detail of whether the user wrote "optional" or not.
+  // This can be useful for round-tripping the .proto file. For consistency we
+  // give message fields a synthetic oneof also, even though it is not required
+  // to track presence. This is especially important because the parser can't
+  // tell if a field is a message or an enum, so it must always create a
+  // synthetic oneof.
+  //
+  // Proto2 optional fields do not set this flag, because they already indicate
+  // optional with `LABEL_OPTIONAL`.
+  optional bool proto3_optional = 17;
+}
+
+// Describes a oneof.
+message OneofDescriptorProto {
+  optional string name = 1;
+  optional OneofOptions options = 2;
+}
+
+// Describes an enum type.
+message EnumDescriptorProto {
+  optional string name = 1;
+
+  repeated EnumValueDescriptorProto value = 2;
+
+  optional EnumOptions options = 3;
+
+  // Range of reserved numeric values. Reserved values may not be used by
+  // entries in the same enum. Reserved ranges may not overlap.
+  //
+  // Note that this is distinct from DescriptorProto.ReservedRange in that it
+  // is inclusive such that it can appropriately represent the entire int32
+  // domain.
+  message EnumReservedRange {
+    optional int32 start = 1;  // Inclusive.
+    optional int32 end = 2;    // Inclusive.
+  }
+
+  // Range of reserved numeric values. Reserved numeric values may not be used
+  // by enum values in the same enum declaration. Reserved ranges may not
+  // overlap.
+  repeated EnumReservedRange reserved_range = 4;
+
+  // Reserved enum value names, which may not be reused. A given name may only
+  // be reserved once.
+  repeated string reserved_name = 5;
+}
+
+// Describes a value within an enum.
+message EnumValueDescriptorProto {
+  optional string name = 1;
+  optional int32 number = 2;
+
+  optional EnumValueOptions options = 3;
+}
+
+// Describes a service.
+message ServiceDescriptorProto {
+  optional string name = 1;
+  repeated MethodDescriptorProto method = 2;
+
+  optional ServiceOptions options = 3;
+}
+
+// Describes a method of a service.
+message MethodDescriptorProto {
+  optional string name = 1;
+
+  // Input and output type names.  These are resolved in the same way as
+  // FieldDescriptorProto.type_name, but must refer to a message type.
+  optional string input_type = 2;
+  optional string output_type = 3;
+
+  optional MethodOptions options = 4;
+
+  // Identifies if client streams multiple client messages
+  optional bool client_streaming = 5 [default = false];
+  // Identifies if server streams multiple server messages
+  optional bool server_streaming = 6 [default = false];
+}
+
+
+// ===================================================================
+// Options
+
+// Each of the definitions above may have "options" attached.  These are
+// just annotations which may cause code to be generated slightly differently
+// or may contain hints for code that manipulates protocol messages.
+//
+// Clients may define custom options as extensions of the *Options messages.
+// These extensions may not yet be known at parsing time, so the parser cannot
+// store the values in them.  Instead it stores them in a field in the *Options
+// message called uninterpreted_option. This field must have the same name
+// across all *Options messages. We then use this field to populate the
+// extensions when we build a descriptor, at which point all protos have been
+// parsed and so all extensions are known.
+//
+// Extension numbers for custom options may be chosen as follows:
+// * For options which will only be used within a single application or
+//   organization, or for experimental options, use field numbers 50000
+//   through 99999.  It is up to you to ensure that you do not use the
+//   same number for multiple options.
+// * For options which will be published and used publicly by multiple
+//   independent entities, e-mail protobuf-global-extension-registry@google.com
+//   to reserve extension numbers. Simply provide your project name (e.g.
+//   Objective-C plugin) and your project website (if available) -- there's no
+//   need to explain how you intend to use them. Usually you only need one
+//   extension number. You can declare multiple options with only one extension
+//   number by putting them in a sub-message. See the Custom Options section of
+//   the docs for examples:
+//   https://developers.google.com/protocol-buffers/docs/proto#options
+//   If this turns out to be popular, a web service will be set up
+//   to automatically assign option numbers.
+
+message FileOptions {
+
+  // Sets the Java package where classes generated from this .proto will be
+  // placed.  By default, the proto package is used, but this is often
+  // inappropriate because proto packages do not normally start with backwards
+  // domain names.
+  optional string java_package = 1;
+
+
+  // Controls the name of the wrapper Java class generated for the .proto file.
+  // That class will always contain the .proto file's getDescriptor() method as
+  // well as any top-level extensions defined in the .proto file.
+  // If java_multiple_files is disabled, then all the other classes from the
+  // .proto file will be nested inside the single wrapper outer class.
+  optional string java_outer_classname = 8;
+
+  // If enabled, then the Java code generator will generate a separate .java
+  // file for each top-level message, enum, and service defined in the .proto
+  // file.  Thus, these types will *not* be nested inside the wrapper class
+  // named by java_outer_classname.  However, the wrapper class will still be
+  // generated to contain the file's getDescriptor() method as well as any
+  // top-level extensions defined in the file.
+  optional bool java_multiple_files = 10 [default = false];
+
+  // This option does nothing.
+  optional bool java_generate_equals_and_hash = 20 [deprecated=true];
+
+  // If set true, then the Java2 code generator will generate code that
+  // throws an exception whenever an attempt is made to assign a non-UTF-8
+  // byte sequence to a string field.
+  // Message reflection will do the same.
+  // However, an extension field still accepts non-UTF-8 byte sequences.
+  // This option has no effect on when used with the lite runtime.
+  optional bool java_string_check_utf8 = 27 [default = false];
+
+
+  // Generated classes can be optimized for speed or code size.
+  enum OptimizeMode {
+    SPEED = 1;         // Generate complete code for parsing, serialization,
+                       // etc.
+    CODE_SIZE = 2;     // Use ReflectionOps to implement these methods.
+    LITE_RUNTIME = 3;  // Generate code using MessageLite and the lite runtime.
+  }
+  optional OptimizeMode optimize_for = 9 [default = SPEED];
+
+  // Sets the Go package where structs generated from this .proto will be
+  // placed. If omitted, the Go package will be derived from the following:
+  //   - The basename of the package import path, if provided.
+  //   - Otherwise, the package statement in the .proto file, if present.
+  //   - Otherwise, the basename of the .proto file, without extension.
+  optional string go_package = 11;
+
+
+
+
+  // Should generic services be generated in each language?  "Generic" services
+  // are not specific to any particular RPC system.  They are generated by the
+  // main code generators in each language (without additional plugins).
+  // Generic services were the only kind of service generation supported by
+  // early versions of google.protobuf.
+  //
+  // Generic services are now considered deprecated in favor of using plugins
+  // that generate code specific to your particular RPC system.  Therefore,
+  // these default to false.  Old code which depends on generic services should
+  // explicitly set them to true.
+  optional bool cc_generic_services = 16 [default = false];
+  optional bool java_generic_services = 17 [default = false];
+  optional bool py_generic_services = 18 [default = false];
+  optional bool php_generic_services = 42 [default = false];
+
+  // Is this file deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for everything in the file, or it will be completely ignored; in the very
+  // least, this is a formalization for deprecating files.
+  optional bool deprecated = 23 [default = false];
+
+  // Enables the use of arenas for the proto messages in this file. This applies
+  // only to generated classes for C++.
+  optional bool cc_enable_arenas = 31 [default = true];
+
+
+  // Sets the objective c class prefix which is prepended to all objective c
+  // generated classes from this .proto. There is no default.
+  optional string objc_class_prefix = 36;
+
+  // Namespace for generated classes; defaults to the package.
+  optional string csharp_namespace = 37;
+
+  // By default Swift generators will take the proto package and CamelCase it
+  // replacing '.' with underscore and use that to prefix the types/symbols
+  // defined. When this options is provided, they will use this value instead
+  // to prefix the types/symbols defined.
+  optional string swift_prefix = 39;
+
+  // Sets the php class prefix which is prepended to all php generated classes
+  // from this .proto. Default is empty.
+  optional string php_class_prefix = 40;
+
+  // Use this option to change the namespace of php generated classes. Default
+  // is empty. When this option is empty, the package name will be used for
+  // determining the namespace.
+  optional string php_namespace = 41;
+
+  // Use this option to change the namespace of php generated metadata classes.
+  // Default is empty. When this option is empty, the proto file name will be
+  // used for determining the namespace.
+  optional string php_metadata_namespace = 44;
+
+  // Use this option to change the package of ruby generated classes. Default
+  // is empty. When this option is not set, the package name will be used for
+  // determining the ruby package.
+  optional string ruby_package = 45;
+
+
+  // The parser stores options it doesn't recognize here.
+  // See the documentation for the "Options" section above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message.
+  // See the documentation for the "Options" section above.
+  extensions 1000 to max;
+
+  reserved 38;
+}
+
+message MessageOptions {
+  // Set true to use the old proto1 MessageSet wire format for extensions.
+  // This is provided for backwards-compatibility with the MessageSet wire
+  // format.  You should not use this for any other reason:  It's less
+  // efficient, has fewer features, and is more complicated.
+  //
+  // The message must be defined exactly as follows:
+  //   message Foo {
+  //     option message_set_wire_format = true;
+  //     extensions 4 to max;
+  //   }
+  // Note that the message cannot have any defined fields; MessageSets only
+  // have extensions.
+  //
+  // All extensions of your type must be singular messages; e.g. they cannot
+  // be int32s, enums, or repeated messages.
+  //
+  // Because this is an option, the above two restrictions are not enforced by
+  // the protocol compiler.
+  optional bool message_set_wire_format = 1 [default = false];
+
+  // Disables the generation of the standard "descriptor()" accessor, which can
+  // conflict with a field of the same name.  This is meant to make migration
+  // from proto1 easier; new code should avoid fields named "descriptor".
+  optional bool no_standard_descriptor_accessor = 2 [default = false];
+
+  // Is this message deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the message, or it will be completely ignored; in the very least,
+  // this is a formalization for deprecating messages.
+  optional bool deprecated = 3 [default = false];
+
+  reserved 4, 5, 6;
+
+  // Whether the message is an automatically generated map entry type for the
+  // maps field.
+  //
+  // For maps fields:
+  //     map<KeyType, ValueType> map_field = 1;
+  // The parsed descriptor looks like:
+  //     message MapFieldEntry {
+  //         option map_entry = true;
+  //         optional KeyType key = 1;
+  //         optional ValueType value = 2;
+  //     }
+  //     repeated MapFieldEntry map_field = 1;
+  //
+  // Implementations may choose not to generate the map_entry=true message, but
+  // use a native map in the target language to hold the keys and values.
+  // The reflection APIs in such implementations still need to work as
+  // if the field is a repeated message field.
+  //
+  // NOTE: Do not set the option in .proto files. Always use the maps syntax
+  // instead. The option should only be implicitly set by the proto compiler
+  // parser.
+  optional bool map_entry = 7;
+
+  reserved 8;  // javalite_serializable
+  reserved 9;  // javanano_as_lite
+
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message FieldOptions {
+  // The ctype option instructs the C++ code generator to use a different
+  // representation of the field than it normally would.  See the specific
+  // options below.  This option is not yet implemented in the open source
+  // release -- sorry, we'll try to include it in a future version!
+  optional CType ctype = 1 [default = STRING];
+  enum CType {
+    // Default mode.
+    STRING = 0;
+
+    CORD = 1;
+
+    STRING_PIECE = 2;
+  }
+  // The packed option can be enabled for repeated primitive fields to enable
+  // a more efficient representation on the wire. Rather than repeatedly
+  // writing the tag and type for each element, the entire array is encoded as
+  // a single length-delimited blob. In proto3, only explicit setting it to
+  // false will avoid using packed encoding.
+  optional bool packed = 2;
+
+  // The jstype option determines the JavaScript type used for values of the
+  // field.  The option is permitted only for 64 bit integral and fixed types
+  // (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
+  // is represented as JavaScript string, which avoids loss of precision that
+  // can happen when a large value is converted to a floating point JavaScript.
+  // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+  // use the JavaScript "number" type.  The behavior of the default option
+  // JS_NORMAL is implementation dependent.
+  //
+  // This option is an enum to permit additional types to be added, e.g.
+  // goog.math.Integer.
+  optional JSType jstype = 6 [default = JS_NORMAL];
+  enum JSType {
+    // Use the default type.
+    JS_NORMAL = 0;
+
+    // Use JavaScript strings.
+    JS_STRING = 1;
+
+    // Use JavaScript numbers.
+    JS_NUMBER = 2;
+  }
+
+  // Should this field be parsed lazily?  Lazy applies only to message-type
+  // fields.  It means that when the outer message is initially parsed, the
+  // inner message's contents will not be parsed but instead stored in encoded
+  // form.  The inner message will actually be parsed when it is first accessed.
+  //
+  // This is only a hint.  Implementations are free to choose whether to use
+  // eager or lazy parsing regardless of the value of this option.  However,
+  // setting this option true suggests that the protocol author believes that
+  // using lazy parsing on this field is worth the additional bookkeeping
+  // overhead typically needed to implement it.
+  //
+  // This option does not affect the public interface of any generated code;
+  // all method signatures remain the same.  Furthermore, thread-safety of the
+  // interface is not affected by this option; const methods remain safe to
+  // call from multiple threads concurrently, while non-const methods continue
+  // to require exclusive access.
+  //
+  //
+  // Note that implementations may choose not to check required fields within
+  // a lazy sub-message.  That is, calling IsInitialized() on the outer message
+  // may return true even if the inner message has missing required fields.
+  // This is necessary because otherwise the inner message would have to be
+  // parsed in order to perform the check, defeating the purpose of lazy
+  // parsing.  An implementation which chooses not to check required fields
+  // must be consistent about it.  That is, for any particular sub-message, the
+  // implementation must either *always* check its required fields, or *never*
+  // check its required fields, regardless of whether or not the message has
+  // been parsed.
+  //
+  // As of 2021, lazy does no correctness checks on the byte stream during
+  // parsing.  This may lead to crashes if and when an invalid byte stream is
+  // finally parsed upon access.
+  //
+  // TODO(b/211906113):  Enable validation on lazy fields.
+  optional bool lazy = 5 [default = false];
+
+  // unverified_lazy does no correctness checks on the byte stream. This should
+  // only be used where lazy with verification is prohibitive for performance
+  // reasons.
+  optional bool unverified_lazy = 15 [default = false];
+
+  // Is this field deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for accessors, or it will be completely ignored; in the very least, this
+  // is a formalization for deprecating fields.
+  optional bool deprecated = 3 [default = false];
+
+  // For Google-internal migration only. Do not use.
+  optional bool weak = 10 [default = false];
+
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+
+  reserved 4;  // removed jtype
+}
+
+message OneofOptions {
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message EnumOptions {
+
+  // Set this option to true to allow mapping different tag names to the same
+  // value.
+  optional bool allow_alias = 2;
+
+  // Is this enum deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the enum, or it will be completely ignored; in the very least, this
+  // is a formalization for deprecating enums.
+  optional bool deprecated = 3 [default = false];
+
+  reserved 5;  // javanano_as_lite
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message EnumValueOptions {
+  // Is this enum value deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the enum value, or it will be completely ignored; in the very least,
+  // this is a formalization for deprecating enum values.
+  optional bool deprecated = 1 [default = false];
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message ServiceOptions {
+
+  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
+  //   framework.  We apologize for hoarding these numbers to ourselves, but
+  //   we were already using them long before we decided to release Protocol
+  //   Buffers.
+
+  // Is this service deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the service, or it will be completely ignored; in the very least,
+  // this is a formalization for deprecating services.
+  optional bool deprecated = 33 [default = false];
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message MethodOptions {
+
+  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
+  //   framework.  We apologize for hoarding these numbers to ourselves, but
+  //   we were already using them long before we decided to release Protocol
+  //   Buffers.
+
+  // Is this method deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for the method, or it will be completely ignored; in the very least,
+  // this is a formalization for deprecating methods.
+  optional bool deprecated = 33 [default = false];
+
+  // Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+  // or neither? HTTP based RPC implementation may choose GET verb for safe
+  // methods, and PUT verb for idempotent methods instead of the default POST.
+  enum IdempotencyLevel {
+    IDEMPOTENCY_UNKNOWN = 0;
+    NO_SIDE_EFFECTS = 1;  // implies idempotent
+    IDEMPOTENT = 2;       // idempotent, but may have side effects
+  }
+  optional IdempotencyLevel idempotency_level = 34
+      [default = IDEMPOTENCY_UNKNOWN];
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+message UninterpretedOption {
+  // The name of the uninterpreted option.  Each string represents a segment in
+  // a dot-separated name.  is_extension is true iff a segment represents an
+  // extension (denoted with parentheses in options specs in .proto files).
+  // E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents
+  // "foo.(bar.baz).moo".
+  message NamePart {
+    required string name_part = 1;
+    required bool is_extension = 2;
+  }
+  repeated NamePart name = 2;
+
+  // The value of the uninterpreted option, in whatever type the tokenizer
+  // identified it as during parsing. Exactly one of these should be set.
+  optional string identifier_value = 3;
+  optional uint64 positive_int_value = 4;
+  optional int64 negative_int_value = 5;
+  optional double double_value = 6;
+  optional bytes string_value = 7;
+  optional string aggregate_value = 8;
+}
+
+// ===================================================================
+// Optional source code info
+
+// Encapsulates information about the original source file from which a
+// FileDescriptorProto was generated.
+message SourceCodeInfo {
+  // A Location identifies a piece of source code in a .proto file which
+  // corresponds to a particular definition.  This information is intended
+  // to be useful to IDEs, code indexers, documentation generators, and similar
+  // tools.
+  //
+  // For example, say we have a file like:
+  //   message Foo {
+  //     optional string foo = 1;
+  //   }
+  // Let's look at just the field definition:
+  //   optional string foo = 1;
+  //   ^       ^^     ^^  ^  ^^^
+  //   a       bc     de  f  ghi
+  // We have the following locations:
+  //   span   path               represents
+  //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
+  //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
+  //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
+  //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
+  //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
+  //
+  // Notes:
+  // - A location may refer to a repeated field itself (i.e. not to any
+  //   particular index within it).  This is used whenever a set of elements are
+  //   logically enclosed in a single code segment.  For example, an entire
+  //   extend block (possibly containing multiple extension definitions) will
+  //   have an outer location whose path refers to the "extensions" repeated
+  //   field without an index.
+  // - Multiple locations may have the same path.  This happens when a single
+  //   logical declaration is spread out across multiple places.  The most
+  //   obvious example is the "extend" block again -- there may be multiple
+  //   extend blocks in the same scope, each of which will have the same path.
+  // - A location's span is not always a subset of its parent's span.  For
+  //   example, the "extendee" of an extension declaration appears at the
+  //   beginning of the "extend" block and is shared by all extensions within
+  //   the block.
+  // - Just because a location's span is a subset of some other location's span
+  //   does not mean that it is a descendant.  For example, a "group" defines
+  //   both a type and a field in a single declaration.  Thus, the locations
+  //   corresponding to the type and field and their components will overlap.
+  // - Code which tries to interpret locations should probably be designed to
+  //   ignore those that it doesn't understand, as more types of locations could
+  //   be recorded in the future.
+  repeated Location location = 1;
+  message Location {
+    // Identifies which part of the FileDescriptorProto was defined at this
+    // location.
+    //
+    // Each element is a field number or an index.  They form a path from
+    // the root FileDescriptorProto to the place where the definition occurs.
+    // For example, this path:
+    //   [ 4, 3, 2, 7, 1 ]
+    // refers to:
+    //   file.message_type(3)  // 4, 3
+    //       .field(7)         // 2, 7
+    //       .name()           // 1
+    // This is because FileDescriptorProto.message_type has field number 4:
+    //   repeated DescriptorProto message_type = 4;
+    // and DescriptorProto.field has field number 2:
+    //   repeated FieldDescriptorProto field = 2;
+    // and FieldDescriptorProto.name has field number 1:
+    //   optional string name = 1;
+    //
+    // Thus, the above path gives the location of a field name.  If we removed
+    // the last element:
+    //   [ 4, 3, 2, 7 ]
+    // this path refers to the whole field declaration (from the beginning
+    // of the label to the terminating semicolon).
+    repeated int32 path = 1 [packed = true];
+
+    // Always has exactly three or four elements: start line, start column,
+    // end line (optional, otherwise assumed same as start line), end column.
+    // These are packed into a single field for efficiency.  Note that line
+    // and column numbers are zero-based -- typically you will want to add
+    // 1 to each before displaying to a user.
+    repeated int32 span = 2 [packed = true];
+
+    // If this SourceCodeInfo represents a complete declaration, these are any
+    // comments appearing before and after the declaration which appear to be
+    // attached to the declaration.
+    //
+    // A series of line comments appearing on consecutive lines, with no other
+    // tokens appearing on those lines, will be treated as a single comment.
+    //
+    // leading_detached_comments will keep paragraphs of comments that appear
+    // before (but not connected to) the current element. Each paragraph,
+    // separated by empty lines, will be one comment element in the repeated
+    // field.
+    //
+    // Only the comment content is provided; comment markers (e.g. //) are
+    // stripped out.  For block comments, leading whitespace and an asterisk
+    // will be stripped from the beginning of each line other than the first.
+    // Newlines are included in the output.
+    //
+    // Examples:
+    //
+    //   optional int32 foo = 1;  // Comment attached to foo.
+    //   // Comment attached to bar.
+    //   optional int32 bar = 2;
+    //
+    //   optional string baz = 3;
+    //   // Comment attached to baz.
+    //   // Another line attached to baz.
+    //
+    //   // Comment attached to moo.
+    //   //
+    //   // Another line attached to moo.
+    //   optional double moo = 4;
+    //
+    //   // Detached comment for corge. This is not leading or trailing comments
+    //   // to moo or corge because there are blank lines separating it from
+    //   // both.
+    //
+    //   // Detached comment for corge paragraph 2.
+    //
+    //   optional string corge = 5;
+    //   /* Block comment attached
+    //    * to corge.  Leading asterisks
+    //    * will be removed. */
+    //   /* Block comment attached to
+    //    * grault. */
+    //   optional int32 grault = 6;
+    //
+    //   // ignored detached comments.
+    optional string leading_comments = 3;
+    optional string trailing_comments = 4;
+    repeated string leading_detached_comments = 6;
+  }
+}
+
+// Describes the relationship between generated code and its original source
+// file. A GeneratedCodeInfo message is associated with only one generated
+// source file, but may contain references to different source .proto files.
+message GeneratedCodeInfo {
+  // An Annotation connects some span of text in generated code to an element
+  // of its generating .proto file.
+  repeated Annotation annotation = 1;
+  message Annotation {
+    // Identifies the element in the original source .proto file. This field
+    // is formatted the same as SourceCodeInfo.Location.path.
+    repeated int32 path = 1 [packed = true];
+
+    // Identifies the filesystem path to the original source .proto.
+    optional string source_file = 2;
+
+    // Identifies the starting offset in bytes in the generated code
+    // that relates to the identified object.
+    optional int32 begin = 3;
+
+    // Identifies the ending offset in bytes in the generated code that
+    // relates to the identified offset. The end offset should be one past
+    // the last relevant byte (so the length of the text = end - begin).
+    optional int32 end = 4;
+  }
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/descriptor_database.h b/CAPI/cpp/grpc/include/google/protobuf/descriptor_database.h
new file mode 100644
index 0000000..f4f06bb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/descriptor_database.h
@@ -0,0 +1,398 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Interface for manipulating databases of descriptors.
+
+#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__
+#define GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__
+
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+// Defined in this file.
+class DescriptorDatabase;
+class SimpleDescriptorDatabase;
+class EncodedDescriptorDatabase;
+class DescriptorPoolDatabase;
+class MergedDescriptorDatabase;
+
+// Abstract interface for a database of descriptors.
+//
+// This is useful if you want to create a DescriptorPool which loads
+// descriptors on-demand from some sort of large database.  If the database
+// is large, it may be inefficient to enumerate every .proto file inside it
+// calling DescriptorPool::BuildFile() for each one.  Instead, a DescriptorPool
+// can be created which wraps a DescriptorDatabase and only builds particular
+// descriptors when they are needed.
+class PROTOBUF_EXPORT DescriptorDatabase {
+ public:
+  inline DescriptorDatabase() {}
+  virtual ~DescriptorDatabase();
+
+  // Find a file by file name.  Fills in in *output and returns true if found.
+  // Otherwise, returns false, leaving the contents of *output undefined.
+  virtual bool FindFileByName(const std::string& filename,
+                              FileDescriptorProto* output) = 0;
+
+  // Find the file that declares the given fully-qualified symbol name.
+  // If found, fills in *output and returns true, otherwise returns false
+  // and leaves *output undefined.
+  virtual bool FindFileContainingSymbol(const std::string& symbol_name,
+                                        FileDescriptorProto* output) = 0;
+
+  // Find the file which defines an extension extending the given message type
+  // with the given field number.  If found, fills in *output and returns true,
+  // otherwise returns false and leaves *output undefined.  containing_type
+  // must be a fully-qualified type name.
+  virtual bool FindFileContainingExtension(const std::string& containing_type,
+                                           int field_number,
+                                           FileDescriptorProto* output) = 0;
+
+  // Finds the tag numbers used by all known extensions of
+  // extendee_type, and appends them to output in an undefined
+  // order. This method is best-effort: it's not guaranteed that the
+  // database will find all extensions, and it's not guaranteed that
+  // FindFileContainingExtension will return true on all of the found
+  // numbers. Returns true if the search was successful, otherwise
+  // returns false and leaves output unchanged.
+  //
+  // This method has a default implementation that always returns
+  // false.
+  virtual bool FindAllExtensionNumbers(const std::string& /* extendee_type */,
+                                       std::vector<int>* /* output */) {
+    return false;
+  }
+
+
+  // Finds the file names and appends them to the output in an
+  // undefined order. This method is best-effort: it's not guaranteed that the
+  // database will find all files. Returns true if the database supports
+  // searching all file names, otherwise returns false and leaves output
+  // unchanged.
+  //
+  // This method has a default implementation that always returns
+  // false.
+  virtual bool FindAllFileNames(std::vector<std::string>* /*output*/) {
+    return false;
+  }
+
+  // Finds the package names and appends them to the output in an
+  // undefined order. This method is best-effort: it's not guaranteed that the
+  // database will find all packages. Returns true if the database supports
+  // searching all package names, otherwise returns false and leaves output
+  // unchanged.
+  bool FindAllPackageNames(std::vector<std::string>* output);
+
+  // Finds the message names and appends them to the output in an
+  // undefined order. This method is best-effort: it's not guaranteed that the
+  // database will find all messages. Returns true if the database supports
+  // searching all message names, otherwise returns false and leaves output
+  // unchanged.
+  bool FindAllMessageNames(std::vector<std::string>* output);
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorDatabase);
+};
+
+// A DescriptorDatabase into which you can insert files manually.
+//
+// FindFileContainingSymbol() is fully-implemented.  When you add a file, its
+// symbols will be indexed for this purpose.  Note that the implementation
+// may return false positives, but only if it isn't possible for the symbol
+// to be defined in any other file.  In particular, if a file defines a symbol
+// "Foo", then searching for "Foo.[anything]" will match that file.  This way,
+// the database does not need to aggressively index all children of a symbol.
+//
+// FindFileContainingExtension() is mostly-implemented.  It works if and only
+// if the original FieldDescriptorProto defining the extension has a
+// fully-qualified type name in its "extendee" field (i.e. starts with a '.').
+// If the extendee is a relative name, SimpleDescriptorDatabase will not
+// attempt to resolve the type, so it will not know what type the extension is
+// extending.  Therefore, calling FindFileContainingExtension() with the
+// extension's containing type will never actually find that extension.  Note
+// that this is an unlikely problem, as all FileDescriptorProtos created by the
+// protocol compiler (as well as ones created by calling
+// FileDescriptor::CopyTo()) will always use fully-qualified names for all
+// types.  You only need to worry if you are constructing FileDescriptorProtos
+// yourself, or are calling compiler::Parser directly.
+class PROTOBUF_EXPORT SimpleDescriptorDatabase : public DescriptorDatabase {
+ public:
+  SimpleDescriptorDatabase();
+  ~SimpleDescriptorDatabase() override;
+
+  // Adds the FileDescriptorProto to the database, making a copy.  The object
+  // can be deleted after Add() returns.  Returns false if the file conflicted
+  // with a file already in the database, in which case an error will have
+  // been written to GOOGLE_LOG(ERROR).
+  bool Add(const FileDescriptorProto& file);
+
+  // Adds the FileDescriptorProto to the database and takes ownership of it.
+  bool AddAndOwn(const FileDescriptorProto* file);
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const std::string& filename,
+                      FileDescriptorProto* output) override;
+  bool FindFileContainingSymbol(const std::string& symbol_name,
+                                FileDescriptorProto* output) override;
+  bool FindFileContainingExtension(const std::string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output) override;
+  bool FindAllExtensionNumbers(const std::string& extendee_type,
+                               std::vector<int>* output) override;
+
+  bool FindAllFileNames(std::vector<std::string>* output) override;
+
+ private:
+  // An index mapping file names, symbol names, and extension numbers to
+  // some sort of values.
+  template <typename Value>
+  class DescriptorIndex {
+   public:
+    // Helpers to recursively add particular descriptors and all their contents
+    // to the index.
+    bool AddFile(const FileDescriptorProto& file, Value value);
+    bool AddSymbol(const std::string& name, Value value);
+    bool AddNestedExtensions(const std::string& filename,
+                             const DescriptorProto& message_type, Value value);
+    bool AddExtension(const std::string& filename,
+                      const FieldDescriptorProto& field, Value value);
+
+    Value FindFile(const std::string& filename);
+    Value FindSymbol(const std::string& name);
+    Value FindExtension(const std::string& containing_type, int field_number);
+    bool FindAllExtensionNumbers(const std::string& containing_type,
+                                 std::vector<int>* output);
+    void FindAllFileNames(std::vector<std::string>* output);
+
+   private:
+    std::map<std::string, Value> by_name_;
+    std::map<std::string, Value> by_symbol_;
+    std::map<std::pair<std::string, int>, Value> by_extension_;
+
+    // Invariant:  The by_symbol_ map does not contain any symbols which are
+    // prefixes of other symbols in the map.  For example, "foo.bar" is a
+    // prefix of "foo.bar.baz" (but is not a prefix of "foo.barbaz").
+    //
+    // This invariant is important because it means that given a symbol name,
+    // we can find a key in the map which is a prefix of the symbol in O(lg n)
+    // time, and we know that there is at most one such key.
+    //
+    // The prefix lookup algorithm works like so:
+    // 1) Find the last key in the map which is less than or equal to the
+    //    search key.
+    // 2) If the found key is a prefix of the search key, then return it.
+    //    Otherwise, there is no match.
+    //
+    // I am sure this algorithm has been described elsewhere, but since I
+    // wasn't able to find it quickly I will instead prove that it works
+    // myself.  The key to the algorithm is that if a match exists, step (1)
+    // will find it.  Proof:
+    // 1) Define the "search key" to be the key we are looking for, the "found
+    //    key" to be the key found in step (1), and the "match key" to be the
+    //    key which actually matches the search key (i.e. the key we're trying
+    //    to find).
+    // 2) The found key must be less than or equal to the search key by
+    //    definition.
+    // 3) The match key must also be less than or equal to the search key
+    //    (because it is a prefix).
+    // 4) The match key cannot be greater than the found key, because if it
+    //    were, then step (1) of the algorithm would have returned the match
+    //    key instead (since it finds the *greatest* key which is less than or
+    //    equal to the search key).
+    // 5) Therefore, the found key must be between the match key and the search
+    //    key, inclusive.
+    // 6) Since the search key must be a sub-symbol of the match key, if it is
+    //    not equal to the match key, then search_key[match_key.size()] must
+    //    be '.'.
+    // 7) Since '.' sorts before any other character that is valid in a symbol
+    //    name, then if the found key is not equal to the match key, then
+    //    found_key[match_key.size()] must also be '.', because any other value
+    //    would make it sort after the search key.
+    // 8) Therefore, if the found key is not equal to the match key, then the
+    //    found key must be a sub-symbol of the match key.  However, this would
+    //    contradict our map invariant which says that no symbol in the map is
+    //    a sub-symbol of any other.
+    // 9) Therefore, the found key must match the match key.
+    //
+    // The above proof assumes the match key exists.  In the case that the
+    // match key does not exist, then step (1) will return some other symbol.
+    // That symbol cannot be a super-symbol of the search key since if it were,
+    // then it would be a match, and we're assuming the match key doesn't exist.
+    // Therefore, step 2 will correctly return no match.
+  };
+
+  DescriptorIndex<const FileDescriptorProto*> index_;
+  std::vector<std::unique_ptr<const FileDescriptorProto>> files_to_delete_;
+
+  // If file is non-nullptr, copy it into *output and return true, otherwise
+  // return false.
+  bool MaybeCopy(const FileDescriptorProto* file, FileDescriptorProto* output);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleDescriptorDatabase);
+};
+
+// Very similar to SimpleDescriptorDatabase, but stores all the descriptors
+// as raw bytes and generally tries to use as little memory as possible.
+//
+// The same caveats regarding FindFileContainingExtension() apply as with
+// SimpleDescriptorDatabase.
+class PROTOBUF_EXPORT EncodedDescriptorDatabase : public DescriptorDatabase {
+ public:
+  EncodedDescriptorDatabase();
+  ~EncodedDescriptorDatabase() override;
+
+  // Adds the FileDescriptorProto to the database.  The descriptor is provided
+  // in encoded form.  The database does not make a copy of the bytes, nor
+  // does it take ownership; it's up to the caller to make sure the bytes
+  // remain valid for the life of the database.  Returns false and logs an error
+  // if the bytes are not a valid FileDescriptorProto or if the file conflicted
+  // with a file already in the database.
+  bool Add(const void* encoded_file_descriptor, int size);
+
+  // Like Add(), but makes a copy of the data, so that the caller does not
+  // need to keep it around.
+  bool AddCopy(const void* encoded_file_descriptor, int size);
+
+  // Like FindFileContainingSymbol but returns only the name of the file.
+  bool FindNameOfFileContainingSymbol(const std::string& symbol_name,
+                                      std::string* output);
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const std::string& filename,
+                      FileDescriptorProto* output) override;
+  bool FindFileContainingSymbol(const std::string& symbol_name,
+                                FileDescriptorProto* output) override;
+  bool FindFileContainingExtension(const std::string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output) override;
+  bool FindAllExtensionNumbers(const std::string& extendee_type,
+                               std::vector<int>* output) override;
+  bool FindAllFileNames(std::vector<std::string>* output) override;
+
+ private:
+  class DescriptorIndex;
+  // Keep DescriptorIndex by pointer to hide the implementation to keep a
+  // cleaner header.
+  std::unique_ptr<DescriptorIndex> index_;
+  std::vector<void*> files_to_delete_;
+
+  // If encoded_file.first is non-nullptr, parse the data into *output and
+  // return true, otherwise return false.
+  bool MaybeParse(std::pair<const void*, int> encoded_file,
+                  FileDescriptorProto* output);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EncodedDescriptorDatabase);
+};
+
+// A DescriptorDatabase that fetches files from a given pool.
+class PROTOBUF_EXPORT DescriptorPoolDatabase : public DescriptorDatabase {
+ public:
+  explicit DescriptorPoolDatabase(const DescriptorPool& pool);
+  ~DescriptorPoolDatabase() override;
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const std::string& filename,
+                      FileDescriptorProto* output) override;
+  bool FindFileContainingSymbol(const std::string& symbol_name,
+                                FileDescriptorProto* output) override;
+  bool FindFileContainingExtension(const std::string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output) override;
+  bool FindAllExtensionNumbers(const std::string& extendee_type,
+                               std::vector<int>* output) override;
+
+ private:
+  const DescriptorPool& pool_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPoolDatabase);
+};
+
+// A DescriptorDatabase that wraps two or more others.  It first searches the
+// first database and, if that fails, tries the second, and so on.
+class PROTOBUF_EXPORT MergedDescriptorDatabase : public DescriptorDatabase {
+ public:
+  // Merge just two databases.  The sources remain property of the caller.
+  MergedDescriptorDatabase(DescriptorDatabase* source1,
+                           DescriptorDatabase* source2);
+  // Merge more than two databases.  The sources remain property of the caller.
+  // The vector may be deleted after the constructor returns but the
+  // DescriptorDatabases need to stick around.
+  explicit MergedDescriptorDatabase(
+      const std::vector<DescriptorDatabase*>& sources);
+  ~MergedDescriptorDatabase() override;
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const std::string& filename,
+                      FileDescriptorProto* output) override;
+  bool FindFileContainingSymbol(const std::string& symbol_name,
+                                FileDescriptorProto* output) override;
+  bool FindFileContainingExtension(const std::string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output) override;
+  // Merges the results of calling all databases. Returns true iff any
+  // of the databases returned true.
+  bool FindAllExtensionNumbers(const std::string& extendee_type,
+                               std::vector<int>* output) override;
+
+
+  // This function is best-effort. Returns true if at least one underlying
+  // DescriptorDatabase returns true.
+  bool FindAllFileNames(std::vector<std::string>* output) override;
+
+ private:
+  std::vector<DescriptorDatabase*> sources_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MergedDescriptorDatabase);
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/duration.pb.h b/CAPI/cpp/grpc/include/google/protobuf/duration.pb.h
new file mode 100644
index 0000000..c4a94c5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/duration.pb.h
@@ -0,0 +1,278 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/duration.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fduration_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fduration_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fduration_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fduration_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fduration_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class Duration;
+struct DurationDefaultTypeInternal;
+PROTOBUF_EXPORT extern DurationDefaultTypeInternal _Duration_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Duration* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+// ===================================================================
+
+class PROTOBUF_EXPORT Duration final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Duration) */ {
+ public:
+  inline Duration() : Duration(nullptr) {}
+  ~Duration() override;
+  explicit PROTOBUF_CONSTEXPR Duration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Duration(const Duration& from);
+  Duration(Duration&& from) noexcept
+    : Duration() {
+    *this = ::std::move(from);
+  }
+
+  inline Duration& operator=(const Duration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Duration& operator=(Duration&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Duration& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Duration* internal_default_instance() {
+    return reinterpret_cast<const Duration*>(
+               &_Duration_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Duration& a, Duration& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Duration* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Duration* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Duration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Duration>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Duration& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Duration& from) {
+    Duration::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Duration* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Duration";
+  }
+  protected:
+  explicit Duration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSecondsFieldNumber = 1,
+    kNanosFieldNumber = 2,
+  };
+  // int64 seconds = 1;
+  void clear_seconds();
+  int64_t seconds() const;
+  void set_seconds(int64_t value);
+  private:
+  int64_t _internal_seconds() const;
+  void _internal_set_seconds(int64_t value);
+  public:
+
+  // int32 nanos = 2;
+  void clear_nanos();
+  int32_t nanos() const;
+  void set_nanos(int32_t value);
+  private:
+  int32_t _internal_nanos() const;
+  void _internal_set_nanos(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Duration)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t seconds_;
+    int32_t nanos_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fduration_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Duration
+
+// int64 seconds = 1;
+inline void Duration::clear_seconds() {
+  _impl_.seconds_ = int64_t{0};
+}
+inline int64_t Duration::_internal_seconds() const {
+  return _impl_.seconds_;
+}
+inline int64_t Duration::seconds() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Duration.seconds)
+  return _internal_seconds();
+}
+inline void Duration::_internal_set_seconds(int64_t value) {
+  
+  _impl_.seconds_ = value;
+}
+inline void Duration::set_seconds(int64_t value) {
+  _internal_set_seconds(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Duration.seconds)
+}
+
+// int32 nanos = 2;
+inline void Duration::clear_nanos() {
+  _impl_.nanos_ = 0;
+}
+inline int32_t Duration::_internal_nanos() const {
+  return _impl_.nanos_;
+}
+inline int32_t Duration::nanos() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Duration.nanos)
+  return _internal_nanos();
+}
+inline void Duration::_internal_set_nanos(int32_t value) {
+  
+  _impl_.nanos_ = value;
+}
+inline void Duration::set_nanos(int32_t value) {
+  _internal_set_nanos(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Duration.nanos)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fduration_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/duration.proto b/CAPI/cpp/grpc/include/google/protobuf/duration.proto
new file mode 100644
index 0000000..81c3e36
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/duration.proto
@@ -0,0 +1,116 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/protobuf/types/known/durationpb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DurationProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// A Duration represents a signed, fixed-length span of time represented
+// as a count of seconds and fractions of seconds at nanosecond
+// resolution. It is independent of any calendar and concepts like "day"
+// or "month". It is related to Timestamp in that the difference between
+// two Timestamp values is a Duration and it can be added or subtracted
+// from a Timestamp. Range is approximately +-10,000 years.
+//
+// # Examples
+//
+// Example 1: Compute Duration from two Timestamps in pseudo code.
+//
+//     Timestamp start = ...;
+//     Timestamp end = ...;
+//     Duration duration = ...;
+//
+//     duration.seconds = end.seconds - start.seconds;
+//     duration.nanos = end.nanos - start.nanos;
+//
+//     if (duration.seconds < 0 && duration.nanos > 0) {
+//       duration.seconds += 1;
+//       duration.nanos -= 1000000000;
+//     } else if (duration.seconds > 0 && duration.nanos < 0) {
+//       duration.seconds -= 1;
+//       duration.nanos += 1000000000;
+//     }
+//
+// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+//
+//     Timestamp start = ...;
+//     Duration duration = ...;
+//     Timestamp end = ...;
+//
+//     end.seconds = start.seconds + duration.seconds;
+//     end.nanos = start.nanos + duration.nanos;
+//
+//     if (end.nanos < 0) {
+//       end.seconds -= 1;
+//       end.nanos += 1000000000;
+//     } else if (end.nanos >= 1000000000) {
+//       end.seconds += 1;
+//       end.nanos -= 1000000000;
+//     }
+//
+// Example 3: Compute Duration from datetime.timedelta in Python.
+//
+//     td = datetime.timedelta(days=3, minutes=10)
+//     duration = Duration()
+//     duration.FromTimedelta(td)
+//
+// # JSON Mapping
+//
+// In JSON format, the Duration type is encoded as a string rather than an
+// object, where the string ends in the suffix "s" (indicating seconds) and
+// is preceded by the number of seconds, with nanoseconds expressed as
+// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+// microsecond should be expressed in JSON format as "3.000001s".
+//
+//
+message Duration {
+  // Signed seconds of the span of time. Must be from -315,576,000,000
+  // to +315,576,000,000 inclusive. Note: these bounds are computed from:
+  // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+  int64 seconds = 1;
+
+  // Signed fractions of a second at nanosecond resolution of the span
+  // of time. Durations less than one second are represented with a 0
+  // `seconds` field and a positive or negative `nanos` field. For durations
+  // of one second or more, a non-zero value for the `nanos` field must be
+  // of the same sign as the `seconds` field. Must be from -999,999,999
+  // to +999,999,999 inclusive.
+  int32 nanos = 2;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/dynamic_message.h b/CAPI/cpp/grpc/include/google/protobuf/dynamic_message.h
new file mode 100644
index 0000000..6fa6425
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/dynamic_message.h
@@ -0,0 +1,227 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines an implementation of Message which can emulate types which are not
+// known at compile-time.
+
+#ifndef GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
+#define GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
+
+
+#include <algorithm>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/reflection.h>
+#include <google/protobuf/repeated_field.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+// Defined in other files.
+class Descriptor;      // descriptor.h
+class DescriptorPool;  // descriptor.h
+
+// Constructs implementations of Message which can emulate types which are not
+// known at compile-time.
+//
+// Sometimes you want to be able to manipulate protocol types that you don't
+// know about at compile time.  It would be nice to be able to construct
+// a Message object which implements the message type given by any arbitrary
+// Descriptor.  DynamicMessage provides this.
+//
+// As it turns out, a DynamicMessage needs to construct extra
+// information about its type in order to operate.  Most of this information
+// can be shared between all DynamicMessages of the same type.  But, caching
+// this information in some sort of global map would be a bad idea, since
+// the cached information for a particular descriptor could outlive the
+// descriptor itself.  To avoid this problem, DynamicMessageFactory
+// encapsulates this "cache".  All DynamicMessages of the same type created
+// from the same factory will share the same support data.  Any Descriptors
+// used with a particular factory must outlive the factory.
+class PROTOBUF_EXPORT DynamicMessageFactory : public MessageFactory {
+ public:
+  // Construct a DynamicMessageFactory that will search for extensions in
+  // the DescriptorPool in which the extendee is defined.
+  DynamicMessageFactory();
+
+  // Construct a DynamicMessageFactory that will search for extensions in
+  // the given DescriptorPool.
+  //
+  // DEPRECATED:  Use CodedInputStream::SetExtensionRegistry() to tell the
+  //   parser to look for extensions in an alternate pool.  However, note that
+  //   this is almost never what you want to do.  Almost all users should use
+  //   the zero-arg constructor.
+  DynamicMessageFactory(const DescriptorPool* pool);
+
+  ~DynamicMessageFactory() override;
+
+  // Call this to tell the DynamicMessageFactory that if it is given a
+  // Descriptor d for which:
+  //   d->file()->pool() == DescriptorPool::generated_pool(),
+  // then it should delegate to MessageFactory::generated_factory() instead
+  // of constructing a dynamic implementation of the message.  In theory there
+  // is no down side to doing this, so it may become the default in the future.
+  void SetDelegateToGeneratedFactory(bool enable) {
+    delegate_to_generated_factory_ = enable;
+  }
+
+  // implements MessageFactory ---------------------------------------
+
+  // Given a Descriptor, constructs the default (prototype) Message of that
+  // type.  You can then call that message's New() method to construct a
+  // mutable message of that type.
+  //
+  // Calling this method twice with the same Descriptor returns the same
+  // object.  The returned object remains property of the factory and will
+  // be destroyed when the factory is destroyed.  Also, any objects created
+  // by calling the prototype's New() method share some data with the
+  // prototype, so these must be destroyed before the DynamicMessageFactory
+  // is destroyed.
+  //
+  // The given descriptor must outlive the returned message, and hence must
+  // outlive the DynamicMessageFactory.
+  //
+  // The method is thread-safe.
+  const Message* GetPrototype(const Descriptor* type) override;
+
+ private:
+  const DescriptorPool* pool_;
+  bool delegate_to_generated_factory_;
+
+  struct TypeInfo;
+  std::unordered_map<const Descriptor*, const TypeInfo*> prototypes_;
+  mutable internal::WrappedMutex prototypes_mutex_;
+
+  friend class DynamicMessage;
+  const Message* GetPrototypeNoLock(const Descriptor* type);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMessageFactory);
+};
+
+// Helper for computing a sorted list of map entries via reflection.
+class PROTOBUF_EXPORT DynamicMapSorter {
+ public:
+  static std::vector<const Message*> Sort(const Message& message, int map_size,
+                                          const Reflection* reflection,
+                                          const FieldDescriptor* field) {
+    std::vector<const Message*> result;
+    result.reserve(map_size);
+    RepeatedFieldRef<Message> map_field =
+        reflection->GetRepeatedFieldRef<Message>(message, field);
+    for (auto it = map_field.begin(); it != map_field.end(); ++it) {
+      result.push_back(&*it);
+    }
+    MapEntryMessageComparator comparator(field->message_type());
+    std::stable_sort(result.begin(), result.end(), comparator);
+    // Complain if the keys aren't in ascending order.
+#ifndef NDEBUG
+    for (size_t j = 1; j < static_cast<size_t>(map_size); j++) {
+      if (!comparator(result[j - 1], result[j])) {
+        GOOGLE_LOG(ERROR) << (comparator(result[j], result[j - 1])
+                           ? "internal error in map key sorting"
+                           : "map keys are not unique");
+      }
+    }
+#endif
+    return result;
+  }
+
+ private:
+  class PROTOBUF_EXPORT MapEntryMessageComparator {
+   public:
+    explicit MapEntryMessageComparator(const Descriptor* descriptor)
+        : field_(descriptor->field(0)) {}
+
+    bool operator()(const Message* a, const Message* b) {
+      const Reflection* reflection = a->GetReflection();
+      switch (field_->cpp_type()) {
+        case FieldDescriptor::CPPTYPE_BOOL: {
+          bool first = reflection->GetBool(*a, field_);
+          bool second = reflection->GetBool(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_INT32: {
+          int32_t first = reflection->GetInt32(*a, field_);
+          int32_t second = reflection->GetInt32(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_INT64: {
+          int64_t first = reflection->GetInt64(*a, field_);
+          int64_t second = reflection->GetInt64(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_UINT32: {
+          uint32_t first = reflection->GetUInt32(*a, field_);
+          uint32_t second = reflection->GetUInt32(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_UINT64: {
+          uint64_t first = reflection->GetUInt64(*a, field_);
+          uint64_t second = reflection->GetUInt64(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_STRING: {
+          std::string first = reflection->GetString(*a, field_);
+          std::string second = reflection->GetString(*b, field_);
+          return first < second;
+        }
+        default:
+          GOOGLE_LOG(DFATAL) << "Invalid key for map field.";
+          return true;
+      }
+    }
+
+   private:
+    const FieldDescriptor* field_;
+  };
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/empty.pb.h b/CAPI/cpp/grpc/include/google/protobuf/empty.pb.h
new file mode 100644
index 0000000..00a4481
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/empty.pb.h
@@ -0,0 +1,198 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/empty.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fempty_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fempty_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_bases.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fempty_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fempty_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fempty_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class Empty;
+struct EmptyDefaultTypeInternal;
+PROTOBUF_EXPORT extern EmptyDefaultTypeInternal _Empty_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Empty* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Empty>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+// ===================================================================
+
+class PROTOBUF_EXPORT Empty final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:google.protobuf.Empty) */ {
+ public:
+  inline Empty() : Empty(nullptr) {}
+  explicit PROTOBUF_CONSTEXPR Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Empty(const Empty& from);
+  Empty(Empty&& from) noexcept
+    : Empty() {
+    *this = ::std::move(from);
+  }
+
+  inline Empty& operator=(const Empty& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Empty& operator=(Empty&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Empty& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Empty* internal_default_instance() {
+    return reinterpret_cast<const Empty*>(
+               &_Empty_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Empty& a, Empty& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Empty* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Empty* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Empty>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const Empty& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const Empty& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Empty";
+  }
+  protected:
+  explicit Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Empty)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+  };
+  friend struct ::TableStruct_google_2fprotobuf_2fempty_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Empty
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fempty_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/empty.proto b/CAPI/cpp/grpc/include/google/protobuf/empty.proto
new file mode 100644
index 0000000..2227462
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/empty.proto
@@ -0,0 +1,51 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "google.golang.org/protobuf/types/known/emptypb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "EmptyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+option cc_enable_arenas = true;
+
+// A generic empty message that you can re-use to avoid defining duplicated
+// empty messages in your APIs. A typical example is to use it as the request
+// or the response type of an API method. For instance:
+//
+//     service Foo {
+//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+//     }
+//
+message Empty {}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/endian.h b/CAPI/cpp/grpc/include/google/protobuf/endian.h
new file mode 100644
index 0000000..e0ee6cd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/endian.h
@@ -0,0 +1,198 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_ENDIAN_H__
+#define GOOGLE_PROTOBUF_ENDIAN_H__
+
+#if defined(_MSC_VER)
+#include <stdlib.h>
+#endif
+
+#include <cstdint>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline uint64_t BSwap64(uint64_t host_int) {
+#if defined(PROTOBUF_BUILTIN_BSWAP64)
+  return PROTOBUF_BUILTIN_BSWAP64(host_int);
+#elif defined(_MSC_VER)
+  return _byteswap_uint64(host_int);
+#else
+  return (((host_int & uint64_t{0xFF}) << 56) |
+          ((host_int & uint64_t{0xFF00}) << 40) |
+          ((host_int & uint64_t{0xFF0000}) << 24) |
+          ((host_int & uint64_t{0xFF000000}) << 8) |
+          ((host_int & uint64_t{0xFF00000000}) >> 8) |
+          ((host_int & uint64_t{0xFF0000000000}) >> 24) |
+          ((host_int & uint64_t{0xFF000000000000}) >> 40) |
+          ((host_int & uint64_t{0xFF00000000000000}) >> 56));
+#endif
+}
+
+inline uint32_t BSwap32(uint32_t host_int) {
+#if defined(PROTOBUF_BUILTIN_BSWAP32)
+  return PROTOBUF_BUILTIN_BSWAP32(host_int);
+#elif defined(_MSC_VER)
+  return _byteswap_ulong(host_int);
+#else
+  return (((host_int & uint32_t{0xFF}) << 24) |
+          ((host_int & uint32_t{0xFF00}) << 8) |
+          ((host_int & uint32_t{0xFF0000}) >> 8) |
+          ((host_int & uint32_t{0xFF000000}) >> 24));
+#endif
+}
+
+inline uint16_t BSwap16(uint16_t host_int) {
+#if defined(PROTOBUF_BUILTIN_BSWAP16)
+  return PROTOBUF_BUILTIN_BSWAP16(host_int);
+#elif defined(_MSC_VER)
+  return _byteswap_ushort(host_int);
+#else
+  return (((host_int & uint16_t{0xFF}) << 8) |
+          ((host_int & uint16_t{0xFF00}) >> 8));
+#endif
+}
+
+namespace little_endian {
+
+inline uint16_t FromHost(uint16_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return BSwap16(value);
+#else
+  return value;
+#endif
+}
+
+inline uint32_t FromHost(uint32_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return BSwap32(value);
+#else
+  return value;
+#endif
+}
+
+inline uint64_t FromHost(uint64_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return BSwap64(value);
+#else
+  return value;
+#endif
+}
+
+inline uint16_t ToHost(uint16_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return BSwap16(value);
+#else
+  return value;
+#endif
+}
+
+inline uint32_t ToHost(uint32_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return BSwap32(value);
+#else
+  return value;
+#endif
+}
+
+inline uint64_t ToHost(uint64_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return BSwap64(value);
+#else
+  return value;
+#endif
+}
+
+}  // namespace little_endian
+
+namespace big_endian {
+
+inline uint16_t FromHost(uint16_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return value;
+#else
+  return BSwap16(value);
+#endif
+}
+
+inline uint32_t FromHost(uint32_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return value;
+#else
+  return BSwap32(value);
+#endif
+}
+
+inline uint64_t FromHost(uint64_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return value;
+#else
+  return BSwap64(value);
+#endif
+}
+
+inline uint16_t ToHost(uint16_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return value;
+#else
+  return BSwap16(value);
+#endif
+}
+
+inline uint32_t ToHost(uint32_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return value;
+#else
+  return BSwap32(value);
+#endif
+}
+
+inline uint64_t ToHost(uint64_t value) {
+#if defined(PROTOBUF_BIG_ENDIAN)
+  return value;
+#else
+  return BSwap64(value);
+#endif
+}
+
+}  // namespace big_endian
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_ENDIAN_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/explicitly_constructed.h b/CAPI/cpp/grpc/include/google/protobuf/explicitly_constructed.h
new file mode 100644
index 0000000..174c59a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/explicitly_constructed.h
@@ -0,0 +1,97 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_EXPLICITLY_CONSTRUCTED_H__
+#define GOOGLE_PROTOBUF_EXPLICITLY_CONSTRUCTED_H__
+
+#include <stdint.h>
+
+#include <utility>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+
+// clang-format off
+#include <google/protobuf/port_def.inc>
+// clang-format on
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Wraps a variable whose constructor and destructor are explicitly
+// called. It is particularly useful for a global variable, without its
+// constructor and destructor run on start and end of the program lifetime.
+// This circumvents the initial construction order fiasco, while keeping
+// the address of the empty string a compile time constant.
+//
+// Pay special attention to the initialization state of the object.
+// 1. The object is "uninitialized" to begin with.
+// 2. Call Construct() or DefaultConstruct() only if the object is
+//    uninitialized. After the call, the object becomes "initialized".
+// 3. Call get() and get_mutable() only if the object is initialized.
+// 4. Call Destruct() only if the object is initialized.
+//    After the call, the object becomes uninitialized.
+template <typename T, size_t min_align = 1>
+class ExplicitlyConstructed {
+ public:
+  void DefaultConstruct() { new (&union_) T(); }
+
+  template <typename... Args>
+  void Construct(Args&&... args) {
+    new (&union_) T(std::forward<Args>(args)...);
+  }
+
+  void Destruct() { get_mutable()->~T(); }
+
+  constexpr const T& get() const { return reinterpret_cast<const T&>(union_); }
+  T* get_mutable() { return reinterpret_cast<T*>(&union_); }
+
+ private:
+  union AlignedUnion {
+    alignas(min_align > alignof(T) ? min_align
+                                   : alignof(T)) char space[sizeof(T)];
+    int64_t align_to_int64;
+    void* align_to_ptr;
+  } union_;
+};
+
+// ArenaStringPtr compatible explicitly constructed string type.
+// This empty string type is aligned with a minimum alignment of 8 bytes
+// which is the minimum requirement of ArenaStringPtr
+using ExplicitlyConstructedArenaString = ExplicitlyConstructed<std::string, 8>;
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_EXPLICITLY_CONSTRUCTED_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/extension_set.h b/CAPI/cpp/grpc/include/google/protobuf/extension_set.h
new file mode 100644
index 0000000..0e6d052
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/extension_set.h
@@ -0,0 +1,1561 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_EXTENSION_SET_H__
+#define GOOGLE_PROTOBUF_EXTENSION_SET_H__
+
+
+#include <algorithm>
+#include <cassert>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/parse_context.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/wire_format_lite.h>
+
+// clang-format off
+#include <google/protobuf/port_def.inc>  // Must be last
+// clang-format on
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+class Arena;
+class Descriptor;       // descriptor.h
+class FieldDescriptor;  // descriptor.h
+class DescriptorPool;   // descriptor.h
+class MessageLite;      // message_lite.h
+class Message;          // message.h
+class MessageFactory;   // message.h
+class Reflection;       // message.h
+class UnknownFieldSet;  // unknown_field_set.h
+namespace internal {
+class FieldSkipper;  // wire_format_lite.h
+enum class LazyVerifyOption;
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+class InternalMetadata;
+
+// Used to store values of type WireFormatLite::FieldType without having to
+// #include wire_format_lite.h.  Also, ensures that we use only one byte to
+// store these values, which is important to keep the layout of
+// ExtensionSet::Extension small.
+typedef uint8_t FieldType;
+
+// A function which, given an integer value, returns true if the number
+// matches one of the defined values for the corresponding enum type.  This
+// is used with RegisterEnumExtension, below.
+typedef bool EnumValidityFunc(int number);
+
+// Version of the above which takes an argument.  This is needed to deal with
+// extensions that are not compiled in.
+typedef bool EnumValidityFuncWithArg(const void* arg, int number);
+
+// Information about a registered extension.
+struct ExtensionInfo {
+  constexpr ExtensionInfo() : enum_validity_check() {}
+  constexpr ExtensionInfo(const MessageLite* extendee, int param_number,
+                          FieldType type_param, bool isrepeated, bool ispacked,
+                          LazyEagerVerifyFnType verify_func)
+      : message(extendee),
+        number(param_number),
+        type(type_param),
+        is_repeated(isrepeated),
+        is_packed(ispacked),
+        enum_validity_check(),
+        lazy_eager_verify_func(verify_func) {}
+
+  const MessageLite* message = nullptr;
+  int number = 0;
+
+  FieldType type = 0;
+  bool is_repeated = false;
+  bool is_packed = false;
+
+  struct EnumValidityCheck {
+    EnumValidityFuncWithArg* func;
+    const void* arg;
+  };
+
+  struct MessageInfo {
+    const MessageLite* prototype;
+  };
+
+  union {
+    EnumValidityCheck enum_validity_check;
+    MessageInfo message_info;
+  };
+
+  // The descriptor for this extension, if one exists and is known.  May be
+  // nullptr.  Must not be nullptr if the descriptor for the extension does not
+  // live in the same pool as the descriptor for the containing type.
+  const FieldDescriptor* descriptor = nullptr;
+
+  // If this field is potentially lazy this function can be used as a cheap
+  // verification of the raw bytes.
+  // If nullptr then no verification is performed.
+  LazyEagerVerifyFnType lazy_eager_verify_func = nullptr;
+};
+
+// An ExtensionFinder is an object which looks up extension definitions.  It
+// must implement this method:
+//
+// bool Find(int number, ExtensionInfo* output);
+
+// GeneratedExtensionFinder is an ExtensionFinder which finds extensions
+// defined in .proto files which have been compiled into the binary.
+class PROTOBUF_EXPORT GeneratedExtensionFinder {
+ public:
+  explicit GeneratedExtensionFinder(const MessageLite* extendee)
+      : extendee_(extendee) {}
+
+  // Returns true and fills in *output if found, otherwise returns false.
+  bool Find(int number, ExtensionInfo* output);
+
+ private:
+  const MessageLite* extendee_;
+};
+
+// Note:  extension_set_heavy.cc defines DescriptorPoolExtensionFinder for
+// finding extensions from a DescriptorPool.
+
+// This is an internal helper class intended for use within the protocol buffer
+// library and generated classes.  Clients should not use it directly.  Instead,
+// use the generated accessors such as GetExtension() of the class being
+// extended.
+//
+// This class manages extensions for a protocol message object.  The
+// message's HasExtension(), GetExtension(), MutableExtension(), and
+// ClearExtension() methods are just thin wrappers around the embedded
+// ExtensionSet.  When parsing, if a tag number is encountered which is
+// inside one of the message type's extension ranges, the tag is passed
+// off to the ExtensionSet for parsing.  Etc.
+class PROTOBUF_EXPORT ExtensionSet {
+ public:
+  constexpr ExtensionSet();
+  explicit ExtensionSet(Arena* arena);
+  ExtensionSet(ArenaInitialized, Arena* arena) : ExtensionSet(arena) {}
+  ~ExtensionSet();
+
+  // These are called at startup by protocol-compiler-generated code to
+  // register known extensions.  The registrations are used by ParseField()
+  // to look up extensions for parsed field numbers.  Note that dynamic parsing
+  // does not use ParseField(); only protocol-compiler-generated parsing
+  // methods do.
+  static void RegisterExtension(const MessageLite* extendee, int number,
+                                FieldType type, bool is_repeated,
+                                bool is_packed,
+                                LazyEagerVerifyFnType verify_func);
+  static void RegisterEnumExtension(const MessageLite* extendee, int number,
+                                    FieldType type, bool is_repeated,
+                                    bool is_packed, EnumValidityFunc* is_valid);
+  static void RegisterMessageExtension(const MessageLite* extendee, int number,
+                                       FieldType type, bool is_repeated,
+                                       bool is_packed,
+                                       const MessageLite* prototype,
+                                       LazyEagerVerifyFnType verify_func);
+
+  // =================================================================
+
+  // Add all fields which are currently present to the given vector.  This
+  // is useful to implement Reflection::ListFields().
+  void AppendToList(const Descriptor* extendee, const DescriptorPool* pool,
+                    std::vector<const FieldDescriptor*>* output) const;
+
+  // =================================================================
+  // Accessors
+  //
+  // Generated message classes include type-safe templated wrappers around
+  // these methods.  Generally you should use those rather than call these
+  // directly, unless you are doing low-level memory management.
+  //
+  // When calling any of these accessors, the extension number requested
+  // MUST exist in the DescriptorPool provided to the constructor.  Otherwise,
+  // the method will fail an assert.  Normally, though, you would not call
+  // these directly; you would either call the generated accessors of your
+  // message class (e.g. GetExtension()) or you would call the accessors
+  // of the reflection interface.  In both cases, it is impossible to
+  // trigger this assert failure:  the generated accessors only accept
+  // linked-in extension types as parameters, while the Reflection interface
+  // requires you to provide the FieldDescriptor describing the extension.
+  //
+  // When calling any of these accessors, a protocol-compiler-generated
+  // implementation of the extension corresponding to the number MUST
+  // be linked in, and the FieldDescriptor used to refer to it MUST be
+  // the one generated by that linked-in code.  Otherwise, the method will
+  // die on an assert failure.  The message objects returned by the message
+  // accessors are guaranteed to be of the correct linked-in type.
+  //
+  // These methods pretty much match Reflection except that:
+  // - They're not virtual.
+  // - They identify fields by number rather than FieldDescriptors.
+  // - They identify enum values using integers rather than descriptors.
+  // - Strings provide Mutable() in addition to Set() accessors.
+
+  bool Has(int number) const;
+  int ExtensionSize(int number) const;  // Size of a repeated extension.
+  int NumExtensions() const;            // The number of extensions
+  FieldType ExtensionType(int number) const;
+  void ClearExtension(int number);
+
+  // singular fields -------------------------------------------------
+
+  int32_t GetInt32(int number, int32_t default_value) const;
+  int64_t GetInt64(int number, int64_t default_value) const;
+  uint32_t GetUInt32(int number, uint32_t default_value) const;
+  uint64_t GetUInt64(int number, uint64_t default_value) const;
+  float GetFloat(int number, float default_value) const;
+  double GetDouble(int number, double default_value) const;
+  bool GetBool(int number, bool default_value) const;
+  int GetEnum(int number, int default_value) const;
+  const std::string& GetString(int number,
+                               const std::string& default_value) const;
+  const MessageLite& GetMessage(int number,
+                                const MessageLite& default_value) const;
+  const MessageLite& GetMessage(int number, const Descriptor* message_type,
+                                MessageFactory* factory) const;
+
+  // |descriptor| may be nullptr so long as it is known that the descriptor for
+  // the extension lives in the same pool as the descriptor for the containing
+  // type.
+#define desc const FieldDescriptor* descriptor  // avoid line wrapping
+  void SetInt32(int number, FieldType type, int32_t value, desc);
+  void SetInt64(int number, FieldType type, int64_t value, desc);
+  void SetUInt32(int number, FieldType type, uint32_t value, desc);
+  void SetUInt64(int number, FieldType type, uint64_t value, desc);
+  void SetFloat(int number, FieldType type, float value, desc);
+  void SetDouble(int number, FieldType type, double value, desc);
+  void SetBool(int number, FieldType type, bool value, desc);
+  void SetEnum(int number, FieldType type, int value, desc);
+  void SetString(int number, FieldType type, std::string value, desc);
+  std::string* MutableString(int number, FieldType type, desc);
+  MessageLite* MutableMessage(int number, FieldType type,
+                              const MessageLite& prototype, desc);
+  MessageLite* MutableMessage(const FieldDescriptor* descriptor,
+                              MessageFactory* factory);
+  // Adds the given message to the ExtensionSet, taking ownership of the
+  // message object. Existing message with the same number will be deleted.
+  // If "message" is nullptr, this is equivalent to "ClearExtension(number)".
+  void SetAllocatedMessage(int number, FieldType type,
+                           const FieldDescriptor* descriptor,
+                           MessageLite* message);
+  void UnsafeArenaSetAllocatedMessage(int number, FieldType type,
+                                      const FieldDescriptor* descriptor,
+                                      MessageLite* message);
+  PROTOBUF_NODISCARD MessageLite* ReleaseMessage(int number,
+                                                 const MessageLite& prototype);
+  MessageLite* UnsafeArenaReleaseMessage(int number,
+                                         const MessageLite& prototype);
+
+  PROTOBUF_NODISCARD MessageLite* ReleaseMessage(
+      const FieldDescriptor* descriptor, MessageFactory* factory);
+  MessageLite* UnsafeArenaReleaseMessage(const FieldDescriptor* descriptor,
+                                         MessageFactory* factory);
+#undef desc
+  Arena* GetArena() const { return arena_; }
+
+  // repeated fields -------------------------------------------------
+
+  // Fetches a RepeatedField extension by number; returns |default_value|
+  // if no such extension exists. User should not touch this directly; it is
+  // used by the GetRepeatedExtension() method.
+  const void* GetRawRepeatedField(int number, const void* default_value) const;
+  // Fetches a mutable version of a RepeatedField extension by number,
+  // instantiating one if none exists. Similar to above, user should not use
+  // this directly; it underlies MutableRepeatedExtension().
+  void* MutableRawRepeatedField(int number, FieldType field_type, bool packed,
+                                const FieldDescriptor* desc);
+
+  // This is an overload of MutableRawRepeatedField to maintain compatibility
+  // with old code using a previous API. This version of
+  // MutableRawRepeatedField() will GOOGLE_CHECK-fail on a missing extension.
+  // (E.g.: borg/clients/internal/proto1/proto2_reflection.cc.)
+  void* MutableRawRepeatedField(int number);
+
+  int32_t GetRepeatedInt32(int number, int index) const;
+  int64_t GetRepeatedInt64(int number, int index) const;
+  uint32_t GetRepeatedUInt32(int number, int index) const;
+  uint64_t GetRepeatedUInt64(int number, int index) const;
+  float GetRepeatedFloat(int number, int index) const;
+  double GetRepeatedDouble(int number, int index) const;
+  bool GetRepeatedBool(int number, int index) const;
+  int GetRepeatedEnum(int number, int index) const;
+  const std::string& GetRepeatedString(int number, int index) const;
+  const MessageLite& GetRepeatedMessage(int number, int index) const;
+
+  void SetRepeatedInt32(int number, int index, int32_t value);
+  void SetRepeatedInt64(int number, int index, int64_t value);
+  void SetRepeatedUInt32(int number, int index, uint32_t value);
+  void SetRepeatedUInt64(int number, int index, uint64_t value);
+  void SetRepeatedFloat(int number, int index, float value);
+  void SetRepeatedDouble(int number, int index, double value);
+  void SetRepeatedBool(int number, int index, bool value);
+  void SetRepeatedEnum(int number, int index, int value);
+  void SetRepeatedString(int number, int index, std::string value);
+  std::string* MutableRepeatedString(int number, int index);
+  MessageLite* MutableRepeatedMessage(int number, int index);
+
+#define desc const FieldDescriptor* descriptor  // avoid line wrapping
+  void AddInt32(int number, FieldType type, bool packed, int32_t value, desc);
+  void AddInt64(int number, FieldType type, bool packed, int64_t value, desc);
+  void AddUInt32(int number, FieldType type, bool packed, uint32_t value, desc);
+  void AddUInt64(int number, FieldType type, bool packed, uint64_t value, desc);
+  void AddFloat(int number, FieldType type, bool packed, float value, desc);
+  void AddDouble(int number, FieldType type, bool packed, double value, desc);
+  void AddBool(int number, FieldType type, bool packed, bool value, desc);
+  void AddEnum(int number, FieldType type, bool packed, int value, desc);
+  void AddString(int number, FieldType type, std::string value, desc);
+  std::string* AddString(int number, FieldType type, desc);
+  MessageLite* AddMessage(int number, FieldType type,
+                          const MessageLite& prototype, desc);
+  MessageLite* AddMessage(const FieldDescriptor* descriptor,
+                          MessageFactory* factory);
+  void AddAllocatedMessage(const FieldDescriptor* descriptor,
+                           MessageLite* new_entry);
+  void UnsafeArenaAddAllocatedMessage(const FieldDescriptor* descriptor,
+                                      MessageLite* new_entry);
+#undef desc
+
+  void RemoveLast(int number);
+  PROTOBUF_NODISCARD MessageLite* ReleaseLast(int number);
+  MessageLite* UnsafeArenaReleaseLast(int number);
+  void SwapElements(int number, int index1, int index2);
+
+  // =================================================================
+  // convenience methods for implementing methods of Message
+  //
+  // These could all be implemented in terms of the other methods of this
+  // class, but providing them here helps keep the generated code size down.
+
+  void Clear();
+  void MergeFrom(const MessageLite* extendee, const ExtensionSet& other);
+  void Swap(const MessageLite* extendee, ExtensionSet* other);
+  void InternalSwap(ExtensionSet* other);
+  void SwapExtension(const MessageLite* extendee, ExtensionSet* other,
+                     int number);
+  void UnsafeShallowSwapExtension(ExtensionSet* other, int number);
+  bool IsInitialized() const;
+
+  // Lite parser
+  const char* ParseField(uint64_t tag, const char* ptr,
+                         const MessageLite* extendee,
+                         internal::InternalMetadata* metadata,
+                         internal::ParseContext* ctx);
+  // Full parser
+  const char* ParseField(uint64_t tag, const char* ptr, const Message* extendee,
+                         internal::InternalMetadata* metadata,
+                         internal::ParseContext* ctx);
+  template <typename Msg>
+  const char* ParseMessageSet(const char* ptr, const Msg* extendee,
+                              InternalMetadata* metadata,
+                              internal::ParseContext* ctx) {
+    struct MessageSetItem {
+      const char* _InternalParse(const char* ptr, ParseContext* ctx) {
+        return me->ParseMessageSetItem(ptr, extendee, metadata, ctx);
+      }
+      ExtensionSet* me;
+      const Msg* extendee;
+      InternalMetadata* metadata;
+    } item{this, extendee, metadata};
+    while (!ctx->Done(&ptr)) {
+      uint32_t tag;
+      ptr = ReadTag(ptr, &tag);
+      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+      if (tag == WireFormatLite::kMessageSetItemStartTag) {
+        ptr = ctx->ParseGroup(&item, ptr, tag);
+        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+      } else {
+        if (tag == 0 || (tag & 7) == 4) {
+          ctx->SetLastTag(tag);
+          return ptr;
+        }
+        ptr = ParseField(tag, ptr, extendee, metadata, ctx);
+        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+      }
+    }
+    return ptr;
+  }
+
+  // Write all extension fields with field numbers in the range
+  //   [start_field_number, end_field_number)
+  // to the output stream, using the cached sizes computed when ByteSize() was
+  // last called.  Note that the range bounds are inclusive-exclusive.
+  void SerializeWithCachedSizes(const MessageLite* extendee,
+                                int start_field_number, int end_field_number,
+                                io::CodedOutputStream* output) const {
+    output->SetCur(_InternalSerialize(extendee, start_field_number,
+                                      end_field_number, output->Cur(),
+                                      output->EpsCopy()));
+  }
+
+  // Same as SerializeWithCachedSizes, but without any bounds checking.
+  // The caller must ensure that target has sufficient capacity for the
+  // serialized extensions.
+  //
+  // Returns a pointer past the last written byte.
+
+  uint8_t* _InternalSerialize(const MessageLite* extendee,
+                              int start_field_number, int end_field_number,
+                              uint8_t* target,
+                              io::EpsCopyOutputStream* stream) const {
+    if (flat_size_ == 0) {
+      assert(!is_large());
+      return target;
+    }
+    return _InternalSerializeImpl(extendee, start_field_number,
+                                  end_field_number, target, stream);
+  }
+
+  // Like above but serializes in MessageSet format.
+  void SerializeMessageSetWithCachedSizes(const MessageLite* extendee,
+                                          io::CodedOutputStream* output) const {
+    output->SetCur(InternalSerializeMessageSetWithCachedSizesToArray(
+        extendee, output->Cur(), output->EpsCopy()));
+  }
+  uint8_t* InternalSerializeMessageSetWithCachedSizesToArray(
+      const MessageLite* extendee, uint8_t* target,
+      io::EpsCopyOutputStream* stream) const;
+
+  // For backward-compatibility, versions of two of the above methods that
+  // serialize deterministically iff SetDefaultSerializationDeterministic()
+  // has been called.
+  uint8_t* SerializeWithCachedSizesToArray(int start_field_number,
+                                           int end_field_number,
+                                           uint8_t* target) const;
+  uint8_t* SerializeMessageSetWithCachedSizesToArray(
+      const MessageLite* extendee, uint8_t* target) const;
+
+  // Returns the total serialized size of all the extensions.
+  size_t ByteSize() const;
+
+  // Like ByteSize() but uses MessageSet format.
+  size_t MessageSetByteSize() const;
+
+  // Returns (an estimate of) the total number of bytes used for storing the
+  // extensions in memory, excluding sizeof(*this).  If the ExtensionSet is
+  // for a lite message (and thus possibly contains lite messages), the results
+  // are undefined (might work, might crash, might corrupt data, might not even
+  // be linked in).  It's up to the protocol compiler to avoid calling this on
+  // such ExtensionSets (easy enough since lite messages don't implement
+  // SpaceUsed()).
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  // This method just calls SpaceUsedExcludingSelfLong() but it can not be
+  // inlined because the definition of SpaceUsedExcludingSelfLong() is not
+  // included in lite runtime and when an inline method refers to it MSVC
+  // will complain about unresolved symbols when building the lite runtime
+  // as .dll.
+  int SpaceUsedExcludingSelf() const;
+
+ private:
+  template <typename Type>
+  friend class PrimitiveTypeTraits;
+
+  template <typename Type>
+  friend class RepeatedPrimitiveTypeTraits;
+
+  template <typename Type, bool IsValid(int)>
+  friend class EnumTypeTraits;
+
+  template <typename Type, bool IsValid(int)>
+  friend class RepeatedEnumTypeTraits;
+
+  friend class google::protobuf::Reflection;
+
+  const int32_t& GetRefInt32(int number, const int32_t& default_value) const;
+  const int64_t& GetRefInt64(int number, const int64_t& default_value) const;
+  const uint32_t& GetRefUInt32(int number, const uint32_t& default_value) const;
+  const uint64_t& GetRefUInt64(int number, const uint64_t& default_value) const;
+  const float& GetRefFloat(int number, const float& default_value) const;
+  const double& GetRefDouble(int number, const double& default_value) const;
+  const bool& GetRefBool(int number, const bool& default_value) const;
+  const int& GetRefEnum(int number, const int& default_value) const;
+  const int32_t& GetRefRepeatedInt32(int number, int index) const;
+  const int64_t& GetRefRepeatedInt64(int number, int index) const;
+  const uint32_t& GetRefRepeatedUInt32(int number, int index) const;
+  const uint64_t& GetRefRepeatedUInt64(int number, int index) const;
+  const float& GetRefRepeatedFloat(int number, int index) const;
+  const double& GetRefRepeatedDouble(int number, int index) const;
+  const bool& GetRefRepeatedBool(int number, int index) const;
+  const int& GetRefRepeatedEnum(int number, int index) const;
+
+  // Implementation of _InternalSerialize for non-empty map_.
+  uint8_t* _InternalSerializeImpl(const MessageLite* extendee,
+                                  int start_field_number, int end_field_number,
+                                  uint8_t* target,
+                                  io::EpsCopyOutputStream* stream) const;
+  // Interface of a lazily parsed singular message extension.
+  class PROTOBUF_EXPORT LazyMessageExtension {
+   public:
+    LazyMessageExtension() {}
+    virtual ~LazyMessageExtension() {}
+
+    virtual LazyMessageExtension* New(Arena* arena) const = 0;
+    virtual const MessageLite& GetMessage(const MessageLite& prototype,
+                                          Arena* arena) const = 0;
+    virtual MessageLite* MutableMessage(const MessageLite& prototype,
+                                        Arena* arena) = 0;
+    virtual void SetAllocatedMessage(MessageLite* message, Arena* arena) = 0;
+    virtual void UnsafeArenaSetAllocatedMessage(MessageLite* message,
+                                                Arena* arena) = 0;
+    PROTOBUF_NODISCARD virtual MessageLite* ReleaseMessage(
+        const MessageLite& prototype, Arena* arena) = 0;
+    virtual MessageLite* UnsafeArenaReleaseMessage(const MessageLite& prototype,
+                                                   Arena* arena) = 0;
+
+    virtual bool IsInitialized() const = 0;
+
+    PROTOBUF_DEPRECATED_MSG("Please use ByteSizeLong() instead")
+    virtual int ByteSize() const { return internal::ToIntSize(ByteSizeLong()); }
+    virtual size_t ByteSizeLong() const = 0;
+    virtual size_t SpaceUsedLong() const = 0;
+
+    virtual void MergeFrom(const MessageLite* prototype,
+                           const LazyMessageExtension& other, Arena* arena) = 0;
+    virtual void MergeFromMessage(const MessageLite& msg, Arena* arena) = 0;
+    virtual void Clear() = 0;
+
+    virtual const char* _InternalParse(const Message& prototype, Arena* arena,
+                                       LazyVerifyOption option, const char* ptr,
+                                       ParseContext* ctx) = 0;
+    virtual uint8_t* WriteMessageToArray(
+        const MessageLite* prototype, int number, uint8_t* target,
+        io::EpsCopyOutputStream* stream) const = 0;
+
+   private:
+    virtual void UnusedKeyMethod();  // Dummy key method to avoid weak vtable.
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LazyMessageExtension);
+  };
+  // Give access to function defined below to see LazyMessageExtension.
+  friend LazyMessageExtension* MaybeCreateLazyExtension(Arena* arena);
+  struct Extension {
+    // The order of these fields packs Extension into 24 bytes when using 8
+    // byte alignment. Consider this when adding or removing fields here.
+    union {
+      int32_t int32_t_value;
+      int64_t int64_t_value;
+      uint32_t uint32_t_value;
+      uint64_t uint64_t_value;
+      float float_value;
+      double double_value;
+      bool bool_value;
+      int enum_value;
+      std::string* string_value;
+      MessageLite* message_value;
+      LazyMessageExtension* lazymessage_value;
+
+      RepeatedField<int32_t>* repeated_int32_t_value;
+      RepeatedField<int64_t>* repeated_int64_t_value;
+      RepeatedField<uint32_t>* repeated_uint32_t_value;
+      RepeatedField<uint64_t>* repeated_uint64_t_value;
+      RepeatedField<float>* repeated_float_value;
+      RepeatedField<double>* repeated_double_value;
+      RepeatedField<bool>* repeated_bool_value;
+      RepeatedField<int>* repeated_enum_value;
+      RepeatedPtrField<std::string>* repeated_string_value;
+      RepeatedPtrField<MessageLite>* repeated_message_value;
+    };
+
+    FieldType type;
+    bool is_repeated;
+
+    // For singular types, indicates if the extension is "cleared".  This
+    // happens when an extension is set and then later cleared by the caller.
+    // We want to keep the Extension object around for reuse, so instead of
+    // removing it from the map, we just set is_cleared = true.  This has no
+    // meaning for repeated types; for those, the size of the RepeatedField
+    // simply becomes zero when cleared.
+    bool is_cleared : 4;
+
+    // For singular message types, indicates whether lazy parsing is enabled
+    // for this extension. This field is only valid when type == TYPE_MESSAGE
+    // and !is_repeated because we only support lazy parsing for singular
+    // message types currently. If is_lazy = true, the extension is stored in
+    // lazymessage_value. Otherwise, the extension will be message_value.
+    bool is_lazy : 4;
+
+    // For repeated types, this indicates if the [packed=true] option is set.
+    bool is_packed;
+
+    // For packed fields, the size of the packed data is recorded here when
+    // ByteSize() is called then used during serialization.
+    // TODO(kenton):  Use atomic<int> when C++ supports it.
+    mutable int cached_size;
+
+    // The descriptor for this extension, if one exists and is known.  May be
+    // nullptr.  Must not be nullptr if the descriptor for the extension does
+    // not live in the same pool as the descriptor for the containing type.
+    const FieldDescriptor* descriptor;
+
+    // Some helper methods for operations on a single Extension.
+    uint8_t* InternalSerializeFieldWithCachedSizesToArray(
+        const MessageLite* extendee, const ExtensionSet* extension_set,
+        int number, uint8_t* target, io::EpsCopyOutputStream* stream) const;
+    uint8_t* InternalSerializeMessageSetItemWithCachedSizesToArray(
+        const MessageLite* extendee, const ExtensionSet* extension_set,
+        int number, uint8_t* target, io::EpsCopyOutputStream* stream) const;
+    size_t ByteSize(int number) const;
+    size_t MessageSetItemByteSize(int number) const;
+    void Clear();
+    int GetSize() const;
+    void Free();
+    size_t SpaceUsedExcludingSelfLong() const;
+    bool IsInitialized() const;
+  };
+
+  // The Extension struct is small enough to be passed by value, so we use it
+  // directly as the value type in mappings rather than use pointers.  We use
+  // sorted maps rather than hash-maps because we expect most ExtensionSets will
+  // only contain a small number of extension.  Also, we want AppendToList and
+  // deterministic serialization to order fields by field number.
+
+  struct KeyValue {
+    int first;
+    Extension second;
+
+    struct FirstComparator {
+      bool operator()(const KeyValue& lhs, const KeyValue& rhs) const {
+        return lhs.first < rhs.first;
+      }
+      bool operator()(const KeyValue& lhs, int key) const {
+        return lhs.first < key;
+      }
+      bool operator()(int key, const KeyValue& rhs) const {
+        return key < rhs.first;
+      }
+    };
+  };
+
+  typedef std::map<int, Extension> LargeMap;
+
+  // Wrapper API that switches between flat-map and LargeMap.
+
+  // Finds a key (if present) in the ExtensionSet.
+  const Extension* FindOrNull(int key) const;
+  Extension* FindOrNull(int key);
+
+  // Helper-functions that only inspect the LargeMap.
+  const Extension* FindOrNullInLargeMap(int key) const;
+  Extension* FindOrNullInLargeMap(int key);
+
+  // Inserts a new (key, Extension) into the ExtensionSet (and returns true), or
+  // finds the already-existing Extension for that key (returns false).
+  // The Extension* will point to the new-or-found Extension.
+  std::pair<Extension*, bool> Insert(int key);
+
+  // Grows the flat_capacity_.
+  // If flat_capacity_ > kMaximumFlatCapacity, converts to LargeMap.
+  void GrowCapacity(size_t minimum_new_capacity);
+  static constexpr uint16_t kMaximumFlatCapacity = 256;
+  bool is_large() const { return static_cast<int16_t>(flat_size_) < 0; }
+
+  // Removes a key from the ExtensionSet.
+  void Erase(int key);
+
+  size_t Size() const {
+    return PROTOBUF_PREDICT_FALSE(is_large()) ? map_.large->size() : flat_size_;
+  }
+
+  // Similar to std::for_each.
+  // Each Iterator is decomposed into ->first and ->second fields, so
+  // that the KeyValueFunctor can be agnostic vis-a-vis KeyValue-vs-std::pair.
+  template <typename Iterator, typename KeyValueFunctor>
+  static KeyValueFunctor ForEach(Iterator begin, Iterator end,
+                                 KeyValueFunctor func) {
+    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
+    return std::move(func);
+  }
+
+  // Applies a functor to the <int, Extension&> pairs in sorted order.
+  template <typename KeyValueFunctor>
+  KeyValueFunctor ForEach(KeyValueFunctor func) {
+    if (PROTOBUF_PREDICT_FALSE(is_large())) {
+      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
+    }
+    return ForEach(flat_begin(), flat_end(), std::move(func));
+  }
+
+  // Applies a functor to the <int, const Extension&> pairs in sorted order.
+  template <typename KeyValueFunctor>
+  KeyValueFunctor ForEach(KeyValueFunctor func) const {
+    if (PROTOBUF_PREDICT_FALSE(is_large())) {
+      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
+    }
+    return ForEach(flat_begin(), flat_end(), std::move(func));
+  }
+
+  // Merges existing Extension from other_extension
+  void InternalExtensionMergeFrom(const MessageLite* extendee, int number,
+                                  const Extension& other_extension,
+                                  Arena* other_arena);
+
+  inline static bool is_packable(WireFormatLite::WireType type) {
+    switch (type) {
+      case WireFormatLite::WIRETYPE_VARINT:
+      case WireFormatLite::WIRETYPE_FIXED64:
+      case WireFormatLite::WIRETYPE_FIXED32:
+        return true;
+      case WireFormatLite::WIRETYPE_LENGTH_DELIMITED:
+      case WireFormatLite::WIRETYPE_START_GROUP:
+      case WireFormatLite::WIRETYPE_END_GROUP:
+        return false;
+
+        // Do not add a default statement. Let the compiler complain when
+        // someone
+        // adds a new wire type.
+    }
+    PROTOBUF_ASSUME(false);  // switch handles all possible enum values
+    return false;
+  }
+
+  // Returns true and fills field_number and extension if extension is found.
+  // Note to support packed repeated field compatibility, it also fills whether
+  // the tag on wire is packed, which can be different from
+  // extension->is_packed (whether packed=true is specified).
+  template <typename ExtensionFinder>
+  bool FindExtensionInfoFromTag(uint32_t tag, ExtensionFinder* extension_finder,
+                                int* field_number, ExtensionInfo* extension,
+                                bool* was_packed_on_wire) {
+    *field_number = WireFormatLite::GetTagFieldNumber(tag);
+    WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
+    return FindExtensionInfoFromFieldNumber(wire_type, *field_number,
+                                            extension_finder, extension,
+                                            was_packed_on_wire);
+  }
+
+  // Returns true and fills extension if extension is found.
+  // Note to support packed repeated field compatibility, it also fills whether
+  // the tag on wire is packed, which can be different from
+  // extension->is_packed (whether packed=true is specified).
+  template <typename ExtensionFinder>
+  bool FindExtensionInfoFromFieldNumber(int wire_type, int field_number,
+                                        ExtensionFinder* extension_finder,
+                                        ExtensionInfo* extension,
+                                        bool* was_packed_on_wire) const {
+    if (!extension_finder->Find(field_number, extension)) {
+      return false;
+    }
+
+    GOOGLE_DCHECK(extension->type > 0 &&
+           extension->type <= WireFormatLite::MAX_FIELD_TYPE);
+    auto real_type = static_cast<WireFormatLite::FieldType>(extension->type);
+
+    WireFormatLite::WireType expected_wire_type =
+        WireFormatLite::WireTypeForFieldType(real_type);
+
+    // Check if this is a packed field.
+    *was_packed_on_wire = false;
+    if (extension->is_repeated &&
+        wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED &&
+        is_packable(expected_wire_type)) {
+      *was_packed_on_wire = true;
+      return true;
+    }
+    // Otherwise the wire type must match.
+    return expected_wire_type == wire_type;
+  }
+
+  // Find the prototype for a LazyMessage from the extension registry. Returns
+  // null if the extension is not found.
+  const MessageLite* GetPrototypeForLazyMessage(const MessageLite* extendee,
+                                                int number) const;
+
+  // Returns true if extension is present and lazy.
+  bool HasLazy(int number) const;
+
+  // Gets the extension with the given number, creating it if it does not
+  // already exist.  Returns true if the extension did not already exist.
+  bool MaybeNewExtension(int number, const FieldDescriptor* descriptor,
+                         Extension** result);
+
+  // Gets the repeated extension for the given descriptor, creating it if
+  // it does not exist.
+  Extension* MaybeNewRepeatedExtension(const FieldDescriptor* descriptor);
+
+  bool FindExtension(int wire_type, uint32_t field, const MessageLite* extendee,
+                     const internal::ParseContext* /*ctx*/,
+                     ExtensionInfo* extension, bool* was_packed_on_wire) {
+    GeneratedExtensionFinder finder(extendee);
+    return FindExtensionInfoFromFieldNumber(wire_type, field, &finder,
+                                            extension, was_packed_on_wire);
+  }
+  inline bool FindExtension(int wire_type, uint32_t field,
+                            const Message* extendee,
+                            const internal::ParseContext* ctx,
+                            ExtensionInfo* extension, bool* was_packed_on_wire);
+  // Used for MessageSet only
+  const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr,
+                                    const MessageLite* extendee,
+                                    internal::InternalMetadata* metadata,
+                                    internal::ParseContext* ctx) {
+    // Lite MessageSet doesn't implement lazy.
+    return ParseField(tag, ptr, extendee, metadata, ctx);
+  }
+  const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr,
+                                    const Message* extendee,
+                                    internal::InternalMetadata* metadata,
+                                    internal::ParseContext* ctx);
+  const char* ParseMessageSetItem(const char* ptr, const MessageLite* extendee,
+                                  internal::InternalMetadata* metadata,
+                                  internal::ParseContext* ctx);
+  const char* ParseMessageSetItem(const char* ptr, const Message* extendee,
+                                  internal::InternalMetadata* metadata,
+                                  internal::ParseContext* ctx);
+
+  // Implemented in extension_set_inl.h to keep code out of the header file.
+  template <typename T>
+  const char* ParseFieldWithExtensionInfo(int number, bool was_packed_on_wire,
+                                          const ExtensionInfo& info,
+                                          internal::InternalMetadata* metadata,
+                                          const char* ptr,
+                                          internal::ParseContext* ctx);
+  template <typename Msg, typename T>
+  const char* ParseMessageSetItemTmpl(const char* ptr, const Msg* extendee,
+                                      internal::InternalMetadata* metadata,
+                                      internal::ParseContext* ctx);
+
+  // Hack:  RepeatedPtrFieldBase declares ExtensionSet as a friend.  This
+  //   friendship should automatically extend to ExtensionSet::Extension, but
+  //   unfortunately some older compilers (e.g. GCC 3.4.4) do not implement this
+  //   correctly.  So, we must provide helpers for calling methods of that
+  //   class.
+
+  // Defined in extension_set_heavy.cc.
+  static inline size_t RepeatedMessage_SpaceUsedExcludingSelfLong(
+      RepeatedPtrFieldBase* field);
+
+  KeyValue* flat_begin() {
+    assert(!is_large());
+    return map_.flat;
+  }
+  const KeyValue* flat_begin() const {
+    assert(!is_large());
+    return map_.flat;
+  }
+  KeyValue* flat_end() {
+    assert(!is_large());
+    return map_.flat + flat_size_;
+  }
+  const KeyValue* flat_end() const {
+    assert(!is_large());
+    return map_.flat + flat_size_;
+  }
+
+  Arena* arena_;
+
+  // Manual memory-management:
+  // map_.flat is an allocated array of flat_capacity_ elements.
+  // [map_.flat, map_.flat + flat_size_) is the currently-in-use prefix.
+  uint16_t flat_capacity_;
+  uint16_t flat_size_;  // negative int16_t(flat_size_) indicates is_large()
+  union AllocatedData {
+    KeyValue* flat;
+
+    // If flat_capacity_ > kMaximumFlatCapacity, switch to LargeMap,
+    // which guarantees O(n lg n) CPU but larger constant factors.
+    LargeMap* large;
+  } map_;
+
+  static void DeleteFlatMap(const KeyValue* flat, uint16_t flat_capacity);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ExtensionSet);
+};
+
+constexpr ExtensionSet::ExtensionSet()
+    : arena_(nullptr), flat_capacity_(0), flat_size_(0), map_{nullptr} {}
+
+// These are just for convenience...
+inline void ExtensionSet::SetString(int number, FieldType type,
+                                    std::string value,
+                                    const FieldDescriptor* descriptor) {
+  MutableString(number, type, descriptor)->assign(std::move(value));
+}
+inline void ExtensionSet::SetRepeatedString(int number, int index,
+                                            std::string value) {
+  MutableRepeatedString(number, index)->assign(std::move(value));
+}
+inline void ExtensionSet::AddString(int number, FieldType type,
+                                    std::string value,
+                                    const FieldDescriptor* descriptor) {
+  AddString(number, type, descriptor)->assign(std::move(value));
+}
+// ===================================================================
+// Glue for generated extension accessors
+
+// -------------------------------------------------------------------
+// Template magic
+
+// First we have a set of classes representing "type traits" for different
+// field types.  A type traits class knows how to implement basic accessors
+// for extensions of a particular type given an ExtensionSet.  The signature
+// for a type traits class looks like this:
+//
+//   class TypeTraits {
+//    public:
+//     typedef ? ConstType;
+//     typedef ? MutableType;
+//     // TypeTraits for singular fields and repeated fields will define the
+//     // symbol "Singular" or "Repeated" respectively. These two symbols will
+//     // be used in extension accessors to distinguish between singular
+//     // extensions and repeated extensions. If the TypeTraits for the passed
+//     // in extension doesn't have the expected symbol defined, it means the
+//     // user is passing a repeated extension to a singular accessor, or the
+//     // opposite. In that case the C++ compiler will generate an error
+//     // message "no matching member function" to inform the user.
+//     typedef ? Singular
+//     typedef ? Repeated
+//
+//     static inline ConstType Get(int number, const ExtensionSet& set);
+//     static inline void Set(int number, ConstType value, ExtensionSet* set);
+//     static inline MutableType Mutable(int number, ExtensionSet* set);
+//
+//     // Variants for repeated fields.
+//     static inline ConstType Get(int number, const ExtensionSet& set,
+//                                 int index);
+//     static inline void Set(int number, int index,
+//                            ConstType value, ExtensionSet* set);
+//     static inline MutableType Mutable(int number, int index,
+//                                       ExtensionSet* set);
+//     static inline void Add(int number, ConstType value, ExtensionSet* set);
+//     static inline MutableType Add(int number, ExtensionSet* set);
+//     This is used by the ExtensionIdentifier constructor to register
+//     the extension at dynamic initialization.
+//     template <typename ExtendeeT>
+//     static void Register(int number, FieldType type, bool is_packed);
+//   };
+//
+// Not all of these methods make sense for all field types.  For example, the
+// "Mutable" methods only make sense for strings and messages, and the
+// repeated methods only make sense for repeated types.  So, each type
+// traits class implements only the set of methods from this signature that it
+// actually supports.  This will cause a compiler error if the user tries to
+// access an extension using a method that doesn't make sense for its type.
+// For example, if "foo" is an extension of type "optional int32", then if you
+// try to write code like:
+//   my_message.MutableExtension(foo)
+// you will get a compile error because PrimitiveTypeTraits<int32_t> does not
+// have a "Mutable()" method.
+
+// -------------------------------------------------------------------
+// PrimitiveTypeTraits
+
+// Since the ExtensionSet has different methods for each primitive type,
+// we must explicitly define the methods of the type traits class for each
+// known type.
+template <typename Type>
+class PrimitiveTypeTraits {
+ public:
+  typedef Type ConstType;
+  typedef Type MutableType;
+  typedef PrimitiveTypeTraits<Type> Singular;
+
+  static inline ConstType Get(int number, const ExtensionSet& set,
+                              ConstType default_value);
+
+  static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
+                                        const ConstType& default_value);
+  static inline void Set(int number, FieldType field_type, ConstType value,
+                         ExtensionSet* set);
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed,
+                       LazyEagerVerifyFnType verify_func) {
+    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
+                                    type, false, is_packed, verify_func);
+  }
+};
+
+template <typename Type>
+class RepeatedPrimitiveTypeTraits {
+ public:
+  typedef Type ConstType;
+  typedef Type MutableType;
+  typedef RepeatedPrimitiveTypeTraits<Type> Repeated;
+
+  typedef RepeatedField<Type> RepeatedFieldType;
+
+  static inline Type Get(int number, const ExtensionSet& set, int index);
+  static inline const Type* GetPtr(int number, const ExtensionSet& set,
+                                   int index);
+  static inline const RepeatedField<ConstType>* GetRepeatedPtr(
+      int number, const ExtensionSet& set);
+  static inline void Set(int number, int index, Type value, ExtensionSet* set);
+  static inline void Add(int number, FieldType field_type, bool is_packed,
+                         Type value, ExtensionSet* set);
+
+  static inline const RepeatedField<ConstType>& GetRepeated(
+      int number, const ExtensionSet& set);
+  static inline RepeatedField<Type>* MutableRepeated(int number,
+                                                     FieldType field_type,
+                                                     bool is_packed,
+                                                     ExtensionSet* set);
+
+  static const RepeatedFieldType* GetDefaultRepeatedField();
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed,
+                       LazyEagerVerifyFnType verify_func) {
+    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
+                                    type, true, is_packed, verify_func);
+  }
+};
+
+class PROTOBUF_EXPORT RepeatedPrimitiveDefaults {
+ private:
+  template <typename Type>
+  friend class RepeatedPrimitiveTypeTraits;
+  static const RepeatedPrimitiveDefaults* default_instance();
+  RepeatedField<int32_t> default_repeated_field_int32_t_;
+  RepeatedField<int64_t> default_repeated_field_int64_t_;
+  RepeatedField<uint32_t> default_repeated_field_uint32_t_;
+  RepeatedField<uint64_t> default_repeated_field_uint64_t_;
+  RepeatedField<double> default_repeated_field_double_;
+  RepeatedField<float> default_repeated_field_float_;
+  RepeatedField<bool> default_repeated_field_bool_;
+};
+
+#define PROTOBUF_DEFINE_PRIMITIVE_TYPE(TYPE, METHOD)                           \
+  template <>                                                                  \
+  inline TYPE PrimitiveTypeTraits<TYPE>::Get(                                  \
+      int number, const ExtensionSet& set, TYPE default_value) {               \
+    return set.Get##METHOD(number, default_value);                             \
+  }                                                                            \
+  template <>                                                                  \
+  inline const TYPE* PrimitiveTypeTraits<TYPE>::GetPtr(                        \
+      int number, const ExtensionSet& set, const TYPE& default_value) {        \
+    return &set.GetRef##METHOD(number, default_value);                         \
+  }                                                                            \
+  template <>                                                                  \
+  inline void PrimitiveTypeTraits<TYPE>::Set(int number, FieldType field_type, \
+                                             TYPE value, ExtensionSet* set) {  \
+    set->Set##METHOD(number, field_type, value, nullptr);                      \
+  }                                                                            \
+                                                                               \
+  template <>                                                                  \
+  inline TYPE RepeatedPrimitiveTypeTraits<TYPE>::Get(                          \
+      int number, const ExtensionSet& set, int index) {                        \
+    return set.GetRepeated##METHOD(number, index);                             \
+  }                                                                            \
+  template <>                                                                  \
+  inline const TYPE* RepeatedPrimitiveTypeTraits<TYPE>::GetPtr(                \
+      int number, const ExtensionSet& set, int index) {                        \
+    return &set.GetRefRepeated##METHOD(number, index);                         \
+  }                                                                            \
+  template <>                                                                  \
+  inline void RepeatedPrimitiveTypeTraits<TYPE>::Set(                          \
+      int number, int index, TYPE value, ExtensionSet* set) {                  \
+    set->SetRepeated##METHOD(number, index, value);                            \
+  }                                                                            \
+  template <>                                                                  \
+  inline void RepeatedPrimitiveTypeTraits<TYPE>::Add(                          \
+      int number, FieldType field_type, bool is_packed, TYPE value,            \
+      ExtensionSet* set) {                                                     \
+    set->Add##METHOD(number, field_type, is_packed, value, nullptr);           \
+  }                                                                            \
+  template <>                                                                  \
+  inline const RepeatedField<TYPE>*                                            \
+  RepeatedPrimitiveTypeTraits<TYPE>::GetDefaultRepeatedField() {               \
+    return &RepeatedPrimitiveDefaults::default_instance()                      \
+                ->default_repeated_field_##TYPE##_;                            \
+  }                                                                            \
+  template <>                                                                  \
+  inline const RepeatedField<TYPE>&                                            \
+  RepeatedPrimitiveTypeTraits<TYPE>::GetRepeated(int number,                   \
+                                                 const ExtensionSet& set) {    \
+    return *reinterpret_cast<const RepeatedField<TYPE>*>(                      \
+        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));           \
+  }                                                                            \
+  template <>                                                                  \
+  inline const RepeatedField<TYPE>*                                            \
+  RepeatedPrimitiveTypeTraits<TYPE>::GetRepeatedPtr(int number,                \
+                                                    const ExtensionSet& set) { \
+    return &GetRepeated(number, set);                                          \
+  }                                                                            \
+  template <>                                                                  \
+  inline RepeatedField<TYPE>*                                                  \
+  RepeatedPrimitiveTypeTraits<TYPE>::MutableRepeated(                          \
+      int number, FieldType field_type, bool is_packed, ExtensionSet* set) {   \
+    return reinterpret_cast<RepeatedField<TYPE>*>(                             \
+        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr)); \
+  }
+
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(int32_t, Int32)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(int64_t, Int64)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint32_t, UInt32)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint64_t, UInt64)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(float, Float)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(double, Double)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(bool, Bool)
+
+#undef PROTOBUF_DEFINE_PRIMITIVE_TYPE
+
+// -------------------------------------------------------------------
+// StringTypeTraits
+
+// Strings support both Set() and Mutable().
+class PROTOBUF_EXPORT StringTypeTraits {
+ public:
+  typedef const std::string& ConstType;
+  typedef std::string* MutableType;
+  typedef StringTypeTraits Singular;
+
+  static inline const std::string& Get(int number, const ExtensionSet& set,
+                                       ConstType default_value) {
+    return set.GetString(number, default_value);
+  }
+  static inline const std::string* GetPtr(int number, const ExtensionSet& set,
+                                          ConstType default_value) {
+    return &Get(number, set, default_value);
+  }
+  static inline void Set(int number, FieldType field_type,
+                         const std::string& value, ExtensionSet* set) {
+    set->SetString(number, field_type, value, nullptr);
+  }
+  static inline std::string* Mutable(int number, FieldType field_type,
+                                     ExtensionSet* set) {
+    return set->MutableString(number, field_type, nullptr);
+  }
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed,
+                       LazyEagerVerifyFnType verify_func) {
+    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
+                                    type, false, is_packed, verify_func);
+  }
+};
+
+class PROTOBUF_EXPORT RepeatedStringTypeTraits {
+ public:
+  typedef const std::string& ConstType;
+  typedef std::string* MutableType;
+  typedef RepeatedStringTypeTraits Repeated;
+
+  typedef RepeatedPtrField<std::string> RepeatedFieldType;
+
+  static inline const std::string& Get(int number, const ExtensionSet& set,
+                                       int index) {
+    return set.GetRepeatedString(number, index);
+  }
+  static inline const std::string* GetPtr(int number, const ExtensionSet& set,
+                                          int index) {
+    return &Get(number, set, index);
+  }
+  static inline const RepeatedPtrField<std::string>* GetRepeatedPtr(
+      int number, const ExtensionSet& set) {
+    return &GetRepeated(number, set);
+  }
+  static inline void Set(int number, int index, const std::string& value,
+                         ExtensionSet* set) {
+    set->SetRepeatedString(number, index, value);
+  }
+  static inline std::string* Mutable(int number, int index, ExtensionSet* set) {
+    return set->MutableRepeatedString(number, index);
+  }
+  static inline void Add(int number, FieldType field_type, bool /*is_packed*/,
+                         const std::string& value, ExtensionSet* set) {
+    set->AddString(number, field_type, value, nullptr);
+  }
+  static inline std::string* Add(int number, FieldType field_type,
+                                 ExtensionSet* set) {
+    return set->AddString(number, field_type, nullptr);
+  }
+  static inline const RepeatedPtrField<std::string>& GetRepeated(
+      int number, const ExtensionSet& set) {
+    return *reinterpret_cast<const RepeatedPtrField<std::string>*>(
+        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
+  }
+
+  static inline RepeatedPtrField<std::string>* MutableRepeated(
+      int number, FieldType field_type, bool is_packed, ExtensionSet* set) {
+    return reinterpret_cast<RepeatedPtrField<std::string>*>(
+        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
+  }
+
+  static const RepeatedFieldType* GetDefaultRepeatedField();
+
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed,
+                       LazyEagerVerifyFnType fn) {
+    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
+                                    type, true, is_packed, fn);
+  }
+
+ private:
+  static void InitializeDefaultRepeatedFields();
+  static void DestroyDefaultRepeatedFields();
+};
+
+// -------------------------------------------------------------------
+// EnumTypeTraits
+
+// ExtensionSet represents enums using integers internally, so we have to
+// static_cast around.
+template <typename Type, bool IsValid(int)>
+class EnumTypeTraits {
+ public:
+  typedef Type ConstType;
+  typedef Type MutableType;
+  typedef EnumTypeTraits<Type, IsValid> Singular;
+
+  static inline ConstType Get(int number, const ExtensionSet& set,
+                              ConstType default_value) {
+    return static_cast<Type>(set.GetEnum(number, default_value));
+  }
+  static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
+                                        const ConstType& default_value) {
+    return reinterpret_cast<const Type*>(
+        &set.GetRefEnum(number, default_value));
+  }
+  static inline void Set(int number, FieldType field_type, ConstType value,
+                         ExtensionSet* set) {
+    GOOGLE_DCHECK(IsValid(value));
+    set->SetEnum(number, field_type, value, nullptr);
+  }
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed,
+                       LazyEagerVerifyFnType fn) {
+    ExtensionSet::RegisterEnumExtension(&ExtendeeT::default_instance(), number,
+                                        type, false, is_packed, IsValid);
+  }
+};
+
+template <typename Type, bool IsValid(int)>
+class RepeatedEnumTypeTraits {
+ public:
+  typedef Type ConstType;
+  typedef Type MutableType;
+  typedef RepeatedEnumTypeTraits<Type, IsValid> Repeated;
+
+  typedef RepeatedField<Type> RepeatedFieldType;
+
+  static inline ConstType Get(int number, const ExtensionSet& set, int index) {
+    return static_cast<Type>(set.GetRepeatedEnum(number, index));
+  }
+  static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
+                                        int index) {
+    return reinterpret_cast<const Type*>(
+        &set.GetRefRepeatedEnum(number, index));
+  }
+  static inline void Set(int number, int index, ConstType value,
+                         ExtensionSet* set) {
+    GOOGLE_DCHECK(IsValid(value));
+    set->SetRepeatedEnum(number, index, value);
+  }
+  static inline void Add(int number, FieldType field_type, bool is_packed,
+                         ConstType value, ExtensionSet* set) {
+    GOOGLE_DCHECK(IsValid(value));
+    set->AddEnum(number, field_type, is_packed, value, nullptr);
+  }
+  static inline const RepeatedField<Type>& GetRepeated(
+      int number, const ExtensionSet& set) {
+    // Hack: the `Extension` struct stores a RepeatedField<int> for enums.
+    // RepeatedField<int> cannot implicitly convert to RepeatedField<EnumType>
+    // so we need to do some casting magic. See message.h for similar
+    // contortions for non-extension fields.
+    return *reinterpret_cast<const RepeatedField<Type>*>(
+        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
+  }
+  static inline const RepeatedField<Type>* GetRepeatedPtr(
+      int number, const ExtensionSet& set) {
+    return &GetRepeated(number, set);
+  }
+  static inline RepeatedField<Type>* MutableRepeated(int number,
+                                                     FieldType field_type,
+                                                     bool is_packed,
+                                                     ExtensionSet* set) {
+    return reinterpret_cast<RepeatedField<Type>*>(
+        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
+  }
+
+  static const RepeatedFieldType* GetDefaultRepeatedField() {
+    // Hack: as noted above, repeated enum fields are internally stored as a
+    // RepeatedField<int>. We need to be able to instantiate global static
+    // objects to return as default (empty) repeated fields on non-existent
+    // extensions. We would not be able to know a-priori all of the enum types
+    // (values of |Type|) to instantiate all of these, so we just re-use
+    // int32_t's default repeated field object.
+    return reinterpret_cast<const RepeatedField<Type>*>(
+        RepeatedPrimitiveTypeTraits<int32_t>::GetDefaultRepeatedField());
+  }
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed,
+                       LazyEagerVerifyFnType fn) {
+    ExtensionSet::RegisterEnumExtension(&ExtendeeT::default_instance(), number,
+                                        type, true, is_packed, IsValid);
+  }
+};
+
+// -------------------------------------------------------------------
+// MessageTypeTraits
+
+// ExtensionSet guarantees that when manipulating extensions with message
+// types, the implementation used will be the compiled-in class representing
+// that type.  So, we can static_cast down to the exact type we expect.
+template <typename Type>
+class MessageTypeTraits {
+ public:
+  typedef const Type& ConstType;
+  typedef Type* MutableType;
+  typedef MessageTypeTraits<Type> Singular;
+
+  static inline ConstType Get(int number, const ExtensionSet& set,
+                              ConstType default_value) {
+    return static_cast<const Type&>(set.GetMessage(number, default_value));
+  }
+  static inline std::nullptr_t GetPtr(int /* number */,
+                                      const ExtensionSet& /* set */,
+                                      ConstType /* default_value */) {
+    // Cannot be implemented because of forward declared messages?
+    return nullptr;
+  }
+  static inline MutableType Mutable(int number, FieldType field_type,
+                                    ExtensionSet* set) {
+    return static_cast<Type*>(set->MutableMessage(
+        number, field_type, Type::default_instance(), nullptr));
+  }
+  static inline void SetAllocated(int number, FieldType field_type,
+                                  MutableType message, ExtensionSet* set) {
+    set->SetAllocatedMessage(number, field_type, nullptr, message);
+  }
+  static inline void UnsafeArenaSetAllocated(int number, FieldType field_type,
+                                             MutableType message,
+                                             ExtensionSet* set) {
+    set->UnsafeArenaSetAllocatedMessage(number, field_type, nullptr, message);
+  }
+  PROTOBUF_NODISCARD static inline MutableType Release(
+      int number, FieldType /* field_type */, ExtensionSet* set) {
+    return static_cast<Type*>(
+        set->ReleaseMessage(number, Type::default_instance()));
+  }
+  static inline MutableType UnsafeArenaRelease(int number,
+                                               FieldType /* field_type */,
+                                               ExtensionSet* set) {
+    return static_cast<Type*>(
+        set->UnsafeArenaReleaseMessage(number, Type::default_instance()));
+  }
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed,
+                       LazyEagerVerifyFnType fn) {
+    ExtensionSet::RegisterMessageExtension(&ExtendeeT::default_instance(),
+                                           number, type, false, is_packed,
+                                           &Type::default_instance(), fn);
+  }
+};
+
+// Used by WireFormatVerify to extract the verify function from the registry.
+LazyEagerVerifyFnType FindExtensionLazyEagerVerifyFn(
+    const MessageLite* extendee, int number);
+
+// forward declaration.
+class RepeatedMessageGenericTypeTraits;
+
+template <typename Type>
+class RepeatedMessageTypeTraits {
+ public:
+  typedef const Type& ConstType;
+  typedef Type* MutableType;
+  typedef RepeatedMessageTypeTraits<Type> Repeated;
+
+  typedef RepeatedPtrField<Type> RepeatedFieldType;
+
+  static inline ConstType Get(int number, const ExtensionSet& set, int index) {
+    return static_cast<const Type&>(set.GetRepeatedMessage(number, index));
+  }
+  static inline std::nullptr_t GetPtr(int /* number */,
+                                      const ExtensionSet& /* set */,
+                                      int /* index */) {
+    // Cannot be implemented because of forward declared messages?
+    return nullptr;
+  }
+  static inline std::nullptr_t GetRepeatedPtr(int /* number */,
+                                              const ExtensionSet& /* set */) {
+    // Cannot be implemented because of forward declared messages?
+    return nullptr;
+  }
+  static inline MutableType Mutable(int number, int index, ExtensionSet* set) {
+    return static_cast<Type*>(set->MutableRepeatedMessage(number, index));
+  }
+  static inline MutableType Add(int number, FieldType field_type,
+                                ExtensionSet* set) {
+    return static_cast<Type*>(
+        set->AddMessage(number, field_type, Type::default_instance(), nullptr));
+  }
+  static inline const RepeatedPtrField<Type>& GetRepeated(
+      int number, const ExtensionSet& set) {
+    // See notes above in RepeatedEnumTypeTraits::GetRepeated(): same
+    // casting hack applies here, because a RepeatedPtrField<MessageLite>
+    // cannot naturally become a RepeatedPtrType<Type> even though Type is
+    // presumably a message. google::protobuf::Message goes through similar contortions
+    // with a reinterpret_cast<>.
+    return *reinterpret_cast<const RepeatedPtrField<Type>*>(
+        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
+  }
+  static inline RepeatedPtrField<Type>* MutableRepeated(int number,
+                                                        FieldType field_type,
+                                                        bool is_packed,
+                                                        ExtensionSet* set) {
+    return reinterpret_cast<RepeatedPtrField<Type>*>(
+        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
+  }
+
+  static const RepeatedFieldType* GetDefaultRepeatedField();
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed,
+                       LazyEagerVerifyFnType fn) {
+    ExtensionSet::RegisterMessageExtension(&ExtendeeT::default_instance(),
+                                           number, type, true, is_packed,
+                                           &Type::default_instance(), fn);
+  }
+};
+
+template <typename Type>
+inline const typename RepeatedMessageTypeTraits<Type>::RepeatedFieldType*
+RepeatedMessageTypeTraits<Type>::GetDefaultRepeatedField() {
+  static auto instance = OnShutdownDelete(new RepeatedFieldType);
+  return instance;
+}
+
+// -------------------------------------------------------------------
+// ExtensionIdentifier
+
+// This is the type of actual extension objects.  E.g. if you have:
+//   extend Foo {
+//     optional int32 bar = 1234;
+//   }
+// then "bar" will be defined in C++ as:
+//   ExtensionIdentifier<Foo, PrimitiveTypeTraits<int32_t>, 5, false> bar(1234);
+//
+// Note that we could, in theory, supply the field number as a template
+// parameter, and thus make an instance of ExtensionIdentifier have no
+// actual contents.  However, if we did that, then using an extension
+// identifier would not necessarily cause the compiler to output any sort
+// of reference to any symbol defined in the extension's .pb.o file.  Some
+// linkers will actually drop object files that are not explicitly referenced,
+// but that would be bad because it would cause this extension to not be
+// registered at static initialization, and therefore using it would crash.
+
+template <typename ExtendeeType, typename TypeTraitsType, FieldType field_type,
+          bool is_packed>
+class ExtensionIdentifier {
+ public:
+  typedef TypeTraitsType TypeTraits;
+  typedef ExtendeeType Extendee;
+
+  ExtensionIdentifier(int number, typename TypeTraits::ConstType default_value,
+                      LazyEagerVerifyFnType verify_func = nullptr)
+      : number_(number), default_value_(default_value) {
+    Register(number, verify_func);
+  }
+  inline int number() const { return number_; }
+  typename TypeTraits::ConstType default_value() const {
+    return default_value_;
+  }
+
+  static void Register(int number, LazyEagerVerifyFnType verify_func) {
+    TypeTraits::template Register<ExtendeeType>(number, field_type, is_packed,
+                                                verify_func);
+  }
+
+  typename TypeTraits::ConstType const& default_value_ref() const {
+    return default_value_;
+  }
+
+ private:
+  const int number_;
+  typename TypeTraits::ConstType default_value_;
+};
+
+// -------------------------------------------------------------------
+// Generated accessors
+
+
+// Used to retrieve a lazy extension, may return nullptr in some environments.
+extern PROTOBUF_ATTRIBUTE_WEAK ExtensionSet::LazyMessageExtension*
+MaybeCreateLazyExtension(Arena* arena);
+
+}  // namespace internal
+
+// Call this function to ensure that this extensions's reflection is linked into
+// the binary:
+//
+//   google::protobuf::LinkExtensionReflection(Foo::my_extension);
+//
+// This will ensure that the following lookup will succeed:
+//
+//   DescriptorPool::generated_pool()->FindExtensionByName("Foo.my_extension");
+//
+// This is often relevant for parsing extensions in text mode.
+//
+// As a side-effect, it will also guarantee that anything else from the same
+// .proto file will also be available for lookup in the generated pool.
+//
+// This function does not actually register the extension, so it does not need
+// to be called before the lookup.  However it does need to occur in a function
+// that cannot be stripped from the binary (ie. it must be reachable from main).
+//
+// Best practice is to call this function as close as possible to where the
+// reflection is actually needed.  This function is very cheap to call, so you
+// should not need to worry about its runtime overhead except in tight loops (on
+// x86-64 it compiles into two "mov" instructions).
+template <typename ExtendeeType, typename TypeTraitsType,
+          internal::FieldType field_type, bool is_packed>
+void LinkExtensionReflection(
+    const google::protobuf::internal::ExtensionIdentifier<
+        ExtendeeType, TypeTraitsType, field_type, is_packed>& extension) {
+  internal::StrongReference(extension);
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_EXTENSION_SET_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/extension_set_inl.h b/CAPI/cpp/grpc/include/google/protobuf/extension_set_inl.h
new file mode 100644
index 0000000..e4e7117
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/extension_set_inl.h
@@ -0,0 +1,285 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_EXTENSION_SET_INL_H__
+#define GOOGLE_PROTOBUF_EXTENSION_SET_INL_H__
+
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/parse_context.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+template <typename T>
+const char* ExtensionSet::ParseFieldWithExtensionInfo(
+    int number, bool was_packed_on_wire, const ExtensionInfo& extension,
+    InternalMetadata* metadata, const char* ptr, internal::ParseContext* ctx) {
+  if (was_packed_on_wire) {
+    switch (extension.type) {
+#define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE)                                \
+  case WireFormatLite::TYPE_##UPPERCASE:                                     \
+    return internal::Packed##CPP_CAMELCASE##Parser(                          \
+        MutableRawRepeatedField(number, extension.type, extension.is_packed, \
+                                extension.descriptor),                       \
+        ptr, ctx);
+      HANDLE_TYPE(INT32, Int32);
+      HANDLE_TYPE(INT64, Int64);
+      HANDLE_TYPE(UINT32, UInt32);
+      HANDLE_TYPE(UINT64, UInt64);
+      HANDLE_TYPE(SINT32, SInt32);
+      HANDLE_TYPE(SINT64, SInt64);
+      HANDLE_TYPE(FIXED32, Fixed32);
+      HANDLE_TYPE(FIXED64, Fixed64);
+      HANDLE_TYPE(SFIXED32, SFixed32);
+      HANDLE_TYPE(SFIXED64, SFixed64);
+      HANDLE_TYPE(FLOAT, Float);
+      HANDLE_TYPE(DOUBLE, Double);
+      HANDLE_TYPE(BOOL, Bool);
+#undef HANDLE_TYPE
+
+      case WireFormatLite::TYPE_ENUM:
+        return internal::PackedEnumParserArg<T>(
+            MutableRawRepeatedField(number, extension.type, extension.is_packed,
+                                    extension.descriptor),
+            ptr, ctx, extension.enum_validity_check.func,
+            extension.enum_validity_check.arg, metadata, number);
+      case WireFormatLite::TYPE_STRING:
+      case WireFormatLite::TYPE_BYTES:
+      case WireFormatLite::TYPE_GROUP:
+      case WireFormatLite::TYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed.";
+        break;
+    }
+  } else {
+    switch (extension.type) {
+#define HANDLE_VARINT_TYPE(UPPERCASE, CPP_CAMELCASE)                        \
+  case WireFormatLite::TYPE_##UPPERCASE: {                                  \
+    uint64_t value;                                                         \
+    ptr = VarintParse(ptr, &value);                                         \
+    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);                                    \
+    if (extension.is_repeated) {                                            \
+      Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE,          \
+                         extension.is_packed, value, extension.descriptor); \
+    } else {                                                                \
+      Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value,   \
+                         extension.descriptor);                             \
+    }                                                                       \
+  } break
+
+      HANDLE_VARINT_TYPE(INT32, Int32);
+      HANDLE_VARINT_TYPE(INT64, Int64);
+      HANDLE_VARINT_TYPE(UINT32, UInt32);
+      HANDLE_VARINT_TYPE(UINT64, UInt64);
+      HANDLE_VARINT_TYPE(BOOL, Bool);
+#undef HANDLE_VARINT_TYPE
+#define HANDLE_SVARINT_TYPE(UPPERCASE, CPP_CAMELCASE, SIZE)                 \
+  case WireFormatLite::TYPE_##UPPERCASE: {                                  \
+    uint64_t val;                                                           \
+    ptr = VarintParse(ptr, &val);                                           \
+    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);                                    \
+    auto value = WireFormatLite::ZigZagDecode##SIZE(val);                   \
+    if (extension.is_repeated) {                                            \
+      Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE,          \
+                         extension.is_packed, value, extension.descriptor); \
+    } else {                                                                \
+      Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value,   \
+                         extension.descriptor);                             \
+    }                                                                       \
+  } break
+
+      HANDLE_SVARINT_TYPE(SINT32, Int32, 32);
+      HANDLE_SVARINT_TYPE(SINT64, Int64, 64);
+#undef HANDLE_SVARINT_TYPE
+#define HANDLE_FIXED_TYPE(UPPERCASE, CPP_CAMELCASE, CPPTYPE)                \
+  case WireFormatLite::TYPE_##UPPERCASE: {                                  \
+    auto value = UnalignedLoad<CPPTYPE>(ptr);                               \
+    ptr += sizeof(CPPTYPE);                                                 \
+    if (extension.is_repeated) {                                            \
+      Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE,          \
+                         extension.is_packed, value, extension.descriptor); \
+    } else {                                                                \
+      Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value,   \
+                         extension.descriptor);                             \
+    }                                                                       \
+  } break
+
+      HANDLE_FIXED_TYPE(FIXED32, UInt32, uint32_t);
+      HANDLE_FIXED_TYPE(FIXED64, UInt64, uint64_t);
+      HANDLE_FIXED_TYPE(SFIXED32, Int32, int32_t);
+      HANDLE_FIXED_TYPE(SFIXED64, Int64, int64_t);
+      HANDLE_FIXED_TYPE(FLOAT, Float, float);
+      HANDLE_FIXED_TYPE(DOUBLE, Double, double);
+#undef HANDLE_FIXED_TYPE
+
+      case WireFormatLite::TYPE_ENUM: {
+        uint64_t val;
+        ptr = VarintParse(ptr, &val);
+        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+        int value = val;
+
+        if (!extension.enum_validity_check.func(
+                extension.enum_validity_check.arg, value)) {
+          WriteVarint(number, val, metadata->mutable_unknown_fields<T>());
+        } else if (extension.is_repeated) {
+          AddEnum(number, WireFormatLite::TYPE_ENUM, extension.is_packed, value,
+                  extension.descriptor);
+        } else {
+          SetEnum(number, WireFormatLite::TYPE_ENUM, value,
+                  extension.descriptor);
+        }
+        break;
+      }
+
+      case WireFormatLite::TYPE_BYTES:
+      case WireFormatLite::TYPE_STRING: {
+        std::string* value =
+            extension.is_repeated
+                ? AddString(number, WireFormatLite::TYPE_STRING,
+                            extension.descriptor)
+                : MutableString(number, WireFormatLite::TYPE_STRING,
+                                extension.descriptor);
+        int size = ReadSize(&ptr);
+        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+        return ctx->ReadString(ptr, size, value);
+      }
+
+      case WireFormatLite::TYPE_GROUP: {
+        MessageLite* value =
+            extension.is_repeated
+                ? AddMessage(number, WireFormatLite::TYPE_GROUP,
+                             *extension.message_info.prototype,
+                             extension.descriptor)
+                : MutableMessage(number, WireFormatLite::TYPE_GROUP,
+                                 *extension.message_info.prototype,
+                                 extension.descriptor);
+        uint32_t tag = (number << 3) + WireFormatLite::WIRETYPE_START_GROUP;
+        return ctx->ParseGroup(value, ptr, tag);
+      }
+
+      case WireFormatLite::TYPE_MESSAGE: {
+        MessageLite* value =
+            extension.is_repeated
+                ? AddMessage(number, WireFormatLite::TYPE_MESSAGE,
+                             *extension.message_info.prototype,
+                             extension.descriptor)
+                : MutableMessage(number, WireFormatLite::TYPE_MESSAGE,
+                                 *extension.message_info.prototype,
+                                 extension.descriptor);
+        return ctx->ParseMessage(value, ptr);
+      }
+    }
+  }
+  return ptr;
+}
+
+template <typename Msg, typename T>
+const char* ExtensionSet::ParseMessageSetItemTmpl(
+    const char* ptr, const Msg* extendee, internal::InternalMetadata* metadata,
+    internal::ParseContext* ctx) {
+  std::string payload;
+  uint32_t type_id;
+  enum class State { kNoTag, kHasType, kHasPayload, kDone };
+  State state = State::kNoTag;
+
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag = static_cast<uint8_t>(*ptr++);
+    if (tag == WireFormatLite::kMessageSetTypeIdTag) {
+      uint64_t tmp;
+      ptr = ParseBigVarint(ptr, &tmp);
+      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+      if (state == State::kNoTag) {
+        type_id = tmp;
+        state = State::kHasType;
+      } else if (state == State::kHasPayload) {
+        type_id = tmp;
+        ExtensionInfo extension;
+        bool was_packed_on_wire;
+        if (!FindExtension(2, type_id, extendee, ctx, &extension,
+                           &was_packed_on_wire)) {
+          WriteLengthDelimited(type_id, payload,
+                               metadata->mutable_unknown_fields<T>());
+        } else {
+          MessageLite* value =
+              extension.is_repeated
+                  ? AddMessage(type_id, WireFormatLite::TYPE_MESSAGE,
+                               *extension.message_info.prototype,
+                               extension.descriptor)
+                  : MutableMessage(type_id, WireFormatLite::TYPE_MESSAGE,
+                                   *extension.message_info.prototype,
+                                   extension.descriptor);
+
+          const char* p;
+          // We can't use regular parse from string as we have to track
+          // proper recursion depth and descriptor pools.
+          ParseContext tmp_ctx(ctx->depth(), false, &p, payload);
+          tmp_ctx.data().pool = ctx->data().pool;
+          tmp_ctx.data().factory = ctx->data().factory;
+          GOOGLE_PROTOBUF_PARSER_ASSERT(value->_InternalParse(p, &tmp_ctx) &&
+                                         tmp_ctx.EndedAtLimit());
+        }
+        state = State::kDone;
+      }
+    } else if (tag == WireFormatLite::kMessageSetMessageTag) {
+      if (state == State::kHasType) {
+        ptr = ParseFieldMaybeLazily(static_cast<uint64_t>(type_id) * 8 + 2, ptr,
+                                    extendee, metadata, ctx);
+        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+        state = State::kDone;
+      } else {
+        std::string tmp;
+        int32_t size = ReadSize(&ptr);
+        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+        ptr = ctx->ReadString(ptr, size, &tmp);
+        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+        if (state == State::kNoTag) {
+          payload = std::move(tmp);
+          state = State::kHasPayload;
+        }
+      }
+    } else {
+      ptr = ReadTag(ptr - 1, &tag);
+      if (tag == 0 || (tag & 7) == 4) {
+        ctx->SetLastTag(tag);
+        return ptr;
+      }
+      ptr = ParseField(tag, ptr, extendee, metadata, ctx);
+      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+    }
+  }
+  return ptr;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_EXTENSION_SET_INL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/field_access_listener.h b/CAPI/cpp/grpc/include/google/protobuf/field_access_listener.h
new file mode 100644
index 0000000..47422e6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/field_access_listener.h
@@ -0,0 +1,172 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_FIELD_ACCESS_LISTENER_H__
+#define GOOGLE_PROTOBUF_FIELD_ACCESS_LISTENER_H__
+
+#include <cstddef>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/message_lite.h>
+
+
+namespace google {
+namespace protobuf {
+
+// A default/no-op implementation of message hooks.
+//
+// See go/statically-dispatched-message-hooks for details.
+template <typename Proto>
+struct NoOpAccessListener {
+  // Number of fields are provided at compile time for the trackers to be able
+  // to have stack allocated bitmaps for the fields. This is useful for
+  // performance critical trackers. This is also to avoid cyclic dependencies
+  // if the number of fields is needed.
+  static constexpr int kFields = Proto::_kInternalFieldNumber;
+  // Default constructor is called during the static global initialization of
+  // the program.
+  // We provide a pointer to extract the name of the proto not to get cyclic
+  // dependencies on GetDescriptor() and OnGetMetadata() calls. If you want
+  // to differentiate the protos during the runtime before the start of the
+  // program, use this functor to get its name. We either way need it for
+  // LITE_RUNTIME protos as they don't have descriptors at all.
+  explicit NoOpAccessListener(StringPiece (*name_extractor)()) {}
+  // called repeatedly during serialization/deserialization/ByteSize of
+  // Reflection as:
+  //   AccessListener<MessageT>::OnSerialize(this);
+  static void OnSerialize(const MessageLite* msg) {}
+  static void OnDeserialize(const MessageLite* msg) {}
+  static void OnByteSize(const MessageLite* msg) {}
+  static void OnMergeFrom(const MessageLite* to, const MessageLite* from) {}
+
+  // NOTE: This function can be called pre-main. Make sure it does not make
+  // the state of the listener invalid.
+  static void OnGetMetadata() {}
+
+  // called from accessors as:
+  //   AccessListener<MessageT>::On$operation(this, &field_storage_);
+  // If you need to override this with type, in your hook implementation
+  // introduce
+  // template <int kFieldNum, typename T>
+  // static void On$operation(const MessageLite* msg,
+  //                          const T* field) {}
+  // And overloads for std::nullptr_t for incomplete types such as Messages,
+  // Maps. Extract them using reflection if you need. Consequently, second
+  // argument can be null pointer.
+  // For an example, see proto_hooks/testing/memory_test_field_listener.h
+  // And argument template deduction will deduce the type itself without
+  // changing the generated code.
+
+  // add_<field>(f)
+  template <int kFieldNum>
+  static void OnAdd(const MessageLite* msg, const void* field) {}
+
+  // add_<field>()
+  template <int kFieldNum>
+  static void OnAddMutable(const MessageLite* msg, const void* field) {}
+
+  // <field>() and <repeated_field>(i)
+  template <int kFieldNum>
+  static void OnGet(const MessageLite* msg, const void* field) {}
+
+  // clear_<field>()
+  template <int kFieldNum>
+  static void OnClear(const MessageLite* msg, const void* field) {}
+
+  // has_<field>()
+  template <int kFieldNum>
+  static void OnHas(const MessageLite* msg, const void* field) {}
+
+  // <repeated_field>()
+  template <int kFieldNum>
+  static void OnList(const MessageLite* msg, const void* field) {}
+
+  // mutable_<field>()
+  template <int kFieldNum>
+  static void OnMutable(const MessageLite* msg, const void* field) {}
+
+  // mutable_<repeated_field>()
+  template <int kFieldNum>
+  static void OnMutableList(const MessageLite* msg, const void* field) {}
+
+  // release_<field>()
+  template <int kFieldNum>
+  static void OnRelease(const MessageLite* msg, const void* field) {}
+
+  // set_<field>() and set_<repeated_field>(i)
+  template <int kFieldNum>
+  static void OnSet(const MessageLite* msg, const void* field) {}
+
+  // <repeated_field>_size()
+  template <int kFieldNum>
+  static void OnSize(const MessageLite* msg, const void* field) {}
+
+  static void OnHasExtension(const MessageLite* msg, int extension_tag,
+                             const void* field) {}
+  // TODO(b/190614678): Support clear in the proto compiler.
+  static void OnClearExtension(const MessageLite* msg, int extension_tag,
+                               const void* field) {}
+  static void OnExtensionSize(const MessageLite* msg, int extension_tag,
+                              const void* field) {}
+  static void OnGetExtension(const MessageLite* msg, int extension_tag,
+                             const void* field) {}
+  static void OnMutableExtension(const MessageLite* msg, int extension_tag,
+                                 const void* field) {}
+  static void OnSetExtension(const MessageLite* msg, int extension_tag,
+                             const void* field) {}
+  static void OnReleaseExtension(const MessageLite* msg, int extension_tag,
+                                 const void* field) {}
+  static void OnAddExtension(const MessageLite* msg, int extension_tag,
+                             const void* field) {}
+  static void OnAddMutableExtension(const MessageLite* msg, int extension_tag,
+                                    const void* field) {}
+  static void OnListExtension(const MessageLite* msg, int extension_tag,
+                              const void* field) {}
+  static void OnMutableListExtension(const MessageLite* msg, int extension_tag,
+                                     const void* field) {}
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#ifndef REPLACE_PROTO_LISTENER_IMPL
+namespace google {
+namespace protobuf {
+template <class T>
+using AccessListener = NoOpAccessListener<T>;
+}  // namespace protobuf
+}  // namespace google
+#else
+// You can put your implementations of hooks/listeners here.
+// All hooks are subject to approval by protobuf-team@.
+
+#endif  // !REPLACE_PROTO_LISTENER_IMPL
+
+#endif  // GOOGLE_PROTOBUF_FIELD_ACCESS_LISTENER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/field_mask.pb.h b/CAPI/cpp/grpc/include/google/protobuf/field_mask.pb.h
new file mode 100644
index 0000000..ecc6ede
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/field_mask.pb.h
@@ -0,0 +1,317 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/field_mask.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ffield_5fmask_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ffield_5fmask_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2ffield_5fmask_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ffield_5fmask_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class FieldMask;
+struct FieldMaskDefaultTypeInternal;
+PROTOBUF_EXPORT extern FieldMaskDefaultTypeInternal _FieldMask_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldMask* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldMask>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+// ===================================================================
+
+class PROTOBUF_EXPORT FieldMask final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldMask) */ {
+ public:
+  inline FieldMask() : FieldMask(nullptr) {}
+  ~FieldMask() override;
+  explicit PROTOBUF_CONSTEXPR FieldMask(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FieldMask(const FieldMask& from);
+  FieldMask(FieldMask&& from) noexcept
+    : FieldMask() {
+    *this = ::std::move(from);
+  }
+
+  inline FieldMask& operator=(const FieldMask& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FieldMask& operator=(FieldMask&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FieldMask& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FieldMask* internal_default_instance() {
+    return reinterpret_cast<const FieldMask*>(
+               &_FieldMask_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(FieldMask& a, FieldMask& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FieldMask* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FieldMask* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FieldMask* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FieldMask>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FieldMask& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FieldMask& from) {
+    FieldMask::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FieldMask* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.FieldMask";
+  }
+  protected:
+  explicit FieldMask(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPathsFieldNumber = 1,
+  };
+  // repeated string paths = 1;
+  int paths_size() const;
+  private:
+  int _internal_paths_size() const;
+  public:
+  void clear_paths();
+  const std::string& paths(int index) const;
+  std::string* mutable_paths(int index);
+  void set_paths(int index, const std::string& value);
+  void set_paths(int index, std::string&& value);
+  void set_paths(int index, const char* value);
+  void set_paths(int index, const char* value, size_t size);
+  std::string* add_paths();
+  void add_paths(const std::string& value);
+  void add_paths(std::string&& value);
+  void add_paths(const char* value);
+  void add_paths(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& paths() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_paths();
+  private:
+  const std::string& _internal_paths(int index) const;
+  std::string* _internal_add_paths();
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FieldMask)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> paths_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// FieldMask
+
+// repeated string paths = 1;
+inline int FieldMask::_internal_paths_size() const {
+  return _impl_.paths_.size();
+}
+inline int FieldMask::paths_size() const {
+  return _internal_paths_size();
+}
+inline void FieldMask::clear_paths() {
+  _impl_.paths_.Clear();
+}
+inline std::string* FieldMask::add_paths() {
+  std::string* _s = _internal_add_paths();
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.FieldMask.paths)
+  return _s;
+}
+inline const std::string& FieldMask::_internal_paths(int index) const {
+  return _impl_.paths_.Get(index);
+}
+inline const std::string& FieldMask::paths(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldMask.paths)
+  return _internal_paths(index);
+}
+inline std::string* FieldMask::mutable_paths(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldMask.paths)
+  return _impl_.paths_.Mutable(index);
+}
+inline void FieldMask::set_paths(int index, const std::string& value) {
+  _impl_.paths_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldMask.paths)
+}
+inline void FieldMask::set_paths(int index, std::string&& value) {
+  _impl_.paths_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldMask.paths)
+}
+inline void FieldMask::set_paths(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.paths_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FieldMask.paths)
+}
+inline void FieldMask::set_paths(int index, const char* value, size_t size) {
+  _impl_.paths_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldMask.paths)
+}
+inline std::string* FieldMask::_internal_add_paths() {
+  return _impl_.paths_.Add();
+}
+inline void FieldMask::add_paths(const std::string& value) {
+  _impl_.paths_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.FieldMask.paths)
+}
+inline void FieldMask::add_paths(std::string&& value) {
+  _impl_.paths_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.FieldMask.paths)
+}
+inline void FieldMask::add_paths(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.paths_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.FieldMask.paths)
+}
+inline void FieldMask::add_paths(const char* value, size_t size) {
+  _impl_.paths_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.FieldMask.paths)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+FieldMask::paths() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FieldMask.paths)
+  return _impl_.paths_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+FieldMask::mutable_paths() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldMask.paths)
+  return &_impl_.paths_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ffield_5fmask_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/field_mask.proto b/CAPI/cpp/grpc/include/google/protobuf/field_mask.proto
new file mode 100644
index 0000000..6b5104f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/field_mask.proto
@@ -0,0 +1,245 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "FieldMaskProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+option go_package = "google.golang.org/protobuf/types/known/fieldmaskpb";
+option cc_enable_arenas = true;
+
+// `FieldMask` represents a set of symbolic field paths, for example:
+//
+//     paths: "f.a"
+//     paths: "f.b.d"
+//
+// Here `f` represents a field in some root message, `a` and `b`
+// fields in the message found in `f`, and `d` a field found in the
+// message in `f.b`.
+//
+// Field masks are used to specify a subset of fields that should be
+// returned by a get operation or modified by an update operation.
+// Field masks also have a custom JSON encoding (see below).
+//
+// # Field Masks in Projections
+//
+// When used in the context of a projection, a response message or
+// sub-message is filtered by the API to only contain those fields as
+// specified in the mask. For example, if the mask in the previous
+// example is applied to a response message as follows:
+//
+//     f {
+//       a : 22
+//       b {
+//         d : 1
+//         x : 2
+//       }
+//       y : 13
+//     }
+//     z: 8
+//
+// The result will not contain specific values for fields x,y and z
+// (their value will be set to the default, and omitted in proto text
+// output):
+//
+//
+//     f {
+//       a : 22
+//       b {
+//         d : 1
+//       }
+//     }
+//
+// A repeated field is not allowed except at the last position of a
+// paths string.
+//
+// If a FieldMask object is not present in a get operation, the
+// operation applies to all fields (as if a FieldMask of all fields
+// had been specified).
+//
+// Note that a field mask does not necessarily apply to the
+// top-level response message. In case of a REST get operation, the
+// field mask applies directly to the response, but in case of a REST
+// list operation, the mask instead applies to each individual message
+// in the returned resource list. In case of a REST custom method,
+// other definitions may be used. Where the mask applies will be
+// clearly documented together with its declaration in the API.  In
+// any case, the effect on the returned resource/resources is required
+// behavior for APIs.
+//
+// # Field Masks in Update Operations
+//
+// A field mask in update operations specifies which fields of the
+// targeted resource are going to be updated. The API is required
+// to only change the values of the fields as specified in the mask
+// and leave the others untouched. If a resource is passed in to
+// describe the updated values, the API ignores the values of all
+// fields not covered by the mask.
+//
+// If a repeated field is specified for an update operation, new values will
+// be appended to the existing repeated field in the target resource. Note that
+// a repeated field is only allowed in the last position of a `paths` string.
+//
+// If a sub-message is specified in the last position of the field mask for an
+// update operation, then new value will be merged into the existing sub-message
+// in the target resource.
+//
+// For example, given the target message:
+//
+//     f {
+//       b {
+//         d: 1
+//         x: 2
+//       }
+//       c: [1]
+//     }
+//
+// And an update message:
+//
+//     f {
+//       b {
+//         d: 10
+//       }
+//       c: [2]
+//     }
+//
+// then if the field mask is:
+//
+//  paths: ["f.b", "f.c"]
+//
+// then the result will be:
+//
+//     f {
+//       b {
+//         d: 10
+//         x: 2
+//       }
+//       c: [1, 2]
+//     }
+//
+// An implementation may provide options to override this default behavior for
+// repeated and message fields.
+//
+// In order to reset a field's value to the default, the field must
+// be in the mask and set to the default value in the provided resource.
+// Hence, in order to reset all fields of a resource, provide a default
+// instance of the resource and set all fields in the mask, or do
+// not provide a mask as described below.
+//
+// If a field mask is not present on update, the operation applies to
+// all fields (as if a field mask of all fields has been specified).
+// Note that in the presence of schema evolution, this may mean that
+// fields the client does not know and has therefore not filled into
+// the request will be reset to their default. If this is unwanted
+// behavior, a specific service may require a client to always specify
+// a field mask, producing an error if not.
+//
+// As with get operations, the location of the resource which
+// describes the updated values in the request message depends on the
+// operation kind. In any case, the effect of the field mask is
+// required to be honored by the API.
+//
+// ## Considerations for HTTP REST
+//
+// The HTTP kind of an update operation which uses a field mask must
+// be set to PATCH instead of PUT in order to satisfy HTTP semantics
+// (PUT must only be used for full updates).
+//
+// # JSON Encoding of Field Masks
+//
+// In JSON, a field mask is encoded as a single string where paths are
+// separated by a comma. Fields name in each path are converted
+// to/from lower-camel naming conventions.
+//
+// As an example, consider the following message declarations:
+//
+//     message Profile {
+//       User user = 1;
+//       Photo photo = 2;
+//     }
+//     message User {
+//       string display_name = 1;
+//       string address = 2;
+//     }
+//
+// In proto a field mask for `Profile` may look as such:
+//
+//     mask {
+//       paths: "user.display_name"
+//       paths: "photo"
+//     }
+//
+// In JSON, the same mask is represented as below:
+//
+//     {
+//       mask: "user.displayName,photo"
+//     }
+//
+// # Field Masks and Oneof Fields
+//
+// Field masks treat fields in oneofs just as regular fields. Consider the
+// following message:
+//
+//     message SampleMessage {
+//       oneof test_oneof {
+//         string name = 4;
+//         SubMessage sub_message = 9;
+//       }
+//     }
+//
+// The field mask can be:
+//
+//     mask {
+//       paths: "name"
+//     }
+//
+// Or:
+//
+//     mask {
+//       paths: "sub_message"
+//     }
+//
+// Note that oneof type names ("test_oneof" in this case) cannot be used in
+// paths.
+//
+// ## Field Mask Verification
+//
+// The implementation of any API method which has a FieldMask type field in the
+// request should verify the included field paths, and return an
+// `INVALID_ARGUMENT` error if any path is unmappable.
+message FieldMask {
+  // The set of field mask paths.
+  repeated string paths = 1;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_enum_reflection.h b/CAPI/cpp/grpc/include/google/protobuf/generated_enum_reflection.h
new file mode 100644
index 0000000..b96a9c6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_enum_reflection.h
@@ -0,0 +1,100 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: jasonh@google.com (Jason Hsueh)
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+// It provides reflection support for generated enums, and is included in
+// generated .pb.h files and should have minimal dependencies. The methods are
+// implemented in generated_message_reflection.cc.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_ENUM_REFLECTION_H__
+#define GOOGLE_PROTOBUF_GENERATED_ENUM_REFLECTION_H__
+
+
+#include <string>
+
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/generated_enum_util.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+class EnumDescriptor;
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+
+// Returns the EnumDescriptor for enum type E, which must be a
+// proto-declared enum type.  Code generated by the protocol compiler
+// will include specializations of this template for each enum type declared.
+template <typename E>
+const EnumDescriptor* GetEnumDescriptor();
+
+namespace internal {
+
+// Helper for EnumType_Parse functions: try to parse the string 'name' as
+// an enum name of the given type, returning true and filling in value on
+// success, or returning false and leaving value unchanged on failure.
+PROTOBUF_EXPORT bool ParseNamedEnum(const EnumDescriptor* descriptor,
+                                    ConstStringParam name, int* value);
+
+template <typename EnumType>
+bool ParseNamedEnum(const EnumDescriptor* descriptor, ConstStringParam name,
+                    EnumType* value) {
+  int tmp;
+  if (!ParseNamedEnum(descriptor, name, &tmp)) return false;
+  *value = static_cast<EnumType>(tmp);
+  return true;
+}
+
+// Just a wrapper around printing the name of a value. The main point of this
+// function is not to be inlined, so that you can do this without including
+// descriptor.h.
+PROTOBUF_EXPORT const std::string& NameOfEnum(const EnumDescriptor* descriptor,
+                                              int value);
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_GENERATED_ENUM_REFLECTION_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_enum_util.h b/CAPI/cpp/grpc/include/google/protobuf/generated_enum_util.h
new file mode 100644
index 0000000..5d10ac0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_enum_util.h
@@ -0,0 +1,85 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_ENUM_UTIL_H__
+#define GOOGLE_PROTOBUF_GENERATED_ENUM_UTIL_H__
+
+
+#include <type_traits>
+
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/message_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+// This type trait can be used to cause templates to only match proto2 enum
+// types.
+template <typename T>
+struct is_proto_enum : ::std::false_type {};
+
+namespace internal {
+
+// The table entry format for storing enum name-to-value mapping used with lite
+// protos. This struct and the following related functions should only be used
+// by protobuf generated code.
+struct EnumEntry {
+  StringPiece name;
+  int value;
+};
+
+// Looks up a numeric enum value given the string name.
+PROTOBUF_EXPORT bool LookUpEnumValue(const EnumEntry* enums, size_t size,
+                                     StringPiece name, int* value);
+
+// Looks up an enum name given the numeric value.
+PROTOBUF_EXPORT int LookUpEnumName(const EnumEntry* enums,
+                                   const int* sorted_indices, size_t size,
+                                   int value);
+
+// Initializes the list of enum names in std::string form.
+PROTOBUF_EXPORT bool InitializeEnumStrings(
+    const EnumEntry* enums, const int* sorted_indices, size_t size,
+    internal::ExplicitlyConstructed<std::string>* enum_strings);
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_GENERATED_ENUM_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_bases.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_bases.h
new file mode 100644
index 0000000..b295218
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_bases.h
@@ -0,0 +1,87 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file contains helpers for generated code.
+//
+//  Nothing in this file should be directly referenced by users of protobufs.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_BASES_H__
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_BASES_H__
+
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/parse_context.h>
+
+// Must come last:
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// To save code size, protos without any fields are derived from ZeroFieldsBase
+// rather than Message.
+class PROTOBUF_EXPORT ZeroFieldsBase : public Message {
+ public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final { return true; }
+  size_t ByteSizeLong() const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+  const char* _InternalParse(const char* ptr,
+                             internal::ParseContext* ctx) final;
+  ::uint8_t* _InternalSerialize(::uint8_t* target,
+                                io::EpsCopyOutputStream* stream) const final;
+
+ protected:
+  constexpr ZeroFieldsBase() {}
+  explicit ZeroFieldsBase(Arena* arena, bool is_message_owned)
+      : Message(arena, is_message_owned) {}
+  ZeroFieldsBase(const ZeroFieldsBase&) = delete;
+  ZeroFieldsBase& operator=(const ZeroFieldsBase&) = delete;
+  ~ZeroFieldsBase() override;
+
+  void SetCachedSize(int size) const final { _cached_size_.Set(size); }
+
+  static void MergeImpl(Message& to, const Message& from);
+  static void CopyImpl(Message& to, const Message& from);
+  void InternalSwap(ZeroFieldsBase* other);
+
+  mutable internal::CachedSize _cached_size_;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_BASES_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_reflection.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_reflection.h
new file mode 100644
index 0000000..334b2cc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_reflection.h
@@ -0,0 +1,354 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
+
+#include <google/protobuf/stubs/casts.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+class MapKey;
+class MapValueRef;
+class MessageLayoutInspector;
+class Message;
+struct Metadata;
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+namespace internal {
+class DefaultEmptyOneof;
+// Defined in other files.
+class ExtensionSet;  // extension_set.h
+class WeakFieldMap;  // weak_field_map.h
+
+// This struct describes the internal layout of the message, hence this is
+// used to act on the message reflectively.
+//   default_instance:  The default instance of the message.  This is only
+//                  used to obtain pointers to default instances of embedded
+//                  messages, which GetMessage() will return if the particular
+//                  sub-message has not been initialized yet.  (Thus, all
+//                  embedded message fields *must* have non-null pointers
+//                  in the default instance.)
+//   offsets:       An array of ints giving the byte offsets.
+//                  For each oneof or weak field, the offset is relative to the
+//                  default_instance. These can be computed at compile time
+//                  using the
+//                  PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET()
+//                  macro. For each none oneof field, the offset is related to
+//                  the start of the message object.  These can be computed at
+//                  compile time using the
+//                  PROTO2_GENERATED_MESSAGE_FIELD_OFFSET() macro.
+//                  Besides offsets for all fields, this array also contains
+//                  offsets for oneof unions. The offset of the i-th oneof union
+//                  is offsets[descriptor->field_count() + i].
+//   has_bit_indices:  Mapping from field indexes to their index in the has
+//                  bit array.
+//   has_bits_offset:  Offset in the message of an array of uint32s of size
+//                  descriptor->field_count()/32, rounded up.  This is a
+//                  bitfield where each bit indicates whether or not the
+//                  corresponding field of the message has been initialized.
+//                  The bit for field index i is obtained by the expression:
+//                    has_bits[i / 32] & (1 << (i % 32))
+//   unknown_fields_offset:  Offset in the message of the UnknownFieldSet for
+//                  the message.
+//   extensions_offset:  Offset in the message of the ExtensionSet for the
+//                  message, or -1 if the message type has no extension
+//                  ranges.
+//   oneof_case_offset:  Offset in the message of an array of uint32s of
+//                  size descriptor->oneof_decl_count().  Each uint32_t
+//                  indicates what field is set for each oneof.
+//   object_size:   The size of a message object of this type, as measured
+//                  by sizeof().
+//   arena_offset:  If a message doesn't have a unknown_field_set that stores
+//                  the arena, it must have a direct pointer to the arena.
+//   weak_field_map_offset: If the message proto has weak fields, this is the
+//                  offset of _weak_field_map_ in the generated proto. Otherwise
+//                  -1.
+struct ReflectionSchema {
+ public:
+  // Size of a google::protobuf::Message object of this type.
+  uint32_t GetObjectSize() const { return static_cast<uint32_t>(object_size_); }
+
+  bool InRealOneof(const FieldDescriptor* field) const {
+    return field->containing_oneof() &&
+           !field->containing_oneof()->is_synthetic();
+  }
+
+  // Offset of a non-oneof field.  Getting a field offset is slightly more
+  // efficient when we know statically that it is not a oneof field.
+  uint32_t GetFieldOffsetNonOneof(const FieldDescriptor* field) const {
+    GOOGLE_DCHECK(!InRealOneof(field));
+    return OffsetValue(offsets_[field->index()], field->type());
+  }
+
+  // Offset of any field.
+  uint32_t GetFieldOffset(const FieldDescriptor* field) const {
+    if (InRealOneof(field)) {
+      size_t offset =
+          static_cast<size_t>(field->containing_type()->field_count()) +
+          field->containing_oneof()->index();
+      return OffsetValue(offsets_[offset], field->type());
+    } else {
+      return GetFieldOffsetNonOneof(field);
+    }
+  }
+
+  bool IsFieldInlined(const FieldDescriptor* field) const {
+    return Inlined(offsets_[field->index()], field->type());
+  }
+
+  uint32_t GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const {
+    return static_cast<uint32_t>(oneof_case_offset_) +
+           static_cast<uint32_t>(
+               static_cast<size_t>(oneof_descriptor->index()) *
+               sizeof(uint32_t));
+  }
+
+  bool HasHasbits() const { return has_bits_offset_ != -1; }
+
+  // Bit index within the bit array of hasbits.  Bit order is low-to-high.
+  uint32_t HasBitIndex(const FieldDescriptor* field) const {
+    if (has_bits_offset_ == -1) return static_cast<uint32_t>(-1);
+    GOOGLE_DCHECK(HasHasbits());
+    return has_bit_indices_[field->index()];
+  }
+
+  // Byte offset of the hasbits array.
+  uint32_t HasBitsOffset() const {
+    GOOGLE_DCHECK(HasHasbits());
+    return static_cast<uint32_t>(has_bits_offset_);
+  }
+
+  bool HasInlinedString() const { return inlined_string_donated_offset_ != -1; }
+
+  // Bit index within the bit array of _inlined_string_donated_.  Bit order is
+  // low-to-high.
+  uint32_t InlinedStringIndex(const FieldDescriptor* field) const {
+    GOOGLE_DCHECK(HasInlinedString());
+    return inlined_string_indices_[field->index()];
+  }
+
+  // Byte offset of the _inlined_string_donated_ array.
+  uint32_t InlinedStringDonatedOffset() const {
+    GOOGLE_DCHECK(HasInlinedString());
+    return static_cast<uint32_t>(inlined_string_donated_offset_);
+  }
+
+  // The offset of the InternalMetadataWithArena member.
+  // For Lite this will actually be an InternalMetadataWithArenaLite.
+  // The schema doesn't contain enough information to distinguish between
+  // these two cases.
+  uint32_t GetMetadataOffset() const {
+    return static_cast<uint32_t>(metadata_offset_);
+  }
+
+  // Whether this message has an ExtensionSet.
+  bool HasExtensionSet() const { return extensions_offset_ != -1; }
+
+  // The offset of the ExtensionSet in this message.
+  uint32_t GetExtensionSetOffset() const {
+    GOOGLE_DCHECK(HasExtensionSet());
+    return static_cast<uint32_t>(extensions_offset_);
+  }
+
+  // The off set of WeakFieldMap when the message contains weak fields.
+  // The default is 0 for now.
+  int GetWeakFieldMapOffset() const { return weak_field_map_offset_; }
+
+  bool IsDefaultInstance(const Message& message) const {
+    return &message == default_instance_;
+  }
+
+  // Returns a pointer to the default value for this field.  The size and type
+  // of the underlying data depends on the field's type.
+  const void* GetFieldDefault(const FieldDescriptor* field) const {
+    return reinterpret_cast<const uint8_t*>(default_instance_) +
+           OffsetValue(offsets_[field->index()], field->type());
+  }
+
+  // Returns true if the field is implicitly backed by LazyField.
+  bool IsEagerlyVerifiedLazyField(const FieldDescriptor* field) const {
+    GOOGLE_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_MESSAGE);
+    (void)field;
+    return false;
+  }
+
+  bool IsFieldStripped(const FieldDescriptor* field) const {
+    (void)field;
+    return false;
+  }
+
+  bool IsMessageStripped(const Descriptor* descriptor) const {
+    (void)descriptor;
+    return false;
+  }
+
+
+  bool HasWeakFields() const { return weak_field_map_offset_ > 0; }
+
+  // These members are intended to be private, but we cannot actually make them
+  // private because this prevents us from using aggregate initialization of
+  // them, ie.
+  //
+  //   ReflectionSchema schema = {a, b, c, d, e, ...};
+  // private:
+  const Message* default_instance_;
+  const uint32_t* offsets_;
+  const uint32_t* has_bit_indices_;
+  int has_bits_offset_;
+  int metadata_offset_;
+  int extensions_offset_;
+  int oneof_case_offset_;
+  int object_size_;
+  int weak_field_map_offset_;
+  const uint32_t* inlined_string_indices_;
+  int inlined_string_donated_offset_;
+
+  // We tag offset values to provide additional data about fields (such as
+  // "unused" or "lazy" or "inlined").
+  static uint32_t OffsetValue(uint32_t v, FieldDescriptor::Type type) {
+    if (type == FieldDescriptor::TYPE_MESSAGE ||
+        type == FieldDescriptor::TYPE_STRING ||
+        type == FieldDescriptor::TYPE_BYTES) {
+      return v & 0xFFFFFFFEu;
+    }
+    return v;
+  }
+
+  static bool Inlined(uint32_t v, FieldDescriptor::Type type) {
+    if (type == FieldDescriptor::TYPE_STRING ||
+        type == FieldDescriptor::TYPE_BYTES) {
+      return (v & 1u) != 0u;
+    } else {
+      // Non string/byte fields are not inlined.
+      return false;
+    }
+  }
+};
+
+// Structs that the code generator emits directly to describe a message.
+// These should never used directly except to build a ReflectionSchema
+// object.
+//
+// EXPERIMENTAL: these are changing rapidly, and may completely disappear
+// or merge with ReflectionSchema.
+struct MigrationSchema {
+  int32_t offsets_index;
+  int32_t has_bit_indices_index;
+  int32_t inlined_string_indices_index;
+  int object_size;
+};
+
+// This struct tries to reduce unnecessary padding.
+// The num_xxx might not be close to their respective pointer, but this saves
+// padding.
+struct PROTOBUF_EXPORT DescriptorTable {
+  mutable bool is_initialized;
+  bool is_eager;
+  int size;  // of serialized descriptor
+  const char* descriptor;
+  const char* filename;
+  once_flag* once;
+  const DescriptorTable* const* deps;
+  int num_deps;
+  int num_messages;
+  const MigrationSchema* schemas;
+  const Message* const* default_instances;
+  const uint32_t* offsets;
+  // update the following descriptor arrays.
+  Metadata* file_level_metadata;
+  const EnumDescriptor** file_level_enum_descriptors;
+  const ServiceDescriptor** file_level_service_descriptors;
+};
+
+enum {
+  // Tag used on offsets for fields that don't have a real offset.
+  // For example, weak message fields go into the WeakFieldMap and not in an
+  // actual field.
+  kInvalidFieldOffsetTag = 0x40000000u,
+};
+
+// AssignDescriptors() pulls the compiled FileDescriptor from the DescriptorPool
+// and uses it to populate all of the global variables which store pointers to
+// the descriptor objects.  It also constructs the reflection objects.  It is
+// called the first time anyone calls descriptor() or GetReflection() on one of
+// the types defined in the file.  AssignDescriptors() is thread-safe.
+void PROTOBUF_EXPORT AssignDescriptors(const DescriptorTable* table,
+                                       bool eager = false);
+
+// Overload used to implement GetMetadataStatic in the generated code.
+// See comments in compiler/cpp/internal/file.cc as to why.
+// It takes a `Metadata` and returns it to allow for tail calls and reduce
+// binary size.
+Metadata PROTOBUF_EXPORT AssignDescriptors(const DescriptorTable* (*table)(),
+                                           internal::once_flag* once,
+                                           const Metadata& metadata);
+
+// These cannot be in lite so we put them in the reflection.
+PROTOBUF_EXPORT void UnknownFieldSetSerializer(const uint8_t* base,
+                                               uint32_t offset, uint32_t tag,
+                                               uint32_t has_offset,
+                                               io::CodedOutputStream* output);
+
+struct PROTOBUF_EXPORT AddDescriptorsRunner {
+  explicit AddDescriptorsRunner(const DescriptorTable* table);
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_decl.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_decl.h
new file mode 100644
index 0000000..b1bb1de
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_decl.h
@@ -0,0 +1,312 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file contains declarations needed in generated headers for messages
+// that use tail-call table parsing. Everything in this file is for internal
+// use only.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/parse_context.h>
+
+// Must come last:
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Additional information about this field:
+struct TcFieldData {
+  constexpr TcFieldData() : data(0) {}
+
+  // Fast table entry constructor:
+  constexpr TcFieldData(uint16_t coded_tag, uint8_t hasbit_idx, uint8_t aux_idx,
+                        uint16_t offset)
+      : data(uint64_t{offset} << 48 |      //
+             uint64_t{aux_idx} << 24 |     //
+             uint64_t{hasbit_idx} << 16 |  //
+             uint64_t{coded_tag}) {}
+
+  // Fields used in fast table parsing:
+  //
+  //     Bit:
+  //     +-----------+-------------------+
+  //     |63    ..     32|31     ..     0|
+  //     +---------------+---------------+
+  //     :   .   :   .   :   . 16|=======| [16] coded_tag()
+  //     :   .   :   .   : 24|===|   .   : [ 8] hasbit_idx()
+  //     :   .   :   . 32|===|   :   .   : [ 8] aux_idx()
+  //     :   . 48:---.---:   .   :   .   : [16] (unused)
+  //     |=======|   .   :   .   :   .   : [16] offset()
+  //     +-----------+-------------------+
+  //     |63    ..     32|31     ..     0|
+  //     +---------------+---------------+
+
+  template <typename TagType = uint16_t>
+  TagType coded_tag() const {
+    return static_cast<TagType>(data);
+  }
+  uint8_t hasbit_idx() const { return static_cast<uint8_t>(data >> 16); }
+  uint8_t aux_idx() const { return static_cast<uint8_t>(data >> 24); }
+  uint16_t offset() const { return static_cast<uint16_t>(data >> 48); }
+
+  // Fields used in mini table parsing:
+  //
+  //     Bit:
+  //     +-----------+-------------------+
+  //     |63    ..     32|31     ..     0|
+  //     +---------------+---------------+
+  //     :   .   :   .   |===============| [32] tag() (decoded)
+  //     |===============|   .   :   .   : [32] entry_offset()
+  //     +-----------+-------------------+
+  //     |63    ..     32|31     ..     0|
+  //     +---------------+---------------+
+
+  uint32_t tag() const { return static_cast<uint32_t>(data); }
+  uint32_t entry_offset() const { return static_cast<uint32_t>(data >> 32); }
+
+  uint64_t data;
+};
+
+struct TcParseTableBase;
+
+// TailCallParseFunc is the function pointer type used in the tailcall table.
+typedef const char* (*TailCallParseFunc)(PROTOBUF_TC_PARAM_DECL);
+
+namespace field_layout {
+struct Offset {
+  uint32_t off;
+};
+}  // namespace field_layout
+
+#if defined(_MSC_VER) && !defined(_WIN64)
+#pragma warning(push)
+// TcParseTableBase is intentionally overaligned on 32 bit targets.
+#pragma warning(disable : 4324)
+#endif
+
+// Base class for message-level table with info for the tail-call parser.
+struct alignas(uint64_t) TcParseTableBase {
+  // Common attributes for message layout:
+  uint16_t has_bits_offset;
+  uint16_t extension_offset;
+  uint32_t extension_range_low;
+  uint32_t extension_range_high;
+  uint32_t max_field_number;
+  uint8_t fast_idx_mask;
+  uint16_t lookup_table_offset;
+  uint32_t skipmap32;
+  uint32_t field_entries_offset;
+  uint16_t num_field_entries;
+
+  uint16_t num_aux_entries;
+  uint32_t aux_offset;
+
+  const MessageLite* default_instance;
+
+  // Handler for fields which are not handled by table dispatch.
+  TailCallParseFunc fallback;
+
+  // This constructor exactly follows the field layout, so it's technically
+  // not necessary.  However, it makes it much much easier to add or re-arrange
+  // fields, because it can be overloaded with an additional constructor,
+  // temporarily allowing both old and new protocol buffer headers to be
+  // compiled.
+  constexpr TcParseTableBase(
+      uint16_t has_bits_offset, uint16_t extension_offset,
+      uint32_t extension_range_low, uint32_t extension_range_high,
+      uint32_t max_field_number, uint8_t fast_idx_mask,
+      uint16_t lookup_table_offset, uint32_t skipmap32,
+      uint32_t field_entries_offset, uint16_t num_field_entries,
+      uint16_t num_aux_entries, uint32_t aux_offset,
+      const MessageLite* default_instance, TailCallParseFunc fallback)
+      : has_bits_offset(has_bits_offset),
+        extension_offset(extension_offset),
+        extension_range_low(extension_range_low),
+        extension_range_high(extension_range_high),
+        max_field_number(max_field_number),
+        fast_idx_mask(fast_idx_mask),
+        lookup_table_offset(lookup_table_offset),
+        skipmap32(skipmap32),
+        field_entries_offset(field_entries_offset),
+        num_field_entries(num_field_entries),
+        num_aux_entries(num_aux_entries),
+        aux_offset(aux_offset),
+        default_instance(default_instance),
+        fallback(fallback) {}
+
+  // Table entry for fast-path tailcall dispatch handling.
+  struct FastFieldEntry {
+    // Target function for dispatch:
+    TailCallParseFunc target;
+    // Field data used during parse:
+    TcFieldData bits;
+  };
+  // There is always at least one table entry.
+  const FastFieldEntry* fast_entry(size_t idx) const {
+    return reinterpret_cast<const FastFieldEntry*>(this + 1) + idx;
+  }
+
+  // Returns a begin iterator (pointer) to the start of the field lookup table.
+  const uint16_t* field_lookup_begin() const {
+    return reinterpret_cast<const uint16_t*>(reinterpret_cast<uintptr_t>(this) +
+                                             lookup_table_offset);
+  }
+
+  // Field entry for all fields.
+  struct FieldEntry {
+    uint32_t offset;     // offset in the message object
+    int32_t has_idx;     // has-bit index
+    uint16_t aux_idx;    // index for `field_aux`.
+    uint16_t type_card;  // `FieldType` and `Cardinality` (see _impl.h)
+  };
+
+  // Returns a begin iterator (pointer) to the start of the field entries array.
+  const FieldEntry* field_entries_begin() const {
+    return reinterpret_cast<const FieldEntry*>(
+        reinterpret_cast<uintptr_t>(this) + field_entries_offset);
+  }
+
+  // Auxiliary entries for field types that need extra information.
+  union FieldAux {
+    constexpr FieldAux() : message_default(nullptr) {}
+    constexpr FieldAux(bool (*enum_validator)(int))
+        : enum_validator(enum_validator) {}
+    constexpr FieldAux(field_layout::Offset off) : offset(off.off) {}
+    constexpr FieldAux(int16_t range_start, uint16_t range_length)
+        : enum_range{range_start, range_length} {}
+    constexpr FieldAux(const MessageLite* msg) : message_default(msg) {}
+    bool (*enum_validator)(int);
+    struct {
+      int16_t start;    // minimum enum number (if it fits)
+      uint16_t length;  // length of range (i.e., max = start + length - 1)
+    } enum_range;
+    uint32_t offset;
+    const MessageLite* message_default;
+  };
+  const FieldAux* field_aux(uint32_t idx) const {
+    return reinterpret_cast<const FieldAux*>(reinterpret_cast<uintptr_t>(this) +
+                                             aux_offset) +
+           idx;
+  }
+  const FieldAux* field_aux(const FieldEntry* entry) const {
+    return field_aux(entry->aux_idx);
+  }
+
+  // Field name data
+  const char* name_data() const {
+    return reinterpret_cast<const char*>(reinterpret_cast<uintptr_t>(this) +
+                                         aux_offset +
+                                         num_aux_entries * sizeof(FieldAux));
+  }
+};
+
+#if defined(_MSC_VER) && !defined(_WIN64)
+#pragma warning(pop)
+#endif
+
+static_assert(sizeof(TcParseTableBase::FastFieldEntry) <= 16,
+              "Fast field entry is too big.");
+static_assert(sizeof(TcParseTableBase::FieldEntry) <= 16,
+              "Field entry is too big.");
+
+template <size_t kFastTableSizeLog2, size_t kNumFieldEntries = 0,
+          size_t kNumFieldAux = 0, size_t kNameTableSize = 0,
+          size_t kFieldLookupSize = 2>
+struct TcParseTable {
+  TcParseTableBase header;
+
+  // Entries for each field.
+  //
+  // Fields are indexed by the lowest bits of their field number. The field
+  // number is masked to fit inside the table. Note that the parsing logic
+  // generally calls `TailCallParseTableBase::fast_entry()` instead of accessing
+  // this field directly.
+  std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
+      fast_entries;
+
+  // Just big enough to find all the field entries.
+  std::array<uint16_t, kFieldLookupSize> field_lookup_table;
+  // Entries for all fields:
+  std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
+  std::array<TcParseTableBase::FieldAux, kNumFieldAux> aux_entries;
+  std::array<char, kNameTableSize> field_names;
+};
+
+// Partial specialization: if there are no aux entries, there will be no array.
+// In C++, arrays cannot have length 0, but (C++11) std::array<T, 0> is valid.
+// However, different implementations have different sizeof(std::array<T, 0>).
+// Skipping the member makes offset computations portable.
+template <size_t kFastTableSizeLog2, size_t kNumFieldEntries,
+          size_t kNameTableSize, size_t kFieldLookupSize>
+struct TcParseTable<kFastTableSizeLog2, kNumFieldEntries, 0, kNameTableSize,
+                    kFieldLookupSize> {
+  TcParseTableBase header;
+  std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
+      fast_entries;
+  std::array<uint16_t, kFieldLookupSize> field_lookup_table;
+  std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
+  std::array<char, kNameTableSize> field_names;
+};
+
+// Partial specialization: if there are no fields at all, then we can save space
+// by skipping the field numbers and entries.
+template <size_t kNameTableSize, size_t kFieldLookupSize>
+struct TcParseTable<0, 0, 0, kNameTableSize, kFieldLookupSize> {
+  TcParseTableBase header;
+  // N.B.: the fast entries are sized by log2, so 2**0 fields = 1 entry.
+  // The fast parsing loop will always use this entry, so it must be present.
+  std::array<TcParseTableBase::FastFieldEntry, 1> fast_entries;
+  std::array<uint16_t, kFieldLookupSize> field_lookup_table;
+  std::array<char, kNameTableSize> field_names;
+};
+
+static_assert(std::is_standard_layout<TcParseTable<1>>::value,
+              "TcParseTable must be standard layout.");
+
+static_assert(offsetof(TcParseTable<1>, fast_entries) ==
+                  sizeof(TcParseTableBase),
+              "Table entries must be laid out after TcParseTableBase.");
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_DECL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_impl.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_impl.h
new file mode 100644
index 0000000..21fa533
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_impl.h
@@ -0,0 +1,553 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_IMPL_H__
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_IMPL_H__
+
+#include <cstdint>
+#include <type_traits>
+
+#include <google/protobuf/port.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_message_tctable_decl.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/parse_context.h>
+#include <google/protobuf/wire_format_lite.h>
+
+// Must come last:
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class Message;
+class UnknownFieldSet;
+
+namespace internal {
+
+// Field layout enums.
+//
+// Structural information about fields is packed into a 16-bit value. The enum
+// types below represent bitwise fields, along with their respective widths,
+// shifts, and masks.
+//
+//     Bit:
+//     +-----------------------+-----------------------+
+//     |15        ..          8|7         ..          0|
+//     +-----------------------+-----------------------+
+//     :  .  :  .  :  .  :  .  :  .  :  .  : 3|========| [3] FieldType
+//     :     :     :     :     :     : 5|=====|  :     : [2] FieldCardinality
+//     :  .  :  .  :  .  :  . 8|========|  :  .  :  .  : [3] FieldRep
+//     :     :     :   10|=====|     :     :     :     : [2] TransformValidation
+//     :  .  :  .12|=====|  .  :  .  :  .  :  .  :  .  : [2] FormatDiscriminator
+//     +-----------------------+-----------------------+
+//     |15        ..          8|7         ..          0|
+//     +-----------------------+-----------------------+
+//
+namespace field_layout {
+// clang-format off
+
+// Field kind (3 bits):
+// These values broadly represent a wire type and an in-memory storage class.
+enum FieldKind : uint16_t {
+  kFkShift = 0,
+  kFkBits = 3,
+  kFkMask = ((1 << kFkBits) - 1) << kFkShift,
+
+  kFkNone = 0,
+  kFkVarint,        // WT=0     rep=8,32,64 bits
+  kFkPackedVarint,  // WT=2     rep=8,32,64 bits
+  kFkFixed,         // WT=1,5   rep=32,64 bits
+  kFkPackedFixed,   // WT=2     rep=32,64 bits
+  kFkString,        // WT=2     rep=various
+  kFkMessage,       // WT=2,3,4 rep=MessageLite*
+  // Maps are a special case of Message, but use different parsing logic.
+  kFkMap,           // WT=2     rep=Map(Lite)<various, various>
+};
+
+static_assert(kFkMap < (1 << kFkBits), "too many types");
+
+// Cardinality (2 bits):
+// These values determine how many values a field can have and its presence.
+// Packed fields are represented in FieldType.
+enum Cardinality : uint16_t {
+  kFcShift    = kFkShift + kFkBits,
+  kFcBits     = 2,
+  kFcMask     = ((1 << kFcBits) - 1) << kFcShift,
+
+  kFcSingular = 0,
+  kFcOptional = 1 << kFcShift,
+  kFcRepeated = 2 << kFcShift,
+  kFcOneof    = 3 << kFcShift,
+};
+
+// Field representation (3 bits):
+// These values are the specific refinements of storage classes in FieldType.
+enum FieldRep : uint16_t {
+  kRepShift    = kFcShift + kFcBits,
+  kRepBits     = 3,
+  kRepMask     = ((1 << kRepBits) - 1) << kRepShift,
+
+  // Numeric types (used for optional and repeated fields):
+  kRep8Bits    = 0,
+  kRep32Bits   = 2 << kRepShift,
+  kRep64Bits   = 3 << kRepShift,
+  // String types:
+  kRepAString  = 0,               // ArenaStringPtr
+  kRepIString  = 1 << kRepShift,  // InlinedString
+  kRepCord     = 2 << kRepShift,  // absl::Cord
+  kRepSPiece   = 3 << kRepShift,  // StringPieceField
+  kRepSString  = 4 << kRepShift,  // std::string*
+  // Message types (WT=2 unless otherwise noted):
+  kRepMessage  = 0,               // MessageLite*
+  kRepGroup    = 1 << kRepShift,  // MessageLite* (WT=3,4)
+  kRepLazy     = 2 << kRepShift,  // LazyField*
+  kRepIWeak    = 3 << kRepShift,  // ImplicitWeak
+};
+
+// Transform/validation (2 bits):
+// These values determine transforms or validation to/from wire format.
+enum TransformValidation : uint16_t {
+  kTvShift     = kRepShift + kRepBits,
+  kTvBits      = 2,
+  kTvMask      = ((1 << kTvBits) - 1) << kTvShift,
+
+  // Varint fields:
+  kTvZigZag    = 1 << kTvShift,
+  kTvEnum      = 2 << kTvShift,  // validate using generated _IsValid()
+  kTvRange     = 3 << kTvShift,  // validate using FieldAux::enum_range
+  // String fields:
+  kTvUtf8Debug = 1 << kTvShift,  // proto2
+  kTvUtf8      = 2 << kTvShift,  // proto3
+};
+
+static_assert((kTvEnum & kTvRange) != 0,
+              "enum validation types must share a bit");
+static_assert((kTvEnum & kTvRange & kTvZigZag) == 0,
+              "zigzag encoding is not enum validation");
+
+// Format discriminators (2 bits):
+enum FormatDiscriminator : uint16_t {
+  kFmtShift      = kTvShift + kTvBits,
+  kFmtBits       = 2,
+  kFmtMask       = ((1 << kFmtBits) - 1) << kFmtShift,
+
+  // Numeric:
+  kFmtUnsigned   = 1 << kFmtShift,  // fixed, varint
+  kFmtSigned     = 2 << kFmtShift,  // fixed, varint
+  kFmtFloating   = 3 << kFmtShift,  // fixed
+  kFmtEnum       = 3 << kFmtShift,  // varint
+  // Strings:
+  kFmtUtf8       = 1 << kFmtShift,  // string (proto3, enforce_utf8=true)
+  kFmtUtf8Escape = 2 << kFmtShift,  // string (proto2, enforce_utf8=false)
+  // Bytes:
+  kFmtArray      = 1 << kFmtShift,  // bytes
+  // Messages:
+  kFmtShow       = 1 << kFmtShift,  // message, map
+};
+
+// Update this assertion (and comments above) when adding or removing bits:
+static_assert(kFmtShift + kFmtBits == 12, "number of bits changed");
+
+// This assertion should not change unless the storage width changes:
+static_assert(kFmtShift + kFmtBits <= 16, "too many bits");
+
+// Convenience aliases (16 bits, with format):
+enum FieldType : uint16_t {
+  // Numeric types:
+  kBool            = kFkVarint | kRep8Bits,
+
+  kFixed32         = kFkFixed  | kRep32Bits | kFmtUnsigned,
+  kUInt32          = kFkVarint | kRep32Bits | kFmtUnsigned,
+  kSFixed32        = kFkFixed  | kRep32Bits | kFmtSigned,
+  kInt32           = kFkVarint | kRep32Bits | kFmtSigned,
+  kSInt32          = kFkVarint | kRep32Bits | kFmtSigned | kTvZigZag,
+  kFloat           = kFkFixed  | kRep32Bits | kFmtFloating,
+  kEnum            = kFkVarint | kRep32Bits | kFmtEnum   | kTvEnum,
+  kEnumRange       = kFkVarint | kRep32Bits | kFmtEnum   | kTvRange,
+  kOpenEnum        = kFkVarint | kRep32Bits | kFmtEnum,
+
+  kFixed64         = kFkFixed  | kRep64Bits | kFmtUnsigned,
+  kUInt64          = kFkVarint | kRep64Bits | kFmtUnsigned,
+  kSFixed64        = kFkFixed  | kRep64Bits | kFmtSigned,
+  kInt64           = kFkVarint | kRep64Bits | kFmtSigned,
+  kSInt64          = kFkVarint | kRep64Bits | kFmtSigned | kTvZigZag,
+  kDouble          = kFkFixed  | kRep64Bits | kFmtFloating,
+
+  kPackedBool      = kFkPackedVarint | kRep8Bits,
+
+  kPackedFixed32   = kFkPackedFixed  | kRep32Bits | kFmtUnsigned,
+  kPackedUInt32    = kFkPackedVarint | kRep32Bits | kFmtUnsigned,
+  kPackedSFixed32  = kFkPackedFixed  | kRep32Bits | kFmtSigned,
+  kPackedInt32     = kFkPackedVarint | kRep32Bits | kFmtSigned,
+  kPackedSInt32    = kFkPackedVarint | kRep32Bits | kFmtSigned | kTvZigZag,
+  kPackedFloat     = kFkPackedFixed  | kRep32Bits | kFmtFloating,
+  kPackedEnum      = kFkPackedVarint | kRep32Bits | kFmtEnum   | kTvEnum,
+  kPackedEnumRange = kFkPackedVarint | kRep32Bits | kFmtEnum   | kTvRange,
+  kPackedOpenEnum  = kFkPackedVarint | kRep32Bits | kFmtEnum,
+
+  kPackedFixed64   = kFkPackedFixed  | kRep64Bits | kFmtUnsigned,
+  kPackedUInt64    = kFkPackedVarint | kRep64Bits | kFmtUnsigned,
+  kPackedSFixed64  = kFkPackedFixed  | kRep64Bits | kFmtSigned,
+  kPackedInt64     = kFkPackedVarint | kRep64Bits | kFmtSigned,
+  kPackedSInt64    = kFkPackedVarint | kRep64Bits | kFmtSigned | kTvZigZag,
+  kPackedDouble    = kFkPackedFixed  | kRep64Bits | kFmtFloating,
+
+  // String types:
+  kBytes           = kFkString | kFmtArray,
+  kRawString       = kFkString | kFmtUtf8  | kTvUtf8Debug,
+  kUtf8String      = kFkString | kFmtUtf8  | kTvUtf8,
+
+  // Message types:
+  kMessage         = kFkMessage,
+
+  // Map types:
+  kMap             = kFkMap,
+};
+
+// clang-format on
+}  // namespace field_layout
+
+// PROTOBUF_TC_PARAM_DECL are the parameters for tailcall functions, it is
+// defined in port_def.inc.
+//
+// Note that this is performance sensitive: changing the parameters will change
+// the registers used by the ABI calling convention, which subsequently affects
+// register selection logic inside the function.
+
+// PROTOBUF_TC_PARAM_PASS passes values to match PROTOBUF_TC_PARAM_DECL.
+#define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, table, hasbits, data
+
+#ifndef NDEBUG
+template <size_t align>
+#ifndef _MSC_VER
+[[noreturn]]
+#endif
+void AlignFail(uintptr_t address) {
+  GOOGLE_LOG(FATAL) << "Unaligned (" << align << ") access at " << address;
+}
+
+extern template void AlignFail<4>(uintptr_t);
+extern template void AlignFail<8>(uintptr_t);
+#endif
+
+// TcParser implements most of the parsing logic for tailcall tables.
+class PROTOBUF_EXPORT TcParser final {
+ public:
+  static const char* GenericFallback(PROTOBUF_TC_PARAM_DECL);
+  static const char* GenericFallbackLite(PROTOBUF_TC_PARAM_DECL);
+
+  static const char* ParseLoop(MessageLite* msg, const char* ptr,
+                               ParseContext* ctx,
+                               const TcParseTableBase* table);
+
+  // Functions referenced by generated fast tables (numeric types):
+  //   F: fixed      V: varint     Z: zigzag
+  //   8/32/64: storage type width (bits)
+  //   S: singular   R: repeated   P: packed
+  //   1/2: tag length (bytes)
+
+  // Fixed:
+  static const char* FastF32S1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF32S2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF32R1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF32R2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF32P1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF32P2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF64S1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF64S2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF64R1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF64R2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF64P1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastF64P2(PROTOBUF_TC_PARAM_DECL);
+
+  // Varint:
+  static const char* FastV8S1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV8S2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV8R1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV8R2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV8P1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV8P2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV32S1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV32S2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV32R1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV32R2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV32P1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV32P2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV64S1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV64S2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV64R1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV64R2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV64P1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastV64P2(PROTOBUF_TC_PARAM_DECL);
+
+  // Varint (with zigzag):
+  static const char* FastZ32S1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ32S2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ32R1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ32R2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ32P1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ32P2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ64S1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ64S2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ64R1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ64R2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ64P1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastZ64P2(PROTOBUF_TC_PARAM_DECL);
+
+  // Functions referenced by generated fast tables (closed enum):
+  //   E: closed enum (N.B.: open enums use V32, above)
+  //   r: enum range  v: enum validator (_IsValid function)
+  //   S: singular   R: repeated
+  //   1/2: tag length (bytes)
+  static const char* FastErS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastErS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastErR1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastErR2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastEvS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastEvS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastEvR1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastEvR2(PROTOBUF_TC_PARAM_DECL);
+
+  // Functions referenced by generated fast tables (string types):
+  //   B: bytes      S: string     U: UTF-8 string
+  //   (empty): ArenaStringPtr     i: InlinedString
+  //   S: singular   R: repeated
+  //   1/2: tag length (bytes)
+  static const char* FastBS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastBS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastBR1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastBR2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastSS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastSS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastSR1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastSR2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastUS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastUS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastUR1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastUR2(PROTOBUF_TC_PARAM_DECL);
+
+  static const char* FastBiS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastBiS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastSiS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastSiS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastUiS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastUiS2(PROTOBUF_TC_PARAM_DECL);
+
+  // Functions referenced by generated fast tables (message types):
+  //   M: message    G: group
+  //   S: singular   R: repeated
+  //   1/2: tag length (bytes)
+  static const char* FastMS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastMS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastMR1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastMR2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastGS1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastGS2(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastGR1(PROTOBUF_TC_PARAM_DECL);
+  static const char* FastGR2(PROTOBUF_TC_PARAM_DECL);
+
+  template <typename T>
+  static inline T& RefAt(void* x, size_t offset) {
+    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
+#ifndef NDEBUG
+    if (PROTOBUF_PREDICT_FALSE(
+            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
+      AlignFail<alignof(T)>(reinterpret_cast<uintptr_t>(target));
+    }
+#endif
+    return *target;
+  }
+
+  template <typename T>
+  static inline const T& RefAt(const void* x, size_t offset) {
+    const T* target =
+        reinterpret_cast<const T*>(static_cast<const char*>(x) + offset);
+#ifndef NDEBUG
+    if (PROTOBUF_PREDICT_FALSE(
+            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
+      AlignFail<alignof(T)>(reinterpret_cast<uintptr_t>(target));
+    }
+#endif
+    return *target;
+  }
+
+  template <typename T>
+  static inline T ReadAt(const void* x, size_t offset) {
+    T out;
+    memcpy(&out, static_cast<const char*>(x) + offset, sizeof(T));
+    return out;
+  }
+
+  // Mini parsing:
+  //
+  // This function parses a field from incoming data based on metadata stored in
+  // the message definition. If the field is not defined in the message, it is
+  // stored in either the ExtensionSet (if applicable) or the UnknownFieldSet.
+  //
+  // NOTE: Currently, this function only calls the table-level fallback
+  // function, so it should only be called as the fallback from fast table
+  // parsing.
+  static const char* MiniParse(PROTOBUF_TC_PARAM_DECL);
+
+ private:
+  friend class GeneratedTcTableLiteTest;
+
+  template <typename TagType, bool group_coding>
+  static inline const char* SingularParseMessageAuxImpl(PROTOBUF_TC_PARAM_DECL);
+  template <typename TagType, bool group_coding>
+  static inline const char* RepeatedParseMessageAuxImpl(PROTOBUF_TC_PARAM_DECL);
+
+  static inline PROTOBUF_ALWAYS_INLINE void SyncHasbits(
+      MessageLite* msg, uint64_t hasbits, const TcParseTableBase* table) {
+    const uint32_t has_bits_offset = table->has_bits_offset;
+    if (has_bits_offset) {
+      // Only the first 32 has-bits are updated. Nothing above those is stored,
+      // but e.g. messages without has-bits update the upper bits.
+      RefAt<uint32_t>(msg, has_bits_offset) = static_cast<uint32_t>(hasbits);
+    }
+  }
+
+  static const char* TagDispatch(PROTOBUF_TC_PARAM_DECL);
+  static const char* ToTagDispatch(PROTOBUF_TC_PARAM_DECL);
+  static const char* ToParseLoop(PROTOBUF_TC_PARAM_DECL);
+  static const char* Error(PROTOBUF_TC_PARAM_DECL);
+
+  static const char* FastUnknownEnumFallback(PROTOBUF_TC_PARAM_DECL);
+
+  class ScopedArenaSwap;
+
+  template <class MessageBaseT, class UnknownFieldsT>
+  static const char* GenericFallbackImpl(PROTOBUF_TC_PARAM_DECL) {
+#define CHK_(x) \
+  if (PROTOBUF_PREDICT_FALSE(!(x))) return nullptr /* NOLINT */
+
+    SyncHasbits(msg, hasbits, table);
+    CHK_(ptr);
+    uint32_t tag = data.tag();
+    if ((tag & 7) == WireFormatLite::WIRETYPE_END_GROUP || tag == 0) {
+      ctx->SetLastTag(tag);
+      return ptr;
+    }
+    uint32_t num = tag >> 3;
+    if (table->extension_range_low <= num &&
+        num <= table->extension_range_high) {
+      return RefAt<ExtensionSet>(msg, table->extension_offset)
+          .ParseField(tag, ptr,
+                      static_cast<const MessageBaseT*>(table->default_instance),
+                      &msg->_internal_metadata_, ctx);
+    }
+    return UnknownFieldParse(
+        tag, msg->_internal_metadata_.mutable_unknown_fields<UnknownFieldsT>(),
+        ptr, ctx);
+#undef CHK_
+  }
+
+  // Note: `inline` is needed on template function declarations below to avoid
+  // -Wattributes diagnostic in GCC.
+
+  // Implementations for fast fixed field parsing functions:
+  template <typename LayoutType, typename TagType>
+  static inline const char* SingularFixed(PROTOBUF_TC_PARAM_DECL);
+  template <typename LayoutType, typename TagType>
+  static inline const char* RepeatedFixed(PROTOBUF_TC_PARAM_DECL);
+  template <typename LayoutType, typename TagType>
+  static inline const char* PackedFixed(PROTOBUF_TC_PARAM_DECL);
+
+  // Implementations for fast varint field parsing functions:
+  template <typename FieldType, typename TagType, bool zigzag = false>
+  static inline const char* SingularVarint(PROTOBUF_TC_PARAM_DECL);
+  template <typename FieldType, typename TagType, bool zigzag = false>
+  static inline const char* RepeatedVarint(PROTOBUF_TC_PARAM_DECL);
+  template <typename FieldType, typename TagType, bool zigzag = false>
+  static inline const char* PackedVarint(PROTOBUF_TC_PARAM_DECL);
+
+  // Helper for ints > 127:
+  template <typename FieldType, typename TagType, bool zigzag = false>
+  static const char* SingularVarBigint(PROTOBUF_TC_PARAM_DECL);
+
+  // Implementations for fast enum field parsing functions:
+  template <typename TagType, uint16_t xform_val>
+  static inline const char* SingularEnum(PROTOBUF_TC_PARAM_DECL);
+  template <typename TagType, uint16_t xform_val>
+  static inline const char* RepeatedEnum(PROTOBUF_TC_PARAM_DECL);
+
+  // Implementations for fast string field parsing functions:
+  enum Utf8Type { kNoUtf8 = 0, kUtf8 = 1, kUtf8ValidateOnly = 2 };
+  template <typename TagType, Utf8Type utf8>
+  static inline const char* SingularString(PROTOBUF_TC_PARAM_DECL);
+  template <typename TagType, Utf8Type utf8>
+  static inline const char* RepeatedString(PROTOBUF_TC_PARAM_DECL);
+
+  // Mini field lookup:
+  static const TcParseTableBase::FieldEntry* FindFieldEntry(
+      const TcParseTableBase* table, uint32_t field_num);
+  static StringPiece MessageName(const TcParseTableBase* table);
+  static StringPiece FieldName(const TcParseTableBase* table,
+                                     const TcParseTableBase::FieldEntry*);
+  static bool ChangeOneof(const TcParseTableBase* table,
+                          const TcParseTableBase::FieldEntry& entry,
+                          uint32_t field_num, ParseContext* ctx,
+                          MessageLite* msg);
+
+  // UTF-8 validation:
+  static void ReportFastUtf8Error(uint32_t decoded_tag,
+                                  const TcParseTableBase* table);
+  static bool MpVerifyUtf8(StringPiece wire_bytes,
+                           const TcParseTableBase* table,
+                           const TcParseTableBase::FieldEntry& entry,
+                           uint16_t xform_val);
+
+  // For FindFieldEntry tests:
+  friend class FindFieldEntryTest;
+  static constexpr const uint32_t kMtSmallScanSize = 4;
+
+  // Mini parsing:
+  static const char* MpVarint(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpRepeatedVarint(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpPackedVarint(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpFixed(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpRepeatedFixed(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpPackedFixed(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpString(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpRepeatedString(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpMessage(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpRepeatedMessage(PROTOBUF_TC_PARAM_DECL);
+  static const char* MpMap(PROTOBUF_TC_PARAM_DECL);
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TCTABLE_IMPL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_util.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_util.h
new file mode 100644
index 0000000..71d15cd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_util.h
@@ -0,0 +1,214 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains miscellaneous helper code used by generated code --
+// including lite types -- but which should not be used directly by users.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__
+
+#include <assert.h>
+
+#include <atomic>
+#include <climits>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>  // Add direct dep on port for pb.cc
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/any.h>
+#include <google/protobuf/has_bits.h>
+#include <google/protobuf/implicit_weak_message.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/stubs/casts.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+class Arena;
+class Message;
+
+namespace io {
+class CodedInputStream;
+}
+
+namespace internal {
+
+template <typename To, typename From>
+inline To DownCast(From* f) {
+  return PROTOBUF_NAMESPACE_ID::internal::down_cast<To>(f);
+}
+template <typename To, typename From>
+inline To DownCast(From& f) {
+  return PROTOBUF_NAMESPACE_ID::internal::down_cast<To>(f);
+}
+
+
+// This fastpath inlines a single branch instead of having to make the
+// InitProtobufDefaults function call.
+// It also generates less inlined code than a function-scope static initializer.
+PROTOBUF_EXPORT extern std::atomic<bool> init_protobuf_defaults_state;
+PROTOBUF_EXPORT void InitProtobufDefaultsSlow();
+PROTOBUF_EXPORT inline void InitProtobufDefaults() {
+  if (PROTOBUF_PREDICT_FALSE(
+          !init_protobuf_defaults_state.load(std::memory_order_acquire))) {
+    InitProtobufDefaultsSlow();
+  }
+}
+
+// This used by proto1
+PROTOBUF_EXPORT inline const std::string& GetEmptyString() {
+  InitProtobufDefaults();
+  return GetEmptyStringAlreadyInited();
+}
+
+
+// True if IsInitialized() is true for all elements of t.  Type is expected
+// to be a RepeatedPtrField<some message type>.  It's useful to have this
+// helper here to keep the protobuf compiler from ever having to emit loops in
+// IsInitialized() methods.  We want the C++ compiler to inline this or not
+// as it sees fit.
+template <typename Msg>
+bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
+  for (int i = t.size(); --i >= 0;) {
+    if (!t.Get(i).IsInitialized()) return false;
+  }
+  return true;
+}
+
+// "Weak" variant of AllAreInitialized, used to implement implicit weak fields.
+// This version operates on MessageLite to avoid introducing a dependency on the
+// concrete message type.
+template <class T>
+bool AllAreInitializedWeak(const RepeatedPtrField<T>& t) {
+  for (int i = t.size(); --i >= 0;) {
+    if (!reinterpret_cast<const RepeatedPtrFieldBase&>(t)
+             .Get<ImplicitWeakTypeHandler<T> >(i)
+             .IsInitialized()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline bool IsPresent(const void* base, uint32_t hasbit) {
+  const uint32_t* has_bits_array = static_cast<const uint32_t*>(base);
+  return (has_bits_array[hasbit / 32] & (1u << (hasbit & 31))) != 0;
+}
+
+inline bool IsOneofPresent(const void* base, uint32_t offset, uint32_t tag) {
+  const uint32_t* oneof = reinterpret_cast<const uint32_t*>(
+      static_cast<const uint8_t*>(base) + offset);
+  return *oneof == tag >> 3;
+}
+
+typedef void (*SpecialSerializer)(const uint8_t* base, uint32_t offset,
+                                  uint32_t tag, uint32_t has_offset,
+                                  io::CodedOutputStream* output);
+
+PROTOBUF_EXPORT void ExtensionSerializer(const MessageLite* extendee,
+                                         const uint8_t* ptr, uint32_t offset,
+                                         uint32_t tag, uint32_t has_offset,
+                                         io::CodedOutputStream* output);
+PROTOBUF_EXPORT void UnknownFieldSerializerLite(const uint8_t* base,
+                                                uint32_t offset, uint32_t tag,
+                                                uint32_t has_offset,
+                                                io::CodedOutputStream* output);
+
+PROTOBUF_EXPORT MessageLite* DuplicateIfNonNullInternal(MessageLite* message);
+PROTOBUF_EXPORT MessageLite* GetOwnedMessageInternal(Arena* message_arena,
+                                                     MessageLite* submessage,
+                                                     Arena* submessage_arena);
+PROTOBUF_EXPORT void GenericSwap(MessageLite* m1, MessageLite* m2);
+// We specialize GenericSwap for non-lite messages to benefit from reflection.
+PROTOBUF_EXPORT void GenericSwap(Message* m1, Message* m2);
+
+template <typename T>
+T* DuplicateIfNonNull(T* message) {
+  // The casts must be reinterpret_cast<> because T might be a forward-declared
+  // type that the compiler doesn't know is related to MessageLite.
+  return reinterpret_cast<T*>(
+      DuplicateIfNonNullInternal(reinterpret_cast<MessageLite*>(message)));
+}
+
+template <typename T>
+T* GetOwnedMessage(Arena* message_arena, T* submessage,
+                   Arena* submessage_arena) {
+  // The casts must be reinterpret_cast<> because T might be a forward-declared
+  // type that the compiler doesn't know is related to MessageLite.
+  return reinterpret_cast<T*>(GetOwnedMessageInternal(
+      message_arena, reinterpret_cast<MessageLite*>(submessage),
+      submessage_arena));
+}
+
+// Hide atomic from the public header and allow easy change to regular int
+// on platforms where the atomic might have a perf impact.
+class PROTOBUF_EXPORT CachedSize {
+ public:
+  int Get() const { return size_.load(std::memory_order_relaxed); }
+  void Set(int size) { size_.store(size, std::memory_order_relaxed); }
+
+ private:
+  std::atomic<int> size_{0};
+};
+
+PROTOBUF_EXPORT void DestroyMessage(const void* message);
+PROTOBUF_EXPORT void DestroyString(const void* s);
+// Destroy (not delete) the message
+inline void OnShutdownDestroyMessage(const void* ptr) {
+  OnShutdownRun(DestroyMessage, ptr);
+}
+// Destroy the string (call std::string destructor)
+inline void OnShutdownDestroyString(const std::string* ptr) {
+  OnShutdownRun(DestroyString, ptr);
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/has_bits.h b/CAPI/cpp/grpc/include/google/protobuf/has_bits.h
new file mode 100644
index 0000000..f8a4587
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/has_bits.h
@@ -0,0 +1,117 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_HAS_BITS_H__
+#define GOOGLE_PROTOBUF_HAS_BITS_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/port.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+template <size_t doublewords>
+class HasBits {
+ public:
+  PROTOBUF_NDEBUG_INLINE constexpr HasBits() : has_bits_{} {}
+
+  PROTOBUF_NDEBUG_INLINE void Clear() {
+    memset(has_bits_, 0, sizeof(has_bits_));
+  }
+
+  PROTOBUF_NDEBUG_INLINE uint32_t& operator[](int index) {
+    return has_bits_[index];
+  }
+
+  PROTOBUF_NDEBUG_INLINE const uint32_t& operator[](int index) const {
+    return has_bits_[index];
+  }
+
+  bool operator==(const HasBits<doublewords>& rhs) const {
+    return memcmp(has_bits_, rhs.has_bits_, sizeof(has_bits_)) == 0;
+  }
+
+  bool operator!=(const HasBits<doublewords>& rhs) const {
+    return !(*this == rhs);
+  }
+
+  void Or(const HasBits<doublewords>& rhs) {
+    for (size_t i = 0; i < doublewords; i++) has_bits_[i] |= rhs[i];
+  }
+
+  bool empty() const;
+
+ private:
+  uint32_t has_bits_[doublewords];
+};
+
+template <>
+inline bool HasBits<1>::empty() const {
+  return !has_bits_[0];
+}
+
+template <>
+inline bool HasBits<2>::empty() const {
+  return !(has_bits_[0] | has_bits_[1]);
+}
+
+template <>
+inline bool HasBits<3>::empty() const {
+  return !(has_bits_[0] | has_bits_[1] | has_bits_[2]);
+}
+
+template <>
+inline bool HasBits<4>::empty() const {
+  return !(has_bits_[0] | has_bits_[1] | has_bits_[2] | has_bits_[3]);
+}
+
+template <size_t doublewords>
+inline bool HasBits<doublewords>::empty() const {
+  for (size_t i = 0; i < doublewords; ++i) {
+    if (has_bits_[i]) return false;
+  }
+  return true;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_HAS_BITS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/implicit_weak_message.h b/CAPI/cpp/grpc/include/google/protobuf/implicit_weak_message.h
new file mode 100644
index 0000000..b894ab4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/implicit_weak_message.h
@@ -0,0 +1,213 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_IMPLICIT_WEAK_MESSAGE_H__
+#define GOOGLE_PROTOBUF_IMPLICIT_WEAK_MESSAGE_H__
+
+#include <string>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+// This file is logically internal-only and should only be used by protobuf
+// generated code.
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// An implementation of MessageLite that treats all data as unknown. This type
+// acts as a placeholder for an implicit weak field in the case where the true
+// message type does not get linked into the binary.
+class PROTOBUF_EXPORT ImplicitWeakMessage : public MessageLite {
+ public:
+  ImplicitWeakMessage() : data_(new std::string) {}
+  explicit constexpr ImplicitWeakMessage(ConstantInitialized)
+      : data_(nullptr) {}
+  explicit ImplicitWeakMessage(Arena* arena)
+      : MessageLite(arena), data_(new std::string) {}
+
+  ~ImplicitWeakMessage() override {
+    // data_ will be null in the default instance, but we can safely call delete
+    // here because the default instance will never be destroyed.
+    delete data_;
+  }
+
+  static const ImplicitWeakMessage* default_instance();
+
+  std::string GetTypeName() const override { return ""; }
+
+  MessageLite* New(Arena* arena) const override {
+    return Arena::CreateMessage<ImplicitWeakMessage>(arena);
+  }
+
+  void Clear() override { data_->clear(); }
+
+  bool IsInitialized() const override { return true; }
+
+  void CheckTypeAndMergeFrom(const MessageLite& other) override {
+    const std::string* other_data =
+        static_cast<const ImplicitWeakMessage&>(other).data_;
+    if (other_data != nullptr) {
+      data_->append(*other_data);
+    }
+  }
+
+  const char* _InternalParse(const char* ptr, ParseContext* ctx) final;
+
+  size_t ByteSizeLong() const override {
+    return data_ == nullptr ? 0 : data_->size();
+  }
+
+  uint8_t* _InternalSerialize(uint8_t* target,
+                              io::EpsCopyOutputStream* stream) const final {
+    if (data_ == nullptr) {
+      return target;
+    }
+    return stream->WriteRaw(data_->data(), static_cast<int>(data_->size()),
+                            target);
+  }
+
+  int GetCachedSize() const override {
+    return data_ == nullptr ? 0 : static_cast<int>(data_->size());
+  }
+
+  typedef void InternalArenaConstructable_;
+
+ private:
+  // This std::string is allocated on the heap, but we use a raw pointer so that
+  // the default instance can be constant-initialized. In the const methods, we
+  // have to handle the possibility of data_ being null.
+  std::string* data_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImplicitWeakMessage);
+};
+
+struct ImplicitWeakMessageDefaultType;
+extern ImplicitWeakMessageDefaultType implicit_weak_message_default_instance;
+
+// A type handler for use with implicit weak repeated message fields.
+template <typename ImplicitWeakType>
+class ImplicitWeakTypeHandler {
+ public:
+  typedef MessageLite Type;
+  static constexpr bool Moveable = false;
+
+  static inline MessageLite* NewFromPrototype(const MessageLite* prototype,
+                                              Arena* arena = nullptr) {
+    return prototype->New(arena);
+  }
+
+  static inline void Delete(MessageLite* value, Arena* arena) {
+    if (arena == nullptr) {
+      delete value;
+    }
+  }
+  static inline Arena* GetArena(MessageLite* value) {
+    return value->GetArena();
+  }
+  static inline void Clear(MessageLite* value) { value->Clear(); }
+  static void Merge(const MessageLite& from, MessageLite* to) {
+    to->CheckTypeAndMergeFrom(from);
+  }
+};
+
+}  // namespace internal
+
+template <typename T>
+struct WeakRepeatedPtrField {
+  using TypeHandler = internal::ImplicitWeakTypeHandler<T>;
+  constexpr WeakRepeatedPtrField() : weak() {}
+  explicit WeakRepeatedPtrField(Arena* arena) : weak(arena) {}
+  ~WeakRepeatedPtrField() { weak.template Destroy<TypeHandler>(); }
+
+  typedef internal::RepeatedPtrIterator<MessageLite> iterator;
+  typedef internal::RepeatedPtrIterator<const MessageLite> const_iterator;
+  typedef internal::RepeatedPtrOverPtrsIterator<MessageLite*, void*>
+      pointer_iterator;
+  typedef internal::RepeatedPtrOverPtrsIterator<const MessageLite* const,
+                                                const void* const>
+      const_pointer_iterator;
+
+  iterator begin() { return iterator(base().raw_data()); }
+  const_iterator begin() const { return iterator(base().raw_data()); }
+  const_iterator cbegin() const { return begin(); }
+  iterator end() { return begin() + base().size(); }
+  const_iterator end() const { return begin() + base().size(); }
+  const_iterator cend() const { return end(); }
+  pointer_iterator pointer_begin() {
+    return pointer_iterator(base().raw_mutable_data());
+  }
+  const_pointer_iterator pointer_begin() const {
+    return const_pointer_iterator(base().raw_mutable_data());
+  }
+  pointer_iterator pointer_end() {
+    return pointer_iterator(base().raw_mutable_data() + base().size());
+  }
+  const_pointer_iterator pointer_end() const {
+    return const_pointer_iterator(base().raw_mutable_data() + base().size());
+  }
+
+  MessageLite* AddWeak(const MessageLite* prototype) {
+    return base().AddWeak(prototype);
+  }
+  T* Add() { return weak.Add(); }
+  void Clear() { base().template Clear<TypeHandler>(); }
+  void MergeFrom(const WeakRepeatedPtrField& other) {
+    base().template MergeFrom<TypeHandler>(other.base());
+  }
+  void InternalSwap(WeakRepeatedPtrField* other) {
+    base().InternalSwap(&other->base());
+  }
+
+  const internal::RepeatedPtrFieldBase& base() const { return weak; }
+  internal::RepeatedPtrFieldBase& base() { return weak; }
+  // Union disables running the destructor. Which would create a strong link.
+  // Instead we explicitly destroy the underlying base through the virtual
+  // destructor.
+  union {
+    RepeatedPtrField<T> weak;
+  };
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_IMPLICIT_WEAK_MESSAGE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/inlined_string_field.h b/CAPI/cpp/grpc/include/google/protobuf/inlined_string_field.h
new file mode 100644
index 0000000..79e37d4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/inlined_string_field.h
@@ -0,0 +1,532 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_INLINED_STRING_FIELD_H__
+#define GOOGLE_PROTOBUF_INLINED_STRING_FIELD_H__
+
+#include <string>
+#include <utility>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/message_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+class Arena;
+
+namespace internal {
+
+// InlinedStringField wraps a std::string instance and exposes an API similar to
+// ArenaStringPtr's wrapping of a std::string* instance.
+//
+// default_value parameters are taken for consistency with ArenaStringPtr, but
+// are not used for most methods. With inlining, these should be removed from
+// the generated binary.
+//
+// InlinedStringField has a donating mechanism that allows string buffer
+// allocated on arena. A string is donated means both the string container and
+// the data buffer are on arena. The donating mechanism here is similar to the
+// one in ArenaStringPtr with some differences:
+//
+// When an InlinedStringField is constructed, the donating state is true. This
+// is because the string container is directly stored in the message on the
+// arena:
+//
+//   Construction: donated=true
+//   Arena:
+//   +-----------------------+
+//   |Message foo:           |
+//   | +-------------------+ |
+//   | |InlinedStringField:| |
+//   | | +-----+           | |
+//   | | | | | |           | |
+//   | | +-----+           | |
+//   | +-------------------+ |
+//   +-----------------------+
+//
+// When lvalue Set is called, the donating state is still true. String data will
+// be allocated on the arena:
+//
+//   Lvalue Set: donated=true
+//   Arena:
+//   +-----------------------+
+//   |Message foo:           |
+//   | +-------------------+ |
+//   | |InlinedStringField:| |
+//   | | +-----+           | |
+//   | | | | | |           | |
+//   | | +|----+           | |
+//   | +--|----------------+ |
+//   |    V                  |
+//   |  +----------------+   |
+//   |  |'f','o','o',... |   |
+//   |  +----------------+   |
+//   +-----------------------+
+//
+// Some operations will undonate a donated string, including: Mutable,
+// SetAllocated, Rvalue Set, and Swap with a non-donated string.
+//
+// For more details of the donating states transitions, go/pd-inlined-string.
+class PROTOBUF_EXPORT InlinedStringField {
+ public:
+  InlinedStringField() { Init(); }
+  inline void Init() { new (get_mutable()) std::string(); }
+  // Add the dummy parameter just to make InlinedStringField(nullptr)
+  // unambiguous.
+  constexpr InlinedStringField(
+      const ExplicitlyConstructed<std::string>* /*default_value*/,
+      bool /*dummy*/)
+      : value_{} {}
+  explicit InlinedStringField(const std::string& default_value);
+  explicit InlinedStringField(Arena* arena);
+  ~InlinedStringField() { Destruct(); }
+
+  // Lvalue Set. To save space, we pack the donating states of multiple
+  // InlinedStringFields into an uint32_t `donating_states`. The `mask`
+  // indicates the position of the bit for this InlinedStringField. `donated` is
+  // whether this field is donated.
+  //
+  // The caller should guarantee that:
+  //
+  //   `donated == ((donating_states & ~mask) != 0)`
+  //
+  // This method never changes the `donating_states`.
+  void Set(ConstStringParam value, Arena* arena, bool donated,
+           uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+  // Rvalue Set. If this field is donated, this method will undonate this field
+  // by mutating the `donating_states` according to `mask`.
+  void Set(std::string&& value, Arena* arena, bool donated,
+           uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+  void Set(const char* str, ::google::protobuf::Arena* arena, bool donated,
+           uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+  void Set(const char* str, size_t size, ::google::protobuf::Arena* arena, bool donated,
+           uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+  template <typename RefWrappedType>
+  void Set(std::reference_wrapper<RefWrappedType> const_string_ref,
+           ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
+           uint32_t mask, MessageLite* msg);
+
+  void SetBytes(ConstStringParam value, Arena* arena, bool donated,
+                uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+  void SetBytes(std::string&& value, Arena* arena, bool donated,
+                uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+  void SetBytes(const char* str, ::google::protobuf::Arena* arena, bool donated,
+                uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+  void SetBytes(const void* p, size_t size, ::google::protobuf::Arena* arena,
+                bool donated, uint32_t* donating_states, uint32_t mask,
+                MessageLite* msg);
+
+  template <typename RefWrappedType>
+  void SetBytes(std::reference_wrapper<RefWrappedType> const_string_ref,
+                ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
+                uint32_t mask, MessageLite* msg);
+
+  PROTOBUF_NDEBUG_INLINE void SetNoArena(StringPiece value);
+  PROTOBUF_NDEBUG_INLINE void SetNoArena(std::string&& value);
+
+  // Basic accessors.
+  PROTOBUF_NDEBUG_INLINE const std::string& Get() const { return GetNoArena(); }
+  PROTOBUF_NDEBUG_INLINE const std::string& GetNoArena() const;
+
+  // Mutable returns a std::string* instance that is heap-allocated. If this
+  // field is donated, this method undonates this field by mutating the
+  // `donating_states` according to `mask`, and copies the content of the
+  // original string to the returning string.
+  std::string* Mutable(Arena* arena, bool donated, uint32_t* donating_states,
+                       uint32_t mask, MessageLite* msg);
+  std::string* Mutable(const LazyString& default_value, Arena* arena,
+                       bool donated, uint32_t* donating_states, uint32_t mask,
+                       MessageLite* msg);
+
+  // Mutable(nullptr_t) is an overload to explicitly support Mutable(nullptr)
+  // calls used by the internal parser logic. This provides API equivalence with
+  // ArenaStringPtr, while still protecting against calls with arena pointers.
+  std::string* Mutable(std::nullptr_t);
+  std::string* MutableNoCopy(std::nullptr_t);
+
+  // Takes a std::string that is heap-allocated, and takes ownership. The
+  // std::string's destructor is registered with the arena. Used to implement
+  // set_allocated_<field> in generated classes.
+  //
+  // If this field is donated, this method undonates this field by mutating the
+  // `donating_states` according to `mask`.
+  void SetAllocated(const std::string* default_value, std::string* value,
+                    Arena* arena, bool donated, uint32_t* donating_states,
+                    uint32_t mask, MessageLite* msg);
+
+  void SetAllocatedNoArena(const std::string* default_value,
+                           std::string* value);
+
+  // Release returns a std::string* instance that is heap-allocated and is not
+  // Own()'d by any arena. If the field is not set, this returns nullptr. The
+  // caller retains ownership. Clears this field back to nullptr state. Used to
+  // implement release_<field>() methods on generated classes.
+  PROTOBUF_NODISCARD std::string* Release(Arena* arena, bool donated);
+  PROTOBUF_NODISCARD std::string* Release();
+
+  // --------------------------------------------------------
+  // Below functions will be removed in subsequent code change
+  // --------------------------------------------------------
+#ifdef DEPRECATED_METHODS_TO_BE_DELETED
+  PROTOBUF_NODISCARD std::string* Release(const std::string*, Arena* arena,
+                                          bool donated) {
+    return Release(arena, donated);
+  }
+
+  PROTOBUF_NODISCARD std::string* ReleaseNonDefault(const std::string*,
+                                                    Arena* arena) {
+    return Release();
+  }
+
+  std::string* ReleaseNonDefaultNoArena(const std::string* default_value) {
+    return Release();
+  }
+
+  void Set(const std::string*, ConstStringParam value, Arena* arena,
+           bool donated, uint32_t* donating_states, uint32_t mask,
+           MessageLite* msg) {
+    Set(value, arena, donated, donating_states, mask, msg);
+  }
+
+  void Set(const std::string*, std::string&& value, Arena* arena, bool donated,
+           uint32_t* donating_states, uint32_t mask, MessageLite* msg) {
+    Set(std::move(value), arena, donated, donating_states, mask, msg);
+  }
+
+
+  template <typename FirstParam>
+  void Set(FirstParam, const char* str, ::google::protobuf::Arena* arena, bool donated,
+           uint32_t* donating_states, uint32_t mask, MessageLite* msg) {
+    Set(str, arena, donated, donating_states, mask, msg);
+  }
+
+  template <typename FirstParam>
+  void Set(FirstParam p1, const char* str, size_t size, ::google::protobuf::Arena* arena,
+           bool donated, uint32_t* donating_states, uint32_t mask,
+           MessageLite* msg) {
+    Set(str, size, arena, donated, donating_states, mask, msg);
+  }
+
+  template <typename FirstParam, typename RefWrappedType>
+  void Set(FirstParam p1,
+           std::reference_wrapper<RefWrappedType> const_string_ref,
+           ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
+           uint32_t mask, MessageLite* msg) {
+    Set(const_string_ref, arena, donated, donating_states, mask, msg);
+  }
+
+  void SetBytes(const std::string*, ConstStringParam value, Arena* arena,
+                bool donated, uint32_t* donating_states, uint32_t mask,
+                MessageLite* msg) {
+    Set(value, arena, donated, donating_states, mask, msg);
+  }
+
+
+  void SetBytes(const std::string*, std::string&& value, Arena* arena,
+                bool donated, uint32_t* donating_states, uint32_t mask,
+                MessageLite* msg) {
+    Set(std::move(value), arena, donated, donating_states, mask, msg);
+  }
+
+  template <typename FirstParam>
+  void SetBytes(FirstParam p1, const char* str, ::google::protobuf::Arena* arena,
+                bool donated, uint32_t* donating_states, uint32_t mask,
+                MessageLite* msg) {
+    SetBytes(str, arena, donated, donating_states, mask, msg);
+  }
+
+  template <typename FirstParam>
+  void SetBytes(FirstParam p1, const void* p, size_t size,
+                ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
+                uint32_t mask, MessageLite* msg) {
+    SetBytes(p, size, arena, donated, donating_states, mask, msg);
+  }
+
+  template <typename FirstParam, typename RefWrappedType>
+  void SetBytes(FirstParam p1,
+                std::reference_wrapper<RefWrappedType> const_string_ref,
+                ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
+                uint32_t mask, MessageLite* msg) {
+    SetBytes(const_string_ref.get(), arena, donated, donating_states, mask,
+             msg);
+  }
+
+  void SetNoArena(const std::string*, StringPiece value) {
+    SetNoArena(value);
+  }
+  void SetNoArena(const std::string*, std::string&& value) {
+    SetNoArena(std::move(value));
+  }
+
+  std::string* Mutable(ArenaStringPtr::EmptyDefault, Arena* arena, bool donated,
+                       uint32_t* donating_states, uint32_t mask,
+                       MessageLite* msg) {
+    return Mutable(arena, donated, donating_states, mask, msg);
+  }
+
+  PROTOBUF_NDEBUG_INLINE std::string* MutableNoArenaNoDefault(
+      const std::string* /*default_value*/) {
+    return MutableNoCopy(nullptr);
+  }
+
+#endif  // DEPRECATED_METHODS_TO_BE_DELETED
+
+  // Arena-safety semantics: this is guarded by the logic in
+  // Swap()/UnsafeArenaSwap() at the message level, so this method is
+  // 'unsafe' if called directly.
+  inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(
+      InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
+      MessageLite* lhs_msg,  //
+      InlinedStringField* rhs, Arena* rhs_arena, bool rhs_arena_dtor_registered,
+      MessageLite* rhs_msg);
+
+  // Frees storage (if not on an arena).
+  PROTOBUF_NDEBUG_INLINE void Destroy(const std::string* default_value,
+                                      Arena* arena) {
+    if (arena == nullptr) {
+      DestroyNoArena(default_value);
+    }
+  }
+  PROTOBUF_NDEBUG_INLINE void DestroyNoArena(const std::string* default_value);
+
+  // Clears content, but keeps allocated std::string, to avoid the overhead of
+  // heap operations. After this returns, the content (as seen by the user) will
+  // always be the empty std::string.
+  PROTOBUF_NDEBUG_INLINE void ClearToEmpty() { ClearNonDefaultToEmpty(); }
+  PROTOBUF_NDEBUG_INLINE void ClearNonDefaultToEmpty() {
+    get_mutable()->clear();
+  }
+
+  // Clears content, but keeps allocated std::string if arena != nullptr, to
+  // avoid the overhead of heap operations. After this returns, the content (as
+  // seen by the user) will always be equal to |default_value|.
+  void ClearToDefault(const LazyString& default_value, Arena* arena,
+                      bool donated);
+
+  // Generated code / reflection only! Returns a mutable pointer to the string.
+  PROTOBUF_NDEBUG_INLINE std::string* UnsafeMutablePointer();
+
+  // InlinedStringField doesn't have things like the `default_value` pointer in
+  // ArenaStringPtr.
+  static constexpr bool IsDefault() { return false; }
+  static constexpr bool IsDefault(const std::string*) { return false; }
+
+ private:
+  void Destruct() { get_mutable()->~basic_string(); }
+
+  PROTOBUF_NDEBUG_INLINE std::string* get_mutable();
+  PROTOBUF_NDEBUG_INLINE const std::string* get_const() const;
+
+  alignas(std::string) char value_[sizeof(std::string)];
+
+  std::string* MutableSlow(::google::protobuf::Arena* arena, bool donated,
+                           uint32_t* donating_states, uint32_t mask,
+                           MessageLite* msg);
+
+
+  // When constructed in an Arena, we want our destructor to be skipped.
+  friend class ::google::protobuf::Arena;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+};
+
+inline std::string* InlinedStringField::get_mutable() {
+  return reinterpret_cast<std::string*>(&value_);
+}
+
+inline const std::string* InlinedStringField::get_const() const {
+  return reinterpret_cast<const std::string*>(&value_);
+}
+
+inline InlinedStringField::InlinedStringField(
+    const std::string& default_value) {
+  new (get_mutable()) std::string(default_value);
+}
+
+
+inline InlinedStringField::InlinedStringField(Arena* /*arena*/) { Init(); }
+
+inline const std::string& InlinedStringField::GetNoArena() const {
+  return *get_const();
+}
+
+inline void InlinedStringField::SetAllocatedNoArena(
+    const std::string* /*default_value*/, std::string* value) {
+  if (value == nullptr) {
+    // Currently, inlined string field can't have non empty default.
+    get_mutable()->clear();
+  } else {
+    get_mutable()->assign(std::move(*value));
+    delete value;
+  }
+}
+
+inline void InlinedStringField::DestroyNoArena(const std::string*) {
+  // This is invoked from the generated message's ArenaDtor, which is used to
+  // clean up objects not allocated on the Arena.
+  this->~InlinedStringField();
+}
+
+inline void InlinedStringField::SetNoArena(StringPiece value) {
+  get_mutable()->assign(value.data(), value.length());
+}
+
+inline void InlinedStringField::SetNoArena(std::string&& value) {
+  get_mutable()->assign(std::move(value));
+}
+
+// Caller should make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
+inline PROTOBUF_NDEBUG_INLINE void InlinedStringField::InternalSwap(
+    InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
+    MessageLite* lhs_msg,  //
+    InlinedStringField* rhs, Arena* rhs_arena, bool rhs_arena_dtor_registered,
+    MessageLite* rhs_msg) {
+#if GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE
+  lhs->get_mutable()->swap(*rhs->get_mutable());
+  if (!lhs_arena_dtor_registered && rhs_arena_dtor_registered) {
+    lhs_msg->OnDemandRegisterArenaDtor(lhs_arena);
+  } else if (lhs_arena_dtor_registered && !rhs_arena_dtor_registered) {
+    rhs_msg->OnDemandRegisterArenaDtor(rhs_arena);
+  }
+#else
+  (void)lhs_arena;
+  (void)rhs_arena;
+  (void)lhs_arena_dtor_registered;
+  (void)rhs_arena_dtor_registered;
+  (void)lhs_msg;
+  (void)rhs_msg;
+  lhs->get_mutable()->swap(*rhs->get_mutable());
+#endif
+}
+
+inline void InlinedStringField::Set(ConstStringParam value, Arena* arena,
+                                    bool donated, uint32_t* /*donating_states*/,
+                                    uint32_t /*mask*/, MessageLite* /*msg*/) {
+  (void)arena;
+  (void)donated;
+  SetNoArena(value);
+}
+
+inline void InlinedStringField::Set(const char* str, ::google::protobuf::Arena* arena,
+                                    bool donated, uint32_t* donating_states,
+                                    uint32_t mask, MessageLite* msg) {
+  Set(ConstStringParam(str), arena, donated, donating_states, mask, msg);
+}
+
+inline void InlinedStringField::Set(const char* str, size_t size,
+                                    ::google::protobuf::Arena* arena, bool donated,
+                                    uint32_t* donating_states, uint32_t mask,
+                                    MessageLite* msg) {
+  Set(ConstStringParam{str, size}, arena, donated, donating_states, mask, msg);
+}
+
+inline void InlinedStringField::SetBytes(ConstStringParam value, Arena* arena,
+                                         bool donated,
+                                         uint32_t* donating_states,
+                                         uint32_t mask, MessageLite* msg) {
+  Set(value, arena, donated, donating_states, mask, msg);
+}
+
+inline void InlinedStringField::SetBytes(std::string&& value, Arena* arena,
+                                         bool donated,
+                                         uint32_t* donating_states,
+                                         uint32_t mask, MessageLite* msg) {
+  Set(std::move(value), arena, donated, donating_states, mask, msg);
+}
+
+inline void InlinedStringField::SetBytes(const char* str,
+                                         ::google::protobuf::Arena* arena, bool donated,
+                                         uint32_t* donating_states,
+                                         uint32_t mask, MessageLite* msg) {
+  Set(str, arena, donated, donating_states, mask, msg);
+}
+
+inline void InlinedStringField::SetBytes(const void* p, size_t size,
+                                         ::google::protobuf::Arena* arena, bool donated,
+                                         uint32_t* donating_states,
+                                         uint32_t mask, MessageLite* msg) {
+  Set(static_cast<const char*>(p), size, arena, donated, donating_states, mask,
+      msg);
+}
+
+template <typename RefWrappedType>
+inline void InlinedStringField::Set(
+    std::reference_wrapper<RefWrappedType> const_string_ref,
+    ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
+    uint32_t mask, MessageLite* msg) {
+  Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
+}
+
+template <typename RefWrappedType>
+inline void InlinedStringField::SetBytes(
+    std::reference_wrapper<RefWrappedType> const_string_ref,
+    ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
+    uint32_t mask, MessageLite* msg) {
+  Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
+}
+
+inline std::string* InlinedStringField::UnsafeMutablePointer() {
+  return get_mutable();
+}
+
+inline std::string* InlinedStringField::Mutable(std::nullptr_t) {
+  return get_mutable();
+}
+
+inline std::string* InlinedStringField::MutableNoCopy(std::nullptr_t) {
+  return get_mutable();
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_INLINED_STRING_FIELD_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/coded_stream.h b/CAPI/cpp/grpc/include/google/protobuf/io/coded_stream.h
new file mode 100644
index 0000000..c8fc994
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/coded_stream.h
@@ -0,0 +1,1799 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains the CodedInputStream and CodedOutputStream classes,
+// which wrap a ZeroCopyInputStream or ZeroCopyOutputStream, respectively,
+// and allow you to read or write individual pieces of data in various
+// formats.  In particular, these implement the varint encoding for
+// integers, a simple variable-length encoding in which smaller numbers
+// take fewer bytes.
+//
+// Typically these classes will only be used internally by the protocol
+// buffer library in order to encode and decode protocol buffers.  Clients
+// of the library only need to know about this class if they wish to write
+// custom message parsing or serialization procedures.
+//
+// CodedOutputStream example:
+//   // Write some data to "myfile".  First we write a 4-byte "magic number"
+//   // to identify the file type, then write a length-delimited string.  The
+//   // string is composed of a varint giving the length followed by the raw
+//   // bytes.
+//   int fd = open("myfile", O_CREAT | O_WRONLY);
+//   ZeroCopyOutputStream* raw_output = new FileOutputStream(fd);
+//   CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
+//
+//   int magic_number = 1234;
+//   char text[] = "Hello world!";
+//   coded_output->WriteLittleEndian32(magic_number);
+//   coded_output->WriteVarint32(strlen(text));
+//   coded_output->WriteRaw(text, strlen(text));
+//
+//   delete coded_output;
+//   delete raw_output;
+//   close(fd);
+//
+// CodedInputStream example:
+//   // Read a file created by the above code.
+//   int fd = open("myfile", O_RDONLY);
+//   ZeroCopyInputStream* raw_input = new FileInputStream(fd);
+//   CodedInputStream* coded_input = new CodedInputStream(raw_input);
+//
+//   coded_input->ReadLittleEndian32(&magic_number);
+//   if (magic_number != 1234) {
+//     cerr << "File not in expected format." << endl;
+//     return;
+//   }
+//
+//   uint32_t size;
+//   coded_input->ReadVarint32(&size);
+//
+//   char* text = new char[size + 1];
+//   coded_input->ReadRaw(buffer, size);
+//   text[size] = '\0';
+//
+//   delete coded_input;
+//   delete raw_input;
+//   close(fd);
+//
+//   cout << "Text is: " << text << endl;
+//   delete [] text;
+//
+// For those who are interested, varint encoding is defined as follows:
+//
+// The encoding operates on unsigned integers of up to 64 bits in length.
+// Each byte of the encoded value has the format:
+// * bits 0-6: Seven bits of the number being encoded.
+// * bit 7: Zero if this is the last byte in the encoding (in which
+//   case all remaining bits of the number are zero) or 1 if
+//   more bytes follow.
+// The first byte contains the least-significant 7 bits of the number, the
+// second byte (if present) contains the next-least-significant 7 bits,
+// and so on.  So, the binary number 1011000101011 would be encoded in two
+// bytes as "10101011 00101100".
+//
+// In theory, varint could be used to encode integers of any length.
+// However, for practicality we set a limit at 64 bits.  The maximum encoded
+// length of a number is thus 10 bytes.
+
+#ifndef GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
+#define GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
+
+
+#include <assert.h>
+
+#include <atomic>
+#include <climits>
+#include <cstddef>
+#include <cstring>
+#include <limits>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
+// If MSVC has "/RTCc" set, it will complain about truncating casts at
+// runtime.  This file contains some intentional truncating casts.
+#pragma runtime_checks("c", off)
+#endif
+
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/port.h>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class DescriptorPool;
+class MessageFactory;
+class ZeroCopyCodedInputStream;
+
+namespace internal {
+void MapTestForceDeterministic();
+class EpsCopyByteStream;
+}  // namespace internal
+
+namespace io {
+
+// Defined in this file.
+class CodedInputStream;
+class CodedOutputStream;
+
+// Defined in other files.
+class ZeroCopyInputStream;   // zero_copy_stream.h
+class ZeroCopyOutputStream;  // zero_copy_stream.h
+
+// Class which reads and decodes binary data which is composed of varint-
+// encoded integers and fixed-width pieces.  Wraps a ZeroCopyInputStream.
+// Most users will not need to deal with CodedInputStream.
+//
+// Most methods of CodedInputStream that return a bool return false if an
+// underlying I/O error occurs or if the data is malformed.  Once such a
+// failure occurs, the CodedInputStream is broken and is no longer useful.
+// After a failure, callers also should assume writes to "out" args may have
+// occurred, though nothing useful can be determined from those writes.
+class PROTOBUF_EXPORT CodedInputStream {
+ public:
+  // Create a CodedInputStream that reads from the given ZeroCopyInputStream.
+  explicit CodedInputStream(ZeroCopyInputStream* input);
+
+  // Create a CodedInputStream that reads from the given flat array.  This is
+  // faster than using an ArrayInputStream.  PushLimit(size) is implied by
+  // this constructor.
+  explicit CodedInputStream(const uint8_t* buffer, int size);
+
+  // Destroy the CodedInputStream and position the underlying
+  // ZeroCopyInputStream at the first unread byte.  If an error occurred while
+  // reading (causing a method to return false), then the exact position of
+  // the input stream may be anywhere between the last value that was read
+  // successfully and the stream's byte limit.
+  ~CodedInputStream();
+
+  // Return true if this CodedInputStream reads from a flat array instead of
+  // a ZeroCopyInputStream.
+  inline bool IsFlat() const;
+
+  // Skips a number of bytes.  Returns false if an underlying read error
+  // occurs.
+  inline bool Skip(int count);
+
+  // Sets *data to point directly at the unread part of the CodedInputStream's
+  // underlying buffer, and *size to the size of that buffer, but does not
+  // advance the stream's current position.  This will always either produce
+  // a non-empty buffer or return false.  If the caller consumes any of
+  // this data, it should then call Skip() to skip over the consumed bytes.
+  // This may be useful for implementing external fast parsing routines for
+  // types of data not covered by the CodedInputStream interface.
+  bool GetDirectBufferPointer(const void** data, int* size);
+
+  // Like GetDirectBufferPointer, but this method is inlined, and does not
+  // attempt to Refresh() if the buffer is currently empty.
+  PROTOBUF_ALWAYS_INLINE
+  void GetDirectBufferPointerInline(const void** data, int* size);
+
+  // Read raw bytes, copying them into the given buffer.
+  bool ReadRaw(void* buffer, int size);
+
+  // Like ReadRaw, but reads into a string.
+  bool ReadString(std::string* buffer, int size);
+
+
+  // Read a 32-bit little-endian integer.
+  bool ReadLittleEndian32(uint32_t* value);
+  // Read a 64-bit little-endian integer.
+  bool ReadLittleEndian64(uint64_t* value);
+
+  // These methods read from an externally provided buffer. The caller is
+  // responsible for ensuring that the buffer has sufficient space.
+  // Read a 32-bit little-endian integer.
+  static const uint8_t* ReadLittleEndian32FromArray(const uint8_t* buffer,
+                                                    uint32_t* value);
+  // Read a 64-bit little-endian integer.
+  static const uint8_t* ReadLittleEndian64FromArray(const uint8_t* buffer,
+                                                    uint64_t* value);
+
+  // Read an unsigned integer with Varint encoding, truncating to 32 bits.
+  // Reading a 32-bit value is equivalent to reading a 64-bit one and casting
+  // it to uint32_t, but may be more efficient.
+  bool ReadVarint32(uint32_t* value);
+  // Read an unsigned integer with Varint encoding.
+  bool ReadVarint64(uint64_t* value);
+
+  // Reads a varint off the wire into an "int". This should be used for reading
+  // sizes off the wire (sizes of strings, submessages, bytes fields, etc).
+  //
+  // The value from the wire is interpreted as unsigned.  If its value exceeds
+  // the representable value of an integer on this platform, instead of
+  // truncating we return false. Truncating (as performed by ReadVarint32()
+  // above) is an acceptable approach for fields representing an integer, but
+  // when we are parsing a size from the wire, truncating the value would result
+  // in us misparsing the payload.
+  bool ReadVarintSizeAsInt(int* value);
+
+  // Read a tag.  This calls ReadVarint32() and returns the result, or returns
+  // zero (which is not a valid tag) if ReadVarint32() fails.  Also, ReadTag
+  // (but not ReadTagNoLastTag) updates the last tag value, which can be checked
+  // with LastTagWas().
+  //
+  // Always inline because this is only called in one place per parse loop
+  // but it is called for every iteration of said loop, so it should be fast.
+  // GCC doesn't want to inline this by default.
+  PROTOBUF_ALWAYS_INLINE uint32_t ReadTag() {
+    return last_tag_ = ReadTagNoLastTag();
+  }
+
+  PROTOBUF_ALWAYS_INLINE uint32_t ReadTagNoLastTag();
+
+  // This usually a faster alternative to ReadTag() when cutoff is a manifest
+  // constant.  It does particularly well for cutoff >= 127.  The first part
+  // of the return value is the tag that was read, though it can also be 0 in
+  // the cases where ReadTag() would return 0.  If the second part is true
+  // then the tag is known to be in [0, cutoff].  If not, the tag either is
+  // above cutoff or is 0.  (There's intentional wiggle room when tag is 0,
+  // because that can arise in several ways, and for best performance we want
+  // to avoid an extra "is tag == 0?" check here.)
+  PROTOBUF_ALWAYS_INLINE
+  std::pair<uint32_t, bool> ReadTagWithCutoff(uint32_t cutoff) {
+    std::pair<uint32_t, bool> result = ReadTagWithCutoffNoLastTag(cutoff);
+    last_tag_ = result.first;
+    return result;
+  }
+
+  PROTOBUF_ALWAYS_INLINE
+  std::pair<uint32_t, bool> ReadTagWithCutoffNoLastTag(uint32_t cutoff);
+
+  // Usually returns true if calling ReadVarint32() now would produce the given
+  // value.  Will always return false if ReadVarint32() would not return the
+  // given value.  If ExpectTag() returns true, it also advances past
+  // the varint.  For best performance, use a compile-time constant as the
+  // parameter.
+  // Always inline because this collapses to a small number of instructions
+  // when given a constant parameter, but GCC doesn't want to inline by default.
+  PROTOBUF_ALWAYS_INLINE bool ExpectTag(uint32_t expected);
+
+  // Like above, except this reads from the specified buffer. The caller is
+  // responsible for ensuring that the buffer is large enough to read a varint
+  // of the expected size. For best performance, use a compile-time constant as
+  // the expected tag parameter.
+  //
+  // Returns a pointer beyond the expected tag if it was found, or NULL if it
+  // was not.
+  PROTOBUF_ALWAYS_INLINE
+  static const uint8_t* ExpectTagFromArray(const uint8_t* buffer,
+                                           uint32_t expected);
+
+  // Usually returns true if no more bytes can be read.  Always returns false
+  // if more bytes can be read.  If ExpectAtEnd() returns true, a subsequent
+  // call to LastTagWas() will act as if ReadTag() had been called and returned
+  // zero, and ConsumedEntireMessage() will return true.
+  bool ExpectAtEnd();
+
+  // If the last call to ReadTag() or ReadTagWithCutoff() returned the given
+  // value, returns true.  Otherwise, returns false.
+  // ReadTagNoLastTag/ReadTagWithCutoffNoLastTag do not preserve the last
+  // returned value.
+  //
+  // This is needed because parsers for some types of embedded messages
+  // (with field type TYPE_GROUP) don't actually know that they've reached the
+  // end of a message until they see an ENDGROUP tag, which was actually part
+  // of the enclosing message.  The enclosing message would like to check that
+  // tag to make sure it had the right number, so it calls LastTagWas() on
+  // return from the embedded parser to check.
+  bool LastTagWas(uint32_t expected);
+  void SetLastTag(uint32_t tag) { last_tag_ = tag; }
+
+  // When parsing message (but NOT a group), this method must be called
+  // immediately after MergeFromCodedStream() returns (if it returns true)
+  // to further verify that the message ended in a legitimate way.  For
+  // example, this verifies that parsing did not end on an end-group tag.
+  // It also checks for some cases where, due to optimizations,
+  // MergeFromCodedStream() can incorrectly return true.
+  bool ConsumedEntireMessage();
+  void SetConsumed() { legitimate_message_end_ = true; }
+
+  // Limits ----------------------------------------------------------
+  // Limits are used when parsing length-delimited embedded messages.
+  // After the message's length is read, PushLimit() is used to prevent
+  // the CodedInputStream from reading beyond that length.  Once the
+  // embedded message has been parsed, PopLimit() is called to undo the
+  // limit.
+
+  // Opaque type used with PushLimit() and PopLimit().  Do not modify
+  // values of this type yourself.  The only reason that this isn't a
+  // struct with private internals is for efficiency.
+  typedef int Limit;
+
+  // Places a limit on the number of bytes that the stream may read,
+  // starting from the current position.  Once the stream hits this limit,
+  // it will act like the end of the input has been reached until PopLimit()
+  // is called.
+  //
+  // As the names imply, the stream conceptually has a stack of limits.  The
+  // shortest limit on the stack is always enforced, even if it is not the
+  // top limit.
+  //
+  // The value returned by PushLimit() is opaque to the caller, and must
+  // be passed unchanged to the corresponding call to PopLimit().
+  Limit PushLimit(int byte_limit);
+
+  // Pops the last limit pushed by PushLimit().  The input must be the value
+  // returned by that call to PushLimit().
+  void PopLimit(Limit limit);
+
+  // Returns the number of bytes left until the nearest limit on the
+  // stack is hit, or -1 if no limits are in place.
+  int BytesUntilLimit() const;
+
+  // Returns current position relative to the beginning of the input stream.
+  int CurrentPosition() const;
+
+  // Total Bytes Limit -----------------------------------------------
+  // To prevent malicious users from sending excessively large messages
+  // and causing memory exhaustion, CodedInputStream imposes a hard limit on
+  // the total number of bytes it will read.
+
+  // Sets the maximum number of bytes that this CodedInputStream will read
+  // before refusing to continue.  To prevent servers from allocating enormous
+  // amounts of memory to hold parsed messages, the maximum message length
+  // should be limited to the shortest length that will not harm usability.
+  // The default limit is INT_MAX (~2GB) and apps should set shorter limits
+  // if possible. An error will always be printed to stderr if the limit is
+  // reached.
+  //
+  // Note: setting a limit less than the current read position is interpreted
+  // as a limit on the current position.
+  //
+  // This is unrelated to PushLimit()/PopLimit().
+  void SetTotalBytesLimit(int total_bytes_limit);
+
+  // The Total Bytes Limit minus the Current Position, or -1 if the total bytes
+  // limit is INT_MAX.
+  int BytesUntilTotalBytesLimit() const;
+
+  // Recursion Limit -------------------------------------------------
+  // To prevent corrupt or malicious messages from causing stack overflows,
+  // we must keep track of the depth of recursion when parsing embedded
+  // messages and groups.  CodedInputStream keeps track of this because it
+  // is the only object that is passed down the stack during parsing.
+
+  // Sets the maximum recursion depth.  The default is 100.
+  void SetRecursionLimit(int limit);
+  int RecursionBudget() { return recursion_budget_; }
+
+  static int GetDefaultRecursionLimit() { return default_recursion_limit_; }
+
+  // Increments the current recursion depth.  Returns true if the depth is
+  // under the limit, false if it has gone over.
+  bool IncrementRecursionDepth();
+
+  // Decrements the recursion depth if possible.
+  void DecrementRecursionDepth();
+
+  // Decrements the recursion depth blindly.  This is faster than
+  // DecrementRecursionDepth().  It should be used only if all previous
+  // increments to recursion depth were successful.
+  void UnsafeDecrementRecursionDepth();
+
+  // Shorthand for make_pair(PushLimit(byte_limit), --recursion_budget_).
+  // Using this can reduce code size and complexity in some cases.  The caller
+  // is expected to check that the second part of the result is non-negative (to
+  // bail out if the depth of recursion is too high) and, if all is well, to
+  // later pass the first part of the result to PopLimit() or similar.
+  std::pair<CodedInputStream::Limit, int> IncrementRecursionDepthAndPushLimit(
+      int byte_limit);
+
+  // Shorthand for PushLimit(ReadVarint32(&length) ? length : 0).
+  Limit ReadLengthAndPushLimit();
+
+  // Helper that is equivalent to: {
+  //  bool result = ConsumedEntireMessage();
+  //  PopLimit(limit);
+  //  UnsafeDecrementRecursionDepth();
+  //  return result; }
+  // Using this can reduce code size and complexity in some cases.
+  // Do not use unless the current recursion depth is greater than zero.
+  bool DecrementRecursionDepthAndPopLimit(Limit limit);
+
+  // Helper that is equivalent to: {
+  //  bool result = ConsumedEntireMessage();
+  //  PopLimit(limit);
+  //  return result; }
+  // Using this can reduce code size and complexity in some cases.
+  bool CheckEntireMessageConsumedAndPopLimit(Limit limit);
+
+  // Extension Registry ----------------------------------------------
+  // ADVANCED USAGE:  99.9% of people can ignore this section.
+  //
+  // By default, when parsing extensions, the parser looks for extension
+  // definitions in the pool which owns the outer message's Descriptor.
+  // However, you may call SetExtensionRegistry() to provide an alternative
+  // pool instead.  This makes it possible, for example, to parse a message
+  // using a generated class, but represent some extensions using
+  // DynamicMessage.
+
+  // Set the pool used to look up extensions.  Most users do not need to call
+  // this as the correct pool will be chosen automatically.
+  //
+  // WARNING:  It is very easy to misuse this.  Carefully read the requirements
+  //   below.  Do not use this unless you are sure you need it.  Almost no one
+  //   does.
+  //
+  // Let's say you are parsing a message into message object m, and you want
+  // to take advantage of SetExtensionRegistry().  You must follow these
+  // requirements:
+  //
+  // The given DescriptorPool must contain m->GetDescriptor().  It is not
+  // sufficient for it to simply contain a descriptor that has the same name
+  // and content -- it must be the *exact object*.  In other words:
+  //   assert(pool->FindMessageTypeByName(m->GetDescriptor()->full_name()) ==
+  //          m->GetDescriptor());
+  // There are two ways to satisfy this requirement:
+  // 1) Use m->GetDescriptor()->pool() as the pool.  This is generally useless
+  //    because this is the pool that would be used anyway if you didn't call
+  //    SetExtensionRegistry() at all.
+  // 2) Use a DescriptorPool which has m->GetDescriptor()->pool() as an
+  //    "underlay".  Read the documentation for DescriptorPool for more
+  //    information about underlays.
+  //
+  // You must also provide a MessageFactory.  This factory will be used to
+  // construct Message objects representing extensions.  The factory's
+  // GetPrototype() MUST return non-NULL for any Descriptor which can be found
+  // through the provided pool.
+  //
+  // If the provided factory might return instances of protocol-compiler-
+  // generated (i.e. compiled-in) types, or if the outer message object m is
+  // a generated type, then the given factory MUST have this property:  If
+  // GetPrototype() is given a Descriptor which resides in
+  // DescriptorPool::generated_pool(), the factory MUST return the same
+  // prototype which MessageFactory::generated_factory() would return.  That
+  // is, given a descriptor for a generated type, the factory must return an
+  // instance of the generated class (NOT DynamicMessage).  However, when
+  // given a descriptor for a type that is NOT in generated_pool, the factory
+  // is free to return any implementation.
+  //
+  // The reason for this requirement is that generated sub-objects may be
+  // accessed via the standard (non-reflection) extension accessor methods,
+  // and these methods will down-cast the object to the generated class type.
+  // If the object is not actually of that type, the results would be undefined.
+  // On the other hand, if an extension is not compiled in, then there is no
+  // way the code could end up accessing it via the standard accessors -- the
+  // only way to access the extension is via reflection.  When using reflection,
+  // DynamicMessage and generated messages are indistinguishable, so it's fine
+  // if these objects are represented using DynamicMessage.
+  //
+  // Using DynamicMessageFactory on which you have called
+  // SetDelegateToGeneratedFactory(true) should be sufficient to satisfy the
+  // above requirement.
+  //
+  // If either pool or factory is NULL, both must be NULL.
+  //
+  // Note that this feature is ignored when parsing "lite" messages as they do
+  // not have descriptors.
+  void SetExtensionRegistry(const DescriptorPool* pool,
+                            MessageFactory* factory);
+
+  // Get the DescriptorPool set via SetExtensionRegistry(), or NULL if no pool
+  // has been provided.
+  const DescriptorPool* GetExtensionPool();
+
+  // Get the MessageFactory set via SetExtensionRegistry(), or NULL if no
+  // factory has been provided.
+  MessageFactory* GetExtensionFactory();
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedInputStream);
+
+  const uint8_t* buffer_;
+  const uint8_t* buffer_end_;  // pointer to the end of the buffer.
+  ZeroCopyInputStream* input_;
+  int total_bytes_read_;  // total bytes read from input_, including
+                          // the current buffer
+
+  // If total_bytes_read_ surpasses INT_MAX, we record the extra bytes here
+  // so that we can BackUp() on destruction.
+  int overflow_bytes_;
+
+  // LastTagWas() stuff.
+  uint32_t last_tag_;  // result of last ReadTag() or ReadTagWithCutoff().
+
+  // This is set true by ReadTag{Fallback/Slow}() if it is called when exactly
+  // at EOF, or by ExpectAtEnd() when it returns true.  This happens when we
+  // reach the end of a message and attempt to read another tag.
+  bool legitimate_message_end_;
+
+  // See EnableAliasing().
+  bool aliasing_enabled_;
+
+  // Limits
+  Limit current_limit_;  // if position = -1, no limit is applied
+
+  // For simplicity, if the current buffer crosses a limit (either a normal
+  // limit created by PushLimit() or the total bytes limit), buffer_size_
+  // only tracks the number of bytes before that limit.  This field
+  // contains the number of bytes after it.  Note that this implies that if
+  // buffer_size_ == 0 and buffer_size_after_limit_ > 0, we know we've
+  // hit a limit.  However, if both are zero, it doesn't necessarily mean
+  // we aren't at a limit -- the buffer may have ended exactly at the limit.
+  int buffer_size_after_limit_;
+
+  // Maximum number of bytes to read, period.  This is unrelated to
+  // current_limit_.  Set using SetTotalBytesLimit().
+  int total_bytes_limit_;
+
+  // Current recursion budget, controlled by IncrementRecursionDepth() and
+  // similar.  Starts at recursion_limit_ and goes down: if this reaches
+  // -1 we are over budget.
+  int recursion_budget_;
+  // Recursion depth limit, set by SetRecursionLimit().
+  int recursion_limit_;
+
+  // See SetExtensionRegistry().
+  const DescriptorPool* extension_pool_;
+  MessageFactory* extension_factory_;
+
+  // Private member functions.
+
+  // Fallback when Skip() goes past the end of the current buffer.
+  bool SkipFallback(int count, int original_buffer_size);
+
+  // Advance the buffer by a given number of bytes.
+  void Advance(int amount);
+
+  // Back up input_ to the current buffer position.
+  void BackUpInputToCurrentPosition();
+
+  // Recomputes the value of buffer_size_after_limit_.  Must be called after
+  // current_limit_ or total_bytes_limit_ changes.
+  void RecomputeBufferLimits();
+
+  // Writes an error message saying that we hit total_bytes_limit_.
+  void PrintTotalBytesLimitError();
+
+  // Called when the buffer runs out to request more data.  Implies an
+  // Advance(BufferSize()).
+  bool Refresh();
+
+  // When parsing varints, we optimize for the common case of small values, and
+  // then optimize for the case when the varint fits within the current buffer
+  // piece. The Fallback method is used when we can't use the one-byte
+  // optimization. The Slow method is yet another fallback when the buffer is
+  // not large enough. Making the slow path out-of-line speeds up the common
+  // case by 10-15%. The slow path is fairly uncommon: it only triggers when a
+  // message crosses multiple buffers.  Note: ReadVarint32Fallback() and
+  // ReadVarint64Fallback() are called frequently and generally not inlined, so
+  // they have been optimized to avoid "out" parameters.  The former returns -1
+  // if it fails and the uint32_t it read otherwise.  The latter has a bool
+  // indicating success or failure as part of its return type.
+  int64_t ReadVarint32Fallback(uint32_t first_byte_or_zero);
+  int ReadVarintSizeAsIntFallback();
+  std::pair<uint64_t, bool> ReadVarint64Fallback();
+  bool ReadVarint32Slow(uint32_t* value);
+  bool ReadVarint64Slow(uint64_t* value);
+  int ReadVarintSizeAsIntSlow();
+  bool ReadLittleEndian32Fallback(uint32_t* value);
+  bool ReadLittleEndian64Fallback(uint64_t* value);
+
+  // Fallback/slow methods for reading tags. These do not update last_tag_,
+  // but will set legitimate_message_end_ if we are at the end of the input
+  // stream.
+  uint32_t ReadTagFallback(uint32_t first_byte_or_zero);
+  uint32_t ReadTagSlow();
+  bool ReadStringFallback(std::string* buffer, int size);
+
+  // Return the size of the buffer.
+  int BufferSize() const;
+
+  static const int kDefaultTotalBytesLimit = INT_MAX;
+
+  static int default_recursion_limit_;  // 100 by default.
+
+  friend class google::protobuf::ZeroCopyCodedInputStream;
+  friend class google::protobuf::internal::EpsCopyByteStream;
+};
+
+// EpsCopyOutputStream wraps a ZeroCopyOutputStream and exposes a new stream,
+// which has the property you can write kSlopBytes (16 bytes) from the current
+// position without bounds checks. The cursor into the stream is managed by
+// the user of the class and is an explicit parameter in the methods. Careful
+// use of this class, ie. keep ptr a local variable, eliminates the need to
+// for the compiler to sync the ptr value between register and memory.
+class PROTOBUF_EXPORT EpsCopyOutputStream {
+ public:
+  enum { kSlopBytes = 16 };
+
+  // Initialize from a stream.
+  EpsCopyOutputStream(ZeroCopyOutputStream* stream, bool deterministic,
+                      uint8_t** pp)
+      : end_(buffer_),
+        stream_(stream),
+        is_serialization_deterministic_(deterministic) {
+    *pp = buffer_;
+  }
+
+  // Only for array serialization. No overflow protection, end_ will be the
+  // pointed to the end of the array. When using this the total size is already
+  // known, so no need to maintain the slop region.
+  EpsCopyOutputStream(void* data, int size, bool deterministic)
+      : end_(static_cast<uint8_t*>(data) + size),
+        buffer_end_(nullptr),
+        stream_(nullptr),
+        is_serialization_deterministic_(deterministic) {}
+
+  // Initialize from stream but with the first buffer already given (eager).
+  EpsCopyOutputStream(void* data, int size, ZeroCopyOutputStream* stream,
+                      bool deterministic, uint8_t** pp)
+      : stream_(stream), is_serialization_deterministic_(deterministic) {
+    *pp = SetInitialBuffer(data, size);
+  }
+
+  // Flush everything that's written into the underlying ZeroCopyOutputStream
+  // and trims the underlying stream to the location of ptr.
+  uint8_t* Trim(uint8_t* ptr);
+
+  // After this it's guaranteed you can safely write kSlopBytes to ptr. This
+  // will never fail! The underlying stream can produce an error. Use HadError
+  // to check for errors.
+  PROTOBUF_NODISCARD uint8_t* EnsureSpace(uint8_t* ptr) {
+    if (PROTOBUF_PREDICT_FALSE(ptr >= end_)) {
+      return EnsureSpaceFallback(ptr);
+    }
+    return ptr;
+  }
+
+  uint8_t* WriteRaw(const void* data, int size, uint8_t* ptr) {
+    if (PROTOBUF_PREDICT_FALSE(end_ - ptr < size)) {
+      return WriteRawFallback(data, size, ptr);
+    }
+    std::memcpy(ptr, data, size);
+    return ptr + size;
+  }
+  // Writes the buffer specified by data, size to the stream. Possibly by
+  // aliasing the buffer (ie. not copying the data). The caller is responsible
+  // to make sure the buffer is alive for the duration of the
+  // ZeroCopyOutputStream.
+#ifndef NDEBUG
+  PROTOBUF_NOINLINE
+#endif
+  uint8_t* WriteRawMaybeAliased(const void* data, int size, uint8_t* ptr) {
+    if (aliasing_enabled_) {
+      return WriteAliasedRaw(data, size, ptr);
+    } else {
+      return WriteRaw(data, size, ptr);
+    }
+  }
+
+
+#ifndef NDEBUG
+  PROTOBUF_NOINLINE
+#endif
+  uint8_t* WriteStringMaybeAliased(uint32_t num, const std::string& s,
+                                   uint8_t* ptr) {
+    std::ptrdiff_t size = s.size();
+    if (PROTOBUF_PREDICT_FALSE(
+            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
+      return WriteStringMaybeAliasedOutline(num, s, ptr);
+    }
+    ptr = UnsafeVarint((num << 3) | 2, ptr);
+    *ptr++ = static_cast<uint8_t>(size);
+    std::memcpy(ptr, s.data(), size);
+    return ptr + size;
+  }
+  uint8_t* WriteBytesMaybeAliased(uint32_t num, const std::string& s,
+                                  uint8_t* ptr) {
+    return WriteStringMaybeAliased(num, s, ptr);
+  }
+
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteString(uint32_t num, const T& s,
+                                              uint8_t* ptr) {
+    std::ptrdiff_t size = s.size();
+    if (PROTOBUF_PREDICT_FALSE(
+            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
+      return WriteStringOutline(num, s, ptr);
+    }
+    ptr = UnsafeVarint((num << 3) | 2, ptr);
+    *ptr++ = static_cast<uint8_t>(size);
+    std::memcpy(ptr, s.data(), size);
+    return ptr + size;
+  }
+  template <typename T>
+#ifndef NDEBUG
+  PROTOBUF_NOINLINE
+#endif
+  uint8_t* WriteBytes(uint32_t num, const T& s, uint8_t* ptr) {
+    return WriteString(num, s, ptr);
+  }
+
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteInt32Packed(int num, const T& r,
+                                                   int size, uint8_t* ptr) {
+    return WriteVarintPacked(num, r, size, ptr, Encode64);
+  }
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteUInt32Packed(int num, const T& r,
+                                                    int size, uint8_t* ptr) {
+    return WriteVarintPacked(num, r, size, ptr, Encode32);
+  }
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteSInt32Packed(int num, const T& r,
+                                                    int size, uint8_t* ptr) {
+    return WriteVarintPacked(num, r, size, ptr, ZigZagEncode32);
+  }
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteInt64Packed(int num, const T& r,
+                                                   int size, uint8_t* ptr) {
+    return WriteVarintPacked(num, r, size, ptr, Encode64);
+  }
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteUInt64Packed(int num, const T& r,
+                                                    int size, uint8_t* ptr) {
+    return WriteVarintPacked(num, r, size, ptr, Encode64);
+  }
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteSInt64Packed(int num, const T& r,
+                                                    int size, uint8_t* ptr) {
+    return WriteVarintPacked(num, r, size, ptr, ZigZagEncode64);
+  }
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteEnumPacked(int num, const T& r, int size,
+                                                  uint8_t* ptr) {
+    return WriteVarintPacked(num, r, size, ptr, Encode64);
+  }
+
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteFixedPacked(int num, const T& r,
+                                                   uint8_t* ptr) {
+    ptr = EnsureSpace(ptr);
+    constexpr auto element_size = sizeof(typename T::value_type);
+    auto size = r.size() * element_size;
+    ptr = WriteLengthDelim(num, size, ptr);
+    return WriteRawLittleEndian<element_size>(r.data(), static_cast<int>(size),
+                                              ptr);
+  }
+
+  // Returns true if there was an underlying I/O error since this object was
+  // created.
+  bool HadError() const { return had_error_; }
+
+  // Instructs the EpsCopyOutputStream to allow the underlying
+  // ZeroCopyOutputStream to hold pointers to the original structure instead of
+  // copying, if it supports it (i.e. output->AllowsAliasing() is true).  If the
+  // underlying stream does not support aliasing, then enabling it has no
+  // affect.  For now, this only affects the behavior of
+  // WriteRawMaybeAliased().
+  //
+  // NOTE: It is caller's responsibility to ensure that the chunk of memory
+  // remains live until all of the data has been consumed from the stream.
+  void EnableAliasing(bool enabled);
+
+  // See documentation on CodedOutputStream::SetSerializationDeterministic.
+  void SetSerializationDeterministic(bool value) {
+    is_serialization_deterministic_ = value;
+  }
+
+  // See documentation on CodedOutputStream::IsSerializationDeterministic.
+  bool IsSerializationDeterministic() const {
+    return is_serialization_deterministic_;
+  }
+
+  // The number of bytes written to the stream at position ptr, relative to the
+  // stream's overall position.
+  int64_t ByteCount(uint8_t* ptr) const;
+
+
+ private:
+  uint8_t* end_;
+  uint8_t* buffer_end_ = buffer_;
+  uint8_t buffer_[2 * kSlopBytes];
+  ZeroCopyOutputStream* stream_;
+  bool had_error_ = false;
+  bool aliasing_enabled_ = false;  // See EnableAliasing().
+  bool is_serialization_deterministic_;
+  bool skip_check_consistency = false;
+
+  uint8_t* EnsureSpaceFallback(uint8_t* ptr);
+  inline uint8_t* Next();
+  int Flush(uint8_t* ptr);
+  std::ptrdiff_t GetSize(uint8_t* ptr) const {
+    GOOGLE_DCHECK(ptr <= end_ + kSlopBytes);  // NOLINT
+    return end_ + kSlopBytes - ptr;
+  }
+
+  uint8_t* Error() {
+    had_error_ = true;
+    // We use the patch buffer to always guarantee space to write to.
+    end_ = buffer_ + kSlopBytes;
+    return buffer_;
+  }
+
+  static constexpr int TagSize(uint32_t tag) {
+    return (tag < (1 << 7))    ? 1
+           : (tag < (1 << 14)) ? 2
+           : (tag < (1 << 21)) ? 3
+           : (tag < (1 << 28)) ? 4
+                               : 5;
+  }
+
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteTag(uint32_t num, uint32_t wt,
+                                           uint8_t* ptr) {
+    GOOGLE_DCHECK(ptr < end_);  // NOLINT
+    return UnsafeVarint((num << 3) | wt, ptr);
+  }
+
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteLengthDelim(int num, uint32_t size,
+                                                   uint8_t* ptr) {
+    ptr = WriteTag(num, 2, ptr);
+    return UnsafeWriteSize(size, ptr);
+  }
+
+  uint8_t* WriteRawFallback(const void* data, int size, uint8_t* ptr);
+
+  uint8_t* WriteAliasedRaw(const void* data, int size, uint8_t* ptr);
+
+  uint8_t* WriteStringMaybeAliasedOutline(uint32_t num, const std::string& s,
+                                          uint8_t* ptr);
+  uint8_t* WriteStringOutline(uint32_t num, const std::string& s, uint8_t* ptr);
+
+  template <typename T, typename E>
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteVarintPacked(int num, const T& r,
+                                                    int size, uint8_t* ptr,
+                                                    const E& encode) {
+    ptr = EnsureSpace(ptr);
+    ptr = WriteLengthDelim(num, size, ptr);
+    auto it = r.data();
+    auto end = it + r.size();
+    do {
+      ptr = EnsureSpace(ptr);
+      ptr = UnsafeVarint(encode(*it++), ptr);
+    } while (it < end);
+    return ptr;
+  }
+
+  static uint32_t Encode32(uint32_t v) { return v; }
+  static uint64_t Encode64(uint64_t v) { return v; }
+  static uint32_t ZigZagEncode32(int32_t v) {
+    return (static_cast<uint32_t>(v) << 1) ^ static_cast<uint32_t>(v >> 31);
+  }
+  static uint64_t ZigZagEncode64(int64_t v) {
+    return (static_cast<uint64_t>(v) << 1) ^ static_cast<uint64_t>(v >> 63);
+  }
+
+  template <typename T>
+  PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeVarint(T value, uint8_t* ptr) {
+    static_assert(std::is_unsigned<T>::value,
+                  "Varint serialization must be unsigned");
+    ptr[0] = static_cast<uint8_t>(value);
+    if (value < 0x80) {
+      return ptr + 1;
+    }
+    // Turn on continuation bit in the byte we just wrote.
+    ptr[0] |= static_cast<uint8_t>(0x80);
+    value >>= 7;
+    ptr[1] = static_cast<uint8_t>(value);
+    if (value < 0x80) {
+      return ptr + 2;
+    }
+    ptr += 2;
+    do {
+      // Turn on continuation bit in the byte we just wrote.
+      ptr[-1] |= static_cast<uint8_t>(0x80);
+      value >>= 7;
+      *ptr = static_cast<uint8_t>(value);
+      ++ptr;
+    } while (value >= 0x80);
+    return ptr;
+  }
+
+  PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeWriteSize(uint32_t value,
+                                                         uint8_t* ptr) {
+    while (PROTOBUF_PREDICT_FALSE(value >= 0x80)) {
+      *ptr = static_cast<uint8_t>(value | 0x80);
+      value >>= 7;
+      ++ptr;
+    }
+    *ptr++ = static_cast<uint8_t>(value);
+    return ptr;
+  }
+
+  template <int S>
+  uint8_t* WriteRawLittleEndian(const void* data, int size, uint8_t* ptr);
+#if !defined(PROTOBUF_LITTLE_ENDIAN) || \
+    defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  uint8_t* WriteRawLittleEndian32(const void* data, int size, uint8_t* ptr);
+  uint8_t* WriteRawLittleEndian64(const void* data, int size, uint8_t* ptr);
+#endif
+
+  // These methods are for CodedOutputStream. Ideally they should be private
+  // but to match current behavior of CodedOutputStream as close as possible
+  // we allow it some functionality.
+ public:
+  uint8_t* SetInitialBuffer(void* data, int size) {
+    auto ptr = static_cast<uint8_t*>(data);
+    if (size > kSlopBytes) {
+      end_ = ptr + size - kSlopBytes;
+      buffer_end_ = nullptr;
+      return ptr;
+    } else {
+      end_ = buffer_ + size;
+      buffer_end_ = ptr;
+      return buffer_;
+    }
+  }
+
+ private:
+  // Needed by CodedOutputStream HadError. HadError needs to flush the patch
+  // buffers to ensure there is no error as of yet.
+  uint8_t* FlushAndResetBuffer(uint8_t*);
+
+  // The following functions mimic the old CodedOutputStream behavior as close
+  // as possible. They flush the current state to the stream, behave as
+  // the old CodedOutputStream and then return to normal operation.
+  bool Skip(int count, uint8_t** pp);
+  bool GetDirectBufferPointer(void** data, int* size, uint8_t** pp);
+  uint8_t* GetDirectBufferForNBytesAndAdvance(int size, uint8_t** pp);
+
+  friend class CodedOutputStream;
+};
+
+template <>
+inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<1>(const void* data,
+                                                             int size,
+                                                             uint8_t* ptr) {
+  return WriteRaw(data, size, ptr);
+}
+template <>
+inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<4>(const void* data,
+                                                             int size,
+                                                             uint8_t* ptr) {
+#if defined(PROTOBUF_LITTLE_ENDIAN) && \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  return WriteRaw(data, size, ptr);
+#else
+  return WriteRawLittleEndian32(data, size, ptr);
+#endif
+}
+template <>
+inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<8>(const void* data,
+                                                             int size,
+                                                             uint8_t* ptr) {
+#if defined(PROTOBUF_LITTLE_ENDIAN) && \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  return WriteRaw(data, size, ptr);
+#else
+  return WriteRawLittleEndian64(data, size, ptr);
+#endif
+}
+
+// Class which encodes and writes binary data which is composed of varint-
+// encoded integers and fixed-width pieces.  Wraps a ZeroCopyOutputStream.
+// Most users will not need to deal with CodedOutputStream.
+//
+// Most methods of CodedOutputStream which return a bool return false if an
+// underlying I/O error occurs.  Once such a failure occurs, the
+// CodedOutputStream is broken and is no longer useful. The Write* methods do
+// not return the stream status, but will invalidate the stream if an error
+// occurs. The client can probe HadError() to determine the status.
+//
+// Note that every method of CodedOutputStream which writes some data has
+// a corresponding static "ToArray" version. These versions write directly
+// to the provided buffer, returning a pointer past the last written byte.
+// They require that the buffer has sufficient capacity for the encoded data.
+// This allows an optimization where we check if an output stream has enough
+// space for an entire message before we start writing and, if there is, we
+// call only the ToArray methods to avoid doing bound checks for each
+// individual value.
+// i.e., in the example above:
+//
+//   CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
+//   int magic_number = 1234;
+//   char text[] = "Hello world!";
+//
+//   int coded_size = sizeof(magic_number) +
+//                    CodedOutputStream::VarintSize32(strlen(text)) +
+//                    strlen(text);
+//
+//   uint8_t* buffer =
+//       coded_output->GetDirectBufferForNBytesAndAdvance(coded_size);
+//   if (buffer != nullptr) {
+//     // The output stream has enough space in the buffer: write directly to
+//     // the array.
+//     buffer = CodedOutputStream::WriteLittleEndian32ToArray(magic_number,
+//                                                            buffer);
+//     buffer = CodedOutputStream::WriteVarint32ToArray(strlen(text), buffer);
+//     buffer = CodedOutputStream::WriteRawToArray(text, strlen(text), buffer);
+//   } else {
+//     // Make bound-checked writes, which will ask the underlying stream for
+//     // more space as needed.
+//     coded_output->WriteLittleEndian32(magic_number);
+//     coded_output->WriteVarint32(strlen(text));
+//     coded_output->WriteRaw(text, strlen(text));
+//   }
+//
+//   delete coded_output;
+class PROTOBUF_EXPORT CodedOutputStream {
+ public:
+  // Creates a CodedOutputStream that writes to the given `stream`.
+  // The provided stream must publicly derive from `ZeroCopyOutputStream`.
+  template <class Stream, class = typename std::enable_if<std::is_base_of<
+                              ZeroCopyOutputStream, Stream>::value>::type>
+  explicit CodedOutputStream(Stream* stream);
+
+  // Creates a CodedOutputStream that writes to the given `stream`, and does
+  // an 'eager initialization' of the internal state if `eager_init` is true.
+  // The provided stream must publicly derive from `ZeroCopyOutputStream`.
+  template <class Stream, class = typename std::enable_if<std::is_base_of<
+                              ZeroCopyOutputStream, Stream>::value>::type>
+  CodedOutputStream(Stream* stream, bool eager_init);
+
+  // Destroy the CodedOutputStream and position the underlying
+  // ZeroCopyOutputStream immediately after the last byte written.
+  ~CodedOutputStream();
+
+  // Returns true if there was an underlying I/O error since this object was
+  // created. On should call Trim before this function in order to catch all
+  // errors.
+  bool HadError() {
+    cur_ = impl_.FlushAndResetBuffer(cur_);
+    GOOGLE_DCHECK(cur_);
+    return impl_.HadError();
+  }
+
+  // Trims any unused space in the underlying buffer so that its size matches
+  // the number of bytes written by this stream. The underlying buffer will
+  // automatically be trimmed when this stream is destroyed; this call is only
+  // necessary if the underlying buffer is accessed *before* the stream is
+  // destroyed.
+  void Trim() { cur_ = impl_.Trim(cur_); }
+
+  // Skips a number of bytes, leaving the bytes unmodified in the underlying
+  // buffer.  Returns false if an underlying write error occurs.  This is
+  // mainly useful with GetDirectBufferPointer().
+  // Note of caution, the skipped bytes may contain uninitialized data. The
+  // caller must make sure that the skipped bytes are properly initialized,
+  // otherwise you might leak bytes from your heap.
+  bool Skip(int count) { return impl_.Skip(count, &cur_); }
+
+  // Sets *data to point directly at the unwritten part of the
+  // CodedOutputStream's underlying buffer, and *size to the size of that
+  // buffer, but does not advance the stream's current position.  This will
+  // always either produce a non-empty buffer or return false.  If the caller
+  // writes any data to this buffer, it should then call Skip() to skip over
+  // the consumed bytes.  This may be useful for implementing external fast
+  // serialization routines for types of data not covered by the
+  // CodedOutputStream interface.
+  bool GetDirectBufferPointer(void** data, int* size) {
+    return impl_.GetDirectBufferPointer(data, size, &cur_);
+  }
+
+  // If there are at least "size" bytes available in the current buffer,
+  // returns a pointer directly into the buffer and advances over these bytes.
+  // The caller may then write directly into this buffer (e.g. using the
+  // *ToArray static methods) rather than go through CodedOutputStream.  If
+  // there are not enough bytes available, returns NULL.  The return pointer is
+  // invalidated as soon as any other non-const method of CodedOutputStream
+  // is called.
+  inline uint8_t* GetDirectBufferForNBytesAndAdvance(int size) {
+    return impl_.GetDirectBufferForNBytesAndAdvance(size, &cur_);
+  }
+
+  // Write raw bytes, copying them from the given buffer.
+  void WriteRaw(const void* buffer, int size) {
+    cur_ = impl_.WriteRaw(buffer, size, cur_);
+  }
+  // Like WriteRaw()  but will try to write aliased data if aliasing is
+  // turned on.
+  void WriteRawMaybeAliased(const void* data, int size);
+  // Like WriteRaw()  but writing directly to the target array.
+  // This is _not_ inlined, as the compiler often optimizes memcpy into inline
+  // copy loops. Since this gets called by every field with string or bytes
+  // type, inlining may lead to a significant amount of code bloat, with only a
+  // minor performance gain.
+  static uint8_t* WriteRawToArray(const void* buffer, int size,
+                                  uint8_t* target);
+
+  // Equivalent to WriteRaw(str.data(), str.size()).
+  void WriteString(const std::string& str);
+  // Like WriteString()  but writing directly to the target array.
+  static uint8_t* WriteStringToArray(const std::string& str, uint8_t* target);
+  // Write the varint-encoded size of str followed by str.
+  static uint8_t* WriteStringWithSizeToArray(const std::string& str,
+                                             uint8_t* target);
+
+
+  // Write a 32-bit little-endian integer.
+  void WriteLittleEndian32(uint32_t value) {
+    cur_ = impl_.EnsureSpace(cur_);
+    SetCur(WriteLittleEndian32ToArray(value, Cur()));
+  }
+  // Like WriteLittleEndian32()  but writing directly to the target array.
+  static uint8_t* WriteLittleEndian32ToArray(uint32_t value, uint8_t* target);
+  // Write a 64-bit little-endian integer.
+  void WriteLittleEndian64(uint64_t value) {
+    cur_ = impl_.EnsureSpace(cur_);
+    SetCur(WriteLittleEndian64ToArray(value, Cur()));
+  }
+  // Like WriteLittleEndian64()  but writing directly to the target array.
+  static uint8_t* WriteLittleEndian64ToArray(uint64_t value, uint8_t* target);
+
+  // Write an unsigned integer with Varint encoding.  Writing a 32-bit value
+  // is equivalent to casting it to uint64_t and writing it as a 64-bit value,
+  // but may be more efficient.
+  void WriteVarint32(uint32_t value);
+  // Like WriteVarint32()  but writing directly to the target array.
+  static uint8_t* WriteVarint32ToArray(uint32_t value, uint8_t* target);
+  // Like WriteVarint32()  but writing directly to the target array, and with
+  // the less common-case paths being out of line rather than inlined.
+  static uint8_t* WriteVarint32ToArrayOutOfLine(uint32_t value,
+                                                uint8_t* target);
+  // Write an unsigned integer with Varint encoding.
+  void WriteVarint64(uint64_t value);
+  // Like WriteVarint64()  but writing directly to the target array.
+  static uint8_t* WriteVarint64ToArray(uint64_t value, uint8_t* target);
+
+  // Equivalent to WriteVarint32() except when the value is negative,
+  // in which case it must be sign-extended to a full 10 bytes.
+  void WriteVarint32SignExtended(int32_t value);
+  // Like WriteVarint32SignExtended()  but writing directly to the target array.
+  static uint8_t* WriteVarint32SignExtendedToArray(int32_t value,
+                                                   uint8_t* target);
+
+  // This is identical to WriteVarint32(), but optimized for writing tags.
+  // In particular, if the input is a compile-time constant, this method
+  // compiles down to a couple instructions.
+  // Always inline because otherwise the aforementioned optimization can't work,
+  // but GCC by default doesn't want to inline this.
+  void WriteTag(uint32_t value);
+  // Like WriteTag()  but writing directly to the target array.
+  PROTOBUF_ALWAYS_INLINE
+  static uint8_t* WriteTagToArray(uint32_t value, uint8_t* target);
+
+  // Returns the number of bytes needed to encode the given value as a varint.
+  static size_t VarintSize32(uint32_t value);
+  // Returns the number of bytes needed to encode the given value as a varint.
+  static size_t VarintSize64(uint64_t value);
+
+  // If negative, 10 bytes.  Otherwise, same as VarintSize32().
+  static size_t VarintSize32SignExtended(int32_t value);
+
+  // Same as above, plus one.  The additional one comes at no compute cost.
+  static size_t VarintSize32PlusOne(uint32_t value);
+  static size_t VarintSize64PlusOne(uint64_t value);
+  static size_t VarintSize32SignExtendedPlusOne(int32_t value);
+
+  // Compile-time equivalent of VarintSize32().
+  template <uint32_t Value>
+  struct StaticVarintSize32 {
+    static const size_t value = (Value < (1 << 7))    ? 1
+                                : (Value < (1 << 14)) ? 2
+                                : (Value < (1 << 21)) ? 3
+                                : (Value < (1 << 28)) ? 4
+                                                      : 5;
+  };
+
+  // Returns the total number of bytes written since this object was created.
+  int ByteCount() const {
+    return static_cast<int>(impl_.ByteCount(cur_) - start_count_);
+  }
+
+  // Instructs the CodedOutputStream to allow the underlying
+  // ZeroCopyOutputStream to hold pointers to the original structure instead of
+  // copying, if it supports it (i.e. output->AllowsAliasing() is true).  If the
+  // underlying stream does not support aliasing, then enabling it has no
+  // affect.  For now, this only affects the behavior of
+  // WriteRawMaybeAliased().
+  //
+  // NOTE: It is caller's responsibility to ensure that the chunk of memory
+  // remains live until all of the data has been consumed from the stream.
+  void EnableAliasing(bool enabled) { impl_.EnableAliasing(enabled); }
+
+  // Indicate to the serializer whether the user wants deterministic
+  // serialization. The default when this is not called comes from the global
+  // default, controlled by SetDefaultSerializationDeterministic.
+  //
+  // What deterministic serialization means is entirely up to the driver of the
+  // serialization process (i.e. the caller of methods like WriteVarint32). In
+  // the case of serializing a proto buffer message using one of the methods of
+  // MessageLite, this means that for a given binary equal messages will always
+  // be serialized to the same bytes. This implies:
+  //
+  //   * Repeated serialization of a message will return the same bytes.
+  //
+  //   * Different processes running the same binary (including on different
+  //     machines) will serialize equal messages to the same bytes.
+  //
+  // Note that this is *not* canonical across languages. It is also unstable
+  // across different builds with intervening message definition changes, due to
+  // unknown fields. Users who need canonical serialization (e.g. persistent
+  // storage in a canonical form, fingerprinting) should define their own
+  // canonicalization specification and implement the serializer using
+  // reflection APIs rather than relying on this API.
+  void SetSerializationDeterministic(bool value) {
+    impl_.SetSerializationDeterministic(value);
+  }
+
+  // Return whether the user wants deterministic serialization. See above.
+  bool IsSerializationDeterministic() const {
+    return impl_.IsSerializationDeterministic();
+  }
+
+  static bool IsDefaultSerializationDeterministic() {
+    return default_serialization_deterministic_.load(
+               std::memory_order_relaxed) != 0;
+  }
+
+  template <typename Func>
+  void Serialize(const Func& func);
+
+  uint8_t* Cur() const { return cur_; }
+  void SetCur(uint8_t* ptr) { cur_ = ptr; }
+  EpsCopyOutputStream* EpsCopy() { return &impl_; }
+
+ private:
+  template <class Stream>
+  void InitEagerly(Stream* stream);
+
+  EpsCopyOutputStream impl_;
+  uint8_t* cur_;
+  int64_t start_count_;
+  static std::atomic<bool> default_serialization_deterministic_;
+
+  // See above.  Other projects may use "friend" to allow them to call this.
+  // After SetDefaultSerializationDeterministic() completes, all protocol
+  // buffer serializations will be deterministic by default.  Thread safe.
+  // However, the meaning of "after" is subtle here: to be safe, each thread
+  // that wants deterministic serialization by default needs to call
+  // SetDefaultSerializationDeterministic() or ensure on its own that another
+  // thread has done so.
+  friend void internal::MapTestForceDeterministic();
+  static void SetDefaultSerializationDeterministic() {
+    default_serialization_deterministic_.store(true, std::memory_order_relaxed);
+  }
+  // REQUIRES: value >= 0x80, and that (value & 7f) has been written to *target.
+  static uint8_t* WriteVarint32ToArrayOutOfLineHelper(uint32_t value,
+                                                      uint8_t* target);
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedOutputStream);
+};
+
+// inline methods ====================================================
+// The vast majority of varints are only one byte.  These inline
+// methods optimize for that case.
+
+inline bool CodedInputStream::ReadVarint32(uint32_t* value) {
+  uint32_t v = 0;
+  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
+    v = *buffer_;
+    if (v < 0x80) {
+      *value = v;
+      Advance(1);
+      return true;
+    }
+  }
+  int64_t result = ReadVarint32Fallback(v);
+  *value = static_cast<uint32_t>(result);
+  return result >= 0;
+}
+
+inline bool CodedInputStream::ReadVarint64(uint64_t* value) {
+  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
+    *value = *buffer_;
+    Advance(1);
+    return true;
+  }
+  std::pair<uint64_t, bool> p = ReadVarint64Fallback();
+  *value = p.first;
+  return p.second;
+}
+
+inline bool CodedInputStream::ReadVarintSizeAsInt(int* value) {
+  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
+    int v = *buffer_;
+    if (v < 0x80) {
+      *value = v;
+      Advance(1);
+      return true;
+    }
+  }
+  *value = ReadVarintSizeAsIntFallback();
+  return *value >= 0;
+}
+
+// static
+inline const uint8_t* CodedInputStream::ReadLittleEndian32FromArray(
+    const uint8_t* buffer, uint32_t* value) {
+#if defined(PROTOBUF_LITTLE_ENDIAN) && \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  memcpy(value, buffer, sizeof(*value));
+  return buffer + sizeof(*value);
+#else
+  *value = (static_cast<uint32_t>(buffer[0])) |
+           (static_cast<uint32_t>(buffer[1]) << 8) |
+           (static_cast<uint32_t>(buffer[2]) << 16) |
+           (static_cast<uint32_t>(buffer[3]) << 24);
+  return buffer + sizeof(*value);
+#endif
+}
+// static
+inline const uint8_t* CodedInputStream::ReadLittleEndian64FromArray(
+    const uint8_t* buffer, uint64_t* value) {
+#if defined(PROTOBUF_LITTLE_ENDIAN) && \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  memcpy(value, buffer, sizeof(*value));
+  return buffer + sizeof(*value);
+#else
+  uint32_t part0 = (static_cast<uint32_t>(buffer[0])) |
+                   (static_cast<uint32_t>(buffer[1]) << 8) |
+                   (static_cast<uint32_t>(buffer[2]) << 16) |
+                   (static_cast<uint32_t>(buffer[3]) << 24);
+  uint32_t part1 = (static_cast<uint32_t>(buffer[4])) |
+                   (static_cast<uint32_t>(buffer[5]) << 8) |
+                   (static_cast<uint32_t>(buffer[6]) << 16) |
+                   (static_cast<uint32_t>(buffer[7]) << 24);
+  *value = static_cast<uint64_t>(part0) | (static_cast<uint64_t>(part1) << 32);
+  return buffer + sizeof(*value);
+#endif
+}
+
+inline bool CodedInputStream::ReadLittleEndian32(uint32_t* value) {
+#if defined(PROTOBUF_LITTLE_ENDIAN) && \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
+    buffer_ = ReadLittleEndian32FromArray(buffer_, value);
+    return true;
+  } else {
+    return ReadLittleEndian32Fallback(value);
+  }
+#else
+  return ReadLittleEndian32Fallback(value);
+#endif
+}
+
+inline bool CodedInputStream::ReadLittleEndian64(uint64_t* value) {
+#if defined(PROTOBUF_LITTLE_ENDIAN) && \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
+    buffer_ = ReadLittleEndian64FromArray(buffer_, value);
+    return true;
+  } else {
+    return ReadLittleEndian64Fallback(value);
+  }
+#else
+  return ReadLittleEndian64Fallback(value);
+#endif
+}
+
+inline uint32_t CodedInputStream::ReadTagNoLastTag() {
+  uint32_t v = 0;
+  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
+    v = *buffer_;
+    if (v < 0x80) {
+      Advance(1);
+      return v;
+    }
+  }
+  v = ReadTagFallback(v);
+  return v;
+}
+
+inline std::pair<uint32_t, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
+    uint32_t cutoff) {
+  // In performance-sensitive code we can expect cutoff to be a compile-time
+  // constant, and things like "cutoff >= kMax1ByteVarint" to be evaluated at
+  // compile time.
+  uint32_t first_byte_or_zero = 0;
+  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
+    // Hot case: buffer_ non_empty, buffer_[0] in [1, 128).
+    // TODO(gpike): Is it worth rearranging this? E.g., if the number of fields
+    // is large enough then is it better to check for the two-byte case first?
+    first_byte_or_zero = buffer_[0];
+    if (static_cast<int8_t>(buffer_[0]) > 0) {
+      const uint32_t kMax1ByteVarint = 0x7f;
+      uint32_t tag = buffer_[0];
+      Advance(1);
+      return std::make_pair(tag, cutoff >= kMax1ByteVarint || tag <= cutoff);
+    }
+    // Other hot case: cutoff >= 0x80, buffer_ has at least two bytes available,
+    // and tag is two bytes.  The latter is tested by bitwise-and-not of the
+    // first byte and the second byte.
+    if (cutoff >= 0x80 && PROTOBUF_PREDICT_TRUE(buffer_ + 1 < buffer_end_) &&
+        PROTOBUF_PREDICT_TRUE((buffer_[0] & ~buffer_[1]) >= 0x80)) {
+      const uint32_t kMax2ByteVarint = (0x7f << 7) + 0x7f;
+      uint32_t tag = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
+      Advance(2);
+      // It might make sense to test for tag == 0 now, but it is so rare that
+      // that we don't bother.  A varint-encoded 0 should be one byte unless
+      // the encoder lost its mind.  The second part of the return value of
+      // this function is allowed to be either true or false if the tag is 0,
+      // so we don't have to check for tag == 0.  We may need to check whether
+      // it exceeds cutoff.
+      bool at_or_below_cutoff = cutoff >= kMax2ByteVarint || tag <= cutoff;
+      return std::make_pair(tag, at_or_below_cutoff);
+    }
+  }
+  // Slow path
+  const uint32_t tag = ReadTagFallback(first_byte_or_zero);
+  return std::make_pair(tag, static_cast<uint32_t>(tag - 1) < cutoff);
+}
+
+inline bool CodedInputStream::LastTagWas(uint32_t expected) {
+  return last_tag_ == expected;
+}
+
+inline bool CodedInputStream::ConsumedEntireMessage() {
+  return legitimate_message_end_;
+}
+
+inline bool CodedInputStream::ExpectTag(uint32_t expected) {
+  if (expected < (1 << 7)) {
+    if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) &&
+        buffer_[0] == expected) {
+      Advance(1);
+      return true;
+    } else {
+      return false;
+    }
+  } else if (expected < (1 << 14)) {
+    if (PROTOBUF_PREDICT_TRUE(BufferSize() >= 2) &&
+        buffer_[0] == static_cast<uint8_t>(expected | 0x80) &&
+        buffer_[1] == static_cast<uint8_t>(expected >> 7)) {
+      Advance(2);
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    // Don't bother optimizing for larger values.
+    return false;
+  }
+}
+
+inline const uint8_t* CodedInputStream::ExpectTagFromArray(
+    const uint8_t* buffer, uint32_t expected) {
+  if (expected < (1 << 7)) {
+    if (buffer[0] == expected) {
+      return buffer + 1;
+    }
+  } else if (expected < (1 << 14)) {
+    if (buffer[0] == static_cast<uint8_t>(expected | 0x80) &&
+        buffer[1] == static_cast<uint8_t>(expected >> 7)) {
+      return buffer + 2;
+    }
+  }
+  return nullptr;
+}
+
+inline void CodedInputStream::GetDirectBufferPointerInline(const void** data,
+                                                           int* size) {
+  *data = buffer_;
+  *size = static_cast<int>(buffer_end_ - buffer_);
+}
+
+inline bool CodedInputStream::ExpectAtEnd() {
+  // If we are at a limit we know no more bytes can be read.  Otherwise, it's
+  // hard to say without calling Refresh(), and we'd rather not do that.
+
+  if (buffer_ == buffer_end_ && ((buffer_size_after_limit_ != 0) ||
+                                 (total_bytes_read_ == current_limit_))) {
+    last_tag_ = 0;                   // Pretend we called ReadTag()...
+    legitimate_message_end_ = true;  // ... and it hit EOF.
+    return true;
+  } else {
+    return false;
+  }
+}
+
+inline int CodedInputStream::CurrentPosition() const {
+  return total_bytes_read_ - (BufferSize() + buffer_size_after_limit_);
+}
+
+inline void CodedInputStream::Advance(int amount) { buffer_ += amount; }
+
+inline void CodedInputStream::SetRecursionLimit(int limit) {
+  recursion_budget_ += limit - recursion_limit_;
+  recursion_limit_ = limit;
+}
+
+inline bool CodedInputStream::IncrementRecursionDepth() {
+  --recursion_budget_;
+  return recursion_budget_ >= 0;
+}
+
+inline void CodedInputStream::DecrementRecursionDepth() {
+  if (recursion_budget_ < recursion_limit_) ++recursion_budget_;
+}
+
+inline void CodedInputStream::UnsafeDecrementRecursionDepth() {
+  assert(recursion_budget_ < recursion_limit_);
+  ++recursion_budget_;
+}
+
+inline void CodedInputStream::SetExtensionRegistry(const DescriptorPool* pool,
+                                                   MessageFactory* factory) {
+  extension_pool_ = pool;
+  extension_factory_ = factory;
+}
+
+inline const DescriptorPool* CodedInputStream::GetExtensionPool() {
+  return extension_pool_;
+}
+
+inline MessageFactory* CodedInputStream::GetExtensionFactory() {
+  return extension_factory_;
+}
+
+inline int CodedInputStream::BufferSize() const {
+  return static_cast<int>(buffer_end_ - buffer_);
+}
+
+inline CodedInputStream::CodedInputStream(ZeroCopyInputStream* input)
+    : buffer_(nullptr),
+      buffer_end_(nullptr),
+      input_(input),
+      total_bytes_read_(0),
+      overflow_bytes_(0),
+      last_tag_(0),
+      legitimate_message_end_(false),
+      aliasing_enabled_(false),
+      current_limit_(std::numeric_limits<int32_t>::max()),
+      buffer_size_after_limit_(0),
+      total_bytes_limit_(kDefaultTotalBytesLimit),
+      recursion_budget_(default_recursion_limit_),
+      recursion_limit_(default_recursion_limit_),
+      extension_pool_(nullptr),
+      extension_factory_(nullptr) {
+  // Eagerly Refresh() so buffer space is immediately available.
+  Refresh();
+}
+
+inline CodedInputStream::CodedInputStream(const uint8_t* buffer, int size)
+    : buffer_(buffer),
+      buffer_end_(buffer + size),
+      input_(nullptr),
+      total_bytes_read_(size),
+      overflow_bytes_(0),
+      last_tag_(0),
+      legitimate_message_end_(false),
+      aliasing_enabled_(false),
+      current_limit_(size),
+      buffer_size_after_limit_(0),
+      total_bytes_limit_(kDefaultTotalBytesLimit),
+      recursion_budget_(default_recursion_limit_),
+      recursion_limit_(default_recursion_limit_),
+      extension_pool_(nullptr),
+      extension_factory_(nullptr) {
+  // Note that setting current_limit_ == size is important to prevent some
+  // code paths from trying to access input_ and segfaulting.
+}
+
+inline bool CodedInputStream::IsFlat() const { return input_ == nullptr; }
+
+inline bool CodedInputStream::Skip(int count) {
+  if (count < 0) return false;  // security: count is often user-supplied
+
+  const int original_buffer_size = BufferSize();
+
+  if (count <= original_buffer_size) {
+    // Just skipping within the current buffer.  Easy.
+    Advance(count);
+    return true;
+  }
+
+  return SkipFallback(count, original_buffer_size);
+}
+
+template <class Stream, class>
+inline CodedOutputStream::CodedOutputStream(Stream* stream)
+    : impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
+      start_count_(stream->ByteCount()) {
+  InitEagerly(stream);
+}
+
+template <class Stream, class>
+inline CodedOutputStream::CodedOutputStream(Stream* stream, bool eager_init)
+    : impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
+      start_count_(stream->ByteCount()) {
+  if (eager_init) {
+    InitEagerly(stream);
+  }
+}
+
+template <class Stream>
+inline void CodedOutputStream::InitEagerly(Stream* stream) {
+  void* data;
+  int size;
+  if (PROTOBUF_PREDICT_TRUE(stream->Next(&data, &size) && size > 0)) {
+    cur_ = impl_.SetInitialBuffer(data, size);
+  }
+}
+
+inline uint8_t* CodedOutputStream::WriteVarint32ToArray(uint32_t value,
+                                                        uint8_t* target) {
+  return EpsCopyOutputStream::UnsafeVarint(value, target);
+}
+
+inline uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLine(
+    uint32_t value, uint8_t* target) {
+  target[0] = static_cast<uint8_t>(value);
+  if (value < 0x80) {
+    return target + 1;
+  } else {
+    return WriteVarint32ToArrayOutOfLineHelper(value, target);
+  }
+}
+
+inline uint8_t* CodedOutputStream::WriteVarint64ToArray(uint64_t value,
+                                                        uint8_t* target) {
+  return EpsCopyOutputStream::UnsafeVarint(value, target);
+}
+
+inline void CodedOutputStream::WriteVarint32SignExtended(int32_t value) {
+  WriteVarint64(static_cast<uint64_t>(value));
+}
+
+inline uint8_t* CodedOutputStream::WriteVarint32SignExtendedToArray(
+    int32_t value, uint8_t* target) {
+  return WriteVarint64ToArray(static_cast<uint64_t>(value), target);
+}
+
+inline uint8_t* CodedOutputStream::WriteLittleEndian32ToArray(uint32_t value,
+                                                              uint8_t* target) {
+#if defined(PROTOBUF_LITTLE_ENDIAN) && \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  memcpy(target, &value, sizeof(value));
+#else
+  target[0] = static_cast<uint8_t>(value);
+  target[1] = static_cast<uint8_t>(value >> 8);
+  target[2] = static_cast<uint8_t>(value >> 16);
+  target[3] = static_cast<uint8_t>(value >> 24);
+#endif
+  return target + sizeof(value);
+}
+
+inline uint8_t* CodedOutputStream::WriteLittleEndian64ToArray(uint64_t value,
+                                                              uint8_t* target) {
+#if defined(PROTOBUF_LITTLE_ENDIAN) && \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+  memcpy(target, &value, sizeof(value));
+#else
+  uint32_t part0 = static_cast<uint32_t>(value);
+  uint32_t part1 = static_cast<uint32_t>(value >> 32);
+
+  target[0] = static_cast<uint8_t>(part0);
+  target[1] = static_cast<uint8_t>(part0 >> 8);
+  target[2] = static_cast<uint8_t>(part0 >> 16);
+  target[3] = static_cast<uint8_t>(part0 >> 24);
+  target[4] = static_cast<uint8_t>(part1);
+  target[5] = static_cast<uint8_t>(part1 >> 8);
+  target[6] = static_cast<uint8_t>(part1 >> 16);
+  target[7] = static_cast<uint8_t>(part1 >> 24);
+#endif
+  return target + sizeof(value);
+}
+
+inline void CodedOutputStream::WriteVarint32(uint32_t value) {
+  cur_ = impl_.EnsureSpace(cur_);
+  SetCur(WriteVarint32ToArray(value, Cur()));
+}
+
+inline void CodedOutputStream::WriteVarint64(uint64_t value) {
+  cur_ = impl_.EnsureSpace(cur_);
+  SetCur(WriteVarint64ToArray(value, Cur()));
+}
+
+inline void CodedOutputStream::WriteTag(uint32_t value) {
+  WriteVarint32(value);
+}
+
+inline uint8_t* CodedOutputStream::WriteTagToArray(uint32_t value,
+                                                   uint8_t* target) {
+  return WriteVarint32ToArray(value, target);
+}
+
+inline size_t CodedOutputStream::VarintSize32(uint32_t value) {
+  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
+  // Use an explicit multiplication to implement the divide of
+  // a number in the 1..31 range.
+  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
+  // undefined.
+  uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
+  return static_cast<size_t>((log2value * 9 + 73) / 64);
+}
+
+inline size_t CodedOutputStream::VarintSize32PlusOne(uint32_t value) {
+  // Same as above, but one more.
+  uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
+  return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
+}
+
+inline size_t CodedOutputStream::VarintSize64(uint64_t value) {
+  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
+  // Use an explicit multiplication to implement the divide of
+  // a number in the 1..63 range.
+  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
+  // undefined.
+  uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
+  return static_cast<size_t>((log2value * 9 + 73) / 64);
+}
+
+inline size_t CodedOutputStream::VarintSize64PlusOne(uint64_t value) {
+  // Same as above, but one more.
+  uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
+  return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
+}
+
+inline size_t CodedOutputStream::VarintSize32SignExtended(int32_t value) {
+  return VarintSize64(static_cast<uint64_t>(int64_t{value}));
+}
+
+inline size_t CodedOutputStream::VarintSize32SignExtendedPlusOne(
+    int32_t value) {
+  return VarintSize64PlusOne(static_cast<uint64_t>(int64_t{value}));
+}
+
+inline void CodedOutputStream::WriteString(const std::string& str) {
+  WriteRaw(str.data(), static_cast<int>(str.size()));
+}
+
+inline void CodedOutputStream::WriteRawMaybeAliased(const void* data,
+                                                    int size) {
+  cur_ = impl_.WriteRawMaybeAliased(data, size, cur_);
+}
+
+inline uint8_t* CodedOutputStream::WriteRawToArray(const void* data, int size,
+                                                   uint8_t* target) {
+  memcpy(target, data, size);
+  return target + size;
+}
+
+inline uint8_t* CodedOutputStream::WriteStringToArray(const std::string& str,
+                                                      uint8_t* target) {
+  return WriteRawToArray(str.data(), static_cast<int>(str.size()), target);
+}
+
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
+#pragma runtime_checks("c", restore)
+#endif  // _MSC_VER && !defined(__INTEL_COMPILER)
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/gzip_stream.h b/CAPI/cpp/grpc/include/google/protobuf/io/gzip_stream.h
new file mode 100644
index 0000000..4cf71b6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/gzip_stream.h
@@ -0,0 +1,205 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: brianolson@google.com (Brian Olson)
+//
+// This file contains the definition for classes GzipInputStream and
+// GzipOutputStream.
+//
+// GzipInputStream decompresses data from an underlying
+// ZeroCopyInputStream and provides the decompressed data as a
+// ZeroCopyInputStream.
+//
+// GzipOutputStream is an ZeroCopyOutputStream that compresses data to
+// an underlying ZeroCopyOutputStream.
+
+#ifndef GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
+#define GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
+
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/port.h>
+#include "zlib.h"
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+// A ZeroCopyInputStream that reads compressed data through zlib
+class PROTOBUF_EXPORT GzipInputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyInputStream {
+ public:
+  // Format key for constructor
+  enum Format {
+    // zlib will autodetect gzip header or deflate stream
+    AUTO = 0,
+
+    // GZIP streams have some extra header data for file attributes.
+    GZIP = 1,
+
+    // Simpler zlib stream format.
+    ZLIB = 2,
+  };
+
+  // buffer_size and format may be -1 for default of 64kB and GZIP format
+  explicit GzipInputStream(ZeroCopyInputStream* sub_stream,
+                           Format format = AUTO, int buffer_size = -1);
+  virtual ~GzipInputStream();
+
+  // Return last error message or NULL if no error.
+  inline const char* ZlibErrorMessage() const { return zcontext_.msg; }
+  inline int ZlibErrorCode() const { return zerror_; }
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size) override;
+  void BackUp(int count) override;
+  bool Skip(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  Format format_;
+
+  ZeroCopyInputStream* sub_stream_;
+
+  z_stream zcontext_;
+  int zerror_;
+
+  void* output_buffer_;
+  void* output_position_;
+  size_t output_buffer_length_;
+  int64_t byte_count_;
+
+  int Inflate(int flush);
+  void DoNextOutput(const void** data, int* size);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipInputStream);
+};
+
+class PROTOBUF_EXPORT GzipOutputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyOutputStream {
+ public:
+  // Format key for constructor
+  enum Format {
+    // GZIP streams have some extra header data for file attributes.
+    GZIP = 1,
+
+    // Simpler zlib stream format.
+    ZLIB = 2,
+  };
+
+  struct PROTOBUF_EXPORT Options {
+    // Defaults to GZIP.
+    Format format;
+
+    // What size buffer to use internally.  Defaults to 64kB.
+    int buffer_size;
+
+    // A number between 0 and 9, where 0 is no compression and 9 is best
+    // compression.  Defaults to Z_DEFAULT_COMPRESSION (see zlib.h).
+    int compression_level;
+
+    // Defaults to Z_DEFAULT_STRATEGY.  Can also be set to Z_FILTERED,
+    // Z_HUFFMAN_ONLY, or Z_RLE.  See the documentation for deflateInit2 in
+    // zlib.h for definitions of these constants.
+    int compression_strategy;
+
+    Options();  // Initializes with default values.
+  };
+
+  // Create a GzipOutputStream with default options.
+  explicit GzipOutputStream(ZeroCopyOutputStream* sub_stream);
+
+  // Create a GzipOutputStream with the given options.
+  GzipOutputStream(ZeroCopyOutputStream* sub_stream, const Options& options);
+
+  virtual ~GzipOutputStream();
+
+  // Return last error message or NULL if no error.
+  inline const char* ZlibErrorMessage() const { return zcontext_.msg; }
+  inline int ZlibErrorCode() const { return zerror_; }
+
+  // Flushes data written so far to zipped data in the underlying stream.
+  // It is the caller's responsibility to flush the underlying stream if
+  // necessary.
+  // Compression may be less efficient stopping and starting around flushes.
+  // Returns true if no error.
+  //
+  // Please ensure that block size is > 6. Here is an excerpt from the zlib
+  // doc that explains why:
+  //
+  // In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that avail_out
+  // is greater than six to avoid repeated flush markers due to
+  // avail_out == 0 on return.
+  bool Flush();
+
+  // Writes out all data and closes the gzip stream.
+  // It is the caller's responsibility to close the underlying stream if
+  // necessary.
+  // Returns true if no error.
+  bool Close();
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size) override;
+  void BackUp(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  ZeroCopyOutputStream* sub_stream_;
+  // Result from calling Next() on sub_stream_
+  void* sub_data_;
+  int sub_data_size_;
+
+  z_stream zcontext_;
+  int zerror_;
+  void* input_buffer_;
+  size_t input_buffer_length_;
+
+  // Shared constructor code.
+  void Init(ZeroCopyOutputStream* sub_stream, const Options& options);
+
+  // Do some compression.
+  // Takes zlib flush mode.
+  // Returns zlib error code.
+  int Deflate(int flush);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipOutputStream);
+};
+
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/io_win32.h b/CAPI/cpp/grpc/include/google/protobuf/io/io_win32.h
new file mode 100644
index 0000000..a72b4ea
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/io_win32.h
@@ -0,0 +1,141 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: laszlocsomor@google.com (Laszlo Csomor)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+
+// This file contains the declarations for Windows implementations of
+// commonly used POSIX functions such as open(2) and access(2), as well
+// as macro definitions for flags of these functions.
+//
+// By including this file you'll redefine open/access/etc. to
+// ::google::protobuf::io::win32::{open/access/etc.}.
+// Make sure you don't include a header that attempts to redeclare or
+// redefine these functions, that'll lead to confusing compilation
+// errors. It's best to #include this file as the last one to ensure that.
+//
+// This file is only used on Windows, it's empty on other platforms.
+
+#ifndef GOOGLE_PROTOBUF_IO_IO_WIN32_H__
+#define GOOGLE_PROTOBUF_IO_IO_WIN32_H__
+
+#if defined(_WIN32)
+
+#include <functional>
+#include <string>
+
+#include <google/protobuf/port.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+// Compilers on Windows other than MSVC (e.g. Cygwin, MinGW32) define the
+// following functions already, except for mkdir.
+namespace google {
+namespace protobuf {
+namespace io {
+namespace win32 {
+
+PROTOBUF_EXPORT FILE* fopen(const char* path, const char* mode);
+PROTOBUF_EXPORT int access(const char* path, int mode);
+PROTOBUF_EXPORT int chdir(const char* path);
+PROTOBUF_EXPORT int close(int fd);
+PROTOBUF_EXPORT int dup(int fd);
+PROTOBUF_EXPORT int dup2(int fd1, int fd2);
+PROTOBUF_EXPORT int mkdir(const char* path, int _mode);
+PROTOBUF_EXPORT int open(const char* path, int flags, int mode = 0);
+PROTOBUF_EXPORT int read(int fd, void* buffer, size_t size);
+PROTOBUF_EXPORT int setmode(int fd, int mode);
+PROTOBUF_EXPORT int stat(const char* path, struct _stat* buffer);
+PROTOBUF_EXPORT int write(int fd, const void* buffer, size_t size);
+PROTOBUF_EXPORT std::wstring testonly_utf8_to_winpath(const char* path);
+
+enum class ExpandWildcardsResult {
+  kSuccess = 0,
+  kErrorNoMatchingFile = 1,
+  kErrorInputPathConversion = 2,
+  kErrorOutputPathConversion = 3,
+};
+
+// Expand wildcards in a path pattern, feed the result to a consumer function.
+//
+// `path` must be a valid, Windows-style path. It may be absolute, or relative
+// to the current working directory, and it may contain wildcards ("*" and "?")
+// in the last path segment. This function passes all matching file names to
+// `consume`. The resulting paths may not be absolute nor normalized.
+//
+// The function returns a value from `ExpandWildcardsResult`.
+PROTOBUF_EXPORT ExpandWildcardsResult ExpandWildcards(
+    const std::string& path, std::function<void(const std::string&)> consume);
+
+namespace strings {
+
+// Convert from UTF-16 to Active-Code-Page-encoded or to UTF-8-encoded text.
+PROTOBUF_EXPORT bool wcs_to_mbs(const wchar_t* s, std::string* out,
+                                bool outUtf8);
+
+// Convert from Active-Code-Page-encoded or UTF-8-encoded text to UTF-16.
+PROTOBUF_EXPORT bool mbs_to_wcs(const char* s, std::wstring* out, bool inUtf8);
+
+// Convert from UTF-8-encoded text to UTF-16.
+PROTOBUF_EXPORT bool utf8_to_wcs(const char* input, std::wstring* out);
+
+// Convert from UTF-16-encoded text to UTF-8.
+PROTOBUF_EXPORT bool wcs_to_utf8(const wchar_t* input, std::string* out);
+
+}  // namespace strings
+
+}  // namespace win32
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#ifndef W_OK
+#define W_OK 02  // not defined by MSVC for whatever reason
+#endif
+
+#ifndef F_OK
+#define F_OK 00  // not defined by MSVC for whatever reason
+#endif
+
+#ifndef STDIN_FILENO
+#define STDIN_FILENO 0
+#endif
+
+#ifndef STDOUT_FILENO
+#define STDOUT_FILENO 1
+#endif
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // defined(_WIN32)
+
+#endif  // GOOGLE_PROTOBUF_IO_IO_WIN32_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/printer.h b/CAPI/cpp/grpc/include/google/protobuf/io/printer.h
new file mode 100644
index 0000000..92a4321
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/printer.h
@@ -0,0 +1,387 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Utility class for writing text to a ZeroCopyOutputStream.
+
+#ifndef GOOGLE_PROTOBUF_IO_PRINTER_H__
+#define GOOGLE_PROTOBUF_IO_PRINTER_H__
+
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+class ZeroCopyOutputStream;  // zero_copy_stream.h
+
+// Records annotations about a Printer's output.
+class PROTOBUF_EXPORT AnnotationCollector {
+ public:
+  // Annotation is a offset range and a payload pair.
+  typedef std::pair<std::pair<size_t, size_t>, std::string> Annotation;
+
+  // Records that the bytes in file_path beginning with begin_offset and ending
+  // before end_offset are associated with the SourceCodeInfo-style path.
+  virtual void AddAnnotation(size_t begin_offset, size_t end_offset,
+                             const std::string& file_path,
+                             const std::vector<int>& path) = 0;
+
+  // TODO(gerbens) I don't see why we need virtuals here. Just a vector of
+  // range, payload pairs stored in a context should suffice.
+  virtual void AddAnnotationNew(Annotation& /* a */) {}
+
+  virtual ~AnnotationCollector() {}
+};
+
+// Records annotations about a Printer's output to the given protocol buffer,
+// assuming that the buffer has an ::Annotation message exposing path,
+// source_file, begin and end fields.
+template <typename AnnotationProto>
+class AnnotationProtoCollector : public AnnotationCollector {
+ public:
+  // annotation_proto is the protocol buffer to which new Annotations should be
+  // added. It is not owned by the AnnotationProtoCollector.
+  explicit AnnotationProtoCollector(AnnotationProto* annotation_proto)
+      : annotation_proto_(annotation_proto) {}
+
+  // Override for AnnotationCollector::AddAnnotation.
+  void AddAnnotation(size_t begin_offset, size_t end_offset,
+                     const std::string& file_path,
+                     const std::vector<int>& path) override {
+    typename AnnotationProto::Annotation* annotation =
+        annotation_proto_->add_annotation();
+    for (int i = 0; i < path.size(); ++i) {
+      annotation->add_path(path[i]);
+    }
+    annotation->set_source_file(file_path);
+    annotation->set_begin(begin_offset);
+    annotation->set_end(end_offset);
+  }
+  // Override for AnnotationCollector::AddAnnotation.
+  void AddAnnotationNew(Annotation& a) override {
+    auto* annotation = annotation_proto_->add_annotation();
+    annotation->ParseFromString(a.second);
+    annotation->set_begin(a.first.first);
+    annotation->set_end(a.first.second);
+  }
+
+ private:
+  // The protocol buffer to which new annotations should be added.
+  AnnotationProto* const annotation_proto_;
+};
+
+// This simple utility class assists in code generation.  It basically
+// allows the caller to define a set of variables and then output some
+// text with variable substitutions.  Example usage:
+//
+//   Printer printer(output, '$');
+//   map<string, string> vars;
+//   vars["name"] = "Bob";
+//   printer.Print(vars, "My name is $name$.");
+//
+// The above writes "My name is Bob." to the output stream.
+//
+// Printer aggressively enforces correct usage, crashing (with assert failures)
+// in the case of undefined variables in debug builds. This helps greatly in
+// debugging code which uses it.
+//
+// If a Printer is constructed with an AnnotationCollector, it will provide it
+// with annotations that connect the Printer's output to paths that can identify
+// various descriptors.  In the above example, if person_ is a descriptor that
+// identifies Bob, we can associate the output string "My name is Bob." with
+// a source path pointing to that descriptor with:
+//
+//   printer.Annotate("name", person_);
+//
+// The AnnotationCollector will be sent an annotation linking the output range
+// covering "Bob" to the logical path provided by person_.  Tools may use
+// this association to (for example) link "Bob" in the output back to the
+// source file that defined the person_ descriptor identifying Bob.
+//
+// Annotate can only examine variables substituted during the last call to
+// Print.  It is invalid to refer to a variable that was used multiple times
+// in a single Print call.
+//
+// In full generality, one may specify a range of output text using a beginning
+// substitution variable and an ending variable.  The resulting annotation will
+// span from the first character of the substituted value for the beginning
+// variable to the last character of the substituted value for the ending
+// variable.  For example, the Annotate call above is equivalent to this one:
+//
+//   printer.Annotate("name", "name", person_);
+//
+// This is useful if multiple variables combine to form a single span of output
+// that should be annotated with the same source path.  For example:
+//
+//   Printer printer(output, '$');
+//   map<string, string> vars;
+//   vars["first"] = "Alice";
+//   vars["last"] = "Smith";
+//   printer.Print(vars, "My name is $first$ $last$.");
+//   printer.Annotate("first", "last", person_);
+//
+// This code would associate the span covering "Alice Smith" in the output with
+// the person_ descriptor.
+//
+// Note that the beginning variable must come before (or overlap with, in the
+// case of zero-sized substitution values) the ending variable.
+//
+// It is also sometimes useful to use variables with zero-sized values as
+// markers.  This avoids issues with multiple references to the same variable
+// and also allows annotation ranges to span literal text from the Print
+// templates:
+//
+//   Printer printer(output, '$');
+//   map<string, string> vars;
+//   vars["foo"] = "bar";
+//   vars["function"] = "call";
+//   vars["mark"] = "";
+//   printer.Print(vars, "$function$($foo$,$foo$)$mark$");
+//   printer.Annotate("function", "mark", call_);
+//
+// This code associates the span covering "call(bar,bar)" in the output with the
+// call_ descriptor.
+
+class PROTOBUF_EXPORT Printer {
+ public:
+  // Create a printer that writes text to the given output stream.  Use the
+  // given character as the delimiter for variables.
+  Printer(ZeroCopyOutputStream* output, char variable_delimiter);
+
+  // Create a printer that writes text to the given output stream.  Use the
+  // given character as the delimiter for variables.  If annotation_collector
+  // is not null, Printer will provide it with annotations about code written
+  // to the stream.  annotation_collector is not owned by Printer.
+  Printer(ZeroCopyOutputStream* output, char variable_delimiter,
+          AnnotationCollector* annotation_collector);
+
+  ~Printer();
+
+  // Link a substitution variable emitted by the last call to Print to the
+  // object described by descriptor.
+  template <typename SomeDescriptor>
+  void Annotate(const char* varname, const SomeDescriptor* descriptor) {
+    Annotate(varname, varname, descriptor);
+  }
+
+  // Link the output range defined by the substitution variables as emitted by
+  // the last call to Print to the object described by descriptor. The range
+  // begins at begin_varname's value and ends after the last character of the
+  // value substituted for end_varname.
+  template <typename SomeDescriptor>
+  void Annotate(const char* begin_varname, const char* end_varname,
+                const SomeDescriptor* descriptor) {
+    if (annotation_collector_ == NULL) {
+      // Annotations aren't turned on for this Printer, so don't pay the cost
+      // of building the location path.
+      return;
+    }
+    std::vector<int> path;
+    descriptor->GetLocationPath(&path);
+    Annotate(begin_varname, end_varname, descriptor->file()->name(), path);
+  }
+
+  // Link a substitution variable emitted by the last call to Print to the file
+  // with path file_name.
+  void Annotate(const char* varname, const std::string& file_name) {
+    Annotate(varname, varname, file_name);
+  }
+
+  // Link the output range defined by the substitution variables as emitted by
+  // the last call to Print to the file with path file_name. The range begins
+  // at begin_varname's value and ends after the last character of the value
+  // substituted for end_varname.
+  void Annotate(const char* begin_varname, const char* end_varname,
+                const std::string& file_name) {
+    if (annotation_collector_ == NULL) {
+      // Annotations aren't turned on for this Printer.
+      return;
+    }
+    std::vector<int> empty_path;
+    Annotate(begin_varname, end_varname, file_name, empty_path);
+  }
+
+  // Print some text after applying variable substitutions.  If a particular
+  // variable in the text is not defined, this will crash.  Variables to be
+  // substituted are identified by their names surrounded by delimiter
+  // characters (as given to the constructor).  The variable bindings are
+  // defined by the given map.
+  void Print(const std::map<std::string, std::string>& variables,
+             const char* text);
+
+  // Like the first Print(), except the substitutions are given as parameters.
+  template <typename... Args>
+  void Print(const char* text, const Args&... args) {
+    std::map<std::string, std::string> vars;
+    PrintInternal(&vars, text, args...);
+  }
+
+  // Indent text by two spaces.  After calling Indent(), two spaces will be
+  // inserted at the beginning of each line of text.  Indent() may be called
+  // multiple times to produce deeper indents.
+  void Indent();
+
+  // Reduces the current indent level by two spaces, or crashes if the indent
+  // level is zero.
+  void Outdent();
+
+  // Write a string to the output buffer.
+  // This method does not look for newlines to add indentation.
+  void PrintRaw(const std::string& data);
+
+  // Write a zero-delimited string to output buffer.
+  // This method does not look for newlines to add indentation.
+  void PrintRaw(const char* data);
+
+  // Write some bytes to the output buffer.
+  // This method does not look for newlines to add indentation.
+  void WriteRaw(const char* data, int size);
+
+  // FormatInternal is a helper function not meant to use directly, use
+  // compiler::cpp::Formatter instead. This function is meant to support
+  // formatting text using named variables (eq. "$foo$) from a lookup map (vars)
+  // and variables directly supplied by arguments (eq "$1$" meaning first
+  // argument which is the zero index element of args).
+  void FormatInternal(const std::vector<std::string>& args,
+                      const std::map<std::string, std::string>& vars,
+                      const char* format);
+
+  // True if any write to the underlying stream failed.  (We don't just
+  // crash in this case because this is an I/O failure, not a programming
+  // error.)
+  bool failed() const { return failed_; }
+
+ private:
+  // Link the output range defined by the substitution variables as emitted by
+  // the last call to Print to the object found at the SourceCodeInfo-style path
+  // in a file with path file_path. The range begins at the start of
+  // begin_varname's value and ends after the last character of the value
+  // substituted for end_varname. Note that begin_varname and end_varname
+  // may refer to the same variable.
+  void Annotate(const char* begin_varname, const char* end_varname,
+                const std::string& file_path, const std::vector<int>& path);
+
+  // Base case
+  void PrintInternal(std::map<std::string, std::string>* vars,
+                     const char* text) {
+    Print(*vars, text);
+  }
+
+  template <typename... Args>
+  void PrintInternal(std::map<std::string, std::string>* vars, const char* text,
+                     const char* key, const std::string& value,
+                     const Args&... args) {
+    (*vars)[key] = value;
+    PrintInternal(vars, text, args...);
+  }
+
+  // Copy size worth of bytes from data to buffer_.
+  void CopyToBuffer(const char* data, int size);
+
+  void push_back(char c) {
+    if (failed_) return;
+    if (buffer_size_ == 0) {
+      if (!Next()) return;
+    }
+    *buffer_++ = c;
+    buffer_size_--;
+    offset_++;
+  }
+
+  bool Next();
+
+  inline void IndentIfAtStart();
+  const char* WriteVariable(
+      const std::vector<std::string>& args,
+      const std::map<std::string, std::string>& vars, const char* format,
+      int* arg_index,
+      std::vector<AnnotationCollector::Annotation>* annotations);
+
+  const char variable_delimiter_;
+
+  ZeroCopyOutputStream* const output_;
+  char* buffer_;
+  int buffer_size_;
+  // The current position, in bytes, in the output stream.  This is equivalent
+  // to the total number of bytes that have been written so far.  This value is
+  // used to calculate annotation ranges in the substitutions_ map below.
+  size_t offset_;
+
+  std::string indent_;
+  bool at_start_of_line_;
+  bool failed_;
+
+  // A map from variable name to [start, end) offsets in the output buffer.
+  // These refer to the offsets used for a variable after the last call to
+  // Print.  If a variable was used more than once, the entry used in
+  // this map is set to a negative-length span.  For singly-used variables, the
+  // start offset is the beginning of the substitution; the end offset is the
+  // last byte of the substitution plus one (such that (end - start) is the
+  // length of the substituted string).
+  std::map<std::string, std::pair<size_t, size_t> > substitutions_;
+
+  // Keeps track of the keys in substitutions_ that need to be updated when
+  // indents are inserted. These are keys that refer to the beginning of the
+  // current line.
+  std::vector<std::string> line_start_variables_;
+
+  // Returns true and sets range to the substitution range in the output for
+  // varname if varname was used once in the last call to Print. If varname
+  // was not used, or if it was used multiple times, returns false (and
+  // fails a debug assertion).
+  bool GetSubstitutionRange(const char* varname,
+                            std::pair<size_t, size_t>* range);
+
+  // If non-null, annotation_collector_ is used to store annotations about
+  // generated code.
+  AnnotationCollector* const annotation_collector_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Printer);
+};
+
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_IO_PRINTER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/strtod.h b/CAPI/cpp/grpc/include/google/protobuf/io/strtod.h
new file mode 100644
index 0000000..38f544a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/strtod.h
@@ -0,0 +1,55 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A locale-independent version of strtod(), used to parse floating
+// point default values in .proto files, where the decimal separator
+// is always a dot.
+
+#ifndef GOOGLE_PROTOBUF_IO_STRTOD_H__
+#define GOOGLE_PROTOBUF_IO_STRTOD_H__
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+// A locale-independent version of the standard strtod(), which always
+// uses a dot as the decimal separator.
+double NoLocaleStrtod(const char* str, char** endptr);
+
+// Casts a double value to a float value. If the value is outside of the
+// representable range of float, it will be converted to positive or negative
+// infinity.
+float SafeDoubleToFloat(double value);
+
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_IO_STRTOD_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/tokenizer.h b/CAPI/cpp/grpc/include/google/protobuf/io/tokenizer.h
new file mode 100644
index 0000000..4abab7e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/tokenizer.h
@@ -0,0 +1,442 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Class for parsing tokenized text from a ZeroCopyInputStream.
+
+#ifndef GOOGLE_PROTOBUF_IO_TOKENIZER_H__
+#define GOOGLE_PROTOBUF_IO_TOKENIZER_H__
+
+
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+class ZeroCopyInputStream;  // zero_copy_stream.h
+
+// Defined in this file.
+class ErrorCollector;
+class Tokenizer;
+
+// By "column number", the proto compiler refers to a count of the number
+// of bytes before a given byte, except that a tab character advances to
+// the next multiple of 8 bytes.  Note in particular that column numbers
+// are zero-based, while many user interfaces use one-based column numbers.
+typedef int ColumnNumber;
+
+// Abstract interface for an object which collects the errors that occur
+// during parsing.  A typical implementation might simply print the errors
+// to stdout.
+class PROTOBUF_EXPORT ErrorCollector {
+ public:
+  inline ErrorCollector() {}
+  virtual ~ErrorCollector();
+
+  // Indicates that there was an error in the input at the given line and
+  // column numbers.  The numbers are zero-based, so you may want to add
+  // 1 to each before printing them.
+  virtual void AddError(int line, ColumnNumber column,
+                        const std::string& message) = 0;
+
+  // Indicates that there was a warning in the input at the given line and
+  // column numbers.  The numbers are zero-based, so you may want to add
+  // 1 to each before printing them.
+  virtual void AddWarning(int /* line */, ColumnNumber /* column */,
+                          const std::string& /* message */) {}
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
+};
+
+// This class converts a stream of raw text into a stream of tokens for
+// the protocol definition parser to parse.  The tokens recognized are
+// similar to those that make up the C language; see the TokenType enum for
+// precise descriptions.  Whitespace and comments are skipped.  By default,
+// C- and C++-style comments are recognized, but other styles can be used by
+// calling set_comment_style().
+class PROTOBUF_EXPORT Tokenizer {
+ public:
+  // Construct a Tokenizer that reads and tokenizes text from the given
+  // input stream and writes errors to the given error_collector.
+  // The caller keeps ownership of input and error_collector.
+  Tokenizer(ZeroCopyInputStream* input, ErrorCollector* error_collector);
+  ~Tokenizer();
+
+  enum TokenType {
+    TYPE_START,  // Next() has not yet been called.
+    TYPE_END,    // End of input reached.  "text" is empty.
+
+    TYPE_IDENTIFIER,  // A sequence of letters, digits, and underscores, not
+                      // starting with a digit.  It is an error for a number
+                      // to be followed by an identifier with no space in
+                      // between.
+    TYPE_INTEGER,     // A sequence of digits representing an integer.  Normally
+                      // the digits are decimal, but a prefix of "0x" indicates
+                      // a hex number and a leading zero indicates octal, just
+                      // like with C numeric literals.  A leading negative sign
+                      // is NOT included in the token; it's up to the parser to
+                      // interpret the unary minus operator on its own.
+    TYPE_FLOAT,       // A floating point literal, with a fractional part and/or
+                      // an exponent.  Always in decimal.  Again, never
+                      // negative.
+    TYPE_STRING,      // A quoted sequence of escaped characters.  Either single
+                      // or double quotes can be used, but they must match.
+                      // A string literal cannot cross a line break.
+    TYPE_SYMBOL,      // Any other printable character, like '!' or '+'.
+                      // Symbols are always a single character, so "!+$%" is
+                      // four tokens.
+    TYPE_WHITESPACE,  // A sequence of whitespace.  This token type is only
+                      // produced if report_whitespace() is true.  It is not
+                      // reported for whitespace within comments or strings.
+    TYPE_NEWLINE,     // A newline (\n).  This token type is only
+                      // produced if report_whitespace() is true and
+                      // report_newlines() is true.  It is not reported for
+                      // newlines in comments or strings.
+  };
+
+  // Structure representing a token read from the token stream.
+  struct Token {
+    TokenType type;
+    std::string text;  // The exact text of the token as it appeared in
+                       // the input.  e.g. tokens of TYPE_STRING will still
+                       // be escaped and in quotes.
+
+    // "line" and "column" specify the position of the first character of
+    // the token within the input stream.  They are zero-based.
+    int line;
+    ColumnNumber column;
+    ColumnNumber end_column;
+  };
+
+  // Get the current token.  This is updated when Next() is called.  Before
+  // the first call to Next(), current() has type TYPE_START and no contents.
+  const Token& current();
+
+  // Return the previous token -- i.e. what current() returned before the
+  // previous call to Next().
+  const Token& previous();
+
+  // Advance to the next token.  Returns false if the end of the input is
+  // reached.
+  bool Next();
+
+  // Like Next(), but also collects comments which appear between the previous
+  // and next tokens.
+  //
+  // Comments which appear to be attached to the previous token are stored
+  // in *prev_tailing_comments.  Comments which appear to be attached to the
+  // next token are stored in *next_leading_comments.  Comments appearing in
+  // between which do not appear to be attached to either will be added to
+  // detached_comments.  Any of these parameters can be NULL to simply discard
+  // the comments.
+  //
+  // A series of line comments appearing on consecutive lines, with no other
+  // tokens appearing on those lines, will be treated as a single comment.
+  //
+  // Only the comment content is returned; comment markers (e.g. //) are
+  // stripped out.  For block comments, leading whitespace and an asterisk will
+  // be stripped from the beginning of each line other than the first.  Newlines
+  // are included in the output.
+  //
+  // Examples:
+  //
+  //   optional int32 foo = 1;  // Comment attached to foo.
+  //   // Comment attached to bar.
+  //   optional int32 bar = 2;
+  //
+  //   optional string baz = 3;
+  //   // Comment attached to baz.
+  //   // Another line attached to baz.
+  //
+  //   // Comment attached to qux.
+  //   //
+  //   // Another line attached to qux.
+  //   optional double qux = 4;
+  //
+  //   // Detached comment.  This is not attached to qux or corge
+  //   // because there are blank lines separating it from both.
+  //
+  //   optional string corge = 5;
+  //   /* Block comment attached
+  //    * to corge.  Leading asterisks
+  //    * will be removed. */
+  //   /* Block comment attached to
+  //    * grault. */
+  //   optional int32 grault = 6;
+  bool NextWithComments(std::string* prev_trailing_comments,
+                        std::vector<std::string>* detached_comments,
+                        std::string* next_leading_comments);
+
+  // Parse helpers ---------------------------------------------------
+
+  // Parses a TYPE_FLOAT token.  This never fails, so long as the text actually
+  // comes from a TYPE_FLOAT token parsed by Tokenizer.  If it doesn't, the
+  // result is undefined (possibly an assert failure).
+  static double ParseFloat(const std::string& text);
+
+  // Parses a TYPE_STRING token.  This never fails, so long as the text actually
+  // comes from a TYPE_STRING token parsed by Tokenizer.  If it doesn't, the
+  // result is undefined (possibly an assert failure).
+  static void ParseString(const std::string& text, std::string* output);
+
+  // Identical to ParseString, but appends to output.
+  static void ParseStringAppend(const std::string& text, std::string* output);
+
+  // Parses a TYPE_INTEGER token.  Returns false if the result would be
+  // greater than max_value.  Otherwise, returns true and sets *output to the
+  // result.  If the text is not from a Token of type TYPE_INTEGER originally
+  // parsed by a Tokenizer, the result is undefined (possibly an assert
+  // failure).
+  static bool ParseInteger(const std::string& text, uint64_t max_value,
+                           uint64_t* output);
+
+  // Options ---------------------------------------------------------
+
+  // Set true to allow floats to be suffixed with the letter 'f'.  Tokens
+  // which would otherwise be integers but which have the 'f' suffix will be
+  // forced to be interpreted as floats.  For all other purposes, the 'f' is
+  // ignored.
+  void set_allow_f_after_float(bool value) { allow_f_after_float_ = value; }
+
+  // Valid values for set_comment_style().
+  enum CommentStyle {
+    // Line comments begin with "//", block comments are delimited by "/*" and
+    // "*/".
+    CPP_COMMENT_STYLE,
+    // Line comments begin with "#".  No way to write block comments.
+    SH_COMMENT_STYLE
+  };
+
+  // Sets the comment style.
+  void set_comment_style(CommentStyle style) { comment_style_ = style; }
+
+  // Whether to require whitespace between a number and a field name.
+  // Default is true. Do not use this; for Google-internal cleanup only.
+  void set_require_space_after_number(bool require) {
+    require_space_after_number_ = require;
+  }
+
+  // Whether to allow string literals to span multiple lines. Default is false.
+  // Do not use this; for Google-internal cleanup only.
+  void set_allow_multiline_strings(bool allow) {
+    allow_multiline_strings_ = allow;
+  }
+
+  // If true, whitespace tokens are reported by Next().
+  // Note: `set_report_whitespace(false)` implies `set_report_newlines(false)`.
+  bool report_whitespace() const;
+  void set_report_whitespace(bool report);
+
+  // If true, newline tokens are reported by Next().
+  // Note: `set_report_newlines(true)` implies `set_report_whitespace(true)`.
+  bool report_newlines() const;
+  void set_report_newlines(bool report);
+
+  // External helper: validate an identifier.
+  static bool IsIdentifier(const std::string& text);
+
+  // -----------------------------------------------------------------
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Tokenizer);
+
+  Token current_;   // Returned by current().
+  Token previous_;  // Returned by previous().
+
+  ZeroCopyInputStream* input_;
+  ErrorCollector* error_collector_;
+
+  char current_char_;   // == buffer_[buffer_pos_], updated by NextChar().
+  const char* buffer_;  // Current buffer returned from input_.
+  int buffer_size_;     // Size of buffer_.
+  int buffer_pos_;      // Current position within the buffer.
+  bool read_error_;     // Did we previously encounter a read error?
+
+  // Line and column number of current_char_ within the whole input stream.
+  int line_;
+  ColumnNumber column_;
+
+  // String to which text should be appended as we advance through it.
+  // Call RecordTo(&str) to start recording and StopRecording() to stop.
+  // E.g. StartToken() calls RecordTo(&current_.text).  record_start_ is the
+  // position within the current buffer where recording started.
+  std::string* record_target_;
+  int record_start_;
+
+  // Options.
+  bool allow_f_after_float_;
+  CommentStyle comment_style_;
+  bool require_space_after_number_;
+  bool allow_multiline_strings_;
+  bool report_whitespace_ = false;
+  bool report_newlines_ = false;
+
+  // Since we count columns we need to interpret tabs somehow.  We'll take
+  // the standard 8-character definition for lack of any way to do better.
+  // This must match the documentation of ColumnNumber.
+  static const int kTabWidth = 8;
+
+  // -----------------------------------------------------------------
+  // Helper methods.
+
+  // Consume this character and advance to the next one.
+  void NextChar();
+
+  // Read a new buffer from the input.
+  void Refresh();
+
+  inline void RecordTo(std::string* target);
+  inline void StopRecording();
+
+  // Called when the current character is the first character of a new
+  // token (not including whitespace or comments).
+  inline void StartToken();
+  // Called when the current character is the first character after the
+  // end of the last token.  After this returns, current_.text will
+  // contain all text consumed since StartToken() was called.
+  inline void EndToken();
+
+  // Convenience method to add an error at the current line and column.
+  void AddError(const std::string& message) {
+    error_collector_->AddError(line_, column_, message);
+  }
+
+  // -----------------------------------------------------------------
+  // The following four methods are used to consume tokens of specific
+  // types.  They are actually used to consume all characters *after*
+  // the first, since the calling function consumes the first character
+  // in order to decide what kind of token is being read.
+
+  // Read and consume a string, ending when the given delimiter is
+  // consumed.
+  void ConsumeString(char delimiter);
+
+  // Read and consume a number, returning TYPE_FLOAT or TYPE_INTEGER
+  // depending on what was read.  This needs to know if the first
+  // character was a zero in order to correctly recognize hex and octal
+  // numbers.
+  // It also needs to know if the first character was a . to parse floating
+  // point correctly.
+  TokenType ConsumeNumber(bool started_with_zero, bool started_with_dot);
+
+  // Consume the rest of a line.
+  void ConsumeLineComment(std::string* content);
+  // Consume until "*/".
+  void ConsumeBlockComment(std::string* content);
+
+  enum NextCommentStatus {
+    // Started a line comment.
+    LINE_COMMENT,
+
+    // Started a block comment.
+    BLOCK_COMMENT,
+
+    // Consumed a slash, then realized it wasn't a comment.  current_ has
+    // been filled in with a slash token.  The caller should return it.
+    SLASH_NOT_COMMENT,
+
+    // We do not appear to be starting a comment here.
+    NO_COMMENT
+  };
+
+  // If we're at the start of a new comment, consume it and return what kind
+  // of comment it is.
+  NextCommentStatus TryConsumeCommentStart();
+
+  // If we're looking at a TYPE_WHITESPACE token and `report_whitespace_` is
+  // true, consume it and return true.
+  bool TryConsumeWhitespace();
+
+  // If we're looking at a TYPE_NEWLINE token and `report_newlines_` is true,
+  // consume it and return true.
+  bool TryConsumeNewline();
+
+  // -----------------------------------------------------------------
+  // These helper methods make the parsing code more readable.  The
+  // "character classes" referred to are defined at the top of the .cc file.
+  // Basically it is a C++ class with one method:
+  //   static bool InClass(char c);
+  // The method returns true if c is a member of this "class", like "Letter"
+  // or "Digit".
+
+  // Returns true if the current character is of the given character
+  // class, but does not consume anything.
+  template <typename CharacterClass>
+  inline bool LookingAt();
+
+  // If the current character is in the given class, consume it and return
+  // true.  Otherwise return false.
+  // e.g. TryConsumeOne<Letter>()
+  template <typename CharacterClass>
+  inline bool TryConsumeOne();
+
+  // Like above, but try to consume the specific character indicated.
+  inline bool TryConsume(char c);
+
+  // Consume zero or more of the given character class.
+  template <typename CharacterClass>
+  inline void ConsumeZeroOrMore();
+
+  // Consume one or more of the given character class or log the given
+  // error message.
+  // e.g. ConsumeOneOrMore<Digit>("Expected digits.");
+  template <typename CharacterClass>
+  inline void ConsumeOneOrMore(const char* error);
+};
+
+// inline methods ====================================================
+inline const Tokenizer::Token& Tokenizer::current() { return current_; }
+
+inline const Tokenizer::Token& Tokenizer::previous() { return previous_; }
+
+inline void Tokenizer::ParseString(const std::string& text,
+                                   std::string* output) {
+  output->clear();
+  ParseStringAppend(text, output);
+}
+
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_IO_TOKENIZER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream.h b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream.h
new file mode 100644
index 0000000..2041cbf
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream.h
@@ -0,0 +1,260 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains the ZeroCopyInputStream and ZeroCopyOutputStream
+// interfaces, which represent abstract I/O streams to and from which
+// protocol buffers can be read and written.  For a few simple
+// implementations of these interfaces, see zero_copy_stream_impl.h.
+//
+// These interfaces are different from classic I/O streams in that they
+// try to minimize the amount of data copying that needs to be done.
+// To accomplish this, responsibility for allocating buffers is moved to
+// the stream object, rather than being the responsibility of the caller.
+// So, the stream can return a buffer which actually points directly into
+// the final data structure where the bytes are to be stored, and the caller
+// can interact directly with that buffer, eliminating an intermediate copy
+// operation.
+//
+// As an example, consider the common case in which you are reading bytes
+// from an array that is already in memory (or perhaps an mmap()ed file).
+// With classic I/O streams, you would do something like:
+//   char buffer[BUFFER_SIZE];
+//   input->Read(buffer, BUFFER_SIZE);
+//   DoSomething(buffer, BUFFER_SIZE);
+// Then, the stream basically just calls memcpy() to copy the data from
+// the array into your buffer.  With a ZeroCopyInputStream, you would do
+// this instead:
+//   const void* buffer;
+//   int size;
+//   input->Next(&buffer, &size);
+//   DoSomething(buffer, size);
+// Here, no copy is performed.  The input stream returns a pointer directly
+// into the backing array, and the caller ends up reading directly from it.
+//
+// If you want to be able to read the old-fashion way, you can create
+// a CodedInputStream or CodedOutputStream wrapping these objects and use
+// their ReadRaw()/WriteRaw() methods.  These will, of course, add a copy
+// step, but Coded*Stream will handle buffering so at least it will be
+// reasonably efficient.
+//
+// ZeroCopyInputStream example:
+//   // Read in a file and print its contents to stdout.
+//   int fd = open("myfile", O_RDONLY);
+//   ZeroCopyInputStream* input = new FileInputStream(fd);
+//
+//   const void* buffer;
+//   int size;
+//   while (input->Next(&buffer, &size)) {
+//     cout.write(buffer, size);
+//   }
+//
+//   delete input;
+//   close(fd);
+//
+// ZeroCopyOutputStream example:
+//   // Copy the contents of "infile" to "outfile", using plain read() for
+//   // "infile" but a ZeroCopyOutputStream for "outfile".
+//   int infd = open("infile", O_RDONLY);
+//   int outfd = open("outfile", O_WRONLY);
+//   ZeroCopyOutputStream* output = new FileOutputStream(outfd);
+//
+//   void* buffer;
+//   int size;
+//   while (output->Next(&buffer, &size)) {
+//     int bytes = read(infd, buffer, size);
+//     if (bytes < size) {
+//       // Reached EOF.
+//       output->BackUp(size - bytes);
+//       break;
+//     }
+//   }
+//
+//   delete output;
+//   close(infd);
+//   close(outfd);
+
+#ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_H__
+#define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_H__
+
+
+#include <google/protobuf/stubs/common.h>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+// Defined in this file.
+class ZeroCopyInputStream;
+class ZeroCopyOutputStream;
+
+// Abstract interface similar to an input stream but designed to minimize
+// copying.
+class PROTOBUF_EXPORT ZeroCopyInputStream {
+ public:
+  ZeroCopyInputStream() {}
+  virtual ~ZeroCopyInputStream() {}
+
+  // Obtains a chunk of data from the stream.
+  //
+  // Preconditions:
+  // * "size" and "data" are not NULL.
+  //
+  // Postconditions:
+  // * If the returned value is false, there is no more data to return or
+  //   an error occurred.  All errors are permanent.
+  // * Otherwise, "size" points to the actual number of bytes read and "data"
+  //   points to a pointer to a buffer containing these bytes.
+  // * Ownership of this buffer remains with the stream, and the buffer
+  //   remains valid only until some other method of the stream is called
+  //   or the stream is destroyed.
+  // * It is legal for the returned buffer to have zero size, as long
+  //   as repeatedly calling Next() eventually yields a buffer with non-zero
+  //   size.
+  virtual bool Next(const void** data, int* size) = 0;
+
+  // Backs up a number of bytes, so that the next call to Next() returns
+  // data again that was already returned by the last call to Next().  This
+  // is useful when writing procedures that are only supposed to read up
+  // to a certain point in the input, then return.  If Next() returns a
+  // buffer that goes beyond what you wanted to read, you can use BackUp()
+  // to return to the point where you intended to finish.
+  //
+  // This method can be called with `count = 0` to finalize (flush) any
+  // previously returned buffer. For example, a file output stream can
+  // flush buffers returned from a previous call to Next() upon such
+  // BackUp(0) invocations. ZeroCopyOutputStream callers should always
+  // invoke BackUp() after a final Next() call, even if there is no
+  // excess buffer data to be backed up to indicate a flush point.
+  //
+  // Preconditions:
+  // * The last method called must have been Next().
+  // * count must be less than or equal to the size of the last buffer
+  //   returned by Next().
+  //
+  // Postconditions:
+  // * The last "count" bytes of the last buffer returned by Next() will be
+  //   pushed back into the stream.  Subsequent calls to Next() will return
+  //   the same data again before producing new data.
+  virtual void BackUp(int count) = 0;
+
+  // Skips a number of bytes.  Returns false if the end of the stream is
+  // reached or some input error occurred.  In the end-of-stream case, the
+  // stream is advanced to the end of the stream (so ByteCount() will return
+  // the total size of the stream).
+  virtual bool Skip(int count) = 0;
+
+  // Returns the total number of bytes read since this object was created.
+  virtual int64_t ByteCount() const = 0;
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyInputStream);
+};
+
+// Abstract interface similar to an output stream but designed to minimize
+// copying.
+class PROTOBUF_EXPORT ZeroCopyOutputStream {
+ public:
+  ZeroCopyOutputStream() {}
+  virtual ~ZeroCopyOutputStream() {}
+
+  // Obtains a buffer into which data can be written.  Any data written
+  // into this buffer will eventually (maybe instantly, maybe later on)
+  // be written to the output.
+  //
+  // Preconditions:
+  // * "size" and "data" are not NULL.
+  //
+  // Postconditions:
+  // * If the returned value is false, an error occurred.  All errors are
+  //   permanent.
+  // * Otherwise, "size" points to the actual number of bytes in the buffer
+  //   and "data" points to the buffer.
+  // * Ownership of this buffer remains with the stream, and the buffer
+  //   remains valid only until some other method of the stream is called
+  //   or the stream is destroyed.
+  // * Any data which the caller stores in this buffer will eventually be
+  //   written to the output (unless BackUp() is called).
+  // * It is legal for the returned buffer to have zero size, as long
+  //   as repeatedly calling Next() eventually yields a buffer with non-zero
+  //   size.
+  virtual bool Next(void** data, int* size) = 0;
+
+  // Backs up a number of bytes, so that the end of the last buffer returned
+  // by Next() is not actually written.  This is needed when you finish
+  // writing all the data you want to write, but the last buffer was bigger
+  // than you needed.  You don't want to write a bunch of garbage after the
+  // end of your data, so you use BackUp() to back up.
+  //
+  // Preconditions:
+  // * The last method called must have been Next().
+  // * count must be less than or equal to the size of the last buffer
+  //   returned by Next().
+  // * The caller must not have written anything to the last "count" bytes
+  //   of that buffer.
+  //
+  // Postconditions:
+  // * The last "count" bytes of the last buffer returned by Next() will be
+  //   ignored.
+  virtual void BackUp(int count) = 0;
+
+  // Returns the total number of bytes written since this object was created.
+  virtual int64_t ByteCount() const = 0;
+
+  // Write a given chunk of data to the output.  Some output streams may
+  // implement this in a way that avoids copying. Check AllowsAliasing() before
+  // calling WriteAliasedRaw(). It will GOOGLE_CHECK fail if WriteAliasedRaw() is
+  // called on a stream that does not allow aliasing.
+  //
+  // NOTE: It is caller's responsibility to ensure that the chunk of memory
+  // remains live until all of the data has been consumed from the stream.
+  virtual bool WriteAliasedRaw(const void* data, int size);
+  virtual bool AllowsAliasing() const { return false; }
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyOutputStream);
+};
+
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl.h b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl.h
new file mode 100644
index 0000000..a385992
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl.h
@@ -0,0 +1,336 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains common implementations of the interfaces defined in
+// zero_copy_stream.h which are only included in the full (non-lite)
+// protobuf library.  These implementations include Unix file descriptors
+// and C++ iostreams.  See also:  zero_copy_stream_impl_lite.h
+
+#ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
+#define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
+
+
+#include <iosfwd>
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+// ===================================================================
+
+// A ZeroCopyInputStream which reads from a file descriptor.
+//
+// FileInputStream is preferred over using an ifstream with IstreamInputStream.
+// The latter will introduce an extra layer of buffering, harming performance.
+// Also, it's conceivable that FileInputStream could someday be enhanced
+// to use zero-copy file descriptors on OSs which support them.
+class PROTOBUF_EXPORT FileInputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyInputStream {
+ public:
+  // Creates a stream that reads from the given Unix file descriptor.
+  // If a block_size is given, it specifies the number of bytes that
+  // should be read and returned with each call to Next().  Otherwise,
+  // a reasonable default is used.
+  explicit FileInputStream(int file_descriptor, int block_size = -1);
+
+  // Flushes any buffers and closes the underlying file.  Returns false if
+  // an error occurs during the process; use GetErrno() to examine the error.
+  // Even if an error occurs, the file descriptor is closed when this returns.
+  bool Close();
+
+  // By default, the file descriptor is not closed when the stream is
+  // destroyed.  Call SetCloseOnDelete(true) to change that.  WARNING:
+  // This leaves no way for the caller to detect if close() fails.  If
+  // detecting close() errors is important to you, you should arrange
+  // to close the descriptor yourself.
+  void SetCloseOnDelete(bool value) { copying_input_.SetCloseOnDelete(value); }
+
+  // If an I/O error has occurred on this file descriptor, this is the
+  // errno from that error.  Otherwise, this is zero.  Once an error
+  // occurs, the stream is broken and all subsequent operations will
+  // fail.
+  int GetErrno() const { return copying_input_.GetErrno(); }
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size) override;
+  void BackUp(int count) override;
+  bool Skip(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  class PROTOBUF_EXPORT CopyingFileInputStream PROTOBUF_FUTURE_FINAL
+      : public CopyingInputStream {
+   public:
+    CopyingFileInputStream(int file_descriptor);
+    ~CopyingFileInputStream() override;
+
+    bool Close();
+    void SetCloseOnDelete(bool value) { close_on_delete_ = value; }
+    int GetErrno() const { return errno_; }
+
+    // implements CopyingInputStream ---------------------------------
+    int Read(void* buffer, int size) override;
+    int Skip(int count) override;
+
+   private:
+    // The file descriptor.
+    const int file_;
+    bool close_on_delete_;
+    bool is_closed_;
+
+    // The errno of the I/O error, if one has occurred.  Otherwise, zero.
+    int errno_;
+
+    // Did we try to seek once and fail?  If so, we assume this file descriptor
+    // doesn't support seeking and won't try again.
+    bool previous_seek_failed_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingFileInputStream);
+  };
+
+  CopyingFileInputStream copying_input_;
+  CopyingInputStreamAdaptor impl_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileInputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyOutputStream which writes to a file descriptor.
+//
+// FileOutputStream is preferred over using an ofstream with
+// OstreamOutputStream.  The latter will introduce an extra layer of buffering,
+// harming performance.  Also, it's conceivable that FileOutputStream could
+// someday be enhanced to use zero-copy file descriptors on OSs which
+// support them.
+class PROTOBUF_EXPORT FileOutputStream PROTOBUF_FUTURE_FINAL
+    : public CopyingOutputStreamAdaptor {
+ public:
+  // Creates a stream that writes to the given Unix file descriptor.
+  // If a block_size is given, it specifies the size of the buffers
+  // that should be returned by Next().  Otherwise, a reasonable default
+  // is used.
+  explicit FileOutputStream(int file_descriptor, int block_size = -1);
+
+  ~FileOutputStream() override;
+
+  // Flushes any buffers and closes the underlying file.  Returns false if
+  // an error occurs during the process; use GetErrno() to examine the error.
+  // Even if an error occurs, the file descriptor is closed when this returns.
+  bool Close();
+
+  // By default, the file descriptor is not closed when the stream is
+  // destroyed.  Call SetCloseOnDelete(true) to change that.  WARNING:
+  // This leaves no way for the caller to detect if close() fails.  If
+  // detecting close() errors is important to you, you should arrange
+  // to close the descriptor yourself.
+  void SetCloseOnDelete(bool value) { copying_output_.SetCloseOnDelete(value); }
+
+  // If an I/O error has occurred on this file descriptor, this is the
+  // errno from that error.  Otherwise, this is zero.  Once an error
+  // occurs, the stream is broken and all subsequent operations will
+  // fail.
+  int GetErrno() const { return copying_output_.GetErrno(); }
+
+ private:
+  class PROTOBUF_EXPORT CopyingFileOutputStream PROTOBUF_FUTURE_FINAL
+      : public CopyingOutputStream {
+   public:
+    CopyingFileOutputStream(int file_descriptor);
+    ~CopyingFileOutputStream() override;
+
+    bool Close();
+    void SetCloseOnDelete(bool value) { close_on_delete_ = value; }
+    int GetErrno() const { return errno_; }
+
+    // implements CopyingOutputStream --------------------------------
+    bool Write(const void* buffer, int size) override;
+
+   private:
+    // The file descriptor.
+    const int file_;
+    bool close_on_delete_;
+    bool is_closed_;
+
+    // The errno of the I/O error, if one has occurred.  Otherwise, zero.
+    int errno_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingFileOutputStream);
+  };
+
+  CopyingFileOutputStream copying_output_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileOutputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyInputStream which reads from a C++ istream.
+//
+// Note that for reading files (or anything represented by a file descriptor),
+// FileInputStream is more efficient.
+class PROTOBUF_EXPORT IstreamInputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyInputStream {
+ public:
+  // Creates a stream that reads from the given C++ istream.
+  // If a block_size is given, it specifies the number of bytes that
+  // should be read and returned with each call to Next().  Otherwise,
+  // a reasonable default is used.
+  explicit IstreamInputStream(std::istream* stream, int block_size = -1);
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size) override;
+  void BackUp(int count) override;
+  bool Skip(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  class PROTOBUF_EXPORT CopyingIstreamInputStream PROTOBUF_FUTURE_FINAL
+      : public CopyingInputStream {
+   public:
+    CopyingIstreamInputStream(std::istream* input);
+    ~CopyingIstreamInputStream() override;
+
+    // implements CopyingInputStream ---------------------------------
+    int Read(void* buffer, int size) override;
+    // (We use the default implementation of Skip().)
+
+   private:
+    // The stream.
+    std::istream* input_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingIstreamInputStream);
+  };
+
+  CopyingIstreamInputStream copying_input_;
+  CopyingInputStreamAdaptor impl_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(IstreamInputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyOutputStream which writes to a C++ ostream.
+//
+// Note that for writing files (or anything represented by a file descriptor),
+// FileOutputStream is more efficient.
+class PROTOBUF_EXPORT OstreamOutputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyOutputStream {
+ public:
+  // Creates a stream that writes to the given C++ ostream.
+  // If a block_size is given, it specifies the size of the buffers
+  // that should be returned by Next().  Otherwise, a reasonable default
+  // is used.
+  explicit OstreamOutputStream(std::ostream* stream, int block_size = -1);
+  ~OstreamOutputStream() override;
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size) override;
+  void BackUp(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  class PROTOBUF_EXPORT CopyingOstreamOutputStream PROTOBUF_FUTURE_FINAL
+      : public CopyingOutputStream {
+   public:
+    CopyingOstreamOutputStream(std::ostream* output);
+    ~CopyingOstreamOutputStream() override;
+
+    // implements CopyingOutputStream --------------------------------
+    bool Write(const void* buffer, int size) override;
+
+   private:
+    // The stream.
+    std::ostream* output_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingOstreamOutputStream);
+  };
+
+  CopyingOstreamOutputStream copying_output_;
+  CopyingOutputStreamAdaptor impl_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OstreamOutputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyInputStream which reads from several other streams in sequence.
+// ConcatenatingInputStream is unable to distinguish between end-of-stream
+// and read errors in the underlying streams, so it assumes any errors mean
+// end-of-stream.  So, if the underlying streams fail for any other reason,
+// ConcatenatingInputStream may do odd things.  It is suggested that you do
+// not use ConcatenatingInputStream on streams that might produce read errors
+// other than end-of-stream.
+class PROTOBUF_EXPORT ConcatenatingInputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyInputStream {
+ public:
+  // All streams passed in as well as the array itself must remain valid
+  // until the ConcatenatingInputStream is destroyed.
+  ConcatenatingInputStream(ZeroCopyInputStream* const streams[], int count);
+  ~ConcatenatingInputStream() override = default;
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size) override;
+  void BackUp(int count) override;
+  bool Skip(int count) override;
+  int64_t ByteCount() const override;
+
+
+ private:
+  // As streams are retired, streams_ is incremented and count_ is
+  // decremented.
+  ZeroCopyInputStream* const* streams_;
+  int stream_count_;
+  int64_t bytes_retired_;  // Bytes read from previous streams.
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ConcatenatingInputStream);
+};
+
+// ===================================================================
+
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl_lite.h b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl_lite.h
new file mode 100644
index 0000000..cbda328
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl_lite.h
@@ -0,0 +1,413 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains common implementations of the interfaces defined in
+// zero_copy_stream.h which are included in the "lite" protobuf library.
+// These implementations cover I/O on raw arrays and strings, as well as
+// adaptors which make it easy to implement streams based on traditional
+// streams.  Of course, many users will probably want to write their own
+// implementations of these interfaces specific to the particular I/O
+// abstractions they prefer to use, but these should cover the most common
+// cases.
+
+#ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
+#define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
+
+
+#include <iosfwd>
+#include <memory>
+#include <string>
+
+#include <google/protobuf/stubs/callback.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/stubs/stl_util.h>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+// ===================================================================
+
+// A ZeroCopyInputStream backed by an in-memory array of bytes.
+class PROTOBUF_EXPORT ArrayInputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyInputStream {
+ public:
+  // Create an InputStream that returns the bytes pointed to by "data".
+  // "data" remains the property of the caller but must remain valid until
+  // the stream is destroyed.  If a block_size is given, calls to Next()
+  // will return data blocks no larger than the given size.  Otherwise, the
+  // first call to Next() returns the entire array.  block_size is mainly
+  // useful for testing; in production you would probably never want to set
+  // it.
+  ArrayInputStream(const void* data, int size, int block_size = -1);
+  ~ArrayInputStream() override = default;
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size) override;
+  void BackUp(int count) override;
+  bool Skip(int count) override;
+  int64_t ByteCount() const override;
+
+
+ private:
+  const uint8_t* const data_;  // The byte array.
+  const int size_;           // Total size of the array.
+  const int block_size_;     // How many bytes to return at a time.
+
+  int position_;
+  int last_returned_size_;  // How many bytes we returned last time Next()
+                            // was called (used for error checking only).
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayInputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyOutputStream backed by an in-memory array of bytes.
+class PROTOBUF_EXPORT ArrayOutputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyOutputStream {
+ public:
+  // Create an OutputStream that writes to the bytes pointed to by "data".
+  // "data" remains the property of the caller but must remain valid until
+  // the stream is destroyed.  If a block_size is given, calls to Next()
+  // will return data blocks no larger than the given size.  Otherwise, the
+  // first call to Next() returns the entire array.  block_size is mainly
+  // useful for testing; in production you would probably never want to set
+  // it.
+  ArrayOutputStream(void* data, int size, int block_size = -1);
+  ~ArrayOutputStream() override = default;
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size) override;
+  void BackUp(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  uint8_t* const data_;     // The byte array.
+  const int size_;        // Total size of the array.
+  const int block_size_;  // How many bytes to return at a time.
+
+  int position_;
+  int last_returned_size_;  // How many bytes we returned last time Next()
+                            // was called (used for error checking only).
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayOutputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyOutputStream which appends bytes to a string.
+class PROTOBUF_EXPORT StringOutputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyOutputStream {
+ public:
+  // Create a StringOutputStream which appends bytes to the given string.
+  // The string remains property of the caller, but it is mutated in arbitrary
+  // ways and MUST NOT be accessed in any way until you're done with the
+  // stream. Either be sure there's no further usage, or (safest) destroy the
+  // stream before using the contents.
+  //
+  // Hint:  If you call target->reserve(n) before creating the stream,
+  //   the first call to Next() will return at least n bytes of buffer
+  //   space.
+  explicit StringOutputStream(std::string* target);
+  ~StringOutputStream() override = default;
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size) override;
+  void BackUp(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  static constexpr size_t kMinimumSize = 16;
+
+  std::string* target_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringOutputStream);
+};
+
+// Note:  There is no StringInputStream.  Instead, just create an
+// ArrayInputStream as follows:
+//   ArrayInputStream input(str.data(), str.size());
+
+// ===================================================================
+
+// A generic traditional input stream interface.
+//
+// Lots of traditional input streams (e.g. file descriptors, C stdio
+// streams, and C++ iostreams) expose an interface where every read
+// involves copying bytes into a buffer.  If you want to take such an
+// interface and make a ZeroCopyInputStream based on it, simply implement
+// CopyingInputStream and then use CopyingInputStreamAdaptor.
+//
+// CopyingInputStream implementations should avoid buffering if possible.
+// CopyingInputStreamAdaptor does its own buffering and will read data
+// in large blocks.
+class PROTOBUF_EXPORT CopyingInputStream {
+ public:
+  virtual ~CopyingInputStream() {}
+
+  // Reads up to "size" bytes into the given buffer.  Returns the number of
+  // bytes read.  Read() waits until at least one byte is available, or
+  // returns zero if no bytes will ever become available (EOF), or -1 if a
+  // permanent read error occurred.
+  virtual int Read(void* buffer, int size) = 0;
+
+  // Skips the next "count" bytes of input.  Returns the number of bytes
+  // actually skipped.  This will always be exactly equal to "count" unless
+  // EOF was reached or a permanent read error occurred.
+  //
+  // The default implementation just repeatedly calls Read() into a scratch
+  // buffer.
+  virtual int Skip(int count);
+};
+
+// A ZeroCopyInputStream which reads from a CopyingInputStream.  This is
+// useful for implementing ZeroCopyInputStreams that read from traditional
+// streams.  Note that this class is not really zero-copy.
+//
+// If you want to read from file descriptors or C++ istreams, this is
+// already implemented for you:  use FileInputStream or IstreamInputStream
+// respectively.
+class PROTOBUF_EXPORT CopyingInputStreamAdaptor : public ZeroCopyInputStream {
+ public:
+  // Creates a stream that reads from the given CopyingInputStream.
+  // If a block_size is given, it specifies the number of bytes that
+  // should be read and returned with each call to Next().  Otherwise,
+  // a reasonable default is used.  The caller retains ownership of
+  // copying_stream unless SetOwnsCopyingStream(true) is called.
+  explicit CopyingInputStreamAdaptor(CopyingInputStream* copying_stream,
+                                     int block_size = -1);
+  ~CopyingInputStreamAdaptor() override;
+
+  // Call SetOwnsCopyingStream(true) to tell the CopyingInputStreamAdaptor to
+  // delete the underlying CopyingInputStream when it is destroyed.
+  void SetOwnsCopyingStream(bool value) { owns_copying_stream_ = value; }
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size) override;
+  void BackUp(int count) override;
+  bool Skip(int count) override;
+  int64_t ByteCount() const override;
+
+ private:
+  // Insures that buffer_ is not NULL.
+  void AllocateBufferIfNeeded();
+  // Frees the buffer and resets buffer_used_.
+  void FreeBuffer();
+
+  // The underlying copying stream.
+  CopyingInputStream* copying_stream_;
+  bool owns_copying_stream_;
+
+  // True if we have seen a permanent error from the underlying stream.
+  bool failed_;
+
+  // The current position of copying_stream_, relative to the point where
+  // we started reading.
+  int64_t position_;
+
+  // Data is read into this buffer.  It may be NULL if no buffer is currently
+  // in use.  Otherwise, it points to an array of size buffer_size_.
+  std::unique_ptr<uint8_t[]> buffer_;
+  const int buffer_size_;
+
+  // Number of valid bytes currently in the buffer (i.e. the size last
+  // returned by Next()).  0 <= buffer_used_ <= buffer_size_.
+  int buffer_used_;
+
+  // Number of bytes in the buffer which were backed up over by a call to
+  // BackUp().  These need to be returned again.
+  // 0 <= backup_bytes_ <= buffer_used_
+  int backup_bytes_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingInputStreamAdaptor);
+};
+
+// ===================================================================
+
+// A generic traditional output stream interface.
+//
+// Lots of traditional output streams (e.g. file descriptors, C stdio
+// streams, and C++ iostreams) expose an interface where every write
+// involves copying bytes from a buffer.  If you want to take such an
+// interface and make a ZeroCopyOutputStream based on it, simply implement
+// CopyingOutputStream and then use CopyingOutputStreamAdaptor.
+//
+// CopyingOutputStream implementations should avoid buffering if possible.
+// CopyingOutputStreamAdaptor does its own buffering and will write data
+// in large blocks.
+class PROTOBUF_EXPORT CopyingOutputStream {
+ public:
+  virtual ~CopyingOutputStream() {}
+
+  // Writes "size" bytes from the given buffer to the output.  Returns true
+  // if successful, false on a write error.
+  virtual bool Write(const void* buffer, int size) = 0;
+};
+
+// A ZeroCopyOutputStream which writes to a CopyingOutputStream.  This is
+// useful for implementing ZeroCopyOutputStreams that write to traditional
+// streams.  Note that this class is not really zero-copy.
+//
+// If you want to write to file descriptors or C++ ostreams, this is
+// already implemented for you:  use FileOutputStream or OstreamOutputStream
+// respectively.
+class PROTOBUF_EXPORT CopyingOutputStreamAdaptor : public ZeroCopyOutputStream {
+ public:
+  // Creates a stream that writes to the given Unix file descriptor.
+  // If a block_size is given, it specifies the size of the buffers
+  // that should be returned by Next().  Otherwise, a reasonable default
+  // is used.
+  explicit CopyingOutputStreamAdaptor(CopyingOutputStream* copying_stream,
+                                      int block_size = -1);
+  ~CopyingOutputStreamAdaptor() override;
+
+  // Writes all pending data to the underlying stream.  Returns false if a
+  // write error occurred on the underlying stream.  (The underlying
+  // stream itself is not necessarily flushed.)
+  bool Flush();
+
+  // Call SetOwnsCopyingStream(true) to tell the CopyingOutputStreamAdaptor to
+  // delete the underlying CopyingOutputStream when it is destroyed.
+  void SetOwnsCopyingStream(bool value) { owns_copying_stream_ = value; }
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size) override;
+  void BackUp(int count) override;
+  int64_t ByteCount() const override;
+  bool WriteAliasedRaw(const void* data, int size) override;
+  bool AllowsAliasing() const override { return true; }
+
+ private:
+  // Write the current buffer, if it is present.
+  bool WriteBuffer();
+  // Insures that buffer_ is not NULL.
+  void AllocateBufferIfNeeded();
+  // Frees the buffer.
+  void FreeBuffer();
+
+  // The underlying copying stream.
+  CopyingOutputStream* copying_stream_;
+  bool owns_copying_stream_;
+
+  // True if we have seen a permanent error from the underlying stream.
+  bool failed_;
+
+  // The current position of copying_stream_, relative to the point where
+  // we started writing.
+  int64_t position_;
+
+  // Data is written from this buffer.  It may be NULL if no buffer is
+  // currently in use.  Otherwise, it points to an array of size buffer_size_.
+  std::unique_ptr<uint8_t[]> buffer_;
+  const int buffer_size_;
+
+  // Number of valid bytes currently in the buffer (i.e. the size last
+  // returned by Next()).  When BackUp() is called, we just reduce this.
+  // 0 <= buffer_used_ <= buffer_size_.
+  int buffer_used_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingOutputStreamAdaptor);
+};
+
+// ===================================================================
+
+// A ZeroCopyInputStream which wraps some other stream and limits it to
+// a particular byte count.
+class PROTOBUF_EXPORT LimitingInputStream PROTOBUF_FUTURE_FINAL
+    : public ZeroCopyInputStream {
+ public:
+  LimitingInputStream(ZeroCopyInputStream* input, int64_t limit);
+  ~LimitingInputStream() override;
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size) override;
+  void BackUp(int count) override;
+  bool Skip(int count) override;
+  int64_t ByteCount() const override;
+
+
+ private:
+  ZeroCopyInputStream* input_;
+  int64_t limit_;  // Decreases as we go, becomes negative if we overshoot.
+  int64_t prior_bytes_read_;  // Bytes read on underlying stream at construction
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LimitingInputStream);
+};
+
+
+// ===================================================================
+
+// mutable_string_data() and as_string_data() are workarounds to improve
+// the performance of writing new data to an existing string.  Unfortunately
+// the methods provided by the string class are suboptimal, and using memcpy()
+// is mildly annoying because it requires its pointer args to be non-NULL even
+// if we ask it to copy 0 bytes.  Furthermore, string_as_array() has the
+// property that it always returns NULL if its arg is the empty string, exactly
+// what we want to avoid if we're using it in conjunction with memcpy()!
+// With C++11, the desired memcpy() boils down to memcpy(..., &(*s)[0], size),
+// where s is a string*.  Without C++11, &(*s)[0] is not guaranteed to be safe,
+// so we use string_as_array(), and live with the extra logic that tests whether
+// *s is empty.
+
+// Return a pointer to mutable characters underlying the given string.  The
+// return value is valid until the next time the string is resized.  We
+// trust the caller to treat the return value as an array of length s->size().
+inline char* mutable_string_data(std::string* s) {
+  // This should be simpler & faster than string_as_array() because the latter
+  // is guaranteed to return NULL when *s is empty, so it has to check for that.
+  return &(*s)[0];
+}
+
+// as_string_data(s) is equivalent to
+//  ({ char* p = mutable_string_data(s); make_pair(p, p != NULL); })
+// Sometimes it's faster: in some scenarios p cannot be NULL, and then the
+// code can avoid that check.
+inline std::pair<char*, bool> as_string_data(std::string* s) {
+  char* p = mutable_string_data(s);
+  return std::make_pair(p, true);
+}
+
+}  // namespace io
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map.h b/CAPI/cpp/grpc/include/google/protobuf/map.h
new file mode 100644
index 0000000..008c192
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/map.h
@@ -0,0 +1,1448 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines the map container and its helpers to support protobuf maps.
+//
+// The Map and MapIterator types are provided by this header file.
+// Please avoid using other types defined here, unless they are public
+// types within Map or MapIterator, such as Map::value_type.
+
+#ifndef GOOGLE_PROTOBUF_MAP_H__
+#define GOOGLE_PROTOBUF_MAP_H__
+
+
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <limits>  // To support Visual Studio 2008
+#include <map>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#if defined(__cpp_lib_string_view)
+#include <string_view>
+#endif  // defined(__cpp_lib_string_view)
+
+#if !defined(GOOGLE_PROTOBUF_NO_RDTSC) && defined(__APPLE__)
+#include <mach/mach_time.h>
+#endif
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/generated_enum_util.h>
+#include <google/protobuf/map_type_handler.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/hash.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+template <typename Key, typename T>
+class Map;
+
+class MapIterator;
+
+template <typename Enum>
+struct is_proto_enum;
+
+namespace internal {
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType key_wire_type,
+          WireFormatLite::FieldType value_wire_type>
+class MapFieldLite;
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType key_wire_type,
+          WireFormatLite::FieldType value_wire_type>
+class MapField;
+
+template <typename Key, typename T>
+class TypeDefinedMapFieldBase;
+
+class DynamicMapField;
+
+class GeneratedMessageReflection;
+
+// re-implement std::allocator to use arena allocator for memory allocation.
+// Used for Map implementation. Users should not use this class
+// directly.
+template <typename U>
+class MapAllocator {
+ public:
+  using value_type = U;
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+
+  constexpr MapAllocator() : arena_(nullptr) {}
+  explicit constexpr MapAllocator(Arena* arena) : arena_(arena) {}
+  template <typename X>
+  MapAllocator(const MapAllocator<X>& allocator)  // NOLINT(runtime/explicit)
+      : arena_(allocator.arena()) {}
+
+  // MapAllocator does not support alignments beyond 8. Technically we should
+  // support up to std::max_align_t, but this fails with ubsan and tcmalloc
+  // debug allocation logic which assume 8 as default alignment.
+  static_assert(alignof(value_type) <= 8, "");
+
+  pointer allocate(size_type n, const void* /* hint */ = nullptr) {
+    // If arena is not given, malloc needs to be called which doesn't
+    // construct element object.
+    if (arena_ == nullptr) {
+      return static_cast<pointer>(::operator new(n * sizeof(value_type)));
+    } else {
+      return reinterpret_cast<pointer>(
+          Arena::CreateArray<uint8_t>(arena_, n * sizeof(value_type)));
+    }
+  }
+
+  void deallocate(pointer p, size_type n) {
+    if (arena_ == nullptr) {
+      internal::SizedDelete(p, n * sizeof(value_type));
+    }
+  }
+
+#if !defined(GOOGLE_PROTOBUF_OS_APPLE) && !defined(GOOGLE_PROTOBUF_OS_NACL) && \
+    !defined(GOOGLE_PROTOBUF_OS_EMSCRIPTEN)
+  template <class NodeType, class... Args>
+  void construct(NodeType* p, Args&&... args) {
+    // Clang 3.6 doesn't compile static casting to void* directly. (Issue
+    // #1266) According C++ standard 5.2.9/1: "The static_cast operator shall
+    // not cast away constness". So first the maybe const pointer is casted to
+    // const void* and after the const void* is const casted.
+    new (const_cast<void*>(static_cast<const void*>(p)))
+        NodeType(std::forward<Args>(args)...);
+  }
+
+  template <class NodeType>
+  void destroy(NodeType* p) {
+    p->~NodeType();
+  }
+#else
+  void construct(pointer p, const_reference t) { new (p) value_type(t); }
+
+  void destroy(pointer p) { p->~value_type(); }
+#endif
+
+  template <typename X>
+  struct rebind {
+    using other = MapAllocator<X>;
+  };
+
+  template <typename X>
+  bool operator==(const MapAllocator<X>& other) const {
+    return arena_ == other.arena_;
+  }
+
+  template <typename X>
+  bool operator!=(const MapAllocator<X>& other) const {
+    return arena_ != other.arena_;
+  }
+
+  // To support Visual Studio 2008
+  size_type max_size() const {
+    // parentheses around (std::...:max) prevents macro warning of max()
+    return (std::numeric_limits<size_type>::max)();
+  }
+
+  // To support gcc-4.4, which does not properly
+  // support templated friend classes
+  Arena* arena() const { return arena_; }
+
+ private:
+  using DestructorSkippable_ = void;
+  Arena* arena_;
+};
+
+template <typename T>
+using KeyForTree =
+    typename std::conditional<std::is_scalar<T>::value, T,
+                              std::reference_wrapper<const T>>::type;
+
+// Default case: Not transparent.
+// We use std::hash<key_type>/std::less<key_type> and all the lookup functions
+// only accept `key_type`.
+template <typename key_type>
+struct TransparentSupport {
+  using hash = std::hash<key_type>;
+  using less = std::less<key_type>;
+
+  static bool Equals(const key_type& a, const key_type& b) { return a == b; }
+
+  template <typename K>
+  using key_arg = key_type;
+};
+
+#if defined(__cpp_lib_string_view)
+// If std::string_view is available, we add transparent support for std::string
+// keys. We use std::hash<std::string_view> as it supports the input types we
+// care about. The lookup functions accept arbitrary `K`. This will include any
+// key type that is convertible to std::string_view.
+template <>
+struct TransparentSupport<std::string> {
+  static std::string_view ImplicitConvert(std::string_view str) { return str; }
+  // If the element is not convertible to std::string_view, try to convert to
+  // std::string first.
+  // The template makes this overload lose resolution when both have the same
+  // rank otherwise.
+  template <typename = void>
+  static std::string_view ImplicitConvert(const std::string& str) {
+    return str;
+  }
+
+  struct hash : private std::hash<std::string_view> {
+    using is_transparent = void;
+
+    template <typename T>
+    size_t operator()(const T& str) const {
+      return base()(ImplicitConvert(str));
+    }
+
+   private:
+    const std::hash<std::string_view>& base() const { return *this; }
+  };
+  struct less {
+    using is_transparent = void;
+
+    template <typename T, typename U>
+    bool operator()(const T& t, const U& u) const {
+      return ImplicitConvert(t) < ImplicitConvert(u);
+    }
+  };
+
+  template <typename T, typename U>
+  static bool Equals(const T& t, const U& u) {
+    return ImplicitConvert(t) == ImplicitConvert(u);
+  }
+
+  template <typename K>
+  using key_arg = K;
+};
+#endif  // defined(__cpp_lib_string_view)
+
+template <typename Key>
+using TreeForMap =
+    std::map<KeyForTree<Key>, void*, typename TransparentSupport<Key>::less,
+             MapAllocator<std::pair<const KeyForTree<Key>, void*>>>;
+
+inline bool TableEntryIsEmpty(void* const* table, size_t b) {
+  return table[b] == nullptr;
+}
+inline bool TableEntryIsNonEmptyList(void* const* table, size_t b) {
+  return table[b] != nullptr && table[b] != table[b ^ 1];
+}
+inline bool TableEntryIsTree(void* const* table, size_t b) {
+  return !TableEntryIsEmpty(table, b) && !TableEntryIsNonEmptyList(table, b);
+}
+inline bool TableEntryIsList(void* const* table, size_t b) {
+  return !TableEntryIsTree(table, b);
+}
+
+// This captures all numeric types.
+inline size_t MapValueSpaceUsedExcludingSelfLong(bool) { return 0; }
+inline size_t MapValueSpaceUsedExcludingSelfLong(const std::string& str) {
+  return StringSpaceUsedExcludingSelfLong(str);
+}
+template <typename T,
+          typename = decltype(std::declval<const T&>().SpaceUsedLong())>
+size_t MapValueSpaceUsedExcludingSelfLong(const T& message) {
+  return message.SpaceUsedLong() - sizeof(T);
+}
+
+constexpr size_t kGlobalEmptyTableSize = 1;
+PROTOBUF_EXPORT extern void* const kGlobalEmptyTable[kGlobalEmptyTableSize];
+
+// Space used for the table, trees, and nodes.
+// Does not include the indirect space used. Eg the data of a std::string.
+template <typename Key>
+PROTOBUF_NOINLINE size_t SpaceUsedInTable(void** table, size_t num_buckets,
+                                          size_t num_elements,
+                                          size_t sizeof_node) {
+  size_t size = 0;
+  // The size of the table.
+  size += sizeof(void*) * num_buckets;
+  // All the nodes.
+  size += sizeof_node * num_elements;
+  // For each tree, count the overhead of the those nodes.
+  // Two buckets at a time because we only care about trees.
+  for (size_t b = 0; b < num_buckets; b += 2) {
+    if (internal::TableEntryIsTree(table, b)) {
+      using Tree = TreeForMap<Key>;
+      Tree* tree = static_cast<Tree*>(table[b]);
+      // Estimated cost of the red-black tree nodes, 3 pointers plus a
+      // bool (plus alignment, so 4 pointers).
+      size += tree->size() *
+              (sizeof(typename Tree::value_type) + sizeof(void*) * 4);
+    }
+  }
+  return size;
+}
+
+template <typename Map,
+          typename = typename std::enable_if<
+              !std::is_scalar<typename Map::key_type>::value ||
+              !std::is_scalar<typename Map::mapped_type>::value>::type>
+size_t SpaceUsedInValues(const Map* map) {
+  size_t size = 0;
+  for (const auto& v : *map) {
+    size += internal::MapValueSpaceUsedExcludingSelfLong(v.first) +
+            internal::MapValueSpaceUsedExcludingSelfLong(v.second);
+  }
+  return size;
+}
+
+inline size_t SpaceUsedInValues(const void*) { return 0; }
+
+}  // namespace internal
+
+// This is the class for Map's internal value_type. Instead of using
+// std::pair as value_type, we use this class which provides us more control of
+// its process of construction and destruction.
+template <typename Key, typename T>
+struct PROTOBUF_ATTRIBUTE_STANDALONE_DEBUG MapPair {
+  using first_type = const Key;
+  using second_type = T;
+
+  MapPair(const Key& other_first, const T& other_second)
+      : first(other_first), second(other_second) {}
+  explicit MapPair(const Key& other_first) : first(other_first), second() {}
+  explicit MapPair(Key&& other_first)
+      : first(std::move(other_first)), second() {}
+  MapPair(const MapPair& other) : first(other.first), second(other.second) {}
+
+  ~MapPair() {}
+
+  // Implicitly convertible to std::pair of compatible types.
+  template <typename T1, typename T2>
+  operator std::pair<T1, T2>() const {  // NOLINT(runtime/explicit)
+    return std::pair<T1, T2>(first, second);
+  }
+
+  const Key first;
+  T second;
+
+ private:
+  friend class Arena;
+  friend class Map<Key, T>;
+};
+
+// Map is an associative container type used to store protobuf map
+// fields.  Each Map instance may or may not use a different hash function, a
+// different iteration order, and so on.  E.g., please don't examine
+// implementation details to decide if the following would work:
+//  Map<int, int> m0, m1;
+//  m0[0] = m1[0] = m0[1] = m1[1] = 0;
+//  assert(m0.begin()->first == m1.begin()->first);  // Bug!
+//
+// Map's interface is similar to std::unordered_map, except that Map is not
+// designed to play well with exceptions.
+template <typename Key, typename T>
+class Map {
+ public:
+  using key_type = Key;
+  using mapped_type = T;
+  using value_type = MapPair<Key, T>;
+
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+
+  using size_type = size_t;
+  using hasher = typename internal::TransparentSupport<Key>::hash;
+
+  constexpr Map() : elements_(nullptr) {}
+  explicit Map(Arena* arena) : elements_(arena) {}
+
+  Map(const Map& other) : Map() { insert(other.begin(), other.end()); }
+
+  Map(Map&& other) noexcept : Map() {
+    if (other.arena() != nullptr) {
+      *this = other;
+    } else {
+      swap(other);
+    }
+  }
+
+  Map& operator=(Map&& other) noexcept {
+    if (this != &other) {
+      if (arena() != other.arena()) {
+        *this = other;
+      } else {
+        swap(other);
+      }
+    }
+    return *this;
+  }
+
+  template <class InputIt>
+  Map(const InputIt& first, const InputIt& last) : Map() {
+    insert(first, last);
+  }
+
+  ~Map() {}
+
+ private:
+  using Allocator = internal::MapAllocator<void*>;
+
+  // InnerMap is a generic hash-based map.  It doesn't contain any
+  // protocol-buffer-specific logic.  It is a chaining hash map with the
+  // additional feature that some buckets can be converted to use an ordered
+  // container.  This ensures O(lg n) bounds on find, insert, and erase, while
+  // avoiding the overheads of ordered containers most of the time.
+  //
+  // The implementation doesn't need the full generality of unordered_map,
+  // and it doesn't have it.  More bells and whistles can be added as needed.
+  // Some implementation details:
+  // 1. The hash function has type hasher and the equality function
+  //    equal_to<Key>.  We inherit from hasher to save space
+  //    (empty-base-class optimization).
+  // 2. The number of buckets is a power of two.
+  // 3. Buckets are converted to trees in pairs: if we convert bucket b then
+  //    buckets b and b^1 will share a tree.  Invariant: buckets b and b^1 have
+  //    the same non-null value iff they are sharing a tree.  (An alternative
+  //    implementation strategy would be to have a tag bit per bucket.)
+  // 4. As is typical for hash_map and such, the Keys and Values are always
+  //    stored in linked list nodes.  Pointers to elements are never invalidated
+  //    until the element is deleted.
+  // 5. The trees' payload type is pointer to linked-list node.  Tree-converting
+  //    a bucket doesn't copy Key-Value pairs.
+  // 6. Once we've tree-converted a bucket, it is never converted back. However,
+  //    the items a tree contains may wind up assigned to trees or lists upon a
+  //    rehash.
+  // 7. The code requires no C++ features from C++14 or later.
+  // 8. Mutations to a map do not invalidate the map's iterators, pointers to
+  //    elements, or references to elements.
+  // 9. Except for erase(iterator), any non-const method can reorder iterators.
+  // 10. InnerMap uses KeyForTree<Key> when using the Tree representation, which
+  //    is either `Key`, if Key is a scalar, or `reference_wrapper<const Key>`
+  //    otherwise. This avoids unnecessary copies of string keys, for example.
+  class InnerMap : private hasher {
+   public:
+    explicit constexpr InnerMap(Arena* arena)
+        : hasher(),
+          num_elements_(0),
+          num_buckets_(internal::kGlobalEmptyTableSize),
+          seed_(0),
+          index_of_first_non_null_(internal::kGlobalEmptyTableSize),
+          table_(const_cast<void**>(internal::kGlobalEmptyTable)),
+          alloc_(arena) {}
+
+    ~InnerMap() {
+      if (alloc_.arena() == nullptr &&
+          num_buckets_ != internal::kGlobalEmptyTableSize) {
+        clear();
+        Dealloc<void*>(table_, num_buckets_);
+      }
+    }
+
+   private:
+    enum { kMinTableSize = 8 };
+
+    // Linked-list nodes, as one would expect for a chaining hash table.
+    struct Node {
+      value_type kv;
+      Node* next;
+    };
+
+    // Trees. The payload type is a copy of Key, so that we can query the tree
+    // with Keys that are not in any particular data structure.
+    // The value is a void* pointing to Node. We use void* instead of Node* to
+    // avoid code bloat. That way there is only one instantiation of the tree
+    // class per key type.
+    using Tree = internal::TreeForMap<Key>;
+    using TreeIterator = typename Tree::iterator;
+
+    static Node* NodeFromTreeIterator(TreeIterator it) {
+      return static_cast<Node*>(it->second);
+    }
+
+    // iterator and const_iterator are instantiations of iterator_base.
+    template <typename KeyValueType>
+    class iterator_base {
+     public:
+      using reference = KeyValueType&;
+      using pointer = KeyValueType*;
+
+      // Invariants:
+      // node_ is always correct. This is handy because the most common
+      // operations are operator* and operator-> and they only use node_.
+      // When node_ is set to a non-null value, all the other non-const fields
+      // are updated to be correct also, but those fields can become stale
+      // if the underlying map is modified.  When those fields are needed they
+      // are rechecked, and updated if necessary.
+      iterator_base() : node_(nullptr), m_(nullptr), bucket_index_(0) {}
+
+      explicit iterator_base(const InnerMap* m) : m_(m) {
+        SearchFrom(m->index_of_first_non_null_);
+      }
+
+      // Any iterator_base can convert to any other.  This is overkill, and we
+      // rely on the enclosing class to use it wisely.  The standard "iterator
+      // can convert to const_iterator" is OK but the reverse direction is not.
+      template <typename U>
+      explicit iterator_base(const iterator_base<U>& it)
+          : node_(it.node_), m_(it.m_), bucket_index_(it.bucket_index_) {}
+
+      iterator_base(Node* n, const InnerMap* m, size_type index)
+          : node_(n), m_(m), bucket_index_(index) {}
+
+      iterator_base(TreeIterator tree_it, const InnerMap* m, size_type index)
+          : node_(NodeFromTreeIterator(tree_it)), m_(m), bucket_index_(index) {
+        // Invariant: iterators that use buckets with trees have an even
+        // bucket_index_.
+        GOOGLE_DCHECK_EQ(bucket_index_ % 2, 0u);
+      }
+
+      // Advance through buckets, looking for the first that isn't empty.
+      // If nothing non-empty is found then leave node_ == nullptr.
+      void SearchFrom(size_type start_bucket) {
+        GOOGLE_DCHECK(m_->index_of_first_non_null_ == m_->num_buckets_ ||
+               m_->table_[m_->index_of_first_non_null_] != nullptr);
+        node_ = nullptr;
+        for (bucket_index_ = start_bucket; bucket_index_ < m_->num_buckets_;
+             bucket_index_++) {
+          if (m_->TableEntryIsNonEmptyList(bucket_index_)) {
+            node_ = static_cast<Node*>(m_->table_[bucket_index_]);
+            break;
+          } else if (m_->TableEntryIsTree(bucket_index_)) {
+            Tree* tree = static_cast<Tree*>(m_->table_[bucket_index_]);
+            GOOGLE_DCHECK(!tree->empty());
+            node_ = NodeFromTreeIterator(tree->begin());
+            break;
+          }
+        }
+      }
+
+      reference operator*() const { return node_->kv; }
+      pointer operator->() const { return &(operator*()); }
+
+      friend bool operator==(const iterator_base& a, const iterator_base& b) {
+        return a.node_ == b.node_;
+      }
+      friend bool operator!=(const iterator_base& a, const iterator_base& b) {
+        return a.node_ != b.node_;
+      }
+
+      iterator_base& operator++() {
+        if (node_->next == nullptr) {
+          TreeIterator tree_it;
+          const bool is_list = revalidate_if_necessary(&tree_it);
+          if (is_list) {
+            SearchFrom(bucket_index_ + 1);
+          } else {
+            GOOGLE_DCHECK_EQ(bucket_index_ & 1, 0u);
+            Tree* tree = static_cast<Tree*>(m_->table_[bucket_index_]);
+            if (++tree_it == tree->end()) {
+              SearchFrom(bucket_index_ + 2);
+            } else {
+              node_ = NodeFromTreeIterator(tree_it);
+            }
+          }
+        } else {
+          node_ = node_->next;
+        }
+        return *this;
+      }
+
+      iterator_base operator++(int /* unused */) {
+        iterator_base tmp = *this;
+        ++*this;
+        return tmp;
+      }
+
+      // Assumes node_ and m_ are correct and non-null, but other fields may be
+      // stale.  Fix them as needed.  Then return true iff node_ points to a
+      // Node in a list.  If false is returned then *it is modified to be
+      // a valid iterator for node_.
+      bool revalidate_if_necessary(TreeIterator* it) {
+        GOOGLE_DCHECK(node_ != nullptr && m_ != nullptr);
+        // Force bucket_index_ to be in range.
+        bucket_index_ &= (m_->num_buckets_ - 1);
+        // Common case: the bucket we think is relevant points to node_.
+        if (m_->table_[bucket_index_] == static_cast<void*>(node_)) return true;
+        // Less common: the bucket is a linked list with node_ somewhere in it,
+        // but not at the head.
+        if (m_->TableEntryIsNonEmptyList(bucket_index_)) {
+          Node* l = static_cast<Node*>(m_->table_[bucket_index_]);
+          while ((l = l->next) != nullptr) {
+            if (l == node_) {
+              return true;
+            }
+          }
+        }
+        // Well, bucket_index_ still might be correct, but probably
+        // not.  Revalidate just to be sure.  This case is rare enough that we
+        // don't worry about potential optimizations, such as having a custom
+        // find-like method that compares Node* instead of the key.
+        iterator_base i(m_->find(node_->kv.first, it));
+        bucket_index_ = i.bucket_index_;
+        return m_->TableEntryIsList(bucket_index_);
+      }
+
+      Node* node_;
+      const InnerMap* m_;
+      size_type bucket_index_;
+    };
+
+   public:
+    using iterator = iterator_base<value_type>;
+    using const_iterator = iterator_base<const value_type>;
+
+    Arena* arena() const { return alloc_.arena(); }
+
+    void Swap(InnerMap* other) {
+      std::swap(num_elements_, other->num_elements_);
+      std::swap(num_buckets_, other->num_buckets_);
+      std::swap(seed_, other->seed_);
+      std::swap(index_of_first_non_null_, other->index_of_first_non_null_);
+      std::swap(table_, other->table_);
+      std::swap(alloc_, other->alloc_);
+    }
+
+    iterator begin() { return iterator(this); }
+    iterator end() { return iterator(); }
+    const_iterator begin() const { return const_iterator(this); }
+    const_iterator end() const { return const_iterator(); }
+
+    void clear() {
+      for (size_type b = 0; b < num_buckets_; b++) {
+        if (TableEntryIsNonEmptyList(b)) {
+          Node* node = static_cast<Node*>(table_[b]);
+          table_[b] = nullptr;
+          do {
+            Node* next = node->next;
+            DestroyNode(node);
+            node = next;
+          } while (node != nullptr);
+        } else if (TableEntryIsTree(b)) {
+          Tree* tree = static_cast<Tree*>(table_[b]);
+          GOOGLE_DCHECK(table_[b] == table_[b + 1] && (b & 1) == 0);
+          table_[b] = table_[b + 1] = nullptr;
+          typename Tree::iterator tree_it = tree->begin();
+          do {
+            Node* node = NodeFromTreeIterator(tree_it);
+            typename Tree::iterator next = tree_it;
+            ++next;
+            tree->erase(tree_it);
+            DestroyNode(node);
+            tree_it = next;
+          } while (tree_it != tree->end());
+          DestroyTree(tree);
+          b++;
+        }
+      }
+      num_elements_ = 0;
+      index_of_first_non_null_ = num_buckets_;
+    }
+
+    const hasher& hash_function() const { return *this; }
+
+    static size_type max_size() {
+      return static_cast<size_type>(1) << (sizeof(void**) >= 8 ? 60 : 28);
+    }
+    size_type size() const { return num_elements_; }
+    bool empty() const { return size() == 0; }
+
+    template <typename K>
+    iterator find(const K& k) {
+      return iterator(FindHelper(k).first);
+    }
+
+    template <typename K>
+    const_iterator find(const K& k) const {
+      return FindHelper(k).first;
+    }
+
+    // Inserts a new element into the container if there is no element with the
+    // key in the container.
+    // The new element is:
+    //  (1) Constructed in-place with the given args, if mapped_type is not
+    //      arena constructible.
+    //  (2) Constructed in-place with the arena and then assigned with a
+    //      mapped_type temporary constructed with the given args, otherwise.
+    template <typename K, typename... Args>
+    std::pair<iterator, bool> try_emplace(K&& k, Args&&... args) {
+      return ArenaAwareTryEmplace(Arena::is_arena_constructable<mapped_type>(),
+                                  std::forward<K>(k),
+                                  std::forward<Args>(args)...);
+    }
+
+    // Inserts the key into the map, if not present. In that case, the value
+    // will be value initialized.
+    template <typename K>
+    std::pair<iterator, bool> insert(K&& k) {
+      return try_emplace(std::forward<K>(k));
+    }
+
+    template <typename K>
+    value_type& operator[](K&& k) {
+      return *try_emplace(std::forward<K>(k)).first;
+    }
+
+    void erase(iterator it) {
+      GOOGLE_DCHECK_EQ(it.m_, this);
+      typename Tree::iterator tree_it;
+      const bool is_list = it.revalidate_if_necessary(&tree_it);
+      size_type b = it.bucket_index_;
+      Node* const item = it.node_;
+      if (is_list) {
+        GOOGLE_DCHECK(TableEntryIsNonEmptyList(b));
+        Node* head = static_cast<Node*>(table_[b]);
+        head = EraseFromLinkedList(item, head);
+        table_[b] = static_cast<void*>(head);
+      } else {
+        GOOGLE_DCHECK(TableEntryIsTree(b));
+        Tree* tree = static_cast<Tree*>(table_[b]);
+        tree->erase(tree_it);
+        if (tree->empty()) {
+          // Force b to be the minimum of b and b ^ 1.  This is important
+          // only because we want index_of_first_non_null_ to be correct.
+          b &= ~static_cast<size_type>(1);
+          DestroyTree(tree);
+          table_[b] = table_[b + 1] = nullptr;
+        }
+      }
+      DestroyNode(item);
+      --num_elements_;
+      if (PROTOBUF_PREDICT_FALSE(b == index_of_first_non_null_)) {
+        while (index_of_first_non_null_ < num_buckets_ &&
+               table_[index_of_first_non_null_] == nullptr) {
+          ++index_of_first_non_null_;
+        }
+      }
+    }
+
+    size_t SpaceUsedInternal() const {
+      return internal::SpaceUsedInTable<Key>(table_, num_buckets_,
+                                             num_elements_, sizeof(Node));
+    }
+
+   private:
+    template <typename K, typename... Args>
+    std::pair<iterator, bool> TryEmplaceInternal(K&& k, Args&&... args) {
+      std::pair<const_iterator, size_type> p = FindHelper(k);
+      // Case 1: key was already present.
+      if (p.first.node_ != nullptr)
+        return std::make_pair(iterator(p.first), false);
+      // Case 2: insert.
+      if (ResizeIfLoadIsOutOfRange(num_elements_ + 1)) {
+        p = FindHelper(k);
+      }
+      const size_type b = p.second;  // bucket number
+      // If K is not key_type, make the conversion to key_type explicit.
+      using TypeToInit = typename std::conditional<
+          std::is_same<typename std::decay<K>::type, key_type>::value, K&&,
+          key_type>::type;
+      Node* node = Alloc<Node>(1);
+      // Even when arena is nullptr, CreateInArenaStorage is still used to
+      // ensure the arena of submessage will be consistent. Otherwise,
+      // submessage may have its own arena when message-owned arena is enabled.
+      // Note: This only works if `Key` is not arena constructible.
+      Arena::CreateInArenaStorage(const_cast<Key*>(&node->kv.first),
+                                  alloc_.arena(),
+                                  static_cast<TypeToInit>(std::forward<K>(k)));
+      // Note: if `T` is arena constructible, `Args` needs to be empty.
+      Arena::CreateInArenaStorage(&node->kv.second, alloc_.arena(),
+                                  std::forward<Args>(args)...);
+
+      iterator result = InsertUnique(b, node);
+      ++num_elements_;
+      return std::make_pair(result, true);
+    }
+
+    // A helper function to perform an assignment of `mapped_type`.
+    // If the first argument is true, then it is a regular assignment.
+    // Otherwise, we first create a temporary and then perform an assignment.
+    template <typename V>
+    static void AssignMapped(std::true_type, mapped_type& mapped, V&& v) {
+      mapped = std::forward<V>(v);
+    }
+    template <typename... Args>
+    static void AssignMapped(std::false_type, mapped_type& mapped,
+                             Args&&... args) {
+      mapped = mapped_type(std::forward<Args>(args)...);
+    }
+
+    // Case 1: `mapped_type` is arena constructible. A temporary object is
+    // created and then (if `Args` are not empty) assigned to a mapped value
+    // that was created with the arena.
+    template <typename K>
+    std::pair<iterator, bool> ArenaAwareTryEmplace(std::true_type, K&& k) {
+      // case 1.1: "default" constructed (e.g. from arena only).
+      return TryEmplaceInternal(std::forward<K>(k));
+    }
+    template <typename K, typename... Args>
+    std::pair<iterator, bool> ArenaAwareTryEmplace(std::true_type, K&& k,
+                                                   Args&&... args) {
+      // case 1.2: "default" constructed + copy/move assignment
+      auto p = TryEmplaceInternal(std::forward<K>(k));
+      if (p.second) {
+        AssignMapped(std::is_same<void(typename std::decay<Args>::type...),
+                                  void(mapped_type)>(),
+                     p.first->second, std::forward<Args>(args)...);
+      }
+      return p;
+    }
+    // Case 2: `mapped_type` is not arena constructible. Using in-place
+    // construction.
+    template <typename... Args>
+    std::pair<iterator, bool> ArenaAwareTryEmplace(std::false_type,
+                                                   Args&&... args) {
+      return TryEmplaceInternal(std::forward<Args>(args)...);
+    }
+
+    const_iterator find(const Key& k, TreeIterator* it) const {
+      return FindHelper(k, it).first;
+    }
+    template <typename K>
+    std::pair<const_iterator, size_type> FindHelper(const K& k) const {
+      return FindHelper(k, nullptr);
+    }
+    template <typename K>
+    std::pair<const_iterator, size_type> FindHelper(const K& k,
+                                                    TreeIterator* it) const {
+      size_type b = BucketNumber(k);
+      if (TableEntryIsNonEmptyList(b)) {
+        Node* node = static_cast<Node*>(table_[b]);
+        do {
+          if (internal::TransparentSupport<Key>::Equals(node->kv.first, k)) {
+            return std::make_pair(const_iterator(node, this, b), b);
+          } else {
+            node = node->next;
+          }
+        } while (node != nullptr);
+      } else if (TableEntryIsTree(b)) {
+        GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
+        b &= ~static_cast<size_t>(1);
+        Tree* tree = static_cast<Tree*>(table_[b]);
+        auto tree_it = tree->find(k);
+        if (tree_it != tree->end()) {
+          if (it != nullptr) *it = tree_it;
+          return std::make_pair(const_iterator(tree_it, this, b), b);
+        }
+      }
+      return std::make_pair(end(), b);
+    }
+
+    // Insert the given Node in bucket b.  If that would make bucket b too big,
+    // and bucket b is not a tree, create a tree for buckets b and b^1 to share.
+    // Requires count(*KeyPtrFromNodePtr(node)) == 0 and that b is the correct
+    // bucket.  num_elements_ is not modified.
+    iterator InsertUnique(size_type b, Node* node) {
+      GOOGLE_DCHECK(index_of_first_non_null_ == num_buckets_ ||
+             table_[index_of_first_non_null_] != nullptr);
+      // In practice, the code that led to this point may have already
+      // determined whether we are inserting into an empty list, a short list,
+      // or whatever.  But it's probably cheap enough to recompute that here;
+      // it's likely that we're inserting into an empty or short list.
+      iterator result;
+      GOOGLE_DCHECK(find(node->kv.first) == end());
+      if (TableEntryIsEmpty(b)) {
+        result = InsertUniqueInList(b, node);
+      } else if (TableEntryIsNonEmptyList(b)) {
+        if (PROTOBUF_PREDICT_FALSE(TableEntryIsTooLong(b))) {
+          TreeConvert(b);
+          result = InsertUniqueInTree(b, node);
+          GOOGLE_DCHECK_EQ(result.bucket_index_, b & ~static_cast<size_type>(1));
+        } else {
+          // Insert into a pre-existing list.  This case cannot modify
+          // index_of_first_non_null_, so we skip the code to update it.
+          return InsertUniqueInList(b, node);
+        }
+      } else {
+        // Insert into a pre-existing tree.  This case cannot modify
+        // index_of_first_non_null_, so we skip the code to update it.
+        return InsertUniqueInTree(b, node);
+      }
+      // parentheses around (std::min) prevents macro expansion of min(...)
+      index_of_first_non_null_ =
+          (std::min)(index_of_first_non_null_, result.bucket_index_);
+      return result;
+    }
+
+    // Returns whether we should insert after the head of the list. For
+    // non-optimized builds, we randomly decide whether to insert right at the
+    // head of the list or just after the head. This helps add a little bit of
+    // non-determinism to the map ordering.
+    bool ShouldInsertAfterHead(void* node) {
+#ifdef NDEBUG
+      (void)node;
+      return false;
+#else
+      // Doing modulo with a prime mixes the bits more.
+      return (reinterpret_cast<uintptr_t>(node) ^ seed_) % 13 > 6;
+#endif
+    }
+
+    // Helper for InsertUnique.  Handles the case where bucket b is a
+    // not-too-long linked list.
+    iterator InsertUniqueInList(size_type b, Node* node) {
+      if (table_[b] != nullptr && ShouldInsertAfterHead(node)) {
+        Node* first = static_cast<Node*>(table_[b]);
+        node->next = first->next;
+        first->next = node;
+        return iterator(node, this, b);
+      }
+
+      node->next = static_cast<Node*>(table_[b]);
+      table_[b] = static_cast<void*>(node);
+      return iterator(node, this, b);
+    }
+
+    // Helper for InsertUnique.  Handles the case where bucket b points to a
+    // Tree.
+    iterator InsertUniqueInTree(size_type b, Node* node) {
+      GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
+      // Maintain the invariant that node->next is null for all Nodes in Trees.
+      node->next = nullptr;
+      return iterator(
+          static_cast<Tree*>(table_[b])->insert({node->kv.first, node}).first,
+          this, b & ~static_cast<size_t>(1));
+    }
+
+    // Returns whether it did resize.  Currently this is only used when
+    // num_elements_ increases, though it could be used in other situations.
+    // It checks for load too low as well as load too high: because any number
+    // of erases can occur between inserts, the load could be as low as 0 here.
+    // Resizing to a lower size is not always helpful, but failing to do so can
+    // destroy the expected big-O bounds for some operations. By having the
+    // policy that sometimes we resize down as well as up, clients can easily
+    // keep O(size()) = O(number of buckets) if they want that.
+    bool ResizeIfLoadIsOutOfRange(size_type new_size) {
+      const size_type kMaxMapLoadTimes16 = 12;  // controls RAM vs CPU tradeoff
+      const size_type hi_cutoff = num_buckets_ * kMaxMapLoadTimes16 / 16;
+      const size_type lo_cutoff = hi_cutoff / 4;
+      // We don't care how many elements are in trees.  If a lot are,
+      // we may resize even though there are many empty buckets.  In
+      // practice, this seems fine.
+      if (PROTOBUF_PREDICT_FALSE(new_size >= hi_cutoff)) {
+        if (num_buckets_ <= max_size() / 2) {
+          Resize(num_buckets_ * 2);
+          return true;
+        }
+      } else if (PROTOBUF_PREDICT_FALSE(new_size <= lo_cutoff &&
+                                        num_buckets_ > kMinTableSize)) {
+        size_type lg2_of_size_reduction_factor = 1;
+        // It's possible we want to shrink a lot here... size() could even be 0.
+        // So, estimate how much to shrink by making sure we don't shrink so
+        // much that we would need to grow the table after a few inserts.
+        const size_type hypothetical_size = new_size * 5 / 4 + 1;
+        while ((hypothetical_size << lg2_of_size_reduction_factor) <
+               hi_cutoff) {
+          ++lg2_of_size_reduction_factor;
+        }
+        size_type new_num_buckets = std::max<size_type>(
+            kMinTableSize, num_buckets_ >> lg2_of_size_reduction_factor);
+        if (new_num_buckets != num_buckets_) {
+          Resize(new_num_buckets);
+          return true;
+        }
+      }
+      return false;
+    }
+
+    // Resize to the given number of buckets.
+    void Resize(size_t new_num_buckets) {
+      if (num_buckets_ == internal::kGlobalEmptyTableSize) {
+        // This is the global empty array.
+        // Just overwrite with a new one. No need to transfer or free anything.
+        num_buckets_ = index_of_first_non_null_ = kMinTableSize;
+        table_ = CreateEmptyTable(num_buckets_);
+        seed_ = Seed();
+        return;
+      }
+
+      GOOGLE_DCHECK_GE(new_num_buckets, kMinTableSize);
+      void** const old_table = table_;
+      const size_type old_table_size = num_buckets_;
+      num_buckets_ = new_num_buckets;
+      table_ = CreateEmptyTable(num_buckets_);
+      const size_type start = index_of_first_non_null_;
+      index_of_first_non_null_ = num_buckets_;
+      for (size_type i = start; i < old_table_size; i++) {
+        if (internal::TableEntryIsNonEmptyList(old_table, i)) {
+          TransferList(old_table, i);
+        } else if (internal::TableEntryIsTree(old_table, i)) {
+          TransferTree(old_table, i++);
+        }
+      }
+      Dealloc<void*>(old_table, old_table_size);
+    }
+
+    void TransferList(void* const* table, size_type index) {
+      Node* node = static_cast<Node*>(table[index]);
+      do {
+        Node* next = node->next;
+        InsertUnique(BucketNumber(node->kv.first), node);
+        node = next;
+      } while (node != nullptr);
+    }
+
+    void TransferTree(void* const* table, size_type index) {
+      Tree* tree = static_cast<Tree*>(table[index]);
+      typename Tree::iterator tree_it = tree->begin();
+      do {
+        InsertUnique(BucketNumber(std::cref(tree_it->first).get()),
+                     NodeFromTreeIterator(tree_it));
+      } while (++tree_it != tree->end());
+      DestroyTree(tree);
+    }
+
+    Node* EraseFromLinkedList(Node* item, Node* head) {
+      if (head == item) {
+        return head->next;
+      } else {
+        head->next = EraseFromLinkedList(item, head->next);
+        return head;
+      }
+    }
+
+    bool TableEntryIsEmpty(size_type b) const {
+      return internal::TableEntryIsEmpty(table_, b);
+    }
+    bool TableEntryIsNonEmptyList(size_type b) const {
+      return internal::TableEntryIsNonEmptyList(table_, b);
+    }
+    bool TableEntryIsTree(size_type b) const {
+      return internal::TableEntryIsTree(table_, b);
+    }
+    bool TableEntryIsList(size_type b) const {
+      return internal::TableEntryIsList(table_, b);
+    }
+
+    void TreeConvert(size_type b) {
+      GOOGLE_DCHECK(!TableEntryIsTree(b) && !TableEntryIsTree(b ^ 1));
+      Tree* tree =
+          Arena::Create<Tree>(alloc_.arena(), typename Tree::key_compare(),
+                              typename Tree::allocator_type(alloc_));
+      size_type count = CopyListToTree(b, tree) + CopyListToTree(b ^ 1, tree);
+      GOOGLE_DCHECK_EQ(count, tree->size());
+      table_[b] = table_[b ^ 1] = static_cast<void*>(tree);
+    }
+
+    // Copy a linked list in the given bucket to a tree.
+    // Returns the number of things it copied.
+    size_type CopyListToTree(size_type b, Tree* tree) {
+      size_type count = 0;
+      Node* node = static_cast<Node*>(table_[b]);
+      while (node != nullptr) {
+        tree->insert({node->kv.first, node});
+        ++count;
+        Node* next = node->next;
+        node->next = nullptr;
+        node = next;
+      }
+      return count;
+    }
+
+    // Return whether table_[b] is a linked list that seems awfully long.
+    // Requires table_[b] to point to a non-empty linked list.
+    bool TableEntryIsTooLong(size_type b) {
+      const size_type kMaxLength = 8;
+      size_type count = 0;
+      Node* node = static_cast<Node*>(table_[b]);
+      do {
+        ++count;
+        node = node->next;
+      } while (node != nullptr);
+      // Invariant: no linked list ever is more than kMaxLength in length.
+      GOOGLE_DCHECK_LE(count, kMaxLength);
+      return count >= kMaxLength;
+    }
+
+    template <typename K>
+    size_type BucketNumber(const K& k) const {
+      // We xor the hash value against the random seed so that we effectively
+      // have a random hash function.
+      uint64_t h = hash_function()(k) ^ seed_;
+
+      // We use the multiplication method to determine the bucket number from
+      // the hash value. The constant kPhi (suggested by Knuth) is roughly
+      // (sqrt(5) - 1) / 2 * 2^64.
+      constexpr uint64_t kPhi = uint64_t{0x9e3779b97f4a7c15};
+      return ((kPhi * h) >> 32) & (num_buckets_ - 1);
+    }
+
+    // Return a power of two no less than max(kMinTableSize, n).
+    // Assumes either n < kMinTableSize or n is a power of two.
+    size_type TableSize(size_type n) {
+      return n < static_cast<size_type>(kMinTableSize)
+                 ? static_cast<size_type>(kMinTableSize)
+                 : n;
+    }
+
+    // Use alloc_ to allocate an array of n objects of type U.
+    template <typename U>
+    U* Alloc(size_type n) {
+      using alloc_type = typename Allocator::template rebind<U>::other;
+      return alloc_type(alloc_).allocate(n);
+    }
+
+    // Use alloc_ to deallocate an array of n objects of type U.
+    template <typename U>
+    void Dealloc(U* t, size_type n) {
+      using alloc_type = typename Allocator::template rebind<U>::other;
+      alloc_type(alloc_).deallocate(t, n);
+    }
+
+    void DestroyNode(Node* node) {
+      if (alloc_.arena() == nullptr) {
+        delete node;
+      }
+    }
+
+    void DestroyTree(Tree* tree) {
+      if (alloc_.arena() == nullptr) {
+        delete tree;
+      }
+    }
+
+    void** CreateEmptyTable(size_type n) {
+      GOOGLE_DCHECK(n >= kMinTableSize);
+      GOOGLE_DCHECK_EQ(n & (n - 1), 0u);
+      void** result = Alloc<void*>(n);
+      memset(result, 0, n * sizeof(result[0]));
+      return result;
+    }
+
+    // Return a randomish value.
+    size_type Seed() const {
+      // We get a little bit of randomness from the address of the map. The
+      // lower bits are not very random, due to alignment, so we discard them
+      // and shift the higher bits into their place.
+      size_type s = reinterpret_cast<uintptr_t>(this) >> 4;
+#if !defined(GOOGLE_PROTOBUF_NO_RDTSC)
+#if defined(__APPLE__)
+      // Use a commpage-based fast time function on Apple environments (MacOS,
+      // iOS, tvOS, watchOS, etc).
+      s += mach_absolute_time();
+#elif defined(__x86_64__) && defined(__GNUC__)
+      uint32_t hi, lo;
+      asm volatile("rdtsc" : "=a"(lo), "=d"(hi));
+      s += ((static_cast<uint64_t>(hi) << 32) | lo);
+#elif defined(__aarch64__) && defined(__GNUC__)
+      // There is no rdtsc on ARMv8. CNTVCT_EL0 is the virtual counter of the
+      // system timer. It runs at a different frequency than the CPU's, but is
+      // the best source of time-based entropy we get.
+      uint64_t virtual_timer_value;
+      asm volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
+      s += virtual_timer_value;
+#endif
+#endif  // !defined(GOOGLE_PROTOBUF_NO_RDTSC)
+      return s;
+    }
+
+    friend class Arena;
+    using InternalArenaConstructable_ = void;
+    using DestructorSkippable_ = void;
+
+    size_type num_elements_;
+    size_type num_buckets_;
+    size_type seed_;
+    size_type index_of_first_non_null_;
+    void** table_;  // an array with num_buckets_ entries
+    Allocator alloc_;
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(InnerMap);
+  };  // end of class InnerMap
+
+  template <typename LookupKey>
+  using key_arg = typename internal::TransparentSupport<
+      key_type>::template key_arg<LookupKey>;
+
+ public:
+  // Iterators
+  class const_iterator {
+    using InnerIt = typename InnerMap::const_iterator;
+
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = typename Map::value_type;
+    using difference_type = ptrdiff_t;
+    using pointer = const value_type*;
+    using reference = const value_type&;
+
+    const_iterator() {}
+    explicit const_iterator(const InnerIt& it) : it_(it) {}
+
+    const_reference operator*() const { return *it_; }
+    const_pointer operator->() const { return &(operator*()); }
+
+    const_iterator& operator++() {
+      ++it_;
+      return *this;
+    }
+    const_iterator operator++(int) { return const_iterator(it_++); }
+
+    friend bool operator==(const const_iterator& a, const const_iterator& b) {
+      return a.it_ == b.it_;
+    }
+    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
+      return !(a == b);
+    }
+
+   private:
+    InnerIt it_;
+  };
+
+  class iterator {
+    using InnerIt = typename InnerMap::iterator;
+
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = typename Map::value_type;
+    using difference_type = ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
+    iterator() {}
+    explicit iterator(const InnerIt& it) : it_(it) {}
+
+    reference operator*() const { return *it_; }
+    pointer operator->() const { return &(operator*()); }
+
+    iterator& operator++() {
+      ++it_;
+      return *this;
+    }
+    iterator operator++(int) { return iterator(it_++); }
+
+    // Allow implicit conversion to const_iterator.
+    operator const_iterator() const {  // NOLINT(runtime/explicit)
+      return const_iterator(typename InnerMap::const_iterator(it_));
+    }
+
+    friend bool operator==(const iterator& a, const iterator& b) {
+      return a.it_ == b.it_;
+    }
+    friend bool operator!=(const iterator& a, const iterator& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class Map;
+
+    InnerIt it_;
+  };
+
+  iterator begin() { return iterator(elements_.begin()); }
+  iterator end() { return iterator(elements_.end()); }
+  const_iterator begin() const { return const_iterator(elements_.begin()); }
+  const_iterator end() const { return const_iterator(elements_.end()); }
+  const_iterator cbegin() const { return begin(); }
+  const_iterator cend() const { return end(); }
+
+  // Capacity
+  size_type size() const { return elements_.size(); }
+  bool empty() const { return size() == 0; }
+
+  // Element access
+  template <typename K = key_type>
+  T& operator[](const key_arg<K>& key) {
+    return elements_[key].second;
+  }
+  template <
+      typename K = key_type,
+      // Disable for integral types to reduce code bloat.
+      typename = typename std::enable_if<!std::is_integral<K>::value>::type>
+  T& operator[](key_arg<K>&& key) {
+    return elements_[std::forward<K>(key)].second;
+  }
+
+  template <typename K = key_type>
+  const T& at(const key_arg<K>& key) const {
+    const_iterator it = find(key);
+    GOOGLE_CHECK(it != end()) << "key not found: " << static_cast<Key>(key);
+    return it->second;
+  }
+
+  template <typename K = key_type>
+  T& at(const key_arg<K>& key) {
+    iterator it = find(key);
+    GOOGLE_CHECK(it != end()) << "key not found: " << static_cast<Key>(key);
+    return it->second;
+  }
+
+  // Lookup
+  template <typename K = key_type>
+  size_type count(const key_arg<K>& key) const {
+    return find(key) == end() ? 0 : 1;
+  }
+
+  template <typename K = key_type>
+  const_iterator find(const key_arg<K>& key) const {
+    return const_iterator(elements_.find(key));
+  }
+  template <typename K = key_type>
+  iterator find(const key_arg<K>& key) {
+    return iterator(elements_.find(key));
+  }
+
+  template <typename K = key_type>
+  bool contains(const key_arg<K>& key) const {
+    return find(key) != end();
+  }
+
+  template <typename K = key_type>
+  std::pair<const_iterator, const_iterator> equal_range(
+      const key_arg<K>& key) const {
+    const_iterator it = find(key);
+    if (it == end()) {
+      return std::pair<const_iterator, const_iterator>(it, it);
+    } else {
+      const_iterator begin = it++;
+      return std::pair<const_iterator, const_iterator>(begin, it);
+    }
+  }
+
+  template <typename K = key_type>
+  std::pair<iterator, iterator> equal_range(const key_arg<K>& key) {
+    iterator it = find(key);
+    if (it == end()) {
+      return std::pair<iterator, iterator>(it, it);
+    } else {
+      iterator begin = it++;
+      return std::pair<iterator, iterator>(begin, it);
+    }
+  }
+
+  // insert
+  template <typename K, typename... Args>
+  std::pair<iterator, bool> try_emplace(K&& k, Args&&... args) {
+    auto p =
+        elements_.try_emplace(std::forward<K>(k), std::forward<Args>(args)...);
+    return std::pair<iterator, bool>(iterator(p.first), p.second);
+  }
+  std::pair<iterator, bool> insert(const value_type& value) {
+    return try_emplace(value.first, value.second);
+  }
+  std::pair<iterator, bool> insert(value_type&& value) {
+    return try_emplace(value.first, std::move(value.second));
+  }
+  template <typename... Args>
+  std::pair<iterator, bool> emplace(Args&&... args) {
+    return insert(value_type(std::forward<Args>(args)...));
+  }
+  template <class InputIt>
+  void insert(InputIt first, InputIt last) {
+    for (; first != last; ++first) {
+      try_emplace(first->first, first->second);
+    }
+  }
+  void insert(std::initializer_list<value_type> values) {
+    insert(values.begin(), values.end());
+  }
+
+  // Erase and clear
+  template <typename K = key_type>
+  size_type erase(const key_arg<K>& key) {
+    iterator it = find(key);
+    if (it == end()) {
+      return 0;
+    } else {
+      erase(it);
+      return 1;
+    }
+  }
+  iterator erase(iterator pos) {
+    iterator i = pos++;
+    elements_.erase(i.it_);
+    return pos;
+  }
+  void erase(iterator first, iterator last) {
+    while (first != last) {
+      first = erase(first);
+    }
+  }
+  void clear() { elements_.clear(); }
+
+  // Assign
+  Map& operator=(const Map& other) {
+    if (this != &other) {
+      clear();
+      insert(other.begin(), other.end());
+    }
+    return *this;
+  }
+
+  void swap(Map& other) {
+    if (arena() == other.arena()) {
+      InternalSwap(other);
+    } else {
+      // TODO(zuguang): optimize this. The temporary copy can be allocated
+      // in the same arena as the other message, and the "other = copy" can
+      // be replaced with the fast-path swap above.
+      Map copy = *this;
+      *this = other;
+      other = copy;
+    }
+  }
+
+  void InternalSwap(Map& other) { elements_.Swap(&other.elements_); }
+
+  // Access to hasher.  Currently this returns a copy, but it may
+  // be modified to return a const reference in the future.
+  hasher hash_function() const { return elements_.hash_function(); }
+
+  size_t SpaceUsedExcludingSelfLong() const {
+    if (empty()) return 0;
+    return elements_.SpaceUsedInternal() + internal::SpaceUsedInValues(this);
+  }
+
+ private:
+  Arena* arena() const { return elements_.arena(); }
+  InnerMap elements_;
+
+  friend class Arena;
+  using InternalArenaConstructable_ = void;
+  using DestructorSkippable_ = void;
+  template <typename Derived, typename K, typename V,
+            internal::WireFormatLite::FieldType key_wire_type,
+            internal::WireFormatLite::FieldType value_wire_type>
+  friend class internal::MapFieldLite;
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_MAP_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_entry.h b/CAPI/cpp/grpc/include/google/protobuf/map_entry.h
new file mode 100644
index 0000000..536dec9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_entry.h
@@ -0,0 +1,134 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_ENTRY_H__
+#define GOOGLE_PROTOBUF_MAP_ENTRY_H__
+
+#include <google/protobuf/port.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/map_entry_lite.h>
+#include <google/protobuf/map_type_handler.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/wire_format_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+class Arena;
+namespace internal {
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+class MapField;
+}
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// MapEntry is the returned google::protobuf::Message when calling AddMessage of
+// google::protobuf::Reflection. In order to let it work with generated message
+// reflection, its in-memory type is the same as generated message with the same
+// fields. However, in order to decide the in-memory type of key/value, we need
+// to know both their cpp type in generated api and proto type. In
+// implementation, all in-memory types have related wire format functions to
+// support except ArenaStringPtr. Therefore, we need to define another type with
+// supporting wire format functions. Since this type is only used as return type
+// of MapEntry accessors, it's named MapEntry accessor type.
+//
+// cpp type:               the type visible to users in public API.
+// proto type:             WireFormatLite::FieldType of the field.
+// in-memory type:         type of the data member used to stored this field.
+// MapEntry accessor type: type used in MapEntry getters/mutators to access the
+//                         field.
+//
+// cpp type | proto type  | in-memory type | MapEntry accessor type
+// int32_t    TYPE_INT32    int32_t          int32_t
+// int32_t    TYPE_FIXED32  int32_t          int32_t
+// string     TYPE_STRING   ArenaStringPtr   string
+// FooEnum    TYPE_ENUM     int              int
+// FooMessage TYPE_MESSAGE  FooMessage*      FooMessage
+//
+// The in-memory types of primitive types can be inferred from its proto type,
+// while we need to explicitly specify the cpp type if proto type is
+// TYPE_MESSAGE to infer the in-memory type.
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+class MapEntry : public MapEntryImpl<Derived, Message, Key, Value,
+                                     kKeyFieldType, kValueFieldType> {
+ public:
+  constexpr MapEntry() {}
+  explicit MapEntry(Arena* arena)
+      : MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType,
+                     kValueFieldType>(arena) {}
+  ~MapEntry() override {
+    Message::_internal_metadata_.template Delete<UnknownFieldSet>();
+  }
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+
+  typedef typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType,
+                                kValueFieldType>::KeyTypeHandler KeyTypeHandler;
+  typedef
+      typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType,
+                            kValueFieldType>::ValueTypeHandler ValueTypeHandler;
+  size_t SpaceUsedLong() const override {
+    size_t size = sizeof(Derived);
+    size += KeyTypeHandler::SpaceUsedInMapEntryLong(this->key_);
+    size += ValueTypeHandler::SpaceUsedInMapEntryLong(this->value_);
+    return size;
+  }
+
+ private:
+  friend class ::PROTOBUF_NAMESPACE_ID::Arena;
+  template <typename C, typename K, typename V,
+            WireFormatLite::FieldType k_wire_type, WireFormatLite::FieldType>
+  friend class internal::MapField;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntry);
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_MAP_ENTRY_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_entry_lite.h b/CAPI/cpp/grpc/include/google/protobuf/map_entry_lite.h
new file mode 100644
index 0000000..6b08cd9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_entry_lite.h
@@ -0,0 +1,563 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
+#define GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
+
+#include <assert.h>
+
+#include <algorithm>
+#include <string>
+#include <utility>
+
+#include <google/protobuf/stubs/casts.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/map.h>
+#include <google/protobuf/map_type_handler.h>
+#include <google/protobuf/parse_context.h>
+#include <google/protobuf/wire_format_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+namespace internal {
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+class MapEntry;
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+class MapFieldLite;
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// MoveHelper::Move is used to set *dest.  It copies *src, or moves it (in
+// the C++11 sense), or swaps it. *src is left in a sane state for
+// subsequent destruction, but shouldn't be used for anything.
+template <bool is_enum, bool is_message, bool is_stringlike, typename T>
+struct MoveHelper {  // primitives
+  static void Move(T* src, T* dest) { *dest = *src; }
+};
+
+template <bool is_message, bool is_stringlike, typename T>
+struct MoveHelper<true, is_message, is_stringlike, T> {  // enums
+  static void Move(T* src, T* dest) { *dest = *src; }
+  // T is an enum here, so allow conversions to and from int.
+  static void Move(T* src, int* dest) { *dest = static_cast<int>(*src); }
+  static void Move(int* src, T* dest) { *dest = static_cast<T>(*src); }
+};
+
+template <bool is_stringlike, typename T>
+struct MoveHelper<false, true, is_stringlike, T> {  // messages
+  static void Move(T* src, T* dest) { dest->Swap(src); }
+};
+
+template <typename T>
+struct MoveHelper<false, false, true, T> {  // strings and similar
+  static void Move(T* src, T* dest) {
+    *dest = std::move(*src);
+  }
+};
+
+// MapEntryImpl is used to implement parsing and serialization of map entries.
+// It uses Curious Recursive Template Pattern (CRTP) to provide the type of
+// the eventual code to the template code.
+template <typename Derived, typename Base, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+class MapEntryImpl : public Base {
+ public:
+  typedef MapEntryFuncs<Key, Value, kKeyFieldType, kValueFieldType> Funcs;
+
+ protected:
+  // Provide utilities to parse/serialize key/value.  Provide utilities to
+  // manipulate internal stored type.
+  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+  typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
+
+  // Define internal memory layout. Strings and messages are stored as
+  // pointers, while other types are stored as values.
+  typedef typename KeyTypeHandler::TypeOnMemory KeyOnMemory;
+  typedef typename ValueTypeHandler::TypeOnMemory ValueOnMemory;
+
+  // Enum type cannot be used for MapTypeHandler::Read. Define a type
+  // which will replace Enum with int.
+  typedef typename KeyTypeHandler::MapEntryAccessorType KeyMapEntryAccessorType;
+  typedef
+      typename ValueTypeHandler::MapEntryAccessorType ValueMapEntryAccessorType;
+
+  // Constants for field number.
+  static const int kKeyFieldNumber = 1;
+  static const int kValueFieldNumber = 2;
+
+  // Constants for field tag.
+  static const uint8_t kKeyTag =
+      GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kKeyFieldNumber, KeyTypeHandler::kWireType);
+  static const uint8_t kValueTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+      kValueFieldNumber, ValueTypeHandler::kWireType);
+  static const size_t kTagSize = 1;
+
+ public:
+  // Work-around for a compiler bug (see repeated_field.h).
+  typedef void MapEntryHasMergeTypeTrait;
+  typedef Derived EntryType;
+  typedef Key EntryKeyType;
+  typedef Value EntryValueType;
+  static const WireFormatLite::FieldType kEntryKeyFieldType = kKeyFieldType;
+  static const WireFormatLite::FieldType kEntryValueFieldType = kValueFieldType;
+
+  constexpr MapEntryImpl()
+      : key_(KeyTypeHandler::Constinit()),
+        value_(ValueTypeHandler::Constinit()),
+        _has_bits_{} {}
+
+  explicit MapEntryImpl(Arena* arena)
+      : Base(arena),
+        key_(KeyTypeHandler::Constinit()),
+        value_(ValueTypeHandler::Constinit()),
+        _has_bits_{} {}
+
+  ~MapEntryImpl() override {
+    if (Base::GetArenaForAllocation() != nullptr) return;
+    KeyTypeHandler::DeleteNoArena(key_);
+    ValueTypeHandler::DeleteNoArena(value_);
+  }
+
+  // accessors ======================================================
+
+  virtual inline const KeyMapEntryAccessorType& key() const {
+    return KeyTypeHandler::GetExternalReference(key_);
+  }
+  virtual inline const ValueMapEntryAccessorType& value() const {
+    return ValueTypeHandler::DefaultIfNotInitialized(value_);
+  }
+  inline KeyMapEntryAccessorType* mutable_key() {
+    set_has_key();
+    return KeyTypeHandler::EnsureMutable(&key_, Base::GetArenaForAllocation());
+  }
+  inline ValueMapEntryAccessorType* mutable_value() {
+    set_has_value();
+    return ValueTypeHandler::EnsureMutable(&value_,
+                                           Base::GetArenaForAllocation());
+  }
+
+  // implements MessageLite =========================================
+
+  // MapEntryImpl is for implementation only and this function isn't called
+  // anywhere. Just provide a fake implementation here for MessageLite.
+  std::string GetTypeName() const override { return ""; }
+
+  void CheckTypeAndMergeFrom(const MessageLite& other) override {
+    MergeFromInternal(*::google::protobuf::internal::DownCast<const Derived*>(&other));
+  }
+
+  const char* _InternalParse(const char* ptr, ParseContext* ctx) final {
+    while (!ctx->Done(&ptr)) {
+      uint32_t tag;
+      ptr = ReadTag(ptr, &tag);
+      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+      if (tag == kKeyTag) {
+        set_has_key();
+        KeyMapEntryAccessorType* key = mutable_key();
+        ptr = KeyTypeHandler::Read(ptr, ctx, key);
+        if (!Derived::ValidateKey(key)) return nullptr;
+      } else if (tag == kValueTag) {
+        set_has_value();
+        ValueMapEntryAccessorType* value = mutable_value();
+        ptr = ValueTypeHandler::Read(ptr, ctx, value);
+        if (!Derived::ValidateValue(value)) return nullptr;
+      } else {
+        if (tag == 0 || WireFormatLite::GetTagWireType(tag) ==
+                            WireFormatLite::WIRETYPE_END_GROUP) {
+          ctx->SetLastTag(tag);
+          return ptr;
+        }
+        ptr = UnknownFieldParse(tag, static_cast<std::string*>(nullptr), ptr,
+                                ctx);
+      }
+      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+    }
+    return ptr;
+  }
+
+  size_t ByteSizeLong() const override {
+    size_t size = 0;
+    size += kTagSize + static_cast<size_t>(KeyTypeHandler::ByteSize(key()));
+    size += kTagSize + static_cast<size_t>(ValueTypeHandler::ByteSize(value()));
+    return size;
+  }
+
+  ::uint8_t* _InternalSerialize(
+      ::uint8_t* ptr, io::EpsCopyOutputStream* stream) const override {
+    ptr = KeyTypeHandler::Write(kKeyFieldNumber, key(), ptr, stream);
+    return ValueTypeHandler::Write(kValueFieldNumber, value(), ptr, stream);
+  }
+
+  // Don't override SerializeWithCachedSizesToArray.  Use MessageLite's.
+
+  int GetCachedSize() const override {
+    int size = 0;
+    size += has_key() ? static_cast<int>(kTagSize) +
+                            KeyTypeHandler::GetCachedSize(key())
+                      : 0;
+    size += has_value() ? static_cast<int>(kTagSize) +
+                              ValueTypeHandler::GetCachedSize(value())
+                        : 0;
+    return size;
+  }
+
+  bool IsInitialized() const override {
+    return ValueTypeHandler::IsInitialized(value_);
+  }
+
+  Base* New(Arena* arena) const override {
+    Derived* entry = Arena::CreateMessage<Derived>(arena);
+    return entry;
+  }
+
+ protected:
+  // We can't declare this function directly here as it would hide the other
+  // overload (const Message&).
+  void MergeFromInternal(const MapEntryImpl& from) {
+    if (from._has_bits_[0]) {
+      if (from.has_key()) {
+        KeyTypeHandler::EnsureMutable(&key_, Base::GetArenaForAllocation());
+        KeyTypeHandler::Merge(from.key(), &key_, Base::GetArenaForAllocation());
+        set_has_key();
+      }
+      if (from.has_value()) {
+        ValueTypeHandler::EnsureMutable(&value_, Base::GetArenaForAllocation());
+        ValueTypeHandler::Merge(from.value(), &value_,
+                                Base::GetArenaForAllocation());
+        set_has_value();
+      }
+    }
+  }
+
+ public:
+  void Clear() override {
+    KeyTypeHandler::Clear(&key_, Base::GetArenaForAllocation());
+    ValueTypeHandler::Clear(&value_, Base::GetArenaForAllocation());
+    clear_has_key();
+    clear_has_value();
+  }
+
+  // Parsing using MergePartialFromCodedStream, above, is not as
+  // efficient as it could be.  This helper class provides a speedier way.
+  template <typename MapField, typename Map>
+  class Parser {
+   public:
+    explicit Parser(MapField* mf) : mf_(mf), map_(mf->MutableMap()) {}
+    ~Parser() {
+      if (entry_ != nullptr && entry_->GetArenaForAllocation() == nullptr)
+        delete entry_;
+    }
+
+    const char* _InternalParse(const char* ptr, ParseContext* ctx) {
+      if (PROTOBUF_PREDICT_TRUE(!ctx->Done(&ptr) && *ptr == kKeyTag)) {
+        ptr = KeyTypeHandler::Read(ptr + 1, ctx, &key_);
+        if (PROTOBUF_PREDICT_FALSE(!ptr || !Derived::ValidateKey(&key_))) {
+          return nullptr;
+        }
+        if (PROTOBUF_PREDICT_TRUE(!ctx->Done(&ptr) && *ptr == kValueTag)) {
+          typename Map::size_type map_size = map_->size();
+          value_ptr_ = &(*map_)[key_];
+          if (PROTOBUF_PREDICT_TRUE(map_size != map_->size())) {
+            using T =
+                typename MapIf<ValueTypeHandler::kIsEnum, int*, Value*>::type;
+            ptr = ValueTypeHandler::Read(ptr + 1, ctx,
+                                         reinterpret_cast<T>(value_ptr_));
+            if (PROTOBUF_PREDICT_FALSE(!ptr ||
+                                       !Derived::ValidateValue(value_ptr_))) {
+              map_->erase(key_);  // Failure! Undo insertion.
+              return nullptr;
+            }
+            if (PROTOBUF_PREDICT_TRUE(ctx->Done(&ptr))) return ptr;
+            if (!ptr) return nullptr;
+            NewEntry();
+            ValueMover::Move(value_ptr_, entry_->mutable_value());
+            map_->erase(key_);
+            goto move_key;
+          }
+        } else {
+          if (!ptr) return nullptr;
+        }
+        NewEntry();
+      move_key:
+        KeyMover::Move(&key_, entry_->mutable_key());
+      } else {
+        if (!ptr) return nullptr;
+        NewEntry();
+      }
+      ptr = entry_->_InternalParse(ptr, ctx);
+      if (ptr) UseKeyAndValueFromEntry();
+      return ptr;
+    }
+
+    template <typename UnknownType>
+    const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
+                                        bool (*is_valid)(int),
+                                        uint32_t field_num,
+                                        InternalMetadata* metadata) {
+      auto entry = NewEntry();
+      ptr = entry->_InternalParse(ptr, ctx);
+      if (!ptr) return nullptr;
+      if (is_valid(entry->value())) {
+        UseKeyAndValueFromEntry();
+      } else {
+        WriteLengthDelimited(field_num, entry->SerializeAsString(),
+                             metadata->mutable_unknown_fields<UnknownType>());
+      }
+      return ptr;
+    }
+
+    MapEntryImpl* NewEntry() { return entry_ = mf_->NewEntry(); }
+
+    const Key& key() const { return key_; }
+    const Value& value() const { return *value_ptr_; }
+
+    const Key& entry_key() const { return entry_->key(); }
+    const Value& entry_value() const { return entry_->value(); }
+
+   private:
+    void UseKeyAndValueFromEntry() {
+      // Update key_ in case we need it later (because key() is called).
+      // This is potentially inefficient, especially if the key is
+      // expensive to copy (e.g., a long string), but this is a cold
+      // path, so it's not a big deal.
+      key_ = entry_->key();
+      value_ptr_ = &(*map_)[key_];
+      ValueMover::Move(entry_->mutable_value(), value_ptr_);
+    }
+
+    // After reading a key and value successfully, and inserting that data
+    // into map_, we are not at the end of the input.  This is unusual, but
+    // allowed by the spec.
+    bool ReadBeyondKeyValuePair(io::CodedInputStream* input) PROTOBUF_COLD {
+      NewEntry();
+      ValueMover::Move(value_ptr_, entry_->mutable_value());
+      map_->erase(key_);
+      KeyMover::Move(&key_, entry_->mutable_key());
+      const bool result = entry_->MergePartialFromCodedStream(input);
+      if (result) UseKeyAndValueFromEntry();
+      return result;
+    }
+
+    typedef MoveHelper<KeyTypeHandler::kIsEnum, KeyTypeHandler::kIsMessage,
+                       KeyTypeHandler::kWireType ==
+                           WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+                       Key>
+        KeyMover;
+    typedef MoveHelper<ValueTypeHandler::kIsEnum, ValueTypeHandler::kIsMessage,
+                       ValueTypeHandler::kWireType ==
+                           WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+                       Value>
+        ValueMover;
+
+    MapField* const mf_;
+    Map* const map_;
+    Key key_;
+    Value* value_ptr_;
+    MapEntryImpl* entry_ = nullptr;
+  };
+
+ protected:
+  void set_has_key() { _has_bits_[0] |= 0x00000001u; }
+  bool has_key() const { return (_has_bits_[0] & 0x00000001u) != 0; }
+  void clear_has_key() { _has_bits_[0] &= ~0x00000001u; }
+  void set_has_value() { _has_bits_[0] |= 0x00000002u; }
+  bool has_value() const { return (_has_bits_[0] & 0x00000002u) != 0; }
+  void clear_has_value() { _has_bits_[0] &= ~0x00000002u; }
+
+ public:
+  inline Arena* GetArena() const { return Base::GetArena(); }
+
+ protected:  // Needed for constructing tables
+  KeyOnMemory key_;
+  ValueOnMemory value_;
+  uint32_t _has_bits_[1];
+
+ private:
+  friend class ::PROTOBUF_NAMESPACE_ID::Arena;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  template <typename C, typename K, typename V, WireFormatLite::FieldType,
+            WireFormatLite::FieldType>
+  friend class internal::MapEntry;
+  template <typename C, typename K, typename V, WireFormatLite::FieldType,
+            WireFormatLite::FieldType>
+  friend class internal::MapFieldLite;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryImpl);
+};
+
+template <typename T, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+class MapEntryLite : public MapEntryImpl<T, MessageLite, Key, Value,
+                                         kKeyFieldType, kValueFieldType> {
+ public:
+  typedef MapEntryImpl<T, MessageLite, Key, Value, kKeyFieldType,
+                       kValueFieldType>
+      SuperType;
+  constexpr MapEntryLite() {}
+  explicit MapEntryLite(Arena* arena) : SuperType(arena) {}
+  ~MapEntryLite() override {
+    MessageLite::_internal_metadata_.template Delete<std::string>();
+  }
+  void MergeFrom(const MapEntryLite& other) { MergeFromInternal(other); }
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryLite);
+};
+
+// Helpers for deterministic serialization =============================
+
+// Iterator base for MapSorterFlat and MapSorterPtr.
+template <typename storage_type>
+struct MapSorterIt {
+  storage_type* ptr;
+  MapSorterIt(storage_type* ptr) : ptr(ptr) {}
+  bool operator==(const MapSorterIt& other) const { return ptr == other.ptr; }
+  bool operator!=(const MapSorterIt& other) const { return !(*this == other); }
+  MapSorterIt& operator++() { ++ptr; return *this; }
+  MapSorterIt operator++(int) { auto other = *this; ++ptr; return other; }
+  MapSorterIt operator+(int v) { return MapSorterIt{ptr + v}; }
+};
+
+// MapSorterFlat stores keys inline with pointers to map entries, so that
+// keys can be compared without indirection. This type is used for maps with
+// keys that are not strings.
+template <typename MapT>
+class MapSorterFlat {
+ public:
+  using value_type = typename MapT::value_type;
+  using storage_type = std::pair<typename MapT::key_type, const value_type*>;
+
+  // This const_iterator dereferenes to the map entry stored in the sorting
+  // array pairs. This is the same interface as the Map::const_iterator type,
+  // and allows generated code to use the same loop body with either form:
+  //   for (const auto& entry : map) { ... }
+  //   for (const auto& entry : MapSorterFlat(map)) { ... }
+  struct const_iterator : public MapSorterIt<storage_type> {
+    using pointer = const typename MapT::value_type*;
+    using reference = const typename MapT::value_type&;
+    using MapSorterIt<storage_type>::MapSorterIt;
+
+    pointer operator->() const { return this->ptr->second; }
+    reference operator*() const { return *this->operator->(); }
+  };
+
+  explicit MapSorterFlat(const MapT& m)
+      : size_(m.size()), items_(size_ ? new storage_type[size_] : nullptr) {
+    if (!size_) return;
+    storage_type* it = &items_[0];
+    for (const auto& entry : m) {
+      *it++ = {entry.first, &entry};
+    }
+    std::sort(&items_[0], &items_[size_],
+              [](const storage_type& a, const storage_type& b) {
+                return a.first < b.first;
+              });
+  }
+  size_t size() const { return size_; }
+  const_iterator begin() const { return {items_.get()}; }
+  const_iterator end() const { return {items_.get() + size_}; }
+
+ private:
+  size_t size_;
+  std::unique_ptr<storage_type[]> items_;
+};
+
+// MapSorterPtr stores and sorts pointers to map entries. This type is used for
+// maps with keys that are strings.
+template <typename MapT>
+class MapSorterPtr {
+ public:
+  using value_type = typename MapT::value_type;
+  using storage_type = const typename MapT::value_type*;
+
+  // This const_iterator dereferenes the map entry pointer stored in the sorting
+  // array. This is the same interface as the Map::const_iterator type, and
+  // allows generated code to use the same loop body with either form:
+  //   for (const auto& entry : map) { ... }
+  //   for (const auto& entry : MapSorterPtr(map)) { ... }
+  struct const_iterator : public MapSorterIt<storage_type> {
+    using pointer = const typename MapT::value_type*;
+    using reference = const typename MapT::value_type&;
+    using MapSorterIt<storage_type>::MapSorterIt;
+
+    pointer operator->() const { return *this->ptr; }
+    reference operator*() const { return *this->operator->(); }
+  };
+
+  explicit MapSorterPtr(const MapT& m)
+      : size_(m.size()), items_(size_ ? new storage_type[size_] : nullptr) {
+    if (!size_) return;
+    storage_type* it = &items_[0];
+    for (const auto& entry : m) {
+      *it++ = &entry;
+    }
+    std::sort(&items_[0], &items_[size_],
+              [](const storage_type& a, const storage_type& b) {
+                return a->first < b->first;
+              });
+  }
+  size_t size() const { return size_; }
+  const_iterator begin() const { return {items_.get()}; }
+  const_iterator end() const { return {items_.get() + size_}; }
+
+ private:
+  size_t size_;
+  std::unique_ptr<storage_type[]> items_;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_field.h b/CAPI/cpp/grpc/include/google/protobuf/map_field.h
new file mode 100644
index 0000000..287d58f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_field.h
@@ -0,0 +1,946 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_FIELD_H__
+#define GOOGLE_PROTOBUF_MAP_FIELD_H__
+
+#include <atomic>
+#include <functional>
+
+#include <google/protobuf/arena.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_lite.h>
+#include <google/protobuf/map_type_handler.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/unknown_field_set.h>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+class DynamicMessage;
+class MapIterator;
+
+// Microsoft compiler complains about non-virtual destructor,
+// even when the destructor is private.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4265)
+#endif  // _MSC_VER
+
+#define TYPE_CHECK(EXPECTEDTYPE, METHOD)                                   \
+  if (type() != EXPECTEDTYPE) {                                            \
+    GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n"                     \
+               << METHOD << " type does not match\n"                       \
+               << "  Expected : "                                          \
+               << FieldDescriptor::CppTypeName(EXPECTEDTYPE) << "\n"       \
+               << "  Actual   : " << FieldDescriptor::CppTypeName(type()); \
+  }
+
+// MapKey is an union type for representing any possible
+// map key.
+class PROTOBUF_EXPORT MapKey {
+ public:
+  MapKey() : type_() {}
+  MapKey(const MapKey& other) : type_() { CopyFrom(other); }
+
+  MapKey& operator=(const MapKey& other) {
+    CopyFrom(other);
+    return *this;
+  }
+
+  ~MapKey() {
+    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
+      val_.string_value_.Destruct();
+    }
+  }
+
+  FieldDescriptor::CppType type() const {
+    if (type_ == FieldDescriptor::CppType()) {
+      GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n"
+                 << "MapKey::type MapKey is not initialized. "
+                 << "Call set methods to initialize MapKey.";
+    }
+    return type_;
+  }
+
+  void SetInt64Value(int64_t value) {
+    SetType(FieldDescriptor::CPPTYPE_INT64);
+    val_.int64_value_ = value;
+  }
+  void SetUInt64Value(uint64_t value) {
+    SetType(FieldDescriptor::CPPTYPE_UINT64);
+    val_.uint64_value_ = value;
+  }
+  void SetInt32Value(int32_t value) {
+    SetType(FieldDescriptor::CPPTYPE_INT32);
+    val_.int32_value_ = value;
+  }
+  void SetUInt32Value(uint32_t value) {
+    SetType(FieldDescriptor::CPPTYPE_UINT32);
+    val_.uint32_value_ = value;
+  }
+  void SetBoolValue(bool value) {
+    SetType(FieldDescriptor::CPPTYPE_BOOL);
+    val_.bool_value_ = value;
+  }
+  void SetStringValue(std::string val) {
+    SetType(FieldDescriptor::CPPTYPE_STRING);
+    *val_.string_value_.get_mutable() = std::move(val);
+  }
+
+  int64_t GetInt64Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapKey::GetInt64Value");
+    return val_.int64_value_;
+  }
+  uint64_t GetUInt64Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapKey::GetUInt64Value");
+    return val_.uint64_value_;
+  }
+  int32_t GetInt32Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapKey::GetInt32Value");
+    return val_.int32_value_;
+  }
+  uint32_t GetUInt32Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapKey::GetUInt32Value");
+    return val_.uint32_value_;
+  }
+  bool GetBoolValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapKey::GetBoolValue");
+    return val_.bool_value_;
+  }
+  const std::string& GetStringValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapKey::GetStringValue");
+    return val_.string_value_.get();
+  }
+
+  bool operator<(const MapKey& other) const {
+    if (type_ != other.type_) {
+      // We could define a total order that handles this case, but
+      // there currently no need.  So, for now, fail.
+      GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
+    }
+    switch (type()) {
+      case FieldDescriptor::CPPTYPE_DOUBLE:
+      case FieldDescriptor::CPPTYPE_FLOAT:
+      case FieldDescriptor::CPPTYPE_ENUM:
+      case FieldDescriptor::CPPTYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Unsupported";
+        return false;
+      case FieldDescriptor::CPPTYPE_STRING:
+        return val_.string_value_.get() < other.val_.string_value_.get();
+      case FieldDescriptor::CPPTYPE_INT64:
+        return val_.int64_value_ < other.val_.int64_value_;
+      case FieldDescriptor::CPPTYPE_INT32:
+        return val_.int32_value_ < other.val_.int32_value_;
+      case FieldDescriptor::CPPTYPE_UINT64:
+        return val_.uint64_value_ < other.val_.uint64_value_;
+      case FieldDescriptor::CPPTYPE_UINT32:
+        return val_.uint32_value_ < other.val_.uint32_value_;
+      case FieldDescriptor::CPPTYPE_BOOL:
+        return val_.bool_value_ < other.val_.bool_value_;
+    }
+    return false;
+  }
+
+  bool operator==(const MapKey& other) const {
+    if (type_ != other.type_) {
+      // To be consistent with operator<, we don't allow this either.
+      GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
+    }
+    switch (type()) {
+      case FieldDescriptor::CPPTYPE_DOUBLE:
+      case FieldDescriptor::CPPTYPE_FLOAT:
+      case FieldDescriptor::CPPTYPE_ENUM:
+      case FieldDescriptor::CPPTYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Unsupported";
+        break;
+      case FieldDescriptor::CPPTYPE_STRING:
+        return val_.string_value_.get() == other.val_.string_value_.get();
+      case FieldDescriptor::CPPTYPE_INT64:
+        return val_.int64_value_ == other.val_.int64_value_;
+      case FieldDescriptor::CPPTYPE_INT32:
+        return val_.int32_value_ == other.val_.int32_value_;
+      case FieldDescriptor::CPPTYPE_UINT64:
+        return val_.uint64_value_ == other.val_.uint64_value_;
+      case FieldDescriptor::CPPTYPE_UINT32:
+        return val_.uint32_value_ == other.val_.uint32_value_;
+      case FieldDescriptor::CPPTYPE_BOOL:
+        return val_.bool_value_ == other.val_.bool_value_;
+    }
+    GOOGLE_LOG(FATAL) << "Can't get here.";
+    return false;
+  }
+
+  void CopyFrom(const MapKey& other) {
+    SetType(other.type());
+    switch (type_) {
+      case FieldDescriptor::CPPTYPE_DOUBLE:
+      case FieldDescriptor::CPPTYPE_FLOAT:
+      case FieldDescriptor::CPPTYPE_ENUM:
+      case FieldDescriptor::CPPTYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Unsupported";
+        break;
+      case FieldDescriptor::CPPTYPE_STRING:
+        *val_.string_value_.get_mutable() = other.val_.string_value_.get();
+        break;
+      case FieldDescriptor::CPPTYPE_INT64:
+        val_.int64_value_ = other.val_.int64_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_INT32:
+        val_.int32_value_ = other.val_.int32_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_UINT64:
+        val_.uint64_value_ = other.val_.uint64_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_UINT32:
+        val_.uint32_value_ = other.val_.uint32_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_BOOL:
+        val_.bool_value_ = other.val_.bool_value_;
+        break;
+    }
+  }
+
+ private:
+  template <typename K, typename V>
+  friend class internal::TypeDefinedMapFieldBase;
+  friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
+  friend class internal::DynamicMapField;
+
+  union KeyValue {
+    KeyValue() {}
+    internal::ExplicitlyConstructed<std::string> string_value_;
+    int64_t int64_value_;
+    int32_t int32_value_;
+    uint64_t uint64_value_;
+    uint32_t uint32_value_;
+    bool bool_value_;
+  } val_;
+
+  void SetType(FieldDescriptor::CppType type) {
+    if (type_ == type) return;
+    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
+      val_.string_value_.Destruct();
+    }
+    type_ = type;
+    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
+      val_.string_value_.DefaultConstruct();
+    }
+  }
+
+  // type_ is 0 or a valid FieldDescriptor::CppType.
+  // Use "CppType()" to indicate zero.
+  FieldDescriptor::CppType type_;
+};
+
+}  // namespace protobuf
+}  // namespace google
+namespace std {
+template <>
+struct hash<::PROTOBUF_NAMESPACE_ID::MapKey> {
+  size_t operator()(const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key) const {
+    switch (map_key.type()) {
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_DOUBLE:
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_FLOAT:
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_ENUM:
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Unsupported";
+        break;
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_STRING:
+        return hash<std::string>()(map_key.GetStringValue());
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_INT64: {
+        auto value = map_key.GetInt64Value();
+        return hash<decltype(value)>()(value);
+      }
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_INT32: {
+        auto value = map_key.GetInt32Value();
+        return hash<decltype(value)>()(map_key.GetInt32Value());
+      }
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_UINT64: {
+        auto value = map_key.GetUInt64Value();
+        return hash<decltype(value)>()(map_key.GetUInt64Value());
+      }
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_UINT32: {
+        auto value = map_key.GetUInt32Value();
+        return hash<decltype(value)>()(map_key.GetUInt32Value());
+      }
+      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_BOOL: {
+        return hash<bool>()(map_key.GetBoolValue());
+      }
+    }
+    GOOGLE_LOG(FATAL) << "Can't get here.";
+    return 0;
+  }
+  bool operator()(const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key1,
+                  const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key2) const {
+    return map_key1 < map_key2;
+  }
+};
+}  // namespace std
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+class ContendedMapCleanTest;
+class GeneratedMessageReflection;
+class MapFieldAccessor;
+
+// This class provides access to map field using reflection, which is the same
+// as those provided for RepeatedPtrField<Message>. It is used for internal
+// reflection implementation only. Users should never use this directly.
+class PROTOBUF_EXPORT MapFieldBase {
+ public:
+  MapFieldBase()
+      : arena_(nullptr), repeated_field_(nullptr), state_(STATE_MODIFIED_MAP) {}
+
+  // This constructor is for constant initialized global instances.
+  // It uses a linker initialized mutex, so it is not compatible with regular
+  // runtime instances.
+  // Except in MSVC, where we can't have a constinit mutex.
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  constexpr MapFieldBase(ConstantInitialized)
+      : arena_(nullptr),
+        repeated_field_(nullptr),
+        mutex_(GOOGLE_PROTOBUF_LINKER_INITIALIZED),
+        state_(STATE_MODIFIED_MAP) {}
+  explicit MapFieldBase(Arena* arena)
+      : arena_(arena), repeated_field_(nullptr), state_(STATE_MODIFIED_MAP) {}
+
+ protected:
+  ~MapFieldBase() {  // "protected" stops users from deleting a `MapFieldBase *`
+    GOOGLE_DCHECK(repeated_field_ == nullptr);
+  }
+  void Destruct();
+
+ public:
+  // Returns reference to internal repeated field. Data written using
+  // Map's api prior to calling this function is guarantted to be
+  // included in repeated field.
+  const RepeatedPtrFieldBase& GetRepeatedField() const;
+
+  // Like above. Returns mutable pointer to the internal repeated field.
+  RepeatedPtrFieldBase* MutableRepeatedField();
+
+  // Pure virtual map APIs for Map Reflection.
+  virtual bool ContainsMapKey(const MapKey& map_key) const = 0;
+  virtual bool InsertOrLookupMapValue(const MapKey& map_key,
+                                      MapValueRef* val) = 0;
+  virtual bool LookupMapValue(const MapKey& map_key,
+                              MapValueConstRef* val) const = 0;
+  bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
+
+  // Returns whether changes to the map are reflected in the repeated field.
+  bool IsRepeatedFieldValid() const;
+  // Insures operations after won't get executed before calling this.
+  bool IsMapValid() const;
+  virtual bool DeleteMapValue(const MapKey& map_key) = 0;
+  virtual bool EqualIterator(const MapIterator& a,
+                             const MapIterator& b) const = 0;
+  virtual void MapBegin(MapIterator* map_iter) const = 0;
+  virtual void MapEnd(MapIterator* map_iter) const = 0;
+  virtual void MergeFrom(const MapFieldBase& other) = 0;
+  virtual void Swap(MapFieldBase* other);
+  virtual void UnsafeShallowSwap(MapFieldBase* other);
+  // Sync Map with repeated field and returns the size of map.
+  virtual int size() const = 0;
+  virtual void Clear() = 0;
+
+  // Returns the number of bytes used by the repeated field, excluding
+  // sizeof(*this)
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+ protected:
+  // Gets the size of space used by map field.
+  virtual size_t SpaceUsedExcludingSelfNoLock() const;
+
+  // Synchronizes the content in Map to RepeatedPtrField if there is any change
+  // to Map after last synchronization.
+  void SyncRepeatedFieldWithMap() const;
+  virtual void SyncRepeatedFieldWithMapNoLock() const;
+
+  // Synchronizes the content in RepeatedPtrField to Map if there is any change
+  // to RepeatedPtrField after last synchronization.
+  void SyncMapWithRepeatedField() const;
+  virtual void SyncMapWithRepeatedFieldNoLock() const {}
+
+  // Tells MapFieldBase that there is new change to Map.
+  void SetMapDirty();
+
+  // Tells MapFieldBase that there is new change to RepeatedPtrField.
+  void SetRepeatedDirty();
+
+  // Provides derived class the access to repeated field.
+  void* MutableRepeatedPtrField() const;
+
+  void InternalSwap(MapFieldBase* other);
+
+  // Support thread sanitizer (tsan) by making const / mutable races
+  // more apparent.  If one thread calls MutableAccess() while another
+  // thread calls either ConstAccess() or MutableAccess(), on the same
+  // MapFieldBase-derived object, and there is no synchronization going
+  // on between them, tsan will alert.
+#if defined(__SANITIZE_THREAD__) || defined(THREAD_SANITIZER)
+  void ConstAccess() const { GOOGLE_CHECK_EQ(seq1_, seq2_); }
+  void MutableAccess() {
+    if (seq1_ & 1) {
+      seq2_ = ++seq1_;
+    } else {
+      seq1_ = ++seq2_;
+    }
+  }
+  unsigned int seq1_ = 0, seq2_ = 0;
+#else
+  void ConstAccess() const {}
+  void MutableAccess() {}
+#endif
+  enum State {
+    STATE_MODIFIED_MAP = 0,       // map has newly added data that has not been
+                                  // synchronized to repeated field
+    STATE_MODIFIED_REPEATED = 1,  // repeated field has newly added data that
+                                  // has not been synchronized to map
+    CLEAN = 2,                    // data in map and repeated field are same
+  };
+
+  Arena* arena_;
+  mutable RepeatedPtrField<Message>* repeated_field_;
+
+  mutable internal::WrappedMutex
+      mutex_;  // The thread to synchronize map and repeated field
+               // needs to get lock first;
+  mutable std::atomic<State> state_;
+
+ private:
+  friend class ContendedMapCleanTest;
+  friend class GeneratedMessageReflection;
+  friend class MapFieldAccessor;
+  friend class ::PROTOBUF_NAMESPACE_ID::Reflection;
+  friend class ::PROTOBUF_NAMESPACE_ID::DynamicMessage;
+
+  // Virtual helper methods for MapIterator. MapIterator doesn't have the
+  // type helper for key and value. Call these help methods to deal with
+  // different types. Real helper methods are implemented in
+  // TypeDefinedMapFieldBase.
+  friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
+  // Allocate map<...>::iterator for MapIterator.
+  virtual void InitializeIterator(MapIterator* map_iter) const = 0;
+
+  // DeleteIterator() is called by the destructor of MapIterator only.
+  // It deletes map<...>::iterator for MapIterator.
+  virtual void DeleteIterator(MapIterator* map_iter) const = 0;
+
+  // Copy the map<...>::iterator from other_iterator to
+  // this_iterator.
+  virtual void CopyIterator(MapIterator* this_iterator,
+                            const MapIterator& other_iterator) const = 0;
+
+  // IncreaseIterator() is called by operator++() of MapIterator only.
+  // It implements the ++ operator of MapIterator.
+  virtual void IncreaseIterator(MapIterator* map_iter) const = 0;
+
+  // Swaps state_ with another MapFieldBase
+  void SwapState(MapFieldBase* other);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapFieldBase);
+};
+
+// This class provides common Map Reflection implementations for generated
+// message and dynamic message.
+template <typename Key, typename T>
+class TypeDefinedMapFieldBase : public MapFieldBase {
+ public:
+  TypeDefinedMapFieldBase() {}
+
+  // This constructor is for constant initialized global instances.
+  // It uses a linker initialized mutex, so it is not compatible with regular
+  // runtime instances.
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  constexpr TypeDefinedMapFieldBase(ConstantInitialized tag)
+      : MapFieldBase(tag) {}
+  explicit TypeDefinedMapFieldBase(Arena* arena) : MapFieldBase(arena) {}
+  TypeDefinedMapFieldBase(ArenaInitialized, Arena* arena)
+      : TypeDefinedMapFieldBase(arena) {}
+
+ protected:
+  ~TypeDefinedMapFieldBase() {}
+  using MapFieldBase::Destruct;
+
+ public:
+  void MapBegin(MapIterator* map_iter) const override;
+  void MapEnd(MapIterator* map_iter) const override;
+  bool EqualIterator(const MapIterator& a, const MapIterator& b) const override;
+
+  virtual const Map<Key, T>& GetMap() const = 0;
+  virtual Map<Key, T>* MutableMap() = 0;
+
+ protected:
+  typename Map<Key, T>::const_iterator& InternalGetIterator(
+      const MapIterator* map_iter) const;
+
+ private:
+  void InitializeIterator(MapIterator* map_iter) const override;
+  void DeleteIterator(MapIterator* map_iter) const override;
+  void CopyIterator(MapIterator* this_iteratorm,
+                    const MapIterator& that_iterator) const override;
+  void IncreaseIterator(MapIterator* map_iter) const override;
+
+  virtual void SetMapIteratorValue(MapIterator* map_iter) const = 0;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeDefinedMapFieldBase);
+};
+
+// This class provides access to map field using generated api. It is used for
+// internal generated message implementation only. Users should never use this
+// directly.
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+class MapField : public TypeDefinedMapFieldBase<Key, T> {
+  // Provide utilities to parse/serialize key/value.  Provide utilities to
+  // manipulate internal stored type.
+  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+  typedef MapTypeHandler<kValueFieldType, T> ValueTypeHandler;
+
+  // Define message type for internal repeated field.
+  typedef Derived EntryType;
+
+  // Define abbreviation for parent MapFieldLite
+  typedef MapFieldLite<Derived, Key, T, kKeyFieldType, kValueFieldType>
+      MapFieldLiteType;
+
+  // Enum needs to be handled differently from other types because it has
+  // different exposed type in Map's api and repeated field's api. For
+  // details see the comment in the implementation of
+  // SyncMapWithRepeatedFieldNoLock.
+  static constexpr bool kIsValueEnum = ValueTypeHandler::kIsEnum;
+  typedef typename MapIf<kIsValueEnum, T, const T&>::type CastValueType;
+
+ public:
+  typedef Map<Key, T> MapType;
+
+  MapField() : impl_() {}
+  virtual ~MapField() {}  // Destruct() must already have been called!
+  void Destruct() {
+    impl_.Destruct();
+    TypeDefinedMapFieldBase<Key, T>::Destruct();
+  }
+
+  // This constructor is for constant initialized global instances.
+  // It uses a linker initialized mutex, so it is not compatible with regular
+  // runtime instances.
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  constexpr MapField(ConstantInitialized tag)
+      : TypeDefinedMapFieldBase<Key, T>(tag), impl_() {}
+  explicit MapField(Arena* arena)
+      : TypeDefinedMapFieldBase<Key, T>(arena), impl_(arena) {}
+  MapField(ArenaInitialized, Arena* arena) : MapField(arena) {}
+
+  // Implement MapFieldBase
+  bool ContainsMapKey(const MapKey& map_key) const override;
+  bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val) override;
+  bool LookupMapValue(const MapKey& map_key,
+                      MapValueConstRef* val) const override;
+  bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
+  bool DeleteMapValue(const MapKey& map_key) override;
+
+  const Map<Key, T>& GetMap() const override {
+    MapFieldBase::SyncMapWithRepeatedField();
+    return impl_.GetMap();
+  }
+
+  Map<Key, T>* MutableMap() override {
+    MapFieldBase::SyncMapWithRepeatedField();
+    Map<Key, T>* result = impl_.MutableMap();
+    MapFieldBase::SetMapDirty();
+    return result;
+  }
+
+  int size() const override;
+  void Clear() override;
+  void MergeFrom(const MapFieldBase& other) override;
+  void Swap(MapFieldBase* other) override;
+  void UnsafeShallowSwap(MapFieldBase* other) override;
+  void InternalSwap(MapField* other);
+
+  // Used in the implementation of parsing. Caller should take the ownership iff
+  // arena_ is nullptr.
+  EntryType* NewEntry() const { return impl_.NewEntry(); }
+
+  const char* _InternalParse(const char* ptr, ParseContext* ctx) {
+    return impl_._InternalParse(ptr, ctx);
+  }
+  template <typename UnknownType>
+  const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
+                                      bool (*is_valid)(int), uint32_t field_num,
+                                      InternalMetadata* metadata) {
+    return impl_.template ParseWithEnumValidation<UnknownType>(
+        ptr, ctx, is_valid, field_num, metadata);
+  }
+
+ private:
+  MapFieldLiteType impl_;
+
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+
+  // Implements MapFieldBase
+  void SyncRepeatedFieldWithMapNoLock() const override;
+  void SyncMapWithRepeatedFieldNoLock() const override;
+  size_t SpaceUsedExcludingSelfNoLock() const override;
+
+  void SetMapIteratorValue(MapIterator* map_iter) const override;
+
+  friend class ::PROTOBUF_NAMESPACE_ID::Arena;
+  friend class MapFieldStateTest;  // For testing, it needs raw access to impl_
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapField);
+};
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType key_wire_type,
+          WireFormatLite::FieldType value_wire_type>
+bool AllAreInitialized(
+    const MapField<Derived, Key, T, key_wire_type, value_wire_type>& field) {
+  const auto& t = field.GetMap();
+  for (typename Map<Key, T>::const_iterator it = t.begin(); it != t.end();
+       ++it) {
+    if (!it->second.IsInitialized()) return false;
+  }
+  return true;
+}
+
+template <typename T, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+struct MapEntryToMapField<
+    MapEntry<T, Key, Value, kKeyFieldType, kValueFieldType>> {
+  typedef MapField<T, Key, Value, kKeyFieldType, kValueFieldType> MapFieldType;
+};
+
+class PROTOBUF_EXPORT DynamicMapField
+    : public TypeDefinedMapFieldBase<MapKey, MapValueRef> {
+ public:
+  explicit DynamicMapField(const Message* default_entry);
+  DynamicMapField(const Message* default_entry, Arena* arena);
+  virtual ~DynamicMapField();
+
+  // Implement MapFieldBase
+  bool ContainsMapKey(const MapKey& map_key) const override;
+  bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val) override;
+  bool LookupMapValue(const MapKey& map_key,
+                      MapValueConstRef* val) const override;
+  bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
+  bool DeleteMapValue(const MapKey& map_key) override;
+  void MergeFrom(const MapFieldBase& other) override;
+  void Swap(MapFieldBase* other) override;
+  void UnsafeShallowSwap(MapFieldBase* other) override { Swap(other); }
+
+  const Map<MapKey, MapValueRef>& GetMap() const override;
+  Map<MapKey, MapValueRef>* MutableMap() override;
+
+  int size() const override;
+  void Clear() override;
+
+ private:
+  Map<MapKey, MapValueRef> map_;
+  const Message* default_entry_;
+
+  void AllocateMapValue(MapValueRef* map_val);
+
+  // Implements MapFieldBase
+  void SyncRepeatedFieldWithMapNoLock() const override;
+  void SyncMapWithRepeatedFieldNoLock() const override;
+  size_t SpaceUsedExcludingSelfNoLock() const override;
+  void SetMapIteratorValue(MapIterator* map_iter) const override;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMapField);
+};
+
+}  // namespace internal
+
+// MapValueConstRef points to a map value. Users can NOT modify
+// the map value.
+class PROTOBUF_EXPORT MapValueConstRef {
+ public:
+  MapValueConstRef() : data_(nullptr), type_() {}
+
+  int64_t GetInt64Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
+               "MapValueConstRef::GetInt64Value");
+    return *reinterpret_cast<int64_t*>(data_);
+  }
+  uint64_t GetUInt64Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
+               "MapValueConstRef::GetUInt64Value");
+    return *reinterpret_cast<uint64_t*>(data_);
+  }
+  int32_t GetInt32Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
+               "MapValueConstRef::GetInt32Value");
+    return *reinterpret_cast<int32_t*>(data_);
+  }
+  uint32_t GetUInt32Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
+               "MapValueConstRef::GetUInt32Value");
+    return *reinterpret_cast<uint32_t*>(data_);
+  }
+  bool GetBoolValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueConstRef::GetBoolValue");
+    return *reinterpret_cast<bool*>(data_);
+  }
+  int GetEnumValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM, "MapValueConstRef::GetEnumValue");
+    return *reinterpret_cast<int*>(data_);
+  }
+  const std::string& GetStringValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
+               "MapValueConstRef::GetStringValue");
+    return *reinterpret_cast<std::string*>(data_);
+  }
+  float GetFloatValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT,
+               "MapValueConstRef::GetFloatValue");
+    return *reinterpret_cast<float*>(data_);
+  }
+  double GetDoubleValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE,
+               "MapValueConstRef::GetDoubleValue");
+    return *reinterpret_cast<double*>(data_);
+  }
+
+  const Message& GetMessageValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE,
+               "MapValueConstRef::GetMessageValue");
+    return *reinterpret_cast<Message*>(data_);
+  }
+
+ protected:
+  // data_ point to a map value. MapValueConstRef does not
+  // own this value.
+  void* data_;
+  // type_ is 0 or a valid FieldDescriptor::CppType.
+  // Use "CppType()" to indicate zero.
+  FieldDescriptor::CppType type_;
+
+  FieldDescriptor::CppType type() const {
+    if (type_ == FieldDescriptor::CppType() || data_ == nullptr) {
+      GOOGLE_LOG(FATAL)
+          << "Protocol Buffer map usage error:\n"
+          << "MapValueConstRef::type MapValueConstRef is not initialized.";
+    }
+    return type_;
+  }
+
+ private:
+  template <typename Derived, typename K, typename V,
+            internal::WireFormatLite::FieldType key_wire_type,
+            internal::WireFormatLite::FieldType value_wire_type>
+  friend class internal::MapField;
+  template <typename K, typename V>
+  friend class internal::TypeDefinedMapFieldBase;
+  friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
+  friend class Reflection;
+  friend class internal::DynamicMapField;
+
+  void SetType(FieldDescriptor::CppType type) { type_ = type; }
+  void SetValue(const void* val) { data_ = const_cast<void*>(val); }
+  void CopyFrom(const MapValueConstRef& other) {
+    type_ = other.type_;
+    data_ = other.data_;
+  }
+};
+
+// MapValueRef points to a map value. Users are able to modify
+// the map value.
+class PROTOBUF_EXPORT MapValueRef final : public MapValueConstRef {
+ public:
+  MapValueRef() {}
+
+  void SetInt64Value(int64_t value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapValueRef::SetInt64Value");
+    *reinterpret_cast<int64_t*>(data_) = value;
+  }
+  void SetUInt64Value(uint64_t value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapValueRef::SetUInt64Value");
+    *reinterpret_cast<uint64_t*>(data_) = value;
+  }
+  void SetInt32Value(int32_t value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapValueRef::SetInt32Value");
+    *reinterpret_cast<int32_t*>(data_) = value;
+  }
+  void SetUInt32Value(uint32_t value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapValueRef::SetUInt32Value");
+    *reinterpret_cast<uint32_t*>(data_) = value;
+  }
+  void SetBoolValue(bool value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueRef::SetBoolValue");
+    *reinterpret_cast<bool*>(data_) = value;
+  }
+  // TODO(jieluo) - Checks that enum is member.
+  void SetEnumValue(int value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM, "MapValueRef::SetEnumValue");
+    *reinterpret_cast<int*>(data_) = value;
+  }
+  void SetStringValue(const std::string& value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapValueRef::SetStringValue");
+    *reinterpret_cast<std::string*>(data_) = value;
+  }
+  void SetFloatValue(float value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT, "MapValueRef::SetFloatValue");
+    *reinterpret_cast<float*>(data_) = value;
+  }
+  void SetDoubleValue(double value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE, "MapValueRef::SetDoubleValue");
+    *reinterpret_cast<double*>(data_) = value;
+  }
+
+  Message* MutableMessageValue() {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE,
+               "MapValueRef::MutableMessageValue");
+    return reinterpret_cast<Message*>(data_);
+  }
+
+ private:
+  friend class internal::DynamicMapField;
+
+  // Only used in DynamicMapField
+  void DeleteData() {
+    switch (type_) {
+#define HANDLE_TYPE(CPPTYPE, TYPE)           \
+  case FieldDescriptor::CPPTYPE_##CPPTYPE: { \
+    delete reinterpret_cast<TYPE*>(data_);   \
+    break;                                   \
+  }
+      HANDLE_TYPE(INT32, int32_t);
+      HANDLE_TYPE(INT64, int64_t);
+      HANDLE_TYPE(UINT32, uint32_t);
+      HANDLE_TYPE(UINT64, uint64_t);
+      HANDLE_TYPE(DOUBLE, double);
+      HANDLE_TYPE(FLOAT, float);
+      HANDLE_TYPE(BOOL, bool);
+      HANDLE_TYPE(STRING, std::string);
+      HANDLE_TYPE(ENUM, int32_t);
+      HANDLE_TYPE(MESSAGE, Message);
+#undef HANDLE_TYPE
+    }
+  }
+};
+
+#undef TYPE_CHECK
+
+class PROTOBUF_EXPORT MapIterator {
+ public:
+  MapIterator(Message* message, const FieldDescriptor* field) {
+    const Reflection* reflection = message->GetReflection();
+    map_ = reflection->MutableMapData(message, field);
+    key_.SetType(field->message_type()->map_key()->cpp_type());
+    value_.SetType(field->message_type()->map_value()->cpp_type());
+    map_->InitializeIterator(this);
+  }
+  MapIterator(const MapIterator& other) {
+    map_ = other.map_;
+    map_->InitializeIterator(this);
+    map_->CopyIterator(this, other);
+  }
+  ~MapIterator() { map_->DeleteIterator(this); }
+  MapIterator& operator=(const MapIterator& other) {
+    map_ = other.map_;
+    map_->CopyIterator(this, other);
+    return *this;
+  }
+  friend bool operator==(const MapIterator& a, const MapIterator& b) {
+    return a.map_->EqualIterator(a, b);
+  }
+  friend bool operator!=(const MapIterator& a, const MapIterator& b) {
+    return !a.map_->EqualIterator(a, b);
+  }
+  MapIterator& operator++() {
+    map_->IncreaseIterator(this);
+    return *this;
+  }
+  MapIterator operator++(int) {
+    // iter_ is copied from Map<...>::iterator, no need to
+    // copy from its self again. Use the same implementation
+    // with operator++()
+    map_->IncreaseIterator(this);
+    return *this;
+  }
+  const MapKey& GetKey() { return key_; }
+  const MapValueRef& GetValueRef() { return value_; }
+  MapValueRef* MutableValueRef() {
+    map_->SetMapDirty();
+    return &value_;
+  }
+
+ private:
+  template <typename Key, typename T>
+  friend class internal::TypeDefinedMapFieldBase;
+  friend class internal::DynamicMapField;
+  template <typename Derived, typename Key, typename T,
+            internal::WireFormatLite::FieldType kKeyFieldType,
+            internal::WireFormatLite::FieldType kValueFieldType>
+  friend class internal::MapField;
+
+  // reinterpret_cast from heap-allocated Map<...>::iterator*. MapIterator owns
+  // the iterator. It is allocated by MapField<...>::InitializeIterator() called
+  // in constructor and deleted by MapField<...>::DeleteIterator() called in
+  // destructor.
+  void* iter_;
+  // Point to a MapField to call helper methods implemented in MapField.
+  // MapIterator does not own this object.
+  internal::MapFieldBase* map_;
+  MapKey key_;
+  MapValueRef value_;
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#ifdef _MSC_VER
+#pragma warning(pop)  // restore warning C4265
+#endif                // _MSC_VER
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_MAP_FIELD_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_field_inl.h b/CAPI/cpp/grpc/include/google/protobuf/map_field_inl.h
new file mode 100644
index 0000000..7c4c232
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_field_inl.h
@@ -0,0 +1,375 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_FIELD_INL_H__
+#define GOOGLE_PROTOBUF_MAP_FIELD_INL_H__
+
+#include <memory>
+
+#include <google/protobuf/stubs/casts.h>
+#include <google/protobuf/map.h>
+#include <google/protobuf/map_field.h>
+#include <google/protobuf/map_type_handler.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+namespace internal {
+// UnwrapMapKey template
+template <typename T>
+T UnwrapMapKey(const MapKey& map_key);
+template <>
+inline int32_t UnwrapMapKey<int32_t>(const MapKey& map_key) {
+  return map_key.GetInt32Value();
+}
+template <>
+inline uint32_t UnwrapMapKey<uint32_t>(const MapKey& map_key) {
+  return map_key.GetUInt32Value();
+}
+template <>
+inline int64_t UnwrapMapKey<int64_t>(const MapKey& map_key) {
+  return map_key.GetInt64Value();
+}
+template <>
+inline uint64_t UnwrapMapKey<uint64_t>(const MapKey& map_key) {
+  return map_key.GetUInt64Value();
+}
+template <>
+inline bool UnwrapMapKey<bool>(const MapKey& map_key) {
+  return map_key.GetBoolValue();
+}
+template <>
+inline std::string UnwrapMapKey<std::string>(const MapKey& map_key) {
+  return map_key.GetStringValue();
+}
+
+// SetMapKey template
+template <typename T>
+inline void SetMapKey(MapKey* map_key, const T& value);
+template <>
+inline void SetMapKey<int32_t>(MapKey* map_key, const int32_t& value) {
+  map_key->SetInt32Value(value);
+}
+template <>
+inline void SetMapKey<uint32_t>(MapKey* map_key, const uint32_t& value) {
+  map_key->SetUInt32Value(value);
+}
+template <>
+inline void SetMapKey<int64_t>(MapKey* map_key, const int64_t& value) {
+  map_key->SetInt64Value(value);
+}
+template <>
+inline void SetMapKey<uint64_t>(MapKey* map_key, const uint64_t& value) {
+  map_key->SetUInt64Value(value);
+}
+template <>
+inline void SetMapKey<bool>(MapKey* map_key, const bool& value) {
+  map_key->SetBoolValue(value);
+}
+template <>
+inline void SetMapKey<std::string>(MapKey* map_key, const std::string& value) {
+  map_key->SetStringValue(value);
+}
+
+// ------------------------TypeDefinedMapFieldBase---------------
+template <typename Key, typename T>
+typename Map<Key, T>::const_iterator&
+TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(
+    const MapIterator* map_iter) const {
+  return *reinterpret_cast<typename Map<Key, T>::const_iterator*>(
+      map_iter->iter_);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::MapBegin(MapIterator* map_iter) const {
+  InternalGetIterator(map_iter) = GetMap().begin();
+  SetMapIteratorValue(map_iter);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::MapEnd(MapIterator* map_iter) const {
+  InternalGetIterator(map_iter) = GetMap().end();
+}
+
+template <typename Key, typename T>
+bool TypeDefinedMapFieldBase<Key, T>::EqualIterator(
+    const MapIterator& a, const MapIterator& b) const {
+  return InternalGetIterator(&a) == InternalGetIterator(&b);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::IncreaseIterator(
+    MapIterator* map_iter) const {
+  ++InternalGetIterator(map_iter);
+  SetMapIteratorValue(map_iter);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::InitializeIterator(
+    MapIterator* map_iter) const {
+  map_iter->iter_ = new typename Map<Key, T>::const_iterator;
+  GOOGLE_CHECK(map_iter->iter_ != nullptr);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::DeleteIterator(
+    MapIterator* map_iter) const {
+  delete reinterpret_cast<typename Map<Key, T>::const_iterator*>(
+      map_iter->iter_);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::CopyIterator(
+    MapIterator* this_iter, const MapIterator& that_iter) const {
+  InternalGetIterator(this_iter) = InternalGetIterator(&that_iter);
+  this_iter->key_.SetType(that_iter.key_.type());
+  // MapValueRef::type() fails when containing data is null. However, if
+  // this_iter points to MapEnd, data can be null.
+  this_iter->value_.SetType(
+      static_cast<FieldDescriptor::CppType>(that_iter.value_.type_));
+  SetMapIteratorValue(this_iter);
+}
+
+// ----------------------------------------------------------------------
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+int MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::size() const {
+  MapFieldBase::SyncMapWithRepeatedField();
+  return static_cast<int>(impl_.GetMap().size());
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::Clear() {
+  if (this->MapFieldBase::repeated_field_ != nullptr) {
+    RepeatedPtrField<EntryType>* repeated_field =
+        reinterpret_cast<RepeatedPtrField<EntryType>*>(
+            this->MapFieldBase::repeated_field_);
+    repeated_field->Clear();
+  }
+
+  impl_.MutableMap()->clear();
+  // Data in map and repeated field are both empty, but we can't set status
+  // CLEAN. Because clear is a generated API, we cannot invalidate previous
+  // reference to map.
+  MapFieldBase::SetMapDirty();
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+void MapField<Derived, Key, T, kKeyFieldType,
+              kValueFieldType>::SetMapIteratorValue(MapIterator* map_iter)
+    const {
+  const Map<Key, T>& map = impl_.GetMap();
+  typename Map<Key, T>::const_iterator iter =
+      TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(map_iter);
+  if (iter == map.end()) return;
+  SetMapKey(&map_iter->key_, iter->first);
+  map_iter->value_.SetValue(&iter->second);
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::ContainsMapKey(
+    const MapKey& map_key) const {
+  const Map<Key, T>& map = impl_.GetMap();
+  const Key& key = UnwrapMapKey<Key>(map_key);
+  typename Map<Key, T>::const_iterator iter = map.find(key);
+  return iter != map.end();
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+bool MapField<Derived, Key, T, kKeyFieldType,
+              kValueFieldType>::InsertOrLookupMapValue(const MapKey& map_key,
+                                                       MapValueRef* val) {
+  // Always use mutable map because users may change the map value by
+  // MapValueRef.
+  Map<Key, T>* map = MutableMap();
+  const Key& key = UnwrapMapKey<Key>(map_key);
+  typename Map<Key, T>::iterator iter = map->find(key);
+  if (map->end() == iter) {
+    val->SetValue(&((*map)[key]));
+    return true;
+  }
+  // Key is already in the map. Make sure (*map)[key] is not called.
+  // [] may reorder the map and iterators.
+  val->SetValue(&(iter->second));
+  return false;
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::LookupMapValue(
+    const MapKey& map_key, MapValueConstRef* val) const {
+  const Map<Key, T>& map = GetMap();
+  const Key& key = UnwrapMapKey<Key>(map_key);
+  typename Map<Key, T>::const_iterator iter = map.find(key);
+  if (map.end() == iter) {
+    return false;
+  }
+  // Key is already in the map. Make sure (*map)[key] is not called.
+  // [] may reorder the map and iterators.
+  val->SetValue(&(iter->second));
+  return true;
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::DeleteMapValue(
+    const MapKey& map_key) {
+  const Key& key = UnwrapMapKey<Key>(map_key);
+  return MutableMap()->erase(key);
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::MergeFrom(
+    const MapFieldBase& other) {
+  MapFieldBase::SyncMapWithRepeatedField();
+  const MapField& other_field = static_cast<const MapField&>(other);
+  other_field.SyncMapWithRepeatedField();
+  impl_.MergeFrom(other_field.impl_);
+  MapFieldBase::SetMapDirty();
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::Swap(
+    MapFieldBase* other) {
+  MapFieldBase::Swap(other);
+  MapField* other_field = down_cast<MapField*>(other);
+  impl_.Swap(&other_field->impl_);
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+void MapField<Derived, Key, T, kKeyFieldType,
+              kValueFieldType>::UnsafeShallowSwap(MapFieldBase* other) {
+  InternalSwap(down_cast<MapField*>(other));
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::InternalSwap(
+    MapField* other) {
+  MapFieldBase::InternalSwap(other);
+  impl_.InternalSwap(&other->impl_);
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+void MapField<Derived, Key, T, kKeyFieldType,
+              kValueFieldType>::SyncRepeatedFieldWithMapNoLock() const {
+  if (this->MapFieldBase::repeated_field_ == nullptr) {
+    this->MapFieldBase::repeated_field_ =
+        Arena::CreateMessage<RepeatedPtrField<Message> >(
+            this->MapFieldBase::arena_);
+  }
+  const Map<Key, T>& map = impl_.GetMap();
+  RepeatedPtrField<EntryType>* repeated_field =
+      reinterpret_cast<RepeatedPtrField<EntryType>*>(
+          this->MapFieldBase::repeated_field_);
+
+  repeated_field->Clear();
+
+  // The only way we can get at this point is through reflection and the
+  // only way we can get the reflection object is by having called GetReflection
+  // on the encompassing field. So that type must have existed and hence we
+  // know that this MapEntry default_type has also already been constructed.
+  // So it's safe to just call internal_default_instance().
+  const Message* default_entry = Derived::internal_default_instance();
+  for (typename Map<Key, T>::const_iterator it = map.begin(); it != map.end();
+       ++it) {
+    EntryType* new_entry =
+        down_cast<EntryType*>(default_entry->New(this->MapFieldBase::arena_));
+    repeated_field->AddAllocated(new_entry);
+    (*new_entry->mutable_key()) = it->first;
+    (*new_entry->mutable_value()) = it->second;
+  }
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+void MapField<Derived, Key, T, kKeyFieldType,
+              kValueFieldType>::SyncMapWithRepeatedFieldNoLock() const {
+  Map<Key, T>* map = const_cast<MapField*>(this)->impl_.MutableMap();
+  RepeatedPtrField<EntryType>* repeated_field =
+      reinterpret_cast<RepeatedPtrField<EntryType>*>(
+          this->MapFieldBase::repeated_field_);
+  GOOGLE_CHECK(this->MapFieldBase::repeated_field_ != nullptr);
+  map->clear();
+  for (typename RepeatedPtrField<EntryType>::iterator it =
+           repeated_field->begin();
+       it != repeated_field->end(); ++it) {
+    // Cast is needed because Map's api and internal storage is different when
+    // value is enum. For enum, we cannot cast an int to enum. Thus, we have to
+    // copy value. For other types, they have same exposed api type and internal
+    // stored type. We should not introduce value copy for them. We achieve this
+    // by casting to value for enum while casting to reference for other types.
+    (*map)[it->key()] = static_cast<CastValueType>(it->value());
+  }
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+size_t MapField<Derived, Key, T, kKeyFieldType,
+                kValueFieldType>::SpaceUsedExcludingSelfNoLock() const {
+  size_t size = 0;
+  if (this->MapFieldBase::repeated_field_ != nullptr) {
+    size += this->MapFieldBase::repeated_field_->SpaceUsedExcludingSelfLong();
+  }
+  size += impl_.GetMap().SpaceUsedExcludingSelfLong();
+
+  return size;
+}
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_MAP_FIELD_INL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_field_lite.h b/CAPI/cpp/grpc/include/google/protobuf/map_field_lite.h
new file mode 100644
index 0000000..53bf7a0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_field_lite.h
@@ -0,0 +1,209 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
+#define GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
+
+#include <type_traits>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/map.h>
+#include <google/protobuf/map_entry_lite.h>
+#include <google/protobuf/parse_context.h>
+#include <google/protobuf/wire_format_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+#ifndef NDEBUG
+void MapFieldLiteNotDestructed(void* map_field_lite);
+#endif
+
+// This class provides access to map field using generated api. It is used for
+// internal generated message implementation only. Users should never use this
+// directly.
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType key_wire_type,
+          WireFormatLite::FieldType value_wire_type>
+class MapFieldLite {
+  // Define message type for internal repeated field.
+  typedef Derived EntryType;
+
+ public:
+  typedef Map<Key, T> MapType;
+
+  constexpr MapFieldLite() : map_() {}
+  explicit MapFieldLite(Arena* arena) : map_(arena) {}
+  MapFieldLite(ArenaInitialized, Arena* arena) : MapFieldLite(arena) {}
+
+#ifdef NDEBUG
+  void Destruct() { map_.~Map(); }
+  ~MapFieldLite() {}
+#else
+  void Destruct() {
+    // We want to destruct the map in such a way that we can verify
+    // that we've done that, but also be sure that we've deallocated
+    // everything (as opposed to leaving an allocation behind with no
+    // data in it, as would happen if a vector was resize'd to zero.
+    // Map::Swap with an empty map accomplishes that.
+    decltype(map_) swapped_map(map_.arena());
+    map_.InternalSwap(swapped_map);
+  }
+  ~MapFieldLite() {
+    if (map_.arena() == nullptr && !map_.empty()) {
+      MapFieldLiteNotDestructed(this);
+    }
+  }
+#endif
+  // Accessors
+  const Map<Key, T>& GetMap() const { return map_; }
+  Map<Key, T>* MutableMap() { return &map_; }
+
+  // Convenient methods for generated message implementation.
+  int size() const { return static_cast<int>(map_.size()); }
+  void Clear() { return map_.clear(); }
+  void MergeFrom(const MapFieldLite& other) {
+    for (typename Map<Key, T>::const_iterator it = other.map_.begin();
+         it != other.map_.end(); ++it) {
+      map_[it->first] = it->second;
+    }
+  }
+  void Swap(MapFieldLite* other) { map_.swap(other->map_); }
+  void InternalSwap(MapFieldLite* other) { map_.InternalSwap(other->map_); }
+
+  // Used in the implementation of parsing. Caller should take the ownership iff
+  // arena_ is nullptr.
+  EntryType* NewEntry() const {
+    return Arena::CreateMessage<EntryType>(map_.arena());
+  }
+
+  const char* _InternalParse(const char* ptr, ParseContext* ctx) {
+    typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
+    return parser._InternalParse(ptr, ctx);
+  }
+
+  template <typename UnknownType>
+  const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
+                                      bool (*is_valid)(int), uint32_t field_num,
+                                      InternalMetadata* metadata) {
+    typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
+    return parser.template ParseWithEnumValidation<UnknownType>(
+        ptr, ctx, is_valid, field_num, metadata);
+  }
+
+ private:
+  typedef void DestructorSkippable_;
+
+  // map_ is inside an anonymous union so we can explicitly control its
+  // destruction
+  union {
+    Map<Key, T> map_;
+  };
+
+  friend class ::PROTOBUF_NAMESPACE_ID::Arena;
+};
+
+template <typename UnknownType, typename T>
+struct EnumParseWrapper {
+  const char* _InternalParse(const char* ptr, ParseContext* ctx) {
+    return map_field->template ParseWithEnumValidation<UnknownType>(
+        ptr, ctx, is_valid, field_num, metadata);
+  }
+  T* map_field;
+  bool (*is_valid)(int);
+  uint32_t field_num;
+  InternalMetadata* metadata;
+};
+
+// Helper function because the typenames of maps are horrendous to print. This
+// leverages compiler type deduction, to keep all type data out of the
+// generated code
+template <typename UnknownType, typename T>
+EnumParseWrapper<UnknownType, T> InitEnumParseWrapper(
+    T* map_field, bool (*is_valid)(int), uint32_t field_num,
+    InternalMetadata* metadata) {
+  return EnumParseWrapper<UnknownType, T>{map_field, is_valid, field_num,
+                                          metadata};
+}
+
+// True if IsInitialized() is true for value field in all elements of t. T is
+// expected to be message.  It's useful to have this helper here to keep the
+// protobuf compiler from ever having to emit loops in IsInitialized() methods.
+// We want the C++ compiler to inline this or not as it sees fit.
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType key_wire_type,
+          WireFormatLite::FieldType value_wire_type>
+bool AllAreInitialized(const MapFieldLite<Derived, Key, T, key_wire_type,
+                                          value_wire_type>& field) {
+  const auto& t = field.GetMap();
+  for (typename Map<Key, T>::const_iterator it = t.begin(); it != t.end();
+       ++it) {
+    if (!it->second.IsInitialized()) return false;
+  }
+  return true;
+}
+
+template <typename MEntry>
+struct MapEntryToMapField : MapEntryToMapField<typename MEntry::SuperType> {};
+
+template <typename T, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+struct MapEntryToMapField<
+    MapEntryLite<T, Key, Value, kKeyFieldType, kValueFieldType>> {
+  typedef MapFieldLite<
+      MapEntryLite<T, Key, Value, kKeyFieldType, kValueFieldType>, Key, Value,
+      kKeyFieldType, kValueFieldType>
+      MapFieldType;
+};
+
+#ifndef NDEBUG
+inline PROTOBUF_NOINLINE void MapFieldLiteNotDestructed(void* map_field_lite) {
+  bool proper_destruct = false;
+  GOOGLE_CHECK(proper_destruct) << map_field_lite;
+}
+#endif
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_type_handler.h b/CAPI/cpp/grpc/include/google/protobuf/map_type_handler.h
new file mode 100644
index 0000000..c210c63
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_type_handler.h
@@ -0,0 +1,736 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_TYPE_HANDLER_H__
+#define GOOGLE_PROTOBUF_MAP_TYPE_HANDLER_H__
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/parse_context.h>
+#include <google/protobuf/wire_format_lite.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Used for compile time type selection. MapIf::type will be TrueType if Flag is
+// true and FalseType otherwise.
+template <bool Flag, typename TrueType, typename FalseType>
+struct MapIf;
+
+template <typename TrueType, typename FalseType>
+struct MapIf<true, TrueType, FalseType> {
+  typedef TrueType type;
+};
+
+template <typename TrueType, typename FalseType>
+struct MapIf<false, TrueType, FalseType> {
+  typedef FalseType type;
+};
+
+template <typename Type, bool is_arena_constructable>
+class MapArenaMessageCreator {
+ public:
+  // Use arena to create message if Type is arena constructable. Otherwise,
+  // create the message on heap.
+  static inline Type* CreateMessage(Arena* arena);
+};
+template <typename Type>
+class MapArenaMessageCreator<Type, true> {
+ public:
+  static inline Type* CreateMessage(Arena* arena) {
+    return Arena::CreateMessage<Type>(arena);
+  }
+};
+template <typename Type>
+class MapArenaMessageCreator<Type, false> {
+ public:
+  static inline Type* CreateMessage(Arena* arena) {
+    return Arena::Create<Type>(arena);
+  }
+};
+
+// Define constants for given wire field type
+template <WireFormatLite::FieldType field_type, typename Type>
+class MapWireFieldTypeTraits {};
+
+#define TYPE_TRAITS(FieldType, CType, WireFormatType, IsMessage, IsEnum)   \
+  template <typename Type>                                                 \
+  class MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type> {   \
+   public:                                                                 \
+    static const bool kIsMessage = IsMessage;                              \
+    static const bool kIsEnum = IsEnum;                                    \
+    typedef typename MapIf<kIsMessage, Type*, CType>::type TypeOnMemory;   \
+    typedef typename MapIf<kIsEnum, int, Type>::type MapEntryAccessorType; \
+    static const WireFormatLite::WireType kWireType =                      \
+        WireFormatLite::WIRETYPE_##WireFormatType;                         \
+  };
+
+TYPE_TRAITS(MESSAGE, Type, LENGTH_DELIMITED, true, false)
+TYPE_TRAITS(STRING, ArenaStringPtr, LENGTH_DELIMITED, false, false)
+TYPE_TRAITS(BYTES, ArenaStringPtr, LENGTH_DELIMITED, false, false)
+TYPE_TRAITS(INT64, int64_t, VARINT, false, false)
+TYPE_TRAITS(UINT64, uint64_t, VARINT, false, false)
+TYPE_TRAITS(INT32, int32_t, VARINT, false, false)
+TYPE_TRAITS(UINT32, uint32_t, VARINT, false, false)
+TYPE_TRAITS(SINT64, int64_t, VARINT, false, false)
+TYPE_TRAITS(SINT32, int32_t, VARINT, false, false)
+TYPE_TRAITS(ENUM, int, VARINT, false, true)
+TYPE_TRAITS(DOUBLE, double, FIXED64, false, false)
+TYPE_TRAITS(FLOAT, float, FIXED32, false, false)
+TYPE_TRAITS(FIXED64, uint64_t, FIXED64, false, false)
+TYPE_TRAITS(FIXED32, uint32_t, FIXED32, false, false)
+TYPE_TRAITS(SFIXED64, int64_t, FIXED64, false, false)
+TYPE_TRAITS(SFIXED32, int32_t, FIXED32, false, false)
+TYPE_TRAITS(BOOL, bool, VARINT, false, false)
+
+#undef TYPE_TRAITS
+
+template <WireFormatLite::FieldType field_type, typename Type>
+class MapTypeHandler {};
+
+template <typename Type>
+class MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type> {
+ public:
+  // Enum type cannot be used for MapTypeHandler::Read. Define a type which will
+  // replace Enum with int.
+  typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
+                                          Type>::MapEntryAccessorType
+      MapEntryAccessorType;
+  // Internal stored type in MapEntryLite for given wire field type.
+  typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
+                                          Type>::TypeOnMemory TypeOnMemory;
+  // Corresponding wire type for field type.
+  static constexpr WireFormatLite::WireType kWireType =
+      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kWireType;
+  // Whether wire type is for message.
+  static constexpr bool kIsMessage =
+      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsMessage;
+  // Whether wire type is for enum.
+  static constexpr bool kIsEnum =
+      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsEnum;
+
+  // Functions used in parsing and serialization. ===================
+  static inline size_t ByteSize(const MapEntryAccessorType& value);
+  static inline int GetCachedSize(const MapEntryAccessorType& value);
+  static inline bool Read(io::CodedInputStream* input,
+                          MapEntryAccessorType* value);
+  static inline const char* Read(const char* ptr, ParseContext* ctx,
+                                 MapEntryAccessorType* value);
+
+  static inline uint8_t* Write(int field, const MapEntryAccessorType& value,
+                               uint8_t* ptr, io::EpsCopyOutputStream* stream);
+
+  // Functions to manipulate data on memory. ========================
+  static inline const Type& GetExternalReference(const Type* value);
+  static inline void DeleteNoArena(const Type* x);
+  static inline void Merge(const Type& from, Type** to, Arena* arena);
+  static inline void Clear(Type** value, Arena* arena);
+  static constexpr TypeOnMemory Constinit();
+
+  static inline Type* EnsureMutable(Type** value, Arena* arena);
+  // SpaceUsedInMapEntry: Return bytes used by value in MapEntry, excluding
+  // those already calculate in sizeof(MapField).
+  static inline size_t SpaceUsedInMapEntryLong(const Type* value);
+  // Return default instance if value is not initialized when calling const
+  // reference accessor.
+  static inline const Type& DefaultIfNotInitialized(const Type* value);
+  // Check if all required fields have values set.
+  static inline bool IsInitialized(Type* value);
+};
+
+#define MAP_HANDLER(FieldType)                                                 \
+  template <typename Type>                                                     \
+  class MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type> {               \
+   public:                                                                     \
+    typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,  \
+                                            Type>::MapEntryAccessorType        \
+        MapEntryAccessorType;                                                  \
+    typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,  \
+                                            Type>::TypeOnMemory TypeOnMemory;  \
+    static const WireFormatLite::WireType kWireType =                          \
+        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,               \
+                               Type>::kWireType;                               \
+    static const bool kIsMessage =                                             \
+        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,               \
+                               Type>::kIsMessage;                              \
+    static const bool kIsEnum =                                                \
+        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,               \
+                               Type>::kIsEnum;                                 \
+    static inline int ByteSize(const MapEntryAccessorType& value);             \
+    static inline int GetCachedSize(const MapEntryAccessorType& value);        \
+    static inline bool Read(io::CodedInputStream* input,                       \
+                            MapEntryAccessorType* value);                      \
+    static inline const char* Read(const char* begin, ParseContext* ctx,       \
+                                   MapEntryAccessorType* value);               \
+    static inline uint8_t* Write(int field, const MapEntryAccessorType& value, \
+                                 uint8_t* ptr,                                 \
+                                 io::EpsCopyOutputStream* stream);             \
+    static inline const MapEntryAccessorType& GetExternalReference(            \
+        const TypeOnMemory& value);                                            \
+    static inline void DeleteNoArena(const TypeOnMemory& x);                   \
+    static inline void Merge(const MapEntryAccessorType& from,                 \
+                             TypeOnMemory* to, Arena* arena);                  \
+    static inline void Clear(TypeOnMemory* value, Arena* arena);               \
+    static inline size_t SpaceUsedInMapEntryLong(const TypeOnMemory& value);   \
+    static inline const MapEntryAccessorType& DefaultIfNotInitialized(         \
+        const TypeOnMemory& value);                                            \
+    static inline bool IsInitialized(const TypeOnMemory& value);               \
+    static void DeleteNoArena(TypeOnMemory& value);                            \
+    static constexpr TypeOnMemory Constinit();                                 \
+    static inline MapEntryAccessorType* EnsureMutable(TypeOnMemory* value,     \
+                                                      Arena* arena);           \
+  };
+MAP_HANDLER(STRING)
+MAP_HANDLER(BYTES)
+MAP_HANDLER(INT64)
+MAP_HANDLER(UINT64)
+MAP_HANDLER(INT32)
+MAP_HANDLER(UINT32)
+MAP_HANDLER(SINT64)
+MAP_HANDLER(SINT32)
+MAP_HANDLER(ENUM)
+MAP_HANDLER(DOUBLE)
+MAP_HANDLER(FLOAT)
+MAP_HANDLER(FIXED64)
+MAP_HANDLER(FIXED32)
+MAP_HANDLER(SFIXED64)
+MAP_HANDLER(SFIXED32)
+MAP_HANDLER(BOOL)
+#undef MAP_HANDLER
+
+template <typename Type>
+inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ByteSize(
+    const MapEntryAccessorType& value) {
+  return WireFormatLite::MessageSizeNoVirtual(value);
+}
+
+#define GOOGLE_PROTOBUF_BYTE_SIZE(FieldType, DeclaredType)                     \
+  template <typename Type>                                                     \
+  inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
+      const MapEntryAccessorType& value) {                                     \
+    return static_cast<int>(WireFormatLite::DeclaredType##Size(value));        \
+  }
+
+GOOGLE_PROTOBUF_BYTE_SIZE(STRING, String)
+GOOGLE_PROTOBUF_BYTE_SIZE(BYTES, Bytes)
+GOOGLE_PROTOBUF_BYTE_SIZE(INT64, Int64)
+GOOGLE_PROTOBUF_BYTE_SIZE(UINT64, UInt64)
+GOOGLE_PROTOBUF_BYTE_SIZE(INT32, Int32)
+GOOGLE_PROTOBUF_BYTE_SIZE(UINT32, UInt32)
+GOOGLE_PROTOBUF_BYTE_SIZE(SINT64, SInt64)
+GOOGLE_PROTOBUF_BYTE_SIZE(SINT32, SInt32)
+GOOGLE_PROTOBUF_BYTE_SIZE(ENUM, Enum)
+
+#undef GOOGLE_PROTOBUF_BYTE_SIZE
+
+#define FIXED_BYTE_SIZE(FieldType, DeclaredType)                               \
+  template <typename Type>                                                     \
+  inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
+      const MapEntryAccessorType& /* value */) {                               \
+    return WireFormatLite::k##DeclaredType##Size;                              \
+  }
+
+FIXED_BYTE_SIZE(DOUBLE, Double)
+FIXED_BYTE_SIZE(FLOAT, Float)
+FIXED_BYTE_SIZE(FIXED64, Fixed64)
+FIXED_BYTE_SIZE(FIXED32, Fixed32)
+FIXED_BYTE_SIZE(SFIXED64, SFixed64)
+FIXED_BYTE_SIZE(SFIXED32, SFixed32)
+FIXED_BYTE_SIZE(BOOL, Bool)
+
+#undef FIXED_BYTE_SIZE
+
+template <typename Type>
+inline int MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetCachedSize(
+    const MapEntryAccessorType& value) {
+  return static_cast<int>(WireFormatLite::LengthDelimitedSize(
+      static_cast<size_t>(value.GetCachedSize())));
+}
+
+#define GET_CACHED_SIZE(FieldType, DeclaredType)                         \
+  template <typename Type>                                               \
+  inline int                                                             \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
+      const MapEntryAccessorType& value) {                               \
+    return static_cast<int>(WireFormatLite::DeclaredType##Size(value));  \
+  }
+
+GET_CACHED_SIZE(STRING, String)
+GET_CACHED_SIZE(BYTES, Bytes)
+GET_CACHED_SIZE(INT64, Int64)
+GET_CACHED_SIZE(UINT64, UInt64)
+GET_CACHED_SIZE(INT32, Int32)
+GET_CACHED_SIZE(UINT32, UInt32)
+GET_CACHED_SIZE(SINT64, SInt64)
+GET_CACHED_SIZE(SINT32, SInt32)
+GET_CACHED_SIZE(ENUM, Enum)
+
+#undef GET_CACHED_SIZE
+
+#define GET_FIXED_CACHED_SIZE(FieldType, DeclaredType)                   \
+  template <typename Type>                                               \
+  inline int                                                             \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
+      const MapEntryAccessorType& /* value */) {                         \
+    return WireFormatLite::k##DeclaredType##Size;                        \
+  }
+
+GET_FIXED_CACHED_SIZE(DOUBLE, Double)
+GET_FIXED_CACHED_SIZE(FLOAT, Float)
+GET_FIXED_CACHED_SIZE(FIXED64, Fixed64)
+GET_FIXED_CACHED_SIZE(FIXED32, Fixed32)
+GET_FIXED_CACHED_SIZE(SFIXED64, SFixed64)
+GET_FIXED_CACHED_SIZE(SFIXED32, SFixed32)
+GET_FIXED_CACHED_SIZE(BOOL, Bool)
+
+#undef GET_FIXED_CACHED_SIZE
+
+template <typename Type>
+inline uint8_t* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Write(
+    int field, const MapEntryAccessorType& value, uint8_t* ptr,
+    io::EpsCopyOutputStream* stream) {
+  ptr = stream->EnsureSpace(ptr);
+  return WireFormatLite::InternalWriteMessage(
+      field, value, value.GetCachedSize(), ptr, stream);
+}
+
+#define WRITE_METHOD(FieldType, DeclaredType)                     \
+  template <typename Type>                                        \
+  inline uint8_t*                                                 \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write(  \
+      int field, const MapEntryAccessorType& value, uint8_t* ptr, \
+      io::EpsCopyOutputStream* stream) {                          \
+    ptr = stream->EnsureSpace(ptr);                               \
+    return stream->Write##DeclaredType(field, value, ptr);        \
+  }
+
+WRITE_METHOD(STRING, String)
+WRITE_METHOD(BYTES, Bytes)
+
+#undef WRITE_METHOD
+#define WRITE_METHOD(FieldType, DeclaredType)                               \
+  template <typename Type>                                                  \
+  inline uint8_t*                                                           \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write(            \
+      int field, const MapEntryAccessorType& value, uint8_t* ptr,           \
+      io::EpsCopyOutputStream* stream) {                                    \
+    ptr = stream->EnsureSpace(ptr);                                         \
+    return WireFormatLite::Write##DeclaredType##ToArray(field, value, ptr); \
+  }
+
+WRITE_METHOD(INT64, Int64)
+WRITE_METHOD(UINT64, UInt64)
+WRITE_METHOD(INT32, Int32)
+WRITE_METHOD(UINT32, UInt32)
+WRITE_METHOD(SINT64, SInt64)
+WRITE_METHOD(SINT32, SInt32)
+WRITE_METHOD(ENUM, Enum)
+WRITE_METHOD(DOUBLE, Double)
+WRITE_METHOD(FLOAT, Float)
+WRITE_METHOD(FIXED64, Fixed64)
+WRITE_METHOD(FIXED32, Fixed32)
+WRITE_METHOD(SFIXED64, SFixed64)
+WRITE_METHOD(SFIXED32, SFixed32)
+WRITE_METHOD(BOOL, Bool)
+
+#undef WRITE_METHOD
+
+template <typename Type>
+inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
+    io::CodedInputStream* input, MapEntryAccessorType* value) {
+  return WireFormatLite::ReadMessageNoVirtual(input, value);
+}
+
+template <typename Type>
+inline bool MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
+    io::CodedInputStream* input, MapEntryAccessorType* value) {
+  return WireFormatLite::ReadString(input, value);
+}
+
+template <typename Type>
+inline bool MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
+    io::CodedInputStream* input, MapEntryAccessorType* value) {
+  return WireFormatLite::ReadBytes(input, value);
+}
+
+template <typename Type>
+const char* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
+    const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
+  return ctx->ParseMessage(value, ptr);
+}
+
+template <typename Type>
+const char* MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
+    const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
+  int size = ReadSize(&ptr);
+  GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+  return ctx->ReadString(ptr, size, value);
+}
+
+template <typename Type>
+const char* MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
+    const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
+  int size = ReadSize(&ptr);
+  GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+  return ctx->ReadString(ptr, size, value);
+}
+
+inline const char* ReadINT64(const char* ptr, int64_t* value) {
+  return VarintParse(ptr, reinterpret_cast<uint64_t*>(value));
+}
+inline const char* ReadUINT64(const char* ptr, uint64_t* value) {
+  return VarintParse(ptr, value);
+}
+inline const char* ReadINT32(const char* ptr, int32_t* value) {
+  return VarintParse(ptr, reinterpret_cast<uint32_t*>(value));
+}
+inline const char* ReadUINT32(const char* ptr, uint32_t* value) {
+  return VarintParse(ptr, value);
+}
+inline const char* ReadSINT64(const char* ptr, int64_t* value) {
+  *value = ReadVarintZigZag64(&ptr);
+  return ptr;
+}
+inline const char* ReadSINT32(const char* ptr, int32_t* value) {
+  *value = ReadVarintZigZag32(&ptr);
+  return ptr;
+}
+template <typename E>
+inline const char* ReadENUM(const char* ptr, E* value) {
+  *value = static_cast<E>(ReadVarint32(&ptr));
+  return ptr;
+}
+inline const char* ReadBOOL(const char* ptr, bool* value) {
+  *value = static_cast<bool>(ReadVarint32(&ptr));
+  return ptr;
+}
+
+template <typename F>
+inline const char* ReadUnaligned(const char* ptr, F* value) {
+  *value = UnalignedLoad<F>(ptr);
+  return ptr + sizeof(F);
+}
+inline const char* ReadFLOAT(const char* ptr, float* value) {
+  return ReadUnaligned(ptr, value);
+}
+inline const char* ReadDOUBLE(const char* ptr, double* value) {
+  return ReadUnaligned(ptr, value);
+}
+inline const char* ReadFIXED64(const char* ptr, uint64_t* value) {
+  return ReadUnaligned(ptr, value);
+}
+inline const char* ReadFIXED32(const char* ptr, uint32_t* value) {
+  return ReadUnaligned(ptr, value);
+}
+inline const char* ReadSFIXED64(const char* ptr, int64_t* value) {
+  return ReadUnaligned(ptr, value);
+}
+inline const char* ReadSFIXED32(const char* ptr, int32_t* value) {
+  return ReadUnaligned(ptr, value);
+}
+
+#define READ_METHOD(FieldType)                                              \
+  template <typename Type>                                                  \
+  inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read( \
+      io::CodedInputStream* input, MapEntryAccessorType* value) {           \
+    return WireFormatLite::ReadPrimitive<TypeOnMemory,                      \
+                                         WireFormatLite::TYPE_##FieldType>( \
+        input, value);                                                      \
+  }                                                                         \
+  template <typename Type>                                                  \
+  const char* MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read( \
+      const char* begin, ParseContext* ctx, MapEntryAccessorType* value) {  \
+    (void)ctx;                                                              \
+    return Read##FieldType(begin, value);                                   \
+  }
+
+READ_METHOD(INT64)
+READ_METHOD(UINT64)
+READ_METHOD(INT32)
+READ_METHOD(UINT32)
+READ_METHOD(SINT64)
+READ_METHOD(SINT32)
+READ_METHOD(ENUM)
+READ_METHOD(DOUBLE)
+READ_METHOD(FLOAT)
+READ_METHOD(FIXED64)
+READ_METHOD(FIXED32)
+READ_METHOD(SFIXED64)
+READ_METHOD(SFIXED32)
+READ_METHOD(BOOL)
+
+#undef READ_METHOD
+
+// Definition for message handler
+
+template <typename Type>
+inline const Type&
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetExternalReference(
+    const Type* value) {
+  return *value;
+}
+
+template <typename Type>
+inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
+                             Type>::SpaceUsedInMapEntryLong(const Type* value) {
+  return value->SpaceUsedLong();
+}
+
+template <typename Type>
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Clear(
+    Type** value, Arena* /* arena */) {
+  if (*value != nullptr) (*value)->Clear();
+}
+template <typename Type>
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Merge(
+    const Type& from, Type** to, Arena* /* arena */) {
+  (*to)->MergeFrom(from);
+}
+
+template <typename Type>
+void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DeleteNoArena(
+    const Type* ptr) {
+  delete ptr;
+}
+
+template <typename Type>
+constexpr auto MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Constinit()
+    -> TypeOnMemory {
+  return nullptr;
+}
+
+template <typename Type>
+inline Type* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::EnsureMutable(
+    Type** value, Arena* arena) {
+  if (*value == nullptr) {
+    *value = MapArenaMessageCreator<
+        Type,
+        Arena::is_arena_constructable<Type>::type::value>::CreateMessage(arena);
+  }
+  return *value;
+}
+
+template <typename Type>
+inline const Type&
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DefaultIfNotInitialized(
+    const Type* value) {
+  return value != nullptr ? *value : *Type::internal_default_instance();
+}
+
+template <typename Type>
+inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::IsInitialized(
+    Type* value) {
+  return value ? value->IsInitialized() : false;
+}
+
+// Definition for string/bytes handler
+
+#define STRING_OR_BYTES_HANDLER_FUNCTIONS(FieldType)                          \
+  template <typename Type>                                                    \
+  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,      \
+                                       Type>::MapEntryAccessorType&           \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                            \
+                 Type>::GetExternalReference(const TypeOnMemory& value) {     \
+    return value.Get();                                                       \
+  }                                                                           \
+  template <typename Type>                                                    \
+  inline size_t                                                               \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                            \
+                 Type>::SpaceUsedInMapEntryLong(const TypeOnMemory& value) {  \
+    return sizeof(value);                                                     \
+  }                                                                           \
+  template <typename Type>                                                    \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear(  \
+      TypeOnMemory* value, Arena* /* arena */) {                              \
+    value->ClearToEmpty();                                                    \
+  }                                                                           \
+  template <typename Type>                                                    \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge(  \
+      const MapEntryAccessorType& from, TypeOnMemory* to, Arena* arena) {     \
+    to->Set(from, arena);                                                     \
+  }                                                                           \
+  template <typename Type>                                                    \
+  void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DeleteNoArena( \
+      TypeOnMemory& value) {                                                  \
+    value.Destroy();                                                          \
+  }                                                                           \
+  template <typename Type>                                                    \
+  constexpr auto                                                              \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit()         \
+      ->TypeOnMemory {                                                        \
+    return TypeOnMemory(&internal::fixed_address_empty_string,                \
+                        ConstantInitialized{});                               \
+  }                                                                           \
+  template <typename Type>                                                    \
+  inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,            \
+                                 Type>::MapEntryAccessorType*                 \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(      \
+      TypeOnMemory* value, Arena* arena) {                                    \
+    return value->Mutable(arena);                                             \
+  }                                                                           \
+  template <typename Type>                                                    \
+  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,      \
+                                       Type>::MapEntryAccessorType&           \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                            \
+                 Type>::DefaultIfNotInitialized(const TypeOnMemory& value) {  \
+    return value.Get();                                                       \
+  }                                                                           \
+  template <typename Type>                                                    \
+  inline bool                                                                 \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized(      \
+      const TypeOnMemory& /* value */) {                                      \
+    return true;                                                              \
+  }
+STRING_OR_BYTES_HANDLER_FUNCTIONS(STRING)
+STRING_OR_BYTES_HANDLER_FUNCTIONS(BYTES)
+#undef STRING_OR_BYTES_HANDLER_FUNCTIONS
+
+#define PRIMITIVE_HANDLER_FUNCTIONS(FieldType)                               \
+  template <typename Type>                                                   \
+  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,     \
+                                       Type>::MapEntryAccessorType&          \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                           \
+                 Type>::GetExternalReference(const TypeOnMemory& value) {    \
+    return value;                                                            \
+  }                                                                          \
+  template <typename Type>                                                   \
+  inline size_t MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::     \
+      SpaceUsedInMapEntryLong(const TypeOnMemory& /* value */) {             \
+    return 0;                                                                \
+  }                                                                          \
+  template <typename Type>                                                   \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear( \
+      TypeOnMemory* value, Arena* /* arena */) {                             \
+    *value = 0;                                                              \
+  }                                                                          \
+  template <typename Type>                                                   \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge( \
+      const MapEntryAccessorType& from, TypeOnMemory* to,                    \
+      Arena* /* arena */) {                                                  \
+    *to = from;                                                              \
+  }                                                                          \
+  template <typename Type>                                                   \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType,               \
+                             Type>::DeleteNoArena(TypeOnMemory& /* x */) {}  \
+  template <typename Type>                                                   \
+  constexpr auto                                                             \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit()        \
+      ->TypeOnMemory {                                                       \
+    return 0;                                                                \
+  }                                                                          \
+  template <typename Type>                                                   \
+  inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,           \
+                                 Type>::MapEntryAccessorType*                \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(     \
+      TypeOnMemory* value, Arena* /* arena */) {                             \
+    return value;                                                            \
+  }                                                                          \
+  template <typename Type>                                                   \
+  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,     \
+                                       Type>::MapEntryAccessorType&          \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                           \
+                 Type>::DefaultIfNotInitialized(const TypeOnMemory& value) { \
+    return value;                                                            \
+  }                                                                          \
+  template <typename Type>                                                   \
+  inline bool                                                                \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized(     \
+      const TypeOnMemory& /* value */) {                                     \
+    return true;                                                             \
+  }
+PRIMITIVE_HANDLER_FUNCTIONS(INT64)
+PRIMITIVE_HANDLER_FUNCTIONS(UINT64)
+PRIMITIVE_HANDLER_FUNCTIONS(INT32)
+PRIMITIVE_HANDLER_FUNCTIONS(UINT32)
+PRIMITIVE_HANDLER_FUNCTIONS(SINT64)
+PRIMITIVE_HANDLER_FUNCTIONS(SINT32)
+PRIMITIVE_HANDLER_FUNCTIONS(ENUM)
+PRIMITIVE_HANDLER_FUNCTIONS(DOUBLE)
+PRIMITIVE_HANDLER_FUNCTIONS(FLOAT)
+PRIMITIVE_HANDLER_FUNCTIONS(FIXED64)
+PRIMITIVE_HANDLER_FUNCTIONS(FIXED32)
+PRIMITIVE_HANDLER_FUNCTIONS(SFIXED64)
+PRIMITIVE_HANDLER_FUNCTIONS(SFIXED32)
+PRIMITIVE_HANDLER_FUNCTIONS(BOOL)
+#undef PRIMITIVE_HANDLER_FUNCTIONS
+
+// Functions for operating on a map entry using type handlers.
+//
+// Does not contain any representation (this class is not intended to be
+// instantiated).
+template <typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType>
+struct MapEntryFuncs {
+  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+  typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
+  enum : int {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2
+  };
+
+  static uint8_t* InternalSerialize(int field_number, const Key& key,
+                                    const Value& value, uint8_t* ptr,
+                                    io::EpsCopyOutputStream* stream) {
+    ptr = stream->EnsureSpace(ptr);
+    ptr = WireFormatLite::WriteTagToArray(
+        field_number, WireFormatLite::WIRETYPE_LENGTH_DELIMITED, ptr);
+    ptr = io::CodedOutputStream::WriteVarint32ToArray(GetCachedSize(key, value),
+                                                      ptr);
+
+    ptr = KeyTypeHandler::Write(kKeyFieldNumber, key, ptr, stream);
+    return ValueTypeHandler::Write(kValueFieldNumber, value, ptr, stream);
+  }
+
+  static size_t ByteSizeLong(const Key& key, const Value& value) {
+    // Tags for key and value will both be one byte (field numbers 1 and 2).
+    size_t inner_length =
+        2 + KeyTypeHandler::ByteSize(key) + ValueTypeHandler::ByteSize(value);
+    return inner_length + io::CodedOutputStream::VarintSize32(
+                              static_cast<uint32_t>(inner_length));
+  }
+
+  static int GetCachedSize(const Key& key, const Value& value) {
+    // Tags for key and value will both be one byte (field numbers 1 and 2).
+    return 2 + KeyTypeHandler::GetCachedSize(key) +
+           ValueTypeHandler::GetCachedSize(value);
+  }
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_MAP_TYPE_HANDLER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/message.h b/CAPI/cpp/grpc/include/google/protobuf/message.h
new file mode 100644
index 0000000..39ec154
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/message.h
@@ -0,0 +1,1497 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines Message, the abstract interface implemented by non-lite
+// protocol message objects.  Although it's possible to implement this
+// interface manually, most users will use the protocol compiler to
+// generate implementations.
+//
+// Example usage:
+//
+// Say you have a message defined as:
+//
+//   message Foo {
+//     optional string text = 1;
+//     repeated int32 numbers = 2;
+//   }
+//
+// Then, if you used the protocol compiler to generate a class from the above
+// definition, you could use it like so:
+//
+//   std::string data;  // Will store a serialized version of the message.
+//
+//   {
+//     // Create a message and serialize it.
+//     Foo foo;
+//     foo.set_text("Hello World!");
+//     foo.add_numbers(1);
+//     foo.add_numbers(5);
+//     foo.add_numbers(42);
+//
+//     foo.SerializeToString(&data);
+//   }
+//
+//   {
+//     // Parse the serialized message and check that it contains the
+//     // correct data.
+//     Foo foo;
+//     foo.ParseFromString(data);
+//
+//     assert(foo.text() == "Hello World!");
+//     assert(foo.numbers_size() == 3);
+//     assert(foo.numbers(0) == 1);
+//     assert(foo.numbers(1) == 5);
+//     assert(foo.numbers(2) == 42);
+//   }
+//
+//   {
+//     // Same as the last block, but do it dynamically via the Message
+//     // reflection interface.
+//     Message* foo = new Foo;
+//     const Descriptor* descriptor = foo->GetDescriptor();
+//
+//     // Get the descriptors for the fields we're interested in and verify
+//     // their types.
+//     const FieldDescriptor* text_field = descriptor->FindFieldByName("text");
+//     assert(text_field != nullptr);
+//     assert(text_field->type() == FieldDescriptor::TYPE_STRING);
+//     assert(text_field->label() == FieldDescriptor::LABEL_OPTIONAL);
+//     const FieldDescriptor* numbers_field = descriptor->
+//                                            FindFieldByName("numbers");
+//     assert(numbers_field != nullptr);
+//     assert(numbers_field->type() == FieldDescriptor::TYPE_INT32);
+//     assert(numbers_field->label() == FieldDescriptor::LABEL_REPEATED);
+//
+//     // Parse the message.
+//     foo->ParseFromString(data);
+//
+//     // Use the reflection interface to examine the contents.
+//     const Reflection* reflection = foo->GetReflection();
+//     assert(reflection->GetString(*foo, text_field) == "Hello World!");
+//     assert(reflection->FieldSize(*foo, numbers_field) == 3);
+//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 0) == 1);
+//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 1) == 5);
+//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 2) == 42);
+//
+//     delete foo;
+//   }
+
+#ifndef GOOGLE_PROTOBUF_MESSAGE_H__
+#define GOOGLE_PROTOBUF_MESSAGE_H__
+
+
+#include <iosfwd>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include <google/protobuf/stubs/casts.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/map.h>  // TODO(b/211442718): cleanup
+#include <google/protobuf/message_lite.h>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+// Defined in this file.
+class Message;
+class Reflection;
+class MessageFactory;
+
+// Defined in other files.
+class AssignDescriptorsHelper;
+class DynamicMessageFactory;
+class GeneratedMessageReflectionTestHelper;
+class MapKey;
+class MapValueConstRef;
+class MapValueRef;
+class MapIterator;
+class MapReflectionTester;
+
+namespace internal {
+struct DescriptorTable;
+class MapFieldBase;
+class SwapFieldHelper;
+class CachedSize;
+}  // namespace internal
+class UnknownFieldSet;  // unknown_field_set.h
+namespace io {
+class ZeroCopyInputStream;   // zero_copy_stream.h
+class ZeroCopyOutputStream;  // zero_copy_stream.h
+class CodedInputStream;      // coded_stream.h
+class CodedOutputStream;     // coded_stream.h
+}  // namespace io
+namespace python {
+class MapReflectionFriend;  // scalar_map_container.h
+class MessageReflectionFriend;
+}  // namespace python
+namespace expr {
+class CelMapReflectionFriend;  // field_backed_map_impl.cc
+}
+
+namespace internal {
+class MapFieldPrinterHelper;  // text_format.cc
+}
+namespace util {
+class MessageDifferencer;
+}
+
+
+namespace internal {
+class ReflectionAccessor;      // message.cc
+class ReflectionOps;           // reflection_ops.h
+class MapKeySorter;            // wire_format.cc
+class WireFormat;              // wire_format.h
+class MapFieldReflectionTest;  // map_test.cc
+}  // namespace internal
+
+template <typename T>
+class RepeatedField;  // repeated_field.h
+
+template <typename T>
+class RepeatedPtrField;  // repeated_field.h
+
+// A container to hold message metadata.
+struct Metadata {
+  const Descriptor* descriptor;
+  const Reflection* reflection;
+};
+
+namespace internal {
+template <class To>
+inline To* GetPointerAtOffset(Message* message, uint32_t offset) {
+  return reinterpret_cast<To*>(reinterpret_cast<char*>(message) + offset);
+}
+
+template <class To>
+const To* GetConstPointerAtOffset(const Message* message, uint32_t offset) {
+  return reinterpret_cast<const To*>(reinterpret_cast<const char*>(message) +
+                                     offset);
+}
+
+template <class To>
+const To& GetConstRefAtOffset(const Message& message, uint32_t offset) {
+  return *GetConstPointerAtOffset<To>(&message, offset);
+}
+
+bool CreateUnknownEnumValues(const FieldDescriptor* field);
+
+// Returns true if "message" is a descendant of "root".
+PROTOBUF_EXPORT bool IsDescendant(Message& root, const Message& message);
+}  // namespace internal
+
+// Abstract interface for protocol messages.
+//
+// See also MessageLite, which contains most every-day operations.  Message
+// adds descriptors and reflection on top of that.
+//
+// The methods of this class that are virtual but not pure-virtual have
+// default implementations based on reflection.  Message classes which are
+// optimized for speed will want to override these with faster implementations,
+// but classes optimized for code size may be happy with keeping them.  See
+// the optimize_for option in descriptor.proto.
+//
+// Users must not derive from this class. Only the protocol compiler and
+// the internal library are allowed to create subclasses.
+class PROTOBUF_EXPORT Message : public MessageLite {
+ public:
+  constexpr Message() {}
+
+  // Basic Operations ------------------------------------------------
+
+  // Construct a new instance of the same type.  Ownership is passed to the
+  // caller.  (This is also defined in MessageLite, but is defined again here
+  // for return-type covariance.)
+  Message* New() const { return New(nullptr); }
+
+  // Construct a new instance on the arena. Ownership is passed to the caller
+  // if arena is a nullptr.
+  Message* New(Arena* arena) const override = 0;
+
+  // Make this message into a copy of the given message.  The given message
+  // must have the same descriptor, but need not necessarily be the same class.
+  // By default this is just implemented as "Clear(); MergeFrom(from);".
+  void CopyFrom(const Message& from);
+
+  // Merge the fields from the given message into this message.  Singular
+  // fields will be overwritten, if specified in from, except for embedded
+  // messages which will be merged.  Repeated fields will be concatenated.
+  // The given message must be of the same type as this message (i.e. the
+  // exact same class).
+  virtual void MergeFrom(const Message& from);
+
+  // Verifies that IsInitialized() returns true.  GOOGLE_CHECK-fails otherwise, with
+  // a nice error message.
+  void CheckInitialized() const;
+
+  // Slowly build a list of all required fields that are not set.
+  // This is much, much slower than IsInitialized() as it is implemented
+  // purely via reflection.  Generally, you should not call this unless you
+  // have already determined that an error exists by calling IsInitialized().
+  void FindInitializationErrors(std::vector<std::string>* errors) const;
+
+  // Like FindInitializationErrors, but joins all the strings, delimited by
+  // commas, and returns them.
+  std::string InitializationErrorString() const override;
+
+  // Clears all unknown fields from this message and all embedded messages.
+  // Normally, if unknown tag numbers are encountered when parsing a message,
+  // the tag and value are stored in the message's UnknownFieldSet and
+  // then written back out when the message is serialized.  This allows servers
+  // which simply route messages to other servers to pass through messages
+  // that have new field definitions which they don't yet know about.  However,
+  // this behavior can have security implications.  To avoid it, call this
+  // method after parsing.
+  //
+  // See Reflection::GetUnknownFields() for more on unknown fields.
+  void DiscardUnknownFields();
+
+  // Computes (an estimate of) the total number of bytes currently used for
+  // storing the message in memory.  The default implementation calls the
+  // Reflection object's SpaceUsed() method.
+  //
+  // SpaceUsed() is noticeably slower than ByteSize(), as it is implemented
+  // using reflection (rather than the generated code implementation for
+  // ByteSize()). Like ByteSize(), its CPU time is linear in the number of
+  // fields defined for the proto.
+  virtual size_t SpaceUsedLong() const;
+
+  PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
+  int SpaceUsed() const { return internal::ToIntSize(SpaceUsedLong()); }
+
+  // Debugging & Testing----------------------------------------------
+
+  // Generates a human-readable form of this message for debugging purposes.
+  // Note that the format and content of a debug string is not guaranteed, may
+  // change without notice, and should not be depended on. Code that does
+  // anything except display a string to assist in debugging should use
+  // TextFormat instead.
+  std::string DebugString() const;
+  // Like DebugString(), but with less whitespace.
+  std::string ShortDebugString() const;
+  // Like DebugString(), but do not escape UTF-8 byte sequences.
+  std::string Utf8DebugString() const;
+  // Convenience function useful in GDB.  Prints DebugString() to stdout.
+  void PrintDebugString() const;
+
+  // Reflection-based methods ----------------------------------------
+  // These methods are pure-virtual in MessageLite, but Message provides
+  // reflection-based default implementations.
+
+  std::string GetTypeName() const override;
+  void Clear() override;
+
+  // Returns whether all required fields have been set. Note that required
+  // fields no longer exist starting in proto3.
+  bool IsInitialized() const override;
+
+  void CheckTypeAndMergeFrom(const MessageLite& other) override;
+  // Reflective parser
+  const char* _InternalParse(const char* ptr,
+                             internal::ParseContext* ctx) override;
+  size_t ByteSizeLong() const override;
+  uint8_t* _InternalSerialize(uint8_t* target,
+                              io::EpsCopyOutputStream* stream) const override;
+
+ private:
+  // This is called only by the default implementation of ByteSize(), to
+  // update the cached size.  If you override ByteSize(), you do not need
+  // to override this.  If you do not override ByteSize(), you MUST override
+  // this; the default implementation will crash.
+  //
+  // The method is private because subclasses should never call it; only
+  // override it.  Yes, C++ lets you do that.  Crazy, huh?
+  virtual void SetCachedSize(int size) const;
+
+ public:
+  // Introspection ---------------------------------------------------
+
+
+  // Get a non-owning pointer to a Descriptor for this message's type.  This
+  // describes what fields the message contains, the types of those fields, etc.
+  // This object remains property of the Message.
+  const Descriptor* GetDescriptor() const { return GetMetadata().descriptor; }
+
+  // Get a non-owning pointer to the Reflection interface for this Message,
+  // which can be used to read and modify the fields of the Message dynamically
+  // (in other words, without knowing the message type at compile time).  This
+  // object remains property of the Message.
+  const Reflection* GetReflection() const { return GetMetadata().reflection; }
+
+ protected:
+  // Get a struct containing the metadata for the Message, which is used in turn
+  // to implement GetDescriptor() and GetReflection() above.
+  virtual Metadata GetMetadata() const = 0;
+
+  struct ClassData {
+    // Note: The order of arguments (to, then from) is chosen so that the ABI
+    // of this function is the same as the CopyFrom method.  That is, the
+    // hidden "this" parameter comes first.
+    void (*copy_to_from)(Message& to, const Message& from_msg);
+    void (*merge_to_from)(Message& to, const Message& from_msg);
+  };
+  // GetClassData() returns a pointer to a ClassData struct which
+  // exists in global memory and is unique to each subclass.  This uniqueness
+  // property is used in order to quickly determine whether two messages are
+  // of the same type.
+  // TODO(jorg): change to pure virtual
+  virtual const ClassData* GetClassData() const { return nullptr; }
+
+  // CopyWithSourceCheck calls Clear() and then MergeFrom(), and in debug
+  // builds, checks that calling Clear() on the destination message doesn't
+  // alter the source.  It assumes the messages are known to be of the same
+  // type, and thus uses GetClassData().
+  static void CopyWithSourceCheck(Message& to, const Message& from);
+
+  // Fail if "from" is a descendant of "to" as such copy is not allowed.
+  static void FailIfCopyFromDescendant(Message& to, const Message& from);
+
+  inline explicit Message(Arena* arena, bool is_message_owned = false)
+      : MessageLite(arena, is_message_owned) {}
+  size_t ComputeUnknownFieldsSize(size_t total_size,
+                                  internal::CachedSize* cached_size) const;
+  size_t MaybeComputeUnknownFieldsSize(size_t total_size,
+                                       internal::CachedSize* cached_size) const;
+
+
+ protected:
+  static uint64_t GetInvariantPerBuild(uint64_t salt);
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
+};
+
+namespace internal {
+// Forward-declare interfaces used to implement RepeatedFieldRef.
+// These are protobuf internals that users shouldn't care about.
+class RepeatedFieldAccessor;
+}  // namespace internal
+
+// Forward-declare RepeatedFieldRef templates. The second type parameter is
+// used for SFINAE tricks. Users should ignore it.
+template <typename T, typename Enable = void>
+class RepeatedFieldRef;
+
+template <typename T, typename Enable = void>
+class MutableRepeatedFieldRef;
+
+// This interface contains methods that can be used to dynamically access
+// and modify the fields of a protocol message.  Their semantics are
+// similar to the accessors the protocol compiler generates.
+//
+// To get the Reflection for a given Message, call Message::GetReflection().
+//
+// This interface is separate from Message only for efficiency reasons;
+// the vast majority of implementations of Message will share the same
+// implementation of Reflection (GeneratedMessageReflection,
+// defined in generated_message.h), and all Messages of a particular class
+// should share the same Reflection object (though you should not rely on
+// the latter fact).
+//
+// There are several ways that these methods can be used incorrectly.  For
+// example, any of the following conditions will lead to undefined
+// results (probably assertion failures):
+// - The FieldDescriptor is not a field of this message type.
+// - The method called is not appropriate for the field's type.  For
+//   each field type in FieldDescriptor::TYPE_*, there is only one
+//   Get*() method, one Set*() method, and one Add*() method that is
+//   valid for that type.  It should be obvious which (except maybe
+//   for TYPE_BYTES, which are represented using strings in C++).
+// - A Get*() or Set*() method for singular fields is called on a repeated
+//   field.
+// - GetRepeated*(), SetRepeated*(), or Add*() is called on a non-repeated
+//   field.
+// - The Message object passed to any method is not of the right type for
+//   this Reflection object (i.e. message.GetReflection() != reflection).
+//
+// You might wonder why there is not any abstract representation for a field
+// of arbitrary type.  E.g., why isn't there just a "GetField()" method that
+// returns "const Field&", where "Field" is some class with accessors like
+// "GetInt32Value()".  The problem is that someone would have to deal with
+// allocating these Field objects.  For generated message classes, having to
+// allocate space for an additional object to wrap every field would at least
+// double the message's memory footprint, probably worse.  Allocating the
+// objects on-demand, on the other hand, would be expensive and prone to
+// memory leaks.  So, instead we ended up with this flat interface.
+class PROTOBUF_EXPORT Reflection final {
+ public:
+  // Get the UnknownFieldSet for the message.  This contains fields which
+  // were seen when the Message was parsed but were not recognized according
+  // to the Message's definition.
+  const UnknownFieldSet& GetUnknownFields(const Message& message) const;
+  // Get a mutable pointer to the UnknownFieldSet for the message.  This
+  // contains fields which were seen when the Message was parsed but were not
+  // recognized according to the Message's definition.
+  UnknownFieldSet* MutableUnknownFields(Message* message) const;
+
+  // Estimate the amount of memory used by the message object.
+  size_t SpaceUsedLong(const Message& message) const;
+
+  PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
+  int SpaceUsed(const Message& message) const {
+    return internal::ToIntSize(SpaceUsedLong(message));
+  }
+
+  // Check if the given non-repeated field is set.
+  bool HasField(const Message& message, const FieldDescriptor* field) const;
+
+  // Get the number of elements of a repeated field.
+  int FieldSize(const Message& message, const FieldDescriptor* field) const;
+
+  // Clear the value of a field, so that HasField() returns false or
+  // FieldSize() returns zero.
+  void ClearField(Message* message, const FieldDescriptor* field) const;
+
+  // Check if the oneof is set. Returns true if any field in oneof
+  // is set, false otherwise.
+  bool HasOneof(const Message& message,
+                const OneofDescriptor* oneof_descriptor) const;
+
+  void ClearOneof(Message* message,
+                  const OneofDescriptor* oneof_descriptor) const;
+
+  // Returns the field descriptor if the oneof is set. nullptr otherwise.
+  const FieldDescriptor* GetOneofFieldDescriptor(
+      const Message& message, const OneofDescriptor* oneof_descriptor) const;
+
+  // Removes the last element of a repeated field.
+  // We don't provide a way to remove any element other than the last
+  // because it invites inefficient use, such as O(n^2) filtering loops
+  // that should have been O(n).  If you want to remove an element other
+  // than the last, the best way to do it is to re-arrange the elements
+  // (using Swap()) so that the one you want removed is at the end, then
+  // call RemoveLast().
+  void RemoveLast(Message* message, const FieldDescriptor* field) const;
+  // Removes the last element of a repeated message field, and returns the
+  // pointer to the caller.  Caller takes ownership of the returned pointer.
+  PROTOBUF_NODISCARD Message* ReleaseLast(Message* message,
+                                          const FieldDescriptor* field) const;
+
+  // Similar to ReleaseLast() without internal safety and ownershp checks. This
+  // method should only be used when the objects are on the same arena or paired
+  // with a call to `UnsafeArenaAddAllocatedMessage`.
+  Message* UnsafeArenaReleaseLast(Message* message,
+                                  const FieldDescriptor* field) const;
+
+  // Swap the complete contents of two messages.
+  void Swap(Message* message1, Message* message2) const;
+
+  // Swap fields listed in fields vector of two messages.
+  void SwapFields(Message* message1, Message* message2,
+                  const std::vector<const FieldDescriptor*>& fields) const;
+
+  // Swap two elements of a repeated field.
+  void SwapElements(Message* message, const FieldDescriptor* field, int index1,
+                    int index2) const;
+
+  // Swap without internal safety and ownership checks. This method should only
+  // be used when the objects are on the same arena.
+  void UnsafeArenaSwap(Message* lhs, Message* rhs) const;
+
+  // SwapFields without internal safety and ownership checks. This method should
+  // only be used when the objects are on the same arena.
+  void UnsafeArenaSwapFields(
+      Message* lhs, Message* rhs,
+      const std::vector<const FieldDescriptor*>& fields) const;
+
+  // List all fields of the message which are currently set, except for unknown
+  // fields, but including extension known to the parser (i.e. compiled in).
+  // Singular fields will only be listed if HasField(field) would return true
+  // and repeated fields will only be listed if FieldSize(field) would return
+  // non-zero.  Fields (both normal fields and extension fields) will be listed
+  // ordered by field number.
+  // Use Reflection::GetUnknownFields() or message.unknown_fields() to also get
+  // access to fields/extensions unknown to the parser.
+  void ListFields(const Message& message,
+                  std::vector<const FieldDescriptor*>* output) const;
+
+  // Singular field getters ------------------------------------------
+  // These get the value of a non-repeated field.  They return the default
+  // value for fields that aren't set.
+
+  int32_t GetInt32(const Message& message, const FieldDescriptor* field) const;
+  int64_t GetInt64(const Message& message, const FieldDescriptor* field) const;
+  uint32_t GetUInt32(const Message& message,
+                     const FieldDescriptor* field) const;
+  uint64_t GetUInt64(const Message& message,
+                     const FieldDescriptor* field) const;
+  float GetFloat(const Message& message, const FieldDescriptor* field) const;
+  double GetDouble(const Message& message, const FieldDescriptor* field) const;
+  bool GetBool(const Message& message, const FieldDescriptor* field) const;
+  std::string GetString(const Message& message,
+                        const FieldDescriptor* field) const;
+  const EnumValueDescriptor* GetEnum(const Message& message,
+                                     const FieldDescriptor* field) const;
+
+  // GetEnumValue() returns an enum field's value as an integer rather than
+  // an EnumValueDescriptor*. If the integer value does not correspond to a
+  // known value descriptor, a new value descriptor is created. (Such a value
+  // will only be present when the new unknown-enum-value semantics are enabled
+  // for a message.)
+  int GetEnumValue(const Message& message, const FieldDescriptor* field) const;
+
+  // See MutableMessage() for the meaning of the "factory" parameter.
+  const Message& GetMessage(const Message& message,
+                            const FieldDescriptor* field,
+                            MessageFactory* factory = nullptr) const;
+
+  // Get a string value without copying, if possible.
+  //
+  // GetString() necessarily returns a copy of the string.  This can be
+  // inefficient when the std::string is already stored in a std::string object
+  // in the underlying message.  GetStringReference() will return a reference to
+  // the underlying std::string in this case.  Otherwise, it will copy the
+  // string into *scratch and return that.
+  //
+  // Note:  It is perfectly reasonable and useful to write code like:
+  //     str = reflection->GetStringReference(message, field, &str);
+  //   This line would ensure that only one copy of the string is made
+  //   regardless of the field's underlying representation.  When initializing
+  //   a newly-constructed string, though, it's just as fast and more
+  //   readable to use code like:
+  //     std::string str = reflection->GetString(message, field);
+  const std::string& GetStringReference(const Message& message,
+                                        const FieldDescriptor* field,
+                                        std::string* scratch) const;
+
+
+  // Singular field mutators -----------------------------------------
+  // These mutate the value of a non-repeated field.
+
+  void SetInt32(Message* message, const FieldDescriptor* field,
+                int32_t value) const;
+  void SetInt64(Message* message, const FieldDescriptor* field,
+                int64_t value) const;
+  void SetUInt32(Message* message, const FieldDescriptor* field,
+                 uint32_t value) const;
+  void SetUInt64(Message* message, const FieldDescriptor* field,
+                 uint64_t value) const;
+  void SetFloat(Message* message, const FieldDescriptor* field,
+                float value) const;
+  void SetDouble(Message* message, const FieldDescriptor* field,
+                 double value) const;
+  void SetBool(Message* message, const FieldDescriptor* field,
+               bool value) const;
+  void SetString(Message* message, const FieldDescriptor* field,
+                 std::string value) const;
+  void SetEnum(Message* message, const FieldDescriptor* field,
+               const EnumValueDescriptor* value) const;
+  // Set an enum field's value with an integer rather than EnumValueDescriptor.
+  // For proto3 this is just setting the enum field to the value specified, for
+  // proto2 it's more complicated. If value is a known enum value the field is
+  // set as usual. If the value is unknown then it is added to the unknown field
+  // set. Note this matches the behavior of parsing unknown enum values.
+  // If multiple calls with unknown values happen than they are all added to the
+  // unknown field set in order of the calls.
+  void SetEnumValue(Message* message, const FieldDescriptor* field,
+                    int value) const;
+
+  // Get a mutable pointer to a field with a message type.  If a MessageFactory
+  // is provided, it will be used to construct instances of the sub-message;
+  // otherwise, the default factory is used.  If the field is an extension that
+  // does not live in the same pool as the containing message's descriptor (e.g.
+  // it lives in an overlay pool), then a MessageFactory must be provided.
+  // If you have no idea what that meant, then you probably don't need to worry
+  // about it (don't provide a MessageFactory).  WARNING:  If the
+  // FieldDescriptor is for a compiled-in extension, then
+  // factory->GetPrototype(field->message_type()) MUST return an instance of
+  // the compiled-in class for this type, NOT DynamicMessage.
+  Message* MutableMessage(Message* message, const FieldDescriptor* field,
+                          MessageFactory* factory = nullptr) const;
+
+  // Replaces the message specified by 'field' with the already-allocated object
+  // sub_message, passing ownership to the message.  If the field contained a
+  // message, that message is deleted.  If sub_message is nullptr, the field is
+  // cleared.
+  void SetAllocatedMessage(Message* message, Message* sub_message,
+                           const FieldDescriptor* field) const;
+
+  // Similar to `SetAllocatedMessage`, but omits all internal safety and
+  // ownership checks.  This method should only be used when the objects are on
+  // the same arena or paired with a call to `UnsafeArenaReleaseMessage`.
+  void UnsafeArenaSetAllocatedMessage(Message* message, Message* sub_message,
+                                      const FieldDescriptor* field) const;
+
+  // Releases the message specified by 'field' and returns the pointer,
+  // ReleaseMessage() will return the message the message object if it exists.
+  // Otherwise, it may or may not return nullptr.  In any case, if the return
+  // value is non-null, the caller takes ownership of the pointer.
+  // If the field existed (HasField() is true), then the returned pointer will
+  // be the same as the pointer returned by MutableMessage().
+  // This function has the same effect as ClearField().
+  PROTOBUF_NODISCARD Message* ReleaseMessage(
+      Message* message, const FieldDescriptor* field,
+      MessageFactory* factory = nullptr) const;
+
+  // Similar to `ReleaseMessage`, but omits all internal safety and ownership
+  // checks.  This method should only be used when the objects are on the same
+  // arena or paired with a call to `UnsafeArenaSetAllocatedMessage`.
+  Message* UnsafeArenaReleaseMessage(Message* message,
+                                     const FieldDescriptor* field,
+                                     MessageFactory* factory = nullptr) const;
+
+
+  // Repeated field getters ------------------------------------------
+  // These get the value of one element of a repeated field.
+
+  int32_t GetRepeatedInt32(const Message& message, const FieldDescriptor* field,
+                           int index) const;
+  int64_t GetRepeatedInt64(const Message& message, const FieldDescriptor* field,
+                           int index) const;
+  uint32_t GetRepeatedUInt32(const Message& message,
+                             const FieldDescriptor* field, int index) const;
+  uint64_t GetRepeatedUInt64(const Message& message,
+                             const FieldDescriptor* field, int index) const;
+  float GetRepeatedFloat(const Message& message, const FieldDescriptor* field,
+                         int index) const;
+  double GetRepeatedDouble(const Message& message, const FieldDescriptor* field,
+                           int index) const;
+  bool GetRepeatedBool(const Message& message, const FieldDescriptor* field,
+                       int index) const;
+  std::string GetRepeatedString(const Message& message,
+                                const FieldDescriptor* field, int index) const;
+  const EnumValueDescriptor* GetRepeatedEnum(const Message& message,
+                                             const FieldDescriptor* field,
+                                             int index) const;
+  // GetRepeatedEnumValue() returns an enum field's value as an integer rather
+  // than an EnumValueDescriptor*. If the integer value does not correspond to a
+  // known value descriptor, a new value descriptor is created. (Such a value
+  // will only be present when the new unknown-enum-value semantics are enabled
+  // for a message.)
+  int GetRepeatedEnumValue(const Message& message, const FieldDescriptor* field,
+                           int index) const;
+  const Message& GetRepeatedMessage(const Message& message,
+                                    const FieldDescriptor* field,
+                                    int index) const;
+
+  // See GetStringReference(), above.
+  const std::string& GetRepeatedStringReference(const Message& message,
+                                                const FieldDescriptor* field,
+                                                int index,
+                                                std::string* scratch) const;
+
+
+  // Repeated field mutators -----------------------------------------
+  // These mutate the value of one element of a repeated field.
+
+  void SetRepeatedInt32(Message* message, const FieldDescriptor* field,
+                        int index, int32_t value) const;
+  void SetRepeatedInt64(Message* message, const FieldDescriptor* field,
+                        int index, int64_t value) const;
+  void SetRepeatedUInt32(Message* message, const FieldDescriptor* field,
+                         int index, uint32_t value) const;
+  void SetRepeatedUInt64(Message* message, const FieldDescriptor* field,
+                         int index, uint64_t value) const;
+  void SetRepeatedFloat(Message* message, const FieldDescriptor* field,
+                        int index, float value) const;
+  void SetRepeatedDouble(Message* message, const FieldDescriptor* field,
+                         int index, double value) const;
+  void SetRepeatedBool(Message* message, const FieldDescriptor* field,
+                       int index, bool value) const;
+  void SetRepeatedString(Message* message, const FieldDescriptor* field,
+                         int index, std::string value) const;
+  void SetRepeatedEnum(Message* message, const FieldDescriptor* field,
+                       int index, const EnumValueDescriptor* value) const;
+  // Set an enum field's value with an integer rather than EnumValueDescriptor.
+  // For proto3 this is just setting the enum field to the value specified, for
+  // proto2 it's more complicated. If value is a known enum value the field is
+  // set as usual. If the value is unknown then it is added to the unknown field
+  // set. Note this matches the behavior of parsing unknown enum values.
+  // If multiple calls with unknown values happen than they are all added to the
+  // unknown field set in order of the calls.
+  void SetRepeatedEnumValue(Message* message, const FieldDescriptor* field,
+                            int index, int value) const;
+  // Get a mutable pointer to an element of a repeated field with a message
+  // type.
+  Message* MutableRepeatedMessage(Message* message,
+                                  const FieldDescriptor* field,
+                                  int index) const;
+
+
+  // Repeated field adders -------------------------------------------
+  // These add an element to a repeated field.
+
+  void AddInt32(Message* message, const FieldDescriptor* field,
+                int32_t value) const;
+  void AddInt64(Message* message, const FieldDescriptor* field,
+                int64_t value) const;
+  void AddUInt32(Message* message, const FieldDescriptor* field,
+                 uint32_t value) const;
+  void AddUInt64(Message* message, const FieldDescriptor* field,
+                 uint64_t value) const;
+  void AddFloat(Message* message, const FieldDescriptor* field,
+                float value) const;
+  void AddDouble(Message* message, const FieldDescriptor* field,
+                 double value) const;
+  void AddBool(Message* message, const FieldDescriptor* field,
+               bool value) const;
+  void AddString(Message* message, const FieldDescriptor* field,
+                 std::string value) const;
+  void AddEnum(Message* message, const FieldDescriptor* field,
+               const EnumValueDescriptor* value) const;
+  // Add an integer value to a repeated enum field rather than
+  // EnumValueDescriptor. For proto3 this is just setting the enum field to the
+  // value specified, for proto2 it's more complicated. If value is a known enum
+  // value the field is set as usual. If the value is unknown then it is added
+  // to the unknown field set. Note this matches the behavior of parsing unknown
+  // enum values. If multiple calls with unknown values happen than they are all
+  // added to the unknown field set in order of the calls.
+  void AddEnumValue(Message* message, const FieldDescriptor* field,
+                    int value) const;
+  // See MutableMessage() for comments on the "factory" parameter.
+  Message* AddMessage(Message* message, const FieldDescriptor* field,
+                      MessageFactory* factory = nullptr) const;
+
+  // Appends an already-allocated object 'new_entry' to the repeated field
+  // specified by 'field' passing ownership to the message.
+  void AddAllocatedMessage(Message* message, const FieldDescriptor* field,
+                           Message* new_entry) const;
+
+  // Similar to AddAllocatedMessage() without internal safety and ownership
+  // checks. This method should only be used when the objects are on the same
+  // arena or paired with a call to `UnsafeArenaReleaseLast`.
+  void UnsafeArenaAddAllocatedMessage(Message* message,
+                                      const FieldDescriptor* field,
+                                      Message* new_entry) const;
+
+
+  // Get a RepeatedFieldRef object that can be used to read the underlying
+  // repeated field. The type parameter T must be set according to the
+  // field's cpp type. The following table shows the mapping from cpp type
+  // to acceptable T.
+  //
+  //   field->cpp_type()      T
+  //   CPPTYPE_INT32        int32_t
+  //   CPPTYPE_UINT32       uint32_t
+  //   CPPTYPE_INT64        int64_t
+  //   CPPTYPE_UINT64       uint64_t
+  //   CPPTYPE_DOUBLE       double
+  //   CPPTYPE_FLOAT        float
+  //   CPPTYPE_BOOL         bool
+  //   CPPTYPE_ENUM         generated enum type or int32_t
+  //   CPPTYPE_STRING       std::string
+  //   CPPTYPE_MESSAGE      generated message type or google::protobuf::Message
+  //
+  // A RepeatedFieldRef object can be copied and the resulted object will point
+  // to the same repeated field in the same message. The object can be used as
+  // long as the message is not destroyed.
+  //
+  // Note that to use this method users need to include the header file
+  // "reflection.h" (which defines the RepeatedFieldRef class templates).
+  template <typename T>
+  RepeatedFieldRef<T> GetRepeatedFieldRef(const Message& message,
+                                          const FieldDescriptor* field) const;
+
+  // Like GetRepeatedFieldRef() but return an object that can also be used
+  // manipulate the underlying repeated field.
+  template <typename T>
+  MutableRepeatedFieldRef<T> GetMutableRepeatedFieldRef(
+      Message* message, const FieldDescriptor* field) const;
+
+  // DEPRECATED. Please use Get(Mutable)RepeatedFieldRef() for repeated field
+  // access. The following repeated field accessors will be removed in the
+  // future.
+  //
+  // Repeated field accessors  -------------------------------------------------
+  // The methods above, e.g. GetRepeatedInt32(msg, fd, index), provide singular
+  // access to the data in a RepeatedField.  The methods below provide aggregate
+  // access by exposing the RepeatedField object itself with the Message.
+  // Applying these templates to inappropriate types will lead to an undefined
+  // reference at link time (e.g. GetRepeatedField<***double>), or possibly a
+  // template matching error at compile time (e.g. GetRepeatedPtrField<File>).
+  //
+  // Usage example: my_doubs = refl->GetRepeatedField<double>(msg, fd);
+
+  // DEPRECATED. Please use GetRepeatedFieldRef().
+  //
+  // for T = Cord and all protobuf scalar types except enums.
+  template <typename T>
+  PROTOBUF_DEPRECATED_MSG("Please use GetRepeatedFieldRef() instead")
+  const RepeatedField<T>& GetRepeatedField(const Message& msg,
+                                           const FieldDescriptor* d) const {
+    return GetRepeatedFieldInternal<T>(msg, d);
+  }
+
+  // DEPRECATED. Please use GetMutableRepeatedFieldRef().
+  //
+  // for T = Cord and all protobuf scalar types except enums.
+  template <typename T>
+  PROTOBUF_DEPRECATED_MSG("Please use GetMutableRepeatedFieldRef() instead")
+  RepeatedField<T>* MutableRepeatedField(Message* msg,
+                                         const FieldDescriptor* d) const {
+    return MutableRepeatedFieldInternal<T>(msg, d);
+  }
+
+  // DEPRECATED. Please use GetRepeatedFieldRef().
+  //
+  // for T = std::string, google::protobuf::internal::StringPieceField
+  //         google::protobuf::Message & descendants.
+  template <typename T>
+  PROTOBUF_DEPRECATED_MSG("Please use GetRepeatedFieldRef() instead")
+  const RepeatedPtrField<T>& GetRepeatedPtrField(
+      const Message& msg, const FieldDescriptor* d) const {
+    return GetRepeatedPtrFieldInternal<T>(msg, d);
+  }
+
+  // DEPRECATED. Please use GetMutableRepeatedFieldRef().
+  //
+  // for T = std::string, google::protobuf::internal::StringPieceField
+  //         google::protobuf::Message & descendants.
+  template <typename T>
+  PROTOBUF_DEPRECATED_MSG("Please use GetMutableRepeatedFieldRef() instead")
+  RepeatedPtrField<T>* MutableRepeatedPtrField(Message* msg,
+                                               const FieldDescriptor* d) const {
+    return MutableRepeatedPtrFieldInternal<T>(msg, d);
+  }
+
+  // Extensions ----------------------------------------------------------------
+
+  // Try to find an extension of this message type by fully-qualified field
+  // name.  Returns nullptr if no extension is known for this name or number.
+  const FieldDescriptor* FindKnownExtensionByName(
+      const std::string& name) const;
+
+  // Try to find an extension of this message type by field number.
+  // Returns nullptr if no extension is known for this name or number.
+  const FieldDescriptor* FindKnownExtensionByNumber(int number) const;
+
+  // Feature Flags -------------------------------------------------------------
+
+  // Does this message support storing arbitrary integer values in enum fields?
+  // If |true|, GetEnumValue/SetEnumValue and associated repeated-field versions
+  // take arbitrary integer values, and the legacy GetEnum() getter will
+  // dynamically create an EnumValueDescriptor for any integer value without
+  // one. If |false|, setting an unknown enum value via the integer-based
+  // setters results in undefined behavior (in practice, GOOGLE_DCHECK-fails).
+  //
+  // Generic code that uses reflection to handle messages with enum fields
+  // should check this flag before using the integer-based setter, and either
+  // downgrade to a compatible value or use the UnknownFieldSet if not. For
+  // example:
+  //
+  //   int new_value = GetValueFromApplicationLogic();
+  //   if (reflection->SupportsUnknownEnumValues()) {
+  //     reflection->SetEnumValue(message, field, new_value);
+  //   } else {
+  //     if (field_descriptor->enum_type()->
+  //             FindValueByNumber(new_value) != nullptr) {
+  //       reflection->SetEnumValue(message, field, new_value);
+  //     } else if (emit_unknown_enum_values) {
+  //       reflection->MutableUnknownFields(message)->AddVarint(
+  //           field->number(), new_value);
+  //     } else {
+  //       // convert value to a compatible/default value.
+  //       new_value = CompatibleDowngrade(new_value);
+  //       reflection->SetEnumValue(message, field, new_value);
+  //     }
+  //   }
+  bool SupportsUnknownEnumValues() const;
+
+  // Returns the MessageFactory associated with this message.  This can be
+  // useful for determining if a message is a generated message or not, for
+  // example:
+  //   if (message->GetReflection()->GetMessageFactory() ==
+  //       google::protobuf::MessageFactory::generated_factory()) {
+  //     // This is a generated message.
+  //   }
+  // It can also be used to create more messages of this type, though
+  // Message::New() is an easier way to accomplish this.
+  MessageFactory* GetMessageFactory() const;
+
+ private:
+  template <typename T>
+  const RepeatedField<T>& GetRepeatedFieldInternal(
+      const Message& message, const FieldDescriptor* field) const;
+  template <typename T>
+  RepeatedField<T>* MutableRepeatedFieldInternal(
+      Message* message, const FieldDescriptor* field) const;
+  template <typename T>
+  const RepeatedPtrField<T>& GetRepeatedPtrFieldInternal(
+      const Message& message, const FieldDescriptor* field) const;
+  template <typename T>
+  RepeatedPtrField<T>* MutableRepeatedPtrFieldInternal(
+      Message* message, const FieldDescriptor* field) const;
+  // Obtain a pointer to a Repeated Field Structure and do some type checking:
+  //   on field->cpp_type(),
+  //   on field->field_option().ctype() (if ctype >= 0)
+  //   of field->message_type() (if message_type != nullptr).
+  // We use 2 routine rather than 4 (const vs mutable) x (scalar vs pointer).
+  void* MutableRawRepeatedField(Message* message, const FieldDescriptor* field,
+                                FieldDescriptor::CppType, int ctype,
+                                const Descriptor* message_type) const;
+
+  const void* GetRawRepeatedField(const Message& message,
+                                  const FieldDescriptor* field,
+                                  FieldDescriptor::CppType cpptype, int ctype,
+                                  const Descriptor* message_type) const;
+
+  // The following methods are used to implement (Mutable)RepeatedFieldRef.
+  // A Ref object will store a raw pointer to the repeated field data (obtained
+  // from RepeatedFieldData()) and a pointer to a Accessor (obtained from
+  // RepeatedFieldAccessor) which will be used to access the raw data.
+
+  // Returns a raw pointer to the repeated field
+  //
+  // "cpp_type" and "message_type" are deduced from the type parameter T passed
+  // to Get(Mutable)RepeatedFieldRef. If T is a generated message type,
+  // "message_type" should be set to its descriptor. Otherwise "message_type"
+  // should be set to nullptr. Implementations of this method should check
+  // whether "cpp_type"/"message_type" is consistent with the actual type of the
+  // field. We use 1 routine rather than 2 (const vs mutable) because it is
+  // protected and it doesn't change the message.
+  void* RepeatedFieldData(Message* message, const FieldDescriptor* field,
+                          FieldDescriptor::CppType cpp_type,
+                          const Descriptor* message_type) const;
+
+  // The returned pointer should point to a singleton instance which implements
+  // the RepeatedFieldAccessor interface.
+  const internal::RepeatedFieldAccessor* RepeatedFieldAccessor(
+      const FieldDescriptor* field) const;
+
+  // Lists all fields of the message which are currently set, except for unknown
+  // fields and stripped fields. See ListFields for details.
+  void ListFieldsOmitStripped(
+      const Message& message,
+      std::vector<const FieldDescriptor*>* output) const;
+
+  bool IsMessageStripped(const Descriptor* descriptor) const {
+    return schema_.IsMessageStripped(descriptor);
+  }
+
+  friend class TextFormat;
+
+  void ListFieldsMayFailOnStripped(
+      const Message& message, bool should_fail,
+      std::vector<const FieldDescriptor*>* output) const;
+
+  // Returns true if the message field is backed by a LazyField.
+  //
+  // A message field may be backed by a LazyField without the user annotation
+  // ([lazy = true]). While the user-annotated LazyField is lazily verified on
+  // first touch (i.e. failure on access rather than parsing if the LazyField is
+  // not initialized), the inferred LazyField is eagerly verified to avoid lazy
+  // parsing error at the cost of lower efficiency. When reflecting a message
+  // field, use this API instead of checking field->options().lazy().
+  bool IsLazyField(const FieldDescriptor* field) const {
+    return IsLazilyVerifiedLazyField(field) ||
+           IsEagerlyVerifiedLazyField(field);
+  }
+
+  // Returns true if the field is lazy extension. It is meant to allow python
+  // reparse lazy field until b/157559327 is fixed.
+  bool IsLazyExtension(const Message& message,
+                       const FieldDescriptor* field) const;
+
+  bool IsLazilyVerifiedLazyField(const FieldDescriptor* field) const;
+  bool IsEagerlyVerifiedLazyField(const FieldDescriptor* field) const;
+
+  friend class FastReflectionMessageMutator;
+  friend bool internal::IsDescendant(Message& root, const Message& message);
+
+  const Descriptor* const descriptor_;
+  const internal::ReflectionSchema schema_;
+  const DescriptorPool* const descriptor_pool_;
+  MessageFactory* const message_factory_;
+
+  // Last non weak field index. This is an optimization when most weak fields
+  // are at the end of the containing message. If a message proto doesn't
+  // contain weak fields, then this field equals descriptor_->field_count().
+  int last_non_weak_field_index_;
+
+  template <typename T, typename Enable>
+  friend class RepeatedFieldRef;
+  template <typename T, typename Enable>
+  friend class MutableRepeatedFieldRef;
+  friend class ::PROTOBUF_NAMESPACE_ID::MessageLayoutInspector;
+  friend class ::PROTOBUF_NAMESPACE_ID::AssignDescriptorsHelper;
+  friend class DynamicMessageFactory;
+  friend class GeneratedMessageReflectionTestHelper;
+  friend class python::MapReflectionFriend;
+  friend class python::MessageReflectionFriend;
+  friend class util::MessageDifferencer;
+#define GOOGLE_PROTOBUF_HAS_CEL_MAP_REFLECTION_FRIEND
+  friend class expr::CelMapReflectionFriend;
+  friend class internal::MapFieldReflectionTest;
+  friend class internal::MapKeySorter;
+  friend class internal::WireFormat;
+  friend class internal::ReflectionOps;
+  friend class internal::SwapFieldHelper;
+  // Needed for implementing text format for map.
+  friend class internal::MapFieldPrinterHelper;
+
+  Reflection(const Descriptor* descriptor,
+             const internal::ReflectionSchema& schema,
+             const DescriptorPool* pool, MessageFactory* factory);
+
+  // Special version for specialized implementations of string.  We can't
+  // call MutableRawRepeatedField directly here because we don't have access to
+  // FieldOptions::* which are defined in descriptor.pb.h.  Including that
+  // file here is not possible because it would cause a circular include cycle.
+  // We use 1 routine rather than 2 (const vs mutable) because it is private
+  // and mutable a repeated string field doesn't change the message.
+  void* MutableRawRepeatedString(Message* message, const FieldDescriptor* field,
+                                 bool is_string) const;
+
+  friend class MapReflectionTester;
+  // Returns true if key is in map. Returns false if key is not in map field.
+  bool ContainsMapKey(const Message& message, const FieldDescriptor* field,
+                      const MapKey& key) const;
+
+  // If key is in map field: Saves the value pointer to val and returns
+  // false. If key in not in map field: Insert the key into map, saves
+  // value pointer to val and returns true. Users are able to modify the
+  // map value by MapValueRef.
+  bool InsertOrLookupMapValue(Message* message, const FieldDescriptor* field,
+                              const MapKey& key, MapValueRef* val) const;
+
+  // If key is in map field: Saves the value pointer to val and returns true.
+  // Returns false if key is not in map field. Users are NOT able to modify
+  // the value by MapValueConstRef.
+  bool LookupMapValue(const Message& message, const FieldDescriptor* field,
+                      const MapKey& key, MapValueConstRef* val) const;
+  bool LookupMapValue(const Message&, const FieldDescriptor*, const MapKey&,
+                      MapValueRef*) const = delete;
+
+  // Delete and returns true if key is in the map field. Returns false
+  // otherwise.
+  bool DeleteMapValue(Message* message, const FieldDescriptor* field,
+                      const MapKey& key) const;
+
+  // Returns a MapIterator referring to the first element in the map field.
+  // If the map field is empty, this function returns the same as
+  // reflection::MapEnd. Mutation to the field may invalidate the iterator.
+  MapIterator MapBegin(Message* message, const FieldDescriptor* field) const;
+
+  // Returns a MapIterator referring to the theoretical element that would
+  // follow the last element in the map field. It does not point to any
+  // real element. Mutation to the field may invalidate the iterator.
+  MapIterator MapEnd(Message* message, const FieldDescriptor* field) const;
+
+  // Get the number of <key, value> pair of a map field. The result may be
+  // different from FieldSize which can have duplicate keys.
+  int MapSize(const Message& message, const FieldDescriptor* field) const;
+
+  // Help method for MapIterator.
+  friend class MapIterator;
+  friend class WireFormatForMapFieldTest;
+  internal::MapFieldBase* MutableMapData(Message* message,
+                                         const FieldDescriptor* field) const;
+
+  const internal::MapFieldBase* GetMapData(const Message& message,
+                                           const FieldDescriptor* field) const;
+
+  template <class T>
+  const T& GetRawNonOneof(const Message& message,
+                          const FieldDescriptor* field) const;
+  template <class T>
+  T* MutableRawNonOneof(Message* message, const FieldDescriptor* field) const;
+
+  template <typename Type>
+  const Type& GetRaw(const Message& message,
+                     const FieldDescriptor* field) const;
+  template <typename Type>
+  inline Type* MutableRaw(Message* message, const FieldDescriptor* field) const;
+  template <typename Type>
+  const Type& DefaultRaw(const FieldDescriptor* field) const;
+
+  const Message* GetDefaultMessageInstance(const FieldDescriptor* field) const;
+
+  inline const uint32_t* GetHasBits(const Message& message) const;
+  inline uint32_t* MutableHasBits(Message* message) const;
+  inline uint32_t GetOneofCase(const Message& message,
+                               const OneofDescriptor* oneof_descriptor) const;
+  inline uint32_t* MutableOneofCase(
+      Message* message, const OneofDescriptor* oneof_descriptor) const;
+  inline bool HasExtensionSet(const Message& /* message */) const {
+    return schema_.HasExtensionSet();
+  }
+  const internal::ExtensionSet& GetExtensionSet(const Message& message) const;
+  internal::ExtensionSet* MutableExtensionSet(Message* message) const;
+
+  const internal::InternalMetadata& GetInternalMetadata(
+      const Message& message) const;
+
+  internal::InternalMetadata* MutableInternalMetadata(Message* message) const;
+
+  inline bool IsInlined(const FieldDescriptor* field) const;
+
+  inline bool HasBit(const Message& message,
+                     const FieldDescriptor* field) const;
+  inline void SetBit(Message* message, const FieldDescriptor* field) const;
+  inline void ClearBit(Message* message, const FieldDescriptor* field) const;
+  inline void SwapBit(Message* message1, Message* message2,
+                      const FieldDescriptor* field) const;
+
+  inline const uint32_t* GetInlinedStringDonatedArray(
+      const Message& message) const;
+  inline uint32_t* MutableInlinedStringDonatedArray(Message* message) const;
+  inline bool IsInlinedStringDonated(const Message& message,
+                                     const FieldDescriptor* field) const;
+  inline void SwapInlinedStringDonated(Message* lhs, Message* rhs,
+                                       const FieldDescriptor* field) const;
+
+  // Shallow-swap fields listed in fields vector of two messages. It is the
+  // caller's responsibility to make sure shallow swap is safe.
+  void UnsafeShallowSwapFields(
+      Message* message1, Message* message2,
+      const std::vector<const FieldDescriptor*>& fields) const;
+
+  // This function only swaps the field. Should swap corresponding has_bit
+  // before or after using this function.
+  void SwapField(Message* message1, Message* message2,
+                 const FieldDescriptor* field) const;
+
+  // Unsafe but shallow version of SwapField.
+  void UnsafeShallowSwapField(Message* message1, Message* message2,
+                              const FieldDescriptor* field) const;
+
+  template <bool unsafe_shallow_swap>
+  void SwapFieldsImpl(Message* message1, Message* message2,
+                      const std::vector<const FieldDescriptor*>& fields) const;
+
+  template <bool unsafe_shallow_swap>
+  void SwapOneofField(Message* lhs, Message* rhs,
+                      const OneofDescriptor* oneof_descriptor) const;
+
+  inline bool HasOneofField(const Message& message,
+                            const FieldDescriptor* field) const;
+  inline void SetOneofCase(Message* message,
+                           const FieldDescriptor* field) const;
+  inline void ClearOneofField(Message* message,
+                              const FieldDescriptor* field) const;
+
+  template <typename Type>
+  inline const Type& GetField(const Message& message,
+                              const FieldDescriptor* field) const;
+  template <typename Type>
+  inline void SetField(Message* message, const FieldDescriptor* field,
+                       const Type& value) const;
+  template <typename Type>
+  inline Type* MutableField(Message* message,
+                            const FieldDescriptor* field) const;
+  template <typename Type>
+  inline const Type& GetRepeatedField(const Message& message,
+                                      const FieldDescriptor* field,
+                                      int index) const;
+  template <typename Type>
+  inline const Type& GetRepeatedPtrField(const Message& message,
+                                         const FieldDescriptor* field,
+                                         int index) const;
+  template <typename Type>
+  inline void SetRepeatedField(Message* message, const FieldDescriptor* field,
+                               int index, Type value) const;
+  template <typename Type>
+  inline Type* MutableRepeatedField(Message* message,
+                                    const FieldDescriptor* field,
+                                    int index) const;
+  template <typename Type>
+  inline void AddField(Message* message, const FieldDescriptor* field,
+                       const Type& value) const;
+  template <typename Type>
+  inline Type* AddField(Message* message, const FieldDescriptor* field) const;
+
+  int GetExtensionNumberOrDie(const Descriptor* type) const;
+
+  // Internal versions of EnumValue API perform no checking. Called after checks
+  // by public methods.
+  void SetEnumValueInternal(Message* message, const FieldDescriptor* field,
+                            int value) const;
+  void SetRepeatedEnumValueInternal(Message* message,
+                                    const FieldDescriptor* field, int index,
+                                    int value) const;
+  void AddEnumValueInternal(Message* message, const FieldDescriptor* field,
+                            int value) const;
+
+  friend inline  // inline so nobody can call this function.
+      void
+      RegisterAllTypesInternal(const Metadata* file_level_metadata, int size);
+  friend inline const char* ParseLenDelim(int field_number,
+                                          const FieldDescriptor* field,
+                                          Message* msg,
+                                          const Reflection* reflection,
+                                          const char* ptr,
+                                          internal::ParseContext* ctx);
+  friend inline const char* ParsePackedField(const FieldDescriptor* field,
+                                             Message* msg,
+                                             const Reflection* reflection,
+                                             const char* ptr,
+                                             internal::ParseContext* ctx);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reflection);
+};
+
+// Abstract interface for a factory for message objects.
+class PROTOBUF_EXPORT MessageFactory {
+ public:
+  inline MessageFactory() {}
+  virtual ~MessageFactory();
+
+  // Given a Descriptor, gets or constructs the default (prototype) Message
+  // of that type.  You can then call that message's New() method to construct
+  // a mutable message of that type.
+  //
+  // Calling this method twice with the same Descriptor returns the same
+  // object.  The returned object remains property of the factory.  Also, any
+  // objects created by calling the prototype's New() method share some data
+  // with the prototype, so these must be destroyed before the MessageFactory
+  // is destroyed.
+  //
+  // The given descriptor must outlive the returned message, and hence must
+  // outlive the MessageFactory.
+  //
+  // Some implementations do not support all types.  GetPrototype() will
+  // return nullptr if the descriptor passed in is not supported.
+  //
+  // This method may or may not be thread-safe depending on the implementation.
+  // Each implementation should document its own degree thread-safety.
+  virtual const Message* GetPrototype(const Descriptor* type) = 0;
+
+  // Gets a MessageFactory which supports all generated, compiled-in messages.
+  // In other words, for any compiled-in type FooMessage, the following is true:
+  //   MessageFactory::generated_factory()->GetPrototype(
+  //     FooMessage::descriptor()) == FooMessage::default_instance()
+  // This factory supports all types which are found in
+  // DescriptorPool::generated_pool().  If given a descriptor from any other
+  // pool, GetPrototype() will return nullptr.  (You can also check if a
+  // descriptor is for a generated message by checking if
+  // descriptor->file()->pool() == DescriptorPool::generated_pool().)
+  //
+  // This factory is 100% thread-safe; calling GetPrototype() does not modify
+  // any shared data.
+  //
+  // This factory is a singleton.  The caller must not delete the object.
+  static MessageFactory* generated_factory();
+
+  // For internal use only:  Registers a .proto file at static initialization
+  // time, to be placed in generated_factory.  The first time GetPrototype()
+  // is called with a descriptor from this file, |register_messages| will be
+  // called, with the file name as the parameter.  It must call
+  // InternalRegisterGeneratedMessage() (below) to register each message type
+  // in the file.  This strange mechanism is necessary because descriptors are
+  // built lazily, so we can't register types by their descriptor until we
+  // know that the descriptor exists.  |filename| must be a permanent string.
+  static void InternalRegisterGeneratedFile(
+      const google::protobuf::internal::DescriptorTable* table);
+
+  // For internal use only:  Registers a message type.  Called only by the
+  // functions which are registered with InternalRegisterGeneratedFile(),
+  // above.
+  static void InternalRegisterGeneratedMessage(const Descriptor* descriptor,
+                                               const Message* prototype);
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFactory);
+};
+
+#define DECLARE_GET_REPEATED_FIELD(TYPE)                           \
+  template <>                                                      \
+  PROTOBUF_EXPORT const RepeatedField<TYPE>&                       \
+  Reflection::GetRepeatedFieldInternal<TYPE>(                      \
+      const Message& message, const FieldDescriptor* field) const; \
+                                                                   \
+  template <>                                                      \
+  PROTOBUF_EXPORT RepeatedField<TYPE>*                             \
+  Reflection::MutableRepeatedFieldInternal<TYPE>(                  \
+      Message * message, const FieldDescriptor* field) const;
+
+DECLARE_GET_REPEATED_FIELD(int32_t)
+DECLARE_GET_REPEATED_FIELD(int64_t)
+DECLARE_GET_REPEATED_FIELD(uint32_t)
+DECLARE_GET_REPEATED_FIELD(uint64_t)
+DECLARE_GET_REPEATED_FIELD(float)
+DECLARE_GET_REPEATED_FIELD(double)
+DECLARE_GET_REPEATED_FIELD(bool)
+
+#undef DECLARE_GET_REPEATED_FIELD
+
+// Tries to downcast this message to a generated message type.  Returns nullptr
+// if this class is not an instance of T.  This works even if RTTI is disabled.
+//
+// This also has the effect of creating a strong reference to T that will
+// prevent the linker from stripping it out at link time.  This can be important
+// if you are using a DynamicMessageFactory that delegates to the generated
+// factory.
+template <typename T>
+const T* DynamicCastToGenerated(const Message* from) {
+  // Compile-time assert that T is a generated type that has a
+  // default_instance() accessor, but avoid actually calling it.
+  const T& (*get_default_instance)() = &T::default_instance;
+  (void)get_default_instance;
+
+  // Compile-time assert that T is a subclass of google::protobuf::Message.
+  const Message* unused = static_cast<T*>(nullptr);
+  (void)unused;
+
+#if PROTOBUF_RTTI
+  return dynamic_cast<const T*>(from);
+#else
+  bool ok = from != nullptr &&
+            T::default_instance().GetReflection() == from->GetReflection();
+  return ok ? down_cast<const T*>(from) : nullptr;
+#endif
+}
+
+template <typename T>
+T* DynamicCastToGenerated(Message* from) {
+  const Message* message_const = from;
+  return const_cast<T*>(DynamicCastToGenerated<T>(message_const));
+}
+
+// Call this function to ensure that this message's reflection is linked into
+// the binary:
+//
+//   google::protobuf::LinkMessageReflection<pkg::FooMessage>();
+//
+// This will ensure that the following lookup will succeed:
+//
+//   DescriptorPool::generated_pool()->FindMessageTypeByName("pkg.FooMessage");
+//
+// As a side-effect, it will also guarantee that anything else from the same
+// .proto file will also be available for lookup in the generated pool.
+//
+// This function does not actually register the message, so it does not need
+// to be called before the lookup.  However it does need to occur in a function
+// that cannot be stripped from the binary (ie. it must be reachable from main).
+//
+// Best practice is to call this function as close as possible to where the
+// reflection is actually needed.  This function is very cheap to call, so you
+// should not need to worry about its runtime overhead except in the tightest
+// of loops (on x86-64 it compiles into two "mov" instructions).
+template <typename T>
+void LinkMessageReflection() {
+  internal::StrongReference(T::default_instance);
+}
+
+// =============================================================================
+// Implementation details for {Get,Mutable}RawRepeatedPtrField.  We provide
+// specializations for <std::string>, <StringPieceField> and <Message> and
+// handle everything else with the default template which will match any type
+// having a method with signature "static const google::protobuf::Descriptor*
+// descriptor()". Such a type presumably is a descendant of google::protobuf::Message.
+
+template <>
+inline const RepeatedPtrField<std::string>&
+Reflection::GetRepeatedPtrFieldInternal<std::string>(
+    const Message& message, const FieldDescriptor* field) const {
+  return *static_cast<RepeatedPtrField<std::string>*>(
+      MutableRawRepeatedString(const_cast<Message*>(&message), field, true));
+}
+
+template <>
+inline RepeatedPtrField<std::string>*
+Reflection::MutableRepeatedPtrFieldInternal<std::string>(
+    Message* message, const FieldDescriptor* field) const {
+  return static_cast<RepeatedPtrField<std::string>*>(
+      MutableRawRepeatedString(message, field, true));
+}
+
+
+// -----
+
+template <>
+inline const RepeatedPtrField<Message>& Reflection::GetRepeatedPtrFieldInternal(
+    const Message& message, const FieldDescriptor* field) const {
+  return *static_cast<const RepeatedPtrField<Message>*>(GetRawRepeatedField(
+      message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, nullptr));
+}
+
+template <>
+inline RepeatedPtrField<Message>* Reflection::MutableRepeatedPtrFieldInternal(
+    Message* message, const FieldDescriptor* field) const {
+  return static_cast<RepeatedPtrField<Message>*>(MutableRawRepeatedField(
+      message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, nullptr));
+}
+
+template <typename PB>
+inline const RepeatedPtrField<PB>& Reflection::GetRepeatedPtrFieldInternal(
+    const Message& message, const FieldDescriptor* field) const {
+  return *static_cast<const RepeatedPtrField<PB>*>(
+      GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1,
+                          PB::default_instance().GetDescriptor()));
+}
+
+template <typename PB>
+inline RepeatedPtrField<PB>* Reflection::MutableRepeatedPtrFieldInternal(
+    Message* message, const FieldDescriptor* field) const {
+  return static_cast<RepeatedPtrField<PB>*>(
+      MutableRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE,
+                              -1, PB::default_instance().GetDescriptor()));
+}
+
+template <typename Type>
+const Type& Reflection::DefaultRaw(const FieldDescriptor* field) const {
+  return *reinterpret_cast<const Type*>(schema_.GetFieldDefault(field));
+}
+
+uint32_t Reflection::GetOneofCase(
+    const Message& message, const OneofDescriptor* oneof_descriptor) const {
+  GOOGLE_DCHECK(!oneof_descriptor->is_synthetic());
+  return internal::GetConstRefAtOffset<uint32_t>(
+      message, schema_.GetOneofCaseOffset(oneof_descriptor));
+}
+
+bool Reflection::HasOneofField(const Message& message,
+                               const FieldDescriptor* field) const {
+  return (GetOneofCase(message, field->containing_oneof()) ==
+          static_cast<uint32_t>(field->number()));
+}
+
+template <typename Type>
+const Type& Reflection::GetRaw(const Message& message,
+                               const FieldDescriptor* field) const {
+  GOOGLE_DCHECK(!schema_.InRealOneof(field) || HasOneofField(message, field))
+      << "Field = " << field->full_name();
+  return internal::GetConstRefAtOffset<Type>(message,
+                                             schema_.GetFieldOffset(field));
+}
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_MESSAGE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/message_lite.h b/CAPI/cpp/grpc/include/google/protobuf/message_lite.h
new file mode 100644
index 0000000..950ae1a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/message_lite.h
@@ -0,0 +1,591 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Authors: wink@google.com (Wink Saville),
+//          kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines MessageLite, the abstract interface implemented by all (lite
+// and non-lite) protocol message objects.
+
+#ifndef GOOGLE_PROTOBUF_MESSAGE_LITE_H__
+#define GOOGLE_PROTOBUF_MESSAGE_LITE_H__
+
+
+#include <climits>
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/explicitly_constructed.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/stubs/hash.h>  // TODO(b/211442718): cleanup
+
+// clang-format off
+#include <google/protobuf/port_def.inc>
+// clang-format on
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+template <typename T>
+class RepeatedPtrField;
+
+class FastReflectionMessageMutator;
+class FastReflectionStringSetter;
+class Reflection;
+
+namespace io {
+
+class CodedInputStream;
+class CodedOutputStream;
+class ZeroCopyInputStream;
+class ZeroCopyOutputStream;
+
+}  // namespace io
+namespace internal {
+
+class SwapFieldHelper;
+
+// See parse_context.h for explanation
+class ParseContext;
+
+class ExtensionSet;
+class LazyField;
+class RepeatedPtrFieldBase;
+class TcParser;
+class WireFormatLite;
+class WeakFieldMap;
+
+template <typename Type>
+class GenericTypeHandler;  // defined in repeated_field.h
+
+// We compute sizes as size_t but cache them as int.  This function converts a
+// computed size to a cached size.  Since we don't proceed with serialization
+// if the total size was > INT_MAX, it is not important what this function
+// returns for inputs > INT_MAX.  However this case should not error or
+// GOOGLE_CHECK-fail, because the full size_t resolution is still returned from
+// ByteSizeLong() and checked against INT_MAX; we can catch the overflow
+// there.
+inline int ToCachedSize(size_t size) { return static_cast<int>(size); }
+
+// We mainly calculate sizes in terms of size_t, but some functions that
+// compute sizes return "int".  These int sizes are expected to always be
+// positive. This function is more efficient than casting an int to size_t
+// directly on 64-bit platforms because it avoids making the compiler emit a
+// sign extending instruction, which we don't want and don't want to pay for.
+inline size_t FromIntSize(int size) {
+  // Convert to unsigned before widening so sign extension is not necessary.
+  return static_cast<unsigned int>(size);
+}
+
+// For cases where a legacy function returns an integer size.  We GOOGLE_DCHECK()
+// that the conversion will fit within an integer; if this is false then we
+// are losing information.
+inline int ToIntSize(size_t size) {
+  GOOGLE_DCHECK_LE(size, static_cast<size_t>(INT_MAX));
+  return static_cast<int>(size);
+}
+
+// Default empty string object. Don't use this directly. Instead, call
+// GetEmptyString() to get the reference. This empty string is aligned with a
+// minimum alignment of 8 bytes to match the requirement of ArenaStringPtr.
+PROTOBUF_EXPORT extern ExplicitlyConstructedArenaString
+    fixed_address_empty_string;
+
+
+PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited() {
+  return fixed_address_empty_string.get();
+}
+
+PROTOBUF_EXPORT size_t StringSpaceUsedExcludingSelfLong(const std::string& str);
+
+}  // namespace internal
+
+// Interface to light weight protocol messages.
+//
+// This interface is implemented by all protocol message objects.  Non-lite
+// messages additionally implement the Message interface, which is a
+// subclass of MessageLite.  Use MessageLite instead when you only need
+// the subset of features which it supports -- namely, nothing that uses
+// descriptors or reflection.  You can instruct the protocol compiler
+// to generate classes which implement only MessageLite, not the full
+// Message interface, by adding the following line to the .proto file:
+//
+//   option optimize_for = LITE_RUNTIME;
+//
+// This is particularly useful on resource-constrained systems where
+// the full protocol buffers runtime library is too big.
+//
+// Note that on non-constrained systems (e.g. servers) when you need
+// to link in lots of protocol definitions, a better way to reduce
+// total code footprint is to use optimize_for = CODE_SIZE.  This
+// will make the generated code smaller while still supporting all the
+// same features (at the expense of speed).  optimize_for = LITE_RUNTIME
+// is best when you only have a small number of message types linked
+// into your binary, in which case the size of the protocol buffers
+// runtime itself is the biggest problem.
+//
+// Users must not derive from this class. Only the protocol compiler and
+// the internal library are allowed to create subclasses.
+class PROTOBUF_EXPORT MessageLite {
+ public:
+  constexpr MessageLite() {}
+  virtual ~MessageLite() = default;
+
+  // Basic Operations ------------------------------------------------
+
+  // Get the name of this message type, e.g. "foo.bar.BazProto".
+  virtual std::string GetTypeName() const = 0;
+
+  // Construct a new instance of the same type.  Ownership is passed to the
+  // caller.
+  MessageLite* New() const { return New(nullptr); }
+
+  // Construct a new instance on the arena. Ownership is passed to the caller
+  // if arena is a nullptr.
+  virtual MessageLite* New(Arena* arena) const = 0;
+
+  // Returns user-owned arena; nullptr if it's message owned.
+  Arena* GetArena() const { return _internal_metadata_.user_arena(); }
+
+  // Clear all fields of the message and set them to their default values.
+  // Clear() assumes that any memory allocated to hold parts of the message
+  // will likely be needed again, so the memory used may not be freed.
+  // To ensure that all memory used by a Message is freed, you must delete it.
+  virtual void Clear() = 0;
+
+  // Quickly check if all required fields have values set.
+  virtual bool IsInitialized() const = 0;
+
+  // This is not implemented for Lite messages -- it just returns "(cannot
+  // determine missing fields for lite message)".  However, it is implemented
+  // for full messages.  See message.h.
+  virtual std::string InitializationErrorString() const;
+
+  // If |other| is the exact same class as this, calls MergeFrom(). Otherwise,
+  // results are undefined (probably crash).
+  virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0;
+
+  // These methods return a human-readable summary of the message. Note that
+  // since the MessageLite interface does not support reflection, there is very
+  // little information that these methods can provide. They are shadowed by
+  // methods of the same name on the Message interface which provide much more
+  // information. The methods here are intended primarily to facilitate code
+  // reuse for logic that needs to interoperate with both full and lite protos.
+  //
+  // The format of the returned string is subject to change, so please do not
+  // assume it will remain stable over time.
+  std::string DebugString() const;
+  std::string ShortDebugString() const { return DebugString(); }
+  // MessageLite::DebugString is already Utf8 Safe. This is to add compatibility
+  // with Message.
+  std::string Utf8DebugString() const { return DebugString(); }
+
+  // Parsing ---------------------------------------------------------
+  // Methods for parsing in protocol buffer format.  Most of these are
+  // just simple wrappers around MergeFromCodedStream().  Clear() will be
+  // called before merging the input.
+
+  // Fill the message with a protocol buffer parsed from the given input
+  // stream. Returns false on a read error or if the input is in the wrong
+  // format.  A successful return does not indicate the entire input is
+  // consumed, ensure you call ConsumedEntireMessage() to check that if
+  // applicable.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromCodedStream(
+      io::CodedInputStream* input);
+  // Like ParseFromCodedStream(), but accepts messages that are missing
+  // required fields.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromCodedStream(
+      io::CodedInputStream* input);
+  // Read a protocol buffer from the given zero-copy input stream.  If
+  // successful, the entire input will be consumed.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromZeroCopyStream(
+      io::ZeroCopyInputStream* input);
+  // Like ParseFromZeroCopyStream(), but accepts messages that are missing
+  // required fields.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromZeroCopyStream(
+      io::ZeroCopyInputStream* input);
+  // Parse a protocol buffer from a file descriptor.  If successful, the entire
+  // input will be consumed.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromFileDescriptor(
+      int file_descriptor);
+  // Like ParseFromFileDescriptor(), but accepts messages that are missing
+  // required fields.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromFileDescriptor(
+      int file_descriptor);
+  // Parse a protocol buffer from a C++ istream.  If successful, the entire
+  // input will be consumed.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromIstream(std::istream* input);
+  // Like ParseFromIstream(), but accepts messages that are missing
+  // required fields.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromIstream(
+      std::istream* input);
+  // Read a protocol buffer from the given zero-copy input stream, expecting
+  // the message to be exactly "size" bytes long.  If successful, exactly
+  // this many bytes will have been consumed from the input.
+  bool MergePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
+                                             int size);
+  // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
+  // missing required fields.
+  bool MergeFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromBoundedZeroCopyStream(
+      io::ZeroCopyInputStream* input, int size);
+  // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
+  // missing required fields.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromBoundedZeroCopyStream(
+      io::ZeroCopyInputStream* input, int size);
+  // Parses a protocol buffer contained in a string. Returns true on success.
+  // This function takes a string in the (non-human-readable) binary wire
+  // format, matching the encoding output by MessageLite::SerializeToString().
+  // If you'd like to convert a human-readable string into a protocol buffer
+  // object, see google::protobuf::TextFormat::ParseFromString().
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromString(ConstStringParam data);
+  // Like ParseFromString(), but accepts messages that are missing
+  // required fields.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromString(
+      ConstStringParam data);
+  // Parse a protocol buffer contained in an array of bytes.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromArray(const void* data,
+                                                       int size);
+  // Like ParseFromArray(), but accepts messages that are missing
+  // required fields.
+  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromArray(const void* data,
+                                                              int size);
+
+
+  // Reads a protocol buffer from the stream and merges it into this
+  // Message.  Singular fields read from the what is
+  // already in the Message and repeated fields are appended to those
+  // already present.
+  //
+  // It is the responsibility of the caller to call input->LastTagWas()
+  // (for groups) or input->ConsumedEntireMessage() (for non-groups) after
+  // this returns to verify that the message's end was delimited correctly.
+  //
+  // ParseFromCodedStream() is implemented as Clear() followed by
+  // MergeFromCodedStream().
+  bool MergeFromCodedStream(io::CodedInputStream* input);
+
+  // Like MergeFromCodedStream(), but succeeds even if required fields are
+  // missing in the input.
+  //
+  // MergeFromCodedStream() is just implemented as MergePartialFromCodedStream()
+  // followed by IsInitialized().
+  bool MergePartialFromCodedStream(io::CodedInputStream* input);
+
+  // Merge a protocol buffer contained in a string.
+  bool MergeFromString(ConstStringParam data);
+
+
+  // Serialization ---------------------------------------------------
+  // Methods for serializing in protocol buffer format.  Most of these
+  // are just simple wrappers around ByteSize() and SerializeWithCachedSizes().
+
+  // Write a protocol buffer of this message to the given output.  Returns
+  // false on a write error.  If the message is missing required fields,
+  // this may GOOGLE_CHECK-fail.
+  bool SerializeToCodedStream(io::CodedOutputStream* output) const;
+  // Like SerializeToCodedStream(), but allows missing required fields.
+  bool SerializePartialToCodedStream(io::CodedOutputStream* output) const;
+  // Write the message to the given zero-copy output stream.  All required
+  // fields must be set.
+  bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
+  // Like SerializeToZeroCopyStream(), but allows missing required fields.
+  bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
+  // Serialize the message and store it in the given string.  All required
+  // fields must be set.
+  bool SerializeToString(std::string* output) const;
+  // Like SerializeToString(), but allows missing required fields.
+  bool SerializePartialToString(std::string* output) const;
+  // Serialize the message and store it in the given byte array.  All required
+  // fields must be set.
+  bool SerializeToArray(void* data, int size) const;
+  // Like SerializeToArray(), but allows missing required fields.
+  bool SerializePartialToArray(void* data, int size) const;
+
+  // Make a string encoding the message. Is equivalent to calling
+  // SerializeToString() on a string and using that.  Returns the empty
+  // string if SerializeToString() would have returned an error.
+  // Note: If you intend to generate many such strings, you may
+  // reduce heap fragmentation by instead re-using the same string
+  // object with calls to SerializeToString().
+  std::string SerializeAsString() const;
+  // Like SerializeAsString(), but allows missing required fields.
+  std::string SerializePartialAsString() const;
+
+  // Serialize the message and write it to the given file descriptor.  All
+  // required fields must be set.
+  bool SerializeToFileDescriptor(int file_descriptor) const;
+  // Like SerializeToFileDescriptor(), but allows missing required fields.
+  bool SerializePartialToFileDescriptor(int file_descriptor) const;
+  // Serialize the message and write it to the given C++ ostream.  All
+  // required fields must be set.
+  bool SerializeToOstream(std::ostream* output) const;
+  // Like SerializeToOstream(), but allows missing required fields.
+  bool SerializePartialToOstream(std::ostream* output) const;
+
+  // Like SerializeToString(), but appends to the data to the string's
+  // existing contents.  All required fields must be set.
+  bool AppendToString(std::string* output) const;
+  // Like AppendToString(), but allows missing required fields.
+  bool AppendPartialToString(std::string* output) const;
+
+
+  // Computes the serialized size of the message.  This recursively calls
+  // ByteSizeLong() on all embedded messages.
+  //
+  // ByteSizeLong() is generally linear in the number of fields defined for the
+  // proto.
+  virtual size_t ByteSizeLong() const = 0;
+
+  // Legacy ByteSize() API.
+  PROTOBUF_DEPRECATED_MSG("Please use ByteSizeLong() instead")
+  int ByteSize() const { return internal::ToIntSize(ByteSizeLong()); }
+
+  // Serializes the message without recomputing the size.  The message must not
+  // have changed since the last call to ByteSize(), and the value returned by
+  // ByteSize must be non-negative.  Otherwise the results are undefined.
+  void SerializeWithCachedSizes(io::CodedOutputStream* output) const {
+    output->SetCur(_InternalSerialize(output->Cur(), output->EpsCopy()));
+  }
+
+  // Functions below here are not part of the public interface.  It isn't
+  // enforced, but they should be treated as private, and will be private
+  // at some future time.  Unfortunately the implementation of the "friend"
+  // keyword in GCC is broken at the moment, but we expect it will be fixed.
+
+  // Like SerializeWithCachedSizes, but writes directly to *target, returning
+  // a pointer to the byte immediately after the last byte written.  "target"
+  // must point at a byte array of at least ByteSize() bytes.  Whether to use
+  // deterministic serialization, e.g., maps in sorted order, is determined by
+  // CodedOutputStream::IsDefaultSerializationDeterministic().
+  uint8_t* SerializeWithCachedSizesToArray(uint8_t* target) const;
+
+  // Returns the result of the last call to ByteSize().  An embedded message's
+  // size is needed both to serialize it (because embedded messages are
+  // length-delimited) and to compute the outer message's size.  Caching
+  // the size avoids computing it multiple times.
+  //
+  // ByteSize() does not automatically use the cached size when available
+  // because this would require invalidating it every time the message was
+  // modified, which would be too hard and expensive.  (E.g. if a deeply-nested
+  // sub-message is changed, all of its parents' cached sizes would need to be
+  // invalidated, which is too much work for an otherwise inlined setter
+  // method.)
+  virtual int GetCachedSize() const = 0;
+
+  virtual const char* _InternalParse(const char* /*ptr*/,
+                                     internal::ParseContext* /*ctx*/) {
+    return nullptr;
+  }
+
+  virtual void OnDemandRegisterArenaDtor(Arena* /*arena*/) {}
+
+ protected:
+  template <typename T>
+  static T* CreateMaybeMessage(Arena* arena) {
+    return Arena::CreateMaybeMessage<T>(arena);
+  }
+
+  inline explicit MessageLite(Arena* arena, bool is_message_owned = false)
+      : _internal_metadata_(arena, is_message_owned) {}
+
+  // Returns the arena, if any, that directly owns this message and its internal
+  // memory (Arena::Own is different in that the arena doesn't directly own the
+  // internal memory). This method is used in proto's implementation for
+  // swapping, moving and setting allocated, for deciding whether the ownership
+  // of this message or its internal memory could be changed.
+  Arena* GetOwningArena() const { return _internal_metadata_.owning_arena(); }
+
+  // Returns the arena, used for allocating internal objects(e.g., child
+  // messages, etc), or owning incoming objects (e.g., set allocated).
+  Arena* GetArenaForAllocation() const { return _internal_metadata_.arena(); }
+
+  // Returns true if this message is enabled for message-owned arena (MOA)
+  // trials. No lite messages are eligible for MOA.
+  static bool InMoaTrial() { return false; }
+
+  internal::InternalMetadata _internal_metadata_;
+
+ public:
+  enum ParseFlags {
+    kMerge = 0,
+    kParse = 1,
+    kMergePartial = 2,
+    kParsePartial = 3,
+    kMergeWithAliasing = 4,
+    kParseWithAliasing = 5,
+    kMergePartialWithAliasing = 6,
+    kParsePartialWithAliasing = 7
+  };
+
+  template <ParseFlags flags, typename T>
+  bool ParseFrom(const T& input);
+
+  // Fast path when conditions match (ie. non-deterministic)
+  //  uint8_t* _InternalSerialize(uint8_t* ptr) const;
+  virtual uint8_t* _InternalSerialize(
+      uint8_t* ptr, io::EpsCopyOutputStream* stream) const = 0;
+
+  // Identical to IsInitialized() except that it logs an error message.
+  bool IsInitializedWithErrors() const {
+    if (IsInitialized()) return true;
+    LogInitializationErrorMessage();
+    return false;
+  }
+
+ private:
+  friend class FastReflectionMessageMutator;
+  friend class FastReflectionStringSetter;
+  friend class Message;
+  friend class Reflection;
+  friend class internal::ExtensionSet;
+  friend class internal::LazyField;
+  friend class internal::SwapFieldHelper;
+  friend class internal::TcParser;
+  friend class internal::WeakFieldMap;
+  friend class internal::WireFormatLite;
+
+  template <typename Type>
+  friend class Arena::InternalHelper;
+  template <typename Type>
+  friend class internal::GenericTypeHandler;
+
+  void LogInitializationErrorMessage() const;
+
+  bool MergeFromImpl(io::CodedInputStream* input, ParseFlags parse_flags);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite);
+};
+
+namespace internal {
+
+template <bool alias>
+bool MergeFromImpl(StringPiece input, MessageLite* msg,
+                   MessageLite::ParseFlags parse_flags);
+extern template bool MergeFromImpl<false>(StringPiece input,
+                                          MessageLite* msg,
+                                          MessageLite::ParseFlags parse_flags);
+extern template bool MergeFromImpl<true>(StringPiece input,
+                                         MessageLite* msg,
+                                         MessageLite::ParseFlags parse_flags);
+
+template <bool alias>
+bool MergeFromImpl(io::ZeroCopyInputStream* input, MessageLite* msg,
+                   MessageLite::ParseFlags parse_flags);
+extern template bool MergeFromImpl<false>(io::ZeroCopyInputStream* input,
+                                          MessageLite* msg,
+                                          MessageLite::ParseFlags parse_flags);
+extern template bool MergeFromImpl<true>(io::ZeroCopyInputStream* input,
+                                         MessageLite* msg,
+                                         MessageLite::ParseFlags parse_flags);
+
+struct BoundedZCIS {
+  io::ZeroCopyInputStream* zcis;
+  int limit;
+};
+
+template <bool alias>
+bool MergeFromImpl(BoundedZCIS input, MessageLite* msg,
+                   MessageLite::ParseFlags parse_flags);
+extern template bool MergeFromImpl<false>(BoundedZCIS input, MessageLite* msg,
+                                          MessageLite::ParseFlags parse_flags);
+extern template bool MergeFromImpl<true>(BoundedZCIS input, MessageLite* msg,
+                                         MessageLite::ParseFlags parse_flags);
+
+template <typename T>
+struct SourceWrapper;
+
+template <bool alias, typename T>
+bool MergeFromImpl(const SourceWrapper<T>& input, MessageLite* msg,
+                   MessageLite::ParseFlags parse_flags) {
+  return input.template MergeInto<alias>(msg, parse_flags);
+}
+
+}  // namespace internal
+
+template <MessageLite::ParseFlags flags, typename T>
+bool MessageLite::ParseFrom(const T& input) {
+  if (flags & kParse) Clear();
+  constexpr bool alias = (flags & kMergeWithAliasing) != 0;
+  return internal::MergeFromImpl<alias>(input, this, flags);
+}
+
+// ===================================================================
+// Shutdown support.
+
+
+// Shut down the entire protocol buffers library, deleting all static-duration
+// objects allocated by the library or by generated .pb.cc files.
+//
+// There are two reasons you might want to call this:
+// * You use a draconian definition of "memory leak" in which you expect
+//   every single malloc() to have a corresponding free(), even for objects
+//   which live until program exit.
+// * You are writing a dynamically-loaded library which needs to clean up
+//   after itself when the library is unloaded.
+//
+// It is safe to call this multiple times.  However, it is not safe to use
+// any other part of the protocol buffers library after
+// ShutdownProtobufLibrary() has been called. Furthermore this call is not
+// thread safe, user needs to synchronize multiple calls.
+PROTOBUF_EXPORT void ShutdownProtobufLibrary();
+
+namespace internal {
+
+// Register a function to be called when ShutdownProtocolBuffers() is called.
+PROTOBUF_EXPORT void OnShutdown(void (*func)());
+// Run an arbitrary function on an arg
+PROTOBUF_EXPORT void OnShutdownRun(void (*f)(const void*), const void* arg);
+
+template <typename T>
+T* OnShutdownDelete(T* p) {
+  OnShutdownRun([](const void* pp) { delete static_cast<const T*>(pp); }, p);
+  return p;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_MESSAGE_LITE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/metadata.h b/CAPI/cpp/grpc/include/google/protobuf/metadata.h
new file mode 100644
index 0000000..4e89648
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/metadata.h
@@ -0,0 +1,36 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_METADATA_H__
+#define GOOGLE_PROTOBUF_METADATA_H__
+
+// TODO(b/151117630): Remove this file and all instances where it gets imported.
+
+#endif  // GOOGLE_PROTOBUF_METADATA_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/metadata_lite.h b/CAPI/cpp/grpc/include/google/protobuf/metadata_lite.h
new file mode 100644
index 0000000..0c31517
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/metadata_lite.h
@@ -0,0 +1,316 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_METADATA_LITE_H__
+#define GOOGLE_PROTOBUF_METADATA_LITE_H__
+
+#include <string>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/port.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// This is the representation for messages that support arena allocation. It
+// uses a tagged pointer to either store the owning Arena pointer, if there are
+// no unknown fields, or a pointer to a block of memory with both the owning
+// Arena pointer and the UnknownFieldSet, if there are unknown fields. Besides,
+// it also uses the tag to distinguish whether the owning Arena pointer is also
+// used by sub-structure allocation. This optimization allows for
+// "zero-overhead" storage of the Arena pointer, relative to the above baseline
+// implementation.
+//
+// The tagged pointer uses the least two significant bits to disambiguate cases.
+// It uses bit 0 == 0 to indicate an arena pointer and bit 0 == 1 to indicate a
+// UFS+Arena-container pointer. Besides it uses bit 1 == 0 to indicate arena
+// allocation and bit 1 == 1 to indicate heap allocation.
+class PROTOBUF_EXPORT InternalMetadata {
+ public:
+  constexpr InternalMetadata() : ptr_(0) {}
+  explicit InternalMetadata(Arena* arena, bool is_message_owned = false) {
+    SetArena(arena, is_message_owned);
+  }
+
+  void SetArena(Arena* arena, bool is_message_owned) {
+    ptr_ = is_message_owned
+               ? reinterpret_cast<intptr_t>(arena) | kMessageOwnedArenaTagMask
+               : reinterpret_cast<intptr_t>(arena);
+    GOOGLE_DCHECK(!is_message_owned || arena != nullptr);
+  }
+
+  // To keep the ABI identical between debug and non-debug builds,
+  // the destructor is always defined here even though it may delegate
+  // to a non-inline private method.
+  // (see https://github.com/protocolbuffers/protobuf/issues/9947)
+  ~InternalMetadata() {
+#if defined(NDEBUG) || defined(_MSC_VER)
+    if (HasMessageOwnedArenaTag()) {
+      delete reinterpret_cast<Arena*>(ptr_ - kMessageOwnedArenaTagMask);
+    }
+#else
+    CheckedDestruct();
+#endif
+  }
+
+  template <typename T>
+  void Delete() {
+    // Note that Delete<> should be called not more than once.
+    if (have_unknown_fields()) {
+      DeleteOutOfLineHelper<T>();
+    }
+  }
+
+  // DeleteReturnArena will delete the unknown fields only if they weren't
+  // allocated on an arena.  Then it updates the flags so that if you call
+  // have_unknown_fields(), it will return false.  Finally, it returns the
+  // current value of arena().  It is designed to be used as part of a
+  // Message class's destructor call, so that when control eventually gets
+  // to ~InternalMetadata(), we don't need to check for have_unknown_fields()
+  // again.
+  template <typename T>
+  Arena* DeleteReturnArena() {
+    if (have_unknown_fields()) {
+      return DeleteOutOfLineHelper<T>();
+    } else {
+      return PtrValue<Arena>();
+    }
+  }
+
+  PROTOBUF_NDEBUG_INLINE Arena* owning_arena() const {
+    return HasMessageOwnedArenaTag() ? nullptr : arena();
+  }
+
+  PROTOBUF_NDEBUG_INLINE Arena* user_arena() const {
+    Arena* a = arena();
+    return a && !a->IsMessageOwned() ? a : nullptr;
+  }
+
+  PROTOBUF_NDEBUG_INLINE Arena* arena() const {
+    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
+      return PtrValue<ContainerBase>()->arena;
+    } else {
+      return PtrValue<Arena>();
+    }
+  }
+
+  PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const {
+    return HasUnknownFieldsTag();
+  }
+
+  PROTOBUF_NDEBUG_INLINE void* raw_arena_ptr() const {
+    return reinterpret_cast<void*>(ptr_);
+  }
+
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE const T& unknown_fields(
+      const T& (*default_instance)()) const {
+    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
+      return PtrValue<Container<T>>()->unknown_fields;
+    } else {
+      return default_instance();
+    }
+  }
+
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE T* mutable_unknown_fields() {
+    if (PROTOBUF_PREDICT_TRUE(have_unknown_fields())) {
+      return &PtrValue<Container<T>>()->unknown_fields;
+    } else {
+      return mutable_unknown_fields_slow<T>();
+    }
+  }
+
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE void Swap(InternalMetadata* other) {
+    // Semantics here are that we swap only the unknown fields, not the arena
+    // pointer. We cannot simply swap ptr_ with other->ptr_ because we need to
+    // maintain our own arena ptr. Also, our ptr_ and other's ptr_ may be in
+    // different states (direct arena pointer vs. container with UFS) so we
+    // cannot simply swap ptr_ and then restore the arena pointers. We reuse
+    // UFS's swap implementation instead.
+    if (have_unknown_fields() || other->have_unknown_fields()) {
+      DoSwap<T>(other->mutable_unknown_fields<T>());
+    }
+  }
+
+  PROTOBUF_NDEBUG_INLINE void InternalSwap(InternalMetadata* other) {
+    std::swap(ptr_, other->ptr_);
+  }
+
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE void MergeFrom(const InternalMetadata& other) {
+    if (other.have_unknown_fields()) {
+      DoMergeFrom<T>(other.unknown_fields<T>(nullptr));
+    }
+  }
+
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE void Clear() {
+    if (have_unknown_fields()) {
+      DoClear<T>();
+    }
+  }
+
+ private:
+  intptr_t ptr_;
+
+  // Tagged pointer implementation.
+  static constexpr intptr_t kUnknownFieldsTagMask = 1;
+  static constexpr intptr_t kMessageOwnedArenaTagMask = 2;
+  static constexpr intptr_t kPtrTagMask =
+      kUnknownFieldsTagMask | kMessageOwnedArenaTagMask;
+  static constexpr intptr_t kPtrValueMask = ~kPtrTagMask;
+
+  // Accessors for pointer tag and pointer value.
+  PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const {
+    return ptr_ & kUnknownFieldsTagMask;
+  }
+  PROTOBUF_ALWAYS_INLINE bool HasMessageOwnedArenaTag() const {
+    return ptr_ & kMessageOwnedArenaTagMask;
+  }
+
+  template <typename U>
+  U* PtrValue() const {
+    return reinterpret_cast<U*>(ptr_ & kPtrValueMask);
+  }
+
+  // If ptr_'s tag is kTagContainer, it points to an instance of this struct.
+  struct ContainerBase {
+    Arena* arena;
+  };
+
+  template <typename T>
+  struct Container : public ContainerBase {
+    T unknown_fields;
+  };
+
+  template <typename T>
+  PROTOBUF_NOINLINE Arena* DeleteOutOfLineHelper() {
+    if (auto* a = arena()) {
+      // Subtle: we want to preserve the message-owned arena flag, while at the
+      // same time replacing the pointer to Container<T> with a pointer to the
+      // arena.
+      intptr_t message_owned_arena_tag = ptr_ & kMessageOwnedArenaTagMask;
+      ptr_ = reinterpret_cast<intptr_t>(a) | message_owned_arena_tag;
+      return a;
+    } else {
+      delete PtrValue<Container<T>>();
+      ptr_ = 0;
+      return nullptr;
+    }
+  }
+
+  template <typename T>
+  PROTOBUF_NOINLINE T* mutable_unknown_fields_slow() {
+    Arena* my_arena = arena();
+    Container<T>* container = Arena::Create<Container<T>>(my_arena);
+    intptr_t message_owned_arena_tag = ptr_ & kMessageOwnedArenaTagMask;
+    // Two-step assignment works around a bug in clang's static analyzer:
+    // https://bugs.llvm.org/show_bug.cgi?id=34198.
+    ptr_ = reinterpret_cast<intptr_t>(container);
+    ptr_ |= kUnknownFieldsTagMask | message_owned_arena_tag;
+    container->arena = my_arena;
+    return &(container->unknown_fields);
+  }
+
+  // Templated functions.
+
+  template <typename T>
+  PROTOBUF_NOINLINE void DoClear() {
+    mutable_unknown_fields<T>()->Clear();
+  }
+
+  template <typename T>
+  PROTOBUF_NOINLINE void DoMergeFrom(const T& other) {
+    mutable_unknown_fields<T>()->MergeFrom(other);
+  }
+
+  template <typename T>
+  PROTOBUF_NOINLINE void DoSwap(T* other) {
+    mutable_unknown_fields<T>()->Swap(other);
+  }
+
+  // Private helper with debug checks for ~InternalMetadata()
+  void CheckedDestruct();
+};
+
+// String Template specializations.
+
+template <>
+PROTOBUF_EXPORT void InternalMetadata::DoClear<std::string>();
+template <>
+PROTOBUF_EXPORT void InternalMetadata::DoMergeFrom<std::string>(
+    const std::string& other);
+template <>
+PROTOBUF_EXPORT void InternalMetadata::DoSwap<std::string>(std::string* other);
+
+// This helper RAII class is needed to efficiently parse unknown fields. We
+// should only call mutable_unknown_fields if there are actual unknown fields.
+// The obvious thing to just use a stack string and swap it at the end of
+// the parse won't work, because the destructor of StringOutputStream needs to
+// be called before we can modify the string (it check-fails). Using
+// LiteUnknownFieldSetter setter(&_internal_metadata_);
+// StringOutputStream stream(setter.buffer());
+// guarantees that the string is only swapped after stream is destroyed.
+class PROTOBUF_EXPORT LiteUnknownFieldSetter {
+ public:
+  explicit LiteUnknownFieldSetter(InternalMetadata* metadata)
+      : metadata_(metadata) {
+    if (metadata->have_unknown_fields()) {
+      buffer_.swap(*metadata->mutable_unknown_fields<std::string>());
+    }
+  }
+  ~LiteUnknownFieldSetter() {
+    if (!buffer_.empty())
+      metadata_->mutable_unknown_fields<std::string>()->swap(buffer_);
+  }
+  std::string* buffer() { return &buffer_; }
+
+ private:
+  InternalMetadata* metadata_;
+  std::string buffer_;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_METADATA_LITE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/parse_context.h b/CAPI/cpp/grpc/include/google/protobuf/parse_context.h
new file mode 100644
index 0000000..7aea50c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/parse_context.h
@@ -0,0 +1,1025 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PARSE_CONTEXT_H__
+#define GOOGLE_PROTOBUF_PARSE_CONTEXT_H__
+
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <type_traits>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/endian.h>
+#include <google/protobuf/implicit_weak_message.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/wire_format_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+
+namespace google {
+namespace protobuf {
+
+class UnknownFieldSet;
+class DescriptorPool;
+class MessageFactory;
+
+namespace internal {
+
+// Template code below needs to know about the existence of these functions.
+PROTOBUF_EXPORT void WriteVarint(uint32_t num, uint64_t val, std::string* s);
+PROTOBUF_EXPORT void WriteLengthDelimited(uint32_t num, StringPiece val,
+                                          std::string* s);
+// Inline because it is just forwarding to s->WriteVarint
+inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* s);
+inline void WriteLengthDelimited(uint32_t num, StringPiece val,
+                                 UnknownFieldSet* s);
+
+
+// The basic abstraction the parser is designed for is a slight modification
+// of the ZeroCopyInputStream (ZCIS) abstraction. A ZCIS presents a serialized
+// stream as a series of buffers that concatenate to the full stream.
+// Pictorially a ZCIS presents a stream in chunks like so
+// [---------------------------------------------------------------]
+// [---------------------] chunk 1
+//                      [----------------------------] chunk 2
+//                                          chunk 3 [--------------]
+//
+// Where the '-' represent the bytes which are vertically lined up with the
+// bytes of the stream. The proto parser requires its input to be presented
+// similarly with the extra
+// property that each chunk has kSlopBytes past its end that overlaps with the
+// first kSlopBytes of the next chunk, or if there is no next chunk at least its
+// still valid to read those bytes. Again, pictorially, we now have
+//
+// [---------------------------------------------------------------]
+// [-------------------....] chunk 1
+//                    [------------------------....] chunk 2
+//                                    chunk 3 [------------------..**]
+//                                                      chunk 4 [--****]
+// Here '-' mean the bytes of the stream or chunk and '.' means bytes past the
+// chunk that match up with the start of the next chunk. Above each chunk has
+// 4 '.' after the chunk. In the case these 'overflow' bytes represents bytes
+// past the stream, indicated by '*' above, their values are unspecified. It is
+// still legal to read them (ie. should not segfault). Reading past the
+// end should be detected by the user and indicated as an error.
+//
+// The reason for this, admittedly, unconventional invariant is to ruthlessly
+// optimize the protobuf parser. Having an overlap helps in two important ways.
+// Firstly it alleviates having to performing bounds checks if a piece of code
+// is guaranteed to not read more than kSlopBytes. Secondly, and more
+// importantly, the protobuf wireformat is such that reading a key/value pair is
+// always less than 16 bytes. This removes the need to change to next buffer in
+// the middle of reading primitive values. Hence there is no need to store and
+// load the current position.
+
+class PROTOBUF_EXPORT EpsCopyInputStream {
+ public:
+  enum { kSlopBytes = 16, kMaxCordBytesToCopy = 512 };
+
+  explicit EpsCopyInputStream(bool enable_aliasing)
+      : aliasing_(enable_aliasing ? kOnPatch : kNoAliasing) {}
+
+  void BackUp(const char* ptr) {
+    GOOGLE_DCHECK(ptr <= buffer_end_ + kSlopBytes);
+    int count;
+    if (next_chunk_ == buffer_) {
+      count = static_cast<int>(buffer_end_ + kSlopBytes - ptr);
+    } else {
+      count = size_ + static_cast<int>(buffer_end_ - ptr);
+    }
+    if (count > 0) StreamBackUp(count);
+  }
+
+  // If return value is negative it's an error
+  PROTOBUF_NODISCARD int PushLimit(const char* ptr, int limit) {
+    GOOGLE_DCHECK(limit >= 0 && limit <= INT_MAX - kSlopBytes);
+    // This add is safe due to the invariant above, because
+    // ptr - buffer_end_ <= kSlopBytes.
+    limit += static_cast<int>(ptr - buffer_end_);
+    limit_end_ = buffer_end_ + (std::min)(0, limit);
+    auto old_limit = limit_;
+    limit_ = limit;
+    return old_limit - limit;
+  }
+
+  PROTOBUF_NODISCARD bool PopLimit(int delta) {
+    if (PROTOBUF_PREDICT_FALSE(!EndedAtLimit())) return false;
+    limit_ = limit_ + delta;
+    // TODO(gerbens) We could remove this line and hoist the code to
+    // DoneFallback. Study the perf/bin-size effects.
+    limit_end_ = buffer_end_ + (std::min)(0, limit_);
+    return true;
+  }
+
+  PROTOBUF_NODISCARD const char* Skip(const char* ptr, int size) {
+    if (size <= buffer_end_ + kSlopBytes - ptr) {
+      return ptr + size;
+    }
+    return SkipFallback(ptr, size);
+  }
+  PROTOBUF_NODISCARD const char* ReadString(const char* ptr, int size,
+                                            std::string* s) {
+    if (size <= buffer_end_ + kSlopBytes - ptr) {
+      s->assign(ptr, size);
+      return ptr + size;
+    }
+    return ReadStringFallback(ptr, size, s);
+  }
+  PROTOBUF_NODISCARD const char* AppendString(const char* ptr, int size,
+                                              std::string* s) {
+    if (size <= buffer_end_ + kSlopBytes - ptr) {
+      s->append(ptr, size);
+      return ptr + size;
+    }
+    return AppendStringFallback(ptr, size, s);
+  }
+  // Implemented in arenastring.cc
+  PROTOBUF_NODISCARD const char* ReadArenaString(const char* ptr,
+                                                 ArenaStringPtr* s,
+                                                 Arena* arena);
+
+  template <typename Tag, typename T>
+  PROTOBUF_NODISCARD const char* ReadRepeatedFixed(const char* ptr,
+                                                   Tag expected_tag,
+                                                   RepeatedField<T>* out);
+
+  template <typename T>
+  PROTOBUF_NODISCARD const char* ReadPackedFixed(const char* ptr, int size,
+                                                 RepeatedField<T>* out);
+  template <typename Add>
+  PROTOBUF_NODISCARD const char* ReadPackedVarint(const char* ptr, Add add);
+
+  uint32_t LastTag() const { return last_tag_minus_1_ + 1; }
+  bool ConsumeEndGroup(uint32_t start_tag) {
+    bool res = last_tag_minus_1_ == start_tag;
+    last_tag_minus_1_ = 0;
+    return res;
+  }
+  bool EndedAtLimit() const { return last_tag_minus_1_ == 0; }
+  bool EndedAtEndOfStream() const { return last_tag_minus_1_ == 1; }
+  void SetLastTag(uint32_t tag) { last_tag_minus_1_ = tag - 1; }
+  void SetEndOfStream() { last_tag_minus_1_ = 1; }
+  bool IsExceedingLimit(const char* ptr) {
+    return ptr > limit_end_ &&
+           (next_chunk_ == nullptr || ptr - buffer_end_ > limit_);
+  }
+  bool AliasingEnabled() const { return aliasing_ != kNoAliasing; }
+  int BytesUntilLimit(const char* ptr) const {
+    return limit_ + static_cast<int>(buffer_end_ - ptr);
+  }
+  // Returns true if more data is available, if false is returned one has to
+  // call Done for further checks.
+  bool DataAvailable(const char* ptr) { return ptr < limit_end_; }
+
+ protected:
+  // Returns true is limit (either an explicit limit or end of stream) is
+  // reached. It aligns *ptr across buffer seams.
+  // If limit is exceeded it returns true and ptr is set to null.
+  bool DoneWithCheck(const char** ptr, int d) {
+    GOOGLE_DCHECK(*ptr);
+    if (PROTOBUF_PREDICT_TRUE(*ptr < limit_end_)) return false;
+    int overrun = static_cast<int>(*ptr - buffer_end_);
+    GOOGLE_DCHECK_LE(overrun, kSlopBytes);  // Guaranteed by parse loop.
+    if (overrun ==
+        limit_) {  //  No need to flip buffers if we ended on a limit.
+      // If we actually overrun the buffer and next_chunk_ is null. It means
+      // the stream ended and we passed the stream end.
+      if (overrun > 0 && next_chunk_ == nullptr) *ptr = nullptr;
+      return true;
+    }
+    auto res = DoneFallback(overrun, d);
+    *ptr = res.first;
+    return res.second;
+  }
+
+  const char* InitFrom(StringPiece flat) {
+    overall_limit_ = 0;
+    if (flat.size() > kSlopBytes) {
+      limit_ = kSlopBytes;
+      limit_end_ = buffer_end_ = flat.data() + flat.size() - kSlopBytes;
+      next_chunk_ = buffer_;
+      if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
+      return flat.data();
+    } else {
+      std::memcpy(buffer_, flat.data(), flat.size());
+      limit_ = 0;
+      limit_end_ = buffer_end_ = buffer_ + flat.size();
+      next_chunk_ = nullptr;
+      if (aliasing_ == kOnPatch) {
+        aliasing_ = reinterpret_cast<std::uintptr_t>(flat.data()) -
+                    reinterpret_cast<std::uintptr_t>(buffer_);
+      }
+      return buffer_;
+    }
+  }
+
+  const char* InitFrom(io::ZeroCopyInputStream* zcis);
+
+  const char* InitFrom(io::ZeroCopyInputStream* zcis, int limit) {
+    if (limit == -1) return InitFrom(zcis);
+    overall_limit_ = limit;
+    auto res = InitFrom(zcis);
+    limit_ = limit - static_cast<int>(buffer_end_ - res);
+    limit_end_ = buffer_end_ + (std::min)(0, limit_);
+    return res;
+  }
+
+ private:
+  const char* limit_end_;  // buffer_end_ + min(limit_, 0)
+  const char* buffer_end_;
+  const char* next_chunk_;
+  int size_;
+  int limit_;  // relative to buffer_end_;
+  io::ZeroCopyInputStream* zcis_ = nullptr;
+  char buffer_[2 * kSlopBytes] = {};
+  enum { kNoAliasing = 0, kOnPatch = 1, kNoDelta = 2 };
+  std::uintptr_t aliasing_ = kNoAliasing;
+  // This variable is used to communicate how the parse ended, in order to
+  // completely verify the parsed data. A wire-format parse can end because of
+  // one of the following conditions:
+  // 1) A parse can end on a pushed limit.
+  // 2) A parse can end on End Of Stream (EOS).
+  // 3) A parse can end on 0 tag (only valid for toplevel message).
+  // 4) A parse can end on an end-group tag.
+  // This variable should always be set to 0, which indicates case 1. If the
+  // parse terminated due to EOS (case 2), it's set to 1. In case the parse
+  // ended due to a terminating tag (case 3 and 4) it's set to (tag - 1).
+  // This var doesn't really belong in EpsCopyInputStream and should be part of
+  // the ParseContext, but case 2 is most easily and optimally implemented in
+  // DoneFallback.
+  uint32_t last_tag_minus_1_ = 0;
+  int overall_limit_ = INT_MAX;  // Overall limit independent of pushed limits.
+  // Pretty random large number that seems like a safe allocation on most
+  // systems. TODO(gerbens) do we need to set this as build flag?
+  enum { kSafeStringSize = 50000000 };
+
+  // Advances to next buffer chunk returns a pointer to the same logical place
+  // in the stream as set by overrun. Overrun indicates the position in the slop
+  // region the parse was left (0 <= overrun <= kSlopBytes). Returns true if at
+  // limit, at which point the returned pointer maybe null if there was an
+  // error. The invariant of this function is that it's guaranteed that
+  // kSlopBytes bytes can be accessed from the returned ptr. This function might
+  // advance more buffers than one in the underlying ZeroCopyInputStream.
+  std::pair<const char*, bool> DoneFallback(int overrun, int depth);
+  // Advances to the next buffer, at most one call to Next() on the underlying
+  // ZeroCopyInputStream is made. This function DOES NOT match the returned
+  // pointer to where in the slop region the parse ends, hence no overrun
+  // parameter. This is useful for string operations where you always copy
+  // to the end of the buffer (including the slop region).
+  const char* Next();
+  // overrun is the location in the slop region the stream currently is
+  // (0 <= overrun <= kSlopBytes). To prevent flipping to the next buffer of
+  // the ZeroCopyInputStream in the case the parse will end in the last
+  // kSlopBytes of the current buffer. depth is the current depth of nested
+  // groups (or negative if the use case does not need careful tracking).
+  inline const char* NextBuffer(int overrun, int depth);
+  const char* SkipFallback(const char* ptr, int size);
+  const char* AppendStringFallback(const char* ptr, int size, std::string* str);
+  const char* ReadStringFallback(const char* ptr, int size, std::string* str);
+  bool StreamNext(const void** data) {
+    bool res = zcis_->Next(data, &size_);
+    if (res) overall_limit_ -= size_;
+    return res;
+  }
+  void StreamBackUp(int count) {
+    zcis_->BackUp(count);
+    overall_limit_ += count;
+  }
+
+  template <typename A>
+  const char* AppendSize(const char* ptr, int size, const A& append) {
+    int chunk_size = buffer_end_ + kSlopBytes - ptr;
+    do {
+      GOOGLE_DCHECK(size > chunk_size);
+      if (next_chunk_ == nullptr) return nullptr;
+      append(ptr, chunk_size);
+      ptr += chunk_size;
+      size -= chunk_size;
+      // TODO(gerbens) Next calls NextBuffer which generates buffers with
+      // overlap and thus incurs cost of copying the slop regions. This is not
+      // necessary for reading strings. We should just call Next buffers.
+      if (limit_ <= kSlopBytes) return nullptr;
+      ptr = Next();
+      if (ptr == nullptr) return nullptr;  // passed the limit
+      ptr += kSlopBytes;
+      chunk_size = buffer_end_ + kSlopBytes - ptr;
+    } while (size > chunk_size);
+    append(ptr, size);
+    return ptr + size;
+  }
+
+  // AppendUntilEnd appends data until a limit (either a PushLimit or end of
+  // stream. Normal payloads are from length delimited fields which have an
+  // explicit size. Reading until limit only comes when the string takes
+  // the place of a protobuf, ie RawMessage/StringRawMessage, lazy fields and
+  // implicit weak messages. We keep these methods private and friend them.
+  template <typename A>
+  const char* AppendUntilEnd(const char* ptr, const A& append) {
+    if (ptr - buffer_end_ > limit_) return nullptr;
+    while (limit_ > kSlopBytes) {
+      size_t chunk_size = buffer_end_ + kSlopBytes - ptr;
+      append(ptr, chunk_size);
+      ptr = Next();
+      if (ptr == nullptr) return limit_end_;
+      ptr += kSlopBytes;
+    }
+    auto end = buffer_end_ + limit_;
+    GOOGLE_DCHECK(end >= ptr);
+    append(ptr, end - ptr);
+    return end;
+  }
+
+  PROTOBUF_NODISCARD const char* AppendString(const char* ptr,
+                                              std::string* str) {
+    return AppendUntilEnd(
+        ptr, [str](const char* p, ptrdiff_t s) { str->append(p, s); });
+  }
+  friend class ImplicitWeakMessage;
+};
+
+using LazyEagerVerifyFnType = const char* (*)(const char* ptr,
+                                              ParseContext* ctx);
+using LazyEagerVerifyFnRef = std::remove_pointer<LazyEagerVerifyFnType>::type&;
+
+// ParseContext holds all data that is global to the entire parse. Most
+// importantly it contains the input stream, but also recursion depth and also
+// stores the end group tag, in case a parser ended on a endgroup, to verify
+// matching start/end group tags.
+class PROTOBUF_EXPORT ParseContext : public EpsCopyInputStream {
+ public:
+  struct Data {
+    const DescriptorPool* pool = nullptr;
+    MessageFactory* factory = nullptr;
+    Arena* arena = nullptr;
+  };
+
+  template <typename... T>
+  ParseContext(int depth, bool aliasing, const char** start, T&&... args)
+      : EpsCopyInputStream(aliasing), depth_(depth) {
+    *start = InitFrom(std::forward<T>(args)...);
+  }
+
+  void TrackCorrectEnding() { group_depth_ = 0; }
+
+  bool Done(const char** ptr) { return DoneWithCheck(ptr, group_depth_); }
+
+  int depth() const { return depth_; }
+
+  Data& data() { return data_; }
+  const Data& data() const { return data_; }
+
+  const char* ParseMessage(MessageLite* msg, const char* ptr);
+
+  // Spawns a child parsing context that inherits key properties. New context
+  // inherits the following:
+  // --depth_, data_, check_required_fields_, lazy_parse_mode_
+  // The spawned context always disables aliasing (different input).
+  template <typename... T>
+  ParseContext Spawn(const char** start, T&&... args) {
+    ParseContext spawned(depth_, false, start, std::forward<T>(args)...);
+    // Transfer key context states.
+    spawned.data_ = data_;
+    return spawned;
+  }
+
+  // This overload supports those few cases where ParseMessage is called
+  // on a class that is not actually a proto message.
+  // TODO(jorg): Eliminate this use case.
+  template <typename T,
+            typename std::enable_if<!std::is_base_of<MessageLite, T>::value,
+                                    bool>::type = true>
+  PROTOBUF_NODISCARD const char* ParseMessage(T* msg, const char* ptr);
+
+  template <typename T>
+  PROTOBUF_NODISCARD PROTOBUF_NDEBUG_INLINE const char* ParseGroup(
+      T* msg, const char* ptr, uint32_t tag) {
+    if (--depth_ < 0) return nullptr;
+    group_depth_++;
+    ptr = msg->_InternalParse(ptr, this);
+    group_depth_--;
+    depth_++;
+    if (PROTOBUF_PREDICT_FALSE(!ConsumeEndGroup(tag))) return nullptr;
+    return ptr;
+  }
+
+ private:
+  // Out-of-line routine to save space in ParseContext::ParseMessage<T>
+  //   int old;
+  //   ptr = ReadSizeAndPushLimitAndDepth(ptr, &old)
+  // is equivalent to:
+  //   int size = ReadSize(&ptr);
+  //   if (!ptr) return nullptr;
+  //   int old = PushLimit(ptr, size);
+  //   if (--depth_ < 0) return nullptr;
+  PROTOBUF_NODISCARD const char* ReadSizeAndPushLimitAndDepth(const char* ptr,
+                                                              int* old_limit);
+
+  // The context keeps an internal stack to keep track of the recursive
+  // part of the parse state.
+  // Current depth of the active parser, depth counts down.
+  // This is used to limit recursion depth (to prevent overflow on malicious
+  // data), but is also used to index in stack_ to store the current state.
+  int depth_;
+  // Unfortunately necessary for the fringe case of ending on 0 or end-group tag
+  // in the last kSlopBytes of a ZeroCopyInputStream chunk.
+  int group_depth_ = INT_MIN;
+  Data data_;
+};
+
+template <uint32_t tag>
+bool ExpectTag(const char* ptr) {
+  if (tag < 128) {
+    return *ptr == static_cast<char>(tag);
+  } else {
+    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
+    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
+    return std::memcmp(ptr, buf, 2) == 0;
+  }
+}
+
+template <int>
+struct EndianHelper;
+
+template <>
+struct EndianHelper<1> {
+  static uint8_t Load(const void* p) { return *static_cast<const uint8_t*>(p); }
+};
+
+template <>
+struct EndianHelper<2> {
+  static uint16_t Load(const void* p) {
+    uint16_t tmp;
+    std::memcpy(&tmp, p, 2);
+    return little_endian::ToHost(tmp);
+  }
+};
+
+template <>
+struct EndianHelper<4> {
+  static uint32_t Load(const void* p) {
+    uint32_t tmp;
+    std::memcpy(&tmp, p, 4);
+    return little_endian::ToHost(tmp);
+  }
+};
+
+template <>
+struct EndianHelper<8> {
+  static uint64_t Load(const void* p) {
+    uint64_t tmp;
+    std::memcpy(&tmp, p, 8);
+    return little_endian::ToHost(tmp);
+  }
+};
+
+template <typename T>
+T UnalignedLoad(const char* p) {
+  auto tmp = EndianHelper<sizeof(T)>::Load(p);
+  T res;
+  memcpy(&res, &tmp, sizeof(T));
+  return res;
+}
+
+PROTOBUF_EXPORT
+std::pair<const char*, uint32_t> VarintParseSlow32(const char* p, uint32_t res);
+PROTOBUF_EXPORT
+std::pair<const char*, uint64_t> VarintParseSlow64(const char* p, uint32_t res);
+
+inline const char* VarintParseSlow(const char* p, uint32_t res, uint32_t* out) {
+  auto tmp = VarintParseSlow32(p, res);
+  *out = tmp.second;
+  return tmp.first;
+}
+
+inline const char* VarintParseSlow(const char* p, uint32_t res, uint64_t* out) {
+  auto tmp = VarintParseSlow64(p, res);
+  *out = tmp.second;
+  return tmp.first;
+}
+
+template <typename T>
+PROTOBUF_NODISCARD const char* VarintParse(const char* p, T* out) {
+  auto ptr = reinterpret_cast<const uint8_t*>(p);
+  uint32_t res = ptr[0];
+  if (!(res & 0x80)) {
+    *out = res;
+    return p + 1;
+  }
+  uint32_t byte = ptr[1];
+  res += (byte - 1) << 7;
+  if (!(byte & 0x80)) {
+    *out = res;
+    return p + 2;
+  }
+  return VarintParseSlow(p, res, out);
+}
+
+// Used for tags, could read up to 5 bytes which must be available.
+// Caller must ensure its safe to call.
+
+PROTOBUF_EXPORT
+std::pair<const char*, uint32_t> ReadTagFallback(const char* p, uint32_t res);
+
+// Same as ParseVarint but only accept 5 bytes at most.
+inline const char* ReadTag(const char* p, uint32_t* out,
+                           uint32_t /*max_tag*/ = 0) {
+  uint32_t res = static_cast<uint8_t>(p[0]);
+  if (res < 128) {
+    *out = res;
+    return p + 1;
+  }
+  uint32_t second = static_cast<uint8_t>(p[1]);
+  res += (second - 1) << 7;
+  if (second < 128) {
+    *out = res;
+    return p + 2;
+  }
+  auto tmp = ReadTagFallback(p, res);
+  *out = tmp.second;
+  return tmp.first;
+}
+
+// As above, but optimized to consume very few registers while still being fast,
+// ReadTagInlined is useful for callers that don't mind the extra code but would
+// like to avoid an extern function call causing spills into the stack.
+//
+// Two support routines for ReadTagInlined come first...
+template <class T>
+PROTOBUF_NODISCARD PROTOBUF_ALWAYS_INLINE constexpr T RotateLeft(
+    T x, int s) noexcept {
+  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
+         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
+}
+
+PROTOBUF_NODISCARD inline PROTOBUF_ALWAYS_INLINE uint64_t
+RotRight7AndReplaceLowByte(uint64_t res, const char& byte) {
+#if defined(__x86_64__) && defined(__GNUC__)
+  // This will only use one register for `res`.
+  // `byte` comes as a reference to allow the compiler to generate code like:
+  //
+  //   rorq    $7, %rcx
+  //   movb    1(%rax), %cl
+  //
+  // which avoids loading the incoming bytes into a separate register first.
+  asm("ror $7,%0\n\t"
+      "movb %1,%b0"
+      : "+r"(res)
+      : "m"(byte));
+#else
+  res = RotateLeft(res, -7);
+  res = res & ~0xFF;
+  res |= 0xFF & byte;
+#endif
+  return res;
+};
+
+inline PROTOBUF_ALWAYS_INLINE
+const char* ReadTagInlined(const char* ptr, uint32_t* out) {
+  uint64_t res = 0xFF & ptr[0];
+  if (PROTOBUF_PREDICT_FALSE(res >= 128)) {
+    res = RotRight7AndReplaceLowByte(res, ptr[1]);
+    if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
+      res = RotRight7AndReplaceLowByte(res, ptr[2]);
+      if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
+        res = RotRight7AndReplaceLowByte(res, ptr[3]);
+        if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
+          // Note: this wouldn't work if res were 32-bit,
+          // because then replacing the low byte would overwrite
+          // the bottom 4 bits of the result.
+          res = RotRight7AndReplaceLowByte(res, ptr[4]);
+          if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
+            // The proto format does not permit longer than 5-byte encodings for
+            // tags.
+            *out = 0;
+            return nullptr;
+          }
+          *out = static_cast<uint32_t>(RotateLeft(res, 28));
+#if defined(__GNUC__)
+          // Note: this asm statement prevents the compiler from
+          // trying to share the "return ptr + constant" among all
+          // branches.
+          asm("" : "+r"(ptr));
+#endif
+          return ptr + 5;
+        }
+        *out = static_cast<uint32_t>(RotateLeft(res, 21));
+        return ptr + 4;
+      }
+      *out = static_cast<uint32_t>(RotateLeft(res, 14));
+      return ptr + 3;
+    }
+    *out = static_cast<uint32_t>(RotateLeft(res, 7));
+    return ptr + 2;
+  }
+  *out = static_cast<uint32_t>(res);
+  return ptr + 1;
+}
+
+// Decode 2 consecutive bytes of a varint and returns the value, shifted left
+// by 1. It simultaneous updates *ptr to *ptr + 1 or *ptr + 2 depending if the
+// first byte's continuation bit is set.
+// If bit 15 of return value is set (equivalent to the continuation bits of both
+// bytes being set) the varint continues, otherwise the parse is done. On x86
+// movsx eax, dil
+// and edi, eax
+// add eax, edi
+// adc [rsi], 1
+inline uint32_t DecodeTwoBytes(const char** ptr) {
+  uint32_t value = UnalignedLoad<uint16_t>(*ptr);
+  // Sign extend the low byte continuation bit
+  uint32_t x = static_cast<int8_t>(value);
+  value &= x;  // Mask out the high byte iff no continuation
+  // This add is an amazing operation, it cancels the low byte continuation bit
+  // from y transferring it to the carry. Simultaneously it also shifts the 7
+  // LSB left by one tightly against high byte varint bits. Hence value now
+  // contains the unpacked value shifted left by 1.
+  value += x;
+  // Use the carry to update the ptr appropriately.
+  *ptr += value < x ? 2 : 1;
+  return value;
+}
+
+// More efficient varint parsing for big varints
+inline const char* ParseBigVarint(const char* p, uint64_t* out) {
+  auto pnew = p;
+  auto tmp = DecodeTwoBytes(&pnew);
+  uint64_t res = tmp >> 1;
+  if (PROTOBUF_PREDICT_TRUE(static_cast<std::int16_t>(tmp) >= 0)) {
+    *out = res;
+    return pnew;
+  }
+  for (std::uint32_t i = 1; i < 5; i++) {
+    pnew = p + 2 * i;
+    tmp = DecodeTwoBytes(&pnew);
+    res += (static_cast<std::uint64_t>(tmp) - 2) << (14 * i - 1);
+    if (PROTOBUF_PREDICT_TRUE(static_cast<std::int16_t>(tmp) >= 0)) {
+      *out = res;
+      return pnew;
+    }
+  }
+  return nullptr;
+}
+
+PROTOBUF_EXPORT
+std::pair<const char*, int32_t> ReadSizeFallback(const char* p, uint32_t first);
+// Used for tags, could read up to 5 bytes which must be available. Additionally
+// it makes sure the unsigned value fits a int32_t, otherwise returns nullptr.
+// Caller must ensure its safe to call.
+inline uint32_t ReadSize(const char** pp) {
+  auto p = *pp;
+  uint32_t res = static_cast<uint8_t>(p[0]);
+  if (res < 128) {
+    *pp = p + 1;
+    return res;
+  }
+  auto x = ReadSizeFallback(p, res);
+  *pp = x.first;
+  return x.second;
+}
+
+// Some convenience functions to simplify the generated parse loop code.
+// Returning the value and updating the buffer pointer allows for nicer
+// function composition. We rely on the compiler to inline this.
+// Also in debug compiles having local scoped variables tend to generated
+// stack frames that scale as O(num fields).
+inline uint64_t ReadVarint64(const char** p) {
+  uint64_t tmp;
+  *p = VarintParse(*p, &tmp);
+  return tmp;
+}
+
+inline uint32_t ReadVarint32(const char** p) {
+  uint32_t tmp;
+  *p = VarintParse(*p, &tmp);
+  return tmp;
+}
+
+inline int64_t ReadVarintZigZag64(const char** p) {
+  uint64_t tmp;
+  *p = VarintParse(*p, &tmp);
+  return WireFormatLite::ZigZagDecode64(tmp);
+}
+
+inline int32_t ReadVarintZigZag32(const char** p) {
+  uint64_t tmp;
+  *p = VarintParse(*p, &tmp);
+  return WireFormatLite::ZigZagDecode32(static_cast<uint32_t>(tmp));
+}
+
+template <typename T, typename std::enable_if<
+                          !std::is_base_of<MessageLite, T>::value, bool>::type>
+PROTOBUF_NODISCARD const char* ParseContext::ParseMessage(T* msg,
+                                                          const char* ptr) {
+  int old;
+  ptr = ReadSizeAndPushLimitAndDepth(ptr, &old);
+  ptr = ptr ? msg->_InternalParse(ptr, this) : nullptr;
+  depth_++;
+  if (!PopLimit(old)) return nullptr;
+  return ptr;
+}
+
+template <typename Tag, typename T>
+const char* EpsCopyInputStream::ReadRepeatedFixed(const char* ptr,
+                                                  Tag expected_tag,
+                                                  RepeatedField<T>* out) {
+  do {
+    out->Add(UnalignedLoad<T>(ptr));
+    ptr += sizeof(T);
+    if (PROTOBUF_PREDICT_FALSE(ptr >= limit_end_)) return ptr;
+  } while (UnalignedLoad<Tag>(ptr) == expected_tag && (ptr += sizeof(Tag)));
+  return ptr;
+}
+
+// Add any of the following lines to debug which parse function is failing.
+
+#define GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, ret) \
+  if (!(predicate)) {                                  \
+    /*  ::raise(SIGINT);  */                           \
+    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
+    return ret;                                        \
+  }
+
+#define GOOGLE_PROTOBUF_PARSER_ASSERT(predicate) \
+  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
+
+template <typename T>
+const char* EpsCopyInputStream::ReadPackedFixed(const char* ptr, int size,
+                                                RepeatedField<T>* out) {
+  GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+  int nbytes = buffer_end_ + kSlopBytes - ptr;
+  while (size > nbytes) {
+    int num = nbytes / sizeof(T);
+    int old_entries = out->size();
+    out->Reserve(old_entries + num);
+    int block_size = num * sizeof(T);
+    auto dst = out->AddNAlreadyReserved(num);
+#ifdef PROTOBUF_LITTLE_ENDIAN
+    std::memcpy(dst, ptr, block_size);
+#else
+    for (int i = 0; i < num; i++)
+      dst[i] = UnalignedLoad<T>(ptr + i * sizeof(T));
+#endif
+    size -= block_size;
+    if (limit_ <= kSlopBytes) return nullptr;
+    ptr = Next();
+    if (ptr == nullptr) return nullptr;
+    ptr += kSlopBytes - (nbytes - block_size);
+    nbytes = buffer_end_ + kSlopBytes - ptr;
+  }
+  int num = size / sizeof(T);
+  int old_entries = out->size();
+  out->Reserve(old_entries + num);
+  int block_size = num * sizeof(T);
+  auto dst = out->AddNAlreadyReserved(num);
+#ifdef PROTOBUF_LITTLE_ENDIAN
+  std::memcpy(dst, ptr, block_size);
+#else
+  for (int i = 0; i < num; i++) dst[i] = UnalignedLoad<T>(ptr + i * sizeof(T));
+#endif
+  ptr += block_size;
+  if (size != block_size) return nullptr;
+  return ptr;
+}
+
+template <typename Add>
+const char* ReadPackedVarintArray(const char* ptr, const char* end, Add add) {
+  while (ptr < end) {
+    uint64_t varint;
+    ptr = VarintParse(ptr, &varint);
+    if (ptr == nullptr) return nullptr;
+    add(varint);
+  }
+  return ptr;
+}
+
+template <typename Add>
+const char* EpsCopyInputStream::ReadPackedVarint(const char* ptr, Add add) {
+  int size = ReadSize(&ptr);
+  GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+  int chunk_size = buffer_end_ - ptr;
+  while (size > chunk_size) {
+    ptr = ReadPackedVarintArray(ptr, buffer_end_, add);
+    if (ptr == nullptr) return nullptr;
+    int overrun = ptr - buffer_end_;
+    GOOGLE_DCHECK(overrun >= 0 && overrun <= kSlopBytes);
+    if (size - chunk_size <= kSlopBytes) {
+      // The current buffer contains all the information needed, we don't need
+      // to flip buffers. However we must parse from a buffer with enough space
+      // so we are not prone to a buffer overflow.
+      char buf[kSlopBytes + 10] = {};
+      std::memcpy(buf, buffer_end_, kSlopBytes);
+      GOOGLE_CHECK_LE(size - chunk_size, kSlopBytes);
+      auto end = buf + (size - chunk_size);
+      auto res = ReadPackedVarintArray(buf + overrun, end, add);
+      if (res == nullptr || res != end) return nullptr;
+      return buffer_end_ + (res - buf);
+    }
+    size -= overrun + chunk_size;
+    GOOGLE_DCHECK_GT(size, 0);
+    // We must flip buffers
+    if (limit_ <= kSlopBytes) return nullptr;
+    ptr = Next();
+    if (ptr == nullptr) return nullptr;
+    ptr += overrun;
+    chunk_size = buffer_end_ - ptr;
+  }
+  auto end = ptr + size;
+  ptr = ReadPackedVarintArray(ptr, end, add);
+  return end == ptr ? ptr : nullptr;
+}
+
+// Helper for verification of utf8
+PROTOBUF_EXPORT
+bool VerifyUTF8(StringPiece s, const char* field_name);
+
+inline bool VerifyUTF8(const std::string* s, const char* field_name) {
+  return VerifyUTF8(*s, field_name);
+}
+
+// All the string parsers with or without UTF checking and for all CTypes.
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* InlineGreedyStringParser(
+    std::string* s, const char* ptr, ParseContext* ctx);
+
+
+template <typename T>
+PROTOBUF_NODISCARD const char* FieldParser(uint64_t tag, T& field_parser,
+                                           const char* ptr, ParseContext* ctx) {
+  uint32_t number = tag >> 3;
+  GOOGLE_PROTOBUF_PARSER_ASSERT(number != 0);
+  using WireType = internal::WireFormatLite::WireType;
+  switch (tag & 7) {
+    case WireType::WIRETYPE_VARINT: {
+      uint64_t value;
+      ptr = VarintParse(ptr, &value);
+      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+      field_parser.AddVarint(number, value);
+      break;
+    }
+    case WireType::WIRETYPE_FIXED64: {
+      uint64_t value = UnalignedLoad<uint64_t>(ptr);
+      ptr += 8;
+      field_parser.AddFixed64(number, value);
+      break;
+    }
+    case WireType::WIRETYPE_LENGTH_DELIMITED: {
+      ptr = field_parser.ParseLengthDelimited(number, ptr, ctx);
+      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+      break;
+    }
+    case WireType::WIRETYPE_START_GROUP: {
+      ptr = field_parser.ParseGroup(number, ptr, ctx);
+      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+      break;
+    }
+    case WireType::WIRETYPE_END_GROUP: {
+      GOOGLE_LOG(FATAL) << "Can't happen";
+      break;
+    }
+    case WireType::WIRETYPE_FIXED32: {
+      uint32_t value = UnalignedLoad<uint32_t>(ptr);
+      ptr += 4;
+      field_parser.AddFixed32(number, value);
+      break;
+    }
+    default:
+      return nullptr;
+  }
+  return ptr;
+}
+
+template <typename T>
+PROTOBUF_NODISCARD const char* WireFormatParser(T& field_parser,
+                                                const char* ptr,
+                                                ParseContext* ctx) {
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ReadTag(ptr, &tag);
+    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+    if (tag == 0 || (tag & 7) == 4) {
+      ctx->SetLastTag(tag);
+      return ptr;
+    }
+    ptr = FieldParser(tag, field_parser, ptr, ctx);
+    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+  }
+  return ptr;
+}
+
+// The packed parsers parse repeated numeric primitives directly into  the
+// corresponding field
+
+// These are packed varints
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedInt32Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedUInt32Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedInt64Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedUInt64Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSInt32Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSInt64Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedEnumParser(
+    void* object, const char* ptr, ParseContext* ctx);
+
+template <typename T>
+PROTOBUF_NODISCARD const char* PackedEnumParser(void* object, const char* ptr,
+                                                ParseContext* ctx,
+                                                bool (*is_valid)(int),
+                                                InternalMetadata* metadata,
+                                                int field_num) {
+  return ctx->ReadPackedVarint(
+      ptr, [object, is_valid, metadata, field_num](uint64_t val) {
+        if (is_valid(val)) {
+          static_cast<RepeatedField<int>*>(object)->Add(val);
+        } else {
+          WriteVarint(field_num, val, metadata->mutable_unknown_fields<T>());
+        }
+      });
+}
+
+template <typename T>
+PROTOBUF_NODISCARD const char* PackedEnumParserArg(
+    void* object, const char* ptr, ParseContext* ctx,
+    bool (*is_valid)(const void*, int), const void* data,
+    InternalMetadata* metadata, int field_num) {
+  return ctx->ReadPackedVarint(
+      ptr, [object, is_valid, data, metadata, field_num](uint64_t val) {
+        if (is_valid(data, val)) {
+          static_cast<RepeatedField<int>*>(object)->Add(val);
+        } else {
+          WriteVarint(field_num, val, metadata->mutable_unknown_fields<T>());
+        }
+      });
+}
+
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedBoolParser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFixed32Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSFixed32Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFixed64Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSFixed64Parser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFloatParser(
+    void* object, const char* ptr, ParseContext* ctx);
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedDoubleParser(
+    void* object, const char* ptr, ParseContext* ctx);
+
+// This is the only recursive parser.
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* UnknownGroupLiteParse(
+    std::string* unknown, const char* ptr, ParseContext* ctx);
+// This is a helper to for the UnknownGroupLiteParse but is actually also
+// useful in the generated code. It uses overload on std::string* vs
+// UnknownFieldSet* to make the generated code isomorphic between full and lite.
+PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* UnknownFieldParse(
+    uint32_t tag, std::string* unknown, const char* ptr, ParseContext* ctx);
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_PARSE_CONTEXT_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/port.h b/CAPI/cpp/grpc/include/google/protobuf/port.h
new file mode 100644
index 0000000..a5c060b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/port.h
@@ -0,0 +1,80 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A common header that is included across all protobuf headers.  We do our best
+// to avoid #defining any macros here; instead we generally put macros in
+// port_def.inc and port_undef.inc so they are not visible from outside of
+// protobuf.
+
+#ifndef GOOGLE_PROTOBUF_PORT_H__
+#define GOOGLE_PROTOBUF_PORT_H__
+
+#include <cstddef>
+#include <new>
+
+
+namespace google {
+namespace protobuf {
+namespace internal {
+inline void SizedDelete(void* p, size_t size) {
+#if defined(__cpp_sized_deallocation)
+  ::operator delete(p, size);
+#else
+  ::operator delete(p);
+#endif
+}
+inline void SizedArrayDelete(void* p, size_t size) {
+#if defined(__cpp_sized_deallocation)
+  ::operator delete[](p, size);
+#else
+  ::operator delete[](p);
+#endif
+}
+
+// Tag type used to invoke the constinit constructor overload of classes
+// such as ArenaStringPtr and MapFieldBase. Such constructors are internal
+// implementation details of the library.
+struct ConstantInitialized {
+  explicit ConstantInitialized() = default;
+};
+
+// Tag type used to invoke the arena constructor overload of classes such
+// as ExtensionSet and MapFieldLite in aggregate initialization. These
+// classes typically don't have move/copy constructors, which rules out
+// explicit initialization in pre-C++17.
+struct ArenaInitialized {
+  explicit ArenaInitialized() = default;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_PORT_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/port_def.inc b/CAPI/cpp/grpc/include/google/protobuf/port_def.inc
new file mode 100644
index 0000000..8943a44
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/port_def.inc
@@ -0,0 +1,928 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines common macros that are used in protobuf.
+//
+// To hide these definitions from the outside world (and to prevent collisions
+// if more than one version of protobuf is #included in the same project) you
+// must follow this pattern when #including port_def.inc in a header file:
+//
+// #include "other_header.h"
+// #include "message.h"
+// // etc.
+//
+// #include "port_def.inc"  // MUST be last header included
+//
+// // Definitions for this header.
+//
+// #include "port_undef.inc"
+//
+// This is a textual header with no include guard, because we want to
+// detect/prohibit anytime it is #included twice without a corresponding
+// #undef.
+
+// The definitions in this file are intended to be portable across Clang,
+// GCC, and MSVC. Function-like macros are usable without an #ifdef guard.
+// Syntax macros (for example, attributes) are always defined, although
+// they may be empty.
+//
+// Some definitions rely on the NDEBUG macro and/or (in MSVC) _DEBUG:
+// - https://en.cppreference.com/w/c/error/assert
+// - https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros#microsoft-specific-predefined-macros
+//
+// References for predefined macros:
+// - Standard: https://en.cppreference.com/w/cpp/preprocessor/replace
+// - Clang: https://clang.llvm.org/docs/LanguageExtensions.html
+//          (see also GCC predefined macros)
+// - GCC: https://gcc.gnu.org/onlinedocs/cpp/Predefined-Macros.html
+// - MSVC: https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
+// - Interactive (Clang/GCC only): https://www.compiler-explorer.com/z/hc6jKd3sj
+//
+// References for attributes (and extension attributes):
+// - Standard: https://en.cppreference.com/w/cpp/language/attributes
+// - Clang: https://clang.llvm.org/docs/AttributeReference.html
+// - GCC: https://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html
+//        (see Clang attribute docs as well)
+//
+// References for standard C++ language conformance (and minimum versions):
+// - Clang: https://clang.llvm.org/cxx_status.html
+// - GCC: https://gcc.gnu.org/projects/cxx-status.html
+// - MSVC: https://docs.microsoft.com/en-us/cpp/overview/visual-cpp-language-conformance
+//
+// Historical release notes (which can help to determine minimum versions):
+// - Clang: https://releases.llvm.org/
+// - GCC: https://gcc.gnu.org/releases.html
+// - MSVC: https://docs.microsoft.com/en-us/visualstudio/releases/2019/release-notes-history
+//         https://docs.microsoft.com/en-us/visualstudio/releasenotes/vs2017-relnotes-history
+
+// Portable fallbacks for C++20 feature test macros:
+// https://en.cppreference.com/w/cpp/feature_test
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(x) 0
+#define PROTOBUF_has_cpp_attribute_DEFINED_
+#endif
+
+// Portable fallback for Clang's __has_feature macro:
+// https://clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension
+#ifndef __has_feature
+#define __has_feature(x) 0
+#define PROTOBUF_has_feature_DEFINED_
+#endif
+
+// Portable fallback for Clang's __has_warning macro:
+#ifndef __has_warning
+#define __has_warning(x) 0
+#define PROTOBUF_has_warning_DEFINED_
+#endif
+
+// Portable fallbacks for the __has_attribute macro (GCC and Clang):
+// https://clang.llvm.org/docs/LanguageExtensions.html#has-attribute
+// https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005fattribute.html
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#define PROTOBUF_has_attribute_DEFINED_
+#endif
+
+// Portable fallback for __has_builtin (GCC and Clang):
+// https://clang.llvm.org/docs/LanguageExtensions.html#has-builtin
+// https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005fbuiltin.html
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#define PROTOBUF_has_builtin_DEFINED_
+#endif
+
+// Portable PROTOBUF_BUILTIN_BSWAPxx definitions
+// Code must check for availability, e.g.: `defined(PROTOBUF_BUILTIN_BSWAP32)`
+#ifdef PROTOBUF_BUILTIN_BSWAP16
+#error PROTOBUF_BUILTIN_BSWAP16 was previously defined
+#endif
+#ifdef PROTOBUF_BUILTIN_BSWAP32
+#error PROTOBUF_BUILTIN_BSWAP32 was previously defined
+#endif
+#ifdef PROTOBUF_BUILTIN_BSWAP64
+#error PROTOBUF_BUILTIN_BSWAP64 was previously defined
+#endif
+#if defined(__GNUC__) || __has_builtin(__builtin_bswap16)
+#define PROTOBUF_BUILTIN_BSWAP16(x) __builtin_bswap16(x)
+#endif
+#if defined(__GNUC__) || __has_builtin(__builtin_bswap32)
+#define PROTOBUF_BUILTIN_BSWAP32(x) __builtin_bswap32(x)
+#endif
+#if defined(__GNUC__) || __has_builtin(__builtin_bswap64)
+#define PROTOBUF_BUILTIN_BSWAP64(x) __builtin_bswap64(x)
+#endif
+
+// Portable check for GCC minimum version:
+// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) \
+    && defined(__GNUC_PATCHLEVEL__)
+#  define PROTOBUF_GNUC_MIN(x, y) \
+  (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
+#else
+#  define PROTOBUF_GNUC_MIN(x, y) 0
+#endif
+
+// Portable check for MSVC minimum version:
+// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
+#if defined(_MSC_VER)
+#define PROTOBUF_MSC_VER_MIN(x) (_MSC_VER >= x)
+#else
+#define PROTOBUF_MSC_VER_MIN(x) 0
+#endif
+
+// Portable check for minimum C++ language version:
+// https://en.cppreference.com/w/cpp/preprocessor/replace
+// https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
+#if !defined(_MSVC_LANG)
+#define PROTOBUF_CPLUSPLUS_MIN(x) (__cplusplus >= x)
+#else
+#define PROTOBUF_CPLUSPLUS_MIN(x) (_MSVC_LANG >= x)
+#endif
+
+// Future versions of protobuf will include breaking changes to some APIs.
+// This macro can be set to enable these API changes ahead of time, so that
+// user code can be updated before upgrading versions of protobuf.
+// PROTOBUF_FUTURE_FINAL is used on classes that are historically not marked as
+// final, but that may be marked final in future (breaking) releases.
+// #define PROTOBUF_FUTURE_BREAKING_CHANGES 1
+// #define PROTOBUF_FUTURE_FINAL final
+#define PROTOBUF_FUTURE_FINAL
+
+#ifdef PROTOBUF_VERSION
+#error PROTOBUF_VERSION was previously defined
+#endif
+#define PROTOBUF_VERSION 3021006
+
+#ifdef PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC
+#error PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC was previously defined
+#endif
+#define PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC 3021000
+
+#ifdef PROTOBUF_MIN_PROTOC_VERSION
+#error PROTOBUF_MIN_PROTOC_VERSION was previously defined
+#endif
+#define PROTOBUF_MIN_PROTOC_VERSION 3021000
+
+#ifdef PROTOBUF_VERSION_SUFFIX
+#error PROTOBUF_VERSION_SUFFIX was previously defined
+#endif
+#define PROTOBUF_VERSION_SUFFIX ""
+
+#if defined(PROTOBUF_NAMESPACE) || defined(PROTOBUF_NAMESPACE_ID)
+#error PROTOBUF_NAMESPACE or PROTOBUF_NAMESPACE_ID was previously defined
+#endif
+#define PROTOBUF_NAMESPACE "google::protobuf"
+#define PROTOBUF_NAMESPACE_ID google::protobuf
+#define PROTOBUF_NAMESPACE_OPEN \
+  namespace google {            \
+  namespace protobuf {
+#define PROTOBUF_NAMESPACE_CLOSE \
+  } /* namespace protobuf */     \
+  } /* namespace google */
+
+#ifdef PROTOBUF_ALWAYS_INLINE
+#error PROTOBUF_ALWAYS_INLINE was previously defined
+#endif
+// For functions we want to force inline.
+#if defined(PROTOBUF_NO_INLINE)
+# define PROTOBUF_ALWAYS_INLINE
+#elif PROTOBUF_GNUC_MIN(3, 1)
+# define PROTOBUF_ALWAYS_INLINE __attribute__((always_inline))
+#elif defined(_MSC_VER)
+# define PROTOBUF_ALWAYS_INLINE __forceinline
+#else
+# define PROTOBUF_ALWAYS_INLINE
+#endif
+
+#ifdef PROTOBUF_NDEBUG_INLINE
+#error PROTOBUF_NDEBUG_INLINE was previously defined
+#endif
+// Avoid excessive inlining in non-optimized builds. Without other optimizations
+// the inlining is not going to provide benefits anyway and the huge resulting
+// functions, especially in the proto-generated serialization functions, produce
+// stack frames so large that many tests run into stack overflows (b/32192897).
+#if defined(NDEBUG) || (defined(_MSC_VER) && !defined(_DEBUG))
+# define PROTOBUF_NDEBUG_INLINE PROTOBUF_ALWAYS_INLINE
+#else
+# define PROTOBUF_NDEBUG_INLINE
+#endif
+
+// Note that PROTOBUF_NOINLINE is an attribute applied to functions, to prevent
+// them from being inlined by the compiler. This is different from
+// PROTOBUF_NO_INLINE, which is a user-supplied macro that disables forced
+// inlining by PROTOBUF_(ALWAYS|NDEBUG)_INLINE.
+#ifdef PROTOBUF_NOINLINE
+#error PROTOBUF_NOINLINE was previously defined
+#endif
+#if PROTOBUF_GNUC_MIN(3, 1)
+# define PROTOBUF_NOINLINE __attribute__((noinline))
+#elif defined(_MSC_VER)
+// Seems to have been around since at least Visual Studio 2005
+# define PROTOBUF_NOINLINE __declspec(noinline)
+#endif
+
+#ifdef PROTOBUF_MUSTTAIL
+#error PROTOBUF_MUSTTAIL was previously defined
+#endif
+#ifdef PROTOBUF_TAILCALL
+#error PROTOBUF_TAILCALL was previously defined
+#endif
+#if __has_cpp_attribute(clang::musttail) && !defined(__arm__) && \
+    !defined(_ARCH_PPC) && !defined(__wasm__) &&                 \
+    !(defined(_MSC_VER) && defined(_M_IX86)) &&                  \
+    !(defined(__NDK_MAJOR__) && __NDK_MAJOR <= 24)
+#  ifndef PROTO2_OPENSOURCE
+// Compilation fails on ARM32: b/195943306
+// Compilation fails on powerpc64le: b/187985113
+// Compilation fails on X86 Windows:
+// https://github.com/llvm/llvm-project/issues/53271
+#  endif
+#define PROTOBUF_MUSTTAIL [[clang::musttail]]
+#define PROTOBUF_TAILCALL true
+#else
+#define PROTOBUF_MUSTTAIL
+#define PROTOBUF_TAILCALL false
+#endif
+
+#ifdef PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED
+#error PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED was previously defined
+#endif
+#if __has_attribute(exclusive_locks_required)
+#define PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED(...) \
+  __attribute__((exclusive_locks_required(__VA_ARGS__)))
+#else
+#define PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED(...)
+#endif
+
+#ifdef PROTOBUF_NO_THREAD_SAFETY_ANALYSIS
+#error PROTOBUF_NO_THREAD_SAFETY_ANALYSIS was previously defined
+#endif
+#if __has_attribute(no_thread_safety_analysis)
+#define PROTOBUF_NO_THREAD_SAFETY_ANALYSIS \
+  __attribute__((no_thread_safety_analysis))
+#else
+#define PROTOBUF_NO_THREAD_SAFETY_ANALYSIS
+#endif
+
+#ifdef PROTOBUF_GUARDED_BY
+#error PROTOBUF_GUARDED_BY was previously defined
+#endif
+#if __has_attribute(guarded_by)
+#define PROTOBUF_GUARDED_BY(x) __attribute__((guarded_by(x)))
+#else
+#define PROTOBUF_GUARDED_BY(x)
+#endif
+
+#ifdef PROTOBUF_LOCKS_EXCLUDED
+#error PROTOBUF_LOCKS_EXCLUDED was previously defined
+#endif
+#if __has_attribute(locks_excluded)
+#define PROTOBUF_LOCKS_EXCLUDED(...) \
+  __attribute__((locks_excluded(__VA_ARGS__)))
+#else
+#define PROTOBUF_LOCKS_EXCLUDED(...)
+#endif
+
+#ifdef PROTOBUF_COLD
+#error PROTOBUF_COLD was previously defined
+#endif
+#if __has_attribute(cold) || PROTOBUF_GNUC_MIN(4, 3)
+# define PROTOBUF_COLD __attribute__((cold))
+#else
+# define PROTOBUF_COLD
+#endif
+
+#ifdef PROTOBUF_SECTION_VARIABLE
+#error PROTOBUF_SECTION_VARIABLE was previously defined
+#endif
+#if (__has_attribute(section) || defined(__GNUC__)) && defined(__ELF__)
+// Place a variable in the given ELF section.
+# define PROTOBUF_SECTION_VARIABLE(x) __attribute__((section(#x)))
+#else
+# define PROTOBUF_SECTION_VARIABLE(x)
+#endif
+
+#if defined(PROTOBUF_DEPRECATED)
+#error PROTOBUF_DEPRECATED was previously defined
+#endif
+#if defined(PROTOBUF_DEPRECATED_MSG)
+#error PROTOBUF_DEPRECATED_MSG was previously defined
+#endif
+#if __has_attribute(deprecated) || PROTOBUF_GNUC_MIN(3, 0)
+# define PROTOBUF_DEPRECATED __attribute__((deprecated))
+# define PROTOBUF_DEPRECATED_MSG(msg) __attribute__((deprecated(msg)))
+#elif defined(_MSC_VER)
+# define PROTOBUF_DEPRECATED __declspec(deprecated)
+# define PROTOBUF_DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+# define PROTOBUF_DEPRECATED
+# define PROTOBUF_DEPRECATED_MSG(msg)
+#endif
+
+#if defined(PROTOBUF_DEPRECATED_ENUM)
+#error PROTOBUF_DEPRECATED_ENUM was previously defined
+#endif
+#if defined(__clang__) || PROTOBUF_GNUC_MIN(6, 0)
+// https://gcc.gnu.org/gcc-6/changes.html
+# define PROTOBUF_DEPRECATED_ENUM __attribute__((deprecated))
+#else
+# define PROTOBUF_DEPRECATED_ENUM
+#endif
+
+#ifdef PROTOBUF_FUNC_ALIGN
+#error PROTOBUF_FUNC_ALIGN was previously defined
+#endif
+#if __has_attribute(aligned) || PROTOBUF_GNUC_MIN(4, 3)
+#define PROTOBUF_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))
+#else
+#define PROTOBUF_FUNC_ALIGN(bytes)
+#endif
+
+#ifdef PROTOBUF_RETURNS_NONNULL
+#error PROTOBUF_RETURNS_NONNULL was previously defined
+#endif
+#if __has_attribute(returns_nonnull) || PROTOBUF_GNUC_MIN(4, 9)
+#define PROTOBUF_RETURNS_NONNULL __attribute__((returns_nonnull))
+#else
+#define PROTOBUF_RETURNS_NONNULL
+#endif
+
+#ifdef PROTOBUF_ATTRIBUTE_REINITIALIZES
+#error PROTOBUF_ATTRIBUTE_REINITIALIZES was previously defined
+#endif
+#if __has_cpp_attribute(clang::reinitializes)
+#define PROTOBUF_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
+#else
+#define PROTOBUF_ATTRIBUTE_REINITIALIZES
+#endif
+
+// The minimum library version which works with the current version of the
+// headers.
+#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3021000
+
+#ifdef PROTOBUF_RTTI
+#error PROTOBUF_RTTI was previously defined
+#endif
+#if defined(GOOGLE_PROTOBUF_NO_RTTI) && GOOGLE_PROTOBUF_NO_RTTI
+// A user-provided definition GOOGLE_PROTOBUF_NO_RTTI=1 disables RTTI.
+#define PROTOBUF_RTTI 0
+#elif defined(__cpp_rtti)
+// https://en.cppreference.com/w/cpp/feature_test
+#define PROTOBUF_RTTI 1
+#elif __has_feature(cxx_rtti)
+// https://clang.llvm.org/docs/LanguageExtensions.html#c-rtti
+#define PROTOBUF_RTTI 1
+#elif defined(__GXX_RTTI)
+// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+#define PROTOBUF_RTTI 1
+#elif defined(_CPPRTTI)
+// https://docs.microsoft.com/en-us/cpp/build/reference/gr-enable-run-time-type-information
+#define PROTOBUF_RTTI 1
+#else
+#define PROTOBUF_RTTI 0
+#endif
+
+// Returns the offset of the given field within the given aggregate type.
+// This is equivalent to the ANSI C offsetof() macro.  However, according
+// to the C++ standard, offsetof() only works on POD types, and GCC
+// enforces this requirement with a warning.  In practice, this rule is
+// unnecessarily strict; there is probably no compiler or platform on
+// which the offsets of the direct fields of a class are non-constant.
+// Fields inherited from superclasses *can* have non-constant offsets,
+// but that's not what this macro will be used for.
+#ifdef PROTOBUF_FIELD_OFFSET
+#error PROTOBUF_FIELD_OFFSET was previously defined
+#endif
+#if defined(__clang__)
+// For Clang we use __builtin_offsetof() and suppress the warning,
+// to avoid Control Flow Integrity and UBSan vptr sanitizers from
+// crashing while trying to validate the invalid reinterpret_casts.
+#define PROTOBUF_FIELD_OFFSET(TYPE, FIELD)                   \
+  _Pragma("clang diagnostic push")                           \
+  _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \
+  __builtin_offsetof(TYPE, FIELD)                            \
+  _Pragma("clang diagnostic pop")
+#elif PROTOBUF_GNUC_MIN(4, 8)
+#define PROTOBUF_FIELD_OFFSET(TYPE, FIELD) __builtin_offsetof(TYPE, FIELD)
+#else  // defined(__clang__)
+// Note that we calculate relative to the pointer value 16 here since if we
+// just use zero, GCC complains about dereferencing a NULL pointer.  We
+// choose 16 rather than some other number just in case the compiler would
+// be confused by an unaligned pointer.
+#define PROTOBUF_FIELD_OFFSET(TYPE, FIELD)                                \
+  static_cast< ::uint32_t>(reinterpret_cast<const char*>(                   \
+                             &reinterpret_cast<const TYPE*>(16)->FIELD) - \
+                         reinterpret_cast<const char*>(16))
+#endif
+
+#ifdef PROTOBUF_EXPORT
+#error PROTOBUF_EXPORT was previously defined
+#endif
+
+#if defined(PROTOBUF_USE_DLLS) && defined(_MSC_VER)
+# if defined(LIBPROTOBUF_EXPORTS)
+#  define PROTOBUF_EXPORT __declspec(dllexport)
+#  define PROTOBUF_EXPORT_TEMPLATE_DECLARE
+#  define PROTOBUF_EXPORT_TEMPLATE_DEFINE __declspec(dllexport)
+# else
+#  define PROTOBUF_EXPORT __declspec(dllimport)
+#  define PROTOBUF_EXPORT_TEMPLATE_DECLARE
+#  define PROTOBUF_EXPORT_TEMPLATE_DEFINE __declspec(dllimport)
+# endif  // defined(LIBPROTOBUF_EXPORTS)
+#elif defined(PROTOBUF_USE_DLLS) && defined(LIBPROTOBUF_EXPORTS)
+# define PROTOBUF_EXPORT __attribute__((visibility("default")))
+# define PROTOBUF_EXPORT_TEMPLATE_DECLARE __attribute__((visibility("default")))
+# define PROTOBUF_EXPORT_TEMPLATE_DEFINE
+#else
+# define PROTOBUF_EXPORT
+# define PROTOBUF_EXPORT_TEMPLATE_DECLARE
+# define PROTOBUF_EXPORT_TEMPLATE_DEFINE
+#endif
+
+#ifdef PROTOC_EXPORT
+#error PROTOC_EXPORT was previously defined
+#endif
+
+#if defined(PROTOBUF_USE_DLLS) && defined(_MSC_VER)
+# if defined(LIBPROTOC_EXPORTS)
+#  define PROTOC_EXPORT __declspec(dllexport)
+# else
+#  define PROTOC_EXPORT __declspec(dllimport)
+# endif  // defined(LIBPROTOC_EXPORTS)
+#elif defined(PROTOBUF_USE_DLLS) && defined(LIBPROTOC_EXPORTS)
+# define PROTOC_EXPORT __attribute__((visibility("default")))
+#else
+# define PROTOC_EXPORT
+#endif
+
+#if defined(PROTOBUF_PREDICT_TRUE) || defined(PROTOBUF_PREDICT_FALSE)
+#error PROTOBUF_PREDICT_(TRUE|FALSE) was previously defined
+#endif
+#if PROTOBUF_GNUC_MIN(3, 0)
+# define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
+# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
+#else
+# define PROTOBUF_PREDICT_TRUE(x) (x)
+# define PROTOBUF_PREDICT_FALSE(x) (x)
+#endif
+
+#ifdef PROTOBUF_NODISCARD
+#error PROTOBUF_NODISCARD was previously defined
+#endif
+#if __has_cpp_attribute(nodiscard) && PROTOBUF_CPLUSPLUS_MIN(201703L)
+#define PROTOBUF_NODISCARD [[nodiscard]]
+#elif __has_attribute(warn_unused_result) || PROTOBUF_GNUC_MIN(4, 8)
+#define PROTOBUF_NODISCARD __attribute__((warn_unused_result))
+#else
+#define PROTOBUF_NODISCARD
+#endif
+
+// Enable all stable experiments if this flag is set.  This allows us to group
+// all of these experiments under a single build flag, which can be enabled in
+// the protobuf.stable-experiments TAP project.
+#ifdef PROTOBUF_ENABLE_STABLE_EXPERIMENTS
+#define PROTOBUF_FORCE_MESSAGE_OWNED_ARENA
+#endif  // !PROTOBUF_ENABLE_STABLE_EXPERIMENTS
+
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+#error PROTOBUF_FORCE_COPY_IN_RELEASE was previously defined
+#endif
+
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+#error PROTOBUF_FORCE_COPY_IN_SWAP was previously defined
+#endif
+
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+#error PROTOBUF_FORCE_COPY_IN_MOVE was previously defined
+#endif
+
+#ifdef PROTOBUF_FORCE_RESET_IN_CLEAR
+#error PROTOBUF_FORCE_RESET_IN_CLEAR was previously defined
+#endif
+
+// Force copy the default string to a string field so that non-optimized builds
+// have harder-to-rely-on address stability.
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+#error PROTOBUF_FORCE_COPY_DEFAULT_STRING was previously defined
+#endif
+
+#ifdef PROTOBUF_FALLTHROUGH_INTENDED
+#error PROTOBUF_FALLTHROUGH_INTENDED was previously defined
+#endif
+#if __has_cpp_attribute(fallthrough)
+#define PROTOBUF_FALLTHROUGH_INTENDED [[fallthrough]]
+#elif __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#define PROTOBUF_FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#elif PROTOBUF_GNUC_MIN(7, 0)
+#define PROTOBUF_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#else
+#define PROTOBUF_FALLTHROUGH_INTENDED
+#endif
+
+// PROTOBUF_ASSUME(pred) tells the compiler that it can assume pred is true. To
+// be safe, we also validate the assumption with a GOOGLE_DCHECK in unoptimized
+// builds. The macro does not do anything useful if the compiler does not
+// support __builtin_assume.
+#ifdef PROTOBUF_ASSUME
+#error PROTOBUF_ASSUME was previously defined
+#endif
+#if __has_builtin(__builtin_assume)
+#define PROTOBUF_ASSUME(pred) \
+  GOOGLE_DCHECK(pred);               \
+  __builtin_assume(pred)
+#else
+#define PROTOBUF_ASSUME(pred) GOOGLE_DCHECK(pred)
+#endif
+
+// Specify memory alignment for structs, classes, etc.
+// Use like:
+//   class PROTOBUF_ALIGNAS(16) MyClass { ... }
+//   PROTOBUF_ALIGNAS(16) int array[4];
+//
+// In most places you can use the C++11 keyword "alignas", which is preferred.
+//
+// But compilers have trouble mixing __attribute__((...)) syntax with
+// alignas(...) syntax.
+//
+// Doesn't work in clang or gcc:
+//   struct alignas(16) __attribute__((packed)) S { char c; };
+// Works in clang but not gcc:
+//   struct __attribute__((packed)) alignas(16) S2 { char c; };
+// Works in clang and gcc:
+//   struct alignas(16) S3 { char c; } __attribute__((packed));
+//
+// There are also some attributes that must be specified *before* a class
+// definition: visibility (used for exporting functions/classes) is one of
+// these attributes. This means that it is not possible to use alignas() with a
+// class that is marked as exported.
+#ifdef PROTOBUF_ALIGNAS
+#error PROTOBUF_ALIGNAS was previously defined
+#endif
+#if defined(_MSC_VER)
+#define PROTOBUF_ALIGNAS(byte_alignment) __declspec(align(byte_alignment))
+#elif PROTOBUF_GNUC_MIN(3, 0)
+#define PROTOBUF_ALIGNAS(byte_alignment) \
+  __attribute__((aligned(byte_alignment)))
+#else
+#define PROTOBUF_ALIGNAS(byte_alignment) alignas(byte_alignment)
+#endif
+
+#ifdef PROTOBUF_FINAL
+#error PROTOBUF_FINAL was previously defined
+#endif
+#define PROTOBUF_FINAL final
+
+#ifdef PROTOBUF_THREAD_LOCAL
+#error PROTOBUF_THREAD_LOCAL was previously defined
+#endif
+#if defined(_MSC_VER)
+#define PROTOBUF_THREAD_LOCAL __declspec(thread)
+#else
+#define PROTOBUF_THREAD_LOCAL __thread
+#endif
+
+// TODO(b/228173843): cleanup PROTOBUF_LITTLE_ENDIAN in various 3p forks.
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
+     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define PROTOBUF_LITTLE_ENDIAN 1
+#ifdef PROTOBUF_BIG_ENDIAN
+#error Conflicting PROTOBUF_BIG_ENDIAN was previously defined
+#endif
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define PROTOBUF_BIG_ENDIAN 1
+#elif defined(_WIN32) || defined(__x86_64__) || defined(__aarch64__)
+#define PROTOBUF_LITTLE_ENDIAN 1
+#else
+#error "endian detection failed for current compiler"
+#endif
+
+// For enabling message owned arena, one major blocker is semantic change from
+// moving to copying when there is ownership transfer (e.g., move ctor, swap,
+// set allocated, release). This change not only causes performance regression
+// but also breaks users code (e.g., dangling reference). For top-level
+// messages, since it owns the arena, we can mitigate the issue by transferring
+// ownership of arena. However, we cannot do that for nested messages. In order
+// to tell how many usages of nested messages affected by message owned arena,
+// we need to simulate the arena ownership.
+// This experiment is purely for the purpose of gathering data. All code guarded
+// by this flag is supposed to be removed after this experiment.
+#define PROTOBUF_MESSAGE_OWNED_ARENA_EXPERIMENT
+#ifdef PROTOBUF_CONSTINIT
+#error PROTOBUF_CONSTINIT was previously defined
+#endif
+#if defined(__cpp_constinit) && !defined(_MSC_VER)
+#define PROTOBUF_CONSTINIT constinit
+#define PROTOBUF_CONSTEXPR constexpr
+// Some older Clang versions incorrectly raise an error about
+// constant-initializing weak default instance pointers. Versions 12.0 and
+// higher seem to work, except that XCode 12.5.1 shows the error even though it
+// uses Clang 12.0.5.
+// Clang-cl on Windows raises error also.
+#elif !defined(_MSC_VER) && __has_cpp_attribute(clang::require_constant_initialization) && \
+    ((defined(__APPLE__) && __clang_major__ >= 13) ||                \
+     (!defined(__APPLE__) && __clang_major__ >= 12))
+#define PROTOBUF_CONSTINIT [[clang::require_constant_initialization]]
+#define PROTOBUF_CONSTEXPR constexpr
+#elif PROTOBUF_GNUC_MIN(12, 2)
+#define PROTOBUF_CONSTINIT __constinit
+#define PROTOBUF_CONSTEXPR constexpr
+// MSVC 17 currently seems to raise an error about constant-initialized pointers.
+#elif defined(_MSC_VER) && _MSC_VER >= 1930
+#define PROTOBUF_CONSTINIT
+#define PROTOBUF_CONSTEXPR constexpr
+#else
+#define PROTOBUF_CONSTINIT
+#define PROTOBUF_CONSTEXPR
+#endif
+
+// Some globals with an empty non-trivial destructor are annotated with
+// no_destroy for performance reasons. It reduces the cost of these globals in
+// non-opt mode and under sanitizers.
+#ifdef PROTOBUF_ATTRIBUTE_NO_DESTROY
+#error PROTOBUF_ATTRIBUTE_NO_DESTROY was previously defined
+#endif
+#if __has_cpp_attribute(clang::no_destroy)
+#define PROTOBUF_ATTRIBUTE_NO_DESTROY [[clang::no_destroy]]
+#else
+#define PROTOBUF_ATTRIBUTE_NO_DESTROY
+#endif
+
+// Force clang to always emit complete debug info for a type.
+// Clang uses constructor homing to determine when to emit debug info for a
+// type. If the constructor of a type is never used, which can happen in some
+// cases where member variables are constructed in place for optimization
+// purposes (see b/208803175 for an example), the type will have incomplete
+// debug info unless this attribute is used.
+#ifdef PROTOBUF_ATTRIBUTE_STANDALONE_DEBUG
+#error PROTOBUF_ATTRIBUTE_STANDALONE_DEBUG was previously defined
+#endif
+#if __has_cpp_attribute(clang::standalone_debug)
+#define PROTOBUF_ATTRIBUTE_STANDALONE_DEBUG [[clang::standalone_debug]]
+#else
+#define PROTOBUF_ATTRIBUTE_STANDALONE_DEBUG
+#endif
+
+// Protobuf extensions and reflection require registration of the protos linked
+// in the binary. Not until everything is registered does the runtime have a
+// complete view on all protos. When code is using reflection or extensions
+// in between registration calls this can lead to surprising behavior. By
+// having the registration run first we mitigate this scenario.
+// Highest priority is 101. We use 102 for registration, to allow code that
+// really wants to higher priority to still beat us. Some initialization happens
+// at higher priority, though, since it is needed before registration.
+#ifdef PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+#error PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 was previously defined
+#endif
+#ifdef PROTOBUF_ATTRIBUTE_INIT_PRIORITY2
+#error PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 was previously defined
+#endif
+#if PROTOBUF_GNUC_MIN(3, 0) && (!defined(__APPLE__) || defined(__clang__)) && \
+    !((defined(sun) || defined(__sun)) &&                                     \
+      (defined(__SVR4) || defined(__svr4__)))
+#define PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 __attribute__((init_priority((101))))
+#define PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 __attribute__((init_priority((102))))
+#else
+#define PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+#define PROTOBUF_ATTRIBUTE_INIT_PRIORITY2
+#endif
+
+#ifdef PROTOBUF_PRAGMA_INIT_SEG
+#error PROTOBUF_PRAGMA_INIT_SEG was previously defined
+#endif
+#ifdef _MSC_VER
+#define PROTOBUF_PRAGMA_INIT_SEG __pragma(init_seg(lib))
+#else
+#define PROTOBUF_PRAGMA_INIT_SEG
+#endif
+
+#ifdef PROTOBUF_ATTRIBUTE_WEAK
+#error PROTOBUF_ATTRIBUTE_WEAK was previously defined
+#endif
+#if __has_attribute(weak) && \
+    !defined(__APPLE__) && \
+    (!defined(_WIN32) || __clang_major__ < 9) && \
+    !defined(__MINGW32__)
+#define PROTOBUF_ATTRIBUTE_WEAK __attribute__((weak))
+#define PROTOBUF_HAVE_ATTRIBUTE_WEAK 1
+#else
+#define PROTOBUF_ATTRIBUTE_WEAK
+#define PROTOBUF_HAVE_ATTRIBUTE_WEAK 0
+#endif
+
+// Macros to detect sanitizers.
+#ifdef PROTOBUF_ASAN
+#error PROTOBUF_ASAN was previously defined
+#endif
+#ifdef PROTOBUF_MSAN
+#error PROTOBUF_MSAN was previously defined
+#endif
+#ifdef PROTOBUF_TSAN
+#error PROTOBUF_TSAN was previously defined
+#endif
+#if defined(__clang__)
+#  if __has_feature(address_sanitizer)
+#    define PROTOBUF_ASAN 1
+#  endif
+#  if __has_feature(thread_sanitizer)
+#    define PROTOBUF_TSAN 1
+#  endif
+#  if __has_feature(memory_sanitizer)
+#    define PROTOBUF_MSAN 1
+#  endif
+#elif PROTOBUF_GNUC_MIN(3, 0)
+// Double-guard is needed for -Wundef:
+#  ifdef __SANITIZE_ADDRESS__
+#  if    __SANITIZE_ADDRESS__
+#    define PROTOBUF_ASAN 1
+#  endif
+#  endif
+#  ifdef __SANITIZE_THREAD__
+#  if    __SANITIZE_THREAD__
+#    define PROTOBUF_TSAN 1
+#  endif
+#  endif
+#endif
+
+// Tail call table-driven parsing can be enabled by defining
+// PROTOBUF_EXPERIMENTAL_USE_TAIL_CALL_TABLE_PARSER at compilation time. Note
+// that this macro is for small-scale testing only, and is not supported.
+#ifdef PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED
+#error PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED was previously declared
+#endif
+#if defined(PROTOBUF_EXPERIMENTAL_USE_TAIL_CALL_TABLE_PARSER)
+#define PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED 1
+#endif
+
+#define PROTOBUF_TC_PARAM_DECL                                 \
+  ::google::protobuf::MessageLite *msg, const char *ptr,                 \
+      ::google::protobuf::internal::ParseContext *ctx,                   \
+      const ::google::protobuf::internal::TcParseTableBase *table,       \
+      uint64_t hasbits, ::google::protobuf::internal::TcFieldData data
+
+#ifdef PROTOBUF_UNUSED
+#error PROTOBUF_UNUSED was previously defined
+#endif
+#if __has_cpp_attribute(maybe_unused) || \
+    (PROTOBUF_MSC_VER_MIN(1911) && PROTOBUF_CPLUSPLUS_MIN(201703L))
+#define PROTOBUF_UNUSED [[maybe_unused]]
+#elif __has_attribute(unused) || PROTOBUF_GNUC_MIN(3, 0)
+#define PROTOBUF_UNUSED __attribute__((__unused__))
+#else
+#define PROTOBUF_UNUSED
+#endif
+
+// ThreadSafeArenaz is turned off completely in opensource builds.
+
+// Windows declares several inconvenient macro names.  We #undef them and then
+// restore them in port_undef.inc.
+#ifdef _MSC_VER
+#pragma push_macro("CREATE_NEW")
+#undef CREATE_NEW
+#pragma push_macro("DELETE")
+#undef DELETE
+#pragma push_macro("DOUBLE_CLICK")
+#undef DOUBLE_CLICK
+#pragma push_macro("ERROR")
+#undef ERROR
+#pragma push_macro("ERROR_BUSY")
+#undef ERROR_BUSY
+#pragma push_macro("ERROR_INSTALL_FAILED")
+#undef ERROR_INSTALL_FAILED
+#pragma push_macro("ERROR_NOT_FOUND")
+#undef ERROR_NOT_FOUND
+#pragma push_macro("GetClassName")
+#undef GetClassName
+#pragma push_macro("GetMessage")
+#undef GetMessage
+#pragma push_macro("GetObject")
+#undef GetObject
+#pragma push_macro("IGNORE")
+#undef IGNORE
+#pragma push_macro("IN")
+#undef IN
+#pragma push_macro("INPUT_KEYBOARD")
+#undef INPUT_KEYBOARD
+#pragma push_macro("NO_ERROR")
+#undef NO_ERROR
+#pragma push_macro("OUT")
+#undef OUT
+#pragma push_macro("OPTIONAL")
+#undef OPTIONAL
+#pragma push_macro("min")
+#undef min
+#pragma push_macro("max")
+#undef max
+#pragma push_macro("NEAR")
+#undef NEAR
+#pragma push_macro("NO_DATA")
+#undef NO_DATA
+#pragma push_macro("REASON_UNKNOWN")
+#undef REASON_UNKNOWN
+#pragma push_macro("SERVICE_DISABLED")
+#undef SERVICE_DISABLED
+#pragma push_macro("SEVERITY_ERROR")
+#undef SEVERITY_ERROR
+#pragma push_macro("STATUS_PENDING")
+#undef STATUS_PENDING
+#pragma push_macro("STRICT")
+#undef STRICT
+#pragma push_macro("timezone")
+#undef timezone
+#endif  // _MSC_VER
+
+#ifdef __APPLE__
+// Inconvenient macro names from usr/include/math.h in some macOS SDKs.
+#pragma push_macro("DOMAIN")
+#undef DOMAIN
+// Inconvenient macro names from /usr/include/mach/boolean.h in some macOS SDKs.
+#pragma push_macro("TRUE")
+#undef TRUE
+#pragma push_macro("FALSE")
+#undef FALSE
+// Inconvenient macro names from usr/include/sys/syslimits.h in some macOS SDKs.
+#pragma push_macro("UID_MAX")
+#undef UID_MAX
+#endif  // __APPLE__
+
+#if defined(__clang__) || PROTOBUF_GNUC_MIN(3, 0) || defined(_MSC_VER)
+// Don't let Objective-C Macros interfere with proto identifiers with the same
+// name.
+#pragma push_macro("DEBUG")
+#undef DEBUG
+#endif // defined(__clang__) || PROTOBUF_GNUC_MIN(3, 0) || defined(_MSC_VER)
+
+#if PROTOBUF_GNUC_MIN(3, 0)
+// GCC does not allow disabling diagnostics within an expression:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60875, so we disable this one
+// globally even though it's only used for PROTOBUF_FIELD_OFFSET.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+#endif
+
+// Silence some MSVC warnings in all our code.
+#ifdef _MSC_VER
+#pragma warning(push)
+// For non-trivial unions
+#pragma warning(disable : 4582)
+#pragma warning(disable : 4583)
+// For init_seg(lib)
+#pragma warning(disable : 4073)
+// To silence the fact that we will pop this push from another file
+#pragma warning(disable : 5031)
+// Conditional expression is constant
+#pragma warning(disable: 4127)
+// decimal digit terminates octal escape sequence
+#pragma warning(disable: 4125)
+#endif
+
+// We don't want code outside port_def doing complex testing, so
+// remove our portable condition test macros to nudge folks away from
+// using it themselves.
+#ifdef PROTOBUF_has_cpp_attribute_DEFINED_
+#  undef __has_cpp_attribute
+#  undef PROTOBUF_has_cpp_attribute_DEFINED_
+#endif
+#ifdef PROTOBUF_has_feature_DEFINED_
+#  undef __has_feature
+#  undef PROTOBUF_has_feature_DEFINED_
+#endif
+#ifdef PROTOBUF_has_warning_DEFINED_
+#  undef __has_warning
+#  undef PROTOBUF_has_warning_DEFINED_
+#endif
+#ifdef PROTOBUF_has_attribute_DEFINED_
+#  undef __has_attribute
+#  undef PROTOBUF_has_attribute_DEFINED_
+#endif
+#ifdef PROTOBUF_has_builtin_DEFINED_
+#  undef __has_builtin
+#  undef PROTOBUF_has_builtin_DEFINED_
+#endif
diff --git a/CAPI/cpp/grpc/include/google/protobuf/port_undef.inc b/CAPI/cpp/grpc/include/google/protobuf/port_undef.inc
new file mode 100644
index 0000000..e880fa5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/port_undef.inc
@@ -0,0 +1,160 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// #undefs all macros defined in port_def.inc.  See comments in port_def.inc
+// for more info.
+
+#ifndef PROTOBUF_NAMESPACE
+#error "port_undef.inc must be included after port_def.inc"
+#endif
+
+#undef PROTOBUF_BUILTIN_BSWAP16
+#undef PROTOBUF_BUILTIN_BSWAP32
+#undef PROTOBUF_BUILTIN_BSWAP64
+#undef PROTOBUF_GNUC_MIN
+#undef PROTOBUF_MSC_VER_MIN
+#undef PROTOBUF_CPLUSPLUS_MIN
+#undef PROTOBUF_NAMESPACE
+#undef PROTOBUF_NAMESPACE_ID
+#undef PROTOBUF_ALWAYS_INLINE
+#undef PROTOBUF_NDEBUG_INLINE
+#undef PROTOBUF_MUSTTAIL
+#undef PROTOBUF_TAILCALL
+#undef PROTOBUF_COLD
+#undef PROTOBUF_NOINLINE
+#undef PROTOBUF_SECTION_VARIABLE
+#undef PROTOBUF_DEPRECATED
+#undef PROTOBUF_DEPRECATED_ENUM
+#undef PROTOBUF_DEPRECATED_MSG
+#undef PROTOBUF_FUNC_ALIGN
+#undef PROTOBUF_RETURNS_NONNULL
+#undef PROTOBUF_ATTRIBUTE_REINITIALIZES
+#undef PROTOBUF_RTTI
+#undef PROTOBUF_VERSION
+#undef PROTOBUF_VERSION_SUFFIX
+#undef PROTOBUF_FIELD_OFFSET
+#undef PROTOBUF_MIN_HEADER_VERSION_FOR_PROTOC
+#undef PROTOBUF_MIN_PROTOC_VERSION
+#undef PROTOBUF_PREDICT_TRUE
+#undef PROTOBUF_PREDICT_FALSE
+#undef PROTOBUF_FALLTHROUGH_INTENDED
+#undef PROTOBUF_EXPORT
+#undef PROTOC_EXPORT
+#undef PROTOBUF_NODISCARD
+#undef PROTOBUF_FORCE_COPY_IN_RELEASE
+#undef PROTOBUF_FORCE_COPY_IN_SWAP
+#undef PROTOBUF_FORCE_COPY_IN_MOVE
+#undef PROTOBUF_FORCE_RESET_IN_CLEAR
+#undef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+#undef PROTOBUF_NAMESPACE_OPEN
+#undef PROTOBUF_NAMESPACE_CLOSE
+#undef PROTOBUF_UNUSED
+#undef PROTOBUF_ASSUME
+#undef PROTOBUF_EXPORT_TEMPLATE_DECLARE
+#undef PROTOBUF_EXPORT_TEMPLATE_DEFINE
+#undef PROTOBUF_ALIGNAS
+#undef PROTOBUF_FINAL
+#undef PROTOBUF_FUTURE_FINAL
+#undef PROTOBUF_THREAD_LOCAL
+#undef PROTOBUF_LITTLE_ENDIAN
+#undef PROTOBUF_BIG_ENDIAN
+#undef PROTOBUF_MESSAGE_OWNED_ARENA_EXPERIMENT
+#undef PROTOBUF_CONSTINIT
+#undef PROTOBUF_CONSTEXPR
+#undef PROTOBUF_ATTRIBUTE_WEAK
+#undef PROTOBUF_HAVE_ATTRIBUTE_WEAK
+#undef PROTOBUF_ATTRIBUTE_NO_DESTROY
+#undef PROTOBUF_ATTRIBUTE_STANDALONE_DEBUG
+#undef PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+#undef PROTOBUF_ATTRIBUTE_INIT_PRIORITY2
+#undef PROTOBUF_PRAGMA_INIT_SEG
+#undef PROTOBUF_ASAN
+#undef PROTOBUF_MSAN
+#undef PROTOBUF_TSAN
+#undef PROTOBUF_TAIL_CALL_TABLE_PARSER_ENABLED
+#undef PROTOBUF_TC_PARAM_DECL
+#undef PROTOBUF_EXCLUSIVE_LOCKS_REQUIRED
+#undef PROTOBUF_LOCKS_EXCLUDED
+#undef PROTOBUF_NO_THREAD_SAFETY_ANALYSIS
+#undef PROTOBUF_GUARDED_BY
+
+#ifdef PROTOBUF_FUTURE_BREAKING_CHANGES
+#undef PROTOBUF_FUTURE_BREAKING_CHANGES
+#endif
+
+// Restore macro that may have been #undef'd in port_def.inc.
+#ifdef _MSC_VER
+#pragma pop_macro("CREATE_NEW")
+#pragma pop_macro("DELETE")
+#pragma pop_macro("DOUBLE_CLICK")
+#pragma pop_macro("ERROR")
+#pragma pop_macro("ERROR_BUSY")
+#pragma pop_macro("ERROR_INSTALL_FAILED")
+#pragma pop_macro("ERROR_NOT_FOUND")
+#pragma pop_macro("GetClassName")
+#pragma pop_macro("GetMessage")
+#pragma pop_macro("GetObject")
+#pragma pop_macro("IGNORE")
+#pragma pop_macro("IN")
+#pragma pop_macro("INPUT_KEYBOARD")
+#pragma pop_macro("OUT")
+#pragma pop_macro("OPTIONAL")
+#pragma pop_macro("min")
+#pragma pop_macro("max")
+#pragma pop_macro("NEAR")
+#pragma pop_macro("NO_DATA")
+#pragma pop_macro("NO_ERROR")
+#pragma pop_macro("REASON_UNKNOWN")
+#pragma pop_macro("SERVICE_DISABLED")
+#pragma pop_macro("SEVERITY_ERROR")
+#pragma pop_macro("STRICT")
+#pragma pop_macro("STATUS_PENDING")
+#pragma pop_macro("timezone")
+#endif
+
+#ifdef __APPLE__
+#pragma pop_macro("DOMAIN")
+#pragma pop_macro("TRUE")
+#pragma pop_macro("FALSE")
+#pragma pop_macro("UID_MAX")
+#endif  // __APPLE__
+
+#if defined(__clang__) || defined(__GNUC__) || defined(_MSC_VER)
+#pragma pop_macro("DEBUG")
+#endif // defined(__clang__) || defined(__GNUC__) || defined(_MSC_VER)
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+// Pop the warning(push) from port_def.inc
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
diff --git a/CAPI/cpp/grpc/include/google/protobuf/reflection.h b/CAPI/cpp/grpc/include/google/protobuf/reflection.h
new file mode 100644
index 0000000..7b75a43
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/reflection.h
@@ -0,0 +1,570 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This header defines the RepeatedFieldRef class template used to access
+// repeated fields with protobuf reflection API.
+#ifndef GOOGLE_PROTOBUF_REFLECTION_H__
+#define GOOGLE_PROTOBUF_REFLECTION_H__
+
+
+#include <memory>
+
+#include <google/protobuf/message.h>
+#include <google/protobuf/generated_enum_util.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+template <typename T, typename Enable = void>
+struct RefTypeTraits;
+}  // namespace internal
+
+template <typename T>
+RepeatedFieldRef<T> Reflection::GetRepeatedFieldRef(
+    const Message& message, const FieldDescriptor* field) const {
+  return RepeatedFieldRef<T>(message, field);
+}
+
+template <typename T>
+MutableRepeatedFieldRef<T> Reflection::GetMutableRepeatedFieldRef(
+    Message* message, const FieldDescriptor* field) const {
+  return MutableRepeatedFieldRef<T>(message, field);
+}
+
+// RepeatedFieldRef definition for non-message types.
+template <typename T>
+class RepeatedFieldRef<
+    T, typename std::enable_if<!std::is_base_of<Message, T>::value>::type> {
+  typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
+  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+ public:
+  bool empty() const { return accessor_->IsEmpty(data_); }
+  int size() const { return accessor_->Size(data_); }
+  T Get(int index) const { return accessor_->template Get<T>(data_, index); }
+
+  typedef IteratorType iterator;
+  typedef IteratorType const_iterator;
+  typedef T value_type;
+  typedef T& reference;
+  typedef const T& const_reference;
+  typedef int size_type;
+  typedef ptrdiff_t difference_type;
+
+  iterator begin() const { return iterator(data_, accessor_, true); }
+  iterator end() const { return iterator(data_, accessor_, false); }
+
+ private:
+  friend class Reflection;
+  RepeatedFieldRef(const Message& message, const FieldDescriptor* field) {
+    const Reflection* reflection = message.GetReflection();
+    data_ = reflection->RepeatedFieldData(const_cast<Message*>(&message), field,
+                                          internal::RefTypeTraits<T>::cpp_type,
+                                          nullptr);
+    accessor_ = reflection->RepeatedFieldAccessor(field);
+  }
+
+  const void* data_;
+  const AccessorType* accessor_;
+};
+
+// MutableRepeatedFieldRef definition for non-message types.
+template <typename T>
+class MutableRepeatedFieldRef<
+    T, typename std::enable_if<!std::is_base_of<Message, T>::value>::type> {
+  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+ public:
+  bool empty() const { return accessor_->IsEmpty(data_); }
+  int size() const { return accessor_->Size(data_); }
+  T Get(int index) const { return accessor_->template Get<T>(data_, index); }
+
+  void Set(int index, const T& value) const {
+    accessor_->template Set<T>(data_, index, value);
+  }
+  void Add(const T& value) const { accessor_->template Add<T>(data_, value); }
+  void RemoveLast() const { accessor_->RemoveLast(data_); }
+  void SwapElements(int index1, int index2) const {
+    accessor_->SwapElements(data_, index1, index2);
+  }
+  void Clear() const { accessor_->Clear(data_); }
+
+  void Swap(const MutableRepeatedFieldRef& other) const {
+    accessor_->Swap(data_, other.accessor_, other.data_);
+  }
+
+  template <typename Container>
+  void MergeFrom(const Container& container) const {
+    typedef typename Container::const_iterator Iterator;
+    for (Iterator it = container.begin(); it != container.end(); ++it) {
+      Add(*it);
+    }
+  }
+  template <typename Container>
+  void CopyFrom(const Container& container) const {
+    Clear();
+    MergeFrom(container);
+  }
+
+ private:
+  friend class Reflection;
+  MutableRepeatedFieldRef(Message* message, const FieldDescriptor* field) {
+    const Reflection* reflection = message->GetReflection();
+    data_ = reflection->RepeatedFieldData(
+        message, field, internal::RefTypeTraits<T>::cpp_type, nullptr);
+    accessor_ = reflection->RepeatedFieldAccessor(field);
+  }
+
+  void* data_;
+  const AccessorType* accessor_;
+};
+
+// RepeatedFieldRef definition for message types.
+template <typename T>
+class RepeatedFieldRef<
+    T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
+  typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
+  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+ public:
+  bool empty() const { return accessor_->IsEmpty(data_); }
+  int size() const { return accessor_->Size(data_); }
+  // This method returns a reference to the underlying message object if it
+  // exists. If a message object doesn't exist (e.g., data stored in serialized
+  // form), scratch_space will be filled with the data and a reference to it
+  // will be returned.
+  //
+  // Example:
+  //   RepeatedFieldRef<Message> h = ...
+  //   unique_ptr<Message> scratch_space(h.NewMessage());
+  //   const Message& item = h.Get(index, scratch_space.get());
+  const T& Get(int index, T* scratch_space) const {
+    return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
+  }
+  // Create a new message of the same type as the messages stored in this
+  // repeated field. Caller takes ownership of the returned object.
+  T* NewMessage() const { return static_cast<T*>(default_instance_->New()); }
+
+  typedef IteratorType iterator;
+  typedef IteratorType const_iterator;
+  typedef T value_type;
+  typedef T& reference;
+  typedef const T& const_reference;
+  typedef int size_type;
+  typedef ptrdiff_t difference_type;
+
+  iterator begin() const {
+    return iterator(data_, accessor_, true, NewMessage());
+  }
+  iterator end() const {
+    // The end iterator must not be dereferenced, no need for scratch space.
+    return iterator(data_, accessor_, false, nullptr);
+  }
+
+ private:
+  friend class Reflection;
+  RepeatedFieldRef(const Message& message, const FieldDescriptor* field) {
+    const Reflection* reflection = message.GetReflection();
+    data_ = reflection->RepeatedFieldData(
+        const_cast<Message*>(&message), field,
+        internal::RefTypeTraits<T>::cpp_type,
+        internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
+    accessor_ = reflection->RepeatedFieldAccessor(field);
+    default_instance_ =
+        reflection->GetMessageFactory()->GetPrototype(field->message_type());
+  }
+
+  const void* data_;
+  const AccessorType* accessor_;
+  const Message* default_instance_;
+};
+
+// MutableRepeatedFieldRef definition for message types.
+template <typename T>
+class MutableRepeatedFieldRef<
+    T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
+  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+ public:
+  bool empty() const { return accessor_->IsEmpty(data_); }
+  int size() const { return accessor_->Size(data_); }
+  // See comments for RepeatedFieldRef<Message>::Get()
+  const T& Get(int index, T* scratch_space) const {
+    return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
+  }
+  // Create a new message of the same type as the messages stored in this
+  // repeated field. Caller takes ownership of the returned object.
+  T* NewMessage() const { return static_cast<T*>(default_instance_->New()); }
+
+  void Set(int index, const T& value) const {
+    accessor_->Set(data_, index, &value);
+  }
+  void Add(const T& value) const { accessor_->Add(data_, &value); }
+  void RemoveLast() const { accessor_->RemoveLast(data_); }
+  void SwapElements(int index1, int index2) const {
+    accessor_->SwapElements(data_, index1, index2);
+  }
+  void Clear() const { accessor_->Clear(data_); }
+
+  void Swap(const MutableRepeatedFieldRef& other) const {
+    accessor_->Swap(data_, other.accessor_, other.data_);
+  }
+
+  template <typename Container>
+  void MergeFrom(const Container& container) const {
+    typedef typename Container::const_iterator Iterator;
+    for (Iterator it = container.begin(); it != container.end(); ++it) {
+      Add(*it);
+    }
+  }
+  template <typename Container>
+  void CopyFrom(const Container& container) const {
+    Clear();
+    MergeFrom(container);
+  }
+
+ private:
+  friend class Reflection;
+  MutableRepeatedFieldRef(Message* message, const FieldDescriptor* field) {
+    const Reflection* reflection = message->GetReflection();
+    data_ = reflection->RepeatedFieldData(
+        message, field, internal::RefTypeTraits<T>::cpp_type,
+        internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
+    accessor_ = reflection->RepeatedFieldAccessor(field);
+    default_instance_ =
+        reflection->GetMessageFactory()->GetPrototype(field->message_type());
+  }
+
+  void* data_;
+  const AccessorType* accessor_;
+  const Message* default_instance_;
+};
+
+namespace internal {
+// Interfaces used to implement reflection RepeatedFieldRef API.
+// Reflection::GetRepeatedAccessor() should return a pointer to an singleton
+// object that implements the below interface.
+//
+// This interface passes/returns values using void pointers. The actual type
+// of the value depends on the field's cpp_type. Following is a mapping from
+// cpp_type to the type that should be used in this interface:
+//
+//   field->cpp_type()      T                Actual type of void*
+//   CPPTYPE_INT32        int32_t                 int32_t
+//   CPPTYPE_UINT32       uint32_t                uint32_t
+//   CPPTYPE_INT64        int64_t                 int64_t
+//   CPPTYPE_UINT64       uint64_t                uint64_t
+//   CPPTYPE_DOUBLE       double                  double
+//   CPPTYPE_FLOAT        float                   float
+//   CPPTYPE_BOOL         bool                    bool
+//   CPPTYPE_ENUM         generated enum type     int32_t
+//   CPPTYPE_STRING       string                  std::string
+//   CPPTYPE_MESSAGE      generated message type  google::protobuf::Message
+//                        or google::protobuf::Message
+//
+// Note that for enums we use int32_t in the interface.
+//
+// You can map from T to the actual type using RefTypeTraits:
+//   typedef RefTypeTraits<T>::AccessorValueType ActualType;
+class PROTOBUF_EXPORT RepeatedFieldAccessor {
+ public:
+  // Typedefs for clarity.
+  typedef void Field;
+  typedef void Value;
+  typedef void Iterator;
+
+  virtual bool IsEmpty(const Field* data) const = 0;
+  virtual int Size(const Field* data) const = 0;
+  // Depends on the underlying representation of the repeated field, this
+  // method can return a pointer to the underlying object if such an object
+  // exists, or fill the data into scratch_space and return scratch_space.
+  // Callers of this method must ensure scratch_space is a valid pointer
+  // to a mutable object of the correct type.
+  virtual const Value* Get(const Field* data, int index,
+                           Value* scratch_space) const = 0;
+
+  virtual void Clear(Field* data) const = 0;
+  virtual void Set(Field* data, int index, const Value* value) const = 0;
+  virtual void Add(Field* data, const Value* value) const = 0;
+  virtual void RemoveLast(Field* data) const = 0;
+  virtual void SwapElements(Field* data, int index1, int index2) const = 0;
+  virtual void Swap(Field* data, const RepeatedFieldAccessor* other_mutator,
+                    Field* other_data) const = 0;
+
+  // Create an iterator that points at the beginning of the repeated field.
+  virtual Iterator* BeginIterator(const Field* data) const = 0;
+  // Create an iterator that points at the end of the repeated field.
+  virtual Iterator* EndIterator(const Field* data) const = 0;
+  // Make a copy of an iterator and return the new copy.
+  virtual Iterator* CopyIterator(const Field* data,
+                                 const Iterator* iterator) const = 0;
+  // Move an iterator to point to the next element.
+  virtual Iterator* AdvanceIterator(const Field* data,
+                                    Iterator* iterator) const = 0;
+  // Compare whether two iterators point to the same element.
+  virtual bool EqualsIterator(const Field* data, const Iterator* a,
+                              const Iterator* b) const = 0;
+  // Delete an iterator created by BeginIterator(), EndIterator() and
+  // CopyIterator().
+  virtual void DeleteIterator(const Field* data, Iterator* iterator) const = 0;
+  // Like Get() but for iterators.
+  virtual const Value* GetIteratorValue(const Field* data,
+                                        const Iterator* iterator,
+                                        Value* scratch_space) const = 0;
+
+  // Templated methods that make using this interface easier for non-message
+  // types.
+  template <typename T>
+  T Get(const Field* data, int index) const {
+    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+    ActualType scratch_space;
+    return static_cast<T>(*reinterpret_cast<const ActualType*>(
+        Get(data, index, static_cast<Value*>(&scratch_space))));
+  }
+
+  template <typename T, typename ValueType>
+  void Set(Field* data, int index, const ValueType& value) const {
+    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+    // In this RepeatedFieldAccessor interface we pass/return data using
+    // raw pointers. Type of the data these raw pointers point to should
+    // be ActualType. Here we have a ValueType object and want a ActualType
+    // pointer. We can't cast a ValueType pointer to an ActualType pointer
+    // directly because their type might be different (for enums ValueType
+    // may be a generated enum type while ActualType is int32_t). To be safe
+    // we make a copy to get a temporary ActualType object and use it.
+    ActualType tmp = static_cast<ActualType>(value);
+    Set(data, index, static_cast<const Value*>(&tmp));
+  }
+
+  template <typename T, typename ValueType>
+  void Add(Field* data, const ValueType& value) const {
+    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+    // In this RepeatedFieldAccessor interface we pass/return data using
+    // raw pointers. Type of the data these raw pointers point to should
+    // be ActualType. Here we have a ValueType object and want a ActualType
+    // pointer. We can't cast a ValueType pointer to an ActualType pointer
+    // directly because their type might be different (for enums ValueType
+    // may be a generated enum type while ActualType is int32_t). To be safe
+    // we make a copy to get a temporary ActualType object and use it.
+    ActualType tmp = static_cast<ActualType>(value);
+    Add(data, static_cast<const Value*>(&tmp));
+  }
+
+ protected:
+  // We want the destructor to be completely trivial as to allow it to be
+  // a function local static. Hence we make it non-virtual and protected,
+  // this class only live as part of a global singleton and should not be
+  // deleted.
+  ~RepeatedFieldAccessor() = default;
+};
+
+// Implement (Mutable)RepeatedFieldRef::iterator
+template <typename T>
+class RepeatedFieldRefIterator {
+  typedef typename RefTypeTraits<T>::AccessorValueType AccessorValueType;
+  typedef typename RefTypeTraits<T>::IteratorValueType IteratorValueType;
+  typedef typename RefTypeTraits<T>::IteratorPointerType IteratorPointerType;
+
+ public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = T;
+  using pointer = T*;
+  using reference = T&;
+  using difference_type = std::ptrdiff_t;
+
+  // Constructor for non-message fields.
+  RepeatedFieldRefIterator(const void* data,
+                           const RepeatedFieldAccessor* accessor, bool begin)
+      : data_(data),
+        accessor_(accessor),
+        iterator_(begin ? accessor->BeginIterator(data)
+                        : accessor->EndIterator(data)),
+        // The end iterator must not be dereferenced, no need for scratch space.
+        scratch_space_(begin ? new AccessorValueType : nullptr) {}
+  // Constructor for message fields.
+  RepeatedFieldRefIterator(const void* data,
+                           const RepeatedFieldAccessor* accessor, bool begin,
+                           AccessorValueType* scratch_space)
+      : data_(data),
+        accessor_(accessor),
+        iterator_(begin ? accessor->BeginIterator(data)
+                        : accessor->EndIterator(data)),
+        scratch_space_(scratch_space) {}
+  ~RepeatedFieldRefIterator() { accessor_->DeleteIterator(data_, iterator_); }
+  RepeatedFieldRefIterator operator++(int) {
+    RepeatedFieldRefIterator tmp(*this);
+    iterator_ = accessor_->AdvanceIterator(data_, iterator_);
+    return tmp;
+  }
+  RepeatedFieldRefIterator& operator++() {
+    iterator_ = accessor_->AdvanceIterator(data_, iterator_);
+    return *this;
+  }
+  IteratorValueType operator*() const {
+    return static_cast<IteratorValueType>(
+        *static_cast<const AccessorValueType*>(accessor_->GetIteratorValue(
+            data_, iterator_, scratch_space_.get())));
+  }
+  IteratorPointerType operator->() const {
+    return static_cast<IteratorPointerType>(
+        accessor_->GetIteratorValue(data_, iterator_, scratch_space_.get()));
+  }
+  bool operator!=(const RepeatedFieldRefIterator& other) const {
+    assert(data_ == other.data_);
+    assert(accessor_ == other.accessor_);
+    return !accessor_->EqualsIterator(data_, iterator_, other.iterator_);
+  }
+  bool operator==(const RepeatedFieldRefIterator& other) const {
+    return !this->operator!=(other);
+  }
+
+  RepeatedFieldRefIterator(const RepeatedFieldRefIterator& other)
+      : data_(other.data_),
+        accessor_(other.accessor_),
+        iterator_(accessor_->CopyIterator(data_, other.iterator_)) {}
+  RepeatedFieldRefIterator& operator=(const RepeatedFieldRefIterator& other) {
+    if (this != &other) {
+      accessor_->DeleteIterator(data_, iterator_);
+      data_ = other.data_;
+      accessor_ = other.accessor_;
+      iterator_ = accessor_->CopyIterator(data_, other.iterator_);
+    }
+    return *this;
+  }
+
+ protected:
+  const void* data_;
+  const RepeatedFieldAccessor* accessor_;
+  void* iterator_;
+  std::unique_ptr<AccessorValueType> scratch_space_;
+};
+
+// TypeTraits that maps the type parameter T of RepeatedFieldRef or
+// MutableRepeatedFieldRef to corresponding iterator type,
+// RepeatedFieldAccessor type, etc.
+template <typename T>
+struct PrimitiveTraits {
+  static constexpr bool is_primitive = false;
+};
+#define DEFINE_PRIMITIVE(TYPE, type)                 \
+  template <>                                        \
+  struct PrimitiveTraits<type> {                     \
+    static const bool is_primitive = true;           \
+    static const FieldDescriptor::CppType cpp_type = \
+        FieldDescriptor::CPPTYPE_##TYPE;             \
+  };
+DEFINE_PRIMITIVE(INT32, int32_t)
+DEFINE_PRIMITIVE(UINT32, uint32_t)
+DEFINE_PRIMITIVE(INT64, int64_t)
+DEFINE_PRIMITIVE(UINT64, uint64_t)
+DEFINE_PRIMITIVE(FLOAT, float)
+DEFINE_PRIMITIVE(DOUBLE, double)
+DEFINE_PRIMITIVE(BOOL, bool)
+#undef DEFINE_PRIMITIVE
+
+template <typename T>
+struct RefTypeTraits<
+    T, typename std::enable_if<PrimitiveTraits<T>::is_primitive>::type> {
+  typedef RepeatedFieldRefIterator<T> iterator;
+  typedef RepeatedFieldAccessor AccessorType;
+  typedef T AccessorValueType;
+  typedef T IteratorValueType;
+  typedef T* IteratorPointerType;
+  static constexpr FieldDescriptor::CppType cpp_type =
+      PrimitiveTraits<T>::cpp_type;
+  static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
+};
+
+template <typename T>
+struct RefTypeTraits<
+    T, typename std::enable_if<is_proto_enum<T>::value>::type> {
+  typedef RepeatedFieldRefIterator<T> iterator;
+  typedef RepeatedFieldAccessor AccessorType;
+  // We use int32_t for repeated enums in RepeatedFieldAccessor.
+  typedef int32_t AccessorValueType;
+  typedef T IteratorValueType;
+  typedef int32_t* IteratorPointerType;
+  static constexpr FieldDescriptor::CppType cpp_type =
+      FieldDescriptor::CPPTYPE_ENUM;
+  static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
+};
+
+template <typename T>
+struct RefTypeTraits<
+    T, typename std::enable_if<std::is_same<std::string, T>::value>::type> {
+  typedef RepeatedFieldRefIterator<T> iterator;
+  typedef RepeatedFieldAccessor AccessorType;
+  typedef std::string AccessorValueType;
+  typedef const std::string IteratorValueType;
+  typedef const std::string* IteratorPointerType;
+  static constexpr FieldDescriptor::CppType cpp_type =
+      FieldDescriptor::CPPTYPE_STRING;
+  static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
+};
+
+template <typename T>
+struct MessageDescriptorGetter {
+  static const Descriptor* get() {
+    return T::default_instance().GetDescriptor();
+  }
+};
+template <>
+struct MessageDescriptorGetter<Message> {
+  static const Descriptor* get() { return nullptr; }
+};
+
+template <typename T>
+struct RefTypeTraits<
+    T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
+  typedef RepeatedFieldRefIterator<T> iterator;
+  typedef RepeatedFieldAccessor AccessorType;
+  typedef Message AccessorValueType;
+  typedef const T& IteratorValueType;
+  typedef const T* IteratorPointerType;
+  static constexpr FieldDescriptor::CppType cpp_type =
+      FieldDescriptor::CPPTYPE_MESSAGE;
+  static const Descriptor* GetMessageFieldDescriptor() {
+    return MessageDescriptorGetter<T>::get();
+  }
+};
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_REFLECTION_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/reflection_ops.h b/CAPI/cpp/grpc/include/google/protobuf/reflection_ops.h
new file mode 100644
index 0000000..0a45702
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/reflection_ops.h
@@ -0,0 +1,92 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_REFLECTION_OPS_H__
+#define GOOGLE_PROTOBUF_REFLECTION_OPS_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/message.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Basic operations that can be performed using reflection.
+// These can be used as a cheap way to implement the corresponding
+// methods of the Message interface, though they are likely to be
+// slower than implementations tailored for the specific message type.
+//
+// This class should stay limited to operations needed to implement
+// the Message interface.
+//
+// This class is really a namespace that contains only static methods.
+class PROTOBUF_EXPORT ReflectionOps {
+ public:
+  static void Copy(const Message& from, Message* to);
+  static void Merge(const Message& from, Message* to);
+  static void Clear(Message* message);
+  static bool IsInitialized(const Message& message);
+  static bool IsInitialized(const Message& message, bool check_fields,
+                            bool check_descendants);
+  static void DiscardUnknownFields(Message* message);
+
+  // Finds all unset required fields in the message and adds their full
+  // paths (e.g. "foo.bar[5].baz") to *names.  "prefix" will be attached to
+  // the front of each name.
+  static void FindInitializationErrors(const Message& message,
+                                       const std::string& prefix,
+                                       std::vector<std::string>* errors);
+
+ private:
+  // All methods are static.  No need to construct.
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ReflectionOps);
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_REFLECTION_OPS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/repeated_field.h b/CAPI/cpp/grpc/include/google/protobuf/repeated_field.h
new file mode 100644
index 0000000..3fb734e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/repeated_field.h
@@ -0,0 +1,1219 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// RepeatedField and RepeatedPtrField are used by generated protocol message
+// classes to manipulate repeated fields.  These classes are very similar to
+// STL's vector, but include a number of optimizations found to be useful
+// specifically in the case of Protocol Buffers.  RepeatedPtrField is
+// particularly different from STL vector as it manages ownership of the
+// pointers that it contains.
+//
+// This header covers RepeatedField.
+
+#ifndef GOOGLE_PROTOBUF_REPEATED_FIELD_H__
+#define GOOGLE_PROTOBUF_REPEATED_FIELD_H__
+
+
+#include <algorithm>
+#include <iterator>
+#include <limits>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_ptr_field.h>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+class Message;
+
+namespace internal {
+
+template <typename T, int kRepHeaderSize>
+constexpr int RepeatedFieldLowerClampLimit() {
+  // The header is padded to be at least `sizeof(T)` when it would be smaller
+  // otherwise.
+  static_assert(sizeof(T) <= kRepHeaderSize, "");
+  // We want to pad the minimum size to be a power of two bytes, including the
+  // header.
+  // The first allocation is kRepHeaderSize bytes worth of elements for a total
+  // of 2*kRepHeaderSize bytes.
+  // For an 8-byte header, we allocate 8 bool, 2 ints, or 1 int64.
+  return kRepHeaderSize / sizeof(T);
+}
+
+// kRepeatedFieldUpperClampLimit is the lowest signed integer value that
+// overflows when multiplied by 2 (which is undefined behavior). Sizes above
+// this will clamp to the maximum int value instead of following exponential
+// growth when growing a repeated field.
+constexpr int kRepeatedFieldUpperClampLimit =
+    (std::numeric_limits<int>::max() / 2) + 1;
+
+template <typename Iter>
+inline int CalculateReserve(Iter begin, Iter end, std::forward_iterator_tag) {
+  return static_cast<int>(std::distance(begin, end));
+}
+
+template <typename Iter>
+inline int CalculateReserve(Iter /*begin*/, Iter /*end*/,
+                            std::input_iterator_tag /*unused*/) {
+  return -1;
+}
+
+template <typename Iter>
+inline int CalculateReserve(Iter begin, Iter end) {
+  typedef typename std::iterator_traits<Iter>::iterator_category Category;
+  return CalculateReserve(begin, end, Category());
+}
+
+// Swaps two blocks of memory of size sizeof(T).
+template <typename T>
+inline void SwapBlock(char* p, char* q) {
+  T tmp;
+  memcpy(&tmp, p, sizeof(T));
+  memcpy(p, q, sizeof(T));
+  memcpy(q, &tmp, sizeof(T));
+}
+
+// Swaps two blocks of memory of size kSize:
+//  template <int kSize> void memswap(char* p, char* q);
+template <int kSize>
+inline typename std::enable_if<(kSize == 0), void>::type memswap(char*, char*) {
+}
+
+#define PROTO_MEMSWAP_DEF_SIZE(reg_type, max_size)                           \
+  template <int kSize>                                                       \
+  typename std::enable_if<(kSize >= sizeof(reg_type) && kSize < (max_size)), \
+                          void>::type                                        \
+  memswap(char* p, char* q) {                                                \
+    SwapBlock<reg_type>(p, q);                                               \
+    memswap<kSize - sizeof(reg_type)>(p + sizeof(reg_type),                  \
+                                      q + sizeof(reg_type));                 \
+  }
+
+PROTO_MEMSWAP_DEF_SIZE(uint8_t, 2)
+PROTO_MEMSWAP_DEF_SIZE(uint16_t, 4)
+PROTO_MEMSWAP_DEF_SIZE(uint32_t, 8)
+
+#ifdef __SIZEOF_INT128__
+PROTO_MEMSWAP_DEF_SIZE(uint64_t, 16)
+PROTO_MEMSWAP_DEF_SIZE(__uint128_t, (1u << 31))
+#else
+PROTO_MEMSWAP_DEF_SIZE(uint64_t, (1u << 31))
+#endif
+
+#undef PROTO_MEMSWAP_DEF_SIZE
+
+template <typename Element>
+class RepeatedIterator;
+
+}  // namespace internal
+
+// RepeatedField is used to represent repeated fields of a primitive type (in
+// other words, everything except strings and nested Messages).  Most users will
+// not ever use a RepeatedField directly; they will use the get-by-index,
+// set-by-index, and add accessors that are generated for all repeated fields.
+template <typename Element>
+class RepeatedField final {
+  static_assert(
+      alignof(Arena) >= alignof(Element),
+      "We only support types that have an alignment smaller than Arena");
+
+ public:
+  constexpr RepeatedField();
+  explicit RepeatedField(Arena* arena);
+
+  RepeatedField(const RepeatedField& other);
+
+  template <typename Iter,
+            typename = typename std::enable_if<std::is_constructible<
+                Element, decltype(*std::declval<Iter>())>::value>::type>
+  RepeatedField(Iter begin, Iter end);
+
+  ~RepeatedField();
+
+  RepeatedField& operator=(const RepeatedField& other);
+
+  RepeatedField(RepeatedField&& other) noexcept;
+  RepeatedField& operator=(RepeatedField&& other) noexcept;
+
+  bool empty() const;
+  int size() const;
+
+  const Element& Get(int index) const;
+  Element* Mutable(int index);
+
+  const Element& operator[](int index) const { return Get(index); }
+  Element& operator[](int index) { return *Mutable(index); }
+
+  const Element& at(int index) const;
+  Element& at(int index);
+
+  void Set(int index, const Element& value);
+  void Add(const Element& value);
+  // Appends a new element and returns a pointer to it.
+  // The new element is uninitialized if |Element| is a POD type.
+  Element* Add();
+  // Appends elements in the range [begin, end) after reserving
+  // the appropriate number of elements.
+  template <typename Iter>
+  void Add(Iter begin, Iter end);
+
+  // Removes the last element in the array.
+  void RemoveLast();
+
+  // Extracts elements with indices in "[start .. start+num-1]".
+  // Copies them into "elements[0 .. num-1]" if "elements" is not nullptr.
+  // Caution: also moves elements with indices [start+num ..].
+  // Calling this routine inside a loop can cause quadratic behavior.
+  void ExtractSubrange(int start, int num, Element* elements);
+
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear();
+  void MergeFrom(const RepeatedField& other);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void CopyFrom(const RepeatedField& other);
+
+  // Replaces the contents with RepeatedField(begin, end).
+  template <typename Iter>
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Assign(Iter begin, Iter end);
+
+  // Reserves space to expand the field to at least the given size.  If the
+  // array is grown, it will always be at least doubled in size.
+  void Reserve(int new_size);
+
+  // Resizes the RepeatedField to a new, smaller size.  This is O(1).
+  void Truncate(int new_size);
+
+  void AddAlreadyReserved(const Element& value);
+  // Appends a new element and return a pointer to it.
+  // The new element is uninitialized if |Element| is a POD type.
+  // Should be called only if Capacity() > Size().
+  Element* AddAlreadyReserved();
+  Element* AddNAlreadyReserved(int elements);
+  int Capacity() const;
+
+  // Like STL resize.  Uses value to fill appended elements.
+  // Like Truncate() if new_size <= size(), otherwise this is
+  // O(new_size - size()).
+  void Resize(int new_size, const Element& value);
+
+  // Gets the underlying array.  This pointer is possibly invalidated by
+  // any add or remove operation.
+  Element* mutable_data();
+  const Element* data() const;
+
+  // Swaps entire contents with "other". If they are separate arenas then,
+  // copies data between each other.
+  void Swap(RepeatedField* other);
+
+  // Swaps entire contents with "other". Should be called only if the caller can
+  // guarantee that both repeated fields are on the same arena or are on the
+  // heap. Swapping between different arenas is disallowed and caught by a
+  // GOOGLE_DCHECK (see API docs for details).
+  void UnsafeArenaSwap(RepeatedField* other);
+
+  // Swaps two elements.
+  void SwapElements(int index1, int index2);
+
+  // STL-like iterator support
+  typedef internal::RepeatedIterator<Element> iterator;
+  typedef internal::RepeatedIterator<const Element> const_iterator;
+  typedef Element value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef int size_type;
+  typedef ptrdiff_t difference_type;
+
+  iterator begin();
+  const_iterator begin() const;
+  const_iterator cbegin() const;
+  iterator end();
+  const_iterator end() const;
+  const_iterator cend() const;
+
+  // Reverse iterator support
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  // Returns the number of bytes used by the repeated field, excluding
+  // sizeof(*this)
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+  // Removes the element referenced by position.
+  //
+  // Returns an iterator to the element immediately following the removed
+  // element.
+  //
+  // Invalidates all iterators at or after the removed element, including end().
+  iterator erase(const_iterator position);
+
+  // Removes the elements in the range [first, last).
+  //
+  // Returns an iterator to the element immediately following the removed range.
+  //
+  // Invalidates all iterators at or after the removed range, including end().
+  iterator erase(const_iterator first, const_iterator last);
+
+  // Gets the Arena on which this RepeatedField stores its elements.
+  inline Arena* GetArena() const {
+    return GetOwningArena();
+  }
+
+  // For internal use only.
+  //
+  // This is public due to it being called by generated code.
+  inline void InternalSwap(RepeatedField* other);
+
+ private:
+  template <typename T> friend class Arena::InternalHelper;
+
+  // Gets the Arena on which this RepeatedField stores its elements.
+  inline Arena* GetOwningArena() const {
+    return (total_size_ == 0) ? static_cast<Arena*>(arena_or_elements_)
+                              : rep()->arena;
+  }
+
+  static constexpr int kInitialSize = 0;
+  // A note on the representation here (see also comment below for
+  // RepeatedPtrFieldBase's struct Rep):
+  //
+  // We maintain the same sizeof(RepeatedField) as before we added arena support
+  // so that we do not degrade performance by bloating memory usage. Directly
+  // adding an arena_ element to RepeatedField is quite costly. By using
+  // indirection in this way, we keep the same size when the RepeatedField is
+  // empty (common case), and add only an 8-byte header to the elements array
+  // when non-empty. We make sure to place the size fields directly in the
+  // RepeatedField class to avoid costly cache misses due to the indirection.
+  int current_size_;
+  int total_size_;
+  // Pad the Rep after arena allow for power-of-two byte sizes when
+  // sizeof(Element) > sizeof(Arena*). eg for 16-byte objects.
+  static PROTOBUF_CONSTEXPR const size_t kRepHeaderSize =
+      sizeof(Arena*) < sizeof(Element) ? sizeof(Element) : sizeof(Arena*);
+  struct Rep {
+    Arena* arena;
+    Element* elements() {
+      return reinterpret_cast<Element*>(reinterpret_cast<char*>(this) +
+                                        kRepHeaderSize);
+    }
+  };
+
+  // If total_size_ == 0 this points to an Arena otherwise it points to the
+  // elements member of a Rep struct. Using this invariant allows the storage of
+  // the arena pointer without an extra allocation in the constructor.
+  void* arena_or_elements_;
+
+  // Returns a pointer to elements array.
+  // pre-condition: the array must have been allocated.
+  Element* elements() const {
+    GOOGLE_DCHECK_GT(total_size_, 0);
+    // Because of above pre-condition this cast is safe.
+    return unsafe_elements();
+  }
+
+  // Returns a pointer to elements array if it exists; otherwise either null or
+  // an invalid pointer is returned. This only happens for empty repeated
+  // fields, where you can't dereference this pointer anyway (it's empty).
+  Element* unsafe_elements() const {
+    return static_cast<Element*>(arena_or_elements_);
+  }
+
+  // Returns a pointer to the Rep struct.
+  // pre-condition: the Rep must have been allocated, ie elements() is safe.
+  Rep* rep() const {
+    return reinterpret_cast<Rep*>(reinterpret_cast<char*>(elements()) -
+                                  kRepHeaderSize);
+  }
+
+  friend class Arena;
+  typedef void InternalArenaConstructable_;
+
+  // Moves the contents of |from| into |to|, possibly clobbering |from| in the
+  // process.  For primitive types this is just a memcpy(), but it could be
+  // specialized for non-primitive types to, say, swap each element instead.
+  void MoveArray(Element* to, Element* from, int size);
+
+  // Copies the elements of |from| into |to|.
+  void CopyArray(Element* to, const Element* from, int size);
+
+  // Internal helper to delete all elements and deallocate the storage.
+  void InternalDeallocate(Rep* rep, int size, bool in_destructor) {
+    if (rep != nullptr) {
+      Element* e = &rep->elements()[0];
+      if (!std::is_trivial<Element>::value) {
+        Element* limit = &rep->elements()[size];
+        for (; e < limit; e++) {
+          e->~Element();
+        }
+      }
+      const size_t bytes = size * sizeof(*e) + kRepHeaderSize;
+      if (rep->arena == nullptr) {
+        internal::SizedDelete(rep, bytes);
+      } else if (!in_destructor) {
+        // If we are in the destructor, we might be being destroyed as part of
+        // the arena teardown. We can't try and return blocks to the arena then.
+        rep->arena->ReturnArrayMemory(rep, bytes);
+      }
+    }
+  }
+
+  // This class is a performance wrapper around RepeatedField::Add(const T&)
+  // function. In general unless a RepeatedField is a local stack variable LLVM
+  // has a hard time optimizing Add. The machine code tends to be
+  // loop:
+  // mov %size, dword ptr [%repeated_field]       // load
+  // cmp %size, dword ptr [%repeated_field + 4]
+  // jae fallback
+  // mov %buffer, qword ptr [%repeated_field + 8]
+  // mov dword [%buffer + %size * 4], %value
+  // inc %size                                    // increment
+  // mov dword ptr [%repeated_field], %size       // store
+  // jmp loop
+  //
+  // This puts a load/store in each iteration of the important loop variable
+  // size. It's a pretty bad compile that happens even in simple cases, but
+  // largely the presence of the fallback path disturbs the compilers mem-to-reg
+  // analysis.
+  //
+  // This class takes ownership of a repeated field for the duration of its
+  // lifetime. The repeated field should not be accessed during this time, ie.
+  // only access through this class is allowed. This class should always be a
+  // function local stack variable. Intended use
+  //
+  // void AddSequence(const int* begin, const int* end, RepeatedField<int>* out)
+  // {
+  //   RepeatedFieldAdder<int> adder(out);  // Take ownership of out
+  //   for (auto it = begin; it != end; ++it) {
+  //     adder.Add(*it);
+  //   }
+  // }
+  //
+  // Typically, due to the fact that adder is a local stack variable, the
+  // compiler will be successful in mem-to-reg transformation and the machine
+  // code will be loop: cmp %size, %capacity jae fallback mov dword ptr [%buffer
+  // + %size * 4], %val inc %size jmp loop
+  //
+  // The first version executes at 7 cycles per iteration while the second
+  // version executes at only 1 or 2 cycles.
+  template <int = 0, bool = std::is_trivial<Element>::value>
+  class FastAdderImpl {
+   public:
+    explicit FastAdderImpl(RepeatedField* rf) : repeated_field_(rf) {
+      index_ = repeated_field_->current_size_;
+      capacity_ = repeated_field_->total_size_;
+      buffer_ = repeated_field_->unsafe_elements();
+    }
+    ~FastAdderImpl() { repeated_field_->current_size_ = index_; }
+
+    void Add(Element val) {
+      if (index_ == capacity_) {
+        repeated_field_->current_size_ = index_;
+        repeated_field_->Reserve(index_ + 1);
+        capacity_ = repeated_field_->total_size_;
+        buffer_ = repeated_field_->unsafe_elements();
+      }
+      buffer_[index_++] = val;
+    }
+
+   private:
+    RepeatedField* repeated_field_;
+    int index_;
+    int capacity_;
+    Element* buffer_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastAdderImpl);
+  };
+
+  // FastAdder is a wrapper for adding fields. The specialization above handles
+  // POD types more efficiently than RepeatedField.
+  template <int I>
+  class FastAdderImpl<I, false> {
+   public:
+    explicit FastAdderImpl(RepeatedField* rf) : repeated_field_(rf) {}
+    void Add(const Element& val) { repeated_field_->Add(val); }
+
+   private:
+    RepeatedField* repeated_field_;
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastAdderImpl);
+  };
+
+  using FastAdder = FastAdderImpl<>;
+
+  friend class TestRepeatedFieldHelper;
+  friend class ::google::protobuf::internal::ParseContext;
+};
+
+namespace internal {
+
+// This is a helper template to copy an array of elements efficiently when they
+// have a trivial copy constructor, and correctly otherwise. This really
+// shouldn't be necessary, but our compiler doesn't optimize std::copy very
+// effectively.
+template <typename Element,
+          bool HasTrivialCopy = std::is_trivial<Element>::value>
+struct ElementCopier {
+  void operator()(Element* to, const Element* from, int array_size);
+};
+
+}  // namespace internal
+
+// implementation ====================================================
+
+template <typename Element>
+constexpr RepeatedField<Element>::RepeatedField()
+    : current_size_(0), total_size_(0), arena_or_elements_(nullptr) {}
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField(Arena* arena)
+    : current_size_(0), total_size_(0), arena_or_elements_(arena) {}
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField(const RepeatedField& other)
+    : current_size_(0), total_size_(0), arena_or_elements_(nullptr) {
+  if (other.current_size_ != 0) {
+    Reserve(other.size());
+    AddNAlreadyReserved(other.size());
+    CopyArray(Mutable(0), &other.Get(0), other.size());
+  }
+}
+
+template <typename Element>
+template <typename Iter, typename>
+RepeatedField<Element>::RepeatedField(Iter begin, Iter end)
+    : current_size_(0), total_size_(0), arena_or_elements_(nullptr) {
+  Add(begin, end);
+}
+
+template <typename Element>
+RepeatedField<Element>::~RepeatedField() {
+#ifndef NDEBUG
+  // Try to trigger segfault / asan failure in non-opt builds if arena_
+  // lifetime has ended before the destructor.
+  auto arena = GetOwningArena();
+  if (arena) (void)arena->SpaceAllocated();
+#endif
+  if (total_size_ > 0) {
+    InternalDeallocate(rep(), total_size_, true);
+  }
+}
+
+template <typename Element>
+inline RepeatedField<Element>& RepeatedField<Element>::operator=(
+    const RepeatedField& other) {
+  if (this != &other) CopyFrom(other);
+  return *this;
+}
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField(RepeatedField&& other) noexcept
+    : RepeatedField() {
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+  CopyFrom(other);
+#else   // PROTOBUF_FORCE_COPY_IN_MOVE
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // other is on an arena. This field can't be on an arena because arena
+  // construction always uses the Arena* accepting constructor.
+  if (other.GetOwningArena()) {
+    CopyFrom(other);
+  } else {
+    InternalSwap(&other);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+}
+
+template <typename Element>
+inline RepeatedField<Element>& RepeatedField<Element>::operator=(
+    RepeatedField&& other) noexcept {
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // the two fields are on different arenas.
+  if (this != &other) {
+    if (GetOwningArena() != other.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        || GetOwningArena() == nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      CopyFrom(other);
+    } else {
+      InternalSwap(&other);
+    }
+  }
+  return *this;
+}
+
+template <typename Element>
+inline bool RepeatedField<Element>::empty() const {
+  return current_size_ == 0;
+}
+
+template <typename Element>
+inline int RepeatedField<Element>::size() const {
+  return current_size_;
+}
+
+template <typename Element>
+inline int RepeatedField<Element>::Capacity() const {
+  return total_size_;
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::AddAlreadyReserved(const Element& value) {
+  GOOGLE_DCHECK_LT(current_size_, total_size_);
+  elements()[current_size_++] = value;
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::AddAlreadyReserved() {
+  GOOGLE_DCHECK_LT(current_size_, total_size_);
+  return &elements()[current_size_++];
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::AddNAlreadyReserved(int elements) {
+  GOOGLE_DCHECK_GE(total_size_ - current_size_, elements)
+      << total_size_ << ", " << current_size_;
+  // Warning: sometimes people call this when elements == 0 and
+  // total_size_ == 0. In this case the return pointer points to a zero size
+  // array (n == 0). Hence we can just use unsafe_elements(), because the user
+  // cannot dereference the pointer anyway.
+  Element* ret = unsafe_elements() + current_size_;
+  current_size_ += elements;
+  return ret;
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Resize(int new_size, const Element& value) {
+  GOOGLE_DCHECK_GE(new_size, 0);
+  if (new_size > current_size_) {
+    Reserve(new_size);
+    std::fill(&elements()[current_size_], &elements()[new_size], value);
+  }
+  current_size_ = new_size;
+}
+
+template <typename Element>
+inline const Element& RepeatedField<Element>::Get(int index) const {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  return elements()[index];
+}
+
+template <typename Element>
+inline const Element& RepeatedField<Element>::at(int index) const {
+  GOOGLE_CHECK_GE(index, 0);
+  GOOGLE_CHECK_LT(index, current_size_);
+  return elements()[index];
+}
+
+template <typename Element>
+inline Element& RepeatedField<Element>::at(int index) {
+  GOOGLE_CHECK_GE(index, 0);
+  GOOGLE_CHECK_LT(index, current_size_);
+  return elements()[index];
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::Mutable(int index) {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  return &elements()[index];
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Set(int index, const Element& value) {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  elements()[index] = value;
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Add(const Element& value) {
+  uint32_t size = current_size_;
+  if (static_cast<int>(size) == total_size_) {
+    // value could reference an element of the array. Reserving new space will
+    // invalidate the reference. So we must make a copy first.
+    auto tmp = value;
+    Reserve(total_size_ + 1);
+    elements()[size] = std::move(tmp);
+  } else {
+    elements()[size] = value;
+  }
+  current_size_ = size + 1;
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::Add() {
+  uint32_t size = current_size_;
+  if (static_cast<int>(size) == total_size_) Reserve(total_size_ + 1);
+  auto ptr = &elements()[size];
+  current_size_ = size + 1;
+  return ptr;
+}
+
+template <typename Element>
+template <typename Iter>
+inline void RepeatedField<Element>::Add(Iter begin, Iter end) {
+  int reserve = internal::CalculateReserve(begin, end);
+  if (reserve != -1) {
+    if (reserve == 0) {
+      return;
+    }
+
+    Reserve(reserve + size());
+    // TODO(ckennelly):  The compiler loses track of the buffer freshly
+    // allocated by Reserve() by the time we call elements, so it cannot
+    // guarantee that elements does not alias [begin(), end()).
+    //
+    // If restrict is available, annotating the pointer obtained from elements()
+    // causes this to lower to memcpy instead of memmove.
+    std::copy(begin, end, elements() + size());
+    current_size_ = reserve + size();
+  } else {
+    FastAdder fast_adder(this);
+    for (; begin != end; ++begin) fast_adder.Add(*begin);
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::RemoveLast() {
+  GOOGLE_DCHECK_GT(current_size_, 0);
+  current_size_--;
+}
+
+template <typename Element>
+void RepeatedField<Element>::ExtractSubrange(int start, int num,
+                                             Element* elements) {
+  GOOGLE_DCHECK_GE(start, 0);
+  GOOGLE_DCHECK_GE(num, 0);
+  GOOGLE_DCHECK_LE(start + num, this->current_size_);
+
+  // Save the values of the removed elements if requested.
+  if (elements != nullptr) {
+    for (int i = 0; i < num; ++i) elements[i] = this->Get(i + start);
+  }
+
+  // Slide remaining elements down to fill the gap.
+  if (num > 0) {
+    for (int i = start + num; i < this->current_size_; ++i)
+      this->Set(i - num, this->Get(i));
+    this->Truncate(this->current_size_ - num);
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Clear() {
+  current_size_ = 0;
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::MergeFrom(const RepeatedField& other) {
+  GOOGLE_DCHECK_NE(&other, this);
+  if (other.current_size_ != 0) {
+    int existing_size = size();
+    Reserve(existing_size + other.size());
+    AddNAlreadyReserved(other.size());
+    CopyArray(Mutable(existing_size), &other.Get(0), other.size());
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
+  if (&other == this) return;
+  Clear();
+  MergeFrom(other);
+}
+
+template <typename Element>
+template <typename Iter>
+inline void RepeatedField<Element>::Assign(Iter begin, Iter end) {
+  Clear();
+  Add(begin, end);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
+    const_iterator position) {
+  return erase(position, position + 1);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
+    const_iterator first, const_iterator last) {
+  size_type first_offset = first - cbegin();
+  if (first != last) {
+    Truncate(std::copy(last, cend(), begin() + first_offset) - cbegin());
+  }
+  return begin() + first_offset;
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::mutable_data() {
+  return unsafe_elements();
+}
+
+template <typename Element>
+inline const Element* RepeatedField<Element>::data() const {
+  return unsafe_elements();
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::InternalSwap(RepeatedField* other) {
+  GOOGLE_DCHECK(this != other);
+
+  // Swap all fields at once.
+  static_assert(std::is_standard_layout<RepeatedField<Element>>::value,
+                "offsetof() requires standard layout before c++17");
+  internal::memswap<offsetof(RepeatedField, arena_or_elements_) +
+                    sizeof(this->arena_or_elements_) -
+                    offsetof(RepeatedField, current_size_)>(
+      reinterpret_cast<char*>(this) + offsetof(RepeatedField, current_size_),
+      reinterpret_cast<char*>(other) + offsetof(RepeatedField, current_size_));
+}
+
+template <typename Element>
+void RepeatedField<Element>::Swap(RepeatedField* other) {
+  if (this == other) return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+  if (GetOwningArena() != nullptr &&
+      GetOwningArena() == other->GetOwningArena()) {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+  if (GetOwningArena() == other->GetOwningArena()) {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+    InternalSwap(other);
+  } else {
+    RepeatedField<Element> temp(other->GetOwningArena());
+    temp.MergeFrom(*this);
+    CopyFrom(*other);
+    other->UnsafeArenaSwap(&temp);
+  }
+}
+
+template <typename Element>
+void RepeatedField<Element>::UnsafeArenaSwap(RepeatedField* other) {
+  if (this == other) return;
+  GOOGLE_DCHECK_EQ(GetOwningArena(), other->GetOwningArena());
+  InternalSwap(other);
+}
+
+template <typename Element>
+void RepeatedField<Element>::SwapElements(int index1, int index2) {
+  using std::swap;  // enable ADL with fallback
+  swap(elements()[index1], elements()[index2]);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator
+RepeatedField<Element>::begin() {
+  return iterator(unsafe_elements());
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::begin() const {
+  return const_iterator(unsafe_elements());
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::cbegin() const {
+  return const_iterator(unsafe_elements());
+}
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::end() {
+  return iterator(unsafe_elements() + current_size_);
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::end() const {
+  return const_iterator(unsafe_elements() + current_size_);
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::cend() const {
+  return const_iterator(unsafe_elements() + current_size_);
+}
+
+template <typename Element>
+inline size_t RepeatedField<Element>::SpaceUsedExcludingSelfLong() const {
+  return total_size_ > 0 ? (total_size_ * sizeof(Element) + kRepHeaderSize) : 0;
+}
+
+namespace internal {
+// Returns the new size for a reserved field based on its 'total_size' and the
+// requested 'new_size'. The result is clamped to the closed interval:
+//   [internal::kMinRepeatedFieldAllocationSize,
+//    std::numeric_limits<int>::max()]
+// Requires:
+//     new_size > total_size &&
+//     (total_size == 0 ||
+//      total_size >= kRepeatedFieldLowerClampLimit)
+template <typename T, int kRepHeaderSize>
+inline int CalculateReserveSize(int total_size, int new_size) {
+  constexpr int lower_limit = RepeatedFieldLowerClampLimit<T, kRepHeaderSize>();
+  if (new_size < lower_limit) {
+    // Clamp to smallest allowed size.
+    return lower_limit;
+  }
+  constexpr int kMaxSizeBeforeClamp =
+      (std::numeric_limits<int>::max() - kRepHeaderSize) / 2;
+  if (PROTOBUF_PREDICT_FALSE(total_size > kMaxSizeBeforeClamp)) {
+    return std::numeric_limits<int>::max();
+  }
+  // We want to double the number of bytes, not the number of elements, to try
+  // to stay within power-of-two allocations.
+  // The allocation has kRepHeaderSize + sizeof(T) * capacity.
+  int doubled_size = 2 * total_size + kRepHeaderSize / sizeof(T);
+  return std::max(doubled_size, new_size);
+}
+}  // namespace internal
+
+// Avoid inlining of Reserve(): new, copy, and delete[] lead to a significant
+// amount of code bloat.
+template <typename Element>
+void RepeatedField<Element>::Reserve(int new_size) {
+  if (total_size_ >= new_size) return;
+  Rep* old_rep = total_size_ > 0 ? rep() : nullptr;
+  Rep* new_rep;
+  Arena* arena = GetOwningArena();
+
+  new_size = internal::CalculateReserveSize<Element, kRepHeaderSize>(
+      total_size_, new_size);
+
+  GOOGLE_DCHECK_LE(
+      static_cast<size_t>(new_size),
+      (std::numeric_limits<size_t>::max() - kRepHeaderSize) / sizeof(Element))
+      << "Requested size is too large to fit into size_t.";
+  size_t bytes =
+      kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
+  if (arena == nullptr) {
+    new_rep = static_cast<Rep*>(::operator new(bytes));
+  } else {
+    new_rep = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
+  }
+  new_rep->arena = arena;
+  int old_total_size = total_size_;
+  // Already known: new_size >= internal::kMinRepeatedFieldAllocationSize
+  // Maintain invariant:
+  //     total_size_ == 0 ||
+  //     total_size_ >= internal::kMinRepeatedFieldAllocationSize
+  total_size_ = new_size;
+  arena_or_elements_ = new_rep->elements();
+  // Invoke placement-new on newly allocated elements. We shouldn't have to do
+  // this, since Element is supposed to be POD, but a previous version of this
+  // code allocated storage with "new Element[size]" and some code uses
+  // RepeatedField with non-POD types, relying on constructor invocation. If
+  // Element has a trivial constructor (e.g., int32_t), gcc (tested with -O2)
+  // completely removes this loop because the loop body is empty, so this has no
+  // effect unless its side-effects are required for correctness.
+  // Note that we do this before MoveArray() below because Element's copy
+  // assignment implementation will want an initialized instance first.
+  Element* e = &elements()[0];
+  Element* limit = e + total_size_;
+  for (; e < limit; e++) {
+    new (e) Element;
+  }
+  if (current_size_ > 0) {
+    MoveArray(&elements()[0], old_rep->elements(), current_size_);
+  }
+
+  // Likewise, we need to invoke destructors on the old array.
+  InternalDeallocate(old_rep, old_total_size, false);
+
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Truncate(int new_size) {
+  GOOGLE_DCHECK_LE(new_size, current_size_);
+  if (current_size_ > 0) {
+    current_size_ = new_size;
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::MoveArray(Element* to, Element* from,
+                                              int array_size) {
+  CopyArray(to, from, array_size);
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::CopyArray(Element* to, const Element* from,
+                                              int array_size) {
+  internal::ElementCopier<Element>()(to, from, array_size);
+}
+
+namespace internal {
+
+template <typename Element, bool HasTrivialCopy>
+void ElementCopier<Element, HasTrivialCopy>::operator()(Element* to,
+                                                        const Element* from,
+                                                        int array_size) {
+  std::copy(from, from + array_size, to);
+}
+
+template <typename Element>
+struct ElementCopier<Element, true> {
+  void operator()(Element* to, const Element* from, int array_size) {
+    memcpy(to, from, static_cast<size_t>(array_size) * sizeof(Element));
+  }
+};
+
+}  // namespace internal
+
+
+// -------------------------------------------------------------------
+
+// Iterators and helper functions that follow the spirit of the STL
+// std::back_insert_iterator and std::back_inserter but are tailor-made
+// for RepeatedField and RepeatedPtrField. Typical usage would be:
+//
+//   std::copy(some_sequence.begin(), some_sequence.end(),
+//             RepeatedFieldBackInserter(proto.mutable_sequence()));
+//
+// Ported by johannes from util/gtl/proto-array-iterators.h
+
+namespace internal {
+
+// STL-like iterator implementation for RepeatedField.  You should not
+// refer to this class directly; use RepeatedField<T>::iterator instead.
+//
+// Note: All of the iterator operators *must* be inlined to avoid performance
+// regressions.  This is caused by the extern template declarations below (which
+// are required because of the RepeatedField extern template declarations).  If
+// any of these functions aren't explicitly inlined (e.g. defined in the class),
+// the compiler isn't allowed to inline them.
+template <typename Element>
+class RepeatedIterator {
+ public:
+  using iterator_category = std::random_access_iterator_tag;
+  // Note: remove_const is necessary for std::partial_sum, which uses value_type
+  // to determine the summation variable type.
+  using value_type = typename std::remove_const<Element>::type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = Element*;
+  using reference = Element&;
+
+  constexpr RepeatedIterator() noexcept : it_(nullptr) {}
+
+  // Allows "upcasting" from RepeatedIterator<T**> to
+  // RepeatedIterator<const T*const*>.
+  template <typename OtherElement,
+            typename std::enable_if<std::is_convertible<
+                OtherElement*, pointer>::value>::type* = nullptr>
+  constexpr RepeatedIterator(
+      const RepeatedIterator<OtherElement>& other) noexcept
+      : it_(other.it_) {}
+
+  // dereferenceable
+  constexpr reference operator*() const noexcept { return *it_; }
+  constexpr pointer operator->() const noexcept { return it_; }
+
+ private:
+  // Helper alias to hide the internal type.
+  using iterator = RepeatedIterator<Element>;
+
+ public:
+  // {inc,dec}rementable
+  iterator& operator++() noexcept {
+    ++it_;
+    return *this;
+  }
+  iterator operator++(int) noexcept { return iterator(it_++); }
+  iterator& operator--() noexcept {
+    --it_;
+    return *this;
+  }
+  iterator operator--(int) noexcept { return iterator(it_--); }
+
+  // equality_comparable
+  friend constexpr bool operator==(const iterator& x,
+                                   const iterator& y) noexcept {
+    return x.it_ == y.it_;
+  }
+  friend constexpr bool operator!=(const iterator& x,
+                                   const iterator& y) noexcept {
+    return x.it_ != y.it_;
+  }
+
+  // less_than_comparable
+  friend constexpr bool operator<(const iterator& x,
+                                  const iterator& y) noexcept {
+    return x.it_ < y.it_;
+  }
+  friend constexpr bool operator<=(const iterator& x,
+                                   const iterator& y) noexcept {
+    return x.it_ <= y.it_;
+  }
+  friend constexpr bool operator>(const iterator& x,
+                                  const iterator& y) noexcept {
+    return x.it_ > y.it_;
+  }
+  friend constexpr bool operator>=(const iterator& x,
+                                   const iterator& y) noexcept {
+    return x.it_ >= y.it_;
+  }
+
+  // addable, subtractable
+  iterator& operator+=(difference_type d) noexcept {
+    it_ += d;
+    return *this;
+  }
+  constexpr iterator operator+(difference_type d) const noexcept {
+    return iterator(it_ + d);
+  }
+  friend constexpr iterator operator+(const difference_type d,
+                                      iterator it) noexcept {
+    return it + d;
+  }
+
+  iterator& operator-=(difference_type d) noexcept {
+    it_ -= d;
+    return *this;
+  }
+  iterator constexpr operator-(difference_type d) const noexcept {
+    return iterator(it_ - d);
+  }
+
+  // indexable
+  constexpr reference operator[](difference_type d) const noexcept {
+    return it_[d];
+  }
+
+  // random access iterator
+  friend constexpr difference_type operator-(iterator it1,
+                                             iterator it2) noexcept {
+    return it1.it_ - it2.it_;
+  }
+
+ private:
+  template <typename OtherElement>
+  friend class RepeatedIterator;
+
+  // Allow construction from RepeatedField.
+  friend class RepeatedField<value_type>;
+  explicit RepeatedIterator(Element* it) noexcept : it_(it) {}
+
+  // The internal iterator.
+  Element* it_;
+};
+
+// A back inserter for RepeatedField objects.
+template <typename T>
+class RepeatedFieldBackInsertIterator {
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = T;
+  using pointer = void;
+  using reference = void;
+  using difference_type = std::ptrdiff_t;
+
+  explicit RepeatedFieldBackInsertIterator(
+      RepeatedField<T>* const mutable_field)
+      : field_(mutable_field) {}
+  RepeatedFieldBackInsertIterator<T>& operator=(const T& value) {
+    field_->Add(value);
+    return *this;
+  }
+  RepeatedFieldBackInsertIterator<T>& operator*() { return *this; }
+  RepeatedFieldBackInsertIterator<T>& operator++() { return *this; }
+  RepeatedFieldBackInsertIterator<T>& operator++(int /* unused */) {
+    return *this;
+  }
+
+ private:
+  RepeatedField<T>* field_;
+};
+
+}  // namespace internal
+
+// Provides a back insert iterator for RepeatedField instances,
+// similar to std::back_inserter().
+template <typename T>
+internal::RepeatedFieldBackInsertIterator<T> RepeatedFieldBackInserter(
+    RepeatedField<T>* const mutable_field) {
+  return internal::RepeatedFieldBackInsertIterator<T>(mutable_field);
+}
+
+// Extern declarations of common instantiations to reduce library bloat.
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<bool>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<int32_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<uint32_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<int64_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<uint64_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<float>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<double>;
+
+namespace internal {
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<bool>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+    RepeatedIterator<int32_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+    RepeatedIterator<uint32_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+    RepeatedIterator<int64_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+    RepeatedIterator<uint64_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<float>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<double>;
+}  // namespace internal
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_REPEATED_FIELD_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.h b/CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.h
new file mode 100644
index 0000000..401230b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.h
@@ -0,0 +1,1970 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// RepeatedField and RepeatedPtrField are used by generated protocol message
+// classes to manipulate repeated fields.  These classes are very similar to
+// STL's vector, but include a number of optimizations found to be useful
+// specifically in the case of Protocol Buffers.  RepeatedPtrField is
+// particularly different from STL vector as it manages ownership of the
+// pointers that it contains.
+//
+// This header covers RepeatedPtrField.
+
+// IWYU pragma: private, include "net/proto2/public/repeated_field.h"
+
+#ifndef GOOGLE_PROTOBUF_REPEATED_PTR_FIELD_H__
+#define GOOGLE_PROTOBUF_REPEATED_PTR_FIELD_H__
+
+#include <utility>
+
+#ifdef _MSC_VER
+// This is required for min/max on VS2013 only.
+#include <algorithm>
+#endif
+
+#include <iterator>
+#include <limits>
+#include <string>
+#include <type_traits>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/message_lite.h>
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+class Message;
+class Reflection;
+
+template <typename T>
+struct WeakRepeatedPtrField;
+
+namespace internal {
+
+class MergePartialFromCodedStreamHelper;
+class SwapFieldHelper;
+
+
+}  // namespace internal
+
+namespace internal {
+template <typename It>
+class RepeatedPtrIterator;
+template <typename It, typename VoidPtr>
+class RepeatedPtrOverPtrsIterator;
+}  // namespace internal
+
+namespace internal {
+
+// type-traits helper for RepeatedPtrFieldBase: we only want to invoke
+// arena-related "copy if on different arena" behavior if the necessary methods
+// exist on the contained type. In particular, we rely on MergeFrom() existing
+// as a general proxy for the fact that a copy will work, and we also provide a
+// specific override for std::string*.
+template <typename T>
+struct TypeImplementsMergeBehaviorProbeForMergeFrom {
+  typedef char HasMerge;
+  typedef long HasNoMerge;
+
+  // We accept either of:
+  // - void MergeFrom(const T& other)
+  // - bool MergeFrom(const T& other)
+  //
+  // We mangle these names a bit to avoid compatibility issues in 'unclean'
+  // include environments that may have, e.g., "#define test ..." (yes, this
+  // exists).
+  template <typename U, typename RetType, RetType (U::*)(const U& arg)>
+  struct CheckType;
+  template <typename U>
+  static HasMerge Check(CheckType<U, void, &U::MergeFrom>*);
+  template <typename U>
+  static HasMerge Check(CheckType<U, bool, &U::MergeFrom>*);
+  template <typename U>
+  static HasNoMerge Check(...);
+
+  // Resolves to either std::true_type or std::false_type.
+  typedef std::integral_constant<bool,
+                                 (sizeof(Check<T>(0)) == sizeof(HasMerge))>
+      type;
+};
+
+template <typename T, typename = void>
+struct TypeImplementsMergeBehavior
+    : TypeImplementsMergeBehaviorProbeForMergeFrom<T> {};
+
+
+template <>
+struct TypeImplementsMergeBehavior<std::string> {
+  typedef std::true_type type;
+};
+
+template <typename T>
+struct IsMovable
+    : std::integral_constant<bool, std::is_move_constructible<T>::value &&
+                                       std::is_move_assignable<T>::value> {};
+
+// This is the common base class for RepeatedPtrFields.  It deals only in void*
+// pointers.  Users should not use this interface directly.
+//
+// The methods of this interface correspond to the methods of RepeatedPtrField,
+// but may have a template argument called TypeHandler.  Its signature is:
+//   class TypeHandler {
+//    public:
+//     typedef MyType Type;
+//     static Type* New();
+//     static Type* NewFromPrototype(const Type* prototype,
+//                                       Arena* arena);
+//     static void Delete(Type*);
+//     static void Clear(Type*);
+//     static void Merge(const Type& from, Type* to);
+//
+//     // Only needs to be implemented if SpaceUsedExcludingSelf() is called.
+//     static int SpaceUsedLong(const Type&);
+//   };
+class PROTOBUF_EXPORT RepeatedPtrFieldBase {
+ protected:
+  constexpr RepeatedPtrFieldBase()
+      : arena_(nullptr), current_size_(0), total_size_(0), rep_(nullptr) {}
+  explicit RepeatedPtrFieldBase(Arena* arena)
+      : arena_(arena), current_size_(0), total_size_(0), rep_(nullptr) {}
+
+  RepeatedPtrFieldBase(const RepeatedPtrFieldBase&) = delete;
+  RepeatedPtrFieldBase& operator=(const RepeatedPtrFieldBase&) = delete;
+
+  ~RepeatedPtrFieldBase() {
+#ifndef NDEBUG
+    // Try to trigger segfault / asan failure in non-opt builds. If arena_
+    // lifetime has ended before the destructor.
+    if (arena_) (void)arena_->SpaceAllocated();
+#endif
+  }
+
+  bool empty() const { return current_size_ == 0; }
+  int size() const { return current_size_; }
+  int Capacity() const { return total_size_; }
+
+  template <typename TypeHandler>
+  const typename TypeHandler::Type& at(int index) const {
+    GOOGLE_CHECK_GE(index, 0);
+    GOOGLE_CHECK_LT(index, current_size_);
+    return *cast<TypeHandler>(rep_->elements[index]);
+  }
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type& at(int index) {
+    GOOGLE_CHECK_GE(index, 0);
+    GOOGLE_CHECK_LT(index, current_size_);
+    return *cast<TypeHandler>(rep_->elements[index]);
+  }
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type* Mutable(int index) {
+    GOOGLE_DCHECK_GE(index, 0);
+    GOOGLE_DCHECK_LT(index, current_size_);
+    return cast<TypeHandler>(rep_->elements[index]);
+  }
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type* Add(
+      const typename TypeHandler::Type* prototype = nullptr) {
+    if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
+      return cast<TypeHandler>(rep_->elements[current_size_++]);
+    }
+    typename TypeHandler::Type* result =
+        TypeHandler::NewFromPrototype(prototype, arena_);
+    return reinterpret_cast<typename TypeHandler::Type*>(
+        AddOutOfLineHelper(result));
+  }
+
+  template <
+      typename TypeHandler,
+      typename std::enable_if<TypeHandler::Movable::value>::type* = nullptr>
+  inline void Add(typename TypeHandler::Type&& value) {
+    if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
+      *cast<TypeHandler>(rep_->elements[current_size_++]) = std::move(value);
+      return;
+    }
+    if (!rep_ || rep_->allocated_size == total_size_) {
+      Reserve(total_size_ + 1);
+    }
+    ++rep_->allocated_size;
+    typename TypeHandler::Type* result =
+        TypeHandler::New(arena_, std::move(value));
+    rep_->elements[current_size_++] = result;
+  }
+
+  template <typename TypeHandler>
+  void Delete(int index) {
+    GOOGLE_DCHECK_GE(index, 0);
+    GOOGLE_DCHECK_LT(index, current_size_);
+    TypeHandler::Delete(cast<TypeHandler>(rep_->elements[index]), arena_);
+  }
+
+  // Must be called from destructor.
+  template <typename TypeHandler>
+  void Destroy() {
+    if (rep_ != nullptr && arena_ == nullptr) {
+      int n = rep_->allocated_size;
+      void* const* elements = rep_->elements;
+      for (int i = 0; i < n; i++) {
+        TypeHandler::Delete(cast<TypeHandler>(elements[i]), nullptr);
+      }
+      const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
+      internal::SizedDelete(rep_, size);
+    }
+    rep_ = nullptr;
+  }
+
+  bool NeedsDestroy() const { return rep_ != nullptr && arena_ == nullptr; }
+  void DestroyProtos();  // implemented in the cc file
+
+ public:
+  // The next few methods are public so that they can be called from generated
+  // code when implicit weak fields are used, but they should never be called by
+  // application code.
+
+  template <typename TypeHandler>
+  const typename TypeHandler::Type& Get(int index) const {
+    GOOGLE_DCHECK_GE(index, 0);
+    GOOGLE_DCHECK_LT(index, current_size_);
+    return *cast<TypeHandler>(rep_->elements[index]);
+  }
+
+  // Creates and adds an element using the given prototype, without introducing
+  // a link-time dependency on the concrete message type. This method is used to
+  // implement implicit weak fields. The prototype may be nullptr, in which case
+  // an ImplicitWeakMessage will be used as a placeholder.
+  MessageLite* AddWeak(const MessageLite* prototype);
+
+  template <typename TypeHandler>
+  void Clear() {
+    const int n = current_size_;
+    GOOGLE_DCHECK_GE(n, 0);
+    if (n > 0) {
+      void* const* elements = rep_->elements;
+      int i = 0;
+      do {
+        TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
+      } while (i < n);
+      current_size_ = 0;
+    }
+  }
+
+  template <typename TypeHandler>
+  void MergeFrom(const RepeatedPtrFieldBase& other) {
+    // To avoid unnecessary code duplication and reduce binary size, we use a
+    // layered approach to implementing MergeFrom(). The toplevel method is
+    // templated, so we get a small thunk per concrete message type in the
+    // binary. This calls a shared implementation with most of the logic,
+    // passing a function pointer to another type-specific piece of code that
+    // calls the object-allocate and merge handlers.
+    GOOGLE_DCHECK_NE(&other, this);
+    if (other.current_size_ == 0) return;
+    MergeFromInternal(other,
+                      &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
+  }
+
+  inline void InternalSwap(RepeatedPtrFieldBase* rhs) {
+    GOOGLE_DCHECK(this != rhs);
+
+    // Swap all fields at once.
+    auto temp = std::make_tuple(rhs->arena_, rhs->current_size_,
+                                rhs->total_size_, rhs->rep_);
+    std::tie(rhs->arena_, rhs->current_size_, rhs->total_size_, rhs->rep_) =
+        std::make_tuple(arena_, current_size_, total_size_, rep_);
+    std::tie(arena_, current_size_, total_size_, rep_) = temp;
+  }
+
+ protected:
+  template <typename TypeHandler>
+  void RemoveLast() {
+    GOOGLE_DCHECK_GT(current_size_, 0);
+    TypeHandler::Clear(cast<TypeHandler>(rep_->elements[--current_size_]));
+  }
+
+  template <typename TypeHandler>
+  void CopyFrom(const RepeatedPtrFieldBase& other) {
+    if (&other == this) return;
+    RepeatedPtrFieldBase::Clear<TypeHandler>();
+    RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
+  }
+
+  void CloseGap(int start, int num);  // implemented in the cc file
+
+  void Reserve(int new_size);  // implemented in the cc file
+
+  template <typename TypeHandler>
+  static inline typename TypeHandler::Type* copy(
+      typename TypeHandler::Type* value) {
+    auto* new_value = TypeHandler::NewFromPrototype(value, nullptr);
+    TypeHandler::Merge(*value, new_value);
+    return new_value;
+  }
+
+  // Used for constructing iterators.
+  void* const* raw_data() const { return rep_ ? rep_->elements : nullptr; }
+  void** raw_mutable_data() const {
+    return rep_ ? const_cast<void**>(rep_->elements) : nullptr;
+  }
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type** mutable_data() {
+    // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
+    //   method entirely.
+    return reinterpret_cast<typename TypeHandler::Type**>(raw_mutable_data());
+  }
+
+  template <typename TypeHandler>
+  const typename TypeHandler::Type* const* data() const {
+    // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
+    //   method entirely.
+    return reinterpret_cast<const typename TypeHandler::Type* const*>(
+        raw_data());
+  }
+
+  template <typename TypeHandler>
+  PROTOBUF_NDEBUG_INLINE void Swap(RepeatedPtrFieldBase* other) {
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena())
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena())
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+    {
+      InternalSwap(other);
+    } else {
+      SwapFallback<TypeHandler>(other);
+    }
+  }
+
+  void SwapElements(int index1, int index2) {
+    using std::swap;  // enable ADL with fallback
+    swap(rep_->elements[index1], rep_->elements[index2]);
+  }
+
+  template <typename TypeHandler>
+  size_t SpaceUsedExcludingSelfLong() const {
+    size_t allocated_bytes = static_cast<size_t>(total_size_) * sizeof(void*);
+    if (rep_ != nullptr) {
+      for (int i = 0; i < rep_->allocated_size; ++i) {
+        allocated_bytes +=
+            TypeHandler::SpaceUsedLong(*cast<TypeHandler>(rep_->elements[i]));
+      }
+      allocated_bytes += kRepHeaderSize;
+    }
+    return allocated_bytes;
+  }
+
+  // Advanced memory management --------------------------------------
+
+  // Like Add(), but if there are no cleared objects to use, returns nullptr.
+  template <typename TypeHandler>
+  typename TypeHandler::Type* AddFromCleared() {
+    if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
+      return cast<TypeHandler>(rep_->elements[current_size_++]);
+    } else {
+      return nullptr;
+    }
+  }
+
+  template <typename TypeHandler>
+  void AddAllocated(typename TypeHandler::Type* value) {
+    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
+    AddAllocatedInternal<TypeHandler>(value, t);
+  }
+
+  template <typename TypeHandler>
+  void UnsafeArenaAddAllocated(typename TypeHandler::Type* value) {
+    // Make room for the new pointer.
+    if (!rep_ || current_size_ == total_size_) {
+      // The array is completely full with no cleared objects, so grow it.
+      Reserve(total_size_ + 1);
+      ++rep_->allocated_size;
+    } else if (rep_->allocated_size == total_size_) {
+      // There is no more space in the pointer array because it contains some
+      // cleared objects awaiting reuse.  We don't want to grow the array in
+      // this case because otherwise a loop calling AddAllocated() followed by
+      // Clear() would leak memory.
+      TypeHandler::Delete(cast<TypeHandler>(rep_->elements[current_size_]),
+                          arena_);
+    } else if (current_size_ < rep_->allocated_size) {
+      // We have some cleared objects.  We don't care about their order, so we
+      // can just move the first one to the end to make space.
+      rep_->elements[rep_->allocated_size] = rep_->elements[current_size_];
+      ++rep_->allocated_size;
+    } else {
+      // There are no cleared objects.
+      ++rep_->allocated_size;
+    }
+
+    rep_->elements[current_size_++] = value;
+  }
+
+  template <typename TypeHandler>
+  PROTOBUF_NODISCARD typename TypeHandler::Type* ReleaseLast() {
+    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
+    return ReleaseLastInternal<TypeHandler>(t);
+  }
+
+  // Releases and returns the last element, but does not do out-of-arena copy.
+  // Instead, just returns the raw pointer to the contained element in the
+  // arena.
+  template <typename TypeHandler>
+  typename TypeHandler::Type* UnsafeArenaReleaseLast() {
+    GOOGLE_DCHECK_GT(current_size_, 0);
+    typename TypeHandler::Type* result =
+        cast<TypeHandler>(rep_->elements[--current_size_]);
+    --rep_->allocated_size;
+    if (current_size_ < rep_->allocated_size) {
+      // There are cleared elements on the end; replace the removed element
+      // with the last allocated element.
+      rep_->elements[current_size_] = rep_->elements[rep_->allocated_size];
+    }
+    return result;
+  }
+
+  int ClearedCount() const {
+    return rep_ ? (rep_->allocated_size - current_size_) : 0;
+  }
+
+  template <typename TypeHandler>
+  void AddCleared(typename TypeHandler::Type* value) {
+    GOOGLE_DCHECK(GetOwningArena() == nullptr) << "AddCleared() can only be used on a "
+                                           "RepeatedPtrField not on an arena.";
+    GOOGLE_DCHECK(TypeHandler::GetOwningArena(value) == nullptr)
+        << "AddCleared() can only accept values not on an arena.";
+    if (!rep_ || rep_->allocated_size == total_size_) {
+      Reserve(total_size_ + 1);
+    }
+    rep_->elements[rep_->allocated_size++] = value;
+  }
+
+  template <typename TypeHandler>
+  PROTOBUF_NODISCARD typename TypeHandler::Type* ReleaseCleared() {
+    GOOGLE_DCHECK(GetOwningArena() == nullptr)
+        << "ReleaseCleared() can only be used on a RepeatedPtrField not on "
+        << "an arena.";
+    GOOGLE_DCHECK(GetOwningArena() == nullptr);
+    GOOGLE_DCHECK(rep_ != nullptr);
+    GOOGLE_DCHECK_GT(rep_->allocated_size, current_size_);
+    return cast<TypeHandler>(rep_->elements[--rep_->allocated_size]);
+  }
+
+  template <typename TypeHandler>
+  void AddAllocatedInternal(typename TypeHandler::Type* value, std::true_type) {
+    // AddAllocated version that implements arena-safe copying behavior.
+    Arena* element_arena =
+        reinterpret_cast<Arena*>(TypeHandler::GetOwningArena(value));
+    Arena* arena = GetOwningArena();
+    if (arena == element_arena && rep_ && rep_->allocated_size < total_size_) {
+      // Fast path: underlying arena representation (tagged pointer) is equal to
+      // our arena pointer, and we can add to array without resizing it (at
+      // least one slot that is not allocated).
+      void** elems = rep_->elements;
+      if (current_size_ < rep_->allocated_size) {
+        // Make space at [current] by moving first allocated element to end of
+        // allocated list.
+        elems[rep_->allocated_size] = elems[current_size_];
+      }
+      elems[current_size_] = value;
+      current_size_ = current_size_ + 1;
+      rep_->allocated_size = rep_->allocated_size + 1;
+    } else {
+      AddAllocatedSlowWithCopy<TypeHandler>(value, element_arena, arena);
+    }
+  }
+
+  template <typename TypeHandler>
+  void AddAllocatedInternal(
+      // AddAllocated version that does not implement arena-safe copying
+      // behavior.
+      typename TypeHandler::Type* value, std::false_type) {
+    if (rep_ && rep_->allocated_size < total_size_) {
+      // Fast path: underlying arena representation (tagged pointer) is equal to
+      // our arena pointer, and we can add to array without resizing it (at
+      // least one slot that is not allocated).
+      void** elems = rep_->elements;
+      if (current_size_ < rep_->allocated_size) {
+        // Make space at [current] by moving first allocated element to end of
+        // allocated list.
+        elems[rep_->allocated_size] = elems[current_size_];
+      }
+      elems[current_size_] = value;
+      current_size_ = current_size_ + 1;
+      ++rep_->allocated_size;
+    } else {
+      UnsafeArenaAddAllocated<TypeHandler>(value);
+    }
+  }
+
+  // Slowpath handles all cases, copying if necessary.
+  template <typename TypeHandler>
+  PROTOBUF_NOINLINE void AddAllocatedSlowWithCopy(
+      // Pass value_arena and my_arena to avoid duplicate virtual call (value)
+      // or load (mine).
+      typename TypeHandler::Type* value, Arena* value_arena, Arena* my_arena) {
+    // Ensure that either the value is in the same arena, or if not, we do the
+    // appropriate thing: Own() it (if it's on heap and we're in an arena) or
+    // copy it to our arena/heap (otherwise).
+    if (my_arena != nullptr && value_arena == nullptr) {
+      my_arena->Own(value);
+    } else if (my_arena != value_arena) {
+      typename TypeHandler::Type* new_value =
+          TypeHandler::NewFromPrototype(value, my_arena);
+      TypeHandler::Merge(*value, new_value);
+      TypeHandler::Delete(value, value_arena);
+      value = new_value;
+    }
+
+    UnsafeArenaAddAllocated<TypeHandler>(value);
+  }
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type* ReleaseLastInternal(std::true_type) {
+    // ReleaseLast() for types that implement merge/copy behavior.
+    // First, release an element.
+    typename TypeHandler::Type* result = UnsafeArenaReleaseLast<TypeHandler>();
+    // Now perform a copy if we're on an arena.
+    Arena* arena = GetOwningArena();
+
+    typename TypeHandler::Type* new_result;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+    new_result = copy<TypeHandler>(result);
+    if (arena == nullptr) delete result;
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    new_result = (arena == nullptr) ? result : copy<TypeHandler>(result);
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return new_result;
+  }
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type* ReleaseLastInternal(std::false_type) {
+    // ReleaseLast() for types that *do not* implement merge/copy behavior --
+    // this is the same as UnsafeArenaReleaseLast(). Note that we GOOGLE_DCHECK-fail if
+    // we're on an arena, since the user really should implement the copy
+    // operation in this case.
+    GOOGLE_DCHECK(GetOwningArena() == nullptr)
+        << "ReleaseLast() called on a RepeatedPtrField that is on an arena, "
+        << "with a type that does not implement MergeFrom. This is unsafe; "
+        << "please implement MergeFrom for your type.";
+    return UnsafeArenaReleaseLast<TypeHandler>();
+  }
+
+  template <typename TypeHandler>
+  PROTOBUF_NOINLINE void SwapFallback(RepeatedPtrFieldBase* other) {
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    GOOGLE_DCHECK(GetOwningArena() == nullptr ||
+           other->GetOwningArena() != GetOwningArena());
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+    GOOGLE_DCHECK(other->GetOwningArena() != GetOwningArena());
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+
+    // Copy semantics in this case. We try to improve efficiency by placing the
+    // temporary on |other|'s arena so that messages are copied twice rather
+    // than three times.
+    RepeatedPtrFieldBase temp(other->GetOwningArena());
+    temp.MergeFrom<TypeHandler>(*this);
+    this->Clear<TypeHandler>();
+    this->MergeFrom<TypeHandler>(*other);
+    other->InternalSwap(&temp);
+    temp.Destroy<TypeHandler>();  // Frees rep_ if `other` had no arena.
+  }
+
+  inline Arena* GetArena() const { return arena_; }
+
+ protected:
+  inline Arena* GetOwningArena() const { return arena_; }
+
+ private:
+  template <typename T> friend class Arena::InternalHelper;
+
+  static constexpr int kInitialSize = 0;
+  // A few notes on internal representation:
+  //
+  // We use an indirected approach, with struct Rep, to keep
+  // sizeof(RepeatedPtrFieldBase) equivalent to what it was before arena support
+  // was added; namely, 3 8-byte machine words on x86-64. An instance of Rep is
+  // allocated only when the repeated field is non-empty, and it is a
+  // dynamically-sized struct (the header is directly followed by elements[]).
+  // We place arena_ and current_size_ directly in the object to avoid cache
+  // misses due to the indirection, because these fields are checked frequently.
+  // Placing all fields directly in the RepeatedPtrFieldBase instance would cost
+  // significant performance for memory-sensitive workloads.
+  Arena* arena_;
+  int current_size_;
+  int total_size_;
+  struct Rep {
+    int allocated_size;
+    // Here we declare a huge array as a way of approximating C's "flexible
+    // array member" feature without relying on undefined behavior.
+    void* elements[(std::numeric_limits<int>::max() - 2 * sizeof(int)) /
+                   sizeof(void*)];
+  };
+  static constexpr size_t kRepHeaderSize = offsetof(Rep, elements);
+  Rep* rep_;
+
+  template <typename TypeHandler>
+  static inline typename TypeHandler::Type* cast(void* element) {
+    return reinterpret_cast<typename TypeHandler::Type*>(element);
+  }
+  template <typename TypeHandler>
+  static inline const typename TypeHandler::Type* cast(const void* element) {
+    return reinterpret_cast<const typename TypeHandler::Type*>(element);
+  }
+
+  // Non-templated inner function to avoid code duplication. Takes a function
+  // pointer to the type-specific (templated) inner allocate/merge loop.
+  void MergeFromInternal(const RepeatedPtrFieldBase& other,
+                         void (RepeatedPtrFieldBase::*inner_loop)(void**,
+                                                                  void**, int,
+                                                                  int)) {
+    // Note: wrapper has already guaranteed that other.rep_ != nullptr here.
+    int other_size = other.current_size_;
+    void** other_elements = other.rep_->elements;
+    void** new_elements = InternalExtend(other_size);
+    int allocated_elems = rep_->allocated_size - current_size_;
+    (this->*inner_loop)(new_elements, other_elements, other_size,
+                        allocated_elems);
+    current_size_ += other_size;
+    if (rep_->allocated_size < current_size_) {
+      rep_->allocated_size = current_size_;
+    }
+  }
+
+  // Merges other_elems to our_elems.
+  template <typename TypeHandler>
+  PROTOBUF_NOINLINE void MergeFromInnerLoop(void** our_elems,
+                                            void** other_elems, int length,
+                                            int already_allocated) {
+    if (already_allocated < length) {
+      Arena* arena = GetOwningArena();
+      typename TypeHandler::Type* elem_prototype =
+          reinterpret_cast<typename TypeHandler::Type*>(other_elems[0]);
+      for (int i = already_allocated; i < length; i++) {
+        // Allocate a new empty element that we'll merge into below
+        typename TypeHandler::Type* new_elem =
+            TypeHandler::NewFromPrototype(elem_prototype, arena);
+        our_elems[i] = new_elem;
+      }
+    }
+    // Main loop that does the actual merging
+    for (int i = 0; i < length; i++) {
+      // Already allocated: use existing element.
+      typename TypeHandler::Type* other_elem =
+          reinterpret_cast<typename TypeHandler::Type*>(other_elems[i]);
+      typename TypeHandler::Type* new_elem =
+          reinterpret_cast<typename TypeHandler::Type*>(our_elems[i]);
+      TypeHandler::Merge(*other_elem, new_elem);
+    }
+  }
+
+  // Internal helper: extends array space if necessary to contain
+  // |extend_amount| more elements, and returns a pointer to the element
+  // immediately following the old list of elements.  This interface factors out
+  // common behavior from Reserve() and MergeFrom() to reduce code size.
+  // |extend_amount| must be > 0.
+  void** InternalExtend(int extend_amount);
+
+  // Internal helper for Add: adds "obj" as the next element in the
+  // array, including potentially resizing the array with Reserve if
+  // needed
+  void* AddOutOfLineHelper(void* obj);
+
+  // The reflection implementation needs to call protected methods directly,
+  // reinterpreting pointers as being to Message instead of a specific Message
+  // subclass.
+  friend class ::PROTOBUF_NAMESPACE_ID::Reflection;
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::SwapFieldHelper;
+
+  // ExtensionSet stores repeated message extensions as
+  // RepeatedPtrField<MessageLite>, but non-lite ExtensionSets need to implement
+  // SpaceUsedLong(), and thus need to call SpaceUsedExcludingSelfLong()
+  // reinterpreting MessageLite as Message.  ExtensionSet also needs to make use
+  // of AddFromCleared(), which is not part of the public interface.
+  friend class ExtensionSet;
+
+  // The MapFieldBase implementation needs to call protected methods directly,
+  // reinterpreting pointers as being to Message instead of a specific Message
+  // subclass.
+  friend class MapFieldBase;
+  friend class MapFieldBaseStub;
+
+  // The table-driven MergePartialFromCodedStream implementation needs to
+  // operate on RepeatedPtrField<MessageLite>.
+  friend class MergePartialFromCodedStreamHelper;
+  friend class AccessorHelper;
+  template <typename T>
+  friend struct google::protobuf::WeakRepeatedPtrField;
+  friend class internal::TcParser;  // TODO(jorg): Remove this friend.
+};
+
+template <typename GenericType>
+class GenericTypeHandler {
+ public:
+  typedef GenericType Type;
+  using Movable = IsMovable<GenericType>;
+
+  static inline GenericType* New(Arena* arena) {
+    return Arena::CreateMaybeMessage<Type>(arena);
+  }
+  static inline GenericType* New(Arena* arena, GenericType&& value) {
+    return Arena::Create<GenericType>(arena, std::move(value));
+  }
+  static inline GenericType* NewFromPrototype(const GenericType* /*prototype*/,
+                                              Arena* arena = nullptr) {
+    return New(arena);
+  }
+  static inline void Delete(GenericType* value, Arena* arena) {
+    if (arena == nullptr) {
+      delete value;
+    }
+  }
+  static inline Arena* GetOwningArena(GenericType* value) {
+    return Arena::GetOwningArena<Type>(value);
+  }
+
+  static inline void Clear(GenericType* value) { value->Clear(); }
+  static void Merge(const GenericType& from, GenericType* to);
+  static inline size_t SpaceUsedLong(const GenericType& value) {
+    return value.SpaceUsedLong();
+  }
+};
+
+// NewFromPrototypeHelper() is not defined inline here, as we will need to do a
+// virtual function dispatch anyways to go from Message* to call New/Merge. (The
+// additional helper is needed as a workaround for MSVC.)
+MessageLite* NewFromPrototypeHelper(const MessageLite* prototype, Arena* arena);
+
+template <>
+inline MessageLite* GenericTypeHandler<MessageLite>::NewFromPrototype(
+    const MessageLite* prototype, Arena* arena) {
+  return NewFromPrototypeHelper(prototype, arena);
+}
+template <>
+inline Arena* GenericTypeHandler<MessageLite>::GetOwningArena(
+    MessageLite* value) {
+  return value->GetOwningArena();
+}
+
+template <typename GenericType>
+PROTOBUF_NOINLINE inline void GenericTypeHandler<GenericType>::Merge(
+    const GenericType& from, GenericType* to) {
+  to->MergeFrom(from);
+}
+template <>
+void GenericTypeHandler<MessageLite>::Merge(const MessageLite& from,
+                                            MessageLite* to);
+
+template <>
+inline void GenericTypeHandler<std::string>::Clear(std::string* value) {
+  value->clear();
+}
+template <>
+void GenericTypeHandler<std::string>::Merge(const std::string& from,
+                                            std::string* to);
+
+// Message specialization bodies defined in message.cc. This split is necessary
+// to allow proto2-lite (which includes this header) to be independent of
+// Message.
+template <>
+PROTOBUF_EXPORT Message* GenericTypeHandler<Message>::NewFromPrototype(
+    const Message* prototype, Arena* arena);
+template <>
+PROTOBUF_EXPORT Arena* GenericTypeHandler<Message>::GetOwningArena(
+    Message* value);
+
+class StringTypeHandler {
+ public:
+  typedef std::string Type;
+  using Movable = IsMovable<Type>;
+
+  static inline std::string* New(Arena* arena) {
+    return Arena::Create<std::string>(arena);
+  }
+  static inline std::string* New(Arena* arena, std::string&& value) {
+    return Arena::Create<std::string>(arena, std::move(value));
+  }
+  static inline std::string* NewFromPrototype(const std::string*,
+                                              Arena* arena) {
+    return New(arena);
+  }
+  static inline Arena* GetOwningArena(std::string*) { return nullptr; }
+  static inline void Delete(std::string* value, Arena* arena) {
+    if (arena == nullptr) {
+      delete value;
+    }
+  }
+  static inline void Clear(std::string* value) { value->clear(); }
+  static inline void Merge(const std::string& from, std::string* to) {
+    *to = from;
+  }
+  static size_t SpaceUsedLong(const std::string& value) {
+    return sizeof(value) + StringSpaceUsedExcludingSelfLong(value);
+  }
+};
+
+}  // namespace internal
+
+// RepeatedPtrField is like RepeatedField, but used for repeated strings or
+// Messages.
+template <typename Element>
+class RepeatedPtrField final : private internal::RepeatedPtrFieldBase {
+
+ public:
+  constexpr RepeatedPtrField();
+  explicit RepeatedPtrField(Arena* arena);
+
+  RepeatedPtrField(const RepeatedPtrField& other);
+
+  template <typename Iter,
+            typename = typename std::enable_if<std::is_constructible<
+                Element, decltype(*std::declval<Iter>())>::value>::type>
+  RepeatedPtrField(Iter begin, Iter end);
+
+  ~RepeatedPtrField();
+
+  RepeatedPtrField& operator=(const RepeatedPtrField& other);
+
+  RepeatedPtrField(RepeatedPtrField&& other) noexcept;
+  RepeatedPtrField& operator=(RepeatedPtrField&& other) noexcept;
+
+  bool empty() const;
+  int size() const;
+
+  const Element& Get(int index) const;
+  Element* Mutable(int index);
+
+  // Unlike std::vector, adding an element to a RepeatedPtrField doesn't always
+  // make a new element; it might re-use an element left over from when the
+  // field was Clear()'d or reize()'d smaller.  For this reason, Add() is the
+  // fastest API for adding a new element.
+  Element* Add();
+
+  // `Add(std::move(value));` is equivalent to `*Add() = std::move(value);`
+  // It will either move-construct to the end of this field, or swap value
+  // with the new-or-recycled element at the end of this field.  Note that
+  // this operation is very slow if this RepeatedPtrField is not on the
+  // same Arena, if any, as `value`.
+  void Add(Element&& value);
+
+  // Copying to the end of this RepeatedPtrField is slowest of all; it can't
+  // reliably copy-construct to the last element of this RepeatedPtrField, for
+  // example (unlike std::vector).
+  // We currently block this API.  The right way to add to the end is to call
+  // Add() and modify the element it points to.
+  // If you must add an existing value, call `*Add() = value;`
+  void Add(const Element& value) = delete;
+
+  // Append elements in the range [begin, end) after reserving
+  // the appropriate number of elements.
+  template <typename Iter>
+  void Add(Iter begin, Iter end);
+
+  const Element& operator[](int index) const { return Get(index); }
+  Element& operator[](int index) { return *Mutable(index); }
+
+  const Element& at(int index) const;
+  Element& at(int index);
+
+  // Removes the last element in the array.
+  // Ownership of the element is retained by the array.
+  void RemoveLast();
+
+  // Deletes elements with indices in the range [start .. start+num-1].
+  // Caution: moves all elements with indices [start+num .. ].
+  // Calling this routine inside a loop can cause quadratic behavior.
+  void DeleteSubrange(int start, int num);
+
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear();
+  void MergeFrom(const RepeatedPtrField& other);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void CopyFrom(const RepeatedPtrField& other);
+
+  // Replaces the contents with RepeatedPtrField(begin, end).
+  template <typename Iter>
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Assign(Iter begin, Iter end);
+
+  // Reserves space to expand the field to at least the given size.  This only
+  // resizes the pointer array; it doesn't allocate any objects.  If the
+  // array is grown, it will always be at least doubled in size.
+  void Reserve(int new_size);
+
+  int Capacity() const;
+
+  // Gets the underlying array.  This pointer is possibly invalidated by
+  // any add or remove operation.
+  //
+  // This API is deprecated. Instead of directly working with element array,
+  // use APIs in repeated_field_util.h; e.g. sorting, etc.
+  PROTOBUF_DEPRECATED_MSG("Use APIs in repeated_field_util.h")
+  Element** mutable_data();
+  const Element* const* data() const;
+
+  // Swaps entire contents with "other". If they are on separate arenas, then
+  // copies data.
+  void Swap(RepeatedPtrField* other);
+
+  // Swaps entire contents with "other". Caller should guarantee that either
+  // both fields are on the same arena or both are on the heap. Swapping between
+  // different arenas with this function is disallowed and is caught via
+  // GOOGLE_DCHECK.
+  void UnsafeArenaSwap(RepeatedPtrField* other);
+
+  // Swaps two elements.
+  void SwapElements(int index1, int index2);
+
+  // STL-like iterator support
+  typedef internal::RepeatedPtrIterator<Element> iterator;
+  typedef internal::RepeatedPtrIterator<const Element> const_iterator;
+  typedef Element value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef int size_type;
+  typedef ptrdiff_t difference_type;
+
+  iterator begin();
+  const_iterator begin() const;
+  const_iterator cbegin() const;
+  iterator end();
+  const_iterator end() const;
+  const_iterator cend() const;
+
+  // Reverse iterator support
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  // Custom STL-like iterator that iterates over and returns the underlying
+  // pointers to Element rather than Element itself.
+  typedef internal::RepeatedPtrOverPtrsIterator<Element*, void*>
+      pointer_iterator;
+  typedef internal::RepeatedPtrOverPtrsIterator<const Element* const,
+                                                const void* const>
+      const_pointer_iterator;
+  pointer_iterator pointer_begin();
+  const_pointer_iterator pointer_begin() const;
+  pointer_iterator pointer_end();
+  const_pointer_iterator pointer_end() const;
+
+  // Returns (an estimate of) the number of bytes used by the repeated field,
+  // excluding sizeof(*this).
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+  // Advanced memory management --------------------------------------
+  // When hardcore memory management becomes necessary -- as it sometimes
+  // does here at Google -- the following methods may be useful.
+
+  // Adds an already-allocated object, passing ownership to the
+  // RepeatedPtrField.
+  //
+  // Note that some special behavior occurs with respect to arenas:
+  //
+  //   (i) if this field holds submessages, the new submessage will be copied if
+  //   the original is in an arena and this RepeatedPtrField is either in a
+  //   different arena, or on the heap.
+  //   (ii) if this field holds strings, the passed-in string *must* be
+  //   heap-allocated, not arena-allocated. There is no way to dynamically check
+  //   this at runtime, so User Beware.
+  void AddAllocated(Element* value);
+
+  // Removes and returns the last element, passing ownership to the caller.
+  // Requires:  size() > 0
+  //
+  // If this RepeatedPtrField is on an arena, an object copy is required to pass
+  // ownership back to the user (for compatible semantics). Use
+  // UnsafeArenaReleaseLast() if this behavior is undesired.
+  PROTOBUF_NODISCARD Element* ReleaseLast();
+
+  // Adds an already-allocated object, skipping arena-ownership checks. The user
+  // must guarantee that the given object is in the same arena as this
+  // RepeatedPtrField.
+  // It is also useful in legacy code that uses temporary ownership to avoid
+  // copies. Example:
+  //   RepeatedPtrField<T> temp_field;
+  //   temp_field.UnsafeArenaAddAllocated(new T);
+  //   ... // Do something with temp_field
+  //   temp_field.UnsafeArenaExtractSubrange(0, temp_field.size(), nullptr);
+  // If you put temp_field on the arena this fails, because the ownership
+  // transfers to the arena at the "AddAllocated" call and is not released
+  // anymore, causing a double delete. UnsafeArenaAddAllocated prevents this.
+  void UnsafeArenaAddAllocated(Element* value);
+
+  // Removes and returns the last element.  Unlike ReleaseLast, the returned
+  // pointer is always to the original object.  This may be in an arena, in
+  // which case it would have the arena's lifetime.
+  // Requires: current_size_ > 0
+  Element* UnsafeArenaReleaseLast();
+
+  // Extracts elements with indices in the range "[start .. start+num-1]".
+  // The caller assumes ownership of the extracted elements and is responsible
+  // for deleting them when they are no longer needed.
+  // If "elements" is non-nullptr, then pointers to the extracted elements
+  // are stored in "elements[0 .. num-1]" for the convenience of the caller.
+  // If "elements" is nullptr, then the caller must use some other mechanism
+  // to perform any further operations (like deletion) on these elements.
+  // Caution: implementation also moves elements with indices [start+num ..].
+  // Calling this routine inside a loop can cause quadratic behavior.
+  //
+  // Memory copying behavior is identical to ReleaseLast(), described above: if
+  // this RepeatedPtrField is on an arena, an object copy is performed for each
+  // returned element, so that all returned element pointers are to
+  // heap-allocated copies. If this copy is not desired, the user should call
+  // UnsafeArenaExtractSubrange().
+  void ExtractSubrange(int start, int num, Element** elements);
+
+  // Identical to ExtractSubrange() described above, except that no object
+  // copies are ever performed. Instead, the raw object pointers are returned.
+  // Thus, if on an arena, the returned objects must not be freed, because they
+  // will not be heap-allocated objects.
+  void UnsafeArenaExtractSubrange(int start, int num, Element** elements);
+
+  // When elements are removed by calls to RemoveLast() or Clear(), they
+  // are not actually freed.  Instead, they are cleared and kept so that
+  // they can be reused later.  This can save lots of CPU time when
+  // repeatedly reusing a protocol message for similar purposes.
+  //
+  // Hardcore programs may choose to manipulate these cleared objects
+  // to better optimize memory management using the following routines.
+
+  // Gets the number of cleared objects that are currently being kept
+  // around for reuse.
+  int ClearedCount() const;
+#ifndef PROTOBUF_FUTURE_BREAKING_CHANGES
+  // Adds an element to the pool of cleared objects, passing ownership to
+  // the RepeatedPtrField.  The element must be cleared prior to calling
+  // this method.
+  //
+  // This method cannot be called when either the repeated field or |value| is
+  // on an arena; both cases will trigger a GOOGLE_DCHECK-failure.
+  void AddCleared(Element* value);
+  // Removes and returns a single element from the cleared pool, passing
+  // ownership to the caller.  The element is guaranteed to be cleared.
+  // Requires:  ClearedCount() > 0
+  //
+  // This method cannot be called when the repeated field is on an arena; doing
+  // so will trigger a GOOGLE_DCHECK-failure.
+  PROTOBUF_NODISCARD Element* ReleaseCleared();
+#endif  // !PROTOBUF_FUTURE_BREAKING_CHANGES
+
+  // Removes the element referenced by position.
+  //
+  // Returns an iterator to the element immediately following the removed
+  // element.
+  //
+  // Invalidates all iterators at or after the removed element, including end().
+  iterator erase(const_iterator position);
+
+  // Removes the elements in the range [first, last).
+  //
+  // Returns an iterator to the element immediately following the removed range.
+  //
+  // Invalidates all iterators at or after the removed range, including end().
+  iterator erase(const_iterator first, const_iterator last);
+
+  // Gets the arena on which this RepeatedPtrField stores its elements.
+  inline Arena* GetArena() const;
+
+  // For internal use only.
+  //
+  // This is public due to it being called by generated code.
+  void InternalSwap(RepeatedPtrField* other) {
+    internal::RepeatedPtrFieldBase::InternalSwap(other);
+  }
+
+ private:
+  // Note:  RepeatedPtrField SHOULD NOT be subclassed by users.
+  class TypeHandler;
+
+  // Internal version of GetArena().
+  inline Arena* GetOwningArena() const;
+
+  // Implementations for ExtractSubrange(). The copying behavior must be
+  // included only if the type supports the necessary operations (e.g.,
+  // MergeFrom()), so we must resolve this at compile time. ExtractSubrange()
+  // uses SFINAE to choose one of the below implementations.
+  void ExtractSubrangeInternal(int start, int num, Element** elements,
+                               std::true_type);
+  void ExtractSubrangeInternal(int start, int num, Element** elements,
+                               std::false_type);
+
+  friend class Arena;
+
+  template <typename T>
+  friend struct WeakRepeatedPtrField;
+
+  typedef void InternalArenaConstructable_;
+
+};
+
+// -------------------------------------------------------------------
+
+template <typename Element>
+class RepeatedPtrField<Element>::TypeHandler
+    : public internal::GenericTypeHandler<Element> {};
+
+template <>
+class RepeatedPtrField<std::string>::TypeHandler
+    : public internal::StringTypeHandler {};
+
+template <typename Element>
+constexpr RepeatedPtrField<Element>::RepeatedPtrField()
+    : RepeatedPtrFieldBase() {}
+
+template <typename Element>
+inline RepeatedPtrField<Element>::RepeatedPtrField(Arena* arena)
+    : RepeatedPtrFieldBase(arena) {}
+
+template <typename Element>
+inline RepeatedPtrField<Element>::RepeatedPtrField(
+    const RepeatedPtrField& other)
+    : RepeatedPtrFieldBase() {
+  MergeFrom(other);
+}
+
+template <typename Element>
+template <typename Iter, typename>
+inline RepeatedPtrField<Element>::RepeatedPtrField(Iter begin, Iter end) {
+  Add(begin, end);
+}
+
+template <typename Element>
+RepeatedPtrField<Element>::~RepeatedPtrField() {
+#ifdef __cpp_if_constexpr
+  if constexpr (std::is_base_of<MessageLite, Element>::value) {
+#else
+  if (std::is_base_of<MessageLite, Element>::value) {
+#endif
+    if (NeedsDestroy()) DestroyProtos();
+  } else {
+    Destroy<TypeHandler>();
+  }
+}
+
+template <typename Element>
+inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
+    const RepeatedPtrField& other) {
+  if (this != &other) CopyFrom(other);
+  return *this;
+}
+
+template <typename Element>
+inline RepeatedPtrField<Element>::RepeatedPtrField(
+    RepeatedPtrField&& other) noexcept
+    : RepeatedPtrField() {
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+  CopyFrom(other);
+#else   // PROTOBUF_FORCE_COPY_IN_MOVE
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // other is on an arena. This field can't be on an arena because arena
+  // construction always uses the Arena* accepting constructor.
+  if (other.GetOwningArena()) {
+    CopyFrom(other);
+  } else {
+    InternalSwap(&other);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+}
+
+template <typename Element>
+inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
+    RepeatedPtrField&& other) noexcept {
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // the two fields are on different arenas.
+  if (this != &other) {
+    if (GetOwningArena() != other.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        || GetOwningArena() == nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      CopyFrom(other);
+    } else {
+      InternalSwap(&other);
+    }
+  }
+  return *this;
+}
+
+template <typename Element>
+inline bool RepeatedPtrField<Element>::empty() const {
+  return RepeatedPtrFieldBase::empty();
+}
+
+template <typename Element>
+inline int RepeatedPtrField<Element>::size() const {
+  return RepeatedPtrFieldBase::size();
+}
+
+template <typename Element>
+inline const Element& RepeatedPtrField<Element>::Get(int index) const {
+  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
+}
+
+template <typename Element>
+inline const Element& RepeatedPtrField<Element>::at(int index) const {
+  return RepeatedPtrFieldBase::at<TypeHandler>(index);
+}
+
+template <typename Element>
+inline Element& RepeatedPtrField<Element>::at(int index) {
+  return RepeatedPtrFieldBase::at<TypeHandler>(index);
+}
+
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::Mutable(int index) {
+  return RepeatedPtrFieldBase::Mutable<TypeHandler>(index);
+}
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::Add() {
+  return RepeatedPtrFieldBase::Add<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::Add(Element&& value) {
+  RepeatedPtrFieldBase::Add<TypeHandler>(std::move(value));
+}
+
+template <typename Element>
+template <typename Iter>
+inline void RepeatedPtrField<Element>::Add(Iter begin, Iter end) {
+  if (std::is_base_of<
+          std::forward_iterator_tag,
+          typename std::iterator_traits<Iter>::iterator_category>::value) {
+    int reserve = std::distance(begin, end);
+    Reserve(size() + reserve);
+  }
+  for (; begin != end; ++begin) {
+    *Add() = *begin;
+  }
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::RemoveLast() {
+  RepeatedPtrFieldBase::RemoveLast<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::DeleteSubrange(int start, int num) {
+  GOOGLE_DCHECK_GE(start, 0);
+  GOOGLE_DCHECK_GE(num, 0);
+  GOOGLE_DCHECK_LE(start + num, size());
+  for (int i = 0; i < num; ++i) {
+    RepeatedPtrFieldBase::Delete<TypeHandler>(start + i);
+  }
+  UnsafeArenaExtractSubrange(start, num, nullptr);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::ExtractSubrange(int start, int num,
+                                                       Element** elements) {
+  typename internal::TypeImplementsMergeBehavior<
+      typename TypeHandler::Type>::type t;
+  ExtractSubrangeInternal(start, num, elements, t);
+}
+
+// ExtractSubrange() implementation for types that implement merge/copy
+// behavior.
+template <typename Element>
+inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
+    int start, int num, Element** elements, std::true_type) {
+  GOOGLE_DCHECK_GE(start, 0);
+  GOOGLE_DCHECK_GE(num, 0);
+  GOOGLE_DCHECK_LE(start + num, size());
+
+  if (num == 0) return;
+
+  GOOGLE_DCHECK_NE(elements, nullptr)
+      << "Releasing elements without transferring ownership is an unsafe "
+         "operation.  Use UnsafeArenaExtractSubrange.";
+  if (elements == nullptr) {
+    CloseGap(start, num);
+    return;
+  }
+
+  Arena* arena = GetOwningArena();
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  // Always copy.
+  for (int i = 0; i < num; ++i) {
+    elements[i] = copy<TypeHandler>(
+        RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start));
+  }
+  if (arena == nullptr) {
+    for (int i = 0; i < num; ++i) {
+      delete RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
+    }
+  }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+  // If we're on an arena, we perform a copy for each element so that the
+  // returned elements are heap-allocated. Otherwise, just forward it.
+  if (arena != nullptr) {
+    for (int i = 0; i < num; ++i) {
+      elements[i] = copy<TypeHandler>(
+          RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start));
+    }
+  } else {
+    for (int i = 0; i < num; ++i) {
+      elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
+    }
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  CloseGap(start, num);
+}
+
+// ExtractSubrange() implementation for types that do not implement merge/copy
+// behavior.
+template <typename Element>
+inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
+    int start, int num, Element** elements, std::false_type) {
+  // This case is identical to UnsafeArenaExtractSubrange(). However, since
+  // ExtractSubrange() must return heap-allocated objects by contract, and we
+  // cannot fulfill this contract if we are an on arena, we must GOOGLE_DCHECK() that
+  // we are not on an arena.
+  GOOGLE_DCHECK(GetOwningArena() == nullptr)
+      << "ExtractSubrange() when arena is non-nullptr is only supported when "
+      << "the Element type supplies a MergeFrom() operation to make copies.";
+  UnsafeArenaExtractSubrange(start, num, elements);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::UnsafeArenaExtractSubrange(
+    int start, int num, Element** elements) {
+  GOOGLE_DCHECK_GE(start, 0);
+  GOOGLE_DCHECK_GE(num, 0);
+  GOOGLE_DCHECK_LE(start + num, size());
+
+  if (num > 0) {
+    // Save the values of the removed elements if requested.
+    if (elements != nullptr) {
+      for (int i = 0; i < num; ++i) {
+        elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
+      }
+    }
+    CloseGap(start, num);
+  }
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::Clear() {
+  RepeatedPtrFieldBase::Clear<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::MergeFrom(
+    const RepeatedPtrField& other) {
+  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::CopyFrom(const RepeatedPtrField& other) {
+  RepeatedPtrFieldBase::CopyFrom<TypeHandler>(other);
+}
+
+template <typename Element>
+template <typename Iter>
+inline void RepeatedPtrField<Element>::Assign(Iter begin, Iter end) {
+  Clear();
+  Add(begin, end);
+}
+
+template <typename Element>
+inline typename RepeatedPtrField<Element>::iterator
+RepeatedPtrField<Element>::erase(const_iterator position) {
+  return erase(position, position + 1);
+}
+
+template <typename Element>
+inline typename RepeatedPtrField<Element>::iterator
+RepeatedPtrField<Element>::erase(const_iterator first, const_iterator last) {
+  size_type pos_offset = std::distance(cbegin(), first);
+  size_type last_offset = std::distance(cbegin(), last);
+  DeleteSubrange(pos_offset, last_offset - pos_offset);
+  return begin() + pos_offset;
+}
+
+template <typename Element>
+inline Element** RepeatedPtrField<Element>::mutable_data() {
+  return RepeatedPtrFieldBase::mutable_data<TypeHandler>();
+}
+
+template <typename Element>
+inline const Element* const* RepeatedPtrField<Element>::data() const {
+  return RepeatedPtrFieldBase::data<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::Swap(RepeatedPtrField* other) {
+  if (this == other) return;
+  RepeatedPtrFieldBase::Swap<TypeHandler>(other);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::UnsafeArenaSwap(
+    RepeatedPtrField* other) {
+  if (this == other) return;
+  GOOGLE_DCHECK_EQ(GetOwningArena(), other->GetOwningArena());
+  RepeatedPtrFieldBase::InternalSwap(other);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::SwapElements(int index1, int index2) {
+  RepeatedPtrFieldBase::SwapElements(index1, index2);
+}
+
+template <typename Element>
+inline Arena* RepeatedPtrField<Element>::GetArena() const {
+  return RepeatedPtrFieldBase::GetArena();
+}
+
+template <typename Element>
+inline Arena* RepeatedPtrField<Element>::GetOwningArena() const {
+  return RepeatedPtrFieldBase::GetOwningArena();
+}
+
+template <typename Element>
+inline size_t RepeatedPtrField<Element>::SpaceUsedExcludingSelfLong() const {
+  return RepeatedPtrFieldBase::SpaceUsedExcludingSelfLong<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::AddAllocated(Element* value) {
+  RepeatedPtrFieldBase::AddAllocated<TypeHandler>(value);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::UnsafeArenaAddAllocated(Element* value) {
+  RepeatedPtrFieldBase::UnsafeArenaAddAllocated<TypeHandler>(value);
+}
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::ReleaseLast() {
+  return RepeatedPtrFieldBase::ReleaseLast<TypeHandler>();
+}
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::UnsafeArenaReleaseLast() {
+  return RepeatedPtrFieldBase::UnsafeArenaReleaseLast<TypeHandler>();
+}
+
+template <typename Element>
+inline int RepeatedPtrField<Element>::ClearedCount() const {
+  return RepeatedPtrFieldBase::ClearedCount();
+}
+
+#ifndef PROTOBUF_FUTURE_BREAKING_CHANGES
+template <typename Element>
+inline void RepeatedPtrField<Element>::AddCleared(Element* value) {
+  return RepeatedPtrFieldBase::AddCleared<TypeHandler>(value);
+}
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::ReleaseCleared() {
+  return RepeatedPtrFieldBase::ReleaseCleared<TypeHandler>();
+}
+#endif  // !PROTOBUF_FUTURE_BREAKING_CHANGES
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::Reserve(int new_size) {
+  return RepeatedPtrFieldBase::Reserve(new_size);
+}
+
+template <typename Element>
+inline int RepeatedPtrField<Element>::Capacity() const {
+  return RepeatedPtrFieldBase::Capacity();
+}
+
+// -------------------------------------------------------------------
+
+namespace internal {
+
+// STL-like iterator implementation for RepeatedPtrField.  You should not
+// refer to this class directly; use RepeatedPtrField<T>::iterator instead.
+//
+// The iterator for RepeatedPtrField<T>, RepeatedPtrIterator<T>, is
+// very similar to iterator_ptr<T**> in util/gtl/iterator_adaptors.h,
+// but adds random-access operators and is modified to wrap a void** base
+// iterator (since RepeatedPtrField stores its array as a void* array and
+// casting void** to T** would violate C++ aliasing rules).
+//
+// This code based on net/proto/proto-array-internal.h by Jeffrey Yasskin
+// (jyasskin@google.com).
+template <typename Element>
+class RepeatedPtrIterator {
+ public:
+  using iterator = RepeatedPtrIterator<Element>;
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type = typename std::remove_const<Element>::type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = Element*;
+  using reference = Element&;
+
+  RepeatedPtrIterator() : it_(nullptr) {}
+  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
+
+  // Allows "upcasting" from RepeatedPtrIterator<T**> to
+  // RepeatedPtrIterator<const T*const*>.
+  template <typename OtherElement,
+            typename std::enable_if<std::is_convertible<
+                OtherElement*, pointer>::value>::type* = nullptr>
+  RepeatedPtrIterator(const RepeatedPtrIterator<OtherElement>& other)
+      : it_(other.it_) {}
+
+  // dereferenceable
+  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
+  pointer operator->() const { return &(operator*()); }
+
+  // {inc,dec}rementable
+  iterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  iterator operator++(int) { return iterator(it_++); }
+  iterator& operator--() {
+    --it_;
+    return *this;
+  }
+  iterator operator--(int) { return iterator(it_--); }
+
+  // equality_comparable
+  friend bool operator==(const iterator& x, const iterator& y) {
+    return x.it_ == y.it_;
+  }
+  friend bool operator!=(const iterator& x, const iterator& y) {
+    return x.it_ != y.it_;
+  }
+
+  // less_than_comparable
+  friend bool operator<(const iterator& x, const iterator& y) {
+    return x.it_ < y.it_;
+  }
+  friend bool operator<=(const iterator& x, const iterator& y) {
+    return x.it_ <= y.it_;
+  }
+  friend bool operator>(const iterator& x, const iterator& y) {
+    return x.it_ > y.it_;
+  }
+  friend bool operator>=(const iterator& x, const iterator& y) {
+    return x.it_ >= y.it_;
+  }
+
+  // addable, subtractable
+  iterator& operator+=(difference_type d) {
+    it_ += d;
+    return *this;
+  }
+  friend iterator operator+(iterator it, const difference_type d) {
+    it += d;
+    return it;
+  }
+  friend iterator operator+(const difference_type d, iterator it) {
+    it += d;
+    return it;
+  }
+  iterator& operator-=(difference_type d) {
+    it_ -= d;
+    return *this;
+  }
+  friend iterator operator-(iterator it, difference_type d) {
+    it -= d;
+    return it;
+  }
+
+  // indexable
+  reference operator[](difference_type d) const { return *(*this + d); }
+
+  // random access iterator
+  friend difference_type operator-(iterator it1, iterator it2) {
+    return it1.it_ - it2.it_;
+  }
+
+ private:
+  template <typename OtherElement>
+  friend class RepeatedPtrIterator;
+
+  // The internal iterator.
+  void* const* it_;
+};
+
+// Provides an iterator that operates on pointers to the underlying objects
+// rather than the objects themselves as RepeatedPtrIterator does.
+// Consider using this when working with stl algorithms that change
+// the array.
+// The VoidPtr template parameter holds the type-agnostic pointer value
+// referenced by the iterator.  It should either be "void *" for a mutable
+// iterator, or "const void* const" for a constant iterator.
+template <typename Element, typename VoidPtr>
+class RepeatedPtrOverPtrsIterator {
+ public:
+  using iterator = RepeatedPtrOverPtrsIterator<Element, VoidPtr>;
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type = typename std::remove_const<Element>::type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = Element*;
+  using reference = Element&;
+
+  RepeatedPtrOverPtrsIterator() : it_(nullptr) {}
+  explicit RepeatedPtrOverPtrsIterator(VoidPtr* it) : it_(it) {}
+
+  // Allows "upcasting" from RepeatedPtrOverPtrsIterator<T**> to
+  // RepeatedPtrOverPtrsIterator<const T*const*>.
+  template <
+      typename OtherElement, typename OtherVoidPtr,
+      typename std::enable_if<
+          std::is_convertible<OtherElement*, pointer>::value &&
+          std::is_convertible<OtherVoidPtr*, VoidPtr>::value>::type* = nullptr>
+  RepeatedPtrOverPtrsIterator(
+      const RepeatedPtrOverPtrsIterator<OtherElement, OtherVoidPtr>& other)
+      : it_(other.it_) {}
+
+  // dereferenceable
+  reference operator*() const { return *reinterpret_cast<Element*>(it_); }
+  pointer operator->() const { return &(operator*()); }
+
+  // {inc,dec}rementable
+  iterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  iterator operator++(int) { return iterator(it_++); }
+  iterator& operator--() {
+    --it_;
+    return *this;
+  }
+  iterator operator--(int) { return iterator(it_--); }
+
+  // equality_comparable
+  friend bool operator==(const iterator& x, const iterator& y) {
+    return x.it_ == y.it_;
+  }
+  friend bool operator!=(const iterator& x, const iterator& y) {
+    return x.it_ != y.it_;
+  }
+
+  // less_than_comparable
+  friend bool operator<(const iterator& x, const iterator& y) {
+    return x.it_ < y.it_;
+  }
+  friend bool operator<=(const iterator& x, const iterator& y) {
+    return x.it_ <= y.it_;
+  }
+  friend bool operator>(const iterator& x, const iterator& y) {
+    return x.it_ > y.it_;
+  }
+  friend bool operator>=(const iterator& x, const iterator& y) {
+    return x.it_ >= y.it_;
+  }
+
+  // addable, subtractable
+  iterator& operator+=(difference_type d) {
+    it_ += d;
+    return *this;
+  }
+  friend iterator operator+(iterator it, difference_type d) {
+    it += d;
+    return it;
+  }
+  friend iterator operator+(difference_type d, iterator it) {
+    it += d;
+    return it;
+  }
+  iterator& operator-=(difference_type d) {
+    it_ -= d;
+    return *this;
+  }
+  friend iterator operator-(iterator it, difference_type d) {
+    it -= d;
+    return it;
+  }
+
+  // indexable
+  reference operator[](difference_type d) const { return *(*this + d); }
+
+  // random access iterator
+  friend difference_type operator-(iterator it1, iterator it2) {
+    return it1.it_ - it2.it_;
+  }
+
+ private:
+  template <typename OtherElement, typename OtherVoidPtr>
+  friend class RepeatedPtrOverPtrsIterator;
+
+  // The internal iterator.
+  VoidPtr* it_;
+};
+
+}  // namespace internal
+
+template <typename Element>
+inline typename RepeatedPtrField<Element>::iterator
+RepeatedPtrField<Element>::begin() {
+  return iterator(raw_data());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_iterator
+RepeatedPtrField<Element>::begin() const {
+  return iterator(raw_data());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_iterator
+RepeatedPtrField<Element>::cbegin() const {
+  return begin();
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::iterator
+RepeatedPtrField<Element>::end() {
+  return iterator(raw_data() + size());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_iterator
+RepeatedPtrField<Element>::end() const {
+  return iterator(raw_data() + size());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_iterator
+RepeatedPtrField<Element>::cend() const {
+  return end();
+}
+
+template <typename Element>
+inline typename RepeatedPtrField<Element>::pointer_iterator
+RepeatedPtrField<Element>::pointer_begin() {
+  return pointer_iterator(raw_mutable_data());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_pointer_iterator
+RepeatedPtrField<Element>::pointer_begin() const {
+  return const_pointer_iterator(const_cast<const void* const*>(raw_data()));
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::pointer_iterator
+RepeatedPtrField<Element>::pointer_end() {
+  return pointer_iterator(raw_mutable_data() + size());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_pointer_iterator
+RepeatedPtrField<Element>::pointer_end() const {
+  return const_pointer_iterator(
+      const_cast<const void* const*>(raw_data() + size()));
+}
+
+// Iterators and helper functions that follow the spirit of the STL
+// std::back_insert_iterator and std::back_inserter but are tailor-made
+// for RepeatedField and RepeatedPtrField. Typical usage would be:
+//
+//   std::copy(some_sequence.begin(), some_sequence.end(),
+//             RepeatedFieldBackInserter(proto.mutable_sequence()));
+//
+// Ported by johannes from util/gtl/proto-array-iterators.h
+
+namespace internal {
+
+// A back inserter for RepeatedPtrField objects.
+template <typename T>
+class RepeatedPtrFieldBackInsertIterator {
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = T;
+  using pointer = void;
+  using reference = void;
+  using difference_type = std::ptrdiff_t;
+
+  RepeatedPtrFieldBackInsertIterator(RepeatedPtrField<T>* const mutable_field)
+      : field_(mutable_field) {}
+  RepeatedPtrFieldBackInsertIterator<T>& operator=(const T& value) {
+    *field_->Add() = value;
+    return *this;
+  }
+  RepeatedPtrFieldBackInsertIterator<T>& operator=(
+      const T* const ptr_to_value) {
+    *field_->Add() = *ptr_to_value;
+    return *this;
+  }
+  RepeatedPtrFieldBackInsertIterator<T>& operator=(T&& value) {
+    *field_->Add() = std::move(value);
+    return *this;
+  }
+  RepeatedPtrFieldBackInsertIterator<T>& operator*() { return *this; }
+  RepeatedPtrFieldBackInsertIterator<T>& operator++() { return *this; }
+  RepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */) {
+    return *this;
+  }
+
+ private:
+  RepeatedPtrField<T>* field_;
+};
+
+// A back inserter for RepeatedPtrFields that inserts by transferring ownership
+// of a pointer.
+template <typename T>
+class AllocatedRepeatedPtrFieldBackInsertIterator {
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = T;
+  using pointer = void;
+  using reference = void;
+  using difference_type = std::ptrdiff_t;
+
+  explicit AllocatedRepeatedPtrFieldBackInsertIterator(
+      RepeatedPtrField<T>* const mutable_field)
+      : field_(mutable_field) {}
+  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
+      T* const ptr_to_value) {
+    field_->AddAllocated(ptr_to_value);
+    return *this;
+  }
+  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() { return *this; }
+  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() { return *this; }
+  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */) {
+    return *this;
+  }
+
+ private:
+  RepeatedPtrField<T>* field_;
+};
+
+// Almost identical to AllocatedRepeatedPtrFieldBackInsertIterator. This one
+// uses the UnsafeArenaAddAllocated instead.
+template <typename T>
+class UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator {
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = T;
+  using pointer = void;
+  using reference = void;
+  using difference_type = std::ptrdiff_t;
+
+  explicit UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator(
+      RepeatedPtrField<T>* const mutable_field)
+      : field_(mutable_field) {}
+  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
+      T const* const ptr_to_value) {
+    field_->UnsafeArenaAddAllocated(const_cast<T*>(ptr_to_value));
+    return *this;
+  }
+  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() {
+    return *this;
+  }
+  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() {
+    return *this;
+  }
+  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(
+      int /* unused */) {
+    return *this;
+  }
+
+ private:
+  RepeatedPtrField<T>* field_;
+};
+
+}  // namespace internal
+
+// Provides a back insert iterator for RepeatedPtrField instances,
+// similar to std::back_inserter().
+template <typename T>
+internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedPtrFieldBackInserter(
+    RepeatedPtrField<T>* const mutable_field) {
+  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
+}
+
+// Special back insert iterator for RepeatedPtrField instances, just in
+// case someone wants to write generic template code that can access both
+// RepeatedFields and RepeatedPtrFields using a common name.
+template <typename T>
+internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedFieldBackInserter(
+    RepeatedPtrField<T>* const mutable_field) {
+  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
+}
+
+// Provides a back insert iterator for RepeatedPtrField instances
+// similar to std::back_inserter() which transfers the ownership while
+// copying elements.
+template <typename T>
+internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>
+AllocatedRepeatedPtrFieldBackInserter(
+    RepeatedPtrField<T>* const mutable_field) {
+  return internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>(
+      mutable_field);
+}
+
+// Similar to AllocatedRepeatedPtrFieldBackInserter, using
+// UnsafeArenaAddAllocated instead of AddAllocated.
+// This is slightly faster if that matters. It is also useful in legacy code
+// that uses temporary ownership to avoid copies. Example:
+//   RepeatedPtrField<T> temp_field;
+//   temp_field.UnsafeArenaAddAllocated(new T);
+//   ... // Do something with temp_field
+//   temp_field.UnsafeArenaExtractSubrange(0, temp_field.size(), nullptr);
+// Putting temp_field on the arena fails because the ownership transfers to the
+// arena at the "AddAllocated" call and is not released anymore causing a
+// double delete. This function uses UnsafeArenaAddAllocated to prevent this.
+template <typename T>
+internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>
+UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
+    RepeatedPtrField<T>* const mutable_field) {
+  return internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>(
+      mutable_field);
+}
+
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+    RepeatedPtrField<std::string>;
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_REPEATED_PTR_FIELD_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/service.h b/CAPI/cpp/grpc/include/google/protobuf/service.h
new file mode 100644
index 0000000..d288eb5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/service.h
@@ -0,0 +1,295 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// DEPRECATED:  This module declares the abstract interfaces underlying proto2
+// RPC services.  These are intended to be independent of any particular RPC
+// implementation, so that proto2 services can be used on top of a variety
+// of implementations.  Starting with version 2.3.0, RPC implementations should
+// not try to build on these, but should instead provide code generator plugins
+// which generate code specific to the particular RPC implementation.  This way
+// the generated code can be more appropriate for the implementation in use
+// and can avoid unnecessary layers of indirection.
+//
+//
+// When you use the protocol compiler to compile a service definition, it
+// generates two classes:  An abstract interface for the service (with
+// methods matching the service definition) and a "stub" implementation.
+// A stub is just a type-safe wrapper around an RpcChannel which emulates a
+// local implementation of the service.
+//
+// For example, the service definition:
+//   service MyService {
+//     rpc Foo(MyRequest) returns(MyResponse);
+//   }
+// will generate abstract interface "MyService" and class "MyService::Stub".
+// You could implement a MyService as follows:
+//   class MyServiceImpl : public MyService {
+//    public:
+//     MyServiceImpl() {}
+//     ~MyServiceImpl() {}
+//
+//     // implements MyService ---------------------------------------
+//
+//     void Foo(google::protobuf::RpcController* controller,
+//              const MyRequest* request,
+//              MyResponse* response,
+//              Closure* done) {
+//       // ... read request and fill in response ...
+//       done->Run();
+//     }
+//   };
+// You would then register an instance of MyServiceImpl with your RPC server
+// implementation.  (How to do that depends on the implementation.)
+//
+// To call a remote MyServiceImpl, first you need an RpcChannel connected to it.
+// How to construct a channel depends, again, on your RPC implementation.
+// Here we use a hypothetical "MyRpcChannel" as an example:
+//   MyRpcChannel channel("rpc:hostname:1234/myservice");
+//   MyRpcController controller;
+//   MyServiceImpl::Stub stub(&channel);
+//   FooRequest request;
+//   FooResponse response;
+//
+//   // ... fill in request ...
+//
+//   stub.Foo(&controller, request, &response, NewCallback(HandleResponse));
+//
+// On Thread-Safety:
+//
+// Different RPC implementations may make different guarantees about what
+// threads they may run callbacks on, and what threads the application is
+// allowed to use to call the RPC system.  Portable software should be ready
+// for callbacks to be called on any thread, but should not try to call the
+// RPC system from any thread except for the ones on which it received the
+// callbacks.  Realistically, though, simple software will probably want to
+// use a single-threaded RPC system while high-end software will want to
+// use multiple threads.  RPC implementations should provide multiple
+// choices.
+
+#ifndef GOOGLE_PROTOBUF_SERVICE_H__
+#define GOOGLE_PROTOBUF_SERVICE_H__
+
+
+#include <string>
+#include <google/protobuf/stubs/callback.h>
+#include <google/protobuf/stubs/common.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+// Defined in this file.
+class Service;
+class RpcController;
+class RpcChannel;
+
+// Defined in other files.
+class Descriptor;         // descriptor.h
+class ServiceDescriptor;  // descriptor.h
+class MethodDescriptor;   // descriptor.h
+class Message;            // message.h
+
+// Abstract base interface for protocol-buffer-based RPC services.  Services
+// themselves are abstract interfaces (implemented either by servers or as
+// stubs), but they subclass this base interface.  The methods of this
+// interface can be used to call the methods of the Service without knowing
+// its exact type at compile time (analogous to Reflection).
+class PROTOBUF_EXPORT Service {
+ public:
+  inline Service() {}
+  virtual ~Service();
+
+  // When constructing a stub, you may pass STUB_OWNS_CHANNEL as the second
+  // parameter to the constructor to tell it to delete its RpcChannel when
+  // destroyed.
+  enum ChannelOwnership { STUB_OWNS_CHANNEL, STUB_DOESNT_OWN_CHANNEL };
+
+  // Get the ServiceDescriptor describing this service and its methods.
+  virtual const ServiceDescriptor* GetDescriptor() = 0;
+
+  // Call a method of the service specified by MethodDescriptor.  This is
+  // normally implemented as a simple switch() that calls the standard
+  // definitions of the service's methods.
+  //
+  // Preconditions:
+  // * method->service() == GetDescriptor()
+  // * request and response are of the exact same classes as the objects
+  //   returned by GetRequestPrototype(method) and
+  //   GetResponsePrototype(method).
+  // * After the call has started, the request must not be modified and the
+  //   response must not be accessed at all until "done" is called.
+  // * "controller" is of the correct type for the RPC implementation being
+  //   used by this Service.  For stubs, the "correct type" depends on the
+  //   RpcChannel which the stub is using.  Server-side Service
+  //   implementations are expected to accept whatever type of RpcController
+  //   the server-side RPC implementation uses.
+  //
+  // Postconditions:
+  // * "done" will be called when the method is complete.  This may be
+  //   before CallMethod() returns or it may be at some point in the future.
+  // * If the RPC succeeded, "response" contains the response returned by
+  //   the server.
+  // * If the RPC failed, "response"'s contents are undefined.  The
+  //   RpcController can be queried to determine if an error occurred and
+  //   possibly to get more information about the error.
+  virtual void CallMethod(const MethodDescriptor* method,
+                          RpcController* controller, const Message* request,
+                          Message* response, Closure* done) = 0;
+
+  // CallMethod() requires that the request and response passed in are of a
+  // particular subclass of Message.  GetRequestPrototype() and
+  // GetResponsePrototype() get the default instances of these required types.
+  // You can then call Message::New() on these instances to construct mutable
+  // objects which you can then pass to CallMethod().
+  //
+  // Example:
+  //   const MethodDescriptor* method =
+  //     service->GetDescriptor()->FindMethodByName("Foo");
+  //   Message* request  = stub->GetRequestPrototype (method)->New();
+  //   Message* response = stub->GetResponsePrototype(method)->New();
+  //   request->ParseFromString(input);
+  //   service->CallMethod(method, *request, response, callback);
+  virtual const Message& GetRequestPrototype(
+      const MethodDescriptor* method) const = 0;
+  virtual const Message& GetResponsePrototype(
+      const MethodDescriptor* method) const = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Service);
+};
+
+// An RpcController mediates a single method call.  The primary purpose of
+// the controller is to provide a way to manipulate settings specific to the
+// RPC implementation and to find out about RPC-level errors.
+//
+// The methods provided by the RpcController interface are intended to be a
+// "least common denominator" set of features which we expect all
+// implementations to support.  Specific implementations may provide more
+// advanced features (e.g. deadline propagation).
+class PROTOBUF_EXPORT RpcController {
+ public:
+  inline RpcController() {}
+  virtual ~RpcController();
+
+  // Client-side methods ---------------------------------------------
+  // These calls may be made from the client side only.  Their results
+  // are undefined on the server side (may crash).
+
+  // Resets the RpcController to its initial state so that it may be reused in
+  // a new call.  Must not be called while an RPC is in progress.
+  virtual void Reset() = 0;
+
+  // After a call has finished, returns true if the call failed.  The possible
+  // reasons for failure depend on the RPC implementation.  Failed() must not
+  // be called before a call has finished.  If Failed() returns true, the
+  // contents of the response message are undefined.
+  virtual bool Failed() const = 0;
+
+  // If Failed() is true, returns a human-readable description of the error.
+  virtual std::string ErrorText() const = 0;
+
+  // Advises the RPC system that the caller desires that the RPC call be
+  // canceled.  The RPC system may cancel it immediately, may wait awhile and
+  // then cancel it, or may not even cancel the call at all.  If the call is
+  // canceled, the "done" callback will still be called and the RpcController
+  // will indicate that the call failed at that time.
+  virtual void StartCancel() = 0;
+
+  // Server-side methods ---------------------------------------------
+  // These calls may be made from the server side only.  Their results
+  // are undefined on the client side (may crash).
+
+  // Causes Failed() to return true on the client side.  "reason" will be
+  // incorporated into the message returned by ErrorText().  If you find
+  // you need to return machine-readable information about failures, you
+  // should incorporate it into your response protocol buffer and should
+  // NOT call SetFailed().
+  virtual void SetFailed(const std::string& reason) = 0;
+
+  // If true, indicates that the client canceled the RPC, so the server may
+  // as well give up on replying to it.  The server should still call the
+  // final "done" callback.
+  virtual bool IsCanceled() const = 0;
+
+  // Asks that the given callback be called when the RPC is canceled.  The
+  // callback will always be called exactly once.  If the RPC completes without
+  // being canceled, the callback will be called after completion.  If the RPC
+  // has already been canceled when NotifyOnCancel() is called, the callback
+  // will be called immediately.
+  //
+  // NotifyOnCancel() must be called no more than once per request.
+  virtual void NotifyOnCancel(Closure* callback) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcController);
+};
+
+// Abstract interface for an RPC channel.  An RpcChannel represents a
+// communication line to a Service which can be used to call that Service's
+// methods.  The Service may be running on another machine.  Normally, you
+// should not call an RpcChannel directly, but instead construct a stub Service
+// wrapping it.  Example:
+//   RpcChannel* channel = new MyRpcChannel("remotehost.example.com:1234");
+//   MyService* service = new MyService::Stub(channel);
+//   service->MyMethod(request, &response, callback);
+class PROTOBUF_EXPORT RpcChannel {
+ public:
+  inline RpcChannel() {}
+  virtual ~RpcChannel();
+
+  // Call the given method of the remote service.  The signature of this
+  // procedure looks the same as Service::CallMethod(), but the requirements
+  // are less strict in one important way:  the request and response objects
+  // need not be of any specific class as long as their descriptors are
+  // method->input_type() and method->output_type().
+  virtual void CallMethod(const MethodDescriptor* method,
+                          RpcController* controller, const Message* request,
+                          Message* response, Closure* done) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcChannel);
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_SERVICE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/source_context.pb.h b/CAPI/cpp/grpc/include/google/protobuf/source_context.pb.h
new file mode 100644
index 0000000..e9c41bd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/source_context.pb.h
@@ -0,0 +1,282 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/source_context.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fsource_5fcontext_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fsource_5fcontext_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fsource_5fcontext_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fsource_5fcontext_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class SourceContext;
+struct SourceContextDefaultTypeInternal;
+PROTOBUF_EXPORT extern SourceContextDefaultTypeInternal _SourceContext_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceContext* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+// ===================================================================
+
+class PROTOBUF_EXPORT SourceContext final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceContext) */ {
+ public:
+  inline SourceContext() : SourceContext(nullptr) {}
+  ~SourceContext() override;
+  explicit PROTOBUF_CONSTEXPR SourceContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SourceContext(const SourceContext& from);
+  SourceContext(SourceContext&& from) noexcept
+    : SourceContext() {
+    *this = ::std::move(from);
+  }
+
+  inline SourceContext& operator=(const SourceContext& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SourceContext& operator=(SourceContext&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SourceContext& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SourceContext* internal_default_instance() {
+    return reinterpret_cast<const SourceContext*>(
+               &_SourceContext_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SourceContext& a, SourceContext& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SourceContext* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SourceContext* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SourceContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SourceContext>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SourceContext& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const SourceContext& from) {
+    SourceContext::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SourceContext* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.SourceContext";
+  }
+  protected:
+  explicit SourceContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileNameFieldNumber = 1,
+  };
+  // string file_name = 1;
+  void clear_file_name();
+  const std::string& file_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_file_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_file_name();
+  PROTOBUF_NODISCARD std::string* release_file_name();
+  void set_allocated_file_name(std::string* file_name);
+  private:
+  const std::string& _internal_file_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value);
+  std::string* _internal_mutable_file_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.SourceContext)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SourceContext
+
+// string file_name = 1;
+inline void SourceContext::clear_file_name() {
+  _impl_.file_name_.ClearToEmpty();
+}
+inline const std::string& SourceContext::file_name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceContext.file_name)
+  return _internal_file_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SourceContext::set_file_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.file_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceContext.file_name)
+}
+inline std::string* SourceContext::mutable_file_name() {
+  std::string* _s = _internal_mutable_file_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceContext.file_name)
+  return _s;
+}
+inline const std::string& SourceContext::_internal_file_name() const {
+  return _impl_.file_name_.Get();
+}
+inline void SourceContext::_internal_set_file_name(const std::string& value) {
+  
+  _impl_.file_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* SourceContext::_internal_mutable_file_name() {
+  
+  return _impl_.file_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SourceContext::release_file_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.SourceContext.file_name)
+  return _impl_.file_name_.Release();
+}
+inline void SourceContext::set_allocated_file_name(std::string* file_name) {
+  if (file_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.file_name_.SetAllocated(file_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.file_name_.IsDefault()) {
+    _impl_.file_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceContext.file_name)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fsource_5fcontext_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/source_context.proto b/CAPI/cpp/grpc/include/google/protobuf/source_context.proto
new file mode 100644
index 0000000..06bfc43
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/source_context.proto
@@ -0,0 +1,48 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "SourceContextProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+option go_package = "google.golang.org/protobuf/types/known/sourcecontextpb";
+
+// `SourceContext` represents information about the source of a
+// protobuf element, like the file in which it is defined.
+message SourceContext {
+  // The path-qualified name of the .proto file that contained the associated
+  // protobuf element.  For example: `"google/protobuf/source_context.proto"`.
+  string file_name = 1;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/struct.pb.h b/CAPI/cpp/grpc/include/google/protobuf/struct.pb.h
new file mode 100644
index 0000000..ac2d971
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/struct.pb.h
@@ -0,0 +1,1177 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/struct.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fstruct_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fstruct_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fstruct_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fstruct_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fstruct_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class ListValue;
+struct ListValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern ListValueDefaultTypeInternal _ListValue_default_instance_;
+class Struct;
+struct StructDefaultTypeInternal;
+PROTOBUF_EXPORT extern StructDefaultTypeInternal _Struct_default_instance_;
+class Struct_FieldsEntry_DoNotUse;
+struct Struct_FieldsEntry_DoNotUseDefaultTypeInternal;
+PROTOBUF_EXPORT extern Struct_FieldsEntry_DoNotUseDefaultTypeInternal _Struct_FieldsEntry_DoNotUse_default_instance_;
+class Value;
+struct ValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern ValueDefaultTypeInternal _Value_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ListValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ListValue>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Struct* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Struct>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Struct_FieldsEntry_DoNotUse* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Struct_FieldsEntry_DoNotUse>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Value>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+enum NullValue : int {
+  NULL_VALUE = 0,
+  NullValue_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  NullValue_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+PROTOBUF_EXPORT bool NullValue_IsValid(int value);
+constexpr NullValue NullValue_MIN = NULL_VALUE;
+constexpr NullValue NullValue_MAX = NULL_VALUE;
+constexpr int NullValue_ARRAYSIZE = NullValue_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NullValue_descriptor();
+template<typename T>
+inline const std::string& NullValue_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, NullValue>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function NullValue_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    NullValue_descriptor(), enum_t_value);
+}
+inline bool NullValue_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NullValue* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NullValue>(
+    NullValue_descriptor(), name, value);
+}
+// ===================================================================
+
+class Struct_FieldsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Struct_FieldsEntry_DoNotUse, 
+    std::string, ::PROTOBUF_NAMESPACE_ID::Value,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Struct_FieldsEntry_DoNotUse, 
+    std::string, ::PROTOBUF_NAMESPACE_ID::Value,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  Struct_FieldsEntry_DoNotUse();
+  explicit PROTOBUF_CONSTEXPR Struct_FieldsEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit Struct_FieldsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const Struct_FieldsEntry_DoNotUse& other);
+  static const Struct_FieldsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Struct_FieldsEntry_DoNotUse*>(&_Struct_FieldsEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.protobuf.Struct.FieldsEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
+};
+
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Struct final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Struct) */ {
+ public:
+  inline Struct() : Struct(nullptr) {}
+  ~Struct() override;
+  explicit PROTOBUF_CONSTEXPR Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Struct(const Struct& from);
+  Struct(Struct&& from) noexcept
+    : Struct() {
+    *this = ::std::move(from);
+  }
+
+  inline Struct& operator=(const Struct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Struct& operator=(Struct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Struct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Struct* internal_default_instance() {
+    return reinterpret_cast<const Struct*>(
+               &_Struct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(Struct& a, Struct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Struct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Struct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Struct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Struct& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Struct& from) {
+    Struct::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Struct* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Struct";
+  }
+  protected:
+  explicit Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFieldsFieldNumber = 1,
+  };
+  // map<string, .google.protobuf.Value> fields = 1;
+  int fields_size() const;
+  private:
+  int _internal_fields_size() const;
+  public:
+  void clear_fields();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >&
+      _internal_fields() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >*
+      _internal_mutable_fields();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >&
+      fields() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >*
+      mutable_fields();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Struct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+        Struct_FieldsEntry_DoNotUse,
+        std::string, ::PROTOBUF_NAMESPACE_ID::Value,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> fields_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Value final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Value) */ {
+ public:
+  inline Value() : Value(nullptr) {}
+  ~Value() override;
+  explicit PROTOBUF_CONSTEXPR Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Value(const Value& from);
+  Value(Value&& from) noexcept
+    : Value() {
+    *this = ::std::move(from);
+  }
+
+  inline Value& operator=(const Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Value& operator=(Value&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Value& default_instance() {
+    return *internal_default_instance();
+  }
+  enum KindCase {
+    kNullValue = 1,
+    kNumberValue = 2,
+    kStringValue = 3,
+    kBoolValue = 4,
+    kStructValue = 5,
+    kListValue = 6,
+    KIND_NOT_SET = 0,
+  };
+
+  static inline const Value* internal_default_instance() {
+    return reinterpret_cast<const Value*>(
+               &_Value_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(Value& a, Value& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Value* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Value* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Value>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Value& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Value& from) {
+    Value::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Value* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Value";
+  }
+  protected:
+  explicit Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNullValueFieldNumber = 1,
+    kNumberValueFieldNumber = 2,
+    kStringValueFieldNumber = 3,
+    kBoolValueFieldNumber = 4,
+    kStructValueFieldNumber = 5,
+    kListValueFieldNumber = 6,
+  };
+  // .google.protobuf.NullValue null_value = 1;
+  bool has_null_value() const;
+  private:
+  bool _internal_has_null_value() const;
+  public:
+  void clear_null_value();
+  ::PROTOBUF_NAMESPACE_ID::NullValue null_value() const;
+  void set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::NullValue _internal_null_value() const;
+  void _internal_set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value);
+  public:
+
+  // double number_value = 2;
+  bool has_number_value() const;
+  private:
+  bool _internal_has_number_value() const;
+  public:
+  void clear_number_value();
+  double number_value() const;
+  void set_number_value(double value);
+  private:
+  double _internal_number_value() const;
+  void _internal_set_number_value(double value);
+  public:
+
+  // string string_value = 3;
+  bool has_string_value() const;
+  private:
+  bool _internal_has_string_value() const;
+  public:
+  void clear_string_value();
+  const std::string& string_value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_string_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_string_value();
+  PROTOBUF_NODISCARD std::string* release_string_value();
+  void set_allocated_string_value(std::string* string_value);
+  private:
+  const std::string& _internal_string_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
+  std::string* _internal_mutable_string_value();
+  public:
+
+  // bool bool_value = 4;
+  bool has_bool_value() const;
+  private:
+  bool _internal_has_bool_value() const;
+  public:
+  void clear_bool_value();
+  bool bool_value() const;
+  void set_bool_value(bool value);
+  private:
+  bool _internal_bool_value() const;
+  void _internal_set_bool_value(bool value);
+  public:
+
+  // .google.protobuf.Struct struct_value = 5;
+  bool has_struct_value() const;
+  private:
+  bool _internal_has_struct_value() const;
+  public:
+  void clear_struct_value();
+  const ::PROTOBUF_NAMESPACE_ID::Struct& struct_value() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Struct* release_struct_value();
+  ::PROTOBUF_NAMESPACE_ID::Struct* mutable_struct_value();
+  void set_allocated_struct_value(::PROTOBUF_NAMESPACE_ID::Struct* struct_value);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Struct& _internal_struct_value() const;
+  ::PROTOBUF_NAMESPACE_ID::Struct* _internal_mutable_struct_value();
+  public:
+  void unsafe_arena_set_allocated_struct_value(
+      ::PROTOBUF_NAMESPACE_ID::Struct* struct_value);
+  ::PROTOBUF_NAMESPACE_ID::Struct* unsafe_arena_release_struct_value();
+
+  // .google.protobuf.ListValue list_value = 6;
+  bool has_list_value() const;
+  private:
+  bool _internal_has_list_value() const;
+  public:
+  void clear_list_value();
+  const ::PROTOBUF_NAMESPACE_ID::ListValue& list_value() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ListValue* release_list_value();
+  ::PROTOBUF_NAMESPACE_ID::ListValue* mutable_list_value();
+  void set_allocated_list_value(::PROTOBUF_NAMESPACE_ID::ListValue* list_value);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::ListValue& _internal_list_value() const;
+  ::PROTOBUF_NAMESPACE_ID::ListValue* _internal_mutable_list_value();
+  public:
+  void unsafe_arena_set_allocated_list_value(
+      ::PROTOBUF_NAMESPACE_ID::ListValue* list_value);
+  ::PROTOBUF_NAMESPACE_ID::ListValue* unsafe_arena_release_list_value();
+
+  void clear_kind();
+  KindCase kind_case() const;
+  // @@protoc_insertion_point(class_scope:google.protobuf.Value)
+ private:
+  class _Internal;
+  void set_has_null_value();
+  void set_has_number_value();
+  void set_has_string_value();
+  void set_has_bool_value();
+  void set_has_struct_value();
+  void set_has_list_value();
+
+  inline bool has_kind() const;
+  inline void clear_has_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    union KindUnion {
+      constexpr KindUnion() : _constinit_{} {}
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+      int null_value_;
+      double number_value_;
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
+      bool bool_value_;
+      ::PROTOBUF_NAMESPACE_ID::Struct* struct_value_;
+      ::PROTOBUF_NAMESPACE_ID::ListValue* list_value_;
+    } kind_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    uint32_t _oneof_case_[1];
+
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT ListValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ListValue) */ {
+ public:
+  inline ListValue() : ListValue(nullptr) {}
+  ~ListValue() override;
+  explicit PROTOBUF_CONSTEXPR ListValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ListValue(const ListValue& from);
+  ListValue(ListValue&& from) noexcept
+    : ListValue() {
+    *this = ::std::move(from);
+  }
+
+  inline ListValue& operator=(const ListValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ListValue& operator=(ListValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ListValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ListValue* internal_default_instance() {
+    return reinterpret_cast<const ListValue*>(
+               &_ListValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ListValue& a, ListValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ListValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ListValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ListValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ListValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ListValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ListValue& from) {
+    ListValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ListValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.ListValue";
+  }
+  protected:
+  explicit ListValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValuesFieldNumber = 1,
+  };
+  // repeated .google.protobuf.Value values = 1;
+  int values_size() const;
+  private:
+  int _internal_values_size() const;
+  public:
+  void clear_values();
+  ::PROTOBUF_NAMESPACE_ID::Value* mutable_values(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value >*
+      mutable_values();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Value& _internal_values(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Value* _internal_add_values();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Value& values(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Value* add_values();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value >&
+      values() const;
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.ListValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value > values_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// Struct
+
+// map<string, .google.protobuf.Value> fields = 1;
+inline int Struct::_internal_fields_size() const {
+  return _impl_.fields_.size();
+}
+inline int Struct::fields_size() const {
+  return _internal_fields_size();
+}
+inline void Struct::clear_fields() {
+  _impl_.fields_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >&
+Struct::_internal_fields() const {
+  return _impl_.fields_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >&
+Struct::fields() const {
+  // @@protoc_insertion_point(field_map:google.protobuf.Struct.fields)
+  return _internal_fields();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >*
+Struct::_internal_mutable_fields() {
+  return _impl_.fields_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >*
+Struct::mutable_fields() {
+  // @@protoc_insertion_point(field_mutable_map:google.protobuf.Struct.fields)
+  return _internal_mutable_fields();
+}
+
+// -------------------------------------------------------------------
+
+// Value
+
+// .google.protobuf.NullValue null_value = 1;
+inline bool Value::_internal_has_null_value() const {
+  return kind_case() == kNullValue;
+}
+inline bool Value::has_null_value() const {
+  return _internal_has_null_value();
+}
+inline void Value::set_has_null_value() {
+  _impl_._oneof_case_[0] = kNullValue;
+}
+inline void Value::clear_null_value() {
+  if (_internal_has_null_value()) {
+    _impl_.kind_.null_value_ = 0;
+    clear_has_kind();
+  }
+}
+inline ::PROTOBUF_NAMESPACE_ID::NullValue Value::_internal_null_value() const {
+  if (_internal_has_null_value()) {
+    return static_cast< ::PROTOBUF_NAMESPACE_ID::NullValue >(_impl_.kind_.null_value_);
+  }
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::NullValue >(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::NullValue Value::null_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.null_value)
+  return _internal_null_value();
+}
+inline void Value::_internal_set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value) {
+  if (!_internal_has_null_value()) {
+    clear_kind();
+    set_has_null_value();
+  }
+  _impl_.kind_.null_value_ = value;
+}
+inline void Value::set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value) {
+  _internal_set_null_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.null_value)
+}
+
+// double number_value = 2;
+inline bool Value::_internal_has_number_value() const {
+  return kind_case() == kNumberValue;
+}
+inline bool Value::has_number_value() const {
+  return _internal_has_number_value();
+}
+inline void Value::set_has_number_value() {
+  _impl_._oneof_case_[0] = kNumberValue;
+}
+inline void Value::clear_number_value() {
+  if (_internal_has_number_value()) {
+    _impl_.kind_.number_value_ = 0;
+    clear_has_kind();
+  }
+}
+inline double Value::_internal_number_value() const {
+  if (_internal_has_number_value()) {
+    return _impl_.kind_.number_value_;
+  }
+  return 0;
+}
+inline void Value::_internal_set_number_value(double value) {
+  if (!_internal_has_number_value()) {
+    clear_kind();
+    set_has_number_value();
+  }
+  _impl_.kind_.number_value_ = value;
+}
+inline double Value::number_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.number_value)
+  return _internal_number_value();
+}
+inline void Value::set_number_value(double value) {
+  _internal_set_number_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.number_value)
+}
+
+// string string_value = 3;
+inline bool Value::_internal_has_string_value() const {
+  return kind_case() == kStringValue;
+}
+inline bool Value::has_string_value() const {
+  return _internal_has_string_value();
+}
+inline void Value::set_has_string_value() {
+  _impl_._oneof_case_[0] = kStringValue;
+}
+inline void Value::clear_string_value() {
+  if (_internal_has_string_value()) {
+    _impl_.kind_.string_value_.Destroy();
+    clear_has_kind();
+  }
+}
+inline const std::string& Value::string_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.string_value)
+  return _internal_string_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Value::set_string_value(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_string_value()) {
+    clear_kind();
+    set_has_string_value();
+    _impl_.kind_.string_value_.InitDefault();
+  }
+  _impl_.kind_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.string_value)
+}
+inline std::string* Value::mutable_string_value() {
+  std::string* _s = _internal_mutable_string_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.string_value)
+  return _s;
+}
+inline const std::string& Value::_internal_string_value() const {
+  if (_internal_has_string_value()) {
+    return _impl_.kind_.string_value_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Value::_internal_set_string_value(const std::string& value) {
+  if (!_internal_has_string_value()) {
+    clear_kind();
+    set_has_string_value();
+    _impl_.kind_.string_value_.InitDefault();
+  }
+  _impl_.kind_.string_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Value::_internal_mutable_string_value() {
+  if (!_internal_has_string_value()) {
+    clear_kind();
+    set_has_string_value();
+    _impl_.kind_.string_value_.InitDefault();
+  }
+  return _impl_.kind_.string_value_.Mutable(      GetArenaForAllocation());
+}
+inline std::string* Value::release_string_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Value.string_value)
+  if (_internal_has_string_value()) {
+    clear_has_kind();
+    return _impl_.kind_.string_value_.Release();
+  } else {
+    return nullptr;
+  }
+}
+inline void Value::set_allocated_string_value(std::string* string_value) {
+  if (has_kind()) {
+    clear_kind();
+  }
+  if (string_value != nullptr) {
+    set_has_string_value();
+    _impl_.kind_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Value.string_value)
+}
+
+// bool bool_value = 4;
+inline bool Value::_internal_has_bool_value() const {
+  return kind_case() == kBoolValue;
+}
+inline bool Value::has_bool_value() const {
+  return _internal_has_bool_value();
+}
+inline void Value::set_has_bool_value() {
+  _impl_._oneof_case_[0] = kBoolValue;
+}
+inline void Value::clear_bool_value() {
+  if (_internal_has_bool_value()) {
+    _impl_.kind_.bool_value_ = false;
+    clear_has_kind();
+  }
+}
+inline bool Value::_internal_bool_value() const {
+  if (_internal_has_bool_value()) {
+    return _impl_.kind_.bool_value_;
+  }
+  return false;
+}
+inline void Value::_internal_set_bool_value(bool value) {
+  if (!_internal_has_bool_value()) {
+    clear_kind();
+    set_has_bool_value();
+  }
+  _impl_.kind_.bool_value_ = value;
+}
+inline bool Value::bool_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.bool_value)
+  return _internal_bool_value();
+}
+inline void Value::set_bool_value(bool value) {
+  _internal_set_bool_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.bool_value)
+}
+
+// .google.protobuf.Struct struct_value = 5;
+inline bool Value::_internal_has_struct_value() const {
+  return kind_case() == kStructValue;
+}
+inline bool Value::has_struct_value() const {
+  return _internal_has_struct_value();
+}
+inline void Value::set_has_struct_value() {
+  _impl_._oneof_case_[0] = kStructValue;
+}
+inline void Value::clear_struct_value() {
+  if (_internal_has_struct_value()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.kind_.struct_value_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::release_struct_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Value.struct_value)
+  if (_internal_has_struct_value()) {
+    clear_has_kind();
+    ::PROTOBUF_NAMESPACE_ID::Struct* temp = _impl_.kind_.struct_value_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.kind_.struct_value_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Struct& Value::_internal_struct_value() const {
+  return _internal_has_struct_value()
+      ? *_impl_.kind_.struct_value_
+      : reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::Struct&>(::PROTOBUF_NAMESPACE_ID::_Struct_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Struct& Value::struct_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.struct_value)
+  return _internal_struct_value();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::unsafe_arena_release_struct_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.struct_value)
+  if (_internal_has_struct_value()) {
+    clear_has_kind();
+    ::PROTOBUF_NAMESPACE_ID::Struct* temp = _impl_.kind_.struct_value_;
+    _impl_.kind_.struct_value_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Value::unsafe_arena_set_allocated_struct_value(::PROTOBUF_NAMESPACE_ID::Struct* struct_value) {
+  clear_kind();
+  if (struct_value) {
+    set_has_struct_value();
+    _impl_.kind_.struct_value_ = struct_value;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.struct_value)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::_internal_mutable_struct_value() {
+  if (!_internal_has_struct_value()) {
+    clear_kind();
+    set_has_struct_value();
+    _impl_.kind_.struct_value_ = CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::Struct >(GetArenaForAllocation());
+  }
+  return _impl_.kind_.struct_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::mutable_struct_value() {
+  ::PROTOBUF_NAMESPACE_ID::Struct* _msg = _internal_mutable_struct_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.struct_value)
+  return _msg;
+}
+
+// .google.protobuf.ListValue list_value = 6;
+inline bool Value::_internal_has_list_value() const {
+  return kind_case() == kListValue;
+}
+inline bool Value::has_list_value() const {
+  return _internal_has_list_value();
+}
+inline void Value::set_has_list_value() {
+  _impl_._oneof_case_[0] = kListValue;
+}
+inline void Value::clear_list_value() {
+  if (_internal_has_list_value()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete _impl_.kind_.list_value_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::release_list_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Value.list_value)
+  if (_internal_has_list_value()) {
+    clear_has_kind();
+    ::PROTOBUF_NAMESPACE_ID::ListValue* temp = _impl_.kind_.list_value_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    _impl_.kind_.list_value_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ListValue& Value::_internal_list_value() const {
+  return _internal_has_list_value()
+      ? *_impl_.kind_.list_value_
+      : reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::ListValue&>(::PROTOBUF_NAMESPACE_ID::_ListValue_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ListValue& Value::list_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.list_value)
+  return _internal_list_value();
+}
+inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::unsafe_arena_release_list_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.list_value)
+  if (_internal_has_list_value()) {
+    clear_has_kind();
+    ::PROTOBUF_NAMESPACE_ID::ListValue* temp = _impl_.kind_.list_value_;
+    _impl_.kind_.list_value_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Value::unsafe_arena_set_allocated_list_value(::PROTOBUF_NAMESPACE_ID::ListValue* list_value) {
+  clear_kind();
+  if (list_value) {
+    set_has_list_value();
+    _impl_.kind_.list_value_ = list_value;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.list_value)
+}
+inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::_internal_mutable_list_value() {
+  if (!_internal_has_list_value()) {
+    clear_kind();
+    set_has_list_value();
+    _impl_.kind_.list_value_ = CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::ListValue >(GetArenaForAllocation());
+  }
+  return _impl_.kind_.list_value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::mutable_list_value() {
+  ::PROTOBUF_NAMESPACE_ID::ListValue* _msg = _internal_mutable_list_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.list_value)
+  return _msg;
+}
+
+inline bool Value::has_kind() const {
+  return kind_case() != KIND_NOT_SET;
+}
+inline void Value::clear_has_kind() {
+  _impl_._oneof_case_[0] = KIND_NOT_SET;
+}
+inline Value::KindCase Value::kind_case() const {
+  return Value::KindCase(_impl_._oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ListValue
+
+// repeated .google.protobuf.Value values = 1;
+inline int ListValue::_internal_values_size() const {
+  return _impl_.values_.size();
+}
+inline int ListValue::values_size() const {
+  return _internal_values_size();
+}
+inline void ListValue::clear_values() {
+  _impl_.values_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::mutable_values(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ListValue.values)
+  return _impl_.values_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value >*
+ListValue::mutable_values() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ListValue.values)
+  return &_impl_.values_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Value& ListValue::_internal_values(int index) const {
+  return _impl_.values_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Value& ListValue::values(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ListValue.values)
+  return _internal_values(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::_internal_add_values() {
+  return _impl_.values_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::add_values() {
+  ::PROTOBUF_NAMESPACE_ID::Value* _add = _internal_add_values();
+  // @@protoc_insertion_point(field_add:google.protobuf.ListValue.values)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value >&
+ListValue::values() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.ListValue.values)
+  return _impl_.values_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::NullValue> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::NullValue>() {
+  return ::PROTOBUF_NAMESPACE_ID::NullValue_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fstruct_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/struct.proto b/CAPI/cpp/grpc/include/google/protobuf/struct.proto
new file mode 100644
index 0000000..0ac843c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/struct.proto
@@ -0,0 +1,95 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/protobuf/types/known/structpb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "StructProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// `Struct` represents a structured data value, consisting of fields
+// which map to dynamically typed values. In some languages, `Struct`
+// might be supported by a native representation. For example, in
+// scripting languages like JS a struct is represented as an
+// object. The details of that representation are described together
+// with the proto support for the language.
+//
+// The JSON representation for `Struct` is JSON object.
+message Struct {
+  // Unordered map of dynamically typed values.
+  map<string, Value> fields = 1;
+}
+
+// `Value` represents a dynamically typed value which can be either
+// null, a number, a string, a boolean, a recursive struct value, or a
+// list of values. A producer of value is expected to set one of these
+// variants. Absence of any variant indicates an error.
+//
+// The JSON representation for `Value` is JSON value.
+message Value {
+  // The kind of value.
+  oneof kind {
+    // Represents a null value.
+    NullValue null_value = 1;
+    // Represents a double value.
+    double number_value = 2;
+    // Represents a string value.
+    string string_value = 3;
+    // Represents a boolean value.
+    bool bool_value = 4;
+    // Represents a structured value.
+    Struct struct_value = 5;
+    // Represents a repeated `Value`.
+    ListValue list_value = 6;
+  }
+}
+
+// `NullValue` is a singleton enumeration to represent the null value for the
+// `Value` type union.
+//
+//  The JSON representation for `NullValue` is JSON `null`.
+enum NullValue {
+  // Null value.
+  NULL_VALUE = 0;
+}
+
+// `ListValue` is a wrapper around a repeated field of values.
+//
+// The JSON representation for `ListValue` is JSON array.
+message ListValue {
+  // Repeated field of dynamically typed values.
+  repeated Value values = 1;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/bytestream.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/bytestream.h
new file mode 100644
index 0000000..c7a48de
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/bytestream.h
@@ -0,0 +1,351 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file declares the ByteSink and ByteSource abstract interfaces. These
+// interfaces represent objects that consume (ByteSink) or produce (ByteSource)
+// a sequence of bytes. Using these abstract interfaces in your APIs can help
+// make your code work with a variety of input and output types.
+//
+// This file also declares the following commonly used implementations of these
+// interfaces.
+//
+//   ByteSink:
+//      UncheckedArrayByteSink  Writes to an array, without bounds checking
+//      CheckedArrayByteSink    Writes to an array, with bounds checking
+//      GrowingArrayByteSink    Allocates and writes to a growable buffer
+//      StringByteSink          Writes to an STL string
+//      NullByteSink            Consumes a never-ending stream of bytes
+//
+//   ByteSource:
+//      ArrayByteSource         Reads from an array or string/StringPiece
+//      LimitedByteSource       Limits the number of bytes read from an
+
+#ifndef GOOGLE_PROTOBUF_STUBS_BYTESTREAM_H_
+#define GOOGLE_PROTOBUF_STUBS_BYTESTREAM_H_
+
+#include <stddef.h>
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/stringpiece.h>
+
+#include <google/protobuf/port_def.inc>
+
+class CordByteSink;
+
+namespace google {
+namespace protobuf {
+namespace strings {
+
+// An abstract interface for an object that consumes a sequence of bytes. This
+// interface offers a way to append data as well as a Flush() function.
+//
+// Example:
+//
+//   string my_data;
+//   ...
+//   ByteSink* sink = ...
+//   sink->Append(my_data.data(), my_data.size());
+//   sink->Flush();
+//
+class PROTOBUF_EXPORT ByteSink {
+ public:
+  ByteSink() {}
+  virtual ~ByteSink() {}
+
+  // Appends the "n" bytes starting at "bytes".
+  virtual void Append(const char* bytes, size_t n) = 0;
+
+  // Flushes internal buffers. The default implementation does nothing. ByteSink
+  // subclasses may use internal buffers that require calling Flush() at the end
+  // of the stream.
+  virtual void Flush();
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ByteSink);
+};
+
+// An abstract interface for an object that produces a fixed-size sequence of
+// bytes.
+//
+// Example:
+//
+//   ByteSource* source = ...
+//   while (source->Available() > 0) {
+//     StringPiece data = source->Peek();
+//     ... do something with "data" ...
+//     source->Skip(data.length());
+//   }
+//
+class PROTOBUF_EXPORT ByteSource {
+ public:
+  ByteSource() {}
+  virtual ~ByteSource() {}
+
+  // Returns the number of bytes left to read from the source. Available()
+  // should decrease by N each time Skip(N) is called. Available() may not
+  // increase. Available() returning 0 indicates that the ByteSource is
+  // exhausted.
+  //
+  // Note: Size() may have been a more appropriate name as it's more
+  //       indicative of the fixed-size nature of a ByteSource.
+  virtual size_t Available() const = 0;
+
+  // Returns a StringPiece of the next contiguous region of the source. Does not
+  // reposition the source. The returned region is empty iff Available() == 0.
+  //
+  // The returned region is valid until the next call to Skip() or until this
+  // object is destroyed, whichever occurs first.
+  //
+  // The length of the returned StringPiece will be <= Available().
+  virtual StringPiece Peek() = 0;
+
+  // Skips the next n bytes. Invalidates any StringPiece returned by a previous
+  // call to Peek().
+  //
+  // REQUIRES: Available() >= n
+  virtual void Skip(size_t n) = 0;
+
+  // Writes the next n bytes in this ByteSource to the given ByteSink, and
+  // advances this ByteSource past the copied bytes. The default implementation
+  // of this method just copies the bytes normally, but subclasses might
+  // override CopyTo to optimize certain cases.
+  //
+  // REQUIRES: Available() >= n
+  virtual void CopyTo(ByteSink* sink, size_t n);
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ByteSource);
+};
+
+//
+// Some commonly used implementations of ByteSink
+//
+
+// Implementation of ByteSink that writes to an unsized byte array. No
+// bounds-checking is performed--it is the caller's responsibility to ensure
+// that the destination array is large enough.
+//
+// Example:
+//
+//   char buf[10];
+//   UncheckedArrayByteSink sink(buf);
+//   sink.Append("hi", 2);    // OK
+//   sink.Append(data, 100);  // WOOPS! Overflows buf[10].
+//
+class PROTOBUF_EXPORT UncheckedArrayByteSink : public ByteSink {
+ public:
+  explicit UncheckedArrayByteSink(char* dest) : dest_(dest) {}
+  virtual void Append(const char* data, size_t n) override;
+
+  // Returns the current output pointer so that a caller can see how many bytes
+  // were produced.
+  //
+  // Note: this method is not part of the ByteSink interface.
+  char* CurrentDestination() const { return dest_; }
+
+ private:
+  char* dest_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UncheckedArrayByteSink);
+};
+
+// Implementation of ByteSink that writes to a sized byte array. This sink will
+// not write more than "capacity" bytes to outbuf. Once "capacity" bytes are
+// appended, subsequent bytes will be ignored and Overflowed() will return true.
+// Overflowed() does not cause a runtime error (i.e., it does not CHECK fail).
+//
+// Example:
+//
+//   char buf[10];
+//   CheckedArrayByteSink sink(buf, 10);
+//   sink.Append("hi", 2);    // OK
+//   sink.Append(data, 100);  // Will only write 8 more bytes
+//
+class PROTOBUF_EXPORT CheckedArrayByteSink : public ByteSink {
+ public:
+  CheckedArrayByteSink(char* outbuf, size_t capacity);
+  virtual void Append(const char* bytes, size_t n) override;
+
+  // Returns the number of bytes actually written to the sink.
+  size_t NumberOfBytesWritten() const { return size_; }
+
+  // Returns true if any bytes were discarded, i.e., if there was an
+  // attempt to write more than 'capacity' bytes.
+  bool Overflowed() const { return overflowed_; }
+
+ private:
+  char* outbuf_;
+  const size_t capacity_;
+  size_t size_;
+  bool overflowed_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CheckedArrayByteSink);
+};
+
+// Implementation of ByteSink that allocates an internal buffer (a char array)
+// and expands it as needed to accommodate appended data (similar to a string),
+// and allows the caller to take ownership of the internal buffer via the
+// GetBuffer() method. The buffer returned from GetBuffer() must be deleted by
+// the caller with delete[]. GetBuffer() also sets the internal buffer to be
+// empty, and subsequent appends to the sink will create a new buffer. The
+// destructor will free the internal buffer if GetBuffer() was not called.
+//
+// Example:
+//
+//   GrowingArrayByteSink sink(10);
+//   sink.Append("hi", 2);
+//   sink.Append(data, n);
+//   const char* buf = sink.GetBuffer();  // Ownership transferred
+//   delete[] buf;
+//
+class PROTOBUF_EXPORT GrowingArrayByteSink : public strings::ByteSink {
+ public:
+  explicit GrowingArrayByteSink(size_t estimated_size);
+  virtual ~GrowingArrayByteSink();
+  virtual void Append(const char* bytes, size_t n) override;
+
+  // Returns the allocated buffer, and sets nbytes to its size. The caller takes
+  // ownership of the buffer and must delete it with delete[].
+  char* GetBuffer(size_t* nbytes);
+
+ private:
+  void Expand(size_t amount);
+  void ShrinkToFit();
+
+  size_t capacity_;
+  char* buf_;
+  size_t size_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GrowingArrayByteSink);
+};
+
+// Implementation of ByteSink that appends to the given string.
+// Existing contents of "dest" are not modified; new data is appended.
+//
+// Example:
+//
+//   string dest = "Hello ";
+//   StringByteSink sink(&dest);
+//   sink.Append("World", 5);
+//   assert(dest == "Hello World");
+//
+class PROTOBUF_EXPORT StringByteSink : public ByteSink {
+ public:
+  explicit StringByteSink(std::string* dest) : dest_(dest) {}
+  virtual void Append(const char* data, size_t n) override;
+
+ private:
+  std::string* dest_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringByteSink);
+};
+
+// Implementation of ByteSink that discards all data.
+//
+// Example:
+//
+//   NullByteSink sink;
+//   sink.Append(data, data.size());  // All data ignored.
+//
+class PROTOBUF_EXPORT NullByteSink : public ByteSink {
+ public:
+  NullByteSink() {}
+  void Append(const char* /*data*/, size_t /*n*/) override {}
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(NullByteSink);
+};
+
+//
+// Some commonly used implementations of ByteSource
+//
+
+// Implementation of ByteSource that reads from a StringPiece.
+//
+// Example:
+//
+//   string data = "Hello";
+//   ArrayByteSource source(data);
+//   assert(source.Available() == 5);
+//   assert(source.Peek() == "Hello");
+//
+class PROTOBUF_EXPORT ArrayByteSource : public ByteSource {
+ public:
+  explicit ArrayByteSource(StringPiece s) : input_(s) {}
+
+  virtual size_t Available() const override;
+  virtual StringPiece Peek() override;
+  virtual void Skip(size_t n) override;
+
+ private:
+  StringPiece   input_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayByteSource);
+};
+
+// Implementation of ByteSource that wraps another ByteSource, limiting the
+// number of bytes returned.
+//
+// The caller maintains ownership of the underlying source, and may not use the
+// underlying source while using the LimitByteSource object.  The underlying
+// source's pointer is advanced by n bytes every time this LimitByteSource
+// object is advanced by n.
+//
+// Example:
+//
+//   string data = "Hello World";
+//   ArrayByteSource abs(data);
+//   assert(abs.Available() == data.size());
+//
+//   LimitByteSource limit(abs, 5);
+//   assert(limit.Available() == 5);
+//   assert(limit.Peek() == "Hello");
+//
+class PROTOBUF_EXPORT LimitByteSource : public ByteSource {
+ public:
+  // Returns at most "limit" bytes from "source".
+  LimitByteSource(ByteSource* source, size_t limit);
+
+  virtual size_t Available() const override;
+  virtual StringPiece Peek() override;
+  virtual void Skip(size_t n) override;
+
+  // We override CopyTo so that we can forward to the underlying source, in
+  // case it has an efficient implementation of CopyTo.
+  virtual void CopyTo(ByteSink* sink, size_t n) override;
+
+ private:
+  ByteSource* source_;
+  size_t limit_;
+};
+
+}  // namespace strings
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_STUBS_BYTESTREAM_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/callback.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/callback.h
new file mode 100644
index 0000000..43d546d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/callback.h
@@ -0,0 +1,583 @@
+#ifndef GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
+#define GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
+
+#include <type_traits>
+
+#include <google/protobuf/stubs/macros.h>
+
+#include <google/protobuf/port_def.inc>
+
+// ===================================================================
+// emulates google3/base/callback.h
+
+namespace google {
+namespace protobuf {
+
+// Abstract interface for a callback.  When calling an RPC, you must provide
+// a Closure to call when the procedure completes.  See the Service interface
+// in service.h.
+//
+// To automatically construct a Closure which calls a particular function or
+// method with a particular set of parameters, use the NewCallback() function.
+// Example:
+//   void FooDone(const FooResponse* response) {
+//     ...
+//   }
+//
+//   void CallFoo() {
+//     ...
+//     // When done, call FooDone() and pass it a pointer to the response.
+//     Closure* callback = NewCallback(&FooDone, response);
+//     // Make the call.
+//     service->Foo(controller, request, response, callback);
+//   }
+//
+// Example that calls a method:
+//   class Handler {
+//    public:
+//     ...
+//
+//     void FooDone(const FooResponse* response) {
+//       ...
+//     }
+//
+//     void CallFoo() {
+//       ...
+//       // When done, call FooDone() and pass it a pointer to the response.
+//       Closure* callback = NewCallback(this, &Handler::FooDone, response);
+//       // Make the call.
+//       service->Foo(controller, request, response, callback);
+//     }
+//   };
+//
+// Currently NewCallback() supports binding zero, one, or two arguments.
+//
+// Callbacks created with NewCallback() automatically delete themselves when
+// executed.  They should be used when a callback is to be called exactly
+// once (usually the case with RPC callbacks).  If a callback may be called
+// a different number of times (including zero), create it with
+// NewPermanentCallback() instead.  You are then responsible for deleting the
+// callback (using the "delete" keyword as normal).
+//
+// Note that NewCallback() is a bit touchy regarding argument types.  Generally,
+// the values you provide for the parameter bindings must exactly match the
+// types accepted by the callback function.  For example:
+//   void Foo(std::string s);
+//   NewCallback(&Foo, "foo");          // WON'T WORK:  const char* != string
+//   NewCallback(&Foo, std::string("foo"));  // WORKS
+// Also note that the arguments cannot be references:
+//   void Foo(const std::string& s);
+//   std::string my_str;
+//   NewCallback(&Foo, my_str);  // WON'T WORK:  Can't use references.
+// However, correctly-typed pointers will work just fine.
+class PROTOBUF_EXPORT Closure {
+ public:
+  Closure() {}
+  virtual ~Closure();
+
+  virtual void Run() = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Closure);
+};
+
+template<typename R>
+class ResultCallback {
+ public:
+  ResultCallback() {}
+  virtual ~ResultCallback() {}
+
+  virtual R Run() = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback);
+};
+
+template <typename R, typename A1>
+class PROTOBUF_EXPORT ResultCallback1 {
+ public:
+  ResultCallback1() {}
+  virtual ~ResultCallback1() {}
+
+  virtual R Run(A1) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback1);
+};
+
+template <typename R, typename A1, typename A2>
+class PROTOBUF_EXPORT ResultCallback2 {
+ public:
+  ResultCallback2() {}
+  virtual ~ResultCallback2() {}
+
+  virtual R Run(A1,A2) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback2);
+};
+
+namespace internal {
+
+class PROTOBUF_EXPORT FunctionClosure0 : public Closure {
+ public:
+  typedef void (*FunctionType)();
+
+  FunctionClosure0(FunctionType function, bool self_deleting)
+    : function_(function), self_deleting_(self_deleting) {}
+  ~FunctionClosure0();
+
+  void Run() override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    function_();
+    if (needs_delete) delete this;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+};
+
+template <typename Class>
+class MethodClosure0 : public Closure {
+ public:
+  typedef void (Class::*MethodType)();
+
+  MethodClosure0(Class* object, MethodType method, bool self_deleting)
+    : object_(object), method_(method), self_deleting_(self_deleting) {}
+  ~MethodClosure0() {}
+
+  void Run() override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    (object_->*method_)();
+    if (needs_delete) delete this;
+  }
+
+ private:
+  Class* object_;
+  MethodType method_;
+  bool self_deleting_;
+};
+
+template <typename Arg1>
+class FunctionClosure1 : public Closure {
+ public:
+  typedef void (*FunctionType)(Arg1 arg1);
+
+  FunctionClosure1(FunctionType function, bool self_deleting,
+                   Arg1 arg1)
+    : function_(function), self_deleting_(self_deleting),
+      arg1_(arg1) {}
+  ~FunctionClosure1() {}
+
+  void Run() override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    function_(arg1_);
+    if (needs_delete) delete this;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+  Arg1 arg1_;
+};
+
+template <typename Class, typename Arg1>
+class MethodClosure1 : public Closure {
+ public:
+  typedef void (Class::*MethodType)(Arg1 arg1);
+
+  MethodClosure1(Class* object, MethodType method, bool self_deleting,
+                 Arg1 arg1)
+    : object_(object), method_(method), self_deleting_(self_deleting),
+      arg1_(arg1) {}
+  ~MethodClosure1() {}
+
+  void Run() override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    (object_->*method_)(arg1_);
+    if (needs_delete) delete this;
+  }
+
+ private:
+  Class* object_;
+  MethodType method_;
+  bool self_deleting_;
+  Arg1 arg1_;
+};
+
+template <typename Arg1, typename Arg2>
+class FunctionClosure2 : public Closure {
+ public:
+  typedef void (*FunctionType)(Arg1 arg1, Arg2 arg2);
+
+  FunctionClosure2(FunctionType function, bool self_deleting,
+                   Arg1 arg1, Arg2 arg2)
+    : function_(function), self_deleting_(self_deleting),
+      arg1_(arg1), arg2_(arg2) {}
+  ~FunctionClosure2() {}
+
+  void Run() override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    function_(arg1_, arg2_);
+    if (needs_delete) delete this;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+};
+
+template <typename Class, typename Arg1, typename Arg2>
+class MethodClosure2 : public Closure {
+ public:
+  typedef void (Class::*MethodType)(Arg1 arg1, Arg2 arg2);
+
+  MethodClosure2(Class* object, MethodType method, bool self_deleting,
+                 Arg1 arg1, Arg2 arg2)
+    : object_(object), method_(method), self_deleting_(self_deleting),
+      arg1_(arg1), arg2_(arg2) {}
+  ~MethodClosure2() {}
+
+  void Run() override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    (object_->*method_)(arg1_, arg2_);
+    if (needs_delete) delete this;
+  }
+
+ private:
+  Class* object_;
+  MethodType method_;
+  bool self_deleting_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+};
+
+template<typename R>
+class FunctionResultCallback_0_0 : public ResultCallback<R> {
+ public:
+  typedef R (*FunctionType)();
+
+  FunctionResultCallback_0_0(FunctionType function, bool self_deleting)
+      : function_(function), self_deleting_(self_deleting) {}
+  ~FunctionResultCallback_0_0() {}
+
+  R Run() override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    R result = function_();
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+};
+
+template<typename R, typename P1>
+class FunctionResultCallback_1_0 : public ResultCallback<R> {
+ public:
+  typedef R (*FunctionType)(P1);
+
+  FunctionResultCallback_1_0(FunctionType function, bool self_deleting,
+                             P1 p1)
+      : function_(function), self_deleting_(self_deleting), p1_(p1) {}
+  ~FunctionResultCallback_1_0() {}
+
+  R Run() override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    R result = function_(p1_);
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+  P1 p1_;
+};
+
+template<typename R, typename Arg1>
+class FunctionResultCallback_0_1 : public ResultCallback1<R, Arg1> {
+ public:
+  typedef R (*FunctionType)(Arg1 arg1);
+
+  FunctionResultCallback_0_1(FunctionType function, bool self_deleting)
+      : function_(function), self_deleting_(self_deleting) {}
+  ~FunctionResultCallback_0_1() {}
+
+  R Run(Arg1 a1) override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    R result = function_(a1);
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+};
+
+template<typename R, typename P1, typename A1>
+class FunctionResultCallback_1_1 : public ResultCallback1<R, A1> {
+ public:
+  typedef R (*FunctionType)(P1, A1);
+
+  FunctionResultCallback_1_1(FunctionType function, bool self_deleting,
+                             P1 p1)
+      : function_(function), self_deleting_(self_deleting), p1_(p1) {}
+  ~FunctionResultCallback_1_1() {}
+
+  R Run(A1 a1) override {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    R result = function_(p1_, a1);
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+  P1 p1_;
+};
+
+template <typename T>
+struct InternalConstRef {
+  typedef typename std::remove_reference<T>::type base_type;
+  typedef const base_type& type;
+};
+
+template<typename R, typename T>
+class MethodResultCallback_0_0 : public ResultCallback<R> {
+ public:
+  typedef R (T::*MethodType)();
+  MethodResultCallback_0_0(T* object, MethodType method, bool self_deleting)
+      : object_(object),
+        method_(method),
+        self_deleting_(self_deleting) {}
+  ~MethodResultCallback_0_0() {}
+
+  R Run() {
+    bool needs_delete = self_deleting_;
+    R result = (object_->*method_)();
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  T* object_;
+  MethodType method_;
+  bool self_deleting_;
+};
+
+template <typename R, typename T, typename P1, typename P2, typename P3,
+          typename P4, typename P5, typename P6, typename A1, typename A2>
+class MethodResultCallback_6_2 : public ResultCallback2<R, A1, A2> {
+ public:
+  typedef R (T::*MethodType)(P1, P2, P3, P4, P5, P6, A1, A2);
+  MethodResultCallback_6_2(T* object, MethodType method, bool self_deleting,
+                           P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
+      : object_(object),
+        method_(method),
+        self_deleting_(self_deleting),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4),
+        p5_(p5),
+        p6_(p6) {}
+  ~MethodResultCallback_6_2() {}
+
+  R Run(A1 a1, A2 a2) override {
+    bool needs_delete = self_deleting_;
+    R result = (object_->*method_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2);
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  T* object_;
+  MethodType method_;
+  bool self_deleting_;
+  typename std::remove_reference<P1>::type p1_;
+  typename std::remove_reference<P2>::type p2_;
+  typename std::remove_reference<P3>::type p3_;
+  typename std::remove_reference<P4>::type p4_;
+  typename std::remove_reference<P5>::type p5_;
+  typename std::remove_reference<P6>::type p6_;
+};
+
+}  // namespace internal
+
+// See Closure.
+inline Closure* NewCallback(void (*function)()) {
+  return new internal::FunctionClosure0(function, true);
+}
+
+// See Closure.
+inline Closure* NewPermanentCallback(void (*function)()) {
+  return new internal::FunctionClosure0(function, false);
+}
+
+// See Closure.
+template <typename Class>
+inline Closure* NewCallback(Class* object, void (Class::*method)()) {
+  return new internal::MethodClosure0<Class>(object, method, true);
+}
+
+// See Closure.
+template <typename Class>
+inline Closure* NewPermanentCallback(Class* object, void (Class::*method)()) {
+  return new internal::MethodClosure0<Class>(object, method, false);
+}
+
+// See Closure.
+template <typename Arg1>
+inline Closure* NewCallback(void (*function)(Arg1),
+                            Arg1 arg1) {
+  return new internal::FunctionClosure1<Arg1>(function, true, arg1);
+}
+
+// See Closure.
+template <typename Arg1>
+inline Closure* NewPermanentCallback(void (*function)(Arg1),
+                                     Arg1 arg1) {
+  return new internal::FunctionClosure1<Arg1>(function, false, arg1);
+}
+
+// See Closure.
+template <typename Class, typename Arg1>
+inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1),
+                            Arg1 arg1) {
+  return new internal::MethodClosure1<Class, Arg1>(object, method, true, arg1);
+}
+
+// See Closure.
+template <typename Class, typename Arg1>
+inline Closure* NewPermanentCallback(Class* object, void (Class::*method)(Arg1),
+                                     Arg1 arg1) {
+  return new internal::MethodClosure1<Class, Arg1>(object, method, false, arg1);
+}
+
+// See Closure.
+template <typename Arg1, typename Arg2>
+inline Closure* NewCallback(void (*function)(Arg1, Arg2),
+                            Arg1 arg1, Arg2 arg2) {
+  return new internal::FunctionClosure2<Arg1, Arg2>(
+    function, true, arg1, arg2);
+}
+
+// See Closure.
+template <typename Arg1, typename Arg2>
+inline Closure* NewPermanentCallback(void (*function)(Arg1, Arg2),
+                                     Arg1 arg1, Arg2 arg2) {
+  return new internal::FunctionClosure2<Arg1, Arg2>(
+    function, false, arg1, arg2);
+}
+
+// See Closure.
+template <typename Class, typename Arg1, typename Arg2>
+inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1, Arg2),
+                            Arg1 arg1, Arg2 arg2) {
+  return new internal::MethodClosure2<Class, Arg1, Arg2>(
+    object, method, true, arg1, arg2);
+}
+
+// See Closure.
+template <typename Class, typename Arg1, typename Arg2>
+inline Closure* NewPermanentCallback(
+    Class* object, void (Class::*method)(Arg1, Arg2),
+    Arg1 arg1, Arg2 arg2) {
+  return new internal::MethodClosure2<Class, Arg1, Arg2>(
+    object, method, false, arg1, arg2);
+}
+
+// See ResultCallback
+template<typename R>
+inline ResultCallback<R>* NewCallback(R (*function)()) {
+  return new internal::FunctionResultCallback_0_0<R>(function, true);
+}
+
+// See ResultCallback
+template<typename R>
+inline ResultCallback<R>* NewPermanentCallback(R (*function)()) {
+  return new internal::FunctionResultCallback_0_0<R>(function, false);
+}
+
+// See ResultCallback
+template<typename R, typename P1>
+inline ResultCallback<R>* NewCallback(R (*function)(P1), P1 p1) {
+  return new internal::FunctionResultCallback_1_0<R, P1>(
+      function, true, p1);
+}
+
+// See ResultCallback
+template<typename R, typename P1>
+inline ResultCallback<R>* NewPermanentCallback(
+    R (*function)(P1), P1 p1) {
+  return new internal::FunctionResultCallback_1_0<R, P1>(
+      function, false, p1);
+}
+
+// See ResultCallback1
+template<typename R, typename A1>
+inline ResultCallback1<R, A1>* NewCallback(R (*function)(A1)) {
+  return new internal::FunctionResultCallback_0_1<R, A1>(function, true);
+}
+
+// See ResultCallback1
+template<typename R, typename A1>
+inline ResultCallback1<R, A1>* NewPermanentCallback(R (*function)(A1)) {
+  return new internal::FunctionResultCallback_0_1<R, A1>(function, false);
+}
+
+// See ResultCallback1
+template<typename R, typename P1, typename A1>
+inline ResultCallback1<R, A1>* NewCallback(R (*function)(P1, A1), P1 p1) {
+  return new internal::FunctionResultCallback_1_1<R, P1, A1>(
+      function, true, p1);
+}
+
+// See ResultCallback1
+template<typename R, typename P1, typename A1>
+inline ResultCallback1<R, A1>* NewPermanentCallback(
+    R (*function)(P1, A1), P1 p1) {
+  return new internal::FunctionResultCallback_1_1<R, P1, A1>(
+      function, false, p1);
+}
+
+// See MethodResultCallback_0_0
+template <typename R, typename T1, typename T2>
+inline ResultCallback<R>* NewPermanentCallback(
+    T1* object, R (T2::*function)()) {
+  return new internal::MethodResultCallback_0_0<R, T1>(object, function, false);
+}
+
+// See MethodResultCallback_6_2
+template <typename R, typename T, typename P1, typename P2, typename P3,
+          typename P4, typename P5, typename P6, typename A1, typename A2>
+inline ResultCallback2<R, A1, A2>* NewPermanentCallback(
+    T* object, R (T::*function)(P1, P2, P3, P4, P5, P6, A1, A2),
+    typename internal::InternalConstRef<P1>::type p1,
+    typename internal::InternalConstRef<P2>::type p2,
+    typename internal::InternalConstRef<P3>::type p3,
+    typename internal::InternalConstRef<P4>::type p4,
+    typename internal::InternalConstRef<P5>::type p5,
+    typename internal::InternalConstRef<P6>::type p6) {
+  return new internal::MethodResultCallback_6_2<R, T, P1, P2, P3, P4, P5, P6,
+                                                A1, A2>(object, function, false,
+                                                        p1, p2, p3, p4, p5, p6);
+}
+
+// A function which does nothing.  Useful for creating no-op callbacks, e.g.:
+//   Closure* nothing = NewCallback(&DoNothing);
+void PROTOBUF_EXPORT DoNothing();
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/casts.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/casts.h
new file mode 100644
index 0000000..ad29dac
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/casts.h
@@ -0,0 +1,138 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2014 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_CASTS_H__
+#define GOOGLE_PROTOBUF_CASTS_H__
+
+#include <google/protobuf/stubs/common.h>
+
+#include <google/protobuf/port_def.inc>
+#include <type_traits>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Use implicit_cast as a safe version of static_cast or const_cast
+// for upcasting in the type hierarchy (i.e. casting a pointer to Foo
+// to a pointer to SuperclassOfFoo or casting a pointer to Foo to
+// a const pointer to Foo).
+// When you use implicit_cast, the compiler checks that the cast is safe.
+// Such explicit implicit_casts are necessary in surprisingly many
+// situations where C++ demands an exact type match instead of an
+// argument type convertible to a target type.
+//
+// The From type can be inferred, so the preferred syntax for using
+// implicit_cast is the same as for static_cast etc.:
+//
+//   implicit_cast<ToType>(expr)
+//
+// implicit_cast would have been part of the C++ standard library,
+// but the proposal was submitted too late.  It will probably make
+// its way into the language in the future.
+template<typename To, typename From>
+inline To implicit_cast(From const &f) {
+  return f;
+}
+
+// When you upcast (that is, cast a pointer from type Foo to type
+// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts
+// always succeed.  When you downcast (that is, cast a pointer from
+// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
+// how do you know the pointer is really of type SubclassOfFoo?  It
+// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
+// when you downcast, you should use this macro.  In debug mode, we
+// use dynamic_cast<> to double-check the downcast is legal (we die
+// if it's not).  In normal mode, we do the efficient static_cast<>
+// instead.  Thus, it's important to test in debug mode to make sure
+// the cast is legal!
+//    This is the only place in the code we should use dynamic_cast<>.
+// In particular, you SHOULDN'T be using dynamic_cast<> in order to
+// do RTTI (eg code like this:
+//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
+//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
+// You should design the code some other way not to need this.
+
+template<typename To, typename From>     // use like this: down_cast<T*>(foo);
+inline To down_cast(From* f) {                   // so we only accept pointers
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  if (false) {
+    implicit_cast<From*, To>(0);
+  }
+
+#if !defined(NDEBUG) && PROTOBUF_RTTI
+  assert(f == nullptr || dynamic_cast<To>(f) != nullptr);  // RTTI: debug mode only!
+#endif
+  return static_cast<To>(f);
+}
+
+template<typename To, typename From>    // use like this: down_cast<T&>(foo);
+inline To down_cast(From& f) {
+  typedef typename std::remove_reference<To>::type* ToAsPointer;
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  if (false) {
+    implicit_cast<From*, ToAsPointer>(0);
+  }
+
+#if !defined(NDEBUG) && PROTOBUF_RTTI
+  // RTTI: debug mode only!
+  assert(dynamic_cast<ToAsPointer>(&f) != nullptr);
+#endif
+  return *static_cast<ToAsPointer>(&f);
+}
+
+template<typename To, typename From>
+inline To bit_cast(const From& from) {
+  static_assert(sizeof(From) == sizeof(To), "bit_cast_with_different_sizes");
+  To dest;
+  memcpy(&dest, &from, sizeof(dest));
+  return dest;
+}
+
+}  // namespace internal
+
+// We made these internal so that they would show up as such in the docs,
+// but we don't want to stick "internal::" in front of them everywhere.
+using internal::implicit_cast;
+using internal::down_cast;
+using internal::bit_cast;
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_CASTS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/common.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/common.h
new file mode 100644
index 0000000..ebb1ca0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/common.h
@@ -0,0 +1,197 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda) and others
+//
+// Contains basic types and utilities used by the rest of the library.
+
+#ifndef GOOGLE_PROTOBUF_COMMON_H__
+#define GOOGLE_PROTOBUF_COMMON_H__
+
+#include <algorithm>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/macros.h>
+#include <google/protobuf/stubs/platform_macros.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/stubs/stringpiece.h>
+
+#ifndef PROTOBUF_USE_EXCEPTIONS
+#if defined(_MSC_VER) && defined(_CPPUNWIND)
+  #define PROTOBUF_USE_EXCEPTIONS 1
+#elif defined(__EXCEPTIONS)
+  #define PROTOBUF_USE_EXCEPTIONS 1
+#else
+  #define PROTOBUF_USE_EXCEPTIONS 0
+#endif
+#endif
+
+#if PROTOBUF_USE_EXCEPTIONS
+#include <exception>
+#endif
+#if defined(__APPLE__)
+#include <TargetConditionals.h>  // for TARGET_OS_IPHONE
+#endif
+
+#if defined(__ANDROID__) || defined(GOOGLE_PROTOBUF_OS_ANDROID) || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE) || defined(GOOGLE_PROTOBUF_OS_IPHONE)
+#include <pthread.h>
+#endif
+
+#include <google/protobuf/port_def.inc>
+
+namespace std {}
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Some of these constants are macros rather than const ints so that they can
+// be used in #if directives.
+
+// The current version, represented as a single integer to make comparison
+// easier:  major * 10^6 + minor * 10^3 + micro
+#define GOOGLE_PROTOBUF_VERSION 3021006
+
+// A suffix string for alpha, beta or rc releases. Empty for stable releases.
+#define GOOGLE_PROTOBUF_VERSION_SUFFIX ""
+
+// The minimum header version which works with the current version of
+// the library.  This constant should only be used by protoc's C++ code
+// generator.
+static const int kMinHeaderVersionForLibrary = 3021000;
+
+// The minimum protoc version which works with the current version of the
+// headers.
+#define GOOGLE_PROTOBUF_MIN_PROTOC_VERSION 3021000
+
+// The minimum header version which works with the current version of
+// protoc.  This constant should only be used in VerifyVersion().
+static const int kMinHeaderVersionForProtoc = 3021000;
+
+// Verifies that the headers and libraries are compatible.  Use the macro
+// below to call this.
+void PROTOBUF_EXPORT VerifyVersion(int headerVersion, int minLibraryVersion,
+                                   const char* filename);
+
+// Converts a numeric version number to a string.
+std::string PROTOBUF_EXPORT VersionString(int version);
+
+}  // namespace internal
+
+// Place this macro in your main() function (or somewhere before you attempt
+// to use the protobuf library) to verify that the version you link against
+// matches the headers you compiled against.  If a version mismatch is
+// detected, the process will abort.
+#define GOOGLE_PROTOBUF_VERIFY_VERSION                                    \
+  ::google::protobuf::internal::VerifyVersion(                            \
+    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
+    __FILE__)
+
+
+// ===================================================================
+// from google3/util/utf8/public/unilib.h
+
+namespace internal {
+
+// Checks if the buffer contains structurally-valid UTF-8.  Implemented in
+// structurally_valid.cc.
+PROTOBUF_EXPORT bool IsStructurallyValidUTF8(const char* buf, int len);
+
+inline bool IsStructurallyValidUTF8(StringPiece str) {
+  return IsStructurallyValidUTF8(str.data(), static_cast<int>(str.length()));
+}
+
+// Returns initial number of bytes of structurally valid UTF-8.
+PROTOBUF_EXPORT int UTF8SpnStructurallyValid(StringPiece str);
+
+// Coerce UTF-8 byte string in src_str to be
+// a structurally-valid equal-length string by selectively
+// overwriting illegal bytes with replace_char (typically ' ' or '?').
+// replace_char must be legal printable 7-bit Ascii 0x20..0x7e.
+// src_str is read-only.
+//
+// Returns pointer to output buffer, src_str.data() if no changes were made,
+//  or idst if some bytes were changed. idst is allocated by the caller
+//  and must be at least as big as src_str
+//
+// Optimized for: all structurally valid and no byte copying is done.
+//
+PROTOBUF_EXPORT char* UTF8CoerceToStructurallyValid(StringPiece str, char* dst,
+                                                    char replace_char);
+
+}  // namespace internal
+
+// This lives in message_lite.h now, but we leave this here for any users that
+// #include common.h and not message_lite.h.
+PROTOBUF_EXPORT void ShutdownProtobufLibrary();
+
+namespace internal {
+
+// Strongly references the given variable such that the linker will be forced
+// to pull in this variable's translation unit.
+template <typename T>
+void StrongReference(const T& var) {
+  auto volatile unused = &var;
+  (void)&unused;  // Use address to avoid an extra load of "unused".
+}
+
+}  // namespace internal
+
+#if PROTOBUF_USE_EXCEPTIONS
+class FatalException : public std::exception {
+ public:
+  FatalException(const char* filename, int line, const std::string& message)
+      : filename_(filename), line_(line), message_(message) {}
+  virtual ~FatalException() throw();
+
+  const char* what() const throw() override;
+
+  const char* filename() const { return filename_; }
+  int line() const { return line_; }
+  const std::string& message() const { return message_; }
+
+ private:
+  const char* filename_;
+  const int line_;
+  const std::string message_;
+};
+#endif
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_COMMON_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/hash.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/hash.h
new file mode 100644
index 0000000..a7ec068
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/hash.h
@@ -0,0 +1,114 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+
+#ifndef GOOGLE_PROTOBUF_STUBS_HASH_H__
+#define GOOGLE_PROTOBUF_STUBS_HASH_H__
+
+#include <cstring>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START \
+  namespace google {                                      \
+  namespace protobuf {
+# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END }}
+
+namespace google {
+namespace protobuf {
+
+template <typename Key>
+struct hash : public std::hash<Key> {};
+
+template <typename Key>
+struct hash<const Key*> {
+  inline size_t operator()(const Key* key) const {
+    return reinterpret_cast<size_t>(key);
+  }
+};
+
+// Unlike the old SGI version, the TR1 "hash" does not special-case char*.  So,
+// we go ahead and provide our own implementation.
+template <>
+struct hash<const char*> {
+  inline size_t operator()(const char* str) const {
+    size_t result = 0;
+    for (; *str != '\0'; str++) {
+      result = 5 * result + static_cast<size_t>(*str);
+    }
+    return result;
+  }
+};
+
+template<>
+struct hash<bool> {
+  size_t operator()(bool x) const {
+    return static_cast<size_t>(x);
+  }
+};
+
+template <>
+struct hash<std::string> {
+  inline size_t operator()(const std::string& key) const {
+    return hash<const char*>()(key.c_str());
+  }
+
+  static const size_t bucket_size = 4;
+  static const size_t min_buckets = 8;
+  inline bool operator()(const std::string& a, const std::string& b) const {
+    return a < b;
+  }
+};
+
+template <typename First, typename Second>
+struct hash<std::pair<First, Second> > {
+  inline size_t operator()(const std::pair<First, Second>& key) const {
+    size_t first_hash = hash<First>()(key.first);
+    size_t second_hash = hash<Second>()(key.second);
+
+    // FIXME(kenton):  What is the best way to compute this hash?  I have
+    // no idea!  This seems a bit better than an XOR.
+    return first_hash * ((1 << 16) - 1) + second_hash;
+  }
+
+  static const size_t bucket_size = 4;
+  static const size_t min_buckets = 8;
+  inline bool operator()(const std::pair<First, Second>& a,
+                           const std::pair<First, Second>& b) const {
+    return a < b;
+  }
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_HASH_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/logging.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/logging.h
new file mode 100644
index 0000000..8ecc2fa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/logging.h
@@ -0,0 +1,239 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_LOGGING_H_
+#define GOOGLE_PROTOBUF_STUBS_LOGGING_H_
+
+#include <google/protobuf/stubs/macros.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/stubs/status.h>
+#include <google/protobuf/stubs/stringpiece.h>
+
+#include <google/protobuf/port_def.inc>
+
+// ===================================================================
+// emulates google3/base/logging.h
+
+namespace google {
+namespace protobuf {
+
+enum LogLevel {
+  LOGLEVEL_INFO,     // Informational.  This is never actually used by
+                     // libprotobuf.
+  LOGLEVEL_WARNING,  // Warns about issues that, although not technically a
+                     // problem now, could cause problems in the future.  For
+                     // example, a // warning will be printed when parsing a
+                     // message that is near the message size limit.
+  LOGLEVEL_ERROR,    // An error occurred which should never happen during
+                     // normal use.
+  LOGLEVEL_FATAL,    // An error occurred from which the library cannot
+                     // recover.  This usually indicates a programming error
+                     // in the code which calls the library, especially when
+                     // compiled in debug mode.
+
+#ifdef NDEBUG
+  LOGLEVEL_DFATAL = LOGLEVEL_ERROR
+#else
+  LOGLEVEL_DFATAL = LOGLEVEL_FATAL
+#endif
+};
+
+class uint128;
+namespace internal {
+
+class LogFinisher;
+
+class PROTOBUF_EXPORT LogMessage {
+ public:
+  LogMessage(LogLevel level, const char* filename, int line);
+  ~LogMessage();
+
+  LogMessage& operator<<(const std::string& value);
+  LogMessage& operator<<(const char* value);
+  LogMessage& operator<<(char value);
+  LogMessage& operator<<(int value);
+  LogMessage& operator<<(uint value);
+  LogMessage& operator<<(long value);
+  LogMessage& operator<<(unsigned long value);
+  LogMessage& operator<<(long long value);
+  LogMessage& operator<<(unsigned long long value);
+  LogMessage& operator<<(double value);
+  LogMessage& operator<<(void* value);
+  LogMessage& operator<<(const StringPiece& value);
+  LogMessage& operator<<(const util::Status& status);
+  LogMessage& operator<<(const uint128& value);
+
+ private:
+  friend class LogFinisher;
+  void Finish();
+
+  LogLevel level_;
+  const char* filename_;
+  int line_;
+  std::string message_;
+};
+
+// Used to make the entire "LOG(BLAH) << etc." expression have a void return
+// type and print a newline after each message.
+class PROTOBUF_EXPORT LogFinisher {
+ public:
+  void operator=(LogMessage& other);
+};
+
+template<typename T>
+bool IsOk(T status) { return status.ok(); }
+template<>
+inline bool IsOk(bool status) { return status; }
+
+}  // namespace internal
+
+// Undef everything in case we're being mixed with some other Google library
+// which already defined them itself.  Presumably all Google libraries will
+// support the same syntax for these so it should not be a big deal if they
+// end up using our definitions instead.
+#undef GOOGLE_LOG
+#undef GOOGLE_LOG_IF
+
+#undef GOOGLE_CHECK
+#undef GOOGLE_CHECK_OK
+#undef GOOGLE_CHECK_EQ
+#undef GOOGLE_CHECK_NE
+#undef GOOGLE_CHECK_LT
+#undef GOOGLE_CHECK_LE
+#undef GOOGLE_CHECK_GT
+#undef GOOGLE_CHECK_GE
+#undef GOOGLE_CHECK_NOTNULL
+
+#undef GOOGLE_DLOG
+#undef GOOGLE_DCHECK
+#undef GOOGLE_DCHECK_OK
+#undef GOOGLE_DCHECK_EQ
+#undef GOOGLE_DCHECK_NE
+#undef GOOGLE_DCHECK_LT
+#undef GOOGLE_DCHECK_LE
+#undef GOOGLE_DCHECK_GT
+#undef GOOGLE_DCHECK_GE
+
+#define GOOGLE_LOG(LEVEL)                          \
+  ::google::protobuf::internal::LogFinisher() = \
+      ::google::protobuf::internal::LogMessage( \
+          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
+#define GOOGLE_LOG_IF(LEVEL, CONDITION) \
+  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
+
+#define GOOGLE_CHECK(EXPRESSION) \
+  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
+#define GOOGLE_CHECK_OK(A) GOOGLE_CHECK(::google::protobuf::internal::IsOk(A))
+#define GOOGLE_CHECK_EQ(A, B) GOOGLE_CHECK((A) == (B))
+#define GOOGLE_CHECK_NE(A, B) GOOGLE_CHECK((A) != (B))
+#define GOOGLE_CHECK_LT(A, B) GOOGLE_CHECK((A) <  (B))
+#define GOOGLE_CHECK_LE(A, B) GOOGLE_CHECK((A) <= (B))
+#define GOOGLE_CHECK_GT(A, B) GOOGLE_CHECK((A) >  (B))
+#define GOOGLE_CHECK_GE(A, B) GOOGLE_CHECK((A) >= (B))
+
+namespace internal {
+template<typename T>
+T* CheckNotNull(const char* /* file */, int /* line */,
+                const char* name, T* val) {
+  if (val == nullptr) {
+    GOOGLE_LOG(FATAL) << name;
+  }
+  return val;
+}
+}  // namespace internal
+#define GOOGLE_CHECK_NOTNULL(A)               \
+  ::google::protobuf::internal::CheckNotNull( \
+      __FILE__, __LINE__, "'" #A "' must not be nullptr", (A))
+
+#ifdef NDEBUG
+
+#define GOOGLE_DLOG(LEVEL) GOOGLE_LOG_IF(LEVEL, false)
+
+#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
+#define GOOGLE_DCHECK_OK(E) GOOGLE_DCHECK(::google::protobuf::internal::IsOk(E))
+#define GOOGLE_DCHECK_EQ(A, B) GOOGLE_DCHECK((A) == (B))
+#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
+#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
+#define GOOGLE_DCHECK_LE(A, B) GOOGLE_DCHECK((A) <= (B))
+#define GOOGLE_DCHECK_GT(A, B) GOOGLE_DCHECK((A) >  (B))
+#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
+
+#else  // NDEBUG
+
+#define GOOGLE_DLOG GOOGLE_LOG
+
+#define GOOGLE_DCHECK    GOOGLE_CHECK
+#define GOOGLE_DCHECK_OK GOOGLE_CHECK_OK
+#define GOOGLE_DCHECK_EQ GOOGLE_CHECK_EQ
+#define GOOGLE_DCHECK_NE GOOGLE_CHECK_NE
+#define GOOGLE_DCHECK_LT GOOGLE_CHECK_LT
+#define GOOGLE_DCHECK_LE GOOGLE_CHECK_LE
+#define GOOGLE_DCHECK_GT GOOGLE_CHECK_GT
+#define GOOGLE_DCHECK_GE GOOGLE_CHECK_GE
+
+#endif  // !NDEBUG
+
+typedef void LogHandler(LogLevel level, const char* filename, int line,
+                        const std::string& message);
+
+// The protobuf library sometimes writes warning and error messages to
+// stderr.  These messages are primarily useful for developers, but may
+// also help end users figure out a problem.  If you would prefer that
+// these messages be sent somewhere other than stderr, call SetLogHandler()
+// to set your own handler.  This returns the old handler.  Set the handler
+// to nullptr to ignore log messages (but see also LogSilencer, below).
+//
+// Obviously, SetLogHandler is not thread-safe.  You should only call it
+// at initialization time, and probably not from library code.  If you
+// simply want to suppress log messages temporarily (e.g. because you
+// have some code that tends to trigger them frequently and you know
+// the warnings are not important to you), use the LogSilencer class
+// below.
+PROTOBUF_EXPORT LogHandler* SetLogHandler(LogHandler* new_func);
+
+// Create a LogSilencer if you want to temporarily suppress all log
+// messages.  As long as any LogSilencer objects exist, non-fatal
+// log messages will be discarded (the current LogHandler will *not*
+// be called).  Constructing a LogSilencer is thread-safe.  You may
+// accidentally suppress log messages occurring in another thread, but
+// since messages are generally for debugging purposes only, this isn't
+// a big deal.  If you want to intercept log messages, use SetLogHandler().
+class PROTOBUF_EXPORT LogSilencer {
+ public:
+  LogSilencer();
+  ~LogSilencer();
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_STUBS_LOGGING_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/macros.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/macros.h
new file mode 100644
index 0000000..ae9a8b9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/macros.h
@@ -0,0 +1,93 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MACROS_H__
+#define GOOGLE_PROTOBUF_MACROS_H__
+
+namespace google {
+namespace protobuf {
+
+#undef GOOGLE_DISALLOW_EVIL_CONSTRUCTORS
+#define GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeName) \
+  TypeName(const TypeName&) = delete;               \
+  void operator=(const TypeName&) = delete
+
+#undef GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS
+#define GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+  TypeName() = delete;                                  \
+  TypeName(const TypeName&) = delete;                   \
+  void operator=(const TypeName&) = delete
+
+// ===================================================================
+// from google3/base/basictypes.h
+
+// The GOOGLE_ARRAYSIZE(arr) macro returns the # of elements in an array arr.
+// The expression is a compile-time constant, and therefore can be
+// used in defining new arrays, for example.
+//
+// GOOGLE_ARRAYSIZE catches a few type errors.  If you see a compiler error
+//
+//   "warning: division by zero in ..."
+//
+// when using GOOGLE_ARRAYSIZE, you are (wrongfully) giving it a pointer.
+// You should only use GOOGLE_ARRAYSIZE on statically allocated arrays.
+//
+// The following comments are on the implementation details, and can
+// be ignored by the users.
+//
+// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
+// the array) and sizeof(*(arr)) (the # of bytes in one array
+// element).  If the former is divisible by the latter, perhaps arr is
+// indeed an array, in which case the division result is the # of
+// elements in the array.  Otherwise, arr cannot possibly be an array,
+// and we generate a compiler error to prevent the code from
+// compiling.
+//
+// Since the size of bool is implementation-defined, we need to cast
+// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
+// result has type size_t.
+//
+// This macro is not perfect as it wrongfully accepts certain
+// pointers, namely where the pointer size is divisible by the pointee
+// size.  Since all our code has to go through a 32-bit compiler,
+// where a pointer is 4 bytes, this means all pointers to a type whose
+// size is 3 or greater than 4 will be (righteously) rejected.
+//
+// Kudos to Jorg Brown for this simple and elegant implementation.
+
+#undef GOOGLE_ARRAYSIZE
+#define GOOGLE_ARRAYSIZE(a) \
+  ((sizeof(a) / sizeof(*(a))) / \
+   static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_MACROS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h
new file mode 100644
index 0000000..24e098a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h
@@ -0,0 +1,769 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2014 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// from google3/util/gtl/map_util.h
+// Author: Anton Carver
+
+#ifndef GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__
+#define GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__
+
+#include <stddef.h>
+#include <iterator>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+// Local implementation of RemoveConst to avoid including base/type_traits.h.
+template <class T> struct RemoveConst { typedef T type; };
+template <class T> struct RemoveConst<const T> : RemoveConst<T> {};
+}  // namespace internal
+
+//
+// Find*()
+//
+
+// Returns a const reference to the value associated with the given key if it
+// exists. Crashes otherwise.
+//
+// This is intended as a replacement for operator[] as an rvalue (for reading)
+// when the key is guaranteed to exist.
+//
+// operator[] for lookup is discouraged for several reasons:
+//  * It has a side-effect of inserting missing keys
+//  * It is not thread-safe (even when it is not inserting, it can still
+//      choose to resize the underlying storage)
+//  * It invalidates iterators (when it chooses to resize)
+//  * It default constructs a value object even if it doesn't need to
+//
+// This version assumes the key is printable, and includes it in the fatal log
+// message.
+template <class Collection>
+const typename Collection::value_type::second_type&
+FindOrDie(const Collection& collection,
+          const typename Collection::value_type::first_type& key) {
+  typename Collection::const_iterator it = collection.find(key);
+  GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
+  return it->second;
+}
+
+// Same as above, but returns a non-const reference.
+template <class Collection>
+typename Collection::value_type::second_type&
+FindOrDie(Collection& collection,  // NOLINT
+          const typename Collection::value_type::first_type& key) {
+  typename Collection::iterator it = collection.find(key);
+  GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
+  return it->second;
+}
+
+// Same as FindOrDie above, but doesn't log the key on failure.
+template <class Collection>
+const typename Collection::value_type::second_type&
+FindOrDieNoPrint(const Collection& collection,
+                 const typename Collection::value_type::first_type& key) {
+  typename Collection::const_iterator it = collection.find(key);
+  GOOGLE_CHECK(it != collection.end()) << "Map key not found";
+  return it->second;
+}
+
+// Same as above, but returns a non-const reference.
+template <class Collection>
+typename Collection::value_type::second_type&
+FindOrDieNoPrint(Collection& collection,  // NOLINT
+                 const typename Collection::value_type::first_type& key) {
+  typename Collection::iterator it = collection.find(key);
+  GOOGLE_CHECK(it != collection.end()) << "Map key not found";
+  return it->second;
+}
+
+// Returns a const reference to the value associated with the given key if it
+// exists, otherwise returns a const reference to the provided default value.
+//
+// WARNING: If a temporary object is passed as the default "value,"
+// this function will return a reference to that temporary object,
+// which will be destroyed at the end of the statement. A common
+// example: if you have a map with string values, and you pass a char*
+// as the default "value," either use the returned value immediately
+// or store it in a string (not string&).
+// Details: http://go/findwithdefault
+template <class Collection>
+const typename Collection::value_type::second_type&
+FindWithDefault(const Collection& collection,
+                const typename Collection::value_type::first_type& key,
+                const typename Collection::value_type::second_type& value) {
+  typename Collection::const_iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return value;
+  }
+  return it->second;
+}
+
+// Returns a pointer to the const value associated with the given key if it
+// exists, or nullptr otherwise.
+template <class Collection>
+const typename Collection::value_type::second_type*
+FindOrNull(const Collection& collection,
+           const typename Collection::value_type::first_type& key) {
+  typename Collection::const_iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return 0;
+  }
+  return &it->second;
+}
+
+// Same as above but returns a pointer to the non-const value.
+template <class Collection>
+typename Collection::value_type::second_type*
+FindOrNull(Collection& collection,  // NOLINT
+           const typename Collection::value_type::first_type& key) {
+  typename Collection::iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return 0;
+  }
+  return &it->second;
+}
+
+// Returns the pointer value associated with the given key. If none is found,
+// nullptr is returned. The function is designed to be used with a map of keys to
+// pointers.
+//
+// This function does not distinguish between a missing key and a key mapped
+// to nullptr.
+template <class Collection>
+typename Collection::value_type::second_type
+FindPtrOrNull(const Collection& collection,
+              const typename Collection::value_type::first_type& key) {
+  typename Collection::const_iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return typename Collection::value_type::second_type();
+  }
+  return it->second;
+}
+
+// Same as above, except takes non-const reference to collection.
+//
+// This function is needed for containers that propagate constness to the
+// pointee, such as boost::ptr_map.
+template <class Collection>
+typename Collection::value_type::second_type
+FindPtrOrNull(Collection& collection,  // NOLINT
+              const typename Collection::value_type::first_type& key) {
+  typename Collection::iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return typename Collection::value_type::second_type();
+  }
+  return it->second;
+}
+
+// Finds the pointer value associated with the given key in a map whose values
+// are linked_ptrs. Returns nullptr if key is not found.
+template <class Collection>
+typename Collection::value_type::second_type::element_type*
+FindLinkedPtrOrNull(const Collection& collection,
+                    const typename Collection::value_type::first_type& key) {
+  typename Collection::const_iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return 0;
+  }
+  // Since linked_ptr::get() is a const member returning a non const,
+  // we do not need a version of this function taking a non const collection.
+  return it->second.get();
+}
+
+// Same as above, but dies if the key is not found.
+template <class Collection>
+typename Collection::value_type::second_type::element_type&
+FindLinkedPtrOrDie(const Collection& collection,
+                   const typename Collection::value_type::first_type& key) {
+  typename Collection::const_iterator it = collection.find(key);
+  GOOGLE_CHECK(it != collection.end()) <<  "key not found: " << key;
+  // Since linked_ptr::operator*() is a const member returning a non const,
+  // we do not need a version of this function taking a non const collection.
+  return *it->second;
+}
+
+// Finds the value associated with the given key and copies it to *value (if not
+// nullptr). Returns false if the key was not found, true otherwise.
+template <class Collection, class Key, class Value>
+bool FindCopy(const Collection& collection,
+              const Key& key,
+              Value* const value) {
+  typename Collection::const_iterator it = collection.find(key);
+  if (it == collection.end()) {
+    return false;
+  }
+  if (value) {
+    *value = it->second;
+  }
+  return true;
+}
+
+//
+// Contains*()
+//
+
+// Returns true if and only if the given collection contains the given key.
+template <class Collection, class Key>
+bool ContainsKey(const Collection& collection, const Key& key) {
+  return collection.find(key) != collection.end();
+}
+
+// Returns true if and only if the given collection contains the given key-value
+// pair.
+template <class Collection, class Key, class Value>
+bool ContainsKeyValuePair(const Collection& collection,
+                          const Key& key,
+                          const Value& value) {
+  typedef typename Collection::const_iterator const_iterator;
+  std::pair<const_iterator, const_iterator> range = collection.equal_range(key);
+  for (const_iterator it = range.first; it != range.second; ++it) {
+    if (it->second == value) {
+      return true;
+    }
+  }
+  return false;
+}
+
+//
+// Insert*()
+//
+
+// Inserts the given key-value pair into the collection. Returns true if and
+// only if the key from the given pair didn't previously exist. Otherwise, the
+// value in the map is replaced with the value from the given pair.
+template <class Collection>
+bool InsertOrUpdate(Collection* const collection,
+                    const typename Collection::value_type& vt) {
+  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
+  if (!ret.second) {
+    // update
+    ret.first->second = vt.second;
+    return false;
+  }
+  return true;
+}
+
+// Same as above, except that the key and value are passed separately.
+template <class Collection>
+bool InsertOrUpdate(Collection* const collection,
+                    const typename Collection::value_type::first_type& key,
+                    const typename Collection::value_type::second_type& value) {
+  return InsertOrUpdate(
+      collection, typename Collection::value_type(key, value));
+}
+
+// Inserts/updates all the key-value pairs from the range defined by the
+// iterators "first" and "last" into the given collection.
+template <class Collection, class InputIterator>
+void InsertOrUpdateMany(Collection* const collection,
+                        InputIterator first, InputIterator last) {
+  for (; first != last; ++first) {
+    InsertOrUpdate(collection, *first);
+  }
+}
+
+// Change the value associated with a particular key in a map or hash_map
+// of the form map<Key, Value*> which owns the objects pointed to by the
+// value pointers.  If there was an existing value for the key, it is deleted.
+// True indicates an insert took place, false indicates an update + delete.
+template <class Collection>
+bool InsertAndDeleteExisting(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key,
+    const typename Collection::value_type::second_type& value) {
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(key, value));
+  if (!ret.second) {
+    delete ret.first->second;
+    ret.first->second = value;
+    return false;
+  }
+  return true;
+}
+
+// Inserts the given key and value into the given collection if and only if the
+// given key did NOT already exist in the collection. If the key previously
+// existed in the collection, the value is not changed. Returns true if the
+// key-value pair was inserted; returns false if the key was already present.
+template <class Collection>
+bool InsertIfNotPresent(Collection* const collection,
+                        const typename Collection::value_type& vt) {
+  return collection->insert(vt).second;
+}
+
+// Same as above except the key and value are passed separately.
+template <class Collection>
+bool InsertIfNotPresent(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key,
+    const typename Collection::value_type::second_type& value) {
+  return InsertIfNotPresent(
+      collection, typename Collection::value_type(key, value));
+}
+
+// Same as above except dies if the key already exists in the collection.
+template <class Collection>
+void InsertOrDie(Collection* const collection,
+                 const typename Collection::value_type& value) {
+  GOOGLE_CHECK(InsertIfNotPresent(collection, value))
+      << "duplicate value: " << value;
+}
+
+// Same as above except doesn't log the value on error.
+template <class Collection>
+void InsertOrDieNoPrint(Collection* const collection,
+                        const typename Collection::value_type& value) {
+  GOOGLE_CHECK(InsertIfNotPresent(collection, value)) << "duplicate value.";
+}
+
+// Inserts the key-value pair into the collection. Dies if key was already
+// present.
+template <class Collection>
+void InsertOrDie(Collection* const collection,
+                 const typename Collection::value_type::first_type& key,
+                 const typename Collection::value_type::second_type& data) {
+  GOOGLE_CHECK(InsertIfNotPresent(collection, key, data))
+      << "duplicate key: " << key;
+}
+
+// Same as above except doesn't log the key on error.
+template <class Collection>
+void InsertOrDieNoPrint(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key,
+    const typename Collection::value_type::second_type& data) {
+  GOOGLE_CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key.";
+}
+
+// Inserts a new key and default-initialized value. Dies if the key was already
+// present. Returns a reference to the value. Example usage:
+//
+// map<int, SomeProto> m;
+// SomeProto& proto = InsertKeyOrDie(&m, 3);
+// proto.set_field("foo");
+template <class Collection>
+typename Collection::value_type::second_type& InsertKeyOrDie(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key) {
+  typedef typename Collection::value_type value_type;
+  std::pair<typename Collection::iterator, bool> res =
+      collection->insert(value_type(key, typename value_type::second_type()));
+  GOOGLE_CHECK(res.second) << "duplicate key: " << key;
+  return res.first->second;
+}
+
+//
+// Lookup*()
+//
+
+// Looks up a given key and value pair in a collection and inserts the key-value
+// pair if it's not already present. Returns a reference to the value associated
+// with the key.
+template <class Collection>
+typename Collection::value_type::second_type&
+LookupOrInsert(Collection* const collection,
+               const typename Collection::value_type& vt) {
+  return collection->insert(vt).first->second;
+}
+
+// Same as above except the key-value are passed separately.
+template <class Collection>
+typename Collection::value_type::second_type&
+LookupOrInsert(Collection* const collection,
+               const typename Collection::value_type::first_type& key,
+               const typename Collection::value_type::second_type& value) {
+  return LookupOrInsert(
+      collection, typename Collection::value_type(key, value));
+}
+
+// Counts the number of equivalent elements in the given "sequence", and stores
+// the results in "count_map" with element as the key and count as the value.
+//
+// Example:
+//   vector<string> v = {"a", "b", "c", "a", "b"};
+//   map<string, int> m;
+//   AddTokenCounts(v, 1, &m);
+//   assert(m["a"] == 2);
+//   assert(m["b"] == 2);
+//   assert(m["c"] == 1);
+template <typename Sequence, typename Collection>
+void AddTokenCounts(
+    const Sequence& sequence,
+    const typename Collection::value_type::second_type& increment,
+    Collection* const count_map) {
+  for (typename Sequence::const_iterator it = sequence.begin();
+       it != sequence.end(); ++it) {
+    typename Collection::value_type::second_type& value =
+        LookupOrInsert(count_map, *it,
+                       typename Collection::value_type::second_type());
+    value += increment;
+  }
+}
+
+// Returns a reference to the value associated with key. If not found, a value
+// is default constructed on the heap and added to the map.
+//
+// This function is useful for containers of the form map<Key, Value*>, where
+// inserting a new key, value pair involves constructing a new heap-allocated
+// Value, and storing a pointer to that in the collection.
+template <class Collection>
+typename Collection::value_type::second_type&
+LookupOrInsertNew(Collection* const collection,
+                  const typename Collection::value_type::first_type& key) {
+  typedef typename std::iterator_traits<
+    typename Collection::value_type::second_type>::value_type Element;
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(
+          key,
+          static_cast<typename Collection::value_type::second_type>(nullptr)));
+  if (ret.second) {
+    ret.first->second = new Element();
+  }
+  return ret.first->second;
+}
+
+// Same as above but constructs the value using the single-argument constructor
+// and the given "arg".
+template <class Collection, class Arg>
+typename Collection::value_type::second_type&
+LookupOrInsertNew(Collection* const collection,
+                  const typename Collection::value_type::first_type& key,
+                  const Arg& arg) {
+  typedef typename std::iterator_traits<
+    typename Collection::value_type::second_type>::value_type Element;
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(
+          key,
+          static_cast<typename Collection::value_type::second_type>(nullptr)));
+  if (ret.second) {
+    ret.first->second = new Element(arg);
+  }
+  return ret.first->second;
+}
+
+// Lookup of linked/shared pointers is used in two scenarios:
+//
+// Use LookupOrInsertNewLinkedPtr if the container owns the elements.
+// In this case it is fine working with the raw pointer as long as it is
+// guaranteed that no other thread can delete/update an accessed element.
+// A mutex will need to lock the container operation as well as the use
+// of the returned elements. Finding an element may be performed using
+// FindLinkedPtr*().
+//
+// Use LookupOrInsertNewSharedPtr if the container does not own the elements
+// for their whole lifetime. This is typically the case when a reader allows
+// parallel updates to the container. In this case a Mutex only needs to lock
+// container operations, but all element operations must be performed on the
+// shared pointer. Finding an element must be performed using FindPtr*() and
+// cannot be done with FindLinkedPtr*() even though it compiles.
+
+// Lookup a key in a map or hash_map whose values are linked_ptrs.  If it is
+// missing, set collection[key].reset(new Value::element_type) and return that.
+// Value::element_type must be default constructable.
+template <class Collection>
+typename Collection::value_type::second_type::element_type*
+LookupOrInsertNewLinkedPtr(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key) {
+  typedef typename Collection::value_type::second_type Value;
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(key, Value()));
+  if (ret.second) {
+    ret.first->second.reset(new typename Value::element_type);
+  }
+  return ret.first->second.get();
+}
+
+// A variant of LookupOrInsertNewLinkedPtr where the value is constructed using
+// a single-parameter constructor.  Note: the constructor argument is computed
+// even if it will not be used, so only values cheap to compute should be passed
+// here.  On the other hand it does not matter how expensive the construction of
+// the actual stored value is, as that only occurs if necessary.
+template <class Collection, class Arg>
+typename Collection::value_type::second_type::element_type*
+LookupOrInsertNewLinkedPtr(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key,
+    const Arg& arg) {
+  typedef typename Collection::value_type::second_type Value;
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(key, Value()));
+  if (ret.second) {
+    ret.first->second.reset(new typename Value::element_type(arg));
+  }
+  return ret.first->second.get();
+}
+
+// Lookup a key in a map or hash_map whose values are shared_ptrs.  If it is
+// missing, set collection[key].reset(new Value::element_type). Unlike
+// LookupOrInsertNewLinkedPtr, this function returns the shared_ptr instead of
+// the raw pointer. Value::element_type must be default constructable.
+template <class Collection>
+typename Collection::value_type::second_type&
+LookupOrInsertNewSharedPtr(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key) {
+  typedef typename Collection::value_type::second_type SharedPtr;
+  typedef typename Collection::value_type::second_type::element_type Element;
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(key, SharedPtr()));
+  if (ret.second) {
+    ret.first->second.reset(new Element());
+  }
+  return ret.first->second;
+}
+
+// A variant of LookupOrInsertNewSharedPtr where the value is constructed using
+// a single-parameter constructor.  Note: the constructor argument is computed
+// even if it will not be used, so only values cheap to compute should be passed
+// here.  On the other hand it does not matter how expensive the construction of
+// the actual stored value is, as that only occurs if necessary.
+template <class Collection, class Arg>
+typename Collection::value_type::second_type&
+LookupOrInsertNewSharedPtr(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key,
+    const Arg& arg) {
+  typedef typename Collection::value_type::second_type SharedPtr;
+  typedef typename Collection::value_type::second_type::element_type Element;
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(key, SharedPtr()));
+  if (ret.second) {
+    ret.first->second.reset(new Element(arg));
+  }
+  return ret.first->second;
+}
+
+//
+// Misc Utility Functions
+//
+
+// Updates the value associated with the given key. If the key was not already
+// present, then the key-value pair are inserted and "previous" is unchanged. If
+// the key was already present, the value is updated and "*previous" will
+// contain a copy of the old value.
+//
+// InsertOrReturnExisting has complementary behavior that returns the
+// address of an already existing value, rather than updating it.
+template <class Collection>
+bool UpdateReturnCopy(Collection* const collection,
+                      const typename Collection::value_type::first_type& key,
+                      const typename Collection::value_type::second_type& value,
+                      typename Collection::value_type::second_type* previous) {
+  std::pair<typename Collection::iterator, bool> ret =
+      collection->insert(typename Collection::value_type(key, value));
+  if (!ret.second) {
+    // update
+    if (previous) {
+      *previous = ret.first->second;
+    }
+    ret.first->second = value;
+    return true;
+  }
+  return false;
+}
+
+// Same as above except that the key and value are passed as a pair.
+template <class Collection>
+bool UpdateReturnCopy(Collection* const collection,
+                      const typename Collection::value_type& vt,
+                      typename Collection::value_type::second_type* previous) {
+  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
+  if (!ret.second) {
+    // update
+    if (previous) {
+      *previous = ret.first->second;
+    }
+    ret.first->second = vt.second;
+    return true;
+  }
+  return false;
+}
+
+// Tries to insert the given key-value pair into the collection. Returns nullptr if
+// the insert succeeds. Otherwise, returns a pointer to the existing value.
+//
+// This complements UpdateReturnCopy in that it allows to update only after
+// verifying the old value and still insert quickly without having to look up
+// twice. Unlike UpdateReturnCopy this also does not come with the issue of an
+// undefined previous* in case new data was inserted.
+template <class Collection>
+typename Collection::value_type::second_type* InsertOrReturnExisting(
+    Collection* const collection, const typename Collection::value_type& vt) {
+  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
+  if (ret.second) {
+    return nullptr;  // Inserted, no existing previous value.
+  } else {
+    return &ret.first->second;  // Return address of already existing value.
+  }
+}
+
+// Same as above, except for explicit key and data.
+template <class Collection>
+typename Collection::value_type::second_type* InsertOrReturnExisting(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key,
+    const typename Collection::value_type::second_type& data) {
+  return InsertOrReturnExisting(collection,
+                                typename Collection::value_type(key, data));
+}
+
+// Erases the collection item identified by the given key, and returns the value
+// associated with that key. It is assumed that the value (i.e., the
+// mapped_type) is a pointer. Returns nullptr if the key was not found in the
+// collection.
+//
+// Examples:
+//   map<string, MyType*> my_map;
+//
+// One line cleanup:
+//     delete EraseKeyReturnValuePtr(&my_map, "abc");
+//
+// Use returned value:
+//     std::unique_ptr<MyType> value_ptr(
+//         EraseKeyReturnValuePtr(&my_map, "abc"));
+//     if (value_ptr.get())
+//       value_ptr->DoSomething();
+//
+template <class Collection>
+typename Collection::value_type::second_type EraseKeyReturnValuePtr(
+    Collection* const collection,
+    const typename Collection::value_type::first_type& key) {
+  typename Collection::iterator it = collection->find(key);
+  if (it == collection->end()) {
+    return nullptr;
+  }
+  typename Collection::value_type::second_type v = it->second;
+  collection->erase(it);
+  return v;
+}
+
+// Inserts all the keys from map_container into key_container, which must
+// support insert(MapContainer::key_type).
+//
+// Note: any initial contents of the key_container are not cleared.
+template <class MapContainer, class KeyContainer>
+void InsertKeysFromMap(const MapContainer& map_container,
+                       KeyContainer* key_container) {
+  GOOGLE_CHECK(key_container != nullptr);
+  for (typename MapContainer::const_iterator it = map_container.begin();
+       it != map_container.end(); ++it) {
+    key_container->insert(it->first);
+  }
+}
+
+// Appends all the keys from map_container into key_container, which must
+// support push_back(MapContainer::key_type).
+//
+// Note: any initial contents of the key_container are not cleared.
+template <class MapContainer, class KeyContainer>
+void AppendKeysFromMap(const MapContainer& map_container,
+                       KeyContainer* key_container) {
+  GOOGLE_CHECK(key_container != nullptr);
+  for (typename MapContainer::const_iterator it = map_container.begin();
+       it != map_container.end(); ++it) {
+    key_container->push_back(it->first);
+  }
+}
+
+// A more specialized overload of AppendKeysFromMap to optimize reallocations
+// for the common case in which we're appending keys to a vector and hence can
+// (and sometimes should) call reserve() first.
+//
+// (It would be possible to play SFINAE games to call reserve() for any
+// container that supports it, but this seems to get us 99% of what we need
+// without the complexity of a SFINAE-based solution.)
+template <class MapContainer, class KeyType>
+void AppendKeysFromMap(const MapContainer& map_container,
+                       std::vector<KeyType>* key_container) {
+  GOOGLE_CHECK(key_container != nullptr);
+  // We now have the opportunity to call reserve(). Calling reserve() every
+  // time is a bad idea for some use cases: libstdc++'s implementation of
+  // vector<>::reserve() resizes the vector's backing store to exactly the
+  // given size (unless it's already at least that big). Because of this,
+  // the use case that involves appending a lot of small maps (total size
+  // N) one by one to a vector would be O(N^2). But never calling reserve()
+  // loses the opportunity to improve the use case of adding from a large
+  // map to an empty vector (this improves performance by up to 33%). A
+  // number of heuristics are possible; see the discussion in
+  // cl/34081696. Here we use the simplest one.
+  if (key_container->empty()) {
+    key_container->reserve(map_container.size());
+  }
+  for (typename MapContainer::const_iterator it = map_container.begin();
+       it != map_container.end(); ++it) {
+    key_container->push_back(it->first);
+  }
+}
+
+// Inserts all the values from map_container into value_container, which must
+// support push_back(MapContainer::mapped_type).
+//
+// Note: any initial contents of the value_container are not cleared.
+template <class MapContainer, class ValueContainer>
+void AppendValuesFromMap(const MapContainer& map_container,
+                         ValueContainer* value_container) {
+  GOOGLE_CHECK(value_container != nullptr);
+  for (typename MapContainer::const_iterator it = map_container.begin();
+       it != map_container.end(); ++it) {
+    value_container->push_back(it->second);
+  }
+}
+
+// A more specialized overload of AppendValuesFromMap to optimize reallocations
+// for the common case in which we're appending values to a vector and hence
+// can (and sometimes should) call reserve() first.
+//
+// (It would be possible to play SFINAE games to call reserve() for any
+// container that supports it, but this seems to get us 99% of what we need
+// without the complexity of a SFINAE-based solution.)
+template <class MapContainer, class ValueType>
+void AppendValuesFromMap(const MapContainer& map_container,
+                         std::vector<ValueType>* value_container) {
+  GOOGLE_CHECK(value_container != nullptr);
+  // See AppendKeysFromMap for why this is done.
+  if (value_container->empty()) {
+    value_container->reserve(map_container.size());
+  }
+  for (typename MapContainer::const_iterator it = map_container.begin();
+       it != map_container.end(); ++it) {
+    value_container->push_back(it->second);
+  }
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/mutex.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/mutex.h
new file mode 100644
index 0000000..c459991
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/mutex.h
@@ -0,0 +1,218 @@
+// Copyright (c) 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_MUTEX_H_
+#define GOOGLE_PROTOBUF_STUBS_MUTEX_H_
+
+#include <mutex>
+
+#ifdef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
+
+#include <windows.h>
+
+// GetMessage conflicts with GeneratedMessageReflection::GetMessage().
+#ifdef GetMessage
+#undef GetMessage
+#endif
+
+#endif
+
+#include <google/protobuf/stubs/macros.h>
+
+// Define thread-safety annotations for use below, if we are building with
+// Clang.
+#if defined(__clang__) && !defined(SWIG)
+#define GOOGLE_PROTOBUF_ACQUIRE(...) \
+  __attribute__((acquire_capability(__VA_ARGS__)))
+#define GOOGLE_PROTOBUF_RELEASE(...) \
+  __attribute__((release_capability(__VA_ARGS__)))
+#define GOOGLE_PROTOBUF_SCOPED_CAPABILITY __attribute__((scoped_lockable))
+#define GOOGLE_PROTOBUF_CAPABILITY(x) __attribute__((capability(x)))
+#else
+#define GOOGLE_PROTOBUF_ACQUIRE(...)
+#define GOOGLE_PROTOBUF_RELEASE(...)
+#define GOOGLE_PROTOBUF_SCOPED_CAPABILITY
+#define GOOGLE_PROTOBUF_CAPABILITY(x)
+#endif
+
+#include <google/protobuf/port_def.inc>
+
+// ===================================================================
+// emulates google3/base/mutex.h
+namespace google {
+namespace protobuf {
+namespace internal {
+
+#define GOOGLE_PROTOBUF_LINKER_INITIALIZED
+
+#ifdef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
+
+// This class is a lightweight replacement for std::mutex on Windows platforms.
+// std::mutex does not work on Windows XP SP2 with the latest VC++ libraries,
+// because it utilizes the Concurrency Runtime that is only supported on Windows
+// XP SP3 and above.
+class PROTOBUF_EXPORT CriticalSectionLock {
+ public:
+  CriticalSectionLock() { InitializeCriticalSection(&critical_section_); }
+  ~CriticalSectionLock() { DeleteCriticalSection(&critical_section_); }
+  void lock() { EnterCriticalSection(&critical_section_); }
+  void unlock() { LeaveCriticalSection(&critical_section_); }
+
+ private:
+  CRITICAL_SECTION critical_section_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CriticalSectionLock);
+};
+
+#endif
+
+// In MSVC std::mutex does not have a constexpr constructor.
+// This wrapper makes the constructor constexpr.
+template <typename T>
+class CallOnceInitializedMutex {
+ public:
+  constexpr CallOnceInitializedMutex() : flag_{}, buf_{} {}
+  ~CallOnceInitializedMutex() { get().~T(); }
+
+  void lock() { get().lock(); }
+  void unlock() { get().unlock(); }
+
+ private:
+  T& get() {
+    std::call_once(flag_, [&] { ::new (static_cast<void*>(&buf_)) T(); });
+    return reinterpret_cast<T&>(buf_);
+  }
+
+  std::once_flag flag_;
+  alignas(T) char buf_[sizeof(T)];
+};
+
+// Mutex is a natural type to wrap. As both google and other organization have
+// specialized mutexes. gRPC also provides an injection mechanism for custom
+// mutexes.
+class GOOGLE_PROTOBUF_CAPABILITY("mutex") PROTOBUF_EXPORT WrappedMutex {
+ public:
+#if defined(__QNX__)
+  constexpr WrappedMutex() = default;
+#else
+  constexpr WrappedMutex() {}
+#endif
+  void Lock() GOOGLE_PROTOBUF_ACQUIRE() { mu_.lock(); }
+  void Unlock() GOOGLE_PROTOBUF_RELEASE() { mu_.unlock(); }
+  // Crash if this Mutex is not held exclusively by this thread.
+  // May fail to crash when it should; will never crash when it should not.
+  void AssertHeld() const {}
+
+ private:
+#if defined(GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP)
+  CallOnceInitializedMutex<CriticalSectionLock> mu_{};
+#elif defined(_WIN32)
+  CallOnceInitializedMutex<std::mutex> mu_{};
+#else
+  std::mutex mu_{};
+#endif
+};
+
+using Mutex = WrappedMutex;
+
+// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
+class GOOGLE_PROTOBUF_SCOPED_CAPABILITY PROTOBUF_EXPORT MutexLock {
+ public:
+  explicit MutexLock(Mutex* mu) GOOGLE_PROTOBUF_ACQUIRE(mu) : mu_(mu) {
+    this->mu_->Lock();
+  }
+  ~MutexLock() GOOGLE_PROTOBUF_RELEASE() { this->mu_->Unlock(); }
+
+ private:
+  Mutex *const mu_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLock);
+};
+
+// TODO(kenton):  Implement these?  Hard to implement portably.
+typedef MutexLock ReaderMutexLock;
+typedef MutexLock WriterMutexLock;
+
+// MutexLockMaybe is like MutexLock, but is a no-op when mu is nullptr.
+class PROTOBUF_EXPORT MutexLockMaybe {
+ public:
+  explicit MutexLockMaybe(Mutex *mu) :
+    mu_(mu) { if (this->mu_ != nullptr) { this->mu_->Lock(); } }
+  ~MutexLockMaybe() { if (this->mu_ != nullptr) { this->mu_->Unlock(); } }
+ private:
+  Mutex *const mu_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLockMaybe);
+};
+
+#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
+template<typename T>
+class ThreadLocalStorage {
+ public:
+  ThreadLocalStorage() {
+    pthread_key_create(&key_, &ThreadLocalStorage::Delete);
+  }
+  ~ThreadLocalStorage() {
+    pthread_key_delete(key_);
+  }
+  T* Get() {
+    T* result = static_cast<T*>(pthread_getspecific(key_));
+    if (result == nullptr) {
+      result = new T();
+      pthread_setspecific(key_, result);
+    }
+    return result;
+  }
+ private:
+  static void Delete(void* value) {
+    delete static_cast<T*>(value);
+  }
+  pthread_key_t key_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadLocalStorage);
+};
+#endif
+
+}  // namespace internal
+
+// We made these internal so that they would show up as such in the docs,
+// but we don't want to stick "internal::" in front of them everywhere.
+using internal::Mutex;
+using internal::MutexLock;
+using internal::ReaderMutexLock;
+using internal::WriterMutexLock;
+using internal::MutexLockMaybe;
+
+}  // namespace protobuf
+}  // namespace google
+
+#undef GOOGLE_PROTOBUF_ACQUIRE
+#undef GOOGLE_PROTOBUF_RELEASE
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_STUBS_MUTEX_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/once.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/once.h
new file mode 100644
index 0000000..070d36d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/once.h
@@ -0,0 +1,55 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_ONCE_H__
+#define GOOGLE_PROTOBUF_STUBS_ONCE_H__
+
+#include <mutex>
+#include <utility>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+using once_flag = std::once_flag;
+template <typename... Args>
+void call_once(Args&&... args ) {
+  std::call_once(std::forward<Args>(args)...);
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_STUBS_ONCE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/platform_macros.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/platform_macros.h
new file mode 100644
index 0000000..2479960
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/platform_macros.h
@@ -0,0 +1,138 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
+#define GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
+
+#define GOOGLE_PROTOBUF_PLATFORM_ERROR \
+#error "Host platform was not detected as supported by protobuf"
+
+// Processor architecture detection.  For more info on what's defined, see:
+//   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+//   http://www.agner.org/optimize/calling_conventions.pdf
+//   or with gcc, run: "echo | gcc -E -dM -"
+#if defined(_M_X64) || defined(__x86_64__)
+#define GOOGLE_PROTOBUF_ARCH_X64 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#elif defined(_M_IX86) || defined(__i386__)
+#define GOOGLE_PROTOBUF_ARCH_IA32 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(__QNX__)
+#define GOOGLE_PROTOBUF_ARCH_ARM_QNX 1
+#if defined(__aarch64__)
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#else
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#endif
+#elif defined(_M_ARM) || defined(__ARMEL__)
+#define GOOGLE_PROTOBUF_ARCH_ARM 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(_M_ARM64)
+#define GOOGLE_PROTOBUF_ARCH_ARM 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#elif defined(__aarch64__)
+#define GOOGLE_PROTOBUF_ARCH_AARCH64 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#elif defined(__mips__)
+#if defined(__LP64__)
+#define GOOGLE_PROTOBUF_ARCH_MIPS64 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#else
+#define GOOGLE_PROTOBUF_ARCH_MIPS 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#endif
+#elif defined(__pnacl__)
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(sparc)
+#define GOOGLE_PROTOBUF_ARCH_SPARC 1
+#if defined(__sparc_v9__) || defined(__sparcv9) || defined(__arch64__)
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#else
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#endif
+#elif defined(_POWER) || defined(__powerpc64__) || defined(__PPC64__)
+#define GOOGLE_PROTOBUF_ARCH_POWER 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#elif defined(__PPC__)
+#define GOOGLE_PROTOBUF_ARCH_PPC 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(__GNUC__)
+# if (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))
+// We fallback to the generic Clang/GCC >= 4.7 implementation in atomicops.h
+# elif defined(__clang__)
+#  if !__has_extension(c_atomic)
+GOOGLE_PROTOBUF_PLATFORM_ERROR
+#  endif
+// We fallback to the generic Clang/GCC >= 4.7 implementation in atomicops.h
+# endif
+# if __LP64__
+#  define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+# else
+#  define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+# endif
+#else
+GOOGLE_PROTOBUF_PLATFORM_ERROR
+#endif
+
+#if defined(__APPLE__)
+#define GOOGLE_PROTOBUF_OS_APPLE
+#include <Availability.h>
+#include <TargetConditionals.h>
+#if TARGET_OS_IPHONE
+#define GOOGLE_PROTOBUF_OS_IPHONE
+#endif
+#elif defined(__EMSCRIPTEN__)
+#define GOOGLE_PROTOBUF_OS_EMSCRIPTEN
+#elif defined(__native_client__)
+#define GOOGLE_PROTOBUF_OS_NACL
+#elif defined(sun)
+#define GOOGLE_PROTOBUF_OS_SOLARIS
+#elif defined(_AIX)
+#define GOOGLE_PROTOBUF_OS_AIX
+#elif defined(__ANDROID__)
+#define GOOGLE_PROTOBUF_OS_ANDROID
+#endif
+
+#undef GOOGLE_PROTOBUF_PLATFORM_ERROR
+
+#if defined(GOOGLE_PROTOBUF_OS_ANDROID) || defined(GOOGLE_PROTOBUF_OS_IPHONE) || defined(__OpenBSD__)
+// Android ndk does not support the __thread keyword very well yet. Here
+// we use pthread_key_create()/pthread_getspecific()/... methods for
+// TLS support on android.
+// iOS and OpenBSD also do not support the __thread keyword.
+#define GOOGLE_PROTOBUF_NO_THREADLOCAL
+#endif
+
+#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 1070
+// __thread keyword requires at least 10.7
+#define GOOGLE_PROTOBUF_NO_THREADLOCAL
+#endif
+
+#endif  // GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/port.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/port.h
new file mode 100644
index 0000000..b074cb1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/port.h
@@ -0,0 +1,413 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_PORT_H_
+#define GOOGLE_PROTOBUF_STUBS_PORT_H_
+
+#include <assert.h>
+#include <cstdint>
+#include <stdlib.h>
+#include <cstddef>
+#include <string>
+#include <string.h>
+
+#include <google/protobuf/stubs/platform_macros.h>
+
+#include <google/protobuf/port_def.inc>
+
+#undef PROTOBUF_LITTLE_ENDIAN
+#ifdef _WIN32
+  // Assuming windows is always little-endian.
+  // TODO(xiaofeng): The PROTOBUF_LITTLE_ENDIAN is not only used for
+  // optimization but also for correctness. We should define an
+  // different macro to test the big-endian code path in coded_stream.
+  #if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+    #define PROTOBUF_LITTLE_ENDIAN 1
+  #endif
+#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
+// If MSVC has "/RTCc" set, it will complain about truncating casts at
+// runtime.  This file contains some intentional truncating casts.
+#pragma runtime_checks("c", off)
+#endif
+#else
+#ifdef __APPLE__
+#include <machine/endian.h>  // __BYTE_ORDER
+#elif defined(__FreeBSD__)
+#include <sys/endian.h>  // __BYTE_ORDER
+#elif (defined(sun) || defined(__sun)) && (defined(__SVR4) || defined(__svr4__))
+#include <sys/isa_defs.h>  // __BYTE_ORDER
+#elif defined(_AIX) || defined(__TOS_AIX__)
+#include <sys/machine.h>  // BYTE_ORDER
+#else
+#if !defined(__QNX__)
+#include <endian.h>  // __BYTE_ORDER
+#endif
+#endif
+#if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) ||   \
+     (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN) || \
+     (defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN)) &&      \
+    !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+#define PROTOBUF_LITTLE_ENDIAN 1
+#endif
+#endif
+
+// These #includes are for the byte swap functions declared later on.
+#ifdef _MSC_VER
+#include <stdlib.h>  // NOLINT(build/include)
+#include <intrin.h>
+#elif defined(__APPLE__)
+#include <libkern/OSByteOrder.h>
+#elif defined(__linux__) || defined(__ANDROID__) || defined(__CYGWIN__)
+#include <byteswap.h>  // IWYU pragma: export
+#endif
+
+// Legacy: some users reference these (internal-only) macros even though we
+// don't need them any more.
+#if defined(_MSC_VER) && defined(PROTOBUF_USE_DLLS)
+  #ifdef LIBPROTOBUF_EXPORTS
+    #define LIBPROTOBUF_EXPORT __declspec(dllexport)
+  #else
+    #define LIBPROTOBUF_EXPORT __declspec(dllimport)
+  #endif
+  #ifdef LIBPROTOC_EXPORTS
+    #define LIBPROTOC_EXPORT   __declspec(dllexport)
+  #else
+    #define LIBPROTOC_EXPORT   __declspec(dllimport)
+  #endif
+#else
+  #define LIBPROTOBUF_EXPORT
+  #define LIBPROTOC_EXPORT
+#endif
+
+#define PROTOBUF_RUNTIME_DEPRECATED(message) PROTOBUF_DEPRECATED_MSG(message)
+#define GOOGLE_PROTOBUF_RUNTIME_DEPRECATED(message) \
+  PROTOBUF_DEPRECATED_MSG(message)
+
+// ===================================================================
+// from google3/base/port.h
+
+#if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L || \
+     (defined(_MSC_VER) && _MSC_VER >= 1900))
+// Define this to 1 if the code is compiled in C++11 mode; leave it
+// undefined otherwise.  Do NOT define it to 0 -- that causes
+// '#ifdef LANG_CXX11' to behave differently from '#if LANG_CXX11'.
+#define LANG_CXX11 1
+#else
+#error "Protobuf requires at least C++11."
+#endif
+
+namespace google {
+namespace protobuf {
+
+using ConstStringParam = const std::string &;
+
+typedef unsigned int uint;
+
+typedef int8_t int8;
+typedef int16_t int16;
+typedef int32_t int32;
+typedef int64_t int64;
+
+typedef uint8_t uint8;
+typedef uint16_t uint16;
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+
+static const int32 kint32max = 0x7FFFFFFF;
+static const int32 kint32min = -kint32max - 1;
+static const int64 kint64max = int64_t{0x7FFFFFFFFFFFFFFF};
+static const int64 kint64min = -kint64max - 1;
+static const uint32 kuint32max = 0xFFFFFFFFu;
+static const uint64 kuint64max = uint64_t{0xFFFFFFFFFFFFFFFFu};
+
+#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) ||\
+    defined(MEMORY_SANITIZER)
+
+#ifdef __cplusplus
+extern "C" {
+#endif  // __cplusplus
+uint16_t __sanitizer_unaligned_load16(const void *p);
+uint32_t __sanitizer_unaligned_load32(const void *p);
+uint64_t __sanitizer_unaligned_load64(const void *p);
+void __sanitizer_unaligned_store16(void *p, uint16_t v);
+void __sanitizer_unaligned_store32(void *p, uint32_t v);
+void __sanitizer_unaligned_store64(void *p, uint64_t v);
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+inline uint16_t GOOGLE_UNALIGNED_LOAD16(const void *p) {
+  return __sanitizer_unaligned_load16(p);
+}
+
+inline uint32_t GOOGLE_UNALIGNED_LOAD32(const void *p) {
+  return __sanitizer_unaligned_load32(p);
+}
+
+inline uint64_t GOOGLE_UNALIGNED_LOAD64(const void *p) {
+  return __sanitizer_unaligned_load64(p);
+}
+
+inline void GOOGLE_UNALIGNED_STORE16(void *p, uint16_t v) {
+  __sanitizer_unaligned_store16(p, v);
+}
+
+inline void GOOGLE_UNALIGNED_STORE32(void *p, uint32_t v) {
+  __sanitizer_unaligned_store32(p, v);
+}
+
+inline void GOOGLE_UNALIGNED_STORE64(void *p, uint64_t v) {
+  __sanitizer_unaligned_store64(p, v);
+}
+
+#elif defined(GOOGLE_PROTOBUF_USE_UNALIGNED) && GOOGLE_PROTOBUF_USE_UNALIGNED
+
+#define GOOGLE_UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16_t *>(_p))
+#define GOOGLE_UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32_t *>(_p))
+#define GOOGLE_UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64_t *>(_p))
+
+#define GOOGLE_UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16_t *>(_p) = (_val))
+#define GOOGLE_UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32_t *>(_p) = (_val))
+#define GOOGLE_UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64_t *>(_p) = (_val))
+
+#else
+inline uint16_t GOOGLE_UNALIGNED_LOAD16(const void *p) {
+  uint16_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32_t GOOGLE_UNALIGNED_LOAD32(const void *p) {
+  uint32_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64_t GOOGLE_UNALIGNED_LOAD64(const void *p) {
+  uint64_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void GOOGLE_UNALIGNED_STORE16(void *p, uint16_t v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void GOOGLE_UNALIGNED_STORE32(void *p, uint32_t v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void GOOGLE_UNALIGNED_STORE64(void *p, uint64_t v) {
+  memcpy(p, &v, sizeof v);
+}
+#endif
+
+#if defined(GOOGLE_PROTOBUF_OS_NACL) \
+    || (defined(__ANDROID__) && defined(__clang__) \
+        && (__clang_major__ == 3 && __clang_minor__ == 8) \
+        && (__clang_patchlevel__ < 275480))
+# define GOOGLE_PROTOBUF_USE_PORTABLE_LOG2
+#endif
+
+// The following guarantees declaration of the byte swap functions.
+#ifdef _MSC_VER
+#define bswap_16(x) _byteswap_ushort(x)
+#define bswap_32(x) _byteswap_ulong(x)
+#define bswap_64(x) _byteswap_uint64(x)
+
+#elif defined(__APPLE__)
+// Mac OS X / Darwin features
+#define bswap_16(x) OSSwapInt16(x)
+#define bswap_32(x) OSSwapInt32(x)
+#define bswap_64(x) OSSwapInt64(x)
+
+#elif !defined(__linux__) && !defined(__ANDROID__) && !defined(__CYGWIN__)
+
+#ifndef bswap_16
+static inline uint16_t bswap_16(uint16_t x) {
+  return static_cast<uint16_t>(((x & 0xFF) << 8) | ((x & 0xFF00) >> 8));
+}
+#define bswap_16(x) bswap_16(x)
+#endif
+
+#ifndef bswap_32
+static inline uint32_t bswap_32(uint32_t x) {
+  return (((x & 0xFF) << 24) |
+          ((x & 0xFF00) << 8) |
+          ((x & 0xFF0000) >> 8) |
+          ((x & 0xFF000000) >> 24));
+}
+#define bswap_32(x) bswap_32(x)
+#endif
+
+#ifndef bswap_64
+static inline uint64_t bswap_64(uint64_t x) {
+  return (((x & uint64_t{0xFFu}) << 56) | ((x & uint64_t{0xFF00u}) << 40) |
+          ((x & uint64_t{0xFF0000u}) << 24) |
+          ((x & uint64_t{0xFF000000u}) << 8) |
+          ((x & uint64_t{0xFF00000000u}) >> 8) |
+          ((x & uint64_t{0xFF0000000000u}) >> 24) |
+          ((x & uint64_t{0xFF000000000000u}) >> 40) |
+          ((x & uint64_t{0xFF00000000000000u}) >> 56));
+}
+#define bswap_64(x) bswap_64(x)
+#endif
+
+#endif
+
+// ===================================================================
+// from google3/util/bits/bits.h
+
+class Bits {
+ public:
+  static uint32_t Log2FloorNonZero(uint32_t n) {
+#if defined(__GNUC__)
+  return 31 ^ static_cast<uint32_t>(__builtin_clz(n));
+#elif defined(_MSC_VER)
+  unsigned long where;
+  _BitScanReverse(&where, n);
+  return where;
+#else
+  return Log2FloorNonZero_Portable(n);
+#endif
+  }
+
+  static uint32_t Log2FloorNonZero64(uint64_t n) {
+    // Older versions of clang run into an instruction-selection failure when
+    // it encounters __builtin_clzll:
+    // https://bugs.chromium.org/p/nativeclient/issues/detail?id=4395
+    // This includes arm-nacl-clang and clang in older Android NDK versions.
+    // To work around this, when we build with those we use the portable
+    // implementation instead.
+#if defined(__GNUC__) && !defined(GOOGLE_PROTOBUF_USE_PORTABLE_LOG2)
+  return 63 ^ static_cast<uint32_t>(__builtin_clzll(n));
+#elif defined(_MSC_VER) && defined(_M_X64)
+  unsigned long where;
+  _BitScanReverse64(&where, n);
+  return where;
+#else
+  return Log2FloorNonZero64_Portable(n);
+#endif
+  }
+ private:
+  static int Log2FloorNonZero_Portable(uint32_t n) {
+    if (n == 0)
+      return -1;
+    int log = 0;
+    uint32_t value = n;
+    for (int i = 4; i >= 0; --i) {
+      int shift = (1 << i);
+      uint32_t x = value >> shift;
+      if (x != 0) {
+        value = x;
+        log += shift;
+      }
+    }
+    assert(value == 1);
+    return log;
+  }
+
+  static int Log2FloorNonZero64_Portable(uint64_t n) {
+    const uint32_t topbits = static_cast<uint32_t>(n >> 32);
+    if (topbits == 0) {
+      // Top bits are zero, so scan in bottom bits
+      return static_cast<int>(Log2FloorNonZero(static_cast<uint32_t>(n)));
+    } else {
+      return 32 + static_cast<int>(Log2FloorNonZero(topbits));
+    }
+  }
+};
+
+// ===================================================================
+// from google3/util/endian/endian.h
+PROTOBUF_EXPORT uint32_t ghtonl(uint32_t x);
+
+class BigEndian {
+ public:
+#ifdef PROTOBUF_LITTLE_ENDIAN
+
+  static uint16_t FromHost16(uint16_t x) { return bswap_16(x); }
+  static uint16_t ToHost16(uint16_t x) { return bswap_16(x); }
+
+  static uint32_t FromHost32(uint32_t x) { return bswap_32(x); }
+  static uint32_t ToHost32(uint32_t x) { return bswap_32(x); }
+
+  static uint64_t FromHost64(uint64_t x) { return bswap_64(x); }
+  static uint64_t ToHost64(uint64_t x) { return bswap_64(x); }
+
+  static bool IsLittleEndian() { return true; }
+
+#else
+
+  static uint16_t FromHost16(uint16_t x) { return x; }
+  static uint16_t ToHost16(uint16_t x) { return x; }
+
+  static uint32_t FromHost32(uint32_t x) { return x; }
+  static uint32_t ToHost32(uint32_t x) { return x; }
+
+  static uint64_t FromHost64(uint64_t x) { return x; }
+  static uint64_t ToHost64(uint64_t x) { return x; }
+
+  static bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+  // Functions to do unaligned loads and stores in big-endian order.
+  static uint16_t Load16(const void *p) {
+    return ToHost16(GOOGLE_UNALIGNED_LOAD16(p));
+  }
+
+  static void Store16(void *p, uint16_t v) {
+    GOOGLE_UNALIGNED_STORE16(p, FromHost16(v));
+  }
+
+  static uint32_t Load32(const void *p) {
+    return ToHost32(GOOGLE_UNALIGNED_LOAD32(p));
+  }
+
+  static void Store32(void *p, uint32_t v) {
+    GOOGLE_UNALIGNED_STORE32(p, FromHost32(v));
+  }
+
+  static uint64_t Load64(const void *p) {
+    return ToHost64(GOOGLE_UNALIGNED_LOAD64(p));
+  }
+
+  static void Store64(void *p, uint64_t v) {
+    GOOGLE_UNALIGNED_STORE64(p, FromHost64(v));
+  }
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_STUBS_PORT_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/status.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/status.h
new file mode 100644
index 0000000..c858cf6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/status.h
@@ -0,0 +1,196 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_STATUS_H_
+#define GOOGLE_PROTOBUF_STUBS_STATUS_H_
+
+#include <string>
+
+#include <google/protobuf/stubs/stringpiece.h>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace util {
+namespace status_internal {
+
+// These values must match error codes defined in google/rpc/code.proto.
+enum class StatusCode : int {
+  kOk = 0,
+  kCancelled = 1,
+  kUnknown = 2,
+  kInvalidArgument = 3,
+  kDeadlineExceeded = 4,
+  kNotFound = 5,
+  kAlreadyExists = 6,
+  kPermissionDenied = 7,
+  kUnauthenticated = 16,
+  kResourceExhausted = 8,
+  kFailedPrecondition = 9,
+  kAborted = 10,
+  kOutOfRange = 11,
+  kUnimplemented = 12,
+  kInternal = 13,
+  kUnavailable = 14,
+  kDataLoss = 15,
+};
+
+class PROTOBUF_EXPORT Status {
+ public:
+  // Creates a "successful" status.
+  Status();
+
+  // Create a status in the canonical error space with the specified
+  // code, and error message.  If "code == 0", error_message is
+  // ignored and a Status object identical to Status::kOk is
+  // constructed.
+  Status(StatusCode error_code, StringPiece error_message);
+  Status(const Status&);
+  Status& operator=(const Status& x);
+  ~Status() {}
+
+  // Accessor
+  bool ok() const { return error_code_ == StatusCode::kOk; }
+  StatusCode code() const { return error_code_; }
+  StringPiece message() const {
+    return error_message_;
+  }
+
+  bool operator==(const Status& x) const;
+  bool operator!=(const Status& x) const {
+    return !operator==(x);
+  }
+
+  // Return a combination of the error code name and message.
+  std::string ToString() const;
+
+ private:
+  StatusCode error_code_;
+  std::string error_message_;
+};
+
+// Returns an OK status, equivalent to a default constructed instance. Prefer
+// usage of `OkStatus()` when constructing such an OK status.
+PROTOBUF_EXPORT Status OkStatus();
+
+// Prints a human-readable representation of 'x' to 'os'.
+PROTOBUF_EXPORT std::ostream& operator<<(std::ostream& os, const Status& x);
+
+// These convenience functions return `true` if a given status matches the
+// `StatusCode` error code of its associated function.
+PROTOBUF_EXPORT bool IsAborted(const Status& status);
+PROTOBUF_EXPORT bool IsAlreadyExists(const Status& status);
+PROTOBUF_EXPORT bool IsCancelled(const Status& status);
+PROTOBUF_EXPORT bool IsDataLoss(const Status& status);
+PROTOBUF_EXPORT bool IsDeadlineExceeded(const Status& status);
+PROTOBUF_EXPORT bool IsFailedPrecondition(const Status& status);
+PROTOBUF_EXPORT bool IsInternal(const Status& status);
+PROTOBUF_EXPORT bool IsInvalidArgument(const Status& status);
+PROTOBUF_EXPORT bool IsNotFound(const Status& status);
+PROTOBUF_EXPORT bool IsOutOfRange(const Status& status);
+PROTOBUF_EXPORT bool IsPermissionDenied(const Status& status);
+PROTOBUF_EXPORT bool IsResourceExhausted(const Status& status);
+PROTOBUF_EXPORT bool IsUnauthenticated(const Status& status);
+PROTOBUF_EXPORT bool IsUnavailable(const Status& status);
+PROTOBUF_EXPORT bool IsUnimplemented(const Status& status);
+PROTOBUF_EXPORT bool IsUnknown(const Status& status);
+
+// These convenience functions create an `Status` object with an error code as
+// indicated by the associated function name, using the error message passed in
+// `message`.
+//
+// These functions are intentionally named `*Error` rather than `*Status` to
+// match the names from Abseil:
+// https://github.com/abseil/abseil-cpp/blob/2e9532cc6c701a8323d0cffb468999ab804095ab/absl/status/status.h#L716
+PROTOBUF_EXPORT Status AbortedError(StringPiece message);
+PROTOBUF_EXPORT Status AlreadyExistsError(StringPiece message);
+PROTOBUF_EXPORT Status CancelledError(StringPiece message);
+PROTOBUF_EXPORT Status DataLossError(StringPiece message);
+PROTOBUF_EXPORT Status DeadlineExceededError(StringPiece message);
+PROTOBUF_EXPORT Status FailedPreconditionError(StringPiece message);
+PROTOBUF_EXPORT Status InternalError(StringPiece message);
+PROTOBUF_EXPORT Status InvalidArgumentError(StringPiece message);
+PROTOBUF_EXPORT Status NotFoundError(StringPiece message);
+PROTOBUF_EXPORT Status OutOfRangeError(StringPiece message);
+PROTOBUF_EXPORT Status PermissionDeniedError(StringPiece message);
+PROTOBUF_EXPORT Status ResourceExhaustedError(StringPiece message);
+PROTOBUF_EXPORT Status UnauthenticatedError(StringPiece message);
+PROTOBUF_EXPORT Status UnavailableError(StringPiece message);
+PROTOBUF_EXPORT Status UnimplementedError(StringPiece message);
+PROTOBUF_EXPORT Status UnknownError(StringPiece message);
+
+}  // namespace status_internal
+
+using ::google::protobuf::util::status_internal::Status;
+using ::google::protobuf::util::status_internal::StatusCode;
+
+using ::google::protobuf::util::status_internal::IsAborted;
+using ::google::protobuf::util::status_internal::IsAlreadyExists;
+using ::google::protobuf::util::status_internal::IsCancelled;
+using ::google::protobuf::util::status_internal::IsDataLoss;
+using ::google::protobuf::util::status_internal::IsDeadlineExceeded;
+using ::google::protobuf::util::status_internal::IsFailedPrecondition;
+using ::google::protobuf::util::status_internal::IsInternal;
+using ::google::protobuf::util::status_internal::IsInvalidArgument;
+using ::google::protobuf::util::status_internal::IsNotFound;
+using ::google::protobuf::util::status_internal::IsOutOfRange;
+using ::google::protobuf::util::status_internal::IsPermissionDenied;
+using ::google::protobuf::util::status_internal::IsResourceExhausted;
+using ::google::protobuf::util::status_internal::IsUnauthenticated;
+using ::google::protobuf::util::status_internal::IsUnavailable;
+using ::google::protobuf::util::status_internal::IsUnimplemented;
+using ::google::protobuf::util::status_internal::IsUnknown;
+
+using ::google::protobuf::util::status_internal::AbortedError;
+using ::google::protobuf::util::status_internal::AlreadyExistsError;
+using ::google::protobuf::util::status_internal::CancelledError;
+using ::google::protobuf::util::status_internal::DataLossError;
+using ::google::protobuf::util::status_internal::DeadlineExceededError;
+using ::google::protobuf::util::status_internal::FailedPreconditionError;
+using ::google::protobuf::util::status_internal::InternalError;
+using ::google::protobuf::util::status_internal::InvalidArgumentError;
+using ::google::protobuf::util::status_internal::NotFoundError;
+using ::google::protobuf::util::status_internal::OkStatus;
+using ::google::protobuf::util::status_internal::OutOfRangeError;
+using ::google::protobuf::util::status_internal::PermissionDeniedError;
+using ::google::protobuf::util::status_internal::ResourceExhaustedError;
+using ::google::protobuf::util::status_internal::UnauthenticatedError;
+using ::google::protobuf::util::status_internal::UnavailableError;
+using ::google::protobuf::util::status_internal::UnimplementedError;
+using ::google::protobuf::util::status_internal::UnknownError;
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_STUBS_STATUS_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/stl_util.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/stl_util.h
new file mode 100644
index 0000000..e6260d0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/stl_util.h
@@ -0,0 +1,90 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// from google3/util/gtl/stl_util.h
+
+#ifndef GOOGLE_PROTOBUF_STUBS_STL_UTIL_H__
+#define GOOGLE_PROTOBUF_STUBS_STL_UTIL_H__
+
+#include <google/protobuf/stubs/common.h>
+
+#include <algorithm>
+
+// Must be last.
+#include <google/protobuf/port_def.inc>  // NOLINT
+
+namespace google {
+namespace protobuf {
+
+// Inside Google, this function implements a horrible, disgusting hack in which
+// we reach into the string's private implementation and resize it without
+// initializing the new bytes.  In some cases doing this can significantly
+// improve performance.  However, since it's totally non-portable it has no
+// place in open source code.  Feel free to fill this function in with your
+// own disgusting hack if you want the perf boost.
+inline void STLStringResizeUninitialized(std::string* s, size_t new_size) {
+  s->resize(new_size);
+}
+
+// As above, but we make sure to follow amortized growth in which we always
+// increase the capacity by at least a constant factor >1.
+inline void STLStringResizeUninitializedAmortized(std::string* s,
+                                                  size_t new_size) {
+  const size_t cap = s->capacity();
+  if (new_size > cap) {
+    // Make sure to always grow by at least a factor of 2x.
+    s->reserve(std::max<size_t>(new_size, 2 * cap));
+  }
+  STLStringResizeUninitialized(s, new_size);
+}
+
+// Return a mutable char* pointing to a string's internal buffer,
+// which may not be null-terminated. Writing through this pointer will
+// modify the string.
+//
+// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
+// next call to a string method that invalidates iterators.
+//
+// As of 2006-04, there is no standard-blessed way of getting a
+// mutable reference to a string's internal buffer. However, issue 530
+// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#530)
+// proposes this as the method. According to Matt Austern, this should
+// already work on all current implementations.
+inline char* string_as_array(std::string* str) {
+  // DO NOT USE const_cast<char*>(str->data())! See the unittest for why.
+  return str->empty() ? nullptr : &*str->begin();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>  // NOLINT
+
+#endif  // GOOGLE_PROTOBUF_STUBS_STL_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/stringpiece.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/stringpiece.h
new file mode 100644
index 0000000..c63e25b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/stringpiece.h
@@ -0,0 +1,402 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A StringPiece points to part or all of a string, Cord, double-quoted string
+// literal, or other string-like object.  A StringPiece does *not* own the
+// string to which it points.  A StringPiece is not null-terminated.
+//
+// You can use StringPiece as a function or method parameter.  A StringPiece
+// parameter can receive a double-quoted string literal argument, a "const
+// char*" argument, a string argument, or a StringPiece argument with no data
+// copying.  Systematic use of StringPiece for arguments reduces data
+// copies and strlen() calls.
+//
+// Prefer passing StringPieces by value:
+//   void MyFunction(StringPiece arg);
+// If circumstances require, you may also pass by const reference:
+//   void MyFunction(const StringPiece& arg);  // not preferred
+// Both of these have the same lifetime semantics.  Passing by value
+// generates slightly smaller code.  For more discussion, see the thread
+// go/stringpiecebyvalue on c-users.
+//
+// StringPiece is also suitable for local variables if you know that
+// the lifetime of the underlying object is longer than the lifetime
+// of your StringPiece variable.
+//
+// Beware of binding a StringPiece to a temporary:
+//   StringPiece sp = obj.MethodReturningString();  // BAD: lifetime problem
+//
+// This code is okay:
+//   string str = obj.MethodReturningString();  // str owns its contents
+//   StringPiece sp(str);  // GOOD, because str outlives sp
+//
+// StringPiece is sometimes a poor choice for a return value and usually a poor
+// choice for a data member.  If you do use a StringPiece this way, it is your
+// responsibility to ensure that the object pointed to by the StringPiece
+// outlives the StringPiece.
+//
+// A StringPiece may represent just part of a string; thus the name "Piece".
+// For example, when splitting a string, vector<StringPiece> is a natural data
+// type for the output.  For another example, a Cord is a non-contiguous,
+// potentially very long string-like object.  The Cord class has an interface
+// that iteratively provides StringPiece objects that point to the
+// successive pieces of a Cord object.
+//
+// A StringPiece is not null-terminated.  If you write code that scans a
+// StringPiece, you must check its length before reading any characters.
+// Common idioms that work on null-terminated strings do not work on
+// StringPiece objects.
+//
+// There are several ways to create a null StringPiece:
+//   StringPiece()
+//   StringPiece(nullptr)
+//   StringPiece(nullptr, 0)
+// For all of the above, sp.data() == nullptr, sp.length() == 0,
+// and sp.empty() == true.  Also, if you create a StringPiece with
+// a non-null pointer then sp.data() != nullptr.  Once created,
+// sp.data() will stay either nullptr or not-nullptr, except if you call
+// sp.clear() or sp.set().
+//
+// Thus, you can use StringPiece(nullptr) to signal an out-of-band value
+// that is different from other StringPiece values.  This is similar
+// to the way that const char* p1 = nullptr; is different from
+// const char* p2 = "";.
+//
+// There are many ways to create an empty StringPiece:
+//   StringPiece()
+//   StringPiece(nullptr)
+//   StringPiece(nullptr, 0)
+//   StringPiece("")
+//   StringPiece("", 0)
+//   StringPiece("abcdef", 0)
+//   StringPiece("abcdef"+6, 0)
+// For all of the above, sp.length() will be 0 and sp.empty() will be true.
+// For some empty StringPiece values, sp.data() will be nullptr.
+// For some empty StringPiece values, sp.data() will not be nullptr.
+//
+// Be careful not to confuse: null StringPiece and empty StringPiece.
+// The set of empty StringPieces properly includes the set of null StringPieces.
+// That is, every null StringPiece is an empty StringPiece,
+// but some non-null StringPieces are empty Stringpieces too.
+//
+// All empty StringPiece values compare equal to each other.
+// Even a null StringPieces compares equal to a non-null empty StringPiece:
+//  StringPiece() == StringPiece("", 0)
+//  StringPiece(nullptr) == StringPiece("abc", 0)
+//  StringPiece(nullptr, 0) == StringPiece("abcdef"+6, 0)
+//
+// Look carefully at this example:
+//   StringPiece("") == nullptr
+// True or false?  TRUE, because StringPiece::operator== converts
+// the right-hand side from nullptr to StringPiece(nullptr),
+// and then compares two zero-length spans of characters.
+// However, we are working to make this example produce a compile error.
+//
+// Suppose you want to write:
+//   bool TestWhat?(StringPiece sp) { return sp == nullptr; }  // BAD
+// Do not do that.  Write one of these instead:
+//   bool TestNull(StringPiece sp) { return sp.data() == nullptr; }
+//   bool TestEmpty(StringPiece sp) { return sp.empty(); }
+// The intent of TestWhat? is unclear.  Did you mean TestNull or TestEmpty?
+// Right now, TestWhat? behaves likes TestEmpty.
+// We are working to make TestWhat? produce a compile error.
+// TestNull is good to test for an out-of-band signal.
+// TestEmpty is good to test for an empty StringPiece.
+//
+// Caveats (again):
+// (1) The lifetime of the pointed-to string (or piece of a string)
+//     must be longer than the lifetime of the StringPiece.
+// (2) There may or may not be a '\0' character after the end of
+//     StringPiece data.
+// (3) A null StringPiece is empty.
+//     An empty StringPiece may or may not be a null StringPiece.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_STRINGPIECE_H_
+#define GOOGLE_PROTOBUF_STUBS_STRINGPIECE_H_
+
+#include <assert.h>
+#include <stddef.h>
+#include <string.h>
+#include <iosfwd>
+#include <limits>
+#include <string>
+
+#if defined(__cpp_lib_string_view)
+#include <string_view>
+#endif
+
+#include <google/protobuf/stubs/hash.h>
+
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace stringpiece_internal {
+
+class PROTOBUF_EXPORT StringPiece {
+ public:
+  using traits_type = std::char_traits<char>;
+  using value_type = char;
+  using pointer = char*;
+  using const_pointer = const char*;
+  using reference = char&;
+  using const_reference = const char&;
+  using const_iterator = const char*;
+  using iterator = const_iterator;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  using reverse_iterator = const_reverse_iterator;
+  using size_type = size_t;
+  using difference_type = std::ptrdiff_t;
+
+ private:
+  const char* ptr_;
+  size_type length_;
+
+  static constexpr size_type kMaxSize =
+      (std::numeric_limits<difference_type>::max)();
+
+  static size_type CheckSize(size_type size) {
+#if !defined(NDEBUG) || defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0
+    if (PROTOBUF_PREDICT_FALSE(size > kMaxSize)) {
+      // Some people grep for this message in logs
+      // so take care if you ever change it.
+      LogFatalSizeTooBig(size, "string length exceeds max size");
+    }
+#endif
+    return size;
+  }
+
+  // Out-of-line error path.
+  static void LogFatalSizeTooBig(size_type size, const char* details);
+
+ public:
+  // We provide non-explicit singleton constructors so users can pass
+  // in a "const char*" or a "string" wherever a "StringPiece" is
+  // expected.
+  //
+  // Style guide exception granted:
+  // http://goto/style-guide-exception-20978288
+  StringPiece() : ptr_(nullptr), length_(0) {}
+
+  StringPiece(const char* str)  // NOLINT(runtime/explicit)
+      : ptr_(str), length_(0) {
+    if (str != nullptr) {
+      length_ = CheckSize(strlen(str));
+    }
+  }
+
+  template <class Allocator>
+  StringPiece(  // NOLINT(runtime/explicit)
+      const std::basic_string<char, std::char_traits<char>, Allocator>& str)
+      : ptr_(str.data()), length_(0) {
+    length_ = CheckSize(str.size());
+  }
+
+#if defined(__cpp_lib_string_view)
+  StringPiece(  // NOLINT(runtime/explicit)
+      std::string_view str)
+      : ptr_(str.data()), length_(0) {
+    length_ = CheckSize(str.size());
+  }
+#endif
+
+  StringPiece(const char* offset, size_type len)
+      : ptr_(offset), length_(CheckSize(len)) {}
+
+  // data() may return a pointer to a buffer with embedded NULs, and the
+  // returned buffer may or may not be null terminated.  Therefore it is
+  // typically a mistake to pass data() to a routine that expects a NUL
+  // terminated string.
+  const_pointer data() const { return ptr_; }
+  size_type size() const { return length_; }
+  size_type length() const { return length_; }
+  bool empty() const { return length_ == 0; }
+
+  char operator[](size_type i) const {
+    assert(i < length_);
+    return ptr_[i];
+  }
+
+  void remove_prefix(size_type n) {
+    assert(length_ >= n);
+    ptr_ += n;
+    length_ -= n;
+  }
+
+  void remove_suffix(size_type n) {
+    assert(length_ >= n);
+    length_ -= n;
+  }
+
+  // returns {-1, 0, 1}
+  int compare(StringPiece x) const {
+    size_type min_size = length_ < x.length_ ? length_ : x.length_;
+    int r = memcmp(ptr_, x.ptr_, static_cast<size_t>(min_size));
+    if (r < 0) return -1;
+    if (r > 0) return 1;
+    if (length_ < x.length_) return -1;
+    if (length_ > x.length_) return 1;
+    return 0;
+  }
+
+  std::string as_string() const { return ToString(); }
+  // We also define ToString() here, since many other string-like
+  // interfaces name the routine that converts to a C++ string
+  // "ToString", and it's confusing to have the method that does that
+  // for a StringPiece be called "as_string()".  We also leave the
+  // "as_string()" method defined here for existing code.
+  std::string ToString() const {
+    if (ptr_ == nullptr) return "";
+    return std::string(data(), static_cast<size_type>(size()));
+  }
+
+  explicit operator std::string() const { return ToString(); }
+
+  void CopyToString(std::string* target) const;
+  void AppendToString(std::string* target) const;
+
+  bool starts_with(StringPiece x) const {
+    return (length_ >= x.length_) &&
+           (memcmp(ptr_, x.ptr_, static_cast<size_t>(x.length_)) == 0);
+  }
+
+  bool ends_with(StringPiece x) const {
+    return ((length_ >= x.length_) &&
+            (memcmp(ptr_ + (length_-x.length_), x.ptr_,
+                 static_cast<size_t>(x.length_)) == 0));
+  }
+
+  // Checks whether StringPiece starts with x and if so advances the beginning
+  // of it to past the match.  It's basically a shortcut for starts_with
+  // followed by remove_prefix.
+  bool Consume(StringPiece x);
+  // Like above but for the end of the string.
+  bool ConsumeFromEnd(StringPiece x);
+
+  // standard STL container boilerplate
+  static const size_type npos;
+  const_iterator begin() const { return ptr_; }
+  const_iterator end() const { return ptr_ + length_; }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(ptr_ + length_);
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(ptr_);
+  }
+  size_type max_size() const { return length_; }
+  size_type capacity() const { return length_; }
+
+  // cpplint.py emits a false positive [build/include_what_you_use]
+  size_type copy(char* buf, size_type n, size_type pos = 0) const;  // NOLINT
+
+  bool contains(StringPiece s) const;
+
+  size_type find(StringPiece s, size_type pos = 0) const;
+  size_type find(char c, size_type pos = 0) const;
+  size_type rfind(StringPiece s, size_type pos = npos) const;
+  size_type rfind(char c, size_type pos = npos) const;
+
+  size_type find_first_of(StringPiece s, size_type pos = 0) const;
+  size_type find_first_of(char c, size_type pos = 0) const {
+    return find(c, pos);
+  }
+  size_type find_first_not_of(StringPiece s, size_type pos = 0) const;
+  size_type find_first_not_of(char c, size_type pos = 0) const;
+  size_type find_last_of(StringPiece s, size_type pos = npos) const;
+  size_type find_last_of(char c, size_type pos = npos) const {
+    return rfind(c, pos);
+  }
+  size_type find_last_not_of(StringPiece s, size_type pos = npos) const;
+  size_type find_last_not_of(char c, size_type pos = npos) const;
+
+  StringPiece substr(size_type pos, size_type n = npos) const;
+};
+
+// This large function is defined inline so that in a fairly common case where
+// one of the arguments is a literal, the compiler can elide a lot of the
+// following comparisons.
+inline bool operator==(StringPiece x, StringPiece y) {
+  StringPiece::size_type len = x.size();
+  if (len != y.size()) {
+    return false;
+  }
+
+  return x.data() == y.data() || len <= 0 ||
+      memcmp(x.data(), y.data(), static_cast<size_t>(len)) == 0;
+}
+
+inline bool operator!=(StringPiece x, StringPiece y) {
+  return !(x == y);
+}
+
+inline bool operator<(StringPiece x, StringPiece y) {
+  const StringPiece::size_type min_size =
+      x.size() < y.size() ? x.size() : y.size();
+  const int r = memcmp(x.data(), y.data(), static_cast<size_t>(min_size));
+  return (r < 0) || (r == 0 && x.size() < y.size());
+}
+
+inline bool operator>(StringPiece x, StringPiece y) {
+  return y < x;
+}
+
+inline bool operator<=(StringPiece x, StringPiece y) {
+  return !(x > y);
+}
+
+inline bool operator>=(StringPiece x, StringPiece y) {
+  return !(x < y);
+}
+
+// allow StringPiece to be logged
+extern std::ostream& operator<<(std::ostream& o, StringPiece piece);
+
+}  // namespace stringpiece_internal
+
+using ::google::protobuf::stringpiece_internal::StringPiece;
+
+}  // namespace protobuf
+}  // namespace google
+
+GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START
+template<> struct hash<StringPiece> {
+  size_t operator()(const StringPiece& s) const {
+    size_t result = 0;
+    for (const char *str = s.data(), *end = str + s.size(); str < end; str++) {
+      result = 5 * result + static_cast<size_t>(*str);
+    }
+    return result;
+  }
+};
+GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // STRINGS_STRINGPIECE_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/strutil.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/strutil.h
new file mode 100644
index 0000000..9658abf
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/strutil.h
@@ -0,0 +1,950 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// from google3/strings/strutil.h
+
+#ifndef GOOGLE_PROTOBUF_STUBS_STRUTIL_H__
+#define GOOGLE_PROTOBUF_STUBS_STRUTIL_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/stringpiece.h>
+#include <stdlib.h>
+
+#include <cstring>
+#include <google/protobuf/port_def.inc>
+#include <vector>
+
+namespace google {
+namespace protobuf {
+
+#if defined(_MSC_VER) && _MSC_VER < 1800
+#define strtoll  _strtoi64
+#define strtoull _strtoui64
+#elif defined(__DECCXX) && defined(__osf__)
+// HP C++ on Tru64 does not have strtoll, but strtol is already 64-bit.
+#define strtoll strtol
+#define strtoull strtoul
+#endif
+
+// ----------------------------------------------------------------------
+// ascii_isalnum()
+//    Check if an ASCII character is alphanumeric.  We can't use ctype's
+//    isalnum() because it is affected by locale.  This function is applied
+//    to identifiers in the protocol buffer language, not to natural-language
+//    strings, so locale should not be taken into account.
+// ascii_isdigit()
+//    Like above, but only accepts digits.
+// ascii_isspace()
+//    Check if the character is a space character.
+// ----------------------------------------------------------------------
+
+inline bool ascii_isalnum(char c) {
+  return ('a' <= c && c <= 'z') ||
+         ('A' <= c && c <= 'Z') ||
+         ('0' <= c && c <= '9');
+}
+
+inline bool ascii_isdigit(char c) {
+  return ('0' <= c && c <= '9');
+}
+
+inline bool ascii_isspace(char c) {
+  return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' ||
+      c == '\r';
+}
+
+inline bool ascii_isupper(char c) {
+  return c >= 'A' && c <= 'Z';
+}
+
+inline bool ascii_islower(char c) {
+  return c >= 'a' && c <= 'z';
+}
+
+inline char ascii_toupper(char c) {
+  return ascii_islower(c) ? c - ('a' - 'A') : c;
+}
+
+inline char ascii_tolower(char c) {
+  return ascii_isupper(c) ? c + ('a' - 'A') : c;
+}
+
+inline int hex_digit_to_int(char c) {
+  /* Assume ASCII. */
+  int x = static_cast<unsigned char>(c);
+  if (x > '9') {
+    x += 9;
+  }
+  return x & 0xf;
+}
+
+// ----------------------------------------------------------------------
+// HasPrefixString()
+//    Check if a string begins with a given prefix.
+// StripPrefixString()
+//    Given a string and a putative prefix, returns the string minus the
+//    prefix string if the prefix matches, otherwise the original
+//    string.
+// ----------------------------------------------------------------------
+inline bool HasPrefixString(StringPiece str, StringPiece prefix) {
+  return str.size() >= prefix.size() &&
+         memcmp(str.data(), prefix.data(), prefix.size()) == 0;
+}
+
+inline std::string StripPrefixString(const std::string& str,
+                                     const std::string& prefix) {
+  if (HasPrefixString(str, prefix)) {
+    return str.substr(prefix.size());
+  } else {
+    return str;
+  }
+}
+
+// ----------------------------------------------------------------------
+// HasSuffixString()
+//    Return true if str ends in suffix.
+// StripSuffixString()
+//    Given a string and a putative suffix, returns the string minus the
+//    suffix string if the suffix matches, otherwise the original
+//    string.
+// ----------------------------------------------------------------------
+inline bool HasSuffixString(StringPiece str, StringPiece suffix) {
+  return str.size() >= suffix.size() &&
+         memcmp(str.data() + str.size() - suffix.size(), suffix.data(),
+                suffix.size()) == 0;
+}
+
+inline std::string StripSuffixString(const std::string& str,
+                                     const std::string& suffix) {
+  if (HasSuffixString(str, suffix)) {
+    return str.substr(0, str.size() - suffix.size());
+  } else {
+    return str;
+  }
+}
+
+// ----------------------------------------------------------------------
+// ReplaceCharacters
+//    Replaces any occurrence of the character 'remove' (or the characters
+//    in 'remove') with the character 'replacewith'.
+//    Good for keeping html characters or protocol characters (\t) out
+//    of places where they might cause a problem.
+// StripWhitespace
+//    Removes whitespaces from both ends of the given string.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT void ReplaceCharacters(std::string* s, const char* remove,
+                                       char replacewith);
+
+PROTOBUF_EXPORT void StripWhitespace(std::string* s);
+
+// ----------------------------------------------------------------------
+// LowerString()
+// UpperString()
+// ToUpper()
+//    Convert the characters in "s" to lowercase or uppercase.  ASCII-only:
+//    these functions intentionally ignore locale because they are applied to
+//    identifiers used in the Protocol Buffer language, not to natural-language
+//    strings.
+// ----------------------------------------------------------------------
+
+inline void LowerString(std::string* s) {
+  std::string::iterator end = s->end();
+  for (std::string::iterator i = s->begin(); i != end; ++i) {
+    // tolower() changes based on locale.  We don't want this!
+    if ('A' <= *i && *i <= 'Z') *i += 'a' - 'A';
+  }
+}
+
+inline void UpperString(std::string* s) {
+  std::string::iterator end = s->end();
+  for (std::string::iterator i = s->begin(); i != end; ++i) {
+    // toupper() changes based on locale.  We don't want this!
+    if ('a' <= *i && *i <= 'z') *i += 'A' - 'a';
+  }
+}
+
+inline void ToUpper(std::string* s) { UpperString(s); }
+
+inline std::string ToUpper(const std::string& s) {
+  std::string out = s;
+  UpperString(&out);
+  return out;
+}
+
+// ----------------------------------------------------------------------
+// StringReplace()
+//    Give me a string and two patterns "old" and "new", and I replace
+//    the first instance of "old" in the string with "new", if it
+//    exists.  RETURN a new string, regardless of whether the replacement
+//    happened or not.
+// ----------------------------------------------------------------------
+
+PROTOBUF_EXPORT std::string StringReplace(const std::string& s,
+                                          const std::string& oldsub,
+                                          const std::string& newsub,
+                                          bool replace_all);
+
+// ----------------------------------------------------------------------
+// SplitStringUsing()
+//    Split a string using a character delimiter. Append the components
+//    to 'result'.  If there are consecutive delimiters, this function skips
+//    over all of them.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT void SplitStringUsing(StringPiece full, const char* delim,
+                                      std::vector<std::string>* res);
+
+// Split a string using one or more byte delimiters, presented
+// as a nul-terminated c string. Append the components to 'result'.
+// If there are consecutive delimiters, this function will return
+// corresponding empty strings.  If you want to drop the empty
+// strings, try SplitStringUsing().
+//
+// If "full" is the empty string, yields an empty string as the only value.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT void SplitStringAllowEmpty(StringPiece full, const char* delim,
+                                           std::vector<std::string>* result);
+
+// ----------------------------------------------------------------------
+// Split()
+//    Split a string using a character delimiter.
+// ----------------------------------------------------------------------
+inline std::vector<std::string> Split(StringPiece full, const char* delim,
+                                      bool skip_empty = true) {
+  std::vector<std::string> result;
+  if (skip_empty) {
+    SplitStringUsing(full, delim, &result);
+  } else {
+    SplitStringAllowEmpty(full, delim, &result);
+  }
+  return result;
+}
+
+// ----------------------------------------------------------------------
+// JoinStrings()
+//    These methods concatenate a vector of strings into a C++ string, using
+//    the C-string "delim" as a separator between components. There are two
+//    flavors of the function, one flavor returns the concatenated string,
+//    another takes a pointer to the target string. In the latter case the
+//    target string is cleared and overwritten.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT void JoinStrings(const std::vector<std::string>& components,
+                                 const char* delim, std::string* result);
+
+inline std::string JoinStrings(const std::vector<std::string>& components,
+                               const char* delim) {
+  std::string result;
+  JoinStrings(components, delim, &result);
+  return result;
+}
+
+// ----------------------------------------------------------------------
+// UnescapeCEscapeSequences()
+//    Copies "source" to "dest", rewriting C-style escape sequences
+//    -- '\n', '\r', '\\', '\ooo', etc -- to their ASCII
+//    equivalents.  "dest" must be sufficiently large to hold all
+//    the characters in the rewritten string (i.e. at least as large
+//    as strlen(source) + 1 should be safe, since the replacements
+//    are always shorter than the original escaped sequences).  It's
+//    safe for source and dest to be the same.  RETURNS the length
+//    of dest.
+//
+//    It allows hex sequences \xhh, or generally \xhhhhh with an
+//    arbitrary number of hex digits, but all of them together must
+//    specify a value of a single byte (e.g. \x0045 is equivalent
+//    to \x45, and \x1234 is erroneous).
+//
+//    It also allows escape sequences of the form \uhhhh (exactly four
+//    hex digits, upper or lower case) or \Uhhhhhhhh (exactly eight
+//    hex digits, upper or lower case) to specify a Unicode code
+//    point. The dest array will contain the UTF8-encoded version of
+//    that code-point (e.g., if source contains \u2019, then dest will
+//    contain the three bytes 0xE2, 0x80, and 0x99).
+//
+//    Errors: In the first form of the call, errors are reported with
+//    LOG(ERROR). The same is true for the second form of the call if
+//    the pointer to the string std::vector is nullptr; otherwise, error
+//    messages are stored in the std::vector. In either case, the effect on
+//    the dest array is not defined, but rest of the source will be
+//    processed.
+//    ----------------------------------------------------------------------
+
+PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest);
+PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest,
+                                             std::vector<std::string>* errors);
+
+// ----------------------------------------------------------------------
+// UnescapeCEscapeString()
+//    This does the same thing as UnescapeCEscapeSequences, but creates
+//    a new string. The caller does not need to worry about allocating
+//    a dest buffer. This should be used for non performance critical
+//    tasks such as printing debug messages. It is safe for src and dest
+//    to be the same.
+//
+//    The second call stores its errors in a supplied string vector.
+//    If the string vector pointer is nullptr, it reports the errors with LOG().
+//
+//    In the first and second calls, the length of dest is returned. In the
+//    the third call, the new string is returned.
+// ----------------------------------------------------------------------
+
+PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src,
+                                          std::string* dest);
+PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src,
+                                          std::string* dest,
+                                          std::vector<std::string>* errors);
+PROTOBUF_EXPORT std::string UnescapeCEscapeString(const std::string& src);
+
+// ----------------------------------------------------------------------
+// CEscape()
+//    Escapes 'src' using C-style escape sequences and returns the resulting
+//    string.
+//
+//    Escaped chars: \n, \r, \t, ", ', \, and !isprint().
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT std::string CEscape(const std::string& src);
+
+// ----------------------------------------------------------------------
+// CEscapeAndAppend()
+//    Escapes 'src' using C-style escape sequences, and appends the escaped
+//    string to 'dest'.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT void CEscapeAndAppend(StringPiece src, std::string* dest);
+
+namespace strings {
+// Like CEscape() but does not escape bytes with the upper bit set.
+PROTOBUF_EXPORT std::string Utf8SafeCEscape(const std::string& src);
+
+// Like CEscape() but uses hex (\x) escapes instead of octals.
+PROTOBUF_EXPORT std::string CHexEscape(const std::string& src);
+}  // namespace strings
+
+// ----------------------------------------------------------------------
+// strto32()
+// strtou32()
+// strto64()
+// strtou64()
+//    Architecture-neutral plug compatible replacements for strtol() and
+//    strtoul().  Long's have different lengths on ILP-32 and LP-64
+//    platforms, so using these is safer, from the point of view of
+//    overflow behavior, than using the standard libc functions.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT int32_t strto32_adaptor(const char* nptr, char** endptr,
+                                        int base);
+PROTOBUF_EXPORT uint32_t strtou32_adaptor(const char* nptr, char** endptr,
+                                          int base);
+
+inline int32_t strto32(const char *nptr, char **endptr, int base) {
+  if (sizeof(int32_t) == sizeof(long))
+    return strtol(nptr, endptr, base);
+  else
+    return strto32_adaptor(nptr, endptr, base);
+}
+
+inline uint32_t strtou32(const char *nptr, char **endptr, int base) {
+  if (sizeof(uint32_t) == sizeof(unsigned long))
+    return strtoul(nptr, endptr, base);
+  else
+    return strtou32_adaptor(nptr, endptr, base);
+}
+
+// For now, long long is 64-bit on all the platforms we care about, so these
+// functions can simply pass the call to strto[u]ll.
+inline int64_t strto64(const char *nptr, char **endptr, int base) {
+  static_assert(sizeof(int64_t) == sizeof(long long),
+                "sizeof int64_t is not sizeof long long");
+  return strtoll(nptr, endptr, base);
+}
+
+inline uint64_t strtou64(const char *nptr, char **endptr, int base) {
+  static_assert(sizeof(uint64_t) == sizeof(unsigned long long),
+                "sizeof uint64_t is not sizeof unsigned long long");
+  return strtoull(nptr, endptr, base);
+}
+
+// ----------------------------------------------------------------------
+// safe_strtob()
+// safe_strto32()
+// safe_strtou32()
+// safe_strto64()
+// safe_strtou64()
+// safe_strtof()
+// safe_strtod()
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT bool safe_strtob(StringPiece str, bool* value);
+
+PROTOBUF_EXPORT bool safe_strto32(const std::string& str, int32_t* value);
+PROTOBUF_EXPORT bool safe_strtou32(const std::string& str, uint32_t* value);
+inline bool safe_strto32(const char* str, int32_t* value) {
+  return safe_strto32(std::string(str), value);
+}
+inline bool safe_strto32(StringPiece str, int32_t* value) {
+  return safe_strto32(str.ToString(), value);
+}
+inline bool safe_strtou32(const char* str, uint32_t* value) {
+  return safe_strtou32(std::string(str), value);
+}
+inline bool safe_strtou32(StringPiece str, uint32_t* value) {
+  return safe_strtou32(str.ToString(), value);
+}
+
+PROTOBUF_EXPORT bool safe_strto64(const std::string& str, int64_t* value);
+PROTOBUF_EXPORT bool safe_strtou64(const std::string& str, uint64_t* value);
+inline bool safe_strto64(const char* str, int64_t* value) {
+  return safe_strto64(std::string(str), value);
+}
+inline bool safe_strto64(StringPiece str, int64_t* value) {
+  return safe_strto64(str.ToString(), value);
+}
+inline bool safe_strtou64(const char* str, uint64_t* value) {
+  return safe_strtou64(std::string(str), value);
+}
+inline bool safe_strtou64(StringPiece str, uint64_t* value) {
+  return safe_strtou64(str.ToString(), value);
+}
+
+PROTOBUF_EXPORT bool safe_strtof(const char* str, float* value);
+PROTOBUF_EXPORT bool safe_strtod(const char* str, double* value);
+inline bool safe_strtof(const std::string& str, float* value) {
+  return safe_strtof(str.c_str(), value);
+}
+inline bool safe_strtod(const std::string& str, double* value) {
+  return safe_strtod(str.c_str(), value);
+}
+inline bool safe_strtof(StringPiece str, float* value) {
+  return safe_strtof(str.ToString(), value);
+}
+inline bool safe_strtod(StringPiece str, double* value) {
+  return safe_strtod(str.ToString(), value);
+}
+
+// ----------------------------------------------------------------------
+// FastIntToBuffer()
+// FastHexToBuffer()
+// FastHex64ToBuffer()
+// FastHex32ToBuffer()
+// FastTimeToBuffer()
+//    These are intended for speed.  FastIntToBuffer() assumes the
+//    integer is non-negative.  FastHexToBuffer() puts output in
+//    hex rather than decimal.  FastTimeToBuffer() puts the output
+//    into RFC822 format.
+//
+//    FastHex64ToBuffer() puts a 64-bit unsigned value in hex-format,
+//    padded to exactly 16 bytes (plus one byte for '\0')
+//
+//    FastHex32ToBuffer() puts a 32-bit unsigned value in hex-format,
+//    padded to exactly 8 bytes (plus one byte for '\0')
+//
+//       All functions take the output buffer as an arg.
+//    They all return a pointer to the beginning of the output,
+//    which may not be the beginning of the input buffer.
+// ----------------------------------------------------------------------
+
+// Suggested buffer size for FastToBuffer functions.  Also works with
+// DoubleToBuffer() and FloatToBuffer().
+static const int kFastToBufferSize = 32;
+
+PROTOBUF_EXPORT char* FastInt32ToBuffer(int32_t i, char* buffer);
+PROTOBUF_EXPORT char* FastInt64ToBuffer(int64_t i, char* buffer);
+char* FastUInt32ToBuffer(uint32_t i, char* buffer);  // inline below
+char* FastUInt64ToBuffer(uint64_t i, char* buffer);  // inline below
+PROTOBUF_EXPORT char* FastHexToBuffer(int i, char* buffer);
+PROTOBUF_EXPORT char* FastHex64ToBuffer(uint64_t i, char* buffer);
+PROTOBUF_EXPORT char* FastHex32ToBuffer(uint32_t i, char* buffer);
+
+// at least 22 bytes long
+inline char* FastIntToBuffer(int i, char* buffer) {
+  return (sizeof(i) == 4 ?
+          FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
+}
+inline char* FastUIntToBuffer(unsigned int i, char* buffer) {
+  return (sizeof(i) == 4 ?
+          FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
+}
+inline char* FastLongToBuffer(long i, char* buffer) {
+  return (sizeof(i) == 4 ?
+          FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
+}
+inline char* FastULongToBuffer(unsigned long i, char* buffer) {
+  return (sizeof(i) == 4 ?
+          FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
+}
+
+// ----------------------------------------------------------------------
+// FastInt32ToBufferLeft()
+// FastUInt32ToBufferLeft()
+// FastInt64ToBufferLeft()
+// FastUInt64ToBufferLeft()
+//
+// Like the Fast*ToBuffer() functions above, these are intended for speed.
+// Unlike the Fast*ToBuffer() functions, however, these functions write
+// their output to the beginning of the buffer (hence the name, as the
+// output is left-aligned).  The caller is responsible for ensuring that
+// the buffer has enough space to hold the output.
+//
+// Returns a pointer to the end of the string (i.e. the null character
+// terminating the string).
+// ----------------------------------------------------------------------
+
+PROTOBUF_EXPORT char* FastInt32ToBufferLeft(int32_t i, char* buffer);
+PROTOBUF_EXPORT char* FastUInt32ToBufferLeft(uint32_t i, char* buffer);
+PROTOBUF_EXPORT char* FastInt64ToBufferLeft(int64_t i, char* buffer);
+PROTOBUF_EXPORT char* FastUInt64ToBufferLeft(uint64_t i, char* buffer);
+
+// Just define these in terms of the above.
+inline char* FastUInt32ToBuffer(uint32_t i, char* buffer) {
+  FastUInt32ToBufferLeft(i, buffer);
+  return buffer;
+}
+inline char* FastUInt64ToBuffer(uint64_t i, char* buffer) {
+  FastUInt64ToBufferLeft(i, buffer);
+  return buffer;
+}
+
+inline std::string SimpleBtoa(bool value) { return value ? "true" : "false"; }
+
+// ----------------------------------------------------------------------
+// SimpleItoa()
+//    Description: converts an integer to a string.
+//
+//    Return value: string
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT std::string SimpleItoa(int i);
+PROTOBUF_EXPORT std::string SimpleItoa(unsigned int i);
+PROTOBUF_EXPORT std::string SimpleItoa(long i);
+PROTOBUF_EXPORT std::string SimpleItoa(unsigned long i);
+PROTOBUF_EXPORT std::string SimpleItoa(long long i);
+PROTOBUF_EXPORT std::string SimpleItoa(unsigned long long i);
+
+// ----------------------------------------------------------------------
+// SimpleDtoa()
+// SimpleFtoa()
+// DoubleToBuffer()
+// FloatToBuffer()
+//    Description: converts a double or float to a string which, if
+//    passed to NoLocaleStrtod(), will produce the exact same original double
+//    (except in case of NaN; all NaNs are considered the same value).
+//    We try to keep the string short but it's not guaranteed to be as
+//    short as possible.
+//
+//    DoubleToBuffer() and FloatToBuffer() write the text to the given
+//    buffer and return it.  The buffer must be at least
+//    kDoubleToBufferSize bytes for doubles and kFloatToBufferSize
+//    bytes for floats.  kFastToBufferSize is also guaranteed to be large
+//    enough to hold either.
+//
+//    Return value: string
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT std::string SimpleDtoa(double value);
+PROTOBUF_EXPORT std::string SimpleFtoa(float value);
+
+PROTOBUF_EXPORT char* DoubleToBuffer(double i, char* buffer);
+PROTOBUF_EXPORT char* FloatToBuffer(float i, char* buffer);
+
+// In practice, doubles should never need more than 24 bytes and floats
+// should never need more than 14 (including null terminators), but we
+// overestimate to be safe.
+static const int kDoubleToBufferSize = 32;
+static const int kFloatToBufferSize = 24;
+
+namespace strings {
+
+enum PadSpec {
+  NO_PAD = 1,
+  ZERO_PAD_2,
+  ZERO_PAD_3,
+  ZERO_PAD_4,
+  ZERO_PAD_5,
+  ZERO_PAD_6,
+  ZERO_PAD_7,
+  ZERO_PAD_8,
+  ZERO_PAD_9,
+  ZERO_PAD_10,
+  ZERO_PAD_11,
+  ZERO_PAD_12,
+  ZERO_PAD_13,
+  ZERO_PAD_14,
+  ZERO_PAD_15,
+  ZERO_PAD_16,
+};
+
+struct Hex {
+  uint64_t value;
+  enum PadSpec spec;
+  template <class Int>
+  explicit Hex(Int v, PadSpec s = NO_PAD)
+      : spec(s) {
+    // Prevent sign-extension by casting integers to
+    // their unsigned counterparts.
+#ifdef LANG_CXX11
+    static_assert(
+        sizeof(v) == 1 || sizeof(v) == 2 || sizeof(v) == 4 || sizeof(v) == 8,
+        "Unknown integer type");
+#endif
+    value = sizeof(v) == 1 ? static_cast<uint8_t>(v)
+          : sizeof(v) == 2 ? static_cast<uint16_t>(v)
+          : sizeof(v) == 4 ? static_cast<uint32_t>(v)
+          : static_cast<uint64_t>(v);
+  }
+};
+
+struct PROTOBUF_EXPORT AlphaNum {
+  const char *piece_data_;  // move these to string_ref eventually
+  size_t piece_size_;       // move these to string_ref eventually
+
+  char digits[kFastToBufferSize];
+
+  // No bool ctor -- bools convert to an integral type.
+  // A bool ctor would also convert incoming pointers (bletch).
+
+  AlphaNum(int i32)
+      : piece_data_(digits),
+        piece_size_(FastInt32ToBufferLeft(i32, digits) - &digits[0]) {}
+  AlphaNum(unsigned int u32)
+      : piece_data_(digits),
+        piece_size_(FastUInt32ToBufferLeft(u32, digits) - &digits[0]) {}
+  AlphaNum(long long i64)
+      : piece_data_(digits),
+        piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {}
+  AlphaNum(unsigned long long u64)
+      : piece_data_(digits),
+        piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0]) {}
+
+  // Note: on some architectures, "long" is only 32 bits, not 64, but the
+  // performance hit of using FastInt64ToBufferLeft to handle 32-bit values
+  // is quite minor.
+  AlphaNum(long i64)
+      : piece_data_(digits),
+        piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {}
+  AlphaNum(unsigned long u64)
+      : piece_data_(digits),
+        piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0]) {}
+
+  AlphaNum(float f)
+    : piece_data_(digits), piece_size_(strlen(FloatToBuffer(f, digits))) {}
+  AlphaNum(double f)
+    : piece_data_(digits), piece_size_(strlen(DoubleToBuffer(f, digits))) {}
+
+  AlphaNum(Hex hex);
+
+  AlphaNum(const char* c_str)
+      : piece_data_(c_str), piece_size_(strlen(c_str)) {}
+  // TODO: Add a string_ref constructor, eventually
+  // AlphaNum(const StringPiece &pc) : piece(pc) {}
+
+  AlphaNum(const std::string& str)
+      : piece_data_(str.data()), piece_size_(str.size()) {}
+
+  AlphaNum(StringPiece str)
+      : piece_data_(str.data()), piece_size_(str.size()) {}
+
+  size_t size() const { return piece_size_; }
+  const char *data() const { return piece_data_; }
+
+ private:
+  // Use ":" not ':'
+  AlphaNum(char c);  // NOLINT(runtime/explicit)
+
+  // Disallow copy and assign.
+  AlphaNum(const AlphaNum&);
+  void operator=(const AlphaNum&);
+};
+
+}  // namespace strings
+
+using strings::AlphaNum;
+
+// ----------------------------------------------------------------------
+// StrCat()
+//    This merges the given strings or numbers, with no delimiter.  This
+//    is designed to be the fastest possible way to construct a string out
+//    of a mix of raw C strings, strings, bool values,
+//    and numeric values.
+//
+//    Don't use this for user-visible strings.  The localization process
+//    works poorly on strings built up out of fragments.
+//
+//    For clarity and performance, don't use StrCat when appending to a
+//    string.  In particular, avoid using any of these (anti-)patterns:
+//      str.append(StrCat(...)
+//      str += StrCat(...)
+//      str = StrCat(str, ...)
+//    where the last is the worse, with the potential to change a loop
+//    from a linear time operation with O(1) dynamic allocations into a
+//    quadratic time operation with O(n) dynamic allocations.  StrAppend
+//    is a better choice than any of the above, subject to the restriction
+//    of StrAppend(&str, a, b, c, ...) that none of the a, b, c, ... may
+//    be a reference into str.
+// ----------------------------------------------------------------------
+
+PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b);
+PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                   const AlphaNum& c);
+PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                   const AlphaNum& c, const AlphaNum& d);
+PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                   const AlphaNum& c, const AlphaNum& d,
+                                   const AlphaNum& e);
+PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                   const AlphaNum& c, const AlphaNum& d,
+                                   const AlphaNum& e, const AlphaNum& f);
+PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                   const AlphaNum& c, const AlphaNum& d,
+                                   const AlphaNum& e, const AlphaNum& f,
+                                   const AlphaNum& g);
+PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                   const AlphaNum& c, const AlphaNum& d,
+                                   const AlphaNum& e, const AlphaNum& f,
+                                   const AlphaNum& g, const AlphaNum& h);
+PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+                                   const AlphaNum& c, const AlphaNum& d,
+                                   const AlphaNum& e, const AlphaNum& f,
+                                   const AlphaNum& g, const AlphaNum& h,
+                                   const AlphaNum& i);
+
+inline std::string StrCat(const AlphaNum& a) {
+  return std::string(a.data(), a.size());
+}
+
+// ----------------------------------------------------------------------
+// StrAppend()
+//    Same as above, but adds the output to the given string.
+//    WARNING: For speed, StrAppend does not try to check each of its input
+//    arguments to be sure that they are not a subset of the string being
+//    appended to.  That is, while this will work:
+//
+//    string s = "foo";
+//    s += s;
+//
+//    This will not (necessarily) work:
+//
+//    string s = "foo";
+//    StrAppend(&s, s);
+//
+//    Note: while StrCat supports appending up to 9 arguments, StrAppend
+//    is currently limited to 4.  That's rarely an issue except when
+//    automatically transforming StrCat to StrAppend, and can easily be
+//    worked around as consecutive calls to StrAppend are quite efficient.
+// ----------------------------------------------------------------------
+
+PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a);
+PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a,
+                               const AlphaNum& b);
+PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a,
+                               const AlphaNum& b, const AlphaNum& c);
+PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a,
+                               const AlphaNum& b, const AlphaNum& c,
+                               const AlphaNum& d);
+
+// ----------------------------------------------------------------------
+// Join()
+//    These methods concatenate a range of components into a C++ string, using
+//    the C-string "delim" as a separator between components.
+// ----------------------------------------------------------------------
+template <typename Iterator>
+void Join(Iterator start, Iterator end, const char* delim,
+          std::string* result) {
+  for (Iterator it = start; it != end; ++it) {
+    if (it != start) {
+      result->append(delim);
+    }
+    StrAppend(result, *it);
+  }
+}
+
+template <typename Range>
+std::string Join(const Range& components, const char* delim) {
+  std::string result;
+  Join(components.begin(), components.end(), delim, &result);
+  return result;
+}
+
+// ----------------------------------------------------------------------
+// ToHex()
+//    Return a lower-case hex string representation of the given integer.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT std::string ToHex(uint64_t num);
+
+// ----------------------------------------------------------------------
+// GlobalReplaceSubstring()
+//    Replaces all instances of a substring in a string.  Does nothing
+//    if 'substring' is empty.  Returns the number of replacements.
+//
+//    NOTE: The string pieces must not overlap s.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT int GlobalReplaceSubstring(const std::string& substring,
+                                           const std::string& replacement,
+                                           std::string* s);
+
+// ----------------------------------------------------------------------
+// Base64Unescape()
+//    Converts "src" which is encoded in Base64 to its binary equivalent and
+//    writes it to "dest". If src contains invalid characters, dest is cleared
+//    and the function returns false. Returns true on success.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT bool Base64Unescape(StringPiece src, std::string* dest);
+
+// ----------------------------------------------------------------------
+// WebSafeBase64Unescape()
+//    This is a variation of Base64Unescape which uses '-' instead of '+', and
+//    '_' instead of '/'. src is not null terminated, instead specify len. I
+//    recommend that slen<szdest, but we honor szdest anyway.
+//    RETURNS the length of dest, or -1 if src contains invalid chars.
+
+//    The variation that stores into a string clears the string first, and
+//    returns false (with dest empty) if src contains invalid chars; for
+//    this version src and dest must be different strings.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT int WebSafeBase64Unescape(const char* src, int slen, char* dest,
+                                          int szdest);
+PROTOBUF_EXPORT bool WebSafeBase64Unescape(StringPiece src, std::string* dest);
+
+// Return the length to use for the output buffer given to the base64 escape
+// routines. Make sure to use the same value for do_padding in both.
+// This function may return incorrect results if given input_len values that
+// are extremely high, which should happen rarely.
+PROTOBUF_EXPORT int CalculateBase64EscapedLen(int input_len, bool do_padding);
+// Use this version when calling Base64Escape without a do_padding arg.
+PROTOBUF_EXPORT int CalculateBase64EscapedLen(int input_len);
+
+// ----------------------------------------------------------------------
+// Base64Escape()
+// WebSafeBase64Escape()
+//    Encode "src" to "dest" using base64 encoding.
+//    src is not null terminated, instead specify len.
+//    'dest' should have at least CalculateBase64EscapedLen() length.
+//    RETURNS the length of dest.
+//    The WebSafe variation use '-' instead of '+' and '_' instead of '/'
+//    so that we can place the out in the URL or cookies without having
+//    to escape them.  It also has an extra parameter "do_padding",
+//    which when set to false will prevent padding with "=".
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT int Base64Escape(const unsigned char* src, int slen, char* dest,
+                                 int szdest);
+PROTOBUF_EXPORT int WebSafeBase64Escape(const unsigned char* src, int slen,
+                                        char* dest, int szdest,
+                                        bool do_padding);
+// Encode src into dest with padding.
+PROTOBUF_EXPORT void Base64Escape(StringPiece src, std::string* dest);
+// Encode src into dest web-safely without padding.
+PROTOBUF_EXPORT void WebSafeBase64Escape(StringPiece src, std::string* dest);
+// Encode src into dest web-safely with padding.
+PROTOBUF_EXPORT void WebSafeBase64EscapeWithPadding(StringPiece src,
+                                                    std::string* dest);
+
+PROTOBUF_EXPORT void Base64Escape(const unsigned char* src, int szsrc,
+                                  std::string* dest, bool do_padding);
+PROTOBUF_EXPORT void WebSafeBase64Escape(const unsigned char* src, int szsrc,
+                                         std::string* dest, bool do_padding);
+
+inline bool IsValidCodePoint(uint32_t code_point) {
+  return code_point < 0xD800 ||
+         (code_point >= 0xE000 && code_point <= 0x10FFFF);
+}
+
+static const int UTFmax = 4;
+// ----------------------------------------------------------------------
+// EncodeAsUTF8Char()
+//  Helper to append a Unicode code point to a string as UTF8, without bringing
+//  in any external dependencies. The output buffer must be as least 4 bytes
+//  large.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT int EncodeAsUTF8Char(uint32_t code_point, char* output);
+
+// ----------------------------------------------------------------------
+// UTF8FirstLetterNumBytes()
+//   Length of the first UTF-8 character.
+// ----------------------------------------------------------------------
+PROTOBUF_EXPORT int UTF8FirstLetterNumBytes(const char* src, int len);
+
+// From google3/third_party/absl/strings/escaping.h
+
+// ----------------------------------------------------------------------
+// CleanStringLineEndings()
+//   Clean up a multi-line string to conform to Unix line endings.
+//   Reads from src and appends to dst, so usually dst should be empty.
+//
+//   If there is no line ending at the end of a non-empty string, it can
+//   be added automatically.
+//
+//   Four different types of input are correctly handled:
+//
+//     - Unix/Linux files: line ending is LF: pass through unchanged
+//
+//     - DOS/Windows files: line ending is CRLF: convert to LF
+//
+//     - Legacy Mac files: line ending is CR: convert to LF
+//
+//     - Garbled files: random line endings: convert gracefully
+//                      lonely CR, lonely LF, CRLF: convert to LF
+//
+//   @param src The multi-line string to convert
+//   @param dst The converted string is appended to this string
+//   @param auto_end_last_line Automatically terminate the last line
+//
+//   Limitations:
+//
+//     This does not do the right thing for CRCRLF files created by
+//     broken programs that do another Unix->DOS conversion on files
+//     that are already in CRLF format.  For this, a two-pass approach
+//     brute-force would be needed that
+//
+//       (1) determines the presence of LF (first one is ok)
+//       (2) if yes, removes any CR, else convert every CR to LF
+PROTOBUF_EXPORT void CleanStringLineEndings(const std::string& src,
+                                            std::string* dst,
+                                            bool auto_end_last_line);
+
+// Same as above, but transforms the argument in place.
+PROTOBUF_EXPORT void CleanStringLineEndings(std::string* str,
+                                            bool auto_end_last_line);
+
+namespace strings {
+inline bool EndsWith(StringPiece text, StringPiece suffix) {
+  return suffix.empty() ||
+      (text.size() >= suffix.size() &&
+       memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
+              suffix.size()) == 0);
+}
+}  // namespace strings
+
+namespace internal {
+
+// A locale-independent version of the standard strtod(), which always
+// uses a dot as the decimal separator.
+double NoLocaleStrtod(const char* str, char** endptr);
+
+}  // namespace internal
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_STUBS_STRUTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h
new file mode 100644
index 0000000..feef904
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h
@@ -0,0 +1,138 @@
+// Copyright 2005 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ----
+// Author: lar@google.com (Laramie Leavitt)
+//
+// Template metaprogramming utility functions.
+//
+// This code is compiled directly on many platforms, including client
+// platforms like Windows, Mac, and embedded systems.  Before making
+// any changes here, make sure that you're not breaking any platforms.
+//
+//
+// The names chosen here reflect those used in tr1 and the boost::mpl
+// library, there are similar operations used in the Loki library as
+// well.  I prefer the boost names for 2 reasons:
+// 1.  I think that portions of the Boost libraries are more likely to
+// be included in the c++ standard.
+// 2.  It is not impossible that some of the boost libraries will be
+// included in our own build in the future.
+// Both of these outcomes means that we may be able to directly replace
+// some of these with boost equivalents.
+//
+#ifndef GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
+#define GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Types small_ and big_ are guaranteed such that sizeof(small_) <
+// sizeof(big_)
+typedef char small_;
+
+struct big_ {
+  char dummy[2];
+};
+
+// Identity metafunction.
+template <class T>
+struct identity_ {
+  typedef T type;
+};
+
+// integral_constant, defined in tr1, is a wrapper for an integer
+// value. We don't really need this generality; we could get away
+// with hardcoding the integer type to bool. We use the fully
+// general integer_constant for compatibility with tr1.
+
+template<class T, T v>
+struct integral_constant {
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T, v> type;
+};
+
+template <class T, T v> const T integral_constant<T, v>::value;
+
+
+// Abbreviations: true_type and false_type are structs that represent boolean
+// true and false values. Also define the boost::mpl versions of those names,
+// true_ and false_.
+typedef integral_constant<bool, true>  true_type;
+typedef integral_constant<bool, false> false_type;
+typedef true_type  true_;
+typedef false_type false_;
+
+// if_ is a templatized conditional statement.
+// if_<cond, A, B> is a compile time evaluation of cond.
+// if_<>::type contains A if cond is true, B otherwise.
+template<bool cond, typename A, typename B>
+struct if_{
+  typedef A type;
+};
+
+template<typename A, typename B>
+struct if_<false, A, B> {
+  typedef B type;
+};
+
+
+// type_equals_ is a template type comparator, similar to Loki IsSameType.
+// type_equals_<A, B>::value is true iff "A" is the same type as "B".
+//
+// New code should prefer base::is_same, defined in base/type_traits.h.
+// It is functionally identical, but is_same is the standard spelling.
+template<typename A, typename B>
+struct type_equals_ : public false_ {
+};
+
+template<typename A>
+struct type_equals_<A, A> : public true_ {
+};
+
+// and_ is a template && operator.
+// and_<A, B>::value evaluates "A::value && B::value".
+template<typename A, typename B>
+struct and_ : public integral_constant<bool, (A::value && B::value)> {
+};
+
+// or_ is a template || operator.
+// or_<A, B>::value evaluates "A::value || B::value".
+template<typename A, typename B>
+struct or_ : public integral_constant<bool, (A::value || B::value)> {
+};
+
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/text_format.h b/CAPI/cpp/grpc/include/google/protobuf/text_format.h
new file mode 100644
index 0000000..e10bef7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/text_format.h
@@ -0,0 +1,693 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: jschorr@google.com (Joseph Schorr)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Utilities for printing and parsing protocol messages in a human-readable,
+// text-based format.
+
+#ifndef GOOGLE_PROTOBUF_TEXT_FORMAT_H__
+#define GOOGLE_PROTOBUF_TEXT_FORMAT_H__
+
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/message_lite.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+
+namespace internal {
+PROTOBUF_EXPORT extern const char kDebugStringSilentMarker[1];
+PROTOBUF_EXPORT extern const char kDebugStringSilentMarkerForDetection[3];
+}  // namespace internal
+
+namespace io {
+class ErrorCollector;  // tokenizer.h
+}
+
+// This class implements protocol buffer text format, colloquially known as text
+// proto.  Printing and parsing protocol messages in text format is useful for
+// debugging and human editing of messages.
+//
+// This class is really a namespace that contains only static methods.
+class PROTOBUF_EXPORT TextFormat {
+ public:
+  // Outputs a textual representation of the given message to the given
+  // output stream. Returns false if printing fails.
+  static bool Print(const Message& message, io::ZeroCopyOutputStream* output);
+
+  // Print the fields in an UnknownFieldSet.  They are printed by tag number
+  // only.  Embedded messages are heuristically identified by attempting to
+  // parse them. Returns false if printing fails.
+  static bool PrintUnknownFields(const UnknownFieldSet& unknown_fields,
+                                 io::ZeroCopyOutputStream* output);
+
+  // Like Print(), but outputs directly to a string.
+  // Note: output will be cleared prior to printing, and will be left empty
+  // even if printing fails. Returns false if printing fails.
+  static bool PrintToString(const Message& message, std::string* output);
+
+  // Like PrintUnknownFields(), but outputs directly to a string. Returns
+  // false if printing fails.
+  static bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields,
+                                         std::string* output);
+
+  // Outputs a textual representation of the value of the field supplied on
+  // the message supplied. For non-repeated fields, an index of -1 must
+  // be supplied. Note that this method will print the default value for a
+  // field if it is not set.
+  static void PrintFieldValueToString(const Message& message,
+                                      const FieldDescriptor* field, int index,
+                                      std::string* output);
+
+  class PROTOBUF_EXPORT BaseTextGenerator {
+   public:
+    virtual ~BaseTextGenerator();
+
+    virtual void Indent() {}
+    virtual void Outdent() {}
+    // Returns the current indentation size in characters.
+    virtual size_t GetCurrentIndentationSize() const { return 0; }
+
+    // Print text to the output stream.
+    virtual void Print(const char* text, size_t size) = 0;
+
+    void PrintString(const std::string& str) { Print(str.data(), str.size()); }
+
+    template <size_t n>
+    void PrintLiteral(const char (&text)[n]) {
+      Print(text, n - 1);  // n includes the terminating zero character.
+    }
+  };
+
+  // The default printer that converts scalar values from fields into their
+  // string representation.
+  // You can derive from this FastFieldValuePrinter if you want to have fields
+  // to be printed in a different way and register it at the Printer.
+  class PROTOBUF_EXPORT FastFieldValuePrinter {
+   public:
+    FastFieldValuePrinter();
+    virtual ~FastFieldValuePrinter();
+    virtual void PrintBool(bool val, BaseTextGenerator* generator) const;
+    virtual void PrintInt32(int32_t val, BaseTextGenerator* generator) const;
+    virtual void PrintUInt32(uint32_t val, BaseTextGenerator* generator) const;
+    virtual void PrintInt64(int64_t val, BaseTextGenerator* generator) const;
+    virtual void PrintUInt64(uint64_t val, BaseTextGenerator* generator) const;
+    virtual void PrintFloat(float val, BaseTextGenerator* generator) const;
+    virtual void PrintDouble(double val, BaseTextGenerator* generator) const;
+    virtual void PrintString(const std::string& val,
+                             BaseTextGenerator* generator) const;
+    virtual void PrintBytes(const std::string& val,
+                            BaseTextGenerator* generator) const;
+    virtual void PrintEnum(int32_t val, const std::string& name,
+                           BaseTextGenerator* generator) const;
+    virtual void PrintFieldName(const Message& message, int field_index,
+                                int field_count, const Reflection* reflection,
+                                const FieldDescriptor* field,
+                                BaseTextGenerator* generator) const;
+    virtual void PrintFieldName(const Message& message,
+                                const Reflection* reflection,
+                                const FieldDescriptor* field,
+                                BaseTextGenerator* generator) const;
+    virtual void PrintMessageStart(const Message& message, int field_index,
+                                   int field_count, bool single_line_mode,
+                                   BaseTextGenerator* generator) const;
+    // Allows to override the logic on how to print the content of a message.
+    // Return false to use the default printing logic. Note that it is legal for
+    // this function to print something and then return false to use the default
+    // content printing (although at that point it would behave similarly to
+    // PrintMessageStart).
+    virtual bool PrintMessageContent(const Message& message, int field_index,
+                                     int field_count, bool single_line_mode,
+                                     BaseTextGenerator* generator) const;
+    virtual void PrintMessageEnd(const Message& message, int field_index,
+                                 int field_count, bool single_line_mode,
+                                 BaseTextGenerator* generator) const;
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastFieldValuePrinter);
+  };
+
+  // Deprecated: please use FastFieldValuePrinter instead.
+  class PROTOBUF_EXPORT FieldValuePrinter {
+   public:
+    FieldValuePrinter();
+    virtual ~FieldValuePrinter();
+    virtual std::string PrintBool(bool val) const;
+    virtual std::string PrintInt32(int32_t val) const;
+    virtual std::string PrintUInt32(uint32_t val) const;
+    virtual std::string PrintInt64(int64_t val) const;
+    virtual std::string PrintUInt64(uint64_t val) const;
+    virtual std::string PrintFloat(float val) const;
+    virtual std::string PrintDouble(double val) const;
+    virtual std::string PrintString(const std::string& val) const;
+    virtual std::string PrintBytes(const std::string& val) const;
+    virtual std::string PrintEnum(int32_t val, const std::string& name) const;
+    virtual std::string PrintFieldName(const Message& message,
+                                       const Reflection* reflection,
+                                       const FieldDescriptor* field) const;
+    virtual std::string PrintMessageStart(const Message& message,
+                                          int field_index, int field_count,
+                                          bool single_line_mode) const;
+    virtual std::string PrintMessageEnd(const Message& message, int field_index,
+                                        int field_count,
+                                        bool single_line_mode) const;
+
+   private:
+    FastFieldValuePrinter delegate_;
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldValuePrinter);
+  };
+
+  class PROTOBUF_EXPORT MessagePrinter {
+   public:
+    MessagePrinter() {}
+    virtual ~MessagePrinter() {}
+    virtual void Print(const Message& message, bool single_line_mode,
+                       BaseTextGenerator* generator) const = 0;
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessagePrinter);
+  };
+
+  // Interface that Printers or Parsers can use to find extensions, or types
+  // referenced in Any messages.
+  class PROTOBUF_EXPORT Finder {
+   public:
+    virtual ~Finder();
+
+    // Try to find an extension of *message by fully-qualified field
+    // name.  Returns nullptr if no extension is known for this name or number.
+    // The base implementation uses the extensions already known by the message.
+    virtual const FieldDescriptor* FindExtension(Message* message,
+                                                 const std::string& name) const;
+
+    // Similar to FindExtension, but uses a Descriptor and the extension number
+    // instead of using a Message and the name when doing the look up.
+    virtual const FieldDescriptor* FindExtensionByNumber(
+        const Descriptor* descriptor, int number) const;
+
+    // Find the message type for an Any proto.
+    // Returns nullptr if no message is known for this name.
+    // The base implementation only accepts prefixes of type.googleprod.com/ or
+    // type.googleapis.com/, and searches the DescriptorPool of the parent
+    // message.
+    virtual const Descriptor* FindAnyType(const Message& message,
+                                          const std::string& prefix,
+                                          const std::string& name) const;
+
+    // Find the message factory for the given extension field. This can be used
+    // to generalize the Parser to add extension fields to a message in the same
+    // way as the "input" message for the Parser.
+    virtual MessageFactory* FindExtensionFactory(
+        const FieldDescriptor* field) const;
+  };
+
+  // Class for those users which require more fine-grained control over how
+  // a protobuffer message is printed out.
+  class PROTOBUF_EXPORT Printer {
+   public:
+    Printer();
+
+    // Like TextFormat::Print
+    bool Print(const Message& message, io::ZeroCopyOutputStream* output) const;
+    // Like TextFormat::PrintUnknownFields
+    bool PrintUnknownFields(const UnknownFieldSet& unknown_fields,
+                            io::ZeroCopyOutputStream* output) const;
+    // Like TextFormat::PrintToString
+    bool PrintToString(const Message& message, std::string* output) const;
+    // Like TextFormat::PrintUnknownFieldsToString
+    bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields,
+                                    std::string* output) const;
+    // Like TextFormat::PrintFieldValueToString
+    void PrintFieldValueToString(const Message& message,
+                                 const FieldDescriptor* field, int index,
+                                 std::string* output) const;
+
+    // Adjust the initial indent level of all output.  Each indent level is
+    // equal to two spaces.
+    void SetInitialIndentLevel(int indent_level) {
+      initial_indent_level_ = indent_level;
+    }
+
+    // If printing in single line mode, then the entire message will be output
+    // on a single line with no line breaks.
+    void SetSingleLineMode(bool single_line_mode) {
+      single_line_mode_ = single_line_mode;
+    }
+
+    bool IsInSingleLineMode() const { return single_line_mode_; }
+
+    // If use_field_number is true, uses field number instead of field name.
+    void SetUseFieldNumber(bool use_field_number) {
+      use_field_number_ = use_field_number;
+    }
+
+    // Set true to print repeated primitives in a format like:
+    //   field_name: [1, 2, 3, 4]
+    // instead of printing each value on its own line.  Short format applies
+    // only to primitive values -- i.e. everything except strings and
+    // sub-messages/groups.
+    void SetUseShortRepeatedPrimitives(bool use_short_repeated_primitives) {
+      use_short_repeated_primitives_ = use_short_repeated_primitives;
+    }
+
+    // Set true to output UTF-8 instead of ASCII.  The only difference
+    // is that bytes >= 0x80 in string fields will not be escaped,
+    // because they are assumed to be part of UTF-8 multi-byte
+    // sequences. This will change the default FastFieldValuePrinter.
+    void SetUseUtf8StringEscaping(bool as_utf8);
+
+    // Set the default FastFieldValuePrinter that is used for all fields that
+    // don't have a field-specific printer registered.
+    // Takes ownership of the printer.
+    void SetDefaultFieldValuePrinter(const FastFieldValuePrinter* printer);
+
+    PROTOBUF_DEPRECATED_MSG("Please use FastFieldValuePrinter")
+    void SetDefaultFieldValuePrinter(const FieldValuePrinter* printer);
+
+    // Sets whether we want to hide unknown fields or not.
+    // Usually unknown fields are printed in a generic way that includes the
+    // tag number of the field instead of field name. However, sometimes it
+    // is useful to be able to print the message without unknown fields (e.g.
+    // for the python protobuf version to maintain consistency between its pure
+    // python and c++ implementations).
+    void SetHideUnknownFields(bool hide) { hide_unknown_fields_ = hide; }
+
+    // If print_message_fields_in_index_order is true, fields of a proto message
+    // will be printed using the order defined in source code instead of the
+    // field number, extensions will be printed at the end of the message
+    // and their relative order is determined by the extension number.
+    // By default, use the field number order.
+    void SetPrintMessageFieldsInIndexOrder(
+        bool print_message_fields_in_index_order) {
+      print_message_fields_in_index_order_ =
+          print_message_fields_in_index_order;
+    }
+
+    // If expand==true, expand google.protobuf.Any payloads. The output
+    // will be of form
+    //    [type_url] { <value_printed_in_text> }
+    //
+    // If expand==false, print Any using the default printer. The output will
+    // look like
+    //    type_url: "<type_url>"  value: "serialized_content"
+    void SetExpandAny(bool expand) { expand_any_ = expand; }
+
+    // Set how parser finds message for Any payloads.
+    void SetFinder(const Finder* finder) { finder_ = finder; }
+
+    // If non-zero, we truncate all string fields that are  longer than
+    // this threshold.  This is useful when the proto message has very long
+    // strings, e.g., dump of encoded image file.
+    //
+    // NOTE(hfgong):  Setting a non-zero value breaks round-trip safe
+    // property of TextFormat::Printer.  That is, from the printed message, we
+    // cannot fully recover the original string field any more.
+    void SetTruncateStringFieldLongerThan(
+        const int64_t truncate_string_field_longer_than) {
+      truncate_string_field_longer_than_ = truncate_string_field_longer_than;
+    }
+
+    // Register a custom field-specific FastFieldValuePrinter for fields
+    // with a particular FieldDescriptor.
+    // Returns "true" if the registration succeeded, or "false", if there is
+    // already a printer for that FieldDescriptor.
+    // Takes ownership of the printer on successful registration.
+    bool RegisterFieldValuePrinter(const FieldDescriptor* field,
+                                   const FastFieldValuePrinter* printer);
+
+    PROTOBUF_DEPRECATED_MSG("Please use FastFieldValuePrinter")
+    bool RegisterFieldValuePrinter(const FieldDescriptor* field,
+                                   const FieldValuePrinter* printer);
+
+    // Register a custom message-specific MessagePrinter for messages with a
+    // particular Descriptor.
+    // Returns "true" if the registration succeeded, or "false" if there is
+    // already a printer for that Descriptor.
+    bool RegisterMessagePrinter(const Descriptor* descriptor,
+                                const MessagePrinter* printer);
+
+   private:
+    friend std::string Message::DebugString() const;
+    friend std::string Message::ShortDebugString() const;
+    friend std::string Message::Utf8DebugString() const;
+
+    // Sets whether *DebugString should insert a silent marker.
+    void SetInsertSilentMarker(bool v) { insert_silent_marker_ = v; }
+
+    // Forward declaration of an internal class used to print the text
+    // output to the OutputStream (see text_format.cc for implementation).
+    class TextGenerator;
+
+    // Forward declaration of an internal class used to print field values for
+    // DebugString APIs (see text_format.cc for implementation).
+    class DebugStringFieldValuePrinter;
+
+    // Forward declaration of an internal class used to print UTF-8 escaped
+    // strings (see text_format.cc for implementation).
+    class FastFieldValuePrinterUtf8Escaping;
+
+    static const char* const kDoNotParse;
+
+    // Internal Print method, used for writing to the OutputStream via
+    // the TextGenerator class.
+    void Print(const Message& message, TextGenerator* generator) const;
+
+    // Print a single field.
+    void PrintField(const Message& message, const Reflection* reflection,
+                    const FieldDescriptor* field,
+                    TextGenerator* generator) const;
+
+    // Print a repeated primitive field in short form.
+    void PrintShortRepeatedField(const Message& message,
+                                 const Reflection* reflection,
+                                 const FieldDescriptor* field,
+                                 TextGenerator* generator) const;
+
+    // Print the name of a field -- i.e. everything that comes before the
+    // ':' for a single name/value pair.
+    void PrintFieldName(const Message& message, int field_index,
+                        int field_count, const Reflection* reflection,
+                        const FieldDescriptor* field,
+                        TextGenerator* generator) const;
+
+    // Outputs a textual representation of the value of the field supplied on
+    // the message supplied or the default value if not set.
+    void PrintFieldValue(const Message& message, const Reflection* reflection,
+                         const FieldDescriptor* field, int index,
+                         TextGenerator* generator) const;
+
+    // Print the fields in an UnknownFieldSet.  They are printed by tag number
+    // only.  Embedded messages are heuristically identified by attempting to
+    // parse them (subject to the recursion budget).
+    void PrintUnknownFields(const UnknownFieldSet& unknown_fields,
+                            TextGenerator* generator,
+                            int recursion_budget) const;
+
+    bool PrintAny(const Message& message, TextGenerator* generator) const;
+
+    const FastFieldValuePrinter* GetFieldPrinter(
+        const FieldDescriptor* field) const {
+      auto it = custom_printers_.find(field);
+      return it == custom_printers_.end() ? default_field_value_printer_.get()
+                                          : it->second.get();
+    }
+
+    int initial_indent_level_;
+    bool single_line_mode_;
+    bool use_field_number_;
+    bool use_short_repeated_primitives_;
+    bool insert_silent_marker_;
+    bool hide_unknown_fields_;
+    bool print_message_fields_in_index_order_;
+    bool expand_any_;
+    int64_t truncate_string_field_longer_than_;
+
+    std::unique_ptr<const FastFieldValuePrinter> default_field_value_printer_;
+    typedef std::map<const FieldDescriptor*,
+                     std::unique_ptr<const FastFieldValuePrinter>>
+        CustomPrinterMap;
+    CustomPrinterMap custom_printers_;
+
+    typedef std::map<const Descriptor*, std::unique_ptr<const MessagePrinter>>
+        CustomMessagePrinterMap;
+    CustomMessagePrinterMap custom_message_printers_;
+
+    const Finder* finder_;
+  };
+
+  // Parses a text-format protocol message from the given input stream to
+  // the given message object. This function parses the human-readable
+  // serialization format written by Print(). Returns true on success. The
+  // message is cleared first, even if the function fails -- See Merge() to
+  // avoid this behavior.
+  //
+  // Example input: "user {\n id: 123 extra { gender: MALE language: 'en' }\n}"
+  //
+  // One common use for this function is parsing handwritten strings in test
+  // code.
+  //
+  // If you would like to read a protocol buffer serialized in the
+  // (non-human-readable) binary wire format, see
+  // google::protobuf::MessageLite::ParseFromString().
+  static bool Parse(io::ZeroCopyInputStream* input, Message* output);
+  // Like Parse(), but reads directly from a string.
+  static bool ParseFromString(ConstStringParam input, Message* output);
+
+  // Like Parse(), but the data is merged into the given message, as if
+  // using Message::MergeFrom().
+  static bool Merge(io::ZeroCopyInputStream* input, Message* output);
+  // Like Merge(), but reads directly from a string.
+  static bool MergeFromString(ConstStringParam input, Message* output);
+
+  // Parse the given text as a single field value and store it into the
+  // given field of the given message. If the field is a repeated field,
+  // the new value will be added to the end
+  static bool ParseFieldValueFromString(const std::string& input,
+                                        const FieldDescriptor* field,
+                                        Message* message);
+
+  // A location in the parsed text.
+  struct ParseLocation {
+    int line;
+    int column;
+
+    ParseLocation() : line(-1), column(-1) {}
+    ParseLocation(int line_param, int column_param)
+        : line(line_param), column(column_param) {}
+  };
+
+  // A range of locations in the parsed text, including `start` and excluding
+  // `end`.
+  struct ParseLocationRange {
+    ParseLocation start;
+    ParseLocation end;
+    ParseLocationRange() : start(), end() {}
+    ParseLocationRange(ParseLocation start_param, ParseLocation end_param)
+        : start(start_param), end(end_param) {}
+  };
+
+  // Data structure which is populated with the locations of each field
+  // value parsed from the text.
+  class PROTOBUF_EXPORT ParseInfoTree {
+   public:
+    ParseInfoTree() = default;
+    ParseInfoTree(const ParseInfoTree&) = delete;
+    ParseInfoTree& operator=(const ParseInfoTree&) = delete;
+
+    // Returns the parse location range for index-th value of the field in
+    // the parsed text. If none exists, returns a location with start and end
+    // line -1. Index should be -1 for not-repeated fields.
+    ParseLocationRange GetLocationRange(const FieldDescriptor* field,
+                                        int index) const;
+
+    // Returns the starting parse location for index-th value of the field in
+    // the parsed text. If none exists, returns a location with line = -1. Index
+    // should be -1 for not-repeated fields.
+    ParseLocation GetLocation(const FieldDescriptor* field, int index) const {
+      return GetLocationRange(field, index).start;
+    }
+
+    // Returns the parse info tree for the given field, which must be a message
+    // type. The nested information tree is owned by the root tree and will be
+    // deleted when it is deleted.
+    ParseInfoTree* GetTreeForNested(const FieldDescriptor* field,
+                                    int index) const;
+
+   private:
+    // Allow the text format parser to record information into the tree.
+    friend class TextFormat;
+
+    // Records the starting and ending locations of a single value for a field.
+    void RecordLocation(const FieldDescriptor* field, ParseLocationRange range);
+
+    // Create and records a nested tree for a nested message field.
+    ParseInfoTree* CreateNested(const FieldDescriptor* field);
+
+    // Defines the map from the index-th field descriptor to its parse location.
+    typedef std::map<const FieldDescriptor*, std::vector<ParseLocationRange>>
+        LocationMap;
+
+    // Defines the map from the index-th field descriptor to the nested parse
+    // info tree.
+    typedef std::map<const FieldDescriptor*,
+                     std::vector<std::unique_ptr<ParseInfoTree>>>
+        NestedMap;
+
+    LocationMap locations_;
+    NestedMap nested_;
+  };
+
+  // For more control over parsing, use this class.
+  class PROTOBUF_EXPORT Parser {
+   public:
+    Parser();
+    ~Parser();
+
+    // Like TextFormat::Parse().
+    bool Parse(io::ZeroCopyInputStream* input, Message* output);
+    // Like TextFormat::ParseFromString().
+    bool ParseFromString(ConstStringParam input, Message* output);
+    // Like TextFormat::Merge().
+    bool Merge(io::ZeroCopyInputStream* input, Message* output);
+    // Like TextFormat::MergeFromString().
+    bool MergeFromString(ConstStringParam input, Message* output);
+
+    // Set where to report parse errors.  If nullptr (the default), errors will
+    // be printed to stderr.
+    void RecordErrorsTo(io::ErrorCollector* error_collector) {
+      error_collector_ = error_collector;
+    }
+
+    // Set how parser finds extensions.  If nullptr (the default), the
+    // parser will use the standard Reflection object associated with
+    // the message being parsed.
+    void SetFinder(const Finder* finder) { finder_ = finder; }
+
+    // Sets where location information about the parse will be written. If
+    // nullptr
+    // (the default), then no location will be written.
+    void WriteLocationsTo(ParseInfoTree* tree) { parse_info_tree_ = tree; }
+
+    // Normally parsing fails if, after parsing, output->IsInitialized()
+    // returns false.  Call AllowPartialMessage(true) to skip this check.
+    void AllowPartialMessage(bool allow) { allow_partial_ = allow; }
+
+    // Allow field names to be matched case-insensitively.
+    // This is not advisable if there are fields that only differ in case, or
+    // if you want to enforce writing in the canonical form.
+    // This is 'false' by default.
+    void AllowCaseInsensitiveField(bool allow) {
+      allow_case_insensitive_field_ = allow;
+    }
+
+    // Like TextFormat::ParseFieldValueFromString
+    bool ParseFieldValueFromString(const std::string& input,
+                                   const FieldDescriptor* field,
+                                   Message* output);
+
+    // When an unknown extension is met, parsing will fail if this option is
+    // set to false (the default). If true, unknown extensions will be ignored
+    // and a warning message will be generated.
+    // Beware! Setting this option true may hide some errors (e.g. spelling
+    // error on extension name).  This allows data loss; unlike binary format,
+    // text format cannot preserve unknown extensions.  Avoid using this option
+    // if possible.
+    void AllowUnknownExtension(bool allow) { allow_unknown_extension_ = allow; }
+
+    // When an unknown field is met, parsing will fail if this option is set
+    // to false (the default). If true, unknown fields will be ignored and
+    // a warning message will be generated.
+    // Beware! Setting this option true may hide some errors (e.g. spelling
+    // error on field name). This allows data loss; unlike binary format, text
+    // format cannot preserve unknown fields.  Avoid using this option
+    // if possible.
+    void AllowUnknownField(bool allow) { allow_unknown_field_ = allow; }
+
+
+    void AllowFieldNumber(bool allow) { allow_field_number_ = allow; }
+
+    // Sets maximum recursion depth which parser can use. This is effectively
+    // the maximum allowed nesting of proto messages.
+    void SetRecursionLimit(int limit) { recursion_limit_ = limit; }
+
+   private:
+    // Forward declaration of an internal class used to parse text
+    // representations (see text_format.cc for implementation).
+    class ParserImpl;
+
+    // Like TextFormat::Merge().  The provided implementation is used
+    // to do the parsing.
+    bool MergeUsingImpl(io::ZeroCopyInputStream* input, Message* output,
+                        ParserImpl* parser_impl);
+
+    io::ErrorCollector* error_collector_;
+    const Finder* finder_;
+    ParseInfoTree* parse_info_tree_;
+    bool allow_partial_;
+    bool allow_case_insensitive_field_;
+    bool allow_unknown_field_;
+    bool allow_unknown_extension_;
+    bool allow_unknown_enum_;
+    bool allow_field_number_;
+    bool allow_relaxed_whitespace_;
+    bool allow_singular_overwrites_;
+    int recursion_limit_;
+  };
+
+
+ private:
+  // Hack: ParseInfoTree declares TextFormat as a friend which should extend
+  // the friendship to TextFormat::Parser::ParserImpl, but unfortunately some
+  // old compilers (e.g. GCC 3.4.6) don't implement this correctly. We provide
+  // helpers for ParserImpl to call methods of ParseInfoTree.
+  static inline void RecordLocation(ParseInfoTree* info_tree,
+                                    const FieldDescriptor* field,
+                                    ParseLocationRange location);
+  static inline ParseInfoTree* CreateNested(ParseInfoTree* info_tree,
+                                            const FieldDescriptor* field);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TextFormat);
+};
+
+inline void TextFormat::RecordLocation(ParseInfoTree* info_tree,
+                                       const FieldDescriptor* field,
+                                       ParseLocationRange location) {
+  info_tree->RecordLocation(field, location);
+}
+
+inline TextFormat::ParseInfoTree* TextFormat::CreateNested(
+    ParseInfoTree* info_tree, const FieldDescriptor* field) {
+  return info_tree->CreateNested(field);
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_TEXT_FORMAT_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/timestamp.pb.h b/CAPI/cpp/grpc/include/google/protobuf/timestamp.pb.h
new file mode 100644
index 0000000..6633822
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/timestamp.pb.h
@@ -0,0 +1,278 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/timestamp.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ftimestamp_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ftimestamp_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2ftimestamp_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ftimestamp_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ftimestamp_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class Timestamp;
+struct TimestampDefaultTypeInternal;
+PROTOBUF_EXPORT extern TimestampDefaultTypeInternal _Timestamp_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Timestamp* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+// ===================================================================
+
+class PROTOBUF_EXPORT Timestamp final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Timestamp) */ {
+ public:
+  inline Timestamp() : Timestamp(nullptr) {}
+  ~Timestamp() override;
+  explicit PROTOBUF_CONSTEXPR Timestamp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Timestamp(const Timestamp& from);
+  Timestamp(Timestamp&& from) noexcept
+    : Timestamp() {
+    *this = ::std::move(from);
+  }
+
+  inline Timestamp& operator=(const Timestamp& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Timestamp& operator=(Timestamp&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Timestamp& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Timestamp* internal_default_instance() {
+    return reinterpret_cast<const Timestamp*>(
+               &_Timestamp_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Timestamp& a, Timestamp& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Timestamp* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Timestamp* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Timestamp>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Timestamp& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Timestamp& from) {
+    Timestamp::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Timestamp* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Timestamp";
+  }
+  protected:
+  explicit Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSecondsFieldNumber = 1,
+    kNanosFieldNumber = 2,
+  };
+  // int64 seconds = 1;
+  void clear_seconds();
+  int64_t seconds() const;
+  void set_seconds(int64_t value);
+  private:
+  int64_t _internal_seconds() const;
+  void _internal_set_seconds(int64_t value);
+  public:
+
+  // int32 nanos = 2;
+  void clear_nanos();
+  int32_t nanos() const;
+  void set_nanos(int32_t value);
+  private:
+  int32_t _internal_nanos() const;
+  void _internal_set_nanos(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Timestamp)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t seconds_;
+    int32_t nanos_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2ftimestamp_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Timestamp
+
+// int64 seconds = 1;
+inline void Timestamp::clear_seconds() {
+  _impl_.seconds_ = int64_t{0};
+}
+inline int64_t Timestamp::_internal_seconds() const {
+  return _impl_.seconds_;
+}
+inline int64_t Timestamp::seconds() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.seconds)
+  return _internal_seconds();
+}
+inline void Timestamp::_internal_set_seconds(int64_t value) {
+  
+  _impl_.seconds_ = value;
+}
+inline void Timestamp::set_seconds(int64_t value) {
+  _internal_set_seconds(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.seconds)
+}
+
+// int32 nanos = 2;
+inline void Timestamp::clear_nanos() {
+  _impl_.nanos_ = 0;
+}
+inline int32_t Timestamp::_internal_nanos() const {
+  return _impl_.nanos_;
+}
+inline int32_t Timestamp::nanos() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.nanos)
+  return _internal_nanos();
+}
+inline void Timestamp::_internal_set_nanos(int32_t value) {
+  
+  _impl_.nanos_ = value;
+}
+inline void Timestamp::set_nanos(int32_t value) {
+  _internal_set_nanos(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.nanos)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ftimestamp_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/timestamp.proto b/CAPI/cpp/grpc/include/google/protobuf/timestamp.proto
new file mode 100644
index 0000000..3b2df6d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/timestamp.proto
@@ -0,0 +1,147 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/protobuf/types/known/timestamppb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TimestampProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// A Timestamp represents a point in time independent of any time zone or local
+// calendar, encoded as a count of seconds and fractions of seconds at
+// nanosecond resolution. The count is relative to an epoch at UTC midnight on
+// January 1, 1970, in the proleptic Gregorian calendar which extends the
+// Gregorian calendar backwards to year one.
+//
+// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+// second table is needed for interpretation, using a [24-hour linear
+// smear](https://developers.google.com/time/smear).
+//
+// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+// restricting to that range, we ensure that we can convert to and from [RFC
+// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+//
+// # Examples
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from Java `Instant.now()`.
+//
+//     Instant now = Instant.now();
+//
+//     Timestamp timestamp =
+//         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+//             .setNanos(now.getNano()).build();
+//
+//
+// Example 6: Compute Timestamp from current time in Python.
+//
+//     timestamp = Timestamp()
+//     timestamp.GetCurrentTime()
+//
+// # JSON Mapping
+//
+// In JSON format, the Timestamp type is encoded as a string in the
+// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+// where {year} is always expressed using four digits while {month}, {day},
+// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+// is required. A proto3 JSON serializer should always use UTC (as indicated by
+// "Z") when printing the Timestamp type and a proto3 JSON parser should be
+// able to accept both UTC and other timezones (as indicated by an offset).
+//
+// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+// 01:30 UTC on January 15, 2017.
+//
+// In JavaScript, one can convert a Date object to this format using the
+// standard
+// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+// method. In Python, a standard `datetime.datetime` object can be converted
+// to this format using
+// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+// the Joda Time's [`ISODateTimeFormat.dateTime()`](
+// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+// ) to obtain a formatter capable of generating timestamps in this format.
+//
+//
+message Timestamp {
+  // Represents seconds of UTC time since Unix epoch
+  // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+  // 9999-12-31T23:59:59Z inclusive.
+  int64 seconds = 1;
+
+  // Non-negative fractions of a second at nanosecond resolution. Negative
+  // second values with fractions must still have non-negative nanos values
+  // that count forward in time. Must be from 0 to 999,999,999
+  // inclusive.
+  int32 nanos = 2;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/type.pb.h b/CAPI/cpp/grpc/include/google/protobuf/type.pb.h
new file mode 100644
index 0000000..0f11e6c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/type.pb.h
@@ -0,0 +1,2571 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/type.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ftype_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ftype_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/any.pb.h>
+#include <google/protobuf/source_context.pb.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2ftype_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ftype_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ftype_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class Enum;
+struct EnumDefaultTypeInternal;
+PROTOBUF_EXPORT extern EnumDefaultTypeInternal _Enum_default_instance_;
+class EnumValue;
+struct EnumValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern EnumValueDefaultTypeInternal _EnumValue_default_instance_;
+class Field;
+struct FieldDefaultTypeInternal;
+PROTOBUF_EXPORT extern FieldDefaultTypeInternal _Field_default_instance_;
+class Option;
+struct OptionDefaultTypeInternal;
+PROTOBUF_EXPORT extern OptionDefaultTypeInternal _Option_default_instance_;
+class Type;
+struct TypeDefaultTypeInternal;
+PROTOBUF_EXPORT extern TypeDefaultTypeInternal _Type_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Enum* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Enum>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValue>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Field* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Field>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Option* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Option>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Type* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Type>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+enum Field_Kind : int {
+  Field_Kind_TYPE_UNKNOWN = 0,
+  Field_Kind_TYPE_DOUBLE = 1,
+  Field_Kind_TYPE_FLOAT = 2,
+  Field_Kind_TYPE_INT64 = 3,
+  Field_Kind_TYPE_UINT64 = 4,
+  Field_Kind_TYPE_INT32 = 5,
+  Field_Kind_TYPE_FIXED64 = 6,
+  Field_Kind_TYPE_FIXED32 = 7,
+  Field_Kind_TYPE_BOOL = 8,
+  Field_Kind_TYPE_STRING = 9,
+  Field_Kind_TYPE_GROUP = 10,
+  Field_Kind_TYPE_MESSAGE = 11,
+  Field_Kind_TYPE_BYTES = 12,
+  Field_Kind_TYPE_UINT32 = 13,
+  Field_Kind_TYPE_ENUM = 14,
+  Field_Kind_TYPE_SFIXED32 = 15,
+  Field_Kind_TYPE_SFIXED64 = 16,
+  Field_Kind_TYPE_SINT32 = 17,
+  Field_Kind_TYPE_SINT64 = 18,
+  Field_Kind_Field_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  Field_Kind_Field_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+PROTOBUF_EXPORT bool Field_Kind_IsValid(int value);
+constexpr Field_Kind Field_Kind_Kind_MIN = Field_Kind_TYPE_UNKNOWN;
+constexpr Field_Kind Field_Kind_Kind_MAX = Field_Kind_TYPE_SINT64;
+constexpr int Field_Kind_Kind_ARRAYSIZE = Field_Kind_Kind_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Field_Kind_descriptor();
+template<typename T>
+inline const std::string& Field_Kind_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Field_Kind>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Field_Kind_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Field_Kind_descriptor(), enum_t_value);
+}
+inline bool Field_Kind_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Field_Kind* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Field_Kind>(
+    Field_Kind_descriptor(), name, value);
+}
+enum Field_Cardinality : int {
+  Field_Cardinality_CARDINALITY_UNKNOWN = 0,
+  Field_Cardinality_CARDINALITY_OPTIONAL = 1,
+  Field_Cardinality_CARDINALITY_REQUIRED = 2,
+  Field_Cardinality_CARDINALITY_REPEATED = 3,
+  Field_Cardinality_Field_Cardinality_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  Field_Cardinality_Field_Cardinality_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+PROTOBUF_EXPORT bool Field_Cardinality_IsValid(int value);
+constexpr Field_Cardinality Field_Cardinality_Cardinality_MIN = Field_Cardinality_CARDINALITY_UNKNOWN;
+constexpr Field_Cardinality Field_Cardinality_Cardinality_MAX = Field_Cardinality_CARDINALITY_REPEATED;
+constexpr int Field_Cardinality_Cardinality_ARRAYSIZE = Field_Cardinality_Cardinality_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Field_Cardinality_descriptor();
+template<typename T>
+inline const std::string& Field_Cardinality_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Field_Cardinality>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Field_Cardinality_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Field_Cardinality_descriptor(), enum_t_value);
+}
+inline bool Field_Cardinality_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Field_Cardinality* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Field_Cardinality>(
+    Field_Cardinality_descriptor(), name, value);
+}
+enum Syntax : int {
+  SYNTAX_PROTO2 = 0,
+  SYNTAX_PROTO3 = 1,
+  Syntax_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  Syntax_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+PROTOBUF_EXPORT bool Syntax_IsValid(int value);
+constexpr Syntax Syntax_MIN = SYNTAX_PROTO2;
+constexpr Syntax Syntax_MAX = SYNTAX_PROTO3;
+constexpr int Syntax_ARRAYSIZE = Syntax_MAX + 1;
+
+PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Syntax_descriptor();
+template<typename T>
+inline const std::string& Syntax_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Syntax>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Syntax_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Syntax_descriptor(), enum_t_value);
+}
+inline bool Syntax_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Syntax* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Syntax>(
+    Syntax_descriptor(), name, value);
+}
+// ===================================================================
+
+class PROTOBUF_EXPORT Type final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Type) */ {
+ public:
+  inline Type() : Type(nullptr) {}
+  ~Type() override;
+  explicit PROTOBUF_CONSTEXPR Type(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type(const Type& from);
+  Type(Type&& from) noexcept
+    : Type() {
+    *this = ::std::move(from);
+  }
+
+  inline Type& operator=(const Type& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type& operator=(Type&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type* internal_default_instance() {
+    return reinterpret_cast<const Type*>(
+               &_Type_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Type& a, Type& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Type& from) {
+    Type::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Type";
+  }
+  protected:
+  explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFieldsFieldNumber = 2,
+    kOneofsFieldNumber = 3,
+    kOptionsFieldNumber = 4,
+    kNameFieldNumber = 1,
+    kSourceContextFieldNumber = 5,
+    kSyntaxFieldNumber = 6,
+  };
+  // repeated .google.protobuf.Field fields = 2;
+  int fields_size() const;
+  private:
+  int _internal_fields_size() const;
+  public:
+  void clear_fields();
+  ::PROTOBUF_NAMESPACE_ID::Field* mutable_fields(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field >*
+      mutable_fields();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Field& _internal_fields(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Field* _internal_add_fields();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Field& fields(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Field* add_fields();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field >&
+      fields() const;
+
+  // repeated string oneofs = 3;
+  int oneofs_size() const;
+  private:
+  int _internal_oneofs_size() const;
+  public:
+  void clear_oneofs();
+  const std::string& oneofs(int index) const;
+  std::string* mutable_oneofs(int index);
+  void set_oneofs(int index, const std::string& value);
+  void set_oneofs(int index, std::string&& value);
+  void set_oneofs(int index, const char* value);
+  void set_oneofs(int index, const char* value, size_t size);
+  std::string* add_oneofs();
+  void add_oneofs(const std::string& value);
+  void add_oneofs(std::string&& value);
+  void add_oneofs(const char* value);
+  void add_oneofs(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& oneofs() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_oneofs();
+  private:
+  const std::string& _internal_oneofs(int index) const;
+  std::string* _internal_add_oneofs();
+  public:
+
+  // repeated .google.protobuf.Option options = 4;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+      mutable_options();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .google.protobuf.SourceContext source_context = 5;
+  bool has_source_context() const;
+  private:
+  bool _internal_has_source_context() const;
+  public:
+  void clear_source_context();
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
+  void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
+  public:
+  void unsafe_arena_set_allocated_source_context(
+      ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
+
+  // .google.protobuf.Syntax syntax = 6;
+  void clear_syntax();
+  ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
+  void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
+  void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Type)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field > fields_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> oneofs_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
+    int syntax_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Field final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Field) */ {
+ public:
+  inline Field() : Field(nullptr) {}
+  ~Field() override;
+  explicit PROTOBUF_CONSTEXPR Field(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Field(const Field& from);
+  Field(Field&& from) noexcept
+    : Field() {
+    *this = ::std::move(from);
+  }
+
+  inline Field& operator=(const Field& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Field& operator=(Field&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Field& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Field* internal_default_instance() {
+    return reinterpret_cast<const Field*>(
+               &_Field_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(Field& a, Field& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Field* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Field* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Field* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Field>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Field& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Field& from) {
+    Field::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Field* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Field";
+  }
+  protected:
+  explicit Field(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Field_Kind Kind;
+  static constexpr Kind TYPE_UNKNOWN =
+    Field_Kind_TYPE_UNKNOWN;
+  static constexpr Kind TYPE_DOUBLE =
+    Field_Kind_TYPE_DOUBLE;
+  static constexpr Kind TYPE_FLOAT =
+    Field_Kind_TYPE_FLOAT;
+  static constexpr Kind TYPE_INT64 =
+    Field_Kind_TYPE_INT64;
+  static constexpr Kind TYPE_UINT64 =
+    Field_Kind_TYPE_UINT64;
+  static constexpr Kind TYPE_INT32 =
+    Field_Kind_TYPE_INT32;
+  static constexpr Kind TYPE_FIXED64 =
+    Field_Kind_TYPE_FIXED64;
+  static constexpr Kind TYPE_FIXED32 =
+    Field_Kind_TYPE_FIXED32;
+  static constexpr Kind TYPE_BOOL =
+    Field_Kind_TYPE_BOOL;
+  static constexpr Kind TYPE_STRING =
+    Field_Kind_TYPE_STRING;
+  static constexpr Kind TYPE_GROUP =
+    Field_Kind_TYPE_GROUP;
+  static constexpr Kind TYPE_MESSAGE =
+    Field_Kind_TYPE_MESSAGE;
+  static constexpr Kind TYPE_BYTES =
+    Field_Kind_TYPE_BYTES;
+  static constexpr Kind TYPE_UINT32 =
+    Field_Kind_TYPE_UINT32;
+  static constexpr Kind TYPE_ENUM =
+    Field_Kind_TYPE_ENUM;
+  static constexpr Kind TYPE_SFIXED32 =
+    Field_Kind_TYPE_SFIXED32;
+  static constexpr Kind TYPE_SFIXED64 =
+    Field_Kind_TYPE_SFIXED64;
+  static constexpr Kind TYPE_SINT32 =
+    Field_Kind_TYPE_SINT32;
+  static constexpr Kind TYPE_SINT64 =
+    Field_Kind_TYPE_SINT64;
+  static inline bool Kind_IsValid(int value) {
+    return Field_Kind_IsValid(value);
+  }
+  static constexpr Kind Kind_MIN =
+    Field_Kind_Kind_MIN;
+  static constexpr Kind Kind_MAX =
+    Field_Kind_Kind_MAX;
+  static constexpr int Kind_ARRAYSIZE =
+    Field_Kind_Kind_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Kind_descriptor() {
+    return Field_Kind_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Kind_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Kind>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Kind_Name.");
+    return Field_Kind_Name(enum_t_value);
+  }
+  static inline bool Kind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Kind* value) {
+    return Field_Kind_Parse(name, value);
+  }
+
+  typedef Field_Cardinality Cardinality;
+  static constexpr Cardinality CARDINALITY_UNKNOWN =
+    Field_Cardinality_CARDINALITY_UNKNOWN;
+  static constexpr Cardinality CARDINALITY_OPTIONAL =
+    Field_Cardinality_CARDINALITY_OPTIONAL;
+  static constexpr Cardinality CARDINALITY_REQUIRED =
+    Field_Cardinality_CARDINALITY_REQUIRED;
+  static constexpr Cardinality CARDINALITY_REPEATED =
+    Field_Cardinality_CARDINALITY_REPEATED;
+  static inline bool Cardinality_IsValid(int value) {
+    return Field_Cardinality_IsValid(value);
+  }
+  static constexpr Cardinality Cardinality_MIN =
+    Field_Cardinality_Cardinality_MIN;
+  static constexpr Cardinality Cardinality_MAX =
+    Field_Cardinality_Cardinality_MAX;
+  static constexpr int Cardinality_ARRAYSIZE =
+    Field_Cardinality_Cardinality_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Cardinality_descriptor() {
+    return Field_Cardinality_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Cardinality_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Cardinality>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Cardinality_Name.");
+    return Field_Cardinality_Name(enum_t_value);
+  }
+  static inline bool Cardinality_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Cardinality* value) {
+    return Field_Cardinality_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptionsFieldNumber = 9,
+    kNameFieldNumber = 4,
+    kTypeUrlFieldNumber = 6,
+    kJsonNameFieldNumber = 10,
+    kDefaultValueFieldNumber = 11,
+    kKindFieldNumber = 1,
+    kCardinalityFieldNumber = 2,
+    kNumberFieldNumber = 3,
+    kOneofIndexFieldNumber = 7,
+    kPackedFieldNumber = 8,
+  };
+  // repeated .google.protobuf.Option options = 9;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+      mutable_options();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+      options() const;
+
+  // string name = 4;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // string type_url = 6;
+  void clear_type_url();
+  const std::string& type_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_url();
+  PROTOBUF_NODISCARD std::string* release_type_url();
+  void set_allocated_type_url(std::string* type_url);
+  private:
+  const std::string& _internal_type_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_url(const std::string& value);
+  std::string* _internal_mutable_type_url();
+  public:
+
+  // string json_name = 10;
+  void clear_json_name();
+  const std::string& json_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_json_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_json_name();
+  PROTOBUF_NODISCARD std::string* release_json_name();
+  void set_allocated_json_name(std::string* json_name);
+  private:
+  const std::string& _internal_json_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_name(const std::string& value);
+  std::string* _internal_mutable_json_name();
+  public:
+
+  // string default_value = 11;
+  void clear_default_value();
+  const std::string& default_value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_default_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_default_value();
+  PROTOBUF_NODISCARD std::string* release_default_value();
+  void set_allocated_default_value(std::string* default_value);
+  private:
+  const std::string& _internal_default_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_value(const std::string& value);
+  std::string* _internal_mutable_default_value();
+  public:
+
+  // .google.protobuf.Field.Kind kind = 1;
+  void clear_kind();
+  ::PROTOBUF_NAMESPACE_ID::Field_Kind kind() const;
+  void set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::Field_Kind _internal_kind() const;
+  void _internal_set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value);
+  public:
+
+  // .google.protobuf.Field.Cardinality cardinality = 2;
+  void clear_cardinality();
+  ::PROTOBUF_NAMESPACE_ID::Field_Cardinality cardinality() const;
+  void set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::Field_Cardinality _internal_cardinality() const;
+  void _internal_set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value);
+  public:
+
+  // int32 number = 3;
+  void clear_number();
+  int32_t number() const;
+  void set_number(int32_t value);
+  private:
+  int32_t _internal_number() const;
+  void _internal_set_number(int32_t value);
+  public:
+
+  // int32 oneof_index = 7;
+  void clear_oneof_index();
+  int32_t oneof_index() const;
+  void set_oneof_index(int32_t value);
+  private:
+  int32_t _internal_oneof_index() const;
+  void _internal_set_oneof_index(int32_t value);
+  public:
+
+  // bool packed = 8;
+  void clear_packed();
+  bool packed() const;
+  void set_packed(bool value);
+  private:
+  bool _internal_packed() const;
+  void _internal_set_packed(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Field)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_;
+    int kind_;
+    int cardinality_;
+    int32_t number_;
+    int32_t oneof_index_;
+    bool packed_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Enum final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Enum) */ {
+ public:
+  inline Enum() : Enum(nullptr) {}
+  ~Enum() override;
+  explicit PROTOBUF_CONSTEXPR Enum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Enum(const Enum& from);
+  Enum(Enum&& from) noexcept
+    : Enum() {
+    *this = ::std::move(from);
+  }
+
+  inline Enum& operator=(const Enum& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Enum& operator=(Enum&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Enum& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Enum* internal_default_instance() {
+    return reinterpret_cast<const Enum*>(
+               &_Enum_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(Enum& a, Enum& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Enum* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Enum* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Enum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Enum>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Enum& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Enum& from) {
+    Enum::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Enum* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Enum";
+  }
+  protected:
+  explicit Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEnumvalueFieldNumber = 2,
+    kOptionsFieldNumber = 3,
+    kNameFieldNumber = 1,
+    kSourceContextFieldNumber = 4,
+    kSyntaxFieldNumber = 5,
+  };
+  // repeated .google.protobuf.EnumValue enumvalue = 2;
+  int enumvalue_size() const;
+  private:
+  int _internal_enumvalue_size() const;
+  public:
+  void clear_enumvalue();
+  ::PROTOBUF_NAMESPACE_ID::EnumValue* mutable_enumvalue(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue >*
+      mutable_enumvalue();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::EnumValue& _internal_enumvalue(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumValue* _internal_add_enumvalue();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::EnumValue& enumvalue(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::EnumValue* add_enumvalue();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue >&
+      enumvalue() const;
+
+  // repeated .google.protobuf.Option options = 3;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+      mutable_options();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .google.protobuf.SourceContext source_context = 4;
+  bool has_source_context() const;
+  private:
+  bool _internal_has_source_context() const;
+  public:
+  void clear_source_context();
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
+  void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
+  public:
+  void unsafe_arena_set_allocated_source_context(
+      ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
+
+  // .google.protobuf.Syntax syntax = 5;
+  void clear_syntax();
+  ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
+  void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
+  void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Enum)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue > enumvalue_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
+    int syntax_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValue) */ {
+ public:
+  inline EnumValue() : EnumValue(nullptr) {}
+  ~EnumValue() override;
+  explicit PROTOBUF_CONSTEXPR EnumValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EnumValue(const EnumValue& from);
+  EnumValue(EnumValue&& from) noexcept
+    : EnumValue() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumValue& operator=(const EnumValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EnumValue& operator=(EnumValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EnumValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EnumValue* internal_default_instance() {
+    return reinterpret_cast<const EnumValue*>(
+               &_EnumValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(EnumValue& a, EnumValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EnumValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EnumValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  EnumValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<EnumValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EnumValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const EnumValue& from) {
+    EnumValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EnumValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.EnumValue";
+  }
+  protected:
+  explicit EnumValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptionsFieldNumber = 3,
+    kNameFieldNumber = 1,
+    kNumberFieldNumber = 2,
+  };
+  // repeated .google.protobuf.Option options = 3;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+      mutable_options();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // int32 number = 2;
+  void clear_number();
+  int32_t number() const;
+  void set_number(int32_t value);
+  private:
+  int32_t _internal_number() const;
+  void _internal_set_number(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    int32_t number_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Option final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Option) */ {
+ public:
+  inline Option() : Option(nullptr) {}
+  ~Option() override;
+  explicit PROTOBUF_CONSTEXPR Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Option(const Option& from);
+  Option(Option&& from) noexcept
+    : Option() {
+    *this = ::std::move(from);
+  }
+
+  inline Option& operator=(const Option& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Option& operator=(Option&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Option& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Option* internal_default_instance() {
+    return reinterpret_cast<const Option*>(
+               &_Option_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(Option& a, Option& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Option* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Option* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Option>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Option& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Option& from) {
+    Option::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Option* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Option";
+  }
+  protected:
+  explicit Option(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .google.protobuf.Any value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::PROTOBUF_NAMESPACE_ID::Any& value() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_value();
+  ::PROTOBUF_NAMESPACE_ID::Any* mutable_value();
+  void set_allocated_value(::PROTOBUF_NAMESPACE_ID::Any* value);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_value() const;
+  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::PROTOBUF_NAMESPACE_ID::Any* value);
+  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_value();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Option)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+    ::PROTOBUF_NAMESPACE_ID::Any* value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Type
+
+// string name = 1;
+inline void Type::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Type::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Type::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Type.name)
+}
+inline std::string* Type::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.name)
+  return _s;
+}
+inline const std::string& Type::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Type::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Type::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Type::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Type.name)
+  return _impl_.name_.Release();
+}
+inline void Type::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Type.name)
+}
+
+// repeated .google.protobuf.Field fields = 2;
+inline int Type::_internal_fields_size() const {
+  return _impl_.fields_.size();
+}
+inline int Type::fields_size() const {
+  return _internal_fields_size();
+}
+inline void Type::clear_fields() {
+  _impl_.fields_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field* Type::mutable_fields(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.fields)
+  return _impl_.fields_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field >*
+Type::mutable_fields() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.fields)
+  return &_impl_.fields_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Field& Type::_internal_fields(int index) const {
+  return _impl_.fields_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Field& Type::fields(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.fields)
+  return _internal_fields(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field* Type::_internal_add_fields() {
+  return _impl_.fields_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field* Type::add_fields() {
+  ::PROTOBUF_NAMESPACE_ID::Field* _add = _internal_add_fields();
+  // @@protoc_insertion_point(field_add:google.protobuf.Type.fields)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field >&
+Type::fields() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Type.fields)
+  return _impl_.fields_;
+}
+
+// repeated string oneofs = 3;
+inline int Type::_internal_oneofs_size() const {
+  return _impl_.oneofs_.size();
+}
+inline int Type::oneofs_size() const {
+  return _internal_oneofs_size();
+}
+inline void Type::clear_oneofs() {
+  _impl_.oneofs_.Clear();
+}
+inline std::string* Type::add_oneofs() {
+  std::string* _s = _internal_add_oneofs();
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.Type.oneofs)
+  return _s;
+}
+inline const std::string& Type::_internal_oneofs(int index) const {
+  return _impl_.oneofs_.Get(index);
+}
+inline const std::string& Type::oneofs(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.oneofs)
+  return _internal_oneofs(index);
+}
+inline std::string* Type::mutable_oneofs(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.oneofs)
+  return _impl_.oneofs_.Mutable(index);
+}
+inline void Type::set_oneofs(int index, const std::string& value) {
+  _impl_.oneofs_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Type.oneofs)
+}
+inline void Type::set_oneofs(int index, std::string&& value) {
+  _impl_.oneofs_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:google.protobuf.Type.oneofs)
+}
+inline void Type::set_oneofs(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.oneofs_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Type.oneofs)
+}
+inline void Type::set_oneofs(int index, const char* value, size_t size) {
+  _impl_.oneofs_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Type.oneofs)
+}
+inline std::string* Type::_internal_add_oneofs() {
+  return _impl_.oneofs_.Add();
+}
+inline void Type::add_oneofs(const std::string& value) {
+  _impl_.oneofs_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.Type.oneofs)
+}
+inline void Type::add_oneofs(std::string&& value) {
+  _impl_.oneofs_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.Type.oneofs)
+}
+inline void Type::add_oneofs(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  _impl_.oneofs_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.Type.oneofs)
+}
+inline void Type::add_oneofs(const char* value, size_t size) {
+  _impl_.oneofs_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.Type.oneofs)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Type::oneofs() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Type.oneofs)
+  return _impl_.oneofs_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Type::mutable_oneofs() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.oneofs)
+  return &_impl_.oneofs_;
+}
+
+// repeated .google.protobuf.Option options = 4;
+inline int Type::_internal_options_size() const {
+  return _impl_.options_.size();
+}
+inline int Type::options_size() const {
+  return _internal_options_size();
+}
+inline void Type::clear_options() {
+  _impl_.options_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Type::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.options)
+  return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+Type::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.options)
+  return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Type::_internal_options(int index) const {
+  return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Type::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.options)
+  return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Type::_internal_add_options() {
+  return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Type::add_options() {
+  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:google.protobuf.Type.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+Type::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Type.options)
+  return _impl_.options_;
+}
+
+// .google.protobuf.SourceContext source_context = 5;
+inline bool Type::_internal_has_source_context() const {
+  return this != internal_default_instance() && _impl_.source_context_ != nullptr;
+}
+inline bool Type::has_source_context() const {
+  return _internal_has_source_context();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Type::_internal_source_context() const {
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(
+      ::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Type::source_context() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.source_context)
+  return _internal_source_context();
+}
+inline void Type::unsafe_arena_set_allocated_source_context(
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+  }
+  _impl_.source_context_ = source_context;
+  if (source_context) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Type.source_context)
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::release_source_context() {
+  
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+  _impl_.source_context_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::unsafe_arena_release_source_context() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Type.source_context)
+  
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+  _impl_.source_context_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::_internal_mutable_source_context() {
+  
+  if (_impl_.source_context_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
+    _impl_.source_context_ = p;
+  }
+  return _impl_.source_context_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::mutable_source_context() {
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.source_context)
+  return _msg;
+}
+inline void Type::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+  }
+  if (source_context) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context));
+    if (message_arena != submessage_arena) {
+      source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, source_context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.source_context_ = source_context;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Type.source_context)
+}
+
+// .google.protobuf.Syntax syntax = 6;
+inline void Type::clear_syntax() {
+  _impl_.syntax_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Type::_internal_syntax() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Type::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.syntax)
+  return _internal_syntax();
+}
+inline void Type::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
+  
+  _impl_.syntax_ = value;
+}
+inline void Type::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
+  _internal_set_syntax(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Type.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// Field
+
+// .google.protobuf.Field.Kind kind = 1;
+inline void Field::clear_kind() {
+  _impl_.kind_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field_Kind Field::_internal_kind() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::Field_Kind >(_impl_.kind_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field_Kind Field::kind() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.kind)
+  return _internal_kind();
+}
+inline void Field::_internal_set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value) {
+  
+  _impl_.kind_ = value;
+}
+inline void Field::set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value) {
+  _internal_set_kind(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.kind)
+}
+
+// .google.protobuf.Field.Cardinality cardinality = 2;
+inline void Field::clear_cardinality() {
+  _impl_.cardinality_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field_Cardinality Field::_internal_cardinality() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::Field_Cardinality >(_impl_.cardinality_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field_Cardinality Field::cardinality() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.cardinality)
+  return _internal_cardinality();
+}
+inline void Field::_internal_set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value) {
+  
+  _impl_.cardinality_ = value;
+}
+inline void Field::set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value) {
+  _internal_set_cardinality(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.cardinality)
+}
+
+// int32 number = 3;
+inline void Field::clear_number() {
+  _impl_.number_ = 0;
+}
+inline int32_t Field::_internal_number() const {
+  return _impl_.number_;
+}
+inline int32_t Field::number() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.number)
+  return _internal_number();
+}
+inline void Field::_internal_set_number(int32_t value) {
+  
+  _impl_.number_ = value;
+}
+inline void Field::set_number(int32_t value) {
+  _internal_set_number(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.number)
+}
+
+// string name = 4;
+inline void Field::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Field::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Field::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.name)
+}
+inline std::string* Field::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.name)
+  return _s;
+}
+inline const std::string& Field::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Field::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Field::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Field::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Field.name)
+  return _impl_.name_.Release();
+}
+inline void Field::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.name)
+}
+
+// string type_url = 6;
+inline void Field::clear_type_url() {
+  _impl_.type_url_.ClearToEmpty();
+}
+inline const std::string& Field::type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.type_url)
+  return _internal_type_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Field::set_type_url(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.type_url)
+}
+inline std::string* Field::mutable_type_url() {
+  std::string* _s = _internal_mutable_type_url();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.type_url)
+  return _s;
+}
+inline const std::string& Field::_internal_type_url() const {
+  return _impl_.type_url_.Get();
+}
+inline void Field::_internal_set_type_url(const std::string& value) {
+  
+  _impl_.type_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Field::_internal_mutable_type_url() {
+  
+  return _impl_.type_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Field::release_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Field.type_url)
+  return _impl_.type_url_.Release();
+}
+inline void Field::set_allocated_type_url(std::string* type_url) {
+  if (type_url != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.type_url_.SetAllocated(type_url, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.type_url_.IsDefault()) {
+    _impl_.type_url_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.type_url)
+}
+
+// int32 oneof_index = 7;
+inline void Field::clear_oneof_index() {
+  _impl_.oneof_index_ = 0;
+}
+inline int32_t Field::_internal_oneof_index() const {
+  return _impl_.oneof_index_;
+}
+inline int32_t Field::oneof_index() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.oneof_index)
+  return _internal_oneof_index();
+}
+inline void Field::_internal_set_oneof_index(int32_t value) {
+  
+  _impl_.oneof_index_ = value;
+}
+inline void Field::set_oneof_index(int32_t value) {
+  _internal_set_oneof_index(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.oneof_index)
+}
+
+// bool packed = 8;
+inline void Field::clear_packed() {
+  _impl_.packed_ = false;
+}
+inline bool Field::_internal_packed() const {
+  return _impl_.packed_;
+}
+inline bool Field::packed() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.packed)
+  return _internal_packed();
+}
+inline void Field::_internal_set_packed(bool value) {
+  
+  _impl_.packed_ = value;
+}
+inline void Field::set_packed(bool value) {
+  _internal_set_packed(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.packed)
+}
+
+// repeated .google.protobuf.Option options = 9;
+inline int Field::_internal_options_size() const {
+  return _impl_.options_.size();
+}
+inline int Field::options_size() const {
+  return _internal_options_size();
+}
+inline void Field::clear_options() {
+  _impl_.options_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Field::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.options)
+  return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+Field::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Field.options)
+  return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Field::_internal_options(int index) const {
+  return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Field::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.options)
+  return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Field::_internal_add_options() {
+  return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Field::add_options() {
+  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:google.protobuf.Field.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+Field::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Field.options)
+  return _impl_.options_;
+}
+
+// string json_name = 10;
+inline void Field::clear_json_name() {
+  _impl_.json_name_.ClearToEmpty();
+}
+inline const std::string& Field::json_name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.json_name)
+  return _internal_json_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Field::set_json_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.json_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.json_name)
+}
+inline std::string* Field::mutable_json_name() {
+  std::string* _s = _internal_mutable_json_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.json_name)
+  return _s;
+}
+inline const std::string& Field::_internal_json_name() const {
+  return _impl_.json_name_.Get();
+}
+inline void Field::_internal_set_json_name(const std::string& value) {
+  
+  _impl_.json_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Field::_internal_mutable_json_name() {
+  
+  return _impl_.json_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Field::release_json_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Field.json_name)
+  return _impl_.json_name_.Release();
+}
+inline void Field::set_allocated_json_name(std::string* json_name) {
+  if (json_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.json_name_.SetAllocated(json_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.json_name_.IsDefault()) {
+    _impl_.json_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.json_name)
+}
+
+// string default_value = 11;
+inline void Field::clear_default_value() {
+  _impl_.default_value_.ClearToEmpty();
+}
+inline const std::string& Field::default_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.default_value)
+  return _internal_default_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Field::set_default_value(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.default_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.default_value)
+}
+inline std::string* Field::mutable_default_value() {
+  std::string* _s = _internal_mutable_default_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.default_value)
+  return _s;
+}
+inline const std::string& Field::_internal_default_value() const {
+  return _impl_.default_value_.Get();
+}
+inline void Field::_internal_set_default_value(const std::string& value) {
+  
+  _impl_.default_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Field::_internal_mutable_default_value() {
+  
+  return _impl_.default_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Field::release_default_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Field.default_value)
+  return _impl_.default_value_.Release();
+}
+inline void Field::set_allocated_default_value(std::string* default_value) {
+  if (default_value != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.default_value_.SetAllocated(default_value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.default_value_.IsDefault()) {
+    _impl_.default_value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.default_value)
+}
+
+// -------------------------------------------------------------------
+
+// Enum
+
+// string name = 1;
+inline void Enum::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Enum::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Enum::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Enum.name)
+}
+inline std::string* Enum::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.name)
+  return _s;
+}
+inline const std::string& Enum::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Enum::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Enum::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Enum::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Enum.name)
+  return _impl_.name_.Release();
+}
+inline void Enum::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Enum.name)
+}
+
+// repeated .google.protobuf.EnumValue enumvalue = 2;
+inline int Enum::_internal_enumvalue_size() const {
+  return _impl_.enumvalue_.size();
+}
+inline int Enum::enumvalue_size() const {
+  return _internal_enumvalue_size();
+}
+inline void Enum::clear_enumvalue() {
+  _impl_.enumvalue_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::mutable_enumvalue(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.enumvalue)
+  return _impl_.enumvalue_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue >*
+Enum::mutable_enumvalue() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Enum.enumvalue)
+  return &_impl_.enumvalue_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValue& Enum::_internal_enumvalue(int index) const {
+  return _impl_.enumvalue_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValue& Enum::enumvalue(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.enumvalue)
+  return _internal_enumvalue(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::_internal_add_enumvalue() {
+  return _impl_.enumvalue_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::add_enumvalue() {
+  ::PROTOBUF_NAMESPACE_ID::EnumValue* _add = _internal_add_enumvalue();
+  // @@protoc_insertion_point(field_add:google.protobuf.Enum.enumvalue)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue >&
+Enum::enumvalue() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Enum.enumvalue)
+  return _impl_.enumvalue_;
+}
+
+// repeated .google.protobuf.Option options = 3;
+inline int Enum::_internal_options_size() const {
+  return _impl_.options_.size();
+}
+inline int Enum::options_size() const {
+  return _internal_options_size();
+}
+inline void Enum::clear_options() {
+  _impl_.options_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.options)
+  return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+Enum::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Enum.options)
+  return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Enum::_internal_options(int index) const {
+  return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Enum::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.options)
+  return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::_internal_add_options() {
+  return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::add_options() {
+  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:google.protobuf.Enum.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+Enum::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Enum.options)
+  return _impl_.options_;
+}
+
+// .google.protobuf.SourceContext source_context = 4;
+inline bool Enum::_internal_has_source_context() const {
+  return this != internal_default_instance() && _impl_.source_context_ != nullptr;
+}
+inline bool Enum::has_source_context() const {
+  return _internal_has_source_context();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Enum::_internal_source_context() const {
+  const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(
+      ::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Enum::source_context() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.source_context)
+  return _internal_source_context();
+}
+inline void Enum::unsafe_arena_set_allocated_source_context(
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+  }
+  _impl_.source_context_ = source_context;
+  if (source_context) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Enum.source_context)
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::release_source_context() {
+  
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+  _impl_.source_context_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::unsafe_arena_release_source_context() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Enum.source_context)
+  
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+  _impl_.source_context_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::_internal_mutable_source_context() {
+  
+  if (_impl_.source_context_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
+    _impl_.source_context_ = p;
+  }
+  return _impl_.source_context_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::mutable_source_context() {
+  ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.source_context)
+  return _msg;
+}
+inline void Enum::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+  }
+  if (source_context) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context));
+    if (message_arena != submessage_arena) {
+      source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, source_context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.source_context_ = source_context;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Enum.source_context)
+}
+
+// .google.protobuf.Syntax syntax = 5;
+inline void Enum::clear_syntax() {
+  _impl_.syntax_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Enum::_internal_syntax() const {
+  return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Enum::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.syntax)
+  return _internal_syntax();
+}
+inline void Enum::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
+  
+  _impl_.syntax_ = value;
+}
+inline void Enum::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
+  _internal_set_syntax(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Enum.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// EnumValue
+
+// string name = 1;
+inline void EnumValue::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& EnumValue::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EnumValue::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.name)
+}
+inline std::string* EnumValue::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValue.name)
+  return _s;
+}
+inline const std::string& EnumValue::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void EnumValue::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* EnumValue::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* EnumValue::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumValue.name)
+  return _impl_.name_.Release();
+}
+inline void EnumValue::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValue.name)
+}
+
+// int32 number = 2;
+inline void EnumValue::clear_number() {
+  _impl_.number_ = 0;
+}
+inline int32_t EnumValue::_internal_number() const {
+  return _impl_.number_;
+}
+inline int32_t EnumValue::number() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.number)
+  return _internal_number();
+}
+inline void EnumValue::_internal_set_number(int32_t value) {
+  
+  _impl_.number_ = value;
+}
+inline void EnumValue::set_number(int32_t value) {
+  _internal_set_number(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.number)
+}
+
+// repeated .google.protobuf.Option options = 3;
+inline int EnumValue::_internal_options_size() const {
+  return _impl_.options_.size();
+}
+inline int EnumValue::options_size() const {
+  return _internal_options_size();
+}
+inline void EnumValue::clear_options() {
+  _impl_.options_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValue.options)
+  return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
+EnumValue::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValue.options)
+  return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& EnumValue::_internal_options(int index) const {
+  return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& EnumValue::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.options)
+  return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::_internal_add_options() {
+  return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::add_options() {
+  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumValue.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
+EnumValue::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumValue.options)
+  return _impl_.options_;
+}
+
+// -------------------------------------------------------------------
+
+// Option
+
+// string name = 1;
+inline void Option::clear_name() {
+  _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Option::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Option.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Option::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.Option.name)
+}
+inline std::string* Option::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Option.name)
+  return _s;
+}
+inline const std::string& Option::_internal_name() const {
+  return _impl_.name_.Get();
+}
+inline void Option::_internal_set_name(const std::string& value) {
+  
+  _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Option::_internal_mutable_name() {
+  
+  return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Option::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Option.name)
+  return _impl_.name_.Release();
+}
+inline void Option::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.name_.IsDefault()) {
+    _impl_.name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Option.name)
+}
+
+// .google.protobuf.Any value = 2;
+inline bool Option::_internal_has_value() const {
+  return this != internal_default_instance() && _impl_.value_ != nullptr;
+}
+inline bool Option::has_value() const {
+  return _internal_has_value();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& Option::_internal_value() const {
+  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
+      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& Option::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Option.value)
+  return _internal_value();
+}
+inline void Option::unsafe_arena_set_allocated_value(
+    ::PROTOBUF_NAMESPACE_ID::Any* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
+  }
+  _impl_.value_ = value;
+  if (value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Option.value)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* Option::release_value() {
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.value_;
+  _impl_.value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* Option::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Option.value)
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.value_;
+  _impl_.value_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* Option::_internal_mutable_value() {
+  
+  if (_impl_.value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
+    _impl_.value_ = p;
+  }
+  return _impl_.value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* Option::mutable_value() {
+  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Option.value)
+  return _msg;
+}
+inline void Option::set_allocated_value(::PROTOBUF_NAMESPACE_ID::Any* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value));
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Option.value)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::Field_Kind> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::Field_Kind>() {
+  return ::PROTOBUF_NAMESPACE_ID::Field_Kind_descriptor();
+}
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::Field_Cardinality> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::Field_Cardinality>() {
+  return ::PROTOBUF_NAMESPACE_ID::Field_Cardinality_descriptor();
+}
+template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::Syntax> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::Syntax>() {
+  return ::PROTOBUF_NAMESPACE_ID::Syntax_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2ftype_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/type.proto b/CAPI/cpp/grpc/include/google/protobuf/type.proto
new file mode 100644
index 0000000..d3f6a68
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/type.proto
@@ -0,0 +1,187 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/source_context.proto";
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TypeProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+option go_package = "google.golang.org/protobuf/types/known/typepb";
+
+// A protocol buffer message type.
+message Type {
+  // The fully qualified message name.
+  string name = 1;
+  // The list of fields.
+  repeated Field fields = 2;
+  // The list of types appearing in `oneof` definitions in this type.
+  repeated string oneofs = 3;
+  // The protocol buffer options.
+  repeated Option options = 4;
+  // The source context.
+  SourceContext source_context = 5;
+  // The source syntax.
+  Syntax syntax = 6;
+}
+
+// A single field of a message type.
+message Field {
+  // Basic field types.
+  enum Kind {
+    // Field type unknown.
+    TYPE_UNKNOWN = 0;
+    // Field type double.
+    TYPE_DOUBLE = 1;
+    // Field type float.
+    TYPE_FLOAT = 2;
+    // Field type int64.
+    TYPE_INT64 = 3;
+    // Field type uint64.
+    TYPE_UINT64 = 4;
+    // Field type int32.
+    TYPE_INT32 = 5;
+    // Field type fixed64.
+    TYPE_FIXED64 = 6;
+    // Field type fixed32.
+    TYPE_FIXED32 = 7;
+    // Field type bool.
+    TYPE_BOOL = 8;
+    // Field type string.
+    TYPE_STRING = 9;
+    // Field type group. Proto2 syntax only, and deprecated.
+    TYPE_GROUP = 10;
+    // Field type message.
+    TYPE_MESSAGE = 11;
+    // Field type bytes.
+    TYPE_BYTES = 12;
+    // Field type uint32.
+    TYPE_UINT32 = 13;
+    // Field type enum.
+    TYPE_ENUM = 14;
+    // Field type sfixed32.
+    TYPE_SFIXED32 = 15;
+    // Field type sfixed64.
+    TYPE_SFIXED64 = 16;
+    // Field type sint32.
+    TYPE_SINT32 = 17;
+    // Field type sint64.
+    TYPE_SINT64 = 18;
+  }
+
+  // Whether a field is optional, required, or repeated.
+  enum Cardinality {
+    // For fields with unknown cardinality.
+    CARDINALITY_UNKNOWN = 0;
+    // For optional fields.
+    CARDINALITY_OPTIONAL = 1;
+    // For required fields. Proto2 syntax only.
+    CARDINALITY_REQUIRED = 2;
+    // For repeated fields.
+    CARDINALITY_REPEATED = 3;
+  }
+
+  // The field type.
+  Kind kind = 1;
+  // The field cardinality.
+  Cardinality cardinality = 2;
+  // The field number.
+  int32 number = 3;
+  // The field name.
+  string name = 4;
+  // The field type URL, without the scheme, for message or enumeration
+  // types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
+  string type_url = 6;
+  // The index of the field type in `Type.oneofs`, for message or enumeration
+  // types. The first type has index 1; zero means the type is not in the list.
+  int32 oneof_index = 7;
+  // Whether to use alternative packed wire representation.
+  bool packed = 8;
+  // The protocol buffer options.
+  repeated Option options = 9;
+  // The field JSON name.
+  string json_name = 10;
+  // The string value of the default value of this field. Proto2 syntax only.
+  string default_value = 11;
+}
+
+// Enum type definition.
+message Enum {
+  // Enum type name.
+  string name = 1;
+  // Enum value definitions.
+  repeated EnumValue enumvalue = 2;
+  // Protocol buffer options.
+  repeated Option options = 3;
+  // The source context.
+  SourceContext source_context = 4;
+  // The source syntax.
+  Syntax syntax = 5;
+}
+
+// Enum value definition.
+message EnumValue {
+  // Enum value name.
+  string name = 1;
+  // Enum value number.
+  int32 number = 2;
+  // Protocol buffer options.
+  repeated Option options = 3;
+}
+
+// A protocol buffer option, which can be attached to a message, field,
+// enumeration, etc.
+message Option {
+  // The option's name. For protobuf built-in options (options defined in
+  // descriptor.proto), this is the short name. For example, `"map_entry"`.
+  // For custom options, it should be the fully-qualified name. For example,
+  // `"google.api.http"`.
+  string name = 1;
+  // The option's value packed in an Any message. If the value is a primitive,
+  // the corresponding wrapper type defined in google/protobuf/wrappers.proto
+  // should be used. If the value is an enum, it should be stored as an int32
+  // value using the google.protobuf.Int32Value type.
+  Any value = 2;
+}
+
+// The syntax in which a protocol buffer element is defined.
+enum Syntax {
+  // Syntax `proto2`.
+  SYNTAX_PROTO2 = 0;
+  // Syntax `proto3`.
+  SYNTAX_PROTO3 = 1;
+}
diff --git a/CAPI/cpp/grpc/include/google/protobuf/unknown_field_set.h b/CAPI/cpp/grpc/include/google/protobuf/unknown_field_set.h
new file mode 100644
index 0000000..9aa2cbb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/unknown_field_set.h
@@ -0,0 +1,407 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Contains classes used to keep track of unrecognized fields seen while
+// parsing a protocol message.
+
+#ifndef GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
+#define GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
+
+
+#include <assert.h>
+
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/parse_context.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+namespace google {
+namespace protobuf {
+namespace internal {
+class InternalMetadata;           // metadata_lite.h
+class WireFormat;                 // wire_format.h
+class MessageSetFieldSkipperUsingCord;
+// extension_set_heavy.cc
+}  // namespace internal
+
+class Message;       // message.h
+class UnknownField;  // below
+
+// An UnknownFieldSet contains fields that were encountered while parsing a
+// message but were not defined by its type.  Keeping track of these can be
+// useful, especially in that they may be written if the message is serialized
+// again without being cleared in between.  This means that software which
+// simply receives messages and forwards them to other servers does not need
+// to be updated every time a new field is added to the message definition.
+//
+// To get the UnknownFieldSet attached to any message, call
+// Reflection::GetUnknownFields().
+//
+// This class is necessarily tied to the protocol buffer wire format, unlike
+// the Reflection interface which is independent of any serialization scheme.
+class PROTOBUF_EXPORT UnknownFieldSet {
+ public:
+  UnknownFieldSet();
+  ~UnknownFieldSet();
+
+  // Remove all fields.
+  inline void Clear();
+
+  // Remove all fields and deallocate internal data objects
+  void ClearAndFreeMemory();
+
+  // Is this set empty?
+  inline bool empty() const;
+
+  // Merge the contents of some other UnknownFieldSet with this one.
+  void MergeFrom(const UnknownFieldSet& other);
+
+  // Similar to above, but this function will destroy the contents of other.
+  void MergeFromAndDestroy(UnknownFieldSet* other);
+
+  // Merge the contents an UnknownFieldSet with the UnknownFieldSet in
+  // *metadata, if there is one.  If *metadata doesn't have an UnknownFieldSet
+  // then add one to it and make it be a copy of the first arg.
+  static void MergeToInternalMetadata(const UnknownFieldSet& other,
+                                      internal::InternalMetadata* metadata);
+
+  // Swaps the contents of some other UnknownFieldSet with this one.
+  inline void Swap(UnknownFieldSet* x);
+
+  // Computes (an estimate of) the total number of bytes currently used for
+  // storing the unknown fields in memory. Does NOT include
+  // sizeof(*this) in the calculation.
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+  // Version of SpaceUsed() including sizeof(*this).
+  size_t SpaceUsedLong() const;
+
+  int SpaceUsed() const { return internal::ToIntSize(SpaceUsedLong()); }
+
+  // Returns the number of fields present in the UnknownFieldSet.
+  inline int field_count() const;
+  // Get a field in the set, where 0 <= index < field_count().  The fields
+  // appear in the order in which they were added.
+  inline const UnknownField& field(int index) const;
+  // Get a mutable pointer to a field in the set, where
+  // 0 <= index < field_count().  The fields appear in the order in which
+  // they were added.
+  inline UnknownField* mutable_field(int index);
+
+  // Adding fields ---------------------------------------------------
+
+  void AddVarint(int number, uint64_t value);
+  void AddFixed32(int number, uint32_t value);
+  void AddFixed64(int number, uint64_t value);
+  void AddLengthDelimited(int number, const std::string& value);
+  std::string* AddLengthDelimited(int number);
+  UnknownFieldSet* AddGroup(int number);
+
+  // Adds an unknown field from another set.
+  void AddField(const UnknownField& field);
+
+  // Delete fields with indices in the range [start .. start+num-1].
+  // Caution: implementation moves all fields with indices [start+num .. ].
+  void DeleteSubrange(int start, int num);
+
+  // Delete all fields with a specific field number. The order of left fields
+  // is preserved.
+  // Caution: implementation moves all fields after the first deleted field.
+  void DeleteByNumber(int number);
+
+  // Parsing helpers -------------------------------------------------
+  // These work exactly like the similarly-named methods of Message.
+
+  bool MergeFromCodedStream(io::CodedInputStream* input);
+  bool ParseFromCodedStream(io::CodedInputStream* input);
+  bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
+  bool ParseFromArray(const void* data, int size);
+  inline bool ParseFromString(const std::string& data) {
+    return ParseFromArray(data.data(), static_cast<int>(data.size()));
+  }
+
+  // Merges this message's unknown field data (if any).  This works whether
+  // the message is a lite or full proto (for legacy reasons, lite and full
+  // return different types for MessageType::unknown_fields()).
+  template <typename MessageType>
+  bool MergeFromMessage(const MessageType& message);
+
+  // Serialization.
+  bool SerializeToString(std::string* output) const;
+  bool SerializeToCodedStream(io::CodedOutputStream* output) const;
+  static const UnknownFieldSet& default_instance();
+
+ private:
+  // For InternalMergeFrom
+  friend class UnknownField;
+  // Merges from other UnknownFieldSet. This method assumes, that this object
+  // is newly created and has no fields.
+  void InternalMergeFrom(const UnknownFieldSet& other);
+  void ClearFallback();
+
+  template <typename MessageType,
+            typename std::enable_if<
+                std::is_base_of<Message, MessageType>::value, int>::type = 0>
+  bool InternalMergeFromMessage(const MessageType& message) {
+    MergeFrom(message.GetReflection()->GetUnknownFields(message));
+    return true;
+  }
+
+  template <typename MessageType,
+            typename std::enable_if<
+                std::is_base_of<MessageLite, MessageType>::value &&
+                    !std::is_base_of<Message, MessageType>::value,
+                int>::type = 0>
+  bool InternalMergeFromMessage(const MessageType& message) {
+    const auto& unknown_fields = message.unknown_fields();
+    io::ArrayInputStream array_stream(unknown_fields.data(),
+                                      unknown_fields.size());
+    io::CodedInputStream coded_stream(&array_stream);
+    return MergeFromCodedStream(&coded_stream);
+  }
+
+  std::vector<UnknownField> fields_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UnknownFieldSet);
+};
+
+namespace internal {
+
+inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* unknown) {
+  unknown->AddVarint(num, val);
+}
+inline void WriteLengthDelimited(uint32_t num, StringPiece val,
+                                 UnknownFieldSet* unknown) {
+  unknown->AddLengthDelimited(num)->assign(val.data(), val.size());
+}
+
+PROTOBUF_EXPORT
+const char* UnknownGroupParse(UnknownFieldSet* unknown, const char* ptr,
+                              ParseContext* ctx);
+PROTOBUF_EXPORT
+const char* UnknownFieldParse(uint64_t tag, UnknownFieldSet* unknown,
+                              const char* ptr, ParseContext* ctx);
+
+}  // namespace internal
+
+// Represents one field in an UnknownFieldSet.
+class PROTOBUF_EXPORT UnknownField {
+ public:
+  enum Type {
+    TYPE_VARINT,
+    TYPE_FIXED32,
+    TYPE_FIXED64,
+    TYPE_LENGTH_DELIMITED,
+    TYPE_GROUP
+  };
+
+  // The field's field number, as seen on the wire.
+  inline int number() const;
+
+  // The field type.
+  inline Type type() const;
+
+  // Accessors -------------------------------------------------------
+  // Each method works only for UnknownFields of the corresponding type.
+
+  inline uint64_t varint() const;
+  inline uint32_t fixed32() const;
+  inline uint64_t fixed64() const;
+  inline const std::string& length_delimited() const;
+  inline const UnknownFieldSet& group() const;
+
+  inline void set_varint(uint64_t value);
+  inline void set_fixed32(uint32_t value);
+  inline void set_fixed64(uint64_t value);
+  inline void set_length_delimited(const std::string& value);
+  inline std::string* mutable_length_delimited();
+  inline UnknownFieldSet* mutable_group();
+
+  inline size_t GetLengthDelimitedSize() const;
+  uint8_t* InternalSerializeLengthDelimitedNoTag(
+      uint8_t* target, io::EpsCopyOutputStream* stream) const;
+
+
+  // If this UnknownField contains a pointer, delete it.
+  void Delete();
+
+  // Make a deep copy of any pointers in this UnknownField.
+  void DeepCopy(const UnknownField& other);
+
+  // Set the wire type of this UnknownField. Should only be used when this
+  // UnknownField is being created.
+  inline void SetType(Type type);
+
+  union LengthDelimited {
+    std::string* string_value;
+  };
+
+  uint32_t number_;
+  uint32_t type_;
+  union {
+    uint64_t varint_;
+    uint32_t fixed32_;
+    uint64_t fixed64_;
+    mutable union LengthDelimited length_delimited_;
+    UnknownFieldSet* group_;
+  } data_;
+};
+
+// ===================================================================
+// inline implementations
+
+inline UnknownFieldSet::UnknownFieldSet() {}
+
+inline UnknownFieldSet::~UnknownFieldSet() { Clear(); }
+
+inline void UnknownFieldSet::ClearAndFreeMemory() { Clear(); }
+
+inline void UnknownFieldSet::Clear() {
+  if (!fields_.empty()) {
+    ClearFallback();
+  }
+}
+
+inline bool UnknownFieldSet::empty() const { return fields_.empty(); }
+
+inline void UnknownFieldSet::Swap(UnknownFieldSet* x) {
+  fields_.swap(x->fields_);
+}
+
+inline int UnknownFieldSet::field_count() const {
+  return static_cast<int>(fields_.size());
+}
+inline const UnknownField& UnknownFieldSet::field(int index) const {
+  return (fields_)[static_cast<size_t>(index)];
+}
+inline UnknownField* UnknownFieldSet::mutable_field(int index) {
+  return &(fields_)[static_cast<size_t>(index)];
+}
+
+inline void UnknownFieldSet::AddLengthDelimited(int number,
+                                                const std::string& value) {
+  AddLengthDelimited(number)->assign(value);
+}
+
+
+
+
+inline int UnknownField::number() const { return static_cast<int>(number_); }
+inline UnknownField::Type UnknownField::type() const {
+  return static_cast<Type>(type_);
+}
+
+inline uint64_t UnknownField::varint() const {
+  assert(type() == TYPE_VARINT);
+  return data_.varint_;
+}
+inline uint32_t UnknownField::fixed32() const {
+  assert(type() == TYPE_FIXED32);
+  return data_.fixed32_;
+}
+inline uint64_t UnknownField::fixed64() const {
+  assert(type() == TYPE_FIXED64);
+  return data_.fixed64_;
+}
+inline const std::string& UnknownField::length_delimited() const {
+  assert(type() == TYPE_LENGTH_DELIMITED);
+  return *data_.length_delimited_.string_value;
+}
+inline const UnknownFieldSet& UnknownField::group() const {
+  assert(type() == TYPE_GROUP);
+  return *data_.group_;
+}
+
+inline void UnknownField::set_varint(uint64_t value) {
+  assert(type() == TYPE_VARINT);
+  data_.varint_ = value;
+}
+inline void UnknownField::set_fixed32(uint32_t value) {
+  assert(type() == TYPE_FIXED32);
+  data_.fixed32_ = value;
+}
+inline void UnknownField::set_fixed64(uint64_t value) {
+  assert(type() == TYPE_FIXED64);
+  data_.fixed64_ = value;
+}
+inline void UnknownField::set_length_delimited(const std::string& value) {
+  assert(type() == TYPE_LENGTH_DELIMITED);
+  data_.length_delimited_.string_value->assign(value);
+}
+inline std::string* UnknownField::mutable_length_delimited() {
+  assert(type() == TYPE_LENGTH_DELIMITED);
+  return data_.length_delimited_.string_value;
+}
+inline UnknownFieldSet* UnknownField::mutable_group() {
+  assert(type() == TYPE_GROUP);
+  return data_.group_;
+}
+template <typename MessageType>
+bool UnknownFieldSet::MergeFromMessage(const MessageType& message) {
+  // SFINAE will route to the right version.
+  return InternalMergeFromMessage(message);
+}
+
+
+inline size_t UnknownField::GetLengthDelimitedSize() const {
+  GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type());
+  return data_.length_delimited_.string_value->size();
+}
+
+inline void UnknownField::SetType(Type type) {
+  type_ = type;
+}
+
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/delimited_message_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/delimited_message_util.h
new file mode 100644
index 0000000..78625cf
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/delimited_message_util.h
@@ -0,0 +1,109 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Adapted from the patch of kenton@google.com (Kenton Varda)
+// See https://github.com/protocolbuffers/protobuf/pull/710 for details.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_DELIMITED_MESSAGE_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_DELIMITED_MESSAGE_UTIL_H__
+
+
+#include <ostream>
+
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace util {
+
+// Write a single size-delimited message from the given stream. Delimited
+// format allows a single file or stream to contain multiple messages,
+// whereas normally writing multiple non-delimited messages to the same
+// stream would cause them to be merged. A delimited message is a varint
+// encoding the message size followed by a message of exactly that size.
+//
+// Note that if you want to *read* a delimited message from a file descriptor
+// or istream, you will need to construct an io::FileInputStream or
+// io::OstreamInputStream (implementations of io::ZeroCopyStream) and use the
+// utility function ParseDelimitedFromZeroCopyStream(). You must then
+// continue to use the same ZeroCopyInputStream to read all further data from
+// the stream until EOF. This is because these ZeroCopyInputStream
+// implementations are buffered: they read a big chunk of data at a time,
+// then parse it. As a result, they may read past the end of the delimited
+// message. There is no way for them to push the extra data back into the
+// underlying source, so instead you must keep using the same stream object.
+bool PROTOBUF_EXPORT SerializeDelimitedToFileDescriptor(
+    const MessageLite& message, int file_descriptor);
+
+bool PROTOBUF_EXPORT SerializeDelimitedToOstream(const MessageLite& message,
+                                                 std::ostream* output);
+
+// Read a single size-delimited message from the given stream. Delimited
+// format allows a single file or stream to contain multiple messages,
+// whereas normally parsing consumes the entire input. A delimited message
+// is a varint encoding the message size followed by a message of exactly
+// that size.
+//
+// If |clean_eof| is not NULL, then it will be set to indicate whether the
+// stream ended cleanly. That is, if the stream ends without this method
+// having read any data at all from it, then *clean_eof will be set true,
+// otherwise it will be set false. Note that these methods return false
+// on EOF, but they also return false on other errors, so |clean_eof| is
+// needed to distinguish a clean end from errors.
+bool PROTOBUF_EXPORT ParseDelimitedFromZeroCopyStream(
+    MessageLite* message, io::ZeroCopyInputStream* input, bool* clean_eof);
+
+bool PROTOBUF_EXPORT ParseDelimitedFromCodedStream(MessageLite* message,
+                                                   io::CodedInputStream* input,
+                                                   bool* clean_eof);
+
+// Write a single size-delimited message from the given stream. Delimited
+// format allows a single file or stream to contain multiple messages,
+// whereas normally writing multiple non-delimited messages to the same
+// stream would cause them to be merged. A delimited message is a varint
+// encoding the message size followed by a message of exactly that size.
+bool PROTOBUF_EXPORT SerializeDelimitedToZeroCopyStream(
+    const MessageLite& message, io::ZeroCopyOutputStream* output);
+
+bool PROTOBUF_EXPORT SerializeDelimitedToCodedStream(
+    const MessageLite& message, io::CodedOutputStream* output);
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_UTIL_DELIMITED_MESSAGE_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/field_comparator.h b/CAPI/cpp/grpc/include/google/protobuf/util/field_comparator.h
new file mode 100644
index 0000000..5706da3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/field_comparator.h
@@ -0,0 +1,288 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines classes for field comparison.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_FIELD_COMPARATOR_H__
+#define GOOGLE_PROTOBUF_UTIL_FIELD_COMPARATOR_H__
+
+
+#include <cstdint>
+#include <map>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class Message;
+class EnumValueDescriptor;
+class FieldDescriptor;
+
+namespace util {
+
+class FieldContext;
+class MessageDifferencer;
+
+// Base class specifying the interface for comparing protocol buffer fields.
+// Regular users should consider using or subclassing DefaultFieldComparator
+// rather than this interface.
+// Currently, this does not support comparing unknown fields.
+class PROTOBUF_EXPORT FieldComparator {
+ public:
+  FieldComparator();
+  virtual ~FieldComparator();
+
+  enum ComparisonResult {
+    SAME,       // Compared fields are equal. In case of comparing submessages,
+                // user should not recursively compare their contents.
+    DIFFERENT,  // Compared fields are different. In case of comparing
+                // submessages, user should not recursively compare their
+                // contents.
+    RECURSE,    // Compared submessages need to be compared recursively.
+                // FieldComparator does not specify the semantics of recursive
+                // comparison. This value should not be returned for simple
+                // values.
+  };
+
+  // Compares the values of a field in two protocol buffer messages.
+  // Returns SAME or DIFFERENT for simple values, and SAME, DIFFERENT or RECURSE
+  // for submessages. Returning RECURSE for fields not being submessages is
+  // illegal.
+  // In case the given FieldDescriptor points to a repeated field, the indices
+  // need to be valid. Otherwise they should be ignored.
+  //
+  // FieldContext contains information about the specific instances of the
+  // fields being compared, versus FieldDescriptor which only contains general
+  // type information about the fields.
+  virtual ComparisonResult Compare(const Message& message_1,
+                                   const Message& message_2,
+                                   const FieldDescriptor* field, int index_1,
+                                   int index_2,
+                                   const util::FieldContext* field_context) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldComparator);
+};
+
+// Basic implementation of FieldComparator.  Supports three modes of floating
+// point value comparison: exact, approximate using MathUtil::AlmostEqual
+// method, and arbitrarily precise using MathUtil::WithinFractionOrMargin.
+class PROTOBUF_EXPORT SimpleFieldComparator : public FieldComparator {
+ public:
+  enum FloatComparison {
+    EXACT,        // Floats and doubles are compared exactly.
+    APPROXIMATE,  // Floats and doubles are compared using the
+                  // MathUtil::AlmostEqual method or
+                  // MathUtil::WithinFractionOrMargin method.
+    // TODO(ksroka): Introduce third value to differentiate uses of AlmostEqual
+    //               and WithinFractionOrMargin.
+  };
+
+  // Creates new comparator with float comparison set to EXACT.
+  SimpleFieldComparator();
+
+  ~SimpleFieldComparator() override;
+
+  void set_float_comparison(FloatComparison float_comparison) {
+    float_comparison_ = float_comparison;
+  }
+
+  FloatComparison float_comparison() const { return float_comparison_; }
+
+  // Set whether the FieldComparator shall treat floats or doubles that are both
+  // NaN as equal (treat_nan_as_equal = true) or as different
+  // (treat_nan_as_equal = false). Default is treating NaNs always as different.
+  void set_treat_nan_as_equal(bool treat_nan_as_equal) {
+    treat_nan_as_equal_ = treat_nan_as_equal;
+  }
+
+  bool treat_nan_as_equal() const { return treat_nan_as_equal_; }
+
+  // Sets the fraction and margin for the float comparison of a given field.
+  // Uses MathUtil::WithinFractionOrMargin to compare the values.
+  //
+  // REQUIRES: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE or
+  //           field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT
+  // REQUIRES: float_comparison_ == APPROXIMATE
+  void SetFractionAndMargin(const FieldDescriptor* field, double fraction,
+                            double margin);
+
+  // Sets the fraction and margin for the float comparison of all float and
+  // double fields, unless a field has been given a specific setting via
+  // SetFractionAndMargin() above.
+  // Uses MathUtil::WithinFractionOrMargin to compare the values.
+  //
+  // REQUIRES: float_comparison_ == APPROXIMATE
+  void SetDefaultFractionAndMargin(double fraction, double margin);
+
+ protected:
+  // Returns the comparison result for the given field in two messages.
+  //
+  // This function is called directly by DefaultFieldComparator::Compare.
+  // Subclasses can call this function to compare fields they do not need to
+  // handle specially.
+  ComparisonResult SimpleCompare(const Message& message_1,
+                                 const Message& message_2,
+                                 const FieldDescriptor* field, int index_1,
+                                 int index_2,
+                                 const util::FieldContext* field_context);
+
+  // Compare using the provided message_differencer. For example, a subclass can
+  // use this method to compare some field in a certain way using the same
+  // message_differencer instance and the field context.
+  bool CompareWithDifferencer(MessageDifferencer* differencer,
+                              const Message& message1, const Message& message2,
+                              const util::FieldContext* field_context);
+
+  // Returns FieldComparator::SAME if boolean_result is true and
+  // FieldComparator::DIFFERENT otherwise.
+  ComparisonResult ResultFromBoolean(bool boolean_result) const;
+
+ private:
+  // Defines the tolerance for floating point comparison (fraction and margin).
+  struct Tolerance {
+    double fraction;
+    double margin;
+    Tolerance() : fraction(0.0), margin(0.0) {}
+    Tolerance(double f, double m) : fraction(f), margin(m) {}
+  };
+
+  // Defines the map to store the tolerances for floating point comparison.
+  typedef std::map<const FieldDescriptor*, Tolerance> ToleranceMap;
+
+  friend class MessageDifferencer;
+  // The following methods get executed when CompareFields is called for the
+  // basic types (instead of submessages). They return true on success. One
+  // can use ResultFromBoolean() to convert that boolean to a ComparisonResult
+  // value.
+  bool CompareBool(const FieldDescriptor& /* unused */, bool value_1,
+                   bool value_2) {
+    return value_1 == value_2;
+  }
+
+  // Uses CompareDoubleOrFloat, a helper function used by both CompareDouble and
+  // CompareFloat.
+  bool CompareDouble(const FieldDescriptor& field, double value_1,
+                     double value_2);
+
+  bool CompareEnum(const FieldDescriptor& field,
+                   const EnumValueDescriptor* value_1,
+                   const EnumValueDescriptor* value_2);
+
+  // Uses CompareDoubleOrFloat, a helper function used by both CompareDouble and
+  // CompareFloat.
+  bool CompareFloat(const FieldDescriptor& field, float value_1, float value_2);
+
+  bool CompareInt32(const FieldDescriptor& /* unused */, int32_t value_1,
+                    int32_t value_2) {
+    return value_1 == value_2;
+  }
+
+  bool CompareInt64(const FieldDescriptor& /* unused */, int64_t value_1,
+                    int64_t value_2) {
+    return value_1 == value_2;
+  }
+
+  bool CompareString(const FieldDescriptor& /* unused */,
+                     const std::string& value_1, const std::string& value_2) {
+    return value_1 == value_2;
+  }
+
+  bool CompareUInt32(const FieldDescriptor& /* unused */, uint32_t value_1,
+                     uint32_t value_2) {
+    return value_1 == value_2;
+  }
+
+  bool CompareUInt64(const FieldDescriptor& /* unused */, uint64_t value_1,
+                     uint64_t value_2) {
+    return value_1 == value_2;
+  }
+
+  // This function is used by CompareDouble and CompareFloat to avoid code
+  // duplication. There are no checks done against types of the values passed,
+  // but it's likely to fail if passed non-numeric arguments.
+  template <typename T>
+  bool CompareDoubleOrFloat(const FieldDescriptor& field, T value_1, T value_2);
+
+  FloatComparison float_comparison_;
+
+  // If true, floats and doubles that are both NaN are considered to be
+  // equal. Otherwise, two floats or doubles that are NaN are considered to be
+  // different.
+  bool treat_nan_as_equal_;
+
+  // True iff default_tolerance_ has been explicitly set.
+  //
+  // If false, then the default tolerance for floats and doubles is that which
+  // is used by MathUtil::AlmostEquals().
+  bool has_default_tolerance_;
+
+  // Default float/double tolerance. Only meaningful if
+  // has_default_tolerance_ == true.
+  Tolerance default_tolerance_;
+
+  // Field-specific float/double tolerances, which override any default for
+  // those particular fields.
+  ToleranceMap map_tolerance_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleFieldComparator);
+};
+
+// Default field comparison: use the basic implementation of FieldComparator.
+#ifdef PROTOBUF_FUTURE_BREAKING_CHANGES
+class PROTOBUF_EXPORT DefaultFieldComparator final
+    : public SimpleFieldComparator
+#else   // PROTOBUF_FUTURE_BREAKING_CHANGES
+class PROTOBUF_EXPORT DefaultFieldComparator : public SimpleFieldComparator
+#endif  // PROTOBUF_FUTURE_BREAKING_CHANGES
+{
+ public:
+  ComparisonResult Compare(const Message& message_1, const Message& message_2,
+                           const FieldDescriptor* field, int index_1,
+                           int index_2,
+                           const util::FieldContext* field_context) override {
+    return SimpleCompare(message_1, message_2, field, index_1, index_2,
+                         field_context);
+  }
+};
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_UTIL_FIELD_COMPARATOR_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/field_mask_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/field_mask_util.h
new file mode 100644
index 0000000..d51a332
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/field_mask_util.h
@@ -0,0 +1,263 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines utilities for the FieldMask well known type.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
+
+#include <cstdint>
+#include <string>
+
+#include <google/protobuf/field_mask.pb.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/descriptor.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace util {
+
+class PROTOBUF_EXPORT FieldMaskUtil {
+  typedef google::protobuf::FieldMask FieldMask;
+
+ public:
+  // Converts FieldMask to/from string, formatted by separating each path
+  // with a comma (e.g., "foo_bar,baz.quz").
+  static std::string ToString(const FieldMask& mask);
+  static void FromString(StringPiece str, FieldMask* out);
+
+  // Populates the FieldMask with the paths corresponding to the fields with the
+  // given numbers, after checking that all field numbers are valid.
+  template <typename T>
+  static void FromFieldNumbers(const std::vector<int64_t>& field_numbers,
+                               FieldMask* out) {
+    for (const auto field_number : field_numbers) {
+      const FieldDescriptor* field_desc =
+          T::descriptor()->FindFieldByNumber(field_number);
+      GOOGLE_CHECK(field_desc != nullptr)
+          << "Invalid field number for " << T::descriptor()->full_name() << ": "
+          << field_number;
+      AddPathToFieldMask<T>(field_desc->lowercase_name(), out);
+    }
+  }
+
+  // Converts FieldMask to/from string, formatted according to proto3 JSON
+  // spec for FieldMask (e.g., "fooBar,baz.quz"). If the field name is not
+  // style conforming (i.e., not snake_case when converted to string, or not
+  // camelCase when converted from string), the conversion will fail.
+  static bool ToJsonString(const FieldMask& mask, std::string* out);
+  static bool FromJsonString(StringPiece str, FieldMask* out);
+
+  // Get the descriptors of the fields which the given path from the message
+  // descriptor traverses, if field_descriptors is not null.
+  // Return false if the path is not valid, and the content of field_descriptors
+  // is unspecified.
+  static bool GetFieldDescriptors(
+      const Descriptor* descriptor, StringPiece path,
+      std::vector<const FieldDescriptor*>* field_descriptors);
+
+  // Checks whether the given path is valid for type T.
+  template <typename T>
+  static bool IsValidPath(StringPiece path) {
+    return GetFieldDescriptors(T::descriptor(), path, nullptr);
+  }
+
+  // Checks whether the given FieldMask is valid for type T.
+  template <typename T>
+  static bool IsValidFieldMask(const FieldMask& mask) {
+    for (int i = 0; i < mask.paths_size(); ++i) {
+      if (!GetFieldDescriptors(T::descriptor(), mask.paths(i), nullptr)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // Adds a path to FieldMask after checking whether the given path is valid.
+  // This method check-fails if the path is not a valid path for type T.
+  template <typename T>
+  static void AddPathToFieldMask(StringPiece path, FieldMask* mask) {
+    GOOGLE_CHECK(IsValidPath<T>(path)) << path;
+    mask->add_paths(std::string(path));
+  }
+
+  // Creates a FieldMask with all fields of type T. This FieldMask only
+  // contains fields of T but not any sub-message fields.
+  template <typename T>
+  static FieldMask GetFieldMaskForAllFields() {
+    FieldMask out;
+    GetFieldMaskForAllFields(T::descriptor(), &out);
+    return out;
+  }
+  template <typename T>
+  PROTOBUF_DEPRECATED_MSG("Use *out = GetFieldMaskForAllFields() instead")
+  static void GetFieldMaskForAllFields(FieldMask* out) {
+    GetFieldMaskForAllFields(T::descriptor(), out);
+  }
+  // This flavor takes the protobuf type descriptor as an argument.
+  // Useful when the type is not known at compile time.
+  static void GetFieldMaskForAllFields(const Descriptor* descriptor,
+                                       FieldMask* out);
+
+  // Converts a FieldMask to the canonical form. It will:
+  //   1. Remove paths that are covered by another path. For example,
+  //      "foo.bar" is covered by "foo" and will be removed if "foo"
+  //      is also in the FieldMask.
+  //   2. Sort all paths in alphabetical order.
+  static void ToCanonicalForm(const FieldMask& mask, FieldMask* out);
+
+  // Creates an union of two FieldMasks.
+  static void Union(const FieldMask& mask1, const FieldMask& mask2,
+                    FieldMask* out);
+
+  // Creates an intersection of two FieldMasks.
+  static void Intersect(const FieldMask& mask1, const FieldMask& mask2,
+                        FieldMask* out);
+
+  // Subtracts mask2 from mask1 base of type T.
+  template <typename T>
+  static void Subtract(const FieldMask& mask1, const FieldMask& mask2,
+                       FieldMask* out) {
+    Subtract(T::descriptor(), mask1, mask2, out);
+  }
+  // This flavor takes the protobuf type descriptor as an argument.
+  // Useful when the type is not known at compile time.
+  static void Subtract(const Descriptor* descriptor, const FieldMask& mask1,
+                       const FieldMask& mask2, FieldMask* out);
+
+  // Returns true if path is covered by the given FieldMask. Note that path
+  // "foo.bar" covers all paths like "foo.bar.baz", "foo.bar.quz.x", etc.
+  // Also note that parent paths are not covered by explicit child path, i.e.
+  // "foo.bar" does NOT cover "foo", even if "bar" is the only child.
+  static bool IsPathInFieldMask(StringPiece path, const FieldMask& mask);
+
+  class MergeOptions;
+  // Merges fields specified in a FieldMask into another message.
+  static void MergeMessageTo(const Message& source, const FieldMask& mask,
+                             const MergeOptions& options, Message* destination);
+
+  class TrimOptions;
+  // Removes from 'message' any field that is not represented in the given
+  // FieldMask. If the FieldMask is empty, does nothing.
+  // Returns true if the message is modified.
+  static bool TrimMessage(const FieldMask& mask, Message* message);
+
+  // Removes from 'message' any field that is not represented in the given
+  // FieldMask with customized TrimOptions.
+  // If the FieldMask is empty, does nothing.
+  // Returns true if the message is modified.
+  static bool TrimMessage(const FieldMask& mask, Message* message,
+                          const TrimOptions& options);
+
+ private:
+  friend class SnakeCaseCamelCaseTest;
+  // Converts a field name from snake_case to camelCase:
+  //   1. Every character after "_" will be converted to uppercase.
+  //   2. All "_"s are removed.
+  // The conversion will fail if:
+  //   1. The field name contains uppercase letters.
+  //   2. Any character after a "_" is not a lowercase letter.
+  // If the conversion succeeds, it's guaranteed that the resulted
+  // camelCase name will yield the original snake_case name when
+  // converted using CamelCaseToSnakeCase().
+  //
+  // Note that the input can contain characters not allowed in C identifiers.
+  // For example, "foo_bar,baz_quz" will be converted to "fooBar,bazQuz"
+  // successfully.
+  static bool SnakeCaseToCamelCase(StringPiece input,
+                                   std::string* output);
+  // Converts a field name from camelCase to snake_case:
+  //   1. Every uppercase letter is converted to lowercase with an additional
+  //      preceding "_".
+  // The conversion will fail if:
+  //   1. The field name contains "_"s.
+  // If the conversion succeeds, it's guaranteed that the resulted
+  // snake_case name will yield the original camelCase name when
+  // converted using SnakeCaseToCamelCase().
+  //
+  // Note that the input can contain characters not allowed in C identifiers.
+  // For example, "fooBar,bazQuz" will be converted to "foo_bar,baz_quz"
+  // successfully.
+  static bool CamelCaseToSnakeCase(StringPiece input,
+                                   std::string* output);
+};
+
+class PROTOBUF_EXPORT FieldMaskUtil::MergeOptions {
+ public:
+  MergeOptions()
+      : replace_message_fields_(false), replace_repeated_fields_(false) {}
+  // When merging message fields, the default behavior is to merge the
+  // content of two message fields together. If you instead want to use
+  // the field from the source message to replace the corresponding field
+  // in the destination message, set this flag to true. When this flag is set,
+  // specified submessage fields that are missing in source will be cleared in
+  // destination.
+  void set_replace_message_fields(bool value) {
+    replace_message_fields_ = value;
+  }
+  bool replace_message_fields() const { return replace_message_fields_; }
+  // The default merging behavior will append entries from the source
+  // repeated field to the destination repeated field. If you only want
+  // to keep the entries from the source repeated field, set this flag
+  // to true.
+  void set_replace_repeated_fields(bool value) {
+    replace_repeated_fields_ = value;
+  }
+  bool replace_repeated_fields() const { return replace_repeated_fields_; }
+
+ private:
+  bool replace_message_fields_;
+  bool replace_repeated_fields_;
+};
+
+class PROTOBUF_EXPORT FieldMaskUtil::TrimOptions {
+ public:
+  TrimOptions() : keep_required_fields_(false) {}
+  // When trimming message fields, the default behavior is to trim required
+  // fields of the present message if they are not specified in the field mask.
+  // If you instead want to keep required fields of the present message even
+  // when they are not specified in the field mask, set this flag to true.
+  void set_keep_required_fields(bool value) { keep_required_fields_ = value; }
+  bool keep_required_fields() const { return keep_required_fields_; }
+
+ private:
+  bool keep_required_fields_;
+};
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/json_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/json_util.h
new file mode 100644
index 0000000..0f1c4d8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/json_util.h
@@ -0,0 +1,204 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Utility functions to convert between protobuf binary format and proto3 JSON
+// format.
+#ifndef GOOGLE_PROTOBUF_UTIL_JSON_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_JSON_UTIL_H__
+
+#include <google/protobuf/stubs/bytestream.h>
+#include <google/protobuf/stubs/status.h>
+#include <google/protobuf/stubs/strutil.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/util/type_resolver.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace io {
+class ZeroCopyInputStream;
+class ZeroCopyOutputStream;
+}  // namespace io
+namespace util {
+
+struct JsonParseOptions {
+  // Whether to ignore unknown JSON fields during parsing
+  bool ignore_unknown_fields;
+
+  // If true, when a lowercase enum value fails to parse, try convert it to
+  // UPPER_CASE and see if it matches a valid enum.
+  // WARNING: This option exists only to preserve legacy behavior. Avoid using
+  // this option. If your enum needs to support different casing, consider using
+  // allow_alias instead.
+  bool case_insensitive_enum_parsing;
+
+  JsonParseOptions()
+      : ignore_unknown_fields(false), case_insensitive_enum_parsing(false) {}
+};
+
+struct JsonPrintOptions {
+  // Whether to add spaces, line breaks and indentation to make the JSON output
+  // easy to read.
+  bool add_whitespace;
+  // Whether to always print primitive fields. By default proto3 primitive
+  // fields with default values will be omitted in JSON output. For example, an
+  // int32 field set to 0 will be omitted. Set this flag to true will override
+  // the default behavior and print primitive fields regardless of their values.
+  bool always_print_primitive_fields;
+  // Whether to always print enums as ints. By default they are rendered as
+  // strings.
+  bool always_print_enums_as_ints;
+  // Whether to preserve proto field names
+  bool preserve_proto_field_names;
+
+  JsonPrintOptions()
+      : add_whitespace(false),
+        always_print_primitive_fields(false),
+        always_print_enums_as_ints(false),
+        preserve_proto_field_names(false) {}
+};
+
+// DEPRECATED. Use JsonPrintOptions instead.
+typedef JsonPrintOptions JsonOptions;
+
+// Converts from protobuf message to JSON and appends it to |output|. This is a
+// simple wrapper of BinaryToJsonString(). It will use the DescriptorPool of the
+// passed-in message to resolve Any types.
+PROTOBUF_EXPORT util::Status MessageToJsonString(const Message& message,
+                                                 std::string* output,
+                                                 const JsonOptions& options);
+
+inline util::Status MessageToJsonString(const Message& message,
+                                        std::string* output) {
+  return MessageToJsonString(message, output, JsonOptions());
+}
+
+// Converts from JSON to protobuf message. This is a simple wrapper of
+// JsonStringToBinary(). It will use the DescriptorPool of the passed-in
+// message to resolve Any types.
+PROTOBUF_EXPORT util::Status JsonStringToMessage(
+    StringPiece input, Message* message, const JsonParseOptions& options);
+
+inline util::Status JsonStringToMessage(StringPiece input,
+                                        Message* message) {
+  return JsonStringToMessage(input, message, JsonParseOptions());
+}
+
+// Converts protobuf binary data to JSON.
+// The conversion will fail if:
+//   1. TypeResolver fails to resolve a type.
+//   2. input is not valid protobuf wire format, or conflicts with the type
+//      information returned by TypeResolver.
+// Note that unknown fields will be discarded silently.
+PROTOBUF_EXPORT util::Status BinaryToJsonStream(
+    TypeResolver* resolver, const std::string& type_url,
+    io::ZeroCopyInputStream* binary_input,
+    io::ZeroCopyOutputStream* json_output, const JsonPrintOptions& options);
+
+inline util::Status BinaryToJsonStream(TypeResolver* resolver,
+                                       const std::string& type_url,
+                                       io::ZeroCopyInputStream* binary_input,
+                                       io::ZeroCopyOutputStream* json_output) {
+  return BinaryToJsonStream(resolver, type_url, binary_input, json_output,
+                            JsonPrintOptions());
+}
+
+PROTOBUF_EXPORT util::Status BinaryToJsonString(
+    TypeResolver* resolver, const std::string& type_url,
+    const std::string& binary_input, std::string* json_output,
+    const JsonPrintOptions& options);
+
+inline util::Status BinaryToJsonString(TypeResolver* resolver,
+                                       const std::string& type_url,
+                                       const std::string& binary_input,
+                                       std::string* json_output) {
+  return BinaryToJsonString(resolver, type_url, binary_input, json_output,
+                            JsonPrintOptions());
+}
+
+// Converts JSON data to protobuf binary format.
+// The conversion will fail if:
+//   1. TypeResolver fails to resolve a type.
+//   2. input is not valid JSON format, or conflicts with the type
+//      information returned by TypeResolver.
+PROTOBUF_EXPORT util::Status JsonToBinaryStream(
+    TypeResolver* resolver, const std::string& type_url,
+    io::ZeroCopyInputStream* json_input,
+    io::ZeroCopyOutputStream* binary_output, const JsonParseOptions& options);
+
+inline util::Status JsonToBinaryStream(
+    TypeResolver* resolver, const std::string& type_url,
+    io::ZeroCopyInputStream* json_input,
+    io::ZeroCopyOutputStream* binary_output) {
+  return JsonToBinaryStream(resolver, type_url, json_input, binary_output,
+                            JsonParseOptions());
+}
+
+PROTOBUF_EXPORT util::Status JsonToBinaryString(
+    TypeResolver* resolver, const std::string& type_url,
+    StringPiece json_input, std::string* binary_output,
+    const JsonParseOptions& options);
+
+inline util::Status JsonToBinaryString(TypeResolver* resolver,
+                                       const std::string& type_url,
+                                       StringPiece json_input,
+                                       std::string* binary_output) {
+  return JsonToBinaryString(resolver, type_url, json_input, binary_output,
+                            JsonParseOptions());
+}
+
+namespace internal {
+// Internal helper class. Put in the header so we can write unit-tests for it.
+class PROTOBUF_EXPORT ZeroCopyStreamByteSink : public strings::ByteSink {
+ public:
+  explicit ZeroCopyStreamByteSink(io::ZeroCopyOutputStream* stream)
+      : stream_(stream), buffer_(nullptr), buffer_size_(0) {}
+  ~ZeroCopyStreamByteSink() override;
+
+  void Append(const char* bytes, size_t len) override;
+
+ private:
+  io::ZeroCopyOutputStream* stream_;
+  void* buffer_;
+  int buffer_size_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyStreamByteSink);
+};
+}  // namespace internal
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_UTIL_JSON_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/message_differencer.h b/CAPI/cpp/grpc/include/google/protobuf/util/message_differencer.h
new file mode 100644
index 0000000..f63cd54
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/message_differencer.h
@@ -0,0 +1,980 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: jschorr@google.com (Joseph Schorr)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file defines static methods and classes for comparing Protocol
+// Messages.
+//
+// Aug. 2008: Added Unknown Fields Comparison for messages.
+// Aug. 2009: Added different options to compare repeated fields.
+// Apr. 2010: Moved field comparison to FieldComparator
+// Sep. 2020: Added option to output map keys in path
+
+#ifndef GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__
+#define GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__
+
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/descriptor.h>  // FieldDescriptor
+#include <google/protobuf/message.h>     // Message
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/util/field_comparator.h>
+
+// Always include as last one, otherwise it can break compilation
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+
+class DynamicMessageFactory;
+class FieldDescriptor;
+
+namespace io {
+class ZeroCopyOutputStream;
+class Printer;
+}  // namespace io
+
+namespace util {
+
+class DefaultFieldComparator;
+class FieldContext;  // declared below MessageDifferencer
+
+// Defines a collection of field descriptors.
+// In case of internal google codebase we are using absl::FixedArray instead
+// of vector. It significantly speeds up proto comparison (by ~30%) by
+// reducing the number of malloc/free operations
+typedef std::vector<const FieldDescriptor*> FieldDescriptorArray;
+
+// A basic differencer that can be used to determine
+// the differences between two specified Protocol Messages. If any differences
+// are found, the Compare method will return false, and any differencer reporter
+// specified via ReportDifferencesTo will have its reporting methods called (see
+// below for implementation of the report). Based off of the original
+// ProtocolDifferencer implementation in //net/proto/protocol-differencer.h
+// (Thanks Todd!).
+//
+// MessageDifferencer REQUIRES that compared messages be the same type, defined
+// as messages that share the same descriptor.  If not, the behavior of this
+// class is undefined.
+//
+// People disagree on what MessageDifferencer should do when asked to compare
+// messages with different descriptors.  Some people think it should always
+// return false.  Others expect it to try to look for similar fields and
+// compare them anyway -- especially if the descriptors happen to be identical.
+// If we chose either of these behaviors, some set of people would find it
+// surprising, and could end up writing code expecting the other behavior
+// without realizing their error.  Therefore, we forbid that usage.
+//
+// This class is implemented based on the proto2 reflection. The performance
+// should be good enough for normal usages. However, for places where the
+// performance is extremely sensitive, there are several alternatives:
+// - Comparing serialized string
+// Downside: false negatives (there are messages that are the same but their
+// serialized strings are different).
+// - Equals code generator by compiler plugin (net/proto2/contrib/equals_plugin)
+// Downside: more generated code; maintenance overhead for the additional rule
+// (must be in sync with the original proto_library).
+//
+// Note on handling of google.protobuf.Any: MessageDifferencer automatically
+// unpacks Any::value into a Message and compares its individual fields.
+// Messages encoded in a repeated Any cannot be compared using TreatAsMap.
+//
+// Note on thread-safety: MessageDifferencer is *not* thread-safe. You need to
+// guard it with a lock to use the same MessageDifferencer instance from
+// multiple threads. Note that it's fine to call static comparison methods
+// (like MessageDifferencer::Equals) concurrently, but it's not recommended for
+// performance critical code as it leads to extra allocations.
+class PROTOBUF_EXPORT MessageDifferencer {
+ public:
+  // Determines whether the supplied messages are equal. Equality is defined as
+  // all fields within the two messages being set to the same value. Primitive
+  // fields and strings are compared by value while embedded messages/groups
+  // are compared as if via a recursive call. Use Compare() with IgnoreField()
+  // if some fields should be ignored in the comparison. Use Compare() with
+  // TreatAsSet() if there are repeated fields where ordering does not matter.
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  static bool Equals(const Message& message1, const Message& message2);
+
+  // Determines whether the supplied messages are equivalent. Equivalency is
+  // defined as all fields within the two messages having the same value. This
+  // differs from the Equals method above in that fields with default values
+  // are considered set to said value automatically. For details on how default
+  // values are defined for each field type, see:
+  // https://developers.google.com/protocol-buffers/docs/proto?csw=1#optional.
+  // Also, Equivalent() ignores unknown fields. Use IgnoreField() and Compare()
+  // if some fields should be ignored in the comparison.
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  static bool Equivalent(const Message& message1, const Message& message2);
+
+  // Determines whether the supplied messages are approximately equal.
+  // Approximate equality is defined as all fields within the two messages
+  // being approximately equal.  Primitive (non-float) fields and strings are
+  // compared by value, floats are compared using MathUtil::AlmostEquals() and
+  // embedded messages/groups are compared as if via a recursive call. Use
+  // IgnoreField() and Compare() if some fields should be ignored in the
+  // comparison.
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  static bool ApproximatelyEquals(const Message& message1,
+                                  const Message& message2);
+
+  // Determines whether the supplied messages are approximately equivalent.
+  // Approximate equivalency is defined as all fields within the two messages
+  // being approximately equivalent. As in
+  // MessageDifferencer::ApproximatelyEquals, primitive (non-float) fields and
+  // strings are compared by value, floats are compared using
+  // MathUtil::AlmostEquals() and embedded messages/groups are compared as if
+  // via a recursive call. However, fields with default values are considered
+  // set to said value, as per MessageDiffencer::Equivalent. Use IgnoreField()
+  // and Compare() if some fields should be ignored in the comparison.
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  static bool ApproximatelyEquivalent(const Message& message1,
+                                      const Message& message2);
+
+  // Identifies an individual field in a message instance.  Used for field_path,
+  // below.
+  struct SpecificField {
+    // For known fields, "field" is filled in and "unknown_field_number" is -1.
+    // For unknown fields, "field" is NULL, "unknown_field_number" is the field
+    // number, and "unknown_field_type" is its type.
+    const FieldDescriptor* field = nullptr;
+    int unknown_field_number = -1;
+    UnknownField::Type unknown_field_type = UnknownField::Type::TYPE_VARINT;
+
+    // If this a repeated field, "index" is the index within it.  For unknown
+    // fields, this is the index of the field among all unknown fields of the
+    // same field number and type.
+    int index = -1;
+
+    // If "field" is a repeated field which is being treated as a map or
+    // a set (see TreatAsMap() and TreatAsSet(), below), new_index indicates
+    // the index the position to which the element has moved.  If the element
+    // has not moved, "new_index" will have the same value as "index".
+    int new_index = -1;
+
+    // If "field" is a map field, point to the map entry.
+    const Message* map_entry1 = nullptr;
+    const Message* map_entry2 = nullptr;
+
+    // For unknown fields, these are the pointers to the UnknownFieldSet
+    // containing the unknown fields. In certain cases (e.g. proto1's
+    // MessageSet, or nested groups of unknown fields), these may differ from
+    // the messages' internal UnknownFieldSets.
+    const UnknownFieldSet* unknown_field_set1 = nullptr;
+    const UnknownFieldSet* unknown_field_set2 = nullptr;
+
+    // For unknown fields, these are the index of the field within the
+    // UnknownFieldSets. One or the other will be -1 when
+    // reporting an addition or deletion.
+    int unknown_field_index1 = -1;
+    int unknown_field_index2 = -1;
+  };
+
+  // Abstract base class from which all MessageDifferencer
+  // reporters derive. The five Report* methods below will be called when
+  // a field has been added, deleted, modified, moved, or matched. The third
+  // argument is a vector of FieldDescriptor pointers which describes the chain
+  // of fields that was taken to find the current field. For example, for a
+  // field found in an embedded message, the vector will contain two
+  // FieldDescriptors. The first will be the field of the embedded message
+  // itself and the second will be the actual field in the embedded message
+  // that was added/deleted/modified.
+  // Fields will be reported in PostTraversalOrder.
+  // For example, given following proto, if both baz and mooo are changed.
+  // foo {
+  //   bar {
+  //     baz: 1
+  //     mooo: 2
+  //   }
+  // }
+  // ReportModified will be invoked with following order:
+  // 1. foo.bar.baz or foo.bar.mooo
+  // 2. foo.bar.mooo or foo.bar.baz
+  // 2. foo.bar
+  // 3. foo
+  class PROTOBUF_EXPORT Reporter {
+   public:
+    Reporter();
+    virtual ~Reporter();
+
+    // Reports that a field has been added into Message2.
+    virtual void ReportAdded(const Message& message1, const Message& message2,
+                             const std::vector<SpecificField>& field_path) = 0;
+
+    // Reports that a field has been deleted from Message1.
+    virtual void ReportDeleted(
+        const Message& message1, const Message& message2,
+        const std::vector<SpecificField>& field_path) = 0;
+
+    // Reports that the value of a field has been modified.
+    virtual void ReportModified(
+        const Message& message1, const Message& message2,
+        const std::vector<SpecificField>& field_path) = 0;
+
+    // Reports that a repeated field has been moved to another location.  This
+    // only applies when using TreatAsSet or TreatAsMap()  -- see below. Also
+    // note that for any given field, ReportModified and ReportMoved are
+    // mutually exclusive. If a field has been both moved and modified, then
+    // only ReportModified will be called.
+    virtual void ReportMoved(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const std::vector<SpecificField>& /* field_path */) {}
+
+    // Reports that two fields match. Useful for doing side-by-side diffs.
+    // This function is mutually exclusive with ReportModified and ReportMoved.
+    // Note that you must call set_report_matches(true) before calling Compare
+    // to make use of this function.
+    virtual void ReportMatched(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const std::vector<SpecificField>& /* field_path */) {}
+
+    // Reports that two fields would have been compared, but the
+    // comparison has been skipped because the field was marked as
+    // 'ignored' using IgnoreField().  This function is mutually
+    // exclusive with all the other Report() functions.
+    //
+    // The contract of ReportIgnored is slightly different than the
+    // other Report() functions, in that |field_path.back().index| is
+    // always equal to -1, even if the last field is repeated. This is
+    // because while the other Report() functions indicate where in a
+    // repeated field the action (Addition, Deletion, etc...)
+    // happened, when a repeated field is 'ignored', the differencer
+    // simply calls ReportIgnored on the repeated field as a whole and
+    // moves on without looking at its individual elements.
+    //
+    // Furthermore, ReportIgnored() does not indicate whether the
+    // fields were in fact equal or not, as Compare() does not inspect
+    // these fields at all. It is up to the Reporter to decide whether
+    // the fields are equal or not (perhaps with a second call to
+    // Compare()), if it cares.
+    virtual void ReportIgnored(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const std::vector<SpecificField>& /* field_path */) {}
+
+    // Report that an unknown field is ignored. (see comment above).
+    // Note this is a different function since the last SpecificField in field
+    // path has a null field.  This could break existing Reporter.
+    virtual void ReportUnknownFieldIgnored(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const std::vector<SpecificField>& /* field_path */) {}
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reporter);
+  };
+
+  // MapKeyComparator is used to determine if two elements have the same key
+  // when comparing elements of a repeated field as a map.
+  class PROTOBUF_EXPORT MapKeyComparator {
+   public:
+    MapKeyComparator();
+    virtual ~MapKeyComparator();
+
+    virtual bool IsMatch(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const std::vector<SpecificField>& /* parent_fields */) const {
+      GOOGLE_CHECK(false) << "IsMatch() is not implemented.";
+      return false;
+    }
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapKeyComparator);
+  };
+
+  // Abstract base class from which all IgnoreCriteria derive.
+  // By adding IgnoreCriteria more complex ignore logic can be implemented.
+  // IgnoreCriteria are registered with AddIgnoreCriteria. For each compared
+  // field IsIgnored is called on each added IgnoreCriteria until one returns
+  // true or all return false.
+  // IsIgnored is called for fields where at least one side has a value.
+  class PROTOBUF_EXPORT IgnoreCriteria {
+   public:
+    IgnoreCriteria();
+    virtual ~IgnoreCriteria();
+
+    // Returns true if the field should be ignored.
+    virtual bool IsIgnored(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const FieldDescriptor* /* field */,
+        const std::vector<SpecificField>& /* parent_fields */) = 0;
+
+    // Returns true if the unknown field should be ignored.
+    // Note: This will be called for unknown fields as well in which case
+    //       field.field will be null.
+    virtual bool IsUnknownFieldIgnored(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const SpecificField& /* field */,
+        const std::vector<SpecificField>& /* parent_fields */) {
+      return false;
+    }
+  };
+
+  // To add a Reporter, construct default here, then use ReportDifferencesTo or
+  // ReportDifferencesToString.
+  explicit MessageDifferencer();
+
+  ~MessageDifferencer();
+
+  enum MessageFieldComparison {
+    EQUAL,       // Fields must be present in both messages
+                 // for the messages to be considered the same.
+    EQUIVALENT,  // Fields with default values are considered set
+                 // for comparison purposes even if not explicitly
+                 // set in the messages themselves.  Unknown fields
+                 // are ignored.
+  };
+
+  enum Scope {
+    FULL,    // All fields of both messages are considered in the comparison.
+    PARTIAL  // Only fields present in the first message are considered; fields
+             // set only in the second message will be skipped during
+             // comparison.
+  };
+
+  // DEPRECATED. Use FieldComparator::FloatComparison instead.
+  enum FloatComparison {
+    EXACT,       // Floats and doubles are compared exactly.
+    APPROXIMATE  // Floats and doubles are compared using the
+                 // MathUtil::AlmostEquals method.
+  };
+
+  enum RepeatedFieldComparison {
+    AS_LIST,  // Repeated fields are compared in order.  Differing values at
+              // the same index are reported using ReportModified().  If the
+              // repeated fields have different numbers of elements, the
+              // unpaired elements are reported using ReportAdded() or
+              // ReportDeleted().
+    AS_SET,   // Treat all the repeated fields as sets.
+              // See TreatAsSet(), as below.
+    AS_SMART_LIST,  // Similar to AS_SET, but preserve the order and find the
+                    // longest matching sequence from the first matching
+                    // element. To use an optimal solution, call
+                    // SetMatchIndicesForSmartListCallback() to pass it in.
+    AS_SMART_SET,   // Similar to AS_SET, but match elements with fewest diffs.
+  };
+
+  // The elements of the given repeated field will be treated as a set for
+  // diffing purposes, so different orderings of the same elements will be
+  // considered equal.  Elements which are present on both sides of the
+  // comparison but which have changed position will be reported with
+  // ReportMoved().  Elements which only exist on one side or the other are
+  // reported with ReportAdded() and ReportDeleted() regardless of their
+  // positions.  ReportModified() is never used for this repeated field.  If
+  // the only differences between the compared messages is that some fields
+  // have been moved, then the comparison returns true.
+  //
+  // Note that despite the name of this method, this is really
+  // comparison as multisets: if one side of the comparison has a duplicate
+  // in the repeated field but the other side doesn't, this will count as
+  // a mismatch.
+  //
+  // If the scope of comparison is set to PARTIAL, then in addition to what's
+  // above, extra values added to repeated fields of the second message will
+  // not cause the comparison to fail.
+  //
+  // Note that set comparison is currently O(k * n^2) (where n is the total
+  // number of elements, and k is the average size of each element). In theory
+  // it could be made O(n * k) with a more complex hashing implementation. Feel
+  // free to contribute one if the current implementation is too slow for you.
+  // If partial matching is also enabled, the time complexity will be O(k * n^2
+  // + n^3) in which n^3 is the time complexity of the maximum matching
+  // algorithm.
+  //
+  // REQUIRES: field->is_repeated() and field not registered with TreatAsMap*
+  void TreatAsSet(const FieldDescriptor* field);
+  void TreatAsSmartSet(const FieldDescriptor* field);
+
+  // The elements of the given repeated field will be treated as a list for
+  // diffing purposes, so different orderings of the same elements will NOT be
+  // considered equal.
+  //
+  // REQUIRES: field->is_repeated() and field not registered with TreatAsMap*
+  void TreatAsList(const FieldDescriptor* field);
+  // Note that the complexity is similar to treating as SET.
+  void TreatAsSmartList(const FieldDescriptor* field);
+
+  // The elements of the given repeated field will be treated as a map for
+  // diffing purposes, with |key| being the map key.  Thus, elements with the
+  // same key will be compared even if they do not appear at the same index.
+  // Differences are reported similarly to TreatAsSet(), except that
+  // ReportModified() is used to report elements with the same key but
+  // different values.  Note that if an element is both moved and modified,
+  // only ReportModified() will be called.  As with TreatAsSet, if the only
+  // differences between the compared messages is that some fields have been
+  // moved, then the comparison returns true. See TreatAsSet for notes on
+  // performance.
+  //
+  // REQUIRES:  field->is_repeated()
+  // REQUIRES:  field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
+  // REQUIRES:  key->containing_type() == field->message_type()
+  void TreatAsMap(const FieldDescriptor* field, const FieldDescriptor* key);
+  // Same as TreatAsMap except that this method will use multiple fields as
+  // the key in comparison. All specified fields in 'key_fields' should be
+  // present in the compared elements. Two elements will be treated as having
+  // the same key iff they have the same value for every specified field. There
+  // are two steps in the comparison process. The first one is key matching.
+  // Every element from one message will be compared to every element from
+  // the other message. Only fields in 'key_fields' are compared in this step
+  // to decide if two elements have the same key. The second step is value
+  // comparison. Those pairs of elements with the same key (with equal value
+  // for every field in 'key_fields') will be compared in this step.
+  // Time complexity of the first step is O(s * m * n ^ 2) where s is the
+  // average size of the fields specified in 'key_fields', m is the number of
+  // fields in 'key_fields' and n is the number of elements. If partial
+  // matching is enabled, an extra O(n^3) will be incured by the maximum
+  // matching algorithm. The second step is O(k * n) where k is the average
+  // size of each element.
+  void TreatAsMapWithMultipleFieldsAsKey(
+      const FieldDescriptor* field,
+      const std::vector<const FieldDescriptor*>& key_fields);
+  // Same as TreatAsMapWithMultipleFieldsAsKey, except that each of the field
+  // do not necessarily need to be a direct subfield. Each element in
+  // key_field_paths indicate a path from the message being compared, listing
+  // successive subfield to reach the key field.
+  //
+  // REQUIRES:
+  //   for key_field_path in key_field_paths:
+  //     key_field_path[0]->containing_type() == field->message_type()
+  //     for i in [0, key_field_path.size() - 1):
+  //       key_field_path[i+1]->containing_type() ==
+  //           key_field_path[i]->message_type()
+  //       key_field_path[i]->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
+  //       !key_field_path[i]->is_repeated()
+  void TreatAsMapWithMultipleFieldPathsAsKey(
+      const FieldDescriptor* field,
+      const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths);
+
+  // Uses a custom MapKeyComparator to determine if two elements have the same
+  // key when comparing a repeated field as a map.
+  // The caller is responsible to delete the key_comparator.
+  // This method varies from TreatAsMapWithMultipleFieldsAsKey only in the
+  // first key matching step. Rather than comparing some specified fields, it
+  // will invoke the IsMatch method of the given 'key_comparator' to decide if
+  // two elements have the same key.
+  void TreatAsMapUsingKeyComparator(const FieldDescriptor* field,
+                                    const MapKeyComparator* key_comparator);
+
+  // Initiates and returns a new instance of MultipleFieldsMapKeyComparator.
+  MapKeyComparator* CreateMultipleFieldsMapKeyComparator(
+      const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths);
+
+  // Add a custom ignore criteria that is evaluated in addition to the
+  // ignored fields added with IgnoreField.
+  // Takes ownership of ignore_criteria.
+  void AddIgnoreCriteria(IgnoreCriteria* ignore_criteria);
+
+  // Indicates that any field with the given descriptor should be
+  // ignored for the purposes of comparing two messages. This applies
+  // to fields nested in the message structure as well as top level
+  // ones. When the MessageDifferencer encounters an ignored field,
+  // ReportIgnored is called on the reporter, if one is specified.
+  //
+  // The only place where the field's 'ignored' status is not applied is when
+  // it is being used as a key in a field passed to TreatAsMap or is one of
+  // the fields passed to TreatAsMapWithMultipleFieldsAsKey.
+  // In this case it is compared in key matching but after that it's ignored
+  // in value comparison.
+  void IgnoreField(const FieldDescriptor* field);
+
+  // Sets the field comparator used to determine differences between protocol
+  // buffer fields. By default it's set to a DefaultFieldComparator instance.
+  // MessageDifferencer doesn't take ownership over the passed object.
+  // Note that this method must be called before Compare for the comparator to
+  // be used.
+  void set_field_comparator(FieldComparator* comparator);
+#ifdef PROTOBUF_FUTURE_BREAKING_CHANGES
+  void set_field_comparator(DefaultFieldComparator* comparator);
+#endif  // PROTOBUF_FUTURE_BREAKING_CHANGES
+
+  // DEPRECATED. Pass a DefaultFieldComparator instance instead.
+  // Sets the fraction and margin for the float comparison of a given field.
+  // Uses MathUtil::WithinFractionOrMargin to compare the values.
+  // NOTE: this method does nothing if differencer's field comparator has been
+  //       set to a custom object.
+  //
+  // REQUIRES: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE or
+  //           field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT
+  // REQUIRES: float_comparison_ == APPROXIMATE
+  void SetFractionAndMargin(const FieldDescriptor* field, double fraction,
+                            double margin);
+
+  // Sets the type of comparison (as defined in the MessageFieldComparison
+  // enumeration above) that is used by this differencer when determining how
+  // to compare fields in messages.
+  void set_message_field_comparison(MessageFieldComparison comparison);
+
+  // Returns the current message field comparison used in this differencer.
+  MessageFieldComparison message_field_comparison() const;
+
+  // Tells the differencer whether or not to report matches. This method must
+  // be called before Compare. The default for a new differencer is false.
+  void set_report_matches(bool report_matches) {
+    report_matches_ = report_matches;
+  }
+
+  // Tells the differencer whether or not to report moves (in a set or map
+  // repeated field). This method must be called before Compare. The default for
+  // a new differencer is true.
+  void set_report_moves(bool report_moves) { report_moves_ = report_moves; }
+
+  // Tells the differencer whether or not to report ignored values. This method
+  // must be called before Compare. The default for a new differencer is true.
+  void set_report_ignores(bool report_ignores) {
+    report_ignores_ = report_ignores;
+  }
+
+  // Sets the scope of the comparison (as defined in the Scope enumeration
+  // above) that is used by this differencer when determining which fields to
+  // compare between the messages.
+  void set_scope(Scope scope);
+
+  // Returns the current scope used by this differencer.
+  Scope scope() const;
+
+  // DEPRECATED. Pass a DefaultFieldComparator instance instead.
+  // Sets the type of comparison (as defined in the FloatComparison enumeration
+  // above) that is used by this differencer when comparing float (and double)
+  // fields in messages.
+  // NOTE: this method does nothing if differencer's field comparator has been
+  //       set to a custom object.
+  void set_float_comparison(FloatComparison comparison);
+
+  // Sets the type of comparison for repeated field (as defined in the
+  // RepeatedFieldComparison enumeration above) that is used by this
+  // differencer when compare repeated fields in messages.
+  void set_repeated_field_comparison(RepeatedFieldComparison comparison);
+
+  // Returns the current repeated field comparison used by this differencer.
+  RepeatedFieldComparison repeated_field_comparison() const;
+
+  // Compares the two specified messages, returning true if they are the same,
+  // false otherwise. If this method returns false, any changes between the
+  // two messages will be reported if a Reporter was specified via
+  // ReportDifferencesTo (see also ReportDifferencesToString).
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  bool Compare(const Message& message1, const Message& message2);
+
+  // Same as above, except comparing only the list of fields specified by the
+  // two vectors of FieldDescriptors.
+  bool CompareWithFields(
+      const Message& message1, const Message& message2,
+      const std::vector<const FieldDescriptor*>& message1_fields,
+      const std::vector<const FieldDescriptor*>& message2_fields);
+
+  // Automatically creates a reporter that will output the differences
+  // found (if any) to the specified output string pointer. Note that this
+  // method must be called before Compare.
+  void ReportDifferencesToString(std::string* output);
+
+  // Tells the MessageDifferencer to report differences via the specified
+  // reporter. Note that this method must be called before Compare for
+  // the reporter to be used. It is the responsibility of the caller to delete
+  // this object.
+  // If the provided pointer equals NULL, the MessageDifferencer stops reporting
+  // differences to any previously set reporters or output strings.
+  void ReportDifferencesTo(Reporter* reporter);
+
+ private:
+  // Class for processing Any deserialization.  This logic is used by both the
+  // MessageDifferencer and StreamReporter classes.
+  class UnpackAnyField {
+   private:
+    std::unique_ptr<DynamicMessageFactory> dynamic_message_factory_;
+
+   public:
+    UnpackAnyField() = default;
+    ~UnpackAnyField() = default;
+    // If "any" is of type google.protobuf.Any, extract its payload using
+    // DynamicMessageFactory and store in "data".
+    bool UnpackAny(const Message& any, std::unique_ptr<Message>* data);
+  };
+
+ public:
+  // An implementation of the MessageDifferencer Reporter that outputs
+  // any differences found in human-readable form to the supplied
+  // ZeroCopyOutputStream or Printer. If a printer is used, the delimiter
+  // *must* be '$'.
+  //
+  // WARNING: this reporter does not necessarily flush its output until it is
+  // destroyed. As a result, it is not safe to assume the output is valid or
+  // complete until after you destroy the reporter. For example, if you use a
+  // StreamReporter to write to a StringOutputStream, the target string may
+  // contain uninitialized data until the reporter is destroyed.
+  class PROTOBUF_EXPORT StreamReporter : public Reporter {
+   public:
+    explicit StreamReporter(io::ZeroCopyOutputStream* output);
+    explicit StreamReporter(io::Printer* printer);  // delimiter '$'
+    ~StreamReporter() override;
+
+    // When set to true, the stream reporter will also output aggregates nodes
+    // (i.e. messages and groups) whose subfields have been modified. When
+    // false, will only report the individual subfields. Defaults to false.
+    void set_report_modified_aggregates(bool report) {
+      report_modified_aggregates_ = report;
+    }
+
+    // The following are implementations of the methods described above.
+
+    void ReportAdded(const Message& message1, const Message& message2,
+                     const std::vector<SpecificField>& field_path) override;
+
+    void ReportDeleted(const Message& message1, const Message& message2,
+                       const std::vector<SpecificField>& field_path) override;
+
+    void ReportModified(const Message& message1, const Message& message2,
+                        const std::vector<SpecificField>& field_path) override;
+
+    void ReportMoved(const Message& message1, const Message& message2,
+                     const std::vector<SpecificField>& field_path) override;
+
+    void ReportMatched(const Message& message1, const Message& message2,
+                       const std::vector<SpecificField>& field_path) override;
+
+    void ReportIgnored(const Message& message1, const Message& message2,
+                       const std::vector<SpecificField>& field_path) override;
+
+    void ReportUnknownFieldIgnored(
+        const Message& message1, const Message& message2,
+        const std::vector<SpecificField>& field_path) override;
+
+    // Messages that are being compared must be provided to StreamReporter prior
+    // to processing
+    void SetMessages(const Message& message1, const Message& message2);
+
+   protected:
+    // Prints the specified path of fields to the buffer.
+    virtual void PrintPath(const std::vector<SpecificField>& field_path,
+                           bool left_side);
+
+    // Prints the value of fields to the buffer.  left_side is true if the
+    // given message is from the left side of the comparison, false if it
+    // was the right.  This is relevant only to decide whether to follow
+    // unknown_field_index1 or unknown_field_index2 when an unknown field
+    // is encountered in field_path.
+    virtual void PrintValue(const Message& message,
+                            const std::vector<SpecificField>& field_path,
+                            bool left_side);
+
+    // Prints the specified path of unknown fields to the buffer.
+    virtual void PrintUnknownFieldValue(const UnknownField* unknown_field);
+
+    // Just print a string
+    void Print(const std::string& str);
+
+   private:
+    // helper function for PrintPath that contains logic for printing maps
+    void PrintMapKey(bool left_side, const SpecificField& specific_field);
+
+    io::Printer* printer_;
+    bool delete_printer_;
+    bool report_modified_aggregates_;
+    const Message* message1_;
+    const Message* message2_;
+    MessageDifferencer::UnpackAnyField unpack_any_field_;
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StreamReporter);
+  };
+
+ private:
+  friend class SimpleFieldComparator;
+
+  // A MapKeyComparator to be used in TreatAsMapUsingKeyComparator.
+  // Implementation of this class needs to do field value comparison which
+  // relies on some private methods of MessageDifferencer. That's why this
+  // class is declared as a nested class of MessageDifferencer.
+  class MultipleFieldsMapKeyComparator;
+
+  // A MapKeyComparator for use with map_entries.
+  class PROTOBUF_EXPORT MapEntryKeyComparator : public MapKeyComparator {
+   public:
+    explicit MapEntryKeyComparator(MessageDifferencer* message_differencer);
+    bool IsMatch(
+        const Message& message1, const Message& message2,
+        const std::vector<SpecificField>& parent_fields) const override;
+
+   private:
+    MessageDifferencer* message_differencer_;
+  };
+
+  // Returns true if field1's number() is less than field2's.
+  static bool FieldBefore(const FieldDescriptor* field1,
+                          const FieldDescriptor* field2);
+
+  // Retrieve all the set fields, including extensions.
+  FieldDescriptorArray RetrieveFields(const Message& message,
+                                      bool base_message);
+
+  // Combine the two lists of fields into the combined_fields output vector.
+  // All fields present in both lists will always be included in the combined
+  // list.  Fields only present in one of the lists will only appear in the
+  // combined list if the corresponding fields_scope option is set to FULL.
+  FieldDescriptorArray CombineFields(const FieldDescriptorArray& fields1,
+                                     Scope fields1_scope,
+                                     const FieldDescriptorArray& fields2,
+                                     Scope fields2_scope);
+
+  // Internal version of the Compare method which performs the actual
+  // comparison. The parent_fields vector is a vector containing field
+  // descriptors of all fields accessed to get to this comparison operation
+  // (i.e. if the current message is an embedded message, the parent_fields
+  // vector will contain the field that has this embedded message).
+  bool Compare(const Message& message1, const Message& message2,
+               std::vector<SpecificField>* parent_fields);
+
+  // Compares all the unknown fields in two messages.
+  bool CompareUnknownFields(const Message& message1, const Message& message2,
+                            const UnknownFieldSet&, const UnknownFieldSet&,
+                            std::vector<SpecificField>* parent_fields);
+
+  // Compares the specified messages for the requested field lists. The field
+  // lists are modified depending on comparison settings, and then passed to
+  // CompareWithFieldsInternal.
+  bool CompareRequestedFieldsUsingSettings(
+      const Message& message1, const Message& message2,
+      const FieldDescriptorArray& message1_fields,
+      const FieldDescriptorArray& message2_fields,
+      std::vector<SpecificField>* parent_fields);
+
+  // Compares the specified messages with the specified field lists.
+  bool CompareWithFieldsInternal(const Message& message1,
+                                 const Message& message2,
+                                 const FieldDescriptorArray& message1_fields,
+                                 const FieldDescriptorArray& message2_fields,
+                                 std::vector<SpecificField>* parent_fields);
+
+  // Compares the repeated fields, and report the error.
+  bool CompareRepeatedField(const Message& message1, const Message& message2,
+                            const FieldDescriptor* field,
+                            std::vector<SpecificField>* parent_fields);
+
+  // Compares map fields, and report the error.
+  bool CompareMapField(const Message& message1, const Message& message2,
+                       const FieldDescriptor* field,
+                       std::vector<SpecificField>* parent_fields);
+
+  // Helper for CompareRepeatedField and CompareMapField: compares and reports
+  // differences element-wise. This is the implementation for non-map fields,
+  // and can also compare map fields by using the underlying representation.
+  bool CompareRepeatedRep(const Message& message1, const Message& message2,
+                          const FieldDescriptor* field,
+                          std::vector<SpecificField>* parent_fields);
+
+  // Helper for CompareMapField: compare the map fields using map reflection
+  // instead of sync to repeated.
+  bool CompareMapFieldByMapReflection(const Message& message1,
+                                      const Message& message2,
+                                      const FieldDescriptor* field,
+                                      std::vector<SpecificField>* parent_fields,
+                                      DefaultFieldComparator* comparator);
+
+  // Shorthand for CompareFieldValueUsingParentFields with NULL parent_fields.
+  bool CompareFieldValue(const Message& message1, const Message& message2,
+                         const FieldDescriptor* field, int index1, int index2);
+
+  // Compares the specified field on the two messages, returning
+  // true if they are the same, false otherwise. For repeated fields,
+  // this method only compares the value in the specified index. This method
+  // uses Compare functions to recurse into submessages.
+  // The parent_fields vector is used in calls to a Reporter instance calls.
+  // It can be NULL, in which case the MessageDifferencer will create new
+  // list of parent messages if it needs to recursively compare the given field.
+  // To avoid confusing users you should not set it to NULL unless you modified
+  // Reporter to handle the change of parent_fields correctly.
+  bool CompareFieldValueUsingParentFields(
+      const Message& message1, const Message& message2,
+      const FieldDescriptor* field, int index1, int index2,
+      std::vector<SpecificField>* parent_fields);
+
+  // Compares the specified field on the two messages, returning comparison
+  // result, as returned by appropriate FieldComparator.
+  FieldComparator::ComparisonResult GetFieldComparisonResult(
+      const Message& message1, const Message& message2,
+      const FieldDescriptor* field, int index1, int index2,
+      const FieldContext* field_context);
+
+  // Check if the two elements in the repeated field are match to each other.
+  // if the key_comprator is NULL, this function returns true when the two
+  // elements are equal.
+  bool IsMatch(const FieldDescriptor* repeated_field,
+               const MapKeyComparator* key_comparator, const Message* message1,
+               const Message* message2,
+               const std::vector<SpecificField>& parent_fields,
+               Reporter* reporter, int index1, int index2);
+
+  // Returns true when this repeated field has been configured to be treated
+  // as a Set / SmartSet / SmartList.
+  bool IsTreatedAsSet(const FieldDescriptor* field);
+  bool IsTreatedAsSmartSet(const FieldDescriptor* field);
+
+  bool IsTreatedAsSmartList(const FieldDescriptor* field);
+  // When treating as SMART_LIST, it uses MatchIndicesPostProcessorForSmartList
+  // by default to find the longest matching sequence from the first matching
+  // element. The callback takes two vectors showing the matching indices from
+  // the other vector, where -1 means an unmatch.
+  void SetMatchIndicesForSmartListCallback(
+      std::function<void(std::vector<int>*, std::vector<int>*)> callback);
+
+  // Returns true when this repeated field is to be compared as a subset, ie.
+  // has been configured to be treated as a set or map and scope is set to
+  // PARTIAL.
+  bool IsTreatedAsSubset(const FieldDescriptor* field);
+
+  // Returns true if this field is to be ignored when this
+  // MessageDifferencer compares messages.
+  bool IsIgnored(const Message& message1, const Message& message2,
+                 const FieldDescriptor* field,
+                 const std::vector<SpecificField>& parent_fields);
+
+  // Returns true if this unknown field is to be ignored when this
+  // MessageDifferencer compares messages.
+  bool IsUnknownFieldIgnored(const Message& message1, const Message& message2,
+                             const SpecificField& field,
+                             const std::vector<SpecificField>& parent_fields);
+
+  // Returns MapKeyComparator* when this field has been configured to be treated
+  // as a map or its is_map() return true.  If not, returns NULL.
+  const MapKeyComparator* GetMapKeyComparator(
+      const FieldDescriptor* field) const;
+
+  // Attempts to match indices of a repeated field, so that the contained values
+  // match. Clears output vectors and sets their values to indices of paired
+  // messages, ie. if message1[0] matches message2[1], then match_list1[0] == 1
+  // and match_list2[1] == 0. The unmatched indices are indicated by -1.
+  // Assumes the repeated field is not treated as a simple list.
+  // This method returns false if the match failed. However, it doesn't mean
+  // that the comparison succeeds when this method returns true (you need to
+  // double-check in this case).
+  bool MatchRepeatedFieldIndices(
+      const Message& message1, const Message& message2,
+      const FieldDescriptor* repeated_field,
+      const MapKeyComparator* key_comparator,
+      const std::vector<SpecificField>& parent_fields,
+      std::vector<int>* match_list1, std::vector<int>* match_list2);
+
+  // Checks if index is equal to new_index in all the specific fields.
+  static bool CheckPathChanged(const std::vector<SpecificField>& parent_fields);
+
+  // CHECKs that the given repeated field can be compared according to
+  // new_comparison.
+  void CheckRepeatedFieldComparisons(
+      const FieldDescriptor* field,
+      const RepeatedFieldComparison& new_comparison);
+
+  // Defines a map between field descriptors and their MapKeyComparators.
+  // Used for repeated fields when they are configured as TreatAsMap.
+  typedef std::map<const FieldDescriptor*, const MapKeyComparator*>
+      FieldKeyComparatorMap;
+
+  // Defines a set to store field descriptors.  Used for repeated fields when
+  // they are configured as TreatAsSet.
+  typedef std::set<const FieldDescriptor*> FieldSet;
+  typedef std::map<const FieldDescriptor*, RepeatedFieldComparison> FieldMap;
+
+  Reporter* reporter_;
+  DefaultFieldComparator default_field_comparator_;
+  MessageFieldComparison message_field_comparison_;
+  Scope scope_;
+  RepeatedFieldComparison repeated_field_comparison_;
+
+  FieldMap repeated_field_comparisons_;
+  // Keeps track of MapKeyComparators that are created within
+  // MessageDifferencer. These MapKeyComparators should be deleted
+  // before MessageDifferencer is destroyed.
+  // When TreatAsMap or TreatAsMapWithMultipleFieldsAsKey is called, we don't
+  // store the supplied FieldDescriptors directly. Instead, a new
+  // MapKeyComparator is created for comparison purpose.
+  std::vector<MapKeyComparator*> owned_key_comparators_;
+  FieldKeyComparatorMap map_field_key_comparator_;
+  MapEntryKeyComparator map_entry_key_comparator_;
+  std::vector<IgnoreCriteria*> ignore_criteria_;
+  // Reused multiple times in RetrieveFields to avoid extra allocations
+  std::vector<const FieldDescriptor*> tmp_message_fields_;
+
+  FieldSet ignored_fields_;
+
+  union {
+    DefaultFieldComparator* default_impl;
+    FieldComparator* base;
+  } field_comparator_ = {&default_field_comparator_};
+  enum { kFCDefault, kFCBase } field_comparator_kind_ = kFCDefault;
+
+  bool report_matches_;
+  bool report_moves_;
+  bool report_ignores_;
+
+  std::string* output_string_;
+
+  // Callback to post-process the matched indices to support SMART_LIST.
+  std::function<void(std::vector<int>*, std::vector<int>*)>
+      match_indices_for_smart_list_callback_;
+
+  MessageDifferencer::UnpackAnyField unpack_any_field_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageDifferencer);
+};
+
+// This class provides extra information to the FieldComparator::Compare
+// function.
+class PROTOBUF_EXPORT FieldContext {
+ public:
+  explicit FieldContext(
+      std::vector<MessageDifferencer::SpecificField>* parent_fields)
+      : parent_fields_(parent_fields) {}
+
+  std::vector<MessageDifferencer::SpecificField>* parent_fields() const {
+    return parent_fields_;
+  }
+
+ private:
+  std::vector<MessageDifferencer::SpecificField>* parent_fields_;
+};
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/time_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/time_util.h
new file mode 100644
index 0000000..709527e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/time_util.h
@@ -0,0 +1,314 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines utilities for the Timestamp and Duration well known types.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_TIME_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_TIME_UTIL_H__
+
+#include <cstdint>
+#include <ctime>
+#include <ostream>
+#include <string>
+#ifdef _MSC_VER
+#ifdef _XBOX_ONE
+struct timeval {
+  int64_t tv_sec;  /* seconds */
+  int64_t tv_usec; /* and microseconds */
+};
+#else
+#include <winsock2.h>
+#endif  // _XBOX_ONE
+#else
+#include <sys/time.h>
+#endif
+
+#include <google/protobuf/duration.pb.h>
+#include <google/protobuf/timestamp.pb.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace util {
+
+// Utility functions for Timestamp and Duration.
+class PROTOBUF_EXPORT TimeUtil {
+  typedef google::protobuf::Timestamp Timestamp;
+  typedef google::protobuf::Duration Duration;
+
+ public:
+  // The min/max Timestamp/Duration values we support.
+  //
+  // For "0001-01-01T00:00:00Z".
+  static const int64_t kTimestampMinSeconds = -62135596800LL;
+  // For "9999-12-31T23:59:59.999999999Z".
+  static const int64_t kTimestampMaxSeconds = 253402300799LL;
+  static const int64_t kDurationMinSeconds = -315576000000LL;
+  static const int64_t kDurationMaxSeconds = 315576000000LL;
+
+  // Converts Timestamp to/from RFC 3339 date string format.
+  // Generated output will always be Z-normalized and uses 3, 6 or 9
+  // fractional digits as required to represent the exact time. When
+  // parsing, any fractional digits (or none) and any offset are
+  // accepted as long as they fit into nano-seconds precision.
+  // Note that Timestamp can only represent time from
+  // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. Converting
+  // a Timestamp outside of this range is undefined behavior.
+  // See https://www.ietf.org/rfc/rfc3339.txt
+  //
+  // Example of generated format:
+  //   "1972-01-01T10:00:20.021Z"
+  //
+  // Example of accepted format:
+  //   "1972-01-01T10:00:20.021-05:00"
+  static std::string ToString(const Timestamp& timestamp);
+  static bool FromString(const std::string& value, Timestamp* timestamp);
+
+  // Converts Duration to/from string format. The string format will contains
+  // 3, 6, or 9 fractional digits depending on the precision required to
+  // represent the exact Duration value. For example:
+  //   "1s", "1.010s", "1.000000100s", "-3.100s"
+  // The range that can be represented by Duration is from -315,576,000,000
+  // to +315,576,000,000 inclusive (in seconds).
+  static std::string ToString(const Duration& duration);
+  static bool FromString(const std::string& value, Duration* timestamp);
+
+#ifdef GetCurrentTime
+#undef GetCurrentTime  // Visual Studio has macro GetCurrentTime
+#endif
+  // Gets the current UTC time.
+  static Timestamp GetCurrentTime();
+  // Returns the Time representing "1970-01-01 00:00:00".
+  static Timestamp GetEpoch();
+
+  // Converts between Duration and integer types. The behavior is undefined if
+  // the input value is not in the valid range of Duration.
+  static Duration NanosecondsToDuration(int64_t nanos);
+  static Duration MicrosecondsToDuration(int64_t micros);
+  static Duration MillisecondsToDuration(int64_t millis);
+  static Duration SecondsToDuration(int64_t seconds);
+  static Duration MinutesToDuration(int64_t minutes);
+  static Duration HoursToDuration(int64_t hours);
+  // Result will be truncated towards zero. For example, "-1.5s" will be
+  // truncated to "-1s", and "1.5s" to "1s" when converting to seconds.
+  // It's undefined behavior if the input duration is not valid or the result
+  // exceeds the range of int64. A duration is not valid if it's not in the
+  // valid range of Duration, or have an invalid nanos value (i.e., larger
+  // than 999999999, less than -999999999, or have a different sign from the
+  // seconds part).
+  static int64_t DurationToNanoseconds(const Duration& duration);
+  static int64_t DurationToMicroseconds(const Duration& duration);
+  static int64_t DurationToMilliseconds(const Duration& duration);
+  static int64_t DurationToSeconds(const Duration& duration);
+  static int64_t DurationToMinutes(const Duration& duration);
+  static int64_t DurationToHours(const Duration& duration);
+  // Creates Timestamp from integer types. The integer value indicates the
+  // time elapsed from Epoch time. The behavior is undefined if the input
+  // value is not in the valid range of Timestamp.
+  static Timestamp NanosecondsToTimestamp(int64_t nanos);
+  static Timestamp MicrosecondsToTimestamp(int64_t micros);
+  static Timestamp MillisecondsToTimestamp(int64_t millis);
+  static Timestamp SecondsToTimestamp(int64_t seconds);
+  // Result will be truncated down to the nearest integer value. For example,
+  // with "1969-12-31T23:59:59.9Z", TimestampToMilliseconds() returns -100
+  // and TimestampToSeconds() returns -1. It's undefined behavior if the input
+  // Timestamp is not valid (i.e., its seconds part or nanos part does not fall
+  // in the valid range) or the return value doesn't fit into int64.
+  static int64_t TimestampToNanoseconds(const Timestamp& timestamp);
+  static int64_t TimestampToMicroseconds(const Timestamp& timestamp);
+  static int64_t TimestampToMilliseconds(const Timestamp& timestamp);
+  static int64_t TimestampToSeconds(const Timestamp& timestamp);
+
+  // Conversion to/from other time/date types. Note that these types may
+  // have a different precision and time range from Timestamp/Duration.
+  // When converting to a lower precision type, the value will be truncated
+  // to the nearest value that can be represented. If the value is
+  // out of the range of the result type, the return value is undefined.
+  //
+  // Conversion to/from time_t
+  static Timestamp TimeTToTimestamp(time_t value);
+  static time_t TimestampToTimeT(const Timestamp& value);
+
+  // Conversion to/from timeval
+  static Timestamp TimevalToTimestamp(const timeval& value);
+  static timeval TimestampToTimeval(const Timestamp& value);
+  static Duration TimevalToDuration(const timeval& value);
+  static timeval DurationToTimeval(const Duration& value);
+};
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+// Overloaded operators for Duration.
+//
+// Assignment operators.
+PROTOBUF_EXPORT Duration& operator+=(Duration& d1,
+                                     const Duration& d2);  // NOLINT
+PROTOBUF_EXPORT Duration& operator-=(Duration& d1,
+                                     const Duration& d2);     // NOLINT
+PROTOBUF_EXPORT Duration& operator*=(Duration& d, int64_t r);  // NOLINT
+PROTOBUF_EXPORT Duration& operator*=(Duration& d, double r);  // NOLINT
+PROTOBUF_EXPORT Duration& operator/=(Duration& d, int64_t r);  // NOLINT
+PROTOBUF_EXPORT Duration& operator/=(Duration& d, double r);  // NOLINT
+// Overload for other integer types.
+template <typename T>
+Duration& operator*=(Duration& d, T r) {  // NOLINT
+  int64_t x = r;
+  return d *= x;
+}
+template <typename T>
+Duration& operator/=(Duration& d, T r) {  // NOLINT
+  int64_t x = r;
+  return d /= x;
+}
+PROTOBUF_EXPORT Duration& operator%=(Duration& d1,
+                                     const Duration& d2);  // NOLINT
+// Relational operators.
+inline bool operator<(const Duration& d1, const Duration& d2) {
+  if (d1.seconds() == d2.seconds()) {
+    return d1.nanos() < d2.nanos();
+  }
+  return d1.seconds() < d2.seconds();
+}
+inline bool operator>(const Duration& d1, const Duration& d2) {
+  return d2 < d1;
+}
+inline bool operator>=(const Duration& d1, const Duration& d2) {
+  return !(d1 < d2);
+}
+inline bool operator<=(const Duration& d1, const Duration& d2) {
+  return !(d2 < d1);
+}
+inline bool operator==(const Duration& d1, const Duration& d2) {
+  return d1.seconds() == d2.seconds() && d1.nanos() == d2.nanos();
+}
+inline bool operator!=(const Duration& d1, const Duration& d2) {
+  return !(d1 == d2);
+}
+// Additive operators
+inline Duration operator-(const Duration& d) {
+  Duration result;
+  result.set_seconds(-d.seconds());
+  result.set_nanos(-d.nanos());
+  return result;
+}
+inline Duration operator+(const Duration& d1, const Duration& d2) {
+  Duration result = d1;
+  return result += d2;
+}
+inline Duration operator-(const Duration& d1, const Duration& d2) {
+  Duration result = d1;
+  return result -= d2;
+}
+// Multiplicative operators
+template <typename T>
+inline Duration operator*(Duration d, T r) {
+  return d *= r;
+}
+template <typename T>
+inline Duration operator*(T r, Duration d) {
+  return d *= r;
+}
+template <typename T>
+inline Duration operator/(Duration d, T r) {
+  return d /= r;
+}
+PROTOBUF_EXPORT int64_t operator/(const Duration& d1, const Duration& d2);
+
+inline Duration operator%(const Duration& d1, const Duration& d2) {
+  Duration result = d1;
+  return result %= d2;
+}
+
+inline std::ostream& operator<<(std::ostream& out, const Duration& d) {
+  out << ::PROTOBUF_NAMESPACE_ID::util::TimeUtil::ToString(d);
+  return out;
+}
+
+// Overloaded operators for Timestamp
+//
+// Assignment operators.
+PROTOBUF_EXPORT Timestamp& operator+=(Timestamp& t,
+                                      const Duration& d);  // NOLINT
+PROTOBUF_EXPORT Timestamp& operator-=(Timestamp& t,
+                                      const Duration& d);  // NOLINT
+// Relational operators.
+inline bool operator<(const Timestamp& t1, const Timestamp& t2) {
+  if (t1.seconds() == t2.seconds()) {
+    return t1.nanos() < t2.nanos();
+  }
+  return t1.seconds() < t2.seconds();
+}
+inline bool operator>(const Timestamp& t1, const Timestamp& t2) {
+  return t2 < t1;
+}
+inline bool operator>=(const Timestamp& t1, const Timestamp& t2) {
+  return !(t1 < t2);
+}
+inline bool operator<=(const Timestamp& t1, const Timestamp& t2) {
+  return !(t2 < t1);
+}
+inline bool operator==(const Timestamp& t1, const Timestamp& t2) {
+  return t1.seconds() == t2.seconds() && t1.nanos() == t2.nanos();
+}
+inline bool operator!=(const Timestamp& t1, const Timestamp& t2) {
+  return !(t1 == t2);
+}
+// Additive operators.
+inline Timestamp operator+(const Timestamp& t, const Duration& d) {
+  Timestamp result = t;
+  return result += d;
+}
+inline Timestamp operator+(const Duration& d, const Timestamp& t) {
+  Timestamp result = t;
+  return result += d;
+}
+inline Timestamp operator-(const Timestamp& t, const Duration& d) {
+  Timestamp result = t;
+  return result -= d;
+}
+PROTOBUF_EXPORT Duration operator-(const Timestamp& t1, const Timestamp& t2);
+
+inline std::ostream& operator<<(std::ostream& out, const Timestamp& t) {
+  out << ::PROTOBUF_NAMESPACE_ID::util::TimeUtil::ToString(t);
+  return out;
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_UTIL_TIME_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver.h b/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver.h
new file mode 100644
index 0000000..b2e7b43
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver.h
@@ -0,0 +1,77 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines a TypeResolver for the Any message.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_H__
+#define GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/type.pb.h>
+#include <google/protobuf/stubs/status.h>
+#include <google/protobuf/stubs/status.h>
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+class DescriptorPool;
+namespace util {
+
+// Abstract interface for a type resolver.
+//
+// Implementations of this interface must be thread-safe.
+class PROTOBUF_EXPORT TypeResolver {
+ public:
+  TypeResolver() {}
+  virtual ~TypeResolver() {}
+
+  // Resolves a type url for a message type.
+  virtual util::Status ResolveMessageType(
+      const std::string& type_url, google::protobuf::Type* message_type) = 0;
+
+  // Resolves a type url for an enum type.
+  virtual util::Status ResolveEnumType(const std::string& type_url,
+                                       google::protobuf::Enum* enum_type) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeResolver);
+};
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver_util.h
new file mode 100644
index 0000000..7f6a4b9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver_util.h
@@ -0,0 +1,58 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines utilities for the TypeResolver.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_UTIL_H__
+
+#include <string>
+
+namespace google {
+namespace protobuf {
+class DescriptorPool;
+namespace util {
+class TypeResolver;
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+// Creates a TypeResolver that serves type information in the given descriptor
+// pool. Caller takes ownership of the returned TypeResolver.
+PROTOBUF_EXPORT TypeResolver* NewTypeResolverForDescriptorPool(
+    const std::string& url_prefix, const DescriptorPool* pool);
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/wire_format.h b/CAPI/cpp/grpc/include/google/protobuf/wire_format.h
new file mode 100644
index 0000000..1acbf9e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/wire_format.h
@@ -0,0 +1,414 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//         atenasio@google.com (Chris Atenasio) (ZigZag transform)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_H__
+#define GOOGLE_PROTOBUF_WIRE_FORMAT_H__
+
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/stubs/casts.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/parse_context.h>
+#include <google/protobuf/wire_format_lite.h>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+class MapKey;           // map_field.h
+class UnknownFieldSet;  // unknown_field_set.h
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// This class is for internal use by the protocol buffer library and by
+// protocol-compiler-generated message classes.  It must not be called
+// directly by clients.
+//
+// This class contains code for implementing the binary protocol buffer
+// wire format via reflection.  The WireFormatLite class implements the
+// non-reflection based routines.
+//
+// This class is really a namespace that contains only static methods
+class PROTOBUF_EXPORT WireFormat {
+ public:
+  // Given a field return its WireType
+  static inline WireFormatLite::WireType WireTypeForField(
+      const FieldDescriptor* field);
+
+  // Given a FieldDescriptor::Type return its WireType
+  static inline WireFormatLite::WireType WireTypeForFieldType(
+      FieldDescriptor::Type type);
+
+  // Compute the byte size of a tag.  For groups, this includes both the start
+  // and end tags.
+  static inline size_t TagSize(int field_number, FieldDescriptor::Type type);
+
+  // These procedures can be used to implement the methods of Message which
+  // handle parsing and serialization of the protocol buffer wire format
+  // using only the Reflection interface.  When you ask the protocol
+  // compiler to optimize for code size rather than speed, it will implement
+  // those methods in terms of these procedures.  Of course, these are much
+  // slower than the specialized implementations which the protocol compiler
+  // generates when told to optimize for speed.
+
+  // Read a message in protocol buffer wire format.
+  //
+  // This procedure reads either to the end of the input stream or through
+  // a WIRETYPE_END_GROUP tag ending the message, whichever comes first.
+  // It returns false if the input is invalid.
+  //
+  // Required fields are NOT checked by this method.  You must call
+  // IsInitialized() on the resulting message yourself.
+  static bool ParseAndMergePartial(io::CodedInputStream* input,
+                                   Message* message);
+
+  // This is meant for internal protobuf use (WireFormat is an internal class).
+  // This is the reflective implementation of the _InternalParse functionality.
+  static const char* _InternalParse(Message* msg, const char* ptr,
+                                    internal::ParseContext* ctx);
+
+  // Serialize a message in protocol buffer wire format.
+  //
+  // Any embedded messages within the message must have their correct sizes
+  // cached.  However, the top-level message need not; its size is passed as
+  // a parameter to this procedure.
+  //
+  // These return false iff the underlying stream returns a write error.
+  static void SerializeWithCachedSizes(const Message& message, int size,
+                                       io::CodedOutputStream* output) {
+    int expected_endpoint = output->ByteCount() + size;
+    output->SetCur(
+        _InternalSerialize(message, output->Cur(), output->EpsCopy()));
+    GOOGLE_CHECK_EQ(output->ByteCount(), expected_endpoint)
+        << ": Protocol message serialized to a size different from what was "
+           "originally expected.  Perhaps it was modified by another thread "
+           "during serialization?";
+  }
+  static uint8_t* _InternalSerialize(const Message& message, uint8_t* target,
+                                     io::EpsCopyOutputStream* stream);
+
+  // Implements Message::ByteSize() via reflection.  WARNING:  The result
+  // of this method is *not* cached anywhere.  However, all embedded messages
+  // will have their ByteSize() methods called, so their sizes will be cached.
+  // Therefore, calling this method is sufficient to allow you to call
+  // WireFormat::SerializeWithCachedSizes() on the same object.
+  static size_t ByteSize(const Message& message);
+
+  // -----------------------------------------------------------------
+  // Helpers for dealing with unknown fields
+
+  // Skips a field value of the given WireType.  The input should start
+  // positioned immediately after the tag.  If unknown_fields is non-nullptr,
+  // the contents of the field will be added to it.
+  static bool SkipField(io::CodedInputStream* input, uint32_t tag,
+                        UnknownFieldSet* unknown_fields);
+
+  // Reads and ignores a message from the input.  If unknown_fields is
+  // non-nullptr, the contents will be added to it.
+  static bool SkipMessage(io::CodedInputStream* input,
+                          UnknownFieldSet* unknown_fields);
+
+  // Read a packed enum field. If the is_valid function is not nullptr, values
+  // for which is_valid(value) returns false are appended to
+  // unknown_fields_stream.
+  static bool ReadPackedEnumPreserveUnknowns(io::CodedInputStream* input,
+                                             uint32_t field_number,
+                                             bool (*is_valid)(int),
+                                             UnknownFieldSet* unknown_fields,
+                                             RepeatedField<int>* values);
+
+  // Write the contents of an UnknownFieldSet to the output.
+  static void SerializeUnknownFields(const UnknownFieldSet& unknown_fields,
+                                     io::CodedOutputStream* output) {
+    output->SetCur(InternalSerializeUnknownFieldsToArray(
+        unknown_fields, output->Cur(), output->EpsCopy()));
+  }
+  // Same as above, except writing directly to the provided buffer.
+  // Requires that the buffer have sufficient capacity for
+  // ComputeUnknownFieldsSize(unknown_fields).
+  //
+  // Returns a pointer past the last written byte.
+  static uint8_t* SerializeUnknownFieldsToArray(
+      const UnknownFieldSet& unknown_fields, uint8_t* target) {
+    io::EpsCopyOutputStream stream(
+        target, static_cast<int>(ComputeUnknownFieldsSize(unknown_fields)),
+        io::CodedOutputStream::IsDefaultSerializationDeterministic());
+    return InternalSerializeUnknownFieldsToArray(unknown_fields, target,
+                                                 &stream);
+  }
+  static uint8_t* InternalSerializeUnknownFieldsToArray(
+      const UnknownFieldSet& unknown_fields, uint8_t* target,
+      io::EpsCopyOutputStream* stream);
+
+  // Same thing except for messages that have the message_set_wire_format
+  // option.
+  static void SerializeUnknownMessageSetItems(
+      const UnknownFieldSet& unknown_fields, io::CodedOutputStream* output) {
+    output->SetCur(InternalSerializeUnknownMessageSetItemsToArray(
+        unknown_fields, output->Cur(), output->EpsCopy()));
+  }
+  // Same as above, except writing directly to the provided buffer.
+  // Requires that the buffer have sufficient capacity for
+  // ComputeUnknownMessageSetItemsSize(unknown_fields).
+  //
+  // Returns a pointer past the last written byte.
+  static uint8_t* SerializeUnknownMessageSetItemsToArray(
+      const UnknownFieldSet& unknown_fields, uint8_t* target);
+  static uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
+      const UnknownFieldSet& unknown_fields, uint8_t* target,
+      io::EpsCopyOutputStream* stream);
+
+  // Compute the size of the UnknownFieldSet on the wire.
+  static size_t ComputeUnknownFieldsSize(const UnknownFieldSet& unknown_fields);
+
+  // Same thing except for messages that have the message_set_wire_format
+  // option.
+  static size_t ComputeUnknownMessageSetItemsSize(
+      const UnknownFieldSet& unknown_fields);
+
+  // Helper functions for encoding and decoding tags.  (Inlined below and in
+  // _inl.h)
+  //
+  // This is different from MakeTag(field->number(), field->type()) in the
+  // case of packed repeated fields.
+  static uint32_t MakeTag(const FieldDescriptor* field);
+
+  // Parse a single field.  The input should start out positioned immediately
+  // after the tag.
+  static bool ParseAndMergeField(
+      uint32_t tag,
+      const FieldDescriptor* field,  // May be nullptr for unknown
+      Message* message, io::CodedInputStream* input);
+
+  // Serialize a single field.
+  static void SerializeFieldWithCachedSizes(
+      const FieldDescriptor* field,  // Cannot be nullptr
+      const Message& message, io::CodedOutputStream* output) {
+    output->SetCur(InternalSerializeField(field, message, output->Cur(),
+                                          output->EpsCopy()));
+  }
+  static uint8_t* InternalSerializeField(
+      const FieldDescriptor* field,  // Cannot be nullptr
+      const Message& message, uint8_t* target, io::EpsCopyOutputStream* stream);
+
+  // Compute size of a single field.  If the field is a message type, this
+  // will call ByteSize() for the embedded message, insuring that it caches
+  // its size.
+  static size_t FieldByteSize(const FieldDescriptor* field,  // Can't be nullptr
+                              const Message& message);
+
+  // Parse/serialize a MessageSet::Item group.  Used with messages that use
+  // option message_set_wire_format = true.
+  static bool ParseAndMergeMessageSetItem(io::CodedInputStream* input,
+                                          Message* message);
+  static void SerializeMessageSetItemWithCachedSizes(
+      const FieldDescriptor* field, const Message& message,
+      io::CodedOutputStream* output) {
+    output->SetCur(InternalSerializeMessageSetItem(
+        field, message, output->Cur(), output->EpsCopy()));
+  }
+  static uint8_t* InternalSerializeMessageSetItem(
+      const FieldDescriptor* field, const Message& message, uint8_t* target,
+      io::EpsCopyOutputStream* stream);
+  static size_t MessageSetItemByteSize(const FieldDescriptor* field,
+                                       const Message& message);
+
+  // Computes the byte size of a field, excluding tags. For packed fields, it
+  // only includes the size of the raw data, and not the size of the total
+  // length, but for other length-delimited types, the size of the length is
+  // included.
+  static size_t FieldDataOnlyByteSize(
+      const FieldDescriptor* field,  // Cannot be nullptr
+      const Message& message);
+
+  enum Operation {
+    PARSE = 0,
+    SERIALIZE = 1,
+  };
+
+  // Verifies that a string field is valid UTF8, logging an error if not.
+  // This function will not be called by newly generated protobuf code
+  // but remains present to support existing code.
+  static void VerifyUTF8String(const char* data, int size, Operation op);
+  // The NamedField variant takes a field name in order to produce an
+  // informative error message if verification fails.
+  static void VerifyUTF8StringNamedField(const char* data, int size,
+                                         Operation op, const char* field_name);
+
+ private:
+  struct MessageSetParser;
+  // Skip a MessageSet field.
+  static bool SkipMessageSetField(io::CodedInputStream* input,
+                                  uint32_t field_number,
+                                  UnknownFieldSet* unknown_fields);
+
+  // Parse a MessageSet field.
+  static bool ParseAndMergeMessageSetField(uint32_t field_number,
+                                           const FieldDescriptor* field,
+                                           Message* message,
+                                           io::CodedInputStream* input);
+  // Parses the value from the wire that belongs to tag.
+  static const char* _InternalParseAndMergeField(Message* msg, const char* ptr,
+                                                 internal::ParseContext* ctx,
+                                                 uint64_t tag,
+                                                 const Reflection* reflection,
+                                                 const FieldDescriptor* field);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormat);
+};
+
+// Subclass of FieldSkipper which saves skipped fields to an UnknownFieldSet.
+class PROTOBUF_EXPORT UnknownFieldSetFieldSkipper : public FieldSkipper {
+ public:
+  UnknownFieldSetFieldSkipper(UnknownFieldSet* unknown_fields)
+      : unknown_fields_(unknown_fields) {}
+  ~UnknownFieldSetFieldSkipper() override {}
+
+  // implements FieldSkipper -----------------------------------------
+  bool SkipField(io::CodedInputStream* input, uint32_t tag) override;
+  bool SkipMessage(io::CodedInputStream* input) override;
+  void SkipUnknownEnum(int field_number, int value) override;
+
+ protected:
+  UnknownFieldSet* unknown_fields_;
+};
+
+// inline methods ====================================================
+
+inline WireFormatLite::WireType WireFormat::WireTypeForField(
+    const FieldDescriptor* field) {
+  if (field->is_packed()) {
+    return WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
+  } else {
+    return WireTypeForFieldType(field->type());
+  }
+}
+
+inline WireFormatLite::WireType WireFormat::WireTypeForFieldType(
+    FieldDescriptor::Type type) {
+  // Some compilers don't like enum -> enum casts, so we implicit_cast to
+  // int first.
+  return WireFormatLite::WireTypeForFieldType(
+      static_cast<WireFormatLite::FieldType>(implicit_cast<int>(type)));
+}
+
+inline uint32_t WireFormat::MakeTag(const FieldDescriptor* field) {
+  return WireFormatLite::MakeTag(field->number(), WireTypeForField(field));
+}
+
+inline size_t WireFormat::TagSize(int field_number,
+                                  FieldDescriptor::Type type) {
+  // Some compilers don't like enum -> enum casts, so we implicit_cast to
+  // int first.
+  return WireFormatLite::TagSize(
+      field_number,
+      static_cast<WireFormatLite::FieldType>(implicit_cast<int>(type)));
+}
+
+inline void WireFormat::VerifyUTF8String(const char* data, int size,
+                                         WireFormat::Operation op) {
+#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
+  WireFormatLite::VerifyUtf8String(
+      data, size, static_cast<WireFormatLite::Operation>(op), nullptr);
+#else
+  // Avoid the compiler warning about unused variables.
+  (void)data;
+  (void)size;
+  (void)op;
+#endif
+}
+
+inline void WireFormat::VerifyUTF8StringNamedField(const char* data, int size,
+                                                   WireFormat::Operation op,
+                                                   const char* field_name) {
+#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
+  WireFormatLite::VerifyUtf8String(
+      data, size, static_cast<WireFormatLite::Operation>(op), field_name);
+#else
+  // Avoid the compiler warning about unused variables.
+  (void)data;
+  (void)size;
+  (void)op;
+  (void)field_name;
+#endif
+}
+
+
+inline uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
+    const UnknownFieldSet& unknown_fields, uint8_t* target,
+    io::EpsCopyOutputStream* stream) {
+  return WireFormat::InternalSerializeUnknownMessageSetItemsToArray(
+      unknown_fields, target, stream);
+}
+
+inline size_t ComputeUnknownMessageSetItemsSize(
+    const UnknownFieldSet& unknown_fields) {
+  return WireFormat::ComputeUnknownMessageSetItemsSize(unknown_fields);
+}
+
+// Compute the size of the UnknownFieldSet on the wire.
+PROTOBUF_EXPORT
+size_t ComputeUnknownFieldsSize(const InternalMetadata& metadata, size_t size,
+                                CachedSize* cached_size);
+
+size_t MapKeyDataOnlyByteSize(const FieldDescriptor* field,
+                              const MapKey& value);
+
+uint8_t* SerializeMapKeyWithCachedSizes(const FieldDescriptor* field,
+                                        const MapKey& value, uint8_t* target,
+                                        io::EpsCopyOutputStream* stream);
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/wire_format_lite.h b/CAPI/cpp/grpc/include/google/protobuf/wire_format_lite.h
new file mode 100644
index 0000000..80d3961
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/wire_format_lite.h
@@ -0,0 +1,1908 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//         atenasio@google.com (Chris Atenasio) (ZigZag transform)
+//         wink@google.com (Wink Saville) (refactored from wire_format.h)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
+#define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
+
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/port.h>
+#include <google/protobuf/stubs/casts.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>
+
+// Do UTF-8 validation on string type in Debug build only
+#ifndef NDEBUG
+#define GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
+#endif
+
+// Avoid conflict with iOS where <ConditionalMacros.h> #defines TYPE_BOOL.
+//
+// If some one needs the macro TYPE_BOOL in a file that includes this header,
+// it's possible to bring it back using push/pop_macro as follows.
+//
+// #pragma push_macro("TYPE_BOOL")
+// #include this header and/or all headers that need the macro to be undefined.
+// #pragma pop_macro("TYPE_BOOL")
+#undef TYPE_BOOL
+
+
+// Must be included last.
+#include <google/protobuf/port_def.inc>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// This class is for internal use by the protocol buffer library and by
+// protocol-compiler-generated message classes.  It must not be called
+// directly by clients.
+//
+// This class contains helpers for implementing the binary protocol buffer
+// wire format without the need for reflection. Use WireFormat when using
+// reflection.
+//
+// This class is really a namespace that contains only static methods.
+class PROTOBUF_EXPORT WireFormatLite {
+ public:
+  // -----------------------------------------------------------------
+  // Helper constants and functions related to the format.  These are
+  // mostly meant for internal and generated code to use.
+
+  // The wire format is composed of a sequence of tag/value pairs, each
+  // of which contains the value of one field (or one element of a repeated
+  // field).  Each tag is encoded as a varint.  The lower bits of the tag
+  // identify its wire type, which specifies the format of the data to follow.
+  // The rest of the bits contain the field number.  Each type of field (as
+  // declared by FieldDescriptor::Type, in descriptor.h) maps to one of
+  // these wire types.  Immediately following each tag is the field's value,
+  // encoded in the format specified by the wire type.  Because the tag
+  // identifies the encoding of this data, it is possible to skip
+  // unrecognized fields for forwards compatibility.
+
+  enum WireType {
+    WIRETYPE_VARINT = 0,
+    WIRETYPE_FIXED64 = 1,
+    WIRETYPE_LENGTH_DELIMITED = 2,
+    WIRETYPE_START_GROUP = 3,
+    WIRETYPE_END_GROUP = 4,
+    WIRETYPE_FIXED32 = 5,
+  };
+
+  // Lite alternative to FieldDescriptor::Type.  Must be kept in sync.
+  enum FieldType {
+    TYPE_DOUBLE = 1,
+    TYPE_FLOAT = 2,
+    TYPE_INT64 = 3,
+    TYPE_UINT64 = 4,
+    TYPE_INT32 = 5,
+    TYPE_FIXED64 = 6,
+    TYPE_FIXED32 = 7,
+    TYPE_BOOL = 8,
+    TYPE_STRING = 9,
+    TYPE_GROUP = 10,
+    TYPE_MESSAGE = 11,
+    TYPE_BYTES = 12,
+    TYPE_UINT32 = 13,
+    TYPE_ENUM = 14,
+    TYPE_SFIXED32 = 15,
+    TYPE_SFIXED64 = 16,
+    TYPE_SINT32 = 17,
+    TYPE_SINT64 = 18,
+    MAX_FIELD_TYPE = 18,
+  };
+
+  // Lite alternative to FieldDescriptor::CppType.  Must be kept in sync.
+  enum CppType {
+    CPPTYPE_INT32 = 1,
+    CPPTYPE_INT64 = 2,
+    CPPTYPE_UINT32 = 3,
+    CPPTYPE_UINT64 = 4,
+    CPPTYPE_DOUBLE = 5,
+    CPPTYPE_FLOAT = 6,
+    CPPTYPE_BOOL = 7,
+    CPPTYPE_ENUM = 8,
+    CPPTYPE_STRING = 9,
+    CPPTYPE_MESSAGE = 10,
+    MAX_CPPTYPE = 10,
+  };
+
+  // Helper method to get the CppType for a particular Type.
+  static CppType FieldTypeToCppType(FieldType type);
+
+  // Given a FieldDescriptor::Type return its WireType
+  static inline WireFormatLite::WireType WireTypeForFieldType(
+      WireFormatLite::FieldType type) {
+    return kWireTypeForFieldType[type];
+  }
+
+  // Number of bits in a tag which identify the wire type.
+  static constexpr int kTagTypeBits = 3;
+  // Mask for those bits.
+  static constexpr uint32_t kTagTypeMask = (1 << kTagTypeBits) - 1;
+
+  // Helper functions for encoding and decoding tags.  (Inlined below and in
+  // _inl.h)
+  //
+  // This is different from MakeTag(field->number(), field->type()) in the
+  // case of packed repeated fields.
+  constexpr static uint32_t MakeTag(int field_number, WireType type);
+  static WireType GetTagWireType(uint32_t tag);
+  static int GetTagFieldNumber(uint32_t tag);
+
+  // Compute the byte size of a tag.  For groups, this includes both the start
+  // and end tags.
+  static inline size_t TagSize(int field_number,
+                               WireFormatLite::FieldType type);
+
+  // Skips a field value with the given tag.  The input should start
+  // positioned immediately after the tag.  Skipped values are simply
+  // discarded, not recorded anywhere.  See WireFormat::SkipField() for a
+  // version that records to an UnknownFieldSet.
+  static bool SkipField(io::CodedInputStream* input, uint32_t tag);
+
+  // Skips a field value with the given tag.  The input should start
+  // positioned immediately after the tag. Skipped values are recorded to a
+  // CodedOutputStream.
+  static bool SkipField(io::CodedInputStream* input, uint32_t tag,
+                        io::CodedOutputStream* output);
+
+  // Reads and ignores a message from the input.  Skipped values are simply
+  // discarded, not recorded anywhere.  See WireFormat::SkipMessage() for a
+  // version that records to an UnknownFieldSet.
+  static bool SkipMessage(io::CodedInputStream* input);
+
+  // Reads and ignores a message from the input.  Skipped values are recorded
+  // to a CodedOutputStream.
+  static bool SkipMessage(io::CodedInputStream* input,
+                          io::CodedOutputStream* output);
+
+  // This macro does the same thing as WireFormatLite::MakeTag(), but the
+  // result is usable as a compile-time constant, which makes it usable
+  // as a switch case or a template input.  WireFormatLite::MakeTag() is more
+  // type-safe, though, so prefer it if possible.
+#define GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(FIELD_NUMBER, TYPE) \
+  static_cast<uint32_t>((static_cast<uint32_t>(FIELD_NUMBER) << 3) | (TYPE))
+
+  // These are the tags for the old MessageSet format, which was defined as:
+  //   message MessageSet {
+  //     repeated group Item = 1 {
+  //       required int32 type_id = 2;
+  //       required string message = 3;
+  //     }
+  //   }
+  static constexpr int kMessageSetItemNumber = 1;
+  static constexpr int kMessageSetTypeIdNumber = 2;
+  static constexpr int kMessageSetMessageNumber = 3;
+  static const int kMessageSetItemStartTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+      kMessageSetItemNumber, WireFormatLite::WIRETYPE_START_GROUP);
+  static const int kMessageSetItemEndTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+      kMessageSetItemNumber, WireFormatLite::WIRETYPE_END_GROUP);
+  static const int kMessageSetTypeIdTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+      kMessageSetTypeIdNumber, WireFormatLite::WIRETYPE_VARINT);
+  static const int kMessageSetMessageTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+      kMessageSetMessageNumber, WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
+
+  // Byte size of all tags of a MessageSet::Item combined.
+  static const size_t kMessageSetItemTagsSize;
+
+  // Helper functions for converting between floats/doubles and IEEE-754
+  // uint32s/uint64s so that they can be written.  (Assumes your platform
+  // uses IEEE-754 floats.)
+  static uint32_t EncodeFloat(float value);
+  static float DecodeFloat(uint32_t value);
+  static uint64_t EncodeDouble(double value);
+  static double DecodeDouble(uint64_t value);
+
+  // Helper functions for mapping signed integers to unsigned integers in
+  // such a way that numbers with small magnitudes will encode to smaller
+  // varints.  If you simply static_cast a negative number to an unsigned
+  // number and varint-encode it, it will always take 10 bytes, defeating
+  // the purpose of varint.  So, for the "sint32" and "sint64" field types,
+  // we ZigZag-encode the values.
+  static uint32_t ZigZagEncode32(int32_t n);
+  static int32_t ZigZagDecode32(uint32_t n);
+  static uint64_t ZigZagEncode64(int64_t n);
+  static int64_t ZigZagDecode64(uint64_t n);
+
+  // =================================================================
+  // Methods for reading/writing individual field.
+
+  // Read fields, not including tags.  The assumption is that you already
+  // read the tag to determine what field to read.
+
+  // For primitive fields, we just use a templatized routine parameterized by
+  // the represented type and the FieldType. These are specialized with the
+  // appropriate definition for each declared type.
+  template <typename CType, enum FieldType DeclaredType>
+  PROTOBUF_NDEBUG_INLINE static bool ReadPrimitive(io::CodedInputStream* input,
+                                                   CType* value);
+
+  // Reads repeated primitive values, with optimizations for repeats.
+  // tag_size and tag should both be compile-time constants provided by the
+  // protocol compiler.
+  template <typename CType, enum FieldType DeclaredType>
+  PROTOBUF_NDEBUG_INLINE static bool ReadRepeatedPrimitive(
+      int tag_size, uint32_t tag, io::CodedInputStream* input,
+      RepeatedField<CType>* value);
+
+  // Identical to ReadRepeatedPrimitive, except will not inline the
+  // implementation.
+  template <typename CType, enum FieldType DeclaredType>
+  static bool ReadRepeatedPrimitiveNoInline(int tag_size, uint32_t tag,
+                                            io::CodedInputStream* input,
+                                            RepeatedField<CType>* value);
+
+  // Reads a primitive value directly from the provided buffer. It returns a
+  // pointer past the segment of data that was read.
+  //
+  // This is only implemented for the types with fixed wire size, e.g.
+  // float, double, and the (s)fixed* types.
+  template <typename CType, enum FieldType DeclaredType>
+  PROTOBUF_NDEBUG_INLINE static const uint8_t* ReadPrimitiveFromArray(
+      const uint8_t* buffer, CType* value);
+
+  // Reads a primitive packed field.
+  //
+  // This is only implemented for packable types.
+  template <typename CType, enum FieldType DeclaredType>
+  PROTOBUF_NDEBUG_INLINE static bool ReadPackedPrimitive(
+      io::CodedInputStream* input, RepeatedField<CType>* value);
+
+  // Identical to ReadPackedPrimitive, except will not inline the
+  // implementation.
+  template <typename CType, enum FieldType DeclaredType>
+  static bool ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
+                                          RepeatedField<CType>* value);
+
+  // Read a packed enum field. If the is_valid function is not nullptr, values
+  // for which is_valid(value) returns false are silently dropped.
+  static bool ReadPackedEnumNoInline(io::CodedInputStream* input,
+                                     bool (*is_valid)(int),
+                                     RepeatedField<int>* values);
+
+  // Read a packed enum field. If the is_valid function is not nullptr, values
+  // for which is_valid(value) returns false are appended to
+  // unknown_fields_stream.
+  static bool ReadPackedEnumPreserveUnknowns(
+      io::CodedInputStream* input, int field_number, bool (*is_valid)(int),
+      io::CodedOutputStream* unknown_fields_stream, RepeatedField<int>* values);
+
+  // Read a string.  ReadString(..., std::string* value) requires an
+  // existing std::string.
+  static inline bool ReadString(io::CodedInputStream* input,
+                                std::string* value);
+  // ReadString(..., std::string** p) is internal-only, and should only be
+  // called from generated code. It starts by setting *p to "new std::string" if
+  // *p == &GetEmptyStringAlreadyInited().  It then invokes
+  // ReadString(io::CodedInputStream* input, *p).  This is useful for reducing
+  // code size.
+  static inline bool ReadString(io::CodedInputStream* input, std::string** p);
+  // Analogous to ReadString().
+  static bool ReadBytes(io::CodedInputStream* input, std::string* value);
+  static bool ReadBytes(io::CodedInputStream* input, std::string** p);
+
+  enum Operation {
+    PARSE = 0,
+    SERIALIZE = 1,
+  };
+
+  // Returns true if the data is valid UTF-8.
+  static bool VerifyUtf8String(const char* data, int size, Operation op,
+                               const char* field_name);
+
+  template <typename MessageType>
+  static inline bool ReadGroup(int field_number, io::CodedInputStream* input,
+                               MessageType* value);
+
+  template <typename MessageType>
+  static inline bool ReadMessage(io::CodedInputStream* input,
+                                 MessageType* value);
+
+  template <typename MessageType>
+  static inline bool ReadMessageNoVirtual(io::CodedInputStream* input,
+                                          MessageType* value) {
+    return ReadMessage(input, value);
+  }
+
+  // Write a tag.  The Write*() functions typically include the tag, so
+  // normally there's no need to call this unless using the Write*NoTag()
+  // variants.
+  PROTOBUF_NDEBUG_INLINE static void WriteTag(int field_number, WireType type,
+                                              io::CodedOutputStream* output);
+
+  // Write fields, without tags.
+  PROTOBUF_NDEBUG_INLINE static void WriteInt32NoTag(
+      int32_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteInt64NoTag(
+      int64_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteUInt32NoTag(
+      uint32_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteUInt64NoTag(
+      uint64_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteSInt32NoTag(
+      int32_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteSInt64NoTag(
+      int64_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteFixed32NoTag(
+      uint32_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteFixed64NoTag(
+      uint64_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteSFixed32NoTag(
+      int32_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteSFixed64NoTag(
+      int64_t value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteFloatNoTag(
+      float value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteDoubleNoTag(
+      double value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteBoolNoTag(
+      bool value, io::CodedOutputStream* output);
+  PROTOBUF_NDEBUG_INLINE static void WriteEnumNoTag(
+      int value, io::CodedOutputStream* output);
+
+  // Write array of primitive fields, without tags
+  static void WriteFloatArray(const float* a, int n,
+                              io::CodedOutputStream* output);
+  static void WriteDoubleArray(const double* a, int n,
+                               io::CodedOutputStream* output);
+  static void WriteFixed32Array(const uint32_t* a, int n,
+                                io::CodedOutputStream* output);
+  static void WriteFixed64Array(const uint64_t* a, int n,
+                                io::CodedOutputStream* output);
+  static void WriteSFixed32Array(const int32_t* a, int n,
+                                 io::CodedOutputStream* output);
+  static void WriteSFixed64Array(const int64_t* a, int n,
+                                 io::CodedOutputStream* output);
+  static void WriteBoolArray(const bool* a, int n,
+                             io::CodedOutputStream* output);
+
+  // Write fields, including tags.
+  static void WriteInt32(int field_number, int32_t value,
+                         io::CodedOutputStream* output);
+  static void WriteInt64(int field_number, int64_t value,
+                         io::CodedOutputStream* output);
+  static void WriteUInt32(int field_number, uint32_t value,
+                          io::CodedOutputStream* output);
+  static void WriteUInt64(int field_number, uint64_t value,
+                          io::CodedOutputStream* output);
+  static void WriteSInt32(int field_number, int32_t value,
+                          io::CodedOutputStream* output);
+  static void WriteSInt64(int field_number, int64_t value,
+                          io::CodedOutputStream* output);
+  static void WriteFixed32(int field_number, uint32_t value,
+                           io::CodedOutputStream* output);
+  static void WriteFixed64(int field_number, uint64_t value,
+                           io::CodedOutputStream* output);
+  static void WriteSFixed32(int field_number, int32_t value,
+                            io::CodedOutputStream* output);
+  static void WriteSFixed64(int field_number, int64_t value,
+                            io::CodedOutputStream* output);
+  static void WriteFloat(int field_number, float value,
+                         io::CodedOutputStream* output);
+  static void WriteDouble(int field_number, double value,
+                          io::CodedOutputStream* output);
+  static void WriteBool(int field_number, bool value,
+                        io::CodedOutputStream* output);
+  static void WriteEnum(int field_number, int value,
+                        io::CodedOutputStream* output);
+
+  static void WriteString(int field_number, const std::string& value,
+                          io::CodedOutputStream* output);
+  static void WriteBytes(int field_number, const std::string& value,
+                         io::CodedOutputStream* output);
+  static void WriteStringMaybeAliased(int field_number,
+                                      const std::string& value,
+                                      io::CodedOutputStream* output);
+  static void WriteBytesMaybeAliased(int field_number, const std::string& value,
+                                     io::CodedOutputStream* output);
+
+  static void WriteGroup(int field_number, const MessageLite& value,
+                         io::CodedOutputStream* output);
+  static void WriteMessage(int field_number, const MessageLite& value,
+                           io::CodedOutputStream* output);
+  // Like above, but these will check if the output stream has enough
+  // space to write directly to a flat array.
+  static void WriteGroupMaybeToArray(int field_number, const MessageLite& value,
+                                     io::CodedOutputStream* output);
+  static void WriteMessageMaybeToArray(int field_number,
+                                       const MessageLite& value,
+                                       io::CodedOutputStream* output);
+
+  // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
+  // pointer must point at an instance of MessageType, *not* a subclass (or
+  // the subclass must not override SerializeWithCachedSizes()).
+  template <typename MessageType>
+  static inline void WriteGroupNoVirtual(int field_number,
+                                         const MessageType& value,
+                                         io::CodedOutputStream* output);
+  template <typename MessageType>
+  static inline void WriteMessageNoVirtual(int field_number,
+                                           const MessageType& value,
+                                           io::CodedOutputStream* output);
+
+  // Like above, but use only *ToArray methods of CodedOutputStream.
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteTagToArray(int field_number,
+                                                         WireType type,
+                                                         uint8_t* target);
+
+  // Write fields, without tags.
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32NoTagToArray(
+      int32_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
+      int64_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32NoTagToArray(
+      uint32_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
+      uint64_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32NoTagToArray(
+      int32_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
+      int64_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32NoTagToArray(
+      uint32_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
+      uint64_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32NoTagToArray(
+      int32_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
+      int64_t value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatNoTagToArray(
+      float value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleNoTagToArray(
+      double value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolNoTagToArray(bool value,
+                                                               uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumNoTagToArray(int value,
+                                                               uint8_t* target);
+
+  // Write fields, without tags.  These require that value.size() > 0.
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WritePrimitiveNoTagToArray(
+      const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*),
+      uint8_t* target);
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixedNoTagToArray(
+      const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*),
+      uint8_t* target);
+
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32NoTagToArray(
+      const RepeatedField<int32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
+      const RepeatedField<int64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32NoTagToArray(
+      const RepeatedField<uint32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
+      const RepeatedField<uint64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32NoTagToArray(
+      const RepeatedField<int32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
+      const RepeatedField<int64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32NoTagToArray(
+      const RepeatedField<uint32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
+      const RepeatedField<uint64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32NoTagToArray(
+      const RepeatedField<int32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
+      const RepeatedField<int64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatNoTagToArray(
+      const RepeatedField<float>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleNoTagToArray(
+      const RepeatedField<double>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolNoTagToArray(
+      const RepeatedField<bool>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumNoTagToArray(
+      const RepeatedField<int>& value, uint8_t* output);
+
+  // Write fields, including tags.
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32ToArray(int field_number,
+                                                           int32_t value,
+                                                           uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64ToArray(int field_number,
+                                                           int64_t value,
+                                                           uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32ToArray(int field_number,
+                                                            uint32_t value,
+                                                            uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64ToArray(int field_number,
+                                                            uint64_t value,
+                                                            uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32ToArray(int field_number,
+                                                            int32_t value,
+                                                            uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64ToArray(int field_number,
+                                                            int64_t value,
+                                                            uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32ToArray(int field_number,
+                                                             uint32_t value,
+                                                             uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64ToArray(int field_number,
+                                                             uint64_t value,
+                                                             uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32ToArray(int field_number,
+                                                              int32_t value,
+                                                              uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64ToArray(int field_number,
+                                                              int64_t value,
+                                                              uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatToArray(int field_number,
+                                                           float value,
+                                                           uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleToArray(int field_number,
+                                                            double value,
+                                                            uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolToArray(int field_number,
+                                                          bool value,
+                                                          uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumToArray(int field_number,
+                                                          int value,
+                                                          uint8_t* target);
+
+  template <typename T>
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WritePrimitiveToArray(
+      int field_number, const RepeatedField<T>& value,
+      uint8_t* (*Writer)(int, T, uint8_t*), uint8_t* target);
+
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32ToArray(
+      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64ToArray(
+      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32ToArray(
+      int field_number, const RepeatedField<uint32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64ToArray(
+      int field_number, const RepeatedField<uint64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32ToArray(
+      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64ToArray(
+      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32ToArray(
+      int field_number, const RepeatedField<uint32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64ToArray(
+      int field_number, const RepeatedField<uint64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32ToArray(
+      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64ToArray(
+      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatToArray(
+      int field_number, const RepeatedField<float>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleToArray(
+      int field_number, const RepeatedField<double>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolToArray(
+      int field_number, const RepeatedField<bool>& value, uint8_t* output);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumToArray(
+      int field_number, const RepeatedField<int>& value, uint8_t* output);
+
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteStringToArray(
+      int field_number, const std::string& value, uint8_t* target);
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBytesToArray(
+      int field_number, const std::string& value, uint8_t* target);
+
+  // Whether to serialize deterministically (e.g., map keys are
+  // sorted) is a property of a CodedOutputStream, and in the process
+  // of serialization, the "ToArray" variants may be invoked.  But they don't
+  // have a CodedOutputStream available, so they get an additional parameter
+  // telling them whether to serialize deterministically.
+  static uint8_t* InternalWriteGroup(int field_number, const MessageLite& value,
+                                     uint8_t* target,
+                                     io::EpsCopyOutputStream* stream);
+  static uint8_t* InternalWriteMessage(int field_number,
+                                       const MessageLite& value,
+                                       int cached_size, uint8_t* target,
+                                       io::EpsCopyOutputStream* stream);
+
+  // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
+  // pointer must point at an instance of MessageType, *not* a subclass (or
+  // the subclass must not override SerializeWithCachedSizes()).
+  template <typename MessageType>
+  PROTOBUF_NDEBUG_INLINE static uint8_t* InternalWriteGroupNoVirtualToArray(
+      int field_number, const MessageType& value, uint8_t* target);
+  template <typename MessageType>
+  PROTOBUF_NDEBUG_INLINE static uint8_t* InternalWriteMessageNoVirtualToArray(
+      int field_number, const MessageType& value, uint8_t* target);
+
+  // For backward-compatibility, the last four methods also have versions
+  // that are non-deterministic always.
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteGroupToArray(
+      int field_number, const MessageLite& value, uint8_t* target) {
+    io::EpsCopyOutputStream stream(
+        target,
+        value.GetCachedSize() +
+            static_cast<int>(2 * io::CodedOutputStream::VarintSize32(
+                                     static_cast<uint32_t>(field_number) << 3)),
+        io::CodedOutputStream::IsDefaultSerializationDeterministic());
+    return InternalWriteGroup(field_number, value, target, &stream);
+  }
+  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteMessageToArray(
+      int field_number, const MessageLite& value, uint8_t* target) {
+    int size = value.GetCachedSize();
+    io::EpsCopyOutputStream stream(
+        target,
+        size + static_cast<int>(io::CodedOutputStream::VarintSize32(
+                                    static_cast<uint32_t>(field_number) << 3) +
+                                io::CodedOutputStream::VarintSize32(size)),
+        io::CodedOutputStream::IsDefaultSerializationDeterministic());
+    return InternalWriteMessage(field_number, value, value.GetCachedSize(),
+                                target, &stream);
+  }
+
+  // Compute the byte size of a field.  The XxSize() functions do NOT include
+  // the tag, so you must also call TagSize().  (This is because, for repeated
+  // fields, you should only call TagSize() once and multiply it by the element
+  // count, but you may have to call XxSize() for each individual element.)
+  static inline size_t Int32Size(int32_t value);
+  static inline size_t Int64Size(int64_t value);
+  static inline size_t UInt32Size(uint32_t value);
+  static inline size_t UInt64Size(uint64_t value);
+  static inline size_t SInt32Size(int32_t value);
+  static inline size_t SInt64Size(int64_t value);
+  static inline size_t EnumSize(int value);
+  static inline size_t Int32SizePlusOne(int32_t value);
+  static inline size_t Int64SizePlusOne(int64_t value);
+  static inline size_t UInt32SizePlusOne(uint32_t value);
+  static inline size_t UInt64SizePlusOne(uint64_t value);
+  static inline size_t SInt32SizePlusOne(int32_t value);
+  static inline size_t SInt64SizePlusOne(int64_t value);
+  static inline size_t EnumSizePlusOne(int value);
+
+  static size_t Int32Size(const RepeatedField<int32_t>& value);
+  static size_t Int64Size(const RepeatedField<int64_t>& value);
+  static size_t UInt32Size(const RepeatedField<uint32_t>& value);
+  static size_t UInt64Size(const RepeatedField<uint64_t>& value);
+  static size_t SInt32Size(const RepeatedField<int32_t>& value);
+  static size_t SInt64Size(const RepeatedField<int64_t>& value);
+  static size_t EnumSize(const RepeatedField<int>& value);
+
+  // These types always have the same size.
+  static constexpr size_t kFixed32Size = 4;
+  static constexpr size_t kFixed64Size = 8;
+  static constexpr size_t kSFixed32Size = 4;
+  static constexpr size_t kSFixed64Size = 8;
+  static constexpr size_t kFloatSize = 4;
+  static constexpr size_t kDoubleSize = 8;
+  static constexpr size_t kBoolSize = 1;
+
+  static inline size_t StringSize(const std::string& value);
+  static inline size_t BytesSize(const std::string& value);
+
+  template <typename MessageType>
+  static inline size_t GroupSize(const MessageType& value);
+  template <typename MessageType>
+  static inline size_t MessageSize(const MessageType& value);
+
+  // Like above, but de-virtualize the call to ByteSize().  The
+  // pointer must point at an instance of MessageType, *not* a subclass (or
+  // the subclass must not override ByteSize()).
+  template <typename MessageType>
+  static inline size_t GroupSizeNoVirtual(const MessageType& value);
+  template <typename MessageType>
+  static inline size_t MessageSizeNoVirtual(const MessageType& value);
+
+  // Given the length of data, calculate the byte size of the data on the
+  // wire if we encode the data as a length delimited field.
+  static inline size_t LengthDelimitedSize(size_t length);
+
+ private:
+  // A helper method for the repeated primitive reader. This method has
+  // optimizations for primitive types that have fixed size on the wire, and
+  // can be read using potentially faster paths.
+  template <typename CType, enum FieldType DeclaredType>
+  PROTOBUF_NDEBUG_INLINE static bool ReadRepeatedFixedSizePrimitive(
+      int tag_size, uint32_t tag, io::CodedInputStream* input,
+      RepeatedField<CType>* value);
+
+  // Like ReadRepeatedFixedSizePrimitive but for packed primitive fields.
+  template <typename CType, enum FieldType DeclaredType>
+  PROTOBUF_NDEBUG_INLINE static bool ReadPackedFixedSizePrimitive(
+      io::CodedInputStream* input, RepeatedField<CType>* value);
+
+  static const CppType kFieldTypeToCppTypeMap[];
+  static const WireFormatLite::WireType kWireTypeForFieldType[];
+  static void WriteSubMessageMaybeToArray(int size, const MessageLite& value,
+                                          io::CodedOutputStream* output);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite);
+};
+
+// A class which deals with unknown values.  The default implementation just
+// discards them.  WireFormat defines a subclass which writes to an
+// UnknownFieldSet.  This class is used by ExtensionSet::ParseField(), since
+// ExtensionSet is part of the lite library but UnknownFieldSet is not.
+class PROTOBUF_EXPORT FieldSkipper {
+ public:
+  FieldSkipper() {}
+  virtual ~FieldSkipper() {}
+
+  // Skip a field whose tag has already been consumed.
+  virtual bool SkipField(io::CodedInputStream* input, uint32_t tag);
+
+  // Skip an entire message or group, up to an end-group tag (which is consumed)
+  // or end-of-stream.
+  virtual bool SkipMessage(io::CodedInputStream* input);
+
+  // Deal with an already-parsed unrecognized enum value.  The default
+  // implementation does nothing, but the UnknownFieldSet-based implementation
+  // saves it as an unknown varint.
+  virtual void SkipUnknownEnum(int field_number, int value);
+};
+
+// Subclass of FieldSkipper which saves skipped fields to a CodedOutputStream.
+
+class PROTOBUF_EXPORT CodedOutputStreamFieldSkipper : public FieldSkipper {
+ public:
+  explicit CodedOutputStreamFieldSkipper(io::CodedOutputStream* unknown_fields)
+      : unknown_fields_(unknown_fields) {}
+  ~CodedOutputStreamFieldSkipper() override {}
+
+  // implements FieldSkipper -----------------------------------------
+  bool SkipField(io::CodedInputStream* input, uint32_t tag) override;
+  bool SkipMessage(io::CodedInputStream* input) override;
+  void SkipUnknownEnum(int field_number, int value) override;
+
+ protected:
+  io::CodedOutputStream* unknown_fields_;
+};
+
+// inline methods ====================================================
+
+inline WireFormatLite::CppType WireFormatLite::FieldTypeToCppType(
+    FieldType type) {
+  return kFieldTypeToCppTypeMap[type];
+}
+
+constexpr inline uint32_t WireFormatLite::MakeTag(int field_number,
+                                                  WireType type) {
+  return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
+}
+
+inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32_t tag) {
+  return static_cast<WireType>(tag & kTagTypeMask);
+}
+
+inline int WireFormatLite::GetTagFieldNumber(uint32_t tag) {
+  return static_cast<int>(tag >> kTagTypeBits);
+}
+
+inline size_t WireFormatLite::TagSize(int field_number,
+                                      WireFormatLite::FieldType type) {
+  size_t result = io::CodedOutputStream::VarintSize32(
+      static_cast<uint32_t>(field_number << kTagTypeBits));
+  if (type == TYPE_GROUP) {
+    // Groups have both a start and an end tag.
+    return result * 2;
+  } else {
+    return result;
+  }
+}
+
+inline uint32_t WireFormatLite::EncodeFloat(float value) {
+  return bit_cast<uint32_t>(value);
+}
+
+inline float WireFormatLite::DecodeFloat(uint32_t value) {
+  return bit_cast<float>(value);
+}
+
+inline uint64_t WireFormatLite::EncodeDouble(double value) {
+  return bit_cast<uint64_t>(value);
+}
+
+inline double WireFormatLite::DecodeDouble(uint64_t value) {
+  return bit_cast<double>(value);
+}
+
+// ZigZag Transform:  Encodes signed integers so that they can be
+// effectively used with varint encoding.
+//
+// varint operates on unsigned integers, encoding smaller numbers into
+// fewer bytes.  If you try to use it on a signed integer, it will treat
+// this number as a very large unsigned integer, which means that even
+// small signed numbers like -1 will take the maximum number of bytes
+// (10) to encode.  ZigZagEncode() maps signed integers to unsigned
+// in such a way that those with a small absolute value will have smaller
+// encoded values, making them appropriate for encoding using varint.
+//
+//       int32_t ->     uint32_t
+// -------------------------
+//           0 ->          0
+//          -1 ->          1
+//           1 ->          2
+//          -2 ->          3
+//         ... ->        ...
+//  2147483647 -> 4294967294
+// -2147483648 -> 4294967295
+//
+//        >> encode >>
+//        << decode <<
+
+inline uint32_t WireFormatLite::ZigZagEncode32(int32_t n) {
+  // Note:  the right-shift must be arithmetic
+  // Note:  left shift must be unsigned because of overflow
+  return (static_cast<uint32_t>(n) << 1) ^ static_cast<uint32_t>(n >> 31);
+}
+
+inline int32_t WireFormatLite::ZigZagDecode32(uint32_t n) {
+  // Note:  Using unsigned types prevent undefined behavior
+  return static_cast<int32_t>((n >> 1) ^ (~(n & 1) + 1));
+}
+
+inline uint64_t WireFormatLite::ZigZagEncode64(int64_t n) {
+  // Note:  the right-shift must be arithmetic
+  // Note:  left shift must be unsigned because of overflow
+  return (static_cast<uint64_t>(n) << 1) ^ static_cast<uint64_t>(n >> 63);
+}
+
+inline int64_t WireFormatLite::ZigZagDecode64(uint64_t n) {
+  // Note:  Using unsigned types prevent undefined behavior
+  return static_cast<int64_t>((n >> 1) ^ (~(n & 1) + 1));
+}
+
+// String is for UTF-8 text only, but, even so, ReadString() can simply
+// call ReadBytes().
+
+inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
+                                       std::string* value) {
+  return ReadBytes(input, value);
+}
+
+inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
+                                       std::string** p) {
+  return ReadBytes(input, p);
+}
+
+inline uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
+    const std::string& unknown_fields, uint8_t* target,
+    io::EpsCopyOutputStream* stream) {
+  return stream->WriteRaw(unknown_fields.data(),
+                          static_cast<int>(unknown_fields.size()), target);
+}
+
+inline size_t ComputeUnknownMessageSetItemsSize(
+    const std::string& unknown_fields) {
+  return unknown_fields.size();
+}
+
+// Implementation details of ReadPrimitive.
+
+template <>
+inline bool WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_INT32>(
+    io::CodedInputStream* input, int32_t* value) {
+  uint32_t temp;
+  if (!input->ReadVarint32(&temp)) return false;
+  *value = static_cast<int32_t>(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_INT64>(
+    io::CodedInputStream* input, int64_t* value) {
+  uint64_t temp;
+  if (!input->ReadVarint64(&temp)) return false;
+  *value = static_cast<int64_t>(temp);
+  return true;
+}
+template <>
+inline bool
+WireFormatLite::ReadPrimitive<uint32_t, WireFormatLite::TYPE_UINT32>(
+    io::CodedInputStream* input, uint32_t* value) {
+  return input->ReadVarint32(value);
+}
+template <>
+inline bool
+WireFormatLite::ReadPrimitive<uint64_t, WireFormatLite::TYPE_UINT64>(
+    io::CodedInputStream* input, uint64_t* value) {
+  return input->ReadVarint64(value);
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_SINT32>(
+    io::CodedInputStream* input, int32_t* value) {
+  uint32_t temp;
+  if (!input->ReadVarint32(&temp)) return false;
+  *value = ZigZagDecode32(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_SINT64>(
+    io::CodedInputStream* input, int64_t* value) {
+  uint64_t temp;
+  if (!input->ReadVarint64(&temp)) return false;
+  *value = ZigZagDecode64(temp);
+  return true;
+}
+template <>
+inline bool
+WireFormatLite::ReadPrimitive<uint32_t, WireFormatLite::TYPE_FIXED32>(
+    io::CodedInputStream* input, uint32_t* value) {
+  return input->ReadLittleEndian32(value);
+}
+template <>
+inline bool
+WireFormatLite::ReadPrimitive<uint64_t, WireFormatLite::TYPE_FIXED64>(
+    io::CodedInputStream* input, uint64_t* value) {
+  return input->ReadLittleEndian64(value);
+}
+template <>
+inline bool
+WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_SFIXED32>(
+    io::CodedInputStream* input, int32_t* value) {
+  uint32_t temp;
+  if (!input->ReadLittleEndian32(&temp)) return false;
+  *value = static_cast<int32_t>(temp);
+  return true;
+}
+template <>
+inline bool
+WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_SFIXED64>(
+    io::CodedInputStream* input, int64_t* value) {
+  uint64_t temp;
+  if (!input->ReadLittleEndian64(&temp)) return false;
+  *value = static_cast<int64_t>(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
+    io::CodedInputStream* input, float* value) {
+  uint32_t temp;
+  if (!input->ReadLittleEndian32(&temp)) return false;
+  *value = DecodeFloat(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
+    io::CodedInputStream* input, double* value) {
+  uint64_t temp;
+  if (!input->ReadLittleEndian64(&temp)) return false;
+  *value = DecodeDouble(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
+    io::CodedInputStream* input, bool* value) {
+  uint64_t temp;
+  if (!input->ReadVarint64(&temp)) return false;
+  *value = temp != 0;
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
+    io::CodedInputStream* input, int* value) {
+  uint32_t temp;
+  if (!input->ReadVarint32(&temp)) return false;
+  *value = static_cast<int>(temp);
+  return true;
+}
+
+template <>
+inline const uint8_t*
+WireFormatLite::ReadPrimitiveFromArray<uint32_t, WireFormatLite::TYPE_FIXED32>(
+    const uint8_t* buffer, uint32_t* value) {
+  return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
+}
+template <>
+inline const uint8_t*
+WireFormatLite::ReadPrimitiveFromArray<uint64_t, WireFormatLite::TYPE_FIXED64>(
+    const uint8_t* buffer, uint64_t* value) {
+  return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
+}
+template <>
+inline const uint8_t*
+WireFormatLite::ReadPrimitiveFromArray<int32_t, WireFormatLite::TYPE_SFIXED32>(
+    const uint8_t* buffer, int32_t* value) {
+  uint32_t temp;
+  buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
+  *value = static_cast<int32_t>(temp);
+  return buffer;
+}
+template <>
+inline const uint8_t*
+WireFormatLite::ReadPrimitiveFromArray<int64_t, WireFormatLite::TYPE_SFIXED64>(
+    const uint8_t* buffer, int64_t* value) {
+  uint64_t temp;
+  buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
+  *value = static_cast<int64_t>(temp);
+  return buffer;
+}
+template <>
+inline const uint8_t*
+WireFormatLite::ReadPrimitiveFromArray<float, WireFormatLite::TYPE_FLOAT>(
+    const uint8_t* buffer, float* value) {
+  uint32_t temp;
+  buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
+  *value = DecodeFloat(temp);
+  return buffer;
+}
+template <>
+inline const uint8_t*
+WireFormatLite::ReadPrimitiveFromArray<double, WireFormatLite::TYPE_DOUBLE>(
+    const uint8_t* buffer, double* value) {
+  uint64_t temp;
+  buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
+  *value = DecodeDouble(temp);
+  return buffer;
+}
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+inline bool WireFormatLite::ReadRepeatedPrimitive(
+    int,  // tag_size, unused.
+    uint32_t tag, io::CodedInputStream* input, RepeatedField<CType>* values) {
+  CType value;
+  if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+  values->Add(value);
+  int elements_already_reserved = values->Capacity() - values->size();
+  while (elements_already_reserved > 0 && input->ExpectTag(tag)) {
+    if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+    values->AddAlreadyReserved(value);
+    elements_already_reserved--;
+  }
+  return true;
+}
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
+    int tag_size, uint32_t tag, io::CodedInputStream* input,
+    RepeatedField<CType>* values) {
+  GOOGLE_DCHECK_EQ(UInt32Size(tag), static_cast<size_t>(tag_size));
+  CType value;
+  if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+  values->Add(value);
+
+  // For fixed size values, repeated values can be read more quickly by
+  // reading directly from a raw array.
+  //
+  // We can get a tight loop by only reading as many elements as can be
+  // added to the RepeatedField without having to do any resizing. Additionally,
+  // we only try to read as many elements as are available from the current
+  // buffer space. Doing so avoids having to perform boundary checks when
+  // reading the value: the maximum number of elements that can be read is
+  // known outside of the loop.
+  const void* void_pointer;
+  int size;
+  input->GetDirectBufferPointerInline(&void_pointer, &size);
+  if (size > 0) {
+    const uint8_t* buffer = reinterpret_cast<const uint8_t*>(void_pointer);
+    // The number of bytes each type occupies on the wire.
+    const int per_value_size = tag_size + static_cast<int>(sizeof(value));
+
+    // parentheses around (std::min) prevents macro expansion of min(...)
+    int elements_available =
+        (std::min)(values->Capacity() - values->size(), size / per_value_size);
+    int num_read = 0;
+    while (num_read < elements_available &&
+           (buffer = io::CodedInputStream::ExpectTagFromArray(buffer, tag)) !=
+               nullptr) {
+      buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
+      values->AddAlreadyReserved(value);
+      ++num_read;
+    }
+    const int read_bytes = num_read * per_value_size;
+    if (read_bytes > 0) {
+      input->Skip(read_bytes);
+    }
+  }
+  return true;
+}
+
+// Specializations of ReadRepeatedPrimitive for the fixed size types, which use
+// the optimized code path.
+#define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)        \
+  template <>                                                             \
+  inline bool WireFormatLite::ReadRepeatedPrimitive<                      \
+      CPPTYPE, WireFormatLite::DECLARED_TYPE>(                            \
+      int tag_size, uint32_t tag, io::CodedInputStream* input,            \
+      RepeatedField<CPPTYPE>* values) {                                   \
+    return ReadRepeatedFixedSizePrimitive<CPPTYPE,                        \
+                                          WireFormatLite::DECLARED_TYPE>( \
+        tag_size, tag, input, values);                                    \
+  }
+
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32_t, TYPE_FIXED32)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64_t, TYPE_FIXED64)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32_t, TYPE_SFIXED32)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64_t, TYPE_SFIXED64)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
+
+#undef READ_REPEATED_FIXED_SIZE_PRIMITIVE
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
+    int tag_size, uint32_t tag, io::CodedInputStream* input,
+    RepeatedField<CType>* value) {
+  return ReadRepeatedPrimitive<CType, DeclaredType>(tag_size, tag, input,
+                                                    value);
+}
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+inline bool WireFormatLite::ReadPackedPrimitive(io::CodedInputStream* input,
+                                                RepeatedField<CType>* values) {
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
+  io::CodedInputStream::Limit limit = input->PushLimit(length);
+  while (input->BytesUntilLimit() > 0) {
+    CType value;
+    if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+    values->Add(value);
+  }
+  input->PopLimit(limit);
+  return true;
+}
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+inline bool WireFormatLite::ReadPackedFixedSizePrimitive(
+    io::CodedInputStream* input, RepeatedField<CType>* values) {
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
+  const int old_entries = values->size();
+  const int new_entries = length / static_cast<int>(sizeof(CType));
+  const int new_bytes = new_entries * static_cast<int>(sizeof(CType));
+  if (new_bytes != length) return false;
+  // We would *like* to pre-allocate the buffer to write into (for
+  // speed), but *must* avoid performing a very large allocation due
+  // to a malicious user-supplied "length" above.  So we have a fast
+  // path that pre-allocates when the "length" is less than a bound.
+  // We determine the bound by calling BytesUntilTotalBytesLimit() and
+  // BytesUntilLimit().  These return -1 to mean "no limit set".
+  // There are four cases:
+  // TotalBytesLimit  Limit
+  // -1               -1     Use slow path.
+  // -1               >= 0   Use fast path if length <= Limit.
+  // >= 0             -1     Use slow path.
+  // >= 0             >= 0   Use fast path if length <= min(both limits).
+  int64_t bytes_limit = input->BytesUntilTotalBytesLimit();
+  if (bytes_limit == -1) {
+    bytes_limit = input->BytesUntilLimit();
+  } else {
+    // parentheses around (std::min) prevents macro expansion of min(...)
+    bytes_limit =
+        (std::min)(bytes_limit, static_cast<int64_t>(input->BytesUntilLimit()));
+  }
+  if (bytes_limit >= new_bytes) {
+    // Fast-path that pre-allocates *values to the final size.
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+    values->Resize(old_entries + new_entries, 0);
+    // values->mutable_data() may change after Resize(), so do this after:
+    void* dest = reinterpret_cast<void*>(values->mutable_data() + old_entries);
+    if (!input->ReadRaw(dest, new_bytes)) {
+      values->Truncate(old_entries);
+      return false;
+    }
+#else
+    values->Reserve(old_entries + new_entries);
+    CType value;
+    for (int i = 0; i < new_entries; ++i) {
+      if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+      values->AddAlreadyReserved(value);
+    }
+#endif
+  } else {
+    // This is the slow-path case where "length" may be too large to
+    // safely allocate.  We read as much as we can into *values
+    // without pre-allocating "length" bytes.
+    CType value;
+    for (int i = 0; i < new_entries; ++i) {
+      if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+      values->Add(value);
+    }
+  }
+  return true;
+}
+
+// Specializations of ReadPackedPrimitive for the fixed size types, which use
+// an optimized code path.
+#define READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)      \
+  template <>                                                                  \
+  inline bool                                                                  \
+  WireFormatLite::ReadPackedPrimitive<CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
+      io::CodedInputStream * input, RepeatedField<CPPTYPE> * values) {         \
+    return ReadPackedFixedSizePrimitive<CPPTYPE,                               \
+                                        WireFormatLite::DECLARED_TYPE>(        \
+        input, values);                                                        \
+  }
+
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint32_t, TYPE_FIXED32)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint64_t, TYPE_FIXED64)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int32_t, TYPE_SFIXED32)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int64_t, TYPE_SFIXED64)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
+
+#undef READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
+                                                 RepeatedField<CType>* values) {
+  return ReadPackedPrimitive<CType, DeclaredType>(input, values);
+}
+
+
+template <typename MessageType>
+inline bool WireFormatLite::ReadGroup(int field_number,
+                                      io::CodedInputStream* input,
+                                      MessageType* value) {
+  if (!input->IncrementRecursionDepth()) return false;
+  if (!value->MergePartialFromCodedStream(input)) return false;
+  input->UnsafeDecrementRecursionDepth();
+  // Make sure the last thing read was an end tag for this group.
+  if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
+    return false;
+  }
+  return true;
+}
+template <typename MessageType>
+inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input,
+                                        MessageType* value) {
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
+  std::pair<io::CodedInputStream::Limit, int> p =
+      input->IncrementRecursionDepthAndPushLimit(length);
+  if (p.second < 0 || !value->MergePartialFromCodedStream(input)) return false;
+  // Make sure that parsing stopped when the limit was hit, not at an endgroup
+  // tag.
+  return input->DecrementRecursionDepthAndPopLimit(p.first);
+}
+
+// ===================================================================
+
+inline void WireFormatLite::WriteTag(int field_number, WireType type,
+                                     io::CodedOutputStream* output) {
+  output->WriteTag(MakeTag(field_number, type));
+}
+
+inline void WireFormatLite::WriteInt32NoTag(int32_t value,
+                                            io::CodedOutputStream* output) {
+  output->WriteVarint32SignExtended(value);
+}
+inline void WireFormatLite::WriteInt64NoTag(int64_t value,
+                                            io::CodedOutputStream* output) {
+  output->WriteVarint64(static_cast<uint64_t>(value));
+}
+inline void WireFormatLite::WriteUInt32NoTag(uint32_t value,
+                                             io::CodedOutputStream* output) {
+  output->WriteVarint32(value);
+}
+inline void WireFormatLite::WriteUInt64NoTag(uint64_t value,
+                                             io::CodedOutputStream* output) {
+  output->WriteVarint64(value);
+}
+inline void WireFormatLite::WriteSInt32NoTag(int32_t value,
+                                             io::CodedOutputStream* output) {
+  output->WriteVarint32(ZigZagEncode32(value));
+}
+inline void WireFormatLite::WriteSInt64NoTag(int64_t value,
+                                             io::CodedOutputStream* output) {
+  output->WriteVarint64(ZigZagEncode64(value));
+}
+inline void WireFormatLite::WriteFixed32NoTag(uint32_t value,
+                                              io::CodedOutputStream* output) {
+  output->WriteLittleEndian32(value);
+}
+inline void WireFormatLite::WriteFixed64NoTag(uint64_t value,
+                                              io::CodedOutputStream* output) {
+  output->WriteLittleEndian64(value);
+}
+inline void WireFormatLite::WriteSFixed32NoTag(int32_t value,
+                                               io::CodedOutputStream* output) {
+  output->WriteLittleEndian32(static_cast<uint32_t>(value));
+}
+inline void WireFormatLite::WriteSFixed64NoTag(int64_t value,
+                                               io::CodedOutputStream* output) {
+  output->WriteLittleEndian64(static_cast<uint64_t>(value));
+}
+inline void WireFormatLite::WriteFloatNoTag(float value,
+                                            io::CodedOutputStream* output) {
+  output->WriteLittleEndian32(EncodeFloat(value));
+}
+inline void WireFormatLite::WriteDoubleNoTag(double value,
+                                             io::CodedOutputStream* output) {
+  output->WriteLittleEndian64(EncodeDouble(value));
+}
+inline void WireFormatLite::WriteBoolNoTag(bool value,
+                                           io::CodedOutputStream* output) {
+  output->WriteVarint32(value ? 1 : 0);
+}
+inline void WireFormatLite::WriteEnumNoTag(int value,
+                                           io::CodedOutputStream* output) {
+  output->WriteVarint32SignExtended(value);
+}
+
+// See comment on ReadGroupNoVirtual to understand the need for this template
+// parameter name.
+template <typename MessageType_WorkAroundCppLookupDefect>
+inline void WireFormatLite::WriteGroupNoVirtual(
+    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
+    io::CodedOutputStream* output) {
+  WriteTag(field_number, WIRETYPE_START_GROUP, output);
+  value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
+  WriteTag(field_number, WIRETYPE_END_GROUP, output);
+}
+template <typename MessageType_WorkAroundCppLookupDefect>
+inline void WireFormatLite::WriteMessageNoVirtual(
+    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
+    io::CodedOutputStream* output) {
+  WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
+  output->WriteVarint32(
+      value.MessageType_WorkAroundCppLookupDefect::GetCachedSize());
+  value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
+}
+
+// ===================================================================
+
+inline uint8_t* WireFormatLite::WriteTagToArray(int field_number, WireType type,
+                                                uint8_t* target) {
+  return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
+                                                target);
+}
+
+inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(int32_t value,
+                                                       uint8_t* target) {
+  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(int64_t value,
+                                                       uint8_t* target) {
+  return io::CodedOutputStream::WriteVarint64ToArray(
+      static_cast<uint64_t>(value), target);
+}
+inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(uint32_t value,
+                                                        uint8_t* target) {
+  return io::CodedOutputStream::WriteVarint32ToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(uint64_t value,
+                                                        uint8_t* target) {
+  return io::CodedOutputStream::WriteVarint64ToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(int32_t value,
+                                                        uint8_t* target) {
+  return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value),
+                                                     target);
+}
+inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(int64_t value,
+                                                        uint8_t* target) {
+  return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
+                                                     target);
+}
+inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(uint32_t value,
+                                                         uint8_t* target) {
+  return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(uint64_t value,
+                                                         uint8_t* target) {
+  return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(int32_t value,
+                                                          uint8_t* target) {
+  return io::CodedOutputStream::WriteLittleEndian32ToArray(
+      static_cast<uint32_t>(value), target);
+}
+inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(int64_t value,
+                                                          uint8_t* target) {
+  return io::CodedOutputStream::WriteLittleEndian64ToArray(
+      static_cast<uint64_t>(value), target);
+}
+inline uint8_t* WireFormatLite::WriteFloatNoTagToArray(float value,
+                                                       uint8_t* target) {
+  return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
+                                                           target);
+}
+inline uint8_t* WireFormatLite::WriteDoubleNoTagToArray(double value,
+                                                        uint8_t* target) {
+  return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value),
+                                                           target);
+}
+inline uint8_t* WireFormatLite::WriteBoolNoTagToArray(bool value,
+                                                      uint8_t* target) {
+  return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
+}
+inline uint8_t* WireFormatLite::WriteEnumNoTagToArray(int value,
+                                                      uint8_t* target) {
+  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
+}
+
+template <typename T>
+inline uint8_t* WireFormatLite::WritePrimitiveNoTagToArray(
+    const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*),
+    uint8_t* target) {
+  const int n = value.size();
+  GOOGLE_DCHECK_GT(n, 0);
+
+  const T* ii = value.data();
+  int i = 0;
+  do {
+    target = Writer(ii[i], target);
+  } while (++i < n);
+
+  return target;
+}
+
+template <typename T>
+inline uint8_t* WireFormatLite::WriteFixedNoTagToArray(
+    const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*),
+    uint8_t* target) {
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+  (void)Writer;
+
+  const int n = value.size();
+  GOOGLE_DCHECK_GT(n, 0);
+
+  const T* ii = value.data();
+  const int bytes = n * static_cast<int>(sizeof(ii[0]));
+  memcpy(target, ii, static_cast<size_t>(bytes));
+  return target + bytes;
+#else
+  return WritePrimitiveNoTagToArray(value, Writer, target);
+#endif
+}
+
+inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(
+    const RepeatedField<int32_t>& value, uint8_t* target) {
+  return WritePrimitiveNoTagToArray(value, WriteInt32NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(
+    const RepeatedField<int64_t>& value, uint8_t* target) {
+  return WritePrimitiveNoTagToArray(value, WriteInt64NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(
+    const RepeatedField<uint32_t>& value, uint8_t* target) {
+  return WritePrimitiveNoTagToArray(value, WriteUInt32NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(
+    const RepeatedField<uint64_t>& value, uint8_t* target) {
+  return WritePrimitiveNoTagToArray(value, WriteUInt64NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(
+    const RepeatedField<int32_t>& value, uint8_t* target) {
+  return WritePrimitiveNoTagToArray(value, WriteSInt32NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(
+    const RepeatedField<int64_t>& value, uint8_t* target) {
+  return WritePrimitiveNoTagToArray(value, WriteSInt64NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(
+    const RepeatedField<uint32_t>& value, uint8_t* target) {
+  return WriteFixedNoTagToArray(value, WriteFixed32NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(
+    const RepeatedField<uint64_t>& value, uint8_t* target) {
+  return WriteFixedNoTagToArray(value, WriteFixed64NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(
+    const RepeatedField<int32_t>& value, uint8_t* target) {
+  return WriteFixedNoTagToArray(value, WriteSFixed32NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(
+    const RepeatedField<int64_t>& value, uint8_t* target) {
+  return WriteFixedNoTagToArray(value, WriteSFixed64NoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteFloatNoTagToArray(
+    const RepeatedField<float>& value, uint8_t* target) {
+  return WriteFixedNoTagToArray(value, WriteFloatNoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteDoubleNoTagToArray(
+    const RepeatedField<double>& value, uint8_t* target) {
+  return WriteFixedNoTagToArray(value, WriteDoubleNoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteBoolNoTagToArray(
+    const RepeatedField<bool>& value, uint8_t* target) {
+  return WritePrimitiveNoTagToArray(value, WriteBoolNoTagToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteEnumNoTagToArray(
+    const RepeatedField<int>& value, uint8_t* target) {
+  return WritePrimitiveNoTagToArray(value, WriteEnumNoTagToArray, target);
+}
+
+inline uint8_t* WireFormatLite::WriteInt32ToArray(int field_number,
+                                                  int32_t value,
+                                                  uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteInt32NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteInt64ToArray(int field_number,
+                                                  int64_t value,
+                                                  uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteInt64NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteUInt32ToArray(int field_number,
+                                                   uint32_t value,
+                                                   uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteUInt32NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteUInt64ToArray(int field_number,
+                                                   uint64_t value,
+                                                   uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteUInt64NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteSInt32ToArray(int field_number,
+                                                   int32_t value,
+                                                   uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteSInt32NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteSInt64ToArray(int field_number,
+                                                   int64_t value,
+                                                   uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteSInt64NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteFixed32ToArray(int field_number,
+                                                    uint32_t value,
+                                                    uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+  return WriteFixed32NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteFixed64ToArray(int field_number,
+                                                    uint64_t value,
+                                                    uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+  return WriteFixed64NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteSFixed32ToArray(int field_number,
+                                                     int32_t value,
+                                                     uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+  return WriteSFixed32NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteSFixed64ToArray(int field_number,
+                                                     int64_t value,
+                                                     uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+  return WriteSFixed64NoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteFloatToArray(int field_number, float value,
+                                                  uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+  return WriteFloatNoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteDoubleToArray(int field_number,
+                                                   double value,
+                                                   uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+  return WriteDoubleNoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteBoolToArray(int field_number, bool value,
+                                                 uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteBoolNoTagToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteEnumToArray(int field_number, int value,
+                                                 uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteEnumNoTagToArray(value, target);
+}
+
+template <typename T>
+inline uint8_t* WireFormatLite::WritePrimitiveToArray(
+    int field_number, const RepeatedField<T>& value,
+    uint8_t* (*Writer)(int, T, uint8_t*), uint8_t* target) {
+  const int n = value.size();
+  if (n == 0) {
+    return target;
+  }
+
+  const T* ii = value.data();
+  int i = 0;
+  do {
+    target = Writer(field_number, ii[i], target);
+  } while (++i < n);
+
+  return target;
+}
+
+inline uint8_t* WireFormatLite::WriteInt32ToArray(
+    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteInt32ToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteInt64ToArray(
+    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteInt64ToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteUInt32ToArray(
+    int field_number, const RepeatedField<uint32_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteUInt32ToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteUInt64ToArray(
+    int field_number, const RepeatedField<uint64_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteUInt64ToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteSInt32ToArray(
+    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteSInt32ToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteSInt64ToArray(
+    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteSInt64ToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteFixed32ToArray(
+    int field_number, const RepeatedField<uint32_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteFixed32ToArray,
+                               target);
+}
+inline uint8_t* WireFormatLite::WriteFixed64ToArray(
+    int field_number, const RepeatedField<uint64_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteFixed64ToArray,
+                               target);
+}
+inline uint8_t* WireFormatLite::WriteSFixed32ToArray(
+    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteSFixed32ToArray,
+                               target);
+}
+inline uint8_t* WireFormatLite::WriteSFixed64ToArray(
+    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteSFixed64ToArray,
+                               target);
+}
+inline uint8_t* WireFormatLite::WriteFloatToArray(
+    int field_number, const RepeatedField<float>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteFloatToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteDoubleToArray(
+    int field_number, const RepeatedField<double>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteDoubleToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteBoolToArray(
+    int field_number, const RepeatedField<bool>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteBoolToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteEnumToArray(
+    int field_number, const RepeatedField<int>& value, uint8_t* target) {
+  return WritePrimitiveToArray(field_number, value, WriteEnumToArray, target);
+}
+inline uint8_t* WireFormatLite::WriteStringToArray(int field_number,
+                                                   const std::string& value,
+                                                   uint8_t* target) {
+  // String is for UTF-8 text only
+  // WARNING:  In wire_format.cc, both strings and bytes are handled by
+  //   WriteString() to avoid code duplication.  If the implementations become
+  //   different, you will need to update that usage.
+  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+  return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
+}
+inline uint8_t* WireFormatLite::WriteBytesToArray(int field_number,
+                                                  const std::string& value,
+                                                  uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+  return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
+}
+
+
+// See comment on ReadGroupNoVirtual to understand the need for this template
+// parameter name.
+template <typename MessageType_WorkAroundCppLookupDefect>
+inline uint8_t* WireFormatLite::InternalWriteGroupNoVirtualToArray(
+    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
+    uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
+  target = value.MessageType_WorkAroundCppLookupDefect::
+               SerializeWithCachedSizesToArray(target);
+  return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
+}
+template <typename MessageType_WorkAroundCppLookupDefect>
+inline uint8_t* WireFormatLite::InternalWriteMessageNoVirtualToArray(
+    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
+    uint8_t* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+  target = io::CodedOutputStream::WriteVarint32ToArray(
+      static_cast<uint32_t>(
+          value.MessageType_WorkAroundCppLookupDefect::GetCachedSize()),
+      target);
+  return value
+      .MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizesToArray(
+          target);
+}
+
+// ===================================================================
+
+inline size_t WireFormatLite::Int32Size(int32_t value) {
+  return io::CodedOutputStream::VarintSize32SignExtended(value);
+}
+inline size_t WireFormatLite::Int64Size(int64_t value) {
+  return io::CodedOutputStream::VarintSize64(static_cast<uint64_t>(value));
+}
+inline size_t WireFormatLite::UInt32Size(uint32_t value) {
+  return io::CodedOutputStream::VarintSize32(value);
+}
+inline size_t WireFormatLite::UInt64Size(uint64_t value) {
+  return io::CodedOutputStream::VarintSize64(value);
+}
+inline size_t WireFormatLite::SInt32Size(int32_t value) {
+  return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
+}
+inline size_t WireFormatLite::SInt64Size(int64_t value) {
+  return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
+}
+inline size_t WireFormatLite::EnumSize(int value) {
+  return io::CodedOutputStream::VarintSize32SignExtended(value);
+}
+inline size_t WireFormatLite::Int32SizePlusOne(int32_t value) {
+  return io::CodedOutputStream::VarintSize32SignExtendedPlusOne(value);
+}
+inline size_t WireFormatLite::Int64SizePlusOne(int64_t value) {
+  return io::CodedOutputStream::VarintSize64PlusOne(
+      static_cast<uint64_t>(value));
+}
+inline size_t WireFormatLite::UInt32SizePlusOne(uint32_t value) {
+  return io::CodedOutputStream::VarintSize32PlusOne(value);
+}
+inline size_t WireFormatLite::UInt64SizePlusOne(uint64_t value) {
+  return io::CodedOutputStream::VarintSize64PlusOne(value);
+}
+inline size_t WireFormatLite::SInt32SizePlusOne(int32_t value) {
+  return io::CodedOutputStream::VarintSize32PlusOne(ZigZagEncode32(value));
+}
+inline size_t WireFormatLite::SInt64SizePlusOne(int64_t value) {
+  return io::CodedOutputStream::VarintSize64PlusOne(ZigZagEncode64(value));
+}
+inline size_t WireFormatLite::EnumSizePlusOne(int value) {
+  return io::CodedOutputStream::VarintSize32SignExtendedPlusOne(value);
+}
+
+inline size_t WireFormatLite::StringSize(const std::string& value) {
+  return LengthDelimitedSize(value.size());
+}
+inline size_t WireFormatLite::BytesSize(const std::string& value) {
+  return LengthDelimitedSize(value.size());
+}
+
+
+template <typename MessageType>
+inline size_t WireFormatLite::GroupSize(const MessageType& value) {
+  return value.ByteSizeLong();
+}
+template <typename MessageType>
+inline size_t WireFormatLite::MessageSize(const MessageType& value) {
+  return LengthDelimitedSize(value.ByteSizeLong());
+}
+
+// See comment on ReadGroupNoVirtual to understand the need for this template
+// parameter name.
+template <typename MessageType_WorkAroundCppLookupDefect>
+inline size_t WireFormatLite::GroupSizeNoVirtual(
+    const MessageType_WorkAroundCppLookupDefect& value) {
+  return value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong();
+}
+template <typename MessageType_WorkAroundCppLookupDefect>
+inline size_t WireFormatLite::MessageSizeNoVirtual(
+    const MessageType_WorkAroundCppLookupDefect& value) {
+  return LengthDelimitedSize(
+      value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong());
+}
+
+inline size_t WireFormatLite::LengthDelimitedSize(size_t length) {
+  // The static_cast here prevents an error in certain compiler configurations
+  // but is not technically correct--if length is too large to fit in a uint32_t
+  // then it will be silently truncated. We will need to fix this if we ever
+  // decide to start supporting serialized messages greater than 2 GiB in size.
+  return length +
+         io::CodedOutputStream::VarintSize32(static_cast<uint32_t>(length));
+}
+
+template <typename MS>
+bool ParseMessageSetItemImpl(io::CodedInputStream* input, MS ms) {
+  // This method parses a group which should contain two fields:
+  //   required int32 type_id = 2;
+  //   required data message = 3;
+
+  uint32_t last_type_id = 0;
+
+  // If we see message data before the type_id, we'll append it to this so
+  // we can parse it later.
+  std::string message_data;
+
+  enum class State { kNoTag, kHasType, kHasPayload, kDone };
+  State state = State::kNoTag;
+
+  while (true) {
+    const uint32_t tag = input->ReadTagNoLastTag();
+    if (tag == 0) return false;
+
+    switch (tag) {
+      case WireFormatLite::kMessageSetTypeIdTag: {
+        uint32_t type_id;
+        if (!input->ReadVarint32(&type_id)) return false;
+        if (state == State::kNoTag) {
+          last_type_id = type_id;
+          state = State::kHasType;
+        } else if (state == State::kHasPayload) {
+          // We saw some message data before the type_id.  Have to parse it
+          // now.
+          io::CodedInputStream sub_input(
+              reinterpret_cast<const uint8_t*>(message_data.data()),
+              static_cast<int>(message_data.size()));
+          sub_input.SetRecursionLimit(input->RecursionBudget());
+          if (!ms.ParseField(type_id, &sub_input)) {
+            return false;
+          }
+          message_data.clear();
+          state = State::kDone;
+        }
+
+        break;
+      }
+
+      case WireFormatLite::kMessageSetMessageTag: {
+        if (state == State::kHasType) {
+          // Already saw type_id, so we can parse this directly.
+          if (!ms.ParseField(last_type_id, input)) {
+            return false;
+          }
+          state = State::kDone;
+        } else if (state == State::kNoTag) {
+          // We haven't seen a type_id yet.  Append this data to message_data.
+          uint32_t length;
+          if (!input->ReadVarint32(&length)) return false;
+          if (static_cast<int32_t>(length) < 0) return false;
+          uint32_t size = static_cast<uint32_t>(
+              length + io::CodedOutputStream::VarintSize32(length));
+          message_data.resize(size);
+          auto ptr = reinterpret_cast<uint8_t*>(&message_data[0]);
+          ptr = io::CodedOutputStream::WriteVarint32ToArray(length, ptr);
+          if (!input->ReadRaw(ptr, length)) return false;
+          state = State::kHasPayload;
+        } else {
+          if (!ms.SkipField(tag, input)) return false;
+        }
+
+        break;
+      }
+
+      case WireFormatLite::kMessageSetItemEndTag: {
+        return true;
+      }
+
+      default: {
+        if (!ms.SkipField(tag, input)) return false;
+      }
+    }
+  }
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
+#endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/wrappers.pb.h b/CAPI/cpp/grpc/include/google/protobuf/wrappers.pb.h
new file mode 100644
index 0000000..cc42a8b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/wrappers.pb.h
@@ -0,0 +1,1741 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/wrappers.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fwrappers_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fwrappers_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3021000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3021006 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fwrappers_2eproto PROTOBUF_EXPORT
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fwrappers_2eproto {
+  static const uint32_t offsets[];
+};
+PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fwrappers_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+class BoolValue;
+struct BoolValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern BoolValueDefaultTypeInternal _BoolValue_default_instance_;
+class BytesValue;
+struct BytesValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern BytesValueDefaultTypeInternal _BytesValue_default_instance_;
+class DoubleValue;
+struct DoubleValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern DoubleValueDefaultTypeInternal _DoubleValue_default_instance_;
+class FloatValue;
+struct FloatValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern FloatValueDefaultTypeInternal _FloatValue_default_instance_;
+class Int32Value;
+struct Int32ValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern Int32ValueDefaultTypeInternal _Int32Value_default_instance_;
+class Int64Value;
+struct Int64ValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern Int64ValueDefaultTypeInternal _Int64Value_default_instance_;
+class StringValue;
+struct StringValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern StringValueDefaultTypeInternal _StringValue_default_instance_;
+class UInt32Value;
+struct UInt32ValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern UInt32ValueDefaultTypeInternal _UInt32Value_default_instance_;
+class UInt64Value;
+struct UInt64ValueDefaultTypeInternal;
+PROTOBUF_EXPORT extern UInt64ValueDefaultTypeInternal _UInt64Value_default_instance_;
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::BoolValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::BytesValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BytesValue>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DoubleValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DoubleValue>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FloatValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FloatValue>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Int32Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Int32Value>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Int64Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Int64Value>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::StringValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::StringValue>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UInt32Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt32Value>(Arena*);
+template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UInt64Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt64Value>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+PROTOBUF_NAMESPACE_OPEN
+
+// ===================================================================
+
+class PROTOBUF_EXPORT DoubleValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DoubleValue) */ {
+ public:
+  inline DoubleValue() : DoubleValue(nullptr) {}
+  ~DoubleValue() override;
+  explicit PROTOBUF_CONSTEXPR DoubleValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DoubleValue(const DoubleValue& from);
+  DoubleValue(DoubleValue&& from) noexcept
+    : DoubleValue() {
+    *this = ::std::move(from);
+  }
+
+  inline DoubleValue& operator=(const DoubleValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DoubleValue& operator=(DoubleValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DoubleValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DoubleValue* internal_default_instance() {
+    return reinterpret_cast<const DoubleValue*>(
+               &_DoubleValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DoubleValue& a, DoubleValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DoubleValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DoubleValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DoubleValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DoubleValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DoubleValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DoubleValue& from) {
+    DoubleValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DoubleValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.DoubleValue";
+  }
+  protected:
+  explicit DoubleValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // double value = 1;
+  void clear_value();
+  double value() const;
+  void set_value(double value);
+  private:
+  double _internal_value() const;
+  void _internal_set_value(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.DoubleValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    double value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT FloatValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FloatValue) */ {
+ public:
+  inline FloatValue() : FloatValue(nullptr) {}
+  ~FloatValue() override;
+  explicit PROTOBUF_CONSTEXPR FloatValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FloatValue(const FloatValue& from);
+  FloatValue(FloatValue&& from) noexcept
+    : FloatValue() {
+    *this = ::std::move(from);
+  }
+
+  inline FloatValue& operator=(const FloatValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FloatValue& operator=(FloatValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FloatValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FloatValue* internal_default_instance() {
+    return reinterpret_cast<const FloatValue*>(
+               &_FloatValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(FloatValue& a, FloatValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FloatValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FloatValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FloatValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FloatValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FloatValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const FloatValue& from) {
+    FloatValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FloatValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.FloatValue";
+  }
+  protected:
+  explicit FloatValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // float value = 1;
+  void clear_value();
+  float value() const;
+  void set_value(float value);
+  private:
+  float _internal_value() const;
+  void _internal_set_value(float value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FloatValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    float value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Int64Value final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int64Value) */ {
+ public:
+  inline Int64Value() : Int64Value(nullptr) {}
+  ~Int64Value() override;
+  explicit PROTOBUF_CONSTEXPR Int64Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Int64Value(const Int64Value& from);
+  Int64Value(Int64Value&& from) noexcept
+    : Int64Value() {
+    *this = ::std::move(from);
+  }
+
+  inline Int64Value& operator=(const Int64Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Int64Value& operator=(Int64Value&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Int64Value& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Int64Value* internal_default_instance() {
+    return reinterpret_cast<const Int64Value*>(
+               &_Int64Value_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(Int64Value& a, Int64Value& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Int64Value* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Int64Value* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Int64Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Int64Value>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Int64Value& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Int64Value& from) {
+    Int64Value::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Int64Value* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Int64Value";
+  }
+  protected:
+  explicit Int64Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // int64 value = 1;
+  void clear_value();
+  int64_t value() const;
+  void set_value(int64_t value);
+  private:
+  int64_t _internal_value() const;
+  void _internal_set_value(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Int64Value)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT UInt64Value final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt64Value) */ {
+ public:
+  inline UInt64Value() : UInt64Value(nullptr) {}
+  ~UInt64Value() override;
+  explicit PROTOBUF_CONSTEXPR UInt64Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  UInt64Value(const UInt64Value& from);
+  UInt64Value(UInt64Value&& from) noexcept
+    : UInt64Value() {
+    *this = ::std::move(from);
+  }
+
+  inline UInt64Value& operator=(const UInt64Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline UInt64Value& operator=(UInt64Value&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const UInt64Value& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const UInt64Value* internal_default_instance() {
+    return reinterpret_cast<const UInt64Value*>(
+               &_UInt64Value_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(UInt64Value& a, UInt64Value& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(UInt64Value* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(UInt64Value* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  UInt64Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<UInt64Value>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const UInt64Value& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const UInt64Value& from) {
+    UInt64Value::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(UInt64Value* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.UInt64Value";
+  }
+  protected:
+  explicit UInt64Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // uint64 value = 1;
+  void clear_value();
+  uint64_t value() const;
+  void set_value(uint64_t value);
+  private:
+  uint64_t _internal_value() const;
+  void _internal_set_value(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.UInt64Value)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    uint64_t value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT Int32Value final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int32Value) */ {
+ public:
+  inline Int32Value() : Int32Value(nullptr) {}
+  ~Int32Value() override;
+  explicit PROTOBUF_CONSTEXPR Int32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Int32Value(const Int32Value& from);
+  Int32Value(Int32Value&& from) noexcept
+    : Int32Value() {
+    *this = ::std::move(from);
+  }
+
+  inline Int32Value& operator=(const Int32Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Int32Value& operator=(Int32Value&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Int32Value& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Int32Value* internal_default_instance() {
+    return reinterpret_cast<const Int32Value*>(
+               &_Int32Value_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(Int32Value& a, Int32Value& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Int32Value* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Int32Value* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Int32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Int32Value>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Int32Value& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const Int32Value& from) {
+    Int32Value::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Int32Value* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.Int32Value";
+  }
+  protected:
+  explicit Int32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // int32 value = 1;
+  void clear_value();
+  int32_t value() const;
+  void set_value(int32_t value);
+  private:
+  int32_t _internal_value() const;
+  void _internal_set_value(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Int32Value)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int32_t value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT UInt32Value final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt32Value) */ {
+ public:
+  inline UInt32Value() : UInt32Value(nullptr) {}
+  ~UInt32Value() override;
+  explicit PROTOBUF_CONSTEXPR UInt32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  UInt32Value(const UInt32Value& from);
+  UInt32Value(UInt32Value&& from) noexcept
+    : UInt32Value() {
+    *this = ::std::move(from);
+  }
+
+  inline UInt32Value& operator=(const UInt32Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline UInt32Value& operator=(UInt32Value&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const UInt32Value& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const UInt32Value* internal_default_instance() {
+    return reinterpret_cast<const UInt32Value*>(
+               &_UInt32Value_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(UInt32Value& a, UInt32Value& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(UInt32Value* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(UInt32Value* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  UInt32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<UInt32Value>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const UInt32Value& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const UInt32Value& from) {
+    UInt32Value::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(UInt32Value* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.UInt32Value";
+  }
+  protected:
+  explicit UInt32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // uint32 value = 1;
+  void clear_value();
+  uint32_t value() const;
+  void set_value(uint32_t value);
+  private:
+  uint32_t _internal_value() const;
+  void _internal_set_value(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.UInt32Value)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    uint32_t value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT BoolValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BoolValue) */ {
+ public:
+  inline BoolValue() : BoolValue(nullptr) {}
+  ~BoolValue() override;
+  explicit PROTOBUF_CONSTEXPR BoolValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BoolValue(const BoolValue& from);
+  BoolValue(BoolValue&& from) noexcept
+    : BoolValue() {
+    *this = ::std::move(from);
+  }
+
+  inline BoolValue& operator=(const BoolValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BoolValue& operator=(BoolValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const BoolValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BoolValue* internal_default_instance() {
+    return reinterpret_cast<const BoolValue*>(
+               &_BoolValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(BoolValue& a, BoolValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BoolValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(BoolValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  BoolValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<BoolValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BoolValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const BoolValue& from) {
+    BoolValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BoolValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.BoolValue";
+  }
+  protected:
+  explicit BoolValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // bool value = 1;
+  void clear_value();
+  bool value() const;
+  void set_value(bool value);
+  private:
+  bool _internal_value() const;
+  void _internal_set_value(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.BoolValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    bool value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT StringValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.StringValue) */ {
+ public:
+  inline StringValue() : StringValue(nullptr) {}
+  ~StringValue() override;
+  explicit PROTOBUF_CONSTEXPR StringValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  StringValue(const StringValue& from);
+  StringValue(StringValue&& from) noexcept
+    : StringValue() {
+    *this = ::std::move(from);
+  }
+
+  inline StringValue& operator=(const StringValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline StringValue& operator=(StringValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const StringValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const StringValue* internal_default_instance() {
+    return reinterpret_cast<const StringValue*>(
+               &_StringValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(StringValue& a, StringValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(StringValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(StringValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  StringValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<StringValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const StringValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const StringValue& from) {
+    StringValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(StringValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.StringValue";
+  }
+  protected:
+  explicit StringValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // string value = 1;
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.StringValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT BytesValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BytesValue) */ {
+ public:
+  inline BytesValue() : BytesValue(nullptr) {}
+  ~BytesValue() override;
+  explicit PROTOBUF_CONSTEXPR BytesValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BytesValue(const BytesValue& from);
+  BytesValue(BytesValue&& from) noexcept
+    : BytesValue() {
+    *this = ::std::move(from);
+  }
+
+  inline BytesValue& operator=(const BytesValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BytesValue& operator=(BytesValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const BytesValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BytesValue* internal_default_instance() {
+    return reinterpret_cast<const BytesValue*>(
+               &_BytesValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(BytesValue& a, BytesValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BytesValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(BytesValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  BytesValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<BytesValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BytesValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const BytesValue& from) {
+    BytesValue::MergeImpl(*this, from);
+  }
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
+
+  private:
+  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BytesValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "google.protobuf.BytesValue";
+  }
+  protected:
+  explicit BytesValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // bytes value = 1;
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.BytesValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DoubleValue
+
+// double value = 1;
+inline void DoubleValue::clear_value() {
+  _impl_.value_ = 0;
+}
+inline double DoubleValue::_internal_value() const {
+  return _impl_.value_;
+}
+inline double DoubleValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DoubleValue.value)
+  return _internal_value();
+}
+inline void DoubleValue::_internal_set_value(double value) {
+  
+  _impl_.value_ = value;
+}
+inline void DoubleValue::set_value(double value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.DoubleValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// FloatValue
+
+// float value = 1;
+inline void FloatValue::clear_value() {
+  _impl_.value_ = 0;
+}
+inline float FloatValue::_internal_value() const {
+  return _impl_.value_;
+}
+inline float FloatValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FloatValue.value)
+  return _internal_value();
+}
+inline void FloatValue::_internal_set_value(float value) {
+  
+  _impl_.value_ = value;
+}
+inline void FloatValue::set_value(float value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FloatValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// Int64Value
+
+// int64 value = 1;
+inline void Int64Value::clear_value() {
+  _impl_.value_ = int64_t{0};
+}
+inline int64_t Int64Value::_internal_value() const {
+  return _impl_.value_;
+}
+inline int64_t Int64Value::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Int64Value.value)
+  return _internal_value();
+}
+inline void Int64Value::_internal_set_value(int64_t value) {
+  
+  _impl_.value_ = value;
+}
+inline void Int64Value::set_value(int64_t value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Int64Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// UInt64Value
+
+// uint64 value = 1;
+inline void UInt64Value::clear_value() {
+  _impl_.value_ = uint64_t{0u};
+}
+inline uint64_t UInt64Value::_internal_value() const {
+  return _impl_.value_;
+}
+inline uint64_t UInt64Value::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UInt64Value.value)
+  return _internal_value();
+}
+inline void UInt64Value::_internal_set_value(uint64_t value) {
+  
+  _impl_.value_ = value;
+}
+inline void UInt64Value::set_value(uint64_t value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.UInt64Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// Int32Value
+
+// int32 value = 1;
+inline void Int32Value::clear_value() {
+  _impl_.value_ = 0;
+}
+inline int32_t Int32Value::_internal_value() const {
+  return _impl_.value_;
+}
+inline int32_t Int32Value::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Int32Value.value)
+  return _internal_value();
+}
+inline void Int32Value::_internal_set_value(int32_t value) {
+  
+  _impl_.value_ = value;
+}
+inline void Int32Value::set_value(int32_t value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Int32Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// UInt32Value
+
+// uint32 value = 1;
+inline void UInt32Value::clear_value() {
+  _impl_.value_ = 0u;
+}
+inline uint32_t UInt32Value::_internal_value() const {
+  return _impl_.value_;
+}
+inline uint32_t UInt32Value::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UInt32Value.value)
+  return _internal_value();
+}
+inline void UInt32Value::_internal_set_value(uint32_t value) {
+  
+  _impl_.value_ = value;
+}
+inline void UInt32Value::set_value(uint32_t value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.UInt32Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// BoolValue
+
+// bool value = 1;
+inline void BoolValue::clear_value() {
+  _impl_.value_ = false;
+}
+inline bool BoolValue::_internal_value() const {
+  return _impl_.value_;
+}
+inline bool BoolValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.BoolValue.value)
+  return _internal_value();
+}
+inline void BoolValue::_internal_set_value(bool value) {
+  
+  _impl_.value_ = value;
+}
+inline void BoolValue::set_value(bool value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:google.protobuf.BoolValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// StringValue
+
+// string value = 1;
+inline void StringValue::clear_value() {
+  _impl_.value_.ClearToEmpty();
+}
+inline const std::string& StringValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.StringValue.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StringValue::set_value(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.StringValue.value)
+}
+inline std::string* StringValue::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.StringValue.value)
+  return _s;
+}
+inline const std::string& StringValue::_internal_value() const {
+  return _impl_.value_.Get();
+}
+inline void StringValue::_internal_set_value(const std::string& value) {
+  
+  _impl_.value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* StringValue::_internal_mutable_value() {
+  
+  return _impl_.value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* StringValue::release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.StringValue.value)
+  return _impl_.value_.Release();
+}
+inline void StringValue::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.StringValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// BytesValue
+
+// bytes value = 1;
+inline void BytesValue::clear_value() {
+  _impl_.value_.ClearToEmpty();
+}
+inline const std::string& BytesValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.BytesValue.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void BytesValue::set_value(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:google.protobuf.BytesValue.value)
+}
+inline std::string* BytesValue::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.BytesValue.value)
+  return _s;
+}
+inline const std::string& BytesValue::_internal_value() const {
+  return _impl_.value_.Get();
+}
+inline void BytesValue::_internal_set_value(const std::string& value) {
+  
+  _impl_.value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* BytesValue::_internal_mutable_value() {
+  
+  return _impl_.value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* BytesValue::release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.BytesValue.value)
+  return _impl_.value_.Release();
+}
+inline void BytesValue::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.value_.IsDefault()) {
+    _impl_.value_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.BytesValue.value)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2fwrappers_2eproto
diff --git a/CAPI/cpp/grpc/include/google/protobuf/wrappers.proto b/CAPI/cpp/grpc/include/google/protobuf/wrappers.proto
new file mode 100644
index 0000000..d49dd53
--- /dev/null
+++ b/CAPI/cpp/grpc/include/google/protobuf/wrappers.proto
@@ -0,0 +1,123 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Wrappers for primitive (non-message) types. These types are useful
+// for embedding primitives in the `google.protobuf.Any` type and for places
+// where we need to distinguish between the absence of a primitive
+// typed field and its default value.
+//
+// These wrappers have no meaningful use within repeated fields as they lack
+// the ability to detect presence on individual elements.
+// These wrappers have no meaningful use within a map or a oneof since
+// individual entries of a map or fields of a oneof can already detect presence.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/protobuf/types/known/wrapperspb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "WrappersProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// Wrapper message for `double`.
+//
+// The JSON representation for `DoubleValue` is JSON number.
+message DoubleValue {
+  // The double value.
+  double value = 1;
+}
+
+// Wrapper message for `float`.
+//
+// The JSON representation for `FloatValue` is JSON number.
+message FloatValue {
+  // The float value.
+  float value = 1;
+}
+
+// Wrapper message for `int64`.
+//
+// The JSON representation for `Int64Value` is JSON string.
+message Int64Value {
+  // The int64 value.
+  int64 value = 1;
+}
+
+// Wrapper message for `uint64`.
+//
+// The JSON representation for `UInt64Value` is JSON string.
+message UInt64Value {
+  // The uint64 value.
+  uint64 value = 1;
+}
+
+// Wrapper message for `int32`.
+//
+// The JSON representation for `Int32Value` is JSON number.
+message Int32Value {
+  // The int32 value.
+  int32 value = 1;
+}
+
+// Wrapper message for `uint32`.
+//
+// The JSON representation for `UInt32Value` is JSON number.
+message UInt32Value {
+  // The uint32 value.
+  uint32 value = 1;
+}
+
+// Wrapper message for `bool`.
+//
+// The JSON representation for `BoolValue` is JSON `true` and `false`.
+message BoolValue {
+  // The bool value.
+  bool value = 1;
+}
+
+// Wrapper message for `string`.
+//
+// The JSON representation for `StringValue` is JSON string.
+message StringValue {
+  // The string value.
+  string value = 1;
+}
+
+// Wrapper message for `bytes`.
+//
+// The JSON representation for `BytesValue` is JSON string.
+message BytesValue {
+  // The bytes value.
+  bytes value = 1;
+}
diff --git a/CAPI/cpp/grpc/include/grpc++/alarm.h b/CAPI/cpp/grpc/include/grpc++/alarm.h
new file mode 100644
index 0000000..dce742e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/alarm.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_ALARM_H
+#define GRPCXX_ALARM_H
+
+#include <grpcpp/alarm.h>
+
+#endif  // GRPCXX_ALARM_H
diff --git a/CAPI/cpp/grpc/include/grpc++/channel.h b/CAPI/cpp/grpc/include/grpc++/channel.h
new file mode 100644
index 0000000..b1154ce
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/channel.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_CHANNEL_H
+#define GRPCXX_CHANNEL_H
+
+#include <grpcpp/channel.h>
+
+#endif  // GRPCXX_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/client_context.h b/CAPI/cpp/grpc/include/grpc++/client_context.h
new file mode 100644
index 0000000..4b23644
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/client_context.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_CLIENT_CONTEXT_H
+#define GRPCXX_CLIENT_CONTEXT_H
+
+#include <grpcpp/client_context.h>
+
+#endif  // GRPCXX_CLIENT_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpc++/completion_queue.h b/CAPI/cpp/grpc/include/grpc++/completion_queue.h
new file mode 100644
index 0000000..98ef18f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/completion_queue.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_COMPLETION_QUEUE_H
+#define GRPCXX_COMPLETION_QUEUE_H
+
+#include <grpcpp/completion_queue.h>
+
+#endif  // GRPCXX_COMPLETION_QUEUE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/create_channel.h b/CAPI/cpp/grpc/include/grpc++/create_channel.h
new file mode 100644
index 0000000..d95f3a9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/create_channel.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_CREATE_CHANNEL_H
+#define GRPCXX_CREATE_CHANNEL_H
+
+#include <grpcpp/create_channel.h>
+
+#endif  // GRPCXX_CREATE_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/create_channel_posix.h b/CAPI/cpp/grpc/include/grpc++/create_channel_posix.h
new file mode 100644
index 0000000..8c8983b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/create_channel_posix.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_CREATE_CHANNEL_POSIX_H
+#define GRPCXX_CREATE_CHANNEL_POSIX_H
+
+#include <grpcpp/create_channel_posix.h>
+
+#endif  // GRPCXX_CREATE_CHANNEL_POSIX_H
diff --git a/CAPI/cpp/grpc/include/grpc++/ext/health_check_service_server_builder_option.h b/CAPI/cpp/grpc/include/grpc++/ext/health_check_service_server_builder_option.h
new file mode 100644
index 0000000..cb82fc0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/ext/health_check_service_server_builder_option.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_EXT_HEALTH_CHECK_SERVICE_SERVER_BUILDER_OPTION_H
+#define GRPCXX_EXT_HEALTH_CHECK_SERVICE_SERVER_BUILDER_OPTION_H
+
+#include <grpcpp/ext/health_check_service_server_builder_option.h>
+
+#endif  // GRPCXX_EXT_HEALTH_CHECK_SERVICE_SERVER_BUILDER_OPTION_H
diff --git a/CAPI/cpp/grpc/include/grpc++/generic/async_generic_service.h b/CAPI/cpp/grpc/include/grpc++/generic/async_generic_service.h
new file mode 100644
index 0000000..d3283fa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/generic/async_generic_service.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_GENERIC_ASYNC_GENERIC_SERVICE_H
+#define GRPCXX_GENERIC_ASYNC_GENERIC_SERVICE_H
+
+#include <grpcpp/generic/async_generic_service.h>
+
+#endif  // GRPCXX_GENERIC_ASYNC_GENERIC_SERVICE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/generic/generic_stub.h b/CAPI/cpp/grpc/include/grpc++/generic/generic_stub.h
new file mode 100644
index 0000000..502953b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/generic/generic_stub.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_GENERIC_GENERIC_STUB_H
+#define GRPCXX_GENERIC_GENERIC_STUB_H
+
+#include <grpcpp/generic/generic_stub.h>
+
+#endif  // GRPCXX_GENERIC_GENERIC_STUB_H
diff --git a/CAPI/cpp/grpc/include/grpc++/grpc++.h b/CAPI/cpp/grpc/include/grpc++/grpc++.h
new file mode 100644
index 0000000..9f1d7b1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/grpc++.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_GRPCXX_H
+#define GRPCXX_GRPCXX_H
+
+#include <grpcpp/grpcpp.h>
+
+#endif  // GRPCXX_GRPCXX_H
diff --git a/CAPI/cpp/grpc/include/grpc++/health_check_service_interface.h b/CAPI/cpp/grpc/include/grpc++/health_check_service_interface.h
new file mode 100644
index 0000000..0cb0668
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/health_check_service_interface.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_HEALTH_CHECK_SERVICE_INTERFACE_H
+#define GRPCXX_HEALTH_CHECK_SERVICE_INTERFACE_H
+
+#include <grpcpp/health_check_service_interface.h>
+
+#endif  // GRPCXX_HEALTH_CHECK_SERVICE_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/call.h b/CAPI/cpp/grpc/include/grpc++/impl/call.h
new file mode 100644
index 0000000..b1da2b6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/call.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CALL_H
+#define GRPCXX_IMPL_CALL_H
+
+#include <grpcpp/impl/call.h>
+
+#endif  // GRPCXX_IMPL_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/channel_argument_option.h b/CAPI/cpp/grpc/include/grpc++/impl/channel_argument_option.h
new file mode 100644
index 0000000..3468378
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/channel_argument_option.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CHANNEL_ARGUMENT_OPTION_H
+#define GRPCXX_IMPL_CHANNEL_ARGUMENT_OPTION_H
+
+#include <grpcpp/impl/channel_argument_option.h>
+
+#endif  // GRPCXX_IMPL_CHANNEL_ARGUMENT_OPTION_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/client_unary_call.h b/CAPI/cpp/grpc/include/grpc++/impl/client_unary_call.h
new file mode 100644
index 0000000..75e6560
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/client_unary_call.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CLIENT_UNARY_CALL_H
+#define GRPCXX_IMPL_CLIENT_UNARY_CALL_H
+
+#include <grpcpp/impl/client_unary_call.h>
+
+#endif  // GRPCXX_IMPL_CLIENT_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/async_stream.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/async_stream.h
new file mode 100644
index 0000000..a034470
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/async_stream.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_ASYNC_STREAM_H
+#define GRPCXX_IMPL_CODEGEN_ASYNC_STREAM_H
+
+#include <grpcpp/impl/codegen/async_stream.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_ASYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/async_unary_call.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/async_unary_call.h
new file mode 100644
index 0000000..2b08920
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/async_unary_call.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
+#define GRPCXX_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
+
+#include <grpcpp/impl/codegen/async_unary_call.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/byte_buffer.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/byte_buffer.h
new file mode 100644
index 0000000..b754fa2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/byte_buffer.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_BYTE_BUFFER_H
+#define GRPCXX_IMPL_CODEGEN_BYTE_BUFFER_H
+
+#include <grpcpp/impl/codegen/byte_buffer.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_BYTE_BUFFER_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/call.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/call.h
new file mode 100644
index 0000000..dadab54
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/call.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CALL_H
+#define GRPCXX_IMPL_CODEGEN_CALL_H
+
+#include <grpcpp/impl/codegen/call.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/call_hook.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/call_hook.h
new file mode 100644
index 0000000..cf5ed57
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/call_hook.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CALL_HOOK_H
+#define GRPCXX_IMPL_CODEGEN_CALL_HOOK_H
+
+#include <grpcpp/impl/codegen/call_hook.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CALL_HOOK_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/channel_interface.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/channel_interface.h
new file mode 100644
index 0000000..c6e782e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/channel_interface.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CHANNEL_INTERFACE_H
+#define GRPCXX_IMPL_CODEGEN_CHANNEL_INTERFACE_H
+
+#include <grpcpp/impl/codegen/channel_interface.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CHANNEL_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/client_context.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/client_context.h
new file mode 100644
index 0000000..107532c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/client_context.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CLIENT_CONTEXT_H
+#define GRPCXX_IMPL_CODEGEN_CLIENT_CONTEXT_H
+
+#include <grpcpp/impl/codegen/client_context.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CLIENT_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/client_unary_call.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/client_unary_call.h
new file mode 100644
index 0000000..f7dff1f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/client_unary_call.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CLIENT_UNARY_CALL_H
+#define GRPCXX_IMPL_CODEGEN_CLIENT_UNARY_CALL_H
+
+#include <grpcpp/impl/codegen/client_unary_call.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CLIENT_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/completion_queue.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/completion_queue.h
new file mode 100644
index 0000000..1075495
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/completion_queue.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_H
+#define GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_H
+
+#include <grpcpp/impl/codegen/completion_queue.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/completion_queue_tag.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/completion_queue_tag.h
new file mode 100644
index 0000000..994fa2a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/completion_queue_tag.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_TAG_H
+#define GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_TAG_H
+
+#include <grpcpp/impl/codegen/completion_queue_tag.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_COMPLETION_QUEUE_TAG_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/config.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/config.h
new file mode 100644
index 0000000..237bf38
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/config.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CONFIG_H
+#define GRPCXX_IMPL_CODEGEN_CONFIG_H
+
+#include <grpcpp/impl/codegen/config.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CONFIG_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/config_protobuf.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/config_protobuf.h
new file mode 100644
index 0000000..debd74a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/config_protobuf.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CONFIG_PROTOBUF_H
+#define GRPCXX_IMPL_CODEGEN_CONFIG_PROTOBUF_H
+
+#include <grpcpp/impl/codegen/config_protobuf.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CONFIG_PROTOBUF_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/core_codegen.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/core_codegen.h
new file mode 100644
index 0000000..ee600a9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/core_codegen.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CORE_CODEGEN_H
+#define GRPCXX_IMPL_CODEGEN_CORE_CODEGEN_H
+
+#include <grpcpp/impl/codegen/core_codegen.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CORE_CODEGEN_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/core_codegen_interface.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/core_codegen_interface.h
new file mode 100644
index 0000000..03b3f67
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/core_codegen_interface.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CORE_CODEGEN_INTERFACE_H
+#define GRPCXX_IMPL_CODEGEN_CORE_CODEGEN_INTERFACE_H
+
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CORE_CODEGEN_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/create_auth_context.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/create_auth_context.h
new file mode 100644
index 0000000..ef89229
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/create_auth_context.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_CREATE_AUTH_CONTEXT_H
+#define GRPCXX_IMPL_CODEGEN_CREATE_AUTH_CONTEXT_H
+
+#include <grpcpp/impl/codegen/create_auth_context.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_CREATE_AUTH_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/grpc_library.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/grpc_library.h
new file mode 100644
index 0000000..33c3e25
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/grpc_library.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_GRPC_LIBRARY_H
+#define GRPCXX_IMPL_CODEGEN_GRPC_LIBRARY_H
+
+#include <grpcpp/impl/codegen/grpc_library.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_GRPC_LIBRARY_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/metadata_map.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/metadata_map.h
new file mode 100644
index 0000000..41c5ad3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/metadata_map.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_METADATA_MAP_H
+#define GRPCXX_IMPL_CODEGEN_METADATA_MAP_H
+
+#include <grpcpp/impl/codegen/metadata_map.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_METADATA_MAP_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/method_handler_impl.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/method_handler_impl.h
new file mode 100644
index 0000000..0bdb620
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/method_handler_impl.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
+#define GRPCXX_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
+
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/proto_utils.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/proto_utils.h
new file mode 100644
index 0000000..1f47884
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/proto_utils.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_PROTO_UTILS_H
+#define GRPCXX_IMPL_CODEGEN_PROTO_UTILS_H
+
+#include <grpcpp/impl/codegen/proto_utils.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_PROTO_UTILS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/rpc_method.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/rpc_method.h
new file mode 100644
index 0000000..2906c74
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/rpc_method.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_RPC_METHOD_H
+#define GRPCXX_IMPL_CODEGEN_RPC_METHOD_H
+
+#include <grpcpp/impl/codegen/rpc_method.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_RPC_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/rpc_service_method.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/rpc_service_method.h
new file mode 100644
index 0000000..999c0d5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/rpc_service_method.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_RPC_SERVICE_METHOD_H
+#define GRPCXX_IMPL_CODEGEN_RPC_SERVICE_METHOD_H
+
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_RPC_SERVICE_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/security/auth_context.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/security/auth_context.h
new file mode 100644
index 0000000..b466373
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/security/auth_context.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H
+#define GRPCXX_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H
+
+#include <grpcpp/impl/codegen/security/auth_context.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/serialization_traits.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/serialization_traits.h
new file mode 100644
index 0000000..480575d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/serialization_traits.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_SERIALIZATION_TRAITS_H
+#define GRPCXX_IMPL_CODEGEN_SERIALIZATION_TRAITS_H
+
+#include <grpcpp/impl/codegen/serialization_traits.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_SERIALIZATION_TRAITS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/server_context.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/server_context.h
new file mode 100644
index 0000000..1c3342d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/server_context.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_SERVER_CONTEXT_H
+#define GRPCXX_IMPL_CODEGEN_SERVER_CONTEXT_H
+
+#include <grpcpp/impl/codegen/server_context.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_SERVER_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/server_interface.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/server_interface.h
new file mode 100644
index 0000000..ceea44c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/server_interface.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_SERVER_INTERFACE_H
+#define GRPCXX_IMPL_CODEGEN_SERVER_INTERFACE_H
+
+#include <grpcpp/impl/codegen/server_interface.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_SERVER_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/service_type.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/service_type.h
new file mode 100644
index 0000000..be02b75
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/service_type.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_SERVICE_TYPE_H
+#define GRPCXX_IMPL_CODEGEN_SERVICE_TYPE_H
+
+#include <grpcpp/impl/codegen/service_type.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_SERVICE_TYPE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/slice.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/slice.h
new file mode 100644
index 0000000..6714bad
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/slice.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_SLICE_H
+#define GRPCXX_IMPL_CODEGEN_SLICE_H
+
+#include <grpcpp/impl/codegen/slice.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_SLICE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/status.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/status.h
new file mode 100644
index 0000000..6cf9459
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/status.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_STATUS_H
+#define GRPCXX_IMPL_CODEGEN_STATUS_H
+
+#include <grpcpp/impl/codegen/status.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_STATUS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/status_code_enum.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/status_code_enum.h
new file mode 100644
index 0000000..7503eae
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/status_code_enum.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_STATUS_CODE_ENUM_H
+#define GRPCXX_IMPL_CODEGEN_STATUS_CODE_ENUM_H
+
+#include <grpcpp/impl/codegen/status_code_enum.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_STATUS_CODE_ENUM_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/string_ref.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/string_ref.h
new file mode 100644
index 0000000..66e250e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/string_ref.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_STRING_REF_H
+#define GRPCXX_IMPL_CODEGEN_STRING_REF_H
+
+#include <grpcpp/impl/codegen/string_ref.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_STRING_REF_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/stub_options.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/stub_options.h
new file mode 100644
index 0000000..07cb441
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/stub_options.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_STUB_OPTIONS_H
+#define GRPCXX_IMPL_CODEGEN_STUB_OPTIONS_H
+
+#include <grpcpp/impl/codegen/stub_options.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_STUB_OPTIONS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/sync_stream.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/sync_stream.h
new file mode 100644
index 0000000..1e6ba27
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/sync_stream.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_SYNC_STREAM_H
+#define GRPCXX_IMPL_CODEGEN_SYNC_STREAM_H
+
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_SYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/codegen/time.h b/CAPI/cpp/grpc/include/grpc++/impl/codegen/time.h
new file mode 100644
index 0000000..f9b70f8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/codegen/time.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_CODEGEN_TIME_H
+#define GRPCXX_IMPL_CODEGEN_TIME_H
+
+#include <grpcpp/impl/codegen/time.h>
+
+#endif  // GRPCXX_IMPL_CODEGEN_TIME_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/grpc_library.h b/CAPI/cpp/grpc/include/grpc++/impl/grpc_library.h
new file mode 100644
index 0000000..f34a281
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/grpc_library.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_GRPC_LIBRARY_H
+#define GRPCXX_IMPL_GRPC_LIBRARY_H
+
+#include <grpcpp/impl/grpc_library.h>
+
+#endif  // GRPCXX_IMPL_GRPC_LIBRARY_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/method_handler_impl.h b/CAPI/cpp/grpc/include/grpc++/impl/method_handler_impl.h
new file mode 100644
index 0000000..3840f48
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/method_handler_impl.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_METHOD_HANDLER_IMPL_H
+#define GRPCXX_IMPL_METHOD_HANDLER_IMPL_H
+
+#include <grpcpp/impl/method_handler_impl.h>
+
+#endif  // GRPCXX_IMPL_METHOD_HANDLER_IMPL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/rpc_method.h b/CAPI/cpp/grpc/include/grpc++/impl/rpc_method.h
new file mode 100644
index 0000000..7cba7c4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/rpc_method.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_RPC_METHOD_H
+#define GRPCXX_IMPL_RPC_METHOD_H
+
+#include <grpcpp/impl/rpc_method.h>
+
+#endif  // GRPCXX_IMPL_RPC_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/rpc_service_method.h b/CAPI/cpp/grpc/include/grpc++/impl/rpc_service_method.h
new file mode 100644
index 0000000..2c75087
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/rpc_service_method.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_RPC_SERVICE_METHOD_H
+#define GRPCXX_IMPL_RPC_SERVICE_METHOD_H
+
+#include <grpcpp/impl/rpc_service_method.h>
+
+#endif  // GRPCXX_IMPL_RPC_SERVICE_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/serialization_traits.h b/CAPI/cpp/grpc/include/grpc++/impl/serialization_traits.h
new file mode 100644
index 0000000..33b3a0b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/serialization_traits.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_SERIALIZATION_TRAITS_H
+#define GRPCXX_IMPL_SERIALIZATION_TRAITS_H
+
+#include <grpcpp/impl/serialization_traits.h>
+
+#endif  // GRPCXX_IMPL_SERIALIZATION_TRAITS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/server_builder_option.h b/CAPI/cpp/grpc/include/grpc++/impl/server_builder_option.h
new file mode 100644
index 0000000..833f8db
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/server_builder_option.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_SERVER_BUILDER_OPTION_H
+#define GRPCXX_IMPL_SERVER_BUILDER_OPTION_H
+
+#include <grpcpp/impl/server_builder_option.h>
+
+#endif  // GRPCXX_IMPL_SERVER_BUILDER_OPTION_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/server_builder_plugin.h b/CAPI/cpp/grpc/include/grpc++/impl/server_builder_plugin.h
new file mode 100644
index 0000000..844d32c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/server_builder_plugin.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_SERVER_BUILDER_PLUGIN_H
+#define GRPCXX_IMPL_SERVER_BUILDER_PLUGIN_H
+
+#include <grpcpp/impl/server_builder_plugin.h>
+
+#endif  // GRPCXX_IMPL_SERVER_BUILDER_PLUGIN_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/server_initializer.h b/CAPI/cpp/grpc/include/grpc++/impl/server_initializer.h
new file mode 100644
index 0000000..6a1669c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/server_initializer.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_SERVER_INITIALIZER_H
+#define GRPCXX_IMPL_SERVER_INITIALIZER_H
+
+#include <grpcpp/impl/server_initializer.h>
+
+#endif  // GRPCXX_IMPL_SERVER_INITIALIZER_H
diff --git a/CAPI/cpp/grpc/include/grpc++/impl/service_type.h b/CAPI/cpp/grpc/include/grpc++/impl/service_type.h
new file mode 100644
index 0000000..8642216
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/impl/service_type.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_IMPL_SERVICE_TYPE_H
+#define GRPCXX_IMPL_SERVICE_TYPE_H
+
+#include <grpcpp/impl/service_type.h>
+
+#endif  // GRPCXX_IMPL_SERVICE_TYPE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/resource_quota.h b/CAPI/cpp/grpc/include/grpc++/resource_quota.h
new file mode 100644
index 0000000..aad1b56
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/resource_quota.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_RESOURCE_QUOTA_H
+#define GRPCXX_RESOURCE_QUOTA_H
+
+#include <grpcpp/resource_quota.h>
+
+#endif  // GRPCXX_RESOURCE_QUOTA_H
diff --git a/CAPI/cpp/grpc/include/grpc++/security/auth_context.h b/CAPI/cpp/grpc/include/grpc++/security/auth_context.h
new file mode 100644
index 0000000..9fe59d4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/security/auth_context.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SECURITY_AUTH_CONTEXT_H
+#define GRPCXX_SECURITY_AUTH_CONTEXT_H
+
+#include <grpcpp/security/auth_context.h>
+
+#endif  // GRPCXX_SECURITY_AUTH_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpc++/security/auth_metadata_processor.h b/CAPI/cpp/grpc/include/grpc++/security/auth_metadata_processor.h
new file mode 100644
index 0000000..d045313
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/security/auth_metadata_processor.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SECURITY_AUTH_METADATA_PROCESSOR_H
+#define GRPCXX_SECURITY_AUTH_METADATA_PROCESSOR_H
+
+#include <grpcpp/security/auth_metadata_processor.h>
+
+#endif  // GRPCXX_SECURITY_AUTH_METADATA_PROCESSOR_H
diff --git a/CAPI/cpp/grpc/include/grpc++/security/credentials.h b/CAPI/cpp/grpc/include/grpc++/security/credentials.h
new file mode 100644
index 0000000..9404418
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/security/credentials.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SECURITY_CREDENTIALS_H
+#define GRPCXX_SECURITY_CREDENTIALS_H
+
+#include <grpcpp/security/credentials.h>
+
+#endif  // GRPCXX_SECURITY_CREDENTIALS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/security/server_credentials.h b/CAPI/cpp/grpc/include/grpc++/security/server_credentials.h
new file mode 100644
index 0000000..c6d1c4f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/security/server_credentials.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SECURITY_SERVER_CREDENTIALS_H
+#define GRPCXX_SECURITY_SERVER_CREDENTIALS_H
+
+#include <grpcpp/security/server_credentials.h>
+
+#endif  // GRPCXX_SECURITY_SERVER_CREDENTIALS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/server.h b/CAPI/cpp/grpc/include/grpc++/server.h
new file mode 100644
index 0000000..086c24c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/server.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SERVER_H
+#define GRPCXX_SERVER_H
+
+#include <grpcpp/server.h>
+
+#endif  // GRPCXX_SERVER_H
diff --git a/CAPI/cpp/grpc/include/grpc++/server_builder.h b/CAPI/cpp/grpc/include/grpc++/server_builder.h
new file mode 100644
index 0000000..2c6dab4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/server_builder.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SERVER_BUILDER_H
+#define GRPCXX_SERVER_BUILDER_H
+
+#include <grpcpp/server_builder.h>
+
+#endif  // GRPCXX_SERVER_BUILDER_H
diff --git a/CAPI/cpp/grpc/include/grpc++/server_context.h b/CAPI/cpp/grpc/include/grpc++/server_context.h
new file mode 100644
index 0000000..672ccdc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/server_context.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SERVER_CONTEXT_H
+#define GRPCXX_SERVER_CONTEXT_H
+
+#include <grpcpp/server_context.h>
+
+#endif  // GRPCXX_SERVER_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpc++/server_posix.h b/CAPI/cpp/grpc/include/grpc++/server_posix.h
new file mode 100644
index 0000000..d2866d9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/server_posix.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SERVER_POSIX_H
+#define GRPCXX_SERVER_POSIX_H
+
+#include <grpcpp/server_posix.h>
+
+#endif  // GRPCXX_SERVER_POSIX_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/async_stream.h b/CAPI/cpp/grpc/include/grpc++/support/async_stream.h
new file mode 100644
index 0000000..9bb2b72
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/async_stream.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_ASYNC_STREAM_H
+#define GRPCXX_SUPPORT_ASYNC_STREAM_H
+
+#include <grpcpp/support/async_stream.h>
+
+#endif  // GRPCXX_SUPPORT_ASYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/async_unary_call.h b/CAPI/cpp/grpc/include/grpc++/support/async_unary_call.h
new file mode 100644
index 0000000..56fbf31
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/async_unary_call.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_ASYNC_UNARY_CALL_H
+#define GRPCXX_SUPPORT_ASYNC_UNARY_CALL_H
+
+#include <grpcpp/support/async_unary_call.h>
+
+#endif  // GRPCXX_SUPPORT_ASYNC_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/byte_buffer.h b/CAPI/cpp/grpc/include/grpc++/support/byte_buffer.h
new file mode 100644
index 0000000..ec607ee
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/byte_buffer.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_BYTE_BUFFER_H
+#define GRPCXX_SUPPORT_BYTE_BUFFER_H
+
+#include <grpcpp/support/byte_buffer.h>
+
+#endif  // GRPCXX_SUPPORT_BYTE_BUFFER_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/channel_arguments.h b/CAPI/cpp/grpc/include/grpc++/support/channel_arguments.h
new file mode 100644
index 0000000..6d5300c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/channel_arguments.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_CHANNEL_ARGUMENTS_H
+#define GRPCXX_SUPPORT_CHANNEL_ARGUMENTS_H
+
+#include <grpcpp/support/channel_arguments.h>
+
+#endif  // GRPCXX_SUPPORT_CHANNEL_ARGUMENTS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/config.h b/CAPI/cpp/grpc/include/grpc++/support/config.h
new file mode 100644
index 0000000..f8eee50
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/config.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_CONFIG_H
+#define GRPCXX_SUPPORT_CONFIG_H
+
+#include <grpcpp/support/config.h>
+
+#endif  // GRPCXX_SUPPORT_CONFIG_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/error_details.h b/CAPI/cpp/grpc/include/grpc++/support/error_details.h
new file mode 100644
index 0000000..7ace308
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/error_details.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_ERROR_DETAILS_H
+#define GRPCXX_SUPPORT_ERROR_DETAILS_H
+
+#include <grpcpp/support/error_details.h>
+
+#endif  // GRPCXX_SUPPORT_ERROR_DETAILS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/slice.h b/CAPI/cpp/grpc/include/grpc++/support/slice.h
new file mode 100644
index 0000000..b02b1a9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/slice.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_SLICE_H
+#define GRPCXX_SUPPORT_SLICE_H
+
+#include <grpcpp/support/slice.h>
+
+#endif  // GRPCXX_SUPPORT_SLICE_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/status.h b/CAPI/cpp/grpc/include/grpc++/support/status.h
new file mode 100644
index 0000000..e58a18b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/status.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_STATUS_H
+#define GRPCXX_SUPPORT_STATUS_H
+
+#include <grpcpp/support/status.h>
+
+#endif  // GRPCXX_SUPPORT_STATUS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/status_code_enum.h b/CAPI/cpp/grpc/include/grpc++/support/status_code_enum.h
new file mode 100644
index 0000000..c278add
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/status_code_enum.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_STATUS_CODE_ENUM_H
+#define GRPCXX_SUPPORT_STATUS_CODE_ENUM_H
+
+#include <grpcpp/support/status_code_enum.h>
+
+#endif  // GRPCXX_SUPPORT_STATUS_CODE_ENUM_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/string_ref.h b/CAPI/cpp/grpc/include/grpc++/support/string_ref.h
new file mode 100644
index 0000000..49de6da
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/string_ref.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_STRING_REF_H
+#define GRPCXX_SUPPORT_STRING_REF_H
+
+#include <grpcpp/support/string_ref.h>
+
+#endif  // GRPCXX_SUPPORT_STRING_REF_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/stub_options.h b/CAPI/cpp/grpc/include/grpc++/support/stub_options.h
new file mode 100644
index 0000000..a712ce8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/stub_options.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_STUB_OPTIONS_H
+#define GRPCXX_SUPPORT_STUB_OPTIONS_H
+
+#include <grpcpp/support/stub_options.h>
+
+#endif  // GRPCXX_SUPPORT_STUB_OPTIONS_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/sync_stream.h b/CAPI/cpp/grpc/include/grpc++/support/sync_stream.h
new file mode 100644
index 0000000..c118df9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/sync_stream.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_SYNC_STREAM_H
+#define GRPCXX_SUPPORT_SYNC_STREAM_H
+
+#include <grpcpp/support/sync_stream.h>
+
+#endif  // GRPCXX_SUPPORT_SYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpc++/support/time.h b/CAPI/cpp/grpc/include/grpc++/support/time.h
new file mode 100644
index 0000000..d356b91
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc++/support/time.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+// DEPRECATED: The headers in include/grpc++ are deprecated. Please include the
+// headers in include/grpcpp instead. This header exists only for backwards
+// compatibility.
+
+#ifndef GRPCXX_SUPPORT_TIME_H
+#define GRPCXX_SUPPORT_TIME_H
+
+#include <grpcpp/support/time.h>
+
+#endif  // GRPCXX_SUPPORT_TIME_H
diff --git a/CAPI/cpp/grpc/include/grpc/byte_buffer.h b/CAPI/cpp/grpc/include/grpc/byte_buffer.h
new file mode 100644
index 0000000..fff33cb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/byte_buffer.h
@@ -0,0 +1,27 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_BYTE_BUFFER_H
+#define GRPC_BYTE_BUFFER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/byte_buffer.h>  // IWYU pragma: export
+#include <grpc/slice_buffer.h>
+
+#endif /* GRPC_BYTE_BUFFER_H */
diff --git a/CAPI/cpp/grpc/include/grpc/byte_buffer_reader.h b/CAPI/cpp/grpc/include/grpc/byte_buffer_reader.h
new file mode 100644
index 0000000..763dd78
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/byte_buffer_reader.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_BYTE_BUFFER_READER_H
+#define GRPC_BYTE_BUFFER_READER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/byte_buffer_reader.h>  // IWYU pragma: export
+
+#endif /* GRPC_BYTE_BUFFER_READER_H */
diff --git a/CAPI/cpp/grpc/include/grpc/census.h b/CAPI/cpp/grpc/include/grpc/census.h
new file mode 100644
index 0000000..4894f1c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/census.h
@@ -0,0 +1,40 @@
+/*
+ *
+ * Copyright 2015-2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_CENSUS_H
+#define GRPC_CENSUS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/grpc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+  A Census Context is a handle used by Census to represent the current tracing
+  and stats collection information. Contexts should be propagated across RPC's
+  (this is the responsibility of the local RPC system). */
+typedef struct census_context census_context;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_CENSUS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/compression.h b/CAPI/cpp/grpc/include/grpc/compression.h
new file mode 100644
index 0000000..2c39c6b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/compression.h
@@ -0,0 +1,75 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_COMPRESSION_H
+#define GRPC_COMPRESSION_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <stdlib.h>
+
+#include <grpc/impl/codegen/compression_types.h>  // IWYU pragma: export
+#include <grpc/slice.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Return if an algorithm is message compression algorithm. */
+GRPCAPI int grpc_compression_algorithm_is_message(
+    grpc_compression_algorithm algorithm);
+
+/** Return if an algorithm is stream compression algorithm. */
+GRPCAPI int grpc_compression_algorithm_is_stream(
+    grpc_compression_algorithm algorithm);
+
+/** Parses the \a slice as a grpc_compression_algorithm instance and updating \a
+ * algorithm. Returns 1 upon success, 0 otherwise. */
+GRPCAPI int grpc_compression_algorithm_parse(
+    grpc_slice name, grpc_compression_algorithm* algorithm);
+
+/** Updates \a name with the encoding name corresponding to a valid \a
+ * algorithm. Note that \a name is statically allocated and must *not* be freed.
+ * Returns 1 upon success, 0 otherwise. */
+GRPCAPI int grpc_compression_algorithm_name(
+    grpc_compression_algorithm algorithm, const char** name);
+
+/** Returns the compression algorithm corresponding to \a level for the
+ * compression algorithms encoded in the \a accepted_encodings bitset.*/
+GRPCAPI grpc_compression_algorithm grpc_compression_algorithm_for_level(
+    grpc_compression_level level, uint32_t accepted_encodings);
+
+GRPCAPI void grpc_compression_options_init(grpc_compression_options* opts);
+
+/** Mark \a algorithm as enabled in \a opts. */
+GRPCAPI void grpc_compression_options_enable_algorithm(
+    grpc_compression_options* opts, grpc_compression_algorithm algorithm);
+
+/** Mark \a algorithm as disabled in \a opts. */
+GRPCAPI void grpc_compression_options_disable_algorithm(
+    grpc_compression_options* opts, grpc_compression_algorithm algorithm);
+
+/** Returns true if \a algorithm is marked as enabled in \a opts. */
+GRPCAPI int grpc_compression_options_is_algorithm_enabled(
+    const grpc_compression_options* opts, grpc_compression_algorithm algorithm);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_COMPRESSION_H */
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/endpoint_config.h b/CAPI/cpp/grpc/include/grpc/event_engine/endpoint_config.h
new file mode 100644
index 0000000..6ca4b4f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/endpoint_config.h
@@ -0,0 +1,43 @@
+// Copyright 2021 The gRPC Authors
+//
+// 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.
+#ifndef GRPC_EVENT_ENGINE_ENDPOINT_CONFIG_H
+#define GRPC_EVENT_ENGINE_ENDPOINT_CONFIG_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Collection of parameters used to configure client and server endpoints. The
+/// \a EndpointConfig maps string-valued keys to values of type int,
+/// string_view, or void pointer. Each EventEngine implementation should
+/// document its set of supported configuration options.
+class EndpointConfig {
+ public:
+  virtual ~EndpointConfig() = default;
+  using Setting = absl::variant<absl::monostate, int, absl::string_view, void*>;
+  /// Returns the Setting for a specified key, or \a absl::monostate if there is
+  /// no such entry. Caller does not take ownership of the resulting value.
+  virtual Setting Get(absl::string_view key) const = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_ENDPOINT_CONFIG_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/event_engine.h b/CAPI/cpp/grpc/include/grpc/event_engine/event_engine.h
new file mode 100644
index 0000000..52edb5a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/event_engine.h
@@ -0,0 +1,446 @@
+// Copyright 2021 The gRPC Authors
+//
+// 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.
+#ifndef GRPC_EVENT_ENGINE_EVENT_ENGINE_H
+#define GRPC_EVENT_ENGINE_EVENT_ENGINE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <vector>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/event_engine/port.h>
+#include <grpc/event_engine/slice_buffer.h>
+
+// TODO(vigneshbabu): Define the Endpoint::Write metrics collection system
+namespace grpc_event_engine {
+namespace experimental {
+
+////////////////////////////////////////////////////////////////////////////////
+/// The EventEngine encapsulates all platform-specific behaviors related to low
+/// level network I/O, timers, asynchronous execution, and DNS resolution.
+///
+/// This interface allows developers to provide their own event management and
+/// network stacks. Motivating uses cases for supporting custom EventEngines
+/// include the ability to hook into external event loops, and using different
+/// EventEngine instances for each channel to better insulate network I/O and
+/// callback processing from other channels.
+///
+/// A default cross-platform EventEngine instance is provided by gRPC.
+///
+/// LIFESPAN AND OWNERSHIP
+///
+/// gRPC takes shared ownership of EventEngines via std::shared_ptrs to ensure
+/// that the engines remain available until they are no longer needed. Depending
+/// on the use case, engines may live until gRPC is shut down.
+///
+/// EXAMPLE USAGE (Not yet implemented)
+///
+/// Custom EventEngines can be specified per channel, and allow configuration
+/// for both clients and servers. To set a custom EventEngine for a client
+/// channel, you can do something like the following:
+///
+///    ChannelArguments args;
+///    std::shared_ptr<EventEngine> engine = std::make_shared<MyEngine>(...);
+///    args.SetEventEngine(engine);
+///    MyAppClient client(grpc::CreateCustomChannel(
+///        "localhost:50051", grpc::InsecureChannelCredentials(), args));
+///
+/// A gRPC server can use a custom EventEngine by calling the
+/// ServerBuilder::SetEventEngine method:
+///
+///    ServerBuilder builder;
+///    std::shared_ptr<EventEngine> engine = std::make_shared<MyEngine>(...);
+///    builder.SetEventEngine(engine);
+///    std::unique_ptr<Server> server(builder.BuildAndStart());
+///    server->Wait();
+///
+////////////////////////////////////////////////////////////////////////////////
+class EventEngine {
+ public:
+  /// A duration between two events.
+  ///
+  /// Throughout the EventEngine API durations are used to express how long
+  /// until an action should be performed.
+  using Duration = std::chrono::duration<int64_t, std::nano>;
+  /// A custom closure type for EventEngine task execution.
+  ///
+  /// Throughout the EventEngine API, \a Closure ownership is retained by the
+  /// caller - the EventEngine will never delete a Closure, and upon
+  /// cancellation, the EventEngine will simply forget the Closure exists. The
+  /// caller is responsible for all necessary cleanup.
+  class Closure {
+   public:
+    Closure() = default;
+    // Closure's are an interface, and thus non-copyable.
+    Closure(const Closure&) = delete;
+    Closure& operator=(const Closure&) = delete;
+    // Polymorphic type => virtual destructor
+    virtual ~Closure() = default;
+    // Run the contained code.
+    virtual void Run() = 0;
+  };
+  /// Represents a scheduled task.
+  ///
+  /// \a TaskHandles are returned by \a Run* methods, and can be given to the
+  /// \a Cancel method.
+  struct TaskHandle {
+    intptr_t keys[2];
+  };
+  /// A handle to a cancellable connection attempt.
+  ///
+  /// Returned by \a Connect, and can be passed to \a CancelConnect.
+  struct ConnectionHandle {
+    intptr_t keys[2];
+  };
+  /// Thin wrapper around a platform-specific sockaddr type. A sockaddr struct
+  /// exists on all platforms that gRPC supports.
+  ///
+  /// Platforms are expected to provide definitions for:
+  /// * sockaddr
+  /// * sockaddr_in
+  /// * sockaddr_in6
+  class ResolvedAddress {
+   public:
+    static constexpr socklen_t MAX_SIZE_BYTES = 128;
+
+    ResolvedAddress(const sockaddr* address, socklen_t size);
+    ResolvedAddress() = default;
+    ResolvedAddress(const ResolvedAddress&) = default;
+    const struct sockaddr* address() const;
+    socklen_t size() const;
+
+   private:
+    char address_[MAX_SIZE_BYTES];
+    socklen_t size_ = 0;
+  };
+
+  /// One end of a connection between a gRPC client and server. Endpoints are
+  /// created when connections are established, and Endpoint operations are
+  /// gRPC's primary means of communication.
+  ///
+  /// Endpoints must use the provided MemoryAllocator for all data buffer memory
+  /// allocations. gRPC allows applications to set memory constraints per
+  /// Channel or Server, and the implementation depends on all dynamic memory
+  /// allocation being handled by the quota system.
+  class Endpoint {
+   public:
+    /// Shuts down all connections and invokes all pending read or write
+    /// callbacks with an error status.
+    virtual ~Endpoint() = default;
+    /// A struct representing optional arguments that may be provided to an
+    /// EventEngine Endpoint Read API  call.
+    ///
+    /// Passed as argument to an Endpoint \a Read
+    struct ReadArgs {
+      // A suggestion to the endpoint implementation to read at-least the
+      // specified number of bytes over the network connection before marking
+      // the endpoint read operation as complete. gRPC may use this argument
+      // to minimize the number of endpoint read API calls over the lifetime
+      // of a connection.
+      int64_t read_hint_bytes;
+    };
+    /// Reads data from the Endpoint.
+    ///
+    /// When data is available on the connection, that data is moved into the
+    /// \a buffer, and the \a on_read callback is called. The caller must ensure
+    /// that the callback has access to the buffer when executed later.
+    /// Ownership of the buffer is not transferred. Valid slices *may* be placed
+    /// into the buffer even if the callback is invoked with a non-OK Status.
+    ///
+    /// There can be at most one outstanding read per Endpoint at any given
+    /// time. An outstanding read is one in which the \a on_read callback has
+    /// not yet been executed for some previous call to \a Read.  If an attempt
+    /// is made to call \a Read while a previous read is still outstanding, the
+    /// \a EventEngine must abort.
+    ///
+    /// For failed read operations, implementations should pass the appropriate
+    /// statuses to \a on_read. For example, callbacks might expect to receive
+    /// CANCELLED on endpoint shutdown.
+    virtual void Read(absl::AnyInvocable<void(absl::Status)> on_read,
+                      SliceBuffer* buffer, const ReadArgs* args) = 0;
+    /// A struct representing optional arguments that may be provided to an
+    /// EventEngine Endpoint Write API call.
+    ///
+    /// Passed as argument to an Endpoint \a Write
+    struct WriteArgs {
+      // Represents private information that may be passed by gRPC for
+      // select endpoints expected to be used only within google.
+      void* google_specific = nullptr;
+      // A suggestion to the endpoint implementation to group data to be written
+      // into frames of the specified max_frame_size. gRPC may use this
+      // argument to dynamically control the max sizes of frames sent to a
+      // receiver in response to high receiver memory pressure.
+      int64_t max_frame_size;
+    };
+    /// Writes data out on the connection.
+    ///
+    /// \a on_writable is called when the connection is ready for more data. The
+    /// Slices within the \a data buffer may be mutated at will by the Endpoint
+    /// until \a on_writable is called. The \a data SliceBuffer will remain
+    /// valid after calling \a Write, but its state is otherwise undefined.  All
+    /// bytes in \a data must have been written before calling \a on_writable
+    /// unless an error has occurred.
+    ///
+    /// There can be at most one outstanding write per Endpoint at any given
+    /// time. An outstanding write is one in which the \a on_writable callback
+    /// has not yet been executed for some previous call to \a Write.  If an
+    /// attempt is made to call \a Write while a previous write is still
+    /// outstanding, the \a EventEngine must abort.
+    ///
+    /// For failed write operations, implementations should pass the appropriate
+    /// statuses to \a on_writable. For example, callbacks might expect to
+    /// receive CANCELLED on endpoint shutdown.
+    virtual void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+                       SliceBuffer* data, const WriteArgs* args) = 0;
+    /// Returns an address in the format described in DNSResolver. The returned
+    /// values are expected to remain valid for the life of the Endpoint.
+    virtual const ResolvedAddress& GetPeerAddress() const = 0;
+    virtual const ResolvedAddress& GetLocalAddress() const = 0;
+  };
+
+  /// Called when a new connection is established.
+  ///
+  /// If the connection attempt was not successful, implementations should pass
+  /// the appropriate statuses to this callback. For example, callbacks might
+  /// expect to receive DEADLINE_EXCEEDED statuses when appropriate, or
+  /// CANCELLED statuses on EventEngine shutdown.
+  using OnConnectCallback =
+      absl::AnyInvocable<void(absl::StatusOr<std::unique_ptr<Endpoint>>)>;
+
+  /// Listens for incoming connection requests from gRPC clients and initiates
+  /// request processing once connections are established.
+  class Listener {
+   public:
+    /// Called when the listener has accepted a new client connection.
+    using AcceptCallback = absl::AnyInvocable<void(
+        std::unique_ptr<Endpoint>, MemoryAllocator memory_allocator)>;
+    virtual ~Listener() = default;
+    /// Bind an address/port to this Listener.
+    ///
+    /// It is expected that multiple addresses/ports can be bound to this
+    /// Listener before Listener::Start has been called. Returns either the
+    /// bound port or an appropriate error status.
+    virtual absl::StatusOr<int> Bind(const ResolvedAddress& addr) = 0;
+    virtual absl::Status Start() = 0;
+  };
+
+  /// Factory method to create a network listener / server.
+  ///
+  /// Once a \a Listener is created and started, the \a on_accept callback will
+  /// be called once asynchronously for each established connection. This method
+  /// may return a non-OK status immediately if an error was encountered in any
+  /// synchronous steps required to create the Listener. In this case,
+  /// \a on_shutdown will never be called.
+  ///
+  /// If this method returns a Listener, then \a on_shutdown will be invoked
+  /// exactly once, when the Listener is shut down. The status passed to it will
+  /// indicate if there was a problem during shutdown.
+  ///
+  /// The provided \a MemoryAllocatorFactory is used to create \a
+  /// MemoryAllocators for Endpoint construction.
+  virtual absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+      Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) = 0;
+  /// Creates a client network connection to a remote network listener.
+  ///
+  /// Even in the event of an error, it is expected that the \a on_connect
+  /// callback will be asynchronously executed exactly once by the EventEngine.
+  /// A connection attempt can be cancelled using the \a CancelConnect method.
+  ///
+  /// Implementation Note: it is important that the \a memory_allocator be used
+  /// for all read/write buffer allocations in the EventEngine implementation.
+  /// This allows gRPC's \a ResourceQuota system to monitor and control memory
+  /// usage with graceful degradation mechanisms. Please see the \a
+  /// MemoryAllocator API for more information.
+  virtual ConnectionHandle Connect(OnConnectCallback on_connect,
+                                   const ResolvedAddress& addr,
+                                   const EndpointConfig& args,
+                                   MemoryAllocator memory_allocator,
+                                   Duration timeout) = 0;
+
+  /// Request cancellation of a connection attempt.
+  ///
+  /// If the associated connection has already been completed, it will not be
+  /// cancelled, and this method will return false.
+  ///
+  /// If the associated connection has not been completed, it will be cancelled,
+  /// and this method will return true. The \a OnConnectCallback will not be
+  /// called.
+  virtual bool CancelConnect(ConnectionHandle handle) = 0;
+  /// Provides asynchronous resolution.
+  class DNSResolver {
+   public:
+    /// Task handle for DNS Resolution requests.
+    struct LookupTaskHandle {
+      intptr_t keys[2];
+    };
+    /// Optional configuration for DNSResolvers.
+    struct ResolverOptions {
+      /// If empty, default DNS servers will be used.
+      /// Must be in the "IP:port" format as described in naming.md.
+      std::string dns_server;
+    };
+    /// DNS SRV record type.
+    struct SRVRecord {
+      std::string host;
+      int port = 0;
+      int priority = 0;
+      int weight = 0;
+    };
+    /// Called with the collection of sockaddrs that were resolved from a given
+    /// target address.
+    using LookupHostnameCallback =
+        absl::AnyInvocable<void(absl::StatusOr<std::vector<ResolvedAddress>>)>;
+    /// Called with a collection of SRV records.
+    using LookupSRVCallback =
+        absl::AnyInvocable<void(absl::StatusOr<std::vector<SRVRecord>>)>;
+    /// Called with the result of a TXT record lookup
+    using LookupTXTCallback =
+        absl::AnyInvocable<void(absl::StatusOr<std::string>)>;
+
+    virtual ~DNSResolver() = default;
+
+    /// Asynchronously resolve an address.
+    ///
+    /// \a default_port may be a non-numeric named service port, and will only
+    /// be used if \a address does not already contain a port component.
+    ///
+    /// When the lookup is complete, the \a on_resolve callback will be invoked
+    /// with a status indicating the success or failure of the lookup.
+    /// Implementations should pass the appropriate statuses to the callback.
+    /// For example, callbacks might expect to receive DEADLINE_EXCEEDED or
+    /// NOT_FOUND.
+    ///
+    /// If cancelled, \a on_resolve will not be executed.
+    virtual LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
+                                            absl::string_view name,
+                                            absl::string_view default_port,
+                                            Duration timeout) = 0;
+    /// Asynchronously perform an SRV record lookup.
+    ///
+    /// \a on_resolve has the same meaning and expectations as \a
+    /// LookupHostname's \a on_resolve callback.
+    virtual LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
+                                       absl::string_view name,
+                                       Duration timeout) = 0;
+    /// Asynchronously perform a TXT record lookup.
+    ///
+    /// \a on_resolve has the same meaning and expectations as \a
+    /// LookupHostname's \a on_resolve callback.
+    virtual LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
+                                       absl::string_view name,
+                                       Duration timeout) = 0;
+    /// Cancel an asynchronous lookup operation.
+    ///
+    /// This shares the same semantics with \a EventEngine::Cancel: successfully
+    /// cancelled lookups will not have their callbacks executed, and this
+    /// method returns true.
+    virtual bool CancelLookup(LookupTaskHandle handle) = 0;
+  };
+
+  /// At time of destruction, the EventEngine must have no active
+  /// responsibilities. EventEngine users (applications) are responsible for
+  /// cancelling all tasks and DNS lookups, shutting down listeners and
+  /// endpoints, prior to EventEngine destruction. If there are any outstanding
+  /// tasks, any running listeners, etc. at time of EventEngine destruction,
+  /// that is an invalid use of the API, and it will result in undefined
+  /// behavior.
+  virtual ~EventEngine() = default;
+
+  // TODO(nnoble): consider whether we can remove this method before we
+  // de-experimentalize this API.
+  virtual bool IsWorkerThread() = 0;
+
+  /// Creates and returns an instance of a DNSResolver, optionally configured by
+  /// the \a options struct.
+  virtual std::unique_ptr<DNSResolver> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) = 0;
+
+  /// Asynchronously executes a task as soon as possible.
+  ///
+  /// \a Closures scheduled with \a Run cannot be cancelled. The \a closure will
+  /// not be deleted after it has been run, ownership remains with the caller.
+  virtual void Run(Closure* closure) = 0;
+  /// Asynchronously executes a task as soon as possible.
+  ///
+  /// \a Closures scheduled with \a Run cannot be cancelled. Unlike the
+  /// overloaded \a Closure alternative, the absl::AnyInvocable version's \a
+  /// closure will be deleted by the EventEngine after the closure has been run.
+  ///
+  /// This version of \a Run may be less performant than the \a Closure version
+  /// in some scenarios. This overload is useful in situations where performance
+  /// is not a critical concern.
+  virtual void Run(absl::AnyInvocable<void()> closure) = 0;
+  /// Synonymous with scheduling an alarm to run after duration \a when.
+  ///
+  /// The \a closure will execute when time \a when arrives unless it has been
+  /// cancelled via the \a Cancel method. If cancelled, the closure will not be
+  /// run, nor will it be deleted. Ownership remains with the caller.
+  virtual TaskHandle RunAfter(Duration when, Closure* closure) = 0;
+  /// Synonymous with scheduling an alarm to run after duration \a when.
+  ///
+  /// The \a closure will execute when time \a when arrives unless it has been
+  /// cancelled via the \a Cancel method. If cancelled, the closure will not be
+  /// run. Unilke the overloaded \a Closure alternative, the absl::AnyInvocable
+  /// version's \a closure will be deleted by the EventEngine after the closure
+  /// has been run, or upon cancellation.
+  ///
+  /// This version of \a RunAfter may be less performant than the \a Closure
+  /// version in some scenarios. This overload is useful in situations where
+  /// performance is not a critical concern.
+  virtual TaskHandle RunAfter(Duration when,
+                              absl::AnyInvocable<void()> closure) = 0;
+  /// Request cancellation of a task.
+  ///
+  /// If the associated closure has already been scheduled to run, it will not
+  /// be cancelled, and this function will return false.
+  ///
+  /// If the associated callback has not been scheduled to run, it will be
+  /// cancelled, and the associated absl::AnyInvocable or \a Closure* will not
+  /// be executed. In this case, Cancel will return true.
+  ///
+  /// Implementation note: closures should be destroyed in a timely manner after
+  /// execution or cancelliation (milliseconds), since any state bound to the
+  /// closure may need to be destroyed for things to progress (e.g., if a
+  /// closure holds a ref to some ref-counted object).
+  virtual bool Cancel(TaskHandle handle) = 0;
+};
+
+/// Replace gRPC's default EventEngine factory.
+///
+/// Applications may call \a SetDefaultEventEngineFactory at any time to replace
+/// the default factory used within gRPC. EventEngines will be created when
+/// necessary, when they are otherwise not provided by the application.
+///
+/// To be certain that none of the gRPC-provided built-in EventEngines are
+/// created, applications must set a custom EventEngine factory method *before*
+/// grpc is initialized.
+void SetDefaultEventEngineFactory(
+    absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory);
+
+/// Create an EventEngine using the default factory.
+std::unique_ptr<EventEngine> CreateEventEngine();
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_EVENT_ENGINE_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/internal/memory_allocator_impl.h b/CAPI/cpp/grpc/include/grpc/event_engine/internal/memory_allocator_impl.h
new file mode 100644
index 0000000..e0ca2f5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/internal/memory_allocator_impl.h
@@ -0,0 +1,68 @@
+// Copyright 2021 The gRPC Authors
+//
+// 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.
+#ifndef GRPC_EVENT_ENGINE_INTERNAL_MEMORY_ALLOCATOR_IMPL_H
+#define GRPC_EVENT_ENGINE_INTERNAL_MEMORY_ALLOCATOR_IMPL_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <algorithm>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include <grpc/event_engine/memory_request.h>
+#include <grpc/slice.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace internal {
+
+/// Underlying memory allocation interface.
+/// This is an internal interface, not intended to be used by users.
+/// Its interface is subject to change at any time.
+class MemoryAllocatorImpl
+    : public std::enable_shared_from_this<MemoryAllocatorImpl> {
+ public:
+  MemoryAllocatorImpl() {}
+  virtual ~MemoryAllocatorImpl() {}
+
+  MemoryAllocatorImpl(const MemoryAllocatorImpl&) = delete;
+  MemoryAllocatorImpl& operator=(const MemoryAllocatorImpl&) = delete;
+
+  /// Reserve bytes from the quota.
+  /// If we enter overcommit, reclamation will begin concurrently.
+  /// Returns the number of bytes reserved.
+  /// If MemoryRequest is invalid, this function will abort.
+  /// If MemoryRequest is valid, this function is infallible, and will always
+  /// succeed at reserving the some number of bytes between request.min() and
+  /// request.max() inclusively.
+  virtual size_t Reserve(MemoryRequest request) = 0;
+
+  /// Release some bytes that were previously reserved.
+  /// If more bytes are released than were reserved, we will have undefined
+  /// behavior.
+  virtual void Release(size_t n) = 0;
+
+  /// Shutdown this allocator.
+  /// Further usage of Reserve() is undefined behavior.
+  virtual void Shutdown() = 0;
+};
+
+}  // namespace internal
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_INTERNAL_MEMORY_ALLOCATOR_IMPL_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/memory_allocator.h b/CAPI/cpp/grpc/include/grpc/event_engine/memory_allocator.h
new file mode 100644
index 0000000..ec10674
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/memory_allocator.h
@@ -0,0 +1,211 @@
+// Copyright 2021 The gRPC Authors
+//
+// 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.
+#ifndef GRPC_EVENT_ENGINE_MEMORY_ALLOCATOR_H
+#define GRPC_EVENT_ENGINE_MEMORY_ALLOCATOR_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <stdlib.h>  // for abort()
+
+#include <algorithm>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include <grpc/event_engine/internal/memory_allocator_impl.h>
+#include <grpc/slice.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Tracks memory allocated by one system.
+// Is effectively a thin wrapper/smart pointer for a MemoryAllocatorImpl,
+// providing a convenient and stable API.
+class MemoryAllocator {
+ public:
+  /// Construct a MemoryAllocator given an internal::MemoryAllocatorImpl
+  /// implementation. The constructed MemoryAllocator will call
+  /// MemoryAllocatorImpl::Shutdown() upon destruction.
+  explicit MemoryAllocator(
+      std::shared_ptr<internal::MemoryAllocatorImpl> allocator)
+      : allocator_(std::move(allocator)) {}
+  // Construct an invalid MemoryAllocator.
+  MemoryAllocator() : allocator_(nullptr) {}
+  ~MemoryAllocator() {
+    if (allocator_ != nullptr) allocator_->Shutdown();
+  }
+
+  MemoryAllocator(const MemoryAllocator&) = delete;
+  MemoryAllocator& operator=(const MemoryAllocator&) = delete;
+
+  MemoryAllocator(MemoryAllocator&&) = default;
+  MemoryAllocator& operator=(MemoryAllocator&&) = default;
+
+  /// Drop the underlying allocator and make this an empty object.
+  /// The object will not be usable after this call unless it's a valid
+  /// allocator is moved into it.
+  void Reset() {
+    if (allocator_ != nullptr) allocator_->Shutdown();
+    allocator_.reset();
+  }
+
+  /// Reserve bytes from the quota.
+  /// If we enter overcommit, reclamation will begin concurrently.
+  /// Returns the number of bytes reserved.
+  size_t Reserve(MemoryRequest request) { return allocator_->Reserve(request); }
+
+  /// Release some bytes that were previously reserved.
+  void Release(size_t n) { return allocator_->Release(n); }
+
+  //
+  // The remainder of this type are helper functions implemented in terms of
+  // Reserve/Release.
+  //
+
+  /// An automatic releasing reservation of memory.
+  class Reservation {
+   public:
+    Reservation() = default;
+    Reservation(const Reservation&) = delete;
+    Reservation& operator=(const Reservation&) = delete;
+    Reservation(Reservation&&) = default;
+    Reservation& operator=(Reservation&&) = default;
+    ~Reservation() {
+      if (allocator_ != nullptr) allocator_->Release(size_);
+    }
+
+   private:
+    friend class MemoryAllocator;
+    Reservation(std::shared_ptr<internal::MemoryAllocatorImpl> allocator,
+                size_t size)
+        : allocator_(std::move(allocator)), size_(size) {}
+
+    std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
+    size_t size_ = 0;
+  };
+
+  /// Reserve bytes from the quota and automatically release them when
+  /// Reservation is destroyed.
+  Reservation MakeReservation(MemoryRequest request) {
+    return Reservation(allocator_, Reserve(request));
+  }
+
+  /// Allocate a new object of type T, with constructor arguments.
+  /// The returned type is wrapped, and upon destruction the reserved memory
+  /// will be released to the allocator automatically. As such, T must have a
+  /// virtual destructor so we can insert the necessary hook.
+  template <typename T, typename... Args>
+  typename std::enable_if<std::has_virtual_destructor<T>::value, T*>::type New(
+      Args&&... args) {
+    // Wrap T such that when it's destroyed, we can release memory back to the
+    // allocator.
+    class Wrapper final : public T {
+     public:
+      explicit Wrapper(std::shared_ptr<internal::MemoryAllocatorImpl> allocator,
+                       Args&&... args)
+          : T(std::forward<Args>(args)...), allocator_(std::move(allocator)) {}
+      ~Wrapper() override { allocator_->Release(sizeof(*this)); }
+
+     private:
+      const std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
+    };
+    Reserve(sizeof(Wrapper));
+    return new Wrapper(allocator_, std::forward<Args>(args)...);
+  }
+
+  /// Construct a unique_ptr immediately.
+  template <typename T, typename... Args>
+  std::unique_ptr<T> MakeUnique(Args&&... args) {
+    return std::unique_ptr<T>(New<T>(std::forward<Args>(args)...));
+  }
+
+  /// Allocate a slice, using MemoryRequest to size the number of returned
+  /// bytes. For a variable length request, check the returned slice length to
+  /// verify how much memory was allocated. Takes care of reserving memory for
+  /// any relevant control structures also.
+  grpc_slice MakeSlice(MemoryRequest request);
+
+  /// A C++ allocator for containers of T.
+  template <typename T>
+  class Container {
+   public:
+    using value_type = T;
+
+    /// Construct the allocator: \a underlying_allocator is borrowed, and must
+    /// outlive this object.
+    explicit Container(MemoryAllocator* underlying_allocator)
+        : underlying_allocator_(underlying_allocator) {}
+    template <typename U>
+    explicit Container(const Container<U>& other)
+        : underlying_allocator_(other.underlying_allocator()) {}
+
+    MemoryAllocator* underlying_allocator() const {
+      return underlying_allocator_;
+    }
+
+    T* allocate(size_t n) {
+      underlying_allocator_->Reserve(n * sizeof(T));
+      return static_cast<T*>(::operator new(n * sizeof(T)));
+    }
+    void deallocate(T* p, size_t n) {
+      ::operator delete(p);
+      underlying_allocator_->Release(n * sizeof(T));
+    }
+
+   private:
+    MemoryAllocator* underlying_allocator_;
+  };
+
+ protected:
+  /// Return a pointer to the underlying implementation.
+  /// Note that the interface of said implementation is unstable and likely to
+  /// change at any time.
+  internal::MemoryAllocatorImpl* get_internal_impl_ptr() {
+    return allocator_.get();
+  }
+
+  const internal::MemoryAllocatorImpl* get_internal_impl_ptr() const {
+    return allocator_.get();
+  }
+
+ private:
+  std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
+};
+
+// Wrapper type around std::vector to make initialization against a
+// MemoryAllocator based container allocator easy.
+template <typename T>
+class Vector : public std::vector<T, MemoryAllocator::Container<T>> {
+ public:
+  explicit Vector(MemoryAllocator* allocator)
+      : std::vector<T, MemoryAllocator::Container<T>>(
+            MemoryAllocator::Container<T>(allocator)) {}
+};
+
+class MemoryAllocatorFactory {
+ public:
+  virtual ~MemoryAllocatorFactory() = default;
+  /// On Endpoint creation, call \a CreateMemoryAllocator to create a new
+  /// allocator for the endpoint.
+  /// \a name is used to label the memory allocator in debug logs.
+  /// Typically we'll want to:
+  ///    auto allocator = factory->CreateMemoryAllocator(peer_address_string);
+  ///    auto* endpoint = allocator->New<MyEndpoint>(std::move(allocator), ...);
+  virtual MemoryAllocator CreateMemoryAllocator(absl::string_view name) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_MEMORY_ALLOCATOR_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/memory_request.h b/CAPI/cpp/grpc/include/grpc/event_engine/memory_request.h
new file mode 100644
index 0000000..fa15e26
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/memory_request.h
@@ -0,0 +1,57 @@
+// Copyright 2021 The gRPC Authors
+//
+// 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.
+#ifndef GRPC_EVENT_ENGINE_MEMORY_REQUEST_H
+#define GRPC_EVENT_ENGINE_MEMORY_REQUEST_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// Reservation request - how much memory do we want to allocate?
+class MemoryRequest {
+ public:
+  /// Request a fixed amount of memory.
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  MemoryRequest(size_t n) : min_(n), max_(n) {}
+  /// Request a range of memory.
+  /// Requires: \a min <= \a max.
+  /// Requires: \a max <= max_size()
+  MemoryRequest(size_t min, size_t max) : min_(min), max_(max) {}
+
+  /// Maximum allowable request size - hard coded to 1GB.
+  static constexpr size_t max_allowed_size() { return 1024 * 1024 * 1024; }
+
+  /// Increase the size by \a amount.
+  /// Undefined behavior if min() + amount or max() + amount overflows.
+  MemoryRequest Increase(size_t amount) const {
+    return MemoryRequest(min_ + amount, max_ + amount);
+  }
+
+  size_t min() const { return min_; }
+  size_t max() const { return max_; }
+
+ private:
+  size_t min_;
+  size_t max_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_MEMORY_REQUEST_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/port.h b/CAPI/cpp/grpc/include/grpc/event_engine/port.h
new file mode 100644
index 0000000..3055a66
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/port.h
@@ -0,0 +1,39 @@
+// Copyright 2021 The gRPC Authors
+//
+// 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.
+#ifndef GRPC_EVENT_ENGINE_PORT_H
+#define GRPC_EVENT_ENGINE_PORT_H
+
+#include <grpc/support/port_platform.h>
+
+// Platform-specific sockaddr includes
+#if defined(GPR_ANDROID) || defined(GPR_LINUX) || defined(GPR_APPLE) ||     \
+    defined(GPR_FREEBSD) || defined(GPR_OPENBSD) || defined(GPR_SOLARIS) || \
+    defined(GPR_AIX) || defined(GPR_NACL) || defined(GPR_FUCHSIA) ||        \
+    defined(GRPC_POSIX_SOCKET) || defined(GPR_NETBSD)
+#define GRPC_EVENT_ENGINE_POSIX
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#elif defined(GPR_WINDOWS)
+#include <winsock2.h>
+#include <ws2tcpip.h>
+// must be included after the above
+#include <mswsock.h>
+#else
+#error UNKNOWN PLATFORM
+#endif
+
+#endif  // GRPC_EVENT_ENGINE_PORT_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/slice.h b/CAPI/cpp/grpc/include/grpc/event_engine/slice.h
new file mode 100644
index 0000000..515cdfd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/slice.h
@@ -0,0 +1,286 @@
+// Copyright 2022 gRPC authors.
+//
+// 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.
+
+#ifndef GRPC_EVENT_ENGINE_SLICE_H
+#define GRPC_EVENT_ENGINE_SLICE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string.h>
+
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/slice.h>
+#include <grpc/support/log.h>
+
+// This public slice definition largely based of the internal grpc_core::Slice
+// implementation. Changes to this implementation might warrant changes to the
+// internal grpc_core::Slice type as well.
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Forward declarations
+class Slice;
+class MutableSlice;
+
+namespace slice_detail {
+
+// Returns an empty slice.
+static constexpr grpc_slice EmptySlice() { return {nullptr, {}}; }
+
+// BaseSlice holds the grpc_slice object, but does not apply refcounting policy.
+// It does export immutable access into the slice, such that this can be shared
+// by all storage policies.
+class BaseSlice {
+ public:
+  BaseSlice(const BaseSlice&) = delete;
+  BaseSlice& operator=(const BaseSlice&) = delete;
+  BaseSlice(BaseSlice&& other) = delete;
+  BaseSlice& operator=(BaseSlice&& other) = delete;
+
+  // Iterator access to the underlying bytes
+  const uint8_t* begin() const { return GRPC_SLICE_START_PTR(c_slice()); }
+  const uint8_t* end() const { return GRPC_SLICE_END_PTR(c_slice()); }
+  const uint8_t* cbegin() const { return GRPC_SLICE_START_PTR(c_slice()); }
+  const uint8_t* cend() const { return GRPC_SLICE_END_PTR(c_slice()); }
+
+  // Retrieve a borrowed reference to the underlying grpc_slice.
+  const grpc_slice& c_slice() const { return slice_; }
+
+  // Retrieve the underlying grpc_slice, and replace the one in this object with
+  // EmptySlice().
+  grpc_slice TakeCSlice() {
+    grpc_slice out = slice_;
+    slice_ = EmptySlice();
+    return out;
+  }
+
+  // As other things... borrowed references.
+  absl::string_view as_string_view() const {
+    return absl::string_view(reinterpret_cast<const char*>(data()), size());
+  }
+
+  // Array access
+  uint8_t operator[](size_t i) const {
+    return GRPC_SLICE_START_PTR(c_slice())[i];
+  }
+
+  // Access underlying data
+  const uint8_t* data() const { return GRPC_SLICE_START_PTR(c_slice()); }
+
+  // Size of the slice
+  size_t size() const { return GRPC_SLICE_LENGTH(c_slice()); }
+  size_t length() const { return size(); }
+  bool empty() const { return size() == 0; }
+
+  // For inlined slices - are these two slices equal?
+  // For non-inlined slices - do these two slices refer to the same block of
+  // memory?
+  bool is_equivalent(const BaseSlice& other) const {
+    return grpc_slice_is_equivalent(slice_, other.slice_);
+  }
+
+  uint32_t Hash() const;
+
+ protected:
+  BaseSlice() : slice_(EmptySlice()) {}
+  explicit BaseSlice(const grpc_slice& slice) : slice_(slice) {}
+  ~BaseSlice() = default;
+
+  void Swap(BaseSlice* other) { std::swap(slice_, other->slice_); }
+  void SetCSlice(const grpc_slice& slice) { slice_ = slice; }
+
+  uint8_t* mutable_data() { return GRPC_SLICE_START_PTR(slice_); }
+
+  grpc_slice* c_slice_ptr() { return &slice_; }
+
+ private:
+  grpc_slice slice_;
+};
+
+inline bool operator==(const BaseSlice& a, const BaseSlice& b) {
+  return grpc_slice_eq(a.c_slice(), b.c_slice()) != 0;
+}
+
+inline bool operator!=(const BaseSlice& a, const BaseSlice& b) {
+  return grpc_slice_eq(a.c_slice(), b.c_slice()) == 0;
+}
+
+inline bool operator==(const BaseSlice& a, absl::string_view b) {
+  return a.as_string_view() == b;
+}
+
+inline bool operator!=(const BaseSlice& a, absl::string_view b) {
+  return a.as_string_view() != b;
+}
+
+inline bool operator==(absl::string_view a, const BaseSlice& b) {
+  return a == b.as_string_view();
+}
+
+inline bool operator!=(absl::string_view a, const BaseSlice& b) {
+  return a != b.as_string_view();
+}
+
+inline bool operator==(const BaseSlice& a, const grpc_slice& b) {
+  return grpc_slice_eq(a.c_slice(), b) != 0;
+}
+
+inline bool operator!=(const BaseSlice& a, const grpc_slice& b) {
+  return grpc_slice_eq(a.c_slice(), b) == 0;
+}
+
+inline bool operator==(const grpc_slice& a, const BaseSlice& b) {
+  return grpc_slice_eq(a, b.c_slice()) != 0;
+}
+
+inline bool operator!=(const grpc_slice& a, const BaseSlice& b) {
+  return grpc_slice_eq(a, b.c_slice()) == 0;
+}
+
+template <typename Out>
+struct CopyConstructors {
+  static Out FromCopiedString(const char* s) {
+    return FromCopiedBuffer(s, strlen(s));
+  }
+  static Out FromCopiedString(absl::string_view s) {
+    return FromCopiedBuffer(s.data(), s.size());
+  }
+  static Out FromCopiedString(std::string s);
+
+  static Out FromCopiedBuffer(const char* p, size_t len) {
+    return Out(grpc_slice_from_copied_buffer(p, len));
+  }
+
+  template <typename Buffer>
+  static Out FromCopiedBuffer(const Buffer& buffer) {
+    return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()),
+                            buffer.size());
+  }
+};
+
+}  // namespace slice_detail
+
+class MutableSlice : public slice_detail::BaseSlice,
+                     public slice_detail::CopyConstructors<MutableSlice> {
+ public:
+  MutableSlice() = default;
+  explicit MutableSlice(const grpc_slice& slice);
+  ~MutableSlice();
+
+  MutableSlice(const MutableSlice&) = delete;
+  MutableSlice& operator=(const MutableSlice&) = delete;
+  MutableSlice(MutableSlice&& other) noexcept
+      : slice_detail::BaseSlice(other.TakeCSlice()) {}
+  MutableSlice& operator=(MutableSlice&& other) noexcept {
+    Swap(&other);
+    return *this;
+  }
+
+  static MutableSlice CreateUninitialized(size_t length) {
+    return MutableSlice(grpc_slice_malloc(length));
+  }
+
+  // Return a sub slice of this one. Leaves this slice in an indeterminate but
+  // valid state.
+  MutableSlice TakeSubSlice(size_t pos, size_t n) {
+    return MutableSlice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
+  }
+
+  // Iterator access to the underlying bytes
+  uint8_t* begin() { return mutable_data(); }
+  uint8_t* end() { return mutable_data() + size(); }
+  uint8_t* data() { return mutable_data(); }
+
+  // Array access
+  uint8_t& operator[](size_t i) { return mutable_data()[i]; }
+};
+
+class Slice : public slice_detail::BaseSlice,
+              public slice_detail::CopyConstructors<Slice> {
+ public:
+  Slice() = default;
+  ~Slice();
+  explicit Slice(const grpc_slice& slice) : slice_detail::BaseSlice(slice) {}
+  explicit Slice(slice_detail::BaseSlice&& other)
+      : slice_detail::BaseSlice(other.TakeCSlice()) {}
+
+  Slice(const Slice&) = delete;
+  Slice& operator=(const Slice&) = delete;
+  Slice(Slice&& other) noexcept : slice_detail::BaseSlice(other.TakeCSlice()) {}
+  Slice& operator=(Slice&& other) noexcept {
+    Swap(&other);
+    return *this;
+  }
+
+  // A slice might refer to some memory that we keep a refcount to (this is
+  // owned), or some memory that's inlined into the slice (also owned), or some
+  // other block of memory that we know will be available for the lifetime of
+  // some operation in the common case (not owned). In the *less common* case
+  // that we need to keep that slice text for longer than our API's guarantee us
+  // access, we need to take a copy and turn this into something that we do own.
+
+  // TakeOwned returns an owned slice regardless of current ownership, and
+  // leaves the current slice in a valid but externally unpredictable state - in
+  // doing so it can avoid adding a ref to the underlying slice.
+  Slice TakeOwned();
+
+  // AsOwned returns an owned slice but does not mutate the current slice,
+  // meaning that it may add a reference to the underlying slice.
+  Slice AsOwned() const;
+
+  // TakeMutable returns a MutableSlice, and leaves the current slice in an
+  // indeterminate but valid state.
+  // A mutable slice requires only one reference to the bytes of the slice -
+  // this can be achieved either with inlined storage or with a single
+  // reference.
+  // If the current slice is refcounted and there are more than one references
+  // to that slice, then the slice is copied in order to achieve a mutable
+  // version.
+  MutableSlice TakeMutable();
+
+  // Return a sub slice of this one. Leaves this slice in an indeterminate but
+  // valid state.
+  Slice TakeSubSlice(size_t pos, size_t n) {
+    return Slice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
+  }
+
+  // Return a sub slice of this one. Adds a reference to the underlying slice.
+  Slice RefSubSlice(size_t pos, size_t n) const {
+    return Slice(grpc_slice_sub(c_slice(), pos, pos + n));
+  }
+
+  // Split this slice, returning a new slice containing (split:end] and
+  // leaving this slice with [begin:split).
+  Slice Split(size_t split) {
+    return Slice(grpc_slice_split_tail(c_slice_ptr(), split));
+  }
+
+  Slice Ref() const;
+
+  Slice Copy() const { return Slice(grpc_slice_copy(c_slice())); }
+
+  static Slice FromRefcountAndBytes(grpc_slice_refcount* r,
+                                    const uint8_t* begin, const uint8_t* end);
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_SLICE_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/slice_buffer.h b/CAPI/cpp/grpc/include/grpc/event_engine/slice_buffer.h
new file mode 100644
index 0000000..3861717
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/slice_buffer.h
@@ -0,0 +1,118 @@
+// Copyright 2022 gRPC authors.
+//
+// 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.
+
+#ifndef GRPC_EVENT_ENGINE_SLICE_BUFFER_H
+#define GRPC_EVENT_ENGINE_SLICE_BUFFER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string.h>
+
+#include <cstdint>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/utility/utility.h"
+
+#include <grpc/event_engine/slice.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/log.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// A Wrapper around \a grpc_slice_buffer pointer.
+///
+/// A slice buffer holds the memory for a collection of slices.
+/// The SliceBuffer object itself is meant to only hide the C-style API,
+/// and won't hold the data itself. In terms of lifespan, the
+/// grpc_slice_buffer ought to be kept somewhere inside the caller's objects,
+/// like a transport or an endpoint.
+///
+/// This lifespan rule is likely to change in the future, as we may
+/// collapse the grpc_slice_buffer structure straight into this class.
+///
+/// The SliceBuffer API is basically a replica of the grpc_slice_buffer's,
+/// and its documentation will move here once we remove the C structure,
+/// which should happen before the Event Engine's API is no longer
+/// an experimental API.
+class SliceBuffer {
+ public:
+  explicit SliceBuffer() { grpc_slice_buffer_init(&slice_buffer_); }
+  SliceBuffer(const SliceBuffer& other) = delete;
+  SliceBuffer(SliceBuffer&& other) noexcept
+      : slice_buffer_(other.slice_buffer_) {
+    grpc_slice_buffer_init(&slice_buffer_);
+    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
+  }
+  /// Upon destruction, the underlying raw slice buffer is cleaned out and all
+  /// slices are unreffed.
+  ~SliceBuffer() { grpc_slice_buffer_destroy(&slice_buffer_); }
+
+  SliceBuffer& operator=(const SliceBuffer&) = delete;
+  SliceBuffer& operator=(SliceBuffer&& other) noexcept {
+    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
+    return *this;
+  }
+
+  /// Appends a new slice into the SliceBuffer and makes an attempt to merge
+  /// this slice with the last slice in the SliceBuffer.
+  void Append(Slice slice);
+
+  /// Adds a new slice into the SliceBuffer at the next available index.
+  /// Returns the index at which the new slice is added.
+  size_t AppendIndexed(Slice slice);
+
+  /// Returns the number of slices held by the SliceBuffer.
+  size_t Count() { return slice_buffer_.count; }
+
+  /// Removes/deletes the last n bytes in the SliceBuffer.
+  void RemoveLastNBytes(size_t n) {
+    grpc_slice_buffer_trim_end(&slice_buffer_, n, nullptr);
+  }
+
+  /// Move the first n bytes of the SliceBuffer into a memory pointed to by dst.
+  void MoveFirstNBytesIntoBuffer(size_t n, void* dst) {
+    grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
+  }
+
+  /// Removes and unrefs all slices in the SliceBuffer.
+  void Clear() { grpc_slice_buffer_reset_and_unref(&slice_buffer_); }
+
+  /// Removes the first slice in the SliceBuffer and returns it.
+  Slice TakeFirst();
+
+  /// Prepends the slice to the the front of the SliceBuffer.
+  void Prepend(Slice slice);
+
+  /// Increased the ref-count of slice at the specified index and returns the
+  /// associated slice.
+  Slice RefSlice(size_t index);
+
+  /// The total number of bytes held by the SliceBuffer
+  size_t Length() { return slice_buffer_.length; }
+
+  /// Return a pointer to the back raw grpc_slice_buffer
+  grpc_slice_buffer* c_slice_buffer() { return &slice_buffer_; }
+
+ private:
+  /// The backing raw slice buffer.
+  grpc_slice_buffer slice_buffer_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_SLICE_BUFFER_H
diff --git a/CAPI/cpp/grpc/include/grpc/fork.h b/CAPI/cpp/grpc/include/grpc/fork.h
new file mode 100644
index 0000000..f52cb50
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/fork.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_FORK_H
+#define GRPC_FORK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/fork.h>  // IWYU pragma: export
+
+#endif /* GRPC_FORK_H */
diff --git a/CAPI/cpp/grpc/include/grpc/grpc.h b/CAPI/cpp/grpc/include/grpc/grpc.h
new file mode 100644
index 0000000..de40299
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/grpc.h
@@ -0,0 +1,605 @@
+/*
+ *
+ * Copyright 2015-2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_GRPC_H
+#define GRPC_GRPC_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <grpc/byte_buffer.h>
+#include <grpc/impl/codegen/connectivity_state.h>  // IWYU pragma: export
+#include <grpc/impl/codegen/grpc_types.h>          // IWYU pragma: export
+#include <grpc/impl/codegen/propagation_bits.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
+#include <grpc/support/time.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*! \mainpage GRPC Core
+ *
+ * The GRPC Core library is a low-level library designed to be wrapped by higher
+ * level libraries. The top-level API is provided in grpc.h. Security related
+ * functionality lives in grpc_security.h.
+ */
+
+GRPCAPI void grpc_metadata_array_init(grpc_metadata_array* array);
+GRPCAPI void grpc_metadata_array_destroy(grpc_metadata_array* array);
+
+GRPCAPI void grpc_call_details_init(grpc_call_details* details);
+GRPCAPI void grpc_call_details_destroy(grpc_call_details* details);
+
+/** Registers a plugin to be initialized and destroyed with the library.
+
+    The \a init and \a destroy functions will be invoked as part of
+    \a grpc_init() and \a grpc_shutdown(), respectively.
+    Note that these functions can be invoked an arbitrary number of times
+    (and hence so will \a init and \a destroy).
+    It is safe to pass NULL to either argument. Plugins are destroyed in
+    the reverse order they were initialized. */
+GRPCAPI void grpc_register_plugin(void (*init)(void), void (*destroy)(void));
+
+/** Initialize the grpc library.
+
+    After it's called, a matching invocation to grpc_shutdown() is expected.
+
+    It is not safe to call any other grpc functions before calling this.
+    (To avoid overhead, little checking is done, and some things may work. We
+    do not warrant that they will continue to do so in future revisions of this
+    library). */
+GRPCAPI void grpc_init(void);
+
+/** Shut down the grpc library.
+
+    Before it's called, there should haven been a matching invocation to
+    grpc_init().
+
+    The last call to grpc_shutdown will initiate cleaning up of grpc library
+    internals, which can happen in another thread. Once the clean-up is done,
+    no memory is used by grpc, nor are any instructions executing within the
+    grpc library.  Prior to calling, all application owned grpc objects must
+    have been destroyed. */
+GRPCAPI void grpc_shutdown(void);
+
+/** EXPERIMENTAL. Returns 1 if the grpc library has been initialized.
+    TODO(ericgribkoff) Decide if this should be promoted to non-experimental as
+    part of stabilizing the fork support API, as tracked in
+    https://github.com/grpc/grpc/issues/15334 */
+GRPCAPI int grpc_is_initialized(void);
+
+/** DEPRECATED. Recommend to use grpc_shutdown only */
+GRPCAPI void grpc_shutdown_blocking(void);
+
+/** Return a string representing the current version of grpc */
+GRPCAPI const char* grpc_version_string(void);
+
+/** Return a string specifying what the 'g' in gRPC stands for */
+GRPCAPI const char* grpc_g_stands_for(void);
+
+/** Returns the completion queue factory based on the attributes. MAY return a
+    NULL if no factory can be found */
+GRPCAPI const grpc_completion_queue_factory*
+grpc_completion_queue_factory_lookup(
+    const grpc_completion_queue_attributes* attributes);
+
+/** Helper function to create a completion queue with grpc_cq_completion_type
+    of GRPC_CQ_NEXT and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING */
+GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_next(
+    void* reserved);
+
+/** Helper function to create a completion queue with grpc_cq_completion_type
+    of GRPC_CQ_PLUCK and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING */
+GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_pluck(
+    void* reserved);
+
+/** Helper function to create a completion queue with grpc_cq_completion_type
+    of GRPC_CQ_CALLBACK and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING.
+    This function is experimental. */
+GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_callback(
+    grpc_completion_queue_functor* shutdown_callback, void* reserved);
+
+/** Create a completion queue */
+GRPCAPI grpc_completion_queue* grpc_completion_queue_create(
+    const grpc_completion_queue_factory* factory,
+    const grpc_completion_queue_attributes* attributes, void* reserved);
+
+/** Blocks until an event is available, the completion queue is being shut down,
+    or deadline is reached.
+
+    Returns a grpc_event with type GRPC_QUEUE_TIMEOUT on timeout,
+    otherwise a grpc_event describing the event that occurred.
+
+    Callers must not call grpc_completion_queue_next and
+    grpc_completion_queue_pluck simultaneously on the same completion queue. */
+GRPCAPI grpc_event grpc_completion_queue_next(grpc_completion_queue* cq,
+                                              gpr_timespec deadline,
+                                              void* reserved);
+
+/** Blocks until an event with tag 'tag' is available, the completion queue is
+    being shutdown or deadline is reached.
+
+    Returns a grpc_event with type GRPC_QUEUE_TIMEOUT on timeout,
+    otherwise a grpc_event describing the event that occurred.
+
+    Callers must not call grpc_completion_queue_next and
+    grpc_completion_queue_pluck simultaneously on the same completion queue.
+
+    Completion queues support a maximum of GRPC_MAX_COMPLETION_QUEUE_PLUCKERS
+    concurrently executing plucks at any time. */
+GRPCAPI grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq,
+                                               void* tag, gpr_timespec deadline,
+                                               void* reserved);
+
+/** Maximum number of outstanding grpc_completion_queue_pluck executions per
+    completion queue */
+#define GRPC_MAX_COMPLETION_QUEUE_PLUCKERS 6
+
+/** Begin destruction of a completion queue. Once all possible events are
+    drained then grpc_completion_queue_next will start to produce
+    GRPC_QUEUE_SHUTDOWN events only. At that point it's safe to call
+    grpc_completion_queue_destroy.
+
+    After calling this function applications should ensure that no
+    NEW work is added to be published on this completion queue. */
+GRPCAPI void grpc_completion_queue_shutdown(grpc_completion_queue* cq);
+
+/** Destroy a completion queue. The caller must ensure that the queue is
+    drained and no threads are executing grpc_completion_queue_next */
+GRPCAPI void grpc_completion_queue_destroy(grpc_completion_queue* cq);
+
+/*********** EXPERIMENTAL API ************/
+/** Initializes a thread local cache for \a cq.
+ * grpc_flush_cq_tls_cache() MUST be called on the same thread,
+ * with the same cq.
+ */
+GRPCAPI void grpc_completion_queue_thread_local_cache_init(
+    grpc_completion_queue* cq);
+
+/*********** EXPERIMENTAL API ************/
+/** Flushes the thread local cache for \a cq.
+ * Returns 1 if there was contents in the cache.  If there was an event
+ * in \a cq tls cache, its tag is placed in tag, and ok is set to the
+ * event success.
+ */
+GRPCAPI int grpc_completion_queue_thread_local_cache_flush(
+    grpc_completion_queue* cq, void** tag, int* ok);
+
+/** Check the connectivity state of a channel. */
+GRPCAPI grpc_connectivity_state grpc_channel_check_connectivity_state(
+    grpc_channel* channel, int try_to_connect);
+
+/** Number of active "external connectivity state watchers" attached to a
+ * channel.
+ * Useful for testing. **/
+GRPCAPI int grpc_channel_num_external_connectivity_watchers(
+    grpc_channel* channel);
+
+/** Watch for a change in connectivity state.
+    Once the channel connectivity state is different from last_observed_state,
+    tag will be enqueued on cq with success=1.
+    If deadline expires BEFORE the state is changed, tag will be enqueued on cq
+    with success=0. */
+GRPCAPI void grpc_channel_watch_connectivity_state(
+    grpc_channel* channel, grpc_connectivity_state last_observed_state,
+    gpr_timespec deadline, grpc_completion_queue* cq, void* tag);
+
+/** Check whether a grpc channel supports connectivity watcher */
+GRPCAPI int grpc_channel_support_connectivity_watcher(grpc_channel* channel);
+
+/** Create a call given a grpc_channel, in order to call 'method'. All
+    completions are sent to 'completion_queue'. 'method' and 'host' need only
+    live through the invocation of this function.
+    If parent_call is non-NULL, it must be a server-side call. It will be used
+    to propagate properties from the server call to this new client call,
+    depending on the value of \a propagation_mask (see propagation_bits.h for
+    possible values). */
+GRPCAPI grpc_call* grpc_channel_create_call(
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* completion_queue, grpc_slice method,
+    const grpc_slice* host, gpr_timespec deadline, void* reserved);
+
+/** Pre-register a method/host pair on a channel.
+    method and host are not owned and must remain alive while the channel is
+    alive. */
+GRPCAPI void* grpc_channel_register_call(grpc_channel* channel,
+                                         const char* method, const char* host,
+                                         void* reserved);
+
+/** Create a call given a handle returned from grpc_channel_register_call.
+    \sa grpc_channel_create_call. */
+GRPCAPI grpc_call* grpc_channel_create_registered_call(
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* completion_queue, void* registered_call_handle,
+    gpr_timespec deadline, void* reserved);
+
+/** Allocate memory in the grpc_call arena: this memory is automatically
+    discarded at call completion */
+GRPCAPI void* grpc_call_arena_alloc(grpc_call* call, size_t size);
+
+/** Start a batch of operations defined in the array ops; when complete, post a
+    completion of type 'tag' to the completion queue bound to the call.
+    The order of ops specified in the batch has no significance.
+    Only one operation of each type can be active at once in any given
+    batch.
+    If a call to grpc_call_start_batch returns GRPC_CALL_OK you must call
+    grpc_completion_queue_next or grpc_completion_queue_pluck on the completion
+    queue associated with 'call' for work to be performed. If a call to
+    grpc_call_start_batch returns any value other than GRPC_CALL_OK it is
+    guaranteed that no state associated with 'call' is changed and it is not
+    appropriate to call grpc_completion_queue_next or
+    grpc_completion_queue_pluck consequent to the failed grpc_call_start_batch
+    call.
+    If a call to grpc_call_start_batch with an empty batch returns
+    GRPC_CALL_OK, the tag is put in the completion queue immediately.
+    THREAD SAFETY: access to grpc_call_start_batch in multi-threaded environment
+    needs to be synchronized. As an optimization, you may synchronize batches
+    containing just send operations independently from batches containing just
+    receive operations. Access to grpc_call_start_batch with an empty batch is
+    thread-compatible. */
+GRPCAPI grpc_call_error grpc_call_start_batch(grpc_call* call,
+                                              const grpc_op* ops, size_t nops,
+                                              void* tag, void* reserved);
+
+/** Returns a newly allocated string representing the endpoint to which this
+    call is communicating with. The string is in the uri format accepted by
+    grpc_channel_create.
+    The returned string should be disposed of with gpr_free().
+
+    WARNING: this value is never authenticated or subject to any security
+    related code. It must not be used for any authentication related
+    functionality. Instead, use grpc_auth_context. */
+GRPCAPI char* grpc_call_get_peer(grpc_call* call);
+
+struct census_context;
+
+/** Set census context for a call; Must be called before first call to
+   grpc_call_start_batch(). */
+GRPCAPI void grpc_census_call_set_context(grpc_call* call,
+                                          struct census_context* context);
+
+/** Retrieve the calls current census context. */
+GRPCAPI struct census_context* grpc_census_call_get_context(grpc_call* call);
+
+/** Return a newly allocated string representing the target a channel was
+    created for. */
+GRPCAPI char* grpc_channel_get_target(grpc_channel* channel);
+
+/** Request info about the channel.
+    \a channel_info indicates what information is being requested and
+    how that information will be returned.
+    \a channel_info is owned by the caller. */
+GRPCAPI void grpc_channel_get_info(grpc_channel* channel,
+                                   const grpc_channel_info* channel_info);
+
+/** EXPERIMENTAL.  Resets the channel's connect backoff.
+    TODO(roth): When we see whether this proves useful, either promote
+    to non-experimental or remove it. */
+GRPCAPI void grpc_channel_reset_connect_backoff(grpc_channel* channel);
+
+/** --- grpc_channel_credentials object. ---
+
+   A channel credentials object represents a way to authenticate a client on a
+   channel. Different types of channel credentials are declared in
+   grpc_security.h. */
+
+typedef struct grpc_channel_credentials grpc_channel_credentials;
+
+/** Releases a channel credentials object.
+   The creator of the credentials object is responsible for its release. */
+
+GRPCAPI void grpc_channel_credentials_release(grpc_channel_credentials* creds);
+
+/** --- grpc_server_credentials object. ---
+
+   A server credentials object represents a way to authenticate a server.
+   Different types of server credentials are declared in grpc_security.h. */
+
+typedef struct grpc_server_credentials grpc_server_credentials;
+
+/** Releases a server_credentials object.
+   The creator of the server_credentials object is responsible for its release.
+   */
+GRPCAPI void grpc_server_credentials_release(grpc_server_credentials* creds);
+
+/** Creates a secure channel using the passed-in credentials. Additional
+    channel level configuration MAY be provided by grpc_channel_args, though
+    the expectation is that most clients will want to simply pass NULL. The
+    user data in 'args' need only live through the invocation of this function.
+    However, if any args of the 'pointer' type are passed, then the referenced
+    vtable must be maintained by the caller until grpc_channel_destroy
+    terminates. See grpc_channel_args definition for more on this. */
+GRPCAPI grpc_channel* grpc_channel_create(const char* target,
+                                          grpc_channel_credentials* creds,
+                                          const grpc_channel_args* args);
+
+/** Create a lame client: this client fails every operation attempted on it. */
+GRPCAPI grpc_channel* grpc_lame_client_channel_create(
+    const char* target, grpc_status_code error_code, const char* error_message);
+
+/** Close and destroy a grpc channel */
+GRPCAPI void grpc_channel_destroy(grpc_channel* channel);
+
+/** Error handling for grpc_call
+   Most grpc_call functions return a grpc_error. If the error is not GRPC_OK
+   then the operation failed due to some unsatisfied precondition.
+   If a grpc_call fails, it's guaranteed that no change to the call state
+   has been made. */
+
+/** Cancel an RPC.
+    Can be called multiple times, from any thread.
+    THREAD-SAFETY grpc_call_cancel and grpc_call_cancel_with_status
+    are thread-safe, and can be called at any point before grpc_call_unref
+    is called.*/
+GRPCAPI grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved);
+
+/** Cancel an RPC.
+    Can be called multiple times, from any thread.
+    If a status has not been received for the call, set it to the status code
+    and description passed in.
+    Importantly, this function does not send status nor description to the
+    remote endpoint.
+    Note that \a description doesn't need be a static string.
+    It doesn't need to be alive after the call to
+    grpc_call_cancel_with_status completes.
+    */
+GRPCAPI grpc_call_error grpc_call_cancel_with_status(grpc_call* call,
+                                                     grpc_status_code status,
+                                                     const char* description,
+                                                     void* reserved);
+
+/* Returns whether or not the call's receive message operation failed because of
+ * an error (as opposed to a graceful end-of-stream) */
+GRPCAPI int grpc_call_failed_before_recv_message(const grpc_call* c);
+
+/** Ref a call.
+    THREAD SAFETY: grpc_call_ref is thread-compatible */
+GRPCAPI void grpc_call_ref(grpc_call* call);
+
+/** Unref a call.
+    THREAD SAFETY: grpc_call_unref is thread-compatible */
+GRPCAPI void grpc_call_unref(grpc_call* call);
+
+/** Request notification of a new call.
+    Once a call is received, a notification tagged with \a tag_new is added to
+    \a cq_for_notification. \a call, \a details and \a request_metadata are
+    updated with the appropriate call information. \a cq_bound_to_call is bound
+    to \a call, and batch operation notifications for that call will be posted
+    to \a cq_bound_to_call.
+    Note that \a cq_for_notification must have been registered to the server via
+    \a grpc_server_register_completion_queue. */
+GRPCAPI grpc_call_error grpc_server_request_call(
+    grpc_server* server, grpc_call** call, grpc_call_details* details,
+    grpc_metadata_array* request_metadata,
+    grpc_completion_queue* cq_bound_to_call,
+    grpc_completion_queue* cq_for_notification, void* tag_new);
+
+/** How to handle payloads for a registered method */
+typedef enum {
+  /** Don't try to read the payload */
+  GRPC_SRM_PAYLOAD_NONE,
+  /** Read the initial payload as a byte buffer */
+  GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER
+} grpc_server_register_method_payload_handling;
+
+/** Registers a method in the server.
+    Methods to this (host, method) pair will not be reported by
+    grpc_server_request_call, but instead be reported by
+    grpc_server_request_registered_call when passed the appropriate
+    registered_method (as returned by this function).
+    Must be called before grpc_server_start.
+    Returns NULL on failure. */
+GRPCAPI void* grpc_server_register_method(
+    grpc_server* server, const char* method, const char* host,
+    grpc_server_register_method_payload_handling payload_handling,
+    uint32_t flags);
+
+/** Request notification of a new pre-registered call. 'cq_for_notification'
+    must have been registered to the server via
+    grpc_server_register_completion_queue. */
+GRPCAPI grpc_call_error grpc_server_request_registered_call(
+    grpc_server* server, void* registered_method, grpc_call** call,
+    gpr_timespec* deadline, grpc_metadata_array* request_metadata,
+    grpc_byte_buffer** optional_payload,
+    grpc_completion_queue* cq_bound_to_call,
+    grpc_completion_queue* cq_for_notification, void* tag_new);
+
+/** Create a server. Additional configuration for each incoming channel can
+    be specified with args. If no additional configuration is needed, args can
+    be NULL. The user data in 'args' need only live through the invocation of
+    this function. However, if any args of the 'pointer' type are passed, then
+    the referenced vtable must be maintained by the caller until
+    grpc_server_destroy terminates. See grpc_channel_args definition for more
+    on this. */
+GRPCAPI grpc_server* grpc_server_create(const grpc_channel_args* args,
+                                        void* reserved);
+
+/** Register a completion queue with the server. Must be done for any
+    notification completion queue that is passed to grpc_server_request_*_call
+    and to grpc_server_shutdown_and_notify. Must be performed prior to
+    grpc_server_start. */
+GRPCAPI void grpc_server_register_completion_queue(grpc_server* server,
+                                                   grpc_completion_queue* cq,
+                                                   void* reserved);
+
+// More members might be added in later, so users should take care to memset
+// this to 0 before using it.
+typedef struct {
+  grpc_status_code code;
+  const char* error_message;
+} grpc_serving_status_update;
+
+// There might be more methods added later, so users should take care to memset
+// this to 0 before using it.
+typedef struct {
+  void (*on_serving_status_update)(void* user_data, const char* uri,
+                                   grpc_serving_status_update update);
+  void* user_data;
+} grpc_server_xds_status_notifier;
+
+typedef struct grpc_server_config_fetcher grpc_server_config_fetcher;
+
+/** EXPERIMENTAL.  Creates an xDS config fetcher. */
+GRPCAPI grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
+    grpc_server_xds_status_notifier notifier, const grpc_channel_args* args);
+
+/** EXPERIMENTAL.  Destroys a config fetcher. */
+GRPCAPI void grpc_server_config_fetcher_destroy(
+    grpc_server_config_fetcher* config_fetcher);
+
+/** EXPERIMENTAL.  Sets the server's config fetcher.  Takes ownership.
+    Must be called before adding ports */
+GRPCAPI void grpc_server_set_config_fetcher(
+    grpc_server* server, grpc_server_config_fetcher* config_fetcher);
+
+/** Add a HTTP2 over an encrypted link over tcp listener.
+   Returns bound port number on success, 0 on failure.
+   REQUIRES: server not started */
+GRPCAPI int grpc_server_add_http2_port(grpc_server* server, const char* addr,
+                                       grpc_server_credentials* creds);
+
+/** Start a server - tells all listeners to start listening */
+GRPCAPI void grpc_server_start(grpc_server* server);
+
+/** Begin shutting down a server.
+    After completion, no new calls or connections will be admitted.
+    Existing calls will be allowed to complete.
+    Send a GRPC_OP_COMPLETE event when there are no more calls being serviced.
+    Shutdown is idempotent, and all tags will be notified at once if multiple
+    grpc_server_shutdown_and_notify calls are made. 'cq' must have been
+    registered to this server via grpc_server_register_completion_queue. */
+GRPCAPI void grpc_server_shutdown_and_notify(grpc_server* server,
+                                             grpc_completion_queue* cq,
+                                             void* tag);
+
+/** Cancel all in-progress calls.
+    Only usable after shutdown. */
+GRPCAPI void grpc_server_cancel_all_calls(grpc_server* server);
+
+/** Destroy a server.
+    Shutdown must have completed beforehand (i.e. all tags generated by
+    grpc_server_shutdown_and_notify must have been received, and at least
+    one call to grpc_server_shutdown_and_notify must have been made). */
+GRPCAPI void grpc_server_destroy(grpc_server* server);
+
+/** Enable or disable a tracer.
+
+    Tracers (usually controlled by the environment variable GRPC_TRACE)
+    allow printf-style debugging on GRPC internals, and are useful for
+    tracking down problems in the field.
+
+    Use of this function is not strictly thread-safe, but the
+    thread-safety issues raised by it should not be of concern. */
+GRPCAPI int grpc_tracer_set_enabled(const char* name, int enabled);
+
+/** Check whether a metadata key is legal (will be accepted by core) */
+GRPCAPI int grpc_header_key_is_legal(grpc_slice slice);
+
+/** Check whether a non-binary metadata value is legal (will be accepted by
+    core) */
+GRPCAPI int grpc_header_nonbin_value_is_legal(grpc_slice slice);
+
+/** Check whether a metadata key corresponds to a binary value */
+GRPCAPI int grpc_is_binary_header(grpc_slice slice);
+
+/** Convert grpc_call_error values to a string */
+GRPCAPI const char* grpc_call_error_to_string(grpc_call_error error);
+
+/** Create a buffer pool */
+GRPCAPI grpc_resource_quota* grpc_resource_quota_create(const char* trace_name);
+
+/** Add a reference to a buffer pool */
+GRPCAPI void grpc_resource_quota_ref(grpc_resource_quota* resource_quota);
+
+/** Drop a reference to a buffer pool */
+GRPCAPI void grpc_resource_quota_unref(grpc_resource_quota* resource_quota);
+
+/** Update the size of a buffer pool */
+GRPCAPI void grpc_resource_quota_resize(grpc_resource_quota* resource_quota,
+                                        size_t new_size);
+
+/** Update the size of the maximum number of threads allowed */
+GRPCAPI void grpc_resource_quota_set_max_threads(
+    grpc_resource_quota* resource_quota, int new_max_threads);
+
+/** EXPERIMENTAL.  Dumps xDS configs as a serialized ClientConfig proto.
+    The full name of the proto is envoy.service.status.v3.ClientConfig. */
+GRPCAPI grpc_slice grpc_dump_xds_configs(void);
+
+/** Fetch a vtable for a grpc_channel_arg that points to a grpc_resource_quota
+ */
+GRPCAPI const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void);
+
+/************* CHANNELZ API *************/
+/** Channelz is under active development. The following APIs will see some
+    churn as the feature is implemented. This comment will be removed once
+    channelz is officially supported, and these APIs become stable. For now
+    you may track the progress by following this github issue:
+    https://github.com/grpc/grpc/issues/15340
+
+    the following APIs return allocated JSON strings that match the response
+    objects from the channelz proto, found here:
+    https://github.com/grpc/grpc/blob/master/src/proto/grpc/channelz/channelz.proto.
+
+    For easy conversion to protobuf, The JSON is formatted according to:
+    https://developers.google.com/protocol-buffers/docs/proto3#json. */
+
+/* Gets all root channels (i.e. channels the application has directly
+   created). This does not include subchannels nor non-top level channels.
+   The returned string is allocated and must be freed by the application. */
+GRPCAPI char* grpc_channelz_get_top_channels(intptr_t start_channel_id);
+
+/* Gets all servers that exist in the process. */
+GRPCAPI char* grpc_channelz_get_servers(intptr_t start_server_id);
+
+/* Returns a single Server, or else a NOT_FOUND code. */
+GRPCAPI char* grpc_channelz_get_server(intptr_t server_id);
+
+/* Gets all server sockets that exist in the server. */
+GRPCAPI char* grpc_channelz_get_server_sockets(intptr_t server_id,
+                                               intptr_t start_socket_id,
+                                               intptr_t max_results);
+
+/* Returns a single Channel, or else a NOT_FOUND code. The returned string
+   is allocated and must be freed by the application. */
+GRPCAPI char* grpc_channelz_get_channel(intptr_t channel_id);
+
+/* Returns a single Subchannel, or else a NOT_FOUND code. The returned string
+   is allocated and must be freed by the application. */
+GRPCAPI char* grpc_channelz_get_subchannel(intptr_t subchannel_id);
+
+/* Returns a single Socket, or else a NOT_FOUND code. The returned string
+   is allocated and must be freed by the application. */
+GRPCAPI char* grpc_channelz_get_socket(intptr_t socket_id);
+
+/**
+ * EXPERIMENTAL - Subject to change.
+ * Fetch a vtable for grpc_channel_arg that points to
+ * grpc_authorization_policy_provider.
+ */
+GRPCAPI const grpc_arg_pointer_vtable*
+grpc_authorization_policy_provider_arg_vtable(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_GRPC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/grpc_posix.h b/CAPI/cpp/grpc/include/grpc/grpc_posix.h
new file mode 100644
index 0000000..797e3c5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/grpc_posix.h
@@ -0,0 +1,63 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_GRPC_POSIX_H
+#define GRPC_GRPC_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*! \mainpage GRPC Core POSIX
+ *
+ * The GRPC Core POSIX library provides some POSIX-specific low-level
+ * functionality on top of GRPC Core.
+ */
+
+/** Create a secure channel to 'target' using file descriptor 'fd' and passed-in
+    credentials. The 'target' argument will be used to indicate the name for
+    this channel. Note that this API currently only supports insecure channel
+    credentials. Using other types of credentials will result in a failure. */
+GRPCAPI grpc_channel* grpc_channel_create_from_fd(
+    const char* target, int fd, grpc_channel_credentials* creds,
+    const grpc_channel_args* args);
+
+/** Add the connected secure communication channel based on file descriptor 'fd'
+   to the 'server' and server credentials 'creds'. The 'fd' must be an open file
+   descriptor corresponding to a connected socket. Events from the file
+   descriptor may come on any of the server completion queues (i.e completion
+   queues registered via the grpc_server_register_completion_queue API).
+   Note that this API currently only supports inseure server credentials
+   Using other types of credentials will result in a failure.
+   TODO(hork): add channel_args to this API to allow endpoints and transports
+   created in this function to participate in the resource quota feature. */
+GRPCAPI void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
+                                             grpc_server_credentials* creds);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_GRPC_POSIX_H */
diff --git a/CAPI/cpp/grpc/include/grpc/grpc_security.h b/CAPI/cpp/grpc/include/grpc/grpc_security.h
new file mode 100644
index 0000000..63810f6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/grpc_security.h
@@ -0,0 +1,1270 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_GRPC_SECURITY_H
+#define GRPC_GRPC_SECURITY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security_constants.h>
+#include <grpc/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** --- Authentication Context. --- */
+
+typedef struct grpc_auth_context grpc_auth_context;
+
+typedef struct grpc_auth_property_iterator {
+  const grpc_auth_context* ctx;
+  size_t index;
+  const char* name;
+} grpc_auth_property_iterator;
+
+/** value, if not NULL, is guaranteed to be NULL terminated. */
+typedef struct grpc_auth_property {
+  char* name;
+  char* value;
+  size_t value_length;
+} grpc_auth_property;
+
+/** Returns NULL when the iterator is at the end. */
+GRPCAPI const grpc_auth_property* grpc_auth_property_iterator_next(
+    grpc_auth_property_iterator* it);
+
+/** Iterates over the auth context. */
+GRPCAPI grpc_auth_property_iterator
+grpc_auth_context_property_iterator(const grpc_auth_context* ctx);
+
+/** Gets the peer identity. Returns an empty iterator (first _next will return
+   NULL) if the peer is not authenticated. */
+GRPCAPI grpc_auth_property_iterator
+grpc_auth_context_peer_identity(const grpc_auth_context* ctx);
+
+/** Finds a property in the context. May return an empty iterator (first _next
+   will return NULL) if no property with this name was found in the context. */
+GRPCAPI grpc_auth_property_iterator grpc_auth_context_find_properties_by_name(
+    const grpc_auth_context* ctx, const char* name);
+
+/** Gets the name of the property that indicates the peer identity. Will return
+   NULL if the peer is not authenticated. */
+GRPCAPI const char* grpc_auth_context_peer_identity_property_name(
+    const grpc_auth_context* ctx);
+
+/** Returns 1 if the peer is authenticated, 0 otherwise. */
+GRPCAPI int grpc_auth_context_peer_is_authenticated(
+    const grpc_auth_context* ctx);
+
+/** Gets the auth context from the call. Caller needs to call
+   grpc_auth_context_release on the returned context. */
+GRPCAPI grpc_auth_context* grpc_call_auth_context(grpc_call* call);
+
+/** Releases the auth context returned from grpc_call_auth_context. */
+GRPCAPI void grpc_auth_context_release(grpc_auth_context* context);
+
+/** --
+   The following auth context methods should only be called by a server metadata
+   processor to set properties extracted from auth metadata.
+   -- */
+
+/** Add a property. */
+GRPCAPI void grpc_auth_context_add_property(grpc_auth_context* ctx,
+                                            const char* name, const char* value,
+                                            size_t value_length);
+
+/** Add a C string property. */
+GRPCAPI void grpc_auth_context_add_cstring_property(grpc_auth_context* ctx,
+                                                    const char* name,
+                                                    const char* value);
+
+/** Sets the property name. Returns 1 if successful or 0 in case of failure
+   (which means that no property with this name exists). */
+GRPCAPI int grpc_auth_context_set_peer_identity_property_name(
+    grpc_auth_context* ctx, const char* name);
+
+/** --- SSL Session Cache. ---
+
+    A SSL session cache object represents a way to cache client sessions
+    between connections. Only ticket-based resumption is supported. */
+
+typedef struct grpc_ssl_session_cache grpc_ssl_session_cache;
+
+/** Create LRU cache for client-side SSL sessions with the given capacity.
+    If capacity is < 1, a default capacity is used instead. */
+GRPCAPI grpc_ssl_session_cache* grpc_ssl_session_cache_create_lru(
+    size_t capacity);
+
+/** Destroy SSL session cache. */
+GRPCAPI void grpc_ssl_session_cache_destroy(grpc_ssl_session_cache* cache);
+
+/** Create a channel arg with the given cache object. */
+GRPCAPI grpc_arg
+grpc_ssl_session_cache_create_channel_arg(grpc_ssl_session_cache* cache);
+
+/** --- grpc_call_credentials object.
+
+   A call credentials object represents a way to authenticate on a particular
+   call. These credentials can be composed with a channel credentials object
+   so that they are sent with every call on this channel.  */
+
+typedef struct grpc_call_credentials grpc_call_credentials;
+
+/** Releases a call credentials object.
+   The creator of the credentials object is responsible for its release. */
+GRPCAPI void grpc_call_credentials_release(grpc_call_credentials* creds);
+
+/** Creates default credentials to connect to a google gRPC service.
+   WARNING: Do NOT use this credentials to connect to a non-google service as
+   this could result in an oauth2 token leak. The security level of the
+   resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+
+   If specified, the supplied call credentials object will be attached to the
+   returned channel credentials object. The call_credentials object must remain
+   valid throughout the lifetime of the returned grpc_channel_credentials
+   object. It is expected that the call credentials object was generated
+   according to the Application Default Credentials mechanism and asserts the
+   identity of the default service account of the machine. Supplying any other
+   sort of call credential will result in undefined behavior, up to and
+   including the sudden and unexpected failure of RPCs.
+
+   If nullptr is supplied, the returned channel credentials object will use a
+   call credentials object based on the Application Default Credentials
+   mechanism.
+*/
+GRPCAPI grpc_channel_credentials* grpc_google_default_credentials_create(
+    grpc_call_credentials* call_credentials);
+
+/** Callback for getting the SSL roots override from the application.
+   In case of success, *pem_roots_certs must be set to a NULL terminated string
+   containing the list of PEM encoded root certificates. The ownership is passed
+   to the core and freed (laster by the core) with gpr_free.
+   If this function fails and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is
+   set to a valid path, it will override the roots specified this func */
+typedef grpc_ssl_roots_override_result (*grpc_ssl_roots_override_callback)(
+    char** pem_root_certs);
+
+/** Setup a callback to override the default TLS/SSL roots.
+   This function is not thread-safe and must be called at initialization time
+   before any ssl credentials are created to have the desired side effect.
+   If GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is set to a valid path, the
+   callback will not be called. */
+GRPCAPI void grpc_set_ssl_roots_override_callback(
+    grpc_ssl_roots_override_callback cb);
+
+/** Object that holds a private key / certificate chain pair in PEM format. */
+typedef struct {
+  /** private_key is the NULL-terminated string containing the PEM encoding of
+     the client's private key. */
+  const char* private_key;
+
+  /** cert_chain is the NULL-terminated string containing the PEM encoding of
+     the client's certificate chain. */
+  const char* cert_chain;
+} grpc_ssl_pem_key_cert_pair;
+
+/** Deprecated in favor of grpc_ssl_verify_peer_options. It will be removed
+  after all of its call sites are migrated to grpc_ssl_verify_peer_options.
+  Object that holds additional peer-verification options on a secure
+  channel. */
+typedef struct {
+  /** If non-NULL this callback will be invoked with the expected
+     target_name, the peer's certificate (in PEM format), and whatever
+     userdata pointer is set below. If a non-zero value is returned by this
+     callback then it is treated as a verification failure. Invocation of
+     the callback is blocking, so any implementation should be light-weight.
+     */
+  int (*verify_peer_callback)(const char* target_name, const char* peer_pem,
+                              void* userdata);
+  /** Arbitrary userdata that will be passed as the last argument to
+     verify_peer_callback. */
+  void* verify_peer_callback_userdata;
+  /** A destruct callback that will be invoked when the channel is being
+     cleaned up. The userdata argument will be passed to it. The intent is
+     to perform any cleanup associated with that userdata. */
+  void (*verify_peer_destruct)(void* userdata);
+} verify_peer_options;
+
+/** Object that holds additional peer-verification options on a secure
+   channel. */
+typedef struct {
+  /** If non-NULL this callback will be invoked with the expected
+     target_name, the peer's certificate (in PEM format), and whatever
+     userdata pointer is set below. If a non-zero value is returned by this
+     callback then it is treated as a verification failure. Invocation of
+     the callback is blocking, so any implementation should be light-weight.
+     */
+  int (*verify_peer_callback)(const char* target_name, const char* peer_pem,
+                              void* userdata);
+  /** Arbitrary userdata that will be passed as the last argument to
+     verify_peer_callback. */
+  void* verify_peer_callback_userdata;
+  /** A destruct callback that will be invoked when the channel is being
+     cleaned up. The userdata argument will be passed to it. The intent is
+     to perform any cleanup associated with that userdata. */
+  void (*verify_peer_destruct)(void* userdata);
+} grpc_ssl_verify_peer_options;
+
+/** Deprecated in favor of grpc_ssl_server_credentials_create_ex. It will be
+   removed after all of its call sites are migrated to
+   grpc_ssl_server_credentials_create_ex. Creates an SSL credentials object.
+   The security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+   - pem_root_certs is the NULL-terminated string containing the PEM encoding
+     of the server root certificates. If this parameter is NULL, the
+     implementation will first try to dereference the file pointed by the
+     GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment variable, and if that fails,
+     try to get the roots set by grpc_override_ssl_default_roots. Eventually,
+     if all these fail, it will try to get the roots from a well-known place on
+     disk (in the grpc install directory).
+
+     gRPC has implemented root cache if the underlying OpenSSL library supports
+     it. The gRPC root certificates cache is only applicable on the default
+     root certificates, which is used when this parameter is nullptr. If user
+     provides their own pem_root_certs, when creating an SSL credential object,
+     gRPC would not be able to cache it, and each subchannel will generate a
+     copy of the root store. So it is recommended to avoid providing large room
+     pem with pem_root_certs parameter to avoid excessive memory consumption,
+     particularly on mobile platforms such as iOS.
+   - pem_key_cert_pair is a pointer on the object containing client's private
+     key and certificate chain. This parameter can be NULL if the client does
+     not have such a key/cert pair.
+   - verify_options is an optional verify_peer_options object which holds
+     additional options controlling how peer certificates are verified. For
+     example, you can supply a callback which receives the peer's certificate
+     with which you can do additional verification. Can be NULL, in which
+     case verification will retain default behavior. Any settings in
+     verify_options are copied during this call, so the verify_options
+     object can be released afterwards. */
+GRPCAPI grpc_channel_credentials* grpc_ssl_credentials_create(
+    const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair,
+    const verify_peer_options* verify_options, void* reserved);
+
+/* Creates an SSL credentials object.
+   The security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+   - pem_root_certs is the NULL-terminated string containing the PEM encoding
+     of the server root certificates. If this parameter is NULL, the
+     implementation will first try to dereference the file pointed by the
+     GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment variable, and if that fails,
+     try to get the roots set by grpc_override_ssl_default_roots. Eventually,
+     if all these fail, it will try to get the roots from a well-known place on
+     disk (in the grpc install directory).
+
+     gRPC has implemented root cache if the underlying OpenSSL library supports
+     it. The gRPC root certificates cache is only applicable on the default
+     root certificates, which is used when this parameter is nullptr. If user
+     provides their own pem_root_certs, when creating an SSL credential object,
+     gRPC would not be able to cache it, and each subchannel will generate a
+     copy of the root store. So it is recommended to avoid providing large room
+     pem with pem_root_certs parameter to avoid excessive memory consumption,
+     particularly on mobile platforms such as iOS.
+   - pem_key_cert_pair is a pointer on the object containing client's private
+     key and certificate chain. This parameter can be NULL if the client does
+     not have such a key/cert pair.
+   - verify_options is an optional verify_peer_options object which holds
+     additional options controlling how peer certificates are verified. For
+     example, you can supply a callback which receives the peer's certificate
+     with which you can do additional verification. Can be NULL, in which
+     case verification will retain default behavior. Any settings in
+     verify_options are copied during this call, so the verify_options
+     object can be released afterwards. */
+GRPCAPI grpc_channel_credentials* grpc_ssl_credentials_create_ex(
+    const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair,
+    const grpc_ssl_verify_peer_options* verify_options, void* reserved);
+
+/** Creates a composite channel credentials object. The security level of
+ * resulting connection is determined by channel_creds. */
+GRPCAPI grpc_channel_credentials* grpc_composite_channel_credentials_create(
+    grpc_channel_credentials* channel_creds, grpc_call_credentials* call_creds,
+    void* reserved);
+
+/** --- composite credentials. */
+
+/** Creates a composite call credentials object. */
+GRPCAPI grpc_call_credentials* grpc_composite_call_credentials_create(
+    grpc_call_credentials* creds1, grpc_call_credentials* creds2,
+    void* reserved);
+
+/** Creates a compute engine credentials object for connecting to Google.
+   WARNING: Do NOT use this credentials to connect to a non-google service as
+   this could result in an oauth2 token leak. */
+GRPCAPI grpc_call_credentials* grpc_google_compute_engine_credentials_create(
+    void* reserved);
+
+GRPCAPI gpr_timespec grpc_max_auth_token_lifetime(void);
+
+/** Creates a JWT credentials object. May return NULL if the input is invalid.
+   - json_key is the JSON key string containing the client's private key.
+   - token_lifetime is the lifetime of each Json Web Token (JWT) created with
+     this credentials.  It should not exceed grpc_max_auth_token_lifetime or
+     will be cropped to this value.  */
+GRPCAPI grpc_call_credentials*
+grpc_service_account_jwt_access_credentials_create(const char* json_key,
+                                                   gpr_timespec token_lifetime,
+                                                   void* reserved);
+
+/** Builds External Account credentials.
+ - json_string is the JSON string containing the credentials options.
+ - scopes_string contains the scopes to be binded with the credentials.
+   This API is used for experimental purposes for now and may change in the
+ future. */
+GRPCAPI grpc_call_credentials* grpc_external_account_credentials_create(
+    const char* json_string, const char* scopes_string);
+
+/** Creates an Oauth2 Refresh Token credentials object for connecting to Google.
+   May return NULL if the input is invalid.
+   WARNING: Do NOT use this credentials to connect to a non-google service as
+   this could result in an oauth2 token leak.
+   - json_refresh_token is the JSON string containing the refresh token itself
+     along with a client_id and client_secret. */
+GRPCAPI grpc_call_credentials* grpc_google_refresh_token_credentials_create(
+    const char* json_refresh_token, void* reserved);
+
+/** Creates an Oauth2 Access Token credentials with an access token that was
+   acquired by an out of band mechanism. */
+GRPCAPI grpc_call_credentials* grpc_access_token_credentials_create(
+    const char* access_token, void* reserved);
+
+/** Creates an IAM credentials object for connecting to Google. */
+GRPCAPI grpc_call_credentials* grpc_google_iam_credentials_create(
+    const char* authorization_token, const char* authority_selector,
+    void* reserved);
+
+/** Options for creating STS Oauth Token Exchange credentials following the IETF
+   draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
+   Optional fields may be set to NULL or empty string. It is the responsibility
+   of the caller to ensure that the subject and actor tokens are refreshed on
+   disk at the specified paths. This API is used for experimental purposes for
+   now and may change in the future. */
+typedef struct {
+  const char* token_exchange_service_uri; /* Required. */
+  const char* resource;                   /* Optional. */
+  const char* audience;                   /* Optional. */
+  const char* scope;                      /* Optional. */
+  const char* requested_token_type;       /* Optional. */
+  const char* subject_token_path;         /* Required. */
+  const char* subject_token_type;         /* Required. */
+  const char* actor_token_path;           /* Optional. */
+  const char* actor_token_type;           /* Optional. */
+} grpc_sts_credentials_options;
+
+/** Creates an STS credentials following the STS Token Exchanged specifed in the
+   IETF draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
+   This API is used for experimental purposes for now and may change in the
+   future. */
+GRPCAPI grpc_call_credentials* grpc_sts_credentials_create(
+    const grpc_sts_credentials_options* options, void* reserved);
+
+/** Callback function to be called by the metadata credentials plugin
+   implementation when the metadata is ready.
+   - user_data is the opaque pointer that was passed in the get_metadata method
+     of the grpc_metadata_credentials_plugin (see below).
+   - creds_md is an array of credentials metadata produced by the plugin. It
+     may be set to NULL in case of an error.
+   - num_creds_md is the number of items in the creds_md array.
+   - status must be GRPC_STATUS_OK in case of success or another specific error
+     code otherwise.
+   - error_details contains details about the error if any. In case of success
+     it should be NULL and will be otherwise ignored. */
+typedef void (*grpc_credentials_plugin_metadata_cb)(
+    void* user_data, const grpc_metadata* creds_md, size_t num_creds_md,
+    grpc_status_code status, const char* error_details);
+
+/** Context that can be used by metadata credentials plugin in order to create
+   auth related metadata. */
+typedef struct {
+  /** The fully qualifed service url. */
+  const char* service_url;
+
+  /** The method name of the RPC being called (not fully qualified).
+     The fully qualified method name can be built from the service_url:
+     full_qualified_method_name = ctx->service_url + '/' + ctx->method_name. */
+  const char* method_name;
+
+  /** The auth_context of the channel which gives the server's identity. */
+  const grpc_auth_context* channel_auth_context;
+
+  /** Reserved for future use. */
+  void* reserved;
+} grpc_auth_metadata_context;
+
+/** Performs a deep copy from \a from to \a to. **/
+GRPCAPI void grpc_auth_metadata_context_copy(grpc_auth_metadata_context* from,
+                                             grpc_auth_metadata_context* to);
+
+/** Releases internal resources held by \a context. **/
+GRPCAPI void grpc_auth_metadata_context_reset(
+    grpc_auth_metadata_context* context);
+
+/** Maximum number of metadata entries returnable by a credentials plugin via
+    a synchronous return. */
+#define GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX 4
+
+/** grpc_metadata_credentials plugin is an API user provided structure used to
+   create grpc_credentials objects that can be set on a channel (composed) or
+   a call. See grpc_credentials_metadata_create_from_plugin below.
+   The grpc client stack will call the get_metadata method of the plugin for
+   every call in scope for the credentials created from it. */
+typedef struct {
+  /** The implementation of this method has to be non-blocking, but can
+     be performed synchronously or asynchronously.
+
+     If processing occurs synchronously, returns non-zero and populates
+     creds_md, num_creds_md, status, and error_details.  In this case,
+     the caller takes ownership of the entries in creds_md and of
+     error_details.  Note that if the plugin needs to return more than
+     GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX entries in creds_md, it must
+     return asynchronously.
+
+     If processing occurs asynchronously, returns zero and invokes \a cb
+     when processing is completed.  \a user_data will be passed as the
+     first parameter of the callback.  NOTE: \a cb MUST be invoked in a
+     different thread, not from the thread in which \a get_metadata() is
+     invoked.
+
+     \a context is the information that can be used by the plugin to create
+     auth metadata. */
+  int (*get_metadata)(
+      void* state, grpc_auth_metadata_context context,
+      grpc_credentials_plugin_metadata_cb cb, void* user_data,
+      grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
+      size_t* num_creds_md, grpc_status_code* status,
+      const char** error_details);
+
+  /** Implements debug string of the given plugin. This method returns an
+   * allocated string that the caller needs to free using gpr_free() */
+  char* (*debug_string)(void* state);
+
+  /** Destroys the plugin state. */
+  void (*destroy)(void* state);
+
+  /** State that will be set as the first parameter of the methods above. */
+  void* state;
+
+  /** Type of credentials that this plugin is implementing. */
+  const char* type;
+} grpc_metadata_credentials_plugin;
+
+/** Creates a credentials object from a plugin with a specified minimum security
+ * level. */
+GRPCAPI grpc_call_credentials* grpc_metadata_credentials_create_from_plugin(
+    grpc_metadata_credentials_plugin plugin,
+    grpc_security_level min_security_level, void* reserved);
+
+/** Server certificate config object holds the server's public certificates and
+   associated private keys, as well as any CA certificates needed for client
+   certificate validation (if applicable). Create using
+   grpc_ssl_server_certificate_config_create(). */
+typedef struct grpc_ssl_server_certificate_config
+    grpc_ssl_server_certificate_config;
+
+/** Creates a grpc_ssl_server_certificate_config object.
+   - pem_roots_cert is the NULL-terminated string containing the PEM encoding of
+     the client root certificates. This parameter may be NULL if the server does
+     not want the client to be authenticated with SSL.
+   - pem_key_cert_pairs is an array private key / certificate chains of the
+     server. This parameter cannot be NULL.
+   - num_key_cert_pairs indicates the number of items in the private_key_files
+     and cert_chain_files parameters. It must be at least 1.
+   - It is the caller's responsibility to free this object via
+     grpc_ssl_server_certificate_config_destroy(). */
+GRPCAPI grpc_ssl_server_certificate_config*
+grpc_ssl_server_certificate_config_create(
+    const char* pem_root_certs,
+    const grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs,
+    size_t num_key_cert_pairs);
+
+/** Destroys a grpc_ssl_server_certificate_config object. */
+GRPCAPI void grpc_ssl_server_certificate_config_destroy(
+    grpc_ssl_server_certificate_config* config);
+
+/** Callback to retrieve updated SSL server certificates, private keys, and
+   trusted CAs (for client authentication).
+    - user_data parameter, if not NULL, contains opaque data to be used by the
+      callback.
+    - Use grpc_ssl_server_certificate_config_create to create the config.
+    - The caller assumes ownership of the config. */
+typedef grpc_ssl_certificate_config_reload_status (
+    *grpc_ssl_server_certificate_config_callback)(
+    void* user_data, grpc_ssl_server_certificate_config** config);
+
+/** Deprecated in favor of grpc_ssl_server_credentials_create_ex.
+   Creates an SSL server_credentials object.
+   - pem_roots_cert is the NULL-terminated string containing the PEM encoding of
+     the client root certificates. This parameter may be NULL if the server does
+     not want the client to be authenticated with SSL.
+   - pem_key_cert_pairs is an array private key / certificate chains of the
+     server. This parameter cannot be NULL.
+   - num_key_cert_pairs indicates the number of items in the private_key_files
+     and cert_chain_files parameters. It should be at least 1.
+   - force_client_auth, if set to non-zero will force the client to authenticate
+     with an SSL cert. Note that this option is ignored if pem_root_certs is
+     NULL. */
+GRPCAPI grpc_server_credentials* grpc_ssl_server_credentials_create(
+    const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs,
+    size_t num_key_cert_pairs, int force_client_auth, void* reserved);
+
+/** Deprecated in favor of grpc_ssl_server_credentials_create_with_options.
+   Same as grpc_ssl_server_credentials_create method except uses
+   grpc_ssl_client_certificate_request_type enum to support more ways to
+   authenticate client certificates.*/
+GRPCAPI grpc_server_credentials* grpc_ssl_server_credentials_create_ex(
+    const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs,
+    size_t num_key_cert_pairs,
+    grpc_ssl_client_certificate_request_type client_certificate_request,
+    void* reserved);
+
+typedef struct grpc_ssl_server_credentials_options
+    grpc_ssl_server_credentials_options;
+
+/** Creates an options object using a certificate config. Use this method when
+   the certificates and keys of the SSL server will not change during the
+   server's lifetime.
+   - Takes ownership of the certificate_config parameter. */
+GRPCAPI grpc_ssl_server_credentials_options*
+grpc_ssl_server_credentials_create_options_using_config(
+    grpc_ssl_client_certificate_request_type client_certificate_request,
+    grpc_ssl_server_certificate_config* certificate_config);
+
+/** Creates an options object using a certificate config fetcher. Use this
+   method to reload the certificates and keys of the SSL server without
+   interrupting the operation of the server. Initial certificate config will be
+   fetched during server initialization.
+   - user_data parameter, if not NULL, contains opaque data which will be passed
+     to the fetcher (see definition of
+     grpc_ssl_server_certificate_config_callback). */
+GRPCAPI grpc_ssl_server_credentials_options*
+grpc_ssl_server_credentials_create_options_using_config_fetcher(
+    grpc_ssl_client_certificate_request_type client_certificate_request,
+    grpc_ssl_server_certificate_config_callback cb, void* user_data);
+
+/** Destroys a grpc_ssl_server_credentials_options object. */
+GRPCAPI void grpc_ssl_server_credentials_options_destroy(
+    grpc_ssl_server_credentials_options* options);
+
+/** Creates an SSL server_credentials object using the provided options struct.
+    - Takes ownership of the options parameter. */
+GRPCAPI grpc_server_credentials*
+grpc_ssl_server_credentials_create_with_options(
+    grpc_ssl_server_credentials_options* options);
+
+/** --- Call specific credentials. --- */
+
+/** Sets a credentials to a call. Can only be called on the client side before
+   grpc_call_start_batch. */
+GRPCAPI grpc_call_error grpc_call_set_credentials(grpc_call* call,
+                                                  grpc_call_credentials* creds);
+
+/** --- Auth Metadata Processing --- */
+
+/** Callback function that is called when the metadata processing is done.
+   - Consumed metadata will be removed from the set of metadata available on the
+     call. consumed_md may be NULL if no metadata has been consumed.
+   - Response metadata will be set on the response. response_md may be NULL.
+   - status is GRPC_STATUS_OK for success or a specific status for an error.
+     Common error status for auth metadata processing is either
+     GRPC_STATUS_UNAUTHENTICATED in case of an authentication failure or
+     GRPC_STATUS PERMISSION_DENIED in case of an authorization failure.
+   - error_details gives details about the error. May be NULL. */
+typedef void (*grpc_process_auth_metadata_done_cb)(
+    void* user_data, const grpc_metadata* consumed_md, size_t num_consumed_md,
+    const grpc_metadata* response_md, size_t num_response_md,
+    grpc_status_code status, const char* error_details);
+
+/** Pluggable server-side metadata processor object. */
+typedef struct {
+  /** The context object is read/write: it contains the properties of the
+     channel peer and it is the job of the process function to augment it with
+     properties derived from the passed-in metadata.
+     The lifetime of these objects is guaranteed until cb is invoked. */
+  void (*process)(void* state, grpc_auth_context* context,
+                  const grpc_metadata* md, size_t num_md,
+                  grpc_process_auth_metadata_done_cb cb, void* user_data);
+  void (*destroy)(void* state);
+  void* state;
+} grpc_auth_metadata_processor;
+
+GRPCAPI void grpc_server_credentials_set_auth_metadata_processor(
+    grpc_server_credentials* creds, grpc_auth_metadata_processor processor);
+
+/** --- ALTS channel/server credentials --- **/
+
+/**
+ * Main interface for ALTS credentials options. The options will contain
+ * information that will be passed from grpc to TSI layer such as RPC protocol
+ * versions. ALTS client (channel) and server credentials will have their own
+ * implementation of this interface. The APIs listed in this header are
+ * thread-compatible. It is used for experimental purpose for now and subject
+ * to change.
+ */
+typedef struct grpc_alts_credentials_options grpc_alts_credentials_options;
+
+/**
+ * This method creates a grpc ALTS credentials client options instance.
+ * It is used for experimental purpose for now and subject to change.
+ */
+GRPCAPI grpc_alts_credentials_options*
+grpc_alts_credentials_client_options_create(void);
+
+/**
+ * This method creates a grpc ALTS credentials server options instance.
+ * It is used for experimental purpose for now and subject to change.
+ */
+GRPCAPI grpc_alts_credentials_options*
+grpc_alts_credentials_server_options_create(void);
+
+/**
+ * This method adds a target service account to grpc client's ALTS credentials
+ * options instance. It is used for experimental purpose for now and subject
+ * to change.
+ *
+ * - options: grpc ALTS credentials options instance.
+ * - service_account: service account of target endpoint.
+ */
+GRPCAPI void grpc_alts_credentials_client_options_add_target_service_account(
+    grpc_alts_credentials_options* options, const char* service_account);
+
+/**
+ * This method destroys a grpc_alts_credentials_options instance by
+ * de-allocating all of its occupied memory. It is used for experimental purpose
+ * for now and subject to change.
+ *
+ * - options: a grpc_alts_credentials_options instance that needs to be
+ *   destroyed.
+ */
+GRPCAPI void grpc_alts_credentials_options_destroy(
+    grpc_alts_credentials_options* options);
+
+/**
+ * This method creates an ALTS channel credential object. The security
+ * level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+ * It is used for experimental purpose for now and subject to change.
+ *
+ * - options: grpc ALTS credentials options instance for client.
+ *
+ * It returns the created ALTS channel credential object.
+ */
+GRPCAPI grpc_channel_credentials* grpc_alts_credentials_create(
+    const grpc_alts_credentials_options* options);
+
+/**
+ * This method creates an ALTS server credential object. It is used for
+ * experimental purpose for now and subject to change.
+ *
+ * - options: grpc ALTS credentials options instance for server.
+ *
+ * It returns the created ALTS server credential object.
+ */
+GRPCAPI grpc_server_credentials* grpc_alts_server_credentials_create(
+    const grpc_alts_credentials_options* options);
+
+/** --- Local channel/server credentials --- **/
+
+/**
+ * This method creates a local channel credential object. The security level
+ * of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY for UDS and
+ * GRPC_SECURITY_NONE for LOCAL_TCP. It is used for experimental purpose
+ * for now and subject to change.
+ *
+ * - type: local connection type
+ *
+ * It returns the created local channel credential object.
+ */
+GRPCAPI grpc_channel_credentials* grpc_local_credentials_create(
+    grpc_local_connect_type type);
+
+/**
+ * This method creates a local server credential object. It is used for
+ * experimental purpose for now and subject to change.
+ *
+ * - type: local connection type
+ *
+ * It returns the created local server credential object.
+ */
+GRPCAPI grpc_server_credentials* grpc_local_server_credentials_create(
+    grpc_local_connect_type type);
+
+/** --- TLS channel/server credentials ---
+ * It is used for experimental purpose for now and subject to change. */
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * A struct that can be specified by callers to configure underlying TLS
+ * behaviors.
+ */
+typedef struct grpc_tls_credentials_options grpc_tls_credentials_options;
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * A struct provides ways to gain credential data that will be used in the TLS
+ * handshake.
+ */
+typedef struct grpc_tls_certificate_provider grpc_tls_certificate_provider;
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * A struct that stores the credential data presented to the peer in handshake
+ * to show local identity.
+ */
+typedef struct grpc_tls_identity_pairs grpc_tls_identity_pairs;
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Creates a grpc_tls_identity_pairs that stores a list of identity credential
+ * data, including identity private key and identity certificate chain.
+ */
+GRPCAPI grpc_tls_identity_pairs* grpc_tls_identity_pairs_create();
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Adds a identity private key and a identity certificate chain to
+ * grpc_tls_identity_pairs. This function will make an internal copy of
+ * |private_key| and |cert_chain|.
+ */
+GRPCAPI void grpc_tls_identity_pairs_add_pair(grpc_tls_identity_pairs* pairs,
+                                              const char* private_key,
+                                              const char* cert_chain);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Destroys a grpc_tls_identity_pairs object. If this object is passed to a
+ * provider initiation function, the ownership is transferred so this function
+ * doesn't need to be called. Otherwise the creator of the
+ * grpc_tls_identity_pairs object is responsible for its destruction.
+ */
+GRPCAPI void grpc_tls_identity_pairs_destroy(grpc_tls_identity_pairs* pairs);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Creates a grpc_tls_certificate_provider that will load credential data from
+ * static string during initialization. This provider will always return the
+ * same cert data for all cert names.
+ * root_certificate and pem_key_cert_pairs can be nullptr, indicating the
+ * corresponding credential data is not needed.
+ * This function will make a copy of |root_certificate|.
+ * The ownership of |pem_key_cert_pairs| is transferred.
+ */
+GRPCAPI grpc_tls_certificate_provider*
+grpc_tls_certificate_provider_static_data_create(
+    const char* root_certificate, grpc_tls_identity_pairs* pem_key_cert_pairs);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Creates a grpc_tls_certificate_provider that will watch the credential
+ * changes on the file system. This provider will always return the up-to-date
+ * cert data for all the cert names callers set through
+ * |grpc_tls_credentials_options|. Note that this API only supports one key-cert
+ * file and hence one set of identity key-cert pair, so SNI(Server Name
+ * Indication) is not supported.
+ * - private_key_path is the file path of the private key. This must be set if
+ *   |identity_certificate_path| is set. Otherwise, it could be null if no
+ *   identity credentials are needed.
+ * - identity_certificate_path is the file path of the identity certificate
+ *   chain. This must be set if |private_key_path| is set. Otherwise, it could
+ *   be null if no identity credentials are needed.
+ * - root_cert_path is the file path to the root certificate bundle. This
+ *   may be null if no root certs are needed.
+ * - refresh_interval_sec is the refreshing interval that we will check the
+ *   files for updates.
+ * It does not take ownership of parameters.
+ */
+GRPCAPI grpc_tls_certificate_provider*
+grpc_tls_certificate_provider_file_watcher_create(
+    const char* private_key_path, const char* identity_certificate_path,
+    const char* root_cert_path, unsigned int refresh_interval_sec);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Releases a grpc_tls_certificate_provider object. The creator of the
+ * grpc_tls_certificate_provider object is responsible for its release.
+ */
+GRPCAPI void grpc_tls_certificate_provider_release(
+    grpc_tls_certificate_provider* provider);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Creates an grpc_tls_credentials_options.
+ */
+GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_create(void);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the credential provider in the options.
+ * The |options| will implicitly take a new ref to the |provider|.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_certificate_provider(
+    grpc_tls_credentials_options* options,
+    grpc_tls_certificate_provider* provider);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * If set, gRPC stack will keep watching the root certificates with
+ * name |root_cert_name|.
+ * If this is not set on the client side, we will use the root certificates
+ * stored in the default system location, since client side must provide root
+ * certificates in TLS.
+ * If this is not set on the server side, we will not watch any root certificate
+ * updates, and assume no root certificates needed for the server(single-side
+ * TLS). Default root certs on the server side is not supported.
+ */
+GRPCAPI void grpc_tls_credentials_options_watch_root_certs(
+    grpc_tls_credentials_options* options);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the name of the root certificates being watched.
+ * If not set, We will use a default empty string as the root certificate name.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_root_cert_name(
+    grpc_tls_credentials_options* options, const char* root_cert_name);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * If set, gRPC stack will keep watching the identity key-cert pairs
+ * with name |identity_cert_name|.
+ * This is required on the server side, and optional on the client side.
+ */
+GRPCAPI void grpc_tls_credentials_options_watch_identity_key_cert_pairs(
+    grpc_tls_credentials_options* options);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the name of the identity certificates being watched.
+ * If not set, We will use a default empty string as the identity certificate
+ * name.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_identity_cert_name(
+    grpc_tls_credentials_options* options, const char* identity_cert_name);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the options of whether to request and/or verify client certs. This shall
+ * only be called on the server side.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_cert_request_type(
+    grpc_tls_credentials_options* options,
+    grpc_ssl_client_certificate_request_type type);
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * If set, gRPC will read all hashed x.509 CRL files in the directory and
+ * enforce the CRL files on all TLS handshakes. Only supported for OpenSSL
+ * version > 1.1.
+ * It is used for experimental purpose for now and subject to change.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_crl_directory(
+    grpc_tls_credentials_options* options, const char* crl_directory);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the options of whether to verify server certs on the client side.
+ * Passing in a non-zero value indicates verifying the certs.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_verify_server_cert(
+    grpc_tls_credentials_options* options, int verify_server_cert);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * The read-only request information exposed in a verification call.
+ * Callers should not directly manage the ownership of it. We will make sure it
+ * is always available inside verify() or cancel() call, and will destroy the
+ * object at the end of custom verification.
+ */
+typedef struct grpc_tls_custom_verification_check_request {
+  /* The target name of the server when the client initiates the connection. */
+  /* This field will be nullptr if on the server side. */
+  const char* target_name;
+  /* The information contained in the certificate chain sent from the peer. */
+  struct peer_info {
+    /* The Common Name field on the peer leaf certificate. */
+    const char* common_name;
+    /* The list of Subject Alternative Names on the peer leaf certificate. */
+    struct san_names {
+      char** uri_names;
+      size_t uri_names_size;
+      char** dns_names;
+      size_t dns_names_size;
+      char** email_names;
+      size_t email_names_size;
+      char** ip_names;
+      size_t ip_names_size;
+    } san_names;
+    /* The raw peer leaf certificate. */
+    const char* peer_cert;
+    /* The raw peer certificate chain. Note that it is not always guaranteed to
+     * get the peer full chain. For more, please refer to
+     * GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME defined in file
+     * grpc_security_constants.h.
+     * TODO(ZhenLian): Consider fixing this in the future. */
+    const char* peer_cert_full_chain;
+  } peer_info;
+} grpc_tls_custom_verification_check_request;
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * A callback function provided by gRPC as a parameter of the |verify| function
+ * in grpc_tls_certificate_verifier_external. If |verify| is expected to be run
+ * asynchronously, the implementer of |verify| will need to invoke this callback
+ * with |callback_arg| and proper verification status at the end to bring the
+ * control back to gRPC C core.
+ */
+typedef void (*grpc_tls_on_custom_verification_check_done_cb)(
+    grpc_tls_custom_verification_check_request* request, void* callback_arg,
+    grpc_status_code status, const char* error_details);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * The internal verifier type that will be used inside core.
+ */
+typedef struct grpc_tls_certificate_verifier grpc_tls_certificate_verifier;
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * A struct containing all the necessary functions a custom external verifier
+ * needs to implement to be able to be converted to an internal verifier.
+ */
+typedef struct grpc_tls_certificate_verifier_external {
+  void* user_data;
+  /**
+   * A function pointer containing the verification logic that will be
+   * performed after the TLS handshake is done. It could be processed
+   * synchronously or asynchronously.
+   * - If expected to be processed synchronously, the implementer should
+   *   populate the verification result through |sync_status| and
+   *   |sync_error_details|, and then return true.
+   * - If expected to be processed asynchronously, the implementer should return
+   *   false immediately, and then in the asynchronous thread invoke |callback|
+   *   with the verification result. The implementer MUST NOT invoke the async
+   *   |callback| in the same thread before |verify| returns, otherwise it can
+   *   lead to deadlocks.
+   *
+   * user_data: any argument that is passed in the user_data of
+   *            grpc_tls_certificate_verifier_external during construction time
+   *            can be retrieved later here.
+   * request: request information exposed to the function implementer.
+   * callback: the callback that the function implementer needs to invoke, if
+   *           return a non-zero value. It is usually invoked when the
+   *           asynchronous verification is done, and serves to bring the
+   *           control back to gRPC.
+   * callback_arg: A pointer to the internal ExternalVerifier instance. This is
+   *               mainly used as an argument in |callback|, if want to invoke
+   *               |callback| in async mode.
+   * sync_status: indicates if a connection should be allowed. This should only
+   *              be used if the verification check is done synchronously.
+   * sync_error_details: the error generated while verifying a connection. This
+   *                     should only be used if the verification check is done
+   *                     synchronously. the implementation must allocate the
+   *                     error string via gpr_malloc() or gpr_strdup().
+   * return: return 0 if |verify| is expected to be executed asynchronously,
+   *         otherwise return a non-zero value.
+   */
+  int (*verify)(void* user_data,
+                grpc_tls_custom_verification_check_request* request,
+                grpc_tls_on_custom_verification_check_done_cb callback,
+                void* callback_arg, grpc_status_code* sync_status,
+                char** sync_error_details);
+  /**
+   * A function pointer that cleans up the caller-specified resources when the
+   * verifier is still running but the whole connection got cancelled. This
+   * could happen when the verifier is doing some async operations, and the
+   * whole handshaker object got destroyed because of connection time limit is
+   * reached, or any other reasons. In such cases, function implementers might
+   * want to be notified, and properly clean up some resources.
+   *
+   * user_data: any argument that is passed in the user_data of
+   *            grpc_tls_certificate_verifier_external during construction time
+   *            can be retrieved later here.
+   * request: request information exposed to the function implementer. It will
+   *          be the same request object that was passed to verify(), and it
+   *          tells the cancel() which request to cancel.
+   */
+  void (*cancel)(void* user_data,
+                 grpc_tls_custom_verification_check_request* request);
+  /**
+   * A function pointer that does some additional destruction work when the
+   * verifier is destroyed. This is used when the caller wants to associate some
+   * objects to the lifetime of external_verifier, and destroy them when
+   * external_verifier got destructed. For example, in C++, the class containing
+   * user-specified callback functions should not be destroyed before
+   * external_verifier, since external_verifier will invoke them while being
+   * used.
+   * Note that the caller MUST delete the grpc_tls_certificate_verifier_external
+   * object itself in this function, otherwise it will cause memory leaks. That
+   * also means the user_data has to carries at least a self pointer, for the
+   * callers to later delete it in destruct().
+   *
+   * user_data: any argument that is passed in the user_data of
+   *            grpc_tls_certificate_verifier_external during construction time
+   *            can be retrieved later here.
+   */
+  void (*destruct)(void* user_data);
+} grpc_tls_certificate_verifier_external;
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Converts an external verifier to an internal verifier.
+ * Note that we will not take the ownership of the external_verifier. Callers
+ * will need to delete external_verifier in its own destruct function.
+ */
+grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_external_create(
+    grpc_tls_certificate_verifier_external* external_verifier);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Factory function for an internal verifier that won't perform any
+ * post-handshake verification. Note: using this solely without any other
+ * authentication mechanisms on the peer identity will leave your applications
+ * to the MITM(Man-In-The-Middle) attacks. Users should avoid doing so in
+ * production environments.
+ */
+grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_no_op_create();
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Factory function for an internal verifier that will do the default hostname
+ * check.
+ */
+grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_host_name_create();
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Releases a grpc_tls_certificate_verifier object. The creator of the
+ * grpc_tls_certificate_verifier object is responsible for its release.
+ */
+void grpc_tls_certificate_verifier_release(
+    grpc_tls_certificate_verifier* verifier);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the verifier in options. The |options| will implicitly take a new ref to
+ * the |verifier|. If not set on the client side, we will verify server's
+ * certificates, and check the default hostname. If not set on the server side,
+ * we will verify client's certificates.
+ */
+void grpc_tls_credentials_options_set_certificate_verifier(
+    grpc_tls_credentials_options* options,
+    grpc_tls_certificate_verifier* verifier);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the options of whether to check the hostname of the peer on a per-call
+ * basis. This is usually used in a combination with virtual hosting at the
+ * client side, where each individual call on a channel can have a different
+ * host associated with it.
+ * This check is intended to verify that the host specified for the individual
+ * call is covered by the cert that the peer presented.
+ * The default is a non-zero value, which indicates performing such checks.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_check_call_host(
+    grpc_tls_credentials_options* options, int check_call_host);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Performs the verification logic of an internal verifier.
+ * This is typically used when composing the internal verifiers as part of the
+ * custom verification.
+ * If |grpc_tls_certificate_verifier_verify| returns true, inspect the
+ * verification result through request->status and request->error_details.
+ * Otherwise, inspect through the parameter of |callback|.
+ */
+int grpc_tls_certificate_verifier_verify(
+    grpc_tls_certificate_verifier* verifier,
+    grpc_tls_custom_verification_check_request* request,
+    grpc_tls_on_custom_verification_check_done_cb callback, void* callback_arg,
+    grpc_status_code* sync_status, char** sync_error_details);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Performs the cancellation logic of an internal verifier.
+ * This is typically used when composing the internal verifiers as part of the
+ * custom verification.
+ */
+void grpc_tls_certificate_verifier_cancel(
+    grpc_tls_certificate_verifier* verifier,
+    grpc_tls_custom_verification_check_request* request);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Creates a TLS channel credential object based on the
+ * grpc_tls_credentials_options specified by callers. The
+ * grpc_channel_credentials will take the ownership of the |options|. The
+ * security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+ */
+grpc_channel_credentials* grpc_tls_credentials_create(
+    grpc_tls_credentials_options* options);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Creates a TLS server credential object based on the
+ * grpc_tls_credentials_options specified by callers. The
+ * grpc_server_credentials will take the ownership of the |options|.
+ */
+grpc_server_credentials* grpc_tls_server_credentials_create(
+    grpc_tls_credentials_options* options);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * This method creates an insecure channel credentials object.
+ */
+GRPCAPI grpc_channel_credentials* grpc_insecure_credentials_create();
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * This method creates an insecure server credentials object.
+ */
+GRPCAPI grpc_server_credentials* grpc_insecure_server_credentials_create();
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * This method creates an xDS channel credentials object.
+ *
+ * Creating a channel with credentials of this type indicates that the channel
+ * should get credentials configuration from the xDS control plane.
+ *
+ * \a fallback_credentials are used if the channel target does not have the
+ * 'xds:///' scheme or if the xDS control plane does not provide information on
+ * how to fetch credentials dynamically. Does NOT take ownership of the \a
+ * fallback_credentials. (Internally takes a ref to the object.)
+ */
+GRPCAPI grpc_channel_credentials* grpc_xds_credentials_create(
+    grpc_channel_credentials* fallback_credentials);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * This method creates an xDS server credentials object.
+ *
+ * \a fallback_credentials are used if the xDS control plane does not provide
+ * information on how to fetch credentials dynamically.
+ *
+ * Does NOT take ownership of the \a fallback_credentials. (Internally takes
+ * a ref to the object.)
+ */
+GRPCAPI grpc_server_credentials* grpc_xds_server_credentials_create(
+    grpc_server_credentials* fallback_credentials);
+
+/**
+ * EXPERIMENTAL - Subject to change.
+ * An opaque type that is responsible for providing authorization policies to
+ * gRPC.
+ */
+typedef struct grpc_authorization_policy_provider
+    grpc_authorization_policy_provider;
+
+/**
+ * EXPERIMENTAL - Subject to change.
+ * Creates a grpc_authorization_policy_provider using gRPC authorization policy
+ * from static string.
+ * - authz_policy is the input gRPC authorization policy.
+ * - code is the error status code on failure. On success, it equals
+ *   GRPC_STATUS_OK.
+ * - error_details contains details about the error if any. If the
+ *   initialization is successful, it will be null. Caller must use gpr_free to
+ *   destroy this string.
+ */
+GRPCAPI grpc_authorization_policy_provider*
+grpc_authorization_policy_provider_static_data_create(
+    const char* authz_policy, grpc_status_code* code,
+    const char** error_details);
+
+/**
+ * EXPERIMENTAL - Subject to change.
+ * Creates a grpc_authorization_policy_provider by watching for gRPC
+ * authorization policy changes in filesystem.
+ * - authz_policy is the file path of gRPC authorization policy.
+ * - refresh_interval_sec is the amount of time the internal thread would wait
+ *   before checking for file updates.
+ * - code is the error status code on failure. On success, it equals
+ *   GRPC_STATUS_OK.
+ * - error_details contains details about the error if any. If the
+ *   initialization is successful, it will be null. Caller must use gpr_free to
+ *   destroy this string.
+ */
+GRPCAPI grpc_authorization_policy_provider*
+grpc_authorization_policy_provider_file_watcher_create(
+    const char* authz_policy_path, unsigned int refresh_interval_sec,
+    grpc_status_code* code, const char** error_details);
+
+/**
+ * EXPERIMENTAL - Subject to change.
+ * Releases grpc_authorization_policy_provider object. The creator of
+ * grpc_authorization_policy_provider is responsible for its release.
+ */
+GRPCAPI void grpc_authorization_policy_provider_release(
+    grpc_authorization_policy_provider* provider);
+
+/** --- TLS session key logging. ---
+ * Experimental API to control tls session key logging. Tls session key logging
+ * is expected to be used only for debugging purposes and never in production.
+ * Tls session key logging is only enabled when:
+ *  At least one grpc_tls_credentials_options object is assigned a tls session
+ *  key logging file path using the API specified below.
+ */
+
+/**
+ * EXPERIMENTAL API - Subject to change.
+ * Configures a grpc_tls_credentials_options object with tls session key
+ * logging capability. TLS channels using these credentials have tls session
+ * key logging enabled.
+ * - options is the grpc_tls_credentials_options object
+ * - path is a string pointing to the location where TLS session keys would be
+ *   stored.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_tls_session_key_log_file_path(
+    grpc_tls_credentials_options* options, const char* path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_GRPC_SECURITY_H */
diff --git a/CAPI/cpp/grpc/include/grpc/grpc_security_constants.h b/CAPI/cpp/grpc/include/grpc/grpc_security_constants.h
new file mode 100644
index 0000000..505037e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/grpc_security_constants.h
@@ -0,0 +1,152 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_GRPC_SECURITY_CONSTANTS_H
+#define GRPC_GRPC_SECURITY_CONSTANTS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME "transport_security_type"
+#define GRPC_SSL_TRANSPORT_SECURITY_TYPE "ssl"
+#define GRPC_TLS_TRANSPORT_SECURITY_TYPE "tls"
+
+#define GRPC_X509_CN_PROPERTY_NAME "x509_common_name"
+#define GRPC_X509_SUBJECT_PROPERTY_NAME "x509_subject"
+#define GRPC_X509_SAN_PROPERTY_NAME "x509_subject_alternative_name"
+#define GRPC_X509_PEM_CERT_PROPERTY_NAME "x509_pem_cert"
+// Please note that internally, we just faithfully pass whatever value we got by
+// calling SSL_get_peer_cert_chain() in OpenSSL/BoringSSL. This will mean in
+// OpenSSL, the following conditions might apply:
+// 1. On the client side, this property returns the full certificate chain. On
+// the server side, this property will return the certificate chain without the
+// leaf certificate. Application can use GRPC_X509_PEM_CERT_PROPERTY_NAME to
+// get the peer leaf certificate.
+// 2. If the session is resumed, this property could be empty for OpenSSL (but
+// not for BoringSSL).
+// For more, please refer to the official OpenSSL manual:
+// https://www.openssl.org/docs/man1.1.0/man3/SSL_get_peer_cert_chain.html.
+#define GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME "x509_pem_cert_chain"
+#define GRPC_SSL_SESSION_REUSED_PROPERTY "ssl_session_reused"
+#define GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME "security_level"
+#define GRPC_PEER_DNS_PROPERTY_NAME "peer_dns"
+#define GRPC_PEER_SPIFFE_ID_PROPERTY_NAME "peer_spiffe_id"
+#define GRPC_PEER_URI_PROPERTY_NAME "peer_uri"
+#define GRPC_PEER_EMAIL_PROPERTY_NAME "peer_email"
+#define GRPC_PEER_IP_PROPERTY_NAME "peer_ip"
+
+/** Environment variable that points to the default SSL roots file. This file
+   must be a PEM encoded file with all the roots such as the one that can be
+   downloaded from https://pki.google.com/roots.pem.  */
+#define GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR \
+  "GRPC_DEFAULT_SSL_ROOTS_FILE_PATH"
+
+/** Environment variable that points to the google default application
+   credentials json key or refresh token. Used in the
+   grpc_google_default_credentials_create function. */
+#define GRPC_GOOGLE_CREDENTIALS_ENV_VAR "GOOGLE_APPLICATION_CREDENTIALS"
+
+/** Results for the SSL roots override callback. */
+typedef enum {
+  GRPC_SSL_ROOTS_OVERRIDE_OK,
+  GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY, /** Do not try fallback options. */
+  GRPC_SSL_ROOTS_OVERRIDE_FAIL
+} grpc_ssl_roots_override_result;
+
+/** Callback results for dynamically loading a SSL certificate config. */
+typedef enum {
+  GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED,
+  GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW,
+  GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL
+} grpc_ssl_certificate_config_reload_status;
+
+typedef enum {
+  /** Server does not request client certificate.
+     The certificate presented by the client is not checked by the server at
+     all. (A client may present a self signed or signed certificate or not
+     present a certificate at all and any of those option would be accepted) */
+  GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE,
+  /** Server requests client certificate but does not enforce that the client
+     presents a certificate.
+
+     If the client presents a certificate, the client authentication is left to
+     the application (the necessary metadata will be available to the
+     application via authentication context properties, see grpc_auth_context).
+
+     The client's key certificate pair must be valid for the SSL connection to
+     be established. */
+  GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY,
+  /** Server requests client certificate but does not enforce that the client
+     presents a certificate.
+
+     If the client presents a certificate, the client authentication is done by
+     the gRPC framework. (For a successful connection the client needs to either
+     present a certificate that can be verified against the root certificate
+     configured by the server or not present a certificate at all)
+
+     The client's key certificate pair must be valid for the SSL connection to
+     be established. */
+  GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY,
+  /** Server requests client certificate and enforces that the client presents a
+     certificate.
+
+     If the client presents a certificate, the client authentication is left to
+     the application (the necessary metadata will be available to the
+     application via authentication context properties, see grpc_auth_context).
+
+     The client's key certificate pair must be valid for the SSL connection to
+     be established. */
+  GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY,
+  /** Server requests client certificate and enforces that the client presents a
+     certificate.
+
+     The certificate presented by the client is verified by the gRPC framework.
+     (For a successful connection the client needs to present a certificate that
+     can be verified against the root certificate configured by the server)
+
+     The client's key certificate pair must be valid for the SSL connection to
+     be established. */
+  GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY
+} grpc_ssl_client_certificate_request_type;
+
+/* Security levels of grpc transport security. It represents an inherent
+ * property of a backend connection and is determined by a channel credential
+ * used to create the connection. */
+typedef enum {
+  GRPC_SECURITY_MIN,
+  GRPC_SECURITY_NONE = GRPC_SECURITY_MIN,
+  GRPC_INTEGRITY_ONLY,
+  GRPC_PRIVACY_AND_INTEGRITY,
+  GRPC_SECURITY_MAX = GRPC_PRIVACY_AND_INTEGRITY,
+} grpc_security_level;
+
+/**
+ * Type of local connections for which local channel/server credentials will be
+ * applied. It supports UDS and local TCP connections.
+ */
+typedef enum { UDS = 0, LOCAL_TCP } grpc_local_connect_type;
+
+/** The TLS versions that are supported by the SSL stack. **/
+typedef enum { TLS1_2, TLS1_3 } grpc_tls_version;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_GRPC_SECURITY_CONSTANTS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h
new file mode 100644
index 0000000..606369a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h
@@ -0,0 +1,97 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_ATM_H
+#define GRPC_IMPL_CODEGEN_ATM_H
+
+// IWYU pragma: private, include <grpc/support/atm.h>
+
+/** This interface provides atomic operations and barriers.
+   It is internal to gpr support code and should not be used outside it.
+
+   If an operation with acquire semantics precedes another memory access by the
+   same thread, the operation will precede that other access as seen by other
+   threads.
+
+   If an operation with release semantics follows another memory access by the
+   same thread, the operation will follow that other access as seen by other
+   threads.
+
+   Routines with "acq" or "full" in the name have acquire semantics.  Routines
+   with "rel" or "full" in the name have release semantics.  Routines with
+   "no_barrier" in the name have neither acquire not release semantics.
+
+   The routines may be implemented as macros.
+
+   // Atomic operations act on an intergral_type gpr_atm that is guaranteed to
+   // be the same size as a pointer.
+   typedef intptr_t gpr_atm;
+
+   // A memory barrier, providing both acquire and release semantics, but not
+   // otherwise acting on memory.
+   void gpr_atm_full_barrier(void);
+
+   // Atomically return *p, with acquire semantics.
+   gpr_atm gpr_atm_acq_load(gpr_atm *p);
+   gpr_atm gpr_atm_no_barrier_load(gpr_atm *p);
+
+   // Atomically set *p = value, with release semantics.
+   void gpr_atm_rel_store(gpr_atm *p, gpr_atm value);
+
+   // Atomically add delta to *p, and return the old value of *p, with
+   // the barriers specified.
+   gpr_atm gpr_atm_no_barrier_fetch_add(gpr_atm *p, gpr_atm delta);
+   gpr_atm gpr_atm_full_fetch_add(gpr_atm *p, gpr_atm delta);
+
+   // Atomically, if *p==o, set *p=n and return non-zero otherwise return 0,
+   // with the barriers specified if the operation succeeds.
+   int gpr_atm_no_barrier_cas(gpr_atm *p, gpr_atm o, gpr_atm n);
+   int gpr_atm_acq_cas(gpr_atm *p, gpr_atm o, gpr_atm n);
+   int gpr_atm_rel_cas(gpr_atm *p, gpr_atm o, gpr_atm n);
+   int gpr_atm_full_cas(gpr_atm *p, gpr_atm o, gpr_atm n);
+
+   // Atomically, set *p=n and return the old value of *p
+   gpr_atm gpr_atm_full_xchg(gpr_atm *p, gpr_atm n);
+*/
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#if defined(GPR_GCC_ATOMIC)
+#include <grpc/impl/codegen/atm_gcc_atomic.h>  // IWYU pragma: export
+#elif defined(GPR_GCC_SYNC)
+#include <grpc/impl/codegen/atm_gcc_sync.h>  // IWYU pragma: export
+#elif defined(GPR_WINDOWS_ATOMIC)
+#include <grpc/impl/codegen/atm_windows.h>  // IWYU pragma: export
+#else
+#error could not determine platform for atm
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Adds \a delta to \a *value, clamping the result to the range specified
+    by \a min and \a max.  Returns the new value. */
+gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta,
+                                       gpr_atm min, gpr_atm max);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_ATM_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_atomic.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_atomic.h
new file mode 100644
index 0000000..05d6e42
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_atomic.h
@@ -0,0 +1,93 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H
+#define GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H
+
+// IWYU pragma: private, include <grpc/support/atm.h>
+
+/* atm_platform.h for gcc and gcc-like compilers with the
+   __atomic_* interface.  */
+#include <grpc/impl/codegen/port_platform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef intptr_t gpr_atm;
+#define GPR_ATM_MAX INTPTR_MAX
+#define GPR_ATM_MIN INTPTR_MIN
+
+#ifdef GPR_LOW_LEVEL_COUNTERS
+extern gpr_atm gpr_counter_atm_cas;
+extern gpr_atm gpr_counter_atm_add;
+#define GPR_ATM_INC_COUNTER(counter) \
+  __atomic_fetch_add(&counter, 1, __ATOMIC_RELAXED)
+#define GPR_ATM_INC_CAS_THEN(blah) \
+  (GPR_ATM_INC_COUNTER(gpr_counter_atm_cas), blah)
+#define GPR_ATM_INC_ADD_THEN(blah) \
+  (GPR_ATM_INC_COUNTER(gpr_counter_atm_add), blah)
+#else
+#define GPR_ATM_INC_CAS_THEN(blah) blah
+#define GPR_ATM_INC_ADD_THEN(blah) blah
+#endif
+
+#define gpr_atm_full_barrier() (__atomic_thread_fence(__ATOMIC_SEQ_CST))
+
+#define gpr_atm_acq_load(p) (__atomic_load_n((p), __ATOMIC_ACQUIRE))
+#define gpr_atm_no_barrier_load(p) (__atomic_load_n((p), __ATOMIC_RELAXED))
+#define gpr_atm_rel_store(p, value) \
+  (__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELEASE))
+#define gpr_atm_no_barrier_store(p, value) \
+  (__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELAXED))
+
+#define gpr_atm_no_barrier_fetch_add(p, delta) \
+  GPR_ATM_INC_ADD_THEN(                        \
+      __atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_RELAXED))
+#define gpr_atm_full_fetch_add(p, delta) \
+  GPR_ATM_INC_ADD_THEN(                  \
+      __atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_ACQ_REL))
+
+static __inline int gpr_atm_no_barrier_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+  return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
+      p, &o, n, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED));
+}
+
+static __inline int gpr_atm_acq_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+  return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
+      p, &o, n, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED));
+}
+
+static __inline int gpr_atm_rel_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+  return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
+      p, &o, n, 0, __ATOMIC_RELEASE, __ATOMIC_RELAXED));
+}
+
+static __inline int gpr_atm_full_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+  return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
+      p, &o, n, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED));
+}
+
+#define gpr_atm_full_xchg(p, n) \
+  GPR_ATM_INC_CAS_THEN(__atomic_exchange_n((p), (n), __ATOMIC_ACQ_REL))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_sync.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_sync.h
new file mode 100644
index 0000000..bdc7a17
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_sync.h
@@ -0,0 +1,87 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H
+#define GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H
+
+// IWYU pragma: private, include <grpc/support/atm.h>
+
+/* variant of atm_platform.h for gcc and gcc-like compiers with __sync_*
+   interface */
+#include <grpc/impl/codegen/port_platform.h>
+
+typedef intptr_t gpr_atm;
+#define GPR_ATM_MAX INTPTR_MAX
+#define GPR_ATM_MIN INTPTR_MIN
+#define GPR_ATM_INC_CAS_THEN(blah) blah
+#define GPR_ATM_INC_ADD_THEN(blah) blah
+
+#define GPR_ATM_COMPILE_BARRIER_() __asm__ __volatile__("" : : : "memory")
+
+#if defined(__i386) || defined(__x86_64__)
+/* All loads are acquire loads and all stores are release stores.  */
+#define GPR_ATM_LS_BARRIER_() GPR_ATM_COMPILE_BARRIER_()
+#else
+#define GPR_ATM_LS_BARRIER_() gpr_atm_full_barrier()
+#endif
+
+#define gpr_atm_full_barrier() (__sync_synchronize())
+
+static __inline gpr_atm gpr_atm_acq_load(const gpr_atm* p) {
+  gpr_atm value = *p;
+  GPR_ATM_LS_BARRIER_();
+  return value;
+}
+
+static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm* p) {
+  gpr_atm value = *p;
+  GPR_ATM_COMPILE_BARRIER_();
+  return value;
+}
+
+static __inline void gpr_atm_rel_store(gpr_atm* p, gpr_atm value) {
+  GPR_ATM_LS_BARRIER_();
+  *p = value;
+}
+
+static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value) {
+  GPR_ATM_COMPILE_BARRIER_();
+  *p = value;
+}
+
+#undef GPR_ATM_LS_BARRIER_
+#undef GPR_ATM_COMPILE_BARRIER_
+
+#define gpr_atm_no_barrier_fetch_add(p, delta) \
+  gpr_atm_full_fetch_add((p), (delta))
+#define gpr_atm_full_fetch_add(p, delta) (__sync_fetch_and_add((p), (delta)))
+
+#define gpr_atm_no_barrier_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n))
+#define gpr_atm_acq_cas(p, o, n) (__sync_bool_compare_and_swap((p), (o), (n)))
+#define gpr_atm_rel_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n))
+#define gpr_atm_full_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n))
+
+static __inline gpr_atm gpr_atm_full_xchg(gpr_atm* p, gpr_atm n) {
+  gpr_atm cur;
+  do {
+    cur = gpr_atm_acq_load(p);
+  } while (!gpr_atm_rel_cas(p, cur, n));
+  return cur;
+}
+
+#endif /* GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_windows.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_windows.h
new file mode 100644
index 0000000..816c9a9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_windows.h
@@ -0,0 +1,134 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_ATM_WINDOWS_H
+#define GRPC_IMPL_CODEGEN_ATM_WINDOWS_H
+
+// IWYU pragma: private, include <grpc/support/atm.h>
+
+/** Win32 variant of atm_platform.h */
+#include <grpc/impl/codegen/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+typedef intptr_t gpr_atm;
+#define GPR_ATM_MAX INTPTR_MAX
+#define GPR_ATM_MIN INTPTR_MIN
+#define GPR_ATM_INC_CAS_THEN(blah) blah
+#define GPR_ATM_INC_ADD_THEN(blah) blah
+
+#define gpr_atm_full_barrier MemoryBarrier
+
+static __inline gpr_atm gpr_atm_acq_load(const gpr_atm* p) {
+  gpr_atm result = *p;
+  gpr_atm_full_barrier();
+  return result;
+}
+
+static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm* p) {
+  /* TODO(dklempner): Can we implement something better here? */
+  return gpr_atm_acq_load(p);
+}
+
+static __inline void gpr_atm_rel_store(gpr_atm* p, gpr_atm value) {
+  gpr_atm_full_barrier();
+  *p = value;
+}
+
+static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value) {
+  /* TODO(ctiller): Can we implement something better here? */
+  gpr_atm_rel_store(p, value);
+}
+
+static __inline int gpr_atm_no_barrier_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+/** InterlockedCompareExchangePointerNoFence() not available on vista or
+   windows7 */
+#ifdef GPR_ARCH_64
+  return o == (gpr_atm)InterlockedCompareExchangeAcquire64(
+                  (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o);
+#else
+  return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG*)p,
+                                                         (LONG)n, (LONG)o);
+#endif
+}
+
+static __inline int gpr_atm_acq_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+#ifdef GPR_ARCH_64
+  return o == (gpr_atm)InterlockedCompareExchangeAcquire64(
+                  (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o);
+#else
+  return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG*)p,
+                                                         (LONG)n, (LONG)o);
+#endif
+}
+
+static __inline int gpr_atm_rel_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+#ifdef GPR_ARCH_64
+  return o == (gpr_atm)InterlockedCompareExchangeRelease64(
+                  (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o);
+#else
+  return o == (gpr_atm)InterlockedCompareExchangeRelease((volatile LONG*)p,
+                                                         (LONG)n, (LONG)o);
+#endif
+}
+
+static __inline int gpr_atm_full_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+#ifdef GPR_ARCH_64
+  return o == (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG*)p,
+                                                    (LONGLONG)n, (LONGLONG)o);
+#else
+  return o == (gpr_atm)InterlockedCompareExchange((volatile LONG*)p, (LONG)n,
+                                                  (LONG)o);
+#endif
+}
+
+static __inline gpr_atm gpr_atm_no_barrier_fetch_add(gpr_atm* p,
+                                                     gpr_atm delta) {
+  /** Use the CAS operation to get pointer-sized fetch and add */
+  gpr_atm old;
+  do {
+    old = *p;
+  } while (!gpr_atm_no_barrier_cas(p, old, old + delta));
+  return old;
+}
+
+static __inline gpr_atm gpr_atm_full_fetch_add(gpr_atm* p, gpr_atm delta) {
+  /** Use a CAS operation to get pointer-sized fetch and add */
+  gpr_atm old;
+#ifdef GPR_ARCH_64
+  do {
+    old = *p;
+  } while (old != (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG*)p,
+                                                        (LONGLONG)old + delta,
+                                                        (LONGLONG)old));
+#else
+  do {
+    old = *p;
+  } while (old != (gpr_atm)InterlockedCompareExchange(
+                      (volatile LONG*)p, (LONG)old + delta, (LONG)old));
+#endif
+  return old;
+}
+
+static __inline gpr_atm gpr_atm_full_xchg(gpr_atm* p, gpr_atm n) {
+  return (gpr_atm)InterlockedExchangePointer((PVOID*)p, (PVOID)n);
+}
+
+#endif /* GPR_WINDOWS */
+
+#endif /* GRPC_IMPL_CODEGEN_ATM_WINDOWS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer.h
new file mode 100644
index 0000000..eeec56c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer.h
@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_BYTE_BUFFER_H
+#define GRPC_IMPL_CODEGEN_BYTE_BUFFER_H
+
+// IWYU pragma: private, include <grpc/byte_buffer.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpc/impl/codegen/grpc_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Returns a RAW byte buffer instance over the given slices (up to \a nslices).
+ *
+ * Increases the reference count for all \a slices processed. The user is
+ * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/
+GRPCAPI grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slices,
+                                                      size_t nslices);
+
+/** Returns a *compressed* RAW byte buffer instance over the given slices (up to
+ * \a nslices). The \a compression argument defines the compression algorithm
+ * used to generate the data in \a slices.
+ *
+ * Increases the reference count for all \a slices processed. The user is
+ * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/
+GRPCAPI grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(
+    grpc_slice* slices, size_t nslices, grpc_compression_algorithm compression);
+
+/** Copies input byte buffer \a bb.
+ *
+ * Increases the reference count of all the source slices. The user is
+ * responsible for calling grpc_byte_buffer_destroy over the returned copy. */
+GRPCAPI grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb);
+
+/** Returns the size of the given byte buffer, in bytes. */
+GRPCAPI size_t grpc_byte_buffer_length(grpc_byte_buffer* bb);
+
+/** Destroys \a byte_buffer deallocating all its memory. */
+GRPCAPI void grpc_byte_buffer_destroy(grpc_byte_buffer* bb);
+
+/** Reader for byte buffers. Iterates over slices in the byte buffer */
+struct grpc_byte_buffer_reader;
+typedef struct grpc_byte_buffer_reader grpc_byte_buffer_reader;
+
+/** Initialize \a reader to read over \a buffer.
+ * Returns 1 upon success, 0 otherwise. */
+GRPCAPI int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
+                                         grpc_byte_buffer* buffer);
+
+/** Cleanup and destroy \a reader */
+GRPCAPI void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader);
+
+/** Updates \a slice with the next piece of data from from \a reader and returns
+ * 1. Returns 0 at the end of the stream. Caller is responsible for calling
+ * grpc_slice_unref on the result. */
+GRPCAPI int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
+                                         grpc_slice* slice);
+
+/** EXPERIMENTAL API - This function may be removed and changed, in the future.
+ *
+ * Updates \a slice with the next piece of data from from \a reader and returns
+ * 1. Returns 0 at the end of the stream. Caller is responsible for making sure
+ * the slice pointer remains valid when accessed.
+ *
+ * NOTE: Do not use this function unless the caller can guarantee that the
+ *       underlying grpc_byte_buffer outlasts the use of the slice. This is only
+ *       safe when the underlying grpc_byte_buffer remains immutable while slice
+ *       is being accessed. */
+GRPCAPI int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader,
+                                         grpc_slice** slice);
+
+/** Merge all data from \a reader into single slice */
+GRPCAPI grpc_slice
+grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader* reader);
+
+/** Returns a RAW byte buffer instance from the output of \a reader. */
+GRPCAPI grpc_byte_buffer* grpc_raw_byte_buffer_from_reader(
+    grpc_byte_buffer_reader* reader);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_BYTE_BUFFER_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer_reader.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer_reader.h
new file mode 100644
index 0000000..35b8ee7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer_reader.h
@@ -0,0 +1,44 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_BYTE_BUFFER_READER_H
+#define GRPC_IMPL_CODEGEN_BYTE_BUFFER_READER_H
+
+// IWYU pragma: private, include <grpc/byte_buffer_reader.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct grpc_byte_buffer;
+
+struct grpc_byte_buffer_reader {
+  struct grpc_byte_buffer* buffer_in;
+  struct grpc_byte_buffer* buffer_out;
+  /** Different current objects correspond to different types of byte buffers */
+  union grpc_byte_buffer_reader_current {
+    /** Index into a slice buffer's array of slices */
+    unsigned index;
+  } current;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_BYTE_BUFFER_READER_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/compression_types.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/compression_types.h
new file mode 100644
index 0000000..c187030
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/compression_types.h
@@ -0,0 +1,109 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H
+#define GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H
+
+// IWYU pragma: private, include <grpc/compression.h>
+// IWYU pragma: friend "src/.*"
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** To be used as initial metadata key for the request of a concrete compression
+ * algorithm */
+#define GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY \
+  "grpc-internal-encoding-request"
+
+/** To be used in channel arguments.
+ *
+ * \addtogroup grpc_arg_keys
+ * \{ */
+/** Default compression algorithm for the channel.
+ * Its value is an int from the \a grpc_compression_algorithm enum. */
+#define GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM \
+  "grpc.default_compression_algorithm"
+/** Default compression level for the channel.
+ * Its value is an int from the \a grpc_compression_level enum. */
+#define GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL "grpc.default_compression_level"
+/** Compression algorithms supported by the channel.
+ * Its value is a bitset (an int). Bits correspond to algorithms in \a
+ * grpc_compression_algorithm. For example, its LSB corresponds to
+ * GRPC_COMPRESS_NONE, the next bit to GRPC_COMPRESS_DEFLATE, etc.
+ * Unset bits disable support for the algorithm. By default all algorithms are
+ * supported. It's not possible to disable GRPC_COMPRESS_NONE (the attempt will
+ * be ignored). */
+#define GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET \
+  "grpc.compression_enabled_algorithms_bitset"
+/** \} */
+
+/** The various compression algorithms supported by gRPC (not sorted by
+ * compression level) */
+typedef enum {
+  GRPC_COMPRESS_NONE = 0,
+  GRPC_COMPRESS_DEFLATE,
+  GRPC_COMPRESS_GZIP,
+  /* TODO(ctiller): snappy */
+  GRPC_COMPRESS_ALGORITHMS_COUNT
+} grpc_compression_algorithm;
+
+/** Compression levels allow a party with knowledge of its peer's accepted
+ * encodings to request compression in an abstract way. The level-algorithm
+ * mapping is performed internally and depends on the peer's supported
+ * compression algorithms. */
+typedef enum {
+  GRPC_COMPRESS_LEVEL_NONE = 0,
+  GRPC_COMPRESS_LEVEL_LOW,
+  GRPC_COMPRESS_LEVEL_MED,
+  GRPC_COMPRESS_LEVEL_HIGH,
+  GRPC_COMPRESS_LEVEL_COUNT
+} grpc_compression_level;
+
+typedef struct grpc_compression_options {
+  /** All algs are enabled by default. This option corresponds to the channel
+   * argument key behind \a GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET
+   */
+  uint32_t enabled_algorithms_bitset;
+
+  /** The default compression level. It'll be used in the absence of call
+   * specific settings. This option corresponds to the channel
+   * argument key behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL. If present,
+   * takes precedence over \a default_algorithm.
+   * TODO(dgq): currently only available for server channels. */
+  struct grpc_compression_options_default_level {
+    int is_set;
+    grpc_compression_level level;
+  } default_level;
+
+  /** The default message compression algorithm. It'll be used in the absence of
+   * call specific settings. This option corresponds to the channel argument key
+   * behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM. */
+  struct grpc_compression_options_default_algorithm {
+    int is_set;
+    grpc_compression_algorithm algorithm;
+  } default_algorithm;
+} grpc_compression_options;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/connectivity_state.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/connectivity_state.h
new file mode 100644
index 0000000..218afd7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/connectivity_state.h
@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H
+#define GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H
+
+// IWYU pragma: private, include <grpc/grpc.h>
+// IWYU pragma: friend "src/.*"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Connectivity state of a channel. */
+typedef enum {
+  /** channel is idle */
+  GRPC_CHANNEL_IDLE,
+  /** channel is connecting */
+  GRPC_CHANNEL_CONNECTING,
+  /** channel is ready for work */
+  GRPC_CHANNEL_READY,
+  /** channel has seen a failure but expects to recover */
+  GRPC_CHANNEL_TRANSIENT_FAILURE,
+  /** channel has seen a failure that it cannot recover from */
+  GRPC_CHANNEL_SHUTDOWN
+} grpc_connectivity_state;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/fork.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/fork.h
new file mode 100644
index 0000000..6818b53
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/fork.h
@@ -0,0 +1,50 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_FORK_H
+#define GRPC_IMPL_CODEGEN_FORK_H
+
+// IWYU pragma: private, include <grpc/fork.h>
+
+/**
+ * gRPC applications should call this before calling fork().  There should be no
+ * active gRPC function calls between calling grpc_prefork() and
+ * grpc_postfork_parent()/grpc_postfork_child().
+ *
+ *
+ * Typical use:
+ * grpc_prefork();
+ * int pid = fork();
+ * if (pid) {
+ *  grpc_postfork_parent();
+ *  // Parent process..
+ * } else {
+ *  grpc_postfork_child();
+ *  // Child process...
+ * }
+ */
+
+void grpc_prefork(void);
+
+void grpc_postfork_parent(void);
+
+void grpc_postfork_child(void);
+
+void grpc_fork_handlers_auto_register(void);
+
+#endif /* GRPC_IMPL_CODEGEN_FORK_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_slice.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_slice.h
new file mode 100644
index 0000000..8782ba3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_slice.h
@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+#ifndef GRPC_IMPL_CODEGEN_GPR_SLICE_H
+#define GRPC_IMPL_CODEGEN_GPR_SLICE_H
+
+// IWYU pragma: private
+
+/** WARNING: Please do not use this header. This was added as a temporary
+ * measure to not break some of the external projects that depend on
+ * gpr_slice_* functions. We are actively working on moving all the
+ * gpr_slice_* references to grpc_slice_* and this file will be removed
+ */
+
+/* TODO (sreek) - Allowed by default but will be very soon turned off */
+#define GRPC_ALLOW_GPR_SLICE_FUNCTIONS 1
+
+#ifdef GRPC_ALLOW_GPR_SLICE_FUNCTIONS
+
+#define gpr_slice_refcount grpc_slice_refcount
+#define gpr_slice grpc_slice
+#define gpr_slice_buffer grpc_slice_buffer
+
+#define gpr_slice_ref grpc_slice_ref
+#define gpr_slice_unref grpc_slice_unref
+#define gpr_slice_new grpc_slice_new
+#define gpr_slice_new_with_user_data grpc_slice_new_with_user_data
+#define gpr_slice_new_with_len grpc_slice_new_with_len
+#define gpr_slice_malloc grpc_slice_malloc
+#define gpr_slice_from_copied_string grpc_slice_from_copied_string
+#define gpr_slice_from_copied_buffer grpc_slice_from_copied_buffer
+#define gpr_slice_from_static_string grpc_slice_from_static_string
+#define gpr_slice_sub grpc_slice_sub
+#define gpr_slice_sub_no_ref grpc_slice_sub_no_ref
+#define gpr_slice_split_tail grpc_slice_split_tail
+#define gpr_slice_split_head grpc_slice_split_head
+#define gpr_slice_cmp grpc_slice_cmp
+#define gpr_slice_str_cmp grpc_slice_str_cmp
+
+#define gpr_slice_buffer grpc_slice_buffer
+#define gpr_slice_buffer_init grpc_slice_buffer_init
+#define gpr_slice_buffer_destroy grpc_slice_buffer_destroy
+#define gpr_slice_buffer_add grpc_slice_buffer_add
+#define gpr_slice_buffer_add_indexed grpc_slice_buffer_add_indexed
+#define gpr_slice_buffer_addn grpc_slice_buffer_addn
+#define gpr_slice_buffer_tiny_add grpc_slice_buffer_tiny_add
+#define gpr_slice_buffer_pop grpc_slice_buffer_pop
+#define gpr_slice_buffer_reset_and_unref grpc_slice_buffer_reset_and_unref
+#define gpr_slice_buffer_swap grpc_slice_buffer_swap
+#define gpr_slice_buffer_move_into grpc_slice_buffer_move_into
+#define gpr_slice_buffer_trim_end grpc_slice_buffer_trim_end
+#define gpr_slice_buffer_move_first grpc_slice_buffer_move_first
+#define gpr_slice_buffer_take_first grpc_slice_buffer_take_first
+
+#endif /* GRPC_ALLOW_GPR_SLICE_FUNCTIONS */
+
+#endif /* GRPC_IMPL_CODEGEN_GPR_SLICE_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_types.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_types.h
new file mode 100644
index 0000000..253ff3a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_types.h
@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_GPR_TYPES_H
+#define GRPC_IMPL_CODEGEN_GPR_TYPES_H
+
+// IWYU pragma: private, include <grpc/grpc.h>
+// IWYU pragma: friend "src/.*"
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** The clocks we support. */
+typedef enum {
+  /** Monotonic clock. Epoch undefined. Always moves forwards. */
+  GPR_CLOCK_MONOTONIC = 0,
+  /** Realtime clock. May jump forwards or backwards. Settable by
+     the system administrator. Has its epoch at 0:00:00 UTC 1 Jan 1970. */
+  GPR_CLOCK_REALTIME,
+  /** CPU cycle time obtained by rdtsc instruction on x86 platforms. Epoch
+     undefined. Degrades to GPR_CLOCK_REALTIME on other platforms. */
+  GPR_CLOCK_PRECISE,
+  /** Unmeasurable clock type: no base, created by taking the difference
+     between two times */
+  GPR_TIMESPAN
+} gpr_clock_type;
+
+/** Analogous to struct timespec. On some machines, absolute times may be in
+ * local time. */
+typedef struct gpr_timespec {
+  int64_t tv_sec;
+  int32_t tv_nsec;
+  /** Against which clock was this time measured? (or GPR_TIMESPAN if
+      this is a relative time measure) */
+  gpr_clock_type clock_type;
+} gpr_timespec;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_GPR_TYPES_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/grpc_types.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/grpc_types.h
new file mode 100644
index 0000000..2dfdbf3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/grpc_types.h
@@ -0,0 +1,812 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_GRPC_TYPES_H
+#define GRPC_IMPL_CODEGEN_GRPC_TYPES_H
+
+// IWYU pragma: private, include <grpc/grpc.h>
+// IWYU pragma: friend "src/.*"
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <stddef.h>
+
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/impl/codegen/slice.h>
+#include <grpc/impl/codegen/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  GRPC_BB_RAW
+  /** Future types may include GRPC_BB_PROTOBUF, etc. */
+} grpc_byte_buffer_type;
+
+typedef struct grpc_byte_buffer {
+  void* reserved;
+  grpc_byte_buffer_type type;
+  union grpc_byte_buffer_data {
+    struct /* internal */ {
+      void* reserved[8];
+    } reserved;
+    struct grpc_compressed_buffer {
+      grpc_compression_algorithm compression;
+      grpc_slice_buffer slice_buffer;
+    } raw;
+  } data;
+} grpc_byte_buffer;
+
+/** Completion Queues enable notification of the completion of
+ * asynchronous actions. */
+typedef struct grpc_completion_queue grpc_completion_queue;
+
+/** The Channel interface allows creation of Call objects. */
+typedef struct grpc_channel grpc_channel;
+
+/** A server listens to some port and responds to request calls */
+typedef struct grpc_server grpc_server;
+
+/** A Call represents an RPC. When created, it is in a configuration state
+    allowing properties to be set until it is invoked. After invoke, the Call
+    can have messages written to it and read from it. */
+typedef struct grpc_call grpc_call;
+
+/** The Socket Mutator interface allows changes on socket options */
+typedef struct grpc_socket_mutator grpc_socket_mutator;
+
+/** The Socket Factory interface creates and binds sockets */
+typedef struct grpc_socket_factory grpc_socket_factory;
+
+/** Type specifier for grpc_arg */
+typedef enum {
+  GRPC_ARG_STRING,
+  GRPC_ARG_INTEGER,
+  GRPC_ARG_POINTER
+} grpc_arg_type;
+
+typedef struct grpc_arg_pointer_vtable {
+  void* (*copy)(void* p);
+  void (*destroy)(void* p);
+  int (*cmp)(void* p, void* q);
+} grpc_arg_pointer_vtable;
+
+/** A single argument... each argument has a key and a value
+
+    A note on naming keys:
+      Keys are namespaced into groups, usually grouped by library, and are
+      keys for module XYZ are named XYZ.key1, XYZ.key2, etc. Module names must
+      be restricted to the regex [A-Za-z][_A-Za-z0-9]{,15}.
+      Key names must be restricted to the regex [A-Za-z][_A-Za-z0-9]{,47}.
+
+    GRPC core library keys are prefixed by grpc.
+
+    Library authors are strongly encouraged to \#define symbolic constants for
+    their keys so that it's possible to change them in the future. */
+typedef struct {
+  grpc_arg_type type;
+  char* key;
+  union grpc_arg_value {
+    char* string;
+    int integer;
+    struct grpc_arg_pointer {
+      void* p;
+      const grpc_arg_pointer_vtable* vtable;
+    } pointer;
+  } value;
+} grpc_arg;
+
+/** An array of arguments that can be passed around.
+
+    Used to set optional channel-level configuration.
+    These configuration options are modelled as key-value pairs as defined
+    by grpc_arg; keys are strings to allow easy backwards-compatible extension
+    by arbitrary parties. All evaluation is performed at channel creation
+    time (i.e. the keys and values in this structure need only live through the
+    creation invocation).
+
+    However, if one of the args has grpc_arg_type==GRPC_ARG_POINTER, then the
+    grpc_arg_pointer_vtable must live until the channel args are done being
+    used by core (i.e. when the object for use with which they were passed
+    is destroyed).
+
+    See the description of the \ref grpc_arg_keys "available args" for more
+    details. */
+typedef struct {
+  size_t num_args;
+  grpc_arg* args;
+} grpc_channel_args;
+
+/** \defgroup grpc_arg_keys
+ * Channel argument keys.
+ * \{
+ */
+/** If non-zero, enable census for tracing and stats collection. */
+#define GRPC_ARG_ENABLE_CENSUS "grpc.census"
+/** If non-zero, enable load reporting. */
+#define GRPC_ARG_ENABLE_LOAD_REPORTING "grpc.loadreporting"
+/** Request that optional features default to off (regardless of what they
+    usually default to) - to enable tight control over what gets enabled */
+#define GRPC_ARG_MINIMAL_STACK "grpc.minimal_stack"
+/** Maximum number of concurrent incoming streams to allow on a http2
+    connection. Int valued. */
+#define GRPC_ARG_MAX_CONCURRENT_STREAMS "grpc.max_concurrent_streams"
+/** Maximum message length that the channel can receive. Int valued, bytes.
+    -1 means unlimited. */
+#define GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH "grpc.max_receive_message_length"
+/** \deprecated For backward compatibility.
+ * Use GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH instead. */
+#define GRPC_ARG_MAX_MESSAGE_LENGTH GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH
+/** Maximum message length that the channel can send. Int valued, bytes.
+    -1 means unlimited. */
+#define GRPC_ARG_MAX_SEND_MESSAGE_LENGTH "grpc.max_send_message_length"
+/** Maximum time that a channel may have no outstanding rpcs, after which the
+ * server will close the connection. Int valued, milliseconds. INT_MAX means
+ * unlimited. */
+#define GRPC_ARG_MAX_CONNECTION_IDLE_MS "grpc.max_connection_idle_ms"
+/** Maximum time that a channel may exist. Int valued, milliseconds.
+ * INT_MAX means unlimited. */
+#define GRPC_ARG_MAX_CONNECTION_AGE_MS "grpc.max_connection_age_ms"
+/** Grace period after the channel reaches its max age. Int valued,
+   milliseconds. INT_MAX means unlimited. */
+#define GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS "grpc.max_connection_age_grace_ms"
+/** Timeout after the last RPC finishes on the client channel at which the
+ * channel goes back into IDLE state. Int valued, milliseconds. INT_MAX means
+ * unlimited. The default value is 30 minutes and the min value is 1 second. */
+#define GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS "grpc.client_idle_timeout_ms"
+/** Enable/disable support for per-message compression. Defaults to 1, unless
+    GRPC_ARG_MINIMAL_STACK is enabled, in which case it defaults to 0. */
+#define GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION "grpc.per_message_compression"
+/** Experimental Arg. Enable/disable support for per-message decompression.
+   Defaults to 1. If disabled, decompression will not be performed and the
+   application will see the compressed message in the byte buffer. */
+#define GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION \
+  "grpc.per_message_decompression"
+/** Enable/disable support for deadline checking. Defaults to 1, unless
+    GRPC_ARG_MINIMAL_STACK is enabled, in which case it defaults to 0 */
+#define GRPC_ARG_ENABLE_DEADLINE_CHECKS "grpc.enable_deadline_checking"
+/** Initial stream ID for http2 transports. Int valued. */
+#define GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER \
+  "grpc.http2.initial_sequence_number"
+/** Amount to read ahead on individual streams. Defaults to 64kb, larger
+    values can help throughput on high-latency connections.
+    NOTE: at some point we'd like to auto-tune this, and this parameter
+    will become a no-op. Int valued, bytes. */
+#define GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES "grpc.http2.lookahead_bytes"
+/** How much memory to use for hpack decoding. Int valued, bytes. */
+#define GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER \
+  "grpc.http2.hpack_table_size.decoder"
+/** How much memory to use for hpack encoding. Int valued, bytes. */
+#define GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER \
+  "grpc.http2.hpack_table_size.encoder"
+/** How big a frame are we willing to receive via HTTP2.
+    Min 16384, max 16777215. Larger values give lower CPU usage for large
+    messages, but more head of line blocking for small messages. */
+#define GRPC_ARG_HTTP2_MAX_FRAME_SIZE "grpc.http2.max_frame_size"
+/** Should BDP probing be performed? */
+#define GRPC_ARG_HTTP2_BDP_PROBE "grpc.http2.bdp_probe"
+/** (DEPRECATED) Does not have any effect.
+    Earlier, this arg configured the minimum time between successive ping frames
+    without receiving any data/header frame, Int valued, milliseconds. This put
+    unnecessary constraints on the configuration of keepalive pings,
+    requiring users to set this channel arg along with
+    GRPC_ARG_KEEPALIVE_TIME_MS. This arg also limited the activity of the other
+    source of pings in gRPC Core - BDP pings, but BDP pings are only sent when
+    there is receive-side data activity, making this arg unuseful for BDP pings
+    too.  */
+#define GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS \
+  "grpc.http2.min_time_between_pings_ms"
+/** Minimum allowed time between a server receiving successive ping frames
+   without sending any data/header frame. Int valued, milliseconds
+ */
+#define GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS \
+  "grpc.http2.min_ping_interval_without_data_ms"
+/** Channel arg to override the http2 :scheme header */
+#define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
+/** How many pings can the client send before needing to send a
+   data/header frame? (0 indicates that an infinite number of
+   pings can be sent without sending a data frame or header frame) */
+#define GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA \
+  "grpc.http2.max_pings_without_data"
+/** How many misbehaving pings the server can bear before sending goaway and
+    closing the transport? (0 indicates that the server can bear an infinite
+    number of misbehaving pings) */
+#define GRPC_ARG_HTTP2_MAX_PING_STRIKES "grpc.http2.max_ping_strikes"
+/** How much data are we willing to queue up per stream if
+    GRPC_WRITE_BUFFER_HINT is set? This is an upper bound */
+#define GRPC_ARG_HTTP2_WRITE_BUFFER_SIZE "grpc.http2.write_buffer_size"
+/** Should we allow receipt of true-binary data on http2 connections?
+    Defaults to on (1) */
+#define GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY "grpc.http2.true_binary"
+/** After a duration of this time the client/server pings its peer to see if the
+    transport is still alive. Int valued, milliseconds. */
+#define GRPC_ARG_KEEPALIVE_TIME_MS "grpc.keepalive_time_ms"
+/** After waiting for a duration of this time, if the keepalive ping sender does
+    not receive the ping ack, it will close the transport. Int valued,
+    milliseconds. */
+#define GRPC_ARG_KEEPALIVE_TIMEOUT_MS "grpc.keepalive_timeout_ms"
+/** Is it permissible to send keepalive pings from the client without any
+   outstanding streams. Int valued, 0(false)/1(true). */
+#define GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS \
+  "grpc.keepalive_permit_without_calls"
+/** Default authority to pass if none specified on call construction. A string.
+ * */
+#define GRPC_ARG_DEFAULT_AUTHORITY "grpc.default_authority"
+/** Primary user agent: goes at the start of the user-agent metadata
+    sent on each request. A string. */
+#define GRPC_ARG_PRIMARY_USER_AGENT_STRING "grpc.primary_user_agent"
+/** Secondary user agent: goes at the end of the user-agent metadata
+    sent on each request. A string. */
+#define GRPC_ARG_SECONDARY_USER_AGENT_STRING "grpc.secondary_user_agent"
+/** The minimum time between subsequent connection attempts, in ms */
+#define GRPC_ARG_MIN_RECONNECT_BACKOFF_MS "grpc.min_reconnect_backoff_ms"
+/** The maximum time between subsequent connection attempts, in ms */
+#define GRPC_ARG_MAX_RECONNECT_BACKOFF_MS "grpc.max_reconnect_backoff_ms"
+/** The time between the first and second connection attempts, in ms */
+#define GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS \
+  "grpc.initial_reconnect_backoff_ms"
+/** Minimum amount of time between DNS resolutions, in ms */
+#define GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS \
+  "grpc.dns_min_time_between_resolutions_ms"
+/** The timeout used on servers for finishing handshaking on an incoming
+    connection.  Defaults to 120 seconds. */
+#define GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS "grpc.server_handshake_timeout_ms"
+/** This *should* be used for testing only.
+    The caller of the secure_channel_create functions may override the target
+    name used for SSL host name checking using this channel argument which is of
+    type \a GRPC_ARG_STRING. If this argument is not specified, the name used
+    for SSL host name checking will be the target parameter (assuming that the
+    secure channel is an SSL channel). If this parameter is specified and the
+    underlying is not an SSL channel, it will just be ignored. */
+#define GRPC_SSL_TARGET_NAME_OVERRIDE_ARG "grpc.ssl_target_name_override"
+/** If non-zero, a pointer to a session cache (a pointer of type
+    grpc_ssl_session_cache*). (use grpc_ssl_session_cache_arg_vtable() to fetch
+    an appropriate pointer arg vtable) */
+#define GRPC_SSL_SESSION_CACHE_ARG "grpc.ssl_session_cache"
+/** If non-zero, it will determine the maximum frame size used by TSI's frame
+ *  protector.
+ *
+ *  NOTE: Be aware that using a large "max_frame_size" is memory inefficient
+ *        for non-zerocopy protectors. Also, increasing this value above 1MiB
+ *        can break old binaries that don't support larger than 1MiB frame
+ *        size. */
+#define GRPC_ARG_TSI_MAX_FRAME_SIZE "grpc.tsi.max_frame_size"
+/** Maximum metadata size, in bytes. Note this limit applies to the max sum of
+    all metadata key-value entries in a batch of headers. */
+#define GRPC_ARG_MAX_METADATA_SIZE "grpc.max_metadata_size"
+/** If non-zero, allow the use of SO_REUSEPORT if it's available (default 1) */
+#define GRPC_ARG_ALLOW_REUSEPORT "grpc.so_reuseport"
+/** If non-zero, a pointer to a buffer pool (a pointer of type
+ * grpc_resource_quota*). (use grpc_resource_quota_arg_vtable() to fetch an
+ * appropriate pointer arg vtable) */
+#define GRPC_ARG_RESOURCE_QUOTA "grpc.resource_quota"
+/** If non-zero, expand wildcard addresses to a list of local addresses. */
+#define GRPC_ARG_EXPAND_WILDCARD_ADDRS "grpc.expand_wildcard_addrs"
+/** Service config data in JSON form.
+    This value will be ignored if the name resolver returns a service config. */
+#define GRPC_ARG_SERVICE_CONFIG "grpc.service_config"
+/** Disable looking up the service config via the name resolver. */
+#define GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION \
+  "grpc.service_config_disable_resolution"
+/** LB policy name. */
+#define GRPC_ARG_LB_POLICY_NAME "grpc.lb_policy_name"
+/** The grpc_socket_mutator instance that set the socket options. A pointer. */
+#define GRPC_ARG_SOCKET_MUTATOR "grpc.socket_mutator"
+/** The grpc_socket_factory instance to create and bind sockets. A pointer. */
+#define GRPC_ARG_SOCKET_FACTORY "grpc.socket_factory"
+/** The maximum amount of memory used by trace events per channel trace node.
+ * Once the maximum is reached, subsequent events will evict the oldest events
+ * from the buffer. The unit for this knob is bytes. Setting it to zero causes
+ * channel tracing to be disabled. */
+#define GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE \
+  "grpc.max_channel_trace_event_memory_per_node"
+/** If non-zero, gRPC library will track stats and information at at per channel
+ * level. Disabling channelz naturally disables channel tracing. The default
+ * is for channelz to be enabled. */
+#define GRPC_ARG_ENABLE_CHANNELZ "grpc.enable_channelz"
+/** If non-zero, Cronet transport will coalesce packets to fewer frames
+ * when possible. */
+#define GRPC_ARG_USE_CRONET_PACKET_COALESCING \
+  "grpc.use_cronet_packet_coalescing"
+/** Channel arg (integer) setting how large a slice to try and read from the
+   wire each time recvmsg (or equivalent) is called **/
+#define GRPC_ARG_TCP_READ_CHUNK_SIZE "grpc.experimental.tcp_read_chunk_size"
+/** Note this is not a "channel arg" key. This is the default slice size to use
+ * when trying to read from the wire if the GRPC_ARG_TCP_READ_CHUNK_SIZE
+ * channel arg is unspecified. */
+#define GRPC_TCP_DEFAULT_READ_SLICE_SIZE 8192
+#define GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE \
+  "grpc.experimental.tcp_min_read_chunk_size"
+#define GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE \
+  "grpc.experimental.tcp_max_read_chunk_size"
+/* TCP TX Zerocopy enable state: zero is disabled, non-zero is enabled. By
+   default, it is disabled. */
+#define GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED \
+  "grpc.experimental.tcp_tx_zerocopy_enabled"
+/* TCP TX Zerocopy send threshold: only zerocopy if >= this many bytes sent. By
+   default, this is set to 16KB. */
+#define GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD \
+  "grpc.experimental.tcp_tx_zerocopy_send_bytes_threshold"
+/* TCP TX Zerocopy max simultaneous sends: limit for maximum number of pending
+   calls to tcp_write() using zerocopy. A tcp_write() is considered pending
+   until the kernel performs the zerocopy-done callback for all sendmsg() calls
+   issued by the tcp_write(). By default, this is set to 4. */
+#define GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS \
+  "grpc.experimental.tcp_tx_zerocopy_max_simultaneous_sends"
+/* Timeout in milliseconds to use for calls to the grpclb load balancer.
+   If 0 or unset, the balancer calls will have no deadline. */
+#define GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS "grpc.grpclb_call_timeout_ms"
+/* Specifies the xDS bootstrap config as a JSON string.
+   FOR TESTING PURPOSES ONLY -- DO NOT USE IN PRODUCTION.
+   This option allows controlling the bootstrap configuration on a
+   per-channel basis, which is useful in tests.  However, this results
+   in having a separate xDS client instance per channel rather than
+   using the global instance, which is not the intended way to use xDS.
+   Currently, this will (a) add unnecessary load on the xDS server and
+   (b) break use of CSDS, and there may be additional side effects in
+   the future. */
+#define GRPC_ARG_TEST_ONLY_DO_NOT_USE_IN_PROD_XDS_BOOTSTRAP_CONFIG \
+  "grpc.TEST_ONLY_DO_NOT_USE_IN_PROD.xds_bootstrap_config"
+/* Timeout in milliseconds to wait for the serverlist from the grpclb load
+   balancer before using fallback backend addresses from the resolver.
+   If 0, enter fallback mode immediately. Default value is 10000. */
+#define GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS "grpc.grpclb_fallback_timeout_ms"
+/* Timeout in milliseconds to wait for the child of a specific priority to
+   complete its initial connection attempt before the priority LB policy fails
+   over to the next priority. Default value is 10 seconds. */
+#define GRPC_ARG_PRIORITY_FAILOVER_TIMEOUT_MS \
+  "grpc.priority_failover_timeout_ms"
+/** If non-zero, grpc server's cronet compression workaround will be enabled */
+#define GRPC_ARG_WORKAROUND_CRONET_COMPRESSION \
+  "grpc.workaround.cronet_compression"
+/** String defining the optimization target for a channel.
+    Can be: "latency"    - attempt to minimize latency at the cost of throughput
+            "blend"      - try to balance latency and throughput
+            "throughput" - attempt to maximize throughput at the expense of
+                           latency
+    Defaults to "blend". In the current implementation "blend" is equivalent to
+    "latency". */
+#define GRPC_ARG_OPTIMIZATION_TARGET "grpc.optimization_target"
+/** Enables retry functionality.  Defaults to true.  When enabled,
+    transparent retries will be performed as appropriate, and configurable
+    retries are enabled when they are configured via the service config.
+    For details, see:
+      https://github.com/grpc/proposal/blob/master/A6-client-retries.md
+    NOTE: Hedging functionality is not yet implemented, so those
+          fields in the service config will currently be ignored.  See
+          also the GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING arg below.
+ */
+#define GRPC_ARG_ENABLE_RETRIES "grpc.enable_retries"
+/** Enables hedging functionality, as described in:
+      https://github.com/grpc/proposal/blob/master/A6-client-retries.md
+    Default is currently false, since this functionality is not yet
+    fully implemented.
+    NOTE: This channel arg is experimental and will eventually be removed.
+          Once hedging functionality has been implemented and proves stable,
+          this arg will be removed, and the hedging functionality will
+          be enabled via the GRPC_ARG_ENABLE_RETRIES arg above. */
+#define GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING "grpc.experimental.enable_hedging"
+/** Per-RPC retry buffer size, in bytes. Default is 256 KiB. */
+#define GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE "grpc.per_rpc_retry_buffer_size"
+/** Channel arg that carries the bridged objective c object for custom metrics
+ * logging filter. */
+#define GRPC_ARG_MOBILE_LOG_CONTEXT "grpc.mobile_log_context"
+/** If non-zero, client authority filter is disabled for the channel */
+#define GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER \
+  "grpc.disable_client_authority_filter"
+/** If set to zero, disables use of http proxies. Enabled by default. */
+#define GRPC_ARG_ENABLE_HTTP_PROXY "grpc.enable_http_proxy"
+/** Channel arg to set http proxy per channel. If set, the channel arg
+ *  value will be prefered over the envrionment variable settings. */
+#define GRPC_ARG_HTTP_PROXY "grpc.http_proxy"
+/** If set to non zero, surfaces the user agent string to the server. User
+    agent is surfaced by default. */
+#define GRPC_ARG_SURFACE_USER_AGENT "grpc.surface_user_agent"
+/** If set, inhibits health checking (which may be enabled via the
+ *  service config.) */
+#define GRPC_ARG_INHIBIT_HEALTH_CHECKING "grpc.inhibit_health_checking"
+/** If enabled, the channel's DNS resolver queries for SRV records.
+ *  This is useful only when using the "grpclb" load balancing policy,
+ *  as described in the following documents:
+ *   https://github.com/grpc/proposal/blob/master/A5-grpclb-in-dns.md
+ *   https://github.com/grpc/proposal/blob/master/A24-lb-policy-config.md
+ *   https://github.com/grpc/proposal/blob/master/A26-grpclb-selection.md
+ *  Note that this works only with the "ares" DNS resolver; it isn't supported
+ *  by the "native" DNS resolver. */
+#define GRPC_ARG_DNS_ENABLE_SRV_QUERIES "grpc.dns_enable_srv_queries"
+/** If set, determines an upper bound on the number of milliseconds that the
+ * c-ares based DNS resolver will wait on queries before cancelling them.
+ * The default value is 120,000. Setting this to "0" will disable the
+ * overall timeout entirely. Note that this doesn't include internal c-ares
+ * timeouts/backoff/retry logic, and so the actual DNS resolution may time out
+ * sooner than the value specified here. */
+#define GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS "grpc.dns_ares_query_timeout"
+/** If set, uses a local subchannel pool within the channel. Otherwise, uses the
+ * global subchannel pool. */
+#define GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL "grpc.use_local_subchannel_pool"
+/** gRPC Objective-C channel pooling domain string. */
+#define GRPC_ARG_CHANNEL_POOL_DOMAIN "grpc.channel_pooling_domain"
+/** gRPC Objective-C channel pooling id. */
+#define GRPC_ARG_CHANNEL_ID "grpc.channel_id"
+/** Channel argument for grpc_authorization_policy_provider. If present, enables
+    gRPC authorization check. */
+#define GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER \
+  "grpc.authorization_policy_provider"
+/** EXPERIMENTAL. Updates to a server's configuration from a config fetcher (for
+ * example, listener updates from xDS) cause all older connections to be
+ * gracefully shut down (i.e., "drained") with a grace period configured by this
+ * channel arg. Int valued, milliseconds. Defaults to 10 minutes.*/
+#define GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS \
+  "grpc.experimental.server_config_change_drain_grace_time_ms"
+/** \} */
+
+/** Result of a grpc call. If the caller satisfies the prerequisites of a
+    particular operation, the grpc_call_error returned will be GRPC_CALL_OK.
+    Receiving any other value listed here is an indication of a bug in the
+    caller. */
+typedef enum grpc_call_error {
+  /** everything went ok */
+  GRPC_CALL_OK = 0,
+  /** something failed, we don't know what */
+  GRPC_CALL_ERROR,
+  /** this method is not available on the server */
+  GRPC_CALL_ERROR_NOT_ON_SERVER,
+  /** this method is not available on the client */
+  GRPC_CALL_ERROR_NOT_ON_CLIENT,
+  /** this method must be called before server_accept */
+  GRPC_CALL_ERROR_ALREADY_ACCEPTED,
+  /** this method must be called before invoke */
+  GRPC_CALL_ERROR_ALREADY_INVOKED,
+  /** this method must be called after invoke */
+  GRPC_CALL_ERROR_NOT_INVOKED,
+  /** this call is already finished
+      (writes_done or write_status has already been called) */
+  GRPC_CALL_ERROR_ALREADY_FINISHED,
+  /** there is already an outstanding read/write operation on the call */
+  GRPC_CALL_ERROR_TOO_MANY_OPERATIONS,
+  /** the flags value was illegal for this call */
+  GRPC_CALL_ERROR_INVALID_FLAGS,
+  /** invalid metadata was passed to this call */
+  GRPC_CALL_ERROR_INVALID_METADATA,
+  /** invalid message was passed to this call */
+  GRPC_CALL_ERROR_INVALID_MESSAGE,
+  /** completion queue for notification has not been registered
+   * with the server */
+  GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE,
+  /** this batch of operations leads to more operations than allowed */
+  GRPC_CALL_ERROR_BATCH_TOO_BIG,
+  /** payload type requested is not the type registered */
+  GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH,
+  /** completion queue has been shutdown */
+  GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN
+} grpc_call_error;
+
+/** Default send/receive message size limits in bytes. -1 for unlimited. */
+/** TODO(roth) Make this match the default receive limit after next release */
+#define GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH (-1)
+#define GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH (4 * 1024 * 1024)
+
+/** Write Flags: */
+/** Hint that the write may be buffered and need not go out on the wire
+    immediately. GRPC is free to buffer the message until the next non-buffered
+    write, or until writes_done, but it need not buffer completely or at all. */
+#define GRPC_WRITE_BUFFER_HINT (0x00000001u)
+/** Force compression to be disabled for a particular write
+    (start_write/add_metadata). Illegal on invoke/accept. */
+#define GRPC_WRITE_NO_COMPRESS (0x00000002u)
+/** Force this message to be written to the socket before completing it */
+#define GRPC_WRITE_THROUGH (0x00000004u)
+/** Mask of all valid flags. */
+#define GRPC_WRITE_USED_MASK \
+  (GRPC_WRITE_BUFFER_HINT | GRPC_WRITE_NO_COMPRESS | GRPC_WRITE_THROUGH)
+
+/** Initial metadata flags */
+/** These flags are to be passed to the `grpc_op::flags` field */
+/** Signal that the call should not return UNAVAILABLE before it has started */
+#define GRPC_INITIAL_METADATA_WAIT_FOR_READY (0x00000020u)
+/** Signal that GRPC_INITIAL_METADATA_WAIT_FOR_READY was explicitly set
+    by the calling application. */
+#define GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET (0x00000080u)
+
+/** Mask of all valid flags */
+#define GRPC_INITIAL_METADATA_USED_MASK                  \
+  (GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET | \
+   GRPC_INITIAL_METADATA_WAIT_FOR_READY | GRPC_WRITE_THROUGH)
+
+/** A single metadata element */
+typedef struct grpc_metadata {
+  /** the key, value values are expected to line up with grpc_mdelem: if
+     changing them, update metadata.h at the same time. */
+  grpc_slice key;
+  grpc_slice value;
+
+  /** The following fields are reserved for grpc internal use.
+      There is no need to initialize them, and they will be set to garbage
+      during calls to grpc. */
+  struct /* internal */ {
+    void* obfuscated[4];
+  } internal_data;
+} grpc_metadata;
+
+/** The type of completion (for grpc_event) */
+typedef enum grpc_completion_type {
+  /** Shutting down */
+  GRPC_QUEUE_SHUTDOWN,
+  /** No event before timeout */
+  GRPC_QUEUE_TIMEOUT,
+  /** Operation completion */
+  GRPC_OP_COMPLETE
+} grpc_completion_type;
+
+/** The result of an operation.
+
+    Returned by a completion queue when the operation started with tag. */
+typedef struct grpc_event {
+  /** The type of the completion. */
+  grpc_completion_type type;
+  /** If the grpc_completion_type is GRPC_OP_COMPLETE, this field indicates
+      whether the operation was successful or not; 0 in case of failure and
+      non-zero in case of success.
+      If grpc_completion_type is GRPC_QUEUE_SHUTDOWN or GRPC_QUEUE_TIMEOUT, this
+      field is guaranteed to be 0 */
+  int success;
+  /** The tag passed to grpc_call_start_batch etc to start this operation.
+      *Only* GRPC_OP_COMPLETE has a tag. For all other grpc_completion_type
+      values, tag is uninitialized. */
+  void* tag;
+} grpc_event;
+
+typedef struct {
+  size_t count;
+  size_t capacity;
+  grpc_metadata* metadata;
+} grpc_metadata_array;
+
+typedef struct {
+  grpc_slice method;
+  grpc_slice host;
+  gpr_timespec deadline;
+} grpc_call_details;
+
+typedef enum {
+  /** Send initial metadata: one and only one instance MUST be sent for each
+      call, unless the call was cancelled - in which case this can be skipped.
+      This op completes after all bytes of metadata have been accepted by
+      outgoing flow control. */
+  GRPC_OP_SEND_INITIAL_METADATA = 0,
+  /** Send a message: 0 or more of these operations can occur for each call.
+      This op completes after all bytes for the message have been accepted by
+      outgoing flow control. */
+  GRPC_OP_SEND_MESSAGE,
+  /** Send a close from the client: one and only one instance MUST be sent from
+      the client, unless the call was cancelled - in which case this can be
+      skipped. This op completes after all bytes for the call
+      (including the close) have passed outgoing flow control. */
+  GRPC_OP_SEND_CLOSE_FROM_CLIENT,
+  /** Send status from the server: one and only one instance MUST be sent from
+      the server unless the call was cancelled - in which case this can be
+      skipped. This op completes after all bytes for the call
+      (including the status) have passed outgoing flow control. */
+  GRPC_OP_SEND_STATUS_FROM_SERVER,
+  /** Receive initial metadata: one and only one MUST be made on the client,
+      must not be made on the server.
+      This op completes after all initial metadata has been read from the
+      peer. */
+  GRPC_OP_RECV_INITIAL_METADATA,
+  /** Receive a message: 0 or more of these operations can occur for each call.
+      This op completes after all bytes of the received message have been
+      read, or after a half-close has been received on this call. */
+  GRPC_OP_RECV_MESSAGE,
+  /** Receive status on the client: one and only one must be made on the client.
+      This operation always succeeds, meaning ops paired with this operation
+      will also appear to succeed, even though they may not have. In that case
+      the status will indicate some failure.
+      This op completes after all activity on the call has completed. */
+  GRPC_OP_RECV_STATUS_ON_CLIENT,
+  /** Receive close on the server: one and only one must be made on the
+      server. This op completes after the close has been received by the
+      server. This operation always succeeds, meaning ops paired with
+      this operation will also appear to succeed, even though they may not
+      have. */
+  GRPC_OP_RECV_CLOSE_ON_SERVER
+} grpc_op_type;
+
+struct grpc_byte_buffer;
+
+/** Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT
+   which has no arguments) */
+typedef struct grpc_op {
+  /** Operation type, as defined by grpc_op_type */
+  grpc_op_type op;
+  /** Write flags bitset for grpc_begin_messages */
+  uint32_t flags;
+  /** Reserved for future usage */
+  void* reserved;
+  union grpc_op_data {
+    /** Reserved for future usage */
+    struct /* internal */ {
+      void* reserved[8];
+    } reserved;
+    struct grpc_op_send_initial_metadata {
+      size_t count;
+      grpc_metadata* metadata;
+      /** If \a is_set, \a compression_level will be used for the call.
+       * Otherwise, \a compression_level won't be considered */
+      struct grpc_op_send_initial_metadata_maybe_compression_level {
+        uint8_t is_set;
+        grpc_compression_level level;
+      } maybe_compression_level;
+    } send_initial_metadata;
+    struct grpc_op_send_message {
+      /** This op takes ownership of the slices in send_message.  After
+       * a call completes, the contents of send_message are not guaranteed
+       * and likely empty.  The original owner should still call
+       * grpc_byte_buffer_destroy() on this object however.
+       */
+      struct grpc_byte_buffer* send_message;
+    } send_message;
+    struct grpc_op_send_status_from_server {
+      size_t trailing_metadata_count;
+      grpc_metadata* trailing_metadata;
+      grpc_status_code status;
+      /** optional: set to NULL if no details need sending, non-NULL if they do
+       * pointer will not be retained past the start_batch call
+       */
+      grpc_slice* status_details;
+    } send_status_from_server;
+    /** ownership of the array is with the caller, but ownership of the elements
+        stays with the call object (ie key, value members are owned by the call
+        object, recv_initial_metadata->array is owned by the caller).
+        After the operation completes, call grpc_metadata_array_destroy on this
+        value, or reuse it in a future op. */
+    struct grpc_op_recv_initial_metadata {
+      grpc_metadata_array* recv_initial_metadata;
+    } recv_initial_metadata;
+    /** ownership of the byte buffer is moved to the caller; the caller must
+        call grpc_byte_buffer_destroy on this value, or reuse it in a future op.
+        The returned byte buffer will be NULL if trailing metadata was
+        received instead of a message.
+       */
+    struct grpc_op_recv_message {
+      struct grpc_byte_buffer** recv_message;
+    } recv_message;
+    struct grpc_op_recv_status_on_client {
+      /** ownership of the array is with the caller, but ownership of the
+          elements stays with the call object (ie key, value members are owned
+          by the call object, trailing_metadata->array is owned by the caller).
+          After the operation completes, call grpc_metadata_array_destroy on
+          this value, or reuse it in a future op. */
+      grpc_metadata_array* trailing_metadata;
+      grpc_status_code* status;
+      grpc_slice* status_details;
+      /** If this is not nullptr, it will be populated with the full fidelity
+       * error string for debugging purposes. The application is responsible
+       * for freeing the data by using gpr_free(). */
+      const char** error_string;
+    } recv_status_on_client;
+    struct grpc_op_recv_close_on_server {
+      /** out argument, set to 1 if the call failed at the server for
+          a reason other than a non-OK status (cancel, deadline
+          exceeded, network failure, etc.), 0 otherwise (RPC processing ran to
+          completion and was able to provide any status from the server) */
+      int* cancelled;
+    } recv_close_on_server;
+  } data;
+} grpc_op;
+
+/** Information requested from the channel. */
+typedef struct {
+  /** If non-NULL, will be set to point to a string indicating the LB
+   * policy name.  Caller takes ownership. */
+  char** lb_policy_name;
+  /** If non-NULL, will be set to point to a string containing the
+   * service config used by the channel in JSON form. */
+  char** service_config_json;
+} grpc_channel_info;
+
+typedef struct grpc_resource_quota grpc_resource_quota;
+
+/** Completion queues internally MAY maintain a set of file descriptors in a
+    structure called 'pollset'. This enum specifies if a completion queue has an
+    associated pollset and any restrictions on the type of file descriptors that
+    can be present in the pollset.
+
+    I/O progress can only be made when grpc_completion_queue_next() or
+    grpc_completion_queue_pluck() are called on the completion queue (unless the
+    grpc_cq_polling_type is GRPC_CQ_NON_POLLING) and hence it is very important
+    to actively call these APIs */
+typedef enum {
+  /** The completion queue will have an associated pollset and there is no
+      restriction on the type of file descriptors the pollset may contain */
+  GRPC_CQ_DEFAULT_POLLING,
+
+  /** Similar to GRPC_CQ_DEFAULT_POLLING except that the completion queues will
+      not contain any 'listening file descriptors' (i.e file descriptors used to
+      listen to incoming channels) */
+  GRPC_CQ_NON_LISTENING,
+
+  /** The completion queue will not have an associated pollset. Note that
+      grpc_completion_queue_next() or grpc_completion_queue_pluck() MUST still
+      be called to pop events from the completion queue; it is not required to
+      call them actively to make I/O progress */
+  GRPC_CQ_NON_POLLING
+} grpc_cq_polling_type;
+
+/** Specifies the type of APIs to use to pop events from the completion queue */
+typedef enum {
+  /** Events are popped out by calling grpc_completion_queue_next() API ONLY */
+  GRPC_CQ_NEXT,
+
+  /** Events are popped out by calling grpc_completion_queue_pluck() API ONLY*/
+  GRPC_CQ_PLUCK,
+
+  /** Events trigger a callback specified as the tag */
+  GRPC_CQ_CALLBACK
+} grpc_cq_completion_type;
+
+/** Specifies an interface class to be used as a tag for callback-based
+ * completion queues. This can be used directly, as the first element of a
+ * struct in C, or as a base class in C++. Its "run" value should be assigned to
+ * some non-member function, such as a static method. */
+typedef struct grpc_completion_queue_functor {
+  /** The run member specifies a function that will be called when this
+      tag is extracted from the completion queue. Its arguments will be a
+      pointer to this functor and a boolean that indicates whether the
+      operation succeeded (non-zero) or failed (zero) */
+  void (*functor_run)(struct grpc_completion_queue_functor*, int);
+
+  /** The inlineable member specifies whether this functor can be run inline.
+      This should only be used for trivial internally-defined functors. */
+  int inlineable;
+
+  /** The following fields are not API. They are meant for internal use. */
+  int internal_success;
+  struct grpc_completion_queue_functor* internal_next;
+} grpc_completion_queue_functor;
+
+#define GRPC_CQ_CURRENT_VERSION 2
+#define GRPC_CQ_VERSION_MINIMUM_FOR_CALLBACKABLE 2
+typedef struct grpc_completion_queue_attributes {
+  /** The version number of this structure. More fields might be added to this
+     structure in future. */
+  int version; /** Set to GRPC_CQ_CURRENT_VERSION */
+
+  grpc_cq_completion_type cq_completion_type;
+
+  grpc_cq_polling_type cq_polling_type;
+
+  /* END OF VERSION 1 CQ ATTRIBUTES */
+
+  /* START OF VERSION 2 CQ ATTRIBUTES */
+  /** When creating a callbackable CQ, pass in a functor to get invoked when
+   * shutdown is complete */
+  grpc_completion_queue_functor* cq_shutdown_cb;
+
+  /* END OF VERSION 2 CQ ATTRIBUTES */
+} grpc_completion_queue_attributes;
+
+/** The completion queue factory structure is opaque to the callers of grpc */
+typedef struct grpc_completion_queue_factory grpc_completion_queue_factory;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_GRPC_TYPES_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/log.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/log.h
new file mode 100644
index 0000000..1d5d2da
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/log.h
@@ -0,0 +1,112 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_LOG_H
+#define GRPC_IMPL_CODEGEN_LOG_H
+
+// IWYU pragma: private, include <grpc/support/log.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <stdarg.h>
+#include <stdlib.h> /* for abort() */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** GPR log API.
+
+   Usage (within grpc):
+
+   int argument1 = 3;
+   char* argument2 = "hello";
+   gpr_log(GPR_DEBUG, "format string %d", argument1);
+   gpr_log(GPR_INFO, "hello world");
+   gpr_log(GPR_ERROR, "%d %s!!", argument1, argument2); */
+
+/** The severity of a log message - use the #defines below when calling into
+   gpr_log to additionally supply file and line data */
+typedef enum gpr_log_severity {
+  GPR_LOG_SEVERITY_DEBUG,
+  GPR_LOG_SEVERITY_INFO,
+  GPR_LOG_SEVERITY_ERROR
+} gpr_log_severity;
+
+/** Returns a string representation of the log severity */
+GPRAPI const char* gpr_log_severity_string(gpr_log_severity severity);
+
+/** Macros to build log contexts at various severity levels */
+#define GPR_DEBUG __FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG
+#define GPR_INFO __FILE__, __LINE__, GPR_LOG_SEVERITY_INFO
+#define GPR_ERROR __FILE__, __LINE__, GPR_LOG_SEVERITY_ERROR
+
+/** Log a message. It's advised to use GPR_xxx above to generate the context
+ * for each message */
+GPRAPI void gpr_log(const char* file, int line, gpr_log_severity severity,
+                    const char* format, ...) GPR_PRINT_FORMAT_CHECK(4, 5);
+
+GPRAPI int gpr_should_log(gpr_log_severity severity);
+
+GPRAPI void gpr_log_message(const char* file, int line,
+                            gpr_log_severity severity, const char* message);
+
+/** Set global log verbosity */
+GPRAPI void gpr_set_log_verbosity(gpr_log_severity min_severity_to_print);
+
+GPRAPI void gpr_log_verbosity_init(void);
+
+/** Log overrides: applications can use this API to intercept logging calls
+   and use their own implementations */
+
+struct gpr_log_func_args {
+  const char* file;
+  int line;
+  gpr_log_severity severity;
+  const char* message;
+};
+
+typedef struct gpr_log_func_args gpr_log_func_args;
+
+typedef void (*gpr_log_func)(gpr_log_func_args* args);
+GPRAPI void gpr_set_log_function(gpr_log_func func);
+
+/** abort() the process if x is zero, having written a line to the log.
+
+   Intended for internal invariants.  If the error can be recovered from,
+   without the possibility of corruption, or might best be reflected via
+   an exception in a higher-level language, consider returning error code.  */
+#define GPR_ASSERT(x)                                 \
+  do {                                                \
+    if (GPR_UNLIKELY(!(x))) {                         \
+      gpr_log(GPR_ERROR, "assertion failed: %s", #x); \
+      abort();                                        \
+    }                                                 \
+  } while (0)
+
+#ifndef NDEBUG
+#define GPR_DEBUG_ASSERT(x) GPR_ASSERT(x)
+#else
+#define GPR_DEBUG_ASSERT(x)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_LOG_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/port_platform.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/port_platform.h
new file mode 100644
index 0000000..ec8217a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/port_platform.h
@@ -0,0 +1,782 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_PORT_PLATFORM_H
+#define GRPC_IMPL_CODEGEN_PORT_PLATFORM_H
+
+// IWYU pragma: private, include <grpc/support/port_platform.h>
+
+/*
+ * Define GPR_BACKWARDS_COMPATIBILITY_MODE to try harder to be ABI
+ * compatible with older platforms (currently only on Linux)
+ * Causes:
+ *  - some libc calls to be gotten via dlsym
+ *  - some syscalls to be made directly
+ */
+
+// [[deprecated]] attribute is only available since C++14
+#if __cplusplus >= 201402L
+#define GRPC_DEPRECATED(reason) [[deprecated(reason)]]
+#else
+#define GRPC_DEPRECATED(reason)
+#endif  // __cplusplus >= 201402L
+
+/*
+ * Defines GPR_ABSEIL_SYNC to use synchronization features from Abseil
+ */
+#ifndef GPR_ABSEIL_SYNC
+#if defined(__APPLE__)
+// This is disabled on Apple platforms because macos/grpc_basictests_c_cpp
+// fails with this. https://github.com/grpc/grpc/issues/23661
+#else
+#define GPR_ABSEIL_SYNC 1
+#endif
+#endif  // GPR_ABSEIL_SYNC
+
+/* Get windows.h included everywhere (we need it) */
+#if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32)
+#ifndef WIN32_LEAN_AND_MEAN
+#define GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED
+#define WIN32_LEAN_AND_MEAN
+#endif /* WIN32_LEAN_AND_MEAN */
+
+#ifndef NOMINMAX
+#define GRPC_NOMINMX_WAS_NOT_DEFINED
+#define NOMINMAX
+#endif /* NOMINMAX */
+
+#include <windows.h>
+
+#ifndef _WIN32_WINNT
+#error \
+    "Please compile grpc with _WIN32_WINNT of at least 0x600 (aka Windows Vista)"
+#else /* !defined(_WIN32_WINNT) */
+#if (_WIN32_WINNT < 0x0600)
+#error \
+    "Please compile grpc with _WIN32_WINNT of at least 0x600 (aka Windows Vista)"
+#endif /* _WIN32_WINNT < 0x0600 */
+#endif /* defined(_WIN32_WINNT) */
+
+#ifdef GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED
+#undef GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED
+#undef WIN32_LEAN_AND_MEAN
+#endif /* GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED */
+
+#ifdef GRPC_NOMINMAX_WAS_NOT_DEFINED
+#undef GRPC_NOMINMAX_WAS_NOT_DEFINED
+#undef NOMINMAX
+#endif /* GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED */
+#endif /* defined(_WIN64) || defined(WIN64) || defined(_WIN32) || \
+          defined(WIN32) */
+
+/* Override this file with one for your platform if you need to redefine
+   things.  */
+
+#if !defined(GPR_NO_AUTODETECT_PLATFORM)
+#if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32)
+#if defined(_WIN64) || defined(WIN64)
+#define GPR_ARCH_64 1
+#else
+#define GPR_ARCH_32 1
+#endif
+#define GPR_PLATFORM_STRING "windows"
+#define GPR_WINDOWS 1
+#define GPR_WINDOWS_SUBPROCESS 1
+#define GPR_WINDOWS_ENV
+#ifdef __MSYS__
+#define GPR_GETPID_IN_UNISTD_H 1
+#define GPR_MSYS_TMPFILE
+#define GPR_POSIX_LOG
+#define GPR_POSIX_STRING
+#define GPR_POSIX_TIME
+#else
+#define GPR_GETPID_IN_PROCESS_H 1
+#define GPR_WINDOWS_TMPFILE
+#define GPR_WINDOWS_LOG
+#define GPR_WINDOWS_CRASH_HANDLER 1
+#define GPR_WINDOWS_STAT
+#define GPR_WINDOWS_STRING
+#define GPR_WINDOWS_TIME
+#endif
+#ifdef __GNUC__
+#define GPR_GCC_ATOMIC 1
+#else
+#define GPR_WINDOWS_ATOMIC 1
+#endif
+#elif defined(ANDROID) || defined(__ANDROID__)
+#define GPR_PLATFORM_STRING "android"
+#define GPR_ANDROID 1
+#ifndef __ANDROID_API__
+#error "__ANDROID_API__ must be defined for Android builds."
+#endif
+#if __ANDROID_API__ < 21
+#error "Requires Android API v21 and above"
+#endif
+#define GPR_SUPPORT_BINDER_TRANSPORT 1
+// TODO(apolcyn): re-evaluate support for c-ares
+// on android after upgrading our c-ares dependency.
+// See https://github.com/grpc/grpc/issues/18038.
+#define GRPC_ARES 0
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_SYNC 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_ANDROID_LOG 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#define GPR_SUPPORT_CHANNELS_FROM_FD 1
+#elif defined(__linux__)
+#define GPR_PLATFORM_STRING "linux"
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <features.h>
+#define GPR_CPU_LINUX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_LINUX 1
+#define GPR_LINUX_LOG
+#define GPR_SUPPORT_CHANNELS_FROM_FD 1
+#define GPR_LINUX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#ifdef __GLIBC__
+#define GPR_POSIX_CRASH_HANDLER 1
+#ifdef __GLIBC_PREREQ
+#if __GLIBC_PREREQ(2, 12)
+#define GPR_LINUX_PTHREAD_NAME 1
+#endif
+#else
+// musl libc & others
+#define GPR_LINUX_PTHREAD_NAME 1
+#endif
+#include <linux/version.h>
+#else /* musl libc */
+#define GPR_MUSL_LIBC_COMPAT 1
+#endif
+#elif defined(__ASYLO__)
+#define GPR_ARCH_64 1
+#define GPR_CPU_POSIX 1
+#define GPR_PLATFORM_STRING "asylo"
+#define GPR_GCC_SYNC 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_TIME 1
+#define GPR_POSIX_ENV 1
+#define GPR_ASYLO 1
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_SOCKETADDR
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_TIMER_USE_GENERIC 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_WAKEUP_FD 1
+#define GRPC_HAVE_MSG_NOSIGNAL 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+#define GRPC_ARES 0
+#define GPR_NO_AUTODETECT_PLATFORM 1
+#elif defined(__APPLE__)
+#include <Availability.h>
+#include <TargetConditionals.h>
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+#if TARGET_OS_IPHONE
+#define GPR_PLATFORM_STRING "ios"
+#define GPR_CPU_IPHONE 1
+#define GRPC_CFSTREAM 1
+/* the c-ares resolver isn't safe to enable on iOS */
+#define GRPC_ARES 0
+#else /* TARGET_OS_IPHONE */
+#define GPR_PLATFORM_STRING "osx"
+#define GPR_CPU_POSIX 1
+#define GPR_POSIX_CRASH_HANDLER 1
+#endif
+#if !(defined(__has_feature) && __has_feature(cxx_thread_local))
+#define GPR_PTHREAD_TLS 1
+#endif
+#define GPR_APPLE 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#ifndef GRPC_CFSTREAM
+#define GPR_SUPPORT_CHANNELS_FROM_FD 1
+#endif
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#elif defined(__FreeBSD__)
+#define GPR_PLATFORM_STRING "freebsd"
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+#define GPR_FREEBSD 1
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#define GPR_SUPPORT_CHANNELS_FROM_FD 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#elif defined(__OpenBSD__)
+#define GPR_PLATFORM_STRING "openbsd"
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+#define GPR_OPENBSD 1
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#define GPR_SUPPORT_CHANNELS_FROM_FD 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#elif defined(__sun) && defined(__SVR4)
+#define GPR_PLATFORM_STRING "solaris"
+#define GPR_SOLARIS 1
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#elif defined(_AIX)
+#define GPR_PLATFORM_STRING "aix"
+#ifndef _ALL_SOURCE
+#define _ALL_SOURCE
+#endif
+#define GPR_AIX 1
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#elif defined(__NetBSD__)
+// NetBSD is a community-supported platform.
+// Please contact Thomas Klausner <wiz@NetBSD.org> for support.
+#define GPR_PLATFORM_STRING "netbsd"
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+#define GPR_NETBSD 1
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_GCC_TLS 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#define GPR_SUPPORT_CHANNELS_FROM_FD 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#elif defined(__native_client__)
+#define GPR_PLATFORM_STRING "nacl"
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#define GPR_NACL 1
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#elif defined(__Fuchsia__)
+#define GRPC_ARES 0
+#define GPR_FUCHSIA 1
+#define GPR_ARCH_64 1
+#define GPR_PLATFORM_STRING "fuchsia"
+#include <features.h>
+// Specifying musl libc affects wrap_memcpy.c. It causes memmove() to be
+// invoked.
+#define GPR_MUSL_LIBC_COMPAT 1
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#define GRPC_ROOT_PEM_PATH "/config/ssl/cert.pem"
+#elif defined(__HAIKU__)
+#define GPR_PLATFORM_STRING "haiku"
+// Haiku is a community-supported platform.
+// Please contact Jerome Duval <jerome.duval@gmail.com> for support.
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+#define GPR_HAIKU 1
+#define GPR_CPU_POSIX 1
+#define GPR_GCC_ATOMIC 1
+#define GPR_POSIX_LOG 1
+#define GPR_POSIX_ENV 1
+#define GPR_POSIX_TMPFILE 1
+#define GPR_POSIX_STAT 1
+#define GPR_POSIX_STRING 1
+#define GPR_POSIX_SUBPROCESS 1
+#define GPR_POSIX_SYNC 1
+#define GPR_POSIX_TIME 1
+#define GPR_HAS_PTHREAD_H 1
+#define GPR_GETPID_IN_UNISTD_H 1
+#define GPR_SUPPORT_CHANNELS_FROM_FD 1
+#ifdef _LP64
+#define GPR_ARCH_64 1
+#else /* _LP64 */
+#define GPR_ARCH_32 1
+#endif /* _LP64 */
+#else
+#error "Could not auto-detect platform"
+#endif
+#endif /* GPR_NO_AUTODETECT_PLATFORM */
+
+#if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
+/*
+ * For backward compatibility mode, reset _FORTIFY_SOURCE to prevent
+ * a library from having non-standard symbols such as __asprintf_chk.
+ * This helps non-glibc systems such as alpine using musl to find symbols.
+ */
+#if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0
+#undef _FORTIFY_SOURCE
+#define _FORTIFY_SOURCE 0
+#endif
+#endif
+
+#if defined(__has_include)
+#if __has_include(<atomic>)
+#define GRPC_HAS_CXX11_ATOMIC
+#endif /* __has_include(<atomic>) */
+#endif /* defined(__has_include) */
+
+#ifndef GPR_PLATFORM_STRING
+#warning "GPR_PLATFORM_STRING not auto-detected"
+#define GPR_PLATFORM_STRING "unknown"
+#endif
+
+#ifdef GPR_GCOV
+#undef GPR_FORBID_UNREACHABLE_CODE
+#define GPR_FORBID_UNREACHABLE_CODE 1
+#endif
+
+#ifdef _MSC_VER
+#if _MSC_VER < 1700
+typedef __int8 int8_t;
+typedef __int16 int16_t;
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int16 uint16_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+#else
+#include <stdint.h>
+#endif /* _MSC_VER < 1700 */
+#else
+#include <stdint.h>
+#endif /* _MSC_VER */
+
+/* Type of cycle clock implementation */
+#ifdef GPR_LINUX
+/* Disable cycle clock by default.
+   TODO(soheil): enable when we support fallback for unstable cycle clocks.
+#if defined(__i386__)
+#define GPR_CYCLE_COUNTER_RDTSC_32 1
+#elif defined(__x86_64__) || defined(__amd64__)
+#define GPR_CYCLE_COUNTER_RDTSC_64 1
+#else
+#define GPR_CYCLE_COUNTER_FALLBACK 1
+#endif
+*/
+#define GPR_CYCLE_COUNTER_FALLBACK 1
+#else
+#define GPR_CYCLE_COUNTER_FALLBACK 1
+#endif /* GPR_LINUX */
+
+/* Cache line alignment */
+#ifndef GPR_CACHELINE_SIZE_LOG
+#if defined(__i386__) || defined(__x86_64__)
+#define GPR_CACHELINE_SIZE_LOG 6
+#endif
+#ifndef GPR_CACHELINE_SIZE_LOG
+/* A reasonable default guess. Note that overestimates tend to waste more
+   space, while underestimates tend to waste more time. */
+#define GPR_CACHELINE_SIZE_LOG 6
+#endif /* GPR_CACHELINE_SIZE_LOG */
+#endif /* GPR_CACHELINE_SIZE_LOG */
+
+#define GPR_CACHELINE_SIZE (1 << GPR_CACHELINE_SIZE_LOG)
+
+/* scrub GCC_ATOMIC if it's not available on this compiler */
+#if defined(GPR_GCC_ATOMIC) && !defined(__ATOMIC_RELAXED)
+#undef GPR_GCC_ATOMIC
+#define GPR_GCC_SYNC 1
+#endif
+
+/* Validate platform combinations */
+#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + \
+        defined(GPR_WINDOWS_ATOMIC) !=                \
+    1
+#error Must define exactly one of GPR_GCC_ATOMIC, GPR_GCC_SYNC, GPR_WINDOWS_ATOMIC
+#endif
+
+#if defined(GPR_ARCH_32) + defined(GPR_ARCH_64) != 1
+#error Must define exactly one of GPR_ARCH_32, GPR_ARCH_64
+#endif
+
+#if defined(GPR_CPU_LINUX) + defined(GPR_CPU_POSIX) + defined(GPR_WINDOWS) + \
+        defined(GPR_CPU_IPHONE) + defined(GPR_CPU_CUSTOM) !=                 \
+    1
+#error Must define exactly one of GPR_CPU_LINUX, GPR_CPU_POSIX, GPR_WINDOWS, GPR_CPU_IPHONE, GPR_CPU_CUSTOM
+#endif
+
+/* maximum alignment needed for any type on this platform, rounded up to a
+   power of two */
+#define GPR_MAX_ALIGNMENT 16
+
+#ifndef GRPC_ARES
+#define GRPC_ARES 1
+#endif
+
+#ifndef GRPC_IF_NAMETOINDEX
+#define GRPC_IF_NAMETOINDEX 1
+#endif
+
+#ifndef GRPC_MUST_USE_RESULT
+#if defined(__GNUC__) && !defined(__MINGW32__)
+#define GRPC_MUST_USE_RESULT __attribute__((warn_unused_result))
+#define GPR_ALIGN_STRUCT(n) __attribute__((aligned(n)))
+#else
+#define GRPC_MUST_USE_RESULT
+#define GPR_ALIGN_STRUCT(n)
+#endif
+#ifdef USE_STRICT_WARNING
+/* When building with USE_STRICT_WARNING (which -Werror), types with this
+   attribute will be treated as annotated with warn_unused_result, enforcing
+   returned values of this type should be used.
+   This is added in grpc::Status in mind to address the issue where it always
+   has this annotation internally but OSS doesn't, sometimes causing internal
+   build failure. To prevent this, this is added while not introducing
+   a breaking change to existing user code which may not use returned values
+   of grpc::Status. */
+#define GRPC_MUST_USE_RESULT_WHEN_USE_STRICT_WARNING GRPC_MUST_USE_RESULT
+#else
+#define GRPC_MUST_USE_RESULT_WHEN_USE_STRICT_WARNING
+#endif
+#endif
+
+#ifndef GRPC_UNUSED
+#if defined(__GNUC__) && !defined(__MINGW32__)
+#define GRPC_UNUSED __attribute__((unused))
+#else
+#define GRPC_UNUSED
+#endif
+#endif
+
+#ifndef GPR_PRINT_FORMAT_CHECK
+#ifdef __GNUC__
+#define GPR_PRINT_FORMAT_CHECK(FORMAT_STR, ARGS) \
+  __attribute__((format(printf, FORMAT_STR, ARGS)))
+#else
+#define GPR_PRINT_FORMAT_CHECK(FORMAT_STR, ARGS)
+#endif
+#endif /* GPR_PRINT_FORMAT_CHECK */
+
+#ifndef GPR_HAS_CPP_ATTRIBUTE
+#ifdef __has_cpp_attribute
+#define GPR_HAS_CPP_ATTRIBUTE(a) __has_cpp_attribute(a)
+#else
+#define GPR_HAS_CPP_ATTRIBUTE(a) 0
+#endif
+#endif /* GPR_HAS_CPP_ATTRIBUTE */
+
+#ifndef GPR_HAS_ATTRIBUTE
+#ifdef __has_attribute
+#define GPR_HAS_ATTRIBUTE(a) __has_attribute(a)
+#else
+#define GPR_HAS_ATTRIBUTE(a) 0
+#endif
+#endif /* GPR_HAS_ATTRIBUTE */
+
+#if GPR_HAS_ATTRIBUTE(noreturn)
+#define GPR_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#else
+#define GPR_ATTRIBUTE_NORETURN
+#endif
+
+#if GPR_FORBID_UNREACHABLE_CODE
+#define GPR_UNREACHABLE_CODE(STATEMENT)
+#else
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void gpr_unreachable_code(const char* reason, const char* file,
+                                 int line) GPR_ATTRIBUTE_NORETURN;
+#ifdef __cplusplus
+}
+#endif
+#define GPR_UNREACHABLE_CODE(STATEMENT)                   \
+  do {                                                    \
+    gpr_unreachable_code(#STATEMENT, __FILE__, __LINE__); \
+    STATEMENT;                                            \
+  } while (0)
+#endif /* GPR_FORBID_UNREACHABLE_CODE */
+
+#ifndef GPRAPI
+#define GPRAPI
+#endif
+
+#ifndef GRPCAPI
+#define GRPCAPI GPRAPI
+#endif
+
+#ifndef CENSUSAPI
+#define CENSUSAPI GRPCAPI
+#endif
+
+#ifndef GPR_HAS_FEATURE
+#ifdef __has_feature
+#define GPR_HAS_FEATURE(a) __has_feature(a)
+#else
+#define GPR_HAS_FEATURE(a) 0
+#endif
+#endif /* GPR_HAS_FEATURE */
+
+#ifndef GPR_ATTRIBUTE_NOINLINE
+#if GPR_HAS_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__))
+#define GPR_ATTRIBUTE_NOINLINE __attribute__((noinline))
+#define GPR_HAS_ATTRIBUTE_NOINLINE 1
+#else
+#define GPR_ATTRIBUTE_NOINLINE
+#endif
+#endif /* GPR_ATTRIBUTE_NOINLINE */
+
+#ifndef GPR_NO_UNIQUE_ADDRESS
+#if GPR_HAS_CPP_ATTRIBUTE(no_unique_address)
+#define GPR_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+#define GPR_NO_UNIQUE_ADDRESS
+#endif
+#endif /* GPR_NO_UNIQUE_ADDRESS */
+
+#ifndef GRPC_DEPRECATED
+#if GPR_HAS_CPP_ATTRIBUTE(deprecated)
+#define GRPC_DEPRECATED(reason) [[deprecated(reason)]]
+#else
+#define GRPC_DEPRECATED(reason)
+#endif
+#endif /* GRPC_DEPRECATED */
+
+#ifndef GPR_ATTRIBUTE_WEAK
+/* Attribute weak is broken on LLVM/windows:
+ * https://bugs.llvm.org/show_bug.cgi?id=37598 */
+#if (GPR_HAS_ATTRIBUTE(weak) || (defined(__GNUC__) && !defined(__clang__))) && \
+    !(defined(__llvm__) && defined(_WIN32))
+#define GPR_ATTRIBUTE_WEAK __attribute__((weak))
+#define GPR_HAS_ATTRIBUTE_WEAK 1
+#else
+#define GPR_ATTRIBUTE_WEAK
+#endif
+#endif /* GPR_ATTRIBUTE_WEAK */
+
+#ifndef GPR_ATTRIBUTE_NO_TSAN /* (1) */
+#if GPR_HAS_FEATURE(thread_sanitizer)
+#define GPR_ATTRIBUTE_NO_TSAN __attribute__((no_sanitize("thread")))
+#endif                        /* GPR_HAS_FEATURE */
+#ifndef GPR_ATTRIBUTE_NO_TSAN /* (2) */
+#define GPR_ATTRIBUTE_NO_TSAN
+#endif /* GPR_ATTRIBUTE_NO_TSAN (2) */
+#endif /* GPR_ATTRIBUTE_NO_TSAN (1) */
+
+/* GRPC_TSAN_ENABLED will be defined, when compiled with thread sanitizer. */
+#ifndef GRPC_TSAN_SUPPRESSED
+#if defined(__SANITIZE_THREAD__)
+#define GRPC_TSAN_ENABLED
+#elif GPR_HAS_FEATURE(thread_sanitizer)
+#define GRPC_TSAN_ENABLED
+#endif
+#endif
+
+/* GRPC_ASAN_ENABLED will be defined, when compiled with address sanitizer. */
+#ifndef GRPC_ASAN_SUPPRESSED
+#if defined(__SANITIZE_ADDRESS__)
+#define GRPC_ASAN_ENABLED
+#elif GPR_HAS_FEATURE(address_sanitizer)
+#define GRPC_ASAN_ENABLED
+#endif
+#endif
+
+/* GRPC_ALLOW_EXCEPTIONS should be 0 or 1 if exceptions are allowed or not */
+#ifndef GRPC_ALLOW_EXCEPTIONS
+#ifdef GPR_WINDOWS
+#if defined(_MSC_VER) && defined(_CPPUNWIND)
+#define GRPC_ALLOW_EXCEPTIONS 1
+#elif defined(__EXCEPTIONS)
+#define GRPC_ALLOW_EXCEPTIONS 1
+#else
+#define GRPC_ALLOW_EXCEPTIONS 0
+#endif
+#else /* GPR_WINDOWS */
+#ifdef __EXCEPTIONS
+#define GRPC_ALLOW_EXCEPTIONS 1
+#else /* __EXCEPTIONS */
+#define GRPC_ALLOW_EXCEPTIONS 0
+#endif /* __EXCEPTIONS */
+#endif /* __GPR_WINDOWS */
+#endif /* GRPC_ALLOW_EXCEPTIONS */
+
+/* Use GPR_LIKELY only in cases where you are sure that a certain outcome is the
+ * most likely. Ideally, also collect performance numbers to justify the claim.
+ */
+#ifdef __GNUC__
+#define GPR_LIKELY(x) __builtin_expect((x), 1)
+#define GPR_UNLIKELY(x) __builtin_expect((x), 0)
+#else /* __GNUC__ */
+#define GPR_LIKELY(x) (x)
+#define GPR_UNLIKELY(x) (x)
+#endif /* __GNUC__ */
+
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS
+#endif
+
+#define GRPC_CALLBACK_API_NONEXPERIMENTAL
+
+/* clang 11 with msan miscompiles destruction of [[no_unique_address]] members
+ * of zero size - for a repro see:
+ * test/core/compiler_bugs/miscompile_with_no_unique_address_test.cc
+ */
+#ifdef __clang__
+#if __clang__ && __clang_major__ <= 11 && __has_feature(memory_sanitizer)
+#undef GPR_NO_UNIQUE_ADDRESS
+#define GPR_NO_UNIQUE_ADDRESS
+#endif
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_PORT_PLATFORM_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/propagation_bits.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/propagation_bits.h
new file mode 100644
index 0000000..d702099
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/propagation_bits.h
@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_PROPAGATION_BITS_H
+#define GRPC_IMPL_CODEGEN_PROPAGATION_BITS_H
+
+// IWYU pragma: private
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Propagation bits: this can be bitwise or-ed to form propagation_mask for
+ * grpc_call */
+/** Propagate deadline */
+#define GRPC_PROPAGATE_DEADLINE ((uint32_t)1)
+/** Propagate census context */
+#define GRPC_PROPAGATE_CENSUS_STATS_CONTEXT ((uint32_t)2)
+#define GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT ((uint32_t)4)
+/** Propagate cancellation */
+#define GRPC_PROPAGATE_CANCELLATION ((uint32_t)8)
+
+/** Default propagation mask: clients of the core API are encouraged to encode
+   deltas from this in their implementations... ie write:
+   GRPC_PROPAGATE_DEFAULTS & ~GRPC_PROPAGATE_DEADLINE to disable deadline
+   propagation. Doing so gives flexibility in the future to define new
+   propagation types that are default inherited or not. */
+#define GRPC_PROPAGATE_DEFAULTS                                                \
+  ((uint32_t)((                                                                \
+      0xffff | GRPC_PROPAGATE_DEADLINE | GRPC_PROPAGATE_CENSUS_STATS_CONTEXT | \
+      GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT | GRPC_PROPAGATE_CANCELLATION)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_PROPAGATION_BITS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/slice.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/slice.h
new file mode 100644
index 0000000..33c1f1b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/slice.h
@@ -0,0 +1,132 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_SLICE_H
+#define GRPC_IMPL_CODEGEN_SLICE_H
+
+// IWYU pragma: private
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <stddef.h>
+
+#include <grpc/impl/codegen/gpr_slice.h>
+
+typedef struct grpc_slice grpc_slice;
+
+/** Slice API
+
+   A slice represents a contiguous reference counted array of bytes.
+   It is cheap to take references to a slice, and it is cheap to create a
+   slice pointing to a subset of another slice.
+
+   The data-structure for slices is exposed here to allow non-gpr code to
+   build slices from whatever data they have available.
+
+   When defining interfaces that handle slices, care should be taken to define
+   reference ownership semantics (who should call unref?) and mutability
+   constraints (is the callee allowed to modify the slice?) */
+
+/* Inlined half of grpc_slice is allowed to expand the size of the overall type
+   by this many bytes */
+#define GRPC_SLICE_INLINE_EXTRA_SIZE sizeof(void*)
+
+#define GRPC_SLICE_INLINED_SIZE \
+  (sizeof(size_t) + sizeof(uint8_t*) - 1 + GRPC_SLICE_INLINE_EXTRA_SIZE)
+
+struct grpc_slice_refcount;
+/** A grpc_slice s, if initialized, represents the byte range
+   s.bytes[0..s.length-1].
+
+   It can have an associated ref count which has a destruction routine to be run
+   when the ref count reaches zero (see grpc_slice_new() and grp_slice_unref()).
+   Multiple grpc_slice values may share a ref count.
+
+   If the slice does not have a refcount, it represents an inlined small piece
+   of data that is copied by value.
+
+   As a special case, a slice can be given refcount == uintptr_t(1), meaning
+   that the slice represents external data that is not refcounted. */
+struct grpc_slice {
+  struct grpc_slice_refcount* refcount;
+  union grpc_slice_data {
+    struct grpc_slice_refcounted {
+      size_t length;
+      uint8_t* bytes;
+    } refcounted;
+    struct grpc_slice_inlined {
+      uint8_t length;
+      uint8_t bytes[GRPC_SLICE_INLINED_SIZE];
+    } inlined;
+  } data;
+};
+
+#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 8
+
+/** Represents an expandable array of slices, to be interpreted as a
+   single item. */
+typedef struct grpc_slice_buffer {
+  /** This is for internal use only. External users (i.e any code outside grpc
+   * core) MUST NOT use this field */
+  grpc_slice* base_slices;
+
+  /** slices in the array (Points to the first valid grpc_slice in the array) */
+  grpc_slice* slices;
+  /** the number of slices in the array */
+  size_t count;
+  /** the number of slices allocated in the array. External users (i.e any code
+   * outside grpc core) MUST NOT use this field */
+  size_t capacity;
+  /** the combined length of all slices in the array */
+  size_t length;
+  /** inlined elements to avoid allocations */
+  grpc_slice inlined[GRPC_SLICE_BUFFER_INLINE_ELEMENTS];
+} grpc_slice_buffer;
+
+#define GRPC_SLICE_START_PTR(slice)                 \
+  ((slice).refcount ? (slice).data.refcounted.bytes \
+                    : (slice).data.inlined.bytes)
+#define GRPC_SLICE_LENGTH(slice)                     \
+  ((slice).refcount ? (slice).data.refcounted.length \
+                    : (slice).data.inlined.length)
+#define GRPC_SLICE_SET_LENGTH(slice, newlen)                              \
+  ((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) \
+                    : ((slice).data.inlined.length = (uint8_t)(newlen)))
+#define GRPC_SLICE_END_PTR(slice) \
+  GRPC_SLICE_START_PTR(slice) + GRPC_SLICE_LENGTH(slice)
+#define GRPC_SLICE_IS_EMPTY(slice) (GRPC_SLICE_LENGTH(slice) == 0)
+
+#ifdef GRPC_ALLOW_GPR_SLICE_FUNCTIONS
+
+/* Duplicate GPR_* definitions */
+#define GPR_SLICE_START_PTR(slice)                  \
+  ((slice).refcount ? (slice).data.refcounted.bytes \
+                    : (slice).data.inlined.bytes)
+#define GPR_SLICE_LENGTH(slice)                      \
+  ((slice).refcount ? (slice).data.refcounted.length \
+                    : (slice).data.inlined.length)
+#define GPR_SLICE_SET_LENGTH(slice, newlen)                               \
+  ((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) \
+                    : ((slice).data.inlined.length = (uint8_t)(newlen)))
+#define GPR_SLICE_END_PTR(slice) \
+  GRPC_SLICE_START_PTR(slice) + GRPC_SLICE_LENGTH(slice)
+#define GPR_SLICE_IS_EMPTY(slice) (GRPC_SLICE_LENGTH(slice) == 0)
+
+#endif /* GRPC_ALLOW_GPR_SLICE_FUNCTIONS */
+
+#endif /* GRPC_IMPL_CODEGEN_SLICE_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/status.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/status.h
new file mode 100644
index 0000000..2b18f6d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/status.h
@@ -0,0 +1,156 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_STATUS_H
+#define GRPC_IMPL_CODEGEN_STATUS_H
+
+// IWYU pragma: private, include <grpc/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  /** Not an error; returned on success */
+  GRPC_STATUS_OK = 0,
+
+  /** The operation was cancelled (typically by the caller). */
+  GRPC_STATUS_CANCELLED = 1,
+
+  /** Unknown error.  An example of where this error may be returned is
+     if a Status value received from another address space belongs to
+     an error-space that is not known in this address space.  Also
+     errors raised by APIs that do not return enough error information
+     may be converted to this error. */
+  GRPC_STATUS_UNKNOWN = 2,
+
+  /** Client specified an invalid argument.  Note that this differs
+     from FAILED_PRECONDITION.  INVALID_ARGUMENT indicates arguments
+     that are problematic regardless of the state of the system
+     (e.g., a malformed file name). */
+  GRPC_STATUS_INVALID_ARGUMENT = 3,
+
+  /** Deadline expired before operation could complete.  For operations
+     that change the state of the system, this error may be returned
+     even if the operation has completed successfully.  For example, a
+     successful response from a server could have been delayed long
+     enough for the deadline to expire. */
+  GRPC_STATUS_DEADLINE_EXCEEDED = 4,
+
+  /** Some requested entity (e.g., file or directory) was not found. */
+  GRPC_STATUS_NOT_FOUND = 5,
+
+  /** Some entity that we attempted to create (e.g., file or directory)
+     already exists. */
+  GRPC_STATUS_ALREADY_EXISTS = 6,
+
+  /** The caller does not have permission to execute the specified
+     operation.  PERMISSION_DENIED must not be used for rejections
+     caused by exhausting some resource (use RESOURCE_EXHAUSTED
+     instead for those errors).  PERMISSION_DENIED must not be
+     used if the caller can not be identified (use UNAUTHENTICATED
+     instead for those errors). */
+  GRPC_STATUS_PERMISSION_DENIED = 7,
+
+  /** The request does not have valid authentication credentials for the
+     operation. */
+  GRPC_STATUS_UNAUTHENTICATED = 16,
+
+  /** Some resource has been exhausted, perhaps a per-user quota, or
+     perhaps the entire file system is out of space. */
+  GRPC_STATUS_RESOURCE_EXHAUSTED = 8,
+
+  /** Operation was rejected because the system is not in a state
+     required for the operation's execution.  For example, directory
+     to be deleted may be non-empty, an rmdir operation is applied to
+     a non-directory, etc.
+
+     A litmus test that may help a service implementor in deciding
+     between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
+      (a) Use UNAVAILABLE if the client can retry just the failing call.
+      (b) Use ABORTED if the client should retry at a higher-level
+          (e.g., restarting a read-modify-write sequence).
+      (c) Use FAILED_PRECONDITION if the client should not retry until
+          the system state has been explicitly fixed.  E.g., if an "rmdir"
+          fails because the directory is non-empty, FAILED_PRECONDITION
+          should be returned since the client should not retry unless
+          they have first fixed up the directory by deleting files from it.
+      (d) Use FAILED_PRECONDITION if the client performs conditional
+          REST Get/Update/Delete on a resource and the resource on the
+          server does not match the condition. E.g., conflicting
+          read-modify-write on the same resource. */
+  GRPC_STATUS_FAILED_PRECONDITION = 9,
+
+  /** The operation was aborted, typically due to a concurrency issue
+     like sequencer check failures, transaction aborts, etc.
+
+     See litmus test above for deciding between FAILED_PRECONDITION,
+     ABORTED, and UNAVAILABLE. */
+  GRPC_STATUS_ABORTED = 10,
+
+  /** Operation was attempted past the valid range.  E.g., seeking or
+     reading past end of file.
+
+     Unlike INVALID_ARGUMENT, this error indicates a problem that may
+     be fixed if the system state changes. For example, a 32-bit file
+     system will generate INVALID_ARGUMENT if asked to read at an
+     offset that is not in the range [0,2^32-1], but it will generate
+     OUT_OF_RANGE if asked to read from an offset past the current
+     file size.
+
+     There is a fair bit of overlap between FAILED_PRECONDITION and
+     OUT_OF_RANGE.  We recommend using OUT_OF_RANGE (the more specific
+     error) when it applies so that callers who are iterating through
+     a space can easily look for an OUT_OF_RANGE error to detect when
+     they are done. */
+  GRPC_STATUS_OUT_OF_RANGE = 11,
+
+  /** Operation is not implemented or not supported/enabled in this service. */
+  GRPC_STATUS_UNIMPLEMENTED = 12,
+
+  /** Internal errors.  Means some invariants expected by underlying
+     system has been broken.  If you see one of these errors,
+     something is very broken. */
+  GRPC_STATUS_INTERNAL = 13,
+
+  /** The service is currently unavailable.  This is a most likely a
+     transient condition and may be corrected by retrying with
+     a backoff. Note that it is not always safe to retry non-idempotent
+     operations.
+
+     WARNING: Although data MIGHT not have been transmitted when this
+     status occurs, there is NOT A GUARANTEE that the server has not seen
+     anything. So in general it is unsafe to retry on this status code
+     if the call is non-idempotent.
+
+     See litmus test above for deciding between FAILED_PRECONDITION,
+     ABORTED, and UNAVAILABLE. */
+  GRPC_STATUS_UNAVAILABLE = 14,
+
+  /** Unrecoverable data loss or corruption. */
+  GRPC_STATUS_DATA_LOSS = 15,
+
+  /** Force users to include a default branch: */
+  GRPC_STATUS__DO_NOT_USE = -1
+} grpc_status_code;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_STATUS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync.h
new file mode 100644
index 0000000..1b30ea7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync.h
@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_SYNC_H
+#define GRPC_IMPL_CODEGEN_SYNC_H
+
+// IWYU pragma: private, include <grpc/support/sync.h>
+
+/** Synchronization primitives for GPR.
+
+   The type  gpr_mu              provides a non-reentrant mutex (lock).
+
+   The type  gpr_cv              provides a condition variable.
+
+   The type  gpr_once            provides for one-time initialization.
+
+   The type gpr_event            provides one-time-setting, reading, and
+                                 waiting of a void*, with memory barriers.
+
+   The type gpr_refcount         provides an object reference counter,
+                                 with memory barriers suitable to control
+                                 object lifetimes.
+
+   The type gpr_stats_counter    provides an atomic statistics counter. It
+                                 provides no memory barriers.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Platform-specific type declarations of gpr_mu and gpr_cv.   */
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpc/impl/codegen/sync_generic.h>  // IWYU pragma: export
+
+#if defined(GPR_CUSTOM_SYNC)
+#include <grpc/impl/codegen/sync_custom.h>  // IWYU pragma: export
+#elif defined(GPR_ABSEIL_SYNC)
+#include <grpc/impl/codegen/sync_abseil.h>  // IWYU pragma: export
+#elif defined(GPR_POSIX_SYNC)
+#include <grpc/impl/codegen/sync_posix.h>  // IWYU pragma: export
+#elif defined(GPR_WINDOWS)
+#include <grpc/impl/codegen/sync_windows.h>  // IWYU pragma: export
+#else
+#error Unable to determine platform for sync
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_SYNC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_abseil.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_abseil.h
new file mode 100644
index 0000000..92b3169
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_abseil.h
@@ -0,0 +1,38 @@
+/*
+ *
+ * Copyright 2020 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_SYNC_ABSEIL_H
+#define GRPC_IMPL_CODEGEN_SYNC_ABSEIL_H
+
+// IWYU pragma: private, include <grpc/support/sync.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpc/impl/codegen/sync_generic.h>
+
+#ifdef GPR_ABSEIL_SYNC
+
+typedef intptr_t gpr_mu;
+typedef intptr_t gpr_cv;
+typedef int32_t gpr_once;
+
+#define GPR_ONCE_INIT 0
+
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_SYNC_ABSEIL_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_custom.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_custom.h
new file mode 100644
index 0000000..ec0d672
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_custom.h
@@ -0,0 +1,40 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_SYNC_CUSTOM_H
+#define GRPC_IMPL_CODEGEN_SYNC_CUSTOM_H
+
+// IWYU pragma: private, include <grpc/support/sync.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpc/impl/codegen/sync_generic.h>
+
+/* Users defining GPR_CUSTOM_SYNC need to define the following macros. */
+
+#ifdef GPR_CUSTOM_SYNC
+
+typedef GPR_CUSTOM_MU_TYPE gpr_mu;
+typedef GPR_CUSTOM_CV_TYPE gpr_cv;
+typedef GPR_CUSTOM_ONCE_TYPE gpr_once;
+
+#define GPR_ONCE_INIT GPR_CUSTOM_ONCE_INIT
+
+#endif
+
+#endif /* GRPC_IMPL_CODEGEN_SYNC_CUSTOM_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_generic.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_generic.h
new file mode 100644
index 0000000..a79b9c6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_generic.h
@@ -0,0 +1,51 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_SYNC_GENERIC_H
+#define GRPC_IMPL_CODEGEN_SYNC_GENERIC_H
+
+// IWYU pragma: private, include <grpc/support/sync.h>
+
+/* Generic type definitions for gpr_sync. */
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpc/impl/codegen/atm.h>
+
+/* gpr_event */
+typedef struct {
+  gpr_atm state;
+} gpr_event;
+
+#define GPR_EVENT_INIT \
+  { 0 }
+
+/* gpr_refcount */
+typedef struct {
+  gpr_atm count;
+} gpr_refcount;
+
+/* gpr_stats_counter */
+typedef struct {
+  gpr_atm value;
+} gpr_stats_counter;
+
+#define GPR_STATS_INIT \
+  { 0 }
+
+#endif /* GRPC_IMPL_CODEGEN_SYNC_GENERIC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_posix.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_posix.h
new file mode 100644
index 0000000..f5cf482
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_posix.h
@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_SYNC_POSIX_H
+#define GRPC_IMPL_CODEGEN_SYNC_POSIX_H
+
+// IWYU pragma: private, include <grpc/support/sync.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <pthread.h>
+
+#include <grpc/impl/codegen/sync_generic.h>
+
+#ifdef GRPC_ASAN_ENABLED
+/* The member |leak_checker| is used to check whether there is a memory leak
+ * caused by upper layer logic that's missing the |gpr_xx_destroy| call
+ * to the object before freeing it.
+ * This issue was reported at https://github.com/grpc/grpc/issues/17563
+ * and discussed at https://github.com/grpc/grpc/pull/17586
+ */
+typedef struct {
+  pthread_mutex_t mutex;
+  int* leak_checker;
+} gpr_mu;
+
+typedef struct {
+  pthread_cond_t cond_var;
+  int* leak_checker;
+} gpr_cv;
+#else
+typedef pthread_mutex_t gpr_mu;
+typedef pthread_cond_t gpr_cv;
+#endif
+typedef pthread_once_t gpr_once;
+
+#define GPR_ONCE_INIT PTHREAD_ONCE_INIT
+
+#endif /* GRPC_IMPL_CODEGEN_SYNC_POSIX_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_windows.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_windows.h
new file mode 100644
index 0000000..2bee03b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_windows.h
@@ -0,0 +1,42 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_IMPL_CODEGEN_SYNC_WINDOWS_H
+#define GRPC_IMPL_CODEGEN_SYNC_WINDOWS_H
+
+// IWYU pragma: private, include <grpc/support/sync.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <grpc/impl/codegen/sync_generic.h>
+
+typedef struct {
+  CRITICAL_SECTION cs; /* Not an SRWLock until Vista is unsupported */
+  int locked;
+} gpr_mu;
+
+typedef CONDITION_VARIABLE gpr_cv;
+
+typedef INIT_ONCE gpr_once;
+#define GPR_ONCE_INIT INIT_ONCE_STATIC_INIT
+
+#endif /* GPR_WINDOWS */
+
+#endif /* GRPC_IMPL_CODEGEN_SYNC_WINDOWS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/load_reporting.h b/CAPI/cpp/grpc/include/grpc/load_reporting.h
new file mode 100644
index 0000000..55f50ea
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/load_reporting.h
@@ -0,0 +1,48 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_LOAD_REPORTING_H
+#define GRPC_LOAD_REPORTING_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Metadata key for the gRPC LB load balancer token.
+ *
+ * The value corresponding to this key is an opaque token that is given to the
+ * frontend as part of each pick; the frontend sends this token to the backend
+ * in each request it sends when using that pick. The token is used by the
+ * backend to verify the request and to allow the backend to report load to the
+ * gRPC LB system. */
+#define GRPC_LB_TOKEN_MD_KEY "lb-token"
+
+/** Metadata key for gRPC LB cost reporting.
+ *
+ * The value corresponding to this key is an opaque binary blob reported by the
+ * backend as part of its trailing metadata containing cost information for the
+ * call. */
+#define GRPC_LB_COST_MD_KEY "lb-cost-bin"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_LOAD_REPORTING_H */
diff --git a/CAPI/cpp/grpc/include/grpc/slice.h b/CAPI/cpp/grpc/include/grpc/slice.h
new file mode 100644
index 0000000..15978fe
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/slice.h
@@ -0,0 +1,161 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SLICE_H
+#define GRPC_SLICE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/slice.h>  // IWYU pragma: export
+#include <grpc/support/sync.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Increment the refcount of s. Requires slice is initialized.
+   Returns s. */
+GPRAPI grpc_slice grpc_slice_ref(grpc_slice s);
+
+/** Decrement the ref count of s.  If the ref count of s reaches zero, all
+   slices sharing the ref count are destroyed, and considered no longer
+   initialized.  If s is ultimately derived from a call to grpc_slice_new(start,
+   len, dest) where dest!=NULL , then (*dest)(start) is called, else if s is
+   ultimately derived from a call to grpc_slice_new_with_len(start, len, dest)
+   where dest!=NULL , then (*dest)(start, len).  Requires s initialized.  */
+GPRAPI void grpc_slice_unref(grpc_slice s);
+
+/** Copy slice - create a new slice that contains the same data as s */
+GPRAPI grpc_slice grpc_slice_copy(grpc_slice s);
+
+/** Create a slice pointing at some data. Calls malloc to allocate a refcount
+   for the object, and arranges that destroy will be called with the pointer
+   passed in at destruction. */
+GPRAPI grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*));
+
+/** Equivalent to grpc_slice_new, but with a separate pointer that is
+   passed to the destroy function.  This function can be useful when
+   the data is part of a larger structure that must be destroyed when
+   the data is no longer needed. */
+GPRAPI grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
+                                                void (*destroy)(void*),
+                                                void* user_data);
+
+/** Equivalent to grpc_slice_new, but with a two argument destroy function that
+   also takes the slice length. */
+GPRAPI grpc_slice grpc_slice_new_with_len(void* p, size_t len,
+                                          void (*destroy)(void*, size_t));
+
+/** Equivalent to grpc_slice_new(malloc(len), len, free), but saves one malloc()
+   call.
+   Aborts if malloc() fails. */
+GPRAPI grpc_slice grpc_slice_malloc(size_t length);
+GPRAPI grpc_slice grpc_slice_malloc_large(size_t length);
+
+#define GRPC_SLICE_MALLOC(len) grpc_slice_malloc(len)
+
+/** Create a slice by copying a string.
+   Does not preserve null terminators.
+   Equivalent to:
+     size_t len = strlen(source);
+     grpc_slice slice = grpc_slice_malloc(len);
+     memcpy(slice->data, source, len); */
+GPRAPI grpc_slice grpc_slice_from_copied_string(const char* source);
+
+/** Create a slice by copying a buffer.
+   Equivalent to:
+     grpc_slice slice = grpc_slice_malloc(len);
+     memcpy(slice->data, source, len); */
+GPRAPI grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t len);
+
+/** Create a slice pointing to constant memory */
+GPRAPI grpc_slice grpc_slice_from_static_string(const char* source);
+
+/** Create a slice pointing to constant memory */
+GPRAPI grpc_slice grpc_slice_from_static_buffer(const void* source, size_t len);
+
+/** Return a result slice derived from s, which shares a ref count with \a s,
+   where result.data==s.data+begin, and result.length==end-begin. The ref count
+   of \a s is increased by one. Do not assign result back to \a s.
+   Requires s initialized, begin <= end, begin <= s.length, and
+   end <= source->length. */
+GPRAPI grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end);
+
+/** The same as grpc_slice_sub, but without altering the ref count */
+GPRAPI grpc_slice grpc_slice_sub_no_ref(grpc_slice s, size_t begin, size_t end);
+
+/** Splits s into two: modifies s to be s[0:split], and returns a new slice,
+   sharing a refcount with s, that contains s[split:s.length].
+   Requires s initialized, split <= s.length */
+GPRAPI grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split);
+
+typedef enum {
+  GRPC_SLICE_REF_TAIL = 1,
+  GRPC_SLICE_REF_HEAD = 2,
+  GRPC_SLICE_REF_BOTH = 1 + 2
+} grpc_slice_ref_whom;
+
+/** The same as grpc_slice_split_tail, but with an option to skip altering
+ * refcounts (grpc_slice_split_tail_maybe_ref(..., true) is equivalent to
+ * grpc_slice_split_tail(...)) */
+GPRAPI grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* s, size_t split,
+                                                  grpc_slice_ref_whom ref_whom);
+
+/** Splits s into two: modifies s to be s[split:s.length], and returns a new
+   slice, sharing a refcount with s, that contains s[0:split].
+   Requires s initialized, split <= s.length */
+GPRAPI grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split);
+
+GPRAPI grpc_slice grpc_empty_slice(void);
+
+GPRAPI int grpc_slice_eq(grpc_slice a, grpc_slice b);
+
+/** Returns <0 if a < b, ==0 if a == b, >0 if a > b
+   The order is arbitrary, and is not guaranteed to be stable across different
+   versions of the API. */
+GPRAPI int grpc_slice_cmp(grpc_slice a, grpc_slice b);
+GPRAPI int grpc_slice_str_cmp(grpc_slice a, const char* b);
+
+/** return non-zero if the first blen bytes of a are equal to b */
+GPRAPI int grpc_slice_buf_start_eq(grpc_slice a, const void* b, size_t blen);
+
+/** return the index of the last instance of \a c in \a s, or -1 if not found */
+GPRAPI int grpc_slice_rchr(grpc_slice s, char c);
+GPRAPI int grpc_slice_chr(grpc_slice s, char c);
+
+/** return the index of the first occurrence of \a needle in \a haystack, or -1
+   if it's not found */
+GPRAPI int grpc_slice_slice(grpc_slice haystack, grpc_slice needle);
+
+/** Do two slices point at the same memory, with the same length
+   If a or b is inlined, actually compares data */
+GPRAPI int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b);
+
+/** Return a slice pointing to newly allocated memory that has the same contents
+ * as \a s */
+GPRAPI grpc_slice grpc_slice_dup(grpc_slice a);
+
+/** Return a copy of slice as a C string. Offers no protection against embedded
+   NULL's. Returned string must be freed with gpr_free. */
+GPRAPI char* grpc_slice_to_c_string(grpc_slice s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_SLICE_H */
diff --git a/CAPI/cpp/grpc/include/grpc/slice_buffer.h b/CAPI/cpp/grpc/include/grpc/slice_buffer.h
new file mode 100644
index 0000000..d8c6b91
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/slice_buffer.h
@@ -0,0 +1,84 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SLICE_BUFFER_H
+#define GRPC_SLICE_BUFFER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/slice.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** initialize a slice buffer */
+GPRAPI void grpc_slice_buffer_init(grpc_slice_buffer* sb);
+/** destroy a slice buffer - unrefs any held elements */
+GPRAPI void grpc_slice_buffer_destroy(grpc_slice_buffer* sb);
+/** Add an element to a slice buffer - takes ownership of the slice.
+   This function is allowed to concatenate the passed in slice to the end of
+   some other slice if desired by the slice buffer. */
+GPRAPI void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice);
+/** add an element to a slice buffer - takes ownership of the slice and returns
+   the index of the slice.
+   Guarantees that the slice will not be concatenated at the end of another
+   slice (i.e. the data for this slice will begin at the first byte of the
+   slice at the returned index in sb->slices)
+   The implementation MAY decide to concatenate data at the end of a small
+   slice added in this fashion. */
+GPRAPI size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb,
+                                            grpc_slice slice);
+GPRAPI void grpc_slice_buffer_addn(grpc_slice_buffer* sb, grpc_slice* slices,
+                                   size_t n);
+/** add a very small (less than 8 bytes) amount of data to the end of a slice
+   buffer: returns a pointer into which to add the data */
+GPRAPI uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t len);
+/** pop the last buffer, but don't unref it */
+GPRAPI void grpc_slice_buffer_pop(grpc_slice_buffer* sb);
+/** clear a slice buffer, unref all elements */
+GPRAPI void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb);
+/** swap the contents of two slice buffers */
+GPRAPI void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b);
+/** move all of the elements of src into dst */
+GPRAPI void grpc_slice_buffer_move_into(grpc_slice_buffer* src,
+                                        grpc_slice_buffer* dst);
+/** remove n bytes from the end of a slice buffer */
+GPRAPI void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
+                                       grpc_slice_buffer* garbage);
+/** move the first n bytes of src into dst */
+GPRAPI void grpc_slice_buffer_move_first(grpc_slice_buffer* src, size_t n,
+                                         grpc_slice_buffer* dst);
+/** move the first n bytes of src into dst without adding references */
+GPRAPI void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src,
+                                                size_t n,
+                                                grpc_slice_buffer* dst);
+/** move the first n bytes of src into dst (copying them) */
+GPRAPI void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src,
+                                                     size_t n, void* dst);
+/** take the first slice in the slice buffer */
+GPRAPI grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb);
+/** undo the above with (a possibly different) \a slice */
+GPRAPI void grpc_slice_buffer_undo_take_first(grpc_slice_buffer* sb,
+                                              grpc_slice slice);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_SLICE_BUFFER_H */
diff --git a/CAPI/cpp/grpc/include/grpc/status.h b/CAPI/cpp/grpc/include/grpc/status.h
new file mode 100644
index 0000000..6763264
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/status.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_STATUS_H
+#define GRPC_STATUS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/status.h>  // IWYU pragma: export
+
+#endif /* GRPC_STATUS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/alloc.h b/CAPI/cpp/grpc/include/grpc/support/alloc.h
new file mode 100644
index 0000000..d440e4b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/alloc.h
@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_ALLOC_H
+#define GRPC_SUPPORT_ALLOC_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** malloc.
+ * If size==0, always returns NULL. Otherwise this function never returns NULL.
+ * The pointer returned is suitably aligned for any kind of variable it could
+ * contain.
+ */
+GPRAPI void* gpr_malloc(size_t size);
+/** like malloc, but zero all bytes before returning them */
+GPRAPI void* gpr_zalloc(size_t size);
+/** free */
+GPRAPI void gpr_free(void* ptr);
+/** realloc, never returns NULL */
+GPRAPI void* gpr_realloc(void* p, size_t size);
+/** aligned malloc, never returns NULL, will align to alignment, which
+ * must be a power of 2. */
+GPRAPI void* gpr_malloc_aligned(size_t size, size_t alignment);
+/** free memory allocated by gpr_malloc_aligned */
+GPRAPI void gpr_free_aligned(void* ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_SUPPORT_ALLOC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/atm.h b/CAPI/cpp/grpc/include/grpc/support/atm.h
new file mode 100644
index 0000000..fbfcee3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/atm.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_ATM_H
+#define GRPC_SUPPORT_ATM_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/atm.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_ATM_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/atm_gcc_atomic.h b/CAPI/cpp/grpc/include/grpc/support/atm_gcc_atomic.h
new file mode 100644
index 0000000..8226349
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/atm_gcc_atomic.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_ATM_GCC_ATOMIC_H
+#define GRPC_SUPPORT_ATM_GCC_ATOMIC_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/atm_gcc_atomic.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_ATM_GCC_ATOMIC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/atm_gcc_sync.h b/CAPI/cpp/grpc/include/grpc/support/atm_gcc_sync.h
new file mode 100644
index 0000000..500a9f1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/atm_gcc_sync.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_ATM_GCC_SYNC_H
+#define GRPC_SUPPORT_ATM_GCC_SYNC_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/atm_gcc_sync.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_ATM_GCC_SYNC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/atm_windows.h b/CAPI/cpp/grpc/include/grpc/support/atm_windows.h
new file mode 100644
index 0000000..b85d7f7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/atm_windows.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_ATM_WINDOWS_H
+#define GRPC_SUPPORT_ATM_WINDOWS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/atm_windows.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_ATM_WINDOWS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/cpu.h b/CAPI/cpp/grpc/include/grpc/support/cpu.h
new file mode 100644
index 0000000..f0e898e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/cpu.h
@@ -0,0 +1,44 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_CPU_H
+#define GRPC_SUPPORT_CPU_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Interface providing CPU information for currently running system */
+
+/** Return the number of CPU cores on the current system. Will return 0 if
+   the information is not available. */
+GPRAPI unsigned gpr_cpu_num_cores(void);
+
+/** Return the CPU on which the current thread is executing; N.B. This should
+   be considered advisory only - it is possible that the thread is switched
+   to a different CPU at any time. Returns a value in range
+   [0, gpr_cpu_num_cores() - 1] */
+GPRAPI unsigned gpr_cpu_current_cpu(void);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif /* GRPC_SUPPORT_CPU_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/log.h b/CAPI/cpp/grpc/include/grpc/support/log.h
new file mode 100644
index 0000000..7af557d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/log.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_LOG_H
+#define GRPC_SUPPORT_LOG_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/log.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_LOG_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/log_windows.h b/CAPI/cpp/grpc/include/grpc/support/log_windows.h
new file mode 100644
index 0000000..e833f9d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/log_windows.h
@@ -0,0 +1,38 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_LOG_WINDOWS_H
+#define GRPC_SUPPORT_LOG_WINDOWS_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Returns a string allocated with gpr_malloc that contains a UTF-8
+ * formatted error message, corresponding to the error messageid.
+ * Use in conjunction with GetLastError() et al.
+ */
+GPRAPI char* gpr_format_message(int messageid);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_SUPPORT_LOG_WINDOWS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/port_platform.h b/CAPI/cpp/grpc/include/grpc/support/port_platform.h
new file mode 100644
index 0000000..fced02a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/port_platform.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_PORT_PLATFORM_H
+#define GRPC_SUPPORT_PORT_PLATFORM_H
+
+#include <grpc/impl/codegen/port_platform.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_PORT_PLATFORM_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/string_util.h b/CAPI/cpp/grpc/include/grpc/support/string_util.h
new file mode 100644
index 0000000..2679160
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/string_util.h
@@ -0,0 +1,51 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_STRING_UTIL_H
+#define GRPC_SUPPORT_STRING_UTIL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/gpr_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** String utility functions */
+
+/** Returns a copy of src that can be passed to gpr_free().
+   If allocation fails or if src is NULL, returns NULL. */
+GPRAPI char* gpr_strdup(const char* src);
+
+/** printf to a newly-allocated string.  The set of supported formats may vary
+   between platforms.
+
+   On success, returns the number of bytes printed (excluding the final '\0'),
+   and *strp points to a string which must later be destroyed with gpr_free().
+
+   On error, returns -1 and sets *strp to NULL. If the format string is bad,
+   the result is undefined. */
+GPRAPI int gpr_asprintf(char** strp, const char* format, ...)
+    GPR_PRINT_FORMAT_CHECK(2, 3);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_SUPPORT_STRING_UTIL_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/sync.h b/CAPI/cpp/grpc/include/grpc/support/sync.h
new file mode 100644
index 0000000..b1f5b78
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/sync.h
@@ -0,0 +1,282 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_SYNC_H
+#define GRPC_SUPPORT_SYNC_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/gpr_types.h> /* for gpr_timespec */
+#include <grpc/impl/codegen/sync.h>      // IWYU pragma: export
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** --- Mutex interface ---
+
+   At most one thread may hold an exclusive lock on a mutex at any given time.
+   Actions taken by a thread that holds a mutex exclusively happen after
+   actions taken by all previous holders of the mutex.  Variables of type
+   gpr_mu are uninitialized when first declared.  */
+
+/** Initialize *mu.  Requires:  *mu uninitialized.  */
+GPRAPI void gpr_mu_init(gpr_mu* mu);
+
+/** Cause *mu no longer to be initialized, freeing any memory in use.  Requires:
+ *mu initialized; no other concurrent operation on *mu.  */
+GPRAPI void gpr_mu_destroy(gpr_mu* mu);
+
+/** Wait until no thread has a lock on *mu, cause the calling thread to own an
+   exclusive lock on *mu, then return.  May block indefinitely or crash if the
+   calling thread has a lock on *mu.  Requires:  *mu initialized.  */
+GPRAPI void gpr_mu_lock(gpr_mu* mu);
+
+/** Release an exclusive lock on *mu held by the calling thread.  Requires:  *mu
+   initialized; the calling thread holds an exclusive lock on *mu.  */
+GPRAPI void gpr_mu_unlock(gpr_mu* mu);
+
+/** Without blocking, attempt to acquire an exclusive lock on *mu for the
+   calling thread, then return non-zero iff success.  Fail, if any thread holds
+   the lock; succeeds with high probability if no thread holds the lock.
+   Requires:  *mu initialized.  */
+GPRAPI int gpr_mu_trylock(gpr_mu* mu);
+
+/** --- Condition variable interface ---
+
+   A while-loop should be used with gpr_cv_wait() when waiting for conditions
+   to become true.  See the example below.  Variables of type gpr_cv are
+   uninitialized when first declared.  */
+
+/** Initialize *cv.  Requires:  *cv uninitialized.  */
+GPRAPI void gpr_cv_init(gpr_cv* cv);
+
+/** Cause *cv no longer to be initialized, freeing any memory in use.  Requires:
+ *cv initialized; no other concurrent operation on *cv.*/
+GPRAPI void gpr_cv_destroy(gpr_cv* cv);
+
+/** Atomically release *mu and wait on *cv.  When the calling thread is woken
+   from *cv or the deadline abs_deadline is exceeded, execute gpr_mu_lock(mu)
+   and return whether the deadline was exceeded.  Use
+   abs_deadline==gpr_inf_future for no deadline.  abs_deadline can be either
+   an absolute deadline, or a GPR_TIMESPAN.  May return even when not
+   woken explicitly.  Requires:  *mu and *cv initialized; the calling thread
+   holds an exclusive lock on *mu.  */
+GPRAPI int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline);
+
+/** If any threads are waiting on *cv, wake at least one.
+   Clients may treat this as an optimization of gpr_cv_broadcast()
+   for use in the case where waking more than one waiter is not useful.
+   Requires:  *cv initialized.  */
+GPRAPI void gpr_cv_signal(gpr_cv* cv);
+
+/** Wake all threads waiting on *cv.  Requires:  *cv initialized.  */
+GPRAPI void gpr_cv_broadcast(gpr_cv* cv);
+
+/** --- One-time initialization ---
+
+   gpr_once must be declared with static storage class, and initialized with
+   GPR_ONCE_INIT.  e.g.,
+     static gpr_once once_var = GPR_ONCE_INIT;     */
+
+/** Ensure that (*init_function)() has been called exactly once (for the
+   specified gpr_once instance) and then return.
+   If multiple threads call gpr_once() on the same gpr_once instance, one of
+   them will call (*init_function)(), and the others will block until that call
+   finishes.*/
+GPRAPI void gpr_once_init(gpr_once* once, void (*init_function)(void));
+
+/** --- One-time event notification ---
+
+  These operations act on a gpr_event, which should be initialized with
+  gpr_ev_init(), or with GPR_EVENT_INIT if static, e.g.,
+       static gpr_event event_var = GPR_EVENT_INIT;
+  It requires no destruction.  */
+
+/** Initialize *ev. */
+GPRAPI void gpr_event_init(gpr_event* ev);
+
+/** Set *ev so that gpr_event_get() and gpr_event_wait() will return value.
+   Requires:  *ev initialized; value != NULL; no prior or concurrent calls to
+   gpr_event_set(ev, ...) since initialization.  */
+GPRAPI void gpr_event_set(gpr_event* ev, void* value);
+
+/** Return the value set by gpr_event_set(ev, ...), or NULL if no such call has
+   completed.  If the result is non-NULL, all operations that occurred prior to
+   the gpr_event_set(ev, ...) set will be visible after this call returns.
+   Requires:  *ev initialized.  This operation is faster than acquiring a mutex
+   on most platforms.  */
+GPRAPI void* gpr_event_get(gpr_event* ev);
+
+/** Wait until *ev is set by gpr_event_set(ev, ...), or abs_deadline is
+   exceeded, then return gpr_event_get(ev).  Requires:  *ev initialized.  Use
+   abs_deadline==gpr_inf_future for no deadline.  When the event has been
+   signalled before the call, this operation is faster than acquiring a mutex
+   on most platforms.  */
+GPRAPI void* gpr_event_wait(gpr_event* ev, gpr_timespec abs_deadline);
+
+/** --- Reference counting ---
+
+   These calls act on the type gpr_refcount.  It requires no destruction.  */
+
+/** Initialize *r to value n.  */
+GPRAPI void gpr_ref_init(gpr_refcount* r, int n);
+
+/** Increment the reference count *r.  Requires *r initialized. */
+GPRAPI void gpr_ref(gpr_refcount* r);
+
+/** Increment the reference count *r.  Requires *r initialized.
+   Crashes if refcount is zero */
+GPRAPI void gpr_ref_non_zero(gpr_refcount* r);
+
+/** Increment the reference count *r by n.  Requires *r initialized, n > 0. */
+GPRAPI void gpr_refn(gpr_refcount* r, int n);
+
+/** Decrement the reference count *r and return non-zero iff it has reached
+   zero. .  Requires *r initialized. */
+GPRAPI int gpr_unref(gpr_refcount* r);
+
+/** Return non-zero iff the reference count of *r is one, and thus is owned
+   by exactly one object. */
+GPRAPI int gpr_ref_is_unique(gpr_refcount* r);
+
+/** --- Stats counters ---
+
+   These calls act on the integral type gpr_stats_counter.  It requires no
+   destruction.  Static instances may be initialized with
+       gpr_stats_counter c = GPR_STATS_INIT;
+   Beware:  These operations do not imply memory barriers.  Do not use them to
+   synchronize other events.  */
+
+/** Initialize *c to the value n. */
+GPRAPI void gpr_stats_init(gpr_stats_counter* c, intptr_t n);
+
+/** *c += inc.  Requires: *c initialized. */
+GPRAPI void gpr_stats_inc(gpr_stats_counter* c, intptr_t inc);
+
+/** Return *c.  Requires: *c initialized. */
+GPRAPI intptr_t gpr_stats_read(const gpr_stats_counter* c);
+
+/** ==================Example use of interface===================
+   A producer-consumer queue of up to N integers,
+   illustrating the use of the calls in this interface. */
+#if 0
+
+#define N 4
+
+   typedef struct queue {
+     gpr_cv non_empty;  /* Signalled when length becomes non-zero. */
+     gpr_cv non_full;   /* Signalled when length becomes non-N. */
+     gpr_mu mu;         /* Protects all fields below.
+                            (That is, except during initialization or
+                            destruction, the fields below should be accessed
+                            only by a thread that holds mu.) */
+     int head;           /* Index of head of queue 0..N-1. */
+     int length;         /* Number of valid elements in queue 0..N. */
+     int elem[N];        /* elem[head .. head+length-1] are queue elements. */
+   } queue;
+
+   /* Initialize *q. */
+   void queue_init(queue *q) {
+     gpr_mu_init(&q->mu);
+     gpr_cv_init(&q->non_empty);
+     gpr_cv_init(&q->non_full);
+     q->head = 0;
+     q->length = 0;
+   }
+
+   /* Free storage associated with *q. */
+   void queue_destroy(queue *q) {
+     gpr_mu_destroy(&q->mu);
+     gpr_cv_destroy(&q->non_empty);
+     gpr_cv_destroy(&q->non_full);
+   }
+
+   /* Wait until there is room in *q, then append x to *q. */
+   void queue_append(queue *q, int x) {
+     gpr_mu_lock(&q->mu);
+     /* To wait for a predicate without a deadline, loop on the negation of the
+        predicate, and use gpr_cv_wait(..., gpr_inf_future) inside the loop
+        to release the lock, wait, and reacquire on each iteration.  Code that
+        makes the condition true should use gpr_cv_broadcast() on the
+        corresponding condition variable.  The predicate must be on state
+        protected by the lock.  */
+     while (q->length == N) {
+       gpr_cv_wait(&q->non_full, &q->mu, gpr_inf_future);
+     }
+     if (q->length == 0) {  /* Wake threads blocked in queue_remove(). */
+       /* It's normal to use gpr_cv_broadcast() or gpr_signal() while
+          holding the lock. */
+       gpr_cv_broadcast(&q->non_empty);
+     }
+     q->elem[(q->head + q->length) % N] = x;
+     q->length++;
+     gpr_mu_unlock(&q->mu);
+   }
+
+   /* If it can be done without blocking, append x to *q and return non-zero.
+      Otherwise return 0. */
+   int queue_try_append(queue *q, int x) {
+     int result = 0;
+     if (gpr_mu_trylock(&q->mu)) {
+       if (q->length != N) {
+         if (q->length == 0) {  /* Wake threads blocked in queue_remove(). */
+           gpr_cv_broadcast(&q->non_empty);
+         }
+         q->elem[(q->head + q->length) % N] = x;
+         q->length++;
+         result = 1;
+       }
+       gpr_mu_unlock(&q->mu);
+     }
+     return result;
+   }
+
+   /* Wait until the *q is non-empty or deadline abs_deadline passes.  If the
+      queue is non-empty, remove its head entry, place it in *head, and return
+      non-zero.  Otherwise return 0.  */
+   int queue_remove(queue *q, int *head, gpr_timespec abs_deadline) {
+     int result = 0;
+     gpr_mu_lock(&q->mu);
+     /* To wait for a predicate with a deadline, loop on the negation of the
+        predicate or until gpr_cv_wait() returns true.  Code that makes
+        the condition true should use gpr_cv_broadcast() on the corresponding
+        condition variable.  The predicate must be on state protected by the
+        lock. */
+     while (q->length == 0 &&
+            !gpr_cv_wait(&q->non_empty, &q->mu, abs_deadline)) {
+     }
+     if (q->length != 0) {    /* Queue is non-empty. */
+       result = 1;
+       if (q->length == N) {  /* Wake threads blocked in queue_append(). */
+         gpr_cv_broadcast(&q->non_full);
+       }
+       *head = q->elem[q->head];
+       q->head = (q->head + 1) % N;
+       q->length--;
+     } /* else deadline exceeded */
+     gpr_mu_unlock(&q->mu);
+     return result;
+   }
+#endif /* 0 */
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif /* GRPC_SUPPORT_SYNC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/sync_abseil.h b/CAPI/cpp/grpc/include/grpc/support/sync_abseil.h
new file mode 100644
index 0000000..d6ad969
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/sync_abseil.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2020 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_SYNC_ABSEIL_H
+#define GRPC_SUPPORT_SYNC_ABSEIL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/sync_abseil.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_SYNC_ABSEIL_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/sync_custom.h b/CAPI/cpp/grpc/include/grpc/support/sync_custom.h
new file mode 100644
index 0000000..de7e220
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/sync_custom.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_SYNC_CUSTOM_H
+#define GRPC_SUPPORT_SYNC_CUSTOM_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/sync_custom.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_SYNC_CUSTOM_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/sync_generic.h b/CAPI/cpp/grpc/include/grpc/support/sync_generic.h
new file mode 100644
index 0000000..d1d9fd7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/sync_generic.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_SYNC_GENERIC_H
+#define GRPC_SUPPORT_SYNC_GENERIC_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/sync_generic.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_SYNC_GENERIC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/sync_posix.h b/CAPI/cpp/grpc/include/grpc/support/sync_posix.h
new file mode 100644
index 0000000..b971cd1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/sync_posix.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_SYNC_POSIX_H
+#define GRPC_SUPPORT_SYNC_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/sync_posix.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_SYNC_POSIX_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/sync_windows.h b/CAPI/cpp/grpc/include/grpc/support/sync_windows.h
new file mode 100644
index 0000000..3ee4a6f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/sync_windows.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_SYNC_WINDOWS_H
+#define GRPC_SUPPORT_SYNC_WINDOWS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/sync_windows.h>  // IWYU pragma: export
+
+#endif /* GRPC_SUPPORT_SYNC_WINDOWS_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/thd_id.h b/CAPI/cpp/grpc/include/grpc/support/thd_id.h
new file mode 100644
index 0000000..e9b2b7e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/thd_id.h
@@ -0,0 +1,44 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_THD_ID_H
+#define GRPC_SUPPORT_THD_ID_H
+/** Thread ID interface for GPR.
+
+   Used by some wrapped languages for logging purposes.
+
+   Types
+        gpr_thd_id        a unique opaque identifier for a thread.
+ */
+
+#include <grpc/support/port_platform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef uintptr_t gpr_thd_id;
+
+/** Returns the identifier of the current thread. */
+GPRAPI gpr_thd_id gpr_thd_currentid(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_SUPPORT_THD_ID_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/time.h b/CAPI/cpp/grpc/include/grpc/support/time.h
new file mode 100644
index 0000000..a193dbc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/time.h
@@ -0,0 +1,92 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_TIME_H
+#define GRPC_SUPPORT_TIME_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <time.h>
+
+#include <grpc/impl/codegen/gpr_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Time constants. */
+GPRAPI gpr_timespec
+gpr_time_0(gpr_clock_type type); /** The zero time interval. */
+GPRAPI gpr_timespec gpr_inf_future(gpr_clock_type type); /** The far future */
+GPRAPI gpr_timespec gpr_inf_past(gpr_clock_type type);   /** The far past. */
+
+#define GPR_MS_PER_SEC 1000
+#define GPR_US_PER_SEC 1000000
+#define GPR_NS_PER_SEC 1000000000
+#define GPR_NS_PER_MS 1000000
+#define GPR_NS_PER_US 1000
+#define GPR_US_PER_MS 1000
+
+/** initialize time subsystem */
+GPRAPI void gpr_time_init(void);
+
+/** Return the current time measured from the given clocks epoch. */
+GPRAPI gpr_timespec gpr_now(gpr_clock_type clock);
+
+/** Convert a timespec from one clock to another */
+GPRAPI gpr_timespec gpr_convert_clock_type(gpr_timespec t,
+                                           gpr_clock_type clock_type);
+
+/** Return -ve, 0, or +ve according to whether a < b, a == b, or a > b
+   respectively.  */
+GPRAPI int gpr_time_cmp(gpr_timespec a, gpr_timespec b);
+
+GPRAPI gpr_timespec gpr_time_max(gpr_timespec a, gpr_timespec b);
+GPRAPI gpr_timespec gpr_time_min(gpr_timespec a, gpr_timespec b);
+
+/** Add and subtract times.  Calculations saturate at infinities. */
+GPRAPI gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b);
+GPRAPI gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b);
+
+/** Return a timespec representing a given number of time units. INT64_MIN is
+   interpreted as gpr_inf_past, and INT64_MAX as gpr_inf_future.  */
+GPRAPI gpr_timespec gpr_time_from_micros(int64_t us, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_nanos(int64_t ns, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_millis(int64_t ms, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_seconds(int64_t s, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_minutes(int64_t m, gpr_clock_type clock_type);
+GPRAPI gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type clock_type);
+
+GPRAPI int32_t gpr_time_to_millis(gpr_timespec timespec);
+
+/** Return 1 if two times are equal or within threshold of each other,
+   0 otherwise */
+GPRAPI int gpr_time_similar(gpr_timespec a, gpr_timespec b,
+                            gpr_timespec threshold);
+
+/** Sleep until at least 'until' - an absolute timeout */
+GPRAPI void gpr_sleep_until(gpr_timespec until);
+
+GPRAPI double gpr_timespec_to_micros(gpr_timespec t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_SUPPORT_TIME_H */
diff --git a/CAPI/cpp/grpc/include/grpc/support/workaround_list.h b/CAPI/cpp/grpc/include/grpc/support/workaround_list.h
new file mode 100644
index 0000000..e28dfa1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpc/support/workaround_list.h
@@ -0,0 +1,31 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_SUPPORT_WORKAROUND_LIST_H
+#define GRPC_SUPPORT_WORKAROUND_LIST_H
+
+/* The list of IDs of server workarounds currently maintained by gRPC. For
+ * explanation and detailed descriptions of workarounds, see
+ * /doc/workarounds.md
+ */
+typedef enum {
+  GRPC_WORKAROUND_ID_CRONET_COMPRESSION = 0,
+  GRPC_MAX_WORKAROUND_ID
+} grpc_workaround_list;
+
+#endif /* GRPC_SUPPORT_WORKAROUND_LIST_H */
diff --git a/CAPI/cpp/grpc/include/grpcpp/alarm.h b/CAPI/cpp/grpc/include/grpcpp/alarm.h
new file mode 100644
index 0000000..1b5ddfe
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/alarm.h
@@ -0,0 +1,101 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+/// An Alarm posts the user-provided tag to its associated completion queue or
+/// invokes the user-provided function on expiry or cancellation.
+#ifndef GRPCPP_ALARM_H
+#define GRPCPP_ALARM_H
+
+#include <functional>
+
+#include <grpc/grpc.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/completion_queue_tag.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+#include <grpcpp/impl/codegen/time.h>
+#include <grpcpp/impl/grpc_library.h>
+
+namespace grpc {
+
+class Alarm : private grpc::GrpcLibraryCodegen {
+ public:
+  /// Create an unset completion queue alarm
+  Alarm();
+
+  /// Destroy the given completion queue alarm, cancelling it in the process.
+  ~Alarm() override;
+
+  /// DEPRECATED: Create and set a completion queue alarm instance associated to
+  /// \a cq.
+  /// This form is deprecated because it is inherently racy.
+  /// \internal We rely on the presence of \a cq for grpc initialization. If \a
+  /// cq were ever to be removed, a reference to a static
+  /// internal::GrpcLibraryInitializer instance would need to be introduced
+  /// here. \endinternal.
+  template <typename T>
+  Alarm(grpc::CompletionQueue* cq, const T& deadline, void* tag) : Alarm() {
+    SetInternal(cq, grpc::TimePoint<T>(deadline).raw_time(), tag);
+  }
+
+  /// Trigger an alarm instance on completion queue \a cq at the specified time.
+  /// Once the alarm expires (at \a deadline) or it's cancelled (see \a Cancel),
+  /// an event with tag \a tag will be added to \a cq. If the alarm expired, the
+  /// event's success bit will be true, false otherwise (ie, upon cancellation).
+  //
+  // USAGE NOTE: This is frequently used to inject arbitrary tags into \a cq by
+  // setting an immediate deadline. Such usage allows synchronizing an external
+  // event with an application's \a grpc::CompletionQueue::Next loop.
+  template <typename T>
+  void Set(grpc::CompletionQueue* cq, const T& deadline, void* tag) {
+    SetInternal(cq, grpc::TimePoint<T>(deadline).raw_time(), tag);
+  }
+
+  /// Alarms aren't copyable.
+  Alarm(const Alarm&) = delete;
+  Alarm& operator=(const Alarm&) = delete;
+
+  /// Alarms are movable.
+  Alarm(Alarm&& rhs) noexcept : alarm_(rhs.alarm_) { rhs.alarm_ = nullptr; }
+  Alarm& operator=(Alarm&& rhs) noexcept {
+    alarm_ = rhs.alarm_;
+    rhs.alarm_ = nullptr;
+    return *this;
+  }
+
+  /// Cancel a completion queue alarm. Calling this function over an alarm that
+  /// has already fired has no effect.
+  void Cancel();
+
+  /// Set an alarm to invoke callback \a f. The argument to the callback
+  /// states whether the alarm expired at \a deadline (true) or was cancelled
+  /// (false)
+  template <typename T>
+  void Set(const T& deadline, std::function<void(bool)> f) {
+    SetInternal(grpc::TimePoint<T>(deadline).raw_time(), std::move(f));
+  }
+
+ private:
+  void SetInternal(grpc::CompletionQueue* cq, gpr_timespec deadline, void* tag);
+  void SetInternal(gpr_timespec deadline, std::function<void(bool)> f);
+
+  grpc::internal::CompletionQueueTag* alarm_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_ALARM_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/channel.h b/CAPI/cpp/grpc/include/grpcpp/channel.h
new file mode 100644
index 0000000..ec8702e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/channel.h
@@ -0,0 +1,126 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_CHANNEL_H
+#define GRPCPP_CHANNEL_H
+
+#include <memory>
+
+#include <grpc/grpc.h>
+#include <grpcpp/impl/call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_interceptor.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+#include <grpcpp/impl/codegen/sync.h>
+
+struct grpc_channel;
+
+namespace grpc {
+namespace testing {
+class ChannelTestPeer;
+}  // namespace testing
+
+std::shared_ptr<Channel> CreateChannelInternal(
+    const std::string& host, grpc_channel* c_channel,
+    std::vector<
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
+        interceptor_creators);
+
+namespace experimental {
+/// Resets the channel's connection backoff.
+/// TODO(roth): Once we see whether this proves useful, either create a gRFC
+/// and change this to be a method of the Channel class, or remove it.
+void ChannelResetConnectionBackoff(Channel* channel);
+}  // namespace experimental
+
+/// Channels represent a connection to an endpoint. Created by \a CreateChannel.
+class Channel final : public grpc::ChannelInterface,
+                      public grpc::internal::CallHook,
+                      public std::enable_shared_from_this<Channel>,
+                      private grpc::GrpcLibraryCodegen {
+ public:
+  ~Channel() override;
+
+  /// Get the current channel state. If the channel is in IDLE and
+  /// \a try_to_connect is set to true, try to connect.
+  grpc_connectivity_state GetState(bool try_to_connect) override;
+
+  /// Returns the LB policy name, or the empty string if not yet available.
+  std::string GetLoadBalancingPolicyName() const;
+
+  /// Returns the service config in JSON form, or the empty string if
+  /// not available.
+  std::string GetServiceConfigJSON() const;
+
+ private:
+  template <class InputMessage, class OutputMessage>
+  friend class grpc::internal::BlockingUnaryCallImpl;
+  friend class grpc::testing::ChannelTestPeer;
+  friend void experimental::ChannelResetConnectionBackoff(Channel* channel);
+  friend std::shared_ptr<Channel> grpc::CreateChannelInternal(
+      const std::string& host, grpc_channel* c_channel,
+      std::vector<std::unique_ptr<
+          grpc::experimental::ClientInterceptorFactoryInterface>>
+          interceptor_creators);
+  friend class grpc::internal::InterceptedChannel;
+  Channel(const std::string& host, grpc_channel* c_channel,
+          std::vector<std::unique_ptr<
+              grpc::experimental::ClientInterceptorFactoryInterface>>
+              interceptor_creators);
+
+  grpc::internal::Call CreateCall(const grpc::internal::RpcMethod& method,
+                                  grpc::ClientContext* context,
+                                  grpc::CompletionQueue* cq) override;
+  void PerformOpsOnCall(grpc::internal::CallOpSetInterface* ops,
+                        grpc::internal::Call* call) override;
+  void* RegisterMethod(const char* method) override;
+
+  void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
+                               gpr_timespec deadline, grpc::CompletionQueue* cq,
+                               void* tag) override;
+  bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
+                              gpr_timespec deadline) override;
+
+  grpc::CompletionQueue* CallbackCQ() override;
+
+  grpc::internal::Call CreateCallInternal(
+      const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
+      grpc::CompletionQueue* cq, size_t interceptor_pos) override;
+
+  const std::string host_;
+  grpc_channel* const c_channel_;  // owned
+
+  // mu_ protects callback_cq_ (the per-channel callbackable completion queue)
+  grpc::internal::Mutex mu_;
+
+  // callback_cq_ references the callbackable completion queue associated
+  // with this channel (if any). It is set on the first call to CallbackCQ().
+  // It is _not owned_ by the channel; ownership belongs with its internal
+  // shutdown callback tag (invoked when the CQ is fully shutdown).
+  std::atomic<CompletionQueue*> callback_cq_{nullptr};
+
+  std::vector<
+      std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+      interceptor_creators_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/client_context.h b/CAPI/cpp/grpc/include/grpcpp/client_context.h
new file mode 100644
index 0000000..74a91e2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/client_context.h
@@ -0,0 +1,39 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+/// A ClientContext allows the person implementing a service client to:
+///
+/// - Add custom metadata key-value pairs that will propagated to the server
+/// side.
+/// - Control call settings such as compression and authentication.
+/// - Initial and trailing metadata coming from the server.
+/// - Get performance metrics (ie, census).
+///
+/// Context settings are only relevant to the call they are invoked with, that
+/// is to say, they aren't sticky. Some of these settings, such as the
+/// compression options, can be made persistent at channel construction time
+/// (see \a grpc::CreateCustomChannel).
+///
+/// \warning ClientContext instances should \em not be reused across rpcs.
+
+#ifndef GRPCPP_CLIENT_CONTEXT_H
+#define GRPCPP_CLIENT_CONTEXT_H
+
+#include <grpcpp/impl/codegen/client_context.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_CLIENT_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/completion_queue.h b/CAPI/cpp/grpc/include/grpcpp/completion_queue.h
new file mode 100644
index 0000000..42637b5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/completion_queue.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_COMPLETION_QUEUE_H
+#define GRPCPP_COMPLETION_QUEUE_H
+
+#include <grpcpp/impl/codegen/completion_queue.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_COMPLETION_QUEUE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/create_channel.h b/CAPI/cpp/grpc/include/grpcpp/create_channel.h
new file mode 100644
index 0000000..4b94a08
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/create_channel.h
@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_CREATE_CHANNEL_H
+#define GRPCPP_CREATE_CHANNEL_H
+
+#include <memory>
+
+#include <grpcpp/channel.h>
+#include <grpcpp/impl/codegen/client_interceptor.h>
+#include <grpcpp/security/credentials.h>
+#include <grpcpp/support/channel_arguments.h>
+#include <grpcpp/support/config.h>
+
+namespace grpc {
+/// Create a new \a Channel pointing to \a target.
+///
+/// \param target The URI of the endpoint to connect to.
+/// \param creds Credentials to use for the created channel. If it does not
+/// hold an object or is invalid, a lame channel (one on which all operations
+/// fail) is returned.
+std::shared_ptr<Channel> CreateChannel(
+    const grpc::string& target,
+    const std::shared_ptr<ChannelCredentials>& creds);
+
+/// Create a new \em custom \a Channel pointing to \a target.
+///
+/// \warning For advanced use and testing ONLY. Override default channel
+/// arguments only if necessary.
+///
+/// \param target The URI of the endpoint to connect to.
+/// \param creds Credentials to use for the created channel. If it does not
+/// hold an object or is invalid, a lame channel (one on which all operations
+/// fail) is returned.
+/// \param args Options for channel creation.
+std::shared_ptr<Channel> CreateCustomChannel(
+    const grpc::string& target,
+    const std::shared_ptr<ChannelCredentials>& creds,
+    const ChannelArguments& args);
+
+namespace experimental {
+/// Create a new \em custom \a Channel pointing to \a target with \a
+/// interceptors being invoked per call.
+///
+/// \warning For advanced use and testing ONLY. Override default channel
+/// arguments only if necessary.
+///
+/// \param target The URI of the endpoint to connect to.
+/// \param creds Credentials to use for the created channel. If it does not
+/// hold an object or is invalid, a lame channel (one on which all operations
+/// fail) is returned.
+/// \param args Options for channel creation.
+std::shared_ptr<Channel> CreateCustomChannelWithInterceptors(
+    const grpc::string& target,
+    const std::shared_ptr<ChannelCredentials>& creds,
+    const ChannelArguments& args,
+    std::vector<
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
+        interceptor_creators);
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_CREATE_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/create_channel_binder.h b/CAPI/cpp/grpc/include/grpcpp/create_channel_binder.h
new file mode 100644
index 0000000..4bfe952
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/create_channel_binder.h
@@ -0,0 +1,126 @@
+// Copyright 2021 gRPC authors.
+//
+// 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.
+
+#ifndef GRPCPP_CREATE_CHANNEL_BINDER_H
+#define GRPCPP_CREATE_CHANNEL_BINDER_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_ANDROID
+
+#include <jni.h>
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+
+#include <grpcpp/channel.h>
+#include <grpcpp/security/binder_security_policy.h>
+#include <grpcpp/support/channel_arguments.h>
+
+namespace grpc {
+namespace experimental {
+
+/// EXPERIMENTAL Create a new \a Channel based on binder transport. The package
+/// name and class name will be used identify the specific application component
+/// to connect to.
+///
+/// \param jni_env Pointer to a JNIEnv structure
+/// \param context The context that we will use to invoke \a bindService See
+/// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
+/// for detail.
+/// \param package_name Package name of the component to be connected to
+/// \param class_name Class name of the component to be connected to
+/// \param security_policy Used for checking if remote component is allowed to
+/// connect
+std::shared_ptr<grpc::Channel> CreateBinderChannel(
+    void* jni_env, jobject context, absl::string_view package_name,
+    absl::string_view class_name,
+    std::shared_ptr<grpc::experimental::binder::SecurityPolicy>
+        security_policy);
+
+/// EXPERIMENTAL Create a new \a Channel based on binder transport. The package
+/// name and class name will be used identify the specific application component
+/// to connect to.
+///
+/// \param jni_env Pointer to a JNIEnv structure
+/// \param context The context that we will use to invoke \a bindService See
+/// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
+/// for detail.
+/// \param package_name Package name of the component to be connected to
+/// \param class_name Class name of the component to be connected to
+/// \param security_policy Used for checking if remote component is allowed to
+/// connect
+/// \param args Options for channel creation.
+std::shared_ptr<grpc::Channel> CreateCustomBinderChannel(
+    void* jni_env_void, jobject application, absl::string_view package_name,
+    absl::string_view class_name,
+    std::shared_ptr<grpc::experimental::binder::SecurityPolicy> security_policy,
+    const ChannelArguments& args);
+
+/// EXPERIMENTAL Create a new \a Channel based on binder transport.
+///
+/// \param jni_env Pointer to a JNIEnv structure
+/// \param context The context that we will use to invoke \a bindService See
+/// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
+/// for detail.
+/// \param uri An URI that can be parsed as an `Intent` with
+/// https://developer.android.com/reference/android/content/Intent#parseUri(java.lang.String,%20int)
+/// \param security_policy Used for checking if remote component is allowed to
+/// connect
+std::shared_ptr<grpc::Channel> CreateBinderChannel(
+    void* jni_env, jobject context, absl::string_view uri,
+    std::shared_ptr<grpc::experimental::binder::SecurityPolicy>
+        security_policy);
+
+/// EXPERIMENTAL Create a new \a Channel based on binder transport.
+///
+/// \param jni_env Pointer to a JNIEnv structure
+/// \param context The context that we will use to invoke \a bindService See
+/// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
+/// for detail.
+/// \param uri An URI that can be parsed as an `Intent` with
+/// https://developer.android.com/reference/android/content/Intent#parseUri(java.lang.String,%20int)
+/// \param security_policy Used for checking if remote component is allowed to
+/// connect
+/// \param args Options for channel creation.
+std::shared_ptr<grpc::Channel> CreateCustomBinderChannel(
+    void* jni_env, jobject context, absl::string_view uri,
+    std::shared_ptr<grpc::experimental::binder::SecurityPolicy> security_policy,
+    const ChannelArguments& args);
+
+/// EXPERIMENTAL Finds internal binder transport Java code. To create channels
+/// in threads created in native code, it is required to call this function
+/// once beforehand in a thread that is not created in native code.
+/// See
+/// https://developer.android.com/training/articles/perf-jni#faq:-why-didnt-findclass-find-my-class
+/// for details of this limitation.
+/// Returns true when the initialization is successful.
+bool InitializeBinderChannelJavaClass(void* jni_env_void);
+
+/// EXPERIMENTAL Alternative version of `InitializeBinderChannelJavaClass(void*
+/// jni_env_void)`. This version used a user-specified function to find the
+/// required internal Java class. When a class is found, the `class_finder`
+/// function should return a local reference to the class (jclass type). The
+/// returned jclass will then be used to create global reference for gRPC to use
+/// it later. After that, gRPC will DeleteLocalRef the returned local reference.
+bool InitializeBinderChannelJavaClass(
+    void* jni_env_void, std::function<void*(std::string)> class_finder);
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif
+
+#endif  // GRPCPP_CREATE_CHANNEL_BINDER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/create_channel_posix.h b/CAPI/cpp/grpc/include/grpcpp/create_channel_posix.h
new file mode 100644
index 0000000..e6019d2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/create_channel_posix.h
@@ -0,0 +1,71 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_CREATE_CHANNEL_POSIX_H
+#define GRPCPP_CREATE_CHANNEL_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include <grpcpp/channel.h>
+#include <grpcpp/support/channel_arguments.h>
+
+namespace grpc {
+
+#ifdef GPR_SUPPORT_CHANNELS_FROM_FD
+
+/// Create a new \a Channel communicating over the given file descriptor.
+///
+/// \param target The name of the target.
+/// \param fd The file descriptor representing a socket.
+std::shared_ptr<grpc::Channel> CreateInsecureChannelFromFd(
+    const std::string& target, int fd);
+
+/// Create a new \a Channel communicating over given file descriptor with custom
+/// channel arguments.
+///
+/// \param target The name of the target.
+/// \param fd The file descriptor representing a socket.
+/// \param args Options for channel creation.
+std::shared_ptr<grpc::Channel> CreateCustomInsecureChannelFromFd(
+    const std::string& target, int fd, const grpc::ChannelArguments& args);
+
+namespace experimental {
+
+/// Create a new \a Channel communicating over given file descriptor with custom
+/// channel arguments.
+///
+/// \param target The name of the target.
+/// \param fd The file descriptor representing a socket.
+/// \param args Options for channel creation.
+/// \param interceptor_creators Vector of interceptor factory objects.
+std::shared_ptr<grpc::Channel>
+CreateCustomInsecureChannelWithInterceptorsFromFd(
+    const std::string& target, int fd, const grpc::ChannelArguments& args,
+    std::vector<
+        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+        interceptor_creators);
+
+}  // namespace experimental
+
+#endif  // GPR_SUPPORT_CHANNELS_FROM_FD
+
+}  // namespace grpc
+
+#endif  // GRPCPP_CREATE_CHANNEL_POSIX_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/ext/call_metric_recorder.h b/CAPI/cpp/grpc/include/grpcpp/ext/call_metric_recorder.h
new file mode 100644
index 0000000..9c52622
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/ext/call_metric_recorder.h
@@ -0,0 +1,94 @@
+/*
+ *
+ * Copyright 2022 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_EXT_CALL_METRIC_RECORDER_H
+#define GRPCPP_EXT_CALL_METRIC_RECORDER_H
+
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpcpp/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/sync.h>
+
+namespace grpc_core {
+class Arena;
+struct BackendMetricData;
+}  // namespace grpc_core
+
+namespace grpc {
+class ServerBuilder;
+
+namespace experimental {
+class OrcaServerInterceptor;
+
+// Registers the per-rpc orca load reporter into the \a ServerBuilder.
+// Once this is done, the server will automatically send the load metrics
+// after each RPC as they were reported. In order to report load metrics,
+// call the \a ServerContext::ExperimentalGetCallMetricRecorder() method to
+// retrieve the recorder for the current call.
+void EnableCallMetricRecording(ServerBuilder*);
+
+/// Records call metrics for the purpose of load balancing.
+/// During an RPC, call \a ServerContext::ExperimentalGetCallMetricRecorder()
+/// method to retrive the recorder for the current call.
+class CallMetricRecorder {
+ public:
+  explicit CallMetricRecorder(grpc_core::Arena* arena);
+  ~CallMetricRecorder();
+
+  /// Records a call metric measurement for CPU utilization.
+  /// Multiple calls to this method will override the stored value.
+  CallMetricRecorder& RecordCpuUtilizationMetric(double value);
+
+  /// Records a call metric measurement for memory utilization.
+  /// Multiple calls to this method will override the stored value.
+  CallMetricRecorder& RecordMemoryUtilizationMetric(double value);
+
+  /// Records a call metric measurement for utilization.
+  /// Multiple calls to this method with the same name will
+  /// override the corresponding stored value. The lifetime of the
+  /// name string needs to be longer than the lifetime of the RPC
+  /// itself, since it's going to be sent as trailers after the RPC
+  /// finishes. It is assumed the strings are common names that
+  /// are global constants.
+  CallMetricRecorder& RecordUtilizationMetric(string_ref name, double value);
+
+  /// Records a call metric measurement for request cost.
+  /// Multiple calls to this method with the same name will
+  /// override the corresponding stored value. The lifetime of the
+  /// name string needs to be longer than the lifetime of the RPC
+  /// itself, since it's going to be sent as trailers after the RPC
+  /// finishes. It is assumed the strings are common names that
+  /// are global constants.
+  CallMetricRecorder& RecordRequestCostMetric(string_ref name, double value);
+
+ private:
+  absl::optional<std::string> CreateSerializedReport();
+
+  internal::Mutex mu_;
+  grpc_core::BackendMetricData* backend_metric_data_ ABSL_GUARDED_BY(&mu_);
+  friend class experimental::OrcaServerInterceptor;
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_EXT_CALL_METRIC_RECORDER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/ext/health_check_service_server_builder_option.h b/CAPI/cpp/grpc/include/grpcpp/ext/health_check_service_server_builder_option.h
new file mode 100644
index 0000000..dd43b05
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/ext/health_check_service_server_builder_option.h
@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_EXT_HEALTH_CHECK_SERVICE_SERVER_BUILDER_OPTION_H
+#define GRPCPP_EXT_HEALTH_CHECK_SERVICE_SERVER_BUILDER_OPTION_H
+
+#include <memory>
+
+#include <grpcpp/health_check_service_interface.h>
+#include <grpcpp/impl/server_builder_option.h>
+#include <grpcpp/support/config.h>
+
+namespace grpc {
+
+class HealthCheckServiceServerBuilderOption : public ServerBuilderOption {
+ public:
+  /// The ownership of \a hc will be taken and transferred to the grpc server.
+  /// To explicitly disable default service, pass in a nullptr.
+  explicit HealthCheckServiceServerBuilderOption(
+      std::unique_ptr<HealthCheckServiceInterface> hc);
+  ~HealthCheckServiceServerBuilderOption() override {}
+  void UpdateArguments(ChannelArguments* args) override;
+  void UpdatePlugins(
+      std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override;
+
+ private:
+  std::unique_ptr<HealthCheckServiceInterface> hc_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_EXT_HEALTH_CHECK_SERVICE_SERVER_BUILDER_OPTION_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/generic/async_generic_service.h b/CAPI/cpp/grpc/include/grpcpp/generic/async_generic_service.h
new file mode 100644
index 0000000..01c7942
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/generic/async_generic_service.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_GENERIC_ASYNC_GENERIC_SERVICE_H
+#define GRPCPP_GENERIC_ASYNC_GENERIC_SERVICE_H
+
+#include <grpcpp/impl/codegen/async_generic_service.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_GENERIC_ASYNC_GENERIC_SERVICE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/generic/generic_stub.h b/CAPI/cpp/grpc/include/grpcpp/generic/generic_stub.h
new file mode 100644
index 0000000..6ae6c99
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/generic/generic_stub.h
@@ -0,0 +1,175 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_GENERIC_GENERIC_STUB_H
+#define GRPCPP_GENERIC_GENERIC_STUB_H
+
+#include <functional>
+
+#include <grpcpp/client_context.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/rpc_method.h>
+#include <grpcpp/support/async_stream.h>
+#include <grpcpp/support/async_unary_call.h>
+#include <grpcpp/support/byte_buffer.h>
+#include <grpcpp/support/client_callback.h>
+#include <grpcpp/support/status.h>
+
+namespace grpc {
+
+class CompletionQueue;
+
+typedef ClientAsyncReaderWriter<ByteBuffer, ByteBuffer>
+    GenericClientAsyncReaderWriter;
+typedef ClientAsyncResponseReader<ByteBuffer> GenericClientAsyncResponseReader;
+
+/// Generic stubs provide a type-unaware interface to call gRPC methods
+/// by name. In practice, the Request and Response types should be basic
+/// types like grpc::ByteBuffer or proto::MessageLite (the base protobuf).
+template <class RequestType, class ResponseType>
+class TemplatedGenericStub final {
+ public:
+  explicit TemplatedGenericStub(std::shared_ptr<grpc::ChannelInterface> channel)
+      : channel_(channel) {}
+
+  /// Setup a call to a named method \a method using \a context, but don't
+  /// start it. Let it be started explicitly with StartCall and a tag.
+  /// The return value only indicates whether or not registration of the call
+  /// succeeded (i.e. the call won't proceed if the return value is nullptr).
+  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>
+  PrepareCall(ClientContext* context, const std::string& method,
+              grpc::CompletionQueue* cq) {
+    return CallInternal(channel_.get(), context, method, /*options=*/{}, cq,
+                        false, nullptr);
+  }
+
+  /// Setup a unary call to a named method \a method using \a context, and don't
+  /// start it. Let it be started explicitly with StartCall.
+  /// The return value only indicates whether or not registration of the call
+  /// succeeded (i.e. the call won't proceed if the return value is nullptr).
+  std::unique_ptr<ClientAsyncResponseReader<ResponseType>> PrepareUnaryCall(
+      ClientContext* context, const std::string& method,
+      const RequestType& request, grpc::CompletionQueue* cq) {
+    return std::unique_ptr<ClientAsyncResponseReader<ResponseType>>(
+        internal::ClientAsyncResponseReaderHelper::Create<ResponseType>(
+            channel_.get(), cq,
+            grpc::internal::RpcMethod(method.c_str(),
+                                      /*suffix_for_stats=*/nullptr,
+                                      grpc::internal::RpcMethod::NORMAL_RPC),
+            context, request));
+  }
+
+  /// DEPRECATED for multi-threaded use
+  /// Begin a call to a named method \a method using \a context.
+  /// A tag \a tag will be delivered to \a cq when the call has been started
+  /// (i.e, initial metadata has been sent).
+  /// The return value only indicates whether or not registration of the call
+  /// succeeded (i.e. the call won't proceed if the return value is nullptr).
+  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>> Call(
+      ClientContext* context, const std::string& method,
+      grpc::CompletionQueue* cq, void* tag) {
+    return CallInternal(channel_.get(), context, method, /*options=*/{}, cq,
+                        true, tag);
+  }
+
+  /// Setup and start a unary call to a named method \a method using
+  /// \a context and specifying the \a request and \a response buffers.
+  void UnaryCall(ClientContext* context, const std::string& method,
+                 StubOptions options, const RequestType* request,
+                 ResponseType* response,
+                 std::function<void(grpc::Status)> on_completion) {
+    UnaryCallInternal(context, method, options, request, response,
+                      std::move(on_completion));
+  }
+
+  /// Setup a unary call to a named method \a method using
+  /// \a context and specifying the \a request and \a response buffers.
+  /// Like any other reactor-based RPC, it will not be activated until
+  /// StartCall is invoked on its reactor.
+  void PrepareUnaryCall(ClientContext* context, const std::string& method,
+                        StubOptions options, const RequestType* request,
+                        ResponseType* response, ClientUnaryReactor* reactor) {
+    PrepareUnaryCallInternal(context, method, options, request, response,
+                             reactor);
+  }
+
+  /// Setup a call to a named method \a method using \a context and tied to
+  /// \a reactor . Like any other bidi streaming RPC, it will not be activated
+  /// until StartCall is invoked on its reactor.
+  void PrepareBidiStreamingCall(
+      ClientContext* context, const std::string& method, StubOptions options,
+      ClientBidiReactor<RequestType, ResponseType>* reactor) {
+    PrepareBidiStreamingCallInternal(context, method, options, reactor);
+  }
+
+ private:
+  std::shared_ptr<grpc::ChannelInterface> channel_;
+
+  void UnaryCallInternal(ClientContext* context, const std::string& method,
+                         StubOptions options, const RequestType* request,
+                         ResponseType* response,
+                         std::function<void(grpc::Status)> on_completion) {
+    internal::CallbackUnaryCall(
+        channel_.get(),
+        grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(),
+                                  grpc::internal::RpcMethod::NORMAL_RPC),
+        context, request, response, std::move(on_completion));
+  }
+
+  void PrepareUnaryCallInternal(ClientContext* context,
+                                const std::string& method, StubOptions options,
+                                const RequestType* request,
+                                ResponseType* response,
+                                ClientUnaryReactor* reactor) {
+    internal::ClientCallbackUnaryFactory::Create<RequestType, ResponseType>(
+        channel_.get(),
+        grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(),
+                                  grpc::internal::RpcMethod::NORMAL_RPC),
+        context, request, response, reactor);
+  }
+
+  void PrepareBidiStreamingCallInternal(
+      ClientContext* context, const std::string& method, StubOptions options,
+      ClientBidiReactor<RequestType, ResponseType>* reactor) {
+    internal::ClientCallbackReaderWriterFactory<RequestType, ResponseType>::
+        Create(channel_.get(),
+               grpc::internal::RpcMethod(
+                   method.c_str(), options.suffix_for_stats(),
+                   grpc::internal::RpcMethod::BIDI_STREAMING),
+               context, reactor);
+  }
+
+  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>
+  CallInternal(grpc::ChannelInterface* channel, ClientContext* context,
+               const std::string& method, StubOptions options,
+               grpc::CompletionQueue* cq, bool start, void* tag) {
+    return std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>(
+        internal::ClientAsyncReaderWriterFactory<RequestType, ResponseType>::
+            Create(channel, cq,
+                   grpc::internal::RpcMethod(
+                       method.c_str(), options.suffix_for_stats(),
+                       grpc::internal::RpcMethod::BIDI_STREAMING),
+                   context, start, tag));
+  }
+};
+
+typedef TemplatedGenericStub<grpc::ByteBuffer, grpc::ByteBuffer> GenericStub;
+
+}  // namespace grpc
+
+#endif  // GRPCPP_GENERIC_GENERIC_STUB_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/grpcpp.h b/CAPI/cpp/grpc/include/grpcpp/grpcpp.h
new file mode 100644
index 0000000..9d707e2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/grpcpp.h
@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+/// \mainpage gRPC C++ API
+///
+/// The gRPC C++ API mainly consists of the following classes:
+/// <br>
+/// - grpc::Channel, which represents the connection to an endpoint. See [the
+/// gRPC Concepts page](https://grpc.io/docs/what-is-grpc/core-concepts) for
+/// more details. Channels are created by the factory function
+/// grpc::CreateChannel.
+///
+/// - grpc::CompletionQueue, the producer-consumer queue used for all
+/// asynchronous communication with the gRPC runtime.
+///
+/// - grpc::ClientContext and grpc::ServerContext, where optional configuration
+/// for an RPC can be set, such as setting custom metadata to be conveyed to the
+/// peer, compression settings, authentication, etc.
+///
+/// - grpc::Server, representing a gRPC server, created by grpc::ServerBuilder.
+///
+/// Streaming calls are handled with the streaming classes in
+/// \ref sync_stream.h and
+/// \ref async_stream.h.
+///
+/// Refer to the
+/// [examples](https://github.com/grpc/grpc/blob/master/examples/cpp)
+/// for code putting these pieces into play.
+
+#ifndef GRPCPP_GRPCPP_H
+#define GRPCPP_GRPCPP_H
+
+// Pragma for http://include-what-you-use.org/ tool, tells that following
+// headers are not private for grpcpp.h and are part of its interface.
+// IWYU pragma: begin_exports
+#include <grpc/grpc.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/client_context.h>
+#include <grpcpp/completion_queue.h>
+#include <grpcpp/create_channel.h>
+#include <grpcpp/create_channel_posix.h>
+#include <grpcpp/server.h>
+#include <grpcpp/server_builder.h>
+#include <grpcpp/server_context.h>
+#include <grpcpp/server_posix.h>
+// IWYU pragma: end_exports
+
+namespace grpc {
+/// Return gRPC library version.
+std::string Version();
+}  // namespace grpc
+
+#endif  // GRPCPP_GRPCPP_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/health_check_service_interface.h b/CAPI/cpp/grpc/include/grpcpp/health_check_service_interface.h
new file mode 100644
index 0000000..9eab8fc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/health_check_service_interface.h
@@ -0,0 +1,58 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_HEALTH_CHECK_SERVICE_INTERFACE_H
+#define GRPCPP_HEALTH_CHECK_SERVICE_INTERFACE_H
+
+#include <grpcpp/support/config.h>
+
+namespace grpc {
+
+const char kHealthCheckServiceInterfaceArg[] =
+    "grpc.health_check_service_interface";
+
+/// The gRPC server uses this interface to expose the health checking service
+/// without depending on protobuf.
+class HealthCheckServiceInterface {
+ public:
+  virtual ~HealthCheckServiceInterface() {}
+
+  /// Set or change the serving status of the given \a service_name.
+  virtual void SetServingStatus(const std::string& service_name,
+                                bool serving) = 0;
+  /// Apply to all registered service names.
+  virtual void SetServingStatus(bool serving) = 0;
+
+  /// Set all registered service names to not serving and prevent future
+  /// state changes.
+  virtual void Shutdown() {}
+};
+
+/// Enable/disable the default health checking service. This applies to all C++
+/// servers created afterwards. For each server, user can override the default
+/// with a HealthCheckServiceServerBuilderOption.
+/// NOT thread safe.
+void EnableDefaultHealthCheckService(bool enable);
+
+/// Returns whether the default health checking service is enabled.
+/// NOT thread safe.
+bool DefaultHealthCheckServiceEnabled();
+
+}  // namespace grpc
+
+#endif  // GRPCPP_HEALTH_CHECK_SERVICE_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/call.h b/CAPI/cpp/grpc/include/grpcpp/impl/call.h
new file mode 100644
index 0000000..97d8fdf
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/call.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CALL_H
+#define GRPCPP_IMPL_CALL_H
+
+#include <grpcpp/impl/codegen/call.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_IMPL_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/channel_argument_option.h b/CAPI/cpp/grpc/include/grpcpp/impl/channel_argument_option.h
new file mode 100644
index 0000000..335072a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/channel_argument_option.h
@@ -0,0 +1,37 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CHANNEL_ARGUMENT_OPTION_H
+#define GRPCPP_IMPL_CHANNEL_ARGUMENT_OPTION_H
+
+#include <map>
+#include <memory>
+
+#include <grpcpp/impl/server_builder_option.h>
+#include <grpcpp/support/channel_arguments.h>
+
+namespace grpc {
+
+std::unique_ptr<ServerBuilderOption> MakeChannelArgumentOption(
+    const std::string& name, const std::string& value);
+std::unique_ptr<ServerBuilderOption> MakeChannelArgumentOption(
+    const std::string& name, int value);
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CHANNEL_ARGUMENT_OPTION_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/client_unary_call.h b/CAPI/cpp/grpc/include/grpcpp/impl/client_unary_call.h
new file mode 100644
index 0000000..7ecf354
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/client_unary_call.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CLIENT_UNARY_CALL_H
+#define GRPCPP_IMPL_CLIENT_UNARY_CALL_H
+
+#include <grpcpp/impl/codegen/client_unary_call.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_IMPL_CLIENT_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_generic_service.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_generic_service.h
new file mode 100644
index 0000000..2a00066
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_generic_service.h
@@ -0,0 +1,137 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_ASYNC_GENERIC_SERVICE_H
+#define GRPCPP_IMPL_CODEGEN_ASYNC_GENERIC_SERVICE_H
+
+// IWYU pragma: private, include <grpcpp/generic/async_generic_service.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+
+struct grpc_server;
+
+namespace grpc {
+
+typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer>
+    GenericServerAsyncReaderWriter;
+typedef ServerAsyncResponseWriter<ByteBuffer> GenericServerAsyncResponseWriter;
+typedef ServerAsyncReader<ByteBuffer, ByteBuffer> GenericServerAsyncReader;
+typedef ServerAsyncWriter<ByteBuffer> GenericServerAsyncWriter;
+
+class GenericServerContext final : public ServerContext {
+ public:
+  const std::string& method() const { return method_; }
+  const std::string& host() const { return host_; }
+
+ private:
+  friend class ServerInterface;
+
+  std::string method_;
+  std::string host_;
+};
+
+// A generic service at the server side accepts all RPC methods and hosts. It is
+// typically used in proxies. The generic service can be registered to a server
+// which also has other services.
+// Sample usage:
+//   ServerBuilder builder;
+//   auto cq = builder.AddCompletionQueue();
+//   AsyncGenericService generic_service;
+//   builder.RegisterAsyncGenericService(&generic_service);
+//   auto server = builder.BuildAndStart();
+//
+//   // request a new call
+//   GenericServerContext context;
+//   GenericServerAsyncReaderWriter stream;
+//   generic_service.RequestCall(&context, &stream, cq.get(), cq.get(), tag);
+//
+// When tag is retrieved from cq->Next(), context.method() can be used to look
+// at the method and the RPC can be handled accordingly.
+class AsyncGenericService final {
+ public:
+  AsyncGenericService() : server_(nullptr) {}
+
+  void RequestCall(GenericServerContext* ctx,
+                   GenericServerAsyncReaderWriter* reader_writer,
+                   grpc::CompletionQueue* call_cq,
+                   grpc::ServerCompletionQueue* notification_cq, void* tag);
+
+ private:
+  friend class grpc::Server;
+  grpc::Server* server_;
+};
+
+/// \a ServerGenericBidiReactor is the reactor class for bidi streaming RPCs
+/// invoked on a CallbackGenericService. It is just a ServerBidi reactor with
+/// ByteBuffer arguments.
+using ServerGenericBidiReactor = ServerBidiReactor<ByteBuffer, ByteBuffer>;
+
+class GenericCallbackServerContext final : public grpc::CallbackServerContext {
+ public:
+  const std::string& method() const { return method_; }
+  const std::string& host() const { return host_; }
+
+ private:
+  friend class grpc::Server;
+
+  std::string method_;
+  std::string host_;
+};
+
+/// \a CallbackGenericService is the base class for generic services implemented
+/// using the callback API and registered through the ServerBuilder using
+/// RegisterCallbackGenericService.
+class CallbackGenericService {
+ public:
+  CallbackGenericService() {}
+  virtual ~CallbackGenericService() {}
+
+  /// The "method handler" for the generic API. This function should be
+  /// overridden to provide a ServerGenericBidiReactor that implements the
+  /// application-level interface for this RPC. Unimplemented by default.
+  virtual ServerGenericBidiReactor* CreateReactor(
+      GenericCallbackServerContext* /*ctx*/) {
+    class Reactor : public ServerGenericBidiReactor {
+     public:
+      Reactor() { this->Finish(Status(StatusCode::UNIMPLEMENTED, "")); }
+      void OnDone() override { delete this; }
+    };
+    return new Reactor;
+  }
+
+ private:
+  friend class grpc::Server;
+
+  internal::CallbackBidiHandler<ByteBuffer, ByteBuffer>* Handler() {
+    return new internal::CallbackBidiHandler<ByteBuffer, ByteBuffer>(
+        [this](grpc::CallbackServerContext* ctx) {
+          return CreateReactor(static_cast<GenericCallbackServerContext*>(ctx));
+        });
+  }
+
+  grpc::Server* server_{nullptr};
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_ASYNC_GENERIC_SERVICE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_stream.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_stream.h
new file mode 100644
index 0000000..5b63c30
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_stream.h
@@ -0,0 +1,1132 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_ASYNC_STREAM_H
+#define GRPCPP_IMPL_CODEGEN_ASYNC_STREAM_H
+
+// IWYU pragma: private, include <grpcpp/support/async_stream.h>
+
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+
+namespace internal {
+/// Common interface for all client side asynchronous streaming.
+class ClientAsyncStreamingInterface {
+ public:
+  virtual ~ClientAsyncStreamingInterface() {}
+
+  /// Start the call that was set up by the constructor, but only if the
+  /// constructor was invoked through the "Prepare" API which doesn't actually
+  /// start the call
+  virtual void StartCall(void* tag) = 0;
+
+  /// Request notification of the reading of the initial metadata. Completion
+  /// will be notified by \a tag on the associated completion queue.
+  /// This call is optional, but if it is used, it cannot be used concurrently
+  /// with or after the \a AsyncReaderInterface::Read method.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  virtual void ReadInitialMetadata(void* tag) = 0;
+
+  /// Indicate that the stream is to be finished and request notification for
+  /// when the call has been ended.
+  /// Should not be used concurrently with other operations.
+  ///
+  /// It is appropriate to call this method exactly once when both:
+  ///   * the client side has no more message to send
+  ///     (this can be declared implicitly by calling this method, or
+  ///     explicitly through an earlier call to the <i>WritesDone</i> method
+  ///     of the class in use, e.g. \a ClientAsyncWriterInterface::WritesDone or
+  ///     \a ClientAsyncReaderWriterInterface::WritesDone).
+  ///   * there are no more messages to be received from the server (this can
+  ///     be known implicitly by the calling code, or explicitly from an
+  ///     earlier call to \a AsyncReaderInterface::Read that yielded a failed
+  ///     result, e.g. cq->Next(&read_tag, &ok) filled in 'ok' with 'false').
+  ///
+  /// The tag will be returned when either:
+  /// - all incoming messages have been read and the server has returned
+  ///   a status.
+  /// - the server has returned a non-OK status.
+  /// - the call failed for some reason and the library generated a
+  ///   status.
+  ///
+  /// Note that implementations of this method attempt to receive initial
+  /// metadata from the server if initial metadata hasn't yet been received.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  /// \param[out] status To be updated with the operation status.
+  virtual void Finish(grpc::Status* status, void* tag) = 0;
+};
+
+/// An interface that yields a sequence of messages of type \a R.
+template <class R>
+class AsyncReaderInterface {
+ public:
+  virtual ~AsyncReaderInterface() {}
+
+  /// Read a message of type \a R into \a msg. Completion will be notified by \a
+  /// tag on the associated completion queue.
+  /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
+  /// should not be called concurrently with other streaming APIs
+  /// on the same stream. It is not meaningful to call it concurrently
+  /// with another \a AsyncReaderInterface::Read on the same stream since reads
+  /// on the same stream are delivered in order.
+  ///
+  /// \param[out] msg Where to eventually store the read message.
+  /// \param[in] tag The tag identifying the operation.
+  ///
+  /// Side effect: note that this method attempt to receive initial metadata for
+  /// a stream if it hasn't yet been received.
+  virtual void Read(R* msg, void* tag) = 0;
+};
+
+/// An interface that can be fed a sequence of messages of type \a W.
+template <class W>
+class AsyncWriterInterface {
+ public:
+  virtual ~AsyncWriterInterface() {}
+
+  /// Request the writing of \a msg with identifying tag \a tag.
+  ///
+  /// Only one write may be outstanding at any given time. This means that
+  /// after calling Write, one must wait to receive \a tag from the completion
+  /// queue BEFORE calling Write again.
+  /// This is thread-safe with respect to \a AsyncReaderInterface::Read
+  ///
+  /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
+  /// to deallocate once Write returns.
+  ///
+  /// \param[in] msg The message to be written.
+  /// \param[in] tag The tag identifying the operation.
+  virtual void Write(const W& msg, void* tag) = 0;
+
+  /// Request the writing of \a msg using WriteOptions \a options with
+  /// identifying tag \a tag.
+  ///
+  /// Only one write may be outstanding at any given time. This means that
+  /// after calling Write, one must wait to receive \a tag from the completion
+  /// queue BEFORE calling Write again.
+  /// WriteOptions \a options is used to set the write options of this message.
+  /// This is thread-safe with respect to \a AsyncReaderInterface::Read
+  ///
+  /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
+  /// to deallocate once Write returns.
+  ///
+  /// \param[in] msg The message to be written.
+  /// \param[in] options The WriteOptions to be used to write this message.
+  /// \param[in] tag The tag identifying the operation.
+  virtual void Write(const W& msg, grpc::WriteOptions options, void* tag) = 0;
+
+  /// Request the writing of \a msg and coalesce it with the writing
+  /// of trailing metadata, using WriteOptions \a options with
+  /// identifying tag \a tag.
+  ///
+  /// For client, WriteLast is equivalent of performing Write and
+  /// WritesDone in a single step.
+  /// For server, WriteLast buffers the \a msg. The writing of \a msg is held
+  /// until Finish is called, where \a msg and trailing metadata are coalesced
+  /// and write is initiated. Note that WriteLast can only buffer \a msg up to
+  /// the flow control window size. If \a msg size is larger than the window
+  /// size, it will be sent on wire without buffering.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
+  /// to deallocate once Write returns.
+  ///
+  /// \param[in] msg The message to be written.
+  /// \param[in] options The WriteOptions to be used to write this message.
+  /// \param[in] tag The tag identifying the operation.
+  void WriteLast(const W& msg, grpc::WriteOptions options, void* tag) {
+    Write(msg, options.set_last_message(), tag);
+  }
+};
+
+}  // namespace internal
+
+template <class R>
+class ClientAsyncReaderInterface
+    : public internal::ClientAsyncStreamingInterface,
+      public internal::AsyncReaderInterface<R> {};
+
+namespace internal {
+template <class R>
+class ClientAsyncReaderFactory {
+ public:
+  /// Create a stream object.
+  /// Write the first request out if \a start is set.
+  /// \a tag will be notified on \a cq when the call has been started and
+  /// \a request has been written out. If \a start is not set, \a tag must be
+  /// nullptr and the actual call must be initiated by StartCall
+  /// Note that \a context will be used to fill in custom initial metadata
+  /// used to send to the server when starting the call.
+  template <class W>
+  static ClientAsyncReader<R>* Create(grpc::ChannelInterface* channel,
+                                      grpc::CompletionQueue* cq,
+                                      const grpc::internal::RpcMethod& method,
+                                      grpc::ClientContext* context,
+                                      const W& request, bool start, void* tag) {
+    grpc::internal::Call call = channel->CreateCall(method, context, cq);
+    return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call.call(), sizeof(ClientAsyncReader<R>)))
+        ClientAsyncReader<R>(call, context, request, start, tag);
+  }
+};
+}  // namespace internal
+
+/// Async client-side API for doing server-streaming RPCs,
+/// where the incoming message stream coming from the server has
+/// messages of type \a R.
+template <class R>
+class ClientAsyncReader final : public ClientAsyncReaderInterface<R> {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncReader));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  void StartCall(void* tag) override {
+    GPR_CODEGEN_ASSERT(!started_);
+    started_ = true;
+    StartCallInternal(tag);
+  }
+
+  /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata
+  /// method for semantics.
+  ///
+  /// Side effect:
+  ///   - upon receiving initial metadata from the server,
+  ///     the \a ClientContext associated with this call is updated, and the
+  ///     calling code can access the received metadata through the
+  ///     \a ClientContext.
+  void ReadInitialMetadata(void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+    meta_ops_.set_output_tag(tag);
+    meta_ops_.RecvInitialMetadata(context_);
+    call_.PerformOps(&meta_ops_);
+  }
+
+  void Read(R* msg, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    read_ops_.set_output_tag(tag);
+    if (!context_->initial_metadata_received_) {
+      read_ops_.RecvInitialMetadata(context_);
+    }
+    read_ops_.RecvMessage(msg);
+    call_.PerformOps(&read_ops_);
+  }
+
+  /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
+  ///
+  /// Side effect:
+  ///   - the \a ClientContext associated with this call is updated with
+  ///     possible initial and trailing metadata received from the server.
+  void Finish(grpc::Status* status, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    finish_ops_.set_output_tag(tag);
+    if (!context_->initial_metadata_received_) {
+      finish_ops_.RecvInitialMetadata(context_);
+    }
+    finish_ops_.ClientRecvStatus(context_, status);
+    call_.PerformOps(&finish_ops_);
+  }
+
+ private:
+  friend class internal::ClientAsyncReaderFactory<R>;
+  template <class W>
+  ClientAsyncReader(grpc::internal::Call call, grpc::ClientContext* context,
+                    const W& request, bool start, void* tag)
+      : context_(context), call_(call), started_(start) {
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(init_ops_.SendMessage(request).ok());
+    init_ops_.ClientSendClose();
+    if (start) {
+      StartCallInternal(tag);
+    } else {
+      GPR_CODEGEN_ASSERT(tag == nullptr);
+    }
+  }
+
+  void StartCallInternal(void* tag) {
+    init_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                  context_->initial_metadata_flags());
+    init_ops_.set_output_tag(tag);
+    call_.PerformOps(&init_ops_);
+  }
+
+  grpc::ClientContext* context_;
+  grpc::internal::Call call_;
+  bool started_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpClientSendClose>
+      init_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
+      meta_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                            grpc::internal::CallOpRecvMessage<R>>
+      read_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                            grpc::internal::CallOpClientRecvStatus>
+      finish_ops_;
+};
+
+/// Common interface for client side asynchronous writing.
+template <class W>
+class ClientAsyncWriterInterface
+    : public internal::ClientAsyncStreamingInterface,
+      public internal::AsyncWriterInterface<W> {
+ public:
+  /// Signal the client is done with the writes (half-close the client stream).
+  /// Thread-safe with respect to \a AsyncReaderInterface::Read
+  ///
+  /// \param[in] tag The tag identifying the operation.
+  virtual void WritesDone(void* tag) = 0;
+};
+
+namespace internal {
+template <class W>
+class ClientAsyncWriterFactory {
+ public:
+  /// Create a stream object.
+  /// Start the RPC if \a start is set
+  /// \a tag will be notified on \a cq when the call has been started (i.e.
+  /// intitial metadata sent) and \a request has been written out.
+  /// If \a start is not set, \a tag must be nullptr and the actual call
+  /// must be initiated by StartCall
+  /// Note that \a context will be used to fill in custom initial metadata
+  /// used to send to the server when starting the call.
+  /// \a response will be filled in with the single expected response
+  /// message from the server upon a successful call to the \a Finish
+  /// method of this instance.
+  template <class R>
+  static ClientAsyncWriter<W>* Create(grpc::ChannelInterface* channel,
+                                      grpc::CompletionQueue* cq,
+                                      const grpc::internal::RpcMethod& method,
+                                      grpc::ClientContext* context, R* response,
+                                      bool start, void* tag) {
+    grpc::internal::Call call = channel->CreateCall(method, context, cq);
+    return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call.call(), sizeof(ClientAsyncWriter<W>)))
+        ClientAsyncWriter<W>(call, context, response, start, tag);
+  }
+};
+}  // namespace internal
+
+/// Async API on the client side for doing client-streaming RPCs,
+/// where the outgoing message stream going to the server contains
+/// messages of type \a W.
+template <class W>
+class ClientAsyncWriter final : public ClientAsyncWriterInterface<W> {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncWriter));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  void StartCall(void* tag) override {
+    GPR_CODEGEN_ASSERT(!started_);
+    started_ = true;
+    StartCallInternal(tag);
+  }
+
+  /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata method for
+  /// semantics.
+  ///
+  /// Side effect:
+  ///   - upon receiving initial metadata from the server, the \a ClientContext
+  ///     associated with this call is updated, and the calling code can access
+  ///     the received metadata through the \a ClientContext.
+  void ReadInitialMetadata(void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+    meta_ops_.set_output_tag(tag);
+    meta_ops_.RecvInitialMetadata(context_);
+    call_.PerformOps(&meta_ops_);
+  }
+
+  void Write(const W& msg, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    write_ops_.set_output_tag(tag);
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
+    call_.PerformOps(&write_ops_);
+  }
+
+  void Write(const W& msg, grpc::WriteOptions options, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    write_ops_.set_output_tag(tag);
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+      write_ops_.ClientSendClose();
+    }
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+    call_.PerformOps(&write_ops_);
+  }
+
+  void WritesDone(void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    write_ops_.set_output_tag(tag);
+    write_ops_.ClientSendClose();
+    call_.PerformOps(&write_ops_);
+  }
+
+  /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
+  ///
+  /// Side effect:
+  ///   - the \a ClientContext associated with this call is updated with
+  ///     possible initial and trailing metadata received from the server.
+  ///   - attempts to fill in the \a response parameter passed to this class's
+  ///     constructor with the server's response message.
+  void Finish(grpc::Status* status, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    finish_ops_.set_output_tag(tag);
+    if (!context_->initial_metadata_received_) {
+      finish_ops_.RecvInitialMetadata(context_);
+    }
+    finish_ops_.ClientRecvStatus(context_, status);
+    call_.PerformOps(&finish_ops_);
+  }
+
+ private:
+  friend class internal::ClientAsyncWriterFactory<W>;
+  template <class R>
+  ClientAsyncWriter(grpc::internal::Call call, grpc::ClientContext* context,
+                    R* response, bool start, void* tag)
+      : context_(context), call_(call), started_(start) {
+    finish_ops_.RecvMessage(response);
+    finish_ops_.AllowNoMessage();
+    if (start) {
+      StartCallInternal(tag);
+    } else {
+      GPR_CODEGEN_ASSERT(tag == nullptr);
+    }
+  }
+
+  void StartCallInternal(void* tag) {
+    write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                   context_->initial_metadata_flags());
+    // if corked bit is set in context, we just keep the initial metadata
+    // buffered up to coalesce with later message send. No op is performed.
+    if (!context_->initial_metadata_corked_) {
+      write_ops_.set_output_tag(tag);
+      call_.PerformOps(&write_ops_);
+    }
+  }
+
+  grpc::ClientContext* context_;
+  grpc::internal::Call call_;
+  bool started_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
+      meta_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpClientSendClose>
+      write_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                            grpc::internal::CallOpGenericRecvMessage,
+                            grpc::internal::CallOpClientRecvStatus>
+      finish_ops_;
+};
+
+/// Async client-side interface for bi-directional streaming,
+/// where the client-to-server message stream has messages of type \a W,
+/// and the server-to-client message stream has messages of type \a R.
+template <class W, class R>
+class ClientAsyncReaderWriterInterface
+    : public internal::ClientAsyncStreamingInterface,
+      public internal::AsyncWriterInterface<W>,
+      public internal::AsyncReaderInterface<R> {
+ public:
+  /// Signal the client is done with the writes (half-close the client stream).
+  /// Thread-safe with respect to \a AsyncReaderInterface::Read
+  ///
+  /// \param[in] tag The tag identifying the operation.
+  virtual void WritesDone(void* tag) = 0;
+};
+
+namespace internal {
+template <class W, class R>
+class ClientAsyncReaderWriterFactory {
+ public:
+  /// Create a stream object.
+  /// Start the RPC request if \a start is set.
+  /// \a tag will be notified on \a cq when the call has been started (i.e.
+  /// intitial metadata sent). If \a start is not set, \a tag must be
+  /// nullptr and the actual call must be initiated by StartCall
+  /// Note that \a context will be used to fill in custom initial metadata
+  /// used to send to the server when starting the call.
+  static ClientAsyncReaderWriter<W, R>* Create(
+      grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
+      const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
+      bool start, void* tag) {
+    grpc::internal::Call call = channel->CreateCall(method, context, cq);
+
+    return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call.call(), sizeof(ClientAsyncReaderWriter<W, R>)))
+        ClientAsyncReaderWriter<W, R>(call, context, start, tag);
+  }
+};
+}  // namespace internal
+
+/// Async client-side interface for bi-directional streaming,
+/// where the outgoing message stream going to the server
+/// has messages of type \a W,  and the incoming message stream coming
+/// from the server has messages of type \a R.
+template <class W, class R>
+class ClientAsyncReaderWriter final
+    : public ClientAsyncReaderWriterInterface<W, R> {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncReaderWriter));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  void StartCall(void* tag) override {
+    GPR_CODEGEN_ASSERT(!started_);
+    started_ = true;
+    StartCallInternal(tag);
+  }
+
+  /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata method
+  /// for semantics of this method.
+  ///
+  /// Side effect:
+  ///   - upon receiving initial metadata from the server, the \a ClientContext
+  ///     is updated with it, and then the receiving initial metadata can
+  ///     be accessed through this \a ClientContext.
+  void ReadInitialMetadata(void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+    meta_ops_.set_output_tag(tag);
+    meta_ops_.RecvInitialMetadata(context_);
+    call_.PerformOps(&meta_ops_);
+  }
+
+  void Read(R* msg, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    read_ops_.set_output_tag(tag);
+    if (!context_->initial_metadata_received_) {
+      read_ops_.RecvInitialMetadata(context_);
+    }
+    read_ops_.RecvMessage(msg);
+    call_.PerformOps(&read_ops_);
+  }
+
+  void Write(const W& msg, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    write_ops_.set_output_tag(tag);
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
+    call_.PerformOps(&write_ops_);
+  }
+
+  void Write(const W& msg, grpc::WriteOptions options, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    write_ops_.set_output_tag(tag);
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+      write_ops_.ClientSendClose();
+    }
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+    call_.PerformOps(&write_ops_);
+  }
+
+  void WritesDone(void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    write_ops_.set_output_tag(tag);
+    write_ops_.ClientSendClose();
+    call_.PerformOps(&write_ops_);
+  }
+
+  /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
+  /// Side effect
+  ///   - the \a ClientContext associated with this call is updated with
+  ///     possible initial and trailing metadata sent from the server.
+  void Finish(grpc::Status* status, void* tag) override {
+    GPR_CODEGEN_ASSERT(started_);
+    finish_ops_.set_output_tag(tag);
+    if (!context_->initial_metadata_received_) {
+      finish_ops_.RecvInitialMetadata(context_);
+    }
+    finish_ops_.ClientRecvStatus(context_, status);
+    call_.PerformOps(&finish_ops_);
+  }
+
+ private:
+  friend class internal::ClientAsyncReaderWriterFactory<W, R>;
+  ClientAsyncReaderWriter(grpc::internal::Call call,
+                          grpc::ClientContext* context, bool start, void* tag)
+      : context_(context), call_(call), started_(start) {
+    if (start) {
+      StartCallInternal(tag);
+    } else {
+      GPR_CODEGEN_ASSERT(tag == nullptr);
+    }
+  }
+
+  void StartCallInternal(void* tag) {
+    write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                   context_->initial_metadata_flags());
+    // if corked bit is set in context, we just keep the initial metadata
+    // buffered up to coalesce with later message send. No op is performed.
+    if (!context_->initial_metadata_corked_) {
+      write_ops_.set_output_tag(tag);
+      call_.PerformOps(&write_ops_);
+    }
+  }
+
+  grpc::ClientContext* context_;
+  grpc::internal::Call call_;
+  bool started_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
+      meta_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                            grpc::internal::CallOpRecvMessage<R>>
+      read_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpClientSendClose>
+      write_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                            grpc::internal::CallOpClientRecvStatus>
+      finish_ops_;
+};
+
+template <class W, class R>
+class ServerAsyncReaderInterface
+    : public grpc::internal::ServerAsyncStreamingInterface,
+      public internal::AsyncReaderInterface<R> {
+ public:
+  /// Indicate that the stream is to be finished with a certain status code
+  /// and also send out \a msg response to the client.
+  /// Request notification for when the server has sent the response and the
+  /// appropriate signals to the client to end the call.
+  /// Should not be used concurrently with other operations.
+  ///
+  /// It is appropriate to call this method when:
+  ///   * all messages from the client have been received (either known
+  ///     implictly, or explicitly because a previous
+  ///     \a AsyncReaderInterface::Read operation with a non-ok result,
+  ///     e.g., cq->Next(&read_tag, &ok) filled in 'ok' with 'false').
+  ///
+  /// This operation will end when the server has finished sending out initial
+  /// metadata (if not sent already), response message, and status, or if
+  /// some failure occurred when trying to do so.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a msg or \a status, so it
+  /// is safe to deallocate once Finish returns.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  /// \param[in] status To be sent to the client as the result of this call.
+  /// \param[in] msg To be sent to the client as the response for this call.
+  virtual void Finish(const W& msg, const grpc::Status& status, void* tag) = 0;
+
+  /// Indicate that the stream is to be finished with a certain
+  /// non-OK status code.
+  /// Request notification for when the server has sent the appropriate
+  /// signals to the client to end the call.
+  /// Should not be used concurrently with other operations.
+  ///
+  /// This call is meant to end the call with some error, and can be called at
+  /// any point that the server would like to "fail" the call (though note
+  /// this shouldn't be called concurrently with any other "sending" call, like
+  /// \a AsyncWriterInterface::Write).
+  ///
+  /// This operation will end when the server has finished sending out initial
+  /// metadata (if not sent already), and status, or if some failure occurred
+  /// when trying to do so.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+  /// to deallocate once FinishWithError returns.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  /// \param[in] status To be sent to the client as the result of this call.
+  ///     - Note: \a status must have a non-OK code.
+  virtual void FinishWithError(const grpc::Status& status, void* tag) = 0;
+};
+
+/// Async server-side API for doing client-streaming RPCs,
+/// where the incoming message stream from the client has messages of type \a R,
+/// and the single response message sent from the server is type \a W.
+template <class W, class R>
+class ServerAsyncReader final : public ServerAsyncReaderInterface<W, R> {
+ public:
+  explicit ServerAsyncReader(grpc::ServerContext* ctx)
+      : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
+
+  /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
+  ///
+  /// Implicit input parameter:
+  ///   - The initial metadata that will be sent to the client from this op will
+  ///     be taken from the \a ServerContext associated with the call.
+  void SendInitialMetadata(void* tag) override {
+    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+    meta_ops_.set_output_tag(tag);
+    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                  ctx_->initial_metadata_flags());
+    if (ctx_->compression_level_set()) {
+      meta_ops_.set_compression_level(ctx_->compression_level());
+    }
+    ctx_->sent_initial_metadata_ = true;
+    call_.PerformOps(&meta_ops_);
+  }
+
+  void Read(R* msg, void* tag) override {
+    read_ops_.set_output_tag(tag);
+    read_ops_.RecvMessage(msg);
+    call_.PerformOps(&read_ops_);
+  }
+
+  /// See the \a ServerAsyncReaderInterface.Read method for semantics
+  ///
+  /// Side effect:
+  ///   - also sends initial metadata if not alreay sent.
+  ///   - uses the \a ServerContext associated with this call to send possible
+  ///     initial and trailing metadata.
+  ///
+  /// Note: \a msg is not sent if \a status has a non-OK code.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+  /// is safe to deallocate once Finish returns.
+  void Finish(const W& msg, const grpc::Status& status, void* tag) override {
+    finish_ops_.set_output_tag(tag);
+    if (!ctx_->sent_initial_metadata_) {
+      finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                      ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        finish_ops_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+    }
+    // The response is dropped if the status is not OK.
+    if (status.ok()) {
+      finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_,
+                                   finish_ops_.SendMessage(msg));
+    } else {
+      finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+    }
+    call_.PerformOps(&finish_ops_);
+  }
+
+  /// See the \a ServerAsyncReaderInterface.Read method for semantics
+  ///
+  /// Side effect:
+  ///   - also sends initial metadata if not alreay sent.
+  ///   - uses the \a ServerContext associated with this call to send possible
+  ///     initial and trailing metadata.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+  /// to deallocate once FinishWithError returns.
+  void FinishWithError(const grpc::Status& status, void* tag) override {
+    GPR_CODEGEN_ASSERT(!status.ok());
+    finish_ops_.set_output_tag(tag);
+    if (!ctx_->sent_initial_metadata_) {
+      finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                      ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        finish_ops_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+    }
+    finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+    call_.PerformOps(&finish_ops_);
+  }
+
+ private:
+  void BindCall(grpc::internal::Call* call) override { call_ = *call; }
+
+  grpc::internal::Call call_;
+  grpc::ServerContext* ctx_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+      meta_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> read_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpServerSendStatus>
+      finish_ops_;
+};
+
+template <class W>
+class ServerAsyncWriterInterface
+    : public grpc::internal::ServerAsyncStreamingInterface,
+      public internal::AsyncWriterInterface<W> {
+ public:
+  /// Indicate that the stream is to be finished with a certain status code.
+  /// Request notification for when the server has sent the appropriate
+  /// signals to the client to end the call.
+  /// Should not be used concurrently with other operations.
+  ///
+  /// It is appropriate to call this method when either:
+  ///   * all messages from the client have been received (either known
+  ///     implictly, or explicitly because a previous \a
+  ///     AsyncReaderInterface::Read operation with a non-ok
+  ///     result (e.g., cq->Next(&read_tag, &ok) filled in 'ok' with 'false'.
+  ///   * it is desired to end the call early with some non-OK status code.
+  ///
+  /// This operation will end when the server has finished sending out initial
+  /// metadata (if not sent already), response message, and status, or if
+  /// some failure occurred when trying to do so.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+  /// to deallocate once Finish returns.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  /// \param[in] status To be sent to the client as the result of this call.
+  virtual void Finish(const grpc::Status& status, void* tag) = 0;
+
+  /// Request the writing of \a msg and coalesce it with trailing metadata which
+  /// contains \a status, using WriteOptions options with
+  /// identifying tag \a tag.
+  ///
+  /// WriteAndFinish is equivalent of performing WriteLast and Finish
+  /// in a single step.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+  /// is safe to deallocate once WriteAndFinish returns.
+  ///
+  /// \param[in] msg The message to be written.
+  /// \param[in] options The WriteOptions to be used to write this message.
+  /// \param[in] status The Status that server returns to client.
+  /// \param[in] tag The tag identifying the operation.
+  virtual void WriteAndFinish(const W& msg, grpc::WriteOptions options,
+                              const grpc::Status& status, void* tag) = 0;
+};
+
+/// Async server-side API for doing server streaming RPCs,
+/// where the outgoing message stream from the server has messages of type \a W.
+template <class W>
+class ServerAsyncWriter final : public ServerAsyncWriterInterface<W> {
+ public:
+  explicit ServerAsyncWriter(grpc::ServerContext* ctx)
+      : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
+
+  /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
+  ///
+  /// Implicit input parameter:
+  ///   - The initial metadata that will be sent to the client from this op will
+  ///     be taken from the \a ServerContext associated with the call.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  void SendInitialMetadata(void* tag) override {
+    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+    meta_ops_.set_output_tag(tag);
+    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                  ctx_->initial_metadata_flags());
+    if (ctx_->compression_level_set()) {
+      meta_ops_.set_compression_level(ctx_->compression_level());
+    }
+    ctx_->sent_initial_metadata_ = true;
+    call_.PerformOps(&meta_ops_);
+  }
+
+  void Write(const W& msg, void* tag) override {
+    write_ops_.set_output_tag(tag);
+    EnsureInitialMetadataSent(&write_ops_);
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
+    call_.PerformOps(&write_ops_);
+  }
+
+  void Write(const W& msg, grpc::WriteOptions options, void* tag) override {
+    write_ops_.set_output_tag(tag);
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+    }
+
+    EnsureInitialMetadataSent(&write_ops_);
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+    call_.PerformOps(&write_ops_);
+  }
+
+  /// See the \a ServerAsyncWriterInterface.WriteAndFinish method for semantics.
+  ///
+  /// Implicit input parameter:
+  ///   - the \a ServerContext associated with this call is used
+  ///     for sending trailing (and initial) metadata to the client.
+  ///
+  /// Note: \a status must have an OK code.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+  /// is safe to deallocate once WriteAndFinish returns.
+  void WriteAndFinish(const W& msg, grpc::WriteOptions options,
+                      const grpc::Status& status, void* tag) override {
+    write_ops_.set_output_tag(tag);
+    EnsureInitialMetadataSent(&write_ops_);
+    options.set_buffer_hint();
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+    write_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+    call_.PerformOps(&write_ops_);
+  }
+
+  /// See the \a ServerAsyncWriterInterface.Finish method for semantics.
+  ///
+  /// Implicit input parameter:
+  ///   - the \a ServerContext associated with this call is used for sending
+  ///     trailing (and initial if not already sent) metadata to the client.
+  ///
+  /// Note: there are no restrictions are the code of
+  /// \a status,it may be non-OK
+  ///
+  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+  /// to deallocate once Finish returns.
+  void Finish(const grpc::Status& status, void* tag) override {
+    finish_ops_.set_output_tag(tag);
+    EnsureInitialMetadataSent(&finish_ops_);
+    finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+    call_.PerformOps(&finish_ops_);
+  }
+
+ private:
+  void BindCall(grpc::internal::Call* call) override { call_ = *call; }
+
+  template <class T>
+  void EnsureInitialMetadataSent(T* ops) {
+    if (!ctx_->sent_initial_metadata_) {
+      ops->SendInitialMetadata(&ctx_->initial_metadata_,
+                               ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        ops->set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+    }
+  }
+
+  grpc::internal::Call call_;
+  grpc::ServerContext* ctx_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+      meta_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpServerSendStatus>
+      write_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpServerSendStatus>
+      finish_ops_;
+};
+
+/// Server-side interface for asynchronous bi-directional streaming.
+template <class W, class R>
+class ServerAsyncReaderWriterInterface
+    : public grpc::internal::ServerAsyncStreamingInterface,
+      public internal::AsyncWriterInterface<W>,
+      public internal::AsyncReaderInterface<R> {
+ public:
+  /// Indicate that the stream is to be finished with a certain status code.
+  /// Request notification for when the server has sent the appropriate
+  /// signals to the client to end the call.
+  /// Should not be used concurrently with other operations.
+  ///
+  /// It is appropriate to call this method when either:
+  ///   * all messages from the client have been received (either known
+  ///     implictly, or explicitly because a previous \a
+  ///     AsyncReaderInterface::Read operation
+  ///     with a non-ok result (e.g., cq->Next(&read_tag, &ok) filled in 'ok'
+  ///     with 'false'.
+  ///   * it is desired to end the call early with some non-OK status code.
+  ///
+  /// This operation will end when the server has finished sending out initial
+  /// metadata (if not sent already), response message, and status, or if some
+  /// failure occurred when trying to do so.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+  /// to deallocate once Finish returns.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  /// \param[in] status To be sent to the client as the result of this call.
+  virtual void Finish(const grpc::Status& status, void* tag) = 0;
+
+  /// Request the writing of \a msg and coalesce it with trailing metadata which
+  /// contains \a status, using WriteOptions options with
+  /// identifying tag \a tag.
+  ///
+  /// WriteAndFinish is equivalent of performing WriteLast and Finish in a
+  /// single step.
+  ///
+  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+  /// is safe to deallocate once WriteAndFinish returns.
+  ///
+  /// \param[in] msg The message to be written.
+  /// \param[in] options The WriteOptions to be used to write this message.
+  /// \param[in] status The Status that server returns to client.
+  /// \param[in] tag The tag identifying the operation.
+  virtual void WriteAndFinish(const W& msg, grpc::WriteOptions options,
+                              const grpc::Status& status, void* tag) = 0;
+};
+
+/// Async server-side API for doing bidirectional streaming RPCs,
+/// where the incoming message stream coming from the client has messages of
+/// type \a R, and the outgoing message stream coming from the server has
+/// messages of type \a W.
+template <class W, class R>
+class ServerAsyncReaderWriter final
+    : public ServerAsyncReaderWriterInterface<W, R> {
+ public:
+  explicit ServerAsyncReaderWriter(grpc::ServerContext* ctx)
+      : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
+
+  /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
+  ///
+  /// Implicit input parameter:
+  ///   - The initial metadata that will be sent to the client from this op will
+  ///     be taken from the \a ServerContext associated with the call.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  void SendInitialMetadata(void* tag) override {
+    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+    meta_ops_.set_output_tag(tag);
+    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                  ctx_->initial_metadata_flags());
+    if (ctx_->compression_level_set()) {
+      meta_ops_.set_compression_level(ctx_->compression_level());
+    }
+    ctx_->sent_initial_metadata_ = true;
+    call_.PerformOps(&meta_ops_);
+  }
+
+  void Read(R* msg, void* tag) override {
+    read_ops_.set_output_tag(tag);
+    read_ops_.RecvMessage(msg);
+    call_.PerformOps(&read_ops_);
+  }
+
+  void Write(const W& msg, void* tag) override {
+    write_ops_.set_output_tag(tag);
+    EnsureInitialMetadataSent(&write_ops_);
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
+    call_.PerformOps(&write_ops_);
+  }
+
+  void Write(const W& msg, grpc::WriteOptions options, void* tag) override {
+    write_ops_.set_output_tag(tag);
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+    }
+    EnsureInitialMetadataSent(&write_ops_);
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+    call_.PerformOps(&write_ops_);
+  }
+
+  /// See the \a ServerAsyncReaderWriterInterface.WriteAndFinish
+  /// method for semantics.
+  ///
+  /// Implicit input parameter:
+  ///   - the \a ServerContext associated with this call is used
+  ///     for sending trailing (and initial) metadata to the client.
+  ///
+  /// Note: \a status must have an OK code.
+  //
+  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+  /// is safe to deallocate once WriteAndFinish returns.
+  void WriteAndFinish(const W& msg, grpc::WriteOptions options,
+                      const grpc::Status& status, void* tag) override {
+    write_ops_.set_output_tag(tag);
+    EnsureInitialMetadataSent(&write_ops_);
+    options.set_buffer_hint();
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+    write_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+    call_.PerformOps(&write_ops_);
+  }
+
+  /// See the \a ServerAsyncReaderWriterInterface.Finish method for semantics.
+  ///
+  /// Implicit input parameter:
+  ///   - the \a ServerContext associated with this call is used for sending
+  ///     trailing (and initial if not already sent) metadata to the client.
+  ///
+  /// Note: there are no restrictions are the code of \a status,
+  /// it may be non-OK
+  //
+  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+  /// to deallocate once Finish returns.
+  void Finish(const grpc::Status& status, void* tag) override {
+    finish_ops_.set_output_tag(tag);
+    EnsureInitialMetadataSent(&finish_ops_);
+
+    finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+    call_.PerformOps(&finish_ops_);
+  }
+
+ private:
+  friend class grpc::Server;
+
+  void BindCall(grpc::internal::Call* call) override { call_ = *call; }
+
+  template <class T>
+  void EnsureInitialMetadataSent(T* ops) {
+    if (!ctx_->sent_initial_metadata_) {
+      ops->SendInitialMetadata(&ctx_->initial_metadata_,
+                               ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        ops->set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+    }
+  }
+
+  grpc::internal::Call call_;
+  grpc::ServerContext* ctx_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+      meta_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> read_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpServerSendStatus>
+      write_ops_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpServerSendStatus>
+      finish_ops_;
+};
+
+}  // namespace grpc
+#endif  // GRPCPP_IMPL_CODEGEN_ASYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_unary_call.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_unary_call.h
new file mode 100644
index 0000000..0034d21
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_unary_call.h
@@ -0,0 +1,420 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
+#define GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
+
+// IWYU pragma: private, include <grpcpp/support/async_unary_call.h>
+
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/call_op_set.h>
+#include <grpcpp/impl/codegen/call_op_set_interface.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+
+// Forward declaration for use in Helper class
+template <class R>
+class ClientAsyncResponseReader;
+
+/// An interface relevant for async client side unary RPCs (which send
+/// one request message to a server and receive one response message).
+template <class R>
+class ClientAsyncResponseReaderInterface {
+ public:
+  virtual ~ClientAsyncResponseReaderInterface() {}
+
+  /// Start the call that was set up by the constructor, but only if the
+  /// constructor was invoked through the "Prepare" API which doesn't actually
+  /// start the call
+  virtual void StartCall() = 0;
+
+  /// Request notification of the reading of initial metadata. Completion
+  /// will be notified by \a tag on the associated completion queue.
+  /// This call is optional, but if it is used, it cannot be used concurrently
+  /// with or after the \a Finish method.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  virtual void ReadInitialMetadata(void* tag) = 0;
+
+  /// Request to receive the server's response \a msg and final \a status for
+  /// the call, and to notify \a tag on this call's completion queue when
+  /// finished.
+  ///
+  /// This function will return when either:
+  /// - when the server's response message and status have been received.
+  /// - when the server has returned a non-OK status (no message expected in
+  ///   this case).
+  /// - when the call failed for some reason and the library generated a
+  ///   non-OK status.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  /// \param[out] status To be updated with the operation status.
+  /// \param[out] msg To be filled in with the server's response message.
+  virtual void Finish(R* msg, grpc::Status* status, void* tag) = 0;
+};
+
+namespace internal {
+
+class ClientAsyncResponseReaderHelper {
+ public:
+  /// Start a call and write the request out if \a start is set.
+  /// \a tag will be notified on \a cq when the call has been started (i.e.
+  /// intitial metadata sent) and \a request has been written out.
+  /// If \a start is not set, the actual call must be initiated by StartCall
+  /// Note that \a context will be used to fill in custom initial metadata
+  /// used to send to the server when starting the call.
+  ///
+  /// Optionally pass in a base class for request and response types so that the
+  /// internal functions and structs can be templated based on that, allowing
+  /// reuse across RPCs (e.g., MessageLite for protobuf). Since constructors
+  /// can't have an explicit template parameter, the last argument is an
+  /// extraneous parameter just to provide the needed type information.
+  template <class R, class W, class BaseR = R, class BaseW = W>
+  static ClientAsyncResponseReader<R>* Create(
+      grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
+      const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
+      const W& request) /* __attribute__((noinline)) */ {
+    grpc::internal::Call call = channel->CreateCall(method, context, cq);
+    ClientAsyncResponseReader<R>* result =
+        new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+            call.call(), sizeof(ClientAsyncResponseReader<R>)))
+            ClientAsyncResponseReader<R>(call, context);
+    SetupRequest<BaseR, BaseW>(
+        call.call(), &result->single_buf_, &result->read_initial_metadata_,
+        &result->finish_, static_cast<const BaseW&>(request));
+
+    return result;
+  }
+
+  // Various helper functions to reduce templating use
+
+  template <class R, class W>
+  static void SetupRequest(
+      grpc_call* call,
+      grpc::internal::CallOpSendInitialMetadata** single_buf_ptr,
+      std::function<void(ClientContext*, internal::Call*,
+                         internal::CallOpSendInitialMetadata*, void*)>*
+          read_initial_metadata,
+      std::function<
+          void(ClientContext*, internal::Call*, bool initial_metadata_read,
+               internal::CallOpSendInitialMetadata*,
+               internal::CallOpSetInterface**, void*, Status*, void*)>* finish,
+      const W& request) {
+    using SingleBufType =
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                                  grpc::internal::CallOpSendMessage,
+                                  grpc::internal::CallOpClientSendClose,
+                                  grpc::internal::CallOpRecvInitialMetadata,
+                                  grpc::internal::CallOpRecvMessage<R>,
+                                  grpc::internal::CallOpClientRecvStatus>;
+    SingleBufType* single_buf =
+        new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+            call, sizeof(SingleBufType))) SingleBufType;
+    *single_buf_ptr = single_buf;
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(single_buf->SendMessage(request).ok());
+    single_buf->ClientSendClose();
+
+    // The purpose of the following functions is to type-erase the actual
+    // templated type of the CallOpSet being used by hiding that type inside the
+    // function definition rather than specifying it as an argument of the
+    // function or a member of the class. The type-erased CallOpSet will get
+    // static_cast'ed back to the real type so that it can be used properly.
+    *read_initial_metadata =
+        [](ClientContext* context, internal::Call* call,
+           internal::CallOpSendInitialMetadata* single_buf_view, void* tag) {
+          auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
+          single_buf->set_output_tag(tag);
+          single_buf->RecvInitialMetadata(context);
+          call->PerformOps(single_buf);
+        };
+
+    // Note that this function goes one step further than the previous one
+    // because it type-erases the message being written down to a void*. This
+    // will be static-cast'ed back to the class specified here by hiding that
+    // class information inside the function definition. Note that this feature
+    // expects the class being specified here for R to be a base-class of the
+    // "real" R without any multiple-inheritance (as applies in protbuf wrt
+    // MessageLite)
+    *finish = [](ClientContext* context, internal::Call* call,
+                 bool initial_metadata_read,
+                 internal::CallOpSendInitialMetadata* single_buf_view,
+                 internal::CallOpSetInterface** finish_buf_ptr, void* msg,
+                 Status* status, void* tag) {
+      if (initial_metadata_read) {
+        using FinishBufType =
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>,
+                                      grpc::internal::CallOpClientRecvStatus>;
+        FinishBufType* finish_buf =
+            new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                call->call(), sizeof(FinishBufType))) FinishBufType;
+        *finish_buf_ptr = finish_buf;
+        finish_buf->set_output_tag(tag);
+        finish_buf->RecvMessage(static_cast<R*>(msg));
+        finish_buf->AllowNoMessage();
+        finish_buf->ClientRecvStatus(context, status);
+        call->PerformOps(finish_buf);
+      } else {
+        auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
+        single_buf->set_output_tag(tag);
+        single_buf->RecvInitialMetadata(context);
+        single_buf->RecvMessage(static_cast<R*>(msg));
+        single_buf->AllowNoMessage();
+        single_buf->ClientRecvStatus(context, status);
+        call->PerformOps(single_buf);
+      }
+    };
+  }
+
+  static void StartCall(grpc::ClientContext* context,
+                        grpc::internal::CallOpSendInitialMetadata* single_buf) {
+    single_buf->SendInitialMetadata(&context->send_initial_metadata_,
+                                    context->initial_metadata_flags());
+  }
+};
+
+// TODO(vjpai): This templated factory is deprecated and will be replaced by
+//.             the non-templated helper as soon as possible.
+template <class R>
+class ClientAsyncResponseReaderFactory {
+ public:
+  template <class W>
+  static ClientAsyncResponseReader<R>* Create(
+      grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
+      const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
+      const W& request, bool start) {
+    auto* result = ClientAsyncResponseReaderHelper::Create<R>(
+        channel, cq, method, context, request);
+    if (start) {
+      result->StartCall();
+    }
+    return result;
+  }
+};
+
+}  // namespace internal
+
+/// Async API for client-side unary RPCs, where the message response
+/// received from the server is of type \a R.
+template <class R>
+class ClientAsyncResponseReader final
+    : public ClientAsyncResponseReaderInterface<R> {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncResponseReader));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  void StartCall() override {
+    GPR_CODEGEN_DEBUG_ASSERT(!started_);
+    started_ = true;
+    internal::ClientAsyncResponseReaderHelper::StartCall(context_, single_buf_);
+  }
+
+  /// See \a ClientAsyncResponseReaderInterface::ReadInitialMetadata for
+  /// semantics.
+  ///
+  /// Side effect:
+  ///   - the \a ClientContext associated with this call is updated with
+  ///     possible initial and trailing metadata sent from the server.
+  void ReadInitialMetadata(void* tag) override {
+    GPR_CODEGEN_DEBUG_ASSERT(started_);
+    GPR_CODEGEN_DEBUG_ASSERT(!context_->initial_metadata_received_);
+    read_initial_metadata_(context_, &call_, single_buf_, tag);
+    initial_metadata_read_ = true;
+  }
+
+  /// See \a ClientAsyncResponseReaderInterface::Finish for semantics.
+  ///
+  /// Side effect:
+  ///   - the \a ClientContext associated with this call is updated with
+  ///     possible initial and trailing metadata sent from the server.
+  void Finish(R* msg, grpc::Status* status, void* tag) override {
+    GPR_CODEGEN_DEBUG_ASSERT(started_);
+    finish_(context_, &call_, initial_metadata_read_, single_buf_, &finish_buf_,
+            static_cast<void*>(msg), status, tag);
+  }
+
+ private:
+  friend class internal::ClientAsyncResponseReaderHelper;
+  grpc::ClientContext* const context_;
+  grpc::internal::Call call_;
+  bool started_ = false;
+  bool initial_metadata_read_ = false;
+
+  ClientAsyncResponseReader(grpc::internal::Call call,
+                            grpc::ClientContext* context)
+      : context_(context), call_(call) {}
+
+  // disable operator new
+  static void* operator new(std::size_t size);
+  static void* operator new(std::size_t /*size*/, void* p) { return p; }
+
+  internal::CallOpSendInitialMetadata* single_buf_;
+  internal::CallOpSetInterface* finish_buf_ = nullptr;
+  std::function<void(ClientContext*, internal::Call*,
+                     internal::CallOpSendInitialMetadata*, void*)>
+      read_initial_metadata_;
+  std::function<void(ClientContext*, internal::Call*,
+                     bool initial_metadata_read,
+                     internal::CallOpSendInitialMetadata*,
+                     internal::CallOpSetInterface**, void*, Status*, void*)>
+      finish_;
+};
+
+/// Async server-side API for handling unary calls, where the single
+/// response message sent to the client is of type \a W.
+template <class W>
+class ServerAsyncResponseWriter final
+    : public grpc::internal::ServerAsyncStreamingInterface {
+ public:
+  explicit ServerAsyncResponseWriter(grpc::ServerContext* ctx)
+      : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
+
+  /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
+  ///
+  /// Side effect:
+  ///   The initial metadata that will be sent to the client from this op will
+  ///   be taken from the \a ServerContext associated with the call.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  void SendInitialMetadata(void* tag) override {
+    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+    meta_buf_.set_output_tag(tag);
+    meta_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                  ctx_->initial_metadata_flags());
+    if (ctx_->compression_level_set()) {
+      meta_buf_.set_compression_level(ctx_->compression_level());
+    }
+    ctx_->sent_initial_metadata_ = true;
+    call_.PerformOps(&meta_buf_);
+  }
+
+  /// Indicate that the stream is to be finished and request notification
+  /// when the server has sent the appropriate signals to the client to
+  /// end the call. Should not be used concurrently with other operations.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  /// \param[in] status To be sent to the client as the result of the call.
+  /// \param[in] msg Message to be sent to the client.
+  ///
+  /// Side effect:
+  ///   - also sends initial metadata if not already sent (using the
+  ///     \a ServerContext associated with this call).
+  ///
+  /// Note: if \a status has a non-OK code, then \a msg will not be sent,
+  /// and the client will receive only the status with possible trailing
+  /// metadata.
+  ///
+  /// gRPC doesn't take ownership or a reference to msg and status, so it is
+  /// safe to deallocate them once the Finish operation is complete (i.e. a
+  /// result arrives in the completion queue).
+  void Finish(const W& msg, const grpc::Status& status, void* tag) {
+    finish_buf_.set_output_tag(tag);
+    finish_buf_.set_core_cq_tag(&finish_buf_);
+    if (!ctx_->sent_initial_metadata_) {
+      finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                      ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        finish_buf_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+    }
+    // The response is dropped if the status is not OK.
+    if (status.ok()) {
+      finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_,
+                                   finish_buf_.SendMessage(msg));
+    } else {
+      finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+    }
+    call_.PerformOps(&finish_buf_);
+  }
+
+  /// Indicate that the stream is to be finished with a non-OK status,
+  /// and request notification for when the server has finished sending the
+  /// appropriate signals to the client to end the call.
+  /// Should not be used concurrently with other operations.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  /// \param[in] status To be sent to the client as the result of the call.
+  ///   - Note: \a status must have a non-OK code.
+  ///
+  /// Side effect:
+  ///   - also sends initial metadata if not already sent (using the
+  ///     \a ServerContext associated with this call).
+  ///
+  /// gRPC doesn't take ownership or a reference to status, so it is safe to
+  /// deallocate them once the Finish operation is complete (i.e. a result
+  /// arrives in the completion queue).
+  void FinishWithError(const grpc::Status& status, void* tag) {
+    GPR_CODEGEN_ASSERT(!status.ok());
+    finish_buf_.set_output_tag(tag);
+    if (!ctx_->sent_initial_metadata_) {
+      finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                      ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        finish_buf_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+    }
+    finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+    call_.PerformOps(&finish_buf_);
+  }
+
+ private:
+  void BindCall(grpc::internal::Call* call) override { call_ = *call; }
+
+  grpc::internal::Call call_;
+  grpc::ServerContext* ctx_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+      meta_buf_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpServerSendStatus>
+      finish_buf_;
+};
+
+}  // namespace grpc
+
+namespace std {
+template <class R>
+class default_delete<grpc::ClientAsyncResponseReader<R>> {
+ public:
+  void operator()(void* /*p*/) {}
+};
+template <class R>
+class default_delete<grpc::ClientAsyncResponseReaderInterface<R>> {
+ public:
+  void operator()(void* /*p*/) {}
+};
+}  // namespace std
+
+#endif  // GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/byte_buffer.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/byte_buffer.h
new file mode 100644
index 0000000..a9ba7d1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/byte_buffer.h
@@ -0,0 +1,239 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_BYTE_BUFFER_H
+#define GRPCPP_IMPL_CODEGEN_BYTE_BUFFER_H
+
+// IWYU pragma: private, include <grpcpp/support/byte_buffer.h>
+
+#include <vector>
+
+#include <grpc/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/serialization_traits.h>
+#include <grpcpp/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+
+class ServerInterface;
+class ByteBuffer;
+class ServerInterface;
+
+namespace internal {
+template <class RequestType, class ResponseType>
+class CallbackUnaryHandler;
+template <class RequestType, class ResponseType>
+class CallbackServerStreamingHandler;
+template <class RequestType>
+void* UnaryDeserializeHelper(grpc_byte_buffer*, grpc::Status*, RequestType*);
+template <class ServiceType, class RequestType, class ResponseType>
+class ServerStreamingHandler;
+template <grpc::StatusCode code>
+class ErrorMethodHandler;
+class CallOpSendMessage;
+template <class R>
+class CallOpRecvMessage;
+class CallOpGenericRecvMessage;
+class ExternalConnectionAcceptorImpl;
+template <class R>
+class DeserializeFuncType;
+class GrpcByteBufferPeer;
+
+}  // namespace internal
+/// A sequence of bytes.
+class ByteBuffer final {
+ public:
+  /// Constuct an empty buffer.
+  ByteBuffer() : buffer_(nullptr) {}
+
+  /// Construct buffer from \a slices, of which there are \a nslices.
+  ByteBuffer(const Slice* slices, size_t nslices) {
+    // The following assertions check that the representation of a grpc::Slice
+    // is identical to that of a grpc_slice:  it has a grpc_slice field, and
+    // nothing else.
+    static_assert(std::is_same<decltype(slices[0].slice_), grpc_slice>::value,
+                  "Slice must have same representation as grpc_slice");
+    static_assert(sizeof(Slice) == sizeof(grpc_slice),
+                  "Slice must have same representation as grpc_slice");
+    // The following assertions check that the representation of a ByteBuffer is
+    // identical to grpc_byte_buffer*:  it has a grpc_byte_buffer* field,
+    // and nothing else.
+    static_assert(std::is_same<decltype(buffer_), grpc_byte_buffer*>::value,
+                  "ByteBuffer must have same representation as "
+                  "grpc_byte_buffer*");
+    static_assert(sizeof(ByteBuffer) == sizeof(grpc_byte_buffer*),
+                  "ByteBuffer must have same representation as "
+                  "grpc_byte_buffer*");
+    // The const_cast is legal if grpc_raw_byte_buffer_create() does no more
+    // than its advertised side effect of increasing the reference count of the
+    // slices it processes, and such an increase does not affect the semantics
+    // seen by the caller of this constructor.
+    buffer_ = g_core_codegen_interface->grpc_raw_byte_buffer_create(
+        reinterpret_cast<grpc_slice*>(const_cast<Slice*>(slices)), nslices);
+  }
+
+  /// Constuct a byte buffer by referencing elements of existing buffer
+  /// \a buf. Wrapper of core function grpc_byte_buffer_copy . This is not
+  /// a deep copy; it is just a referencing. As a result, its performance is
+  /// size-independent.
+  ByteBuffer(const ByteBuffer& buf) : buffer_(nullptr) { operator=(buf); }
+
+  ~ByteBuffer() {
+    if (buffer_) {
+      g_core_codegen_interface->grpc_byte_buffer_destroy(buffer_);
+    }
+  }
+
+  /// Wrapper of core function grpc_byte_buffer_copy . This is not
+  /// a deep copy; it is just a referencing. As a result, its performance is
+  /// size-independent.
+  ByteBuffer& operator=(const ByteBuffer& buf) {
+    if (this != &buf) {
+      Clear();  // first remove existing data
+    }
+    if (buf.buffer_) {
+      // then copy
+      buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buf.buffer_);
+    }
+    return *this;
+  }
+
+  // If this ByteBuffer's representation is a single flat slice, returns a
+  // slice referencing that array.
+  Status TrySingleSlice(Slice* slice) const;
+
+  /// Dump (read) the buffer contents into \a slics.
+  Status DumpToSingleSlice(Slice* slice) const;
+
+  /// Dump (read) the buffer contents into \a slices.
+  Status Dump(std::vector<Slice>* slices) const;
+
+  /// Remove all data.
+  void Clear() {
+    if (buffer_) {
+      g_core_codegen_interface->grpc_byte_buffer_destroy(buffer_);
+      buffer_ = nullptr;
+    }
+  }
+
+  /// Make a duplicate copy of the internals of this byte
+  /// buffer so that we have our own owned version of it.
+  /// bbuf.Duplicate(); is equivalent to bbuf=bbuf; but is actually readable.
+  /// This is not a deep copy; it is a referencing and its performance
+  /// is size-independent.
+  void Duplicate() {
+    buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buffer_);
+  }
+
+  /// Forget underlying byte buffer without destroying
+  /// Use this only for un-owned byte buffers
+  void Release() { buffer_ = nullptr; }
+
+  /// Buffer size in bytes.
+  size_t Length() const {
+    return buffer_ == nullptr
+               ? 0
+               : g_core_codegen_interface->grpc_byte_buffer_length(buffer_);
+  }
+
+  /// Swap the state of *this and *other.
+  void Swap(ByteBuffer* other) {
+    grpc_byte_buffer* tmp = other->buffer_;
+    other->buffer_ = buffer_;
+    buffer_ = tmp;
+  }
+
+  /// Is this ByteBuffer valid?
+  bool Valid() const { return (buffer_ != nullptr); }
+
+ private:
+  friend class SerializationTraits<ByteBuffer, void>;
+  friend class ServerInterface;
+  friend class internal::CallOpSendMessage;
+  template <class R>
+  friend class internal::CallOpRecvMessage;
+  friend class internal::CallOpGenericRecvMessage;
+  template <class RequestType>
+  friend void* internal::UnaryDeserializeHelper(grpc_byte_buffer*,
+                                                grpc::Status*, RequestType*);
+  template <class ServiceType, class RequestType, class ResponseType>
+  friend class internal::ServerStreamingHandler;
+  template <class RequestType, class ResponseType>
+  friend class internal::CallbackUnaryHandler;
+  template <class RequestType, class ResponseType>
+  friend class internal::CallbackServerStreamingHandler;
+  template <StatusCode code>
+  friend class internal::ErrorMethodHandler;
+  template <class R>
+  friend class internal::DeserializeFuncType;
+  friend class ProtoBufferReader;
+  friend class ProtoBufferWriter;
+  friend class internal::GrpcByteBufferPeer;
+  friend class internal::ExternalConnectionAcceptorImpl;
+
+  grpc_byte_buffer* buffer_;
+
+  // takes ownership
+  void set_buffer(grpc_byte_buffer* buf) {
+    if (buffer_) {
+      Clear();
+    }
+    buffer_ = buf;
+  }
+
+  grpc_byte_buffer* c_buffer() { return buffer_; }
+  grpc_byte_buffer** c_buffer_ptr() { return &buffer_; }
+
+  class ByteBufferPointer {
+   public:
+    /* NOLINTNEXTLINE(google-explicit-constructor) */
+    ByteBufferPointer(const ByteBuffer* b)
+        : bbuf_(const_cast<ByteBuffer*>(b)) {}
+    /* NOLINTNEXTLINE(google-explicit-constructor) */
+    operator ByteBuffer*() { return bbuf_; }
+    /* NOLINTNEXTLINE(google-explicit-constructor) */
+    operator grpc_byte_buffer*() { return bbuf_->buffer_; }
+    /* NOLINTNEXTLINE(google-explicit-constructor) */
+    operator grpc_byte_buffer**() { return &bbuf_->buffer_; }
+
+   private:
+    ByteBuffer* bbuf_;
+  };
+  ByteBufferPointer bbuf_ptr() const { return ByteBufferPointer(this); }
+};
+
+template <>
+class SerializationTraits<ByteBuffer, void> {
+ public:
+  static Status Deserialize(ByteBuffer* byte_buffer, ByteBuffer* dest) {
+    dest->set_buffer(byte_buffer->buffer_);
+    return Status::OK;
+  }
+  static Status Serialize(const ByteBuffer& source, ByteBuffer* buffer,
+                          bool* own_buffer) {
+    *buffer = source;
+    *own_buffer = true;
+    return g_core_codegen_interface->ok();
+  }
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_BYTE_BUFFER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call.h
new file mode 100644
index 0000000..90d54bc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call.h
@@ -0,0 +1,95 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+#ifndef GRPCPP_IMPL_CODEGEN_CALL_H
+#define GRPCPP_IMPL_CODEGEN_CALL_H
+
+// IWYU pragma: private, include <grpcpp/impl/call.h>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/call_hook.h>
+
+namespace grpc {
+class CompletionQueue;
+namespace experimental {
+class ClientRpcInfo;
+class ServerRpcInfo;
+}  // namespace experimental
+namespace internal {
+class CallHook;
+class CallOpSetInterface;
+
+/// Straightforward wrapping of the C call object
+class Call final {
+ public:
+  Call()
+      : call_hook_(nullptr),
+        cq_(nullptr),
+        call_(nullptr),
+        max_receive_message_size_(-1) {}
+  /** call is owned by the caller */
+  Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq)
+      : call_hook_(call_hook),
+        cq_(cq),
+        call_(call),
+        max_receive_message_size_(-1) {}
+
+  Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq,
+       experimental::ClientRpcInfo* rpc_info)
+      : call_hook_(call_hook),
+        cq_(cq),
+        call_(call),
+        max_receive_message_size_(-1),
+        client_rpc_info_(rpc_info) {}
+
+  Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq,
+       int max_receive_message_size, experimental::ServerRpcInfo* rpc_info)
+      : call_hook_(call_hook),
+        cq_(cq),
+        call_(call),
+        max_receive_message_size_(max_receive_message_size),
+        server_rpc_info_(rpc_info) {}
+
+  void PerformOps(CallOpSetInterface* ops) {
+    call_hook_->PerformOpsOnCall(ops, this);
+  }
+
+  grpc_call* call() const { return call_; }
+  grpc::CompletionQueue* cq() const { return cq_; }
+
+  int max_receive_message_size() const { return max_receive_message_size_; }
+
+  experimental::ClientRpcInfo* client_rpc_info() const {
+    return client_rpc_info_;
+  }
+
+  experimental::ServerRpcInfo* server_rpc_info() const {
+    return server_rpc_info_;
+  }
+
+ private:
+  CallHook* call_hook_;
+  grpc::CompletionQueue* cq_;
+  grpc_call* call_;
+  int max_receive_message_size_;
+  experimental::ClientRpcInfo* client_rpc_info_ = nullptr;
+  experimental::ServerRpcInfo* server_rpc_info_ = nullptr;
+};
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_hook.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_hook.h
new file mode 100644
index 0000000..8c4278e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_hook.h
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CALL_HOOK_H
+#define GRPCPP_IMPL_CODEGEN_CALL_HOOK_H
+
+// IWYU pragma: private
+
+namespace grpc {
+
+namespace internal {
+class CallOpSetInterface;
+class Call;
+
+/// This is an interface that Channel and Server implement to allow them to hook
+/// performing ops.
+class CallHook {
+ public:
+  virtual ~CallHook() {}
+  virtual void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) = 0;
+};
+}  // namespace internal
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CALL_HOOK_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set.h
new file mode 100644
index 0000000..5b1d440
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set.h
@@ -0,0 +1,1045 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
+#define GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
+
+// IWYU pragma: private
+
+#include <cstring>
+#include <map>
+#include <memory>
+
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/call_hook.h>
+#include <grpcpp/impl/codegen/call_op_set_interface.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/completion_queue_tag.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/intercepted_channel.h>
+#include <grpcpp/impl/codegen/interceptor_common.h>
+#include <grpcpp/impl/codegen/serialization_traits.h>
+#include <grpcpp/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/string_ref.h>
+
+namespace grpc {
+
+extern CoreCodegenInterface* g_core_codegen_interface;
+
+namespace internal {
+class Call;
+class CallHook;
+
+// TODO(yangg) if the map is changed before we send, the pointers will be a
+// mess. Make sure it does not happen.
+inline grpc_metadata* FillMetadataArray(
+    const std::multimap<std::string, std::string>& metadata,
+    size_t* metadata_count, const std::string& optional_error_details) {
+  *metadata_count = metadata.size() + (optional_error_details.empty() ? 0 : 1);
+  if (*metadata_count == 0) {
+    return nullptr;
+  }
+  grpc_metadata* metadata_array =
+      static_cast<grpc_metadata*>(g_core_codegen_interface->gpr_malloc(
+          (*metadata_count) * sizeof(grpc_metadata)));
+  size_t i = 0;
+  for (auto iter = metadata.cbegin(); iter != metadata.cend(); ++iter, ++i) {
+    metadata_array[i].key = SliceReferencingString(iter->first);
+    metadata_array[i].value = SliceReferencingString(iter->second);
+  }
+  if (!optional_error_details.empty()) {
+    metadata_array[i].key =
+        g_core_codegen_interface->grpc_slice_from_static_buffer(
+            kBinaryErrorDetailsKey, sizeof(kBinaryErrorDetailsKey) - 1);
+    metadata_array[i].value = SliceReferencingString(optional_error_details);
+  }
+  return metadata_array;
+}
+}  // namespace internal
+
+/// Per-message write options.
+class WriteOptions {
+ public:
+  WriteOptions() : flags_(0), last_message_(false) {}
+
+  /// Clear all flags.
+  inline void Clear() { flags_ = 0; }
+
+  /// Returns raw flags bitset.
+  inline uint32_t flags() const { return flags_; }
+
+  /// Sets flag for the disabling of compression for the next message write.
+  ///
+  /// \sa GRPC_WRITE_NO_COMPRESS
+  inline WriteOptions& set_no_compression() {
+    SetBit(GRPC_WRITE_NO_COMPRESS);
+    return *this;
+  }
+
+  /// Clears flag for the disabling of compression for the next message write.
+  ///
+  /// \sa GRPC_WRITE_NO_COMPRESS
+  inline WriteOptions& clear_no_compression() {
+    ClearBit(GRPC_WRITE_NO_COMPRESS);
+    return *this;
+  }
+
+  /// Get value for the flag indicating whether compression for the next
+  /// message write is forcefully disabled.
+  ///
+  /// \sa GRPC_WRITE_NO_COMPRESS
+  inline bool get_no_compression() const {
+    return GetBit(GRPC_WRITE_NO_COMPRESS);
+  }
+
+  /// Sets flag indicating that the write may be buffered and need not go out on
+  /// the wire immediately.
+  ///
+  /// \sa GRPC_WRITE_BUFFER_HINT
+  inline WriteOptions& set_buffer_hint() {
+    SetBit(GRPC_WRITE_BUFFER_HINT);
+    return *this;
+  }
+
+  /// Clears flag indicating that the write may be buffered and need not go out
+  /// on the wire immediately.
+  ///
+  /// \sa GRPC_WRITE_BUFFER_HINT
+  inline WriteOptions& clear_buffer_hint() {
+    ClearBit(GRPC_WRITE_BUFFER_HINT);
+    return *this;
+  }
+
+  /// Get value for the flag indicating that the write may be buffered and need
+  /// not go out on the wire immediately.
+  ///
+  /// \sa GRPC_WRITE_BUFFER_HINT
+  inline bool get_buffer_hint() const { return GetBit(GRPC_WRITE_BUFFER_HINT); }
+
+  /// corked bit: aliases set_buffer_hint currently, with the intent that
+  /// set_buffer_hint will be removed in the future
+  inline WriteOptions& set_corked() {
+    SetBit(GRPC_WRITE_BUFFER_HINT);
+    return *this;
+  }
+
+  inline WriteOptions& clear_corked() {
+    ClearBit(GRPC_WRITE_BUFFER_HINT);
+    return *this;
+  }
+
+  inline bool is_corked() const { return GetBit(GRPC_WRITE_BUFFER_HINT); }
+
+  /// last-message bit: indicates this is the last message in a stream
+  /// client-side:  makes Write the equivalent of performing Write, WritesDone
+  /// in a single step
+  /// server-side:  hold the Write until the service handler returns (sync api)
+  /// or until Finish is called (async api)
+  inline WriteOptions& set_last_message() {
+    last_message_ = true;
+    return *this;
+  }
+
+  /// Clears flag indicating that this is the last message in a stream,
+  /// disabling coalescing.
+  inline WriteOptions& clear_last_message() {
+    last_message_ = false;
+    return *this;
+  }
+
+  /// Get value for the flag indicating that this is the last message, and
+  /// should be coalesced with trailing metadata.
+  ///
+  /// \sa GRPC_WRITE_LAST_MESSAGE
+  bool is_last_message() const { return last_message_; }
+
+  /// Guarantee that all bytes have been written to the socket before completing
+  /// this write (usually writes are completed when they pass flow control).
+  inline WriteOptions& set_write_through() {
+    SetBit(GRPC_WRITE_THROUGH);
+    return *this;
+  }
+
+  inline WriteOptions& clear_write_through() {
+    ClearBit(GRPC_WRITE_THROUGH);
+    return *this;
+  }
+
+  inline bool is_write_through() const { return GetBit(GRPC_WRITE_THROUGH); }
+
+ private:
+  void SetBit(const uint32_t mask) { flags_ |= mask; }
+
+  void ClearBit(const uint32_t mask) { flags_ &= ~mask; }
+
+  bool GetBit(const uint32_t mask) const { return (flags_ & mask) != 0; }
+
+  uint32_t flags_;
+  bool last_message_;
+};
+
+namespace internal {
+
+/// Default argument for CallOpSet. The Unused parameter is unused by
+/// the class, but can be used for generating multiple names for the
+/// same thing.
+template <int Unused>
+class CallNoOp {
+ protected:
+  void AddOp(grpc_op* /*ops*/, size_t* /*nops*/) {}
+  void FinishOp(bool* /*status*/) {}
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
+  }
+};
+
+class CallOpSendInitialMetadata {
+ public:
+  CallOpSendInitialMetadata() : send_(false) {
+    maybe_compression_level_.is_set = false;
+  }
+
+  void SendInitialMetadata(std::multimap<std::string, std::string>* metadata,
+                           uint32_t flags) {
+    maybe_compression_level_.is_set = false;
+    send_ = true;
+    flags_ = flags;
+    metadata_map_ = metadata;
+  }
+
+  void set_compression_level(grpc_compression_level level) {
+    maybe_compression_level_.is_set = true;
+    maybe_compression_level_.level = level;
+  }
+
+ protected:
+  void AddOp(grpc_op* ops, size_t* nops) {
+    if (!send_ || hijacked_) return;
+    grpc_op* op = &ops[(*nops)++];
+    op->op = GRPC_OP_SEND_INITIAL_METADATA;
+    op->flags = flags_;
+    op->reserved = nullptr;
+    initial_metadata_ =
+        FillMetadataArray(*metadata_map_, &initial_metadata_count_, "");
+    op->data.send_initial_metadata.count = initial_metadata_count_;
+    op->data.send_initial_metadata.metadata = initial_metadata_;
+    op->data.send_initial_metadata.maybe_compression_level.is_set =
+        maybe_compression_level_.is_set;
+    if (maybe_compression_level_.is_set) {
+      op->data.send_initial_metadata.maybe_compression_level.level =
+          maybe_compression_level_.level;
+    }
+  }
+  void FinishOp(bool* /*status*/) {
+    if (!send_ || hijacked_) return;
+    g_core_codegen_interface->gpr_free(initial_metadata_);
+    send_ = false;
+  }
+
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (!send_) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::PRE_SEND_INITIAL_METADATA);
+    interceptor_methods->SetSendInitialMetadata(metadata_map_);
+  }
+
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
+
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
+    hijacked_ = true;
+  }
+
+  bool hijacked_ = false;
+  bool send_;
+  uint32_t flags_;
+  size_t initial_metadata_count_;
+  std::multimap<std::string, std::string>* metadata_map_;
+  grpc_metadata* initial_metadata_;
+  struct {
+    bool is_set;
+    grpc_compression_level level;
+  } maybe_compression_level_;
+};
+
+class CallOpSendMessage {
+ public:
+  CallOpSendMessage() : send_buf_() {}
+
+  /// Send \a message using \a options for the write. The \a options are cleared
+  /// after use.
+  template <class M>
+  Status SendMessage(const M& message,
+                     WriteOptions options) GRPC_MUST_USE_RESULT;
+
+  template <class M>
+  Status SendMessage(const M& message) GRPC_MUST_USE_RESULT;
+
+  /// Send \a message using \a options for the write. The \a options are cleared
+  /// after use. This form of SendMessage allows gRPC to reference \a message
+  /// beyond the lifetime of SendMessage.
+  template <class M>
+  Status SendMessagePtr(const M* message,
+                        WriteOptions options) GRPC_MUST_USE_RESULT;
+
+  /// This form of SendMessage allows gRPC to reference \a message beyond the
+  /// lifetime of SendMessage.
+  template <class M>
+  Status SendMessagePtr(const M* message) GRPC_MUST_USE_RESULT;
+
+ protected:
+  void AddOp(grpc_op* ops, size_t* nops) {
+    if (msg_ == nullptr && !send_buf_.Valid()) return;
+    if (hijacked_) {
+      serializer_ = nullptr;
+      return;
+    }
+    if (msg_ != nullptr) {
+      GPR_CODEGEN_ASSERT(serializer_(msg_).ok());
+    }
+    serializer_ = nullptr;
+    grpc_op* op = &ops[(*nops)++];
+    op->op = GRPC_OP_SEND_MESSAGE;
+    op->flags = write_options_.flags();
+    op->reserved = nullptr;
+    op->data.send_message.send_message = send_buf_.c_buffer();
+    // Flags are per-message: clear them after use.
+    write_options_.Clear();
+  }
+  void FinishOp(bool* status) {
+    if (msg_ == nullptr && !send_buf_.Valid()) return;
+    send_buf_.Clear();
+    if (hijacked_ && failed_send_) {
+      // Hijacking interceptor failed this Op
+      *status = false;
+    } else if (!*status) {
+      // This Op was passed down to core and the Op failed
+      failed_send_ = true;
+    }
+  }
+
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (msg_ == nullptr && !send_buf_.Valid()) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::PRE_SEND_MESSAGE);
+    interceptor_methods->SetSendMessage(&send_buf_, &msg_, &failed_send_,
+                                        serializer_);
+  }
+
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (msg_ != nullptr || send_buf_.Valid()) {
+      interceptor_methods->AddInterceptionHookPoint(
+          experimental::InterceptionHookPoints::POST_SEND_MESSAGE);
+    }
+    send_buf_.Clear();
+    msg_ = nullptr;
+    // The contents of the SendMessage value that was previously set
+    // has had its references stolen by core's operations
+    interceptor_methods->SetSendMessage(nullptr, nullptr, &failed_send_,
+                                        nullptr);
+  }
+
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
+    hijacked_ = true;
+  }
+
+ private:
+  const void* msg_ = nullptr;  // The original non-serialized message
+  bool hijacked_ = false;
+  bool failed_send_ = false;
+  ByteBuffer send_buf_;
+  WriteOptions write_options_;
+  std::function<Status(const void*)> serializer_;
+};
+
+template <class M>
+Status CallOpSendMessage::SendMessage(const M& message, WriteOptions options) {
+  write_options_ = options;
+  // Serialize immediately since we do not have access to the message pointer
+  bool own_buf;
+  // TODO(vjpai): Remove the void below when possible
+  // The void in the template parameter below should not be needed
+  // (since it should be implicit) but is needed due to an observed
+  // difference in behavior between clang and gcc for certain internal users
+  Status result = SerializationTraits<M, void>::Serialize(
+      message, send_buf_.bbuf_ptr(), &own_buf);
+  if (!own_buf) {
+    send_buf_.Duplicate();
+  }
+  return result;
+}
+
+template <class M>
+Status CallOpSendMessage::SendMessage(const M& message) {
+  return SendMessage(message, WriteOptions());
+}
+
+template <class M>
+Status CallOpSendMessage::SendMessagePtr(const M* message,
+                                         WriteOptions options) {
+  msg_ = message;
+  write_options_ = options;
+  // Store the serializer for later since we have access to the message
+  serializer_ = [this](const void* message) {
+    bool own_buf;
+    // TODO(vjpai): Remove the void below when possible
+    // The void in the template parameter below should not be needed
+    // (since it should be implicit) but is needed due to an observed
+    // difference in behavior between clang and gcc for certain internal users
+    Status result = SerializationTraits<M, void>::Serialize(
+        *static_cast<const M*>(message), send_buf_.bbuf_ptr(), &own_buf);
+    if (!own_buf) {
+      send_buf_.Duplicate();
+    }
+    return result;
+  };
+  return Status();
+}
+
+template <class M>
+Status CallOpSendMessage::SendMessagePtr(const M* message) {
+  return SendMessagePtr(message, WriteOptions());
+}
+
+template <class R>
+class CallOpRecvMessage {
+ public:
+  void RecvMessage(R* message) { message_ = message; }
+
+  // Do not change status if no message is received.
+  void AllowNoMessage() { allow_not_getting_message_ = true; }
+
+  bool got_message = false;
+
+ protected:
+  void AddOp(grpc_op* ops, size_t* nops) {
+    if (message_ == nullptr || hijacked_) return;
+    grpc_op* op = &ops[(*nops)++];
+    op->op = GRPC_OP_RECV_MESSAGE;
+    op->flags = 0;
+    op->reserved = nullptr;
+    op->data.recv_message.recv_message = recv_buf_.c_buffer_ptr();
+  }
+
+  void FinishOp(bool* status) {
+    if (message_ == nullptr) return;
+    if (recv_buf_.Valid()) {
+      if (*status) {
+        got_message = *status =
+            SerializationTraits<R>::Deserialize(recv_buf_.bbuf_ptr(), message_)
+                .ok();
+        recv_buf_.Release();
+      } else {
+        got_message = false;
+        recv_buf_.Clear();
+      }
+    } else if (hijacked_) {
+      if (hijacked_recv_message_failed_) {
+        FinishOpRecvMessageFailureHandler(status);
+      } else {
+        // The op was hijacked and it was successful. There is no further action
+        // to be performed since the message is already in its non-serialized
+        // form.
+      }
+    } else {
+      FinishOpRecvMessageFailureHandler(status);
+    }
+  }
+
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (message_ == nullptr) return;
+    interceptor_methods->SetRecvMessage(message_,
+                                        &hijacked_recv_message_failed_);
+  }
+
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (message_ == nullptr) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::POST_RECV_MESSAGE);
+    if (!got_message) interceptor_methods->SetRecvMessage(nullptr, nullptr);
+  }
+  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
+    hijacked_ = true;
+    if (message_ == nullptr) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::PRE_RECV_MESSAGE);
+    got_message = true;
+  }
+
+ private:
+  // Sets got_message and \a status for a failed recv message op
+  void FinishOpRecvMessageFailureHandler(bool* status) {
+    got_message = false;
+    if (!allow_not_getting_message_) {
+      *status = false;
+    }
+  }
+
+  R* message_ = nullptr;
+  ByteBuffer recv_buf_;
+  bool allow_not_getting_message_ = false;
+  bool hijacked_ = false;
+  bool hijacked_recv_message_failed_ = false;
+};
+
+class DeserializeFunc {
+ public:
+  virtual Status Deserialize(ByteBuffer* buf) = 0;
+  virtual ~DeserializeFunc() {}
+};
+
+template <class R>
+class DeserializeFuncType final : public DeserializeFunc {
+ public:
+  explicit DeserializeFuncType(R* message) : message_(message) {}
+  Status Deserialize(ByteBuffer* buf) override {
+    return SerializationTraits<R>::Deserialize(buf->bbuf_ptr(), message_);
+  }
+
+  ~DeserializeFuncType() override {}
+
+ private:
+  R* message_;  // Not a managed pointer because management is external to this
+};
+
+class CallOpGenericRecvMessage {
+ public:
+  template <class R>
+  void RecvMessage(R* message) {
+    // Use an explicit base class pointer to avoid resolution error in the
+    // following unique_ptr::reset for some old implementations.
+    DeserializeFunc* func = new DeserializeFuncType<R>(message);
+    deserialize_.reset(func);
+    message_ = message;
+  }
+
+  // Do not change status if no message is received.
+  void AllowNoMessage() { allow_not_getting_message_ = true; }
+
+  bool got_message = false;
+
+ protected:
+  void AddOp(grpc_op* ops, size_t* nops) {
+    if (!deserialize_ || hijacked_) return;
+    grpc_op* op = &ops[(*nops)++];
+    op->op = GRPC_OP_RECV_MESSAGE;
+    op->flags = 0;
+    op->reserved = nullptr;
+    op->data.recv_message.recv_message = recv_buf_.c_buffer_ptr();
+  }
+
+  void FinishOp(bool* status) {
+    if (!deserialize_) return;
+    if (recv_buf_.Valid()) {
+      if (*status) {
+        got_message = true;
+        *status = deserialize_->Deserialize(&recv_buf_).ok();
+        recv_buf_.Release();
+      } else {
+        got_message = false;
+        recv_buf_.Clear();
+      }
+    } else if (hijacked_) {
+      if (hijacked_recv_message_failed_) {
+        FinishOpRecvMessageFailureHandler(status);
+      } else {
+        // The op was hijacked and it was successful. There is no further action
+        // to be performed since the message is already in its non-serialized
+        // form.
+      }
+    } else {
+      got_message = false;
+      if (!allow_not_getting_message_) {
+        *status = false;
+      }
+    }
+  }
+
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (!deserialize_) return;
+    interceptor_methods->SetRecvMessage(message_,
+                                        &hijacked_recv_message_failed_);
+  }
+
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (!deserialize_) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::POST_RECV_MESSAGE);
+    if (!got_message) interceptor_methods->SetRecvMessage(nullptr, nullptr);
+    deserialize_.reset();
+  }
+  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
+    hijacked_ = true;
+    if (!deserialize_) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::PRE_RECV_MESSAGE);
+    got_message = true;
+  }
+
+ private:
+  // Sets got_message and \a status for a failed recv message op
+  void FinishOpRecvMessageFailureHandler(bool* status) {
+    got_message = false;
+    if (!allow_not_getting_message_) {
+      *status = false;
+    }
+  }
+
+  void* message_ = nullptr;
+  std::unique_ptr<DeserializeFunc> deserialize_;
+  ByteBuffer recv_buf_;
+  bool allow_not_getting_message_ = false;
+  bool hijacked_ = false;
+  bool hijacked_recv_message_failed_ = false;
+};
+
+class CallOpClientSendClose {
+ public:
+  CallOpClientSendClose() : send_(false) {}
+
+  void ClientSendClose() { send_ = true; }
+
+ protected:
+  void AddOp(grpc_op* ops, size_t* nops) {
+    if (!send_ || hijacked_) return;
+    grpc_op* op = &ops[(*nops)++];
+    op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
+    op->flags = 0;
+    op->reserved = nullptr;
+  }
+  void FinishOp(bool* /*status*/) { send_ = false; }
+
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (!send_) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::PRE_SEND_CLOSE);
+  }
+
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
+
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
+    hijacked_ = true;
+  }
+
+ private:
+  bool hijacked_ = false;
+  bool send_;
+};
+
+class CallOpServerSendStatus {
+ public:
+  CallOpServerSendStatus() : send_status_available_(false) {}
+
+  void ServerSendStatus(
+      std::multimap<std::string, std::string>* trailing_metadata,
+      const Status& status) {
+    send_error_details_ = status.error_details();
+    metadata_map_ = trailing_metadata;
+    send_status_available_ = true;
+    send_status_code_ = static_cast<grpc_status_code>(status.error_code());
+    send_error_message_ = status.error_message();
+  }
+
+ protected:
+  void AddOp(grpc_op* ops, size_t* nops) {
+    if (!send_status_available_ || hijacked_) return;
+    trailing_metadata_ = FillMetadataArray(
+        *metadata_map_, &trailing_metadata_count_, send_error_details_);
+    grpc_op* op = &ops[(*nops)++];
+    op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
+    op->data.send_status_from_server.trailing_metadata_count =
+        trailing_metadata_count_;
+    op->data.send_status_from_server.trailing_metadata = trailing_metadata_;
+    op->data.send_status_from_server.status = send_status_code_;
+    error_message_slice_ = SliceReferencingString(send_error_message_);
+    op->data.send_status_from_server.status_details =
+        send_error_message_.empty() ? nullptr : &error_message_slice_;
+    op->flags = 0;
+    op->reserved = nullptr;
+  }
+
+  void FinishOp(bool* /*status*/) {
+    if (!send_status_available_ || hijacked_) return;
+    g_core_codegen_interface->gpr_free(trailing_metadata_);
+    send_status_available_ = false;
+  }
+
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (!send_status_available_) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::PRE_SEND_STATUS);
+    interceptor_methods->SetSendTrailingMetadata(metadata_map_);
+    interceptor_methods->SetSendStatus(&send_status_code_, &send_error_details_,
+                                       &send_error_message_);
+  }
+
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
+
+  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
+    hijacked_ = true;
+  }
+
+ private:
+  bool hijacked_ = false;
+  bool send_status_available_;
+  grpc_status_code send_status_code_;
+  std::string send_error_details_;
+  std::string send_error_message_;
+  size_t trailing_metadata_count_;
+  std::multimap<std::string, std::string>* metadata_map_;
+  grpc_metadata* trailing_metadata_;
+  grpc_slice error_message_slice_;
+};
+
+class CallOpRecvInitialMetadata {
+ public:
+  CallOpRecvInitialMetadata() : metadata_map_(nullptr) {}
+
+  void RecvInitialMetadata(grpc::ClientContext* context) {
+    context->initial_metadata_received_ = true;
+    metadata_map_ = &context->recv_initial_metadata_;
+  }
+
+ protected:
+  void AddOp(grpc_op* ops, size_t* nops) {
+    if (metadata_map_ == nullptr || hijacked_) return;
+    grpc_op* op = &ops[(*nops)++];
+    op->op = GRPC_OP_RECV_INITIAL_METADATA;
+    op->data.recv_initial_metadata.recv_initial_metadata = metadata_map_->arr();
+    op->flags = 0;
+    op->reserved = nullptr;
+  }
+
+  void FinishOp(bool* /*status*/) {
+    if (metadata_map_ == nullptr || hijacked_) return;
+  }
+
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    interceptor_methods->SetRecvInitialMetadata(metadata_map_);
+  }
+
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (metadata_map_ == nullptr) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::POST_RECV_INITIAL_METADATA);
+    metadata_map_ = nullptr;
+  }
+
+  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
+    hijacked_ = true;
+    if (metadata_map_ == nullptr) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::PRE_RECV_INITIAL_METADATA);
+  }
+
+ private:
+  bool hijacked_ = false;
+  MetadataMap* metadata_map_;
+};
+
+class CallOpClientRecvStatus {
+ public:
+  CallOpClientRecvStatus()
+      : recv_status_(nullptr), debug_error_string_(nullptr) {}
+
+  void ClientRecvStatus(grpc::ClientContext* context, Status* status) {
+    client_context_ = context;
+    metadata_map_ = &client_context_->trailing_metadata_;
+    recv_status_ = status;
+    error_message_ = g_core_codegen_interface->grpc_empty_slice();
+  }
+
+ protected:
+  void AddOp(grpc_op* ops, size_t* nops) {
+    if (recv_status_ == nullptr || hijacked_) return;
+    grpc_op* op = &ops[(*nops)++];
+    op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
+    op->data.recv_status_on_client.trailing_metadata = metadata_map_->arr();
+    op->data.recv_status_on_client.status = &status_code_;
+    op->data.recv_status_on_client.status_details = &error_message_;
+    op->data.recv_status_on_client.error_string = &debug_error_string_;
+    op->flags = 0;
+    op->reserved = nullptr;
+  }
+
+  void FinishOp(bool* /*status*/) {
+    if (recv_status_ == nullptr || hijacked_) return;
+    if (static_cast<StatusCode>(status_code_) == StatusCode::OK) {
+      *recv_status_ = Status();
+      GPR_CODEGEN_DEBUG_ASSERT(debug_error_string_ == nullptr);
+    } else {
+      *recv_status_ =
+          Status(static_cast<StatusCode>(status_code_),
+                 GRPC_SLICE_IS_EMPTY(error_message_)
+                     ? std::string()
+                     : std::string(GRPC_SLICE_START_PTR(error_message_),
+                                   GRPC_SLICE_END_PTR(error_message_)),
+                 metadata_map_->GetBinaryErrorDetails());
+      if (debug_error_string_ != nullptr) {
+        client_context_->set_debug_error_string(debug_error_string_);
+        g_core_codegen_interface->gpr_free(
+            const_cast<char*>(debug_error_string_));
+      }
+    }
+    // TODO(soheil): Find callers that set debug string even for status OK,
+    //               and fix them.
+    g_core_codegen_interface->grpc_slice_unref(error_message_);
+  }
+
+  void SetInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    interceptor_methods->SetRecvStatus(recv_status_);
+    interceptor_methods->SetRecvTrailingMetadata(metadata_map_);
+  }
+
+  void SetFinishInterceptionHookPoint(
+      InterceptorBatchMethodsImpl* interceptor_methods) {
+    if (recv_status_ == nullptr) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::POST_RECV_STATUS);
+    recv_status_ = nullptr;
+  }
+
+  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
+    hijacked_ = true;
+    if (recv_status_ == nullptr) return;
+    interceptor_methods->AddInterceptionHookPoint(
+        experimental::InterceptionHookPoints::PRE_RECV_STATUS);
+  }
+
+ private:
+  bool hijacked_ = false;
+  grpc::ClientContext* client_context_;
+  MetadataMap* metadata_map_;
+  Status* recv_status_;
+  const char* debug_error_string_;
+  grpc_status_code status_code_;
+  grpc_slice error_message_;
+};
+
+template <class Op1 = CallNoOp<1>, class Op2 = CallNoOp<2>,
+          class Op3 = CallNoOp<3>, class Op4 = CallNoOp<4>,
+          class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>>
+class CallOpSet;
+
+/// Primary implementation of CallOpSetInterface.
+/// Since we cannot use variadic templates, we declare slots up to
+/// the maximum count of ops we'll need in a set. We leverage the
+/// empty base class optimization to slim this class (especially
+/// when there are many unused slots used). To avoid duplicate base classes,
+/// the template parameter for CallNoOp is varied by argument position.
+template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
+class CallOpSet : public CallOpSetInterface,
+                  public Op1,
+                  public Op2,
+                  public Op3,
+                  public Op4,
+                  public Op5,
+                  public Op6 {
+ public:
+  CallOpSet() : core_cq_tag_(this), return_tag_(this) {}
+  // The copy constructor and assignment operator reset the value of
+  // core_cq_tag_, return_tag_, done_intercepting_ and interceptor_methods_
+  // since those are only meaningful on a specific object, not across objects.
+  CallOpSet(const CallOpSet& other)
+      : core_cq_tag_(this),
+        return_tag_(this),
+        call_(other.call_),
+        done_intercepting_(false),
+        interceptor_methods_(InterceptorBatchMethodsImpl()) {}
+
+  CallOpSet& operator=(const CallOpSet& other) {
+    if (&other == this) {
+      return *this;
+    }
+    core_cq_tag_ = this;
+    return_tag_ = this;
+    call_ = other.call_;
+    done_intercepting_ = false;
+    interceptor_methods_ = InterceptorBatchMethodsImpl();
+    return *this;
+  }
+
+  void FillOps(Call* call) override {
+    done_intercepting_ = false;
+    g_core_codegen_interface->grpc_call_ref(call->call());
+    call_ =
+        *call;  // It's fine to create a copy of call since it's just pointers
+
+    if (RunInterceptors()) {
+      ContinueFillOpsAfterInterception();
+    } else {
+      // After the interceptors are run, ContinueFillOpsAfterInterception will
+      // be run
+    }
+  }
+
+  bool FinalizeResult(void** tag, bool* status) override {
+    if (done_intercepting_) {
+      // Complete the avalanching since we are done with this batch of ops
+      call_.cq()->CompleteAvalanching();
+      // We have already finished intercepting and filling in the results. This
+      // round trip from the core needed to be made because interceptors were
+      // run
+      *tag = return_tag_;
+      *status = saved_status_;
+      g_core_codegen_interface->grpc_call_unref(call_.call());
+      return true;
+    }
+
+    this->Op1::FinishOp(status);
+    this->Op2::FinishOp(status);
+    this->Op3::FinishOp(status);
+    this->Op4::FinishOp(status);
+    this->Op5::FinishOp(status);
+    this->Op6::FinishOp(status);
+    saved_status_ = *status;
+    if (RunInterceptorsPostRecv()) {
+      *tag = return_tag_;
+      g_core_codegen_interface->grpc_call_unref(call_.call());
+      return true;
+    }
+    // Interceptors are going to be run, so we can't return the tag just yet.
+    // After the interceptors are run, ContinueFinalizeResultAfterInterception
+    return false;
+  }
+
+  void set_output_tag(void* return_tag) { return_tag_ = return_tag; }
+
+  void* core_cq_tag() override { return core_cq_tag_; }
+
+  /// set_core_cq_tag is used to provide a different core CQ tag than "this".
+  /// This is used for callback-based tags, where the core tag is the core
+  /// callback function. It does not change the use or behavior of any other
+  /// function (such as FinalizeResult)
+  void set_core_cq_tag(void* core_cq_tag) { core_cq_tag_ = core_cq_tag; }
+
+  // This will be called while interceptors are run if the RPC is a hijacked
+  // RPC. This should set hijacking state for each of the ops.
+  void SetHijackingState() override {
+    this->Op1::SetHijackingState(&interceptor_methods_);
+    this->Op2::SetHijackingState(&interceptor_methods_);
+    this->Op3::SetHijackingState(&interceptor_methods_);
+    this->Op4::SetHijackingState(&interceptor_methods_);
+    this->Op5::SetHijackingState(&interceptor_methods_);
+    this->Op6::SetHijackingState(&interceptor_methods_);
+  }
+
+  // Should be called after interceptors are done running
+  void ContinueFillOpsAfterInterception() override {
+    static const size_t MAX_OPS = 6;
+    grpc_op ops[MAX_OPS];
+    size_t nops = 0;
+    this->Op1::AddOp(ops, &nops);
+    this->Op2::AddOp(ops, &nops);
+    this->Op3::AddOp(ops, &nops);
+    this->Op4::AddOp(ops, &nops);
+    this->Op5::AddOp(ops, &nops);
+    this->Op6::AddOp(ops, &nops);
+
+    grpc_call_error err = g_core_codegen_interface->grpc_call_start_batch(
+        call_.call(), ops, nops, core_cq_tag(), nullptr);
+
+    if (err != GRPC_CALL_OK) {
+      // A failure here indicates an API misuse; for example, doing a Write
+      // while another Write is already pending on the same RPC or invoking
+      // WritesDone multiple times
+      // gpr_log(GPR_ERROR, "API misuse of type %s observed",
+      //        g_core_codegen_interface->grpc_call_error_to_string(err));
+      GPR_CODEGEN_ASSERT(false);
+    }
+  }
+
+  // Should be called after interceptors are done running on the finalize result
+  // path
+  void ContinueFinalizeResultAfterInterception() override {
+    done_intercepting_ = true;
+    // The following call_start_batch is internally-generated so no need for an
+    // explanatory log on failure.
+    GPR_CODEGEN_ASSERT(g_core_codegen_interface->grpc_call_start_batch(
+                           call_.call(), nullptr, 0, core_cq_tag(), nullptr) ==
+                       GRPC_CALL_OK);
+  }
+
+ private:
+  // Returns true if no interceptors need to be run
+  bool RunInterceptors() {
+    interceptor_methods_.ClearState();
+    interceptor_methods_.SetCallOpSetInterface(this);
+    interceptor_methods_.SetCall(&call_);
+    this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
+    this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
+    this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
+    this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
+    this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
+    this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
+    if (interceptor_methods_.InterceptorsListEmpty()) {
+      return true;
+    }
+    // This call will go through interceptors and would need to
+    // schedule new batches, so delay completion queue shutdown
+    call_.cq()->RegisterAvalanching();
+    return interceptor_methods_.RunInterceptors();
+  }
+  // Returns true if no interceptors need to be run
+  bool RunInterceptorsPostRecv() {
+    // Call and OpSet had already been set on the set state.
+    // SetReverse also clears previously set hook points
+    interceptor_methods_.SetReverse();
+    this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
+    this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
+    this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
+    this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
+    this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
+    this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
+    return interceptor_methods_.RunInterceptors();
+  }
+
+  void* core_cq_tag_;
+  void* return_tag_;
+  Call call_;
+  bool done_intercepting_ = false;
+  InterceptorBatchMethodsImpl interceptor_methods_;
+  bool saved_status_;
+};
+
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set_interface.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set_interface.h
new file mode 100644
index 0000000..a8eed9f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set_interface.h
@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CALL_OP_SET_INTERFACE_H
+#define GRPCPP_IMPL_CODEGEN_CALL_OP_SET_INTERFACE_H
+
+// IWYU pragma: private
+
+#include <grpcpp/impl/codegen/completion_queue_tag.h>
+
+namespace grpc {
+namespace internal {
+
+class Call;
+
+/// An abstract collection of call ops, used to generate the
+/// grpc_call_op structure to pass down to the lower layers,
+/// and as it is-a CompletionQueueTag, also massages the final
+/// completion into the correct form for consumption in the C++
+/// API.
+class CallOpSetInterface : public CompletionQueueTag {
+ public:
+  /// Fills in grpc_op, starting from ops[*nops] and moving
+  /// upwards.
+  virtual void FillOps(internal::Call* call) = 0;
+
+  /// Get the tag to be used at the core completion queue. Generally, the
+  /// value of core_cq_tag will be "this". However, it can be overridden if we
+  /// want core to process the tag differently (e.g., as a core callback)
+  virtual void* core_cq_tag() = 0;
+
+  // This will be called while interceptors are run if the RPC is a hijacked
+  // RPC. This should set hijacking state for each of the ops.
+  virtual void SetHijackingState() = 0;
+
+  // Should be called after interceptors are done running
+  virtual void ContinueFillOpsAfterInterception() = 0;
+
+  // Should be called after interceptors are done running on the finalize result
+  // path
+  virtual void ContinueFinalizeResultAfterInterception() = 0;
+};
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CALL_OP_SET_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/callback_common.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/callback_common.h
new file mode 100644
index 0000000..7c67c92
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/callback_common.h
@@ -0,0 +1,222 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CALLBACK_COMMON_H
+#define GRPCPP_IMPL_CODEGEN_CALLBACK_COMMON_H
+
+// IWYU pragma: private
+
+#include <functional>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/completion_queue_tag.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+namespace internal {
+
+/// An exception-safe way of invoking a user-specified callback function
+// TODO(vjpai): decide whether it is better for this to take a const lvalue
+//              parameter or an rvalue parameter, or if it even matters
+template <class Func, class... Args>
+void CatchingCallback(Func&& func, Args&&... args) {
+#if GRPC_ALLOW_EXCEPTIONS
+  try {
+    func(std::forward<Args>(args)...);
+  } catch (...) {
+    // nothing to return or change here, just don't crash the library
+  }
+#else   // GRPC_ALLOW_EXCEPTIONS
+  func(std::forward<Args>(args)...);
+#endif  // GRPC_ALLOW_EXCEPTIONS
+}
+
+template <class Reactor, class Func, class... Args>
+Reactor* CatchingReactorGetter(Func&& func, Args&&... args) {
+#if GRPC_ALLOW_EXCEPTIONS
+  try {
+    return func(std::forward<Args>(args)...);
+  } catch (...) {
+    // fail the RPC, don't crash the library
+    return nullptr;
+  }
+#else   // GRPC_ALLOW_EXCEPTIONS
+  return func(std::forward<Args>(args)...);
+#endif  // GRPC_ALLOW_EXCEPTIONS
+}
+
+// The contract on these tags is that they are single-shot. They must be
+// constructed and then fired at exactly one point. There is no expectation
+// that they can be reused without reconstruction.
+
+class CallbackWithStatusTag : public grpc_completion_queue_functor {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(CallbackWithStatusTag));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  CallbackWithStatusTag(grpc_call* call, std::function<void(Status)> f,
+                        CompletionQueueTag* ops)
+      : call_(call), func_(std::move(f)), ops_(ops) {
+    g_core_codegen_interface->grpc_call_ref(call);
+    functor_run = &CallbackWithStatusTag::StaticRun;
+    // A client-side callback should never be run inline since they will always
+    // have work to do from the user application. So, set the parent's
+    // inlineable field to false
+    inlineable = false;
+  }
+  ~CallbackWithStatusTag() {}
+  Status* status_ptr() { return &status_; }
+
+  // force_run can not be performed on a tag if operations using this tag
+  // have been sent to PerformOpsOnCall. It is intended for error conditions
+  // that are detected before the operations are internally processed.
+  void force_run(Status s) {
+    status_ = std::move(s);
+    Run(true);
+  }
+
+ private:
+  grpc_call* call_;
+  std::function<void(Status)> func_;
+  CompletionQueueTag* ops_;
+  Status status_;
+
+  static void StaticRun(grpc_completion_queue_functor* cb, int ok) {
+    static_cast<CallbackWithStatusTag*>(cb)->Run(static_cast<bool>(ok));
+  }
+  void Run(bool ok) {
+    void* ignored = ops_;
+
+    if (!ops_->FinalizeResult(&ignored, &ok)) {
+      // The tag was swallowed
+      return;
+    }
+    GPR_CODEGEN_ASSERT(ignored == ops_);
+
+    // Last use of func_ or status_, so ok to move them out
+    auto func = std::move(func_);
+    auto status = std::move(status_);
+    func_ = nullptr;     // reset to clear this out for sure
+    status_ = Status();  // reset to clear this out for sure
+    CatchingCallback(std::move(func), std::move(status));
+    g_core_codegen_interface->grpc_call_unref(call_);
+  }
+};
+
+/// CallbackWithSuccessTag can be reused multiple times, and will be used in
+/// this fashion for streaming operations. As a result, it shouldn't clear
+/// anything up until its destructor
+class CallbackWithSuccessTag : public grpc_completion_queue_functor {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(CallbackWithSuccessTag));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  CallbackWithSuccessTag() : call_(nullptr) {}
+
+  CallbackWithSuccessTag(const CallbackWithSuccessTag&) = delete;
+  CallbackWithSuccessTag& operator=(const CallbackWithSuccessTag&) = delete;
+
+  ~CallbackWithSuccessTag() { Clear(); }
+
+  // Set can only be called on a default-constructed or Clear'ed tag.
+  // It should never be called on a tag that was constructed with arguments
+  // or on a tag that has been Set before unless the tag has been cleared.
+  // can_inline indicates that this particular callback can be executed inline
+  // (without needing a thread hop) and is only used for library-provided server
+  // callbacks.
+  void Set(grpc_call* call, std::function<void(bool)> f,
+           CompletionQueueTag* ops, bool can_inline) {
+    GPR_CODEGEN_ASSERT(call_ == nullptr);
+    g_core_codegen_interface->grpc_call_ref(call);
+    call_ = call;
+    func_ = std::move(f);
+    ops_ = ops;
+    functor_run = &CallbackWithSuccessTag::StaticRun;
+    inlineable = can_inline;
+  }
+
+  void Clear() {
+    if (call_ != nullptr) {
+      grpc_call* call = call_;
+      call_ = nullptr;
+      func_ = nullptr;
+      g_core_codegen_interface->grpc_call_unref(call);
+    }
+  }
+
+  CompletionQueueTag* ops() { return ops_; }
+
+  // force_run can not be performed on a tag if operations using this tag
+  // have been sent to PerformOpsOnCall. It is intended for error conditions
+  // that are detected before the operations are internally processed.
+  void force_run(bool ok) { Run(ok); }
+
+  /// check if this tag is currently set
+  /* NOLINTNEXTLINE(google-explicit-constructor) */
+  operator bool() const { return call_ != nullptr; }
+
+ private:
+  grpc_call* call_;
+  std::function<void(bool)> func_;
+  CompletionQueueTag* ops_;
+
+  static void StaticRun(grpc_completion_queue_functor* cb, int ok) {
+    static_cast<CallbackWithSuccessTag*>(cb)->Run(static_cast<bool>(ok));
+  }
+  void Run(bool ok) {
+    void* ignored = ops_;
+    // Allow a "false" return value from FinalizeResult to silence the
+    // callback, just as it silences a CQ tag in the async cases
+#ifndef NDEBUG
+    auto* ops = ops_;
+#endif
+    bool do_callback = ops_->FinalizeResult(&ignored, &ok);
+    GPR_CODEGEN_DEBUG_ASSERT(ignored == ops);
+
+    if (do_callback) {
+      CatchingCallback(func_, ok);
+    }
+  }
+};
+
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CALLBACK_COMMON_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/channel_interface.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/channel_interface.h
new file mode 100644
index 0000000..19fef7e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/channel_interface.h
@@ -0,0 +1,172 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CHANNEL_INTERFACE_H
+#define GRPCPP_IMPL_CODEGEN_CHANNEL_INTERFACE_H
+
+// IWYU pragma: private
+
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/time.h>
+
+namespace grpc {
+template <class R>
+class ClientReader;
+template <class W>
+class ClientWriter;
+template <class W, class R>
+class ClientReaderWriter;
+namespace internal {
+template <class InputMessage, class OutputMessage>
+class CallbackUnaryCallImpl;
+template <class R>
+class ClientAsyncReaderFactory;
+template <class W>
+class ClientAsyncWriterFactory;
+template <class W, class R>
+class ClientAsyncReaderWriterFactory;
+class ClientAsyncResponseReaderHelper;
+template <class W, class R>
+class ClientCallbackReaderWriterFactory;
+template <class R>
+class ClientCallbackReaderFactory;
+template <class W>
+class ClientCallbackWriterFactory;
+class ClientCallbackUnaryFactory;
+}  // namespace internal
+
+class ChannelInterface;
+class ClientContext;
+class CompletionQueue;
+
+namespace experimental {
+class DelegatingChannel;
+}
+
+namespace internal {
+class Call;
+class CallOpSetInterface;
+class RpcMethod;
+class InterceptedChannel;
+template <class InputMessage, class OutputMessage>
+class BlockingUnaryCallImpl;
+}  // namespace internal
+
+/// Codegen interface for \a grpc::Channel.
+class ChannelInterface {
+ public:
+  virtual ~ChannelInterface() {}
+  /// Get the current channel state. If the channel is in IDLE and
+  /// \a try_to_connect is set to true, try to connect.
+  virtual grpc_connectivity_state GetState(bool try_to_connect) = 0;
+
+  /// Return the \a tag on \a cq when the channel state is changed or \a
+  /// deadline expires. \a GetState needs to called to get the current state.
+  template <typename T>
+  void NotifyOnStateChange(grpc_connectivity_state last_observed, T deadline,
+                           grpc::CompletionQueue* cq, void* tag) {
+    TimePoint<T> deadline_tp(deadline);
+    NotifyOnStateChangeImpl(last_observed, deadline_tp.raw_time(), cq, tag);
+  }
+
+  /// Blocking wait for channel state change or \a deadline expiration.
+  /// \a GetState needs to called to get the current state.
+  template <typename T>
+  bool WaitForStateChange(grpc_connectivity_state last_observed, T deadline) {
+    TimePoint<T> deadline_tp(deadline);
+    return WaitForStateChangeImpl(last_observed, deadline_tp.raw_time());
+  }
+
+  /// Wait for this channel to be connected
+  template <typename T>
+  bool WaitForConnected(T deadline) {
+    grpc_connectivity_state state;
+    while ((state = GetState(true)) != GRPC_CHANNEL_READY) {
+      if (!WaitForStateChange(state, deadline)) return false;
+    }
+    return true;
+  }
+
+ private:
+  template <class R>
+  friend class grpc::ClientReader;
+  template <class W>
+  friend class grpc::ClientWriter;
+  template <class W, class R>
+  friend class grpc::ClientReaderWriter;
+  template <class R>
+  friend class grpc::internal::ClientAsyncReaderFactory;
+  template <class W>
+  friend class grpc::internal::ClientAsyncWriterFactory;
+  template <class W, class R>
+  friend class grpc::internal::ClientAsyncReaderWriterFactory;
+  friend class grpc::internal::ClientAsyncResponseReaderHelper;
+  template <class W, class R>
+  friend class grpc::internal::ClientCallbackReaderWriterFactory;
+  template <class R>
+  friend class grpc::internal::ClientCallbackReaderFactory;
+  template <class W>
+  friend class grpc::internal::ClientCallbackWriterFactory;
+  friend class grpc::internal::ClientCallbackUnaryFactory;
+  template <class InputMessage, class OutputMessage>
+  friend class grpc::internal::BlockingUnaryCallImpl;
+  template <class InputMessage, class OutputMessage>
+  friend class grpc::internal::CallbackUnaryCallImpl;
+  friend class grpc::internal::RpcMethod;
+  friend class grpc::experimental::DelegatingChannel;
+  friend class grpc::internal::InterceptedChannel;
+  virtual internal::Call CreateCall(const internal::RpcMethod& method,
+                                    grpc::ClientContext* context,
+                                    grpc::CompletionQueue* cq) = 0;
+  virtual void PerformOpsOnCall(internal::CallOpSetInterface* ops,
+                                internal::Call* call) = 0;
+  virtual void* RegisterMethod(const char* method) = 0;
+  virtual void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
+                                       gpr_timespec deadline,
+                                       grpc::CompletionQueue* cq,
+                                       void* tag) = 0;
+  virtual bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
+                                      gpr_timespec deadline) = 0;
+
+  // EXPERIMENTAL
+  // This is needed to keep codegen_test_minimal happy. InterceptedChannel needs
+  // to make use of this but can't directly call Channel's implementation
+  // because of the test.
+  // Returns an empty Call object (rather than being pure) since this is a new
+  // method and adding a new pure method to an interface would be a breaking
+  // change (even though this is private and non-API)
+  virtual internal::Call CreateCallInternal(
+      const internal::RpcMethod& /*method*/, grpc::ClientContext* /*context*/,
+      grpc::CompletionQueue* /*cq*/, size_t /*interceptor_pos*/) {
+    return internal::Call();
+  }
+
+  // A method to get the callbackable completion queue associated with this
+  // channel. If the return value is nullptr, this channel doesn't support
+  // callback operations.
+  // TODO(vjpai): Consider a better default like using a global CQ
+  // Returns nullptr (rather than being pure) since this is a post-1.0 method
+  // and adding a new pure method to an interface would be a breaking change
+  // (even though this is private and non-API)
+  virtual grpc::CompletionQueue* CallbackCQ() { return nullptr; }
+};
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CHANNEL_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_callback.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_callback.h
new file mode 100644
index 0000000..04ab4aa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_callback.h
@@ -0,0 +1,1229 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CLIENT_CALLBACK_H
+#define GRPCPP_IMPL_CODEGEN_CLIENT_CALLBACK_H
+
+// IWYU pragma: private, include <grpcpp/support/client_callback.h>
+
+#include <atomic>
+#include <functional>
+
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/call_op_set.h>
+#include <grpcpp/impl/codegen/callback_common.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/sync.h>
+
+namespace grpc {
+class Channel;
+class ClientContext;
+
+namespace internal {
+class RpcMethod;
+
+/// Perform a callback-based unary call.  May optionally specify the base
+/// class of the Request and Response so that the internal calls and structures
+/// below this may be based on those base classes and thus achieve code reuse
+/// across different RPCs (e.g., for protobuf, MessageLite would be a base
+/// class).
+/// TODO(vjpai): Combine as much as possible with the blocking unary call code
+template <class InputMessage, class OutputMessage,
+          class BaseInputMessage = InputMessage,
+          class BaseOutputMessage = OutputMessage>
+void CallbackUnaryCall(grpc::ChannelInterface* channel,
+                       const grpc::internal::RpcMethod& method,
+                       grpc::ClientContext* context,
+                       const InputMessage* request, OutputMessage* result,
+                       std::function<void(grpc::Status)> on_completion) {
+  static_assert(std::is_base_of<BaseInputMessage, InputMessage>::value,
+                "Invalid input message specification");
+  static_assert(std::is_base_of<BaseOutputMessage, OutputMessage>::value,
+                "Invalid output message specification");
+  CallbackUnaryCallImpl<BaseInputMessage, BaseOutputMessage> x(
+      channel, method, context, request, result, on_completion);
+}
+
+template <class InputMessage, class OutputMessage>
+class CallbackUnaryCallImpl {
+ public:
+  CallbackUnaryCallImpl(grpc::ChannelInterface* channel,
+                        const grpc::internal::RpcMethod& method,
+                        grpc::ClientContext* context,
+                        const InputMessage* request, OutputMessage* result,
+                        std::function<void(grpc::Status)> on_completion) {
+    grpc::CompletionQueue* cq = channel->CallbackCQ();
+    GPR_CODEGEN_ASSERT(cq != nullptr);
+    grpc::internal::Call call(channel->CreateCall(method, context, cq));
+
+    using FullCallOpSet = grpc::internal::CallOpSet<
+        grpc::internal::CallOpSendInitialMetadata,
+        grpc::internal::CallOpSendMessage,
+        grpc::internal::CallOpRecvInitialMetadata,
+        grpc::internal::CallOpRecvMessage<OutputMessage>,
+        grpc::internal::CallOpClientSendClose,
+        grpc::internal::CallOpClientRecvStatus>;
+
+    struct OpSetAndTag {
+      FullCallOpSet opset;
+      grpc::internal::CallbackWithStatusTag tag;
+    };
+    const size_t alloc_sz = sizeof(OpSetAndTag);
+    auto* const alloced = static_cast<OpSetAndTag*>(
+        grpc::g_core_codegen_interface->grpc_call_arena_alloc(call.call(),
+                                                              alloc_sz));
+    auto* ops = new (&alloced->opset) FullCallOpSet;
+    auto* tag = new (&alloced->tag)
+        grpc::internal::CallbackWithStatusTag(call.call(), on_completion, ops);
+
+    // TODO(vjpai): Unify code with sync API as much as possible
+    grpc::Status s = ops->SendMessagePtr(request);
+    if (!s.ok()) {
+      tag->force_run(s);
+      return;
+    }
+    ops->SendInitialMetadata(&context->send_initial_metadata_,
+                             context->initial_metadata_flags());
+    ops->RecvInitialMetadata(context);
+    ops->RecvMessage(result);
+    ops->AllowNoMessage();
+    ops->ClientSendClose();
+    ops->ClientRecvStatus(context, tag->status_ptr());
+    ops->set_core_cq_tag(tag);
+    call.PerformOps(ops);
+  }
+};
+
+// Base class for public API classes.
+class ClientReactor {
+ public:
+  virtual ~ClientReactor() = default;
+
+  /// Called by the library when all operations associated with this RPC have
+  /// completed and all Holds have been removed. OnDone provides the RPC status
+  /// outcome for both successful and failed RPCs. If it is never called on an
+  /// RPC, it indicates an application-level problem (like failure to remove a
+  /// hold).
+  ///
+  /// \param[in] s The status outcome of this RPC
+  virtual void OnDone(const grpc::Status& /*s*/) = 0;
+
+  /// InternalScheduleOnDone is not part of the API and is not meant to be
+  /// overridden. It is virtual to allow successful builds for certain bazel
+  /// build users that only want to depend on gRPC codegen headers and not the
+  /// full library (although this is not a generally-supported option). Although
+  /// the virtual call is slower than a direct call, this function is
+  /// heavyweight and the cost of the virtual call is not much in comparison.
+  /// This function may be removed or devirtualized in the future.
+  virtual void InternalScheduleOnDone(grpc::Status s);
+
+  /// InternalTrailersOnly is not part of the API and is not meant to be
+  /// overridden. It is virtual to allow successful builds for certain bazel
+  /// build users that only want to depend on gRPC codegen headers and not the
+  /// full library (although this is not a generally-supported option). Although
+  /// the virtual call is slower than a direct call, this function is
+  /// heavyweight and the cost of the virtual call is not much in comparison.
+  /// This function may be removed or devirtualized in the future.
+  virtual bool InternalTrailersOnly(const grpc_call* call) const;
+};
+
+}  // namespace internal
+
+// Forward declarations
+template <class Request, class Response>
+class ClientBidiReactor;
+template <class Response>
+class ClientReadReactor;
+template <class Request>
+class ClientWriteReactor;
+class ClientUnaryReactor;
+
+// NOTE: The streaming objects are not actually implemented in the public API.
+//       These interfaces are provided for mocking only. Typical applications
+//       will interact exclusively with the reactors that they define.
+template <class Request, class Response>
+class ClientCallbackReaderWriter {
+ public:
+  virtual ~ClientCallbackReaderWriter() {}
+  virtual void StartCall() = 0;
+  virtual void Write(const Request* req, grpc::WriteOptions options) = 0;
+  virtual void WritesDone() = 0;
+  virtual void Read(Response* resp) = 0;
+  virtual void AddHold(int holds) = 0;
+  virtual void RemoveHold() = 0;
+
+ protected:
+  void BindReactor(ClientBidiReactor<Request, Response>* reactor) {
+    reactor->BindStream(this);
+  }
+};
+
+template <class Response>
+class ClientCallbackReader {
+ public:
+  virtual ~ClientCallbackReader() {}
+  virtual void StartCall() = 0;
+  virtual void Read(Response* resp) = 0;
+  virtual void AddHold(int holds) = 0;
+  virtual void RemoveHold() = 0;
+
+ protected:
+  void BindReactor(ClientReadReactor<Response>* reactor) {
+    reactor->BindReader(this);
+  }
+};
+
+template <class Request>
+class ClientCallbackWriter {
+ public:
+  virtual ~ClientCallbackWriter() {}
+  virtual void StartCall() = 0;
+  void Write(const Request* req) { Write(req, grpc::WriteOptions()); }
+  virtual void Write(const Request* req, grpc::WriteOptions options) = 0;
+  void WriteLast(const Request* req, grpc::WriteOptions options) {
+    Write(req, options.set_last_message());
+  }
+  virtual void WritesDone() = 0;
+
+  virtual void AddHold(int holds) = 0;
+  virtual void RemoveHold() = 0;
+
+ protected:
+  void BindReactor(ClientWriteReactor<Request>* reactor) {
+    reactor->BindWriter(this);
+  }
+};
+
+class ClientCallbackUnary {
+ public:
+  virtual ~ClientCallbackUnary() {}
+  virtual void StartCall() = 0;
+
+ protected:
+  void BindReactor(ClientUnaryReactor* reactor);
+};
+
+// The following classes are the reactor interfaces that are to be implemented
+// by the user. They are passed in to the library as an argument to a call on a
+// stub (either a codegen-ed call or a generic call). The streaming RPC is
+// activated by calling StartCall, possibly after initiating StartRead,
+// StartWrite, or AddHold operations on the streaming object. Note that none of
+// the classes are pure; all reactions have a default empty reaction so that the
+// user class only needs to override those reactions that it cares about.
+// The reactor must be passed to the stub invocation before any of the below
+// operations can be called and its reactions will be invoked by the library in
+// response to the completion of various operations. Reactions must not include
+// blocking operations (such as blocking I/O, starting synchronous RPCs, or
+// waiting on condition variables). Reactions may be invoked concurrently,
+// except that OnDone is called after all others (assuming proper API usage).
+// The reactor may not be deleted until OnDone is called.
+
+/// \a ClientBidiReactor is the interface for a bidirectional streaming RPC.
+template <class Request, class Response>
+class ClientBidiReactor : public internal::ClientReactor {
+ public:
+  /// Activate the RPC and initiate any reads or writes that have been Start'ed
+  /// before this call. All streaming RPCs issued by the client MUST have
+  /// StartCall invoked on them (even if they are canceled) as this call is the
+  /// activation of their lifecycle.
+  void StartCall() { stream_->StartCall(); }
+
+  /// Initiate a read operation (or post it for later initiation if StartCall
+  /// has not yet been invoked).
+  ///
+  /// \param[out] resp Where to eventually store the read message. Valid when
+  ///                  the library calls OnReadDone
+  void StartRead(Response* resp) { stream_->Read(resp); }
+
+  /// Initiate a write operation (or post it for later initiation if StartCall
+  /// has not yet been invoked).
+  ///
+  /// \param[in] req The message to be written. The library does not take
+  ///                ownership but the caller must ensure that the message is
+  ///                not deleted or modified until OnWriteDone is called.
+  void StartWrite(const Request* req) { StartWrite(req, grpc::WriteOptions()); }
+
+  /// Initiate/post a write operation with specified options.
+  ///
+  /// \param[in] req The message to be written. The library does not take
+  ///                ownership but the caller must ensure that the message is
+  ///                not deleted or modified until OnWriteDone is called.
+  /// \param[in] options The WriteOptions to use for writing this message
+  void StartWrite(const Request* req, grpc::WriteOptions options) {
+    stream_->Write(req, options);
+  }
+
+  /// Initiate/post a write operation with specified options and an indication
+  /// that this is the last write (like StartWrite and StartWritesDone, merged).
+  /// Note that calling this means that no more calls to StartWrite,
+  /// StartWriteLast, or StartWritesDone are allowed.
+  ///
+  /// \param[in] req The message to be written. The library does not take
+  ///                ownership but the caller must ensure that the message is
+  ///                not deleted or modified until OnWriteDone is called.
+  /// \param[in] options The WriteOptions to use for writing this message
+  void StartWriteLast(const Request* req, grpc::WriteOptions options) {
+    StartWrite(req, options.set_last_message());
+  }
+
+  /// Indicate that the RPC will have no more write operations. This can only be
+  /// issued once for a given RPC. This is not required or allowed if
+  /// StartWriteLast is used since that already has the same implication.
+  /// Note that calling this means that no more calls to StartWrite,
+  /// StartWriteLast, or StartWritesDone are allowed.
+  void StartWritesDone() { stream_->WritesDone(); }
+
+  /// Holds are needed if (and only if) this stream has operations that take
+  /// place on it after StartCall but from outside one of the reactions
+  /// (OnReadDone, etc). This is _not_ a common use of the streaming API.
+  ///
+  /// Holds must be added before calling StartCall. If a stream still has a hold
+  /// in place, its resources will not be destroyed even if the status has
+  /// already come in from the wire and there are currently no active callbacks
+  /// outstanding. Similarly, the stream will not call OnDone if there are still
+  /// holds on it.
+  ///
+  /// For example, if a StartRead or StartWrite operation is going to be
+  /// initiated from elsewhere in the application, the application should call
+  /// AddHold or AddMultipleHolds before StartCall.  If there is going to be,
+  /// for example, a read-flow and a write-flow taking place outside the
+  /// reactions, then call AddMultipleHolds(2) before StartCall. When the
+  /// application knows that it won't issue any more read operations (such as
+  /// when a read comes back as not ok), it should issue a RemoveHold(). It
+  /// should also call RemoveHold() again after it does StartWriteLast or
+  /// StartWritesDone that indicates that there will be no more write ops.
+  /// The number of RemoveHold calls must match the total number of AddHold
+  /// calls plus the number of holds added by AddMultipleHolds.
+  /// The argument to AddMultipleHolds must be positive.
+  void AddHold() { AddMultipleHolds(1); }
+  void AddMultipleHolds(int holds) {
+    GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
+    stream_->AddHold(holds);
+  }
+  void RemoveHold() { stream_->RemoveHold(); }
+
+  /// Notifies the application that all operations associated with this RPC
+  /// have completed and all Holds have been removed. OnDone provides the RPC
+  /// status outcome for both successful and failed RPCs and will be called in
+  /// all cases. If it is not called, it indicates an application-level problem
+  /// (like failure to remove a hold).
+  ///
+  /// \param[in] s The status outcome of this RPC
+  void OnDone(const grpc::Status& /*s*/) override {}
+
+  /// Notifies the application that a read of initial metadata from the
+  /// server is done. If the application chooses not to implement this method,
+  /// it can assume that the initial metadata has been read before the first
+  /// call of OnReadDone or OnDone.
+  ///
+  /// \param[in] ok Was the initial metadata read successfully? If false, no
+  ///               new read/write operation will succeed, and any further
+  ///               Start* operations should not be called.
+  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
+
+  /// Notifies the application that a StartRead operation completed.
+  ///
+  /// \param[in] ok Was it successful? If false, no new read/write operation
+  ///               will succeed, and any further Start* should not be called.
+  virtual void OnReadDone(bool /*ok*/) {}
+
+  /// Notifies the application that a StartWrite or StartWriteLast operation
+  /// completed.
+  ///
+  /// \param[in] ok Was it successful? If false, no new read/write operation
+  ///               will succeed, and any further Start* should not be called.
+  virtual void OnWriteDone(bool /*ok*/) {}
+
+  /// Notifies the application that a StartWritesDone operation completed. Note
+  /// that this is only used on explicit StartWritesDone operations and not for
+  /// those that are implicitly invoked as part of a StartWriteLast.
+  ///
+  /// \param[in] ok Was it successful? If false, the application will later see
+  ///               the failure reflected as a bad status in OnDone and no
+  ///               further Start* should be called.
+  virtual void OnWritesDoneDone(bool /*ok*/) {}
+
+ private:
+  friend class ClientCallbackReaderWriter<Request, Response>;
+  void BindStream(ClientCallbackReaderWriter<Request, Response>* stream) {
+    stream_ = stream;
+  }
+  ClientCallbackReaderWriter<Request, Response>* stream_;
+};
+
+/// \a ClientReadReactor is the interface for a server-streaming RPC.
+/// All public methods behave as in ClientBidiReactor.
+template <class Response>
+class ClientReadReactor : public internal::ClientReactor {
+ public:
+  void StartCall() { reader_->StartCall(); }
+  void StartRead(Response* resp) { reader_->Read(resp); }
+
+  void AddHold() { AddMultipleHolds(1); }
+  void AddMultipleHolds(int holds) {
+    GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
+    reader_->AddHold(holds);
+  }
+  void RemoveHold() { reader_->RemoveHold(); }
+
+  void OnDone(const grpc::Status& /*s*/) override {}
+  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
+  virtual void OnReadDone(bool /*ok*/) {}
+
+ private:
+  friend class ClientCallbackReader<Response>;
+  void BindReader(ClientCallbackReader<Response>* reader) { reader_ = reader; }
+  ClientCallbackReader<Response>* reader_;
+};
+
+/// \a ClientWriteReactor is the interface for a client-streaming RPC.
+/// All public methods behave as in ClientBidiReactor.
+template <class Request>
+class ClientWriteReactor : public internal::ClientReactor {
+ public:
+  void StartCall() { writer_->StartCall(); }
+  void StartWrite(const Request* req) { StartWrite(req, grpc::WriteOptions()); }
+  void StartWrite(const Request* req, grpc::WriteOptions options) {
+    writer_->Write(req, options);
+  }
+  void StartWriteLast(const Request* req, grpc::WriteOptions options) {
+    StartWrite(req, options.set_last_message());
+  }
+  void StartWritesDone() { writer_->WritesDone(); }
+
+  void AddHold() { AddMultipleHolds(1); }
+  void AddMultipleHolds(int holds) {
+    GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
+    writer_->AddHold(holds);
+  }
+  void RemoveHold() { writer_->RemoveHold(); }
+
+  void OnDone(const grpc::Status& /*s*/) override {}
+  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
+  virtual void OnWriteDone(bool /*ok*/) {}
+  virtual void OnWritesDoneDone(bool /*ok*/) {}
+
+ private:
+  friend class ClientCallbackWriter<Request>;
+  void BindWriter(ClientCallbackWriter<Request>* writer) { writer_ = writer; }
+
+  ClientCallbackWriter<Request>* writer_;
+};
+
+/// \a ClientUnaryReactor is a reactor-style interface for a unary RPC.
+/// This is _not_ a common way of invoking a unary RPC. In practice, this
+/// option should be used only if the unary RPC wants to receive initial
+/// metadata without waiting for the response to complete. Most deployments of
+/// RPC systems do not use this option, but it is needed for generality.
+/// All public methods behave as in ClientBidiReactor.
+/// StartCall is included for consistency with the other reactor flavors: even
+/// though there are no StartRead or StartWrite operations to queue before the
+/// call (that is part of the unary call itself) and there is no reactor object
+/// being created as a result of this call, we keep a consistent 2-phase
+/// initiation API among all the reactor flavors.
+class ClientUnaryReactor : public internal::ClientReactor {
+ public:
+  void StartCall() { call_->StartCall(); }
+  void OnDone(const grpc::Status& /*s*/) override {}
+  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
+
+ private:
+  friend class ClientCallbackUnary;
+  void BindCall(ClientCallbackUnary* call) { call_ = call; }
+  ClientCallbackUnary* call_;
+};
+
+// Define function out-of-line from class to avoid forward declaration issue
+inline void ClientCallbackUnary::BindReactor(ClientUnaryReactor* reactor) {
+  reactor->BindCall(this);
+}
+
+namespace internal {
+
+// Forward declare factory classes for friendship
+template <class Request, class Response>
+class ClientCallbackReaderWriterFactory;
+template <class Response>
+class ClientCallbackReaderFactory;
+template <class Request>
+class ClientCallbackWriterFactory;
+
+template <class Request, class Response>
+class ClientCallbackReaderWriterImpl
+    : public ClientCallbackReaderWriter<Request, Response> {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackReaderWriterImpl));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_) override {
+    // This call initiates two batches, plus any backlog, each with a callback
+    // 1. Send initial metadata (unless corked) + recv initial metadata
+    // 2. Any read backlog
+    // 3. Any write backlog
+    // 4. Recv trailing metadata (unless corked)
+    if (!start_corked_) {
+      start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                     context_->initial_metadata_flags());
+    }
+
+    call_.PerformOps(&start_ops_);
+
+    {
+      grpc::internal::MutexLock lock(&start_mu_);
+
+      if (backlog_.read_ops) {
+        call_.PerformOps(&read_ops_);
+      }
+      if (backlog_.write_ops) {
+        call_.PerformOps(&write_ops_);
+      }
+      if (backlog_.writes_done_ops) {
+        call_.PerformOps(&writes_done_ops_);
+      }
+      call_.PerformOps(&finish_ops_);
+      // The last thing in this critical section is to set started_ so that it
+      // can be used lock-free as well.
+      started_.store(true, std::memory_order_release);
+    }
+    // MaybeFinish outside the lock to make sure that destruction of this object
+    // doesn't take place while holding the lock (which would cause the lock to
+    // be released after destruction)
+    this->MaybeFinish(/*from_reaction=*/false);
+  }
+
+  void Read(Response* msg) override {
+    read_ops_.RecvMessage(msg);
+    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
+      grpc::internal::MutexLock lock(&start_mu_);
+      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
+        backlog_.read_ops = true;
+        return;
+      }
+    }
+    call_.PerformOps(&read_ops_);
+  }
+
+  void Write(const Request* msg, grpc::WriteOptions options)
+      ABSL_LOCKS_EXCLUDED(start_mu_) override {
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+      write_ops_.ClientSendClose();
+    }
+    // TODO(vjpai): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(msg, options).ok());
+    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+    if (GPR_UNLIKELY(corked_write_needed_)) {
+      write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                     context_->initial_metadata_flags());
+      corked_write_needed_ = false;
+    }
+
+    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
+      grpc::internal::MutexLock lock(&start_mu_);
+      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
+        backlog_.write_ops = true;
+        return;
+      }
+    }
+    call_.PerformOps(&write_ops_);
+  }
+  void WritesDone() ABSL_LOCKS_EXCLUDED(start_mu_) override {
+    writes_done_ops_.ClientSendClose();
+    writes_done_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnWritesDoneDone(ok);
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &writes_done_ops_, /*can_inline=*/false);
+    writes_done_ops_.set_core_cq_tag(&writes_done_tag_);
+    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+    if (GPR_UNLIKELY(corked_write_needed_)) {
+      writes_done_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                           context_->initial_metadata_flags());
+      corked_write_needed_ = false;
+    }
+    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
+      grpc::internal::MutexLock lock(&start_mu_);
+      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
+        backlog_.writes_done_ops = true;
+        return;
+      }
+    }
+    call_.PerformOps(&writes_done_ops_);
+  }
+
+  void AddHold(int holds) override {
+    callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
+  }
+  void RemoveHold() override { MaybeFinish(/*from_reaction=*/false); }
+
+ private:
+  friend class ClientCallbackReaderWriterFactory<Request, Response>;
+
+  ClientCallbackReaderWriterImpl(grpc::internal::Call call,
+                                 grpc::ClientContext* context,
+                                 ClientBidiReactor<Request, Response>* reactor)
+      : context_(context),
+        call_(call),
+        reactor_(reactor),
+        start_corked_(context_->initial_metadata_corked_),
+        corked_write_needed_(start_corked_) {
+    this->BindReactor(reactor);
+
+    // Set up the unchanging parts of the start, read, and write tags and ops.
+    start_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnReadInitialMetadataDone(
+              ok && !reactor_->InternalTrailersOnly(call_.call()));
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &start_ops_, /*can_inline=*/false);
+    start_ops_.RecvInitialMetadata(context_);
+    start_ops_.set_core_cq_tag(&start_tag_);
+
+    write_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnWriteDone(ok);
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &write_ops_, /*can_inline=*/false);
+    write_ops_.set_core_cq_tag(&write_tag_);
+
+    read_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnReadDone(ok);
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &read_ops_, /*can_inline=*/false);
+    read_ops_.set_core_cq_tag(&read_tag_);
+
+    // Also set up the Finish tag and op set.
+    finish_tag_.Set(
+        call_.call(),
+        [this](bool /*ok*/) { MaybeFinish(/*from_reaction=*/true); },
+        &finish_ops_,
+        /*can_inline=*/false);
+    finish_ops_.ClientRecvStatus(context_, &finish_status_);
+    finish_ops_.set_core_cq_tag(&finish_tag_);
+  }
+
+  // MaybeFinish can be called from reactions or from user-initiated operations
+  // like StartCall or RemoveHold. If this is the last operation or hold on this
+  // object, it will invoke the OnDone reaction. If MaybeFinish was called from
+  // a reaction, it can call OnDone directly. If not, it would need to schedule
+  // OnDone onto an executor thread to avoid the possibility of deadlocking with
+  // any locks in the user code that invoked it.
+  void MaybeFinish(bool from_reaction) {
+    if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(
+                         1, std::memory_order_acq_rel) == 1)) {
+      grpc::Status s = std::move(finish_status_);
+      auto* reactor = reactor_;
+      auto* call = call_.call();
+      this->~ClientCallbackReaderWriterImpl();
+      grpc::g_core_codegen_interface->grpc_call_unref(call);
+      if (GPR_LIKELY(from_reaction)) {
+        reactor->OnDone(s);
+      } else {
+        reactor->InternalScheduleOnDone(std::move(s));
+      }
+    }
+  }
+
+  grpc::ClientContext* const context_;
+  grpc::internal::Call call_;
+  ClientBidiReactor<Request, Response>* const reactor_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpRecvInitialMetadata>
+      start_ops_;
+  grpc::internal::CallbackWithSuccessTag start_tag_;
+  const bool start_corked_;
+  bool corked_write_needed_;  // no lock needed since only accessed in
+                              // Write/WritesDone which cannot be concurrent
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpClientRecvStatus> finish_ops_;
+  grpc::internal::CallbackWithSuccessTag finish_tag_;
+  grpc::Status finish_status_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpClientSendClose>
+      write_ops_;
+  grpc::internal::CallbackWithSuccessTag write_tag_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpClientSendClose>
+      writes_done_ops_;
+  grpc::internal::CallbackWithSuccessTag writes_done_tag_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<Response>>
+      read_ops_;
+  grpc::internal::CallbackWithSuccessTag read_tag_;
+
+  struct StartCallBacklog {
+    bool write_ops = false;
+    bool writes_done_ops = false;
+    bool read_ops = false;
+  };
+  StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
+
+  // Minimum of 3 callbacks to pre-register for start ops, StartCall, and finish
+  std::atomic<intptr_t> callbacks_outstanding_{3};
+  std::atomic_bool started_{false};
+  grpc::internal::Mutex start_mu_;
+};
+
+template <class Request, class Response>
+class ClientCallbackReaderWriterFactory {
+ public:
+  static void Create(grpc::ChannelInterface* channel,
+                     const grpc::internal::RpcMethod& method,
+                     grpc::ClientContext* context,
+                     ClientBidiReactor<Request, Response>* reactor) {
+    grpc::internal::Call call =
+        channel->CreateCall(method, context, channel->CallbackCQ());
+
+    grpc::g_core_codegen_interface->grpc_call_ref(call.call());
+    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call.call(), sizeof(ClientCallbackReaderWriterImpl<Request, Response>)))
+        ClientCallbackReaderWriterImpl<Request, Response>(call, context,
+                                                          reactor);
+  }
+};
+
+template <class Response>
+class ClientCallbackReaderImpl : public ClientCallbackReader<Response> {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackReaderImpl));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  void StartCall() override {
+    // This call initiates two batches, plus any backlog, each with a callback
+    // 1. Send initial metadata (unless corked) + recv initial metadata
+    // 2. Any backlog
+    // 3. Recv trailing metadata
+
+    start_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnReadInitialMetadataDone(
+              ok && !reactor_->InternalTrailersOnly(call_.call()));
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &start_ops_, /*can_inline=*/false);
+    start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                   context_->initial_metadata_flags());
+    start_ops_.RecvInitialMetadata(context_);
+    start_ops_.set_core_cq_tag(&start_tag_);
+    call_.PerformOps(&start_ops_);
+
+    // Also set up the read tag so it doesn't have to be set up each time
+    read_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnReadDone(ok);
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &read_ops_, /*can_inline=*/false);
+    read_ops_.set_core_cq_tag(&read_tag_);
+
+    {
+      grpc::internal::MutexLock lock(&start_mu_);
+      if (backlog_.read_ops) {
+        call_.PerformOps(&read_ops_);
+      }
+      started_.store(true, std::memory_order_release);
+    }
+
+    finish_tag_.Set(
+        call_.call(),
+        [this](bool /*ok*/) { MaybeFinish(/*from_reaction=*/true); },
+        &finish_ops_, /*can_inline=*/false);
+    finish_ops_.ClientRecvStatus(context_, &finish_status_);
+    finish_ops_.set_core_cq_tag(&finish_tag_);
+    call_.PerformOps(&finish_ops_);
+  }
+
+  void Read(Response* msg) override {
+    read_ops_.RecvMessage(msg);
+    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
+      grpc::internal::MutexLock lock(&start_mu_);
+      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
+        backlog_.read_ops = true;
+        return;
+      }
+    }
+    call_.PerformOps(&read_ops_);
+  }
+
+  void AddHold(int holds) override {
+    callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
+  }
+  void RemoveHold() override { MaybeFinish(/*from_reaction=*/false); }
+
+ private:
+  friend class ClientCallbackReaderFactory<Response>;
+
+  template <class Request>
+  ClientCallbackReaderImpl(grpc::internal::Call call,
+                           grpc::ClientContext* context, Request* request,
+                           ClientReadReactor<Response>* reactor)
+      : context_(context), call_(call), reactor_(reactor) {
+    this->BindReactor(reactor);
+    // TODO(vjpai): don't assert
+    GPR_CODEGEN_ASSERT(start_ops_.SendMessagePtr(request).ok());
+    start_ops_.ClientSendClose();
+  }
+
+  // MaybeFinish behaves as in ClientCallbackReaderWriterImpl.
+  void MaybeFinish(bool from_reaction) {
+    if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(
+                         1, std::memory_order_acq_rel) == 1)) {
+      grpc::Status s = std::move(finish_status_);
+      auto* reactor = reactor_;
+      auto* call = call_.call();
+      this->~ClientCallbackReaderImpl();
+      grpc::g_core_codegen_interface->grpc_call_unref(call);
+      if (GPR_LIKELY(from_reaction)) {
+        reactor->OnDone(s);
+      } else {
+        reactor->InternalScheduleOnDone(std::move(s));
+      }
+    }
+  }
+
+  grpc::ClientContext* const context_;
+  grpc::internal::Call call_;
+  ClientReadReactor<Response>* const reactor_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpClientSendClose,
+                            grpc::internal::CallOpRecvInitialMetadata>
+      start_ops_;
+  grpc::internal::CallbackWithSuccessTag start_tag_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpClientRecvStatus> finish_ops_;
+  grpc::internal::CallbackWithSuccessTag finish_tag_;
+  grpc::Status finish_status_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<Response>>
+      read_ops_;
+  grpc::internal::CallbackWithSuccessTag read_tag_;
+
+  struct StartCallBacklog {
+    bool read_ops = false;
+  };
+  StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
+
+  // Minimum of 2 callbacks to pre-register for start and finish
+  std::atomic<intptr_t> callbacks_outstanding_{2};
+  std::atomic_bool started_{false};
+  grpc::internal::Mutex start_mu_;
+};
+
+template <class Response>
+class ClientCallbackReaderFactory {
+ public:
+  template <class Request>
+  static void Create(grpc::ChannelInterface* channel,
+                     const grpc::internal::RpcMethod& method,
+                     grpc::ClientContext* context, const Request* request,
+                     ClientReadReactor<Response>* reactor) {
+    grpc::internal::Call call =
+        channel->CreateCall(method, context, channel->CallbackCQ());
+
+    grpc::g_core_codegen_interface->grpc_call_ref(call.call());
+    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call.call(), sizeof(ClientCallbackReaderImpl<Response>)))
+        ClientCallbackReaderImpl<Response>(call, context, request, reactor);
+  }
+};
+
+template <class Request>
+class ClientCallbackWriterImpl : public ClientCallbackWriter<Request> {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackWriterImpl));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_) override {
+    // This call initiates two batches, plus any backlog, each with a callback
+    // 1. Send initial metadata (unless corked) + recv initial metadata
+    // 2. Any backlog
+    // 3. Recv trailing metadata
+
+    if (!start_corked_) {
+      start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                     context_->initial_metadata_flags());
+    }
+    call_.PerformOps(&start_ops_);
+
+    {
+      grpc::internal::MutexLock lock(&start_mu_);
+
+      if (backlog_.write_ops) {
+        call_.PerformOps(&write_ops_);
+      }
+      if (backlog_.writes_done_ops) {
+        call_.PerformOps(&writes_done_ops_);
+      }
+      call_.PerformOps(&finish_ops_);
+      // The last thing in this critical section is to set started_ so that it
+      // can be used lock-free as well.
+      started_.store(true, std::memory_order_release);
+    }
+    // MaybeFinish outside the lock to make sure that destruction of this object
+    // doesn't take place while holding the lock (which would cause the lock to
+    // be released after destruction)
+    this->MaybeFinish(/*from_reaction=*/false);
+  }
+
+  void Write(const Request* msg, grpc::WriteOptions options)
+      ABSL_LOCKS_EXCLUDED(start_mu_) override {
+    if (GPR_UNLIKELY(options.is_last_message())) {
+      options.set_buffer_hint();
+      write_ops_.ClientSendClose();
+    }
+    // TODO(vjpai): don't assert
+    GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(msg, options).ok());
+    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+
+    if (GPR_UNLIKELY(corked_write_needed_)) {
+      write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                     context_->initial_metadata_flags());
+      corked_write_needed_ = false;
+    }
+
+    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
+      grpc::internal::MutexLock lock(&start_mu_);
+      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
+        backlog_.write_ops = true;
+        return;
+      }
+    }
+    call_.PerformOps(&write_ops_);
+  }
+
+  void WritesDone() ABSL_LOCKS_EXCLUDED(start_mu_) override {
+    writes_done_ops_.ClientSendClose();
+    writes_done_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnWritesDoneDone(ok);
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &writes_done_ops_, /*can_inline=*/false);
+    writes_done_ops_.set_core_cq_tag(&writes_done_tag_);
+    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+
+    if (GPR_UNLIKELY(corked_write_needed_)) {
+      writes_done_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                           context_->initial_metadata_flags());
+      corked_write_needed_ = false;
+    }
+
+    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
+      grpc::internal::MutexLock lock(&start_mu_);
+      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
+        backlog_.writes_done_ops = true;
+        return;
+      }
+    }
+    call_.PerformOps(&writes_done_ops_);
+  }
+
+  void AddHold(int holds) override {
+    callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
+  }
+  void RemoveHold() override { MaybeFinish(/*from_reaction=*/false); }
+
+ private:
+  friend class ClientCallbackWriterFactory<Request>;
+
+  template <class Response>
+  ClientCallbackWriterImpl(grpc::internal::Call call,
+                           grpc::ClientContext* context, Response* response,
+                           ClientWriteReactor<Request>* reactor)
+      : context_(context),
+        call_(call),
+        reactor_(reactor),
+        start_corked_(context_->initial_metadata_corked_),
+        corked_write_needed_(start_corked_) {
+    this->BindReactor(reactor);
+
+    // Set up the unchanging parts of the start and write tags and ops.
+    start_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnReadInitialMetadataDone(
+              ok && !reactor_->InternalTrailersOnly(call_.call()));
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &start_ops_, /*can_inline=*/false);
+    start_ops_.RecvInitialMetadata(context_);
+    start_ops_.set_core_cq_tag(&start_tag_);
+
+    write_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnWriteDone(ok);
+          MaybeFinish(/*from_reaction=*/true);
+        },
+        &write_ops_, /*can_inline=*/false);
+    write_ops_.set_core_cq_tag(&write_tag_);
+
+    // Also set up the Finish tag and op set.
+    finish_ops_.RecvMessage(response);
+    finish_ops_.AllowNoMessage();
+    finish_tag_.Set(
+        call_.call(),
+        [this](bool /*ok*/) { MaybeFinish(/*from_reaction=*/true); },
+        &finish_ops_,
+        /*can_inline=*/false);
+    finish_ops_.ClientRecvStatus(context_, &finish_status_);
+    finish_ops_.set_core_cq_tag(&finish_tag_);
+  }
+
+  // MaybeFinish behaves as in ClientCallbackReaderWriterImpl.
+  void MaybeFinish(bool from_reaction) {
+    if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(
+                         1, std::memory_order_acq_rel) == 1)) {
+      grpc::Status s = std::move(finish_status_);
+      auto* reactor = reactor_;
+      auto* call = call_.call();
+      this->~ClientCallbackWriterImpl();
+      grpc::g_core_codegen_interface->grpc_call_unref(call);
+      if (GPR_LIKELY(from_reaction)) {
+        reactor->OnDone(s);
+      } else {
+        reactor->InternalScheduleOnDone(std::move(s));
+      }
+    }
+  }
+
+  grpc::ClientContext* const context_;
+  grpc::internal::Call call_;
+  ClientWriteReactor<Request>* const reactor_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpRecvInitialMetadata>
+      start_ops_;
+  grpc::internal::CallbackWithSuccessTag start_tag_;
+  const bool start_corked_;
+  bool corked_write_needed_;  // no lock needed since only accessed in
+                              // Write/WritesDone which cannot be concurrent
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpGenericRecvMessage,
+                            grpc::internal::CallOpClientRecvStatus>
+      finish_ops_;
+  grpc::internal::CallbackWithSuccessTag finish_tag_;
+  grpc::Status finish_status_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpClientSendClose>
+      write_ops_;
+  grpc::internal::CallbackWithSuccessTag write_tag_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpClientSendClose>
+      writes_done_ops_;
+  grpc::internal::CallbackWithSuccessTag writes_done_tag_;
+
+  struct StartCallBacklog {
+    bool write_ops = false;
+    bool writes_done_ops = false;
+  };
+  StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
+
+  // Minimum of 3 callbacks to pre-register for start ops, StartCall, and finish
+  std::atomic<intptr_t> callbacks_outstanding_{3};
+  std::atomic_bool started_{false};
+  grpc::internal::Mutex start_mu_;
+};
+
+template <class Request>
+class ClientCallbackWriterFactory {
+ public:
+  template <class Response>
+  static void Create(grpc::ChannelInterface* channel,
+                     const grpc::internal::RpcMethod& method,
+                     grpc::ClientContext* context, Response* response,
+                     ClientWriteReactor<Request>* reactor) {
+    grpc::internal::Call call =
+        channel->CreateCall(method, context, channel->CallbackCQ());
+
+    grpc::g_core_codegen_interface->grpc_call_ref(call.call());
+    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call.call(), sizeof(ClientCallbackWriterImpl<Request>)))
+        ClientCallbackWriterImpl<Request>(call, context, response, reactor);
+  }
+};
+
+class ClientCallbackUnaryImpl final : public ClientCallbackUnary {
+ public:
+  // always allocated against a call arena, no memory free required
+  static void operator delete(void* /*ptr*/, std::size_t size) {
+    GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackUnaryImpl));
+  }
+
+  // This operator should never be called as the memory should be freed as part
+  // of the arena destruction. It only exists to provide a matching operator
+  // delete to the operator new so that some compilers will not complain (see
+  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+  // there are no tests catching the compiler warning.
+  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
+
+  void StartCall() override {
+    // This call initiates two batches, each with a callback
+    // 1. Send initial metadata + write + writes done + recv initial metadata
+    // 2. Read message, recv trailing metadata
+
+    start_tag_.Set(
+        call_.call(),
+        [this](bool ok) {
+          reactor_->OnReadInitialMetadataDone(
+              ok && !reactor_->InternalTrailersOnly(call_.call()));
+          MaybeFinish();
+        },
+        &start_ops_, /*can_inline=*/false);
+    start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
+                                   context_->initial_metadata_flags());
+    start_ops_.RecvInitialMetadata(context_);
+    start_ops_.set_core_cq_tag(&start_tag_);
+    call_.PerformOps(&start_ops_);
+
+    finish_tag_.Set(
+        call_.call(), [this](bool /*ok*/) { MaybeFinish(); }, &finish_ops_,
+        /*can_inline=*/false);
+    finish_ops_.ClientRecvStatus(context_, &finish_status_);
+    finish_ops_.set_core_cq_tag(&finish_tag_);
+    call_.PerformOps(&finish_ops_);
+  }
+
+ private:
+  friend class ClientCallbackUnaryFactory;
+
+  template <class Request, class Response>
+  ClientCallbackUnaryImpl(grpc::internal::Call call,
+                          grpc::ClientContext* context, Request* request,
+                          Response* response, ClientUnaryReactor* reactor)
+      : context_(context), call_(call), reactor_(reactor) {
+    this->BindReactor(reactor);
+    // TODO(vjpai): don't assert
+    GPR_CODEGEN_ASSERT(start_ops_.SendMessagePtr(request).ok());
+    start_ops_.ClientSendClose();
+    finish_ops_.RecvMessage(response);
+    finish_ops_.AllowNoMessage();
+  }
+
+  // In the unary case, MaybeFinish is only ever invoked from a
+  // library-initiated reaction, so it will just directly call OnDone if this is
+  // the last reaction for this RPC.
+  void MaybeFinish() {
+    if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(
+                         1, std::memory_order_acq_rel) == 1)) {
+      grpc::Status s = std::move(finish_status_);
+      auto* reactor = reactor_;
+      auto* call = call_.call();
+      this->~ClientCallbackUnaryImpl();
+      grpc::g_core_codegen_interface->grpc_call_unref(call);
+      reactor->OnDone(s);
+    }
+  }
+
+  grpc::ClientContext* const context_;
+  grpc::internal::Call call_;
+  ClientUnaryReactor* const reactor_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpClientSendClose,
+                            grpc::internal::CallOpRecvInitialMetadata>
+      start_ops_;
+  grpc::internal::CallbackWithSuccessTag start_tag_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpGenericRecvMessage,
+                            grpc::internal::CallOpClientRecvStatus>
+      finish_ops_;
+  grpc::internal::CallbackWithSuccessTag finish_tag_;
+  grpc::Status finish_status_;
+
+  // This call will have 2 callbacks: start and finish
+  std::atomic<intptr_t> callbacks_outstanding_{2};
+};
+
+class ClientCallbackUnaryFactory {
+ public:
+  template <class Request, class Response, class BaseRequest = Request,
+            class BaseResponse = Response>
+  static void Create(grpc::ChannelInterface* channel,
+                     const grpc::internal::RpcMethod& method,
+                     grpc::ClientContext* context, const Request* request,
+                     Response* response, ClientUnaryReactor* reactor) {
+    grpc::internal::Call call =
+        channel->CreateCall(method, context, channel->CallbackCQ());
+
+    grpc::g_core_codegen_interface->grpc_call_ref(call.call());
+
+    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call.call(), sizeof(ClientCallbackUnaryImpl)))
+        ClientCallbackUnaryImpl(call, context,
+                                static_cast<const BaseRequest*>(request),
+                                static_cast<BaseResponse*>(response), reactor);
+  }
+};
+
+}  // namespace internal
+}  // namespace grpc
+#endif  // GRPCPP_IMPL_CODEGEN_CLIENT_CALLBACK_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_context.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_context.h
new file mode 100644
index 0000000..172546c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_context.h
@@ -0,0 +1,518 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+/// A ClientContext allows the person implementing a service client to:
+///
+/// - Add custom metadata key-value pairs that will propagated to the server
+/// side.
+/// - Control call settings such as compression and authentication.
+/// - Initial and trailing metadata coming from the server.
+/// - Get performance metrics (ie, census).
+///
+/// Context settings are only relevant to the call they are invoked with, that
+/// is to say, they aren't sticky. Some of these settings, such as the
+/// compression options, can be made persistent at channel construction time
+/// (see \a grpc::CreateCustomChannel).
+///
+/// \warning ClientContext instances should \em not be reused across rpcs.
+
+#ifndef GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_H
+#define GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_H
+
+// IWYU pragma: private, include <grpcpp/client_context.h>
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/codegen/propagation_bits.h>
+#include <grpcpp/impl/codegen/client_interceptor.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/create_auth_context.h>
+#include <grpcpp/impl/codegen/metadata_map.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/security/auth_context.h>
+#include <grpcpp/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/string_ref.h>
+#include <grpcpp/impl/codegen/sync.h>
+#include <grpcpp/impl/codegen/time.h>
+
+struct census_context;
+struct grpc_call;
+
+namespace grpc {
+class ServerContext;
+class ServerContextBase;
+class CallbackServerContext;
+
+namespace internal {
+template <class InputMessage, class OutputMessage>
+class CallbackUnaryCallImpl;
+template <class Request, class Response>
+class ClientCallbackReaderWriterImpl;
+template <class Response>
+class ClientCallbackReaderImpl;
+template <class Request>
+class ClientCallbackWriterImpl;
+class ClientCallbackUnaryImpl;
+class ClientContextAccessor;
+class ClientAsyncResponseReaderHelper;
+}  // namespace internal
+
+template <class R>
+class ClientReader;
+template <class W>
+class ClientWriter;
+template <class W, class R>
+class ClientReaderWriter;
+template <class R>
+class ClientAsyncReader;
+template <class W>
+class ClientAsyncWriter;
+template <class W, class R>
+class ClientAsyncReaderWriter;
+template <class R>
+class ClientAsyncResponseReader;
+
+namespace testing {
+class InteropClientContextInspector;
+class ClientContextTestPeer;
+}  // namespace testing
+
+namespace internal {
+class RpcMethod;
+template <class InputMessage, class OutputMessage>
+class BlockingUnaryCallImpl;
+class CallOpClientRecvStatus;
+class CallOpRecvInitialMetadata;
+class ServerContextImpl;
+template <class InputMessage, class OutputMessage>
+class CallbackUnaryCallImpl;
+template <class Request, class Response>
+class ClientCallbackReaderWriterImpl;
+template <class Response>
+class ClientCallbackReaderImpl;
+template <class Request>
+class ClientCallbackWriterImpl;
+class ClientCallbackUnaryImpl;
+class ClientContextAccessor;
+}  // namespace internal
+
+class CallCredentials;
+class Channel;
+class ChannelInterface;
+class CompletionQueue;
+
+/// Options for \a ClientContext::FromServerContext specifying which traits from
+/// the \a ServerContext to propagate (copy) from it into a new \a
+/// ClientContext.
+///
+/// \see ClientContext::FromServerContext
+class PropagationOptions {
+ public:
+  PropagationOptions() : propagate_(GRPC_PROPAGATE_DEFAULTS) {}
+
+  PropagationOptions& enable_deadline_propagation() {
+    propagate_ |= GRPC_PROPAGATE_DEADLINE;
+    return *this;
+  }
+
+  PropagationOptions& disable_deadline_propagation() {
+    propagate_ &= ~GRPC_PROPAGATE_DEADLINE;
+    return *this;
+  }
+
+  PropagationOptions& enable_census_stats_propagation() {
+    propagate_ |= GRPC_PROPAGATE_CENSUS_STATS_CONTEXT;
+    return *this;
+  }
+
+  PropagationOptions& disable_census_stats_propagation() {
+    propagate_ &= ~GRPC_PROPAGATE_CENSUS_STATS_CONTEXT;
+    return *this;
+  }
+
+  PropagationOptions& enable_census_tracing_propagation() {
+    propagate_ |= GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT;
+    return *this;
+  }
+
+  PropagationOptions& disable_census_tracing_propagation() {
+    propagate_ &= ~GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT;
+    return *this;
+  }
+
+  PropagationOptions& enable_cancellation_propagation() {
+    propagate_ |= GRPC_PROPAGATE_CANCELLATION;
+    return *this;
+  }
+
+  PropagationOptions& disable_cancellation_propagation() {
+    propagate_ &= ~GRPC_PROPAGATE_CANCELLATION;
+    return *this;
+  }
+
+  uint32_t c_bitmask() const { return propagate_; }
+
+ private:
+  uint32_t propagate_;
+};
+
+/// A ClientContext allows the person implementing a service client to:
+///
+/// - Add custom metadata key-value pairs that will propagated to the server
+///   side.
+/// - Control call settings such as compression and authentication.
+/// - Initial and trailing metadata coming from the server.
+/// - Get performance metrics (ie, census).
+///
+/// Context settings are only relevant to the call they are invoked with, that
+/// is to say, they aren't sticky. Some of these settings, such as the
+/// compression options, can be made persistent at channel construction time
+/// (see \a grpc::CreateCustomChannel).
+///
+/// \warning ClientContext instances should \em not be reused across rpcs.
+/// \warning The ClientContext instance used for creating an rpc must remain
+///          alive and valid for the lifetime of the rpc.
+class ClientContext {
+ public:
+  ClientContext();
+  ~ClientContext();
+
+  /// Create a new \a ClientContext as a child of an incoming server call,
+  /// according to \a options (\see PropagationOptions).
+  ///
+  /// \param server_context The source server context to use as the basis for
+  /// constructing the client context.
+  /// \param options The options controlling what to copy from the \a
+  /// server_context.
+  ///
+  /// \return A newly constructed \a ClientContext instance based on \a
+  /// server_context, with traits propagated (copied) according to \a options.
+  static std::unique_ptr<ClientContext> FromServerContext(
+      const grpc::ServerContextBase& server_context,
+      PropagationOptions options = PropagationOptions());
+  static std::unique_ptr<ClientContext> FromCallbackServerContext(
+      const grpc::CallbackServerContext& server_context,
+      PropagationOptions options = PropagationOptions());
+
+  /// Add the (\a meta_key, \a meta_value) pair to the metadata associated with
+  /// a client call. These are made available at the server side by the \a
+  /// grpc::ServerContext::client_metadata() method.
+  ///
+  /// \warning This method should only be called before invoking the rpc.
+  ///
+  /// \param meta_key The metadata key. If \a meta_value is binary data, it must
+  /// end in "-bin".
+  /// \param meta_value The metadata value. If its value is binary, the key name
+  /// must end in "-bin".
+  ///
+  /// Metadata must conform to the following format:
+  /**
+  \verbatim
+  Custom-Metadata -> Binary-Header / ASCII-Header
+  Binary-Header -> {Header-Name "-bin" } {binary value}
+  ASCII-Header -> Header-Name ASCII-Value
+  Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
+  ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
+  Custom-Metadata -> Binary-Header / ASCII-Header
+  \endverbatim
+  **/
+  void AddMetadata(const std::string& meta_key, const std::string& meta_value);
+
+  /// Return a collection of initial metadata key-value pairs. Note that keys
+  /// may happen more than once (ie, a \a std::multimap is returned).
+  ///
+  /// \warning This method should only be called after initial metadata has been
+  /// received. For streaming calls, see \a
+  /// ClientReaderInterface::WaitForInitialMetadata().
+  ///
+  /// \return A multimap of initial metadata key-value pairs from the server.
+  const std::multimap<grpc::string_ref, grpc::string_ref>&
+  GetServerInitialMetadata() const {
+    GPR_CODEGEN_ASSERT(initial_metadata_received_);
+    return *recv_initial_metadata_.map();
+  }
+
+  /// Return a collection of trailing metadata key-value pairs. Note that keys
+  /// may happen more than once (ie, a \a std::multimap is returned).
+  ///
+  /// \warning This method is only callable once the stream has finished.
+  ///
+  /// \return A multimap of metadata trailing key-value pairs from the server.
+  const std::multimap<grpc::string_ref, grpc::string_ref>&
+  GetServerTrailingMetadata() const {
+    // TODO(yangg) check finished
+    return *trailing_metadata_.map();
+  }
+
+  /// Set the deadline for the client call.
+  ///
+  /// \warning This method should only be called before invoking the rpc.
+  ///
+  /// \param deadline the deadline for the client call. Units are determined by
+  /// the type used. The deadline is an absolute (not relative) time.
+  template <typename T>
+  void set_deadline(const T& deadline) {
+    grpc::TimePoint<T> deadline_tp(deadline);
+    deadline_ = deadline_tp.raw_time();
+  }
+
+  /// Trigger wait-for-ready or not on this request.
+  /// See https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md.
+  /// If set, if an RPC is made when a channel's connectivity state is
+  /// TRANSIENT_FAILURE or CONNECTING, the call will not "fail fast",
+  /// and the channel will wait until the channel is READY before making the
+  /// call.
+  void set_wait_for_ready(bool wait_for_ready) {
+    wait_for_ready_ = wait_for_ready;
+    wait_for_ready_explicitly_set_ = true;
+  }
+
+  /// DEPRECATED: Use set_wait_for_ready() instead.
+  void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); }
+
+  /// Return the deadline for the client call.
+  std::chrono::system_clock::time_point deadline() const {
+    return grpc::Timespec2Timepoint(deadline_);
+  }
+
+  /// Return a \a gpr_timespec representation of the client call's deadline.
+  gpr_timespec raw_deadline() const { return deadline_; }
+
+  /// Set the per call authority header (see
+  /// https://tools.ietf.org/html/rfc7540#section-8.1.2.3).
+  void set_authority(const std::string& authority) { authority_ = authority; }
+
+  /// Return the authentication context for the associated client call.
+  /// It is only valid to call this during the lifetime of the client call.
+  ///
+  /// \see grpc::AuthContext.
+  std::shared_ptr<const grpc::AuthContext> auth_context() const {
+    if (auth_context_ == nullptr) {
+      auth_context_ = grpc::CreateAuthContext(call_);
+    }
+    return auth_context_;
+  }
+
+  /// Set credentials for the client call.
+  ///
+  /// A credentials object encapsulates all the state needed by a client to
+  /// authenticate with a server and make various assertions, e.g., about the
+  /// client’s identity, role, or whether it is authorized to make a particular
+  /// call.
+  ///
+  /// It is legal to call this only before initial metadata is sent.
+  ///
+  /// \see  https://grpc.io/docs/guides/auth.html
+  void set_credentials(const std::shared_ptr<grpc::CallCredentials>& creds);
+
+  /// EXPERIMENTAL debugging API
+  ///
+  /// Returns the credentials for the client call. This should be used only in
+  /// tests and for diagnostic purposes, and should not be used by application
+  /// logic.
+  std::shared_ptr<grpc::CallCredentials> credentials() { return creds_; }
+
+  /// Return the compression algorithm the client call will request be used.
+  /// Note that the gRPC runtime may decide to ignore this request, for example,
+  /// due to resource constraints.
+  grpc_compression_algorithm compression_algorithm() const {
+    return compression_algorithm_;
+  }
+
+  /// Set \a algorithm to be the compression algorithm used for the client call.
+  ///
+  /// \param algorithm The compression algorithm used for the client call.
+  void set_compression_algorithm(grpc_compression_algorithm algorithm);
+
+  /// Flag whether the initial metadata should be \a corked
+  ///
+  /// If \a corked is true, then the initial metadata will be coalesced with the
+  /// write of first message in the stream. As a result, any tag set for the
+  /// initial metadata operation (starting a client-streaming or bidi-streaming
+  /// RPC) will not actually be sent to the completion queue or delivered
+  /// via Next.
+  ///
+  /// \param corked The flag indicating whether the initial metadata is to be
+  /// corked or not.
+  void set_initial_metadata_corked(bool corked) {
+    initial_metadata_corked_ = corked;
+  }
+
+  /// Return the peer uri in a string.
+  /// It is only valid to call this during the lifetime of the client call.
+  ///
+  /// \warning This value is never authenticated or subject to any security
+  /// related code. It must not be used for any authentication related
+  /// functionality. Instead, use auth_context.
+  ///
+  /// \return The call's peer URI.
+  std::string peer() const;
+
+  /// Sets the census context.
+  /// It is only valid to call this before the client call is created. A common
+  /// place of setting census context is from within the DefaultConstructor
+  /// method of GlobalCallbacks.
+  void set_census_context(struct census_context* ccp) { census_context_ = ccp; }
+
+  /// Returns the census context that has been set, or nullptr if not set.
+  struct census_context* census_context() const {
+    return census_context_;
+  }
+
+  /// Send a best-effort out-of-band cancel on the call associated with
+  /// this client context.  The call could be in any stage; e.g., if it is
+  /// already finished, it may still return success.
+  ///
+  /// There is no guarantee the call will be cancelled.
+  ///
+  /// Note that TryCancel() does not change any of the tags that are pending
+  /// on the completion queue. All pending tags will still be delivered
+  /// (though their ok result may reflect the effect of cancellation).
+  void TryCancel();
+
+  /// Global Callbacks
+  ///
+  /// Can be set exactly once per application to install hooks whenever
+  /// a client context is constructed and destructed.
+  class GlobalCallbacks {
+   public:
+    virtual ~GlobalCallbacks() {}
+    virtual void DefaultConstructor(ClientContext* context) = 0;
+    virtual void Destructor(ClientContext* context) = 0;
+  };
+  static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
+
+  /// Should be used for framework-level extensions only.
+  /// Applications never need to call this method.
+  grpc_call* c_call() { return call_; }
+
+  /// EXPERIMENTAL debugging API
+  ///
+  /// if status is not ok() for an RPC, this will return a detailed string
+  /// of the gRPC Core error that led to the failure. It should not be relied
+  /// upon for anything other than gaining more debug data in failure cases.
+  std::string debug_error_string() const { return debug_error_string_; }
+
+ private:
+  // Disallow copy and assign.
+  ClientContext(const ClientContext&);
+  ClientContext& operator=(const ClientContext&);
+
+  friend class grpc::testing::InteropClientContextInspector;
+  friend class grpc::testing::ClientContextTestPeer;
+  friend class grpc::internal::CallOpClientRecvStatus;
+  friend class grpc::internal::CallOpRecvInitialMetadata;
+  friend class grpc::Channel;
+  template <class R>
+  friend class grpc::ClientReader;
+  template <class W>
+  friend class grpc::ClientWriter;
+  template <class W, class R>
+  friend class grpc::ClientReaderWriter;
+  template <class R>
+  friend class grpc::ClientAsyncReader;
+  template <class W>
+  friend class grpc::ClientAsyncWriter;
+  template <class W, class R>
+  friend class grpc::ClientAsyncReaderWriter;
+  template <class R>
+  friend class grpc::ClientAsyncResponseReader;
+  friend class grpc::internal::ClientAsyncResponseReaderHelper;
+  template <class InputMessage, class OutputMessage>
+  friend class grpc::internal::BlockingUnaryCallImpl;
+  template <class InputMessage, class OutputMessage>
+  friend class grpc::internal::CallbackUnaryCallImpl;
+  template <class Request, class Response>
+  friend class grpc::internal::ClientCallbackReaderWriterImpl;
+  template <class Response>
+  friend class grpc::internal::ClientCallbackReaderImpl;
+  template <class Request>
+  friend class grpc::internal::ClientCallbackWriterImpl;
+  friend class grpc::internal::ClientCallbackUnaryImpl;
+  friend class grpc::internal::ClientContextAccessor;
+
+  // Used by friend class CallOpClientRecvStatus
+  void set_debug_error_string(const std::string& debug_error_string) {
+    debug_error_string_ = debug_error_string;
+  }
+
+  grpc_call* call() const { return call_; }
+  void set_call(grpc_call* call, const std::shared_ptr<grpc::Channel>& channel);
+
+  grpc::experimental::ClientRpcInfo* set_client_rpc_info(
+      const char* method, const char* suffix_for_stats,
+      grpc::internal::RpcMethod::RpcType type, grpc::ChannelInterface* channel,
+      const std::vector<std::unique_ptr<
+          grpc::experimental::ClientInterceptorFactoryInterface>>& creators,
+      size_t interceptor_pos) {
+    rpc_info_ = grpc::experimental::ClientRpcInfo(this, type, method,
+                                                  suffix_for_stats, channel);
+    rpc_info_.RegisterInterceptors(creators, interceptor_pos);
+    return &rpc_info_;
+  }
+
+  uint32_t initial_metadata_flags() const {
+    return (wait_for_ready_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0) |
+           (wait_for_ready_explicitly_set_
+                ? GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET
+                : 0);
+  }
+
+  std::string authority() { return authority_; }
+
+  void SendCancelToInterceptors();
+
+  static std::unique_ptr<ClientContext> FromInternalServerContext(
+      const grpc::ServerContextBase& server_context,
+      PropagationOptions options);
+
+  bool initial_metadata_received_;
+  bool wait_for_ready_;
+  bool wait_for_ready_explicitly_set_;
+  std::shared_ptr<grpc::Channel> channel_;
+  grpc::internal::Mutex mu_;
+  grpc_call* call_;
+  bool call_canceled_;
+  gpr_timespec deadline_;
+  grpc::string authority_;
+  std::shared_ptr<grpc::CallCredentials> creds_;
+  mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
+  struct census_context* census_context_;
+  std::multimap<std::string, std::string> send_initial_metadata_;
+  mutable grpc::internal::MetadataMap recv_initial_metadata_;
+  mutable grpc::internal::MetadataMap trailing_metadata_;
+
+  grpc_call* propagate_from_call_;
+  PropagationOptions propagation_options_;
+
+  grpc_compression_algorithm compression_algorithm_;
+  bool initial_metadata_corked_;
+
+  std::string debug_error_string_;
+
+  grpc::experimental::ClientRpcInfo rpc_info_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CLIENT_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_interceptor.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_interceptor.h
new file mode 100644
index 0000000..f3560b5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_interceptor.h
@@ -0,0 +1,199 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CLIENT_INTERCEPTOR_H
+#define GRPCPP_IMPL_CODEGEN_CLIENT_INTERCEPTOR_H
+
+// IWYU pragma: private, include <grpcpp/support/client_interceptor.h>
+
+#include <memory>
+#include <vector>
+
+#include <grpcpp/impl/codegen/interceptor.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/string_ref.h>
+
+namespace grpc {
+
+class Channel;
+class ClientContext;
+
+namespace internal {
+class InterceptorBatchMethodsImpl;
+}
+
+namespace experimental {
+class ClientRpcInfo;
+
+// A factory interface for creation of client interceptors. A vector of
+// factories can be provided at channel creation which will be used to create a
+// new vector of client interceptors per RPC. Client interceptor authors should
+// create a subclass of ClientInterceptorFactorInterface which creates objects
+// of their interceptors.
+class ClientInterceptorFactoryInterface {
+ public:
+  virtual ~ClientInterceptorFactoryInterface() {}
+  // Returns a pointer to an Interceptor object on successful creation, nullptr
+  // otherwise. If nullptr is returned, this server interceptor factory is
+  // ignored for the purposes of that RPC.
+  virtual Interceptor* CreateClientInterceptor(ClientRpcInfo* info) = 0;
+};
+}  // namespace experimental
+
+namespace internal {
+extern experimental::ClientInterceptorFactoryInterface*
+    g_global_client_interceptor_factory;
+}
+
+/// ClientRpcInfo represents the state of a particular RPC as it
+/// appears to an interceptor. It is created and owned by the library and
+/// passed to the CreateClientInterceptor method of the application's
+/// ClientInterceptorFactoryInterface implementation
+namespace experimental {
+class ClientRpcInfo {
+ public:
+  // TODO(yashykt): Stop default-constructing ClientRpcInfo and remove UNKNOWN
+  //                from the list of possible Types.
+  /// Type categorizes RPCs by unary or streaming type
+  enum class Type {
+    UNARY,
+    CLIENT_STREAMING,
+    SERVER_STREAMING,
+    BIDI_STREAMING,
+    UNKNOWN  // UNKNOWN is not API and will be removed later
+  };
+
+  ~ClientRpcInfo() {}
+
+  // Delete copy constructor but allow default move constructor
+  ClientRpcInfo(const ClientRpcInfo&) = delete;
+  ClientRpcInfo(ClientRpcInfo&&) = default;
+
+  // Getter methods
+
+  /// Return the fully-specified method name
+  const char* method() const { return method_; }
+
+  /// Return an identifying suffix for the client stub, or nullptr if one wasn't
+  /// specified.
+  const char* suffix_for_stats() const { return suffix_for_stats_; }
+
+  /// Return a pointer to the channel on which the RPC is being sent
+  ChannelInterface* channel() { return channel_; }
+
+  /// Return a pointer to the underlying ClientContext structure associated
+  /// with the RPC to support features that apply to it
+  grpc::ClientContext* client_context() { return ctx_; }
+
+  /// Return the type of the RPC (unary or a streaming flavor)
+  Type type() const { return type_; }
+
+ private:
+  static_assert(Type::UNARY ==
+                    static_cast<Type>(internal::RpcMethod::NORMAL_RPC),
+                "violated expectation about Type enum");
+  static_assert(Type::CLIENT_STREAMING ==
+                    static_cast<Type>(internal::RpcMethod::CLIENT_STREAMING),
+                "violated expectation about Type enum");
+  static_assert(Type::SERVER_STREAMING ==
+                    static_cast<Type>(internal::RpcMethod::SERVER_STREAMING),
+                "violated expectation about Type enum");
+  static_assert(Type::BIDI_STREAMING ==
+                    static_cast<Type>(internal::RpcMethod::BIDI_STREAMING),
+                "violated expectation about Type enum");
+
+  // Default constructor should only be used by ClientContext
+  ClientRpcInfo() = default;
+
+  // Constructor will only be called from ClientContext
+  ClientRpcInfo(grpc::ClientContext* ctx, internal::RpcMethod::RpcType type,
+                const char* method, const char* suffix_for_stats,
+                grpc::ChannelInterface* channel)
+      : ctx_(ctx),
+        type_(static_cast<Type>(type)),
+        method_(method),
+        suffix_for_stats_(suffix_for_stats),
+        channel_(channel) {}
+
+  // Move assignment should only be used by ClientContext
+  // TODO(yashykt): Delete move assignment
+  ClientRpcInfo& operator=(ClientRpcInfo&&) = default;
+
+  // Runs interceptor at pos \a pos.
+  void RunInterceptor(
+      experimental::InterceptorBatchMethods* interceptor_methods, size_t pos) {
+    GPR_CODEGEN_ASSERT(pos < interceptors_.size());
+    interceptors_[pos]->Intercept(interceptor_methods);
+  }
+
+  void RegisterInterceptors(
+      const std::vector<std::unique_ptr<
+          experimental::ClientInterceptorFactoryInterface>>& creators,
+      size_t interceptor_pos) {
+    if (interceptor_pos > creators.size()) {
+      // No interceptors to register
+      return;
+    }
+    // NOTE: The following is not a range-based for loop because it will only
+    //       iterate over a portion of the creators vector.
+    for (auto it = creators.begin() + interceptor_pos; it != creators.end();
+         ++it) {
+      auto* interceptor = (*it)->CreateClientInterceptor(this);
+      if (interceptor != nullptr) {
+        interceptors_.push_back(
+            std::unique_ptr<experimental::Interceptor>(interceptor));
+      }
+    }
+    if (internal::g_global_client_interceptor_factory != nullptr) {
+      interceptors_.push_back(std::unique_ptr<experimental::Interceptor>(
+          internal::g_global_client_interceptor_factory
+              ->CreateClientInterceptor(this)));
+    }
+  }
+
+  grpc::ClientContext* ctx_ = nullptr;
+  // TODO(yashykt): make type_ const once move-assignment is deleted
+  Type type_{Type::UNKNOWN};
+  const char* method_ = nullptr;
+  const char* suffix_for_stats_ = nullptr;
+  grpc::ChannelInterface* channel_ = nullptr;
+  std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_;
+  bool hijacked_ = false;
+  size_t hijacked_interceptor_ = 0;
+
+  friend class internal::InterceptorBatchMethodsImpl;
+  friend class grpc::ClientContext;
+};
+
+// PLEASE DO NOT USE THIS. ALWAYS PREFER PER CHANNEL INTERCEPTORS OVER A GLOBAL
+// INTERCEPTOR. IF USAGE IS ABSOLUTELY NECESSARY, PLEASE READ THE SAFETY NOTES.
+// Registers a global client interceptor factory object, which is used for all
+// RPCs made in this process. The application is responsible for maintaining the
+// life of the object while gRPC operations are in progress. The global
+// interceptor factory should only be registered once at the start of the
+// process before any gRPC operations have begun.
+void RegisterGlobalClientInterceptorFactory(
+    ClientInterceptorFactoryInterface* factory);
+
+// For testing purposes only
+void TestOnlyResetGlobalClientInterceptorFactory();
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CLIENT_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_unary_call.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_unary_call.h
new file mode 100644
index 0000000..86adb3e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_unary_call.h
@@ -0,0 +1,105 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CLIENT_UNARY_CALL_H
+#define GRPCPP_IMPL_CODEGEN_CLIENT_UNARY_CALL_H
+
+// IWYU pragma: private, include <grpcpp/impl/client_unary_call.h>
+
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/call_op_set.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+
+class ClientContext;
+namespace internal {
+class RpcMethod;
+
+/// Wrapper that performs a blocking unary call. May optionally specify the base
+/// class of the Request and Response so that the internal calls and structures
+/// below this may be based on those base classes and thus achieve code reuse
+/// across different RPCs (e.g., for protobuf, MessageLite would be a base
+/// class).
+template <class InputMessage, class OutputMessage,
+          class BaseInputMessage = InputMessage,
+          class BaseOutputMessage = OutputMessage>
+Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method,
+                         grpc::ClientContext* context,
+                         const InputMessage& request, OutputMessage* result) {
+  static_assert(std::is_base_of<BaseInputMessage, InputMessage>::value,
+                "Invalid input message specification");
+  static_assert(std::is_base_of<BaseOutputMessage, OutputMessage>::value,
+                "Invalid output message specification");
+  return BlockingUnaryCallImpl<BaseInputMessage, BaseOutputMessage>(
+             channel, method, context, request, result)
+      .status();
+}
+
+template <class InputMessage, class OutputMessage>
+class BlockingUnaryCallImpl {
+ public:
+  BlockingUnaryCallImpl(ChannelInterface* channel, const RpcMethod& method,
+                        grpc::ClientContext* context,
+                        const InputMessage& request, OutputMessage* result) {
+    grpc::CompletionQueue cq(grpc_completion_queue_attributes{
+        GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
+        nullptr});  // Pluckable completion queue
+    grpc::internal::Call call(channel->CreateCall(method, context, &cq));
+    CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
+              CallOpRecvInitialMetadata, CallOpRecvMessage<OutputMessage>,
+              CallOpClientSendClose, CallOpClientRecvStatus>
+        ops;
+    status_ = ops.SendMessagePtr(&request);
+    if (!status_.ok()) {
+      return;
+    }
+    ops.SendInitialMetadata(&context->send_initial_metadata_,
+                            context->initial_metadata_flags());
+    ops.RecvInitialMetadata(context);
+    ops.RecvMessage(result);
+    ops.AllowNoMessage();
+    ops.ClientSendClose();
+    ops.ClientRecvStatus(context, &status_);
+    call.PerformOps(&ops);
+    cq.Pluck(&ops);
+    // Some of the ops might fail. If the ops fail in the core layer, status
+    // would reflect the error. But, if the ops fail in the C++ layer, the
+    // status would still be the same as the one returned by gRPC Core. This can
+    // happen if deserialization of the message fails.
+    // TODO(yashykt): If deserialization fails, but the status received is OK,
+    // then it might be a good idea to change the status to something better
+    // than StatusCode::UNIMPLEMENTED to reflect this.
+    if (!ops.got_message && status_.ok()) {
+      status_ = Status(StatusCode::UNIMPLEMENTED,
+                       "No message returned for unary request");
+    }
+  }
+  Status status() { return status_; }
+
+ private:
+  Status status_;
+};
+
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CLIENT_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue.h
new file mode 100644
index 0000000..33786f6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue.h
@@ -0,0 +1,466 @@
+/*
+ *
+ * Copyright 2015-2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+/// A completion queue implements a concurrent producer-consumer queue, with
+/// two main API-exposed methods: \a Next and \a AsyncNext. These
+/// methods are the essential component of the gRPC C++ asynchronous API.
+/// There is also a \a Shutdown method to indicate that a given completion queue
+/// will no longer have regular events. This must be called before the
+/// completion queue is destroyed.
+/// All completion queue APIs are thread-safe and may be used concurrently with
+/// any other completion queue API invocation; it is acceptable to have
+/// multiple threads calling \a Next or \a AsyncNext on the same or different
+/// completion queues, or to call these methods concurrently with a \a Shutdown
+/// elsewhere.
+/// \remark{All other API calls on completion queue should be completed before
+/// a completion queue destructor is called.}
+#ifndef GRPCPP_IMPL_CODEGEN_COMPLETION_QUEUE_H
+#define GRPCPP_IMPL_CODEGEN_COMPLETION_QUEUE_H
+
+// IWYU pragma: private, include <grpcpp/completion_queue.h>
+
+#include <list>
+
+#include <grpc/impl/codegen/atm.h>
+#include <grpcpp/impl/codegen/completion_queue_tag.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/sync.h>
+#include <grpcpp/impl/codegen/time.h>
+
+struct grpc_completion_queue;
+
+namespace grpc {
+template <class R>
+class ClientReader;
+template <class W>
+class ClientWriter;
+template <class W, class R>
+class ClientReaderWriter;
+template <class R>
+class ServerReader;
+template <class W>
+class ServerWriter;
+namespace internal {
+template <class W, class R>
+class ServerReaderWriterBody;
+
+template <class ResponseType>
+void UnaryRunHandlerHelper(
+    const grpc::internal::MethodHandler::HandlerParameter&, ResponseType*,
+    grpc::Status&);
+template <class ServiceType, class RequestType, class ResponseType,
+          class BaseRequestType, class BaseResponseType>
+class RpcMethodHandler;
+template <class ServiceType, class RequestType, class ResponseType>
+class ClientStreamingHandler;
+template <class ServiceType, class RequestType, class ResponseType>
+class ServerStreamingHandler;
+template <class Streamer, bool WriteNeeded>
+class TemplatedBidiStreamingHandler;
+template <grpc::StatusCode code>
+class ErrorMethodHandler;
+}  // namespace internal
+
+class Channel;
+class ChannelInterface;
+class Server;
+class ServerBuilder;
+class ServerContextBase;
+class ServerInterface;
+
+namespace internal {
+class CompletionQueueTag;
+class RpcMethod;
+template <class InputMessage, class OutputMessage>
+class BlockingUnaryCallImpl;
+template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
+class CallOpSet;
+}  // namespace internal
+
+extern CoreCodegenInterface* g_core_codegen_interface;
+
+/// A thin wrapper around \ref grpc_completion_queue (see \ref
+/// src/core/lib/surface/completion_queue.h).
+/// See \ref doc/cpp/perf_notes.md for notes on best practices for high
+/// performance servers.
+class CompletionQueue : private grpc::GrpcLibraryCodegen {
+ public:
+  /// Default constructor. Implicitly creates a \a grpc_completion_queue
+  /// instance.
+  CompletionQueue()
+      : CompletionQueue(grpc_completion_queue_attributes{
+            GRPC_CQ_CURRENT_VERSION, GRPC_CQ_NEXT, GRPC_CQ_DEFAULT_POLLING,
+            nullptr}) {}
+
+  /// Wrap \a take, taking ownership of the instance.
+  ///
+  /// \param take The completion queue instance to wrap. Ownership is taken.
+  explicit CompletionQueue(grpc_completion_queue* take);
+
+  /// Destructor. Destroys the owned wrapped completion queue / instance.
+  ~CompletionQueue() override {
+    grpc::g_core_codegen_interface->grpc_completion_queue_destroy(cq_);
+  }
+
+  /// Tri-state return for AsyncNext: SHUTDOWN, GOT_EVENT, TIMEOUT.
+  enum NextStatus {
+    SHUTDOWN,   ///< The completion queue has been shutdown and fully-drained
+    GOT_EVENT,  ///< Got a new event; \a tag will be filled in with its
+                ///< associated value; \a ok indicating its success.
+    TIMEOUT     ///< deadline was reached.
+  };
+
+  /// Read from the queue, blocking until an event is available or the queue is
+  /// shutting down.
+  ///
+  /// \param[out] tag Updated to point to the read event's tag.
+  /// \param[out] ok true if read a successful event, false otherwise.
+  ///
+  /// Note that each tag sent to the completion queue (through RPC operations
+  /// or alarms) will be delivered out of the completion queue by a call to
+  /// Next (or a related method), regardless of whether the operation succeeded
+  /// or not. Success here means that this operation completed in the normal
+  /// valid manner.
+  ///
+  /// Server-side RPC request: \a ok indicates that the RPC has indeed
+  /// been started. If it is false, the server has been Shutdown
+  /// before this particular call got matched to an incoming RPC.
+  ///
+  /// Client-side StartCall/RPC invocation: \a ok indicates that the RPC is
+  /// going to go to the wire. If it is false, it not going to the wire. This
+  /// would happen if the channel is either permanently broken or
+  /// transiently broken but with the fail-fast option. (Note that async unary
+  /// RPCs don't post a CQ tag at this point, nor do client-streaming
+  /// or bidi-streaming RPCs that have the initial metadata corked option set.)
+  ///
+  /// Client-side Write, Client-side WritesDone, Server-side Write,
+  /// Server-side Finish, Server-side SendInitialMetadata (which is
+  /// typically included in Write or Finish when not done explicitly):
+  /// \a ok means that the data/metadata/status/etc is going to go to the
+  /// wire. If it is false, it not going to the wire because the call
+  /// is already dead (i.e., canceled, deadline expired, other side
+  /// dropped the channel, etc).
+  ///
+  /// Client-side Read, Server-side Read, Client-side
+  /// RecvInitialMetadata (which is typically included in Read if not
+  /// done explicitly): \a ok indicates whether there is a valid message
+  /// that got read. If not, you know that there are certainly no more
+  /// messages that can ever be read from this stream. For the client-side
+  /// operations, this only happens because the call is dead. For the
+  /// server-sider operation, though, this could happen because the client
+  /// has done a WritesDone already.
+  ///
+  /// Client-side Finish: \a ok should always be true
+  ///
+  /// Server-side AsyncNotifyWhenDone: \a ok should always be true
+  ///
+  /// Alarm: \a ok is true if it expired, false if it was canceled
+  ///
+  /// \return true if got an event, false if the queue is fully drained and
+  ///         shut down.
+  bool Next(void** tag, bool* ok) {
+    // Check return type == GOT_EVENT... cases:
+    // SHUTDOWN  - queue has been shutdown, return false.
+    // TIMEOUT   - we passed infinity time => queue has been shutdown, return
+    //             false.
+    // GOT_EVENT - we actually got an event, return true.
+    return (AsyncNextInternal(tag, ok,
+                              grpc::g_core_codegen_interface->gpr_inf_future(
+                                  GPR_CLOCK_REALTIME)) == GOT_EVENT);
+  }
+
+  /// Read from the queue, blocking up to \a deadline (or the queue's shutdown).
+  /// Both \a tag and \a ok are updated upon success (if an event is available
+  /// within the \a deadline).  A \a tag points to an arbitrary location usually
+  /// employed to uniquely identify an event.
+  ///
+  /// \param[out] tag Upon success, updated to point to the event's tag.
+  /// \param[out] ok Upon success, true if a successful event, false otherwise
+  ///        See documentation for CompletionQueue::Next for explanation of ok
+  /// \param[in] deadline How long to block in wait for an event.
+  ///
+  /// \return The type of event read.
+  template <typename T>
+  NextStatus AsyncNext(void** tag, bool* ok, const T& deadline) {
+    grpc::TimePoint<T> deadline_tp(deadline);
+    return AsyncNextInternal(tag, ok, deadline_tp.raw_time());
+  }
+
+  /// EXPERIMENTAL
+  /// First executes \a F, then reads from the queue, blocking up to
+  /// \a deadline (or the queue's shutdown).
+  /// Both \a tag and \a ok are updated upon success (if an event is available
+  /// within the \a deadline).  A \a tag points to an arbitrary location usually
+  /// employed to uniquely identify an event.
+  ///
+  /// \param[in] f Function to execute before calling AsyncNext on this queue.
+  /// \param[out] tag Upon success, updated to point to the event's tag.
+  /// \param[out] ok Upon success, true if read a regular event, false
+  /// otherwise.
+  /// \param[in] deadline How long to block in wait for an event.
+  ///
+  /// \return The type of event read.
+  template <typename T, typename F>
+  NextStatus DoThenAsyncNext(F&& f, void** tag, bool* ok, const T& deadline) {
+    CompletionQueueTLSCache cache = CompletionQueueTLSCache(this);
+    f();
+    if (cache.Flush(tag, ok)) {
+      return GOT_EVENT;
+    } else {
+      return AsyncNext(tag, ok, deadline);
+    }
+  }
+
+  /// Request the shutdown of the queue.
+  ///
+  /// \warning This method must be called at some point if this completion queue
+  /// is accessed with Next or AsyncNext. \a Next will not return false
+  /// until this method has been called and all pending tags have been drained.
+  /// (Likewise for \a AsyncNext returning \a NextStatus::SHUTDOWN .)
+  /// Only once either one of these methods does that (that is, once the queue
+  /// has been \em drained) can an instance of this class be destroyed.
+  /// Also note that applications must ensure that no work is enqueued on this
+  /// completion queue after this method is called.
+  void Shutdown();
+
+  /// Returns a \em raw pointer to the underlying \a grpc_completion_queue
+  /// instance.
+  ///
+  /// \warning Remember that the returned instance is owned. No transfer of
+  /// owership is performed.
+  grpc_completion_queue* cq() { return cq_; }
+
+ protected:
+  /// Private constructor of CompletionQueue only visible to friend classes
+  explicit CompletionQueue(const grpc_completion_queue_attributes& attributes) {
+    cq_ = grpc::g_core_codegen_interface->grpc_completion_queue_create(
+        grpc::g_core_codegen_interface->grpc_completion_queue_factory_lookup(
+            &attributes),
+        &attributes, nullptr);
+    InitialAvalanching();  // reserve this for the future shutdown
+  }
+
+ private:
+  // Friends for access to server registration lists that enable checking and
+  // logging on shutdown
+  friend class grpc::ServerBuilder;
+  friend class grpc::Server;
+
+  // Friend synchronous wrappers so that they can access Pluck(), which is
+  // a semi-private API geared towards the synchronous implementation.
+  template <class R>
+  friend class grpc::ClientReader;
+  template <class W>
+  friend class grpc::ClientWriter;
+  template <class W, class R>
+  friend class grpc::ClientReaderWriter;
+  template <class R>
+  friend class grpc::ServerReader;
+  template <class W>
+  friend class grpc::ServerWriter;
+  template <class W, class R>
+  friend class grpc::internal::ServerReaderWriterBody;
+  template <class ResponseType>
+  friend void grpc::internal::UnaryRunHandlerHelper(
+      const grpc::internal::MethodHandler::HandlerParameter&, ResponseType*,
+      grpc::Status&);
+  template <class ServiceType, class RequestType, class ResponseType>
+  friend class grpc::internal::ClientStreamingHandler;
+  template <class ServiceType, class RequestType, class ResponseType>
+  friend class grpc::internal::ServerStreamingHandler;
+  template <class Streamer, bool WriteNeeded>
+  friend class grpc::internal::TemplatedBidiStreamingHandler;
+  template <grpc::StatusCode code>
+  friend class grpc::internal::ErrorMethodHandler;
+  friend class grpc::ServerContextBase;
+  friend class grpc::ServerInterface;
+  template <class InputMessage, class OutputMessage>
+  friend class grpc::internal::BlockingUnaryCallImpl;
+
+  // Friends that need access to constructor for callback CQ
+  friend class grpc::Channel;
+
+  // For access to Register/CompleteAvalanching
+  template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
+  friend class grpc::internal::CallOpSet;
+
+  /// EXPERIMENTAL
+  /// Creates a Thread Local cache to store the first event
+  /// On this completion queue queued from this thread.  Once
+  /// initialized, it must be flushed on the same thread.
+  class CompletionQueueTLSCache {
+   public:
+    explicit CompletionQueueTLSCache(CompletionQueue* cq);
+    ~CompletionQueueTLSCache();
+    bool Flush(void** tag, bool* ok);
+
+   private:
+    CompletionQueue* cq_;
+    bool flushed_;
+  };
+
+  NextStatus AsyncNextInternal(void** tag, bool* ok, gpr_timespec deadline);
+
+  /// Wraps \a grpc_completion_queue_pluck.
+  /// \warning Must not be mixed with calls to \a Next.
+  bool Pluck(grpc::internal::CompletionQueueTag* tag) {
+    auto deadline =
+        grpc::g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME);
+    while (true) {
+      auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
+          cq_, tag, deadline, nullptr);
+      bool ok = ev.success != 0;
+      void* ignored = tag;
+      if (tag->FinalizeResult(&ignored, &ok)) {
+        GPR_CODEGEN_ASSERT(ignored == tag);
+        return ok;
+      }
+    }
+  }
+
+  /// Performs a single polling pluck on \a tag.
+  /// \warning Must not be mixed with calls to \a Next.
+  ///
+  /// TODO: sreek - This calls tag->FinalizeResult() even if the cq_ is already
+  /// shutdown. This is most likely a bug and if it is a bug, then change this
+  /// implementation to simple call the other TryPluck function with a zero
+  /// timeout. i.e:
+  ///      TryPluck(tag, gpr_time_0(GPR_CLOCK_REALTIME))
+  void TryPluck(grpc::internal::CompletionQueueTag* tag) {
+    auto deadline =
+        grpc::g_core_codegen_interface->gpr_time_0(GPR_CLOCK_REALTIME);
+    auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
+        cq_, tag, deadline, nullptr);
+    if (ev.type == GRPC_QUEUE_TIMEOUT) return;
+    bool ok = ev.success != 0;
+    void* ignored = tag;
+    // the tag must be swallowed if using TryPluck
+    GPR_CODEGEN_ASSERT(!tag->FinalizeResult(&ignored, &ok));
+  }
+
+  /// Performs a single polling pluck on \a tag. Calls tag->FinalizeResult if
+  /// the pluck() was successful and returned the tag.
+  ///
+  /// This exects tag->FinalizeResult (if called) to return 'false' i.e expects
+  /// that the tag is internal not something that is returned to the user.
+  void TryPluck(grpc::internal::CompletionQueueTag* tag,
+                gpr_timespec deadline) {
+    auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
+        cq_, tag, deadline, nullptr);
+    if (ev.type == GRPC_QUEUE_TIMEOUT || ev.type == GRPC_QUEUE_SHUTDOWN) {
+      return;
+    }
+
+    bool ok = ev.success != 0;
+    void* ignored = tag;
+    GPR_CODEGEN_ASSERT(!tag->FinalizeResult(&ignored, &ok));
+  }
+
+  /// Manage state of avalanching operations : completion queue tags that
+  /// trigger other completion queue operations. The underlying core completion
+  /// queue should not really shutdown until all avalanching operations have
+  /// been finalized. Note that we maintain the requirement that an avalanche
+  /// registration must take place before CQ shutdown (which must be maintained
+  /// elsehwere)
+  void InitialAvalanching() {
+    gpr_atm_rel_store(&avalanches_in_flight_, static_cast<gpr_atm>(1));
+  }
+  void RegisterAvalanching() {
+    gpr_atm_no_barrier_fetch_add(&avalanches_in_flight_,
+                                 static_cast<gpr_atm>(1));
+  }
+  void CompleteAvalanching() {
+    if (gpr_atm_no_barrier_fetch_add(&avalanches_in_flight_,
+                                     static_cast<gpr_atm>(-1)) == 1) {
+      grpc::g_core_codegen_interface->grpc_completion_queue_shutdown(cq_);
+    }
+  }
+
+  void RegisterServer(const grpc::Server* server) {
+    (void)server;
+#ifndef NDEBUG
+    grpc::internal::MutexLock l(&server_list_mutex_);
+    server_list_.push_back(server);
+#endif
+  }
+  void UnregisterServer(const grpc::Server* server) {
+    (void)server;
+#ifndef NDEBUG
+    grpc::internal::MutexLock l(&server_list_mutex_);
+    server_list_.remove(server);
+#endif
+  }
+  bool ServerListEmpty() const {
+#ifndef NDEBUG
+    grpc::internal::MutexLock l(&server_list_mutex_);
+    return server_list_.empty();
+#endif
+    return true;
+  }
+
+  static CompletionQueue* CallbackAlternativeCQ();
+  static void ReleaseCallbackAlternativeCQ(CompletionQueue* cq);
+
+  grpc_completion_queue* cq_;  // owned
+
+  gpr_atm avalanches_in_flight_;
+
+  // List of servers associated with this CQ. Even though this is only used with
+  // NDEBUG, instantiate it in all cases since otherwise the size will be
+  // inconsistent.
+  mutable grpc::internal::Mutex server_list_mutex_;
+  std::list<const grpc::Server*>
+      server_list_ /* GUARDED_BY(server_list_mutex_) */;
+};
+
+/// A specific type of completion queue used by the processing of notifications
+/// by servers. Instantiated by \a ServerBuilder or Server (for health checker).
+class ServerCompletionQueue : public CompletionQueue {
+ public:
+  bool IsFrequentlyPolled() { return polling_type_ != GRPC_CQ_NON_LISTENING; }
+
+ protected:
+  /// Default constructor
+  ServerCompletionQueue() : polling_type_(GRPC_CQ_DEFAULT_POLLING) {}
+
+ private:
+  /// \param completion_type indicates whether this is a NEXT or CALLBACK
+  /// completion queue.
+  /// \param polling_type Informs the GRPC library about the type of polling
+  /// allowed on this completion queue. See grpc_cq_polling_type's description
+  /// in grpc_types.h for more details.
+  /// \param shutdown_cb is the shutdown callback used for CALLBACK api queues
+  ServerCompletionQueue(grpc_cq_completion_type completion_type,
+                        grpc_cq_polling_type polling_type,
+                        grpc_completion_queue_functor* shutdown_cb)
+      : CompletionQueue(grpc_completion_queue_attributes{
+            GRPC_CQ_CURRENT_VERSION, completion_type, polling_type,
+            shutdown_cb}),
+        polling_type_(polling_type) {}
+
+  grpc_cq_polling_type polling_type_;
+  friend class grpc::ServerBuilder;
+  friend class grpc::Server;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_COMPLETION_QUEUE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue_tag.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue_tag.h
new file mode 100644
index 0000000..9af470b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue_tag.h
@@ -0,0 +1,56 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_COMPLETION_QUEUE_TAG_H
+#define GRPCPP_IMPL_CODEGEN_COMPLETION_QUEUE_TAG_H
+
+// IWYU pragma: private
+
+namespace grpc {
+
+namespace internal {
+/// An interface allowing implementors to process and filter event tags.
+class CompletionQueueTag {
+ public:
+  virtual ~CompletionQueueTag() {}
+
+  /// FinalizeResult must be called before informing user code that the
+  /// operation bound to the underlying core completion queue tag has
+  /// completed. In practice, this means:
+  ///
+  ///   1. For the sync API - before returning from Pluck
+  ///   2. For the CQ-based async API - before returning from Next
+  ///   3. For the callback-based API - before invoking the user callback
+  ///
+  /// This is the method that translates from core-side tag/status to
+  /// C++ API-observable tag/status.
+  ///
+  /// The return value is the status of the operation (returning status is the
+  /// general behavior of this function). If this function returns false, the
+  /// tag is dropped and not returned from the completion queue: this concept is
+  /// for events that are observed at core but not requested by the user
+  /// application (e.g., server shutdown, for server unimplemented method
+  /// responses, or for cases where a server-side RPC doesn't have a completion
+  /// notification registered using AsyncNotifyWhenDone)
+  virtual bool FinalizeResult(void** tag, bool* status) = 0;
+};
+}  // namespace internal
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_COMPLETION_QUEUE_TAG_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config.h
new file mode 100644
index 0000000..d810cfa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config.h
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CONFIG_H
+#define GRPCPP_IMPL_CODEGEN_CONFIG_H
+
+// IWYU pragma: private, include <grpcpp/support/config.h>
+
+#include <string>
+
+/// The following macros are deprecated and appear only for users
+/// with PB files generated using gRPC 1.0.x plugins. They should
+/// not be used in new code
+#define GRPC_OVERRIDE override  // deprecated
+#define GRPC_FINAL final        // deprecated
+
+#ifdef GRPC_CUSTOM_STRING
+#warning GRPC_CUSTOM_STRING is no longer supported. Please use std::string.
+#endif
+
+namespace grpc {
+
+// Using grpc::string and grpc::to_string is discouraged in favor of
+// std::string and std::to_string. This is only for legacy code using
+// them explictly.
+using std::string;     // deprecated // NOLINT(misc-unused-using-decls)
+using std::to_string;  // deprecated // NOLINT(misc-unused-using-decls)
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CONFIG_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config_protobuf.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config_protobuf.h
new file mode 100644
index 0000000..da874c5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config_protobuf.h
@@ -0,0 +1,108 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CONFIG_PROTOBUF_H
+#define GRPCPP_IMPL_CODEGEN_CONFIG_PROTOBUF_H
+
+// IWYU pragma: private
+
+#define GRPC_OPEN_SOURCE_PROTO
+
+#ifndef GRPC_CUSTOM_MESSAGE
+#ifdef GRPC_USE_PROTO_LITE
+#include <google/protobuf/message_lite.h>
+#define GRPC_CUSTOM_MESSAGE ::google::protobuf::MessageLite
+#define GRPC_CUSTOM_MESSAGELITE ::google::protobuf::MessageLite
+#else
+#include <google/protobuf/message.h>
+#define GRPC_CUSTOM_MESSAGE ::google::protobuf::Message
+#define GRPC_CUSTOM_MESSAGELITE ::google::protobuf::MessageLite
+#endif
+#endif
+
+#ifndef GRPC_CUSTOM_DESCRIPTOR
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor.pb.h>
+#define GRPC_CUSTOM_DESCRIPTOR ::google::protobuf::Descriptor
+#define GRPC_CUSTOM_DESCRIPTORPOOL ::google::protobuf::DescriptorPool
+#define GRPC_CUSTOM_FIELDDESCRIPTOR ::google::protobuf::FieldDescriptor
+#define GRPC_CUSTOM_FILEDESCRIPTOR ::google::protobuf::FileDescriptor
+#define GRPC_CUSTOM_FILEDESCRIPTORPROTO ::google::protobuf::FileDescriptorProto
+#define GRPC_CUSTOM_METHODDESCRIPTOR ::google::protobuf::MethodDescriptor
+#define GRPC_CUSTOM_SERVICEDESCRIPTOR ::google::protobuf::ServiceDescriptor
+#define GRPC_CUSTOM_SOURCELOCATION ::google::protobuf::SourceLocation
+#endif
+
+#ifndef GRPC_CUSTOM_DESCRIPTORDATABASE
+#include <google/protobuf/descriptor_database.h>
+#define GRPC_CUSTOM_DESCRIPTORDATABASE ::google::protobuf::DescriptorDatabase
+#define GRPC_CUSTOM_SIMPLEDESCRIPTORDATABASE \
+  ::google::protobuf::SimpleDescriptorDatabase
+#endif
+
+#ifndef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#define GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM \
+  ::google::protobuf::io::ZeroCopyOutputStream
+#define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM \
+  ::google::protobuf::io::ZeroCopyInputStream
+#define GRPC_CUSTOM_CODEDINPUTSTREAM ::google::protobuf::io::CodedInputStream
+#endif
+
+#ifndef GRPC_CUSTOM_JSONUTIL
+#include <google/protobuf/util/json_util.h>
+#include <google/protobuf/util/type_resolver_util.h>
+#define GRPC_CUSTOM_JSONUTIL ::google::protobuf::util
+#define GRPC_CUSTOM_UTIL_STATUS ::google::protobuf::util::Status
+#endif
+
+namespace grpc {
+namespace protobuf {
+
+typedef GRPC_CUSTOM_MESSAGE Message;
+typedef GRPC_CUSTOM_MESSAGELITE MessageLite;
+
+typedef GRPC_CUSTOM_DESCRIPTOR Descriptor;
+typedef GRPC_CUSTOM_DESCRIPTORPOOL DescriptorPool;
+typedef GRPC_CUSTOM_DESCRIPTORDATABASE DescriptorDatabase;
+typedef GRPC_CUSTOM_FIELDDESCRIPTOR FieldDescriptor;
+typedef GRPC_CUSTOM_FILEDESCRIPTOR FileDescriptor;
+typedef GRPC_CUSTOM_FILEDESCRIPTORPROTO FileDescriptorProto;
+typedef GRPC_CUSTOM_METHODDESCRIPTOR MethodDescriptor;
+typedef GRPC_CUSTOM_SERVICEDESCRIPTOR ServiceDescriptor;
+typedef GRPC_CUSTOM_SIMPLEDESCRIPTORDATABASE SimpleDescriptorDatabase;
+typedef GRPC_CUSTOM_SOURCELOCATION SourceLocation;
+
+namespace util {
+typedef GRPC_CUSTOM_UTIL_STATUS Status;
+}  // namespace util
+
+// NOLINTNEXTLINE(misc-unused-alias-decls)
+namespace json = GRPC_CUSTOM_JSONUTIL;
+
+namespace io {
+typedef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM ZeroCopyOutputStream;
+typedef GRPC_CUSTOM_ZEROCOPYINPUTSTREAM ZeroCopyInputStream;
+typedef GRPC_CUSTOM_CODEDINPUTSTREAM CodedInputStream;
+}  // namespace io
+
+}  // namespace protobuf
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CONFIG_PROTOBUF_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen.h
new file mode 100644
index 0000000..340dc47
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen.h
@@ -0,0 +1,131 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CORE_CODEGEN_H
+#define GRPCPP_IMPL_CODEGEN_CORE_CODEGEN_H
+
+// IWYU pragma: private
+
+// This file should be compiled as part of grpcpp.
+
+#include <grpc/byte_buffer.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+
+namespace grpc {
+
+/// Implementation of the core codegen interface.
+class CoreCodegen final : public CoreCodegenInterface {
+ private:
+  const grpc_completion_queue_factory* grpc_completion_queue_factory_lookup(
+      const grpc_completion_queue_attributes* attributes) override;
+  grpc_completion_queue* grpc_completion_queue_create(
+      const grpc_completion_queue_factory* factory,
+      const grpc_completion_queue_attributes* attributes,
+      void* reserved) override;
+  grpc_completion_queue* grpc_completion_queue_create_for_next(
+      void* reserved) override;
+  grpc_completion_queue* grpc_completion_queue_create_for_pluck(
+      void* reserved) override;
+  void grpc_completion_queue_shutdown(grpc_completion_queue* cq) override;
+  void grpc_completion_queue_destroy(grpc_completion_queue* cq) override;
+  grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
+                                         gpr_timespec deadline,
+                                         void* reserved) override;
+
+  void* gpr_malloc(size_t size) override;
+  void gpr_free(void* p) override;
+
+  void grpc_init() override;
+  void grpc_shutdown() override;
+
+  void gpr_mu_init(gpr_mu* mu) override;
+  void gpr_mu_destroy(gpr_mu* mu) override;
+  void gpr_mu_lock(gpr_mu* mu) override;
+  void gpr_mu_unlock(gpr_mu* mu) override;
+  void gpr_cv_init(gpr_cv* cv) override;
+  void gpr_cv_destroy(gpr_cv* cv) override;
+  int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) override;
+  void gpr_cv_signal(gpr_cv* cv) override;
+  void gpr_cv_broadcast(gpr_cv* cv) override;
+
+  grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops,
+                                        size_t nops, void* tag,
+                                        void* reserved) override;
+  grpc_call_error grpc_call_cancel_with_status(grpc_call* call,
+                                               grpc_status_code status,
+                                               const char* description,
+                                               void* reserved) override;
+  int grpc_call_failed_before_recv_message(const grpc_call* c) override;
+  void grpc_call_ref(grpc_call* call) override;
+  void grpc_call_unref(grpc_call* call) override;
+  void* grpc_call_arena_alloc(grpc_call* call, size_t length) override;
+  const char* grpc_call_error_to_string(grpc_call_error error) override;
+
+  grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb) override;
+  void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) override;
+  size_t grpc_byte_buffer_length(grpc_byte_buffer* bb) override;
+
+  int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
+                                   grpc_byte_buffer* buffer) override;
+  void grpc_byte_buffer_reader_destroy(
+      grpc_byte_buffer_reader* reader) override;
+  int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
+                                   grpc_slice* slice) override;
+  int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader,
+                                   grpc_slice** slice) override;
+
+  grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slice,
+                                                size_t nslices) override;
+  grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
+                                           void (*destroy)(void*),
+                                           void* user_data) override;
+  grpc_slice grpc_slice_new_with_len(void* p, size_t len,
+                                     void (*destroy)(void*, size_t)) override;
+  grpc_slice grpc_empty_slice() override;
+  grpc_slice grpc_slice_malloc(size_t length) override;
+  void grpc_slice_unref(grpc_slice slice) override;
+  grpc_slice grpc_slice_ref(grpc_slice slice) override;
+  grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split) override;
+  grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split) override;
+  grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end) override;
+  void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice) override;
+  void grpc_slice_buffer_pop(grpc_slice_buffer* sb) override;
+  void grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb,
+                                     grpc_slice slice) override;
+  grpc_slice grpc_slice_from_static_buffer(const void* buffer,
+                                           size_t length) override;
+  grpc_slice grpc_slice_from_copied_buffer(const void* buffer,
+                                           size_t length) override;
+  void grpc_metadata_array_init(grpc_metadata_array* array) override;
+  void grpc_metadata_array_destroy(grpc_metadata_array* array) override;
+
+  gpr_timespec gpr_inf_future(gpr_clock_type type) override;
+  gpr_timespec gpr_time_0(gpr_clock_type type) override;
+
+  const Status& ok() override;
+  const Status& cancelled() override;
+
+  void assert_fail(const char* failed_assertion, const char* file,
+                   int line) override;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CORE_CODEGEN_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen_interface.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen_interface.h
new file mode 100644
index 0000000..5ca1fef
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen_interface.h
@@ -0,0 +1,169 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CORE_CODEGEN_INTERFACE_H
+#define GRPCPP_IMPL_CODEGEN_CORE_CODEGEN_INTERFACE_H
+
+// IWYU pragma: private
+
+#include <grpc/impl/codegen/byte_buffer.h>
+#include <grpc/impl/codegen/byte_buffer_reader.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/sync.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+
+/// Interface between the codegen library and the minimal subset of core
+/// features required by the generated code.
+///
+/// All undocumented methods are simply forwarding the call to their namesakes.
+/// Please refer to their corresponding documentation for details.
+///
+/// \warning This interface should be considered internal and private.
+class CoreCodegenInterface {
+ public:
+  virtual ~CoreCodegenInterface() = default;
+
+  /// Upon a failed assertion, log the error.
+  virtual void assert_fail(const char* failed_assertion, const char* file,
+                           int line) = 0;
+
+  virtual const grpc_completion_queue_factory*
+  grpc_completion_queue_factory_lookup(
+      const grpc_completion_queue_attributes* attributes) = 0;
+  virtual grpc_completion_queue* grpc_completion_queue_create(
+      const grpc_completion_queue_factory* factory,
+      const grpc_completion_queue_attributes* attributes, void* reserved) = 0;
+  virtual grpc_completion_queue* grpc_completion_queue_create_for_next(
+      void* reserved) = 0;
+  virtual grpc_completion_queue* grpc_completion_queue_create_for_pluck(
+      void* reserved) = 0;
+  virtual void grpc_completion_queue_shutdown(grpc_completion_queue* cq) = 0;
+  virtual void grpc_completion_queue_destroy(grpc_completion_queue* cq) = 0;
+  virtual grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq,
+                                                 void* tag,
+                                                 gpr_timespec deadline,
+                                                 void* reserved) = 0;
+
+  virtual void* gpr_malloc(size_t size) = 0;
+  virtual void gpr_free(void* p) = 0;
+
+  // These are only to be used to fix edge cases involving grpc_init and
+  // grpc_shutdown. Calling grpc_init from the codegen interface before
+  // the real grpc_init is called will cause a crash, so if you use this
+  // function, ensure that it is not the first call to grpc_init.
+  virtual void grpc_init() = 0;
+  virtual void grpc_shutdown() = 0;
+
+  virtual void gpr_mu_init(gpr_mu* mu) = 0;
+  virtual void gpr_mu_destroy(gpr_mu* mu) = 0;
+  virtual void gpr_mu_lock(gpr_mu* mu) = 0;
+  virtual void gpr_mu_unlock(gpr_mu* mu) = 0;
+  virtual void gpr_cv_init(gpr_cv* cv) = 0;
+  virtual void gpr_cv_destroy(gpr_cv* cv) = 0;
+  virtual int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu,
+                          gpr_timespec abs_deadline) = 0;
+  virtual void gpr_cv_signal(gpr_cv* cv) = 0;
+  virtual void gpr_cv_broadcast(gpr_cv* cv) = 0;
+
+  virtual grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb) = 0;
+  virtual void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) = 0;
+  virtual size_t grpc_byte_buffer_length(grpc_byte_buffer* bb)
+      GRPC_MUST_USE_RESULT = 0;
+
+  virtual int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
+                                           grpc_byte_buffer* buffer)
+      GRPC_MUST_USE_RESULT = 0;
+  virtual void grpc_byte_buffer_reader_destroy(
+      grpc_byte_buffer_reader* reader) = 0;
+  virtual int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
+                                           grpc_slice* slice) = 0;
+  virtual int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader,
+                                           grpc_slice** slice) = 0;
+
+  virtual grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slice,
+                                                        size_t nslices) = 0;
+  virtual grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
+                                                   void (*destroy)(void*),
+                                                   void* user_data) = 0;
+  virtual grpc_slice grpc_slice_new_with_len(void* p, size_t len,
+                                             void (*destroy)(void*,
+                                                             size_t)) = 0;
+  virtual grpc_call_error grpc_call_start_batch(grpc_call* call,
+                                                const grpc_op* ops, size_t nops,
+                                                void* tag, void* reserved) = 0;
+  virtual grpc_call_error grpc_call_cancel_with_status(grpc_call* call,
+                                                       grpc_status_code status,
+                                                       const char* description,
+                                                       void* reserved) = 0;
+  virtual int grpc_call_failed_before_recv_message(const grpc_call* c) = 0;
+  virtual void grpc_call_ref(grpc_call* call) = 0;
+  virtual void grpc_call_unref(grpc_call* call) = 0;
+  virtual void* grpc_call_arena_alloc(grpc_call* call, size_t length) = 0;
+  virtual const char* grpc_call_error_to_string(grpc_call_error error) = 0;
+  virtual grpc_slice grpc_empty_slice() = 0;
+  virtual grpc_slice grpc_slice_malloc(size_t length) = 0;
+  virtual void grpc_slice_unref(grpc_slice slice) = 0;
+  virtual grpc_slice grpc_slice_ref(grpc_slice slice) = 0;
+  virtual grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split) = 0;
+  virtual grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split) = 0;
+  virtual grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end) = 0;
+  virtual void grpc_slice_buffer_add(grpc_slice_buffer* sb,
+                                     grpc_slice slice) = 0;
+  virtual void grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb,
+                                             grpc_slice slice) = 0;
+  virtual void grpc_slice_buffer_pop(grpc_slice_buffer* sb) = 0;
+  virtual grpc_slice grpc_slice_from_static_buffer(const void* buffer,
+                                                   size_t length) = 0;
+  virtual grpc_slice grpc_slice_from_copied_buffer(const void* buffer,
+                                                   size_t length) = 0;
+
+  virtual void grpc_metadata_array_init(grpc_metadata_array* array) = 0;
+  virtual void grpc_metadata_array_destroy(grpc_metadata_array* array) = 0;
+
+  virtual const Status& ok() = 0;
+  virtual const Status& cancelled() = 0;
+
+  virtual gpr_timespec gpr_inf_future(gpr_clock_type type) = 0;
+  virtual gpr_timespec gpr_time_0(gpr_clock_type type) = 0;
+};
+
+extern CoreCodegenInterface* g_core_codegen_interface;
+
+/// Codegen specific version of \a GPR_ASSERT.
+#define GPR_CODEGEN_ASSERT(x)                                              \
+  do {                                                                     \
+    if (GPR_UNLIKELY(!(x))) {                                              \
+      grpc::g_core_codegen_interface->assert_fail(#x, __FILE__, __LINE__); \
+    }                                                                      \
+  } while (0)
+
+/// Codegen specific version of \a GPR_DEBUG_ASSERT.
+#ifndef NDEBUG
+#define GPR_CODEGEN_DEBUG_ASSERT(x) GPR_CODEGEN_ASSERT(x)
+#else
+#define GPR_CODEGEN_DEBUG_ASSERT(x) \
+  do {                              \
+  } while (0)
+#endif
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CORE_CODEGEN_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/create_auth_context.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/create_auth_context.h
new file mode 100644
index 0000000..817988f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/create_auth_context.h
@@ -0,0 +1,35 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_CREATE_AUTH_CONTEXT_H
+#define GRPCPP_IMPL_CODEGEN_CREATE_AUTH_CONTEXT_H
+
+// IWYU pragma: private
+
+#include <memory>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/security/auth_context.h>
+
+namespace grpc {
+
+std::shared_ptr<const AuthContext> CreateAuthContext(grpc_call* call);
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_CREATE_AUTH_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/delegating_channel.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/delegating_channel.h
new file mode 100644
index 0000000..5e63d54
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/delegating_channel.h
@@ -0,0 +1,93 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_DELEGATING_CHANNEL_H
+#define GRPCPP_IMPL_CODEGEN_DELEGATING_CHANNEL_H
+
+// IWYU pragma: private
+
+#include <memory>
+
+#include <grpcpp/impl/codegen/channel_interface.h>
+
+namespace grpc {
+namespace experimental {
+
+class DelegatingChannel : public grpc::ChannelInterface {
+ public:
+  ~DelegatingChannel() override {}
+
+  explicit DelegatingChannel(
+      std::shared_ptr<grpc::ChannelInterface> delegate_channel)
+      : delegate_channel_(delegate_channel) {}
+
+  grpc_connectivity_state GetState(bool try_to_connect) override {
+    return delegate_channel()->GetState(try_to_connect);
+  }
+
+  std::shared_ptr<grpc::ChannelInterface> delegate_channel() {
+    return delegate_channel_;
+  }
+
+ private:
+  internal::Call CreateCall(const internal::RpcMethod& method,
+                            ClientContext* context,
+                            grpc::CompletionQueue* cq) final {
+    return delegate_channel()->CreateCall(method, context, cq);
+  }
+
+  void PerformOpsOnCall(internal::CallOpSetInterface* ops,
+                        internal::Call* call) final {
+    delegate_channel()->PerformOpsOnCall(ops, call);
+  }
+
+  void* RegisterMethod(const char* method) final {
+    return delegate_channel()->RegisterMethod(method);
+  }
+
+  void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
+                               gpr_timespec deadline, grpc::CompletionQueue* cq,
+                               void* tag) override {
+    delegate_channel()->NotifyOnStateChangeImpl(last_observed, deadline, cq,
+                                                tag);
+  }
+
+  bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
+                              gpr_timespec deadline) override {
+    return delegate_channel()->WaitForStateChangeImpl(last_observed, deadline);
+  }
+
+  internal::Call CreateCallInternal(const internal::RpcMethod& method,
+                                    ClientContext* context,
+                                    grpc::CompletionQueue* cq,
+                                    size_t interceptor_pos) final {
+    return delegate_channel()->CreateCallInternal(method, context, cq,
+                                                  interceptor_pos);
+  }
+
+  grpc::CompletionQueue* CallbackCQ() final {
+    return delegate_channel()->CallbackCQ();
+  }
+
+  std::shared_ptr<grpc::ChannelInterface> delegate_channel_;
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_DELEGATING_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/grpc_library.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/grpc_library.h
new file mode 100644
index 0000000..9f83a7f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/grpc_library.h
@@ -0,0 +1,67 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_GRPC_LIBRARY_H
+#define GRPCPP_IMPL_CODEGEN_GRPC_LIBRARY_H
+
+// IWYU pragma: private, include <grpcpp/impl/grpc_library.h>
+
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+
+namespace grpc {
+
+class GrpcLibraryInterface {
+ public:
+  virtual ~GrpcLibraryInterface() = default;
+  virtual void init() = 0;
+  virtual void shutdown() = 0;
+};
+
+/// Initialized by \a grpc::GrpcLibraryInitializer from
+/// <grpcpp/impl/grpc_library.h>
+extern GrpcLibraryInterface* g_glip;
+
+/// Classes that require gRPC to be initialized should inherit from this class.
+class GrpcLibraryCodegen {
+ public:
+  explicit GrpcLibraryCodegen(bool call_grpc_init = true)
+      : grpc_init_called_(false) {
+    if (call_grpc_init) {
+      GPR_CODEGEN_ASSERT(g_glip &&
+                         "gRPC library not initialized. See "
+                         "grpc::internal::GrpcLibraryInitializer.");
+      g_glip->init();
+      grpc_init_called_ = true;
+    }
+  }
+  virtual ~GrpcLibraryCodegen() {
+    if (grpc_init_called_) {
+      GPR_CODEGEN_ASSERT(g_glip &&
+                         "gRPC library not initialized. See "
+                         "grpc::internal::GrpcLibraryInitializer.");
+      g_glip->shutdown();
+    }
+  }
+
+ private:
+  bool grpc_init_called_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_GRPC_LIBRARY_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/intercepted_channel.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/intercepted_channel.h
new file mode 100644
index 0000000..57c97dd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/intercepted_channel.h
@@ -0,0 +1,85 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_INTERCEPTED_CHANNEL_H
+#define GRPCPP_IMPL_CODEGEN_INTERCEPTED_CHANNEL_H
+
+// IWYU pragma: private
+
+#include <grpcpp/impl/codegen/channel_interface.h>
+
+namespace grpc {
+class CompletionQueue;
+
+namespace internal {
+
+class InterceptorBatchMethodsImpl;
+
+/// An InterceptedChannel is available to client Interceptors. An
+/// InterceptedChannel is unique to an interceptor, and when an RPC is started
+/// on this channel, only those interceptors that come after this interceptor
+/// see the RPC.
+class InterceptedChannel : public ChannelInterface {
+ public:
+  ~InterceptedChannel() override { channel_ = nullptr; }
+
+  /// Get the current channel state. If the channel is in IDLE and
+  /// \a try_to_connect is set to true, try to connect.
+  grpc_connectivity_state GetState(bool try_to_connect) override {
+    return channel_->GetState(try_to_connect);
+  }
+
+ private:
+  InterceptedChannel(ChannelInterface* channel, size_t pos)
+      : channel_(channel), interceptor_pos_(pos) {}
+
+  Call CreateCall(const RpcMethod& method, grpc::ClientContext* context,
+                  grpc::CompletionQueue* cq) override {
+    return channel_->CreateCallInternal(method, context, cq, interceptor_pos_);
+  }
+
+  void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) override {
+    return channel_->PerformOpsOnCall(ops, call);
+  }
+  void* RegisterMethod(const char* method) override {
+    return channel_->RegisterMethod(method);
+  }
+
+  void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
+                               gpr_timespec deadline, grpc::CompletionQueue* cq,
+                               void* tag) override {
+    return channel_->NotifyOnStateChangeImpl(last_observed, deadline, cq, tag);
+  }
+  bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
+                              gpr_timespec deadline) override {
+    return channel_->WaitForStateChangeImpl(last_observed, deadline);
+  }
+
+  grpc::CompletionQueue* CallbackCQ() override {
+    return channel_->CallbackCQ();
+  }
+
+  ChannelInterface* channel_;
+  size_t interceptor_pos_;
+
+  friend class InterceptorBatchMethodsImpl;
+};
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_INTERCEPTED_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor.h
new file mode 100644
index 0000000..1445053
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor.h
@@ -0,0 +1,233 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_INTERCEPTOR_H
+#define GRPCPP_IMPL_CODEGEN_INTERCEPTOR_H
+
+// IWYU pragma: private, include <grpcpp/support/interceptor.h>
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/metadata_map.h>
+#include <grpcpp/impl/codegen/string_ref.h>
+
+namespace grpc {
+
+class ChannelInterface;
+class Status;
+
+namespace experimental {
+
+/// An enumeration of different possible points at which the \a Intercept
+/// method of the \a Interceptor interface may be called. Any given call
+/// to \a Intercept will include one or more of these hook points, and
+/// each hook point makes certain types of information available to the
+/// interceptor.
+/// In these enumeration names, PRE_SEND means that an interception has taken
+/// place between the time the application provided a certain type of data
+/// (e.g., initial metadata, status) and the time that that data goes to the
+/// other side. POST_SEND means that the data has been committed for going to
+/// the other side (even if it has not yet been received at the other side).
+/// PRE_RECV means an interception between the time that a certain
+/// operation has been requested and it is available. POST_RECV means that a
+/// result is available but has not yet been passed back to the application.
+/// A batch of interception points will only contain either PRE or POST hooks
+/// but not both types. For example, a batch with PRE_SEND hook points will not
+/// contain POST_RECV or POST_SEND ops. Likewise, a batch with POST_* ops can
+/// not contain PRE_* ops.
+enum class InterceptionHookPoints {
+  /// The first three in this list are for clients and servers
+  PRE_SEND_INITIAL_METADATA,
+  PRE_SEND_MESSAGE,
+  POST_SEND_MESSAGE,
+  PRE_SEND_STATUS,  // server only
+  PRE_SEND_CLOSE,   // client only: WritesDone for stream; after write in unary
+  /// The following three are for hijacked clients only. A batch with PRE_RECV_*
+  /// hook points will never contain hook points of other types.
+  PRE_RECV_INITIAL_METADATA,
+  PRE_RECV_MESSAGE,
+  PRE_RECV_STATUS,
+  /// The following two are for all clients and servers
+  POST_RECV_INITIAL_METADATA,
+  POST_RECV_MESSAGE,
+  POST_RECV_STATUS,  // client only
+  POST_RECV_CLOSE,   // server only
+  /// This is a special hook point available to both clients and servers when
+  /// TryCancel() is performed.
+  ///  - No other hook points will be present along with this.
+  ///  - It is illegal for an interceptor to block/delay this operation.
+  ///  - ALL interceptors see this hook point irrespective of whether the
+  ///    RPC was hijacked or not.
+  PRE_SEND_CANCEL,
+  NUM_INTERCEPTION_HOOKS
+};
+
+/// Class that is passed as an argument to the \a Intercept method
+/// of the application's \a Interceptor interface implementation. It has five
+/// purposes:
+///   1. Indicate which hook points are present at a specific interception
+///   2. Allow an interceptor to inform the library that an RPC should
+///      continue to the next stage of its processing (which may be another
+///      interceptor or the main path of the library)
+///   3. Allow an interceptor to hijack the processing of the RPC (only for
+///      client-side RPCs with PRE_SEND_INITIAL_METADATA) so that it does not
+///      proceed with normal processing beyond that stage
+///   4. Access the relevant fields of an RPC at each interception point
+///   5. Set some fields of an RPC at each interception point, when possible
+class InterceptorBatchMethods {
+ public:
+  virtual ~InterceptorBatchMethods() {}
+  /// Determine whether the current batch has an interception hook point
+  /// of type \a type
+  virtual bool QueryInterceptionHookPoint(InterceptionHookPoints type) = 0;
+  /// Signal that the interceptor is done intercepting the current batch of the
+  /// RPC. Every interceptor must either call Proceed or Hijack on each
+  /// interception. In most cases, only Proceed will be used. Explicit use of
+  /// Proceed is what enables interceptors to delay the processing of RPCs
+  /// while they perform other work.
+  /// Proceed is a no-op if the batch contains PRE_SEND_CANCEL. Simply returning
+  /// from the Intercept method does the job of continuing the RPC in this case.
+  /// This is because PRE_SEND_CANCEL is always in a separate batch and is not
+  /// allowed to be delayed.
+  virtual void Proceed() = 0;
+  /// Indicate that the interceptor has hijacked the RPC (only valid if the
+  /// batch contains send_initial_metadata on the client side). Later
+  /// interceptors in the interceptor list will not be called. Later batches
+  /// on the same RPC will go through interception, but only up to the point
+  /// of the hijacking interceptor.
+  virtual void Hijack() = 0;
+
+  /// Send Message Methods
+  /// GetSerializedSendMessage and GetSendMessage/ModifySendMessage are the
+  /// available methods to view and modify the request payload. An interceptor
+  /// can access the payload in either serialized form or non-serialized form
+  /// but not both at the same time.
+  /// gRPC performs serialization in a lazy manner, which means
+  /// that a call to GetSerializedSendMessage will result in a serialization
+  /// operation if the payload stored is not in the serialized form already; the
+  /// non-serialized form will be lost and GetSendMessage will no longer return
+  /// a valid pointer, and this will remain true for later interceptors too.
+  /// This can change however if ModifySendMessage is used to replace the
+  /// current payload. Note that ModifySendMessage requires a new payload
+  /// message in the non-serialized form. This will overwrite the existing
+  /// payload irrespective of whether it had been serialized earlier. Also note
+  /// that gRPC Async API requires early serialization of the payload which
+  /// means that the payload would be available in the serialized form only
+  /// unless an interceptor replaces the payload with ModifySendMessage.
+
+  /// Returns a modifable ByteBuffer holding the serialized form of the message
+  /// that is going to be sent. Valid for PRE_SEND_MESSAGE interceptions.
+  /// A return value of nullptr indicates that this ByteBuffer is not valid.
+  virtual ByteBuffer* GetSerializedSendMessage() = 0;
+
+  /// Returns a non-modifiable pointer to the non-serialized form of the message
+  /// to be sent. Valid for PRE_SEND_MESSAGE interceptions. A return value of
+  /// nullptr indicates that this field is not valid.
+  virtual const void* GetSendMessage() = 0;
+
+  /// Overwrites the message to be sent with \a message. \a message should be in
+  /// the non-serialized form expected by the method. Valid for PRE_SEND_MESSAGE
+  /// interceptions. Note that the interceptor is responsible for maintaining
+  /// the life of the message till it is serialized or it receives the
+  /// POST_SEND_MESSAGE interception point, whichever happens earlier. The
+  /// modifying interceptor may itself force early serialization by calling
+  /// GetSerializedSendMessage.
+  virtual void ModifySendMessage(const void* message) = 0;
+
+  /// Checks whether the SEND MESSAGE op succeeded. Valid for POST_SEND_MESSAGE
+  /// interceptions.
+  virtual bool GetSendMessageStatus() = 0;
+
+  /// Returns a modifiable multimap of the initial metadata to be sent. Valid
+  /// for PRE_SEND_INITIAL_METADATA interceptions. A value of nullptr indicates
+  /// that this field is not valid.
+  virtual std::multimap<std::string, std::string>* GetSendInitialMetadata() = 0;
+
+  /// Returns the status to be sent. Valid for PRE_SEND_STATUS interceptions.
+  virtual Status GetSendStatus() = 0;
+
+  /// Overwrites the status with \a status. Valid for PRE_SEND_STATUS
+  /// interceptions.
+  virtual void ModifySendStatus(const Status& status) = 0;
+
+  /// Returns a modifiable multimap of the trailing metadata to be sent. Valid
+  /// for PRE_SEND_STATUS interceptions. A value of nullptr indicates
+  /// that this field is not valid.
+  virtual std::multimap<std::string, std::string>*
+  GetSendTrailingMetadata() = 0;
+
+  /// Returns a pointer to the modifiable received message. Note that the
+  /// message is already deserialized but the type is not set; the interceptor
+  /// should static_cast to the appropriate type before using it. This is valid
+  /// for PRE_RECV_MESSAGE and POST_RECV_MESSAGE interceptions; nullptr for not
+  /// valid
+  virtual void* GetRecvMessage() = 0;
+
+  /// Returns a modifiable multimap of the received initial metadata.
+  /// Valid for PRE_RECV_INITIAL_METADATA and POST_RECV_INITIAL_METADATA
+  /// interceptions; nullptr if not valid
+  virtual std::multimap<grpc::string_ref, grpc::string_ref>*
+  GetRecvInitialMetadata() = 0;
+
+  /// Returns a modifiable view of the received status on PRE_RECV_STATUS and
+  /// POST_RECV_STATUS interceptions; nullptr if not valid.
+  virtual Status* GetRecvStatus() = 0;
+
+  /// Returns a modifiable multimap of the received trailing metadata on
+  /// PRE_RECV_STATUS and POST_RECV_STATUS interceptions; nullptr if not valid
+  virtual std::multimap<grpc::string_ref, grpc::string_ref>*
+  GetRecvTrailingMetadata() = 0;
+
+  /// Gets an intercepted channel. When a call is started on this interceptor,
+  /// only interceptors after the current interceptor are created from the
+  /// factory objects registered with the channel. This allows calls to be
+  /// started from interceptors without infinite regress through the interceptor
+  /// list.
+  virtual std::unique_ptr<ChannelInterface> GetInterceptedChannel() = 0;
+
+  /// On a hijacked RPC, an interceptor can decide to fail a PRE_RECV_MESSAGE
+  /// op. This would be a signal to the reader that there will be no more
+  /// messages, or the stream has failed or been cancelled.
+  virtual void FailHijackedRecvMessage() = 0;
+
+  /// On a hijacked RPC/ to-be hijacked RPC, this can be called to fail a SEND
+  /// MESSAGE op
+  virtual void FailHijackedSendMessage() = 0;
+};
+
+/// Interface for an interceptor. Interceptor authors must create a class
+/// that derives from this parent class.
+class Interceptor {
+ public:
+  virtual ~Interceptor() {}
+
+  /// The one public method of an Interceptor interface. Override this to
+  /// trigger the desired actions at the hook points described above.
+  virtual void Intercept(InterceptorBatchMethods* methods) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor_common.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor_common.h
new file mode 100644
index 0000000..b084b7c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor_common.h
@@ -0,0 +1,540 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_INTERCEPTOR_COMMON_H
+#define GRPCPP_IMPL_CODEGEN_INTERCEPTOR_COMMON_H
+
+// IWYU pragma: private
+
+#include <array>
+#include <functional>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/call_op_set_interface.h>
+#include <grpcpp/impl/codegen/client_interceptor.h>
+#include <grpcpp/impl/codegen/intercepted_channel.h>
+#include <grpcpp/impl/codegen/server_interceptor.h>
+
+namespace grpc {
+namespace internal {
+
+class InterceptorBatchMethodsImpl
+    : public experimental::InterceptorBatchMethods {
+ public:
+  InterceptorBatchMethodsImpl() {
+    for (auto i = static_cast<experimental::InterceptionHookPoints>(0);
+         i < experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS;
+         i = static_cast<experimental::InterceptionHookPoints>(
+             static_cast<size_t>(i) + 1)) {
+      hooks_[static_cast<size_t>(i)] = false;
+    }
+  }
+
+  ~InterceptorBatchMethodsImpl() override {}
+
+  bool QueryInterceptionHookPoint(
+      experimental::InterceptionHookPoints type) override {
+    return hooks_[static_cast<size_t>(type)];
+  }
+
+  void Proceed() override {
+    if (call_->client_rpc_info() != nullptr) {
+      return ProceedClient();
+    }
+    GPR_CODEGEN_ASSERT(call_->server_rpc_info() != nullptr);
+    ProceedServer();
+  }
+
+  void Hijack() override {
+    // Only the client can hijack when sending down initial metadata
+    GPR_CODEGEN_ASSERT(!reverse_ && ops_ != nullptr &&
+                       call_->client_rpc_info() != nullptr);
+    // It is illegal to call Hijack twice
+    GPR_CODEGEN_ASSERT(!ran_hijacking_interceptor_);
+    auto* rpc_info = call_->client_rpc_info();
+    rpc_info->hijacked_ = true;
+    rpc_info->hijacked_interceptor_ = current_interceptor_index_;
+    ClearHookPoints();
+    ops_->SetHijackingState();
+    ran_hijacking_interceptor_ = true;
+    rpc_info->RunInterceptor(this, current_interceptor_index_);
+  }
+
+  void AddInterceptionHookPoint(experimental::InterceptionHookPoints type) {
+    hooks_[static_cast<size_t>(type)] = true;
+  }
+
+  ByteBuffer* GetSerializedSendMessage() override {
+    GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
+    if (*orig_send_message_ != nullptr) {
+      GPR_CODEGEN_ASSERT(serializer_(*orig_send_message_).ok());
+      *orig_send_message_ = nullptr;
+    }
+    return send_message_;
+  }
+
+  const void* GetSendMessage() override {
+    GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
+    return *orig_send_message_;
+  }
+
+  void ModifySendMessage(const void* message) override {
+    GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
+    *orig_send_message_ = message;
+  }
+
+  bool GetSendMessageStatus() override { return !*fail_send_message_; }
+
+  std::multimap<std::string, std::string>* GetSendInitialMetadata() override {
+    return send_initial_metadata_;
+  }
+
+  Status GetSendStatus() override {
+    return Status(static_cast<StatusCode>(*code_), *error_message_,
+                  *error_details_);
+  }
+
+  void ModifySendStatus(const Status& status) override {
+    *code_ = static_cast<grpc_status_code>(status.error_code());
+    *error_details_ = status.error_details();
+    *error_message_ = status.error_message();
+  }
+
+  std::multimap<std::string, std::string>* GetSendTrailingMetadata() override {
+    return send_trailing_metadata_;
+  }
+
+  void* GetRecvMessage() override { return recv_message_; }
+
+  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvInitialMetadata()
+      override {
+    return recv_initial_metadata_->map();
+  }
+
+  Status* GetRecvStatus() override { return recv_status_; }
+
+  void FailHijackedSendMessage() override {
+    GPR_CODEGEN_ASSERT(hooks_[static_cast<size_t>(
+        experimental::InterceptionHookPoints::PRE_SEND_MESSAGE)]);
+    *fail_send_message_ = true;
+  }
+
+  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvTrailingMetadata()
+      override {
+    return recv_trailing_metadata_->map();
+  }
+
+  void SetSendMessage(ByteBuffer* buf, const void** msg,
+                      bool* fail_send_message,
+                      std::function<Status(const void*)> serializer) {
+    send_message_ = buf;
+    orig_send_message_ = msg;
+    fail_send_message_ = fail_send_message;
+    serializer_ = serializer;
+  }
+
+  void SetSendInitialMetadata(
+      std::multimap<std::string, std::string>* metadata) {
+    send_initial_metadata_ = metadata;
+  }
+
+  void SetSendStatus(grpc_status_code* code, std::string* error_details,
+                     std::string* error_message) {
+    code_ = code;
+    error_details_ = error_details;
+    error_message_ = error_message;
+  }
+
+  void SetSendTrailingMetadata(
+      std::multimap<std::string, std::string>* metadata) {
+    send_trailing_metadata_ = metadata;
+  }
+
+  void SetRecvMessage(void* message, bool* hijacked_recv_message_failed) {
+    recv_message_ = message;
+    hijacked_recv_message_failed_ = hijacked_recv_message_failed;
+  }
+
+  void SetRecvInitialMetadata(MetadataMap* map) {
+    recv_initial_metadata_ = map;
+  }
+
+  void SetRecvStatus(Status* status) { recv_status_ = status; }
+
+  void SetRecvTrailingMetadata(MetadataMap* map) {
+    recv_trailing_metadata_ = map;
+  }
+
+  std::unique_ptr<ChannelInterface> GetInterceptedChannel() override {
+    auto* info = call_->client_rpc_info();
+    if (info == nullptr) {
+      return std::unique_ptr<ChannelInterface>(nullptr);
+    }
+    // The intercepted channel starts from the interceptor just after the
+    // current interceptor
+    return std::unique_ptr<ChannelInterface>(new InterceptedChannel(
+        info->channel(), current_interceptor_index_ + 1));
+  }
+
+  void FailHijackedRecvMessage() override {
+    GPR_CODEGEN_ASSERT(hooks_[static_cast<size_t>(
+        experimental::InterceptionHookPoints::PRE_RECV_MESSAGE)]);
+    *hijacked_recv_message_failed_ = true;
+  }
+
+  // Clears all state
+  void ClearState() {
+    reverse_ = false;
+    ran_hijacking_interceptor_ = false;
+    ClearHookPoints();
+  }
+
+  // Prepares for Post_recv operations
+  void SetReverse() {
+    reverse_ = true;
+    ran_hijacking_interceptor_ = false;
+    ClearHookPoints();
+  }
+
+  // This needs to be set before interceptors are run
+  void SetCall(Call* call) { call_ = call; }
+
+  // This needs to be set before interceptors are run using RunInterceptors().
+  // Alternatively, RunInterceptors(std::function<void(void)> f) can be used.
+  void SetCallOpSetInterface(CallOpSetInterface* ops) { ops_ = ops; }
+
+  // SetCall should have been called before this.
+  // Returns true if the interceptors list is empty
+  bool InterceptorsListEmpty() {
+    auto* client_rpc_info = call_->client_rpc_info();
+    if (client_rpc_info != nullptr) {
+      return client_rpc_info->interceptors_.empty();
+    }
+
+    auto* server_rpc_info = call_->server_rpc_info();
+    return server_rpc_info == nullptr || server_rpc_info->interceptors_.empty();
+  }
+
+  // This should be used only by subclasses of CallOpSetInterface. SetCall and
+  // SetCallOpSetInterface should have been called before this. After all the
+  // interceptors are done running, either ContinueFillOpsAfterInterception or
+  // ContinueFinalizeOpsAfterInterception will be called. Note that neither of
+  // them is invoked if there were no interceptors registered.
+  bool RunInterceptors() {
+    GPR_CODEGEN_ASSERT(ops_);
+    auto* client_rpc_info = call_->client_rpc_info();
+    if (client_rpc_info != nullptr) {
+      if (client_rpc_info->interceptors_.empty()) {
+        return true;
+      } else {
+        RunClientInterceptors();
+        return false;
+      }
+    }
+
+    auto* server_rpc_info = call_->server_rpc_info();
+    if (server_rpc_info == nullptr || server_rpc_info->interceptors_.empty()) {
+      return true;
+    }
+    RunServerInterceptors();
+    return false;
+  }
+
+  // Returns true if no interceptors are run. Returns false otherwise if there
+  // are interceptors registered. After the interceptors are done running \a f
+  // will be invoked. This is to be used only by BaseAsyncRequest and
+  // SyncRequest.
+  bool RunInterceptors(std::function<void(void)> f) {
+    // This is used only by the server for initial call request
+    GPR_CODEGEN_ASSERT(reverse_ == true);
+    GPR_CODEGEN_ASSERT(call_->client_rpc_info() == nullptr);
+    auto* server_rpc_info = call_->server_rpc_info();
+    if (server_rpc_info == nullptr || server_rpc_info->interceptors_.empty()) {
+      return true;
+    }
+    callback_ = std::move(f);
+    RunServerInterceptors();
+    return false;
+  }
+
+ private:
+  void RunClientInterceptors() {
+    auto* rpc_info = call_->client_rpc_info();
+    if (!reverse_) {
+      current_interceptor_index_ = 0;
+    } else {
+      if (rpc_info->hijacked_) {
+        current_interceptor_index_ = rpc_info->hijacked_interceptor_;
+      } else {
+        current_interceptor_index_ = rpc_info->interceptors_.size() - 1;
+      }
+    }
+    rpc_info->RunInterceptor(this, current_interceptor_index_);
+  }
+
+  void RunServerInterceptors() {
+    auto* rpc_info = call_->server_rpc_info();
+    if (!reverse_) {
+      current_interceptor_index_ = 0;
+    } else {
+      current_interceptor_index_ = rpc_info->interceptors_.size() - 1;
+    }
+    rpc_info->RunInterceptor(this, current_interceptor_index_);
+  }
+
+  void ProceedClient() {
+    auto* rpc_info = call_->client_rpc_info();
+    if (rpc_info->hijacked_ && !reverse_ &&
+        current_interceptor_index_ == rpc_info->hijacked_interceptor_ &&
+        !ran_hijacking_interceptor_) {
+      // We now need to provide hijacked recv ops to this interceptor
+      ClearHookPoints();
+      ops_->SetHijackingState();
+      ran_hijacking_interceptor_ = true;
+      rpc_info->RunInterceptor(this, current_interceptor_index_);
+      return;
+    }
+    if (!reverse_) {
+      current_interceptor_index_++;
+      // We are going down the stack of interceptors
+      if (current_interceptor_index_ < rpc_info->interceptors_.size()) {
+        if (rpc_info->hijacked_ &&
+            current_interceptor_index_ > rpc_info->hijacked_interceptor_) {
+          // This is a hijacked RPC and we are done with hijacking
+          ops_->ContinueFillOpsAfterInterception();
+        } else {
+          rpc_info->RunInterceptor(this, current_interceptor_index_);
+        }
+      } else {
+        // we are done running all the interceptors without any hijacking
+        ops_->ContinueFillOpsAfterInterception();
+      }
+    } else {
+      // We are going up the stack of interceptors
+      if (current_interceptor_index_ > 0) {
+        // Continue running interceptors
+        current_interceptor_index_--;
+        rpc_info->RunInterceptor(this, current_interceptor_index_);
+      } else {
+        // we are done running all the interceptors without any hijacking
+        ops_->ContinueFinalizeResultAfterInterception();
+      }
+    }
+  }
+
+  void ProceedServer() {
+    auto* rpc_info = call_->server_rpc_info();
+    if (!reverse_) {
+      current_interceptor_index_++;
+      if (current_interceptor_index_ < rpc_info->interceptors_.size()) {
+        return rpc_info->RunInterceptor(this, current_interceptor_index_);
+      } else if (ops_) {
+        return ops_->ContinueFillOpsAfterInterception();
+      }
+    } else {
+      // We are going up the stack of interceptors
+      if (current_interceptor_index_ > 0) {
+        // Continue running interceptors
+        current_interceptor_index_--;
+        return rpc_info->RunInterceptor(this, current_interceptor_index_);
+      } else if (ops_) {
+        return ops_->ContinueFinalizeResultAfterInterception();
+      }
+    }
+    GPR_CODEGEN_ASSERT(callback_);
+    callback_();
+  }
+
+  void ClearHookPoints() {
+    for (auto i = static_cast<experimental::InterceptionHookPoints>(0);
+         i < experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS;
+         i = static_cast<experimental::InterceptionHookPoints>(
+             static_cast<size_t>(i) + 1)) {
+      hooks_[static_cast<size_t>(i)] = false;
+    }
+  }
+
+  std::array<bool,
+             static_cast<size_t>(
+                 experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS)>
+      hooks_;
+
+  size_t current_interceptor_index_ = 0;  // Current iterator
+  bool reverse_ = false;
+  bool ran_hijacking_interceptor_ = false;
+  Call* call_ = nullptr;  // The Call object is present along with CallOpSet
+                          // object/callback
+  CallOpSetInterface* ops_ = nullptr;
+  std::function<void(void)> callback_;
+
+  ByteBuffer* send_message_ = nullptr;
+  bool* fail_send_message_ = nullptr;
+  const void** orig_send_message_ = nullptr;
+  std::function<Status(const void*)> serializer_;
+
+  std::multimap<std::string, std::string>* send_initial_metadata_;
+
+  grpc_status_code* code_ = nullptr;
+  std::string* error_details_ = nullptr;
+  std::string* error_message_ = nullptr;
+
+  std::multimap<std::string, std::string>* send_trailing_metadata_ = nullptr;
+
+  void* recv_message_ = nullptr;
+  bool* hijacked_recv_message_failed_ = nullptr;
+
+  MetadataMap* recv_initial_metadata_ = nullptr;
+
+  Status* recv_status_ = nullptr;
+
+  MetadataMap* recv_trailing_metadata_ = nullptr;
+};
+
+// A special implementation of InterceptorBatchMethods to send a Cancel
+// notification down the interceptor stack
+class CancelInterceptorBatchMethods
+    : public experimental::InterceptorBatchMethods {
+ public:
+  bool QueryInterceptionHookPoint(
+      experimental::InterceptionHookPoints type) override {
+    return type == experimental::InterceptionHookPoints::PRE_SEND_CANCEL;
+  }
+
+  void Proceed() override {
+    // This is a no-op. For actual continuation of the RPC simply needs to
+    // return from the Intercept method
+  }
+
+  void Hijack() override {
+    // Only the client can hijack when sending down initial metadata
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call Hijack on a method which has a "
+                       "Cancel notification");
+  }
+
+  ByteBuffer* GetSerializedSendMessage() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetSendMessage on a method which "
+                       "has a Cancel notification");
+    return nullptr;
+  }
+
+  bool GetSendMessageStatus() override {
+    GPR_CODEGEN_ASSERT(
+        false &&
+        "It is illegal to call GetSendMessageStatus on a method which "
+        "has a Cancel notification");
+    return false;
+  }
+
+  const void* GetSendMessage() override {
+    GPR_CODEGEN_ASSERT(
+        false &&
+        "It is illegal to call GetOriginalSendMessage on a method which "
+        "has a Cancel notification");
+    return nullptr;
+  }
+
+  void ModifySendMessage(const void* /*message*/) override {
+    GPR_CODEGEN_ASSERT(
+        false &&
+        "It is illegal to call ModifySendMessage on a method which "
+        "has a Cancel notification");
+  }
+
+  std::multimap<std::string, std::string>* GetSendInitialMetadata() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetSendInitialMetadata on a "
+                       "method which has a Cancel notification");
+    return nullptr;
+  }
+
+  Status GetSendStatus() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetSendStatus on a method which "
+                       "has a Cancel notification");
+    return Status();
+  }
+
+  void ModifySendStatus(const Status& /*status*/) override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call ModifySendStatus on a method "
+                       "which has a Cancel notification");
+  }
+
+  std::multimap<std::string, std::string>* GetSendTrailingMetadata() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetSendTrailingMetadata on a "
+                       "method which has a Cancel notification");
+    return nullptr;
+  }
+
+  void* GetRecvMessage() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetRecvMessage on a method which "
+                       "has a Cancel notification");
+    return nullptr;
+  }
+
+  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvInitialMetadata()
+      override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetRecvInitialMetadata on a "
+                       "method which has a Cancel notification");
+    return nullptr;
+  }
+
+  Status* GetRecvStatus() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetRecvStatus on a method which "
+                       "has a Cancel notification");
+    return nullptr;
+  }
+
+  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvTrailingMetadata()
+      override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetRecvTrailingMetadata on a "
+                       "method which has a Cancel notification");
+    return nullptr;
+  }
+
+  std::unique_ptr<ChannelInterface> GetInterceptedChannel() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call GetInterceptedChannel on a "
+                       "method which has a Cancel notification");
+    return std::unique_ptr<ChannelInterface>(nullptr);
+  }
+
+  void FailHijackedRecvMessage() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call FailHijackedRecvMessage on a "
+                       "method which has a Cancel notification");
+  }
+
+  void FailHijackedSendMessage() override {
+    GPR_CODEGEN_ASSERT(false &&
+                       "It is illegal to call FailHijackedSendMessage on a "
+                       "method which has a Cancel notification");
+  }
+};
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_INTERCEPTOR_COMMON_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/message_allocator.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/message_allocator.h
new file mode 100644
index 0000000..440c7f1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/message_allocator.h
@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_MESSAGE_ALLOCATOR_H
+#define GRPCPP_IMPL_CODEGEN_MESSAGE_ALLOCATOR_H
+
+// IWYU pragma: private, include <grpcpp/support/message_allocator.h>
+
+namespace grpc {
+
+// NOTE: This is an API for advanced users who need custom allocators.
+// Per rpc struct for the allocator. This is the interface to return to user.
+class RpcAllocatorState {
+ public:
+  virtual ~RpcAllocatorState() = default;
+  // Optionally deallocate request early to reduce the size of working set.
+  // A custom MessageAllocator needs to be registered to make use of this.
+  // This is not abstract because implementing it is optional.
+  virtual void FreeRequest() {}
+};
+
+// This is the interface returned by the allocator.
+// grpc library will call the methods to get request/response pointers and to
+// release the object when it is done.
+template <typename RequestT, typename ResponseT>
+class MessageHolder : public RpcAllocatorState {
+ public:
+  // Release this object. For example, if the custom allocator's
+  // AllocateMessasge creates an instance of a subclass with new, the Release()
+  // should do a "delete this;".
+  virtual void Release() = 0;
+  RequestT* request() { return request_; }
+  ResponseT* response() { return response_; }
+
+ protected:
+  void set_request(RequestT* request) { request_ = request; }
+  void set_response(ResponseT* response) { response_ = response; }
+
+ private:
+  // NOTE: subclasses should set these pointers.
+  RequestT* request_;
+  ResponseT* response_;
+};
+
+// A custom allocator can be set via the generated code to a callback unary
+// method, such as SetMessageAllocatorFor_Echo(custom_allocator). The allocator
+// needs to be alive for the lifetime of the server.
+// Implementations need to be thread-safe.
+template <typename RequestT, typename ResponseT>
+class MessageAllocator {
+ public:
+  virtual ~MessageAllocator() = default;
+  virtual MessageHolder<RequestT, ResponseT>* AllocateMessages() = 0;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_MESSAGE_ALLOCATOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/metadata_map.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/metadata_map.h
new file mode 100644
index 0000000..931d682
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/metadata_map.h
@@ -0,0 +1,107 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_METADATA_MAP_H
+#define GRPCPP_IMPL_CODEGEN_METADATA_MAP_H
+
+// IWYU pragma: private
+
+#include <map>
+
+#include <grpc/impl/codegen/log.h>
+#include <grpcpp/impl/codegen/slice.h>
+
+namespace grpc {
+
+namespace internal {
+
+const char kBinaryErrorDetailsKey[] = "grpc-status-details-bin";
+
+class MetadataMap {
+ public:
+  MetadataMap() { Setup(); }
+
+  ~MetadataMap() { Destroy(); }
+
+  std::string GetBinaryErrorDetails() {
+    // if filled_, extract from the multimap for O(log(n))
+    if (filled_) {
+      auto iter = map_.find(kBinaryErrorDetailsKey);
+      if (iter != map_.end()) {
+        return std::string(iter->second.begin(), iter->second.length());
+      }
+    }
+    // if not yet filled, take the O(n) lookup to avoid allocating the
+    // multimap until it is requested.
+    // TODO(ncteisen): plumb this through core as a first class object, just
+    // like code and message.
+    else {
+      for (size_t i = 0; i < arr_.count; i++) {
+        if (strncmp(reinterpret_cast<const char*>(
+                        GRPC_SLICE_START_PTR(arr_.metadata[i].key)),
+                    kBinaryErrorDetailsKey,
+                    GRPC_SLICE_LENGTH(arr_.metadata[i].key)) == 0) {
+          return std::string(reinterpret_cast<const char*>(
+                                 GRPC_SLICE_START_PTR(arr_.metadata[i].value)),
+                             GRPC_SLICE_LENGTH(arr_.metadata[i].value));
+        }
+      }
+    }
+    return std::string();
+  }
+
+  std::multimap<grpc::string_ref, grpc::string_ref>* map() {
+    FillMap();
+    return &map_;
+  }
+  grpc_metadata_array* arr() { return &arr_; }
+
+  void Reset() {
+    filled_ = false;
+    map_.clear();
+    Destroy();
+    Setup();
+  }
+
+ private:
+  bool filled_ = false;
+  grpc_metadata_array arr_;
+  std::multimap<grpc::string_ref, grpc::string_ref> map_;
+
+  void Destroy() {
+    g_core_codegen_interface->grpc_metadata_array_destroy(&arr_);
+  }
+
+  void Setup() { memset(&arr_, 0, sizeof(arr_)); }
+
+  void FillMap() {
+    if (filled_) return;
+    filled_ = true;
+    for (size_t i = 0; i < arr_.count; i++) {
+      // TODO(yangg) handle duplicates?
+      map_.insert(std::pair<grpc::string_ref, grpc::string_ref>(
+          StringRefFromSlice(&arr_.metadata[i].key),
+          StringRefFromSlice(&arr_.metadata[i].value)));
+    }
+  }
+};
+}  // namespace internal
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_METADATA_MAP_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler.h
new file mode 100644
index 0000000..5805631
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler.h
@@ -0,0 +1,406 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_H
+#define GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_H
+
+// IWYU pragma: private, include <grpcpp/support/method_handler.h>
+
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace grpc {
+
+namespace internal {
+
+// Invoke the method handler, fill in the status, and
+// return whether or not we finished safely (without an exception).
+// Note that exception handling is 0-cost in most compiler/library
+// implementations (except when an exception is actually thrown),
+// so this process doesn't require additional overhead in the common case.
+// Additionally, we don't need to return if we caught an exception or not;
+// the handling is the same in either case.
+template <class Callable>
+::grpc::Status CatchingFunctionHandler(Callable&& handler) {
+#if GRPC_ALLOW_EXCEPTIONS
+  try {
+    return handler();
+  } catch (...) {
+    return grpc::Status(grpc::StatusCode::UNKNOWN,
+                        "Unexpected error in RPC handling");
+  }
+#else   // GRPC_ALLOW_EXCEPTIONS
+  return handler();
+#endif  // GRPC_ALLOW_EXCEPTIONS
+}
+
+/// A helper function with reduced templating to do the common work needed to
+/// actually send the server response. Uses non-const parameter for Status since
+/// this should only ever be called from the end of the RunHandler method.
+
+template <class ResponseType>
+void UnaryRunHandlerHelper(const MethodHandler::HandlerParameter& param,
+                           ResponseType* rsp, grpc::Status& status) {
+  GPR_CODEGEN_ASSERT(!param.server_context->sent_initial_metadata_);
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage,
+                            grpc::internal::CallOpServerSendStatus>
+      ops;
+  ops.SendInitialMetadata(&param.server_context->initial_metadata_,
+                          param.server_context->initial_metadata_flags());
+  if (param.server_context->compression_level_set()) {
+    ops.set_compression_level(param.server_context->compression_level());
+  }
+  if (status.ok()) {
+    status = ops.SendMessagePtr(rsp);
+  }
+  ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
+  param.call->PerformOps(&ops);
+  param.call->cq()->Pluck(&ops);
+}
+
+/// A helper function with reduced templating to do deserializing.
+
+template <class RequestType>
+void* UnaryDeserializeHelper(grpc_byte_buffer* req, grpc::Status* status,
+                             RequestType* request) {
+  grpc::ByteBuffer buf;
+  buf.set_buffer(req);
+  *status = grpc::SerializationTraits<RequestType>::Deserialize(
+      &buf, static_cast<RequestType*>(request));
+  buf.Release();
+  if (status->ok()) {
+    return request;
+  }
+  request->~RequestType();
+  return nullptr;
+}
+
+/// A wrapper class of an application provided rpc method handler.
+template <class ServiceType, class RequestType, class ResponseType,
+          class BaseRequestType = RequestType,
+          class BaseResponseType = ResponseType>
+class RpcMethodHandler : public grpc::internal::MethodHandler {
+ public:
+  RpcMethodHandler(
+      std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
+                                 const RequestType*, ResponseType*)>
+          func,
+      ServiceType* service)
+      : func_(func), service_(service) {}
+
+  void RunHandler(const HandlerParameter& param) final {
+    ResponseType rsp;
+    grpc::Status status = param.status;
+    if (status.ok()) {
+      status = CatchingFunctionHandler([this, &param, &rsp] {
+        return func_(service_,
+                     static_cast<grpc::ServerContext*>(param.server_context),
+                     static_cast<RequestType*>(param.request), &rsp);
+      });
+      static_cast<RequestType*>(param.request)->~RequestType();
+    }
+    UnaryRunHandlerHelper(param, static_cast<BaseResponseType*>(&rsp), status);
+  }
+
+  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
+                    grpc::Status* status, void** /*handler_data*/) final {
+    auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call, sizeof(RequestType))) RequestType;
+    return UnaryDeserializeHelper(req, status,
+                                  static_cast<BaseRequestType*>(request));
+  }
+
+ private:
+  /// Application provided rpc handler function.
+  std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
+                             const RequestType*, ResponseType*)>
+      func_;
+  // The class the above handler function lives in.
+  ServiceType* service_;
+};
+
+/// A wrapper class of an application provided client streaming handler.
+template <class ServiceType, class RequestType, class ResponseType>
+class ClientStreamingHandler : public grpc::internal::MethodHandler {
+ public:
+  ClientStreamingHandler(
+      std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
+                                 ServerReader<RequestType>*, ResponseType*)>
+          func,
+      ServiceType* service)
+      : func_(func), service_(service) {}
+
+  void RunHandler(const HandlerParameter& param) final {
+    ServerReader<RequestType> reader(
+        param.call, static_cast<grpc::ServerContext*>(param.server_context));
+    ResponseType rsp;
+    grpc::Status status =
+        CatchingFunctionHandler([this, &param, &reader, &rsp] {
+          return func_(service_,
+                       static_cast<grpc::ServerContext*>(param.server_context),
+                       &reader, &rsp);
+        });
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage,
+                              grpc::internal::CallOpServerSendStatus>
+        ops;
+    if (!param.server_context->sent_initial_metadata_) {
+      ops.SendInitialMetadata(&param.server_context->initial_metadata_,
+                              param.server_context->initial_metadata_flags());
+      if (param.server_context->compression_level_set()) {
+        ops.set_compression_level(param.server_context->compression_level());
+      }
+    }
+    if (status.ok()) {
+      status = ops.SendMessagePtr(&rsp);
+    }
+    ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
+    param.call->PerformOps(&ops);
+    param.call->cq()->Pluck(&ops);
+  }
+
+ private:
+  std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
+                             ServerReader<RequestType>*, ResponseType*)>
+      func_;
+  ServiceType* service_;
+};
+
+/// A wrapper class of an application provided server streaming handler.
+template <class ServiceType, class RequestType, class ResponseType>
+class ServerStreamingHandler : public grpc::internal::MethodHandler {
+ public:
+  ServerStreamingHandler(std::function<grpc::Status(
+                             ServiceType*, grpc::ServerContext*,
+                             const RequestType*, ServerWriter<ResponseType>*)>
+                             func,
+                         ServiceType* service)
+      : func_(func), service_(service) {}
+
+  void RunHandler(const HandlerParameter& param) final {
+    grpc::Status status = param.status;
+    if (status.ok()) {
+      ServerWriter<ResponseType> writer(
+          param.call, static_cast<grpc::ServerContext*>(param.server_context));
+      status = CatchingFunctionHandler([this, &param, &writer] {
+        return func_(service_,
+                     static_cast<grpc::ServerContext*>(param.server_context),
+                     static_cast<RequestType*>(param.request), &writer);
+      });
+      static_cast<RequestType*>(param.request)->~RequestType();
+    }
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpServerSendStatus>
+        ops;
+    if (!param.server_context->sent_initial_metadata_) {
+      ops.SendInitialMetadata(&param.server_context->initial_metadata_,
+                              param.server_context->initial_metadata_flags());
+      if (param.server_context->compression_level_set()) {
+        ops.set_compression_level(param.server_context->compression_level());
+      }
+    }
+    ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
+    param.call->PerformOps(&ops);
+    if (param.server_context->has_pending_ops_) {
+      param.call->cq()->Pluck(&param.server_context->pending_ops_);
+    }
+    param.call->cq()->Pluck(&ops);
+  }
+
+  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
+                    grpc::Status* status, void** /*handler_data*/) final {
+    grpc::ByteBuffer buf;
+    buf.set_buffer(req);
+    auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call, sizeof(RequestType))) RequestType();
+    *status =
+        grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
+    buf.Release();
+    if (status->ok()) {
+      return request;
+    }
+    request->~RequestType();
+    return nullptr;
+  }
+
+ private:
+  std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
+                             const RequestType*, ServerWriter<ResponseType>*)>
+      func_;
+  ServiceType* service_;
+};
+
+/// A wrapper class of an application provided bidi-streaming handler.
+/// This also applies to server-streamed implementation of a unary method
+/// with the additional requirement that such methods must have done a
+/// write for status to be ok
+/// Since this is used by more than 1 class, the service is not passed in.
+/// Instead, it is expected to be an implicitly-captured argument of func
+/// (through bind or something along those lines)
+template <class Streamer, bool WriteNeeded>
+class TemplatedBidiStreamingHandler : public grpc::internal::MethodHandler {
+ public:
+  explicit TemplatedBidiStreamingHandler(
+      std::function<grpc::Status(grpc::ServerContext*, Streamer*)> func)
+      : func_(func), write_needed_(WriteNeeded) {}
+
+  void RunHandler(const HandlerParameter& param) final {
+    Streamer stream(param.call,
+                    static_cast<grpc::ServerContext*>(param.server_context));
+    grpc::Status status = CatchingFunctionHandler([this, &param, &stream] {
+      return func_(static_cast<grpc::ServerContext*>(param.server_context),
+                   &stream);
+    });
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpServerSendStatus>
+        ops;
+    if (!param.server_context->sent_initial_metadata_) {
+      ops.SendInitialMetadata(&param.server_context->initial_metadata_,
+                              param.server_context->initial_metadata_flags());
+      if (param.server_context->compression_level_set()) {
+        ops.set_compression_level(param.server_context->compression_level());
+      }
+      if (write_needed_ && status.ok()) {
+        // If we needed a write but never did one, we need to mark the
+        // status as a fail
+        status = grpc::Status(grpc::StatusCode::INTERNAL,
+                              "Service did not provide response message");
+      }
+    }
+    ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
+    param.call->PerformOps(&ops);
+    if (param.server_context->has_pending_ops_) {
+      param.call->cq()->Pluck(&param.server_context->pending_ops_);
+    }
+    param.call->cq()->Pluck(&ops);
+  }
+
+ private:
+  std::function<grpc::Status(grpc::ServerContext*, Streamer*)> func_;
+  const bool write_needed_;
+};
+
+template <class ServiceType, class RequestType, class ResponseType>
+class BidiStreamingHandler
+    : public TemplatedBidiStreamingHandler<
+          ServerReaderWriter<ResponseType, RequestType>, false> {
+ public:
+  BidiStreamingHandler(std::function<grpc::Status(
+                           ServiceType*, grpc::ServerContext*,
+                           ServerReaderWriter<ResponseType, RequestType>*)>
+                           func,
+                       ServiceType* service)
+      // TODO(vjpai): When gRPC supports C++14, move-capture func in the below
+      : TemplatedBidiStreamingHandler<
+            ServerReaderWriter<ResponseType, RequestType>, false>(
+            [func, service](
+                grpc::ServerContext* ctx,
+                ServerReaderWriter<ResponseType, RequestType>* streamer) {
+              return func(service, ctx, streamer);
+            }) {}
+};
+
+template <class RequestType, class ResponseType>
+class StreamedUnaryHandler
+    : public TemplatedBidiStreamingHandler<
+          ServerUnaryStreamer<RequestType, ResponseType>, true> {
+ public:
+  explicit StreamedUnaryHandler(
+      std::function<
+          grpc::Status(grpc::ServerContext*,
+                       ServerUnaryStreamer<RequestType, ResponseType>*)>
+          func)
+      : TemplatedBidiStreamingHandler<
+            ServerUnaryStreamer<RequestType, ResponseType>, true>(
+            std::move(func)) {}
+};
+
+template <class RequestType, class ResponseType>
+class SplitServerStreamingHandler
+    : public TemplatedBidiStreamingHandler<
+          ServerSplitStreamer<RequestType, ResponseType>, false> {
+ public:
+  explicit SplitServerStreamingHandler(
+      std::function<
+          grpc::Status(grpc::ServerContext*,
+                       ServerSplitStreamer<RequestType, ResponseType>*)>
+          func)
+      : TemplatedBidiStreamingHandler<
+            ServerSplitStreamer<RequestType, ResponseType>, false>(
+            std::move(func)) {}
+};
+
+/// General method handler class for errors that prevent real method use
+/// e.g., handle unknown method by returning UNIMPLEMENTED error.
+template <grpc::StatusCode code>
+class ErrorMethodHandler : public grpc::internal::MethodHandler {
+ public:
+  explicit ErrorMethodHandler(const std::string& message) : message_(message) {}
+
+  template <class T>
+  static void FillOps(grpc::ServerContextBase* context,
+                      const std::string& message, T* ops) {
+    grpc::Status status(code, message);
+    if (!context->sent_initial_metadata_) {
+      ops->SendInitialMetadata(&context->initial_metadata_,
+                               context->initial_metadata_flags());
+      if (context->compression_level_set()) {
+        ops->set_compression_level(context->compression_level());
+      }
+      context->sent_initial_metadata_ = true;
+    }
+    ops->ServerSendStatus(&context->trailing_metadata_, status);
+  }
+
+  void RunHandler(const HandlerParameter& param) final {
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpServerSendStatus>
+        ops;
+    FillOps(param.server_context, message_, &ops);
+    param.call->PerformOps(&ops);
+    param.call->cq()->Pluck(&ops);
+  }
+
+  void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req,
+                    grpc::Status* /*status*/, void** /*handler_data*/) final {
+    // We have to destroy any request payload
+    if (req != nullptr) {
+      grpc::g_core_codegen_interface->grpc_byte_buffer_destroy(req);
+    }
+    return nullptr;
+  }
+
+ private:
+  const std::string message_;
+};
+
+typedef ErrorMethodHandler<grpc::StatusCode::UNIMPLEMENTED>
+    UnknownMethodHandler;
+typedef ErrorMethodHandler<grpc::StatusCode::RESOURCE_EXHAUSTED>
+    ResourceExhaustedHandler;
+
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler_impl.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler_impl.h
new file mode 100644
index 0000000..3f1d573
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler_impl.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
+#define GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
+
+// IWYU pragma: private
+
+#endif  // GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_IMPL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_reader.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_reader.h
new file mode 100644
index 0000000..ecc0e30
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_reader.h
@@ -0,0 +1,151 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H
+#define GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H
+
+// IWYU pragma: private, include <grpcpp/support/proto_buffer_reader.h>
+
+#include <type_traits>
+
+#include <grpc/impl/codegen/byte_buffer_reader.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/config_protobuf.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/serialization_traits.h>
+#include <grpcpp/impl/codegen/status.h>
+
+/// This header provides an object that reads bytes directly from a
+/// grpc::ByteBuffer, via the ZeroCopyInputStream interface
+
+namespace grpc {
+
+extern CoreCodegenInterface* g_core_codegen_interface;
+
+/// This is a specialization of the protobuf class ZeroCopyInputStream
+/// The principle is to get one chunk of data at a time from the proto layer,
+/// with options to backup (re-see some bytes) or skip (forward past some bytes)
+///
+/// Read more about ZeroCopyInputStream interface here:
+/// https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.io.zero_copy_stream#ZeroCopyInputStream
+class ProtoBufferReader : public grpc::protobuf::io::ZeroCopyInputStream {
+ public:
+  /// Constructs buffer reader from \a buffer. Will set \a status() to non ok
+  /// if \a buffer is invalid (the internal buffer has not been initialized).
+  explicit ProtoBufferReader(ByteBuffer* buffer)
+      : byte_count_(0), backup_count_(0), status_() {
+    /// Implemented through a grpc_byte_buffer_reader which iterates
+    /// over the slices that make up a byte buffer
+    if (!buffer->Valid() ||
+        !g_core_codegen_interface->grpc_byte_buffer_reader_init(
+            &reader_, buffer->c_buffer())) {
+      status_ = Status(StatusCode::INTERNAL,
+                       "Couldn't initialize byte buffer reader");
+    }
+  }
+
+  ~ProtoBufferReader() override {
+    if (status_.ok()) {
+      g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_);
+    }
+  }
+
+  /// Give the proto library a chunk of data from the stream. The caller
+  /// may safely read from data[0, size - 1].
+  bool Next(const void** data, int* size) override {
+    if (!status_.ok()) {
+      return false;
+    }
+    /// If we have backed up previously, we need to return the backed-up slice
+    if (backup_count_ > 0) {
+      *data = GRPC_SLICE_START_PTR(*slice_) + GRPC_SLICE_LENGTH(*slice_) -
+              backup_count_;
+      GPR_CODEGEN_ASSERT(backup_count_ <= INT_MAX);
+      *size = static_cast<int>(backup_count_);
+      backup_count_ = 0;
+      return true;
+    }
+    /// Otherwise get the next slice from the byte buffer reader
+    if (!g_core_codegen_interface->grpc_byte_buffer_reader_peek(&reader_,
+                                                                &slice_)) {
+      return false;
+    }
+    *data = GRPC_SLICE_START_PTR(*slice_);
+    // On win x64, int is only 32bit
+    GPR_CODEGEN_ASSERT(GRPC_SLICE_LENGTH(*slice_) <= INT_MAX);
+    byte_count_ += * size = static_cast<int>(GRPC_SLICE_LENGTH(*slice_));
+    return true;
+  }
+
+  /// Returns the status of the buffer reader.
+  Status status() const { return status_; }
+
+  /// The proto library calls this to indicate that we should back up \a count
+  /// bytes that have already been returned by the last call of Next.
+  /// So do the backup and have that ready for a later Next.
+  void BackUp(int count) override {
+    GPR_CODEGEN_ASSERT(count <= static_cast<int>(GRPC_SLICE_LENGTH(*slice_)));
+    backup_count_ = count;
+  }
+
+  /// The proto library calls this to skip over \a count bytes. Implement this
+  /// using Next and BackUp combined.
+  bool Skip(int count) override {
+    const void* data;
+    int size;
+    while (Next(&data, &size)) {
+      if (size >= count) {
+        BackUp(size - count);
+        return true;
+      }
+      // size < count;
+      count -= size;
+    }
+    // error or we have too large count;
+    return false;
+  }
+
+  /// Returns the total number of bytes read since this object was created.
+  int64_t ByteCount() const override { return byte_count_ - backup_count_; }
+
+  // These protected members are needed to support internal optimizations.
+  // they expose internal bits of grpc core that are NOT stable. If you have
+  // a use case needs to use one of these functions, please send an email to
+  // https://groups.google.com/forum/#!forum/grpc-io.
+ protected:
+  void set_byte_count(int64_t byte_count) { byte_count_ = byte_count; }
+  int64_t backup_count() { return backup_count_; }
+  void set_backup_count(int64_t backup_count) { backup_count_ = backup_count; }
+  grpc_byte_buffer_reader* reader() { return &reader_; }
+  grpc_slice* slice() { return slice_; }
+  grpc_slice** mutable_slice_ptr() { return &slice_; }
+
+ private:
+  int64_t byte_count_;              ///< total bytes read since object creation
+  int64_t backup_count_;            ///< how far backed up in the stream we are
+  grpc_byte_buffer_reader reader_;  ///< internal object to read \a grpc_slice
+                                    ///< from the \a grpc_byte_buffer
+  grpc_slice* slice_;               ///< current slice passed back to the caller
+  Status status_;                   ///< status of the entire object
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_READER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_writer.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_writer.h
new file mode 100644
index 0000000..efb6dd0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_writer.h
@@ -0,0 +1,181 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_WRITER_H
+#define GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_WRITER_H
+
+// IWYU pragma: private, include <grpcpp/support/proto_buffer_writer.h>
+
+#include <type_traits>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/config_protobuf.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/serialization_traits.h>
+#include <grpcpp/impl/codegen/status.h>
+
+/// This header provides an object that writes bytes directly into a
+/// grpc::ByteBuffer, via the ZeroCopyOutputStream interface
+
+namespace grpc {
+
+extern CoreCodegenInterface* g_core_codegen_interface;
+
+// Forward declaration for testing use only
+namespace internal {
+class ProtoBufferWriterPeer;
+}  // namespace internal
+
+const int kProtoBufferWriterMaxBufferLength = 1024 * 1024;
+
+/// This is a specialization of the protobuf class ZeroCopyOutputStream.
+/// The principle is to give the proto layer one buffer of bytes at a time
+/// that it can use to serialize the next portion of the message, with the
+/// option to "backup" if more buffer is given than required at the last buffer.
+///
+/// Read more about ZeroCopyOutputStream interface here:
+/// https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.io.zero_copy_stream#ZeroCopyOutputStream
+class ProtoBufferWriter : public grpc::protobuf::io::ZeroCopyOutputStream {
+ public:
+  /// Constructor for this derived class
+  ///
+  /// \param[out] byte_buffer A pointer to the grpc::ByteBuffer created
+  /// \param block_size How big are the chunks to allocate at a time
+  /// \param total_size How many total bytes are required for this proto
+  ProtoBufferWriter(ByteBuffer* byte_buffer, int block_size, int total_size)
+      : block_size_(block_size),
+        total_size_(total_size),
+        byte_count_(0),
+        have_backup_(false) {
+    GPR_CODEGEN_ASSERT(!byte_buffer->Valid());
+    /// Create an empty raw byte buffer and look at its underlying slice buffer
+    grpc_byte_buffer* bp =
+        g_core_codegen_interface->grpc_raw_byte_buffer_create(nullptr, 0);
+    byte_buffer->set_buffer(bp);
+    slice_buffer_ = &bp->data.raw.slice_buffer;
+  }
+
+  ~ProtoBufferWriter() override {
+    if (have_backup_) {
+      g_core_codegen_interface->grpc_slice_unref(backup_slice_);
+    }
+  }
+
+  /// Give the proto library the next buffer of bytes and its size. It is
+  /// safe for the caller to write from data[0, size - 1].
+  bool Next(void** data, int* size) override {
+    // Protobuf should not ask for more memory than total_size_.
+    GPR_CODEGEN_ASSERT(byte_count_ < total_size_);
+    // 1. Use the remaining backup slice if we have one
+    // 2. Otherwise allocate a slice, up to the remaining length needed
+    //    or our maximum allocation size
+    // 3. Provide the slice start and size available
+    // 4. Add the slice being returned to the slice buffer
+    size_t remain = static_cast<size_t>(total_size_ - byte_count_);
+    if (have_backup_) {
+      /// If we have a backup slice, we should use it first
+      slice_ = backup_slice_;
+      have_backup_ = false;
+      if (GRPC_SLICE_LENGTH(slice_) > remain) {
+        GRPC_SLICE_SET_LENGTH(slice_, remain);
+      }
+    } else {
+      // When less than a whole block is needed, only allocate that much.
+      // But make sure the allocated slice is not inlined.
+      size_t allocate_length =
+          remain > static_cast<size_t>(block_size_) ? block_size_ : remain;
+      slice_ = g_core_codegen_interface->grpc_slice_malloc(
+          allocate_length > GRPC_SLICE_INLINED_SIZE
+              ? allocate_length
+              : GRPC_SLICE_INLINED_SIZE + 1);
+    }
+    *data = GRPC_SLICE_START_PTR(slice_);
+    // On win x64, int is only 32bit
+    GPR_CODEGEN_ASSERT(GRPC_SLICE_LENGTH(slice_) <= INT_MAX);
+    byte_count_ += * size = static_cast<int>(GRPC_SLICE_LENGTH(slice_));
+    // Using grpc_slice_buffer_add could modify slice_ and merge it with the
+    // previous slice. Therefore, use grpc_slice_buffer_add_indexed method to
+    // ensure the slice gets added at a separate index. It can then be kept
+    // around and popped later in the BackUp function.
+    g_core_codegen_interface->grpc_slice_buffer_add_indexed(slice_buffer_,
+                                                            slice_);
+    return true;
+  }
+
+  /// Backup by \a count bytes because Next returned more bytes than needed
+  /// (only used in the last buffer). \a count must be less than or equal too
+  /// the last buffer returned from next.
+  void BackUp(int count) override {
+    // count == 0 is invoked by ZeroCopyOutputStream users indicating that any
+    // potential buffer obtained through a previous call to Next() is final.
+    // ZeroCopyOutputStream implementations such as streaming output can use
+    // these calls to flush any temporary buffer and flush the output. The logic
+    // below is not robust against count == 0 invocations, so directly return.
+    if (count == 0) return;
+
+    /// 1. Remove the partially-used last slice from the slice buffer
+    /// 2. Split it into the needed (if any) and unneeded part
+    /// 3. Add the needed part back to the slice buffer
+    /// 4. Mark that we still have the remaining part (for later use/unref)
+    GPR_CODEGEN_ASSERT(count <= static_cast<int>(GRPC_SLICE_LENGTH(slice_)));
+    g_core_codegen_interface->grpc_slice_buffer_pop(slice_buffer_);
+    if (static_cast<size_t>(count) == GRPC_SLICE_LENGTH(slice_)) {
+      backup_slice_ = slice_;
+    } else {
+      backup_slice_ = g_core_codegen_interface->grpc_slice_split_tail(
+          &slice_, GRPC_SLICE_LENGTH(slice_) - count);
+      g_core_codegen_interface->grpc_slice_buffer_add(slice_buffer_, slice_);
+    }
+    // It's dangerous to keep an inlined grpc_slice as the backup slice, since
+    // on a following Next() call, a reference will be returned to this slice
+    // via GRPC_SLICE_START_PTR, which will not be an address held by
+    // slice_buffer_.
+    have_backup_ = backup_slice_.refcount != nullptr;
+    byte_count_ -= count;
+  }
+
+  /// Returns the total number of bytes written since this object was created.
+  int64_t ByteCount() const override { return byte_count_; }
+
+  // These protected members are needed to support internal optimizations.
+  // they expose internal bits of grpc core that are NOT stable. If you have
+  // a use case needs to use one of these functions, please send an email to
+  // https://groups.google.com/forum/#!forum/grpc-io.
+ protected:
+  grpc_slice_buffer* slice_buffer() { return slice_buffer_; }
+  void set_byte_count(int64_t byte_count) { byte_count_ = byte_count; }
+
+ private:
+  // friend for testing purposes only
+  friend class internal::ProtoBufferWriterPeer;
+  const int block_size_;  ///< size to alloc for each new \a grpc_slice needed
+  const int total_size_;  ///< byte size of proto being serialized
+  int64_t byte_count_;    ///< bytes written since this object was created
+  grpc_slice_buffer*
+      slice_buffer_;  ///< internal buffer of slices holding the serialized data
+  bool have_backup_;  ///< if we are holding a backup slice or not
+  grpc_slice backup_slice_;  ///< holds space we can still write to, if the
+                             ///< caller has called BackUp
+  grpc_slice slice_;         ///< current slice passed back to the caller
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_PROTO_BUFFER_WRITER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_utils.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_utils.h
new file mode 100644
index 0000000..4f6d874
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_utils.h
@@ -0,0 +1,121 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_PROTO_UTILS_H
+#define GRPCPP_IMPL_CODEGEN_PROTO_UTILS_H
+
+// IWYU pragma: private
+
+#include <type_traits>
+
+#include <grpc/impl/codegen/byte_buffer_reader.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/config_protobuf.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/proto_buffer_reader.h>
+#include <grpcpp/impl/codegen/proto_buffer_writer.h>
+#include <grpcpp/impl/codegen/serialization_traits.h>
+#include <grpcpp/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/status.h>
+
+/// This header provides serialization and deserialization between gRPC
+/// messages serialized using protobuf and the C++ objects they represent.
+
+namespace grpc {
+
+extern CoreCodegenInterface* g_core_codegen_interface;
+
+// ProtoBufferWriter must be a subclass of ::protobuf::io::ZeroCopyOutputStream.
+template <class ProtoBufferWriter, class T>
+Status GenericSerialize(const grpc::protobuf::MessageLite& msg, ByteBuffer* bb,
+                        bool* own_buffer) {
+  static_assert(std::is_base_of<protobuf::io::ZeroCopyOutputStream,
+                                ProtoBufferWriter>::value,
+                "ProtoBufferWriter must be a subclass of "
+                "::protobuf::io::ZeroCopyOutputStream");
+  *own_buffer = true;
+  int byte_size = static_cast<int>(msg.ByteSizeLong());
+  if (static_cast<size_t>(byte_size) <= GRPC_SLICE_INLINED_SIZE) {
+    Slice slice(byte_size);
+    // We serialize directly into the allocated slices memory
+    GPR_CODEGEN_ASSERT(slice.end() == msg.SerializeWithCachedSizesToArray(
+                                          const_cast<uint8_t*>(slice.begin())));
+    ByteBuffer tmp(&slice, 1);
+    bb->Swap(&tmp);
+
+    return g_core_codegen_interface->ok();
+  }
+  ProtoBufferWriter writer(bb, kProtoBufferWriterMaxBufferLength, byte_size);
+  return msg.SerializeToZeroCopyStream(&writer)
+             ? g_core_codegen_interface->ok()
+             : Status(StatusCode::INTERNAL, "Failed to serialize message");
+}
+
+// BufferReader must be a subclass of ::protobuf::io::ZeroCopyInputStream.
+template <class ProtoBufferReader, class T>
+Status GenericDeserialize(ByteBuffer* buffer,
+                          grpc::protobuf::MessageLite* msg) {
+  static_assert(std::is_base_of<protobuf::io::ZeroCopyInputStream,
+                                ProtoBufferReader>::value,
+                "ProtoBufferReader must be a subclass of "
+                "::protobuf::io::ZeroCopyInputStream");
+  if (buffer == nullptr) {
+    return Status(StatusCode::INTERNAL, "No payload");
+  }
+  Status result = g_core_codegen_interface->ok();
+  {
+    ProtoBufferReader reader(buffer);
+    if (!reader.status().ok()) {
+      return reader.status();
+    }
+    if (!msg->ParseFromZeroCopyStream(&reader)) {
+      result = Status(StatusCode::INTERNAL, msg->InitializationErrorString());
+    }
+  }
+  buffer->Clear();
+  return result;
+}
+
+// this is needed so the following class does not conflict with protobuf
+// serializers that utilize internal-only tools.
+#ifdef GRPC_OPEN_SOURCE_PROTO
+// This class provides a protobuf serializer. It translates between protobuf
+// objects and grpc_byte_buffers. More information about SerializationTraits can
+// be found in include/grpcpp/impl/codegen/serialization_traits.h.
+template <class T>
+class SerializationTraits<
+    T, typename std::enable_if<
+           std::is_base_of<grpc::protobuf::MessageLite, T>::value>::type> {
+ public:
+  static Status Serialize(const grpc::protobuf::MessageLite& msg,
+                          ByteBuffer* bb, bool* own_buffer) {
+    return GenericSerialize<ProtoBufferWriter, T>(msg, bb, own_buffer);
+  }
+
+  static Status Deserialize(ByteBuffer* buffer,
+                            grpc::protobuf::MessageLite* msg) {
+    return GenericDeserialize<ProtoBufferReader, T>(buffer, msg);
+  }
+};
+#endif
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_PROTO_UTILS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_method.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_method.h
new file mode 100644
index 0000000..83dedda
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_method.h
@@ -0,0 +1,82 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_RPC_METHOD_H
+#define GRPCPP_IMPL_CODEGEN_RPC_METHOD_H
+
+// IWYU pragma: private, include <grpcpp/impl/rpc_method.h>
+
+#include <memory>
+
+#include <grpcpp/impl/codegen/channel_interface.h>
+
+namespace grpc {
+namespace internal {
+/// Descriptor of an RPC method
+class RpcMethod {
+ public:
+  enum RpcType {
+    NORMAL_RPC = 0,
+    CLIENT_STREAMING,  // request streaming
+    SERVER_STREAMING,  // response streaming
+    BIDI_STREAMING
+  };
+
+  RpcMethod(const char* name, RpcType type)
+      : name_(name),
+        suffix_for_stats_(nullptr),
+        method_type_(type),
+        channel_tag_(nullptr) {}
+
+  RpcMethod(const char* name, const char* suffix_for_stats, RpcType type)
+      : name_(name),
+        suffix_for_stats_(suffix_for_stats),
+        method_type_(type),
+        channel_tag_(nullptr) {}
+
+  RpcMethod(const char* name, RpcType type,
+            const std::shared_ptr<ChannelInterface>& channel)
+      : name_(name),
+        suffix_for_stats_(nullptr),
+        method_type_(type),
+        channel_tag_(channel->RegisterMethod(name)) {}
+
+  RpcMethod(const char* name, const char* suffix_for_stats, RpcType type,
+            const std::shared_ptr<ChannelInterface>& channel)
+      : name_(name),
+        suffix_for_stats_(suffix_for_stats),
+        method_type_(type),
+        channel_tag_(channel->RegisterMethod(name)) {}
+
+  const char* name() const { return name_; }
+  const char* suffix_for_stats() const { return suffix_for_stats_; }
+  RpcType method_type() const { return method_type_; }
+  void SetMethodType(RpcType type) { method_type_ = type; }
+  void* channel_tag() const { return channel_tag_; }
+
+ private:
+  const char* const name_;
+  const char* const suffix_for_stats_;
+  RpcType method_type_;
+  void* const channel_tag_;
+};
+
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_RPC_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_service_method.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_service_method.h
new file mode 100644
index 0000000..6f6730a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_service_method.h
@@ -0,0 +1,155 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_RPC_SERVICE_METHOD_H
+#define GRPCPP_IMPL_CODEGEN_RPC_SERVICE_METHOD_H
+
+// IWYU pragma: private, include <grpcpp/impl/rpc_service_method.h>
+
+#include <climits>
+#include <functional>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include <grpc/impl/codegen/log.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+class ServerContextBase;
+namespace internal {
+/// Base class for running an RPC handler.
+class MethodHandler {
+ public:
+  virtual ~MethodHandler() {}
+  struct HandlerParameter {
+    /// Constructor for HandlerParameter
+    ///
+    /// \param c : the gRPC Call structure for this server call
+    /// \param context : the ServerContext structure for this server call
+    /// \param req : the request payload, if appropriate for this RPC
+    /// \param req_status : the request status after any interceptors have run
+    /// \param handler_data: internal data for the handler.
+    /// \param requester : used only by the callback API. It is a function
+    ///        called by the RPC Controller to request another RPC (and also
+    ///        to set up the state required to make that request possible)
+    HandlerParameter(Call* c, grpc::ServerContextBase* context, void* req,
+                     Status req_status, void* handler_data,
+                     std::function<void()> requester)
+        : call(c),
+          server_context(context),
+          request(req),
+          status(req_status),
+          internal_data(handler_data),
+          call_requester(std::move(requester)) {}
+    ~HandlerParameter() {}
+    Call* const call;
+    grpc::ServerContextBase* const server_context;
+    void* const request;
+    const Status status;
+    void* const internal_data;
+    const std::function<void()> call_requester;
+  };
+  virtual void RunHandler(const HandlerParameter& param) = 0;
+
+  /* Returns a pointer to the deserialized request. \a status reflects the
+     result of deserialization. This pointer and the status should be filled in
+     a HandlerParameter and passed to RunHandler. It is illegal to access the
+     pointer after calling RunHandler. Ownership of the deserialized request is
+     retained by the handler. Returns nullptr if deserialization failed. */
+  virtual void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req,
+                            Status* /*status*/, void** /*handler_data*/) {
+    GPR_CODEGEN_ASSERT(req == nullptr);
+    return nullptr;
+  }
+};
+
+/// Server side rpc method class
+class RpcServiceMethod : public RpcMethod {
+ public:
+  /// Takes ownership of the handler
+  RpcServiceMethod(const char* name, RpcMethod::RpcType type,
+                   MethodHandler* handler)
+      : RpcMethod(name, type),
+        server_tag_(nullptr),
+        api_type_(ApiType::SYNC),
+        handler_(handler) {}
+
+  enum class ApiType {
+    SYNC,
+    ASYNC,
+    RAW,
+    CALL_BACK,  // not CALLBACK because that is reserved in Windows
+    RAW_CALL_BACK,
+  };
+
+  void set_server_tag(void* tag) { server_tag_ = tag; }
+  void* server_tag() const { return server_tag_; }
+  /// if MethodHandler is nullptr, then this is an async method
+  MethodHandler* handler() const { return handler_.get(); }
+  ApiType api_type() const { return api_type_; }
+  void SetHandler(MethodHandler* handler) { handler_.reset(handler); }
+  void SetServerApiType(RpcServiceMethod::ApiType type) {
+    if ((api_type_ == ApiType::SYNC) &&
+        (type == ApiType::ASYNC || type == ApiType::RAW)) {
+      // this marks this method as async
+      handler_.reset();
+    } else if (api_type_ != ApiType::SYNC) {
+      // this is not an error condition, as it allows users to declare a server
+      // like WithRawMethod_foo<AsyncService>. However since it
+      // overwrites behavior, it should be logged.
+      gpr_log(
+          GPR_INFO,
+          "You are marking method %s as '%s', even though it was "
+          "previously marked '%s'. This behavior will overwrite the original "
+          "behavior. If you expected this then ignore this message.",
+          name(), TypeToString(api_type_), TypeToString(type));
+    }
+    api_type_ = type;
+  }
+
+ private:
+  void* server_tag_;
+  ApiType api_type_;
+  std::unique_ptr<MethodHandler> handler_;
+
+  const char* TypeToString(RpcServiceMethod::ApiType type) {
+    switch (type) {
+      case ApiType::SYNC:
+        return "sync";
+      case ApiType::ASYNC:
+        return "async";
+      case ApiType::RAW:
+        return "raw";
+      case ApiType::CALL_BACK:
+        return "callback";
+      case ApiType::RAW_CALL_BACK:
+        return "raw_callback";
+      default:
+        GPR_UNREACHABLE_CODE(return "unknown");
+    }
+  }
+};
+}  // namespace internal
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_RPC_SERVICE_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/security/auth_context.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/security/auth_context.h
new file mode 100644
index 0000000..c67e1cf
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/security/auth_context.h
@@ -0,0 +1,101 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H
+#define GRPCPP_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H
+
+// IWYU pragma: private, include <grpcpp/security/auth_context.h>
+
+#include <iterator>
+#include <vector>
+
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/string_ref.h>
+
+struct grpc_auth_context;
+struct grpc_auth_property;
+struct grpc_auth_property_iterator;
+
+namespace grpc {
+class SecureAuthContext;
+
+typedef std::pair<string_ref, string_ref> AuthProperty;
+
+class AuthPropertyIterator {
+ public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = const AuthProperty;
+  using pointer = void;
+  using reference = void;
+  using difference_type = std::ptrdiff_t;
+
+  ~AuthPropertyIterator();
+  AuthPropertyIterator& operator++();
+  AuthPropertyIterator operator++(int);
+  bool operator==(const AuthPropertyIterator& rhs) const;
+  bool operator!=(const AuthPropertyIterator& rhs) const;
+  AuthProperty operator*();
+
+ protected:
+  AuthPropertyIterator();
+  AuthPropertyIterator(const grpc_auth_property* property,
+                       const grpc_auth_property_iterator* iter);
+
+ private:
+  friend class SecureAuthContext;
+  const grpc_auth_property* property_;
+  // The following items form a grpc_auth_property_iterator.
+  const grpc_auth_context* ctx_;
+  size_t index_;
+  const char* name_;
+};
+
+/// Class encapsulating the Authentication Information.
+///
+/// It includes the secure identity of the peer, the type of secure transport
+/// used as well as any other properties required by the authorization layer.
+class AuthContext {
+ public:
+  virtual ~AuthContext() {}
+
+  /// Returns true if the peer is authenticated.
+  virtual bool IsPeerAuthenticated() const = 0;
+
+  /// A peer identity.
+  ///
+  /// It is, in general, comprised of one or more properties (in which case they
+  /// have the same name).
+  virtual std::vector<grpc::string_ref> GetPeerIdentity() const = 0;
+  virtual std::string GetPeerIdentityPropertyName() const = 0;
+
+  /// Returns all the property values with the given name.
+  virtual std::vector<grpc::string_ref> FindPropertyValues(
+      const std::string& name) const = 0;
+
+  /// Iteration over all the properties.
+  virtual AuthPropertyIterator begin() const = 0;
+  virtual AuthPropertyIterator end() const = 0;
+
+  /// Mutation functions: should only be used by an AuthMetadataProcessor.
+  virtual void AddProperty(const std::string& key, const string_ref& value) = 0;
+  virtual bool SetPeerIdentityPropertyName(const std::string& name) = 0;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SECURITY_AUTH_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/serialization_traits.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/serialization_traits.h
new file mode 100644
index 0000000..3148dff
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/serialization_traits.h
@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SERIALIZATION_TRAITS_H
+#define GRPCPP_IMPL_CODEGEN_SERIALIZATION_TRAITS_H
+
+// IWYU pragma: private, include <grpcpp/impl/serialization_traits.h>
+
+namespace grpc {
+
+/// Defines how to serialize and deserialize some type.
+///
+/// Used for hooking different message serialization API's into GRPC.
+/// Each SerializationTraits<Message> implementation must provide the
+/// following functions:
+/// 1.  static Status Serialize(const Message& msg,
+///                             ByteBuffer* buffer,
+///                             bool* own_buffer);
+///     OR
+///     static Status Serialize(const Message& msg,
+///                             grpc_byte_buffer** buffer,
+///                             bool* own_buffer);
+///     The former is preferred; the latter is deprecated
+///
+/// 2.  static Status Deserialize(ByteBuffer* buffer,
+///                               Message* msg);
+///     OR
+///     static Status Deserialize(grpc_byte_buffer* buffer,
+///                               Message* msg);
+///     The former is preferred; the latter is deprecated
+///
+/// Serialize is required to convert message to a ByteBuffer, and
+/// return that byte buffer through *buffer. *own_buffer should
+/// be set to true if the caller owns said byte buffer, or false if
+/// ownership is retained elsewhere.
+///
+/// Deserialize is required to convert buffer into the message stored at
+/// msg. max_receive_message_size is passed in as a bound on the maximum
+/// number of message bytes Deserialize should accept.
+///
+/// Both functions return a Status, allowing them to explain what went
+/// wrong if required.
+template <class Message,
+          class UnusedButHereForPartialTemplateSpecialization = void>
+class SerializationTraits;
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SERIALIZATION_TRAITS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback.h
new file mode 100644
index 0000000..d292e7b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback.h
@@ -0,0 +1,799 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_H
+#define GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_H
+
+// IWYU pragma: private, include <grpcpp/support/server_callback.h>
+
+#include <atomic>
+#include <functional>
+#include <type_traits>
+
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/call_op_set.h>
+#include <grpcpp/impl/codegen/callback_common.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/sync.h>
+
+namespace grpc {
+
+// Declare base class of all reactors as internal
+namespace internal {
+
+// Forward declarations
+template <class Request, class Response>
+class CallbackUnaryHandler;
+template <class Request, class Response>
+class CallbackClientStreamingHandler;
+template <class Request, class Response>
+class CallbackServerStreamingHandler;
+template <class Request, class Response>
+class CallbackBidiHandler;
+
+class ServerReactor {
+ public:
+  virtual ~ServerReactor() = default;
+  virtual void OnDone() = 0;
+  virtual void OnCancel() = 0;
+
+  // The following is not API. It is for internal use only and specifies whether
+  // all reactions of this Reactor can be run without an extra executor
+  // scheduling. This should only be used for internally-defined reactors with
+  // trivial reactions.
+  virtual bool InternalInlineable() { return false; }
+
+ private:
+  template <class Request, class Response>
+  friend class CallbackUnaryHandler;
+  template <class Request, class Response>
+  friend class CallbackClientStreamingHandler;
+  template <class Request, class Response>
+  friend class CallbackServerStreamingHandler;
+  template <class Request, class Response>
+  friend class CallbackBidiHandler;
+};
+
+/// The base class of ServerCallbackUnary etc.
+class ServerCallbackCall {
+ public:
+  virtual ~ServerCallbackCall() {}
+
+  // This object is responsible for tracking when it is safe to call OnDone and
+  // OnCancel. OnDone should not be called until the method handler is complete,
+  // Finish has been called, the ServerContext CompletionOp (which tracks
+  // cancellation or successful completion) has completed, and all outstanding
+  // Read/Write actions have seen their reactions. OnCancel should not be called
+  // until after the method handler is done and the RPC has completed with a
+  // cancellation. This is tracked by counting how many of these conditions have
+  // been met and calling OnCancel when none remain unmet.
+
+  // Public versions of MaybeDone: one where we don't know the reactor in
+  // advance (used for the ServerContext CompletionOp), and one for where we
+  // know the inlineability of the OnDone reaction. You should set the inline
+  // flag to true if either the Reactor is InternalInlineable() or if this
+  // callback is already being forced to run dispatched to an executor
+  // (typically because it contains additional work than just the MaybeDone).
+
+  void MaybeDone() {
+    if (GPR_UNLIKELY(Unref() == 1)) {
+      ScheduleOnDone(reactor()->InternalInlineable());
+    }
+  }
+
+  void MaybeDone(bool inline_ondone) {
+    if (GPR_UNLIKELY(Unref() == 1)) {
+      ScheduleOnDone(inline_ondone);
+    }
+  }
+
+  // Fast version called with known reactor passed in, used from derived
+  // classes, typically in non-cancel case
+  void MaybeCallOnCancel(ServerReactor* reactor) {
+    if (GPR_UNLIKELY(UnblockCancellation())) {
+      CallOnCancel(reactor);
+    }
+  }
+
+  // Slower version called from object that doesn't know the reactor a priori
+  // (such as the ServerContext CompletionOp which is formed before the
+  // reactor). This is used in cancel cases only, so it's ok to be slower and
+  // invoke a virtual function.
+  void MaybeCallOnCancel() {
+    if (GPR_UNLIKELY(UnblockCancellation())) {
+      CallOnCancel(reactor());
+    }
+  }
+
+ protected:
+  /// Increases the reference count
+  void Ref() { callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed); }
+
+ private:
+  virtual ServerReactor* reactor() = 0;
+
+  // CallOnDone performs the work required at completion of the RPC: invoking
+  // the OnDone function and doing all necessary cleanup. This function is only
+  // ever invoked on a fully-Unref'fed ServerCallbackCall.
+  virtual void CallOnDone() = 0;
+
+  // If the OnDone reaction is inlineable, execute it inline. Otherwise send it
+  // to an executor.
+  void ScheduleOnDone(bool inline_ondone);
+
+  // If the OnCancel reaction is inlineable, execute it inline. Otherwise send
+  // it to an executor.
+  void CallOnCancel(ServerReactor* reactor);
+
+  // Implement the cancellation constraint counter. Return true if OnCancel
+  // should be called, false otherwise.
+  bool UnblockCancellation() {
+    return on_cancel_conditions_remaining_.fetch_sub(
+               1, std::memory_order_acq_rel) == 1;
+  }
+
+  /// Decreases the reference count and returns the previous value
+  int Unref() {
+    return callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel);
+  }
+
+  std::atomic_int on_cancel_conditions_remaining_{2};
+  std::atomic_int callbacks_outstanding_{
+      3};  // reserve for start, Finish, and CompletionOp
+};
+
+template <class Request, class Response>
+class DefaultMessageHolder : public MessageHolder<Request, Response> {
+ public:
+  DefaultMessageHolder() {
+    this->set_request(&request_obj_);
+    this->set_response(&response_obj_);
+  }
+  void Release() override {
+    // the object is allocated in the call arena.
+    this->~DefaultMessageHolder<Request, Response>();
+  }
+
+ private:
+  Request request_obj_;
+  Response response_obj_;
+};
+
+}  // namespace internal
+
+// Forward declarations
+class ServerUnaryReactor;
+template <class Request>
+class ServerReadReactor;
+template <class Response>
+class ServerWriteReactor;
+template <class Request, class Response>
+class ServerBidiReactor;
+
+// NOTE: The actual call/stream object classes are provided as API only to
+// support mocking. There are no implementations of these class interfaces in
+// the API.
+class ServerCallbackUnary : public internal::ServerCallbackCall {
+ public:
+  ~ServerCallbackUnary() override {}
+  virtual void Finish(grpc::Status s) = 0;
+  virtual void SendInitialMetadata() = 0;
+
+ protected:
+  // Use a template rather than explicitly specifying ServerUnaryReactor to
+  // delay binding and avoid a circular forward declaration issue
+  template <class Reactor>
+  void BindReactor(Reactor* reactor) {
+    reactor->InternalBindCall(this);
+  }
+};
+
+template <class Request>
+class ServerCallbackReader : public internal::ServerCallbackCall {
+ public:
+  ~ServerCallbackReader() override {}
+  virtual void Finish(grpc::Status s) = 0;
+  virtual void SendInitialMetadata() = 0;
+  virtual void Read(Request* msg) = 0;
+
+ protected:
+  void BindReactor(ServerReadReactor<Request>* reactor) {
+    reactor->InternalBindReader(this);
+  }
+};
+
+template <class Response>
+class ServerCallbackWriter : public internal::ServerCallbackCall {
+ public:
+  ~ServerCallbackWriter() override {}
+
+  virtual void Finish(grpc::Status s) = 0;
+  virtual void SendInitialMetadata() = 0;
+  virtual void Write(const Response* msg, grpc::WriteOptions options) = 0;
+  virtual void WriteAndFinish(const Response* msg, grpc::WriteOptions options,
+                              grpc::Status s) = 0;
+
+ protected:
+  void BindReactor(ServerWriteReactor<Response>* reactor) {
+    reactor->InternalBindWriter(this);
+  }
+};
+
+template <class Request, class Response>
+class ServerCallbackReaderWriter : public internal::ServerCallbackCall {
+ public:
+  ~ServerCallbackReaderWriter() override {}
+
+  virtual void Finish(grpc::Status s) = 0;
+  virtual void SendInitialMetadata() = 0;
+  virtual void Read(Request* msg) = 0;
+  virtual void Write(const Response* msg, grpc::WriteOptions options) = 0;
+  virtual void WriteAndFinish(const Response* msg, grpc::WriteOptions options,
+                              grpc::Status s) = 0;
+
+ protected:
+  void BindReactor(ServerBidiReactor<Request, Response>* reactor) {
+    reactor->InternalBindStream(this);
+  }
+};
+
+// The following classes are the reactor interfaces that are to be implemented
+// by the user, returned as the output parameter of the method handler for a
+// callback method. Note that none of the classes are pure; all reactions have a
+// default empty reaction so that the user class only needs to override those
+// reactions that it cares about. The reaction methods will be invoked by the
+// library in response to the completion of various operations. Reactions must
+// not include blocking operations (such as blocking I/O, starting synchronous
+// RPCs, or waiting on condition variables). Reactions may be invoked
+// concurrently, except that OnDone is called after all others (assuming proper
+// API usage). The reactor may not be deleted until OnDone is called.
+
+/// \a ServerBidiReactor is the interface for a bidirectional streaming RPC.
+template <class Request, class Response>
+class ServerBidiReactor : public internal::ServerReactor {
+ public:
+  // NOTE: Initializing stream_ as a constructor initializer rather than a
+  //       default initializer because gcc-4.x requires a copy constructor for
+  //       default initializing a templated member, which isn't ok for atomic.
+  // TODO(vjpai): Switch to default constructor and default initializer when
+  //              gcc-4.x is no longer supported
+  ServerBidiReactor() : stream_(nullptr) {}
+  ~ServerBidiReactor() override = default;
+
+  /// Send any initial metadata stored in the RPC context. If not invoked,
+  /// any initial metadata will be passed along with the first Write or the
+  /// Finish (if there are no writes).
+  void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(stream_mu_) {
+    ServerCallbackReaderWriter<Request, Response>* stream =
+        stream_.load(std::memory_order_acquire);
+    if (stream == nullptr) {
+      grpc::internal::MutexLock l(&stream_mu_);
+      stream = stream_.load(std::memory_order_relaxed);
+      if (stream == nullptr) {
+        backlog_.send_initial_metadata_wanted = true;
+        return;
+      }
+    }
+    stream->SendInitialMetadata();
+  }
+
+  /// Initiate a read operation.
+  ///
+  /// \param[out] req Where to eventually store the read message. Valid when
+  ///                 the library calls OnReadDone
+  void StartRead(Request* req) ABSL_LOCKS_EXCLUDED(stream_mu_) {
+    ServerCallbackReaderWriter<Request, Response>* stream =
+        stream_.load(std::memory_order_acquire);
+    if (stream == nullptr) {
+      grpc::internal::MutexLock l(&stream_mu_);
+      stream = stream_.load(std::memory_order_relaxed);
+      if (stream == nullptr) {
+        backlog_.read_wanted = req;
+        return;
+      }
+    }
+    stream->Read(req);
+  }
+
+  /// Initiate a write operation.
+  ///
+  /// \param[in] resp The message to be written. The library does not take
+  ///                 ownership but the caller must ensure that the message is
+  ///                 not deleted or modified until OnWriteDone is called.
+  void StartWrite(const Response* resp) {
+    StartWrite(resp, grpc::WriteOptions());
+  }
+
+  /// Initiate a write operation with specified options.
+  ///
+  /// \param[in] resp The message to be written. The library does not take
+  ///                 ownership but the caller must ensure that the message is
+  ///                 not deleted or modified until OnWriteDone is called.
+  /// \param[in] options The WriteOptions to use for writing this message
+  void StartWrite(const Response* resp, grpc::WriteOptions options)
+      ABSL_LOCKS_EXCLUDED(stream_mu_) {
+    ServerCallbackReaderWriter<Request, Response>* stream =
+        stream_.load(std::memory_order_acquire);
+    if (stream == nullptr) {
+      grpc::internal::MutexLock l(&stream_mu_);
+      stream = stream_.load(std::memory_order_relaxed);
+      if (stream == nullptr) {
+        backlog_.write_wanted = resp;
+        backlog_.write_options_wanted = options;
+        return;
+      }
+    }
+    stream->Write(resp, options);
+  }
+
+  /// Initiate a write operation with specified options and final RPC Status,
+  /// which also causes any trailing metadata for this RPC to be sent out.
+  /// StartWriteAndFinish is like merging StartWriteLast and Finish into a
+  /// single step. A key difference, though, is that this operation doesn't have
+  /// an OnWriteDone reaction - it is considered complete only when OnDone is
+  /// available. An RPC can either have StartWriteAndFinish or Finish, but not
+  /// both.
+  ///
+  /// \param[in] resp The message to be written. The library does not take
+  ///                 ownership but the caller must ensure that the message is
+  ///                 not deleted or modified until OnDone is called.
+  /// \param[in] options The WriteOptions to use for writing this message
+  /// \param[in] s The status outcome of this RPC
+  void StartWriteAndFinish(const Response* resp, grpc::WriteOptions options,
+                           grpc::Status s) ABSL_LOCKS_EXCLUDED(stream_mu_) {
+    ServerCallbackReaderWriter<Request, Response>* stream =
+        stream_.load(std::memory_order_acquire);
+    if (stream == nullptr) {
+      grpc::internal::MutexLock l(&stream_mu_);
+      stream = stream_.load(std::memory_order_relaxed);
+      if (stream == nullptr) {
+        backlog_.write_and_finish_wanted = true;
+        backlog_.write_wanted = resp;
+        backlog_.write_options_wanted = options;
+        backlog_.status_wanted = std::move(s);
+        return;
+      }
+    }
+    stream->WriteAndFinish(resp, options, std::move(s));
+  }
+
+  /// Inform system of a planned write operation with specified options, but
+  /// allow the library to schedule the actual write coalesced with the writing
+  /// of trailing metadata (which takes place on a Finish call).
+  ///
+  /// \param[in] resp The message to be written. The library does not take
+  ///                 ownership but the caller must ensure that the message is
+  ///                 not deleted or modified until OnWriteDone is called.
+  /// \param[in] options The WriteOptions to use for writing this message
+  void StartWriteLast(const Response* resp, grpc::WriteOptions options) {
+    StartWrite(resp, options.set_last_message());
+  }
+
+  /// Indicate that the stream is to be finished and the trailing metadata and
+  /// RPC status are to be sent. Every RPC MUST be finished using either Finish
+  /// or StartWriteAndFinish (but not both), even if the RPC is already
+  /// cancelled.
+  ///
+  /// \param[in] s The status outcome of this RPC
+  void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(stream_mu_) {
+    ServerCallbackReaderWriter<Request, Response>* stream =
+        stream_.load(std::memory_order_acquire);
+    if (stream == nullptr) {
+      grpc::internal::MutexLock l(&stream_mu_);
+      stream = stream_.load(std::memory_order_relaxed);
+      if (stream == nullptr) {
+        backlog_.finish_wanted = true;
+        backlog_.status_wanted = std::move(s);
+        return;
+      }
+    }
+    stream->Finish(std::move(s));
+  }
+
+  /// Notifies the application that an explicit StartSendInitialMetadata
+  /// operation completed. Not used when the sending of initial metadata
+  /// piggybacks onto the first write.
+  ///
+  /// \param[in] ok Was it successful? If false, no further write-side operation
+  ///               will succeed.
+  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
+
+  /// Notifies the application that a StartRead operation completed.
+  ///
+  /// \param[in] ok Was it successful? If false, no further read-side operation
+  ///               will succeed.
+  virtual void OnReadDone(bool /*ok*/) {}
+
+  /// Notifies the application that a StartWrite (or StartWriteLast) operation
+  /// completed.
+  ///
+  /// \param[in] ok Was it successful? If false, no further write-side operation
+  ///               will succeed.
+  virtual void OnWriteDone(bool /*ok*/) {}
+
+  /// Notifies the application that all operations associated with this RPC
+  /// have completed. This is an override (from the internal base class) but
+  /// still abstract, so derived classes MUST override it to be instantiated.
+  void OnDone() override = 0;
+
+  /// Notifies the application that this RPC has been cancelled. This is an
+  /// override (from the internal base class) but not final, so derived classes
+  /// should override it if they want to take action.
+  void OnCancel() override {}
+
+ private:
+  friend class ServerCallbackReaderWriter<Request, Response>;
+  // May be overridden by internal implementation details. This is not a public
+  // customization point.
+  virtual void InternalBindStream(
+      ServerCallbackReaderWriter<Request, Response>* stream) {
+    grpc::internal::MutexLock l(&stream_mu_);
+
+    if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted)) {
+      stream->SendInitialMetadata();
+    }
+    if (GPR_UNLIKELY(backlog_.read_wanted != nullptr)) {
+      stream->Read(backlog_.read_wanted);
+    }
+    if (GPR_UNLIKELY(backlog_.write_and_finish_wanted)) {
+      stream->WriteAndFinish(backlog_.write_wanted,
+                             std::move(backlog_.write_options_wanted),
+                             std::move(backlog_.status_wanted));
+    } else {
+      if (GPR_UNLIKELY(backlog_.write_wanted != nullptr)) {
+        stream->Write(backlog_.write_wanted,
+                      std::move(backlog_.write_options_wanted));
+      }
+      if (GPR_UNLIKELY(backlog_.finish_wanted)) {
+        stream->Finish(std::move(backlog_.status_wanted));
+      }
+    }
+    // Set stream_ last so that other functions can use it lock-free
+    stream_.store(stream, std::memory_order_release);
+  }
+
+  grpc::internal::Mutex stream_mu_;
+  // TODO(vjpai): Make stream_or_backlog_ into a std::variant or absl::variant
+  //              once C++17 or ABSL is supported since stream and backlog are
+  //              mutually exclusive in this class. Do likewise with the
+  //              remaining reactor classes and their backlogs as well.
+  std::atomic<ServerCallbackReaderWriter<Request, Response>*> stream_{nullptr};
+  struct PreBindBacklog {
+    bool send_initial_metadata_wanted = false;
+    bool write_and_finish_wanted = false;
+    bool finish_wanted = false;
+    Request* read_wanted = nullptr;
+    const Response* write_wanted = nullptr;
+    grpc::WriteOptions write_options_wanted;
+    grpc::Status status_wanted;
+  };
+  PreBindBacklog backlog_ ABSL_GUARDED_BY(stream_mu_);
+};
+
+/// \a ServerReadReactor is the interface for a client-streaming RPC.
+template <class Request>
+class ServerReadReactor : public internal::ServerReactor {
+ public:
+  ServerReadReactor() : reader_(nullptr) {}
+  ~ServerReadReactor() override = default;
+
+  /// The following operation initiations are exactly like ServerBidiReactor.
+  void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(reader_mu_) {
+    ServerCallbackReader<Request>* reader =
+        reader_.load(std::memory_order_acquire);
+    if (reader == nullptr) {
+      grpc::internal::MutexLock l(&reader_mu_);
+      reader = reader_.load(std::memory_order_relaxed);
+      if (reader == nullptr) {
+        backlog_.send_initial_metadata_wanted = true;
+        return;
+      }
+    }
+    reader->SendInitialMetadata();
+  }
+  void StartRead(Request* req) ABSL_LOCKS_EXCLUDED(reader_mu_) {
+    ServerCallbackReader<Request>* reader =
+        reader_.load(std::memory_order_acquire);
+    if (reader == nullptr) {
+      grpc::internal::MutexLock l(&reader_mu_);
+      reader = reader_.load(std::memory_order_relaxed);
+      if (reader == nullptr) {
+        backlog_.read_wanted = req;
+        return;
+      }
+    }
+    reader->Read(req);
+  }
+  void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(reader_mu_) {
+    ServerCallbackReader<Request>* reader =
+        reader_.load(std::memory_order_acquire);
+    if (reader == nullptr) {
+      grpc::internal::MutexLock l(&reader_mu_);
+      reader = reader_.load(std::memory_order_relaxed);
+      if (reader == nullptr) {
+        backlog_.finish_wanted = true;
+        backlog_.status_wanted = std::move(s);
+        return;
+      }
+    }
+    reader->Finish(std::move(s));
+  }
+
+  /// The following notifications are exactly like ServerBidiReactor.
+  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
+  virtual void OnReadDone(bool /*ok*/) {}
+  void OnDone() override = 0;
+  void OnCancel() override {}
+
+ private:
+  friend class ServerCallbackReader<Request>;
+
+  // May be overridden by internal implementation details. This is not a public
+  // customization point.
+  virtual void InternalBindReader(ServerCallbackReader<Request>* reader)
+      ABSL_LOCKS_EXCLUDED(reader_mu_) {
+    grpc::internal::MutexLock l(&reader_mu_);
+
+    if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted)) {
+      reader->SendInitialMetadata();
+    }
+    if (GPR_UNLIKELY(backlog_.read_wanted != nullptr)) {
+      reader->Read(backlog_.read_wanted);
+    }
+    if (GPR_UNLIKELY(backlog_.finish_wanted)) {
+      reader->Finish(std::move(backlog_.status_wanted));
+    }
+    // Set reader_ last so that other functions can use it lock-free
+    reader_.store(reader, std::memory_order_release);
+  }
+
+  grpc::internal::Mutex reader_mu_;
+  std::atomic<ServerCallbackReader<Request>*> reader_{nullptr};
+  struct PreBindBacklog {
+    bool send_initial_metadata_wanted = false;
+    bool finish_wanted = false;
+    Request* read_wanted = nullptr;
+    grpc::Status status_wanted;
+  };
+  PreBindBacklog backlog_ ABSL_GUARDED_BY(reader_mu_);
+};
+
+/// \a ServerWriteReactor is the interface for a server-streaming RPC.
+template <class Response>
+class ServerWriteReactor : public internal::ServerReactor {
+ public:
+  ServerWriteReactor() : writer_(nullptr) {}
+  ~ServerWriteReactor() override = default;
+
+  /// The following operation initiations are exactly like ServerBidiReactor.
+  void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(writer_mu_) {
+    ServerCallbackWriter<Response>* writer =
+        writer_.load(std::memory_order_acquire);
+    if (writer == nullptr) {
+      grpc::internal::MutexLock l(&writer_mu_);
+      writer = writer_.load(std::memory_order_relaxed);
+      if (writer == nullptr) {
+        backlog_.send_initial_metadata_wanted = true;
+        return;
+      }
+    }
+    writer->SendInitialMetadata();
+  }
+  void StartWrite(const Response* resp) {
+    StartWrite(resp, grpc::WriteOptions());
+  }
+  void StartWrite(const Response* resp, grpc::WriteOptions options)
+      ABSL_LOCKS_EXCLUDED(writer_mu_) {
+    ServerCallbackWriter<Response>* writer =
+        writer_.load(std::memory_order_acquire);
+    if (writer == nullptr) {
+      grpc::internal::MutexLock l(&writer_mu_);
+      writer = writer_.load(std::memory_order_relaxed);
+      if (writer == nullptr) {
+        backlog_.write_wanted = resp;
+        backlog_.write_options_wanted = options;
+        return;
+      }
+    }
+    writer->Write(resp, options);
+  }
+  void StartWriteAndFinish(const Response* resp, grpc::WriteOptions options,
+                           grpc::Status s) ABSL_LOCKS_EXCLUDED(writer_mu_) {
+    ServerCallbackWriter<Response>* writer =
+        writer_.load(std::memory_order_acquire);
+    if (writer == nullptr) {
+      grpc::internal::MutexLock l(&writer_mu_);
+      writer = writer_.load(std::memory_order_relaxed);
+      if (writer == nullptr) {
+        backlog_.write_and_finish_wanted = true;
+        backlog_.write_wanted = resp;
+        backlog_.write_options_wanted = options;
+        backlog_.status_wanted = std::move(s);
+        return;
+      }
+    }
+    writer->WriteAndFinish(resp, options, std::move(s));
+  }
+  void StartWriteLast(const Response* resp, grpc::WriteOptions options) {
+    StartWrite(resp, options.set_last_message());
+  }
+  void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(writer_mu_) {
+    ServerCallbackWriter<Response>* writer =
+        writer_.load(std::memory_order_acquire);
+    if (writer == nullptr) {
+      grpc::internal::MutexLock l(&writer_mu_);
+      writer = writer_.load(std::memory_order_relaxed);
+      if (writer == nullptr) {
+        backlog_.finish_wanted = true;
+        backlog_.status_wanted = std::move(s);
+        return;
+      }
+    }
+    writer->Finish(std::move(s));
+  }
+
+  /// The following notifications are exactly like ServerBidiReactor.
+  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
+  virtual void OnWriteDone(bool /*ok*/) {}
+  void OnDone() override = 0;
+  void OnCancel() override {}
+
+ private:
+  friend class ServerCallbackWriter<Response>;
+  // May be overridden by internal implementation details. This is not a public
+  // customization point.
+  virtual void InternalBindWriter(ServerCallbackWriter<Response>* writer)
+      ABSL_LOCKS_EXCLUDED(writer_mu_) {
+    grpc::internal::MutexLock l(&writer_mu_);
+
+    if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted)) {
+      writer->SendInitialMetadata();
+    }
+    if (GPR_UNLIKELY(backlog_.write_and_finish_wanted)) {
+      writer->WriteAndFinish(backlog_.write_wanted,
+                             std::move(backlog_.write_options_wanted),
+                             std::move(backlog_.status_wanted));
+    } else {
+      if (GPR_UNLIKELY(backlog_.write_wanted != nullptr)) {
+        writer->Write(backlog_.write_wanted,
+                      std::move(backlog_.write_options_wanted));
+      }
+      if (GPR_UNLIKELY(backlog_.finish_wanted)) {
+        writer->Finish(std::move(backlog_.status_wanted));
+      }
+    }
+    // Set writer_ last so that other functions can use it lock-free
+    writer_.store(writer, std::memory_order_release);
+  }
+
+  grpc::internal::Mutex writer_mu_;
+  std::atomic<ServerCallbackWriter<Response>*> writer_{nullptr};
+  struct PreBindBacklog {
+    bool send_initial_metadata_wanted = false;
+    bool write_and_finish_wanted = false;
+    bool finish_wanted = false;
+    const Response* write_wanted = nullptr;
+    grpc::WriteOptions write_options_wanted;
+    grpc::Status status_wanted;
+  };
+  PreBindBacklog backlog_ ABSL_GUARDED_BY(writer_mu_);
+};
+
+class ServerUnaryReactor : public internal::ServerReactor {
+ public:
+  ServerUnaryReactor() : call_(nullptr) {}
+  ~ServerUnaryReactor() override = default;
+
+  /// StartSendInitialMetadata is exactly like ServerBidiReactor.
+  void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(call_mu_) {
+    ServerCallbackUnary* call = call_.load(std::memory_order_acquire);
+    if (call == nullptr) {
+      grpc::internal::MutexLock l(&call_mu_);
+      call = call_.load(std::memory_order_relaxed);
+      if (call == nullptr) {
+        backlog_.send_initial_metadata_wanted = true;
+        return;
+      }
+    }
+    call->SendInitialMetadata();
+  }
+  /// Finish is similar to ServerBidiReactor except for one detail.
+  /// If the status is non-OK, any message will not be sent. Instead,
+  /// the client will only receive the status and any trailing metadata.
+  void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(call_mu_) {
+    ServerCallbackUnary* call = call_.load(std::memory_order_acquire);
+    if (call == nullptr) {
+      grpc::internal::MutexLock l(&call_mu_);
+      call = call_.load(std::memory_order_relaxed);
+      if (call == nullptr) {
+        backlog_.finish_wanted = true;
+        backlog_.status_wanted = std::move(s);
+        return;
+      }
+    }
+    call->Finish(std::move(s));
+  }
+
+  /// The following notifications are exactly like ServerBidiReactor.
+  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
+  void OnDone() override = 0;
+  void OnCancel() override {}
+
+ private:
+  friend class ServerCallbackUnary;
+  // May be overridden by internal implementation details. This is not a public
+  // customization point.
+  virtual void InternalBindCall(ServerCallbackUnary* call)
+      ABSL_LOCKS_EXCLUDED(call_mu_) {
+    grpc::internal::MutexLock l(&call_mu_);
+
+    if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted)) {
+      call->SendInitialMetadata();
+    }
+    if (GPR_UNLIKELY(backlog_.finish_wanted)) {
+      call->Finish(std::move(backlog_.status_wanted));
+    }
+    // Set call_ last so that other functions can use it lock-free
+    call_.store(call, std::memory_order_release);
+  }
+
+  grpc::internal::Mutex call_mu_;
+  std::atomic<ServerCallbackUnary*> call_{nullptr};
+  struct PreBindBacklog {
+    bool send_initial_metadata_wanted = false;
+    bool finish_wanted = false;
+    grpc::Status status_wanted;
+  };
+  PreBindBacklog backlog_ ABSL_GUARDED_BY(call_mu_);
+};
+
+namespace internal {
+
+template <class Base>
+class FinishOnlyReactor : public Base {
+ public:
+  explicit FinishOnlyReactor(grpc::Status s) { this->Finish(std::move(s)); }
+  void OnDone() override { this->~FinishOnlyReactor(); }
+};
+
+using UnimplementedUnaryReactor = FinishOnlyReactor<ServerUnaryReactor>;
+template <class Request>
+using UnimplementedReadReactor = FinishOnlyReactor<ServerReadReactor<Request>>;
+template <class Response>
+using UnimplementedWriteReactor =
+    FinishOnlyReactor<ServerWriteReactor<Response>>;
+template <class Request, class Response>
+using UnimplementedBidiReactor =
+    FinishOnlyReactor<ServerBidiReactor<Request, Response>>;
+
+}  // namespace internal
+
+// TODO(vjpai): Remove namespace experimental when last known users are migrated
+// off.
+namespace experimental {
+
+template <class Request, class Response>
+using ServerBidiReactor = ::grpc::ServerBidiReactor<Request, Response>;
+
+}  // namespace experimental
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback_handlers.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback_handlers.h
new file mode 100644
index 0000000..eac524f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback_handlers.h
@@ -0,0 +1,889 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_HANDLERS_H
+#define GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_HANDLERS_H
+
+// IWYU pragma: private
+
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+namespace internal {
+
+template <class RequestType, class ResponseType>
+class CallbackUnaryHandler : public grpc::internal::MethodHandler {
+ public:
+  explicit CallbackUnaryHandler(
+      std::function<ServerUnaryReactor*(grpc::CallbackServerContext*,
+                                        const RequestType*, ResponseType*)>
+          get_reactor)
+      : get_reactor_(std::move(get_reactor)) {}
+
+  void SetMessageAllocator(
+      MessageAllocator<RequestType, ResponseType>* allocator) {
+    allocator_ = allocator;
+  }
+
+  void RunHandler(const HandlerParameter& param) final {
+    // Arena allocate a controller structure (that includes request/response)
+    grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
+    auto* allocator_state =
+        static_cast<MessageHolder<RequestType, ResponseType>*>(
+            param.internal_data);
+
+    auto* call = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        param.call->call(), sizeof(ServerCallbackUnaryImpl)))
+        ServerCallbackUnaryImpl(
+            static_cast<grpc::CallbackServerContext*>(param.server_context),
+            param.call, allocator_state, param.call_requester);
+    param.server_context->BeginCompletionOp(
+        param.call, [call](bool) { call->MaybeDone(); }, call);
+
+    ServerUnaryReactor* reactor = nullptr;
+    if (param.status.ok()) {
+      reactor = grpc::internal::CatchingReactorGetter<ServerUnaryReactor>(
+          get_reactor_,
+          static_cast<grpc::CallbackServerContext*>(param.server_context),
+          call->request(), call->response());
+    }
+
+    if (reactor == nullptr) {
+      // if deserialization or reactor creator failed, we need to fail the call
+      reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+          param.call->call(), sizeof(UnimplementedUnaryReactor)))
+          UnimplementedUnaryReactor(
+              grpc::Status(grpc::StatusCode::UNIMPLEMENTED, ""));
+    }
+
+    /// Invoke SetupReactor as the last part of the handler
+    call->SetupReactor(reactor);
+  }
+
+  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
+                    grpc::Status* status, void** handler_data) final {
+    grpc::ByteBuffer buf;
+    buf.set_buffer(req);
+    RequestType* request = nullptr;
+    MessageHolder<RequestType, ResponseType>* allocator_state;
+    if (allocator_ != nullptr) {
+      allocator_state = allocator_->AllocateMessages();
+    } else {
+      allocator_state =
+          new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+              call, sizeof(DefaultMessageHolder<RequestType, ResponseType>)))
+              DefaultMessageHolder<RequestType, ResponseType>();
+    }
+    *handler_data = allocator_state;
+    request = allocator_state->request();
+    *status =
+        grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
+    buf.Release();
+    if (status->ok()) {
+      return request;
+    }
+    return nullptr;
+  }
+
+ private:
+  std::function<ServerUnaryReactor*(grpc::CallbackServerContext*,
+                                    const RequestType*, ResponseType*)>
+      get_reactor_;
+  MessageAllocator<RequestType, ResponseType>* allocator_ = nullptr;
+
+  class ServerCallbackUnaryImpl : public ServerCallbackUnary {
+   public:
+    void Finish(grpc::Status s) override {
+      // A callback that only contains a call to MaybeDone can be run as an
+      // inline callback regardless of whether or not OnDone is inlineable
+      // because if the actual OnDone callback needs to be scheduled, MaybeDone
+      // is responsible for dispatching to an executor thread if needed. Thus,
+      // when setting up the finish_tag_, we can set its own callback to
+      // inlineable.
+      finish_tag_.Set(
+          call_.call(),
+          [this](bool) {
+            this->MaybeDone(
+                reactor_.load(std::memory_order_relaxed)->InternalInlineable());
+          },
+          &finish_ops_, /*can_inline=*/true);
+      finish_ops_.set_core_cq_tag(&finish_tag_);
+
+      if (!ctx_->sent_initial_metadata_) {
+        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                        ctx_->initial_metadata_flags());
+        if (ctx_->compression_level_set()) {
+          finish_ops_.set_compression_level(ctx_->compression_level());
+        }
+        ctx_->sent_initial_metadata_ = true;
+      }
+      // The response is dropped if the status is not OK.
+      if (s.ok()) {
+        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_,
+                                     finish_ops_.SendMessagePtr(response()));
+      } else {
+        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
+      }
+      finish_ops_.set_core_cq_tag(&finish_tag_);
+      call_.PerformOps(&finish_ops_);
+    }
+
+    void SendInitialMetadata() override {
+      GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+      this->Ref();
+      // The callback for this function should not be marked inline because it
+      // is directly invoking a user-controlled reaction
+      // (OnSendInitialMetadataDone). Thus it must be dispatched to an executor
+      // thread. However, any OnDone needed after that can be inlined because it
+      // is already running on an executor thread.
+      meta_tag_.Set(
+          call_.call(),
+          [this](bool ok) {
+            ServerUnaryReactor* reactor =
+                reactor_.load(std::memory_order_relaxed);
+            reactor->OnSendInitialMetadataDone(ok);
+            this->MaybeDone(/*inlineable_ondone=*/true);
+          },
+          &meta_ops_, /*can_inline=*/false);
+      meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                    ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        meta_ops_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+      meta_ops_.set_core_cq_tag(&meta_tag_);
+      call_.PerformOps(&meta_ops_);
+    }
+
+   private:
+    friend class CallbackUnaryHandler<RequestType, ResponseType>;
+
+    ServerCallbackUnaryImpl(
+        grpc::CallbackServerContext* ctx, grpc::internal::Call* call,
+        MessageHolder<RequestType, ResponseType>* allocator_state,
+        std::function<void()> call_requester)
+        : ctx_(ctx),
+          call_(*call),
+          allocator_state_(allocator_state),
+          call_requester_(std::move(call_requester)) {
+      ctx_->set_message_allocator_state(allocator_state);
+    }
+
+    /// SetupReactor binds the reactor (which also releases any queued
+    /// operations), maybe calls OnCancel if possible/needed, and maybe marks
+    /// the completion of the RPC. This should be the last component of the
+    /// handler.
+    void SetupReactor(ServerUnaryReactor* reactor) {
+      reactor_.store(reactor, std::memory_order_relaxed);
+      this->BindReactor(reactor);
+      this->MaybeCallOnCancel(reactor);
+      this->MaybeDone(reactor->InternalInlineable());
+    }
+
+    const RequestType* request() { return allocator_state_->request(); }
+    ResponseType* response() { return allocator_state_->response(); }
+
+    void CallOnDone() override {
+      reactor_.load(std::memory_order_relaxed)->OnDone();
+      grpc_call* call = call_.call();
+      auto call_requester = std::move(call_requester_);
+      allocator_state_->Release();
+      if (ctx_->context_allocator() != nullptr) {
+        ctx_->context_allocator()->Release(ctx_);
+      }
+      this->~ServerCallbackUnaryImpl();  // explicitly call destructor
+      grpc::g_core_codegen_interface->grpc_call_unref(call);
+      call_requester();
+    }
+
+    ServerReactor* reactor() override {
+      return reactor_.load(std::memory_order_relaxed);
+    }
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+        meta_ops_;
+    grpc::internal::CallbackWithSuccessTag meta_tag_;
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage,
+                              grpc::internal::CallOpServerSendStatus>
+        finish_ops_;
+    grpc::internal::CallbackWithSuccessTag finish_tag_;
+
+    grpc::CallbackServerContext* const ctx_;
+    grpc::internal::Call call_;
+    MessageHolder<RequestType, ResponseType>* const allocator_state_;
+    std::function<void()> call_requester_;
+    // reactor_ can always be loaded/stored with relaxed memory ordering because
+    // its value is only set once, independently of other data in the object,
+    // and the loads that use it will always actually come provably later even
+    // though they are from different threads since they are triggered by
+    // actions initiated only by the setting up of the reactor_ variable. In
+    // a sense, it's a delayed "const": it gets its value from the SetupReactor
+    // method (not the constructor, so it's not a true const), but it doesn't
+    // change after that and it only gets used by actions caused, directly or
+    // indirectly, by that setup. This comment also applies to the reactor_
+    // variables of the other streaming objects in this file.
+    std::atomic<ServerUnaryReactor*> reactor_;
+    // callbacks_outstanding_ follows a refcount pattern
+    std::atomic<intptr_t> callbacks_outstanding_{
+        3};  // reserve for start, Finish, and CompletionOp
+  };
+};
+
+template <class RequestType, class ResponseType>
+class CallbackClientStreamingHandler : public grpc::internal::MethodHandler {
+ public:
+  explicit CallbackClientStreamingHandler(
+      std::function<ServerReadReactor<RequestType>*(
+          grpc::CallbackServerContext*, ResponseType*)>
+          get_reactor)
+      : get_reactor_(std::move(get_reactor)) {}
+  void RunHandler(const HandlerParameter& param) final {
+    // Arena allocate a reader structure (that includes response)
+    grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
+
+    auto* reader = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        param.call->call(), sizeof(ServerCallbackReaderImpl)))
+        ServerCallbackReaderImpl(
+            static_cast<grpc::CallbackServerContext*>(param.server_context),
+            param.call, param.call_requester);
+    // Inlineable OnDone can be false in the CompletionOp callback because there
+    // is no read reactor that has an inlineable OnDone; this only applies to
+    // the DefaultReactor (which is unary).
+    param.server_context->BeginCompletionOp(
+        param.call,
+        [reader](bool) { reader->MaybeDone(/*inlineable_ondone=*/false); },
+        reader);
+
+    ServerReadReactor<RequestType>* reactor = nullptr;
+    if (param.status.ok()) {
+      reactor =
+          grpc::internal::CatchingReactorGetter<ServerReadReactor<RequestType>>(
+              get_reactor_,
+              static_cast<grpc::CallbackServerContext*>(param.server_context),
+              reader->response());
+    }
+
+    if (reactor == nullptr) {
+      // if deserialization or reactor creator failed, we need to fail the call
+      reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+          param.call->call(), sizeof(UnimplementedReadReactor<RequestType>)))
+          UnimplementedReadReactor<RequestType>(
+              grpc::Status(grpc::StatusCode::UNIMPLEMENTED, ""));
+    }
+
+    reader->SetupReactor(reactor);
+  }
+
+ private:
+  std::function<ServerReadReactor<RequestType>*(grpc::CallbackServerContext*,
+                                                ResponseType*)>
+      get_reactor_;
+
+  class ServerCallbackReaderImpl : public ServerCallbackReader<RequestType> {
+   public:
+    void Finish(grpc::Status s) override {
+      // A finish tag with only MaybeDone can have its callback inlined
+      // regardless even if OnDone is not inlineable because this callback just
+      // checks a ref and then decides whether or not to dispatch OnDone.
+      finish_tag_.Set(
+          call_.call(),
+          [this](bool) {
+            // Inlineable OnDone can be false here because there is
+            // no read reactor that has an inlineable OnDone; this
+            // only applies to the DefaultReactor (which is unary).
+            this->MaybeDone(/*inlineable_ondone=*/false);
+          },
+          &finish_ops_, /*can_inline=*/true);
+      if (!ctx_->sent_initial_metadata_) {
+        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                        ctx_->initial_metadata_flags());
+        if (ctx_->compression_level_set()) {
+          finish_ops_.set_compression_level(ctx_->compression_level());
+        }
+        ctx_->sent_initial_metadata_ = true;
+      }
+      // The response is dropped if the status is not OK.
+      if (s.ok()) {
+        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_,
+                                     finish_ops_.SendMessagePtr(&resp_));
+      } else {
+        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
+      }
+      finish_ops_.set_core_cq_tag(&finish_tag_);
+      call_.PerformOps(&finish_ops_);
+    }
+
+    void SendInitialMetadata() override {
+      GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+      this->Ref();
+      // The callback for this function should not be inlined because it invokes
+      // a user-controlled reaction, but any resulting OnDone can be inlined in
+      // the executor to which this callback is dispatched.
+      meta_tag_.Set(
+          call_.call(),
+          [this](bool ok) {
+            ServerReadReactor<RequestType>* reactor =
+                reactor_.load(std::memory_order_relaxed);
+            reactor->OnSendInitialMetadataDone(ok);
+            this->MaybeDone(/*inlineable_ondone=*/true);
+          },
+          &meta_ops_, /*can_inline=*/false);
+      meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                    ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        meta_ops_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+      meta_ops_.set_core_cq_tag(&meta_tag_);
+      call_.PerformOps(&meta_ops_);
+    }
+
+    void Read(RequestType* req) override {
+      this->Ref();
+      read_ops_.RecvMessage(req);
+      call_.PerformOps(&read_ops_);
+    }
+
+   private:
+    friend class CallbackClientStreamingHandler<RequestType, ResponseType>;
+
+    ServerCallbackReaderImpl(grpc::CallbackServerContext* ctx,
+                             grpc::internal::Call* call,
+                             std::function<void()> call_requester)
+        : ctx_(ctx), call_(*call), call_requester_(std::move(call_requester)) {}
+
+    void SetupReactor(ServerReadReactor<RequestType>* reactor) {
+      reactor_.store(reactor, std::memory_order_relaxed);
+      // The callback for this function should not be inlined because it invokes
+      // a user-controlled reaction, but any resulting OnDone can be inlined in
+      // the executor to which this callback is dispatched.
+      read_tag_.Set(
+          call_.call(),
+          [this, reactor](bool ok) {
+            if (GPR_UNLIKELY(!ok)) {
+              ctx_->MaybeMarkCancelledOnRead();
+            }
+            reactor->OnReadDone(ok);
+            this->MaybeDone(/*inlineable_ondone=*/true);
+          },
+          &read_ops_, /*can_inline=*/false);
+      read_ops_.set_core_cq_tag(&read_tag_);
+      this->BindReactor(reactor);
+      this->MaybeCallOnCancel(reactor);
+      // Inlineable OnDone can be false here because there is no read
+      // reactor that has an inlineable OnDone; this only applies to the
+      // DefaultReactor (which is unary).
+      this->MaybeDone(/*inlineable_ondone=*/false);
+    }
+
+    ~ServerCallbackReaderImpl() {}
+
+    ResponseType* response() { return &resp_; }
+
+    void CallOnDone() override {
+      reactor_.load(std::memory_order_relaxed)->OnDone();
+      grpc_call* call = call_.call();
+      auto call_requester = std::move(call_requester_);
+      if (ctx_->context_allocator() != nullptr) {
+        ctx_->context_allocator()->Release(ctx_);
+      }
+      this->~ServerCallbackReaderImpl();  // explicitly call destructor
+      grpc::g_core_codegen_interface->grpc_call_unref(call);
+      call_requester();
+    }
+
+    ServerReactor* reactor() override {
+      return reactor_.load(std::memory_order_relaxed);
+    }
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+        meta_ops_;
+    grpc::internal::CallbackWithSuccessTag meta_tag_;
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage,
+                              grpc::internal::CallOpServerSendStatus>
+        finish_ops_;
+    grpc::internal::CallbackWithSuccessTag finish_tag_;
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<RequestType>>
+        read_ops_;
+    grpc::internal::CallbackWithSuccessTag read_tag_;
+
+    grpc::CallbackServerContext* const ctx_;
+    grpc::internal::Call call_;
+    ResponseType resp_;
+    std::function<void()> call_requester_;
+    // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
+    std::atomic<ServerReadReactor<RequestType>*> reactor_;
+    // callbacks_outstanding_ follows a refcount pattern
+    std::atomic<intptr_t> callbacks_outstanding_{
+        3};  // reserve for OnStarted, Finish, and CompletionOp
+  };
+};
+
+template <class RequestType, class ResponseType>
+class CallbackServerStreamingHandler : public grpc::internal::MethodHandler {
+ public:
+  explicit CallbackServerStreamingHandler(
+      std::function<ServerWriteReactor<ResponseType>*(
+          grpc::CallbackServerContext*, const RequestType*)>
+          get_reactor)
+      : get_reactor_(std::move(get_reactor)) {}
+  void RunHandler(const HandlerParameter& param) final {
+    // Arena allocate a writer structure
+    grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
+
+    auto* writer = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        param.call->call(), sizeof(ServerCallbackWriterImpl)))
+        ServerCallbackWriterImpl(
+            static_cast<grpc::CallbackServerContext*>(param.server_context),
+            param.call, static_cast<RequestType*>(param.request),
+            param.call_requester);
+    // Inlineable OnDone can be false in the CompletionOp callback because there
+    // is no write reactor that has an inlineable OnDone; this only applies to
+    // the DefaultReactor (which is unary).
+    param.server_context->BeginCompletionOp(
+        param.call,
+        [writer](bool) { writer->MaybeDone(/*inlineable_ondone=*/false); },
+        writer);
+
+    ServerWriteReactor<ResponseType>* reactor = nullptr;
+    if (param.status.ok()) {
+      reactor = grpc::internal::CatchingReactorGetter<
+          ServerWriteReactor<ResponseType>>(
+          get_reactor_,
+          static_cast<grpc::CallbackServerContext*>(param.server_context),
+          writer->request());
+    }
+    if (reactor == nullptr) {
+      // if deserialization or reactor creator failed, we need to fail the call
+      reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+          param.call->call(), sizeof(UnimplementedWriteReactor<ResponseType>)))
+          UnimplementedWriteReactor<ResponseType>(
+              grpc::Status(grpc::StatusCode::UNIMPLEMENTED, ""));
+    }
+
+    writer->SetupReactor(reactor);
+  }
+
+  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
+                    grpc::Status* status, void** /*handler_data*/) final {
+    grpc::ByteBuffer buf;
+    buf.set_buffer(req);
+    auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        call, sizeof(RequestType))) RequestType();
+    *status =
+        grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
+    buf.Release();
+    if (status->ok()) {
+      return request;
+    }
+    request->~RequestType();
+    return nullptr;
+  }
+
+ private:
+  std::function<ServerWriteReactor<ResponseType>*(grpc::CallbackServerContext*,
+                                                  const RequestType*)>
+      get_reactor_;
+
+  class ServerCallbackWriterImpl : public ServerCallbackWriter<ResponseType> {
+   public:
+    void Finish(grpc::Status s) override {
+      // A finish tag with only MaybeDone can have its callback inlined
+      // regardless even if OnDone is not inlineable because this callback just
+      // checks a ref and then decides whether or not to dispatch OnDone.
+      finish_tag_.Set(
+          call_.call(),
+          [this](bool) {
+            // Inlineable OnDone can be false here because there is
+            // no write reactor that has an inlineable OnDone; this
+            // only applies to the DefaultReactor (which is unary).
+            this->MaybeDone(/*inlineable_ondone=*/false);
+          },
+          &finish_ops_, /*can_inline=*/true);
+      finish_ops_.set_core_cq_tag(&finish_tag_);
+
+      if (!ctx_->sent_initial_metadata_) {
+        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                        ctx_->initial_metadata_flags());
+        if (ctx_->compression_level_set()) {
+          finish_ops_.set_compression_level(ctx_->compression_level());
+        }
+        ctx_->sent_initial_metadata_ = true;
+      }
+      finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
+      call_.PerformOps(&finish_ops_);
+    }
+
+    void SendInitialMetadata() override {
+      GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+      this->Ref();
+      // The callback for this function should not be inlined because it invokes
+      // a user-controlled reaction, but any resulting OnDone can be inlined in
+      // the executor to which this callback is dispatched.
+      meta_tag_.Set(
+          call_.call(),
+          [this](bool ok) {
+            ServerWriteReactor<ResponseType>* reactor =
+                reactor_.load(std::memory_order_relaxed);
+            reactor->OnSendInitialMetadataDone(ok);
+            this->MaybeDone(/*inlineable_ondone=*/true);
+          },
+          &meta_ops_, /*can_inline=*/false);
+      meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                    ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        meta_ops_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+      meta_ops_.set_core_cq_tag(&meta_tag_);
+      call_.PerformOps(&meta_ops_);
+    }
+
+    void Write(const ResponseType* resp, grpc::WriteOptions options) override {
+      this->Ref();
+      if (options.is_last_message()) {
+        options.set_buffer_hint();
+      }
+      if (!ctx_->sent_initial_metadata_) {
+        write_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                       ctx_->initial_metadata_flags());
+        if (ctx_->compression_level_set()) {
+          write_ops_.set_compression_level(ctx_->compression_level());
+        }
+        ctx_->sent_initial_metadata_ = true;
+      }
+      // TODO(vjpai): don't assert
+      GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(resp, options).ok());
+      call_.PerformOps(&write_ops_);
+    }
+
+    void WriteAndFinish(const ResponseType* resp, grpc::WriteOptions options,
+                        grpc::Status s) override {
+      // This combines the write into the finish callback
+      // TODO(vjpai): don't assert
+      GPR_CODEGEN_ASSERT(finish_ops_.SendMessagePtr(resp, options).ok());
+      Finish(std::move(s));
+    }
+
+   private:
+    friend class CallbackServerStreamingHandler<RequestType, ResponseType>;
+
+    ServerCallbackWriterImpl(grpc::CallbackServerContext* ctx,
+                             grpc::internal::Call* call, const RequestType* req,
+                             std::function<void()> call_requester)
+        : ctx_(ctx),
+          call_(*call),
+          req_(req),
+          call_requester_(std::move(call_requester)) {}
+
+    void SetupReactor(ServerWriteReactor<ResponseType>* reactor) {
+      reactor_.store(reactor, std::memory_order_relaxed);
+      // The callback for this function should not be inlined because it invokes
+      // a user-controlled reaction, but any resulting OnDone can be inlined in
+      // the executor to which this callback is dispatched.
+      write_tag_.Set(
+          call_.call(),
+          [this, reactor](bool ok) {
+            reactor->OnWriteDone(ok);
+            this->MaybeDone(/*inlineable_ondone=*/true);
+          },
+          &write_ops_, /*can_inline=*/false);
+      write_ops_.set_core_cq_tag(&write_tag_);
+      this->BindReactor(reactor);
+      this->MaybeCallOnCancel(reactor);
+      // Inlineable OnDone can be false here because there is no write
+      // reactor that has an inlineable OnDone; this only applies to the
+      // DefaultReactor (which is unary).
+      this->MaybeDone(/*inlineable_ondone=*/false);
+    }
+    ~ServerCallbackWriterImpl() {
+      if (req_ != nullptr) {
+        req_->~RequestType();
+      }
+    }
+
+    const RequestType* request() { return req_; }
+
+    void CallOnDone() override {
+      reactor_.load(std::memory_order_relaxed)->OnDone();
+      grpc_call* call = call_.call();
+      auto call_requester = std::move(call_requester_);
+      if (ctx_->context_allocator() != nullptr) {
+        ctx_->context_allocator()->Release(ctx_);
+      }
+      this->~ServerCallbackWriterImpl();  // explicitly call destructor
+      grpc::g_core_codegen_interface->grpc_call_unref(call);
+      call_requester();
+    }
+
+    ServerReactor* reactor() override {
+      return reactor_.load(std::memory_order_relaxed);
+    }
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+        meta_ops_;
+    grpc::internal::CallbackWithSuccessTag meta_tag_;
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage,
+                              grpc::internal::CallOpServerSendStatus>
+        finish_ops_;
+    grpc::internal::CallbackWithSuccessTag finish_tag_;
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage>
+        write_ops_;
+    grpc::internal::CallbackWithSuccessTag write_tag_;
+
+    grpc::CallbackServerContext* const ctx_;
+    grpc::internal::Call call_;
+    const RequestType* req_;
+    std::function<void()> call_requester_;
+    // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
+    std::atomic<ServerWriteReactor<ResponseType>*> reactor_;
+    // callbacks_outstanding_ follows a refcount pattern
+    std::atomic<intptr_t> callbacks_outstanding_{
+        3};  // reserve for OnStarted, Finish, and CompletionOp
+  };
+};
+
+template <class RequestType, class ResponseType>
+class CallbackBidiHandler : public grpc::internal::MethodHandler {
+ public:
+  explicit CallbackBidiHandler(
+      std::function<ServerBidiReactor<RequestType, ResponseType>*(
+          grpc::CallbackServerContext*)>
+          get_reactor)
+      : get_reactor_(std::move(get_reactor)) {}
+  void RunHandler(const HandlerParameter& param) final {
+    grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
+
+    auto* stream = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+        param.call->call(), sizeof(ServerCallbackReaderWriterImpl)))
+        ServerCallbackReaderWriterImpl(
+            static_cast<grpc::CallbackServerContext*>(param.server_context),
+            param.call, param.call_requester);
+    // Inlineable OnDone can be false in the CompletionOp callback because there
+    // is no bidi reactor that has an inlineable OnDone; this only applies to
+    // the DefaultReactor (which is unary).
+    param.server_context->BeginCompletionOp(
+        param.call,
+        [stream](bool) { stream->MaybeDone(/*inlineable_ondone=*/false); },
+        stream);
+
+    ServerBidiReactor<RequestType, ResponseType>* reactor = nullptr;
+    if (param.status.ok()) {
+      reactor = grpc::internal::CatchingReactorGetter<
+          ServerBidiReactor<RequestType, ResponseType>>(
+          get_reactor_,
+          static_cast<grpc::CallbackServerContext*>(param.server_context));
+    }
+
+    if (reactor == nullptr) {
+      // if deserialization or reactor creator failed, we need to fail the call
+      reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+          param.call->call(),
+          sizeof(UnimplementedBidiReactor<RequestType, ResponseType>)))
+          UnimplementedBidiReactor<RequestType, ResponseType>(
+              grpc::Status(grpc::StatusCode::UNIMPLEMENTED, ""));
+    }
+
+    stream->SetupReactor(reactor);
+  }
+
+ private:
+  std::function<ServerBidiReactor<RequestType, ResponseType>*(
+      grpc::CallbackServerContext*)>
+      get_reactor_;
+
+  class ServerCallbackReaderWriterImpl
+      : public ServerCallbackReaderWriter<RequestType, ResponseType> {
+   public:
+    void Finish(grpc::Status s) override {
+      // A finish tag with only MaybeDone can have its callback inlined
+      // regardless even if OnDone is not inlineable because this callback just
+      // checks a ref and then decides whether or not to dispatch OnDone.
+      finish_tag_.Set(
+          call_.call(),
+          [this](bool) {
+            // Inlineable OnDone can be false here because there is
+            // no bidi reactor that has an inlineable OnDone; this
+            // only applies to the DefaultReactor (which is unary).
+            this->MaybeDone(/*inlineable_ondone=*/false);
+          },
+          &finish_ops_, /*can_inline=*/true);
+      finish_ops_.set_core_cq_tag(&finish_tag_);
+
+      if (!ctx_->sent_initial_metadata_) {
+        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                        ctx_->initial_metadata_flags());
+        if (ctx_->compression_level_set()) {
+          finish_ops_.set_compression_level(ctx_->compression_level());
+        }
+        ctx_->sent_initial_metadata_ = true;
+      }
+      finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
+      call_.PerformOps(&finish_ops_);
+    }
+
+    void SendInitialMetadata() override {
+      GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+      this->Ref();
+      // The callback for this function should not be inlined because it invokes
+      // a user-controlled reaction, but any resulting OnDone can be inlined in
+      // the executor to which this callback is dispatched.
+      meta_tag_.Set(
+          call_.call(),
+          [this](bool ok) {
+            ServerBidiReactor<RequestType, ResponseType>* reactor =
+                reactor_.load(std::memory_order_relaxed);
+            reactor->OnSendInitialMetadataDone(ok);
+            this->MaybeDone(/*inlineable_ondone=*/true);
+          },
+          &meta_ops_, /*can_inline=*/false);
+      meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                    ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        meta_ops_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+      meta_ops_.set_core_cq_tag(&meta_tag_);
+      call_.PerformOps(&meta_ops_);
+    }
+
+    void Write(const ResponseType* resp, grpc::WriteOptions options) override {
+      this->Ref();
+      if (options.is_last_message()) {
+        options.set_buffer_hint();
+      }
+      if (!ctx_->sent_initial_metadata_) {
+        write_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                       ctx_->initial_metadata_flags());
+        if (ctx_->compression_level_set()) {
+          write_ops_.set_compression_level(ctx_->compression_level());
+        }
+        ctx_->sent_initial_metadata_ = true;
+      }
+      // TODO(vjpai): don't assert
+      GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(resp, options).ok());
+      call_.PerformOps(&write_ops_);
+    }
+
+    void WriteAndFinish(const ResponseType* resp, grpc::WriteOptions options,
+                        grpc::Status s) override {
+      // TODO(vjpai): don't assert
+      GPR_CODEGEN_ASSERT(finish_ops_.SendMessagePtr(resp, options).ok());
+      Finish(std::move(s));
+    }
+
+    void Read(RequestType* req) override {
+      this->Ref();
+      read_ops_.RecvMessage(req);
+      call_.PerformOps(&read_ops_);
+    }
+
+   private:
+    friend class CallbackBidiHandler<RequestType, ResponseType>;
+
+    ServerCallbackReaderWriterImpl(grpc::CallbackServerContext* ctx,
+                                   grpc::internal::Call* call,
+                                   std::function<void()> call_requester)
+        : ctx_(ctx), call_(*call), call_requester_(std::move(call_requester)) {}
+
+    void SetupReactor(ServerBidiReactor<RequestType, ResponseType>* reactor) {
+      reactor_.store(reactor, std::memory_order_relaxed);
+      // The callbacks for these functions should not be inlined because they
+      // invoke user-controlled reactions, but any resulting OnDones can be
+      // inlined in the executor to which a callback is dispatched.
+      write_tag_.Set(
+          call_.call(),
+          [this, reactor](bool ok) {
+            reactor->OnWriteDone(ok);
+            this->MaybeDone(/*inlineable_ondone=*/true);
+          },
+          &write_ops_, /*can_inline=*/false);
+      write_ops_.set_core_cq_tag(&write_tag_);
+      read_tag_.Set(
+          call_.call(),
+          [this, reactor](bool ok) {
+            if (GPR_UNLIKELY(!ok)) {
+              ctx_->MaybeMarkCancelledOnRead();
+            }
+            reactor->OnReadDone(ok);
+            this->MaybeDone(/*inlineable_ondone=*/true);
+          },
+          &read_ops_, /*can_inline=*/false);
+      read_ops_.set_core_cq_tag(&read_tag_);
+      this->BindReactor(reactor);
+      this->MaybeCallOnCancel(reactor);
+      // Inlineable OnDone can be false here because there is no bidi
+      // reactor that has an inlineable OnDone; this only applies to the
+      // DefaultReactor (which is unary).
+      this->MaybeDone(/*inlineable_ondone=*/false);
+    }
+
+    void CallOnDone() override {
+      reactor_.load(std::memory_order_relaxed)->OnDone();
+      grpc_call* call = call_.call();
+      auto call_requester = std::move(call_requester_);
+      if (ctx_->context_allocator() != nullptr) {
+        ctx_->context_allocator()->Release(ctx_);
+      }
+      this->~ServerCallbackReaderWriterImpl();  // explicitly call destructor
+      grpc::g_core_codegen_interface->grpc_call_unref(call);
+      call_requester();
+    }
+
+    ServerReactor* reactor() override {
+      return reactor_.load(std::memory_order_relaxed);
+    }
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+        meta_ops_;
+    grpc::internal::CallbackWithSuccessTag meta_tag_;
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage,
+                              grpc::internal::CallOpServerSendStatus>
+        finish_ops_;
+    grpc::internal::CallbackWithSuccessTag finish_tag_;
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage>
+        write_ops_;
+    grpc::internal::CallbackWithSuccessTag write_tag_;
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<RequestType>>
+        read_ops_;
+    grpc::internal::CallbackWithSuccessTag read_tag_;
+
+    grpc::CallbackServerContext* const ctx_;
+    grpc::internal::Call call_;
+    std::function<void()> call_requester_;
+    // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
+    std::atomic<ServerBidiReactor<RequestType, ResponseType>*> reactor_;
+    // callbacks_outstanding_ follows a refcount pattern
+    std::atomic<intptr_t> callbacks_outstanding_{
+        3};  // reserve for OnStarted, Finish, and CompletionOp
+  };
+};
+
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_HANDLERS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_context.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_context.h
new file mode 100644
index 0000000..05d8d63
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_context.h
@@ -0,0 +1,679 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_H
+#define GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_H
+
+// IWYU pragma: private, include <grpcpp/server_context.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <atomic>
+#include <cassert>
+#include <map>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include <grpc/impl/codegen/compression_types.h>
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/call_op_set.h>
+#include <grpcpp/impl/codegen/callback_common.h>
+#include <grpcpp/impl/codegen/completion_queue_tag.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/create_auth_context.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/metadata_map.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/security/auth_context.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_interceptor.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/string_ref.h>
+#include <grpcpp/impl/codegen/time.h>
+
+struct grpc_metadata;
+struct grpc_call;
+struct census_context;
+
+namespace grpc {
+template <class W, class R>
+class ServerAsyncReader;
+template <class W>
+class ServerAsyncWriter;
+template <class W>
+class ServerAsyncResponseWriter;
+template <class W, class R>
+class ServerAsyncReaderWriter;
+template <class R>
+class ServerReader;
+template <class W>
+class ServerWriter;
+
+extern CoreCodegenInterface* g_core_codegen_interface;
+
+namespace internal {
+template <class ServiceType, class RequestType, class ResponseType>
+class BidiStreamingHandler;
+template <class RequestType, class ResponseType>
+class CallbackUnaryHandler;
+template <class RequestType, class ResponseType>
+class CallbackClientStreamingHandler;
+template <class RequestType, class ResponseType>
+class CallbackServerStreamingHandler;
+template <class RequestType, class ResponseType>
+class CallbackBidiHandler;
+template <class ServiceType, class RequestType, class ResponseType>
+class ClientStreamingHandler;
+template <class ResponseType>
+void UnaryRunHandlerHelper(const MethodHandler::HandlerParameter&,
+                           ResponseType*, Status&);
+template <class ServiceType, class RequestType, class ResponseType,
+          class BaseRequestType, class BaseResponseType>
+class RpcMethodHandler;
+template <class Base>
+class FinishOnlyReactor;
+template <class W, class R>
+class ServerReaderWriterBody;
+template <class ServiceType, class RequestType, class ResponseType>
+class ServerStreamingHandler;
+class ServerReactor;
+template <class Streamer, bool WriteNeeded>
+class TemplatedBidiStreamingHandler;
+template <grpc::StatusCode code>
+class ErrorMethodHandler;
+}  // namespace internal
+
+class ClientContext;
+class CompletionQueue;
+class GenericServerContext;
+class Server;
+class ServerInterface;
+class ContextAllocator;
+class GenericCallbackServerContext;
+
+namespace internal {
+class Call;
+}  // namespace internal
+
+namespace testing {
+class InteropServerContextInspector;
+class ServerContextTestSpouse;
+class DefaultReactorTestPeer;
+}  // namespace testing
+
+namespace experimental {
+class OrcaServerInterceptor;
+class CallMetricRecorder;
+}  // namespace experimental
+
+/// Base class of ServerContext.
+class ServerContextBase {
+ public:
+  virtual ~ServerContextBase();
+
+  /// Return the deadline for the server call.
+  std::chrono::system_clock::time_point deadline() const {
+    return grpc::Timespec2Timepoint(deadline_);
+  }
+
+  /// Return a \a gpr_timespec representation of the server call's deadline.
+  gpr_timespec raw_deadline() const { return deadline_; }
+
+  /// Add the (\a key, \a value) pair to the initial metadata
+  /// associated with a server call. These are made available at the client side
+  /// by the \a grpc::ClientContext::GetServerInitialMetadata() method.
+  ///
+  /// \warning This method should only be called before sending initial metadata
+  /// to the client (which can happen explicitly, or implicitly when sending a
+  /// a response message or status to the client).
+  ///
+  /// \param key The metadata key. If \a value is binary data, it must
+  /// end in "-bin".
+  /// \param value The metadata value. If its value is binary, the key name
+  /// must end in "-bin".
+  ///
+  /// Metadata must conform to the following format:
+  /**
+  \verbatim
+  Custom-Metadata -> Binary-Header / ASCII-Header
+  Binary-Header -> {Header-Name "-bin" } {binary value}
+  ASCII-Header -> Header-Name ASCII-Value
+  Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
+  ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
+  \endverbatim
+  **/
+  void AddInitialMetadata(const std::string& key, const std::string& value);
+
+  /// Add the (\a key, \a value) pair to the initial metadata
+  /// associated with a server call. These are made available at the client
+  /// side by the \a grpc::ClientContext::GetServerTrailingMetadata() method.
+  ///
+  /// \warning This method should only be called before sending trailing
+  /// metadata to the client (which happens when the call is finished and a
+  /// status is sent to the client).
+  ///
+  /// \param key The metadata key. If \a value is binary data,
+  /// it must end in "-bin".
+  /// \param value The metadata value. If its value is binary, the key name
+  /// must end in "-bin".
+  ///
+  /// Metadata must conform to the following format:
+  /**
+  \verbatim
+  Custom-Metadata -> Binary-Header / ASCII-Header
+  Binary-Header -> {Header-Name "-bin" } {binary value}
+  ASCII-Header -> Header-Name ASCII-Value
+  Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
+  ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
+  \endverbatim
+  **/
+  void AddTrailingMetadata(const std::string& key, const std::string& value);
+
+  /// Return whether this RPC failed before the server could provide its status
+  /// back to the client. This could be because of explicit API cancellation
+  /// from the client-side or server-side, because of deadline exceeded, network
+  /// connection reset, HTTP/2 parameter configuration (e.g., max message size,
+  /// max connection age), etc. It does NOT include failure due to a non-OK
+  /// status return from the server application's request handler, including
+  /// Status::CANCELLED.
+  ///
+  /// IsCancelled is always safe to call when using sync or callback API.
+  /// When using async API, it is only safe to call IsCancelled after
+  /// the AsyncNotifyWhenDone tag has been delivered. Thread-safe.
+  bool IsCancelled() const;
+
+  /// Cancel the Call from the server. This is a best-effort API and
+  /// depending on when it is called, the RPC may still appear successful to
+  /// the client. For example, if TryCancel() is called on a separate thread, it
+  /// might race with the server handler which might return success to the
+  /// client before TryCancel() was even started by the thread.
+  ///
+  /// It is the caller's responsibility to prevent such races and ensure that if
+  /// TryCancel() is called, the serverhandler must return Status::CANCELLED.
+  /// The only exception is that if the serverhandler is already returning an
+  /// error status code, it is ok to not return Status::CANCELLED even if
+  /// TryCancel() was called.
+  ///
+  /// For reasons such as the above, it is generally preferred to explicitly
+  /// finish an RPC by returning Status::CANCELLED rather than using TryCancel.
+  ///
+  /// Note that TryCancel() does not change any of the tags that are pending
+  /// on the completion queue. All pending tags will still be delivered
+  /// (though their ok result may reflect the effect of cancellation).
+  void TryCancel() const;
+
+  /// Return a collection of initial metadata key-value pairs sent from the
+  /// client. Note that keys may happen more than
+  /// once (ie, a \a std::multimap is returned).
+  ///
+  /// It is safe to use this method after initial metadata has been received,
+  /// Calls always begin with the client sending initial metadata, so this is
+  /// safe to access as soon as the call has begun on the server side.
+  ///
+  /// \return A multimap of initial metadata key-value pairs from the server.
+  const std::multimap<grpc::string_ref, grpc::string_ref>& client_metadata()
+      const {
+    return *client_metadata_.map();
+  }
+
+  /// Return the compression algorithm to be used by the server call.
+  grpc_compression_level compression_level() const {
+    return compression_level_;
+  }
+
+  /// Set \a level to be the compression level used for the server call.
+  ///
+  /// \param level The compression level used for the server call.
+  void set_compression_level(grpc_compression_level level) {
+    compression_level_set_ = true;
+    compression_level_ = level;
+  }
+
+  /// Return a bool indicating whether the compression level for this call
+  /// has been set (either implicitly or through a previous call to
+  /// \a set_compression_level.
+  bool compression_level_set() const { return compression_level_set_; }
+
+  /// Return the compression algorithm the server call will request be used.
+  /// Note that the gRPC runtime may decide to ignore this request, for example,
+  /// due to resource constraints, or if the server is aware the client doesn't
+  /// support the requested algorithm.
+  grpc_compression_algorithm compression_algorithm() const {
+    return compression_algorithm_;
+  }
+  /// Set \a algorithm to be the compression algorithm used for the server call.
+  ///
+  /// \param algorithm The compression algorithm used for the server call.
+  void set_compression_algorithm(grpc_compression_algorithm algorithm);
+
+  /// Set the serialized load reporting costs in \a cost_data for the call.
+  void SetLoadReportingCosts(const std::vector<std::string>& cost_data);
+
+  /// Return the authentication context for this server call.
+  ///
+  /// \see grpc::AuthContext.
+  std::shared_ptr<const grpc::AuthContext> auth_context() const {
+    if (auth_context_ == nullptr) {
+      auth_context_ = grpc::CreateAuthContext(call_.call);
+    }
+    return auth_context_;
+  }
+
+  /// Return the peer uri in a string.
+  /// WARNING: this value is never authenticated or subject to any security
+  /// related code. It must not be used for any authentication related
+  /// functionality. Instead, use auth_context.
+  std::string peer() const;
+
+  /// Get the census context associated with this server call.
+  const struct census_context* census_context() const;
+
+  /// Should be used for framework-level extensions only.
+  /// Applications never need to call this method.
+  grpc_call* c_call() { return call_.call; }
+
+  /// Get the \a CallMetricRecorder object for the current RPC.
+  /// Use it to record metrics during your RPC to send back to the
+  /// client in order to make load balancing decisions. This will
+  /// return nullptr if the feature hasn't been enabled using
+  /// \a EnableCallMetricRecording.
+  experimental::CallMetricRecorder* ExperimentalGetCallMetricRecorder() {
+    return call_metric_recorder_;
+  }
+
+  /// EXPERIMENTAL API
+  /// Returns the call's authority.
+  grpc::string_ref ExperimentalGetAuthority() const;
+
+ protected:
+  /// Async only. Has to be called before the rpc starts.
+  /// Returns the tag in completion queue when the rpc finishes.
+  /// IsCancelled() can then be called to check whether the rpc was cancelled.
+  /// TODO(vjpai): Fix this so that the tag is returned even if the call never
+  /// starts (https://github.com/grpc/grpc/issues/10136).
+  void AsyncNotifyWhenDone(void* tag) {
+    has_notify_when_done_tag_ = true;
+    async_notify_when_done_tag_ = tag;
+  }
+
+  /// NOTE: This is an API for advanced users who need custom allocators.
+  /// Get and maybe mutate the allocator state associated with the current RPC.
+  /// Currently only applicable for callback unary RPC methods.
+  RpcAllocatorState* GetRpcAllocatorState() { return message_allocator_state_; }
+
+  /// Get a library-owned default unary reactor for use in minimal reaction
+  /// cases. This supports typical unary RPC usage of providing a response and
+  /// status. It supports immediate Finish (finish from within the method
+  /// handler) or delayed Finish (finish called after the method handler
+  /// invocation). It does not support reacting to cancellation or completion,
+  /// or early sending of initial metadata. Since this is a library-owned
+  /// reactor, it should not be delete'd or freed in any way. This is more
+  /// efficient than creating a user-owned reactor both because of avoiding an
+  /// allocation and because its minimal reactions are optimized using a core
+  /// surface flag that allows their reactions to run inline without any
+  /// thread-hop.
+  ///
+  /// This method should not be called more than once or called after return
+  /// from the method handler.
+  grpc::ServerUnaryReactor* DefaultReactor() {
+    // Short-circuit the case where a default reactor was already set up by
+    // the TestPeer.
+    if (test_unary_ != nullptr) {
+      return reinterpret_cast<Reactor*>(&default_reactor_);
+    }
+    new (&default_reactor_) Reactor;
+#ifndef NDEBUG
+    bool old = false;
+    assert(default_reactor_used_.compare_exchange_strong(
+        old, true, std::memory_order_relaxed));
+#else
+    default_reactor_used_.store(true, std::memory_order_relaxed);
+#endif
+    return reinterpret_cast<Reactor*>(&default_reactor_);
+  }
+
+  /// Constructors for use by derived classes
+  ServerContextBase();
+  ServerContextBase(gpr_timespec deadline, grpc_metadata_array* arr);
+
+  void set_context_allocator(ContextAllocator* context_allocator) {
+    context_allocator_ = context_allocator;
+  }
+
+  ContextAllocator* context_allocator() const { return context_allocator_; }
+
+ private:
+  friend class grpc::testing::InteropServerContextInspector;
+  friend class grpc::testing::ServerContextTestSpouse;
+  friend class grpc::testing::DefaultReactorTestPeer;
+  friend class grpc::ServerInterface;
+  friend class grpc::Server;
+  template <class W, class R>
+  friend class grpc::ServerAsyncReader;
+  template <class W>
+  friend class grpc::ServerAsyncWriter;
+  template <class W>
+  friend class grpc::ServerAsyncResponseWriter;
+  template <class W, class R>
+  friend class grpc::ServerAsyncReaderWriter;
+  template <class R>
+  friend class grpc::ServerReader;
+  template <class W>
+  friend class grpc::ServerWriter;
+  template <class W, class R>
+  friend class grpc::internal::ServerReaderWriterBody;
+  template <class ResponseType>
+  friend void grpc::internal::UnaryRunHandlerHelper(
+      const internal::MethodHandler::HandlerParameter& param, ResponseType* rsp,
+      Status& status);
+  template <class ServiceType, class RequestType, class ResponseType,
+            class BaseRequestType, class BaseResponseType>
+  friend class grpc::internal::RpcMethodHandler;
+  template <class ServiceType, class RequestType, class ResponseType>
+  friend class grpc::internal::ClientStreamingHandler;
+  template <class ServiceType, class RequestType, class ResponseType>
+  friend class grpc::internal::ServerStreamingHandler;
+  template <class Streamer, bool WriteNeeded>
+  friend class grpc::internal::TemplatedBidiStreamingHandler;
+  template <class RequestType, class ResponseType>
+  friend class grpc::internal::CallbackUnaryHandler;
+  template <class RequestType, class ResponseType>
+  friend class grpc::internal::CallbackClientStreamingHandler;
+  template <class RequestType, class ResponseType>
+  friend class grpc::internal::CallbackServerStreamingHandler;
+  template <class RequestType, class ResponseType>
+  friend class grpc::internal::CallbackBidiHandler;
+  template <grpc::StatusCode code>
+  friend class grpc::internal::ErrorMethodHandler;
+  template <class Base>
+  friend class grpc::internal::FinishOnlyReactor;
+  friend class grpc::ClientContext;
+  friend class grpc::GenericServerContext;
+  friend class grpc::GenericCallbackServerContext;
+  friend class grpc::experimental::OrcaServerInterceptor;
+
+  /// Prevent copying.
+  ServerContextBase(const ServerContextBase&);
+  ServerContextBase& operator=(const ServerContextBase&);
+
+  class CompletionOp;
+
+  void BeginCompletionOp(
+      grpc::internal::Call* call, std::function<void(bool)> callback,
+      grpc::internal::ServerCallbackCall* callback_controller);
+  /// Return the tag queued by BeginCompletionOp()
+  grpc::internal::CompletionQueueTag* GetCompletionOpTag();
+
+  void set_call(grpc_call* call) { call_.call = call; }
+
+  void BindDeadlineAndMetadata(gpr_timespec deadline, grpc_metadata_array* arr);
+
+  uint32_t initial_metadata_flags() const { return 0; }
+
+  grpc::experimental::ServerRpcInfo* set_server_rpc_info(
+      const char* method, grpc::internal::RpcMethod::RpcType type,
+      const std::vector<std::unique_ptr<
+          grpc::experimental::ServerInterceptorFactoryInterface>>& creators) {
+    if (!creators.empty()) {
+      rpc_info_ = new grpc::experimental::ServerRpcInfo(this, method, type);
+      rpc_info_->RegisterInterceptors(creators);
+    }
+    return rpc_info_;
+  }
+
+  void set_message_allocator_state(RpcAllocatorState* allocator_state) {
+    message_allocator_state_ = allocator_state;
+  }
+
+  void MaybeMarkCancelledOnRead() {
+    if (g_core_codegen_interface->grpc_call_failed_before_recv_message(
+            call_.call)) {
+      marked_cancelled_.store(true, std::memory_order_release);
+    }
+  }
+
+  void CreateCallMetricRecorder();
+
+  struct CallWrapper {
+    ~CallWrapper();
+
+    grpc_call* call = nullptr;
+  };
+
+  // NOTE: call_ must be the first data member of this object so that its
+  //       destructor is the last to be called, since its destructor may unref
+  //       the underlying core call which holds the arena that may be used to
+  //       hold this object.
+  CallWrapper call_;
+
+  CompletionOp* completion_op_ = nullptr;
+  bool has_notify_when_done_tag_ = false;
+  void* async_notify_when_done_tag_ = nullptr;
+  grpc::internal::CallbackWithSuccessTag completion_tag_;
+
+  gpr_timespec deadline_;
+  grpc::CompletionQueue* cq_ = nullptr;
+  bool sent_initial_metadata_ = false;
+  mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
+  mutable grpc::internal::MetadataMap client_metadata_;
+  std::multimap<std::string, std::string> initial_metadata_;
+  std::multimap<std::string, std::string> trailing_metadata_;
+
+  bool compression_level_set_ = false;
+  grpc_compression_level compression_level_;
+  grpc_compression_algorithm compression_algorithm_;
+
+  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                            grpc::internal::CallOpSendMessage>
+      pending_ops_;
+  bool has_pending_ops_ = false;
+
+  grpc::experimental::ServerRpcInfo* rpc_info_ = nullptr;
+  RpcAllocatorState* message_allocator_state_ = nullptr;
+  ContextAllocator* context_allocator_ = nullptr;
+  experimental::CallMetricRecorder* call_metric_recorder_ = nullptr;
+
+  class Reactor : public grpc::ServerUnaryReactor {
+   public:
+    void OnCancel() override {}
+    void OnDone() override {}
+    // Override InternalInlineable for this class since its reactions are
+    // trivial and thus do not need to be run from the executor (triggering a
+    // thread hop). This should only be used by internal reactors (thus the
+    // name) and not by user application code.
+    bool InternalInlineable() override { return true; }
+  };
+
+  void SetupTestDefaultReactor(std::function<void(grpc::Status)> func) {
+    // NOLINTNEXTLINE(modernize-make-unique)
+    test_unary_.reset(new TestServerCallbackUnary(this, std::move(func)));
+  }
+  bool test_status_set() const {
+    return (test_unary_ != nullptr) && test_unary_->status_set();
+  }
+  grpc::Status test_status() const { return test_unary_->status(); }
+
+  class TestServerCallbackUnary : public grpc::ServerCallbackUnary {
+   public:
+    TestServerCallbackUnary(ServerContextBase* ctx,
+                            std::function<void(grpc::Status)> func)
+        : reactor_(ctx->DefaultReactor()), func_(std::move(func)) {
+      this->BindReactor(reactor_);
+    }
+    void Finish(grpc::Status s) override {
+      status_ = s;
+      func_(std::move(s));
+      status_set_.store(true, std::memory_order_release);
+    }
+    void SendInitialMetadata() override {}
+
+    bool status_set() const {
+      return status_set_.load(std::memory_order_acquire);
+    }
+    grpc::Status status() const { return status_; }
+
+   private:
+    void CallOnDone() override {}
+    grpc::internal::ServerReactor* reactor() override { return reactor_; }
+
+    grpc::ServerUnaryReactor* const reactor_;
+    std::atomic_bool status_set_{false};
+    grpc::Status status_;
+    const std::function<void(grpc::Status s)> func_;
+  };
+
+  typename std::aligned_storage<sizeof(Reactor), alignof(Reactor)>::type
+      default_reactor_;
+  std::atomic_bool default_reactor_used_{false};
+
+  std::atomic_bool marked_cancelled_{false};
+
+  std::unique_ptr<TestServerCallbackUnary> test_unary_;
+};
+
+/// A ServerContext or CallbackServerContext allows the code implementing a
+/// service handler to:
+///
+/// - Add custom initial and trailing metadata key-value pairs that will
+///   propagated to the client side.
+/// - Control call settings such as compression and authentication.
+/// - Access metadata coming from the client.
+/// - Get performance metrics (ie, census).
+///
+/// Context settings are only relevant to the call handler they are supplied to,
+/// that is to say, they aren't sticky across multiple calls. Some of these
+/// settings, such as the compression options, can be made persistent at server
+/// construction time by specifying the appropriate \a ChannelArguments
+/// to a \a grpc::ServerBuilder, via \a ServerBuilder::AddChannelArgument.
+///
+/// \warning ServerContext instances should \em not be reused across rpcs.
+class ServerContext : public ServerContextBase {
+ public:
+  ServerContext() {}  // for async calls
+
+  using ServerContextBase::AddInitialMetadata;
+  using ServerContextBase::AddTrailingMetadata;
+  using ServerContextBase::auth_context;
+  using ServerContextBase::c_call;
+  using ServerContextBase::census_context;
+  using ServerContextBase::client_metadata;
+  using ServerContextBase::compression_algorithm;
+  using ServerContextBase::compression_level;
+  using ServerContextBase::compression_level_set;
+  using ServerContextBase::deadline;
+  using ServerContextBase::IsCancelled;
+  using ServerContextBase::peer;
+  using ServerContextBase::raw_deadline;
+  using ServerContextBase::set_compression_algorithm;
+  using ServerContextBase::set_compression_level;
+  using ServerContextBase::SetLoadReportingCosts;
+  using ServerContextBase::TryCancel;
+
+  // Sync/CQ-based Async ServerContext only
+  using ServerContextBase::AsyncNotifyWhenDone;
+
+ private:
+  // Constructor for internal use by server only
+  friend class grpc::Server;
+  ServerContext(gpr_timespec deadline, grpc_metadata_array* arr)
+      : ServerContextBase(deadline, arr) {}
+
+  // CallbackServerContext only
+  using ServerContextBase::DefaultReactor;
+  using ServerContextBase::GetRpcAllocatorState;
+
+  /// Prevent copying.
+  ServerContext(const ServerContext&) = delete;
+  ServerContext& operator=(const ServerContext&) = delete;
+};
+
+class CallbackServerContext : public ServerContextBase {
+ public:
+  /// Public constructors are for direct use only by mocking tests. In practice,
+  /// these objects will be owned by the library.
+  CallbackServerContext() {}
+
+  using ServerContextBase::AddInitialMetadata;
+  using ServerContextBase::AddTrailingMetadata;
+  using ServerContextBase::auth_context;
+  using ServerContextBase::c_call;
+  using ServerContextBase::census_context;
+  using ServerContextBase::client_metadata;
+  using ServerContextBase::compression_algorithm;
+  using ServerContextBase::compression_level;
+  using ServerContextBase::compression_level_set;
+  using ServerContextBase::context_allocator;
+  using ServerContextBase::deadline;
+  using ServerContextBase::IsCancelled;
+  using ServerContextBase::peer;
+  using ServerContextBase::raw_deadline;
+  using ServerContextBase::set_compression_algorithm;
+  using ServerContextBase::set_compression_level;
+  using ServerContextBase::set_context_allocator;
+  using ServerContextBase::SetLoadReportingCosts;
+  using ServerContextBase::TryCancel;
+
+  // CallbackServerContext only
+  using ServerContextBase::DefaultReactor;
+  using ServerContextBase::GetRpcAllocatorState;
+
+ private:
+  // Sync/CQ-based Async ServerContext only
+  using ServerContextBase::AsyncNotifyWhenDone;
+
+  /// Prevent copying.
+  CallbackServerContext(const CallbackServerContext&) = delete;
+  CallbackServerContext& operator=(const CallbackServerContext&) = delete;
+};
+
+/// A CallbackServerContext allows users to use the contents of the
+/// CallbackServerContext or GenericCallbackServerContext structure for the
+/// callback API.
+/// The library will invoke the allocator any time a new call is initiated.
+/// and call the Release method after the server OnDone.
+class ContextAllocator {
+ public:
+  virtual ~ContextAllocator() {}
+
+  virtual CallbackServerContext* NewCallbackServerContext() { return nullptr; }
+
+  virtual GenericCallbackServerContext* NewGenericCallbackServerContext() {
+    return nullptr;
+  }
+
+  virtual void Release(CallbackServerContext*) {}
+
+  virtual void Release(GenericCallbackServerContext*) {}
+};
+
+}  // namespace grpc
+
+static_assert(
+    std::is_base_of<grpc::ServerContextBase, grpc::ServerContext>::value,
+    "improper base class");
+static_assert(std::is_base_of<grpc::ServerContextBase,
+                              grpc::CallbackServerContext>::value,
+              "improper base class");
+static_assert(sizeof(grpc::ServerContextBase) == sizeof(grpc::ServerContext),
+              "wrong size");
+static_assert(sizeof(grpc::ServerContextBase) ==
+                  sizeof(grpc::CallbackServerContext),
+              "wrong size");
+
+#endif  // GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interceptor.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interceptor.h
new file mode 100644
index 0000000..3a8fd52
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interceptor.h
@@ -0,0 +1,141 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SERVER_INTERCEPTOR_H
+#define GRPCPP_IMPL_CODEGEN_SERVER_INTERCEPTOR_H
+
+// IWYU pragma: private, include <grpcpp/support/server_interceptor.h>
+
+#include <atomic>
+#include <vector>
+
+#include <grpcpp/impl/codegen/interceptor.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/string_ref.h>
+
+namespace grpc {
+class ServerContextBase;
+namespace internal {
+class InterceptorBatchMethodsImpl;
+}
+
+namespace experimental {
+class ServerRpcInfo;
+
+// A factory interface for creation of server interceptors. A vector of
+// factories can be provided to ServerBuilder which will be used to create a new
+// vector of server interceptors per RPC. Server interceptor authors should
+// create a subclass of ServerInterceptorFactorInterface which creates objects
+// of their interceptors.
+class ServerInterceptorFactoryInterface {
+ public:
+  virtual ~ServerInterceptorFactoryInterface() {}
+  // Returns a pointer to an Interceptor object on successful creation, nullptr
+  // otherwise. If nullptr is returned, this server interceptor factory is
+  // ignored for the purposes of that RPC.
+  virtual Interceptor* CreateServerInterceptor(ServerRpcInfo* info) = 0;
+};
+
+/// ServerRpcInfo represents the state of a particular RPC as it
+/// appears to an interceptor. It is created and owned by the library and
+/// passed to the CreateServerInterceptor method of the application's
+/// ServerInterceptorFactoryInterface implementation
+class ServerRpcInfo {
+ public:
+  /// Type categorizes RPCs by unary or streaming type
+  enum class Type { UNARY, CLIENT_STREAMING, SERVER_STREAMING, BIDI_STREAMING };
+
+  ~ServerRpcInfo() {}
+
+  // Delete all copy and move constructors and assignments
+  ServerRpcInfo(const ServerRpcInfo&) = delete;
+  ServerRpcInfo& operator=(const ServerRpcInfo&) = delete;
+  ServerRpcInfo(ServerRpcInfo&&) = delete;
+  ServerRpcInfo& operator=(ServerRpcInfo&&) = delete;
+
+  // Getter methods
+
+  /// Return the fully-specified method name
+  const char* method() const { return method_; }
+
+  /// Return the type of the RPC (unary or a streaming flavor)
+  Type type() const { return type_; }
+
+  /// Return a pointer to the underlying ServerContext structure associated
+  /// with the RPC to support features that apply to it
+  ServerContextBase* server_context() { return ctx_; }
+
+ private:
+  static_assert(Type::UNARY ==
+                    static_cast<Type>(internal::RpcMethod::NORMAL_RPC),
+                "violated expectation about Type enum");
+  static_assert(Type::CLIENT_STREAMING ==
+                    static_cast<Type>(internal::RpcMethod::CLIENT_STREAMING),
+                "violated expectation about Type enum");
+  static_assert(Type::SERVER_STREAMING ==
+                    static_cast<Type>(internal::RpcMethod::SERVER_STREAMING),
+                "violated expectation about Type enum");
+  static_assert(Type::BIDI_STREAMING ==
+                    static_cast<Type>(internal::RpcMethod::BIDI_STREAMING),
+                "violated expectation about Type enum");
+
+  ServerRpcInfo(ServerContextBase* ctx, const char* method,
+                internal::RpcMethod::RpcType type)
+      : ctx_(ctx), method_(method), type_(static_cast<Type>(type)) {}
+
+  // Runs interceptor at pos \a pos.
+  void RunInterceptor(
+      experimental::InterceptorBatchMethods* interceptor_methods, size_t pos) {
+    GPR_CODEGEN_ASSERT(pos < interceptors_.size());
+    interceptors_[pos]->Intercept(interceptor_methods);
+  }
+
+  void RegisterInterceptors(
+      const std::vector<
+          std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>&
+          creators) {
+    for (const auto& creator : creators) {
+      auto* interceptor = creator->CreateServerInterceptor(this);
+      if (interceptor != nullptr) {
+        interceptors_.push_back(
+            std::unique_ptr<experimental::Interceptor>(interceptor));
+      }
+    }
+  }
+
+  void Ref() { ref_.fetch_add(1, std::memory_order_relaxed); }
+  void Unref() {
+    if (GPR_UNLIKELY(ref_.fetch_sub(1, std::memory_order_acq_rel) == 1)) {
+      delete this;
+    }
+  }
+
+  ServerContextBase* ctx_ = nullptr;
+  const char* method_ = nullptr;
+  const Type type_;
+  std::atomic<intptr_t> ref_{1};
+  std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_;
+
+  friend class internal::InterceptorBatchMethodsImpl;
+  friend class grpc::ServerContextBase;
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SERVER_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interface.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interface.h
new file mode 100644
index 0000000..0deac82
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interface.h
@@ -0,0 +1,370 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SERVER_INTERFACE_H
+#define GRPCPP_IMPL_CODEGEN_SERVER_INTERFACE_H
+
+// IWYU pragma: private
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/call_hook.h>
+#include <grpcpp/impl/codegen/completion_queue_tag.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/interceptor_common.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_context.h>
+
+namespace grpc {
+
+class AsyncGenericService;
+class Channel;
+class CompletionQueue;
+class GenericServerContext;
+class ServerCompletionQueue;
+class ServerCredentials;
+class Service;
+
+extern CoreCodegenInterface* g_core_codegen_interface;
+
+/// Models a gRPC server.
+///
+/// Servers are configured and started via \a grpc::ServerBuilder.
+namespace internal {
+class ServerAsyncStreamingInterface;
+}  // namespace internal
+
+class CallbackGenericService;
+
+namespace experimental {
+class ServerInterceptorFactoryInterface;
+}  // namespace experimental
+
+class ServerInterface : public internal::CallHook {
+ public:
+  ~ServerInterface() override {}
+
+  /// \a Shutdown does the following things:
+  ///
+  /// 1. Shutdown the server: deactivate all listening ports, mark it in
+  ///    "shutdown mode" so that further call Request's or incoming RPC matches
+  ///    are no longer allowed. Also return all Request'ed-but-not-yet-active
+  ///    calls as failed (!ok). This refers to calls that have been requested
+  ///    at the server by the server-side library or application code but that
+  ///    have not yet been matched to incoming RPCs from the client. Note that
+  ///    this would even include default calls added automatically by the gRPC
+  ///    C++ API without the user's input (e.g., "Unimplemented RPC method")
+  ///
+  /// 2. Block until all rpc method handlers invoked automatically by the sync
+  ///    API finish.
+  ///
+  /// 3. If all pending calls complete (and all their operations are
+  ///    retrieved by Next) before \a deadline expires, this finishes
+  ///    gracefully. Otherwise, forcefully cancel all pending calls associated
+  ///    with the server after \a deadline expires. In the case of the sync API,
+  ///    if the RPC function for a streaming call has already been started and
+  ///    takes a week to complete, the RPC function won't be forcefully
+  ///    terminated (since that would leave state corrupt and incomplete) and
+  ///    the method handler will just keep running (which will prevent the
+  ///    server from completing the "join" operation that it needs to do at
+  ///    shutdown time).
+  ///
+  /// All completion queue associated with the server (for example, for async
+  /// serving) must be shutdown *after* this method has returned:
+  /// See \a ServerBuilder::AddCompletionQueue for details.
+  /// They must also be drained (by repeated Next) after being shutdown.
+  ///
+  /// \param deadline How long to wait until pending rpcs are forcefully
+  /// terminated.
+  template <class T>
+  void Shutdown(const T& deadline) {
+    ShutdownInternal(TimePoint<T>(deadline).raw_time());
+  }
+
+  /// Shutdown the server without a deadline and forced cancellation.
+  ///
+  /// All completion queue associated with the server (for example, for async
+  /// serving) must be shutdown *after* this method has returned:
+  /// See \a ServerBuilder::AddCompletionQueue for details.
+  void Shutdown() {
+    ShutdownInternal(
+        g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_MONOTONIC));
+  }
+
+  /// Block waiting for all work to complete.
+  ///
+  /// \warning The server must be either shutting down or some other thread must
+  /// call \a Shutdown for this function to ever return.
+  virtual void Wait() = 0;
+
+ protected:
+  friend class grpc::Service;
+
+  /// Register a service. This call does not take ownership of the service.
+  /// The service must exist for the lifetime of the Server instance.
+  virtual bool RegisterService(const std::string* host, Service* service) = 0;
+
+  /// Register a generic service. This call does not take ownership of the
+  /// service. The service must exist for the lifetime of the Server instance.
+  virtual void RegisterAsyncGenericService(AsyncGenericService* service) = 0;
+
+  /// Register a callback generic service. This call does not take ownership of
+  /// the  service. The service must exist for the lifetime of the Server
+  /// instance. May not be abstract since this is a post-1.0 API addition.
+
+  virtual void RegisterCallbackGenericService(CallbackGenericService*
+                                              /*service*/) {}
+
+  /// Tries to bind \a server to the given \a addr.
+  ///
+  /// It can be invoked multiple times.
+  ///
+  /// \param addr The address to try to bind to the server (eg, localhost:1234,
+  /// 192.168.1.1:31416, [::1]:27182, etc.).
+  /// \params creds The credentials associated with the server.
+  ///
+  /// \return bound port number on success, 0 on failure.
+  ///
+  /// \warning It's an error to call this method on an already started server.
+  virtual int AddListeningPort(const std::string& addr,
+                               ServerCredentials* creds) = 0;
+
+  /// Start the server.
+  ///
+  /// \param cqs Completion queues for handling asynchronous services. The
+  /// caller is required to keep all completion queues live until the server is
+  /// destroyed.
+  /// \param num_cqs How many completion queues does \a cqs hold.
+  virtual void Start(grpc::ServerCompletionQueue** cqs, size_t num_cqs) = 0;
+
+  virtual void ShutdownInternal(gpr_timespec deadline) = 0;
+
+  virtual int max_receive_message_size() const = 0;
+
+  virtual grpc_server* server() = 0;
+
+  void PerformOpsOnCall(internal::CallOpSetInterface* ops,
+                        internal::Call* call) override = 0;
+
+  class BaseAsyncRequest : public internal::CompletionQueueTag {
+   public:
+    BaseAsyncRequest(ServerInterface* server, grpc::ServerContext* context,
+                     internal::ServerAsyncStreamingInterface* stream,
+                     grpc::CompletionQueue* call_cq,
+                     grpc::ServerCompletionQueue* notification_cq, void* tag,
+                     bool delete_on_finalize);
+    ~BaseAsyncRequest() override;
+
+    bool FinalizeResult(void** tag, bool* status) override;
+
+   private:
+    void ContinueFinalizeResultAfterInterception();
+
+   protected:
+    ServerInterface* const server_;
+    grpc::ServerContext* const context_;
+    internal::ServerAsyncStreamingInterface* const stream_;
+    grpc::CompletionQueue* const call_cq_;
+    grpc::ServerCompletionQueue* const notification_cq_;
+    void* const tag_;
+    const bool delete_on_finalize_;
+    grpc_call* call_;
+    internal::Call call_wrapper_;
+    internal::InterceptorBatchMethodsImpl interceptor_methods_;
+    bool done_intercepting_;
+  };
+
+  /// RegisteredAsyncRequest is not part of the C++ API
+  class RegisteredAsyncRequest : public BaseAsyncRequest {
+   public:
+    RegisteredAsyncRequest(ServerInterface* server,
+                           grpc::ServerContext* context,
+                           internal::ServerAsyncStreamingInterface* stream,
+                           grpc::CompletionQueue* call_cq,
+                           grpc::ServerCompletionQueue* notification_cq,
+                           void* tag, const char* name,
+                           internal::RpcMethod::RpcType type);
+
+    bool FinalizeResult(void** tag, bool* status) override {
+      /* If we are done intercepting, then there is nothing more for us to do */
+      if (done_intercepting_) {
+        return BaseAsyncRequest::FinalizeResult(tag, status);
+      }
+      call_wrapper_ = grpc::internal::Call(
+          call_, server_, call_cq_, server_->max_receive_message_size(),
+          context_->set_server_rpc_info(name_, type_,
+                                        *server_->interceptor_creators()));
+      return BaseAsyncRequest::FinalizeResult(tag, status);
+    }
+
+   protected:
+    void IssueRequest(void* registered_method, grpc_byte_buffer** payload,
+                      grpc::ServerCompletionQueue* notification_cq);
+    const char* name_;
+    const internal::RpcMethod::RpcType type_;
+  };
+
+  class NoPayloadAsyncRequest final : public RegisteredAsyncRequest {
+   public:
+    NoPayloadAsyncRequest(internal::RpcServiceMethod* registered_method,
+                          ServerInterface* server, grpc::ServerContext* context,
+                          internal::ServerAsyncStreamingInterface* stream,
+                          grpc::CompletionQueue* call_cq,
+                          grpc::ServerCompletionQueue* notification_cq,
+                          void* tag)
+        : RegisteredAsyncRequest(
+              server, context, stream, call_cq, notification_cq, tag,
+              registered_method->name(), registered_method->method_type()) {
+      IssueRequest(registered_method->server_tag(), nullptr, notification_cq);
+    }
+
+    // uses RegisteredAsyncRequest::FinalizeResult
+  };
+
+  template <class Message>
+  class PayloadAsyncRequest final : public RegisteredAsyncRequest {
+   public:
+    PayloadAsyncRequest(internal::RpcServiceMethod* registered_method,
+                        ServerInterface* server, grpc::ServerContext* context,
+                        internal::ServerAsyncStreamingInterface* stream,
+                        grpc::CompletionQueue* call_cq,
+                        grpc::ServerCompletionQueue* notification_cq, void* tag,
+                        Message* request)
+        : RegisteredAsyncRequest(
+              server, context, stream, call_cq, notification_cq, tag,
+              registered_method->name(), registered_method->method_type()),
+          registered_method_(registered_method),
+          request_(request) {
+      IssueRequest(registered_method->server_tag(), payload_.bbuf_ptr(),
+                   notification_cq);
+    }
+
+    ~PayloadAsyncRequest() override {
+      payload_.Release();  // We do not own the payload_
+    }
+
+    bool FinalizeResult(void** tag, bool* status) override {
+      /* If we are done intercepting, then there is nothing more for us to do */
+      if (done_intercepting_) {
+        return RegisteredAsyncRequest::FinalizeResult(tag, status);
+      }
+      if (*status) {
+        if (!payload_.Valid() || !SerializationTraits<Message>::Deserialize(
+                                      payload_.bbuf_ptr(), request_)
+                                      .ok()) {
+          // If deserialization fails, we cancel the call and instantiate
+          // a new instance of ourselves to request another call.  We then
+          // return false, which prevents the call from being returned to
+          // the application.
+          g_core_codegen_interface->grpc_call_cancel_with_status(
+              call_, GRPC_STATUS_INTERNAL, "Unable to parse request", nullptr);
+          g_core_codegen_interface->grpc_call_unref(call_);
+          new PayloadAsyncRequest(registered_method_, server_, context_,
+                                  stream_, call_cq_, notification_cq_, tag_,
+                                  request_);
+          delete this;
+          return false;
+        }
+      }
+      /* Set interception point for recv message */
+      interceptor_methods_.AddInterceptionHookPoint(
+          experimental::InterceptionHookPoints::POST_RECV_MESSAGE);
+      interceptor_methods_.SetRecvMessage(request_, nullptr);
+      return RegisteredAsyncRequest::FinalizeResult(tag, status);
+    }
+
+   private:
+    internal::RpcServiceMethod* const registered_method_;
+    Message* const request_;
+    ByteBuffer payload_;
+  };
+
+  class GenericAsyncRequest : public BaseAsyncRequest {
+   public:
+    GenericAsyncRequest(ServerInterface* server, GenericServerContext* context,
+                        internal::ServerAsyncStreamingInterface* stream,
+                        grpc::CompletionQueue* call_cq,
+                        grpc::ServerCompletionQueue* notification_cq, void* tag,
+                        bool delete_on_finalize);
+
+    bool FinalizeResult(void** tag, bool* status) override;
+
+   private:
+    grpc_call_details call_details_;
+  };
+
+  template <class Message>
+  void RequestAsyncCall(internal::RpcServiceMethod* method,
+                        grpc::ServerContext* context,
+                        internal::ServerAsyncStreamingInterface* stream,
+                        grpc::CompletionQueue* call_cq,
+                        grpc::ServerCompletionQueue* notification_cq, void* tag,
+                        Message* message) {
+    GPR_CODEGEN_ASSERT(method);
+    new PayloadAsyncRequest<Message>(method, this, context, stream, call_cq,
+                                     notification_cq, tag, message);
+  }
+
+  void RequestAsyncCall(internal::RpcServiceMethod* method,
+                        grpc::ServerContext* context,
+                        internal::ServerAsyncStreamingInterface* stream,
+                        grpc::CompletionQueue* call_cq,
+                        grpc::ServerCompletionQueue* notification_cq,
+                        void* tag) {
+    GPR_CODEGEN_ASSERT(method);
+    new NoPayloadAsyncRequest(method, this, context, stream, call_cq,
+                              notification_cq, tag);
+  }
+
+  void RequestAsyncGenericCall(GenericServerContext* context,
+                               internal::ServerAsyncStreamingInterface* stream,
+                               grpc::CompletionQueue* call_cq,
+                               grpc::ServerCompletionQueue* notification_cq,
+                               void* tag) {
+    new GenericAsyncRequest(this, context, stream, call_cq, notification_cq,
+                            tag, true);
+  }
+
+ private:
+  // EXPERIMENTAL
+  // Getter method for the vector of interceptor factory objects.
+  // Returns a nullptr (rather than being pure) since this is a post-1.0 method
+  // and adding a new pure method to an interface would be a breaking change
+  // (even though this is private and non-API)
+  virtual std::vector<
+      std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>*
+  interceptor_creators() {
+    return nullptr;
+  }
+
+  // A method to get the callbackable completion queue associated with this
+  // server. If the return value is nullptr, this server doesn't support
+  // callback operations.
+  // TODO(vjpai): Consider a better default like using a global CQ
+  // Returns nullptr (rather than being pure) since this is a post-1.0 method
+  // and adding a new pure method to an interface would be a breaking change
+  // (even though this is private and non-API)
+  virtual grpc::CompletionQueue* CallbackCQ() { return nullptr; }
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SERVER_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/service_type.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/service_type.h
new file mode 100644
index 0000000..88bcb4a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/service_type.h
@@ -0,0 +1,238 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SERVICE_TYPE_H
+#define GRPCPP_IMPL_CODEGEN_SERVICE_TYPE_H
+
+// IWYU pragma: private, include <grpcpp/impl/service_type.h>
+
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/serialization_traits.h>
+#include <grpcpp/impl/codegen/server_interface.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+
+class CompletionQueue;
+class ServerContext;
+class ServerInterface;
+
+namespace internal {
+class Call;
+class ServerAsyncStreamingInterface {
+ public:
+  virtual ~ServerAsyncStreamingInterface() {}
+
+  /// Request notification of the sending of initial metadata to the client.
+  /// Completion will be notified by \a tag on the associated completion
+  /// queue. This call is optional, but if it is used, it cannot be used
+  /// concurrently with or after the \a Finish method.
+  ///
+  /// \param[in] tag Tag identifying this request.
+  virtual void SendInitialMetadata(void* tag) = 0;
+
+ private:
+  friend class grpc::ServerInterface;
+  virtual void BindCall(Call* call) = 0;
+};
+}  // namespace internal
+
+/// Desriptor of an RPC service and its various RPC methods
+class Service {
+ public:
+  Service() : server_(nullptr) {}
+  virtual ~Service() {}
+
+  bool has_async_methods() const {
+    for (const auto& method : methods_) {
+      if (method && method->handler() == nullptr) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool has_synchronous_methods() const {
+    for (const auto& method : methods_) {
+      if (method &&
+          method->api_type() == internal::RpcServiceMethod::ApiType::SYNC) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool has_callback_methods() const {
+    for (const auto& method : methods_) {
+      if (method && (method->api_type() ==
+                         internal::RpcServiceMethod::ApiType::CALL_BACK ||
+                     method->api_type() ==
+                         internal::RpcServiceMethod::ApiType::RAW_CALL_BACK)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool has_generic_methods() const {
+    for (const auto& method : methods_) {
+      if (method == nullptr) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+ protected:
+  template <class Message>
+  void RequestAsyncUnary(int index, grpc::ServerContext* context,
+                         Message* request,
+                         internal::ServerAsyncStreamingInterface* stream,
+                         grpc::CompletionQueue* call_cq,
+                         grpc::ServerCompletionQueue* notification_cq,
+                         void* tag) {
+    // Typecast the index to size_t for indexing into a vector
+    // while preserving the API that existed before a compiler
+    // warning was first seen (grpc/grpc#11664)
+    size_t idx = static_cast<size_t>(index);
+    server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq,
+                              notification_cq, tag, request);
+  }
+  void RequestAsyncClientStreaming(
+      int index, grpc::ServerContext* context,
+      internal::ServerAsyncStreamingInterface* stream,
+      grpc::CompletionQueue* call_cq,
+      grpc::ServerCompletionQueue* notification_cq, void* tag) {
+    size_t idx = static_cast<size_t>(index);
+    server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq,
+                              notification_cq, tag);
+  }
+  template <class Message>
+  void RequestAsyncServerStreaming(
+      int index, grpc::ServerContext* context, Message* request,
+      internal::ServerAsyncStreamingInterface* stream,
+      grpc::CompletionQueue* call_cq,
+      grpc::ServerCompletionQueue* notification_cq, void* tag) {
+    size_t idx = static_cast<size_t>(index);
+    server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq,
+                              notification_cq, tag, request);
+  }
+  void RequestAsyncBidiStreaming(
+      int index, grpc::ServerContext* context,
+      internal::ServerAsyncStreamingInterface* stream,
+      grpc::CompletionQueue* call_cq,
+      grpc::ServerCompletionQueue* notification_cq, void* tag) {
+    size_t idx = static_cast<size_t>(index);
+    server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq,
+                              notification_cq, tag);
+  }
+
+  void AddMethod(internal::RpcServiceMethod* method) {
+    methods_.emplace_back(method);
+  }
+
+  void MarkMethodAsync(int index) {
+    // This does not have to be a hard error, however no one has approached us
+    // with a use case yet. Please file an issue if you believe you have one.
+    size_t idx = static_cast<size_t>(index);
+    GPR_CODEGEN_ASSERT(
+        methods_[idx].get() != nullptr &&
+        "Cannot mark the method as 'async' because it has already been "
+        "marked as 'generic'.");
+    methods_[idx]->SetServerApiType(internal::RpcServiceMethod::ApiType::ASYNC);
+  }
+
+  void MarkMethodRaw(int index) {
+    // This does not have to be a hard error, however no one has approached us
+    // with a use case yet. Please file an issue if you believe you have one.
+    size_t idx = static_cast<size_t>(index);
+    GPR_CODEGEN_ASSERT(methods_[idx].get() != nullptr &&
+                       "Cannot mark the method as 'raw' because it has already "
+                       "been marked as 'generic'.");
+    methods_[idx]->SetServerApiType(internal::RpcServiceMethod::ApiType::RAW);
+  }
+
+  void MarkMethodGeneric(int index) {
+    // This does not have to be a hard error, however no one has approached us
+    // with a use case yet. Please file an issue if you believe you have one.
+    size_t idx = static_cast<size_t>(index);
+    GPR_CODEGEN_ASSERT(
+        methods_[idx]->handler() != nullptr &&
+        "Cannot mark the method as 'generic' because it has already been "
+        "marked as 'async' or 'raw'.");
+    methods_[idx].reset();
+  }
+
+  void MarkMethodStreamed(int index, internal::MethodHandler* streamed_method) {
+    // This does not have to be a hard error, however no one has approached us
+    // with a use case yet. Please file an issue if you believe you have one.
+    size_t idx = static_cast<size_t>(index);
+    GPR_CODEGEN_ASSERT(methods_[idx] && methods_[idx]->handler() &&
+                       "Cannot mark an async or generic method Streamed");
+    methods_[idx]->SetHandler(streamed_method);
+
+    // From the server's point of view, streamed unary is a special
+    // case of BIDI_STREAMING that has 1 read and 1 write, in that order,
+    // and split server-side streaming is BIDI_STREAMING with 1 read and
+    // any number of writes, in that order.
+    methods_[idx]->SetMethodType(internal::RpcMethod::BIDI_STREAMING);
+  }
+
+  void MarkMethodCallback(int index, internal::MethodHandler* handler) {
+    // This does not have to be a hard error, however no one has approached us
+    // with a use case yet. Please file an issue if you believe you have one.
+    size_t idx = static_cast<size_t>(index);
+    GPR_CODEGEN_ASSERT(
+        methods_[idx].get() != nullptr &&
+        "Cannot mark the method as 'callback' because it has already been "
+        "marked as 'generic'.");
+    methods_[idx]->SetHandler(handler);
+    methods_[idx]->SetServerApiType(
+        internal::RpcServiceMethod::ApiType::CALL_BACK);
+  }
+
+  void MarkMethodRawCallback(int index, internal::MethodHandler* handler) {
+    // This does not have to be a hard error, however no one has approached us
+    // with a use case yet. Please file an issue if you believe you have one.
+    size_t idx = static_cast<size_t>(index);
+    GPR_CODEGEN_ASSERT(
+        methods_[idx].get() != nullptr &&
+        "Cannot mark the method as 'raw callback' because it has already "
+        "been marked as 'generic'.");
+    methods_[idx]->SetHandler(handler);
+    methods_[idx]->SetServerApiType(
+        internal::RpcServiceMethod::ApiType::RAW_CALL_BACK);
+  }
+
+  internal::MethodHandler* GetHandler(int index) {
+    size_t idx = static_cast<size_t>(index);
+    return methods_[idx]->handler();
+  }
+
+ private:
+  friend class Server;
+  friend class ServerInterface;
+  ServerInterface* server_;
+  std::vector<std::unique_ptr<internal::RpcServiceMethod>> methods_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SERVICE_TYPE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/slice.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/slice.h
new file mode 100644
index 0000000..392986a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/slice.h
@@ -0,0 +1,156 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SLICE_H
+#define GRPCPP_IMPL_CODEGEN_SLICE_H
+
+// IWYU pragma: private, include <grpcpp/support/slice.h>
+
+#include <grpc/impl/codegen/slice.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/string_ref.h>
+
+namespace grpc {
+
+/// A wrapper around \a grpc_slice.
+///
+/// A slice represents a contiguous reference counted array of bytes.
+/// It is cheap to take references to a slice, and it is cheap to create a
+/// slice pointing to a subset of another slice.
+class Slice final {
+ public:
+  /// Construct an empty slice.
+  Slice() : slice_(g_core_codegen_interface->grpc_empty_slice()) {}
+  /// Destructor - drops one reference.
+  ~Slice() { g_core_codegen_interface->grpc_slice_unref(slice_); }
+
+  enum AddRef { ADD_REF };
+  /// Construct a slice from \a slice, adding a reference.
+  Slice(grpc_slice slice, AddRef)
+      : slice_(g_core_codegen_interface->grpc_slice_ref(slice)) {}
+
+  enum StealRef { STEAL_REF };
+  /// Construct a slice from \a slice, stealing a reference.
+  Slice(grpc_slice slice, StealRef) : slice_(slice) {}
+
+  /// Allocate a slice of specified size
+  explicit Slice(size_t len)
+      : slice_(g_core_codegen_interface->grpc_slice_malloc(len)) {}
+
+  /// Construct a slice from a copied buffer
+  Slice(const void* buf, size_t len)
+      : slice_(g_core_codegen_interface->grpc_slice_from_copied_buffer(
+            reinterpret_cast<const char*>(buf), len)) {}
+
+  /// Construct a slice from a copied string
+  /* NOLINTNEXTLINE(google-explicit-constructor) */
+  Slice(const std::string& str)
+      : slice_(g_core_codegen_interface->grpc_slice_from_copied_buffer(
+            str.c_str(), str.length())) {}
+
+  enum StaticSlice { STATIC_SLICE };
+
+  /// Construct a slice from a static buffer
+  Slice(const void* buf, size_t len, StaticSlice)
+      : slice_(g_core_codegen_interface->grpc_slice_from_static_buffer(
+            reinterpret_cast<const char*>(buf), len)) {}
+
+  /// Copy constructor, adds a reference.
+  Slice(const Slice& other)
+      : slice_(g_core_codegen_interface->grpc_slice_ref(other.slice_)) {}
+
+  /// Move constructor, steals a reference.
+  Slice(Slice&& other) noexcept : slice_(other.slice_) {
+    other.slice_ = g_core_codegen_interface->grpc_empty_slice();
+  }
+
+  /// Assignment, reference count is unchanged.
+  Slice& operator=(Slice other) {
+    std::swap(slice_, other.slice_);
+    return *this;
+  }
+
+  /// Create a slice pointing at some data. Calls malloc to allocate a refcount
+  /// for the object, and arranges that destroy will be called with the
+  /// user data pointer passed in at destruction. Can be the same as buf or
+  /// different (e.g., if data is part of a larger structure that must be
+  /// destroyed when the data is no longer needed)
+  Slice(void* buf, size_t len, void (*destroy)(void*), void* user_data)
+      : slice_(g_core_codegen_interface->grpc_slice_new_with_user_data(
+            buf, len, destroy, user_data)) {}
+
+  /// Specialization of above for common case where buf == user_data
+  Slice(void* buf, size_t len, void (*destroy)(void*))
+      : Slice(buf, len, destroy, buf) {}
+
+  /// Similar to the above but has a destroy that also takes slice length
+  Slice(void* buf, size_t len, void (*destroy)(void*, size_t))
+      : slice_(g_core_codegen_interface->grpc_slice_new_with_len(buf, len,
+                                                                 destroy)) {}
+
+  /// Byte size.
+  size_t size() const { return GRPC_SLICE_LENGTH(slice_); }
+
+  /// Raw pointer to the beginning (first element) of the slice.
+  const uint8_t* begin() const { return GRPC_SLICE_START_PTR(slice_); }
+
+  /// Raw pointer to the end (one byte \em past the last element) of the slice.
+  const uint8_t* end() const { return GRPC_SLICE_END_PTR(slice_); }
+
+  /// Returns a substring of the `slice` as another slice.
+  Slice sub(size_t begin, size_t end) const {
+    return Slice(g_core_codegen_interface->grpc_slice_sub(slice_, begin, end),
+                 STEAL_REF);
+  }
+
+  /// Raw C slice. Caller needs to call grpc_slice_unref when done.
+  grpc_slice c_slice() const {
+    return g_core_codegen_interface->grpc_slice_ref(slice_);
+  }
+
+ private:
+  friend class ByteBuffer;
+
+  grpc_slice slice_;
+};
+
+inline grpc::string_ref StringRefFromSlice(const grpc_slice* slice) {
+  return grpc::string_ref(
+      reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(*slice)),
+      GRPC_SLICE_LENGTH(*slice));
+}
+
+inline std::string StringFromCopiedSlice(grpc_slice slice) {
+  return std::string(reinterpret_cast<char*>(GRPC_SLICE_START_PTR(slice)),
+                     GRPC_SLICE_LENGTH(slice));
+}
+
+inline grpc_slice SliceReferencingString(const std::string& str) {
+  return g_core_codegen_interface->grpc_slice_from_static_buffer(str.data(),
+                                                                 str.length());
+}
+
+inline grpc_slice SliceFromCopiedString(const std::string& str) {
+  return g_core_codegen_interface->grpc_slice_from_copied_buffer(str.data(),
+                                                                 str.length());
+}
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SLICE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status.h
new file mode 100644
index 0000000..cc8d3cd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status.h
@@ -0,0 +1,141 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_STATUS_H
+#define GRPCPP_IMPL_CODEGEN_STATUS_H
+
+// IWYU pragma: private, include <grpcpp/support/status.h>
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpc/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/status_code_enum.h>
+
+namespace grpc {
+
+/// Did it work? If it didn't, why?
+///
+/// See \a grpc::StatusCode for details on the available code and their meaning.
+class GRPC_MUST_USE_RESULT_WHEN_USE_STRICT_WARNING Status {
+ public:
+  /// Construct an OK instance.
+  Status() : code_(StatusCode::OK) {
+    // Static assertions to make sure that the C++ API value correctly
+    // maps to the core surface API value
+    static_assert(StatusCode::OK == static_cast<StatusCode>(GRPC_STATUS_OK),
+                  "Mismatched status code");
+    static_assert(
+        StatusCode::CANCELLED == static_cast<StatusCode>(GRPC_STATUS_CANCELLED),
+        "Mismatched status code");
+    static_assert(
+        StatusCode::UNKNOWN == static_cast<StatusCode>(GRPC_STATUS_UNKNOWN),
+        "Mismatched status code");
+    static_assert(StatusCode::INVALID_ARGUMENT ==
+                      static_cast<StatusCode>(GRPC_STATUS_INVALID_ARGUMENT),
+                  "Mismatched status code");
+    static_assert(StatusCode::DEADLINE_EXCEEDED ==
+                      static_cast<StatusCode>(GRPC_STATUS_DEADLINE_EXCEEDED),
+                  "Mismatched status code");
+    static_assert(
+        StatusCode::NOT_FOUND == static_cast<StatusCode>(GRPC_STATUS_NOT_FOUND),
+        "Mismatched status code");
+    static_assert(StatusCode::ALREADY_EXISTS ==
+                      static_cast<StatusCode>(GRPC_STATUS_ALREADY_EXISTS),
+                  "Mismatched status code");
+    static_assert(StatusCode::PERMISSION_DENIED ==
+                      static_cast<StatusCode>(GRPC_STATUS_PERMISSION_DENIED),
+                  "Mismatched status code");
+    static_assert(StatusCode::UNAUTHENTICATED ==
+                      static_cast<StatusCode>(GRPC_STATUS_UNAUTHENTICATED),
+                  "Mismatched status code");
+    static_assert(StatusCode::RESOURCE_EXHAUSTED ==
+                      static_cast<StatusCode>(GRPC_STATUS_RESOURCE_EXHAUSTED),
+                  "Mismatched status code");
+    static_assert(StatusCode::FAILED_PRECONDITION ==
+                      static_cast<StatusCode>(GRPC_STATUS_FAILED_PRECONDITION),
+                  "Mismatched status code");
+    static_assert(
+        StatusCode::ABORTED == static_cast<StatusCode>(GRPC_STATUS_ABORTED),
+        "Mismatched status code");
+    static_assert(StatusCode::OUT_OF_RANGE ==
+                      static_cast<StatusCode>(GRPC_STATUS_OUT_OF_RANGE),
+                  "Mismatched status code");
+    static_assert(StatusCode::UNIMPLEMENTED ==
+                      static_cast<StatusCode>(GRPC_STATUS_UNIMPLEMENTED),
+                  "Mismatched status code");
+    static_assert(
+        StatusCode::INTERNAL == static_cast<StatusCode>(GRPC_STATUS_INTERNAL),
+        "Mismatched status code");
+    static_assert(StatusCode::UNAVAILABLE ==
+                      static_cast<StatusCode>(GRPC_STATUS_UNAVAILABLE),
+                  "Mismatched status code");
+    static_assert(
+        StatusCode::DATA_LOSS == static_cast<StatusCode>(GRPC_STATUS_DATA_LOSS),
+        "Mismatched status code");
+  }
+
+  /// Construct an instance with associated \a code and \a error_message.
+  /// It is an error to construct an OK status with non-empty \a error_message.
+  /// Note that \a message is intentionally accepted as a const reference
+  /// instead of a value (which results in a copy instead of a move) to allow
+  /// for easy transition to absl::Status in the future which accepts an
+  /// absl::string_view as a parameter.
+  Status(StatusCode code, const std::string& error_message)
+      : code_(code), error_message_(error_message) {}
+
+  /// Construct an instance with \a code,  \a error_message and
+  /// \a error_details. It is an error to construct an OK status with non-empty
+  /// \a error_message and/or \a error_details.
+  Status(StatusCode code, const std::string& error_message,
+         const std::string& error_details)
+      : code_(code),
+        error_message_(error_message),
+        binary_error_details_(error_details) {}
+
+  // Pre-defined special status objects.
+  /// An OK pre-defined instance.
+  static const Status& OK;
+  /// A CANCELLED pre-defined instance.
+  static const Status& CANCELLED;
+
+  /// Return the instance's error code.
+  StatusCode error_code() const { return code_; }
+  /// Return the instance's error message.
+  std::string error_message() const { return error_message_; }
+  /// Return the (binary) error details.
+  // Usually it contains a serialized google.rpc.Status proto.
+  std::string error_details() const { return binary_error_details_; }
+
+  /// Is the status OK?
+  bool ok() const { return code_ == StatusCode::OK; }
+
+  // Ignores any errors. This method does nothing except potentially suppress
+  // complaints from any tools that are checking that errors are not dropped on
+  // the floor.
+  void IgnoreError() const {}
+
+ private:
+  StatusCode code_;
+  std::string error_message_;
+  std::string binary_error_details_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_STATUS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status_code_enum.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status_code_enum.h
new file mode 100644
index 0000000..6950eab
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status_code_enum.h
@@ -0,0 +1,145 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_STATUS_CODE_ENUM_H
+#define GRPCPP_IMPL_CODEGEN_STATUS_CODE_ENUM_H
+
+// IWYU pragma: private, include <grpcpp/support/status.h>
+
+namespace grpc {
+
+enum StatusCode {
+  /// Not an error; returned on success.
+  OK = 0,
+
+  /// The operation was cancelled (typically by the caller).
+  CANCELLED = 1,
+
+  /// Unknown error. An example of where this error may be returned is if a
+  /// Status value received from another address space belongs to an error-space
+  /// that is not known in this address space. Also errors raised by APIs that
+  /// do not return enough error information may be converted to this error.
+  UNKNOWN = 2,
+
+  /// Client specified an invalid argument. Note that this differs from
+  /// FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments that are
+  /// problematic regardless of the state of the system (e.g., a malformed file
+  /// name).
+  INVALID_ARGUMENT = 3,
+
+  /// Deadline expired before operation could complete. For operations that
+  /// change the state of the system, this error may be returned even if the
+  /// operation has completed successfully. For example, a successful response
+  /// from a server could have been delayed long enough for the deadline to
+  /// expire.
+  DEADLINE_EXCEEDED = 4,
+
+  /// Some requested entity (e.g., file or directory) was not found.
+  NOT_FOUND = 5,
+
+  /// Some entity that we attempted to create (e.g., file or directory) already
+  /// exists.
+  ALREADY_EXISTS = 6,
+
+  /// The caller does not have permission to execute the specified operation.
+  /// PERMISSION_DENIED must not be used for rejections caused by exhausting
+  /// some resource (use RESOURCE_EXHAUSTED instead for those errors).
+  /// PERMISSION_DENIED must not be used if the caller can not be identified
+  /// (use UNAUTHENTICATED instead for those errors).
+  PERMISSION_DENIED = 7,
+
+  /// The request does not have valid authentication credentials for the
+  /// operation.
+  UNAUTHENTICATED = 16,
+
+  /// Some resource has been exhausted, perhaps a per-user quota, or perhaps the
+  /// entire file system is out of space.
+  RESOURCE_EXHAUSTED = 8,
+
+  /// Operation was rejected because the system is not in a state required for
+  /// the operation's execution. For example, directory to be deleted may be
+  /// non-empty, an rmdir operation is applied to a non-directory, etc.
+  ///
+  /// A litmus test that may help a service implementor in deciding
+  /// between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
+  ///  (a) Use UNAVAILABLE if the client can retry just the failing call.
+  ///  (b) Use ABORTED if the client should retry at a higher-level
+  ///      (e.g., restarting a read-modify-write sequence).
+  ///  (c) Use FAILED_PRECONDITION if the client should not retry until
+  ///      the system state has been explicitly fixed. E.g., if an "rmdir"
+  ///      fails because the directory is non-empty, FAILED_PRECONDITION
+  ///      should be returned since the client should not retry unless
+  ///      they have first fixed up the directory by deleting files from it.
+  ///  (d) Use FAILED_PRECONDITION if the client performs conditional
+  ///      REST Get/Update/Delete on a resource and the resource on the
+  ///      server does not match the condition. E.g., conflicting
+  ///      read-modify-write on the same resource.
+  FAILED_PRECONDITION = 9,
+
+  /// The operation was aborted, typically due to a concurrency issue like
+  /// sequencer check failures, transaction aborts, etc.
+  ///
+  /// See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,
+  /// and UNAVAILABLE.
+  ABORTED = 10,
+
+  /// Operation was attempted past the valid range. E.g., seeking or reading
+  /// past end of file.
+  ///
+  /// Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed
+  /// if the system state changes. For example, a 32-bit file system will
+  /// generate INVALID_ARGUMENT if asked to read at an offset that is not in the
+  /// range [0,2^32-1], but it will generate OUT_OF_RANGE if asked to read from
+  /// an offset past the current file size.
+  ///
+  /// There is a fair bit of overlap between FAILED_PRECONDITION and
+  /// OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific error)
+  /// when it applies so that callers who are iterating through a space can
+  /// easily look for an OUT_OF_RANGE error to detect when they are done.
+  OUT_OF_RANGE = 11,
+
+  /// Operation is not implemented or not supported/enabled in this service.
+  UNIMPLEMENTED = 12,
+
+  /// Internal errors. Means some invariants expected by underlying System has
+  /// been broken. If you see one of these errors, Something is very broken.
+  INTERNAL = 13,
+
+  /// The service is currently unavailable. This is a most likely a transient
+  /// condition and may be corrected by retrying with a backoff. Note that it is
+  /// not always safe to retry non-idempotent operations.
+  ///
+  /// \warning Although data MIGHT not have been transmitted when this
+  /// status occurs, there is NOT A GUARANTEE that the server has not seen
+  /// anything. So in general it is unsafe to retry on this status code
+  /// if the call is non-idempotent.
+  ///
+  /// See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,
+  /// and UNAVAILABLE.
+  UNAVAILABLE = 14,
+
+  /// Unrecoverable data loss or corruption.
+  DATA_LOSS = 15,
+
+  /// Force users to include a default branch:
+  DO_NOT_USE = -1
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_STATUS_CODE_ENUM_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/string_ref.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/string_ref.h
new file mode 100644
index 0000000..f71778b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/string_ref.h
@@ -0,0 +1,151 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_STRING_REF_H
+#define GRPCPP_IMPL_CODEGEN_STRING_REF_H
+
+// IWYU pragma: private, include <grpcpp/support/string_ref.h>
+
+#include <string.h>
+
+#include <algorithm>
+#include <iosfwd>
+#include <iostream>
+#include <iterator>
+
+#include <grpcpp/impl/codegen/config.h>
+
+namespace grpc {
+
+/// This class is a non owning reference to a string.
+///
+/// It should be a strict subset of the upcoming std::string_ref.
+///
+/// \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
+///
+/// The constexpr is dropped or replaced with const for legacy compiler
+/// compatibility.
+class string_ref {
+ public:
+  /// types
+  typedef const char* const_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+  /// constants
+  const static size_t npos;
+
+  /// construct/copy.
+  string_ref() : data_(nullptr), length_(0) {}
+  string_ref(const string_ref& other)
+      : data_(other.data_), length_(other.length_) {}
+  // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
+  string_ref& operator=(const string_ref& rhs) {
+    data_ = rhs.data_;
+    length_ = rhs.length_;
+    return *this;
+  }
+
+  /* NOLINTNEXTLINE(google-explicit-constructor) */
+  string_ref(const char* s) : data_(s), length_(strlen(s)) {}
+  string_ref(const char* s, size_t l) : data_(s), length_(l) {}
+  /* NOLINTNEXTLINE(google-explicit-constructor) */
+  string_ref(const std::string& s) : data_(s.data()), length_(s.length()) {}
+
+  /// iterators
+  const_iterator begin() const { return data_; }
+  const_iterator end() const { return data_ + length_; }
+  const_iterator cbegin() const { return data_; }
+  const_iterator cend() const { return data_ + length_; }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+  const_reverse_iterator crbegin() const {
+    return const_reverse_iterator(end());
+  }
+  const_reverse_iterator crend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  /// capacity
+  size_t size() const { return length_; }
+  size_t length() const { return length_; }
+  size_t max_size() const { return length_; }
+  bool empty() const { return length_ == 0; }
+
+  /// element access
+  const char* data() const { return data_; }
+
+  /// string operations
+  int compare(string_ref x) const {
+    size_t min_size = length_ < x.length_ ? length_ : x.length_;
+    int r = memcmp(data_, x.data_, min_size);
+    if (r < 0) return -1;
+    if (r > 0) return 1;
+    if (length_ < x.length_) return -1;
+    if (length_ > x.length_) return 1;
+    return 0;
+  }
+
+  bool starts_with(string_ref x) const {
+    return length_ >= x.length_ && (memcmp(data_, x.data_, x.length_) == 0);
+  }
+
+  bool ends_with(string_ref x) const {
+    return length_ >= x.length_ &&
+           (memcmp(data_ + (length_ - x.length_), x.data_, x.length_) == 0);
+  }
+
+  size_t find(string_ref s) const {
+    auto it = std::search(cbegin(), cend(), s.cbegin(), s.cend());
+    return it == cend() ? npos : std::distance(cbegin(), it);
+  }
+
+  size_t find(char c) const {
+    auto it = std::find(cbegin(), cend(), c);
+    return it == cend() ? npos : std::distance(cbegin(), it);
+  }
+
+  string_ref substr(size_t pos, size_t n = npos) const {
+    if (pos > length_) pos = length_;
+    if (n > (length_ - pos)) n = length_ - pos;
+    return string_ref(data_ + pos, n);
+  }
+
+ private:
+  const char* data_;
+  size_t length_;
+};
+
+/// Comparison operators
+inline bool operator==(string_ref x, string_ref y) { return x.compare(y) == 0; }
+inline bool operator!=(string_ref x, string_ref y) { return x.compare(y) != 0; }
+inline bool operator<(string_ref x, string_ref y) { return x.compare(y) < 0; }
+inline bool operator<=(string_ref x, string_ref y) { return x.compare(y) <= 0; }
+inline bool operator>(string_ref x, string_ref y) { return x.compare(y) > 0; }
+inline bool operator>=(string_ref x, string_ref y) { return x.compare(y) >= 0; }
+
+inline std::ostream& operator<<(std::ostream& out, const string_ref& string) {
+  return out << std::string(string.begin(), string.end());
+}
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_STRING_REF_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/stub_options.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/stub_options.h
new file mode 100644
index 0000000..efa1e38
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/stub_options.h
@@ -0,0 +1,44 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_STUB_OPTIONS_H
+#define GRPCPP_IMPL_CODEGEN_STUB_OPTIONS_H
+
+// IWYU pragma: private, include <grpcpp/support/stub_options.h>
+
+namespace grpc {
+
+/// Useful interface for generated stubs
+class StubOptions {
+ public:
+  StubOptions() = default;
+  explicit StubOptions(const char* suffix_for_stats)
+      : suffix_for_stats_(suffix_for_stats) {}
+
+  void set_suffix_for_stats(const char* suffix_for_stats) {
+    suffix_for_stats_ = suffix_for_stats;
+  }
+  const char* suffix_for_stats() const { return suffix_for_stats_; }
+
+ private:
+  const char* suffix_for_stats_ = nullptr;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_STUB_OPTIONS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync.h
new file mode 100644
index 0000000..4cb8133
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync.h
@@ -0,0 +1,158 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SYNC_H
+#define GRPCPP_IMPL_CODEGEN_SYNC_H
+
+// IWYU pragma: private
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#ifdef GPR_HAS_PTHREAD_H
+#include <pthread.h>
+#endif
+
+#include <mutex>
+
+#include "absl/synchronization/mutex.h"
+
+#include <grpc/impl/codegen/log.h>
+#include <grpc/impl/codegen/sync.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+
+// The core library is not accessible in C++ codegen headers, and vice versa.
+// Thus, we need to have duplicate headers with similar functionality.
+// Make sure any change to this file is also reflected in
+// src/core/lib/gprpp/sync.h too.
+//
+// Whenever possible, prefer "src/core/lib/gprpp/sync.h" over this file,
+// since in core we do not rely on g_core_codegen_interface and hence do not
+// pay the costs of virtual function calls.
+
+namespace grpc {
+namespace internal {
+
+#ifdef GPR_ABSEIL_SYNC
+
+using Mutex = absl::Mutex;
+using MutexLock = absl::MutexLock;
+using ReleasableMutexLock = absl::ReleasableMutexLock;
+using CondVar = absl::CondVar;
+
+#else
+
+class ABSL_LOCKABLE Mutex {
+ public:
+  Mutex() { g_core_codegen_interface->gpr_mu_init(&mu_); }
+  ~Mutex() { g_core_codegen_interface->gpr_mu_destroy(&mu_); }
+
+  Mutex(const Mutex&) = delete;
+  Mutex& operator=(const Mutex&) = delete;
+
+  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    g_core_codegen_interface->gpr_mu_lock(&mu_);
+  }
+  void Unlock() ABSL_UNLOCK_FUNCTION() {
+    g_core_codegen_interface->gpr_mu_unlock(&mu_);
+  }
+
+ private:
+  union {
+    gpr_mu mu_;
+    std::mutex do_not_use_sth_;
+#ifdef GPR_HAS_PTHREAD_H
+    pthread_mutex_t do_not_use_pth_;
+#endif
+  };
+
+  friend class CondVar;
+};
+
+class ABSL_SCOPED_LOCKABLE MutexLock {
+ public:
+  explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+    mu_->Lock();
+  }
+  ~MutexLock() ABSL_UNLOCK_FUNCTION() { mu_->Unlock(); }
+
+  MutexLock(const MutexLock&) = delete;
+  MutexLock& operator=(const MutexLock&) = delete;
+
+ private:
+  Mutex* const mu_;
+};
+
+class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
+ public:
+  explicit ReleasableMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      : mu_(mu) {
+    mu_->Lock();
+  }
+  ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+    if (!released_) mu_->Unlock();
+  }
+
+  ReleasableMutexLock(const ReleasableMutexLock&) = delete;
+  ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
+
+  void Release() ABSL_UNLOCK_FUNCTION() {
+    GPR_DEBUG_ASSERT(!released_);
+    released_ = true;
+    mu_->Unlock();
+  }
+
+ private:
+  Mutex* const mu_;
+  bool released_ = false;
+};
+
+class CondVar {
+ public:
+  CondVar() { g_core_codegen_interface->gpr_cv_init(&cv_); }
+  ~CondVar() { g_core_codegen_interface->gpr_cv_destroy(&cv_); }
+
+  CondVar(const CondVar&) = delete;
+  CondVar& operator=(const CondVar&) = delete;
+
+  void Signal() { g_core_codegen_interface->gpr_cv_signal(&cv_); }
+  void SignalAll() { g_core_codegen_interface->gpr_cv_broadcast(&cv_); }
+
+  void Wait(Mutex* mu) {
+    g_core_codegen_interface->gpr_cv_wait(
+        &cv_, &mu->mu_,
+        g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME));
+  }
+
+ private:
+  gpr_cv cv_;
+};
+
+#endif  // GPR_ABSEIL_SYNC
+
+template <typename Predicate>
+GRPC_DEPRECATED("incompatible with thread safety analysis")
+static void WaitUntil(CondVar* cv, Mutex* mu, Predicate pred) {
+  while (!pred()) {
+    cv->Wait(mu);
+  }
+}
+
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SYNC_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync_stream.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync_stream.h
new file mode 100644
index 0000000..aca6079
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync_stream.h
@@ -0,0 +1,950 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_SYNC_STREAM_H
+#define GRPCPP_IMPL_CODEGEN_SYNC_STREAM_H
+
+// IWYU pragma: private, include <grpcpp/support/sync_stream.h>
+
+#include <grpcpp/impl/codegen/call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/core_codegen_interface.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+
+namespace grpc {
+
+namespace internal {
+/// Common interface for all synchronous client side streaming.
+class ClientStreamingInterface {
+ public:
+  virtual ~ClientStreamingInterface() {}
+
+  /// Block waiting until the stream finishes and a final status of the call is
+  /// available.
+  ///
+  /// It is appropriate to call this method exactly once when both:
+  ///   * the calling code (client-side) has no more message to send
+  ///     (this can be declared implicitly by calling this method, or
+  ///     explicitly through an earlier call to <i>WritesDone</i> method of the
+  ///     class in use, e.g. \a ClientWriterInterface::WritesDone or
+  ///     \a ClientReaderWriterInterface::WritesDone).
+  ///   * there are no more messages to be received from the server (which can
+  ///     be known implicitly, or explicitly from an earlier call to \a
+  ///     ReaderInterface::Read that returned "false").
+  ///
+  /// This function will return either:
+  /// - when all incoming messages have been read and the server has
+  ///   returned status.
+  /// - when the server has returned a non-OK status.
+  /// - OR when the call failed for some reason and the library generated a
+  ///   status.
+  ///
+  /// Return values:
+  ///   - \a Status contains the status code, message and details for the call
+  ///   - the \a ClientContext associated with this call is updated with
+  ///     possible trailing metadata sent from the server.
+  virtual grpc::Status Finish() = 0;
+};
+
+/// Common interface for all synchronous server side streaming.
+class ServerStreamingInterface {
+ public:
+  virtual ~ServerStreamingInterface() {}
+
+  /// Block to send initial metadata to client.
+  /// This call is optional, but if it is used, it cannot be used concurrently
+  /// with or after the \a Finish method.
+  ///
+  /// The initial metadata that will be sent to the client will be
+  /// taken from the \a ServerContext associated with the call.
+  virtual void SendInitialMetadata() = 0;
+};
+
+/// An interface that yields a sequence of messages of type \a R.
+template <class R>
+class ReaderInterface {
+ public:
+  virtual ~ReaderInterface() {}
+
+  /// Get an upper bound on the next message size available for reading on this
+  /// stream.
+  virtual bool NextMessageSize(uint32_t* sz) = 0;
+
+  /// Block to read a message and parse to \a msg. Returns \a true on success.
+  /// This is thread-safe with respect to \a Write or \WritesDone methods on
+  /// the same stream. It should not be called concurrently with another \a
+  /// Read on the same stream as the order of delivery will not be defined.
+  ///
+  /// \param[out] msg The read message.
+  ///
+  /// \return \a false when there will be no more incoming messages, either
+  /// because the other side has called \a WritesDone() or the stream has failed
+  /// (or been cancelled).
+  virtual bool Read(R* msg) = 0;
+};
+
+/// An interface that can be fed a sequence of messages of type \a W.
+template <class W>
+class WriterInterface {
+ public:
+  virtual ~WriterInterface() {}
+
+  /// Block to write \a msg to the stream with WriteOptions \a options.
+  /// This is thread-safe with respect to \a ReaderInterface::Read
+  ///
+  /// \param msg The message to be written to the stream.
+  /// \param options The WriteOptions affecting the write operation.
+  ///
+  /// \return \a true on success, \a false when the stream has been closed.
+  virtual bool Write(const W& msg, grpc::WriteOptions options) = 0;
+
+  /// Block to write \a msg to the stream with default write options.
+  /// This is thread-safe with respect to \a ReaderInterface::Read
+  ///
+  /// \param msg The message to be written to the stream.
+  ///
+  /// \return \a true on success, \a false when the stream has been closed.
+  inline bool Write(const W& msg) { return Write(msg, grpc::WriteOptions()); }
+
+  /// Write \a msg and coalesce it with the writing of trailing metadata, using
+  /// WriteOptions \a options.
+  ///
+  /// For client, WriteLast is equivalent of performing Write and WritesDone in
+  /// a single step. \a msg and trailing metadata are coalesced and sent on wire
+  /// by calling this function. For server, WriteLast buffers the \a msg.
+  /// The writing of \a msg is held until the service handler returns,
+  /// where \a msg and trailing metadata are coalesced and sent on wire.
+  /// Note that WriteLast can only buffer \a msg up to the flow control window
+  /// size. If \a msg size is larger than the window size, it will be sent on
+  /// wire without buffering.
+  ///
+  /// \param[in] msg The message to be written to the stream.
+  /// \param[in] options The WriteOptions to be used to write this message.
+  void WriteLast(const W& msg, grpc::WriteOptions options) {
+    Write(msg, options.set_last_message());
+  }
+};
+
+}  // namespace internal
+
+/// Client-side interface for streaming reads of message of type \a R.
+template <class R>
+class ClientReaderInterface : public internal::ClientStreamingInterface,
+                              public internal::ReaderInterface<R> {
+ public:
+  /// Block to wait for initial metadata from server. The received metadata
+  /// can only be accessed after this call returns. Should only be called before
+  /// the first read. Calling this method is optional, and if it is not called
+  /// the metadata will be available in ClientContext after the first read.
+  virtual void WaitForInitialMetadata() = 0;
+};
+
+namespace internal {
+template <class R>
+class ClientReaderFactory {
+ public:
+  template <class W>
+  static ClientReader<R>* Create(grpc::ChannelInterface* channel,
+                                 const grpc::internal::RpcMethod& method,
+                                 grpc::ClientContext* context,
+                                 const W& request) {
+    return new ClientReader<R>(channel, method, context, request);
+  }
+};
+}  // namespace internal
+
+/// Synchronous (blocking) client-side API for doing server-streaming RPCs,
+/// where the stream of messages coming from the server has messages
+/// of type \a R.
+template <class R>
+class ClientReader final : public ClientReaderInterface<R> {
+ public:
+  /// See the \a ClientStreamingInterface.WaitForInitialMetadata method for
+  /// semantics.
+  ///
+  //  Side effect:
+  ///   Once complete, the initial metadata read from
+  ///   the server will be accessible through the \a ClientContext used to
+  ///   construct this object.
+  void WaitForInitialMetadata() override {
+    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
+    ops.RecvInitialMetadata(context_);
+    call_.PerformOps(&ops);
+    cq_.Pluck(&ops);  /// status ignored
+  }
+
+  bool NextMessageSize(uint32_t* sz) override {
+    int result = call_.max_receive_message_size();
+    *sz = (result > 0) ? result : UINT32_MAX;
+    return true;
+  }
+
+  /// See the \a ReaderInterface.Read method for semantics.
+  /// Side effect:
+  ///   This also receives initial metadata from the server, if not
+  ///   already received (if initial metadata is received, it can be then
+  ///   accessed through the \a ClientContext associated with this call).
+  bool Read(R* msg) override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                              grpc::internal::CallOpRecvMessage<R>>
+        ops;
+    if (!context_->initial_metadata_received_) {
+      ops.RecvInitialMetadata(context_);
+    }
+    ops.RecvMessage(msg);
+    call_.PerformOps(&ops);
+    return cq_.Pluck(&ops) && ops.got_message;
+  }
+
+  /// See the \a ClientStreamingInterface.Finish method for semantics.
+  ///
+  /// Side effect:
+  ///   The \a ClientContext associated with this call is updated with
+  ///   possible metadata received from the server.
+  grpc::Status Finish() override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                              grpc::internal::CallOpClientRecvStatus>
+        ops;
+    if (!context_->initial_metadata_received_) {
+      ops.RecvInitialMetadata(context_);
+    }
+    grpc::Status status;
+    ops.ClientRecvStatus(context_, &status);
+    call_.PerformOps(&ops);
+    GPR_CODEGEN_ASSERT(cq_.Pluck(&ops));
+    return status;
+  }
+
+ private:
+  friend class internal::ClientReaderFactory<R>;
+  grpc::ClientContext* context_;
+  grpc::CompletionQueue cq_;
+  grpc::internal::Call call_;
+
+  /// Block to create a stream and write the initial metadata and \a request
+  /// out. Note that \a context will be used to fill in custom initial
+  /// metadata used to send to the server when starting the call.
+  template <class W>
+  ClientReader(grpc::ChannelInterface* channel,
+               const grpc::internal::RpcMethod& method,
+               grpc::ClientContext* context, const W& request)
+      : context_(context),
+        cq_(grpc_completion_queue_attributes{
+            GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
+            nullptr}),  // Pluckable cq
+        call_(channel->CreateCall(method, context, &cq_)) {
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage,
+                              grpc::internal::CallOpClientSendClose>
+        ops;
+    ops.SendInitialMetadata(&context->send_initial_metadata_,
+                            context->initial_metadata_flags());
+    // TODO(ctiller): don't assert
+    GPR_CODEGEN_ASSERT(ops.SendMessagePtr(&request).ok());
+    ops.ClientSendClose();
+    call_.PerformOps(&ops);
+    cq_.Pluck(&ops);
+  }
+};
+
+/// Client-side interface for streaming writes of message type \a W.
+template <class W>
+class ClientWriterInterface : public internal::ClientStreamingInterface,
+                              public internal::WriterInterface<W> {
+ public:
+  /// Half close writing from the client. (signal that the stream of messages
+  /// coming from the client is complete).
+  /// Blocks until currently-pending writes are completed.
+  /// Thread safe with respect to \a ReaderInterface::Read operations only
+  ///
+  /// \return Whether the writes were successful.
+  virtual bool WritesDone() = 0;
+};
+
+namespace internal {
+template <class W>
+class ClientWriterFactory {
+ public:
+  template <class R>
+  static ClientWriter<W>* Create(grpc::ChannelInterface* channel,
+                                 const grpc::internal::RpcMethod& method,
+                                 grpc::ClientContext* context, R* response) {
+    return new ClientWriter<W>(channel, method, context, response);
+  }
+};
+}  // namespace internal
+
+/// Synchronous (blocking) client-side API for doing client-streaming RPCs,
+/// where the outgoing message stream coming from the client has messages of
+/// type \a W.
+template <class W>
+class ClientWriter : public ClientWriterInterface<W> {
+ public:
+  /// See the \a ClientStreamingInterface.WaitForInitialMetadata method for
+  /// semantics.
+  ///
+  //  Side effect:
+  ///   Once complete, the initial metadata read from the server will be
+  ///   accessible through the \a ClientContext used to construct this object.
+  void WaitForInitialMetadata() {
+    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
+    ops.RecvInitialMetadata(context_);
+    call_.PerformOps(&ops);
+    cq_.Pluck(&ops);  // status ignored
+  }
+
+  /// See the WriterInterface.Write(const W& msg, WriteOptions options) method
+  /// for semantics.
+  ///
+  /// Side effect:
+  ///   Also sends initial metadata if not already sent (using the
+  ///   \a ClientContext associated with this call).
+  using internal::WriterInterface<W>::Write;
+  bool Write(const W& msg, grpc::WriteOptions options) override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage,
+                              grpc::internal::CallOpClientSendClose>
+        ops;
+
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+      ops.ClientSendClose();
+    }
+    if (context_->initial_metadata_corked_) {
+      ops.SendInitialMetadata(&context_->send_initial_metadata_,
+                              context_->initial_metadata_flags());
+      context_->set_initial_metadata_corked(false);
+    }
+    if (!ops.SendMessagePtr(&msg, options).ok()) {
+      return false;
+    }
+
+    call_.PerformOps(&ops);
+    return cq_.Pluck(&ops);
+  }
+
+  bool WritesDone() override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpClientSendClose> ops;
+    ops.ClientSendClose();
+    call_.PerformOps(&ops);
+    return cq_.Pluck(&ops);
+  }
+
+  /// See the ClientStreamingInterface.Finish method for semantics.
+  /// Side effects:
+  ///   - Also receives initial metadata if not already received.
+  ///   - Attempts to fill in the \a response parameter passed
+  ///     to the constructor of this instance with the response
+  ///     message from the server.
+  grpc::Status Finish() override {
+    grpc::Status status;
+    if (!context_->initial_metadata_received_) {
+      finish_ops_.RecvInitialMetadata(context_);
+    }
+    finish_ops_.ClientRecvStatus(context_, &status);
+    call_.PerformOps(&finish_ops_);
+    GPR_CODEGEN_ASSERT(cq_.Pluck(&finish_ops_));
+    return status;
+  }
+
+ private:
+  friend class internal::ClientWriterFactory<W>;
+
+  /// Block to create a stream (i.e. send request headers and other initial
+  /// metadata to the server). Note that \a context will be used to fill
+  /// in custom initial metadata. \a response will be filled in with the
+  /// single expected response message from the server upon a successful
+  /// call to the \a Finish method of this instance.
+  template <class R>
+  ClientWriter(grpc::ChannelInterface* channel,
+               const grpc::internal::RpcMethod& method,
+               grpc::ClientContext* context, R* response)
+      : context_(context),
+        cq_(grpc_completion_queue_attributes{
+            GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
+            nullptr}),  // Pluckable cq
+        call_(channel->CreateCall(method, context, &cq_)) {
+    finish_ops_.RecvMessage(response);
+    finish_ops_.AllowNoMessage();
+
+    if (!context_->initial_metadata_corked_) {
+      grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+      ops.SendInitialMetadata(&context->send_initial_metadata_,
+                              context->initial_metadata_flags());
+      call_.PerformOps(&ops);
+      cq_.Pluck(&ops);
+    }
+  }
+
+  grpc::ClientContext* context_;
+  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                            grpc::internal::CallOpGenericRecvMessage,
+                            grpc::internal::CallOpClientRecvStatus>
+      finish_ops_;
+  grpc::CompletionQueue cq_;
+  grpc::internal::Call call_;
+};
+
+/// Client-side interface for bi-directional streaming with
+/// client-to-server stream messages of type \a W and
+/// server-to-client stream messages of type \a R.
+template <class W, class R>
+class ClientReaderWriterInterface : public internal::ClientStreamingInterface,
+                                    public internal::WriterInterface<W>,
+                                    public internal::ReaderInterface<R> {
+ public:
+  /// Block to wait for initial metadata from server. The received metadata
+  /// can only be accessed after this call returns. Should only be called before
+  /// the first read. Calling this method is optional, and if it is not called
+  /// the metadata will be available in ClientContext after the first read.
+  virtual void WaitForInitialMetadata() = 0;
+
+  /// Half close writing from the client. (signal that the stream of messages
+  /// coming from the client is complete).
+  /// Blocks until currently-pending writes are completed.
+  /// Thread-safe with respect to \a ReaderInterface::Read
+  ///
+  /// \return Whether the writes were successful.
+  virtual bool WritesDone() = 0;
+};
+
+namespace internal {
+template <class W, class R>
+class ClientReaderWriterFactory {
+ public:
+  static ClientReaderWriter<W, R>* Create(
+      grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method,
+      grpc::ClientContext* context) {
+    return new ClientReaderWriter<W, R>(channel, method, context);
+  }
+};
+}  // namespace internal
+
+/// Synchronous (blocking) client-side API for bi-directional streaming RPCs,
+/// where the outgoing message stream coming from the client has messages of
+/// type \a W, and the incoming messages stream coming from the server has
+/// messages of type \a R.
+template <class W, class R>
+class ClientReaderWriter final : public ClientReaderWriterInterface<W, R> {
+ public:
+  /// Block waiting to read initial metadata from the server.
+  /// This call is optional, but if it is used, it cannot be used concurrently
+  /// with or after the \a Finish method.
+  ///
+  /// Once complete, the initial metadata read from the server will be
+  /// accessible through the \a ClientContext used to construct this object.
+  void WaitForInitialMetadata() override {
+    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
+    ops.RecvInitialMetadata(context_);
+    call_.PerformOps(&ops);
+    cq_.Pluck(&ops);  // status ignored
+  }
+
+  bool NextMessageSize(uint32_t* sz) override {
+    int result = call_.max_receive_message_size();
+    *sz = (result > 0) ? result : UINT32_MAX;
+    return true;
+  }
+
+  /// See the \a ReaderInterface.Read method for semantics.
+  /// Side effect:
+  ///   Also receives initial metadata if not already received (updates the \a
+  ///   ClientContext associated with this call in that case).
+  bool Read(R* msg) override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                              grpc::internal::CallOpRecvMessage<R>>
+        ops;
+    if (!context_->initial_metadata_received_) {
+      ops.RecvInitialMetadata(context_);
+    }
+    ops.RecvMessage(msg);
+    call_.PerformOps(&ops);
+    return cq_.Pluck(&ops) && ops.got_message;
+  }
+
+  /// See the \a WriterInterface.Write method for semantics.
+  ///
+  /// Side effect:
+  ///   Also sends initial metadata if not already sent (using the
+  ///   \a ClientContext associated with this call to fill in values).
+  using internal::WriterInterface<W>::Write;
+  bool Write(const W& msg, grpc::WriteOptions options) override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
+                              grpc::internal::CallOpSendMessage,
+                              grpc::internal::CallOpClientSendClose>
+        ops;
+
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+      ops.ClientSendClose();
+    }
+    if (context_->initial_metadata_corked_) {
+      ops.SendInitialMetadata(&context_->send_initial_metadata_,
+                              context_->initial_metadata_flags());
+      context_->set_initial_metadata_corked(false);
+    }
+    if (!ops.SendMessagePtr(&msg, options).ok()) {
+      return false;
+    }
+
+    call_.PerformOps(&ops);
+    return cq_.Pluck(&ops);
+  }
+
+  bool WritesDone() override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpClientSendClose> ops;
+    ops.ClientSendClose();
+    call_.PerformOps(&ops);
+    return cq_.Pluck(&ops);
+  }
+
+  /// See the ClientStreamingInterface.Finish method for semantics.
+  ///
+  /// Side effect:
+  ///   - the \a ClientContext associated with this call is updated with
+  ///     possible trailing metadata sent from the server.
+  grpc::Status Finish() override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
+                              grpc::internal::CallOpClientRecvStatus>
+        ops;
+    if (!context_->initial_metadata_received_) {
+      ops.RecvInitialMetadata(context_);
+    }
+    grpc::Status status;
+    ops.ClientRecvStatus(context_, &status);
+    call_.PerformOps(&ops);
+    GPR_CODEGEN_ASSERT(cq_.Pluck(&ops));
+    return status;
+  }
+
+ private:
+  friend class internal::ClientReaderWriterFactory<W, R>;
+
+  grpc::ClientContext* context_;
+  grpc::CompletionQueue cq_;
+  grpc::internal::Call call_;
+
+  /// Block to create a stream and write the initial metadata and \a request
+  /// out. Note that \a context will be used to fill in custom initial metadata
+  /// used to send to the server when starting the call.
+  ClientReaderWriter(grpc::ChannelInterface* channel,
+                     const grpc::internal::RpcMethod& method,
+                     grpc::ClientContext* context)
+      : context_(context),
+        cq_(grpc_completion_queue_attributes{
+            GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
+            nullptr}),  // Pluckable cq
+        call_(channel->CreateCall(method, context, &cq_)) {
+    if (!context_->initial_metadata_corked_) {
+      grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+      ops.SendInitialMetadata(&context->send_initial_metadata_,
+                              context->initial_metadata_flags());
+      call_.PerformOps(&ops);
+      cq_.Pluck(&ops);
+    }
+  }
+};
+
+/// Server-side interface for streaming reads of message of type \a R.
+template <class R>
+class ServerReaderInterface : public internal::ServerStreamingInterface,
+                              public internal::ReaderInterface<R> {};
+
+/// Synchronous (blocking) server-side API for doing client-streaming RPCs,
+/// where the incoming message stream coming from the client has messages of
+/// type \a R.
+template <class R>
+class ServerReader final : public ServerReaderInterface<R> {
+ public:
+  /// See the \a ServerStreamingInterface.SendInitialMetadata method
+  /// for semantics. Note that initial metadata will be affected by the
+  /// \a ServerContext associated with this call.
+  void SendInitialMetadata() override {
+    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+    ops.SendInitialMetadata(&ctx_->initial_metadata_,
+                            ctx_->initial_metadata_flags());
+    if (ctx_->compression_level_set()) {
+      ops.set_compression_level(ctx_->compression_level());
+    }
+    ctx_->sent_initial_metadata_ = true;
+    call_->PerformOps(&ops);
+    call_->cq()->Pluck(&ops);
+  }
+
+  bool NextMessageSize(uint32_t* sz) override {
+    int result = call_->max_receive_message_size();
+    *sz = (result > 0) ? result : UINT32_MAX;
+    return true;
+  }
+
+  bool Read(R* msg) override {
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> ops;
+    ops.RecvMessage(msg);
+    call_->PerformOps(&ops);
+    bool ok = call_->cq()->Pluck(&ops) && ops.got_message;
+    if (!ok) {
+      ctx_->MaybeMarkCancelledOnRead();
+    }
+    return ok;
+  }
+
+ private:
+  grpc::internal::Call* const call_;
+  ServerContext* const ctx_;
+
+  template <class ServiceType, class RequestType, class ResponseType>
+  friend class internal::ClientStreamingHandler;
+
+  ServerReader(grpc::internal::Call* call, grpc::ServerContext* ctx)
+      : call_(call), ctx_(ctx) {}
+};
+
+/// Server-side interface for streaming writes of message of type \a W.
+template <class W>
+class ServerWriterInterface : public internal::ServerStreamingInterface,
+                              public internal::WriterInterface<W> {};
+
+/// Synchronous (blocking) server-side API for doing for doing a
+/// server-streaming RPCs, where the outgoing message stream coming from the
+/// server has messages of type \a W.
+template <class W>
+class ServerWriter final : public ServerWriterInterface<W> {
+ public:
+  /// See the \a ServerStreamingInterface.SendInitialMetadata method
+  /// for semantics.
+  /// Note that initial metadata will be affected by the
+  /// \a ServerContext associated with this call.
+  void SendInitialMetadata() override {
+    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+    ops.SendInitialMetadata(&ctx_->initial_metadata_,
+                            ctx_->initial_metadata_flags());
+    if (ctx_->compression_level_set()) {
+      ops.set_compression_level(ctx_->compression_level());
+    }
+    ctx_->sent_initial_metadata_ = true;
+    call_->PerformOps(&ops);
+    call_->cq()->Pluck(&ops);
+  }
+
+  /// See the \a WriterInterface.Write method for semantics.
+  ///
+  /// Side effect:
+  ///   Also sends initial metadata if not already sent (using the
+  ///   \a ClientContext associated with this call to fill in values).
+  using internal::WriterInterface<W>::Write;
+  bool Write(const W& msg, grpc::WriteOptions options) override {
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+    }
+
+    if (!ctx_->pending_ops_.SendMessagePtr(&msg, options).ok()) {
+      return false;
+    }
+    if (!ctx_->sent_initial_metadata_) {
+      ctx_->pending_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                             ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        ctx_->pending_ops_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+    }
+    call_->PerformOps(&ctx_->pending_ops_);
+    // if this is the last message we defer the pluck until AFTER we start
+    // the trailing md op. This prevents hangs. See
+    // https://github.com/grpc/grpc/issues/11546
+    if (options.is_last_message()) {
+      ctx_->has_pending_ops_ = true;
+      return true;
+    }
+    ctx_->has_pending_ops_ = false;
+    return call_->cq()->Pluck(&ctx_->pending_ops_);
+  }
+
+ private:
+  grpc::internal::Call* const call_;
+  grpc::ServerContext* const ctx_;
+
+  template <class ServiceType, class RequestType, class ResponseType>
+  friend class internal::ServerStreamingHandler;
+
+  ServerWriter(grpc::internal::Call* call, grpc::ServerContext* ctx)
+      : call_(call), ctx_(ctx) {}
+};
+
+/// Server-side interface for bi-directional streaming.
+template <class W, class R>
+class ServerReaderWriterInterface : public internal::ServerStreamingInterface,
+                                    public internal::WriterInterface<W>,
+                                    public internal::ReaderInterface<R> {};
+
+/// Actual implementation of bi-directional streaming
+namespace internal {
+template <class W, class R>
+class ServerReaderWriterBody final {
+ public:
+  ServerReaderWriterBody(grpc::internal::Call* call, grpc::ServerContext* ctx)
+      : call_(call), ctx_(ctx) {}
+
+  void SendInitialMetadata() {
+    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+    ops.SendInitialMetadata(&ctx_->initial_metadata_,
+                            ctx_->initial_metadata_flags());
+    if (ctx_->compression_level_set()) {
+      ops.set_compression_level(ctx_->compression_level());
+    }
+    ctx_->sent_initial_metadata_ = true;
+    call_->PerformOps(&ops);
+    call_->cq()->Pluck(&ops);
+  }
+
+  bool NextMessageSize(uint32_t* sz) {
+    int result = call_->max_receive_message_size();
+    *sz = (result > 0) ? result : UINT32_MAX;
+    return true;
+  }
+
+  bool Read(R* msg) {
+    grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> ops;
+    ops.RecvMessage(msg);
+    call_->PerformOps(&ops);
+    bool ok = call_->cq()->Pluck(&ops) && ops.got_message;
+    if (!ok) {
+      ctx_->MaybeMarkCancelledOnRead();
+    }
+    return ok;
+  }
+
+  bool Write(const W& msg, grpc::WriteOptions options) {
+    if (options.is_last_message()) {
+      options.set_buffer_hint();
+    }
+    if (!ctx_->pending_ops_.SendMessagePtr(&msg, options).ok()) {
+      return false;
+    }
+    if (!ctx_->sent_initial_metadata_) {
+      ctx_->pending_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
+                                             ctx_->initial_metadata_flags());
+      if (ctx_->compression_level_set()) {
+        ctx_->pending_ops_.set_compression_level(ctx_->compression_level());
+      }
+      ctx_->sent_initial_metadata_ = true;
+    }
+    call_->PerformOps(&ctx_->pending_ops_);
+    // if this is the last message we defer the pluck until AFTER we start
+    // the trailing md op. This prevents hangs. See
+    // https://github.com/grpc/grpc/issues/11546
+    if (options.is_last_message()) {
+      ctx_->has_pending_ops_ = true;
+      return true;
+    }
+    ctx_->has_pending_ops_ = false;
+    return call_->cq()->Pluck(&ctx_->pending_ops_);
+  }
+
+ private:
+  grpc::internal::Call* const call_;
+  grpc::ServerContext* const ctx_;
+};
+
+}  // namespace internal
+
+/// Synchronous (blocking) server-side API for a bidirectional
+/// streaming call, where the incoming message stream coming from the client has
+/// messages of type \a R, and the outgoing message streaming coming from
+/// the server has messages of type \a W.
+template <class W, class R>
+class ServerReaderWriter final : public ServerReaderWriterInterface<W, R> {
+ public:
+  /// See the \a ServerStreamingInterface.SendInitialMetadata method
+  /// for semantics. Note that initial metadata will be affected by the
+  /// \a ServerContext associated with this call.
+  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
+
+  bool NextMessageSize(uint32_t* sz) override {
+    return body_.NextMessageSize(sz);
+  }
+
+  bool Read(R* msg) override { return body_.Read(msg); }
+
+  /// See the \a WriterInterface.Write(const W& msg, WriteOptions options)
+  /// method for semantics.
+  /// Side effect:
+  ///   Also sends initial metadata if not already sent (using the \a
+  ///   ServerContext associated with this call).
+  using internal::WriterInterface<W>::Write;
+  bool Write(const W& msg, grpc::WriteOptions options) override {
+    return body_.Write(msg, options);
+  }
+
+ private:
+  internal::ServerReaderWriterBody<W, R> body_;
+
+  friend class internal::TemplatedBidiStreamingHandler<ServerReaderWriter<W, R>,
+                                                       false>;
+  ServerReaderWriter(grpc::internal::Call* call, grpc::ServerContext* ctx)
+      : body_(call, ctx) {}
+};
+
+/// A class to represent a flow-controlled unary call. This is something
+/// of a hybrid between conventional unary and streaming. This is invoked
+/// through a unary call on the client side, but the server responds to it
+/// as though it were a single-ping-pong streaming call. The server can use
+/// the \a NextMessageSize method to determine an upper-bound on the size of
+/// the message. A key difference relative to streaming: ServerUnaryStreamer
+/// must have exactly 1 Read and exactly 1 Write, in that order, to function
+/// correctly. Otherwise, the RPC is in error.
+template <class RequestType, class ResponseType>
+class ServerUnaryStreamer final
+    : public ServerReaderWriterInterface<ResponseType, RequestType> {
+ public:
+  /// Block to send initial metadata to client.
+  /// Implicit input parameter:
+  ///    - the \a ServerContext associated with this call will be used for
+  ///      sending initial metadata.
+  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
+
+  /// Get an upper bound on the request message size from the client.
+  bool NextMessageSize(uint32_t* sz) override {
+    return body_.NextMessageSize(sz);
+  }
+
+  /// Read a message of type \a R into \a msg. Completion will be notified by \a
+  /// tag on the associated completion queue.
+  /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
+  /// should not be called concurrently with other streaming APIs
+  /// on the same stream. It is not meaningful to call it concurrently
+  /// with another \a ReaderInterface::Read on the same stream since reads on
+  /// the same stream are delivered in order.
+  ///
+  /// \param[out] msg Where to eventually store the read message.
+  /// \param[in] tag The tag identifying the operation.
+  bool Read(RequestType* request) override {
+    if (read_done_) {
+      return false;
+    }
+    read_done_ = true;
+    return body_.Read(request);
+  }
+
+  /// Block to write \a msg to the stream with WriteOptions \a options.
+  /// This is thread-safe with respect to \a ReaderInterface::Read
+  ///
+  /// \param msg The message to be written to the stream.
+  /// \param options The WriteOptions affecting the write operation.
+  ///
+  /// \return \a true on success, \a false when the stream has been closed.
+  using internal::WriterInterface<ResponseType>::Write;
+  bool Write(const ResponseType& response,
+             grpc::WriteOptions options) override {
+    if (write_done_ || !read_done_) {
+      return false;
+    }
+    write_done_ = true;
+    return body_.Write(response, options);
+  }
+
+ private:
+  internal::ServerReaderWriterBody<ResponseType, RequestType> body_;
+  bool read_done_;
+  bool write_done_;
+
+  friend class internal::TemplatedBidiStreamingHandler<
+      ServerUnaryStreamer<RequestType, ResponseType>, true>;
+  ServerUnaryStreamer(grpc::internal::Call* call, grpc::ServerContext* ctx)
+      : body_(call, ctx), read_done_(false), write_done_(false) {}
+};
+
+/// A class to represent a flow-controlled server-side streaming call.
+/// This is something of a hybrid between server-side and bidi streaming.
+/// This is invoked through a server-side streaming call on the client side,
+/// but the server responds to it as though it were a bidi streaming call that
+/// must first have exactly 1 Read and then any number of Writes.
+template <class RequestType, class ResponseType>
+class ServerSplitStreamer final
+    : public ServerReaderWriterInterface<ResponseType, RequestType> {
+ public:
+  /// Block to send initial metadata to client.
+  /// Implicit input parameter:
+  ///    - the \a ServerContext associated with this call will be used for
+  ///      sending initial metadata.
+  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
+
+  /// Get an upper bound on the request message size from the client.
+  bool NextMessageSize(uint32_t* sz) override {
+    return body_.NextMessageSize(sz);
+  }
+
+  /// Read a message of type \a R into \a msg. Completion will be notified by \a
+  /// tag on the associated completion queue.
+  /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
+  /// should not be called concurrently with other streaming APIs
+  /// on the same stream. It is not meaningful to call it concurrently
+  /// with another \a ReaderInterface::Read on the same stream since reads on
+  /// the same stream are delivered in order.
+  ///
+  /// \param[out] msg Where to eventually store the read message.
+  /// \param[in] tag The tag identifying the operation.
+  bool Read(RequestType* request) override {
+    if (read_done_) {
+      return false;
+    }
+    read_done_ = true;
+    return body_.Read(request);
+  }
+
+  /// Block to write \a msg to the stream with WriteOptions \a options.
+  /// This is thread-safe with respect to \a ReaderInterface::Read
+  ///
+  /// \param msg The message to be written to the stream.
+  /// \param options The WriteOptions affecting the write operation.
+  ///
+  /// \return \a true on success, \a false when the stream has been closed.
+  using internal::WriterInterface<ResponseType>::Write;
+  bool Write(const ResponseType& response,
+             grpc::WriteOptions options) override {
+    return read_done_ && body_.Write(response, options);
+  }
+
+ private:
+  internal::ServerReaderWriterBody<ResponseType, RequestType> body_;
+  bool read_done_;
+
+  friend class internal::TemplatedBidiStreamingHandler<
+      ServerSplitStreamer<RequestType, ResponseType>, false>;
+  ServerSplitStreamer(grpc::internal::Call* call, grpc::ServerContext* ctx)
+      : body_(call, ctx), read_done_(false) {}
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_SYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/time.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/time.h
new file mode 100644
index 0000000..f2021f5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/time.h
@@ -0,0 +1,91 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_CODEGEN_TIME_H
+#define GRPCPP_IMPL_CODEGEN_TIME_H
+
+// IWYU pragma: private, include <grpcpp/support/time.h>
+
+#include <chrono>
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpcpp/impl/codegen/config.h>
+
+namespace grpc {
+
+/** If you are trying to use CompletionQueue::AsyncNext with a time class that
+    isn't either gpr_timespec or std::chrono::system_clock::time_point, you
+    will most likely be looking at this comment as your compiler will have
+    fired an error below. In order to fix this issue, you have two potential
+    solutions:
+
+      1. Use gpr_timespec or std::chrono::system_clock::time_point instead
+      2. Specialize the TimePoint class with whichever time class that you
+         want to use here. See below for two examples of how to do this.
+ */
+template <typename T>
+class TimePoint {
+ public:
+  // If you see the error with methods below, you may need either
+  // i) using the existing types having a conversion class such as
+  // gpr_timespec and std::chrono::system_clock::time_point or
+  // ii) writing a new TimePoint<YourType> to address your case.
+  TimePoint(const T& /*time*/) = delete;
+  gpr_timespec raw_time() = delete;
+};
+
+template <>
+class TimePoint<gpr_timespec> {
+ public:
+  /* NOLINTNEXTLINE(google-explicit-constructor) */
+  TimePoint(const gpr_timespec& time) : time_(time) {}
+  gpr_timespec raw_time() { return time_; }
+
+ private:
+  gpr_timespec time_;
+};
+
+}  // namespace grpc
+
+namespace grpc {
+
+// from and to should be absolute time.
+void Timepoint2Timespec(const std::chrono::system_clock::time_point& from,
+                        gpr_timespec* to);
+void TimepointHR2Timespec(
+    const std::chrono::high_resolution_clock::time_point& from,
+    gpr_timespec* to);
+
+std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t);
+
+template <>
+class TimePoint<std::chrono::system_clock::time_point> {
+ public:
+  /* NOLINTNEXTLINE(google-explicit-constructor) */
+  TimePoint(const std::chrono::system_clock::time_point& time) {
+    Timepoint2Timespec(time, &time_);
+  }
+  gpr_timespec raw_time() const { return time_; }
+
+ private:
+  gpr_timespec time_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_CODEGEN_TIME_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/grpc_library.h b/CAPI/cpp/grpc/include/grpcpp/impl/grpc_library.h
new file mode 100644
index 0000000..0afca8e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/grpc_library.h
@@ -0,0 +1,60 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_GRPC_LIBRARY_H
+#define GRPCPP_IMPL_GRPC_LIBRARY_H
+
+#include <iostream>
+
+#include <grpc/grpc.h>
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/core_codegen.h>
+#include <grpcpp/impl/codegen/grpc_library.h>  // IWYU pragma: export
+
+namespace grpc {
+
+namespace internal {
+class GrpcLibrary final : public GrpcLibraryInterface {
+ public:
+  void init() override { grpc_init(); }
+  void shutdown() override { grpc_shutdown(); }
+};
+
+/// Instantiating this class ensures the proper initialization of gRPC.
+class GrpcLibraryInitializer final {
+ public:
+  GrpcLibraryInitializer() {
+    if (grpc::g_glip == nullptr) {
+      static auto* const g_gli = new GrpcLibrary();
+      grpc::g_glip = g_gli;
+    }
+    if (grpc::g_core_codegen_interface == nullptr) {
+      static auto* const g_core_codegen = new CoreCodegen();
+      grpc::g_core_codegen_interface = g_core_codegen;
+    }
+  }
+
+  /// A no-op method to force the linker to reference this class, which will
+  /// take care of initializing and shutting down the gRPC runtime.
+  int summon() { return 0; }
+};
+
+}  // namespace internal
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_GRPC_LIBRARY_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/method_handler_impl.h b/CAPI/cpp/grpc/include/grpcpp/impl/method_handler_impl.h
new file mode 100644
index 0000000..5eceb5f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/method_handler_impl.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_METHOD_HANDLER_IMPL_H
+#define GRPCPP_IMPL_METHOD_HANDLER_IMPL_H
+
+#include <grpcpp/impl/codegen/method_handler.h>
+
+#endif  // GRPCPP_IMPL_METHOD_HANDLER_IMPL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/rpc_method.h b/CAPI/cpp/grpc/include/grpcpp/impl/rpc_method.h
new file mode 100644
index 0000000..aeef8b7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/rpc_method.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_RPC_METHOD_H
+#define GRPCPP_IMPL_RPC_METHOD_H
+
+#include <grpcpp/impl/codegen/rpc_method.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_IMPL_RPC_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/rpc_service_method.h b/CAPI/cpp/grpc/include/grpcpp/impl/rpc_service_method.h
new file mode 100644
index 0000000..86cb2dc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/rpc_service_method.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_RPC_SERVICE_METHOD_H
+#define GRPCPP_IMPL_RPC_SERVICE_METHOD_H
+
+#include <grpcpp/impl/codegen/rpc_service_method.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_IMPL_RPC_SERVICE_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/serialization_traits.h b/CAPI/cpp/grpc/include/grpcpp/impl/serialization_traits.h
new file mode 100644
index 0000000..6da8b4d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/serialization_traits.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_SERIALIZATION_TRAITS_H
+#define GRPCPP_IMPL_SERIALIZATION_TRAITS_H
+
+#include <grpcpp/impl/codegen/serialization_traits.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_IMPL_SERIALIZATION_TRAITS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_option.h b/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_option.h
new file mode 100644
index 0000000..c8f047b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_option.h
@@ -0,0 +1,43 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_SERVER_BUILDER_OPTION_H
+#define GRPCPP_IMPL_SERVER_BUILDER_OPTION_H
+
+#include <map>
+#include <memory>
+
+#include <grpcpp/impl/server_builder_plugin.h>
+#include <grpcpp/support/channel_arguments.h>
+
+namespace grpc {
+
+/// Interface to pass an option to a \a ServerBuilder.
+class ServerBuilderOption {
+ public:
+  virtual ~ServerBuilderOption() {}
+  /// Alter the \a ChannelArguments used to create the gRPC server.
+  virtual void UpdateArguments(grpc::ChannelArguments* args) = 0;
+  /// Alter the ServerBuilderPlugin map that will be added into ServerBuilder.
+  virtual void UpdatePlugins(
+      std::vector<std::unique_ptr<grpc::ServerBuilderPlugin>>* plugins) = 0;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_SERVER_BUILDER_OPTION_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_plugin.h b/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_plugin.h
new file mode 100644
index 0000000..e5bb058
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_plugin.h
@@ -0,0 +1,66 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_SERVER_BUILDER_PLUGIN_H
+#define GRPCPP_IMPL_SERVER_BUILDER_PLUGIN_H
+
+#include <memory>
+
+#include <grpcpp/support/channel_arguments.h>
+#include <grpcpp/support/config.h>
+
+namespace grpc {
+
+class ServerBuilder;
+class ServerInitializer;
+
+/// This interface is meant for internal usage only. Implementations of this
+/// interface should add themselves to a \a ServerBuilder instance through the
+/// \a InternalAddPluginFactory method.
+class ServerBuilderPlugin {
+ public:
+  virtual ~ServerBuilderPlugin() {}
+  virtual std::string name() = 0;
+
+  /// UpdateServerBuilder will be called at an early stage in
+  /// ServerBuilder::BuildAndStart(), right after the ServerBuilderOptions have
+  /// done their updates.
+  virtual void UpdateServerBuilder(ServerBuilder* /*builder*/) {}
+
+  /// InitServer will be called in ServerBuilder::BuildAndStart(), after the
+  /// Server instance is created.
+  virtual void InitServer(ServerInitializer* si) = 0;
+
+  /// Finish will be called at the end of ServerBuilder::BuildAndStart().
+  virtual void Finish(ServerInitializer* si) = 0;
+
+  /// ChangeArguments is an interface that can be used in
+  /// ServerBuilderOption::UpdatePlugins
+  virtual void ChangeArguments(const std::string& name, void* value) = 0;
+
+  /// UpdateChannelArguments will be called in ServerBuilder::BuildAndStart(),
+  /// before the Server instance is created.
+  virtual void UpdateChannelArguments(ChannelArguments* /*args*/) {}
+
+  virtual bool has_sync_methods() const { return false; }
+  virtual bool has_async_methods() const { return false; }
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_SERVER_BUILDER_PLUGIN_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/server_initializer.h b/CAPI/cpp/grpc/include/grpcpp/impl/server_initializer.h
new file mode 100644
index 0000000..610df80
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/server_initializer.h
@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_SERVER_INITIALIZER_H
+#define GRPCPP_IMPL_SERVER_INITIALIZER_H
+
+#include <memory>
+#include <vector>
+
+#include <grpcpp/server.h>
+
+namespace grpc {
+class Server;
+class Service;
+
+class ServerInitializer {
+ public:
+  explicit ServerInitializer(grpc::Server* server) : server_(server) {}
+
+  bool RegisterService(std::shared_ptr<grpc::Service> service) {
+    if (!server_->RegisterService(nullptr, service.get())) {
+      return false;
+    }
+    default_services_.push_back(service);
+    return true;
+  }
+
+  const std::vector<std::string>* GetServiceList() {
+    return &server_->services_;
+  }
+
+ private:
+  grpc::Server* server_;
+  std::vector<std::shared_ptr<grpc::Service> > default_services_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_IMPL_SERVER_INITIALIZER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/service_type.h b/CAPI/cpp/grpc/include/grpcpp/impl/service_type.h
new file mode 100644
index 0000000..de45c42
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/service_type.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_IMPL_SERVICE_TYPE_H
+#define GRPCPP_IMPL_SERVICE_TYPE_H
+
+#include <grpcpp/impl/codegen/service_type.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_IMPL_SERVICE_TYPE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/resource_quota.h b/CAPI/cpp/grpc/include/grpcpp/resource_quota.h
new file mode 100644
index 0000000..bde32f9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/resource_quota.h
@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_RESOURCE_QUOTA_H
+#define GRPCPP_RESOURCE_QUOTA_H
+
+struct grpc_resource_quota;
+
+#include <grpcpp/impl/codegen/config.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+
+namespace grpc {
+
+/// ResourceQuota represents a bound on memory and thread usage by the gRPC
+/// library. A ResourceQuota can be attached to a server (via \a ServerBuilder),
+/// or a client channel (via \a ChannelArguments).
+/// gRPC will attempt to keep memory and threads used by all attached entities
+/// below the ResourceQuota bound.
+class ResourceQuota final : private grpc::GrpcLibraryCodegen {
+ public:
+  /// \param name - a unique name for this ResourceQuota.
+  explicit ResourceQuota(const std::string& name);
+  ResourceQuota();
+  ~ResourceQuota() override;
+
+  /// Resize this \a ResourceQuota to a new size. If \a new_size is smaller
+  /// than the current size of the pool, memory usage will be monotonically
+  /// decreased until it falls under \a new_size.
+  /// No time bound is given for this to occur however.
+  ResourceQuota& Resize(size_t new_size);
+
+  /// Set the max number of threads that can be allocated from this
+  /// ResourceQuota object.
+  ///
+  /// If the new_max_threads value is smaller than the current value, no new
+  /// threads are allocated until the number of active threads fall below
+  /// new_max_threads. There is no time bound on when this may happen i.e none
+  /// of the current threads are forcefully destroyed and all threads run their
+  /// normal course.
+  ResourceQuota& SetMaxThreads(int new_max_threads);
+
+  grpc_resource_quota* c_resource_quota() const { return impl_; }
+
+ private:
+  ResourceQuota(const ResourceQuota& rhs);
+  ResourceQuota& operator=(const ResourceQuota& rhs);
+
+  grpc_resource_quota* const impl_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_RESOURCE_QUOTA_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/alts_context.h b/CAPI/cpp/grpc/include/grpcpp/security/alts_context.h
new file mode 100644
index 0000000..8d84257
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/alts_context.h
@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SECURITY_ALTS_CONTEXT_H
+#define GRPCPP_SECURITY_ALTS_CONTEXT_H
+
+#include <map>
+#include <memory>
+
+#include <grpc/grpc_security_constants.h>
+#include <grpcpp/security/auth_context.h>
+
+struct grpc_gcp_AltsContext;
+
+namespace grpc {
+namespace experimental {
+
+// AltsContext is a wrapper class for grpc_gcp_AltsContext.
+class AltsContext {
+ public:
+  struct RpcProtocolVersions {
+    struct Version {
+      int major_version;
+      int minor_version;
+    };
+    Version max_rpc_version;
+    Version min_rpc_version;
+  };
+  explicit AltsContext(const grpc_gcp_AltsContext* ctx);
+  AltsContext& operator=(const AltsContext&) = default;
+  AltsContext(const AltsContext&) = default;
+
+  std::string application_protocol() const;
+  std::string record_protocol() const;
+  std::string peer_service_account() const;
+  std::string local_service_account() const;
+  grpc_security_level security_level() const;
+  RpcProtocolVersions peer_rpc_versions() const;
+  const std::map<std::string, std::string>& peer_attributes() const;
+
+ private:
+  std::string application_protocol_;
+  std::string record_protocol_;
+  std::string peer_service_account_;
+  std::string local_service_account_;
+  grpc_security_level security_level_ = GRPC_SECURITY_NONE;
+  RpcProtocolVersions peer_rpc_versions_ = {{0, 0}, {0, 0}};
+  std::map<std::string, std::string> peer_attributes_map_;
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_ALTS_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/alts_util.h b/CAPI/cpp/grpc/include/grpcpp/security/alts_util.h
new file mode 100644
index 0000000..b0ef4b4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/alts_util.h
@@ -0,0 +1,50 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SECURITY_ALTS_UTIL_H
+#define GRPCPP_SECURITY_ALTS_UTIL_H
+
+#include <memory>
+
+#include <grpc/grpc_security_constants.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/security/alts_context.h>
+#include <grpcpp/security/auth_context.h>
+
+struct grpc_gcp_AltsContext;
+
+namespace grpc {
+namespace experimental {
+
+// GetAltsContextFromAuthContext helps to get the AltsContext from AuthContext.
+// If ALTS is not the transport security protocol used to establish the
+// connection, this function will return nullptr.
+std::unique_ptr<AltsContext> GetAltsContextFromAuthContext(
+    const std::shared_ptr<const AuthContext>& auth_context);
+
+// This utility function performs ALTS client authorization check on server
+// side, i.e., checks if the client identity matches one of the expected service
+// accounts. It returns OK if client is authorized and an error otherwise.
+grpc::Status AltsClientAuthzCheck(
+    const std::shared_ptr<const AuthContext>& auth_context,
+    const std::vector<std::string>& expected_service_accounts);
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_ALTS_UTIL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/auth_context.h b/CAPI/cpp/grpc/include/grpcpp/security/auth_context.h
new file mode 100644
index 0000000..1778450
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/auth_context.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SECURITY_AUTH_CONTEXT_H
+#define GRPCPP_SECURITY_AUTH_CONTEXT_H
+
+#include <grpcpp/impl/codegen/security/auth_context.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SECURITY_AUTH_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/auth_metadata_processor.h b/CAPI/cpp/grpc/include/grpcpp/security/auth_metadata_processor.h
new file mode 100644
index 0000000..545bdf1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/auth_metadata_processor.h
@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SECURITY_AUTH_METADATA_PROCESSOR_H
+#define GRPCPP_SECURITY_AUTH_METADATA_PROCESSOR_H
+
+#include <map>
+
+#include <grpcpp/security/auth_context.h>
+#include <grpcpp/support/status.h>
+#include <grpcpp/support/string_ref.h>
+
+namespace grpc {
+
+/// Interface allowing custom server-side authorization based on credentials
+/// encoded in metadata.  Objects of this type can be passed to
+/// \a ServerCredentials::SetAuthMetadataProcessor().
+/// Please also check out \a grpc::experimental::Interceptor for another way to
+/// do customized operations on the information provided by a specific call.
+class AuthMetadataProcessor {
+ public:
+  typedef std::multimap<grpc::string_ref, grpc::string_ref> InputMetadata;
+  typedef std::multimap<std::string, std::string> OutputMetadata;
+
+  virtual ~AuthMetadataProcessor() {}
+
+  /// If this method returns true, the \a Process function will be scheduled in
+  /// a different thread from the one processing the call.
+  virtual bool IsBlocking() const { return true; }
+
+  /// Processes a Call associated with a connection.
+  /// auth_metadata: the authentication metadata associated with the particular
+  ///   call
+  /// context: contains the connection-level info, e.g. the peer identity. This
+  ///   parameter is readable and writable. Note that since the information is
+  ///   shared for all calls associated with the connection, if the
+  ///   implementation updates the info in a specific call, all the subsequent
+  ///   calls will see the updates. A typical usage of context is to use
+  ///   |auth_metadata| to infer the peer identity, and augment it with
+  ///   properties.
+  /// consumed_auth_metadata: contains the metadata that the implementation
+  ///   wants to remove from the current call, so that the server application is
+  ///   no longer able to see it anymore. A typical usage would be to do token
+  ///   authentication in the first call, and then remove the token information
+  ///   for all subsequent calls.
+  /// response_metadata(CURRENTLY NOT SUPPORTED): the metadata that will be sent
+  ///   as part of the response.
+  /// return: if the return value is not Status::OK, the rpc call will be
+  ///   aborted with the error code and error message sent back to the client.
+  virtual grpc::Status Process(const InputMetadata& auth_metadata,
+                               grpc::AuthContext* context,
+                               OutputMetadata* consumed_auth_metadata,
+                               OutputMetadata* response_metadata) = 0;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_AUTH_METADATA_PROCESSOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/authorization_policy_provider.h b/CAPI/cpp/grpc/include/grpcpp/security/authorization_policy_provider.h
new file mode 100644
index 0000000..1718db4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/authorization_policy_provider.h
@@ -0,0 +1,88 @@
+// Copyright 2021 gRPC authors.
+//
+// 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.
+
+#ifndef GRPCPP_SECURITY_AUTHORIZATION_POLICY_PROVIDER_H
+#define GRPCPP_SECURITY_AUTHORIZATION_POLICY_PROVIDER_H
+
+#include <memory>
+
+#include <grpc/grpc_security.h>
+#include <grpc/status.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+
+namespace grpc {
+namespace experimental {
+
+// Wrapper around C-core grpc_authorization_policy_provider. Internally, it
+// handles creating and updating authorization engine objects, using SDK
+// authorization policy.
+class AuthorizationPolicyProviderInterface {
+ public:
+  virtual ~AuthorizationPolicyProviderInterface() = default;
+  virtual grpc_authorization_policy_provider* c_provider() = 0;
+};
+
+// Implementation obtains authorization policy from static string. This provider
+// will always return the same authorization engines.
+class StaticDataAuthorizationPolicyProvider
+    : public AuthorizationPolicyProviderInterface {
+ public:
+  static std::shared_ptr<StaticDataAuthorizationPolicyProvider> Create(
+      const std::string& authz_policy, grpc::Status* status);
+
+  // Use factory method "Create" to create an instance of
+  // StaticDataAuthorizationPolicyProvider.
+  explicit StaticDataAuthorizationPolicyProvider(
+      grpc_authorization_policy_provider* provider)
+      : c_provider_(provider) {}
+
+  ~StaticDataAuthorizationPolicyProvider() override;
+
+  grpc_authorization_policy_provider* c_provider() override {
+    return c_provider_;
+  }
+
+ private:
+  grpc_authorization_policy_provider* c_provider_ = nullptr;
+};
+
+// Implementation obtains authorization policy by watching for changes in
+// filesystem.
+class FileWatcherAuthorizationPolicyProvider
+    : public AuthorizationPolicyProviderInterface {
+ public:
+  static std::shared_ptr<FileWatcherAuthorizationPolicyProvider> Create(
+      const std::string& authz_policy_path, unsigned int refresh_interval_sec,
+      grpc::Status* status);
+
+  // Use factory method "Create" to create an instance of
+  // FileWatcherAuthorizationPolicyProvider.
+  explicit FileWatcherAuthorizationPolicyProvider(
+      grpc_authorization_policy_provider* provider)
+      : c_provider_(provider) {}
+
+  ~FileWatcherAuthorizationPolicyProvider() override;
+
+  grpc_authorization_policy_provider* c_provider() override {
+    return c_provider_;
+  }
+
+ private:
+  grpc_authorization_policy_provider* c_provider_ = nullptr;
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_AUTHORIZATION_POLICY_PROVIDER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/binder_credentials.h b/CAPI/cpp/grpc/include/grpcpp/security/binder_credentials.h
new file mode 100644
index 0000000..f511837
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/binder_credentials.h
@@ -0,0 +1,43 @@
+// Copyright 2021 gRPC authors.
+//
+// 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.
+
+#ifndef GRPCPP_SECURITY_BINDER_CREDENTIALS_H
+#define GRPCPP_SECURITY_BINDER_CREDENTIALS_H
+
+#include <memory>
+
+#include <grpcpp/security/binder_security_policy.h>
+#include <grpcpp/security/server_credentials.h>
+
+namespace grpc {
+
+class ChannelCredentials;
+
+namespace experimental {
+
+/// EXPERIMENTAL Builds Binder ServerCredentials.
+///
+/// This should be used along with `binder:` URI scheme. The path in the URI can
+/// later be used to access the server's endpoint binder.
+/// Note that calling \a ServerBuilder::AddListeningPort() with Binder
+/// ServerCredentials in a non-supported environment will make the subsequent
+/// call to \a ServerBuilder::BuildAndStart() return a null pointer.
+std::shared_ptr<grpc::ServerCredentials> BinderServerCredentials(
+    std::shared_ptr<grpc::experimental::binder::SecurityPolicy>
+        security_policy);
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_BINDER_CREDENTIALS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/binder_security_policy.h b/CAPI/cpp/grpc/include/grpcpp/security/binder_security_policy.h
new file mode 100644
index 0000000..e1c951f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/binder_security_policy.h
@@ -0,0 +1,82 @@
+// Copyright 2021 gRPC authors.
+//
+// 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.
+
+#ifndef GRPCPP_SECURITY_BINDER_SECURITY_POLICY_H
+#define GRPCPP_SECURITY_BINDER_SECURITY_POLICY_H
+
+#include <memory>
+
+#ifdef GPR_ANDROID
+
+#include <jni.h>
+
+#endif
+
+namespace grpc {
+namespace experimental {
+namespace binder {
+
+// EXPERIMENTAL Determinines if a connection is allowed to be
+// established on Android. See https://source.android.com/security/app-sandbox
+// for more info about UID.
+class SecurityPolicy {
+ public:
+  virtual ~SecurityPolicy() = default;
+  // Returns true if the UID is authorized to connect.
+  // Must return the same value for the same inputs so callers can safely cache
+  // the result.
+  virtual bool IsAuthorized(int uid) = 0;
+};
+
+// EXPERIMENTAL Allows all connection. Anything on the Android device will be
+// able to connect, use with caution!
+class UntrustedSecurityPolicy : public SecurityPolicy {
+ public:
+  UntrustedSecurityPolicy();
+  ~UntrustedSecurityPolicy() override;
+  bool IsAuthorized(int uid) override;
+};
+
+// EXPERIMENTAL Only allows the connections from processes with the same UID. In
+// most cases this means "from the same APK".
+class InternalOnlySecurityPolicy : public SecurityPolicy {
+ public:
+  InternalOnlySecurityPolicy();
+  ~InternalOnlySecurityPolicy() override;
+  bool IsAuthorized(int uid) override;
+};
+
+#ifdef GPR_ANDROID
+
+// EXPERIMENTAL Only allows the connections from the APK that have the same
+// signature.
+class SameSignatureSecurityPolicy : public SecurityPolicy {
+ public:
+  // `context` is required for getting PackageManager Java class
+  SameSignatureSecurityPolicy(JavaVM* jvm, jobject context);
+  ~SameSignatureSecurityPolicy() override;
+  bool IsAuthorized(int uid) override;
+
+ private:
+  JavaVM* jvm_;
+  jobject context_;
+};
+
+#endif
+
+}  // namespace binder
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_BINDER_SECURITY_POLICY_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/credentials.h b/CAPI/cpp/grpc/include/grpcpp/security/credentials.h
new file mode 100644
index 0000000..18dce96
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/credentials.h
@@ -0,0 +1,349 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SECURITY_CREDENTIALS_H
+#define GRPCPP_SECURITY_CREDENTIALS_H
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include <grpc/grpc_security_constants.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/impl/codegen/client_interceptor.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+#include <grpcpp/security/auth_context.h>
+#include <grpcpp/security/tls_credentials_options.h>
+#include <grpcpp/support/channel_arguments.h>
+#include <grpcpp/support/status.h>
+#include <grpcpp/support/string_ref.h>
+
+struct grpc_call;
+
+namespace grpc {
+class CallCredentials;
+class SecureCallCredentials;
+class SecureChannelCredentials;
+class ChannelCredentials;
+
+std::shared_ptr<Channel> CreateCustomChannel(
+    const grpc::string& target,
+    const std::shared_ptr<grpc::ChannelCredentials>& creds,
+    const grpc::ChannelArguments& args);
+
+namespace experimental {
+std::shared_ptr<grpc::Channel> CreateCustomChannelWithInterceptors(
+    const grpc::string& target,
+    const std::shared_ptr<grpc::ChannelCredentials>& creds,
+    const grpc::ChannelArguments& args,
+    std::vector<
+        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+        interceptor_creators);
+
+GRPC_DEPRECATED(
+    "Use grpc::XdsCredentials instead. The experimental version will be "
+    "deleted after the 1.41 release.")
+std::shared_ptr<ChannelCredentials> XdsCredentials(
+    const std::shared_ptr<ChannelCredentials>& fallback_creds);
+}  // namespace experimental
+
+/// Builds XDS Credentials.
+std::shared_ptr<ChannelCredentials> XdsCredentials(
+    const std::shared_ptr<ChannelCredentials>& fallback_creds);
+
+/// A channel credentials object encapsulates all the state needed by a client
+/// to authenticate with a server for a given channel.
+/// It can make various assertions, e.g., about the client’s identity, role
+/// for all the calls on that channel.
+///
+/// \see https://grpc.io/docs/guides/auth.html
+class ChannelCredentials : private grpc::GrpcLibraryCodegen {
+ public:
+  ChannelCredentials();
+  ~ChannelCredentials() override;
+
+ protected:
+  friend std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
+      const std::shared_ptr<ChannelCredentials>& channel_creds,
+      const std::shared_ptr<CallCredentials>& call_creds);
+
+  // TODO(yashykt): We need this friend declaration mainly for access to
+  // AsSecureCredentials(). Once we are able to remove insecure builds from gRPC
+  // (and also internal dependencies on the indirect method of creating a
+  // channel through credentials), we would be able to remove this.
+  friend std::shared_ptr<ChannelCredentials> grpc::XdsCredentials(
+      const std::shared_ptr<ChannelCredentials>& fallback_creds);
+
+  virtual SecureChannelCredentials* AsSecureCredentials() = 0;
+
+ private:
+  friend std::shared_ptr<grpc::Channel> CreateCustomChannel(
+      const grpc::string& target,
+      const std::shared_ptr<grpc::ChannelCredentials>& creds,
+      const grpc::ChannelArguments& args);
+
+  friend std::shared_ptr<grpc::Channel>
+  grpc::experimental::CreateCustomChannelWithInterceptors(
+      const grpc::string& target,
+      const std::shared_ptr<grpc::ChannelCredentials>& creds,
+      const grpc::ChannelArguments& args,
+      std::vector<std::unique_ptr<
+          grpc::experimental::ClientInterceptorFactoryInterface>>
+          interceptor_creators);
+
+  virtual std::shared_ptr<Channel> CreateChannelImpl(
+      const grpc::string& target, const ChannelArguments& args) = 0;
+
+  // This function should have been a pure virtual function, but it is
+  // implemented as a virtual function so that it does not break API.
+  virtual std::shared_ptr<Channel> CreateChannelWithInterceptors(
+      const grpc::string& /*target*/, const ChannelArguments& /*args*/,
+      std::vector<std::unique_ptr<
+          grpc::experimental::ClientInterceptorFactoryInterface>>
+      /*interceptor_creators*/) {
+    return nullptr;
+  }
+
+  // TODO(yashkt): This is a hack that is needed since InsecureCredentials can
+  // not use grpc_channel_credentials internally and should be removed after
+  // insecure builds are removed from gRPC.
+  virtual bool IsInsecure() const { return false; }
+};
+
+/// A call credentials object encapsulates the state needed by a client to
+/// authenticate with a server for a given call on a channel.
+///
+/// \see https://grpc.io/docs/guides/auth.html
+class CallCredentials : private grpc::GrpcLibraryCodegen {
+ public:
+  CallCredentials();
+  ~CallCredentials() override;
+
+  /// Apply this instance's credentials to \a call.
+  virtual bool ApplyToCall(grpc_call* call) = 0;
+  virtual grpc::string DebugString() {
+    return "CallCredentials did not provide a debug string";
+  }
+
+ protected:
+  friend std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
+      const std::shared_ptr<ChannelCredentials>& channel_creds,
+      const std::shared_ptr<CallCredentials>& call_creds);
+
+  friend std::shared_ptr<CallCredentials> CompositeCallCredentials(
+      const std::shared_ptr<CallCredentials>& creds1,
+      const std::shared_ptr<CallCredentials>& creds2);
+
+  virtual SecureCallCredentials* AsSecureCredentials() = 0;
+};
+
+/// Options used to build SslCredentials.
+struct SslCredentialsOptions {
+  /// The buffer containing the PEM encoding of the server root certificates. If
+  /// this parameter is empty, the default roots will be used.  The default
+  /// roots can be overridden using the \a GRPC_DEFAULT_SSL_ROOTS_FILE_PATH
+  /// environment variable pointing to a file on the file system containing the
+  /// roots.
+  grpc::string pem_root_certs;
+
+  /// The buffer containing the PEM encoding of the client's private key. This
+  /// parameter can be empty if the client does not have a private key.
+  grpc::string pem_private_key;
+
+  /// The buffer containing the PEM encoding of the client's certificate chain.
+  /// This parameter can be empty if the client does not have a certificate
+  /// chain.
+  grpc::string pem_cert_chain;
+};
+
+// Factories for building different types of Credentials The functions may
+// return empty shared_ptr when credentials cannot be created. If a
+// Credentials pointer is returned, it can still be invalid when used to create
+// a channel. A lame channel will be created then and all rpcs will fail on it.
+
+/// Builds credentials with reasonable defaults.
+///
+/// \warning Only use these credentials when connecting to a Google endpoint.
+/// Using these credentials to connect to any other service may result in this
+/// service being able to impersonate your client for requests to Google
+/// services.
+std::shared_ptr<ChannelCredentials> GoogleDefaultCredentials();
+
+/// Builds SSL Credentials given SSL specific options
+std::shared_ptr<ChannelCredentials> SslCredentials(
+    const SslCredentialsOptions& options);
+
+/// Builds credentials for use when running in GCE
+///
+/// \warning Only use these credentials when connecting to a Google endpoint.
+/// Using these credentials to connect to any other service may result in this
+/// service being able to impersonate your client for requests to Google
+/// services.
+std::shared_ptr<CallCredentials> GoogleComputeEngineCredentials();
+
+constexpr long kMaxAuthTokenLifetimeSecs = 3600;
+
+/// Builds Service Account JWT Access credentials.
+/// json_key is the JSON key string containing the client's private key.
+/// token_lifetime_seconds is the lifetime in seconds of each Json Web Token
+/// (JWT) created with this credentials. It should not exceed
+/// \a kMaxAuthTokenLifetimeSecs or will be cropped to this value.
+std::shared_ptr<CallCredentials> ServiceAccountJWTAccessCredentials(
+    const grpc::string& json_key,
+    long token_lifetime_seconds = kMaxAuthTokenLifetimeSecs);
+
+/// Builds refresh token credentials.
+/// json_refresh_token is the JSON string containing the refresh token along
+/// with a client_id and client_secret.
+///
+/// \warning Only use these credentials when connecting to a Google endpoint.
+/// Using these credentials to connect to any other service may result in this
+/// service being able to impersonate your client for requests to Google
+/// services.
+std::shared_ptr<CallCredentials> GoogleRefreshTokenCredentials(
+    const grpc::string& json_refresh_token);
+
+/// Builds access token credentials.
+/// access_token is an oauth2 access token that was fetched using an out of band
+/// mechanism.
+///
+/// \warning Only use these credentials when connecting to a Google endpoint.
+/// Using these credentials to connect to any other service may result in this
+/// service being able to impersonate your client for requests to Google
+/// services.
+std::shared_ptr<CallCredentials> AccessTokenCredentials(
+    const grpc::string& access_token);
+
+/// Builds IAM credentials.
+///
+/// \warning Only use these credentials when connecting to a Google endpoint.
+/// Using these credentials to connect to any other service may result in this
+/// service being able to impersonate your client for requests to Google
+/// services.
+std::shared_ptr<CallCredentials> GoogleIAMCredentials(
+    const grpc::string& authorization_token,
+    const grpc::string& authority_selector);
+
+/// Combines a channel credentials and a call credentials into a composite
+/// channel credentials.
+std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
+    const std::shared_ptr<ChannelCredentials>& channel_creds,
+    const std::shared_ptr<CallCredentials>& call_creds);
+
+/// Combines two call credentials objects into a composite call credentials.
+std::shared_ptr<CallCredentials> CompositeCallCredentials(
+    const std::shared_ptr<CallCredentials>& creds1,
+    const std::shared_ptr<CallCredentials>& creds2);
+
+/// Credentials for an unencrypted, unauthenticated channel
+std::shared_ptr<ChannelCredentials> InsecureChannelCredentials();
+
+/// User defined metadata credentials.
+class MetadataCredentialsPlugin {
+ public:
+  virtual ~MetadataCredentialsPlugin() {}
+
+  /// If this method returns true, the Process function will be scheduled in
+  /// a different thread from the one processing the call.
+  virtual bool IsBlocking() const { return true; }
+
+  /// Type of credentials this plugin is implementing.
+  virtual const char* GetType() const { return ""; }
+
+  /// Gets the auth metatada produced by this plugin.
+  /// The fully qualified method name is:
+  /// service_url + "/" + method_name.
+  /// The channel_auth_context contains (among other things), the identity of
+  /// the server.
+  virtual grpc::Status GetMetadata(
+      grpc::string_ref service_url, grpc::string_ref method_name,
+      const grpc::AuthContext& channel_auth_context,
+      std::multimap<grpc::string, grpc::string>* metadata) = 0;
+
+  virtual grpc::string DebugString() {
+    return "MetadataCredentialsPlugin did not provide a debug string";
+  }
+};
+
+std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
+    std::unique_ptr<MetadataCredentialsPlugin> plugin);
+
+/// Builds External Account credentials.
+/// json_string is the JSON string containing the credentials options.
+/// scopes contains the scopes to be binded with the credentials.
+std::shared_ptr<CallCredentials> ExternalAccountCredentials(
+    const grpc::string& json_string, const std::vector<grpc::string>& scopes);
+
+namespace experimental {
+
+/// Options for creating STS Oauth Token Exchange credentials following the IETF
+/// draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
+/// Optional fields may be set to empty string. It is the responsibility of the
+/// caller to ensure that the subject and actor tokens are refreshed on disk at
+/// the specified paths.
+struct StsCredentialsOptions {
+  grpc::string token_exchange_service_uri;  // Required.
+  grpc::string resource;                    // Optional.
+  grpc::string audience;                    // Optional.
+  grpc::string scope;                       // Optional.
+  grpc::string requested_token_type;        // Optional.
+  grpc::string subject_token_path;          // Required.
+  grpc::string subject_token_type;          // Required.
+  grpc::string actor_token_path;            // Optional.
+  grpc::string actor_token_type;            // Optional.
+};
+
+grpc::Status StsCredentialsOptionsFromJson(const std::string& json_string,
+                                           StsCredentialsOptions* options);
+
+/// Creates STS credentials options from the $STS_CREDENTIALS environment
+/// variable. This environment variable points to the path of a JSON file
+/// comforming to the schema described above.
+grpc::Status StsCredentialsOptionsFromEnv(StsCredentialsOptions* options);
+
+std::shared_ptr<CallCredentials> StsCredentials(
+    const StsCredentialsOptions& options);
+
+std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
+    std::unique_ptr<MetadataCredentialsPlugin> plugin,
+    grpc_security_level min_security_level);
+
+/// Options used to build AltsCredentials.
+struct AltsCredentialsOptions {
+  /// service accounts of target endpoint that will be acceptable
+  /// by the client. If service accounts are provided and none of them matches
+  /// that of the server, authentication will fail.
+  std::vector<grpc::string> target_service_accounts;
+};
+
+/// Builds ALTS Credentials given ALTS specific options
+std::shared_ptr<ChannelCredentials> AltsCredentials(
+    const AltsCredentialsOptions& options);
+
+/// Builds Local Credentials.
+std::shared_ptr<ChannelCredentials> LocalCredentials(
+    grpc_local_connect_type type);
+
+/// Builds TLS Credentials given TLS options.
+std::shared_ptr<ChannelCredentials> TlsCredentials(
+    const TlsChannelCredentialsOptions& options);
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_CREDENTIALS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/server_credentials.h b/CAPI/cpp/grpc/include/grpcpp/security/server_credentials.h
new file mode 100644
index 0000000..2d1bc07
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/server_credentials.h
@@ -0,0 +1,145 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SECURITY_SERVER_CREDENTIALS_H
+#define GRPCPP_SECURITY_SERVER_CREDENTIALS_H
+
+#include <memory>
+#include <vector>
+
+#include <grpc/grpc_security_constants.h>
+#include <grpcpp/security/auth_metadata_processor.h>
+#include <grpcpp/security/tls_credentials_options.h>
+#include <grpcpp/support/config.h>
+
+struct grpc_server;
+
+namespace grpc {
+
+class Server;
+class ServerCredentials;
+class SecureServerCredentials;
+/// Options to create ServerCredentials with SSL
+struct SslServerCredentialsOptions {
+  /// \warning Deprecated
+  SslServerCredentialsOptions()
+      : force_client_auth(false),
+        client_certificate_request(GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE) {}
+  explicit SslServerCredentialsOptions(
+      grpc_ssl_client_certificate_request_type request_type)
+      : force_client_auth(false), client_certificate_request(request_type) {}
+
+  struct PemKeyCertPair {
+    std::string private_key;
+    std::string cert_chain;
+  };
+  std::string pem_root_certs;
+  std::vector<PemKeyCertPair> pem_key_cert_pairs;
+  /// \warning Deprecated
+  bool force_client_auth;
+
+  /// If both \a force_client_auth and \a client_certificate_request
+  /// fields are set, \a force_client_auth takes effect, i.e.
+  /// \a REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY
+  /// will be enforced.
+  grpc_ssl_client_certificate_request_type client_certificate_request;
+};
+
+/// Builds Xds ServerCredentials given fallback credentials
+std::shared_ptr<ServerCredentials> XdsServerCredentials(
+    const std::shared_ptr<ServerCredentials>& fallback_credentials);
+
+namespace experimental {
+GRPC_DEPRECATED(
+    "Use grpc::XdsServerCredentials instead. The experimental version will be "
+    "deleted after the 1.41 release.")
+std::shared_ptr<ServerCredentials> XdsServerCredentials(
+    const std::shared_ptr<ServerCredentials>& fallback_credentials);
+}  // namespace experimental
+
+/// Wrapper around \a grpc_server_credentials, a way to authenticate a server.
+class ServerCredentials : private grpc::GrpcLibraryCodegen {
+ public:
+  ServerCredentials();
+  ~ServerCredentials() override;
+
+  /// This method is not thread-safe and has to be called before the server is
+  /// started. The last call to this function wins.
+  virtual void SetAuthMetadataProcessor(
+      const std::shared_ptr<grpc::AuthMetadataProcessor>& processor) = 0;
+
+ private:
+  friend class Server;
+
+  // We need this friend declaration for access to Insecure() and
+  // AsSecureServerCredentials(). When these two functions are no longer
+  // necessary, this friend declaration can be removed too.
+  friend std::shared_ptr<ServerCredentials> grpc::XdsServerCredentials(
+      const std::shared_ptr<ServerCredentials>& fallback_credentials);
+
+  /// Tries to bind \a server to the given \a addr (eg, localhost:1234,
+  /// 192.168.1.1:31416, [::1]:27182, etc.)
+  ///
+  /// \return bound port number on success, 0 on failure.
+  // TODO(dgq): the "port" part seems to be a misnomer.
+  virtual int AddPortToServer(const std::string& addr, grpc_server* server) = 0;
+
+  // TODO(yashykt): This is a hack since InsecureServerCredentials() cannot use
+  // grpc_insecure_server_credentials_create() and should be removed after
+  // insecure builds are removed from gRPC.
+  virtual bool IsInsecure() const { return false; }
+
+  // TODO(yashkt): This is a hack that should be removed once we remove insecure
+  // builds and the indirect method of adding ports to a server.
+  virtual SecureServerCredentials* AsSecureServerCredentials() {
+    return nullptr;
+  }
+};
+
+/// Builds SSL ServerCredentials given SSL specific options
+std::shared_ptr<ServerCredentials> SslServerCredentials(
+    const grpc::SslServerCredentialsOptions& options);
+
+std::shared_ptr<ServerCredentials> InsecureServerCredentials();
+
+namespace experimental {
+
+/// Options to create ServerCredentials with ALTS
+struct AltsServerCredentialsOptions {
+  /// Add fields if needed.
+};
+
+/// Builds ALTS ServerCredentials given ALTS specific options
+std::shared_ptr<ServerCredentials> AltsServerCredentials(
+    const AltsServerCredentialsOptions& options);
+
+/// Builds Local ServerCredentials.
+std::shared_ptr<ServerCredentials> AltsServerCredentials(
+    const AltsServerCredentialsOptions& options);
+
+std::shared_ptr<ServerCredentials> LocalServerCredentials(
+    grpc_local_connect_type type);
+
+/// Builds TLS ServerCredentials given TLS options.
+std::shared_ptr<ServerCredentials> TlsServerCredentials(
+    const experimental::TlsServerCredentialsOptions& options);
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_SERVER_CREDENTIALS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_provider.h b/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_provider.h
new file mode 100644
index 0000000..bbef455
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_provider.h
@@ -0,0 +1,127 @@
+//
+// Copyright 2020 gRPC authors.
+//
+// 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.
+//
+
+#ifndef GRPCPP_SECURITY_TLS_CERTIFICATE_PROVIDER_H
+#define GRPCPP_SECURITY_TLS_CERTIFICATE_PROVIDER_H
+
+#include <memory>
+#include <vector>
+
+#include <grpc/grpc_security.h>
+#include <grpc/grpc_security_constants.h>
+#include <grpc/status.h>
+#include <grpc/support/log.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+#include <grpcpp/support/config.h>
+
+namespace grpc {
+namespace experimental {
+
+// Interface for a class that handles the process to fetch credential data.
+// Implementations should be a wrapper class of an internal provider
+// implementation.
+class CertificateProviderInterface {
+ public:
+  virtual ~CertificateProviderInterface() = default;
+  virtual grpc_tls_certificate_provider* c_provider() = 0;
+};
+
+// A struct that stores the credential data presented to the peer in handshake
+// to show local identity. The private_key and certificate_chain should always
+// match.
+struct IdentityKeyCertPair {
+  std::string private_key;
+  std::string certificate_chain;
+};
+
+// A basic CertificateProviderInterface implementation that will load credential
+// data from static string during initialization. This provider will always
+// return the same cert data for all cert names, and reloading is not supported.
+class StaticDataCertificateProvider : public CertificateProviderInterface {
+ public:
+  StaticDataCertificateProvider(
+      const std::string& root_certificate,
+      const std::vector<IdentityKeyCertPair>& identity_key_cert_pairs);
+
+  explicit StaticDataCertificateProvider(const std::string& root_certificate)
+      : StaticDataCertificateProvider(root_certificate, {}) {}
+
+  explicit StaticDataCertificateProvider(
+      const std::vector<IdentityKeyCertPair>& identity_key_cert_pairs)
+      : StaticDataCertificateProvider("", identity_key_cert_pairs) {}
+
+  ~StaticDataCertificateProvider() override;
+
+  grpc_tls_certificate_provider* c_provider() override { return c_provider_; }
+
+ private:
+  grpc_tls_certificate_provider* c_provider_ = nullptr;
+};
+
+// A CertificateProviderInterface implementation that will watch the credential
+// changes on the file system. This provider will always return the up-to-date
+// cert data for all the cert names callers set through |TlsCredentialsOptions|.
+// Several things to note:
+// 1. This API only supports one key-cert file and hence one set of identity
+// key-cert pair, so SNI(Server Name Indication) is not supported.
+// 2. The private key and identity certificate should always match. This API
+// guarantees atomic read, and it is the callers' responsibility to do atomic
+// updates. There are many ways to atomically update the key and certs in the
+// file system. To name a few:
+//   1)  creating a new directory, renaming the old directory to a new name, and
+//   then renaming the new directory to the original name of the old directory.
+//   2)  using a symlink for the directory. When need to change, put new
+//   credential data in a new directory, and change symlink.
+class FileWatcherCertificateProvider final
+    : public CertificateProviderInterface {
+ public:
+  // Constructor to get credential updates from root and identity file paths.
+  //
+  // @param private_key_path is the file path of the private key.
+  // @param identity_certificate_path is the file path of the identity
+  // certificate chain.
+  // @param root_cert_path is the file path to the root certificate bundle.
+  // @param refresh_interval_sec is the refreshing interval that we will check
+  // the files for updates.
+  FileWatcherCertificateProvider(const std::string& private_key_path,
+                                 const std::string& identity_certificate_path,
+                                 const std::string& root_cert_path,
+                                 unsigned int refresh_interval_sec);
+  // Constructor to get credential updates from identity file paths only.
+  FileWatcherCertificateProvider(const std::string& private_key_path,
+                                 const std::string& identity_certificate_path,
+                                 unsigned int refresh_interval_sec)
+      : FileWatcherCertificateProvider(private_key_path,
+                                       identity_certificate_path, "",
+                                       refresh_interval_sec) {}
+  // Constructor to get credential updates from root file path only.
+  FileWatcherCertificateProvider(const std::string& root_cert_path,
+                                 unsigned int refresh_interval_sec)
+      : FileWatcherCertificateProvider("", "", root_cert_path,
+                                       refresh_interval_sec) {}
+
+  ~FileWatcherCertificateProvider() override;
+
+  grpc_tls_certificate_provider* c_provider() override { return c_provider_; }
+
+ private:
+  grpc_tls_certificate_provider* c_provider_ = nullptr;
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_TLS_CERTIFICATE_PROVIDER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_verifier.h b/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_verifier.h
new file mode 100644
index 0000000..881adf2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_verifier.h
@@ -0,0 +1,238 @@
+//
+// Copyright 2021 gRPC authors.
+//
+// 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.
+//
+
+#ifndef GRPCPP_SECURITY_TLS_CERTIFICATE_VERIFIER_H
+#define GRPCPP_SECURITY_TLS_CERTIFICATE_VERIFIER_H
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <grpc/grpc_security_constants.h>
+#include <grpc/status.h>
+#include <grpc/support/log.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+#include <grpcpp/impl/codegen/sync.h>
+#include <grpcpp/impl/grpc_library.h>
+#include <grpcpp/support/config.h>
+#include <grpcpp/support/string_ref.h>
+
+// TODO(yihuazhang): remove the forward declaration here and include
+// <grpc/grpc_security.h> directly once the insecure builds are cleaned up.
+typedef struct grpc_tls_custom_verification_check_request
+    grpc_tls_custom_verification_check_request;
+typedef struct grpc_tls_certificate_verifier grpc_tls_certificate_verifier;
+typedef struct grpc_tls_certificate_verifier_external
+    grpc_tls_certificate_verifier_external;
+typedef void (*grpc_tls_on_custom_verification_check_done_cb)(
+    grpc_tls_custom_verification_check_request* request, void* callback_arg,
+    grpc_status_code status, const char* error_details);
+extern "C" grpc_tls_certificate_verifier*
+grpc_tls_certificate_verifier_external_create(
+    grpc_tls_certificate_verifier_external* external_verifier);
+
+namespace grpc {
+namespace experimental {
+
+// Contains the verification-related information associated with a connection
+// request. Users should not directly create or destroy this request object, but
+// shall interact with it through CertificateVerifier's Verify() and Cancel().
+class TlsCustomVerificationCheckRequest {
+ public:
+  explicit TlsCustomVerificationCheckRequest(
+      grpc_tls_custom_verification_check_request* request);
+  ~TlsCustomVerificationCheckRequest() {}
+
+  grpc::string_ref target_name() const;
+  grpc::string_ref peer_cert() const;
+  grpc::string_ref peer_cert_full_chain() const;
+  grpc::string_ref common_name() const;
+  std::vector<grpc::string_ref> uri_names() const;
+  std::vector<grpc::string_ref> dns_names() const;
+  std::vector<grpc::string_ref> email_names() const;
+  std::vector<grpc::string_ref> ip_names() const;
+
+  grpc_tls_custom_verification_check_request* c_request() { return c_request_; }
+
+ private:
+  grpc_tls_custom_verification_check_request* c_request_ = nullptr;
+};
+
+// The base class of all internal verifier implementations, and the ultimate
+// class that all external verifiers will eventually be transformed into.
+// To implement a custom verifier, do not extend this class; instead,
+// implement a subclass of ExternalCertificateVerifier. Note that custom
+// verifier implementations can compose their functionality with existing
+// implementations of this interface, such as HostnameVerifier, by delegating
+// to an instance of that class.
+class CertificateVerifier {
+ public:
+  explicit CertificateVerifier(grpc_tls_certificate_verifier* v);
+
+  ~CertificateVerifier();
+
+  // Verifies a connection request, based on the logic specified in an internal
+  // verifier. The check on each internal verifier could be either synchronous
+  // or asynchronous, and we will need to use return value to know.
+  //
+  // request: the verification information associated with this request
+  // callback: This will only take effect if the verifier is asynchronous.
+  //           The function that gRPC will invoke when the verifier has already
+  //           completed its asynchronous check. Callers can use this function
+  //           to perform any additional checks. The input parameter of the
+  //           std::function indicates the status of the verifier check.
+  // sync_status: This will only be useful if the verifier is synchronous.
+  //              The status of the verifier as it has already done it's
+  //              synchronous check.
+  // return: return true if executed synchronously, otherwise return false
+  bool Verify(TlsCustomVerificationCheckRequest* request,
+              std::function<void(grpc::Status)> callback,
+              grpc::Status* sync_status);
+
+  // Cancels a verification request previously started via Verify().
+  // Used when the connection attempt times out or is cancelled while an async
+  // verification request is pending.
+  //
+  // request: the verification information associated with this request
+  void Cancel(TlsCustomVerificationCheckRequest* request);
+
+  // Gets the core verifier used internally.
+  grpc_tls_certificate_verifier* c_verifier() { return verifier_; }
+
+ private:
+  static void AsyncCheckDone(
+      grpc_tls_custom_verification_check_request* request, void* callback_arg,
+      grpc_status_code status, const char* error_details);
+
+  grpc_tls_certificate_verifier* verifier_ = nullptr;
+  grpc::internal::Mutex mu_;
+  std::map<grpc_tls_custom_verification_check_request*,
+           std::function<void(grpc::Status)>>
+      request_map_ ABSL_GUARDED_BY(mu_);
+};
+
+// The base class of all external, user-specified verifiers. Users should
+// inherit this class to implement a custom verifier.
+// Note that while implementing the custom verifier that extends this class, it
+// is possible to compose an existing ExternalCertificateVerifier or
+// CertificateVerifier, inside the Verify() and Cancel() function of the new
+// custom verifier.
+class ExternalCertificateVerifier {
+ public:
+  // A factory method for creating a |CertificateVerifier| from this class. All
+  // the user-implemented verifiers should use this function to be converted to
+  // verifiers compatible with |TlsCredentialsOptions|.
+  // The resulting CertificateVerifier takes ownership of the newly instantiated
+  // Subclass.
+  template <typename Subclass, typename... Args>
+  static std::shared_ptr<CertificateVerifier> Create(Args&&... args) {
+    grpc::internal::GrpcLibraryInitializer g_gli_initializer;
+    g_gli_initializer.summon();
+    auto* external_verifier = new Subclass(std::forward<Args>(args)...);
+    return std::make_shared<CertificateVerifier>(
+        grpc_tls_certificate_verifier_external_create(
+            external_verifier->base_));
+  }
+
+  // The verification logic that will be performed after the TLS handshake
+  // completes. Implementers can choose to do their checks synchronously or
+  // asynchronously.
+  //
+  // request: the verification information associated with this request
+  // callback: This should only be used if your check is done asynchronously.
+  //           When the asynchronous work is done, invoke this callback function
+  //           with the proper status, indicating the success or the failure of
+  //           the check. The implementer MUST NOT invoke this |callback| in the
+  //           same thread before Verify() returns, otherwise it can lead to
+  //           deadlocks.
+  // sync_status: This should only be used if your check is done synchronously.
+  //              Modifies this value to indicate the success or the failure of
+  //              the check.
+  // return: return true if your check is done synchronously, otherwise return
+  //         false
+  virtual bool Verify(TlsCustomVerificationCheckRequest* request,
+                      std::function<void(grpc::Status)> callback,
+                      grpc::Status* sync_status) = 0;
+
+  // Cancels a verification request previously started via Verify().
+  // Used when the connection attempt times out or is cancelled while an async
+  // verification request is pending. The implementation should abort whatever
+  // async operation it is waiting for and quickly invoke the callback that was
+  // passed to Verify() with a status indicating the cancellation.
+  //
+  // request: the verification information associated with this request
+  virtual void Cancel(TlsCustomVerificationCheckRequest* request) = 0;
+
+ protected:
+  ExternalCertificateVerifier();
+
+  virtual ~ExternalCertificateVerifier();
+
+ private:
+  struct AsyncRequestState {
+    AsyncRequestState(grpc_tls_on_custom_verification_check_done_cb cb,
+                      void* arg,
+                      grpc_tls_custom_verification_check_request* request)
+        : callback(cb), callback_arg(arg), cpp_request(request) {}
+
+    grpc_tls_on_custom_verification_check_done_cb callback;
+    void* callback_arg;
+    TlsCustomVerificationCheckRequest cpp_request;
+  };
+
+  static int VerifyInCoreExternalVerifier(
+      void* user_data, grpc_tls_custom_verification_check_request* request,
+      grpc_tls_on_custom_verification_check_done_cb callback,
+      void* callback_arg, grpc_status_code* sync_status,
+      char** sync_error_details);
+
+  static void CancelInCoreExternalVerifier(
+      void* user_data, grpc_tls_custom_verification_check_request* request);
+
+  static void DestructInCoreExternalVerifier(void* user_data);
+
+  // TODO(yihuazhang): after the insecure build is removed, make this an object
+  // member instead of a pointer.
+  grpc_tls_certificate_verifier_external* base_ = nullptr;
+  grpc::internal::Mutex mu_;
+  std::map<grpc_tls_custom_verification_check_request*, AsyncRequestState>
+      request_map_ ABSL_GUARDED_BY(mu_);
+};
+
+// A CertificateVerifier that doesn't perform any additional checks other than
+// certificate verification, if specified.
+// Note: using this solely without any other authentication mechanisms on the
+// peer identity will leave your applications to the MITM(Man-In-The-Middle)
+// attacks. Users should avoid doing so in production environments.
+class NoOpCertificateVerifier : public CertificateVerifier {
+ public:
+  NoOpCertificateVerifier();
+};
+
+// A CertificateVerifier that will perform hostname verification, to see if the
+// target name set from the client side matches the identity information
+// specified on the server's certificate.
+class HostNameCertificateVerifier : public CertificateVerifier {
+ public:
+  HostNameCertificateVerifier();
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_TLS_CERTIFICATE_VERIFIER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/tls_credentials_options.h b/CAPI/cpp/grpc/include/grpcpp/security/tls_credentials_options.h
new file mode 100644
index 0000000..220c953
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/security/tls_credentials_options.h
@@ -0,0 +1,157 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SECURITY_TLS_CREDENTIALS_OPTIONS_H
+#define GRPCPP_SECURITY_TLS_CREDENTIALS_OPTIONS_H
+
+#include <memory>
+#include <vector>
+
+#include <grpc/grpc_security.h>
+#include <grpc/grpc_security_constants.h>
+#include <grpc/status.h>
+#include <grpc/support/log.h>
+#include <grpcpp/security/tls_certificate_provider.h>
+#include <grpcpp/security/tls_certificate_verifier.h>
+#include <grpcpp/support/config.h>
+
+namespace grpc {
+namespace experimental {
+
+// Base class of configurable options specified by users to configure their
+// certain security features supported in TLS. It is used for experimental
+// purposes for now and it is subject to change.
+class TlsCredentialsOptions {
+ public:
+  // Constructor for base class TlsCredentialsOptions.
+  //
+  // @param certificate_provider the provider which fetches TLS credentials that
+  // will be used in the TLS handshake
+  TlsCredentialsOptions();
+  // ---- Setters for member fields ----
+  // Sets the certificate provider used to store root certs and identity certs.
+  void set_certificate_provider(
+      std::shared_ptr<CertificateProviderInterface> certificate_provider);
+  // Watches the updates of root certificates with name |root_cert_name|.
+  // If used in TLS credentials, setting this field is optional for both the
+  // client side and the server side.
+  // If this is not set on the client side, we will use the root certificates
+  // stored in the default system location, since client side must provide root
+  // certificates in TLS(no matter single-side TLS or mutual TLS).
+  // If this is not set on the server side, we will not watch any root
+  // certificate updates, and assume no root certificates needed for the server
+  // (in the one-side TLS scenario, the server is not required to provide root
+  // certs). We don't support default root certs on server side.
+  void watch_root_certs();
+  // Sets the name of root certificates being watched, if |watch_root_certs| is
+  // called. If not set, an empty string will be used as the name.
+  //
+  // @param root_cert_name the name of root certs being set.
+  void set_root_cert_name(const std::string& root_cert_name);
+  // Watches the updates of identity key-cert pairs with name
+  // |identity_cert_name|. If used in TLS credentials, it is required to be set
+  // on the server side, and optional for the client side(in the one-side
+  // TLS scenario, the client is not required to provide identity certs).
+  void watch_identity_key_cert_pairs();
+  // Sets the name of identity key-cert pairs being watched, if
+  // |watch_identity_key_cert_pairs| is called. If not set, an empty string will
+  // be used as the name.
+  //
+  // @param identity_cert_name the name of identity key-cert pairs being set.
+  void set_identity_cert_name(const std::string& identity_cert_name);
+  // Sets the Tls session key logging configuration. If not set, tls
+  // session key logging is disabled. Note that this should be used only for
+  // debugging purposes. It should never be used in a production environment
+  // due to security concerns.
+  //
+  // @param tls_session_key_log_file_path: Path where tls session keys would
+  // be logged.
+  void set_tls_session_key_log_file_path(
+      const std::string& tls_session_key_log_file_path);
+  // Sets the certificate verifier used to perform post-handshake peer identity
+  // checks.
+  void set_certificate_verifier(
+      std::shared_ptr<CertificateVerifier> certificate_verifier);
+  // Sets the options of whether to check the hostname of the peer on a per-call
+  // basis. This is usually used in a combination with virtual hosting at the
+  // client side, where each individual call on a channel can have a different
+  // host associated with it.
+  // This check is intended to verify that the host specified for the individual
+  // call is covered by the cert that the peer presented.
+  // We will perform such checks by default. This should be disabled if
+  // verifiers other than the host name verifier is used.
+  void set_check_call_host(bool check_call_host);
+
+  // TODO(zhenlian): This is an experimental API is likely to change in the
+  // future. Before de-experiementalizing, verify the API is up to date.
+  // If set, gRPC will read all hashed x.509 CRL files in the directory and
+  // enforce the CRL files on all TLS handshakes. Only supported for OpenSSL
+  // version > 1.1.
+  void set_crl_directory(const std::string& path);
+
+  // ----- Getters for member fields ----
+  // Get the internal c options. This function shall be used only internally.
+  grpc_tls_credentials_options* c_credentials_options() const {
+    return c_credentials_options_;
+  }
+
+ private:
+  std::shared_ptr<CertificateProviderInterface> certificate_provider_;
+  std::shared_ptr<CertificateVerifier> certificate_verifier_;
+  grpc_tls_credentials_options* c_credentials_options_ = nullptr;
+};
+
+// Contains configurable options on the client side.
+// Client side doesn't need to always use certificate provider. When the
+// certificate provider is not set, we will use the root certificates stored
+// in the system default locations, and assume client won't provide any
+// identity certificates(single side TLS).
+// It is used for experimental purposes for now and it is subject to change.
+class TlsChannelCredentialsOptions final : public TlsCredentialsOptions {
+ public:
+  // Sets the decision of whether to do a crypto check on the server certs.
+  // The default is true.
+  void set_verify_server_certs(bool verify_server_certs);
+
+ private:
+};
+
+// Contains configurable options on the server side.
+// It is used for experimental purposes for now and it is subject to change.
+class TlsServerCredentialsOptions final : public TlsCredentialsOptions {
+ public:
+  // Server side is required to use a provider, because server always needs to
+  // use identity certs.
+  explicit TlsServerCredentialsOptions(
+      std::shared_ptr<CertificateProviderInterface> certificate_provider)
+      : TlsCredentialsOptions() {
+    set_certificate_provider(certificate_provider);
+  }
+
+  // Sets option to request the certificates from the client.
+  // The default is GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE.
+  void set_cert_request_type(
+      grpc_ssl_client_certificate_request_type cert_request_type);
+
+ private:
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+#endif  // GRPCPP_SECURITY_TLS_CREDENTIALS_OPTIONS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/server.h b/CAPI/cpp/grpc/include/grpcpp/server.h
new file mode 100644
index 0000000..dce8744
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/server.h
@@ -0,0 +1,347 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SERVER_H
+#define GRPCPP_SERVER_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <list>
+#include <memory>
+#include <vector>
+
+#include <grpc/compression.h>
+#include <grpc/support/atm.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/completion_queue.h>
+#include <grpcpp/health_check_service_interface.h>
+#include <grpcpp/impl/call.h>
+#include <grpcpp/impl/codegen/client_interceptor.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/grpc_library.h>
+#include <grpcpp/impl/codegen/server_interface.h>
+#include <grpcpp/impl/rpc_service_method.h>
+#include <grpcpp/security/server_credentials.h>
+#include <grpcpp/support/channel_arguments.h>
+#include <grpcpp/support/config.h>
+#include <grpcpp/support/status.h>
+
+struct grpc_server;
+
+namespace grpc {
+class AsyncGenericService;
+class ServerContext;
+class ServerInitializer;
+
+namespace internal {
+class ExternalConnectionAcceptorImpl;
+}  // namespace internal
+
+/// Represents a gRPC server.
+///
+/// Use a \a grpc::ServerBuilder to create, configure, and start
+/// \a Server instances.
+class Server : public ServerInterface, private GrpcLibraryCodegen {
+ public:
+  ~Server() ABSL_LOCKS_EXCLUDED(mu_) override;
+
+  /// Block until the server shuts down.
+  ///
+  /// \warning The server must be either shutting down or some other thread must
+  /// call \a Shutdown for this function to ever return.
+  void Wait() ABSL_LOCKS_EXCLUDED(mu_) override;
+
+  /// Global callbacks are a set of hooks that are called when server
+  /// events occur.  \a SetGlobalCallbacks method is used to register
+  /// the hooks with gRPC.  Note that
+  /// the \a GlobalCallbacks instance will be shared among all
+  /// \a Server instances in an application and can be set exactly
+  /// once per application.
+  class GlobalCallbacks {
+   public:
+    virtual ~GlobalCallbacks() {}
+    /// Called before server is created.
+    virtual void UpdateArguments(ChannelArguments* /*args*/) {}
+    /// Called before application callback for each synchronous server request
+    virtual void PreSynchronousRequest(ServerContext* context) = 0;
+    /// Called after application callback for each synchronous server request
+    virtual void PostSynchronousRequest(ServerContext* context) = 0;
+    /// Called before server is started.
+    virtual void PreServerStart(Server* /*server*/) {}
+    /// Called after a server port is added.
+    virtual void AddPort(Server* /*server*/, const std::string& /*addr*/,
+                         ServerCredentials* /*creds*/, int /*port*/) {}
+  };
+  /// Set the global callback object. Can only be called once per application.
+  /// Does not take ownership of callbacks, and expects the pointed to object
+  /// to be alive until all server objects in the process have been destroyed.
+  /// The same \a GlobalCallbacks object will be used throughout the
+  /// application and is shared among all \a Server objects.
+  static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
+
+  /// Returns a \em raw pointer to the underlying \a grpc_server instance.
+  /// EXPERIMENTAL:  for internal/test use only
+  grpc_server* c_server();
+
+  /// Returns the health check service.
+  HealthCheckServiceInterface* GetHealthCheckService() const {
+    return health_check_service_.get();
+  }
+
+  /// Establish a channel for in-process communication
+  std::shared_ptr<Channel> InProcessChannel(const ChannelArguments& args);
+
+  /// NOTE: class experimental_type is not part of the public API of this class.
+  /// TODO(yashykt): Integrate into public API when this is no longer
+  /// experimental.
+  class experimental_type {
+   public:
+    explicit experimental_type(Server* server) : server_(server) {}
+
+    /// Establish a channel for in-process communication with client
+    /// interceptors
+    std::shared_ptr<Channel> InProcessChannelWithInterceptors(
+        const ChannelArguments& args,
+        std::vector<
+            std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
+            interceptor_creators);
+
+   private:
+    Server* server_;
+  };
+
+  /// NOTE: The function experimental() is not stable public API. It is a view
+  /// to the experimental components of this class. It may be changed or removed
+  /// at any time.
+  experimental_type experimental() { return experimental_type(this); }
+
+ protected:
+  /// Register a service. This call does not take ownership of the service.
+  /// The service must exist for the lifetime of the Server instance.
+  bool RegisterService(const std::string* addr, Service* service) override;
+
+  /// Try binding the server to the given \a addr endpoint
+  /// (port, and optionally including IP address to bind to).
+  ///
+  /// It can be invoked multiple times. Should be used before
+  /// starting the server.
+  ///
+  /// \param addr The address to try to bind to the server (eg, localhost:1234,
+  /// 192.168.1.1:31416, [::1]:27182, etc.).
+  /// \param creds The credentials associated with the server.
+  ///
+  /// \return bound port number on success, 0 on failure.
+  ///
+  /// \warning It is an error to call this method on an already started server.
+  int AddListeningPort(const std::string& addr,
+                       ServerCredentials* creds) override;
+
+  /// NOTE: This is *NOT* a public API. The server constructors are supposed to
+  /// be used by \a ServerBuilder class only. The constructor will be made
+  /// 'private' very soon.
+  ///
+  /// Server constructors. To be used by \a ServerBuilder only.
+  ///
+  /// \param args The channel args
+  ///
+  /// \param sync_server_cqs The completion queues to use if the server is a
+  /// synchronous server (or a hybrid server). The server polls for new RPCs on
+  /// these queues
+  ///
+  /// \param min_pollers The minimum number of polling threads per server
+  /// completion queue (in param sync_server_cqs) to use for listening to
+  /// incoming requests (used only in case of sync server)
+  ///
+  /// \param max_pollers The maximum number of polling threads per server
+  /// completion queue (in param sync_server_cqs) to use for listening to
+  /// incoming requests (used only in case of sync server)
+  ///
+  /// \param sync_cq_timeout_msec The timeout to use when calling AsyncNext() on
+  /// server completion queues passed via sync_server_cqs param.
+  Server(ChannelArguments* args,
+         std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
+             sync_server_cqs,
+         int min_pollers, int max_pollers, int sync_cq_timeout_msec,
+         std::vector<std::shared_ptr<internal::ExternalConnectionAcceptorImpl>>
+             acceptors,
+         grpc_server_config_fetcher* server_config_fetcher = nullptr,
+         grpc_resource_quota* server_rq = nullptr,
+         std::vector<
+             std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>
+             interceptor_creators = std::vector<std::unique_ptr<
+                 experimental::ServerInterceptorFactoryInterface>>());
+
+  /// Start the server.
+  ///
+  /// \param cqs Completion queues for handling asynchronous services. The
+  /// caller is required to keep all completion queues live until the server is
+  /// destroyed.
+  /// \param num_cqs How many completion queues does \a cqs hold.
+  void Start(ServerCompletionQueue** cqs, size_t num_cqs) override;
+
+  grpc_server* server() override { return server_; }
+
+ protected:
+  /// NOTE: This method is not part of the public API for this class.
+  void set_health_check_service(
+      std::unique_ptr<HealthCheckServiceInterface> service) {
+    health_check_service_ = std::move(service);
+  }
+
+  ContextAllocator* context_allocator() { return context_allocator_.get(); }
+
+  /// NOTE: This method is not part of the public API for this class.
+  bool health_check_service_disabled() const {
+    return health_check_service_disabled_;
+  }
+
+ private:
+  std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>*
+  interceptor_creators() override {
+    return &interceptor_creators_;
+  }
+
+  friend class AsyncGenericService;
+  friend class ServerBuilder;
+  friend class ServerInitializer;
+
+  class SyncRequest;
+  class CallbackRequestBase;
+  template <class ServerContextType>
+  class CallbackRequest;
+  class UnimplementedAsyncRequest;
+  class UnimplementedAsyncResponse;
+
+  /// SyncRequestThreadManager is an implementation of ThreadManager. This class
+  /// is responsible for polling for incoming RPCs and calling the RPC handlers.
+  /// This is only used in case of a Sync server (i.e a server exposing a sync
+  /// interface)
+  class SyncRequestThreadManager;
+
+  /// Register a generic service. This call does not take ownership of the
+  /// service. The service must exist for the lifetime of the Server instance.
+  void RegisterAsyncGenericService(AsyncGenericService* service) override;
+
+  /// Register a callback-based generic service. This call does not take
+  /// ownership of theservice. The service must exist for the lifetime of the
+  /// Server instance.
+  void RegisterCallbackGenericService(CallbackGenericService* service) override;
+
+  void RegisterContextAllocator(
+      std::unique_ptr<ContextAllocator> context_allocator) {
+    context_allocator_ = std::move(context_allocator);
+  }
+
+  void PerformOpsOnCall(internal::CallOpSetInterface* ops,
+                        internal::Call* call) override;
+
+  void ShutdownInternal(gpr_timespec deadline)
+      ABSL_LOCKS_EXCLUDED(mu_) override;
+
+  int max_receive_message_size() const override {
+    return max_receive_message_size_;
+  }
+
+  CompletionQueue* CallbackCQ() ABSL_LOCKS_EXCLUDED(mu_) override;
+
+  ServerInitializer* initializer();
+
+  // Functions to manage the server shutdown ref count. Things that increase
+  // the ref count are the running state of the server (take a ref at start and
+  // drop it at shutdown) and each running callback RPC.
+  void Ref();
+  void UnrefWithPossibleNotify() ABSL_LOCKS_EXCLUDED(mu_);
+  void UnrefAndWaitLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  std::vector<std::shared_ptr<internal::ExternalConnectionAcceptorImpl>>
+      acceptors_;
+
+  // A vector of interceptor factory objects.
+  // This should be destroyed after health_check_service_ and this requirement
+  // is satisfied by declaring interceptor_creators_ before
+  // health_check_service_. (C++ mandates that member objects be destroyed in
+  // the reverse order of initialization.)
+  std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>
+      interceptor_creators_;
+
+  int max_receive_message_size_;
+
+  /// The following completion queues are ONLY used in case of Sync API
+  /// i.e. if the server has any services with sync methods. The server uses
+  /// these completion queues to poll for new RPCs
+  std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
+      sync_server_cqs_;
+
+  /// List of \a ThreadManager instances (one for each cq in
+  /// the \a sync_server_cqs)
+  std::vector<std::unique_ptr<SyncRequestThreadManager>> sync_req_mgrs_;
+
+  // Server status
+  internal::Mutex mu_;
+  bool started_;
+  bool shutdown_ ABSL_GUARDED_BY(mu_);
+  bool shutdown_notified_
+      ABSL_GUARDED_BY(mu_);  // Was notify called on the shutdown_cv_
+  internal::CondVar shutdown_done_cv_;
+  bool shutdown_done_ ABSL_GUARDED_BY(mu_) = false;
+  std::atomic_int shutdown_refs_outstanding_{1};
+
+  internal::CondVar shutdown_cv_;
+
+  std::shared_ptr<GlobalCallbacks> global_callbacks_;
+
+  std::vector<std::string> services_;
+  bool has_async_generic_service_ = false;
+  bool has_callback_generic_service_ = false;
+  bool has_callback_methods_ = false;
+
+  // Pointer to the wrapped grpc_server.
+  grpc_server* server_;
+
+  std::unique_ptr<ServerInitializer> server_initializer_;
+
+  std::unique_ptr<ContextAllocator> context_allocator_;
+
+  std::unique_ptr<HealthCheckServiceInterface> health_check_service_;
+  bool health_check_service_disabled_;
+
+  // When appropriate, use a default callback generic service to handle
+  // unimplemented methods
+  std::unique_ptr<CallbackGenericService> unimplemented_service_;
+
+  // A special handler for resource exhausted in sync case
+  std::unique_ptr<internal::MethodHandler> resource_exhausted_handler_;
+
+  // Handler for callback generic service, if any
+  std::unique_ptr<internal::MethodHandler> generic_handler_;
+
+  // callback_cq_ references the callbackable completion queue associated
+  // with this server (if any). It is set on the first call to CallbackCQ().
+  // It is _not owned_ by the server; ownership belongs with its internal
+  // shutdown callback tag (invoked when the CQ is fully shutdown).
+  std::atomic<CompletionQueue*> callback_cq_{nullptr};
+
+  // List of CQs passed in by user that must be Shutdown only after Server is
+  // Shutdown.  Even though this is only used with NDEBUG, instantiate it in all
+  // cases since otherwise the size will be inconsistent.
+  std::vector<CompletionQueue*> cq_list_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_SERVER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/server_builder.h b/CAPI/cpp/grpc/include/grpcpp/server_builder.h
new file mode 100644
index 0000000..2f72a87
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/server_builder.h
@@ -0,0 +1,419 @@
+/*
+ *
+ * Copyright 2015-2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SERVER_BUILDER_H
+#define GRPCPP_SERVER_BUILDER_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <climits>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include <grpc/compression.h>
+#include <grpc/support/cpu.h>
+#include <grpc/support/workaround_list.h>
+#include <grpcpp/impl/channel_argument_option.h>
+#include <grpcpp/impl/codegen/server_interceptor.h>
+#include <grpcpp/impl/server_builder_option.h>
+#include <grpcpp/impl/server_builder_plugin.h>
+#include <grpcpp/security/authorization_policy_provider.h>
+#include <grpcpp/server.h>
+#include <grpcpp/support/config.h>
+
+struct grpc_resource_quota;
+
+namespace grpc {
+
+class CompletionQueue;
+class Server;
+class ServerCompletionQueue;
+class AsyncGenericService;
+class ResourceQuota;
+class ServerCredentials;
+class Service;
+namespace testing {
+class ServerBuilderPluginTest;
+}  // namespace testing
+
+namespace internal {
+class ExternalConnectionAcceptorImpl;
+}  // namespace internal
+
+class CallbackGenericService;
+
+namespace experimental {
+class OrcaServerInterceptorFactory;
+// EXPERIMENTAL API:
+// Interface for a grpc server to build transports with connections created out
+// of band.
+// See ServerBuilder's AddExternalConnectionAcceptor API.
+class ExternalConnectionAcceptor {
+ public:
+  struct NewConnectionParameters {
+    int listener_fd = -1;
+    int fd = -1;
+    ByteBuffer read_buffer;  // data intended for the grpc server
+  };
+  virtual ~ExternalConnectionAcceptor() {}
+  // If called before grpc::Server is started or after it is shut down, the new
+  // connection will be closed.
+  virtual void HandleNewConnection(NewConnectionParameters* p) = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc
+
+namespace grpc {
+
+/// A builder class for the creation and startup of \a grpc::Server instances.
+class ServerBuilder {
+ public:
+  ServerBuilder();
+  virtual ~ServerBuilder();
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Primary API's
+
+  /// Return a running server which is ready for processing calls.
+  /// Before calling, one typically needs to ensure that:
+  ///  1. a service is registered - so that the server knows what to serve
+  ///     (via RegisterService, or RegisterAsyncGenericService)
+  ///  2. a listening port has been added - so the server knows where to receive
+  ///     traffic (via AddListeningPort)
+  ///  3. [for async api only] completion queues have been added via
+  ///     AddCompletionQueue
+  ///
+  ///  Will return a nullptr on errors.
+  virtual std::unique_ptr<grpc::Server> BuildAndStart();
+
+  /// Register a service. This call does not take ownership of the service.
+  /// The service must exist for the lifetime of the \a Server instance returned
+  /// by \a BuildAndStart().
+  /// Matches requests with any :authority
+  ServerBuilder& RegisterService(grpc::Service* service);
+
+  /// Enlists an endpoint \a addr (port with an optional IP address) to
+  /// bind the \a grpc::Server object to be created to.
+  ///
+  /// It can be invoked multiple times.
+  ///
+  /// \param addr_uri The address to try to bind to the server in URI form. If
+  /// the scheme name is omitted, "dns:///" is assumed. To bind to any address,
+  /// please use IPv6 any, i.e., [::]:<port>, which also accepts IPv4
+  /// connections.  Valid values include dns:///localhost:1234,
+  /// 192.168.1.1:31416, dns:///[::1]:27182, etc.
+  /// \param creds The credentials associated with the server.
+  /// \param[out] selected_port If not `nullptr`, gets populated with the port
+  /// number bound to the \a grpc::Server for the corresponding endpoint after
+  /// it is successfully bound by BuildAndStart(), 0 otherwise. AddListeningPort
+  /// does not modify this pointer.
+  ServerBuilder& AddListeningPort(
+      const std::string& addr_uri,
+      std::shared_ptr<grpc::ServerCredentials> creds,
+      int* selected_port = nullptr);
+
+  /// Add a completion queue for handling asynchronous services.
+  ///
+  /// Best performance is typically obtained by using one thread per polling
+  /// completion queue.
+  ///
+  /// Caller is required to shutdown the server prior to shutting down the
+  /// returned completion queue. Caller is also required to drain the
+  /// completion queue after shutting it down. A typical usage scenario:
+  ///
+  /// // While building the server:
+  /// ServerBuilder builder;
+  /// ...
+  /// cq_ = builder.AddCompletionQueue();
+  /// server_ = builder.BuildAndStart();
+  ///
+  /// // While shutting down the server;
+  /// server_->Shutdown();
+  /// cq_->Shutdown();  // Always *after* the associated server's Shutdown()!
+  /// // Drain the cq_ that was created
+  /// void* ignored_tag;
+  /// bool ignored_ok;
+  /// while (cq_->Next(&ignored_tag, &ignored_ok)) { }
+  ///
+  /// \param is_frequently_polled This is an optional parameter to inform gRPC
+  /// library about whether this completion queue would be frequently polled
+  /// (i.e. by calling \a Next() or \a AsyncNext()). The default value is
+  /// 'true' and is the recommended setting. Setting this to 'false' (i.e.
+  /// not polling the completion queue frequently) will have a significantly
+  /// negative performance impact and hence should not be used in production
+  /// use cases.
+  std::unique_ptr<grpc::ServerCompletionQueue> AddCompletionQueue(
+      bool is_frequently_polled = true);
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Less commonly used RegisterService variants
+
+  /// Register a service. This call does not take ownership of the service.
+  /// The service must exist for the lifetime of the \a Server instance
+  /// returned by \a BuildAndStart(). Only matches requests with :authority \a
+  /// host
+  ServerBuilder& RegisterService(const std::string& host,
+                                 grpc::Service* service);
+
+  /// Register a generic service.
+  /// Matches requests with any :authority
+  /// This is mostly useful for writing generic gRPC Proxies where the exact
+  /// serialization format is unknown
+  ServerBuilder& RegisterAsyncGenericService(
+      grpc::AsyncGenericService* service);
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Fine control knobs
+
+  /// Set max receive message size in bytes.
+  /// The default is GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH.
+  ServerBuilder& SetMaxReceiveMessageSize(int max_receive_message_size) {
+    max_receive_message_size_ = max_receive_message_size;
+    return *this;
+  }
+
+  /// Set max send message size in bytes.
+  /// The default is GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH.
+  ServerBuilder& SetMaxSendMessageSize(int max_send_message_size) {
+    max_send_message_size_ = max_send_message_size;
+    return *this;
+  }
+
+  /// \deprecated For backward compatibility.
+  ServerBuilder& SetMaxMessageSize(int max_message_size) {
+    return SetMaxReceiveMessageSize(max_message_size);
+  }
+
+  /// Set the support status for compression algorithms. All algorithms are
+  /// enabled by default.
+  ///
+  /// Incoming calls compressed with an unsupported algorithm will fail with
+  /// \a GRPC_STATUS_UNIMPLEMENTED.
+  ServerBuilder& SetCompressionAlgorithmSupportStatus(
+      grpc_compression_algorithm algorithm, bool enabled);
+
+  /// The default compression level to use for all channel calls in the
+  /// absence of a call-specific level.
+  ServerBuilder& SetDefaultCompressionLevel(grpc_compression_level level);
+
+  /// The default compression algorithm to use for all channel calls in the
+  /// absence of a call-specific level. Note that it overrides any compression
+  /// level set by \a SetDefaultCompressionLevel.
+  ServerBuilder& SetDefaultCompressionAlgorithm(
+      grpc_compression_algorithm algorithm);
+
+  /// Set the attached buffer pool for this server
+  ServerBuilder& SetResourceQuota(const grpc::ResourceQuota& resource_quota);
+
+  ServerBuilder& SetOption(std::unique_ptr<grpc::ServerBuilderOption> option);
+
+  /// Options for synchronous servers.
+  enum SyncServerOption {
+    NUM_CQS,         ///< Number of completion queues.
+    MIN_POLLERS,     ///< Minimum number of polling threads.
+    MAX_POLLERS,     ///< Maximum number of polling threads.
+    CQ_TIMEOUT_MSEC  ///< Completion queue timeout in milliseconds.
+  };
+
+  /// Only useful if this is a Synchronous server.
+  ServerBuilder& SetSyncServerOption(SyncServerOption option, int value);
+
+  /// Add a channel argument (an escape hatch to tuning core library parameters
+  /// directly)
+  template <class T>
+  ServerBuilder& AddChannelArgument(const std::string& arg, const T& value) {
+    return SetOption(grpc::MakeChannelArgumentOption(arg, value));
+  }
+
+  /// For internal use only: Register a ServerBuilderPlugin factory function.
+  static void InternalAddPluginFactory(
+      std::unique_ptr<grpc::ServerBuilderPlugin> (*CreatePlugin)());
+
+  /// Enable a server workaround. Do not use unless you know what the workaround
+  /// does. For explanation and detailed descriptions of workarounds, see
+  /// doc/workarounds.md.
+  ServerBuilder& EnableWorkaround(grpc_workaround_list id);
+
+  /// NOTE: class experimental_type is not part of the public API of this class.
+  /// TODO(yashykt): Integrate into public API when this is no longer
+  /// experimental.
+  class experimental_type {
+   public:
+    explicit experimental_type(ServerBuilder* builder) : builder_(builder) {}
+
+    void SetInterceptorCreators(
+        std::vector<std::unique_ptr<
+            grpc::experimental::ServerInterceptorFactoryInterface>>
+            interceptor_creators) {
+      builder_->interceptor_creators_ = std::move(interceptor_creators);
+    }
+
+    enum class ExternalConnectionType {
+      FROM_FD = 0  // in the form of a file descriptor
+    };
+
+    /// Register an acceptor to handle the externally accepted connection in
+    /// grpc server. The returned acceptor can be used to pass the connection
+    /// to grpc server, where a channel will be created with the provided
+    /// server credentials.
+    std::unique_ptr<grpc::experimental::ExternalConnectionAcceptor>
+    AddExternalConnectionAcceptor(ExternalConnectionType type,
+                                  std::shared_ptr<ServerCredentials> creds);
+
+    /// Sets server authorization policy provider in
+    /// GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER channel argument.
+    void SetAuthorizationPolicyProvider(
+        std::shared_ptr<experimental::AuthorizationPolicyProviderInterface>
+            provider);
+
+   private:
+    ServerBuilder* builder_;
+  };
+
+  /// Set the allocator for creating and releasing callback server context.
+  /// Takes the owndership of the allocator.
+  ServerBuilder& SetContextAllocator(
+      std::unique_ptr<grpc::ContextAllocator> context_allocator);
+
+  /// Register a generic service that uses the callback API.
+  /// Matches requests with any :authority
+  /// This is mostly useful for writing generic gRPC Proxies where the exact
+  /// serialization format is unknown
+  ServerBuilder& RegisterCallbackGenericService(
+      grpc::CallbackGenericService* service);
+
+  /// NOTE: The function experimental() is not stable public API. It is a view
+  /// to the experimental components of this class. It may be changed or removed
+  /// at any time.
+  experimental_type experimental() { return experimental_type(this); }
+
+ protected:
+  /// Experimental, to be deprecated
+  struct Port {
+    std::string addr;
+    std::shared_ptr<ServerCredentials> creds;
+    int* selected_port;
+  };
+
+  /// Experimental, to be deprecated
+  typedef std::unique_ptr<std::string> HostString;
+  struct NamedService {
+    explicit NamedService(grpc::Service* s) : service(s) {}
+    NamedService(const std::string& h, grpc::Service* s)
+        : host(new std::string(h)), service(s) {}
+    HostString host;
+    grpc::Service* service;
+  };
+
+  /// Experimental, to be deprecated
+  std::vector<Port> ports() { return ports_; }
+
+  /// Experimental, to be deprecated
+  std::vector<NamedService*> services() {
+    std::vector<NamedService*> service_refs;
+    for (auto& ptr : services_) {
+      service_refs.push_back(ptr.get());
+    }
+    return service_refs;
+  }
+
+  /// Experimental, to be deprecated
+  std::vector<grpc::ServerBuilderOption*> options() {
+    std::vector<grpc::ServerBuilderOption*> option_refs;
+    for (auto& ptr : options_) {
+      option_refs.push_back(ptr.get());
+    }
+    return option_refs;
+  }
+
+  /// Experimental API, subject to change.
+  void set_fetcher(grpc_server_config_fetcher* server_config_fetcher) {
+    server_config_fetcher_ = server_config_fetcher;
+  }
+
+  /// Experimental API, subject to change.
+  virtual ChannelArguments BuildChannelArgs();
+
+ private:
+  friend class grpc::testing::ServerBuilderPluginTest;
+  friend class grpc::experimental::OrcaServerInterceptorFactory;
+
+  struct SyncServerSettings {
+    SyncServerSettings()
+        : num_cqs(1), min_pollers(1), max_pollers(2), cq_timeout_msec(10000) {}
+
+    /// Number of server completion queues to create to listen to incoming RPCs.
+    int num_cqs;
+
+    /// Minimum number of threads per completion queue that should be listening
+    /// to incoming RPCs.
+    int min_pollers;
+
+    /// Maximum number of threads per completion queue that can be listening to
+    /// incoming RPCs.
+    int max_pollers;
+
+    /// The timeout for server completion queue's AsyncNext call.
+    int cq_timeout_msec;
+  };
+
+  int max_receive_message_size_;
+  int max_send_message_size_;
+  std::vector<std::unique_ptr<grpc::ServerBuilderOption>> options_;
+  std::vector<std::unique_ptr<NamedService>> services_;
+  std::vector<Port> ports_;
+
+  SyncServerSettings sync_server_settings_;
+
+  /// List of completion queues added via \a AddCompletionQueue method.
+  std::vector<grpc::ServerCompletionQueue*> cqs_;
+
+  std::shared_ptr<grpc::ServerCredentials> creds_;
+  std::vector<std::unique_ptr<grpc::ServerBuilderPlugin>> plugins_;
+  grpc_resource_quota* resource_quota_;
+  grpc::AsyncGenericService* generic_service_{nullptr};
+  std::unique_ptr<ContextAllocator> context_allocator_;
+  grpc::CallbackGenericService* callback_generic_service_{nullptr};
+
+  struct {
+    bool is_set;
+    grpc_compression_level level;
+  } maybe_default_compression_level_;
+  struct {
+    bool is_set;
+    grpc_compression_algorithm algorithm;
+  } maybe_default_compression_algorithm_;
+  uint32_t enabled_compression_algorithms_bitset_;
+  std::vector<
+      std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>>
+      interceptor_creators_;
+  std::vector<
+      std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>>
+      internal_interceptor_creators_;
+  std::vector<std::shared_ptr<grpc::internal::ExternalConnectionAcceptorImpl>>
+      acceptors_;
+  grpc_server_config_fetcher* server_config_fetcher_ = nullptr;
+  std::shared_ptr<experimental::AuthorizationPolicyProviderInterface>
+      authorization_provider_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_SERVER_BUILDER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/server_context.h b/CAPI/cpp/grpc/include/grpcpp/server_context.h
new file mode 100644
index 0000000..ed6bd66
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/server_context.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SERVER_CONTEXT_H
+#define GRPCPP_SERVER_CONTEXT_H
+
+#include <grpcpp/impl/codegen/server_context.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SERVER_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/server_posix.h b/CAPI/cpp/grpc/include/grpcpp/server_posix.h
new file mode 100644
index 0000000..2e93862
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/server_posix.h
@@ -0,0 +1,43 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SERVER_POSIX_H
+#define GRPCPP_SERVER_POSIX_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include <grpcpp/server.h>
+
+namespace grpc {
+
+#ifdef GPR_SUPPORT_CHANNELS_FROM_FD
+
+/// Add a new client to a \a Server communicating over the given
+/// file descriptor.
+///
+/// \param server The server to add the client to.
+/// \param fd The file descriptor representing a socket.
+void AddInsecureChannelFromFd(Server* server, int fd);
+
+#endif  // GPR_SUPPORT_CHANNELS_FROM_FD
+
+}  // namespace grpc
+
+#endif  // GRPCPP_SERVER_POSIX_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/async_stream.h b/CAPI/cpp/grpc/include/grpcpp/support/async_stream.h
new file mode 100644
index 0000000..5f71701
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/async_stream.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_ASYNC_STREAM_H
+#define GRPCPP_SUPPORT_ASYNC_STREAM_H
+
+#include <grpcpp/impl/codegen/async_stream.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_ASYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/async_unary_call.h b/CAPI/cpp/grpc/include/grpcpp/support/async_unary_call.h
new file mode 100644
index 0000000..02071e4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/async_unary_call.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H
+#define GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H
+
+#include <grpcpp/impl/codegen/async_unary_call.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_ASYNC_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/byte_buffer.h b/CAPI/cpp/grpc/include/grpcpp/support/byte_buffer.h
new file mode 100644
index 0000000..6f566e7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/byte_buffer.h
@@ -0,0 +1,31 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_BYTE_BUFFER_H
+#define GRPCPP_SUPPORT_BYTE_BUFFER_H
+
+#include <grpc/byte_buffer.h>
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <grpcpp/impl/codegen/byte_buffer.h>  // IWYU pragma: export
+#include <grpcpp/impl/serialization_traits.h>
+#include <grpcpp/support/config.h>
+#include <grpcpp/support/slice.h>
+#include <grpcpp/support/status.h>
+
+#endif  // GRPCPP_SUPPORT_BYTE_BUFFER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/channel_arguments.h b/CAPI/cpp/grpc/include/grpcpp/support/channel_arguments.h
new file mode 100644
index 0000000..afee704
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/channel_arguments.h
@@ -0,0 +1,146 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_CHANNEL_ARGUMENTS_H
+#define GRPCPP_SUPPORT_CHANNEL_ARGUMENTS_H
+
+#include <list>
+#include <vector>
+
+#include <grpc/compression.h>
+#include <grpc/grpc.h>
+#include <grpcpp/resource_quota.h>
+#include <grpcpp/support/config.h>
+
+namespace grpc {
+class SecureChannelCredentials;
+namespace testing {
+class ChannelArgumentsTest;
+}  // namespace testing
+
+/// Options for channel creation. The user can use generic setters to pass
+/// key value pairs down to C channel creation code. For gRPC related options,
+/// concrete setters are provided.
+class ChannelArguments {
+ public:
+  ChannelArguments();
+  ~ChannelArguments();
+
+  ChannelArguments(const ChannelArguments& other);
+  ChannelArguments& operator=(ChannelArguments other) {
+    Swap(other);
+    return *this;
+  }
+
+  void Swap(ChannelArguments& other);
+
+  /// Dump arguments in this instance to \a channel_args. Does not take
+  /// ownership of \a channel_args.
+  ///
+  /// Note that the underlying arguments are shared. Changes made to either \a
+  /// channel_args or this instance would be reflected on both.
+  void SetChannelArgs(grpc_channel_args* channel_args) const;
+
+  // gRPC specific channel argument setters
+  /// Set target name override for SSL host name checking. This option should
+  /// be used with caution in production.
+  void SetSslTargetNameOverride(const std::string& name);
+  // TODO(yangg) add flow control options
+  /// Set the compression algorithm for the channel.
+  void SetCompressionAlgorithm(grpc_compression_algorithm algorithm);
+
+  /// Set the grpclb fallback timeout (in ms) for the channel. If this amount
+  /// of time has passed but we have not gotten any non-empty \a serverlist from
+  /// the balancer, we will fall back to use the backend address(es) returned by
+  /// the resolver.
+  void SetGrpclbFallbackTimeout(int fallback_timeout);
+
+  /// Set a mutator for the underlying socket.
+  void SetSocketMutator(grpc_socket_mutator* mutator);
+
+  /// Set the string to prepend to the user agent.
+  void SetUserAgentPrefix(const std::string& user_agent_prefix);
+
+  /// Set the buffer pool to be attached to the constructed channel.
+  void SetResourceQuota(const grpc::ResourceQuota& resource_quota);
+
+  /// Set the max receive and send message sizes.
+  void SetMaxReceiveMessageSize(int size);
+  void SetMaxSendMessageSize(int size);
+
+  /// Set LB policy name.
+  /// Note that if the name resolver returns only balancer addresses, the
+  /// grpclb LB policy will be used, regardless of what is specified here.
+  void SetLoadBalancingPolicyName(const std::string& lb_policy_name);
+
+  /// Set service config in JSON form.
+  /// Primarily meant for use in unit tests.
+  void SetServiceConfigJSON(const std::string& service_config_json);
+
+  // Generic channel argument setter. Only for advanced use cases.
+  /// Set an integer argument \a value under \a key.
+  void SetInt(const std::string& key, int value);
+
+  // Generic channel argument setter. Only for advanced use cases.
+  /// Set a pointer argument \a value under \a key. Ownership is not
+  /// transferred.
+  void SetPointer(const std::string& key, void* value);
+
+  /// Set a pointer argument \a value under \a key, transferring ownership of
+  /// \a value to the \a ChannelArguments object. The \a vtable::Delete function
+  /// is responsible for \a value cleanup/destruction when called.
+  void SetPointerWithVtable(const std::string& key, void* value,
+                            const grpc_arg_pointer_vtable* vtable);
+
+  /// Set a textual argument \a value under \a key.
+  void SetString(const std::string& key, const std::string& value);
+
+  /// Return (by value) a C \a grpc_channel_args structure which points to
+  /// arguments owned by this \a ChannelArguments instance
+  grpc_channel_args c_channel_args() const {
+    grpc_channel_args out;
+    out.num_args = args_.size();
+    out.args = args_.empty() ? nullptr : const_cast<grpc_arg*>(&args_[0]);
+    return out;
+  }
+
+ private:
+  friend class grpc::SecureChannelCredentials;
+  friend class grpc::testing::ChannelArgumentsTest;
+
+  /// Default pointer argument operations.
+  struct PointerVtableMembers {
+    static void* Copy(void* in) { return in; }
+    static void Destroy(void* /*in*/) {}
+    static int Compare(void* a, void* b) {
+      if (a < b) return -1;
+      if (a > b) return 1;
+      return 0;
+    }
+  };
+
+  // Returns empty string when it is not set.
+  std::string GetSslTargetNameOverride() const;
+
+  std::vector<grpc_arg> args_;
+  std::list<std::string> strings_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPCPP_SUPPORT_CHANNEL_ARGUMENTS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/client_callback.h b/CAPI/cpp/grpc/include/grpcpp/support/client_callback.h
new file mode 100644
index 0000000..c15bca0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/client_callback.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_CLIENT_CALLBACK_H
+#define GRPCPP_SUPPORT_CLIENT_CALLBACK_H
+
+#include <grpcpp/impl/codegen/client_callback.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_CLIENT_CALLBACK_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/client_interceptor.h b/CAPI/cpp/grpc/include/grpcpp/support/client_interceptor.h
new file mode 100644
index 0000000..552cab4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/client_interceptor.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_CLIENT_INTERCEPTOR_H
+#define GRPCPP_SUPPORT_CLIENT_INTERCEPTOR_H
+
+#include <grpcpp/impl/codegen/client_interceptor.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_CLIENT_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/config.h b/CAPI/cpp/grpc/include/grpcpp/support/config.h
new file mode 100644
index 0000000..f2632f2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/config.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_CONFIG_H
+#define GRPCPP_SUPPORT_CONFIG_H
+
+#include <grpcpp/impl/codegen/config.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_CONFIG_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/error_details.h b/CAPI/cpp/grpc/include/grpcpp/support/error_details.h
new file mode 100644
index 0000000..72305e8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/error_details.h
@@ -0,0 +1,76 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_ERROR_DETAILS_H
+#define GRPCPP_SUPPORT_ERROR_DETAILS_H
+
+#include <grpcpp/support/status.h>
+
+namespace grpc {
+
+/// Map a \a grpc::Status to a \a google::rpc::Status.
+/// The given \a to object will be cleared.
+/// On success, returns status with OK.
+/// Returns status with \a INVALID_ARGUMENT, if failed to deserialize.
+/// Returns status with \a FAILED_PRECONDITION, if \a to is nullptr.
+///
+/// \note
+/// This function is a template to avoid a build dep on \a status.proto.
+/// However, this function still requires that \tparam T is of type
+/// \a google::rpc::Status, which is defined at
+/// https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto
+template <typename T>
+grpc::Status ExtractErrorDetails(const grpc::Status& from, T* to) {
+  if (to == nullptr) {
+    return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
+  }
+  if (!to->ParseFromString(from.error_details())) {
+    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, "");
+  }
+  return grpc::Status::OK;
+}
+inline grpc::Status ExtractErrorDetails(const grpc::Status&, std::nullptr_t) {
+  return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
+}
+
+/// Map \a google::rpc::Status to a \a grpc::Status.
+/// Returns OK on success.
+/// Returns status with \a FAILED_PRECONDITION if \a to is nullptr.
+///
+/// \note
+/// This function is a template to avoid a build dep on \a status.proto.
+/// However, this function still requires that \tparam T is of type
+/// \a google::rpc::Status, which is defined at
+/// https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto
+template <typename T>
+grpc::Status SetErrorDetails(const T& from, grpc::Status* to) {
+  if (to == nullptr) {
+    return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
+  }
+  grpc::StatusCode code = grpc::StatusCode::UNKNOWN;
+  if (from.code() >= grpc::StatusCode::OK &&
+      from.code() <= grpc::StatusCode::UNAUTHENTICATED) {
+    code = static_cast<grpc::StatusCode>(from.code());
+  }
+  *to = grpc::Status(code, from.message(), from.SerializeAsString());
+  return grpc::Status::OK;
+}
+
+}  // namespace grpc
+
+#endif  // GRPCPP_SUPPORT_ERROR_DETAILS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/interceptor.h b/CAPI/cpp/grpc/include/grpcpp/support/interceptor.h
new file mode 100644
index 0000000..d4f2ea1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/interceptor.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_INTERCEPTOR_H
+#define GRPCPP_SUPPORT_INTERCEPTOR_H
+
+#include <grpcpp/impl/codegen/interceptor.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/message_allocator.h b/CAPI/cpp/grpc/include/grpcpp/support/message_allocator.h
new file mode 100644
index 0000000..22a963f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/message_allocator.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_MESSAGE_ALLOCATOR_H
+#define GRPCPP_SUPPORT_MESSAGE_ALLOCATOR_H
+
+#include <grpcpp/impl/codegen/message_allocator.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_MESSAGE_ALLOCATOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/method_handler.h b/CAPI/cpp/grpc/include/grpcpp/support/method_handler.h
new file mode 100644
index 0000000..0b97a7a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/method_handler.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_METHOD_HANDLER_H
+#define GRPCPP_SUPPORT_METHOD_HANDLER_H
+
+#include <grpcpp/impl/codegen/method_handler.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_METHOD_HANDLER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/proto_buffer_reader.h b/CAPI/cpp/grpc/include/grpcpp/support/proto_buffer_reader.h
new file mode 100644
index 0000000..07e523e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/proto_buffer_reader.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_PROTO_BUFFER_READER_H
+#define GRPCPP_SUPPORT_PROTO_BUFFER_READER_H
+
+#include <grpcpp/impl/codegen/proto_buffer_reader.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_PROTO_BUFFER_READER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/proto_buffer_writer.h b/CAPI/cpp/grpc/include/grpcpp/support/proto_buffer_writer.h
new file mode 100644
index 0000000..589deb8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/proto_buffer_writer.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_PROTO_BUFFER_WRITER_H
+#define GRPCPP_SUPPORT_PROTO_BUFFER_WRITER_H
+
+#include <grpcpp/impl/codegen/proto_buffer_writer.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_PROTO_BUFFER_WRITER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/server_callback.h b/CAPI/cpp/grpc/include/grpcpp/support/server_callback.h
new file mode 100644
index 0000000..1ffdce5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/server_callback.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_SERVER_CALLBACK_H
+#define GRPCPP_SUPPORT_SERVER_CALLBACK_H
+
+#include <grpcpp/impl/codegen/server_callback.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_SERVER_CALLBACK_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/server_interceptor.h b/CAPI/cpp/grpc/include/grpcpp/support/server_interceptor.h
new file mode 100644
index 0000000..ad9c7a1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/server_interceptor.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_SERVER_INTERCEPTOR_H
+#define GRPCPP_SUPPORT_SERVER_INTERCEPTOR_H
+
+#include <grpcpp/impl/codegen/server_interceptor.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_SERVER_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/slice.h b/CAPI/cpp/grpc/include/grpcpp/support/slice.h
new file mode 100644
index 0000000..2434983
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/slice.h
@@ -0,0 +1,26 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_SLICE_H
+#define GRPCPP_SUPPORT_SLICE_H
+
+#include <grpc/slice.h>
+#include <grpcpp/impl/codegen/slice.h>  // IWYU pragma: export
+#include <grpcpp/support/config.h>
+
+#endif  // GRPCPP_SUPPORT_SLICE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/status.h b/CAPI/cpp/grpc/include/grpcpp/support/status.h
new file mode 100644
index 0000000..e46b46d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/status.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_STATUS_H
+#define GRPCPP_SUPPORT_STATUS_H
+
+#include <grpcpp/impl/codegen/status.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_STATUS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/status_code_enum.h b/CAPI/cpp/grpc/include/grpcpp/support/status_code_enum.h
new file mode 100644
index 0000000..eac697f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/status_code_enum.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_STATUS_CODE_ENUM_H
+#define GRPCPP_SUPPORT_STATUS_CODE_ENUM_H
+
+#include <grpcpp/impl/codegen/status_code_enum.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_STATUS_CODE_ENUM_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/string_ref.h b/CAPI/cpp/grpc/include/grpcpp/support/string_ref.h
new file mode 100644
index 0000000..6cf82be
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/string_ref.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_STRING_REF_H
+#define GRPCPP_SUPPORT_STRING_REF_H
+
+#include <grpcpp/impl/codegen/string_ref.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_STRING_REF_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/stub_options.h b/CAPI/cpp/grpc/include/grpcpp/support/stub_options.h
new file mode 100644
index 0000000..ffe1ad7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/stub_options.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_STUB_OPTIONS_H
+#define GRPCPP_SUPPORT_STUB_OPTIONS_H
+
+#include <grpcpp/impl/codegen/stub_options.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_STUB_OPTIONS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/sync_stream.h b/CAPI/cpp/grpc/include/grpcpp/support/sync_stream.h
new file mode 100644
index 0000000..78a348d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/sync_stream.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_SYNC_STREAM_H
+#define GRPCPP_SUPPORT_SYNC_STREAM_H
+
+#include <grpcpp/impl/codegen/sync_stream.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_SYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/time.h b/CAPI/cpp/grpc/include/grpcpp/support/time.h
new file mode 100644
index 0000000..b5e07b6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/time.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_TIME_H
+#define GRPCPP_SUPPORT_TIME_H
+
+#include <grpcpp/impl/codegen/time.h>  // IWYU pragma: export
+
+#endif  // GRPCPP_SUPPORT_TIME_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/validate_service_config.h b/CAPI/cpp/grpc/include/grpcpp/support/validate_service_config.h
new file mode 100644
index 0000000..4306cb8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/support/validate_service_config.h
@@ -0,0 +1,36 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCPP_SUPPORT_VALIDATE_SERVICE_CONFIG_H
+#define GRPCPP_SUPPORT_VALIDATE_SERVICE_CONFIG_H
+
+#include <grpcpp/support/config.h>
+
+namespace grpc {
+
+namespace experimental {
+/// Validates \a service_config_json. If valid, returns an empty string.
+/// Otherwise, returns the validation error.
+/// TODO(yashykt): Promote it to out of experimental once it is proved useful
+/// and gRFC is accepted.
+std::string ValidateServiceConfigJSON(const std::string& service_config_json);
+}  // namespace experimental
+
+}  // namespace grpc
+
+#endif  // GRPCPP_SUPPORT_VALIDATE_SERVICE_CONFIG_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/xds_server_builder.h b/CAPI/cpp/grpc/include/grpcpp/xds_server_builder.h
new file mode 100644
index 0000000..e2fde72
--- /dev/null
+++ b/CAPI/cpp/grpc/include/grpcpp/xds_server_builder.h
@@ -0,0 +1,123 @@
+//
+//
+// Copyright 2020 gRPC authors.
+//
+// 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.
+//
+//
+
+#ifndef GRPCPP_XDS_SERVER_BUILDER_H
+#define GRPCPP_XDS_SERVER_BUILDER_H
+
+#include <grpc/impl/codegen/port_platform.h>
+
+#include <grpcpp/server_builder.h>
+
+namespace grpc {
+
+class XdsServerServingStatusNotifierInterface {
+ public:
+  struct ServingStatusUpdate {
+    grpc::Status status;
+  };
+
+  virtual ~XdsServerServingStatusNotifierInterface() = default;
+
+  // \a uri contains the listening target associated with the notification. Note
+  // that a single target provided to XdsServerBuilder can get resolved to
+  // multiple listening addresses.
+  // The callback is invoked each time there is an update to the serving status.
+  // The API does not provide any guarantees around duplicate updates.
+  // Status::OK signifies that the server is serving, while a non-OK status
+  // signifies that the server is not serving.
+  virtual void OnServingStatusUpdate(std::string uri,
+                                     ServingStatusUpdate update) = 0;
+};
+
+class XdsServerBuilder : public grpc::ServerBuilder {
+ public:
+  // NOTE: class experimental_type is not part of the public API of this class
+  // TODO(yashykt): Integrate into public API when this is no longer
+  // experimental.
+  class experimental_type : public grpc::ServerBuilder::experimental_type {
+   public:
+    explicit experimental_type(XdsServerBuilder* builder)
+        : ServerBuilder::experimental_type(builder), builder_(builder) {}
+
+    // EXPERIMENTAL: Sets the drain grace period in ms for older connections
+    // when updates to a Listener is received.
+    void set_drain_grace_time(int drain_grace_time_ms) {
+      builder_->drain_grace_time_ms_ = drain_grace_time_ms;
+    }
+
+   private:
+    XdsServerBuilder* builder_;
+  };
+
+  // It is the responsibility of the application to make sure that \a notifier
+  // outlasts the life of the server. Notifications will start being made
+  // asynchronously once `BuildAndStart()` has been called. Note that it is
+  // possible for notifications to be made before `BuildAndStart()` returns.
+  void set_status_notifier(XdsServerServingStatusNotifierInterface* notifier) {
+    notifier_ = notifier;
+  }
+
+  /// NOTE: The function experimental() is not stable public API. It is a view
+  /// to the experimental components of this class. It may be changed or removed
+  /// at any time.
+  experimental_type experimental() { return experimental_type(this); }
+
+ private:
+  // Called at the beginning of BuildAndStart().
+  ChannelArguments BuildChannelArgs() override {
+    ChannelArguments args = ServerBuilder::BuildChannelArgs();
+    if (drain_grace_time_ms_ >= 0) {
+      args.SetInt(GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS,
+                  drain_grace_time_ms_);
+    }
+    grpc_channel_args c_channel_args = args.c_channel_args();
+    grpc_server_config_fetcher* fetcher = grpc_server_config_fetcher_xds_create(
+        {OnServingStatusUpdate, notifier_}, &c_channel_args);
+    if (fetcher != nullptr) set_fetcher(fetcher);
+    return args;
+  }
+
+  static void OnServingStatusUpdate(void* user_data, const char* uri,
+                                    grpc_serving_status_update update) {
+    if (user_data == nullptr) return;
+    XdsServerServingStatusNotifierInterface* notifier =
+        static_cast<XdsServerServingStatusNotifierInterface*>(user_data);
+    notifier->OnServingStatusUpdate(
+        uri, {grpc::Status(static_cast<StatusCode>(update.code),
+                           update.error_message)});
+  }
+
+  XdsServerServingStatusNotifierInterface* notifier_ = nullptr;
+  int drain_grace_time_ms_ = -1;
+};
+
+namespace experimental {
+// TODO(yashykt): Delete this after the 1.42 release.
+GRPC_DEPRECATED(
+    "Use grpc::XdsServerServingStatusNotifierInterface instead. The "
+    "experimental version will be deleted after the 1.42 release.")
+typedef grpc::XdsServerServingStatusNotifierInterface
+    XdsServerServingStatusNotifierInterface;
+GRPC_DEPRECATED(
+    "Use grpc::XdsServerBuilder instead. The experimental version will be "
+    "deleted after the 1.42 release.")
+typedef grpc::XdsServerBuilder XdsServerBuilder;
+}  // namespace experimental
+}  // namespace grpc
+
+#endif /* GRPCPP_XDS_SERVER_BUILDER_H */
diff --git a/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_EPILOGUE.H b/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_EPILOGUE.H
new file mode 100644
index 0000000..d251d0a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_EPILOGUE.H
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * This file is only used by HP C/C++ on VMS, and is included automatically
+ * after each header file from this directory
+ */
+
+/*
+ * The C++ compiler doesn't understand these pragmas, even though it
+ * understands the corresponding command line qualifier.
+ */
+#ifndef __cplusplus
+/* restore state.  Must correspond to the save in __decc_include_prologue.h */
+# pragma names restore
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_PROLOGUE.H b/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_PROLOGUE.H
new file mode 100644
index 0000000..91ac6b3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_PROLOGUE.H
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * This file is only used by HP C/C++ on VMS, and is included automatically
+ * after each header file from this directory
+ */
+
+/*
+ * The C++ compiler doesn't understand these pragmas, even though it
+ * understands the corresponding command line qualifier.
+ */
+#ifndef __cplusplus
+/* save state */
+# pragma names save
+/* have the compiler shorten symbols larger than 31 chars to 23 chars
+ * followed by a 8 hex char CRC
+ */
+# pragma names as_is,shortened
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/aes.h b/CAPI/cpp/grpc/include/openssl/aes.h
new file mode 100644
index 0000000..d0f9dfc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/aes.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2002-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_AES_H
+# define OPENSSL_AES_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_AES_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define AES_BLOCK_SIZE 16
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#  define AES_ENCRYPT     1
+#  define AES_DECRYPT     0
+
+#  define AES_MAXNR 14
+
+
+/* This should be a hidden type, but EVP requires that the size be known */
+struct aes_key_st {
+#  ifdef AES_LONG
+    unsigned long rd_key[4 * (AES_MAXNR + 1)];
+#  else
+    unsigned int rd_key[4 * (AES_MAXNR + 1)];
+#  endif
+    int rounds;
+};
+typedef struct aes_key_st AES_KEY;
+
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *AES_options(void);
+OSSL_DEPRECATEDIN_3_0
+int AES_set_encrypt_key(const unsigned char *userKey, const int bits,
+                        AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+int AES_set_decrypt_key(const unsigned char *userKey, const int bits,
+                        AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_encrypt(const unsigned char *in, unsigned char *out,
+                 const AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_decrypt(const unsigned char *in, unsigned char *out,
+                 const AES_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void AES_ecb_encrypt(const unsigned char *in, unsigned char *out,
+                     const AES_KEY *key, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
+                     size_t length, const AES_KEY *key,
+                     unsigned char *ivec, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out,
+                        size_t length, const AES_KEY *key,
+                        unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out,
+                      size_t length, const AES_KEY *key,
+                      unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out,
+                      size_t length, const AES_KEY *key,
+                      unsigned char *ivec, int *num, const int enc);
+OSSL_DEPRECATEDIN_3_0
+void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out,
+                        size_t length, const AES_KEY *key,
+                        unsigned char *ivec, int *num);
+
+/* NB: the IV is _two_ blocks long */
+OSSL_DEPRECATEDIN_3_0
+void AES_ige_encrypt(const unsigned char *in, unsigned char *out,
+                     size_t length, const AES_KEY *key,
+                     unsigned char *ivec, const int enc);
+/* NB: the IV is _four_ blocks long */
+OSSL_DEPRECATEDIN_3_0
+void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
+                        size_t length, const AES_KEY *key, const AES_KEY *key2,
+                        const unsigned char *ivec, const int enc);
+OSSL_DEPRECATEDIN_3_0
+int AES_wrap_key(AES_KEY *key, const unsigned char *iv,
+                 unsigned char *out, const unsigned char *in,
+                 unsigned int inlen);
+OSSL_DEPRECATEDIN_3_0
+int AES_unwrap_key(AES_KEY *key, const unsigned char *iv,
+                   unsigned char *out, const unsigned char *in,
+                   unsigned int inlen);
+# endif
+
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/asn1.h b/CAPI/cpp/grpc/include/openssl/asn1.h
new file mode 100644
index 0000000..aada23d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/asn1.h
@@ -0,0 +1,1128 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\asn1.h.in
+ *
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_ASN1_H
+# define OPENSSL_ASN1_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ASN1_H
+# endif
+
+# include <time.h>
+# include <openssl/e_os2.h>
+# include <openssl/opensslconf.h>
+# include <openssl/bio.h>
+# include <openssl/safestack.h>
+# include <openssl/asn1err.h>
+# include <openssl/symhacks.h>
+
+# include <openssl/types.h>
+# include <openssl/bn.h>
+
+# ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#  undef OPENSSL_EXTERN
+#  define OPENSSL_EXTERN OPENSSL_EXPORT
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define V_ASN1_UNIVERSAL                0x00
+# define V_ASN1_APPLICATION              0x40
+# define V_ASN1_CONTEXT_SPECIFIC         0x80
+# define V_ASN1_PRIVATE                  0xc0
+
+# define V_ASN1_CONSTRUCTED              0x20
+# define V_ASN1_PRIMITIVE_TAG            0x1f
+# define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG
+
+# define V_ASN1_APP_CHOOSE               -2/* let the recipient choose */
+# define V_ASN1_OTHER                    -3/* used in ASN1_TYPE */
+# define V_ASN1_ANY                      -4/* used in ASN1 template code */
+
+# define V_ASN1_UNDEF                    -1
+/* ASN.1 tag values */
+# define V_ASN1_EOC                      0
+# define V_ASN1_BOOLEAN                  1 /**/
+# define V_ASN1_INTEGER                  2
+# define V_ASN1_BIT_STRING               3
+# define V_ASN1_OCTET_STRING             4
+# define V_ASN1_NULL                     5
+# define V_ASN1_OBJECT                   6
+# define V_ASN1_OBJECT_DESCRIPTOR        7
+# define V_ASN1_EXTERNAL                 8
+# define V_ASN1_REAL                     9
+# define V_ASN1_ENUMERATED               10
+# define V_ASN1_UTF8STRING               12
+# define V_ASN1_SEQUENCE                 16
+# define V_ASN1_SET                      17
+# define V_ASN1_NUMERICSTRING            18 /**/
+# define V_ASN1_PRINTABLESTRING          19
+# define V_ASN1_T61STRING                20
+# define V_ASN1_TELETEXSTRING            20/* alias */
+# define V_ASN1_VIDEOTEXSTRING           21 /**/
+# define V_ASN1_IA5STRING                22
+# define V_ASN1_UTCTIME                  23
+# define V_ASN1_GENERALIZEDTIME          24 /**/
+# define V_ASN1_GRAPHICSTRING            25 /**/
+# define V_ASN1_ISO64STRING              26 /**/
+# define V_ASN1_VISIBLESTRING            26/* alias */
+# define V_ASN1_GENERALSTRING            27 /**/
+# define V_ASN1_UNIVERSALSTRING          28 /**/
+# define V_ASN1_BMPSTRING                30
+
+/*
+ * NB the constants below are used internally by ASN1_INTEGER
+ * and ASN1_ENUMERATED to indicate the sign. They are *not* on
+ * the wire tag values.
+ */
+
+# define V_ASN1_NEG                      0x100
+# define V_ASN1_NEG_INTEGER              (2 | V_ASN1_NEG)
+# define V_ASN1_NEG_ENUMERATED           (10 | V_ASN1_NEG)
+
+/* For use with d2i_ASN1_type_bytes() */
+# define B_ASN1_NUMERICSTRING    0x0001
+# define B_ASN1_PRINTABLESTRING  0x0002
+# define B_ASN1_T61STRING        0x0004
+# define B_ASN1_TELETEXSTRING    0x0004
+# define B_ASN1_VIDEOTEXSTRING   0x0008
+# define B_ASN1_IA5STRING        0x0010
+# define B_ASN1_GRAPHICSTRING    0x0020
+# define B_ASN1_ISO64STRING      0x0040
+# define B_ASN1_VISIBLESTRING    0x0040
+# define B_ASN1_GENERALSTRING    0x0080
+# define B_ASN1_UNIVERSALSTRING  0x0100
+# define B_ASN1_OCTET_STRING     0x0200
+# define B_ASN1_BIT_STRING       0x0400
+# define B_ASN1_BMPSTRING        0x0800
+# define B_ASN1_UNKNOWN          0x1000
+# define B_ASN1_UTF8STRING       0x2000
+# define B_ASN1_UTCTIME          0x4000
+# define B_ASN1_GENERALIZEDTIME  0x8000
+# define B_ASN1_SEQUENCE         0x10000
+/* For use with ASN1_mbstring_copy() */
+# define MBSTRING_FLAG           0x1000
+# define MBSTRING_UTF8           (MBSTRING_FLAG)
+# define MBSTRING_ASC            (MBSTRING_FLAG|1)
+# define MBSTRING_BMP            (MBSTRING_FLAG|2)
+# define MBSTRING_UNIV           (MBSTRING_FLAG|4)
+# define SMIME_OLDMIME           0x400
+# define SMIME_CRLFEOL           0x800
+# define SMIME_STREAM            0x1000
+
+/* Stacks for types not otherwise defined in this header */
+SKM_DEFINE_STACK_OF_INTERNAL(X509_ALGOR, X509_ALGOR, X509_ALGOR)
+#define sk_X509_ALGOR_num(sk) OPENSSL_sk_num(ossl_check_const_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_value(sk, idx) ((X509_ALGOR *)OPENSSL_sk_value(ossl_check_const_X509_ALGOR_sk_type(sk), (idx)))
+#define sk_X509_ALGOR_new(cmp) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new(ossl_check_X509_ALGOR_compfunc_type(cmp)))
+#define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_null())
+#define sk_X509_ALGOR_new_reserve(cmp, n) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_reserve(ossl_check_X509_ALGOR_compfunc_type(cmp), (n)))
+#define sk_X509_ALGOR_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_ALGOR_sk_type(sk), (n))
+#define sk_X509_ALGOR_free(sk) OPENSSL_sk_free(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_zero(sk) OPENSSL_sk_zero(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_delete(sk, i) ((X509_ALGOR *)OPENSSL_sk_delete(ossl_check_X509_ALGOR_sk_type(sk), (i)))
+#define sk_X509_ALGOR_delete_ptr(sk, ptr) ((X509_ALGOR *)OPENSSL_sk_delete_ptr(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr)))
+#define sk_X509_ALGOR_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_pop(sk) ((X509_ALGOR *)OPENSSL_sk_pop(ossl_check_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_shift(sk) ((X509_ALGOR *)OPENSSL_sk_shift(ossl_check_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ALGOR_sk_type(sk),ossl_check_X509_ALGOR_freefunc_type(freefunc))
+#define sk_X509_ALGOR_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), (idx))
+#define sk_X509_ALGOR_set(sk, idx, ptr) ((X509_ALGOR *)OPENSSL_sk_set(ossl_check_X509_ALGOR_sk_type(sk), (idx), ossl_check_X509_ALGOR_type(ptr)))
+#define sk_X509_ALGOR_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
+#define sk_X509_ALGOR_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), pnum)
+#define sk_X509_ALGOR_sort(sk) OPENSSL_sk_sort(ossl_check_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_ALGOR_sk_type(sk))
+#define sk_X509_ALGOR_dup(sk) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_dup(ossl_check_const_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_copyfunc_type(copyfunc), ossl_check_X509_ALGOR_freefunc_type(freefunc)))
+#define sk_X509_ALGOR_set_cmp_func(sk, cmp) ((sk_X509_ALGOR_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_compfunc_type(cmp)))
+
+
+
+# define ASN1_STRING_FLAG_BITS_LEFT 0x08/* Set if 0x07 has bits left value */
+/*
+ * This indicates that the ASN1_STRING is not a real value but just a place
+ * holder for the location where indefinite length constructed data should be
+ * inserted in the memory buffer
+ */
+# define ASN1_STRING_FLAG_NDEF 0x010
+
+/*
+ * This flag is used by the CMS code to indicate that a string is not
+ * complete and is a place holder for content when it had all been accessed.
+ * The flag will be reset when content has been written to it.
+ */
+
+# define ASN1_STRING_FLAG_CONT 0x020
+/*
+ * This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING
+ * type.
+ */
+# define ASN1_STRING_FLAG_MSTRING 0x040
+/* String is embedded and only content should be freed */
+# define ASN1_STRING_FLAG_EMBED 0x080
+/* String should be parsed in RFC 5280's time format */
+# define ASN1_STRING_FLAG_X509_TIME 0x100
+/* This is the base type that holds just about everything :-) */
+struct asn1_string_st {
+    int length;
+    int type;
+    unsigned char *data;
+    /*
+     * The value of the following field depends on the type being held.  It
+     * is mostly being used for BIT_STRING so if the input data has a
+     * non-zero 'unused bits' value, it will be handled correctly
+     */
+    long flags;
+};
+
+/*
+ * ASN1_ENCODING structure: this is used to save the received encoding of an
+ * ASN1 type. This is useful to get round problems with invalid encodings
+ * which can break signatures.
+ */
+
+typedef struct ASN1_ENCODING_st {
+    unsigned char *enc;         /* DER encoding */
+    long len;                   /* Length of encoding */
+    int modified;               /* set to 1 if 'enc' is invalid */
+} ASN1_ENCODING;
+
+/* Used with ASN1 LONG type: if a long is set to this it is omitted */
+# define ASN1_LONG_UNDEF 0x7fffffffL
+
+# define STABLE_FLAGS_MALLOC     0x01
+/*
+ * A zero passed to ASN1_STRING_TABLE_new_add for the flags is interpreted
+ * as "don't change" and STABLE_FLAGS_MALLOC is always set. By setting
+ * STABLE_FLAGS_MALLOC only we can clear the existing value. Use the alias
+ * STABLE_FLAGS_CLEAR to reflect this.
+ */
+# define STABLE_FLAGS_CLEAR      STABLE_FLAGS_MALLOC
+# define STABLE_NO_MASK          0x02
+# define DIRSTRING_TYPE  \
+ (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING)
+# define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING)
+
+struct asn1_string_table_st {
+    int nid;
+    long minsize;
+    long maxsize;
+    unsigned long mask;
+    unsigned long flags;
+};
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING_TABLE, ASN1_STRING_TABLE, ASN1_STRING_TABLE)
+#define sk_ASN1_STRING_TABLE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_value(sk, idx) ((ASN1_STRING_TABLE *)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), (idx)))
+#define sk_ASN1_STRING_TABLE_new(cmp) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
+#define sk_ASN1_STRING_TABLE_new_null() ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_STRING_TABLE_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp), (n)))
+#define sk_ASN1_STRING_TABLE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (n))
+#define sk_ASN1_STRING_TABLE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_delete(sk, i) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (i)))
+#define sk_ASN1_STRING_TABLE_delete_ptr(sk, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr)))
+#define sk_ASN1_STRING_TABLE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_pop(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_pop(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_shift(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_shift(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk),ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc))
+#define sk_ASN1_STRING_TABLE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), (idx))
+#define sk_ASN1_STRING_TABLE_set(sk, idx, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_set(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (idx), ossl_check_ASN1_STRING_TABLE_type(ptr)))
+#define sk_ASN1_STRING_TABLE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
+#define sk_ASN1_STRING_TABLE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), pnum)
+#define sk_ASN1_STRING_TABLE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))
+#define sk_ASN1_STRING_TABLE_dup(sk) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc)))
+#define sk_ASN1_STRING_TABLE_set_cmp_func(sk, cmp) ((sk_ASN1_STRING_TABLE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
+
+
+/* size limits: this stuff is taken straight from RFC2459 */
+
+# define ub_name                         32768
+# define ub_common_name                  64
+# define ub_locality_name                128
+# define ub_state_name                   128
+# define ub_organization_name            64
+# define ub_organization_unit_name       64
+# define ub_title                        64
+# define ub_email_address                128
+
+/*
+ * Declarations for template structures: for full definitions see asn1t.h
+ */
+typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
+typedef struct ASN1_TLC_st ASN1_TLC;
+/* This is just an opaque pointer */
+typedef struct ASN1_VALUE_st ASN1_VALUE;
+
+/* Declare ASN1 functions: the implement macro in in asn1t.h */
+
+/*
+ * The mysterious 'extern' that's passed to some macros is innocuous,
+ * and is there to quiet pre-C99 compilers that may complain about empty
+ * arguments in macro calls.
+ */
+
+# define DECLARE_ASN1_FUNCTIONS_attr(attr, type)                            \
+    DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, type)
+# define DECLARE_ASN1_FUNCTIONS(type)                                       \
+    DECLARE_ASN1_FUNCTIONS_attr(extern, type)
+
+# define DECLARE_ASN1_ALLOC_FUNCTIONS_attr(attr, type)                      \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, type)
+# define DECLARE_ASN1_ALLOC_FUNCTIONS(type)                                 \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_attr(extern, type)
+
+# define DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, name)                 \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name)                \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)
+# define DECLARE_ASN1_FUNCTIONS_name(type, name)                            \
+    DECLARE_ASN1_FUNCTIONS_name_attr(extern, type, name)
+
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, itname, name)       \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)               \
+    DECLARE_ASN1_ITEM_attr(attr, itname)
+# define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)                  \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_attr(extern, type, itname, name)
+
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)          \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, name, name)
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_name(type, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(extern, type, name)
+
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)          \
+    attr type *d2i_##name(type **a, const unsigned char **in, long len);    \
+    attr int i2d_##name(const type *a, unsigned char **out);
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_only(type, name)                     \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(extern, type, name)
+
+# define DECLARE_ASN1_NDEF_FUNCTION_attr(attr, name)                        \
+    attr int i2d_##name##_NDEF(const name *a, unsigned char **out);
+# define DECLARE_ASN1_NDEF_FUNCTION(name)                                   \
+    DECLARE_ASN1_NDEF_FUNCTION_attr(extern, name)
+
+# define DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name)           \
+    attr type *name##_new(void);                                            \
+    attr void name##_free(type *a);
+# define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name)                      \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(extern, type, name)
+
+# define DECLARE_ASN1_DUP_FUNCTION_attr(attr, type)                         \
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, type)
+# define DECLARE_ASN1_DUP_FUNCTION(type)                                    \
+    DECLARE_ASN1_DUP_FUNCTION_attr(extern, type)
+
+# define DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, name)              \
+    attr type *name##_dup(const type *a);
+# define DECLARE_ASN1_DUP_FUNCTION_name(type, name)                         \
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(extern, type, name)
+
+# define DECLARE_ASN1_PRINT_FUNCTION_attr(attr, stname)                     \
+    DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, stname)
+# define DECLARE_ASN1_PRINT_FUNCTION(stname)                                \
+    DECLARE_ASN1_PRINT_FUNCTION_attr(extern, stname)
+
+# define DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, fname)        \
+    attr int fname##_print_ctx(BIO *out, const stname *x, int indent,       \
+                               const ASN1_PCTX *pctx);
+# define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname)                   \
+    DECLARE_ASN1_PRINT_FUNCTION_fname_attr(extern, stname, fname)
+
+# define D2I_OF(type) type *(*)(type **,const unsigned char **,long)
+# define I2D_OF(type) int (*)(const type *,unsigned char **)
+
+# define CHECKED_D2I_OF(type, d2i) \
+    ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0)))
+# define CHECKED_I2D_OF(type, i2d) \
+    ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0)))
+# define CHECKED_NEW_OF(type, xnew) \
+    ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0)))
+# define CHECKED_PTR_OF(type, p) \
+    ((void*) (1 ? p : (type*)0))
+# define CHECKED_PPTR_OF(type, p) \
+    ((void**) (1 ? p : (type**)0))
+
+# define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long)
+# define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(const type *,unsigned char **)
+# define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type)
+
+typedef void *d2i_of_void(void **, const unsigned char **, long);
+typedef int i2d_of_void(const void *, unsigned char **);
+
+/*-
+ * The following macros and typedefs allow an ASN1_ITEM
+ * to be embedded in a structure and referenced. Since
+ * the ASN1_ITEM pointers need to be globally accessible
+ * (possibly from shared libraries) they may exist in
+ * different forms. On platforms that support it the
+ * ASN1_ITEM structure itself will be globally exported.
+ * Other platforms will export a function that returns
+ * an ASN1_ITEM pointer.
+ *
+ * To handle both cases transparently the macros below
+ * should be used instead of hard coding an ASN1_ITEM
+ * pointer in a structure.
+ *
+ * The structure will look like this:
+ *
+ * typedef struct SOMETHING_st {
+ *      ...
+ *      ASN1_ITEM_EXP *iptr;
+ *      ...
+ * } SOMETHING;
+ *
+ * It would be initialised as e.g.:
+ *
+ * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...};
+ *
+ * and the actual pointer extracted with:
+ *
+ * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr);
+ *
+ * Finally an ASN1_ITEM pointer can be extracted from an
+ * appropriate reference with: ASN1_ITEM_rptr(X509). This
+ * would be used when a function takes an ASN1_ITEM * argument.
+ *
+ */
+
+
+/*
+ * Platforms that can't easily handle shared global variables are declared as
+ * functions returning ASN1_ITEM pointers.
+ */
+
+/* ASN1_ITEM pointer exported type */
+typedef const ASN1_ITEM *ASN1_ITEM_EXP (void);
+
+/* Macro to obtain ASN1_ITEM pointer from exported type */
+# define ASN1_ITEM_ptr(iptr) (iptr())
+
+/* Macro to include ASN1_ITEM pointer from base type */
+# define ASN1_ITEM_ref(iptr) (iptr##_it)
+
+# define ASN1_ITEM_rptr(ref) (ref##_it())
+
+# define DECLARE_ASN1_ITEM_attr(attr, name)                                 \
+    attr const ASN1_ITEM * name##_it(void);
+# define DECLARE_ASN1_ITEM(name)                                            \
+    DECLARE_ASN1_ITEM_attr(extern, name)
+
+/* Parameters used by ASN1_STRING_print_ex() */
+
+/*
+ * These determine which characters to escape: RFC2253 special characters,
+ * control characters and MSB set characters
+ */
+
+# define ASN1_STRFLGS_ESC_2253           1
+# define ASN1_STRFLGS_ESC_CTRL           2
+# define ASN1_STRFLGS_ESC_MSB            4
+
+/* Lower 8 bits are reserved as an output type specifier */
+# define ASN1_DTFLGS_TYPE_MASK    0x0FUL
+# define ASN1_DTFLGS_RFC822       0x00UL
+# define ASN1_DTFLGS_ISO8601      0x01UL
+
+/*
+ * This flag determines how we do escaping: normally RC2253 backslash only,
+ * set this to use backslash and quote.
+ */
+
+# define ASN1_STRFLGS_ESC_QUOTE          8
+
+/* These three flags are internal use only. */
+
+/* Character is a valid PrintableString character */
+# define CHARTYPE_PRINTABLESTRING        0x10
+/* Character needs escaping if it is the first character */
+# define CHARTYPE_FIRST_ESC_2253         0x20
+/* Character needs escaping if it is the last character */
+# define CHARTYPE_LAST_ESC_2253          0x40
+
+/*
+ * NB the internal flags are safely reused below by flags handled at the top
+ * level.
+ */
+
+/*
+ * If this is set we convert all character strings to UTF8 first
+ */
+
+# define ASN1_STRFLGS_UTF8_CONVERT       0x10
+
+/*
+ * If this is set we don't attempt to interpret content: just assume all
+ * strings are 1 byte per character. This will produce some pretty odd
+ * looking output!
+ */
+
+# define ASN1_STRFLGS_IGNORE_TYPE        0x20
+
+/* If this is set we include the string type in the output */
+# define ASN1_STRFLGS_SHOW_TYPE          0x40
+
+/*
+ * This determines which strings to display and which to 'dump' (hex dump of
+ * content octets or DER encoding). We can only dump non character strings or
+ * everything. If we don't dump 'unknown' they are interpreted as character
+ * strings with 1 octet per character and are subject to the usual escaping
+ * options.
+ */
+
+# define ASN1_STRFLGS_DUMP_ALL           0x80
+# define ASN1_STRFLGS_DUMP_UNKNOWN       0x100
+
+/*
+ * These determine what 'dumping' does, we can dump the content octets or the
+ * DER encoding: both use the RFC2253 #XXXXX notation.
+ */
+
+# define ASN1_STRFLGS_DUMP_DER           0x200
+
+/*
+ * This flag specifies that RC2254 escaping shall be performed.
+ */
+#define ASN1_STRFLGS_ESC_2254           0x400
+
+/*
+ * All the string flags consistent with RFC2253, escaping control characters
+ * isn't essential in RFC2253 but it is advisable anyway.
+ */
+
+# define ASN1_STRFLGS_RFC2253    (ASN1_STRFLGS_ESC_2253 | \
+                                ASN1_STRFLGS_ESC_CTRL | \
+                                ASN1_STRFLGS_ESC_MSB | \
+                                ASN1_STRFLGS_UTF8_CONVERT | \
+                                ASN1_STRFLGS_DUMP_UNKNOWN | \
+                                ASN1_STRFLGS_DUMP_DER)
+
+
+struct asn1_type_st {
+    int type;
+    union {
+        char *ptr;
+        ASN1_BOOLEAN boolean;
+        ASN1_STRING *asn1_string;
+        ASN1_OBJECT *object;
+        ASN1_INTEGER *integer;
+        ASN1_ENUMERATED *enumerated;
+        ASN1_BIT_STRING *bit_string;
+        ASN1_OCTET_STRING *octet_string;
+        ASN1_PRINTABLESTRING *printablestring;
+        ASN1_T61STRING *t61string;
+        ASN1_IA5STRING *ia5string;
+        ASN1_GENERALSTRING *generalstring;
+        ASN1_BMPSTRING *bmpstring;
+        ASN1_UNIVERSALSTRING *universalstring;
+        ASN1_UTCTIME *utctime;
+        ASN1_GENERALIZEDTIME *generalizedtime;
+        ASN1_VISIBLESTRING *visiblestring;
+        ASN1_UTF8STRING *utf8string;
+        /*
+         * set and sequence are left complete and still contain the set or
+         * sequence bytes
+         */
+        ASN1_STRING *set;
+        ASN1_STRING *sequence;
+        ASN1_VALUE *asn1_value;
+    } value;
+};
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_TYPE, ASN1_TYPE, ASN1_TYPE)
+#define sk_ASN1_TYPE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_value(sk, idx) ((ASN1_TYPE *)OPENSSL_sk_value(ossl_check_const_ASN1_TYPE_sk_type(sk), (idx)))
+#define sk_ASN1_TYPE_new(cmp) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new(ossl_check_ASN1_TYPE_compfunc_type(cmp)))
+#define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_TYPE_new_reserve(cmp, n) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_TYPE_compfunc_type(cmp), (n)))
+#define sk_ASN1_TYPE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_TYPE_sk_type(sk), (n))
+#define sk_ASN1_TYPE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_delete(sk, i) ((ASN1_TYPE *)OPENSSL_sk_delete(ossl_check_ASN1_TYPE_sk_type(sk), (i)))
+#define sk_ASN1_TYPE_delete_ptr(sk, ptr) ((ASN1_TYPE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr)))
+#define sk_ASN1_TYPE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_pop(sk) ((ASN1_TYPE *)OPENSSL_sk_pop(ossl_check_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_shift(sk) ((ASN1_TYPE *)OPENSSL_sk_shift(ossl_check_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_TYPE_sk_type(sk),ossl_check_ASN1_TYPE_freefunc_type(freefunc))
+#define sk_ASN1_TYPE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), (idx))
+#define sk_ASN1_TYPE_set(sk, idx, ptr) ((ASN1_TYPE *)OPENSSL_sk_set(ossl_check_ASN1_TYPE_sk_type(sk), (idx), ossl_check_ASN1_TYPE_type(ptr)))
+#define sk_ASN1_TYPE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
+#define sk_ASN1_TYPE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), pnum)
+#define sk_ASN1_TYPE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_TYPE_sk_type(sk))
+#define sk_ASN1_TYPE_dup(sk) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_copyfunc_type(copyfunc), ossl_check_ASN1_TYPE_freefunc_type(freefunc)))
+#define sk_ASN1_TYPE_set_cmp_func(sk, cmp) ((sk_ASN1_TYPE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_compfunc_type(cmp)))
+
+
+typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY;
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY)
+DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SET_ANY)
+
+/* This is used to contain a list of bit names */
+typedef struct BIT_STRING_BITNAME_st {
+    int bitnum;
+    const char *lname;
+    const char *sname;
+} BIT_STRING_BITNAME;
+
+# define B_ASN1_TIME \
+                        B_ASN1_UTCTIME | \
+                        B_ASN1_GENERALIZEDTIME
+
+# define B_ASN1_PRINTABLE \
+                        B_ASN1_NUMERICSTRING| \
+                        B_ASN1_PRINTABLESTRING| \
+                        B_ASN1_T61STRING| \
+                        B_ASN1_IA5STRING| \
+                        B_ASN1_BIT_STRING| \
+                        B_ASN1_UNIVERSALSTRING|\
+                        B_ASN1_BMPSTRING|\
+                        B_ASN1_UTF8STRING|\
+                        B_ASN1_SEQUENCE|\
+                        B_ASN1_UNKNOWN
+
+# define B_ASN1_DIRECTORYSTRING \
+                        B_ASN1_PRINTABLESTRING| \
+                        B_ASN1_TELETEXSTRING|\
+                        B_ASN1_BMPSTRING|\
+                        B_ASN1_UNIVERSALSTRING|\
+                        B_ASN1_UTF8STRING
+
+# define B_ASN1_DISPLAYTEXT \
+                        B_ASN1_IA5STRING| \
+                        B_ASN1_VISIBLESTRING| \
+                        B_ASN1_BMPSTRING|\
+                        B_ASN1_UTF8STRING
+
+DECLARE_ASN1_ALLOC_FUNCTIONS_name(ASN1_TYPE, ASN1_TYPE)
+DECLARE_ASN1_ENCODE_FUNCTIONS(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)
+
+int ASN1_TYPE_get(const ASN1_TYPE *a);
+void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value);
+int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value);
+int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b);
+
+ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t);
+void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t);
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_OBJECT, ASN1_OBJECT, ASN1_OBJECT)
+#define sk_ASN1_OBJECT_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_value(sk, idx) ((ASN1_OBJECT *)OPENSSL_sk_value(ossl_check_const_ASN1_OBJECT_sk_type(sk), (idx)))
+#define sk_ASN1_OBJECT_new(cmp) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new(ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
+#define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_null())
+#define sk_ASN1_OBJECT_new_reserve(cmp, n) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_OBJECT_compfunc_type(cmp), (n)))
+#define sk_ASN1_OBJECT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_OBJECT_sk_type(sk), (n))
+#define sk_ASN1_OBJECT_free(sk) OPENSSL_sk_free(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_delete(sk, i) ((ASN1_OBJECT *)OPENSSL_sk_delete(ossl_check_ASN1_OBJECT_sk_type(sk), (i)))
+#define sk_ASN1_OBJECT_delete_ptr(sk, ptr) ((ASN1_OBJECT *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr)))
+#define sk_ASN1_OBJECT_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_pop(sk) ((ASN1_OBJECT *)OPENSSL_sk_pop(ossl_check_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_shift(sk) ((ASN1_OBJECT *)OPENSSL_sk_shift(ossl_check_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_OBJECT_sk_type(sk),ossl_check_ASN1_OBJECT_freefunc_type(freefunc))
+#define sk_ASN1_OBJECT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), (idx))
+#define sk_ASN1_OBJECT_set(sk, idx, ptr) ((ASN1_OBJECT *)OPENSSL_sk_set(ossl_check_ASN1_OBJECT_sk_type(sk), (idx), ossl_check_ASN1_OBJECT_type(ptr)))
+#define sk_ASN1_OBJECT_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
+#define sk_ASN1_OBJECT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), pnum)
+#define sk_ASN1_OBJECT_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_OBJECT_sk_type(sk))
+#define sk_ASN1_OBJECT_dup(sk) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_dup(ossl_check_const_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_copyfunc_type(copyfunc), ossl_check_ASN1_OBJECT_freefunc_type(freefunc)))
+#define sk_ASN1_OBJECT_set_cmp_func(sk, cmp) ((sk_ASN1_OBJECT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_FUNCTIONS(ASN1_OBJECT)
+
+ASN1_STRING *ASN1_STRING_new(void);
+void ASN1_STRING_free(ASN1_STRING *a);
+void ASN1_STRING_clear_free(ASN1_STRING *a);
+int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str);
+DECLARE_ASN1_DUP_FUNCTION(ASN1_STRING)
+ASN1_STRING *ASN1_STRING_type_new(int type);
+int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);
+  /*
+   * Since this is used to store all sorts of things, via macros, for now,
+   * make its data void *
+   */
+int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);
+void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len);
+int ASN1_STRING_length(const ASN1_STRING *x);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void ASN1_STRING_length_set(ASN1_STRING *x, int n);
+# endif
+int ASN1_STRING_type(const ASN1_STRING *x);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 unsigned char *ASN1_STRING_data(ASN1_STRING *x);
+# endif
+const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING)
+int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length);
+int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value);
+int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n);
+int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a,
+                          const unsigned char *flags, int flags_len);
+
+int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
+                               BIT_STRING_BITNAME *tbl, int indent);
+int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl);
+int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
+                            BIT_STRING_BITNAME *tbl);
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_INTEGER, ASN1_INTEGER, ASN1_INTEGER)
+#define sk_ASN1_INTEGER_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_value(sk, idx) ((ASN1_INTEGER *)OPENSSL_sk_value(ossl_check_const_ASN1_INTEGER_sk_type(sk), (idx)))
+#define sk_ASN1_INTEGER_new(cmp) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new(ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
+#define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_null())
+#define sk_ASN1_INTEGER_new_reserve(cmp, n) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_INTEGER_compfunc_type(cmp), (n)))
+#define sk_ASN1_INTEGER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_INTEGER_sk_type(sk), (n))
+#define sk_ASN1_INTEGER_free(sk) OPENSSL_sk_free(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_delete(sk, i) ((ASN1_INTEGER *)OPENSSL_sk_delete(ossl_check_ASN1_INTEGER_sk_type(sk), (i)))
+#define sk_ASN1_INTEGER_delete_ptr(sk, ptr) ((ASN1_INTEGER *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr)))
+#define sk_ASN1_INTEGER_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_pop(sk) ((ASN1_INTEGER *)OPENSSL_sk_pop(ossl_check_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_shift(sk) ((ASN1_INTEGER *)OPENSSL_sk_shift(ossl_check_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_INTEGER_sk_type(sk),ossl_check_ASN1_INTEGER_freefunc_type(freefunc))
+#define sk_ASN1_INTEGER_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), (idx))
+#define sk_ASN1_INTEGER_set(sk, idx, ptr) ((ASN1_INTEGER *)OPENSSL_sk_set(ossl_check_ASN1_INTEGER_sk_type(sk), (idx), ossl_check_ASN1_INTEGER_type(ptr)))
+#define sk_ASN1_INTEGER_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
+#define sk_ASN1_INTEGER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), pnum)
+#define sk_ASN1_INTEGER_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_INTEGER_sk_type(sk))
+#define sk_ASN1_INTEGER_dup(sk) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_dup(ossl_check_const_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_copyfunc_type(copyfunc), ossl_check_ASN1_INTEGER_freefunc_type(freefunc)))
+#define sk_ASN1_INTEGER_set_cmp_func(sk, cmp) ((sk_ASN1_INTEGER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
+
+
+
+DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER)
+ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
+                                long length);
+DECLARE_ASN1_DUP_FUNCTION(ASN1_INTEGER)
+int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED)
+
+int ASN1_UTCTIME_check(const ASN1_UTCTIME *a);
+ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t);
+ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
+                               int offset_day, long offset_sec);
+int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str);
+int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t);
+
+int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a);
+ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
+                                               time_t t);
+ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
+                                               time_t t, int offset_day,
+                                               long offset_sec);
+int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str);
+
+int ASN1_TIME_diff(int *pday, int *psec,
+                   const ASN1_TIME *from, const ASN1_TIME *to);
+
+DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_OCTET_STRING)
+int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a,
+                          const ASN1_OCTET_STRING *b);
+int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data,
+                          int len);
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_UTF8STRING, ASN1_UTF8STRING, ASN1_UTF8STRING)
+#define sk_ASN1_UTF8STRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_value(sk, idx) ((ASN1_UTF8STRING *)OPENSSL_sk_value(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), (idx)))
+#define sk_ASN1_UTF8STRING_new(cmp) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
+#define sk_ASN1_UTF8STRING_new_null() ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_null())
+#define sk_ASN1_UTF8STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_UTF8STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_UTF8STRING_sk_type(sk), (n))
+#define sk_ASN1_UTF8STRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_delete(sk, i) ((ASN1_UTF8STRING *)OPENSSL_sk_delete(ossl_check_ASN1_UTF8STRING_sk_type(sk), (i)))
+#define sk_ASN1_UTF8STRING_delete_ptr(sk, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr)))
+#define sk_ASN1_UTF8STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_pop(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_pop(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_shift(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_shift(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_UTF8STRING_sk_type(sk),ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc))
+#define sk_ASN1_UTF8STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), (idx))
+#define sk_ASN1_UTF8STRING_set(sk, idx, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_set(ossl_check_ASN1_UTF8STRING_sk_type(sk), (idx), ossl_check_ASN1_UTF8STRING_type(ptr)))
+#define sk_ASN1_UTF8STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
+#define sk_ASN1_UTF8STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), pnum)
+#define sk_ASN1_UTF8STRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))
+#define sk_ASN1_UTF8STRING_dup(sk) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_copyfunc_type(copyfunc), ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc)))
+#define sk_ASN1_UTF8STRING_set_cmp_func(sk, cmp) ((sk_ASN1_UTF8STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_NULL)
+DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING)
+
+int UTF8_getc(const unsigned char *str, int len, unsigned long *val);
+int UTF8_putc(unsigned char *str, int len, unsigned long value);
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_GENERALSTRING, ASN1_GENERALSTRING, ASN1_GENERALSTRING)
+#define sk_ASN1_GENERALSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_value(sk, idx) ((ASN1_GENERALSTRING *)OPENSSL_sk_value(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), (idx)))
+#define sk_ASN1_GENERALSTRING_new(cmp) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
+#define sk_ASN1_GENERALSTRING_new_null() ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_null())
+#define sk_ASN1_GENERALSTRING_new_reserve(cmp, n) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_GENERALSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (n))
+#define sk_ASN1_GENERALSTRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_delete(sk, i) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (i)))
+#define sk_ASN1_GENERALSTRING_delete_ptr(sk, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr)))
+#define sk_ASN1_GENERALSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_pop(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_pop(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_shift(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_shift(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk),ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc))
+#define sk_ASN1_GENERALSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), (idx))
+#define sk_ASN1_GENERALSTRING_set(sk, idx, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_set(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (idx), ossl_check_ASN1_GENERALSTRING_type(ptr)))
+#define sk_ASN1_GENERALSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
+#define sk_ASN1_GENERALSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), pnum)
+#define sk_ASN1_GENERALSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))
+#define sk_ASN1_GENERALSTRING_dup(sk) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_copyfunc_type(copyfunc), ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc)))
+#define sk_ASN1_GENERALSTRING_set_cmp_func(sk, cmp) ((sk_ASN1_GENERALSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE)
+
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING)
+DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT)
+DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING)
+DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME)
+DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME)
+DECLARE_ASN1_FUNCTIONS(ASN1_TIME)
+
+DECLARE_ASN1_DUP_FUNCTION(ASN1_TIME)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_UTCTIME)
+DECLARE_ASN1_DUP_FUNCTION(ASN1_GENERALIZEDTIME)
+
+DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF)
+
+ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t);
+ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t,
+                         int offset_day, long offset_sec);
+int ASN1_TIME_check(const ASN1_TIME *t);
+ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t,
+                                                   ASN1_GENERALIZEDTIME **out);
+int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
+int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str);
+int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm);
+int ASN1_TIME_normalize(ASN1_TIME *s);
+int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t);
+int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b);
+
+int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a);
+int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size);
+int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a);
+int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size);
+int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a);
+int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size);
+int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type);
+int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a);
+
+int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num);
+ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
+                                const char *sn, const char *ln);
+
+int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a);
+int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r);
+int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a);
+int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r);
+
+int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
+long ASN1_INTEGER_get(const ASN1_INTEGER *a);
+ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai);
+BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn);
+
+int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a);
+int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r);
+
+
+int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v);
+long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a);
+ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai);
+BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn);
+
+/* General */
+/* given a string, return the correct type, max is the maximum length */
+int ASN1_PRINTABLE_type(const unsigned char *s, int max);
+
+unsigned long ASN1_tag2bit(int tag);
+
+/* SPECIALS */
+int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
+                    int *pclass, long omax);
+int ASN1_check_infinite_end(unsigned char **p, long len);
+int ASN1_const_check_infinite_end(const unsigned char **p, long len);
+void ASN1_put_object(unsigned char **pp, int constructed, int length,
+                     int tag, int xclass);
+int ASN1_put_eoc(unsigned char **pp);
+int ASN1_object_size(int constructed, int length, int tag);
+
+/* Used to implement other functions */
+void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, const void *x);
+
+# define ASN1_dup_of(type,i2d,d2i,x) \
+    ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \
+                     CHECKED_D2I_OF(type, d2i), \
+                     CHECKED_PTR_OF(const type, x)))
+
+void *ASN1_item_dup(const ASN1_ITEM *it, const void *x);
+int ASN1_item_sign_ex(const ASN1_ITEM *it, X509_ALGOR *algor1,
+                      X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
+                      const void *data, const ASN1_OCTET_STRING *id,
+                      EVP_PKEY *pkey, const EVP_MD *md, OSSL_LIB_CTX *libctx,
+                      const char *propq);
+int ASN1_item_verify_ex(const ASN1_ITEM *it, const X509_ALGOR *alg,
+                        const ASN1_BIT_STRING *signature, const void *data,
+                        const ASN1_OCTET_STRING *id, EVP_PKEY *pkey,
+                        OSSL_LIB_CTX *libctx, const char *propq);
+
+/* ASN1 alloc/free macros for when a type is only used internally */
+
+# define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type))
+# define M_ASN1_free_of(x, type) \
+                ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type))
+
+# ifndef OPENSSL_NO_STDIO
+void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x);
+
+#  define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \
+    ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \
+                        CHECKED_D2I_OF(type, d2i), \
+                        in, \
+                        CHECKED_PPTR_OF(type, x)))
+
+void *ASN1_item_d2i_fp_ex(const ASN1_ITEM *it, FILE *in, void *x,
+                          OSSL_LIB_CTX *libctx, const char *propq);
+void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
+int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, const void *x);
+
+#  define ASN1_i2d_fp_of(type,i2d,out,x) \
+    (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \
+                 out, \
+                 CHECKED_PTR_OF(const type, x)))
+
+int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, const void *x);
+int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags);
+# endif
+
+int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in);
+
+void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x);
+
+#  define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \
+    ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \
+                          CHECKED_D2I_OF(type, d2i), \
+                          in, \
+                          CHECKED_PPTR_OF(type, x)))
+
+void *ASN1_item_d2i_bio_ex(const ASN1_ITEM *it, BIO *in, void *pval,
+                           OSSL_LIB_CTX *libctx, const char *propq);
+void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *pval);
+int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, const void *x);
+
+#  define ASN1_i2d_bio_of(type,i2d,out,x) \
+    (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \
+                  out, \
+                  CHECKED_PTR_OF(const type, x)))
+
+int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, const void *x);
+BIO *ASN1_item_i2d_mem_bio(const ASN1_ITEM *it, const ASN1_VALUE *val);
+int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a);
+int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a);
+int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm);
+int ASN1_TIME_print_ex(BIO *bp, const ASN1_TIME *tm, unsigned long flags);
+int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v);
+int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags);
+int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off);
+int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num,
+                  unsigned char *buf, int off);
+int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent);
+int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent,
+                    int dump);
+const char *ASN1_tag2str(int tag);
+
+/* Used to load and write Netscape format cert */
+
+int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s);
+
+int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len);
+int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len);
+int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num,
+                                  unsigned char *data, int len);
+int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num,
+                                  unsigned char *data, int max_len);
+
+void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it);
+
+ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it,
+                            ASN1_OCTET_STRING **oct);
+
+void ASN1_STRING_set_default_mask(unsigned long mask);
+int ASN1_STRING_set_default_mask_asc(const char *p);
+unsigned long ASN1_STRING_get_default_mask(void);
+int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
+                       int inform, unsigned long mask);
+int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
+                        int inform, unsigned long mask,
+                        long minsize, long maxsize);
+
+ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out,
+                                    const unsigned char *in, int inlen,
+                                    int inform, int nid);
+ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid);
+int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long);
+void ASN1_STRING_TABLE_cleanup(void);
+
+/* ASN1 template functions */
+
+/* Old API compatible functions */
+ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);
+ASN1_VALUE *ASN1_item_new_ex(const ASN1_ITEM *it, OSSL_LIB_CTX *libctx,
+                             const char *propq);
+void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);
+ASN1_VALUE *ASN1_item_d2i_ex(ASN1_VALUE **val, const unsigned char **in,
+                             long len, const ASN1_ITEM *it,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in,
+                          long len, const ASN1_ITEM *it);
+int ASN1_item_i2d(const ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
+int ASN1_item_ndef_i2d(const ASN1_VALUE *val, unsigned char **out,
+                       const ASN1_ITEM *it);
+
+void ASN1_add_oid_module(void);
+void ASN1_add_stable_module(void);
+
+ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf);
+ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf);
+int ASN1_str2mask(const char *str, unsigned long *pmask);
+
+/* ASN1 Print flags */
+
+/* Indicate missing OPTIONAL fields */
+# define ASN1_PCTX_FLAGS_SHOW_ABSENT             0x001
+/* Mark start and end of SEQUENCE */
+# define ASN1_PCTX_FLAGS_SHOW_SEQUENCE           0x002
+/* Mark start and end of SEQUENCE/SET OF */
+# define ASN1_PCTX_FLAGS_SHOW_SSOF               0x004
+/* Show the ASN1 type of primitives */
+# define ASN1_PCTX_FLAGS_SHOW_TYPE               0x008
+/* Don't show ASN1 type of ANY */
+# define ASN1_PCTX_FLAGS_NO_ANY_TYPE             0x010
+/* Don't show ASN1 type of MSTRINGs */
+# define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE         0x020
+/* Don't show field names in SEQUENCE */
+# define ASN1_PCTX_FLAGS_NO_FIELD_NAME           0x040
+/* Show structure names of each SEQUENCE field */
+# define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME  0x080
+/* Don't show structure name even at top level */
+# define ASN1_PCTX_FLAGS_NO_STRUCT_NAME          0x100
+
+int ASN1_item_print(BIO *out, const ASN1_VALUE *ifld, int indent,
+                    const ASN1_ITEM *it, const ASN1_PCTX *pctx);
+ASN1_PCTX *ASN1_PCTX_new(void);
+void ASN1_PCTX_free(ASN1_PCTX *p);
+unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags);
+unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p);
+void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags);
+
+ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx));
+void ASN1_SCTX_free(ASN1_SCTX *p);
+const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p);
+const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p);
+unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p);
+void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data);
+void *ASN1_SCTX_get_app_data(ASN1_SCTX *p);
+
+const BIO_METHOD *BIO_f_asn1(void);
+
+/* cannot constify val because of CMS_stream() */
+BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it);
+
+int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
+                        const ASN1_ITEM *it);
+int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
+                              const char *hdr, const ASN1_ITEM *it);
+/* cannot constify val because of CMS_dataFinal() */
+int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
+                     int ctype_nid, int econt_nid,
+                     STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it);
+int SMIME_write_ASN1_ex(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
+                        int ctype_nid, int econt_nid,
+                        STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it,
+                        OSSL_LIB_CTX *libctx, const char *propq);
+ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it);
+ASN1_VALUE *SMIME_read_ASN1_ex(BIO *bio, int flags, BIO **bcont,
+                               const ASN1_ITEM *it, ASN1_VALUE **x,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+int SMIME_crlf_copy(BIO *in, BIO *out, int flags);
+int SMIME_text(BIO *in, BIO *out);
+
+const ASN1_ITEM *ASN1_ITEM_lookup(const char *name);
+const ASN1_ITEM *ASN1_ITEM_get(size_t i);
+
+/* Legacy compatibility */
+# define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \
+         DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \
+         DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)
+# define DECLARE_ASN1_FUNCTIONS_const(type) DECLARE_ASN1_FUNCTIONS(type)
+# define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \
+         DECLARE_ASN1_ENCODE_FUNCTIONS(type, name)
+# define I2D_OF_const(type) I2D_OF(type)
+# define ASN1_dup_of_const(type,i2d,d2i,x) ASN1_dup_of(type,i2d,d2i,x)
+# define ASN1_i2d_fp_of_const(type,i2d,out,x) ASN1_i2d_fp_of(type,i2d,out,x)
+# define ASN1_i2d_bio_of_const(type,i2d,out,x) ASN1_i2d_bio_of(type,i2d,out,x)
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/asn1_mac.h b/CAPI/cpp/grpc/include/openssl/asn1_mac.h
new file mode 100644
index 0000000..fdcb983
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/asn1_mac.h
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#error "This file is obsolete; please update your software."
diff --git a/CAPI/cpp/grpc/include/openssl/asn1err.h b/CAPI/cpp/grpc/include/openssl/asn1err.h
new file mode 100644
index 0000000..d427622
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/asn1err.h
@@ -0,0 +1,140 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ASN1ERR_H
+# define OPENSSL_ASN1ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * ASN1 reason codes.
+ */
+# define ASN1_R_ADDING_OBJECT                             171
+# define ASN1_R_ASN1_PARSE_ERROR                          203
+# define ASN1_R_ASN1_SIG_PARSE_ERROR                      204
+# define ASN1_R_AUX_ERROR                                 100
+# define ASN1_R_BAD_OBJECT_HEADER                         102
+# define ASN1_R_BAD_TEMPLATE                              230
+# define ASN1_R_BMPSTRING_IS_WRONG_LENGTH                 214
+# define ASN1_R_BN_LIB                                    105
+# define ASN1_R_BOOLEAN_IS_WRONG_LENGTH                   106
+# define ASN1_R_BUFFER_TOO_SMALL                          107
+# define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER           108
+# define ASN1_R_CONTEXT_NOT_INITIALISED                   217
+# define ASN1_R_DATA_IS_WRONG                             109
+# define ASN1_R_DECODE_ERROR                              110
+# define ASN1_R_DEPTH_EXCEEDED                            174
+# define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED         198
+# define ASN1_R_ENCODE_ERROR                              112
+# define ASN1_R_ERROR_GETTING_TIME                        173
+# define ASN1_R_ERROR_LOADING_SECTION                     172
+# define ASN1_R_ERROR_SETTING_CIPHER_PARAMS               114
+# define ASN1_R_EXPECTING_AN_INTEGER                      115
+# define ASN1_R_EXPECTING_AN_OBJECT                       116
+# define ASN1_R_EXPLICIT_LENGTH_MISMATCH                  119
+# define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED              120
+# define ASN1_R_FIELD_MISSING                             121
+# define ASN1_R_FIRST_NUM_TOO_LARGE                       122
+# define ASN1_R_HEADER_TOO_LONG                           123
+# define ASN1_R_ILLEGAL_BITSTRING_FORMAT                  175
+# define ASN1_R_ILLEGAL_BOOLEAN                           176
+# define ASN1_R_ILLEGAL_CHARACTERS                        124
+# define ASN1_R_ILLEGAL_FORMAT                            177
+# define ASN1_R_ILLEGAL_HEX                               178
+# define ASN1_R_ILLEGAL_IMPLICIT_TAG                      179
+# define ASN1_R_ILLEGAL_INTEGER                           180
+# define ASN1_R_ILLEGAL_NEGATIVE_VALUE                    226
+# define ASN1_R_ILLEGAL_NESTED_TAGGING                    181
+# define ASN1_R_ILLEGAL_NULL                              125
+# define ASN1_R_ILLEGAL_NULL_VALUE                        182
+# define ASN1_R_ILLEGAL_OBJECT                            183
+# define ASN1_R_ILLEGAL_OPTIONAL_ANY                      126
+# define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE          170
+# define ASN1_R_ILLEGAL_PADDING                           221
+# define ASN1_R_ILLEGAL_TAGGED_ANY                        127
+# define ASN1_R_ILLEGAL_TIME_VALUE                        184
+# define ASN1_R_ILLEGAL_ZERO_CONTENT                      222
+# define ASN1_R_INTEGER_NOT_ASCII_FORMAT                  185
+# define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG                128
+# define ASN1_R_INVALID_BIT_STRING_BITS_LEFT              220
+# define ASN1_R_INVALID_BMPSTRING_LENGTH                  129
+# define ASN1_R_INVALID_DIGIT                             130
+# define ASN1_R_INVALID_MIME_TYPE                         205
+# define ASN1_R_INVALID_MODIFIER                          186
+# define ASN1_R_INVALID_NUMBER                            187
+# define ASN1_R_INVALID_OBJECT_ENCODING                   216
+# define ASN1_R_INVALID_SCRYPT_PARAMETERS                 227
+# define ASN1_R_INVALID_SEPARATOR                         131
+# define ASN1_R_INVALID_STRING_TABLE_VALUE                218
+# define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH            133
+# define ASN1_R_INVALID_UTF8STRING                        134
+# define ASN1_R_INVALID_VALUE                             219
+# define ASN1_R_LENGTH_TOO_LONG                           231
+# define ASN1_R_LIST_ERROR                                188
+# define ASN1_R_MIME_NO_CONTENT_TYPE                      206
+# define ASN1_R_MIME_PARSE_ERROR                          207
+# define ASN1_R_MIME_SIG_PARSE_ERROR                      208
+# define ASN1_R_MISSING_EOC                               137
+# define ASN1_R_MISSING_SECOND_NUMBER                     138
+# define ASN1_R_MISSING_VALUE                             189
+# define ASN1_R_MSTRING_NOT_UNIVERSAL                     139
+# define ASN1_R_MSTRING_WRONG_TAG                         140
+# define ASN1_R_NESTED_ASN1_STRING                        197
+# define ASN1_R_NESTED_TOO_DEEP                           201
+# define ASN1_R_NON_HEX_CHARACTERS                        141
+# define ASN1_R_NOT_ASCII_FORMAT                          190
+# define ASN1_R_NOT_ENOUGH_DATA                           142
+# define ASN1_R_NO_CONTENT_TYPE                           209
+# define ASN1_R_NO_MATCHING_CHOICE_TYPE                   143
+# define ASN1_R_NO_MULTIPART_BODY_FAILURE                 210
+# define ASN1_R_NO_MULTIPART_BOUNDARY                     211
+# define ASN1_R_NO_SIG_CONTENT_TYPE                       212
+# define ASN1_R_NULL_IS_WRONG_LENGTH                      144
+# define ASN1_R_OBJECT_NOT_ASCII_FORMAT                   191
+# define ASN1_R_ODD_NUMBER_OF_CHARS                       145
+# define ASN1_R_SECOND_NUMBER_TOO_LARGE                   147
+# define ASN1_R_SEQUENCE_LENGTH_MISMATCH                  148
+# define ASN1_R_SEQUENCE_NOT_CONSTRUCTED                  149
+# define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG              192
+# define ASN1_R_SHORT_LINE                                150
+# define ASN1_R_SIG_INVALID_MIME_TYPE                     213
+# define ASN1_R_STREAMING_NOT_SUPPORTED                   202
+# define ASN1_R_STRING_TOO_LONG                           151
+# define ASN1_R_STRING_TOO_SHORT                          152
+# define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154
+# define ASN1_R_TIME_NOT_ASCII_FORMAT                     193
+# define ASN1_R_TOO_LARGE                                 223
+# define ASN1_R_TOO_LONG                                  155
+# define ASN1_R_TOO_SMALL                                 224
+# define ASN1_R_TYPE_NOT_CONSTRUCTED                      156
+# define ASN1_R_TYPE_NOT_PRIMITIVE                        195
+# define ASN1_R_UNEXPECTED_EOC                            159
+# define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH           215
+# define ASN1_R_UNKNOWN_DIGEST                            229
+# define ASN1_R_UNKNOWN_FORMAT                            160
+# define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM          161
+# define ASN1_R_UNKNOWN_OBJECT_TYPE                       162
+# define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE                   163
+# define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM               199
+# define ASN1_R_UNKNOWN_TAG                               194
+# define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE           164
+# define ASN1_R_UNSUPPORTED_CIPHER                        228
+# define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE               167
+# define ASN1_R_UNSUPPORTED_TYPE                          196
+# define ASN1_R_WRONG_INTEGER_TYPE                        225
+# define ASN1_R_WRONG_PUBLIC_KEY_TYPE                     200
+# define ASN1_R_WRONG_TAG                                 168
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/asn1t.h b/CAPI/cpp/grpc/include/openssl/asn1t.h
new file mode 100644
index 0000000..a725c53
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/asn1t.h
@@ -0,0 +1,946 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\asn1t.h.in
+ *
+ * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_ASN1T_H
+# define OPENSSL_ASN1T_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ASN1T_H
+# endif
+
+# include <stddef.h>
+# include <openssl/e_os2.h>
+# include <openssl/asn1.h>
+
+# ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#  undef OPENSSL_EXTERN
+#  define OPENSSL_EXTERN OPENSSL_EXPORT
+# endif
+
+/* ASN1 template defines, structures and functions */
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*-
+ * These are the possible values for the itype field of the
+ * ASN1_ITEM structure and determine how it is interpreted.
+ *
+ * For PRIMITIVE types the underlying type
+ * determines the behaviour if items is NULL.
+ *
+ * Otherwise templates must contain a single
+ * template and the type is treated in the
+ * same way as the type specified in the template.
+ *
+ * For SEQUENCE types the templates field points
+ * to the members, the size field is the
+ * structure size.
+ *
+ * For CHOICE types the templates field points
+ * to each possible member (typically a union)
+ * and the 'size' field is the offset of the
+ * selector.
+ *
+ * The 'funcs' field is used for application-specific
+ * data and functions.
+ *
+ * The EXTERN type uses a new style d2i/i2d.
+ * The new style should be used where possible
+ * because it avoids things like the d2i IMPLICIT
+ * hack.
+ *
+ * MSTRING is a multiple string type, it is used
+ * for a CHOICE of character strings where the
+ * actual strings all occupy an ASN1_STRING
+ * structure. In this case the 'utype' field
+ * has a special meaning, it is used as a mask
+ * of acceptable types using the B_ASN1 constants.
+ *
+ * NDEF_SEQUENCE is the same as SEQUENCE except
+ * that it will use indefinite length constructed
+ * encoding if requested.
+ *
+ */
+
+# define ASN1_ITYPE_PRIMITIVE            0x0
+# define ASN1_ITYPE_SEQUENCE             0x1
+# define ASN1_ITYPE_CHOICE               0x2
+/* unused value                          0x3 */
+# define ASN1_ITYPE_EXTERN               0x4
+# define ASN1_ITYPE_MSTRING              0x5
+# define ASN1_ITYPE_NDEF_SEQUENCE        0x6
+
+/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
+# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)((iptr)()))
+
+/* Macros for start and end of ASN1_ITEM definition */
+
+# define ASN1_ITEM_start(itname) \
+        const ASN1_ITEM * itname##_it(void) \
+        { \
+                static const ASN1_ITEM local_it = {
+
+# define static_ASN1_ITEM_start(itname) \
+        static ASN1_ITEM_start(itname)
+
+# define ASN1_ITEM_end(itname) \
+                }; \
+        return &local_it; \
+        }
+
+/* Macros to aid ASN1 template writing */
+
+# define ASN1_ITEM_TEMPLATE(tname) \
+        static const ASN1_TEMPLATE tname##_item_tt
+
+# define ASN1_ITEM_TEMPLATE_END(tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_PRIMITIVE,\
+                -1,\
+                &tname##_item_tt,\
+                0,\
+                NULL,\
+                0,\
+                #tname \
+        ASN1_ITEM_end(tname)
+# define static_ASN1_ITEM_TEMPLATE_END(tname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_PRIMITIVE,\
+                -1,\
+                &tname##_item_tt,\
+                0,\
+                NULL,\
+                0,\
+                #tname \
+        ASN1_ITEM_end(tname)
+
+/* This is a ASN1 type which just embeds a template */
+
+/*-
+ * This pair helps declare a SEQUENCE. We can do:
+ *
+ *      ASN1_SEQUENCE(stname) = {
+ *              ... SEQUENCE components ...
+ *      } ASN1_SEQUENCE_END(stname)
+ *
+ *      This will produce an ASN1_ITEM called stname_it
+ *      for a structure called stname.
+ *
+ *      If you want the same structure but a different
+ *      name then use:
+ *
+ *      ASN1_SEQUENCE(itname) = {
+ *              ... SEQUENCE components ...
+ *      } ASN1_SEQUENCE_END_name(stname, itname)
+ *
+ *      This will create an item called itname_it using
+ *      a structure called stname.
+ */
+
+# define ASN1_SEQUENCE(tname) \
+        static const ASN1_TEMPLATE tname##_seq_tt[]
+
+# define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)
+
+# define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname)
+
+# define ASN1_SEQUENCE_END_name(stname, tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(stname),\
+                #tname \
+        ASN1_ITEM_end(tname)
+
+# define static_ASN1_SEQUENCE_END_name(stname, tname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+# define ASN1_NDEF_SEQUENCE(tname) \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_NDEF_SEQUENCE_cb(tname, cb) \
+        ASN1_SEQUENCE_cb(tname, cb)
+
+# define ASN1_SEQUENCE_cb(tname, cb) \
+        static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0, NULL}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_SEQUENCE_const_cb(tname, const_cb) \
+        static const ASN1_AUX tname##_aux = \
+            {NULL, ASN1_AFLG_CONST_CB, 0, 0, NULL, 0, const_cb}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_SEQUENCE_cb_const_cb(tname, cb, const_cb) \
+        static const ASN1_AUX tname##_aux = \
+            {NULL, ASN1_AFLG_CONST_CB, 0, 0, cb, 0, const_cb}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_SEQUENCE_ref(tname, cb) \
+        static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0, NULL}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_SEQUENCE_enc(tname, enc, cb) \
+        static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc), NULL}; \
+        ASN1_SEQUENCE(tname)
+
+# define ASN1_NDEF_SEQUENCE_END(tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_NDEF_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(tname),\
+                #tname \
+        ASN1_ITEM_end(tname)
+# define static_ASN1_NDEF_SEQUENCE_END(tname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_NDEF_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(tname),\
+                #tname \
+        ASN1_ITEM_end(tname)
+
+
+# define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
+
+# define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
+# define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname)
+
+# define ASN1_SEQUENCE_END_ref(stname, tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                &tname##_aux,\
+                sizeof(stname),\
+                #tname \
+        ASN1_ITEM_end(tname)
+# define static_ASN1_SEQUENCE_END_ref(stname, tname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                &tname##_aux,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+# define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_NDEF_SEQUENCE,\
+                V_ASN1_SEQUENCE,\
+                tname##_seq_tt,\
+                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
+                &tname##_aux,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+/*-
+ * This pair helps declare a CHOICE type. We can do:
+ *
+ *      ASN1_CHOICE(chname) = {
+ *              ... CHOICE options ...
+ *      ASN1_CHOICE_END(chname)
+ *
+ *      This will produce an ASN1_ITEM called chname_it
+ *      for a structure called chname. The structure
+ *      definition must look like this:
+ *      typedef struct {
+ *              int type;
+ *              union {
+ *                      ASN1_SOMETHING *opt1;
+ *                      ASN1_SOMEOTHER *opt2;
+ *              } value;
+ *      } chname;
+ *
+ *      the name of the selector must be 'type'.
+ *      to use an alternative selector name use the
+ *      ASN1_CHOICE_END_selector() version.
+ */
+
+# define ASN1_CHOICE(tname) \
+        static const ASN1_TEMPLATE tname##_ch_tt[]
+
+# define ASN1_CHOICE_cb(tname, cb) \
+        static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0, NULL}; \
+        ASN1_CHOICE(tname)
+
+# define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
+
+# define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname)
+
+# define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
+
+# define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type)
+
+# define ASN1_CHOICE_END_selector(stname, tname, selname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_CHOICE,\
+                offsetof(stname,selname) ,\
+                tname##_ch_tt,\
+                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+# define static_ASN1_CHOICE_END_selector(stname, tname, selname) \
+        ;\
+        static_ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_CHOICE,\
+                offsetof(stname,selname) ,\
+                tname##_ch_tt,\
+                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
+                NULL,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+# define ASN1_CHOICE_END_cb(stname, tname, selname) \
+        ;\
+        ASN1_ITEM_start(tname) \
+                ASN1_ITYPE_CHOICE,\
+                offsetof(stname,selname) ,\
+                tname##_ch_tt,\
+                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
+                &tname##_aux,\
+                sizeof(stname),\
+                #stname \
+        ASN1_ITEM_end(tname)
+
+/* This helps with the template wrapper form of ASN1_ITEM */
+
+# define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \
+        (flags), (tag), 0,\
+        #name, ASN1_ITEM_ref(type) }
+
+/* These help with SEQUENCE or CHOICE components */
+
+/* used to declare other types */
+
+# define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
+        (flags), (tag), offsetof(stname, field),\
+        #field, ASN1_ITEM_ref(type) }
+
+/* implicit and explicit helper macros */
+
+# define ASN1_IMP_EX(stname, field, type, tag, ex) \
+         ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type)
+
+# define ASN1_EXP_EX(stname, field, type, tag, ex) \
+         ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type)
+
+/* Any defined by macros: the field used is in the table itself */
+
+# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb }
+# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb }
+
+/* Plain simple type */
+# define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type)
+/* Embedded simple type */
+# define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED,0, stname, field, type)
+
+/* OPTIONAL simple type */
+# define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+# define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED, 0, stname, field, type)
+
+/* IMPLICIT tagged simple type */
+# define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0)
+# define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
+
+/* IMPLICIT tagged OPTIONAL simple type */
+# define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
+# define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED)
+
+/* Same as above but EXPLICIT */
+
+# define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0)
+# define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
+# define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
+# define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED)
+
+/* SEQUENCE OF type */
+# define ASN1_SEQUENCE_OF(stname, field, type) \
+                ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type)
+
+/* OPTIONAL SEQUENCE OF */
+# define ASN1_SEQUENCE_OF_OPT(stname, field, type) \
+                ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+
+/* Same as above but for SET OF */
+
+# define ASN1_SET_OF(stname, field, type) \
+                ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type)
+
+# define ASN1_SET_OF_OPT(stname, field, type) \
+                ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+
+/* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */
+
+# define ASN1_IMP_SET_OF(stname, field, type, tag) \
+                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
+
+# define ASN1_EXP_SET_OF(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
+
+# define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \
+                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
+
+# define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
+
+# define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \
+                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
+
+# define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \
+                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
+
+# define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
+
+# define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
+
+/* EXPLICIT using indefinite length constructed form */
+# define ASN1_NDEF_EXP(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF)
+
+/* EXPLICIT OPTIONAL using indefinite length constructed form */
+# define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \
+                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF)
+
+/* Macros for the ASN1_ADB structure */
+
+# define ASN1_ADB(name) \
+        static const ASN1_ADB_TABLE name##_adbtbl[]
+
+# define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \
+        ;\
+        static const ASN1_ITEM *name##_adb(void) \
+        { \
+        static const ASN1_ADB internal_adb = \
+                {\
+                flags,\
+                offsetof(name, field),\
+                adb_cb,\
+                name##_adbtbl,\
+                sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
+                def,\
+                none\
+                }; \
+                return (const ASN1_ITEM *) &internal_adb; \
+        } \
+        void dummy_function(void)
+
+# define ADB_ENTRY(val, template) {val, template}
+
+# define ASN1_ADB_TEMPLATE(name) \
+        static const ASN1_TEMPLATE name##_tt
+
+/*
+ * This is the ASN1 template structure that defines a wrapper round the
+ * actual type. It determines the actual position of the field in the value
+ * structure, various flags such as OPTIONAL and the field name.
+ */
+
+struct ASN1_TEMPLATE_st {
+    unsigned long flags;        /* Various flags */
+    long tag;                   /* tag, not used if no tagging */
+    unsigned long offset;       /* Offset of this field in structure */
+    const char *field_name;     /* Field name */
+    ASN1_ITEM_EXP *item;        /* Relevant ASN1_ITEM or ASN1_ADB */
+};
+
+/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
+
+# define ASN1_TEMPLATE_item(t) (t->item_ptr)
+# define ASN1_TEMPLATE_adb(t) (t->item_ptr)
+
+typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
+typedef struct ASN1_ADB_st ASN1_ADB;
+
+struct ASN1_ADB_st {
+    unsigned long flags;        /* Various flags */
+    unsigned long offset;       /* Offset of selector field */
+    int (*adb_cb)(long *psel);  /* Application callback */
+    const ASN1_ADB_TABLE *tbl;  /* Table of possible types */
+    long tblcount;              /* Number of entries in tbl */
+    const ASN1_TEMPLATE *default_tt; /* Type to use if no match */
+    const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */
+};
+
+struct ASN1_ADB_TABLE_st {
+    long value;                 /* NID for an object or value for an int */
+    const ASN1_TEMPLATE tt;     /* item for this value */
+};
+
+/* template flags */
+
+/* Field is optional */
+# define ASN1_TFLG_OPTIONAL      (0x1)
+
+/* Field is a SET OF */
+# define ASN1_TFLG_SET_OF        (0x1 << 1)
+
+/* Field is a SEQUENCE OF */
+# define ASN1_TFLG_SEQUENCE_OF   (0x2 << 1)
+
+/*
+ * Special case: this refers to a SET OF that will be sorted into DER order
+ * when encoded *and* the corresponding STACK will be modified to match the
+ * new order.
+ */
+# define ASN1_TFLG_SET_ORDER     (0x3 << 1)
+
+/* Mask for SET OF or SEQUENCE OF */
+# define ASN1_TFLG_SK_MASK       (0x3 << 1)
+
+/*
+ * These flags mean the tag should be taken from the tag field. If EXPLICIT
+ * then the underlying type is used for the inner tag.
+ */
+
+/* IMPLICIT tagging */
+# define ASN1_TFLG_IMPTAG        (0x1 << 3)
+
+/* EXPLICIT tagging, inner tag from underlying type */
+# define ASN1_TFLG_EXPTAG        (0x2 << 3)
+
+# define ASN1_TFLG_TAG_MASK      (0x3 << 3)
+
+/* context specific IMPLICIT */
+# define ASN1_TFLG_IMPLICIT      (ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT)
+
+/* context specific EXPLICIT */
+# define ASN1_TFLG_EXPLICIT      (ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT)
+
+/*
+ * If tagging is in force these determine the type of tag to use. Otherwise
+ * the tag is determined by the underlying type. These values reflect the
+ * actual octet format.
+ */
+
+/* Universal tag */
+# define ASN1_TFLG_UNIVERSAL     (0x0<<6)
+/* Application tag */
+# define ASN1_TFLG_APPLICATION   (0x1<<6)
+/* Context specific tag */
+# define ASN1_TFLG_CONTEXT       (0x2<<6)
+/* Private tag */
+# define ASN1_TFLG_PRIVATE       (0x3<<6)
+
+# define ASN1_TFLG_TAG_CLASS     (0x3<<6)
+
+/*
+ * These are for ANY DEFINED BY type. In this case the 'item' field points to
+ * an ASN1_ADB structure which contains a table of values to decode the
+ * relevant type
+ */
+
+# define ASN1_TFLG_ADB_MASK      (0x3<<8)
+
+# define ASN1_TFLG_ADB_OID       (0x1<<8)
+
+# define ASN1_TFLG_ADB_INT       (0x1<<9)
+
+/*
+ * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes
+ * indefinite length constructed encoding to be used if required.
+ */
+
+# define ASN1_TFLG_NDEF          (0x1<<11)
+
+/* Field is embedded and not a pointer */
+# define ASN1_TFLG_EMBED         (0x1 << 12)
+
+/* This is the actual ASN1 item itself */
+
+struct ASN1_ITEM_st {
+    char itype;                 /* The item type, primitive, SEQUENCE, CHOICE
+                                 * or extern */
+    long utype;                 /* underlying type */
+    const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains
+                                     * the contents */
+    long tcount;                /* Number of templates if SEQUENCE or CHOICE */
+    const void *funcs;          /* further data and type-specific functions */
+    /* funcs can be ASN1_PRIMITIVE_FUNCS*, ASN1_EXTERN_FUNCS*, or ASN1_AUX* */
+    long size;                  /* Structure size (usually) */
+    const char *sname;          /* Structure name */
+};
+
+/*
+ * Cache for ASN1 tag and length, so we don't keep re-reading it for things
+ * like CHOICE
+ */
+
+struct ASN1_TLC_st {
+    char valid;                 /* Values below are valid */
+    int ret;                    /* return value */
+    long plen;                  /* length */
+    int ptag;                   /* class value */
+    int pclass;                 /* class value */
+    int hdrlen;                 /* header length */
+};
+
+/* Typedefs for ASN1 function pointers */
+typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
+                        const ASN1_ITEM *it, int tag, int aclass, char opt,
+                        ASN1_TLC *ctx);
+
+typedef int ASN1_ex_d2i_ex(ASN1_VALUE **pval, const unsigned char **in, long len,
+                           const ASN1_ITEM *it, int tag, int aclass, char opt,
+                           ASN1_TLC *ctx, OSSL_LIB_CTX *libctx,
+                           const char *propq);
+typedef int ASN1_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
+                        const ASN1_ITEM *it, int tag, int aclass);
+typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
+typedef int ASN1_ex_new_ex_func(ASN1_VALUE **pval, const ASN1_ITEM *it,
+                                OSSL_LIB_CTX *libctx, const char *propq);
+typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
+
+typedef int ASN1_ex_print_func(BIO *out, const ASN1_VALUE **pval,
+                               int indent, const char *fname,
+                               const ASN1_PCTX *pctx);
+
+typedef int ASN1_primitive_i2c(const ASN1_VALUE **pval, unsigned char *cont,
+                               int *putype, const ASN1_ITEM *it);
+typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont,
+                               int len, int utype, char *free_cont,
+                               const ASN1_ITEM *it);
+typedef int ASN1_primitive_print(BIO *out, const ASN1_VALUE **pval,
+                                 const ASN1_ITEM *it, int indent,
+                                 const ASN1_PCTX *pctx);
+
+typedef struct ASN1_EXTERN_FUNCS_st {
+    void *app_data;
+    ASN1_ex_new_func *asn1_ex_new;
+    ASN1_ex_free_func *asn1_ex_free;
+    ASN1_ex_free_func *asn1_ex_clear;
+    ASN1_ex_d2i *asn1_ex_d2i;
+    ASN1_ex_i2d *asn1_ex_i2d;
+    ASN1_ex_print_func *asn1_ex_print;
+    ASN1_ex_new_ex_func *asn1_ex_new_ex;
+    ASN1_ex_d2i_ex *asn1_ex_d2i_ex;
+} ASN1_EXTERN_FUNCS;
+
+typedef struct ASN1_PRIMITIVE_FUNCS_st {
+    void *app_data;
+    unsigned long flags;
+    ASN1_ex_new_func *prim_new;
+    ASN1_ex_free_func *prim_free;
+    ASN1_ex_free_func *prim_clear;
+    ASN1_primitive_c2i *prim_c2i;
+    ASN1_primitive_i2c *prim_i2c;
+    ASN1_primitive_print *prim_print;
+} ASN1_PRIMITIVE_FUNCS;
+
+/*
+ * This is the ASN1_AUX structure: it handles various miscellaneous
+ * requirements. For example the use of reference counts and an informational
+ * callback. The "informational callback" is called at various points during
+ * the ASN1 encoding and decoding. It can be used to provide minor
+ * customisation of the structures used. This is most useful where the
+ * supplied routines *almost* do the right thing but need some extra help at
+ * a few points. If the callback returns zero then it is assumed a fatal
+ * error has occurred and the main operation should be abandoned. If major
+ * changes in the default behaviour are required then an external type is
+ * more appropriate.
+ * For the operations ASN1_OP_I2D_PRE, ASN1_OP_I2D_POST, ASN1_OP_PRINT_PRE, and
+ * ASN1_OP_PRINT_POST, meanwhile a variant of the callback with const parameter
+ * 'in' is provided to make clear statically that its input is not modified. If
+ * and only if this variant is in use the flag ASN1_AFLG_CONST_CB must be set.
+ */
+
+typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it,
+                        void *exarg);
+typedef int ASN1_aux_const_cb(int operation, const ASN1_VALUE **in,
+                              const ASN1_ITEM *it, void *exarg);
+
+typedef struct ASN1_AUX_st {
+    void *app_data;
+    int flags;
+    int ref_offset;             /* Offset of reference value */
+    int ref_lock;               /* Offset of lock value */
+    ASN1_aux_cb *asn1_cb;
+    int enc_offset;             /* Offset of ASN1_ENCODING structure */
+    ASN1_aux_const_cb *asn1_const_cb; /* for ASN1_OP_I2D_ and ASN1_OP_PRINT_ */
+} ASN1_AUX;
+
+/* For print related callbacks exarg points to this structure */
+typedef struct ASN1_PRINT_ARG_st {
+    BIO *out;
+    int indent;
+    const ASN1_PCTX *pctx;
+} ASN1_PRINT_ARG;
+
+/* For streaming related callbacks exarg points to this structure */
+typedef struct ASN1_STREAM_ARG_st {
+    /* BIO to stream through */
+    BIO *out;
+    /* BIO with filters appended */
+    BIO *ndef_bio;
+    /* Streaming I/O boundary */
+    unsigned char **boundary;
+} ASN1_STREAM_ARG;
+
+/* Flags in ASN1_AUX */
+
+/* Use a reference count */
+# define ASN1_AFLG_REFCOUNT      1
+/* Save the encoding of structure (useful for signatures) */
+# define ASN1_AFLG_ENCODING      2
+/* The Sequence length is invalid */
+# define ASN1_AFLG_BROKEN        4
+/* Use the new asn1_const_cb */
+# define ASN1_AFLG_CONST_CB      8
+
+/* operation values for asn1_cb */
+
+# define ASN1_OP_NEW_PRE         0
+# define ASN1_OP_NEW_POST        1
+# define ASN1_OP_FREE_PRE        2
+# define ASN1_OP_FREE_POST       3
+# define ASN1_OP_D2I_PRE         4
+# define ASN1_OP_D2I_POST        5
+# define ASN1_OP_I2D_PRE         6
+# define ASN1_OP_I2D_POST        7
+# define ASN1_OP_PRINT_PRE       8
+# define ASN1_OP_PRINT_POST      9
+# define ASN1_OP_STREAM_PRE      10
+# define ASN1_OP_STREAM_POST     11
+# define ASN1_OP_DETACHED_PRE    12
+# define ASN1_OP_DETACHED_POST   13
+# define ASN1_OP_DUP_PRE         14
+# define ASN1_OP_DUP_POST        15
+# define ASN1_OP_GET0_LIBCTX     16
+# define ASN1_OP_GET0_PROPQ      17
+
+/* Macro to implement a primitive type */
+# define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
+# define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
+                                ASN1_ITEM_start(itname) \
+                                        ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \
+                                ASN1_ITEM_end(itname)
+
+/* Macro to implement a multi string type */
+# define IMPLEMENT_ASN1_MSTRING(itname, mask) \
+                                ASN1_ITEM_start(itname) \
+                                        ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \
+                                ASN1_ITEM_end(itname)
+
+# define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
+        ASN1_ITEM_start(sname) \
+                ASN1_ITYPE_EXTERN, \
+                tag, \
+                NULL, \
+                0, \
+                &fptrs, \
+                0, \
+                #sname \
+        ASN1_ITEM_end(sname)
+
+/* Macro to implement standard functions in terms of ASN1_ITEM structures */
+
+# define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
+
+# define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
+
+# define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
+                        IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
+
+# define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \
+                IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname)
+
+# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \
+                IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname)
+
+# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \
+        pre stname *fname##_new(void) \
+        { \
+                return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
+        } \
+        pre void fname##_free(stname *a) \
+        { \
+                ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
+        }
+
+# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
+        stname *fname##_new(void) \
+        { \
+                return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
+        } \
+        void fname##_free(stname *a) \
+        { \
+                ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
+        }
+
+# define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \
+        IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
+        IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
+
+# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
+        stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
+        { \
+                return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
+        } \
+        int i2d_##fname(const stname *a, unsigned char **out) \
+        { \
+                return ASN1_item_i2d((const ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
+        }
+
+# define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \
+        int i2d_##stname##_NDEF(const stname *a, unsigned char **out) \
+        { \
+                return ASN1_item_ndef_i2d((const ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\
+        }
+
+# define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname) \
+        static stname *d2i_##stname(stname **a, \
+                                   const unsigned char **in, long len) \
+        { \
+                return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \
+                                               ASN1_ITEM_rptr(stname)); \
+        } \
+        static int i2d_##stname(const stname *a, unsigned char **out) \
+        { \
+                return ASN1_item_i2d((const ASN1_VALUE *)a, out, \
+                                     ASN1_ITEM_rptr(stname)); \
+        }
+
+# define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \
+        stname * stname##_dup(const stname *x) \
+        { \
+        return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \
+        }
+
+# define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \
+        IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname)
+
+# define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \
+        int fname##_print_ctx(BIO *out, const stname *x, int indent, \
+                                                const ASN1_PCTX *pctx) \
+        { \
+                return ASN1_item_print(out, (const ASN1_VALUE *)x, indent, \
+                        ASN1_ITEM_rptr(itname), pctx); \
+        }
+
+/* external definitions for primitive types */
+
+DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
+DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
+DECLARE_ASN1_ITEM(CBIGNUM)
+DECLARE_ASN1_ITEM(BIGNUM)
+DECLARE_ASN1_ITEM(INT32)
+DECLARE_ASN1_ITEM(ZINT32)
+DECLARE_ASN1_ITEM(UINT32)
+DECLARE_ASN1_ITEM(ZUINT32)
+DECLARE_ASN1_ITEM(INT64)
+DECLARE_ASN1_ITEM(ZINT64)
+DECLARE_ASN1_ITEM(UINT64)
+DECLARE_ASN1_ITEM(ZUINT64)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * LONG and ZLONG are strongly discouraged for use as stored data, as the
+ * underlying C type (long) differs in size depending on the architecture.
+ * They are designed with 32-bit longs in mind.
+ */
+DECLARE_ASN1_ITEM(LONG)
+DECLARE_ASN1_ITEM(ZLONG)
+# endif
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_VALUE, ASN1_VALUE, ASN1_VALUE)
+#define sk_ASN1_VALUE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_value(sk, idx) ((ASN1_VALUE *)OPENSSL_sk_value(ossl_check_const_ASN1_VALUE_sk_type(sk), (idx)))
+#define sk_ASN1_VALUE_new(cmp) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new(ossl_check_ASN1_VALUE_compfunc_type(cmp)))
+#define sk_ASN1_VALUE_new_null() ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new_null())
+#define sk_ASN1_VALUE_new_reserve(cmp, n) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_VALUE_compfunc_type(cmp), (n)))
+#define sk_ASN1_VALUE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_VALUE_sk_type(sk), (n))
+#define sk_ASN1_VALUE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_delete(sk, i) ((ASN1_VALUE *)OPENSSL_sk_delete(ossl_check_ASN1_VALUE_sk_type(sk), (i)))
+#define sk_ASN1_VALUE_delete_ptr(sk, ptr) ((ASN1_VALUE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr)))
+#define sk_ASN1_VALUE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_pop(sk) ((ASN1_VALUE *)OPENSSL_sk_pop(ossl_check_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_shift(sk) ((ASN1_VALUE *)OPENSSL_sk_shift(ossl_check_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_VALUE_sk_type(sk),ossl_check_ASN1_VALUE_freefunc_type(freefunc))
+#define sk_ASN1_VALUE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr), (idx))
+#define sk_ASN1_VALUE_set(sk, idx, ptr) ((ASN1_VALUE *)OPENSSL_sk_set(ossl_check_ASN1_VALUE_sk_type(sk), (idx), ossl_check_ASN1_VALUE_type(ptr)))
+#define sk_ASN1_VALUE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
+#define sk_ASN1_VALUE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr), pnum)
+#define sk_ASN1_VALUE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_VALUE_sk_type(sk))
+#define sk_ASN1_VALUE_dup(sk) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_copyfunc_type(copyfunc), ossl_check_ASN1_VALUE_freefunc_type(freefunc)))
+#define sk_ASN1_VALUE_set_cmp_func(sk, cmp) ((sk_ASN1_VALUE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_compfunc_type(cmp)))
+
+
+
+/* Functions used internally by the ASN1 code */
+
+int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
+void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
+
+int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
+                     const ASN1_ITEM *it, int tag, int aclass, char opt,
+                     ASN1_TLC *ctx);
+
+int ASN1_item_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
+                     const ASN1_ITEM *it, int tag, int aclass);
+
+/* Legacy compatibility */
+# define IMPLEMENT_ASN1_FUNCTIONS_const(name) IMPLEMENT_ASN1_FUNCTIONS(name)
+# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
+         IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname)
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/async.h b/CAPI/cpp/grpc/include/openssl/async.h
new file mode 100644
index 0000000..bc27d5d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/async.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <stdlib.h>
+
+#ifndef OPENSSL_ASYNC_H
+# define OPENSSL_ASYNC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ASYNC_H
+# endif
+
+#if defined(_WIN32)
+# if defined(BASETYPES) || defined(_WINDEF_H)
+/* application has to include <windows.h> to use this */
+#define OSSL_ASYNC_FD       HANDLE
+#define OSSL_BAD_ASYNC_FD   INVALID_HANDLE_VALUE
+# endif
+#else
+#define OSSL_ASYNC_FD       int
+#define OSSL_BAD_ASYNC_FD   -1
+#endif
+# include <openssl/asyncerr.h>
+
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+typedef struct async_job_st ASYNC_JOB;
+typedef struct async_wait_ctx_st ASYNC_WAIT_CTX;
+typedef int (*ASYNC_callback_fn)(void *arg);
+
+#define ASYNC_ERR      0
+#define ASYNC_NO_JOBS  1
+#define ASYNC_PAUSE    2
+#define ASYNC_FINISH   3
+
+#define ASYNC_STATUS_UNSUPPORTED    0
+#define ASYNC_STATUS_ERR            1
+#define ASYNC_STATUS_OK             2
+#define ASYNC_STATUS_EAGAIN         3
+
+int ASYNC_init_thread(size_t max_size, size_t init_size);
+void ASYNC_cleanup_thread(void);
+
+#ifdef OSSL_ASYNC_FD
+ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void);
+void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx);
+int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key,
+                               OSSL_ASYNC_FD fd,
+                               void *custom_data,
+                               void (*cleanup)(ASYNC_WAIT_CTX *, const void *,
+                                               OSSL_ASYNC_FD, void *));
+int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key,
+                        OSSL_ASYNC_FD *fd, void **custom_data);
+int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd,
+                               size_t *numfds);
+int ASYNC_WAIT_CTX_get_callback(ASYNC_WAIT_CTX *ctx,
+                                ASYNC_callback_fn *callback,
+                                void **callback_arg);
+int ASYNC_WAIT_CTX_set_callback(ASYNC_WAIT_CTX *ctx,
+                                ASYNC_callback_fn callback,
+                                void *callback_arg);
+int ASYNC_WAIT_CTX_set_status(ASYNC_WAIT_CTX *ctx, int status);
+int ASYNC_WAIT_CTX_get_status(ASYNC_WAIT_CTX *ctx);
+int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd,
+                                   size_t *numaddfds, OSSL_ASYNC_FD *delfd,
+                                   size_t *numdelfds);
+int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key);
+#endif
+
+int ASYNC_is_capable(void);
+
+int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret,
+                    int (*func)(void *), void *args, size_t size);
+int ASYNC_pause_job(void);
+
+ASYNC_JOB *ASYNC_get_current_job(void);
+ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job);
+void ASYNC_block_pause(void);
+void ASYNC_unblock_pause(void);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/asyncerr.h b/CAPI/cpp/grpc/include/openssl/asyncerr.h
new file mode 100644
index 0000000..c093f7b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/asyncerr.h
@@ -0,0 +1,29 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ASYNCERR_H
+# define OPENSSL_ASYNCERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * ASYNC reason codes.
+ */
+# define ASYNC_R_FAILED_TO_SET_POOL                       101
+# define ASYNC_R_FAILED_TO_SWAP_CONTEXT                   102
+# define ASYNC_R_INIT_FAILED                              105
+# define ASYNC_R_INVALID_POOL_SIZE                        103
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/bio.h b/CAPI/cpp/grpc/include/openssl/bio.h
new file mode 100644
index 0000000..0c1077e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/bio.h
@@ -0,0 +1,886 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\bio.h.in
+ *
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+#ifndef OPENSSL_BIO_H
+# define OPENSSL_BIO_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_BIO_H
+# endif
+
+# include <openssl/e_os2.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <stdarg.h>
+
+# include <openssl/crypto.h>
+# include <openssl/bioerr.h>
+# include <openssl/core.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* There are the classes of BIOs */
+# define BIO_TYPE_DESCRIPTOR     0x0100 /* socket, fd, connect or accept */
+# define BIO_TYPE_FILTER         0x0200
+# define BIO_TYPE_SOURCE_SINK    0x0400
+
+/* These are the 'types' of BIOs */
+# define BIO_TYPE_NONE             0
+# define BIO_TYPE_MEM            ( 1|BIO_TYPE_SOURCE_SINK)
+# define BIO_TYPE_FILE           ( 2|BIO_TYPE_SOURCE_SINK)
+
+# define BIO_TYPE_FD             ( 4|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# define BIO_TYPE_SOCKET         ( 5|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# define BIO_TYPE_NULL           ( 6|BIO_TYPE_SOURCE_SINK)
+# define BIO_TYPE_SSL            ( 7|BIO_TYPE_FILTER)
+# define BIO_TYPE_MD             ( 8|BIO_TYPE_FILTER)
+# define BIO_TYPE_BUFFER         ( 9|BIO_TYPE_FILTER)
+# define BIO_TYPE_CIPHER         (10|BIO_TYPE_FILTER)
+# define BIO_TYPE_BASE64         (11|BIO_TYPE_FILTER)
+# define BIO_TYPE_CONNECT        (12|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# define BIO_TYPE_ACCEPT         (13|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+
+# define BIO_TYPE_NBIO_TEST      (16|BIO_TYPE_FILTER)/* server proxy BIO */
+# define BIO_TYPE_NULL_FILTER    (17|BIO_TYPE_FILTER)
+# define BIO_TYPE_BIO            (19|BIO_TYPE_SOURCE_SINK)/* half a BIO pair */
+# define BIO_TYPE_LINEBUFFER     (20|BIO_TYPE_FILTER)
+# define BIO_TYPE_DGRAM          (21|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# define BIO_TYPE_ASN1           (22|BIO_TYPE_FILTER)
+# define BIO_TYPE_COMP           (23|BIO_TYPE_FILTER)
+# ifndef OPENSSL_NO_SCTP
+#  define BIO_TYPE_DGRAM_SCTP    (24|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
+# endif
+# define BIO_TYPE_CORE_TO_PROV   (25|BIO_TYPE_SOURCE_SINK)
+
+#define BIO_TYPE_START           128
+
+/*
+ * BIO_FILENAME_READ|BIO_CLOSE to open or close on free.
+ * BIO_set_fp(in,stdin,BIO_NOCLOSE);
+ */
+# define BIO_NOCLOSE             0x00
+# define BIO_CLOSE               0x01
+
+/*
+ * These are used in the following macros and are passed to BIO_ctrl()
+ */
+# define BIO_CTRL_RESET          1/* opt - rewind/zero etc */
+# define BIO_CTRL_EOF            2/* opt - are we at the eof */
+# define BIO_CTRL_INFO           3/* opt - extra tit-bits */
+# define BIO_CTRL_SET            4/* man - set the 'IO' type */
+# define BIO_CTRL_GET            5/* man - get the 'IO' type */
+# define BIO_CTRL_PUSH           6/* opt - internal, used to signify change */
+# define BIO_CTRL_POP            7/* opt - internal, used to signify change */
+# define BIO_CTRL_GET_CLOSE      8/* man - set the 'close' on free */
+# define BIO_CTRL_SET_CLOSE      9/* man - set the 'close' on free */
+# define BIO_CTRL_PENDING        10/* opt - is their more data buffered */
+# define BIO_CTRL_FLUSH          11/* opt - 'flush' buffered output */
+# define BIO_CTRL_DUP            12/* man - extra stuff for 'duped' BIO */
+# define BIO_CTRL_WPENDING       13/* opt - number of bytes still to write */
+# define BIO_CTRL_SET_CALLBACK   14/* opt - set callback function */
+# define BIO_CTRL_GET_CALLBACK   15/* opt - set callback function */
+
+# define BIO_CTRL_PEEK           29/* BIO_f_buffer special */
+# define BIO_CTRL_SET_FILENAME   30/* BIO_s_file special */
+
+/* dgram BIO stuff */
+# define BIO_CTRL_DGRAM_CONNECT       31/* BIO dgram special */
+# define BIO_CTRL_DGRAM_SET_CONNECTED 32/* allow for an externally connected
+                                         * socket to be passed in */
+# define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33/* setsockopt, essentially */
+# define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34/* getsockopt, essentially */
+# define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35/* setsockopt, essentially */
+# define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36/* getsockopt, essentially */
+
+# define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37/* flag whether the last */
+# define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38/* I/O operation timed out */
+
+/* #ifdef IP_MTU_DISCOVER */
+# define BIO_CTRL_DGRAM_MTU_DISCOVER       39/* set DF bit on egress packets */
+/* #endif */
+
+# define BIO_CTRL_DGRAM_QUERY_MTU          40/* as kernel for current MTU */
+# define BIO_CTRL_DGRAM_GET_FALLBACK_MTU   47
+# define BIO_CTRL_DGRAM_GET_MTU            41/* get cached value for MTU */
+# define BIO_CTRL_DGRAM_SET_MTU            42/* set cached value for MTU.
+                                              * want to use this if asking
+                                              * the kernel fails */
+
+# define BIO_CTRL_DGRAM_MTU_EXCEEDED       43/* check whether the MTU was
+                                              * exceed in the previous write
+                                              * operation */
+
+# define BIO_CTRL_DGRAM_GET_PEER           46
+# define BIO_CTRL_DGRAM_SET_PEER           44/* Destination for the data */
+
+# define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT   45/* Next DTLS handshake timeout
+                                              * to adjust socket timeouts */
+# define BIO_CTRL_DGRAM_SET_DONT_FRAG      48
+
+# define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD   49
+
+/* Deliberately outside of OPENSSL_NO_SCTP - used in bss_dgram.c */
+#  define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE    50
+# ifndef OPENSSL_NO_SCTP
+/* SCTP stuff */
+#  define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY                51
+#  define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY               52
+#  define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD               53
+#  define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO         60
+#  define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO         61
+#  define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO         62
+#  define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO         63
+#  define BIO_CTRL_DGRAM_SCTP_GET_PRINFO                  64
+#  define BIO_CTRL_DGRAM_SCTP_SET_PRINFO                  65
+#  define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN               70
+# endif
+
+# define BIO_CTRL_DGRAM_SET_PEEK_MODE      71
+
+/*
+ * internal BIO:
+ * # define BIO_CTRL_SET_KTLS_SEND                 72
+ * # define BIO_CTRL_SET_KTLS_SEND_CTRL_MSG        74
+ * # define BIO_CTRL_CLEAR_KTLS_CTRL_MSG           75
+ */
+
+# define BIO_CTRL_GET_KTLS_SEND                 73
+# define BIO_CTRL_GET_KTLS_RECV                 76
+
+# define BIO_CTRL_DGRAM_SCTP_WAIT_FOR_DRY       77
+# define BIO_CTRL_DGRAM_SCTP_MSG_WAITING        78
+
+/* BIO_f_prefix controls */
+# define BIO_CTRL_SET_PREFIX                    79
+# define BIO_CTRL_SET_INDENT                    80
+# define BIO_CTRL_GET_INDENT                    81
+
+# ifndef OPENSSL_NO_KTLS
+#  define BIO_get_ktls_send(b)         \
+     (BIO_ctrl(b, BIO_CTRL_GET_KTLS_SEND, 0, NULL) > 0)
+#  define BIO_get_ktls_recv(b)         \
+     (BIO_ctrl(b, BIO_CTRL_GET_KTLS_RECV, 0, NULL) > 0)
+# else
+#  define BIO_get_ktls_send(b)  (0)
+#  define BIO_get_ktls_recv(b)  (0)
+# endif
+
+/* modifiers */
+# define BIO_FP_READ             0x02
+# define BIO_FP_WRITE            0x04
+# define BIO_FP_APPEND           0x08
+# define BIO_FP_TEXT             0x10
+
+# define BIO_FLAGS_READ          0x01
+# define BIO_FLAGS_WRITE         0x02
+# define BIO_FLAGS_IO_SPECIAL    0x04
+# define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL)
+# define BIO_FLAGS_SHOULD_RETRY  0x08
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/* This #define was replaced by an internal constant and should not be used. */
+#  define BIO_FLAGS_UPLINK       0
+# endif
+
+# define BIO_FLAGS_BASE64_NO_NL  0x100
+
+/*
+ * This is used with memory BIOs:
+ * BIO_FLAGS_MEM_RDONLY means we shouldn't free up or change the data in any way;
+ * BIO_FLAGS_NONCLEAR_RST means we shouldn't clear data on reset.
+ */
+# define BIO_FLAGS_MEM_RDONLY    0x200
+# define BIO_FLAGS_NONCLEAR_RST  0x400
+# define BIO_FLAGS_IN_EOF        0x800
+
+/* the BIO FLAGS values 0x1000 to 0x4000 are reserved for internal KTLS flags */
+
+typedef union bio_addr_st BIO_ADDR;
+typedef struct bio_addrinfo_st BIO_ADDRINFO;
+
+int BIO_get_new_index(void);
+void BIO_set_flags(BIO *b, int flags);
+int BIO_test_flags(const BIO *b, int flags);
+void BIO_clear_flags(BIO *b, int flags);
+
+# define BIO_get_flags(b) BIO_test_flags(b, ~(0x0))
+# define BIO_set_retry_special(b) \
+                BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
+# define BIO_set_retry_read(b) \
+                BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
+# define BIO_set_retry_write(b) \
+                BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY))
+
+/* These are normally used internally in BIOs */
+# define BIO_clear_retry_flags(b) \
+                BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+# define BIO_get_retry_flags(b) \
+                BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+
+/* These should be used by the application to tell why we should retry */
+# define BIO_should_read(a)              BIO_test_flags(a, BIO_FLAGS_READ)
+# define BIO_should_write(a)             BIO_test_flags(a, BIO_FLAGS_WRITE)
+# define BIO_should_io_special(a)        BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL)
+# define BIO_retry_type(a)               BIO_test_flags(a, BIO_FLAGS_RWS)
+# define BIO_should_retry(a)             BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY)
+
+/*
+ * The next three are used in conjunction with the BIO_should_io_special()
+ * condition.  After this returns true, BIO *BIO_get_retry_BIO(BIO *bio, int
+ * *reason); will walk the BIO stack and return the 'reason' for the special
+ * and the offending BIO. Given a BIO, BIO_get_retry_reason(bio) will return
+ * the code.
+ */
+/*
+ * Returned from the SSL bio when the certificate retrieval code had an error
+ */
+# define BIO_RR_SSL_X509_LOOKUP          0x01
+/* Returned from the connect BIO when a connect would have blocked */
+# define BIO_RR_CONNECT                  0x02
+/* Returned from the accept BIO when an accept would have blocked */
+# define BIO_RR_ACCEPT                   0x03
+
+/* These are passed by the BIO callback */
+# define BIO_CB_FREE     0x01
+# define BIO_CB_READ     0x02
+# define BIO_CB_WRITE    0x03
+# define BIO_CB_PUTS     0x04
+# define BIO_CB_GETS     0x05
+# define BIO_CB_CTRL     0x06
+
+/*
+ * The callback is called before and after the underling operation, The
+ * BIO_CB_RETURN flag indicates if it is after the call
+ */
+# define BIO_CB_RETURN   0x80
+# define BIO_CB_return(a) ((a)|BIO_CB_RETURN)
+# define BIO_cb_pre(a)   (!((a)&BIO_CB_RETURN))
+# define BIO_cb_post(a)  ((a)&BIO_CB_RETURN)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi,
+                                long argl, long ret);
+OSSL_DEPRECATEDIN_3_0 BIO_callback_fn BIO_get_callback(const BIO *b);
+OSSL_DEPRECATEDIN_3_0 void BIO_set_callback(BIO *b, BIO_callback_fn callback);
+OSSL_DEPRECATEDIN_3_0 long BIO_debug_callback(BIO *bio, int cmd,
+                                               const char *argp, int argi,
+                                               long argl, long ret);
+# endif
+
+typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp,
+                                   size_t len, int argi,
+                                   long argl, int ret, size_t *processed);
+BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b);
+void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback);
+long BIO_debug_callback_ex(BIO *bio, int oper, const char *argp, size_t len,
+                           int argi, long argl, int ret, size_t *processed);
+
+char *BIO_get_callback_arg(const BIO *b);
+void BIO_set_callback_arg(BIO *b, char *arg);
+
+typedef struct bio_method_st BIO_METHOD;
+
+const char *BIO_method_name(const BIO *b);
+int BIO_method_type(const BIO *b);
+
+typedef int BIO_info_cb(BIO *, int, int);
+typedef BIO_info_cb bio_info_cb;  /* backward compatibility */
+
+SKM_DEFINE_STACK_OF_INTERNAL(BIO, BIO, BIO)
+#define sk_BIO_num(sk) OPENSSL_sk_num(ossl_check_const_BIO_sk_type(sk))
+#define sk_BIO_value(sk, idx) ((BIO *)OPENSSL_sk_value(ossl_check_const_BIO_sk_type(sk), (idx)))
+#define sk_BIO_new(cmp) ((STACK_OF(BIO) *)OPENSSL_sk_new(ossl_check_BIO_compfunc_type(cmp)))
+#define sk_BIO_new_null() ((STACK_OF(BIO) *)OPENSSL_sk_new_null())
+#define sk_BIO_new_reserve(cmp, n) ((STACK_OF(BIO) *)OPENSSL_sk_new_reserve(ossl_check_BIO_compfunc_type(cmp), (n)))
+#define sk_BIO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_BIO_sk_type(sk), (n))
+#define sk_BIO_free(sk) OPENSSL_sk_free(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_zero(sk) OPENSSL_sk_zero(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_delete(sk, i) ((BIO *)OPENSSL_sk_delete(ossl_check_BIO_sk_type(sk), (i)))
+#define sk_BIO_delete_ptr(sk, ptr) ((BIO *)OPENSSL_sk_delete_ptr(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr)))
+#define sk_BIO_push(sk, ptr) OPENSSL_sk_push(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_pop(sk) ((BIO *)OPENSSL_sk_pop(ossl_check_BIO_sk_type(sk)))
+#define sk_BIO_shift(sk) ((BIO *)OPENSSL_sk_shift(ossl_check_BIO_sk_type(sk)))
+#define sk_BIO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_BIO_sk_type(sk),ossl_check_BIO_freefunc_type(freefunc))
+#define sk_BIO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr), (idx))
+#define sk_BIO_set(sk, idx, ptr) ((BIO *)OPENSSL_sk_set(ossl_check_BIO_sk_type(sk), (idx), ossl_check_BIO_type(ptr)))
+#define sk_BIO_find(sk, ptr) OPENSSL_sk_find(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
+#define sk_BIO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr), pnum)
+#define sk_BIO_sort(sk) OPENSSL_sk_sort(ossl_check_BIO_sk_type(sk))
+#define sk_BIO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_BIO_sk_type(sk))
+#define sk_BIO_dup(sk) ((STACK_OF(BIO) *)OPENSSL_sk_dup(ossl_check_const_BIO_sk_type(sk)))
+#define sk_BIO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(BIO) *)OPENSSL_sk_deep_copy(ossl_check_const_BIO_sk_type(sk), ossl_check_BIO_copyfunc_type(copyfunc), ossl_check_BIO_freefunc_type(freefunc)))
+#define sk_BIO_set_cmp_func(sk, cmp) ((sk_BIO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_BIO_sk_type(sk), ossl_check_BIO_compfunc_type(cmp)))
+
+
+
+/* Prefix and suffix callback in ASN1 BIO */
+typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen,
+                          void *parg);
+
+typedef void (*BIO_dgram_sctp_notification_handler_fn) (BIO *b,
+                                                        void *context,
+                                                        void *buf);
+# ifndef OPENSSL_NO_SCTP
+/* SCTP parameter structs */
+struct bio_dgram_sctp_sndinfo {
+    uint16_t snd_sid;
+    uint16_t snd_flags;
+    uint32_t snd_ppid;
+    uint32_t snd_context;
+};
+
+struct bio_dgram_sctp_rcvinfo {
+    uint16_t rcv_sid;
+    uint16_t rcv_ssn;
+    uint16_t rcv_flags;
+    uint32_t rcv_ppid;
+    uint32_t rcv_tsn;
+    uint32_t rcv_cumtsn;
+    uint32_t rcv_context;
+};
+
+struct bio_dgram_sctp_prinfo {
+    uint16_t pr_policy;
+    uint32_t pr_value;
+};
+# endif
+
+/*
+ * #define BIO_CONN_get_param_hostname BIO_ctrl
+ */
+
+# define BIO_C_SET_CONNECT                       100
+# define BIO_C_DO_STATE_MACHINE                  101
+# define BIO_C_SET_NBIO                          102
+/* # define BIO_C_SET_PROXY_PARAM                   103 */
+# define BIO_C_SET_FD                            104
+# define BIO_C_GET_FD                            105
+# define BIO_C_SET_FILE_PTR                      106
+# define BIO_C_GET_FILE_PTR                      107
+# define BIO_C_SET_FILENAME                      108
+# define BIO_C_SET_SSL                           109
+# define BIO_C_GET_SSL                           110
+# define BIO_C_SET_MD                            111
+# define BIO_C_GET_MD                            112
+# define BIO_C_GET_CIPHER_STATUS                 113
+# define BIO_C_SET_BUF_MEM                       114
+# define BIO_C_GET_BUF_MEM_PTR                   115
+# define BIO_C_GET_BUFF_NUM_LINES                116
+# define BIO_C_SET_BUFF_SIZE                     117
+# define BIO_C_SET_ACCEPT                        118
+# define BIO_C_SSL_MODE                          119
+# define BIO_C_GET_MD_CTX                        120
+/* # define BIO_C_GET_PROXY_PARAM                   121 */
+# define BIO_C_SET_BUFF_READ_DATA                122/* data to read first */
+# define BIO_C_GET_CONNECT                       123
+# define BIO_C_GET_ACCEPT                        124
+# define BIO_C_SET_SSL_RENEGOTIATE_BYTES         125
+# define BIO_C_GET_SSL_NUM_RENEGOTIATES          126
+# define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT       127
+# define BIO_C_FILE_SEEK                         128
+# define BIO_C_GET_CIPHER_CTX                    129
+# define BIO_C_SET_BUF_MEM_EOF_RETURN            130/* return end of input
+                                                     * value */
+# define BIO_C_SET_BIND_MODE                     131
+# define BIO_C_GET_BIND_MODE                     132
+# define BIO_C_FILE_TELL                         133
+# define BIO_C_GET_SOCKS                         134
+# define BIO_C_SET_SOCKS                         135
+
+# define BIO_C_SET_WRITE_BUF_SIZE                136/* for BIO_s_bio */
+# define BIO_C_GET_WRITE_BUF_SIZE                137
+# define BIO_C_MAKE_BIO_PAIR                     138
+# define BIO_C_DESTROY_BIO_PAIR                  139
+# define BIO_C_GET_WRITE_GUARANTEE               140
+# define BIO_C_GET_READ_REQUEST                  141
+# define BIO_C_SHUTDOWN_WR                       142
+# define BIO_C_NREAD0                            143
+# define BIO_C_NREAD                             144
+# define BIO_C_NWRITE0                           145
+# define BIO_C_NWRITE                            146
+# define BIO_C_RESET_READ_REQUEST                147
+# define BIO_C_SET_MD_CTX                        148
+
+# define BIO_C_SET_PREFIX                        149
+# define BIO_C_GET_PREFIX                        150
+# define BIO_C_SET_SUFFIX                        151
+# define BIO_C_GET_SUFFIX                        152
+
+# define BIO_C_SET_EX_ARG                        153
+# define BIO_C_GET_EX_ARG                        154
+
+# define BIO_C_SET_CONNECT_MODE                  155
+
+# define BIO_set_app_data(s,arg)         BIO_set_ex_data(s,0,arg)
+# define BIO_get_app_data(s)             BIO_get_ex_data(s,0)
+
+# define BIO_set_nbio(b,n)             BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL)
+
+# ifndef OPENSSL_NO_SOCK
+/* IP families we support, for BIO_s_connect() and BIO_s_accept() */
+/* Note: the underlying operating system may not support some of them */
+#  define BIO_FAMILY_IPV4                         4
+#  define BIO_FAMILY_IPV6                         6
+#  define BIO_FAMILY_IPANY                        256
+
+/* BIO_s_connect() */
+#  define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0, \
+                                                 (char *)(name))
+#  define BIO_set_conn_port(b,port)     BIO_ctrl(b,BIO_C_SET_CONNECT,1, \
+                                                 (char *)(port))
+#  define BIO_set_conn_address(b,addr)  BIO_ctrl(b,BIO_C_SET_CONNECT,2, \
+                                                 (char *)(addr))
+#  define BIO_set_conn_ip_family(b,f)   BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,f)
+#  define BIO_get_conn_hostname(b)      ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0))
+#  define BIO_get_conn_port(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1))
+#  define BIO_get_conn_address(b)       ((const BIO_ADDR *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2))
+#  define BIO_get_conn_ip_family(b)     BIO_ctrl(b,BIO_C_GET_CONNECT,3,NULL)
+#  define BIO_set_conn_mode(b,n)        BIO_ctrl(b,BIO_C_SET_CONNECT_MODE,(n),NULL)
+
+/* BIO_s_accept() */
+#  define BIO_set_accept_name(b,name)   BIO_ctrl(b,BIO_C_SET_ACCEPT,0, \
+                                                 (char *)(name))
+#  define BIO_set_accept_port(b,port)   BIO_ctrl(b,BIO_C_SET_ACCEPT,1, \
+                                                 (char *)(port))
+#  define BIO_get_accept_name(b)        ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0))
+#  define BIO_get_accept_port(b)        ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,1))
+#  define BIO_get_peer_name(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,2))
+#  define BIO_get_peer_port(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,3))
+/* #define BIO_set_nbio(b,n)    BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */
+#  define BIO_set_nbio_accept(b,n)      BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(n)?(void *)"a":NULL)
+#  define BIO_set_accept_bios(b,bio)    BIO_ctrl(b,BIO_C_SET_ACCEPT,3, \
+                                                 (char *)(bio))
+#  define BIO_set_accept_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_ACCEPT,4,f)
+#  define BIO_get_accept_ip_family(b)   BIO_ctrl(b,BIO_C_GET_ACCEPT,4,NULL)
+
+/* Aliases kept for backward compatibility */
+#  define BIO_BIND_NORMAL                 0
+#  define BIO_BIND_REUSEADDR              BIO_SOCK_REUSEADDR
+#  define BIO_BIND_REUSEADDR_IF_UNUSED    BIO_SOCK_REUSEADDR
+#  define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL)
+#  define BIO_get_bind_mode(b)    BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL)
+# endif /* OPENSSL_NO_SOCK */
+
+# define BIO_do_connect(b)       BIO_do_handshake(b)
+# define BIO_do_accept(b)        BIO_do_handshake(b)
+
+# define BIO_do_handshake(b)     BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL)
+
+/* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */
+# define BIO_set_fd(b,fd,c)      BIO_int_ctrl(b,BIO_C_SET_FD,c,fd)
+# define BIO_get_fd(b,c)         BIO_ctrl(b,BIO_C_GET_FD,0,(char *)(c))
+
+/* BIO_s_file() */
+# define BIO_set_fp(b,fp,c)      BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)(fp))
+# define BIO_get_fp(b,fpp)       BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)(fpp))
+
+/* BIO_s_fd() and BIO_s_file() */
+# define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL)
+# define BIO_tell(b)     (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL)
+
+/*
+ * name is cast to lose const, but might be better to route through a
+ * function so we can do it safely
+ */
+# ifdef CONST_STRICT
+/*
+ * If you are wondering why this isn't defined, its because CONST_STRICT is
+ * purely a compile-time kludge to allow const to be checked.
+ */
+int BIO_read_filename(BIO *b, const char *name);
+# else
+#  define BIO_read_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_READ,(char *)(name))
+# endif
+# define BIO_write_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_WRITE,name)
+# define BIO_append_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_APPEND,name)
+# define BIO_rw_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name)
+
+/*
+ * WARNING WARNING, this ups the reference count on the read bio of the SSL
+ * structure.  This is because the ssl read BIO is now pointed to by the
+ * next_bio field in the bio.  So when you free the BIO, make sure you are
+ * doing a BIO_free_all() to catch the underlying BIO.
+ */
+# define BIO_set_ssl(b,ssl,c)    BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)(ssl))
+# define BIO_get_ssl(b,sslp)     BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)(sslp))
+# define BIO_set_ssl_mode(b,client)      BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL)
+# define BIO_set_ssl_renegotiate_bytes(b,num) \
+        BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL)
+# define BIO_get_num_renegotiates(b) \
+        BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL)
+# define BIO_set_ssl_renegotiate_timeout(b,seconds) \
+        BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL)
+
+/* defined in evp.h */
+/* #define BIO_set_md(b,md)     BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */
+
+# define BIO_get_mem_data(b,pp)  BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)(pp))
+# define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)(bm))
+# define BIO_get_mem_ptr(b,pp)   BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0, \
+                                          (char *)(pp))
+# define BIO_set_mem_eof_return(b,v) \
+                                BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL)
+
+/* For the BIO_f_buffer() type */
+# define BIO_get_buffer_num_lines(b)     BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL)
+# define BIO_set_buffer_size(b,size)     BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL)
+# define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0)
+# define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1)
+# define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf)
+
+/* Don't use the next one unless you know what you are doing :-) */
+# define BIO_dup_state(b,ret)    BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret))
+
+# define BIO_reset(b)            (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL)
+# define BIO_eof(b)              (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL)
+# define BIO_set_close(b,c)      (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL)
+# define BIO_get_close(b)        (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL)
+# define BIO_pending(b)          (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL)
+# define BIO_wpending(b)         (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL)
+/* ...pending macros have inappropriate return type */
+size_t BIO_ctrl_pending(BIO *b);
+size_t BIO_ctrl_wpending(BIO *b);
+# define BIO_flush(b)            (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL)
+# define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \
+                                                   cbp)
+# define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb)
+
+/* For the BIO_f_buffer() type */
+# define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL)
+# define BIO_buffer_peek(b,s,l) BIO_ctrl(b,BIO_CTRL_PEEK,(l),(s))
+
+/* For BIO_s_bio() */
+# define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL)
+# define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL)
+# define BIO_make_bio_pair(b1,b2)   (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2)
+# define BIO_destroy_bio_pair(b)    (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL)
+# define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL)
+/* macros with inappropriate type -- but ...pending macros use int too: */
+# define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL)
+# define BIO_get_read_request(b)    (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL)
+size_t BIO_ctrl_get_write_guarantee(BIO *b);
+size_t BIO_ctrl_get_read_request(BIO *b);
+int BIO_ctrl_reset_read_request(BIO *b);
+
+/* ctrl macros for dgram */
+# define BIO_ctrl_dgram_connect(b,peer)  \
+                     (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)(peer))
+# define BIO_ctrl_set_connected(b,peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char *)(peer))
+# define BIO_dgram_recv_timedout(b) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL)
+# define BIO_dgram_send_timedout(b) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL)
+# define BIO_dgram_get_peer(b,peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)(peer))
+# define BIO_dgram_set_peer(b,peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)(peer))
+# define BIO_dgram_get_mtu_overhead(b) \
+         (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL)
+
+/* ctrl macros for BIO_f_prefix */
+# define BIO_set_prefix(b,p) BIO_ctrl((b), BIO_CTRL_SET_PREFIX, 0, (void *)(p))
+# define BIO_set_indent(b,i) BIO_ctrl((b), BIO_CTRL_SET_INDENT, (i), NULL)
+# define BIO_get_indent(b) BIO_ctrl((b), BIO_CTRL_GET_INDENT, 0, NULL)
+
+#define BIO_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, l, p, newf, dupf, freef)
+int BIO_set_ex_data(BIO *bio, int idx, void *data);
+void *BIO_get_ex_data(const BIO *bio, int idx);
+uint64_t BIO_number_read(BIO *bio);
+uint64_t BIO_number_written(BIO *bio);
+
+/* For BIO_f_asn1() */
+int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
+                        asn1_ps_func *prefix_free);
+int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
+                        asn1_ps_func **pprefix_free);
+int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
+                        asn1_ps_func *suffix_free);
+int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
+                        asn1_ps_func **psuffix_free);
+
+const BIO_METHOD *BIO_s_file(void);
+BIO *BIO_new_file(const char *filename, const char *mode);
+BIO *BIO_new_from_core_bio(OSSL_LIB_CTX *libctx, OSSL_CORE_BIO *corebio);
+# ifndef OPENSSL_NO_STDIO
+BIO *BIO_new_fp(FILE *stream, int close_flag);
+# endif
+BIO *BIO_new_ex(OSSL_LIB_CTX *libctx, const BIO_METHOD *method);
+BIO *BIO_new(const BIO_METHOD *type);
+int BIO_free(BIO *a);
+void BIO_set_data(BIO *a, void *ptr);
+void *BIO_get_data(BIO *a);
+void BIO_set_init(BIO *a, int init);
+int BIO_get_init(BIO *a);
+void BIO_set_shutdown(BIO *a, int shut);
+int BIO_get_shutdown(BIO *a);
+void BIO_vfree(BIO *a);
+int BIO_up_ref(BIO *a);
+int BIO_read(BIO *b, void *data, int dlen);
+int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes);
+int BIO_gets(BIO *bp, char *buf, int size);
+int BIO_get_line(BIO *bio, char *buf, int size);
+int BIO_write(BIO *b, const void *data, int dlen);
+int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written);
+int BIO_puts(BIO *bp, const char *buf);
+int BIO_indent(BIO *b, int indent, int max);
+long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg);
+long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
+void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
+long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
+BIO *BIO_push(BIO *b, BIO *append);
+BIO *BIO_pop(BIO *b);
+void BIO_free_all(BIO *a);
+BIO *BIO_find_type(BIO *b, int bio_type);
+BIO *BIO_next(BIO *b);
+void BIO_set_next(BIO *b, BIO *next);
+BIO *BIO_get_retry_BIO(BIO *bio, int *reason);
+int BIO_get_retry_reason(BIO *bio);
+void BIO_set_retry_reason(BIO *bio, int reason);
+BIO *BIO_dup_chain(BIO *in);
+
+int BIO_nread0(BIO *bio, char **buf);
+int BIO_nread(BIO *bio, char **buf, int num);
+int BIO_nwrite0(BIO *bio, char **buf);
+int BIO_nwrite(BIO *bio, char **buf, int num);
+
+const BIO_METHOD *BIO_s_mem(void);
+const BIO_METHOD *BIO_s_secmem(void);
+BIO *BIO_new_mem_buf(const void *buf, int len);
+# ifndef OPENSSL_NO_SOCK
+const BIO_METHOD *BIO_s_socket(void);
+const BIO_METHOD *BIO_s_connect(void);
+const BIO_METHOD *BIO_s_accept(void);
+# endif
+const BIO_METHOD *BIO_s_fd(void);
+const BIO_METHOD *BIO_s_log(void);
+const BIO_METHOD *BIO_s_bio(void);
+const BIO_METHOD *BIO_s_null(void);
+const BIO_METHOD *BIO_f_null(void);
+const BIO_METHOD *BIO_f_buffer(void);
+const BIO_METHOD *BIO_f_readbuffer(void);
+const BIO_METHOD *BIO_f_linebuffer(void);
+const BIO_METHOD *BIO_f_nbio_test(void);
+const BIO_METHOD *BIO_f_prefix(void);
+const BIO_METHOD *BIO_s_core(void);
+# ifndef OPENSSL_NO_DGRAM
+const BIO_METHOD *BIO_s_datagram(void);
+int BIO_dgram_non_fatal_error(int error);
+BIO *BIO_new_dgram(int fd, int close_flag);
+#  ifndef OPENSSL_NO_SCTP
+const BIO_METHOD *BIO_s_datagram_sctp(void);
+BIO *BIO_new_dgram_sctp(int fd, int close_flag);
+int BIO_dgram_is_sctp(BIO *bio);
+int BIO_dgram_sctp_notification_cb(BIO *b,
+                BIO_dgram_sctp_notification_handler_fn handle_notifications,
+                void *context);
+int BIO_dgram_sctp_wait_for_dry(BIO *b);
+int BIO_dgram_sctp_msg_waiting(BIO *b);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_SOCK
+int BIO_sock_should_retry(int i);
+int BIO_sock_non_fatal_error(int error);
+int BIO_socket_wait(int fd, int for_read, time_t max_time);
+# endif
+int BIO_wait(BIO *bio, time_t max_time, unsigned int nap_milliseconds);
+int BIO_do_connect_retry(BIO *bio, int timeout, int nap_milliseconds);
+
+int BIO_fd_should_retry(int i);
+int BIO_fd_non_fatal_error(int error);
+int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u),
+                void *u, const void *s, int len);
+int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u),
+                       void *u, const void *s, int len, int indent);
+int BIO_dump(BIO *b, const void *bytes, int len);
+int BIO_dump_indent(BIO *b, const void *bytes, int len, int indent);
+# ifndef OPENSSL_NO_STDIO
+int BIO_dump_fp(FILE *fp, const void *s, int len);
+int BIO_dump_indent_fp(FILE *fp, const void *s, int len, int indent);
+# endif
+int BIO_hex_string(BIO *out, int indent, int width, const void *data,
+                   int datalen);
+
+# ifndef OPENSSL_NO_SOCK
+BIO_ADDR *BIO_ADDR_new(void);
+int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
+                     const void *where, size_t wherelen, unsigned short port);
+void BIO_ADDR_free(BIO_ADDR *);
+void BIO_ADDR_clear(BIO_ADDR *ap);
+int BIO_ADDR_family(const BIO_ADDR *ap);
+int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l);
+unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap);
+char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric);
+char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric);
+char *BIO_ADDR_path_string(const BIO_ADDR *ap);
+
+const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai);
+int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai);
+const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai);
+void BIO_ADDRINFO_free(BIO_ADDRINFO *bai);
+
+enum BIO_hostserv_priorities {
+    BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV
+};
+int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
+                       enum BIO_hostserv_priorities hostserv_prio);
+enum BIO_lookup_type {
+    BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER
+};
+int BIO_lookup(const char *host, const char *service,
+               enum BIO_lookup_type lookup_type,
+               int family, int socktype, BIO_ADDRINFO **res);
+int BIO_lookup_ex(const char *host, const char *service,
+                  int lookup_type, int family, int socktype, int protocol,
+                  BIO_ADDRINFO **res);
+int BIO_sock_error(int sock);
+int BIO_socket_ioctl(int fd, long type, void *arg);
+int BIO_socket_nbio(int fd, int mode);
+int BIO_sock_init(void);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define BIO_sock_cleanup() while(0) continue
+# endif
+int BIO_set_tcp_ndelay(int sock, int turn_on);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 struct hostent *BIO_gethostbyname(const char *name);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_port(const char *str, unsigned short *port_ptr);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_host_ip(const char *str, unsigned char *ip);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_get_accept_socket(char *host_port, int mode);
+OSSL_DEPRECATEDIN_1_1_0 int BIO_accept(int sock, char **ip_port);
+# endif
+
+union BIO_sock_info_u {
+    BIO_ADDR *addr;
+};
+enum BIO_sock_info_type {
+    BIO_SOCK_INFO_ADDRESS
+};
+int BIO_sock_info(int sock,
+                  enum BIO_sock_info_type type, union BIO_sock_info_u *info);
+
+#  define BIO_SOCK_REUSEADDR    0x01
+#  define BIO_SOCK_V6_ONLY      0x02
+#  define BIO_SOCK_KEEPALIVE    0x04
+#  define BIO_SOCK_NONBLOCK     0x08
+#  define BIO_SOCK_NODELAY      0x10
+
+int BIO_socket(int domain, int socktype, int protocol, int options);
+int BIO_connect(int sock, const BIO_ADDR *addr, int options);
+int BIO_bind(int sock, const BIO_ADDR *addr, int options);
+int BIO_listen(int sock, const BIO_ADDR *addr, int options);
+int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options);
+int BIO_closesocket(int sock);
+
+BIO *BIO_new_socket(int sock, int close_flag);
+BIO *BIO_new_connect(const char *host_port);
+BIO *BIO_new_accept(const char *host_port);
+# endif /* OPENSSL_NO_SOCK*/
+
+BIO *BIO_new_fd(int fd, int close_flag);
+
+int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
+                     BIO **bio2, size_t writebuf2);
+/*
+ * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints.
+ * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default
+ * value.
+ */
+
+void BIO_copy_next_retry(BIO *b);
+
+/*
+ * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);
+ */
+
+# define ossl_bio__attr__(x)
+# if defined(__GNUC__) && defined(__STDC_VERSION__) \
+    && !defined(__APPLE__)
+    /*
+     * Because we support the 'z' modifier, which made its appearance in C99,
+     * we can't use __attribute__ with pre C99 dialects.
+     */
+#  if __STDC_VERSION__ >= 199901L
+#   undef ossl_bio__attr__
+#   define ossl_bio__attr__ __attribute__
+#   if __GNUC__*10 + __GNUC_MINOR__ >= 44
+#    define ossl_bio__printf__ __gnu_printf__
+#   else
+#    define ossl_bio__printf__ __printf__
+#   endif
+#  endif
+# endif
+int BIO_printf(BIO *bio, const char *format, ...)
+ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3)));
+int BIO_vprintf(BIO *bio, const char *format, va_list args)
+ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0)));
+int BIO_snprintf(char *buf, size_t n, const char *format, ...)
+ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4)));
+int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
+ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0)));
+# undef ossl_bio__attr__
+# undef ossl_bio__printf__
+
+
+BIO_METHOD *BIO_meth_new(int type, const char *name);
+void BIO_meth_free(BIO_METHOD *biom);
+int (*BIO_meth_get_write(const BIO_METHOD *biom)) (BIO *, const char *, int);
+int (*BIO_meth_get_write_ex(const BIO_METHOD *biom)) (BIO *, const char *, size_t,
+                                                size_t *);
+int BIO_meth_set_write(BIO_METHOD *biom,
+                       int (*write) (BIO *, const char *, int));
+int BIO_meth_set_write_ex(BIO_METHOD *biom,
+                       int (*bwrite) (BIO *, const char *, size_t, size_t *));
+int (*BIO_meth_get_read(const BIO_METHOD *biom)) (BIO *, char *, int);
+int (*BIO_meth_get_read_ex(const BIO_METHOD *biom)) (BIO *, char *, size_t, size_t *);
+int BIO_meth_set_read(BIO_METHOD *biom,
+                      int (*read) (BIO *, char *, int));
+int BIO_meth_set_read_ex(BIO_METHOD *biom,
+                         int (*bread) (BIO *, char *, size_t, size_t *));
+int (*BIO_meth_get_puts(const BIO_METHOD *biom)) (BIO *, const char *);
+int BIO_meth_set_puts(BIO_METHOD *biom,
+                      int (*puts) (BIO *, const char *));
+int (*BIO_meth_get_gets(const BIO_METHOD *biom)) (BIO *, char *, int);
+int BIO_meth_set_gets(BIO_METHOD *biom,
+                      int (*gets) (BIO *, char *, int));
+long (*BIO_meth_get_ctrl(const BIO_METHOD *biom)) (BIO *, int, long, void *);
+int BIO_meth_set_ctrl(BIO_METHOD *biom,
+                      long (*ctrl) (BIO *, int, long, void *));
+int (*BIO_meth_get_create(const BIO_METHOD *bion)) (BIO *);
+int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *));
+int (*BIO_meth_get_destroy(const BIO_METHOD *biom)) (BIO *);
+int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *));
+long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom))
+                                 (BIO *, int, BIO_info_cb *);
+int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
+                               long (*callback_ctrl) (BIO *, int,
+                                                      BIO_info_cb *));
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/bioerr.h b/CAPI/cpp/grpc/include/openssl/bioerr.h
new file mode 100644
index 0000000..787b30a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/bioerr.h
@@ -0,0 +1,65 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BIOERR_H
+# define OPENSSL_BIOERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * BIO reason codes.
+ */
+# define BIO_R_ACCEPT_ERROR                               100
+# define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET               141
+# define BIO_R_AMBIGUOUS_HOST_OR_SERVICE                  129
+# define BIO_R_BAD_FOPEN_MODE                             101
+# define BIO_R_BROKEN_PIPE                                124
+# define BIO_R_CONNECT_ERROR                              103
+# define BIO_R_CONNECT_TIMEOUT                            147
+# define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET          107
+# define BIO_R_GETSOCKNAME_ERROR                          132
+# define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS              133
+# define BIO_R_GETTING_SOCKTYPE                           134
+# define BIO_R_INVALID_ARGUMENT                           125
+# define BIO_R_INVALID_SOCKET                             135
+# define BIO_R_IN_USE                                     123
+# define BIO_R_LENGTH_TOO_LONG                            102
+# define BIO_R_LISTEN_V6_ONLY                             136
+# define BIO_R_LOOKUP_RETURNED_NOTHING                    142
+# define BIO_R_MALFORMED_HOST_OR_SERVICE                  130
+# define BIO_R_NBIO_CONNECT_ERROR                         110
+# define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED        143
+# define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED           144
+# define BIO_R_NO_PORT_DEFINED                            113
+# define BIO_R_NO_SUCH_FILE                               128
+# define BIO_R_NULL_PARAMETER                             115 /* unused */
+# define BIO_R_TRANSFER_ERROR                             104
+# define BIO_R_TRANSFER_TIMEOUT                           105
+# define BIO_R_UNABLE_TO_BIND_SOCKET                      117
+# define BIO_R_UNABLE_TO_CREATE_SOCKET                    118
+# define BIO_R_UNABLE_TO_KEEPALIVE                        137
+# define BIO_R_UNABLE_TO_LISTEN_SOCKET                    119
+# define BIO_R_UNABLE_TO_NODELAY                          138
+# define BIO_R_UNABLE_TO_REUSEADDR                        139
+# define BIO_R_UNAVAILABLE_IP_FAMILY                      145
+# define BIO_R_UNINITIALIZED                              120
+# define BIO_R_UNKNOWN_INFO_TYPE                          140
+# define BIO_R_UNSUPPORTED_IP_FAMILY                      146
+# define BIO_R_UNSUPPORTED_METHOD                         121
+# define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY                131
+# define BIO_R_WRITE_TO_READ_ONLY_BIO                     126
+# define BIO_R_WSASTARTUP                                 122
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/blowfish.h b/CAPI/cpp/grpc/include/openssl/blowfish.h
new file mode 100644
index 0000000..667d642
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/blowfish.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BLOWFISH_H
+# define OPENSSL_BLOWFISH_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_BLOWFISH_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_BF
+# include <openssl/e_os2.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define BF_BLOCK        8
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#  define BF_ENCRYPT      1
+#  define BF_DECRYPT      0
+
+/*-
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! BF_LONG has to be at least 32 bits wide.                     !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#  define BF_LONG unsigned int
+
+#  define BF_ROUNDS       16
+
+typedef struct bf_key_st {
+    BF_LONG P[BF_ROUNDS + 2];
+    BF_LONG S[4 * 256];
+} BF_KEY;
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void BF_set_key(BF_KEY *key, int len,
+                                      const unsigned char *data);
+OSSL_DEPRECATEDIN_3_0 void BF_encrypt(BF_LONG *data, const BF_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void BF_decrypt(BF_LONG *data, const BF_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void BF_ecb_encrypt(const unsigned char *in,
+                                          unsigned char *out, const BF_KEY *key,
+                                          int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_cbc_encrypt(const unsigned char *in,
+                                          unsigned char *out, long length,
+                                          const BF_KEY *schedule,
+                                          unsigned char *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_cfb64_encrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            long length, const BF_KEY *schedule,
+                                            unsigned char *ivec, int *num,
+                                            int enc);
+OSSL_DEPRECATEDIN_3_0 void BF_ofb64_encrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            long length, const BF_KEY *schedule,
+                                            unsigned char *ivec, int *num);
+OSSL_DEPRECATEDIN_3_0 const char *BF_options(void);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/bn.h b/CAPI/cpp/grpc/include/openssl/bn.h
new file mode 100644
index 0000000..ecd7f01
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/bn.h
@@ -0,0 +1,583 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BN_H
+# define OPENSSL_BN_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_BN_H
+# endif
+
+# include <openssl/e_os2.h>
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+# include <openssl/crypto.h>
+# include <openssl/bnerr.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * 64-bit processor with LP64 ABI
+ */
+# ifdef SIXTY_FOUR_BIT_LONG
+#  define BN_ULONG        unsigned long
+#  define BN_BYTES        8
+# endif
+
+/*
+ * 64-bit processor other than LP64 ABI
+ */
+# ifdef SIXTY_FOUR_BIT
+#  define BN_ULONG        unsigned long long
+#  define BN_BYTES        8
+# endif
+
+# ifdef THIRTY_TWO_BIT
+#  define BN_ULONG        unsigned int
+#  define BN_BYTES        4
+# endif
+
+# define BN_BITS2       (BN_BYTES * 8)
+# define BN_BITS        (BN_BITS2 * 2)
+# define BN_TBIT        ((BN_ULONG)1 << (BN_BITS2 - 1))
+
+# define BN_FLG_MALLOCED         0x01
+# define BN_FLG_STATIC_DATA      0x02
+
+/*
+ * avoid leaking exponent information through timing,
+ * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime,
+ * BN_div() will call BN_div_no_branch,
+ * BN_mod_inverse() will call bn_mod_inverse_no_branch.
+ */
+# define BN_FLG_CONSTTIME        0x04
+# define BN_FLG_SECURE           0x08
+
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+/* deprecated name for the flag */
+#  define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME
+#  define BN_FLG_FREE            0x8000 /* used for debugging */
+# endif
+
+void BN_set_flags(BIGNUM *b, int n);
+int BN_get_flags(const BIGNUM *b, int n);
+
+/* Values for |top| in BN_rand() */
+#define BN_RAND_TOP_ANY    -1
+#define BN_RAND_TOP_ONE     0
+#define BN_RAND_TOP_TWO     1
+
+/* Values for |bottom| in BN_rand() */
+#define BN_RAND_BOTTOM_ANY  0
+#define BN_RAND_BOTTOM_ODD  1
+
+/*
+ * get a clone of a BIGNUM with changed flags, for *temporary* use only (the
+ * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The
+ * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that
+ * has not been otherwise initialised or used.
+ */
+void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags);
+
+/* Wrapper function to make using BN_GENCB easier */
+int BN_GENCB_call(BN_GENCB *cb, int a, int b);
+
+BN_GENCB *BN_GENCB_new(void);
+void BN_GENCB_free(BN_GENCB *cb);
+
+/* Populate a BN_GENCB structure with an "old"-style callback */
+void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *),
+                      void *cb_arg);
+
+/* Populate a BN_GENCB structure with a "new"-style callback */
+void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *),
+                  void *cb_arg);
+
+void *BN_GENCB_get_arg(BN_GENCB *cb);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define BN_prime_checks 0      /* default: select number of iterations based
+                                  * on the size of the number */
+
+/*
+ * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations
+ * that will be done for checking that a random number is probably prime. The
+ * error rate for accepting a composite number as prime depends on the size of
+ * the prime |b|. The error rates used are for calculating an RSA key with 2 primes,
+ * and so the level is what you would expect for a key of double the size of the
+ * prime.
+ *
+ * This table is generated using the algorithm of FIPS PUB 186-4
+ * Digital Signature Standard (DSS), section F.1, page 117.
+ * (https://dx.doi.org/10.6028/NIST.FIPS.186-4)
+ *
+ * The following magma script was used to generate the output:
+ * securitybits:=125;
+ * k:=1024;
+ * for t:=1 to 65 do
+ *   for M:=3 to Floor(2*Sqrt(k-1)-1) do
+ *     S:=0;
+ *     // Sum over m
+ *     for m:=3 to M do
+ *       s:=0;
+ *       // Sum over j
+ *       for j:=2 to m do
+ *         s+:=(RealField(32)!2)^-(j+(k-1)/j);
+ *       end for;
+ *       S+:=2^(m-(m-1)*t)*s;
+ *     end for;
+ *     A:=2^(k-2-M*t);
+ *     B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S;
+ *     pkt:=2.00743*Log(2)*k*2^-k*(A+B);
+ *     seclevel:=Floor(-Log(2,pkt));
+ *     if seclevel ge securitybits then
+ *       printf "k: %5o, security: %o bits  (t: %o, M: %o)\n",k,seclevel,t,M;
+ *       break;
+ *     end if;
+ *   end for;
+ *   if seclevel ge securitybits then break; end if;
+ * end for;
+ *
+ * It can be run online at:
+ * http://magma.maths.usyd.edu.au/calc
+ *
+ * And will output:
+ * k:  1024, security: 129 bits  (t: 6, M: 23)
+ *
+ * k is the number of bits of the prime, securitybits is the level we want to
+ * reach.
+ *
+ * prime length | RSA key size | # MR tests | security level
+ * -------------+--------------|------------+---------------
+ *  (b) >= 6394 |     >= 12788 |          3 |        256 bit
+ *  (b) >= 3747 |     >=  7494 |          3 |        192 bit
+ *  (b) >= 1345 |     >=  2690 |          4 |        128 bit
+ *  (b) >= 1080 |     >=  2160 |          5 |        128 bit
+ *  (b) >=  852 |     >=  1704 |          5 |        112 bit
+ *  (b) >=  476 |     >=   952 |          5 |         80 bit
+ *  (b) >=  400 |     >=   800 |          6 |         80 bit
+ *  (b) >=  347 |     >=   694 |          7 |         80 bit
+ *  (b) >=  308 |     >=   616 |          8 |         80 bit
+ *  (b) >=   55 |     >=   110 |         27 |         64 bit
+ *  (b) >=    6 |     >=    12 |         34 |         64 bit
+ */
+
+#  define BN_prime_checks_for_size(b) ((b) >= 3747 ?  3 : \
+                                      (b) >=  1345 ?  4 : \
+                                      (b) >=  476 ?  5 : \
+                                      (b) >=  400 ?  6 : \
+                                      (b) >=  347 ?  7 : \
+                                      (b) >=  308 ?  8 : \
+                                      (b) >=  55  ? 27 : \
+                                      /* b >= 6 */ 34)
+# endif
+
+# define BN_num_bytes(a) ((BN_num_bits(a)+7)/8)
+
+int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w);
+int BN_is_zero(const BIGNUM *a);
+int BN_is_one(const BIGNUM *a);
+int BN_is_word(const BIGNUM *a, const BN_ULONG w);
+int BN_is_odd(const BIGNUM *a);
+
+# define BN_one(a)       (BN_set_word((a),1))
+
+void BN_zero_ex(BIGNUM *a);
+
+# if OPENSSL_API_LEVEL > 908
+#  define BN_zero(a)      BN_zero_ex(a)
+# else
+#  define BN_zero(a)      (BN_set_word((a),0))
+# endif
+
+const BIGNUM *BN_value_one(void);
+char *BN_options(void);
+BN_CTX *BN_CTX_new_ex(OSSL_LIB_CTX *ctx);
+BN_CTX *BN_CTX_new(void);
+BN_CTX *BN_CTX_secure_new_ex(OSSL_LIB_CTX *ctx);
+BN_CTX *BN_CTX_secure_new(void);
+void BN_CTX_free(BN_CTX *c);
+void BN_CTX_start(BN_CTX *ctx);
+BIGNUM *BN_CTX_get(BN_CTX *ctx);
+void BN_CTX_end(BN_CTX *ctx);
+int BN_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
+               unsigned int strength, BN_CTX *ctx);
+int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
+int BN_priv_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
+                    unsigned int strength, BN_CTX *ctx);
+int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom);
+int BN_rand_range_ex(BIGNUM *r, const BIGNUM *range, unsigned int strength,
+                     BN_CTX *ctx);
+int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
+int BN_priv_rand_range_ex(BIGNUM *r, const BIGNUM *range,
+                          unsigned int strength, BN_CTX *ctx);
+int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
+OSSL_DEPRECATEDIN_3_0
+int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
+# endif
+int BN_num_bits(const BIGNUM *a);
+int BN_num_bits_word(BN_ULONG l);
+int BN_security_bits(int L, int N);
+BIGNUM *BN_new(void);
+BIGNUM *BN_secure_new(void);
+void BN_clear_free(BIGNUM *a);
+BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
+void BN_swap(BIGNUM *a, BIGNUM *b);
+BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2bin(const BIGNUM *a, unsigned char *to);
+int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2nativepad(const BIGNUM *a, unsigned char *to, int tolen);
+BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
+int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
+int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
+/** BN_set_negative sets sign of a BIGNUM
+ * \param  b  pointer to the BIGNUM object
+ * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
+ */
+void BN_set_negative(BIGNUM *b, int n);
+/** BN_is_negative returns 1 if the BIGNUM is negative
+ * \param  b  pointer to the BIGNUM object
+ * \return 1 if a < 0 and 0 otherwise
+ */
+int BN_is_negative(const BIGNUM *b);
+
+int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
+           BN_CTX *ctx);
+# define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx))
+int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
+int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+               BN_CTX *ctx);
+int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                     const BIGNUM *m);
+int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+               BN_CTX *ctx);
+int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                     const BIGNUM *m);
+int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
+               BN_CTX *ctx);
+int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
+int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
+                  BN_CTX *ctx);
+int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
+
+BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
+BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
+int BN_mul_word(BIGNUM *a, BN_ULONG w);
+int BN_add_word(BIGNUM *a, BN_ULONG w);
+int BN_sub_word(BIGNUM *a, BN_ULONG w);
+int BN_set_word(BIGNUM *a, BN_ULONG w);
+BN_ULONG BN_get_word(const BIGNUM *a);
+
+int BN_cmp(const BIGNUM *a, const BIGNUM *b);
+void BN_free(BIGNUM *a);
+int BN_is_bit_set(const BIGNUM *a, int n);
+int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
+int BN_lshift1(BIGNUM *r, const BIGNUM *a);
+int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+
+int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+               const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
+                              const BIGNUM *m, BN_CTX *ctx,
+                              BN_MONT_CTX *in_mont);
+int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,
+                         const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
+                     const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
+                     BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                      const BIGNUM *m, BN_CTX *ctx);
+int BN_mod_exp_mont_consttime_x2(BIGNUM *rr1, const BIGNUM *a1, const BIGNUM *p1,
+                                 const BIGNUM *m1, BN_MONT_CTX *in_mont1,
+                                 BIGNUM *rr2, const BIGNUM *a2, const BIGNUM *p2,
+                                 const BIGNUM *m2, BN_MONT_CTX *in_mont2,
+                                 BN_CTX *ctx);
+
+int BN_mask_bits(BIGNUM *a, int n);
+# ifndef OPENSSL_NO_STDIO
+int BN_print_fp(FILE *fp, const BIGNUM *a);
+# endif
+int BN_print(BIO *bio, const BIGNUM *a);
+int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
+int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
+int BN_rshift1(BIGNUM *r, const BIGNUM *a);
+void BN_clear(BIGNUM *a);
+BIGNUM *BN_dup(const BIGNUM *a);
+int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
+int BN_set_bit(BIGNUM *a, int n);
+int BN_clear_bit(BIGNUM *a, int n);
+char *BN_bn2hex(const BIGNUM *a);
+char *BN_bn2dec(const BIGNUM *a);
+int BN_hex2bn(BIGNUM **a, const char *str);
+int BN_dec2bn(BIGNUM **a, const char *str);
+int BN_asc2bn(BIGNUM **a, const char *str);
+int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns
+                                                                  * -2 for
+                                                                  * error */
+BIGNUM *BN_mod_inverse(BIGNUM *ret,
+                       const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
+BIGNUM *BN_mod_sqrt(BIGNUM *ret,
+                    const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
+
+void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords);
+
+/* Deprecated versions */
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8
+BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe,
+                          const BIGNUM *add, const BIGNUM *rem,
+                          void (*callback) (int, int, void *),
+                          void *cb_arg);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_is_prime(const BIGNUM *p, int nchecks,
+                void (*callback) (int, int, void *),
+                BN_CTX *ctx, void *cb_arg);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_is_prime_fasttest(const BIGNUM *p, int nchecks,
+                         void (*callback) (int, int, void *),
+                         BN_CTX *ctx, void *cb_arg,
+                         int do_trial_division);
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
+                            int do_trial_division, BN_GENCB *cb);
+# endif
+/* Newer versions */
+int BN_generate_prime_ex2(BIGNUM *ret, int bits, int safe,
+                          const BIGNUM *add, const BIGNUM *rem, BN_GENCB *cb,
+                          BN_CTX *ctx);
+int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
+                         const BIGNUM *rem, BN_GENCB *cb);
+int BN_check_prime(const BIGNUM *p, BN_CTX *ctx, BN_GENCB *cb);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
+
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
+                            const BIGNUM *Xp, const BIGNUM *Xp1,
+                            const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,
+                            BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1,
+                              BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e,
+                              BN_CTX *ctx, BN_GENCB *cb);
+# endif
+
+BN_MONT_CTX *BN_MONT_CTX_new(void);
+int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                          BN_MONT_CTX *mont, BN_CTX *ctx);
+int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
+                     BN_CTX *ctx);
+int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
+                       BN_CTX *ctx);
+void BN_MONT_CTX_free(BN_MONT_CTX *mont);
+int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
+BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
+BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock,
+                                    const BIGNUM *mod, BN_CTX *ctx);
+
+/* BN_BLINDING flags */
+# define BN_BLINDING_NO_UPDATE   0x00000001
+# define BN_BLINDING_NO_RECREATE 0x00000002
+
+BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
+void BN_BLINDING_free(BN_BLINDING *b);
+int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
+int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
+int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
+                          BN_CTX *);
+
+int BN_BLINDING_is_current_thread(BN_BLINDING *b);
+void BN_BLINDING_set_current_thread(BN_BLINDING *b);
+int BN_BLINDING_lock(BN_BLINDING *b);
+int BN_BLINDING_unlock(BN_BLINDING *b);
+
+unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
+void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
+BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
+                                      const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
+                                      int (*bn_mod_exp) (BIGNUM *r,
+                                                         const BIGNUM *a,
+                                                         const BIGNUM *p,
+                                                         const BIGNUM *m,
+                                                         BN_CTX *ctx,
+                                                         BN_MONT_CTX *m_ctx),
+                                      BN_MONT_CTX *m_ctx);
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8
+void BN_set_params(int mul, int high, int low, int mont);
+OSSL_DEPRECATEDIN_0_9_8
+int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */
+# endif
+
+BN_RECP_CTX *BN_RECP_CTX_new(void);
+void BN_RECP_CTX_free(BN_RECP_CTX *recp);
+int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
+int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
+                          BN_RECP_CTX *recp, BN_CTX *ctx);
+int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                    const BIGNUM *m, BN_CTX *ctx);
+int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
+                BN_RECP_CTX *recp, BN_CTX *ctx);
+
+# ifndef OPENSSL_NO_EC2M
+
+/*
+ * Functions for arithmetic over binary polynomials represented by BIGNUMs.
+ * The BIGNUM::neg property of BIGNUMs representing binary polynomials is
+ * ignored. Note that input arguments are not const so that their bit arrays
+ * can be expanded to the appropriate size if needed.
+ */
+
+/*
+ * r = a + b
+ */
+int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+#  define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b)
+/*
+ * r=a mod p
+ */
+int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p);
+/* r = (a * b) mod p */
+int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                    const BIGNUM *p, BN_CTX *ctx);
+/* r = (a * a) mod p */
+int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+/* r = (1 / b) mod p */
+int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx);
+/* r = (a / b) mod p */
+int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                    const BIGNUM *p, BN_CTX *ctx);
+/* r = (a ^ b) mod p */
+int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                    const BIGNUM *p, BN_CTX *ctx);
+/* r = sqrt(a) mod p */
+int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                     BN_CTX *ctx);
+/* r^2 + r = a mod p */
+int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+                           BN_CTX *ctx);
+#  define BN_GF2m_cmp(a, b) BN_ucmp((a), (b))
+/*-
+ * Some functions allow for representation of the irreducible polynomials
+ * as an unsigned int[], say p.  The irreducible f(t) is then of the form:
+ *     t^p[0] + t^p[1] + ... + t^p[k]
+ * where m = p[0] > p[1] > ... > p[k] = 0.
+ */
+/* r = a mod p */
+int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]);
+/* r = (a * b) mod p */
+int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                        const int p[], BN_CTX *ctx);
+/* r = (a * a) mod p */
+int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
+                        BN_CTX *ctx);
+/* r = (1 / b) mod p */
+int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[],
+                        BN_CTX *ctx);
+/* r = (a / b) mod p */
+int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                        const int p[], BN_CTX *ctx);
+/* r = (a ^ b) mod p */
+int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
+                        const int p[], BN_CTX *ctx);
+/* r = sqrt(a) mod p */
+int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a,
+                         const int p[], BN_CTX *ctx);
+/* r^2 + r = a mod p */
+int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a,
+                               const int p[], BN_CTX *ctx);
+int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max);
+int BN_GF2m_arr2poly(const int p[], BIGNUM *a);
+
+# endif
+
+/*
+ * faster mod functions for the 'NIST primes' 0 <= a < p^2
+ */
+int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+
+const BIGNUM *BN_get0_nist_prime_192(void);
+const BIGNUM *BN_get0_nist_prime_224(void);
+const BIGNUM *BN_get0_nist_prime_256(void);
+const BIGNUM *BN_get0_nist_prime_384(void);
+const BIGNUM *BN_get0_nist_prime_521(void);
+
+int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a,
+                                          const BIGNUM *field, BN_CTX *ctx);
+
+int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
+                          const BIGNUM *priv, const unsigned char *message,
+                          size_t message_len, BN_CTX *ctx);
+
+/* Primes from RFC 2409 */
+BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
+BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);
+
+/* Primes from RFC 3526 */
+BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
+BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   define get_rfc2409_prime_768 BN_get_rfc2409_prime_768
+#   define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024
+#   define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536
+#   define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048
+#   define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072
+#   define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096
+#   define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144
+#   define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192
+#  endif
+
+int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/bnerr.h b/CAPI/cpp/grpc/include/openssl/bnerr.h
new file mode 100644
index 0000000..7c3f6ef
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/bnerr.h
@@ -0,0 +1,47 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BNERR_H
+# define OPENSSL_BNERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * BN reason codes.
+ */
+# define BN_R_ARG2_LT_ARG3                                100
+# define BN_R_BAD_RECIPROCAL                              101
+# define BN_R_BIGNUM_TOO_LONG                             114
+# define BN_R_BITS_TOO_SMALL                              118
+# define BN_R_CALLED_WITH_EVEN_MODULUS                    102
+# define BN_R_DIV_BY_ZERO                                 103
+# define BN_R_ENCODING_ERROR                              104
+# define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA                105
+# define BN_R_INPUT_NOT_REDUCED                           110
+# define BN_R_INVALID_LENGTH                              106
+# define BN_R_INVALID_RANGE                               115
+# define BN_R_INVALID_SHIFT                               119
+# define BN_R_NOT_A_SQUARE                                111
+# define BN_R_NOT_INITIALIZED                             107
+# define BN_R_NO_INVERSE                                  108
+# define BN_R_NO_PRIME_CANDIDATE                          121
+# define BN_R_NO_SOLUTION                                 116
+# define BN_R_NO_SUITABLE_DIGEST                          120
+# define BN_R_PRIVATE_KEY_TOO_LARGE                       117
+# define BN_R_P_IS_NOT_PRIME                              112
+# define BN_R_TOO_MANY_ITERATIONS                         113
+# define BN_R_TOO_MANY_TEMPORARY_VARIABLES                109
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/buffer.h b/CAPI/cpp/grpc/include/openssl/buffer.h
new file mode 100644
index 0000000..5773b98
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/buffer.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BUFFER_H
+# define OPENSSL_BUFFER_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_BUFFER_H
+# endif
+
+# include <openssl/types.h>
+# ifndef OPENSSL_CRYPTO_H
+#  include <openssl/crypto.h>
+# endif
+# include <openssl/buffererr.h>
+
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# include <stddef.h>
+# include <sys/types.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define BUF_strdup(s) OPENSSL_strdup(s)
+#  define BUF_strndup(s, size) OPENSSL_strndup(s, size)
+#  define BUF_memdup(data, size) OPENSSL_memdup(data, size)
+#  define BUF_strlcpy(dst, src, size)  OPENSSL_strlcpy(dst, src, size)
+#  define BUF_strlcat(dst, src, size) OPENSSL_strlcat(dst, src, size)
+#  define BUF_strnlen(str, maxlen) OPENSSL_strnlen(str, maxlen)
+# endif
+
+struct buf_mem_st {
+    size_t length;              /* current number of bytes */
+    char *data;
+    size_t max;                 /* size of buffer */
+    unsigned long flags;
+};
+
+# define BUF_MEM_FLAG_SECURE  0x01
+
+BUF_MEM *BUF_MEM_new(void);
+BUF_MEM *BUF_MEM_new_ex(unsigned long flags);
+void BUF_MEM_free(BUF_MEM *a);
+size_t BUF_MEM_grow(BUF_MEM *str, size_t len);
+size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len);
+void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/buffererr.h b/CAPI/cpp/grpc/include/openssl/buffererr.h
new file mode 100644
index 0000000..d18b1f8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/buffererr.h
@@ -0,0 +1,25 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BUFFERERR_H
+# define OPENSSL_BUFFERERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * BUF reason codes.
+ */
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/camellia.h b/CAPI/cpp/grpc/include/openssl/camellia.h
new file mode 100644
index 0000000..88c2279
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/camellia.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2006-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CAMELLIA_H
+# define OPENSSL_CAMELLIA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CAMELLIA_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CAMELLIA
+# include <stddef.h>
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define CAMELLIA_BLOCK_SIZE 16
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#  define CAMELLIA_ENCRYPT        1
+#  define CAMELLIA_DECRYPT        0
+
+/*
+ * Because array size can't be a const in C, the following two are macros.
+ * Both sizes are in bytes.
+ */
+
+/* This should be a hidden type, but EVP requires that the size be known */
+
+#  define CAMELLIA_TABLE_BYTE_LEN 272
+#  define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4)
+
+typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match
+                                                               * with WORD */
+
+struct camellia_key_st {
+    union {
+        double d;               /* ensures 64-bit align */
+        KEY_TABLE_TYPE rd_key;
+    } u;
+    int grand_rounds;
+};
+typedef struct camellia_key_st CAMELLIA_KEY;
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int Camellia_set_key(const unsigned char *userKey,
+                                           const int bits,
+                                           CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_encrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            const CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_decrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            const CAMELLIA_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void Camellia_ecb_encrypt(const unsigned char *in,
+                                                unsigned char *out,
+                                                const CAMELLIA_KEY *key,
+                                                const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cbc_encrypt(const unsigned char *in,
+                                                unsigned char *out,
+                                                size_t length,
+                                                const CAMELLIA_KEY *key,
+                                                unsigned char *ivec,
+                                                const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb128_encrypt(const unsigned char *in,
+                                                   unsigned char *out,
+                                                   size_t length,
+                                                   const CAMELLIA_KEY *key,
+                                                   unsigned char *ivec,
+                                                   int *num,
+                                                   const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb1_encrypt(const unsigned char *in,
+                                                 unsigned char *out,
+                                                 size_t length,
+                                                 const CAMELLIA_KEY *key,
+                                                 unsigned char *ivec,
+                                                 int *num,
+                                                 const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_cfb8_encrypt(const unsigned char *in,
+                                                 unsigned char *out,
+                                                 size_t length,
+                                                 const CAMELLIA_KEY *key,
+                                                 unsigned char *ivec,
+                                                 int *num,
+                                                 const int enc);
+OSSL_DEPRECATEDIN_3_0 void Camellia_ofb128_encrypt(const unsigned char *in,
+                                                   unsigned char *out,
+                                                   size_t length,
+                                                   const CAMELLIA_KEY *key,
+                                                   unsigned char *ivec,
+                                                   int *num);
+OSSL_DEPRECATEDIN_3_0
+void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out,
+                             size_t length, const CAMELLIA_KEY *key,
+                             unsigned char ivec[CAMELLIA_BLOCK_SIZE],
+                             unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE],
+                             unsigned int *num);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/cast.h b/CAPI/cpp/grpc/include/openssl/cast.h
new file mode 100644
index 0000000..0bf217b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cast.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CAST_H
+# define OPENSSL_CAST_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CAST_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CAST
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define CAST_BLOCK      8
+# define CAST_KEY_LENGTH 16
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#  define CAST_ENCRYPT    1
+#  define CAST_DECRYPT    0
+
+#  define CAST_LONG unsigned int
+
+typedef struct cast_key_st {
+    CAST_LONG data[32];
+    int short_key;              /* Use reduced rounds for short key */
+} CAST_KEY;
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data);
+OSSL_DEPRECATEDIN_3_0
+void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out,
+                      const CAST_KEY *key, int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key);
+OSSL_DEPRECATEDIN_3_0
+void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out,
+                      long length, const CAST_KEY *ks, unsigned char *iv,
+                      int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+                        long length, const CAST_KEY *schedule,
+                        unsigned char *ivec, int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+                        long length, const CAST_KEY *schedule,
+                        unsigned char *ivec, int *num);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/cmac.h b/CAPI/cpp/grpc/include/openssl/cmac.h
new file mode 100644
index 0000000..f508618
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cmac.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMAC_H
+# define OPENSSL_CMAC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CMAC_H
+# endif
+
+# ifndef OPENSSL_NO_CMAC
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+#  include <openssl/evp.h>
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/* Opaque */
+typedef struct CMAC_CTX_st CMAC_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 CMAC_CTX *CMAC_CTX_new(void);
+OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_cleanup(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_free(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 EVP_CIPHER_CTX *CMAC_CTX_get0_cipher_ctx(CMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Init(CMAC_CTX *ctx,
+                                    const void *key, size_t keylen,
+                                    const EVP_CIPHER *cipher, ENGINE *impl);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Update(CMAC_CTX *ctx,
+                                      const void *data, size_t dlen);
+OSSL_DEPRECATEDIN_3_0 int CMAC_Final(CMAC_CTX *ctx,
+                                     unsigned char *out, size_t *poutlen);
+OSSL_DEPRECATEDIN_3_0 int CMAC_resume(CMAC_CTX *ctx);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/cmp.h b/CAPI/cpp/grpc/include/openssl/cmp.h
new file mode 100644
index 0000000..7f258dc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cmp.h
@@ -0,0 +1,592 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\cmp.h.in
+ *
+ * Copyright 2007-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Nokia 2007-2019
+ * Copyright Siemens AG 2015-2019
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_CMP_H
+# define OPENSSL_CMP_H
+
+# include <openssl/opensslconf.h>
+# ifndef OPENSSL_NO_CMP
+
+#  include <openssl/crmf.h>
+#  include <openssl/cmperr.h>
+#  include <openssl/cmp_util.h>
+#  include <openssl/http.h>
+
+/* explicit #includes not strictly needed since implied by the above: */
+#  include <openssl/types.h>
+#  include <openssl/safestack.h>
+#  include <openssl/x509.h>
+#  include <openssl/x509v3.h>
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+#  define OSSL_CMP_PVNO 2
+
+/*-
+ *   PKIFailureInfo ::= BIT STRING {
+ *   -- since we can fail in more than one way!
+ *   -- More codes may be added in the future if/when required.
+ *       badAlg              (0),
+ *       -- unrecognized or unsupported Algorithm Identifier
+ *       badMessageCheck     (1),
+ *       -- integrity check failed (e.g., signature did not verify)
+ *       badRequest          (2),
+ *       -- transaction not permitted or supported
+ *       badTime             (3),
+ *       -- messageTime was not sufficiently close to the system time,
+ *       -- as defined by local policy
+ *       badCertId           (4),
+ *       -- no certificate could be found matching the provided criteria
+ *       badDataFormat       (5),
+ *       -- the data submitted has the wrong format
+ *       wrongAuthority      (6),
+ *       -- the authority indicated in the request is different from the
+ *       -- one creating the response token
+ *       incorrectData       (7),
+ *       -- the requester's data is incorrect (for notary services)
+ *       missingTimeStamp    (8),
+ *       -- when the timestamp is missing but should be there
+ *       -- (by policy)
+ *       badPOP              (9),
+ *       -- the proof-of-possession failed
+ *       certRevoked         (10),
+ *          -- the certificate has already been revoked
+ *       certConfirmed       (11),
+ *          -- the certificate has already been confirmed
+ *       wrongIntegrity      (12),
+ *          -- invalid integrity, password based instead of signature or
+ *          -- vice versa
+ *       badRecipientNonce   (13),
+ *          -- invalid recipient nonce, either missing or wrong value
+ *       timeNotAvailable    (14),
+ *          -- the TSA's time source is not available
+ *       unacceptedPolicy    (15),
+ *          -- the requested TSA policy is not supported by the TSA.
+ *       unacceptedExtension (16),
+ *          -- the requested extension is not supported by the TSA.
+ *       addInfoNotAvailable (17),
+ *          -- the additional information requested could not be
+ *          -- understood or is not available
+ *       badSenderNonce      (18),
+ *          -- invalid sender nonce, either missing or wrong size
+ *       badCertTemplate     (19),
+ *          -- invalid cert. template or missing mandatory information
+ *       signerNotTrusted    (20),
+ *          -- signer of the message unknown or not trusted
+ *       transactionIdInUse  (21),
+ *          -- the transaction identifier is already in use
+ *       unsupportedVersion  (22),
+ *          -- the version of the message is not supported
+ *       notAuthorized       (23),
+ *          -- the sender was not authorized to make the preceding
+ *          -- request or perform the preceding action
+ *       systemUnavail       (24),
+ *       -- the request cannot be handled due to system unavailability
+ *       systemFailure       (25),
+ *       -- the request cannot be handled due to system failure
+ *       duplicateCertReq    (26)
+ *       -- certificate cannot be issued because a duplicate
+ *       -- certificate already exists
+ *   }
+ */
+#  define OSSL_CMP_PKIFAILUREINFO_badAlg 0
+#  define OSSL_CMP_PKIFAILUREINFO_badMessageCheck 1
+#  define OSSL_CMP_PKIFAILUREINFO_badRequest 2
+#  define OSSL_CMP_PKIFAILUREINFO_badTime 3
+#  define OSSL_CMP_PKIFAILUREINFO_badCertId 4
+#  define OSSL_CMP_PKIFAILUREINFO_badDataFormat 5
+#  define OSSL_CMP_PKIFAILUREINFO_wrongAuthority 6
+#  define OSSL_CMP_PKIFAILUREINFO_incorrectData 7
+#  define OSSL_CMP_PKIFAILUREINFO_missingTimeStamp 8
+#  define OSSL_CMP_PKIFAILUREINFO_badPOP 9
+#  define OSSL_CMP_PKIFAILUREINFO_certRevoked 10
+#  define OSSL_CMP_PKIFAILUREINFO_certConfirmed 11
+#  define OSSL_CMP_PKIFAILUREINFO_wrongIntegrity 12
+#  define OSSL_CMP_PKIFAILUREINFO_badRecipientNonce 13
+#  define OSSL_CMP_PKIFAILUREINFO_timeNotAvailable 14
+#  define OSSL_CMP_PKIFAILUREINFO_unacceptedPolicy 15
+#  define OSSL_CMP_PKIFAILUREINFO_unacceptedExtension 16
+#  define OSSL_CMP_PKIFAILUREINFO_addInfoNotAvailable 17
+#  define OSSL_CMP_PKIFAILUREINFO_badSenderNonce 18
+#  define OSSL_CMP_PKIFAILUREINFO_badCertTemplate 19
+#  define OSSL_CMP_PKIFAILUREINFO_signerNotTrusted 20
+#  define OSSL_CMP_PKIFAILUREINFO_transactionIdInUse 21
+#  define OSSL_CMP_PKIFAILUREINFO_unsupportedVersion 22
+#  define OSSL_CMP_PKIFAILUREINFO_notAuthorized 23
+#  define OSSL_CMP_PKIFAILUREINFO_systemUnavail 24
+#  define OSSL_CMP_PKIFAILUREINFO_systemFailure 25
+#  define OSSL_CMP_PKIFAILUREINFO_duplicateCertReq 26
+#  define OSSL_CMP_PKIFAILUREINFO_MAX 26
+#  define OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN \
+    ((1 << (OSSL_CMP_PKIFAILUREINFO_MAX + 1)) - 1)
+#  if OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN > INT_MAX
+#   error CMP_PKIFAILUREINFO_MAX bit pattern does not fit in type int
+#  endif
+
+typedef ASN1_BIT_STRING OSSL_CMP_PKIFAILUREINFO;
+
+#  define OSSL_CMP_CTX_FAILINFO_badAlg (1 << 0)
+#  define OSSL_CMP_CTX_FAILINFO_badMessageCheck (1 << 1)
+#  define OSSL_CMP_CTX_FAILINFO_badRequest (1 << 2)
+#  define OSSL_CMP_CTX_FAILINFO_badTime (1 << 3)
+#  define OSSL_CMP_CTX_FAILINFO_badCertId (1 << 4)
+#  define OSSL_CMP_CTX_FAILINFO_badDataFormat (1 << 5)
+#  define OSSL_CMP_CTX_FAILINFO_wrongAuthority (1 << 6)
+#  define OSSL_CMP_CTX_FAILINFO_incorrectData (1 << 7)
+#  define OSSL_CMP_CTX_FAILINFO_missingTimeStamp (1 << 8)
+#  define OSSL_CMP_CTX_FAILINFO_badPOP (1 << 9)
+#  define OSSL_CMP_CTX_FAILINFO_certRevoked (1 << 10)
+#  define OSSL_CMP_CTX_FAILINFO_certConfirmed (1 << 11)
+#  define OSSL_CMP_CTX_FAILINFO_wrongIntegrity (1 << 12)
+#  define OSSL_CMP_CTX_FAILINFO_badRecipientNonce (1 << 13)
+#  define OSSL_CMP_CTX_FAILINFO_timeNotAvailable (1 << 14)
+#  define OSSL_CMP_CTX_FAILINFO_unacceptedPolicy (1 << 15)
+#  define OSSL_CMP_CTX_FAILINFO_unacceptedExtension (1 << 16)
+#  define OSSL_CMP_CTX_FAILINFO_addInfoNotAvailable (1 << 17)
+#  define OSSL_CMP_CTX_FAILINFO_badSenderNonce (1 << 18)
+#  define OSSL_CMP_CTX_FAILINFO_badCertTemplate (1 << 19)
+#  define OSSL_CMP_CTX_FAILINFO_signerNotTrusted (1 << 20)
+#  define OSSL_CMP_CTX_FAILINFO_transactionIdInUse (1 << 21)
+#  define OSSL_CMP_CTX_FAILINFO_unsupportedVersion (1 << 22)
+#  define OSSL_CMP_CTX_FAILINFO_notAuthorized (1 << 23)
+#  define OSSL_CMP_CTX_FAILINFO_systemUnavail (1 << 24)
+#  define OSSL_CMP_CTX_FAILINFO_systemFailure (1 << 25)
+#  define OSSL_CMP_CTX_FAILINFO_duplicateCertReq (1 << 26)
+
+/*-
+ *   PKIStatus ::= INTEGER {
+ *       accepted                (0),
+ *       -- you got exactly what you asked for
+ *       grantedWithMods        (1),
+ *       -- you got something like what you asked for; the
+ *       -- requester is responsible for ascertaining the differences
+ *       rejection              (2),
+ *       -- you don't get it, more information elsewhere in the message
+ *       waiting                (3),
+ *       -- the request body part has not yet been processed; expect to
+ *       -- hear more later (note: proper handling of this status
+ *       -- response MAY use the polling req/rep PKIMessages specified
+ *       -- in Section 5.3.22; alternatively, polling in the underlying
+ *       -- transport layer MAY have some utility in this regard)
+ *       revocationWarning      (4),
+ *       -- this message contains a warning that a revocation is
+ *       -- imminent
+ *       revocationNotification (5),
+ *       -- notification that a revocation has occurred
+ *       keyUpdateWarning       (6)
+ *       -- update already done for the oldCertId specified in
+ *       -- CertReqMsg
+ *   }
+ */
+#  define OSSL_CMP_PKISTATUS_accepted 0
+#  define OSSL_CMP_PKISTATUS_grantedWithMods 1
+#  define OSSL_CMP_PKISTATUS_rejection 2
+#  define OSSL_CMP_PKISTATUS_waiting 3
+#  define OSSL_CMP_PKISTATUS_revocationWarning 4
+#  define OSSL_CMP_PKISTATUS_revocationNotification 5
+#  define OSSL_CMP_PKISTATUS_keyUpdateWarning 6
+
+typedef ASN1_INTEGER OSSL_CMP_PKISTATUS;
+DECLARE_ASN1_ITEM(OSSL_CMP_PKISTATUS)
+
+#  define OSSL_CMP_CERTORENCCERT_CERTIFICATE 0
+#  define OSSL_CMP_CERTORENCCERT_ENCRYPTEDCERT 1
+
+/* data type declarations */
+typedef struct ossl_cmp_ctx_st OSSL_CMP_CTX;
+typedef struct ossl_cmp_pkiheader_st OSSL_CMP_PKIHEADER;
+DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKIHEADER)
+typedef struct ossl_cmp_msg_st OSSL_CMP_MSG;
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_MSG)
+DECLARE_ASN1_ENCODE_FUNCTIONS(OSSL_CMP_MSG, OSSL_CMP_MSG, OSSL_CMP_MSG)
+typedef struct ossl_cmp_certstatus_st OSSL_CMP_CERTSTATUS;
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS)
+#define sk_OSSL_CMP_CERTSTATUS_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_value(sk, idx) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTSTATUS_new(cmp) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTSTATUS_new_null() ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTSTATUS_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTSTATUS_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTSTATUS_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_delete(sk, i) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTSTATUS_delete_ptr(sk, ptr) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CERTSTATUS_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_pop(sk) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_shift(sk) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk),ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTSTATUS_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTSTATUS_set(sk, idx, ptr) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CERTSTATUS_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
+#define sk_OSSL_CMP_CERTSTATUS_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTSTATUS_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk))
+#define sk_OSSL_CMP_CERTSTATUS_dup(sk) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTSTATUS_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTSTATUS_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
+
+typedef struct ossl_cmp_itav_st OSSL_CMP_ITAV;
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_ITAV)
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_ITAV, OSSL_CMP_ITAV, OSSL_CMP_ITAV)
+#define sk_OSSL_CMP_ITAV_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_value(sk, idx) ((OSSL_CMP_ITAV *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_ITAV_new(cmp) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
+#define sk_OSSL_CMP_ITAV_new_null() ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_ITAV_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_ITAV_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (n))
+#define sk_OSSL_CMP_ITAV_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_delete(sk, i) ((OSSL_CMP_ITAV *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (i)))
+#define sk_OSSL_CMP_ITAV_delete_ptr(sk, ptr) ((OSSL_CMP_ITAV *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr)))
+#define sk_OSSL_CMP_ITAV_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_pop(sk) ((OSSL_CMP_ITAV *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_shift(sk) ((OSSL_CMP_ITAV *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk),ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc))
+#define sk_OSSL_CMP_ITAV_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr), (idx))
+#define sk_OSSL_CMP_ITAV_set(sk, idx, ptr) ((OSSL_CMP_ITAV *)OPENSSL_sk_set(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (idx), ossl_check_OSSL_CMP_ITAV_type(ptr)))
+#define sk_OSSL_CMP_ITAV_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
+#define sk_OSSL_CMP_ITAV_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr), pnum)
+#define sk_OSSL_CMP_ITAV_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk))
+#define sk_OSSL_CMP_ITAV_dup(sk) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_ITAV_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_ITAV_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
+
+typedef struct ossl_cmp_revrepcontent_st OSSL_CMP_REVREPCONTENT;
+typedef struct ossl_cmp_pkisi_st OSSL_CMP_PKISI;
+DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKISI)
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_PKISI)
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_PKISI, OSSL_CMP_PKISI, OSSL_CMP_PKISI)
+#define sk_OSSL_CMP_PKISI_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_value(sk, idx) ((OSSL_CMP_PKISI *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_PKISI_new(cmp) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
+#define sk_OSSL_CMP_PKISI_new_null() ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_PKISI_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_PKISI_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (n))
+#define sk_OSSL_CMP_PKISI_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_delete(sk, i) ((OSSL_CMP_PKISI *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (i)))
+#define sk_OSSL_CMP_PKISI_delete_ptr(sk, ptr) ((OSSL_CMP_PKISI *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr)))
+#define sk_OSSL_CMP_PKISI_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_pop(sk) ((OSSL_CMP_PKISI *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_shift(sk) ((OSSL_CMP_PKISI *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk),ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc))
+#define sk_OSSL_CMP_PKISI_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr), (idx))
+#define sk_OSSL_CMP_PKISI_set(sk, idx, ptr) ((OSSL_CMP_PKISI *)OPENSSL_sk_set(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (idx), ossl_check_OSSL_CMP_PKISI_type(ptr)))
+#define sk_OSSL_CMP_PKISI_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
+#define sk_OSSL_CMP_PKISI_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr), pnum)
+#define sk_OSSL_CMP_PKISI_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk))
+#define sk_OSSL_CMP_PKISI_dup(sk) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_PKISI_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_PKISI_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
+
+typedef struct ossl_cmp_certrepmessage_st OSSL_CMP_CERTREPMESSAGE;
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE)
+#define sk_OSSL_CMP_CERTREPMESSAGE_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_value(sk, idx) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_new(cmp) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_new_null() ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTREPMESSAGE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTREPMESSAGE_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_delete(sk, i) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_pop(sk) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_shift(sk) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk),ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTREPMESSAGE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTREPMESSAGE_set(sk, idx, ptr) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
+#define sk_OSSL_CMP_CERTREPMESSAGE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTREPMESSAGE_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
+#define sk_OSSL_CMP_CERTREPMESSAGE_dup(sk) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTREPMESSAGE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
+
+typedef struct ossl_cmp_pollrep_st OSSL_CMP_POLLREP;
+typedef STACK_OF(OSSL_CMP_POLLREP) OSSL_CMP_POLLREPCONTENT;
+typedef struct ossl_cmp_certresponse_st OSSL_CMP_CERTRESPONSE;
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE)
+#define sk_OSSL_CMP_CERTRESPONSE_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_value(sk, idx) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTRESPONSE_new(cmp) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTRESPONSE_new_null() ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTRESPONSE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTRESPONSE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (n))
+#define sk_OSSL_CMP_CERTRESPONSE_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_delete(sk, i) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTRESPONSE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
+#define sk_OSSL_CMP_CERTRESPONSE_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_pop(sk) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_shift(sk) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk),ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTRESPONSE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr), (idx))
+#define sk_OSSL_CMP_CERTRESPONSE_set(sk, idx, ptr) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
+#define sk_OSSL_CMP_CERTRESPONSE_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
+#define sk_OSSL_CMP_CERTRESPONSE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr), pnum)
+#define sk_OSSL_CMP_CERTRESPONSE_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk))
+#define sk_OSSL_CMP_CERTRESPONSE_dup(sk) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTRESPONSE_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTRESPONSE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
+
+typedef STACK_OF(ASN1_UTF8STRING) OSSL_CMP_PKIFREETEXT;
+
+/*
+ * function DECLARATIONS
+ */
+
+/* from cmp_asn.c */
+OSSL_CMP_ITAV *OSSL_CMP_ITAV_create(ASN1_OBJECT *type, ASN1_TYPE *value);
+void OSSL_CMP_ITAV_set0(OSSL_CMP_ITAV *itav, ASN1_OBJECT *type,
+                        ASN1_TYPE *value);
+ASN1_OBJECT *OSSL_CMP_ITAV_get0_type(const OSSL_CMP_ITAV *itav);
+ASN1_TYPE *OSSL_CMP_ITAV_get0_value(const OSSL_CMP_ITAV *itav);
+int OSSL_CMP_ITAV_push0_stack_item(STACK_OF(OSSL_CMP_ITAV) **itav_sk_p,
+                                   OSSL_CMP_ITAV *itav);
+void OSSL_CMP_ITAV_free(OSSL_CMP_ITAV *itav);
+void OSSL_CMP_MSG_free(OSSL_CMP_MSG *msg);
+
+/* from cmp_ctx.c */
+OSSL_CMP_CTX *OSSL_CMP_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
+void OSSL_CMP_CTX_free(OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_reinit(OSSL_CMP_CTX *ctx);
+/* CMP general options: */
+#  define OSSL_CMP_OPT_LOG_VERBOSITY 0
+/* CMP transfer options: */
+#  define OSSL_CMP_OPT_KEEP_ALIVE 10
+#  define OSSL_CMP_OPT_MSG_TIMEOUT 11
+#  define OSSL_CMP_OPT_TOTAL_TIMEOUT 12
+/* CMP request options: */
+#  define OSSL_CMP_OPT_VALIDITY_DAYS 20
+#  define OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT 21
+#  define OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL 22
+#  define OSSL_CMP_OPT_POLICIES_CRITICAL 23
+#  define OSSL_CMP_OPT_POPO_METHOD 24
+#  define OSSL_CMP_OPT_IMPLICIT_CONFIRM 25
+#  define OSSL_CMP_OPT_DISABLE_CONFIRM 26
+#  define OSSL_CMP_OPT_REVOCATION_REASON 27
+/* CMP protection options: */
+#  define OSSL_CMP_OPT_UNPROTECTED_SEND 30
+#  define OSSL_CMP_OPT_UNPROTECTED_ERRORS 31
+#  define OSSL_CMP_OPT_OWF_ALGNID 32
+#  define OSSL_CMP_OPT_MAC_ALGNID 33
+#  define OSSL_CMP_OPT_DIGEST_ALGNID 34
+#  define OSSL_CMP_OPT_IGNORE_KEYUSAGE 35
+#  define OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR 36
+int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX *ctx, int opt, int val);
+int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX *ctx, int opt);
+/* CMP-specific callback for logging and outputting the error queue: */
+int OSSL_CMP_CTX_set_log_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_log_cb_t cb);
+#  define OSSL_CMP_CTX_set_log_verbosity(ctx, level) \
+    OSSL_CMP_CTX_set_option(ctx, OSSL_CMP_OPT_LOG_VERBOSITY, level)
+void OSSL_CMP_CTX_print_errors(const OSSL_CMP_CTX *ctx);
+/* message transfer: */
+int OSSL_CMP_CTX_set1_serverPath(OSSL_CMP_CTX *ctx, const char *path);
+int OSSL_CMP_CTX_set1_server(OSSL_CMP_CTX *ctx, const char *address);
+int OSSL_CMP_CTX_set_serverPort(OSSL_CMP_CTX *ctx, int port);
+int OSSL_CMP_CTX_set1_proxy(OSSL_CMP_CTX *ctx, const char *name);
+int OSSL_CMP_CTX_set1_no_proxy(OSSL_CMP_CTX *ctx, const char *names);
+int OSSL_CMP_CTX_set_http_cb(OSSL_CMP_CTX *ctx, OSSL_HTTP_bio_cb_t cb);
+int OSSL_CMP_CTX_set_http_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_http_cb_arg(const OSSL_CMP_CTX *ctx);
+typedef OSSL_CMP_MSG *(*OSSL_CMP_transfer_cb_t) (OSSL_CMP_CTX *ctx,
+                                                 const OSSL_CMP_MSG *req);
+int OSSL_CMP_CTX_set_transfer_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_transfer_cb_t cb);
+int OSSL_CMP_CTX_set_transfer_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_transfer_cb_arg(const OSSL_CMP_CTX *ctx);
+/* server authentication: */
+int OSSL_CMP_CTX_set1_srvCert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_set1_expected_sender(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_set0_trustedStore(OSSL_CMP_CTX *ctx, X509_STORE *store);
+X509_STORE *OSSL_CMP_CTX_get0_trustedStore(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_set1_untrusted(OSSL_CMP_CTX *ctx, STACK_OF(X509) *certs);
+STACK_OF(X509) *OSSL_CMP_CTX_get0_untrusted(const OSSL_CMP_CTX *ctx);
+/* client authentication: */
+int OSSL_CMP_CTX_set1_cert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_build_cert_chain(OSSL_CMP_CTX *ctx, X509_STORE *own_trusted,
+                                  STACK_OF(X509) *candidates);
+int OSSL_CMP_CTX_set1_pkey(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey);
+int OSSL_CMP_CTX_set1_referenceValue(OSSL_CMP_CTX *ctx,
+                                     const unsigned char *ref, int len);
+int OSSL_CMP_CTX_set1_secretValue(OSSL_CMP_CTX *ctx, const unsigned char *sec,
+                                  const int len);
+/* CMP message header and extra certificates: */
+int OSSL_CMP_CTX_set1_recipient(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_push0_geninfo_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav);
+int OSSL_CMP_CTX_set1_extraCertsOut(OSSL_CMP_CTX *ctx,
+                                    STACK_OF(X509) *extraCertsOut);
+/* certificate template: */
+int OSSL_CMP_CTX_set0_newPkey(OSSL_CMP_CTX *ctx, int priv, EVP_PKEY *pkey);
+EVP_PKEY *OSSL_CMP_CTX_get0_newPkey(const OSSL_CMP_CTX *ctx, int priv);
+int OSSL_CMP_CTX_set1_issuer(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_set1_subjectName(OSSL_CMP_CTX *ctx, const X509_NAME *name);
+int OSSL_CMP_CTX_push1_subjectAltName(OSSL_CMP_CTX *ctx,
+                                      const GENERAL_NAME *name);
+int OSSL_CMP_CTX_set0_reqExtensions(OSSL_CMP_CTX *ctx, X509_EXTENSIONS *exts);
+int OSSL_CMP_CTX_reqExtensions_have_SAN(OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_push0_policy(OSSL_CMP_CTX *ctx, POLICYINFO *pinfo);
+int OSSL_CMP_CTX_set1_oldCert(OSSL_CMP_CTX *ctx, X509 *cert);
+int OSSL_CMP_CTX_set1_p10CSR(OSSL_CMP_CTX *ctx, const X509_REQ *csr);
+/* misc body contents: */
+int OSSL_CMP_CTX_push0_genm_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav);
+/* certificate confirmation: */
+typedef int (*OSSL_CMP_certConf_cb_t) (OSSL_CMP_CTX *ctx, X509 *cert,
+                                       int fail_info, const char **txt);
+int OSSL_CMP_certConf_cb(OSSL_CMP_CTX *ctx, X509 *cert, int fail_info,
+                         const char **text);
+int OSSL_CMP_CTX_set_certConf_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_certConf_cb_t cb);
+int OSSL_CMP_CTX_set_certConf_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
+void *OSSL_CMP_CTX_get_certConf_cb_arg(const OSSL_CMP_CTX *ctx);
+/* result fetching: */
+int OSSL_CMP_CTX_get_status(const OSSL_CMP_CTX *ctx);
+OSSL_CMP_PKIFREETEXT *OSSL_CMP_CTX_get0_statusString(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_get_failInfoCode(const OSSL_CMP_CTX *ctx);
+#  define OSSL_CMP_PKISI_BUFLEN 1024
+X509 *OSSL_CMP_CTX_get0_newCert(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_newChain(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_caPubs(const OSSL_CMP_CTX *ctx);
+STACK_OF(X509) *OSSL_CMP_CTX_get1_extraCertsIn(const OSSL_CMP_CTX *ctx);
+int OSSL_CMP_CTX_set1_transactionID(OSSL_CMP_CTX *ctx,
+                                    const ASN1_OCTET_STRING *id);
+int OSSL_CMP_CTX_set1_senderNonce(OSSL_CMP_CTX *ctx,
+                                  const ASN1_OCTET_STRING *nonce);
+
+/* from cmp_status.c */
+char *OSSL_CMP_CTX_snprint_PKIStatus(const OSSL_CMP_CTX *ctx, char *buf,
+                                     size_t bufsize);
+char *OSSL_CMP_snprint_PKIStatusInfo(const OSSL_CMP_PKISI *statusInfo,
+                                     char *buf, size_t bufsize);
+OSSL_CMP_PKISI *
+OSSL_CMP_STATUSINFO_new(int status, int fail_info, const char *text);
+
+/* from cmp_hdr.c */
+ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_transactionID(const
+                                                   OSSL_CMP_PKIHEADER *hdr);
+ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_recipNonce(const OSSL_CMP_PKIHEADER *hdr);
+
+/* from cmp_msg.c */
+OSSL_CMP_PKIHEADER *OSSL_CMP_MSG_get0_header(const OSSL_CMP_MSG *msg);
+int OSSL_CMP_MSG_get_bodytype(const OSSL_CMP_MSG *msg);
+int OSSL_CMP_MSG_update_transactionID(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg);
+OSSL_CRMF_MSG *OSSL_CMP_CTX_setup_CRM(OSSL_CMP_CTX *ctx, int for_KUR, int rid);
+OSSL_CMP_MSG *OSSL_CMP_MSG_read(const char *file, OSSL_LIB_CTX *libctx,
+                                const char *propq);
+int OSSL_CMP_MSG_write(const char *file, const OSSL_CMP_MSG *msg);
+OSSL_CMP_MSG *d2i_OSSL_CMP_MSG_bio(BIO *bio, OSSL_CMP_MSG **msg);
+int i2d_OSSL_CMP_MSG_bio(BIO *bio, const OSSL_CMP_MSG *msg);
+
+/* from cmp_vfy.c */
+int OSSL_CMP_validate_msg(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg);
+int OSSL_CMP_validate_cert_path(const OSSL_CMP_CTX *ctx,
+                                X509_STORE *trusted_store, X509 *cert);
+
+/* from cmp_http.c */
+OSSL_CMP_MSG *OSSL_CMP_MSG_http_perform(OSSL_CMP_CTX *ctx,
+                                        const OSSL_CMP_MSG *req);
+
+/* from cmp_server.c */
+typedef struct ossl_cmp_srv_ctx_st OSSL_CMP_SRV_CTX;
+OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx,
+                                           const OSSL_CMP_MSG *req);
+OSSL_CMP_MSG * OSSL_CMP_CTX_server_perform(OSSL_CMP_CTX *client_ctx,
+                                           const OSSL_CMP_MSG *req);
+OSSL_CMP_SRV_CTX *OSSL_CMP_SRV_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
+void OSSL_CMP_SRV_CTX_free(OSSL_CMP_SRV_CTX *srv_ctx);
+typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_cert_request_cb_t)
+    (OSSL_CMP_SRV_CTX *srv_ctx, const OSSL_CMP_MSG *req, int certReqId,
+     const OSSL_CRMF_MSG *crm, const X509_REQ *p10cr,
+     X509 **certOut, STACK_OF(X509) **chainOut, STACK_OF(X509) **caPubs);
+typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_rr_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                                const OSSL_CMP_MSG *req,
+                                                const X509_NAME *issuer,
+                                                const ASN1_INTEGER *serial);
+typedef int (*OSSL_CMP_SRV_genm_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                      const OSSL_CMP_MSG *req,
+                                      const STACK_OF(OSSL_CMP_ITAV) *in,
+                                      STACK_OF(OSSL_CMP_ITAV) **out);
+typedef void (*OSSL_CMP_SRV_error_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                        const OSSL_CMP_MSG *req,
+                                        const OSSL_CMP_PKISI *statusInfo,
+                                        const ASN1_INTEGER *errorCode,
+                                        const OSSL_CMP_PKIFREETEXT *errDetails);
+typedef int (*OSSL_CMP_SRV_certConf_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                          const OSSL_CMP_MSG *req,
+                                          int certReqId,
+                                          const ASN1_OCTET_STRING *certHash,
+                                          const OSSL_CMP_PKISI *si);
+typedef int (*OSSL_CMP_SRV_pollReq_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
+                                         const OSSL_CMP_MSG *req, int certReqId,
+                                         OSSL_CMP_MSG **certReq,
+                                         int64_t *check_after);
+int OSSL_CMP_SRV_CTX_init(OSSL_CMP_SRV_CTX *srv_ctx, void *custom_ctx,
+                          OSSL_CMP_SRV_cert_request_cb_t process_cert_request,
+                          OSSL_CMP_SRV_rr_cb_t process_rr,
+                          OSSL_CMP_SRV_genm_cb_t process_genm,
+                          OSSL_CMP_SRV_error_cb_t process_error,
+                          OSSL_CMP_SRV_certConf_cb_t process_certConf,
+                          OSSL_CMP_SRV_pollReq_cb_t process_pollReq);
+OSSL_CMP_CTX *OSSL_CMP_SRV_CTX_get0_cmp_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
+void *OSSL_CMP_SRV_CTX_get0_custom_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
+int OSSL_CMP_SRV_CTX_set_send_unprotected_errors(OSSL_CMP_SRV_CTX *srv_ctx,
+                                                 int val);
+int OSSL_CMP_SRV_CTX_set_accept_unprotected(OSSL_CMP_SRV_CTX *srv_ctx, int val);
+int OSSL_CMP_SRV_CTX_set_accept_raverified(OSSL_CMP_SRV_CTX *srv_ctx, int val);
+int OSSL_CMP_SRV_CTX_set_grant_implicit_confirm(OSSL_CMP_SRV_CTX *srv_ctx,
+                                                int val);
+
+/* from cmp_client.c */
+X509 *OSSL_CMP_exec_certreq(OSSL_CMP_CTX *ctx, int req_type,
+                            const OSSL_CRMF_MSG *crm);
+#  define OSSL_CMP_IR    0
+#  define OSSL_CMP_CR    2
+#  define OSSL_CMP_P10CR 4
+#  define OSSL_CMP_KUR   7
+#  define OSSL_CMP_exec_IR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_IR, NULL)
+#  define OSSL_CMP_exec_CR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_CR, NULL)
+#  define OSSL_CMP_exec_P10CR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_P10CR, NULL)
+#  define OSSL_CMP_exec_KUR_ses(ctx) \
+    OSSL_CMP_exec_certreq(ctx, OSSL_CMP_KUR, NULL)
+int OSSL_CMP_try_certreq(OSSL_CMP_CTX *ctx, int req_type,
+                         const OSSL_CRMF_MSG *crm, int *checkAfter);
+int OSSL_CMP_exec_RR_ses(OSSL_CMP_CTX *ctx);
+STACK_OF(OSSL_CMP_ITAV) *OSSL_CMP_exec_GENM_ses(OSSL_CMP_CTX *ctx);
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif /* !defined(OPENSSL_NO_CMP) */
+#endif /* !defined(OPENSSL_CMP_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/cmp_util.h b/CAPI/cpp/grpc/include/openssl/cmp_util.h
new file mode 100644
index 0000000..9a16892
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cmp_util.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2007-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Nokia 2007-2019
+ * Copyright Siemens AG 2015-2019
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMP_UTIL_H
+# define OPENSSL_CMP_UTIL_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# ifndef OPENSSL_NO_CMP
+
+#  include <openssl/macros.h>
+#  include <openssl/trace.h>
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+int  OSSL_CMP_log_open(void);
+void OSSL_CMP_log_close(void);
+#  define OSSL_CMP_LOG_PREFIX "CMP "
+
+/*
+ * generalized logging/error callback mirroring the severity levels of syslog.h
+ */
+typedef int OSSL_CMP_severity;
+#  define OSSL_CMP_LOG_EMERG   0
+#  define OSSL_CMP_LOG_ALERT   1
+#  define OSSL_CMP_LOG_CRIT    2
+#  define OSSL_CMP_LOG_ERR     3
+#  define OSSL_CMP_LOG_WARNING 4
+#  define OSSL_CMP_LOG_NOTICE  5
+#  define OSSL_CMP_LOG_INFO    6
+#  define OSSL_CMP_LOG_DEBUG   7
+#  define OSSL_CMP_LOG_TRACE   8
+#  define OSSL_CMP_LOG_MAX     OSSL_CMP_LOG_TRACE
+typedef int (*OSSL_CMP_log_cb_t)(const char *func, const char *file, int line,
+                                 OSSL_CMP_severity level, const char *msg);
+
+int OSSL_CMP_print_to_bio(BIO *bio, const char *component, const char *file,
+                          int line, OSSL_CMP_severity level, const char *msg);
+/* use of the logging callback for outputting error queue */
+void OSSL_CMP_print_errors_cb(OSSL_CMP_log_cb_t log_fn);
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif /* !defined(OPENSSL_NO_CMP) */
+#endif /* !defined(OPENSSL_CMP_UTIL_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/cmperr.h b/CAPI/cpp/grpc/include/openssl/cmperr.h
new file mode 100644
index 0000000..3a26fd0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cmperr.h
@@ -0,0 +1,112 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMPERR_H
+# define OPENSSL_CMPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_CMP
+
+
+/*
+ * CMP reason codes.
+ */
+#  define CMP_R_ALGORITHM_NOT_SUPPORTED                    139
+#  define CMP_R_BAD_CHECKAFTER_IN_POLLREP                  167
+#  define CMP_R_BAD_REQUEST_ID                             108
+#  define CMP_R_CERTHASH_UNMATCHED                         156
+#  define CMP_R_CERTID_NOT_FOUND                           109
+#  define CMP_R_CERTIFICATE_NOT_ACCEPTED                   169
+#  define CMP_R_CERTIFICATE_NOT_FOUND                      112
+#  define CMP_R_CERTREQMSG_NOT_FOUND                       157
+#  define CMP_R_CERTRESPONSE_NOT_FOUND                     113
+#  define CMP_R_CERT_AND_KEY_DO_NOT_MATCH                  114
+#  define CMP_R_CHECKAFTER_OUT_OF_RANGE                    181
+#  define CMP_R_ENCOUNTERED_KEYUPDATEWARNING               176
+#  define CMP_R_ENCOUNTERED_WAITING                        162
+#  define CMP_R_ERROR_CALCULATING_PROTECTION               115
+#  define CMP_R_ERROR_CREATING_CERTCONF                    116
+#  define CMP_R_ERROR_CREATING_CERTREP                     117
+#  define CMP_R_ERROR_CREATING_CERTREQ                     163
+#  define CMP_R_ERROR_CREATING_ERROR                       118
+#  define CMP_R_ERROR_CREATING_GENM                        119
+#  define CMP_R_ERROR_CREATING_GENP                        120
+#  define CMP_R_ERROR_CREATING_PKICONF                     122
+#  define CMP_R_ERROR_CREATING_POLLREP                     123
+#  define CMP_R_ERROR_CREATING_POLLREQ                     124
+#  define CMP_R_ERROR_CREATING_RP                          125
+#  define CMP_R_ERROR_CREATING_RR                          126
+#  define CMP_R_ERROR_PARSING_PKISTATUS                    107
+#  define CMP_R_ERROR_PROCESSING_MESSAGE                   158
+#  define CMP_R_ERROR_PROTECTING_MESSAGE                   127
+#  define CMP_R_ERROR_SETTING_CERTHASH                     128
+#  define CMP_R_ERROR_UNEXPECTED_CERTCONF                  160
+#  define CMP_R_ERROR_VALIDATING_PROTECTION                140
+#  define CMP_R_ERROR_VALIDATING_SIGNATURE                 171
+#  define CMP_R_FAILED_BUILDING_OWN_CHAIN                  164
+#  define CMP_R_FAILED_EXTRACTING_PUBKEY                   141
+#  define CMP_R_FAILURE_OBTAINING_RANDOM                   110
+#  define CMP_R_FAIL_INFO_OUT_OF_RANGE                     129
+#  define CMP_R_INVALID_ARGS                               100
+#  define CMP_R_INVALID_OPTION                             174
+#  define CMP_R_MISSING_CERTID                             165
+#  define CMP_R_MISSING_KEY_INPUT_FOR_CREATING_PROTECTION  130
+#  define CMP_R_MISSING_KEY_USAGE_DIGITALSIGNATURE         142
+#  define CMP_R_MISSING_P10CSR                             121
+#  define CMP_R_MISSING_PBM_SECRET                         166
+#  define CMP_R_MISSING_PRIVATE_KEY                        131
+#  define CMP_R_MISSING_PROTECTION                         143
+#  define CMP_R_MISSING_REFERENCE_CERT                     168
+#  define CMP_R_MISSING_SENDER_IDENTIFICATION              111
+#  define CMP_R_MISSING_TRUST_STORE                        144
+#  define CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED            161
+#  define CMP_R_MULTIPLE_RESPONSES_NOT_SUPPORTED           170
+#  define CMP_R_MULTIPLE_SAN_SOURCES                       102
+#  define CMP_R_NO_STDIO                                   194
+#  define CMP_R_NO_SUITABLE_SENDER_CERT                    145
+#  define CMP_R_NULL_ARGUMENT                              103
+#  define CMP_R_PKIBODY_ERROR                              146
+#  define CMP_R_PKISTATUSINFO_NOT_FOUND                    132
+#  define CMP_R_POLLING_FAILED                             172
+#  define CMP_R_POTENTIALLY_INVALID_CERTIFICATE            147
+#  define CMP_R_RECEIVED_ERROR                             180
+#  define CMP_R_RECIPNONCE_UNMATCHED                       148
+#  define CMP_R_REQUEST_NOT_ACCEPTED                       149
+#  define CMP_R_REQUEST_REJECTED_BY_SERVER                 182
+#  define CMP_R_SENDER_GENERALNAME_TYPE_NOT_SUPPORTED      150
+#  define CMP_R_SRVCERT_DOES_NOT_VALIDATE_MSG              151
+#  define CMP_R_TOTAL_TIMEOUT                              184
+#  define CMP_R_TRANSACTIONID_UNMATCHED                    152
+#  define CMP_R_TRANSFER_ERROR                             159
+#  define CMP_R_UNEXPECTED_PKIBODY                         133
+#  define CMP_R_UNEXPECTED_PKISTATUS                       185
+#  define CMP_R_UNEXPECTED_PVNO                            153
+#  define CMP_R_UNKNOWN_ALGORITHM_ID                       134
+#  define CMP_R_UNKNOWN_CERT_TYPE                          135
+#  define CMP_R_UNKNOWN_PKISTATUS                          186
+#  define CMP_R_UNSUPPORTED_ALGORITHM                      136
+#  define CMP_R_UNSUPPORTED_KEY_TYPE                       137
+#  define CMP_R_UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC      154
+#  define CMP_R_VALUE_TOO_LARGE                            175
+#  define CMP_R_VALUE_TOO_SMALL                            177
+#  define CMP_R_WRONG_ALGORITHM_OID                        138
+#  define CMP_R_WRONG_CERTID                               189
+#  define CMP_R_WRONG_CERTID_IN_RP                         187
+#  define CMP_R_WRONG_PBM_VALUE                            155
+#  define CMP_R_WRONG_RP_COMPONENT_COUNT                   188
+#  define CMP_R_WRONG_SERIAL_IN_RP                         173
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/cms.h b/CAPI/cpp/grpc/include/openssl/cms.h
new file mode 100644
index 0000000..5b907f2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cms.h
@@ -0,0 +1,493 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\cms.h.in
+ *
+ * Copyright 2008-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_CMS_H
+# define OPENSSL_CMS_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CMS_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CMS
+# include <openssl/x509.h>
+# include <openssl/x509v3.h>
+# include <openssl/cmserr.h>
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+typedef struct CMS_ContentInfo_st CMS_ContentInfo;
+typedef struct CMS_SignerInfo_st CMS_SignerInfo;
+typedef struct CMS_CertificateChoices CMS_CertificateChoices;
+typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice;
+typedef struct CMS_RecipientInfo_st CMS_RecipientInfo;
+typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest;
+typedef struct CMS_Receipt_st CMS_Receipt;
+typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey;
+typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute;
+
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_SignerInfo, CMS_SignerInfo, CMS_SignerInfo)
+#define sk_CMS_SignerInfo_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_value(sk, idx) ((CMS_SignerInfo *)OPENSSL_sk_value(ossl_check_const_CMS_SignerInfo_sk_type(sk), (idx)))
+#define sk_CMS_SignerInfo_new(cmp) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new(ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
+#define sk_CMS_SignerInfo_new_null() ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new_null())
+#define sk_CMS_SignerInfo_new_reserve(cmp, n) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new_reserve(ossl_check_CMS_SignerInfo_compfunc_type(cmp), (n)))
+#define sk_CMS_SignerInfo_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_SignerInfo_sk_type(sk), (n))
+#define sk_CMS_SignerInfo_free(sk) OPENSSL_sk_free(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_delete(sk, i) ((CMS_SignerInfo *)OPENSSL_sk_delete(ossl_check_CMS_SignerInfo_sk_type(sk), (i)))
+#define sk_CMS_SignerInfo_delete_ptr(sk, ptr) ((CMS_SignerInfo *)OPENSSL_sk_delete_ptr(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr)))
+#define sk_CMS_SignerInfo_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_pop(sk) ((CMS_SignerInfo *)OPENSSL_sk_pop(ossl_check_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_shift(sk) ((CMS_SignerInfo *)OPENSSL_sk_shift(ossl_check_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_SignerInfo_sk_type(sk),ossl_check_CMS_SignerInfo_freefunc_type(freefunc))
+#define sk_CMS_SignerInfo_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr), (idx))
+#define sk_CMS_SignerInfo_set(sk, idx, ptr) ((CMS_SignerInfo *)OPENSSL_sk_set(ossl_check_CMS_SignerInfo_sk_type(sk), (idx), ossl_check_CMS_SignerInfo_type(ptr)))
+#define sk_CMS_SignerInfo_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
+#define sk_CMS_SignerInfo_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr), pnum)
+#define sk_CMS_SignerInfo_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_SignerInfo_sk_type(sk))
+#define sk_CMS_SignerInfo_dup(sk) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_dup(ossl_check_const_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_copyfunc_type(copyfunc), ossl_check_CMS_SignerInfo_freefunc_type(freefunc)))
+#define sk_CMS_SignerInfo_set_cmp_func(sk, cmp) ((sk_CMS_SignerInfo_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey)
+#define sk_CMS_RecipientEncryptedKey_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_value(sk, idx) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_value(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), (idx)))
+#define sk_CMS_RecipientEncryptedKey_new(cmp) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
+#define sk_CMS_RecipientEncryptedKey_new_null() ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new_null())
+#define sk_CMS_RecipientEncryptedKey_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp), (n)))
+#define sk_CMS_RecipientEncryptedKey_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (n))
+#define sk_CMS_RecipientEncryptedKey_free(sk) OPENSSL_sk_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_delete(sk, i) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_delete(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (i)))
+#define sk_CMS_RecipientEncryptedKey_delete_ptr(sk, ptr) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
+#define sk_CMS_RecipientEncryptedKey_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_pop(sk) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_pop(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_shift(sk) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_shift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk),ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc))
+#define sk_CMS_RecipientEncryptedKey_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr), (idx))
+#define sk_CMS_RecipientEncryptedKey_set(sk, idx, ptr) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_set(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (idx), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
+#define sk_CMS_RecipientEncryptedKey_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
+#define sk_CMS_RecipientEncryptedKey_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr), pnum)
+#define sk_CMS_RecipientEncryptedKey_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk))
+#define sk_CMS_RecipientEncryptedKey_dup(sk) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_copyfunc_type(copyfunc), ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc)))
+#define sk_CMS_RecipientEncryptedKey_set_cmp_func(sk, cmp) ((sk_CMS_RecipientEncryptedKey_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientInfo, CMS_RecipientInfo, CMS_RecipientInfo)
+#define sk_CMS_RecipientInfo_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_value(sk, idx) ((CMS_RecipientInfo *)OPENSSL_sk_value(ossl_check_const_CMS_RecipientInfo_sk_type(sk), (idx)))
+#define sk_CMS_RecipientInfo_new(cmp) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new(ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
+#define sk_CMS_RecipientInfo_new_null() ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new_null())
+#define sk_CMS_RecipientInfo_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientInfo_compfunc_type(cmp), (n)))
+#define sk_CMS_RecipientInfo_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RecipientInfo_sk_type(sk), (n))
+#define sk_CMS_RecipientInfo_free(sk) OPENSSL_sk_free(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_delete(sk, i) ((CMS_RecipientInfo *)OPENSSL_sk_delete(ossl_check_CMS_RecipientInfo_sk_type(sk), (i)))
+#define sk_CMS_RecipientInfo_delete_ptr(sk, ptr) ((CMS_RecipientInfo *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr)))
+#define sk_CMS_RecipientInfo_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_pop(sk) ((CMS_RecipientInfo *)OPENSSL_sk_pop(ossl_check_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_shift(sk) ((CMS_RecipientInfo *)OPENSSL_sk_shift(ossl_check_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientInfo_sk_type(sk),ossl_check_CMS_RecipientInfo_freefunc_type(freefunc))
+#define sk_CMS_RecipientInfo_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr), (idx))
+#define sk_CMS_RecipientInfo_set(sk, idx, ptr) ((CMS_RecipientInfo *)OPENSSL_sk_set(ossl_check_CMS_RecipientInfo_sk_type(sk), (idx), ossl_check_CMS_RecipientInfo_type(ptr)))
+#define sk_CMS_RecipientInfo_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
+#define sk_CMS_RecipientInfo_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr), pnum)
+#define sk_CMS_RecipientInfo_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RecipientInfo_sk_type(sk))
+#define sk_CMS_RecipientInfo_dup(sk) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_copyfunc_type(copyfunc), ossl_check_CMS_RecipientInfo_freefunc_type(freefunc)))
+#define sk_CMS_RecipientInfo_set_cmp_func(sk, cmp) ((sk_CMS_RecipientInfo_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CMS_RevocationInfoChoice, CMS_RevocationInfoChoice, CMS_RevocationInfoChoice)
+#define sk_CMS_RevocationInfoChoice_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_value(sk, idx) ((CMS_RevocationInfoChoice *)OPENSSL_sk_value(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), (idx)))
+#define sk_CMS_RevocationInfoChoice_new(cmp) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
+#define sk_CMS_RevocationInfoChoice_new_null() ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new_null())
+#define sk_CMS_RevocationInfoChoice_new_reserve(cmp, n) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp), (n)))
+#define sk_CMS_RevocationInfoChoice_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (n))
+#define sk_CMS_RevocationInfoChoice_free(sk) OPENSSL_sk_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_delete(sk, i) ((CMS_RevocationInfoChoice *)OPENSSL_sk_delete(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (i)))
+#define sk_CMS_RevocationInfoChoice_delete_ptr(sk, ptr) ((CMS_RevocationInfoChoice *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
+#define sk_CMS_RevocationInfoChoice_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_pop(sk) ((CMS_RevocationInfoChoice *)OPENSSL_sk_pop(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_shift(sk) ((CMS_RevocationInfoChoice *)OPENSSL_sk_shift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk),ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc))
+#define sk_CMS_RevocationInfoChoice_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr), (idx))
+#define sk_CMS_RevocationInfoChoice_set(sk, idx, ptr) ((CMS_RevocationInfoChoice *)OPENSSL_sk_set(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (idx), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
+#define sk_CMS_RevocationInfoChoice_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
+#define sk_CMS_RevocationInfoChoice_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr), pnum)
+#define sk_CMS_RevocationInfoChoice_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk))
+#define sk_CMS_RevocationInfoChoice_dup(sk) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_dup(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_copyfunc_type(copyfunc), ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc)))
+#define sk_CMS_RevocationInfoChoice_set_cmp_func(sk, cmp) ((sk_CMS_RevocationInfoChoice_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo)
+DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest)
+DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo)
+
+CMS_ContentInfo *CMS_ContentInfo_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+# define CMS_SIGNERINFO_ISSUER_SERIAL    0
+# define CMS_SIGNERINFO_KEYIDENTIFIER    1
+
+# define CMS_RECIPINFO_NONE              -1
+# define CMS_RECIPINFO_TRANS             0
+# define CMS_RECIPINFO_AGREE             1
+# define CMS_RECIPINFO_KEK               2
+# define CMS_RECIPINFO_PASS              3
+# define CMS_RECIPINFO_OTHER             4
+
+/* S/MIME related flags */
+
+# define CMS_TEXT                        0x1
+# define CMS_NOCERTS                     0x2
+# define CMS_NO_CONTENT_VERIFY           0x4
+# define CMS_NO_ATTR_VERIFY              0x8
+# define CMS_NOSIGS                      \
+                        (CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY)
+# define CMS_NOINTERN                    0x10
+# define CMS_NO_SIGNER_CERT_VERIFY       0x20
+# define CMS_NOVERIFY                    0x20
+# define CMS_DETACHED                    0x40
+# define CMS_BINARY                      0x80
+# define CMS_NOATTR                      0x100
+# define CMS_NOSMIMECAP                  0x200
+# define CMS_NOOLDMIMETYPE               0x400
+# define CMS_CRLFEOL                     0x800
+# define CMS_STREAM                      0x1000
+# define CMS_NOCRL                       0x2000
+# define CMS_PARTIAL                     0x4000
+# define CMS_REUSE_DIGEST                0x8000
+# define CMS_USE_KEYID                   0x10000
+# define CMS_DEBUG_DECRYPT               0x20000
+# define CMS_KEY_PARAM                   0x40000
+# define CMS_ASCIICRLF                   0x80000
+# define CMS_CADES                       0x100000
+# define CMS_USE_ORIGINATOR_KEYID        0x200000
+
+const ASN1_OBJECT *CMS_get0_type(const CMS_ContentInfo *cms);
+
+BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont);
+int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio);
+
+ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms);
+int CMS_is_detached(CMS_ContentInfo *cms);
+int CMS_set_detached(CMS_ContentInfo *cms, int detached);
+
+# ifdef OPENSSL_PEM_H
+DECLARE_PEM_rw(CMS, CMS_ContentInfo)
+# endif
+int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms);
+CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms);
+int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms);
+
+BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms);
+int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags);
+int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in,
+                             int flags);
+CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont);
+CMS_ContentInfo *SMIME_read_CMS_ex(BIO *bio, int flags, BIO **bcont, CMS_ContentInfo **ci);
+int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags);
+
+int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont,
+              unsigned int flags);
+
+CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey,
+                          STACK_OF(X509) *certs, BIO *data,
+                          unsigned int flags);
+CMS_ContentInfo *CMS_sign_ex(X509 *signcert, EVP_PKEY *pkey,
+                             STACK_OF(X509) *certs, BIO *data,
+                             unsigned int flags, OSSL_LIB_CTX *ctx,
+                             const char *propq);
+
+CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si,
+                                  X509 *signcert, EVP_PKEY *pkey,
+                                  STACK_OF(X509) *certs, unsigned int flags);
+
+int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags);
+CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags);
+CMS_ContentInfo *CMS_data_create_ex(BIO *in, unsigned int flags,
+                                    OSSL_LIB_CTX *ctx, const char *propq);
+
+int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
+                      unsigned int flags);
+CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md,
+                                   unsigned int flags);
+CMS_ContentInfo *CMS_digest_create_ex(BIO *in, const EVP_MD *md,
+                                      unsigned int flags, OSSL_LIB_CTX *ctx,
+                                      const char *propq);
+
+int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms,
+                              const unsigned char *key, size_t keylen,
+                              BIO *dcont, BIO *out, unsigned int flags);
+
+CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher,
+                                           const unsigned char *key,
+                                           size_t keylen, unsigned int flags);
+CMS_ContentInfo *CMS_EncryptedData_encrypt_ex(BIO *in, const EVP_CIPHER *cipher,
+                                              const unsigned char *key,
+                                              size_t keylen, unsigned int flags,
+                                              OSSL_LIB_CTX *ctx,
+                                              const char *propq);
+
+int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph,
+                               const unsigned char *key, size_t keylen);
+
+int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
+               X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags);
+
+int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms,
+                       STACK_OF(X509) *certs,
+                       X509_STORE *store, unsigned int flags);
+
+STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms);
+
+CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in,
+                             const EVP_CIPHER *cipher, unsigned int flags);
+CMS_ContentInfo *CMS_encrypt_ex(STACK_OF(X509) *certs, BIO *in,
+                                const EVP_CIPHER *cipher, unsigned int flags,
+                                OSSL_LIB_CTX *ctx, const char *propq);
+
+int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert,
+                BIO *dcont, BIO *out, unsigned int flags);
+
+int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert);
+int CMS_decrypt_set1_pkey_and_peer(CMS_ContentInfo *cms, EVP_PKEY *pk,
+                                   X509 *cert, X509 *peer);
+int CMS_decrypt_set1_key(CMS_ContentInfo *cms,
+                         unsigned char *key, size_t keylen,
+                         const unsigned char *id, size_t idlen);
+int CMS_decrypt_set1_password(CMS_ContentInfo *cms,
+                              unsigned char *pass, ossl_ssize_t passlen);
+
+STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms);
+int CMS_RecipientInfo_type(CMS_RecipientInfo *ri);
+EVP_PKEY_CTX *CMS_RecipientInfo_get0_pkey_ctx(CMS_RecipientInfo *ri);
+CMS_ContentInfo *CMS_AuthEnvelopedData_create(const EVP_CIPHER *cipher);
+CMS_ContentInfo *
+CMS_AuthEnvelopedData_create_ex(const EVP_CIPHER *cipher, OSSL_LIB_CTX *ctx,
+                                const char *propq);
+CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher);
+CMS_ContentInfo *CMS_EnvelopedData_create_ex(const EVP_CIPHER *cipher,
+                                             OSSL_LIB_CTX *ctx,
+                                             const char *propq);
+
+CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms,
+                                           X509 *recip, unsigned int flags);
+CMS_RecipientInfo *CMS_add1_recipient(CMS_ContentInfo *cms, X509 *recip,
+     EVP_PKEY *originatorPrivKey, X509 * originator, unsigned int flags);
+int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey);
+int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert);
+int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri,
+                                     EVP_PKEY **pk, X509 **recip,
+                                     X509_ALGOR **palg);
+int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri,
+                                          ASN1_OCTET_STRING **keyid,
+                                          X509_NAME **issuer,
+                                          ASN1_INTEGER **sno);
+
+CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid,
+                                          unsigned char *key, size_t keylen,
+                                          unsigned char *id, size_t idlen,
+                                          ASN1_GENERALIZEDTIME *date,
+                                          ASN1_OBJECT *otherTypeId,
+                                          ASN1_TYPE *otherType);
+
+int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri,
+                                    X509_ALGOR **palg,
+                                    ASN1_OCTET_STRING **pid,
+                                    ASN1_GENERALIZEDTIME **pdate,
+                                    ASN1_OBJECT **potherid,
+                                    ASN1_TYPE **pothertype);
+
+int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri,
+                               unsigned char *key, size_t keylen);
+
+int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri,
+                                   const unsigned char *id, size_t idlen);
+
+int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri,
+                                    unsigned char *pass,
+                                    ossl_ssize_t passlen);
+
+CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,
+                                               int iter, int wrap_nid,
+                                               int pbe_nid,
+                                               unsigned char *pass,
+                                               ossl_ssize_t passlen,
+                                               const EVP_CIPHER *kekciph);
+
+int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri);
+int CMS_RecipientInfo_encrypt(const CMS_ContentInfo *cms, CMS_RecipientInfo *ri);
+
+int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
+                   unsigned int flags);
+CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags);
+
+int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid);
+const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms);
+
+CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms);
+int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert);
+int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert);
+STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms);
+
+CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms);
+int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl);
+int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl);
+STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms);
+
+int CMS_SignedData_init(CMS_ContentInfo *cms);
+CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms,
+                                X509 *signer, EVP_PKEY *pk, const EVP_MD *md,
+                                unsigned int flags);
+EVP_PKEY_CTX *CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si);
+EVP_MD_CTX *CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si);
+STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms);
+
+void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer);
+int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si,
+                                  ASN1_OCTET_STRING **keyid,
+                                  X509_NAME **issuer, ASN1_INTEGER **sno);
+int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert);
+int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
+                           unsigned int flags);
+void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk,
+                              X509 **signer, X509_ALGOR **pdig,
+                              X509_ALGOR **psig);
+ASN1_OCTET_STRING *CMS_SignerInfo_get0_signature(CMS_SignerInfo *si);
+int CMS_SignerInfo_sign(CMS_SignerInfo *si);
+int CMS_SignerInfo_verify(CMS_SignerInfo *si);
+int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain);
+
+int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs);
+int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs,
+                            int algnid, int keysize);
+int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap);
+
+int CMS_signed_get_attr_count(const CMS_SignerInfo *si);
+int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
+                               int lastpos);
+int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, const ASN1_OBJECT *obj,
+                               int lastpos);
+X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc);
+X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc);
+int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr);
+int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si,
+                                const ASN1_OBJECT *obj, int type,
+                                const void *bytes, int len);
+int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si,
+                                int nid, int type,
+                                const void *bytes, int len);
+int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si,
+                                const char *attrname, int type,
+                                const void *bytes, int len);
+void *CMS_signed_get0_data_by_OBJ(const CMS_SignerInfo *si,
+                                  const ASN1_OBJECT *oid,
+                                  int lastpos, int type);
+
+int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si);
+int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
+                                 int lastpos);
+int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si,
+                                 const ASN1_OBJECT *obj, int lastpos);
+X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc);
+X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc);
+int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr);
+int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si,
+                                  const ASN1_OBJECT *obj, int type,
+                                  const void *bytes, int len);
+int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si,
+                                  int nid, int type,
+                                  const void *bytes, int len);
+int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si,
+                                  const char *attrname, int type,
+                                  const void *bytes, int len);
+void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid,
+                                    int lastpos, int type);
+
+int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr);
+CMS_ReceiptRequest *CMS_ReceiptRequest_create0(
+    unsigned char *id, int idlen, int allorfirst,
+    STACK_OF(GENERAL_NAMES) *receiptList,
+    STACK_OF(GENERAL_NAMES) *receiptsTo);
+CMS_ReceiptRequest *CMS_ReceiptRequest_create0_ex(
+    unsigned char *id, int idlen, int allorfirst,
+    STACK_OF(GENERAL_NAMES) *receiptList,
+    STACK_OF(GENERAL_NAMES) *receiptsTo,
+    OSSL_LIB_CTX *ctx);
+
+int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr);
+void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr,
+                                    ASN1_STRING **pcid,
+                                    int *pallorfirst,
+                                    STACK_OF(GENERAL_NAMES) **plist,
+                                    STACK_OF(GENERAL_NAMES) **prto);
+int CMS_RecipientInfo_kari_get0_alg(CMS_RecipientInfo *ri,
+                                    X509_ALGOR **palg,
+                                    ASN1_OCTET_STRING **pukm);
+STACK_OF(CMS_RecipientEncryptedKey)
+*CMS_RecipientInfo_kari_get0_reks(CMS_RecipientInfo *ri);
+
+int CMS_RecipientInfo_kari_get0_orig_id(CMS_RecipientInfo *ri,
+                                        X509_ALGOR **pubalg,
+                                        ASN1_BIT_STRING **pubkey,
+                                        ASN1_OCTET_STRING **keyid,
+                                        X509_NAME **issuer,
+                                        ASN1_INTEGER **sno);
+
+int CMS_RecipientInfo_kari_orig_id_cmp(CMS_RecipientInfo *ri, X509 *cert);
+
+int CMS_RecipientEncryptedKey_get0_id(CMS_RecipientEncryptedKey *rek,
+                                      ASN1_OCTET_STRING **keyid,
+                                      ASN1_GENERALIZEDTIME **tm,
+                                      CMS_OtherKeyAttribute **other,
+                                      X509_NAME **issuer, ASN1_INTEGER **sno);
+int CMS_RecipientEncryptedKey_cert_cmp(CMS_RecipientEncryptedKey *rek,
+                                       X509 *cert);
+int CMS_RecipientInfo_kari_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pk);
+int CMS_RecipientInfo_kari_set0_pkey_and_peer(CMS_RecipientInfo *ri, EVP_PKEY *pk, X509 *peer);
+EVP_CIPHER_CTX *CMS_RecipientInfo_kari_get0_ctx(CMS_RecipientInfo *ri);
+int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo *cms,
+                                   CMS_RecipientInfo *ri,
+                                   CMS_RecipientEncryptedKey *rek);
+
+int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg,
+                          ASN1_OCTET_STRING *ukm, int keylen);
+
+/* Backward compatibility for spelling errors. */
+# define CMS_R_UNKNOWN_DIGEST_ALGORITM CMS_R_UNKNOWN_DIGEST_ALGORITHM
+# define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE \
+    CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/cmserr.h b/CAPI/cpp/grpc/include/openssl/cmserr.h
new file mode 100644
index 0000000..1c4f4c7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cmserr.h
@@ -0,0 +1,122 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CMSERR_H
+# define OPENSSL_CMSERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_CMS
+
+
+/*
+ * CMS reason codes.
+ */
+#  define CMS_R_ADD_SIGNER_ERROR                           99
+#  define CMS_R_ATTRIBUTE_ERROR                            161
+#  define CMS_R_CERTIFICATE_ALREADY_PRESENT                175
+#  define CMS_R_CERTIFICATE_HAS_NO_KEYID                   160
+#  define CMS_R_CERTIFICATE_VERIFY_ERROR                   100
+#  define CMS_R_CIPHER_AEAD_SET_TAG_ERROR                  184
+#  define CMS_R_CIPHER_GET_TAG                             185
+#  define CMS_R_CIPHER_INITIALISATION_ERROR                101
+#  define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR      102
+#  define CMS_R_CMS_DATAFINAL_ERROR                        103
+#  define CMS_R_CMS_LIB                                    104
+#  define CMS_R_CONTENTIDENTIFIER_MISMATCH                 170
+#  define CMS_R_CONTENT_NOT_FOUND                          105
+#  define CMS_R_CONTENT_TYPE_MISMATCH                      171
+#  define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA           106
+#  define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA            107
+#  define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA               108
+#  define CMS_R_CONTENT_VERIFY_ERROR                       109
+#  define CMS_R_CTRL_ERROR                                 110
+#  define CMS_R_CTRL_FAILURE                               111
+#  define CMS_R_DECODE_ERROR                               187
+#  define CMS_R_DECRYPT_ERROR                              112
+#  define CMS_R_ERROR_GETTING_PUBLIC_KEY                   113
+#  define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE      114
+#  define CMS_R_ERROR_SETTING_KEY                          115
+#  define CMS_R_ERROR_SETTING_RECIPIENTINFO                116
+#  define CMS_R_ESS_SIGNING_CERTID_MISMATCH_ERROR          183
+#  define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH               117
+#  define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER           176
+#  define CMS_R_INVALID_KEY_LENGTH                         118
+#  define CMS_R_INVALID_LABEL                              190
+#  define CMS_R_INVALID_OAEP_PARAMETERS                    191
+#  define CMS_R_KDF_PARAMETER_ERROR                        186
+#  define CMS_R_MD_BIO_INIT_ERROR                          119
+#  define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH       120
+#  define CMS_R_MESSAGEDIGEST_WRONG_LENGTH                 121
+#  define CMS_R_MSGSIGDIGEST_ERROR                         172
+#  define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE          162
+#  define CMS_R_MSGSIGDIGEST_WRONG_LENGTH                  163
+#  define CMS_R_NEED_ONE_SIGNER                            164
+#  define CMS_R_NOT_A_SIGNED_RECEIPT                       165
+#  define CMS_R_NOT_ENCRYPTED_DATA                         122
+#  define CMS_R_NOT_KEK                                    123
+#  define CMS_R_NOT_KEY_AGREEMENT                          181
+#  define CMS_R_NOT_KEY_TRANSPORT                          124
+#  define CMS_R_NOT_PWRI                                   177
+#  define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE            125
+#  define CMS_R_NO_CIPHER                                  126
+#  define CMS_R_NO_CONTENT                                 127
+#  define CMS_R_NO_CONTENT_TYPE                            173
+#  define CMS_R_NO_DEFAULT_DIGEST                          128
+#  define CMS_R_NO_DIGEST_SET                              129
+#  define CMS_R_NO_KEY                                     130
+#  define CMS_R_NO_KEY_OR_CERT                             174
+#  define CMS_R_NO_MATCHING_DIGEST                         131
+#  define CMS_R_NO_MATCHING_RECIPIENT                      132
+#  define CMS_R_NO_MATCHING_SIGNATURE                      166
+#  define CMS_R_NO_MSGSIGDIGEST                            167
+#  define CMS_R_NO_PASSWORD                                178
+#  define CMS_R_NO_PRIVATE_KEY                             133
+#  define CMS_R_NO_PUBLIC_KEY                              134
+#  define CMS_R_NO_RECEIPT_REQUEST                         168
+#  define CMS_R_NO_SIGNERS                                 135
+#  define CMS_R_PEER_KEY_ERROR                             188
+#  define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE     136
+#  define CMS_R_RECEIPT_DECODE_ERROR                       169
+#  define CMS_R_RECIPIENT_ERROR                            137
+#  define CMS_R_SHARED_INFO_ERROR                          189
+#  define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND               138
+#  define CMS_R_SIGNFINAL_ERROR                            139
+#  define CMS_R_SMIME_TEXT_ERROR                           140
+#  define CMS_R_STORE_INIT_ERROR                           141
+#  define CMS_R_TYPE_NOT_COMPRESSED_DATA                   142
+#  define CMS_R_TYPE_NOT_DATA                              143
+#  define CMS_R_TYPE_NOT_DIGESTED_DATA                     144
+#  define CMS_R_TYPE_NOT_ENCRYPTED_DATA                    145
+#  define CMS_R_TYPE_NOT_ENVELOPED_DATA                    146
+#  define CMS_R_UNABLE_TO_FINALIZE_CONTEXT                 147
+#  define CMS_R_UNKNOWN_CIPHER                             148
+#  define CMS_R_UNKNOWN_DIGEST_ALGORITHM                   149
+#  define CMS_R_UNKNOWN_ID                                 150
+#  define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM          151
+#  define CMS_R_UNSUPPORTED_CONTENT_TYPE                   152
+#  define CMS_R_UNSUPPORTED_ENCRYPTION_TYPE                192
+#  define CMS_R_UNSUPPORTED_KEK_ALGORITHM                  153
+#  define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM       179
+#  define CMS_R_UNSUPPORTED_LABEL_SOURCE                   193
+#  define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE             155
+#  define CMS_R_UNSUPPORTED_RECIPIENT_TYPE                 154
+#  define CMS_R_UNSUPPORTED_TYPE                           156
+#  define CMS_R_UNWRAP_ERROR                               157
+#  define CMS_R_UNWRAP_FAILURE                             180
+#  define CMS_R_VERIFICATION_FAILURE                       158
+#  define CMS_R_WRAP_ERROR                                 159
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/comp.h b/CAPI/cpp/grpc/include/openssl/comp.h
new file mode 100644
index 0000000..06ff581
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/comp.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_COMP_H
+# define OPENSSL_COMP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_COMP_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_COMP
+# include <openssl/crypto.h>
+# include <openssl/comperr.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+
+
+COMP_CTX *COMP_CTX_new(COMP_METHOD *meth);
+const COMP_METHOD *COMP_CTX_get_method(const COMP_CTX *ctx);
+int COMP_CTX_get_type(const COMP_CTX* comp);
+int COMP_get_type(const COMP_METHOD *meth);
+const char *COMP_get_name(const COMP_METHOD *meth);
+void COMP_CTX_free(COMP_CTX *ctx);
+
+int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen,
+                        unsigned char *in, int ilen);
+int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen,
+                      unsigned char *in, int ilen);
+
+COMP_METHOD *COMP_zlib(void);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define COMP_zlib_cleanup() while(0) continue
+#endif
+
+# ifdef OPENSSL_BIO_H
+#  ifdef ZLIB
+const BIO_METHOD *BIO_f_zlib(void);
+#  endif
+# endif
+
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/comperr.h b/CAPI/cpp/grpc/include/openssl/comperr.h
new file mode 100644
index 0000000..01dd3e6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/comperr.h
@@ -0,0 +1,31 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_COMPERR_H
+# define OPENSSL_COMPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_COMP
+
+
+/*
+ * COMP reason codes.
+ */
+#  define COMP_R_ZLIB_DEFLATE_ERROR                        99
+#  define COMP_R_ZLIB_INFLATE_ERROR                        100
+#  define COMP_R_ZLIB_NOT_SUPPORTED                        101
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/conf.h b/CAPI/cpp/grpc/include/openssl/conf.h
new file mode 100644
index 0000000..07793f1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/conf.h
@@ -0,0 +1,211 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\conf.h.in
+ *
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef  OPENSSL_CONF_H
+# define OPENSSL_CONF_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CONF_H
+# endif
+
+# include <openssl/bio.h>
+# include <openssl/lhash.h>
+# include <openssl/safestack.h>
+# include <openssl/e_os2.h>
+# include <openssl/types.h>
+# include <openssl/conferr.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    char *section;
+    char *name;
+    char *value;
+} CONF_VALUE;
+
+SKM_DEFINE_STACK_OF_INTERNAL(CONF_VALUE, CONF_VALUE, CONF_VALUE)
+#define sk_CONF_VALUE_num(sk) OPENSSL_sk_num(ossl_check_const_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_value(sk, idx) ((CONF_VALUE *)OPENSSL_sk_value(ossl_check_const_CONF_VALUE_sk_type(sk), (idx)))
+#define sk_CONF_VALUE_new(cmp) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new(ossl_check_CONF_VALUE_compfunc_type(cmp)))
+#define sk_CONF_VALUE_new_null() ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new_null())
+#define sk_CONF_VALUE_new_reserve(cmp, n) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new_reserve(ossl_check_CONF_VALUE_compfunc_type(cmp), (n)))
+#define sk_CONF_VALUE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CONF_VALUE_sk_type(sk), (n))
+#define sk_CONF_VALUE_free(sk) OPENSSL_sk_free(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_zero(sk) OPENSSL_sk_zero(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_delete(sk, i) ((CONF_VALUE *)OPENSSL_sk_delete(ossl_check_CONF_VALUE_sk_type(sk), (i)))
+#define sk_CONF_VALUE_delete_ptr(sk, ptr) ((CONF_VALUE *)OPENSSL_sk_delete_ptr(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr)))
+#define sk_CONF_VALUE_push(sk, ptr) OPENSSL_sk_push(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_pop(sk) ((CONF_VALUE *)OPENSSL_sk_pop(ossl_check_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_shift(sk) ((CONF_VALUE *)OPENSSL_sk_shift(ossl_check_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CONF_VALUE_sk_type(sk),ossl_check_CONF_VALUE_freefunc_type(freefunc))
+#define sk_CONF_VALUE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr), (idx))
+#define sk_CONF_VALUE_set(sk, idx, ptr) ((CONF_VALUE *)OPENSSL_sk_set(ossl_check_CONF_VALUE_sk_type(sk), (idx), ossl_check_CONF_VALUE_type(ptr)))
+#define sk_CONF_VALUE_find(sk, ptr) OPENSSL_sk_find(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
+#define sk_CONF_VALUE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr), pnum)
+#define sk_CONF_VALUE_sort(sk) OPENSSL_sk_sort(ossl_check_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CONF_VALUE_sk_type(sk))
+#define sk_CONF_VALUE_dup(sk) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_dup(ossl_check_const_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_deep_copy(ossl_check_const_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_copyfunc_type(copyfunc), ossl_check_CONF_VALUE_freefunc_type(freefunc)))
+#define sk_CONF_VALUE_set_cmp_func(sk, cmp) ((sk_CONF_VALUE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_compfunc_type(cmp)))
+DEFINE_LHASH_OF_INTERNAL(CONF_VALUE);
+#define lh_CONF_VALUE_new(hfn, cmp) ((LHASH_OF(CONF_VALUE) *)OPENSSL_LH_new(ossl_check_CONF_VALUE_lh_hashfunc_type(hfn), ossl_check_CONF_VALUE_lh_compfunc_type(cmp)))
+#define lh_CONF_VALUE_free(lh) OPENSSL_LH_free(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_flush(lh) OPENSSL_LH_flush(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_insert(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_insert(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_delete(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_delete(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_retrieve(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_retrieve(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_error(lh) OPENSSL_LH_error(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_num_items(lh) OPENSSL_LH_num_items(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
+#define lh_CONF_VALUE_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_CONF_VALUE_lh_type(lh))
+#define lh_CONF_VALUE_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_CONF_VALUE_lh_type(lh), dl)
+#define lh_CONF_VALUE_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_doallfunc_type(dfn))
+
+
+struct conf_st;
+struct conf_method_st;
+typedef struct conf_method_st CONF_METHOD;
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  include <openssl/conftypes.h>
+# endif
+
+/* Module definitions */
+typedef struct conf_imodule_st CONF_IMODULE;
+typedef struct conf_module_st CONF_MODULE;
+
+STACK_OF(CONF_MODULE);
+STACK_OF(CONF_IMODULE);
+
+/* DSO module function typedefs */
+typedef int conf_init_func (CONF_IMODULE *md, const CONF *cnf);
+typedef void conf_finish_func (CONF_IMODULE *md);
+
+# define CONF_MFLAGS_IGNORE_ERRORS       0x1
+# define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2
+# define CONF_MFLAGS_SILENT              0x4
+# define CONF_MFLAGS_NO_DSO              0x8
+# define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10
+# define CONF_MFLAGS_DEFAULT_SECTION     0x20
+
+int CONF_set_default_method(CONF_METHOD *meth);
+void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash);
+LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file,
+                                long *eline);
+# ifndef OPENSSL_NO_STDIO
+LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp,
+                                   long *eline);
+# endif
+LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp,
+                                    long *eline);
+STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf,
+                                       const char *section);
+char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group,
+                      const char *name);
+long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group,
+                     const char *name);
+void CONF_free(LHASH_OF(CONF_VALUE) *conf);
+#ifndef OPENSSL_NO_STDIO
+int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out);
+#endif
+int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void OPENSSL_config(const char *config_name);
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define OPENSSL_no_config() \
+    OPENSSL_init_crypto(OPENSSL_INIT_NO_LOAD_CONFIG, NULL)
+#endif
+
+/*
+ * New conf code.  The semantics are different from the functions above. If
+ * that wasn't the case, the above functions would have been replaced
+ */
+
+CONF *NCONF_new_ex(OSSL_LIB_CTX *libctx, CONF_METHOD *meth);
+OSSL_LIB_CTX *NCONF_get0_libctx(const CONF *conf);
+CONF *NCONF_new(CONF_METHOD *meth);
+CONF_METHOD *NCONF_default(void);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 CONF_METHOD *NCONF_WIN32(void);
+#endif
+void NCONF_free(CONF *conf);
+void NCONF_free_data(CONF *conf);
+
+int NCONF_load(CONF *conf, const char *file, long *eline);
+# ifndef OPENSSL_NO_STDIO
+int NCONF_load_fp(CONF *conf, FILE *fp, long *eline);
+# endif
+int NCONF_load_bio(CONF *conf, BIO *bp, long *eline);
+STACK_OF(OPENSSL_CSTRING) *NCONF_get_section_names(const CONF *conf);
+STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,
+                                        const char *section);
+char *NCONF_get_string(const CONF *conf, const char *group, const char *name);
+int NCONF_get_number_e(const CONF *conf, const char *group, const char *name,
+                       long *result);
+#ifndef OPENSSL_NO_STDIO
+int NCONF_dump_fp(const CONF *conf, FILE *out);
+#endif
+int NCONF_dump_bio(const CONF *conf, BIO *out);
+
+#define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r)
+
+/* Module functions */
+
+int CONF_modules_load(const CONF *cnf, const char *appname,
+                      unsigned long flags);
+int CONF_modules_load_file_ex(OSSL_LIB_CTX *libctx, const char *filename,
+                              const char *appname, unsigned long flags);
+int CONF_modules_load_file(const char *filename, const char *appname,
+                           unsigned long flags);
+void CONF_modules_unload(int all);
+void CONF_modules_finish(void);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define CONF_modules_free() while(0) continue
+#endif
+int CONF_module_add(const char *name, conf_init_func *ifunc,
+                    conf_finish_func *ffunc);
+
+const char *CONF_imodule_get_name(const CONF_IMODULE *md);
+const char *CONF_imodule_get_value(const CONF_IMODULE *md);
+void *CONF_imodule_get_usr_data(const CONF_IMODULE *md);
+void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data);
+CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md);
+unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md);
+void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags);
+void *CONF_module_get_usr_data(CONF_MODULE *pmod);
+void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data);
+
+char *CONF_get1_default_config_file(void);
+
+int CONF_parse_list(const char *list, int sep, int nospc,
+                    int (*list_cb) (const char *elem, int len, void *usr),
+                    void *arg);
+
+void OPENSSL_load_builtin_modules(void);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/conf_api.h b/CAPI/cpp/grpc/include/openssl/conf_api.h
new file mode 100644
index 0000000..ed67d57
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/conf_api.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef  OPENSSL_CONF_API_H
+# define OPENSSL_CONF_API_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CONF_API_H
+# endif
+
+# include <openssl/lhash.h>
+# include <openssl/conf.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Up until OpenSSL 0.9.5a, this was new_section */
+CONF_VALUE *_CONF_new_section(CONF *conf, const char *section);
+/* Up until OpenSSL 0.9.5a, this was get_section */
+CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section);
+/* Up until OpenSSL 0.9.5a, this was CONF_get_section */
+STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf,
+                                               const char *section);
+
+int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value);
+char *_CONF_get_string(const CONF *conf, const char *section,
+                       const char *name);
+long _CONF_get_number(const CONF *conf, const char *section,
+                      const char *name);
+
+int _CONF_new_data(CONF *conf);
+void _CONF_free_data(CONF *conf);
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/conferr.h b/CAPI/cpp/grpc/include/openssl/conferr.h
new file mode 100644
index 0000000..496e2e1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/conferr.h
@@ -0,0 +1,51 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CONFERR_H
+# define OPENSSL_CONFERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * CONF reason codes.
+ */
+# define CONF_R_ERROR_LOADING_DSO                         110
+# define CONF_R_INVALID_PRAGMA                            122
+# define CONF_R_LIST_CANNOT_BE_NULL                       115
+# define CONF_R_MANDATORY_BRACES_IN_VARIABLE_EXPANSION    123
+# define CONF_R_MISSING_CLOSE_SQUARE_BRACKET              100
+# define CONF_R_MISSING_EQUAL_SIGN                        101
+# define CONF_R_MISSING_INIT_FUNCTION                     112
+# define CONF_R_MODULE_INITIALIZATION_ERROR               109
+# define CONF_R_NO_CLOSE_BRACE                            102
+# define CONF_R_NO_CONF                                   105
+# define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE           106
+# define CONF_R_NO_SECTION                                107
+# define CONF_R_NO_SUCH_FILE                              114
+# define CONF_R_NO_VALUE                                  108
+# define CONF_R_NUMBER_TOO_LARGE                          121
+# define CONF_R_OPENSSL_CONF_REFERENCES_MISSING_SECTION   124
+# define CONF_R_RECURSIVE_DIRECTORY_INCLUDE               111
+# define CONF_R_RELATIVE_PATH                             125
+# define CONF_R_SSL_COMMAND_SECTION_EMPTY                 117
+# define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND             118
+# define CONF_R_SSL_SECTION_EMPTY                         119
+# define CONF_R_SSL_SECTION_NOT_FOUND                     120
+# define CONF_R_UNABLE_TO_CREATE_NEW_SECTION              103
+# define CONF_R_UNKNOWN_MODULE_NAME                       113
+# define CONF_R_VARIABLE_EXPANSION_TOO_LONG               116
+# define CONF_R_VARIABLE_HAS_NO_VALUE                     104
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/configuration.h b/CAPI/cpp/grpc/include/openssl/configuration.h
new file mode 100644
index 0000000..00d8937
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/configuration.h
@@ -0,0 +1,146 @@
+/*
+ * WARNING: do not edit!
+ * Generated by configdata.pm from Configurations\common0.tmpl, Configurations\windows-makefile.tmpl
+ * via makefile.in
+ *
+ * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CONFIGURATION_H
+# define OPENSSL_CONFIGURATION_H
+# pragma once
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifdef OPENSSL_ALGORITHM_DEFINES
+#  error OPENSSL_ALGORITHM_DEFINES no longer supported
+# endif
+
+/*
+ * OpenSSL was configured with the following options:
+ */
+
+# ifndef OPENSSL_SYS_WIN64A
+#  define OPENSSL_SYS_WIN64A 1
+# endif
+# define OPENSSL_CONFIGURED_API 30000
+# ifndef OPENSSL_RAND_SEED_OS
+#  define OPENSSL_RAND_SEED_OS
+# endif
+# ifndef OPENSSL_THREADS
+#  define OPENSSL_THREADS
+# endif
+# ifndef OPENSSL_NO_ACVP_TESTS
+#  define OPENSSL_NO_ACVP_TESTS
+# endif
+# ifndef OPENSSL_NO_AFALGENG
+#  define OPENSSL_NO_AFALGENG
+# endif
+# ifndef OPENSSL_NO_ASAN
+#  define OPENSSL_NO_ASAN
+# endif
+# ifndef OPENSSL_NO_CRYPTO_MDEBUG
+#  define OPENSSL_NO_CRYPTO_MDEBUG
+# endif
+# ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
+#  define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
+# endif
+# ifndef OPENSSL_NO_DEVCRYPTOENG
+#  define OPENSSL_NO_DEVCRYPTOENG
+# endif
+# ifndef OPENSSL_NO_DSO
+#  define OPENSSL_NO_DSO
+# endif
+# ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
+#  define OPENSSL_NO_EC_NISTP_64_GCC_128
+# endif
+# ifndef OPENSSL_NO_EGD
+#  define OPENSSL_NO_EGD
+# endif
+# ifndef OPENSSL_NO_EXTERNAL_TESTS
+#  define OPENSSL_NO_EXTERNAL_TESTS
+# endif
+# ifndef OPENSSL_NO_FIPS_SECURITYCHECKS
+#  define OPENSSL_NO_FIPS_SECURITYCHECKS
+# endif
+# ifndef OPENSSL_NO_FUZZ_AFL
+#  define OPENSSL_NO_FUZZ_AFL
+# endif
+# ifndef OPENSSL_NO_FUZZ_LIBFUZZER
+#  define OPENSSL_NO_FUZZ_LIBFUZZER
+# endif
+# ifndef OPENSSL_NO_KTLS
+#  define OPENSSL_NO_KTLS
+# endif
+# ifndef OPENSSL_NO_LOADERENG
+#  define OPENSSL_NO_LOADERENG
+# endif
+# ifndef OPENSSL_NO_MD2
+#  define OPENSSL_NO_MD2
+# endif
+# ifndef OPENSSL_NO_MSAN
+#  define OPENSSL_NO_MSAN
+# endif
+# ifndef OPENSSL_NO_RC5
+#  define OPENSSL_NO_RC5
+# endif
+# ifndef OPENSSL_NO_SCTP
+#  define OPENSSL_NO_SCTP
+# endif
+# ifndef OPENSSL_NO_SSL3
+#  define OPENSSL_NO_SSL3
+# endif
+# ifndef OPENSSL_NO_SSL3_METHOD
+#  define OPENSSL_NO_SSL3_METHOD
+# endif
+# ifndef OPENSSL_NO_TESTS
+#  define OPENSSL_NO_TESTS
+# endif
+# ifndef OPENSSL_NO_TRACE
+#  define OPENSSL_NO_TRACE
+# endif
+# ifndef OPENSSL_NO_UBSAN
+#  define OPENSSL_NO_UBSAN
+# endif
+# ifndef OPENSSL_NO_UNIT_TEST
+#  define OPENSSL_NO_UNIT_TEST
+# endif
+# ifndef OPENSSL_NO_UPLINK
+#  define OPENSSL_NO_UPLINK
+# endif
+# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#  define OPENSSL_NO_WEAK_SSL_CIPHERS
+# endif
+# ifndef OPENSSL_NO_DYNAMIC_ENGINE
+#  define OPENSSL_NO_DYNAMIC_ENGINE
+# endif
+
+
+/* Generate 80386 code? */
+# undef I386_ONLY
+
+/*
+ * The following are cipher-specific, but are part of the public API.
+ */
+# if !defined(OPENSSL_SYS_UEFI)
+#  undef BN_LLONG
+/* Only one for the following should be defined */
+#  undef SIXTY_FOUR_BIT_LONG
+#  define SIXTY_FOUR_BIT
+#  undef THIRTY_TWO_BIT
+# endif
+
+# define RC4_INT unsigned int
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif                          /* OPENSSL_CONFIGURATION_H */
diff --git a/CAPI/cpp/grpc/include/openssl/conftypes.h b/CAPI/cpp/grpc/include/openssl/conftypes.h
new file mode 100644
index 0000000..17cefaa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/conftypes.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef  OPENSSL_CONFTYPES_H
+# define OPENSSL_CONFTYPES_H
+# pragma once
+
+#ifndef  OPENSSL_CONF_H
+# include <openssl/conf.h>
+#endif
+
+/*
+ * The contents of this file are deprecated and will be made opaque
+ */
+struct conf_method_st {
+    const char *name;
+    CONF *(*create) (CONF_METHOD *meth);
+    int (*init) (CONF *conf);
+    int (*destroy) (CONF *conf);
+    int (*destroy_data) (CONF *conf);
+    int (*load_bio) (CONF *conf, BIO *bp, long *eline);
+    int (*dump) (const CONF *conf, BIO *bp);
+    int (*is_number) (const CONF *conf, char c);
+    int (*to_int) (const CONF *conf, char c);
+    int (*load) (CONF *conf, const char *name, long *eline);
+};
+
+struct conf_st {
+    CONF_METHOD *meth;
+    void *meth_data;
+    LHASH_OF(CONF_VALUE) *data;
+    int flag_dollarid;
+    int flag_abspath;
+    char *includedir;
+    OSSL_LIB_CTX *libctx;
+};
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/core.h b/CAPI/cpp/grpc/include/openssl/core.h
new file mode 100644
index 0000000..9683ac7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/core.h
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_H
+# define OPENSSL_CORE_H
+# pragma once
+
+# include <stddef.h>
+# include <openssl/types.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/*-
+ * Base types
+ * ----------
+ *
+ * These are the types that the OpenSSL core and providers have in common
+ * to communicate data between them.
+ */
+
+/* Opaque handles to be used with core upcall functions from providers */
+typedef struct ossl_core_handle_st OSSL_CORE_HANDLE;
+typedef struct openssl_core_ctx_st OPENSSL_CORE_CTX;
+typedef struct ossl_core_bio_st OSSL_CORE_BIO;
+
+/*
+ * Dispatch table element.  function_id numbers and the functions are defined
+ * in core_dispatch.h, see macros with 'OSSL_CORE_MAKE_FUNC' in their names.
+ *
+ * An array of these is always terminated by function_id == 0
+ */
+struct ossl_dispatch_st {
+    int function_id;
+    void (*function)(void);
+};
+
+/*
+ * Other items, essentially an int<->pointer map element.
+ *
+ * We make this type distinct from OSSL_DISPATCH to ensure that dispatch
+ * tables remain tables with function pointers only.
+ *
+ * This is used whenever we need to pass things like a table of error reason
+ * codes <-> reason string maps, ...
+ *
+ * Usage determines which field works as key if any, rather than field order.
+ *
+ * An array of these is always terminated by id == 0 && ptr == NULL
+ */
+struct ossl_item_st {
+    unsigned int id;
+    void *ptr;
+};
+
+/*
+ * Type to tie together algorithm names, property definition string and
+ * the algorithm implementation in the form of a dispatch table.
+ *
+ * An array of these is always terminated by algorithm_names == NULL
+ */
+struct ossl_algorithm_st {
+    const char *algorithm_names;     /* key */
+    const char *property_definition; /* key */
+    const OSSL_DISPATCH *implementation;
+    const char *algorithm_description;
+};
+
+/*
+ * Type to pass object data in a uniform way, without exposing the object
+ * structure.
+ *
+ * An array of these is always terminated by key == NULL
+ */
+struct ossl_param_st {
+    const char *key;             /* the name of the parameter */
+    unsigned int data_type;      /* declare what kind of content is in buffer */
+    void *data;                  /* value being passed in or out */
+    size_t data_size;            /* data size */
+    size_t return_size;          /* returned content size */
+};
+
+/* Currently supported OSSL_PARAM data types */
+/*
+ * OSSL_PARAM_INTEGER and OSSL_PARAM_UNSIGNED_INTEGER
+ * are arbitrary length and therefore require an arbitrarily sized buffer,
+ * since they may be used to pass numbers larger than what is natively
+ * available.
+ *
+ * The number must be buffered in native form, i.e. MSB first on B_ENDIAN
+ * systems and LSB first on L_ENDIAN systems.  This means that arbitrary
+ * native integers can be stored in the buffer, just make sure that the
+ * buffer size is correct and the buffer itself is properly aligned (for
+ * example by having the buffer field point at a C integer).
+ */
+# define OSSL_PARAM_INTEGER              1
+# define OSSL_PARAM_UNSIGNED_INTEGER     2
+/*-
+ * OSSL_PARAM_REAL
+ * is a C binary floating point values in native form and alignment.
+ */
+# define OSSL_PARAM_REAL                 3
+/*-
+ * OSSL_PARAM_UTF8_STRING
+ * is a printable string.  It is expected to be printed as it is.
+ */
+# define OSSL_PARAM_UTF8_STRING          4
+/*-
+ * OSSL_PARAM_OCTET_STRING
+ * is a string of bytes with no further specification.  It is expected to be
+ * printed as a hexdump.
+ */
+# define OSSL_PARAM_OCTET_STRING         5
+/*-
+ * OSSL_PARAM_UTF8_PTR
+ * is a pointer to a printable string.  It is expected to be printed as it is.
+ *
+ * The difference between this and OSSL_PARAM_UTF8_STRING is that only pointers
+ * are manipulated for this type.
+ *
+ * This is more relevant for parameter requests, where the responding
+ * function doesn't need to copy the data to the provided buffer, but
+ * sets the provided buffer to point at the actual data instead.
+ *
+ * WARNING!  Using these is FRAGILE, as it assumes that the actual
+ * data and its location are constant.
+ *
+ * EXTRA WARNING!  If you are not completely sure you most likely want
+ * to use the OSSL_PARAM_UTF8_STRING type.
+ */
+# define OSSL_PARAM_UTF8_PTR             6
+/*-
+ * OSSL_PARAM_OCTET_PTR
+ * is a pointer to a string of bytes with no further specification.  It is
+ * expected to be printed as a hexdump.
+ *
+ * The difference between this and OSSL_PARAM_OCTET_STRING is that only pointers
+ * are manipulated for this type.
+ *
+ * This is more relevant for parameter requests, where the responding
+ * function doesn't need to copy the data to the provided buffer, but
+ * sets the provided buffer to point at the actual data instead.
+ *
+ * WARNING!  Using these is FRAGILE, as it assumes that the actual
+ * data and its location are constant.
+ *
+ * EXTRA WARNING!  If you are not completely sure you most likely want
+ * to use the OSSL_PARAM_OCTET_STRING type.
+ */
+# define OSSL_PARAM_OCTET_PTR            7
+
+/*
+ * Typedef for the thread stop handling callback. Used both internally and by
+ * providers.
+ *
+ * Providers may register for notifications about threads stopping by
+ * registering a callback to hear about such events. Providers register the
+ * callback using the OSSL_FUNC_CORE_THREAD_START function in the |in| dispatch
+ * table passed to OSSL_provider_init(). The arg passed back to a provider will
+ * be the provider side context object.
+ */
+typedef void (*OSSL_thread_stop_handler_fn)(void *arg);
+
+
+/*-
+ * Provider entry point
+ * --------------------
+ *
+ * This function is expected to be present in any dynamically loadable
+ * provider module.  By definition, if this function doesn't exist in a
+ * module, that module is not an OpenSSL provider module.
+ */
+/*-
+ * |handle|     pointer to opaque type OSSL_CORE_HANDLE.  This can be used
+ *              together with some functions passed via |in| to query data.
+ * |in|         is the array of functions that the Core passes to the provider.
+ * |out|        will be the array of base functions that the provider passes
+ *              back to the Core.
+ * |provctx|    a provider side context object, optionally created if the
+ *              provider needs it.  This value is passed to other provider
+ *              functions, notably other context constructors.
+ */
+typedef int (OSSL_provider_init_fn)(const OSSL_CORE_HANDLE *handle,
+                                    const OSSL_DISPATCH *in,
+                                    const OSSL_DISPATCH **out,
+                                    void **provctx);
+# ifdef __VMS
+#  pragma names save
+#  pragma names uppercase,truncated
+# endif
+OPENSSL_EXPORT OSSL_provider_init_fn OSSL_provider_init;
+# ifdef __VMS
+#  pragma names restore
+# endif
+
+/*
+ * Generic callback function signature.
+ *
+ * The expectation is that any provider function that wants to offer
+ * a callback / hook can do so by taking an argument with this type,
+ * as well as a pointer to caller-specific data.  When calling the
+ * callback, the provider function can populate an OSSL_PARAM array
+ * with data of its choice and pass that in the callback call, along
+ * with the caller data argument.
+ *
+ * libcrypto may use the OSSL_PARAM array to create arguments for an
+ * application callback it knows about.
+ */
+typedef int (OSSL_CALLBACK)(const OSSL_PARAM params[], void *arg);
+typedef int (OSSL_INOUT_CALLBACK)(const OSSL_PARAM in_params[],
+                                  OSSL_PARAM out_params[], void *arg);
+/*
+ * Passphrase callback function signature
+ *
+ * This is similar to the generic callback function above, but adds a
+ * result parameter.
+ */
+typedef int (OSSL_PASSPHRASE_CALLBACK)(char *pass, size_t pass_size,
+                                       size_t *pass_len,
+                                       const OSSL_PARAM params[], void *arg);
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/core_dispatch.h b/CAPI/cpp/grpc/include/openssl/core_dispatch.h
new file mode 100644
index 0000000..99fcda0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/core_dispatch.h
@@ -0,0 +1,943 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_NUMBERS_H
+# define OPENSSL_CORE_NUMBERS_H
+# pragma once
+
+# include <stdarg.h>
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/*-
+ * Identities
+ * ----------
+ *
+ * All series start with 1, to allow 0 to be an array terminator.
+ * For any FUNC identity, we also provide a function signature typedef
+ * and a static inline function to extract a function pointer from a
+ * OSSL_DISPATCH element in a type safe manner.
+ *
+ * Names:
+ * for any function base name 'foo' (uppercase form 'FOO'), we will have
+ * the following:
+ * - a macro for the identity with the name OSSL_FUNC_'FOO' or derivatives
+ *   thereof (to be specified further down)
+ * - a function signature typedef with the name OSSL_FUNC_'foo'_fn
+ * - a function pointer extractor function with the name OSSL_FUNC_'foo'
+ */
+
+/*
+ * Helper macro to create the function signature typedef and the extractor
+ * |type| is the return-type of the function, |name| is the name of the
+ * function to fetch, and |args| is a parenthesized list of parameters
+ * for the function (that is, it is |name|'s function signature).
+ * Note: This is considered a "reserved" internal macro. Applications should
+ * not use this or assume its existence.
+ */
+#define OSSL_CORE_MAKE_FUNC(type,name,args)                             \
+    typedef type (OSSL_FUNC_##name##_fn)args;                           \
+    static ossl_unused ossl_inline \
+    OSSL_FUNC_##name##_fn *OSSL_FUNC_##name(const OSSL_DISPATCH *opf)   \
+    {                                                                   \
+        return (OSSL_FUNC_##name##_fn *)opf->function;                  \
+    }
+
+/*
+ * Core function identities, for the two OSSL_DISPATCH tables being passed
+ * in the OSSL_provider_init call.
+ *
+ * 0 serves as a marker for the end of the OSSL_DISPATCH array, and must
+ * therefore NEVER be used as a function identity.
+ */
+/* Functions provided by the Core to the provider, reserved numbers 1-1023 */
+# define OSSL_FUNC_CORE_GETTABLE_PARAMS        1
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+                    core_gettable_params,(const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_GET_PARAMS             2
+OSSL_CORE_MAKE_FUNC(int,core_get_params,(const OSSL_CORE_HANDLE *prov,
+                                         OSSL_PARAM params[]))
+# define OSSL_FUNC_CORE_THREAD_START           3
+OSSL_CORE_MAKE_FUNC(int,core_thread_start,(const OSSL_CORE_HANDLE *prov,
+                                           OSSL_thread_stop_handler_fn handfn,
+                                           void *arg))
+# define OSSL_FUNC_CORE_GET_LIBCTX             4
+OSSL_CORE_MAKE_FUNC(OPENSSL_CORE_CTX *,core_get_libctx,
+                    (const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_NEW_ERROR              5
+OSSL_CORE_MAKE_FUNC(void,core_new_error,(const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_SET_ERROR_DEBUG        6
+OSSL_CORE_MAKE_FUNC(void,core_set_error_debug,
+                    (const OSSL_CORE_HANDLE *prov,
+                     const char *file, int line, const char *func))
+# define OSSL_FUNC_CORE_VSET_ERROR             7
+OSSL_CORE_MAKE_FUNC(void,core_vset_error,
+                    (const OSSL_CORE_HANDLE *prov,
+                     uint32_t reason, const char *fmt, va_list args))
+# define OSSL_FUNC_CORE_SET_ERROR_MARK         8
+OSSL_CORE_MAKE_FUNC(int, core_set_error_mark, (const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK  9
+OSSL_CORE_MAKE_FUNC(int, core_clear_last_error_mark,
+                    (const OSSL_CORE_HANDLE *prov))
+# define OSSL_FUNC_CORE_POP_ERROR_TO_MARK     10
+OSSL_CORE_MAKE_FUNC(int, core_pop_error_to_mark, (const OSSL_CORE_HANDLE *prov))
+
+
+/* Functions to access the OBJ database */
+
+#define OSSL_FUNC_CORE_OBJ_ADD_SIGID          11
+#define OSSL_FUNC_CORE_OBJ_CREATE             12
+
+OSSL_CORE_MAKE_FUNC(int, core_obj_add_sigid,
+                    (const OSSL_CORE_HANDLE *prov, const char  *sign_name,
+                     const char *digest_name, const char *pkey_name))
+OSSL_CORE_MAKE_FUNC(int, core_obj_create,
+                    (const OSSL_CORE_HANDLE *prov, const char *oid,
+                     const char *sn, const char *ln))
+
+/* Memory allocation, freeing, clearing. */
+#define OSSL_FUNC_CRYPTO_MALLOC               20
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_malloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_ZALLOC               21
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_zalloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_FREE                 22
+OSSL_CORE_MAKE_FUNC(void,
+        CRYPTO_free, (void *ptr, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_CLEAR_FREE           23
+OSSL_CORE_MAKE_FUNC(void,
+        CRYPTO_clear_free, (void *ptr, size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_REALLOC              24
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_realloc, (void *addr, size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_CLEAR_REALLOC        25
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_clear_realloc, (void *addr, size_t old_num, size_t num,
+                               const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_MALLOC        26
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_secure_malloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_ZALLOC        27
+OSSL_CORE_MAKE_FUNC(void *,
+        CRYPTO_secure_zalloc, (size_t num, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_FREE          28
+OSSL_CORE_MAKE_FUNC(void,
+        CRYPTO_secure_free, (void *ptr, const char *file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE    29
+OSSL_CORE_MAKE_FUNC(void,
+        CRYPTO_secure_clear_free, (void *ptr, size_t num, const char *file,
+                                   int line))
+#define OSSL_FUNC_CRYPTO_SECURE_ALLOCATED     30
+OSSL_CORE_MAKE_FUNC(int,
+        CRYPTO_secure_allocated, (const void *ptr))
+#define OSSL_FUNC_OPENSSL_CLEANSE             31
+OSSL_CORE_MAKE_FUNC(void,
+        OPENSSL_cleanse, (void *ptr, size_t len))
+
+/* Bio functions provided by the core */
+#define OSSL_FUNC_BIO_NEW_FILE                40
+#define OSSL_FUNC_BIO_NEW_MEMBUF              41
+#define OSSL_FUNC_BIO_READ_EX                 42
+#define OSSL_FUNC_BIO_WRITE_EX                43
+#define OSSL_FUNC_BIO_UP_REF                  44
+#define OSSL_FUNC_BIO_FREE                    45
+#define OSSL_FUNC_BIO_VPRINTF                 46
+#define OSSL_FUNC_BIO_VSNPRINTF               47
+#define OSSL_FUNC_BIO_PUTS                    48
+#define OSSL_FUNC_BIO_GETS                    49
+#define OSSL_FUNC_BIO_CTRL                    50
+
+
+OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_file, (const char *filename,
+                                                    const char *mode))
+OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_membuf, (const void *buf, int len))
+OSSL_CORE_MAKE_FUNC(int, BIO_read_ex, (OSSL_CORE_BIO *bio, void *data,
+                                       size_t data_len, size_t *bytes_read))
+OSSL_CORE_MAKE_FUNC(int, BIO_write_ex, (OSSL_CORE_BIO *bio, const void *data,
+                                        size_t data_len, size_t *written))
+OSSL_CORE_MAKE_FUNC(int, BIO_gets, (OSSL_CORE_BIO *bio, char *buf, int size))
+OSSL_CORE_MAKE_FUNC(int, BIO_puts, (OSSL_CORE_BIO *bio, const char *str))
+OSSL_CORE_MAKE_FUNC(int, BIO_up_ref, (OSSL_CORE_BIO *bio))
+OSSL_CORE_MAKE_FUNC(int, BIO_free, (OSSL_CORE_BIO *bio))
+OSSL_CORE_MAKE_FUNC(int, BIO_vprintf, (OSSL_CORE_BIO *bio, const char *format,
+                                       va_list args))
+OSSL_CORE_MAKE_FUNC(int, BIO_vsnprintf,
+                   (char *buf, size_t n, const char *fmt, va_list args))
+OSSL_CORE_MAKE_FUNC(int, BIO_ctrl, (OSSL_CORE_BIO *bio,
+                                    int cmd, long num, void *ptr))
+
+#define OSSL_FUNC_SELF_TEST_CB               100
+OSSL_CORE_MAKE_FUNC(void, self_test_cb, (OPENSSL_CORE_CTX *ctx, OSSL_CALLBACK **cb,
+                                         void **cbarg))
+
+/* Functions to get seed material from the operating system */
+#define OSSL_FUNC_GET_ENTROPY                101
+#define OSSL_FUNC_CLEANUP_ENTROPY            102
+#define OSSL_FUNC_GET_NONCE                  103
+#define OSSL_FUNC_CLEANUP_NONCE              104
+OSSL_CORE_MAKE_FUNC(size_t, get_entropy, (const OSSL_CORE_HANDLE *handle,
+                                          unsigned char **pout, int entropy,
+                                          size_t min_len, size_t max_len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_entropy, (const OSSL_CORE_HANDLE *handle,
+                                            unsigned char *buf, size_t len))
+OSSL_CORE_MAKE_FUNC(size_t, get_nonce, (const OSSL_CORE_HANDLE *handle,
+                                        unsigned char **pout, size_t min_len,
+                                        size_t max_len, const void *salt,
+                                        size_t salt_len))
+OSSL_CORE_MAKE_FUNC(void, cleanup_nonce, (const OSSL_CORE_HANDLE *handle,
+                                          unsigned char *buf, size_t len))
+
+/* Functions to access the core's providers */
+#define OSSL_FUNC_PROVIDER_REGISTER_CHILD_CB   105
+#define OSSL_FUNC_PROVIDER_DEREGISTER_CHILD_CB 106
+#define OSSL_FUNC_PROVIDER_NAME                107
+#define OSSL_FUNC_PROVIDER_GET0_PROVIDER_CTX   108
+#define OSSL_FUNC_PROVIDER_GET0_DISPATCH       109
+#define OSSL_FUNC_PROVIDER_UP_REF              110
+#define OSSL_FUNC_PROVIDER_FREE                111
+
+OSSL_CORE_MAKE_FUNC(int, provider_register_child_cb,
+                    (const OSSL_CORE_HANDLE *handle,
+                     int (*create_cb)(const OSSL_CORE_HANDLE *provider, void *cbdata),
+                     int (*remove_cb)(const OSSL_CORE_HANDLE *provider, void *cbdata),
+                     int (*global_props_cb)(const char *props, void *cbdata),
+                     void *cbdata))
+OSSL_CORE_MAKE_FUNC(void, provider_deregister_child_cb,
+                    (const OSSL_CORE_HANDLE *handle))
+OSSL_CORE_MAKE_FUNC(const char *, provider_name,
+                    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(void *, provider_get0_provider_ctx,
+                    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(const OSSL_DISPATCH *, provider_get0_dispatch,
+                    (const OSSL_CORE_HANDLE *prov))
+OSSL_CORE_MAKE_FUNC(int, provider_up_ref,
+                    (const OSSL_CORE_HANDLE *prov, int activate))
+OSSL_CORE_MAKE_FUNC(int, provider_free,
+                    (const OSSL_CORE_HANDLE *prov, int deactivate))
+
+/* Functions provided by the provider to the Core, reserved numbers 1024-1535 */
+# define OSSL_FUNC_PROVIDER_TEARDOWN           1024
+OSSL_CORE_MAKE_FUNC(void,provider_teardown,(void *provctx))
+# define OSSL_FUNC_PROVIDER_GETTABLE_PARAMS    1025
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+                    provider_gettable_params,(void *provctx))
+# define OSSL_FUNC_PROVIDER_GET_PARAMS         1026
+OSSL_CORE_MAKE_FUNC(int,provider_get_params,(void *provctx,
+                                             OSSL_PARAM params[]))
+# define OSSL_FUNC_PROVIDER_QUERY_OPERATION    1027
+OSSL_CORE_MAKE_FUNC(const OSSL_ALGORITHM *,provider_query_operation,
+                    (void *provctx, int operation_id, int *no_store))
+# define OSSL_FUNC_PROVIDER_UNQUERY_OPERATION  1028
+OSSL_CORE_MAKE_FUNC(void, provider_unquery_operation,
+                    (void *provctx, int operation_id, const OSSL_ALGORITHM *))
+# define OSSL_FUNC_PROVIDER_GET_REASON_STRINGS 1029
+OSSL_CORE_MAKE_FUNC(const OSSL_ITEM *,provider_get_reason_strings,
+                    (void *provctx))
+# define OSSL_FUNC_PROVIDER_GET_CAPABILITIES   1030
+OSSL_CORE_MAKE_FUNC(int, provider_get_capabilities, (void *provctx,
+                    const char *capability, OSSL_CALLBACK *cb, void *arg))
+# define OSSL_FUNC_PROVIDER_SELF_TEST          1031
+OSSL_CORE_MAKE_FUNC(int, provider_self_test, (void *provctx))
+
+/* Operations */
+
+# define OSSL_OP_DIGEST                              1
+# define OSSL_OP_CIPHER                              2   /* Symmetric Ciphers */
+# define OSSL_OP_MAC                                 3
+# define OSSL_OP_KDF                                 4
+# define OSSL_OP_RAND                                5
+# define OSSL_OP_KEYMGMT                            10
+# define OSSL_OP_KEYEXCH                            11
+# define OSSL_OP_SIGNATURE                          12
+# define OSSL_OP_ASYM_CIPHER                        13
+# define OSSL_OP_KEM                                14
+/* New section for non-EVP operations */
+# define OSSL_OP_ENCODER                            20
+# define OSSL_OP_DECODER                            21
+# define OSSL_OP_STORE                              22
+/* Highest known operation number */
+# define OSSL_OP__HIGHEST                           22
+
+/* Digests */
+
+# define OSSL_FUNC_DIGEST_NEWCTX                     1
+# define OSSL_FUNC_DIGEST_INIT                       2
+# define OSSL_FUNC_DIGEST_UPDATE                     3
+# define OSSL_FUNC_DIGEST_FINAL                      4
+# define OSSL_FUNC_DIGEST_DIGEST                     5
+# define OSSL_FUNC_DIGEST_FREECTX                    6
+# define OSSL_FUNC_DIGEST_DUPCTX                     7
+# define OSSL_FUNC_DIGEST_GET_PARAMS                 8
+# define OSSL_FUNC_DIGEST_SET_CTX_PARAMS             9
+# define OSSL_FUNC_DIGEST_GET_CTX_PARAMS            10
+# define OSSL_FUNC_DIGEST_GETTABLE_PARAMS           11
+# define OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS       12
+# define OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS       13
+
+OSSL_CORE_MAKE_FUNC(void *, digest_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, digest_init, (void *dctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_update,
+                    (void *dctx, const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, digest_final,
+                    (void *dctx,
+                     unsigned char *out, size_t *outl, size_t outsz))
+OSSL_CORE_MAKE_FUNC(int, digest_digest,
+                    (void *provctx, const unsigned char *in, size_t inl,
+                     unsigned char *out, size_t *outl, size_t outsz))
+
+OSSL_CORE_MAKE_FUNC(void, digest_freectx, (void *dctx))
+OSSL_CORE_MAKE_FUNC(void *, digest_dupctx, (void *dctx))
+
+OSSL_CORE_MAKE_FUNC(int, digest_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_set_ctx_params,
+                    (void *vctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, digest_get_ctx_params,
+                    (void *vctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_gettable_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_settable_ctx_params,
+                    (void *dctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_gettable_ctx_params,
+                    (void *dctx, void *provctx))
+
+/* Symmetric Ciphers */
+
+# define OSSL_FUNC_CIPHER_NEWCTX                     1
+# define OSSL_FUNC_CIPHER_ENCRYPT_INIT               2
+# define OSSL_FUNC_CIPHER_DECRYPT_INIT               3
+# define OSSL_FUNC_CIPHER_UPDATE                     4
+# define OSSL_FUNC_CIPHER_FINAL                      5
+# define OSSL_FUNC_CIPHER_CIPHER                     6
+# define OSSL_FUNC_CIPHER_FREECTX                    7
+# define OSSL_FUNC_CIPHER_DUPCTX                     8
+# define OSSL_FUNC_CIPHER_GET_PARAMS                 9
+# define OSSL_FUNC_CIPHER_GET_CTX_PARAMS            10
+# define OSSL_FUNC_CIPHER_SET_CTX_PARAMS            11
+# define OSSL_FUNC_CIPHER_GETTABLE_PARAMS           12
+# define OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS       13
+# define OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS       14
+
+OSSL_CORE_MAKE_FUNC(void *, cipher_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, cipher_encrypt_init, (void *cctx,
+                                                  const unsigned char *key,
+                                                  size_t keylen,
+                                                  const unsigned char *iv,
+                                                  size_t ivlen,
+                                                  const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_decrypt_init, (void *cctx,
+                                                  const unsigned char *key,
+                                                  size_t keylen,
+                                                  const unsigned char *iv,
+                                                  size_t ivlen,
+                                                  const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_update,
+                    (void *cctx,
+                     unsigned char *out, size_t *outl, size_t outsize,
+                     const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, cipher_final,
+                    (void *cctx,
+                     unsigned char *out, size_t *outl, size_t outsize))
+OSSL_CORE_MAKE_FUNC(int, cipher_cipher,
+                    (void *cctx,
+                     unsigned char *out, size_t *outl, size_t outsize,
+                     const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(void, cipher_freectx, (void *cctx))
+OSSL_CORE_MAKE_FUNC(void *, cipher_dupctx, (void *cctx))
+OSSL_CORE_MAKE_FUNC(int, cipher_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_get_ctx_params, (void *cctx,
+                                                    OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, cipher_set_ctx_params, (void *cctx,
+                                                    const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_gettable_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_settable_ctx_params,
+                    (void *cctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_gettable_ctx_params,
+                    (void *cctx, void *provctx))
+
+/* MACs */
+
+# define OSSL_FUNC_MAC_NEWCTX                        1
+# define OSSL_FUNC_MAC_DUPCTX                        2
+# define OSSL_FUNC_MAC_FREECTX                       3
+# define OSSL_FUNC_MAC_INIT                          4
+# define OSSL_FUNC_MAC_UPDATE                        5
+# define OSSL_FUNC_MAC_FINAL                         6
+# define OSSL_FUNC_MAC_GET_PARAMS                    7
+# define OSSL_FUNC_MAC_GET_CTX_PARAMS                8
+# define OSSL_FUNC_MAC_SET_CTX_PARAMS                9
+# define OSSL_FUNC_MAC_GETTABLE_PARAMS              10
+# define OSSL_FUNC_MAC_GETTABLE_CTX_PARAMS          11
+# define OSSL_FUNC_MAC_SETTABLE_CTX_PARAMS          12
+
+OSSL_CORE_MAKE_FUNC(void *, mac_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, mac_dupctx, (void *src))
+OSSL_CORE_MAKE_FUNC(void, mac_freectx, (void *mctx))
+OSSL_CORE_MAKE_FUNC(int, mac_init, (void *mctx, const unsigned char *key,
+                                    size_t keylen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_update,
+                    (void *mctx, const unsigned char *in, size_t inl))
+OSSL_CORE_MAKE_FUNC(int, mac_final,
+                    (void *mctx,
+                     unsigned char *out, size_t *outl, size_t outsize))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_gettable_ctx_params,
+                    (void *mctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_settable_ctx_params,
+                    (void *mctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, mac_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_get_ctx_params,
+                    (void *mctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, mac_set_ctx_params,
+                    (void *mctx, const OSSL_PARAM params[]))
+
+/* KDFs and PRFs */
+
+# define OSSL_FUNC_KDF_NEWCTX                        1
+# define OSSL_FUNC_KDF_DUPCTX                        2
+# define OSSL_FUNC_KDF_FREECTX                       3
+# define OSSL_FUNC_KDF_RESET                         4
+# define OSSL_FUNC_KDF_DERIVE                        5
+# define OSSL_FUNC_KDF_GETTABLE_PARAMS               6
+# define OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS           7
+# define OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS           8
+# define OSSL_FUNC_KDF_GET_PARAMS                    9
+# define OSSL_FUNC_KDF_GET_CTX_PARAMS               10
+# define OSSL_FUNC_KDF_SET_CTX_PARAMS               11
+
+OSSL_CORE_MAKE_FUNC(void *, kdf_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, kdf_dupctx, (void *src))
+OSSL_CORE_MAKE_FUNC(void, kdf_freectx, (void *kctx))
+OSSL_CORE_MAKE_FUNC(void, kdf_reset, (void *kctx))
+OSSL_CORE_MAKE_FUNC(int, kdf_derive, (void *kctx, unsigned char *key,
+                                      size_t keylen, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_gettable_ctx_params,
+                    (void *kctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_settable_ctx_params,
+                    (void *kctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kdf_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kdf_get_ctx_params,
+                    (void *kctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kdf_set_ctx_params,
+                    (void *kctx, const OSSL_PARAM params[]))
+
+/* RAND */
+
+# define OSSL_FUNC_RAND_NEWCTX                        1
+# define OSSL_FUNC_RAND_FREECTX                       2
+# define OSSL_FUNC_RAND_INSTANTIATE                   3
+# define OSSL_FUNC_RAND_UNINSTANTIATE                 4
+# define OSSL_FUNC_RAND_GENERATE                      5
+# define OSSL_FUNC_RAND_RESEED                        6
+# define OSSL_FUNC_RAND_NONCE                         7
+# define OSSL_FUNC_RAND_ENABLE_LOCKING                8
+# define OSSL_FUNC_RAND_LOCK                          9
+# define OSSL_FUNC_RAND_UNLOCK                       10
+# define OSSL_FUNC_RAND_GETTABLE_PARAMS              11
+# define OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS          12
+# define OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS          13
+# define OSSL_FUNC_RAND_GET_PARAMS                   14
+# define OSSL_FUNC_RAND_GET_CTX_PARAMS               15
+# define OSSL_FUNC_RAND_SET_CTX_PARAMS               16
+# define OSSL_FUNC_RAND_VERIFY_ZEROIZATION           17
+# define OSSL_FUNC_RAND_GET_SEED                     18
+# define OSSL_FUNC_RAND_CLEAR_SEED                   19
+
+OSSL_CORE_MAKE_FUNC(void *,rand_newctx,
+                    (void *provctx, void *parent,
+                    const OSSL_DISPATCH *parent_calls))
+OSSL_CORE_MAKE_FUNC(void,rand_freectx, (void *vctx))
+OSSL_CORE_MAKE_FUNC(int,rand_instantiate,
+                    (void *vdrbg, unsigned int strength,
+                     int prediction_resistance,
+                     const unsigned char *pstr, size_t pstr_len,
+                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int,rand_uninstantiate, (void *vdrbg))
+OSSL_CORE_MAKE_FUNC(int,rand_generate,
+                    (void *vctx, unsigned char *out, size_t outlen,
+                     unsigned int strength, int prediction_resistance,
+                     const unsigned char *addin, size_t addin_len))
+OSSL_CORE_MAKE_FUNC(int,rand_reseed,
+                    (void *vctx, int prediction_resistance,
+                     const unsigned char *ent, size_t ent_len,
+                     const unsigned char *addin, size_t addin_len))
+OSSL_CORE_MAKE_FUNC(size_t,rand_nonce,
+                    (void *vctx, unsigned char *out, unsigned int strength,
+                     size_t min_noncelen, size_t max_noncelen))
+OSSL_CORE_MAKE_FUNC(int,rand_enable_locking, (void *vctx))
+OSSL_CORE_MAKE_FUNC(int,rand_lock, (void *vctx))
+OSSL_CORE_MAKE_FUNC(void,rand_unlock, (void *vctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_gettable_params, (void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_gettable_ctx_params,
+                    (void *vctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_settable_ctx_params,
+                    (void *vctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int,rand_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int,rand_get_ctx_params,
+                    (void *vctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int,rand_set_ctx_params,
+                    (void *vctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(void,rand_set_callbacks,
+                    (void *vctx, OSSL_INOUT_CALLBACK *get_entropy,
+                     OSSL_CALLBACK *cleanup_entropy,
+                     OSSL_INOUT_CALLBACK *get_nonce,
+                     OSSL_CALLBACK *cleanup_nonce, void *arg))
+OSSL_CORE_MAKE_FUNC(int,rand_verify_zeroization,
+                    (void *vctx))
+OSSL_CORE_MAKE_FUNC(size_t,rand_get_seed,
+                    (void *vctx, unsigned char **buffer,
+                     int entropy, size_t min_len, size_t max_len,
+                     int prediction_resistance,
+                     const unsigned char *adin, size_t adin_len))
+OSSL_CORE_MAKE_FUNC(void,rand_clear_seed,
+                    (void *vctx, unsigned char *buffer, size_t b_len))
+
+/*-
+ * Key management
+ *
+ * The Key Management takes care of provider side key objects, and includes
+ * all current functionality to create them, destroy them, set parameters
+ * and key material, etc, essentially everything that manipulates the keys
+ * themselves and their parameters.
+ *
+ * The key objects are commonly refered to as |keydata|, and it MUST be able
+ * to contain parameters if the key has any, the public key and the private
+ * key.  All parts are optional, but their presence determines what can be
+ * done with the key object in terms of encryption, signature, and so on.
+ * The assumption from libcrypto is that the key object contains any of the
+ * following data combinations:
+ *
+ * - parameters only
+ * - public key only
+ * - public key + private key
+ * - parameters + public key
+ * - parameters + public key + private key
+ *
+ * What "parameters", "public key" and "private key" means in detail is left
+ * to the implementation.  In the case of DH and DSA, they would typically
+ * include domain parameters, while for certain variants of RSA, they would
+ * typically include PSS or OAEP parameters.
+ *
+ * Key objects are created with OSSL_FUNC_keymgmt_new() and destroyed with
+ * OSSL_FUNC_keymgmt_free().  Key objects can have data filled in with
+ * OSSL_FUNC_keymgmt_import().
+ *
+ * Three functions are made available to check what selection of data is
+ * present in a key object: OSSL_FUNC_keymgmt_has_parameters(),
+ * OSSL_FUNC_keymgmt_has_public_key(), and OSSL_FUNC_keymgmt_has_private_key(),
+ */
+
+/* Key data subset selection - individual bits */
+# define OSSL_KEYMGMT_SELECT_PRIVATE_KEY            0x01
+# define OSSL_KEYMGMT_SELECT_PUBLIC_KEY             0x02
+# define OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS      0x04
+# define OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS       0x80
+
+/* Key data subset selection - combinations */
+# define OSSL_KEYMGMT_SELECT_ALL_PARAMETERS     \
+    ( OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS     \
+      | OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS)
+# define OSSL_KEYMGMT_SELECT_KEYPAIR            \
+    ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY | OSSL_KEYMGMT_SELECT_PUBLIC_KEY )
+# define OSSL_KEYMGMT_SELECT_ALL                \
+    ( OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS )
+
+# define OSSL_KEYMGMT_VALIDATE_FULL_CHECK              0
+# define OSSL_KEYMGMT_VALIDATE_QUICK_CHECK             1
+
+/* Basic key object creation */
+# define OSSL_FUNC_KEYMGMT_NEW                         1
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_new, (void *provctx))
+
+/* Generation, a more complex constructor */
+# define OSSL_FUNC_KEYMGMT_GEN_INIT                    2
+# define OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE            3
+# define OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS              4
+# define OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS         5
+# define OSSL_FUNC_KEYMGMT_GEN                         6
+# define OSSL_FUNC_KEYMGMT_GEN_CLEANUP                 7
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_gen_init,
+                    (void *provctx, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_template,
+                    (void *genctx, void *templ))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_params,
+                    (void *genctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
+                    keymgmt_gen_settable_params,
+                    (void *genctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_gen,
+                    (void *genctx, OSSL_CALLBACK *cb, void *cbarg))
+OSSL_CORE_MAKE_FUNC(void, keymgmt_gen_cleanup, (void *genctx))
+
+/* Key loading by object reference */
+# define OSSL_FUNC_KEYMGMT_LOAD                        8
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_load,
+                    (const void *reference, size_t reference_sz))
+
+/* Basic key object destruction */
+# define OSSL_FUNC_KEYMGMT_FREE                       10
+OSSL_CORE_MAKE_FUNC(void, keymgmt_free, (void *keydata))
+
+/* Key object information, with discovery */
+#define OSSL_FUNC_KEYMGMT_GET_PARAMS                  11
+#define OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS             12
+OSSL_CORE_MAKE_FUNC(int, keymgmt_get_params,
+                    (void *keydata, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_gettable_params,
+                    (void *provctx))
+
+#define OSSL_FUNC_KEYMGMT_SET_PARAMS                  13
+#define OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS             14
+OSSL_CORE_MAKE_FUNC(int, keymgmt_set_params,
+                    (void *keydata, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_settable_params,
+                    (void *provctx))
+
+/* Key checks - discovery of supported operations */
+# define OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME       20
+OSSL_CORE_MAKE_FUNC(const char *, keymgmt_query_operation_name,
+                    (int operation_id))
+
+/* Key checks - key data content checks */
+# define OSSL_FUNC_KEYMGMT_HAS                        21
+OSSL_CORE_MAKE_FUNC(int, keymgmt_has, (const void *keydata, int selection))
+
+/* Key checks - validation */
+# define OSSL_FUNC_KEYMGMT_VALIDATE                   22
+OSSL_CORE_MAKE_FUNC(int, keymgmt_validate, (const void *keydata, int selection,
+                                            int checktype))
+
+/* Key checks - matching */
+# define OSSL_FUNC_KEYMGMT_MATCH                      23
+OSSL_CORE_MAKE_FUNC(int, keymgmt_match,
+                    (const void *keydata1, const void *keydata2,
+                     int selection))
+
+/* Import and export functions, with discovery */
+# define OSSL_FUNC_KEYMGMT_IMPORT                     40
+# define OSSL_FUNC_KEYMGMT_IMPORT_TYPES               41
+# define OSSL_FUNC_KEYMGMT_EXPORT                     42
+# define OSSL_FUNC_KEYMGMT_EXPORT_TYPES               43
+OSSL_CORE_MAKE_FUNC(int, keymgmt_import,
+                    (void *keydata, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_import_types,
+                    (int selection))
+OSSL_CORE_MAKE_FUNC(int, keymgmt_export,
+                    (void *keydata, int selection,
+                     OSSL_CALLBACK *param_cb, void *cbarg))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_export_types,
+                    (int selection))
+
+/* Dup function, constructor */
+# define OSSL_FUNC_KEYMGMT_DUP                        44
+OSSL_CORE_MAKE_FUNC(void *, keymgmt_dup,
+                    (const void *keydata_from, int selection))
+
+/* Key Exchange */
+
+# define OSSL_FUNC_KEYEXCH_NEWCTX                      1
+# define OSSL_FUNC_KEYEXCH_INIT                        2
+# define OSSL_FUNC_KEYEXCH_DERIVE                      3
+# define OSSL_FUNC_KEYEXCH_SET_PEER                    4
+# define OSSL_FUNC_KEYEXCH_FREECTX                     5
+# define OSSL_FUNC_KEYEXCH_DUPCTX                      6
+# define OSSL_FUNC_KEYEXCH_SET_CTX_PARAMS              7
+# define OSSL_FUNC_KEYEXCH_SETTABLE_CTX_PARAMS         8
+# define OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS              9
+# define OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS        10
+
+OSSL_CORE_MAKE_FUNC(void *, keyexch_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_init, (void *ctx, void *provkey,
+                                        const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, keyexch_derive, (void *ctx,  unsigned char *secret,
+                                             size_t *secretlen, size_t outlen))
+OSSL_CORE_MAKE_FUNC(int, keyexch_set_peer, (void *ctx, void *provkey))
+OSSL_CORE_MAKE_FUNC(void, keyexch_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, keyexch_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_set_ctx_params, (void *ctx,
+                                                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keyexch_settable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, keyexch_get_ctx_params, (void *ctx,
+                                                     OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keyexch_gettable_ctx_params,
+                    (void *ctx, void *provctx))
+
+/* Signature */
+
+# define OSSL_FUNC_SIGNATURE_NEWCTX                  1
+# define OSSL_FUNC_SIGNATURE_SIGN_INIT               2
+# define OSSL_FUNC_SIGNATURE_SIGN                    3
+# define OSSL_FUNC_SIGNATURE_VERIFY_INIT             4
+# define OSSL_FUNC_SIGNATURE_VERIFY                  5
+# define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT     6
+# define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER          7
+# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT        8
+# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE      9
+# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL      10
+# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN            11
+# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT     12
+# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE   13
+# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL    14
+# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY          15
+# define OSSL_FUNC_SIGNATURE_FREECTX                16
+# define OSSL_FUNC_SIGNATURE_DUPCTX                 17
+# define OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS         18
+# define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS    19
+# define OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS         20
+# define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS    21
+# define OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS      22
+# define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS 23
+# define OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS      24
+# define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS 25
+
+OSSL_CORE_MAKE_FUNC(void *, signature_newctx, (void *provctx,
+                                                  const char *propq))
+OSSL_CORE_MAKE_FUNC(int, signature_sign_init, (void *ctx, void *provkey,
+                                               const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_sign, (void *ctx,  unsigned char *sig,
+                                             size_t *siglen, size_t sigsize,
+                                             const unsigned char *tbs,
+                                             size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_init, (void *ctx, void *provkey,
+                                                 const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_verify, (void *ctx,
+                                               const unsigned char *sig,
+                                               size_t siglen,
+                                               const unsigned char *tbs,
+                                               size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_recover_init,
+                    (void *ctx, void *provkey, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_verify_recover,
+                    (void *ctx, unsigned char *rout, size_t *routlen,
+                     size_t routsize, const unsigned char *sig, size_t siglen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_init,
+                    (void *ctx, const char *mdname, void *provkey,
+                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_update,
+                    (void *ctx, const unsigned char *data, size_t datalen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_final,
+                    (void *ctx, unsigned char *sig, size_t *siglen,
+                     size_t sigsize))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_sign,
+                    (void *ctx, unsigned char *sigret, size_t *siglen,
+                     size_t sigsize, const unsigned char *tbs, size_t tbslen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_init,
+                    (void *ctx, const char *mdname, void *provkey,
+                     const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_update,
+                    (void *ctx, const unsigned char *data, size_t datalen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_final,
+                    (void *ctx, const unsigned char *sig, size_t siglen))
+OSSL_CORE_MAKE_FUNC(int, signature_digest_verify,
+                    (void *ctx, const unsigned char *sig, size_t siglen,
+                     const unsigned char *tbs, size_t tbslen))
+OSSL_CORE_MAKE_FUNC(void, signature_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, signature_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_params,
+                    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_gettable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_settable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_md_params,
+                    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_gettable_ctx_md_params,
+                    (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_md_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_settable_ctx_md_params,
+                    (void *ctx))
+
+
+/* Asymmetric Ciphers */
+
+# define OSSL_FUNC_ASYM_CIPHER_NEWCTX                  1
+# define OSSL_FUNC_ASYM_CIPHER_ENCRYPT_INIT            2
+# define OSSL_FUNC_ASYM_CIPHER_ENCRYPT                 3
+# define OSSL_FUNC_ASYM_CIPHER_DECRYPT_INIT            4
+# define OSSL_FUNC_ASYM_CIPHER_DECRYPT                 5
+# define OSSL_FUNC_ASYM_CIPHER_FREECTX                 6
+# define OSSL_FUNC_ASYM_CIPHER_DUPCTX                  7
+# define OSSL_FUNC_ASYM_CIPHER_GET_CTX_PARAMS          8
+# define OSSL_FUNC_ASYM_CIPHER_GETTABLE_CTX_PARAMS     9
+# define OSSL_FUNC_ASYM_CIPHER_SET_CTX_PARAMS         10
+# define OSSL_FUNC_ASYM_CIPHER_SETTABLE_CTX_PARAMS    11
+
+OSSL_CORE_MAKE_FUNC(void *, asym_cipher_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt_init, (void *ctx, void *provkey,
+                                                    const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt, (void *ctx, unsigned char *out,
+                                                  size_t *outlen,
+                                                  size_t outsize,
+                                                  const unsigned char *in,
+                                                  size_t inlen))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt_init, (void *ctx, void *provkey,
+                                                    const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt, (void *ctx, unsigned char *out,
+                                                  size_t *outlen,
+                                                  size_t outsize,
+                                                  const unsigned char *in,
+                                                  size_t inlen))
+OSSL_CORE_MAKE_FUNC(void, asym_cipher_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, asym_cipher_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_get_ctx_params,
+                    (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, asym_cipher_gettable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, asym_cipher_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, asym_cipher_settable_ctx_params,
+                    (void *ctx, void *provctx))
+
+/* Asymmetric Key encapsulation */
+# define OSSL_FUNC_KEM_NEWCTX                  1
+# define OSSL_FUNC_KEM_ENCAPSULATE_INIT        2
+# define OSSL_FUNC_KEM_ENCAPSULATE             3
+# define OSSL_FUNC_KEM_DECAPSULATE_INIT        4
+# define OSSL_FUNC_KEM_DECAPSULATE             5
+# define OSSL_FUNC_KEM_FREECTX                 6
+# define OSSL_FUNC_KEM_DUPCTX                  7
+# define OSSL_FUNC_KEM_GET_CTX_PARAMS          8
+# define OSSL_FUNC_KEM_GETTABLE_CTX_PARAMS     9
+# define OSSL_FUNC_KEM_SET_CTX_PARAMS         10
+# define OSSL_FUNC_KEM_SETTABLE_CTX_PARAMS    11
+
+OSSL_CORE_MAKE_FUNC(void *, kem_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kem_encapsulate_init, (void *ctx, void *provkey,
+                                                const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_encapsulate, (void *ctx,
+                                           unsigned char *out, size_t *outlen,
+                                           unsigned char *secret,
+                                           size_t *secretlen))
+OSSL_CORE_MAKE_FUNC(int, kem_decapsulate_init, (void *ctx, void *provkey,
+                                                const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, kem_decapsulate, (void *ctx,
+                                           unsigned char *out, size_t *outlen,
+                                           const unsigned char *in, size_t inlen))
+OSSL_CORE_MAKE_FUNC(void, kem_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(void *, kem_dupctx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, kem_get_ctx_params, (void *ctx, OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kem_gettable_ctx_params,
+                    (void *ctx, void *provctx))
+OSSL_CORE_MAKE_FUNC(int, kem_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kem_settable_ctx_params,
+                    (void *ctx, void *provctx))
+
+/* Encoders and decoders */
+# define OSSL_FUNC_ENCODER_NEWCTX                      1
+# define OSSL_FUNC_ENCODER_FREECTX                     2
+# define OSSL_FUNC_ENCODER_GET_PARAMS                  3
+# define OSSL_FUNC_ENCODER_GETTABLE_PARAMS             4
+# define OSSL_FUNC_ENCODER_SET_CTX_PARAMS              5
+# define OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS         6
+# define OSSL_FUNC_ENCODER_DOES_SELECTION             10
+# define OSSL_FUNC_ENCODER_ENCODE                     11
+# define OSSL_FUNC_ENCODER_IMPORT_OBJECT              20
+# define OSSL_FUNC_ENCODER_FREE_OBJECT                21
+OSSL_CORE_MAKE_FUNC(void *, encoder_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void, encoder_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, encoder_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, encoder_gettable_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, encoder_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, encoder_settable_ctx_params,
+                    (void *provctx))
+
+OSSL_CORE_MAKE_FUNC(int, encoder_does_selection,
+                    (void *provctx, int selection))
+OSSL_CORE_MAKE_FUNC(int, encoder_encode,
+                    (void *ctx, OSSL_CORE_BIO *out,
+                     const void *obj_raw, const OSSL_PARAM obj_abstract[],
+                     int selection,
+                     OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg))
+
+OSSL_CORE_MAKE_FUNC(void *, encoder_import_object,
+                    (void *ctx, int selection, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(void, encoder_free_object, (void *obj))
+
+# define OSSL_FUNC_DECODER_NEWCTX                      1
+# define OSSL_FUNC_DECODER_FREECTX                     2
+# define OSSL_FUNC_DECODER_GET_PARAMS                  3
+# define OSSL_FUNC_DECODER_GETTABLE_PARAMS             4
+# define OSSL_FUNC_DECODER_SET_CTX_PARAMS              5
+# define OSSL_FUNC_DECODER_SETTABLE_CTX_PARAMS         6
+# define OSSL_FUNC_DECODER_DOES_SELECTION             10
+# define OSSL_FUNC_DECODER_DECODE                     11
+# define OSSL_FUNC_DECODER_EXPORT_OBJECT              20
+OSSL_CORE_MAKE_FUNC(void *, decoder_newctx, (void *provctx))
+OSSL_CORE_MAKE_FUNC(void, decoder_freectx, (void *ctx))
+OSSL_CORE_MAKE_FUNC(int, decoder_get_params, (OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, decoder_gettable_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, decoder_set_ctx_params,
+                    (void *ctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, decoder_settable_ctx_params,
+                    (void *provctx))
+
+OSSL_CORE_MAKE_FUNC(int, decoder_does_selection,
+                    (void *provctx, int selection))
+OSSL_CORE_MAKE_FUNC(int, decoder_decode,
+                    (void *ctx, OSSL_CORE_BIO *in, int selection,
+                     OSSL_CALLBACK *data_cb, void *data_cbarg,
+                     OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+OSSL_CORE_MAKE_FUNC(int, decoder_export_object,
+                    (void *ctx, const void *objref, size_t objref_sz,
+                     OSSL_CALLBACK *export_cb, void *export_cbarg))
+
+/*-
+ * Store
+ *
+ * Objects are scanned by using the 'open', 'load', 'eof' and 'close'
+ * functions, which implement an OSSL_STORE loader.
+ *
+ * store_load() works in a way that's very similar to the decoders, in
+ * that they pass an abstract object through a callback, either as a DER
+ * octet string or as an object reference, which libcrypto will have to
+ * deal with.
+ */
+
+#define OSSL_FUNC_STORE_OPEN                        1
+#define OSSL_FUNC_STORE_ATTACH                      2
+#define OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS         3
+#define OSSL_FUNC_STORE_SET_CTX_PARAMS              4
+#define OSSL_FUNC_STORE_LOAD                        5
+#define OSSL_FUNC_STORE_EOF                         6
+#define OSSL_FUNC_STORE_CLOSE                       7
+#define OSSL_FUNC_STORE_EXPORT_OBJECT               8
+OSSL_CORE_MAKE_FUNC(void *, store_open, (void *provctx, const char *uri))
+OSSL_CORE_MAKE_FUNC(void *, store_attach, (void *provctx, OSSL_CORE_BIO *in))
+OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, store_settable_ctx_params,
+                    (void *provctx))
+OSSL_CORE_MAKE_FUNC(int, store_set_ctx_params,
+                    (void *loaderctx, const OSSL_PARAM params[]))
+OSSL_CORE_MAKE_FUNC(int, store_load,
+                    (void *loaderctx,
+                     OSSL_CALLBACK *object_cb, void *object_cbarg,
+                     OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
+OSSL_CORE_MAKE_FUNC(int, store_eof, (void *loaderctx))
+OSSL_CORE_MAKE_FUNC(int, store_close, (void *loaderctx))
+OSSL_CORE_MAKE_FUNC(int, store_export_object,
+                    (void *loaderctx, const void *objref, size_t objref_sz,
+                     OSSL_CALLBACK *export_cb, void *export_cbarg))
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/core_names.h b/CAPI/cpp/grpc/include/openssl/core_names.h
new file mode 100644
index 0000000..6bed5a8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/core_names.h
@@ -0,0 +1,556 @@
+/*
+ * Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_NAMES_H
+# define OPENSSL_CORE_NAMES_H
+# pragma once
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* Well known parameter names that core passes to providers */
+#define OSSL_PROV_PARAM_CORE_VERSION         "openssl-version" /* utf8_ptr */
+#define OSSL_PROV_PARAM_CORE_PROV_NAME       "provider-name"   /* utf8_ptr */
+#define OSSL_PROV_PARAM_CORE_MODULE_FILENAME "module-filename" /* utf8_ptr */
+
+/* Well known parameter names that Providers can define */
+#define OSSL_PROV_PARAM_NAME            "name"                /* utf8_ptr */
+#define OSSL_PROV_PARAM_VERSION         "version"             /* utf8_ptr */
+#define OSSL_PROV_PARAM_BUILDINFO       "buildinfo"           /* utf8_ptr */
+#define OSSL_PROV_PARAM_STATUS          "status"              /* uint */
+#define OSSL_PROV_PARAM_SECURITY_CHECKS "security-checks"     /* uint */
+
+/* Self test callback parameters */
+#define OSSL_PROV_PARAM_SELF_TEST_PHASE  "st-phase" /* utf8_string */
+#define OSSL_PROV_PARAM_SELF_TEST_TYPE   "st-type"  /* utf8_string */
+#define OSSL_PROV_PARAM_SELF_TEST_DESC   "st-desc"  /* utf8_string */
+
+/*-
+ * Provider-native object abstractions
+ *
+ * These are used when a provider wants to pass object data or an object
+ * reference back to libcrypto.  This is only useful for provider functions
+ * that take a callback to which an OSSL_PARAM array with these parameters
+ * can be passed.
+ *
+ * This set of parameter names is explained in detail in provider-object(7)
+ * (doc/man7/provider-object.pod)
+ */
+#define OSSL_OBJECT_PARAM_TYPE              "type"      /* INTEGER */
+#define OSSL_OBJECT_PARAM_DATA_TYPE         "data-type" /* UTF8_STRING */
+#define OSSL_OBJECT_PARAM_DATA_STRUCTURE    "data-structure" /* UTF8_STRING */
+#define OSSL_OBJECT_PARAM_REFERENCE         "reference" /* OCTET_STRING */
+#define OSSL_OBJECT_PARAM_DATA              "data" /* OCTET_STRING or UTF8_STRING */
+#define OSSL_OBJECT_PARAM_DESC              "desc"      /* UTF8_STRING */
+
+/*
+ * Algorithm parameters
+ * If "engine" or "properties" are specified, they should always be paired
+ * with the algorithm type.
+ * Note these are common names that are shared by many types (such as kdf, mac,
+ * and pkey) e.g: see OSSL_MAC_PARAM_DIGEST below.
+ */
+#define OSSL_ALG_PARAM_DIGEST       "digest"    /* utf8_string */
+#define OSSL_ALG_PARAM_CIPHER       "cipher"    /* utf8_string */
+#define OSSL_ALG_PARAM_ENGINE       "engine"    /* utf8_string */
+#define OSSL_ALG_PARAM_MAC          "mac"       /* utf8_string */
+#define OSSL_ALG_PARAM_PROPERTIES   "properties"/* utf8_string */
+
+/* cipher parameters */
+#define OSSL_CIPHER_PARAM_PADDING              "padding"      /* uint */
+#define OSSL_CIPHER_PARAM_USE_BITS             "use-bits"     /* uint */
+#define OSSL_CIPHER_PARAM_TLS_VERSION          "tls-version"  /* uint */
+#define OSSL_CIPHER_PARAM_TLS_MAC              "tls-mac"      /* octet_ptr */
+#define OSSL_CIPHER_PARAM_TLS_MAC_SIZE         "tls-mac-size" /* size_t */
+#define OSSL_CIPHER_PARAM_MODE                 "mode"         /* uint */
+#define OSSL_CIPHER_PARAM_BLOCK_SIZE           "blocksize"    /* size_t */
+#define OSSL_CIPHER_PARAM_AEAD                 "aead"         /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_CUSTOM_IV            "custom-iv"    /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_CTS                  "cts"          /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK      "tls-multi"    /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_HAS_RAND_KEY         "has-randkey"  /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_KEYLEN               "keylen"       /* size_t */
+#define OSSL_CIPHER_PARAM_IVLEN                "ivlen"        /* size_t */
+#define OSSL_CIPHER_PARAM_IV                   "iv"           /* octet_string OR octet_ptr */
+#define OSSL_CIPHER_PARAM_UPDATED_IV           "updated-iv"   /* octet_string OR octet_ptr */
+#define OSSL_CIPHER_PARAM_NUM                  "num"          /* uint */
+#define OSSL_CIPHER_PARAM_ROUNDS               "rounds"       /* uint */
+#define OSSL_CIPHER_PARAM_AEAD_TAG             "tag"          /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD        "tlsaad"       /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD    "tlsaadpad"    /* size_t */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED   "tlsivfixed"   /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN "tlsivgen"     /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV "tlsivinv"     /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_IVLEN           OSSL_CIPHER_PARAM_IVLEN
+#define OSSL_CIPHER_PARAM_AEAD_TAGLEN          "taglen"       /* size_t */
+#define OSSL_CIPHER_PARAM_AEAD_MAC_KEY         "mackey"       /* octet_string */
+#define OSSL_CIPHER_PARAM_RANDOM_KEY           "randkey"      /* octet_string */
+#define OSSL_CIPHER_PARAM_RC2_KEYBITS          "keybits"      /* size_t */
+#define OSSL_CIPHER_PARAM_SPEED                "speed"        /* uint */
+#define OSSL_CIPHER_PARAM_CTS_MODE             "cts_mode"     /* utf8_string */
+/* For passing the AlgorithmIdentifier parameter in DER form */
+#define OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS  "alg_id_param" /* octet_string */
+
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT                    \
+    "tls1multi_maxsndfrag" /* uint */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE                          \
+    "tls1multi_maxbufsz"   /* size_t */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE                           \
+    "tls1multi_interleave" /* uint */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD                                  \
+    "tls1multi_aad"        /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN                          \
+    "tls1multi_aadpacklen" /* uint */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC                                  \
+    "tls1multi_enc"        /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN                               \
+    "tls1multi_encin"      /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN                              \
+    "tls1multi_enclen"     /* size_t */
+
+/* OSSL_CIPHER_PARAM_CTS_MODE Values */
+#define OSSL_CIPHER_CTS_MODE_CS1 "CS1"
+#define OSSL_CIPHER_CTS_MODE_CS2 "CS2"
+#define OSSL_CIPHER_CTS_MODE_CS3 "CS3"
+
+/* digest parameters */
+#define OSSL_DIGEST_PARAM_XOFLEN       "xoflen"        /* size_t */
+#define OSSL_DIGEST_PARAM_SSL3_MS      "ssl3-ms"       /* octet string */
+#define OSSL_DIGEST_PARAM_PAD_TYPE     "pad-type"      /* uint */
+#define OSSL_DIGEST_PARAM_MICALG       "micalg"        /* utf8 string */
+#define OSSL_DIGEST_PARAM_BLOCK_SIZE   "blocksize"     /* size_t */
+#define OSSL_DIGEST_PARAM_SIZE         "size"          /* size_t */
+#define OSSL_DIGEST_PARAM_XOF          "xof"           /* int, 0 or 1 */
+#define OSSL_DIGEST_PARAM_ALGID_ABSENT "algid-absent"  /* int, 0 or 1 */
+
+/* Known DIGEST names (not a complete list) */
+#define OSSL_DIGEST_NAME_MD5            "MD5"
+#define OSSL_DIGEST_NAME_MD5_SHA1       "MD5-SHA1"
+#define OSSL_DIGEST_NAME_SHA1           "SHA1"
+#define OSSL_DIGEST_NAME_SHA2_224       "SHA2-224"
+#define OSSL_DIGEST_NAME_SHA2_256       "SHA2-256"
+#define OSSL_DIGEST_NAME_SHA2_384       "SHA2-384"
+#define OSSL_DIGEST_NAME_SHA2_512       "SHA2-512"
+#define OSSL_DIGEST_NAME_SHA2_512_224   "SHA2-512/224"
+#define OSSL_DIGEST_NAME_SHA2_512_256   "SHA2-512/256"
+#define OSSL_DIGEST_NAME_MD2            "MD2"
+#define OSSL_DIGEST_NAME_MD4            "MD4"
+#define OSSL_DIGEST_NAME_MDC2           "MDC2"
+#define OSSL_DIGEST_NAME_RIPEMD160      "RIPEMD160"
+#define OSSL_DIGEST_NAME_SHA3_224       "SHA3-224"
+#define OSSL_DIGEST_NAME_SHA3_256       "SHA3-256"
+#define OSSL_DIGEST_NAME_SHA3_384       "SHA3-384"
+#define OSSL_DIGEST_NAME_SHA3_512       "SHA3-512"
+#define OSSL_DIGEST_NAME_KECCAK_KMAC128 "KECCAK-KMAC-128"
+#define OSSL_DIGEST_NAME_KECCAK_KMAC256 "KECCAK-KMAC-256"
+#define OSSL_DIGEST_NAME_SM3            "SM3"
+
+/* MAC parameters */
+#define OSSL_MAC_PARAM_KEY            "key"            /* octet string */
+#define OSSL_MAC_PARAM_IV             "iv"             /* octet string */
+#define OSSL_MAC_PARAM_CUSTOM         "custom"         /* utf8 string */
+#define OSSL_MAC_PARAM_SALT           "salt"           /* octet string */
+#define OSSL_MAC_PARAM_XOF            "xof"            /* int, 0 or 1 */
+#define OSSL_MAC_PARAM_DIGEST_NOINIT  "digest-noinit"  /* int, 0 or 1 */
+#define OSSL_MAC_PARAM_DIGEST_ONESHOT "digest-oneshot" /* int, 0 or 1 */
+#define OSSL_MAC_PARAM_C_ROUNDS       "c-rounds"       /* unsigned int */
+#define OSSL_MAC_PARAM_D_ROUNDS       "d-rounds"       /* unsigned int */
+
+/*
+ * If "engine" or "properties" are specified, they should always be paired
+ * with "cipher" or "digest".
+ */
+#define OSSL_MAC_PARAM_CIPHER           OSSL_ALG_PARAM_CIPHER     /* utf8 string */
+#define OSSL_MAC_PARAM_DIGEST           OSSL_ALG_PARAM_DIGEST     /* utf8 string */
+#define OSSL_MAC_PARAM_PROPERTIES       OSSL_ALG_PARAM_PROPERTIES /* utf8 string */
+#define OSSL_MAC_PARAM_SIZE             "size"                    /* size_t */
+#define OSSL_MAC_PARAM_BLOCK_SIZE       "block-size"              /* size_t */
+#define OSSL_MAC_PARAM_TLS_DATA_SIZE    "tls-data-size"           /* size_t */
+
+/* Known MAC names */
+#define OSSL_MAC_NAME_BLAKE2BMAC    "BLAKE2BMAC"
+#define OSSL_MAC_NAME_BLAKE2SMAC    "BLAKE2SMAC"
+#define OSSL_MAC_NAME_CMAC          "CMAC"
+#define OSSL_MAC_NAME_GMAC          "GMAC"
+#define OSSL_MAC_NAME_HMAC          "HMAC"
+#define OSSL_MAC_NAME_KMAC128       "KMAC128"
+#define OSSL_MAC_NAME_KMAC256       "KMAC256"
+#define OSSL_MAC_NAME_POLY1305      "POLY1305"
+#define OSSL_MAC_NAME_SIPHASH       "SIPHASH"
+
+/* KDF / PRF parameters */
+#define OSSL_KDF_PARAM_SECRET       "secret"    /* octet string */
+#define OSSL_KDF_PARAM_KEY          "key"       /* octet string */
+#define OSSL_KDF_PARAM_SALT         "salt"      /* octet string */
+#define OSSL_KDF_PARAM_PASSWORD     "pass"      /* octet string */
+#define OSSL_KDF_PARAM_PREFIX       "prefix"    /* octet string */
+#define OSSL_KDF_PARAM_LABEL        "label"     /* octet string */
+#define OSSL_KDF_PARAM_DATA         "data"      /* octet string */
+#define OSSL_KDF_PARAM_DIGEST       OSSL_ALG_PARAM_DIGEST     /* utf8 string */
+#define OSSL_KDF_PARAM_CIPHER       OSSL_ALG_PARAM_CIPHER     /* utf8 string */
+#define OSSL_KDF_PARAM_MAC          OSSL_ALG_PARAM_MAC        /* utf8 string */
+#define OSSL_KDF_PARAM_MAC_SIZE     "maclen"    /* size_t */
+#define OSSL_KDF_PARAM_PROPERTIES   OSSL_ALG_PARAM_PROPERTIES /* utf8 string */
+#define OSSL_KDF_PARAM_ITER         "iter"      /* unsigned int */
+#define OSSL_KDF_PARAM_MODE         "mode"      /* utf8 string or int */
+#define OSSL_KDF_PARAM_PKCS5        "pkcs5"     /* int */
+#define OSSL_KDF_PARAM_UKM          "ukm"       /* octet string */
+#define OSSL_KDF_PARAM_CEK_ALG      "cekalg"    /* utf8 string */
+#define OSSL_KDF_PARAM_SCRYPT_N     "n"         /* uint64_t */
+#define OSSL_KDF_PARAM_SCRYPT_R     "r"         /* uint32_t */
+#define OSSL_KDF_PARAM_SCRYPT_P     "p"         /* uint32_t */
+#define OSSL_KDF_PARAM_SCRYPT_MAXMEM "maxmem_bytes" /* uint64_t */
+#define OSSL_KDF_PARAM_INFO         "info"      /* octet string */
+#define OSSL_KDF_PARAM_SEED         "seed"      /* octet string */
+#define OSSL_KDF_PARAM_SSHKDF_XCGHASH "xcghash" /* octet string */
+#define OSSL_KDF_PARAM_SSHKDF_SESSION_ID "session_id" /* octet string */
+#define OSSL_KDF_PARAM_SSHKDF_TYPE  "type"      /* int */
+#define OSSL_KDF_PARAM_SIZE         "size"      /* size_t */
+#define OSSL_KDF_PARAM_CONSTANT     "constant"  /* octet string */
+#define OSSL_KDF_PARAM_PKCS12_ID    "id"        /* int */
+#define OSSL_KDF_PARAM_KBKDF_USE_L  "use-l"             /* int */
+#define OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR  "use-separator"     /* int */
+#define OSSL_KDF_PARAM_X942_ACVPINFO        "acvp-info"
+#define OSSL_KDF_PARAM_X942_PARTYUINFO      "partyu-info"
+#define OSSL_KDF_PARAM_X942_PARTYVINFO      "partyv-info"
+#define OSSL_KDF_PARAM_X942_SUPP_PUBINFO    "supp-pubinfo"
+#define OSSL_KDF_PARAM_X942_SUPP_PRIVINFO   "supp-privinfo"
+#define OSSL_KDF_PARAM_X942_USE_KEYBITS     "use-keybits"
+
+/* Known KDF names */
+#define OSSL_KDF_NAME_HKDF           "HKDF"
+#define OSSL_KDF_NAME_TLS1_3_KDF     "TLS13-KDF"
+#define OSSL_KDF_NAME_PBKDF1         "PBKDF1"
+#define OSSL_KDF_NAME_PBKDF2         "PBKDF2"
+#define OSSL_KDF_NAME_SCRYPT         "SCRYPT"
+#define OSSL_KDF_NAME_SSHKDF         "SSHKDF"
+#define OSSL_KDF_NAME_SSKDF          "SSKDF"
+#define OSSL_KDF_NAME_TLS1_PRF       "TLS1-PRF"
+#define OSSL_KDF_NAME_X942KDF_ASN1   "X942KDF-ASN1"
+#define OSSL_KDF_NAME_X942KDF_CONCAT "X942KDF-CONCAT"
+#define OSSL_KDF_NAME_X963KDF        "X963KDF"
+#define OSSL_KDF_NAME_KBKDF          "KBKDF"
+#define OSSL_KDF_NAME_KRB5KDF        "KRB5KDF"
+
+/* Known RAND names */
+#define OSSL_RAND_PARAM_STATE                   "state"
+#define OSSL_RAND_PARAM_STRENGTH                "strength"
+#define OSSL_RAND_PARAM_MAX_REQUEST             "max_request"
+#define OSSL_RAND_PARAM_TEST_ENTROPY            "test_entropy"
+#define OSSL_RAND_PARAM_TEST_NONCE              "test_nonce"
+
+/* RAND/DRBG names */
+#define OSSL_DRBG_PARAM_RESEED_REQUESTS         "reseed_requests"
+#define OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL    "reseed_time_interval"
+#define OSSL_DRBG_PARAM_MIN_ENTROPYLEN          "min_entropylen"
+#define OSSL_DRBG_PARAM_MAX_ENTROPYLEN          "max_entropylen"
+#define OSSL_DRBG_PARAM_MIN_NONCELEN            "min_noncelen"
+#define OSSL_DRBG_PARAM_MAX_NONCELEN            "max_noncelen"
+#define OSSL_DRBG_PARAM_MAX_PERSLEN             "max_perslen"
+#define OSSL_DRBG_PARAM_MAX_ADINLEN             "max_adinlen"
+#define OSSL_DRBG_PARAM_RESEED_COUNTER          "reseed_counter"
+#define OSSL_DRBG_PARAM_RESEED_TIME             "reseed_time"
+#define OSSL_DRBG_PARAM_PROPERTIES              OSSL_ALG_PARAM_PROPERTIES
+#define OSSL_DRBG_PARAM_DIGEST                  OSSL_ALG_PARAM_DIGEST
+#define OSSL_DRBG_PARAM_CIPHER                  OSSL_ALG_PARAM_CIPHER
+#define OSSL_DRBG_PARAM_MAC                     OSSL_ALG_PARAM_MAC
+#define OSSL_DRBG_PARAM_USE_DF                  "use_derivation_function"
+
+/* DRBG call back parameters */
+#define OSSL_DRBG_PARAM_ENTROPY_REQUIRED        "entropy_required"
+#define OSSL_DRBG_PARAM_PREDICTION_RESISTANCE   "prediction_resistance"
+#define OSSL_DRBG_PARAM_MIN_LENGTH              "minium_length"
+#define OSSL_DRBG_PARAM_MAX_LENGTH              "maxium_length"
+#define OSSL_DRBG_PARAM_RANDOM_DATA             "random_data"
+#define OSSL_DRBG_PARAM_SIZE                    "size"
+
+/* PKEY parameters */
+/* Common PKEY parameters */
+#define OSSL_PKEY_PARAM_BITS                "bits" /* integer */
+#define OSSL_PKEY_PARAM_MAX_SIZE            "max-size" /* integer */
+#define OSSL_PKEY_PARAM_SECURITY_BITS       "security-bits" /* integer */
+#define OSSL_PKEY_PARAM_DIGEST              OSSL_ALG_PARAM_DIGEST
+#define OSSL_PKEY_PARAM_CIPHER              OSSL_ALG_PARAM_CIPHER /* utf8 string */
+#define OSSL_PKEY_PARAM_ENGINE              OSSL_ALG_PARAM_ENGINE /* utf8 string */
+#define OSSL_PKEY_PARAM_PROPERTIES          OSSL_ALG_PARAM_PROPERTIES
+#define OSSL_PKEY_PARAM_DEFAULT_DIGEST      "default-digest" /* utf8 string */
+#define OSSL_PKEY_PARAM_MANDATORY_DIGEST    "mandatory-digest" /* utf8 string */
+#define OSSL_PKEY_PARAM_PAD_MODE            "pad-mode"
+#define OSSL_PKEY_PARAM_DIGEST_SIZE         "digest-size"
+#define OSSL_PKEY_PARAM_MASKGENFUNC         "mgf"
+#define OSSL_PKEY_PARAM_MGF1_DIGEST         "mgf1-digest"
+#define OSSL_PKEY_PARAM_MGF1_PROPERTIES     "mgf1-properties"
+#define OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY  "encoded-pub-key"
+#define OSSL_PKEY_PARAM_GROUP_NAME          "group"
+#define OSSL_PKEY_PARAM_DIST_ID             "distid"
+#define OSSL_PKEY_PARAM_PUB_KEY             "pub"
+#define OSSL_PKEY_PARAM_PRIV_KEY            "priv"
+
+/* Diffie-Hellman/DSA Parameters */
+#define OSSL_PKEY_PARAM_FFC_P               "p"
+#define OSSL_PKEY_PARAM_FFC_G               "g"
+#define OSSL_PKEY_PARAM_FFC_Q               "q"
+#define OSSL_PKEY_PARAM_FFC_GINDEX          "gindex"
+#define OSSL_PKEY_PARAM_FFC_PCOUNTER        "pcounter"
+#define OSSL_PKEY_PARAM_FFC_SEED            "seed"
+#define OSSL_PKEY_PARAM_FFC_COFACTOR        "j"
+#define OSSL_PKEY_PARAM_FFC_H               "hindex"
+#define OSSL_PKEY_PARAM_FFC_VALIDATE_PQ     "validate-pq"
+#define OSSL_PKEY_PARAM_FFC_VALIDATE_G      "validate-g"
+#define OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY "validate-legacy"
+
+/* Diffie-Hellman params */
+#define OSSL_PKEY_PARAM_DH_GENERATOR        "safeprime-generator"
+#define OSSL_PKEY_PARAM_DH_PRIV_LEN         "priv_len"
+
+/* Elliptic Curve Domain Parameters */
+#define OSSL_PKEY_PARAM_EC_PUB_X     "qx"
+#define OSSL_PKEY_PARAM_EC_PUB_Y     "qy"
+
+/* Elliptic Curve Explicit Domain Parameters */
+#define OSSL_PKEY_PARAM_EC_FIELD_TYPE                   "field-type"
+#define OSSL_PKEY_PARAM_EC_P                            "p"
+#define OSSL_PKEY_PARAM_EC_A                            "a"
+#define OSSL_PKEY_PARAM_EC_B                            "b"
+#define OSSL_PKEY_PARAM_EC_GENERATOR                    "generator"
+#define OSSL_PKEY_PARAM_EC_ORDER                        "order"
+#define OSSL_PKEY_PARAM_EC_COFACTOR                     "cofactor"
+#define OSSL_PKEY_PARAM_EC_SEED                         "seed"
+#define OSSL_PKEY_PARAM_EC_CHAR2_M                      "m"
+#define OSSL_PKEY_PARAM_EC_CHAR2_TYPE                   "basis-type"
+#define OSSL_PKEY_PARAM_EC_CHAR2_TP_BASIS               "tp"
+#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K1                  "k1"
+#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K2                  "k2"
+#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K3                  "k3"
+#define OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS "decoded-from-explicit"
+
+/* Elliptic Curve Key Parameters */
+#define OSSL_PKEY_PARAM_USE_COFACTOR_FLAG "use-cofactor-flag"
+#define OSSL_PKEY_PARAM_USE_COFACTOR_ECDH \
+    OSSL_PKEY_PARAM_USE_COFACTOR_FLAG
+
+/* RSA Keys */
+/*
+ * n, e, d are the usual public and private key components
+ *
+ * rsa-num is the number of factors, including p and q
+ * rsa-factor is used for each factor: p, q, r_i (i = 3, ...)
+ * rsa-exponent is used for each exponent: dP, dQ, d_i (i = 3, ...)
+ * rsa-coefficient is used for each coefficient: qInv, t_i (i = 3, ...)
+ *
+ * The number of rsa-factor items must be equal to the number of rsa-exponent
+ * items, and the number of rsa-coefficients must be one less.
+ * (the base i for the coefficients is 2, not 1, at least as implied by
+ * RFC 8017)
+ */
+#define OSSL_PKEY_PARAM_RSA_N           "n"
+#define OSSL_PKEY_PARAM_RSA_E           "e"
+#define OSSL_PKEY_PARAM_RSA_D           "d"
+#define OSSL_PKEY_PARAM_RSA_FACTOR      "rsa-factor"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT    "rsa-exponent"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT "rsa-coefficient"
+#define OSSL_PKEY_PARAM_RSA_FACTOR1      OSSL_PKEY_PARAM_RSA_FACTOR"1"
+#define OSSL_PKEY_PARAM_RSA_FACTOR2      OSSL_PKEY_PARAM_RSA_FACTOR"2"
+#define OSSL_PKEY_PARAM_RSA_FACTOR3      OSSL_PKEY_PARAM_RSA_FACTOR"3"
+#define OSSL_PKEY_PARAM_RSA_FACTOR4      OSSL_PKEY_PARAM_RSA_FACTOR"4"
+#define OSSL_PKEY_PARAM_RSA_FACTOR5      OSSL_PKEY_PARAM_RSA_FACTOR"5"
+#define OSSL_PKEY_PARAM_RSA_FACTOR6      OSSL_PKEY_PARAM_RSA_FACTOR"6"
+#define OSSL_PKEY_PARAM_RSA_FACTOR7      OSSL_PKEY_PARAM_RSA_FACTOR"7"
+#define OSSL_PKEY_PARAM_RSA_FACTOR8      OSSL_PKEY_PARAM_RSA_FACTOR"8"
+#define OSSL_PKEY_PARAM_RSA_FACTOR9      OSSL_PKEY_PARAM_RSA_FACTOR"9"
+#define OSSL_PKEY_PARAM_RSA_FACTOR10     OSSL_PKEY_PARAM_RSA_FACTOR"10"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT1    OSSL_PKEY_PARAM_RSA_EXPONENT"1"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT2    OSSL_PKEY_PARAM_RSA_EXPONENT"2"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT3    OSSL_PKEY_PARAM_RSA_EXPONENT"3"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT4    OSSL_PKEY_PARAM_RSA_EXPONENT"4"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT5    OSSL_PKEY_PARAM_RSA_EXPONENT"5"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT6    OSSL_PKEY_PARAM_RSA_EXPONENT"6"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT7    OSSL_PKEY_PARAM_RSA_EXPONENT"7"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT8    OSSL_PKEY_PARAM_RSA_EXPONENT"8"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT9    OSSL_PKEY_PARAM_RSA_EXPONENT"9"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT10   OSSL_PKEY_PARAM_RSA_EXPONENT"10"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT1 OSSL_PKEY_PARAM_RSA_COEFFICIENT"1"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT2 OSSL_PKEY_PARAM_RSA_COEFFICIENT"2"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT3 OSSL_PKEY_PARAM_RSA_COEFFICIENT"3"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT4 OSSL_PKEY_PARAM_RSA_COEFFICIENT"4"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT5 OSSL_PKEY_PARAM_RSA_COEFFICIENT"5"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT6 OSSL_PKEY_PARAM_RSA_COEFFICIENT"6"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT7 OSSL_PKEY_PARAM_RSA_COEFFICIENT"7"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT8 OSSL_PKEY_PARAM_RSA_COEFFICIENT"8"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT9 OSSL_PKEY_PARAM_RSA_COEFFICIENT"9"
+
+/* RSA padding modes */
+#define OSSL_PKEY_RSA_PAD_MODE_NONE    "none"
+#define OSSL_PKEY_RSA_PAD_MODE_PKCSV15 "pkcs1"
+#define OSSL_PKEY_RSA_PAD_MODE_OAEP    "oaep"
+#define OSSL_PKEY_RSA_PAD_MODE_X931    "x931"
+#define OSSL_PKEY_RSA_PAD_MODE_PSS     "pss"
+
+/* RSA pss padding salt length */
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_DIGEST "digest"
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_MAX    "max"
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_AUTO   "auto"
+
+/* Key generation parameters */
+#define OSSL_PKEY_PARAM_RSA_BITS             OSSL_PKEY_PARAM_BITS
+#define OSSL_PKEY_PARAM_RSA_PRIMES           "primes"
+#define OSSL_PKEY_PARAM_RSA_DIGEST           OSSL_PKEY_PARAM_DIGEST
+#define OSSL_PKEY_PARAM_RSA_DIGEST_PROPS     OSSL_PKEY_PARAM_PROPERTIES
+#define OSSL_PKEY_PARAM_RSA_MASKGENFUNC      OSSL_PKEY_PARAM_MASKGENFUNC
+#define OSSL_PKEY_PARAM_RSA_MGF1_DIGEST      OSSL_PKEY_PARAM_MGF1_DIGEST
+#define OSSL_PKEY_PARAM_RSA_PSS_SALTLEN      "saltlen"
+
+/* Key generation parameters */
+#define OSSL_PKEY_PARAM_FFC_TYPE         "type"
+#define OSSL_PKEY_PARAM_FFC_PBITS        "pbits"
+#define OSSL_PKEY_PARAM_FFC_QBITS        "qbits"
+#define OSSL_PKEY_PARAM_FFC_DIGEST       OSSL_PKEY_PARAM_DIGEST
+#define OSSL_PKEY_PARAM_FFC_DIGEST_PROPS OSSL_PKEY_PARAM_PROPERTIES
+
+#define OSSL_PKEY_PARAM_EC_ENCODING                "encoding" /* utf8_string */
+#define OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT "point-format"
+#define OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE        "group-check"
+#define OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC          "include-public"
+
+/* OSSL_PKEY_PARAM_EC_ENCODING values */
+#define OSSL_PKEY_EC_ENCODING_EXPLICIT  "explicit"
+#define OSSL_PKEY_EC_ENCODING_GROUP     "named_curve"
+
+#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_UNCOMPRESSED "uncompressed"
+#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_COMPRESSED   "compressed"
+#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_HYBRID       "hybrid"
+
+#define OSSL_PKEY_EC_GROUP_CHECK_DEFAULT     "default"
+#define OSSL_PKEY_EC_GROUP_CHECK_NAMED       "named"
+#define OSSL_PKEY_EC_GROUP_CHECK_NAMED_NIST  "named-nist"
+
+/* Key Exchange parameters */
+#define OSSL_EXCHANGE_PARAM_PAD                   "pad" /* uint */
+#define OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE "ecdh-cofactor-mode" /* int */
+#define OSSL_EXCHANGE_PARAM_KDF_TYPE              "kdf-type" /* utf8_string */
+#define OSSL_EXCHANGE_PARAM_KDF_DIGEST            "kdf-digest" /* utf8_string */
+#define OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS      "kdf-digest-props" /* utf8_string */
+#define OSSL_EXCHANGE_PARAM_KDF_OUTLEN            "kdf-outlen" /* size_t */
+/* The following parameter is an octet_string on set and an octet_ptr on get */
+#define OSSL_EXCHANGE_PARAM_KDF_UKM               "kdf-ukm"
+
+/* Signature parameters */
+#define OSSL_SIGNATURE_PARAM_ALGORITHM_ID       "algorithm-id"
+#define OSSL_SIGNATURE_PARAM_PAD_MODE           OSSL_PKEY_PARAM_PAD_MODE
+#define OSSL_SIGNATURE_PARAM_DIGEST             OSSL_PKEY_PARAM_DIGEST
+#define OSSL_SIGNATURE_PARAM_PROPERTIES         OSSL_PKEY_PARAM_PROPERTIES
+#define OSSL_SIGNATURE_PARAM_PSS_SALTLEN        "saltlen"
+#define OSSL_SIGNATURE_PARAM_MGF1_DIGEST        OSSL_PKEY_PARAM_MGF1_DIGEST
+#define OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES    \
+    OSSL_PKEY_PARAM_MGF1_PROPERTIES
+#define OSSL_SIGNATURE_PARAM_DIGEST_SIZE        OSSL_PKEY_PARAM_DIGEST_SIZE
+
+/* Asym cipher parameters */
+#define OSSL_ASYM_CIPHER_PARAM_DIGEST                   OSSL_PKEY_PARAM_DIGEST
+#define OSSL_ASYM_CIPHER_PARAM_PROPERTIES               OSSL_PKEY_PARAM_PROPERTIES
+#define OSSL_ASYM_CIPHER_PARAM_ENGINE                   OSSL_PKEY_PARAM_ENGINE
+#define OSSL_ASYM_CIPHER_PARAM_PAD_MODE                 OSSL_PKEY_PARAM_PAD_MODE
+#define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST              \
+    OSSL_PKEY_PARAM_MGF1_DIGEST
+#define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS        \
+    OSSL_PKEY_PARAM_MGF1_PROPERTIES
+#define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST              OSSL_ALG_PARAM_DIGEST
+#define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS        "digest-props"
+/* The following parameter is an octet_string on set and an octet_ptr on get */
+#define OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL               "oaep-label"
+#define OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION       "tls-client-version"
+#define OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION   "tls-negotiated-version"
+
+/*
+ * Encoder / decoder parameters
+ */
+#define OSSL_ENCODER_PARAM_CIPHER           OSSL_ALG_PARAM_CIPHER
+#define OSSL_ENCODER_PARAM_PROPERTIES       OSSL_ALG_PARAM_PROPERTIES
+/* Currently PVK only, but reusable for others as needed */
+#define OSSL_ENCODER_PARAM_ENCRYPT_LEVEL    "encrypt-level"
+#define OSSL_ENCODER_PARAM_SAVE_PARAMETERS  "save-parameters" /* integer */
+
+#define OSSL_DECODER_PARAM_PROPERTIES       OSSL_ALG_PARAM_PROPERTIES
+
+/* Passphrase callback parameters */
+#define OSSL_PASSPHRASE_PARAM_INFO      "info"
+
+/* Keygen callback parameters, from provider to libcrypto */
+#define OSSL_GEN_PARAM_POTENTIAL            "potential" /* integer */
+#define OSSL_GEN_PARAM_ITERATION            "iteration" /* integer */
+
+/* ACVP Test parameters : These should not be used normally */
+#define OSSL_PKEY_PARAM_RSA_TEST_XP1 "xp1"
+#define OSSL_PKEY_PARAM_RSA_TEST_XP2 "xp2"
+#define OSSL_PKEY_PARAM_RSA_TEST_XP  "xp"
+#define OSSL_PKEY_PARAM_RSA_TEST_XQ1 "xq1"
+#define OSSL_PKEY_PARAM_RSA_TEST_XQ2 "xq2"
+#define OSSL_PKEY_PARAM_RSA_TEST_XQ  "xq"
+#define OSSL_PKEY_PARAM_RSA_TEST_P1  "p1"
+#define OSSL_PKEY_PARAM_RSA_TEST_P2  "p2"
+#define OSSL_PKEY_PARAM_RSA_TEST_Q1  "q1"
+#define OSSL_PKEY_PARAM_RSA_TEST_Q2  "q2"
+#define OSSL_SIGNATURE_PARAM_KAT "kat"
+
+/* KEM parameters */
+#define OSSL_KEM_PARAM_OPERATION            "operation"
+
+/* OSSL_KEM_PARAM_OPERATION values */
+#define OSSL_KEM_PARAM_OPERATION_RSASVE     "RSASVE"
+
+/* Capabilities */
+
+/* TLS-GROUP Capability */
+#define OSSL_CAPABILITY_TLS_GROUP_NAME              "tls-group-name"
+#define OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL     "tls-group-name-internal"
+#define OSSL_CAPABILITY_TLS_GROUP_ID                "tls-group-id"
+#define OSSL_CAPABILITY_TLS_GROUP_ALG               "tls-group-alg"
+#define OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS     "tls-group-sec-bits"
+#define OSSL_CAPABILITY_TLS_GROUP_IS_KEM            "tls-group-is-kem"
+#define OSSL_CAPABILITY_TLS_GROUP_MIN_TLS           "tls-min-tls"
+#define OSSL_CAPABILITY_TLS_GROUP_MAX_TLS           "tls-max-tls"
+#define OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS          "tls-min-dtls"
+#define OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS          "tls-max-dtls"
+
+/*-
+ * storemgmt parameters
+ */
+
+/*
+ * Used by storemgmt_ctx_set_params():
+ *
+ * - OSSL_STORE_PARAM_EXPECT is an INTEGER, and the value is any of the
+ *   OSSL_STORE_INFO numbers.  This is used to set the expected type of
+ *   object loaded.
+ *
+ * - OSSL_STORE_PARAM_SUBJECT, OSSL_STORE_PARAM_ISSUER,
+ *   OSSL_STORE_PARAM_SERIAL, OSSL_STORE_PARAM_FINGERPRINT,
+ *   OSSL_STORE_PARAM_DIGEST, OSSL_STORE_PARAM_ALIAS
+ *   are used as search criteria.
+ *   (OSSL_STORE_PARAM_DIGEST is used with OSSL_STORE_PARAM_FINGERPRINT)
+ */
+#define OSSL_STORE_PARAM_EXPECT     "expect"       /* INTEGER */
+#define OSSL_STORE_PARAM_SUBJECT    "subject" /* DER blob => OCTET_STRING */
+#define OSSL_STORE_PARAM_ISSUER     "name" /* DER blob => OCTET_STRING */
+#define OSSL_STORE_PARAM_SERIAL     "serial"       /* INTEGER */
+#define OSSL_STORE_PARAM_DIGEST     "digest"       /* UTF8_STRING */
+#define OSSL_STORE_PARAM_FINGERPRINT "fingerprint" /* OCTET_STRING */
+#define OSSL_STORE_PARAM_ALIAS      "alias"        /* UTF8_STRING */
+
+/* You may want to pass properties for the provider implementation to use */
+#define OSSL_STORE_PARAM_PROPERTIES "properties"   /* utf8_string */
+/* OSSL_DECODER input type if a decoder is used by the store */
+#define OSSL_STORE_PARAM_INPUT_TYPE "input-type"   /* UTF8_STRING */
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/core_object.h b/CAPI/cpp/grpc/include/openssl/core_object.h
new file mode 100644
index 0000000..62ccf39
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/core_object.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CORE_OBJECT_H
+# define OPENSSL_CORE_OBJECT_H
+# pragma once
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/*-
+ * Known object types
+ *
+ * These numbers are used as values for the OSSL_PARAM parameter
+ * OSSL_OBJECT_PARAM_TYPE.
+ *
+ * For most of these types, there's a corresponding libcrypto object type.
+ * The corresponding type is indicated with a comment after the number.
+ */
+# define OSSL_OBJECT_UNKNOWN            0
+# define OSSL_OBJECT_NAME               1 /* char * */
+# define OSSL_OBJECT_PKEY               2 /* EVP_PKEY * */
+# define OSSL_OBJECT_CERT               3 /* X509 * */
+# define OSSL_OBJECT_CRL                4 /* X509_CRL * */
+
+/*
+ * The rest of the associated OSSL_PARAM elements is described in core_names.h
+ */
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/crmf.h b/CAPI/cpp/grpc/include/openssl/crmf.h
new file mode 100644
index 0000000..b2a82ed
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/crmf.h
@@ -0,0 +1,227 @@
+/*-
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\crmf.h.in
+ *
+ * Copyright 2007-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Nokia 2007-2019
+ * Copyright Siemens AG 2015-2019
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ *
+ * CRMF (RFC 4211) implementation by M. Peylo, M. Viljanen, and D. von Oheimb.
+ */
+
+
+
+#ifndef OPENSSL_CRMF_H
+# define OPENSSL_CRMF_H
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CRMF
+#  include <openssl/opensslv.h>
+#  include <openssl/safestack.h>
+#  include <openssl/crmferr.h>
+#  include <openssl/x509v3.h> /* for GENERAL_NAME etc. */
+
+/* explicit #includes not strictly needed since implied by the above: */
+#  include <openssl/types.h>
+#  include <openssl/x509.h>
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+#  define OSSL_CRMF_POPOPRIVKEY_THISMESSAGE          0
+#  define OSSL_CRMF_POPOPRIVKEY_SUBSEQUENTMESSAGE    1
+#  define OSSL_CRMF_POPOPRIVKEY_DHMAC                2
+#  define OSSL_CRMF_POPOPRIVKEY_AGREEMAC             3
+#  define OSSL_CRMF_POPOPRIVKEY_ENCRYPTEDKEY         4
+
+#  define OSSL_CRMF_SUBSEQUENTMESSAGE_ENCRCERT       0
+#  define OSSL_CRMF_SUBSEQUENTMESSAGE_CHALLENGERESP  1
+
+typedef struct ossl_crmf_encryptedvalue_st OSSL_CRMF_ENCRYPTEDVALUE;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_ENCRYPTEDVALUE)
+typedef struct ossl_crmf_msg_st OSSL_CRMF_MSG;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_MSG)
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CRMF_MSG)
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CRMF_MSG, OSSL_CRMF_MSG, OSSL_CRMF_MSG)
+#define sk_OSSL_CRMF_MSG_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_value(sk, idx) ((OSSL_CRMF_MSG *)OPENSSL_sk_value(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk), (idx)))
+#define sk_OSSL_CRMF_MSG_new(cmp) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new(ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp)))
+#define sk_OSSL_CRMF_MSG_new_null() ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CRMF_MSG_new_reserve(cmp, n) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp), (n)))
+#define sk_OSSL_CRMF_MSG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (n))
+#define sk_OSSL_CRMF_MSG_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_delete(sk, i) ((OSSL_CRMF_MSG *)OPENSSL_sk_delete(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (i)))
+#define sk_OSSL_CRMF_MSG_delete_ptr(sk, ptr) ((OSSL_CRMF_MSG *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr)))
+#define sk_OSSL_CRMF_MSG_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
+#define sk_OSSL_CRMF_MSG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
+#define sk_OSSL_CRMF_MSG_pop(sk) ((OSSL_CRMF_MSG *)OPENSSL_sk_pop(ossl_check_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_shift(sk) ((OSSL_CRMF_MSG *)OPENSSL_sk_shift(ossl_check_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CRMF_MSG_sk_type(sk),ossl_check_OSSL_CRMF_MSG_freefunc_type(freefunc))
+#define sk_OSSL_CRMF_MSG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr), (idx))
+#define sk_OSSL_CRMF_MSG_set(sk, idx, ptr) ((OSSL_CRMF_MSG *)OPENSSL_sk_set(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (idx), ossl_check_OSSL_CRMF_MSG_type(ptr)))
+#define sk_OSSL_CRMF_MSG_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
+#define sk_OSSL_CRMF_MSG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
+#define sk_OSSL_CRMF_MSG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr), pnum)
+#define sk_OSSL_CRMF_MSG_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk))
+#define sk_OSSL_CRMF_MSG_dup(sk) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_copyfunc_type(copyfunc), ossl_check_OSSL_CRMF_MSG_freefunc_type(freefunc)))
+#define sk_OSSL_CRMF_MSG_set_cmp_func(sk, cmp) ((sk_OSSL_CRMF_MSG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp)))
+
+typedef struct ossl_crmf_attributetypeandvalue_st OSSL_CRMF_ATTRIBUTETYPEANDVALUE;
+typedef struct ossl_crmf_pbmparameter_st OSSL_CRMF_PBMPARAMETER;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_PBMPARAMETER)
+typedef struct ossl_crmf_poposigningkey_st OSSL_CRMF_POPOSIGNINGKEY;
+typedef struct ossl_crmf_certrequest_st OSSL_CRMF_CERTREQUEST;
+typedef struct ossl_crmf_certid_st OSSL_CRMF_CERTID;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_CERTID)
+DECLARE_ASN1_DUP_FUNCTION(OSSL_CRMF_CERTID)
+SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CRMF_CERTID, OSSL_CRMF_CERTID, OSSL_CRMF_CERTID)
+#define sk_OSSL_CRMF_CERTID_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_value(sk, idx) ((OSSL_CRMF_CERTID *)OPENSSL_sk_value(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk), (idx)))
+#define sk_OSSL_CRMF_CERTID_new(cmp) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new(ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp)))
+#define sk_OSSL_CRMF_CERTID_new_null() ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new_null())
+#define sk_OSSL_CRMF_CERTID_new_reserve(cmp, n) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp), (n)))
+#define sk_OSSL_CRMF_CERTID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (n))
+#define sk_OSSL_CRMF_CERTID_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_delete(sk, i) ((OSSL_CRMF_CERTID *)OPENSSL_sk_delete(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (i)))
+#define sk_OSSL_CRMF_CERTID_delete_ptr(sk, ptr) ((OSSL_CRMF_CERTID *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr)))
+#define sk_OSSL_CRMF_CERTID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
+#define sk_OSSL_CRMF_CERTID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
+#define sk_OSSL_CRMF_CERTID_pop(sk) ((OSSL_CRMF_CERTID *)OPENSSL_sk_pop(ossl_check_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_shift(sk) ((OSSL_CRMF_CERTID *)OPENSSL_sk_shift(ossl_check_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CRMF_CERTID_sk_type(sk),ossl_check_OSSL_CRMF_CERTID_freefunc_type(freefunc))
+#define sk_OSSL_CRMF_CERTID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr), (idx))
+#define sk_OSSL_CRMF_CERTID_set(sk, idx, ptr) ((OSSL_CRMF_CERTID *)OPENSSL_sk_set(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (idx), ossl_check_OSSL_CRMF_CERTID_type(ptr)))
+#define sk_OSSL_CRMF_CERTID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
+#define sk_OSSL_CRMF_CERTID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
+#define sk_OSSL_CRMF_CERTID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr), pnum)
+#define sk_OSSL_CRMF_CERTID_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk))
+#define sk_OSSL_CRMF_CERTID_dup(sk) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_copyfunc_type(copyfunc), ossl_check_OSSL_CRMF_CERTID_freefunc_type(freefunc)))
+#define sk_OSSL_CRMF_CERTID_set_cmp_func(sk, cmp) ((sk_OSSL_CRMF_CERTID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp)))
+
+
+typedef struct ossl_crmf_pkipublicationinfo_st OSSL_CRMF_PKIPUBLICATIONINFO;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_PKIPUBLICATIONINFO)
+typedef struct ossl_crmf_singlepubinfo_st OSSL_CRMF_SINGLEPUBINFO;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_SINGLEPUBINFO)
+typedef struct ossl_crmf_certtemplate_st OSSL_CRMF_CERTTEMPLATE;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_CERTTEMPLATE)
+typedef STACK_OF(OSSL_CRMF_MSG) OSSL_CRMF_MSGS;
+DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_MSGS)
+
+typedef struct ossl_crmf_optionalvalidity_st OSSL_CRMF_OPTIONALVALIDITY;
+
+/* crmf_pbm.c */
+OSSL_CRMF_PBMPARAMETER *OSSL_CRMF_pbmp_new(OSSL_LIB_CTX *libctx, size_t slen,
+                                           int owfnid, size_t itercnt,
+                                           int macnid);
+int OSSL_CRMF_pbm_new(OSSL_LIB_CTX *libctx, const char *propq,
+                      const OSSL_CRMF_PBMPARAMETER *pbmp,
+                      const unsigned char *msg, size_t msglen,
+                      const unsigned char *sec, size_t seclen,
+                      unsigned char **mac, size_t *maclen);
+
+/* crmf_lib.c */
+int OSSL_CRMF_MSG_set1_regCtrl_regToken(OSSL_CRMF_MSG *msg,
+                                        const ASN1_UTF8STRING *tok);
+ASN1_UTF8STRING
+*OSSL_CRMF_MSG_get0_regCtrl_regToken(const OSSL_CRMF_MSG *msg);
+int OSSL_CRMF_MSG_set1_regCtrl_authenticator(OSSL_CRMF_MSG *msg,
+                                             const ASN1_UTF8STRING *auth);
+ASN1_UTF8STRING
+*OSSL_CRMF_MSG_get0_regCtrl_authenticator(const OSSL_CRMF_MSG *msg);
+int
+OSSL_CRMF_MSG_PKIPublicationInfo_push0_SinglePubInfo(OSSL_CRMF_PKIPUBLICATIONINFO *pi,
+                                                     OSSL_CRMF_SINGLEPUBINFO *spi);
+#  define OSSL_CRMF_PUB_METHOD_DONTCARE 0
+#  define OSSL_CRMF_PUB_METHOD_X500     1
+#  define OSSL_CRMF_PUB_METHOD_WEB      2
+#  define OSSL_CRMF_PUB_METHOD_LDAP     3
+int OSSL_CRMF_MSG_set0_SinglePubInfo(OSSL_CRMF_SINGLEPUBINFO *spi,
+                                     int method, GENERAL_NAME *nm);
+#  define OSSL_CRMF_PUB_ACTION_DONTPUBLISH   0
+#  define OSSL_CRMF_PUB_ACTION_PLEASEPUBLISH 1
+int OSSL_CRMF_MSG_set_PKIPublicationInfo_action(OSSL_CRMF_PKIPUBLICATIONINFO *pi,
+                                                int action);
+int OSSL_CRMF_MSG_set1_regCtrl_pkiPublicationInfo(OSSL_CRMF_MSG *msg,
+                                                  const OSSL_CRMF_PKIPUBLICATIONINFO *pi);
+OSSL_CRMF_PKIPUBLICATIONINFO
+*OSSL_CRMF_MSG_get0_regCtrl_pkiPublicationInfo(const OSSL_CRMF_MSG *msg);
+int OSSL_CRMF_MSG_set1_regCtrl_protocolEncrKey(OSSL_CRMF_MSG *msg,
+                                               const X509_PUBKEY *pubkey);
+X509_PUBKEY
+*OSSL_CRMF_MSG_get0_regCtrl_protocolEncrKey(const OSSL_CRMF_MSG *msg);
+int OSSL_CRMF_MSG_set1_regCtrl_oldCertID(OSSL_CRMF_MSG *msg,
+                                         const OSSL_CRMF_CERTID *cid);
+OSSL_CRMF_CERTID
+*OSSL_CRMF_MSG_get0_regCtrl_oldCertID(const OSSL_CRMF_MSG *msg);
+OSSL_CRMF_CERTID *OSSL_CRMF_CERTID_gen(const X509_NAME *issuer,
+                                       const ASN1_INTEGER *serial);
+
+int OSSL_CRMF_MSG_set1_regInfo_utf8Pairs(OSSL_CRMF_MSG *msg,
+                                         const ASN1_UTF8STRING *utf8pairs);
+ASN1_UTF8STRING
+*OSSL_CRMF_MSG_get0_regInfo_utf8Pairs(const OSSL_CRMF_MSG *msg);
+int OSSL_CRMF_MSG_set1_regInfo_certReq(OSSL_CRMF_MSG *msg,
+                                       const OSSL_CRMF_CERTREQUEST *cr);
+OSSL_CRMF_CERTREQUEST
+*OSSL_CRMF_MSG_get0_regInfo_certReq(const OSSL_CRMF_MSG *msg);
+
+int OSSL_CRMF_MSG_set0_validity(OSSL_CRMF_MSG *crm,
+                                ASN1_TIME *notBefore, ASN1_TIME *notAfter);
+int OSSL_CRMF_MSG_set_certReqId(OSSL_CRMF_MSG *crm, int rid);
+int OSSL_CRMF_MSG_get_certReqId(const OSSL_CRMF_MSG *crm);
+int OSSL_CRMF_MSG_set0_extensions(OSSL_CRMF_MSG *crm, X509_EXTENSIONS *exts);
+
+int OSSL_CRMF_MSG_push0_extension(OSSL_CRMF_MSG *crm, X509_EXTENSION *ext);
+#  define OSSL_CRMF_POPO_NONE       -1
+#  define OSSL_CRMF_POPO_RAVERIFIED 0
+#  define OSSL_CRMF_POPO_SIGNATURE  1
+#  define OSSL_CRMF_POPO_KEYENC     2
+#  define OSSL_CRMF_POPO_KEYAGREE   3
+int OSSL_CRMF_MSG_create_popo(int meth, OSSL_CRMF_MSG *crm,
+                              EVP_PKEY *pkey, const EVP_MD *digest,
+                              OSSL_LIB_CTX *libctx, const char *propq);
+int OSSL_CRMF_MSGS_verify_popo(const OSSL_CRMF_MSGS *reqs,
+                               int rid, int acceptRAVerified,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_CRMF_CERTTEMPLATE *OSSL_CRMF_MSG_get0_tmpl(const OSSL_CRMF_MSG *crm);
+const ASN1_INTEGER
+*OSSL_CRMF_CERTTEMPLATE_get0_serialNumber(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+const X509_NAME
+*OSSL_CRMF_CERTTEMPLATE_get0_subject(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+const X509_NAME
+*OSSL_CRMF_CERTTEMPLATE_get0_issuer(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+X509_EXTENSIONS
+*OSSL_CRMF_CERTTEMPLATE_get0_extensions(const OSSL_CRMF_CERTTEMPLATE *tmpl);
+const X509_NAME
+*OSSL_CRMF_CERTID_get0_issuer(const OSSL_CRMF_CERTID *cid);
+const ASN1_INTEGER
+*OSSL_CRMF_CERTID_get0_serialNumber(const OSSL_CRMF_CERTID *cid);
+int OSSL_CRMF_CERTTEMPLATE_fill(OSSL_CRMF_CERTTEMPLATE *tmpl,
+                                EVP_PKEY *pubkey,
+                                const X509_NAME *subject,
+                                const X509_NAME *issuer,
+                                const ASN1_INTEGER *serial);
+X509
+*OSSL_CRMF_ENCRYPTEDVALUE_get1_encCert(const OSSL_CRMF_ENCRYPTEDVALUE *ecert,
+                                       OSSL_LIB_CTX *libctx, const char *propq,
+                                       EVP_PKEY *pkey);
+
+#  ifdef __cplusplus
+}
+#  endif
+# endif /* !defined(OPENSSL_NO_CRMF) */
+#endif /* !defined(OPENSSL_CRMF_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/crmferr.h b/CAPI/cpp/grpc/include/openssl/crmferr.h
new file mode 100644
index 0000000..b242b92
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/crmferr.h
@@ -0,0 +1,50 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CRMFERR_H
+# define OPENSSL_CRMFERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_CRMF
+
+
+/*
+ * CRMF reason codes.
+ */
+#  define CRMF_R_BAD_PBM_ITERATIONCOUNT                    100
+#  define CRMF_R_CRMFERROR                                 102
+#  define CRMF_R_ERROR                                     103
+#  define CRMF_R_ERROR_DECODING_CERTIFICATE                104
+#  define CRMF_R_ERROR_DECRYPTING_CERTIFICATE              105
+#  define CRMF_R_ERROR_DECRYPTING_SYMMETRIC_KEY            106
+#  define CRMF_R_FAILURE_OBTAINING_RANDOM                  107
+#  define CRMF_R_ITERATIONCOUNT_BELOW_100                  108
+#  define CRMF_R_MALFORMED_IV                              101
+#  define CRMF_R_NULL_ARGUMENT                             109
+#  define CRMF_R_POPOSKINPUT_NOT_SUPPORTED                 113
+#  define CRMF_R_POPO_INCONSISTENT_PUBLIC_KEY              117
+#  define CRMF_R_POPO_MISSING                              121
+#  define CRMF_R_POPO_MISSING_PUBLIC_KEY                   118
+#  define CRMF_R_POPO_MISSING_SUBJECT                      119
+#  define CRMF_R_POPO_RAVERIFIED_NOT_ACCEPTED              120
+#  define CRMF_R_SETTING_MAC_ALGOR_FAILURE                 110
+#  define CRMF_R_SETTING_OWF_ALGOR_FAILURE                 111
+#  define CRMF_R_UNSUPPORTED_ALGORITHM                     112
+#  define CRMF_R_UNSUPPORTED_CIPHER                        114
+#  define CRMF_R_UNSUPPORTED_METHOD_FOR_CREATING_POPO      115
+#  define CRMF_R_UNSUPPORTED_POPO_METHOD                   116
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/crypto.h b/CAPI/cpp/grpc/include/openssl/crypto.h
new file mode 100644
index 0000000..8b82593
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/crypto.h
@@ -0,0 +1,558 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\crypto.h.in
+ *
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_CRYPTO_H
+# define OPENSSL_CRYPTO_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CRYPTO_H
+# endif
+
+# include <stdlib.h>
+# include <time.h>
+
+# include <openssl/e_os2.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+# include <openssl/safestack.h>
+# include <openssl/opensslv.h>
+# include <openssl/types.h>
+# include <openssl/opensslconf.h>
+# include <openssl/cryptoerr.h>
+# include <openssl/core.h>
+
+# ifdef CHARSET_EBCDIC
+#  include <openssl/ebcdic.h>
+# endif
+
+/*
+ * Resolve problems on some operating systems with symbol names that clash
+ * one way or another
+ */
+# include <openssl/symhacks.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/opensslv.h>
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSLeay                  OpenSSL_version_num
+#  define SSLeay_version          OpenSSL_version
+#  define SSLEAY_VERSION_NUMBER   OPENSSL_VERSION_NUMBER
+#  define SSLEAY_VERSION          OPENSSL_VERSION
+#  define SSLEAY_CFLAGS           OPENSSL_CFLAGS
+#  define SSLEAY_BUILT_ON         OPENSSL_BUILT_ON
+#  define SSLEAY_PLATFORM         OPENSSL_PLATFORM
+#  define SSLEAY_DIR              OPENSSL_DIR
+
+/*
+ * Old type for allocating dynamic locks. No longer used. Use the new thread
+ * API instead.
+ */
+typedef struct {
+    int dummy;
+} CRYPTO_dynlock;
+
+# endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
+
+typedef void CRYPTO_RWLOCK;
+
+CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void);
+__owur int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock);
+__owur int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock);
+int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock);
+void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock);
+
+int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock);
+int CRYPTO_atomic_or(uint64_t *val, uint64_t op, uint64_t *ret,
+                     CRYPTO_RWLOCK *lock);
+int CRYPTO_atomic_load(uint64_t *val, uint64_t *ret, CRYPTO_RWLOCK *lock);
+
+/* No longer needed, so this is a no-op */
+#define OPENSSL_malloc_init() while(0) continue
+
+# define OPENSSL_malloc(num) \
+        CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_zalloc(num) \
+        CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_realloc(addr, num) \
+        CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_clear_realloc(addr, old_num, num) \
+        CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_clear_free(addr, num) \
+        CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_free(addr) \
+        CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_memdup(str, s) \
+        CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_strdup(str) \
+        CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_strndup(str, n) \
+        CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_malloc(num) \
+        CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_zalloc(num) \
+        CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_free(addr) \
+        CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_clear_free(addr, num) \
+        CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+# define OPENSSL_secure_actual_size(ptr) \
+        CRYPTO_secure_actual_size(ptr)
+
+size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz);
+size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz);
+size_t OPENSSL_strnlen(const char *str, size_t maxlen);
+int OPENSSL_buf2hexstr_ex(char *str, size_t str_n, size_t *strlength,
+                          const unsigned char *buf, size_t buflen,
+                          const char sep);
+char *OPENSSL_buf2hexstr(const unsigned char *buf, long buflen);
+int OPENSSL_hexstr2buf_ex(unsigned char *buf, size_t buf_n, size_t *buflen,
+                          const char *str, const char sep);
+unsigned char *OPENSSL_hexstr2buf(const char *str, long *buflen);
+int OPENSSL_hexchar2int(unsigned char c);
+int OPENSSL_strcasecmp(const char *s1, const char *s2);
+int OPENSSL_strncasecmp(const char *s1, const char *s2, size_t n);
+
+# define OPENSSL_MALLOC_MAX_NELEMS(type)  (((1U<<(sizeof(int)*8-1))-1)/sizeof(type))
+
+/*
+ * These functions return the values of OPENSSL_VERSION_MAJOR,
+ * OPENSSL_VERSION_MINOR, OPENSSL_VERSION_PATCH, OPENSSL_VERSION_PRE_RELEASE
+ * and OPENSSL_VERSION_BUILD_METADATA, respectively.
+ */
+unsigned int OPENSSL_version_major(void);
+unsigned int OPENSSL_version_minor(void);
+unsigned int OPENSSL_version_patch(void);
+const char *OPENSSL_version_pre_release(void);
+const char *OPENSSL_version_build_metadata(void);
+
+unsigned long OpenSSL_version_num(void);
+const char *OpenSSL_version(int type);
+# define OPENSSL_VERSION                0
+# define OPENSSL_CFLAGS                 1
+# define OPENSSL_BUILT_ON               2
+# define OPENSSL_PLATFORM               3
+# define OPENSSL_DIR                    4
+# define OPENSSL_ENGINES_DIR            5
+# define OPENSSL_VERSION_STRING         6
+# define OPENSSL_FULL_VERSION_STRING    7
+# define OPENSSL_MODULES_DIR            8
+# define OPENSSL_CPU_INFO               9
+
+const char *OPENSSL_info(int type);
+/*
+ * The series starts at 1001 to avoid confusion with the OpenSSL_version
+ * types.
+ */
+# define OPENSSL_INFO_CONFIG_DIR                1001
+# define OPENSSL_INFO_ENGINES_DIR               1002
+# define OPENSSL_INFO_MODULES_DIR               1003
+# define OPENSSL_INFO_DSO_EXTENSION             1004
+# define OPENSSL_INFO_DIR_FILENAME_SEPARATOR    1005
+# define OPENSSL_INFO_LIST_SEPARATOR            1006
+# define OPENSSL_INFO_SEED_SOURCE               1007
+# define OPENSSL_INFO_CPU_SETTINGS              1008
+
+int OPENSSL_issetugid(void);
+
+struct crypto_ex_data_st {
+    OSSL_LIB_CTX *ctx;
+    STACK_OF(void) *sk;
+};
+
+SKM_DEFINE_STACK_OF_INTERNAL(void, void, void)
+#define sk_void_num(sk) OPENSSL_sk_num(ossl_check_const_void_sk_type(sk))
+#define sk_void_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_void_sk_type(sk), (idx)))
+#define sk_void_new(cmp) ((STACK_OF(void) *)OPENSSL_sk_new(ossl_check_void_compfunc_type(cmp)))
+#define sk_void_new_null() ((STACK_OF(void) *)OPENSSL_sk_new_null())
+#define sk_void_new_reserve(cmp, n) ((STACK_OF(void) *)OPENSSL_sk_new_reserve(ossl_check_void_compfunc_type(cmp), (n)))
+#define sk_void_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_void_sk_type(sk), (n))
+#define sk_void_free(sk) OPENSSL_sk_free(ossl_check_void_sk_type(sk))
+#define sk_void_zero(sk) OPENSSL_sk_zero(ossl_check_void_sk_type(sk))
+#define sk_void_delete(sk, i) ((void *)OPENSSL_sk_delete(ossl_check_void_sk_type(sk), (i)))
+#define sk_void_delete_ptr(sk, ptr) ((void *)OPENSSL_sk_delete_ptr(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr)))
+#define sk_void_push(sk, ptr) OPENSSL_sk_push(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
+#define sk_void_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
+#define sk_void_pop(sk) ((void *)OPENSSL_sk_pop(ossl_check_void_sk_type(sk)))
+#define sk_void_shift(sk) ((void *)OPENSSL_sk_shift(ossl_check_void_sk_type(sk)))
+#define sk_void_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_void_sk_type(sk),ossl_check_void_freefunc_type(freefunc))
+#define sk_void_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr), (idx))
+#define sk_void_set(sk, idx, ptr) ((void *)OPENSSL_sk_set(ossl_check_void_sk_type(sk), (idx), ossl_check_void_type(ptr)))
+#define sk_void_find(sk, ptr) OPENSSL_sk_find(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
+#define sk_void_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
+#define sk_void_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr), pnum)
+#define sk_void_sort(sk) OPENSSL_sk_sort(ossl_check_void_sk_type(sk))
+#define sk_void_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_void_sk_type(sk))
+#define sk_void_dup(sk) ((STACK_OF(void) *)OPENSSL_sk_dup(ossl_check_const_void_sk_type(sk)))
+#define sk_void_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(void) *)OPENSSL_sk_deep_copy(ossl_check_const_void_sk_type(sk), ossl_check_void_copyfunc_type(copyfunc), ossl_check_void_freefunc_type(freefunc)))
+#define sk_void_set_cmp_func(sk, cmp) ((sk_void_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_void_sk_type(sk), ossl_check_void_compfunc_type(cmp)))
+
+
+
+/*
+ * Per class, we have a STACK of function pointers.
+ */
+# define CRYPTO_EX_INDEX_SSL              0
+# define CRYPTO_EX_INDEX_SSL_CTX          1
+# define CRYPTO_EX_INDEX_SSL_SESSION      2
+# define CRYPTO_EX_INDEX_X509             3
+# define CRYPTO_EX_INDEX_X509_STORE       4
+# define CRYPTO_EX_INDEX_X509_STORE_CTX   5
+# define CRYPTO_EX_INDEX_DH               6
+# define CRYPTO_EX_INDEX_DSA              7
+# define CRYPTO_EX_INDEX_EC_KEY           8
+# define CRYPTO_EX_INDEX_RSA              9
+# define CRYPTO_EX_INDEX_ENGINE          10
+# define CRYPTO_EX_INDEX_UI              11
+# define CRYPTO_EX_INDEX_BIO             12
+# define CRYPTO_EX_INDEX_APP             13
+# define CRYPTO_EX_INDEX_UI_METHOD       14
+# define CRYPTO_EX_INDEX_RAND_DRBG       15
+# define CRYPTO_EX_INDEX_DRBG            CRYPTO_EX_INDEX_RAND_DRBG
+# define CRYPTO_EX_INDEX_OSSL_LIB_CTX    16
+# define CRYPTO_EX_INDEX_EVP_PKEY        17
+# define CRYPTO_EX_INDEX__COUNT          18
+
+typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
+                           int idx, long argl, void *argp);
+typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
+                             int idx, long argl, void *argp);
+typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
+                           void **from_d, int idx, long argl, void *argp);
+__owur int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
+                                   CRYPTO_EX_new *new_func,
+                                   CRYPTO_EX_dup *dup_func,
+                                   CRYPTO_EX_free *free_func);
+/* No longer use an index. */
+int CRYPTO_free_ex_index(int class_index, int idx);
+
+/*
+ * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a
+ * given class (invokes whatever per-class callbacks are applicable)
+ */
+int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
+int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
+                       const CRYPTO_EX_DATA *from);
+
+void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
+
+/* Allocate a single item in the CRYPTO_EX_DATA variable */
+int CRYPTO_alloc_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad,
+                         int idx);
+
+/*
+ * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular
+ * index (relative to the class type involved)
+ */
+int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
+void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/*
+ * This function cleans up all "ex_data" state. It mustn't be called under
+ * potential race-conditions.
+ */
+# define CRYPTO_cleanup_all_ex_data() while(0) continue
+
+/*
+ * The old locking functions have been removed completely without compatibility
+ * macros. This is because the old functions either could not properly report
+ * errors, or the returned error values were not clearly documented.
+ * Replacing the locking functions with no-ops would cause race condition
+ * issues in the affected applications. It is far better for them to fail at
+ * compile time.
+ * On the other hand, the locking callbacks are no longer used.  Consequently,
+ * the callback management functions can be safely replaced with no-op macros.
+ */
+#  define CRYPTO_num_locks()            (1)
+#  define CRYPTO_set_locking_callback(func)
+#  define CRYPTO_get_locking_callback()         (NULL)
+#  define CRYPTO_set_add_lock_callback(func)
+#  define CRYPTO_get_add_lock_callback()        (NULL)
+
+/*
+ * These defines where used in combination with the old locking callbacks,
+ * they are not called anymore, but old code that's not called might still
+ * use them.
+ */
+#  define CRYPTO_LOCK             1
+#  define CRYPTO_UNLOCK           2
+#  define CRYPTO_READ             4
+#  define CRYPTO_WRITE            8
+
+/* This structure is no longer used */
+typedef struct crypto_threadid_st {
+    int dummy;
+} CRYPTO_THREADID;
+/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
+#  define CRYPTO_THREADID_set_numeric(id, val)
+#  define CRYPTO_THREADID_set_pointer(id, ptr)
+#  define CRYPTO_THREADID_set_callback(threadid_func)   (0)
+#  define CRYPTO_THREADID_get_callback()                (NULL)
+#  define CRYPTO_THREADID_current(id)
+#  define CRYPTO_THREADID_cmp(a, b)                     (-1)
+#  define CRYPTO_THREADID_cpy(dest, src)
+#  define CRYPTO_THREADID_hash(id)                      (0UL)
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_0_0
+#   define CRYPTO_set_id_callback(func)
+#   define CRYPTO_get_id_callback()                     (NULL)
+#   define CRYPTO_thread_id()                           (0UL)
+#  endif /* OPENSSL_NO_DEPRECATED_1_0_0 */
+
+#  define CRYPTO_set_dynlock_create_callback(dyn_create_function)
+#  define CRYPTO_set_dynlock_lock_callback(dyn_lock_function)
+#  define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function)
+#  define CRYPTO_get_dynlock_create_callback()          (NULL)
+#  define CRYPTO_get_dynlock_lock_callback()            (NULL)
+#  define CRYPTO_get_dynlock_destroy_callback()         (NULL)
+# endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
+
+typedef void *(*CRYPTO_malloc_fn)(size_t num, const char *file, int line);
+typedef void *(*CRYPTO_realloc_fn)(void *addr, size_t num, const char *file,
+                                   int line);
+typedef void (*CRYPTO_free_fn)(void *addr, const char *file, int line);
+int CRYPTO_set_mem_functions(CRYPTO_malloc_fn malloc_fn,
+                             CRYPTO_realloc_fn realloc_fn,
+                             CRYPTO_free_fn free_fn);
+void CRYPTO_get_mem_functions(CRYPTO_malloc_fn *malloc_fn,
+                              CRYPTO_realloc_fn *realloc_fn,
+                              CRYPTO_free_fn *free_fn);
+
+void *CRYPTO_malloc(size_t num, const char *file, int line);
+void *CRYPTO_zalloc(size_t num, const char *file, int line);
+void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line);
+char *CRYPTO_strdup(const char *str, const char *file, int line);
+char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line);
+void CRYPTO_free(void *ptr, const char *file, int line);
+void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line);
+void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line);
+void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
+                           const char *file, int line);
+
+int CRYPTO_secure_malloc_init(size_t sz, size_t minsize);
+int CRYPTO_secure_malloc_done(void);
+void *CRYPTO_secure_malloc(size_t num, const char *file, int line);
+void *CRYPTO_secure_zalloc(size_t num, const char *file, int line);
+void CRYPTO_secure_free(void *ptr, const char *file, int line);
+void CRYPTO_secure_clear_free(void *ptr, size_t num,
+                              const char *file, int line);
+int CRYPTO_secure_allocated(const void *ptr);
+int CRYPTO_secure_malloc_initialized(void);
+size_t CRYPTO_secure_actual_size(void *ptr);
+size_t CRYPTO_secure_used(void);
+
+void OPENSSL_cleanse(void *ptr, size_t len);
+
+# ifndef OPENSSL_NO_CRYPTO_MDEBUG
+/*
+ * The following can be used to detect memory leaks in the library. If
+ * used, it turns on malloc checking
+ */
+# define CRYPTO_MEM_CHECK_OFF     0x0   /* Control only */
+# define CRYPTO_MEM_CHECK_ON      0x1   /* Control and mode bit */
+# define CRYPTO_MEM_CHECK_ENABLE  0x2   /* Control and mode bit */
+# define CRYPTO_MEM_CHECK_DISABLE 0x3   /* Control only */
+
+void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount);
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#    define OPENSSL_mem_debug_push(info) \
+         CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE)
+#    define OPENSSL_mem_debug_pop() \
+         CRYPTO_mem_debug_pop()
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_set_mem_debug(int flag);
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_ctrl(int mode);
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_push(const char *info,
+                                                const char *file, int line);
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_pop(void);
+OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_malloc(void *addr, size_t num,
+                                                   int flag,
+                                                   const char *file, int line);
+OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_realloc(void *addr1, void *addr2,
+                                                    size_t num, int flag,
+                                                    const char *file, int line);
+OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_free(void *addr, int flag,
+                                                 const char *file, int line);
+OSSL_DEPRECATEDIN_3_0
+int CRYPTO_mem_leaks_cb(int (*cb)(const char *str, size_t len, void *u),
+                        void *u);
+#  endif
+#  ifndef OPENSSL_NO_STDIO
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks_fp(FILE *);
+#  endif
+#  endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks(BIO *bio);
+# endif
+# endif /* OPENSSL_NO_CRYPTO_MDEBUG */
+
+/* die if we have to */
+ossl_noreturn void OPENSSL_die(const char *assertion, const char *file, int line);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define OpenSSLDie(f,l,a) OPENSSL_die((a),(f),(l))
+# endif
+# define OPENSSL_assert(e) \
+    (void)((e) ? 0 : (OPENSSL_die("assertion failed: " #e, OPENSSL_FILE, OPENSSL_LINE), 1))
+
+int OPENSSL_isservice(void);
+
+void OPENSSL_init(void);
+# ifdef OPENSSL_SYS_UNIX
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_prepare(void);
+OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_parent(void);
+OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_child(void);
+#  endif
+# endif
+
+struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result);
+int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec);
+int OPENSSL_gmtime_diff(int *pday, int *psec,
+                        const struct tm *from, const struct tm *to);
+
+/*
+ * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal.
+ * It takes an amount of time dependent on |len|, but independent of the
+ * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements
+ * into a defined order as the return value when a != b is undefined, other
+ * than to be non-zero.
+ */
+int CRYPTO_memcmp(const void * in_a, const void * in_b, size_t len);
+
+/* Standard initialisation options */
+# define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L
+# define OPENSSL_INIT_LOAD_CRYPTO_STRINGS    0x00000002L
+# define OPENSSL_INIT_ADD_ALL_CIPHERS        0x00000004L
+# define OPENSSL_INIT_ADD_ALL_DIGESTS        0x00000008L
+# define OPENSSL_INIT_NO_ADD_ALL_CIPHERS     0x00000010L
+# define OPENSSL_INIT_NO_ADD_ALL_DIGESTS     0x00000020L
+# define OPENSSL_INIT_LOAD_CONFIG            0x00000040L
+# define OPENSSL_INIT_NO_LOAD_CONFIG         0x00000080L
+# define OPENSSL_INIT_ASYNC                  0x00000100L
+# define OPENSSL_INIT_ENGINE_RDRAND          0x00000200L
+# define OPENSSL_INIT_ENGINE_DYNAMIC         0x00000400L
+# define OPENSSL_INIT_ENGINE_OPENSSL         0x00000800L
+# define OPENSSL_INIT_ENGINE_CRYPTODEV       0x00001000L
+# define OPENSSL_INIT_ENGINE_CAPI            0x00002000L
+# define OPENSSL_INIT_ENGINE_PADLOCK         0x00004000L
+# define OPENSSL_INIT_ENGINE_AFALG           0x00008000L
+/* FREE:                                     0x00010000L */
+# define OPENSSL_INIT_ATFORK                 0x00020000L
+/* OPENSSL_INIT_BASE_ONLY                    0x00040000L */
+# define OPENSSL_INIT_NO_ATEXIT              0x00080000L
+/* OPENSSL_INIT flag range 0x03f00000 reserved for OPENSSL_init_ssl() */
+/* FREE: 0x04000000L */
+/* FREE: 0x08000000L */
+/* FREE: 0x10000000L */
+/* FREE: 0x20000000L */
+/* FREE: 0x40000000L */
+/* FREE: 0x80000000L */
+/* Max OPENSSL_INIT flag value is 0x80000000 */
+
+/* openssl and dasync not counted as builtin */
+# define OPENSSL_INIT_ENGINE_ALL_BUILTIN \
+    (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC \
+    | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | \
+    OPENSSL_INIT_ENGINE_PADLOCK)
+
+/* Library initialisation functions */
+void OPENSSL_cleanup(void);
+int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
+int OPENSSL_atexit(void (*handler)(void));
+void OPENSSL_thread_stop(void);
+void OPENSSL_thread_stop_ex(OSSL_LIB_CTX *ctx);
+
+/* Low-level control of initialization */
+OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void);
+# ifndef OPENSSL_NO_STDIO
+int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings,
+                                     const char *config_filename);
+void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings,
+                                        unsigned long flags);
+int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings,
+                                    const char *config_appname);
+# endif
+void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings);
+
+# if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
+#  if defined(_WIN32)
+#   if defined(BASETYPES) || defined(_WINDEF_H)
+/* application has to include <windows.h> in order to use this */
+typedef DWORD CRYPTO_THREAD_LOCAL;
+typedef DWORD CRYPTO_THREAD_ID;
+
+typedef LONG CRYPTO_ONCE;
+#    define CRYPTO_ONCE_STATIC_INIT 0
+#   endif
+#  else
+#   if defined(__TANDEM) && defined(_SPT_MODEL_)
+#    define  SPT_THREAD_SIGNAL 1
+#    define  SPT_THREAD_AWARE 1
+#    include <spthread.h>
+#   else
+#    include <pthread.h>
+#   endif
+typedef pthread_once_t CRYPTO_ONCE;
+typedef pthread_key_t CRYPTO_THREAD_LOCAL;
+typedef pthread_t CRYPTO_THREAD_ID;
+
+#   define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT
+#  endif
+# endif
+
+# if !defined(CRYPTO_ONCE_STATIC_INIT)
+typedef unsigned int CRYPTO_ONCE;
+typedef unsigned int CRYPTO_THREAD_LOCAL;
+typedef unsigned int CRYPTO_THREAD_ID;
+#  define CRYPTO_ONCE_STATIC_INIT 0
+# endif
+
+int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void));
+
+int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *));
+void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key);
+int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val);
+int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key);
+
+CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void);
+int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b);
+
+OSSL_LIB_CTX *OSSL_LIB_CTX_new(void);
+OSSL_LIB_CTX *OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE *handle,
+                                             const OSSL_DISPATCH *in);
+OSSL_LIB_CTX *OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE *handle,
+                                     const OSSL_DISPATCH *in);
+int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX *ctx, const char *config_file);
+void OSSL_LIB_CTX_free(OSSL_LIB_CTX *);
+OSSL_LIB_CTX *OSSL_LIB_CTX_get0_global_default(void);
+OSSL_LIB_CTX *OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX *libctx);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/cryptoerr.h b/CAPI/cpp/grpc/include/openssl/cryptoerr.h
new file mode 100644
index 0000000..c6a04d9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cryptoerr.h
@@ -0,0 +1,46 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CRYPTOERR_H
+# define OPENSSL_CRYPTOERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * CRYPTO reason codes.
+ */
+# define CRYPTO_R_BAD_ALGORITHM_NAME                      117
+# define CRYPTO_R_CONFLICTING_NAMES                       118
+# define CRYPTO_R_HEX_STRING_TOO_SHORT                    121
+# define CRYPTO_R_ILLEGAL_HEX_DIGIT                       102
+# define CRYPTO_R_INSUFFICIENT_DATA_SPACE                 106
+# define CRYPTO_R_INSUFFICIENT_PARAM_SIZE                 107
+# define CRYPTO_R_INSUFFICIENT_SECURE_DATA_SPACE          108
+# define CRYPTO_R_INVALID_NEGATIVE_VALUE                  122
+# define CRYPTO_R_INVALID_NULL_ARGUMENT                   109
+# define CRYPTO_R_INVALID_OSSL_PARAM_TYPE                 110
+# define CRYPTO_R_ODD_NUMBER_OF_DIGITS                    103
+# define CRYPTO_R_PROVIDER_ALREADY_EXISTS                 104
+# define CRYPTO_R_PROVIDER_SECTION_ERROR                  105
+# define CRYPTO_R_RANDOM_SECTION_ERROR                    119
+# define CRYPTO_R_SECURE_MALLOC_FAILURE                   111
+# define CRYPTO_R_STRING_TOO_LONG                         112
+# define CRYPTO_R_TOO_MANY_BYTES                          113
+# define CRYPTO_R_TOO_MANY_RECORDS                        114
+# define CRYPTO_R_TOO_SMALL_BUFFER                        116
+# define CRYPTO_R_UNKNOWN_NAME_IN_RANDOM_SECTION          120
+# define CRYPTO_R_ZERO_LENGTH_NUMBER                      115
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/cryptoerr_legacy.h b/CAPI/cpp/grpc/include/openssl/cryptoerr_legacy.h
new file mode 100644
index 0000000..ccab33a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cryptoerr_legacy.h
@@ -0,0 +1,1466 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * This header file preserves symbols from pre-3.0 OpenSSL.
+ * It should never be included directly, as it's already included
+ * by the public {lib}err.h headers, and since it will go away some
+ * time in the future.
+ */
+
+#ifndef OPENSSL_CRYPTOERR_LEGACY_H
+# define OPENSSL_CRYPTOERR_LEGACY_H
+# pragma once
+
+# include <openssl/macros.h>
+# include <openssl/symhacks.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ERR_load_ASN1_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_ASYNC_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_BIO_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_BN_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_BUF_strings(void);
+#  ifndef OPENSSL_NO_CMS
+OSSL_DEPRECATEDIN_3_0 int ERR_load_CMS_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_COMP
+OSSL_DEPRECATEDIN_3_0 int ERR_load_COMP_strings(void);
+#  endif
+OSSL_DEPRECATEDIN_3_0 int ERR_load_CONF_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_CRYPTO_strings(void);
+#  ifndef OPENSSL_NO_CT
+OSSL_DEPRECATEDIN_3_0 int ERR_load_CT_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_DH
+OSSL_DEPRECATEDIN_3_0 int ERR_load_DH_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_DSA
+OSSL_DEPRECATEDIN_3_0 int ERR_load_DSA_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_EC
+OSSL_DEPRECATEDIN_3_0 int ERR_load_EC_strings(void);
+#  endif
+#  ifndef OPENSSL_NO_ENGINE
+OSSL_DEPRECATEDIN_3_0 int ERR_load_ENGINE_strings(void);
+#  endif
+OSSL_DEPRECATEDIN_3_0 int ERR_load_ERR_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_EVP_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_KDF_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_OBJ_strings(void);
+#  ifndef OPENSSL_NO_OCSP
+OSSL_DEPRECATEDIN_3_0 int ERR_load_OCSP_strings(void);
+#  endif
+OSSL_DEPRECATEDIN_3_0 int ERR_load_PEM_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_PKCS12_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_PKCS7_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_RAND_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_RSA_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_OSSL_STORE_strings(void);
+#  ifndef OPENSSL_NO_TS
+OSSL_DEPRECATEDIN_3_0 int ERR_load_TS_strings(void);
+#  endif
+OSSL_DEPRECATEDIN_3_0 int ERR_load_UI_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_X509_strings(void);
+OSSL_DEPRECATEDIN_3_0 int ERR_load_X509V3_strings(void);
+
+/* Collected _F_ macros from OpenSSL 1.1.1 */
+
+/*
+ * ASN1 function codes.
+ */
+#  define ASN1_F_A2D_ASN1_OBJECT                           0
+#  define ASN1_F_A2I_ASN1_INTEGER                          0
+#  define ASN1_F_A2I_ASN1_STRING                           0
+#  define ASN1_F_APPEND_EXP                                0
+#  define ASN1_F_ASN1_BIO_INIT                             0
+#  define ASN1_F_ASN1_BIT_STRING_SET_BIT                   0
+#  define ASN1_F_ASN1_CB                                   0
+#  define ASN1_F_ASN1_CHECK_TLEN                           0
+#  define ASN1_F_ASN1_COLLECT                              0
+#  define ASN1_F_ASN1_D2I_EX_PRIMITIVE                     0
+#  define ASN1_F_ASN1_D2I_FP                               0
+#  define ASN1_F_ASN1_D2I_READ_BIO                         0
+#  define ASN1_F_ASN1_DIGEST                               0
+#  define ASN1_F_ASN1_DO_ADB                               0
+#  define ASN1_F_ASN1_DO_LOCK                              0
+#  define ASN1_F_ASN1_DUP                                  0
+#  define ASN1_F_ASN1_ENC_SAVE                             0
+#  define ASN1_F_ASN1_EX_C2I                               0
+#  define ASN1_F_ASN1_FIND_END                             0
+#  define ASN1_F_ASN1_GENERALIZEDTIME_ADJ                  0
+#  define ASN1_F_ASN1_GENERATE_V3                          0
+#  define ASN1_F_ASN1_GET_INT64                            0
+#  define ASN1_F_ASN1_GET_OBJECT                           0
+#  define ASN1_F_ASN1_GET_UINT64                           0
+#  define ASN1_F_ASN1_I2D_BIO                              0
+#  define ASN1_F_ASN1_I2D_FP                               0
+#  define ASN1_F_ASN1_ITEM_D2I_FP                          0
+#  define ASN1_F_ASN1_ITEM_DUP                             0
+#  define ASN1_F_ASN1_ITEM_EMBED_D2I                       0
+#  define ASN1_F_ASN1_ITEM_EMBED_NEW                       0
+#  define ASN1_F_ASN1_ITEM_FLAGS_I2D                       0
+#  define ASN1_F_ASN1_ITEM_I2D_BIO                         0
+#  define ASN1_F_ASN1_ITEM_I2D_FP                          0
+#  define ASN1_F_ASN1_ITEM_PACK                            0
+#  define ASN1_F_ASN1_ITEM_SIGN                            0
+#  define ASN1_F_ASN1_ITEM_SIGN_CTX                        0
+#  define ASN1_F_ASN1_ITEM_UNPACK                          0
+#  define ASN1_F_ASN1_ITEM_VERIFY                          0
+#  define ASN1_F_ASN1_MBSTRING_NCOPY                       0
+#  define ASN1_F_ASN1_OBJECT_NEW                           0
+#  define ASN1_F_ASN1_OUTPUT_DATA                          0
+#  define ASN1_F_ASN1_PCTX_NEW                             0
+#  define ASN1_F_ASN1_PRIMITIVE_NEW                        0
+#  define ASN1_F_ASN1_SCTX_NEW                             0
+#  define ASN1_F_ASN1_SIGN                                 0
+#  define ASN1_F_ASN1_STR2TYPE                             0
+#  define ASN1_F_ASN1_STRING_GET_INT64                     0
+#  define ASN1_F_ASN1_STRING_GET_UINT64                    0
+#  define ASN1_F_ASN1_STRING_SET                           0
+#  define ASN1_F_ASN1_STRING_TABLE_ADD                     0
+#  define ASN1_F_ASN1_STRING_TO_BN                         0
+#  define ASN1_F_ASN1_STRING_TYPE_NEW                      0
+#  define ASN1_F_ASN1_TEMPLATE_EX_D2I                      0
+#  define ASN1_F_ASN1_TEMPLATE_NEW                         0
+#  define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I                   0
+#  define ASN1_F_ASN1_TIME_ADJ                             0
+#  define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING             0
+#  define ASN1_F_ASN1_TYPE_GET_OCTETSTRING                 0
+#  define ASN1_F_ASN1_UTCTIME_ADJ                          0
+#  define ASN1_F_ASN1_VERIFY                               0
+#  define ASN1_F_B64_READ_ASN1                             0
+#  define ASN1_F_B64_WRITE_ASN1                            0
+#  define ASN1_F_BIO_NEW_NDEF                              0
+#  define ASN1_F_BITSTR_CB                                 0
+#  define ASN1_F_BN_TO_ASN1_STRING                         0
+#  define ASN1_F_C2I_ASN1_BIT_STRING                       0
+#  define ASN1_F_C2I_ASN1_INTEGER                          0
+#  define ASN1_F_C2I_ASN1_OBJECT                           0
+#  define ASN1_F_C2I_IBUF                                  0
+#  define ASN1_F_C2I_UINT64_INT                            0
+#  define ASN1_F_COLLECT_DATA                              0
+#  define ASN1_F_D2I_ASN1_OBJECT                           0
+#  define ASN1_F_D2I_ASN1_UINTEGER                         0
+#  define ASN1_F_D2I_AUTOPRIVATEKEY                        0
+#  define ASN1_F_D2I_PRIVATEKEY                            0
+#  define ASN1_F_D2I_PUBLICKEY                             0
+#  define ASN1_F_DO_BUF                                    0
+#  define ASN1_F_DO_CREATE                                 0
+#  define ASN1_F_DO_DUMP                                   0
+#  define ASN1_F_DO_TCREATE                                0
+#  define ASN1_F_I2A_ASN1_OBJECT                           0
+#  define ASN1_F_I2D_ASN1_BIO_STREAM                       0
+#  define ASN1_F_I2D_ASN1_OBJECT                           0
+#  define ASN1_F_I2D_DSA_PUBKEY                            0
+#  define ASN1_F_I2D_EC_PUBKEY                             0
+#  define ASN1_F_I2D_PRIVATEKEY                            0
+#  define ASN1_F_I2D_PUBLICKEY                             0
+#  define ASN1_F_I2D_RSA_PUBKEY                            0
+#  define ASN1_F_LONG_C2I                                  0
+#  define ASN1_F_NDEF_PREFIX                               0
+#  define ASN1_F_NDEF_SUFFIX                               0
+#  define ASN1_F_OID_MODULE_INIT                           0
+#  define ASN1_F_PARSE_TAGGING                             0
+#  define ASN1_F_PKCS5_PBE2_SET_IV                         0
+#  define ASN1_F_PKCS5_PBE2_SET_SCRYPT                     0
+#  define ASN1_F_PKCS5_PBE_SET                             0
+#  define ASN1_F_PKCS5_PBE_SET0_ALGOR                      0
+#  define ASN1_F_PKCS5_PBKDF2_SET                          0
+#  define ASN1_F_PKCS5_SCRYPT_SET                          0
+#  define ASN1_F_SMIME_READ_ASN1                           0
+#  define ASN1_F_SMIME_TEXT                                0
+#  define ASN1_F_STABLE_GET                                0
+#  define ASN1_F_STBL_MODULE_INIT                          0
+#  define ASN1_F_UINT32_C2I                                0
+#  define ASN1_F_UINT32_NEW                                0
+#  define ASN1_F_UINT64_C2I                                0
+#  define ASN1_F_UINT64_NEW                                0
+#  define ASN1_F_X509_CRL_ADD0_REVOKED                     0
+#  define ASN1_F_X509_INFO_NEW                             0
+#  define ASN1_F_X509_NAME_ENCODE                          0
+#  define ASN1_F_X509_NAME_EX_D2I                          0
+#  define ASN1_F_X509_NAME_EX_NEW                          0
+#  define ASN1_F_X509_PKEY_NEW                             0
+
+/*
+ * ASYNC function codes.
+ */
+#  define ASYNC_F_ASYNC_CTX_NEW                            0
+#  define ASYNC_F_ASYNC_INIT_THREAD                        0
+#  define ASYNC_F_ASYNC_JOB_NEW                            0
+#  define ASYNC_F_ASYNC_PAUSE_JOB                          0
+#  define ASYNC_F_ASYNC_START_FUNC                         0
+#  define ASYNC_F_ASYNC_START_JOB                          0
+#  define ASYNC_F_ASYNC_WAIT_CTX_SET_WAIT_FD               0
+
+/*
+ * BIO function codes.
+ */
+#  define BIO_F_ACPT_STATE                                 0
+#  define BIO_F_ADDRINFO_WRAP                              0
+#  define BIO_F_ADDR_STRINGS                               0
+#  define BIO_F_BIO_ACCEPT                                 0
+#  define BIO_F_BIO_ACCEPT_EX                              0
+#  define BIO_F_BIO_ACCEPT_NEW                             0
+#  define BIO_F_BIO_ADDR_NEW                               0
+#  define BIO_F_BIO_BIND                                   0
+#  define BIO_F_BIO_CALLBACK_CTRL                          0
+#  define BIO_F_BIO_CONNECT                                0
+#  define BIO_F_BIO_CONNECT_NEW                            0
+#  define BIO_F_BIO_CTRL                                   0
+#  define BIO_F_BIO_GETS                                   0
+#  define BIO_F_BIO_GET_HOST_IP                            0
+#  define BIO_F_BIO_GET_NEW_INDEX                          0
+#  define BIO_F_BIO_GET_PORT                               0
+#  define BIO_F_BIO_LISTEN                                 0
+#  define BIO_F_BIO_LOOKUP                                 0
+#  define BIO_F_BIO_LOOKUP_EX                              0
+#  define BIO_F_BIO_MAKE_PAIR                              0
+#  define BIO_F_BIO_METH_NEW                               0
+#  define BIO_F_BIO_NEW                                    0
+#  define BIO_F_BIO_NEW_DGRAM_SCTP                         0
+#  define BIO_F_BIO_NEW_FILE                               0
+#  define BIO_F_BIO_NEW_MEM_BUF                            0
+#  define BIO_F_BIO_NREAD                                  0
+#  define BIO_F_BIO_NREAD0                                 0
+#  define BIO_F_BIO_NWRITE                                 0
+#  define BIO_F_BIO_NWRITE0                                0
+#  define BIO_F_BIO_PARSE_HOSTSERV                         0
+#  define BIO_F_BIO_PUTS                                   0
+#  define BIO_F_BIO_READ                                   0
+#  define BIO_F_BIO_READ_EX                                0
+#  define BIO_F_BIO_READ_INTERN                            0
+#  define BIO_F_BIO_SOCKET                                 0
+#  define BIO_F_BIO_SOCKET_NBIO                            0
+#  define BIO_F_BIO_SOCK_INFO                              0
+#  define BIO_F_BIO_SOCK_INIT                              0
+#  define BIO_F_BIO_WRITE                                  0
+#  define BIO_F_BIO_WRITE_EX                               0
+#  define BIO_F_BIO_WRITE_INTERN                           0
+#  define BIO_F_BUFFER_CTRL                                0
+#  define BIO_F_CONN_CTRL                                  0
+#  define BIO_F_CONN_STATE                                 0
+#  define BIO_F_DGRAM_SCTP_NEW                             0
+#  define BIO_F_DGRAM_SCTP_READ                            0
+#  define BIO_F_DGRAM_SCTP_WRITE                           0
+#  define BIO_F_DOAPR_OUTCH                                0
+#  define BIO_F_FILE_CTRL                                  0
+#  define BIO_F_FILE_READ                                  0
+#  define BIO_F_LINEBUFFER_CTRL                            0
+#  define BIO_F_LINEBUFFER_NEW                             0
+#  define BIO_F_MEM_WRITE                                  0
+#  define BIO_F_NBIOF_NEW                                  0
+#  define BIO_F_SLG_WRITE                                  0
+#  define BIO_F_SSL_NEW                                    0
+
+/*
+ * BN function codes.
+ */
+#  define BN_F_BNRAND                                      0
+#  define BN_F_BNRAND_RANGE                                0
+#  define BN_F_BN_BLINDING_CONVERT_EX                      0
+#  define BN_F_BN_BLINDING_CREATE_PARAM                    0
+#  define BN_F_BN_BLINDING_INVERT_EX                       0
+#  define BN_F_BN_BLINDING_NEW                             0
+#  define BN_F_BN_BLINDING_UPDATE                          0
+#  define BN_F_BN_BN2DEC                                   0
+#  define BN_F_BN_BN2HEX                                   0
+#  define BN_F_BN_COMPUTE_WNAF                             0
+#  define BN_F_BN_CTX_GET                                  0
+#  define BN_F_BN_CTX_NEW                                  0
+#  define BN_F_BN_CTX_START                                0
+#  define BN_F_BN_DIV                                      0
+#  define BN_F_BN_DIV_RECP                                 0
+#  define BN_F_BN_EXP                                      0
+#  define BN_F_BN_EXPAND_INTERNAL                          0
+#  define BN_F_BN_GENCB_NEW                                0
+#  define BN_F_BN_GENERATE_DSA_NONCE                       0
+#  define BN_F_BN_GENERATE_PRIME_EX                        0
+#  define BN_F_BN_GF2M_MOD                                 0
+#  define BN_F_BN_GF2M_MOD_EXP                             0
+#  define BN_F_BN_GF2M_MOD_MUL                             0
+#  define BN_F_BN_GF2M_MOD_SOLVE_QUAD                      0
+#  define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR                  0
+#  define BN_F_BN_GF2M_MOD_SQR                             0
+#  define BN_F_BN_GF2M_MOD_SQRT                            0
+#  define BN_F_BN_LSHIFT                                   0
+#  define BN_F_BN_MOD_EXP2_MONT                            0
+#  define BN_F_BN_MOD_EXP_MONT                             0
+#  define BN_F_BN_MOD_EXP_MONT_CONSTTIME                   0
+#  define BN_F_BN_MOD_EXP_MONT_WORD                        0
+#  define BN_F_BN_MOD_EXP_RECP                             0
+#  define BN_F_BN_MOD_EXP_SIMPLE                           0
+#  define BN_F_BN_MOD_INVERSE                              0
+#  define BN_F_BN_MOD_INVERSE_NO_BRANCH                    0
+#  define BN_F_BN_MOD_LSHIFT_QUICK                         0
+#  define BN_F_BN_MOD_SQRT                                 0
+#  define BN_F_BN_MONT_CTX_NEW                             0
+#  define BN_F_BN_MPI2BN                                   0
+#  define BN_F_BN_NEW                                      0
+#  define BN_F_BN_POOL_GET                                 0
+#  define BN_F_BN_RAND                                     0
+#  define BN_F_BN_RAND_RANGE                               0
+#  define BN_F_BN_RECP_CTX_NEW                             0
+#  define BN_F_BN_RSHIFT                                   0
+#  define BN_F_BN_SET_WORDS                                0
+#  define BN_F_BN_STACK_PUSH                               0
+#  define BN_F_BN_USUB                                     0
+
+/*
+ * BUF function codes.
+ */
+#  define BUF_F_BUF_MEM_GROW                               0
+#  define BUF_F_BUF_MEM_GROW_CLEAN                         0
+#  define BUF_F_BUF_MEM_NEW                                0
+
+#  ifndef OPENSSL_NO_CMS
+/*
+ * CMS function codes.
+ */
+#   define CMS_F_CHECK_CONTENT                              0
+#   define CMS_F_CMS_ADD0_CERT                              0
+#   define CMS_F_CMS_ADD0_RECIPIENT_KEY                     0
+#   define CMS_F_CMS_ADD0_RECIPIENT_PASSWORD                0
+#   define CMS_F_CMS_ADD1_RECEIPTREQUEST                    0
+#   define CMS_F_CMS_ADD1_RECIPIENT_CERT                    0
+#   define CMS_F_CMS_ADD1_SIGNER                            0
+#   define CMS_F_CMS_ADD1_SIGNINGTIME                       0
+#   define CMS_F_CMS_COMPRESS                               0
+#   define CMS_F_CMS_COMPRESSEDDATA_CREATE                  0
+#   define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO                0
+#   define CMS_F_CMS_COPY_CONTENT                           0
+#   define CMS_F_CMS_COPY_MESSAGEDIGEST                     0
+#   define CMS_F_CMS_DATA                                   0
+#   define CMS_F_CMS_DATAFINAL                              0
+#   define CMS_F_CMS_DATAINIT                               0
+#   define CMS_F_CMS_DECRYPT                                0
+#   define CMS_F_CMS_DECRYPT_SET1_KEY                       0
+#   define CMS_F_CMS_DECRYPT_SET1_PASSWORD                  0
+#   define CMS_F_CMS_DECRYPT_SET1_PKEY                      0
+#   define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX               0
+#   define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO               0
+#   define CMS_F_CMS_DIGESTEDDATA_DO_FINAL                  0
+#   define CMS_F_CMS_DIGEST_VERIFY                          0
+#   define CMS_F_CMS_ENCODE_RECEIPT                         0
+#   define CMS_F_CMS_ENCRYPT                                0
+#   define CMS_F_CMS_ENCRYPTEDCONTENT_INIT                  0
+#   define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO              0
+#   define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT                  0
+#   define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT                  0
+#   define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY                 0
+#   define CMS_F_CMS_ENVELOPEDDATA_CREATE                   0
+#   define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO                 0
+#   define CMS_F_CMS_ENVELOPED_DATA_INIT                    0
+#   define CMS_F_CMS_ENV_ASN1_CTRL                          0
+#   define CMS_F_CMS_FINAL                                  0
+#   define CMS_F_CMS_GET0_CERTIFICATE_CHOICES               0
+#   define CMS_F_CMS_GET0_CONTENT                           0
+#   define CMS_F_CMS_GET0_ECONTENT_TYPE                     0
+#   define CMS_F_CMS_GET0_ENVELOPED                         0
+#   define CMS_F_CMS_GET0_REVOCATION_CHOICES                0
+#   define CMS_F_CMS_GET0_SIGNED                            0
+#   define CMS_F_CMS_MSGSIGDIGEST_ADD1                      0
+#   define CMS_F_CMS_RECEIPTREQUEST_CREATE0                 0
+#   define CMS_F_CMS_RECEIPT_VERIFY                         0
+#   define CMS_F_CMS_RECIPIENTINFO_DECRYPT                  0
+#   define CMS_F_CMS_RECIPIENTINFO_ENCRYPT                  0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_ENCRYPT             0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ALG            0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ORIG_ID        0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_REKS           0
+#   define CMS_F_CMS_RECIPIENTINFO_KARI_ORIG_ID_CMP         0
+#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT            0
+#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT            0
+#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID            0
+#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP             0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP            0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT             0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT             0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS           0
+#   define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID      0
+#   define CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT               0
+#   define CMS_F_CMS_RECIPIENTINFO_SET0_KEY                 0
+#   define CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD            0
+#   define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY                0
+#   define CMS_F_CMS_SD_ASN1_CTRL                           0
+#   define CMS_F_CMS_SET1_IAS                               0
+#   define CMS_F_CMS_SET1_KEYID                             0
+#   define CMS_F_CMS_SET1_SIGNERIDENTIFIER                  0
+#   define CMS_F_CMS_SET_DETACHED                           0
+#   define CMS_F_CMS_SIGN                                   0
+#   define CMS_F_CMS_SIGNED_DATA_INIT                       0
+#   define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN                0
+#   define CMS_F_CMS_SIGNERINFO_SIGN                        0
+#   define CMS_F_CMS_SIGNERINFO_VERIFY                      0
+#   define CMS_F_CMS_SIGNERINFO_VERIFY_CERT                 0
+#   define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT              0
+#   define CMS_F_CMS_SIGN_RECEIPT                           0
+#   define CMS_F_CMS_SI_CHECK_ATTRIBUTES                    0
+#   define CMS_F_CMS_STREAM                                 0
+#   define CMS_F_CMS_UNCOMPRESS                             0
+#   define CMS_F_CMS_VERIFY                                 0
+#   define CMS_F_KEK_UNWRAP_KEY                             0
+#  endif
+
+#  ifndef OPENSSL_NO_COMP
+/*
+ * COMP function codes.
+ */
+#   define COMP_F_BIO_ZLIB_FLUSH                            0
+#   define COMP_F_BIO_ZLIB_NEW                              0
+#   define COMP_F_BIO_ZLIB_READ                             0
+#   define COMP_F_BIO_ZLIB_WRITE                            0
+#   define COMP_F_COMP_CTX_NEW                              0
+#  endif
+
+/*
+ * CONF function codes.
+ */
+#  define CONF_F_CONF_DUMP_FP                              0
+#  define CONF_F_CONF_LOAD                                 0
+#  define CONF_F_CONF_LOAD_FP                              0
+#  define CONF_F_CONF_PARSE_LIST                           0
+#  define CONF_F_DEF_LOAD                                  0
+#  define CONF_F_DEF_LOAD_BIO                              0
+#  define CONF_F_GET_NEXT_FILE                             0
+#  define CONF_F_MODULE_ADD                                0
+#  define CONF_F_MODULE_INIT                               0
+#  define CONF_F_MODULE_LOAD_DSO                           0
+#  define CONF_F_MODULE_RUN                                0
+#  define CONF_F_NCONF_DUMP_BIO                            0
+#  define CONF_F_NCONF_DUMP_FP                             0
+#  define CONF_F_NCONF_GET_NUMBER_E                        0
+#  define CONF_F_NCONF_GET_SECTION                         0
+#  define CONF_F_NCONF_GET_STRING                          0
+#  define CONF_F_NCONF_LOAD                                0
+#  define CONF_F_NCONF_LOAD_BIO                            0
+#  define CONF_F_NCONF_LOAD_FP                             0
+#  define CONF_F_NCONF_NEW                                 0
+#  define CONF_F_PROCESS_INCLUDE                           0
+#  define CONF_F_SSL_MODULE_INIT                           0
+#  define CONF_F_STR_COPY                                  0
+
+/*
+ * CRYPTO function codes.
+ */
+#  define CRYPTO_F_CMAC_CTX_NEW                            0
+#  define CRYPTO_F_CRYPTO_DUP_EX_DATA                      0
+#  define CRYPTO_F_CRYPTO_FREE_EX_DATA                     0
+#  define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX                 0
+#  define CRYPTO_F_CRYPTO_MEMDUP                           0
+#  define CRYPTO_F_CRYPTO_NEW_EX_DATA                      0
+#  define CRYPTO_F_CRYPTO_OCB128_COPY_CTX                  0
+#  define CRYPTO_F_CRYPTO_OCB128_INIT                      0
+#  define CRYPTO_F_CRYPTO_SET_EX_DATA                      0
+#  define CRYPTO_F_GET_AND_LOCK                            0
+#  define CRYPTO_F_OPENSSL_ATEXIT                          0
+#  define CRYPTO_F_OPENSSL_BUF2HEXSTR                      0
+#  define CRYPTO_F_OPENSSL_FOPEN                           0
+#  define CRYPTO_F_OPENSSL_HEXSTR2BUF                      0
+#  define CRYPTO_F_OPENSSL_INIT_CRYPTO                     0
+#  define CRYPTO_F_OPENSSL_LH_NEW                          0
+#  define CRYPTO_F_OPENSSL_SK_DEEP_COPY                    0
+#  define CRYPTO_F_OPENSSL_SK_DUP                          0
+#  define CRYPTO_F_PKEY_HMAC_INIT                          0
+#  define CRYPTO_F_PKEY_POLY1305_INIT                      0
+#  define CRYPTO_F_PKEY_SIPHASH_INIT                       0
+#  define CRYPTO_F_SK_RESERVE                              0
+
+#  ifndef OPENSSL_NO_CT
+/*
+ * CT function codes.
+ */
+#   define CT_F_CTLOG_NEW                                   0
+#   define CT_F_CTLOG_NEW_FROM_BASE64                       0
+#   define CT_F_CTLOG_NEW_FROM_CONF                         0
+#   define CT_F_CTLOG_STORE_LOAD_CTX_NEW                    0
+#   define CT_F_CTLOG_STORE_LOAD_FILE                       0
+#   define CT_F_CTLOG_STORE_LOAD_LOG                        0
+#   define CT_F_CTLOG_STORE_NEW                             0
+#   define CT_F_CT_BASE64_DECODE                            0
+#   define CT_F_CT_POLICY_EVAL_CTX_NEW                      0
+#   define CT_F_CT_V1_LOG_ID_FROM_PKEY                      0
+#   define CT_F_I2O_SCT                                     0
+#   define CT_F_I2O_SCT_LIST                                0
+#   define CT_F_I2O_SCT_SIGNATURE                           0
+#   define CT_F_O2I_SCT                                     0
+#   define CT_F_O2I_SCT_LIST                                0
+#   define CT_F_O2I_SCT_SIGNATURE                           0
+#   define CT_F_SCT_CTX_NEW                                 0
+#   define CT_F_SCT_CTX_VERIFY                              0
+#   define CT_F_SCT_NEW                                     0
+#   define CT_F_SCT_NEW_FROM_BASE64                         0
+#   define CT_F_SCT_SET0_LOG_ID                             0
+#   define CT_F_SCT_SET1_EXTENSIONS                         0
+#   define CT_F_SCT_SET1_LOG_ID                             0
+#   define CT_F_SCT_SET1_SIGNATURE                          0
+#   define CT_F_SCT_SET_LOG_ENTRY_TYPE                      0
+#   define CT_F_SCT_SET_SIGNATURE_NID                       0
+#   define CT_F_SCT_SET_VERSION                             0
+#  endif
+
+#  ifndef OPENSSL_NO_DH
+/*
+ * DH function codes.
+ */
+#   define DH_F_COMPUTE_KEY                                 0
+#   define DH_F_DHPARAMS_PRINT_FP                           0
+#   define DH_F_DH_BUILTIN_GENPARAMS                        0
+#   define DH_F_DH_CHECK_EX                                 0
+#   define DH_F_DH_CHECK_PARAMS_EX                          0
+#   define DH_F_DH_CHECK_PUB_KEY_EX                         0
+#   define DH_F_DH_CMS_DECRYPT                              0
+#   define DH_F_DH_CMS_SET_PEERKEY                          0
+#   define DH_F_DH_CMS_SET_SHARED_INFO                      0
+#   define DH_F_DH_METH_DUP                                 0
+#   define DH_F_DH_METH_NEW                                 0
+#   define DH_F_DH_METH_SET1_NAME                           0
+#   define DH_F_DH_NEW_BY_NID                               0
+#   define DH_F_DH_NEW_METHOD                               0
+#   define DH_F_DH_PARAM_DECODE                             0
+#   define DH_F_DH_PKEY_PUBLIC_CHECK                        0
+#   define DH_F_DH_PRIV_DECODE                              0
+#   define DH_F_DH_PRIV_ENCODE                              0
+#   define DH_F_DH_PUB_DECODE                               0
+#   define DH_F_DH_PUB_ENCODE                               0
+#   define DH_F_DO_DH_PRINT                                 0
+#   define DH_F_GENERATE_KEY                                0
+#   define DH_F_PKEY_DH_CTRL_STR                            0
+#   define DH_F_PKEY_DH_DERIVE                              0
+#   define DH_F_PKEY_DH_INIT                                0
+#   define DH_F_PKEY_DH_KEYGEN                              0
+#  endif
+
+#  ifndef OPENSSL_NO_DSA
+/*
+ * DSA function codes.
+ */
+#   define DSA_F_DSAPARAMS_PRINT                            0
+#   define DSA_F_DSAPARAMS_PRINT_FP                         0
+#   define DSA_F_DSA_BUILTIN_PARAMGEN                       0
+#   define DSA_F_DSA_BUILTIN_PARAMGEN2                      0
+#   define DSA_F_DSA_DO_SIGN                                0
+#   define DSA_F_DSA_DO_VERIFY                              0
+#   define DSA_F_DSA_METH_DUP                               0
+#   define DSA_F_DSA_METH_NEW                               0
+#   define DSA_F_DSA_METH_SET1_NAME                         0
+#   define DSA_F_DSA_NEW_METHOD                             0
+#   define DSA_F_DSA_PARAM_DECODE                           0
+#   define DSA_F_DSA_PRINT_FP                               0
+#   define DSA_F_DSA_PRIV_DECODE                            0
+#   define DSA_F_DSA_PRIV_ENCODE                            0
+#   define DSA_F_DSA_PUB_DECODE                             0
+#   define DSA_F_DSA_PUB_ENCODE                             0
+#   define DSA_F_DSA_SIGN                                   0
+#   define DSA_F_DSA_SIGN_SETUP                             0
+#   define DSA_F_DSA_SIG_NEW                                0
+#   define DSA_F_OLD_DSA_PRIV_DECODE                        0
+#   define DSA_F_PKEY_DSA_CTRL                              0
+#   define DSA_F_PKEY_DSA_CTRL_STR                          0
+#   define DSA_F_PKEY_DSA_KEYGEN                            0
+#  endif
+
+#  ifndef OPENSSL_NO_EC
+/*
+ * EC function codes.
+ */
+#   define EC_F_BN_TO_FELEM                                 0
+#   define EC_F_D2I_ECPARAMETERS                            0
+#   define EC_F_D2I_ECPKPARAMETERS                          0
+#   define EC_F_D2I_ECPRIVATEKEY                            0
+#   define EC_F_DO_EC_KEY_PRINT                             0
+#   define EC_F_ECDH_CMS_DECRYPT                            0
+#   define EC_F_ECDH_CMS_SET_SHARED_INFO                    0
+#   define EC_F_ECDH_COMPUTE_KEY                            0
+#   define EC_F_ECDH_SIMPLE_COMPUTE_KEY                     0
+#   define EC_F_ECDSA_DO_SIGN_EX                            0
+#   define EC_F_ECDSA_DO_VERIFY                             0
+#   define EC_F_ECDSA_SIGN_EX                               0
+#   define EC_F_ECDSA_SIGN_SETUP                            0
+#   define EC_F_ECDSA_SIG_NEW                               0
+#   define EC_F_ECDSA_VERIFY                                0
+#   define EC_F_ECD_ITEM_VERIFY                             0
+#   define EC_F_ECKEY_PARAM2TYPE                            0
+#   define EC_F_ECKEY_PARAM_DECODE                          0
+#   define EC_F_ECKEY_PRIV_DECODE                           0
+#   define EC_F_ECKEY_PRIV_ENCODE                           0
+#   define EC_F_ECKEY_PUB_DECODE                            0
+#   define EC_F_ECKEY_PUB_ENCODE                            0
+#   define EC_F_ECKEY_TYPE2PARAM                            0
+#   define EC_F_ECPARAMETERS_PRINT                          0
+#   define EC_F_ECPARAMETERS_PRINT_FP                       0
+#   define EC_F_ECPKPARAMETERS_PRINT                        0
+#   define EC_F_ECPKPARAMETERS_PRINT_FP                     0
+#   define EC_F_ECP_NISTZ256_GET_AFFINE                     0
+#   define EC_F_ECP_NISTZ256_INV_MOD_ORD                    0
+#   define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE                0
+#   define EC_F_ECP_NISTZ256_POINTS_MUL                     0
+#   define EC_F_ECP_NISTZ256_PRE_COMP_NEW                   0
+#   define EC_F_ECP_NISTZ256_WINDOWED_MUL                   0
+#   define EC_F_ECX_KEY_OP                                  0
+#   define EC_F_ECX_PRIV_ENCODE                             0
+#   define EC_F_ECX_PUB_ENCODE                              0
+#   define EC_F_EC_ASN1_GROUP2CURVE                         0
+#   define EC_F_EC_ASN1_GROUP2FIELDID                       0
+#   define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY           0
+#   define EC_F_EC_GF2M_SIMPLE_FIELD_INV                    0
+#   define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT     0
+#   define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE              0
+#   define EC_F_EC_GF2M_SIMPLE_LADDER_POST                  0
+#   define EC_F_EC_GF2M_SIMPLE_LADDER_PRE                   0
+#   define EC_F_EC_GF2M_SIMPLE_OCT2POINT                    0
+#   define EC_F_EC_GF2M_SIMPLE_POINT2OCT                    0
+#   define EC_F_EC_GF2M_SIMPLE_POINTS_MUL                   0
+#   define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES   0
+#   define EC_F_EC_GFP_MONT_FIELD_DECODE                    0
+#   define EC_F_EC_GFP_MONT_FIELD_ENCODE                    0
+#   define EC_F_EC_GFP_MONT_FIELD_INV                       0
+#   define EC_F_EC_GFP_MONT_FIELD_MUL                       0
+#   define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE                0
+#   define EC_F_EC_GFP_MONT_FIELD_SQR                       0
+#   define EC_F_EC_GFP_MONT_GROUP_SET_CURVE                 0
+#   define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE             0
+#   define EC_F_EC_GFP_NISTP224_POINTS_MUL                  0
+#   define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE             0
+#   define EC_F_EC_GFP_NISTP256_POINTS_MUL                  0
+#   define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE             0
+#   define EC_F_EC_GFP_NISTP521_POINTS_MUL                  0
+#   define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 0
+#   define EC_F_EC_GFP_NIST_FIELD_MUL                       0
+#   define EC_F_EC_GFP_NIST_FIELD_SQR                       0
+#   define EC_F_EC_GFP_NIST_GROUP_SET_CURVE                 0
+#   define EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES             0
+#   define EC_F_EC_GFP_SIMPLE_FIELD_INV                     0
+#   define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT      0
+#   define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE               0
+#   define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE                   0
+#   define EC_F_EC_GFP_SIMPLE_OCT2POINT                     0
+#   define EC_F_EC_GFP_SIMPLE_POINT2OCT                     0
+#   define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE            0
+#   define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES  0
+#   define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES  0
+#   define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES    0
+#   define EC_F_EC_GROUP_CHECK                              0
+#   define EC_F_EC_GROUP_CHECK_DISCRIMINANT                 0
+#   define EC_F_EC_GROUP_COPY                               0
+#   define EC_F_EC_GROUP_GET_CURVE                          0
+#   define EC_F_EC_GROUP_GET_CURVE_GF2M                     0
+#   define EC_F_EC_GROUP_GET_CURVE_GFP                      0
+#   define EC_F_EC_GROUP_GET_DEGREE                         0
+#   define EC_F_EC_GROUP_GET_ECPARAMETERS                   0
+#   define EC_F_EC_GROUP_GET_ECPKPARAMETERS                 0
+#   define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS              0
+#   define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS                0
+#   define EC_F_EC_GROUP_NEW                                0
+#   define EC_F_EC_GROUP_NEW_BY_CURVE_NAME                  0
+#   define EC_F_EC_GROUP_NEW_FROM_DATA                      0
+#   define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS              0
+#   define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS            0
+#   define EC_F_EC_GROUP_SET_CURVE                          0
+#   define EC_F_EC_GROUP_SET_CURVE_GF2M                     0
+#   define EC_F_EC_GROUP_SET_CURVE_GFP                      0
+#   define EC_F_EC_GROUP_SET_GENERATOR                      0
+#   define EC_F_EC_GROUP_SET_SEED                           0
+#   define EC_F_EC_KEY_CHECK_KEY                            0
+#   define EC_F_EC_KEY_COPY                                 0
+#   define EC_F_EC_KEY_GENERATE_KEY                         0
+#   define EC_F_EC_KEY_NEW                                  0
+#   define EC_F_EC_KEY_NEW_METHOD                           0
+#   define EC_F_EC_KEY_OCT2PRIV                             0
+#   define EC_F_EC_KEY_PRINT                                0
+#   define EC_F_EC_KEY_PRINT_FP                             0
+#   define EC_F_EC_KEY_PRIV2BUF                             0
+#   define EC_F_EC_KEY_PRIV2OCT                             0
+#   define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES    0
+#   define EC_F_EC_KEY_SIMPLE_CHECK_KEY                     0
+#   define EC_F_EC_KEY_SIMPLE_OCT2PRIV                      0
+#   define EC_F_EC_KEY_SIMPLE_PRIV2OCT                      0
+#   define EC_F_EC_PKEY_CHECK                               0
+#   define EC_F_EC_PKEY_PARAM_CHECK                         0
+#   define EC_F_EC_POINTS_MAKE_AFFINE                       0
+#   define EC_F_EC_POINTS_MUL                               0
+#   define EC_F_EC_POINT_ADD                                0
+#   define EC_F_EC_POINT_BN2POINT                           0
+#   define EC_F_EC_POINT_CMP                                0
+#   define EC_F_EC_POINT_COPY                               0
+#   define EC_F_EC_POINT_DBL                                0
+#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES             0
+#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M        0
+#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP         0
+#   define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP    0
+#   define EC_F_EC_POINT_INVERT                             0
+#   define EC_F_EC_POINT_IS_AT_INFINITY                     0
+#   define EC_F_EC_POINT_IS_ON_CURVE                        0
+#   define EC_F_EC_POINT_MAKE_AFFINE                        0
+#   define EC_F_EC_POINT_NEW                                0
+#   define EC_F_EC_POINT_OCT2POINT                          0
+#   define EC_F_EC_POINT_POINT2BUF                          0
+#   define EC_F_EC_POINT_POINT2OCT                          0
+#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES             0
+#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M        0
+#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP         0
+#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES         0
+#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M    0
+#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP     0
+#   define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP    0
+#   define EC_F_EC_POINT_SET_TO_INFINITY                    0
+#   define EC_F_EC_PRE_COMP_NEW                             0
+#   define EC_F_EC_SCALAR_MUL_LADDER                        0
+#   define EC_F_EC_WNAF_MUL                                 0
+#   define EC_F_EC_WNAF_PRECOMPUTE_MULT                     0
+#   define EC_F_I2D_ECPARAMETERS                            0
+#   define EC_F_I2D_ECPKPARAMETERS                          0
+#   define EC_F_I2D_ECPRIVATEKEY                            0
+#   define EC_F_I2O_ECPUBLICKEY                             0
+#   define EC_F_NISTP224_PRE_COMP_NEW                       0
+#   define EC_F_NISTP256_PRE_COMP_NEW                       0
+#   define EC_F_NISTP521_PRE_COMP_NEW                       0
+#   define EC_F_O2I_ECPUBLICKEY                             0
+#   define EC_F_OLD_EC_PRIV_DECODE                          0
+#   define EC_F_OSSL_ECDH_COMPUTE_KEY                       0
+#   define EC_F_OSSL_ECDSA_SIGN_SIG                         0
+#   define EC_F_OSSL_ECDSA_VERIFY_SIG                       0
+#   define EC_F_PKEY_ECD_CTRL                               0
+#   define EC_F_PKEY_ECD_DIGESTSIGN                         0
+#   define EC_F_PKEY_ECD_DIGESTSIGN25519                    0
+#   define EC_F_PKEY_ECD_DIGESTSIGN448                      0
+#   define EC_F_PKEY_ECX_DERIVE                             0
+#   define EC_F_PKEY_EC_CTRL                                0
+#   define EC_F_PKEY_EC_CTRL_STR                            0
+#   define EC_F_PKEY_EC_DERIVE                              0
+#   define EC_F_PKEY_EC_INIT                                0
+#   define EC_F_PKEY_EC_KDF_DERIVE                          0
+#   define EC_F_PKEY_EC_KEYGEN                              0
+#   define EC_F_PKEY_EC_PARAMGEN                            0
+#   define EC_F_PKEY_EC_SIGN                                0
+#   define EC_F_VALIDATE_ECX_DERIVE                         0
+#  endif
+
+#  ifndef OPENSSL_NO_ENGINE
+/*
+ * ENGINE function codes.
+ */
+#   define ENGINE_F_DIGEST_UPDATE                           0
+#   define ENGINE_F_DYNAMIC_CTRL                            0
+#   define ENGINE_F_DYNAMIC_GET_DATA_CTX                    0
+#   define ENGINE_F_DYNAMIC_LOAD                            0
+#   define ENGINE_F_DYNAMIC_SET_DATA_CTX                    0
+#   define ENGINE_F_ENGINE_ADD                              0
+#   define ENGINE_F_ENGINE_BY_ID                            0
+#   define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE                0
+#   define ENGINE_F_ENGINE_CTRL                             0
+#   define ENGINE_F_ENGINE_CTRL_CMD                         0
+#   define ENGINE_F_ENGINE_CTRL_CMD_STRING                  0
+#   define ENGINE_F_ENGINE_FINISH                           0
+#   define ENGINE_F_ENGINE_GET_CIPHER                       0
+#   define ENGINE_F_ENGINE_GET_DIGEST                       0
+#   define ENGINE_F_ENGINE_GET_FIRST                        0
+#   define ENGINE_F_ENGINE_GET_LAST                         0
+#   define ENGINE_F_ENGINE_GET_NEXT                         0
+#   define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH               0
+#   define ENGINE_F_ENGINE_GET_PKEY_METH                    0
+#   define ENGINE_F_ENGINE_GET_PREV                         0
+#   define ENGINE_F_ENGINE_INIT                             0
+#   define ENGINE_F_ENGINE_LIST_ADD                         0
+#   define ENGINE_F_ENGINE_LIST_REMOVE                      0
+#   define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY                 0
+#   define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY                  0
+#   define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT             0
+#   define ENGINE_F_ENGINE_NEW                              0
+#   define ENGINE_F_ENGINE_PKEY_ASN1_FIND_STR               0
+#   define ENGINE_F_ENGINE_REMOVE                           0
+#   define ENGINE_F_ENGINE_SET_DEFAULT_STRING               0
+#   define ENGINE_F_ENGINE_SET_ID                           0
+#   define ENGINE_F_ENGINE_SET_NAME                         0
+#   define ENGINE_F_ENGINE_TABLE_REGISTER                   0
+#   define ENGINE_F_ENGINE_UNLOCKED_FINISH                  0
+#   define ENGINE_F_ENGINE_UP_REF                           0
+#   define ENGINE_F_INT_CLEANUP_ITEM                        0
+#   define ENGINE_F_INT_CTRL_HELPER                         0
+#   define ENGINE_F_INT_ENGINE_CONFIGURE                    0
+#   define ENGINE_F_INT_ENGINE_MODULE_INIT                  0
+#   define ENGINE_F_OSSL_HMAC_INIT                          0
+#  endif
+
+/*
+ * EVP function codes.
+ */
+#  define EVP_F_AESNI_INIT_KEY                             0
+#  define EVP_F_AESNI_XTS_INIT_KEY                         0
+#  define EVP_F_AES_GCM_CTRL                               0
+#  define EVP_F_AES_INIT_KEY                               0
+#  define EVP_F_AES_OCB_CIPHER                             0
+#  define EVP_F_AES_T4_INIT_KEY                            0
+#  define EVP_F_AES_T4_XTS_INIT_KEY                        0
+#  define EVP_F_AES_WRAP_CIPHER                            0
+#  define EVP_F_AES_XTS_INIT_KEY                           0
+#  define EVP_F_ALG_MODULE_INIT                            0
+#  define EVP_F_ARIA_CCM_INIT_KEY                          0
+#  define EVP_F_ARIA_GCM_CTRL                              0
+#  define EVP_F_ARIA_GCM_INIT_KEY                          0
+#  define EVP_F_ARIA_INIT_KEY                              0
+#  define EVP_F_B64_NEW                                    0
+#  define EVP_F_CAMELLIA_INIT_KEY                          0
+#  define EVP_F_CHACHA20_POLY1305_CTRL                     0
+#  define EVP_F_CMLL_T4_INIT_KEY                           0
+#  define EVP_F_DES_EDE3_WRAP_CIPHER                       0
+#  define EVP_F_DO_SIGVER_INIT                             0
+#  define EVP_F_ENC_NEW                                    0
+#  define EVP_F_EVP_CIPHERINIT_EX                          0
+#  define EVP_F_EVP_CIPHER_ASN1_TO_PARAM                   0
+#  define EVP_F_EVP_CIPHER_CTX_COPY                        0
+#  define EVP_F_EVP_CIPHER_CTX_CTRL                        0
+#  define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH              0
+#  define EVP_F_EVP_CIPHER_PARAM_TO_ASN1                   0
+#  define EVP_F_EVP_DECRYPTFINAL_EX                        0
+#  define EVP_F_EVP_DECRYPTUPDATE                          0
+#  define EVP_F_EVP_DIGESTFINALXOF                         0
+#  define EVP_F_EVP_DIGESTINIT_EX                          0
+#  define EVP_F_EVP_ENCRYPTDECRYPTUPDATE                   0
+#  define EVP_F_EVP_ENCRYPTFINAL_EX                        0
+#  define EVP_F_EVP_ENCRYPTUPDATE                          0
+#  define EVP_F_EVP_MD_CTX_COPY_EX                         0
+#  define EVP_F_EVP_MD_SIZE                                0
+#  define EVP_F_EVP_OPENINIT                               0
+#  define EVP_F_EVP_PBE_ALG_ADD                            0
+#  define EVP_F_EVP_PBE_ALG_ADD_TYPE                       0
+#  define EVP_F_EVP_PBE_CIPHERINIT                         0
+#  define EVP_F_EVP_PBE_SCRYPT                             0
+#  define EVP_F_EVP_PKCS82PKEY                             0
+#  define EVP_F_EVP_PKEY2PKCS8                             0
+#  define EVP_F_EVP_PKEY_ASN1_ADD0                         0
+#  define EVP_F_EVP_PKEY_CHECK                             0
+#  define EVP_F_EVP_PKEY_COPY_PARAMETERS                   0
+#  define EVP_F_EVP_PKEY_CTX_CTRL                          0
+#  define EVP_F_EVP_PKEY_CTX_CTRL_STR                      0
+#  define EVP_F_EVP_PKEY_CTX_DUP                           0
+#  define EVP_F_EVP_PKEY_CTX_MD                            0
+#  define EVP_F_EVP_PKEY_DECRYPT                           0
+#  define EVP_F_EVP_PKEY_DECRYPT_INIT                      0
+#  define EVP_F_EVP_PKEY_DECRYPT_OLD                       0
+#  define EVP_F_EVP_PKEY_DERIVE                            0
+#  define EVP_F_EVP_PKEY_DERIVE_INIT                       0
+#  define EVP_F_EVP_PKEY_DERIVE_SET_PEER                   0
+#  define EVP_F_EVP_PKEY_ENCRYPT                           0
+#  define EVP_F_EVP_PKEY_ENCRYPT_INIT                      0
+#  define EVP_F_EVP_PKEY_ENCRYPT_OLD                       0
+#  define EVP_F_EVP_PKEY_GET0_DH                           0
+#  define EVP_F_EVP_PKEY_GET0_DSA                          0
+#  define EVP_F_EVP_PKEY_GET0_EC_KEY                       0
+#  define EVP_F_EVP_PKEY_GET0_HMAC                         0
+#  define EVP_F_EVP_PKEY_GET0_POLY1305                     0
+#  define EVP_F_EVP_PKEY_GET0_RSA                          0
+#  define EVP_F_EVP_PKEY_GET0_SIPHASH                      0
+#  define EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY               0
+#  define EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY                0
+#  define EVP_F_EVP_PKEY_KEYGEN                            0
+#  define EVP_F_EVP_PKEY_KEYGEN_INIT                       0
+#  define EVP_F_EVP_PKEY_METH_ADD0                         0
+#  define EVP_F_EVP_PKEY_METH_NEW                          0
+#  define EVP_F_EVP_PKEY_NEW                               0
+#  define EVP_F_EVP_PKEY_NEW_CMAC_KEY                      0
+#  define EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY               0
+#  define EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY                0
+#  define EVP_F_EVP_PKEY_PARAMGEN                          0
+#  define EVP_F_EVP_PKEY_PARAMGEN_INIT                     0
+#  define EVP_F_EVP_PKEY_PARAM_CHECK                       0
+#  define EVP_F_EVP_PKEY_PUBLIC_CHECK                      0
+#  define EVP_F_EVP_PKEY_SET1_ENGINE                       0
+#  define EVP_F_EVP_PKEY_SET_ALIAS_TYPE                    0
+#  define EVP_F_EVP_PKEY_SIGN                              0
+#  define EVP_F_EVP_PKEY_SIGN_INIT                         0
+#  define EVP_F_EVP_PKEY_VERIFY                            0
+#  define EVP_F_EVP_PKEY_VERIFY_INIT                       0
+#  define EVP_F_EVP_PKEY_VERIFY_RECOVER                    0
+#  define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT               0
+#  define EVP_F_EVP_SIGNFINAL                              0
+#  define EVP_F_EVP_VERIFYFINAL                            0
+#  define EVP_F_INT_CTX_NEW                                0
+#  define EVP_F_OK_NEW                                     0
+#  define EVP_F_PKCS5_PBE_KEYIVGEN                         0
+#  define EVP_F_PKCS5_V2_PBE_KEYIVGEN                      0
+#  define EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN                   0
+#  define EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN                   0
+#  define EVP_F_PKEY_SET_TYPE                              0
+#  define EVP_F_RC2_MAGIC_TO_METH                          0
+#  define EVP_F_RC5_CTRL                                   0
+#  define EVP_F_R_32_12_16_INIT_KEY                        0
+#  define EVP_F_S390X_AES_GCM_CTRL                         0
+#  define EVP_F_UPDATE                                     0
+
+/*
+ * KDF function codes.
+ */
+#  define KDF_F_PKEY_HKDF_CTRL_STR                         0
+#  define KDF_F_PKEY_HKDF_DERIVE                           0
+#  define KDF_F_PKEY_HKDF_INIT                             0
+#  define KDF_F_PKEY_SCRYPT_CTRL_STR                       0
+#  define KDF_F_PKEY_SCRYPT_CTRL_UINT64                    0
+#  define KDF_F_PKEY_SCRYPT_DERIVE                         0
+#  define KDF_F_PKEY_SCRYPT_INIT                           0
+#  define KDF_F_PKEY_SCRYPT_SET_MEMBUF                     0
+#  define KDF_F_PKEY_TLS1_PRF_CTRL_STR                     0
+#  define KDF_F_PKEY_TLS1_PRF_DERIVE                       0
+#  define KDF_F_PKEY_TLS1_PRF_INIT                         0
+#  define KDF_F_TLS1_PRF_ALG                               0
+
+/*
+ * KDF reason codes.
+ */
+#  define KDF_R_INVALID_DIGEST                             0
+#  define KDF_R_MISSING_ITERATION_COUNT                    0
+#  define KDF_R_MISSING_KEY                                0
+#  define KDF_R_MISSING_MESSAGE_DIGEST                     0
+#  define KDF_R_MISSING_PARAMETER                          0
+#  define KDF_R_MISSING_PASS                               0
+#  define KDF_R_MISSING_SALT                               0
+#  define KDF_R_MISSING_SECRET                             0
+#  define KDF_R_MISSING_SEED                               0
+#  define KDF_R_UNKNOWN_PARAMETER_TYPE                     0
+#  define KDF_R_VALUE_ERROR                                0
+#  define KDF_R_VALUE_MISSING                              0
+
+/*
+ * OBJ function codes.
+ */
+#  define OBJ_F_OBJ_ADD_OBJECT                             0
+#  define OBJ_F_OBJ_ADD_SIGID                              0
+#  define OBJ_F_OBJ_CREATE                                 0
+#  define OBJ_F_OBJ_DUP                                    0
+#  define OBJ_F_OBJ_NAME_NEW_INDEX                         0
+#  define OBJ_F_OBJ_NID2LN                                 0
+#  define OBJ_F_OBJ_NID2OBJ                                0
+#  define OBJ_F_OBJ_NID2SN                                 0
+#  define OBJ_F_OBJ_TXT2OBJ                                0
+
+#  ifndef OPENSSL_NO_OCSP
+/*
+ * OCSP function codes.
+ */
+#   define OCSP_F_D2I_OCSP_NONCE                            0
+#   define OCSP_F_OCSP_BASIC_ADD1_STATUS                    0
+#   define OCSP_F_OCSP_BASIC_SIGN                           0
+#   define OCSP_F_OCSP_BASIC_SIGN_CTX                       0
+#   define OCSP_F_OCSP_BASIC_VERIFY                         0
+#   define OCSP_F_OCSP_CERT_ID_NEW                          0
+#   define OCSP_F_OCSP_CHECK_DELEGATED                      0
+#   define OCSP_F_OCSP_CHECK_IDS                            0
+#   define OCSP_F_OCSP_CHECK_ISSUER                         0
+#   define OCSP_F_OCSP_CHECK_VALIDITY                       0
+#   define OCSP_F_OCSP_MATCH_ISSUERID                       0
+#   define OCSP_F_OCSP_PARSE_URL                            0
+#   define OCSP_F_OCSP_REQUEST_SIGN                         0
+#   define OCSP_F_OCSP_REQUEST_VERIFY                       0
+#   define OCSP_F_OCSP_RESPONSE_GET1_BASIC                  0
+#   define OCSP_F_PARSE_HTTP_LINE1                          0
+#  endif
+
+/*
+ * PEM function codes.
+ */
+#  define PEM_F_B2I_DSS                                    0
+#  define PEM_F_B2I_PVK_BIO                                0
+#  define PEM_F_B2I_RSA                                    0
+#  define PEM_F_CHECK_BITLEN_DSA                           0
+#  define PEM_F_CHECK_BITLEN_RSA                           0
+#  define PEM_F_D2I_PKCS8PRIVATEKEY_BIO                    0
+#  define PEM_F_D2I_PKCS8PRIVATEKEY_FP                     0
+#  define PEM_F_DO_B2I                                     0
+#  define PEM_F_DO_B2I_BIO                                 0
+#  define PEM_F_DO_BLOB_HEADER                             0
+#  define PEM_F_DO_I2B                                     0
+#  define PEM_F_DO_PK8PKEY                                 0
+#  define PEM_F_DO_PK8PKEY_FP                              0
+#  define PEM_F_DO_PVK_BODY                                0
+#  define PEM_F_DO_PVK_HEADER                              0
+#  define PEM_F_GET_HEADER_AND_DATA                        0
+#  define PEM_F_GET_NAME                                   0
+#  define PEM_F_I2B_PVK                                    0
+#  define PEM_F_I2B_PVK_BIO                                0
+#  define PEM_F_LOAD_IV                                    0
+#  define PEM_F_PEM_ASN1_READ                              0
+#  define PEM_F_PEM_ASN1_READ_BIO                          0
+#  define PEM_F_PEM_ASN1_WRITE                             0
+#  define PEM_F_PEM_ASN1_WRITE_BIO                         0
+#  define PEM_F_PEM_DEF_CALLBACK                           0
+#  define PEM_F_PEM_DO_HEADER                              0
+#  define PEM_F_PEM_GET_EVP_CIPHER_INFO                    0
+#  define PEM_F_PEM_READ                                   0
+#  define PEM_F_PEM_READ_BIO                               0
+#  define PEM_F_PEM_READ_BIO_DHPARAMS                      0
+#  define PEM_F_PEM_READ_BIO_EX                            0
+#  define PEM_F_PEM_READ_BIO_PARAMETERS                    0
+#  define PEM_F_PEM_READ_BIO_PRIVATEKEY                    0
+#  define PEM_F_PEM_READ_DHPARAMS                          0
+#  define PEM_F_PEM_READ_PRIVATEKEY                        0
+#  define PEM_F_PEM_SIGNFINAL                              0
+#  define PEM_F_PEM_WRITE                                  0
+#  define PEM_F_PEM_WRITE_BIO                              0
+#  define PEM_F_PEM_WRITE_BIO_PRIVATEKEY_TRADITIONAL       0
+#  define PEM_F_PEM_WRITE_PRIVATEKEY                       0
+#  define PEM_F_PEM_X509_INFO_READ                         0
+#  define PEM_F_PEM_X509_INFO_READ_BIO                     0
+#  define PEM_F_PEM_X509_INFO_WRITE_BIO                    0
+
+/*
+ * PKCS12 function codes.
+ */
+#  define PKCS12_F_OPENSSL_ASC2UNI                         0
+#  define PKCS12_F_OPENSSL_UNI2ASC                         0
+#  define PKCS12_F_OPENSSL_UNI2UTF8                        0
+#  define PKCS12_F_OPENSSL_UTF82UNI                        0
+#  define PKCS12_F_PKCS12_CREATE                           0
+#  define PKCS12_F_PKCS12_GEN_MAC                          0
+#  define PKCS12_F_PKCS12_INIT                             0
+#  define PKCS12_F_PKCS12_ITEM_DECRYPT_D2I                 0
+#  define PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT                 0
+#  define PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG                0
+#  define PKCS12_F_PKCS12_KEY_GEN_ASC                      0
+#  define PKCS12_F_PKCS12_KEY_GEN_UNI                      0
+#  define PKCS12_F_PKCS12_KEY_GEN_UTF8                     0
+#  define PKCS12_F_PKCS12_NEWPASS                          0
+#  define PKCS12_F_PKCS12_PACK_P7DATA                      0
+#  define PKCS12_F_PKCS12_PACK_P7ENCDATA                   0
+#  define PKCS12_F_PKCS12_PARSE                            0
+#  define PKCS12_F_PKCS12_PBE_CRYPT                        0
+#  define PKCS12_F_PKCS12_PBE_KEYIVGEN                     0
+#  define PKCS12_F_PKCS12_SAFEBAG_CREATE0_P8INF            0
+#  define PKCS12_F_PKCS12_SAFEBAG_CREATE0_PKCS8            0
+#  define PKCS12_F_PKCS12_SAFEBAG_CREATE_PKCS8_ENCRYPT     0
+#  define PKCS12_F_PKCS12_SETUP_MAC                        0
+#  define PKCS12_F_PKCS12_SET_MAC                          0
+#  define PKCS12_F_PKCS12_UNPACK_AUTHSAFES                 0
+#  define PKCS12_F_PKCS12_UNPACK_P7DATA                    0
+#  define PKCS12_F_PKCS12_VERIFY_MAC                       0
+#  define PKCS12_F_PKCS8_ENCRYPT                           0
+#  define PKCS12_F_PKCS8_SET0_PBE                          0
+
+/*
+ * PKCS7 function codes.
+ */
+#  define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB                   0
+#  define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME           0
+#  define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP                0
+#  define PKCS7_F_PKCS7_ADD_CERTIFICATE                    0
+#  define PKCS7_F_PKCS7_ADD_CRL                            0
+#  define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO                 0
+#  define PKCS7_F_PKCS7_ADD_SIGNATURE                      0
+#  define PKCS7_F_PKCS7_ADD_SIGNER                         0
+#  define PKCS7_F_PKCS7_BIO_ADD_DIGEST                     0
+#  define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST               0
+#  define PKCS7_F_PKCS7_CTRL                               0
+#  define PKCS7_F_PKCS7_DATADECODE                         0
+#  define PKCS7_F_PKCS7_DATAFINAL                          0
+#  define PKCS7_F_PKCS7_DATAINIT                           0
+#  define PKCS7_F_PKCS7_DATAVERIFY                         0
+#  define PKCS7_F_PKCS7_DECRYPT                            0
+#  define PKCS7_F_PKCS7_DECRYPT_RINFO                      0
+#  define PKCS7_F_PKCS7_ENCODE_RINFO                       0
+#  define PKCS7_F_PKCS7_ENCRYPT                            0
+#  define PKCS7_F_PKCS7_FINAL                              0
+#  define PKCS7_F_PKCS7_FIND_DIGEST                        0
+#  define PKCS7_F_PKCS7_GET0_SIGNERS                       0
+#  define PKCS7_F_PKCS7_RECIP_INFO_SET                     0
+#  define PKCS7_F_PKCS7_SET_CIPHER                         0
+#  define PKCS7_F_PKCS7_SET_CONTENT                        0
+#  define PKCS7_F_PKCS7_SET_DIGEST                         0
+#  define PKCS7_F_PKCS7_SET_TYPE                           0
+#  define PKCS7_F_PKCS7_SIGN                               0
+#  define PKCS7_F_PKCS7_SIGNATUREVERIFY                    0
+#  define PKCS7_F_PKCS7_SIGNER_INFO_SET                    0
+#  define PKCS7_F_PKCS7_SIGNER_INFO_SIGN                   0
+#  define PKCS7_F_PKCS7_SIGN_ADD_SIGNER                    0
+#  define PKCS7_F_PKCS7_SIMPLE_SMIMECAP                    0
+#  define PKCS7_F_PKCS7_VERIFY                             0
+
+/*
+ * RAND function codes.
+ */
+#  define RAND_F_DATA_COLLECT_METHOD                       0
+#  define RAND_F_DRBG_BYTES                                0
+#  define RAND_F_DRBG_GET_ENTROPY                          0
+#  define RAND_F_DRBG_SETUP                                0
+#  define RAND_F_GET_ENTROPY                               0
+#  define RAND_F_RAND_BYTES                                0
+#  define RAND_F_RAND_DRBG_ENABLE_LOCKING                  0
+#  define RAND_F_RAND_DRBG_GENERATE                        0
+#  define RAND_F_RAND_DRBG_GET_ENTROPY                     0
+#  define RAND_F_RAND_DRBG_GET_NONCE                       0
+#  define RAND_F_RAND_DRBG_INSTANTIATE                     0
+#  define RAND_F_RAND_DRBG_NEW                             0
+#  define RAND_F_RAND_DRBG_RESEED                          0
+#  define RAND_F_RAND_DRBG_RESTART                         0
+#  define RAND_F_RAND_DRBG_SET                             0
+#  define RAND_F_RAND_DRBG_SET_DEFAULTS                    0
+#  define RAND_F_RAND_DRBG_UNINSTANTIATE                   0
+#  define RAND_F_RAND_LOAD_FILE                            0
+#  define RAND_F_RAND_POOL_ACQUIRE_ENTROPY                 0
+#  define RAND_F_RAND_POOL_ADD                             0
+#  define RAND_F_RAND_POOL_ADD_BEGIN                       0
+#  define RAND_F_RAND_POOL_ADD_END                         0
+#  define RAND_F_RAND_POOL_ATTACH                          0
+#  define RAND_F_RAND_POOL_BYTES_NEEDED                    0
+#  define RAND_F_RAND_POOL_GROW                            0
+#  define RAND_F_RAND_POOL_NEW                             0
+#  define RAND_F_RAND_PSEUDO_BYTES                         0
+#  define RAND_F_RAND_WRITE_FILE                           0
+
+/*
+ * RSA function codes.
+ */
+#  define RSA_F_CHECK_PADDING_MD                           0
+#  define RSA_F_ENCODE_PKCS1                               0
+#  define RSA_F_INT_RSA_VERIFY                             0
+#  define RSA_F_OLD_RSA_PRIV_DECODE                        0
+#  define RSA_F_PKEY_PSS_INIT                              0
+#  define RSA_F_PKEY_RSA_CTRL                              0
+#  define RSA_F_PKEY_RSA_CTRL_STR                          0
+#  define RSA_F_PKEY_RSA_SIGN                              0
+#  define RSA_F_PKEY_RSA_VERIFY                            0
+#  define RSA_F_PKEY_RSA_VERIFYRECOVER                     0
+#  define RSA_F_RSA_ALGOR_TO_MD                            0
+#  define RSA_F_RSA_BUILTIN_KEYGEN                         0
+#  define RSA_F_RSA_CHECK_KEY                              0
+#  define RSA_F_RSA_CHECK_KEY_EX                           0
+#  define RSA_F_RSA_CMS_DECRYPT                            0
+#  define RSA_F_RSA_CMS_VERIFY                             0
+#  define RSA_F_RSA_ITEM_VERIFY                            0
+#  define RSA_F_RSA_METH_DUP                               0
+#  define RSA_F_RSA_METH_NEW                               0
+#  define RSA_F_RSA_METH_SET1_NAME                         0
+#  define RSA_F_RSA_MGF1_TO_MD                             0
+#  define RSA_F_RSA_MULTIP_INFO_NEW                        0
+#  define RSA_F_RSA_NEW_METHOD                             0
+#  define RSA_F_RSA_NULL                                   0
+#  define RSA_F_RSA_NULL_PRIVATE_DECRYPT                   0
+#  define RSA_F_RSA_NULL_PRIVATE_ENCRYPT                   0
+#  define RSA_F_RSA_NULL_PUBLIC_DECRYPT                    0
+#  define RSA_F_RSA_NULL_PUBLIC_ENCRYPT                    0
+#  define RSA_F_RSA_OSSL_PRIVATE_DECRYPT                   0
+#  define RSA_F_RSA_OSSL_PRIVATE_ENCRYPT                   0
+#  define RSA_F_RSA_OSSL_PUBLIC_DECRYPT                    0
+#  define RSA_F_RSA_OSSL_PUBLIC_ENCRYPT                    0
+#  define RSA_F_RSA_PADDING_ADD_NONE                       0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP                 0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP_MGF1            0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_PSS                  0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1             0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1               0
+#  define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2               0
+#  define RSA_F_RSA_PADDING_ADD_SSLV23                     0
+#  define RSA_F_RSA_PADDING_ADD_X931                       0
+#  define RSA_F_RSA_PADDING_CHECK_NONE                     0
+#  define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP               0
+#  define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP_MGF1          0
+#  define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1             0
+#  define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2             0
+#  define RSA_F_RSA_PADDING_CHECK_SSLV23                   0
+#  define RSA_F_RSA_PADDING_CHECK_X931                     0
+#  define RSA_F_RSA_PARAM_DECODE                           0
+#  define RSA_F_RSA_PRINT                                  0
+#  define RSA_F_RSA_PRINT_FP                               0
+#  define RSA_F_RSA_PRIV_DECODE                            0
+#  define RSA_F_RSA_PRIV_ENCODE                            0
+#  define RSA_F_RSA_PSS_GET_PARAM                          0
+#  define RSA_F_RSA_PSS_TO_CTX                             0
+#  define RSA_F_RSA_PUB_DECODE                             0
+#  define RSA_F_RSA_SETUP_BLINDING                         0
+#  define RSA_F_RSA_SIGN                                   0
+#  define RSA_F_RSA_SIGN_ASN1_OCTET_STRING                 0
+#  define RSA_F_RSA_VERIFY                                 0
+#  define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING               0
+#  define RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1                  0
+#  define RSA_F_SETUP_TBUF                                 0
+
+/*
+ * OSSL_STORE function codes.
+ */
+#  define OSSL_STORE_F_FILE_CTRL                           0
+#  define OSSL_STORE_F_FILE_FIND                           0
+#  define OSSL_STORE_F_FILE_GET_PASS                       0
+#  define OSSL_STORE_F_FILE_LOAD                           0
+#  define OSSL_STORE_F_FILE_LOAD_TRY_DECODE                0
+#  define OSSL_STORE_F_FILE_NAME_TO_URI                    0
+#  define OSSL_STORE_F_FILE_OPEN                           0
+#  define OSSL_STORE_F_OSSL_STORE_ATTACH_PEM_BIO           0
+#  define OSSL_STORE_F_OSSL_STORE_EXPECT                   0
+#  define OSSL_STORE_F_OSSL_STORE_FILE_ATTACH_PEM_BIO_INT  0
+#  define OSSL_STORE_F_OSSL_STORE_FIND                     0
+#  define OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT          0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CERT           0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CRL            0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME           0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME_DESCRIPTION 0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PARAMS         0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PKEY           0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CERT            0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CRL             0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_EMBEDDED        0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_NAME            0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PARAMS          0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PKEY            0
+#  define OSSL_STORE_F_OSSL_STORE_INFO_SET0_NAME_DESCRIPTION 0
+#  define OSSL_STORE_F_OSSL_STORE_INIT_ONCE                0
+#  define OSSL_STORE_F_OSSL_STORE_LOADER_NEW               0
+#  define OSSL_STORE_F_OSSL_STORE_OPEN                     0
+#  define OSSL_STORE_F_OSSL_STORE_OPEN_INT                 0
+#  define OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT      0
+#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ALIAS          0
+#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ISSUER_SERIAL  0
+#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 0
+#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_NAME           0
+#  define OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT    0
+#  define OSSL_STORE_F_TRY_DECODE_PARAMS                   0
+#  define OSSL_STORE_F_TRY_DECODE_PKCS12                   0
+#  define OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED           0
+
+#  ifndef OPENSSL_NO_TS
+/*
+ * TS function codes.
+ */
+#   define TS_F_DEF_SERIAL_CB                               0
+#   define TS_F_DEF_TIME_CB                                 0
+#   define TS_F_ESS_ADD_SIGNING_CERT                        0
+#   define TS_F_ESS_ADD_SIGNING_CERT_V2                     0
+#   define TS_F_ESS_CERT_ID_NEW_INIT                        0
+#   define TS_F_ESS_CERT_ID_V2_NEW_INIT                     0
+#   define TS_F_ESS_SIGNING_CERT_NEW_INIT                   0
+#   define TS_F_ESS_SIGNING_CERT_V2_NEW_INIT                0
+#   define TS_F_INT_TS_RESP_VERIFY_TOKEN                    0
+#   define TS_F_PKCS7_TO_TS_TST_INFO                        0
+#   define TS_F_TS_ACCURACY_SET_MICROS                      0
+#   define TS_F_TS_ACCURACY_SET_MILLIS                      0
+#   define TS_F_TS_ACCURACY_SET_SECONDS                     0
+#   define TS_F_TS_CHECK_IMPRINTS                           0
+#   define TS_F_TS_CHECK_NONCES                             0
+#   define TS_F_TS_CHECK_POLICY                             0
+#   define TS_F_TS_CHECK_SIGNING_CERTS                      0
+#   define TS_F_TS_CHECK_STATUS_INFO                        0
+#   define TS_F_TS_COMPUTE_IMPRINT                          0
+#   define TS_F_TS_CONF_INVALID                             0
+#   define TS_F_TS_CONF_LOAD_CERT                           0
+#   define TS_F_TS_CONF_LOAD_CERTS                          0
+#   define TS_F_TS_CONF_LOAD_KEY                            0
+#   define TS_F_TS_CONF_LOOKUP_FAIL                         0
+#   define TS_F_TS_CONF_SET_DEFAULT_ENGINE                  0
+#   define TS_F_TS_GET_STATUS_TEXT                          0
+#   define TS_F_TS_MSG_IMPRINT_SET_ALGO                     0
+#   define TS_F_TS_REQ_SET_MSG_IMPRINT                      0
+#   define TS_F_TS_REQ_SET_NONCE                            0
+#   define TS_F_TS_REQ_SET_POLICY_ID                        0
+#   define TS_F_TS_RESP_CREATE_RESPONSE                     0
+#   define TS_F_TS_RESP_CREATE_TST_INFO                     0
+#   define TS_F_TS_RESP_CTX_ADD_FAILURE_INFO                0
+#   define TS_F_TS_RESP_CTX_ADD_MD                          0
+#   define TS_F_TS_RESP_CTX_ADD_POLICY                      0
+#   define TS_F_TS_RESP_CTX_NEW                             0
+#   define TS_F_TS_RESP_CTX_SET_ACCURACY                    0
+#   define TS_F_TS_RESP_CTX_SET_CERTS                       0
+#   define TS_F_TS_RESP_CTX_SET_DEF_POLICY                  0
+#   define TS_F_TS_RESP_CTX_SET_SIGNER_CERT                 0
+#   define TS_F_TS_RESP_CTX_SET_STATUS_INFO                 0
+#   define TS_F_TS_RESP_GET_POLICY                          0
+#   define TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION          0
+#   define TS_F_TS_RESP_SET_STATUS_INFO                     0
+#   define TS_F_TS_RESP_SET_TST_INFO                        0
+#   define TS_F_TS_RESP_SIGN                                0
+#   define TS_F_TS_RESP_VERIFY_SIGNATURE                    0
+#   define TS_F_TS_TST_INFO_SET_ACCURACY                    0
+#   define TS_F_TS_TST_INFO_SET_MSG_IMPRINT                 0
+#   define TS_F_TS_TST_INFO_SET_NONCE                       0
+#   define TS_F_TS_TST_INFO_SET_POLICY_ID                   0
+#   define TS_F_TS_TST_INFO_SET_SERIAL                      0
+#   define TS_F_TS_TST_INFO_SET_TIME                        0
+#   define TS_F_TS_TST_INFO_SET_TSA                         0
+#   define TS_F_TS_VERIFY                                   0
+#   define TS_F_TS_VERIFY_CERT                              0
+#   define TS_F_TS_VERIFY_CTX_NEW                           0
+#  endif
+
+/*
+ * UI function codes.
+ */
+#  define UI_F_CLOSE_CONSOLE                               0
+#  define UI_F_ECHO_CONSOLE                                0
+#  define UI_F_GENERAL_ALLOCATE_BOOLEAN                    0
+#  define UI_F_GENERAL_ALLOCATE_PROMPT                     0
+#  define UI_F_NOECHO_CONSOLE                              0
+#  define UI_F_OPEN_CONSOLE                                0
+#  define UI_F_UI_CONSTRUCT_PROMPT                         0
+#  define UI_F_UI_CREATE_METHOD                            0
+#  define UI_F_UI_CTRL                                     0
+#  define UI_F_UI_DUP_ERROR_STRING                         0
+#  define UI_F_UI_DUP_INFO_STRING                          0
+#  define UI_F_UI_DUP_INPUT_BOOLEAN                        0
+#  define UI_F_UI_DUP_INPUT_STRING                         0
+#  define UI_F_UI_DUP_USER_DATA                            0
+#  define UI_F_UI_DUP_VERIFY_STRING                        0
+#  define UI_F_UI_GET0_RESULT                              0
+#  define UI_F_UI_GET_RESULT_LENGTH                        0
+#  define UI_F_UI_NEW_METHOD                               0
+#  define UI_F_UI_PROCESS                                  0
+#  define UI_F_UI_SET_RESULT                               0
+#  define UI_F_UI_SET_RESULT_EX                            0
+
+/*
+ * X509 function codes.
+ */
+#  define X509_F_ADD_CERT_DIR                              0
+#  define X509_F_BUILD_CHAIN                               0
+#  define X509_F_BY_FILE_CTRL                              0
+#  define X509_F_CHECK_NAME_CONSTRAINTS                    0
+#  define X509_F_CHECK_POLICY                              0
+#  define X509_F_DANE_I2D                                  0
+#  define X509_F_DIR_CTRL                                  0
+#  define X509_F_GET_CERT_BY_SUBJECT                       0
+#  define X509_F_I2D_X509_AUX                              0
+#  define X509_F_LOOKUP_CERTS_SK                           0
+#  define X509_F_NETSCAPE_SPKI_B64_DECODE                  0
+#  define X509_F_NETSCAPE_SPKI_B64_ENCODE                  0
+#  define X509_F_NEW_DIR                                   0
+#  define X509_F_X509AT_ADD1_ATTR                          0
+#  define X509_F_X509V3_ADD_EXT                            0
+#  define X509_F_X509_ATTRIBUTE_CREATE_BY_NID              0
+#  define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ              0
+#  define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT              0
+#  define X509_F_X509_ATTRIBUTE_GET0_DATA                  0
+#  define X509_F_X509_ATTRIBUTE_SET1_DATA                  0
+#  define X509_F_X509_CHECK_PRIVATE_KEY                    0
+#  define X509_F_X509_CRL_DIFF                             0
+#  define X509_F_X509_CRL_METHOD_NEW                       0
+#  define X509_F_X509_CRL_PRINT_FP                         0
+#  define X509_F_X509_EXTENSION_CREATE_BY_NID              0
+#  define X509_F_X509_EXTENSION_CREATE_BY_OBJ              0
+#  define X509_F_X509_GET_PUBKEY_PARAMETERS                0
+#  define X509_F_X509_LOAD_CERT_CRL_FILE                   0
+#  define X509_F_X509_LOAD_CERT_FILE                       0
+#  define X509_F_X509_LOAD_CRL_FILE                        0
+#  define X509_F_X509_LOOKUP_METH_NEW                      0
+#  define X509_F_X509_LOOKUP_NEW                           0
+#  define X509_F_X509_NAME_ADD_ENTRY                       0
+#  define X509_F_X509_NAME_CANON                           0
+#  define X509_F_X509_NAME_ENTRY_CREATE_BY_NID             0
+#  define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT             0
+#  define X509_F_X509_NAME_ENTRY_SET_OBJECT                0
+#  define X509_F_X509_NAME_ONELINE                         0
+#  define X509_F_X509_NAME_PRINT                           0
+#  define X509_F_X509_OBJECT_NEW                           0
+#  define X509_F_X509_PRINT_EX_FP                          0
+#  define X509_F_X509_PUBKEY_DECODE                        0
+#  define X509_F_X509_PUBKEY_GET                           0
+#  define X509_F_X509_PUBKEY_GET0                          0
+#  define X509_F_X509_PUBKEY_SET                           0
+#  define X509_F_X509_REQ_CHECK_PRIVATE_KEY                0
+#  define X509_F_X509_REQ_PRINT_EX                         0
+#  define X509_F_X509_REQ_PRINT_FP                         0
+#  define X509_F_X509_REQ_TO_X509                          0
+#  define X509_F_X509_STORE_ADD_CERT                       0
+#  define X509_F_X509_STORE_ADD_CRL                        0
+#  define X509_F_X509_STORE_ADD_LOOKUP                     0
+#  define X509_F_X509_STORE_CTX_GET1_ISSUER                0
+#  define X509_F_X509_STORE_CTX_INIT                       0
+#  define X509_F_X509_STORE_CTX_NEW                        0
+#  define X509_F_X509_STORE_CTX_PURPOSE_INHERIT            0
+#  define X509_F_X509_STORE_NEW                            0
+#  define X509_F_X509_TO_X509_REQ                          0
+#  define X509_F_X509_TRUST_ADD                            0
+#  define X509_F_X509_TRUST_SET                            0
+#  define X509_F_X509_VERIFY_CERT                          0
+#  define X509_F_X509_VERIFY_PARAM_NEW                     0
+
+/*
+ * X509V3 function codes.
+ */
+#  define X509V3_F_A2I_GENERAL_NAME                        0
+#  define X509V3_F_ADDR_VALIDATE_PATH_INTERNAL             0
+#  define X509V3_F_ASIDENTIFIERCHOICE_CANONIZE             0
+#  define X509V3_F_ASIDENTIFIERCHOICE_IS_CANONICAL         0
+#  define X509V3_F_BIGNUM_TO_STRING                        0
+#  define X509V3_F_COPY_EMAIL                              0
+#  define X509V3_F_COPY_ISSUER                             0
+#  define X509V3_F_DO_DIRNAME                              0
+#  define X509V3_F_DO_EXT_I2D                              0
+#  define X509V3_F_DO_EXT_NCONF                            0
+#  define X509V3_F_GNAMES_FROM_SECTNAME                    0
+#  define X509V3_F_I2S_ASN1_ENUMERATED                     0
+#  define X509V3_F_I2S_ASN1_IA5STRING                      0
+#  define X509V3_F_I2S_ASN1_INTEGER                        0
+#  define X509V3_F_I2V_AUTHORITY_INFO_ACCESS               0
+#  define X509V3_F_LEVEL_ADD_NODE                          0
+#  define X509V3_F_NOTICE_SECTION                          0
+#  define X509V3_F_NREF_NOS                                0
+#  define X509V3_F_POLICY_CACHE_CREATE                     0
+#  define X509V3_F_POLICY_CACHE_NEW                        0
+#  define X509V3_F_POLICY_DATA_NEW                         0
+#  define X509V3_F_POLICY_SECTION                          0
+#  define X509V3_F_PROCESS_PCI_VALUE                       0
+#  define X509V3_F_R2I_CERTPOL                             0
+#  define X509V3_F_R2I_PCI                                 0
+#  define X509V3_F_S2I_ASN1_IA5STRING                      0
+#  define X509V3_F_S2I_ASN1_INTEGER                        0
+#  define X509V3_F_S2I_ASN1_OCTET_STRING                   0
+#  define X509V3_F_S2I_SKEY_ID                             0
+#  define X509V3_F_SET_DIST_POINT_NAME                     0
+#  define X509V3_F_SXNET_ADD_ID_ASC                        0
+#  define X509V3_F_SXNET_ADD_ID_INTEGER                    0
+#  define X509V3_F_SXNET_ADD_ID_ULONG                      0
+#  define X509V3_F_SXNET_GET_ID_ASC                        0
+#  define X509V3_F_SXNET_GET_ID_ULONG                      0
+#  define X509V3_F_TREE_INIT                               0
+#  define X509V3_F_V2I_ASIDENTIFIERS                       0
+#  define X509V3_F_V2I_ASN1_BIT_STRING                     0
+#  define X509V3_F_V2I_AUTHORITY_INFO_ACCESS               0
+#  define X509V3_F_V2I_AUTHORITY_KEYID                     0
+#  define X509V3_F_V2I_BASIC_CONSTRAINTS                   0
+#  define X509V3_F_V2I_CRLD                                0
+#  define X509V3_F_V2I_EXTENDED_KEY_USAGE                  0
+#  define X509V3_F_V2I_GENERAL_NAMES                       0
+#  define X509V3_F_V2I_GENERAL_NAME_EX                     0
+#  define X509V3_F_V2I_IDP                                 0
+#  define X509V3_F_V2I_IPADDRBLOCKS                        0
+#  define X509V3_F_V2I_ISSUER_ALT                          0
+#  define X509V3_F_V2I_NAME_CONSTRAINTS                    0
+#  define X509V3_F_V2I_POLICY_CONSTRAINTS                  0
+#  define X509V3_F_V2I_POLICY_MAPPINGS                     0
+#  define X509V3_F_V2I_SUBJECT_ALT                         0
+#  define X509V3_F_V2I_TLS_FEATURE                         0
+#  define X509V3_F_V3_GENERIC_EXTENSION                    0
+#  define X509V3_F_X509V3_ADD1_I2D                         0
+#  define X509V3_F_X509V3_ADD_VALUE                        0
+#  define X509V3_F_X509V3_EXT_ADD                          0
+#  define X509V3_F_X509V3_EXT_ADD_ALIAS                    0
+#  define X509V3_F_X509V3_EXT_I2D                          0
+#  define X509V3_F_X509V3_EXT_NCONF                        0
+#  define X509V3_F_X509V3_GET_SECTION                      0
+#  define X509V3_F_X509V3_GET_STRING                       0
+#  define X509V3_F_X509V3_GET_VALUE_BOOL                   0
+#  define X509V3_F_X509V3_PARSE_LIST                       0
+#  define X509V3_F_X509_PURPOSE_ADD                        0
+#  define X509V3_F_X509_PURPOSE_SET                        0
+
+/*
+ * Compatibility defines.
+ */
+# define EVP_R_OPERATON_NOT_INITIALIZED    EVP_R_OPERATION_NOT_INITIALIZED
+
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ct.h b/CAPI/cpp/grpc/include/openssl/ct.h
new file mode 100644
index 0000000..06c41b7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ct.h
@@ -0,0 +1,573 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ct.h.in
+ *
+ * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_CT_H
+# define OPENSSL_CT_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_CT_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_CT
+# include <openssl/types.h>
+# include <openssl/safestack.h>
+# include <openssl/x509.h>
+# include <openssl/cterr.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+
+/* Minimum RSA key size, from RFC6962 */
+# define SCT_MIN_RSA_BITS 2048
+
+/* All hashes are SHA256 in v1 of Certificate Transparency */
+# define CT_V1_HASHLEN SHA256_DIGEST_LENGTH
+
+SKM_DEFINE_STACK_OF_INTERNAL(SCT, SCT, SCT)
+#define sk_SCT_num(sk) OPENSSL_sk_num(ossl_check_const_SCT_sk_type(sk))
+#define sk_SCT_value(sk, idx) ((SCT *)OPENSSL_sk_value(ossl_check_const_SCT_sk_type(sk), (idx)))
+#define sk_SCT_new(cmp) ((STACK_OF(SCT) *)OPENSSL_sk_new(ossl_check_SCT_compfunc_type(cmp)))
+#define sk_SCT_new_null() ((STACK_OF(SCT) *)OPENSSL_sk_new_null())
+#define sk_SCT_new_reserve(cmp, n) ((STACK_OF(SCT) *)OPENSSL_sk_new_reserve(ossl_check_SCT_compfunc_type(cmp), (n)))
+#define sk_SCT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SCT_sk_type(sk), (n))
+#define sk_SCT_free(sk) OPENSSL_sk_free(ossl_check_SCT_sk_type(sk))
+#define sk_SCT_zero(sk) OPENSSL_sk_zero(ossl_check_SCT_sk_type(sk))
+#define sk_SCT_delete(sk, i) ((SCT *)OPENSSL_sk_delete(ossl_check_SCT_sk_type(sk), (i)))
+#define sk_SCT_delete_ptr(sk, ptr) ((SCT *)OPENSSL_sk_delete_ptr(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr)))
+#define sk_SCT_push(sk, ptr) OPENSSL_sk_push(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
+#define sk_SCT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
+#define sk_SCT_pop(sk) ((SCT *)OPENSSL_sk_pop(ossl_check_SCT_sk_type(sk)))
+#define sk_SCT_shift(sk) ((SCT *)OPENSSL_sk_shift(ossl_check_SCT_sk_type(sk)))
+#define sk_SCT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SCT_sk_type(sk),ossl_check_SCT_freefunc_type(freefunc))
+#define sk_SCT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr), (idx))
+#define sk_SCT_set(sk, idx, ptr) ((SCT *)OPENSSL_sk_set(ossl_check_SCT_sk_type(sk), (idx), ossl_check_SCT_type(ptr)))
+#define sk_SCT_find(sk, ptr) OPENSSL_sk_find(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
+#define sk_SCT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
+#define sk_SCT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr), pnum)
+#define sk_SCT_sort(sk) OPENSSL_sk_sort(ossl_check_SCT_sk_type(sk))
+#define sk_SCT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SCT_sk_type(sk))
+#define sk_SCT_dup(sk) ((STACK_OF(SCT) *)OPENSSL_sk_dup(ossl_check_const_SCT_sk_type(sk)))
+#define sk_SCT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SCT) *)OPENSSL_sk_deep_copy(ossl_check_const_SCT_sk_type(sk), ossl_check_SCT_copyfunc_type(copyfunc), ossl_check_SCT_freefunc_type(freefunc)))
+#define sk_SCT_set_cmp_func(sk, cmp) ((sk_SCT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SCT_sk_type(sk), ossl_check_SCT_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(CTLOG, CTLOG, CTLOG)
+#define sk_CTLOG_num(sk) OPENSSL_sk_num(ossl_check_const_CTLOG_sk_type(sk))
+#define sk_CTLOG_value(sk, idx) ((CTLOG *)OPENSSL_sk_value(ossl_check_const_CTLOG_sk_type(sk), (idx)))
+#define sk_CTLOG_new(cmp) ((STACK_OF(CTLOG) *)OPENSSL_sk_new(ossl_check_CTLOG_compfunc_type(cmp)))
+#define sk_CTLOG_new_null() ((STACK_OF(CTLOG) *)OPENSSL_sk_new_null())
+#define sk_CTLOG_new_reserve(cmp, n) ((STACK_OF(CTLOG) *)OPENSSL_sk_new_reserve(ossl_check_CTLOG_compfunc_type(cmp), (n)))
+#define sk_CTLOG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CTLOG_sk_type(sk), (n))
+#define sk_CTLOG_free(sk) OPENSSL_sk_free(ossl_check_CTLOG_sk_type(sk))
+#define sk_CTLOG_zero(sk) OPENSSL_sk_zero(ossl_check_CTLOG_sk_type(sk))
+#define sk_CTLOG_delete(sk, i) ((CTLOG *)OPENSSL_sk_delete(ossl_check_CTLOG_sk_type(sk), (i)))
+#define sk_CTLOG_delete_ptr(sk, ptr) ((CTLOG *)OPENSSL_sk_delete_ptr(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr)))
+#define sk_CTLOG_push(sk, ptr) OPENSSL_sk_push(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
+#define sk_CTLOG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
+#define sk_CTLOG_pop(sk) ((CTLOG *)OPENSSL_sk_pop(ossl_check_CTLOG_sk_type(sk)))
+#define sk_CTLOG_shift(sk) ((CTLOG *)OPENSSL_sk_shift(ossl_check_CTLOG_sk_type(sk)))
+#define sk_CTLOG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CTLOG_sk_type(sk),ossl_check_CTLOG_freefunc_type(freefunc))
+#define sk_CTLOG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr), (idx))
+#define sk_CTLOG_set(sk, idx, ptr) ((CTLOG *)OPENSSL_sk_set(ossl_check_CTLOG_sk_type(sk), (idx), ossl_check_CTLOG_type(ptr)))
+#define sk_CTLOG_find(sk, ptr) OPENSSL_sk_find(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
+#define sk_CTLOG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
+#define sk_CTLOG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr), pnum)
+#define sk_CTLOG_sort(sk) OPENSSL_sk_sort(ossl_check_CTLOG_sk_type(sk))
+#define sk_CTLOG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CTLOG_sk_type(sk))
+#define sk_CTLOG_dup(sk) ((STACK_OF(CTLOG) *)OPENSSL_sk_dup(ossl_check_const_CTLOG_sk_type(sk)))
+#define sk_CTLOG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CTLOG) *)OPENSSL_sk_deep_copy(ossl_check_const_CTLOG_sk_type(sk), ossl_check_CTLOG_copyfunc_type(copyfunc), ossl_check_CTLOG_freefunc_type(freefunc)))
+#define sk_CTLOG_set_cmp_func(sk, cmp) ((sk_CTLOG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_compfunc_type(cmp)))
+
+
+
+typedef enum {
+    CT_LOG_ENTRY_TYPE_NOT_SET = -1,
+    CT_LOG_ENTRY_TYPE_X509 = 0,
+    CT_LOG_ENTRY_TYPE_PRECERT = 1
+} ct_log_entry_type_t;
+
+typedef enum {
+    SCT_VERSION_NOT_SET = -1,
+    SCT_VERSION_V1 = 0
+} sct_version_t;
+
+typedef enum {
+    SCT_SOURCE_UNKNOWN,
+    SCT_SOURCE_TLS_EXTENSION,
+    SCT_SOURCE_X509V3_EXTENSION,
+    SCT_SOURCE_OCSP_STAPLED_RESPONSE
+} sct_source_t;
+
+typedef enum {
+    SCT_VALIDATION_STATUS_NOT_SET,
+    SCT_VALIDATION_STATUS_UNKNOWN_LOG,
+    SCT_VALIDATION_STATUS_VALID,
+    SCT_VALIDATION_STATUS_INVALID,
+    SCT_VALIDATION_STATUS_UNVERIFIED,
+    SCT_VALIDATION_STATUS_UNKNOWN_VERSION
+} sct_validation_status_t;
+
+/******************************************
+ * CT policy evaluation context functions *
+ ******************************************/
+
+/*
+ * Creates a new, empty policy evaluation context associated with the given
+ * library context and property query string.
+ * The caller is responsible for calling CT_POLICY_EVAL_CTX_free when finished
+ * with the CT_POLICY_EVAL_CTX.
+ */
+CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new_ex(OSSL_LIB_CTX *libctx,
+                                              const char *propq);
+                                                       
+/*
+ * The same as CT_POLICY_EVAL_CTX_new_ex() but the default library
+ * context and property query string is used.
+ */
+CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new(void);
+
+/* Deletes a policy evaluation context and anything it owns. */
+void CT_POLICY_EVAL_CTX_free(CT_POLICY_EVAL_CTX *ctx);
+
+/* Gets the peer certificate that the SCTs are for */
+X509* CT_POLICY_EVAL_CTX_get0_cert(const CT_POLICY_EVAL_CTX *ctx);
+
+/*
+ * Sets the certificate associated with the received SCTs.
+ * Increments the reference count of cert.
+ * Returns 1 on success, 0 otherwise.
+ */
+int CT_POLICY_EVAL_CTX_set1_cert(CT_POLICY_EVAL_CTX *ctx, X509 *cert);
+
+/* Gets the issuer of the aforementioned certificate */
+X509* CT_POLICY_EVAL_CTX_get0_issuer(const CT_POLICY_EVAL_CTX *ctx);
+
+/*
+ * Sets the issuer of the certificate associated with the received SCTs.
+ * Increments the reference count of issuer.
+ * Returns 1 on success, 0 otherwise.
+ */
+int CT_POLICY_EVAL_CTX_set1_issuer(CT_POLICY_EVAL_CTX *ctx, X509 *issuer);
+
+/* Gets the CT logs that are trusted sources of SCTs */
+const CTLOG_STORE *CT_POLICY_EVAL_CTX_get0_log_store(const CT_POLICY_EVAL_CTX *ctx);
+
+/* Sets the log store that is in use. It must outlive the CT_POLICY_EVAL_CTX. */
+void CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(CT_POLICY_EVAL_CTX *ctx,
+                                               CTLOG_STORE *log_store);
+
+/*
+ * Gets the time, in milliseconds since the Unix epoch, that will be used as the
+ * current time when checking whether an SCT was issued in the future.
+ * Such SCTs will fail validation, as required by RFC6962.
+ */
+uint64_t CT_POLICY_EVAL_CTX_get_time(const CT_POLICY_EVAL_CTX *ctx);
+
+/*
+ * Sets the time to evaluate SCTs against, in milliseconds since the Unix epoch.
+ * If an SCT's timestamp is after this time, it will be interpreted as having
+ * been issued in the future. RFC6962 states that "TLS clients MUST reject SCTs
+ * whose timestamp is in the future", so an SCT will not validate in this case.
+ */
+void CT_POLICY_EVAL_CTX_set_time(CT_POLICY_EVAL_CTX *ctx, uint64_t time_in_ms);
+
+/*****************
+ * SCT functions *
+ *****************/
+
+/*
+ * Creates a new, blank SCT.
+ * The caller is responsible for calling SCT_free when finished with the SCT.
+ */
+SCT *SCT_new(void);
+
+/*
+ * Creates a new SCT from some base64-encoded strings.
+ * The caller is responsible for calling SCT_free when finished with the SCT.
+ */
+SCT *SCT_new_from_base64(unsigned char version,
+                         const char *logid_base64,
+                         ct_log_entry_type_t entry_type,
+                         uint64_t timestamp,
+                         const char *extensions_base64,
+                         const char *signature_base64);
+
+/*
+ * Frees the SCT and the underlying data structures.
+ */
+void SCT_free(SCT *sct);
+
+/*
+ * Free a stack of SCTs, and the underlying SCTs themselves.
+ * Intended to be compatible with X509V3_EXT_FREE.
+ */
+void SCT_LIST_free(STACK_OF(SCT) *a);
+
+/*
+ * Returns the version of the SCT.
+ */
+sct_version_t SCT_get_version(const SCT *sct);
+
+/*
+ * Set the version of an SCT.
+ * Returns 1 on success, 0 if the version is unrecognized.
+ */
+__owur int SCT_set_version(SCT *sct, sct_version_t version);
+
+/*
+ * Returns the log entry type of the SCT.
+ */
+ct_log_entry_type_t SCT_get_log_entry_type(const SCT *sct);
+
+/*
+ * Set the log entry type of an SCT.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set_log_entry_type(SCT *sct, ct_log_entry_type_t entry_type);
+
+/*
+ * Gets the ID of the log that an SCT came from.
+ * Ownership of the log ID remains with the SCT.
+ * Returns the length of the log ID.
+ */
+size_t SCT_get0_log_id(const SCT *sct, unsigned char **log_id);
+
+/*
+ * Set the log ID of an SCT to point directly to the *log_id specified.
+ * The SCT takes ownership of the specified pointer.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len);
+
+/*
+ * Set the log ID of an SCT.
+ * This makes a copy of the log_id.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set1_log_id(SCT *sct, const unsigned char *log_id,
+                           size_t log_id_len);
+
+/*
+ * Returns the timestamp for the SCT (epoch time in milliseconds).
+ */
+uint64_t SCT_get_timestamp(const SCT *sct);
+
+/*
+ * Set the timestamp of an SCT (epoch time in milliseconds).
+ */
+void SCT_set_timestamp(SCT *sct, uint64_t timestamp);
+
+/*
+ * Return the NID for the signature used by the SCT.
+ * For CT v1, this will be either NID_sha256WithRSAEncryption or
+ * NID_ecdsa_with_SHA256 (or NID_undef if incorrect/unset).
+ */
+int SCT_get_signature_nid(const SCT *sct);
+
+/*
+ * Set the signature type of an SCT
+ * For CT v1, this should be either NID_sha256WithRSAEncryption or
+ * NID_ecdsa_with_SHA256.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set_signature_nid(SCT *sct, int nid);
+
+/*
+ * Set *ext to point to the extension data for the SCT. ext must not be NULL.
+ * The SCT retains ownership of this pointer.
+ * Returns length of the data pointed to.
+ */
+size_t SCT_get0_extensions(const SCT *sct, unsigned char **ext);
+
+/*
+ * Set the extensions of an SCT to point directly to the *ext specified.
+ * The SCT takes ownership of the specified pointer.
+ */
+void SCT_set0_extensions(SCT *sct, unsigned char *ext, size_t ext_len);
+
+/*
+ * Set the extensions of an SCT.
+ * This takes a copy of the ext.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set1_extensions(SCT *sct, const unsigned char *ext,
+                               size_t ext_len);
+
+/*
+ * Set *sig to point to the signature for the SCT. sig must not be NULL.
+ * The SCT retains ownership of this pointer.
+ * Returns length of the data pointed to.
+ */
+size_t SCT_get0_signature(const SCT *sct, unsigned char **sig);
+
+/*
+ * Set the signature of an SCT to point directly to the *sig specified.
+ * The SCT takes ownership of the specified pointer.
+ */
+void SCT_set0_signature(SCT *sct, unsigned char *sig, size_t sig_len);
+
+/*
+ * Set the signature of an SCT to be a copy of the *sig specified.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set1_signature(SCT *sct, const unsigned char *sig,
+                              size_t sig_len);
+
+/*
+ * The origin of this SCT, e.g. TLS extension, OCSP response, etc.
+ */
+sct_source_t SCT_get_source(const SCT *sct);
+
+/*
+ * Set the origin of this SCT, e.g. TLS extension, OCSP response, etc.
+ * Returns 1 on success, 0 otherwise.
+ */
+__owur int SCT_set_source(SCT *sct, sct_source_t source);
+
+/*
+ * Returns a text string describing the validation status of |sct|.
+ */
+const char *SCT_validation_status_string(const SCT *sct);
+
+/*
+ * Pretty-prints an |sct| to |out|.
+ * It will be indented by the number of spaces specified by |indent|.
+ * If |logs| is not NULL, it will be used to lookup the CT log that the SCT came
+ * from, so that the log name can be printed.
+ */
+void SCT_print(const SCT *sct, BIO *out, int indent, const CTLOG_STORE *logs);
+
+/*
+ * Pretty-prints an |sct_list| to |out|.
+ * It will be indented by the number of spaces specified by |indent|.
+ * SCTs will be delimited by |separator|.
+ * If |logs| is not NULL, it will be used to lookup the CT log that each SCT
+ * came from, so that the log names can be printed.
+ */
+void SCT_LIST_print(const STACK_OF(SCT) *sct_list, BIO *out, int indent,
+                    const char *separator, const CTLOG_STORE *logs);
+
+/*
+ * Gets the last result of validating this SCT.
+ * If it has not been validated yet, returns SCT_VALIDATION_STATUS_NOT_SET.
+ */
+sct_validation_status_t SCT_get_validation_status(const SCT *sct);
+
+/*
+ * Validates the given SCT with the provided context.
+ * Sets the "validation_status" field of the SCT.
+ * Returns 1 if the SCT is valid and the signature verifies.
+ * Returns 0 if the SCT is invalid or could not be verified.
+ * Returns -1 if an error occurs.
+ */
+__owur int SCT_validate(SCT *sct, const CT_POLICY_EVAL_CTX *ctx);
+
+/*
+ * Validates the given list of SCTs with the provided context.
+ * Sets the "validation_status" field of each SCT.
+ * Returns 1 if there are no invalid SCTs and all signatures verify.
+ * Returns 0 if at least one SCT is invalid or could not be verified.
+ * Returns a negative integer if an error occurs.
+ */
+__owur int SCT_LIST_validate(const STACK_OF(SCT) *scts,
+                             CT_POLICY_EVAL_CTX *ctx);
+
+
+/*********************************
+ * SCT parsing and serialization *
+ *********************************/
+
+/*
+ * Serialize (to TLS format) a stack of SCTs and return the length.
+ * "a" must not be NULL.
+ * If "pp" is NULL, just return the length of what would have been serialized.
+ * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer
+ * for data that caller is responsible for freeing (only if function returns
+ * successfully).
+ * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring
+ * that "*pp" is large enough to accept all of the serialized data.
+ * Returns < 0 on error, >= 0 indicating bytes written (or would have been)
+ * on success.
+ */
+__owur int i2o_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp);
+
+/*
+ * Convert TLS format SCT list to a stack of SCTs.
+ * If "a" or "*a" is NULL, a new stack will be created that the caller is
+ * responsible for freeing (by calling SCT_LIST_free).
+ * "**pp" and "*pp" must not be NULL.
+ * Upon success, "*pp" will point to after the last bytes read, and a stack
+ * will be returned.
+ * Upon failure, a NULL pointer will be returned, and the position of "*pp" is
+ * not defined.
+ */
+STACK_OF(SCT) *o2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
+                            size_t len);
+
+/*
+ * Serialize (to DER format) a stack of SCTs and return the length.
+ * "a" must not be NULL.
+ * If "pp" is NULL, just returns the length of what would have been serialized.
+ * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer
+ * for data that caller is responsible for freeing (only if function returns
+ * successfully).
+ * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring
+ * that "*pp" is large enough to accept all of the serialized data.
+ * Returns < 0 on error, >= 0 indicating bytes written (or would have been)
+ * on success.
+ */
+__owur int i2d_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp);
+
+/*
+ * Parses an SCT list in DER format and returns it.
+ * If "a" or "*a" is NULL, a new stack will be created that the caller is
+ * responsible for freeing (by calling SCT_LIST_free).
+ * "**pp" and "*pp" must not be NULL.
+ * Upon success, "*pp" will point to after the last bytes read, and a stack
+ * will be returned.
+ * Upon failure, a NULL pointer will be returned, and the position of "*pp" is
+ * not defined.
+ */
+STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
+                            long len);
+
+/*
+ * Serialize (to TLS format) an |sct| and write it to |out|.
+ * If |out| is null, no SCT will be output but the length will still be returned.
+ * If |out| points to a null pointer, a string will be allocated to hold the
+ * TLS-format SCT. It is the responsibility of the caller to free it.
+ * If |out| points to an allocated string, the TLS-format SCT will be written
+ * to it.
+ * The length of the SCT in TLS format will be returned.
+ */
+__owur int i2o_SCT(const SCT *sct, unsigned char **out);
+
+/*
+ * Parses an SCT in TLS format and returns it.
+ * If |psct| is not null, it will end up pointing to the parsed SCT. If it
+ * already points to a non-null pointer, the pointer will be free'd.
+ * |in| should be a pointer to a string containing the TLS-format SCT.
+ * |in| will be advanced to the end of the SCT if parsing succeeds.
+ * |len| should be the length of the SCT in |in|.
+ * Returns NULL if an error occurs.
+ * If the SCT is an unsupported version, only the SCT's 'sct' and 'sct_len'
+ * fields will be populated (with |in| and |len| respectively).
+ */
+SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len);
+
+/********************
+ * CT log functions *
+ ********************/
+
+/*
+ * Creates a new CT log instance with the given |public_key| and |name| and
+ * associates it with the give library context |libctx| and property query
+ * string |propq|.
+ * Takes ownership of |public_key| but copies |name|.
+ * Returns NULL if malloc fails or if |public_key| cannot be converted to DER.
+ * Should be deleted by the caller using CTLOG_free when no longer needed.
+ */
+CTLOG *CTLOG_new_ex(EVP_PKEY *public_key, const char *name, OSSL_LIB_CTX *libctx,
+                    const char *propq);
+
+/*
+ * The same as CTLOG_new_ex except that the default library context and
+ * property query string are used.
+ */
+CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name);
+
+/*
+ * Creates a new CTLOG instance with the base64-encoded SubjectPublicKeyInfo DER
+ * in |pkey_base64| and associated with the given library context |libctx| and
+ * property query string |propq|. The |name| is a string to help users identify
+ * this log.
+ * Returns 1 on success, 0 on failure.
+ * Should be deleted by the caller using CTLOG_free when no longer needed.
+ */
+int CTLOG_new_from_base64_ex(CTLOG **ct_log, const char *pkey_base64,
+                             const char *name, OSSL_LIB_CTX *libctx,
+                             const char *propq);
+
+/*
+ * The same as CTLOG_new_from_base64_ex() except that the default
+ * library context and property query string are used.
+ * Returns 1 on success, 0 on failure.
+ */
+int CTLOG_new_from_base64(CTLOG ** ct_log,
+                          const char *pkey_base64, const char *name);
+
+/*
+ * Deletes a CT log instance and its fields.
+ */
+void CTLOG_free(CTLOG *log);
+
+/* Gets the name of the CT log */
+const char *CTLOG_get0_name(const CTLOG *log);
+/* Gets the ID of the CT log */
+void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id,
+                       size_t *log_id_len);
+/* Gets the public key of the CT log */
+EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log);
+
+/**************************
+ * CT log store functions *
+ **************************/
+
+/*
+ * Creates a new CT log store and associates it with the given libctx and
+ * property query string.
+ * Should be deleted by the caller using CTLOG_STORE_free when no longer needed.
+ */
+CTLOG_STORE *CTLOG_STORE_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+/*
+ * Same as CTLOG_STORE_new_ex except that the default libctx and
+ * property query string are used.
+ * Should be deleted by the caller using CTLOG_STORE_free when no longer needed.
+ */
+CTLOG_STORE *CTLOG_STORE_new(void);
+
+/*
+ * Deletes a CT log store and all of the CT log instances held within.
+ */
+void CTLOG_STORE_free(CTLOG_STORE *store);
+
+/*
+ * Finds a CT log in the store based on its log ID.
+ * Returns the CT log, or NULL if no match is found.
+ */
+const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store,
+                                        const uint8_t *log_id,
+                                        size_t log_id_len);
+
+/*
+ * Loads a CT log list into a |store| from a |file|.
+ * Returns 1 if loading is successful, or 0 otherwise.
+ */
+__owur int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file);
+
+/*
+ * Loads the default CT log list into a |store|.
+ * Returns 1 if loading is successful, or 0 otherwise.
+ */
+__owur int CTLOG_STORE_load_default_file(CTLOG_STORE *store);
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/cterr.h b/CAPI/cpp/grpc/include/openssl/cterr.h
new file mode 100644
index 0000000..935d32d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/cterr.h
@@ -0,0 +1,45 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_CTERR_H
+# define OPENSSL_CTERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_CT
+
+
+/*
+ * CT reason codes.
+ */
+#  define CT_R_BASE64_DECODE_ERROR                         108
+#  define CT_R_INVALID_LOG_ID_LENGTH                       100
+#  define CT_R_LOG_CONF_INVALID                            109
+#  define CT_R_LOG_CONF_INVALID_KEY                        110
+#  define CT_R_LOG_CONF_MISSING_DESCRIPTION                111
+#  define CT_R_LOG_CONF_MISSING_KEY                        112
+#  define CT_R_LOG_KEY_INVALID                             113
+#  define CT_R_SCT_FUTURE_TIMESTAMP                        116
+#  define CT_R_SCT_INVALID                                 104
+#  define CT_R_SCT_INVALID_SIGNATURE                       107
+#  define CT_R_SCT_LIST_INVALID                            105
+#  define CT_R_SCT_LOG_ID_MISMATCH                         114
+#  define CT_R_SCT_NOT_SET                                 106
+#  define CT_R_SCT_UNSUPPORTED_VERSION                     115
+#  define CT_R_UNRECOGNIZED_SIGNATURE_NID                  101
+#  define CT_R_UNSUPPORTED_ENTRY_TYPE                      102
+#  define CT_R_UNSUPPORTED_VERSION                         103
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/decoder.h b/CAPI/cpp/grpc/include/openssl/decoder.h
new file mode 100644
index 0000000..d4ee2cf
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/decoder.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DECODER_H
+# define OPENSSL_DECODER_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <stdarg.h>
+# include <stddef.h>
+# include <openssl/decodererr.h>
+# include <openssl/types.h>
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+OSSL_DECODER *OSSL_DECODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
+                                 const char *properties);
+int OSSL_DECODER_up_ref(OSSL_DECODER *encoder);
+void OSSL_DECODER_free(OSSL_DECODER *encoder);
+
+const OSSL_PROVIDER *OSSL_DECODER_get0_provider(const OSSL_DECODER *encoder);
+const char *OSSL_DECODER_get0_properties(const OSSL_DECODER *encoder);
+const char *OSSL_DECODER_get0_name(const OSSL_DECODER *decoder);
+const char *OSSL_DECODER_get0_description(const OSSL_DECODER *decoder);
+int OSSL_DECODER_is_a(const OSSL_DECODER *encoder, const char *name);
+
+void OSSL_DECODER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                  void (*fn)(OSSL_DECODER *encoder, void *arg),
+                                  void *arg);
+int OSSL_DECODER_names_do_all(const OSSL_DECODER *encoder,
+                              void (*fn)(const char *name, void *data),
+                              void *data);
+const OSSL_PARAM *OSSL_DECODER_gettable_params(OSSL_DECODER *decoder);
+int OSSL_DECODER_get_params(OSSL_DECODER *decoder, OSSL_PARAM params[]);
+
+const OSSL_PARAM *OSSL_DECODER_settable_ctx_params(OSSL_DECODER *encoder);
+OSSL_DECODER_CTX *OSSL_DECODER_CTX_new(void);
+int OSSL_DECODER_CTX_set_params(OSSL_DECODER_CTX *ctx,
+                                const OSSL_PARAM params[]);
+void OSSL_DECODER_CTX_free(OSSL_DECODER_CTX *ctx);
+
+/* Utilities that help set specific parameters */
+int OSSL_DECODER_CTX_set_passphrase(OSSL_DECODER_CTX *ctx,
+                                    const unsigned char *kstr, size_t klen);
+int OSSL_DECODER_CTX_set_pem_password_cb(OSSL_DECODER_CTX *ctx,
+                                         pem_password_cb *cb, void *cbarg);
+int OSSL_DECODER_CTX_set_passphrase_cb(OSSL_DECODER_CTX *ctx,
+                                       OSSL_PASSPHRASE_CALLBACK *cb,
+                                       void *cbarg);
+int OSSL_DECODER_CTX_set_passphrase_ui(OSSL_DECODER_CTX *ctx,
+                                       const UI_METHOD *ui_method,
+                                       void *ui_data);
+
+/*
+ * Utilities to read the object to decode, with the result sent to cb.
+ * These will discover all provided methods
+ */
+
+int OSSL_DECODER_CTX_set_selection(OSSL_DECODER_CTX *ctx, int selection);
+int OSSL_DECODER_CTX_set_input_type(OSSL_DECODER_CTX *ctx,
+                                    const char *input_type);
+int OSSL_DECODER_CTX_set_input_structure(OSSL_DECODER_CTX *ctx,
+                                         const char *input_structure);
+int OSSL_DECODER_CTX_add_decoder(OSSL_DECODER_CTX *ctx, OSSL_DECODER *decoder);
+int OSSL_DECODER_CTX_add_extra(OSSL_DECODER_CTX *ctx,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+int OSSL_DECODER_CTX_get_num_decoders(OSSL_DECODER_CTX *ctx);
+
+typedef struct ossl_decoder_instance_st OSSL_DECODER_INSTANCE;
+OSSL_DECODER *
+OSSL_DECODER_INSTANCE_get_decoder(OSSL_DECODER_INSTANCE *decoder_inst);
+void *
+OSSL_DECODER_INSTANCE_get_decoder_ctx(OSSL_DECODER_INSTANCE *decoder_inst);
+const char *
+OSSL_DECODER_INSTANCE_get_input_type(OSSL_DECODER_INSTANCE *decoder_inst);
+const char *
+OSSL_DECODER_INSTANCE_get_input_structure(OSSL_DECODER_INSTANCE *decoder_inst,
+                                          int *was_set);
+
+typedef int OSSL_DECODER_CONSTRUCT(OSSL_DECODER_INSTANCE *decoder_inst,
+                                   const OSSL_PARAM *params,
+                                   void *construct_data);
+typedef void OSSL_DECODER_CLEANUP(void *construct_data);
+
+int OSSL_DECODER_CTX_set_construct(OSSL_DECODER_CTX *ctx,
+                                   OSSL_DECODER_CONSTRUCT *construct);
+int OSSL_DECODER_CTX_set_construct_data(OSSL_DECODER_CTX *ctx,
+                                        void *construct_data);
+int OSSL_DECODER_CTX_set_cleanup(OSSL_DECODER_CTX *ctx,
+                                 OSSL_DECODER_CLEANUP *cleanup);
+OSSL_DECODER_CONSTRUCT *OSSL_DECODER_CTX_get_construct(OSSL_DECODER_CTX *ctx);
+void *OSSL_DECODER_CTX_get_construct_data(OSSL_DECODER_CTX *ctx);
+OSSL_DECODER_CLEANUP *OSSL_DECODER_CTX_get_cleanup(OSSL_DECODER_CTX *ctx);
+
+int OSSL_DECODER_export(OSSL_DECODER_INSTANCE *decoder_inst,
+                        void *reference, size_t reference_sz,
+                        OSSL_CALLBACK *export_cb, void *export_cbarg);
+
+int OSSL_DECODER_from_bio(OSSL_DECODER_CTX *ctx, BIO *in);
+#ifndef OPENSSL_NO_STDIO
+int OSSL_DECODER_from_fp(OSSL_DECODER_CTX *ctx, FILE *in);
+#endif
+int OSSL_DECODER_from_data(OSSL_DECODER_CTX *ctx, const unsigned char **pdata,
+                           size_t *pdata_len);
+
+/*
+ * Create the OSSL_DECODER_CTX with an associated type.  This will perform
+ * an implicit OSSL_DECODER_fetch(), suitable for the object of that type.
+ */
+OSSL_DECODER_CTX *
+OSSL_DECODER_CTX_new_for_pkey(EVP_PKEY **pkey,
+                              const char *input_type,
+                              const char *input_struct,
+                              const char *keytype, int selection,
+                              OSSL_LIB_CTX *libctx, const char *propquery);
+
+# ifdef __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/decodererr.h b/CAPI/cpp/grpc/include/openssl/decodererr.h
new file mode 100644
index 0000000..4212a38
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/decodererr.h
@@ -0,0 +1,28 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DECODERERR_H
+# define OPENSSL_DECODERERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * OSSL_DECODER reason codes.
+ */
+# define OSSL_DECODER_R_COULD_NOT_DECODE_OBJECT           101
+# define OSSL_DECODER_R_DECODER_NOT_FOUND                 102
+# define OSSL_DECODER_R_MISSING_GET_PARAMS                100
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/des.h b/CAPI/cpp/grpc/include/openssl/des.h
new file mode 100644
index 0000000..09798a6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/des.h
@@ -0,0 +1,211 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DES_H
+# define OPENSSL_DES_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_DES_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_DES
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+#  include <openssl/e_os2.h>
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef unsigned int DES_LONG;
+
+#   ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#    undef OPENSSL_EXTERN
+#    define OPENSSL_EXTERN OPENSSL_EXPORT
+#   endif
+
+typedef unsigned char DES_cblock[8];
+typedef /* const */ unsigned char const_DES_cblock[8];
+/*
+ * With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * and
+ * const_DES_cblock * are incompatible pointer types.
+ */
+
+typedef struct DES_ks {
+    union {
+        DES_cblock cblock;
+        /*
+         * make sure things are correct size on machines with 8 byte longs
+         */
+        DES_LONG deslong[2];
+    } ks[16];
+} DES_key_schedule;
+
+#   define DES_KEY_SZ      (sizeof(DES_cblock))
+#   define DES_SCHEDULE_SZ (sizeof(DES_key_schedule))
+
+#   define DES_ENCRYPT     1
+#   define DES_DECRYPT     0
+
+#   define DES_CBC_MODE    0
+#   define DES_PCBC_MODE   1
+
+#   define DES_ecb2_encrypt(i,o,k1,k2,e) \
+        DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e))
+
+#   define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \
+        DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e))
+
+#   define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \
+        DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e))
+
+#   define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \
+        DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n))
+
+#   define DES_fixup_key_parity DES_set_odd_parity
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *DES_options(void);
+OSSL_DEPRECATEDIN_3_0
+void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output,
+                      DES_key_schedule *ks1, DES_key_schedule *ks2,
+                      DES_key_schedule *ks3, int enc);
+OSSL_DEPRECATEDIN_3_0
+DES_LONG DES_cbc_cksum(const unsigned char *input, DES_cblock *output,
+                       long length, DES_key_schedule *schedule,
+                       const_DES_cblock *ivec);
+#  endif
+/* DES_cbc_encrypt does not update the IV!  Use DES_ncbc_encrypt instead. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void DES_cbc_encrypt(const unsigned char *input, unsigned char *output,
+                     long length, DES_key_schedule *schedule, DES_cblock *ivec,
+                     int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ncbc_encrypt(const unsigned char *input, unsigned char *output,
+                      long length, DES_key_schedule *schedule, DES_cblock *ivec,
+                      int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_xcbc_encrypt(const unsigned char *input, unsigned char *output,
+                      long length, DES_key_schedule *schedule, DES_cblock *ivec,
+                      const_DES_cblock *inw, const_DES_cblock *outw, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits,
+                     long length, DES_key_schedule *schedule, DES_cblock *ivec,
+                     int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output,
+                     DES_key_schedule *ks, int enc);
+#  endif
+
+/*
+ * This is the DES encryption function that gets called by just about every
+ * other DES routine in the library.  You should not use this function except
+ * to implement 'modes' of DES.  I say this because the functions that call
+ * this routine do the conversion from 'char *' to long, and this needs to be
+ * done to make sure 'non-aligned' memory access do not occur.  The
+ * characters are loaded 'little endian'. Data is a pointer to 2 unsigned
+ * long's and ks is the DES_key_schedule to use.  enc, is non zero specifies
+ * encryption, zero if decryption.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc);
+#  endif
+
+/*
+ * This functions is the same as DES_encrypt1() except that the DES initial
+ * permutation (IP) and final permutation (FP) have been left out.  As for
+ * DES_encrypt1(), you should not use this function. It is used by the
+ * routines in the library that implement triple DES. IP() DES_encrypt2()
+ * DES_encrypt2() DES_encrypt2() FP() is the same as DES_encrypt1()
+ * DES_encrypt1() DES_encrypt1() except faster :-).
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, DES_key_schedule *ks2,
+                  DES_key_schedule *ks3);
+OSSL_DEPRECATEDIN_3_0
+void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, DES_key_schedule *ks2,
+                  DES_key_schedule *ks3);
+OSSL_DEPRECATEDIN_3_0
+void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output,
+                          long length, DES_key_schedule *ks1,
+                          DES_key_schedule *ks2, DES_key_schedule *ks3,
+                          DES_cblock *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+                            long length, DES_key_schedule *ks1,
+                            DES_key_schedule *ks2, DES_key_schedule *ks3,
+                            DES_cblock *ivec, int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ede3_cfb_encrypt(const unsigned char *in, unsigned char *out,
+                          int numbits, long length, DES_key_schedule *ks1,
+                          DES_key_schedule *ks2, DES_key_schedule *ks3,
+                          DES_cblock *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ede3_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+                            long length, DES_key_schedule *ks1,
+                            DES_key_schedule *ks2, DES_key_schedule *ks3,
+                            DES_cblock *ivec, int *num);
+OSSL_DEPRECATEDIN_3_0
+char *DES_fcrypt(const char *buf, const char *salt, char *ret);
+OSSL_DEPRECATEDIN_3_0
+char *DES_crypt(const char *buf, const char *salt);
+OSSL_DEPRECATEDIN_3_0
+void DES_ofb_encrypt(const unsigned char *in, unsigned char *out, int numbits,
+                     long length, DES_key_schedule *schedule, DES_cblock *ivec);
+OSSL_DEPRECATEDIN_3_0
+void DES_pcbc_encrypt(const unsigned char *input, unsigned char *output,
+                      long length, DES_key_schedule *schedule,
+                      DES_cblock *ivec, int enc);
+OSSL_DEPRECATEDIN_3_0
+DES_LONG DES_quad_cksum(const unsigned char *input, DES_cblock output[],
+                        long length, int out_count, DES_cblock *seed);
+OSSL_DEPRECATEDIN_3_0 int DES_random_key(DES_cblock *ret);
+OSSL_DEPRECATEDIN_3_0 void DES_set_odd_parity(DES_cblock *key);
+OSSL_DEPRECATEDIN_3_0 int DES_check_key_parity(const_DES_cblock *key);
+OSSL_DEPRECATEDIN_3_0 int DES_is_weak_key(const_DES_cblock *key);
+#  endif
+/*
+ * DES_set_key (= set_key = DES_key_sched = key_sched) calls
+ * DES_set_key_checked
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule);
+OSSL_DEPRECATEDIN_3_0
+int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule);
+OSSL_DEPRECATEDIN_3_0
+int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule);
+OSSL_DEPRECATEDIN_3_0
+void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule);
+OSSL_DEPRECATEDIN_3_0 void DES_string_to_key(const char *str, DES_cblock *key);
+OSSL_DEPRECATEDIN_3_0
+void DES_string_to_2keys(const char *str, DES_cblock *key1, DES_cblock *key2);
+OSSL_DEPRECATEDIN_3_0
+void DES_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+                       long length, DES_key_schedule *schedule,
+                       DES_cblock *ivec, int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void DES_ofb64_encrypt(const unsigned char *in, unsigned char *out,
+                       long length, DES_key_schedule *schedule,
+                       DES_cblock *ivec, int *num);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/dh.h b/CAPI/cpp/grpc/include/openssl/dh.h
new file mode 100644
index 0000000..b97871e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/dh.h
@@ -0,0 +1,328 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DH_H
+# define OPENSSL_DH_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_DH_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+#include <stdlib.h>
+
+/* DH parameter generation types used by EVP_PKEY_CTX_set_dh_paramgen_type() */
+# define DH_PARAMGEN_TYPE_GENERATOR     0   /* Use a safe prime generator */
+# define DH_PARAMGEN_TYPE_FIPS_186_2    1   /* Use FIPS186-2 standard */
+# define DH_PARAMGEN_TYPE_FIPS_186_4    2   /* Use FIPS186-4 standard */
+# define DH_PARAMGEN_TYPE_GROUP         3   /* Use a named safe prime group */
+
+int EVP_PKEY_CTX_set_dh_paramgen_type(EVP_PKEY_CTX *ctx, int typ);
+int EVP_PKEY_CTX_set_dh_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex);
+int EVP_PKEY_CTX_set_dh_paramgen_seed(EVP_PKEY_CTX *ctx,
+                                      const unsigned char *seed,
+                                      size_t seedlen);
+int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *ctx, int pbits);
+int EVP_PKEY_CTX_set_dh_paramgen_subprime_len(EVP_PKEY_CTX *ctx, int qlen);
+int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *ctx, int gen);
+int EVP_PKEY_CTX_set_dh_nid(EVP_PKEY_CTX *ctx, int nid);
+int EVP_PKEY_CTX_set_dh_rfc5114(EVP_PKEY_CTX *ctx, int gen);
+int EVP_PKEY_CTX_set_dhx_rfc5114(EVP_PKEY_CTX *ctx, int gen);
+int EVP_PKEY_CTX_set_dh_pad(EVP_PKEY_CTX *ctx, int pad);
+
+int EVP_PKEY_CTX_set_dh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
+int EVP_PKEY_CTX_get_dh_kdf_type(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_CTX_set0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT *oid);
+int EVP_PKEY_CTX_get0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT **oid);
+int EVP_PKEY_CTX_set_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_get_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+int EVP_PKEY_CTX_set_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
+int EVP_PKEY_CTX_get_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
+int EVP_PKEY_CTX_set0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_CTX_get0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **ukm);
+#endif
+
+# define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN     (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR     (EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_DH_RFC5114                (EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN  (EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_DH_PARAMGEN_TYPE          (EVP_PKEY_ALG_CTRL + 5)
+# define EVP_PKEY_CTRL_DH_KDF_TYPE               (EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_DH_KDF_MD                 (EVP_PKEY_ALG_CTRL + 7)
+# define EVP_PKEY_CTRL_GET_DH_KDF_MD             (EVP_PKEY_ALG_CTRL + 8)
+# define EVP_PKEY_CTRL_DH_KDF_OUTLEN             (EVP_PKEY_ALG_CTRL + 9)
+# define EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN         (EVP_PKEY_ALG_CTRL + 10)
+# define EVP_PKEY_CTRL_DH_KDF_UKM                (EVP_PKEY_ALG_CTRL + 11)
+# define EVP_PKEY_CTRL_GET_DH_KDF_UKM            (EVP_PKEY_ALG_CTRL + 12)
+# define EVP_PKEY_CTRL_DH_KDF_OID                (EVP_PKEY_ALG_CTRL + 13)
+# define EVP_PKEY_CTRL_GET_DH_KDF_OID            (EVP_PKEY_ALG_CTRL + 14)
+# define EVP_PKEY_CTRL_DH_NID                    (EVP_PKEY_ALG_CTRL + 15)
+# define EVP_PKEY_CTRL_DH_PAD                    (EVP_PKEY_ALG_CTRL + 16)
+
+/* KDF types */
+# define EVP_PKEY_DH_KDF_NONE                            1
+# define EVP_PKEY_DH_KDF_X9_42                           2
+
+# ifndef OPENSSL_NO_DH
+#  include <openssl/e_os2.h>
+#  include <openssl/bio.h>
+#  include <openssl/asn1.h>
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   include <openssl/bn.h>
+#  endif
+#  include <openssl/dherr.h>
+
+#  ifndef OPENSSL_DH_MAX_MODULUS_BITS
+#   define OPENSSL_DH_MAX_MODULUS_BITS    10000
+#  endif
+
+#  define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 1024
+
+#  define DH_FLAG_CACHE_MONT_P     0x01
+
+#  define DH_FLAG_TYPE_MASK             0xF000
+#  define DH_FLAG_TYPE_DH               0x0000
+#  define DH_FLAG_TYPE_DHX              0x1000
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/*
+ * Does nothing. Previously this switched off constant time behaviour.
+ */
+#   define DH_FLAG_NO_EXP_CONSTTIME 0x00
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * If this flag is set the DH method is FIPS compliant and can be used in
+ * FIPS mode. This is set in the validated module method. If an application
+ * sets this flag in its own methods it is its responsibility to ensure the
+ * result is compliant.
+ */
+
+#   define DH_FLAG_FIPS_METHOD                     0x0400
+
+/*
+ * If this flag is set the operations normally disabled in FIPS mode are
+ * permitted it is then the applications responsibility to ensure that the
+ * usage is compliant.
+ */
+
+#   define DH_FLAG_NON_FIPS_ALLOW                  0x0400
+#  endif
+
+/* Already defined in ossl_typ.h */
+/* typedef struct dh_st DH; */
+/* typedef struct dh_method DH_METHOD; */
+
+DECLARE_ASN1_ITEM(DHparams)
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DH_GENERATOR_2          2
+#   define DH_GENERATOR_3          3
+#   define DH_GENERATOR_5          5
+
+/* DH_check error codes */
+/*
+ * NB: These values must align with the equivalently named macros in
+ * internal/ffc.h.
+ */
+#   define DH_CHECK_P_NOT_PRIME            0x01
+#   define DH_CHECK_P_NOT_SAFE_PRIME       0x02
+#   define DH_UNABLE_TO_CHECK_GENERATOR    0x04
+#   define DH_NOT_SUITABLE_GENERATOR       0x08
+#   define DH_CHECK_Q_NOT_PRIME            0x10
+#   define DH_CHECK_INVALID_Q_VALUE        0x20
+#   define DH_CHECK_INVALID_J_VALUE        0x40
+#   define DH_MODULUS_TOO_SMALL            0x80
+#   define DH_MODULUS_TOO_LARGE            0x100
+
+/* DH_check_pub_key error codes */
+#   define DH_CHECK_PUBKEY_TOO_SMALL       0x01
+#   define DH_CHECK_PUBKEY_TOO_LARGE       0x02
+#   define DH_CHECK_PUBKEY_INVALID         0x04
+
+/*
+ * primes p where (p-1)/2 is prime too are called "safe"; we define this for
+ * backward compatibility:
+ */
+#   define DH_CHECK_P_NOT_STRONG_PRIME     DH_CHECK_P_NOT_SAFE_PRIME
+
+#   define d2i_DHparams_fp(fp, x) \
+        (DH *)ASN1_d2i_fp((char *(*)())DH_new, \
+                          (char *(*)())d2i_DHparams, \
+                          (fp), \
+                          (unsigned char **)(x))
+#   define i2d_DHparams_fp(fp, x) \
+        ASN1_i2d_fp(i2d_DHparams,(fp), (unsigned char *)(x))
+#   define d2i_DHparams_bio(bp, x) \
+        ASN1_d2i_bio_of(DH, DH_new, d2i_DHparams, bp, x)
+#   define i2d_DHparams_bio(bp, x) \
+        ASN1_i2d_bio_of(DH, i2d_DHparams, bp, x)
+
+#   define d2i_DHxparams_fp(fp,x) \
+        (DH *)ASN1_d2i_fp((char *(*)())DH_new, \
+                          (char *(*)())d2i_DHxparams, \
+                          (fp), \
+                          (unsigned char **)(x))
+#   define i2d_DHxparams_fp(fp, x) \
+        ASN1_i2d_fp(i2d_DHxparams,(fp), (unsigned char *)(x))
+#   define d2i_DHxparams_bio(bp, x) \
+        ASN1_d2i_bio_of(DH, DH_new, d2i_DHxparams, bp, x)
+#   define i2d_DHxparams_bio(bp, x) \
+        ASN1_i2d_bio_of(DH, i2d_DHxparams, bp, x)
+
+DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, DH, DHparams)
+
+OSSL_DEPRECATEDIN_3_0 const DH_METHOD *DH_OpenSSL(void);
+
+OSSL_DEPRECATEDIN_3_0 void DH_set_default_method(const DH_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const DH_METHOD *DH_get_default_method(void);
+OSSL_DEPRECATEDIN_3_0 int DH_set_method(DH *dh, const DH_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 DH *DH_new_method(ENGINE *engine);
+
+OSSL_DEPRECATEDIN_3_0 DH *DH_new(void);
+OSSL_DEPRECATEDIN_3_0 void DH_free(DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_up_ref(DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_bits(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_size(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_security_bits(const DH *dh);
+
+#   define DH_get_ex_new_index(l, p, newf, dupf, freef) \
+        CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DH, l, p, newf, dupf, freef)
+
+OSSL_DEPRECATEDIN_3_0 int DH_set_ex_data(DH *d, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *DH_get_ex_data(const DH *d, int idx);
+
+OSSL_DEPRECATEDIN_3_0 int DH_generate_parameters_ex(DH *dh, int prime_len,
+                                                    int generator,
+                                                    BN_GENCB *cb);
+
+OSSL_DEPRECATEDIN_3_0 int DH_check_params_ex(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_check_ex(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_check_pub_key_ex(const DH *dh, const BIGNUM *pub_key);
+OSSL_DEPRECATEDIN_3_0 int DH_check_params(const DH *dh, int *ret);
+OSSL_DEPRECATEDIN_3_0 int DH_check(const DH *dh, int *codes);
+OSSL_DEPRECATEDIN_3_0 int DH_check_pub_key(const DH *dh, const BIGNUM *pub_key,
+                                           int *codes);
+OSSL_DEPRECATEDIN_3_0 int DH_generate_key(DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_compute_key(unsigned char *key,
+                                         const BIGNUM *pub_key, DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_compute_key_padded(unsigned char *key,
+                                                const BIGNUM *pub_key, DH *dh);
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DH, DHparams)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DH, DHxparams)
+
+#   ifndef OPENSSL_NO_STDIO
+OSSL_DEPRECATEDIN_3_0 int DHparams_print_fp(FILE *fp, const DH *x);
+#   endif
+OSSL_DEPRECATEDIN_3_0 int DHparams_print(BIO *bp, const DH *x);
+
+/* RFC 5114 parameters */
+OSSL_DEPRECATEDIN_3_0 DH *DH_get_1024_160(void);
+OSSL_DEPRECATEDIN_3_0 DH *DH_get_2048_224(void);
+OSSL_DEPRECATEDIN_3_0 DH *DH_get_2048_256(void);
+
+/* Named parameters, currently RFC7919 and RFC3526 */
+OSSL_DEPRECATEDIN_3_0 DH *DH_new_by_nid(int nid);
+OSSL_DEPRECATEDIN_3_0 int DH_get_nid(const DH *dh);
+
+/* RFC2631 KDF */
+OSSL_DEPRECATEDIN_3_0 int DH_KDF_X9_42(unsigned char *out, size_t outlen,
+                                       const unsigned char *Z, size_t Zlen,
+                                       ASN1_OBJECT *key_oid,
+                                       const unsigned char *ukm,
+                                       size_t ukmlen, const EVP_MD *md);
+
+OSSL_DEPRECATEDIN_3_0 void DH_get0_pqg(const DH *dh, const BIGNUM **p,
+                                       const BIGNUM **q, const BIGNUM **g);
+OSSL_DEPRECATEDIN_3_0 int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g);
+OSSL_DEPRECATEDIN_3_0 void DH_get0_key(const DH *dh, const BIGNUM **pub_key,
+                                       const BIGNUM **priv_key);
+OSSL_DEPRECATEDIN_3_0 int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_p(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_q(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_g(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_priv_key(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_pub_key(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 void DH_clear_flags(DH *dh, int flags);
+OSSL_DEPRECATEDIN_3_0 int DH_test_flags(const DH *dh, int flags);
+OSSL_DEPRECATEDIN_3_0 void DH_set_flags(DH *dh, int flags);
+OSSL_DEPRECATEDIN_3_0 ENGINE *DH_get0_engine(DH *d);
+OSSL_DEPRECATEDIN_3_0 long DH_get_length(const DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_set_length(DH *dh, long length);
+
+OSSL_DEPRECATEDIN_3_0 DH_METHOD *DH_meth_new(const char *name, int flags);
+OSSL_DEPRECATEDIN_3_0 void DH_meth_free(DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 DH_METHOD *DH_meth_dup(const DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 const char *DH_meth_get0_name(const DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set1_name(DH_METHOD *dhm, const char *name);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_get_flags(const DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_flags(DH_METHOD *dhm, int flags);
+OSSL_DEPRECATEDIN_3_0 void *DH_meth_get0_app_data(const DH_METHOD *dhm);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data);
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_generate_key(DH_METHOD *dhm,
+                                                   int (*generate_key) (DH *));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_compute_key(const DH_METHOD *dhm))
+                                                   (unsigned char *key,
+                                                    const BIGNUM *pub_key,
+                                                    DH *dh);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_compute_key(DH_METHOD *dhm,
+                                                  int (*compute_key)
+                                                  (unsigned char *key,
+                                                   const BIGNUM *pub_key,
+                                                   DH *dh));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm))
+                                                   (const DH *, BIGNUM *,
+                                                    const BIGNUM *,
+                                                    const BIGNUM *,
+                                                    const BIGNUM *, BN_CTX *,
+                                                    BN_MONT_CTX *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_bn_mod_exp(DH_METHOD *dhm,
+                                                 int (*bn_mod_exp)
+                                                 (const DH *, BIGNUM *,
+                                                  const BIGNUM *, const BIGNUM *,
+                                                  const BIGNUM *, BN_CTX *,
+                                                  BN_MONT_CTX *));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *));
+OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_generate_params(const DH_METHOD *dhm))
+                                                        (DH *, int, int,
+                                                         BN_GENCB *);
+OSSL_DEPRECATEDIN_3_0 int DH_meth_set_generate_params(DH_METHOD *dhm,
+                                                      int (*generate_params)
+                                                      (DH *, int, int,
+                                                       BN_GENCB *));
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+#  ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8 DH *DH_generate_parameters(int prime_len, int generator,
+                                                   void (*callback) (int, int,
+                                                                void *),
+                                                   void *cb_arg);
+#  endif
+
+# endif
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/dherr.h b/CAPI/cpp/grpc/include/openssl/dherr.h
new file mode 100644
index 0000000..5d2a762
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/dherr.h
@@ -0,0 +1,57 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DHERR_H
+# define OPENSSL_DHERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_DH
+
+
+/*
+ * DH reason codes.
+ */
+#  define DH_R_BAD_FFC_PARAMETERS                          127
+#  define DH_R_BAD_GENERATOR                               101
+#  define DH_R_BN_DECODE_ERROR                             109
+#  define DH_R_BN_ERROR                                    106
+#  define DH_R_CHECK_INVALID_J_VALUE                       115
+#  define DH_R_CHECK_INVALID_Q_VALUE                       116
+#  define DH_R_CHECK_PUBKEY_INVALID                        122
+#  define DH_R_CHECK_PUBKEY_TOO_LARGE                      123
+#  define DH_R_CHECK_PUBKEY_TOO_SMALL                      124
+#  define DH_R_CHECK_P_NOT_PRIME                           117
+#  define DH_R_CHECK_P_NOT_SAFE_PRIME                      118
+#  define DH_R_CHECK_Q_NOT_PRIME                           119
+#  define DH_R_DECODE_ERROR                                104
+#  define DH_R_INVALID_PARAMETER_NAME                      110
+#  define DH_R_INVALID_PARAMETER_NID                       114
+#  define DH_R_INVALID_PUBKEY                              102
+#  define DH_R_INVALID_SECRET                              128
+#  define DH_R_KDF_PARAMETER_ERROR                         112
+#  define DH_R_KEYS_NOT_SET                                108
+#  define DH_R_MISSING_PUBKEY                              125
+#  define DH_R_MODULUS_TOO_LARGE                           103
+#  define DH_R_MODULUS_TOO_SMALL                           126
+#  define DH_R_NOT_SUITABLE_GENERATOR                      120
+#  define DH_R_NO_PARAMETERS_SET                           107
+#  define DH_R_NO_PRIVATE_VALUE                            100
+#  define DH_R_PARAMETER_ENCODING_ERROR                    105
+#  define DH_R_PEER_KEY_ERROR                              111
+#  define DH_R_SHARED_INFO_ERROR                           113
+#  define DH_R_UNABLE_TO_CHECK_GENERATOR                   121
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/dsa.h b/CAPI/cpp/grpc/include/openssl/dsa.h
new file mode 100644
index 0000000..5c0e4cd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/dsa.h
@@ -0,0 +1,275 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DSA_H
+# define OPENSSL_DSA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_DSA_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# include <stdlib.h>
+
+int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX *ctx, int nbits);
+int EVP_PKEY_CTX_set_dsa_paramgen_q_bits(EVP_PKEY_CTX *ctx, int qbits);
+int EVP_PKEY_CTX_set_dsa_paramgen_md_props(EVP_PKEY_CTX *ctx,
+                                           const char *md_name,
+                                           const char *md_properties);
+int EVP_PKEY_CTX_set_dsa_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex);
+int EVP_PKEY_CTX_set_dsa_paramgen_type(EVP_PKEY_CTX *ctx, const char *name);
+int EVP_PKEY_CTX_set_dsa_paramgen_seed(EVP_PKEY_CTX *ctx,
+                                       const unsigned char *seed,
+                                       size_t seedlen);
+int EVP_PKEY_CTX_set_dsa_paramgen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+
+# define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS         (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS       (EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_DSA_PARAMGEN_MD           (EVP_PKEY_ALG_CTRL + 3)
+
+# ifndef OPENSSL_NO_DSA
+#  include <openssl/e_os2.h>
+#  include <openssl/asn1.h>
+#  include <openssl/bio.h>
+#  include <openssl/crypto.h>
+#  include <openssl/bn.h>
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   include <openssl/dh.h>
+#  endif
+#  include <openssl/dsaerr.h>
+
+#  ifndef OPENSSL_DSA_MAX_MODULUS_BITS
+#   define OPENSSL_DSA_MAX_MODULUS_BITS   10000
+#  endif
+
+#  define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 1024
+
+typedef struct DSA_SIG_st DSA_SIG;
+DSA_SIG *DSA_SIG_new(void);
+void DSA_SIG_free(DSA_SIG *a);
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(DSA_SIG, DSA_SIG)
+void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
+int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s);
+
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/*
+ * Does nothing. Previously this switched off constant time behaviour.
+ */
+#   define DSA_FLAG_NO_EXP_CONSTTIME       0x00
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DSA_FLAG_CACHE_MONT_P   0x01
+
+/*
+ * If this flag is set the DSA method is FIPS compliant and can be used in
+ * FIPS mode. This is set in the validated module method. If an application
+ * sets this flag in its own methods it is its responsibility to ensure the
+ * result is compliant.
+ */
+
+#   define DSA_FLAG_FIPS_METHOD                    0x0400
+
+/*
+ * If this flag is set the operations normally disabled in FIPS mode are
+ * permitted it is then the applications responsibility to ensure that the
+ * usage is compliant.
+ */
+
+#   define DSA_FLAG_NON_FIPS_ALLOW                 0x0400
+#   define DSA_FLAG_FIPS_CHECKED                   0x0800
+
+/* Already defined in ossl_typ.h */
+/* typedef struct dsa_st DSA; */
+/* typedef struct dsa_method DSA_METHOD; */
+
+#   define d2i_DSAparams_fp(fp, x) \
+        (DSA *)ASN1_d2i_fp((char *(*)())DSA_new, \
+                           (char *(*)())d2i_DSAparams, (fp), \
+                           (unsigned char **)(x))
+#   define i2d_DSAparams_fp(fp, x) \
+        ASN1_i2d_fp(i2d_DSAparams, (fp), (unsigned char *)(x))
+#   define d2i_DSAparams_bio(bp, x) \
+        ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSAparams, bp, x)
+#   define i2d_DSAparams_bio(bp, x) \
+        ASN1_i2d_bio_of(DSA, i2d_DSAparams, bp, x)
+
+DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, DSA, DSAparams)
+OSSL_DEPRECATEDIN_3_0 DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen,
+                                           DSA *dsa);
+OSSL_DEPRECATEDIN_3_0 int DSA_do_verify(const unsigned char *dgst, int dgst_len,
+                                        DSA_SIG *sig, DSA *dsa);
+
+OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_OpenSSL(void);
+
+OSSL_DEPRECATEDIN_3_0 void DSA_set_default_method(const DSA_METHOD *);
+OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_get_default_method(void);
+OSSL_DEPRECATEDIN_3_0 int DSA_set_method(DSA *dsa, const DSA_METHOD *);
+OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_get_method(DSA *d);
+
+OSSL_DEPRECATEDIN_3_0 DSA *DSA_new(void);
+OSSL_DEPRECATEDIN_3_0 DSA *DSA_new_method(ENGINE *engine);
+OSSL_DEPRECATEDIN_3_0 void DSA_free(DSA *r);
+/* "up" the DSA object's reference count */
+OSSL_DEPRECATEDIN_3_0 int DSA_up_ref(DSA *r);
+OSSL_DEPRECATEDIN_3_0 int DSA_size(const DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_bits(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 int DSA_security_bits(const DSA *d);
+        /* next 4 return -1 on error */
+OSSL_DEPRECATEDIN_3_0 int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in,
+                                         BIGNUM **kinvp, BIGNUM **rp);
+OSSL_DEPRECATEDIN_3_0 int DSA_sign(int type, const unsigned char *dgst,
+                                   int dlen, unsigned char *sig,
+                                   unsigned int *siglen, DSA *dsa);
+OSSL_DEPRECATEDIN_3_0 int DSA_verify(int type, const unsigned char *dgst,
+                                     int dgst_len, const unsigned char *sigbuf,
+                                     int siglen, DSA *dsa);
+
+#   define DSA_get_ex_new_index(l, p, newf, dupf, freef) \
+        CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, l, p, newf, dupf, freef)
+OSSL_DEPRECATEDIN_3_0 int DSA_set_ex_data(DSA *d, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *DSA_get_ex_data(const DSA *d, int idx);
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
+                                        DSA, DSAPublicKey)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
+                                        DSA, DSAPrivateKey)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
+                                        DSA, DSAparams)
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_0_9_8
+/* Deprecated version */
+OSSL_DEPRECATEDIN_0_9_8
+DSA *DSA_generate_parameters(int bits, unsigned char *seed, int seed_len,
+                             int *counter_ret, unsigned long *h_ret,
+                             void (*callback) (int, int, void *),
+                             void *cb_arg);
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/* New version */
+OSSL_DEPRECATEDIN_3_0 int DSA_generate_parameters_ex(DSA *dsa, int bits,
+                                                     const unsigned char *seed,
+                                                     int seed_len,
+                                                     int *counter_ret,
+                                                     unsigned long *h_ret,
+                                                     BN_GENCB *cb);
+
+OSSL_DEPRECATEDIN_3_0 int DSA_generate_key(DSA *a);
+
+OSSL_DEPRECATEDIN_3_0 int DSAparams_print(BIO *bp, const DSA *x);
+OSSL_DEPRECATEDIN_3_0 int DSA_print(BIO *bp, const DSA *x, int off);
+#   ifndef OPENSSL_NO_STDIO
+OSSL_DEPRECATEDIN_3_0 int DSAparams_print_fp(FILE *fp, const DSA *x);
+OSSL_DEPRECATEDIN_3_0 int DSA_print_fp(FILE *bp, const DSA *x, int off);
+#   endif
+
+#   define DSS_prime_checks 64
+/*
+ * Primality test according to FIPS PUB 186-4, Appendix C.3. Since we only
+ * have one value here we set the number of checks to 64 which is the 128 bit
+ * security level that is the highest level and valid for creating a 3072 bit
+ * DSA key.
+ */
+#   define DSA_is_prime(n, callback, cb_arg) \
+            BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg)
+
+#   ifndef OPENSSL_NO_DH
+/*
+ * Convert DSA structure (key or just parameters) into DH structure (be
+ * careful to avoid small subgroup attacks when using this!)
+ */
+OSSL_DEPRECATEDIN_3_0 DH *DSA_dup_DH(const DSA *r);
+#   endif
+
+OSSL_DEPRECATEDIN_3_0 void DSA_get0_pqg(const DSA *d, const BIGNUM **p,
+                                        const BIGNUM **q, const BIGNUM **g);
+OSSL_DEPRECATEDIN_3_0 int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g);
+OSSL_DEPRECATEDIN_3_0 void DSA_get0_key(const DSA *d, const BIGNUM **pub_key,
+                                        const BIGNUM **priv_key);
+OSSL_DEPRECATEDIN_3_0 int DSA_set0_key(DSA *d, BIGNUM *pub_key,
+                                       BIGNUM *priv_key);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_p(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_q(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_g(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_pub_key(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_priv_key(const DSA *d);
+OSSL_DEPRECATEDIN_3_0 void DSA_clear_flags(DSA *d, int flags);
+OSSL_DEPRECATEDIN_3_0 int DSA_test_flags(const DSA *d, int flags);
+OSSL_DEPRECATEDIN_3_0 void DSA_set_flags(DSA *d, int flags);
+OSSL_DEPRECATEDIN_3_0 ENGINE *DSA_get0_engine(DSA *d);
+
+OSSL_DEPRECATEDIN_3_0 DSA_METHOD *DSA_meth_new(const char *name, int flags);
+OSSL_DEPRECATEDIN_3_0 void DSA_meth_free(DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 DSA_METHOD *DSA_meth_dup(const DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 const char *DSA_meth_get0_name(const DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set1_name(DSA_METHOD *dsam,
+                                             const char *name);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_get_flags(const DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_flags(DSA_METHOD *dsam, int flags);
+OSSL_DEPRECATEDIN_3_0 void *DSA_meth_get0_app_data(const DSA_METHOD *dsam);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set0_app_data(DSA_METHOD *dsam,
+                                                 void *app_data);
+OSSL_DEPRECATEDIN_3_0 DSA_SIG *(*DSA_meth_get_sign(const DSA_METHOD *dsam))
+        (const unsigned char *, int, DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_sign(DSA_METHOD *dsam,
+                       DSA_SIG *(*sign) (const unsigned char *, int, DSA *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_sign_setup(const DSA_METHOD *dsam))
+        (DSA *, BN_CTX *, BIGNUM **, BIGNUM **);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_sign_setup(DSA_METHOD *dsam,
+        int (*sign_setup) (DSA *, BN_CTX *, BIGNUM **, BIGNUM **));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_verify(const DSA_METHOD *dsam))
+        (const unsigned char *, int, DSA_SIG *, DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_verify(DSA_METHOD *dsam,
+    int (*verify) (const unsigned char *, int, DSA_SIG *, DSA *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_mod_exp(const DSA_METHOD *dsam))
+        (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
+         const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_mod_exp(DSA_METHOD *dsam,
+    int (*mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
+                    const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *,
+                    BN_MONT_CTX *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD *dsam))
+    (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
+     BN_CTX *, BN_MONT_CTX *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_bn_mod_exp(DSA_METHOD *dsam,
+    int (*bn_mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
+                       const BIGNUM *, BN_CTX *, BN_MONT_CTX *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_init(const DSA_METHOD *dsam))(DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_init(DSA_METHOD *dsam,
+                                            int (*init)(DSA *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_finish(const DSA_METHOD *dsam))(DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_finish(DSA_METHOD *dsam,
+                                              int (*finish)(DSA *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_paramgen(const DSA_METHOD *dsam))
+        (DSA *, int, const unsigned char *, int, int *, unsigned long *,
+         BN_GENCB *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_paramgen(DSA_METHOD *dsam,
+        int (*paramgen) (DSA *, int, const unsigned char *, int, int *,
+                         unsigned long *, BN_GENCB *));
+OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_keygen(const DSA_METHOD *dsam))(DSA *);
+OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_keygen(DSA_METHOD *dsam,
+                                              int (*keygen) (DSA *));
+
+#  endif
+# endif
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/dsaerr.h b/CAPI/cpp/grpc/include/openssl/dsaerr.h
new file mode 100644
index 0000000..5f0ca8d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/dsaerr.h
@@ -0,0 +1,43 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DSAERR_H
+# define OPENSSL_DSAERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_DSA
+
+
+/*
+ * DSA reason codes.
+ */
+#  define DSA_R_BAD_FFC_PARAMETERS                         114
+#  define DSA_R_BAD_Q_VALUE                                102
+#  define DSA_R_BN_DECODE_ERROR                            108
+#  define DSA_R_BN_ERROR                                   109
+#  define DSA_R_DECODE_ERROR                               104
+#  define DSA_R_INVALID_DIGEST_TYPE                        106
+#  define DSA_R_INVALID_PARAMETERS                         112
+#  define DSA_R_MISSING_PARAMETERS                         101
+#  define DSA_R_MISSING_PRIVATE_KEY                        111
+#  define DSA_R_MODULUS_TOO_LARGE                          103
+#  define DSA_R_NO_PARAMETERS_SET                          107
+#  define DSA_R_PARAMETER_ENCODING_ERROR                   105
+#  define DSA_R_P_NOT_PRIME                                115
+#  define DSA_R_Q_NOT_PRIME                                113
+#  define DSA_R_SEED_LEN_SMALL                             110
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/dtls1.h b/CAPI/cpp/grpc/include/openssl/dtls1.h
new file mode 100644
index 0000000..5dc6b54
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/dtls1.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2005-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_DTLS1_H
+# define OPENSSL_DTLS1_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_DTLS1_H
+# endif
+
+# include <openssl/prov_ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#include <openssl/opensslconf.h>
+
+/* DTLS*_VERSION constants are defined in prov_ssl.h */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define DTLS_MIN_VERSION                DTLS1_VERSION
+#  define DTLS_MAX_VERSION                DTLS1_2_VERSION
+# endif
+# define DTLS1_VERSION_MAJOR             0xFE
+
+/* Special value for method supporting multiple versions */
+# define DTLS_ANY_VERSION                0x1FFFF
+
+/* lengths of messages */
+
+# define DTLS1_COOKIE_LENGTH                     255
+
+# define DTLS1_RT_HEADER_LENGTH                  13
+
+# define DTLS1_HM_HEADER_LENGTH                  12
+
+# define DTLS1_HM_BAD_FRAGMENT                   -2
+# define DTLS1_HM_FRAGMENT_RETRY                 -3
+
+# define DTLS1_CCS_HEADER_LENGTH                  1
+
+# define DTLS1_AL_HEADER_LENGTH                   2
+
+# define DTLS1_TMO_ALERT_COUNT                     12
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/e_os2.h b/CAPI/cpp/grpc/include/openssl/e_os2.h
new file mode 100644
index 0000000..6728909
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/e_os2.h
@@ -0,0 +1,305 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_E_OS2_H
+# define OPENSSL_E_OS2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_E_OS2_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/******************************************************************************
+ * Detect operating systems.  This probably needs completing.
+ * The result is that at least one OPENSSL_SYS_os macro should be defined.
+ * However, if none is defined, Unix is assumed.
+ **/
+
+# define OPENSSL_SYS_UNIX
+
+/* --------------------- Microsoft operating systems ---------------------- */
+
+/*
+ * Note that MSDOS actually denotes 32-bit environments running on top of
+ * MS-DOS, such as DJGPP one.
+ */
+# if defined(OPENSSL_SYS_MSDOS)
+#  undef OPENSSL_SYS_UNIX
+# endif
+
+/*
+ * For 32 bit environment, there seems to be the CygWin environment and then
+ * all the others that try to do the same thing Microsoft does...
+ */
+/*
+ * UEFI lives here because it might be built with a Microsoft toolchain and
+ * we need to avoid the false positive match on Windows.
+ */
+# if defined(OPENSSL_SYS_UEFI)
+#  undef OPENSSL_SYS_UNIX
+# elif defined(OPENSSL_SYS_UWIN)
+#  undef OPENSSL_SYS_UNIX
+#  define OPENSSL_SYS_WIN32_UWIN
+# else
+#  if defined(__CYGWIN__) || defined(OPENSSL_SYS_CYGWIN)
+#   define OPENSSL_SYS_WIN32_CYGWIN
+#  else
+#   if defined(_WIN32) || defined(OPENSSL_SYS_WIN32)
+#    undef OPENSSL_SYS_UNIX
+#    if !defined(OPENSSL_SYS_WIN32)
+#     define OPENSSL_SYS_WIN32
+#    endif
+#   endif
+#   if defined(_WIN64) || defined(OPENSSL_SYS_WIN64)
+#    undef OPENSSL_SYS_UNIX
+#    if !defined(OPENSSL_SYS_WIN64)
+#     define OPENSSL_SYS_WIN64
+#    endif
+#   endif
+#   if defined(OPENSSL_SYS_WINNT)
+#    undef OPENSSL_SYS_UNIX
+#   endif
+#   if defined(OPENSSL_SYS_WINCE)
+#    undef OPENSSL_SYS_UNIX
+#   endif
+#  endif
+# endif
+
+/* Anything that tries to look like Microsoft is "Windows" */
+# if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN64) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE)
+#  undef OPENSSL_SYS_UNIX
+#  define OPENSSL_SYS_WINDOWS
+#  ifndef OPENSSL_SYS_MSDOS
+#   define OPENSSL_SYS_MSDOS
+#  endif
+# endif
+
+/*
+ * DLL settings.  This part is a bit tough, because it's up to the
+ * application implementor how he or she will link the application, so it
+ * requires some macro to be used.
+ */
+# ifdef OPENSSL_SYS_WINDOWS
+#  ifndef OPENSSL_OPT_WINDLL
+#   if defined(_WINDLL)         /* This is used when building OpenSSL to
+                                 * indicate that DLL linkage should be used */
+#    define OPENSSL_OPT_WINDLL
+#   endif
+#  endif
+# endif
+
+/* ------------------------------- OpenVMS -------------------------------- */
+# if defined(__VMS) || defined(VMS)
+#  if !defined(OPENSSL_SYS_VMS)
+#   undef OPENSSL_SYS_UNIX
+#   define OPENSSL_SYS_VMS
+#  endif
+#  if defined(__DECC)
+#   define OPENSSL_SYS_VMS_DECC
+#  elif defined(__DECCXX)
+#   define OPENSSL_SYS_VMS_DECC
+#   define OPENSSL_SYS_VMS_DECCXX
+#  else
+#   define OPENSSL_SYS_VMS_NODECC
+#  endif
+# endif
+
+/* -------------------------------- Unix ---------------------------------- */
+# ifdef OPENSSL_SYS_UNIX
+#  if defined(linux) || defined(__linux__) && !defined(OPENSSL_SYS_LINUX)
+#   define OPENSSL_SYS_LINUX
+#  endif
+#  if defined(_AIX) && !defined(OPENSSL_SYS_AIX)
+#   define OPENSSL_SYS_AIX
+#  endif
+# endif
+
+/* -------------------------------- VOS ----------------------------------- */
+# if defined(__VOS__) && !defined(OPENSSL_SYS_VOS)
+#  define OPENSSL_SYS_VOS
+#  ifdef __HPPA__
+#   define OPENSSL_SYS_VOS_HPPA
+#  endif
+#  ifdef __IA32__
+#   define OPENSSL_SYS_VOS_IA32
+#  endif
+# endif
+
+/* ---------------------------- HP NonStop -------------------------------- */
+# ifdef __TANDEM
+#  ifdef _STRING
+#   include <strings.h>
+#  endif
+# define OPENSSL_USE_BUILD_DATE
+# if defined(OPENSSL_THREADS) && defined(_SPT_MODEL_)
+#  define  SPT_THREAD_SIGNAL 1
+#  define  SPT_THREAD_AWARE 1
+#  include <spthread.h>
+# elif defined(OPENSSL_THREADS) && defined(_PUT_MODEL_)
+#  include <pthread.h>
+# endif
+# endif
+
+/**
+ * That's it for OS-specific stuff
+ *****************************************************************************/
+
+/*-
+ * OPENSSL_EXTERN is normally used to declare a symbol with possible extra
+ * attributes to handle its presence in a shared library.
+ * OPENSSL_EXPORT is used to define a symbol with extra possible attributes
+ * to make it visible in a shared library.
+ * Care needs to be taken when a header file is used both to declare and
+ * define symbols.  Basically, for any library that exports some global
+ * variables, the following code must be present in the header file that
+ * declares them, before OPENSSL_EXTERN is used:
+ *
+ * #ifdef SOME_BUILD_FLAG_MACRO
+ * # undef OPENSSL_EXTERN
+ * # define OPENSSL_EXTERN OPENSSL_EXPORT
+ * #endif
+ *
+ * The default is to have OPENSSL_EXPORT and OPENSSL_EXTERN
+ * have some generally sensible values.
+ */
+
+# if defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL)
+#  define OPENSSL_EXPORT extern __declspec(dllexport)
+#  define OPENSSL_EXTERN extern __declspec(dllimport)
+# else
+#  define OPENSSL_EXPORT extern
+#  define OPENSSL_EXTERN extern
+# endif
+
+# ifdef _WIN32
+#  ifdef _WIN64
+#   define ossl_ssize_t __int64
+#   define OSSL_SSIZE_MAX _I64_MAX
+#  else
+#   define ossl_ssize_t int
+#   define OSSL_SSIZE_MAX INT_MAX
+#  endif
+# endif
+
+# if defined(OPENSSL_SYS_UEFI) && !defined(ossl_ssize_t)
+#  define ossl_ssize_t INTN
+#  define OSSL_SSIZE_MAX MAX_INTN
+# endif
+
+# ifndef ossl_ssize_t
+#  define ossl_ssize_t ssize_t
+#  if defined(SSIZE_MAX)
+#   define OSSL_SSIZE_MAX SSIZE_MAX
+#  elif defined(_POSIX_SSIZE_MAX)
+#   define OSSL_SSIZE_MAX _POSIX_SSIZE_MAX
+#  else
+#   define OSSL_SSIZE_MAX ((ssize_t)(SIZE_MAX>>1))
+#  endif
+# endif
+
+# if defined(UNUSEDRESULT_DEBUG)
+#  define __owur __attribute__((__warn_unused_result__))
+# else
+#  define __owur
+# endif
+
+/* Standard integer types */
+# define OPENSSL_NO_INTTYPES_H
+# define OPENSSL_NO_STDINT_H
+# if defined(OPENSSL_SYS_UEFI)
+typedef INT8 int8_t;
+typedef UINT8 uint8_t;
+typedef INT16 int16_t;
+typedef UINT16 uint16_t;
+typedef INT32 int32_t;
+typedef UINT32 uint32_t;
+typedef INT64 int64_t;
+typedef UINT64 uint64_t;
+# elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \
+     defined(__osf__) || defined(__sgi) || defined(__hpux) || \
+     defined(OPENSSL_SYS_VMS) || defined (__OpenBSD__)
+#  include <inttypes.h>
+#  undef OPENSSL_NO_INTTYPES_H
+/* Because the specs say that inttypes.h includes stdint.h if present */
+#  undef OPENSSL_NO_STDINT_H
+# elif defined(_MSC_VER) && _MSC_VER<1600
+/*
+ * minimally required typdefs for systems not supporting inttypes.h or
+ * stdint.h: currently just older VC++
+ */
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef short int16_t;
+typedef unsigned short uint16_t;
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+# else
+#  include <stdint.h>
+#  undef OPENSSL_NO_STDINT_H
+# endif
+# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \
+    defined(INTMAX_MAX) && defined(UINTMAX_MAX)
+typedef intmax_t ossl_intmax_t;
+typedef uintmax_t ossl_uintmax_t;
+# else
+/* Fall back to the largest we know we require and can handle */
+typedef int64_t ossl_intmax_t;
+typedef uint64_t ossl_uintmax_t;
+# endif
+
+/* ossl_inline: portable inline definition usable in public headers */
+# if !defined(inline) && !defined(__cplusplus)
+#  if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
+   /* just use inline */
+#   define ossl_inline inline
+#  elif defined(__GNUC__) && __GNUC__>=2
+#   define ossl_inline __inline__
+#  elif defined(_MSC_VER)
+  /*
+   * Visual Studio: inline is available in C++ only, however
+   * __inline is available for C, see
+   * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx
+   */
+#   define ossl_inline __inline
+#  else
+#   define ossl_inline
+#  endif
+# else
+#  define ossl_inline inline
+# endif
+
+# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && \
+     !defined(__cplusplus) 
+#  define ossl_noreturn _Noreturn
+# elif defined(__GNUC__) && __GNUC__ >= 2
+#  define ossl_noreturn __attribute__((noreturn))
+# else
+#  define ossl_noreturn
+# endif
+
+/* ossl_unused: portable unused attribute for use in public headers */
+# if defined(__GNUC__)
+#  define ossl_unused __attribute__((unused))
+# else
+#  define ossl_unused
+# endif
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ebcdic.h b/CAPI/cpp/grpc/include/openssl/ebcdic.h
new file mode 100644
index 0000000..e0ae1aa
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ebcdic.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_EBCDIC_H
+# define OPENSSL_EBCDIC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_EBCDIC_H
+# endif
+
+# include <stdlib.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Avoid name clashes with other applications */
+# define os_toascii   _openssl_os_toascii
+# define os_toebcdic  _openssl_os_toebcdic
+# define ebcdic2ascii _openssl_ebcdic2ascii
+# define ascii2ebcdic _openssl_ascii2ebcdic
+
+extern const unsigned char os_toascii[256];
+extern const unsigned char os_toebcdic[256];
+void *ebcdic2ascii(void *dest, const void *srce, size_t count);
+void *ascii2ebcdic(void *dest, const void *srce, size_t count);
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ec.h b/CAPI/cpp/grpc/include/openssl/ec.h
new file mode 100644
index 0000000..44d7193
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ec.h
@@ -0,0 +1,1569 @@
+/*
+ * Copyright 2002-2022 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_EC_H
+# define OPENSSL_EC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_EC_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+
+# include <string.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/* Values for EVP_PKEY_CTX_set_ec_param_enc() */
+# define OPENSSL_EC_EXPLICIT_CURVE  0x000
+# define OPENSSL_EC_NAMED_CURVE     0x001
+
+int EVP_PKEY_CTX_set_ec_paramgen_curve_nid(EVP_PKEY_CTX *ctx, int nid);
+int EVP_PKEY_CTX_set_ec_param_enc(EVP_PKEY_CTX *ctx, int param_enc);
+int EVP_PKEY_CTX_set_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx, int cofactor_mode);
+int EVP_PKEY_CTX_get_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx);
+
+int EVP_PKEY_CTX_set_ecdh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
+int EVP_PKEY_CTX_get_ecdh_kdf_type(EVP_PKEY_CTX *ctx);
+
+int EVP_PKEY_CTX_set_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_get_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+
+int EVP_PKEY_CTX_set_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
+int EVP_PKEY_CTX_get_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
+
+int EVP_PKEY_CTX_set0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm,
+                                   int len);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_CTX_get0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **ukm);
+# endif
+
+# define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID    (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_EC_PARAM_ENC             (EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_EC_ECDH_COFACTOR         (EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_EC_KDF_TYPE              (EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_EC_KDF_MD                (EVP_PKEY_ALG_CTRL + 5)
+# define EVP_PKEY_CTRL_GET_EC_KDF_MD            (EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_EC_KDF_OUTLEN            (EVP_PKEY_ALG_CTRL + 7)
+# define EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN        (EVP_PKEY_ALG_CTRL + 8)
+# define EVP_PKEY_CTRL_EC_KDF_UKM               (EVP_PKEY_ALG_CTRL + 9)
+# define EVP_PKEY_CTRL_GET_EC_KDF_UKM           (EVP_PKEY_ALG_CTRL + 10)
+
+/* KDF types */
+# define EVP_PKEY_ECDH_KDF_NONE                      1
+# define EVP_PKEY_ECDH_KDF_X9_63                     2
+/*
+ * The old name for EVP_PKEY_ECDH_KDF_X9_63
+ *  The ECDH KDF specification has been mistakenly attributed to ANSI X9.62,
+ *  it is actually specified in ANSI X9.63.
+ *  This identifier is retained for backwards compatibility
+ */
+# define EVP_PKEY_ECDH_KDF_X9_62   EVP_PKEY_ECDH_KDF_X9_63
+
+/** Enum for the point conversion form as defined in X9.62 (ECDSA)
+ *  for the encoding of a elliptic curve point (x,y) */
+typedef enum {
+        /** the point is encoded as z||x, where the octet z specifies
+         *  which solution of the quadratic equation y is  */
+    POINT_CONVERSION_COMPRESSED = 2,
+        /** the point is encoded as z||x||y, where z is the octet 0x04  */
+    POINT_CONVERSION_UNCOMPRESSED = 4,
+        /** the point is encoded as z||x||y, where the octet z specifies
+         *  which solution of the quadratic equation y is  */
+    POINT_CONVERSION_HYBRID = 6
+} point_conversion_form_t;
+
+const char *OSSL_EC_curve_nid2name(int nid);
+
+# ifndef OPENSSL_NO_EC
+#  include <openssl/asn1.h>
+#  include <openssl/symhacks.h>
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   include <openssl/bn.h>
+#  endif
+#  include <openssl/ecerr.h>
+
+#  ifndef OPENSSL_ECC_MAX_FIELD_BITS
+#   define OPENSSL_ECC_MAX_FIELD_BITS 661
+#  endif
+
+#  include <openssl/params.h>
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct ec_method_st EC_METHOD;
+#  endif
+typedef struct ec_group_st EC_GROUP;
+typedef struct ec_point_st EC_POINT;
+typedef struct ecpk_parameters_st ECPKPARAMETERS;
+typedef struct ec_parameters_st ECPARAMETERS;
+
+/********************************************************************/
+/*               EC_METHODs for curves over GF(p)                   */
+/********************************************************************/
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Returns the basic GFp ec methods which provides the basis for the
+ *  optimized methods.
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_simple_method(void);
+
+/** Returns GFp methods using montgomery multiplication.
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_mont_method(void);
+
+/** Returns GFp methods using optimized methods for NIST recommended curves
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nist_method(void);
+
+#   ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
+/** Returns 64-bit optimized methods for nistp224
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp224_method(void);
+
+/** Returns 64-bit optimized methods for nistp256
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp256_method(void);
+
+/** Returns 64-bit optimized methods for nistp521
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp521_method(void);
+#   endif /* OPENSSL_NO_EC_NISTP_64_GCC_128 */
+
+#   ifndef OPENSSL_NO_EC2M
+/********************************************************************/
+/*           EC_METHOD for curves over GF(2^m)                      */
+/********************************************************************/
+
+/** Returns the basic GF2m ec method
+ *  \return  EC_METHOD object
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GF2m_simple_method(void);
+
+#   endif
+
+/********************************************************************/
+/*                   EC_GROUP functions                             */
+/********************************************************************/
+
+/**
+ *  Creates a new EC_GROUP object
+ *  \param   meth   EC_METHOD to use
+ *  \return  newly created EC_GROUP object or NULL in case of an error.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth);
+
+/** Clears and frees a EC_GROUP object
+ *  \param  group  EC_GROUP object to be cleared and freed.
+ */
+OSSL_DEPRECATEDIN_3_0 void EC_GROUP_clear_free(EC_GROUP *group);
+
+/** Returns the EC_METHOD of the EC_GROUP object.
+ *  \param  group  EC_GROUP object
+ *  \return EC_METHOD used in this EC_GROUP object.
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group);
+
+/** Returns the field type of the EC_METHOD.
+ *  \param  meth  EC_METHOD object
+ *  \return NID of the underlying field type OID.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_METHOD_get_field_type(const EC_METHOD *meth);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Frees a EC_GROUP object
+ *  \param  group  EC_GROUP object to be freed.
+ */
+void EC_GROUP_free(EC_GROUP *group);
+
+/** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD.
+ *  \param  dst  destination EC_GROUP object
+ *  \param  src  source EC_GROUP object
+ *  \return 1 on success and 0 if an error occurred.
+ */
+int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src);
+
+/** Creates a new EC_GROUP object and copies the content
+ *  form src to the newly created EC_KEY object
+ *  \param  src  source EC_GROUP object
+ *  \return newly created EC_GROUP object or NULL in case of an error.
+ */
+EC_GROUP *EC_GROUP_dup(const EC_GROUP *src);
+
+/** Sets the generator and its order/cofactor of a EC_GROUP object.
+ *  \param  group      EC_GROUP object
+ *  \param  generator  EC_POINT object with the generator.
+ *  \param  order      the order of the group generated by the generator.
+ *  \param  cofactor   the index of the sub-group generated by the generator
+ *                     in the group of all points on the elliptic curve.
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
+                           const BIGNUM *order, const BIGNUM *cofactor);
+
+/** Returns the generator of a EC_GROUP object.
+ *  \param  group  EC_GROUP object
+ *  \return the currently used generator (possibly NULL).
+ */
+const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group);
+
+/** Returns the montgomery data for order(Generator)
+ *  \param  group  EC_GROUP object
+ *  \return the currently used montgomery data (possibly NULL).
+*/
+BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group);
+
+/** Gets the order of a EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \param  order  BIGNUM to which the order is copied
+ *  \param  ctx    unused
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx);
+
+/** Gets the order of an EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \return the group order
+ */
+const BIGNUM *EC_GROUP_get0_order(const EC_GROUP *group);
+
+/** Gets the number of bits of the order of an EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \return number of bits of group order.
+ */
+int EC_GROUP_order_bits(const EC_GROUP *group);
+
+/** Gets the cofactor of a EC_GROUP
+ *  \param  group     EC_GROUP object
+ *  \param  cofactor  BIGNUM to which the cofactor is copied
+ *  \param  ctx       unused
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor,
+                          BN_CTX *ctx);
+
+/** Gets the cofactor of an EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \return the group cofactor
+ */
+const BIGNUM *EC_GROUP_get0_cofactor(const EC_GROUP *group);
+
+/** Sets the name of a EC_GROUP object
+ *  \param  group  EC_GROUP object
+ *  \param  nid    NID of the curve name OID
+ */
+void EC_GROUP_set_curve_name(EC_GROUP *group, int nid);
+
+/** Returns the curve name of a EC_GROUP object
+ *  \param  group  EC_GROUP object
+ *  \return NID of the curve name OID or 0 if not set.
+ */
+int EC_GROUP_get_curve_name(const EC_GROUP *group);
+
+/** Gets the field of an EC_GROUP
+ *  \param  group  EC_GROUP object
+ *  \return the group field
+ */
+const BIGNUM *EC_GROUP_get0_field(const EC_GROUP *group);
+
+/** Returns the field type of the EC_GROUP.
+ *  \param  group  EC_GROUP object
+ *  \return NID of the underlying field type OID.
+ */
+int EC_GROUP_get_field_type(const EC_GROUP *group);
+
+void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag);
+int EC_GROUP_get_asn1_flag(const EC_GROUP *group);
+
+void EC_GROUP_set_point_conversion_form(EC_GROUP *group,
+                                        point_conversion_form_t form);
+point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *);
+
+unsigned char *EC_GROUP_get0_seed(const EC_GROUP *x);
+size_t EC_GROUP_get_seed_len(const EC_GROUP *);
+size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len);
+
+/** Sets the parameters of an ec curve defined by y^2 = x^3 + a*x + b (for GFp)
+ *  or y^2 + x*y = x^3 + a*x^2 + b (for GF2m)
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM with parameter a of the equation
+ *  \param  b      BIGNUM with parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
+                       const BIGNUM *b, BN_CTX *ctx);
+
+/** Gets the parameters of the ec curve defined by y^2 = x^3 + a*x + b (for GFp)
+ *  or y^2 + x*y = x^3 + a*x^2 + b (for GF2m)
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM for parameter a of the equation
+ *  \param  b      BIGNUM for parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
+                       BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Sets the parameters of an ec curve. Synonym for EC_GROUP_set_curve
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM with parameter a of the equation
+ *  \param  b      BIGNUM with parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_set_curve_GFp(EC_GROUP *group,
+                                                 const BIGNUM *p,
+                                                 const BIGNUM *a,
+                                                 const BIGNUM *b,
+                                                 BN_CTX *ctx);
+
+/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM for parameter a of the equation
+ *  \param  b      BIGNUM for parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_get_curve_GFp(const EC_GROUP *group,
+                                                 BIGNUM *p,
+                                                 BIGNUM *a, BIGNUM *b,
+                                                 BN_CTX *ctx);
+
+#   ifndef OPENSSL_NO_EC2M
+/** Sets the parameter of an ec curve. Synonym for EC_GROUP_set_curve
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM with parameter a of the equation
+ *  \param  b      BIGNUM with parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_set_curve_GF2m(EC_GROUP *group,
+                                                  const BIGNUM *p,
+                                                  const BIGNUM *a,
+                                                  const BIGNUM *b,
+                                                  BN_CTX *ctx);
+
+/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve
+ *  \param  group  EC_GROUP object
+ *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+ *                 defining the underlying field (GF2m)
+ *  \param  a      BIGNUM for parameter a of the equation
+ *  \param  b      BIGNUM for parameter b of the equation
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_get_curve_GF2m(const EC_GROUP *group,
+                                                  BIGNUM *p,
+                                                  BIGNUM *a, BIGNUM *b,
+                                                  BN_CTX *ctx);
+#   endif /* OPENSSL_NO_EC2M */
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Returns the number of bits needed to represent a field element
+ *  \param  group  EC_GROUP object
+ *  \return number of bits needed to represent a field element
+ */
+int EC_GROUP_get_degree(const EC_GROUP *group);
+
+/** Checks whether the parameter in the EC_GROUP define a valid ec group
+ *  \param  group  EC_GROUP object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 if group is a valid ec group and 0 otherwise
+ */
+int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx);
+
+/** Checks whether the discriminant of the elliptic curve is zero or not
+ *  \param  group  EC_GROUP object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 if the discriminant is not zero and 0 otherwise
+ */
+int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx);
+
+/** Compares two EC_GROUP objects
+ *  \param  a    first EC_GROUP object
+ *  \param  b    second EC_GROUP object
+ *  \param  ctx  BN_CTX object (optional)
+ *  \return 0 if the groups are equal, 1 if not, or -1 on error
+ */
+int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx);
+
+/*
+ * EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*() after
+ * choosing an appropriate EC_METHOD
+ */
+
+/** Creates a new EC_GROUP object with the specified parameters defined
+ *  over GFp (defined by the equation y^2 = x^3 + a*x + b)
+ *  \param  p    BIGNUM with the prime number
+ *  \param  a    BIGNUM with the parameter a of the equation
+ *  \param  b    BIGNUM with the parameter b of the equation
+ *  \param  ctx  BN_CTX object (optional)
+ *  \return newly created EC_GROUP object with the specified parameters
+ */
+EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a,
+                                 const BIGNUM *b, BN_CTX *ctx);
+#  ifndef OPENSSL_NO_EC2M
+/** Creates a new EC_GROUP object with the specified parameters defined
+ *  over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b)
+ *  \param  p    BIGNUM with the polynomial defining the underlying field
+ *  \param  a    BIGNUM with the parameter a of the equation
+ *  \param  b    BIGNUM with the parameter b of the equation
+ *  \param  ctx  BN_CTX object (optional)
+ *  \return newly created EC_GROUP object with the specified parameters
+ */
+EC_GROUP *EC_GROUP_new_curve_GF2m(const BIGNUM *p, const BIGNUM *a,
+                                  const BIGNUM *b, BN_CTX *ctx);
+#  endif
+
+/**
+ * Creates a EC_GROUP object with a curve specified by parameters.
+ * The parameters may be explicit or a named curve,
+ *  \param  params A list of parameters describing the group.
+ *  \param  libctx The associated library context or NULL for the default
+ *                 context
+ *  \param  propq  A property query string
+ *  \return newly created EC_GROUP object with specified parameters or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_from_params(const OSSL_PARAM params[],
+                                   OSSL_LIB_CTX *libctx, const char *propq);
+
+/**
+ * Creates a EC_GROUP object with a curve specified by a NID
+ *  \param  libctx The associated library context or NULL for the default
+ *                 context
+ *  \param  propq  A property query string
+ *  \param  nid    NID of the OID of the curve name
+ *  \return newly created EC_GROUP object with specified curve or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_by_curve_name_ex(OSSL_LIB_CTX *libctx, const char *propq,
+                                        int nid);
+
+/**
+ * Creates a EC_GROUP object with a curve specified by a NID. Same as
+ * EC_GROUP_new_by_curve_name_ex but the libctx and propq are always
+ * NULL.
+ *  \param  nid    NID of the OID of the curve name
+ *  \return newly created EC_GROUP object with specified curve or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_by_curve_name(int nid);
+
+/** Creates a new EC_GROUP object from an ECPARAMETERS object
+ *  \param  params  pointer to the ECPARAMETERS object
+ *  \return newly created EC_GROUP object with specified curve or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_from_ecparameters(const ECPARAMETERS *params);
+
+/** Creates an ECPARAMETERS object for the given EC_GROUP object.
+ *  \param  group   pointer to the EC_GROUP object
+ *  \param  params  pointer to an existing ECPARAMETERS object or NULL
+ *  \return pointer to the new ECPARAMETERS object or NULL
+ *          if an error occurred.
+ */
+ECPARAMETERS *EC_GROUP_get_ecparameters(const EC_GROUP *group,
+                                        ECPARAMETERS *params);
+
+/** Creates a new EC_GROUP object from an ECPKPARAMETERS object
+ *  \param  params  pointer to an existing ECPKPARAMETERS object, or NULL
+ *  \return newly created EC_GROUP object with specified curve, or NULL
+ *          if an error occurred
+ */
+EC_GROUP *EC_GROUP_new_from_ecpkparameters(const ECPKPARAMETERS *params);
+
+/** Creates an ECPKPARAMETERS object for the given EC_GROUP object.
+ *  \param  group   pointer to the EC_GROUP object
+ *  \param  params  pointer to an existing ECPKPARAMETERS object or NULL
+ *  \return pointer to the new ECPKPARAMETERS object or NULL
+ *          if an error occurred.
+ */
+ECPKPARAMETERS *EC_GROUP_get_ecpkparameters(const EC_GROUP *group,
+                                            ECPKPARAMETERS *params);
+
+/********************************************************************/
+/*               handling of internal curves                        */
+/********************************************************************/
+
+typedef struct {
+    int nid;
+    const char *comment;
+} EC_builtin_curve;
+
+/*
+ * EC_builtin_curves(EC_builtin_curve *r, size_t size) returns number of all
+ * available curves or zero if a error occurred. In case r is not zero,
+ * nitems EC_builtin_curve structures are filled with the data of the first
+ * nitems internal groups
+ */
+size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems);
+
+const char *EC_curve_nid2nist(int nid);
+int EC_curve_nist2nid(const char *name);
+int EC_GROUP_check_named_curve(const EC_GROUP *group, int nist_only,
+                               BN_CTX *ctx);
+
+/********************************************************************/
+/*                    EC_POINT functions                            */
+/********************************************************************/
+
+/** Creates a new EC_POINT object for the specified EC_GROUP
+ *  \param  group  EC_GROUP the underlying EC_GROUP object
+ *  \return newly created EC_POINT object or NULL if an error occurred
+ */
+EC_POINT *EC_POINT_new(const EC_GROUP *group);
+
+/** Frees a EC_POINT object
+ *  \param  point  EC_POINT object to be freed
+ */
+void EC_POINT_free(EC_POINT *point);
+
+/** Clears and frees a EC_POINT object
+ *  \param  point  EC_POINT object to be cleared and freed
+ */
+void EC_POINT_clear_free(EC_POINT *point);
+
+/** Copies EC_POINT object
+ *  \param  dst  destination EC_POINT object
+ *  \param  src  source EC_POINT object
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src);
+
+/** Creates a new EC_POINT object and copies the content of the supplied
+ *  EC_POINT
+ *  \param  src    source EC_POINT object
+ *  \param  group  underlying the EC_GROUP object
+ *  \return newly created EC_POINT object or NULL if an error occurred
+ */
+EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group);
+
+/** Sets a point to infinity (neutral element)
+ *  \param  group  underlying EC_GROUP object
+ *  \param  point  EC_POINT to set to infinity
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Returns the EC_METHOD used in EC_POINT object
+ *  \param  point  EC_POINT object
+ *  \return the EC_METHOD used
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point);
+
+/** Sets the jacobian projective coordinates of a EC_POINT over GFp
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with the x-coordinate
+ *  \param  y      BIGNUM with the y-coordinate
+ *  \param  z      BIGNUM with the z-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_Jprojective_coordinates_GFp
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, const BIGNUM *y, const BIGNUM *z,
+                       BN_CTX *ctx);
+
+/** Gets the jacobian projective coordinates of a EC_POINT over GFp
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM for the x-coordinate
+ *  \param  y      BIGNUM for the y-coordinate
+ *  \param  z      BIGNUM for the z-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_Jprojective_coordinates_GFp
+                      (const EC_GROUP *group, const EC_POINT *p,
+                       BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Sets the affine coordinates of an EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with the x-coordinate
+ *  \param  y      BIGNUM with the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *p,
+                                    const BIGNUM *x, const BIGNUM *y,
+                                    BN_CTX *ctx);
+
+/** Gets the affine coordinates of an EC_POINT.
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM for the x-coordinate
+ *  \param  y      BIGNUM for the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *p,
+                                    BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Sets the affine coordinates of an EC_POINT. A synonym of
+ *  EC_POINT_set_affine_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with the x-coordinate
+ *  \param  y      BIGNUM with the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_affine_coordinates_GFp
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx);
+
+/** Gets the affine coordinates of an EC_POINT. A synonym of
+ *  EC_POINT_get_affine_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM for the x-coordinate
+ *  \param  y      BIGNUM for the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_affine_coordinates_GFp
+                      (const EC_GROUP *group, const EC_POINT *p,
+                       BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Sets the x9.62 compressed coordinates of a EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with x-coordinate
+ *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *p,
+                                        const BIGNUM *x, int y_bit,
+                                        BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of
+ *  EC_POINT_set_compressed_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with x-coordinate
+ *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_compressed_coordinates_GFp
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, int y_bit, BN_CTX *ctx);
+#   ifndef OPENSSL_NO_EC2M
+/** Sets the affine coordinates of an EC_POINT. A synonym of
+ *  EC_POINT_set_affine_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with the x-coordinate
+ *  \param  y      BIGNUM with the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_affine_coordinates_GF2m
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx);
+
+/** Gets the affine coordinates of an EC_POINT. A synonym of
+ *  EC_POINT_get_affine_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM for the x-coordinate
+ *  \param  y      BIGNUM for the y-coordinate
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_affine_coordinates_GF2m
+                      (const EC_GROUP *group, const EC_POINT *p,
+                       BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
+
+/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of
+ *  EC_POINT_set_compressed_coordinates
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  x      BIGNUM with x-coordinate
+ *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_compressed_coordinates_GF2m
+                      (const EC_GROUP *group, EC_POINT *p,
+                       const BIGNUM *x, int y_bit, BN_CTX *ctx);
+#   endif
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Encodes a EC_POINT object to a octet string
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  form   point conversion form
+ *  \param  buf    memory buffer for the result. If NULL the function returns
+ *                 required buffer size.
+ *  \param  len    length of the memory buffer
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p,
+                          point_conversion_form_t form,
+                          unsigned char *buf, size_t len, BN_CTX *ctx);
+
+/** Decodes a EC_POINT from a octet string
+ *  \param  group  underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \param  buf    memory buffer with the encoded ec point
+ *  \param  len    length of the encoded ec point
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p,
+                       const unsigned char *buf, size_t len, BN_CTX *ctx);
+
+/** Encodes an EC_POINT object to an allocated octet string
+ *  \param  group  underlying EC_GROUP object
+ *  \param  point  EC_POINT object
+ *  \param  form   point conversion form
+ *  \param  pbuf   returns pointer to allocated buffer
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+size_t EC_POINT_point2buf(const EC_GROUP *group, const EC_POINT *point,
+                          point_conversion_form_t form,
+                          unsigned char **pbuf, BN_CTX *ctx);
+
+/* other interfaces to point2oct/oct2point: */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 BIGNUM *EC_POINT_point2bn(const EC_GROUP *,
+                                                const EC_POINT *,
+                                                point_conversion_form_t form,
+                                                BIGNUM *, BN_CTX *);
+OSSL_DEPRECATEDIN_3_0 EC_POINT *EC_POINT_bn2point(const EC_GROUP *,
+                                                  const BIGNUM *,
+                                                  EC_POINT *, BN_CTX *);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *,
+                         point_conversion_form_t form, BN_CTX *);
+EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *,
+                             EC_POINT *, BN_CTX *);
+
+/********************************************************************/
+/*         functions for doing EC_POINT arithmetic                  */
+/********************************************************************/
+
+/** Computes the sum of two EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  r      EC_POINT object for the result (r = a + b)
+ *  \param  a      EC_POINT object with the first summand
+ *  \param  b      EC_POINT object with the second summand
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
+                 const EC_POINT *b, BN_CTX *ctx);
+
+/** Computes the double of a EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  r      EC_POINT object for the result (r = 2 * a)
+ *  \param  a      EC_POINT object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
+                 BN_CTX *ctx);
+
+/** Computes the inverse of a EC_POINT
+ *  \param  group  underlying EC_GROUP object
+ *  \param  a      EC_POINT object to be inverted (it's used for the result as well)
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx);
+
+/** Checks whether the point is the neutral element of the group
+ *  \param  group  the underlying EC_GROUP object
+ *  \param  p      EC_POINT object
+ *  \return 1 if the point is the neutral element and 0 otherwise
+ */
+int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p);
+
+/** Checks whether the point is on the curve
+ *  \param  group  underlying EC_GROUP object
+ *  \param  point  EC_POINT object to check
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 if the point is on the curve, 0 if not, or -1 on error
+ */
+int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
+                         BN_CTX *ctx);
+
+/** Compares two EC_POINTs
+ *  \param  group  underlying EC_GROUP object
+ *  \param  a      first EC_POINT object
+ *  \param  b      second EC_POINT object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 if the points are not equal, 0 if they are, or -1 on error
+ */
+int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
+                 BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int EC_POINT_make_affine(const EC_GROUP *group,
+                                               EC_POINT *point, BN_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num,
+                                                EC_POINT *points[], BN_CTX *ctx);
+
+/** Computes r = generator * n + sum_{i=0}^{num-1} p[i] * m[i]
+ *  \param  group  underlying EC_GROUP object
+ *  \param  r      EC_POINT object for the result
+ *  \param  n      BIGNUM with the multiplier for the group generator (optional)
+ *  \param  num    number further summands
+ *  \param  p      array of size num of EC_POINT objects
+ *  \param  m      array of size num of BIGNUM objects
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r,
+                                        const BIGNUM *n, size_t num,
+                                        const EC_POINT *p[], const BIGNUM *m[],
+                                        BN_CTX *ctx);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/** Computes r = generator * n + q * m
+ *  \param  group  underlying EC_GROUP object
+ *  \param  r      EC_POINT object for the result
+ *  \param  n      BIGNUM with the multiplier for the group generator (optional)
+ *  \param  q      EC_POINT object with the first factor of the second summand
+ *  \param  m      BIGNUM with the second factor of the second summand
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n,
+                 const EC_POINT *q, const BIGNUM *m, BN_CTX *ctx);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Stores multiples of generator for faster point multiplication
+ *  \param  group  EC_GROUP object
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx);
+
+/** Reports whether a precomputation has been done
+ *  \param  group  EC_GROUP object
+ *  \return 1 if a pre-computation has been done and 0 otherwise
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_GROUP_have_precompute_mult(const EC_GROUP *group);
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/********************************************************************/
+/*                       ASN1 stuff                                 */
+/********************************************************************/
+
+DECLARE_ASN1_ITEM(ECPKPARAMETERS)
+DECLARE_ASN1_ALLOC_FUNCTIONS(ECPKPARAMETERS)
+DECLARE_ASN1_ITEM(ECPARAMETERS)
+DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS)
+
+/*
+ * EC_GROUP_get_basis_type() returns the NID of the basis type used to
+ * represent the field elements
+ */
+int EC_GROUP_get_basis_type(const EC_GROUP *);
+#  ifndef OPENSSL_NO_EC2M
+int EC_GROUP_get_trinomial_basis(const EC_GROUP *, unsigned int *k);
+int EC_GROUP_get_pentanomial_basis(const EC_GROUP *, unsigned int *k1,
+                                   unsigned int *k2, unsigned int *k3);
+#  endif
+
+EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len);
+int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out);
+
+#  define d2i_ECPKParameters_bio(bp,x) \
+    ASN1_d2i_bio_of(EC_GROUP, NULL, d2i_ECPKParameters, bp, x)
+#  define i2d_ECPKParameters_bio(bp,x) \
+    ASN1_i2d_bio_of(EC_GROUP, i2d_ECPKParameters, bp, x)
+#  define d2i_ECPKParameters_fp(fp,x) \
+    (EC_GROUP *)ASN1_d2i_fp(NULL, (d2i_of_void *)d2i_ECPKParameters, (fp), \
+                            (void **)(x))
+#  define i2d_ECPKParameters_fp(fp,x) \
+    ASN1_i2d_fp((i2d_of_void *)i2d_ECPKParameters, (fp), (void *)(x))
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ECPKParameters_print(BIO *bp, const EC_GROUP *x,
+                                               int off);
+#   ifndef OPENSSL_NO_STDIO
+OSSL_DEPRECATEDIN_3_0 int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x,
+                                                  int off);
+#   endif
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/********************************************************************/
+/*                      EC_KEY functions                            */
+/********************************************************************/
+
+/* some values for the encoding_flag */
+#  define EC_PKEY_NO_PARAMETERS   0x001
+#  define EC_PKEY_NO_PUBKEY       0x002
+
+/* some values for the flags field */
+#  define EC_FLAG_SM2_RANGE              0x0004
+#  define EC_FLAG_COFACTOR_ECDH          0x1000
+#  define EC_FLAG_CHECK_NAMED_GROUP      0x2000
+#  define EC_FLAG_CHECK_NAMED_GROUP_NIST 0x4000
+#  define EC_FLAG_CHECK_NAMED_GROUP_MASK \
+    (EC_FLAG_CHECK_NAMED_GROUP | EC_FLAG_CHECK_NAMED_GROUP_NIST)
+
+/* Deprecated flags -  it was using 0x01..0x02 */
+#  define EC_FLAG_NON_FIPS_ALLOW         0x0000
+#  define EC_FLAG_FIPS_CHECKED           0x0000
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/**
+ *  Creates a new EC_KEY object.
+ *  \param  ctx  The library context for to use for this EC_KEY. May be NULL in
+ *               which case the default library context is used.
+ *  \return EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_ex(OSSL_LIB_CTX *ctx, const char *propq);
+
+/**
+ *  Creates a new EC_KEY object. Same as calling EC_KEY_new_ex with a
+ *  NULL library context
+ *  \return EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new(void);
+
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_get_flags(const EC_KEY *key);
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_flags(EC_KEY *key, int flags);
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_clear_flags(EC_KEY *key, int flags);
+
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_decoded_from_explicit_params(const EC_KEY *key);
+
+/**
+ *  Creates a new EC_KEY object using a named curve as underlying
+ *  EC_GROUP object.
+ *  \param  ctx   The library context for to use for this EC_KEY. May be NULL in
+ *                which case the default library context is used.
+ *  \param  propq Any property query string
+ *  \param  nid   NID of the named curve.
+ *  \return EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_by_curve_name_ex(OSSL_LIB_CTX *ctx,
+                                                          const char *propq,
+                                                          int nid);
+
+/**
+ *  Creates a new EC_KEY object using a named curve as underlying
+ *  EC_GROUP object. Same as calling EC_KEY_new_by_curve_name_ex with a NULL
+ *  library context and property query string.
+ *  \param  nid  NID of the named curve.
+ *  \return EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_by_curve_name(int nid);
+
+/** Frees a EC_KEY object.
+ *  \param  key  EC_KEY object to be freed.
+ */
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_free(EC_KEY *key);
+
+/** Copies a EC_KEY object.
+ *  \param  dst  destination EC_KEY object
+ *  \param  src  src EC_KEY object
+ *  \return dst or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src);
+
+/** Creates a new EC_KEY object and copies the content from src to it.
+ *  \param  src  the source EC_KEY object
+ *  \return newly created EC_KEY object or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_dup(const EC_KEY *src);
+
+/** Increases the internal reference count of a EC_KEY object.
+ *  \param  key  EC_KEY object
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_up_ref(EC_KEY *key);
+
+/** Returns the ENGINE object of a EC_KEY object
+ *  \param  eckey  EC_KEY object
+ *  \return the ENGINE object (possibly NULL).
+ */
+OSSL_DEPRECATEDIN_3_0 ENGINE *EC_KEY_get0_engine(const EC_KEY *eckey);
+
+/** Returns the EC_GROUP object of a EC_KEY object
+ *  \param  key  EC_KEY object
+ *  \return the EC_GROUP object (possibly NULL).
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key);
+
+/** Sets the EC_GROUP of a EC_KEY object.
+ *  \param  key    EC_KEY object
+ *  \param  group  EC_GROUP to use in the EC_KEY object (note: the EC_KEY
+ *                 object will use an own copy of the EC_GROUP).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group);
+
+/** Returns the private key of a EC_KEY object.
+ *  \param  key  EC_KEY object
+ *  \return a BIGNUM with the private key (possibly NULL).
+ */
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key);
+
+/** Sets the private key of a EC_KEY object.
+ *  \param  key  EC_KEY object
+ *  \param  prv  BIGNUM with the private key (note: the EC_KEY object
+ *               will use an own copy of the BIGNUM).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv);
+
+/** Returns the public key of a EC_KEY object.
+ *  \param  key  the EC_KEY object
+ *  \return a EC_POINT object with the public key (possibly NULL)
+ */
+OSSL_DEPRECATEDIN_3_0 const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key);
+
+/** Sets the public key of a EC_KEY object.
+ *  \param  key  EC_KEY object
+ *  \param  pub  EC_POINT object with the public key (note: the EC_KEY object
+ *               will use an own copy of the EC_POINT object).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub);
+
+OSSL_DEPRECATEDIN_3_0 unsigned EC_KEY_get_enc_flags(const EC_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags);
+OSSL_DEPRECATEDIN_3_0 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_conv_form(EC_KEY *eckey,
+                                                point_conversion_form_t cform);
+#  endif /*OPENSSL_NO_DEPRECATED_3_0 */
+
+#  define EC_KEY_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_EC_KEY, l, p, newf, dupf, freef)
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_ex_data(EC_KEY *key, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *EC_KEY_get_ex_data(const EC_KEY *key, int idx);
+
+/* wrapper functions for the underlying EC_GROUP object */
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag);
+
+/** Creates a table of pre-computed multiples of the generator to
+ *  accelerate further EC_KEY operations.
+ *  \param  key  EC_KEY object
+ *  \param  ctx  BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx);
+
+/** Creates a new ec private (and optional a new public) key.
+ *  \param  key  EC_KEY object
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_generate_key(EC_KEY *key);
+
+/** Verifies that a private and/or public key is valid.
+ *  \param  key  the EC_KEY object
+ *  \return 1 on success and 0 otherwise.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_check_key(const EC_KEY *key);
+
+/** Indicates if an EC_KEY can be used for signing.
+ *  \param  eckey  the EC_KEY object
+ *  \return 1 if can can sign and 0 otherwise.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_can_sign(const EC_KEY *eckey);
+
+/** Sets a public key from affine coordinates performing
+ *  necessary NIST PKV tests.
+ *  \param  key  the EC_KEY object
+ *  \param  x    public key x coordinate
+ *  \param  y    public key y coordinate
+ *  \return 1 on success and 0 otherwise.
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key,
+                                                                   BIGNUM *x,
+                                                                   BIGNUM *y);
+
+/** Encodes an EC_KEY public key to an allocated octet string
+ *  \param  key    key to encode
+ *  \param  form   point conversion form
+ *  \param  pbuf   returns pointer to allocated buffer
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_key2buf(const EC_KEY *key,
+                                            point_conversion_form_t form,
+                                            unsigned char **pbuf, BN_CTX *ctx);
+
+/** Decodes a EC_KEY public key from a octet string
+ *  \param  key    key to decode
+ *  \param  buf    memory buffer with the encoded ec point
+ *  \param  len    length of the encoded ec point
+ *  \param  ctx    BN_CTX object (optional)
+ *  \return 1 on success and 0 if an error occurred
+ */
+
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf,
+                                         size_t len, BN_CTX *ctx);
+
+/** Decodes an EC_KEY private key from an octet string
+ *  \param  key    key to decode
+ *  \param  buf    memory buffer with the encoded private key
+ *  \param  len    length of the encoded key
+ *  \return 1 on success and 0 if an error occurred
+ */
+
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_oct2priv(EC_KEY *key, const unsigned char *buf,
+                                          size_t len);
+
+/** Encodes a EC_KEY private key to an octet string
+ *  \param  key    key to encode
+ *  \param  buf    memory buffer for the result. If NULL the function returns
+ *                 required buffer size.
+ *  \param  len    length of the memory buffer
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+
+OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_priv2oct(const EC_KEY *key,
+                                             unsigned char *buf, size_t len);
+
+/** Encodes an EC_KEY private key to an allocated octet string
+ *  \param  eckey  key to encode
+ *  \param  pbuf   returns pointer to allocated buffer
+ *  \return the length of the encoded octet string or 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_priv2buf(const EC_KEY *eckey,
+                                             unsigned char **pbuf);
+
+/********************************************************************/
+/*        de- and encoding functions for SEC1 ECPrivateKey          */
+/********************************************************************/
+
+/** Decodes a private key from a memory buffer.
+ *  \param  key  a pointer to a EC_KEY object which should be used (or NULL)
+ *  \param  in   pointer to memory with the DER encoded private key
+ *  \param  len  length of the DER encoded private key
+ *  \return the decoded private key or NULL if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey(EC_KEY **key,
+                                               const unsigned char **in,
+                                               long len);
+
+/** Encodes a private key object and stores the result in a buffer.
+ *  \param  key  the EC_KEY object to encode
+ *  \param  out  the buffer for the result (if NULL the function returns number
+ *               of bytes needed).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey(const EC_KEY *key,
+                                           unsigned char **out);
+
+/********************************************************************/
+/*        de- and encoding functions for EC parameters              */
+/********************************************************************/
+
+/** Decodes ec parameter from a memory buffer.
+ *  \param  key  a pointer to a EC_KEY object which should be used (or NULL)
+ *  \param  in   pointer to memory with the DER encoded ec parameters
+ *  \param  len  length of the DER encoded ec parameters
+ *  \return a EC_KEY object with the decoded parameters or NULL if an error
+ *          occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECParameters(EC_KEY **key,
+                                               const unsigned char **in,
+                                               long len);
+
+/** Encodes ec parameter and stores the result in a buffer.
+ *  \param  key  the EC_KEY object with ec parameters to encode
+ *  \param  out  the buffer for the result (if NULL the function returns number
+ *               of bytes needed).
+ *  \return 1 on success and 0 if an error occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 int i2d_ECParameters(const EC_KEY *key,
+                                           unsigned char **out);
+
+/********************************************************************/
+/*         de- and encoding functions for EC public key             */
+/*         (octet string, not DER -- hence 'o2i' and 'i2o')         */
+/********************************************************************/
+
+/** Decodes an ec public key from a octet string.
+ *  \param  key  a pointer to a EC_KEY object which should be used
+ *  \param  in   memory buffer with the encoded public key
+ *  \param  len  length of the encoded public key
+ *  \return EC_KEY object with decoded public key or NULL if an error
+ *          occurred.
+ */
+OSSL_DEPRECATEDIN_3_0 EC_KEY *o2i_ECPublicKey(EC_KEY **key,
+                                              const unsigned char **in, long len);
+
+/** Encodes an ec public key in an octet string.
+ *  \param  key  the EC_KEY object with the public key
+ *  \param  out  the buffer for the result (if NULL the function returns number
+ *               of bytes needed).
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int i2o_ECPublicKey(const EC_KEY *key, unsigned char **out);
+
+/** Prints out the ec parameters on human readable form.
+ *  \param  bp   BIO object to which the information is printed
+ *  \param  key  EC_KEY object
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int ECParameters_print(BIO *bp, const EC_KEY *key);
+
+/** Prints out the contents of a EC_KEY object
+ *  \param  bp   BIO object to which the information is printed
+ *  \param  key  EC_KEY object
+ *  \param  off  line offset
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_print(BIO *bp, const EC_KEY *key, int off);
+
+#   ifndef OPENSSL_NO_STDIO
+/** Prints out the ec parameters on human readable form.
+ *  \param  fp   file descriptor to which the information is printed
+ *  \param  key  EC_KEY object
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int ECParameters_print_fp(FILE *fp, const EC_KEY *key);
+
+/** Prints out the contents of a EC_KEY object
+ *  \param  fp   file descriptor to which the information is printed
+ *  \param  key  EC_KEY object
+ *  \param  off  line offset
+ *  \return 1 on success and 0 if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off);
+#   endif /* OPENSSL_NO_STDIO */
+
+OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_OpenSSL(void);
+OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_get_default_method(void);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_default_method(const EC_KEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_get_method(const EC_KEY *key);
+OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_method(ENGINE *engine);
+
+/** The old name for ecdh_KDF_X9_63
+ *  The ECDH KDF specification has been mistakingly attributed to ANSI X9.62,
+ *  it is actually specified in ANSI X9.63.
+ *  This identifier is retained for backwards compatibility
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDH_KDF_X9_62(unsigned char *out, size_t outlen,
+                                         const unsigned char *Z, size_t Zlen,
+                                         const unsigned char *sinfo,
+                                         size_t sinfolen, const EVP_MD *md);
+
+OSSL_DEPRECATEDIN_3_0 int ECDH_compute_key(void *out, size_t outlen,
+                                           const EC_POINT *pub_key,
+                                           const EC_KEY *ecdh,
+                                           void *(*KDF)(const void *in,
+                                                        size_t inlen, void *out,
+                                                        size_t *outlen));
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+typedef struct ECDSA_SIG_st ECDSA_SIG;
+
+/** Allocates and initialize a ECDSA_SIG structure
+ *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+ */
+ECDSA_SIG *ECDSA_SIG_new(void);
+
+/** frees a ECDSA_SIG structure
+ *  \param  sig  pointer to the ECDSA_SIG structure
+ */
+void ECDSA_SIG_free(ECDSA_SIG *sig);
+
+/** i2d_ECDSA_SIG encodes content of ECDSA_SIG (note: this function modifies *pp
+ *  (*pp += length of the DER encoded signature)).
+ *  \param  sig  pointer to the ECDSA_SIG object
+ *  \param  pp   pointer to a unsigned char pointer for the output or NULL
+ *  \return the length of the DER encoded ECDSA_SIG object or a negative value
+ *          on error
+ */
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(ECDSA_SIG, ECDSA_SIG)
+
+/** d2i_ECDSA_SIG decodes an ECDSA signature (note: this function modifies *pp
+ *  (*pp += len)).
+ *  \param  sig  pointer to ECDSA_SIG pointer (may be NULL)
+ *  \param  pp   memory buffer with the DER encoded signature
+ *  \param  len  length of the buffer
+ *  \return pointer to the decoded ECDSA_SIG structure (or NULL)
+ */
+
+/** Accessor for r and s fields of ECDSA_SIG
+ *  \param  sig  pointer to ECDSA_SIG structure
+ *  \param  pr   pointer to BIGNUM pointer for r (may be NULL)
+ *  \param  ps   pointer to BIGNUM pointer for s (may be NULL)
+ */
+void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
+
+/** Accessor for r field of ECDSA_SIG
+ *  \param  sig  pointer to ECDSA_SIG structure
+ */
+const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig);
+
+/** Accessor for s field of ECDSA_SIG
+ *  \param  sig  pointer to ECDSA_SIG structure
+ */
+const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig);
+
+/** Setter for r and s fields of ECDSA_SIG
+ *  \param  sig  pointer to ECDSA_SIG structure
+ *  \param  r    pointer to BIGNUM for r
+ *  \param  s    pointer to BIGNUM for s
+ */
+int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/** Computes the ECDSA signature of the given hash value using
+ *  the supplied private key and returns the created signature.
+ *  \param  dgst      pointer to the hash value
+ *  \param  dgst_len  length of the hash value
+ *  \param  eckey     EC_KEY object containing a private EC key
+ *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst,
+                                               int dgst_len, EC_KEY *eckey);
+
+/** Computes ECDSA signature of a given hash value using the supplied
+ *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+ *  \param  dgst     pointer to the hash value to sign
+ *  \param  dgstlen  length of the hash value
+ *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
+ *  \param  rp       BIGNUM with a pre-computed rp value (optional),
+ *                   see ECDSA_sign_setup
+ *  \param  eckey    EC_KEY object containing a private EC key
+ *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+ */
+OSSL_DEPRECATEDIN_3_0 ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst,
+                                                  int dgstlen, const BIGNUM *kinv,
+                                                  const BIGNUM *rp, EC_KEY *eckey);
+
+/** Verifies that the supplied signature is a valid ECDSA
+ *  signature of the supplied hash value using the supplied public key.
+ *  \param  dgst      pointer to the hash value
+ *  \param  dgst_len  length of the hash value
+ *  \param  sig       ECDSA_SIG structure
+ *  \param  eckey     EC_KEY object containing a public EC key
+ *  \return 1 if the signature is valid, 0 if the signature is invalid
+ *          and -1 on error
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
+                                          const ECDSA_SIG *sig, EC_KEY *eckey);
+
+/** Precompute parts of the signing operation
+ *  \param  eckey  EC_KEY object containing a private EC key
+ *  \param  ctx    BN_CTX object (optional)
+ *  \param  kinv   BIGNUM pointer for the inverse of k
+ *  \param  rp     BIGNUM pointer for x coordinate of k * generator
+ *  \return 1 on success and 0 otherwise
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx,
+                                           BIGNUM **kinv, BIGNUM **rp);
+
+/** Computes ECDSA signature of a given hash value using the supplied
+ *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+ *  \param  type     this parameter is ignored
+ *  \param  dgst     pointer to the hash value to sign
+ *  \param  dgstlen  length of the hash value
+ *  \param  sig      memory for the DER encoded created signature
+ *  \param  siglen   pointer to the length of the returned signature
+ *  \param  eckey    EC_KEY object containing a private EC key
+ *  \return 1 on success and 0 otherwise
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_sign(int type, const unsigned char *dgst,
+                                     int dgstlen, unsigned char *sig,
+                                     unsigned int *siglen, EC_KEY *eckey);
+
+/** Computes ECDSA signature of a given hash value using the supplied
+ *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+ *  \param  type     this parameter is ignored
+ *  \param  dgst     pointer to the hash value to sign
+ *  \param  dgstlen  length of the hash value
+ *  \param  sig      buffer to hold the DER encoded signature
+ *  \param  siglen   pointer to the length of the returned signature
+ *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
+ *  \param  rp       BIGNUM with a pre-computed rp value (optional),
+ *                   see ECDSA_sign_setup
+ *  \param  eckey    EC_KEY object containing a private EC key
+ *  \return 1 on success and 0 otherwise
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_sign_ex(int type, const unsigned char *dgst,
+                                        int dgstlen, unsigned char *sig,
+                                        unsigned int *siglen, const BIGNUM *kinv,
+                                        const BIGNUM *rp, EC_KEY *eckey);
+
+/** Verifies that the given signature is valid ECDSA signature
+ *  of the supplied hash value using the specified public key.
+ *  \param  type     this parameter is ignored
+ *  \param  dgst     pointer to the hash value
+ *  \param  dgstlen  length of the hash value
+ *  \param  sig      pointer to the DER encoded signature
+ *  \param  siglen   length of the DER encoded signature
+ *  \param  eckey    EC_KEY object containing a public EC key
+ *  \return 1 if the signature is valid, 0 if the signature is invalid
+ *          and -1 on error
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_verify(int type, const unsigned char *dgst,
+                                       int dgstlen, const unsigned char *sig,
+                                       int siglen, EC_KEY *eckey);
+
+/** Returns the maximum length of the DER encoded signature
+ *  \param  eckey  EC_KEY object
+ *  \return numbers of bytes required for the DER encoded signature
+ */
+OSSL_DEPRECATEDIN_3_0 int ECDSA_size(const EC_KEY *eckey);
+
+/********************************************************************/
+/*  EC_KEY_METHOD constructors, destructors, writers and accessors  */
+/********************************************************************/
+
+OSSL_DEPRECATEDIN_3_0 EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_free(EC_KEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_init
+                      (EC_KEY_METHOD *meth,
+                       int (*init)(EC_KEY *key),
+                       void (*finish)(EC_KEY *key),
+                       int (*copy)(EC_KEY *dest, const EC_KEY *src),
+                       int (*set_group)(EC_KEY *key, const EC_GROUP *grp),
+                       int (*set_private)(EC_KEY *key, const BIGNUM *priv_key),
+                       int (*set_public)(EC_KEY *key, const EC_POINT *pub_key));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth,
+                                                    int (*keygen)(EC_KEY *key));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_compute_key
+                      (EC_KEY_METHOD *meth,
+                       int (*ckey)(unsigned char **psec, size_t *pseclen,
+                                   const EC_POINT *pub_key, const EC_KEY *ecdh));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_sign
+                      (EC_KEY_METHOD *meth,
+                       int (*sign)(int type, const unsigned char *dgst,
+                                   int dlen, unsigned char *sig,
+                                   unsigned int *siglen,
+                                   const BIGNUM *kinv, const BIGNUM *r,
+                                   EC_KEY *eckey),
+                       int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
+                                         BIGNUM **kinvp, BIGNUM **rp),
+                       ECDSA_SIG *(*sign_sig)(const unsigned char *dgst,
+                                              int dgst_len,
+                                              const BIGNUM *in_kinv,
+                                              const BIGNUM *in_r,
+                                              EC_KEY *eckey));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_verify
+                      (EC_KEY_METHOD *meth,
+                       int (*verify)(int type, const unsigned
+                                     char *dgst, int dgst_len,
+                                     const unsigned char *sigbuf,
+                                     int sig_len, EC_KEY *eckey),
+                       int (*verify_sig)(const unsigned char *dgst,
+                                         int dgst_len, const ECDSA_SIG *sig,
+                                         EC_KEY *eckey));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_init
+                      (const EC_KEY_METHOD *meth,
+                       int (**pinit)(EC_KEY *key),
+                       void (**pfinish)(EC_KEY *key),
+                       int (**pcopy)(EC_KEY *dest, const EC_KEY *src),
+                       int (**pset_group)(EC_KEY *key, const EC_GROUP *grp),
+                       int (**pset_private)(EC_KEY *key, const BIGNUM *priv_key),
+                       int (**pset_public)(EC_KEY *key, const EC_POINT *pub_key));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_keygen
+                      (const EC_KEY_METHOD *meth, int (**pkeygen)(EC_KEY *key));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_compute_key
+                      (const EC_KEY_METHOD *meth,
+                       int (**pck)(unsigned char **psec,
+                       size_t *pseclen,
+                       const EC_POINT *pub_key,
+                       const EC_KEY *ecdh));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_sign
+                      (const EC_KEY_METHOD *meth,
+                       int (**psign)(int type, const unsigned char *dgst,
+                                     int dlen, unsigned char *sig,
+                                     unsigned int *siglen,
+                                     const BIGNUM *kinv, const BIGNUM *r,
+                                     EC_KEY *eckey),
+                       int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
+                                           BIGNUM **kinvp, BIGNUM **rp),
+                       ECDSA_SIG *(**psign_sig)(const unsigned char *dgst,
+                                                int dgst_len,
+                                                const BIGNUM *in_kinv,
+                                                const BIGNUM *in_r,
+                                                EC_KEY *eckey));
+
+OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_verify
+                      (const EC_KEY_METHOD *meth,
+                       int (**pverify)(int type, const unsigned
+                                       char *dgst, int dgst_len,
+                                       const unsigned char *sigbuf,
+                                       int sig_len, EC_KEY *eckey),
+                       int (**pverify_sig)(const unsigned char *dgst,
+                                           int dgst_len,
+                                           const ECDSA_SIG *sig,
+                                           EC_KEY *eckey));
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+#  define EVP_EC_gen(curve) \
+    EVP_PKEY_Q_keygen(NULL, NULL, "EC", (char *)(strstr(curve, "")))
+    /* strstr is used to enable type checking for the variadic string arg */
+#  define ECParameters_dup(x) ASN1_dup_of(EC_KEY, i2d_ECParameters, \
+                                          d2i_ECParameters, x)
+
+#  ifndef __cplusplus
+#   if defined(__SUNPRO_C)
+#    if __SUNPRO_C >= 0x520
+#     pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE)
+#    endif
+#   endif
+#  endif
+
+# endif
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ecdh.h b/CAPI/cpp/grpc/include/openssl/ecdh.h
new file mode 100644
index 0000000..56bd4cc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ecdh.h
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <openssl/ec.h>
diff --git a/CAPI/cpp/grpc/include/openssl/ecdsa.h b/CAPI/cpp/grpc/include/openssl/ecdsa.h
new file mode 100644
index 0000000..56bd4cc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ecdsa.h
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <openssl/ec.h>
diff --git a/CAPI/cpp/grpc/include/openssl/ecerr.h b/CAPI/cpp/grpc/include/openssl/ecerr.h
new file mode 100644
index 0000000..46405ac
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ecerr.h
@@ -0,0 +1,103 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ECERR_H
+# define OPENSSL_ECERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_EC
+
+
+/*
+ * EC reason codes.
+ */
+#  define EC_R_ASN1_ERROR                                  115
+#  define EC_R_BAD_SIGNATURE                               156
+#  define EC_R_BIGNUM_OUT_OF_RANGE                         144
+#  define EC_R_BUFFER_TOO_SMALL                            100
+#  define EC_R_CANNOT_INVERT                               165
+#  define EC_R_COORDINATES_OUT_OF_RANGE                    146
+#  define EC_R_CURVE_DOES_NOT_SUPPORT_ECDH                 160
+#  define EC_R_CURVE_DOES_NOT_SUPPORT_ECDSA                170
+#  define EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING              159
+#  define EC_R_DECODE_ERROR                                142
+#  define EC_R_DISCRIMINANT_IS_ZERO                        118
+#  define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE                119
+#  define EC_R_EXPLICIT_PARAMS_NOT_SUPPORTED               127
+#  define EC_R_FAILED_MAKING_PUBLIC_KEY                    166
+#  define EC_R_FIELD_TOO_LARGE                             143
+#  define EC_R_GF2M_NOT_SUPPORTED                          147
+#  define EC_R_GROUP2PKPARAMETERS_FAILURE                  120
+#  define EC_R_I2D_ECPKPARAMETERS_FAILURE                  121
+#  define EC_R_INCOMPATIBLE_OBJECTS                        101
+#  define EC_R_INVALID_A                                   168
+#  define EC_R_INVALID_ARGUMENT                            112
+#  define EC_R_INVALID_B                                   169
+#  define EC_R_INVALID_COFACTOR                            171
+#  define EC_R_INVALID_COMPRESSED_POINT                    110
+#  define EC_R_INVALID_COMPRESSION_BIT                     109
+#  define EC_R_INVALID_CURVE                               141
+#  define EC_R_INVALID_DIGEST                              151
+#  define EC_R_INVALID_DIGEST_TYPE                         138
+#  define EC_R_INVALID_ENCODING                            102
+#  define EC_R_INVALID_FIELD                               103
+#  define EC_R_INVALID_FORM                                104
+#  define EC_R_INVALID_GENERATOR                           173
+#  define EC_R_INVALID_GROUP_ORDER                         122
+#  define EC_R_INVALID_KEY                                 116
+#  define EC_R_INVALID_LENGTH                              117
+#  define EC_R_INVALID_NAMED_GROUP_CONVERSION              174
+#  define EC_R_INVALID_OUTPUT_LENGTH                       161
+#  define EC_R_INVALID_P                                   172
+#  define EC_R_INVALID_PEER_KEY                            133
+#  define EC_R_INVALID_PENTANOMIAL_BASIS                   132
+#  define EC_R_INVALID_PRIVATE_KEY                         123
+#  define EC_R_INVALID_SEED                                175
+#  define EC_R_INVALID_TRINOMIAL_BASIS                     137
+#  define EC_R_KDF_PARAMETER_ERROR                         148
+#  define EC_R_KEYS_NOT_SET                                140
+#  define EC_R_LADDER_POST_FAILURE                         136
+#  define EC_R_LADDER_PRE_FAILURE                          153
+#  define EC_R_LADDER_STEP_FAILURE                         162
+#  define EC_R_MISSING_OID                                 167
+#  define EC_R_MISSING_PARAMETERS                          124
+#  define EC_R_MISSING_PRIVATE_KEY                         125
+#  define EC_R_NEED_NEW_SETUP_VALUES                       157
+#  define EC_R_NOT_A_NIST_PRIME                            135
+#  define EC_R_NOT_IMPLEMENTED                             126
+#  define EC_R_NOT_INITIALIZED                             111
+#  define EC_R_NO_PARAMETERS_SET                           139
+#  define EC_R_NO_PRIVATE_VALUE                            154
+#  define EC_R_OPERATION_NOT_SUPPORTED                     152
+#  define EC_R_PASSED_NULL_PARAMETER                       134
+#  define EC_R_PEER_KEY_ERROR                              149
+#  define EC_R_POINT_ARITHMETIC_FAILURE                    155
+#  define EC_R_POINT_AT_INFINITY                           106
+#  define EC_R_POINT_COORDINATES_BLIND_FAILURE             163
+#  define EC_R_POINT_IS_NOT_ON_CURVE                       107
+#  define EC_R_RANDOM_NUMBER_GENERATION_FAILED             158
+#  define EC_R_SHARED_INFO_ERROR                           150
+#  define EC_R_SLOT_FULL                                   108
+#  define EC_R_UNDEFINED_GENERATOR                         113
+#  define EC_R_UNDEFINED_ORDER                             128
+#  define EC_R_UNKNOWN_COFACTOR                            164
+#  define EC_R_UNKNOWN_GROUP                               129
+#  define EC_R_UNKNOWN_ORDER                               114
+#  define EC_R_UNSUPPORTED_FIELD                           131
+#  define EC_R_WRONG_CURVE_PARAMETERS                      145
+#  define EC_R_WRONG_ORDER                                 130
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/encoder.h b/CAPI/cpp/grpc/include/openssl/encoder.h
new file mode 100644
index 0000000..c37a6f1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/encoder.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ENCODER_H
+# define OPENSSL_ENCODER_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+# include <stdarg.h>
+# include <stddef.h>
+# include <openssl/encodererr.h>
+# include <openssl/types.h>
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+OSSL_ENCODER *OSSL_ENCODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
+                                 const char *properties);
+int OSSL_ENCODER_up_ref(OSSL_ENCODER *encoder);
+void OSSL_ENCODER_free(OSSL_ENCODER *encoder);
+
+const OSSL_PROVIDER *OSSL_ENCODER_get0_provider(const OSSL_ENCODER *encoder);
+const char *OSSL_ENCODER_get0_properties(const OSSL_ENCODER *encoder);
+const char *OSSL_ENCODER_get0_name(const OSSL_ENCODER *kdf);
+const char *OSSL_ENCODER_get0_description(const OSSL_ENCODER *kdf);
+int OSSL_ENCODER_is_a(const OSSL_ENCODER *encoder, const char *name);
+
+void OSSL_ENCODER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                  void (*fn)(OSSL_ENCODER *encoder, void *arg),
+                                  void *arg);
+int OSSL_ENCODER_names_do_all(const OSSL_ENCODER *encoder,
+                              void (*fn)(const char *name, void *data),
+                              void *data);
+const OSSL_PARAM *OSSL_ENCODER_gettable_params(OSSL_ENCODER *encoder);
+int OSSL_ENCODER_get_params(OSSL_ENCODER *encoder, OSSL_PARAM params[]);
+
+const OSSL_PARAM *OSSL_ENCODER_settable_ctx_params(OSSL_ENCODER *encoder);
+OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new(void);
+int OSSL_ENCODER_CTX_set_params(OSSL_ENCODER_CTX *ctx,
+                                const OSSL_PARAM params[]);
+void OSSL_ENCODER_CTX_free(OSSL_ENCODER_CTX *ctx);
+
+/* Utilities that help set specific parameters */
+int OSSL_ENCODER_CTX_set_passphrase(OSSL_ENCODER_CTX *ctx,
+                                    const unsigned char *kstr, size_t klen);
+int OSSL_ENCODER_CTX_set_pem_password_cb(OSSL_ENCODER_CTX *ctx,
+                                         pem_password_cb *cb, void *cbarg);
+int OSSL_ENCODER_CTX_set_passphrase_cb(OSSL_ENCODER_CTX *ctx,
+                                       OSSL_PASSPHRASE_CALLBACK *cb,
+                                       void *cbarg);
+int OSSL_ENCODER_CTX_set_passphrase_ui(OSSL_ENCODER_CTX *ctx,
+                                       const UI_METHOD *ui_method,
+                                       void *ui_data);
+int OSSL_ENCODER_CTX_set_cipher(OSSL_ENCODER_CTX *ctx,
+                                const char *cipher_name,
+                                const char *propquery);
+int OSSL_ENCODER_CTX_set_selection(OSSL_ENCODER_CTX *ctx, int selection);
+int OSSL_ENCODER_CTX_set_output_type(OSSL_ENCODER_CTX *ctx,
+                                     const char *output_type);
+int OSSL_ENCODER_CTX_set_output_structure(OSSL_ENCODER_CTX *ctx,
+                                          const char *output_structure);
+
+/* Utilities to add encoders */
+int OSSL_ENCODER_CTX_add_encoder(OSSL_ENCODER_CTX *ctx, OSSL_ENCODER *encoder);
+int OSSL_ENCODER_CTX_add_extra(OSSL_ENCODER_CTX *ctx,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+int OSSL_ENCODER_CTX_get_num_encoders(OSSL_ENCODER_CTX *ctx);
+
+typedef struct ossl_encoder_instance_st OSSL_ENCODER_INSTANCE;
+OSSL_ENCODER *
+OSSL_ENCODER_INSTANCE_get_encoder(OSSL_ENCODER_INSTANCE *encoder_inst);
+void *
+OSSL_ENCODER_INSTANCE_get_encoder_ctx(OSSL_ENCODER_INSTANCE *encoder_inst);
+const char *
+OSSL_ENCODER_INSTANCE_get_output_type(OSSL_ENCODER_INSTANCE *encoder_inst);
+const char *
+OSSL_ENCODER_INSTANCE_get_output_structure(OSSL_ENCODER_INSTANCE *encoder_inst);
+
+typedef const void *OSSL_ENCODER_CONSTRUCT(OSSL_ENCODER_INSTANCE *encoder_inst,
+                                           void *construct_data);
+typedef void OSSL_ENCODER_CLEANUP(void *construct_data);
+
+int OSSL_ENCODER_CTX_set_construct(OSSL_ENCODER_CTX *ctx,
+                                   OSSL_ENCODER_CONSTRUCT *construct);
+int OSSL_ENCODER_CTX_set_construct_data(OSSL_ENCODER_CTX *ctx,
+                                        void *construct_data);
+int OSSL_ENCODER_CTX_set_cleanup(OSSL_ENCODER_CTX *ctx,
+                                 OSSL_ENCODER_CLEANUP *cleanup);
+
+/* Utilities to output the object to encode */
+int OSSL_ENCODER_to_bio(OSSL_ENCODER_CTX *ctx, BIO *out);
+#ifndef OPENSSL_NO_STDIO
+int OSSL_ENCODER_to_fp(OSSL_ENCODER_CTX *ctx, FILE *fp);
+#endif
+int OSSL_ENCODER_to_data(OSSL_ENCODER_CTX *ctx, unsigned char **pdata,
+                         size_t *pdata_len);
+
+/*
+ * Create the OSSL_ENCODER_CTX with an associated type.  This will perform
+ * an implicit OSSL_ENCODER_fetch(), suitable for the object of that type.
+ * This is more useful than calling OSSL_ENCODER_CTX_new().
+ */
+OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new_for_pkey(const EVP_PKEY *pkey,
+                                                int selection,
+                                                const char *output_type,
+                                                const char *output_struct,
+                                                const char *propquery);
+
+# ifdef __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/encodererr.h b/CAPI/cpp/grpc/include/openssl/encodererr.h
new file mode 100644
index 0000000..5e318b1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/encodererr.h
@@ -0,0 +1,28 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ENCODERERR_H
+# define OPENSSL_ENCODERERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * OSSL_ENCODER reason codes.
+ */
+# define OSSL_ENCODER_R_ENCODER_NOT_FOUND                 101
+# define OSSL_ENCODER_R_INCORRECT_PROPERTY_QUERY          100
+# define OSSL_ENCODER_R_MISSING_GET_PARAMS                102
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/engine.h b/CAPI/cpp/grpc/include/openssl/engine.h
new file mode 100644
index 0000000..c965800
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/engine.h
@@ -0,0 +1,833 @@
+/*
+ * Copyright 2000-2022 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ENGINE_H
+# define OPENSSL_ENGINE_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ENGINE_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_ENGINE
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   include <openssl/bn.h>
+#   include <openssl/rsa.h>
+#   include <openssl/dsa.h>
+#   include <openssl/dh.h>
+#   include <openssl/ec.h>
+#   include <openssl/rand.h>
+#   include <openssl/ui.h>
+#   include <openssl/err.h>
+#  endif
+#  include <openssl/types.h>
+#  include <openssl/symhacks.h>
+#  include <openssl/x509.h>
+#  include <openssl/engineerr.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+/*
+ * These flags are used to control combinations of algorithm (methods) by
+ * bitwise "OR"ing.
+ */
+#  define ENGINE_METHOD_RSA               (unsigned int)0x0001
+#  define ENGINE_METHOD_DSA               (unsigned int)0x0002
+#  define ENGINE_METHOD_DH                (unsigned int)0x0004
+#  define ENGINE_METHOD_RAND              (unsigned int)0x0008
+#  define ENGINE_METHOD_CIPHERS           (unsigned int)0x0040
+#  define ENGINE_METHOD_DIGESTS           (unsigned int)0x0080
+#  define ENGINE_METHOD_PKEY_METHS        (unsigned int)0x0200
+#  define ENGINE_METHOD_PKEY_ASN1_METHS   (unsigned int)0x0400
+#  define ENGINE_METHOD_EC                (unsigned int)0x0800
+/* Obvious all-or-nothing cases. */
+#  define ENGINE_METHOD_ALL               (unsigned int)0xFFFF
+#  define ENGINE_METHOD_NONE              (unsigned int)0x0000
+
+/*
+ * This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used
+ * internally to control registration of ENGINE implementations, and can be
+ * set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to
+ * initialise registered ENGINEs if they are not already initialised.
+ */
+#  define ENGINE_TABLE_FLAG_NOINIT        (unsigned int)0x0001
+
+/* ENGINE flags that can be set by ENGINE_set_flags(). */
+/* Not used */
+/* #define ENGINE_FLAGS_MALLOCED        0x0001 */
+
+/*
+ * This flag is for ENGINEs that wish to handle the various 'CMD'-related
+ * control commands on their own. Without this flag, ENGINE_ctrl() handles
+ * these control commands on behalf of the ENGINE using their "cmd_defns"
+ * data.
+ */
+#  define ENGINE_FLAGS_MANUAL_CMD_CTRL    (int)0x0002
+
+/*
+ * This flag is for ENGINEs who return new duplicate structures when found
+ * via "ENGINE_by_id()". When an ENGINE must store state (eg. if
+ * ENGINE_ctrl() commands are called in sequence as part of some stateful
+ * process like key-generation setup and execution), it can set this flag -
+ * then each attempt to obtain the ENGINE will result in it being copied into
+ * a new structure. Normally, ENGINEs don't declare this flag so
+ * ENGINE_by_id() just increments the existing ENGINE's structural reference
+ * count.
+ */
+#  define ENGINE_FLAGS_BY_ID_COPY         (int)0x0004
+
+/*
+ * This flag if for an ENGINE that does not want its methods registered as
+ * part of ENGINE_register_all_complete() for example if the methods are not
+ * usable as default methods.
+ */
+
+#  define ENGINE_FLAGS_NO_REGISTER_ALL    (int)0x0008
+
+/*
+ * ENGINEs can support their own command types, and these flags are used in
+ * ENGINE_CTRL_GET_CMD_FLAGS to indicate to the caller what kind of input
+ * each command expects. Currently only numeric and string input is
+ * supported. If a control command supports none of the _NUMERIC, _STRING, or
+ * _NO_INPUT options, then it is regarded as an "internal" control command -
+ * and not for use in config setting situations. As such, they're not
+ * available to the ENGINE_ctrl_cmd_string() function, only raw ENGINE_ctrl()
+ * access. Changes to this list of 'command types' should be reflected
+ * carefully in ENGINE_cmd_is_executable() and ENGINE_ctrl_cmd_string().
+ */
+
+/* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */
+#  define ENGINE_CMD_FLAG_NUMERIC         (unsigned int)0x0001
+/*
+ * accepts string input (cast from 'void*' to 'const char *', 4th parameter
+ * to ENGINE_ctrl)
+ */
+#  define ENGINE_CMD_FLAG_STRING          (unsigned int)0x0002
+/*
+ * Indicates that the control command takes *no* input. Ie. the control
+ * command is unparameterised.
+ */
+#  define ENGINE_CMD_FLAG_NO_INPUT        (unsigned int)0x0004
+/*
+ * Indicates that the control command is internal. This control command won't
+ * be shown in any output, and is only usable through the ENGINE_ctrl_cmd()
+ * function.
+ */
+#  define ENGINE_CMD_FLAG_INTERNAL        (unsigned int)0x0008
+
+/*
+ * NB: These 3 control commands are deprecated and should not be used.
+ * ENGINEs relying on these commands should compile conditional support for
+ * compatibility (eg. if these symbols are defined) but should also migrate
+ * the same functionality to their own ENGINE-specific control functions that
+ * can be "discovered" by calling applications. The fact these control
+ * commands wouldn't be "executable" (ie. usable by text-based config)
+ * doesn't change the fact that application code can find and use them
+ * without requiring per-ENGINE hacking.
+ */
+
+/*
+ * These flags are used to tell the ctrl function what should be done. All
+ * command numbers are shared between all engines, even if some don't make
+ * sense to some engines.  In such a case, they do nothing but return the
+ * error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED.
+ */
+#  define ENGINE_CTRL_SET_LOGSTREAM               1
+#  define ENGINE_CTRL_SET_PASSWORD_CALLBACK       2
+#  define ENGINE_CTRL_HUP                         3/* Close and reinitialise
+                                                   * any handles/connections
+                                                   * etc. */
+#  define ENGINE_CTRL_SET_USER_INTERFACE          4/* Alternative to callback */
+#  define ENGINE_CTRL_SET_CALLBACK_DATA           5/* User-specific data, used
+                                                   * when calling the password
+                                                   * callback and the user
+                                                   * interface */
+#  define ENGINE_CTRL_LOAD_CONFIGURATION          6/* Load a configuration,
+                                                   * given a string that
+                                                   * represents a file name
+                                                   * or so */
+#  define ENGINE_CTRL_LOAD_SECTION                7/* Load data from a given
+                                                   * section in the already
+                                                   * loaded configuration */
+
+/*
+ * These control commands allow an application to deal with an arbitrary
+ * engine in a dynamic way. Warn: Negative return values indicate errors FOR
+ * THESE COMMANDS because zero is used to indicate 'end-of-list'. Other
+ * commands, including ENGINE-specific command types, return zero for an
+ * error. An ENGINE can choose to implement these ctrl functions, and can
+ * internally manage things however it chooses - it does so by setting the
+ * ENGINE_FLAGS_MANUAL_CMD_CTRL flag (using ENGINE_set_flags()). Otherwise
+ * the ENGINE_ctrl() code handles this on the ENGINE's behalf using the
+ * cmd_defns data (set using ENGINE_set_cmd_defns()). This means an ENGINE's
+ * ctrl() handler need only implement its own commands - the above "meta"
+ * commands will be taken care of.
+ */
+
+/*
+ * Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not",
+ * then all the remaining control commands will return failure, so it is
+ * worth checking this first if the caller is trying to "discover" the
+ * engine's capabilities and doesn't want errors generated unnecessarily.
+ */
+#  define ENGINE_CTRL_HAS_CTRL_FUNCTION           10
+/*
+ * Returns a positive command number for the first command supported by the
+ * engine. Returns zero if no ctrl commands are supported.
+ */
+#  define ENGINE_CTRL_GET_FIRST_CMD_TYPE          11
+/*
+ * The 'long' argument specifies a command implemented by the engine, and the
+ * return value is the next command supported, or zero if there are no more.
+ */
+#  define ENGINE_CTRL_GET_NEXT_CMD_TYPE           12
+/*
+ * The 'void*' argument is a command name (cast from 'const char *'), and the
+ * return value is the command that corresponds to it.
+ */
+#  define ENGINE_CTRL_GET_CMD_FROM_NAME           13
+/*
+ * The next two allow a command to be converted into its corresponding string
+ * form. In each case, the 'long' argument supplies the command. In the
+ * NAME_LEN case, the return value is the length of the command name (not
+ * counting a trailing EOL). In the NAME case, the 'void*' argument must be a
+ * string buffer large enough, and it will be populated with the name of the
+ * command (WITH a trailing EOL).
+ */
+#  define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD       14
+#  define ENGINE_CTRL_GET_NAME_FROM_CMD           15
+/* The next two are similar but give a "short description" of a command. */
+#  define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD       16
+#  define ENGINE_CTRL_GET_DESC_FROM_CMD           17
+/*
+ * With this command, the return value is the OR'd combination of
+ * ENGINE_CMD_FLAG_*** values that indicate what kind of input a given
+ * engine-specific ctrl command expects.
+ */
+#  define ENGINE_CTRL_GET_CMD_FLAGS               18
+
+/*
+ * ENGINE implementations should start the numbering of their own control
+ * commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc).
+ */
+#  define ENGINE_CMD_BASE                         200
+
+/*
+ * NB: These 2 nCipher "chil" control commands are deprecated, and their
+ * functionality is now available through ENGINE-specific control commands
+ * (exposed through the above-mentioned 'CMD'-handling). Code using these 2
+ * commands should be migrated to the more general command handling before
+ * these are removed.
+ */
+
+/* Flags specific to the nCipher "chil" engine */
+#  define ENGINE_CTRL_CHIL_SET_FORKCHECK          100
+         /*
+          * Depending on the value of the (long)i argument, this sets or
+          * unsets the SimpleForkCheck flag in the CHIL API to enable or
+          * disable checking and workarounds for applications that fork().
+          */
+#  define ENGINE_CTRL_CHIL_NO_LOCKING             101
+         /*
+          * This prevents the initialisation function from providing mutex
+          * callbacks to the nCipher library.
+          */
+
+/*
+ * If an ENGINE supports its own specific control commands and wishes the
+ * framework to handle the above 'ENGINE_CMD_***'-manipulation commands on
+ * its behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN
+ * entries to ENGINE_set_cmd_defns(). It should also implement a ctrl()
+ * handler that supports the stated commands (ie. the "cmd_num" entries as
+ * described by the array). NB: The array must be ordered in increasing order
+ * of cmd_num. "null-terminated" means that the last ENGINE_CMD_DEFN element
+ * has cmd_num set to zero and/or cmd_name set to NULL.
+ */
+typedef struct ENGINE_CMD_DEFN_st {
+    unsigned int cmd_num;       /* The command number */
+    const char *cmd_name;       /* The command name itself */
+    const char *cmd_desc;       /* A short description of the command */
+    unsigned int cmd_flags;     /* The input the command expects */
+} ENGINE_CMD_DEFN;
+
+/* Generic function pointer */
+typedef int (*ENGINE_GEN_FUNC_PTR) (void);
+/* Generic function pointer taking no arguments */
+typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *);
+/* Specific control function pointer */
+typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *,
+                                     void (*f) (void));
+/* Generic load_key function pointer */
+typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *,
+                                         UI_METHOD *ui_method,
+                                         void *callback_data);
+typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl,
+                                           STACK_OF(X509_NAME) *ca_dn,
+                                           X509 **pcert, EVP_PKEY **pkey,
+                                           STACK_OF(X509) **pother,
+                                           UI_METHOD *ui_method,
+                                           void *callback_data);
+/*-
+ * These callback types are for an ENGINE's handler for cipher and digest logic.
+ * These handlers have these prototypes;
+ *   int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);
+ *   int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid);
+ * Looking at how to implement these handlers in the case of cipher support, if
+ * the framework wants the EVP_CIPHER for 'nid', it will call;
+ *   foo(e, &p_evp_cipher, NULL, nid);    (return zero for failure)
+ * If the framework wants a list of supported 'nid's, it will call;
+ *   foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error)
+ */
+/*
+ * Returns to a pointer to the array of supported cipher 'nid's. If the
+ * second parameter is non-NULL it is set to the size of the returned array.
+ */
+typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **,
+                                   const int **, int);
+typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **,
+                                   int);
+typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **,
+                                      const int **, int);
+typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **,
+                                           const int **, int);
+/*
+ * STRUCTURE functions ... all of these functions deal with pointers to
+ * ENGINE structures where the pointers have a "structural reference". This
+ * means that their reference is to allowed access to the structure but it
+ * does not imply that the structure is functional. To simply increment or
+ * decrement the structural reference count, use ENGINE_by_id and
+ * ENGINE_free. NB: This is not required when iterating using ENGINE_get_next
+ * as it will automatically decrement the structural reference count of the
+ * "current" ENGINE and increment the structural reference count of the
+ * ENGINE it returns (unless it is NULL).
+ */
+
+/* Get the first/last "ENGINE" type available. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_first(void);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_last(void);
+#  endif
+/* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_next(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_prev(ENGINE *e);
+#  endif
+/* Add another "ENGINE" type into the array. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_add(ENGINE *e);
+#  endif
+/* Remove an existing "ENGINE" type from the array. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_remove(ENGINE *e);
+#  endif
+/* Retrieve an engine from the list by its unique "id" value. */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_by_id(const char *id);
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   define ENGINE_load_openssl() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL)
+#   define ENGINE_load_dynamic() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL)
+#   ifndef OPENSSL_NO_STATIC_ENGINE
+#    define ENGINE_load_padlock() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL)
+#    define ENGINE_load_capi() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL)
+#    define ENGINE_load_afalg() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL)
+#   endif
+#   define ENGINE_load_cryptodev() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL)
+#   define ENGINE_load_rdrand() \
+        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL)
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void ENGINE_load_builtin_engines(void);
+#  endif
+
+/*
+ * Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation
+ * "registry" handling.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 unsigned int ENGINE_get_table_flags(void);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_set_table_flags(unsigned int flags);
+#  endif
+
+/*- Manage registration of ENGINEs per "table". For each type, there are 3
+ * functions;
+ *   ENGINE_register_***(e) - registers the implementation from 'e' (if it has one)
+ *   ENGINE_unregister_***(e) - unregister the implementation from 'e'
+ *   ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list
+ * Cleanup is automatically registered from each table when required.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_RSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_RSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_RSA(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_DSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_DSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_DSA(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_EC(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_EC(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_EC(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_DH(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_DH(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_DH(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_RAND(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_RAND(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_RAND(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_ciphers(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_ciphers(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_ciphers(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_digests(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_digests(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_digests(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_pkey_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_pkey_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_meths(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_pkey_asn1_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_pkey_asn1_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_asn1_meths(void);
+#  endif
+
+/*
+ * These functions register all support from the above categories. Note, use
+ * of these functions can result in static linkage of code your application
+ * may not need. If you only need a subset of functionality, consider using
+ * more selective initialisation.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_complete(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_register_all_complete(void);
+#  endif
+
+/*
+ * Send parameterised control commands to the engine. The possibilities to
+ * send down an integer, a pointer to data or a function pointer are
+ * provided. Any of the parameters may or may not be NULL, depending on the
+ * command number. In actuality, this function only requires a structural
+ * (rather than functional) reference to an engine, but many control commands
+ * may require the engine be functional. The caller should be aware of trying
+ * commands that require an operational ENGINE, and only use functional
+ * references in such situations.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p,
+                                      void (*f) (void));
+#  endif
+
+/*
+ * This function tests if an ENGINE-specific command is usable as a
+ * "setting". Eg. in an application's config file that gets processed through
+ * ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to
+ * ENGINE_ctrl_cmd_string(), only ENGINE_ctrl().
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
+#  endif
+
+/*
+ * This function works like ENGINE_ctrl() with the exception of taking a
+ * command name instead of a command number, and can handle optional
+ * commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation
+ * on how to use the cmd_name and cmd_optional.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
+                                          long i, void *p, void (*f) (void),
+                                          int cmd_optional);
+#  endif
+
+/*
+ * This function passes a command-name and argument to an ENGINE. The
+ * cmd_name is converted to a command number and the control command is
+ * called using 'arg' as an argument (unless the ENGINE doesn't support such
+ * a command, in which case no control command is called). The command is
+ * checked for input flags, and if necessary the argument will be converted
+ * to a numeric value. If cmd_optional is non-zero, then if the ENGINE
+ * doesn't support the given cmd_name the return value will be success
+ * anyway. This function is intended for applications to use so that users
+ * (or config files) can supply engine-specific config data to the ENGINE at
+ * run-time to control behaviour of specific engines. As such, it shouldn't
+ * be used for calling ENGINE_ctrl() functions that return data, deal with
+ * binary data, or that are otherwise supposed to be used directly through
+ * ENGINE_ctrl() in application code. Any "return" data from an ENGINE_ctrl()
+ * operation in this function will be lost - the return value is interpreted
+ * as failure if the return value is zero, success otherwise, and this
+ * function returns a boolean value as a result. In other words, vendors of
+ * 'ENGINE'-enabled devices should write ENGINE implementations with
+ * parameterisations that work in this scheme, so that compliant ENGINE-based
+ * applications can work consistently with the same configuration for the
+ * same ENGINE-enabled devices, across applications.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
+                           int cmd_optional);
+#  endif
+
+/*
+ * These functions are useful for manufacturing new ENGINE structures. They
+ * don't address reference counting at all - one uses them to populate an
+ * ENGINE structure with personalised implementations of things prior to
+ * using it directly or adding it to the builtin ENGINE list in OpenSSL.
+ * These are also here so that the ENGINE structure doesn't have to be
+ * exposed and break binary compatibility!
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_new(void);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_free(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_up_ref(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_id(ENGINE *e, const char *id);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_name(ENGINE *e, const char *name);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_destroy_function(ENGINE *e,ENGINE_GEN_INT_FUNC_PTR destroy_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
+                                             ENGINE_SSL_CLIENT_CERT_PTR loadssl_f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_flags(ENGINE *e, int flags);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_cmd_defns(ENGINE *e,
+                                               const ENGINE_CMD_DEFN *defns);
+#  endif
+/* These functions allow control over any per-structure ENGINE data. */
+#  define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, l, p, newf, dupf, freef)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *ENGINE_get_ex_data(const ENGINE *e, int idx);
+# endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/*
+ * This function previously cleaned up anything that needs it. Auto-deinit will
+ * now take care of it so it is no longer required to call this function.
+ */
+#   define ENGINE_cleanup() while(0) continue
+#  endif
+
+/*
+ * These return values from within the ENGINE structure. These can be useful
+ * with functional references as well as structural references - it depends
+ * which you obtained. Using the result for functional purposes if you only
+ * obtained a structural reference may be problematic!
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *ENGINE_get_id(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const char *ENGINE_get_name(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
+OSSL_DEPRECATEDIN_3_0
+const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
+OSSL_DEPRECATEDIN_3_0
+const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid);
+OSSL_DEPRECATEDIN_3_0
+const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid);
+OSSL_DEPRECATEDIN_3_0
+const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e,
+                                                          const char *str,
+                                                          int len);
+OSSL_DEPRECATEDIN_3_0
+const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe,
+                                                      const char *str, int len);
+OSSL_DEPRECATEDIN_3_0
+const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_get_flags(const ENGINE *e);
+#  endif
+
+/*
+ * FUNCTIONAL functions. These functions deal with ENGINE structures that
+ * have (or will) be initialised for use. Broadly speaking, the structural
+ * functions are useful for iterating the list of available engine types,
+ * creating new engine types, and other "list" operations. These functions
+ * actually deal with ENGINEs that are to be used. As such these functions
+ * can fail (if applicable) when particular engines are unavailable - eg. if
+ * a hardware accelerator is not attached or not functioning correctly. Each
+ * ENGINE has 2 reference counts; structural and functional. Every time a
+ * functional reference is obtained or released, a corresponding structural
+ * reference is automatically obtained or released too.
+ */
+
+/*
+ * Initialise a engine type for use (or up its reference count if it's
+ * already in use). This will fail if the engine is not currently operational
+ * and cannot initialise.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_init(ENGINE *e);
+#  endif
+/*
+ * Free a functional reference to a engine type. This does not require a
+ * corresponding call to ENGINE_free as it also releases a structural
+ * reference.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_finish(ENGINE *e);
+#  endif
+
+/*
+ * The following functions handle keys that are stored in some secondary
+ * location, handled by the engine.  The storage may be on a card or
+ * whatever.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
+                                  UI_METHOD *ui_method, void *callback_data);
+OSSL_DEPRECATEDIN_3_0
+EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
+                                 UI_METHOD *ui_method, void *callback_data);
+OSSL_DEPRECATEDIN_3_0
+int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, STACK_OF(X509_NAME) *ca_dn,
+                                X509 **pcert, EVP_PKEY **ppkey,
+                                STACK_OF(X509) **pother,
+                                UI_METHOD *ui_method, void *callback_data);
+#  endif
+
+/*
+ * This returns a pointer for the current ENGINE structure that is (by
+ * default) performing any RSA operations. The value returned is an
+ * incremented reference, so it should be free'd (ENGINE_finish) before it is
+ * discarded.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_RSA(void);
+#  endif
+/* Same for the other "methods" */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_DSA(void);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_EC(void);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_DH(void);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_RAND(void);
+#  endif
+/*
+ * These functions can be used to get a functional reference to perform
+ * ciphering or digesting corresponding to "nid".
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_cipher_engine(int nid);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_digest_engine(int nid);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_pkey_meth_engine(int nid);
+OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid);
+#  endif
+
+/*
+ * This sets a new default ENGINE structure for performing RSA operations. If
+ * the result is non-zero (success) then the ENGINE structure will have had
+ * its reference count up'd so the caller should still free their own
+ * reference 'e'.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_RSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_string(ENGINE *e,
+                                                    const char *def_list);
+#  endif
+/* Same for the other "methods" */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_DSA(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_EC(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_DH(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_RAND(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_ciphers(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_digests(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_meths(ENGINE *e);
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_asn1_meths(ENGINE *e);
+#  endif
+
+/*
+ * The combination "set" - the flags are bitwise "OR"d from the
+ * ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()"
+ * function, this function can result in unnecessary static linkage. If your
+ * application requires only specific functionality, consider using more
+ * selective functions.
+ */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default(ENGINE *e, unsigned int flags);
+OSSL_DEPRECATEDIN_3_0 void ENGINE_add_conf_module(void);
+#  endif
+
+/* Deprecated functions ... */
+/* int ENGINE_clear_defaults(void); */
+
+/**************************/
+/* DYNAMIC ENGINE SUPPORT */
+/**************************/
+
+/* Binary/behaviour compatibility levels */
+#  define OSSL_DYNAMIC_VERSION            (unsigned long)0x00030000
+/*
+ * Binary versions older than this are too old for us (whether we're a loader
+ * or a loadee)
+ */
+#  define OSSL_DYNAMIC_OLDEST             (unsigned long)0x00030000
+
+/*
+ * When compiling an ENGINE entirely as an external shared library, loadable
+ * by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns'
+ * structure type provides the calling application's (or library's) error
+ * functionality and memory management function pointers to the loaded
+ * library. These should be used/set in the loaded library code so that the
+ * loading application's 'state' will be used/changed in all operations. The
+ * 'static_state' pointer allows the loaded library to know if it shares the
+ * same static data as the calling application (or library), and thus whether
+ * these callbacks need to be set or not.
+ */
+typedef void *(*dyn_MEM_malloc_fn) (size_t, const char *, int);
+typedef void *(*dyn_MEM_realloc_fn) (void *, size_t, const char *, int);
+typedef void (*dyn_MEM_free_fn) (void *, const char *, int);
+typedef struct st_dynamic_MEM_fns {
+    dyn_MEM_malloc_fn malloc_fn;
+    dyn_MEM_realloc_fn realloc_fn;
+    dyn_MEM_free_fn free_fn;
+} dynamic_MEM_fns;
+/*
+ * FIXME: Perhaps the memory and locking code (crypto.h) should declare and
+ * use these types so we (and any other dependent code) can simplify a bit??
+ */
+/* The top-level structure */
+typedef struct st_dynamic_fns {
+    void *static_state;
+    dynamic_MEM_fns mem_fns;
+} dynamic_fns;
+
+/*
+ * The version checking function should be of this prototype. NB: The
+ * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading
+ * code. If this function returns zero, it indicates a (potential) version
+ * incompatibility and the loaded library doesn't believe it can proceed.
+ * Otherwise, the returned value is the (latest) version supported by the
+ * loading library. The loader may still decide that the loaded code's
+ * version is unsatisfactory and could veto the load. The function is
+ * expected to be implemented with the symbol name "v_check", and a default
+ * implementation can be fully instantiated with
+ * IMPLEMENT_DYNAMIC_CHECK_FN().
+ */
+typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version);
+#  define IMPLEMENT_DYNAMIC_CHECK_FN() \
+        OPENSSL_EXPORT unsigned long v_check(unsigned long v); \
+        OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \
+                if (v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \
+                return 0; }
+
+/*
+ * This function is passed the ENGINE structure to initialise with its own
+ * function and command settings. It should not adjust the structural or
+ * functional reference counts. If this function returns zero, (a) the load
+ * will be aborted, (b) the previous ENGINE state will be memcpy'd back onto
+ * the structure, and (c) the shared library will be unloaded. So
+ * implementations should do their own internal cleanup in failure
+ * circumstances otherwise they could leak. The 'id' parameter, if non-NULL,
+ * represents the ENGINE id that the loader is looking for. If this is NULL,
+ * the shared library can choose to return failure or to initialise a
+ * 'default' ENGINE. If non-NULL, the shared library must initialise only an
+ * ENGINE matching the passed 'id'. The function is expected to be
+ * implemented with the symbol name "bind_engine". A standard implementation
+ * can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where the parameter
+ * 'fn' is a callback function that populates the ENGINE structure and
+ * returns an int value (zero for failure). 'fn' should have prototype;
+ * [static] int fn(ENGINE *e, const char *id);
+ */
+typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id,
+                                    const dynamic_fns *fns);
+#  define IMPLEMENT_DYNAMIC_BIND_FN(fn) \
+        OPENSSL_EXPORT \
+        int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \
+        OPENSSL_EXPORT \
+        int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \
+            if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \
+            CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, \
+                                     fns->mem_fns.realloc_fn, \
+                                     fns->mem_fns.free_fn); \
+            OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, NULL); \
+        skip_cbs: \
+            if (!fn(e, id)) return 0; \
+            return 1; }
+
+/*
+ * If the loading application (or library) and the loaded ENGINE library
+ * share the same static data (eg. they're both dynamically linked to the
+ * same libcrypto.so) we need a way to avoid trying to set system callbacks -
+ * this would fail, and for the same reason that it's unnecessary to try. If
+ * the loaded ENGINE has (or gets from through the loader) its own copy of
+ * the libcrypto static data, we will need to set the callbacks. The easiest
+ * way to detect this is to have a function that returns a pointer to some
+ * static data and let the loading application and loaded ENGINE compare
+ * their respective values.
+ */
+void *ENGINE_get_static_state(void);
+
+#  if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+#   ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void ENGINE_setup_bsd_cryptodev(void);
+#   endif
+#  endif
+
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif /* OPENSSL_NO_ENGINE */
+#endif  /* OPENSSL_ENGINE_H */
diff --git a/CAPI/cpp/grpc/include/openssl/engineerr.h b/CAPI/cpp/grpc/include/openssl/engineerr.h
new file mode 100644
index 0000000..d439b68
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/engineerr.h
@@ -0,0 +1,63 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ENGINEERR_H
+# define OPENSSL_ENGINEERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_ENGINE
+
+
+/*
+ * ENGINE reason codes.
+ */
+#  define ENGINE_R_ALREADY_LOADED                          100
+#  define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER                133
+#  define ENGINE_R_CMD_NOT_EXECUTABLE                      134
+#  define ENGINE_R_COMMAND_TAKES_INPUT                     135
+#  define ENGINE_R_COMMAND_TAKES_NO_INPUT                  136
+#  define ENGINE_R_CONFLICTING_ENGINE_ID                   103
+#  define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED            119
+#  define ENGINE_R_DSO_FAILURE                             104
+#  define ENGINE_R_DSO_NOT_FOUND                           132
+#  define ENGINE_R_ENGINES_SECTION_ERROR                   148
+#  define ENGINE_R_ENGINE_CONFIGURATION_ERROR              102
+#  define ENGINE_R_ENGINE_IS_NOT_IN_LIST                   105
+#  define ENGINE_R_ENGINE_SECTION_ERROR                    149
+#  define ENGINE_R_FAILED_LOADING_PRIVATE_KEY              128
+#  define ENGINE_R_FAILED_LOADING_PUBLIC_KEY               129
+#  define ENGINE_R_FINISH_FAILED                           106
+#  define ENGINE_R_ID_OR_NAME_MISSING                      108
+#  define ENGINE_R_INIT_FAILED                             109
+#  define ENGINE_R_INTERNAL_LIST_ERROR                     110
+#  define ENGINE_R_INVALID_ARGUMENT                        143
+#  define ENGINE_R_INVALID_CMD_NAME                        137
+#  define ENGINE_R_INVALID_CMD_NUMBER                      138
+#  define ENGINE_R_INVALID_INIT_VALUE                      151
+#  define ENGINE_R_INVALID_STRING                          150
+#  define ENGINE_R_NOT_INITIALISED                         117
+#  define ENGINE_R_NOT_LOADED                              112
+#  define ENGINE_R_NO_CONTROL_FUNCTION                     120
+#  define ENGINE_R_NO_INDEX                                144
+#  define ENGINE_R_NO_LOAD_FUNCTION                        125
+#  define ENGINE_R_NO_REFERENCE                            130
+#  define ENGINE_R_NO_SUCH_ENGINE                          116
+#  define ENGINE_R_UNIMPLEMENTED_CIPHER                    146
+#  define ENGINE_R_UNIMPLEMENTED_DIGEST                    147
+#  define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD         101
+#  define ENGINE_R_VERSION_INCOMPATIBILITY                 145
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/err.h b/CAPI/cpp/grpc/include/openssl/err.h
new file mode 100644
index 0000000..3c7299d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/err.h
@@ -0,0 +1,492 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_ERR_H
+# define OPENSSL_ERR_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ERR_H
+# endif
+
+# include <openssl/e_os2.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+#  include <stdlib.h>
+# endif
+
+# include <openssl/types.h>
+# include <openssl/bio.h>
+# include <openssl/lhash.h>
+# include <openssl/cryptoerr_legacy.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_FILENAMES
+#   define ERR_PUT_error(l,f,r,fn,ln)      ERR_put_error(l,f,r,fn,ln)
+#  else
+#   define ERR_PUT_error(l,f,r,fn,ln)      ERR_put_error(l,f,r,NULL,0)
+#  endif
+# endif
+
+# include <limits.h>
+# include <errno.h>
+
+# define ERR_TXT_MALLOCED        0x01
+# define ERR_TXT_STRING          0x02
+
+# if !defined(OPENSSL_NO_DEPRECATED_3_0) || defined(OSSL_FORCE_ERR_STATE)
+#  define ERR_FLAG_MARK           0x01
+#  define ERR_FLAG_CLEAR          0x02
+
+#  define ERR_NUM_ERRORS  16
+struct err_state_st {
+    int err_flags[ERR_NUM_ERRORS];
+    int err_marks[ERR_NUM_ERRORS];
+    unsigned long err_buffer[ERR_NUM_ERRORS];
+    char *err_data[ERR_NUM_ERRORS];
+    size_t err_data_size[ERR_NUM_ERRORS];
+    int err_data_flags[ERR_NUM_ERRORS];
+    char *err_file[ERR_NUM_ERRORS];
+    int err_line[ERR_NUM_ERRORS];
+    char *err_func[ERR_NUM_ERRORS];
+    int top, bottom;
+};
+# endif
+
+/* library */
+# define ERR_LIB_NONE            1
+# define ERR_LIB_SYS             2
+# define ERR_LIB_BN              3
+# define ERR_LIB_RSA             4
+# define ERR_LIB_DH              5
+# define ERR_LIB_EVP             6
+# define ERR_LIB_BUF             7
+# define ERR_LIB_OBJ             8
+# define ERR_LIB_PEM             9
+# define ERR_LIB_DSA             10
+# define ERR_LIB_X509            11
+/* #define ERR_LIB_METH         12 */
+# define ERR_LIB_ASN1            13
+# define ERR_LIB_CONF            14
+# define ERR_LIB_CRYPTO          15
+# define ERR_LIB_EC              16
+# define ERR_LIB_SSL             20
+/* #define ERR_LIB_SSL23        21 */
+/* #define ERR_LIB_SSL2         22 */
+/* #define ERR_LIB_SSL3         23 */
+/* #define ERR_LIB_RSAREF       30 */
+/* #define ERR_LIB_PROXY        31 */
+# define ERR_LIB_BIO             32
+# define ERR_LIB_PKCS7           33
+# define ERR_LIB_X509V3          34
+# define ERR_LIB_PKCS12          35
+# define ERR_LIB_RAND            36
+# define ERR_LIB_DSO             37
+# define ERR_LIB_ENGINE          38
+# define ERR_LIB_OCSP            39
+# define ERR_LIB_UI              40
+# define ERR_LIB_COMP            41
+# define ERR_LIB_ECDSA           42
+# define ERR_LIB_ECDH            43
+# define ERR_LIB_OSSL_STORE      44
+# define ERR_LIB_FIPS            45
+# define ERR_LIB_CMS             46
+# define ERR_LIB_TS              47
+# define ERR_LIB_HMAC            48
+/* # define ERR_LIB_JPAKE       49 */
+# define ERR_LIB_CT              50
+# define ERR_LIB_ASYNC           51
+# define ERR_LIB_KDF             52
+# define ERR_LIB_SM2             53
+# define ERR_LIB_ESS             54
+# define ERR_LIB_PROP            55
+# define ERR_LIB_CRMF            56
+# define ERR_LIB_PROV            57
+# define ERR_LIB_CMP             58
+# define ERR_LIB_OSSL_ENCODER    59
+# define ERR_LIB_OSSL_DECODER    60
+# define ERR_LIB_HTTP            61
+
+# define ERR_LIB_USER            128
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define ASN1err(f, r) ERR_raise_data(ERR_LIB_ASN1, (r), NULL)
+#  define ASYNCerr(f, r) ERR_raise_data(ERR_LIB_ASYNC, (r), NULL)
+#  define BIOerr(f, r) ERR_raise_data(ERR_LIB_BIO, (r), NULL)
+#  define BNerr(f, r)  ERR_raise_data(ERR_LIB_BN, (r), NULL)
+#  define BUFerr(f, r) ERR_raise_data(ERR_LIB_BUF, (r), NULL)
+#  define CMPerr(f, r) ERR_raise_data(ERR_LIB_CMP, (r), NULL)
+#  define CMSerr(f, r) ERR_raise_data(ERR_LIB_CMS, (r), NULL)
+#  define COMPerr(f, r) ERR_raise_data(ERR_LIB_COMP, (r), NULL)
+#  define CONFerr(f, r) ERR_raise_data(ERR_LIB_CONF, (r), NULL)
+#  define CRMFerr(f, r) ERR_raise_data(ERR_LIB_CRMF, (r), NULL)
+#  define CRYPTOerr(f, r) ERR_raise_data(ERR_LIB_CRYPTO, (r), NULL)
+#  define CTerr(f, r) ERR_raise_data(ERR_LIB_CT, (r), NULL)
+#  define DHerr(f, r)  ERR_raise_data(ERR_LIB_DH, (r), NULL)
+#  define DSAerr(f, r) ERR_raise_data(ERR_LIB_DSA, (r), NULL)
+#  define DSOerr(f, r) ERR_raise_data(ERR_LIB_DSO, (r), NULL)
+#  define ECDHerr(f, r) ERR_raise_data(ERR_LIB_ECDH, (r), NULL)
+#  define ECDSAerr(f, r) ERR_raise_data(ERR_LIB_ECDSA, (r), NULL)
+#  define ECerr(f, r)  ERR_raise_data(ERR_LIB_EC, (r), NULL)
+#  define ENGINEerr(f, r) ERR_raise_data(ERR_LIB_ENGINE, (r), NULL)
+#  define ESSerr(f, r) ERR_raise_data(ERR_LIB_ESS, (r), NULL)
+#  define EVPerr(f, r) ERR_raise_data(ERR_LIB_EVP, (r), NULL)
+#  define FIPSerr(f, r) ERR_raise_data(ERR_LIB_FIPS, (r), NULL)
+#  define HMACerr(f, r) ERR_raise_data(ERR_LIB_HMAC, (r), NULL)
+#  define HTTPerr(f, r) ERR_raise_data(ERR_LIB_HTTP, (r), NULL)
+#  define KDFerr(f, r) ERR_raise_data(ERR_LIB_KDF, (r), NULL)
+#  define OBJerr(f, r) ERR_raise_data(ERR_LIB_OBJ, (r), NULL)
+#  define OCSPerr(f, r) ERR_raise_data(ERR_LIB_OCSP, (r), NULL)
+#  define OSSL_STOREerr(f, r) ERR_raise_data(ERR_LIB_OSSL_STORE, (r), NULL)
+#  define PEMerr(f, r) ERR_raise_data(ERR_LIB_PEM, (r), NULL)
+#  define PKCS12err(f, r) ERR_raise_data(ERR_LIB_PKCS12, (r), NULL)
+#  define PKCS7err(f, r) ERR_raise_data(ERR_LIB_PKCS7, (r), NULL)
+#  define PROPerr(f, r) ERR_raise_data(ERR_LIB_PROP, (r), NULL)
+#  define PROVerr(f, r) ERR_raise_data(ERR_LIB_PROV, (r), NULL)
+#  define RANDerr(f, r) ERR_raise_data(ERR_LIB_RAND, (r), NULL)
+#  define RSAerr(f, r) ERR_raise_data(ERR_LIB_RSA, (r), NULL)
+#  define KDFerr(f, r) ERR_raise_data(ERR_LIB_KDF, (r), NULL)
+#  define SM2err(f, r) ERR_raise_data(ERR_LIB_SM2, (r), NULL)
+#  define SSLerr(f, r) ERR_raise_data(ERR_LIB_SSL, (r), NULL)
+#  define SYSerr(f, r) ERR_raise_data(ERR_LIB_SYS, (r), NULL)
+#  define TSerr(f, r) ERR_raise_data(ERR_LIB_TS, (r), NULL)
+#  define UIerr(f, r) ERR_raise_data(ERR_LIB_UI, (r), NULL)
+#  define X509V3err(f, r) ERR_raise_data(ERR_LIB_X509V3, (r), NULL)
+#  define X509err(f, r) ERR_raise_data(ERR_LIB_X509, (r), NULL)
+# endif
+
+/*-
+ * The error code packs differently depending on if it records a system
+ * error or an OpenSSL error.
+ *
+ * A system error packs like this (we follow POSIX and only allow positive
+ * numbers that fit in an |int|):
+ *
+ * +-+-------------------------------------------------------------+
+ * |1|                     system error number                     |
+ * +-+-------------------------------------------------------------+
+ *
+ * An OpenSSL error packs like this:
+ *
+ * <---------------------------- 32 bits -------------------------->
+ *    <--- 8 bits ---><------------------ 23 bits ----------------->
+ * +-+---------------+---------------------------------------------+
+ * |0|    library    |                    reason                   |
+ * +-+---------------+---------------------------------------------+
+ *
+ * A few of the reason bits are reserved as flags with special meaning:
+ *
+ *                    <5 bits-<>--------- 19 bits ----------------->
+ *                   +-------+-+-----------------------------------+
+ *                   | rflags| |          reason                   |
+ *                   +-------+-+-----------------------------------+
+ *                            ^
+ *                            |
+ *                           ERR_RFLAG_FATAL = ERR_R_FATAL
+ *
+ * The reason flags are part of the overall reason code for practical
+ * reasons, as they provide an easy way to place different types of
+ * reason codes in different numeric ranges.
+ *
+ * The currently known reason flags are:
+ *
+ * ERR_RFLAG_FATAL      Flags that the reason code is considered fatal.
+ *                      For backward compatibility reasons, this flag
+ *                      is also the code for ERR_R_FATAL (that reason
+ *                      code served the dual purpose of flag and reason
+ *                      code in one in pre-3.0 OpenSSL).
+ * ERR_RFLAG_COMMON     Flags that the reason code is common to all
+ *                      libraries.  All ERR_R_ macros must use this flag,
+ *                      and no other _R_ macro is allowed to use it.
+ */
+
+/* Macros to help decode recorded system errors */
+# define ERR_SYSTEM_FLAG                ((unsigned int)INT_MAX + 1)
+# define ERR_SYSTEM_MASK                ((unsigned int)INT_MAX)
+
+/*
+ * Macros to help decode recorded OpenSSL errors
+ * As expressed above, RFLAGS and REASON overlap by one bit to allow
+ * ERR_R_FATAL to use ERR_RFLAG_FATAL as its reason code.
+ */
+# define ERR_LIB_OFFSET                 23L
+# define ERR_LIB_MASK                   0xFF
+# define ERR_RFLAGS_OFFSET              18L
+# define ERR_RFLAGS_MASK                0x1F
+# define ERR_REASON_MASK                0X7FFFFF
+
+/*
+ * Reason flags are defined pre-shifted to easily combine with the reason
+ * number.
+ */
+# define ERR_RFLAG_FATAL                (0x1 << ERR_RFLAGS_OFFSET)
+# define ERR_RFLAG_COMMON               (0x2 << ERR_RFLAGS_OFFSET)
+
+# define ERR_SYSTEM_ERROR(errcode)      (((errcode) & ERR_SYSTEM_FLAG) != 0)
+
+static ossl_unused ossl_inline int ERR_GET_LIB(unsigned long errcode)
+{
+    if (ERR_SYSTEM_ERROR(errcode))
+        return ERR_LIB_SYS;
+    return (errcode >> ERR_LIB_OFFSET) & ERR_LIB_MASK;
+}
+
+static ossl_unused ossl_inline int ERR_GET_RFLAGS(unsigned long errcode)
+{
+    if (ERR_SYSTEM_ERROR(errcode))
+        return 0;
+    return errcode & (ERR_RFLAGS_MASK << ERR_RFLAGS_OFFSET);
+}
+
+static ossl_unused ossl_inline int ERR_GET_REASON(unsigned long errcode)
+{
+    if (ERR_SYSTEM_ERROR(errcode))
+        return errcode & ERR_SYSTEM_MASK;
+    return errcode & ERR_REASON_MASK;
+}
+
+static ossl_unused ossl_inline int ERR_FATAL_ERROR(unsigned long errcode)
+{
+    return (ERR_GET_RFLAGS(errcode) & ERR_RFLAG_FATAL) != 0;
+}
+
+static ossl_unused ossl_inline int ERR_COMMON_ERROR(unsigned long errcode)
+{
+    return (ERR_GET_RFLAGS(errcode) & ERR_RFLAG_COMMON) != 0;
+}
+
+/*
+ * ERR_PACK is a helper macro to properly pack OpenSSL error codes and may
+ * only be used for that purpose.  System errors are packed internally.
+ * ERR_PACK takes reason flags and reason code combined in |reason|.
+ * ERR_PACK ignores |func|, that parameter is just legacy from pre-3.0 OpenSSL.
+ */
+# define ERR_PACK(lib,func,reason)                                      \
+    ( (((unsigned long)(lib)    & ERR_LIB_MASK   ) << ERR_LIB_OFFSET) | \
+      (((unsigned long)(reason) & ERR_REASON_MASK)) )
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SYS_F_FOPEN             0
+#  define SYS_F_CONNECT           0
+#  define SYS_F_GETSERVBYNAME     0
+#  define SYS_F_SOCKET            0
+#  define SYS_F_IOCTLSOCKET       0
+#  define SYS_F_BIND              0
+#  define SYS_F_LISTEN            0
+#  define SYS_F_ACCEPT            0
+#  define SYS_F_WSASTARTUP        0
+#  define SYS_F_OPENDIR           0
+#  define SYS_F_FREAD             0
+#  define SYS_F_GETADDRINFO       0
+#  define SYS_F_GETNAMEINFO       0
+#  define SYS_F_SETSOCKOPT        0
+#  define SYS_F_GETSOCKOPT        0
+#  define SYS_F_GETSOCKNAME       0
+#  define SYS_F_GETHOSTBYNAME     0
+#  define SYS_F_FFLUSH            0
+#  define SYS_F_OPEN              0
+#  define SYS_F_CLOSE             0
+#  define SYS_F_IOCTL             0
+#  define SYS_F_STAT              0
+#  define SYS_F_FCNTL             0
+#  define SYS_F_FSTAT             0
+#  define SYS_F_SENDFILE          0
+# endif
+
+/*
+ * All ERR_R_ codes must be combined with ERR_RFLAG_COMMON.
+ */
+
+/* "we came from here" global reason codes, range 1..255 */
+# define ERR_R_SYS_LIB          (ERR_LIB_SYS/* 2 */ | ERR_RFLAG_COMMON)
+# define ERR_R_BN_LIB           (ERR_LIB_BN/* 3 */ | ERR_RFLAG_COMMON)
+# define ERR_R_RSA_LIB          (ERR_LIB_RSA/* 4 */ | ERR_RFLAG_COMMON)
+# define ERR_R_DH_LIB           (ERR_LIB_DH/* 5 */ | ERR_RFLAG_COMMON)
+# define ERR_R_EVP_LIB          (ERR_LIB_EVP/* 6 */ | ERR_RFLAG_COMMON)
+# define ERR_R_BUF_LIB          (ERR_LIB_BUF/* 7 */ | ERR_RFLAG_COMMON)
+# define ERR_R_OBJ_LIB          (ERR_LIB_OBJ/* 8 */ | ERR_RFLAG_COMMON)
+# define ERR_R_PEM_LIB          (ERR_LIB_PEM/* 9 */ | ERR_RFLAG_COMMON)
+# define ERR_R_DSA_LIB          (ERR_LIB_DSA/* 10 */ | ERR_RFLAG_COMMON)
+# define ERR_R_X509_LIB         (ERR_LIB_X509/* 11 */ | ERR_RFLAG_COMMON)
+# define ERR_R_ASN1_LIB         (ERR_LIB_ASN1/* 13 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CRYPTO_LIB       (ERR_LIB_CRYPTO/* 15 */ | ERR_RFLAG_COMMON)
+# define ERR_R_EC_LIB           (ERR_LIB_EC/* 16 */ | ERR_RFLAG_COMMON)
+# define ERR_R_BIO_LIB          (ERR_LIB_BIO/* 32 */ | ERR_RFLAG_COMMON)
+# define ERR_R_PKCS7_LIB        (ERR_LIB_PKCS7/* 33 */ | ERR_RFLAG_COMMON)
+# define ERR_R_X509V3_LIB       (ERR_LIB_X509V3/* 34 */ | ERR_RFLAG_COMMON)
+# define ERR_R_ENGINE_LIB       (ERR_LIB_ENGINE/* 38 */ | ERR_RFLAG_COMMON)
+# define ERR_R_UI_LIB           (ERR_LIB_UI/* 40 */ | ERR_RFLAG_COMMON)
+# define ERR_R_ECDSA_LIB        (ERR_LIB_ECDSA/* 42 */ | ERR_RFLAG_COMMON)
+# define ERR_R_OSSL_STORE_LIB   (ERR_LIB_OSSL_STORE/* 44 */ | ERR_RFLAG_COMMON)
+# define ERR_R_OSSL_DECODER_LIB (ERR_LIB_OSSL_DECODER/* 60 */ | ERR_RFLAG_COMMON)
+
+/* Other common error codes, range 256..2^ERR_RFLAGS_OFFSET-1 */
+# define ERR_R_FATAL                             (ERR_RFLAG_FATAL|ERR_RFLAG_COMMON)
+# define ERR_R_MALLOC_FAILURE                    (256|ERR_R_FATAL)
+# define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED       (257|ERR_R_FATAL)
+# define ERR_R_PASSED_NULL_PARAMETER             (258|ERR_R_FATAL)
+# define ERR_R_INTERNAL_ERROR                    (259|ERR_R_FATAL)
+# define ERR_R_DISABLED                          (260|ERR_R_FATAL)
+# define ERR_R_INIT_FAIL                         (261|ERR_R_FATAL)
+# define ERR_R_PASSED_INVALID_ARGUMENT           (262|ERR_RFLAG_COMMON)
+# define ERR_R_OPERATION_FAIL                    (263|ERR_R_FATAL)
+# define ERR_R_INVALID_PROVIDER_FUNCTIONS        (264|ERR_R_FATAL)
+# define ERR_R_INTERRUPTED_OR_CANCELLED          (265|ERR_RFLAG_COMMON)
+# define ERR_R_NESTED_ASN1_ERROR                 (266|ERR_RFLAG_COMMON)
+# define ERR_R_MISSING_ASN1_EOS                  (267|ERR_RFLAG_COMMON)
+# define ERR_R_UNSUPPORTED                       (268|ERR_RFLAG_COMMON)
+# define ERR_R_FETCH_FAILED                      (269|ERR_RFLAG_COMMON)
+# define ERR_R_INVALID_PROPERTY_DEFINITION       (270|ERR_RFLAG_COMMON)
+# define ERR_R_UNABLE_TO_GET_READ_LOCK           (271|ERR_R_FATAL)
+# define ERR_R_UNABLE_TO_GET_WRITE_LOCK          (272|ERR_R_FATAL)
+
+typedef struct ERR_string_data_st {
+    unsigned long error;
+    const char *string;
+} ERR_STRING_DATA;
+
+DEFINE_LHASH_OF_INTERNAL(ERR_STRING_DATA);
+#define lh_ERR_STRING_DATA_new(hfn, cmp) ((LHASH_OF(ERR_STRING_DATA) *)OPENSSL_LH_new(ossl_check_ERR_STRING_DATA_lh_hashfunc_type(hfn), ossl_check_ERR_STRING_DATA_lh_compfunc_type(cmp)))
+#define lh_ERR_STRING_DATA_free(lh) OPENSSL_LH_free(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_flush(lh) OPENSSL_LH_flush(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_insert(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_insert(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_delete(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_delete(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_const_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_retrieve(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_retrieve(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_const_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_error(lh) OPENSSL_LH_error(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_num_items(lh) OPENSSL_LH_num_items(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_ERR_STRING_DATA_lh_type(lh), out)
+#define lh_ERR_STRING_DATA_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_ERR_STRING_DATA_lh_type(lh), out)
+#define lh_ERR_STRING_DATA_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_ERR_STRING_DATA_lh_type(lh), out)
+#define lh_ERR_STRING_DATA_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_ERR_STRING_DATA_lh_type(lh))
+#define lh_ERR_STRING_DATA_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_ERR_STRING_DATA_lh_type(lh), dl)
+#define lh_ERR_STRING_DATA_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_ERR_STRING_DATA_lh_doallfunc_type(dfn))
+
+
+/* 12 lines and some on an 80 column terminal */
+#define ERR_MAX_DATA_SIZE       1024
+
+/* Building blocks */
+void ERR_new(void);
+void ERR_set_debug(const char *file, int line, const char *func);
+void ERR_set_error(int lib, int reason, const char *fmt, ...);
+void ERR_vset_error(int lib, int reason, const char *fmt, va_list args);
+
+/* Main error raising functions */
+# define ERR_raise(lib, reason) ERR_raise_data((lib),(reason),NULL)
+# define ERR_raise_data                                         \
+    (ERR_new(),                                                 \
+     ERR_set_debug(OPENSSL_FILE,OPENSSL_LINE,OPENSSL_FUNC),     \
+     ERR_set_error)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/* Backward compatibility */
+#  define ERR_put_error(lib, func, reason, file, line)          \
+    (ERR_new(),                                                 \
+     ERR_set_debug((file), (line), OPENSSL_FUNC),               \
+     ERR_set_error((lib), (reason), NULL))
+# endif
+
+void ERR_set_error_data(char *data, int flags);
+
+unsigned long ERR_get_error(void);
+unsigned long ERR_get_error_all(const char **file, int *line,
+                                const char **func,
+                                const char **data, int *flags);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+unsigned long ERR_get_error_line(const char **file, int *line);
+OSSL_DEPRECATEDIN_3_0
+unsigned long ERR_get_error_line_data(const char **file, int *line,
+                                      const char **data, int *flags);
+#endif
+unsigned long ERR_peek_error(void);
+unsigned long ERR_peek_error_line(const char **file, int *line);
+unsigned long ERR_peek_error_func(const char **func);
+unsigned long ERR_peek_error_data(const char **data, int *flags);
+unsigned long ERR_peek_error_all(const char **file, int *line,
+                                 const char **func,
+                                 const char **data, int *flags);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+unsigned long ERR_peek_error_line_data(const char **file, int *line,
+                                       const char **data, int *flags);
+# endif
+unsigned long ERR_peek_last_error(void);
+unsigned long ERR_peek_last_error_line(const char **file, int *line);
+unsigned long ERR_peek_last_error_func(const char **func);
+unsigned long ERR_peek_last_error_data(const char **data, int *flags);
+unsigned long ERR_peek_last_error_all(const char **file, int *line,
+                                      const char **func,
+                                      const char **data, int *flags);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+unsigned long ERR_peek_last_error_line_data(const char **file, int *line,
+                                            const char **data, int *flags);
+# endif
+
+void ERR_clear_error(void);
+
+char *ERR_error_string(unsigned long e, char *buf);
+void ERR_error_string_n(unsigned long e, char *buf, size_t len);
+const char *ERR_lib_error_string(unsigned long e);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *ERR_func_error_string(unsigned long e);
+# endif
+const char *ERR_reason_error_string(unsigned long e);
+
+void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u),
+                         void *u);
+# ifndef OPENSSL_NO_STDIO
+void ERR_print_errors_fp(FILE *fp);
+# endif
+void ERR_print_errors(BIO *bp);
+
+void ERR_add_error_data(int num, ...);
+void ERR_add_error_vdata(int num, va_list args);
+void ERR_add_error_txt(const char *sepr, const char *txt);
+void ERR_add_error_mem_bio(const char *sep, BIO *bio);
+
+int ERR_load_strings(int lib, ERR_STRING_DATA *str);
+int ERR_load_strings_const(const ERR_STRING_DATA *str);
+int ERR_unload_strings(int lib, ERR_STRING_DATA *str);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define ERR_load_crypto_strings() \
+    OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
+# define ERR_free_strings() while(0) continue
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void ERR_remove_thread_state(void *);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_1_0_0
+OSSL_DEPRECATEDIN_1_0_0 void ERR_remove_state(unsigned long pid);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 ERR_STATE *ERR_get_state(void);
+#endif
+
+int ERR_get_next_error_library(void);
+
+int ERR_set_mark(void);
+int ERR_pop_to_mark(void);
+int ERR_clear_last_mark(void);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ess.h b/CAPI/cpp/grpc/include/openssl/ess.h
new file mode 100644
index 0000000..dad596a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ess.h
@@ -0,0 +1,128 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ess.h.in
+ *
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_ESS_H
+# define OPENSSL_ESS_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+
+# include <openssl/safestack.h>
+# include <openssl/x509.h>
+# include <openssl/esserr.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+
+typedef struct ESS_issuer_serial ESS_ISSUER_SERIAL;
+typedef struct ESS_cert_id ESS_CERT_ID;
+typedef struct ESS_signing_cert ESS_SIGNING_CERT;
+
+SKM_DEFINE_STACK_OF_INTERNAL(ESS_CERT_ID, ESS_CERT_ID, ESS_CERT_ID)
+#define sk_ESS_CERT_ID_num(sk) OPENSSL_sk_num(ossl_check_const_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_value(sk, idx) ((ESS_CERT_ID *)OPENSSL_sk_value(ossl_check_const_ESS_CERT_ID_sk_type(sk), (idx)))
+#define sk_ESS_CERT_ID_new(cmp) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new(ossl_check_ESS_CERT_ID_compfunc_type(cmp)))
+#define sk_ESS_CERT_ID_new_null() ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new_null())
+#define sk_ESS_CERT_ID_new_reserve(cmp, n) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new_reserve(ossl_check_ESS_CERT_ID_compfunc_type(cmp), (n)))
+#define sk_ESS_CERT_ID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ESS_CERT_ID_sk_type(sk), (n))
+#define sk_ESS_CERT_ID_free(sk) OPENSSL_sk_free(ossl_check_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_zero(sk) OPENSSL_sk_zero(ossl_check_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_delete(sk, i) ((ESS_CERT_ID *)OPENSSL_sk_delete(ossl_check_ESS_CERT_ID_sk_type(sk), (i)))
+#define sk_ESS_CERT_ID_delete_ptr(sk, ptr) ((ESS_CERT_ID *)OPENSSL_sk_delete_ptr(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr)))
+#define sk_ESS_CERT_ID_push(sk, ptr) OPENSSL_sk_push(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
+#define sk_ESS_CERT_ID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
+#define sk_ESS_CERT_ID_pop(sk) ((ESS_CERT_ID *)OPENSSL_sk_pop(ossl_check_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_shift(sk) ((ESS_CERT_ID *)OPENSSL_sk_shift(ossl_check_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ESS_CERT_ID_sk_type(sk),ossl_check_ESS_CERT_ID_freefunc_type(freefunc))
+#define sk_ESS_CERT_ID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr), (idx))
+#define sk_ESS_CERT_ID_set(sk, idx, ptr) ((ESS_CERT_ID *)OPENSSL_sk_set(ossl_check_ESS_CERT_ID_sk_type(sk), (idx), ossl_check_ESS_CERT_ID_type(ptr)))
+#define sk_ESS_CERT_ID_find(sk, ptr) OPENSSL_sk_find(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
+#define sk_ESS_CERT_ID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
+#define sk_ESS_CERT_ID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr), pnum)
+#define sk_ESS_CERT_ID_sort(sk) OPENSSL_sk_sort(ossl_check_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ESS_CERT_ID_sk_type(sk))
+#define sk_ESS_CERT_ID_dup(sk) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_dup(ossl_check_const_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_deep_copy(ossl_check_const_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_copyfunc_type(copyfunc), ossl_check_ESS_CERT_ID_freefunc_type(freefunc)))
+#define sk_ESS_CERT_ID_set_cmp_func(sk, cmp) ((sk_ESS_CERT_ID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_compfunc_type(cmp)))
+
+
+
+typedef struct ESS_signing_cert_v2_st ESS_SIGNING_CERT_V2;
+typedef struct ESS_cert_id_v2_st ESS_CERT_ID_V2;
+
+SKM_DEFINE_STACK_OF_INTERNAL(ESS_CERT_ID_V2, ESS_CERT_ID_V2, ESS_CERT_ID_V2)
+#define sk_ESS_CERT_ID_V2_num(sk) OPENSSL_sk_num(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_value(sk, idx) ((ESS_CERT_ID_V2 *)OPENSSL_sk_value(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk), (idx)))
+#define sk_ESS_CERT_ID_V2_new(cmp) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new(ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp)))
+#define sk_ESS_CERT_ID_V2_new_null() ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new_null())
+#define sk_ESS_CERT_ID_V2_new_reserve(cmp, n) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new_reserve(ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp), (n)))
+#define sk_ESS_CERT_ID_V2_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (n))
+#define sk_ESS_CERT_ID_V2_free(sk) OPENSSL_sk_free(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_zero(sk) OPENSSL_sk_zero(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_delete(sk, i) ((ESS_CERT_ID_V2 *)OPENSSL_sk_delete(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (i)))
+#define sk_ESS_CERT_ID_V2_delete_ptr(sk, ptr) ((ESS_CERT_ID_V2 *)OPENSSL_sk_delete_ptr(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr)))
+#define sk_ESS_CERT_ID_V2_push(sk, ptr) OPENSSL_sk_push(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
+#define sk_ESS_CERT_ID_V2_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
+#define sk_ESS_CERT_ID_V2_pop(sk) ((ESS_CERT_ID_V2 *)OPENSSL_sk_pop(ossl_check_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_shift(sk) ((ESS_CERT_ID_V2 *)OPENSSL_sk_shift(ossl_check_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ESS_CERT_ID_V2_sk_type(sk),ossl_check_ESS_CERT_ID_V2_freefunc_type(freefunc))
+#define sk_ESS_CERT_ID_V2_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr), (idx))
+#define sk_ESS_CERT_ID_V2_set(sk, idx, ptr) ((ESS_CERT_ID_V2 *)OPENSSL_sk_set(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (idx), ossl_check_ESS_CERT_ID_V2_type(ptr)))
+#define sk_ESS_CERT_ID_V2_find(sk, ptr) OPENSSL_sk_find(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
+#define sk_ESS_CERT_ID_V2_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
+#define sk_ESS_CERT_ID_V2_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr), pnum)
+#define sk_ESS_CERT_ID_V2_sort(sk) OPENSSL_sk_sort(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk))
+#define sk_ESS_CERT_ID_V2_dup(sk) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_dup(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_deep_copy(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_copyfunc_type(copyfunc), ossl_check_ESS_CERT_ID_V2_freefunc_type(freefunc)))
+#define sk_ESS_CERT_ID_V2_set_cmp_func(sk, cmp) ((sk_ESS_CERT_ID_V2_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp)))
+
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_ISSUER_SERIAL)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_ISSUER_SERIAL, ESS_ISSUER_SERIAL)
+DECLARE_ASN1_DUP_FUNCTION(ESS_ISSUER_SERIAL)
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_CERT_ID)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_CERT_ID, ESS_CERT_ID)
+DECLARE_ASN1_DUP_FUNCTION(ESS_CERT_ID)
+
+DECLARE_ASN1_FUNCTIONS(ESS_SIGNING_CERT)
+DECLARE_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT)
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_CERT_ID_V2)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_CERT_ID_V2, ESS_CERT_ID_V2)
+DECLARE_ASN1_DUP_FUNCTION(ESS_CERT_ID_V2)
+
+DECLARE_ASN1_FUNCTIONS(ESS_SIGNING_CERT_V2)
+DECLARE_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT_V2)
+
+ESS_SIGNING_CERT *OSSL_ESS_signing_cert_new_init(const X509 *signcert,
+                                                 const STACK_OF(X509) *certs,
+                                                 int set_issuer_serial);
+ESS_SIGNING_CERT_V2 *OSSL_ESS_signing_cert_v2_new_init(const EVP_MD *hash_alg,
+                                                       const X509 *signcert,
+                                                       const
+                                                       STACK_OF(X509) *certs,
+                                                       int set_issuer_serial);
+int OSSL_ESS_check_signing_certs(const ESS_SIGNING_CERT *ss,
+                                 const ESS_SIGNING_CERT_V2 *ssv2,
+                                 const STACK_OF(X509) *chain,
+                                 int require_signing_cert);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/esserr.h b/CAPI/cpp/grpc/include/openssl/esserr.h
new file mode 100644
index 0000000..165ce7c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/esserr.h
@@ -0,0 +1,32 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_ESSERR_H
+# define OPENSSL_ESSERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+/*
+ * ESS reason codes.
+ */
+# define ESS_R_EMPTY_ESS_CERT_ID_LIST                     107
+# define ESS_R_ESS_CERT_DIGEST_ERROR                      103
+# define ESS_R_ESS_CERT_ID_NOT_FOUND                      104
+# define ESS_R_ESS_CERT_ID_WRONG_ORDER                    105
+# define ESS_R_ESS_DIGEST_ALG_UNKNOWN                     106
+# define ESS_R_ESS_SIGNING_CERTIFICATE_ERROR              102
+# define ESS_R_ESS_SIGNING_CERT_ADD_ERROR                 100
+# define ESS_R_ESS_SIGNING_CERT_V2_ADD_ERROR              101
+# define ESS_R_MISSING_SIGNING_CERTIFICATE_ATTRIBUTE      108
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/evp.h b/CAPI/cpp/grpc/include/openssl/evp.h
new file mode 100644
index 0000000..49e8e1d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/evp.h
@@ -0,0 +1,2170 @@
+/*
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_EVP_H
+# define OPENSSL_EVP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_ENVELOPE_H
+# endif
+
+# include <stdarg.h>
+
+# ifndef OPENSSL_NO_STDIO
+#  include <stdio.h>
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/types.h>
+# include <openssl/core.h>
+# include <openssl/core_dispatch.h>
+# include <openssl/symhacks.h>
+# include <openssl/bio.h>
+# include <openssl/evperr.h>
+# include <openssl/params.h>
+
+# define EVP_MAX_MD_SIZE                 64/* longest known is SHA512 */
+# define EVP_MAX_KEY_LENGTH              64
+# define EVP_MAX_IV_LENGTH               16
+# define EVP_MAX_BLOCK_LENGTH            32
+
+# define PKCS5_SALT_LEN                  8
+/* Default PKCS#5 iteration count */
+# define PKCS5_DEFAULT_ITER              2048
+
+# include <openssl/objects.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define EVP_PK_RSA      0x0001
+#  define EVP_PK_DSA      0x0002
+#  define EVP_PK_DH       0x0004
+#  define EVP_PK_EC       0x0008
+#  define EVP_PKT_SIGN    0x0010
+#  define EVP_PKT_ENC     0x0020
+#  define EVP_PKT_EXCH    0x0040
+#  define EVP_PKS_RSA     0x0100
+#  define EVP_PKS_DSA     0x0200
+#  define EVP_PKS_EC      0x0400
+# endif
+
+# define EVP_PKEY_NONE   NID_undef
+# define EVP_PKEY_RSA    NID_rsaEncryption
+# define EVP_PKEY_RSA2   NID_rsa
+# define EVP_PKEY_RSA_PSS NID_rsassaPss
+# define EVP_PKEY_DSA    NID_dsa
+# define EVP_PKEY_DSA1   NID_dsa_2
+# define EVP_PKEY_DSA2   NID_dsaWithSHA
+# define EVP_PKEY_DSA3   NID_dsaWithSHA1
+# define EVP_PKEY_DSA4   NID_dsaWithSHA1_2
+# define EVP_PKEY_DH     NID_dhKeyAgreement
+# define EVP_PKEY_DHX    NID_dhpublicnumber
+# define EVP_PKEY_EC     NID_X9_62_id_ecPublicKey
+# define EVP_PKEY_SM2    NID_sm2
+# define EVP_PKEY_HMAC   NID_hmac
+# define EVP_PKEY_CMAC   NID_cmac
+# define EVP_PKEY_SCRYPT NID_id_scrypt
+# define EVP_PKEY_TLS1_PRF NID_tls1_prf
+# define EVP_PKEY_HKDF   NID_hkdf
+# define EVP_PKEY_POLY1305 NID_poly1305
+# define EVP_PKEY_SIPHASH NID_siphash
+# define EVP_PKEY_X25519 NID_X25519
+# define EVP_PKEY_ED25519 NID_ED25519
+# define EVP_PKEY_X448 NID_X448
+# define EVP_PKEY_ED448 NID_ED448
+/* Special indicator that the object is uniquely provider side */
+# define EVP_PKEY_KEYMGMT -1
+
+/* Easy to use macros for EVP_PKEY related selections */
+# define EVP_PKEY_KEY_PARAMETERS                                            \
+    ( OSSL_KEYMGMT_SELECT_ALL_PARAMETERS )
+# define EVP_PKEY_PUBLIC_KEY                                                \
+    ( EVP_PKEY_KEY_PARAMETERS | OSSL_KEYMGMT_SELECT_PUBLIC_KEY )
+# define EVP_PKEY_KEYPAIR                                                   \
+    ( EVP_PKEY_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_PRIVATE_KEY )
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+int EVP_set_default_properties(OSSL_LIB_CTX *libctx, const char *propq);
+int EVP_default_properties_is_fips_enabled(OSSL_LIB_CTX *libctx);
+int EVP_default_properties_enable_fips(OSSL_LIB_CTX *libctx, int enable);
+
+# define EVP_PKEY_MO_SIGN        0x0001
+# define EVP_PKEY_MO_VERIFY      0x0002
+# define EVP_PKEY_MO_ENCRYPT     0x0004
+# define EVP_PKEY_MO_DECRYPT     0x0008
+
+# ifndef EVP_MD
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type);
+OSSL_DEPRECATEDIN_3_0 EVP_MD *EVP_MD_meth_dup(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0 void EVP_MD_meth_free(EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags);
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
+                                                     const void *data,
+                                                     size_t count));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
+                                                   unsigned char *md));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
+                                                 const EVP_MD_CTX *from));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0
+int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
+                                                 int p1, void *p2));
+OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_input_blocksize(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_result_size(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_app_datasize(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0 unsigned long EVP_MD_meth_get_flags(const EVP_MD *md);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
+                                                const void *data, size_t count);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
+                                               unsigned char *md);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
+                                              const EVP_MD_CTX *from);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
+                                              int p1, void *p2);
+#  endif
+/* digest can only handle a single block */
+#  define EVP_MD_FLAG_ONESHOT     0x0001
+
+/* digest is extensible-output function, XOF */
+#  define EVP_MD_FLAG_XOF         0x0002
+
+/* DigestAlgorithmIdentifier flags... */
+
+#  define EVP_MD_FLAG_DIGALGID_MASK               0x0018
+
+/* NULL or absent parameter accepted. Use NULL */
+
+#  define EVP_MD_FLAG_DIGALGID_NULL               0x0000
+
+/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */
+
+#  define EVP_MD_FLAG_DIGALGID_ABSENT             0x0008
+
+/* Custom handling via ctrl */
+
+#  define EVP_MD_FLAG_DIGALGID_CUSTOM             0x0018
+
+/* Note if suitable for use in FIPS mode */
+#  define EVP_MD_FLAG_FIPS        0x0400
+
+/* Digest ctrls */
+
+#  define EVP_MD_CTRL_DIGALGID                    0x1
+#  define EVP_MD_CTRL_MICALG                      0x2
+#  define EVP_MD_CTRL_XOF_LEN                     0x3
+#  define EVP_MD_CTRL_TLSTREE                     0x4
+
+/* Minimum Algorithm specific ctrl value */
+
+#  define EVP_MD_CTRL_ALG_CTRL                    0x1000
+
+# endif                         /* !EVP_MD */
+
+/* values for EVP_MD_CTX flags */
+
+# define EVP_MD_CTX_FLAG_ONESHOT         0x0001/* digest update will be
+                                                * called once only */
+# define EVP_MD_CTX_FLAG_CLEANED         0x0002/* context has already been
+                                                * cleaned */
+# define EVP_MD_CTX_FLAG_REUSE           0x0004/* Don't free up ctx->md_data
+                                                * in EVP_MD_CTX_reset */
+/*
+ * FIPS and pad options are ignored in 1.0.0, definitions are here so we
+ * don't accidentally reuse the values for other purposes.
+ */
+
+/* This flag has no effect from openssl-3.0 onwards */
+# define EVP_MD_CTX_FLAG_NON_FIPS_ALLOW  0x0008
+
+/*
+ * The following PAD options are also currently ignored in 1.0.0, digest
+ * parameters are handled through EVP_DigestSign*() and EVP_DigestVerify*()
+ * instead.
+ */
+# define EVP_MD_CTX_FLAG_PAD_MASK        0xF0/* RSA mode to use */
+# define EVP_MD_CTX_FLAG_PAD_PKCS1       0x00/* PKCS#1 v1.5 mode */
+# define EVP_MD_CTX_FLAG_PAD_X931        0x10/* X9.31 mode */
+# define EVP_MD_CTX_FLAG_PAD_PSS         0x20/* PSS mode */
+
+# define EVP_MD_CTX_FLAG_NO_INIT         0x0100/* Don't initialize md_data */
+/*
+ * Some functions such as EVP_DigestSign only finalise copies of internal
+ * contexts so additional data can be included after the finalisation call.
+ * This is inefficient if this functionality is not required: it is disabled
+ * if the following flag is set.
+ */
+# define EVP_MD_CTX_FLAG_FINALISE        0x0200
+/* NOTE: 0x0400 is reserved for internal usage */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+EVP_CIPHER *EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len);
+OSSL_DEPRECATEDIN_3_0
+EVP_CIPHER *EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher);
+OSSL_DEPRECATEDIN_3_0
+void EVP_CIPHER_meth_free(EVP_CIPHER *cipher);
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len);
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags);
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size);
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher,
+                             int (*init) (EVP_CIPHER_CTX *ctx,
+                                          const unsigned char *key,
+                                          const unsigned char *iv,
+                                          int enc));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher,
+                                  int (*do_cipher) (EVP_CIPHER_CTX *ctx,
+                                                    unsigned char *out,
+                                                    const unsigned char *in,
+                                                    size_t inl));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher,
+                                int (*cleanup) (EVP_CIPHER_CTX *));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher,
+                                        int (*set_asn1_parameters) (EVP_CIPHER_CTX *,
+                                                                    ASN1_TYPE *));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher,
+                                        int (*get_asn1_parameters) (EVP_CIPHER_CTX *,
+                                                                    ASN1_TYPE *));
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher,
+                             int (*ctrl) (EVP_CIPHER_CTX *, int type,
+                                          int arg, void *ptr));
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_init(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
+                                                      const unsigned char *key,
+                                                      const unsigned char *iv,
+                                                      int enc);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_do_cipher(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
+                                                           unsigned char *out,
+                                                           const unsigned char *in,
+                                                           size_t inl);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_cleanup(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_set_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
+                                                                 ASN1_TYPE *);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_get_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
+                                                                 ASN1_TYPE *);
+OSSL_DEPRECATEDIN_3_0 int
+(*EVP_CIPHER_meth_get_ctrl(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, int type,
+                                                      int arg, void *ptr);
+# endif
+
+/* Values for cipher flags */
+
+/* Modes for ciphers */
+
+# define         EVP_CIPH_STREAM_CIPHER          0x0
+# define         EVP_CIPH_ECB_MODE               0x1
+# define         EVP_CIPH_CBC_MODE               0x2
+# define         EVP_CIPH_CFB_MODE               0x3
+# define         EVP_CIPH_OFB_MODE               0x4
+# define         EVP_CIPH_CTR_MODE               0x5
+# define         EVP_CIPH_GCM_MODE               0x6
+# define         EVP_CIPH_CCM_MODE               0x7
+# define         EVP_CIPH_XTS_MODE               0x10001
+# define         EVP_CIPH_WRAP_MODE              0x10002
+# define         EVP_CIPH_OCB_MODE               0x10003
+# define         EVP_CIPH_SIV_MODE               0x10004
+# define         EVP_CIPH_MODE                   0xF0007
+/* Set if variable length cipher */
+# define         EVP_CIPH_VARIABLE_LENGTH        0x8
+/* Set if the iv handling should be done by the cipher itself */
+# define         EVP_CIPH_CUSTOM_IV              0x10
+/* Set if the cipher's init() function should be called if key is NULL */
+# define         EVP_CIPH_ALWAYS_CALL_INIT       0x20
+/* Call ctrl() to init cipher parameters */
+# define         EVP_CIPH_CTRL_INIT              0x40
+/* Don't use standard key length function */
+# define         EVP_CIPH_CUSTOM_KEY_LENGTH      0x80
+/* Don't use standard block padding */
+# define         EVP_CIPH_NO_PADDING             0x100
+/* cipher handles random key generation */
+# define         EVP_CIPH_RAND_KEY               0x200
+/* cipher has its own additional copying logic */
+# define         EVP_CIPH_CUSTOM_COPY            0x400
+/* Don't use standard iv length function */
+# define         EVP_CIPH_CUSTOM_IV_LENGTH       0x800
+/* Legacy and no longer relevant: Allow use default ASN1 get/set iv */
+# define         EVP_CIPH_FLAG_DEFAULT_ASN1      0
+/* Free:                                         0x1000 */
+/* Buffer length in bits not bytes: CFB1 mode only */
+# define         EVP_CIPH_FLAG_LENGTH_BITS       0x2000
+/* Deprecated FIPS flag: was 0x4000 */
+# define         EVP_CIPH_FLAG_FIPS              0
+/* Deprecated FIPS flag: was 0x8000 */
+# define         EVP_CIPH_FLAG_NON_FIPS_ALLOW    0
+
+/*
+ * Cipher handles any and all padding logic as well as finalisation.
+ */
+# define         EVP_CIPH_FLAG_CTS               0x4000
+# define         EVP_CIPH_FLAG_CUSTOM_CIPHER     0x100000
+# define         EVP_CIPH_FLAG_AEAD_CIPHER       0x200000
+# define         EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0x400000
+/* Cipher can handle pipeline operations */
+# define         EVP_CIPH_FLAG_PIPELINE          0X800000
+/* For provider implementations that handle  ASN1 get/set param themselves */
+# define         EVP_CIPH_FLAG_CUSTOM_ASN1       0x1000000
+/* For ciphers generating unprotected CMS attributes */
+# define         EVP_CIPH_FLAG_CIPHER_WITH_MAC   0x2000000
+/* For supplementary wrap cipher support */
+# define         EVP_CIPH_FLAG_GET_WRAP_CIPHER   0x4000000
+# define         EVP_CIPH_FLAG_INVERSE_CIPHER    0x8000000
+
+/*
+ * Cipher context flag to indicate we can handle wrap mode: if allowed in
+ * older applications it could overflow buffers.
+ */
+
+# define         EVP_CIPHER_CTX_FLAG_WRAP_ALLOW  0x1
+
+/* ctrl() values */
+
+# define         EVP_CTRL_INIT                   0x0
+# define         EVP_CTRL_SET_KEY_LENGTH         0x1
+# define         EVP_CTRL_GET_RC2_KEY_BITS       0x2
+# define         EVP_CTRL_SET_RC2_KEY_BITS       0x3
+# define         EVP_CTRL_GET_RC5_ROUNDS         0x4
+# define         EVP_CTRL_SET_RC5_ROUNDS         0x5
+# define         EVP_CTRL_RAND_KEY               0x6
+# define         EVP_CTRL_PBE_PRF_NID            0x7
+# define         EVP_CTRL_COPY                   0x8
+# define         EVP_CTRL_AEAD_SET_IVLEN         0x9
+# define         EVP_CTRL_AEAD_GET_TAG           0x10
+# define         EVP_CTRL_AEAD_SET_TAG           0x11
+# define         EVP_CTRL_AEAD_SET_IV_FIXED      0x12
+# define         EVP_CTRL_GCM_SET_IVLEN          EVP_CTRL_AEAD_SET_IVLEN
+# define         EVP_CTRL_GCM_GET_TAG            EVP_CTRL_AEAD_GET_TAG
+# define         EVP_CTRL_GCM_SET_TAG            EVP_CTRL_AEAD_SET_TAG
+# define         EVP_CTRL_GCM_SET_IV_FIXED       EVP_CTRL_AEAD_SET_IV_FIXED
+# define         EVP_CTRL_GCM_IV_GEN             0x13
+# define         EVP_CTRL_CCM_SET_IVLEN          EVP_CTRL_AEAD_SET_IVLEN
+# define         EVP_CTRL_CCM_GET_TAG            EVP_CTRL_AEAD_GET_TAG
+# define         EVP_CTRL_CCM_SET_TAG            EVP_CTRL_AEAD_SET_TAG
+# define         EVP_CTRL_CCM_SET_IV_FIXED       EVP_CTRL_AEAD_SET_IV_FIXED
+# define         EVP_CTRL_CCM_SET_L              0x14
+# define         EVP_CTRL_CCM_SET_MSGLEN         0x15
+/*
+ * AEAD cipher deduces payload length and returns number of bytes required to
+ * store MAC and eventual padding. Subsequent call to EVP_Cipher even
+ * appends/verifies MAC.
+ */
+# define         EVP_CTRL_AEAD_TLS1_AAD          0x16
+/* Used by composite AEAD ciphers, no-op in GCM, CCM... */
+# define         EVP_CTRL_AEAD_SET_MAC_KEY       0x17
+/* Set the GCM invocation field, decrypt only */
+# define         EVP_CTRL_GCM_SET_IV_INV         0x18
+
+# define         EVP_CTRL_TLS1_1_MULTIBLOCK_AAD  0x19
+# define         EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT      0x1a
+# define         EVP_CTRL_TLS1_1_MULTIBLOCK_DECRYPT      0x1b
+# define         EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE  0x1c
+
+# define         EVP_CTRL_SSL3_MASTER_SECRET             0x1d
+
+/* EVP_CTRL_SET_SBOX takes the char * specifying S-boxes */
+# define         EVP_CTRL_SET_SBOX                       0x1e
+/*
+ * EVP_CTRL_SBOX_USED takes a 'size_t' and 'char *', pointing at a
+ * pre-allocated buffer with specified size
+ */
+# define         EVP_CTRL_SBOX_USED                      0x1f
+/* EVP_CTRL_KEY_MESH takes 'size_t' number of bytes to mesh the key after,
+ * 0 switches meshing off
+ */
+# define         EVP_CTRL_KEY_MESH                       0x20
+/* EVP_CTRL_BLOCK_PADDING_MODE takes the padding mode */
+# define         EVP_CTRL_BLOCK_PADDING_MODE             0x21
+
+/* Set the output buffers to use for a pipelined operation */
+# define         EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS       0x22
+/* Set the input buffers to use for a pipelined operation */
+# define         EVP_CTRL_SET_PIPELINE_INPUT_BUFS        0x23
+/* Set the input buffer lengths to use for a pipelined operation */
+# define         EVP_CTRL_SET_PIPELINE_INPUT_LENS        0x24
+/* Get the IV length used by the cipher */
+# define         EVP_CTRL_GET_IVLEN                      0x25
+/* 0x26 is unused */
+/* Tell the cipher it's doing a speed test (SIV disallows multiple ops) */
+# define         EVP_CTRL_SET_SPEED                      0x27
+/* Get the unprotectedAttrs from cipher ctx */
+# define         EVP_CTRL_PROCESS_UNPROTECTED            0x28
+/* Get the supplementary wrap cipher */
+#define          EVP_CTRL_GET_WRAP_CIPHER                0x29
+/* TLSTREE key diversification */
+#define          EVP_CTRL_TLSTREE                        0x2A
+
+/* Padding modes */
+#define EVP_PADDING_PKCS7       1
+#define EVP_PADDING_ISO7816_4   2
+#define EVP_PADDING_ANSI923     3
+#define EVP_PADDING_ISO10126    4
+#define EVP_PADDING_ZERO        5
+
+/* RFC 5246 defines additional data to be 13 bytes in length */
+# define         EVP_AEAD_TLS1_AAD_LEN           13
+
+typedef struct {
+    unsigned char *out;
+    const unsigned char *inp;
+    size_t len;
+    unsigned int interleave;
+} EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM;
+
+/* GCM TLS constants */
+/* Length of fixed part of IV derived from PRF */
+# define EVP_GCM_TLS_FIXED_IV_LEN                        4
+/* Length of explicit part of IV part of TLS records */
+# define EVP_GCM_TLS_EXPLICIT_IV_LEN                     8
+/* Length of tag for TLS */
+# define EVP_GCM_TLS_TAG_LEN                             16
+
+/* CCM TLS constants */
+/* Length of fixed part of IV derived from PRF */
+# define EVP_CCM_TLS_FIXED_IV_LEN                        4
+/* Length of explicit part of IV part of TLS records */
+# define EVP_CCM_TLS_EXPLICIT_IV_LEN                     8
+/* Total length of CCM IV length for TLS */
+# define EVP_CCM_TLS_IV_LEN                              12
+/* Length of tag for TLS */
+# define EVP_CCM_TLS_TAG_LEN                             16
+/* Length of CCM8 tag for TLS */
+# define EVP_CCM8_TLS_TAG_LEN                            8
+
+/* Length of tag for TLS */
+# define EVP_CHACHAPOLY_TLS_TAG_LEN                      16
+
+typedef struct evp_cipher_info_st {
+    const EVP_CIPHER *cipher;
+    unsigned char iv[EVP_MAX_IV_LENGTH];
+} EVP_CIPHER_INFO;
+
+
+/* Password based encryption function */
+typedef int (EVP_PBE_KEYGEN) (EVP_CIPHER_CTX *ctx, const char *pass,
+                              int passlen, ASN1_TYPE *param,
+                              const EVP_CIPHER *cipher, const EVP_MD *md,
+                              int en_de);
+
+typedef int (EVP_PBE_KEYGEN_EX) (EVP_CIPHER_CTX *ctx, const char *pass,
+                                 int passlen, ASN1_TYPE *param,
+                                 const EVP_CIPHER *cipher, const EVP_MD *md,
+                                 int en_de, OSSL_LIB_CTX *libctx, const char *propq);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\
+                                                         (rsa))
+# endif
+
+# ifndef OPENSSL_NO_DSA
+#  define EVP_PKEY_assign_DSA(pkey,dsa) EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\
+                                        (dsa))
+# endif
+
+# if !defined(OPENSSL_NO_DH) && !defined(OPENSSL_NO_DEPRECATED_3_0)
+#  define EVP_PKEY_assign_DH(pkey,dh) EVP_PKEY_assign((pkey),EVP_PKEY_DH,(dh))
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_EC
+#   define EVP_PKEY_assign_EC_KEY(pkey,eckey) \
+        EVP_PKEY_assign((pkey), EVP_PKEY_EC, (eckey))
+#  endif
+# endif
+# ifndef OPENSSL_NO_SIPHASH
+#  define EVP_PKEY_assign_SIPHASH(pkey,shkey) EVP_PKEY_assign((pkey),\
+                                        EVP_PKEY_SIPHASH,(shkey))
+# endif
+
+# ifndef OPENSSL_NO_POLY1305
+#  define EVP_PKEY_assign_POLY1305(pkey,polykey) EVP_PKEY_assign((pkey),\
+                                        EVP_PKEY_POLY1305,(polykey))
+# endif
+
+/* Add some extra combinations */
+# define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a))
+# define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a))
+# define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a))
+# define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a))
+
+int EVP_MD_get_type(const EVP_MD *md);
+# define EVP_MD_type EVP_MD_get_type
+# define EVP_MD_nid EVP_MD_get_type
+const char *EVP_MD_get0_name(const EVP_MD *md);
+# define EVP_MD_name EVP_MD_get0_name
+const char *EVP_MD_get0_description(const EVP_MD *md);
+int EVP_MD_is_a(const EVP_MD *md, const char *name);
+int EVP_MD_names_do_all(const EVP_MD *md,
+                        void (*fn)(const char *name, void *data),
+                        void *data);
+const OSSL_PROVIDER *EVP_MD_get0_provider(const EVP_MD *md);
+int EVP_MD_get_pkey_type(const EVP_MD *md);
+# define EVP_MD_pkey_type EVP_MD_get_pkey_type
+int EVP_MD_get_size(const EVP_MD *md);
+# define EVP_MD_size EVP_MD_get_size
+int EVP_MD_get_block_size(const EVP_MD *md);
+# define EVP_MD_block_size EVP_MD_get_block_size
+unsigned long EVP_MD_get_flags(const EVP_MD *md);
+# define EVP_MD_flags EVP_MD_get_flags
+
+const EVP_MD *EVP_MD_CTX_get0_md(const EVP_MD_CTX *ctx);
+EVP_MD *EVP_MD_CTX_get1_md(EVP_MD_CTX *ctx);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0
+int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
+                                             const void *data, size_t count);
+OSSL_DEPRECATEDIN_3_0
+void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
+                              int (*update) (EVP_MD_CTX *ctx,
+                                             const void *data, size_t count));
+# endif
+# define EVP_MD_CTX_get0_name(e)       EVP_MD_get0_name(EVP_MD_CTX_get0_md(e))
+# define EVP_MD_CTX_get_size(e)        EVP_MD_get_size(EVP_MD_CTX_get0_md(e))
+# define EVP_MD_CTX_size               EVP_MD_CTX_get_size
+# define EVP_MD_CTX_get_block_size(e)  EVP_MD_get_block_size(EVP_MD_CTX_get0_md(e))
+# define EVP_MD_CTX_block_size EVP_MD_CTX_get_block_size
+# define EVP_MD_CTX_get_type(e)            EVP_MD_get_type(EVP_MD_CTX_get0_md(e))
+# define EVP_MD_CTX_type EVP_MD_CTX_get_type
+EVP_PKEY_CTX *EVP_MD_CTX_get_pkey_ctx(const EVP_MD_CTX *ctx);
+# define EVP_MD_CTX_pkey_ctx EVP_MD_CTX_get_pkey_ctx
+void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx);
+void *EVP_MD_CTX_get0_md_data(const EVP_MD_CTX *ctx);
+# define EVP_MD_CTX_md_data EVP_MD_CTX_get0_md_data
+
+int EVP_CIPHER_get_nid(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_nid EVP_CIPHER_get_nid
+const char *EVP_CIPHER_get0_name(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_name EVP_CIPHER_get0_name
+const char *EVP_CIPHER_get0_description(const EVP_CIPHER *cipher);
+int EVP_CIPHER_is_a(const EVP_CIPHER *cipher, const char *name);
+int EVP_CIPHER_names_do_all(const EVP_CIPHER *cipher,
+                            void (*fn)(const char *name, void *data),
+                            void *data);
+const OSSL_PROVIDER *EVP_CIPHER_get0_provider(const EVP_CIPHER *cipher);
+int EVP_CIPHER_get_block_size(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_block_size EVP_CIPHER_get_block_size
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *cipher);
+# endif
+int EVP_CIPHER_get_key_length(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_key_length EVP_CIPHER_get_key_length
+int EVP_CIPHER_get_iv_length(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_iv_length EVP_CIPHER_get_iv_length
+unsigned long EVP_CIPHER_get_flags(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_flags EVP_CIPHER_get_flags
+int EVP_CIPHER_get_mode(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_mode EVP_CIPHER_get_mode
+int EVP_CIPHER_get_type(const EVP_CIPHER *cipher);
+# define EVP_CIPHER_type EVP_CIPHER_get_type
+EVP_CIPHER *EVP_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                             const char *properties);
+int EVP_CIPHER_up_ref(EVP_CIPHER *cipher);
+void EVP_CIPHER_free(EVP_CIPHER *cipher);
+
+const EVP_CIPHER *EVP_CIPHER_CTX_get0_cipher(const EVP_CIPHER_CTX *ctx);
+EVP_CIPHER *EVP_CIPHER_CTX_get1_cipher(EVP_CIPHER_CTX *ctx);
+int EVP_CIPHER_CTX_is_encrypting(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_encrypting EVP_CIPHER_CTX_is_encrypting
+int EVP_CIPHER_CTX_get_nid(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_nid EVP_CIPHER_CTX_get_nid
+int EVP_CIPHER_CTX_get_block_size(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_block_size EVP_CIPHER_CTX_get_block_size
+int EVP_CIPHER_CTX_get_key_length(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_key_length EVP_CIPHER_CTX_get_key_length
+int EVP_CIPHER_CTX_get_iv_length(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_iv_length EVP_CIPHER_CTX_get_iv_length
+int EVP_CIPHER_CTX_get_tag_length(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_tag_length EVP_CIPHER_CTX_get_tag_length
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx);
+# endif
+int EVP_CIPHER_CTX_get_updated_iv(EVP_CIPHER_CTX *ctx, void *buf, size_t len);
+int EVP_CIPHER_CTX_get_original_iv(EVP_CIPHER_CTX *ctx, void *buf, size_t len);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx);
+# endif
+int EVP_CIPHER_CTX_get_num(const EVP_CIPHER_CTX *ctx);
+# define EVP_CIPHER_CTX_num EVP_CIPHER_CTX_get_num
+int EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num);
+int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in);
+void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
+void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data);
+void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx);
+void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data);
+# define EVP_CIPHER_CTX_get0_name(c) EVP_CIPHER_get0_name(EVP_CIPHER_CTX_get0_cipher(c))
+# define EVP_CIPHER_CTX_get_type(c)  EVP_CIPHER_get_type(EVP_CIPHER_CTX_get0_cipher(c))
+# define EVP_CIPHER_CTX_type         EVP_CIPHER_CTX_get_type
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define EVP_CIPHER_CTX_flags(c)    EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(c))
+# endif
+# define EVP_CIPHER_CTX_get_mode(c)  EVP_CIPHER_get_mode(EVP_CIPHER_CTX_get0_cipher(c))
+# define EVP_CIPHER_CTX_mode         EVP_CIPHER_CTX_get_mode
+
+# define EVP_ENCODE_LENGTH(l)    ((((l)+2)/3*4)+((l)/48+1)*2+80)
+# define EVP_DECODE_LENGTH(l)    (((l)+3)/4*3+80)
+
+# define EVP_SignInit_ex(a,b,c)          EVP_DigestInit_ex(a,b,c)
+# define EVP_SignInit(a,b)               EVP_DigestInit(a,b)
+# define EVP_SignUpdate(a,b,c)           EVP_DigestUpdate(a,b,c)
+# define EVP_VerifyInit_ex(a,b,c)        EVP_DigestInit_ex(a,b,c)
+# define EVP_VerifyInit(a,b)             EVP_DigestInit(a,b)
+# define EVP_VerifyUpdate(a,b,c)         EVP_DigestUpdate(a,b,c)
+# define EVP_OpenUpdate(a,b,c,d,e)       EVP_DecryptUpdate(a,b,c,d,e)
+# define EVP_SealUpdate(a,b,c,d,e)       EVP_EncryptUpdate(a,b,c,d,e)
+
+# ifdef CONST_STRICT
+void BIO_set_md(BIO *, const EVP_MD *md);
+# else
+#  define BIO_set_md(b,md)          BIO_ctrl(b,BIO_C_SET_MD,0,(void *)(md))
+# endif
+# define BIO_get_md(b,mdp)          BIO_ctrl(b,BIO_C_GET_MD,0,(mdp))
+# define BIO_get_md_ctx(b,mdcp)     BIO_ctrl(b,BIO_C_GET_MD_CTX,0,(mdcp))
+# define BIO_set_md_ctx(b,mdcp)     BIO_ctrl(b,BIO_C_SET_MD_CTX,0,(mdcp))
+# define BIO_get_cipher_status(b)   BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL)
+# define BIO_get_cipher_ctx(b,c_pp) BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0,(c_pp))
+
+/*__owur*/ int EVP_Cipher(EVP_CIPHER_CTX *c,
+                          unsigned char *out,
+                          const unsigned char *in, unsigned int inl);
+
+# define EVP_add_cipher_alias(n,alias) \
+        OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n))
+# define EVP_add_digest_alias(n,alias) \
+        OBJ_NAME_add((alias),OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n))
+# define EVP_delete_cipher_alias(alias) \
+        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS);
+# define EVP_delete_digest_alias(alias) \
+        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS);
+
+int EVP_MD_get_params(const EVP_MD *digest, OSSL_PARAM params[]);
+int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[]);
+const OSSL_PARAM *EVP_MD_gettable_params(const EVP_MD *digest);
+const OSSL_PARAM *EVP_MD_settable_ctx_params(const EVP_MD *md);
+const OSSL_PARAM *EVP_MD_gettable_ctx_params(const EVP_MD *md);
+const OSSL_PARAM *EVP_MD_CTX_settable_params(EVP_MD_CTX *ctx);
+const OSSL_PARAM *EVP_MD_CTX_gettable_params(EVP_MD_CTX *ctx);
+int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
+EVP_MD_CTX *EVP_MD_CTX_new(void);
+int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
+void EVP_MD_CTX_free(EVP_MD_CTX *ctx);
+# define EVP_MD_CTX_create()     EVP_MD_CTX_new()
+# define EVP_MD_CTX_init(ctx)    EVP_MD_CTX_reset((ctx))
+# define EVP_MD_CTX_destroy(ctx) EVP_MD_CTX_free((ctx))
+__owur int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in);
+void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
+void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);
+int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags);
+__owur int EVP_DigestInit_ex2(EVP_MD_CTX *ctx, const EVP_MD *type,
+                              const OSSL_PARAM params[]);
+__owur int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type,
+                                 ENGINE *impl);
+__owur int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d,
+                                size_t cnt);
+__owur int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
+                                  unsigned int *s);
+__owur int EVP_Digest(const void *data, size_t count,
+                          unsigned char *md, unsigned int *size,
+                          const EVP_MD *type, ENGINE *impl);
+__owur int EVP_Q_digest(OSSL_LIB_CTX *libctx, const char *name,
+                        const char *propq, const void *data, size_t datalen,
+                        unsigned char *md, size_t *mdlen);
+
+__owur int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in);
+__owur int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
+__owur int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md,
+                           unsigned int *s);
+__owur int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md,
+                              size_t len);
+
+__owur EVP_MD *EVP_MD_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                            const char *properties);
+
+int EVP_MD_up_ref(EVP_MD *md);
+void EVP_MD_free(EVP_MD *md);
+
+int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify);
+int EVP_read_pw_string_min(char *buf, int minlen, int maxlen,
+                           const char *prompt, int verify);
+void EVP_set_pw_prompt(const char *prompt);
+char *EVP_get_pw_prompt(void);
+
+__owur int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
+                          const unsigned char *salt,
+                          const unsigned char *data, int datal, int count,
+                          unsigned char *key, unsigned char *iv);
+
+void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags);
+void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags);
+int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags);
+
+__owur int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                           const unsigned char *key, const unsigned char *iv);
+/*__owur*/ int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,
+                                  const EVP_CIPHER *cipher, ENGINE *impl,
+                                  const unsigned char *key,
+                                  const unsigned char *iv);
+__owur int EVP_EncryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                               const unsigned char *key,
+                               const unsigned char *iv,
+                               const OSSL_PARAM params[]);
+/*__owur*/ int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                 int *outl, const unsigned char *in, int inl);
+/*__owur*/ int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                   int *outl);
+/*__owur*/ int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                int *outl);
+
+__owur int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                           const unsigned char *key, const unsigned char *iv);
+/*__owur*/ int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,
+                                  const EVP_CIPHER *cipher, ENGINE *impl,
+                                  const unsigned char *key,
+                                  const unsigned char *iv);
+__owur int EVP_DecryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                               const unsigned char *key,
+                               const unsigned char *iv,
+                               const OSSL_PARAM params[]);
+/*__owur*/ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                 int *outl, const unsigned char *in, int inl);
+__owur int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
+                            int *outl);
+/*__owur*/ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
+                                   int *outl);
+
+__owur int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                          const unsigned char *key, const unsigned char *iv,
+                          int enc);
+/*__owur*/ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx,
+                                 const EVP_CIPHER *cipher, ENGINE *impl,
+                                 const unsigned char *key,
+                                 const unsigned char *iv, int enc);
+__owur int EVP_CipherInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                              const unsigned char *key, const unsigned char *iv,
+                              int enc, const OSSL_PARAM params[]);
+__owur int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                            int *outl, const unsigned char *in, int inl);
+__owur int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
+                           int *outl);
+__owur int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
+                              int *outl);
+
+__owur int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
+                         EVP_PKEY *pkey);
+__owur int EVP_SignFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
+                            EVP_PKEY *pkey, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+
+__owur int EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret,
+                          size_t *siglen, const unsigned char *tbs,
+                          size_t tbslen);
+
+__owur int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
+                           unsigned int siglen, EVP_PKEY *pkey);
+__owur int EVP_VerifyFinal_ex(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
+                              unsigned int siglen, EVP_PKEY *pkey,
+                              OSSL_LIB_CTX *libctx, const char *propq);
+
+__owur int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret,
+                            size_t siglen, const unsigned char *tbs,
+                            size_t tbslen);
+
+int EVP_DigestSignInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                          const char *mdname, OSSL_LIB_CTX *libctx,
+                          const char *props, EVP_PKEY *pkey,
+                          const OSSL_PARAM params[]);
+/*__owur*/ int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                                  const EVP_MD *type, ENGINE *e,
+                                  EVP_PKEY *pkey);
+int EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t dsize);
+__owur int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
+                               size_t *siglen);
+
+int EVP_DigestVerifyInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                            const char *mdname, OSSL_LIB_CTX *libctx,
+                            const char *props, EVP_PKEY *pkey,
+                            const OSSL_PARAM params[]);
+__owur int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
+                                const EVP_MD *type, ENGINE *e,
+                                EVP_PKEY *pkey);
+int EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t dsize);
+__owur int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
+                                 size_t siglen);
+
+__owur int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
+                        const unsigned char *ek, int ekl,
+                        const unsigned char *iv, EVP_PKEY *priv);
+__owur int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
+
+__owur int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
+                        unsigned char **ek, int *ekl, unsigned char *iv,
+                        EVP_PKEY **pubk, int npubk);
+__owur int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
+
+EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void);
+void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx);
+int EVP_ENCODE_CTX_copy(EVP_ENCODE_CTX *dctx, const EVP_ENCODE_CTX *sctx);
+int EVP_ENCODE_CTX_num(EVP_ENCODE_CTX *ctx);
+void EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
+int EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
+                     const unsigned char *in, int inl);
+void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl);
+int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);
+
+void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
+int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
+                     const unsigned char *in, int inl);
+int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned
+                    char *out, int *outl);
+int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define EVP_CIPHER_CTX_init(c)      EVP_CIPHER_CTX_reset(c)
+#  define EVP_CIPHER_CTX_cleanup(c)   EVP_CIPHER_CTX_reset(c)
+# endif
+EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
+int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *c);
+void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *c);
+int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
+int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad);
+int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
+int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);
+int EVP_CIPHER_get_params(EVP_CIPHER *cipher, OSSL_PARAM params[]);
+int EVP_CIPHER_CTX_set_params(EVP_CIPHER_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_CIPHER_CTX_get_params(EVP_CIPHER_CTX *ctx, OSSL_PARAM params[]);
+const OSSL_PARAM *EVP_CIPHER_gettable_params(const EVP_CIPHER *cipher);
+const OSSL_PARAM *EVP_CIPHER_settable_ctx_params(const EVP_CIPHER *cipher);
+const OSSL_PARAM *EVP_CIPHER_gettable_ctx_params(const EVP_CIPHER *cipher);
+const OSSL_PARAM *EVP_CIPHER_CTX_settable_params(EVP_CIPHER_CTX *ctx);
+const OSSL_PARAM *EVP_CIPHER_CTX_gettable_params(EVP_CIPHER_CTX *ctx);
+
+const BIO_METHOD *BIO_f_md(void);
+const BIO_METHOD *BIO_f_base64(void);
+const BIO_METHOD *BIO_f_cipher(void);
+const BIO_METHOD *BIO_f_reliable(void);
+__owur int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
+                          const unsigned char *i, int enc);
+
+const EVP_MD *EVP_md_null(void);
+# ifndef OPENSSL_NO_MD2
+const EVP_MD *EVP_md2(void);
+# endif
+# ifndef OPENSSL_NO_MD4
+const EVP_MD *EVP_md4(void);
+# endif
+# ifndef OPENSSL_NO_MD5
+const EVP_MD *EVP_md5(void);
+const EVP_MD *EVP_md5_sha1(void);
+# endif
+# ifndef OPENSSL_NO_BLAKE2
+const EVP_MD *EVP_blake2b512(void);
+const EVP_MD *EVP_blake2s256(void);
+# endif
+const EVP_MD *EVP_sha1(void);
+const EVP_MD *EVP_sha224(void);
+const EVP_MD *EVP_sha256(void);
+const EVP_MD *EVP_sha384(void);
+const EVP_MD *EVP_sha512(void);
+const EVP_MD *EVP_sha512_224(void);
+const EVP_MD *EVP_sha512_256(void);
+const EVP_MD *EVP_sha3_224(void);
+const EVP_MD *EVP_sha3_256(void);
+const EVP_MD *EVP_sha3_384(void);
+const EVP_MD *EVP_sha3_512(void);
+const EVP_MD *EVP_shake128(void);
+const EVP_MD *EVP_shake256(void);
+
+# ifndef OPENSSL_NO_MDC2
+const EVP_MD *EVP_mdc2(void);
+# endif
+# ifndef OPENSSL_NO_RMD160
+const EVP_MD *EVP_ripemd160(void);
+# endif
+# ifndef OPENSSL_NO_WHIRLPOOL
+const EVP_MD *EVP_whirlpool(void);
+# endif
+# ifndef OPENSSL_NO_SM3
+const EVP_MD *EVP_sm3(void);
+# endif
+const EVP_CIPHER *EVP_enc_null(void); /* does nothing :-) */
+# ifndef OPENSSL_NO_DES
+const EVP_CIPHER *EVP_des_ecb(void);
+const EVP_CIPHER *EVP_des_ede(void);
+const EVP_CIPHER *EVP_des_ede3(void);
+const EVP_CIPHER *EVP_des_ede_ecb(void);
+const EVP_CIPHER *EVP_des_ede3_ecb(void);
+const EVP_CIPHER *EVP_des_cfb64(void);
+#  define EVP_des_cfb EVP_des_cfb64
+const EVP_CIPHER *EVP_des_cfb1(void);
+const EVP_CIPHER *EVP_des_cfb8(void);
+const EVP_CIPHER *EVP_des_ede_cfb64(void);
+#  define EVP_des_ede_cfb EVP_des_ede_cfb64
+const EVP_CIPHER *EVP_des_ede3_cfb64(void);
+#  define EVP_des_ede3_cfb EVP_des_ede3_cfb64
+const EVP_CIPHER *EVP_des_ede3_cfb1(void);
+const EVP_CIPHER *EVP_des_ede3_cfb8(void);
+const EVP_CIPHER *EVP_des_ofb(void);
+const EVP_CIPHER *EVP_des_ede_ofb(void);
+const EVP_CIPHER *EVP_des_ede3_ofb(void);
+const EVP_CIPHER *EVP_des_cbc(void);
+const EVP_CIPHER *EVP_des_ede_cbc(void);
+const EVP_CIPHER *EVP_des_ede3_cbc(void);
+const EVP_CIPHER *EVP_desx_cbc(void);
+const EVP_CIPHER *EVP_des_ede3_wrap(void);
+/*
+ * This should now be supported through the dev_crypto ENGINE. But also, why
+ * are rc4 and md5 declarations made here inside a "NO_DES" precompiler
+ * branch?
+ */
+# endif
+# ifndef OPENSSL_NO_RC4
+const EVP_CIPHER *EVP_rc4(void);
+const EVP_CIPHER *EVP_rc4_40(void);
+#  ifndef OPENSSL_NO_MD5
+const EVP_CIPHER *EVP_rc4_hmac_md5(void);
+#  endif
+# endif
+# ifndef OPENSSL_NO_IDEA
+const EVP_CIPHER *EVP_idea_ecb(void);
+const EVP_CIPHER *EVP_idea_cfb64(void);
+#  define EVP_idea_cfb EVP_idea_cfb64
+const EVP_CIPHER *EVP_idea_ofb(void);
+const EVP_CIPHER *EVP_idea_cbc(void);
+# endif
+# ifndef OPENSSL_NO_RC2
+const EVP_CIPHER *EVP_rc2_ecb(void);
+const EVP_CIPHER *EVP_rc2_cbc(void);
+const EVP_CIPHER *EVP_rc2_40_cbc(void);
+const EVP_CIPHER *EVP_rc2_64_cbc(void);
+const EVP_CIPHER *EVP_rc2_cfb64(void);
+#  define EVP_rc2_cfb EVP_rc2_cfb64
+const EVP_CIPHER *EVP_rc2_ofb(void);
+# endif
+# ifndef OPENSSL_NO_BF
+const EVP_CIPHER *EVP_bf_ecb(void);
+const EVP_CIPHER *EVP_bf_cbc(void);
+const EVP_CIPHER *EVP_bf_cfb64(void);
+#  define EVP_bf_cfb EVP_bf_cfb64
+const EVP_CIPHER *EVP_bf_ofb(void);
+# endif
+# ifndef OPENSSL_NO_CAST
+const EVP_CIPHER *EVP_cast5_ecb(void);
+const EVP_CIPHER *EVP_cast5_cbc(void);
+const EVP_CIPHER *EVP_cast5_cfb64(void);
+#  define EVP_cast5_cfb EVP_cast5_cfb64
+const EVP_CIPHER *EVP_cast5_ofb(void);
+# endif
+# ifndef OPENSSL_NO_RC5
+const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void);
+const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void);
+const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void);
+#  define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64
+const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void);
+# endif
+const EVP_CIPHER *EVP_aes_128_ecb(void);
+const EVP_CIPHER *EVP_aes_128_cbc(void);
+const EVP_CIPHER *EVP_aes_128_cfb1(void);
+const EVP_CIPHER *EVP_aes_128_cfb8(void);
+const EVP_CIPHER *EVP_aes_128_cfb128(void);
+# define EVP_aes_128_cfb EVP_aes_128_cfb128
+const EVP_CIPHER *EVP_aes_128_ofb(void);
+const EVP_CIPHER *EVP_aes_128_ctr(void);
+const EVP_CIPHER *EVP_aes_128_ccm(void);
+const EVP_CIPHER *EVP_aes_128_gcm(void);
+const EVP_CIPHER *EVP_aes_128_xts(void);
+const EVP_CIPHER *EVP_aes_128_wrap(void);
+const EVP_CIPHER *EVP_aes_128_wrap_pad(void);
+# ifndef OPENSSL_NO_OCB
+const EVP_CIPHER *EVP_aes_128_ocb(void);
+# endif
+const EVP_CIPHER *EVP_aes_192_ecb(void);
+const EVP_CIPHER *EVP_aes_192_cbc(void);
+const EVP_CIPHER *EVP_aes_192_cfb1(void);
+const EVP_CIPHER *EVP_aes_192_cfb8(void);
+const EVP_CIPHER *EVP_aes_192_cfb128(void);
+# define EVP_aes_192_cfb EVP_aes_192_cfb128
+const EVP_CIPHER *EVP_aes_192_ofb(void);
+const EVP_CIPHER *EVP_aes_192_ctr(void);
+const EVP_CIPHER *EVP_aes_192_ccm(void);
+const EVP_CIPHER *EVP_aes_192_gcm(void);
+const EVP_CIPHER *EVP_aes_192_wrap(void);
+const EVP_CIPHER *EVP_aes_192_wrap_pad(void);
+# ifndef OPENSSL_NO_OCB
+const EVP_CIPHER *EVP_aes_192_ocb(void);
+# endif
+const EVP_CIPHER *EVP_aes_256_ecb(void);
+const EVP_CIPHER *EVP_aes_256_cbc(void);
+const EVP_CIPHER *EVP_aes_256_cfb1(void);
+const EVP_CIPHER *EVP_aes_256_cfb8(void);
+const EVP_CIPHER *EVP_aes_256_cfb128(void);
+# define EVP_aes_256_cfb EVP_aes_256_cfb128
+const EVP_CIPHER *EVP_aes_256_ofb(void);
+const EVP_CIPHER *EVP_aes_256_ctr(void);
+const EVP_CIPHER *EVP_aes_256_ccm(void);
+const EVP_CIPHER *EVP_aes_256_gcm(void);
+const EVP_CIPHER *EVP_aes_256_xts(void);
+const EVP_CIPHER *EVP_aes_256_wrap(void);
+const EVP_CIPHER *EVP_aes_256_wrap_pad(void);
+# ifndef OPENSSL_NO_OCB
+const EVP_CIPHER *EVP_aes_256_ocb(void);
+# endif
+const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void);
+const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void);
+const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha256(void);
+const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha256(void);
+# ifndef OPENSSL_NO_ARIA
+const EVP_CIPHER *EVP_aria_128_ecb(void);
+const EVP_CIPHER *EVP_aria_128_cbc(void);
+const EVP_CIPHER *EVP_aria_128_cfb1(void);
+const EVP_CIPHER *EVP_aria_128_cfb8(void);
+const EVP_CIPHER *EVP_aria_128_cfb128(void);
+#  define EVP_aria_128_cfb EVP_aria_128_cfb128
+const EVP_CIPHER *EVP_aria_128_ctr(void);
+const EVP_CIPHER *EVP_aria_128_ofb(void);
+const EVP_CIPHER *EVP_aria_128_gcm(void);
+const EVP_CIPHER *EVP_aria_128_ccm(void);
+const EVP_CIPHER *EVP_aria_192_ecb(void);
+const EVP_CIPHER *EVP_aria_192_cbc(void);
+const EVP_CIPHER *EVP_aria_192_cfb1(void);
+const EVP_CIPHER *EVP_aria_192_cfb8(void);
+const EVP_CIPHER *EVP_aria_192_cfb128(void);
+#  define EVP_aria_192_cfb EVP_aria_192_cfb128
+const EVP_CIPHER *EVP_aria_192_ctr(void);
+const EVP_CIPHER *EVP_aria_192_ofb(void);
+const EVP_CIPHER *EVP_aria_192_gcm(void);
+const EVP_CIPHER *EVP_aria_192_ccm(void);
+const EVP_CIPHER *EVP_aria_256_ecb(void);
+const EVP_CIPHER *EVP_aria_256_cbc(void);
+const EVP_CIPHER *EVP_aria_256_cfb1(void);
+const EVP_CIPHER *EVP_aria_256_cfb8(void);
+const EVP_CIPHER *EVP_aria_256_cfb128(void);
+#  define EVP_aria_256_cfb EVP_aria_256_cfb128
+const EVP_CIPHER *EVP_aria_256_ctr(void);
+const EVP_CIPHER *EVP_aria_256_ofb(void);
+const EVP_CIPHER *EVP_aria_256_gcm(void);
+const EVP_CIPHER *EVP_aria_256_ccm(void);
+# endif
+# ifndef OPENSSL_NO_CAMELLIA
+const EVP_CIPHER *EVP_camellia_128_ecb(void);
+const EVP_CIPHER *EVP_camellia_128_cbc(void);
+const EVP_CIPHER *EVP_camellia_128_cfb1(void);
+const EVP_CIPHER *EVP_camellia_128_cfb8(void);
+const EVP_CIPHER *EVP_camellia_128_cfb128(void);
+#  define EVP_camellia_128_cfb EVP_camellia_128_cfb128
+const EVP_CIPHER *EVP_camellia_128_ofb(void);
+const EVP_CIPHER *EVP_camellia_128_ctr(void);
+const EVP_CIPHER *EVP_camellia_192_ecb(void);
+const EVP_CIPHER *EVP_camellia_192_cbc(void);
+const EVP_CIPHER *EVP_camellia_192_cfb1(void);
+const EVP_CIPHER *EVP_camellia_192_cfb8(void);
+const EVP_CIPHER *EVP_camellia_192_cfb128(void);
+#  define EVP_camellia_192_cfb EVP_camellia_192_cfb128
+const EVP_CIPHER *EVP_camellia_192_ofb(void);
+const EVP_CIPHER *EVP_camellia_192_ctr(void);
+const EVP_CIPHER *EVP_camellia_256_ecb(void);
+const EVP_CIPHER *EVP_camellia_256_cbc(void);
+const EVP_CIPHER *EVP_camellia_256_cfb1(void);
+const EVP_CIPHER *EVP_camellia_256_cfb8(void);
+const EVP_CIPHER *EVP_camellia_256_cfb128(void);
+#  define EVP_camellia_256_cfb EVP_camellia_256_cfb128
+const EVP_CIPHER *EVP_camellia_256_ofb(void);
+const EVP_CIPHER *EVP_camellia_256_ctr(void);
+# endif
+# ifndef OPENSSL_NO_CHACHA
+const EVP_CIPHER *EVP_chacha20(void);
+#  ifndef OPENSSL_NO_POLY1305
+const EVP_CIPHER *EVP_chacha20_poly1305(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_SEED
+const EVP_CIPHER *EVP_seed_ecb(void);
+const EVP_CIPHER *EVP_seed_cbc(void);
+const EVP_CIPHER *EVP_seed_cfb128(void);
+#  define EVP_seed_cfb EVP_seed_cfb128
+const EVP_CIPHER *EVP_seed_ofb(void);
+# endif
+
+# ifndef OPENSSL_NO_SM4
+const EVP_CIPHER *EVP_sm4_ecb(void);
+const EVP_CIPHER *EVP_sm4_cbc(void);
+const EVP_CIPHER *EVP_sm4_cfb128(void);
+#  define EVP_sm4_cfb EVP_sm4_cfb128
+const EVP_CIPHER *EVP_sm4_ofb(void);
+const EVP_CIPHER *EVP_sm4_ctr(void);
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define OPENSSL_add_all_algorithms_conf() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \
+                        | OPENSSL_INIT_ADD_ALL_DIGESTS \
+                        | OPENSSL_INIT_LOAD_CONFIG, NULL)
+#  define OPENSSL_add_all_algorithms_noconf() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \
+                        | OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
+
+#  ifdef OPENSSL_LOAD_CONF
+#   define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_conf()
+#  else
+#   define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_noconf()
+#  endif
+
+#  define OpenSSL_add_all_ciphers() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL)
+#  define OpenSSL_add_all_digests() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
+
+#  define EVP_cleanup() while(0) continue
+# endif
+
+int EVP_add_cipher(const EVP_CIPHER *cipher);
+int EVP_add_digest(const EVP_MD *digest);
+
+const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
+const EVP_MD *EVP_get_digestbyname(const char *name);
+
+void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph,
+                                   const char *from, const char *to, void *x),
+                       void *arg);
+void EVP_CIPHER_do_all_sorted(void (*fn)
+                               (const EVP_CIPHER *ciph, const char *from,
+                                const char *to, void *x), void *arg);
+void EVP_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                void (*fn)(EVP_CIPHER *cipher, void *arg),
+                                void *arg);
+
+void EVP_MD_do_all(void (*fn) (const EVP_MD *ciph,
+                               const char *from, const char *to, void *x),
+                   void *arg);
+void EVP_MD_do_all_sorted(void (*fn)
+                           (const EVP_MD *ciph, const char *from,
+                            const char *to, void *x), void *arg);
+void EVP_MD_do_all_provided(OSSL_LIB_CTX *libctx,
+                            void (*fn)(EVP_MD *md, void *arg),
+                            void *arg);
+
+/* MAC stuff */
+
+EVP_MAC *EVP_MAC_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
+                       const char *properties);
+int EVP_MAC_up_ref(EVP_MAC *mac);
+void EVP_MAC_free(EVP_MAC *mac);
+const char *EVP_MAC_get0_name(const EVP_MAC *mac);
+const char *EVP_MAC_get0_description(const EVP_MAC *mac);
+int EVP_MAC_is_a(const EVP_MAC *mac, const char *name);
+const OSSL_PROVIDER *EVP_MAC_get0_provider(const EVP_MAC *mac);
+int EVP_MAC_get_params(EVP_MAC *mac, OSSL_PARAM params[]);
+
+EVP_MAC_CTX *EVP_MAC_CTX_new(EVP_MAC *mac);
+void EVP_MAC_CTX_free(EVP_MAC_CTX *ctx);
+EVP_MAC_CTX *EVP_MAC_CTX_dup(const EVP_MAC_CTX *src);
+EVP_MAC *EVP_MAC_CTX_get0_mac(EVP_MAC_CTX *ctx);
+int EVP_MAC_CTX_get_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[]);
+int EVP_MAC_CTX_set_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[]);
+
+size_t EVP_MAC_CTX_get_mac_size(EVP_MAC_CTX *ctx);
+size_t EVP_MAC_CTX_get_block_size(EVP_MAC_CTX *ctx);
+unsigned char *EVP_Q_mac(OSSL_LIB_CTX *libctx, const char *name, const char *propq,
+                         const char *subalg, const OSSL_PARAM *params,
+                         const void *key, size_t keylen,
+                         const unsigned char *data, size_t datalen,
+                         unsigned char *out, size_t outsize, size_t *outlen);
+int EVP_MAC_init(EVP_MAC_CTX *ctx, const unsigned char *key, size_t keylen,
+                 const OSSL_PARAM params[]);
+int EVP_MAC_update(EVP_MAC_CTX *ctx, const unsigned char *data, size_t datalen);
+int EVP_MAC_final(EVP_MAC_CTX *ctx,
+                  unsigned char *out, size_t *outl, size_t outsize);
+int EVP_MAC_finalXOF(EVP_MAC_CTX *ctx, unsigned char *out, size_t outsize);
+const OSSL_PARAM *EVP_MAC_gettable_params(const EVP_MAC *mac);
+const OSSL_PARAM *EVP_MAC_gettable_ctx_params(const EVP_MAC *mac);
+const OSSL_PARAM *EVP_MAC_settable_ctx_params(const EVP_MAC *mac);
+const OSSL_PARAM *EVP_MAC_CTX_gettable_params(EVP_MAC_CTX *ctx);
+const OSSL_PARAM *EVP_MAC_CTX_settable_params(EVP_MAC_CTX *ctx);
+
+void EVP_MAC_do_all_provided(OSSL_LIB_CTX *libctx,
+                             void (*fn)(EVP_MAC *mac, void *arg),
+                             void *arg);
+int EVP_MAC_names_do_all(const EVP_MAC *mac,
+                         void (*fn)(const char *name, void *data),
+                         void *data);
+
+/* RAND stuff */
+EVP_RAND *EVP_RAND_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
+                         const char *properties);
+int EVP_RAND_up_ref(EVP_RAND *rand);
+void EVP_RAND_free(EVP_RAND *rand);
+const char *EVP_RAND_get0_name(const EVP_RAND *rand);
+const char *EVP_RAND_get0_description(const EVP_RAND *md);
+int EVP_RAND_is_a(const EVP_RAND *rand, const char *name);
+const OSSL_PROVIDER *EVP_RAND_get0_provider(const EVP_RAND *rand);
+int EVP_RAND_get_params(EVP_RAND *rand, OSSL_PARAM params[]);
+
+EVP_RAND_CTX *EVP_RAND_CTX_new(EVP_RAND *rand, EVP_RAND_CTX *parent);
+void EVP_RAND_CTX_free(EVP_RAND_CTX *ctx);
+EVP_RAND *EVP_RAND_CTX_get0_rand(EVP_RAND_CTX *ctx);
+int EVP_RAND_CTX_get_params(EVP_RAND_CTX *ctx, OSSL_PARAM params[]);
+int EVP_RAND_CTX_set_params(EVP_RAND_CTX *ctx, const OSSL_PARAM params[]);
+const OSSL_PARAM *EVP_RAND_gettable_params(const EVP_RAND *rand);
+const OSSL_PARAM *EVP_RAND_gettable_ctx_params(const EVP_RAND *rand);
+const OSSL_PARAM *EVP_RAND_settable_ctx_params(const EVP_RAND *rand);
+const OSSL_PARAM *EVP_RAND_CTX_gettable_params(EVP_RAND_CTX *ctx);
+const OSSL_PARAM *EVP_RAND_CTX_settable_params(EVP_RAND_CTX *ctx);
+
+void EVP_RAND_do_all_provided(OSSL_LIB_CTX *libctx,
+                              void (*fn)(EVP_RAND *rand, void *arg),
+                              void *arg);
+int EVP_RAND_names_do_all(const EVP_RAND *rand,
+                          void (*fn)(const char *name, void *data),
+                          void *data);
+
+__owur int EVP_RAND_instantiate(EVP_RAND_CTX *ctx, unsigned int strength,
+                                int prediction_resistance,
+                                const unsigned char *pstr, size_t pstr_len,
+                                const OSSL_PARAM params[]);
+int EVP_RAND_uninstantiate(EVP_RAND_CTX *ctx);
+__owur int EVP_RAND_generate(EVP_RAND_CTX *ctx, unsigned char *out,
+                             size_t outlen, unsigned int strength,
+                             int prediction_resistance,
+                             const unsigned char *addin, size_t addin_len);
+int EVP_RAND_reseed(EVP_RAND_CTX *ctx, int prediction_resistance,
+                    const unsigned char *ent, size_t ent_len,
+                    const unsigned char *addin, size_t addin_len);
+__owur int EVP_RAND_nonce(EVP_RAND_CTX *ctx, unsigned char *out, size_t outlen);
+__owur int EVP_RAND_enable_locking(EVP_RAND_CTX *ctx);
+
+int EVP_RAND_verify_zeroization(EVP_RAND_CTX *ctx);
+unsigned int EVP_RAND_get_strength(EVP_RAND_CTX *ctx);
+int EVP_RAND_get_state(EVP_RAND_CTX *ctx);
+
+# define EVP_RAND_STATE_UNINITIALISED    0
+# define EVP_RAND_STATE_READY            1
+# define EVP_RAND_STATE_ERROR            2
+
+/* PKEY stuff */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_decrypt_old(unsigned char *dec_key,
+                                          const unsigned char *enc_key,
+                                          int enc_key_len,
+                                          EVP_PKEY *private_key);
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_encrypt_old(unsigned char *enc_key,
+                                          const unsigned char *key,
+                                          int key_len, EVP_PKEY *pub_key);
+# endif
+int EVP_PKEY_is_a(const EVP_PKEY *pkey, const char *name);
+int EVP_PKEY_type_names_do_all(const EVP_PKEY *pkey,
+                               void (*fn)(const char *name, void *data),
+                               void *data);
+int EVP_PKEY_type(int type);
+int EVP_PKEY_get_id(const EVP_PKEY *pkey);
+# define EVP_PKEY_id EVP_PKEY_get_id
+int EVP_PKEY_get_base_id(const EVP_PKEY *pkey);
+# define EVP_PKEY_base_id EVP_PKEY_get_base_id
+int EVP_PKEY_get_bits(const EVP_PKEY *pkey);
+# define EVP_PKEY_bits EVP_PKEY_get_bits
+int EVP_PKEY_get_security_bits(const EVP_PKEY *pkey);
+# define EVP_PKEY_security_bits EVP_PKEY_get_security_bits
+int EVP_PKEY_get_size(const EVP_PKEY *pkey);
+# define EVP_PKEY_size EVP_PKEY_get_size
+int EVP_PKEY_can_sign(const EVP_PKEY *pkey);
+int EVP_PKEY_set_type(EVP_PKEY *pkey, int type);
+int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len);
+int EVP_PKEY_set_type_by_keymgmt(EVP_PKEY *pkey, EVP_KEYMGMT *keymgmt);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_ENGINE
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e);
+OSSL_DEPRECATEDIN_3_0
+ENGINE *EVP_PKEY_get0_engine(const EVP_PKEY *pkey);
+#  endif
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key);
+OSSL_DEPRECATEDIN_3_0
+void *EVP_PKEY_get0(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len);
+#  ifndef OPENSSL_NO_POLY1305
+OSSL_DEPRECATEDIN_3_0
+const unsigned char *EVP_PKEY_get0_poly1305(const EVP_PKEY *pkey, size_t *len);
+#  endif
+#  ifndef OPENSSL_NO_SIPHASH
+OSSL_DEPRECATEDIN_3_0
+const unsigned char *EVP_PKEY_get0_siphash(const EVP_PKEY *pkey, size_t *len);
+#  endif
+
+struct rsa_st;
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key);
+OSSL_DEPRECATEDIN_3_0
+const struct rsa_st *EVP_PKEY_get0_RSA(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
+
+#  ifndef OPENSSL_NO_DSA
+struct dsa_st;
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key);
+OSSL_DEPRECATEDIN_3_0
+const struct dsa_st *EVP_PKEY_get0_DSA(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
+#  endif
+
+#  ifndef OPENSSL_NO_DH
+struct dh_st;
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key);
+OSSL_DEPRECATEDIN_3_0 const struct dh_st *EVP_PKEY_get0_DH(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0 struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
+#  endif
+
+#  ifndef OPENSSL_NO_EC
+struct ec_key_st;
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key);
+OSSL_DEPRECATEDIN_3_0
+const struct ec_key_st *EVP_PKEY_get0_EC_KEY(const EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
+#  endif
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+EVP_PKEY *EVP_PKEY_new(void);
+int EVP_PKEY_up_ref(EVP_PKEY *pkey);
+EVP_PKEY *EVP_PKEY_dup(EVP_PKEY *pkey);
+void EVP_PKEY_free(EVP_PKEY *pkey);
+const char *EVP_PKEY_get0_description(const EVP_PKEY *pkey);
+const OSSL_PROVIDER *EVP_PKEY_get0_provider(const EVP_PKEY *key);
+
+EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp,
+                        long length);
+int i2d_PublicKey(const EVP_PKEY *a, unsigned char **pp);
+
+
+EVP_PKEY *d2i_PrivateKey_ex(int type, EVP_PKEY **a, const unsigned char **pp,
+                            long length, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp,
+                         long length);
+EVP_PKEY *d2i_AutoPrivateKey_ex(EVP_PKEY **a, const unsigned char **pp,
+                                long length, OSSL_LIB_CTX *libctx,
+                                const char *propq);
+EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp,
+                             long length);
+int i2d_PrivateKey(const EVP_PKEY *a, unsigned char **pp);
+
+int i2d_KeyParams(const EVP_PKEY *a, unsigned char **pp);
+EVP_PKEY *d2i_KeyParams(int type, EVP_PKEY **a, const unsigned char **pp,
+                        long length);
+int i2d_KeyParams_bio(BIO *bp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_KeyParams_bio(int type, EVP_PKEY **a, BIO *in);
+
+int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from);
+int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey);
+int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode);
+int EVP_PKEY_parameters_eq(const EVP_PKEY *a, const EVP_PKEY *b);
+int EVP_PKEY_eq(const EVP_PKEY *a, const EVP_PKEY *b);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b);
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b);
+# endif
+
+int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
+                          int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
+                           int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
+                          int indent, ASN1_PCTX *pctx);
+# ifndef OPENSSL_NO_STDIO
+int EVP_PKEY_print_public_fp(FILE *fp, const EVP_PKEY *pkey,
+                             int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_private_fp(FILE *fp, const EVP_PKEY *pkey,
+                              int indent, ASN1_PCTX *pctx);
+int EVP_PKEY_print_params_fp(FILE *fp, const EVP_PKEY *pkey,
+                             int indent, ASN1_PCTX *pctx);
+# endif
+
+int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid);
+int EVP_PKEY_get_default_digest_name(EVP_PKEY *pkey,
+                                     char *mdname, size_t mdname_sz);
+int EVP_PKEY_digestsign_supports_digest(EVP_PKEY *pkey, OSSL_LIB_CTX *libctx,
+                                        const char *name, const char *propq);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * For backwards compatibility. Use EVP_PKEY_set1_encoded_public_key in
+ * preference
+ */
+#  define EVP_PKEY_set1_tls_encodedpoint(pkey, pt, ptlen) \
+          EVP_PKEY_set1_encoded_public_key((pkey), (pt), (ptlen))
+# endif
+
+int EVP_PKEY_set1_encoded_public_key(EVP_PKEY *pkey,
+                                     const unsigned char *pub, size_t publen);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * For backwards compatibility. Use EVP_PKEY_get1_encoded_public_key in
+ * preference
+ */
+#  define EVP_PKEY_get1_tls_encodedpoint(pkey, ppt) \
+          EVP_PKEY_get1_encoded_public_key((pkey), (ppt))
+# endif
+
+size_t EVP_PKEY_get1_encoded_public_key(EVP_PKEY *pkey, unsigned char **ppub);
+
+/* calls methods */
+int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+
+/* These are used by EVP_CIPHER methods */
+int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
+
+/* PKCS5 password based encryption */
+int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                       ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                       const EVP_MD *md, int en_de);
+int PKCS5_PBE_keyivgen_ex(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,
+                          ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                          const EVP_MD *md, int en_de, OSSL_LIB_CTX *libctx,
+                          const char *propq);
+int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
+                           const unsigned char *salt, int saltlen, int iter,
+                           int keylen, unsigned char *out);
+int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
+                      const unsigned char *salt, int saltlen, int iter,
+                      const EVP_MD *digest, int keylen, unsigned char *out);
+int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                          ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                          const EVP_MD *md, int en_de);
+int PKCS5_v2_PBE_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                             ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                             const EVP_MD *md, int en_de,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+
+#ifndef OPENSSL_NO_SCRYPT
+int EVP_PBE_scrypt(const char *pass, size_t passlen,
+                   const unsigned char *salt, size_t saltlen,
+                   uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem,
+                   unsigned char *key, size_t keylen);
+int EVP_PBE_scrypt_ex(const char *pass, size_t passlen,
+                      const unsigned char *salt, size_t saltlen,
+                      uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem,
+                      unsigned char *key, size_t keylen,
+                      OSSL_LIB_CTX *ctx, const char *propq);
+
+int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
+                             int passlen, ASN1_TYPE *param,
+                             const EVP_CIPHER *c, const EVP_MD *md, int en_de);
+int PKCS5_v2_scrypt_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass,
+                                int passlen, ASN1_TYPE *param,
+                                const EVP_CIPHER *c, const EVP_MD *md, int en_de,
+                                OSSL_LIB_CTX *libctx, const char *propq);
+#endif
+
+void PKCS5_PBE_add(void);
+
+int EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
+                       ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de);
+
+int EVP_PBE_CipherInit_ex(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
+                          ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de,
+                          OSSL_LIB_CTX *libctx, const char *propq);
+
+/* PBE type */
+
+/* Can appear as the outermost AlgorithmIdentifier */
+# define EVP_PBE_TYPE_OUTER      0x0
+/* Is an PRF type OID */
+# define EVP_PBE_TYPE_PRF        0x1
+/* Is a PKCS#5 v2.0 KDF */
+# define EVP_PBE_TYPE_KDF        0x2
+
+int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid,
+                         int md_nid, EVP_PBE_KEYGEN *keygen);
+int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
+                    EVP_PBE_KEYGEN *keygen);
+int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid,
+                 EVP_PBE_KEYGEN **pkeygen);
+int EVP_PBE_find_ex(int type, int pbe_nid, int *pcnid, int *pmnid,
+                    EVP_PBE_KEYGEN **pkeygen, EVP_PBE_KEYGEN_EX **pkeygen_ex);
+void EVP_PBE_cleanup(void);
+int EVP_PBE_get(int *ptype, int *ppbe_nid, size_t num);
+
+# define ASN1_PKEY_ALIAS         0x1
+# define ASN1_PKEY_DYNAMIC       0x2
+# define ASN1_PKEY_SIGPARAM_NULL 0x4
+
+# define ASN1_PKEY_CTRL_PKCS7_SIGN       0x1
+# define ASN1_PKEY_CTRL_PKCS7_ENCRYPT    0x2
+# define ASN1_PKEY_CTRL_DEFAULT_MD_NID   0x3
+# define ASN1_PKEY_CTRL_CMS_SIGN         0x5
+# define ASN1_PKEY_CTRL_CMS_ENVELOPE     0x7
+# define ASN1_PKEY_CTRL_CMS_RI_TYPE      0x8
+
+# define ASN1_PKEY_CTRL_SET1_TLS_ENCPT   0x9
+# define ASN1_PKEY_CTRL_GET1_TLS_ENCPT   0xa
+# define ASN1_PKEY_CTRL_CMS_IS_RI_TYPE_SUPPORTED 0xb
+
+int EVP_PKEY_asn1_get_count(void);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type);
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
+                                                   const char *str, int len);
+int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth);
+int EVP_PKEY_asn1_add_alias(int to, int from);
+int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id,
+                            int *ppkey_flags, const char **pinfo,
+                            const char **ppem_str,
+                            const EVP_PKEY_ASN1_METHOD *ameth);
+
+const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(const EVP_PKEY *pkey);
+EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,
+                                        const char *pem_str,
+                                        const char *info);
+void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
+                        const EVP_PKEY_ASN1_METHOD *src);
+void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth);
+void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
+                              int (*pub_decode) (EVP_PKEY *pk,
+                                                 const X509_PUBKEY *pub),
+                              int (*pub_encode) (X509_PUBKEY *pub,
+                                                 const EVP_PKEY *pk),
+                              int (*pub_cmp) (const EVP_PKEY *a,
+                                              const EVP_PKEY *b),
+                              int (*pub_print) (BIO *out,
+                                                const EVP_PKEY *pkey,
+                                                int indent, ASN1_PCTX *pctx),
+                              int (*pkey_size) (const EVP_PKEY *pk),
+                              int (*pkey_bits) (const EVP_PKEY *pk));
+void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
+                               int (*priv_decode) (EVP_PKEY *pk,
+                                                   const PKCS8_PRIV_KEY_INFO
+                                                   *p8inf),
+                               int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8,
+                                                   const EVP_PKEY *pk),
+                               int (*priv_print) (BIO *out,
+                                                  const EVP_PKEY *pkey,
+                                                  int indent,
+                                                  ASN1_PCTX *pctx));
+void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
+                             int (*param_decode) (EVP_PKEY *pkey,
+                                                  const unsigned char **pder,
+                                                  int derlen),
+                             int (*param_encode) (const EVP_PKEY *pkey,
+                                                  unsigned char **pder),
+                             int (*param_missing) (const EVP_PKEY *pk),
+                             int (*param_copy) (EVP_PKEY *to,
+                                                const EVP_PKEY *from),
+                             int (*param_cmp) (const EVP_PKEY *a,
+                                               const EVP_PKEY *b),
+                             int (*param_print) (BIO *out,
+                                                 const EVP_PKEY *pkey,
+                                                 int indent,
+                                                 ASN1_PCTX *pctx));
+
+void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
+                            void (*pkey_free) (EVP_PKEY *pkey));
+void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
+                            int (*pkey_ctrl) (EVP_PKEY *pkey, int op,
+                                              long arg1, void *arg2));
+void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth,
+                            int (*item_verify) (EVP_MD_CTX *ctx,
+                                                const ASN1_ITEM *it,
+                                                const void *data,
+                                                const X509_ALGOR *a,
+                                                const ASN1_BIT_STRING *sig,
+                                                EVP_PKEY *pkey),
+                            int (*item_sign) (EVP_MD_CTX *ctx,
+                                              const ASN1_ITEM *it,
+                                              const void *data,
+                                              X509_ALGOR *alg1,
+                                              X509_ALGOR *alg2,
+                                              ASN1_BIT_STRING *sig));
+
+void EVP_PKEY_asn1_set_siginf(EVP_PKEY_ASN1_METHOD *ameth,
+                              int (*siginf_set) (X509_SIG_INFO *siginf,
+                                                 const X509_ALGOR *alg,
+                                                 const ASN1_STRING *sig));
+
+void EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth,
+                             int (*pkey_check) (const EVP_PKEY *pk));
+
+void EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth,
+                                    int (*pkey_pub_check) (const EVP_PKEY *pk));
+
+void EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth,
+                                   int (*pkey_param_check) (const EVP_PKEY *pk));
+
+void EVP_PKEY_asn1_set_set_priv_key(EVP_PKEY_ASN1_METHOD *ameth,
+                                    int (*set_priv_key) (EVP_PKEY *pk,
+                                                         const unsigned char
+                                                            *priv,
+                                                         size_t len));
+void EVP_PKEY_asn1_set_set_pub_key(EVP_PKEY_ASN1_METHOD *ameth,
+                                   int (*set_pub_key) (EVP_PKEY *pk,
+                                                       const unsigned char *pub,
+                                                       size_t len));
+void EVP_PKEY_asn1_set_get_priv_key(EVP_PKEY_ASN1_METHOD *ameth,
+                                    int (*get_priv_key) (const EVP_PKEY *pk,
+                                                         unsigned char *priv,
+                                                         size_t *len));
+void EVP_PKEY_asn1_set_get_pub_key(EVP_PKEY_ASN1_METHOD *ameth,
+                                   int (*get_pub_key) (const EVP_PKEY *pk,
+                                                       unsigned char *pub,
+                                                       size_t *len));
+
+void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
+                                     int (*pkey_security_bits) (const EVP_PKEY
+                                                                *pk));
+
+int EVP_PKEY_CTX_get_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+int EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+
+int EVP_PKEY_CTX_set1_id(EVP_PKEY_CTX *ctx, const void *id, int len);
+int EVP_PKEY_CTX_get1_id(EVP_PKEY_CTX *ctx, void *id);
+int EVP_PKEY_CTX_get1_id_len(EVP_PKEY_CTX *ctx, size_t *id_len);
+
+int EVP_PKEY_CTX_set_kem_op(EVP_PKEY_CTX *ctx, const char *op);
+
+const char *EVP_PKEY_get0_type_name(const EVP_PKEY *key);
+
+# define EVP_PKEY_OP_UNDEFINED           0
+# define EVP_PKEY_OP_PARAMGEN            (1<<1)
+# define EVP_PKEY_OP_KEYGEN              (1<<2)
+# define EVP_PKEY_OP_FROMDATA            (1<<3)
+# define EVP_PKEY_OP_SIGN                (1<<4)
+# define EVP_PKEY_OP_VERIFY              (1<<5)
+# define EVP_PKEY_OP_VERIFYRECOVER       (1<<6)
+# define EVP_PKEY_OP_SIGNCTX             (1<<7)
+# define EVP_PKEY_OP_VERIFYCTX           (1<<8)
+# define EVP_PKEY_OP_ENCRYPT             (1<<9)
+# define EVP_PKEY_OP_DECRYPT             (1<<10)
+# define EVP_PKEY_OP_DERIVE              (1<<11)
+# define EVP_PKEY_OP_ENCAPSULATE         (1<<12)
+# define EVP_PKEY_OP_DECAPSULATE         (1<<13)
+
+# define EVP_PKEY_OP_TYPE_SIG    \
+        (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER \
+                | EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX)
+
+# define EVP_PKEY_OP_TYPE_CRYPT \
+        (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT)
+
+# define EVP_PKEY_OP_TYPE_NOGEN \
+        (EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_DERIVE)
+
+# define EVP_PKEY_OP_TYPE_GEN \
+        (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN)
+
+
+int EVP_PKEY_CTX_set_mac_key(EVP_PKEY_CTX *ctx, const unsigned char *key,
+                             int keylen);
+
+# define EVP_PKEY_CTRL_MD                1
+# define EVP_PKEY_CTRL_PEER_KEY          2
+# define EVP_PKEY_CTRL_SET_MAC_KEY       6
+# define EVP_PKEY_CTRL_DIGESTINIT        7
+/* Used by GOST key encryption in TLS */
+# define EVP_PKEY_CTRL_SET_IV            8
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define EVP_PKEY_CTRL_PKCS7_ENCRYPT     3
+#  define EVP_PKEY_CTRL_PKCS7_DECRYPT     4
+#  define EVP_PKEY_CTRL_PKCS7_SIGN        5
+#  define EVP_PKEY_CTRL_CMS_ENCRYPT       9
+#  define EVP_PKEY_CTRL_CMS_DECRYPT       10
+#  define EVP_PKEY_CTRL_CMS_SIGN          11
+# endif
+# define EVP_PKEY_CTRL_CIPHER            12
+# define EVP_PKEY_CTRL_GET_MD            13
+# define EVP_PKEY_CTRL_SET_DIGEST_SIZE   14
+# define EVP_PKEY_CTRL_SET1_ID           15
+# define EVP_PKEY_CTRL_GET1_ID           16
+# define EVP_PKEY_CTRL_GET1_ID_LEN       17
+
+# define EVP_PKEY_ALG_CTRL               0x1000
+
+# define EVP_PKEY_FLAG_AUTOARGLEN        2
+/*
+ * Method handles all operations: don't assume any digest related defaults.
+ */
+# define EVP_PKEY_FLAG_SIGCTX_CUSTOM     4
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
+OSSL_DEPRECATEDIN_3_0 EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags);
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
+                                              const EVP_PKEY_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst,
+                                         const EVP_PKEY_METHOD *src);
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
+OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth);
+OSSL_DEPRECATEDIN_3_0 size_t EVP_PKEY_meth_get_count(void);
+OSSL_DEPRECATEDIN_3_0 const EVP_PKEY_METHOD *EVP_PKEY_meth_get0(size_t idx);
+# endif
+
+EVP_KEYMGMT *EVP_KEYMGMT_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                               const char *properties);
+int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt);
+void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt);
+const OSSL_PROVIDER *EVP_KEYMGMT_get0_provider(const EVP_KEYMGMT *keymgmt);
+const char *EVP_KEYMGMT_get0_name(const EVP_KEYMGMT *keymgmt);
+const char *EVP_KEYMGMT_get0_description(const EVP_KEYMGMT *keymgmt);
+int EVP_KEYMGMT_is_a(const EVP_KEYMGMT *keymgmt, const char *name);
+void EVP_KEYMGMT_do_all_provided(OSSL_LIB_CTX *libctx,
+                                 void (*fn)(EVP_KEYMGMT *keymgmt, void *arg),
+                                 void *arg);
+int EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
+                             void (*fn)(const char *name, void *data),
+                             void *data);
+const OSSL_PARAM *EVP_KEYMGMT_gettable_params(const EVP_KEYMGMT *keymgmt);
+const OSSL_PARAM *EVP_KEYMGMT_settable_params(const EVP_KEYMGMT *keymgmt);
+const OSSL_PARAM *EVP_KEYMGMT_gen_settable_params(const EVP_KEYMGMT *keymgmt);
+
+EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
+EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
+EVP_PKEY_CTX *EVP_PKEY_CTX_new_from_name(OSSL_LIB_CTX *libctx,
+                                         const char *name,
+                                         const char *propquery);
+EVP_PKEY_CTX *EVP_PKEY_CTX_new_from_pkey(OSSL_LIB_CTX *libctx,
+                                         EVP_PKEY *pkey, const char *propquery);
+EVP_PKEY_CTX *EVP_PKEY_CTX_dup(const EVP_PKEY_CTX *ctx);
+void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_CTX_is_a(EVP_PKEY_CTX *ctx, const char *keytype);
+
+int EVP_PKEY_CTX_get_params(EVP_PKEY_CTX *ctx, OSSL_PARAM *params);
+const OSSL_PARAM *EVP_PKEY_CTX_gettable_params(const EVP_PKEY_CTX *ctx);
+int EVP_PKEY_CTX_set_params(EVP_PKEY_CTX *ctx, const OSSL_PARAM *params);
+const OSSL_PARAM *EVP_PKEY_CTX_settable_params(const EVP_PKEY_CTX *ctx);
+int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
+                      int cmd, int p1, void *p2);
+int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
+                          const char *value);
+int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype,
+                             int cmd, uint64_t value);
+
+int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str);
+int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex);
+
+int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md);
+
+int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx);
+void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen);
+
+EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
+                               const unsigned char *key, int keylen);
+EVP_PKEY *EVP_PKEY_new_raw_private_key_ex(OSSL_LIB_CTX *libctx,
+                                          const char *keytype,
+                                          const char *propq,
+                                          const unsigned char *priv, size_t len);
+EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e,
+                                       const unsigned char *priv,
+                                       size_t len);
+EVP_PKEY *EVP_PKEY_new_raw_public_key_ex(OSSL_LIB_CTX *libctx,
+                                         const char *keytype, const char *propq,
+                                         const unsigned char *pub, size_t len);
+EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e,
+                                      const unsigned char *pub,
+                                      size_t len);
+int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv,
+                                 size_t *len);
+int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub,
+                                size_t *len);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+EVP_PKEY *EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv,
+                                size_t len, const EVP_CIPHER *cipher);
+# endif
+
+void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data);
+void *EVP_PKEY_CTX_get_data(const EVP_PKEY_CTX *ctx);
+EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx);
+
+EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx);
+
+void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data);
+void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);
+
+void EVP_SIGNATURE_free(EVP_SIGNATURE *signature);
+int EVP_SIGNATURE_up_ref(EVP_SIGNATURE *signature);
+OSSL_PROVIDER *EVP_SIGNATURE_get0_provider(const EVP_SIGNATURE *signature);
+EVP_SIGNATURE *EVP_SIGNATURE_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                                   const char *properties);
+int EVP_SIGNATURE_is_a(const EVP_SIGNATURE *signature, const char *name);
+const char *EVP_SIGNATURE_get0_name(const EVP_SIGNATURE *signature);
+const char *EVP_SIGNATURE_get0_description(const EVP_SIGNATURE *signature);
+void EVP_SIGNATURE_do_all_provided(OSSL_LIB_CTX *libctx,
+                                   void (*fn)(EVP_SIGNATURE *signature,
+                                              void *data),
+                                   void *data);
+int EVP_SIGNATURE_names_do_all(const EVP_SIGNATURE *signature,
+                               void (*fn)(const char *name, void *data),
+                               void *data);
+const OSSL_PARAM *EVP_SIGNATURE_gettable_ctx_params(const EVP_SIGNATURE *sig);
+const OSSL_PARAM *EVP_SIGNATURE_settable_ctx_params(const EVP_SIGNATURE *sig);
+
+void EVP_ASYM_CIPHER_free(EVP_ASYM_CIPHER *cipher);
+int EVP_ASYM_CIPHER_up_ref(EVP_ASYM_CIPHER *cipher);
+OSSL_PROVIDER *EVP_ASYM_CIPHER_get0_provider(const EVP_ASYM_CIPHER *cipher);
+EVP_ASYM_CIPHER *EVP_ASYM_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                                       const char *properties);
+int EVP_ASYM_CIPHER_is_a(const EVP_ASYM_CIPHER *cipher, const char *name);
+const char *EVP_ASYM_CIPHER_get0_name(const EVP_ASYM_CIPHER *cipher);
+const char *EVP_ASYM_CIPHER_get0_description(const EVP_ASYM_CIPHER *cipher);
+void EVP_ASYM_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                     void (*fn)(EVP_ASYM_CIPHER *cipher,
+                                                void *arg),
+                                     void *arg);
+int EVP_ASYM_CIPHER_names_do_all(const EVP_ASYM_CIPHER *cipher,
+                                 void (*fn)(const char *name, void *data),
+                                 void *data);
+const OSSL_PARAM *EVP_ASYM_CIPHER_gettable_ctx_params(const EVP_ASYM_CIPHER *ciph);
+const OSSL_PARAM *EVP_ASYM_CIPHER_settable_ctx_params(const EVP_ASYM_CIPHER *ciph);
+
+void EVP_KEM_free(EVP_KEM *wrap);
+int EVP_KEM_up_ref(EVP_KEM *wrap);
+OSSL_PROVIDER *EVP_KEM_get0_provider(const EVP_KEM *wrap);
+EVP_KEM *EVP_KEM_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                       const char *properties);
+int EVP_KEM_is_a(const EVP_KEM *wrap, const char *name);
+const char *EVP_KEM_get0_name(const EVP_KEM *wrap);
+const char *EVP_KEM_get0_description(const EVP_KEM *wrap);
+void EVP_KEM_do_all_provided(OSSL_LIB_CTX *libctx,
+                             void (*fn)(EVP_KEM *wrap, void *arg), void *arg);
+int EVP_KEM_names_do_all(const EVP_KEM *wrap,
+                         void (*fn)(const char *name, void *data), void *data);
+const OSSL_PARAM *EVP_KEM_gettable_ctx_params(const EVP_KEM *kem);
+const OSSL_PARAM *EVP_KEM_settable_ctx_params(const EVP_KEM *kem);
+
+int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_sign_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
+                  unsigned char *sig, size_t *siglen,
+                  const unsigned char *tbs, size_t tbslen);
+int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_verify_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
+                    const unsigned char *sig, size_t siglen,
+                    const unsigned char *tbs, size_t tbslen);
+int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_verify_recover_init_ex(EVP_PKEY_CTX *ctx,
+                                    const OSSL_PARAM params[]);
+int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
+                            unsigned char *rout, size_t *routlen,
+                            const unsigned char *sig, size_t siglen);
+int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_encrypt_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
+                     unsigned char *out, size_t *outlen,
+                     const unsigned char *in, size_t inlen);
+int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_decrypt_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
+                     unsigned char *out, size_t *outlen,
+                     const unsigned char *in, size_t inlen);
+
+int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_derive_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_derive_set_peer_ex(EVP_PKEY_CTX *ctx, EVP_PKEY *peer,
+                                int validate_peer);
+int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
+int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
+
+int EVP_PKEY_encapsulate_init(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_encapsulate(EVP_PKEY_CTX *ctx,
+                         unsigned char *wrappedkey, size_t *wrappedkeylen,
+                         unsigned char *genkey, size_t *genkeylen);
+int EVP_PKEY_decapsulate_init(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
+int EVP_PKEY_decapsulate(EVP_PKEY_CTX *ctx,
+                         unsigned char *unwrapped, size_t *unwrappedlen,
+                         const unsigned char *wrapped, size_t wrappedlen);
+
+typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);
+
+int EVP_PKEY_fromdata_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_fromdata(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, int selection,
+                      OSSL_PARAM param[]);
+const OSSL_PARAM *EVP_PKEY_fromdata_settable(EVP_PKEY_CTX *ctx, int selection);
+
+int EVP_PKEY_todata(const EVP_PKEY *pkey, int selection, OSSL_PARAM **params);
+int EVP_PKEY_export(const EVP_PKEY *pkey, int selection,
+                    OSSL_CALLBACK *export_cb, void *export_cbarg);
+
+const OSSL_PARAM *EVP_PKEY_gettable_params(const EVP_PKEY *pkey);
+int EVP_PKEY_get_params(const EVP_PKEY *pkey, OSSL_PARAM params[]);
+int EVP_PKEY_get_int_param(const EVP_PKEY *pkey, const char *key_name,
+                           int *out);
+int EVP_PKEY_get_size_t_param(const EVP_PKEY *pkey, const char *key_name,
+                              size_t *out);
+int EVP_PKEY_get_bn_param(const EVP_PKEY *pkey, const char *key_name,
+                          BIGNUM **bn);
+int EVP_PKEY_get_utf8_string_param(const EVP_PKEY *pkey, const char *key_name,
+                                    char *str, size_t max_buf_sz, size_t *out_sz);
+int EVP_PKEY_get_octet_string_param(const EVP_PKEY *pkey, const char *key_name,
+                                    unsigned char *buf, size_t max_buf_sz,
+                                    size_t *out_sz);
+
+const OSSL_PARAM *EVP_PKEY_settable_params(const EVP_PKEY *pkey);
+int EVP_PKEY_set_params(EVP_PKEY *pkey, OSSL_PARAM params[]);
+int EVP_PKEY_set_int_param(EVP_PKEY *pkey, const char *key_name, int in);
+int EVP_PKEY_set_size_t_param(EVP_PKEY *pkey, const char *key_name, size_t in);
+int EVP_PKEY_set_bn_param(EVP_PKEY *pkey, const char *key_name,
+                          const BIGNUM *bn);
+int EVP_PKEY_set_utf8_string_param(EVP_PKEY *pkey, const char *key_name,
+                                   const char *str);
+int EVP_PKEY_set_octet_string_param(EVP_PKEY *pkey, const char *key_name,
+                                    const unsigned char *buf, size_t bsize);
+
+int EVP_PKEY_get_ec_point_conv_form(const EVP_PKEY *pkey);
+int EVP_PKEY_get_field_type(const EVP_PKEY *pkey);
+
+EVP_PKEY *EVP_PKEY_Q_keygen(OSSL_LIB_CTX *libctx, const char *propq,
+                            const char *type, ...);
+int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
+int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
+int EVP_PKEY_generate(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
+int EVP_PKEY_check(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_public_check(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_public_check_quick(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_param_check(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_param_check_quick(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_private_check(EVP_PKEY_CTX *ctx);
+int EVP_PKEY_pairwise_check(EVP_PKEY_CTX *ctx);
+
+# define EVP_PKEY_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_EVP_PKEY, l, p, newf, dupf, freef)
+int EVP_PKEY_set_ex_data(EVP_PKEY *key, int idx, void *arg);
+void *EVP_PKEY_get_ex_data(const EVP_PKEY *key, int idx);
+
+void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb);
+EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx);
+
+int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
+                                             int (*init) (EVP_PKEY_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_copy
+    (EVP_PKEY_METHOD *pmeth, int (*copy) (EVP_PKEY_CTX *dst,
+                                          const EVP_PKEY_CTX *src));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_cleanup
+    (EVP_PKEY_METHOD *pmeth, void (*cleanup) (EVP_PKEY_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_paramgen
+    (EVP_PKEY_METHOD *pmeth, int (*paramgen_init) (EVP_PKEY_CTX *ctx),
+     int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_keygen
+    (EVP_PKEY_METHOD *pmeth, int (*keygen_init) (EVP_PKEY_CTX *ctx),
+     int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_sign
+    (EVP_PKEY_METHOD *pmeth, int (*sign_init) (EVP_PKEY_CTX *ctx),
+     int (*sign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                  const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verify
+    (EVP_PKEY_METHOD *pmeth, int (*verify_init) (EVP_PKEY_CTX *ctx),
+     int (*verify) (EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
+                    const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verify_recover
+    (EVP_PKEY_METHOD *pmeth, int (*verify_recover_init) (EVP_PKEY_CTX *ctx),
+     int (*verify_recover) (EVP_PKEY_CTX *ctx, unsigned char *sig,
+                            size_t *siglen, const unsigned char *tbs,
+                            size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_signctx
+    (EVP_PKEY_METHOD *pmeth, int (*signctx_init) (EVP_PKEY_CTX *ctx,
+                                                  EVP_MD_CTX *mctx),
+     int (*signctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                     EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verifyctx
+    (EVP_PKEY_METHOD *pmeth, int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
+                                                    EVP_MD_CTX *mctx),
+     int (*verifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
+                       EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_encrypt
+    (EVP_PKEY_METHOD *pmeth, int (*encrypt_init) (EVP_PKEY_CTX *ctx),
+     int (*encryptfn) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                       const unsigned char *in, size_t inlen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_decrypt
+    (EVP_PKEY_METHOD *pmeth, int (*decrypt_init) (EVP_PKEY_CTX *ctx),
+     int (*decrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                     const unsigned char *in, size_t inlen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_derive
+    (EVP_PKEY_METHOD *pmeth, int (*derive_init) (EVP_PKEY_CTX *ctx),
+     int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_ctrl
+    (EVP_PKEY_METHOD *pmeth, int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
+                                          void *p2),
+     int (*ctrl_str) (EVP_PKEY_CTX *ctx, const char *type, const char *value));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digestsign
+    (EVP_PKEY_METHOD *pmeth,
+     int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
+                        const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digestverify
+    (EVP_PKEY_METHOD *pmeth,
+     int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
+                          size_t siglen, const unsigned char *tbs,
+                          size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_check
+    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_public_check
+    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_param_check
+    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digest_custom
+    (EVP_PKEY_METHOD *pmeth, int (*digest_custom) (EVP_PKEY_CTX *ctx,
+                                                   EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_init
+    (const EVP_PKEY_METHOD *pmeth, int (**pinit) (EVP_PKEY_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_copy
+    (const EVP_PKEY_METHOD *pmeth, int (**pcopy) (EVP_PKEY_CTX *dst,
+                                                  const EVP_PKEY_CTX *src));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_cleanup
+    (const EVP_PKEY_METHOD *pmeth, void (**pcleanup) (EVP_PKEY_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_paramgen
+    (const EVP_PKEY_METHOD *pmeth, int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
+     int (**pparamgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_keygen
+    (const EVP_PKEY_METHOD *pmeth, int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
+     int (**pkeygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_sign
+    (const EVP_PKEY_METHOD *pmeth, int (**psign_init) (EVP_PKEY_CTX *ctx),
+     int (**psign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                    const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verify
+    (const EVP_PKEY_METHOD *pmeth, int (**pverify_init) (EVP_PKEY_CTX *ctx),
+     int (**pverify) (EVP_PKEY_CTX *ctx, const unsigned char *sig,
+                      size_t siglen, const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verify_recover
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**pverify_recover_init) (EVP_PKEY_CTX *ctx),
+     int (**pverify_recover) (EVP_PKEY_CTX *ctx, unsigned char *sig,
+                              size_t *siglen, const unsigned char *tbs,
+                              size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_signctx
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**psignctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
+     int (**psignctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+                       EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verifyctx
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**pverifyctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
+     int (**pverifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig,
+                          int siglen, EVP_MD_CTX *mctx));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_encrypt
+    (const EVP_PKEY_METHOD *pmeth, int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
+     int (**pencryptfn) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                         const unsigned char *in, size_t inlen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_decrypt
+    (const EVP_PKEY_METHOD *pmeth, int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
+     int (**pdecrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+                       const unsigned char *in, size_t inlen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_derive
+    (const EVP_PKEY_METHOD *pmeth, int (**pderive_init) (EVP_PKEY_CTX *ctx),
+     int (**pderive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_ctrl
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
+     int (**pctrl_str) (EVP_PKEY_CTX *ctx, const char *type,
+                        const char *value));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digestsign
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
+                         const unsigned char *tbs, size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digestverify
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
+                           size_t siglen, const unsigned char *tbs,
+                           size_t tbslen));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_check
+    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_public_check
+    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_param_check
+    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
+OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digest_custom
+    (const EVP_PKEY_METHOD *pmeth,
+     int (**pdigest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx));
+# endif
+
+void EVP_KEYEXCH_free(EVP_KEYEXCH *exchange);
+int EVP_KEYEXCH_up_ref(EVP_KEYEXCH *exchange);
+EVP_KEYEXCH *EVP_KEYEXCH_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
+                               const char *properties);
+OSSL_PROVIDER *EVP_KEYEXCH_get0_provider(const EVP_KEYEXCH *exchange);
+int EVP_KEYEXCH_is_a(const EVP_KEYEXCH *keyexch, const char *name);
+const char *EVP_KEYEXCH_get0_name(const EVP_KEYEXCH *keyexch);
+const char *EVP_KEYEXCH_get0_description(const EVP_KEYEXCH *keyexch);
+void EVP_KEYEXCH_do_all_provided(OSSL_LIB_CTX *libctx,
+                                 void (*fn)(EVP_KEYEXCH *keyexch, void *data),
+                                 void *data);
+int EVP_KEYEXCH_names_do_all(const EVP_KEYEXCH *keyexch,
+                             void (*fn)(const char *name, void *data),
+                             void *data);
+const OSSL_PARAM *EVP_KEYEXCH_gettable_ctx_params(const EVP_KEYEXCH *keyexch);
+const OSSL_PARAM *EVP_KEYEXCH_settable_ctx_params(const EVP_KEYEXCH *keyexch);
+
+void EVP_add_alg_module(void);
+
+int EVP_PKEY_CTX_set_group_name(EVP_PKEY_CTX *ctx, const char *name);
+int EVP_PKEY_CTX_get_group_name(EVP_PKEY_CTX *ctx, char *name, size_t namelen);
+int EVP_PKEY_get_group_name(const EVP_PKEY *pkey, char *name, size_t name_sz,
+                            size_t *gname_len);
+
+OSSL_LIB_CTX *EVP_PKEY_CTX_get0_libctx(EVP_PKEY_CTX *ctx);
+const char *EVP_PKEY_CTX_get0_propq(const EVP_PKEY_CTX *ctx);
+const OSSL_PROVIDER *EVP_PKEY_CTX_get0_provider(const EVP_PKEY_CTX *ctx);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/evperr.h b/CAPI/cpp/grpc/include/openssl/evperr.h
new file mode 100644
index 0000000..a5053f6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/evperr.h
@@ -0,0 +1,134 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_EVPERR_H
+# define OPENSSL_EVPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * EVP reason codes.
+ */
+# define EVP_R_AES_KEY_SETUP_FAILED                       143
+# define EVP_R_ARIA_KEY_SETUP_FAILED                      176
+# define EVP_R_BAD_ALGORITHM_NAME                         200
+# define EVP_R_BAD_DECRYPT                                100
+# define EVP_R_BAD_KEY_LENGTH                             195
+# define EVP_R_BUFFER_TOO_SMALL                           155
+# define EVP_R_CACHE_CONSTANTS_FAILED                     225
+# define EVP_R_CAMELLIA_KEY_SETUP_FAILED                  157
+# define EVP_R_CANNOT_GET_PARAMETERS                      197
+# define EVP_R_CANNOT_SET_PARAMETERS                      198
+# define EVP_R_CIPHER_NOT_GCM_MODE                        184
+# define EVP_R_CIPHER_PARAMETER_ERROR                     122
+# define EVP_R_COMMAND_NOT_SUPPORTED                      147
+# define EVP_R_CONFLICTING_ALGORITHM_NAME                 201
+# define EVP_R_COPY_ERROR                                 173
+# define EVP_R_CTRL_NOT_IMPLEMENTED                       132
+# define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED             133
+# define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH          138
+# define EVP_R_DECODE_ERROR                               114
+# define EVP_R_DEFAULT_QUERY_PARSE_ERROR                  210
+# define EVP_R_DIFFERENT_KEY_TYPES                        101
+# define EVP_R_DIFFERENT_PARAMETERS                       153
+# define EVP_R_ERROR_LOADING_SECTION                      165
+# define EVP_R_EXPECTING_AN_HMAC_KEY                      174
+# define EVP_R_EXPECTING_AN_RSA_KEY                       127
+# define EVP_R_EXPECTING_A_DH_KEY                         128
+# define EVP_R_EXPECTING_A_DSA_KEY                        129
+# define EVP_R_EXPECTING_A_ECX_KEY                        219
+# define EVP_R_EXPECTING_A_EC_KEY                         142
+# define EVP_R_EXPECTING_A_POLY1305_KEY                   164
+# define EVP_R_EXPECTING_A_SIPHASH_KEY                    175
+# define EVP_R_FINAL_ERROR                                188
+# define EVP_R_GENERATE_ERROR                             214
+# define EVP_R_GET_RAW_KEY_FAILED                         182
+# define EVP_R_ILLEGAL_SCRYPT_PARAMETERS                  171
+# define EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS             204
+# define EVP_R_INACCESSIBLE_KEY                           203
+# define EVP_R_INITIALIZATION_ERROR                       134
+# define EVP_R_INPUT_NOT_INITIALIZED                      111
+# define EVP_R_INVALID_CUSTOM_LENGTH                      185
+# define EVP_R_INVALID_DIGEST                             152
+# define EVP_R_INVALID_IV_LENGTH                          194
+# define EVP_R_INVALID_KEY                                163
+# define EVP_R_INVALID_KEY_LENGTH                         130
+# define EVP_R_INVALID_LENGTH                             221
+# define EVP_R_INVALID_NULL_ALGORITHM                     218
+# define EVP_R_INVALID_OPERATION                          148
+# define EVP_R_INVALID_PROVIDER_FUNCTIONS                 193
+# define EVP_R_INVALID_SALT_LENGTH                        186
+# define EVP_R_INVALID_SECRET_LENGTH                      223
+# define EVP_R_INVALID_SEED_LENGTH                        220
+# define EVP_R_INVALID_VALUE                              222
+# define EVP_R_KEYMGMT_EXPORT_FAILURE                     205
+# define EVP_R_KEY_SETUP_FAILED                           180
+# define EVP_R_LOCKING_NOT_SUPPORTED                      213
+# define EVP_R_MEMORY_LIMIT_EXCEEDED                      172
+# define EVP_R_MESSAGE_DIGEST_IS_NULL                     159
+# define EVP_R_METHOD_NOT_SUPPORTED                       144
+# define EVP_R_MISSING_PARAMETERS                         103
+# define EVP_R_NOT_ABLE_TO_COPY_CTX                       190
+# define EVP_R_NOT_XOF_OR_INVALID_LENGTH                  178
+# define EVP_R_NO_CIPHER_SET                              131
+# define EVP_R_NO_DEFAULT_DIGEST                          158
+# define EVP_R_NO_DIGEST_SET                              139
+# define EVP_R_NO_IMPORT_FUNCTION                         206
+# define EVP_R_NO_KEYMGMT_AVAILABLE                       199
+# define EVP_R_NO_KEYMGMT_PRESENT                         196
+# define EVP_R_NO_KEY_SET                                 154
+# define EVP_R_NO_OPERATION_SET                           149
+# define EVP_R_NULL_MAC_PKEY_CTX                          208
+# define EVP_R_ONLY_ONESHOT_SUPPORTED                     177
+# define EVP_R_OPERATION_NOT_INITIALIZED                  151
+# define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE   150
+# define EVP_R_OUTPUT_WOULD_OVERFLOW                      202
+# define EVP_R_PARAMETER_TOO_LARGE                        187
+# define EVP_R_PARTIALLY_OVERLAPPING                      162
+# define EVP_R_PBKDF2_ERROR                               181
+# define EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED 179
+# define EVP_R_PRIVATE_KEY_DECODE_ERROR                   145
+# define EVP_R_PRIVATE_KEY_ENCODE_ERROR                   146
+# define EVP_R_PUBLIC_KEY_NOT_RSA                         106
+# define EVP_R_SETTING_XOF_FAILED                         227
+# define EVP_R_SET_DEFAULT_PROPERTY_FAILURE               209
+# define EVP_R_TOO_MANY_RECORDS                           183
+# define EVP_R_UNABLE_TO_ENABLE_LOCKING                   212
+# define EVP_R_UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE         215
+# define EVP_R_UNABLE_TO_GET_RANDOM_STRENGTH              216
+# define EVP_R_UNABLE_TO_LOCK_CONTEXT                     211
+# define EVP_R_UNABLE_TO_SET_CALLBACKS                    217
+# define EVP_R_UNKNOWN_CIPHER                             160
+# define EVP_R_UNKNOWN_DIGEST                             161
+# define EVP_R_UNKNOWN_KEY_TYPE                           207
+# define EVP_R_UNKNOWN_OPTION                             169
+# define EVP_R_UNKNOWN_PBE_ALGORITHM                      121
+# define EVP_R_UNSUPPORTED_ALGORITHM                      156
+# define EVP_R_UNSUPPORTED_CIPHER                         107
+# define EVP_R_UNSUPPORTED_KEYLENGTH                      123
+# define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION        124
+# define EVP_R_UNSUPPORTED_KEY_SIZE                       108
+# define EVP_R_UNSUPPORTED_KEY_TYPE                       224
+# define EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS               135
+# define EVP_R_UNSUPPORTED_PRF                            125
+# define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM          118
+# define EVP_R_UNSUPPORTED_SALT_TYPE                      126
+# define EVP_R_UPDATE_ERROR                               189
+# define EVP_R_WRAP_MODE_NOT_ALLOWED                      170
+# define EVP_R_WRONG_FINAL_BLOCK_LENGTH                   109
+# define EVP_R_XTS_DATA_UNIT_IS_TOO_LARGE                 191
+# define EVP_R_XTS_DUPLICATED_KEYS                        192
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/fips_names.h b/CAPI/cpp/grpc/include/openssl/fips_names.h
new file mode 100644
index 0000000..0fdf544
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/fips_names.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_FIPS_NAMES_H
+# define OPENSSL_FIPS_NAMES_H
+# pragma once
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/*
+ * Parameter names that the FIPS Provider defines
+ */
+
+/*
+ * The calculated MAC of the module file (Used for FIPS Self Testing)
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_MODULE_MAC      "module-mac"
+/*
+ * A version number for the fips install process (Used for FIPS Self Testing)
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_INSTALL_VERSION "install-version"
+/*
+ * The calculated MAC of the install status indicator (Used for FIPS Self Testing)
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_INSTALL_MAC     "install-mac"
+/*
+ * The install status indicator (Used for FIPS Self Testing)
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_INSTALL_STATUS  "install-status"
+
+/*
+ * A boolean that determines if the FIPS conditional test errors result in
+ * the module entering an error state.
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_CONDITIONAL_ERRORS "conditional-errors"
+
+/*
+ * A boolean that determines if the runtime FIPS security checks are performed.
+ * Type: OSSL_PARAM_UTF8_STRING
+ */
+# define OSSL_PROV_FIPS_PARAM_SECURITY_CHECKS "security-checks"
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif /* OPENSSL_FIPS_NAMES_H */
diff --git a/CAPI/cpp/grpc/include/openssl/fipskey.h b/CAPI/cpp/grpc/include/openssl/fipskey.h
new file mode 100644
index 0000000..ccc1d2f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/fipskey.h
@@ -0,0 +1,36 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\fipskey.h.in
+ *
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_FIPSKEY_H
+# define OPENSSL_FIPSKEY_H
+# pragma once
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * The FIPS validation HMAC key, usable as an array initializer.
+ */
+#define FIPS_KEY_ELEMENTS \
+    0xf4, 0x55, 0x66, 0x50, 0xac, 0x31, 0xd3, 0x54, 0x61, 0x61, 0x0b, 0xac, 0x4e, 0xd8, 0x1b, 0x1a, 0x18, 0x1b, 0x2d, 0x8a, 0x43, 0xea, 0x28, 0x54, 0xcb, 0xae, 0x22, 0xca, 0x74, 0x56, 0x08, 0x13
+
+/*
+ * The FIPS validation key, as a string.
+ */
+#define FIPS_KEY_STRING "f4556650ac31d35461610bac4ed81b1a181b2d8a43ea2854cbae22ca74560813"
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/hmac.h b/CAPI/cpp/grpc/include/openssl/hmac.h
new file mode 100644
index 0000000..f9e1bff
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/hmac.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_HMAC_H
+# define OPENSSL_HMAC_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_HMAC_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# include <openssl/evp.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HMAC_MAX_MD_CBLOCK      200    /* Deprecated */
+# endif
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 size_t HMAC_size(const HMAC_CTX *e);
+OSSL_DEPRECATEDIN_3_0 HMAC_CTX *HMAC_CTX_new(void);
+OSSL_DEPRECATEDIN_3_0 int HMAC_CTX_reset(HMAC_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_free(HMAC_CTX *ctx);
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur int HMAC_Init(HMAC_CTX *ctx,
+                                             const void *key, int len,
+                                             const EVP_MD *md);
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
+                                       const EVP_MD *md, ENGINE *impl);
+OSSL_DEPRECATEDIN_3_0 int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data,
+                                      size_t len);
+OSSL_DEPRECATEDIN_3_0 int HMAC_Final(HMAC_CTX *ctx, unsigned char *md,
+                                     unsigned int *len);
+OSSL_DEPRECATEDIN_3_0 __owur int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);
+OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags);
+OSSL_DEPRECATEDIN_3_0 const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx);
+# endif
+
+unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
+                    const unsigned char *data, size_t data_len,
+                    unsigned char *md, unsigned int *md_len);
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/http.h b/CAPI/cpp/grpc/include/openssl/http.h
new file mode 100644
index 0000000..f7ab214
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/http.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright Siemens AG 2018-2020
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_HTTP_H
+# define OPENSSL_HTTP_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+
+# include <openssl/bio.h>
+# include <openssl/asn1.h>
+# include <openssl/conf.h>
+
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+# define OSSL_HTTP_NAME "http"
+# define OSSL_HTTPS_NAME "https"
+# define OSSL_HTTP_PREFIX OSSL_HTTP_NAME"://"
+# define OSSL_HTTPS_PREFIX OSSL_HTTPS_NAME"://"
+# define OSSL_HTTP_PORT "80"
+# define OSSL_HTTPS_PORT "443"
+# define OPENSSL_NO_PROXY "NO_PROXY"
+# define OPENSSL_HTTP_PROXY "HTTP_PROXY"
+# define OPENSSL_HTTPS_PROXY "HTTPS_PROXY"
+
+#define OSSL_HTTP_DEFAULT_MAX_LINE_LEN (4 * 1024)
+#define OSSL_HTTP_DEFAULT_MAX_RESP_LEN (100 * 1024)
+
+/* Low-level HTTP API */
+OSSL_HTTP_REQ_CTX *OSSL_HTTP_REQ_CTX_new(BIO *wbio, BIO *rbio, int buf_size);
+void OSSL_HTTP_REQ_CTX_free(OSSL_HTTP_REQ_CTX *rctx);
+int OSSL_HTTP_REQ_CTX_set_request_line(OSSL_HTTP_REQ_CTX *rctx, int method_POST,
+                                       const char *server, const char *port,
+                                       const char *path);
+int OSSL_HTTP_REQ_CTX_add1_header(OSSL_HTTP_REQ_CTX *rctx,
+                                  const char *name, const char *value);
+int OSSL_HTTP_REQ_CTX_set_expected(OSSL_HTTP_REQ_CTX *rctx,
+                                   const char *content_type, int asn1,
+                                   int timeout, int keep_alive);
+int OSSL_HTTP_REQ_CTX_set1_req(OSSL_HTTP_REQ_CTX *rctx, const char *content_type,
+                               const ASN1_ITEM *it, const ASN1_VALUE *req);
+int OSSL_HTTP_REQ_CTX_nbio(OSSL_HTTP_REQ_CTX *rctx);
+int OSSL_HTTP_REQ_CTX_nbio_d2i(OSSL_HTTP_REQ_CTX *rctx,
+                               ASN1_VALUE **pval, const ASN1_ITEM *it);
+BIO *OSSL_HTTP_REQ_CTX_exchange(OSSL_HTTP_REQ_CTX *rctx);
+BIO *OSSL_HTTP_REQ_CTX_get0_mem_bio(const OSSL_HTTP_REQ_CTX *rctx);
+size_t OSSL_HTTP_REQ_CTX_get_resp_len(const OSSL_HTTP_REQ_CTX *rctx);
+void OSSL_HTTP_REQ_CTX_set_max_response_length(OSSL_HTTP_REQ_CTX *rctx,
+                                               unsigned long len);
+int OSSL_HTTP_is_alive(const OSSL_HTTP_REQ_CTX *rctx);
+
+/* High-level HTTP API */
+typedef BIO *(*OSSL_HTTP_bio_cb_t)(BIO *bio, void *arg, int connect, int detail);
+OSSL_HTTP_REQ_CTX *OSSL_HTTP_open(const char *server, const char *port,
+                                  const char *proxy, const char *no_proxy,
+                                  int use_ssl, BIO *bio, BIO *rbio,
+                                  OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
+                                  int buf_size, int overall_timeout);
+int OSSL_HTTP_proxy_connect(BIO *bio, const char *server, const char *port,
+                            const char *proxyuser, const char *proxypass,
+                            int timeout, BIO *bio_err, const char *prog);
+int OSSL_HTTP_set1_request(OSSL_HTTP_REQ_CTX *rctx, const char *path,
+                           const STACK_OF(CONF_VALUE) *headers,
+                           const char *content_type, BIO *req,
+                           const char *expected_content_type, int expect_asn1,
+                           size_t max_resp_len, int timeout, int keep_alive);
+BIO *OSSL_HTTP_exchange(OSSL_HTTP_REQ_CTX *rctx, char **redirection_url);
+BIO *OSSL_HTTP_get(const char *url, const char *proxy, const char *no_proxy,
+                   BIO *bio, BIO *rbio,
+                   OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
+                   int buf_size, const STACK_OF(CONF_VALUE) *headers,
+                   const char *expected_content_type, int expect_asn1,
+                   size_t max_resp_len, int timeout);
+BIO *OSSL_HTTP_transfer(OSSL_HTTP_REQ_CTX **prctx,
+                        const char *server, const char *port,
+                        const char *path, int use_ssl,
+                        const char *proxy, const char *no_proxy,
+                        BIO *bio, BIO *rbio,
+                        OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
+                        int buf_size, const STACK_OF(CONF_VALUE) *headers,
+                        const char *content_type, BIO *req,
+                        const char *expected_content_type, int expect_asn1,
+                        size_t max_resp_len, int timeout, int keep_alive);
+int OSSL_HTTP_close(OSSL_HTTP_REQ_CTX *rctx, int ok);
+
+/* Auxiliary functions */
+int OSSL_parse_url(const char *url, char **pscheme, char **puser, char **phost,
+                   char **pport, int *pport_num,
+                   char **ppath, char **pquery, char **pfrag);
+int OSSL_HTTP_parse_url(const char *url, int *pssl, char **puser, char **phost,
+                        char **pport, int *pport_num,
+                        char **ppath, char **pquery, char **pfrag);
+const char *OSSL_HTTP_adapt_proxy(const char *proxy, const char *no_proxy,
+                                  const char *server, int use_ssl);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif /* !defined(OPENSSL_HTTP_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/httperr.h b/CAPI/cpp/grpc/include/openssl/httperr.h
new file mode 100644
index 0000000..ee08959
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/httperr.h
@@ -0,0 +1,55 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_HTTPERR_H
+# define OPENSSL_HTTPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * HTTP reason codes.
+ */
+# define HTTP_R_ASN1_LEN_EXCEEDS_MAX_RESP_LEN             108
+# define HTTP_R_CONNECT_FAILURE                           100
+# define HTTP_R_ERROR_PARSING_ASN1_LENGTH                 109
+# define HTTP_R_ERROR_PARSING_CONTENT_LENGTH              119
+# define HTTP_R_ERROR_PARSING_URL                         101
+# define HTTP_R_ERROR_RECEIVING                           103
+# define HTTP_R_ERROR_SENDING                             102
+# define HTTP_R_FAILED_READING_DATA                       128
+# define HTTP_R_HEADER_PARSE_ERROR                        126
+# define HTTP_R_INCONSISTENT_CONTENT_LENGTH               120
+# define HTTP_R_INVALID_PORT_NUMBER                       123
+# define HTTP_R_INVALID_URL_PATH                          125
+# define HTTP_R_INVALID_URL_SCHEME                        124
+# define HTTP_R_MAX_RESP_LEN_EXCEEDED                     117
+# define HTTP_R_MISSING_ASN1_ENCODING                     110
+# define HTTP_R_MISSING_CONTENT_TYPE                      121
+# define HTTP_R_MISSING_REDIRECT_LOCATION                 111
+# define HTTP_R_RECEIVED_ERROR                            105
+# define HTTP_R_RECEIVED_WRONG_HTTP_VERSION               106
+# define HTTP_R_REDIRECTION_FROM_HTTPS_TO_HTTP            112
+# define HTTP_R_REDIRECTION_NOT_ENABLED                   116
+# define HTTP_R_RESPONSE_LINE_TOO_LONG                    113
+# define HTTP_R_RESPONSE_PARSE_ERROR                      104
+# define HTTP_R_RETRY_TIMEOUT                             129
+# define HTTP_R_SERVER_CANCELED_CONNECTION                127
+# define HTTP_R_SOCK_NOT_SUPPORTED                        122
+# define HTTP_R_STATUS_CODE_UNSUPPORTED                   114
+# define HTTP_R_TLS_NOT_ENABLED                           107
+# define HTTP_R_TOO_MANY_REDIRECTIONS                     115
+# define HTTP_R_UNEXPECTED_CONTENT_TYPE                   118
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/idea.h b/CAPI/cpp/grpc/include/openssl/idea.h
new file mode 100644
index 0000000..1f9bb3b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/idea.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_IDEA_H
+# define OPENSSL_IDEA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_IDEA_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_IDEA
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define IDEA_BLOCK      8
+#  define IDEA_KEY_LENGTH 16
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+
+typedef unsigned int IDEA_INT;
+
+#   define IDEA_ENCRYPT    1
+#   define IDEA_DECRYPT    0
+
+typedef struct idea_key_st {
+    IDEA_INT data[9][6];
+} IDEA_KEY_SCHEDULE;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *IDEA_options(void);
+OSSL_DEPRECATEDIN_3_0 void IDEA_ecb_encrypt(const unsigned char *in,
+                                            unsigned char *out,
+                                            IDEA_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0 void IDEA_set_encrypt_key(const unsigned char *key,
+                                                IDEA_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0 void IDEA_set_decrypt_key(IDEA_KEY_SCHEDULE *ek,
+                                                IDEA_KEY_SCHEDULE *dk);
+OSSL_DEPRECATEDIN_3_0 void IDEA_cbc_encrypt(const unsigned char *in,
+                                            unsigned char *out, long length,
+                                            IDEA_KEY_SCHEDULE *ks,
+                                            unsigned char *iv, int enc);
+OSSL_DEPRECATEDIN_3_0 void IDEA_cfb64_encrypt(const unsigned char *in,
+                                              unsigned char *out, long length,
+                                              IDEA_KEY_SCHEDULE *ks,
+                                              unsigned char *iv, int *num,
+                                              int enc);
+OSSL_DEPRECATEDIN_3_0 void IDEA_ofb64_encrypt(const unsigned char *in,
+                                              unsigned char *out, long length,
+                                              IDEA_KEY_SCHEDULE *ks,
+                                              unsigned char *iv, int *num);
+OSSL_DEPRECATEDIN_3_0 void IDEA_encrypt(unsigned long *in,
+                                        IDEA_KEY_SCHEDULE *ks);
+#endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   define idea_options          IDEA_options
+#   define idea_ecb_encrypt      IDEA_ecb_encrypt
+#   define idea_set_encrypt_key  IDEA_set_encrypt_key
+#   define idea_set_decrypt_key  IDEA_set_decrypt_key
+#   define idea_cbc_encrypt      IDEA_cbc_encrypt
+#   define idea_cfb64_encrypt    IDEA_cfb64_encrypt
+#   define idea_ofb64_encrypt    IDEA_ofb64_encrypt
+#   define idea_encrypt          IDEA_encrypt
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/kdf.h b/CAPI/cpp/grpc/include/openssl/kdf.h
new file mode 100644
index 0000000..0983230
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/kdf.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_KDF_H
+# define OPENSSL_KDF_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_KDF_H
+# endif
+
+# include <stdarg.h>
+# include <stddef.h>
+# include <openssl/types.h>
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+int EVP_KDF_up_ref(EVP_KDF *kdf);
+void EVP_KDF_free(EVP_KDF *kdf);
+EVP_KDF *EVP_KDF_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
+                       const char *properties);
+
+EVP_KDF_CTX *EVP_KDF_CTX_new(EVP_KDF *kdf);
+void EVP_KDF_CTX_free(EVP_KDF_CTX *ctx);
+EVP_KDF_CTX *EVP_KDF_CTX_dup(const EVP_KDF_CTX *src);
+const char *EVP_KDF_get0_description(const EVP_KDF *kdf);
+int EVP_KDF_is_a(const EVP_KDF *kdf, const char *name);
+const char *EVP_KDF_get0_name(const EVP_KDF *kdf);
+const OSSL_PROVIDER *EVP_KDF_get0_provider(const EVP_KDF *kdf);
+const EVP_KDF *EVP_KDF_CTX_kdf(EVP_KDF_CTX *ctx);
+
+void EVP_KDF_CTX_reset(EVP_KDF_CTX *ctx);
+size_t EVP_KDF_CTX_get_kdf_size(EVP_KDF_CTX *ctx);
+int EVP_KDF_derive(EVP_KDF_CTX *ctx, unsigned char *key, size_t keylen,
+                   const OSSL_PARAM params[]);
+int EVP_KDF_get_params(EVP_KDF *kdf, OSSL_PARAM params[]);
+int EVP_KDF_CTX_get_params(EVP_KDF_CTX *ctx, OSSL_PARAM params[]);
+int EVP_KDF_CTX_set_params(EVP_KDF_CTX *ctx, const OSSL_PARAM params[]);
+const OSSL_PARAM *EVP_KDF_gettable_params(const EVP_KDF *kdf);
+const OSSL_PARAM *EVP_KDF_gettable_ctx_params(const EVP_KDF *kdf);
+const OSSL_PARAM *EVP_KDF_settable_ctx_params(const EVP_KDF *kdf);
+const OSSL_PARAM *EVP_KDF_CTX_gettable_params(EVP_KDF_CTX *ctx);
+const OSSL_PARAM *EVP_KDF_CTX_settable_params(EVP_KDF_CTX *ctx);
+
+void EVP_KDF_do_all_provided(OSSL_LIB_CTX *libctx,
+                             void (*fn)(EVP_KDF *kdf, void *arg),
+                             void *arg);
+int EVP_KDF_names_do_all(const EVP_KDF *kdf,
+                         void (*fn)(const char *name, void *data),
+                         void *data);
+
+# define EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND  0
+# define EVP_KDF_HKDF_MODE_EXTRACT_ONLY        1
+# define EVP_KDF_HKDF_MODE_EXPAND_ONLY         2
+
+#define EVP_KDF_SSHKDF_TYPE_INITIAL_IV_CLI_TO_SRV     65
+#define EVP_KDF_SSHKDF_TYPE_INITIAL_IV_SRV_TO_CLI     66
+#define EVP_KDF_SSHKDF_TYPE_ENCRYPTION_KEY_CLI_TO_SRV 67
+#define EVP_KDF_SSHKDF_TYPE_ENCRYPTION_KEY_SRV_TO_CLI 68
+#define EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_CLI_TO_SRV  69
+#define EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_SRV_TO_CLI  70
+
+/**** The legacy PKEY-based KDF API follows. ****/
+
+# define EVP_PKEY_CTRL_TLS_MD                   (EVP_PKEY_ALG_CTRL)
+# define EVP_PKEY_CTRL_TLS_SECRET               (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_TLS_SEED                 (EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_HKDF_MD                  (EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_HKDF_SALT                (EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_HKDF_KEY                 (EVP_PKEY_ALG_CTRL + 5)
+# define EVP_PKEY_CTRL_HKDF_INFO                (EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_HKDF_MODE                (EVP_PKEY_ALG_CTRL + 7)
+# define EVP_PKEY_CTRL_PASS                     (EVP_PKEY_ALG_CTRL + 8)
+# define EVP_PKEY_CTRL_SCRYPT_SALT              (EVP_PKEY_ALG_CTRL + 9)
+# define EVP_PKEY_CTRL_SCRYPT_N                 (EVP_PKEY_ALG_CTRL + 10)
+# define EVP_PKEY_CTRL_SCRYPT_R                 (EVP_PKEY_ALG_CTRL + 11)
+# define EVP_PKEY_CTRL_SCRYPT_P                 (EVP_PKEY_ALG_CTRL + 12)
+# define EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES      (EVP_PKEY_ALG_CTRL + 13)
+
+# define EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND \
+            EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND
+# define EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY       \
+            EVP_KDF_HKDF_MODE_EXTRACT_ONLY
+# define EVP_PKEY_HKDEF_MODE_EXPAND_ONLY        \
+            EVP_KDF_HKDF_MODE_EXPAND_ONLY
+
+int EVP_PKEY_CTX_set_tls1_prf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+
+int EVP_PKEY_CTX_set1_tls1_prf_secret(EVP_PKEY_CTX *pctx,
+                                      const unsigned char *sec, int seclen);
+
+int EVP_PKEY_CTX_add1_tls1_prf_seed(EVP_PKEY_CTX *pctx,
+                                    const unsigned char *seed, int seedlen);
+
+int EVP_PKEY_CTX_set_hkdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+
+int EVP_PKEY_CTX_set1_hkdf_salt(EVP_PKEY_CTX *ctx,
+                                const unsigned char *salt, int saltlen);
+
+int EVP_PKEY_CTX_set1_hkdf_key(EVP_PKEY_CTX *ctx,
+                               const unsigned char *key, int keylen);
+
+int EVP_PKEY_CTX_add1_hkdf_info(EVP_PKEY_CTX *ctx,
+                                const unsigned char *info, int infolen);
+
+int EVP_PKEY_CTX_set_hkdf_mode(EVP_PKEY_CTX *ctx, int mode);
+# define EVP_PKEY_CTX_hkdf_mode EVP_PKEY_CTX_set_hkdf_mode
+
+int EVP_PKEY_CTX_set1_pbe_pass(EVP_PKEY_CTX *ctx, const char *pass,
+                               int passlen);
+
+int EVP_PKEY_CTX_set1_scrypt_salt(EVP_PKEY_CTX *ctx,
+                                  const unsigned char *salt, int saltlen);
+
+int EVP_PKEY_CTX_set_scrypt_N(EVP_PKEY_CTX *ctx, uint64_t n);
+
+int EVP_PKEY_CTX_set_scrypt_r(EVP_PKEY_CTX *ctx, uint64_t r);
+
+int EVP_PKEY_CTX_set_scrypt_p(EVP_PKEY_CTX *ctx, uint64_t p);
+
+int EVP_PKEY_CTX_set_scrypt_maxmem_bytes(EVP_PKEY_CTX *ctx,
+                                         uint64_t maxmem_bytes);
+
+
+# ifdef __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/kdferr.h b/CAPI/cpp/grpc/include/openssl/kdferr.h
new file mode 100644
index 0000000..963d766
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/kdferr.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_KDFERR_H
+# define OPENSSL_KDFERR_H
+# pragma once
+
+#include <openssl/cryptoerr_legacy.h>
+
+#endif /* !defined(OPENSSL_KDFERR_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/lhash.h b/CAPI/cpp/grpc/include/openssl/lhash.h
new file mode 100644
index 0000000..39dd625
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/lhash.h
@@ -0,0 +1,288 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+/*
+ * Header for dynamic hash table routines Author - Eric Young
+ */
+
+#ifndef OPENSSL_LHASH_H
+# define OPENSSL_LHASH_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_LHASH_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/bio.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct lhash_node_st OPENSSL_LH_NODE;
+typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *);
+typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *);
+typedef void (*OPENSSL_LH_DOALL_FUNC) (void *);
+typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *);
+typedef struct lhash_st OPENSSL_LHASH;
+
+/*
+ * Macros for declaring and implementing type-safe wrappers for LHASH
+ * callbacks. This way, callbacks can be provided to LHASH structures without
+ * function pointer casting and the macro-defined callbacks provide
+ * per-variable casting before deferring to the underlying type-specific
+ * callbacks. NB: It is possible to place a "static" in front of both the
+ * DECLARE and IMPLEMENT macros if the functions are strictly internal.
+ */
+
+/* First: "hash" functions */
+# define DECLARE_LHASH_HASH_FN(name, o_type) \
+        unsigned long name##_LHASH_HASH(const void *);
+# define IMPLEMENT_LHASH_HASH_FN(name, o_type) \
+        unsigned long name##_LHASH_HASH(const void *arg) { \
+                const o_type *a = arg; \
+                return name##_hash(a); }
+# define LHASH_HASH_FN(name) name##_LHASH_HASH
+
+/* Second: "compare" functions */
+# define DECLARE_LHASH_COMP_FN(name, o_type) \
+        int name##_LHASH_COMP(const void *, const void *);
+# define IMPLEMENT_LHASH_COMP_FN(name, o_type) \
+        int name##_LHASH_COMP(const void *arg1, const void *arg2) { \
+                const o_type *a = arg1;             \
+                const o_type *b = arg2; \
+                return name##_cmp(a,b); }
+# define LHASH_COMP_FN(name) name##_LHASH_COMP
+
+/* Fourth: "doall_arg" functions */
+# define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
+        void name##_LHASH_DOALL_ARG(void *, void *);
+# define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
+        void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \
+                o_type *a = arg1; \
+                a_type *b = arg2; \
+                name##_doall_arg(a, b); }
+# define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG
+
+
+# define LH_LOAD_MULT    256
+
+int OPENSSL_LH_error(OPENSSL_LHASH *lh);
+OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c);
+void OPENSSL_LH_free(OPENSSL_LHASH *lh);
+void OPENSSL_LH_flush(OPENSSL_LHASH *lh);
+void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data);
+void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data);
+void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data);
+void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func);
+void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg);
+unsigned long OPENSSL_LH_strhash(const char *c);
+unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh);
+unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh);
+void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load);
+
+# ifndef OPENSSL_NO_STDIO
+void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp);
+void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp);
+void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp);
+# endif
+void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define _LHASH OPENSSL_LHASH
+#  define LHASH_NODE OPENSSL_LH_NODE
+#  define lh_error OPENSSL_LH_error
+#  define lh_new OPENSSL_LH_new
+#  define lh_free OPENSSL_LH_free
+#  define lh_insert OPENSSL_LH_insert
+#  define lh_delete OPENSSL_LH_delete
+#  define lh_retrieve OPENSSL_LH_retrieve
+#  define lh_doall OPENSSL_LH_doall
+#  define lh_doall_arg OPENSSL_LH_doall_arg
+#  define lh_strhash OPENSSL_LH_strhash
+#  define lh_num_items OPENSSL_LH_num_items
+#  ifndef OPENSSL_NO_STDIO
+#   define lh_stats OPENSSL_LH_stats
+#   define lh_node_stats OPENSSL_LH_node_stats
+#   define lh_node_usage_stats OPENSSL_LH_node_usage_stats
+#  endif
+#  define lh_stats_bio OPENSSL_LH_stats_bio
+#  define lh_node_stats_bio OPENSSL_LH_node_stats_bio
+#  define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio
+# endif
+
+/* Type checking... */
+
+# define LHASH_OF(type) struct lhash_st_##type
+
+/* Helper macro for internal use */
+# define DEFINE_LHASH_OF_INTERNAL(type) \
+    LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \
+    typedef int (*lh_##type##_compfunc)(const type *a, const type *b); \
+    typedef unsigned long (*lh_##type##_hashfunc)(const type *a); \
+    typedef void (*lh_##type##_doallfunc)(type *a); \
+    static ossl_unused ossl_inline type *ossl_check_##type##_lh_plain_type(type *ptr) \
+    { \
+        return ptr; \
+    } \
+    static ossl_unused ossl_inline const type *ossl_check_const_##type##_lh_plain_type(const type *ptr) \
+    { \
+        return ptr; \
+    } \
+    static ossl_unused ossl_inline const OPENSSL_LHASH *ossl_check_const_##type##_lh_type(const LHASH_OF(type) *lh) \
+    { \
+        return (const OPENSSL_LHASH *)lh; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_LHASH *ossl_check_##type##_lh_type(LHASH_OF(type) *lh) \
+    { \
+        return (OPENSSL_LHASH *)lh; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_LH_COMPFUNC ossl_check_##type##_lh_compfunc_type(lh_##type##_compfunc cmp) \
+    { \
+        return (OPENSSL_LH_COMPFUNC)cmp; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_LH_HASHFUNC ossl_check_##type##_lh_hashfunc_type(lh_##type##_hashfunc hfn) \
+    { \
+        return (OPENSSL_LH_HASHFUNC)hfn; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_LH_DOALL_FUNC ossl_check_##type##_lh_doallfunc_type(lh_##type##_doallfunc dfn) \
+    { \
+        return (OPENSSL_LH_DOALL_FUNC)dfn; \
+    } \
+    LHASH_OF(type)
+
+# define DEFINE_LHASH_OF(type) \
+    LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \
+    static ossl_unused ossl_inline LHASH_OF(type) *lh_##type##_new(unsigned long (*hfn)(const type *), \
+                                                                   int (*cfn)(const type *, const type *)) \
+    { \
+        return (LHASH_OF(type) *) \
+            OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); \
+    } \
+    static ossl_unused ossl_inline void lh_##type##_free(LHASH_OF(type) *lh) \
+    { \
+        OPENSSL_LH_free((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline void lh_##type##_flush(LHASH_OF(type) *lh) \
+    { \
+        OPENSSL_LH_flush((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline type *lh_##type##_insert(LHASH_OF(type) *lh, type *d) \
+    { \
+        return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \
+    } \
+    static ossl_unused ossl_inline type *lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \
+    { \
+        return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \
+    } \
+    static ossl_unused ossl_inline type *lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \
+    { \
+        return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \
+    } \
+    static ossl_unused ossl_inline int lh_##type##_error(LHASH_OF(type) *lh) \
+    { \
+        return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) *lh) \
+    { \
+        return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
+    { \
+        OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \
+    } \
+    static ossl_unused ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
+    { \
+        OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \
+    } \
+    static ossl_unused ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
+    { \
+        OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \
+    } \
+    static ossl_unused ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) *lh) \
+    { \
+        return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \
+    } \
+    static ossl_unused ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \
+    { \
+        OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \
+    } \
+    static ossl_unused ossl_inline void lh_##type##_doall(LHASH_OF(type) *lh, \
+                                                          void (*doall)(type *)) \
+    { \
+        OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \
+    } \
+    static ossl_unused ossl_inline void lh_##type##_doall_arg(LHASH_OF(type) *lh, \
+                                                              void (*doallarg)(type *, void *), \
+                                                              void *arg) \
+    { \
+        OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, \
+                             (OPENSSL_LH_DOALL_FUNCARG)doallarg, arg); \
+    } \
+    LHASH_OF(type)
+
+#define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \
+    int_implement_lhash_doall(type, argtype, const type)
+
+#define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \
+    int_implement_lhash_doall(type, argtype, type)
+
+#define int_implement_lhash_doall(type, argtype, cbargtype) \
+    static ossl_unused ossl_inline void \
+        lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \
+                                   void (*fn)(cbargtype *, argtype *), \
+                                   argtype *arg) \
+    { \
+        OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void *)arg); \
+    } \
+    LHASH_OF(type)
+
+DEFINE_LHASH_OF_INTERNAL(OPENSSL_STRING);
+#define lh_OPENSSL_STRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_STRING) *)OPENSSL_LH_new(ossl_check_OPENSSL_STRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_STRING_lh_compfunc_type(cmp)))
+#define lh_OPENSSL_STRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_insert(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_delete(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_retrieve(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
+#define lh_OPENSSL_STRING_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
+#define lh_OPENSSL_STRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
+#define lh_OPENSSL_STRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_STRING_lh_type(lh))
+#define lh_OPENSSL_STRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_STRING_lh_type(lh), dl)
+#define lh_OPENSSL_STRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_doallfunc_type(dfn))
+DEFINE_LHASH_OF_INTERNAL(OPENSSL_CSTRING);
+#define lh_OPENSSL_CSTRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_CSTRING) *)OPENSSL_LH_new(ossl_check_OPENSSL_CSTRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_CSTRING_lh_compfunc_type(cmp)))
+#define lh_OPENSSL_CSTRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_insert(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_delete(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_retrieve(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
+#define lh_OPENSSL_CSTRING_node_usage_stats_bio(lh, out) OPENSSL_LH_node_usage_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
+#define lh_OPENSSL_CSTRING_stats_bio(lh, out) OPENSSL_LH_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
+#define lh_OPENSSL_CSTRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh))
+#define lh_OPENSSL_CSTRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh), dl)
+#define lh_OPENSSL_CSTRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_doallfunc_type(dfn))
+
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/macros.h b/CAPI/cpp/grpc/include/openssl/macros.h
new file mode 100644
index 0000000..a6bc3f1
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/macros.h
@@ -0,0 +1,304 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MACROS_H
+# define OPENSSL_MACROS_H
+# pragma once
+
+#include <openssl/opensslconf.h>
+#include <openssl/opensslv.h>
+
+
+/* Helper macros for CPP string composition */
+# define OPENSSL_MSTR_HELPER(x) #x
+# define OPENSSL_MSTR(x) OPENSSL_MSTR_HELPER(x)
+
+/*
+ * Sometimes OPENSSL_NO_xxx ends up with an empty file and some compilers
+ * don't like that.  This will hopefully silence them.
+ */
+# define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy;
+
+/*
+ * Generic deprecation macro
+ *
+ * If OPENSSL_SUPPRESS_DEPRECATED is defined, then OSSL_DEPRECATED and
+ * OSSL_DEPRECATED_FOR become no-ops
+ */
+# ifndef OSSL_DEPRECATED
+#  undef OSSL_DEPRECATED_FOR
+#  ifndef OPENSSL_SUPPRESS_DEPRECATED
+#   if defined(_MSC_VER)
+     /*
+      * MSVC supports __declspec(deprecated) since MSVC 2003 (13.10),
+      * and __declspec(deprecated(message)) since MSVC 2005 (14.00)
+      */
+#    if _MSC_VER >= 1400
+#     define OSSL_DEPRECATED(since) \
+          __declspec(deprecated("Since OpenSSL " # since))
+#     define OSSL_DEPRECATED_FOR(since, message) \
+          __declspec(deprecated("Since OpenSSL " # since ";" message))
+#    elif _MSC_VER >= 1310
+#     define OSSL_DEPRECATED(since) __declspec(deprecated)
+#     define OSSL_DEPRECATED_FOR(since, message) __declspec(deprecated)
+#    endif
+#   elif defined(__GNUC__)
+     /*
+      * According to GCC documentation, deprecations with message appeared in
+      * GCC 4.5.0
+      */
+#    if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#     define OSSL_DEPRECATED(since) \
+          __attribute__((deprecated("Since OpenSSL " # since)))
+#     define OSSL_DEPRECATED_FOR(since, message) \
+          __attribute__((deprecated("Since OpenSSL " # since ";" message)))
+#    elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
+#     define OSSL_DEPRECATED(since) __attribute__((deprecated))
+#     define OSSL_DEPRECATED_FOR(since, message) __attribute__((deprecated))
+#    endif
+#   elif defined(__SUNPRO_C)
+#    if (__SUNPRO_C >= 0x5130)
+#     define OSSL_DEPRECATED(since) __attribute__ ((deprecated))
+#     define OSSL_DEPRECATED_FOR(since, message) __attribute__ ((deprecated))
+#    endif
+#   endif
+#  endif
+# endif
+
+/*
+ * Still not defined?  Then define no-op macros. This means these macros
+ * are unsuitable for use in a typedef.
+ */
+# ifndef OSSL_DEPRECATED
+#  define OSSL_DEPRECATED(since)                extern
+#  define OSSL_DEPRECATED_FOR(since, message)   extern
+# endif
+
+/*
+ * Applications should use -DOPENSSL_API_COMPAT=<version> to suppress the
+ * declarations of functions deprecated in or before <version>.  If this is
+ * undefined, the value of the macro OPENSSL_CONFIGURED_API (defined in
+ * <openssl/opensslconf.h>) is the default.
+ *
+ * For any version number up until version 1.1.x, <version> is expected to be
+ * the calculated version number 0xMNNFFPPSL.
+ * For version numbers 3.0 and on, <version> is expected to be a computation
+ * of the major and minor numbers in decimal using this formula:
+ *
+ *     MAJOR * 10000 + MINOR * 100
+ *
+ * So version 3.0 becomes 30000, version 3.2 becomes 30200, etc.
+ */
+
+/*
+ * We use the OPENSSL_API_COMPAT value to define API level macros.  These
+ * macros are used to enable or disable features at that API version boundary.
+ */
+
+# ifdef OPENSSL_API_LEVEL
+#  error "OPENSSL_API_LEVEL must not be defined by application"
+# endif
+
+/*
+ * We figure out what API level was intended by simple numeric comparison.
+ * The lowest old style number we recognise is 0x00908000L, so we take some
+ * safety margin and assume that anything below 0x00900000L is a new style
+ * number.  This allows new versions up to and including v943.71.83.
+ */
+# ifdef OPENSSL_API_COMPAT
+#  if OPENSSL_API_COMPAT < 0x900000L
+#   define OPENSSL_API_LEVEL (OPENSSL_API_COMPAT)
+#  else
+#   define OPENSSL_API_LEVEL                            \
+           (((OPENSSL_API_COMPAT >> 28) & 0xF) * 10000  \
+            + ((OPENSSL_API_COMPAT >> 20) & 0xFF) * 100 \
+            + ((OPENSSL_API_COMPAT >> 12) & 0xFF))
+#  endif
+# endif
+
+/*
+ * If OPENSSL_API_COMPAT wasn't given, we use default numbers to set
+ * the API compatibility level.
+ */
+# ifndef OPENSSL_API_LEVEL
+#  if OPENSSL_CONFIGURED_API > 0
+#   define OPENSSL_API_LEVEL (OPENSSL_CONFIGURED_API)
+#  else
+#   define OPENSSL_API_LEVEL \
+           (OPENSSL_VERSION_MAJOR * 10000 + OPENSSL_VERSION_MINOR * 100)
+#  endif
+# endif
+
+# if OPENSSL_API_LEVEL > OPENSSL_CONFIGURED_API
+#  error "The requested API level higher than the configured API compatibility level"
+# endif
+
+/*
+ * Check of sane values.
+ */
+/* Can't go higher than the current version. */
+# if OPENSSL_API_LEVEL > (OPENSSL_VERSION_MAJOR * 10000 + OPENSSL_VERSION_MINOR * 100)
+#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+# endif
+/* OpenSSL will have no version 2.y.z */
+# if OPENSSL_API_LEVEL < 30000 && OPENSSL_API_LEVEL >= 20000
+#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+# endif
+/* Below 0.9.8 is unacceptably low */
+# if OPENSSL_API_LEVEL < 908
+#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+# endif
+
+/*
+ * Define macros for deprecation and simulated removal purposes.
+ *
+ * The macros OSSL_DEPRECATED_{major}_{minor} are always defined for
+ * all OpenSSL versions we care for.  They can be used as attributes
+ * in function declarations where appropriate.
+ *
+ * The macros OPENSSL_NO_DEPRECATED_{major}_{minor} are defined for
+ * all OpenSSL versions up to or equal to the version given with
+ * OPENSSL_API_COMPAT.  They are used as guards around anything that's
+ * deprecated up to that version, as an effect of the developer option
+ * 'no-deprecated'.
+ */
+
+# undef OPENSSL_NO_DEPRECATED_3_0
+# undef OPENSSL_NO_DEPRECATED_1_1_1
+# undef OPENSSL_NO_DEPRECATED_1_1_0
+# undef OPENSSL_NO_DEPRECATED_1_0_2
+# undef OPENSSL_NO_DEPRECATED_1_0_1
+# undef OPENSSL_NO_DEPRECATED_1_0_0
+# undef OPENSSL_NO_DEPRECATED_0_9_8
+
+# if OPENSSL_API_LEVEL >= 30000
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_3_0                OSSL_DEPRECATED(3.0)
+#   define OSSL_DEPRECATEDIN_3_0_FOR(msg)       OSSL_DEPRECATED_FOR(3.0, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_3_0
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_3_0
+#  define OSSL_DEPRECATEDIN_3_0_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10101
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_1_1              OSSL_DEPRECATED(1.1.1)
+#   define OSSL_DEPRECATEDIN_1_1_1_FOR(msg)     OSSL_DEPRECATED_FOR(1.1.1, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_1_1
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_1_1
+#  define OSSL_DEPRECATEDIN_1_1_1_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10100
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_1_0              OSSL_DEPRECATED(1.1.0)
+#   define OSSL_DEPRECATEDIN_1_1_0_FOR(msg)     OSSL_DEPRECATED_FOR(1.1.0, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_1_0
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_1_0
+#  define OSSL_DEPRECATEDIN_1_1_0_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10002
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_0_2              OSSL_DEPRECATED(1.0.2)
+#   define OSSL_DEPRECATEDIN_1_0_2_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.2, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_0_2
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_0_2
+#  define OSSL_DEPRECATEDIN_1_0_2_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10001
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_0_1              OSSL_DEPRECATED(1.0.1)
+#   define OSSL_DEPRECATEDIN_1_0_1_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.1, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_0_1
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_0_1
+#  define OSSL_DEPRECATEDIN_1_0_1_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 10000
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_1_0_0              OSSL_DEPRECATED(1.0.0)
+#   define OSSL_DEPRECATEDIN_1_0_0_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.0, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_1_0_0
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_1_0_0
+#  define OSSL_DEPRECATEDIN_1_0_0_FOR(msg)
+# endif
+# if OPENSSL_API_LEVEL >= 908
+#  ifndef OPENSSL_NO_DEPRECATED
+#   define OSSL_DEPRECATEDIN_0_9_8              OSSL_DEPRECATED(0.9.8)
+#   define OSSL_DEPRECATEDIN_0_9_8_FOR(msg)     OSSL_DEPRECATED_FOR(0.9.8, msg)
+#  else
+#   define OPENSSL_NO_DEPRECATED_0_9_8
+#  endif
+# else
+#  define OSSL_DEPRECATEDIN_0_9_8
+#  define OSSL_DEPRECATEDIN_0_9_8_FOR(msg)
+# endif
+
+/*
+ * Make our own variants of __FILE__ and __LINE__, depending on configuration
+ */
+
+# ifndef OPENSSL_FILE
+#  ifdef OPENSSL_NO_FILENAMES
+#   define OPENSSL_FILE ""
+#   define OPENSSL_LINE 0
+#  else
+#   define OPENSSL_FILE __FILE__
+#   define OPENSSL_LINE __LINE__
+#  endif
+# endif
+
+/*
+ * __func__ was standardized in C99, so for any compiler that claims
+ * to implement that language level or newer, we assume we can safely
+ * use that symbol.
+ *
+ * GNU C also provides __FUNCTION__ since version 2, which predates
+ * C99.  We can, however, only use this if __STDC_VERSION__ exists,
+ * as it's otherwise not allowed according to ISO C standards (C90).
+ * (compiling with GNU C's -pedantic tells us so)
+ *
+ * If none of the above applies, we check if the compiler is MSVC,
+ * and use __FUNCTION__ if that's the case.
+ */
+# ifndef OPENSSL_FUNC
+#  if defined(__STDC_VERSION__)
+#   if __STDC_VERSION__ >= 199901L
+#    define OPENSSL_FUNC __func__
+#   elif defined(__GNUC__) && __GNUC__ >= 2
+#    define OPENSSL_FUNC __FUNCTION__
+#   endif
+#  elif defined(_MSC_VER)
+#    define OPENSSL_FUNC __FUNCTION__
+#  endif
+/*
+ * If all these possibilities are exhausted, we give up and use a
+ * static string.
+ */
+#  ifndef OPENSSL_FUNC
+#   define OPENSSL_FUNC "(unknown function)"
+#  endif
+# endif
+
+#endif  /* OPENSSL_MACROS_H */
diff --git a/CAPI/cpp/grpc/include/openssl/md2.h b/CAPI/cpp/grpc/include/openssl/md2.h
new file mode 100644
index 0000000..5d4cb77
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/md2.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MD2_H
+# define OPENSSL_MD2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MD2_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_MD2
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define MD2_DIGEST_LENGTH       16
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+typedef unsigned char MD2_INT;
+
+#   define MD2_BLOCK               16
+
+typedef struct MD2state_st {
+    unsigned int num;
+    unsigned char data[MD2_BLOCK];
+    MD2_INT cksm[MD2_BLOCK];
+    MD2_INT state[MD2_BLOCK];
+} MD2_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *MD2_options(void);
+OSSL_DEPRECATEDIN_3_0 int MD2_Init(MD2_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int MD2_Update(MD2_CTX *c, const unsigned char *data,
+                                     size_t len);
+OSSL_DEPRECATEDIN_3_0 int MD2_Final(unsigned char *md, MD2_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *MD2(const unsigned char *d, size_t n,
+                                         unsigned char *md);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/md4.h b/CAPI/cpp/grpc/include/openssl/md4.h
new file mode 100644
index 0000000..6c150a6
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/md4.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MD4_H
+# define OPENSSL_MD4_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MD4_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_MD4
+#  include <openssl/e_os2.h>
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C" {
+#   endif
+
+#  define MD4_DIGEST_LENGTH 16
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+/*-
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! MD4_LONG has to be at least 32 bits wide.                     !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#   define MD4_LONG unsigned int
+
+#   define MD4_CBLOCK      64
+#   define MD4_LBLOCK      (MD4_CBLOCK/4)
+
+typedef struct MD4state_st {
+    MD4_LONG A, B, C, D;
+    MD4_LONG Nl, Nh;
+    MD4_LONG data[MD4_LBLOCK];
+    unsigned int num;
+} MD4_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int MD4_Init(MD4_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int MD4_Update(MD4_CTX *c, const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int MD4_Final(unsigned char *md, MD4_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *MD4(const unsigned char *d, size_t n,
+                                         unsigned char *md);
+OSSL_DEPRECATEDIN_3_0 void MD4_Transform(MD4_CTX *c, const unsigned char *b);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/md5.h b/CAPI/cpp/grpc/include/openssl/md5.h
new file mode 100644
index 0000000..77a5773
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/md5.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MD5_H
+# define OPENSSL_MD5_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MD5_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_MD5
+#  include <openssl/e_os2.h>
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define MD5_DIGEST_LENGTH 16
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+/*
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! MD5_LONG has to be at least 32 bits wide.                     !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#   define MD5_LONG unsigned int
+
+#   define MD5_CBLOCK      64
+#   define MD5_LBLOCK      (MD5_CBLOCK/4)
+
+typedef struct MD5state_st {
+    MD5_LONG A, B, C, D;
+    MD5_LONG Nl, Nh;
+    MD5_LONG data[MD5_LBLOCK];
+    unsigned int num;
+} MD5_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int MD5_Init(MD5_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int MD5_Update(MD5_CTX *c, const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int MD5_Final(unsigned char *md, MD5_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *MD5(const unsigned char *d, size_t n,
+                                         unsigned char *md);
+OSSL_DEPRECATEDIN_3_0 void MD5_Transform(MD5_CTX *c, const unsigned char *b);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/mdc2.h b/CAPI/cpp/grpc/include/openssl/mdc2.h
new file mode 100644
index 0000000..5a7ee28
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/mdc2.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MDC2_H
+# define OPENSSL_MDC2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MDC2_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_MDC2
+#  include <stdlib.h>
+#  include <openssl/des.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define MDC2_DIGEST_LENGTH      16
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#   define MDC2_BLOCK              8
+
+typedef struct mdc2_ctx_st {
+    unsigned int num;
+    unsigned char data[MDC2_BLOCK];
+    DES_cblock h, hh;
+    unsigned int pad_type;   /* either 1 or 2, default 1 */
+} MDC2_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int MDC2_Init(MDC2_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int MDC2_Update(MDC2_CTX *c, const unsigned char *data,
+                                      size_t len);
+OSSL_DEPRECATEDIN_3_0 int MDC2_Final(unsigned char *md, MDC2_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *MDC2(const unsigned char *d, size_t n,
+                                          unsigned char *md);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/modes.h b/CAPI/cpp/grpc/include/openssl/modes.h
new file mode 100644
index 0000000..e190799
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/modes.h
@@ -0,0 +1,219 @@
+/*
+ * Copyright 2008-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_MODES_H
+# define OPENSSL_MODES_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_MODES_H
+# endif
+
+# include <stddef.h>
+# include <openssl/types.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+typedef void (*block128_f) (const unsigned char in[16],
+                            unsigned char out[16], const void *key);
+
+typedef void (*cbc128_f) (const unsigned char *in, unsigned char *out,
+                          size_t len, const void *key,
+                          unsigned char ivec[16], int enc);
+
+typedef void (*ecb128_f) (const unsigned char *in, unsigned char *out,
+                          size_t len, const void *key,
+                          int enc);
+
+typedef void (*ctr128_f) (const unsigned char *in, unsigned char *out,
+                          size_t blocks, const void *key,
+                          const unsigned char ivec[16]);
+
+typedef void (*ccm128_f) (const unsigned char *in, unsigned char *out,
+                          size_t blocks, const void *key,
+                          const unsigned char ivec[16],
+                          unsigned char cmac[16]);
+
+void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16], block128_f block);
+void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16], block128_f block);
+
+void CRYPTO_ctr128_encrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16],
+                           unsigned char ecount_buf[16], unsigned int *num,
+                           block128_f block);
+
+void CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out,
+                                 size_t len, const void *key,
+                                 unsigned char ivec[16],
+                                 unsigned char ecount_buf[16],
+                                 unsigned int *num, ctr128_f ctr);
+
+void CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16], int *num,
+                           block128_f block);
+
+void CRYPTO_cfb128_encrypt(const unsigned char *in, unsigned char *out,
+                           size_t len, const void *key,
+                           unsigned char ivec[16], int *num,
+                           int enc, block128_f block);
+void CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out,
+                             size_t length, const void *key,
+                             unsigned char ivec[16], int *num,
+                             int enc, block128_f block);
+void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out,
+                             size_t bits, const void *key,
+                             unsigned char ivec[16], int *num,
+                             int enc, block128_f block);
+
+size_t CRYPTO_cts128_encrypt_block(const unsigned char *in,
+                                   unsigned char *out, size_t len,
+                                   const void *key, unsigned char ivec[16],
+                                   block128_f block);
+size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out,
+                             size_t len, const void *key,
+                             unsigned char ivec[16], cbc128_f cbc);
+size_t CRYPTO_cts128_decrypt_block(const unsigned char *in,
+                                   unsigned char *out, size_t len,
+                                   const void *key, unsigned char ivec[16],
+                                   block128_f block);
+size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out,
+                             size_t len, const void *key,
+                             unsigned char ivec[16], cbc128_f cbc);
+
+size_t CRYPTO_nistcts128_encrypt_block(const unsigned char *in,
+                                       unsigned char *out, size_t len,
+                                       const void *key,
+                                       unsigned char ivec[16],
+                                       block128_f block);
+size_t CRYPTO_nistcts128_encrypt(const unsigned char *in, unsigned char *out,
+                                 size_t len, const void *key,
+                                 unsigned char ivec[16], cbc128_f cbc);
+size_t CRYPTO_nistcts128_decrypt_block(const unsigned char *in,
+                                       unsigned char *out, size_t len,
+                                       const void *key,
+                                       unsigned char ivec[16],
+                                       block128_f block);
+size_t CRYPTO_nistcts128_decrypt(const unsigned char *in, unsigned char *out,
+                                 size_t len, const void *key,
+                                 unsigned char ivec[16], cbc128_f cbc);
+
+typedef struct gcm128_context GCM128_CONTEXT;
+
+GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block);
+void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key, block128_f block);
+void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv,
+                         size_t len);
+int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad,
+                      size_t len);
+int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx,
+                          const unsigned char *in, unsigned char *out,
+                          size_t len);
+int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
+                          const unsigned char *in, unsigned char *out,
+                          size_t len);
+int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx,
+                                const unsigned char *in, unsigned char *out,
+                                size_t len, ctr128_f stream);
+int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
+                                const unsigned char *in, unsigned char *out,
+                                size_t len, ctr128_f stream);
+int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag,
+                         size_t len);
+void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, unsigned char *tag, size_t len);
+void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx);
+
+typedef struct ccm128_context CCM128_CONTEXT;
+
+void CRYPTO_ccm128_init(CCM128_CONTEXT *ctx,
+                        unsigned int M, unsigned int L, void *key,
+                        block128_f block);
+int CRYPTO_ccm128_setiv(CCM128_CONTEXT *ctx, const unsigned char *nonce,
+                        size_t nlen, size_t mlen);
+void CRYPTO_ccm128_aad(CCM128_CONTEXT *ctx, const unsigned char *aad,
+                       size_t alen);
+int CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx, const unsigned char *inp,
+                          unsigned char *out, size_t len);
+int CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx, const unsigned char *inp,
+                          unsigned char *out, size_t len);
+int CRYPTO_ccm128_encrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp,
+                                unsigned char *out, size_t len,
+                                ccm128_f stream);
+int CRYPTO_ccm128_decrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp,
+                                unsigned char *out, size_t len,
+                                ccm128_f stream);
+size_t CRYPTO_ccm128_tag(CCM128_CONTEXT *ctx, unsigned char *tag, size_t len);
+
+typedef struct xts128_context XTS128_CONTEXT;
+
+int CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx,
+                          const unsigned char iv[16],
+                          const unsigned char *inp, unsigned char *out,
+                          size_t len, int enc);
+
+size_t CRYPTO_128_wrap(void *key, const unsigned char *iv,
+                       unsigned char *out,
+                       const unsigned char *in, size_t inlen,
+                       block128_f block);
+
+size_t CRYPTO_128_unwrap(void *key, const unsigned char *iv,
+                         unsigned char *out,
+                         const unsigned char *in, size_t inlen,
+                         block128_f block);
+size_t CRYPTO_128_wrap_pad(void *key, const unsigned char *icv,
+                           unsigned char *out, const unsigned char *in,
+                           size_t inlen, block128_f block);
+size_t CRYPTO_128_unwrap_pad(void *key, const unsigned char *icv,
+                             unsigned char *out, const unsigned char *in,
+                             size_t inlen, block128_f block);
+
+# ifndef OPENSSL_NO_OCB
+typedef struct ocb128_context OCB128_CONTEXT;
+
+typedef void (*ocb128_f) (const unsigned char *in, unsigned char *out,
+                          size_t blocks, const void *key,
+                          size_t start_block_num,
+                          unsigned char offset_i[16],
+                          const unsigned char L_[][16],
+                          unsigned char checksum[16]);
+
+OCB128_CONTEXT *CRYPTO_ocb128_new(void *keyenc, void *keydec,
+                                  block128_f encrypt, block128_f decrypt,
+                                  ocb128_f stream);
+int CRYPTO_ocb128_init(OCB128_CONTEXT *ctx, void *keyenc, void *keydec,
+                       block128_f encrypt, block128_f decrypt,
+                       ocb128_f stream);
+int CRYPTO_ocb128_copy_ctx(OCB128_CONTEXT *dest, OCB128_CONTEXT *src,
+                           void *keyenc, void *keydec);
+int CRYPTO_ocb128_setiv(OCB128_CONTEXT *ctx, const unsigned char *iv,
+                        size_t len, size_t taglen);
+int CRYPTO_ocb128_aad(OCB128_CONTEXT *ctx, const unsigned char *aad,
+                      size_t len);
+int CRYPTO_ocb128_encrypt(OCB128_CONTEXT *ctx, const unsigned char *in,
+                          unsigned char *out, size_t len);
+int CRYPTO_ocb128_decrypt(OCB128_CONTEXT *ctx, const unsigned char *in,
+                          unsigned char *out, size_t len);
+int CRYPTO_ocb128_finish(OCB128_CONTEXT *ctx, const unsigned char *tag,
+                         size_t len);
+int CRYPTO_ocb128_tag(OCB128_CONTEXT *ctx, unsigned char *tag, size_t len);
+void CRYPTO_ocb128_cleanup(OCB128_CONTEXT *ctx);
+# endif                          /* OPENSSL_NO_OCB */
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/obj_mac.h b/CAPI/cpp/grpc/include/openssl/obj_mac.h
new file mode 100644
index 0000000..0e86027
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/obj_mac.h
@@ -0,0 +1,5481 @@
+/*
+ * WARNING: do not edit!
+ * Generated by crypto/objects/objects.pl
+ *
+ * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OBJ_MAC_H
+# define OPENSSL_OBJ_MAC_H
+# pragma once
+
+#define SN_undef                        "UNDEF"
+#define LN_undef                        "undefined"
+#define NID_undef                       0
+#define OBJ_undef                       0L
+
+#define SN_itu_t                "ITU-T"
+#define LN_itu_t                "itu-t"
+#define NID_itu_t               645
+#define OBJ_itu_t               0L
+
+#define NID_ccitt               404
+#define OBJ_ccitt               OBJ_itu_t
+
+#define SN_iso          "ISO"
+#define LN_iso          "iso"
+#define NID_iso         181
+#define OBJ_iso         1L
+
+#define SN_joint_iso_itu_t              "JOINT-ISO-ITU-T"
+#define LN_joint_iso_itu_t              "joint-iso-itu-t"
+#define NID_joint_iso_itu_t             646
+#define OBJ_joint_iso_itu_t             2L
+
+#define NID_joint_iso_ccitt             393
+#define OBJ_joint_iso_ccitt             OBJ_joint_iso_itu_t
+
+#define SN_member_body          "member-body"
+#define LN_member_body          "ISO Member Body"
+#define NID_member_body         182
+#define OBJ_member_body         OBJ_iso,2L
+
+#define SN_identified_organization              "identified-organization"
+#define NID_identified_organization             676
+#define OBJ_identified_organization             OBJ_iso,3L
+
+#define SN_gmac         "GMAC"
+#define LN_gmac         "gmac"
+#define NID_gmac                1195
+#define OBJ_gmac                OBJ_iso,0L,9797L,3L,4L
+
+#define SN_hmac_md5             "HMAC-MD5"
+#define LN_hmac_md5             "hmac-md5"
+#define NID_hmac_md5            780
+#define OBJ_hmac_md5            OBJ_identified_organization,6L,1L,5L,5L,8L,1L,1L
+
+#define SN_hmac_sha1            "HMAC-SHA1"
+#define LN_hmac_sha1            "hmac-sha1"
+#define NID_hmac_sha1           781
+#define OBJ_hmac_sha1           OBJ_identified_organization,6L,1L,5L,5L,8L,1L,2L
+
+#define SN_x509ExtAdmission             "x509ExtAdmission"
+#define LN_x509ExtAdmission             "Professional Information or basis for Admission"
+#define NID_x509ExtAdmission            1093
+#define OBJ_x509ExtAdmission            OBJ_identified_organization,36L,8L,3L,3L
+
+#define SN_certicom_arc         "certicom-arc"
+#define NID_certicom_arc                677
+#define OBJ_certicom_arc                OBJ_identified_organization,132L
+
+#define SN_ieee         "ieee"
+#define NID_ieee                1170
+#define OBJ_ieee                OBJ_identified_organization,111L
+
+#define SN_ieee_siswg           "ieee-siswg"
+#define LN_ieee_siswg           "IEEE Security in Storage Working Group"
+#define NID_ieee_siswg          1171
+#define OBJ_ieee_siswg          OBJ_ieee,2L,1619L
+
+#define SN_international_organizations          "international-organizations"
+#define LN_international_organizations          "International Organizations"
+#define NID_international_organizations         647
+#define OBJ_international_organizations         OBJ_joint_iso_itu_t,23L
+
+#define SN_wap          "wap"
+#define NID_wap         678
+#define OBJ_wap         OBJ_international_organizations,43L
+
+#define SN_wap_wsg              "wap-wsg"
+#define NID_wap_wsg             679
+#define OBJ_wap_wsg             OBJ_wap,1L
+
+#define SN_selected_attribute_types             "selected-attribute-types"
+#define LN_selected_attribute_types             "Selected Attribute Types"
+#define NID_selected_attribute_types            394
+#define OBJ_selected_attribute_types            OBJ_joint_iso_itu_t,5L,1L,5L
+
+#define SN_clearance            "clearance"
+#define NID_clearance           395
+#define OBJ_clearance           OBJ_selected_attribute_types,55L
+
+#define SN_ISO_US               "ISO-US"
+#define LN_ISO_US               "ISO US Member Body"
+#define NID_ISO_US              183
+#define OBJ_ISO_US              OBJ_member_body,840L
+
+#define SN_X9_57                "X9-57"
+#define LN_X9_57                "X9.57"
+#define NID_X9_57               184
+#define OBJ_X9_57               OBJ_ISO_US,10040L
+
+#define SN_X9cm         "X9cm"
+#define LN_X9cm         "X9.57 CM ?"
+#define NID_X9cm                185
+#define OBJ_X9cm                OBJ_X9_57,4L
+
+#define SN_ISO_CN               "ISO-CN"
+#define LN_ISO_CN               "ISO CN Member Body"
+#define NID_ISO_CN              1140
+#define OBJ_ISO_CN              OBJ_member_body,156L
+
+#define SN_oscca                "oscca"
+#define NID_oscca               1141
+#define OBJ_oscca               OBJ_ISO_CN,10197L
+
+#define SN_sm_scheme            "sm-scheme"
+#define NID_sm_scheme           1142
+#define OBJ_sm_scheme           OBJ_oscca,1L
+
+#define SN_dsa          "DSA"
+#define LN_dsa          "dsaEncryption"
+#define NID_dsa         116
+#define OBJ_dsa         OBJ_X9cm,1L
+
+#define SN_dsaWithSHA1          "DSA-SHA1"
+#define LN_dsaWithSHA1          "dsaWithSHA1"
+#define NID_dsaWithSHA1         113
+#define OBJ_dsaWithSHA1         OBJ_X9cm,3L
+
+#define SN_ansi_X9_62           "ansi-X9-62"
+#define LN_ansi_X9_62           "ANSI X9.62"
+#define NID_ansi_X9_62          405
+#define OBJ_ansi_X9_62          OBJ_ISO_US,10045L
+
+#define OBJ_X9_62_id_fieldType          OBJ_ansi_X9_62,1L
+
+#define SN_X9_62_prime_field            "prime-field"
+#define NID_X9_62_prime_field           406
+#define OBJ_X9_62_prime_field           OBJ_X9_62_id_fieldType,1L
+
+#define SN_X9_62_characteristic_two_field               "characteristic-two-field"
+#define NID_X9_62_characteristic_two_field              407
+#define OBJ_X9_62_characteristic_two_field              OBJ_X9_62_id_fieldType,2L
+
+#define SN_X9_62_id_characteristic_two_basis            "id-characteristic-two-basis"
+#define NID_X9_62_id_characteristic_two_basis           680
+#define OBJ_X9_62_id_characteristic_two_basis           OBJ_X9_62_characteristic_two_field,3L
+
+#define SN_X9_62_onBasis                "onBasis"
+#define NID_X9_62_onBasis               681
+#define OBJ_X9_62_onBasis               OBJ_X9_62_id_characteristic_two_basis,1L
+
+#define SN_X9_62_tpBasis                "tpBasis"
+#define NID_X9_62_tpBasis               682
+#define OBJ_X9_62_tpBasis               OBJ_X9_62_id_characteristic_two_basis,2L
+
+#define SN_X9_62_ppBasis                "ppBasis"
+#define NID_X9_62_ppBasis               683
+#define OBJ_X9_62_ppBasis               OBJ_X9_62_id_characteristic_two_basis,3L
+
+#define OBJ_X9_62_id_publicKeyType              OBJ_ansi_X9_62,2L
+
+#define SN_X9_62_id_ecPublicKey         "id-ecPublicKey"
+#define NID_X9_62_id_ecPublicKey                408
+#define OBJ_X9_62_id_ecPublicKey                OBJ_X9_62_id_publicKeyType,1L
+
+#define OBJ_X9_62_ellipticCurve         OBJ_ansi_X9_62,3L
+
+#define OBJ_X9_62_c_TwoCurve            OBJ_X9_62_ellipticCurve,0L
+
+#define SN_X9_62_c2pnb163v1             "c2pnb163v1"
+#define NID_X9_62_c2pnb163v1            684
+#define OBJ_X9_62_c2pnb163v1            OBJ_X9_62_c_TwoCurve,1L
+
+#define SN_X9_62_c2pnb163v2             "c2pnb163v2"
+#define NID_X9_62_c2pnb163v2            685
+#define OBJ_X9_62_c2pnb163v2            OBJ_X9_62_c_TwoCurve,2L
+
+#define SN_X9_62_c2pnb163v3             "c2pnb163v3"
+#define NID_X9_62_c2pnb163v3            686
+#define OBJ_X9_62_c2pnb163v3            OBJ_X9_62_c_TwoCurve,3L
+
+#define SN_X9_62_c2pnb176v1             "c2pnb176v1"
+#define NID_X9_62_c2pnb176v1            687
+#define OBJ_X9_62_c2pnb176v1            OBJ_X9_62_c_TwoCurve,4L
+
+#define SN_X9_62_c2tnb191v1             "c2tnb191v1"
+#define NID_X9_62_c2tnb191v1            688
+#define OBJ_X9_62_c2tnb191v1            OBJ_X9_62_c_TwoCurve,5L
+
+#define SN_X9_62_c2tnb191v2             "c2tnb191v2"
+#define NID_X9_62_c2tnb191v2            689
+#define OBJ_X9_62_c2tnb191v2            OBJ_X9_62_c_TwoCurve,6L
+
+#define SN_X9_62_c2tnb191v3             "c2tnb191v3"
+#define NID_X9_62_c2tnb191v3            690
+#define OBJ_X9_62_c2tnb191v3            OBJ_X9_62_c_TwoCurve,7L
+
+#define SN_X9_62_c2onb191v4             "c2onb191v4"
+#define NID_X9_62_c2onb191v4            691
+#define OBJ_X9_62_c2onb191v4            OBJ_X9_62_c_TwoCurve,8L
+
+#define SN_X9_62_c2onb191v5             "c2onb191v5"
+#define NID_X9_62_c2onb191v5            692
+#define OBJ_X9_62_c2onb191v5            OBJ_X9_62_c_TwoCurve,9L
+
+#define SN_X9_62_c2pnb208w1             "c2pnb208w1"
+#define NID_X9_62_c2pnb208w1            693
+#define OBJ_X9_62_c2pnb208w1            OBJ_X9_62_c_TwoCurve,10L
+
+#define SN_X9_62_c2tnb239v1             "c2tnb239v1"
+#define NID_X9_62_c2tnb239v1            694
+#define OBJ_X9_62_c2tnb239v1            OBJ_X9_62_c_TwoCurve,11L
+
+#define SN_X9_62_c2tnb239v2             "c2tnb239v2"
+#define NID_X9_62_c2tnb239v2            695
+#define OBJ_X9_62_c2tnb239v2            OBJ_X9_62_c_TwoCurve,12L
+
+#define SN_X9_62_c2tnb239v3             "c2tnb239v3"
+#define NID_X9_62_c2tnb239v3            696
+#define OBJ_X9_62_c2tnb239v3            OBJ_X9_62_c_TwoCurve,13L
+
+#define SN_X9_62_c2onb239v4             "c2onb239v4"
+#define NID_X9_62_c2onb239v4            697
+#define OBJ_X9_62_c2onb239v4            OBJ_X9_62_c_TwoCurve,14L
+
+#define SN_X9_62_c2onb239v5             "c2onb239v5"
+#define NID_X9_62_c2onb239v5            698
+#define OBJ_X9_62_c2onb239v5            OBJ_X9_62_c_TwoCurve,15L
+
+#define SN_X9_62_c2pnb272w1             "c2pnb272w1"
+#define NID_X9_62_c2pnb272w1            699
+#define OBJ_X9_62_c2pnb272w1            OBJ_X9_62_c_TwoCurve,16L
+
+#define SN_X9_62_c2pnb304w1             "c2pnb304w1"
+#define NID_X9_62_c2pnb304w1            700
+#define OBJ_X9_62_c2pnb304w1            OBJ_X9_62_c_TwoCurve,17L
+
+#define SN_X9_62_c2tnb359v1             "c2tnb359v1"
+#define NID_X9_62_c2tnb359v1            701
+#define OBJ_X9_62_c2tnb359v1            OBJ_X9_62_c_TwoCurve,18L
+
+#define SN_X9_62_c2pnb368w1             "c2pnb368w1"
+#define NID_X9_62_c2pnb368w1            702
+#define OBJ_X9_62_c2pnb368w1            OBJ_X9_62_c_TwoCurve,19L
+
+#define SN_X9_62_c2tnb431r1             "c2tnb431r1"
+#define NID_X9_62_c2tnb431r1            703
+#define OBJ_X9_62_c2tnb431r1            OBJ_X9_62_c_TwoCurve,20L
+
+#define OBJ_X9_62_primeCurve            OBJ_X9_62_ellipticCurve,1L
+
+#define SN_X9_62_prime192v1             "prime192v1"
+#define NID_X9_62_prime192v1            409
+#define OBJ_X9_62_prime192v1            OBJ_X9_62_primeCurve,1L
+
+#define SN_X9_62_prime192v2             "prime192v2"
+#define NID_X9_62_prime192v2            410
+#define OBJ_X9_62_prime192v2            OBJ_X9_62_primeCurve,2L
+
+#define SN_X9_62_prime192v3             "prime192v3"
+#define NID_X9_62_prime192v3            411
+#define OBJ_X9_62_prime192v3            OBJ_X9_62_primeCurve,3L
+
+#define SN_X9_62_prime239v1             "prime239v1"
+#define NID_X9_62_prime239v1            412
+#define OBJ_X9_62_prime239v1            OBJ_X9_62_primeCurve,4L
+
+#define SN_X9_62_prime239v2             "prime239v2"
+#define NID_X9_62_prime239v2            413
+#define OBJ_X9_62_prime239v2            OBJ_X9_62_primeCurve,5L
+
+#define SN_X9_62_prime239v3             "prime239v3"
+#define NID_X9_62_prime239v3            414
+#define OBJ_X9_62_prime239v3            OBJ_X9_62_primeCurve,6L
+
+#define SN_X9_62_prime256v1             "prime256v1"
+#define NID_X9_62_prime256v1            415
+#define OBJ_X9_62_prime256v1            OBJ_X9_62_primeCurve,7L
+
+#define OBJ_X9_62_id_ecSigType          OBJ_ansi_X9_62,4L
+
+#define SN_ecdsa_with_SHA1              "ecdsa-with-SHA1"
+#define NID_ecdsa_with_SHA1             416
+#define OBJ_ecdsa_with_SHA1             OBJ_X9_62_id_ecSigType,1L
+
+#define SN_ecdsa_with_Recommended               "ecdsa-with-Recommended"
+#define NID_ecdsa_with_Recommended              791
+#define OBJ_ecdsa_with_Recommended              OBJ_X9_62_id_ecSigType,2L
+
+#define SN_ecdsa_with_Specified         "ecdsa-with-Specified"
+#define NID_ecdsa_with_Specified                792
+#define OBJ_ecdsa_with_Specified                OBJ_X9_62_id_ecSigType,3L
+
+#define SN_ecdsa_with_SHA224            "ecdsa-with-SHA224"
+#define NID_ecdsa_with_SHA224           793
+#define OBJ_ecdsa_with_SHA224           OBJ_ecdsa_with_Specified,1L
+
+#define SN_ecdsa_with_SHA256            "ecdsa-with-SHA256"
+#define NID_ecdsa_with_SHA256           794
+#define OBJ_ecdsa_with_SHA256           OBJ_ecdsa_with_Specified,2L
+
+#define SN_ecdsa_with_SHA384            "ecdsa-with-SHA384"
+#define NID_ecdsa_with_SHA384           795
+#define OBJ_ecdsa_with_SHA384           OBJ_ecdsa_with_Specified,3L
+
+#define SN_ecdsa_with_SHA512            "ecdsa-with-SHA512"
+#define NID_ecdsa_with_SHA512           796
+#define OBJ_ecdsa_with_SHA512           OBJ_ecdsa_with_Specified,4L
+
+#define OBJ_secg_ellipticCurve          OBJ_certicom_arc,0L
+
+#define SN_secp112r1            "secp112r1"
+#define NID_secp112r1           704
+#define OBJ_secp112r1           OBJ_secg_ellipticCurve,6L
+
+#define SN_secp112r2            "secp112r2"
+#define NID_secp112r2           705
+#define OBJ_secp112r2           OBJ_secg_ellipticCurve,7L
+
+#define SN_secp128r1            "secp128r1"
+#define NID_secp128r1           706
+#define OBJ_secp128r1           OBJ_secg_ellipticCurve,28L
+
+#define SN_secp128r2            "secp128r2"
+#define NID_secp128r2           707
+#define OBJ_secp128r2           OBJ_secg_ellipticCurve,29L
+
+#define SN_secp160k1            "secp160k1"
+#define NID_secp160k1           708
+#define OBJ_secp160k1           OBJ_secg_ellipticCurve,9L
+
+#define SN_secp160r1            "secp160r1"
+#define NID_secp160r1           709
+#define OBJ_secp160r1           OBJ_secg_ellipticCurve,8L
+
+#define SN_secp160r2            "secp160r2"
+#define NID_secp160r2           710
+#define OBJ_secp160r2           OBJ_secg_ellipticCurve,30L
+
+#define SN_secp192k1            "secp192k1"
+#define NID_secp192k1           711
+#define OBJ_secp192k1           OBJ_secg_ellipticCurve,31L
+
+#define SN_secp224k1            "secp224k1"
+#define NID_secp224k1           712
+#define OBJ_secp224k1           OBJ_secg_ellipticCurve,32L
+
+#define SN_secp224r1            "secp224r1"
+#define NID_secp224r1           713
+#define OBJ_secp224r1           OBJ_secg_ellipticCurve,33L
+
+#define SN_secp256k1            "secp256k1"
+#define NID_secp256k1           714
+#define OBJ_secp256k1           OBJ_secg_ellipticCurve,10L
+
+#define SN_secp384r1            "secp384r1"
+#define NID_secp384r1           715
+#define OBJ_secp384r1           OBJ_secg_ellipticCurve,34L
+
+#define SN_secp521r1            "secp521r1"
+#define NID_secp521r1           716
+#define OBJ_secp521r1           OBJ_secg_ellipticCurve,35L
+
+#define SN_sect113r1            "sect113r1"
+#define NID_sect113r1           717
+#define OBJ_sect113r1           OBJ_secg_ellipticCurve,4L
+
+#define SN_sect113r2            "sect113r2"
+#define NID_sect113r2           718
+#define OBJ_sect113r2           OBJ_secg_ellipticCurve,5L
+
+#define SN_sect131r1            "sect131r1"
+#define NID_sect131r1           719
+#define OBJ_sect131r1           OBJ_secg_ellipticCurve,22L
+
+#define SN_sect131r2            "sect131r2"
+#define NID_sect131r2           720
+#define OBJ_sect131r2           OBJ_secg_ellipticCurve,23L
+
+#define SN_sect163k1            "sect163k1"
+#define NID_sect163k1           721
+#define OBJ_sect163k1           OBJ_secg_ellipticCurve,1L
+
+#define SN_sect163r1            "sect163r1"
+#define NID_sect163r1           722
+#define OBJ_sect163r1           OBJ_secg_ellipticCurve,2L
+
+#define SN_sect163r2            "sect163r2"
+#define NID_sect163r2           723
+#define OBJ_sect163r2           OBJ_secg_ellipticCurve,15L
+
+#define SN_sect193r1            "sect193r1"
+#define NID_sect193r1           724
+#define OBJ_sect193r1           OBJ_secg_ellipticCurve,24L
+
+#define SN_sect193r2            "sect193r2"
+#define NID_sect193r2           725
+#define OBJ_sect193r2           OBJ_secg_ellipticCurve,25L
+
+#define SN_sect233k1            "sect233k1"
+#define NID_sect233k1           726
+#define OBJ_sect233k1           OBJ_secg_ellipticCurve,26L
+
+#define SN_sect233r1            "sect233r1"
+#define NID_sect233r1           727
+#define OBJ_sect233r1           OBJ_secg_ellipticCurve,27L
+
+#define SN_sect239k1            "sect239k1"
+#define NID_sect239k1           728
+#define OBJ_sect239k1           OBJ_secg_ellipticCurve,3L
+
+#define SN_sect283k1            "sect283k1"
+#define NID_sect283k1           729
+#define OBJ_sect283k1           OBJ_secg_ellipticCurve,16L
+
+#define SN_sect283r1            "sect283r1"
+#define NID_sect283r1           730
+#define OBJ_sect283r1           OBJ_secg_ellipticCurve,17L
+
+#define SN_sect409k1            "sect409k1"
+#define NID_sect409k1           731
+#define OBJ_sect409k1           OBJ_secg_ellipticCurve,36L
+
+#define SN_sect409r1            "sect409r1"
+#define NID_sect409r1           732
+#define OBJ_sect409r1           OBJ_secg_ellipticCurve,37L
+
+#define SN_sect571k1            "sect571k1"
+#define NID_sect571k1           733
+#define OBJ_sect571k1           OBJ_secg_ellipticCurve,38L
+
+#define SN_sect571r1            "sect571r1"
+#define NID_sect571r1           734
+#define OBJ_sect571r1           OBJ_secg_ellipticCurve,39L
+
+#define OBJ_wap_wsg_idm_ecid            OBJ_wap_wsg,4L
+
+#define SN_wap_wsg_idm_ecid_wtls1               "wap-wsg-idm-ecid-wtls1"
+#define NID_wap_wsg_idm_ecid_wtls1              735
+#define OBJ_wap_wsg_idm_ecid_wtls1              OBJ_wap_wsg_idm_ecid,1L
+
+#define SN_wap_wsg_idm_ecid_wtls3               "wap-wsg-idm-ecid-wtls3"
+#define NID_wap_wsg_idm_ecid_wtls3              736
+#define OBJ_wap_wsg_idm_ecid_wtls3              OBJ_wap_wsg_idm_ecid,3L
+
+#define SN_wap_wsg_idm_ecid_wtls4               "wap-wsg-idm-ecid-wtls4"
+#define NID_wap_wsg_idm_ecid_wtls4              737
+#define OBJ_wap_wsg_idm_ecid_wtls4              OBJ_wap_wsg_idm_ecid,4L
+
+#define SN_wap_wsg_idm_ecid_wtls5               "wap-wsg-idm-ecid-wtls5"
+#define NID_wap_wsg_idm_ecid_wtls5              738
+#define OBJ_wap_wsg_idm_ecid_wtls5              OBJ_wap_wsg_idm_ecid,5L
+
+#define SN_wap_wsg_idm_ecid_wtls6               "wap-wsg-idm-ecid-wtls6"
+#define NID_wap_wsg_idm_ecid_wtls6              739
+#define OBJ_wap_wsg_idm_ecid_wtls6              OBJ_wap_wsg_idm_ecid,6L
+
+#define SN_wap_wsg_idm_ecid_wtls7               "wap-wsg-idm-ecid-wtls7"
+#define NID_wap_wsg_idm_ecid_wtls7              740
+#define OBJ_wap_wsg_idm_ecid_wtls7              OBJ_wap_wsg_idm_ecid,7L
+
+#define SN_wap_wsg_idm_ecid_wtls8               "wap-wsg-idm-ecid-wtls8"
+#define NID_wap_wsg_idm_ecid_wtls8              741
+#define OBJ_wap_wsg_idm_ecid_wtls8              OBJ_wap_wsg_idm_ecid,8L
+
+#define SN_wap_wsg_idm_ecid_wtls9               "wap-wsg-idm-ecid-wtls9"
+#define NID_wap_wsg_idm_ecid_wtls9              742
+#define OBJ_wap_wsg_idm_ecid_wtls9              OBJ_wap_wsg_idm_ecid,9L
+
+#define SN_wap_wsg_idm_ecid_wtls10              "wap-wsg-idm-ecid-wtls10"
+#define NID_wap_wsg_idm_ecid_wtls10             743
+#define OBJ_wap_wsg_idm_ecid_wtls10             OBJ_wap_wsg_idm_ecid,10L
+
+#define SN_wap_wsg_idm_ecid_wtls11              "wap-wsg-idm-ecid-wtls11"
+#define NID_wap_wsg_idm_ecid_wtls11             744
+#define OBJ_wap_wsg_idm_ecid_wtls11             OBJ_wap_wsg_idm_ecid,11L
+
+#define SN_wap_wsg_idm_ecid_wtls12              "wap-wsg-idm-ecid-wtls12"
+#define NID_wap_wsg_idm_ecid_wtls12             745
+#define OBJ_wap_wsg_idm_ecid_wtls12             OBJ_wap_wsg_idm_ecid,12L
+
+#define SN_cast5_cbc            "CAST5-CBC"
+#define LN_cast5_cbc            "cast5-cbc"
+#define NID_cast5_cbc           108
+#define OBJ_cast5_cbc           OBJ_ISO_US,113533L,7L,66L,10L
+
+#define SN_cast5_ecb            "CAST5-ECB"
+#define LN_cast5_ecb            "cast5-ecb"
+#define NID_cast5_ecb           109
+
+#define SN_cast5_cfb64          "CAST5-CFB"
+#define LN_cast5_cfb64          "cast5-cfb"
+#define NID_cast5_cfb64         110
+
+#define SN_cast5_ofb64          "CAST5-OFB"
+#define LN_cast5_ofb64          "cast5-ofb"
+#define NID_cast5_ofb64         111
+
+#define LN_pbeWithMD5AndCast5_CBC               "pbeWithMD5AndCast5CBC"
+#define NID_pbeWithMD5AndCast5_CBC              112
+#define OBJ_pbeWithMD5AndCast5_CBC              OBJ_ISO_US,113533L,7L,66L,12L
+
+#define SN_id_PasswordBasedMAC          "id-PasswordBasedMAC"
+#define LN_id_PasswordBasedMAC          "password based MAC"
+#define NID_id_PasswordBasedMAC         782
+#define OBJ_id_PasswordBasedMAC         OBJ_ISO_US,113533L,7L,66L,13L
+
+#define SN_id_DHBasedMac                "id-DHBasedMac"
+#define LN_id_DHBasedMac                "Diffie-Hellman based MAC"
+#define NID_id_DHBasedMac               783
+#define OBJ_id_DHBasedMac               OBJ_ISO_US,113533L,7L,66L,30L
+
+#define SN_rsadsi               "rsadsi"
+#define LN_rsadsi               "RSA Data Security, Inc."
+#define NID_rsadsi              1
+#define OBJ_rsadsi              OBJ_ISO_US,113549L
+
+#define SN_pkcs         "pkcs"
+#define LN_pkcs         "RSA Data Security, Inc. PKCS"
+#define NID_pkcs                2
+#define OBJ_pkcs                OBJ_rsadsi,1L
+
+#define SN_pkcs1                "pkcs1"
+#define NID_pkcs1               186
+#define OBJ_pkcs1               OBJ_pkcs,1L
+
+#define LN_rsaEncryption                "rsaEncryption"
+#define NID_rsaEncryption               6
+#define OBJ_rsaEncryption               OBJ_pkcs1,1L
+
+#define SN_md2WithRSAEncryption         "RSA-MD2"
+#define LN_md2WithRSAEncryption         "md2WithRSAEncryption"
+#define NID_md2WithRSAEncryption                7
+#define OBJ_md2WithRSAEncryption                OBJ_pkcs1,2L
+
+#define SN_md4WithRSAEncryption         "RSA-MD4"
+#define LN_md4WithRSAEncryption         "md4WithRSAEncryption"
+#define NID_md4WithRSAEncryption                396
+#define OBJ_md4WithRSAEncryption                OBJ_pkcs1,3L
+
+#define SN_md5WithRSAEncryption         "RSA-MD5"
+#define LN_md5WithRSAEncryption         "md5WithRSAEncryption"
+#define NID_md5WithRSAEncryption                8
+#define OBJ_md5WithRSAEncryption                OBJ_pkcs1,4L
+
+#define SN_sha1WithRSAEncryption                "RSA-SHA1"
+#define LN_sha1WithRSAEncryption                "sha1WithRSAEncryption"
+#define NID_sha1WithRSAEncryption               65
+#define OBJ_sha1WithRSAEncryption               OBJ_pkcs1,5L
+
+#define SN_rsaesOaep            "RSAES-OAEP"
+#define LN_rsaesOaep            "rsaesOaep"
+#define NID_rsaesOaep           919
+#define OBJ_rsaesOaep           OBJ_pkcs1,7L
+
+#define SN_mgf1         "MGF1"
+#define LN_mgf1         "mgf1"
+#define NID_mgf1                911
+#define OBJ_mgf1                OBJ_pkcs1,8L
+
+#define SN_pSpecified           "PSPECIFIED"
+#define LN_pSpecified           "pSpecified"
+#define NID_pSpecified          935
+#define OBJ_pSpecified          OBJ_pkcs1,9L
+
+#define SN_rsassaPss            "RSASSA-PSS"
+#define LN_rsassaPss            "rsassaPss"
+#define NID_rsassaPss           912
+#define OBJ_rsassaPss           OBJ_pkcs1,10L
+
+#define SN_sha256WithRSAEncryption              "RSA-SHA256"
+#define LN_sha256WithRSAEncryption              "sha256WithRSAEncryption"
+#define NID_sha256WithRSAEncryption             668
+#define OBJ_sha256WithRSAEncryption             OBJ_pkcs1,11L
+
+#define SN_sha384WithRSAEncryption              "RSA-SHA384"
+#define LN_sha384WithRSAEncryption              "sha384WithRSAEncryption"
+#define NID_sha384WithRSAEncryption             669
+#define OBJ_sha384WithRSAEncryption             OBJ_pkcs1,12L
+
+#define SN_sha512WithRSAEncryption              "RSA-SHA512"
+#define LN_sha512WithRSAEncryption              "sha512WithRSAEncryption"
+#define NID_sha512WithRSAEncryption             670
+#define OBJ_sha512WithRSAEncryption             OBJ_pkcs1,13L
+
+#define SN_sha224WithRSAEncryption              "RSA-SHA224"
+#define LN_sha224WithRSAEncryption              "sha224WithRSAEncryption"
+#define NID_sha224WithRSAEncryption             671
+#define OBJ_sha224WithRSAEncryption             OBJ_pkcs1,14L
+
+#define SN_sha512_224WithRSAEncryption          "RSA-SHA512/224"
+#define LN_sha512_224WithRSAEncryption          "sha512-224WithRSAEncryption"
+#define NID_sha512_224WithRSAEncryption         1145
+#define OBJ_sha512_224WithRSAEncryption         OBJ_pkcs1,15L
+
+#define SN_sha512_256WithRSAEncryption          "RSA-SHA512/256"
+#define LN_sha512_256WithRSAEncryption          "sha512-256WithRSAEncryption"
+#define NID_sha512_256WithRSAEncryption         1146
+#define OBJ_sha512_256WithRSAEncryption         OBJ_pkcs1,16L
+
+#define SN_pkcs3                "pkcs3"
+#define NID_pkcs3               27
+#define OBJ_pkcs3               OBJ_pkcs,3L
+
+#define LN_dhKeyAgreement               "dhKeyAgreement"
+#define NID_dhKeyAgreement              28
+#define OBJ_dhKeyAgreement              OBJ_pkcs3,1L
+
+#define SN_pkcs5                "pkcs5"
+#define NID_pkcs5               187
+#define OBJ_pkcs5               OBJ_pkcs,5L
+
+#define SN_pbeWithMD2AndDES_CBC         "PBE-MD2-DES"
+#define LN_pbeWithMD2AndDES_CBC         "pbeWithMD2AndDES-CBC"
+#define NID_pbeWithMD2AndDES_CBC                9
+#define OBJ_pbeWithMD2AndDES_CBC                OBJ_pkcs5,1L
+
+#define SN_pbeWithMD5AndDES_CBC         "PBE-MD5-DES"
+#define LN_pbeWithMD5AndDES_CBC         "pbeWithMD5AndDES-CBC"
+#define NID_pbeWithMD5AndDES_CBC                10
+#define OBJ_pbeWithMD5AndDES_CBC                OBJ_pkcs5,3L
+
+#define SN_pbeWithMD2AndRC2_CBC         "PBE-MD2-RC2-64"
+#define LN_pbeWithMD2AndRC2_CBC         "pbeWithMD2AndRC2-CBC"
+#define NID_pbeWithMD2AndRC2_CBC                168
+#define OBJ_pbeWithMD2AndRC2_CBC                OBJ_pkcs5,4L
+
+#define SN_pbeWithMD5AndRC2_CBC         "PBE-MD5-RC2-64"
+#define LN_pbeWithMD5AndRC2_CBC         "pbeWithMD5AndRC2-CBC"
+#define NID_pbeWithMD5AndRC2_CBC                169
+#define OBJ_pbeWithMD5AndRC2_CBC                OBJ_pkcs5,6L
+
+#define SN_pbeWithSHA1AndDES_CBC                "PBE-SHA1-DES"
+#define LN_pbeWithSHA1AndDES_CBC                "pbeWithSHA1AndDES-CBC"
+#define NID_pbeWithSHA1AndDES_CBC               170
+#define OBJ_pbeWithSHA1AndDES_CBC               OBJ_pkcs5,10L
+
+#define SN_pbeWithSHA1AndRC2_CBC                "PBE-SHA1-RC2-64"
+#define LN_pbeWithSHA1AndRC2_CBC                "pbeWithSHA1AndRC2-CBC"
+#define NID_pbeWithSHA1AndRC2_CBC               68
+#define OBJ_pbeWithSHA1AndRC2_CBC               OBJ_pkcs5,11L
+
+#define LN_id_pbkdf2            "PBKDF2"
+#define NID_id_pbkdf2           69
+#define OBJ_id_pbkdf2           OBJ_pkcs5,12L
+
+#define LN_pbes2                "PBES2"
+#define NID_pbes2               161
+#define OBJ_pbes2               OBJ_pkcs5,13L
+
+#define LN_pbmac1               "PBMAC1"
+#define NID_pbmac1              162
+#define OBJ_pbmac1              OBJ_pkcs5,14L
+
+#define SN_pkcs7                "pkcs7"
+#define NID_pkcs7               20
+#define OBJ_pkcs7               OBJ_pkcs,7L
+
+#define LN_pkcs7_data           "pkcs7-data"
+#define NID_pkcs7_data          21
+#define OBJ_pkcs7_data          OBJ_pkcs7,1L
+
+#define LN_pkcs7_signed         "pkcs7-signedData"
+#define NID_pkcs7_signed                22
+#define OBJ_pkcs7_signed                OBJ_pkcs7,2L
+
+#define LN_pkcs7_enveloped              "pkcs7-envelopedData"
+#define NID_pkcs7_enveloped             23
+#define OBJ_pkcs7_enveloped             OBJ_pkcs7,3L
+
+#define LN_pkcs7_signedAndEnveloped             "pkcs7-signedAndEnvelopedData"
+#define NID_pkcs7_signedAndEnveloped            24
+#define OBJ_pkcs7_signedAndEnveloped            OBJ_pkcs7,4L
+
+#define LN_pkcs7_digest         "pkcs7-digestData"
+#define NID_pkcs7_digest                25
+#define OBJ_pkcs7_digest                OBJ_pkcs7,5L
+
+#define LN_pkcs7_encrypted              "pkcs7-encryptedData"
+#define NID_pkcs7_encrypted             26
+#define OBJ_pkcs7_encrypted             OBJ_pkcs7,6L
+
+#define SN_pkcs9                "pkcs9"
+#define NID_pkcs9               47
+#define OBJ_pkcs9               OBJ_pkcs,9L
+
+#define LN_pkcs9_emailAddress           "emailAddress"
+#define NID_pkcs9_emailAddress          48
+#define OBJ_pkcs9_emailAddress          OBJ_pkcs9,1L
+
+#define LN_pkcs9_unstructuredName               "unstructuredName"
+#define NID_pkcs9_unstructuredName              49
+#define OBJ_pkcs9_unstructuredName              OBJ_pkcs9,2L
+
+#define LN_pkcs9_contentType            "contentType"
+#define NID_pkcs9_contentType           50
+#define OBJ_pkcs9_contentType           OBJ_pkcs9,3L
+
+#define LN_pkcs9_messageDigest          "messageDigest"
+#define NID_pkcs9_messageDigest         51
+#define OBJ_pkcs9_messageDigest         OBJ_pkcs9,4L
+
+#define LN_pkcs9_signingTime            "signingTime"
+#define NID_pkcs9_signingTime           52
+#define OBJ_pkcs9_signingTime           OBJ_pkcs9,5L
+
+#define LN_pkcs9_countersignature               "countersignature"
+#define NID_pkcs9_countersignature              53
+#define OBJ_pkcs9_countersignature              OBJ_pkcs9,6L
+
+#define LN_pkcs9_challengePassword              "challengePassword"
+#define NID_pkcs9_challengePassword             54
+#define OBJ_pkcs9_challengePassword             OBJ_pkcs9,7L
+
+#define LN_pkcs9_unstructuredAddress            "unstructuredAddress"
+#define NID_pkcs9_unstructuredAddress           55
+#define OBJ_pkcs9_unstructuredAddress           OBJ_pkcs9,8L
+
+#define LN_pkcs9_extCertAttributes              "extendedCertificateAttributes"
+#define NID_pkcs9_extCertAttributes             56
+#define OBJ_pkcs9_extCertAttributes             OBJ_pkcs9,9L
+
+#define SN_ext_req              "extReq"
+#define LN_ext_req              "Extension Request"
+#define NID_ext_req             172
+#define OBJ_ext_req             OBJ_pkcs9,14L
+
+#define SN_SMIMECapabilities            "SMIME-CAPS"
+#define LN_SMIMECapabilities            "S/MIME Capabilities"
+#define NID_SMIMECapabilities           167
+#define OBJ_SMIMECapabilities           OBJ_pkcs9,15L
+
+#define SN_SMIME                "SMIME"
+#define LN_SMIME                "S/MIME"
+#define NID_SMIME               188
+#define OBJ_SMIME               OBJ_pkcs9,16L
+
+#define SN_id_smime_mod         "id-smime-mod"
+#define NID_id_smime_mod                189
+#define OBJ_id_smime_mod                OBJ_SMIME,0L
+
+#define SN_id_smime_ct          "id-smime-ct"
+#define NID_id_smime_ct         190
+#define OBJ_id_smime_ct         OBJ_SMIME,1L
+
+#define SN_id_smime_aa          "id-smime-aa"
+#define NID_id_smime_aa         191
+#define OBJ_id_smime_aa         OBJ_SMIME,2L
+
+#define SN_id_smime_alg         "id-smime-alg"
+#define NID_id_smime_alg                192
+#define OBJ_id_smime_alg                OBJ_SMIME,3L
+
+#define SN_id_smime_cd          "id-smime-cd"
+#define NID_id_smime_cd         193
+#define OBJ_id_smime_cd         OBJ_SMIME,4L
+
+#define SN_id_smime_spq         "id-smime-spq"
+#define NID_id_smime_spq                194
+#define OBJ_id_smime_spq                OBJ_SMIME,5L
+
+#define SN_id_smime_cti         "id-smime-cti"
+#define NID_id_smime_cti                195
+#define OBJ_id_smime_cti                OBJ_SMIME,6L
+
+#define SN_id_smime_mod_cms             "id-smime-mod-cms"
+#define NID_id_smime_mod_cms            196
+#define OBJ_id_smime_mod_cms            OBJ_id_smime_mod,1L
+
+#define SN_id_smime_mod_ess             "id-smime-mod-ess"
+#define NID_id_smime_mod_ess            197
+#define OBJ_id_smime_mod_ess            OBJ_id_smime_mod,2L
+
+#define SN_id_smime_mod_oid             "id-smime-mod-oid"
+#define NID_id_smime_mod_oid            198
+#define OBJ_id_smime_mod_oid            OBJ_id_smime_mod,3L
+
+#define SN_id_smime_mod_msg_v3          "id-smime-mod-msg-v3"
+#define NID_id_smime_mod_msg_v3         199
+#define OBJ_id_smime_mod_msg_v3         OBJ_id_smime_mod,4L
+
+#define SN_id_smime_mod_ets_eSignature_88               "id-smime-mod-ets-eSignature-88"
+#define NID_id_smime_mod_ets_eSignature_88              200
+#define OBJ_id_smime_mod_ets_eSignature_88              OBJ_id_smime_mod,5L
+
+#define SN_id_smime_mod_ets_eSignature_97               "id-smime-mod-ets-eSignature-97"
+#define NID_id_smime_mod_ets_eSignature_97              201
+#define OBJ_id_smime_mod_ets_eSignature_97              OBJ_id_smime_mod,6L
+
+#define SN_id_smime_mod_ets_eSigPolicy_88               "id-smime-mod-ets-eSigPolicy-88"
+#define NID_id_smime_mod_ets_eSigPolicy_88              202
+#define OBJ_id_smime_mod_ets_eSigPolicy_88              OBJ_id_smime_mod,7L
+
+#define SN_id_smime_mod_ets_eSigPolicy_97               "id-smime-mod-ets-eSigPolicy-97"
+#define NID_id_smime_mod_ets_eSigPolicy_97              203
+#define OBJ_id_smime_mod_ets_eSigPolicy_97              OBJ_id_smime_mod,8L
+
+#define SN_id_smime_ct_receipt          "id-smime-ct-receipt"
+#define NID_id_smime_ct_receipt         204
+#define OBJ_id_smime_ct_receipt         OBJ_id_smime_ct,1L
+
+#define SN_id_smime_ct_authData         "id-smime-ct-authData"
+#define NID_id_smime_ct_authData                205
+#define OBJ_id_smime_ct_authData                OBJ_id_smime_ct,2L
+
+#define SN_id_smime_ct_publishCert              "id-smime-ct-publishCert"
+#define NID_id_smime_ct_publishCert             206
+#define OBJ_id_smime_ct_publishCert             OBJ_id_smime_ct,3L
+
+#define SN_id_smime_ct_TSTInfo          "id-smime-ct-TSTInfo"
+#define NID_id_smime_ct_TSTInfo         207
+#define OBJ_id_smime_ct_TSTInfo         OBJ_id_smime_ct,4L
+
+#define SN_id_smime_ct_TDTInfo          "id-smime-ct-TDTInfo"
+#define NID_id_smime_ct_TDTInfo         208
+#define OBJ_id_smime_ct_TDTInfo         OBJ_id_smime_ct,5L
+
+#define SN_id_smime_ct_contentInfo              "id-smime-ct-contentInfo"
+#define NID_id_smime_ct_contentInfo             209
+#define OBJ_id_smime_ct_contentInfo             OBJ_id_smime_ct,6L
+
+#define SN_id_smime_ct_DVCSRequestData          "id-smime-ct-DVCSRequestData"
+#define NID_id_smime_ct_DVCSRequestData         210
+#define OBJ_id_smime_ct_DVCSRequestData         OBJ_id_smime_ct,7L
+
+#define SN_id_smime_ct_DVCSResponseData         "id-smime-ct-DVCSResponseData"
+#define NID_id_smime_ct_DVCSResponseData                211
+#define OBJ_id_smime_ct_DVCSResponseData                OBJ_id_smime_ct,8L
+
+#define SN_id_smime_ct_compressedData           "id-smime-ct-compressedData"
+#define NID_id_smime_ct_compressedData          786
+#define OBJ_id_smime_ct_compressedData          OBJ_id_smime_ct,9L
+
+#define SN_id_smime_ct_contentCollection                "id-smime-ct-contentCollection"
+#define NID_id_smime_ct_contentCollection               1058
+#define OBJ_id_smime_ct_contentCollection               OBJ_id_smime_ct,19L
+
+#define SN_id_smime_ct_authEnvelopedData                "id-smime-ct-authEnvelopedData"
+#define NID_id_smime_ct_authEnvelopedData               1059
+#define OBJ_id_smime_ct_authEnvelopedData               OBJ_id_smime_ct,23L
+
+#define SN_id_ct_routeOriginAuthz               "id-ct-routeOriginAuthz"
+#define NID_id_ct_routeOriginAuthz              1234
+#define OBJ_id_ct_routeOriginAuthz              OBJ_id_smime_ct,24L
+
+#define SN_id_ct_rpkiManifest           "id-ct-rpkiManifest"
+#define NID_id_ct_rpkiManifest          1235
+#define OBJ_id_ct_rpkiManifest          OBJ_id_smime_ct,26L
+
+#define SN_id_ct_asciiTextWithCRLF              "id-ct-asciiTextWithCRLF"
+#define NID_id_ct_asciiTextWithCRLF             787
+#define OBJ_id_ct_asciiTextWithCRLF             OBJ_id_smime_ct,27L
+
+#define SN_id_ct_xml            "id-ct-xml"
+#define NID_id_ct_xml           1060
+#define OBJ_id_ct_xml           OBJ_id_smime_ct,28L
+
+#define SN_id_ct_rpkiGhostbusters               "id-ct-rpkiGhostbusters"
+#define NID_id_ct_rpkiGhostbusters              1236
+#define OBJ_id_ct_rpkiGhostbusters              OBJ_id_smime_ct,35L
+
+#define SN_id_ct_resourceTaggedAttest           "id-ct-resourceTaggedAttest"
+#define NID_id_ct_resourceTaggedAttest          1237
+#define OBJ_id_ct_resourceTaggedAttest          OBJ_id_smime_ct,36L
+
+#define SN_id_ct_geofeedCSVwithCRLF             "id-ct-geofeedCSVwithCRLF"
+#define NID_id_ct_geofeedCSVwithCRLF            1246
+#define OBJ_id_ct_geofeedCSVwithCRLF            OBJ_id_smime_ct,47L
+
+#define SN_id_ct_signedChecklist                "id-ct-signedChecklist"
+#define NID_id_ct_signedChecklist               1247
+#define OBJ_id_ct_signedChecklist               OBJ_id_smime_ct,48L
+
+#define SN_id_smime_aa_receiptRequest           "id-smime-aa-receiptRequest"
+#define NID_id_smime_aa_receiptRequest          212
+#define OBJ_id_smime_aa_receiptRequest          OBJ_id_smime_aa,1L
+
+#define SN_id_smime_aa_securityLabel            "id-smime-aa-securityLabel"
+#define NID_id_smime_aa_securityLabel           213
+#define OBJ_id_smime_aa_securityLabel           OBJ_id_smime_aa,2L
+
+#define SN_id_smime_aa_mlExpandHistory          "id-smime-aa-mlExpandHistory"
+#define NID_id_smime_aa_mlExpandHistory         214
+#define OBJ_id_smime_aa_mlExpandHistory         OBJ_id_smime_aa,3L
+
+#define SN_id_smime_aa_contentHint              "id-smime-aa-contentHint"
+#define NID_id_smime_aa_contentHint             215
+#define OBJ_id_smime_aa_contentHint             OBJ_id_smime_aa,4L
+
+#define SN_id_smime_aa_msgSigDigest             "id-smime-aa-msgSigDigest"
+#define NID_id_smime_aa_msgSigDigest            216
+#define OBJ_id_smime_aa_msgSigDigest            OBJ_id_smime_aa,5L
+
+#define SN_id_smime_aa_encapContentType         "id-smime-aa-encapContentType"
+#define NID_id_smime_aa_encapContentType                217
+#define OBJ_id_smime_aa_encapContentType                OBJ_id_smime_aa,6L
+
+#define SN_id_smime_aa_contentIdentifier                "id-smime-aa-contentIdentifier"
+#define NID_id_smime_aa_contentIdentifier               218
+#define OBJ_id_smime_aa_contentIdentifier               OBJ_id_smime_aa,7L
+
+#define SN_id_smime_aa_macValue         "id-smime-aa-macValue"
+#define NID_id_smime_aa_macValue                219
+#define OBJ_id_smime_aa_macValue                OBJ_id_smime_aa,8L
+
+#define SN_id_smime_aa_equivalentLabels         "id-smime-aa-equivalentLabels"
+#define NID_id_smime_aa_equivalentLabels                220
+#define OBJ_id_smime_aa_equivalentLabels                OBJ_id_smime_aa,9L
+
+#define SN_id_smime_aa_contentReference         "id-smime-aa-contentReference"
+#define NID_id_smime_aa_contentReference                221
+#define OBJ_id_smime_aa_contentReference                OBJ_id_smime_aa,10L
+
+#define SN_id_smime_aa_encrypKeyPref            "id-smime-aa-encrypKeyPref"
+#define NID_id_smime_aa_encrypKeyPref           222
+#define OBJ_id_smime_aa_encrypKeyPref           OBJ_id_smime_aa,11L
+
+#define SN_id_smime_aa_signingCertificate               "id-smime-aa-signingCertificate"
+#define NID_id_smime_aa_signingCertificate              223
+#define OBJ_id_smime_aa_signingCertificate              OBJ_id_smime_aa,12L
+
+#define SN_id_smime_aa_smimeEncryptCerts                "id-smime-aa-smimeEncryptCerts"
+#define NID_id_smime_aa_smimeEncryptCerts               224
+#define OBJ_id_smime_aa_smimeEncryptCerts               OBJ_id_smime_aa,13L
+
+#define SN_id_smime_aa_timeStampToken           "id-smime-aa-timeStampToken"
+#define NID_id_smime_aa_timeStampToken          225
+#define OBJ_id_smime_aa_timeStampToken          OBJ_id_smime_aa,14L
+
+#define SN_id_smime_aa_ets_sigPolicyId          "id-smime-aa-ets-sigPolicyId"
+#define NID_id_smime_aa_ets_sigPolicyId         226
+#define OBJ_id_smime_aa_ets_sigPolicyId         OBJ_id_smime_aa,15L
+
+#define SN_id_smime_aa_ets_commitmentType               "id-smime-aa-ets-commitmentType"
+#define NID_id_smime_aa_ets_commitmentType              227
+#define OBJ_id_smime_aa_ets_commitmentType              OBJ_id_smime_aa,16L
+
+#define SN_id_smime_aa_ets_signerLocation               "id-smime-aa-ets-signerLocation"
+#define NID_id_smime_aa_ets_signerLocation              228
+#define OBJ_id_smime_aa_ets_signerLocation              OBJ_id_smime_aa,17L
+
+#define SN_id_smime_aa_ets_signerAttr           "id-smime-aa-ets-signerAttr"
+#define NID_id_smime_aa_ets_signerAttr          229
+#define OBJ_id_smime_aa_ets_signerAttr          OBJ_id_smime_aa,18L
+
+#define SN_id_smime_aa_ets_otherSigCert         "id-smime-aa-ets-otherSigCert"
+#define NID_id_smime_aa_ets_otherSigCert                230
+#define OBJ_id_smime_aa_ets_otherSigCert                OBJ_id_smime_aa,19L
+
+#define SN_id_smime_aa_ets_contentTimestamp             "id-smime-aa-ets-contentTimestamp"
+#define NID_id_smime_aa_ets_contentTimestamp            231
+#define OBJ_id_smime_aa_ets_contentTimestamp            OBJ_id_smime_aa,20L
+
+#define SN_id_smime_aa_ets_CertificateRefs              "id-smime-aa-ets-CertificateRefs"
+#define NID_id_smime_aa_ets_CertificateRefs             232
+#define OBJ_id_smime_aa_ets_CertificateRefs             OBJ_id_smime_aa,21L
+
+#define SN_id_smime_aa_ets_RevocationRefs               "id-smime-aa-ets-RevocationRefs"
+#define NID_id_smime_aa_ets_RevocationRefs              233
+#define OBJ_id_smime_aa_ets_RevocationRefs              OBJ_id_smime_aa,22L
+
+#define SN_id_smime_aa_ets_certValues           "id-smime-aa-ets-certValues"
+#define NID_id_smime_aa_ets_certValues          234
+#define OBJ_id_smime_aa_ets_certValues          OBJ_id_smime_aa,23L
+
+#define SN_id_smime_aa_ets_revocationValues             "id-smime-aa-ets-revocationValues"
+#define NID_id_smime_aa_ets_revocationValues            235
+#define OBJ_id_smime_aa_ets_revocationValues            OBJ_id_smime_aa,24L
+
+#define SN_id_smime_aa_ets_escTimeStamp         "id-smime-aa-ets-escTimeStamp"
+#define NID_id_smime_aa_ets_escTimeStamp                236
+#define OBJ_id_smime_aa_ets_escTimeStamp                OBJ_id_smime_aa,25L
+
+#define SN_id_smime_aa_ets_certCRLTimestamp             "id-smime-aa-ets-certCRLTimestamp"
+#define NID_id_smime_aa_ets_certCRLTimestamp            237
+#define OBJ_id_smime_aa_ets_certCRLTimestamp            OBJ_id_smime_aa,26L
+
+#define SN_id_smime_aa_ets_archiveTimeStamp             "id-smime-aa-ets-archiveTimeStamp"
+#define NID_id_smime_aa_ets_archiveTimeStamp            238
+#define OBJ_id_smime_aa_ets_archiveTimeStamp            OBJ_id_smime_aa,27L
+
+#define SN_id_smime_aa_signatureType            "id-smime-aa-signatureType"
+#define NID_id_smime_aa_signatureType           239
+#define OBJ_id_smime_aa_signatureType           OBJ_id_smime_aa,28L
+
+#define SN_id_smime_aa_dvcs_dvc         "id-smime-aa-dvcs-dvc"
+#define NID_id_smime_aa_dvcs_dvc                240
+#define OBJ_id_smime_aa_dvcs_dvc                OBJ_id_smime_aa,29L
+
+#define SN_id_smime_aa_signingCertificateV2             "id-smime-aa-signingCertificateV2"
+#define NID_id_smime_aa_signingCertificateV2            1086
+#define OBJ_id_smime_aa_signingCertificateV2            OBJ_id_smime_aa,47L
+
+#define SN_id_smime_alg_ESDHwith3DES            "id-smime-alg-ESDHwith3DES"
+#define NID_id_smime_alg_ESDHwith3DES           241
+#define OBJ_id_smime_alg_ESDHwith3DES           OBJ_id_smime_alg,1L
+
+#define SN_id_smime_alg_ESDHwithRC2             "id-smime-alg-ESDHwithRC2"
+#define NID_id_smime_alg_ESDHwithRC2            242
+#define OBJ_id_smime_alg_ESDHwithRC2            OBJ_id_smime_alg,2L
+
+#define SN_id_smime_alg_3DESwrap                "id-smime-alg-3DESwrap"
+#define NID_id_smime_alg_3DESwrap               243
+#define OBJ_id_smime_alg_3DESwrap               OBJ_id_smime_alg,3L
+
+#define SN_id_smime_alg_RC2wrap         "id-smime-alg-RC2wrap"
+#define NID_id_smime_alg_RC2wrap                244
+#define OBJ_id_smime_alg_RC2wrap                OBJ_id_smime_alg,4L
+
+#define SN_id_smime_alg_ESDH            "id-smime-alg-ESDH"
+#define NID_id_smime_alg_ESDH           245
+#define OBJ_id_smime_alg_ESDH           OBJ_id_smime_alg,5L
+
+#define SN_id_smime_alg_CMS3DESwrap             "id-smime-alg-CMS3DESwrap"
+#define NID_id_smime_alg_CMS3DESwrap            246
+#define OBJ_id_smime_alg_CMS3DESwrap            OBJ_id_smime_alg,6L
+
+#define SN_id_smime_alg_CMSRC2wrap              "id-smime-alg-CMSRC2wrap"
+#define NID_id_smime_alg_CMSRC2wrap             247
+#define OBJ_id_smime_alg_CMSRC2wrap             OBJ_id_smime_alg,7L
+
+#define SN_id_alg_PWRI_KEK              "id-alg-PWRI-KEK"
+#define NID_id_alg_PWRI_KEK             893
+#define OBJ_id_alg_PWRI_KEK             OBJ_id_smime_alg,9L
+
+#define SN_id_smime_cd_ldap             "id-smime-cd-ldap"
+#define NID_id_smime_cd_ldap            248
+#define OBJ_id_smime_cd_ldap            OBJ_id_smime_cd,1L
+
+#define SN_id_smime_spq_ets_sqt_uri             "id-smime-spq-ets-sqt-uri"
+#define NID_id_smime_spq_ets_sqt_uri            249
+#define OBJ_id_smime_spq_ets_sqt_uri            OBJ_id_smime_spq,1L
+
+#define SN_id_smime_spq_ets_sqt_unotice         "id-smime-spq-ets-sqt-unotice"
+#define NID_id_smime_spq_ets_sqt_unotice                250
+#define OBJ_id_smime_spq_ets_sqt_unotice                OBJ_id_smime_spq,2L
+
+#define SN_id_smime_cti_ets_proofOfOrigin               "id-smime-cti-ets-proofOfOrigin"
+#define NID_id_smime_cti_ets_proofOfOrigin              251
+#define OBJ_id_smime_cti_ets_proofOfOrigin              OBJ_id_smime_cti,1L
+
+#define SN_id_smime_cti_ets_proofOfReceipt              "id-smime-cti-ets-proofOfReceipt"
+#define NID_id_smime_cti_ets_proofOfReceipt             252
+#define OBJ_id_smime_cti_ets_proofOfReceipt             OBJ_id_smime_cti,2L
+
+#define SN_id_smime_cti_ets_proofOfDelivery             "id-smime-cti-ets-proofOfDelivery"
+#define NID_id_smime_cti_ets_proofOfDelivery            253
+#define OBJ_id_smime_cti_ets_proofOfDelivery            OBJ_id_smime_cti,3L
+
+#define SN_id_smime_cti_ets_proofOfSender               "id-smime-cti-ets-proofOfSender"
+#define NID_id_smime_cti_ets_proofOfSender              254
+#define OBJ_id_smime_cti_ets_proofOfSender              OBJ_id_smime_cti,4L
+
+#define SN_id_smime_cti_ets_proofOfApproval             "id-smime-cti-ets-proofOfApproval"
+#define NID_id_smime_cti_ets_proofOfApproval            255
+#define OBJ_id_smime_cti_ets_proofOfApproval            OBJ_id_smime_cti,5L
+
+#define SN_id_smime_cti_ets_proofOfCreation             "id-smime-cti-ets-proofOfCreation"
+#define NID_id_smime_cti_ets_proofOfCreation            256
+#define OBJ_id_smime_cti_ets_proofOfCreation            OBJ_id_smime_cti,6L
+
+#define LN_friendlyName         "friendlyName"
+#define NID_friendlyName                156
+#define OBJ_friendlyName                OBJ_pkcs9,20L
+
+#define LN_localKeyID           "localKeyID"
+#define NID_localKeyID          157
+#define OBJ_localKeyID          OBJ_pkcs9,21L
+
+#define SN_ms_csp_name          "CSPName"
+#define LN_ms_csp_name          "Microsoft CSP Name"
+#define NID_ms_csp_name         417
+#define OBJ_ms_csp_name         1L,3L,6L,1L,4L,1L,311L,17L,1L
+
+#define SN_LocalKeySet          "LocalKeySet"
+#define LN_LocalKeySet          "Microsoft Local Key set"
+#define NID_LocalKeySet         856
+#define OBJ_LocalKeySet         1L,3L,6L,1L,4L,1L,311L,17L,2L
+
+#define OBJ_certTypes           OBJ_pkcs9,22L
+
+#define LN_x509Certificate              "x509Certificate"
+#define NID_x509Certificate             158
+#define OBJ_x509Certificate             OBJ_certTypes,1L
+
+#define LN_sdsiCertificate              "sdsiCertificate"
+#define NID_sdsiCertificate             159
+#define OBJ_sdsiCertificate             OBJ_certTypes,2L
+
+#define OBJ_crlTypes            OBJ_pkcs9,23L
+
+#define LN_x509Crl              "x509Crl"
+#define NID_x509Crl             160
+#define OBJ_x509Crl             OBJ_crlTypes,1L
+
+#define OBJ_pkcs12              OBJ_pkcs,12L
+
+#define OBJ_pkcs12_pbeids               OBJ_pkcs12,1L
+
+#define SN_pbe_WithSHA1And128BitRC4             "PBE-SHA1-RC4-128"
+#define LN_pbe_WithSHA1And128BitRC4             "pbeWithSHA1And128BitRC4"
+#define NID_pbe_WithSHA1And128BitRC4            144
+#define OBJ_pbe_WithSHA1And128BitRC4            OBJ_pkcs12_pbeids,1L
+
+#define SN_pbe_WithSHA1And40BitRC4              "PBE-SHA1-RC4-40"
+#define LN_pbe_WithSHA1And40BitRC4              "pbeWithSHA1And40BitRC4"
+#define NID_pbe_WithSHA1And40BitRC4             145
+#define OBJ_pbe_WithSHA1And40BitRC4             OBJ_pkcs12_pbeids,2L
+
+#define SN_pbe_WithSHA1And3_Key_TripleDES_CBC           "PBE-SHA1-3DES"
+#define LN_pbe_WithSHA1And3_Key_TripleDES_CBC           "pbeWithSHA1And3-KeyTripleDES-CBC"
+#define NID_pbe_WithSHA1And3_Key_TripleDES_CBC          146
+#define OBJ_pbe_WithSHA1And3_Key_TripleDES_CBC          OBJ_pkcs12_pbeids,3L
+
+#define SN_pbe_WithSHA1And2_Key_TripleDES_CBC           "PBE-SHA1-2DES"
+#define LN_pbe_WithSHA1And2_Key_TripleDES_CBC           "pbeWithSHA1And2-KeyTripleDES-CBC"
+#define NID_pbe_WithSHA1And2_Key_TripleDES_CBC          147
+#define OBJ_pbe_WithSHA1And2_Key_TripleDES_CBC          OBJ_pkcs12_pbeids,4L
+
+#define SN_pbe_WithSHA1And128BitRC2_CBC         "PBE-SHA1-RC2-128"
+#define LN_pbe_WithSHA1And128BitRC2_CBC         "pbeWithSHA1And128BitRC2-CBC"
+#define NID_pbe_WithSHA1And128BitRC2_CBC                148
+#define OBJ_pbe_WithSHA1And128BitRC2_CBC                OBJ_pkcs12_pbeids,5L
+
+#define SN_pbe_WithSHA1And40BitRC2_CBC          "PBE-SHA1-RC2-40"
+#define LN_pbe_WithSHA1And40BitRC2_CBC          "pbeWithSHA1And40BitRC2-CBC"
+#define NID_pbe_WithSHA1And40BitRC2_CBC         149
+#define OBJ_pbe_WithSHA1And40BitRC2_CBC         OBJ_pkcs12_pbeids,6L
+
+#define OBJ_pkcs12_Version1             OBJ_pkcs12,10L
+
+#define OBJ_pkcs12_BagIds               OBJ_pkcs12_Version1,1L
+
+#define LN_keyBag               "keyBag"
+#define NID_keyBag              150
+#define OBJ_keyBag              OBJ_pkcs12_BagIds,1L
+
+#define LN_pkcs8ShroudedKeyBag          "pkcs8ShroudedKeyBag"
+#define NID_pkcs8ShroudedKeyBag         151
+#define OBJ_pkcs8ShroudedKeyBag         OBJ_pkcs12_BagIds,2L
+
+#define LN_certBag              "certBag"
+#define NID_certBag             152
+#define OBJ_certBag             OBJ_pkcs12_BagIds,3L
+
+#define LN_crlBag               "crlBag"
+#define NID_crlBag              153
+#define OBJ_crlBag              OBJ_pkcs12_BagIds,4L
+
+#define LN_secretBag            "secretBag"
+#define NID_secretBag           154
+#define OBJ_secretBag           OBJ_pkcs12_BagIds,5L
+
+#define LN_safeContentsBag              "safeContentsBag"
+#define NID_safeContentsBag             155
+#define OBJ_safeContentsBag             OBJ_pkcs12_BagIds,6L
+
+#define SN_md2          "MD2"
+#define LN_md2          "md2"
+#define NID_md2         3
+#define OBJ_md2         OBJ_rsadsi,2L,2L
+
+#define SN_md4          "MD4"
+#define LN_md4          "md4"
+#define NID_md4         257
+#define OBJ_md4         OBJ_rsadsi,2L,4L
+
+#define SN_md5          "MD5"
+#define LN_md5          "md5"
+#define NID_md5         4
+#define OBJ_md5         OBJ_rsadsi,2L,5L
+
+#define SN_md5_sha1             "MD5-SHA1"
+#define LN_md5_sha1             "md5-sha1"
+#define NID_md5_sha1            114
+
+#define LN_hmacWithMD5          "hmacWithMD5"
+#define NID_hmacWithMD5         797
+#define OBJ_hmacWithMD5         OBJ_rsadsi,2L,6L
+
+#define LN_hmacWithSHA1         "hmacWithSHA1"
+#define NID_hmacWithSHA1                163
+#define OBJ_hmacWithSHA1                OBJ_rsadsi,2L,7L
+
+#define SN_sm2          "SM2"
+#define LN_sm2          "sm2"
+#define NID_sm2         1172
+#define OBJ_sm2         OBJ_sm_scheme,301L
+
+#define SN_sm3          "SM3"
+#define LN_sm3          "sm3"
+#define NID_sm3         1143
+#define OBJ_sm3         OBJ_sm_scheme,401L
+
+#define SN_sm3WithRSAEncryption         "RSA-SM3"
+#define LN_sm3WithRSAEncryption         "sm3WithRSAEncryption"
+#define NID_sm3WithRSAEncryption                1144
+#define OBJ_sm3WithRSAEncryption                OBJ_sm_scheme,504L
+
+#define SN_SM2_with_SM3         "SM2-SM3"
+#define LN_SM2_with_SM3         "SM2-with-SM3"
+#define NID_SM2_with_SM3                1204
+#define OBJ_SM2_with_SM3                OBJ_sm_scheme,501L
+
+#define LN_hmacWithSHA224               "hmacWithSHA224"
+#define NID_hmacWithSHA224              798
+#define OBJ_hmacWithSHA224              OBJ_rsadsi,2L,8L
+
+#define LN_hmacWithSHA256               "hmacWithSHA256"
+#define NID_hmacWithSHA256              799
+#define OBJ_hmacWithSHA256              OBJ_rsadsi,2L,9L
+
+#define LN_hmacWithSHA384               "hmacWithSHA384"
+#define NID_hmacWithSHA384              800
+#define OBJ_hmacWithSHA384              OBJ_rsadsi,2L,10L
+
+#define LN_hmacWithSHA512               "hmacWithSHA512"
+#define NID_hmacWithSHA512              801
+#define OBJ_hmacWithSHA512              OBJ_rsadsi,2L,11L
+
+#define LN_hmacWithSHA512_224           "hmacWithSHA512-224"
+#define NID_hmacWithSHA512_224          1193
+#define OBJ_hmacWithSHA512_224          OBJ_rsadsi,2L,12L
+
+#define LN_hmacWithSHA512_256           "hmacWithSHA512-256"
+#define NID_hmacWithSHA512_256          1194
+#define OBJ_hmacWithSHA512_256          OBJ_rsadsi,2L,13L
+
+#define SN_rc2_cbc              "RC2-CBC"
+#define LN_rc2_cbc              "rc2-cbc"
+#define NID_rc2_cbc             37
+#define OBJ_rc2_cbc             OBJ_rsadsi,3L,2L
+
+#define SN_rc2_ecb              "RC2-ECB"
+#define LN_rc2_ecb              "rc2-ecb"
+#define NID_rc2_ecb             38
+
+#define SN_rc2_cfb64            "RC2-CFB"
+#define LN_rc2_cfb64            "rc2-cfb"
+#define NID_rc2_cfb64           39
+
+#define SN_rc2_ofb64            "RC2-OFB"
+#define LN_rc2_ofb64            "rc2-ofb"
+#define NID_rc2_ofb64           40
+
+#define SN_rc2_40_cbc           "RC2-40-CBC"
+#define LN_rc2_40_cbc           "rc2-40-cbc"
+#define NID_rc2_40_cbc          98
+
+#define SN_rc2_64_cbc           "RC2-64-CBC"
+#define LN_rc2_64_cbc           "rc2-64-cbc"
+#define NID_rc2_64_cbc          166
+
+#define SN_rc4          "RC4"
+#define LN_rc4          "rc4"
+#define NID_rc4         5
+#define OBJ_rc4         OBJ_rsadsi,3L,4L
+
+#define SN_rc4_40               "RC4-40"
+#define LN_rc4_40               "rc4-40"
+#define NID_rc4_40              97
+
+#define SN_des_ede3_cbc         "DES-EDE3-CBC"
+#define LN_des_ede3_cbc         "des-ede3-cbc"
+#define NID_des_ede3_cbc                44
+#define OBJ_des_ede3_cbc                OBJ_rsadsi,3L,7L
+
+#define SN_rc5_cbc              "RC5-CBC"
+#define LN_rc5_cbc              "rc5-cbc"
+#define NID_rc5_cbc             120
+#define OBJ_rc5_cbc             OBJ_rsadsi,3L,8L
+
+#define SN_rc5_ecb              "RC5-ECB"
+#define LN_rc5_ecb              "rc5-ecb"
+#define NID_rc5_ecb             121
+
+#define SN_rc5_cfb64            "RC5-CFB"
+#define LN_rc5_cfb64            "rc5-cfb"
+#define NID_rc5_cfb64           122
+
+#define SN_rc5_ofb64            "RC5-OFB"
+#define LN_rc5_ofb64            "rc5-ofb"
+#define NID_rc5_ofb64           123
+
+#define SN_ms_ext_req           "msExtReq"
+#define LN_ms_ext_req           "Microsoft Extension Request"
+#define NID_ms_ext_req          171
+#define OBJ_ms_ext_req          1L,3L,6L,1L,4L,1L,311L,2L,1L,14L
+
+#define SN_ms_code_ind          "msCodeInd"
+#define LN_ms_code_ind          "Microsoft Individual Code Signing"
+#define NID_ms_code_ind         134
+#define OBJ_ms_code_ind         1L,3L,6L,1L,4L,1L,311L,2L,1L,21L
+
+#define SN_ms_code_com          "msCodeCom"
+#define LN_ms_code_com          "Microsoft Commercial Code Signing"
+#define NID_ms_code_com         135
+#define OBJ_ms_code_com         1L,3L,6L,1L,4L,1L,311L,2L,1L,22L
+
+#define SN_ms_ctl_sign          "msCTLSign"
+#define LN_ms_ctl_sign          "Microsoft Trust List Signing"
+#define NID_ms_ctl_sign         136
+#define OBJ_ms_ctl_sign         1L,3L,6L,1L,4L,1L,311L,10L,3L,1L
+
+#define SN_ms_sgc               "msSGC"
+#define LN_ms_sgc               "Microsoft Server Gated Crypto"
+#define NID_ms_sgc              137
+#define OBJ_ms_sgc              1L,3L,6L,1L,4L,1L,311L,10L,3L,3L
+
+#define SN_ms_efs               "msEFS"
+#define LN_ms_efs               "Microsoft Encrypted File System"
+#define NID_ms_efs              138
+#define OBJ_ms_efs              1L,3L,6L,1L,4L,1L,311L,10L,3L,4L
+
+#define SN_ms_smartcard_login           "msSmartcardLogin"
+#define LN_ms_smartcard_login           "Microsoft Smartcard Login"
+#define NID_ms_smartcard_login          648
+#define OBJ_ms_smartcard_login          1L,3L,6L,1L,4L,1L,311L,20L,2L,2L
+
+#define SN_ms_upn               "msUPN"
+#define LN_ms_upn               "Microsoft User Principal Name"
+#define NID_ms_upn              649
+#define OBJ_ms_upn              1L,3L,6L,1L,4L,1L,311L,20L,2L,3L
+
+#define SN_idea_cbc             "IDEA-CBC"
+#define LN_idea_cbc             "idea-cbc"
+#define NID_idea_cbc            34
+#define OBJ_idea_cbc            1L,3L,6L,1L,4L,1L,188L,7L,1L,1L,2L
+
+#define SN_idea_ecb             "IDEA-ECB"
+#define LN_idea_ecb             "idea-ecb"
+#define NID_idea_ecb            36
+
+#define SN_idea_cfb64           "IDEA-CFB"
+#define LN_idea_cfb64           "idea-cfb"
+#define NID_idea_cfb64          35
+
+#define SN_idea_ofb64           "IDEA-OFB"
+#define LN_idea_ofb64           "idea-ofb"
+#define NID_idea_ofb64          46
+
+#define SN_bf_cbc               "BF-CBC"
+#define LN_bf_cbc               "bf-cbc"
+#define NID_bf_cbc              91
+#define OBJ_bf_cbc              1L,3L,6L,1L,4L,1L,3029L,1L,2L
+
+#define SN_bf_ecb               "BF-ECB"
+#define LN_bf_ecb               "bf-ecb"
+#define NID_bf_ecb              92
+
+#define SN_bf_cfb64             "BF-CFB"
+#define LN_bf_cfb64             "bf-cfb"
+#define NID_bf_cfb64            93
+
+#define SN_bf_ofb64             "BF-OFB"
+#define LN_bf_ofb64             "bf-ofb"
+#define NID_bf_ofb64            94
+
+#define SN_id_pkix              "PKIX"
+#define NID_id_pkix             127
+#define OBJ_id_pkix             1L,3L,6L,1L,5L,5L,7L
+
+#define SN_id_pkix_mod          "id-pkix-mod"
+#define NID_id_pkix_mod         258
+#define OBJ_id_pkix_mod         OBJ_id_pkix,0L
+
+#define SN_id_pe                "id-pe"
+#define NID_id_pe               175
+#define OBJ_id_pe               OBJ_id_pkix,1L
+
+#define SN_id_qt                "id-qt"
+#define NID_id_qt               259
+#define OBJ_id_qt               OBJ_id_pkix,2L
+
+#define SN_id_kp                "id-kp"
+#define NID_id_kp               128
+#define OBJ_id_kp               OBJ_id_pkix,3L
+
+#define SN_id_it                "id-it"
+#define NID_id_it               260
+#define OBJ_id_it               OBJ_id_pkix,4L
+
+#define SN_id_pkip              "id-pkip"
+#define NID_id_pkip             261
+#define OBJ_id_pkip             OBJ_id_pkix,5L
+
+#define SN_id_alg               "id-alg"
+#define NID_id_alg              262
+#define OBJ_id_alg              OBJ_id_pkix,6L
+
+#define SN_id_cmc               "id-cmc"
+#define NID_id_cmc              263
+#define OBJ_id_cmc              OBJ_id_pkix,7L
+
+#define SN_id_on                "id-on"
+#define NID_id_on               264
+#define OBJ_id_on               OBJ_id_pkix,8L
+
+#define SN_id_pda               "id-pda"
+#define NID_id_pda              265
+#define OBJ_id_pda              OBJ_id_pkix,9L
+
+#define SN_id_aca               "id-aca"
+#define NID_id_aca              266
+#define OBJ_id_aca              OBJ_id_pkix,10L
+
+#define SN_id_qcs               "id-qcs"
+#define NID_id_qcs              267
+#define OBJ_id_qcs              OBJ_id_pkix,11L
+
+#define SN_id_cp                "id-cp"
+#define NID_id_cp               1238
+#define OBJ_id_cp               OBJ_id_pkix,14L
+
+#define SN_id_cct               "id-cct"
+#define NID_id_cct              268
+#define OBJ_id_cct              OBJ_id_pkix,12L
+
+#define SN_id_ppl               "id-ppl"
+#define NID_id_ppl              662
+#define OBJ_id_ppl              OBJ_id_pkix,21L
+
+#define SN_id_ad                "id-ad"
+#define NID_id_ad               176
+#define OBJ_id_ad               OBJ_id_pkix,48L
+
+#define SN_id_pkix1_explicit_88         "id-pkix1-explicit-88"
+#define NID_id_pkix1_explicit_88                269
+#define OBJ_id_pkix1_explicit_88                OBJ_id_pkix_mod,1L
+
+#define SN_id_pkix1_implicit_88         "id-pkix1-implicit-88"
+#define NID_id_pkix1_implicit_88                270
+#define OBJ_id_pkix1_implicit_88                OBJ_id_pkix_mod,2L
+
+#define SN_id_pkix1_explicit_93         "id-pkix1-explicit-93"
+#define NID_id_pkix1_explicit_93                271
+#define OBJ_id_pkix1_explicit_93                OBJ_id_pkix_mod,3L
+
+#define SN_id_pkix1_implicit_93         "id-pkix1-implicit-93"
+#define NID_id_pkix1_implicit_93                272
+#define OBJ_id_pkix1_implicit_93                OBJ_id_pkix_mod,4L
+
+#define SN_id_mod_crmf          "id-mod-crmf"
+#define NID_id_mod_crmf         273
+#define OBJ_id_mod_crmf         OBJ_id_pkix_mod,5L
+
+#define SN_id_mod_cmc           "id-mod-cmc"
+#define NID_id_mod_cmc          274
+#define OBJ_id_mod_cmc          OBJ_id_pkix_mod,6L
+
+#define SN_id_mod_kea_profile_88                "id-mod-kea-profile-88"
+#define NID_id_mod_kea_profile_88               275
+#define OBJ_id_mod_kea_profile_88               OBJ_id_pkix_mod,7L
+
+#define SN_id_mod_kea_profile_93                "id-mod-kea-profile-93"
+#define NID_id_mod_kea_profile_93               276
+#define OBJ_id_mod_kea_profile_93               OBJ_id_pkix_mod,8L
+
+#define SN_id_mod_cmp           "id-mod-cmp"
+#define NID_id_mod_cmp          277
+#define OBJ_id_mod_cmp          OBJ_id_pkix_mod,9L
+
+#define SN_id_mod_qualified_cert_88             "id-mod-qualified-cert-88"
+#define NID_id_mod_qualified_cert_88            278
+#define OBJ_id_mod_qualified_cert_88            OBJ_id_pkix_mod,10L
+
+#define SN_id_mod_qualified_cert_93             "id-mod-qualified-cert-93"
+#define NID_id_mod_qualified_cert_93            279
+#define OBJ_id_mod_qualified_cert_93            OBJ_id_pkix_mod,11L
+
+#define SN_id_mod_attribute_cert                "id-mod-attribute-cert"
+#define NID_id_mod_attribute_cert               280
+#define OBJ_id_mod_attribute_cert               OBJ_id_pkix_mod,12L
+
+#define SN_id_mod_timestamp_protocol            "id-mod-timestamp-protocol"
+#define NID_id_mod_timestamp_protocol           281
+#define OBJ_id_mod_timestamp_protocol           OBJ_id_pkix_mod,13L
+
+#define SN_id_mod_ocsp          "id-mod-ocsp"
+#define NID_id_mod_ocsp         282
+#define OBJ_id_mod_ocsp         OBJ_id_pkix_mod,14L
+
+#define SN_id_mod_dvcs          "id-mod-dvcs"
+#define NID_id_mod_dvcs         283
+#define OBJ_id_mod_dvcs         OBJ_id_pkix_mod,15L
+
+#define SN_id_mod_cmp2000               "id-mod-cmp2000"
+#define NID_id_mod_cmp2000              284
+#define OBJ_id_mod_cmp2000              OBJ_id_pkix_mod,16L
+
+#define SN_info_access          "authorityInfoAccess"
+#define LN_info_access          "Authority Information Access"
+#define NID_info_access         177
+#define OBJ_info_access         OBJ_id_pe,1L
+
+#define SN_biometricInfo                "biometricInfo"
+#define LN_biometricInfo                "Biometric Info"
+#define NID_biometricInfo               285
+#define OBJ_biometricInfo               OBJ_id_pe,2L
+
+#define SN_qcStatements         "qcStatements"
+#define NID_qcStatements                286
+#define OBJ_qcStatements                OBJ_id_pe,3L
+
+#define SN_ac_auditEntity               "ac-auditEntity"
+#define NID_ac_auditEntity              287
+#define OBJ_ac_auditEntity              OBJ_id_pe,4L
+
+#define SN_ac_targeting         "ac-targeting"
+#define NID_ac_targeting                288
+#define OBJ_ac_targeting                OBJ_id_pe,5L
+
+#define SN_aaControls           "aaControls"
+#define NID_aaControls          289
+#define OBJ_aaControls          OBJ_id_pe,6L
+
+#define SN_sbgp_ipAddrBlock             "sbgp-ipAddrBlock"
+#define NID_sbgp_ipAddrBlock            290
+#define OBJ_sbgp_ipAddrBlock            OBJ_id_pe,7L
+
+#define SN_sbgp_autonomousSysNum                "sbgp-autonomousSysNum"
+#define NID_sbgp_autonomousSysNum               291
+#define OBJ_sbgp_autonomousSysNum               OBJ_id_pe,8L
+
+#define SN_sbgp_routerIdentifier                "sbgp-routerIdentifier"
+#define NID_sbgp_routerIdentifier               292
+#define OBJ_sbgp_routerIdentifier               OBJ_id_pe,9L
+
+#define SN_ac_proxying          "ac-proxying"
+#define NID_ac_proxying         397
+#define OBJ_ac_proxying         OBJ_id_pe,10L
+
+#define SN_sinfo_access         "subjectInfoAccess"
+#define LN_sinfo_access         "Subject Information Access"
+#define NID_sinfo_access                398
+#define OBJ_sinfo_access                OBJ_id_pe,11L
+
+#define SN_proxyCertInfo                "proxyCertInfo"
+#define LN_proxyCertInfo                "Proxy Certificate Information"
+#define NID_proxyCertInfo               663
+#define OBJ_proxyCertInfo               OBJ_id_pe,14L
+
+#define SN_tlsfeature           "tlsfeature"
+#define LN_tlsfeature           "TLS Feature"
+#define NID_tlsfeature          1020
+#define OBJ_tlsfeature          OBJ_id_pe,24L
+
+#define SN_sbgp_ipAddrBlockv2           "sbgp-ipAddrBlockv2"
+#define NID_sbgp_ipAddrBlockv2          1239
+#define OBJ_sbgp_ipAddrBlockv2          OBJ_id_pe,28L
+
+#define SN_sbgp_autonomousSysNumv2              "sbgp-autonomousSysNumv2"
+#define NID_sbgp_autonomousSysNumv2             1240
+#define OBJ_sbgp_autonomousSysNumv2             OBJ_id_pe,29L
+
+#define SN_id_qt_cps            "id-qt-cps"
+#define LN_id_qt_cps            "Policy Qualifier CPS"
+#define NID_id_qt_cps           164
+#define OBJ_id_qt_cps           OBJ_id_qt,1L
+
+#define SN_id_qt_unotice                "id-qt-unotice"
+#define LN_id_qt_unotice                "Policy Qualifier User Notice"
+#define NID_id_qt_unotice               165
+#define OBJ_id_qt_unotice               OBJ_id_qt,2L
+
+#define SN_textNotice           "textNotice"
+#define NID_textNotice          293
+#define OBJ_textNotice          OBJ_id_qt,3L
+
+#define SN_server_auth          "serverAuth"
+#define LN_server_auth          "TLS Web Server Authentication"
+#define NID_server_auth         129
+#define OBJ_server_auth         OBJ_id_kp,1L
+
+#define SN_client_auth          "clientAuth"
+#define LN_client_auth          "TLS Web Client Authentication"
+#define NID_client_auth         130
+#define OBJ_client_auth         OBJ_id_kp,2L
+
+#define SN_code_sign            "codeSigning"
+#define LN_code_sign            "Code Signing"
+#define NID_code_sign           131
+#define OBJ_code_sign           OBJ_id_kp,3L
+
+#define SN_email_protect                "emailProtection"
+#define LN_email_protect                "E-mail Protection"
+#define NID_email_protect               132
+#define OBJ_email_protect               OBJ_id_kp,4L
+
+#define SN_ipsecEndSystem               "ipsecEndSystem"
+#define LN_ipsecEndSystem               "IPSec End System"
+#define NID_ipsecEndSystem              294
+#define OBJ_ipsecEndSystem              OBJ_id_kp,5L
+
+#define SN_ipsecTunnel          "ipsecTunnel"
+#define LN_ipsecTunnel          "IPSec Tunnel"
+#define NID_ipsecTunnel         295
+#define OBJ_ipsecTunnel         OBJ_id_kp,6L
+
+#define SN_ipsecUser            "ipsecUser"
+#define LN_ipsecUser            "IPSec User"
+#define NID_ipsecUser           296
+#define OBJ_ipsecUser           OBJ_id_kp,7L
+
+#define SN_time_stamp           "timeStamping"
+#define LN_time_stamp           "Time Stamping"
+#define NID_time_stamp          133
+#define OBJ_time_stamp          OBJ_id_kp,8L
+
+#define SN_OCSP_sign            "OCSPSigning"
+#define LN_OCSP_sign            "OCSP Signing"
+#define NID_OCSP_sign           180
+#define OBJ_OCSP_sign           OBJ_id_kp,9L
+
+#define SN_dvcs         "DVCS"
+#define LN_dvcs         "dvcs"
+#define NID_dvcs                297
+#define OBJ_dvcs                OBJ_id_kp,10L
+
+#define SN_ipsec_IKE            "ipsecIKE"
+#define LN_ipsec_IKE            "ipsec Internet Key Exchange"
+#define NID_ipsec_IKE           1022
+#define OBJ_ipsec_IKE           OBJ_id_kp,17L
+
+#define SN_capwapAC             "capwapAC"
+#define LN_capwapAC             "Ctrl/provision WAP Access"
+#define NID_capwapAC            1023
+#define OBJ_capwapAC            OBJ_id_kp,18L
+
+#define SN_capwapWTP            "capwapWTP"
+#define LN_capwapWTP            "Ctrl/Provision WAP Termination"
+#define NID_capwapWTP           1024
+#define OBJ_capwapWTP           OBJ_id_kp,19L
+
+#define SN_sshClient            "secureShellClient"
+#define LN_sshClient            "SSH Client"
+#define NID_sshClient           1025
+#define OBJ_sshClient           OBJ_id_kp,21L
+
+#define SN_sshServer            "secureShellServer"
+#define LN_sshServer            "SSH Server"
+#define NID_sshServer           1026
+#define OBJ_sshServer           OBJ_id_kp,22L
+
+#define SN_sendRouter           "sendRouter"
+#define LN_sendRouter           "Send Router"
+#define NID_sendRouter          1027
+#define OBJ_sendRouter          OBJ_id_kp,23L
+
+#define SN_sendProxiedRouter            "sendProxiedRouter"
+#define LN_sendProxiedRouter            "Send Proxied Router"
+#define NID_sendProxiedRouter           1028
+#define OBJ_sendProxiedRouter           OBJ_id_kp,24L
+
+#define SN_sendOwner            "sendOwner"
+#define LN_sendOwner            "Send Owner"
+#define NID_sendOwner           1029
+#define OBJ_sendOwner           OBJ_id_kp,25L
+
+#define SN_sendProxiedOwner             "sendProxiedOwner"
+#define LN_sendProxiedOwner             "Send Proxied Owner"
+#define NID_sendProxiedOwner            1030
+#define OBJ_sendProxiedOwner            OBJ_id_kp,26L
+
+#define SN_cmcCA                "cmcCA"
+#define LN_cmcCA                "CMC Certificate Authority"
+#define NID_cmcCA               1131
+#define OBJ_cmcCA               OBJ_id_kp,27L
+
+#define SN_cmcRA                "cmcRA"
+#define LN_cmcRA                "CMC Registration Authority"
+#define NID_cmcRA               1132
+#define OBJ_cmcRA               OBJ_id_kp,28L
+
+#define SN_cmcArchive           "cmcArchive"
+#define LN_cmcArchive           "CMC Archive Server"
+#define NID_cmcArchive          1219
+#define OBJ_cmcArchive          OBJ_id_kp,29L
+
+#define SN_id_kp_bgpsec_router          "id-kp-bgpsec-router"
+#define LN_id_kp_bgpsec_router          "BGPsec Router"
+#define NID_id_kp_bgpsec_router         1220
+#define OBJ_id_kp_bgpsec_router         OBJ_id_kp,30L
+
+#define SN_id_kp_BrandIndicatorforMessageIdentification         "id-kp-BrandIndicatorforMessageIdentification"
+#define LN_id_kp_BrandIndicatorforMessageIdentification         "Brand Indicator for Message Identification"
+#define NID_id_kp_BrandIndicatorforMessageIdentification                1221
+#define OBJ_id_kp_BrandIndicatorforMessageIdentification                OBJ_id_kp,31L
+
+#define SN_cmKGA                "cmKGA"
+#define LN_cmKGA                "Certificate Management Key Generation Authority"
+#define NID_cmKGA               1222
+#define OBJ_cmKGA               OBJ_id_kp,32L
+
+#define SN_id_it_caProtEncCert          "id-it-caProtEncCert"
+#define NID_id_it_caProtEncCert         298
+#define OBJ_id_it_caProtEncCert         OBJ_id_it,1L
+
+#define SN_id_it_signKeyPairTypes               "id-it-signKeyPairTypes"
+#define NID_id_it_signKeyPairTypes              299
+#define OBJ_id_it_signKeyPairTypes              OBJ_id_it,2L
+
+#define SN_id_it_encKeyPairTypes                "id-it-encKeyPairTypes"
+#define NID_id_it_encKeyPairTypes               300
+#define OBJ_id_it_encKeyPairTypes               OBJ_id_it,3L
+
+#define SN_id_it_preferredSymmAlg               "id-it-preferredSymmAlg"
+#define NID_id_it_preferredSymmAlg              301
+#define OBJ_id_it_preferredSymmAlg              OBJ_id_it,4L
+
+#define SN_id_it_caKeyUpdateInfo                "id-it-caKeyUpdateInfo"
+#define NID_id_it_caKeyUpdateInfo               302
+#define OBJ_id_it_caKeyUpdateInfo               OBJ_id_it,5L
+
+#define SN_id_it_currentCRL             "id-it-currentCRL"
+#define NID_id_it_currentCRL            303
+#define OBJ_id_it_currentCRL            OBJ_id_it,6L
+
+#define SN_id_it_unsupportedOIDs                "id-it-unsupportedOIDs"
+#define NID_id_it_unsupportedOIDs               304
+#define OBJ_id_it_unsupportedOIDs               OBJ_id_it,7L
+
+#define SN_id_it_subscriptionRequest            "id-it-subscriptionRequest"
+#define NID_id_it_subscriptionRequest           305
+#define OBJ_id_it_subscriptionRequest           OBJ_id_it,8L
+
+#define SN_id_it_subscriptionResponse           "id-it-subscriptionResponse"
+#define NID_id_it_subscriptionResponse          306
+#define OBJ_id_it_subscriptionResponse          OBJ_id_it,9L
+
+#define SN_id_it_keyPairParamReq                "id-it-keyPairParamReq"
+#define NID_id_it_keyPairParamReq               307
+#define OBJ_id_it_keyPairParamReq               OBJ_id_it,10L
+
+#define SN_id_it_keyPairParamRep                "id-it-keyPairParamRep"
+#define NID_id_it_keyPairParamRep               308
+#define OBJ_id_it_keyPairParamRep               OBJ_id_it,11L
+
+#define SN_id_it_revPassphrase          "id-it-revPassphrase"
+#define NID_id_it_revPassphrase         309
+#define OBJ_id_it_revPassphrase         OBJ_id_it,12L
+
+#define SN_id_it_implicitConfirm                "id-it-implicitConfirm"
+#define NID_id_it_implicitConfirm               310
+#define OBJ_id_it_implicitConfirm               OBJ_id_it,13L
+
+#define SN_id_it_confirmWaitTime                "id-it-confirmWaitTime"
+#define NID_id_it_confirmWaitTime               311
+#define OBJ_id_it_confirmWaitTime               OBJ_id_it,14L
+
+#define SN_id_it_origPKIMessage         "id-it-origPKIMessage"
+#define NID_id_it_origPKIMessage                312
+#define OBJ_id_it_origPKIMessage                OBJ_id_it,15L
+
+#define SN_id_it_suppLangTags           "id-it-suppLangTags"
+#define NID_id_it_suppLangTags          784
+#define OBJ_id_it_suppLangTags          OBJ_id_it,16L
+
+#define SN_id_it_caCerts                "id-it-caCerts"
+#define NID_id_it_caCerts               1223
+#define OBJ_id_it_caCerts               OBJ_id_it,17L
+
+#define SN_id_it_rootCaKeyUpdate                "id-it-rootCaKeyUpdate"
+#define NID_id_it_rootCaKeyUpdate               1224
+#define OBJ_id_it_rootCaKeyUpdate               OBJ_id_it,18L
+
+#define SN_id_it_certReqTemplate                "id-it-certReqTemplate"
+#define NID_id_it_certReqTemplate               1225
+#define OBJ_id_it_certReqTemplate               OBJ_id_it,19L
+
+#define SN_id_regCtrl           "id-regCtrl"
+#define NID_id_regCtrl          313
+#define OBJ_id_regCtrl          OBJ_id_pkip,1L
+
+#define SN_id_regInfo           "id-regInfo"
+#define NID_id_regInfo          314
+#define OBJ_id_regInfo          OBJ_id_pkip,2L
+
+#define SN_id_regCtrl_regToken          "id-regCtrl-regToken"
+#define NID_id_regCtrl_regToken         315
+#define OBJ_id_regCtrl_regToken         OBJ_id_regCtrl,1L
+
+#define SN_id_regCtrl_authenticator             "id-regCtrl-authenticator"
+#define NID_id_regCtrl_authenticator            316
+#define OBJ_id_regCtrl_authenticator            OBJ_id_regCtrl,2L
+
+#define SN_id_regCtrl_pkiPublicationInfo                "id-regCtrl-pkiPublicationInfo"
+#define NID_id_regCtrl_pkiPublicationInfo               317
+#define OBJ_id_regCtrl_pkiPublicationInfo               OBJ_id_regCtrl,3L
+
+#define SN_id_regCtrl_pkiArchiveOptions         "id-regCtrl-pkiArchiveOptions"
+#define NID_id_regCtrl_pkiArchiveOptions                318
+#define OBJ_id_regCtrl_pkiArchiveOptions                OBJ_id_regCtrl,4L
+
+#define SN_id_regCtrl_oldCertID         "id-regCtrl-oldCertID"
+#define NID_id_regCtrl_oldCertID                319
+#define OBJ_id_regCtrl_oldCertID                OBJ_id_regCtrl,5L
+
+#define SN_id_regCtrl_protocolEncrKey           "id-regCtrl-protocolEncrKey"
+#define NID_id_regCtrl_protocolEncrKey          320
+#define OBJ_id_regCtrl_protocolEncrKey          OBJ_id_regCtrl,6L
+
+#define SN_id_regInfo_utf8Pairs         "id-regInfo-utf8Pairs"
+#define NID_id_regInfo_utf8Pairs                321
+#define OBJ_id_regInfo_utf8Pairs                OBJ_id_regInfo,1L
+
+#define SN_id_regInfo_certReq           "id-regInfo-certReq"
+#define NID_id_regInfo_certReq          322
+#define OBJ_id_regInfo_certReq          OBJ_id_regInfo,2L
+
+#define SN_id_alg_des40         "id-alg-des40"
+#define NID_id_alg_des40                323
+#define OBJ_id_alg_des40                OBJ_id_alg,1L
+
+#define SN_id_alg_noSignature           "id-alg-noSignature"
+#define NID_id_alg_noSignature          324
+#define OBJ_id_alg_noSignature          OBJ_id_alg,2L
+
+#define SN_id_alg_dh_sig_hmac_sha1              "id-alg-dh-sig-hmac-sha1"
+#define NID_id_alg_dh_sig_hmac_sha1             325
+#define OBJ_id_alg_dh_sig_hmac_sha1             OBJ_id_alg,3L
+
+#define SN_id_alg_dh_pop                "id-alg-dh-pop"
+#define NID_id_alg_dh_pop               326
+#define OBJ_id_alg_dh_pop               OBJ_id_alg,4L
+
+#define SN_id_cmc_statusInfo            "id-cmc-statusInfo"
+#define NID_id_cmc_statusInfo           327
+#define OBJ_id_cmc_statusInfo           OBJ_id_cmc,1L
+
+#define SN_id_cmc_identification                "id-cmc-identification"
+#define NID_id_cmc_identification               328
+#define OBJ_id_cmc_identification               OBJ_id_cmc,2L
+
+#define SN_id_cmc_identityProof         "id-cmc-identityProof"
+#define NID_id_cmc_identityProof                329
+#define OBJ_id_cmc_identityProof                OBJ_id_cmc,3L
+
+#define SN_id_cmc_dataReturn            "id-cmc-dataReturn"
+#define NID_id_cmc_dataReturn           330
+#define OBJ_id_cmc_dataReturn           OBJ_id_cmc,4L
+
+#define SN_id_cmc_transactionId         "id-cmc-transactionId"
+#define NID_id_cmc_transactionId                331
+#define OBJ_id_cmc_transactionId                OBJ_id_cmc,5L
+
+#define SN_id_cmc_senderNonce           "id-cmc-senderNonce"
+#define NID_id_cmc_senderNonce          332
+#define OBJ_id_cmc_senderNonce          OBJ_id_cmc,6L
+
+#define SN_id_cmc_recipientNonce                "id-cmc-recipientNonce"
+#define NID_id_cmc_recipientNonce               333
+#define OBJ_id_cmc_recipientNonce               OBJ_id_cmc,7L
+
+#define SN_id_cmc_addExtensions         "id-cmc-addExtensions"
+#define NID_id_cmc_addExtensions                334
+#define OBJ_id_cmc_addExtensions                OBJ_id_cmc,8L
+
+#define SN_id_cmc_encryptedPOP          "id-cmc-encryptedPOP"
+#define NID_id_cmc_encryptedPOP         335
+#define OBJ_id_cmc_encryptedPOP         OBJ_id_cmc,9L
+
+#define SN_id_cmc_decryptedPOP          "id-cmc-decryptedPOP"
+#define NID_id_cmc_decryptedPOP         336
+#define OBJ_id_cmc_decryptedPOP         OBJ_id_cmc,10L
+
+#define SN_id_cmc_lraPOPWitness         "id-cmc-lraPOPWitness"
+#define NID_id_cmc_lraPOPWitness                337
+#define OBJ_id_cmc_lraPOPWitness                OBJ_id_cmc,11L
+
+#define SN_id_cmc_getCert               "id-cmc-getCert"
+#define NID_id_cmc_getCert              338
+#define OBJ_id_cmc_getCert              OBJ_id_cmc,15L
+
+#define SN_id_cmc_getCRL                "id-cmc-getCRL"
+#define NID_id_cmc_getCRL               339
+#define OBJ_id_cmc_getCRL               OBJ_id_cmc,16L
+
+#define SN_id_cmc_revokeRequest         "id-cmc-revokeRequest"
+#define NID_id_cmc_revokeRequest                340
+#define OBJ_id_cmc_revokeRequest                OBJ_id_cmc,17L
+
+#define SN_id_cmc_regInfo               "id-cmc-regInfo"
+#define NID_id_cmc_regInfo              341
+#define OBJ_id_cmc_regInfo              OBJ_id_cmc,18L
+
+#define SN_id_cmc_responseInfo          "id-cmc-responseInfo"
+#define NID_id_cmc_responseInfo         342
+#define OBJ_id_cmc_responseInfo         OBJ_id_cmc,19L
+
+#define SN_id_cmc_queryPending          "id-cmc-queryPending"
+#define NID_id_cmc_queryPending         343
+#define OBJ_id_cmc_queryPending         OBJ_id_cmc,21L
+
+#define SN_id_cmc_popLinkRandom         "id-cmc-popLinkRandom"
+#define NID_id_cmc_popLinkRandom                344
+#define OBJ_id_cmc_popLinkRandom                OBJ_id_cmc,22L
+
+#define SN_id_cmc_popLinkWitness                "id-cmc-popLinkWitness"
+#define NID_id_cmc_popLinkWitness               345
+#define OBJ_id_cmc_popLinkWitness               OBJ_id_cmc,23L
+
+#define SN_id_cmc_confirmCertAcceptance         "id-cmc-confirmCertAcceptance"
+#define NID_id_cmc_confirmCertAcceptance                346
+#define OBJ_id_cmc_confirmCertAcceptance                OBJ_id_cmc,24L
+
+#define SN_id_on_personalData           "id-on-personalData"
+#define NID_id_on_personalData          347
+#define OBJ_id_on_personalData          OBJ_id_on,1L
+
+#define SN_id_on_permanentIdentifier            "id-on-permanentIdentifier"
+#define LN_id_on_permanentIdentifier            "Permanent Identifier"
+#define NID_id_on_permanentIdentifier           858
+#define OBJ_id_on_permanentIdentifier           OBJ_id_on,3L
+
+#define SN_XmppAddr             "id-on-xmppAddr"
+#define LN_XmppAddr             "XmppAddr"
+#define NID_XmppAddr            1209
+#define OBJ_XmppAddr            OBJ_id_on,5L
+
+#define SN_SRVName              "id-on-dnsSRV"
+#define LN_SRVName              "SRVName"
+#define NID_SRVName             1210
+#define OBJ_SRVName             OBJ_id_on,7L
+
+#define SN_NAIRealm             "id-on-NAIRealm"
+#define LN_NAIRealm             "NAIRealm"
+#define NID_NAIRealm            1211
+#define OBJ_NAIRealm            OBJ_id_on,8L
+
+#define SN_id_on_SmtpUTF8Mailbox                "id-on-SmtpUTF8Mailbox"
+#define LN_id_on_SmtpUTF8Mailbox                "Smtp UTF8 Mailbox"
+#define NID_id_on_SmtpUTF8Mailbox               1208
+#define OBJ_id_on_SmtpUTF8Mailbox               OBJ_id_on,9L
+
+#define SN_id_pda_dateOfBirth           "id-pda-dateOfBirth"
+#define NID_id_pda_dateOfBirth          348
+#define OBJ_id_pda_dateOfBirth          OBJ_id_pda,1L
+
+#define SN_id_pda_placeOfBirth          "id-pda-placeOfBirth"
+#define NID_id_pda_placeOfBirth         349
+#define OBJ_id_pda_placeOfBirth         OBJ_id_pda,2L
+
+#define SN_id_pda_gender                "id-pda-gender"
+#define NID_id_pda_gender               351
+#define OBJ_id_pda_gender               OBJ_id_pda,3L
+
+#define SN_id_pda_countryOfCitizenship          "id-pda-countryOfCitizenship"
+#define NID_id_pda_countryOfCitizenship         352
+#define OBJ_id_pda_countryOfCitizenship         OBJ_id_pda,4L
+
+#define SN_id_pda_countryOfResidence            "id-pda-countryOfResidence"
+#define NID_id_pda_countryOfResidence           353
+#define OBJ_id_pda_countryOfResidence           OBJ_id_pda,5L
+
+#define SN_id_aca_authenticationInfo            "id-aca-authenticationInfo"
+#define NID_id_aca_authenticationInfo           354
+#define OBJ_id_aca_authenticationInfo           OBJ_id_aca,1L
+
+#define SN_id_aca_accessIdentity                "id-aca-accessIdentity"
+#define NID_id_aca_accessIdentity               355
+#define OBJ_id_aca_accessIdentity               OBJ_id_aca,2L
+
+#define SN_id_aca_chargingIdentity              "id-aca-chargingIdentity"
+#define NID_id_aca_chargingIdentity             356
+#define OBJ_id_aca_chargingIdentity             OBJ_id_aca,3L
+
+#define SN_id_aca_group         "id-aca-group"
+#define NID_id_aca_group                357
+#define OBJ_id_aca_group                OBJ_id_aca,4L
+
+#define SN_id_aca_role          "id-aca-role"
+#define NID_id_aca_role         358
+#define OBJ_id_aca_role         OBJ_id_aca,5L
+
+#define SN_id_aca_encAttrs              "id-aca-encAttrs"
+#define NID_id_aca_encAttrs             399
+#define OBJ_id_aca_encAttrs             OBJ_id_aca,6L
+
+#define SN_id_qcs_pkixQCSyntax_v1               "id-qcs-pkixQCSyntax-v1"
+#define NID_id_qcs_pkixQCSyntax_v1              359
+#define OBJ_id_qcs_pkixQCSyntax_v1              OBJ_id_qcs,1L
+
+#define SN_ipAddr_asNumber              "ipAddr-asNumber"
+#define NID_ipAddr_asNumber             1241
+#define OBJ_ipAddr_asNumber             OBJ_id_cp,2L
+
+#define SN_ipAddr_asNumberv2            "ipAddr-asNumberv2"
+#define NID_ipAddr_asNumberv2           1242
+#define OBJ_ipAddr_asNumberv2           OBJ_id_cp,3L
+
+#define SN_id_cct_crs           "id-cct-crs"
+#define NID_id_cct_crs          360
+#define OBJ_id_cct_crs          OBJ_id_cct,1L
+
+#define SN_id_cct_PKIData               "id-cct-PKIData"
+#define NID_id_cct_PKIData              361
+#define OBJ_id_cct_PKIData              OBJ_id_cct,2L
+
+#define SN_id_cct_PKIResponse           "id-cct-PKIResponse"
+#define NID_id_cct_PKIResponse          362
+#define OBJ_id_cct_PKIResponse          OBJ_id_cct,3L
+
+#define SN_id_ppl_anyLanguage           "id-ppl-anyLanguage"
+#define LN_id_ppl_anyLanguage           "Any language"
+#define NID_id_ppl_anyLanguage          664
+#define OBJ_id_ppl_anyLanguage          OBJ_id_ppl,0L
+
+#define SN_id_ppl_inheritAll            "id-ppl-inheritAll"
+#define LN_id_ppl_inheritAll            "Inherit all"
+#define NID_id_ppl_inheritAll           665
+#define OBJ_id_ppl_inheritAll           OBJ_id_ppl,1L
+
+#define SN_Independent          "id-ppl-independent"
+#define LN_Independent          "Independent"
+#define NID_Independent         667
+#define OBJ_Independent         OBJ_id_ppl,2L
+
+#define SN_ad_OCSP              "OCSP"
+#define LN_ad_OCSP              "OCSP"
+#define NID_ad_OCSP             178
+#define OBJ_ad_OCSP             OBJ_id_ad,1L
+
+#define SN_ad_ca_issuers                "caIssuers"
+#define LN_ad_ca_issuers                "CA Issuers"
+#define NID_ad_ca_issuers               179
+#define OBJ_ad_ca_issuers               OBJ_id_ad,2L
+
+#define SN_ad_timeStamping              "ad_timestamping"
+#define LN_ad_timeStamping              "AD Time Stamping"
+#define NID_ad_timeStamping             363
+#define OBJ_ad_timeStamping             OBJ_id_ad,3L
+
+#define SN_ad_dvcs              "AD_DVCS"
+#define LN_ad_dvcs              "ad dvcs"
+#define NID_ad_dvcs             364
+#define OBJ_ad_dvcs             OBJ_id_ad,4L
+
+#define SN_caRepository         "caRepository"
+#define LN_caRepository         "CA Repository"
+#define NID_caRepository                785
+#define OBJ_caRepository                OBJ_id_ad,5L
+
+#define SN_rpkiManifest         "rpkiManifest"
+#define LN_rpkiManifest         "RPKI Manifest"
+#define NID_rpkiManifest                1243
+#define OBJ_rpkiManifest                OBJ_id_ad,10L
+
+#define SN_signedObject         "signedObject"
+#define LN_signedObject         "Signed Object"
+#define NID_signedObject                1244
+#define OBJ_signedObject                OBJ_id_ad,11L
+
+#define SN_rpkiNotify           "rpkiNotify"
+#define LN_rpkiNotify           "RPKI Notify"
+#define NID_rpkiNotify          1245
+#define OBJ_rpkiNotify          OBJ_id_ad,13L
+
+#define OBJ_id_pkix_OCSP                OBJ_ad_OCSP
+
+#define SN_id_pkix_OCSP_basic           "basicOCSPResponse"
+#define LN_id_pkix_OCSP_basic           "Basic OCSP Response"
+#define NID_id_pkix_OCSP_basic          365
+#define OBJ_id_pkix_OCSP_basic          OBJ_id_pkix_OCSP,1L
+
+#define SN_id_pkix_OCSP_Nonce           "Nonce"
+#define LN_id_pkix_OCSP_Nonce           "OCSP Nonce"
+#define NID_id_pkix_OCSP_Nonce          366
+#define OBJ_id_pkix_OCSP_Nonce          OBJ_id_pkix_OCSP,2L
+
+#define SN_id_pkix_OCSP_CrlID           "CrlID"
+#define LN_id_pkix_OCSP_CrlID           "OCSP CRL ID"
+#define NID_id_pkix_OCSP_CrlID          367
+#define OBJ_id_pkix_OCSP_CrlID          OBJ_id_pkix_OCSP,3L
+
+#define SN_id_pkix_OCSP_acceptableResponses             "acceptableResponses"
+#define LN_id_pkix_OCSP_acceptableResponses             "Acceptable OCSP Responses"
+#define NID_id_pkix_OCSP_acceptableResponses            368
+#define OBJ_id_pkix_OCSP_acceptableResponses            OBJ_id_pkix_OCSP,4L
+
+#define SN_id_pkix_OCSP_noCheck         "noCheck"
+#define LN_id_pkix_OCSP_noCheck         "OCSP No Check"
+#define NID_id_pkix_OCSP_noCheck                369
+#define OBJ_id_pkix_OCSP_noCheck                OBJ_id_pkix_OCSP,5L
+
+#define SN_id_pkix_OCSP_archiveCutoff           "archiveCutoff"
+#define LN_id_pkix_OCSP_archiveCutoff           "OCSP Archive Cutoff"
+#define NID_id_pkix_OCSP_archiveCutoff          370
+#define OBJ_id_pkix_OCSP_archiveCutoff          OBJ_id_pkix_OCSP,6L
+
+#define SN_id_pkix_OCSP_serviceLocator          "serviceLocator"
+#define LN_id_pkix_OCSP_serviceLocator          "OCSP Service Locator"
+#define NID_id_pkix_OCSP_serviceLocator         371
+#define OBJ_id_pkix_OCSP_serviceLocator         OBJ_id_pkix_OCSP,7L
+
+#define SN_id_pkix_OCSP_extendedStatus          "extendedStatus"
+#define LN_id_pkix_OCSP_extendedStatus          "Extended OCSP Status"
+#define NID_id_pkix_OCSP_extendedStatus         372
+#define OBJ_id_pkix_OCSP_extendedStatus         OBJ_id_pkix_OCSP,8L
+
+#define SN_id_pkix_OCSP_valid           "valid"
+#define NID_id_pkix_OCSP_valid          373
+#define OBJ_id_pkix_OCSP_valid          OBJ_id_pkix_OCSP,9L
+
+#define SN_id_pkix_OCSP_path            "path"
+#define NID_id_pkix_OCSP_path           374
+#define OBJ_id_pkix_OCSP_path           OBJ_id_pkix_OCSP,10L
+
+#define SN_id_pkix_OCSP_trustRoot               "trustRoot"
+#define LN_id_pkix_OCSP_trustRoot               "Trust Root"
+#define NID_id_pkix_OCSP_trustRoot              375
+#define OBJ_id_pkix_OCSP_trustRoot              OBJ_id_pkix_OCSP,11L
+
+#define SN_algorithm            "algorithm"
+#define LN_algorithm            "algorithm"
+#define NID_algorithm           376
+#define OBJ_algorithm           1L,3L,14L,3L,2L
+
+#define SN_md5WithRSA           "RSA-NP-MD5"
+#define LN_md5WithRSA           "md5WithRSA"
+#define NID_md5WithRSA          104
+#define OBJ_md5WithRSA          OBJ_algorithm,3L
+
+#define SN_des_ecb              "DES-ECB"
+#define LN_des_ecb              "des-ecb"
+#define NID_des_ecb             29
+#define OBJ_des_ecb             OBJ_algorithm,6L
+
+#define SN_des_cbc              "DES-CBC"
+#define LN_des_cbc              "des-cbc"
+#define NID_des_cbc             31
+#define OBJ_des_cbc             OBJ_algorithm,7L
+
+#define SN_des_ofb64            "DES-OFB"
+#define LN_des_ofb64            "des-ofb"
+#define NID_des_ofb64           45
+#define OBJ_des_ofb64           OBJ_algorithm,8L
+
+#define SN_des_cfb64            "DES-CFB"
+#define LN_des_cfb64            "des-cfb"
+#define NID_des_cfb64           30
+#define OBJ_des_cfb64           OBJ_algorithm,9L
+
+#define SN_rsaSignature         "rsaSignature"
+#define NID_rsaSignature                377
+#define OBJ_rsaSignature                OBJ_algorithm,11L
+
+#define SN_dsa_2                "DSA-old"
+#define LN_dsa_2                "dsaEncryption-old"
+#define NID_dsa_2               67
+#define OBJ_dsa_2               OBJ_algorithm,12L
+
+#define SN_dsaWithSHA           "DSA-SHA"
+#define LN_dsaWithSHA           "dsaWithSHA"
+#define NID_dsaWithSHA          66
+#define OBJ_dsaWithSHA          OBJ_algorithm,13L
+
+#define SN_shaWithRSAEncryption         "RSA-SHA"
+#define LN_shaWithRSAEncryption         "shaWithRSAEncryption"
+#define NID_shaWithRSAEncryption                42
+#define OBJ_shaWithRSAEncryption                OBJ_algorithm,15L
+
+#define SN_des_ede_ecb          "DES-EDE"
+#define LN_des_ede_ecb          "des-ede"
+#define NID_des_ede_ecb         32
+#define OBJ_des_ede_ecb         OBJ_algorithm,17L
+
+#define SN_des_ede3_ecb         "DES-EDE3"
+#define LN_des_ede3_ecb         "des-ede3"
+#define NID_des_ede3_ecb                33
+
+#define SN_des_ede_cbc          "DES-EDE-CBC"
+#define LN_des_ede_cbc          "des-ede-cbc"
+#define NID_des_ede_cbc         43
+
+#define SN_des_ede_cfb64                "DES-EDE-CFB"
+#define LN_des_ede_cfb64                "des-ede-cfb"
+#define NID_des_ede_cfb64               60
+
+#define SN_des_ede3_cfb64               "DES-EDE3-CFB"
+#define LN_des_ede3_cfb64               "des-ede3-cfb"
+#define NID_des_ede3_cfb64              61
+
+#define SN_des_ede_ofb64                "DES-EDE-OFB"
+#define LN_des_ede_ofb64                "des-ede-ofb"
+#define NID_des_ede_ofb64               62
+
+#define SN_des_ede3_ofb64               "DES-EDE3-OFB"
+#define LN_des_ede3_ofb64               "des-ede3-ofb"
+#define NID_des_ede3_ofb64              63
+
+#define SN_desx_cbc             "DESX-CBC"
+#define LN_desx_cbc             "desx-cbc"
+#define NID_desx_cbc            80
+
+#define SN_sha          "SHA"
+#define LN_sha          "sha"
+#define NID_sha         41
+#define OBJ_sha         OBJ_algorithm,18L
+
+#define SN_sha1         "SHA1"
+#define LN_sha1         "sha1"
+#define NID_sha1                64
+#define OBJ_sha1                OBJ_algorithm,26L
+
+#define SN_dsaWithSHA1_2                "DSA-SHA1-old"
+#define LN_dsaWithSHA1_2                "dsaWithSHA1-old"
+#define NID_dsaWithSHA1_2               70
+#define OBJ_dsaWithSHA1_2               OBJ_algorithm,27L
+
+#define SN_sha1WithRSA          "RSA-SHA1-2"
+#define LN_sha1WithRSA          "sha1WithRSA"
+#define NID_sha1WithRSA         115
+#define OBJ_sha1WithRSA         OBJ_algorithm,29L
+
+#define SN_ripemd160            "RIPEMD160"
+#define LN_ripemd160            "ripemd160"
+#define NID_ripemd160           117
+#define OBJ_ripemd160           1L,3L,36L,3L,2L,1L
+
+#define SN_ripemd160WithRSA             "RSA-RIPEMD160"
+#define LN_ripemd160WithRSA             "ripemd160WithRSA"
+#define NID_ripemd160WithRSA            119
+#define OBJ_ripemd160WithRSA            1L,3L,36L,3L,3L,1L,2L
+
+#define SN_blake2bmac           "BLAKE2BMAC"
+#define LN_blake2bmac           "blake2bmac"
+#define NID_blake2bmac          1201
+#define OBJ_blake2bmac          1L,3L,6L,1L,4L,1L,1722L,12L,2L,1L
+
+#define SN_blake2smac           "BLAKE2SMAC"
+#define LN_blake2smac           "blake2smac"
+#define NID_blake2smac          1202
+#define OBJ_blake2smac          1L,3L,6L,1L,4L,1L,1722L,12L,2L,2L
+
+#define SN_blake2b512           "BLAKE2b512"
+#define LN_blake2b512           "blake2b512"
+#define NID_blake2b512          1056
+#define OBJ_blake2b512          OBJ_blake2bmac,16L
+
+#define SN_blake2s256           "BLAKE2s256"
+#define LN_blake2s256           "blake2s256"
+#define NID_blake2s256          1057
+#define OBJ_blake2s256          OBJ_blake2smac,8L
+
+#define SN_sxnet                "SXNetID"
+#define LN_sxnet                "Strong Extranet ID"
+#define NID_sxnet               143
+#define OBJ_sxnet               1L,3L,101L,1L,4L,1L
+
+#define SN_X500         "X500"
+#define LN_X500         "directory services (X.500)"
+#define NID_X500                11
+#define OBJ_X500                2L,5L
+
+#define SN_X509         "X509"
+#define NID_X509                12
+#define OBJ_X509                OBJ_X500,4L
+
+#define SN_commonName           "CN"
+#define LN_commonName           "commonName"
+#define NID_commonName          13
+#define OBJ_commonName          OBJ_X509,3L
+
+#define SN_surname              "SN"
+#define LN_surname              "surname"
+#define NID_surname             100
+#define OBJ_surname             OBJ_X509,4L
+
+#define LN_serialNumber         "serialNumber"
+#define NID_serialNumber                105
+#define OBJ_serialNumber                OBJ_X509,5L
+
+#define SN_countryName          "C"
+#define LN_countryName          "countryName"
+#define NID_countryName         14
+#define OBJ_countryName         OBJ_X509,6L
+
+#define SN_localityName         "L"
+#define LN_localityName         "localityName"
+#define NID_localityName                15
+#define OBJ_localityName                OBJ_X509,7L
+
+#define SN_stateOrProvinceName          "ST"
+#define LN_stateOrProvinceName          "stateOrProvinceName"
+#define NID_stateOrProvinceName         16
+#define OBJ_stateOrProvinceName         OBJ_X509,8L
+
+#define SN_streetAddress                "street"
+#define LN_streetAddress                "streetAddress"
+#define NID_streetAddress               660
+#define OBJ_streetAddress               OBJ_X509,9L
+
+#define SN_organizationName             "O"
+#define LN_organizationName             "organizationName"
+#define NID_organizationName            17
+#define OBJ_organizationName            OBJ_X509,10L
+
+#define SN_organizationalUnitName               "OU"
+#define LN_organizationalUnitName               "organizationalUnitName"
+#define NID_organizationalUnitName              18
+#define OBJ_organizationalUnitName              OBJ_X509,11L
+
+#define SN_title                "title"
+#define LN_title                "title"
+#define NID_title               106
+#define OBJ_title               OBJ_X509,12L
+
+#define LN_description          "description"
+#define NID_description         107
+#define OBJ_description         OBJ_X509,13L
+
+#define LN_searchGuide          "searchGuide"
+#define NID_searchGuide         859
+#define OBJ_searchGuide         OBJ_X509,14L
+
+#define LN_businessCategory             "businessCategory"
+#define NID_businessCategory            860
+#define OBJ_businessCategory            OBJ_X509,15L
+
+#define LN_postalAddress                "postalAddress"
+#define NID_postalAddress               861
+#define OBJ_postalAddress               OBJ_X509,16L
+
+#define LN_postalCode           "postalCode"
+#define NID_postalCode          661
+#define OBJ_postalCode          OBJ_X509,17L
+
+#define LN_postOfficeBox                "postOfficeBox"
+#define NID_postOfficeBox               862
+#define OBJ_postOfficeBox               OBJ_X509,18L
+
+#define LN_physicalDeliveryOfficeName           "physicalDeliveryOfficeName"
+#define NID_physicalDeliveryOfficeName          863
+#define OBJ_physicalDeliveryOfficeName          OBJ_X509,19L
+
+#define LN_telephoneNumber              "telephoneNumber"
+#define NID_telephoneNumber             864
+#define OBJ_telephoneNumber             OBJ_X509,20L
+
+#define LN_telexNumber          "telexNumber"
+#define NID_telexNumber         865
+#define OBJ_telexNumber         OBJ_X509,21L
+
+#define LN_teletexTerminalIdentifier            "teletexTerminalIdentifier"
+#define NID_teletexTerminalIdentifier           866
+#define OBJ_teletexTerminalIdentifier           OBJ_X509,22L
+
+#define LN_facsimileTelephoneNumber             "facsimileTelephoneNumber"
+#define NID_facsimileTelephoneNumber            867
+#define OBJ_facsimileTelephoneNumber            OBJ_X509,23L
+
+#define LN_x121Address          "x121Address"
+#define NID_x121Address         868
+#define OBJ_x121Address         OBJ_X509,24L
+
+#define LN_internationaliSDNNumber              "internationaliSDNNumber"
+#define NID_internationaliSDNNumber             869
+#define OBJ_internationaliSDNNumber             OBJ_X509,25L
+
+#define LN_registeredAddress            "registeredAddress"
+#define NID_registeredAddress           870
+#define OBJ_registeredAddress           OBJ_X509,26L
+
+#define LN_destinationIndicator         "destinationIndicator"
+#define NID_destinationIndicator                871
+#define OBJ_destinationIndicator                OBJ_X509,27L
+
+#define LN_preferredDeliveryMethod              "preferredDeliveryMethod"
+#define NID_preferredDeliveryMethod             872
+#define OBJ_preferredDeliveryMethod             OBJ_X509,28L
+
+#define LN_presentationAddress          "presentationAddress"
+#define NID_presentationAddress         873
+#define OBJ_presentationAddress         OBJ_X509,29L
+
+#define LN_supportedApplicationContext          "supportedApplicationContext"
+#define NID_supportedApplicationContext         874
+#define OBJ_supportedApplicationContext         OBJ_X509,30L
+
+#define SN_member               "member"
+#define NID_member              875
+#define OBJ_member              OBJ_X509,31L
+
+#define SN_owner                "owner"
+#define NID_owner               876
+#define OBJ_owner               OBJ_X509,32L
+
+#define LN_roleOccupant         "roleOccupant"
+#define NID_roleOccupant                877
+#define OBJ_roleOccupant                OBJ_X509,33L
+
+#define SN_seeAlso              "seeAlso"
+#define NID_seeAlso             878
+#define OBJ_seeAlso             OBJ_X509,34L
+
+#define LN_userPassword         "userPassword"
+#define NID_userPassword                879
+#define OBJ_userPassword                OBJ_X509,35L
+
+#define LN_userCertificate              "userCertificate"
+#define NID_userCertificate             880
+#define OBJ_userCertificate             OBJ_X509,36L
+
+#define LN_cACertificate                "cACertificate"
+#define NID_cACertificate               881
+#define OBJ_cACertificate               OBJ_X509,37L
+
+#define LN_authorityRevocationList              "authorityRevocationList"
+#define NID_authorityRevocationList             882
+#define OBJ_authorityRevocationList             OBJ_X509,38L
+
+#define LN_certificateRevocationList            "certificateRevocationList"
+#define NID_certificateRevocationList           883
+#define OBJ_certificateRevocationList           OBJ_X509,39L
+
+#define LN_crossCertificatePair         "crossCertificatePair"
+#define NID_crossCertificatePair                884
+#define OBJ_crossCertificatePair                OBJ_X509,40L
+
+#define SN_name         "name"
+#define LN_name         "name"
+#define NID_name                173
+#define OBJ_name                OBJ_X509,41L
+
+#define SN_givenName            "GN"
+#define LN_givenName            "givenName"
+#define NID_givenName           99
+#define OBJ_givenName           OBJ_X509,42L
+
+#define SN_initials             "initials"
+#define LN_initials             "initials"
+#define NID_initials            101
+#define OBJ_initials            OBJ_X509,43L
+
+#define LN_generationQualifier          "generationQualifier"
+#define NID_generationQualifier         509
+#define OBJ_generationQualifier         OBJ_X509,44L
+
+#define LN_x500UniqueIdentifier         "x500UniqueIdentifier"
+#define NID_x500UniqueIdentifier                503
+#define OBJ_x500UniqueIdentifier                OBJ_X509,45L
+
+#define SN_dnQualifier          "dnQualifier"
+#define LN_dnQualifier          "dnQualifier"
+#define NID_dnQualifier         174
+#define OBJ_dnQualifier         OBJ_X509,46L
+
+#define LN_enhancedSearchGuide          "enhancedSearchGuide"
+#define NID_enhancedSearchGuide         885
+#define OBJ_enhancedSearchGuide         OBJ_X509,47L
+
+#define LN_protocolInformation          "protocolInformation"
+#define NID_protocolInformation         886
+#define OBJ_protocolInformation         OBJ_X509,48L
+
+#define LN_distinguishedName            "distinguishedName"
+#define NID_distinguishedName           887
+#define OBJ_distinguishedName           OBJ_X509,49L
+
+#define LN_uniqueMember         "uniqueMember"
+#define NID_uniqueMember                888
+#define OBJ_uniqueMember                OBJ_X509,50L
+
+#define LN_houseIdentifier              "houseIdentifier"
+#define NID_houseIdentifier             889
+#define OBJ_houseIdentifier             OBJ_X509,51L
+
+#define LN_supportedAlgorithms          "supportedAlgorithms"
+#define NID_supportedAlgorithms         890
+#define OBJ_supportedAlgorithms         OBJ_X509,52L
+
+#define LN_deltaRevocationList          "deltaRevocationList"
+#define NID_deltaRevocationList         891
+#define OBJ_deltaRevocationList         OBJ_X509,53L
+
+#define SN_dmdName              "dmdName"
+#define NID_dmdName             892
+#define OBJ_dmdName             OBJ_X509,54L
+
+#define LN_pseudonym            "pseudonym"
+#define NID_pseudonym           510
+#define OBJ_pseudonym           OBJ_X509,65L
+
+#define SN_role         "role"
+#define LN_role         "role"
+#define NID_role                400
+#define OBJ_role                OBJ_X509,72L
+
+#define LN_organizationIdentifier               "organizationIdentifier"
+#define NID_organizationIdentifier              1089
+#define OBJ_organizationIdentifier              OBJ_X509,97L
+
+#define SN_countryCode3c                "c3"
+#define LN_countryCode3c                "countryCode3c"
+#define NID_countryCode3c               1090
+#define OBJ_countryCode3c               OBJ_X509,98L
+
+#define SN_countryCode3n                "n3"
+#define LN_countryCode3n                "countryCode3n"
+#define NID_countryCode3n               1091
+#define OBJ_countryCode3n               OBJ_X509,99L
+
+#define LN_dnsName              "dnsName"
+#define NID_dnsName             1092
+#define OBJ_dnsName             OBJ_X509,100L
+
+#define SN_X500algorithms               "X500algorithms"
+#define LN_X500algorithms               "directory services - algorithms"
+#define NID_X500algorithms              378
+#define OBJ_X500algorithms              OBJ_X500,8L
+
+#define SN_rsa          "RSA"
+#define LN_rsa          "rsa"
+#define NID_rsa         19
+#define OBJ_rsa         OBJ_X500algorithms,1L,1L
+
+#define SN_mdc2WithRSA          "RSA-MDC2"
+#define LN_mdc2WithRSA          "mdc2WithRSA"
+#define NID_mdc2WithRSA         96
+#define OBJ_mdc2WithRSA         OBJ_X500algorithms,3L,100L
+
+#define SN_mdc2         "MDC2"
+#define LN_mdc2         "mdc2"
+#define NID_mdc2                95
+#define OBJ_mdc2                OBJ_X500algorithms,3L,101L
+
+#define SN_id_ce                "id-ce"
+#define NID_id_ce               81
+#define OBJ_id_ce               OBJ_X500,29L
+
+#define SN_subject_directory_attributes         "subjectDirectoryAttributes"
+#define LN_subject_directory_attributes         "X509v3 Subject Directory Attributes"
+#define NID_subject_directory_attributes                769
+#define OBJ_subject_directory_attributes                OBJ_id_ce,9L
+
+#define SN_subject_key_identifier               "subjectKeyIdentifier"
+#define LN_subject_key_identifier               "X509v3 Subject Key Identifier"
+#define NID_subject_key_identifier              82
+#define OBJ_subject_key_identifier              OBJ_id_ce,14L
+
+#define SN_key_usage            "keyUsage"
+#define LN_key_usage            "X509v3 Key Usage"
+#define NID_key_usage           83
+#define OBJ_key_usage           OBJ_id_ce,15L
+
+#define SN_private_key_usage_period             "privateKeyUsagePeriod"
+#define LN_private_key_usage_period             "X509v3 Private Key Usage Period"
+#define NID_private_key_usage_period            84
+#define OBJ_private_key_usage_period            OBJ_id_ce,16L
+
+#define SN_subject_alt_name             "subjectAltName"
+#define LN_subject_alt_name             "X509v3 Subject Alternative Name"
+#define NID_subject_alt_name            85
+#define OBJ_subject_alt_name            OBJ_id_ce,17L
+
+#define SN_issuer_alt_name              "issuerAltName"
+#define LN_issuer_alt_name              "X509v3 Issuer Alternative Name"
+#define NID_issuer_alt_name             86
+#define OBJ_issuer_alt_name             OBJ_id_ce,18L
+
+#define SN_basic_constraints            "basicConstraints"
+#define LN_basic_constraints            "X509v3 Basic Constraints"
+#define NID_basic_constraints           87
+#define OBJ_basic_constraints           OBJ_id_ce,19L
+
+#define SN_crl_number           "crlNumber"
+#define LN_crl_number           "X509v3 CRL Number"
+#define NID_crl_number          88
+#define OBJ_crl_number          OBJ_id_ce,20L
+
+#define SN_crl_reason           "CRLReason"
+#define LN_crl_reason           "X509v3 CRL Reason Code"
+#define NID_crl_reason          141
+#define OBJ_crl_reason          OBJ_id_ce,21L
+
+#define SN_invalidity_date              "invalidityDate"
+#define LN_invalidity_date              "Invalidity Date"
+#define NID_invalidity_date             142
+#define OBJ_invalidity_date             OBJ_id_ce,24L
+
+#define SN_delta_crl            "deltaCRL"
+#define LN_delta_crl            "X509v3 Delta CRL Indicator"
+#define NID_delta_crl           140
+#define OBJ_delta_crl           OBJ_id_ce,27L
+
+#define SN_issuing_distribution_point           "issuingDistributionPoint"
+#define LN_issuing_distribution_point           "X509v3 Issuing Distribution Point"
+#define NID_issuing_distribution_point          770
+#define OBJ_issuing_distribution_point          OBJ_id_ce,28L
+
+#define SN_certificate_issuer           "certificateIssuer"
+#define LN_certificate_issuer           "X509v3 Certificate Issuer"
+#define NID_certificate_issuer          771
+#define OBJ_certificate_issuer          OBJ_id_ce,29L
+
+#define SN_name_constraints             "nameConstraints"
+#define LN_name_constraints             "X509v3 Name Constraints"
+#define NID_name_constraints            666
+#define OBJ_name_constraints            OBJ_id_ce,30L
+
+#define SN_crl_distribution_points              "crlDistributionPoints"
+#define LN_crl_distribution_points              "X509v3 CRL Distribution Points"
+#define NID_crl_distribution_points             103
+#define OBJ_crl_distribution_points             OBJ_id_ce,31L
+
+#define SN_certificate_policies         "certificatePolicies"
+#define LN_certificate_policies         "X509v3 Certificate Policies"
+#define NID_certificate_policies                89
+#define OBJ_certificate_policies                OBJ_id_ce,32L
+
+#define SN_any_policy           "anyPolicy"
+#define LN_any_policy           "X509v3 Any Policy"
+#define NID_any_policy          746
+#define OBJ_any_policy          OBJ_certificate_policies,0L
+
+#define SN_policy_mappings              "policyMappings"
+#define LN_policy_mappings              "X509v3 Policy Mappings"
+#define NID_policy_mappings             747
+#define OBJ_policy_mappings             OBJ_id_ce,33L
+
+#define SN_authority_key_identifier             "authorityKeyIdentifier"
+#define LN_authority_key_identifier             "X509v3 Authority Key Identifier"
+#define NID_authority_key_identifier            90
+#define OBJ_authority_key_identifier            OBJ_id_ce,35L
+
+#define SN_policy_constraints           "policyConstraints"
+#define LN_policy_constraints           "X509v3 Policy Constraints"
+#define NID_policy_constraints          401
+#define OBJ_policy_constraints          OBJ_id_ce,36L
+
+#define SN_ext_key_usage                "extendedKeyUsage"
+#define LN_ext_key_usage                "X509v3 Extended Key Usage"
+#define NID_ext_key_usage               126
+#define OBJ_ext_key_usage               OBJ_id_ce,37L
+
+#define SN_freshest_crl         "freshestCRL"
+#define LN_freshest_crl         "X509v3 Freshest CRL"
+#define NID_freshest_crl                857
+#define OBJ_freshest_crl                OBJ_id_ce,46L
+
+#define SN_inhibit_any_policy           "inhibitAnyPolicy"
+#define LN_inhibit_any_policy           "X509v3 Inhibit Any Policy"
+#define NID_inhibit_any_policy          748
+#define OBJ_inhibit_any_policy          OBJ_id_ce,54L
+
+#define SN_target_information           "targetInformation"
+#define LN_target_information           "X509v3 AC Targeting"
+#define NID_target_information          402
+#define OBJ_target_information          OBJ_id_ce,55L
+
+#define SN_no_rev_avail         "noRevAvail"
+#define LN_no_rev_avail         "X509v3 No Revocation Available"
+#define NID_no_rev_avail                403
+#define OBJ_no_rev_avail                OBJ_id_ce,56L
+
+#define SN_anyExtendedKeyUsage          "anyExtendedKeyUsage"
+#define LN_anyExtendedKeyUsage          "Any Extended Key Usage"
+#define NID_anyExtendedKeyUsage         910
+#define OBJ_anyExtendedKeyUsage         OBJ_ext_key_usage,0L
+
+#define SN_netscape             "Netscape"
+#define LN_netscape             "Netscape Communications Corp."
+#define NID_netscape            57
+#define OBJ_netscape            2L,16L,840L,1L,113730L
+
+#define SN_netscape_cert_extension              "nsCertExt"
+#define LN_netscape_cert_extension              "Netscape Certificate Extension"
+#define NID_netscape_cert_extension             58
+#define OBJ_netscape_cert_extension             OBJ_netscape,1L
+
+#define SN_netscape_data_type           "nsDataType"
+#define LN_netscape_data_type           "Netscape Data Type"
+#define NID_netscape_data_type          59
+#define OBJ_netscape_data_type          OBJ_netscape,2L
+
+#define SN_netscape_cert_type           "nsCertType"
+#define LN_netscape_cert_type           "Netscape Cert Type"
+#define NID_netscape_cert_type          71
+#define OBJ_netscape_cert_type          OBJ_netscape_cert_extension,1L
+
+#define SN_netscape_base_url            "nsBaseUrl"
+#define LN_netscape_base_url            "Netscape Base Url"
+#define NID_netscape_base_url           72
+#define OBJ_netscape_base_url           OBJ_netscape_cert_extension,2L
+
+#define SN_netscape_revocation_url              "nsRevocationUrl"
+#define LN_netscape_revocation_url              "Netscape Revocation Url"
+#define NID_netscape_revocation_url             73
+#define OBJ_netscape_revocation_url             OBJ_netscape_cert_extension,3L
+
+#define SN_netscape_ca_revocation_url           "nsCaRevocationUrl"
+#define LN_netscape_ca_revocation_url           "Netscape CA Revocation Url"
+#define NID_netscape_ca_revocation_url          74
+#define OBJ_netscape_ca_revocation_url          OBJ_netscape_cert_extension,4L
+
+#define SN_netscape_renewal_url         "nsRenewalUrl"
+#define LN_netscape_renewal_url         "Netscape Renewal Url"
+#define NID_netscape_renewal_url                75
+#define OBJ_netscape_renewal_url                OBJ_netscape_cert_extension,7L
+
+#define SN_netscape_ca_policy_url               "nsCaPolicyUrl"
+#define LN_netscape_ca_policy_url               "Netscape CA Policy Url"
+#define NID_netscape_ca_policy_url              76
+#define OBJ_netscape_ca_policy_url              OBJ_netscape_cert_extension,8L
+
+#define SN_netscape_ssl_server_name             "nsSslServerName"
+#define LN_netscape_ssl_server_name             "Netscape SSL Server Name"
+#define NID_netscape_ssl_server_name            77
+#define OBJ_netscape_ssl_server_name            OBJ_netscape_cert_extension,12L
+
+#define SN_netscape_comment             "nsComment"
+#define LN_netscape_comment             "Netscape Comment"
+#define NID_netscape_comment            78
+#define OBJ_netscape_comment            OBJ_netscape_cert_extension,13L
+
+#define SN_netscape_cert_sequence               "nsCertSequence"
+#define LN_netscape_cert_sequence               "Netscape Certificate Sequence"
+#define NID_netscape_cert_sequence              79
+#define OBJ_netscape_cert_sequence              OBJ_netscape_data_type,5L
+
+#define SN_ns_sgc               "nsSGC"
+#define LN_ns_sgc               "Netscape Server Gated Crypto"
+#define NID_ns_sgc              139
+#define OBJ_ns_sgc              OBJ_netscape,4L,1L
+
+#define SN_org          "ORG"
+#define LN_org          "org"
+#define NID_org         379
+#define OBJ_org         OBJ_iso,3L
+
+#define SN_dod          "DOD"
+#define LN_dod          "dod"
+#define NID_dod         380
+#define OBJ_dod         OBJ_org,6L
+
+#define SN_iana         "IANA"
+#define LN_iana         "iana"
+#define NID_iana                381
+#define OBJ_iana                OBJ_dod,1L
+
+#define OBJ_internet            OBJ_iana
+
+#define SN_Directory            "directory"
+#define LN_Directory            "Directory"
+#define NID_Directory           382
+#define OBJ_Directory           OBJ_internet,1L
+
+#define SN_Management           "mgmt"
+#define LN_Management           "Management"
+#define NID_Management          383
+#define OBJ_Management          OBJ_internet,2L
+
+#define SN_Experimental         "experimental"
+#define LN_Experimental         "Experimental"
+#define NID_Experimental                384
+#define OBJ_Experimental                OBJ_internet,3L
+
+#define SN_Private              "private"
+#define LN_Private              "Private"
+#define NID_Private             385
+#define OBJ_Private             OBJ_internet,4L
+
+#define SN_Security             "security"
+#define LN_Security             "Security"
+#define NID_Security            386
+#define OBJ_Security            OBJ_internet,5L
+
+#define SN_SNMPv2               "snmpv2"
+#define LN_SNMPv2               "SNMPv2"
+#define NID_SNMPv2              387
+#define OBJ_SNMPv2              OBJ_internet,6L
+
+#define LN_Mail         "Mail"
+#define NID_Mail                388
+#define OBJ_Mail                OBJ_internet,7L
+
+#define SN_Enterprises          "enterprises"
+#define LN_Enterprises          "Enterprises"
+#define NID_Enterprises         389
+#define OBJ_Enterprises         OBJ_Private,1L
+
+#define SN_dcObject             "dcobject"
+#define LN_dcObject             "dcObject"
+#define NID_dcObject            390
+#define OBJ_dcObject            OBJ_Enterprises,1466L,344L
+
+#define SN_mime_mhs             "mime-mhs"
+#define LN_mime_mhs             "MIME MHS"
+#define NID_mime_mhs            504
+#define OBJ_mime_mhs            OBJ_Mail,1L
+
+#define SN_mime_mhs_headings            "mime-mhs-headings"
+#define LN_mime_mhs_headings            "mime-mhs-headings"
+#define NID_mime_mhs_headings           505
+#define OBJ_mime_mhs_headings           OBJ_mime_mhs,1L
+
+#define SN_mime_mhs_bodies              "mime-mhs-bodies"
+#define LN_mime_mhs_bodies              "mime-mhs-bodies"
+#define NID_mime_mhs_bodies             506
+#define OBJ_mime_mhs_bodies             OBJ_mime_mhs,2L
+
+#define SN_id_hex_partial_message               "id-hex-partial-message"
+#define LN_id_hex_partial_message               "id-hex-partial-message"
+#define NID_id_hex_partial_message              507
+#define OBJ_id_hex_partial_message              OBJ_mime_mhs_headings,1L
+
+#define SN_id_hex_multipart_message             "id-hex-multipart-message"
+#define LN_id_hex_multipart_message             "id-hex-multipart-message"
+#define NID_id_hex_multipart_message            508
+#define OBJ_id_hex_multipart_message            OBJ_mime_mhs_headings,2L
+
+#define SN_zlib_compression             "ZLIB"
+#define LN_zlib_compression             "zlib compression"
+#define NID_zlib_compression            125
+#define OBJ_zlib_compression            OBJ_id_smime_alg,8L
+
+#define OBJ_csor                2L,16L,840L,1L,101L,3L
+
+#define OBJ_nistAlgorithms              OBJ_csor,4L
+
+#define OBJ_aes         OBJ_nistAlgorithms,1L
+
+#define SN_aes_128_ecb          "AES-128-ECB"
+#define LN_aes_128_ecb          "aes-128-ecb"
+#define NID_aes_128_ecb         418
+#define OBJ_aes_128_ecb         OBJ_aes,1L
+
+#define SN_aes_128_cbc          "AES-128-CBC"
+#define LN_aes_128_cbc          "aes-128-cbc"
+#define NID_aes_128_cbc         419
+#define OBJ_aes_128_cbc         OBJ_aes,2L
+
+#define SN_aes_128_ofb128               "AES-128-OFB"
+#define LN_aes_128_ofb128               "aes-128-ofb"
+#define NID_aes_128_ofb128              420
+#define OBJ_aes_128_ofb128              OBJ_aes,3L
+
+#define SN_aes_128_cfb128               "AES-128-CFB"
+#define LN_aes_128_cfb128               "aes-128-cfb"
+#define NID_aes_128_cfb128              421
+#define OBJ_aes_128_cfb128              OBJ_aes,4L
+
+#define SN_id_aes128_wrap               "id-aes128-wrap"
+#define NID_id_aes128_wrap              788
+#define OBJ_id_aes128_wrap              OBJ_aes,5L
+
+#define SN_aes_128_gcm          "id-aes128-GCM"
+#define LN_aes_128_gcm          "aes-128-gcm"
+#define NID_aes_128_gcm         895
+#define OBJ_aes_128_gcm         OBJ_aes,6L
+
+#define SN_aes_128_ccm          "id-aes128-CCM"
+#define LN_aes_128_ccm          "aes-128-ccm"
+#define NID_aes_128_ccm         896
+#define OBJ_aes_128_ccm         OBJ_aes,7L
+
+#define SN_id_aes128_wrap_pad           "id-aes128-wrap-pad"
+#define NID_id_aes128_wrap_pad          897
+#define OBJ_id_aes128_wrap_pad          OBJ_aes,8L
+
+#define SN_aes_192_ecb          "AES-192-ECB"
+#define LN_aes_192_ecb          "aes-192-ecb"
+#define NID_aes_192_ecb         422
+#define OBJ_aes_192_ecb         OBJ_aes,21L
+
+#define SN_aes_192_cbc          "AES-192-CBC"
+#define LN_aes_192_cbc          "aes-192-cbc"
+#define NID_aes_192_cbc         423
+#define OBJ_aes_192_cbc         OBJ_aes,22L
+
+#define SN_aes_192_ofb128               "AES-192-OFB"
+#define LN_aes_192_ofb128               "aes-192-ofb"
+#define NID_aes_192_ofb128              424
+#define OBJ_aes_192_ofb128              OBJ_aes,23L
+
+#define SN_aes_192_cfb128               "AES-192-CFB"
+#define LN_aes_192_cfb128               "aes-192-cfb"
+#define NID_aes_192_cfb128              425
+#define OBJ_aes_192_cfb128              OBJ_aes,24L
+
+#define SN_id_aes192_wrap               "id-aes192-wrap"
+#define NID_id_aes192_wrap              789
+#define OBJ_id_aes192_wrap              OBJ_aes,25L
+
+#define SN_aes_192_gcm          "id-aes192-GCM"
+#define LN_aes_192_gcm          "aes-192-gcm"
+#define NID_aes_192_gcm         898
+#define OBJ_aes_192_gcm         OBJ_aes,26L
+
+#define SN_aes_192_ccm          "id-aes192-CCM"
+#define LN_aes_192_ccm          "aes-192-ccm"
+#define NID_aes_192_ccm         899
+#define OBJ_aes_192_ccm         OBJ_aes,27L
+
+#define SN_id_aes192_wrap_pad           "id-aes192-wrap-pad"
+#define NID_id_aes192_wrap_pad          900
+#define OBJ_id_aes192_wrap_pad          OBJ_aes,28L
+
+#define SN_aes_256_ecb          "AES-256-ECB"
+#define LN_aes_256_ecb          "aes-256-ecb"
+#define NID_aes_256_ecb         426
+#define OBJ_aes_256_ecb         OBJ_aes,41L
+
+#define SN_aes_256_cbc          "AES-256-CBC"
+#define LN_aes_256_cbc          "aes-256-cbc"
+#define NID_aes_256_cbc         427
+#define OBJ_aes_256_cbc         OBJ_aes,42L
+
+#define SN_aes_256_ofb128               "AES-256-OFB"
+#define LN_aes_256_ofb128               "aes-256-ofb"
+#define NID_aes_256_ofb128              428
+#define OBJ_aes_256_ofb128              OBJ_aes,43L
+
+#define SN_aes_256_cfb128               "AES-256-CFB"
+#define LN_aes_256_cfb128               "aes-256-cfb"
+#define NID_aes_256_cfb128              429
+#define OBJ_aes_256_cfb128              OBJ_aes,44L
+
+#define SN_id_aes256_wrap               "id-aes256-wrap"
+#define NID_id_aes256_wrap              790
+#define OBJ_id_aes256_wrap              OBJ_aes,45L
+
+#define SN_aes_256_gcm          "id-aes256-GCM"
+#define LN_aes_256_gcm          "aes-256-gcm"
+#define NID_aes_256_gcm         901
+#define OBJ_aes_256_gcm         OBJ_aes,46L
+
+#define SN_aes_256_ccm          "id-aes256-CCM"
+#define LN_aes_256_ccm          "aes-256-ccm"
+#define NID_aes_256_ccm         902
+#define OBJ_aes_256_ccm         OBJ_aes,47L
+
+#define SN_id_aes256_wrap_pad           "id-aes256-wrap-pad"
+#define NID_id_aes256_wrap_pad          903
+#define OBJ_id_aes256_wrap_pad          OBJ_aes,48L
+
+#define SN_aes_128_xts          "AES-128-XTS"
+#define LN_aes_128_xts          "aes-128-xts"
+#define NID_aes_128_xts         913
+#define OBJ_aes_128_xts         OBJ_ieee_siswg,0L,1L,1L
+
+#define SN_aes_256_xts          "AES-256-XTS"
+#define LN_aes_256_xts          "aes-256-xts"
+#define NID_aes_256_xts         914
+#define OBJ_aes_256_xts         OBJ_ieee_siswg,0L,1L,2L
+
+#define SN_aes_128_cfb1         "AES-128-CFB1"
+#define LN_aes_128_cfb1         "aes-128-cfb1"
+#define NID_aes_128_cfb1                650
+
+#define SN_aes_192_cfb1         "AES-192-CFB1"
+#define LN_aes_192_cfb1         "aes-192-cfb1"
+#define NID_aes_192_cfb1                651
+
+#define SN_aes_256_cfb1         "AES-256-CFB1"
+#define LN_aes_256_cfb1         "aes-256-cfb1"
+#define NID_aes_256_cfb1                652
+
+#define SN_aes_128_cfb8         "AES-128-CFB8"
+#define LN_aes_128_cfb8         "aes-128-cfb8"
+#define NID_aes_128_cfb8                653
+
+#define SN_aes_192_cfb8         "AES-192-CFB8"
+#define LN_aes_192_cfb8         "aes-192-cfb8"
+#define NID_aes_192_cfb8                654
+
+#define SN_aes_256_cfb8         "AES-256-CFB8"
+#define LN_aes_256_cfb8         "aes-256-cfb8"
+#define NID_aes_256_cfb8                655
+
+#define SN_aes_128_ctr          "AES-128-CTR"
+#define LN_aes_128_ctr          "aes-128-ctr"
+#define NID_aes_128_ctr         904
+
+#define SN_aes_192_ctr          "AES-192-CTR"
+#define LN_aes_192_ctr          "aes-192-ctr"
+#define NID_aes_192_ctr         905
+
+#define SN_aes_256_ctr          "AES-256-CTR"
+#define LN_aes_256_ctr          "aes-256-ctr"
+#define NID_aes_256_ctr         906
+
+#define SN_aes_128_ocb          "AES-128-OCB"
+#define LN_aes_128_ocb          "aes-128-ocb"
+#define NID_aes_128_ocb         958
+
+#define SN_aes_192_ocb          "AES-192-OCB"
+#define LN_aes_192_ocb          "aes-192-ocb"
+#define NID_aes_192_ocb         959
+
+#define SN_aes_256_ocb          "AES-256-OCB"
+#define LN_aes_256_ocb          "aes-256-ocb"
+#define NID_aes_256_ocb         960
+
+#define SN_des_cfb1             "DES-CFB1"
+#define LN_des_cfb1             "des-cfb1"
+#define NID_des_cfb1            656
+
+#define SN_des_cfb8             "DES-CFB8"
+#define LN_des_cfb8             "des-cfb8"
+#define NID_des_cfb8            657
+
+#define SN_des_ede3_cfb1                "DES-EDE3-CFB1"
+#define LN_des_ede3_cfb1                "des-ede3-cfb1"
+#define NID_des_ede3_cfb1               658
+
+#define SN_des_ede3_cfb8                "DES-EDE3-CFB8"
+#define LN_des_ede3_cfb8                "des-ede3-cfb8"
+#define NID_des_ede3_cfb8               659
+
+#define OBJ_nist_hashalgs               OBJ_nistAlgorithms,2L
+
+#define SN_sha256               "SHA256"
+#define LN_sha256               "sha256"
+#define NID_sha256              672
+#define OBJ_sha256              OBJ_nist_hashalgs,1L
+
+#define SN_sha384               "SHA384"
+#define LN_sha384               "sha384"
+#define NID_sha384              673
+#define OBJ_sha384              OBJ_nist_hashalgs,2L
+
+#define SN_sha512               "SHA512"
+#define LN_sha512               "sha512"
+#define NID_sha512              674
+#define OBJ_sha512              OBJ_nist_hashalgs,3L
+
+#define SN_sha224               "SHA224"
+#define LN_sha224               "sha224"
+#define NID_sha224              675
+#define OBJ_sha224              OBJ_nist_hashalgs,4L
+
+#define SN_sha512_224           "SHA512-224"
+#define LN_sha512_224           "sha512-224"
+#define NID_sha512_224          1094
+#define OBJ_sha512_224          OBJ_nist_hashalgs,5L
+
+#define SN_sha512_256           "SHA512-256"
+#define LN_sha512_256           "sha512-256"
+#define NID_sha512_256          1095
+#define OBJ_sha512_256          OBJ_nist_hashalgs,6L
+
+#define SN_sha3_224             "SHA3-224"
+#define LN_sha3_224             "sha3-224"
+#define NID_sha3_224            1096
+#define OBJ_sha3_224            OBJ_nist_hashalgs,7L
+
+#define SN_sha3_256             "SHA3-256"
+#define LN_sha3_256             "sha3-256"
+#define NID_sha3_256            1097
+#define OBJ_sha3_256            OBJ_nist_hashalgs,8L
+
+#define SN_sha3_384             "SHA3-384"
+#define LN_sha3_384             "sha3-384"
+#define NID_sha3_384            1098
+#define OBJ_sha3_384            OBJ_nist_hashalgs,9L
+
+#define SN_sha3_512             "SHA3-512"
+#define LN_sha3_512             "sha3-512"
+#define NID_sha3_512            1099
+#define OBJ_sha3_512            OBJ_nist_hashalgs,10L
+
+#define SN_shake128             "SHAKE128"
+#define LN_shake128             "shake128"
+#define NID_shake128            1100
+#define OBJ_shake128            OBJ_nist_hashalgs,11L
+
+#define SN_shake256             "SHAKE256"
+#define LN_shake256             "shake256"
+#define NID_shake256            1101
+#define OBJ_shake256            OBJ_nist_hashalgs,12L
+
+#define SN_hmac_sha3_224                "id-hmacWithSHA3-224"
+#define LN_hmac_sha3_224                "hmac-sha3-224"
+#define NID_hmac_sha3_224               1102
+#define OBJ_hmac_sha3_224               OBJ_nist_hashalgs,13L
+
+#define SN_hmac_sha3_256                "id-hmacWithSHA3-256"
+#define LN_hmac_sha3_256                "hmac-sha3-256"
+#define NID_hmac_sha3_256               1103
+#define OBJ_hmac_sha3_256               OBJ_nist_hashalgs,14L
+
+#define SN_hmac_sha3_384                "id-hmacWithSHA3-384"
+#define LN_hmac_sha3_384                "hmac-sha3-384"
+#define NID_hmac_sha3_384               1104
+#define OBJ_hmac_sha3_384               OBJ_nist_hashalgs,15L
+
+#define SN_hmac_sha3_512                "id-hmacWithSHA3-512"
+#define LN_hmac_sha3_512                "hmac-sha3-512"
+#define NID_hmac_sha3_512               1105
+#define OBJ_hmac_sha3_512               OBJ_nist_hashalgs,16L
+
+#define SN_kmac128              "KMAC128"
+#define LN_kmac128              "kmac128"
+#define NID_kmac128             1196
+#define OBJ_kmac128             OBJ_nist_hashalgs,19L
+
+#define SN_kmac256              "KMAC256"
+#define LN_kmac256              "kmac256"
+#define NID_kmac256             1197
+#define OBJ_kmac256             OBJ_nist_hashalgs,20L
+
+#define OBJ_dsa_with_sha2               OBJ_nistAlgorithms,3L
+
+#define SN_dsa_with_SHA224              "dsa_with_SHA224"
+#define NID_dsa_with_SHA224             802
+#define OBJ_dsa_with_SHA224             OBJ_dsa_with_sha2,1L
+
+#define SN_dsa_with_SHA256              "dsa_with_SHA256"
+#define NID_dsa_with_SHA256             803
+#define OBJ_dsa_with_SHA256             OBJ_dsa_with_sha2,2L
+
+#define OBJ_sigAlgs             OBJ_nistAlgorithms,3L
+
+#define SN_dsa_with_SHA384              "id-dsa-with-sha384"
+#define LN_dsa_with_SHA384              "dsa_with_SHA384"
+#define NID_dsa_with_SHA384             1106
+#define OBJ_dsa_with_SHA384             OBJ_sigAlgs,3L
+
+#define SN_dsa_with_SHA512              "id-dsa-with-sha512"
+#define LN_dsa_with_SHA512              "dsa_with_SHA512"
+#define NID_dsa_with_SHA512             1107
+#define OBJ_dsa_with_SHA512             OBJ_sigAlgs,4L
+
+#define SN_dsa_with_SHA3_224            "id-dsa-with-sha3-224"
+#define LN_dsa_with_SHA3_224            "dsa_with_SHA3-224"
+#define NID_dsa_with_SHA3_224           1108
+#define OBJ_dsa_with_SHA3_224           OBJ_sigAlgs,5L
+
+#define SN_dsa_with_SHA3_256            "id-dsa-with-sha3-256"
+#define LN_dsa_with_SHA3_256            "dsa_with_SHA3-256"
+#define NID_dsa_with_SHA3_256           1109
+#define OBJ_dsa_with_SHA3_256           OBJ_sigAlgs,6L
+
+#define SN_dsa_with_SHA3_384            "id-dsa-with-sha3-384"
+#define LN_dsa_with_SHA3_384            "dsa_with_SHA3-384"
+#define NID_dsa_with_SHA3_384           1110
+#define OBJ_dsa_with_SHA3_384           OBJ_sigAlgs,7L
+
+#define SN_dsa_with_SHA3_512            "id-dsa-with-sha3-512"
+#define LN_dsa_with_SHA3_512            "dsa_with_SHA3-512"
+#define NID_dsa_with_SHA3_512           1111
+#define OBJ_dsa_with_SHA3_512           OBJ_sigAlgs,8L
+
+#define SN_ecdsa_with_SHA3_224          "id-ecdsa-with-sha3-224"
+#define LN_ecdsa_with_SHA3_224          "ecdsa_with_SHA3-224"
+#define NID_ecdsa_with_SHA3_224         1112
+#define OBJ_ecdsa_with_SHA3_224         OBJ_sigAlgs,9L
+
+#define SN_ecdsa_with_SHA3_256          "id-ecdsa-with-sha3-256"
+#define LN_ecdsa_with_SHA3_256          "ecdsa_with_SHA3-256"
+#define NID_ecdsa_with_SHA3_256         1113
+#define OBJ_ecdsa_with_SHA3_256         OBJ_sigAlgs,10L
+
+#define SN_ecdsa_with_SHA3_384          "id-ecdsa-with-sha3-384"
+#define LN_ecdsa_with_SHA3_384          "ecdsa_with_SHA3-384"
+#define NID_ecdsa_with_SHA3_384         1114
+#define OBJ_ecdsa_with_SHA3_384         OBJ_sigAlgs,11L
+
+#define SN_ecdsa_with_SHA3_512          "id-ecdsa-with-sha3-512"
+#define LN_ecdsa_with_SHA3_512          "ecdsa_with_SHA3-512"
+#define NID_ecdsa_with_SHA3_512         1115
+#define OBJ_ecdsa_with_SHA3_512         OBJ_sigAlgs,12L
+
+#define SN_RSA_SHA3_224         "id-rsassa-pkcs1-v1_5-with-sha3-224"
+#define LN_RSA_SHA3_224         "RSA-SHA3-224"
+#define NID_RSA_SHA3_224                1116
+#define OBJ_RSA_SHA3_224                OBJ_sigAlgs,13L
+
+#define SN_RSA_SHA3_256         "id-rsassa-pkcs1-v1_5-with-sha3-256"
+#define LN_RSA_SHA3_256         "RSA-SHA3-256"
+#define NID_RSA_SHA3_256                1117
+#define OBJ_RSA_SHA3_256                OBJ_sigAlgs,14L
+
+#define SN_RSA_SHA3_384         "id-rsassa-pkcs1-v1_5-with-sha3-384"
+#define LN_RSA_SHA3_384         "RSA-SHA3-384"
+#define NID_RSA_SHA3_384                1118
+#define OBJ_RSA_SHA3_384                OBJ_sigAlgs,15L
+
+#define SN_RSA_SHA3_512         "id-rsassa-pkcs1-v1_5-with-sha3-512"
+#define LN_RSA_SHA3_512         "RSA-SHA3-512"
+#define NID_RSA_SHA3_512                1119
+#define OBJ_RSA_SHA3_512                OBJ_sigAlgs,16L
+
+#define SN_hold_instruction_code                "holdInstructionCode"
+#define LN_hold_instruction_code                "Hold Instruction Code"
+#define NID_hold_instruction_code               430
+#define OBJ_hold_instruction_code               OBJ_id_ce,23L
+
+#define OBJ_holdInstruction             OBJ_X9_57,2L
+
+#define SN_hold_instruction_none                "holdInstructionNone"
+#define LN_hold_instruction_none                "Hold Instruction None"
+#define NID_hold_instruction_none               431
+#define OBJ_hold_instruction_none               OBJ_holdInstruction,1L
+
+#define SN_hold_instruction_call_issuer         "holdInstructionCallIssuer"
+#define LN_hold_instruction_call_issuer         "Hold Instruction Call Issuer"
+#define NID_hold_instruction_call_issuer                432
+#define OBJ_hold_instruction_call_issuer                OBJ_holdInstruction,2L
+
+#define SN_hold_instruction_reject              "holdInstructionReject"
+#define LN_hold_instruction_reject              "Hold Instruction Reject"
+#define NID_hold_instruction_reject             433
+#define OBJ_hold_instruction_reject             OBJ_holdInstruction,3L
+
+#define SN_data         "data"
+#define NID_data                434
+#define OBJ_data                OBJ_itu_t,9L
+
+#define SN_pss          "pss"
+#define NID_pss         435
+#define OBJ_pss         OBJ_data,2342L
+
+#define SN_ucl          "ucl"
+#define NID_ucl         436
+#define OBJ_ucl         OBJ_pss,19200300L
+
+#define SN_pilot                "pilot"
+#define NID_pilot               437
+#define OBJ_pilot               OBJ_ucl,100L
+
+#define LN_pilotAttributeType           "pilotAttributeType"
+#define NID_pilotAttributeType          438
+#define OBJ_pilotAttributeType          OBJ_pilot,1L
+
+#define LN_pilotAttributeSyntax         "pilotAttributeSyntax"
+#define NID_pilotAttributeSyntax                439
+#define OBJ_pilotAttributeSyntax                OBJ_pilot,3L
+
+#define LN_pilotObjectClass             "pilotObjectClass"
+#define NID_pilotObjectClass            440
+#define OBJ_pilotObjectClass            OBJ_pilot,4L
+
+#define LN_pilotGroups          "pilotGroups"
+#define NID_pilotGroups         441
+#define OBJ_pilotGroups         OBJ_pilot,10L
+
+#define LN_iA5StringSyntax              "iA5StringSyntax"
+#define NID_iA5StringSyntax             442
+#define OBJ_iA5StringSyntax             OBJ_pilotAttributeSyntax,4L
+
+#define LN_caseIgnoreIA5StringSyntax            "caseIgnoreIA5StringSyntax"
+#define NID_caseIgnoreIA5StringSyntax           443
+#define OBJ_caseIgnoreIA5StringSyntax           OBJ_pilotAttributeSyntax,5L
+
+#define LN_pilotObject          "pilotObject"
+#define NID_pilotObject         444
+#define OBJ_pilotObject         OBJ_pilotObjectClass,3L
+
+#define LN_pilotPerson          "pilotPerson"
+#define NID_pilotPerson         445
+#define OBJ_pilotPerson         OBJ_pilotObjectClass,4L
+
+#define SN_account              "account"
+#define NID_account             446
+#define OBJ_account             OBJ_pilotObjectClass,5L
+
+#define SN_document             "document"
+#define NID_document            447
+#define OBJ_document            OBJ_pilotObjectClass,6L
+
+#define SN_room         "room"
+#define NID_room                448
+#define OBJ_room                OBJ_pilotObjectClass,7L
+
+#define LN_documentSeries               "documentSeries"
+#define NID_documentSeries              449
+#define OBJ_documentSeries              OBJ_pilotObjectClass,9L
+
+#define SN_Domain               "domain"
+#define LN_Domain               "Domain"
+#define NID_Domain              392
+#define OBJ_Domain              OBJ_pilotObjectClass,13L
+
+#define LN_rFC822localPart              "rFC822localPart"
+#define NID_rFC822localPart             450
+#define OBJ_rFC822localPart             OBJ_pilotObjectClass,14L
+
+#define LN_dNSDomain            "dNSDomain"
+#define NID_dNSDomain           451
+#define OBJ_dNSDomain           OBJ_pilotObjectClass,15L
+
+#define LN_domainRelatedObject          "domainRelatedObject"
+#define NID_domainRelatedObject         452
+#define OBJ_domainRelatedObject         OBJ_pilotObjectClass,17L
+
+#define LN_friendlyCountry              "friendlyCountry"
+#define NID_friendlyCountry             453
+#define OBJ_friendlyCountry             OBJ_pilotObjectClass,18L
+
+#define LN_simpleSecurityObject         "simpleSecurityObject"
+#define NID_simpleSecurityObject                454
+#define OBJ_simpleSecurityObject                OBJ_pilotObjectClass,19L
+
+#define LN_pilotOrganization            "pilotOrganization"
+#define NID_pilotOrganization           455
+#define OBJ_pilotOrganization           OBJ_pilotObjectClass,20L
+
+#define LN_pilotDSA             "pilotDSA"
+#define NID_pilotDSA            456
+#define OBJ_pilotDSA            OBJ_pilotObjectClass,21L
+
+#define LN_qualityLabelledData          "qualityLabelledData"
+#define NID_qualityLabelledData         457
+#define OBJ_qualityLabelledData         OBJ_pilotObjectClass,22L
+
+#define SN_userId               "UID"
+#define LN_userId               "userId"
+#define NID_userId              458
+#define OBJ_userId              OBJ_pilotAttributeType,1L
+
+#define LN_textEncodedORAddress         "textEncodedORAddress"
+#define NID_textEncodedORAddress                459
+#define OBJ_textEncodedORAddress                OBJ_pilotAttributeType,2L
+
+#define SN_rfc822Mailbox                "mail"
+#define LN_rfc822Mailbox                "rfc822Mailbox"
+#define NID_rfc822Mailbox               460
+#define OBJ_rfc822Mailbox               OBJ_pilotAttributeType,3L
+
+#define SN_info         "info"
+#define NID_info                461
+#define OBJ_info                OBJ_pilotAttributeType,4L
+
+#define LN_favouriteDrink               "favouriteDrink"
+#define NID_favouriteDrink              462
+#define OBJ_favouriteDrink              OBJ_pilotAttributeType,5L
+
+#define LN_roomNumber           "roomNumber"
+#define NID_roomNumber          463
+#define OBJ_roomNumber          OBJ_pilotAttributeType,6L
+
+#define SN_photo                "photo"
+#define NID_photo               464
+#define OBJ_photo               OBJ_pilotAttributeType,7L
+
+#define LN_userClass            "userClass"
+#define NID_userClass           465
+#define OBJ_userClass           OBJ_pilotAttributeType,8L
+
+#define SN_host         "host"
+#define NID_host                466
+#define OBJ_host                OBJ_pilotAttributeType,9L
+
+#define SN_manager              "manager"
+#define NID_manager             467
+#define OBJ_manager             OBJ_pilotAttributeType,10L
+
+#define LN_documentIdentifier           "documentIdentifier"
+#define NID_documentIdentifier          468
+#define OBJ_documentIdentifier          OBJ_pilotAttributeType,11L
+
+#define LN_documentTitle                "documentTitle"
+#define NID_documentTitle               469
+#define OBJ_documentTitle               OBJ_pilotAttributeType,12L
+
+#define LN_documentVersion              "documentVersion"
+#define NID_documentVersion             470
+#define OBJ_documentVersion             OBJ_pilotAttributeType,13L
+
+#define LN_documentAuthor               "documentAuthor"
+#define NID_documentAuthor              471
+#define OBJ_documentAuthor              OBJ_pilotAttributeType,14L
+
+#define LN_documentLocation             "documentLocation"
+#define NID_documentLocation            472
+#define OBJ_documentLocation            OBJ_pilotAttributeType,15L
+
+#define LN_homeTelephoneNumber          "homeTelephoneNumber"
+#define NID_homeTelephoneNumber         473
+#define OBJ_homeTelephoneNumber         OBJ_pilotAttributeType,20L
+
+#define SN_secretary            "secretary"
+#define NID_secretary           474
+#define OBJ_secretary           OBJ_pilotAttributeType,21L
+
+#define LN_otherMailbox         "otherMailbox"
+#define NID_otherMailbox                475
+#define OBJ_otherMailbox                OBJ_pilotAttributeType,22L
+
+#define LN_lastModifiedTime             "lastModifiedTime"
+#define NID_lastModifiedTime            476
+#define OBJ_lastModifiedTime            OBJ_pilotAttributeType,23L
+
+#define LN_lastModifiedBy               "lastModifiedBy"
+#define NID_lastModifiedBy              477
+#define OBJ_lastModifiedBy              OBJ_pilotAttributeType,24L
+
+#define SN_domainComponent              "DC"
+#define LN_domainComponent              "domainComponent"
+#define NID_domainComponent             391
+#define OBJ_domainComponent             OBJ_pilotAttributeType,25L
+
+#define LN_aRecord              "aRecord"
+#define NID_aRecord             478
+#define OBJ_aRecord             OBJ_pilotAttributeType,26L
+
+#define LN_pilotAttributeType27         "pilotAttributeType27"
+#define NID_pilotAttributeType27                479
+#define OBJ_pilotAttributeType27                OBJ_pilotAttributeType,27L
+
+#define LN_mXRecord             "mXRecord"
+#define NID_mXRecord            480
+#define OBJ_mXRecord            OBJ_pilotAttributeType,28L
+
+#define LN_nSRecord             "nSRecord"
+#define NID_nSRecord            481
+#define OBJ_nSRecord            OBJ_pilotAttributeType,29L
+
+#define LN_sOARecord            "sOARecord"
+#define NID_sOARecord           482
+#define OBJ_sOARecord           OBJ_pilotAttributeType,30L
+
+#define LN_cNAMERecord          "cNAMERecord"
+#define NID_cNAMERecord         483
+#define OBJ_cNAMERecord         OBJ_pilotAttributeType,31L
+
+#define LN_associatedDomain             "associatedDomain"
+#define NID_associatedDomain            484
+#define OBJ_associatedDomain            OBJ_pilotAttributeType,37L
+
+#define LN_associatedName               "associatedName"
+#define NID_associatedName              485
+#define OBJ_associatedName              OBJ_pilotAttributeType,38L
+
+#define LN_homePostalAddress            "homePostalAddress"
+#define NID_homePostalAddress           486
+#define OBJ_homePostalAddress           OBJ_pilotAttributeType,39L
+
+#define LN_personalTitle                "personalTitle"
+#define NID_personalTitle               487
+#define OBJ_personalTitle               OBJ_pilotAttributeType,40L
+
+#define LN_mobileTelephoneNumber                "mobileTelephoneNumber"
+#define NID_mobileTelephoneNumber               488
+#define OBJ_mobileTelephoneNumber               OBJ_pilotAttributeType,41L
+
+#define LN_pagerTelephoneNumber         "pagerTelephoneNumber"
+#define NID_pagerTelephoneNumber                489
+#define OBJ_pagerTelephoneNumber                OBJ_pilotAttributeType,42L
+
+#define LN_friendlyCountryName          "friendlyCountryName"
+#define NID_friendlyCountryName         490
+#define OBJ_friendlyCountryName         OBJ_pilotAttributeType,43L
+
+#define SN_uniqueIdentifier             "uid"
+#define LN_uniqueIdentifier             "uniqueIdentifier"
+#define NID_uniqueIdentifier            102
+#define OBJ_uniqueIdentifier            OBJ_pilotAttributeType,44L
+
+#define LN_organizationalStatus         "organizationalStatus"
+#define NID_organizationalStatus                491
+#define OBJ_organizationalStatus                OBJ_pilotAttributeType,45L
+
+#define LN_janetMailbox         "janetMailbox"
+#define NID_janetMailbox                492
+#define OBJ_janetMailbox                OBJ_pilotAttributeType,46L
+
+#define LN_mailPreferenceOption         "mailPreferenceOption"
+#define NID_mailPreferenceOption                493
+#define OBJ_mailPreferenceOption                OBJ_pilotAttributeType,47L
+
+#define LN_buildingName         "buildingName"
+#define NID_buildingName                494
+#define OBJ_buildingName                OBJ_pilotAttributeType,48L
+
+#define LN_dSAQuality           "dSAQuality"
+#define NID_dSAQuality          495
+#define OBJ_dSAQuality          OBJ_pilotAttributeType,49L
+
+#define LN_singleLevelQuality           "singleLevelQuality"
+#define NID_singleLevelQuality          496
+#define OBJ_singleLevelQuality          OBJ_pilotAttributeType,50L
+
+#define LN_subtreeMinimumQuality                "subtreeMinimumQuality"
+#define NID_subtreeMinimumQuality               497
+#define OBJ_subtreeMinimumQuality               OBJ_pilotAttributeType,51L
+
+#define LN_subtreeMaximumQuality                "subtreeMaximumQuality"
+#define NID_subtreeMaximumQuality               498
+#define OBJ_subtreeMaximumQuality               OBJ_pilotAttributeType,52L
+
+#define LN_personalSignature            "personalSignature"
+#define NID_personalSignature           499
+#define OBJ_personalSignature           OBJ_pilotAttributeType,53L
+
+#define LN_dITRedirect          "dITRedirect"
+#define NID_dITRedirect         500
+#define OBJ_dITRedirect         OBJ_pilotAttributeType,54L
+
+#define SN_audio                "audio"
+#define NID_audio               501
+#define OBJ_audio               OBJ_pilotAttributeType,55L
+
+#define LN_documentPublisher            "documentPublisher"
+#define NID_documentPublisher           502
+#define OBJ_documentPublisher           OBJ_pilotAttributeType,56L
+
+#define SN_id_set               "id-set"
+#define LN_id_set               "Secure Electronic Transactions"
+#define NID_id_set              512
+#define OBJ_id_set              OBJ_international_organizations,42L
+
+#define SN_set_ctype            "set-ctype"
+#define LN_set_ctype            "content types"
+#define NID_set_ctype           513
+#define OBJ_set_ctype           OBJ_id_set,0L
+
+#define SN_set_msgExt           "set-msgExt"
+#define LN_set_msgExt           "message extensions"
+#define NID_set_msgExt          514
+#define OBJ_set_msgExt          OBJ_id_set,1L
+
+#define SN_set_attr             "set-attr"
+#define NID_set_attr            515
+#define OBJ_set_attr            OBJ_id_set,3L
+
+#define SN_set_policy           "set-policy"
+#define NID_set_policy          516
+#define OBJ_set_policy          OBJ_id_set,5L
+
+#define SN_set_certExt          "set-certExt"
+#define LN_set_certExt          "certificate extensions"
+#define NID_set_certExt         517
+#define OBJ_set_certExt         OBJ_id_set,7L
+
+#define SN_set_brand            "set-brand"
+#define NID_set_brand           518
+#define OBJ_set_brand           OBJ_id_set,8L
+
+#define SN_setct_PANData                "setct-PANData"
+#define NID_setct_PANData               519
+#define OBJ_setct_PANData               OBJ_set_ctype,0L
+
+#define SN_setct_PANToken               "setct-PANToken"
+#define NID_setct_PANToken              520
+#define OBJ_setct_PANToken              OBJ_set_ctype,1L
+
+#define SN_setct_PANOnly                "setct-PANOnly"
+#define NID_setct_PANOnly               521
+#define OBJ_setct_PANOnly               OBJ_set_ctype,2L
+
+#define SN_setct_OIData         "setct-OIData"
+#define NID_setct_OIData                522
+#define OBJ_setct_OIData                OBJ_set_ctype,3L
+
+#define SN_setct_PI             "setct-PI"
+#define NID_setct_PI            523
+#define OBJ_setct_PI            OBJ_set_ctype,4L
+
+#define SN_setct_PIData         "setct-PIData"
+#define NID_setct_PIData                524
+#define OBJ_setct_PIData                OBJ_set_ctype,5L
+
+#define SN_setct_PIDataUnsigned         "setct-PIDataUnsigned"
+#define NID_setct_PIDataUnsigned                525
+#define OBJ_setct_PIDataUnsigned                OBJ_set_ctype,6L
+
+#define SN_setct_HODInput               "setct-HODInput"
+#define NID_setct_HODInput              526
+#define OBJ_setct_HODInput              OBJ_set_ctype,7L
+
+#define SN_setct_AuthResBaggage         "setct-AuthResBaggage"
+#define NID_setct_AuthResBaggage                527
+#define OBJ_setct_AuthResBaggage                OBJ_set_ctype,8L
+
+#define SN_setct_AuthRevReqBaggage              "setct-AuthRevReqBaggage"
+#define NID_setct_AuthRevReqBaggage             528
+#define OBJ_setct_AuthRevReqBaggage             OBJ_set_ctype,9L
+
+#define SN_setct_AuthRevResBaggage              "setct-AuthRevResBaggage"
+#define NID_setct_AuthRevResBaggage             529
+#define OBJ_setct_AuthRevResBaggage             OBJ_set_ctype,10L
+
+#define SN_setct_CapTokenSeq            "setct-CapTokenSeq"
+#define NID_setct_CapTokenSeq           530
+#define OBJ_setct_CapTokenSeq           OBJ_set_ctype,11L
+
+#define SN_setct_PInitResData           "setct-PInitResData"
+#define NID_setct_PInitResData          531
+#define OBJ_setct_PInitResData          OBJ_set_ctype,12L
+
+#define SN_setct_PI_TBS         "setct-PI-TBS"
+#define NID_setct_PI_TBS                532
+#define OBJ_setct_PI_TBS                OBJ_set_ctype,13L
+
+#define SN_setct_PResData               "setct-PResData"
+#define NID_setct_PResData              533
+#define OBJ_setct_PResData              OBJ_set_ctype,14L
+
+#define SN_setct_AuthReqTBS             "setct-AuthReqTBS"
+#define NID_setct_AuthReqTBS            534
+#define OBJ_setct_AuthReqTBS            OBJ_set_ctype,16L
+
+#define SN_setct_AuthResTBS             "setct-AuthResTBS"
+#define NID_setct_AuthResTBS            535
+#define OBJ_setct_AuthResTBS            OBJ_set_ctype,17L
+
+#define SN_setct_AuthResTBSX            "setct-AuthResTBSX"
+#define NID_setct_AuthResTBSX           536
+#define OBJ_setct_AuthResTBSX           OBJ_set_ctype,18L
+
+#define SN_setct_AuthTokenTBS           "setct-AuthTokenTBS"
+#define NID_setct_AuthTokenTBS          537
+#define OBJ_setct_AuthTokenTBS          OBJ_set_ctype,19L
+
+#define SN_setct_CapTokenData           "setct-CapTokenData"
+#define NID_setct_CapTokenData          538
+#define OBJ_setct_CapTokenData          OBJ_set_ctype,20L
+
+#define SN_setct_CapTokenTBS            "setct-CapTokenTBS"
+#define NID_setct_CapTokenTBS           539
+#define OBJ_setct_CapTokenTBS           OBJ_set_ctype,21L
+
+#define SN_setct_AcqCardCodeMsg         "setct-AcqCardCodeMsg"
+#define NID_setct_AcqCardCodeMsg                540
+#define OBJ_setct_AcqCardCodeMsg                OBJ_set_ctype,22L
+
+#define SN_setct_AuthRevReqTBS          "setct-AuthRevReqTBS"
+#define NID_setct_AuthRevReqTBS         541
+#define OBJ_setct_AuthRevReqTBS         OBJ_set_ctype,23L
+
+#define SN_setct_AuthRevResData         "setct-AuthRevResData"
+#define NID_setct_AuthRevResData                542
+#define OBJ_setct_AuthRevResData                OBJ_set_ctype,24L
+
+#define SN_setct_AuthRevResTBS          "setct-AuthRevResTBS"
+#define NID_setct_AuthRevResTBS         543
+#define OBJ_setct_AuthRevResTBS         OBJ_set_ctype,25L
+
+#define SN_setct_CapReqTBS              "setct-CapReqTBS"
+#define NID_setct_CapReqTBS             544
+#define OBJ_setct_CapReqTBS             OBJ_set_ctype,26L
+
+#define SN_setct_CapReqTBSX             "setct-CapReqTBSX"
+#define NID_setct_CapReqTBSX            545
+#define OBJ_setct_CapReqTBSX            OBJ_set_ctype,27L
+
+#define SN_setct_CapResData             "setct-CapResData"
+#define NID_setct_CapResData            546
+#define OBJ_setct_CapResData            OBJ_set_ctype,28L
+
+#define SN_setct_CapRevReqTBS           "setct-CapRevReqTBS"
+#define NID_setct_CapRevReqTBS          547
+#define OBJ_setct_CapRevReqTBS          OBJ_set_ctype,29L
+
+#define SN_setct_CapRevReqTBSX          "setct-CapRevReqTBSX"
+#define NID_setct_CapRevReqTBSX         548
+#define OBJ_setct_CapRevReqTBSX         OBJ_set_ctype,30L
+
+#define SN_setct_CapRevResData          "setct-CapRevResData"
+#define NID_setct_CapRevResData         549
+#define OBJ_setct_CapRevResData         OBJ_set_ctype,31L
+
+#define SN_setct_CredReqTBS             "setct-CredReqTBS"
+#define NID_setct_CredReqTBS            550
+#define OBJ_setct_CredReqTBS            OBJ_set_ctype,32L
+
+#define SN_setct_CredReqTBSX            "setct-CredReqTBSX"
+#define NID_setct_CredReqTBSX           551
+#define OBJ_setct_CredReqTBSX           OBJ_set_ctype,33L
+
+#define SN_setct_CredResData            "setct-CredResData"
+#define NID_setct_CredResData           552
+#define OBJ_setct_CredResData           OBJ_set_ctype,34L
+
+#define SN_setct_CredRevReqTBS          "setct-CredRevReqTBS"
+#define NID_setct_CredRevReqTBS         553
+#define OBJ_setct_CredRevReqTBS         OBJ_set_ctype,35L
+
+#define SN_setct_CredRevReqTBSX         "setct-CredRevReqTBSX"
+#define NID_setct_CredRevReqTBSX                554
+#define OBJ_setct_CredRevReqTBSX                OBJ_set_ctype,36L
+
+#define SN_setct_CredRevResData         "setct-CredRevResData"
+#define NID_setct_CredRevResData                555
+#define OBJ_setct_CredRevResData                OBJ_set_ctype,37L
+
+#define SN_setct_PCertReqData           "setct-PCertReqData"
+#define NID_setct_PCertReqData          556
+#define OBJ_setct_PCertReqData          OBJ_set_ctype,38L
+
+#define SN_setct_PCertResTBS            "setct-PCertResTBS"
+#define NID_setct_PCertResTBS           557
+#define OBJ_setct_PCertResTBS           OBJ_set_ctype,39L
+
+#define SN_setct_BatchAdminReqData              "setct-BatchAdminReqData"
+#define NID_setct_BatchAdminReqData             558
+#define OBJ_setct_BatchAdminReqData             OBJ_set_ctype,40L
+
+#define SN_setct_BatchAdminResData              "setct-BatchAdminResData"
+#define NID_setct_BatchAdminResData             559
+#define OBJ_setct_BatchAdminResData             OBJ_set_ctype,41L
+
+#define SN_setct_CardCInitResTBS                "setct-CardCInitResTBS"
+#define NID_setct_CardCInitResTBS               560
+#define OBJ_setct_CardCInitResTBS               OBJ_set_ctype,42L
+
+#define SN_setct_MeAqCInitResTBS                "setct-MeAqCInitResTBS"
+#define NID_setct_MeAqCInitResTBS               561
+#define OBJ_setct_MeAqCInitResTBS               OBJ_set_ctype,43L
+
+#define SN_setct_RegFormResTBS          "setct-RegFormResTBS"
+#define NID_setct_RegFormResTBS         562
+#define OBJ_setct_RegFormResTBS         OBJ_set_ctype,44L
+
+#define SN_setct_CertReqData            "setct-CertReqData"
+#define NID_setct_CertReqData           563
+#define OBJ_setct_CertReqData           OBJ_set_ctype,45L
+
+#define SN_setct_CertReqTBS             "setct-CertReqTBS"
+#define NID_setct_CertReqTBS            564
+#define OBJ_setct_CertReqTBS            OBJ_set_ctype,46L
+
+#define SN_setct_CertResData            "setct-CertResData"
+#define NID_setct_CertResData           565
+#define OBJ_setct_CertResData           OBJ_set_ctype,47L
+
+#define SN_setct_CertInqReqTBS          "setct-CertInqReqTBS"
+#define NID_setct_CertInqReqTBS         566
+#define OBJ_setct_CertInqReqTBS         OBJ_set_ctype,48L
+
+#define SN_setct_ErrorTBS               "setct-ErrorTBS"
+#define NID_setct_ErrorTBS              567
+#define OBJ_setct_ErrorTBS              OBJ_set_ctype,49L
+
+#define SN_setct_PIDualSignedTBE                "setct-PIDualSignedTBE"
+#define NID_setct_PIDualSignedTBE               568
+#define OBJ_setct_PIDualSignedTBE               OBJ_set_ctype,50L
+
+#define SN_setct_PIUnsignedTBE          "setct-PIUnsignedTBE"
+#define NID_setct_PIUnsignedTBE         569
+#define OBJ_setct_PIUnsignedTBE         OBJ_set_ctype,51L
+
+#define SN_setct_AuthReqTBE             "setct-AuthReqTBE"
+#define NID_setct_AuthReqTBE            570
+#define OBJ_setct_AuthReqTBE            OBJ_set_ctype,52L
+
+#define SN_setct_AuthResTBE             "setct-AuthResTBE"
+#define NID_setct_AuthResTBE            571
+#define OBJ_setct_AuthResTBE            OBJ_set_ctype,53L
+
+#define SN_setct_AuthResTBEX            "setct-AuthResTBEX"
+#define NID_setct_AuthResTBEX           572
+#define OBJ_setct_AuthResTBEX           OBJ_set_ctype,54L
+
+#define SN_setct_AuthTokenTBE           "setct-AuthTokenTBE"
+#define NID_setct_AuthTokenTBE          573
+#define OBJ_setct_AuthTokenTBE          OBJ_set_ctype,55L
+
+#define SN_setct_CapTokenTBE            "setct-CapTokenTBE"
+#define NID_setct_CapTokenTBE           574
+#define OBJ_setct_CapTokenTBE           OBJ_set_ctype,56L
+
+#define SN_setct_CapTokenTBEX           "setct-CapTokenTBEX"
+#define NID_setct_CapTokenTBEX          575
+#define OBJ_setct_CapTokenTBEX          OBJ_set_ctype,57L
+
+#define SN_setct_AcqCardCodeMsgTBE              "setct-AcqCardCodeMsgTBE"
+#define NID_setct_AcqCardCodeMsgTBE             576
+#define OBJ_setct_AcqCardCodeMsgTBE             OBJ_set_ctype,58L
+
+#define SN_setct_AuthRevReqTBE          "setct-AuthRevReqTBE"
+#define NID_setct_AuthRevReqTBE         577
+#define OBJ_setct_AuthRevReqTBE         OBJ_set_ctype,59L
+
+#define SN_setct_AuthRevResTBE          "setct-AuthRevResTBE"
+#define NID_setct_AuthRevResTBE         578
+#define OBJ_setct_AuthRevResTBE         OBJ_set_ctype,60L
+
+#define SN_setct_AuthRevResTBEB         "setct-AuthRevResTBEB"
+#define NID_setct_AuthRevResTBEB                579
+#define OBJ_setct_AuthRevResTBEB                OBJ_set_ctype,61L
+
+#define SN_setct_CapReqTBE              "setct-CapReqTBE"
+#define NID_setct_CapReqTBE             580
+#define OBJ_setct_CapReqTBE             OBJ_set_ctype,62L
+
+#define SN_setct_CapReqTBEX             "setct-CapReqTBEX"
+#define NID_setct_CapReqTBEX            581
+#define OBJ_setct_CapReqTBEX            OBJ_set_ctype,63L
+
+#define SN_setct_CapResTBE              "setct-CapResTBE"
+#define NID_setct_CapResTBE             582
+#define OBJ_setct_CapResTBE             OBJ_set_ctype,64L
+
+#define SN_setct_CapRevReqTBE           "setct-CapRevReqTBE"
+#define NID_setct_CapRevReqTBE          583
+#define OBJ_setct_CapRevReqTBE          OBJ_set_ctype,65L
+
+#define SN_setct_CapRevReqTBEX          "setct-CapRevReqTBEX"
+#define NID_setct_CapRevReqTBEX         584
+#define OBJ_setct_CapRevReqTBEX         OBJ_set_ctype,66L
+
+#define SN_setct_CapRevResTBE           "setct-CapRevResTBE"
+#define NID_setct_CapRevResTBE          585
+#define OBJ_setct_CapRevResTBE          OBJ_set_ctype,67L
+
+#define SN_setct_CredReqTBE             "setct-CredReqTBE"
+#define NID_setct_CredReqTBE            586
+#define OBJ_setct_CredReqTBE            OBJ_set_ctype,68L
+
+#define SN_setct_CredReqTBEX            "setct-CredReqTBEX"
+#define NID_setct_CredReqTBEX           587
+#define OBJ_setct_CredReqTBEX           OBJ_set_ctype,69L
+
+#define SN_setct_CredResTBE             "setct-CredResTBE"
+#define NID_setct_CredResTBE            588
+#define OBJ_setct_CredResTBE            OBJ_set_ctype,70L
+
+#define SN_setct_CredRevReqTBE          "setct-CredRevReqTBE"
+#define NID_setct_CredRevReqTBE         589
+#define OBJ_setct_CredRevReqTBE         OBJ_set_ctype,71L
+
+#define SN_setct_CredRevReqTBEX         "setct-CredRevReqTBEX"
+#define NID_setct_CredRevReqTBEX                590
+#define OBJ_setct_CredRevReqTBEX                OBJ_set_ctype,72L
+
+#define SN_setct_CredRevResTBE          "setct-CredRevResTBE"
+#define NID_setct_CredRevResTBE         591
+#define OBJ_setct_CredRevResTBE         OBJ_set_ctype,73L
+
+#define SN_setct_BatchAdminReqTBE               "setct-BatchAdminReqTBE"
+#define NID_setct_BatchAdminReqTBE              592
+#define OBJ_setct_BatchAdminReqTBE              OBJ_set_ctype,74L
+
+#define SN_setct_BatchAdminResTBE               "setct-BatchAdminResTBE"
+#define NID_setct_BatchAdminResTBE              593
+#define OBJ_setct_BatchAdminResTBE              OBJ_set_ctype,75L
+
+#define SN_setct_RegFormReqTBE          "setct-RegFormReqTBE"
+#define NID_setct_RegFormReqTBE         594
+#define OBJ_setct_RegFormReqTBE         OBJ_set_ctype,76L
+
+#define SN_setct_CertReqTBE             "setct-CertReqTBE"
+#define NID_setct_CertReqTBE            595
+#define OBJ_setct_CertReqTBE            OBJ_set_ctype,77L
+
+#define SN_setct_CertReqTBEX            "setct-CertReqTBEX"
+#define NID_setct_CertReqTBEX           596
+#define OBJ_setct_CertReqTBEX           OBJ_set_ctype,78L
+
+#define SN_setct_CertResTBE             "setct-CertResTBE"
+#define NID_setct_CertResTBE            597
+#define OBJ_setct_CertResTBE            OBJ_set_ctype,79L
+
+#define SN_setct_CRLNotificationTBS             "setct-CRLNotificationTBS"
+#define NID_setct_CRLNotificationTBS            598
+#define OBJ_setct_CRLNotificationTBS            OBJ_set_ctype,80L
+
+#define SN_setct_CRLNotificationResTBS          "setct-CRLNotificationResTBS"
+#define NID_setct_CRLNotificationResTBS         599
+#define OBJ_setct_CRLNotificationResTBS         OBJ_set_ctype,81L
+
+#define SN_setct_BCIDistributionTBS             "setct-BCIDistributionTBS"
+#define NID_setct_BCIDistributionTBS            600
+#define OBJ_setct_BCIDistributionTBS            OBJ_set_ctype,82L
+
+#define SN_setext_genCrypt              "setext-genCrypt"
+#define LN_setext_genCrypt              "generic cryptogram"
+#define NID_setext_genCrypt             601
+#define OBJ_setext_genCrypt             OBJ_set_msgExt,1L
+
+#define SN_setext_miAuth                "setext-miAuth"
+#define LN_setext_miAuth                "merchant initiated auth"
+#define NID_setext_miAuth               602
+#define OBJ_setext_miAuth               OBJ_set_msgExt,3L
+
+#define SN_setext_pinSecure             "setext-pinSecure"
+#define NID_setext_pinSecure            603
+#define OBJ_setext_pinSecure            OBJ_set_msgExt,4L
+
+#define SN_setext_pinAny                "setext-pinAny"
+#define NID_setext_pinAny               604
+#define OBJ_setext_pinAny               OBJ_set_msgExt,5L
+
+#define SN_setext_track2                "setext-track2"
+#define NID_setext_track2               605
+#define OBJ_setext_track2               OBJ_set_msgExt,7L
+
+#define SN_setext_cv            "setext-cv"
+#define LN_setext_cv            "additional verification"
+#define NID_setext_cv           606
+#define OBJ_setext_cv           OBJ_set_msgExt,8L
+
+#define SN_set_policy_root              "set-policy-root"
+#define NID_set_policy_root             607
+#define OBJ_set_policy_root             OBJ_set_policy,0L
+
+#define SN_setCext_hashedRoot           "setCext-hashedRoot"
+#define NID_setCext_hashedRoot          608
+#define OBJ_setCext_hashedRoot          OBJ_set_certExt,0L
+
+#define SN_setCext_certType             "setCext-certType"
+#define NID_setCext_certType            609
+#define OBJ_setCext_certType            OBJ_set_certExt,1L
+
+#define SN_setCext_merchData            "setCext-merchData"
+#define NID_setCext_merchData           610
+#define OBJ_setCext_merchData           OBJ_set_certExt,2L
+
+#define SN_setCext_cCertRequired                "setCext-cCertRequired"
+#define NID_setCext_cCertRequired               611
+#define OBJ_setCext_cCertRequired               OBJ_set_certExt,3L
+
+#define SN_setCext_tunneling            "setCext-tunneling"
+#define NID_setCext_tunneling           612
+#define OBJ_setCext_tunneling           OBJ_set_certExt,4L
+
+#define SN_setCext_setExt               "setCext-setExt"
+#define NID_setCext_setExt              613
+#define OBJ_setCext_setExt              OBJ_set_certExt,5L
+
+#define SN_setCext_setQualf             "setCext-setQualf"
+#define NID_setCext_setQualf            614
+#define OBJ_setCext_setQualf            OBJ_set_certExt,6L
+
+#define SN_setCext_PGWYcapabilities             "setCext-PGWYcapabilities"
+#define NID_setCext_PGWYcapabilities            615
+#define OBJ_setCext_PGWYcapabilities            OBJ_set_certExt,7L
+
+#define SN_setCext_TokenIdentifier              "setCext-TokenIdentifier"
+#define NID_setCext_TokenIdentifier             616
+#define OBJ_setCext_TokenIdentifier             OBJ_set_certExt,8L
+
+#define SN_setCext_Track2Data           "setCext-Track2Data"
+#define NID_setCext_Track2Data          617
+#define OBJ_setCext_Track2Data          OBJ_set_certExt,9L
+
+#define SN_setCext_TokenType            "setCext-TokenType"
+#define NID_setCext_TokenType           618
+#define OBJ_setCext_TokenType           OBJ_set_certExt,10L
+
+#define SN_setCext_IssuerCapabilities           "setCext-IssuerCapabilities"
+#define NID_setCext_IssuerCapabilities          619
+#define OBJ_setCext_IssuerCapabilities          OBJ_set_certExt,11L
+
+#define SN_setAttr_Cert         "setAttr-Cert"
+#define NID_setAttr_Cert                620
+#define OBJ_setAttr_Cert                OBJ_set_attr,0L
+
+#define SN_setAttr_PGWYcap              "setAttr-PGWYcap"
+#define LN_setAttr_PGWYcap              "payment gateway capabilities"
+#define NID_setAttr_PGWYcap             621
+#define OBJ_setAttr_PGWYcap             OBJ_set_attr,1L
+
+#define SN_setAttr_TokenType            "setAttr-TokenType"
+#define NID_setAttr_TokenType           622
+#define OBJ_setAttr_TokenType           OBJ_set_attr,2L
+
+#define SN_setAttr_IssCap               "setAttr-IssCap"
+#define LN_setAttr_IssCap               "issuer capabilities"
+#define NID_setAttr_IssCap              623
+#define OBJ_setAttr_IssCap              OBJ_set_attr,3L
+
+#define SN_set_rootKeyThumb             "set-rootKeyThumb"
+#define NID_set_rootKeyThumb            624
+#define OBJ_set_rootKeyThumb            OBJ_setAttr_Cert,0L
+
+#define SN_set_addPolicy                "set-addPolicy"
+#define NID_set_addPolicy               625
+#define OBJ_set_addPolicy               OBJ_setAttr_Cert,1L
+
+#define SN_setAttr_Token_EMV            "setAttr-Token-EMV"
+#define NID_setAttr_Token_EMV           626
+#define OBJ_setAttr_Token_EMV           OBJ_setAttr_TokenType,1L
+
+#define SN_setAttr_Token_B0Prime                "setAttr-Token-B0Prime"
+#define NID_setAttr_Token_B0Prime               627
+#define OBJ_setAttr_Token_B0Prime               OBJ_setAttr_TokenType,2L
+
+#define SN_setAttr_IssCap_CVM           "setAttr-IssCap-CVM"
+#define NID_setAttr_IssCap_CVM          628
+#define OBJ_setAttr_IssCap_CVM          OBJ_setAttr_IssCap,3L
+
+#define SN_setAttr_IssCap_T2            "setAttr-IssCap-T2"
+#define NID_setAttr_IssCap_T2           629
+#define OBJ_setAttr_IssCap_T2           OBJ_setAttr_IssCap,4L
+
+#define SN_setAttr_IssCap_Sig           "setAttr-IssCap-Sig"
+#define NID_setAttr_IssCap_Sig          630
+#define OBJ_setAttr_IssCap_Sig          OBJ_setAttr_IssCap,5L
+
+#define SN_setAttr_GenCryptgrm          "setAttr-GenCryptgrm"
+#define LN_setAttr_GenCryptgrm          "generate cryptogram"
+#define NID_setAttr_GenCryptgrm         631
+#define OBJ_setAttr_GenCryptgrm         OBJ_setAttr_IssCap_CVM,1L
+
+#define SN_setAttr_T2Enc                "setAttr-T2Enc"
+#define LN_setAttr_T2Enc                "encrypted track 2"
+#define NID_setAttr_T2Enc               632
+#define OBJ_setAttr_T2Enc               OBJ_setAttr_IssCap_T2,1L
+
+#define SN_setAttr_T2cleartxt           "setAttr-T2cleartxt"
+#define LN_setAttr_T2cleartxt           "cleartext track 2"
+#define NID_setAttr_T2cleartxt          633
+#define OBJ_setAttr_T2cleartxt          OBJ_setAttr_IssCap_T2,2L
+
+#define SN_setAttr_TokICCsig            "setAttr-TokICCsig"
+#define LN_setAttr_TokICCsig            "ICC or token signature"
+#define NID_setAttr_TokICCsig           634
+#define OBJ_setAttr_TokICCsig           OBJ_setAttr_IssCap_Sig,1L
+
+#define SN_setAttr_SecDevSig            "setAttr-SecDevSig"
+#define LN_setAttr_SecDevSig            "secure device signature"
+#define NID_setAttr_SecDevSig           635
+#define OBJ_setAttr_SecDevSig           OBJ_setAttr_IssCap_Sig,2L
+
+#define SN_set_brand_IATA_ATA           "set-brand-IATA-ATA"
+#define NID_set_brand_IATA_ATA          636
+#define OBJ_set_brand_IATA_ATA          OBJ_set_brand,1L
+
+#define SN_set_brand_Diners             "set-brand-Diners"
+#define NID_set_brand_Diners            637
+#define OBJ_set_brand_Diners            OBJ_set_brand,30L
+
+#define SN_set_brand_AmericanExpress            "set-brand-AmericanExpress"
+#define NID_set_brand_AmericanExpress           638
+#define OBJ_set_brand_AmericanExpress           OBJ_set_brand,34L
+
+#define SN_set_brand_JCB                "set-brand-JCB"
+#define NID_set_brand_JCB               639
+#define OBJ_set_brand_JCB               OBJ_set_brand,35L
+
+#define SN_set_brand_Visa               "set-brand-Visa"
+#define NID_set_brand_Visa              640
+#define OBJ_set_brand_Visa              OBJ_set_brand,4L
+
+#define SN_set_brand_MasterCard         "set-brand-MasterCard"
+#define NID_set_brand_MasterCard                641
+#define OBJ_set_brand_MasterCard                OBJ_set_brand,5L
+
+#define SN_set_brand_Novus              "set-brand-Novus"
+#define NID_set_brand_Novus             642
+#define OBJ_set_brand_Novus             OBJ_set_brand,6011L
+
+#define SN_des_cdmf             "DES-CDMF"
+#define LN_des_cdmf             "des-cdmf"
+#define NID_des_cdmf            643
+#define OBJ_des_cdmf            OBJ_rsadsi,3L,10L
+
+#define SN_rsaOAEPEncryptionSET         "rsaOAEPEncryptionSET"
+#define NID_rsaOAEPEncryptionSET                644
+#define OBJ_rsaOAEPEncryptionSET                OBJ_rsadsi,1L,1L,6L
+
+#define SN_ipsec3               "Oakley-EC2N-3"
+#define LN_ipsec3               "ipsec3"
+#define NID_ipsec3              749
+
+#define SN_ipsec4               "Oakley-EC2N-4"
+#define LN_ipsec4               "ipsec4"
+#define NID_ipsec4              750
+
+#define SN_whirlpool            "whirlpool"
+#define NID_whirlpool           804
+#define OBJ_whirlpool           OBJ_iso,0L,10118L,3L,0L,55L
+
+#define SN_cryptopro            "cryptopro"
+#define NID_cryptopro           805
+#define OBJ_cryptopro           OBJ_member_body,643L,2L,2L
+
+#define SN_cryptocom            "cryptocom"
+#define NID_cryptocom           806
+#define OBJ_cryptocom           OBJ_member_body,643L,2L,9L
+
+#define SN_id_tc26              "id-tc26"
+#define NID_id_tc26             974
+#define OBJ_id_tc26             OBJ_member_body,643L,7L,1L
+
+#define SN_id_GostR3411_94_with_GostR3410_2001          "id-GostR3411-94-with-GostR3410-2001"
+#define LN_id_GostR3411_94_with_GostR3410_2001          "GOST R 34.11-94 with GOST R 34.10-2001"
+#define NID_id_GostR3411_94_with_GostR3410_2001         807
+#define OBJ_id_GostR3411_94_with_GostR3410_2001         OBJ_cryptopro,3L
+
+#define SN_id_GostR3411_94_with_GostR3410_94            "id-GostR3411-94-with-GostR3410-94"
+#define LN_id_GostR3411_94_with_GostR3410_94            "GOST R 34.11-94 with GOST R 34.10-94"
+#define NID_id_GostR3411_94_with_GostR3410_94           808
+#define OBJ_id_GostR3411_94_with_GostR3410_94           OBJ_cryptopro,4L
+
+#define SN_id_GostR3411_94              "md_gost94"
+#define LN_id_GostR3411_94              "GOST R 34.11-94"
+#define NID_id_GostR3411_94             809
+#define OBJ_id_GostR3411_94             OBJ_cryptopro,9L
+
+#define SN_id_HMACGostR3411_94          "id-HMACGostR3411-94"
+#define LN_id_HMACGostR3411_94          "HMAC GOST 34.11-94"
+#define NID_id_HMACGostR3411_94         810
+#define OBJ_id_HMACGostR3411_94         OBJ_cryptopro,10L
+
+#define SN_id_GostR3410_2001            "gost2001"
+#define LN_id_GostR3410_2001            "GOST R 34.10-2001"
+#define NID_id_GostR3410_2001           811
+#define OBJ_id_GostR3410_2001           OBJ_cryptopro,19L
+
+#define SN_id_GostR3410_94              "gost94"
+#define LN_id_GostR3410_94              "GOST R 34.10-94"
+#define NID_id_GostR3410_94             812
+#define OBJ_id_GostR3410_94             OBJ_cryptopro,20L
+
+#define SN_id_Gost28147_89              "gost89"
+#define LN_id_Gost28147_89              "GOST 28147-89"
+#define NID_id_Gost28147_89             813
+#define OBJ_id_Gost28147_89             OBJ_cryptopro,21L
+
+#define SN_gost89_cnt           "gost89-cnt"
+#define NID_gost89_cnt          814
+
+#define SN_gost89_cnt_12                "gost89-cnt-12"
+#define NID_gost89_cnt_12               975
+
+#define SN_gost89_cbc           "gost89-cbc"
+#define NID_gost89_cbc          1009
+
+#define SN_gost89_ecb           "gost89-ecb"
+#define NID_gost89_ecb          1010
+
+#define SN_gost89_ctr           "gost89-ctr"
+#define NID_gost89_ctr          1011
+
+#define SN_id_Gost28147_89_MAC          "gost-mac"
+#define LN_id_Gost28147_89_MAC          "GOST 28147-89 MAC"
+#define NID_id_Gost28147_89_MAC         815
+#define OBJ_id_Gost28147_89_MAC         OBJ_cryptopro,22L
+
+#define SN_gost_mac_12          "gost-mac-12"
+#define NID_gost_mac_12         976
+
+#define SN_id_GostR3411_94_prf          "prf-gostr3411-94"
+#define LN_id_GostR3411_94_prf          "GOST R 34.11-94 PRF"
+#define NID_id_GostR3411_94_prf         816
+#define OBJ_id_GostR3411_94_prf         OBJ_cryptopro,23L
+
+#define SN_id_GostR3410_2001DH          "id-GostR3410-2001DH"
+#define LN_id_GostR3410_2001DH          "GOST R 34.10-2001 DH"
+#define NID_id_GostR3410_2001DH         817
+#define OBJ_id_GostR3410_2001DH         OBJ_cryptopro,98L
+
+#define SN_id_GostR3410_94DH            "id-GostR3410-94DH"
+#define LN_id_GostR3410_94DH            "GOST R 34.10-94 DH"
+#define NID_id_GostR3410_94DH           818
+#define OBJ_id_GostR3410_94DH           OBJ_cryptopro,99L
+
+#define SN_id_Gost28147_89_CryptoPro_KeyMeshing         "id-Gost28147-89-CryptoPro-KeyMeshing"
+#define NID_id_Gost28147_89_CryptoPro_KeyMeshing                819
+#define OBJ_id_Gost28147_89_CryptoPro_KeyMeshing                OBJ_cryptopro,14L,1L
+
+#define SN_id_Gost28147_89_None_KeyMeshing              "id-Gost28147-89-None-KeyMeshing"
+#define NID_id_Gost28147_89_None_KeyMeshing             820
+#define OBJ_id_Gost28147_89_None_KeyMeshing             OBJ_cryptopro,14L,0L
+
+#define SN_id_GostR3411_94_TestParamSet         "id-GostR3411-94-TestParamSet"
+#define NID_id_GostR3411_94_TestParamSet                821
+#define OBJ_id_GostR3411_94_TestParamSet                OBJ_cryptopro,30L,0L
+
+#define SN_id_GostR3411_94_CryptoProParamSet            "id-GostR3411-94-CryptoProParamSet"
+#define NID_id_GostR3411_94_CryptoProParamSet           822
+#define OBJ_id_GostR3411_94_CryptoProParamSet           OBJ_cryptopro,30L,1L
+
+#define SN_id_Gost28147_89_TestParamSet         "id-Gost28147-89-TestParamSet"
+#define NID_id_Gost28147_89_TestParamSet                823
+#define OBJ_id_Gost28147_89_TestParamSet                OBJ_cryptopro,31L,0L
+
+#define SN_id_Gost28147_89_CryptoPro_A_ParamSet         "id-Gost28147-89-CryptoPro-A-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_A_ParamSet                824
+#define OBJ_id_Gost28147_89_CryptoPro_A_ParamSet                OBJ_cryptopro,31L,1L
+
+#define SN_id_Gost28147_89_CryptoPro_B_ParamSet         "id-Gost28147-89-CryptoPro-B-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_B_ParamSet                825
+#define OBJ_id_Gost28147_89_CryptoPro_B_ParamSet                OBJ_cryptopro,31L,2L
+
+#define SN_id_Gost28147_89_CryptoPro_C_ParamSet         "id-Gost28147-89-CryptoPro-C-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_C_ParamSet                826
+#define OBJ_id_Gost28147_89_CryptoPro_C_ParamSet                OBJ_cryptopro,31L,3L
+
+#define SN_id_Gost28147_89_CryptoPro_D_ParamSet         "id-Gost28147-89-CryptoPro-D-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_D_ParamSet                827
+#define OBJ_id_Gost28147_89_CryptoPro_D_ParamSet                OBJ_cryptopro,31L,4L
+
+#define SN_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet         "id-Gost28147-89-CryptoPro-Oscar-1-1-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet                828
+#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet                OBJ_cryptopro,31L,5L
+
+#define SN_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet         "id-Gost28147-89-CryptoPro-Oscar-1-0-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet                829
+#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet                OBJ_cryptopro,31L,6L
+
+#define SN_id_Gost28147_89_CryptoPro_RIC_1_ParamSet             "id-Gost28147-89-CryptoPro-RIC-1-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_RIC_1_ParamSet            830
+#define OBJ_id_Gost28147_89_CryptoPro_RIC_1_ParamSet            OBJ_cryptopro,31L,7L
+
+#define SN_id_GostR3410_94_TestParamSet         "id-GostR3410-94-TestParamSet"
+#define NID_id_GostR3410_94_TestParamSet                831
+#define OBJ_id_GostR3410_94_TestParamSet                OBJ_cryptopro,32L,0L
+
+#define SN_id_GostR3410_94_CryptoPro_A_ParamSet         "id-GostR3410-94-CryptoPro-A-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_A_ParamSet                832
+#define OBJ_id_GostR3410_94_CryptoPro_A_ParamSet                OBJ_cryptopro,32L,2L
+
+#define SN_id_GostR3410_94_CryptoPro_B_ParamSet         "id-GostR3410-94-CryptoPro-B-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_B_ParamSet                833
+#define OBJ_id_GostR3410_94_CryptoPro_B_ParamSet                OBJ_cryptopro,32L,3L
+
+#define SN_id_GostR3410_94_CryptoPro_C_ParamSet         "id-GostR3410-94-CryptoPro-C-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_C_ParamSet                834
+#define OBJ_id_GostR3410_94_CryptoPro_C_ParamSet                OBJ_cryptopro,32L,4L
+
+#define SN_id_GostR3410_94_CryptoPro_D_ParamSet         "id-GostR3410-94-CryptoPro-D-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_D_ParamSet                835
+#define OBJ_id_GostR3410_94_CryptoPro_D_ParamSet                OBJ_cryptopro,32L,5L
+
+#define SN_id_GostR3410_94_CryptoPro_XchA_ParamSet              "id-GostR3410-94-CryptoPro-XchA-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchA_ParamSet             836
+#define OBJ_id_GostR3410_94_CryptoPro_XchA_ParamSet             OBJ_cryptopro,33L,1L
+
+#define SN_id_GostR3410_94_CryptoPro_XchB_ParamSet              "id-GostR3410-94-CryptoPro-XchB-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchB_ParamSet             837
+#define OBJ_id_GostR3410_94_CryptoPro_XchB_ParamSet             OBJ_cryptopro,33L,2L
+
+#define SN_id_GostR3410_94_CryptoPro_XchC_ParamSet              "id-GostR3410-94-CryptoPro-XchC-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchC_ParamSet             838
+#define OBJ_id_GostR3410_94_CryptoPro_XchC_ParamSet             OBJ_cryptopro,33L,3L
+
+#define SN_id_GostR3410_2001_TestParamSet               "id-GostR3410-2001-TestParamSet"
+#define NID_id_GostR3410_2001_TestParamSet              839
+#define OBJ_id_GostR3410_2001_TestParamSet              OBJ_cryptopro,35L,0L
+
+#define SN_id_GostR3410_2001_CryptoPro_A_ParamSet               "id-GostR3410-2001-CryptoPro-A-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_A_ParamSet              840
+#define OBJ_id_GostR3410_2001_CryptoPro_A_ParamSet              OBJ_cryptopro,35L,1L
+
+#define SN_id_GostR3410_2001_CryptoPro_B_ParamSet               "id-GostR3410-2001-CryptoPro-B-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_B_ParamSet              841
+#define OBJ_id_GostR3410_2001_CryptoPro_B_ParamSet              OBJ_cryptopro,35L,2L
+
+#define SN_id_GostR3410_2001_CryptoPro_C_ParamSet               "id-GostR3410-2001-CryptoPro-C-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_C_ParamSet              842
+#define OBJ_id_GostR3410_2001_CryptoPro_C_ParamSet              OBJ_cryptopro,35L,3L
+
+#define SN_id_GostR3410_2001_CryptoPro_XchA_ParamSet            "id-GostR3410-2001-CryptoPro-XchA-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet           843
+#define OBJ_id_GostR3410_2001_CryptoPro_XchA_ParamSet           OBJ_cryptopro,36L,0L
+
+#define SN_id_GostR3410_2001_CryptoPro_XchB_ParamSet            "id-GostR3410-2001-CryptoPro-XchB-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet           844
+#define OBJ_id_GostR3410_2001_CryptoPro_XchB_ParamSet           OBJ_cryptopro,36L,1L
+
+#define SN_id_GostR3410_94_a            "id-GostR3410-94-a"
+#define NID_id_GostR3410_94_a           845
+#define OBJ_id_GostR3410_94_a           OBJ_id_GostR3410_94,1L
+
+#define SN_id_GostR3410_94_aBis         "id-GostR3410-94-aBis"
+#define NID_id_GostR3410_94_aBis                846
+#define OBJ_id_GostR3410_94_aBis                OBJ_id_GostR3410_94,2L
+
+#define SN_id_GostR3410_94_b            "id-GostR3410-94-b"
+#define NID_id_GostR3410_94_b           847
+#define OBJ_id_GostR3410_94_b           OBJ_id_GostR3410_94,3L
+
+#define SN_id_GostR3410_94_bBis         "id-GostR3410-94-bBis"
+#define NID_id_GostR3410_94_bBis                848
+#define OBJ_id_GostR3410_94_bBis                OBJ_id_GostR3410_94,4L
+
+#define SN_id_Gost28147_89_cc           "id-Gost28147-89-cc"
+#define LN_id_Gost28147_89_cc           "GOST 28147-89 Cryptocom ParamSet"
+#define NID_id_Gost28147_89_cc          849
+#define OBJ_id_Gost28147_89_cc          OBJ_cryptocom,1L,6L,1L
+
+#define SN_id_GostR3410_94_cc           "gost94cc"
+#define LN_id_GostR3410_94_cc           "GOST 34.10-94 Cryptocom"
+#define NID_id_GostR3410_94_cc          850
+#define OBJ_id_GostR3410_94_cc          OBJ_cryptocom,1L,5L,3L
+
+#define SN_id_GostR3410_2001_cc         "gost2001cc"
+#define LN_id_GostR3410_2001_cc         "GOST 34.10-2001 Cryptocom"
+#define NID_id_GostR3410_2001_cc                851
+#define OBJ_id_GostR3410_2001_cc                OBJ_cryptocom,1L,5L,4L
+
+#define SN_id_GostR3411_94_with_GostR3410_94_cc         "id-GostR3411-94-with-GostR3410-94-cc"
+#define LN_id_GostR3411_94_with_GostR3410_94_cc         "GOST R 34.11-94 with GOST R 34.10-94 Cryptocom"
+#define NID_id_GostR3411_94_with_GostR3410_94_cc                852
+#define OBJ_id_GostR3411_94_with_GostR3410_94_cc                OBJ_cryptocom,1L,3L,3L
+
+#define SN_id_GostR3411_94_with_GostR3410_2001_cc               "id-GostR3411-94-with-GostR3410-2001-cc"
+#define LN_id_GostR3411_94_with_GostR3410_2001_cc               "GOST R 34.11-94 with GOST R 34.10-2001 Cryptocom"
+#define NID_id_GostR3411_94_with_GostR3410_2001_cc              853
+#define OBJ_id_GostR3411_94_with_GostR3410_2001_cc              OBJ_cryptocom,1L,3L,4L
+
+#define SN_id_GostR3410_2001_ParamSet_cc                "id-GostR3410-2001-ParamSet-cc"
+#define LN_id_GostR3410_2001_ParamSet_cc                "GOST R 3410-2001 Parameter Set Cryptocom"
+#define NID_id_GostR3410_2001_ParamSet_cc               854
+#define OBJ_id_GostR3410_2001_ParamSet_cc               OBJ_cryptocom,1L,8L,1L
+
+#define SN_id_tc26_algorithms           "id-tc26-algorithms"
+#define NID_id_tc26_algorithms          977
+#define OBJ_id_tc26_algorithms          OBJ_id_tc26,1L
+
+#define SN_id_tc26_sign         "id-tc26-sign"
+#define NID_id_tc26_sign                978
+#define OBJ_id_tc26_sign                OBJ_id_tc26_algorithms,1L
+
+#define SN_id_GostR3410_2012_256                "gost2012_256"
+#define LN_id_GostR3410_2012_256                "GOST R 34.10-2012 with 256 bit modulus"
+#define NID_id_GostR3410_2012_256               979
+#define OBJ_id_GostR3410_2012_256               OBJ_id_tc26_sign,1L
+
+#define SN_id_GostR3410_2012_512                "gost2012_512"
+#define LN_id_GostR3410_2012_512                "GOST R 34.10-2012 with 512 bit modulus"
+#define NID_id_GostR3410_2012_512               980
+#define OBJ_id_GostR3410_2012_512               OBJ_id_tc26_sign,2L
+
+#define SN_id_tc26_digest               "id-tc26-digest"
+#define NID_id_tc26_digest              981
+#define OBJ_id_tc26_digest              OBJ_id_tc26_algorithms,2L
+
+#define SN_id_GostR3411_2012_256                "md_gost12_256"
+#define LN_id_GostR3411_2012_256                "GOST R 34.11-2012 with 256 bit hash"
+#define NID_id_GostR3411_2012_256               982
+#define OBJ_id_GostR3411_2012_256               OBJ_id_tc26_digest,2L
+
+#define SN_id_GostR3411_2012_512                "md_gost12_512"
+#define LN_id_GostR3411_2012_512                "GOST R 34.11-2012 with 512 bit hash"
+#define NID_id_GostR3411_2012_512               983
+#define OBJ_id_GostR3411_2012_512               OBJ_id_tc26_digest,3L
+
+#define SN_id_tc26_signwithdigest               "id-tc26-signwithdigest"
+#define NID_id_tc26_signwithdigest              984
+#define OBJ_id_tc26_signwithdigest              OBJ_id_tc26_algorithms,3L
+
+#define SN_id_tc26_signwithdigest_gost3410_2012_256             "id-tc26-signwithdigest-gost3410-2012-256"
+#define LN_id_tc26_signwithdigest_gost3410_2012_256             "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)"
+#define NID_id_tc26_signwithdigest_gost3410_2012_256            985
+#define OBJ_id_tc26_signwithdigest_gost3410_2012_256            OBJ_id_tc26_signwithdigest,2L
+
+#define SN_id_tc26_signwithdigest_gost3410_2012_512             "id-tc26-signwithdigest-gost3410-2012-512"
+#define LN_id_tc26_signwithdigest_gost3410_2012_512             "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)"
+#define NID_id_tc26_signwithdigest_gost3410_2012_512            986
+#define OBJ_id_tc26_signwithdigest_gost3410_2012_512            OBJ_id_tc26_signwithdigest,3L
+
+#define SN_id_tc26_mac          "id-tc26-mac"
+#define NID_id_tc26_mac         987
+#define OBJ_id_tc26_mac         OBJ_id_tc26_algorithms,4L
+
+#define SN_id_tc26_hmac_gost_3411_2012_256              "id-tc26-hmac-gost-3411-2012-256"
+#define LN_id_tc26_hmac_gost_3411_2012_256              "HMAC GOST 34.11-2012 256 bit"
+#define NID_id_tc26_hmac_gost_3411_2012_256             988
+#define OBJ_id_tc26_hmac_gost_3411_2012_256             OBJ_id_tc26_mac,1L
+
+#define SN_id_tc26_hmac_gost_3411_2012_512              "id-tc26-hmac-gost-3411-2012-512"
+#define LN_id_tc26_hmac_gost_3411_2012_512              "HMAC GOST 34.11-2012 512 bit"
+#define NID_id_tc26_hmac_gost_3411_2012_512             989
+#define OBJ_id_tc26_hmac_gost_3411_2012_512             OBJ_id_tc26_mac,2L
+
+#define SN_id_tc26_cipher               "id-tc26-cipher"
+#define NID_id_tc26_cipher              990
+#define OBJ_id_tc26_cipher              OBJ_id_tc26_algorithms,5L
+
+#define SN_id_tc26_cipher_gostr3412_2015_magma          "id-tc26-cipher-gostr3412-2015-magma"
+#define NID_id_tc26_cipher_gostr3412_2015_magma         1173
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma         OBJ_id_tc26_cipher,1L
+
+#define SN_magma_ctr_acpkm              "magma-ctr-acpkm"
+#define NID_magma_ctr_acpkm             1174
+#define OBJ_magma_ctr_acpkm             OBJ_id_tc26_cipher_gostr3412_2015_magma,1L
+
+#define SN_magma_ctr_acpkm_omac         "magma-ctr-acpkm-omac"
+#define NID_magma_ctr_acpkm_omac                1175
+#define OBJ_magma_ctr_acpkm_omac                OBJ_id_tc26_cipher_gostr3412_2015_magma,2L
+
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik             "id-tc26-cipher-gostr3412-2015-kuznyechik"
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik            1176
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik            OBJ_id_tc26_cipher,2L
+
+#define SN_kuznyechik_ctr_acpkm         "kuznyechik-ctr-acpkm"
+#define NID_kuznyechik_ctr_acpkm                1177
+#define OBJ_kuznyechik_ctr_acpkm                OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,1L
+
+#define SN_kuznyechik_ctr_acpkm_omac            "kuznyechik-ctr-acpkm-omac"
+#define NID_kuznyechik_ctr_acpkm_omac           1178
+#define OBJ_kuznyechik_ctr_acpkm_omac           OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,2L
+
+#define SN_id_tc26_agreement            "id-tc26-agreement"
+#define NID_id_tc26_agreement           991
+#define OBJ_id_tc26_agreement           OBJ_id_tc26_algorithms,6L
+
+#define SN_id_tc26_agreement_gost_3410_2012_256         "id-tc26-agreement-gost-3410-2012-256"
+#define NID_id_tc26_agreement_gost_3410_2012_256                992
+#define OBJ_id_tc26_agreement_gost_3410_2012_256                OBJ_id_tc26_agreement,1L
+
+#define SN_id_tc26_agreement_gost_3410_2012_512         "id-tc26-agreement-gost-3410-2012-512"
+#define NID_id_tc26_agreement_gost_3410_2012_512                993
+#define OBJ_id_tc26_agreement_gost_3410_2012_512                OBJ_id_tc26_agreement,2L
+
+#define SN_id_tc26_wrap         "id-tc26-wrap"
+#define NID_id_tc26_wrap                1179
+#define OBJ_id_tc26_wrap                OBJ_id_tc26_algorithms,7L
+
+#define SN_id_tc26_wrap_gostr3412_2015_magma            "id-tc26-wrap-gostr3412-2015-magma"
+#define NID_id_tc26_wrap_gostr3412_2015_magma           1180
+#define OBJ_id_tc26_wrap_gostr3412_2015_magma           OBJ_id_tc26_wrap,1L
+
+#define SN_magma_kexp15         "magma-kexp15"
+#define NID_magma_kexp15                1181
+#define OBJ_magma_kexp15                OBJ_id_tc26_wrap_gostr3412_2015_magma,1L
+
+#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik               "id-tc26-wrap-gostr3412-2015-kuznyechik"
+#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik              1182
+#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik              OBJ_id_tc26_wrap,2L
+
+#define SN_kuznyechik_kexp15            "kuznyechik-kexp15"
+#define NID_kuznyechik_kexp15           1183
+#define OBJ_kuznyechik_kexp15           OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik,1L
+
+#define SN_id_tc26_constants            "id-tc26-constants"
+#define NID_id_tc26_constants           994
+#define OBJ_id_tc26_constants           OBJ_id_tc26,2L
+
+#define SN_id_tc26_sign_constants               "id-tc26-sign-constants"
+#define NID_id_tc26_sign_constants              995
+#define OBJ_id_tc26_sign_constants              OBJ_id_tc26_constants,1L
+
+#define SN_id_tc26_gost_3410_2012_256_constants         "id-tc26-gost-3410-2012-256-constants"
+#define NID_id_tc26_gost_3410_2012_256_constants                1147
+#define OBJ_id_tc26_gost_3410_2012_256_constants                OBJ_id_tc26_sign_constants,1L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetA         "id-tc26-gost-3410-2012-256-paramSetA"
+#define LN_id_tc26_gost_3410_2012_256_paramSetA         "GOST R 34.10-2012 (256 bit) ParamSet A"
+#define NID_id_tc26_gost_3410_2012_256_paramSetA                1148
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetA                OBJ_id_tc26_gost_3410_2012_256_constants,1L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetB         "id-tc26-gost-3410-2012-256-paramSetB"
+#define LN_id_tc26_gost_3410_2012_256_paramSetB         "GOST R 34.10-2012 (256 bit) ParamSet B"
+#define NID_id_tc26_gost_3410_2012_256_paramSetB                1184
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetB                OBJ_id_tc26_gost_3410_2012_256_constants,2L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetC         "id-tc26-gost-3410-2012-256-paramSetC"
+#define LN_id_tc26_gost_3410_2012_256_paramSetC         "GOST R 34.10-2012 (256 bit) ParamSet C"
+#define NID_id_tc26_gost_3410_2012_256_paramSetC                1185
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetC                OBJ_id_tc26_gost_3410_2012_256_constants,3L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetD         "id-tc26-gost-3410-2012-256-paramSetD"
+#define LN_id_tc26_gost_3410_2012_256_paramSetD         "GOST R 34.10-2012 (256 bit) ParamSet D"
+#define NID_id_tc26_gost_3410_2012_256_paramSetD                1186
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetD                OBJ_id_tc26_gost_3410_2012_256_constants,4L
+
+#define SN_id_tc26_gost_3410_2012_512_constants         "id-tc26-gost-3410-2012-512-constants"
+#define NID_id_tc26_gost_3410_2012_512_constants                996
+#define OBJ_id_tc26_gost_3410_2012_512_constants                OBJ_id_tc26_sign_constants,2L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetTest              "id-tc26-gost-3410-2012-512-paramSetTest"
+#define LN_id_tc26_gost_3410_2012_512_paramSetTest              "GOST R 34.10-2012 (512 bit) testing parameter set"
+#define NID_id_tc26_gost_3410_2012_512_paramSetTest             997
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetTest             OBJ_id_tc26_gost_3410_2012_512_constants,0L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetA         "id-tc26-gost-3410-2012-512-paramSetA"
+#define LN_id_tc26_gost_3410_2012_512_paramSetA         "GOST R 34.10-2012 (512 bit) ParamSet A"
+#define NID_id_tc26_gost_3410_2012_512_paramSetA                998
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetA                OBJ_id_tc26_gost_3410_2012_512_constants,1L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetB         "id-tc26-gost-3410-2012-512-paramSetB"
+#define LN_id_tc26_gost_3410_2012_512_paramSetB         "GOST R 34.10-2012 (512 bit) ParamSet B"
+#define NID_id_tc26_gost_3410_2012_512_paramSetB                999
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetB                OBJ_id_tc26_gost_3410_2012_512_constants,2L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetC         "id-tc26-gost-3410-2012-512-paramSetC"
+#define LN_id_tc26_gost_3410_2012_512_paramSetC         "GOST R 34.10-2012 (512 bit) ParamSet C"
+#define NID_id_tc26_gost_3410_2012_512_paramSetC                1149
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetC                OBJ_id_tc26_gost_3410_2012_512_constants,3L
+
+#define SN_id_tc26_digest_constants             "id-tc26-digest-constants"
+#define NID_id_tc26_digest_constants            1000
+#define OBJ_id_tc26_digest_constants            OBJ_id_tc26_constants,2L
+
+#define SN_id_tc26_cipher_constants             "id-tc26-cipher-constants"
+#define NID_id_tc26_cipher_constants            1001
+#define OBJ_id_tc26_cipher_constants            OBJ_id_tc26_constants,5L
+
+#define SN_id_tc26_gost_28147_constants         "id-tc26-gost-28147-constants"
+#define NID_id_tc26_gost_28147_constants                1002
+#define OBJ_id_tc26_gost_28147_constants                OBJ_id_tc26_cipher_constants,1L
+
+#define SN_id_tc26_gost_28147_param_Z           "id-tc26-gost-28147-param-Z"
+#define LN_id_tc26_gost_28147_param_Z           "GOST 28147-89 TC26 parameter set"
+#define NID_id_tc26_gost_28147_param_Z          1003
+#define OBJ_id_tc26_gost_28147_param_Z          OBJ_id_tc26_gost_28147_constants,1L
+
+#define SN_INN          "INN"
+#define LN_INN          "INN"
+#define NID_INN         1004
+#define OBJ_INN         OBJ_member_body,643L,3L,131L,1L,1L
+
+#define SN_OGRN         "OGRN"
+#define LN_OGRN         "OGRN"
+#define NID_OGRN                1005
+#define OBJ_OGRN                OBJ_member_body,643L,100L,1L
+
+#define SN_SNILS                "SNILS"
+#define LN_SNILS                "SNILS"
+#define NID_SNILS               1006
+#define OBJ_SNILS               OBJ_member_body,643L,100L,3L
+
+#define SN_OGRNIP               "OGRNIP"
+#define LN_OGRNIP               "OGRNIP"
+#define NID_OGRNIP              1226
+#define OBJ_OGRNIP              OBJ_member_body,643L,100L,5L
+
+#define SN_subjectSignTool              "subjectSignTool"
+#define LN_subjectSignTool              "Signing Tool of Subject"
+#define NID_subjectSignTool             1007
+#define OBJ_subjectSignTool             OBJ_member_body,643L,100L,111L
+
+#define SN_issuerSignTool               "issuerSignTool"
+#define LN_issuerSignTool               "Signing Tool of Issuer"
+#define NID_issuerSignTool              1008
+#define OBJ_issuerSignTool              OBJ_member_body,643L,100L,112L
+
+#define SN_classSignTool                "classSignTool"
+#define LN_classSignTool                "Class of Signing Tool"
+#define NID_classSignTool               1227
+#define OBJ_classSignTool               OBJ_member_body,643L,100L,113L
+
+#define SN_classSignToolKC1             "classSignToolKC1"
+#define LN_classSignToolKC1             "Class of Signing Tool KC1"
+#define NID_classSignToolKC1            1228
+#define OBJ_classSignToolKC1            OBJ_member_body,643L,100L,113L,1L
+
+#define SN_classSignToolKC2             "classSignToolKC2"
+#define LN_classSignToolKC2             "Class of Signing Tool KC2"
+#define NID_classSignToolKC2            1229
+#define OBJ_classSignToolKC2            OBJ_member_body,643L,100L,113L,2L
+
+#define SN_classSignToolKC3             "classSignToolKC3"
+#define LN_classSignToolKC3             "Class of Signing Tool KC3"
+#define NID_classSignToolKC3            1230
+#define OBJ_classSignToolKC3            OBJ_member_body,643L,100L,113L,3L
+
+#define SN_classSignToolKB1             "classSignToolKB1"
+#define LN_classSignToolKB1             "Class of Signing Tool KB1"
+#define NID_classSignToolKB1            1231
+#define OBJ_classSignToolKB1            OBJ_member_body,643L,100L,113L,4L
+
+#define SN_classSignToolKB2             "classSignToolKB2"
+#define LN_classSignToolKB2             "Class of Signing Tool KB2"
+#define NID_classSignToolKB2            1232
+#define OBJ_classSignToolKB2            OBJ_member_body,643L,100L,113L,5L
+
+#define SN_classSignToolKA1             "classSignToolKA1"
+#define LN_classSignToolKA1             "Class of Signing Tool KA1"
+#define NID_classSignToolKA1            1233
+#define OBJ_classSignToolKA1            OBJ_member_body,643L,100L,113L,6L
+
+#define SN_kuznyechik_ecb               "kuznyechik-ecb"
+#define NID_kuznyechik_ecb              1012
+
+#define SN_kuznyechik_ctr               "kuznyechik-ctr"
+#define NID_kuznyechik_ctr              1013
+
+#define SN_kuznyechik_ofb               "kuznyechik-ofb"
+#define NID_kuznyechik_ofb              1014
+
+#define SN_kuznyechik_cbc               "kuznyechik-cbc"
+#define NID_kuznyechik_cbc              1015
+
+#define SN_kuznyechik_cfb               "kuznyechik-cfb"
+#define NID_kuznyechik_cfb              1016
+
+#define SN_kuznyechik_mac               "kuznyechik-mac"
+#define NID_kuznyechik_mac              1017
+
+#define SN_magma_ecb            "magma-ecb"
+#define NID_magma_ecb           1187
+
+#define SN_magma_ctr            "magma-ctr"
+#define NID_magma_ctr           1188
+
+#define SN_magma_ofb            "magma-ofb"
+#define NID_magma_ofb           1189
+
+#define SN_magma_cbc            "magma-cbc"
+#define NID_magma_cbc           1190
+
+#define SN_magma_cfb            "magma-cfb"
+#define NID_magma_cfb           1191
+
+#define SN_magma_mac            "magma-mac"
+#define NID_magma_mac           1192
+
+#define SN_camellia_128_cbc             "CAMELLIA-128-CBC"
+#define LN_camellia_128_cbc             "camellia-128-cbc"
+#define NID_camellia_128_cbc            751
+#define OBJ_camellia_128_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,2L
+
+#define SN_camellia_192_cbc             "CAMELLIA-192-CBC"
+#define LN_camellia_192_cbc             "camellia-192-cbc"
+#define NID_camellia_192_cbc            752
+#define OBJ_camellia_192_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,3L
+
+#define SN_camellia_256_cbc             "CAMELLIA-256-CBC"
+#define LN_camellia_256_cbc             "camellia-256-cbc"
+#define NID_camellia_256_cbc            753
+#define OBJ_camellia_256_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,4L
+
+#define SN_id_camellia128_wrap          "id-camellia128-wrap"
+#define NID_id_camellia128_wrap         907
+#define OBJ_id_camellia128_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,2L
+
+#define SN_id_camellia192_wrap          "id-camellia192-wrap"
+#define NID_id_camellia192_wrap         908
+#define OBJ_id_camellia192_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,3L
+
+#define SN_id_camellia256_wrap          "id-camellia256-wrap"
+#define NID_id_camellia256_wrap         909
+#define OBJ_id_camellia256_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,4L
+
+#define OBJ_ntt_ds              0L,3L,4401L,5L
+
+#define OBJ_camellia            OBJ_ntt_ds,3L,1L,9L
+
+#define SN_camellia_128_ecb             "CAMELLIA-128-ECB"
+#define LN_camellia_128_ecb             "camellia-128-ecb"
+#define NID_camellia_128_ecb            754
+#define OBJ_camellia_128_ecb            OBJ_camellia,1L
+
+#define SN_camellia_128_ofb128          "CAMELLIA-128-OFB"
+#define LN_camellia_128_ofb128          "camellia-128-ofb"
+#define NID_camellia_128_ofb128         766
+#define OBJ_camellia_128_ofb128         OBJ_camellia,3L
+
+#define SN_camellia_128_cfb128          "CAMELLIA-128-CFB"
+#define LN_camellia_128_cfb128          "camellia-128-cfb"
+#define NID_camellia_128_cfb128         757
+#define OBJ_camellia_128_cfb128         OBJ_camellia,4L
+
+#define SN_camellia_128_gcm             "CAMELLIA-128-GCM"
+#define LN_camellia_128_gcm             "camellia-128-gcm"
+#define NID_camellia_128_gcm            961
+#define OBJ_camellia_128_gcm            OBJ_camellia,6L
+
+#define SN_camellia_128_ccm             "CAMELLIA-128-CCM"
+#define LN_camellia_128_ccm             "camellia-128-ccm"
+#define NID_camellia_128_ccm            962
+#define OBJ_camellia_128_ccm            OBJ_camellia,7L
+
+#define SN_camellia_128_ctr             "CAMELLIA-128-CTR"
+#define LN_camellia_128_ctr             "camellia-128-ctr"
+#define NID_camellia_128_ctr            963
+#define OBJ_camellia_128_ctr            OBJ_camellia,9L
+
+#define SN_camellia_128_cmac            "CAMELLIA-128-CMAC"
+#define LN_camellia_128_cmac            "camellia-128-cmac"
+#define NID_camellia_128_cmac           964
+#define OBJ_camellia_128_cmac           OBJ_camellia,10L
+
+#define SN_camellia_192_ecb             "CAMELLIA-192-ECB"
+#define LN_camellia_192_ecb             "camellia-192-ecb"
+#define NID_camellia_192_ecb            755
+#define OBJ_camellia_192_ecb            OBJ_camellia,21L
+
+#define SN_camellia_192_ofb128          "CAMELLIA-192-OFB"
+#define LN_camellia_192_ofb128          "camellia-192-ofb"
+#define NID_camellia_192_ofb128         767
+#define OBJ_camellia_192_ofb128         OBJ_camellia,23L
+
+#define SN_camellia_192_cfb128          "CAMELLIA-192-CFB"
+#define LN_camellia_192_cfb128          "camellia-192-cfb"
+#define NID_camellia_192_cfb128         758
+#define OBJ_camellia_192_cfb128         OBJ_camellia,24L
+
+#define SN_camellia_192_gcm             "CAMELLIA-192-GCM"
+#define LN_camellia_192_gcm             "camellia-192-gcm"
+#define NID_camellia_192_gcm            965
+#define OBJ_camellia_192_gcm            OBJ_camellia,26L
+
+#define SN_camellia_192_ccm             "CAMELLIA-192-CCM"
+#define LN_camellia_192_ccm             "camellia-192-ccm"
+#define NID_camellia_192_ccm            966
+#define OBJ_camellia_192_ccm            OBJ_camellia,27L
+
+#define SN_camellia_192_ctr             "CAMELLIA-192-CTR"
+#define LN_camellia_192_ctr             "camellia-192-ctr"
+#define NID_camellia_192_ctr            967
+#define OBJ_camellia_192_ctr            OBJ_camellia,29L
+
+#define SN_camellia_192_cmac            "CAMELLIA-192-CMAC"
+#define LN_camellia_192_cmac            "camellia-192-cmac"
+#define NID_camellia_192_cmac           968
+#define OBJ_camellia_192_cmac           OBJ_camellia,30L
+
+#define SN_camellia_256_ecb             "CAMELLIA-256-ECB"
+#define LN_camellia_256_ecb             "camellia-256-ecb"
+#define NID_camellia_256_ecb            756
+#define OBJ_camellia_256_ecb            OBJ_camellia,41L
+
+#define SN_camellia_256_ofb128          "CAMELLIA-256-OFB"
+#define LN_camellia_256_ofb128          "camellia-256-ofb"
+#define NID_camellia_256_ofb128         768
+#define OBJ_camellia_256_ofb128         OBJ_camellia,43L
+
+#define SN_camellia_256_cfb128          "CAMELLIA-256-CFB"
+#define LN_camellia_256_cfb128          "camellia-256-cfb"
+#define NID_camellia_256_cfb128         759
+#define OBJ_camellia_256_cfb128         OBJ_camellia,44L
+
+#define SN_camellia_256_gcm             "CAMELLIA-256-GCM"
+#define LN_camellia_256_gcm             "camellia-256-gcm"
+#define NID_camellia_256_gcm            969
+#define OBJ_camellia_256_gcm            OBJ_camellia,46L
+
+#define SN_camellia_256_ccm             "CAMELLIA-256-CCM"
+#define LN_camellia_256_ccm             "camellia-256-ccm"
+#define NID_camellia_256_ccm            970
+#define OBJ_camellia_256_ccm            OBJ_camellia,47L
+
+#define SN_camellia_256_ctr             "CAMELLIA-256-CTR"
+#define LN_camellia_256_ctr             "camellia-256-ctr"
+#define NID_camellia_256_ctr            971
+#define OBJ_camellia_256_ctr            OBJ_camellia,49L
+
+#define SN_camellia_256_cmac            "CAMELLIA-256-CMAC"
+#define LN_camellia_256_cmac            "camellia-256-cmac"
+#define NID_camellia_256_cmac           972
+#define OBJ_camellia_256_cmac           OBJ_camellia,50L
+
+#define SN_camellia_128_cfb1            "CAMELLIA-128-CFB1"
+#define LN_camellia_128_cfb1            "camellia-128-cfb1"
+#define NID_camellia_128_cfb1           760
+
+#define SN_camellia_192_cfb1            "CAMELLIA-192-CFB1"
+#define LN_camellia_192_cfb1            "camellia-192-cfb1"
+#define NID_camellia_192_cfb1           761
+
+#define SN_camellia_256_cfb1            "CAMELLIA-256-CFB1"
+#define LN_camellia_256_cfb1            "camellia-256-cfb1"
+#define NID_camellia_256_cfb1           762
+
+#define SN_camellia_128_cfb8            "CAMELLIA-128-CFB8"
+#define LN_camellia_128_cfb8            "camellia-128-cfb8"
+#define NID_camellia_128_cfb8           763
+
+#define SN_camellia_192_cfb8            "CAMELLIA-192-CFB8"
+#define LN_camellia_192_cfb8            "camellia-192-cfb8"
+#define NID_camellia_192_cfb8           764
+
+#define SN_camellia_256_cfb8            "CAMELLIA-256-CFB8"
+#define LN_camellia_256_cfb8            "camellia-256-cfb8"
+#define NID_camellia_256_cfb8           765
+
+#define OBJ_aria                1L,2L,410L,200046L,1L,1L
+
+#define SN_aria_128_ecb         "ARIA-128-ECB"
+#define LN_aria_128_ecb         "aria-128-ecb"
+#define NID_aria_128_ecb                1065
+#define OBJ_aria_128_ecb                OBJ_aria,1L
+
+#define SN_aria_128_cbc         "ARIA-128-CBC"
+#define LN_aria_128_cbc         "aria-128-cbc"
+#define NID_aria_128_cbc                1066
+#define OBJ_aria_128_cbc                OBJ_aria,2L
+
+#define SN_aria_128_cfb128              "ARIA-128-CFB"
+#define LN_aria_128_cfb128              "aria-128-cfb"
+#define NID_aria_128_cfb128             1067
+#define OBJ_aria_128_cfb128             OBJ_aria,3L
+
+#define SN_aria_128_ofb128              "ARIA-128-OFB"
+#define LN_aria_128_ofb128              "aria-128-ofb"
+#define NID_aria_128_ofb128             1068
+#define OBJ_aria_128_ofb128             OBJ_aria,4L
+
+#define SN_aria_128_ctr         "ARIA-128-CTR"
+#define LN_aria_128_ctr         "aria-128-ctr"
+#define NID_aria_128_ctr                1069
+#define OBJ_aria_128_ctr                OBJ_aria,5L
+
+#define SN_aria_192_ecb         "ARIA-192-ECB"
+#define LN_aria_192_ecb         "aria-192-ecb"
+#define NID_aria_192_ecb                1070
+#define OBJ_aria_192_ecb                OBJ_aria,6L
+
+#define SN_aria_192_cbc         "ARIA-192-CBC"
+#define LN_aria_192_cbc         "aria-192-cbc"
+#define NID_aria_192_cbc                1071
+#define OBJ_aria_192_cbc                OBJ_aria,7L
+
+#define SN_aria_192_cfb128              "ARIA-192-CFB"
+#define LN_aria_192_cfb128              "aria-192-cfb"
+#define NID_aria_192_cfb128             1072
+#define OBJ_aria_192_cfb128             OBJ_aria,8L
+
+#define SN_aria_192_ofb128              "ARIA-192-OFB"
+#define LN_aria_192_ofb128              "aria-192-ofb"
+#define NID_aria_192_ofb128             1073
+#define OBJ_aria_192_ofb128             OBJ_aria,9L
+
+#define SN_aria_192_ctr         "ARIA-192-CTR"
+#define LN_aria_192_ctr         "aria-192-ctr"
+#define NID_aria_192_ctr                1074
+#define OBJ_aria_192_ctr                OBJ_aria,10L
+
+#define SN_aria_256_ecb         "ARIA-256-ECB"
+#define LN_aria_256_ecb         "aria-256-ecb"
+#define NID_aria_256_ecb                1075
+#define OBJ_aria_256_ecb                OBJ_aria,11L
+
+#define SN_aria_256_cbc         "ARIA-256-CBC"
+#define LN_aria_256_cbc         "aria-256-cbc"
+#define NID_aria_256_cbc                1076
+#define OBJ_aria_256_cbc                OBJ_aria,12L
+
+#define SN_aria_256_cfb128              "ARIA-256-CFB"
+#define LN_aria_256_cfb128              "aria-256-cfb"
+#define NID_aria_256_cfb128             1077
+#define OBJ_aria_256_cfb128             OBJ_aria,13L
+
+#define SN_aria_256_ofb128              "ARIA-256-OFB"
+#define LN_aria_256_ofb128              "aria-256-ofb"
+#define NID_aria_256_ofb128             1078
+#define OBJ_aria_256_ofb128             OBJ_aria,14L
+
+#define SN_aria_256_ctr         "ARIA-256-CTR"
+#define LN_aria_256_ctr         "aria-256-ctr"
+#define NID_aria_256_ctr                1079
+#define OBJ_aria_256_ctr                OBJ_aria,15L
+
+#define SN_aria_128_cfb1                "ARIA-128-CFB1"
+#define LN_aria_128_cfb1                "aria-128-cfb1"
+#define NID_aria_128_cfb1               1080
+
+#define SN_aria_192_cfb1                "ARIA-192-CFB1"
+#define LN_aria_192_cfb1                "aria-192-cfb1"
+#define NID_aria_192_cfb1               1081
+
+#define SN_aria_256_cfb1                "ARIA-256-CFB1"
+#define LN_aria_256_cfb1                "aria-256-cfb1"
+#define NID_aria_256_cfb1               1082
+
+#define SN_aria_128_cfb8                "ARIA-128-CFB8"
+#define LN_aria_128_cfb8                "aria-128-cfb8"
+#define NID_aria_128_cfb8               1083
+
+#define SN_aria_192_cfb8                "ARIA-192-CFB8"
+#define LN_aria_192_cfb8                "aria-192-cfb8"
+#define NID_aria_192_cfb8               1084
+
+#define SN_aria_256_cfb8                "ARIA-256-CFB8"
+#define LN_aria_256_cfb8                "aria-256-cfb8"
+#define NID_aria_256_cfb8               1085
+
+#define SN_aria_128_ccm         "ARIA-128-CCM"
+#define LN_aria_128_ccm         "aria-128-ccm"
+#define NID_aria_128_ccm                1120
+#define OBJ_aria_128_ccm                OBJ_aria,37L
+
+#define SN_aria_192_ccm         "ARIA-192-CCM"
+#define LN_aria_192_ccm         "aria-192-ccm"
+#define NID_aria_192_ccm                1121
+#define OBJ_aria_192_ccm                OBJ_aria,38L
+
+#define SN_aria_256_ccm         "ARIA-256-CCM"
+#define LN_aria_256_ccm         "aria-256-ccm"
+#define NID_aria_256_ccm                1122
+#define OBJ_aria_256_ccm                OBJ_aria,39L
+
+#define SN_aria_128_gcm         "ARIA-128-GCM"
+#define LN_aria_128_gcm         "aria-128-gcm"
+#define NID_aria_128_gcm                1123
+#define OBJ_aria_128_gcm                OBJ_aria,34L
+
+#define SN_aria_192_gcm         "ARIA-192-GCM"
+#define LN_aria_192_gcm         "aria-192-gcm"
+#define NID_aria_192_gcm                1124
+#define OBJ_aria_192_gcm                OBJ_aria,35L
+
+#define SN_aria_256_gcm         "ARIA-256-GCM"
+#define LN_aria_256_gcm         "aria-256-gcm"
+#define NID_aria_256_gcm                1125
+#define OBJ_aria_256_gcm                OBJ_aria,36L
+
+#define SN_kisa         "KISA"
+#define LN_kisa         "kisa"
+#define NID_kisa                773
+#define OBJ_kisa                OBJ_member_body,410L,200004L
+
+#define SN_seed_ecb             "SEED-ECB"
+#define LN_seed_ecb             "seed-ecb"
+#define NID_seed_ecb            776
+#define OBJ_seed_ecb            OBJ_kisa,1L,3L
+
+#define SN_seed_cbc             "SEED-CBC"
+#define LN_seed_cbc             "seed-cbc"
+#define NID_seed_cbc            777
+#define OBJ_seed_cbc            OBJ_kisa,1L,4L
+
+#define SN_seed_cfb128          "SEED-CFB"
+#define LN_seed_cfb128          "seed-cfb"
+#define NID_seed_cfb128         779
+#define OBJ_seed_cfb128         OBJ_kisa,1L,5L
+
+#define SN_seed_ofb128          "SEED-OFB"
+#define LN_seed_ofb128          "seed-ofb"
+#define NID_seed_ofb128         778
+#define OBJ_seed_ofb128         OBJ_kisa,1L,6L
+
+#define SN_sm4_ecb              "SM4-ECB"
+#define LN_sm4_ecb              "sm4-ecb"
+#define NID_sm4_ecb             1133
+#define OBJ_sm4_ecb             OBJ_sm_scheme,104L,1L
+
+#define SN_sm4_cbc              "SM4-CBC"
+#define LN_sm4_cbc              "sm4-cbc"
+#define NID_sm4_cbc             1134
+#define OBJ_sm4_cbc             OBJ_sm_scheme,104L,2L
+
+#define SN_sm4_ofb128           "SM4-OFB"
+#define LN_sm4_ofb128           "sm4-ofb"
+#define NID_sm4_ofb128          1135
+#define OBJ_sm4_ofb128          OBJ_sm_scheme,104L,3L
+
+#define SN_sm4_cfb128           "SM4-CFB"
+#define LN_sm4_cfb128           "sm4-cfb"
+#define NID_sm4_cfb128          1137
+#define OBJ_sm4_cfb128          OBJ_sm_scheme,104L,4L
+
+#define SN_sm4_cfb1             "SM4-CFB1"
+#define LN_sm4_cfb1             "sm4-cfb1"
+#define NID_sm4_cfb1            1136
+#define OBJ_sm4_cfb1            OBJ_sm_scheme,104L,5L
+
+#define SN_sm4_cfb8             "SM4-CFB8"
+#define LN_sm4_cfb8             "sm4-cfb8"
+#define NID_sm4_cfb8            1138
+#define OBJ_sm4_cfb8            OBJ_sm_scheme,104L,6L
+
+#define SN_sm4_ctr              "SM4-CTR"
+#define LN_sm4_ctr              "sm4-ctr"
+#define NID_sm4_ctr             1139
+#define OBJ_sm4_ctr             OBJ_sm_scheme,104L,7L
+
+#define SN_hmac         "HMAC"
+#define LN_hmac         "hmac"
+#define NID_hmac                855
+
+#define SN_cmac         "CMAC"
+#define LN_cmac         "cmac"
+#define NID_cmac                894
+
+#define SN_rc4_hmac_md5         "RC4-HMAC-MD5"
+#define LN_rc4_hmac_md5         "rc4-hmac-md5"
+#define NID_rc4_hmac_md5                915
+
+#define SN_aes_128_cbc_hmac_sha1                "AES-128-CBC-HMAC-SHA1"
+#define LN_aes_128_cbc_hmac_sha1                "aes-128-cbc-hmac-sha1"
+#define NID_aes_128_cbc_hmac_sha1               916
+
+#define SN_aes_192_cbc_hmac_sha1                "AES-192-CBC-HMAC-SHA1"
+#define LN_aes_192_cbc_hmac_sha1                "aes-192-cbc-hmac-sha1"
+#define NID_aes_192_cbc_hmac_sha1               917
+
+#define SN_aes_256_cbc_hmac_sha1                "AES-256-CBC-HMAC-SHA1"
+#define LN_aes_256_cbc_hmac_sha1                "aes-256-cbc-hmac-sha1"
+#define NID_aes_256_cbc_hmac_sha1               918
+
+#define SN_aes_128_cbc_hmac_sha256              "AES-128-CBC-HMAC-SHA256"
+#define LN_aes_128_cbc_hmac_sha256              "aes-128-cbc-hmac-sha256"
+#define NID_aes_128_cbc_hmac_sha256             948
+
+#define SN_aes_192_cbc_hmac_sha256              "AES-192-CBC-HMAC-SHA256"
+#define LN_aes_192_cbc_hmac_sha256              "aes-192-cbc-hmac-sha256"
+#define NID_aes_192_cbc_hmac_sha256             949
+
+#define SN_aes_256_cbc_hmac_sha256              "AES-256-CBC-HMAC-SHA256"
+#define LN_aes_256_cbc_hmac_sha256              "aes-256-cbc-hmac-sha256"
+#define NID_aes_256_cbc_hmac_sha256             950
+
+#define SN_chacha20_poly1305            "ChaCha20-Poly1305"
+#define LN_chacha20_poly1305            "chacha20-poly1305"
+#define NID_chacha20_poly1305           1018
+
+#define SN_chacha20             "ChaCha20"
+#define LN_chacha20             "chacha20"
+#define NID_chacha20            1019
+
+#define SN_dhpublicnumber               "dhpublicnumber"
+#define LN_dhpublicnumber               "X9.42 DH"
+#define NID_dhpublicnumber              920
+#define OBJ_dhpublicnumber              OBJ_ISO_US,10046L,2L,1L
+
+#define SN_brainpoolP160r1              "brainpoolP160r1"
+#define NID_brainpoolP160r1             921
+#define OBJ_brainpoolP160r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,1L
+
+#define SN_brainpoolP160t1              "brainpoolP160t1"
+#define NID_brainpoolP160t1             922
+#define OBJ_brainpoolP160t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,2L
+
+#define SN_brainpoolP192r1              "brainpoolP192r1"
+#define NID_brainpoolP192r1             923
+#define OBJ_brainpoolP192r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,3L
+
+#define SN_brainpoolP192t1              "brainpoolP192t1"
+#define NID_brainpoolP192t1             924
+#define OBJ_brainpoolP192t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,4L
+
+#define SN_brainpoolP224r1              "brainpoolP224r1"
+#define NID_brainpoolP224r1             925
+#define OBJ_brainpoolP224r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,5L
+
+#define SN_brainpoolP224t1              "brainpoolP224t1"
+#define NID_brainpoolP224t1             926
+#define OBJ_brainpoolP224t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,6L
+
+#define SN_brainpoolP256r1              "brainpoolP256r1"
+#define NID_brainpoolP256r1             927
+#define OBJ_brainpoolP256r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,7L
+
+#define SN_brainpoolP256t1              "brainpoolP256t1"
+#define NID_brainpoolP256t1             928
+#define OBJ_brainpoolP256t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,8L
+
+#define SN_brainpoolP320r1              "brainpoolP320r1"
+#define NID_brainpoolP320r1             929
+#define OBJ_brainpoolP320r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,9L
+
+#define SN_brainpoolP320t1              "brainpoolP320t1"
+#define NID_brainpoolP320t1             930
+#define OBJ_brainpoolP320t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,10L
+
+#define SN_brainpoolP384r1              "brainpoolP384r1"
+#define NID_brainpoolP384r1             931
+#define OBJ_brainpoolP384r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,11L
+
+#define SN_brainpoolP384t1              "brainpoolP384t1"
+#define NID_brainpoolP384t1             932
+#define OBJ_brainpoolP384t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,12L
+
+#define SN_brainpoolP512r1              "brainpoolP512r1"
+#define NID_brainpoolP512r1             933
+#define OBJ_brainpoolP512r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,13L
+
+#define SN_brainpoolP512t1              "brainpoolP512t1"
+#define NID_brainpoolP512t1             934
+#define OBJ_brainpoolP512t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,14L
+
+#define OBJ_x9_63_scheme                1L,3L,133L,16L,840L,63L,0L
+
+#define OBJ_secg_scheme         OBJ_certicom_arc,1L
+
+#define SN_dhSinglePass_stdDH_sha1kdf_scheme            "dhSinglePass-stdDH-sha1kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha1kdf_scheme           936
+#define OBJ_dhSinglePass_stdDH_sha1kdf_scheme           OBJ_x9_63_scheme,2L
+
+#define SN_dhSinglePass_stdDH_sha224kdf_scheme          "dhSinglePass-stdDH-sha224kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha224kdf_scheme         937
+#define OBJ_dhSinglePass_stdDH_sha224kdf_scheme         OBJ_secg_scheme,11L,0L
+
+#define SN_dhSinglePass_stdDH_sha256kdf_scheme          "dhSinglePass-stdDH-sha256kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha256kdf_scheme         938
+#define OBJ_dhSinglePass_stdDH_sha256kdf_scheme         OBJ_secg_scheme,11L,1L
+
+#define SN_dhSinglePass_stdDH_sha384kdf_scheme          "dhSinglePass-stdDH-sha384kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha384kdf_scheme         939
+#define OBJ_dhSinglePass_stdDH_sha384kdf_scheme         OBJ_secg_scheme,11L,2L
+
+#define SN_dhSinglePass_stdDH_sha512kdf_scheme          "dhSinglePass-stdDH-sha512kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha512kdf_scheme         940
+#define OBJ_dhSinglePass_stdDH_sha512kdf_scheme         OBJ_secg_scheme,11L,3L
+
+#define SN_dhSinglePass_cofactorDH_sha1kdf_scheme               "dhSinglePass-cofactorDH-sha1kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha1kdf_scheme              941
+#define OBJ_dhSinglePass_cofactorDH_sha1kdf_scheme              OBJ_x9_63_scheme,3L
+
+#define SN_dhSinglePass_cofactorDH_sha224kdf_scheme             "dhSinglePass-cofactorDH-sha224kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha224kdf_scheme            942
+#define OBJ_dhSinglePass_cofactorDH_sha224kdf_scheme            OBJ_secg_scheme,14L,0L
+
+#define SN_dhSinglePass_cofactorDH_sha256kdf_scheme             "dhSinglePass-cofactorDH-sha256kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha256kdf_scheme            943
+#define OBJ_dhSinglePass_cofactorDH_sha256kdf_scheme            OBJ_secg_scheme,14L,1L
+
+#define SN_dhSinglePass_cofactorDH_sha384kdf_scheme             "dhSinglePass-cofactorDH-sha384kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha384kdf_scheme            944
+#define OBJ_dhSinglePass_cofactorDH_sha384kdf_scheme            OBJ_secg_scheme,14L,2L
+
+#define SN_dhSinglePass_cofactorDH_sha512kdf_scheme             "dhSinglePass-cofactorDH-sha512kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha512kdf_scheme            945
+#define OBJ_dhSinglePass_cofactorDH_sha512kdf_scheme            OBJ_secg_scheme,14L,3L
+
+#define SN_dh_std_kdf           "dh-std-kdf"
+#define NID_dh_std_kdf          946
+
+#define SN_dh_cofactor_kdf              "dh-cofactor-kdf"
+#define NID_dh_cofactor_kdf             947
+
+#define SN_ct_precert_scts              "ct_precert_scts"
+#define LN_ct_precert_scts              "CT Precertificate SCTs"
+#define NID_ct_precert_scts             951
+#define OBJ_ct_precert_scts             1L,3L,6L,1L,4L,1L,11129L,2L,4L,2L
+
+#define SN_ct_precert_poison            "ct_precert_poison"
+#define LN_ct_precert_poison            "CT Precertificate Poison"
+#define NID_ct_precert_poison           952
+#define OBJ_ct_precert_poison           1L,3L,6L,1L,4L,1L,11129L,2L,4L,3L
+
+#define SN_ct_precert_signer            "ct_precert_signer"
+#define LN_ct_precert_signer            "CT Precertificate Signer"
+#define NID_ct_precert_signer           953
+#define OBJ_ct_precert_signer           1L,3L,6L,1L,4L,1L,11129L,2L,4L,4L
+
+#define SN_ct_cert_scts         "ct_cert_scts"
+#define LN_ct_cert_scts         "CT Certificate SCTs"
+#define NID_ct_cert_scts                954
+#define OBJ_ct_cert_scts                1L,3L,6L,1L,4L,1L,11129L,2L,4L,5L
+
+#define SN_jurisdictionLocalityName             "jurisdictionL"
+#define LN_jurisdictionLocalityName             "jurisdictionLocalityName"
+#define NID_jurisdictionLocalityName            955
+#define OBJ_jurisdictionLocalityName            1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,1L
+
+#define SN_jurisdictionStateOrProvinceName              "jurisdictionST"
+#define LN_jurisdictionStateOrProvinceName              "jurisdictionStateOrProvinceName"
+#define NID_jurisdictionStateOrProvinceName             956
+#define OBJ_jurisdictionStateOrProvinceName             1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,2L
+
+#define SN_jurisdictionCountryName              "jurisdictionC"
+#define LN_jurisdictionCountryName              "jurisdictionCountryName"
+#define NID_jurisdictionCountryName             957
+#define OBJ_jurisdictionCountryName             1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,3L
+
+#define SN_id_scrypt            "id-scrypt"
+#define LN_id_scrypt            "scrypt"
+#define NID_id_scrypt           973
+#define OBJ_id_scrypt           1L,3L,6L,1L,4L,1L,11591L,4L,11L
+
+#define SN_tls1_prf             "TLS1-PRF"
+#define LN_tls1_prf             "tls1-prf"
+#define NID_tls1_prf            1021
+
+#define SN_hkdf         "HKDF"
+#define LN_hkdf         "hkdf"
+#define NID_hkdf                1036
+
+#define SN_sshkdf               "SSHKDF"
+#define LN_sshkdf               "sshkdf"
+#define NID_sshkdf              1203
+
+#define SN_sskdf                "SSKDF"
+#define LN_sskdf                "sskdf"
+#define NID_sskdf               1205
+
+#define SN_x942kdf              "X942KDF"
+#define LN_x942kdf              "x942kdf"
+#define NID_x942kdf             1207
+
+#define SN_x963kdf              "X963KDF"
+#define LN_x963kdf              "x963kdf"
+#define NID_x963kdf             1206
+
+#define SN_id_pkinit            "id-pkinit"
+#define NID_id_pkinit           1031
+#define OBJ_id_pkinit           1L,3L,6L,1L,5L,2L,3L
+
+#define SN_pkInitClientAuth             "pkInitClientAuth"
+#define LN_pkInitClientAuth             "PKINIT Client Auth"
+#define NID_pkInitClientAuth            1032
+#define OBJ_pkInitClientAuth            OBJ_id_pkinit,4L
+
+#define SN_pkInitKDC            "pkInitKDC"
+#define LN_pkInitKDC            "Signing KDC Response"
+#define NID_pkInitKDC           1033
+#define OBJ_pkInitKDC           OBJ_id_pkinit,5L
+
+#define SN_X25519               "X25519"
+#define NID_X25519              1034
+#define OBJ_X25519              1L,3L,101L,110L
+
+#define SN_X448         "X448"
+#define NID_X448                1035
+#define OBJ_X448                1L,3L,101L,111L
+
+#define SN_ED25519              "ED25519"
+#define NID_ED25519             1087
+#define OBJ_ED25519             1L,3L,101L,112L
+
+#define SN_ED448                "ED448"
+#define NID_ED448               1088
+#define OBJ_ED448               1L,3L,101L,113L
+
+#define SN_kx_rsa               "KxRSA"
+#define LN_kx_rsa               "kx-rsa"
+#define NID_kx_rsa              1037
+
+#define SN_kx_ecdhe             "KxECDHE"
+#define LN_kx_ecdhe             "kx-ecdhe"
+#define NID_kx_ecdhe            1038
+
+#define SN_kx_dhe               "KxDHE"
+#define LN_kx_dhe               "kx-dhe"
+#define NID_kx_dhe              1039
+
+#define SN_kx_ecdhe_psk         "KxECDHE-PSK"
+#define LN_kx_ecdhe_psk         "kx-ecdhe-psk"
+#define NID_kx_ecdhe_psk                1040
+
+#define SN_kx_dhe_psk           "KxDHE-PSK"
+#define LN_kx_dhe_psk           "kx-dhe-psk"
+#define NID_kx_dhe_psk          1041
+
+#define SN_kx_rsa_psk           "KxRSA_PSK"
+#define LN_kx_rsa_psk           "kx-rsa-psk"
+#define NID_kx_rsa_psk          1042
+
+#define SN_kx_psk               "KxPSK"
+#define LN_kx_psk               "kx-psk"
+#define NID_kx_psk              1043
+
+#define SN_kx_srp               "KxSRP"
+#define LN_kx_srp               "kx-srp"
+#define NID_kx_srp              1044
+
+#define SN_kx_gost              "KxGOST"
+#define LN_kx_gost              "kx-gost"
+#define NID_kx_gost             1045
+
+#define SN_kx_gost18            "KxGOST18"
+#define LN_kx_gost18            "kx-gost18"
+#define NID_kx_gost18           1218
+
+#define SN_kx_any               "KxANY"
+#define LN_kx_any               "kx-any"
+#define NID_kx_any              1063
+
+#define SN_auth_rsa             "AuthRSA"
+#define LN_auth_rsa             "auth-rsa"
+#define NID_auth_rsa            1046
+
+#define SN_auth_ecdsa           "AuthECDSA"
+#define LN_auth_ecdsa           "auth-ecdsa"
+#define NID_auth_ecdsa          1047
+
+#define SN_auth_psk             "AuthPSK"
+#define LN_auth_psk             "auth-psk"
+#define NID_auth_psk            1048
+
+#define SN_auth_dss             "AuthDSS"
+#define LN_auth_dss             "auth-dss"
+#define NID_auth_dss            1049
+
+#define SN_auth_gost01          "AuthGOST01"
+#define LN_auth_gost01          "auth-gost01"
+#define NID_auth_gost01         1050
+
+#define SN_auth_gost12          "AuthGOST12"
+#define LN_auth_gost12          "auth-gost12"
+#define NID_auth_gost12         1051
+
+#define SN_auth_srp             "AuthSRP"
+#define LN_auth_srp             "auth-srp"
+#define NID_auth_srp            1052
+
+#define SN_auth_null            "AuthNULL"
+#define LN_auth_null            "auth-null"
+#define NID_auth_null           1053
+
+#define SN_auth_any             "AuthANY"
+#define LN_auth_any             "auth-any"
+#define NID_auth_any            1064
+
+#define SN_poly1305             "Poly1305"
+#define LN_poly1305             "poly1305"
+#define NID_poly1305            1061
+
+#define SN_siphash              "SipHash"
+#define LN_siphash              "siphash"
+#define NID_siphash             1062
+
+#define SN_ffdhe2048            "ffdhe2048"
+#define NID_ffdhe2048           1126
+
+#define SN_ffdhe3072            "ffdhe3072"
+#define NID_ffdhe3072           1127
+
+#define SN_ffdhe4096            "ffdhe4096"
+#define NID_ffdhe4096           1128
+
+#define SN_ffdhe6144            "ffdhe6144"
+#define NID_ffdhe6144           1129
+
+#define SN_ffdhe8192            "ffdhe8192"
+#define NID_ffdhe8192           1130
+
+#define SN_modp_1536            "modp_1536"
+#define NID_modp_1536           1212
+
+#define SN_modp_2048            "modp_2048"
+#define NID_modp_2048           1213
+
+#define SN_modp_3072            "modp_3072"
+#define NID_modp_3072           1214
+
+#define SN_modp_4096            "modp_4096"
+#define NID_modp_4096           1215
+
+#define SN_modp_6144            "modp_6144"
+#define NID_modp_6144           1216
+
+#define SN_modp_8192            "modp_8192"
+#define NID_modp_8192           1217
+
+#define SN_ISO_UA               "ISO-UA"
+#define NID_ISO_UA              1150
+#define OBJ_ISO_UA              OBJ_member_body,804L
+
+#define SN_ua_pki               "ua-pki"
+#define NID_ua_pki              1151
+#define OBJ_ua_pki              OBJ_ISO_UA,2L,1L,1L,1L
+
+#define SN_dstu28147            "dstu28147"
+#define LN_dstu28147            "DSTU Gost 28147-2009"
+#define NID_dstu28147           1152
+#define OBJ_dstu28147           OBJ_ua_pki,1L,1L,1L
+
+#define SN_dstu28147_ofb                "dstu28147-ofb"
+#define LN_dstu28147_ofb                "DSTU Gost 28147-2009 OFB mode"
+#define NID_dstu28147_ofb               1153
+#define OBJ_dstu28147_ofb               OBJ_dstu28147,2L
+
+#define SN_dstu28147_cfb                "dstu28147-cfb"
+#define LN_dstu28147_cfb                "DSTU Gost 28147-2009 CFB mode"
+#define NID_dstu28147_cfb               1154
+#define OBJ_dstu28147_cfb               OBJ_dstu28147,3L
+
+#define SN_dstu28147_wrap               "dstu28147-wrap"
+#define LN_dstu28147_wrap               "DSTU Gost 28147-2009 key wrap"
+#define NID_dstu28147_wrap              1155
+#define OBJ_dstu28147_wrap              OBJ_dstu28147,5L
+
+#define SN_hmacWithDstu34311            "hmacWithDstu34311"
+#define LN_hmacWithDstu34311            "HMAC DSTU Gost 34311-95"
+#define NID_hmacWithDstu34311           1156
+#define OBJ_hmacWithDstu34311           OBJ_ua_pki,1L,1L,2L
+
+#define SN_dstu34311            "dstu34311"
+#define LN_dstu34311            "DSTU Gost 34311-95"
+#define NID_dstu34311           1157
+#define OBJ_dstu34311           OBJ_ua_pki,1L,2L,1L
+
+#define SN_dstu4145le           "dstu4145le"
+#define LN_dstu4145le           "DSTU 4145-2002 little endian"
+#define NID_dstu4145le          1158
+#define OBJ_dstu4145le          OBJ_ua_pki,1L,3L,1L,1L
+
+#define SN_dstu4145be           "dstu4145be"
+#define LN_dstu4145be           "DSTU 4145-2002 big endian"
+#define NID_dstu4145be          1159
+#define OBJ_dstu4145be          OBJ_dstu4145le,1L,1L
+
+#define SN_uacurve0             "uacurve0"
+#define LN_uacurve0             "DSTU curve 0"
+#define NID_uacurve0            1160
+#define OBJ_uacurve0            OBJ_dstu4145le,2L,0L
+
+#define SN_uacurve1             "uacurve1"
+#define LN_uacurve1             "DSTU curve 1"
+#define NID_uacurve1            1161
+#define OBJ_uacurve1            OBJ_dstu4145le,2L,1L
+
+#define SN_uacurve2             "uacurve2"
+#define LN_uacurve2             "DSTU curve 2"
+#define NID_uacurve2            1162
+#define OBJ_uacurve2            OBJ_dstu4145le,2L,2L
+
+#define SN_uacurve3             "uacurve3"
+#define LN_uacurve3             "DSTU curve 3"
+#define NID_uacurve3            1163
+#define OBJ_uacurve3            OBJ_dstu4145le,2L,3L
+
+#define SN_uacurve4             "uacurve4"
+#define LN_uacurve4             "DSTU curve 4"
+#define NID_uacurve4            1164
+#define OBJ_uacurve4            OBJ_dstu4145le,2L,4L
+
+#define SN_uacurve5             "uacurve5"
+#define LN_uacurve5             "DSTU curve 5"
+#define NID_uacurve5            1165
+#define OBJ_uacurve5            OBJ_dstu4145le,2L,5L
+
+#define SN_uacurve6             "uacurve6"
+#define LN_uacurve6             "DSTU curve 6"
+#define NID_uacurve6            1166
+#define OBJ_uacurve6            OBJ_dstu4145le,2L,6L
+
+#define SN_uacurve7             "uacurve7"
+#define LN_uacurve7             "DSTU curve 7"
+#define NID_uacurve7            1167
+#define OBJ_uacurve7            OBJ_dstu4145le,2L,7L
+
+#define SN_uacurve8             "uacurve8"
+#define LN_uacurve8             "DSTU curve 8"
+#define NID_uacurve8            1168
+#define OBJ_uacurve8            OBJ_dstu4145le,2L,8L
+
+#define SN_uacurve9             "uacurve9"
+#define LN_uacurve9             "DSTU curve 9"
+#define NID_uacurve9            1169
+#define OBJ_uacurve9            OBJ_dstu4145le,2L,9L
+
+#define SN_aes_128_siv          "AES-128-SIV"
+#define LN_aes_128_siv          "aes-128-siv"
+#define NID_aes_128_siv         1198
+
+#define SN_aes_192_siv          "AES-192-SIV"
+#define LN_aes_192_siv          "aes-192-siv"
+#define NID_aes_192_siv         1199
+
+#define SN_aes_256_siv          "AES-256-SIV"
+#define LN_aes_256_siv          "aes-256-siv"
+#define NID_aes_256_siv         1200
+
+#endif /* OPENSSL_OBJ_MAC_H */
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+
+#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                 SN_magma_ctr_acpkm
+#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                NID_magma_ctr_acpkm
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                OBJ_magma_ctr_acpkm
+
+#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac            SN_magma_ctr_acpkm_omac
+#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac           NID_magma_ctr_acpkm_omac
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac           OBJ_magma_ctr_acpkm_omac
+
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm            SN_kuznyechik_ctr_acpkm
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm           NID_kuznyechik_ctr_acpkm
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm           OBJ_kuznyechik_ctr_acpkm
+
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac               SN_kuznyechik_ctr_acpkm_omac
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac              NID_kuznyechik_ctr_acpkm_omac
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac              OBJ_kuznyechik_ctr_acpkm_omac
+
+#define SN_id_tc26_wrap_gostr3412_2015_magma_kexp15             SN_magma_kexp15
+#define NID_id_tc26_wrap_gostr3412_2015_magma_kexp15            NID_magma_kexp15
+#define OBJ_id_tc26_wrap_gostr3412_2015_magma_kexp15            OBJ_magma_kexp15
+
+#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15                SN_kuznyechik_kexp15
+#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15               NID_kuznyechik_kexp15
+#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15               OBJ_kuznyechik_kexp15
+
+#define SN_grasshopper_ecb              SN_kuznyechik_ecb
+#define NID_grasshopper_ecb             NID_kuznyechik_ecb
+
+#define SN_grasshopper_ctr              SN_kuznyechik_ctr
+#define NID_grasshopper_ctr             NID_kuznyechik_ctr
+
+#define SN_grasshopper_ofb              SN_kuznyechik_ofb
+#define NID_grasshopper_ofb             NID_kuznyechik_ofb
+
+#define SN_grasshopper_cbc              SN_kuznyechik_cbc
+#define NID_grasshopper_cbc             NID_kuznyechik_cbc
+
+#define SN_grasshopper_cfb              SN_kuznyechik_cfb
+#define NID_grasshopper_cfb             NID_kuznyechik_cfb
+
+#define SN_grasshopper_mac              SN_kuznyechik_mac
+#define NID_grasshopper_mac             NID_kuznyechik_mac
+
+#endif  /* OPENSSL_NO_DEPRECATED_3_0 */
diff --git a/CAPI/cpp/grpc/include/openssl/objects.h b/CAPI/cpp/grpc/include/openssl/objects.h
new file mode 100644
index 0000000..9ea91c2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/objects.h
@@ -0,0 +1,183 @@
+/*
+ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OBJECTS_H
+# define OPENSSL_OBJECTS_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OBJECTS_H
+# endif
+
+# include <openssl/obj_mac.h>
+# include <openssl/bio.h>
+# include <openssl/asn1.h>
+# include <openssl/objectserr.h>
+
+# define OBJ_NAME_TYPE_UNDEF             0x00
+# define OBJ_NAME_TYPE_MD_METH           0x01
+# define OBJ_NAME_TYPE_CIPHER_METH       0x02
+# define OBJ_NAME_TYPE_PKEY_METH         0x03
+# define OBJ_NAME_TYPE_COMP_METH         0x04
+# define OBJ_NAME_TYPE_MAC_METH          0x05
+# define OBJ_NAME_TYPE_KDF_METH          0x06
+# define OBJ_NAME_TYPE_NUM               0x07
+
+# define OBJ_NAME_ALIAS                  0x8000
+
+# define OBJ_BSEARCH_VALUE_ON_NOMATCH            0x01
+# define OBJ_BSEARCH_FIRST_VALUE_ON_MATCH        0x02
+
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct obj_name_st {
+    int type;
+    int alias;
+    const char *name;
+    const char *data;
+} OBJ_NAME;
+
+# define         OBJ_create_and_add_object(a,b,c) OBJ_create(a,b,c)
+
+int OBJ_NAME_init(void);
+int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
+                       int (*cmp_func) (const char *, const char *),
+                       void (*free_func) (const char *, int, const char *));
+const char *OBJ_NAME_get(const char *name, int type);
+int OBJ_NAME_add(const char *name, int type, const char *data);
+int OBJ_NAME_remove(const char *name, int type);
+void OBJ_NAME_cleanup(int type); /* -1 for everything */
+void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg),
+                     void *arg);
+void OBJ_NAME_do_all_sorted(int type,
+                            void (*fn) (const OBJ_NAME *, void *arg),
+                            void *arg);
+
+DECLARE_ASN1_DUP_FUNCTION_name(ASN1_OBJECT, OBJ)
+ASN1_OBJECT *OBJ_nid2obj(int n);
+const char *OBJ_nid2ln(int n);
+const char *OBJ_nid2sn(int n);
+int OBJ_obj2nid(const ASN1_OBJECT *o);
+ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name);
+int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name);
+int OBJ_txt2nid(const char *s);
+int OBJ_ln2nid(const char *s);
+int OBJ_sn2nid(const char *s);
+int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b);
+const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
+                         int (*cmp) (const void *, const void *));
+const void *OBJ_bsearch_ex_(const void *key, const void *base, int num,
+                            int size,
+                            int (*cmp) (const void *, const void *),
+                            int flags);
+
+# define _DECLARE_OBJ_BSEARCH_CMP_FN(scope, type1, type2, nm)    \
+  static int nm##_cmp_BSEARCH_CMP_FN(const void *, const void *); \
+  static int nm##_cmp(type1 const *, type2 const *); \
+  scope type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num)
+
+# define DECLARE_OBJ_BSEARCH_CMP_FN(type1, type2, cmp)   \
+  _DECLARE_OBJ_BSEARCH_CMP_FN(static, type1, type2, cmp)
+# define DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm)     \
+  type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num)
+
+/*-
+ * Unsolved problem: if a type is actually a pointer type, like
+ * nid_triple is, then its impossible to get a const where you need
+ * it. Consider:
+ *
+ * typedef int nid_triple[3];
+ * const void *a_;
+ * const nid_triple const *a = a_;
+ *
+ * The assignment discards a const because what you really want is:
+ *
+ * const int const * const *a = a_;
+ *
+ * But if you do that, you lose the fact that a is an array of 3 ints,
+ * which breaks comparison functions.
+ *
+ * Thus we end up having to cast, sadly, or unpack the
+ * declarations. Or, as I finally did in this case, declare nid_triple
+ * to be a struct, which it should have been in the first place.
+ *
+ * Ben, August 2008.
+ *
+ * Also, strictly speaking not all types need be const, but handling
+ * the non-constness means a lot of complication, and in practice
+ * comparison routines do always not touch their arguments.
+ */
+
+# define IMPLEMENT_OBJ_BSEARCH_CMP_FN(type1, type2, nm)  \
+  static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)    \
+      { \
+      type1 const *a = a_; \
+      type2 const *b = b_; \
+      return nm##_cmp(a,b); \
+      } \
+  static type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \
+      { \
+      return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \
+                                        nm##_cmp_BSEARCH_CMP_FN); \
+      } \
+      extern void dummy_prototype(void)
+
+# define IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm)   \
+  static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)    \
+      { \
+      type1 const *a = a_; \
+      type2 const *b = b_; \
+      return nm##_cmp(a,b); \
+      } \
+  type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \
+      { \
+      return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \
+                                        nm##_cmp_BSEARCH_CMP_FN); \
+      } \
+      extern void dummy_prototype(void)
+
+# define OBJ_bsearch(type1,key,type2,base,num,cmp)                              \
+  ((type2 *)OBJ_bsearch_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \
+                         num,sizeof(type2),                             \
+                         ((void)CHECKED_PTR_OF(type1,cmp##_type_1),     \
+                          (void)CHECKED_PTR_OF(type2,cmp##_type_2),     \
+                          cmp##_BSEARCH_CMP_FN)))
+
+# define OBJ_bsearch_ex(type1,key,type2,base,num,cmp,flags)                      \
+  ((type2 *)OBJ_bsearch_ex_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \
+                         num,sizeof(type2),                             \
+                         ((void)CHECKED_PTR_OF(type1,cmp##_type_1),     \
+                          (void)type_2=CHECKED_PTR_OF(type2,cmp##_type_2), \
+                          cmp##_BSEARCH_CMP_FN)),flags)
+
+int OBJ_new_nid(int num);
+int OBJ_add_object(const ASN1_OBJECT *obj);
+int OBJ_create(const char *oid, const char *sn, const char *ln);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define OBJ_cleanup() while(0) continue
+#endif
+int OBJ_create_objects(BIO *in);
+
+size_t OBJ_length(const ASN1_OBJECT *obj);
+const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj);
+
+int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid);
+int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid);
+int OBJ_add_sigid(int signid, int dig_id, int pkey_id);
+void OBJ_sigid_free(void);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/objectserr.h b/CAPI/cpp/grpc/include/openssl/objectserr.h
new file mode 100644
index 0000000..585217f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/objectserr.h
@@ -0,0 +1,28 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OBJECTSERR_H
+# define OPENSSL_OBJECTSERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * OBJ reason codes.
+ */
+# define OBJ_R_OID_EXISTS                                 102
+# define OBJ_R_UNKNOWN_NID                                101
+# define OBJ_R_UNKNOWN_OBJECT_NAME                        103
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ocsp.h b/CAPI/cpp/grpc/include/openssl/ocsp.h
new file mode 100644
index 0000000..5688381
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ocsp.h
@@ -0,0 +1,483 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ocsp.h.in
+ *
+ * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_OCSP_H
+# define OPENSSL_OCSP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OCSP_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/http.h>
+# include <openssl/asn1.h>
+
+/*
+ * These definitions are outside the OPENSSL_NO_OCSP guard because although for
+ * historical reasons they have OCSP_* names, they can actually be used
+ * independently of OCSP. E.g. see RFC5280
+ */
+/*-
+ *   CRLReason ::= ENUMERATED {
+ *        unspecified             (0),
+ *        keyCompromise           (1),
+ *        cACompromise            (2),
+ *        affiliationChanged      (3),
+ *        superseded              (4),
+ *        cessationOfOperation    (5),
+ *        certificateHold         (6),
+ *        -- value 7 is not used
+ *        removeFromCRL           (8),
+ *        privilegeWithdrawn      (9),
+ *        aACompromise           (10) }
+ */
+# define OCSP_REVOKED_STATUS_NOSTATUS                -1
+# define OCSP_REVOKED_STATUS_UNSPECIFIED             0
+# define OCSP_REVOKED_STATUS_KEYCOMPROMISE           1
+# define OCSP_REVOKED_STATUS_CACOMPROMISE            2
+# define OCSP_REVOKED_STATUS_AFFILIATIONCHANGED      3
+# define OCSP_REVOKED_STATUS_SUPERSEDED              4
+# define OCSP_REVOKED_STATUS_CESSATIONOFOPERATION    5
+# define OCSP_REVOKED_STATUS_CERTIFICATEHOLD         6
+# define OCSP_REVOKED_STATUS_REMOVEFROMCRL           8
+# define OCSP_REVOKED_STATUS_PRIVILEGEWITHDRAWN      9
+# define OCSP_REVOKED_STATUS_AACOMPROMISE            10
+
+
+# ifndef OPENSSL_NO_OCSP
+
+#  include <openssl/x509.h>
+#  include <openssl/x509v3.h>
+#  include <openssl/safestack.h>
+#  include <openssl/ocsperr.h>
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+/* Various flags and values */
+
+#  define OCSP_DEFAULT_NONCE_LENGTH       16
+
+#  define OCSP_NOCERTS                    0x1
+#  define OCSP_NOINTERN                   0x2
+#  define OCSP_NOSIGS                     0x4
+#  define OCSP_NOCHAIN                    0x8
+#  define OCSP_NOVERIFY                   0x10
+#  define OCSP_NOEXPLICIT                 0x20
+#  define OCSP_NOCASIGN                   0x40
+#  define OCSP_NODELEGATED                0x80
+#  define OCSP_NOCHECKS                   0x100
+#  define OCSP_TRUSTOTHER                 0x200
+#  define OCSP_RESPID_KEY                 0x400
+#  define OCSP_NOTIME                     0x800
+#  define OCSP_PARTIAL_CHAIN              0x1000
+
+typedef struct ocsp_cert_id_st OCSP_CERTID;
+typedef struct ocsp_one_request_st OCSP_ONEREQ;
+typedef struct ocsp_req_info_st OCSP_REQINFO;
+typedef struct ocsp_signature_st OCSP_SIGNATURE;
+typedef struct ocsp_request_st OCSP_REQUEST;
+
+SKM_DEFINE_STACK_OF_INTERNAL(OCSP_CERTID, OCSP_CERTID, OCSP_CERTID)
+#define sk_OCSP_CERTID_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_value(sk, idx) ((OCSP_CERTID *)OPENSSL_sk_value(ossl_check_const_OCSP_CERTID_sk_type(sk), (idx)))
+#define sk_OCSP_CERTID_new(cmp) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new(ossl_check_OCSP_CERTID_compfunc_type(cmp)))
+#define sk_OCSP_CERTID_new_null() ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new_null())
+#define sk_OCSP_CERTID_new_reserve(cmp, n) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_CERTID_compfunc_type(cmp), (n)))
+#define sk_OCSP_CERTID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_CERTID_sk_type(sk), (n))
+#define sk_OCSP_CERTID_free(sk) OPENSSL_sk_free(ossl_check_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_delete(sk, i) ((OCSP_CERTID *)OPENSSL_sk_delete(ossl_check_OCSP_CERTID_sk_type(sk), (i)))
+#define sk_OCSP_CERTID_delete_ptr(sk, ptr) ((OCSP_CERTID *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr)))
+#define sk_OCSP_CERTID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
+#define sk_OCSP_CERTID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
+#define sk_OCSP_CERTID_pop(sk) ((OCSP_CERTID *)OPENSSL_sk_pop(ossl_check_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_shift(sk) ((OCSP_CERTID *)OPENSSL_sk_shift(ossl_check_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_CERTID_sk_type(sk),ossl_check_OCSP_CERTID_freefunc_type(freefunc))
+#define sk_OCSP_CERTID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr), (idx))
+#define sk_OCSP_CERTID_set(sk, idx, ptr) ((OCSP_CERTID *)OPENSSL_sk_set(ossl_check_OCSP_CERTID_sk_type(sk), (idx), ossl_check_OCSP_CERTID_type(ptr)))
+#define sk_OCSP_CERTID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
+#define sk_OCSP_CERTID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
+#define sk_OCSP_CERTID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr), pnum)
+#define sk_OCSP_CERTID_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_CERTID_sk_type(sk))
+#define sk_OCSP_CERTID_dup(sk) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_dup(ossl_check_const_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_copyfunc_type(copyfunc), ossl_check_OCSP_CERTID_freefunc_type(freefunc)))
+#define sk_OCSP_CERTID_set_cmp_func(sk, cmp) ((sk_OCSP_CERTID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(OCSP_ONEREQ, OCSP_ONEREQ, OCSP_ONEREQ)
+#define sk_OCSP_ONEREQ_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_value(sk, idx) ((OCSP_ONEREQ *)OPENSSL_sk_value(ossl_check_const_OCSP_ONEREQ_sk_type(sk), (idx)))
+#define sk_OCSP_ONEREQ_new(cmp) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new(ossl_check_OCSP_ONEREQ_compfunc_type(cmp)))
+#define sk_OCSP_ONEREQ_new_null() ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new_null())
+#define sk_OCSP_ONEREQ_new_reserve(cmp, n) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_ONEREQ_compfunc_type(cmp), (n)))
+#define sk_OCSP_ONEREQ_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_ONEREQ_sk_type(sk), (n))
+#define sk_OCSP_ONEREQ_free(sk) OPENSSL_sk_free(ossl_check_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_delete(sk, i) ((OCSP_ONEREQ *)OPENSSL_sk_delete(ossl_check_OCSP_ONEREQ_sk_type(sk), (i)))
+#define sk_OCSP_ONEREQ_delete_ptr(sk, ptr) ((OCSP_ONEREQ *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr)))
+#define sk_OCSP_ONEREQ_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
+#define sk_OCSP_ONEREQ_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
+#define sk_OCSP_ONEREQ_pop(sk) ((OCSP_ONEREQ *)OPENSSL_sk_pop(ossl_check_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_shift(sk) ((OCSP_ONEREQ *)OPENSSL_sk_shift(ossl_check_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_ONEREQ_sk_type(sk),ossl_check_OCSP_ONEREQ_freefunc_type(freefunc))
+#define sk_OCSP_ONEREQ_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr), (idx))
+#define sk_OCSP_ONEREQ_set(sk, idx, ptr) ((OCSP_ONEREQ *)OPENSSL_sk_set(ossl_check_OCSP_ONEREQ_sk_type(sk), (idx), ossl_check_OCSP_ONEREQ_type(ptr)))
+#define sk_OCSP_ONEREQ_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
+#define sk_OCSP_ONEREQ_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
+#define sk_OCSP_ONEREQ_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr), pnum)
+#define sk_OCSP_ONEREQ_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_ONEREQ_sk_type(sk))
+#define sk_OCSP_ONEREQ_dup(sk) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_dup(ossl_check_const_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_copyfunc_type(copyfunc), ossl_check_OCSP_ONEREQ_freefunc_type(freefunc)))
+#define sk_OCSP_ONEREQ_set_cmp_func(sk, cmp) ((sk_OCSP_ONEREQ_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_compfunc_type(cmp)))
+
+
+#  define OCSP_RESPONSE_STATUS_SUCCESSFUL           0
+#  define OCSP_RESPONSE_STATUS_MALFORMEDREQUEST     1
+#  define OCSP_RESPONSE_STATUS_INTERNALERROR        2
+#  define OCSP_RESPONSE_STATUS_TRYLATER             3
+#  define OCSP_RESPONSE_STATUS_SIGREQUIRED          5
+#  define OCSP_RESPONSE_STATUS_UNAUTHORIZED         6
+
+typedef struct ocsp_resp_bytes_st OCSP_RESPBYTES;
+
+#  define V_OCSP_RESPID_NAME 0
+#  define V_OCSP_RESPID_KEY  1
+
+SKM_DEFINE_STACK_OF_INTERNAL(OCSP_RESPID, OCSP_RESPID, OCSP_RESPID)
+#define sk_OCSP_RESPID_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_value(sk, idx) ((OCSP_RESPID *)OPENSSL_sk_value(ossl_check_const_OCSP_RESPID_sk_type(sk), (idx)))
+#define sk_OCSP_RESPID_new(cmp) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new(ossl_check_OCSP_RESPID_compfunc_type(cmp)))
+#define sk_OCSP_RESPID_new_null() ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new_null())
+#define sk_OCSP_RESPID_new_reserve(cmp, n) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_RESPID_compfunc_type(cmp), (n)))
+#define sk_OCSP_RESPID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_RESPID_sk_type(sk), (n))
+#define sk_OCSP_RESPID_free(sk) OPENSSL_sk_free(ossl_check_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_delete(sk, i) ((OCSP_RESPID *)OPENSSL_sk_delete(ossl_check_OCSP_RESPID_sk_type(sk), (i)))
+#define sk_OCSP_RESPID_delete_ptr(sk, ptr) ((OCSP_RESPID *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr)))
+#define sk_OCSP_RESPID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
+#define sk_OCSP_RESPID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
+#define sk_OCSP_RESPID_pop(sk) ((OCSP_RESPID *)OPENSSL_sk_pop(ossl_check_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_shift(sk) ((OCSP_RESPID *)OPENSSL_sk_shift(ossl_check_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_RESPID_sk_type(sk),ossl_check_OCSP_RESPID_freefunc_type(freefunc))
+#define sk_OCSP_RESPID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr), (idx))
+#define sk_OCSP_RESPID_set(sk, idx, ptr) ((OCSP_RESPID *)OPENSSL_sk_set(ossl_check_OCSP_RESPID_sk_type(sk), (idx), ossl_check_OCSP_RESPID_type(ptr)))
+#define sk_OCSP_RESPID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
+#define sk_OCSP_RESPID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
+#define sk_OCSP_RESPID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr), pnum)
+#define sk_OCSP_RESPID_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_RESPID_sk_type(sk))
+#define sk_OCSP_RESPID_dup(sk) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_dup(ossl_check_const_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_copyfunc_type(copyfunc), ossl_check_OCSP_RESPID_freefunc_type(freefunc)))
+#define sk_OCSP_RESPID_set_cmp_func(sk, cmp) ((sk_OCSP_RESPID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_compfunc_type(cmp)))
+
+
+typedef struct ocsp_revoked_info_st OCSP_REVOKEDINFO;
+
+#  define V_OCSP_CERTSTATUS_GOOD    0
+#  define V_OCSP_CERTSTATUS_REVOKED 1
+#  define V_OCSP_CERTSTATUS_UNKNOWN 2
+
+typedef struct ocsp_cert_status_st OCSP_CERTSTATUS;
+typedef struct ocsp_single_response_st OCSP_SINGLERESP;
+
+SKM_DEFINE_STACK_OF_INTERNAL(OCSP_SINGLERESP, OCSP_SINGLERESP, OCSP_SINGLERESP)
+#define sk_OCSP_SINGLERESP_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_value(sk, idx) ((OCSP_SINGLERESP *)OPENSSL_sk_value(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), (idx)))
+#define sk_OCSP_SINGLERESP_new(cmp) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)))
+#define sk_OCSP_SINGLERESP_new_null() ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new_null())
+#define sk_OCSP_SINGLERESP_new_reserve(cmp, n) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp), (n)))
+#define sk_OCSP_SINGLERESP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_SINGLERESP_sk_type(sk), (n))
+#define sk_OCSP_SINGLERESP_free(sk) OPENSSL_sk_free(ossl_check_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_delete(sk, i) ((OCSP_SINGLERESP *)OPENSSL_sk_delete(ossl_check_OCSP_SINGLERESP_sk_type(sk), (i)))
+#define sk_OCSP_SINGLERESP_delete_ptr(sk, ptr) ((OCSP_SINGLERESP *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr)))
+#define sk_OCSP_SINGLERESP_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
+#define sk_OCSP_SINGLERESP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
+#define sk_OCSP_SINGLERESP_pop(sk) ((OCSP_SINGLERESP *)OPENSSL_sk_pop(ossl_check_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_shift(sk) ((OCSP_SINGLERESP *)OPENSSL_sk_shift(ossl_check_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_SINGLERESP_sk_type(sk),ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc))
+#define sk_OCSP_SINGLERESP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr), (idx))
+#define sk_OCSP_SINGLERESP_set(sk, idx, ptr) ((OCSP_SINGLERESP *)OPENSSL_sk_set(ossl_check_OCSP_SINGLERESP_sk_type(sk), (idx), ossl_check_OCSP_SINGLERESP_type(ptr)))
+#define sk_OCSP_SINGLERESP_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
+#define sk_OCSP_SINGLERESP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
+#define sk_OCSP_SINGLERESP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr), pnum)
+#define sk_OCSP_SINGLERESP_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_SINGLERESP_sk_type(sk))
+#define sk_OCSP_SINGLERESP_dup(sk) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_dup(ossl_check_const_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_copyfunc_type(copyfunc), ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc)))
+#define sk_OCSP_SINGLERESP_set_cmp_func(sk, cmp) ((sk_OCSP_SINGLERESP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)))
+
+
+typedef struct ocsp_response_data_st OCSP_RESPDATA;
+
+typedef struct ocsp_basic_response_st OCSP_BASICRESP;
+
+typedef struct ocsp_crl_id_st OCSP_CRLID;
+typedef struct ocsp_service_locator_st OCSP_SERVICELOC;
+
+#  define PEM_STRING_OCSP_REQUEST "OCSP REQUEST"
+#  define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE"
+
+#  define d2i_OCSP_REQUEST_bio(bp,p) ASN1_d2i_bio_of(OCSP_REQUEST,OCSP_REQUEST_new,d2i_OCSP_REQUEST,bp,p)
+
+#  define d2i_OCSP_RESPONSE_bio(bp,p) ASN1_d2i_bio_of(OCSP_RESPONSE,OCSP_RESPONSE_new,d2i_OCSP_RESPONSE,bp,p)
+
+#  define PEM_read_bio_OCSP_REQUEST(bp,x,cb) (OCSP_REQUEST *)PEM_ASN1_read_bio( \
+     (char *(*)())d2i_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST, \
+     bp,(char **)(x),cb,NULL)
+
+#  define PEM_read_bio_OCSP_RESPONSE(bp,x,cb) (OCSP_RESPONSE *)PEM_ASN1_read_bio(\
+     (char *(*)())d2i_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE, \
+     bp,(char **)(x),cb,NULL)
+
+#  define PEM_write_bio_OCSP_REQUEST(bp,o) \
+    PEM_ASN1_write_bio((int (*)())i2d_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,\
+                        bp,(char *)(o), NULL,NULL,0,NULL,NULL)
+
+#  define PEM_write_bio_OCSP_RESPONSE(bp,o) \
+    PEM_ASN1_write_bio((int (*)())i2d_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,\
+                        bp,(char *)(o), NULL,NULL,0,NULL,NULL)
+
+#  define i2d_OCSP_RESPONSE_bio(bp,o) ASN1_i2d_bio_of(OCSP_RESPONSE,i2d_OCSP_RESPONSE,bp,o)
+
+#  define i2d_OCSP_REQUEST_bio(bp,o) ASN1_i2d_bio_of(OCSP_REQUEST,i2d_OCSP_REQUEST,bp,o)
+
+#  define ASN1_BIT_STRING_digest(data,type,md,len) \
+        ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING),type,data,md,len)
+
+#  define OCSP_CERTSTATUS_dup(cs)\
+                (OCSP_CERTSTATUS*)ASN1_dup((i2d_of_void *)i2d_OCSP_CERTSTATUS,\
+                (d2i_of_void *)d2i_OCSP_CERTSTATUS,(char *)(cs))
+
+DECLARE_ASN1_DUP_FUNCTION(OCSP_CERTID)
+
+OSSL_HTTP_REQ_CTX *OCSP_sendreq_new(BIO *io, const char *path,
+                                    const OCSP_REQUEST *req, int buf_size);
+OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, const char *path, OCSP_REQUEST *req);
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef OSSL_HTTP_REQ_CTX OCSP_REQ_CTX;
+#   define OCSP_REQ_CTX_new(io, buf_size) \
+        OSSL_HTTP_REQ_CTX_new(io, io, buf_size)
+#   define OCSP_REQ_CTX_free OSSL_HTTP_REQ_CTX_free
+#   define OCSP_REQ_CTX_http(rctx, op, path) \
+        (OSSL_HTTP_REQ_CTX_set_expected(rctx, NULL, 1 /* asn1 */, 0, 0) && \
+         OSSL_HTTP_REQ_CTX_set_request_line(rctx, strcmp(op, "POST") == 0, \
+                                            NULL, NULL, path))
+#   define OCSP_REQ_CTX_add1_header OSSL_HTTP_REQ_CTX_add1_header
+#   define OCSP_REQ_CTX_i2d(r, it, req) \
+        OSSL_HTTP_REQ_CTX_set1_req(r, "application/ocsp-request", it, req)
+#   define OCSP_REQ_CTX_set1_req(r, req) \
+        OCSP_REQ_CTX_i2d(r, ASN1_ITEM_rptr(OCSP_REQUEST), (ASN1_VALUE *)(req))
+#   define OCSP_REQ_CTX_nbio OSSL_HTTP_REQ_CTX_nbio
+#   define OCSP_REQ_CTX_nbio_d2i OSSL_HTTP_REQ_CTX_nbio_d2i
+#   define OCSP_sendreq_nbio(p, r) \
+        OSSL_HTTP_REQ_CTX_nbio_d2i(r, (ASN1_VALUE **)(p), \
+                                   ASN1_ITEM_rptr(OCSP_RESPONSE))
+#   define OCSP_REQ_CTX_get0_mem_bio OSSL_HTTP_REQ_CTX_get0_mem_bio
+#   define OCSP_set_max_response_length OSSL_HTTP_REQ_CTX_set_max_response_length
+#  endif
+
+OCSP_CERTID *OCSP_cert_to_id(const EVP_MD *dgst, const X509 *subject,
+                             const X509 *issuer);
+
+OCSP_CERTID *OCSP_cert_id_new(const EVP_MD *dgst,
+                              const X509_NAME *issuerName,
+                              const ASN1_BIT_STRING *issuerKey,
+                              const ASN1_INTEGER *serialNumber);
+
+OCSP_ONEREQ *OCSP_request_add0_id(OCSP_REQUEST *req, OCSP_CERTID *cid);
+
+int OCSP_request_add1_nonce(OCSP_REQUEST *req, unsigned char *val, int len);
+int OCSP_basic_add1_nonce(OCSP_BASICRESP *resp, unsigned char *val, int len);
+int OCSP_check_nonce(OCSP_REQUEST *req, OCSP_BASICRESP *bs);
+int OCSP_copy_nonce(OCSP_BASICRESP *resp, OCSP_REQUEST *req);
+
+int OCSP_request_set1_name(OCSP_REQUEST *req, const X509_NAME *nm);
+int OCSP_request_add1_cert(OCSP_REQUEST *req, X509 *cert);
+
+int OCSP_request_sign(OCSP_REQUEST *req,
+                      X509 *signer,
+                      EVP_PKEY *key,
+                      const EVP_MD *dgst,
+                      STACK_OF(X509) *certs, unsigned long flags);
+
+int OCSP_response_status(OCSP_RESPONSE *resp);
+OCSP_BASICRESP *OCSP_response_get1_basic(OCSP_RESPONSE *resp);
+
+const ASN1_OCTET_STRING *OCSP_resp_get0_signature(const OCSP_BASICRESP *bs);
+const X509_ALGOR *OCSP_resp_get0_tbs_sigalg(const OCSP_BASICRESP *bs);
+const OCSP_RESPDATA *OCSP_resp_get0_respdata(const OCSP_BASICRESP *bs);
+int OCSP_resp_get0_signer(OCSP_BASICRESP *bs, X509 **signer,
+                          STACK_OF(X509) *extra_certs);
+
+int OCSP_resp_count(OCSP_BASICRESP *bs);
+OCSP_SINGLERESP *OCSP_resp_get0(OCSP_BASICRESP *bs, int idx);
+const ASN1_GENERALIZEDTIME *OCSP_resp_get0_produced_at(const OCSP_BASICRESP* bs);
+const STACK_OF(X509) *OCSP_resp_get0_certs(const OCSP_BASICRESP *bs);
+int OCSP_resp_get0_id(const OCSP_BASICRESP *bs,
+                      const ASN1_OCTET_STRING **pid,
+                      const X509_NAME **pname);
+int OCSP_resp_get1_id(const OCSP_BASICRESP *bs,
+                      ASN1_OCTET_STRING **pid,
+                      X509_NAME **pname);
+
+int OCSP_resp_find(OCSP_BASICRESP *bs, OCSP_CERTID *id, int last);
+int OCSP_single_get0_status(OCSP_SINGLERESP *single, int *reason,
+                            ASN1_GENERALIZEDTIME **revtime,
+                            ASN1_GENERALIZEDTIME **thisupd,
+                            ASN1_GENERALIZEDTIME **nextupd);
+int OCSP_resp_find_status(OCSP_BASICRESP *bs, OCSP_CERTID *id, int *status,
+                          int *reason,
+                          ASN1_GENERALIZEDTIME **revtime,
+                          ASN1_GENERALIZEDTIME **thisupd,
+                          ASN1_GENERALIZEDTIME **nextupd);
+int OCSP_check_validity(ASN1_GENERALIZEDTIME *thisupd,
+                        ASN1_GENERALIZEDTIME *nextupd, long sec, long maxsec);
+
+int OCSP_request_verify(OCSP_REQUEST *req, STACK_OF(X509) *certs,
+                        X509_STORE *store, unsigned long flags);
+
+#  define OCSP_parse_url(url, host, port, path, ssl) \
+    OSSL_HTTP_parse_url(url, ssl, NULL, host, port, NULL, path, NULL, NULL)
+
+int OCSP_id_issuer_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b);
+int OCSP_id_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b);
+
+int OCSP_request_onereq_count(OCSP_REQUEST *req);
+OCSP_ONEREQ *OCSP_request_onereq_get0(OCSP_REQUEST *req, int i);
+OCSP_CERTID *OCSP_onereq_get0_id(OCSP_ONEREQ *one);
+int OCSP_id_get0_info(ASN1_OCTET_STRING **piNameHash, ASN1_OBJECT **pmd,
+                      ASN1_OCTET_STRING **pikeyHash,
+                      ASN1_INTEGER **pserial, OCSP_CERTID *cid);
+int OCSP_request_is_signed(OCSP_REQUEST *req);
+OCSP_RESPONSE *OCSP_response_create(int status, OCSP_BASICRESP *bs);
+OCSP_SINGLERESP *OCSP_basic_add1_status(OCSP_BASICRESP *rsp,
+                                        OCSP_CERTID *cid,
+                                        int status, int reason,
+                                        ASN1_TIME *revtime,
+                                        ASN1_TIME *thisupd,
+                                        ASN1_TIME *nextupd);
+int OCSP_basic_add1_cert(OCSP_BASICRESP *resp, X509 *cert);
+int OCSP_basic_sign(OCSP_BASICRESP *brsp,
+                    X509 *signer, EVP_PKEY *key, const EVP_MD *dgst,
+                    STACK_OF(X509) *certs, unsigned long flags);
+int OCSP_basic_sign_ctx(OCSP_BASICRESP *brsp,
+                        X509 *signer, EVP_MD_CTX *ctx,
+                        STACK_OF(X509) *certs, unsigned long flags);
+int OCSP_RESPID_set_by_name(OCSP_RESPID *respid, X509 *cert);
+int OCSP_RESPID_set_by_key_ex(OCSP_RESPID *respid, X509 *cert,
+                              OSSL_LIB_CTX *libctx, const char *propq);
+int OCSP_RESPID_set_by_key(OCSP_RESPID *respid, X509 *cert);
+int OCSP_RESPID_match_ex(OCSP_RESPID *respid, X509 *cert, OSSL_LIB_CTX *libctx,
+                         const char *propq);
+int OCSP_RESPID_match(OCSP_RESPID *respid, X509 *cert);
+
+X509_EXTENSION *OCSP_crlID_new(const char *url, long *n, char *tim);
+
+X509_EXTENSION *OCSP_accept_responses_new(char **oids);
+
+X509_EXTENSION *OCSP_archive_cutoff_new(char *tim);
+
+X509_EXTENSION *OCSP_url_svcloc_new(const X509_NAME *issuer, const char **urls);
+
+int OCSP_REQUEST_get_ext_count(OCSP_REQUEST *x);
+int OCSP_REQUEST_get_ext_by_NID(OCSP_REQUEST *x, int nid, int lastpos);
+int OCSP_REQUEST_get_ext_by_OBJ(OCSP_REQUEST *x, const ASN1_OBJECT *obj,
+                                int lastpos);
+int OCSP_REQUEST_get_ext_by_critical(OCSP_REQUEST *x, int crit, int lastpos);
+X509_EXTENSION *OCSP_REQUEST_get_ext(OCSP_REQUEST *x, int loc);
+X509_EXTENSION *OCSP_REQUEST_delete_ext(OCSP_REQUEST *x, int loc);
+void *OCSP_REQUEST_get1_ext_d2i(OCSP_REQUEST *x, int nid, int *crit,
+                                int *idx);
+int OCSP_REQUEST_add1_ext_i2d(OCSP_REQUEST *x, int nid, void *value, int crit,
+                              unsigned long flags);
+int OCSP_REQUEST_add_ext(OCSP_REQUEST *x, X509_EXTENSION *ex, int loc);
+
+int OCSP_ONEREQ_get_ext_count(OCSP_ONEREQ *x);
+int OCSP_ONEREQ_get_ext_by_NID(OCSP_ONEREQ *x, int nid, int lastpos);
+int OCSP_ONEREQ_get_ext_by_OBJ(OCSP_ONEREQ *x, const ASN1_OBJECT *obj, int lastpos);
+int OCSP_ONEREQ_get_ext_by_critical(OCSP_ONEREQ *x, int crit, int lastpos);
+X509_EXTENSION *OCSP_ONEREQ_get_ext(OCSP_ONEREQ *x, int loc);
+X509_EXTENSION *OCSP_ONEREQ_delete_ext(OCSP_ONEREQ *x, int loc);
+void *OCSP_ONEREQ_get1_ext_d2i(OCSP_ONEREQ *x, int nid, int *crit, int *idx);
+int OCSP_ONEREQ_add1_ext_i2d(OCSP_ONEREQ *x, int nid, void *value, int crit,
+                             unsigned long flags);
+int OCSP_ONEREQ_add_ext(OCSP_ONEREQ *x, X509_EXTENSION *ex, int loc);
+
+int OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP *x);
+int OCSP_BASICRESP_get_ext_by_NID(OCSP_BASICRESP *x, int nid, int lastpos);
+int OCSP_BASICRESP_get_ext_by_OBJ(OCSP_BASICRESP *x, const ASN1_OBJECT *obj,
+                                  int lastpos);
+int OCSP_BASICRESP_get_ext_by_critical(OCSP_BASICRESP *x, int crit,
+                                       int lastpos);
+X509_EXTENSION *OCSP_BASICRESP_get_ext(OCSP_BASICRESP *x, int loc);
+X509_EXTENSION *OCSP_BASICRESP_delete_ext(OCSP_BASICRESP *x, int loc);
+void *OCSP_BASICRESP_get1_ext_d2i(OCSP_BASICRESP *x, int nid, int *crit,
+                                  int *idx);
+int OCSP_BASICRESP_add1_ext_i2d(OCSP_BASICRESP *x, int nid, void *value,
+                                int crit, unsigned long flags);
+int OCSP_BASICRESP_add_ext(OCSP_BASICRESP *x, X509_EXTENSION *ex, int loc);
+
+int OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP *x);
+int OCSP_SINGLERESP_get_ext_by_NID(OCSP_SINGLERESP *x, int nid, int lastpos);
+int OCSP_SINGLERESP_get_ext_by_OBJ(OCSP_SINGLERESP *x, const ASN1_OBJECT *obj,
+                                   int lastpos);
+int OCSP_SINGLERESP_get_ext_by_critical(OCSP_SINGLERESP *x, int crit,
+                                        int lastpos);
+X509_EXTENSION *OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP *x, int loc);
+X509_EXTENSION *OCSP_SINGLERESP_delete_ext(OCSP_SINGLERESP *x, int loc);
+void *OCSP_SINGLERESP_get1_ext_d2i(OCSP_SINGLERESP *x, int nid, int *crit,
+                                   int *idx);
+int OCSP_SINGLERESP_add1_ext_i2d(OCSP_SINGLERESP *x, int nid, void *value,
+                                 int crit, unsigned long flags);
+int OCSP_SINGLERESP_add_ext(OCSP_SINGLERESP *x, X509_EXTENSION *ex, int loc);
+const OCSP_CERTID *OCSP_SINGLERESP_get0_id(const OCSP_SINGLERESP *x);
+
+DECLARE_ASN1_FUNCTIONS(OCSP_SINGLERESP)
+DECLARE_ASN1_FUNCTIONS(OCSP_CERTSTATUS)
+DECLARE_ASN1_FUNCTIONS(OCSP_REVOKEDINFO)
+DECLARE_ASN1_FUNCTIONS(OCSP_BASICRESP)
+DECLARE_ASN1_FUNCTIONS(OCSP_RESPDATA)
+DECLARE_ASN1_FUNCTIONS(OCSP_RESPID)
+DECLARE_ASN1_FUNCTIONS(OCSP_RESPONSE)
+DECLARE_ASN1_FUNCTIONS(OCSP_RESPBYTES)
+DECLARE_ASN1_FUNCTIONS(OCSP_ONEREQ)
+DECLARE_ASN1_FUNCTIONS(OCSP_CERTID)
+DECLARE_ASN1_FUNCTIONS(OCSP_REQUEST)
+DECLARE_ASN1_FUNCTIONS(OCSP_SIGNATURE)
+DECLARE_ASN1_FUNCTIONS(OCSP_REQINFO)
+DECLARE_ASN1_FUNCTIONS(OCSP_CRLID)
+DECLARE_ASN1_FUNCTIONS(OCSP_SERVICELOC)
+
+const char *OCSP_response_status_str(long s);
+const char *OCSP_cert_status_str(long s);
+const char *OCSP_crl_reason_str(long s);
+
+int OCSP_REQUEST_print(BIO *bp, OCSP_REQUEST *a, unsigned long flags);
+int OCSP_RESPONSE_print(BIO *bp, OCSP_RESPONSE *o, unsigned long flags);
+
+int OCSP_basic_verify(OCSP_BASICRESP *bs, STACK_OF(X509) *certs,
+                      X509_STORE *st, unsigned long flags);
+
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif /* !defined(OPENSSL_NO_OCSP) */
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ocsperr.h b/CAPI/cpp/grpc/include/openssl/ocsperr.h
new file mode 100644
index 0000000..46a0523
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ocsperr.h
@@ -0,0 +1,53 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OCSPERR_H
+# define OPENSSL_OCSPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_OCSP
+
+
+/*
+ * OCSP reason codes.
+ */
+#  define OCSP_R_CERTIFICATE_VERIFY_ERROR                  101
+#  define OCSP_R_DIGEST_ERR                                102
+#  define OCSP_R_DIGEST_NAME_ERR                           106
+#  define OCSP_R_DIGEST_SIZE_ERR                           107
+#  define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD                 122
+#  define OCSP_R_ERROR_IN_THISUPDATE_FIELD                 123
+#  define OCSP_R_MISSING_OCSPSIGNING_USAGE                 103
+#  define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE              124
+#  define OCSP_R_NOT_BASIC_RESPONSE                        104
+#  define OCSP_R_NO_CERTIFICATES_IN_CHAIN                  105
+#  define OCSP_R_NO_RESPONSE_DATA                          108
+#  define OCSP_R_NO_REVOKED_TIME                           109
+#  define OCSP_R_NO_SIGNER_KEY                             130
+#  define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE    110
+#  define OCSP_R_REQUEST_NOT_SIGNED                        128
+#  define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA      111
+#  define OCSP_R_ROOT_CA_NOT_TRUSTED                       112
+#  define OCSP_R_SIGNATURE_FAILURE                         117
+#  define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND              118
+#  define OCSP_R_STATUS_EXPIRED                            125
+#  define OCSP_R_STATUS_NOT_YET_VALID                      126
+#  define OCSP_R_STATUS_TOO_OLD                            127
+#  define OCSP_R_UNKNOWN_MESSAGE_DIGEST                    119
+#  define OCSP_R_UNKNOWN_NID                               120
+#  define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE            129
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/opensslconf.h b/CAPI/cpp/grpc/include/openssl/opensslconf.h
new file mode 100644
index 0000000..1e83371
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/opensslconf.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OPENSSLCONF_H
+# define OPENSSL_OPENSSLCONF_H
+# pragma once
+
+# include <openssl/configuration.h>
+# include <openssl/macros.h>
+
+#endif  /* OPENSSL_OPENSSLCONF_H */
diff --git a/CAPI/cpp/grpc/include/openssl/opensslv.h b/CAPI/cpp/grpc/include/openssl/opensslv.h
new file mode 100644
index 0000000..028ae24
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/opensslv.h
@@ -0,0 +1,114 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\opensslv.h.in
+ *
+ * Copyright 1999-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OPENSSLV_H
+# define OPENSSL_OPENSSLV_H
+# pragma once
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * SECTION 1: VERSION DATA.  These will change for each release
+ */
+
+/*
+ * Base version macros
+ *
+ * These macros express version number MAJOR.MINOR.PATCH exactly
+ */
+# define OPENSSL_VERSION_MAJOR  3
+# define OPENSSL_VERSION_MINOR  0
+# define OPENSSL_VERSION_PATCH  5
+
+/*
+ * Additional version information
+ *
+ * These are also part of the new version scheme, but aren't part
+ * of the version number itself.
+ */
+
+/* Could be: #define OPENSSL_VERSION_PRE_RELEASE "-alpha.1" */
+# define OPENSSL_VERSION_PRE_RELEASE ""
+/* Could be: #define OPENSSL_VERSION_BUILD_METADATA "+fips" */
+/* Could be: #define OPENSSL_VERSION_BUILD_METADATA "+vendor.1" */
+# define OPENSSL_VERSION_BUILD_METADATA ""
+
+/*
+ * Note: The OpenSSL Project will never define OPENSSL_VERSION_BUILD_METADATA
+ * to be anything but the empty string.  Its use is entirely reserved for
+ * others
+ */
+
+/*
+ * Shared library version
+ *
+ * This is strictly to express ABI version, which may or may not
+ * be related to the API version expressed with the macros above.
+ * This is defined in free form.
+ */
+# define OPENSSL_SHLIB_VERSION 3
+
+/*
+ * SECTION 2: USEFUL MACROS
+ */
+
+/* For checking general API compatibility when preprocessing */
+# define OPENSSL_VERSION_PREREQ(maj,min)                                \
+    ((OPENSSL_VERSION_MAJOR << 16) + OPENSSL_VERSION_MINOR >= ((maj) << 16) + (min))
+
+/*
+ * Macros to get the version in easily digested string form, both the short
+ * "MAJOR.MINOR.PATCH" variant (where MAJOR, MINOR and PATCH are replaced
+ * with the values from the corresponding OPENSSL_VERSION_ macros) and the
+ * longer variant with OPENSSL_VERSION_PRE_RELEASE_STR and
+ * OPENSSL_VERSION_BUILD_METADATA_STR appended.
+ */
+# define OPENSSL_VERSION_STR "3.0.5"
+# define OPENSSL_FULL_VERSION_STR "3.0.5"
+
+/*
+ * SECTION 3: ADDITIONAL METADATA
+ *
+ * These strings are defined separately to allow them to be parsable.
+ */
+# define OPENSSL_RELEASE_DATE "5 Jul 2022"
+
+/*
+ * SECTION 4: BACKWARD COMPATIBILITY
+ */
+
+# define OPENSSL_VERSION_TEXT "OpenSSL 3.0.5 5 Jul 2022"
+
+/* Synthesize OPENSSL_VERSION_NUMBER with the layout 0xMNN00PPSL */
+# ifdef OPENSSL_VERSION_PRE_RELEASE
+#  define _OPENSSL_VERSION_PRE_RELEASE 0x0L
+# else
+#  define _OPENSSL_VERSION_PRE_RELEASE 0xfL
+# endif
+# define OPENSSL_VERSION_NUMBER          \
+    ( (OPENSSL_VERSION_MAJOR<<28)        \
+      |(OPENSSL_VERSION_MINOR<<20)       \
+      |(OPENSSL_VERSION_PATCH<<4)        \
+      |_OPENSSL_VERSION_PRE_RELEASE )
+
+# ifdef  __cplusplus
+}
+# endif
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OPENSSLV_H
+# endif
+
+#endif                          /* OPENSSL_OPENSSLV_H */
diff --git a/CAPI/cpp/grpc/include/openssl/ossl_typ.h b/CAPI/cpp/grpc/include/openssl/ossl_typ.h
new file mode 100644
index 0000000..82a5898
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ossl_typ.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * The original <openssl/ossl_typ.h> was renamed to <openssl/types.h>
+ *
+ * This header file only exists for compatibility reasons with older
+ * applications which #include <openssl/ossl_typ.h>.
+ */
+# include <openssl/types.h>
diff --git a/CAPI/cpp/grpc/include/openssl/param_build.h b/CAPI/cpp/grpc/include/openssl/param_build.h
new file mode 100644
index 0000000..f29fdb2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/param_build.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PARAM_BUILD_H
+# define OPENSSL_PARAM_BUILD_H
+# pragma once
+
+# include <openssl/params.h>
+# include <openssl/types.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+OSSL_PARAM_BLD *OSSL_PARAM_BLD_new(void);
+OSSL_PARAM *OSSL_PARAM_BLD_to_param(OSSL_PARAM_BLD *bld);
+void OSSL_PARAM_BLD_free(OSSL_PARAM_BLD *bld);
+
+int OSSL_PARAM_BLD_push_int(OSSL_PARAM_BLD *bld, const char *key, int val);
+int OSSL_PARAM_BLD_push_uint(OSSL_PARAM_BLD *bld, const char *key,
+                             unsigned int val);
+int OSSL_PARAM_BLD_push_long(OSSL_PARAM_BLD *bld, const char *key,
+                             long int val);
+int OSSL_PARAM_BLD_push_ulong(OSSL_PARAM_BLD *bld, const char *key,
+                              unsigned long int val);
+int OSSL_PARAM_BLD_push_int32(OSSL_PARAM_BLD *bld, const char *key,
+                              int32_t val);
+int OSSL_PARAM_BLD_push_uint32(OSSL_PARAM_BLD *bld, const char *key,
+                               uint32_t val);
+int OSSL_PARAM_BLD_push_int64(OSSL_PARAM_BLD *bld, const char *key,
+                              int64_t val);
+int OSSL_PARAM_BLD_push_uint64(OSSL_PARAM_BLD *bld, const char *key,
+                               uint64_t val);
+int OSSL_PARAM_BLD_push_size_t(OSSL_PARAM_BLD *bld, const char *key,
+                               size_t val);
+int OSSL_PARAM_BLD_push_time_t(OSSL_PARAM_BLD *bld, const char *key,
+                               time_t val);
+int OSSL_PARAM_BLD_push_double(OSSL_PARAM_BLD *bld, const char *key,
+                               double val);
+int OSSL_PARAM_BLD_push_BN(OSSL_PARAM_BLD *bld, const char *key,
+                           const BIGNUM *bn);
+int OSSL_PARAM_BLD_push_BN_pad(OSSL_PARAM_BLD *bld, const char *key,
+                               const BIGNUM *bn, size_t sz);
+int OSSL_PARAM_BLD_push_utf8_string(OSSL_PARAM_BLD *bld, const char *key,
+                                    const char *buf, size_t bsize);
+int OSSL_PARAM_BLD_push_utf8_ptr(OSSL_PARAM_BLD *bld, const char *key,
+                                 char *buf, size_t bsize);
+int OSSL_PARAM_BLD_push_octet_string(OSSL_PARAM_BLD *bld, const char *key,
+                                     const void *buf, size_t bsize);
+int OSSL_PARAM_BLD_push_octet_ptr(OSSL_PARAM_BLD *bld, const char *key,
+                                  void *buf, size_t bsize);
+
+# ifdef __cplusplus
+}
+# endif
+#endif  /* OPENSSL_PARAM_BUILD_H */
diff --git a/CAPI/cpp/grpc/include/openssl/params.h b/CAPI/cpp/grpc/include/openssl/params.h
new file mode 100644
index 0000000..d75eab0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/params.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PARAMS_H
+# define OPENSSL_PARAMS_H
+# pragma once
+
+# include <openssl/core.h>
+# include <openssl/bn.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define OSSL_PARAM_UNMODIFIED ((size_t)-1)
+
+# define OSSL_PARAM_END \
+    { NULL, 0, NULL, 0, 0 }
+
+# define OSSL_PARAM_DEFN(key, type, addr, sz)    \
+    { (key), (type), (addr), (sz), OSSL_PARAM_UNMODIFIED }
+
+/* Basic parameter types without return sizes */
+# define OSSL_PARAM_int(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int))
+# define OSSL_PARAM_uint(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
+                    sizeof(unsigned int))
+# define OSSL_PARAM_long(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(long int))
+# define OSSL_PARAM_ulong(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
+                    sizeof(unsigned long int))
+# define OSSL_PARAM_int32(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int32_t))
+# define OSSL_PARAM_uint32(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
+                    sizeof(uint32_t))
+# define OSSL_PARAM_int64(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int64_t))
+# define OSSL_PARAM_uint64(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
+                    sizeof(uint64_t))
+# define OSSL_PARAM_size_t(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(size_t))
+# define OSSL_PARAM_time_t(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(time_t))
+# define OSSL_PARAM_double(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_REAL, (addr), sizeof(double))
+
+# define OSSL_PARAM_BN(key, bn, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (bn), (sz))
+# define OSSL_PARAM_utf8_string(key, addr, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_STRING, (addr), sz)
+# define OSSL_PARAM_octet_string(key, addr, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_STRING, (addr), sz)
+
+# define OSSL_PARAM_utf8_ptr(key, addr, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_PTR, (addr), sz)
+# define OSSL_PARAM_octet_ptr(key, addr, sz) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_PTR, (addr), sz)
+
+/* Search an OSSL_PARAM array for a matching name */
+OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key);
+const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key);
+
+/* Basic parameter type run-time construction */
+OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf);
+OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf);
+OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf);
+OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf);
+OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_time_t(const char *key, time_t *buf);
+OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
+                                   size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf);
+OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
+                                            size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
+                                         size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
+                                             size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
+                                          size_t bsize);
+OSSL_PARAM OSSL_PARAM_construct_end(void);
+
+int OSSL_PARAM_allocate_from_text(OSSL_PARAM *to,
+                                  const OSSL_PARAM *paramdefs,
+                                  const char *key, const char *value,
+                                  size_t value_n, int *found);
+
+int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val);
+int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val);
+int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val);
+int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val);
+int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val);
+int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val);
+int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val);
+int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val);
+int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val);
+int OSSL_PARAM_get_time_t(const OSSL_PARAM *p, time_t *val);
+
+int OSSL_PARAM_set_int(OSSL_PARAM *p, int val);
+int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val);
+int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val);
+int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val);
+int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val);
+int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val);
+int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val);
+int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val);
+int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val);
+int OSSL_PARAM_set_time_t(OSSL_PARAM *p, time_t val);
+
+int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val);
+int OSSL_PARAM_set_double(OSSL_PARAM *p, double val);
+
+int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val);
+int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val);
+
+int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len);
+int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val);
+
+int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
+                                size_t *used_len);
+int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val, size_t len);
+
+int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val);
+int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val);
+
+int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
+                             size_t *used_len);
+int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
+                             size_t used_len);
+
+int OSSL_PARAM_get_utf8_string_ptr(const OSSL_PARAM *p, const char **val);
+int OSSL_PARAM_get_octet_string_ptr(const OSSL_PARAM *p, const void **val,
+                                    size_t *used_len);
+
+int OSSL_PARAM_modified(const OSSL_PARAM *p);
+void OSSL_PARAM_set_all_unmodified(OSSL_PARAM *p);
+
+OSSL_PARAM *OSSL_PARAM_dup(const OSSL_PARAM *p);
+OSSL_PARAM *OSSL_PARAM_merge(const OSSL_PARAM *p1, const OSSL_PARAM *p2);
+void OSSL_PARAM_free(OSSL_PARAM *p);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/pem.h b/CAPI/cpp/grpc/include/openssl/pem.h
new file mode 100644
index 0000000..80940df
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/pem.h
@@ -0,0 +1,538 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PEM_H
+# define OPENSSL_PEM_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_PEM_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/bio.h>
+# include <openssl/safestack.h>
+# include <openssl/evp.h>
+# include <openssl/x509.h>
+# include <openssl/pemerr.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define PEM_BUFSIZE             1024
+
+# define PEM_STRING_X509_OLD     "X509 CERTIFICATE"
+# define PEM_STRING_X509         "CERTIFICATE"
+# define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE"
+# define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"
+# define PEM_STRING_X509_REQ     "CERTIFICATE REQUEST"
+# define PEM_STRING_X509_CRL     "X509 CRL"
+# define PEM_STRING_EVP_PKEY     "ANY PRIVATE KEY"
+# define PEM_STRING_PUBLIC       "PUBLIC KEY"
+# define PEM_STRING_RSA          "RSA PRIVATE KEY"
+# define PEM_STRING_RSA_PUBLIC   "RSA PUBLIC KEY"
+# define PEM_STRING_DSA          "DSA PRIVATE KEY"
+# define PEM_STRING_DSA_PUBLIC   "DSA PUBLIC KEY"
+# define PEM_STRING_PKCS7        "PKCS7"
+# define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA"
+# define PEM_STRING_PKCS8        "ENCRYPTED PRIVATE KEY"
+# define PEM_STRING_PKCS8INF     "PRIVATE KEY"
+# define PEM_STRING_DHPARAMS     "DH PARAMETERS"
+# define PEM_STRING_DHXPARAMS    "X9.42 DH PARAMETERS"
+# define PEM_STRING_SSL_SESSION  "SSL SESSION PARAMETERS"
+# define PEM_STRING_DSAPARAMS    "DSA PARAMETERS"
+# define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"
+# define PEM_STRING_ECPARAMETERS "EC PARAMETERS"
+# define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY"
+# define PEM_STRING_PARAMETERS   "PARAMETERS"
+# define PEM_STRING_CMS          "CMS"
+
+# define PEM_TYPE_ENCRYPTED      10
+# define PEM_TYPE_MIC_ONLY       20
+# define PEM_TYPE_MIC_CLEAR      30
+# define PEM_TYPE_CLEAR          40
+
+/*
+ * These macros make the PEM_read/PEM_write functions easier to maintain and
+ * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or
+ * IMPLEMENT_PEM_rw_cb(...)
+ */
+
+# define PEM_read_cb_fnsig(name, type, INTYPE, readname)                \
+    type *PEM_##readname##_##name(INTYPE *out, type **x,                \
+                                 pem_password_cb *cb, void *u)
+# define PEM_read_cb_ex_fnsig(name, type, INTYPE, readname)             \
+    type *PEM_##readname##_##name##_ex(INTYPE *out, type **x,           \
+                                       pem_password_cb *cb, void *u,    \
+                                       OSSL_LIB_CTX *libctx,            \
+                                       const char *propq)
+
+# define PEM_write_fnsig(name, type, OUTTYPE, writename)                \
+    int PEM_##writename##_##name(OUTTYPE *out, const type *x)
+# define PEM_write_cb_fnsig(name, type, OUTTYPE, writename)             \
+    int PEM_##writename##_##name(OUTTYPE *out, const type *x,           \
+                                 const EVP_CIPHER *enc,                 \
+                                 const unsigned char *kstr, int klen,   \
+                                 pem_password_cb *cb, void *u)
+# define PEM_write_ex_fnsig(name, type, OUTTYPE, writename)             \
+    int PEM_##writename##_##name##_ex(OUTTYPE *out, const type *x,      \
+                                      OSSL_LIB_CTX *libctx,             \
+                                      const char *propq)
+# define PEM_write_cb_ex_fnsig(name, type, OUTTYPE, writename)          \
+    int PEM_##writename##_##name##_ex(OUTTYPE *out, const type *x,      \
+                                      const EVP_CIPHER *enc,            \
+                                      const unsigned char *kstr, int klen, \
+                                      pem_password_cb *cb, void *u,     \
+                                      OSSL_LIB_CTX *libctx,             \
+                                      const char *propq)
+
+# ifdef OPENSSL_NO_STDIO
+
+#  define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/
+#  define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/
+#  endif
+#  define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/
+#  endif
+# else
+
+#  define IMPLEMENT_PEM_read_fp(name, type, str, asn1)                  \
+    type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u) \
+    {                                                                   \
+        return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str, fp,        \
+                             (void **)x, cb, u);                        \
+    }
+
+#  define IMPLEMENT_PEM_write_fp(name, type, str, asn1)                 \
+    PEM_write_fnsig(name, type, FILE, write)                            \
+    {                                                                   \
+        return PEM_ASN1_write((i2d_of_void *)i2d_##asn1, str, out,      \
+                              x, NULL, NULL, 0, NULL, NULL);            \
+    }
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)  \
+    IMPLEMENT_PEM_write_fp(name, type, str, asn1)
+#  endif
+
+#  define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)              \
+    PEM_write_cb_fnsig(name, type, FILE, write)                         \
+    {                                                                   \
+        return PEM_ASN1_write((i2d_of_void *)i2d_##asn1, str, out,      \
+                              x, enc, kstr, klen, cb, u);               \
+    }
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)       \
+    IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
+#  endif
+# endif
+
+# define IMPLEMENT_PEM_read_bio(name, type, str, asn1)                  \
+    type *PEM_read_bio_##name(BIO *bp, type **x,                        \
+                              pem_password_cb *cb, void *u)             \
+    {                                                                   \
+        return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str, bp,    \
+                                 (void **)x, cb, u);                    \
+    }
+
+# define IMPLEMENT_PEM_write_bio(name, type, str, asn1)                 \
+    PEM_write_fnsig(name, type, BIO, write_bio)                         \
+    {                                                                   \
+        return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1, str, out,  \
+                                  x, NULL,NULL,0,NULL,NULL);            \
+    }
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1)   \
+    IMPLEMENT_PEM_write_bio(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)              \
+    PEM_write_cb_fnsig(name, type, BIO, write_bio)                      \
+    {                                                                   \
+        return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1, str, out,  \
+                                  x, enc, kstr, klen, cb, u);           \
+    }
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1)  \
+    IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_write(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_fp(name, type, str, asn1)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_write_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_read(name, type, str, asn1) \
+        IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
+        IMPLEMENT_PEM_read_fp(name, type, str, asn1)
+
+# define IMPLEMENT_PEM_rw(name, type, str, asn1) \
+        IMPLEMENT_PEM_read(name, type, str, asn1) \
+        IMPLEMENT_PEM_write(name, type, str, asn1)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \
+        IMPLEMENT_PEM_read(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_const(name, type, str, asn1)
+# endif
+
+# define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \
+        IMPLEMENT_PEM_read(name, type, str, asn1) \
+        IMPLEMENT_PEM_write_cb(name, type, str, asn1)
+
+/* These are the same except they are for the declarations */
+
+/*
+ * The mysterious 'extern' that's passed to some macros is innocuous,
+ * and is there to quiet pre-C99 compilers that may complain about empty
+ * arguments in macro calls.
+ */
+# if defined(OPENSSL_NO_STDIO)
+
+#  define DECLARE_PEM_read_fp_attr(attr, name, type) /**/
+#  define DECLARE_PEM_read_fp_ex_attr(attr, name, type) /**/
+#  define DECLARE_PEM_write_fp_attr(attr, name, type) /**/
+#  define DECLARE_PEM_write_fp_ex_attr(attr, name, type) /**/
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DECLARE_PEM_write_fp_const_attr(attr, name, type) /**/
+#  endif
+#  define DECLARE_PEM_write_cb_fp_attr(attr, name, type) /**/
+#  define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) /**/
+
+# else
+
+#  define DECLARE_PEM_read_fp_attr(attr, name, type)                        \
+    attr PEM_read_cb_fnsig(name, type, FILE, read);
+#  define DECLARE_PEM_read_fp_ex_attr(attr, name, type)                     \
+    attr PEM_read_cb_fnsig(name, type, FILE, read);                         \
+    attr PEM_read_cb_ex_fnsig(name, type, FILE, read);
+
+#  define DECLARE_PEM_write_fp_attr(attr, name, type)                       \
+    attr PEM_write_fnsig(name, type, FILE, write);
+#  define DECLARE_PEM_write_fp_ex_attr(attr, name, type)                    \
+    attr PEM_write_fnsig(name, type, FILE, write);                          \
+    attr PEM_write_ex_fnsig(name, type, FILE, write);
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DECLARE_PEM_write_fp_const_attr(attr, name, type)                \
+    attr PEM_write_fnsig(name, type, FILE, write);
+#  endif
+#  define DECLARE_PEM_write_cb_fp_attr(attr, name, type)                    \
+    attr PEM_write_cb_fnsig(name, type, FILE, write);
+#  define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)                 \
+    attr PEM_write_cb_fnsig(name, type, FILE, write);                       \
+    attr PEM_write_cb_ex_fnsig(name, type, FILE, write);
+
+# endif
+
+# define DECLARE_PEM_read_fp(name, type)                                    \
+    DECLARE_PEM_read_fp_attr(extern, name, type)
+# define DECLARE_PEM_write_fp(name, type)                                   \
+    DECLARE_PEM_write_fp_attr(extern, name, type)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define DECLARE_PEM_write_fp_const(name, type)                           \
+    DECLARE_PEM_write_fp_const_attr(extern, name, type)
+# endif
+# define DECLARE_PEM_write_cb_fp(name, type)                                \
+    DECLARE_PEM_write_cb_fp_attr(extern, name, type)
+
+#  define DECLARE_PEM_read_bio_attr(attr, name, type)                       \
+    attr PEM_read_cb_fnsig(name, type, BIO, read_bio);
+#  define DECLARE_PEM_read_bio_ex_attr(attr, name, type)                    \
+    attr PEM_read_cb_fnsig(name, type, BIO, read_bio);                      \
+    attr PEM_read_cb_ex_fnsig(name, type, BIO, read_bio);
+# define DECLARE_PEM_read_bio(name, type)                                   \
+    DECLARE_PEM_read_bio_attr(extern, name, type)
+# define DECLARE_PEM_read_bio_ex(name, type)                                \
+    DECLARE_PEM_read_bio_ex_attr(extern, name, type)
+
+# define DECLARE_PEM_write_bio_attr(attr, name, type)                       \
+    attr PEM_write_fnsig(name, type, BIO, write_bio);
+# define DECLARE_PEM_write_bio_ex_attr(attr, name, type)                    \
+    attr PEM_write_fnsig(name, type, BIO, write_bio);                       \
+    attr PEM_write_ex_fnsig(name, type, BIO, write_bio);
+# define DECLARE_PEM_write_bio(name, type)                                  \
+    DECLARE_PEM_write_bio_attr(extern, name, type)
+# define DECLARE_PEM_write_bio_ex(name, type)                               \
+    DECLARE_PEM_write_bio_ex_attr(extern, name, type)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define DECLARE_PEM_write_bio_const_attr(attr, name, type)                \
+    attr PEM_write_fnsig(name, type, BIO, write_bio);
+#  define DECLARE_PEM_write_bio_const(name, type)      \
+    DECLARE_PEM_write_bio_const_attr(extern, name, type)
+# endif
+
+# define DECLARE_PEM_write_cb_bio_attr(attr, name, type)                    \
+    attr PEM_write_cb_fnsig(name, type, BIO, write_bio);
+# define DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type)                 \
+    attr PEM_write_cb_fnsig(name, type, BIO, write_bio);                    \
+    attr PEM_write_cb_ex_fnsig(name, type, BIO, write_bio);
+# define DECLARE_PEM_write_cb_bio(name, type)                               \
+    DECLARE_PEM_write_cb_bio_attr(extern, name, type)
+# define DECLARE_PEM_write_cb_ex_bio(name, type)                            \
+    DECLARE_PEM_write_cb_bio_ex_attr(extern, name, type)
+
+# define DECLARE_PEM_write_attr(attr, name, type)                           \
+    DECLARE_PEM_write_bio_attr(attr, name, type)                            \
+    DECLARE_PEM_write_fp_attr(attr, name, type)
+# define DECLARE_PEM_write_ex_attr(attr, name, type)                        \
+    DECLARE_PEM_write_bio_ex_attr(attr, name, type)                         \
+    DECLARE_PEM_write_fp_ex_attr(attr, name, type)
+# define DECLARE_PEM_write(name, type) \
+    DECLARE_PEM_write_attr(extern, name, type)
+# define DECLARE_PEM_write_ex(name, type) \
+    DECLARE_PEM_write_ex_attr(extern, name, type)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define DECLARE_PEM_write_const_attr(attr, name, type)                    \
+    DECLARE_PEM_write_bio_const_attr(attr, name, type)                      \
+    DECLARE_PEM_write_fp_const_attr(attr, name, type)
+#  define DECLARE_PEM_write_const(name, type)                               \
+    DECLARE_PEM_write_const_attr(extern, name, type)
+# endif
+# define DECLARE_PEM_write_cb_attr(attr, name, type)                        \
+    DECLARE_PEM_write_cb_bio_attr(attr, name, type)                         \
+    DECLARE_PEM_write_cb_fp_attr(attr, name, type)
+# define DECLARE_PEM_write_cb_ex_attr(attr, name, type)                     \
+    DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type)                      \
+    DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)
+# define DECLARE_PEM_write_cb(name, type)                                   \
+    DECLARE_PEM_write_cb_attr(extern, name, type)
+# define DECLARE_PEM_write_cb_ex(name, type)                                \
+    DECLARE_PEM_write_cb_ex_attr(extern, name, type)
+# define DECLARE_PEM_read_attr(attr, name, type)                            \
+    DECLARE_PEM_read_bio_attr(attr, name, type)                             \
+    DECLARE_PEM_read_fp_attr(attr, name, type)
+# define DECLARE_PEM_read_ex_attr(attr, name, type)                         \
+    DECLARE_PEM_read_bio_ex_attr(attr, name, type)                          \
+    DECLARE_PEM_read_fp_ex_attr(attr, name, type)
+# define DECLARE_PEM_read(name, type)                                       \
+    DECLARE_PEM_read_attr(extern, name, type)
+# define DECLARE_PEM_read_ex(name, type)                                    \
+    DECLARE_PEM_read_ex_attr(extern, name, type)
+# define DECLARE_PEM_rw_attr(attr, name, type)                              \
+    DECLARE_PEM_read_attr(attr, name, type)                                 \
+    DECLARE_PEM_write_attr(attr, name, type)
+# define DECLARE_PEM_rw_ex_attr(attr, name, type)                           \
+    DECLARE_PEM_read_ex_attr(attr, name, type)                              \
+    DECLARE_PEM_write_ex_attr(attr, name, type)
+# define DECLARE_PEM_rw(name, type) \
+    DECLARE_PEM_rw_attr(extern, name, type)
+# define DECLARE_PEM_rw_ex(name, type) \
+    DECLARE_PEM_rw_ex_attr(extern, name, type)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define DECLARE_PEM_rw_const_attr(attr, name, type)                       \
+    DECLARE_PEM_read_attr(attr, name, type)                                 \
+    DECLARE_PEM_write_const_attr(attr, name, type)
+#  define DECLARE_PEM_rw_const(name, type) \
+    DECLARE_PEM_rw_const_attr(extern, name, type)
+# endif
+# define DECLARE_PEM_rw_cb_attr(attr, name, type)                           \
+    DECLARE_PEM_read_attr(attr, name, type)                                 \
+    DECLARE_PEM_write_cb_attr(attr, name, type)
+# define DECLARE_PEM_rw_cb_ex_attr(attr, name, type)                        \
+    DECLARE_PEM_read_ex_attr(attr, name, type)                              \
+    DECLARE_PEM_write_cb_ex_attr(attr, name, type)
+# define DECLARE_PEM_rw_cb(name, type) \
+    DECLARE_PEM_rw_cb_attr(extern, name, type)
+# define DECLARE_PEM_rw_cb_ex(name, type) \
+    DECLARE_PEM_rw_cb_ex_attr(extern, name, type)
+
+int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);
+int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len,
+                  pem_password_cb *callback, void *u);
+
+int PEM_read_bio(BIO *bp, char **name, char **header,
+                 unsigned char **data, long *len);
+#   define PEM_FLAG_SECURE             0x1
+#   define PEM_FLAG_EAY_COMPATIBLE     0x2
+#   define PEM_FLAG_ONLY_B64           0x4
+int PEM_read_bio_ex(BIO *bp, char **name, char **header,
+                    unsigned char **data, long *len, unsigned int flags);
+int PEM_bytes_read_bio_secmem(unsigned char **pdata, long *plen, char **pnm,
+                              const char *name, BIO *bp, pem_password_cb *cb,
+                              void *u);
+int PEM_write_bio(BIO *bp, const char *name, const char *hdr,
+                  const unsigned char *data, long len);
+int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
+                       const char *name, BIO *bp, pem_password_cb *cb,
+                       void *u);
+void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x,
+                        pem_password_cb *cb, void *u);
+int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp,
+                       const void *x, const EVP_CIPHER *enc,
+                       const unsigned char *kstr, int klen,
+                       pem_password_cb *cb, void *u);
+
+STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk,
+                                            pem_password_cb *cb, void *u);
+STACK_OF(X509_INFO)
+*PEM_X509_INFO_read_bio_ex(BIO *bp, STACK_OF(X509_INFO) *sk,
+                           pem_password_cb *cb, void *u, OSSL_LIB_CTX *libctx,
+                           const char *propq);
+
+int PEM_X509_INFO_write_bio(BIO *bp, const X509_INFO *xi, EVP_CIPHER *enc,
+                            const unsigned char *kstr, int klen,
+                            pem_password_cb *cd, void *u);
+
+#ifndef OPENSSL_NO_STDIO
+int PEM_read(FILE *fp, char **name, char **header,
+             unsigned char **data, long *len);
+int PEM_write(FILE *fp, const char *name, const char *hdr,
+              const unsigned char *data, long len);
+void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
+                    pem_password_cb *cb, void *u);
+int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp,
+                   const void *x, const EVP_CIPHER *enc,
+                   const unsigned char *kstr, int klen,
+                   pem_password_cb *callback, void *u);
+STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
+                                        pem_password_cb *cb, void *u);
+STACK_OF(X509_INFO)
+*PEM_X509_INFO_read_ex(FILE *fp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb,
+                       void *u, OSSL_LIB_CTX *libctx, const char *propq);
+#endif
+
+int PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);
+int PEM_SignUpdate(EVP_MD_CTX *ctx, const unsigned char *d, unsigned int cnt);
+int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
+                  unsigned int *siglen, EVP_PKEY *pkey);
+
+/* The default pem_password_cb that's used internally */
+int PEM_def_callback(char *buf, int num, int rwflag, void *userdata);
+void PEM_proc_type(char *buf, int type);
+void PEM_dek_info(char *buf, const char *type, int len, const char *str);
+
+# include <openssl/symhacks.h>
+
+DECLARE_PEM_rw(X509, X509)
+DECLARE_PEM_rw(X509_AUX, X509)
+DECLARE_PEM_rw(X509_REQ, X509_REQ)
+DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)
+DECLARE_PEM_rw(X509_CRL, X509_CRL)
+DECLARE_PEM_rw(X509_PUBKEY, X509_PUBKEY)
+DECLARE_PEM_rw(PKCS7, PKCS7)
+DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)
+DECLARE_PEM_rw(PKCS8, X509_SIG)
+DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, RSAPrivateKey, RSA)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSAPublicKey, RSA)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSA_PUBKEY, RSA)
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_DSA
+DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, DSAPrivateKey, DSA)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSA_PUBKEY, DSA)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSAparams, DSA)
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_EC
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, ECPKParameters, EC_GROUP)
+DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, ECPrivateKey, EC_KEY)
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, EC_PUBKEY, EC_KEY)
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_DH
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DHparams, DH)
+DECLARE_PEM_write_attr(OSSL_DEPRECATEDIN_3_0, DHxparams, DH)
+#  endif
+# endif
+DECLARE_PEM_rw_cb_ex(PrivateKey, EVP_PKEY)
+DECLARE_PEM_rw_ex(PUBKEY, EVP_PKEY)
+
+int PEM_write_bio_PrivateKey_traditional(BIO *bp, const EVP_PKEY *x,
+                                         const EVP_CIPHER *enc,
+                                         const unsigned char *kstr, int klen,
+                                         pem_password_cb *cb, void *u);
+
+/* Why do these take a signed char *kstr? */
+int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, const EVP_PKEY *x, int nid,
+                                      const char *kstr, int klen,
+                                      pem_password_cb *cb, void *u);
+int PEM_write_bio_PKCS8PrivateKey(BIO *, const EVP_PKEY *, const EVP_CIPHER *,
+                                  const char *kstr, int klen,
+                                  pem_password_cb *cb, void *u);
+int i2d_PKCS8PrivateKey_bio(BIO *bp, const EVP_PKEY *x, const EVP_CIPHER *enc,
+                            const char *kstr, int klen,
+                            pem_password_cb *cb, void *u);
+int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, const EVP_PKEY *x, int nid,
+                                const char *kstr, int klen,
+                                pem_password_cb *cb, void *u);
+EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
+                                  void *u);
+
+# ifndef OPENSSL_NO_STDIO
+int i2d_PKCS8PrivateKey_fp(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
+                           const char *kstr, int klen,
+                           pem_password_cb *cb, void *u);
+int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, const EVP_PKEY *x, int nid,
+                               const char *kstr, int klen,
+                               pem_password_cb *cb, void *u);
+int PEM_write_PKCS8PrivateKey_nid(FILE *fp, const EVP_PKEY *x, int nid,
+                                  const char *kstr, int klen,
+                                  pem_password_cb *cb, void *u);
+
+EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
+                                 void *u);
+
+int PEM_write_PKCS8PrivateKey(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
+                              const char *kstr, int klen,
+                              pem_password_cb *cd, void *u);
+# endif
+EVP_PKEY *PEM_read_bio_Parameters_ex(BIO *bp, EVP_PKEY **x,
+                                     OSSL_LIB_CTX *libctx, const char *propq);
+EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x);
+int PEM_write_bio_Parameters(BIO *bp, const EVP_PKEY *x);
+
+EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length);
+EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length);
+EVP_PKEY *b2i_PrivateKey_bio(BIO *in);
+EVP_PKEY *b2i_PublicKey_bio(BIO *in);
+int i2b_PrivateKey_bio(BIO *out, const EVP_PKEY *pk);
+int i2b_PublicKey_bio(BIO *out, const EVP_PKEY *pk);
+EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u);
+EVP_PKEY *b2i_PVK_bio_ex(BIO *in, pem_password_cb *cb, void *u,
+                         OSSL_LIB_CTX *libctx, const char *propq);
+int i2b_PVK_bio(BIO *out, const EVP_PKEY *pk, int enclevel,
+                pem_password_cb *cb, void *u);
+int i2b_PVK_bio_ex(BIO *out, const EVP_PKEY *pk, int enclevel,
+                   pem_password_cb *cb, void *u,
+                   OSSL_LIB_CTX *libctx, const char *propq);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/pem2.h b/CAPI/cpp/grpc/include/openssl/pem2.h
new file mode 100644
index 0000000..a8a5325
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/pem2.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PEM2_H
+# define OPENSSL_PEM2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_PEM2_H
+# endif
+# include <openssl/pemerr.h>
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/pemerr.h b/CAPI/cpp/grpc/include/openssl/pemerr.h
new file mode 100644
index 0000000..18f6d9e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/pemerr.h
@@ -0,0 +1,58 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PEMERR_H
+# define OPENSSL_PEMERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PEM reason codes.
+ */
+# define PEM_R_BAD_BASE64_DECODE                          100
+# define PEM_R_BAD_DECRYPT                                101
+# define PEM_R_BAD_END_LINE                               102
+# define PEM_R_BAD_IV_CHARS                               103
+# define PEM_R_BAD_MAGIC_NUMBER                           116
+# define PEM_R_BAD_PASSWORD_READ                          104
+# define PEM_R_BAD_VERSION_NUMBER                         117
+# define PEM_R_BIO_WRITE_FAILURE                          118
+# define PEM_R_CIPHER_IS_NULL                             127
+# define PEM_R_ERROR_CONVERTING_PRIVATE_KEY               115
+# define PEM_R_EXPECTING_DSS_KEY_BLOB                     131
+# define PEM_R_EXPECTING_PRIVATE_KEY_BLOB                 119
+# define PEM_R_EXPECTING_PUBLIC_KEY_BLOB                  120
+# define PEM_R_EXPECTING_RSA_KEY_BLOB                     132
+# define PEM_R_HEADER_TOO_LONG                            128
+# define PEM_R_INCONSISTENT_HEADER                        121
+# define PEM_R_KEYBLOB_HEADER_PARSE_ERROR                 122
+# define PEM_R_KEYBLOB_TOO_SHORT                          123
+# define PEM_R_MISSING_DEK_IV                             129
+# define PEM_R_NOT_DEK_INFO                               105
+# define PEM_R_NOT_ENCRYPTED                              106
+# define PEM_R_NOT_PROC_TYPE                              107
+# define PEM_R_NO_START_LINE                              108
+# define PEM_R_PROBLEMS_GETTING_PASSWORD                  109
+# define PEM_R_PVK_DATA_TOO_SHORT                         124
+# define PEM_R_PVK_TOO_SHORT                              125
+# define PEM_R_READ_KEY                                   111
+# define PEM_R_SHORT_HEADER                               112
+# define PEM_R_UNEXPECTED_DEK_IV                          130
+# define PEM_R_UNSUPPORTED_CIPHER                         113
+# define PEM_R_UNSUPPORTED_ENCRYPTION                     114
+# define PEM_R_UNSUPPORTED_KEY_COMPONENTS                 126
+# define PEM_R_UNSUPPORTED_PUBLIC_KEY_TYPE                110
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/pkcs12.h b/CAPI/cpp/grpc/include/openssl/pkcs12.h
new file mode 100644
index 0000000..f0da086
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/pkcs12.h
@@ -0,0 +1,350 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\pkcs12.h.in
+ *
+ * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_PKCS12_H
+# define OPENSSL_PKCS12_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_PKCS12_H
+# endif
+
+# include <openssl/bio.h>
+# include <openssl/core.h>
+# include <openssl/x509.h>
+# include <openssl/pkcs12err.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+# define PKCS12_KEY_ID   1
+# define PKCS12_IV_ID    2
+# define PKCS12_MAC_ID   3
+
+/* Default iteration count */
+# ifndef PKCS12_DEFAULT_ITER
+#  define PKCS12_DEFAULT_ITER     PKCS5_DEFAULT_ITER
+# endif
+
+# define PKCS12_MAC_KEY_LENGTH 20
+
+# define PKCS12_SALT_LEN 8
+
+/* It's not clear if these are actually needed... */
+# define PKCS12_key_gen PKCS12_key_gen_utf8
+# define PKCS12_add_friendlyname PKCS12_add_friendlyname_utf8
+
+/* MS key usage constants */
+
+# define KEY_EX  0x10
+# define KEY_SIG 0x80
+
+typedef struct PKCS12_MAC_DATA_st PKCS12_MAC_DATA;
+
+typedef struct PKCS12_st PKCS12;
+
+typedef struct PKCS12_SAFEBAG_st PKCS12_SAFEBAG;
+
+SKM_DEFINE_STACK_OF_INTERNAL(PKCS12_SAFEBAG, PKCS12_SAFEBAG, PKCS12_SAFEBAG)
+#define sk_PKCS12_SAFEBAG_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_value(sk, idx) ((PKCS12_SAFEBAG *)OPENSSL_sk_value(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), (idx)))
+#define sk_PKCS12_SAFEBAG_new(cmp) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)))
+#define sk_PKCS12_SAFEBAG_new_null() ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new_null())
+#define sk_PKCS12_SAFEBAG_new_reserve(cmp, n) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new_reserve(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp), (n)))
+#define sk_PKCS12_SAFEBAG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (n))
+#define sk_PKCS12_SAFEBAG_free(sk) OPENSSL_sk_free(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_delete(sk, i) ((PKCS12_SAFEBAG *)OPENSSL_sk_delete(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (i)))
+#define sk_PKCS12_SAFEBAG_delete_ptr(sk, ptr) ((PKCS12_SAFEBAG *)OPENSSL_sk_delete_ptr(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr)))
+#define sk_PKCS12_SAFEBAG_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
+#define sk_PKCS12_SAFEBAG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
+#define sk_PKCS12_SAFEBAG_pop(sk) ((PKCS12_SAFEBAG *)OPENSSL_sk_pop(ossl_check_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_shift(sk) ((PKCS12_SAFEBAG *)OPENSSL_sk_shift(ossl_check_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS12_SAFEBAG_sk_type(sk),ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc))
+#define sk_PKCS12_SAFEBAG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr), (idx))
+#define sk_PKCS12_SAFEBAG_set(sk, idx, ptr) ((PKCS12_SAFEBAG *)OPENSSL_sk_set(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (idx), ossl_check_PKCS12_SAFEBAG_type(ptr)))
+#define sk_PKCS12_SAFEBAG_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
+#define sk_PKCS12_SAFEBAG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
+#define sk_PKCS12_SAFEBAG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr), pnum)
+#define sk_PKCS12_SAFEBAG_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk))
+#define sk_PKCS12_SAFEBAG_dup(sk) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_dup(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_copyfunc_type(copyfunc), ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc)))
+#define sk_PKCS12_SAFEBAG_set_cmp_func(sk, cmp) ((sk_PKCS12_SAFEBAG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)))
+
+
+typedef struct pkcs12_bag_st PKCS12_BAGS;
+
+# define PKCS12_ERROR    0
+# define PKCS12_OK       1
+
+/* Compatibility macros */
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+
+# define M_PKCS12_bag_type PKCS12_bag_type
+# define M_PKCS12_cert_bag_type PKCS12_cert_bag_type
+# define M_PKCS12_crl_bag_type PKCS12_cert_bag_type
+
+# define PKCS12_certbag2x509 PKCS12_SAFEBAG_get1_cert
+# define PKCS12_certbag2scrl PKCS12_SAFEBAG_get1_crl
+# define PKCS12_bag_type PKCS12_SAFEBAG_get_nid
+# define PKCS12_cert_bag_type PKCS12_SAFEBAG_get_bag_nid
+# define PKCS12_x5092certbag PKCS12_SAFEBAG_create_cert
+# define PKCS12_x509crl2certbag PKCS12_SAFEBAG_create_crl
+# define PKCS12_MAKE_KEYBAG PKCS12_SAFEBAG_create0_p8inf
+# define PKCS12_MAKE_SHKEYBAG PKCS12_SAFEBAG_create_pkcs8_encrypt
+
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 ASN1_TYPE *PKCS12_get_attr(const PKCS12_SAFEBAG *bag,
+                                                   int attr_nid);
+#endif
+
+ASN1_TYPE *PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid);
+int PKCS12_mac_present(const PKCS12 *p12);
+void PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac,
+                     const X509_ALGOR **pmacalg,
+                     const ASN1_OCTET_STRING **psalt,
+                     const ASN1_INTEGER **piter,
+                     const PKCS12 *p12);
+
+const ASN1_TYPE *PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG *bag,
+                                          int attr_nid);
+const ASN1_OBJECT *PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag);
+int PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag);
+int PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag);
+const ASN1_TYPE *PKCS12_SAFEBAG_get0_bag_obj(const PKCS12_SAFEBAG *bag);
+const ASN1_OBJECT *PKCS12_SAFEBAG_get0_bag_type(const PKCS12_SAFEBAG *bag);
+
+X509 *PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag);
+X509_CRL *PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag);
+const STACK_OF(PKCS12_SAFEBAG) *
+PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag);
+const PKCS8_PRIV_KEY_INFO *PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag);
+const X509_SIG *PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag);
+
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_cert(X509 *x509);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_crl(X509_CRL *crl);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_secret(int type, int vtype, const unsigned char *value, int len);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO *p8);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_pkcs8(X509_SIG *p8);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid,
+                                                    const char *pass,
+                                                    int passlen,
+                                                    unsigned char *salt,
+                                                    int saltlen, int iter,
+                                                    PKCS8_PRIV_KEY_INFO *p8inf);
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt_ex(int pbe_nid,
+                                                       const char *pass,
+                                                       int passlen,
+                                                       unsigned char *salt,
+                                                       int saltlen, int iter,
+                                                       PKCS8_PRIV_KEY_INFO *p8inf,
+                                                       OSSL_LIB_CTX *ctx,
+                                                       const char *propq);
+
+PKCS12_SAFEBAG *PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it,
+                                         int nid1, int nid2);
+PKCS8_PRIV_KEY_INFO *PKCS8_decrypt(const X509_SIG *p8, const char *pass,
+                                   int passlen);
+PKCS8_PRIV_KEY_INFO *PKCS8_decrypt_ex(const X509_SIG *p8, const char *pass,
+                                      int passlen, OSSL_LIB_CTX *ctx,
+                                      const char *propq);
+PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey(const PKCS12_SAFEBAG *bag,
+                                         const char *pass, int passlen);
+PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey_ex(const PKCS12_SAFEBAG *bag,
+                                            const char *pass, int passlen,
+                                            OSSL_LIB_CTX *ctx,
+                                            const char *propq);
+X509_SIG *PKCS8_encrypt(int pbe_nid, const EVP_CIPHER *cipher,
+                        const char *pass, int passlen, unsigned char *salt,
+                        int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8);
+X509_SIG *PKCS8_encrypt_ex(int pbe_nid, const EVP_CIPHER *cipher,
+                           const char *pass, int passlen, unsigned char *salt,
+                           int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8,
+                           OSSL_LIB_CTX *ctx, const char *propq);
+X509_SIG *PKCS8_set0_pbe(const char *pass, int passlen,
+                        PKCS8_PRIV_KEY_INFO *p8inf, X509_ALGOR *pbe);
+X509_SIG *PKCS8_set0_pbe_ex(const char *pass, int passlen,
+                            PKCS8_PRIV_KEY_INFO *p8inf, X509_ALGOR *pbe,
+                            OSSL_LIB_CTX *ctx, const char *propq);
+PKCS7 *PKCS12_pack_p7data(STACK_OF(PKCS12_SAFEBAG) *sk);
+STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7data(PKCS7 *p7);
+PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, const char *pass, int passlen,
+                             unsigned char *salt, int saltlen, int iter,
+                             STACK_OF(PKCS12_SAFEBAG) *bags);
+PKCS7 *PKCS12_pack_p7encdata_ex(int pbe_nid, const char *pass, int passlen,
+                                unsigned char *salt, int saltlen, int iter,
+                                STACK_OF(PKCS12_SAFEBAG) *bags,
+                                OSSL_LIB_CTX *ctx, const char *propq);
+
+STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass,
+                                                  int passlen);
+
+int PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes);
+STACK_OF(PKCS7) *PKCS12_unpack_authsafes(const PKCS12 *p12);
+
+int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name,
+                          int namelen);
+int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name,
+                                int namelen);
+int PKCS12_add_friendlyname_utf8(PKCS12_SAFEBAG *bag, const char *name,
+                                 int namelen);
+int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name,
+                           int namelen);
+int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag,
+                                const unsigned char *name, int namelen);
+int PKCS12_add1_attr_by_NID(PKCS12_SAFEBAG *bag, int nid, int type,
+                            const unsigned char *bytes, int len);
+int PKCS12_add1_attr_by_txt(PKCS12_SAFEBAG *bag, const char *attrname, int type,
+                            const unsigned char *bytes, int len);
+int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage);
+ASN1_TYPE *PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs,
+                               int attr_nid);
+char *PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag);
+const STACK_OF(X509_ATTRIBUTE) *
+PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG *bag);
+unsigned char *PKCS12_pbe_crypt(const X509_ALGOR *algor,
+                                const char *pass, int passlen,
+                                const unsigned char *in, int inlen,
+                                unsigned char **data, int *datalen,
+                                int en_de);
+unsigned char *PKCS12_pbe_crypt_ex(const X509_ALGOR *algor,
+                                   const char *pass, int passlen,
+                                   const unsigned char *in, int inlen,
+                                   unsigned char **data, int *datalen,
+                                   int en_de, OSSL_LIB_CTX *libctx,
+                                   const char *propq);
+void *PKCS12_item_decrypt_d2i(const X509_ALGOR *algor, const ASN1_ITEM *it,
+                              const char *pass, int passlen,
+                              const ASN1_OCTET_STRING *oct, int zbuf);
+void *PKCS12_item_decrypt_d2i_ex(const X509_ALGOR *algor, const ASN1_ITEM *it,
+                                 const char *pass, int passlen,
+                                 const ASN1_OCTET_STRING *oct, int zbuf,
+                                 OSSL_LIB_CTX *libctx, 
+                                 const char *propq);
+ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor,
+                                           const ASN1_ITEM *it,
+                                           const char *pass, int passlen,
+                                           void *obj, int zbuf);
+ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt_ex(X509_ALGOR *algor,
+                                              const ASN1_ITEM *it,
+                                              const char *pass, int passlen,
+                                              void *obj, int zbuf,
+                                              OSSL_LIB_CTX *ctx,
+                                              const char *propq);
+PKCS12 *PKCS12_init(int mode);
+PKCS12 *PKCS12_init_ex(int mode, OSSL_LIB_CTX *ctx, const char *propq);
+
+int PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt,
+                       int saltlen, int id, int iter, int n,
+                       unsigned char *out, const EVP_MD *md_type);
+int PKCS12_key_gen_asc_ex(const char *pass, int passlen, unsigned char *salt,
+                          int saltlen, int id, int iter, int n,
+                          unsigned char *out, const EVP_MD *md_type,
+                          OSSL_LIB_CTX *ctx, const char *propq);
+int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt,
+                       int saltlen, int id, int iter, int n,
+                       unsigned char *out, const EVP_MD *md_type);
+int PKCS12_key_gen_uni_ex(unsigned char *pass, int passlen, unsigned char *salt,
+                          int saltlen, int id, int iter, int n,
+                          unsigned char *out, const EVP_MD *md_type,
+                          OSSL_LIB_CTX *ctx, const char *propq);
+int PKCS12_key_gen_utf8(const char *pass, int passlen, unsigned char *salt,
+                        int saltlen, int id, int iter, int n,
+                        unsigned char *out, const EVP_MD *md_type);
+int PKCS12_key_gen_utf8_ex(const char *pass, int passlen, unsigned char *salt,
+                           int saltlen, int id, int iter, int n,
+                           unsigned char *out, const EVP_MD *md_type,
+                           OSSL_LIB_CTX *ctx, const char *propq);
+
+int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                        ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                        const EVP_MD *md_type, int en_de);
+int PKCS12_PBE_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
+                           ASN1_TYPE *param, const EVP_CIPHER *cipher,
+                           const EVP_MD *md_type, int en_de,
+                           OSSL_LIB_CTX *libctx, const char *propq);
+int PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen,
+                   unsigned char *mac, unsigned int *maclen);
+int PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen);
+int PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen,
+                   unsigned char *salt, int saltlen, int iter,
+                   const EVP_MD *md_type);
+int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt,
+                     int saltlen, const EVP_MD *md_type);
+unsigned char *OPENSSL_asc2uni(const char *asc, int asclen,
+                               unsigned char **uni, int *unilen);
+char *OPENSSL_uni2asc(const unsigned char *uni, int unilen);
+unsigned char *OPENSSL_utf82uni(const char *asc, int asclen,
+                                unsigned char **uni, int *unilen);
+char *OPENSSL_uni2utf8(const unsigned char *uni, int unilen);
+
+DECLARE_ASN1_FUNCTIONS(PKCS12)
+DECLARE_ASN1_FUNCTIONS(PKCS12_MAC_DATA)
+DECLARE_ASN1_FUNCTIONS(PKCS12_SAFEBAG)
+DECLARE_ASN1_FUNCTIONS(PKCS12_BAGS)
+
+DECLARE_ASN1_ITEM(PKCS12_SAFEBAGS)
+DECLARE_ASN1_ITEM(PKCS12_AUTHSAFES)
+
+void PKCS12_PBE_add(void);
+int PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert,
+                 STACK_OF(X509) **ca);
+PKCS12 *PKCS12_create(const char *pass, const char *name, EVP_PKEY *pkey,
+                      X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert,
+                      int iter, int mac_iter, int keytype);
+PKCS12 *PKCS12_create_ex(const char *pass, const char *name, EVP_PKEY *pkey,
+                         X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert,
+                         int iter, int mac_iter, int keytype,
+                         OSSL_LIB_CTX *ctx, const char *propq);
+
+PKCS12_SAFEBAG *PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert);
+PKCS12_SAFEBAG *PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags,
+                               EVP_PKEY *key, int key_usage, int iter,
+                               int key_nid, const char *pass);
+PKCS12_SAFEBAG *PKCS12_add_key_ex(STACK_OF(PKCS12_SAFEBAG) **pbags,
+                                  EVP_PKEY *key, int key_usage, int iter,
+                                  int key_nid, const char *pass,
+                                  OSSL_LIB_CTX *ctx, const char *propq);
+
+PKCS12_SAFEBAG *PKCS12_add_secret(STACK_OF(PKCS12_SAFEBAG) **pbags,
+                                  int nid_type, const unsigned char *value, int len);
+int PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags,
+                    int safe_nid, int iter, const char *pass);
+int PKCS12_add_safe_ex(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags,
+                       int safe_nid, int iter, const char *pass,
+                       OSSL_LIB_CTX *ctx, const char *propq);
+
+PKCS12 *PKCS12_add_safes(STACK_OF(PKCS7) *safes, int p7_nid);
+PKCS12 *PKCS12_add_safes_ex(STACK_OF(PKCS7) *safes, int p7_nid,
+                            OSSL_LIB_CTX *ctx, const char *propq);
+
+int i2d_PKCS12_bio(BIO *bp, const PKCS12 *p12);
+# ifndef OPENSSL_NO_STDIO
+int i2d_PKCS12_fp(FILE *fp, const PKCS12 *p12);
+# endif
+PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12);
+# ifndef OPENSSL_NO_STDIO
+PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12);
+# endif
+int PKCS12_newpass(PKCS12 *p12, const char *oldpass, const char *newpass);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/pkcs12err.h b/CAPI/cpp/grpc/include/openssl/pkcs12err.h
new file mode 100644
index 0000000..933c832
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/pkcs12err.h
@@ -0,0 +1,45 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PKCS12ERR_H
+# define OPENSSL_PKCS12ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PKCS12 reason codes.
+ */
+# define PKCS12_R_CANT_PACK_STRUCTURE                     100
+# define PKCS12_R_CONTENT_TYPE_NOT_DATA                   121
+# define PKCS12_R_DECODE_ERROR                            101
+# define PKCS12_R_ENCODE_ERROR                            102
+# define PKCS12_R_ENCRYPT_ERROR                           103
+# define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE       120
+# define PKCS12_R_INVALID_NULL_ARGUMENT                   104
+# define PKCS12_R_INVALID_NULL_PKCS12_POINTER             105
+# define PKCS12_R_INVALID_TYPE                            112
+# define PKCS12_R_IV_GEN_ERROR                            106
+# define PKCS12_R_KEY_GEN_ERROR                           107
+# define PKCS12_R_MAC_ABSENT                              108
+# define PKCS12_R_MAC_GENERATION_ERROR                    109
+# define PKCS12_R_MAC_SETUP_ERROR                         110
+# define PKCS12_R_MAC_STRING_SET_ERROR                    111
+# define PKCS12_R_MAC_VERIFY_FAILURE                      113
+# define PKCS12_R_PARSE_ERROR                             114
+# define PKCS12_R_PKCS12_CIPHERFINAL_ERROR                116
+# define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM                118
+# define PKCS12_R_UNSUPPORTED_PKCS12_MODE                 119
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/pkcs7.h b/CAPI/cpp/grpc/include/openssl/pkcs7.h
new file mode 100644
index 0000000..097d2db
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/pkcs7.h
@@ -0,0 +1,427 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\pkcs7.h.in
+ *
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_PKCS7_H
+# define OPENSSL_PKCS7_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_PKCS7_H
+# endif
+
+# include <openssl/asn1.h>
+# include <openssl/bio.h>
+# include <openssl/e_os2.h>
+
+# include <openssl/symhacks.h>
+# include <openssl/types.h>
+# include <openssl/pkcs7err.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+
+/*-
+Encryption_ID           DES-CBC
+Digest_ID               MD5
+Digest_Encryption_ID    rsaEncryption
+Key_Encryption_ID       rsaEncryption
+*/
+
+typedef struct PKCS7_CTX_st {
+    OSSL_LIB_CTX *libctx;
+    char *propq;
+} PKCS7_CTX;
+
+typedef struct pkcs7_issuer_and_serial_st {
+    X509_NAME *issuer;
+    ASN1_INTEGER *serial;
+} PKCS7_ISSUER_AND_SERIAL;
+
+typedef struct pkcs7_signer_info_st {
+    ASN1_INTEGER *version;      /* version 1 */
+    PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
+    X509_ALGOR *digest_alg;
+    STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */
+    X509_ALGOR *digest_enc_alg;
+    ASN1_OCTET_STRING *enc_digest;
+    STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */
+    /* The private key to sign with */
+    EVP_PKEY *pkey;
+    const PKCS7_CTX *ctx;
+} PKCS7_SIGNER_INFO;
+SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO)
+#define sk_PKCS7_SIGNER_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_value(sk, idx) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_value(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), (idx)))
+#define sk_PKCS7_SIGNER_INFO_new(cmp) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)))
+#define sk_PKCS7_SIGNER_INFO_new_null() ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new_null())
+#define sk_PKCS7_SIGNER_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp), (n)))
+#define sk_PKCS7_SIGNER_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (n))
+#define sk_PKCS7_SIGNER_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_delete(sk, i) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_delete(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (i)))
+#define sk_PKCS7_SIGNER_INFO_delete_ptr(sk, ptr) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr)))
+#define sk_PKCS7_SIGNER_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
+#define sk_PKCS7_SIGNER_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
+#define sk_PKCS7_SIGNER_INFO_pop(sk) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_pop(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_shift(sk) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_shift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk),ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc))
+#define sk_PKCS7_SIGNER_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), (idx))
+#define sk_PKCS7_SIGNER_INFO_set(sk, idx, ptr) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_set(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (idx), ossl_check_PKCS7_SIGNER_INFO_type(ptr)))
+#define sk_PKCS7_SIGNER_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
+#define sk_PKCS7_SIGNER_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
+#define sk_PKCS7_SIGNER_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), pnum)
+#define sk_PKCS7_SIGNER_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))
+#define sk_PKCS7_SIGNER_INFO_dup(sk) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc)))
+#define sk_PKCS7_SIGNER_INFO_set_cmp_func(sk, cmp) ((sk_PKCS7_SIGNER_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)))
+
+
+typedef struct pkcs7_recip_info_st {
+    ASN1_INTEGER *version;      /* version 0 */
+    PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
+    X509_ALGOR *key_enc_algor;
+    ASN1_OCTET_STRING *enc_key;
+    X509 *cert;                 /* get the pub-key from this */
+    const PKCS7_CTX *ctx;
+} PKCS7_RECIP_INFO;
+SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO, PKCS7_RECIP_INFO)
+#define sk_PKCS7_RECIP_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_value(sk, idx) ((PKCS7_RECIP_INFO *)OPENSSL_sk_value(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), (idx)))
+#define sk_PKCS7_RECIP_INFO_new(cmp) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)))
+#define sk_PKCS7_RECIP_INFO_new_null() ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new_null())
+#define sk_PKCS7_RECIP_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp), (n)))
+#define sk_PKCS7_RECIP_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (n))
+#define sk_PKCS7_RECIP_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_delete(sk, i) ((PKCS7_RECIP_INFO *)OPENSSL_sk_delete(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (i)))
+#define sk_PKCS7_RECIP_INFO_delete_ptr(sk, ptr) ((PKCS7_RECIP_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr)))
+#define sk_PKCS7_RECIP_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
+#define sk_PKCS7_RECIP_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
+#define sk_PKCS7_RECIP_INFO_pop(sk) ((PKCS7_RECIP_INFO *)OPENSSL_sk_pop(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_shift(sk) ((PKCS7_RECIP_INFO *)OPENSSL_sk_shift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk),ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc))
+#define sk_PKCS7_RECIP_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), (idx))
+#define sk_PKCS7_RECIP_INFO_set(sk, idx, ptr) ((PKCS7_RECIP_INFO *)OPENSSL_sk_set(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (idx), ossl_check_PKCS7_RECIP_INFO_type(ptr)))
+#define sk_PKCS7_RECIP_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
+#define sk_PKCS7_RECIP_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
+#define sk_PKCS7_RECIP_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), pnum)
+#define sk_PKCS7_RECIP_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))
+#define sk_PKCS7_RECIP_INFO_dup(sk) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc)))
+#define sk_PKCS7_RECIP_INFO_set_cmp_func(sk, cmp) ((sk_PKCS7_RECIP_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)))
+
+
+
+typedef struct pkcs7_signed_st {
+    ASN1_INTEGER *version;      /* version 1 */
+    STACK_OF(X509_ALGOR) *md_algs; /* md used */
+    STACK_OF(X509) *cert;       /* [ 0 ] */
+    STACK_OF(X509_CRL) *crl;    /* [ 1 ] */
+    STACK_OF(PKCS7_SIGNER_INFO) *signer_info;
+    struct pkcs7_st *contents;
+} PKCS7_SIGNED;
+/*
+ * The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about
+ * merging the two
+ */
+
+typedef struct pkcs7_enc_content_st {
+    ASN1_OBJECT *content_type;
+    X509_ALGOR *algorithm;
+    ASN1_OCTET_STRING *enc_data; /* [ 0 ] */
+    const EVP_CIPHER *cipher;
+    const PKCS7_CTX *ctx;
+} PKCS7_ENC_CONTENT;
+
+typedef struct pkcs7_enveloped_st {
+    ASN1_INTEGER *version;      /* version 0 */
+    STACK_OF(PKCS7_RECIP_INFO) *recipientinfo;
+    PKCS7_ENC_CONTENT *enc_data;
+} PKCS7_ENVELOPE;
+
+typedef struct pkcs7_signedandenveloped_st {
+    ASN1_INTEGER *version;      /* version 1 */
+    STACK_OF(X509_ALGOR) *md_algs; /* md used */
+    STACK_OF(X509) *cert;       /* [ 0 ] */
+    STACK_OF(X509_CRL) *crl;    /* [ 1 ] */
+    STACK_OF(PKCS7_SIGNER_INFO) *signer_info;
+    PKCS7_ENC_CONTENT *enc_data;
+    STACK_OF(PKCS7_RECIP_INFO) *recipientinfo;
+} PKCS7_SIGN_ENVELOPE;
+
+typedef struct pkcs7_digest_st {
+    ASN1_INTEGER *version;      /* version 0 */
+    X509_ALGOR *md;             /* md used */
+    struct pkcs7_st *contents;
+    ASN1_OCTET_STRING *digest;
+} PKCS7_DIGEST;
+
+typedef struct pkcs7_encrypted_st {
+    ASN1_INTEGER *version;      /* version 0 */
+    PKCS7_ENC_CONTENT *enc_data;
+} PKCS7_ENCRYPT;
+
+typedef struct pkcs7_st {
+    /*
+     * The following is non NULL if it contains ASN1 encoding of this
+     * structure
+     */
+    unsigned char *asn1;
+    long length;
+# define PKCS7_S_HEADER  0
+# define PKCS7_S_BODY    1
+# define PKCS7_S_TAIL    2
+    int state;                  /* used during processing */
+    int detached;
+    ASN1_OBJECT *type;
+    /* content as defined by the type */
+    /*
+     * all encryption/message digests are applied to the 'contents', leaving
+     * out the 'type' field.
+     */
+    union {
+        char *ptr;
+        /* NID_pkcs7_data */
+        ASN1_OCTET_STRING *data;
+        /* NID_pkcs7_signed */
+        PKCS7_SIGNED *sign;
+        /* NID_pkcs7_enveloped */
+        PKCS7_ENVELOPE *enveloped;
+        /* NID_pkcs7_signedAndEnveloped */
+        PKCS7_SIGN_ENVELOPE *signed_and_enveloped;
+        /* NID_pkcs7_digest */
+        PKCS7_DIGEST *digest;
+        /* NID_pkcs7_encrypted */
+        PKCS7_ENCRYPT *encrypted;
+        /* Anything else */
+        ASN1_TYPE *other;
+    } d;
+    PKCS7_CTX ctx;
+} PKCS7;
+SKM_DEFINE_STACK_OF_INTERNAL(PKCS7, PKCS7, PKCS7)
+#define sk_PKCS7_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_sk_type(sk))
+#define sk_PKCS7_value(sk, idx) ((PKCS7 *)OPENSSL_sk_value(ossl_check_const_PKCS7_sk_type(sk), (idx)))
+#define sk_PKCS7_new(cmp) ((STACK_OF(PKCS7) *)OPENSSL_sk_new(ossl_check_PKCS7_compfunc_type(cmp)))
+#define sk_PKCS7_new_null() ((STACK_OF(PKCS7) *)OPENSSL_sk_new_null())
+#define sk_PKCS7_new_reserve(cmp, n) ((STACK_OF(PKCS7) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_compfunc_type(cmp), (n)))
+#define sk_PKCS7_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_sk_type(sk), (n))
+#define sk_PKCS7_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_sk_type(sk))
+#define sk_PKCS7_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_sk_type(sk))
+#define sk_PKCS7_delete(sk, i) ((PKCS7 *)OPENSSL_sk_delete(ossl_check_PKCS7_sk_type(sk), (i)))
+#define sk_PKCS7_delete_ptr(sk, ptr) ((PKCS7 *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr)))
+#define sk_PKCS7_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
+#define sk_PKCS7_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
+#define sk_PKCS7_pop(sk) ((PKCS7 *)OPENSSL_sk_pop(ossl_check_PKCS7_sk_type(sk)))
+#define sk_PKCS7_shift(sk) ((PKCS7 *)OPENSSL_sk_shift(ossl_check_PKCS7_sk_type(sk)))
+#define sk_PKCS7_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_sk_type(sk),ossl_check_PKCS7_freefunc_type(freefunc))
+#define sk_PKCS7_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), (idx))
+#define sk_PKCS7_set(sk, idx, ptr) ((PKCS7 *)OPENSSL_sk_set(ossl_check_PKCS7_sk_type(sk), (idx), ossl_check_PKCS7_type(ptr)))
+#define sk_PKCS7_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
+#define sk_PKCS7_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
+#define sk_PKCS7_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), pnum)
+#define sk_PKCS7_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_sk_type(sk))
+#define sk_PKCS7_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_sk_type(sk))
+#define sk_PKCS7_dup(sk) ((STACK_OF(PKCS7) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_sk_type(sk)))
+#define sk_PKCS7_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_sk_type(sk), ossl_check_PKCS7_copyfunc_type(copyfunc), ossl_check_PKCS7_freefunc_type(freefunc)))
+#define sk_PKCS7_set_cmp_func(sk, cmp) ((sk_PKCS7_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_compfunc_type(cmp)))
+
+
+
+# define PKCS7_OP_SET_DETACHED_SIGNATURE 1
+# define PKCS7_OP_GET_DETACHED_SIGNATURE 2
+
+# define PKCS7_get_signed_attributes(si) ((si)->auth_attr)
+# define PKCS7_get_attributes(si)        ((si)->unauth_attr)
+
+# define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed)
+# define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted)
+# define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped)
+# define PKCS7_type_is_signedAndEnveloped(a) \
+                (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped)
+# define PKCS7_type_is_data(a)   (OBJ_obj2nid((a)->type) == NID_pkcs7_data)
+# define PKCS7_type_is_digest(a)   (OBJ_obj2nid((a)->type) == NID_pkcs7_digest)
+
+# define PKCS7_set_detached(p,v) \
+                PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL)
+# define PKCS7_get_detached(p) \
+                PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL)
+
+# define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7))
+
+/* S/MIME related flags */
+
+# define PKCS7_TEXT              0x1
+# define PKCS7_NOCERTS           0x2
+# define PKCS7_NOSIGS            0x4
+# define PKCS7_NOCHAIN           0x8
+# define PKCS7_NOINTERN          0x10
+# define PKCS7_NOVERIFY          0x20
+# define PKCS7_DETACHED          0x40
+# define PKCS7_BINARY            0x80
+# define PKCS7_NOATTR            0x100
+# define PKCS7_NOSMIMECAP        0x200
+# define PKCS7_NOOLDMIMETYPE     0x400
+# define PKCS7_CRLFEOL           0x800
+# define PKCS7_STREAM            0x1000
+# define PKCS7_NOCRL             0x2000
+# define PKCS7_PARTIAL           0x4000
+# define PKCS7_REUSE_DIGEST      0x8000
+# define PKCS7_NO_DUAL_CONTENT   0x10000
+
+/* Flags: for compatibility with older code */
+
+# define SMIME_TEXT      PKCS7_TEXT
+# define SMIME_NOCERTS   PKCS7_NOCERTS
+# define SMIME_NOSIGS    PKCS7_NOSIGS
+# define SMIME_NOCHAIN   PKCS7_NOCHAIN
+# define SMIME_NOINTERN  PKCS7_NOINTERN
+# define SMIME_NOVERIFY  PKCS7_NOVERIFY
+# define SMIME_DETACHED  PKCS7_DETACHED
+# define SMIME_BINARY    PKCS7_BINARY
+# define SMIME_NOATTR    PKCS7_NOATTR
+
+/* CRLF ASCII canonicalisation */
+# define SMIME_ASCIICRLF         0x80000
+
+DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL)
+
+int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
+                                   const EVP_MD *type, unsigned char *md,
+                                   unsigned int *len);
+# ifndef OPENSSL_NO_STDIO
+PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7);
+int i2d_PKCS7_fp(FILE *fp, const PKCS7 *p7);
+# endif
+DECLARE_ASN1_DUP_FUNCTION(PKCS7)
+PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7);
+int i2d_PKCS7_bio(BIO *bp, const PKCS7 *p7);
+int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
+int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
+
+DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO)
+DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO)
+DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED)
+DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT)
+DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE)
+DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE)
+DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST)
+DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT)
+DECLARE_ASN1_FUNCTIONS(PKCS7)
+PKCS7 *PKCS7_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN)
+DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY)
+
+DECLARE_ASN1_NDEF_FUNCTION(PKCS7)
+DECLARE_ASN1_PRINT_FUNCTION(PKCS7)
+
+long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg);
+
+int PKCS7_type_is_other(PKCS7 *p7);
+int PKCS7_set_type(PKCS7 *p7, int type);
+int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other);
+int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data);
+int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
+                          const EVP_MD *dgst);
+int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si);
+int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i);
+int PKCS7_add_certificate(PKCS7 *p7, X509 *x509);
+int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509);
+int PKCS7_content_new(PKCS7 *p7, int nid);
+int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx,
+                     BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si);
+int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si,
+                          X509 *x509);
+
+BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio);
+int PKCS7_dataFinal(PKCS7 *p7, BIO *bio);
+BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert);
+
+PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509,
+                                       EVP_PKEY *pkey, const EVP_MD *dgst);
+X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si);
+int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md);
+STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7);
+
+PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509);
+void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
+                                 X509_ALGOR **pdig, X509_ALGOR **psig);
+void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc);
+int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri);
+int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509);
+int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher);
+int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7);
+
+PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx);
+ASN1_OCTET_STRING *PKCS7_get_octet_string(PKCS7 *p7);
+ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk);
+int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int type,
+                               void *data);
+int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
+                        void *value);
+ASN1_TYPE *PKCS7_get_attribute(const PKCS7_SIGNER_INFO *si, int nid);
+ASN1_TYPE *PKCS7_get_signed_attribute(const PKCS7_SIGNER_INFO *si, int nid);
+int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
+                                STACK_OF(X509_ATTRIBUTE) *sk);
+int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si,
+                         STACK_OF(X509_ATTRIBUTE) *sk);
+
+PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
+                  BIO *data, int flags);
+PKCS7 *PKCS7_sign_ex(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
+                     BIO *data, int flags, OSSL_LIB_CTX *libctx,
+                     const char *propq);
+
+PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7,
+                                         X509 *signcert, EVP_PKEY *pkey,
+                                         const EVP_MD *md, int flags);
+
+int PKCS7_final(PKCS7 *p7, BIO *data, int flags);
+int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store,
+                 BIO *indata, BIO *out, int flags);
+STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs,
+                                   int flags);
+PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher,
+                     int flags);
+PKCS7 *PKCS7_encrypt_ex(STACK_OF(X509) *certs, BIO *in,
+                        const EVP_CIPHER *cipher, int flags,
+                        OSSL_LIB_CTX *libctx, const char *propq);
+int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data,
+                  int flags);
+
+int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si,
+                              STACK_OF(X509_ALGOR) *cap);
+STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si);
+int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg);
+
+int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid);
+int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t);
+int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si,
+                             const unsigned char *md, int mdlen);
+
+int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags);
+PKCS7 *SMIME_read_PKCS7_ex(BIO *bio, BIO **bcont, PKCS7 **p7);
+PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont);
+
+BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/pkcs7err.h b/CAPI/cpp/grpc/include/openssl/pkcs7err.h
new file mode 100644
index 0000000..ceb1a50
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/pkcs7err.h
@@ -0,0 +1,63 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PKCS7ERR_H
+# define OPENSSL_PKCS7ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PKCS7 reason codes.
+ */
+# define PKCS7_R_CERTIFICATE_VERIFY_ERROR                 117
+# define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER          144
+# define PKCS7_R_CIPHER_NOT_INITIALIZED                   116
+# define PKCS7_R_CONTENT_AND_DATA_PRESENT                 118
+# define PKCS7_R_CTRL_ERROR                               152
+# define PKCS7_R_DECRYPT_ERROR                            119
+# define PKCS7_R_DIGEST_FAILURE                           101
+# define PKCS7_R_ENCRYPTION_CTRL_FAILURE                  149
+# define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150
+# define PKCS7_R_ERROR_ADDING_RECIPIENT                   120
+# define PKCS7_R_ERROR_SETTING_CIPHER                     121
+# define PKCS7_R_INVALID_NULL_POINTER                     143
+# define PKCS7_R_INVALID_SIGNED_DATA_TYPE                 155
+# define PKCS7_R_NO_CONTENT                               122
+# define PKCS7_R_NO_DEFAULT_DIGEST                        151
+# define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND            154
+# define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE         115
+# define PKCS7_R_NO_SIGNATURES_ON_DATA                    123
+# define PKCS7_R_NO_SIGNERS                               142
+# define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE     104
+# define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR                124
+# define PKCS7_R_PKCS7_ADD_SIGNER_ERROR                   153
+# define PKCS7_R_PKCS7_DATASIGN                           145
+# define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE   127
+# define PKCS7_R_SIGNATURE_FAILURE                        105
+# define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND             128
+# define PKCS7_R_SIGNING_CTRL_FAILURE                     147
+# define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE  148
+# define PKCS7_R_SMIME_TEXT_ERROR                         129
+# define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE               106
+# define PKCS7_R_UNABLE_TO_FIND_MEM_BIO                   107
+# define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST            108
+# define PKCS7_R_UNKNOWN_DIGEST_TYPE                      109
+# define PKCS7_R_UNKNOWN_OPERATION                        110
+# define PKCS7_R_UNSUPPORTED_CIPHER_TYPE                  111
+# define PKCS7_R_UNSUPPORTED_CONTENT_TYPE                 112
+# define PKCS7_R_WRONG_CONTENT_TYPE                       113
+# define PKCS7_R_WRONG_PKCS7_TYPE                         114
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/prov_ssl.h b/CAPI/cpp/grpc/include/openssl/prov_ssl.h
new file mode 100644
index 0000000..d3e0896
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/prov_ssl.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PROV_SSL_H
+# define OPENSSL_PROV_SSL_H
+# pragma once
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* SSL/TLS related defines useful to providers */
+
+# define SSL_MAX_MASTER_KEY_LENGTH 48
+
+# define SSL3_VERSION                    0x0300
+# define TLS1_VERSION                    0x0301
+# define TLS1_1_VERSION                  0x0302
+# define TLS1_2_VERSION                  0x0303
+# define TLS1_3_VERSION                  0x0304
+# define DTLS1_VERSION                   0xFEFF
+# define DTLS1_2_VERSION                 0xFEFD
+# define DTLS1_BAD_VER                   0x0100
+
+# ifdef __cplusplus
+}
+# endif
+#endif /* OPENSSL_PROV_SSL_H */
diff --git a/CAPI/cpp/grpc/include/openssl/proverr.h b/CAPI/cpp/grpc/include/openssl/proverr.h
new file mode 100644
index 0000000..ad67a8f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/proverr.h
@@ -0,0 +1,148 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PROVERR_H
+# define OPENSSL_PROVERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PROV reason codes.
+ */
+# define PROV_R_ADDITIONAL_INPUT_TOO_LONG                 184
+# define PROV_R_ALGORITHM_MISMATCH                        173
+# define PROV_R_ALREADY_INSTANTIATED                      185
+# define PROV_R_BAD_DECRYPT                               100
+# define PROV_R_BAD_ENCODING                              141
+# define PROV_R_BAD_LENGTH                                142
+# define PROV_R_BAD_TLS_CLIENT_VERSION                    161
+# define PROV_R_BN_ERROR                                  160
+# define PROV_R_CIPHER_OPERATION_FAILED                   102
+# define PROV_R_DERIVATION_FUNCTION_INIT_FAILED           205
+# define PROV_R_DIGEST_NOT_ALLOWED                        174
+# define PROV_R_ENTROPY_SOURCE_STRENGTH_TOO_WEAK          186
+# define PROV_R_ERROR_INSTANTIATING_DRBG                  188
+# define PROV_R_ERROR_RETRIEVING_ENTROPY                  189
+# define PROV_R_ERROR_RETRIEVING_NONCE                    190
+# define PROV_R_FAILED_DURING_DERIVATION                  164
+# define PROV_R_FAILED_TO_CREATE_LOCK                     180
+# define PROV_R_FAILED_TO_DECRYPT                         162
+# define PROV_R_FAILED_TO_GENERATE_KEY                    121
+# define PROV_R_FAILED_TO_GET_PARAMETER                   103
+# define PROV_R_FAILED_TO_SET_PARAMETER                   104
+# define PROV_R_FAILED_TO_SIGN                            175
+# define PROV_R_FIPS_MODULE_CONDITIONAL_ERROR             227
+# define PROV_R_FIPS_MODULE_ENTERING_ERROR_STATE          224
+# define PROV_R_FIPS_MODULE_IN_ERROR_STATE                225
+# define PROV_R_GENERATE_ERROR                            191
+# define PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE       165
+# define PROV_R_INDICATOR_INTEGRITY_FAILURE               210
+# define PROV_R_INSUFFICIENT_DRBG_STRENGTH                181
+# define PROV_R_INVALID_AAD                               108
+# define PROV_R_INVALID_CONFIG_DATA                       211
+# define PROV_R_INVALID_CONSTANT_LENGTH                   157
+# define PROV_R_INVALID_CURVE                             176
+# define PROV_R_INVALID_CUSTOM_LENGTH                     111
+# define PROV_R_INVALID_DATA                              115
+# define PROV_R_INVALID_DIGEST                            122
+# define PROV_R_INVALID_DIGEST_LENGTH                     166
+# define PROV_R_INVALID_DIGEST_SIZE                       218
+# define PROV_R_INVALID_INPUT_LENGTH                      230
+# define PROV_R_INVALID_ITERATION_COUNT                   123
+# define PROV_R_INVALID_IV_LENGTH                         109
+# define PROV_R_INVALID_KEY                               158
+# define PROV_R_INVALID_KEY_LENGTH                        105
+# define PROV_R_INVALID_MAC                               151
+# define PROV_R_INVALID_MGF1_MD                           167
+# define PROV_R_INVALID_MODE                              125
+# define PROV_R_INVALID_OUTPUT_LENGTH                     217
+# define PROV_R_INVALID_PADDING_MODE                      168
+# define PROV_R_INVALID_PUBINFO                           198
+# define PROV_R_INVALID_SALT_LENGTH                       112
+# define PROV_R_INVALID_SEED_LENGTH                       154
+# define PROV_R_INVALID_SIGNATURE_SIZE                    179
+# define PROV_R_INVALID_STATE                             212
+# define PROV_R_INVALID_TAG                               110
+# define PROV_R_INVALID_TAG_LENGTH                        118
+# define PROV_R_INVALID_UKM_LENGTH                        200
+# define PROV_R_INVALID_X931_DIGEST                       170
+# define PROV_R_IN_ERROR_STATE                            192
+# define PROV_R_KEY_SETUP_FAILED                          101
+# define PROV_R_KEY_SIZE_TOO_SMALL                        171
+# define PROV_R_LENGTH_TOO_LARGE                          202
+# define PROV_R_MISMATCHING_DOMAIN_PARAMETERS             203
+# define PROV_R_MISSING_CEK_ALG                           144
+# define PROV_R_MISSING_CIPHER                            155
+# define PROV_R_MISSING_CONFIG_DATA                       213
+# define PROV_R_MISSING_CONSTANT                          156
+# define PROV_R_MISSING_KEY                               128
+# define PROV_R_MISSING_MAC                               150
+# define PROV_R_MISSING_MESSAGE_DIGEST                    129
+# define PROV_R_MISSING_OID                               209
+# define PROV_R_MISSING_PASS                              130
+# define PROV_R_MISSING_SALT                              131
+# define PROV_R_MISSING_SECRET                            132
+# define PROV_R_MISSING_SEED                              140
+# define PROV_R_MISSING_SESSION_ID                        133
+# define PROV_R_MISSING_TYPE                              134
+# define PROV_R_MISSING_XCGHASH                           135
+# define PROV_R_MODULE_INTEGRITY_FAILURE                  214
+# define PROV_R_NOT_A_PRIVATE_KEY                         221
+# define PROV_R_NOT_A_PUBLIC_KEY                          220
+# define PROV_R_NOT_INSTANTIATED                          193
+# define PROV_R_NOT_PARAMETERS                            226
+# define PROV_R_NOT_SUPPORTED                             136
+# define PROV_R_NOT_XOF_OR_INVALID_LENGTH                 113
+# define PROV_R_NO_KEY_SET                                114
+# define PROV_R_NO_PARAMETERS_SET                         177
+# define PROV_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE  178
+# define PROV_R_OUTPUT_BUFFER_TOO_SMALL                   106
+# define PROV_R_PARENT_CANNOT_GENERATE_RANDOM_NUMBERS     228
+# define PROV_R_PARENT_CANNOT_SUPPLY_ENTROPY_SEED         187
+# define PROV_R_PARENT_LOCKING_NOT_ENABLED                182
+# define PROV_R_PARENT_STRENGTH_TOO_WEAK                  194
+# define PROV_R_PATH_MUST_BE_ABSOLUTE                     219
+# define PROV_R_PERSONALISATION_STRING_TOO_LONG           195
+# define PROV_R_PSS_SALTLEN_TOO_SMALL                     172
+# define PROV_R_REQUEST_TOO_LARGE_FOR_DRBG                196
+# define PROV_R_REQUIRE_CTR_MODE_CIPHER                   206
+# define PROV_R_RESEED_ERROR                              197
+# define PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES     222
+# define PROV_R_SEED_SOURCES_MUST_NOT_HAVE_A_PARENT       229
+# define PROV_R_SELF_TEST_KAT_FAILURE                     215
+# define PROV_R_SELF_TEST_POST_FAILURE                    216
+# define PROV_R_TAG_NOT_NEEDED                            120
+# define PROV_R_TAG_NOT_SET                               119
+# define PROV_R_TOO_MANY_RECORDS                          126
+# define PROV_R_UNABLE_TO_FIND_CIPHERS                    207
+# define PROV_R_UNABLE_TO_GET_PARENT_STRENGTH             199
+# define PROV_R_UNABLE_TO_GET_PASSPHRASE                  159
+# define PROV_R_UNABLE_TO_INITIALISE_CIPHERS              208
+# define PROV_R_UNABLE_TO_LOAD_SHA256                     147
+# define PROV_R_UNABLE_TO_LOCK_PARENT                     201
+# define PROV_R_UNABLE_TO_RESEED                          204
+# define PROV_R_UNSUPPORTED_CEK_ALG                       145
+# define PROV_R_UNSUPPORTED_KEY_SIZE                      153
+# define PROV_R_UNSUPPORTED_MAC_TYPE                      137
+# define PROV_R_UNSUPPORTED_NUMBER_OF_ROUNDS              152
+# define PROV_R_URI_AUTHORITY_UNSUPPORTED                 223
+# define PROV_R_VALUE_ERROR                               138
+# define PROV_R_WRONG_FINAL_BLOCK_LENGTH                  107
+# define PROV_R_WRONG_OUTPUT_BUFFER_SIZE                  139
+# define PROV_R_XOF_DIGESTS_NOT_ALLOWED                   183
+# define PROV_R_XTS_DATA_UNIT_IS_TOO_LARGE                148
+# define PROV_R_XTS_DUPLICATED_KEYS                       149
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/provider.h b/CAPI/cpp/grpc/include/openssl/provider.h
new file mode 100644
index 0000000..dc86ff5
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/provider.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PROVIDER_H
+# define OPENSSL_PROVIDER_H
+# pragma once
+
+# include <openssl/core.h>
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* Set the default provider search path */
+int OSSL_PROVIDER_set_default_search_path(OSSL_LIB_CTX *, const char *path);
+
+/* Load and unload a provider */
+OSSL_PROVIDER *OSSL_PROVIDER_load(OSSL_LIB_CTX *, const char *name);
+OSSL_PROVIDER *OSSL_PROVIDER_try_load(OSSL_LIB_CTX *, const char *name,
+                                      int retain_fallbacks);
+int OSSL_PROVIDER_unload(OSSL_PROVIDER *prov);
+int OSSL_PROVIDER_available(OSSL_LIB_CTX *, const char *name);
+int OSSL_PROVIDER_do_all(OSSL_LIB_CTX *ctx,
+                         int (*cb)(OSSL_PROVIDER *provider, void *cbdata),
+                         void *cbdata);
+
+const OSSL_PARAM *OSSL_PROVIDER_gettable_params(const OSSL_PROVIDER *prov);
+int OSSL_PROVIDER_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[]);
+int OSSL_PROVIDER_self_test(const OSSL_PROVIDER *prov);
+int OSSL_PROVIDER_get_capabilities(const OSSL_PROVIDER *prov,
+                                   const char *capability,
+                                   OSSL_CALLBACK *cb,
+                                   void *arg);
+
+const OSSL_ALGORITHM *OSSL_PROVIDER_query_operation(const OSSL_PROVIDER *prov,
+                                                    int operation_id,
+                                                    int *no_cache);
+void OSSL_PROVIDER_unquery_operation(const OSSL_PROVIDER *prov,
+                                     int operation_id, const OSSL_ALGORITHM *algs);
+void *OSSL_PROVIDER_get0_provider_ctx(const OSSL_PROVIDER *prov);
+const OSSL_DISPATCH *OSSL_PROVIDER_get0_dispatch(const OSSL_PROVIDER *prov);
+
+/* Add a built in providers */
+int OSSL_PROVIDER_add_builtin(OSSL_LIB_CTX *, const char *name,
+                              OSSL_provider_init_fn *init_fn);
+
+/* Information */
+const char *OSSL_PROVIDER_get0_name(const OSSL_PROVIDER *prov);
+
+# ifdef __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/rand.h b/CAPI/cpp/grpc/include/openssl/rand.h
new file mode 100644
index 0000000..ad3054f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/rand.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RAND_H
+# define OPENSSL_RAND_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RAND_H
+# endif
+
+# include <stdlib.h>
+# include <openssl/types.h>
+# include <openssl/e_os2.h>
+# include <openssl/randerr.h>
+# include <openssl/evp.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Default security strength (in the sense of [NIST SP 800-90Ar1])
+ *
+ * NIST SP 800-90Ar1 supports the strength of the DRBG being smaller than that
+ * of the cipher by collecting less entropy. The current DRBG implementation
+ * does not take RAND_DRBG_STRENGTH into account and sets the strength of the
+ * DRBG to that of the cipher.
+ */
+# define RAND_DRBG_STRENGTH             256
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+struct rand_meth_st {
+    int (*seed) (const void *buf, int num);
+    int (*bytes) (unsigned char *buf, int num);
+    void (*cleanup) (void);
+    int (*add) (const void *buf, int num, double randomness);
+    int (*pseudorand) (unsigned char *buf, int num);
+    int (*status) (void);
+};
+
+OSSL_DEPRECATEDIN_3_0 int RAND_set_rand_method(const RAND_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const RAND_METHOD *RAND_get_rand_method(void);
+#  ifndef OPENSSL_NO_ENGINE
+OSSL_DEPRECATEDIN_3_0 int RAND_set_rand_engine(ENGINE *engine);
+#  endif
+
+OSSL_DEPRECATEDIN_3_0 RAND_METHOD *RAND_OpenSSL(void);
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#   define RAND_cleanup() while(0) continue
+# endif
+int RAND_bytes(unsigned char *buf, int num);
+int RAND_priv_bytes(unsigned char *buf, int num);
+
+/*
+ * Equivalent of RAND_priv_bytes() but additionally taking an OSSL_LIB_CTX and
+ * a strength.
+ */
+int RAND_priv_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, size_t num,
+                       unsigned int strength);
+
+/*
+ * Equivalent of RAND_bytes() but additionally taking an OSSL_LIB_CTX and
+ * a strength.
+ */
+int RAND_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, size_t num,
+                  unsigned int strength);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 int RAND_pseudo_bytes(unsigned char *buf, int num);
+# endif
+
+EVP_RAND_CTX *RAND_get0_primary(OSSL_LIB_CTX *ctx);
+EVP_RAND_CTX *RAND_get0_public(OSSL_LIB_CTX *ctx);
+EVP_RAND_CTX *RAND_get0_private(OSSL_LIB_CTX *ctx);
+
+int RAND_set_DRBG_type(OSSL_LIB_CTX *ctx, const char *drbg, const char *propq,
+                       const char *cipher, const char *digest);
+int RAND_set_seed_source_type(OSSL_LIB_CTX *ctx, const char *seed,
+                              const char *propq);
+
+void RAND_seed(const void *buf, int num);
+void RAND_keep_random_devices_open(int keep);
+
+# if defined(__ANDROID__) && defined(__NDK_FPABI__)
+__NDK_FPABI__   /* __attribute__((pcs("aapcs"))) on ARM */
+# endif
+void RAND_add(const void *buf, int num, double randomness);
+int RAND_load_file(const char *file, long max_bytes);
+int RAND_write_file(const char *file);
+const char *RAND_file_name(char *file, size_t num);
+int RAND_status(void);
+
+# ifndef OPENSSL_NO_EGD
+int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes);
+int RAND_egd(const char *path);
+int RAND_egd_bytes(const char *path, int bytes);
+# endif
+
+int RAND_poll(void);
+
+# if defined(_WIN32) && (defined(BASETYPES) || defined(_WINDEF_H))
+/* application has to include <windows.h> in order to use these */
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void RAND_screen(void);
+OSSL_DEPRECATEDIN_1_1_0 int RAND_event(UINT, WPARAM, LPARAM);
+#  endif
+# endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/randerr.h b/CAPI/cpp/grpc/include/openssl/randerr.h
new file mode 100644
index 0000000..b5e08e4
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/randerr.h
@@ -0,0 +1,68 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RANDERR_H
+# define OPENSSL_RANDERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * RAND reason codes.
+ */
+# define RAND_R_ADDITIONAL_INPUT_TOO_LONG                 102
+# define RAND_R_ALREADY_INSTANTIATED                      103
+# define RAND_R_ARGUMENT_OUT_OF_RANGE                     105
+# define RAND_R_CANNOT_OPEN_FILE                          121
+# define RAND_R_DRBG_ALREADY_INITIALIZED                  129
+# define RAND_R_DRBG_NOT_INITIALISED                      104
+# define RAND_R_ENTROPY_INPUT_TOO_LONG                    106
+# define RAND_R_ENTROPY_OUT_OF_RANGE                      124
+# define RAND_R_ERROR_ENTROPY_POOL_WAS_IGNORED            127
+# define RAND_R_ERROR_INITIALISING_DRBG                   107
+# define RAND_R_ERROR_INSTANTIATING_DRBG                  108
+# define RAND_R_ERROR_RETRIEVING_ADDITIONAL_INPUT         109
+# define RAND_R_ERROR_RETRIEVING_ENTROPY                  110
+# define RAND_R_ERROR_RETRIEVING_NONCE                    111
+# define RAND_R_FAILED_TO_CREATE_LOCK                     126
+# define RAND_R_FUNC_NOT_IMPLEMENTED                      101
+# define RAND_R_FWRITE_ERROR                              123
+# define RAND_R_GENERATE_ERROR                            112
+# define RAND_R_INSUFFICIENT_DRBG_STRENGTH                139
+# define RAND_R_INTERNAL_ERROR                            113
+# define RAND_R_IN_ERROR_STATE                            114
+# define RAND_R_NOT_A_REGULAR_FILE                        122
+# define RAND_R_NOT_INSTANTIATED                          115
+# define RAND_R_NO_DRBG_IMPLEMENTATION_SELECTED           128
+# define RAND_R_PARENT_LOCKING_NOT_ENABLED                130
+# define RAND_R_PARENT_STRENGTH_TOO_WEAK                  131
+# define RAND_R_PERSONALISATION_STRING_TOO_LONG           116
+# define RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED       133
+# define RAND_R_PRNG_NOT_SEEDED                           100
+# define RAND_R_RANDOM_POOL_OVERFLOW                      125
+# define RAND_R_RANDOM_POOL_UNDERFLOW                     134
+# define RAND_R_REQUEST_TOO_LARGE_FOR_DRBG                117
+# define RAND_R_RESEED_ERROR                              118
+# define RAND_R_SELFTEST_FAILURE                          119
+# define RAND_R_TOO_LITTLE_NONCE_REQUESTED                135
+# define RAND_R_TOO_MUCH_NONCE_REQUESTED                  136
+# define RAND_R_UNABLE_TO_CREATE_DRBG                     143
+# define RAND_R_UNABLE_TO_FETCH_DRBG                      144
+# define RAND_R_UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER  141
+# define RAND_R_UNABLE_TO_GET_PARENT_STRENGTH             138
+# define RAND_R_UNABLE_TO_LOCK_PARENT                     140
+# define RAND_R_UNSUPPORTED_DRBG_FLAGS                    132
+# define RAND_R_UNSUPPORTED_DRBG_TYPE                     120
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/rc2.h b/CAPI/cpp/grpc/include/openssl/rc2.h
new file mode 100644
index 0000000..ff633fd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/rc2.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RC2_H
+# define OPENSSL_RC2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RC2_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_RC2
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define RC2_BLOCK       8
+#  define RC2_KEY_LENGTH  16
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef unsigned int RC2_INT;
+
+#   define RC2_ENCRYPT     1
+#   define RC2_DECRYPT     0
+
+typedef struct rc2_key_st {
+    RC2_INT data[64];
+} RC2_KEY;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 void RC2_set_key(RC2_KEY *key, int len,
+                                       const unsigned char *data, int bits);
+OSSL_DEPRECATEDIN_3_0 void RC2_ecb_encrypt(const unsigned char *in,
+                                           unsigned char *out, RC2_KEY *key,
+                                           int enc);
+OSSL_DEPRECATEDIN_3_0 void RC2_encrypt(unsigned long *data, RC2_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void RC2_decrypt(unsigned long *data, RC2_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void RC2_cbc_encrypt(const unsigned char *in,
+                                           unsigned char *out, long length,
+                                           RC2_KEY *ks, unsigned char *iv,
+                                           int enc);
+OSSL_DEPRECATEDIN_3_0 void RC2_cfb64_encrypt(const unsigned char *in,
+                                             unsigned char *out, long length,
+                                             RC2_KEY *schedule,
+                                             unsigned char *ivec,
+                                             int *num, int enc);
+OSSL_DEPRECATEDIN_3_0 void RC2_ofb64_encrypt(const unsigned char *in,
+                                             unsigned char *out, long length,
+                                             RC2_KEY *schedule,
+                                             unsigned char *ivec,
+                                             int *num);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/rc4.h b/CAPI/cpp/grpc/include/openssl/rc4.h
new file mode 100644
index 0000000..600b288
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/rc4.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RC4_H
+# define OPENSSL_RC4_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RC4_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_RC4
+#  include <stddef.h>
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct rc4_key_st {
+    RC4_INT x, y;
+    RC4_INT data[256];
+} RC4_KEY;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 const char *RC4_options(void);
+OSSL_DEPRECATEDIN_3_0 void RC4_set_key(RC4_KEY *key, int len,
+                                       const unsigned char *data);
+OSSL_DEPRECATEDIN_3_0 void RC4(RC4_KEY *key, size_t len,
+                               const unsigned char *indata,
+                               unsigned char *outdata);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/rc5.h b/CAPI/cpp/grpc/include/openssl/rc5.h
new file mode 100644
index 0000000..de83352
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/rc5.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RC5_H
+# define OPENSSL_RC5_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RC5_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_RC5
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define RC5_32_BLOCK            8
+#  define RC5_32_KEY_LENGTH       16/* This is a default, max is 255 */
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define RC5_ENCRYPT     1
+#   define RC5_DECRYPT     0
+
+#   define RC5_32_INT unsigned int
+
+/*
+ * This are the only values supported.  Tweak the code if you want more The
+ * most supported modes will be RC5-32/12/16 RC5-32/16/8
+ */
+#   define RC5_8_ROUNDS    8
+#   define RC5_12_ROUNDS   12
+#   define RC5_16_ROUNDS   16
+
+typedef struct rc5_key_st {
+    /* Number of rounds */
+    int rounds;
+    RC5_32_INT data[2 * (RC5_16_ROUNDS + 1)];
+} RC5_32_KEY;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int RC5_32_set_key(RC5_32_KEY *key, int len,
+                                         const unsigned char *data,
+                                         int rounds);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_ecb_encrypt(const unsigned char *in,
+                                              unsigned char *out,
+                                              RC5_32_KEY *key,
+                                              int enc);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_encrypt(unsigned long *data, RC5_32_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_decrypt(unsigned long *data, RC5_32_KEY *key);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_cbc_encrypt(const unsigned char *in,
+                                              unsigned char *out, long length,
+                                              RC5_32_KEY *ks, unsigned char *iv,
+                                              int enc);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_cfb64_encrypt(const unsigned char *in,
+                                                unsigned char *out, long length,
+                                                RC5_32_KEY *schedule,
+                                                unsigned char *ivec, int *num,
+                                                int enc);
+OSSL_DEPRECATEDIN_3_0 void RC5_32_ofb64_encrypt(const unsigned char *in,
+                                                unsigned char *out, long length,
+                                                RC5_32_KEY *schedule,
+                                                unsigned char *ivec, int *num);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ripemd.h b/CAPI/cpp/grpc/include/openssl/ripemd.h
new file mode 100644
index 0000000..900ee31
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ripemd.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RIPEMD_H
+# define OPENSSL_RIPEMD_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RIPEMD_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_RMD160
+#  include <openssl/e_os2.h>
+#  include <stddef.h>
+
+#  define RIPEMD160_DIGEST_LENGTH 20
+
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#   define RIPEMD160_LONG unsigned int
+
+#   define RIPEMD160_CBLOCK        64
+#   define RIPEMD160_LBLOCK        (RIPEMD160_CBLOCK/4)
+
+typedef struct RIPEMD160state_st {
+    RIPEMD160_LONG A, B, C, D, E;
+    RIPEMD160_LONG Nl, Nh;
+    RIPEMD160_LONG data[RIPEMD160_LBLOCK];
+    unsigned int num;
+} RIPEMD160_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Init(RIPEMD160_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data,
+                                           size_t len);
+OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *RIPEMD160(const unsigned char *d, size_t n,
+                                               unsigned char *md);
+OSSL_DEPRECATEDIN_3_0 void RIPEMD160_Transform(RIPEMD160_CTX *c,
+                                               const unsigned char *b);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/rsa.h b/CAPI/cpp/grpc/include/openssl/rsa.h
new file mode 100644
index 0000000..a55c972
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/rsa.h
@@ -0,0 +1,604 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RSA_H
+# define OPENSSL_RSA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_RSA_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# include <openssl/asn1.h>
+# include <openssl/bio.h>
+# include <openssl/crypto.h>
+# include <openssl/types.h>
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/bn.h>
+# endif
+# include <openssl/rsaerr.h>
+# include <openssl/safestack.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_RSA_MAX_MODULUS_BITS
+#  define OPENSSL_RSA_MAX_MODULUS_BITS   16384
+# endif
+
+# define RSA_3   0x3L
+# define RSA_F4  0x10001L
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/* The types RSA and RSA_METHOD are defined in ossl_typ.h */
+
+#  define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS 2048
+
+#  ifndef OPENSSL_RSA_SMALL_MODULUS_BITS
+#   define OPENSSL_RSA_SMALL_MODULUS_BITS 3072
+#  endif
+
+/* exponent limit enforced for "large" modulus only */
+#  ifndef OPENSSL_RSA_MAX_PUBEXP_BITS
+#   define OPENSSL_RSA_MAX_PUBEXP_BITS    64
+#  endif
+/* based on RFC 8017 appendix A.1.2 */
+#  define RSA_ASN1_VERSION_DEFAULT        0
+#  define RSA_ASN1_VERSION_MULTI          1
+
+#  define RSA_DEFAULT_PRIME_NUM           2
+
+#  define RSA_METHOD_FLAG_NO_CHECK        0x0001
+#  define RSA_FLAG_CACHE_PUBLIC           0x0002
+#  define RSA_FLAG_CACHE_PRIVATE          0x0004
+#  define RSA_FLAG_BLINDING               0x0008
+#  define RSA_FLAG_THREAD_SAFE            0x0010
+/*
+ * This flag means the private key operations will be handled by rsa_mod_exp
+ * and that they do not depend on the private key components being present:
+ * for example a key stored in external hardware. Without this flag
+ * bn_mod_exp gets called when private key components are absent.
+ */
+#  define RSA_FLAG_EXT_PKEY               0x0020
+
+/*
+ * new with 0.9.6j and 0.9.7b; the built-in
+ * RSA implementation now uses blinding by
+ * default (ignoring RSA_FLAG_BLINDING),
+ * but other engines might not need it
+ */
+#  define RSA_FLAG_NO_BLINDING            0x0080
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+/*
+ * Does nothing. Previously this switched off constant time behaviour.
+ */
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define RSA_FLAG_NO_CONSTTIME           0x0000
+# endif
+/* deprecated name for the flag*/
+/*
+ * new with 0.9.7h; the built-in RSA
+ * implementation now uses constant time
+ * modular exponentiation for secret exponents
+ * by default. This flag causes the
+ * faster variable sliding window method to
+ * be used for all exponents.
+ */
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+#  define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME
+# endif
+
+/*-
+ * New with 3.0: use part of the flags to denote exact type of RSA key,
+ * some of which are limited to specific signature and encryption schemes.
+ * These different types share the same RSA structure, but indicate the
+ * use of certain fields in that structure.
+ * Currently known are:
+ * RSA          - this is the "normal" unlimited RSA structure (typenum 0)
+ * RSASSA-PSS   - indicates that the PSS parameters are used.
+ * RSAES-OAEP   - no specific field used for the moment, but OAEP padding
+ *                is expected.  (currently unused)
+ *
+ * 4 bits allow for 16 types
+ */
+# define RSA_FLAG_TYPE_MASK            0xF000
+# define RSA_FLAG_TYPE_RSA             0x0000
+# define RSA_FLAG_TYPE_RSASSAPSS       0x1000
+# define RSA_FLAG_TYPE_RSAESOAEP       0x2000
+
+int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *ctx, int pad_mode);
+int EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX *ctx, int *pad_mode);
+
+int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int saltlen);
+int EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int *saltlen);
+
+int EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX *ctx, int bits);
+int EVP_PKEY_CTX_set1_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
+int EVP_PKEY_CTX_set_rsa_keygen_primes(EVP_PKEY_CTX *ctx, int primes);
+int EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(EVP_PKEY_CTX *ctx, int saltlen);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
+# endif
+
+/* Salt length matches digest */
+# define RSA_PSS_SALTLEN_DIGEST -1
+/* Verify only: auto detect salt length */
+# define RSA_PSS_SALTLEN_AUTO   -2
+/* Set salt length to maximum possible */
+# define RSA_PSS_SALTLEN_MAX    -3
+/* Old compatible max salt length for sign only */
+# define RSA_PSS_SALTLEN_MAX_SIGN    -2
+
+int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_set_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
+                                      const char *mdprops);
+int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+int EVP_PKEY_CTX_get_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, char *name,
+                                      size_t namelen);
+int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md_name(EVP_PKEY_CTX *ctx,
+                                                 const char *mdname);
+
+int EVP_PKEY_CTX_set_rsa_pss_keygen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_set_rsa_pss_keygen_md_name(EVP_PKEY_CTX *ctx,
+                                            const char *mdname,
+                                            const char *mdprops);
+
+int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+int EVP_PKEY_CTX_set_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
+                                      const char *mdprops);
+int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
+int EVP_PKEY_CTX_get_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, char *name,
+                                      size_t namelen);
+int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX *ctx, void *label, int llen);
+int EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX *ctx, unsigned char **label);
+
+# define EVP_PKEY_CTRL_RSA_PADDING       (EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_RSA_PSS_SALTLEN   (EVP_PKEY_ALG_CTRL + 2)
+
+# define EVP_PKEY_CTRL_RSA_KEYGEN_BITS   (EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_RSA_MGF1_MD       (EVP_PKEY_ALG_CTRL + 5)
+
+# define EVP_PKEY_CTRL_GET_RSA_PADDING           (EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN       (EVP_PKEY_ALG_CTRL + 7)
+# define EVP_PKEY_CTRL_GET_RSA_MGF1_MD           (EVP_PKEY_ALG_CTRL + 8)
+
+# define EVP_PKEY_CTRL_RSA_OAEP_MD       (EVP_PKEY_ALG_CTRL + 9)
+# define EVP_PKEY_CTRL_RSA_OAEP_LABEL    (EVP_PKEY_ALG_CTRL + 10)
+
+# define EVP_PKEY_CTRL_GET_RSA_OAEP_MD   (EVP_PKEY_ALG_CTRL + 11)
+# define EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 12)
+
+# define EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES  (EVP_PKEY_ALG_CTRL + 13)
+
+# define RSA_PKCS1_PADDING          1
+# define RSA_NO_PADDING             3
+# define RSA_PKCS1_OAEP_PADDING     4
+# define RSA_X931_PADDING           5
+
+/* EVP_PKEY_ only */
+# define RSA_PKCS1_PSS_PADDING      6
+# define RSA_PKCS1_WITH_TLS_PADDING 7
+
+# define RSA_PKCS1_PADDING_SIZE    11
+
+# define RSA_set_app_data(s,arg)         RSA_set_ex_data(s,0,arg)
+# define RSA_get_app_data(s)             RSA_get_ex_data(s,0)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 RSA *RSA_new(void);
+OSSL_DEPRECATEDIN_3_0 RSA *RSA_new_method(ENGINE *engine);
+OSSL_DEPRECATEDIN_3_0 int RSA_bits(const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 int RSA_size(const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 int RSA_security_bits(const RSA *rsa);
+
+OSSL_DEPRECATEDIN_3_0 int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d);
+OSSL_DEPRECATEDIN_3_0 int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q);
+OSSL_DEPRECATEDIN_3_0 int RSA_set0_crt_params(RSA *r,
+                                              BIGNUM *dmp1, BIGNUM *dmq1,
+                                              BIGNUM *iqmp);
+OSSL_DEPRECATEDIN_3_0 int RSA_set0_multi_prime_params(RSA *r,
+                                                      BIGNUM *primes[],
+                                                      BIGNUM *exps[],
+                                                      BIGNUM *coeffs[],
+                                                      int pnum);
+OSSL_DEPRECATEDIN_3_0 void RSA_get0_key(const RSA *r,
+                                        const BIGNUM **n, const BIGNUM **e,
+                                        const BIGNUM **d);
+OSSL_DEPRECATEDIN_3_0 void RSA_get0_factors(const RSA *r,
+                                            const BIGNUM **p, const BIGNUM **q);
+OSSL_DEPRECATEDIN_3_0 int RSA_get_multi_prime_extra_count(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 int RSA_get0_multi_prime_factors(const RSA *r,
+                                                       const BIGNUM *primes[]);
+OSSL_DEPRECATEDIN_3_0 void RSA_get0_crt_params(const RSA *r,
+                                               const BIGNUM **dmp1,
+                                               const BIGNUM **dmq1,
+                                               const BIGNUM **iqmp);
+OSSL_DEPRECATEDIN_3_0
+int RSA_get0_multi_prime_crt_params(const RSA *r, const BIGNUM *exps[],
+                                    const BIGNUM *coeffs[]);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_n(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_e(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_d(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_p(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_q(const RSA *d);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_dmp1(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_dmq1(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_iqmp(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 const RSA_PSS_PARAMS *RSA_get0_pss_params(const RSA *r);
+OSSL_DEPRECATEDIN_3_0 void RSA_clear_flags(RSA *r, int flags);
+OSSL_DEPRECATEDIN_3_0 int RSA_test_flags(const RSA *r, int flags);
+OSSL_DEPRECATEDIN_3_0 void RSA_set_flags(RSA *r, int flags);
+OSSL_DEPRECATEDIN_3_0 int RSA_get_version(RSA *r);
+OSSL_DEPRECATEDIN_3_0 ENGINE *RSA_get0_engine(const RSA *r);
+# endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+# define EVP_RSA_gen(bits) \
+    EVP_PKEY_Q_keygen(NULL, NULL, "RSA", (size_t)(0 + (bits)))
+
+/* Deprecated version */
+# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+OSSL_DEPRECATEDIN_0_9_8 RSA *RSA_generate_key(int bits, unsigned long e, void
+                                              (*callback) (int, int, void *),
+                                              void *cb_arg);
+# endif
+
+/* New version */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e,
+                                              BN_GENCB *cb);
+/* Multi-prime version */
+OSSL_DEPRECATEDIN_3_0 int RSA_generate_multi_prime_key(RSA *rsa, int bits,
+                                                       int primes, BIGNUM *e,
+                                                       BN_GENCB *cb);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_X931_derive_ex(RSA *rsa, BIGNUM *p1, BIGNUM *p2,
+                       BIGNUM *q1, BIGNUM *q2,
+                       const BIGNUM *Xp1, const BIGNUM *Xp2,
+                       const BIGNUM *Xp, const BIGNUM *Xq1,
+                       const BIGNUM *Xq2, const BIGNUM *Xq,
+                       const BIGNUM *e, BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0 int RSA_X931_generate_key_ex(RSA *rsa, int bits,
+                                                   const BIGNUM *e,
+                                                   BN_GENCB *cb);
+
+OSSL_DEPRECATEDIN_3_0 int RSA_check_key(const RSA *);
+OSSL_DEPRECATEDIN_3_0 int RSA_check_key_ex(const RSA *, BN_GENCB *cb);
+        /* next 4 return -1 on error */
+OSSL_DEPRECATEDIN_3_0
+int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to,
+                       RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to,
+                        RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_public_decrypt(int flen, const unsigned char *from, unsigned char *to,
+                       RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to,
+                        RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0 void RSA_free(RSA *r);
+/* "up" the RSA object's reference count */
+OSSL_DEPRECATEDIN_3_0 int RSA_up_ref(RSA *r);
+OSSL_DEPRECATEDIN_3_0 int RSA_flags(const RSA *r);
+
+OSSL_DEPRECATEDIN_3_0 void RSA_set_default_method(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_get_default_method(void);
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_null_method(void);
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_get_method(const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 int RSA_set_method(RSA *rsa, const RSA_METHOD *meth);
+
+/* these are the actual RSA functions */
+OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_PKCS1_OpenSSL(void);
+
+DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(OSSL_DEPRECATEDIN_3_0,
+                                        RSA, RSAPublicKey)
+DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(OSSL_DEPRECATEDIN_3_0,
+                                        RSA, RSAPrivateKey)
+# endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+int RSA_pkey_ctx_ctrl(EVP_PKEY_CTX *ctx, int optype, int cmd, int p1, void *p2);
+
+struct rsa_pss_params_st {
+    X509_ALGOR *hashAlgorithm;
+    X509_ALGOR *maskGenAlgorithm;
+    ASN1_INTEGER *saltLength;
+    ASN1_INTEGER *trailerField;
+    /* Decoded hash algorithm from maskGenAlgorithm */
+    X509_ALGOR *maskHash;
+};
+
+DECLARE_ASN1_FUNCTIONS(RSA_PSS_PARAMS)
+DECLARE_ASN1_DUP_FUNCTION(RSA_PSS_PARAMS)
+
+typedef struct rsa_oaep_params_st {
+    X509_ALGOR *hashFunc;
+    X509_ALGOR *maskGenFunc;
+    X509_ALGOR *pSourceFunc;
+    /* Decoded hash algorithm from maskGenFunc */
+    X509_ALGOR *maskHash;
+} RSA_OAEP_PARAMS;
+
+DECLARE_ASN1_FUNCTIONS(RSA_OAEP_PARAMS)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_STDIO
+OSSL_DEPRECATEDIN_3_0 int RSA_print_fp(FILE *fp, const RSA *r, int offset);
+#  endif
+
+OSSL_DEPRECATEDIN_3_0 int RSA_print(BIO *bp, const RSA *r, int offset);
+
+/*
+ * The following 2 functions sign and verify a X509_SIG ASN1 object inside
+ * PKCS#1 padded RSA encryption
+ */
+OSSL_DEPRECATEDIN_3_0 int RSA_sign(int type, const unsigned char *m,
+                                   unsigned int m_length, unsigned char *sigret,
+                                   unsigned int *siglen, RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 int RSA_verify(int type, const unsigned char *m,
+                                     unsigned int m_length,
+                                     const unsigned char *sigbuf,
+                                     unsigned int siglen, RSA *rsa);
+
+/*
+ * The following 2 function sign and verify a ASN1_OCTET_STRING object inside
+ * PKCS#1 padded RSA encryption
+ */
+OSSL_DEPRECATEDIN_3_0
+int RSA_sign_ASN1_OCTET_STRING(int type,
+                               const unsigned char *m, unsigned int m_length,
+                               unsigned char *sigret, unsigned int *siglen,
+                               RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_verify_ASN1_OCTET_STRING(int type,
+                                 const unsigned char *m, unsigned int m_length,
+                                 unsigned char *sigbuf, unsigned int siglen,
+                                 RSA *rsa);
+
+OSSL_DEPRECATEDIN_3_0 int RSA_blinding_on(RSA *rsa, BN_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 void RSA_blinding_off(RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen,
+                                 const unsigned char *f, int fl);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen,
+                                   const unsigned char *f, int fl,
+                                   int rsa_len);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen,
+                                 const unsigned char *f, int fl);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen,
+                                   const unsigned char *f, int fl,
+                                   int rsa_len);
+OSSL_DEPRECATEDIN_3_0 int PKCS1_MGF1(unsigned char *mask, long len,
+                                     const unsigned char *seed, long seedlen,
+                                     const EVP_MD *dgst);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen,
+                               const unsigned char *f, int fl,
+                               const unsigned char *p, int pl);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen,
+                                 const unsigned char *f, int fl, int rsa_len,
+                                 const unsigned char *p, int pl);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_OAEP_mgf1(unsigned char *to, int tlen,
+                                    const unsigned char *from, int flen,
+                                    const unsigned char *param, int plen,
+                                    const EVP_MD *md, const EVP_MD *mgf1md);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_check_PKCS1_OAEP_mgf1(unsigned char *to, int tlen,
+                                      const unsigned char *from, int flen,
+                                      int num,
+                                      const unsigned char *param, int plen,
+                                      const EVP_MD *md, const EVP_MD *mgf1md);
+OSSL_DEPRECATEDIN_3_0 int RSA_padding_add_none(unsigned char *to, int tlen,
+                                               const unsigned char *f, int fl);
+OSSL_DEPRECATEDIN_3_0 int RSA_padding_check_none(unsigned char *to, int tlen,
+                                                 const unsigned char *f, int fl,
+                                                 int rsa_len);
+OSSL_DEPRECATEDIN_3_0 int RSA_padding_add_X931(unsigned char *to, int tlen,
+                                               const unsigned char *f, int fl);
+OSSL_DEPRECATEDIN_3_0 int RSA_padding_check_X931(unsigned char *to, int tlen,
+                                                 const unsigned char *f, int fl,
+                                                 int rsa_len);
+OSSL_DEPRECATEDIN_3_0 int RSA_X931_hash_id(int nid);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash,
+                         const EVP_MD *Hash, const unsigned char *EM,
+                         int sLen);
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM,
+                              const unsigned char *mHash, const EVP_MD *Hash,
+                              int sLen);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash,
+                              const EVP_MD *Hash, const EVP_MD *mgf1Hash,
+                              const unsigned char *EM, int sLen);
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM,
+                                   const unsigned char *mHash,
+                                   const EVP_MD *Hash, const EVP_MD *mgf1Hash,
+                                   int sLen);
+
+# define RSA_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, l, p, newf, dupf, freef)
+OSSL_DEPRECATEDIN_3_0 int RSA_set_ex_data(RSA *r, int idx, void *arg);
+OSSL_DEPRECATEDIN_3_0 void *RSA_get_ex_data(const RSA *r, int idx);
+
+DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPublicKey)
+DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPrivateKey)
+
+/*
+ * If this flag is set the RSA method is FIPS compliant and can be used in
+ * FIPS mode. This is set in the validated module method. If an application
+ * sets this flag in its own methods it is its responsibility to ensure the
+ * result is compliant.
+ */
+
+#  define RSA_FLAG_FIPS_METHOD                    0x0400
+
+/*
+ * If this flag is set the operations normally disabled in FIPS mode are
+ * permitted it is then the applications responsibility to ensure that the
+ * usage is compliant.
+ */
+
+#  define RSA_FLAG_NON_FIPS_ALLOW                 0x0400
+/*
+ * Application has decided PRNG is good enough to generate a key: don't
+ * check.
+ */
+#  define RSA_FLAG_CHECKED                        0x0800
+
+OSSL_DEPRECATEDIN_3_0 RSA_METHOD *RSA_meth_new(const char *name, int flags);
+OSSL_DEPRECATEDIN_3_0 void RSA_meth_free(RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 const char *RSA_meth_get0_name(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 int RSA_meth_set1_name(RSA_METHOD *meth,
+                                             const char *name);
+OSSL_DEPRECATEDIN_3_0 int RSA_meth_get_flags(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 int RSA_meth_set_flags(RSA_METHOD *meth, int flags);
+OSSL_DEPRECATEDIN_3_0 void *RSA_meth_get0_app_data(const RSA_METHOD *meth);
+OSSL_DEPRECATEDIN_3_0 int RSA_meth_set0_app_data(RSA_METHOD *meth,
+                                                 void *app_data);
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_pub_enc(const RSA_METHOD *meth)) (int flen,
+                                                     const unsigned char *from,
+                                                     unsigned char *to,
+                                                     RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_pub_enc(RSA_METHOD *rsa,
+                         int (*pub_enc) (int flen, const unsigned char *from,
+                                         unsigned char *to, RSA *rsa,
+                                         int padding));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_pub_dec(const RSA_METHOD *meth)) (int flen,
+                                                     const unsigned char *from,
+                                                     unsigned char *to,
+                                                     RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_pub_dec(RSA_METHOD *rsa,
+                         int (*pub_dec) (int flen, const unsigned char *from,
+                                         unsigned char *to, RSA *rsa,
+                                         int padding));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_priv_enc(const RSA_METHOD *meth)) (int flen,
+                                                      const unsigned char *from,
+                                                      unsigned char *to,
+                                                      RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_priv_enc(RSA_METHOD *rsa,
+                          int (*priv_enc) (int flen, const unsigned char *from,
+                                           unsigned char *to, RSA *rsa,
+                                           int padding));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_priv_dec(const RSA_METHOD *meth)) (int flen,
+                                                      const unsigned char *from,
+                                                      unsigned char *to,
+                                                      RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_priv_dec(RSA_METHOD *rsa,
+                          int (*priv_dec) (int flen, const unsigned char *from,
+                                           unsigned char *to, RSA *rsa,
+                                           int padding));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_mod_exp(const RSA_METHOD *meth)) (BIGNUM *r0,
+                                                     const BIGNUM *i,
+                                                     RSA *rsa, BN_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_mod_exp(RSA_METHOD *rsa,
+                         int (*mod_exp) (BIGNUM *r0, const BIGNUM *i, RSA *rsa,
+                                         BN_CTX *ctx));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD *meth)) (BIGNUM *r,
+                                                        const BIGNUM *a,
+                                                        const BIGNUM *p,
+                                                        const BIGNUM *m,
+                                                        BN_CTX *ctx,
+                                                        BN_MONT_CTX *m_ctx);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa,
+                            int (*bn_mod_exp) (BIGNUM *r,
+                                               const BIGNUM *a,
+                                               const BIGNUM *p,
+                                               const BIGNUM *m,
+                                               BN_CTX *ctx,
+                                               BN_MONT_CTX *m_ctx));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_init(const RSA_METHOD *meth)) (RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_finish(const RSA_METHOD *meth)) (RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_sign(const RSA_METHOD *meth)) (int type,
+                                                  const unsigned char *m,
+                                                  unsigned int m_length,
+                                                  unsigned char *sigret,
+                                                  unsigned int *siglen,
+                                                  const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_sign(RSA_METHOD *rsa,
+                      int (*sign) (int type, const unsigned char *m,
+                                   unsigned int m_length,
+                                   unsigned char *sigret, unsigned int *siglen,
+                                   const RSA *rsa));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_verify(const RSA_METHOD *meth)) (int dtype,
+                                                    const unsigned char *m,
+                                                    unsigned int m_length,
+                                                    const unsigned char *sigbuf,
+                                                    unsigned int siglen,
+                                                    const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_verify(RSA_METHOD *rsa,
+                        int (*verify) (int dtype, const unsigned char *m,
+                                       unsigned int m_length,
+                                       const unsigned char *sigbuf,
+                                       unsigned int siglen, const RSA *rsa));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_keygen(const RSA_METHOD *meth)) (RSA *rsa, int bits,
+                                                    BIGNUM *e, BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_keygen(RSA_METHOD *rsa,
+                        int (*keygen) (RSA *rsa, int bits, BIGNUM *e,
+                                       BN_GENCB *cb));
+OSSL_DEPRECATEDIN_3_0
+int (*RSA_meth_get_multi_prime_keygen(const RSA_METHOD *meth)) (RSA *rsa,
+                                                                int bits,
+                                                                int primes,
+                                                                BIGNUM *e,
+                                                                BN_GENCB *cb);
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_multi_prime_keygen(RSA_METHOD *meth,
+                                    int (*keygen) (RSA *rsa, int bits,
+                                                   int primes, BIGNUM *e,
+                                                   BN_GENCB *cb));
+#endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/rsaerr.h b/CAPI/cpp/grpc/include/openssl/rsaerr.h
new file mode 100644
index 0000000..c58463c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/rsaerr.h
@@ -0,0 +1,107 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_RSAERR_H
+# define OPENSSL_RSAERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * RSA reason codes.
+ */
+# define RSA_R_ALGORITHM_MISMATCH                         100
+# define RSA_R_BAD_E_VALUE                                101
+# define RSA_R_BAD_FIXED_HEADER_DECRYPT                   102
+# define RSA_R_BAD_PAD_BYTE_COUNT                         103
+# define RSA_R_BAD_SIGNATURE                              104
+# define RSA_R_BLOCK_TYPE_IS_NOT_01                       106
+# define RSA_R_BLOCK_TYPE_IS_NOT_02                       107
+# define RSA_R_DATA_GREATER_THAN_MOD_LEN                  108
+# define RSA_R_DATA_TOO_LARGE                             109
+# define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE                110
+# define RSA_R_DATA_TOO_LARGE_FOR_MODULUS                 132
+# define RSA_R_DATA_TOO_SMALL                             111
+# define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE                122
+# define RSA_R_DIGEST_DOES_NOT_MATCH                      158
+# define RSA_R_DIGEST_NOT_ALLOWED                         145
+# define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY                 112
+# define RSA_R_DMP1_NOT_CONGRUENT_TO_D                    124
+# define RSA_R_DMQ1_NOT_CONGRUENT_TO_D                    125
+# define RSA_R_D_E_NOT_CONGRUENT_TO_1                     123
+# define RSA_R_FIRST_OCTET_INVALID                        133
+# define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE        144
+# define RSA_R_INVALID_DIGEST                             157
+# define RSA_R_INVALID_DIGEST_LENGTH                      143
+# define RSA_R_INVALID_HEADER                             137
+# define RSA_R_INVALID_KEYPAIR                            171
+# define RSA_R_INVALID_KEY_LENGTH                         173
+# define RSA_R_INVALID_LABEL                              160
+# define RSA_R_INVALID_LENGTH                             181
+# define RSA_R_INVALID_MESSAGE_LENGTH                     131
+# define RSA_R_INVALID_MGF1_MD                            156
+# define RSA_R_INVALID_MODULUS                            174
+# define RSA_R_INVALID_MULTI_PRIME_KEY                    167
+# define RSA_R_INVALID_OAEP_PARAMETERS                    161
+# define RSA_R_INVALID_PADDING                            138
+# define RSA_R_INVALID_PADDING_MODE                       141
+# define RSA_R_INVALID_PSS_PARAMETERS                     149
+# define RSA_R_INVALID_PSS_SALTLEN                        146
+# define RSA_R_INVALID_REQUEST                            175
+# define RSA_R_INVALID_SALT_LENGTH                        150
+# define RSA_R_INVALID_STRENGTH                           176
+# define RSA_R_INVALID_TRAILER                            139
+# define RSA_R_INVALID_X931_DIGEST                        142
+# define RSA_R_IQMP_NOT_INVERSE_OF_Q                      126
+# define RSA_R_KEY_PRIME_NUM_INVALID                      165
+# define RSA_R_KEY_SIZE_TOO_SMALL                         120
+# define RSA_R_LAST_OCTET_INVALID                         134
+# define RSA_R_MGF1_DIGEST_NOT_ALLOWED                    152
+# define RSA_R_MISSING_PRIVATE_KEY                        179
+# define RSA_R_MODULUS_TOO_LARGE                          105
+# define RSA_R_MP_COEFFICIENT_NOT_INVERSE_OF_R            168
+# define RSA_R_MP_EXPONENT_NOT_CONGRUENT_TO_D             169
+# define RSA_R_MP_R_NOT_PRIME                             170
+# define RSA_R_NO_PUBLIC_EXPONENT                         140
+# define RSA_R_NULL_BEFORE_BLOCK_MISSING                  113
+# define RSA_R_N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES         172
+# define RSA_R_N_DOES_NOT_EQUAL_P_Q                       127
+# define RSA_R_OAEP_DECODING_ERROR                        121
+# define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE   148
+# define RSA_R_PADDING_CHECK_FAILED                       114
+# define RSA_R_PAIRWISE_TEST_FAILURE                      177
+# define RSA_R_PKCS_DECODING_ERROR                        159
+# define RSA_R_PSS_SALTLEN_TOO_SMALL                      164
+# define RSA_R_PUB_EXPONENT_OUT_OF_RANGE                  178
+# define RSA_R_P_NOT_PRIME                                128
+# define RSA_R_Q_NOT_PRIME                                129
+# define RSA_R_RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT    180
+# define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED               130
+# define RSA_R_SLEN_CHECK_FAILED                          136
+# define RSA_R_SLEN_RECOVERY_FAILED                       135
+# define RSA_R_SSLV3_ROLLBACK_ATTACK                      115
+# define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116
+# define RSA_R_UNKNOWN_ALGORITHM_TYPE                     117
+# define RSA_R_UNKNOWN_DIGEST                             166
+# define RSA_R_UNKNOWN_MASK_DIGEST                        151
+# define RSA_R_UNKNOWN_PADDING_TYPE                       118
+# define RSA_R_UNSUPPORTED_ENCRYPTION_TYPE                162
+# define RSA_R_UNSUPPORTED_LABEL_SOURCE                   163
+# define RSA_R_UNSUPPORTED_MASK_ALGORITHM                 153
+# define RSA_R_UNSUPPORTED_MASK_PARAMETER                 154
+# define RSA_R_UNSUPPORTED_SIGNATURE_TYPE                 155
+# define RSA_R_VALUE_MISSING                              147
+# define RSA_R_WRONG_SIGNATURE_LENGTH                     119
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/safestack.h b/CAPI/cpp/grpc/include/openssl/safestack.h
new file mode 100644
index 0000000..159ccf2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/safestack.h
@@ -0,0 +1,297 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\safestack.h.in
+ *
+ * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_SAFESTACK_H
+# define OPENSSL_SAFESTACK_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SAFESTACK_H
+# endif
+
+# include <openssl/stack.h>
+# include <openssl/e_os2.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+# define STACK_OF(type) struct stack_st_##type
+
+/* Helper macro for internal use */
+# define SKM_DEFINE_STACK_OF_INTERNAL(t1, t2, t3) \
+    STACK_OF(t1); \
+    typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \
+    typedef void (*sk_##t1##_freefunc)(t3 *a); \
+    typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \
+    static ossl_unused ossl_inline t2 *ossl_check_##t1##_type(t2 *ptr) \
+    { \
+        return ptr; \
+    } \
+    static ossl_unused ossl_inline const OPENSSL_STACK *ossl_check_const_##t1##_sk_type(const STACK_OF(t1) *sk) \
+    { \
+        return (const OPENSSL_STACK *)sk; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_STACK *ossl_check_##t1##_sk_type(STACK_OF(t1) *sk) \
+    { \
+        return (OPENSSL_STACK *)sk; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_sk_compfunc ossl_check_##t1##_compfunc_type(sk_##t1##_compfunc cmp) \
+    { \
+        return (OPENSSL_sk_compfunc)cmp; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_sk_copyfunc ossl_check_##t1##_copyfunc_type(sk_##t1##_copyfunc cpy) \
+    { \
+        return (OPENSSL_sk_copyfunc)cpy; \
+    } \
+    static ossl_unused ossl_inline OPENSSL_sk_freefunc ossl_check_##t1##_freefunc_type(sk_##t1##_freefunc fr) \
+    { \
+        return (OPENSSL_sk_freefunc)fr; \
+    }
+
+# define SKM_DEFINE_STACK_OF(t1, t2, t3) \
+    STACK_OF(t1); \
+    typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \
+    typedef void (*sk_##t1##_freefunc)(t3 *a); \
+    typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \
+    static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \
+    { \
+        return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \
+    { \
+        return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n) \
+    { \
+        return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); \
+    } \
+    static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \
+    { \
+        OPENSSL_sk_free((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \
+    { \
+        OPENSSL_sk_zero((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \
+    { \
+        return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \
+                                           (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \
+    { \
+        return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \
+    { \
+        return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \
+    { \
+        OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \
+    { \
+        return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); \
+    } \
+    static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \
+    { \
+        return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \
+    { \
+        return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_find_all(STACK_OF(t1) *sk, t2 *ptr, int *pnum) \
+    { \
+        return OPENSSL_sk_find_all((OPENSSL_STACK *)sk, (const void *)ptr, pnum); \
+    } \
+    static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \
+    { \
+        OPENSSL_sk_sort((OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \
+    { \
+        return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) *sk) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); \
+    } \
+    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk, \
+                                                    sk_##t1##_copyfunc copyfunc, \
+                                                    sk_##t1##_freefunc freefunc) \
+    { \
+        return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, \
+                                            (OPENSSL_sk_copyfunc)copyfunc, \
+                                            (OPENSSL_sk_freefunc)freefunc); \
+    } \
+    static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \
+    { \
+        return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \
+    }
+
+# define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t)
+# define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t)
+# define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2)
+# define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \
+            SKM_DEFINE_STACK_OF(t1, const t2, t2)
+
+/*-
+ * Strings are special: normally an lhash entry will point to a single
+ * (somewhat) mutable object. In the case of strings:
+ *
+ * a) Instead of a single char, there is an array of chars, NUL-terminated.
+ * b) The string may have be immutable.
+ *
+ * So, they need their own declarations. Especially important for
+ * type-checking tools, such as Deputy.
+ *
+ * In practice, however, it appears to be hard to have a const
+ * string. For now, I'm settling for dealing with the fact it is a
+ * string at all.
+ */
+typedef char *OPENSSL_STRING;
+typedef const char *OPENSSL_CSTRING;
+
+/*-
+ * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but
+ * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned
+ * above, instead of a single char each entry is a NUL-terminated array of
+ * chars. So, we have to implement STRING specially for STACK_OF. This is
+ * dealt with in the autogenerated macros below.
+ */
+SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_STRING, char, char)
+#define sk_OPENSSL_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_value(sk, idx) ((char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_STRING_sk_type(sk), (idx)))
+#define sk_OPENSSL_STRING_new(cmp) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new(ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
+#define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new_null())
+#define sk_OPENSSL_STRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_STRING_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_STRING_sk_type(sk), (n))
+#define sk_OPENSSL_STRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_delete(sk, i) ((char *)OPENSSL_sk_delete(ossl_check_OPENSSL_STRING_sk_type(sk), (i)))
+#define sk_OPENSSL_STRING_delete_ptr(sk, ptr) ((char *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr)))
+#define sk_OPENSSL_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
+#define sk_OPENSSL_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
+#define sk_OPENSSL_STRING_pop(sk) ((char *)OPENSSL_sk_pop(ossl_check_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_shift(sk) ((char *)OPENSSL_sk_shift(ossl_check_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_STRING_sk_type(sk),ossl_check_OPENSSL_STRING_freefunc_type(freefunc))
+#define sk_OPENSSL_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), (idx))
+#define sk_OPENSSL_STRING_set(sk, idx, ptr) ((char *)OPENSSL_sk_set(ossl_check_OPENSSL_STRING_sk_type(sk), (idx), ossl_check_OPENSSL_STRING_type(ptr)))
+#define sk_OPENSSL_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
+#define sk_OPENSSL_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
+#define sk_OPENSSL_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), pnum)
+#define sk_OPENSSL_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_STRING_sk_type(sk))
+#define sk_OPENSSL_STRING_dup(sk) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_STRING_freefunc_type(freefunc)))
+#define sk_OPENSSL_STRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_CSTRING, const char, char)
+#define sk_OPENSSL_CSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_value(sk, idx) ((const char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), (idx)))
+#define sk_OPENSSL_CSTRING_new(cmp) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
+#define sk_OPENSSL_CSTRING_new_null() ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new_null())
+#define sk_OPENSSL_CSTRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_CSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_CSTRING_sk_type(sk), (n))
+#define sk_OPENSSL_CSTRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_delete(sk, i) ((const char *)OPENSSL_sk_delete(ossl_check_OPENSSL_CSTRING_sk_type(sk), (i)))
+#define sk_OPENSSL_CSTRING_delete_ptr(sk, ptr) ((const char *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr)))
+#define sk_OPENSSL_CSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
+#define sk_OPENSSL_CSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
+#define sk_OPENSSL_CSTRING_pop(sk) ((const char *)OPENSSL_sk_pop(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_shift(sk) ((const char *)OPENSSL_sk_shift(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_CSTRING_sk_type(sk),ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc))
+#define sk_OPENSSL_CSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), (idx))
+#define sk_OPENSSL_CSTRING_set(sk, idx, ptr) ((const char *)OPENSSL_sk_set(ossl_check_OPENSSL_CSTRING_sk_type(sk), (idx), ossl_check_OPENSSL_CSTRING_type(ptr)))
+#define sk_OPENSSL_CSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
+#define sk_OPENSSL_CSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
+#define sk_OPENSSL_CSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), pnum)
+#define sk_OPENSSL_CSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
+#define sk_OPENSSL_CSTRING_dup(sk) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc)))
+#define sk_OPENSSL_CSTRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_CSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
+
+
+#if !defined(OPENSSL_NO_DEPRECATED_3_0)
+/*
+ * This is not used by OpenSSL.  A block of bytes,  NOT nul-terminated.
+ * These should also be distinguished from "normal" stacks.
+ */
+typedef void *OPENSSL_BLOCK;
+SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_BLOCK, void, void)
+#define sk_OPENSSL_BLOCK_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), (idx)))
+#define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
+#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new_null())
+#define sk_OPENSSL_BLOCK_new_reserve(cmp, n) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_BLOCK_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_BLOCK_sk_type(sk), (n))
+#define sk_OPENSSL_BLOCK_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_delete(sk, i) ((void *)OPENSSL_sk_delete(ossl_check_OPENSSL_BLOCK_sk_type(sk), (i)))
+#define sk_OPENSSL_BLOCK_delete_ptr(sk, ptr) ((void *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr)))
+#define sk_OPENSSL_BLOCK_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
+#define sk_OPENSSL_BLOCK_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
+#define sk_OPENSSL_BLOCK_pop(sk) ((void *)OPENSSL_sk_pop(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_shift(sk) ((void *)OPENSSL_sk_shift(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_BLOCK_sk_type(sk),ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc))
+#define sk_OPENSSL_BLOCK_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), (idx))
+#define sk_OPENSSL_BLOCK_set(sk, idx, ptr) ((void *)OPENSSL_sk_set(ossl_check_OPENSSL_BLOCK_sk_type(sk), (idx), ossl_check_OPENSSL_BLOCK_type(ptr)))
+#define sk_OPENSSL_BLOCK_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
+#define sk_OPENSSL_BLOCK_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
+#define sk_OPENSSL_BLOCK_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), pnum)
+#define sk_OPENSSL_BLOCK_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
+#define sk_OPENSSL_BLOCK_dup(sk) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_copyfunc_type(copyfunc), ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc)))
+#define sk_OPENSSL_BLOCK_set_cmp_func(sk, cmp) ((sk_OPENSSL_BLOCK_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
+
+#endif
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/seed.h b/CAPI/cpp/grpc/include/openssl/seed.h
new file mode 100644
index 0000000..edb218a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/seed.h
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2007-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * Copyright (c) 2007 KISA(Korea Information Security Agency). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Neither the name of author nor the names of its contributors may
+ *    be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef OPENSSL_SEED_H
+# define OPENSSL_SEED_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SEED_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_SEED
+#  include <openssl/e_os2.h>
+#  include <openssl/crypto.h>
+#  include <sys/types.h>
+
+#  ifdef  __cplusplus
+extern "C" {
+#  endif
+
+#  define SEED_BLOCK_SIZE 16
+#  define SEED_KEY_LENGTH 16
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/* look whether we need 'long' to get 32 bits */
+#   ifdef AES_LONG
+#    ifndef SEED_LONG
+#     define SEED_LONG 1
+#    endif
+#   endif
+
+
+typedef struct seed_key_st {
+#   ifdef SEED_LONG
+    unsigned long data[32];
+#   else
+    unsigned int data[32];
+#   endif
+} SEED_KEY_SCHEDULE;
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH],
+                  SEED_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0
+void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE],
+                  unsigned char d[SEED_BLOCK_SIZE],
+                  const SEED_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0
+void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE],
+                  unsigned char d[SEED_BLOCK_SIZE],
+                  const SEED_KEY_SCHEDULE *ks);
+OSSL_DEPRECATEDIN_3_0
+void SEED_ecb_encrypt(const unsigned char *in,
+                      unsigned char *out,
+                      const SEED_KEY_SCHEDULE *ks, int enc);
+OSSL_DEPRECATEDIN_3_0
+void SEED_cbc_encrypt(const unsigned char *in, unsigned char *out, size_t len,
+                      const SEED_KEY_SCHEDULE *ks,
+                      unsigned char ivec[SEED_BLOCK_SIZE],
+                      int enc);
+OSSL_DEPRECATEDIN_3_0
+void SEED_cfb128_encrypt(const unsigned char *in, unsigned char *out,
+                         size_t len, const SEED_KEY_SCHEDULE *ks,
+                         unsigned char ivec[SEED_BLOCK_SIZE],
+                         int *num, int enc);
+OSSL_DEPRECATEDIN_3_0
+void SEED_ofb128_encrypt(const unsigned char *in, unsigned char *out,
+                         size_t len, const SEED_KEY_SCHEDULE *ks,
+                         unsigned char ivec[SEED_BLOCK_SIZE],
+                         int *num);
+#  endif
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/self_test.h b/CAPI/cpp/grpc/include/openssl/self_test.h
new file mode 100644
index 0000000..ee4949e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/self_test.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SELF_TEST_H
+# define OPENSSL_SELF_TEST_H
+# pragma once
+
+# include <openssl/core.h> /* OSSL_CALLBACK */
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* The test event phases */
+# define OSSL_SELF_TEST_PHASE_NONE     "None"
+# define OSSL_SELF_TEST_PHASE_START    "Start"
+# define OSSL_SELF_TEST_PHASE_CORRUPT  "Corrupt"
+# define OSSL_SELF_TEST_PHASE_PASS     "Pass"
+# define OSSL_SELF_TEST_PHASE_FAIL     "Fail"
+
+/* Test event categories */
+# define OSSL_SELF_TEST_TYPE_NONE               "None"
+# define OSSL_SELF_TEST_TYPE_MODULE_INTEGRITY   "Module_Integrity"
+# define OSSL_SELF_TEST_TYPE_INSTALL_INTEGRITY  "Install_Integrity"
+# define OSSL_SELF_TEST_TYPE_CRNG               "Continuous_RNG_Test"
+# define OSSL_SELF_TEST_TYPE_PCT                "Conditional_PCT"
+# define OSSL_SELF_TEST_TYPE_KAT_CIPHER         "KAT_Cipher"
+# define OSSL_SELF_TEST_TYPE_KAT_ASYM_CIPHER    "KAT_AsymmetricCipher"
+# define OSSL_SELF_TEST_TYPE_KAT_DIGEST         "KAT_Digest"
+# define OSSL_SELF_TEST_TYPE_KAT_SIGNATURE      "KAT_Signature"
+# define OSSL_SELF_TEST_TYPE_PCT_SIGNATURE      "PCT_Signature"
+# define OSSL_SELF_TEST_TYPE_KAT_KDF            "KAT_KDF"
+# define OSSL_SELF_TEST_TYPE_KAT_KA             "KAT_KA"
+# define OSSL_SELF_TEST_TYPE_DRBG               "DRBG"
+
+/* Test event sub categories */
+# define OSSL_SELF_TEST_DESC_NONE           "None"
+# define OSSL_SELF_TEST_DESC_INTEGRITY_HMAC "HMAC"
+# define OSSL_SELF_TEST_DESC_PCT_RSA_PKCS1  "RSA"
+# define OSSL_SELF_TEST_DESC_PCT_ECDSA      "ECDSA"
+# define OSSL_SELF_TEST_DESC_PCT_DSA        "DSA"
+# define OSSL_SELF_TEST_DESC_CIPHER_AES_GCM "AES_GCM"
+# define OSSL_SELF_TEST_DESC_CIPHER_AES_ECB "AES_ECB_Decrypt"
+# define OSSL_SELF_TEST_DESC_CIPHER_TDES    "TDES"
+# define OSSL_SELF_TEST_DESC_ASYM_RSA_ENC   "RSA_Encrypt"
+# define OSSL_SELF_TEST_DESC_ASYM_RSA_DEC   "RSA_Decrypt"
+# define OSSL_SELF_TEST_DESC_MD_SHA1        "SHA1"
+# define OSSL_SELF_TEST_DESC_MD_SHA2        "SHA2"
+# define OSSL_SELF_TEST_DESC_MD_SHA3        "SHA3"
+# define OSSL_SELF_TEST_DESC_SIGN_DSA       "DSA"
+# define OSSL_SELF_TEST_DESC_SIGN_RSA       "RSA"
+# define OSSL_SELF_TEST_DESC_SIGN_ECDSA     "ECDSA"
+# define OSSL_SELF_TEST_DESC_DRBG_CTR       "CTR"
+# define OSSL_SELF_TEST_DESC_DRBG_HASH      "HASH"
+# define OSSL_SELF_TEST_DESC_DRBG_HMAC      "HMAC"
+# define OSSL_SELF_TEST_DESC_KA_DH          "DH"
+# define OSSL_SELF_TEST_DESC_KA_ECDH        "ECDH"
+# define OSSL_SELF_TEST_DESC_KDF_HKDF       "HKDF"
+# define OSSL_SELF_TEST_DESC_KDF_SSKDF      "SSKDF"
+# define OSSL_SELF_TEST_DESC_KDF_X963KDF    "X963KDF"
+# define OSSL_SELF_TEST_DESC_KDF_X942KDF    "X942KDF"
+# define OSSL_SELF_TEST_DESC_KDF_PBKDF2     "PBKDF2"
+# define OSSL_SELF_TEST_DESC_KDF_SSHKDF     "SSHKDF"
+# define OSSL_SELF_TEST_DESC_KDF_TLS12_PRF  "TLS12_PRF"
+# define OSSL_SELF_TEST_DESC_KDF_KBKDF      "KBKDF"
+# define OSSL_SELF_TEST_DESC_KDF_TLS13_EXTRACT  "TLS13_KDF_EXTRACT"
+# define OSSL_SELF_TEST_DESC_KDF_TLS13_EXPAND   "TLS13_KDF_EXPAND"
+# define OSSL_SELF_TEST_DESC_RNG            "RNG"
+
+void OSSL_SELF_TEST_set_callback(OSSL_LIB_CTX *libctx, OSSL_CALLBACK *cb,
+                                 void *cbarg);
+void OSSL_SELF_TEST_get_callback(OSSL_LIB_CTX *libctx, OSSL_CALLBACK **cb,
+                                 void **cbarg);
+
+OSSL_SELF_TEST *OSSL_SELF_TEST_new(OSSL_CALLBACK *cb, void *cbarg);
+void OSSL_SELF_TEST_free(OSSL_SELF_TEST *st);
+
+void OSSL_SELF_TEST_onbegin(OSSL_SELF_TEST *st, const char *type,
+                            const char *desc);
+int OSSL_SELF_TEST_oncorrupt_byte(OSSL_SELF_TEST *st, unsigned char *bytes);
+void OSSL_SELF_TEST_onend(OSSL_SELF_TEST *st, int ret);
+
+# ifdef __cplusplus
+}
+# endif
+#endif /* OPENSSL_SELF_TEST_H */
diff --git a/CAPI/cpp/grpc/include/openssl/sha.h b/CAPI/cpp/grpc/include/openssl/sha.h
new file mode 100644
index 0000000..6e65a04
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/sha.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SHA_H
+# define OPENSSL_SHA_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SHA_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <stddef.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# define SHA_DIGEST_LENGTH 20
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*-
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ * ! SHA_LONG has to be at least 32 bits wide.                    !
+ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+#  define SHA_LONG unsigned int
+
+#  define SHA_LBLOCK      16
+#  define SHA_CBLOCK      (SHA_LBLOCK*4)/* SHA treats input data as a
+                                         * contiguous array of 32 bit wide
+                                         * big-endian values. */
+#  define SHA_LAST_BLOCK  (SHA_CBLOCK-8)
+
+typedef struct SHAstate_st {
+    SHA_LONG h0, h1, h2, h3, h4;
+    SHA_LONG Nl, Nh;
+    SHA_LONG data[SHA_LBLOCK];
+    unsigned int num;
+} SHA_CTX;
+
+OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char *md, SHA_CTX *c);
+OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
+# endif
+
+unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SHA256_CBLOCK   (SHA_LBLOCK*4)/* SHA-256 treats input data as a
+                                        * contiguous array of 32 bit wide
+                                        * big-endian values. */
+
+typedef struct SHA256state_st {
+    SHA_LONG h[8];
+    SHA_LONG Nl, Nh;
+    SHA_LONG data[SHA_LBLOCK];
+    unsigned int num, md_len;
+} SHA256_CTX;
+
+OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c,
+                                        const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c,
+                                        const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
+OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c,
+                                            const unsigned char *data);
+# endif
+
+unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
+unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
+
+# define SHA224_DIGEST_LENGTH    28
+# define SHA256_DIGEST_LENGTH    32
+# define SHA384_DIGEST_LENGTH    48
+# define SHA512_DIGEST_LENGTH    64
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+/*
+ * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64
+ * being exactly 64-bit wide. See Implementation Notes in sha512.c
+ * for further details.
+ */
+/*
+ * SHA-512 treats input data as a
+ * contiguous array of 64 bit
+ * wide big-endian values.
+ */
+#  define SHA512_CBLOCK   (SHA_LBLOCK*8)
+#  if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
+#   define SHA_LONG64 unsigned __int64
+#  elif defined(__arch64__)
+#   define SHA_LONG64 unsigned long
+#  else
+#   define SHA_LONG64 unsigned long long
+#  endif
+
+typedef struct SHA512state_st {
+    SHA_LONG64 h[8];
+    SHA_LONG64 Nl, Nh;
+    union {
+        SHA_LONG64 d[SHA_LBLOCK];
+        unsigned char p[SHA512_CBLOCK];
+    } u;
+    unsigned int num, md_len;
+} SHA512_CTX;
+
+OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c,
+                                        const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX *c,
+                                        const void *data, size_t len);
+OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char *md, SHA512_CTX *c);
+OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c,
+                                            const unsigned char *data);
+# endif
+
+unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
+unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/srp.h b/CAPI/cpp/grpc/include/openssl/srp.h
new file mode 100644
index 0000000..a86fa5d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/srp.h
@@ -0,0 +1,285 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\srp.h.in
+ *
+ * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2004, EdelKey Project. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ *
+ * Originally written by Christophe Renou and Peter Sylvester,
+ * for the EdelKey project.
+ */
+
+
+
+#ifndef OPENSSL_SRP_H
+# define OPENSSL_SRP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SRP_H
+# endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_SRP
+# include <stdio.h>
+# include <string.h>
+# include <openssl/safestack.h>
+# include <openssl/bn.h>
+# include <openssl/crypto.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+typedef struct SRP_gN_cache_st {
+    char *b64_bn;
+    BIGNUM *bn;
+} SRP_gN_cache;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN_cache, SRP_gN_cache, SRP_gN_cache)
+#define sk_SRP_gN_cache_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_value(sk, idx) ((SRP_gN_cache *)OPENSSL_sk_value(ossl_check_const_SRP_gN_cache_sk_type(sk), (idx)))
+#define sk_SRP_gN_cache_new(cmp) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new(ossl_check_SRP_gN_cache_compfunc_type(cmp)))
+#define sk_SRP_gN_cache_new_null() ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new_null())
+#define sk_SRP_gN_cache_new_reserve(cmp, n) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_cache_compfunc_type(cmp), (n)))
+#define sk_SRP_gN_cache_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_cache_sk_type(sk), (n))
+#define sk_SRP_gN_cache_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_delete(sk, i) ((SRP_gN_cache *)OPENSSL_sk_delete(ossl_check_SRP_gN_cache_sk_type(sk), (i)))
+#define sk_SRP_gN_cache_delete_ptr(sk, ptr) ((SRP_gN_cache *)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr)))
+#define sk_SRP_gN_cache_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_pop(sk) ((SRP_gN_cache *)OPENSSL_sk_pop(ossl_check_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_shift(sk) ((SRP_gN_cache *)OPENSSL_sk_shift(ossl_check_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_cache_sk_type(sk),ossl_check_SRP_gN_cache_freefunc_type(freefunc))
+#define sk_SRP_gN_cache_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), (idx))
+#define sk_SRP_gN_cache_set(sk, idx, ptr) ((SRP_gN_cache *)OPENSSL_sk_set(ossl_check_SRP_gN_cache_sk_type(sk), (idx), ossl_check_SRP_gN_cache_type(ptr)))
+#define sk_SRP_gN_cache_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), pnum)
+#define sk_SRP_gN_cache_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_dup(sk) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_copyfunc_type(copyfunc), ossl_check_SRP_gN_cache_freefunc_type(freefunc)))
+#define sk_SRP_gN_cache_set_cmp_func(sk, cmp) ((sk_SRP_gN_cache_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_compfunc_type(cmp)))
+
+
+
+typedef struct SRP_user_pwd_st {
+    /* Owned by us. */
+    char *id;
+    BIGNUM *s;
+    BIGNUM *v;
+    /* Not owned by us. */
+    const BIGNUM *g;
+    const BIGNUM *N;
+    /* Owned by us. */
+    char *info;
+} SRP_user_pwd;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_user_pwd, SRP_user_pwd, SRP_user_pwd)
+#define sk_SRP_user_pwd_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_value(sk, idx) ((SRP_user_pwd *)OPENSSL_sk_value(ossl_check_const_SRP_user_pwd_sk_type(sk), (idx)))
+#define sk_SRP_user_pwd_new(cmp) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new(ossl_check_SRP_user_pwd_compfunc_type(cmp)))
+#define sk_SRP_user_pwd_new_null() ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new_null())
+#define sk_SRP_user_pwd_new_reserve(cmp, n) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new_reserve(ossl_check_SRP_user_pwd_compfunc_type(cmp), (n)))
+#define sk_SRP_user_pwd_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_user_pwd_sk_type(sk), (n))
+#define sk_SRP_user_pwd_free(sk) OPENSSL_sk_free(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_delete(sk, i) ((SRP_user_pwd *)OPENSSL_sk_delete(ossl_check_SRP_user_pwd_sk_type(sk), (i)))
+#define sk_SRP_user_pwd_delete_ptr(sk, ptr) ((SRP_user_pwd *)OPENSSL_sk_delete_ptr(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr)))
+#define sk_SRP_user_pwd_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_pop(sk) ((SRP_user_pwd *)OPENSSL_sk_pop(ossl_check_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_shift(sk) ((SRP_user_pwd *)OPENSSL_sk_shift(ossl_check_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_user_pwd_sk_type(sk),ossl_check_SRP_user_pwd_freefunc_type(freefunc))
+#define sk_SRP_user_pwd_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), (idx))
+#define sk_SRP_user_pwd_set(sk, idx, ptr) ((SRP_user_pwd *)OPENSSL_sk_set(ossl_check_SRP_user_pwd_sk_type(sk), (idx), ossl_check_SRP_user_pwd_type(ptr)))
+#define sk_SRP_user_pwd_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), pnum)
+#define sk_SRP_user_pwd_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_dup(sk) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_dup(ossl_check_const_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_copyfunc_type(copyfunc), ossl_check_SRP_user_pwd_freefunc_type(freefunc)))
+#define sk_SRP_user_pwd_set_cmp_func(sk, cmp) ((sk_SRP_user_pwd_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_compfunc_type(cmp)))
+
+
+OSSL_DEPRECATEDIN_3_0
+SRP_user_pwd *SRP_user_pwd_new(void);
+OSSL_DEPRECATEDIN_3_0
+void SRP_user_pwd_free(SRP_user_pwd *user_pwd);
+
+OSSL_DEPRECATEDIN_3_0
+void SRP_user_pwd_set_gN(SRP_user_pwd *user_pwd, const BIGNUM *g,
+                         const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+int SRP_user_pwd_set1_ids(SRP_user_pwd *user_pwd, const char *id,
+                          const char *info);
+OSSL_DEPRECATEDIN_3_0
+int SRP_user_pwd_set0_sv(SRP_user_pwd *user_pwd, BIGNUM *s, BIGNUM *v);
+
+typedef struct SRP_VBASE_st {
+    STACK_OF(SRP_user_pwd) *users_pwd;
+    STACK_OF(SRP_gN_cache) *gN_cache;
+/* to simulate a user */
+    char *seed_key;
+    const BIGNUM *default_g;
+    const BIGNUM *default_N;
+} SRP_VBASE;
+
+/*
+ * Internal structure storing N and g pair
+ */
+typedef struct SRP_gN_st {
+    char *id;
+    const BIGNUM *g;
+    const BIGNUM *N;
+} SRP_gN;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN, SRP_gN, SRP_gN)
+#define sk_SRP_gN_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_value(sk, idx) ((SRP_gN *)OPENSSL_sk_value(ossl_check_const_SRP_gN_sk_type(sk), (idx)))
+#define sk_SRP_gN_new(cmp) ((STACK_OF(SRP_gN) *)OPENSSL_sk_new(ossl_check_SRP_gN_compfunc_type(cmp)))
+#define sk_SRP_gN_new_null() ((STACK_OF(SRP_gN) *)OPENSSL_sk_new_null())
+#define sk_SRP_gN_new_reserve(cmp, n) ((STACK_OF(SRP_gN) *)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_compfunc_type(cmp), (n)))
+#define sk_SRP_gN_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_sk_type(sk), (n))
+#define sk_SRP_gN_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_delete(sk, i) ((SRP_gN *)OPENSSL_sk_delete(ossl_check_SRP_gN_sk_type(sk), (i)))
+#define sk_SRP_gN_delete_ptr(sk, ptr) ((SRP_gN *)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr)))
+#define sk_SRP_gN_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_pop(sk) ((SRP_gN *)OPENSSL_sk_pop(ossl_check_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_shift(sk) ((SRP_gN *)OPENSSL_sk_shift(ossl_check_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_sk_type(sk),ossl_check_SRP_gN_freefunc_type(freefunc))
+#define sk_SRP_gN_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), (idx))
+#define sk_SRP_gN_set(sk, idx, ptr) ((SRP_gN *)OPENSSL_sk_set(ossl_check_SRP_gN_sk_type(sk), (idx), ossl_check_SRP_gN_type(ptr)))
+#define sk_SRP_gN_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), pnum)
+#define sk_SRP_gN_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_dup(sk) ((STACK_OF(SRP_gN) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_sk_type(sk), ossl_check_SRP_gN_copyfunc_type(copyfunc), ossl_check_SRP_gN_freefunc_type(freefunc)))
+#define sk_SRP_gN_set_cmp_func(sk, cmp) ((sk_SRP_gN_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_compfunc_type(cmp)))
+
+
+
+OSSL_DEPRECATEDIN_3_0
+SRP_VBASE *SRP_VBASE_new(char *seed_key);
+OSSL_DEPRECATEDIN_3_0
+void SRP_VBASE_free(SRP_VBASE *vb);
+OSSL_DEPRECATEDIN_3_0
+int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file);
+
+OSSL_DEPRECATEDIN_3_0
+int SRP_VBASE_add0_user(SRP_VBASE *vb, SRP_user_pwd *user_pwd);
+
+/* NOTE: unlike in SRP_VBASE_get_by_user, caller owns the returned pointer.*/
+OSSL_DEPRECATEDIN_3_0
+SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username);
+
+OSSL_DEPRECATEDIN_3_0
+char *SRP_create_verifier_ex(const char *user, const char *pass, char **salt,
+                             char **verifier, const char *N, const char *g,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+char *SRP_create_verifier(const char *user, const char *pass, char **salt,
+                          char **verifier, const char *N, const char *g);
+OSSL_DEPRECATEDIN_3_0
+int SRP_create_verifier_BN_ex(const char *user, const char *pass, BIGNUM **salt,
+                              BIGNUM **verifier, const BIGNUM *N,
+                              const BIGNUM *g, OSSL_LIB_CTX *libctx,
+                              const char *propq);
+OSSL_DEPRECATEDIN_3_0
+int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt,
+                           BIGNUM **verifier, const BIGNUM *N,
+                           const BIGNUM *g);
+
+#  define SRP_NO_ERROR 0
+#  define SRP_ERR_VBASE_INCOMPLETE_FILE 1
+#  define SRP_ERR_VBASE_BN_LIB 2
+#  define SRP_ERR_OPEN_FILE 3
+#  define SRP_ERR_MEMORY 4
+
+#  define DB_srptype      0
+#  define DB_srpverifier  1
+#  define DB_srpsalt      2
+#  define DB_srpid        3
+#  define DB_srpgN        4
+#  define DB_srpinfo      5
+#  undef  DB_NUMBER
+#  define DB_NUMBER       6
+
+#  define DB_SRP_INDEX    'I'
+#  define DB_SRP_VALID    'V'
+#  define DB_SRP_REVOKED  'R'
+#  define DB_SRP_MODIF    'v'
+
+/* see srp.c */
+OSSL_DEPRECATEDIN_3_0
+char *SRP_check_known_gN_param(const BIGNUM *g, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+SRP_gN *SRP_get_default_gN(const char *id);
+
+/* server side .... */
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_server_key(const BIGNUM *A, const BIGNUM *v, const BIGNUM *u,
+                            const BIGNUM *b, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_B_ex(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g,
+                      const BIGNUM *v, OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_B(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g,
+                   const BIGNUM *v);
+
+OSSL_DEPRECATEDIN_3_0
+int SRP_Verify_A_mod_N(const BIGNUM *A, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_u_ex(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N,
+                      OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_u(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N);
+
+/* client side .... */
+
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_x_ex(const BIGNUM *s, const char *user, const char *pass,
+                      OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_x(const BIGNUM *s, const char *user, const char *pass);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_A(const BIGNUM *a, const BIGNUM *N, const BIGNUM *g);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_client_key_ex(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g,
+                            const BIGNUM *x, const BIGNUM *a, const BIGNUM *u,
+                            OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_client_key(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g,
+                            const BIGNUM *x, const BIGNUM *a, const BIGNUM *u);
+OSSL_DEPRECATEDIN_3_0
+int SRP_Verify_B_mod_N(const BIGNUM *B, const BIGNUM *N);
+
+#  define SRP_MINIMAL_N 1024
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/* This method ignores the configured seed and fails for an unknown user. */
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0
+SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/srtp.h b/CAPI/cpp/grpc/include/openssl/srtp.h
new file mode 100644
index 0000000..d64606e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/srtp.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2011-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * DTLS code by Eric Rescorla <ekr@rtfm.com>
+ *
+ * Copyright (C) 2006, Network Resonance, Inc. Copyright (C) 2011, RTFM, Inc.
+ */
+
+#ifndef OPENSSL_SRTP_H
+# define OPENSSL_SRTP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_D1_SRTP_H
+# endif
+
+# include <openssl/ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define SRTP_AES128_CM_SHA1_80 0x0001
+# define SRTP_AES128_CM_SHA1_32 0x0002
+# define SRTP_AES128_F8_SHA1_80 0x0003
+# define SRTP_AES128_F8_SHA1_32 0x0004
+# define SRTP_NULL_SHA1_80      0x0005
+# define SRTP_NULL_SHA1_32      0x0006
+
+/* AEAD SRTP protection profiles from RFC 7714 */
+# define SRTP_AEAD_AES_128_GCM  0x0007
+# define SRTP_AEAD_AES_256_GCM  0x0008
+
+# ifndef OPENSSL_NO_SRTP
+
+__owur int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles);
+__owur int SSL_set_tlsext_use_srtp(SSL *ssl, const char *profiles);
+
+__owur STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *ssl);
+__owur SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s);
+
+# endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ssl.h b/CAPI/cpp/grpc/include/openssl/ssl.h
new file mode 100644
index 0000000..441b818
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ssl.h
@@ -0,0 +1,2599 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ssl.h.in
+ *
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ * Copyright 2005 Nokia. All rights reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_SSL_H
+# define OPENSSL_SSL_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SSL_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/opensslconf.h>
+# include <openssl/comp.h>
+# include <openssl/bio.h>
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/x509.h>
+#  include <openssl/crypto.h>
+#  include <openssl/buffer.h>
+# endif
+# include <openssl/lhash.h>
+# include <openssl/pem.h>
+# include <openssl/hmac.h>
+# include <openssl/async.h>
+
+# include <openssl/safestack.h>
+# include <openssl/symhacks.h>
+# include <openssl/ct.h>
+# include <openssl/sslerr.h>
+# include <openssl/prov_ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* OpenSSL version number for ASN.1 encoding of the session information */
+/*-
+ * Version 0 - initial version
+ * Version 1 - added the optional peer certificate
+ */
+# define SSL_SESSION_ASN1_VERSION 0x0001
+
+# define SSL_MAX_SSL_SESSION_ID_LENGTH           32
+# define SSL_MAX_SID_CTX_LENGTH                  32
+
+# define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES     (512/8)
+# define SSL_MAX_KEY_ARG_LENGTH                  8
+/* SSL_MAX_MASTER_KEY_LENGTH is defined in prov_ssl.h */
+
+/* The maximum number of encrypt/decrypt pipelines we can support */
+# define SSL_MAX_PIPELINES  32
+
+/* text strings for the ciphers */
+
+/* These are used to specify which ciphers to use and not to use */
+
+# define SSL_TXT_LOW             "LOW"
+# define SSL_TXT_MEDIUM          "MEDIUM"
+# define SSL_TXT_HIGH            "HIGH"
+# define SSL_TXT_FIPS            "FIPS"
+
+# define SSL_TXT_aNULL           "aNULL"
+# define SSL_TXT_eNULL           "eNULL"
+# define SSL_TXT_NULL            "NULL"
+
+# define SSL_TXT_kRSA            "kRSA"
+# define SSL_TXT_kDHr            "kDHr"/* this cipher class has been removed */
+# define SSL_TXT_kDHd            "kDHd"/* this cipher class has been removed */
+# define SSL_TXT_kDH             "kDH"/* this cipher class has been removed */
+# define SSL_TXT_kEDH            "kEDH"/* alias for kDHE */
+# define SSL_TXT_kDHE            "kDHE"
+# define SSL_TXT_kECDHr          "kECDHr"/* this cipher class has been removed */
+# define SSL_TXT_kECDHe          "kECDHe"/* this cipher class has been removed */
+# define SSL_TXT_kECDH           "kECDH"/* this cipher class has been removed */
+# define SSL_TXT_kEECDH          "kEECDH"/* alias for kECDHE */
+# define SSL_TXT_kECDHE          "kECDHE"
+# define SSL_TXT_kPSK            "kPSK"
+# define SSL_TXT_kRSAPSK         "kRSAPSK"
+# define SSL_TXT_kECDHEPSK       "kECDHEPSK"
+# define SSL_TXT_kDHEPSK         "kDHEPSK"
+# define SSL_TXT_kGOST           "kGOST"
+# define SSL_TXT_kGOST18         "kGOST18"
+# define SSL_TXT_kSRP            "kSRP"
+
+# define SSL_TXT_aRSA            "aRSA"
+# define SSL_TXT_aDSS            "aDSS"
+# define SSL_TXT_aDH             "aDH"/* this cipher class has been removed */
+# define SSL_TXT_aECDH           "aECDH"/* this cipher class has been removed */
+# define SSL_TXT_aECDSA          "aECDSA"
+# define SSL_TXT_aPSK            "aPSK"
+# define SSL_TXT_aGOST94         "aGOST94"
+# define SSL_TXT_aGOST01         "aGOST01"
+# define SSL_TXT_aGOST12         "aGOST12"
+# define SSL_TXT_aGOST           "aGOST"
+# define SSL_TXT_aSRP            "aSRP"
+
+# define SSL_TXT_DSS             "DSS"
+# define SSL_TXT_DH              "DH"
+# define SSL_TXT_DHE             "DHE"/* same as "kDHE:-ADH" */
+# define SSL_TXT_EDH             "EDH"/* alias for DHE */
+# define SSL_TXT_ADH             "ADH"
+# define SSL_TXT_RSA             "RSA"
+# define SSL_TXT_ECDH            "ECDH"
+# define SSL_TXT_EECDH           "EECDH"/* alias for ECDHE" */
+# define SSL_TXT_ECDHE           "ECDHE"/* same as "kECDHE:-AECDH" */
+# define SSL_TXT_AECDH           "AECDH"
+# define SSL_TXT_ECDSA           "ECDSA"
+# define SSL_TXT_PSK             "PSK"
+# define SSL_TXT_SRP             "SRP"
+
+# define SSL_TXT_DES             "DES"
+# define SSL_TXT_3DES            "3DES"
+# define SSL_TXT_RC4             "RC4"
+# define SSL_TXT_RC2             "RC2"
+# define SSL_TXT_IDEA            "IDEA"
+# define SSL_TXT_SEED            "SEED"
+# define SSL_TXT_AES128          "AES128"
+# define SSL_TXT_AES256          "AES256"
+# define SSL_TXT_AES             "AES"
+# define SSL_TXT_AES_GCM         "AESGCM"
+# define SSL_TXT_AES_CCM         "AESCCM"
+# define SSL_TXT_AES_CCM_8       "AESCCM8"
+# define SSL_TXT_CAMELLIA128     "CAMELLIA128"
+# define SSL_TXT_CAMELLIA256     "CAMELLIA256"
+# define SSL_TXT_CAMELLIA        "CAMELLIA"
+# define SSL_TXT_CHACHA20        "CHACHA20"
+# define SSL_TXT_GOST            "GOST89"
+# define SSL_TXT_ARIA            "ARIA"
+# define SSL_TXT_ARIA_GCM        "ARIAGCM"
+# define SSL_TXT_ARIA128         "ARIA128"
+# define SSL_TXT_ARIA256         "ARIA256"
+# define SSL_TXT_GOST2012_GOST8912_GOST8912 "GOST2012-GOST8912-GOST8912"
+# define SSL_TXT_CBC             "CBC"
+
+# define SSL_TXT_MD5             "MD5"
+# define SSL_TXT_SHA1            "SHA1"
+# define SSL_TXT_SHA             "SHA"/* same as "SHA1" */
+# define SSL_TXT_GOST94          "GOST94"
+# define SSL_TXT_GOST89MAC       "GOST89MAC"
+# define SSL_TXT_GOST12          "GOST12"
+# define SSL_TXT_GOST89MAC12     "GOST89MAC12"
+# define SSL_TXT_SHA256          "SHA256"
+# define SSL_TXT_SHA384          "SHA384"
+
+# define SSL_TXT_SSLV3           "SSLv3"
+# define SSL_TXT_TLSV1           "TLSv1"
+# define SSL_TXT_TLSV1_1         "TLSv1.1"
+# define SSL_TXT_TLSV1_2         "TLSv1.2"
+
+# define SSL_TXT_ALL             "ALL"
+
+/*-
+ * COMPLEMENTOF* definitions. These identifiers are used to (de-select)
+ * ciphers normally not being used.
+ * Example: "RC4" will activate all ciphers using RC4 including ciphers
+ * without authentication, which would normally disabled by DEFAULT (due
+ * the "!ADH" being part of default). Therefore "RC4:!COMPLEMENTOFDEFAULT"
+ * will make sure that it is also disabled in the specific selection.
+ * COMPLEMENTOF* identifiers are portable between version, as adjustments
+ * to the default cipher setup will also be included here.
+ *
+ * COMPLEMENTOFDEFAULT does not experience the same special treatment that
+ * DEFAULT gets, as only selection is being done and no sorting as needed
+ * for DEFAULT.
+ */
+# define SSL_TXT_CMPALL          "COMPLEMENTOFALL"
+# define SSL_TXT_CMPDEF          "COMPLEMENTOFDEFAULT"
+
+/*
+ * The following cipher list is used by default. It also is substituted when
+ * an application-defined cipher list string starts with 'DEFAULT'.
+ * This applies to ciphersuites for TLSv1.2 and below.
+ * DEPRECATED IN 3.0.0, in favor of OSSL_default_cipher_list()
+ * Update both macro and function simultaneously
+ */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_DEFAULT_CIPHER_LIST "ALL:!COMPLEMENTOFDEFAULT:!eNULL"
+/*
+ * This is the default set of TLSv1.3 ciphersuites
+ * DEPRECATED IN 3.0.0, in favor of OSSL_default_ciphersuites()
+ * Update both macro and function simultaneously
+ */
+#  define TLS_DEFAULT_CIPHERSUITES "TLS_AES_256_GCM_SHA384:" \
+                                   "TLS_CHACHA20_POLY1305_SHA256:" \
+                                   "TLS_AES_128_GCM_SHA256"
+# endif
+/*
+ * As of OpenSSL 1.0.0, ssl_create_cipher_list() in ssl/ssl_ciph.c always
+ * starts with a reasonable order, and all we have to do for DEFAULT is
+ * throwing out anonymous and unencrypted ciphersuites! (The latter are not
+ * actually enabled by ALL, but "ALL:RSA" would enable some of them.)
+ */
+
+/* Used in SSL_set_shutdown()/SSL_get_shutdown(); */
+# define SSL_SENT_SHUTDOWN       1
+# define SSL_RECEIVED_SHUTDOWN   2
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define SSL_FILETYPE_ASN1       X509_FILETYPE_ASN1
+# define SSL_FILETYPE_PEM        X509_FILETYPE_PEM
+
+/*
+ * This is needed to stop compilers complaining about the 'struct ssl_st *'
+ * function parameters used to prototype callbacks in SSL_CTX.
+ */
+typedef struct ssl_st *ssl_crock_st;
+typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT;
+typedef struct ssl_method_st SSL_METHOD;
+typedef struct ssl_cipher_st SSL_CIPHER;
+typedef struct ssl_session_st SSL_SESSION;
+typedef struct tls_sigalgs_st TLS_SIGALGS;
+typedef struct ssl_conf_ctx_st SSL_CONF_CTX;
+typedef struct ssl_comp_st SSL_COMP;
+
+STACK_OF(SSL_CIPHER);
+STACK_OF(SSL_COMP);
+
+/* SRTP protection profiles for use with the use_srtp extension (RFC 5764)*/
+typedef struct srtp_protection_profile_st {
+    const char *name;
+    unsigned long id;
+} SRTP_PROTECTION_PROFILE;
+SKM_DEFINE_STACK_OF_INTERNAL(SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE)
+#define sk_SRTP_PROTECTION_PROFILE_num(sk) OPENSSL_sk_num(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_value(sk, idx) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_value(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx)))
+#define sk_SRTP_PROTECTION_PROFILE_new(cmp) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)))
+#define sk_SRTP_PROTECTION_PROFILE_new_null() ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new_null())
+#define sk_SRTP_PROTECTION_PROFILE_new_reserve(cmp, n) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new_reserve(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp), (n)))
+#define sk_SRTP_PROTECTION_PROFILE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (n))
+#define sk_SRTP_PROTECTION_PROFILE_free(sk) OPENSSL_sk_free(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_zero(sk) OPENSSL_sk_zero(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_delete(sk, i) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_delete(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (i)))
+#define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, ptr) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_delete_ptr(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr)))
+#define sk_SRTP_PROTECTION_PROFILE_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
+#define sk_SRTP_PROTECTION_PROFILE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
+#define sk_SRTP_PROTECTION_PROFILE_pop(sk) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_pop(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_shift(sk) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_shift(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk),ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc))
+#define sk_SRTP_PROTECTION_PROFILE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr), (idx))
+#define sk_SRTP_PROTECTION_PROFILE_set(sk, idx, ptr) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_set(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr)))
+#define sk_SRTP_PROTECTION_PROFILE_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
+#define sk_SRTP_PROTECTION_PROFILE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
+#define sk_SRTP_PROTECTION_PROFILE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr), pnum)
+#define sk_SRTP_PROTECTION_PROFILE_sort(sk) OPENSSL_sk_sort(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk))
+#define sk_SRTP_PROTECTION_PROFILE_dup(sk) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_dup(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_deep_copy(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_copyfunc_type(copyfunc), ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc)))
+#define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, cmp) ((sk_SRTP_PROTECTION_PROFILE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)))
+
+
+
+typedef int (*tls_session_ticket_ext_cb_fn)(SSL *s, const unsigned char *data,
+                                            int len, void *arg);
+typedef int (*tls_session_secret_cb_fn)(SSL *s, void *secret, int *secret_len,
+                                        STACK_OF(SSL_CIPHER) *peer_ciphers,
+                                        const SSL_CIPHER **cipher, void *arg);
+
+/* Extension context codes */
+/* This extension is only allowed in TLS */
+#define SSL_EXT_TLS_ONLY                        0x0001
+/* This extension is only allowed in DTLS */
+#define SSL_EXT_DTLS_ONLY                       0x0002
+/* Some extensions may be allowed in DTLS but we don't implement them for it */
+#define SSL_EXT_TLS_IMPLEMENTATION_ONLY         0x0004
+/* Most extensions are not defined for SSLv3 but EXT_TYPE_renegotiate is */
+#define SSL_EXT_SSL3_ALLOWED                    0x0008
+/* Extension is only defined for TLS1.2 and below */
+#define SSL_EXT_TLS1_2_AND_BELOW_ONLY           0x0010
+/* Extension is only defined for TLS1.3 and above */
+#define SSL_EXT_TLS1_3_ONLY                     0x0020
+/* Ignore this extension during parsing if we are resuming */
+#define SSL_EXT_IGNORE_ON_RESUMPTION            0x0040
+#define SSL_EXT_CLIENT_HELLO                    0x0080
+/* Really means TLS1.2 or below */
+#define SSL_EXT_TLS1_2_SERVER_HELLO             0x0100
+#define SSL_EXT_TLS1_3_SERVER_HELLO             0x0200
+#define SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS     0x0400
+#define SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST      0x0800
+#define SSL_EXT_TLS1_3_CERTIFICATE              0x1000
+#define SSL_EXT_TLS1_3_NEW_SESSION_TICKET       0x2000
+#define SSL_EXT_TLS1_3_CERTIFICATE_REQUEST      0x4000
+
+/* Typedefs for handling custom extensions */
+
+typedef int (*custom_ext_add_cb)(SSL *s, unsigned int ext_type,
+                                 const unsigned char **out, size_t *outlen,
+                                 int *al, void *add_arg);
+
+typedef void (*custom_ext_free_cb)(SSL *s, unsigned int ext_type,
+                                   const unsigned char *out, void *add_arg);
+
+typedef int (*custom_ext_parse_cb)(SSL *s, unsigned int ext_type,
+                                   const unsigned char *in, size_t inlen,
+                                   int *al, void *parse_arg);
+
+
+typedef int (*SSL_custom_ext_add_cb_ex)(SSL *s, unsigned int ext_type,
+                                        unsigned int context,
+                                        const unsigned char **out,
+                                        size_t *outlen, X509 *x,
+                                        size_t chainidx,
+                                        int *al, void *add_arg);
+
+typedef void (*SSL_custom_ext_free_cb_ex)(SSL *s, unsigned int ext_type,
+                                          unsigned int context,
+                                          const unsigned char *out,
+                                          void *add_arg);
+
+typedef int (*SSL_custom_ext_parse_cb_ex)(SSL *s, unsigned int ext_type,
+                                          unsigned int context,
+                                          const unsigned char *in,
+                                          size_t inlen, X509 *x,
+                                          size_t chainidx,
+                                          int *al, void *parse_arg);
+
+/* Typedef for verification callback */
+typedef int (*SSL_verify_cb)(int preverify_ok, X509_STORE_CTX *x509_ctx);
+
+/* Typedef for SSL async callback */
+typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
+
+#define SSL_OP_BIT(n)  ((uint64_t)1 << (uint64_t)n)
+
+/*
+ * SSL/TLS connection options.
+ */
+    /* Disable Extended master secret */
+# define SSL_OP_NO_EXTENDED_MASTER_SECRET                SSL_OP_BIT(0)
+    /* Cleanse plaintext copies of data delivered to the application */
+# define SSL_OP_CLEANSE_PLAINTEXT                        SSL_OP_BIT(1)
+    /* Allow initial connection to servers that don't support RI */
+# define SSL_OP_LEGACY_SERVER_CONNECT                    SSL_OP_BIT(2)
+    /* Enable support for Kernel TLS */
+# define SSL_OP_ENABLE_KTLS                              SSL_OP_BIT(3)
+# define SSL_OP_TLSEXT_PADDING                           SSL_OP_BIT(4)
+# define SSL_OP_SAFARI_ECDHE_ECDSA_BUG                   SSL_OP_BIT(6)
+# define SSL_OP_IGNORE_UNEXPECTED_EOF                    SSL_OP_BIT(7)
+# define SSL_OP_ALLOW_CLIENT_RENEGOTIATION               SSL_OP_BIT(8)
+# define SSL_OP_DISABLE_TLSEXT_CA_NAMES                  SSL_OP_BIT(9)
+    /* In TLSv1.3 allow a non-(ec)dhe based kex_mode */
+# define SSL_OP_ALLOW_NO_DHE_KEX                         SSL_OP_BIT(10)
+    /*
+     * Disable SSL 3.0/TLS 1.0 CBC vulnerability workaround that was added
+     * in OpenSSL 0.9.6d.  Usually (depending on the application protocol)
+     * the workaround is not needed.  Unfortunately some broken SSL/TLS
+     * implementations cannot handle it at all, which is why we include it
+     * in SSL_OP_ALL. Added in 0.9.6e
+     */
+# define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS              SSL_OP_BIT(11)
+    /* DTLS options */
+# define SSL_OP_NO_QUERY_MTU                             SSL_OP_BIT(12)
+    /* Turn on Cookie Exchange (on relevant for servers) */
+# define SSL_OP_COOKIE_EXCHANGE                          SSL_OP_BIT(13)
+    /* Don't use RFC4507 ticket extension */
+# define SSL_OP_NO_TICKET                                SSL_OP_BIT(14)
+# ifndef OPENSSL_NO_DTLS1_METHOD
+    /*
+     * Use Cisco's version identifier of DTLS_BAD_VER
+     * (only with deprecated DTLSv1_client_method())
+     */
+#  define SSL_OP_CISCO_ANYCONNECT                        SSL_OP_BIT(15)
+# endif
+    /* As server, disallow session resumption on renegotiation */
+# define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION   SSL_OP_BIT(16)
+    /* Don't use compression even if supported */
+# define SSL_OP_NO_COMPRESSION                           SSL_OP_BIT(17)
+    /* Permit unsafe legacy renegotiation */
+# define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION        SSL_OP_BIT(18)
+    /* Disable encrypt-then-mac */
+# define SSL_OP_NO_ENCRYPT_THEN_MAC                      SSL_OP_BIT(19)
+    /*
+     * Enable TLSv1.3 Compatibility mode. This is on by default. A future
+     * version of OpenSSL may have this disabled by default.
+     */
+# define SSL_OP_ENABLE_MIDDLEBOX_COMPAT                  SSL_OP_BIT(20)
+    /*
+     * Prioritize Chacha20Poly1305 when client does.
+     * Modifies SSL_OP_CIPHER_SERVER_PREFERENCE
+     */
+# define SSL_OP_PRIORITIZE_CHACHA                        SSL_OP_BIT(21)
+    /*
+     * Set on servers to choose the cipher according to server's preferences.
+     */
+# define SSL_OP_CIPHER_SERVER_PREFERENCE                 SSL_OP_BIT(22)
+    /*
+     * If set, a server will allow a client to issue a SSLv3.0 version
+     * number as latest version supported in the premaster secret, even when
+     * TLSv1.0 (version 3.1) was announced in the client hello. Normally
+     * this is forbidden to prevent version rollback attacks.
+     */
+# define SSL_OP_TLS_ROLLBACK_BUG                         SSL_OP_BIT(23)
+    /*
+     * Switches off automatic TLSv1.3 anti-replay protection for early data.
+     * This is a server-side option only (no effect on the client).
+     */
+# define SSL_OP_NO_ANTI_REPLAY                           SSL_OP_BIT(24)
+# define SSL_OP_NO_SSLv3                                 SSL_OP_BIT(25)
+# define SSL_OP_NO_TLSv1                                 SSL_OP_BIT(26)
+# define SSL_OP_NO_TLSv1_2                               SSL_OP_BIT(27)
+# define SSL_OP_NO_TLSv1_1                               SSL_OP_BIT(28)
+# define SSL_OP_NO_TLSv1_3                               SSL_OP_BIT(29)
+# define SSL_OP_NO_DTLSv1                                SSL_OP_BIT(26)
+# define SSL_OP_NO_DTLSv1_2                              SSL_OP_BIT(27)
+    /* Disallow all renegotiation */
+# define SSL_OP_NO_RENEGOTIATION                         SSL_OP_BIT(30)
+    /*
+     * Make server add server-hello extension from early version of
+     * cryptopro draft, when GOST ciphersuite is negotiated. Required for
+     * interoperability with CryptoPro CSP 3.x
+     */
+# define SSL_OP_CRYPTOPRO_TLSEXT_BUG                     SSL_OP_BIT(31)
+
+/*
+ * Option "collections."
+ */
+# define SSL_OP_NO_SSL_MASK \
+        ( SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 \
+          | SSL_OP_NO_TLSv1_2 | SSL_OP_NO_TLSv1_3 )
+# define SSL_OP_NO_DTLS_MASK \
+        ( SSL_OP_NO_DTLSv1 | SSL_OP_NO_DTLSv1_2 )
+
+/* Various bug workarounds that should be rather harmless. */
+# define SSL_OP_ALL \
+        ( SSL_OP_CRYPTOPRO_TLSEXT_BUG | SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS \
+          | SSL_OP_TLSEXT_PADDING | SSL_OP_SAFARI_ECDHE_ECDSA_BUG )
+
+/*
+ * OBSOLETE OPTIONS retained for compatibility
+ */
+
+# define SSL_OP_MICROSOFT_SESS_ID_BUG                    0x0
+# define SSL_OP_NETSCAPE_CHALLENGE_BUG                   0x0
+# define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG         0x0
+# define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG              0x0
+# define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER               0x0
+# define SSL_OP_MSIE_SSLV2_RSA_PADDING                   0x0
+# define SSL_OP_SSLEAY_080_CLIENT_DH_BUG                 0x0
+# define SSL_OP_TLS_D5_BUG                               0x0
+# define SSL_OP_TLS_BLOCK_PADDING_BUG                    0x0
+# define SSL_OP_SINGLE_ECDH_USE                          0x0
+# define SSL_OP_SINGLE_DH_USE                            0x0
+# define SSL_OP_EPHEMERAL_RSA                            0x0
+# define SSL_OP_NO_SSLv2                                 0x0
+# define SSL_OP_PKCS1_CHECK_1                            0x0
+# define SSL_OP_PKCS1_CHECK_2                            0x0
+# define SSL_OP_NETSCAPE_CA_DN_BUG                       0x0
+# define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG          0x0
+
+/*
+ * Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success
+ * when just a single record has been written):
+ */
+# define SSL_MODE_ENABLE_PARTIAL_WRITE       0x00000001U
+/*
+ * Make it possible to retry SSL_write() with changed buffer location (buffer
+ * contents must stay the same!); this is not the default to avoid the
+ * misconception that non-blocking SSL_write() behaves like non-blocking
+ * write():
+ */
+# define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002U
+/*
+ * Never bother the application with retries if the transport is blocking:
+ */
+# define SSL_MODE_AUTO_RETRY 0x00000004U
+/* Don't attempt to automatically build certificate chain */
+# define SSL_MODE_NO_AUTO_CHAIN 0x00000008U
+/*
+ * Save RAM by releasing read and write buffers when they're empty. (SSL3 and
+ * TLS only.) Released buffers are freed.
+ */
+# define SSL_MODE_RELEASE_BUFFERS 0x00000010U
+/*
+ * Send the current time in the Random fields of the ClientHello and
+ * ServerHello records for compatibility with hypothetical implementations
+ * that require it.
+ */
+# define SSL_MODE_SEND_CLIENTHELLO_TIME 0x00000020U
+# define SSL_MODE_SEND_SERVERHELLO_TIME 0x00000040U
+/*
+ * Send TLS_FALLBACK_SCSV in the ClientHello. To be set only by applications
+ * that reconnect with a downgraded protocol version; see
+ * draft-ietf-tls-downgrade-scsv-00 for details. DO NOT ENABLE THIS if your
+ * application attempts a normal handshake. Only use this in explicit
+ * fallback retries, following the guidance in
+ * draft-ietf-tls-downgrade-scsv-00.
+ */
+# define SSL_MODE_SEND_FALLBACK_SCSV 0x00000080U
+/*
+ * Support Asynchronous operation
+ */
+# define SSL_MODE_ASYNC 0x00000100U
+
+/*
+ * When using DTLS/SCTP, include the terminating zero in the label
+ * used for computing the endpoint-pair shared secret. Required for
+ * interoperability with implementations having this bug like these
+ * older version of OpenSSL:
+ * - OpenSSL 1.0.0 series
+ * - OpenSSL 1.0.1 series
+ * - OpenSSL 1.0.2 series
+ * - OpenSSL 1.1.0 series
+ * - OpenSSL 1.1.1 and 1.1.1a
+ */
+# define SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG 0x00000400U
+
+/* Cert related flags */
+/*
+ * Many implementations ignore some aspects of the TLS standards such as
+ * enforcing certificate chain algorithms. When this is set we enforce them.
+ */
+# define SSL_CERT_FLAG_TLS_STRICT                0x00000001U
+
+/* Suite B modes, takes same values as certificate verify flags */
+# define SSL_CERT_FLAG_SUITEB_128_LOS_ONLY       0x10000
+/* Suite B 192 bit only mode */
+# define SSL_CERT_FLAG_SUITEB_192_LOS            0x20000
+/* Suite B 128 bit mode allowing 192 bit algorithms */
+# define SSL_CERT_FLAG_SUITEB_128_LOS            0x30000
+
+/* Perform all sorts of protocol violations for testing purposes */
+# define SSL_CERT_FLAG_BROKEN_PROTOCOL           0x10000000
+
+/* Flags for building certificate chains */
+/* Treat any existing certificates as untrusted CAs */
+# define SSL_BUILD_CHAIN_FLAG_UNTRUSTED          0x1
+/* Don't include root CA in chain */
+# define SSL_BUILD_CHAIN_FLAG_NO_ROOT            0x2
+/* Just check certificates already there */
+# define SSL_BUILD_CHAIN_FLAG_CHECK              0x4
+/* Ignore verification errors */
+# define SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR       0x8
+/* Clear verification errors from queue */
+# define SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR        0x10
+
+/* Flags returned by SSL_check_chain */
+/* Certificate can be used with this session */
+# define CERT_PKEY_VALID         0x1
+/* Certificate can also be used for signing */
+# define CERT_PKEY_SIGN          0x2
+/* EE certificate signing algorithm OK */
+# define CERT_PKEY_EE_SIGNATURE  0x10
+/* CA signature algorithms OK */
+# define CERT_PKEY_CA_SIGNATURE  0x20
+/* EE certificate parameters OK */
+# define CERT_PKEY_EE_PARAM      0x40
+/* CA certificate parameters OK */
+# define CERT_PKEY_CA_PARAM      0x80
+/* Signing explicitly allowed as opposed to SHA1 fallback */
+# define CERT_PKEY_EXPLICIT_SIGN 0x100
+/* Client CA issuer names match (always set for server cert) */
+# define CERT_PKEY_ISSUER_NAME   0x200
+/* Cert type matches client types (always set for server cert) */
+# define CERT_PKEY_CERT_TYPE     0x400
+/* Cert chain suitable to Suite B */
+# define CERT_PKEY_SUITEB        0x800
+
+# define SSL_CONF_FLAG_CMDLINE           0x1
+# define SSL_CONF_FLAG_FILE              0x2
+# define SSL_CONF_FLAG_CLIENT            0x4
+# define SSL_CONF_FLAG_SERVER            0x8
+# define SSL_CONF_FLAG_SHOW_ERRORS       0x10
+# define SSL_CONF_FLAG_CERTIFICATE       0x20
+# define SSL_CONF_FLAG_REQUIRE_PRIVATE   0x40
+/* Configuration value types */
+# define SSL_CONF_TYPE_UNKNOWN           0x0
+# define SSL_CONF_TYPE_STRING            0x1
+# define SSL_CONF_TYPE_FILE              0x2
+# define SSL_CONF_TYPE_DIR               0x3
+# define SSL_CONF_TYPE_NONE              0x4
+# define SSL_CONF_TYPE_STORE             0x5
+
+/* Maximum length of the application-controlled segment of a a TLSv1.3 cookie */
+# define SSL_COOKIE_LENGTH                       4096
+
+/*
+ * Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value, they
+ * cannot be used to clear bits.
+ */
+
+uint64_t SSL_CTX_get_options(const SSL_CTX *ctx);
+uint64_t SSL_get_options(const SSL *s);
+uint64_t SSL_CTX_clear_options(SSL_CTX *ctx, uint64_t op);
+uint64_t SSL_clear_options(SSL *s, uint64_t op);
+uint64_t SSL_CTX_set_options(SSL_CTX *ctx, uint64_t op);
+uint64_t SSL_set_options(SSL *s, uint64_t op);
+
+# define SSL_CTX_set_mode(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,(op),NULL)
+# define SSL_CTX_clear_mode(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_MODE,(op),NULL)
+# define SSL_CTX_get_mode(ctx) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,0,NULL)
+# define SSL_clear_mode(ssl,op) \
+        SSL_ctrl((ssl),SSL_CTRL_CLEAR_MODE,(op),NULL)
+# define SSL_set_mode(ssl,op) \
+        SSL_ctrl((ssl),SSL_CTRL_MODE,(op),NULL)
+# define SSL_get_mode(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_MODE,0,NULL)
+# define SSL_set_mtu(ssl, mtu) \
+        SSL_ctrl((ssl),SSL_CTRL_SET_MTU,(mtu),NULL)
+# define DTLS_set_link_mtu(ssl, mtu) \
+        SSL_ctrl((ssl),DTLS_CTRL_SET_LINK_MTU,(mtu),NULL)
+# define DTLS_get_link_min_mtu(ssl) \
+        SSL_ctrl((ssl),DTLS_CTRL_GET_LINK_MIN_MTU,0,NULL)
+
+# define SSL_get_secure_renegotiation_support(ssl) \
+        SSL_ctrl((ssl), SSL_CTRL_GET_RI_SUPPORT, 0, NULL)
+
+# define SSL_CTX_set_cert_flags(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_CERT_FLAGS,(op),NULL)
+# define SSL_set_cert_flags(s,op) \
+        SSL_ctrl((s),SSL_CTRL_CERT_FLAGS,(op),NULL)
+# define SSL_CTX_clear_cert_flags(ctx,op) \
+        SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL)
+# define SSL_clear_cert_flags(s,op) \
+        SSL_ctrl((s),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL)
+
+void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
+                              void (*cb) (int write_p, int version,
+                                          int content_type, const void *buf,
+                                          size_t len, SSL *ssl, void *arg));
+void SSL_set_msg_callback(SSL *ssl,
+                          void (*cb) (int write_p, int version,
+                                      int content_type, const void *buf,
+                                      size_t len, SSL *ssl, void *arg));
+# define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
+# define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
+
+# define SSL_get_extms_support(s) \
+        SSL_ctrl((s),SSL_CTRL_GET_EXTMS_SUPPORT,0,NULL)
+
+# ifndef OPENSSL_NO_SRP
+/* see tls_srp.c */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 __owur int SSL_SRP_CTX_init(SSL *s);
+OSSL_DEPRECATEDIN_3_0 __owur int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 int SSL_SRP_CTX_free(SSL *ctx);
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx);
+OSSL_DEPRECATEDIN_3_0 __owur int SSL_srp_server_param_with_username(SSL *s,
+                                                                    int *ad);
+OSSL_DEPRECATEDIN_3_0 __owur int SRP_Calc_A_param(SSL *s);
+#  endif
+# endif
+
+/* 100k max cert list */
+# define SSL_MAX_CERT_LIST_DEFAULT (1024*100)
+
+# define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT      (1024*20)
+
+/*
+ * This callback type is used inside SSL_CTX, SSL, and in the functions that
+ * set them. It is used to override the generation of SSL/TLS session IDs in
+ * a server. Return value should be zero on an error, non-zero to proceed.
+ * Also, callbacks should themselves check if the id they generate is unique
+ * otherwise the SSL handshake will fail with an error - callbacks can do
+ * this using the 'ssl' value they're passed by;
+ * SSL_has_matching_session_id(ssl, id, *id_len) The length value passed in
+ * is set at the maximum size the session ID can be. In SSLv3/TLSv1 it is 32
+ * bytes. The callback can alter this length to be less if desired. It is
+ * also an error for the callback to set the size to zero.
+ */
+typedef int (*GEN_SESSION_CB) (SSL *ssl, unsigned char *id,
+                               unsigned int *id_len);
+
+# define SSL_SESS_CACHE_OFF                      0x0000
+# define SSL_SESS_CACHE_CLIENT                   0x0001
+# define SSL_SESS_CACHE_SERVER                   0x0002
+# define SSL_SESS_CACHE_BOTH     (SSL_SESS_CACHE_CLIENT|SSL_SESS_CACHE_SERVER)
+# define SSL_SESS_CACHE_NO_AUTO_CLEAR            0x0080
+/* enough comments already ... see SSL_CTX_set_session_cache_mode(3) */
+# define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP       0x0100
+# define SSL_SESS_CACHE_NO_INTERNAL_STORE        0x0200
+# define SSL_SESS_CACHE_NO_INTERNAL \
+        (SSL_SESS_CACHE_NO_INTERNAL_LOOKUP|SSL_SESS_CACHE_NO_INTERNAL_STORE)
+# define SSL_SESS_CACHE_UPDATE_TIME              0x0400
+
+LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx);
+# define SSL_CTX_sess_number(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_NUMBER,0,NULL)
+# define SSL_CTX_sess_connect(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT,0,NULL)
+# define SSL_CTX_sess_connect_good(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_GOOD,0,NULL)
+# define SSL_CTX_sess_connect_renegotiate(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_RENEGOTIATE,0,NULL)
+# define SSL_CTX_sess_accept(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT,0,NULL)
+# define SSL_CTX_sess_accept_renegotiate(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,0,NULL)
+# define SSL_CTX_sess_accept_good(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_GOOD,0,NULL)
+# define SSL_CTX_sess_hits(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_HIT,0,NULL)
+# define SSL_CTX_sess_cb_hits(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CB_HIT,0,NULL)
+# define SSL_CTX_sess_misses(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_MISSES,0,NULL)
+# define SSL_CTX_sess_timeouts(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_TIMEOUTS,0,NULL)
+# define SSL_CTX_sess_cache_full(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL)
+
+void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
+                             int (*new_session_cb) (struct ssl_st *ssl,
+                                                    SSL_SESSION *sess));
+int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,
+                                              SSL_SESSION *sess);
+void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
+                                void (*remove_session_cb) (struct ssl_ctx_st
+                                                           *ctx,
+                                                           SSL_SESSION *sess));
+void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (struct ssl_ctx_st *ctx,
+                                                  SSL_SESSION *sess);
+void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
+                             SSL_SESSION *(*get_session_cb) (struct ssl_st
+                                                             *ssl,
+                                                             const unsigned char
+                                                             *data, int len,
+                                                             int *copy));
+SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,
+                                                       const unsigned char *data,
+                                                       int len, int *copy);
+void SSL_CTX_set_info_callback(SSL_CTX *ctx,
+                               void (*cb) (const SSL *ssl, int type, int val));
+void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type,
+                                                 int val);
+void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
+                                int (*client_cert_cb) (SSL *ssl, X509 **x509,
+                                                       EVP_PKEY **pkey));
+int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509,
+                                                 EVP_PKEY **pkey);
+# ifndef OPENSSL_NO_ENGINE
+__owur int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e);
+# endif
+void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
+                                    int (*app_gen_cookie_cb) (SSL *ssl,
+                                                              unsigned char
+                                                              *cookie,
+                                                              unsigned int
+                                                              *cookie_len));
+void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,
+                                  int (*app_verify_cookie_cb) (SSL *ssl,
+                                                               const unsigned
+                                                               char *cookie,
+                                                               unsigned int
+                                                               cookie_len));
+
+void SSL_CTX_set_stateless_cookie_generate_cb(
+    SSL_CTX *ctx,
+    int (*gen_stateless_cookie_cb) (SSL *ssl,
+                                    unsigned char *cookie,
+                                    size_t *cookie_len));
+void SSL_CTX_set_stateless_cookie_verify_cb(
+    SSL_CTX *ctx,
+    int (*verify_stateless_cookie_cb) (SSL *ssl,
+                                       const unsigned char *cookie,
+                                       size_t cookie_len));
+# ifndef OPENSSL_NO_NEXTPROTONEG
+
+typedef int (*SSL_CTX_npn_advertised_cb_func)(SSL *ssl,
+                                              const unsigned char **out,
+                                              unsigned int *outlen,
+                                              void *arg);
+void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *s,
+                                           SSL_CTX_npn_advertised_cb_func cb,
+                                           void *arg);
+#  define SSL_CTX_set_npn_advertised_cb SSL_CTX_set_next_protos_advertised_cb
+
+typedef int (*SSL_CTX_npn_select_cb_func)(SSL *s,
+                                          unsigned char **out,
+                                          unsigned char *outlen,
+                                          const unsigned char *in,
+                                          unsigned int inlen,
+                                          void *arg);
+void SSL_CTX_set_next_proto_select_cb(SSL_CTX *s,
+                                      SSL_CTX_npn_select_cb_func cb,
+                                      void *arg);
+#  define SSL_CTX_set_npn_select_cb SSL_CTX_set_next_proto_select_cb
+
+void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
+                                    unsigned *len);
+#  define SSL_get0_npn_negotiated SSL_get0_next_proto_negotiated
+# endif
+
+__owur int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
+                                 const unsigned char *in, unsigned int inlen,
+                                 const unsigned char *client,
+                                 unsigned int client_len);
+
+# define OPENSSL_NPN_UNSUPPORTED 0
+# define OPENSSL_NPN_NEGOTIATED  1
+# define OPENSSL_NPN_NO_OVERLAP  2
+
+__owur int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
+                                   unsigned int protos_len);
+__owur int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
+                               unsigned int protos_len);
+typedef int (*SSL_CTX_alpn_select_cb_func)(SSL *ssl,
+                                           const unsigned char **out,
+                                           unsigned char *outlen,
+                                           const unsigned char *in,
+                                           unsigned int inlen,
+                                           void *arg);
+void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
+                                SSL_CTX_alpn_select_cb_func cb,
+                                void *arg);
+void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
+                            unsigned int *len);
+
+# ifndef OPENSSL_NO_PSK
+/*
+ * the maximum length of the buffer given to callbacks containing the
+ * resulting identity/psk
+ */
+#  define PSK_MAX_IDENTITY_LEN 256
+#  define PSK_MAX_PSK_LEN 512
+typedef unsigned int (*SSL_psk_client_cb_func)(SSL *ssl,
+                                               const char *hint,
+                                               char *identity,
+                                               unsigned int max_identity_len,
+                                               unsigned char *psk,
+                                               unsigned int max_psk_len);
+void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb);
+void SSL_set_psk_client_callback(SSL *ssl, SSL_psk_client_cb_func cb);
+
+typedef unsigned int (*SSL_psk_server_cb_func)(SSL *ssl,
+                                               const char *identity,
+                                               unsigned char *psk,
+                                               unsigned int max_psk_len);
+void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb);
+void SSL_set_psk_server_callback(SSL *ssl, SSL_psk_server_cb_func cb);
+
+__owur int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint);
+__owur int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint);
+const char *SSL_get_psk_identity_hint(const SSL *s);
+const char *SSL_get_psk_identity(const SSL *s);
+# endif
+
+typedef int (*SSL_psk_find_session_cb_func)(SSL *ssl,
+                                            const unsigned char *identity,
+                                            size_t identity_len,
+                                            SSL_SESSION **sess);
+typedef int (*SSL_psk_use_session_cb_func)(SSL *ssl, const EVP_MD *md,
+                                           const unsigned char **id,
+                                           size_t *idlen,
+                                           SSL_SESSION **sess);
+
+void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb);
+void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx,
+                                           SSL_psk_find_session_cb_func cb);
+void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb);
+void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx,
+                                          SSL_psk_use_session_cb_func cb);
+
+/* Register callbacks to handle custom TLS Extensions for client or server. */
+
+__owur int SSL_CTX_has_client_custom_ext(const SSL_CTX *ctx,
+                                         unsigned int ext_type);
+
+__owur int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx,
+                                         unsigned int ext_type,
+                                         custom_ext_add_cb add_cb,
+                                         custom_ext_free_cb free_cb,
+                                         void *add_arg,
+                                         custom_ext_parse_cb parse_cb,
+                                         void *parse_arg);
+
+__owur int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx,
+                                         unsigned int ext_type,
+                                         custom_ext_add_cb add_cb,
+                                         custom_ext_free_cb free_cb,
+                                         void *add_arg,
+                                         custom_ext_parse_cb parse_cb,
+                                         void *parse_arg);
+
+__owur int SSL_CTX_add_custom_ext(SSL_CTX *ctx, unsigned int ext_type,
+                                  unsigned int context,
+                                  SSL_custom_ext_add_cb_ex add_cb,
+                                  SSL_custom_ext_free_cb_ex free_cb,
+                                  void *add_arg,
+                                  SSL_custom_ext_parse_cb_ex parse_cb,
+                                  void *parse_arg);
+
+__owur int SSL_extension_supported(unsigned int ext_type);
+
+# define SSL_NOTHING            1
+# define SSL_WRITING            2
+# define SSL_READING            3
+# define SSL_X509_LOOKUP        4
+# define SSL_ASYNC_PAUSED       5
+# define SSL_ASYNC_NO_JOBS      6
+# define SSL_CLIENT_HELLO_CB    7
+# define SSL_RETRY_VERIFY       8
+
+/* These will only be used when doing non-blocking IO */
+# define SSL_want_nothing(s)         (SSL_want(s) == SSL_NOTHING)
+# define SSL_want_read(s)            (SSL_want(s) == SSL_READING)
+# define SSL_want_write(s)           (SSL_want(s) == SSL_WRITING)
+# define SSL_want_x509_lookup(s)     (SSL_want(s) == SSL_X509_LOOKUP)
+# define SSL_want_retry_verify(s)    (SSL_want(s) == SSL_RETRY_VERIFY)
+# define SSL_want_async(s)           (SSL_want(s) == SSL_ASYNC_PAUSED)
+# define SSL_want_async_job(s)       (SSL_want(s) == SSL_ASYNC_NO_JOBS)
+# define SSL_want_client_hello_cb(s) (SSL_want(s) == SSL_CLIENT_HELLO_CB)
+
+# define SSL_MAC_FLAG_READ_MAC_STREAM 1
+# define SSL_MAC_FLAG_WRITE_MAC_STREAM 2
+# define SSL_MAC_FLAG_READ_MAC_TLSTREE 4
+# define SSL_MAC_FLAG_WRITE_MAC_TLSTREE 8
+
+/*
+ * A callback for logging out TLS key material. This callback should log out
+ * |line| followed by a newline.
+ */
+typedef void (*SSL_CTX_keylog_cb_func)(const SSL *ssl, const char *line);
+
+/*
+ * SSL_CTX_set_keylog_callback configures a callback to log key material. This
+ * is intended for debugging use with tools like Wireshark. The cb function
+ * should log line followed by a newline.
+ */
+void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb);
+
+/*
+ * SSL_CTX_get_keylog_callback returns the callback configured by
+ * SSL_CTX_set_keylog_callback.
+ */
+SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx);
+
+int SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data);
+uint32_t SSL_CTX_get_max_early_data(const SSL_CTX *ctx);
+int SSL_set_max_early_data(SSL *s, uint32_t max_early_data);
+uint32_t SSL_get_max_early_data(const SSL *s);
+int SSL_CTX_set_recv_max_early_data(SSL_CTX *ctx, uint32_t recv_max_early_data);
+uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX *ctx);
+int SSL_set_recv_max_early_data(SSL *s, uint32_t recv_max_early_data);
+uint32_t SSL_get_recv_max_early_data(const SSL *s);
+
+#ifdef __cplusplus
+}
+#endif
+
+# include <openssl/ssl2.h>
+# include <openssl/ssl3.h>
+# include <openssl/tls1.h>      /* This is mostly sslv3 with a few tweaks */
+# include <openssl/dtls1.h>     /* Datagram TLS */
+# include <openssl/srtp.h>      /* Support for the use_srtp extension */
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * These need to be after the above set of includes due to a compiler bug
+ * in VisualStudio 2015
+ */
+SKM_DEFINE_STACK_OF_INTERNAL(SSL_CIPHER, const SSL_CIPHER, SSL_CIPHER)
+#define sk_SSL_CIPHER_num(sk) OPENSSL_sk_num(ossl_check_const_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_value(sk, idx) ((const SSL_CIPHER *)OPENSSL_sk_value(ossl_check_const_SSL_CIPHER_sk_type(sk), (idx)))
+#define sk_SSL_CIPHER_new(cmp) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new(ossl_check_SSL_CIPHER_compfunc_type(cmp)))
+#define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new_null())
+#define sk_SSL_CIPHER_new_reserve(cmp, n) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new_reserve(ossl_check_SSL_CIPHER_compfunc_type(cmp), (n)))
+#define sk_SSL_CIPHER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SSL_CIPHER_sk_type(sk), (n))
+#define sk_SSL_CIPHER_free(sk) OPENSSL_sk_free(ossl_check_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_zero(sk) OPENSSL_sk_zero(ossl_check_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_delete(sk, i) ((const SSL_CIPHER *)OPENSSL_sk_delete(ossl_check_SSL_CIPHER_sk_type(sk), (i)))
+#define sk_SSL_CIPHER_delete_ptr(sk, ptr) ((const SSL_CIPHER *)OPENSSL_sk_delete_ptr(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr)))
+#define sk_SSL_CIPHER_push(sk, ptr) OPENSSL_sk_push(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
+#define sk_SSL_CIPHER_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
+#define sk_SSL_CIPHER_pop(sk) ((const SSL_CIPHER *)OPENSSL_sk_pop(ossl_check_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_shift(sk) ((const SSL_CIPHER *)OPENSSL_sk_shift(ossl_check_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_CIPHER_sk_type(sk),ossl_check_SSL_CIPHER_freefunc_type(freefunc))
+#define sk_SSL_CIPHER_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr), (idx))
+#define sk_SSL_CIPHER_set(sk, idx, ptr) ((const SSL_CIPHER *)OPENSSL_sk_set(ossl_check_SSL_CIPHER_sk_type(sk), (idx), ossl_check_SSL_CIPHER_type(ptr)))
+#define sk_SSL_CIPHER_find(sk, ptr) OPENSSL_sk_find(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
+#define sk_SSL_CIPHER_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
+#define sk_SSL_CIPHER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr), pnum)
+#define sk_SSL_CIPHER_sort(sk) OPENSSL_sk_sort(ossl_check_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SSL_CIPHER_sk_type(sk))
+#define sk_SSL_CIPHER_dup(sk) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_dup(ossl_check_const_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_deep_copy(ossl_check_const_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_copyfunc_type(copyfunc), ossl_check_SSL_CIPHER_freefunc_type(freefunc)))
+#define sk_SSL_CIPHER_set_cmp_func(sk, cmp) ((sk_SSL_CIPHER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(SSL_COMP, SSL_COMP, SSL_COMP)
+#define sk_SSL_COMP_num(sk) OPENSSL_sk_num(ossl_check_const_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_value(sk, idx) ((SSL_COMP *)OPENSSL_sk_value(ossl_check_const_SSL_COMP_sk_type(sk), (idx)))
+#define sk_SSL_COMP_new(cmp) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new(ossl_check_SSL_COMP_compfunc_type(cmp)))
+#define sk_SSL_COMP_new_null() ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new_null())
+#define sk_SSL_COMP_new_reserve(cmp, n) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new_reserve(ossl_check_SSL_COMP_compfunc_type(cmp), (n)))
+#define sk_SSL_COMP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SSL_COMP_sk_type(sk), (n))
+#define sk_SSL_COMP_free(sk) OPENSSL_sk_free(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_zero(sk) OPENSSL_sk_zero(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_delete(sk, i) ((SSL_COMP *)OPENSSL_sk_delete(ossl_check_SSL_COMP_sk_type(sk), (i)))
+#define sk_SSL_COMP_delete_ptr(sk, ptr) ((SSL_COMP *)OPENSSL_sk_delete_ptr(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr)))
+#define sk_SSL_COMP_push(sk, ptr) OPENSSL_sk_push(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_pop(sk) ((SSL_COMP *)OPENSSL_sk_pop(ossl_check_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_shift(sk) ((SSL_COMP *)OPENSSL_sk_shift(ossl_check_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_COMP_sk_type(sk),ossl_check_SSL_COMP_freefunc_type(freefunc))
+#define sk_SSL_COMP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr), (idx))
+#define sk_SSL_COMP_set(sk, idx, ptr) ((SSL_COMP *)OPENSSL_sk_set(ossl_check_SSL_COMP_sk_type(sk), (idx), ossl_check_SSL_COMP_type(ptr)))
+#define sk_SSL_COMP_find(sk, ptr) OPENSSL_sk_find(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
+#define sk_SSL_COMP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr), pnum)
+#define sk_SSL_COMP_sort(sk) OPENSSL_sk_sort(ossl_check_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SSL_COMP_sk_type(sk))
+#define sk_SSL_COMP_dup(sk) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_dup(ossl_check_const_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_deep_copy(ossl_check_const_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_copyfunc_type(copyfunc), ossl_check_SSL_COMP_freefunc_type(freefunc)))
+#define sk_SSL_COMP_set_cmp_func(sk, cmp) ((sk_SSL_COMP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_compfunc_type(cmp)))
+
+
+/* compatibility */
+# define SSL_set_app_data(s,arg)         (SSL_set_ex_data(s,0,(char *)(arg)))
+# define SSL_get_app_data(s)             (SSL_get_ex_data(s,0))
+# define SSL_SESSION_set_app_data(s,a)   (SSL_SESSION_set_ex_data(s,0, \
+                                                                  (char *)(a)))
+# define SSL_SESSION_get_app_data(s)     (SSL_SESSION_get_ex_data(s,0))
+# define SSL_CTX_get_app_data(ctx)       (SSL_CTX_get_ex_data(ctx,0))
+# define SSL_CTX_set_app_data(ctx,arg)   (SSL_CTX_set_ex_data(ctx,0, \
+                                                              (char *)(arg)))
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 void SSL_set_debug(SSL *s, int debug);
+# endif
+
+/* TLSv1.3 KeyUpdate message types */
+/* -1 used so that this is an invalid value for the on-the-wire protocol */
+#define SSL_KEY_UPDATE_NONE             -1
+/* Values as defined for the on-the-wire protocol */
+#define SSL_KEY_UPDATE_NOT_REQUESTED     0
+#define SSL_KEY_UPDATE_REQUESTED         1
+
+/*
+ * The valid handshake states (one for each type message sent and one for each
+ * type of message received). There are also two "special" states:
+ * TLS = TLS or DTLS state
+ * DTLS = DTLS specific state
+ * CR/SR = Client Read/Server Read
+ * CW/SW = Client Write/Server Write
+ *
+ * The "special" states are:
+ * TLS_ST_BEFORE = No handshake has been initiated yet
+ * TLS_ST_OK = A handshake has been successfully completed
+ */
+typedef enum {
+    TLS_ST_BEFORE,
+    TLS_ST_OK,
+    DTLS_ST_CR_HELLO_VERIFY_REQUEST,
+    TLS_ST_CR_SRVR_HELLO,
+    TLS_ST_CR_CERT,
+    TLS_ST_CR_CERT_STATUS,
+    TLS_ST_CR_KEY_EXCH,
+    TLS_ST_CR_CERT_REQ,
+    TLS_ST_CR_SRVR_DONE,
+    TLS_ST_CR_SESSION_TICKET,
+    TLS_ST_CR_CHANGE,
+    TLS_ST_CR_FINISHED,
+    TLS_ST_CW_CLNT_HELLO,
+    TLS_ST_CW_CERT,
+    TLS_ST_CW_KEY_EXCH,
+    TLS_ST_CW_CERT_VRFY,
+    TLS_ST_CW_CHANGE,
+    TLS_ST_CW_NEXT_PROTO,
+    TLS_ST_CW_FINISHED,
+    TLS_ST_SW_HELLO_REQ,
+    TLS_ST_SR_CLNT_HELLO,
+    DTLS_ST_SW_HELLO_VERIFY_REQUEST,
+    TLS_ST_SW_SRVR_HELLO,
+    TLS_ST_SW_CERT,
+    TLS_ST_SW_KEY_EXCH,
+    TLS_ST_SW_CERT_REQ,
+    TLS_ST_SW_SRVR_DONE,
+    TLS_ST_SR_CERT,
+    TLS_ST_SR_KEY_EXCH,
+    TLS_ST_SR_CERT_VRFY,
+    TLS_ST_SR_NEXT_PROTO,
+    TLS_ST_SR_CHANGE,
+    TLS_ST_SR_FINISHED,
+    TLS_ST_SW_SESSION_TICKET,
+    TLS_ST_SW_CERT_STATUS,
+    TLS_ST_SW_CHANGE,
+    TLS_ST_SW_FINISHED,
+    TLS_ST_SW_ENCRYPTED_EXTENSIONS,
+    TLS_ST_CR_ENCRYPTED_EXTENSIONS,
+    TLS_ST_CR_CERT_VRFY,
+    TLS_ST_SW_CERT_VRFY,
+    TLS_ST_CR_HELLO_REQ,
+    TLS_ST_SW_KEY_UPDATE,
+    TLS_ST_CW_KEY_UPDATE,
+    TLS_ST_SR_KEY_UPDATE,
+    TLS_ST_CR_KEY_UPDATE,
+    TLS_ST_EARLY_DATA,
+    TLS_ST_PENDING_EARLY_DATA_END,
+    TLS_ST_CW_END_OF_EARLY_DATA,
+    TLS_ST_SR_END_OF_EARLY_DATA
+} OSSL_HANDSHAKE_STATE;
+
+/*
+ * Most of the following state values are no longer used and are defined to be
+ * the closest equivalent value in the current state machine code. Not all
+ * defines have an equivalent and are set to a dummy value (-1). SSL_ST_CONNECT
+ * and SSL_ST_ACCEPT are still in use in the definition of SSL_CB_ACCEPT_LOOP,
+ * SSL_CB_ACCEPT_EXIT, SSL_CB_CONNECT_LOOP and SSL_CB_CONNECT_EXIT.
+ */
+
+# define SSL_ST_CONNECT                  0x1000
+# define SSL_ST_ACCEPT                   0x2000
+
+# define SSL_ST_MASK                     0x0FFF
+
+# define SSL_CB_LOOP                     0x01
+# define SSL_CB_EXIT                     0x02
+# define SSL_CB_READ                     0x04
+# define SSL_CB_WRITE                    0x08
+# define SSL_CB_ALERT                    0x4000/* used in callback */
+# define SSL_CB_READ_ALERT               (SSL_CB_ALERT|SSL_CB_READ)
+# define SSL_CB_WRITE_ALERT              (SSL_CB_ALERT|SSL_CB_WRITE)
+# define SSL_CB_ACCEPT_LOOP              (SSL_ST_ACCEPT|SSL_CB_LOOP)
+# define SSL_CB_ACCEPT_EXIT              (SSL_ST_ACCEPT|SSL_CB_EXIT)
+# define SSL_CB_CONNECT_LOOP             (SSL_ST_CONNECT|SSL_CB_LOOP)
+# define SSL_CB_CONNECT_EXIT             (SSL_ST_CONNECT|SSL_CB_EXIT)
+# define SSL_CB_HANDSHAKE_START          0x10
+# define SSL_CB_HANDSHAKE_DONE           0x20
+
+/* Is the SSL_connection established? */
+# define SSL_in_connect_init(a)          (SSL_in_init(a) && !SSL_is_server(a))
+# define SSL_in_accept_init(a)           (SSL_in_init(a) && SSL_is_server(a))
+int SSL_in_init(const SSL *s);
+int SSL_in_before(const SSL *s);
+int SSL_is_init_finished(const SSL *s);
+
+/*
+ * The following 3 states are kept in ssl->rlayer.rstate when reads fail, you
+ * should not need these
+ */
+# define SSL_ST_READ_HEADER                      0xF0
+# define SSL_ST_READ_BODY                        0xF1
+# define SSL_ST_READ_DONE                        0xF2
+
+/*-
+ * Obtain latest Finished message
+ *   -- that we sent (SSL_get_finished)
+ *   -- that we expected from peer (SSL_get_peer_finished).
+ * Returns length (0 == no Finished so far), copies up to 'count' bytes.
+ */
+size_t SSL_get_finished(const SSL *s, void *buf, size_t count);
+size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count);
+
+/*
+ * use either SSL_VERIFY_NONE or SSL_VERIFY_PEER, the last 3 options are
+ * 'ored' with SSL_VERIFY_PEER if they are desired
+ */
+# define SSL_VERIFY_NONE                 0x00
+# define SSL_VERIFY_PEER                 0x01
+# define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02
+# define SSL_VERIFY_CLIENT_ONCE          0x04
+# define SSL_VERIFY_POST_HANDSHAKE       0x08
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define OpenSSL_add_ssl_algorithms()   SSL_library_init()
+#  define SSLeay_add_ssl_algorithms()    SSL_library_init()
+# endif
+
+/* More backward compatibility */
+# define SSL_get_cipher(s) \
+                SSL_CIPHER_get_name(SSL_get_current_cipher(s))
+# define SSL_get_cipher_bits(s,np) \
+                SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np)
+# define SSL_get_cipher_version(s) \
+                SSL_CIPHER_get_version(SSL_get_current_cipher(s))
+# define SSL_get_cipher_name(s) \
+                SSL_CIPHER_get_name(SSL_get_current_cipher(s))
+# define SSL_get_time(a)         SSL_SESSION_get_time(a)
+# define SSL_set_time(a,b)       SSL_SESSION_set_time((a),(b))
+# define SSL_get_timeout(a)      SSL_SESSION_get_timeout(a)
+# define SSL_set_timeout(a,b)    SSL_SESSION_set_timeout((a),(b))
+
+# define d2i_SSL_SESSION_bio(bp,s_id) ASN1_d2i_bio_of(SSL_SESSION,SSL_SESSION_new,d2i_SSL_SESSION,bp,s_id)
+# define i2d_SSL_SESSION_bio(bp,s_id) ASN1_i2d_bio_of(SSL_SESSION,i2d_SSL_SESSION,bp,s_id)
+
+DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION)
+# define SSL_AD_REASON_OFFSET            1000/* offset to get SSL_R_... value
+                                              * from SSL_AD_... */
+/* These alert types are for SSLv3 and TLSv1 */
+# define SSL_AD_CLOSE_NOTIFY             SSL3_AD_CLOSE_NOTIFY
+/* fatal */
+# define SSL_AD_UNEXPECTED_MESSAGE       SSL3_AD_UNEXPECTED_MESSAGE
+/* fatal */
+# define SSL_AD_BAD_RECORD_MAC           SSL3_AD_BAD_RECORD_MAC
+# define SSL_AD_DECRYPTION_FAILED        TLS1_AD_DECRYPTION_FAILED
+# define SSL_AD_RECORD_OVERFLOW          TLS1_AD_RECORD_OVERFLOW
+/* fatal */
+# define SSL_AD_DECOMPRESSION_FAILURE    SSL3_AD_DECOMPRESSION_FAILURE
+/* fatal */
+# define SSL_AD_HANDSHAKE_FAILURE        SSL3_AD_HANDSHAKE_FAILURE
+/* Not for TLS */
+# define SSL_AD_NO_CERTIFICATE           SSL3_AD_NO_CERTIFICATE
+# define SSL_AD_BAD_CERTIFICATE          SSL3_AD_BAD_CERTIFICATE
+# define SSL_AD_UNSUPPORTED_CERTIFICATE  SSL3_AD_UNSUPPORTED_CERTIFICATE
+# define SSL_AD_CERTIFICATE_REVOKED      SSL3_AD_CERTIFICATE_REVOKED
+# define SSL_AD_CERTIFICATE_EXPIRED      SSL3_AD_CERTIFICATE_EXPIRED
+# define SSL_AD_CERTIFICATE_UNKNOWN      SSL3_AD_CERTIFICATE_UNKNOWN
+/* fatal */
+# define SSL_AD_ILLEGAL_PARAMETER        SSL3_AD_ILLEGAL_PARAMETER
+/* fatal */
+# define SSL_AD_UNKNOWN_CA               TLS1_AD_UNKNOWN_CA
+/* fatal */
+# define SSL_AD_ACCESS_DENIED            TLS1_AD_ACCESS_DENIED
+/* fatal */
+# define SSL_AD_DECODE_ERROR             TLS1_AD_DECODE_ERROR
+# define SSL_AD_DECRYPT_ERROR            TLS1_AD_DECRYPT_ERROR
+/* fatal */
+# define SSL_AD_EXPORT_RESTRICTION       TLS1_AD_EXPORT_RESTRICTION
+/* fatal */
+# define SSL_AD_PROTOCOL_VERSION         TLS1_AD_PROTOCOL_VERSION
+/* fatal */
+# define SSL_AD_INSUFFICIENT_SECURITY    TLS1_AD_INSUFFICIENT_SECURITY
+/* fatal */
+# define SSL_AD_INTERNAL_ERROR           TLS1_AD_INTERNAL_ERROR
+# define SSL_AD_USER_CANCELLED           TLS1_AD_USER_CANCELLED
+# define SSL_AD_NO_RENEGOTIATION         TLS1_AD_NO_RENEGOTIATION
+# define SSL_AD_MISSING_EXTENSION        TLS13_AD_MISSING_EXTENSION
+# define SSL_AD_CERTIFICATE_REQUIRED     TLS13_AD_CERTIFICATE_REQUIRED
+# define SSL_AD_UNSUPPORTED_EXTENSION    TLS1_AD_UNSUPPORTED_EXTENSION
+# define SSL_AD_CERTIFICATE_UNOBTAINABLE TLS1_AD_CERTIFICATE_UNOBTAINABLE
+# define SSL_AD_UNRECOGNIZED_NAME        TLS1_AD_UNRECOGNIZED_NAME
+# define SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE
+# define SSL_AD_BAD_CERTIFICATE_HASH_VALUE TLS1_AD_BAD_CERTIFICATE_HASH_VALUE
+/* fatal */
+# define SSL_AD_UNKNOWN_PSK_IDENTITY     TLS1_AD_UNKNOWN_PSK_IDENTITY
+/* fatal */
+# define SSL_AD_INAPPROPRIATE_FALLBACK   TLS1_AD_INAPPROPRIATE_FALLBACK
+# define SSL_AD_NO_APPLICATION_PROTOCOL  TLS1_AD_NO_APPLICATION_PROTOCOL
+# define SSL_ERROR_NONE                  0
+# define SSL_ERROR_SSL                   1
+# define SSL_ERROR_WANT_READ             2
+# define SSL_ERROR_WANT_WRITE            3
+# define SSL_ERROR_WANT_X509_LOOKUP      4
+# define SSL_ERROR_SYSCALL               5/* look at error stack/return
+                                           * value/errno */
+# define SSL_ERROR_ZERO_RETURN           6
+# define SSL_ERROR_WANT_CONNECT          7
+# define SSL_ERROR_WANT_ACCEPT           8
+# define SSL_ERROR_WANT_ASYNC            9
+# define SSL_ERROR_WANT_ASYNC_JOB       10
+# define SSL_ERROR_WANT_CLIENT_HELLO_CB 11
+# define SSL_ERROR_WANT_RETRY_VERIFY    12
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTRL_SET_TMP_DH                    3
+#  define SSL_CTRL_SET_TMP_ECDH                  4
+#  define SSL_CTRL_SET_TMP_DH_CB                 6
+# endif
+
+# define SSL_CTRL_GET_CLIENT_CERT_REQUEST        9
+# define SSL_CTRL_GET_NUM_RENEGOTIATIONS         10
+# define SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS       11
+# define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS       12
+# define SSL_CTRL_GET_FLAGS                      13
+# define SSL_CTRL_EXTRA_CHAIN_CERT               14
+# define SSL_CTRL_SET_MSG_CALLBACK               15
+# define SSL_CTRL_SET_MSG_CALLBACK_ARG           16
+/* only applies to datagram connections */
+# define SSL_CTRL_SET_MTU                17
+/* Stats */
+# define SSL_CTRL_SESS_NUMBER                    20
+# define SSL_CTRL_SESS_CONNECT                   21
+# define SSL_CTRL_SESS_CONNECT_GOOD              22
+# define SSL_CTRL_SESS_CONNECT_RENEGOTIATE       23
+# define SSL_CTRL_SESS_ACCEPT                    24
+# define SSL_CTRL_SESS_ACCEPT_GOOD               25
+# define SSL_CTRL_SESS_ACCEPT_RENEGOTIATE        26
+# define SSL_CTRL_SESS_HIT                       27
+# define SSL_CTRL_SESS_CB_HIT                    28
+# define SSL_CTRL_SESS_MISSES                    29
+# define SSL_CTRL_SESS_TIMEOUTS                  30
+# define SSL_CTRL_SESS_CACHE_FULL                31
+# define SSL_CTRL_MODE                           33
+# define SSL_CTRL_GET_READ_AHEAD                 40
+# define SSL_CTRL_SET_READ_AHEAD                 41
+# define SSL_CTRL_SET_SESS_CACHE_SIZE            42
+# define SSL_CTRL_GET_SESS_CACHE_SIZE            43
+# define SSL_CTRL_SET_SESS_CACHE_MODE            44
+# define SSL_CTRL_GET_SESS_CACHE_MODE            45
+# define SSL_CTRL_GET_MAX_CERT_LIST              50
+# define SSL_CTRL_SET_MAX_CERT_LIST              51
+# define SSL_CTRL_SET_MAX_SEND_FRAGMENT          52
+/* see tls1.h for macros based on these */
+# define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB       53
+# define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG      54
+# define SSL_CTRL_SET_TLSEXT_HOSTNAME            55
+# define SSL_CTRL_SET_TLSEXT_DEBUG_CB            56
+# define SSL_CTRL_SET_TLSEXT_DEBUG_ARG           57
+# define SSL_CTRL_GET_TLSEXT_TICKET_KEYS         58
+# define SSL_CTRL_SET_TLSEXT_TICKET_KEYS         59
+/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT    60 */
+/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB 61 */
+/*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB_ARG 62 */
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB       63
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG   64
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE     65
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS     66
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS     67
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS      68
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS      69
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP        70
+# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP        71
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB      72
+# endif
+# define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB    75
+# define SSL_CTRL_SET_SRP_VERIFY_PARAM_CB                76
+# define SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB             77
+# define SSL_CTRL_SET_SRP_ARG            78
+# define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME               79
+# define SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH               80
+# define SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD               81
+# define DTLS_CTRL_GET_TIMEOUT           73
+# define DTLS_CTRL_HANDLE_TIMEOUT        74
+# define SSL_CTRL_GET_RI_SUPPORT                 76
+# define SSL_CTRL_CLEAR_MODE                     78
+# define SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB      79
+# define SSL_CTRL_GET_EXTRA_CHAIN_CERTS          82
+# define SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS        83
+# define SSL_CTRL_CHAIN                          88
+# define SSL_CTRL_CHAIN_CERT                     89
+# define SSL_CTRL_GET_GROUPS                     90
+# define SSL_CTRL_SET_GROUPS                     91
+# define SSL_CTRL_SET_GROUPS_LIST                92
+# define SSL_CTRL_GET_SHARED_GROUP               93
+# define SSL_CTRL_SET_SIGALGS                    97
+# define SSL_CTRL_SET_SIGALGS_LIST               98
+# define SSL_CTRL_CERT_FLAGS                     99
+# define SSL_CTRL_CLEAR_CERT_FLAGS               100
+# define SSL_CTRL_SET_CLIENT_SIGALGS             101
+# define SSL_CTRL_SET_CLIENT_SIGALGS_LIST        102
+# define SSL_CTRL_GET_CLIENT_CERT_TYPES          103
+# define SSL_CTRL_SET_CLIENT_CERT_TYPES          104
+# define SSL_CTRL_BUILD_CERT_CHAIN               105
+# define SSL_CTRL_SET_VERIFY_CERT_STORE          106
+# define SSL_CTRL_SET_CHAIN_CERT_STORE           107
+# define SSL_CTRL_GET_PEER_SIGNATURE_NID         108
+# define SSL_CTRL_GET_PEER_TMP_KEY               109
+# define SSL_CTRL_GET_RAW_CIPHERLIST             110
+# define SSL_CTRL_GET_EC_POINT_FORMATS           111
+# define SSL_CTRL_GET_CHAIN_CERTS                115
+# define SSL_CTRL_SELECT_CURRENT_CERT            116
+# define SSL_CTRL_SET_CURRENT_CERT               117
+# define SSL_CTRL_SET_DH_AUTO                    118
+# define DTLS_CTRL_SET_LINK_MTU                  120
+# define DTLS_CTRL_GET_LINK_MIN_MTU              121
+# define SSL_CTRL_GET_EXTMS_SUPPORT              122
+# define SSL_CTRL_SET_MIN_PROTO_VERSION          123
+# define SSL_CTRL_SET_MAX_PROTO_VERSION          124
+# define SSL_CTRL_SET_SPLIT_SEND_FRAGMENT        125
+# define SSL_CTRL_SET_MAX_PIPELINES              126
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE     127
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB       128
+# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG   129
+# define SSL_CTRL_GET_MIN_PROTO_VERSION          130
+# define SSL_CTRL_GET_MAX_PROTO_VERSION          131
+# define SSL_CTRL_GET_SIGNATURE_NID              132
+# define SSL_CTRL_GET_TMP_KEY                    133
+# define SSL_CTRL_GET_NEGOTIATED_GROUP           134
+# define SSL_CTRL_SET_RETRY_VERIFY               136
+# define SSL_CTRL_GET_VERIFY_CERT_STORE          137
+# define SSL_CTRL_GET_CHAIN_CERT_STORE           138
+# define SSL_CERT_SET_FIRST                      1
+# define SSL_CERT_SET_NEXT                       2
+# define SSL_CERT_SET_SERVER                     3
+# define DTLSv1_get_timeout(ssl, arg) \
+        SSL_ctrl(ssl,DTLS_CTRL_GET_TIMEOUT,0, (void *)(arg))
+# define DTLSv1_handle_timeout(ssl) \
+        SSL_ctrl(ssl,DTLS_CTRL_HANDLE_TIMEOUT,0, NULL)
+# define SSL_num_renegotiations(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_GET_NUM_RENEGOTIATIONS,0,NULL)
+# define SSL_clear_num_renegotiations(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS,0,NULL)
+# define SSL_total_renegotiations(ssl) \
+        SSL_ctrl((ssl),SSL_CTRL_GET_TOTAL_RENEGOTIATIONS,0,NULL)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTX_set_tmp_dh(ctx,dh) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH,0,(char *)(dh))
+# endif
+# define SSL_CTX_set_dh_auto(ctx, onoff) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_DH_AUTO,onoff,NULL)
+# define SSL_set_dh_auto(s, onoff) \
+        SSL_ctrl(s,SSL_CTRL_SET_DH_AUTO,onoff,NULL)
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_set_tmp_dh(ssl,dh) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH,0,(char *)(dh))
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTX_set_tmp_ecdh(ctx,ecdh) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH,0,(char *)(ecdh))
+#  define SSL_set_tmp_ecdh(ssl,ecdh) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH,0,(char *)(ecdh))
+# endif
+# define SSL_CTX_add_extra_chain_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char *)(x509))
+# define SSL_CTX_get_extra_chain_certs(ctx,px509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_EXTRA_CHAIN_CERTS,0,px509)
+# define SSL_CTX_get_extra_chain_certs_only(ctx,px509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_EXTRA_CHAIN_CERTS,1,px509)
+# define SSL_CTX_clear_extra_chain_certs(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS,0,NULL)
+# define SSL_CTX_set0_chain(ctx,sk) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN,0,(char *)(sk))
+# define SSL_CTX_set1_chain(ctx,sk) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN,1,(char *)(sk))
+# define SSL_CTX_add0_chain_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN_CERT,0,(char *)(x509))
+# define SSL_CTX_add1_chain_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN_CERT,1,(char *)(x509))
+# define SSL_CTX_get0_chain_certs(ctx,px509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_CHAIN_CERTS,0,px509)
+# define SSL_CTX_clear_chain_certs(ctx) \
+        SSL_CTX_set0_chain(ctx,NULL)
+# define SSL_CTX_build_cert_chain(ctx, flags) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL)
+# define SSL_CTX_select_current_cert(ctx,x509) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SELECT_CURRENT_CERT,0,(char *)(x509))
+# define SSL_CTX_set_current_cert(ctx, op) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CURRENT_CERT, op, NULL)
+# define SSL_CTX_set0_verify_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st))
+# define SSL_CTX_set1_verify_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st))
+# define SSL_CTX_get0_verify_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_VERIFY_CERT_STORE,0,(char *)(st))
+# define SSL_CTX_set0_chain_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st))
+# define SSL_CTX_set1_chain_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st))
+# define SSL_CTX_get0_chain_cert_store(ctx,st) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_CHAIN_CERT_STORE,0,(char *)(st))
+# define SSL_set0_chain(s,sk) \
+        SSL_ctrl(s,SSL_CTRL_CHAIN,0,(char *)(sk))
+# define SSL_set1_chain(s,sk) \
+        SSL_ctrl(s,SSL_CTRL_CHAIN,1,(char *)(sk))
+# define SSL_add0_chain_cert(s,x509) \
+        SSL_ctrl(s,SSL_CTRL_CHAIN_CERT,0,(char *)(x509))
+# define SSL_add1_chain_cert(s,x509) \
+        SSL_ctrl(s,SSL_CTRL_CHAIN_CERT,1,(char *)(x509))
+# define SSL_get0_chain_certs(s,px509) \
+        SSL_ctrl(s,SSL_CTRL_GET_CHAIN_CERTS,0,px509)
+# define SSL_clear_chain_certs(s) \
+        SSL_set0_chain(s,NULL)
+# define SSL_build_cert_chain(s, flags) \
+        SSL_ctrl(s,SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL)
+# define SSL_select_current_cert(s,x509) \
+        SSL_ctrl(s,SSL_CTRL_SELECT_CURRENT_CERT,0,(char *)(x509))
+# define SSL_set_current_cert(s,op) \
+        SSL_ctrl(s,SSL_CTRL_SET_CURRENT_CERT, op, NULL)
+# define SSL_set0_verify_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st))
+# define SSL_set1_verify_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st))
+#define SSL_get0_verify_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_GET_VERIFY_CERT_STORE,0,(char *)(st))
+# define SSL_set0_chain_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st))
+# define SSL_set1_chain_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st))
+#define SSL_get0_chain_cert_store(s,st) \
+        SSL_ctrl(s,SSL_CTRL_GET_CHAIN_CERT_STORE,0,(char *)(st))
+
+# define SSL_get1_groups(s, glist) \
+        SSL_ctrl(s,SSL_CTRL_GET_GROUPS,0,(int*)(glist))
+# define SSL_CTX_set1_groups(ctx, glist, glistlen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_GROUPS,glistlen,(int *)(glist))
+# define SSL_CTX_set1_groups_list(ctx, s) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_GROUPS_LIST,0,(char *)(s))
+# define SSL_set1_groups(s, glist, glistlen) \
+        SSL_ctrl(s,SSL_CTRL_SET_GROUPS,glistlen,(char *)(glist))
+# define SSL_set1_groups_list(s, str) \
+        SSL_ctrl(s,SSL_CTRL_SET_GROUPS_LIST,0,(char *)(str))
+# define SSL_get_shared_group(s, n) \
+        SSL_ctrl(s,SSL_CTRL_GET_SHARED_GROUP,n,NULL)
+# define SSL_get_negotiated_group(s) \
+        SSL_ctrl(s,SSL_CTRL_GET_NEGOTIATED_GROUP,0,NULL)
+# define SSL_CTX_set1_sigalgs(ctx, slist, slistlen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SIGALGS,slistlen,(int *)(slist))
+# define SSL_CTX_set1_sigalgs_list(ctx, s) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SIGALGS_LIST,0,(char *)(s))
+# define SSL_set1_sigalgs(s, slist, slistlen) \
+        SSL_ctrl(s,SSL_CTRL_SET_SIGALGS,slistlen,(int *)(slist))
+# define SSL_set1_sigalgs_list(s, str) \
+        SSL_ctrl(s,SSL_CTRL_SET_SIGALGS_LIST,0,(char *)(str))
+# define SSL_CTX_set1_client_sigalgs(ctx, slist, slistlen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_SIGALGS,slistlen,(int *)(slist))
+# define SSL_CTX_set1_client_sigalgs_list(ctx, s) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_SIGALGS_LIST,0,(char *)(s))
+# define SSL_set1_client_sigalgs(s, slist, slistlen) \
+        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_SIGALGS,slistlen,(int *)(slist))
+# define SSL_set1_client_sigalgs_list(s, str) \
+        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_SIGALGS_LIST,0,(char *)(str))
+# define SSL_get0_certificate_types(s, clist) \
+        SSL_ctrl(s, SSL_CTRL_GET_CLIENT_CERT_TYPES, 0, (char *)(clist))
+# define SSL_CTX_set1_client_certificate_types(ctx, clist, clistlen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_CERT_TYPES,clistlen, \
+                     (char *)(clist))
+# define SSL_set1_client_certificate_types(s, clist, clistlen) \
+        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_CERT_TYPES,clistlen,(char *)(clist))
+# define SSL_get_signature_nid(s, pn) \
+        SSL_ctrl(s,SSL_CTRL_GET_SIGNATURE_NID,0,pn)
+# define SSL_get_peer_signature_nid(s, pn) \
+        SSL_ctrl(s,SSL_CTRL_GET_PEER_SIGNATURE_NID,0,pn)
+# define SSL_get_peer_tmp_key(s, pk) \
+        SSL_ctrl(s,SSL_CTRL_GET_PEER_TMP_KEY,0,pk)
+# define SSL_get_tmp_key(s, pk) \
+        SSL_ctrl(s,SSL_CTRL_GET_TMP_KEY,0,pk)
+# define SSL_get0_raw_cipherlist(s, plst) \
+        SSL_ctrl(s,SSL_CTRL_GET_RAW_CIPHERLIST,0,plst)
+# define SSL_get0_ec_point_formats(s, plst) \
+        SSL_ctrl(s,SSL_CTRL_GET_EC_POINT_FORMATS,0,plst)
+# define SSL_CTX_set_min_proto_version(ctx, version) \
+        SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL)
+# define SSL_CTX_set_max_proto_version(ctx, version) \
+        SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL)
+# define SSL_CTX_get_min_proto_version(ctx) \
+        SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL)
+# define SSL_CTX_get_max_proto_version(ctx) \
+        SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL)
+# define SSL_set_min_proto_version(s, version) \
+        SSL_ctrl(s, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL)
+# define SSL_set_max_proto_version(s, version) \
+        SSL_ctrl(s, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL)
+# define SSL_get_min_proto_version(s) \
+        SSL_ctrl(s, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL)
+# define SSL_get_max_proto_version(s) \
+        SSL_ctrl(s, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL)
+
+const char *SSL_group_to_name(SSL *s, int id);
+
+/* Backwards compatibility, original 1.1.0 names */
+# define SSL_CTRL_GET_SERVER_TMP_KEY \
+         SSL_CTRL_GET_PEER_TMP_KEY
+# define SSL_get_server_tmp_key(s, pk) \
+         SSL_get_peer_tmp_key(s, pk)
+
+int SSL_set0_tmp_dh_pkey(SSL *s, EVP_PKEY *dhpkey);
+int SSL_CTX_set0_tmp_dh_pkey(SSL_CTX *ctx, EVP_PKEY *dhpkey);
+
+/*
+ * The following symbol names are old and obsolete. They are kept
+ * for compatibility reasons only and should not be used anymore.
+ */
+# define SSL_CTRL_GET_CURVES           SSL_CTRL_GET_GROUPS
+# define SSL_CTRL_SET_CURVES           SSL_CTRL_SET_GROUPS
+# define SSL_CTRL_SET_CURVES_LIST      SSL_CTRL_SET_GROUPS_LIST
+# define SSL_CTRL_GET_SHARED_CURVE     SSL_CTRL_GET_SHARED_GROUP
+
+# define SSL_get1_curves               SSL_get1_groups
+# define SSL_CTX_set1_curves           SSL_CTX_set1_groups
+# define SSL_CTX_set1_curves_list      SSL_CTX_set1_groups_list
+# define SSL_set1_curves               SSL_set1_groups
+# define SSL_set1_curves_list          SSL_set1_groups_list
+# define SSL_get_shared_curve          SSL_get_shared_group
+
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/* Provide some compatibility macros for removed functionality. */
+#  define SSL_CTX_need_tmp_RSA(ctx)                0
+#  define SSL_CTX_set_tmp_rsa(ctx,rsa)             1
+#  define SSL_need_tmp_RSA(ssl)                    0
+#  define SSL_set_tmp_rsa(ssl,rsa)                 1
+#  define SSL_CTX_set_ecdh_auto(dummy, onoff)      ((onoff) != 0)
+#  define SSL_set_ecdh_auto(dummy, onoff)          ((onoff) != 0)
+/*
+ * We "pretend" to call the callback to avoid warnings about unused static
+ * functions.
+ */
+#  define SSL_CTX_set_tmp_rsa_callback(ctx, cb)    while(0) (cb)(NULL, 0, 0)
+#  define SSL_set_tmp_rsa_callback(ssl, cb)        while(0) (cb)(NULL, 0, 0)
+# endif
+__owur const BIO_METHOD *BIO_f_ssl(void);
+__owur BIO *BIO_new_ssl(SSL_CTX *ctx, int client);
+__owur BIO *BIO_new_ssl_connect(SSL_CTX *ctx);
+__owur BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx);
+__owur int BIO_ssl_copy_session_id(BIO *to, BIO *from);
+void BIO_ssl_shutdown(BIO *ssl_bio);
+
+__owur int SSL_CTX_set_cipher_list(SSL_CTX *, const char *str);
+__owur SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth);
+__owur SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
+                               const SSL_METHOD *meth);
+int SSL_CTX_up_ref(SSL_CTX *ctx);
+void SSL_CTX_free(SSL_CTX *);
+__owur long SSL_CTX_set_timeout(SSL_CTX *ctx, long t);
+__owur long SSL_CTX_get_timeout(const SSL_CTX *ctx);
+__owur X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *);
+void SSL_CTX_set_cert_store(SSL_CTX *, X509_STORE *);
+void SSL_CTX_set1_cert_store(SSL_CTX *, X509_STORE *);
+__owur int SSL_want(const SSL *s);
+__owur int SSL_clear(SSL *s);
+
+void SSL_CTX_flush_sessions(SSL_CTX *ctx, long tm);
+
+__owur const SSL_CIPHER *SSL_get_current_cipher(const SSL *s);
+__owur const SSL_CIPHER *SSL_get_pending_cipher(const SSL *s);
+__owur int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits);
+__owur const char *SSL_CIPHER_get_version(const SSL_CIPHER *c);
+__owur const char *SSL_CIPHER_get_name(const SSL_CIPHER *c);
+__owur const char *SSL_CIPHER_standard_name(const SSL_CIPHER *c);
+__owur const char *OPENSSL_cipher_name(const char *rfc_name);
+__owur uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *c);
+__owur uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER *c);
+__owur int SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c);
+__owur int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c);
+__owur const EVP_MD *SSL_CIPHER_get_handshake_digest(const SSL_CIPHER *c);
+__owur int SSL_CIPHER_is_aead(const SSL_CIPHER *c);
+
+__owur int SSL_get_fd(const SSL *s);
+__owur int SSL_get_rfd(const SSL *s);
+__owur int SSL_get_wfd(const SSL *s);
+__owur const char *SSL_get_cipher_list(const SSL *s, int n);
+__owur char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size);
+__owur int SSL_get_read_ahead(const SSL *s);
+__owur int SSL_pending(const SSL *s);
+__owur int SSL_has_pending(const SSL *s);
+# ifndef OPENSSL_NO_SOCK
+__owur int SSL_set_fd(SSL *s, int fd);
+__owur int SSL_set_rfd(SSL *s, int fd);
+__owur int SSL_set_wfd(SSL *s, int fd);
+# endif
+void SSL_set0_rbio(SSL *s, BIO *rbio);
+void SSL_set0_wbio(SSL *s, BIO *wbio);
+void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio);
+__owur BIO *SSL_get_rbio(const SSL *s);
+__owur BIO *SSL_get_wbio(const SSL *s);
+__owur int SSL_set_cipher_list(SSL *s, const char *str);
+__owur int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str);
+__owur int SSL_set_ciphersuites(SSL *s, const char *str);
+void SSL_set_read_ahead(SSL *s, int yes);
+__owur int SSL_get_verify_mode(const SSL *s);
+__owur int SSL_get_verify_depth(const SSL *s);
+__owur SSL_verify_cb SSL_get_verify_callback(const SSL *s);
+void SSL_set_verify(SSL *s, int mode, SSL_verify_cb callback);
+void SSL_set_verify_depth(SSL *s, int depth);
+void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 __owur int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_use_RSAPrivateKey_ASN1(SSL *ssl,
+                                      const unsigned char *d, long len);
+# endif
+__owur int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);
+__owur int SSL_use_PrivateKey_ASN1(int pk, SSL *ssl, const unsigned char *d,
+                                   long len);
+__owur int SSL_use_certificate(SSL *ssl, X509 *x);
+__owur int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len);
+__owur int SSL_use_cert_and_key(SSL *ssl, X509 *x509, EVP_PKEY *privatekey,
+                                STACK_OF(X509) *chain, int override);
+
+
+/* serverinfo file format versions */
+# define SSL_SERVERINFOV1   1
+# define SSL_SERVERINFOV2   2
+
+/* Set serverinfo data for the current active cert. */
+__owur int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,
+                                  size_t serverinfo_length);
+__owur int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
+                                     const unsigned char *serverinfo,
+                                     size_t serverinfo_length);
+__owur int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type);
+#endif
+
+__owur int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type);
+__owur int SSL_use_certificate_file(SSL *ssl, const char *file, int type);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file,
+                                          int type);
+#endif
+__owur int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file,
+                                       int type);
+__owur int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file,
+                                        int type);
+/* PEM type */
+__owur int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file);
+__owur int SSL_use_certificate_chain_file(SSL *ssl, const char *file);
+__owur STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file);
+__owur STACK_OF(X509_NAME)
+*SSL_load_client_CA_file_ex(const char *file, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+__owur int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
+                                               const char *file);
+int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
+                                       const char *dir);
+int SSL_add_store_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
+                                       const char *uri);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSL_load_error_strings() \
+    OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS \
+                     | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
+# endif
+
+__owur const char *SSL_state_string(const SSL *s);
+__owur const char *SSL_rstate_string(const SSL *s);
+__owur const char *SSL_state_string_long(const SSL *s);
+__owur const char *SSL_rstate_string_long(const SSL *s);
+__owur long SSL_SESSION_get_time(const SSL_SESSION *s);
+__owur long SSL_SESSION_set_time(SSL_SESSION *s, long t);
+__owur long SSL_SESSION_get_timeout(const SSL_SESSION *s);
+__owur long SSL_SESSION_set_timeout(SSL_SESSION *s, long t);
+__owur int SSL_SESSION_get_protocol_version(const SSL_SESSION *s);
+__owur int SSL_SESSION_set_protocol_version(SSL_SESSION *s, int version);
+
+__owur const char *SSL_SESSION_get0_hostname(const SSL_SESSION *s);
+__owur int SSL_SESSION_set1_hostname(SSL_SESSION *s, const char *hostname);
+void SSL_SESSION_get0_alpn_selected(const SSL_SESSION *s,
+                                    const unsigned char **alpn,
+                                    size_t *len);
+__owur int SSL_SESSION_set1_alpn_selected(SSL_SESSION *s,
+                                          const unsigned char *alpn,
+                                          size_t len);
+__owur const SSL_CIPHER *SSL_SESSION_get0_cipher(const SSL_SESSION *s);
+__owur int SSL_SESSION_set_cipher(SSL_SESSION *s, const SSL_CIPHER *cipher);
+__owur int SSL_SESSION_has_ticket(const SSL_SESSION *s);
+__owur unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION *s);
+void SSL_SESSION_get0_ticket(const SSL_SESSION *s, const unsigned char **tick,
+                             size_t *len);
+__owur uint32_t SSL_SESSION_get_max_early_data(const SSL_SESSION *s);
+__owur int SSL_SESSION_set_max_early_data(SSL_SESSION *s,
+                                          uint32_t max_early_data);
+__owur int SSL_copy_session_id(SSL *to, const SSL *from);
+__owur X509 *SSL_SESSION_get0_peer(SSL_SESSION *s);
+__owur int SSL_SESSION_set1_id_context(SSL_SESSION *s,
+                                       const unsigned char *sid_ctx,
+                                       unsigned int sid_ctx_len);
+__owur int SSL_SESSION_set1_id(SSL_SESSION *s, const unsigned char *sid,
+                               unsigned int sid_len);
+__owur int SSL_SESSION_is_resumable(const SSL_SESSION *s);
+
+__owur SSL_SESSION *SSL_SESSION_new(void);
+__owur SSL_SESSION *SSL_SESSION_dup(const SSL_SESSION *src);
+const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s,
+                                        unsigned int *len);
+const unsigned char *SSL_SESSION_get0_id_context(const SSL_SESSION *s,
+                                                 unsigned int *len);
+__owur unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s);
+# ifndef OPENSSL_NO_STDIO
+int SSL_SESSION_print_fp(FILE *fp, const SSL_SESSION *ses);
+# endif
+int SSL_SESSION_print(BIO *fp, const SSL_SESSION *ses);
+int SSL_SESSION_print_keylog(BIO *bp, const SSL_SESSION *x);
+int SSL_SESSION_up_ref(SSL_SESSION *ses);
+void SSL_SESSION_free(SSL_SESSION *ses);
+__owur int i2d_SSL_SESSION(const SSL_SESSION *in, unsigned char **pp);
+__owur int SSL_set_session(SSL *to, SSL_SESSION *session);
+int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *session);
+int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *session);
+__owur int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb);
+__owur int SSL_set_generate_session_id(SSL *s, GEN_SESSION_CB cb);
+__owur int SSL_has_matching_session_id(const SSL *s,
+                                       const unsigned char *id,
+                                       unsigned int id_len);
+SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp,
+                             long length);
+
+# ifdef OPENSSL_X509_H
+__owur X509 *SSL_get0_peer_certificate(const SSL *s);
+__owur X509 *SSL_get1_peer_certificate(const SSL *s);
+/* Deprecated in 3.0.0 */
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   define SSL_get_peer_certificate SSL_get1_peer_certificate
+#  endif
+# endif
+
+__owur STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s);
+
+__owur int SSL_CTX_get_verify_mode(const SSL_CTX *ctx);
+__owur int SSL_CTX_get_verify_depth(const SSL_CTX *ctx);
+__owur SSL_verify_cb SSL_CTX_get_verify_callback(const SSL_CTX *ctx);
+void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, SSL_verify_cb callback);
+void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth);
+void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
+                                      int (*cb) (X509_STORE_CTX *, void *),
+                                      void *arg);
+void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
+                         void *arg);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d,
+                                          long len);
+# endif
+__owur int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
+__owur int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx,
+                                       const unsigned char *d, long len);
+__owur int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);
+__owur int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len,
+                                        const unsigned char *d);
+__owur int SSL_CTX_use_cert_and_key(SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey,
+                                    STACK_OF(X509) *chain, int override);
+
+void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb);
+void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u);
+pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx);
+void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx);
+void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb);
+void SSL_set_default_passwd_cb_userdata(SSL *s, void *u);
+pem_password_cb *SSL_get_default_passwd_cb(SSL *s);
+void *SSL_get_default_passwd_cb_userdata(SSL *s);
+
+__owur int SSL_CTX_check_private_key(const SSL_CTX *ctx);
+__owur int SSL_check_private_key(const SSL *ctx);
+
+__owur int SSL_CTX_set_session_id_context(SSL_CTX *ctx,
+                                          const unsigned char *sid_ctx,
+                                          unsigned int sid_ctx_len);
+
+SSL *SSL_new(SSL_CTX *ctx);
+int SSL_up_ref(SSL *s);
+int SSL_is_dtls(const SSL *s);
+__owur int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
+                                      unsigned int sid_ctx_len);
+
+__owur int SSL_CTX_set_purpose(SSL_CTX *ctx, int purpose);
+__owur int SSL_set_purpose(SSL *ssl, int purpose);
+__owur int SSL_CTX_set_trust(SSL_CTX *ctx, int trust);
+__owur int SSL_set_trust(SSL *ssl, int trust);
+
+__owur int SSL_set1_host(SSL *s, const char *hostname);
+__owur int SSL_add1_host(SSL *s, const char *hostname);
+__owur const char *SSL_get0_peername(SSL *s);
+void SSL_set_hostflags(SSL *s, unsigned int flags);
+
+__owur int SSL_CTX_dane_enable(SSL_CTX *ctx);
+__owur int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md,
+                                  uint8_t mtype, uint8_t ord);
+__owur int SSL_dane_enable(SSL *s, const char *basedomain);
+__owur int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
+                             uint8_t mtype, const unsigned char *data, size_t dlen);
+__owur int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki);
+__owur int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
+                              uint8_t *mtype, const unsigned char **data,
+                              size_t *dlen);
+/*
+ * Bridge opacity barrier between libcrypt and libssl, also needed to support
+ * offline testing in test/danetest.c
+ */
+SSL_DANE *SSL_get0_dane(SSL *ssl);
+/*
+ * DANE flags
+ */
+unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags);
+unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags);
+unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags);
+unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags);
+
+__owur int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm);
+__owur int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm);
+
+__owur X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx);
+__owur X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl);
+
+# ifndef OPENSSL_NO_SRP
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name);
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password);
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength);
+OSSL_DEPRECATEDIN_3_0
+int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx,
+                                        char *(*cb) (SSL *, void *));
+OSSL_DEPRECATEDIN_3_0
+int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx,
+                                          int (*cb) (SSL *, void *));
+OSSL_DEPRECATEDIN_3_0
+int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
+                                      int (*cb) (SSL *, int *, void *));
+OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg);
+
+OSSL_DEPRECATEDIN_3_0
+int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
+                             BIGNUM *sa, BIGNUM *v, char *info);
+OSSL_DEPRECATEDIN_3_0
+int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
+                                const char *grp);
+
+OSSL_DEPRECATEDIN_3_0 __owur BIGNUM *SSL_get_srp_g(SSL *s);
+OSSL_DEPRECATEDIN_3_0 __owur BIGNUM *SSL_get_srp_N(SSL *s);
+
+OSSL_DEPRECATEDIN_3_0 __owur char *SSL_get_srp_username(SSL *s);
+OSSL_DEPRECATEDIN_3_0 __owur char *SSL_get_srp_userinfo(SSL *s);
+#  endif
+# endif
+
+/*
+ * ClientHello callback and helpers.
+ */
+
+# define SSL_CLIENT_HELLO_SUCCESS 1
+# define SSL_CLIENT_HELLO_ERROR   0
+# define SSL_CLIENT_HELLO_RETRY   (-1)
+
+typedef int (*SSL_client_hello_cb_fn) (SSL *s, int *al, void *arg);
+void SSL_CTX_set_client_hello_cb(SSL_CTX *c, SSL_client_hello_cb_fn cb,
+                                 void *arg);
+int SSL_client_hello_isv2(SSL *s);
+unsigned int SSL_client_hello_get0_legacy_version(SSL *s);
+size_t SSL_client_hello_get0_random(SSL *s, const unsigned char **out);
+size_t SSL_client_hello_get0_session_id(SSL *s, const unsigned char **out);
+size_t SSL_client_hello_get0_ciphers(SSL *s, const unsigned char **out);
+size_t SSL_client_hello_get0_compression_methods(SSL *s,
+                                                 const unsigned char **out);
+int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen);
+int SSL_client_hello_get0_ext(SSL *s, unsigned int type,
+                              const unsigned char **out, size_t *outlen);
+
+void SSL_certs_clear(SSL *s);
+void SSL_free(SSL *ssl);
+# ifdef OSSL_ASYNC_FD
+/*
+ * Windows application developer has to include windows.h to use these.
+ */
+__owur int SSL_waiting_for_async(SSL *s);
+__owur int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds);
+__owur int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd,
+                                     size_t *numaddfds, OSSL_ASYNC_FD *delfd,
+                                     size_t *numdelfds);
+__owur int SSL_CTX_set_async_callback(SSL_CTX *ctx, SSL_async_callback_fn callback);
+__owur int SSL_CTX_set_async_callback_arg(SSL_CTX *ctx, void *arg);
+__owur int SSL_set_async_callback(SSL *s, SSL_async_callback_fn callback);
+__owur int SSL_set_async_callback_arg(SSL *s, void *arg);
+__owur int SSL_get_async_status(SSL *s, int *status);
+
+# endif
+__owur int SSL_accept(SSL *ssl);
+__owur int SSL_stateless(SSL *s);
+__owur int SSL_connect(SSL *ssl);
+__owur int SSL_read(SSL *ssl, void *buf, int num);
+__owur int SSL_read_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes);
+
+# define SSL_READ_EARLY_DATA_ERROR   0
+# define SSL_READ_EARLY_DATA_SUCCESS 1
+# define SSL_READ_EARLY_DATA_FINISH  2
+
+__owur int SSL_read_early_data(SSL *s, void *buf, size_t num,
+                               size_t *readbytes);
+__owur int SSL_peek(SSL *ssl, void *buf, int num);
+__owur int SSL_peek_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes);
+__owur ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size,
+                                 int flags);
+__owur int SSL_write(SSL *ssl, const void *buf, int num);
+__owur int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written);
+__owur int SSL_write_early_data(SSL *s, const void *buf, size_t num,
+                                size_t *written);
+long SSL_ctrl(SSL *ssl, int cmd, long larg, void *parg);
+long SSL_callback_ctrl(SSL *, int, void (*)(void));
+long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg);
+long SSL_CTX_callback_ctrl(SSL_CTX *, int, void (*)(void));
+
+# define SSL_EARLY_DATA_NOT_SENT    0
+# define SSL_EARLY_DATA_REJECTED    1
+# define SSL_EARLY_DATA_ACCEPTED    2
+
+__owur int SSL_get_early_data_status(const SSL *s);
+
+__owur int SSL_get_error(const SSL *s, int ret_code);
+__owur const char *SSL_get_version(const SSL *s);
+
+/* This sets the 'default' SSL version that SSL_new() will create */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+__owur int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth);
+# endif
+
+# ifndef OPENSSL_NO_SSL3_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_method(void); /* SSLv3 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_client_method(void);
+#  endif
+# endif
+
+#define SSLv23_method           TLS_method
+#define SSLv23_server_method    TLS_server_method
+#define SSLv23_client_method    TLS_client_method
+
+/* Negotiate highest available SSL/TLS version */
+__owur const SSL_METHOD *TLS_method(void);
+__owur const SSL_METHOD *TLS_server_method(void);
+__owur const SSL_METHOD *TLS_client_method(void);
+
+# ifndef OPENSSL_NO_TLS1_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_method(void); /* TLSv1.0 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_client_method(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_TLS1_1_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_method(void); /* TLSv1.1 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_client_method(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_TLS1_2_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_method(void); /* TLSv1.2 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_client_method(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_DTLS1_METHOD
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_method(void); /* DTLSv1.0 */
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_client_method(void);
+#  endif
+# endif
+
+# ifndef OPENSSL_NO_DTLS1_2_METHOD
+/* DTLSv1.2 */
+#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_server_method(void);
+OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_client_method(void);
+#  endif
+# endif
+
+__owur const SSL_METHOD *DTLS_method(void); /* DTLS 1.0 and 1.2 */
+__owur const SSL_METHOD *DTLS_server_method(void); /* DTLS 1.0 and 1.2 */
+__owur const SSL_METHOD *DTLS_client_method(void); /* DTLS 1.0 and 1.2 */
+
+__owur size_t DTLS_get_data_mtu(const SSL *s);
+
+__owur STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s);
+__owur STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx);
+__owur STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s);
+__owur STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s);
+
+__owur int SSL_do_handshake(SSL *s);
+int SSL_key_update(SSL *s, int updatetype);
+int SSL_get_key_update_type(const SSL *s);
+int SSL_renegotiate(SSL *s);
+int SSL_renegotiate_abbreviated(SSL *s);
+__owur int SSL_renegotiate_pending(const SSL *s);
+int SSL_new_session_ticket(SSL *s);
+int SSL_shutdown(SSL *s);
+__owur int SSL_verify_client_post_handshake(SSL *s);
+void SSL_CTX_set_post_handshake_auth(SSL_CTX *ctx, int val);
+void SSL_set_post_handshake_auth(SSL *s, int val);
+
+__owur const SSL_METHOD *SSL_CTX_get_ssl_method(const SSL_CTX *ctx);
+__owur const SSL_METHOD *SSL_get_ssl_method(const SSL *s);
+__owur int SSL_set_ssl_method(SSL *s, const SSL_METHOD *method);
+__owur const char *SSL_alert_type_string_long(int value);
+__owur const char *SSL_alert_type_string(int value);
+__owur const char *SSL_alert_desc_string_long(int value);
+__owur const char *SSL_alert_desc_string(int value);
+
+void SSL_set0_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list);
+void SSL_CTX_set0_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list);
+__owur const STACK_OF(X509_NAME) *SSL_get0_CA_list(const SSL *s);
+__owur const STACK_OF(X509_NAME) *SSL_CTX_get0_CA_list(const SSL_CTX *ctx);
+__owur int SSL_add1_to_CA_list(SSL *ssl, const X509 *x);
+__owur int SSL_CTX_add1_to_CA_list(SSL_CTX *ctx, const X509 *x);
+__owur const STACK_OF(X509_NAME) *SSL_get0_peer_CA_list(const SSL *s);
+
+void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list);
+void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list);
+__owur STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s);
+__owur STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *s);
+__owur int SSL_add_client_CA(SSL *ssl, X509 *x);
+__owur int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x);
+
+void SSL_set_connect_state(SSL *s);
+void SSL_set_accept_state(SSL *s);
+
+__owur long SSL_get_default_timeout(const SSL *s);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSL_library_init() OPENSSL_init_ssl(0, NULL)
+# endif
+
+__owur char *SSL_CIPHER_description(const SSL_CIPHER *, char *buf, int size);
+__owur STACK_OF(X509_NAME) *SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk);
+
+__owur SSL *SSL_dup(SSL *ssl);
+
+__owur X509 *SSL_get_certificate(const SSL *ssl);
+/*
+ * EVP_PKEY
+ */
+struct evp_pkey_st *SSL_get_privatekey(const SSL *ssl);
+
+__owur X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx);
+__owur EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx);
+
+void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode);
+__owur int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx);
+void SSL_set_quiet_shutdown(SSL *ssl, int mode);
+__owur int SSL_get_quiet_shutdown(const SSL *ssl);
+void SSL_set_shutdown(SSL *ssl, int mode);
+__owur int SSL_get_shutdown(const SSL *ssl);
+__owur int SSL_version(const SSL *ssl);
+__owur int SSL_client_version(const SSL *s);
+__owur int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);
+__owur int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx);
+__owur int SSL_CTX_set_default_verify_file(SSL_CTX *ctx);
+__owur int SSL_CTX_set_default_verify_store(SSL_CTX *ctx);
+__owur int SSL_CTX_load_verify_file(SSL_CTX *ctx, const char *CAfile);
+__owur int SSL_CTX_load_verify_dir(SSL_CTX *ctx, const char *CApath);
+__owur int SSL_CTX_load_verify_store(SSL_CTX *ctx, const char *CAstore);
+__owur int SSL_CTX_load_verify_locations(SSL_CTX *ctx,
+                                                        const char *CAfile,
+                                                        const char *CApath);
+# define SSL_get0_session SSL_get_session/* just peek at pointer */
+__owur SSL_SESSION *SSL_get_session(const SSL *ssl);
+__owur SSL_SESSION *SSL_get1_session(SSL *ssl); /* obtain a reference count */
+__owur SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl);
+SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx);
+void SSL_set_info_callback(SSL *ssl,
+                           void (*cb) (const SSL *ssl, int type, int val));
+void (*SSL_get_info_callback(const SSL *ssl)) (const SSL *ssl, int type,
+                                               int val);
+__owur OSSL_HANDSHAKE_STATE SSL_get_state(const SSL *ssl);
+
+void SSL_set_verify_result(SSL *ssl, long v);
+__owur long SSL_get_verify_result(const SSL *ssl);
+__owur STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s);
+
+__owur size_t SSL_get_client_random(const SSL *ssl, unsigned char *out,
+                                    size_t outlen);
+__owur size_t SSL_get_server_random(const SSL *ssl, unsigned char *out,
+                                    size_t outlen);
+__owur size_t SSL_SESSION_get_master_key(const SSL_SESSION *sess,
+                                         unsigned char *out, size_t outlen);
+__owur int SSL_SESSION_set1_master_key(SSL_SESSION *sess,
+                                       const unsigned char *in, size_t len);
+uint8_t SSL_SESSION_get_max_fragment_length(const SSL_SESSION *sess);
+
+#define SSL_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, l, p, newf, dupf, freef)
+__owur int SSL_set_ex_data(SSL *ssl, int idx, void *data);
+void *SSL_get_ex_data(const SSL *ssl, int idx);
+#define SSL_SESSION_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_SESSION, l, p, newf, dupf, freef)
+__owur int SSL_SESSION_set_ex_data(SSL_SESSION *ss, int idx, void *data);
+void *SSL_SESSION_get_ex_data(const SSL_SESSION *ss, int idx);
+#define SSL_CTX_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, l, p, newf, dupf, freef)
+__owur int SSL_CTX_set_ex_data(SSL_CTX *ssl, int idx, void *data);
+void *SSL_CTX_get_ex_data(const SSL_CTX *ssl, int idx);
+
+__owur int SSL_get_ex_data_X509_STORE_CTX_idx(void);
+
+# define SSL_CTX_sess_set_cache_size(ctx,t) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_SIZE,t,NULL)
+# define SSL_CTX_sess_get_cache_size(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_SIZE,0,NULL)
+# define SSL_CTX_set_session_cache_mode(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_MODE,m,NULL)
+# define SSL_CTX_get_session_cache_mode(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_MODE,0,NULL)
+
+# define SSL_CTX_get_default_read_ahead(ctx) SSL_CTX_get_read_ahead(ctx)
+# define SSL_CTX_set_default_read_ahead(ctx,m) SSL_CTX_set_read_ahead(ctx,m)
+# define SSL_CTX_get_read_ahead(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_READ_AHEAD,0,NULL)
+# define SSL_CTX_set_read_ahead(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_READ_AHEAD,m,NULL)
+# define SSL_CTX_get_max_cert_list(ctx) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL)
+# define SSL_CTX_set_max_cert_list(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL)
+# define SSL_get_max_cert_list(ssl) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL)
+# define SSL_set_max_cert_list(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL)
+
+# define SSL_CTX_set_max_send_fragment(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL)
+# define SSL_set_max_send_fragment(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL)
+# define SSL_CTX_set_split_send_fragment(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SPLIT_SEND_FRAGMENT,m,NULL)
+# define SSL_set_split_send_fragment(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_SPLIT_SEND_FRAGMENT,m,NULL)
+# define SSL_CTX_set_max_pipelines(ctx,m) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_PIPELINES,m,NULL)
+# define SSL_set_max_pipelines(ssl,m) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_PIPELINES,m,NULL)
+# define SSL_set_retry_verify(ssl) \
+        (SSL_ctrl(ssl,SSL_CTRL_SET_RETRY_VERIFY,0,NULL) > 0)
+
+void SSL_CTX_set_default_read_buffer_len(SSL_CTX *ctx, size_t len);
+void SSL_set_default_read_buffer_len(SSL *s, size_t len);
+
+# ifndef OPENSSL_NO_DH
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+/* NB: the |keylength| is only applicable when is_export is true */
+OSSL_DEPRECATEDIN_3_0
+void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
+                                 DH *(*dh) (SSL *ssl, int is_export,
+                                            int keylength));
+OSSL_DEPRECATEDIN_3_0
+void SSL_set_tmp_dh_callback(SSL *ssl,
+                             DH *(*dh) (SSL *ssl, int is_export,
+                                        int keylength));
+#  endif
+# endif
+
+__owur const COMP_METHOD *SSL_get_current_compression(const SSL *s);
+__owur const COMP_METHOD *SSL_get_current_expansion(const SSL *s);
+__owur const char *SSL_COMP_get_name(const COMP_METHOD *comp);
+__owur const char *SSL_COMP_get0_name(const SSL_COMP *comp);
+__owur int SSL_COMP_get_id(const SSL_COMP *comp);
+STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void);
+__owur STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP)
+                                                             *meths);
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSL_COMP_free_compression_methods() while(0) continue
+# endif
+__owur int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm);
+
+const SSL_CIPHER *SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr);
+int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c);
+int SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c);
+int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len,
+                             int isv2format, STACK_OF(SSL_CIPHER) **sk,
+                             STACK_OF(SSL_CIPHER) **scsvs);
+
+/* TLS extensions functions */
+__owur int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len);
+
+__owur int SSL_set_session_ticket_ext_cb(SSL *s,
+                                         tls_session_ticket_ext_cb_fn cb,
+                                         void *arg);
+
+/* Pre-shared secret session resumption functions */
+__owur int SSL_set_session_secret_cb(SSL *s,
+                                     tls_session_secret_cb_fn session_secret_cb,
+                                     void *arg);
+
+void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
+                                                int (*cb) (SSL *ssl,
+                                                           int
+                                                           is_forward_secure));
+
+void SSL_set_not_resumable_session_callback(SSL *ssl,
+                                            int (*cb) (SSL *ssl,
+                                                       int is_forward_secure));
+
+void SSL_CTX_set_record_padding_callback(SSL_CTX *ctx,
+                                         size_t (*cb) (SSL *ssl, int type,
+                                                       size_t len, void *arg));
+void SSL_CTX_set_record_padding_callback_arg(SSL_CTX *ctx, void *arg);
+void *SSL_CTX_get_record_padding_callback_arg(const SSL_CTX *ctx);
+int SSL_CTX_set_block_padding(SSL_CTX *ctx, size_t block_size);
+
+int SSL_set_record_padding_callback(SSL *ssl,
+                                    size_t (*cb) (SSL *ssl, int type,
+                                                  size_t len, void *arg));
+void SSL_set_record_padding_callback_arg(SSL *ssl, void *arg);
+void *SSL_get_record_padding_callback_arg(const SSL *ssl);
+int SSL_set_block_padding(SSL *ssl, size_t block_size);
+
+int SSL_set_num_tickets(SSL *s, size_t num_tickets);
+size_t SSL_get_num_tickets(const SSL *s);
+int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets);
+size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define SSL_cache_hit(s) SSL_session_reused(s)
+# endif
+
+__owur int SSL_session_reused(const SSL *s);
+__owur int SSL_is_server(const SSL *s);
+
+__owur __owur SSL_CONF_CTX *SSL_CONF_CTX_new(void);
+int SSL_CONF_CTX_finish(SSL_CONF_CTX *cctx);
+void SSL_CONF_CTX_free(SSL_CONF_CTX *cctx);
+unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX *cctx, unsigned int flags);
+__owur unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX *cctx,
+                                             unsigned int flags);
+__owur int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX *cctx, const char *pre);
+
+void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl);
+void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx);
+
+__owur int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value);
+__owur int SSL_CONF_cmd_argv(SSL_CONF_CTX *cctx, int *pargc, char ***pargv);
+__owur int SSL_CONF_cmd_value_type(SSL_CONF_CTX *cctx, const char *cmd);
+
+void SSL_add_ssl_module(void);
+int SSL_config(SSL *s, const char *name);
+int SSL_CTX_config(SSL_CTX *ctx, const char *name);
+
+# ifndef OPENSSL_NO_SSL_TRACE
+void SSL_trace(int write_p, int version, int content_type,
+               const void *buf, size_t len, SSL *ssl, void *arg);
+# endif
+
+# ifndef OPENSSL_NO_SOCK
+int DTLSv1_listen(SSL *s, BIO_ADDR *client);
+# endif
+
+# ifndef OPENSSL_NO_CT
+
+/*
+ * A callback for verifying that the received SCTs are sufficient.
+ * Expected to return 1 if they are sufficient, otherwise 0.
+ * May return a negative integer if an error occurs.
+ * A connection should be aborted if the SCTs are deemed insufficient.
+ */
+typedef int (*ssl_ct_validation_cb)(const CT_POLICY_EVAL_CTX *ctx,
+                                    const STACK_OF(SCT) *scts, void *arg);
+
+/*
+ * Sets a |callback| that is invoked upon receipt of ServerHelloDone to validate
+ * the received SCTs.
+ * If the callback returns a non-positive result, the connection is terminated.
+ * Call this function before beginning a handshake.
+ * If a NULL |callback| is provided, SCT validation is disabled.
+ * |arg| is arbitrary userdata that will be passed to the callback whenever it
+ * is invoked. Ownership of |arg| remains with the caller.
+ *
+ * NOTE: A side-effect of setting a CT callback is that an OCSP stapled response
+ *       will be requested.
+ */
+int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
+                                   void *arg);
+int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
+                                       ssl_ct_validation_cb callback,
+                                       void *arg);
+#define SSL_disable_ct(s) \
+        ((void) SSL_set_validation_callback((s), NULL, NULL))
+#define SSL_CTX_disable_ct(ctx) \
+        ((void) SSL_CTX_set_validation_callback((ctx), NULL, NULL))
+
+/*
+ * The validation type enumerates the available behaviours of the built-in SSL
+ * CT validation callback selected via SSL_enable_ct() and SSL_CTX_enable_ct().
+ * The underlying callback is a static function in libssl.
+ */
+enum {
+    SSL_CT_VALIDATION_PERMISSIVE = 0,
+    SSL_CT_VALIDATION_STRICT
+};
+
+/*
+ * Enable CT by setting up a callback that implements one of the built-in
+ * validation variants.  The SSL_CT_VALIDATION_PERMISSIVE variant always
+ * continues the handshake, the application can make appropriate decisions at
+ * handshake completion.  The SSL_CT_VALIDATION_STRICT variant requires at
+ * least one valid SCT, or else handshake termination will be requested.  The
+ * handshake may continue anyway if SSL_VERIFY_NONE is in effect.
+ */
+int SSL_enable_ct(SSL *s, int validation_mode);
+int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode);
+
+/*
+ * Report whether a non-NULL callback is enabled.
+ */
+int SSL_ct_is_enabled(const SSL *s);
+int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx);
+
+/* Gets the SCTs received from a connection */
+const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s);
+
+/*
+ * Loads the CT log list from the default location.
+ * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store,
+ * the log information loaded from this file will be appended to the
+ * CTLOG_STORE.
+ * Returns 1 on success, 0 otherwise.
+ */
+int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx);
+
+/*
+ * Loads the CT log list from the specified file path.
+ * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store,
+ * the log information loaded from this file will be appended to the
+ * CTLOG_STORE.
+ * Returns 1 on success, 0 otherwise.
+ */
+int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path);
+
+/*
+ * Sets the CT log list used by all SSL connections created from this SSL_CTX.
+ * Ownership of the CTLOG_STORE is transferred to the SSL_CTX.
+ */
+void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE *logs);
+
+/*
+ * Gets the CT log list used by all SSL connections created from this SSL_CTX.
+ * This will be NULL unless one of the following functions has been called:
+ * - SSL_CTX_set_default_ctlog_list_file
+ * - SSL_CTX_set_ctlog_list_file
+ * - SSL_CTX_set_ctlog_store
+ */
+const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx);
+
+# endif /* OPENSSL_NO_CT */
+
+/* What the "other" parameter contains in security callback */
+/* Mask for type */
+# define SSL_SECOP_OTHER_TYPE    0xffff0000
+# define SSL_SECOP_OTHER_NONE    0
+# define SSL_SECOP_OTHER_CIPHER  (1 << 16)
+# define SSL_SECOP_OTHER_CURVE   (2 << 16)
+# define SSL_SECOP_OTHER_DH      (3 << 16)
+# define SSL_SECOP_OTHER_PKEY    (4 << 16)
+# define SSL_SECOP_OTHER_SIGALG  (5 << 16)
+# define SSL_SECOP_OTHER_CERT    (6 << 16)
+
+/* Indicated operation refers to peer key or certificate */
+# define SSL_SECOP_PEER          0x1000
+
+/* Values for "op" parameter in security callback */
+
+/* Called to filter ciphers */
+/* Ciphers client supports */
+# define SSL_SECOP_CIPHER_SUPPORTED      (1 | SSL_SECOP_OTHER_CIPHER)
+/* Cipher shared by client/server */
+# define SSL_SECOP_CIPHER_SHARED         (2 | SSL_SECOP_OTHER_CIPHER)
+/* Sanity check of cipher server selects */
+# define SSL_SECOP_CIPHER_CHECK          (3 | SSL_SECOP_OTHER_CIPHER)
+/* Curves supported by client */
+# define SSL_SECOP_CURVE_SUPPORTED       (4 | SSL_SECOP_OTHER_CURVE)
+/* Curves shared by client/server */
+# define SSL_SECOP_CURVE_SHARED          (5 | SSL_SECOP_OTHER_CURVE)
+/* Sanity check of curve server selects */
+# define SSL_SECOP_CURVE_CHECK           (6 | SSL_SECOP_OTHER_CURVE)
+/* Temporary DH key */
+# define SSL_SECOP_TMP_DH                (7 | SSL_SECOP_OTHER_PKEY)
+/* SSL/TLS version */
+# define SSL_SECOP_VERSION               (9 | SSL_SECOP_OTHER_NONE)
+/* Session tickets */
+# define SSL_SECOP_TICKET                (10 | SSL_SECOP_OTHER_NONE)
+/* Supported signature algorithms sent to peer */
+# define SSL_SECOP_SIGALG_SUPPORTED      (11 | SSL_SECOP_OTHER_SIGALG)
+/* Shared signature algorithm */
+# define SSL_SECOP_SIGALG_SHARED         (12 | SSL_SECOP_OTHER_SIGALG)
+/* Sanity check signature algorithm allowed */
+# define SSL_SECOP_SIGALG_CHECK          (13 | SSL_SECOP_OTHER_SIGALG)
+/* Used to get mask of supported public key signature algorithms */
+# define SSL_SECOP_SIGALG_MASK           (14 | SSL_SECOP_OTHER_SIGALG)
+/* Use to see if compression is allowed */
+# define SSL_SECOP_COMPRESSION           (15 | SSL_SECOP_OTHER_NONE)
+/* EE key in certificate */
+# define SSL_SECOP_EE_KEY                (16 | SSL_SECOP_OTHER_CERT)
+/* CA key in certificate */
+# define SSL_SECOP_CA_KEY                (17 | SSL_SECOP_OTHER_CERT)
+/* CA digest algorithm in certificate */
+# define SSL_SECOP_CA_MD                 (18 | SSL_SECOP_OTHER_CERT)
+/* Peer EE key in certificate */
+# define SSL_SECOP_PEER_EE_KEY           (SSL_SECOP_EE_KEY | SSL_SECOP_PEER)
+/* Peer CA key in certificate */
+# define SSL_SECOP_PEER_CA_KEY           (SSL_SECOP_CA_KEY | SSL_SECOP_PEER)
+/* Peer CA digest algorithm in certificate */
+# define SSL_SECOP_PEER_CA_MD            (SSL_SECOP_CA_MD | SSL_SECOP_PEER)
+
+void SSL_set_security_level(SSL *s, int level);
+__owur int SSL_get_security_level(const SSL *s);
+void SSL_set_security_callback(SSL *s,
+                               int (*cb) (const SSL *s, const SSL_CTX *ctx,
+                                          int op, int bits, int nid,
+                                          void *other, void *ex));
+int (*SSL_get_security_callback(const SSL *s)) (const SSL *s,
+                                                const SSL_CTX *ctx, int op,
+                                                int bits, int nid, void *other,
+                                                void *ex);
+void SSL_set0_security_ex_data(SSL *s, void *ex);
+__owur void *SSL_get0_security_ex_data(const SSL *s);
+
+void SSL_CTX_set_security_level(SSL_CTX *ctx, int level);
+__owur int SSL_CTX_get_security_level(const SSL_CTX *ctx);
+void SSL_CTX_set_security_callback(SSL_CTX *ctx,
+                                   int (*cb) (const SSL *s, const SSL_CTX *ctx,
+                                              int op, int bits, int nid,
+                                              void *other, void *ex));
+int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
+                                                          const SSL_CTX *ctx,
+                                                          int op, int bits,
+                                                          int nid,
+                                                          void *other,
+                                                          void *ex);
+void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex);
+__owur void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx);
+
+/* OPENSSL_INIT flag 0x010000 reserved for internal use */
+# define OPENSSL_INIT_NO_LOAD_SSL_STRINGS    0x00100000L
+# define OPENSSL_INIT_LOAD_SSL_STRINGS       0x00200000L
+
+# define OPENSSL_INIT_SSL_DEFAULT \
+        (OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
+
+int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
+
+# ifndef OPENSSL_NO_UNIT_TEST
+__owur const struct openssl_ssl_test_functions *SSL_test_functions(void);
+# endif
+
+__owur int SSL_free_buffers(SSL *ssl);
+__owur int SSL_alloc_buffers(SSL *ssl);
+
+/* Status codes passed to the decrypt session ticket callback. Some of these
+ * are for internal use only and are never passed to the callback. */
+typedef int SSL_TICKET_STATUS;
+
+/* Support for ticket appdata */
+/* fatal error, malloc failure */
+# define SSL_TICKET_FATAL_ERR_MALLOC 0
+/* fatal error, either from parsing or decrypting the ticket */
+# define SSL_TICKET_FATAL_ERR_OTHER  1
+/* No ticket present */
+# define SSL_TICKET_NONE             2
+/* Empty ticket present */
+# define SSL_TICKET_EMPTY            3
+/* the ticket couldn't be decrypted */
+# define SSL_TICKET_NO_DECRYPT       4
+/* a ticket was successfully decrypted */
+# define SSL_TICKET_SUCCESS          5
+/* same as above but the ticket needs to be renewed */
+# define SSL_TICKET_SUCCESS_RENEW    6
+
+/* Return codes for the decrypt session ticket callback */
+typedef int SSL_TICKET_RETURN;
+
+/* An error occurred */
+#define SSL_TICKET_RETURN_ABORT             0
+/* Do not use the ticket, do not send a renewed ticket to the client */
+#define SSL_TICKET_RETURN_IGNORE            1
+/* Do not use the ticket, send a renewed ticket to the client */
+#define SSL_TICKET_RETURN_IGNORE_RENEW      2
+/* Use the ticket, do not send a renewed ticket to the client */
+#define SSL_TICKET_RETURN_USE               3
+/* Use the ticket, send a renewed ticket to the client */
+#define SSL_TICKET_RETURN_USE_RENEW         4
+
+typedef int (*SSL_CTX_generate_session_ticket_fn)(SSL *s, void *arg);
+typedef SSL_TICKET_RETURN (*SSL_CTX_decrypt_session_ticket_fn)(SSL *s, SSL_SESSION *ss,
+                                                               const unsigned char *keyname,
+                                                               size_t keyname_length,
+                                                               SSL_TICKET_STATUS status,
+                                                               void *arg);
+int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx,
+                                  SSL_CTX_generate_session_ticket_fn gen_cb,
+                                  SSL_CTX_decrypt_session_ticket_fn dec_cb,
+                                  void *arg);
+int SSL_SESSION_set1_ticket_appdata(SSL_SESSION *ss, const void *data, size_t len);
+int SSL_SESSION_get0_ticket_appdata(SSL_SESSION *ss, void **data, size_t *len);
+
+typedef unsigned int (*DTLS_timer_cb)(SSL *s, unsigned int timer_us);
+
+void DTLS_set_timer_cb(SSL *s, DTLS_timer_cb cb);
+
+
+typedef int (*SSL_allow_early_data_cb_fn)(SSL *s, void *arg);
+void SSL_CTX_set_allow_early_data_cb(SSL_CTX *ctx,
+                                     SSL_allow_early_data_cb_fn cb,
+                                     void *arg);
+void SSL_set_allow_early_data_cb(SSL *s,
+                                 SSL_allow_early_data_cb_fn cb,
+                                 void *arg);
+
+/* store the default cipher strings inside the library */
+const char *OSSL_default_cipher_list(void);
+const char *OSSL_default_ciphersuites(void);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ssl2.h b/CAPI/cpp/grpc/include/openssl/ssl2.h
new file mode 100644
index 0000000..428ead0
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ssl2.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SSL2_H
+# define OPENSSL_SSL2_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SSL2_H
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define SSL2_VERSION            0x0002
+
+# define SSL2_MT_CLIENT_HELLO            1
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ssl3.h b/CAPI/cpp/grpc/include/openssl/ssl3.h
new file mode 100644
index 0000000..49bd51f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ssl3.h
@@ -0,0 +1,347 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SSL3_H
+# define OPENSSL_SSL3_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SSL3_H
+# endif
+
+# include <openssl/comp.h>
+# include <openssl/buffer.h>
+# include <openssl/evp.h>
+# include <openssl/ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Signalling cipher suite value from RFC 5746
+ * (TLS_EMPTY_RENEGOTIATION_INFO_SCSV)
+ */
+# define SSL3_CK_SCSV                            0x030000FF
+
+/*
+ * Signalling cipher suite value from draft-ietf-tls-downgrade-scsv-00
+ * (TLS_FALLBACK_SCSV)
+ */
+# define SSL3_CK_FALLBACK_SCSV                   0x03005600
+
+# define SSL3_CK_RSA_NULL_MD5                    0x03000001
+# define SSL3_CK_RSA_NULL_SHA                    0x03000002
+# define SSL3_CK_RSA_RC4_40_MD5                  0x03000003
+# define SSL3_CK_RSA_RC4_128_MD5                 0x03000004
+# define SSL3_CK_RSA_RC4_128_SHA                 0x03000005
+# define SSL3_CK_RSA_RC2_40_MD5                  0x03000006
+# define SSL3_CK_RSA_IDEA_128_SHA                0x03000007
+# define SSL3_CK_RSA_DES_40_CBC_SHA              0x03000008
+# define SSL3_CK_RSA_DES_64_CBC_SHA              0x03000009
+# define SSL3_CK_RSA_DES_192_CBC3_SHA            0x0300000A
+
+# define SSL3_CK_DH_DSS_DES_40_CBC_SHA           0x0300000B
+# define SSL3_CK_DH_DSS_DES_64_CBC_SHA           0x0300000C
+# define SSL3_CK_DH_DSS_DES_192_CBC3_SHA         0x0300000D
+# define SSL3_CK_DH_RSA_DES_40_CBC_SHA           0x0300000E
+# define SSL3_CK_DH_RSA_DES_64_CBC_SHA           0x0300000F
+# define SSL3_CK_DH_RSA_DES_192_CBC3_SHA         0x03000010
+
+# define SSL3_CK_DHE_DSS_DES_40_CBC_SHA          0x03000011
+# define SSL3_CK_EDH_DSS_DES_40_CBC_SHA          SSL3_CK_DHE_DSS_DES_40_CBC_SHA
+# define SSL3_CK_DHE_DSS_DES_64_CBC_SHA          0x03000012
+# define SSL3_CK_EDH_DSS_DES_64_CBC_SHA          SSL3_CK_DHE_DSS_DES_64_CBC_SHA
+# define SSL3_CK_DHE_DSS_DES_192_CBC3_SHA        0x03000013
+# define SSL3_CK_EDH_DSS_DES_192_CBC3_SHA        SSL3_CK_DHE_DSS_DES_192_CBC3_SHA
+# define SSL3_CK_DHE_RSA_DES_40_CBC_SHA          0x03000014
+# define SSL3_CK_EDH_RSA_DES_40_CBC_SHA          SSL3_CK_DHE_RSA_DES_40_CBC_SHA
+# define SSL3_CK_DHE_RSA_DES_64_CBC_SHA          0x03000015
+# define SSL3_CK_EDH_RSA_DES_64_CBC_SHA          SSL3_CK_DHE_RSA_DES_64_CBC_SHA
+# define SSL3_CK_DHE_RSA_DES_192_CBC3_SHA        0x03000016
+# define SSL3_CK_EDH_RSA_DES_192_CBC3_SHA        SSL3_CK_DHE_RSA_DES_192_CBC3_SHA
+
+# define SSL3_CK_ADH_RC4_40_MD5                  0x03000017
+# define SSL3_CK_ADH_RC4_128_MD5                 0x03000018
+# define SSL3_CK_ADH_DES_40_CBC_SHA              0x03000019
+# define SSL3_CK_ADH_DES_64_CBC_SHA              0x0300001A
+# define SSL3_CK_ADH_DES_192_CBC_SHA             0x0300001B
+
+/* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */
+# define SSL3_RFC_RSA_NULL_MD5                   "TLS_RSA_WITH_NULL_MD5"
+# define SSL3_RFC_RSA_NULL_SHA                   "TLS_RSA_WITH_NULL_SHA"
+# define SSL3_RFC_RSA_DES_192_CBC3_SHA           "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
+# define SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA       "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"
+# define SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA       "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"
+# define SSL3_RFC_ADH_DES_192_CBC_SHA            "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"
+# define SSL3_RFC_RSA_IDEA_128_SHA               "TLS_RSA_WITH_IDEA_CBC_SHA"
+# define SSL3_RFC_RSA_RC4_128_MD5                "TLS_RSA_WITH_RC4_128_MD5"
+# define SSL3_RFC_RSA_RC4_128_SHA                "TLS_RSA_WITH_RC4_128_SHA"
+# define SSL3_RFC_ADH_RC4_128_MD5                "TLS_DH_anon_WITH_RC4_128_MD5"
+
+# define SSL3_TXT_RSA_NULL_MD5                   "NULL-MD5"
+# define SSL3_TXT_RSA_NULL_SHA                   "NULL-SHA"
+# define SSL3_TXT_RSA_RC4_40_MD5                 "EXP-RC4-MD5"
+# define SSL3_TXT_RSA_RC4_128_MD5                "RC4-MD5"
+# define SSL3_TXT_RSA_RC4_128_SHA                "RC4-SHA"
+# define SSL3_TXT_RSA_RC2_40_MD5                 "EXP-RC2-CBC-MD5"
+# define SSL3_TXT_RSA_IDEA_128_SHA               "IDEA-CBC-SHA"
+# define SSL3_TXT_RSA_DES_40_CBC_SHA             "EXP-DES-CBC-SHA"
+# define SSL3_TXT_RSA_DES_64_CBC_SHA             "DES-CBC-SHA"
+# define SSL3_TXT_RSA_DES_192_CBC3_SHA           "DES-CBC3-SHA"
+
+# define SSL3_TXT_DH_DSS_DES_40_CBC_SHA          "EXP-DH-DSS-DES-CBC-SHA"
+# define SSL3_TXT_DH_DSS_DES_64_CBC_SHA          "DH-DSS-DES-CBC-SHA"
+# define SSL3_TXT_DH_DSS_DES_192_CBC3_SHA        "DH-DSS-DES-CBC3-SHA"
+# define SSL3_TXT_DH_RSA_DES_40_CBC_SHA          "EXP-DH-RSA-DES-CBC-SHA"
+# define SSL3_TXT_DH_RSA_DES_64_CBC_SHA          "DH-RSA-DES-CBC-SHA"
+# define SSL3_TXT_DH_RSA_DES_192_CBC3_SHA        "DH-RSA-DES-CBC3-SHA"
+
+# define SSL3_TXT_DHE_DSS_DES_40_CBC_SHA         "EXP-DHE-DSS-DES-CBC-SHA"
+# define SSL3_TXT_DHE_DSS_DES_64_CBC_SHA         "DHE-DSS-DES-CBC-SHA"
+# define SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA       "DHE-DSS-DES-CBC3-SHA"
+# define SSL3_TXT_DHE_RSA_DES_40_CBC_SHA         "EXP-DHE-RSA-DES-CBC-SHA"
+# define SSL3_TXT_DHE_RSA_DES_64_CBC_SHA         "DHE-RSA-DES-CBC-SHA"
+# define SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA       "DHE-RSA-DES-CBC3-SHA"
+
+/*
+ * This next block of six "EDH" labels is for backward compatibility with
+ * older versions of OpenSSL.  New code should use the six "DHE" labels above
+ * instead:
+ */
+# define SSL3_TXT_EDH_DSS_DES_40_CBC_SHA         "EXP-EDH-DSS-DES-CBC-SHA"
+# define SSL3_TXT_EDH_DSS_DES_64_CBC_SHA         "EDH-DSS-DES-CBC-SHA"
+# define SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA       "EDH-DSS-DES-CBC3-SHA"
+# define SSL3_TXT_EDH_RSA_DES_40_CBC_SHA         "EXP-EDH-RSA-DES-CBC-SHA"
+# define SSL3_TXT_EDH_RSA_DES_64_CBC_SHA         "EDH-RSA-DES-CBC-SHA"
+# define SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA       "EDH-RSA-DES-CBC3-SHA"
+
+# define SSL3_TXT_ADH_RC4_40_MD5                 "EXP-ADH-RC4-MD5"
+# define SSL3_TXT_ADH_RC4_128_MD5                "ADH-RC4-MD5"
+# define SSL3_TXT_ADH_DES_40_CBC_SHA             "EXP-ADH-DES-CBC-SHA"
+# define SSL3_TXT_ADH_DES_64_CBC_SHA             "ADH-DES-CBC-SHA"
+# define SSL3_TXT_ADH_DES_192_CBC_SHA            "ADH-DES-CBC3-SHA"
+
+# define SSL3_SSL_SESSION_ID_LENGTH              32
+# define SSL3_MAX_SSL_SESSION_ID_LENGTH          32
+
+# define SSL3_MASTER_SECRET_SIZE                 48
+# define SSL3_RANDOM_SIZE                        32
+# define SSL3_SESSION_ID_SIZE                    32
+# define SSL3_RT_HEADER_LENGTH                   5
+
+# define SSL3_HM_HEADER_LENGTH                  4
+
+# ifndef SSL3_ALIGN_PAYLOAD
+ /*
+  * Some will argue that this increases memory footprint, but it's not
+  * actually true. Point is that malloc has to return at least 64-bit aligned
+  * pointers, meaning that allocating 5 bytes wastes 3 bytes in either case.
+  * Suggested pre-gaping simply moves these wasted bytes from the end of
+  * allocated region to its front, but makes data payload aligned, which
+  * improves performance:-)
+  */
+#  define SSL3_ALIGN_PAYLOAD                     8
+# else
+#  if (SSL3_ALIGN_PAYLOAD&(SSL3_ALIGN_PAYLOAD-1))!=0
+#   error "insane SSL3_ALIGN_PAYLOAD"
+#   undef SSL3_ALIGN_PAYLOAD
+#  endif
+# endif
+
+/*
+ * This is the maximum MAC (digest) size used by the SSL library. Currently
+ * maximum of 20 is used by SHA1, but we reserve for future extension for
+ * 512-bit hashes.
+ */
+
+# define SSL3_RT_MAX_MD_SIZE                     64
+
+/*
+ * Maximum block size used in all ciphersuites. Currently 16 for AES.
+ */
+
+# define SSL_RT_MAX_CIPHER_BLOCK_SIZE            16
+
+# define SSL3_RT_MAX_EXTRA                       (16384)
+
+/* Maximum plaintext length: defined by SSL/TLS standards */
+# define SSL3_RT_MAX_PLAIN_LENGTH                16384
+/* Maximum compression overhead: defined by SSL/TLS standards */
+# define SSL3_RT_MAX_COMPRESSED_OVERHEAD         1024
+
+/*
+ * The standards give a maximum encryption overhead of 1024 bytes. In
+ * practice the value is lower than this. The overhead is the maximum number
+ * of padding bytes (256) plus the mac size.
+ */
+# define SSL3_RT_MAX_ENCRYPTED_OVERHEAD        (256 + SSL3_RT_MAX_MD_SIZE)
+# define SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD  256
+
+/*
+ * OpenSSL currently only uses a padding length of at most one block so the
+ * send overhead is smaller.
+ */
+
+# define SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
+                        (SSL_RT_MAX_CIPHER_BLOCK_SIZE + SSL3_RT_MAX_MD_SIZE)
+
+/* If compression isn't used don't include the compression overhead */
+
+# ifdef OPENSSL_NO_COMP
+#  define SSL3_RT_MAX_COMPRESSED_LENGTH           SSL3_RT_MAX_PLAIN_LENGTH
+# else
+#  define SSL3_RT_MAX_COMPRESSED_LENGTH   \
+            (SSL3_RT_MAX_PLAIN_LENGTH+SSL3_RT_MAX_COMPRESSED_OVERHEAD)
+# endif
+# define SSL3_RT_MAX_ENCRYPTED_LENGTH    \
+            (SSL3_RT_MAX_ENCRYPTED_OVERHEAD+SSL3_RT_MAX_COMPRESSED_LENGTH)
+# define SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH \
+            (SSL3_RT_MAX_PLAIN_LENGTH + SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD)
+# define SSL3_RT_MAX_PACKET_SIZE         \
+            (SSL3_RT_MAX_ENCRYPTED_LENGTH+SSL3_RT_HEADER_LENGTH)
+
+# define SSL3_MD_CLIENT_FINISHED_CONST   "\x43\x4C\x4E\x54"
+# define SSL3_MD_SERVER_FINISHED_CONST   "\x53\x52\x56\x52"
+
+/* SSL3_VERSION is defined in prov_ssl.h */
+# define SSL3_VERSION_MAJOR              0x03
+# define SSL3_VERSION_MINOR              0x00
+
+# define SSL3_RT_CHANGE_CIPHER_SPEC      20
+# define SSL3_RT_ALERT                   21
+# define SSL3_RT_HANDSHAKE               22
+# define SSL3_RT_APPLICATION_DATA        23
+
+/* Pseudo content types to indicate additional parameters */
+# define TLS1_RT_CRYPTO                  0x1000
+# define TLS1_RT_CRYPTO_PREMASTER        (TLS1_RT_CRYPTO | 0x1)
+# define TLS1_RT_CRYPTO_CLIENT_RANDOM    (TLS1_RT_CRYPTO | 0x2)
+# define TLS1_RT_CRYPTO_SERVER_RANDOM    (TLS1_RT_CRYPTO | 0x3)
+# define TLS1_RT_CRYPTO_MASTER           (TLS1_RT_CRYPTO | 0x4)
+
+# define TLS1_RT_CRYPTO_READ             0x0000
+# define TLS1_RT_CRYPTO_WRITE            0x0100
+# define TLS1_RT_CRYPTO_MAC              (TLS1_RT_CRYPTO | 0x5)
+# define TLS1_RT_CRYPTO_KEY              (TLS1_RT_CRYPTO | 0x6)
+# define TLS1_RT_CRYPTO_IV               (TLS1_RT_CRYPTO | 0x7)
+# define TLS1_RT_CRYPTO_FIXED_IV         (TLS1_RT_CRYPTO | 0x8)
+
+/* Pseudo content types for SSL/TLS header info */
+# define SSL3_RT_HEADER                  0x100
+# define SSL3_RT_INNER_CONTENT_TYPE      0x101
+
+# define SSL3_AL_WARNING                 1
+# define SSL3_AL_FATAL                   2
+
+# define SSL3_AD_CLOSE_NOTIFY             0
+# define SSL3_AD_UNEXPECTED_MESSAGE      10/* fatal */
+# define SSL3_AD_BAD_RECORD_MAC          20/* fatal */
+# define SSL3_AD_DECOMPRESSION_FAILURE   30/* fatal */
+# define SSL3_AD_HANDSHAKE_FAILURE       40/* fatal */
+# define SSL3_AD_NO_CERTIFICATE          41
+# define SSL3_AD_BAD_CERTIFICATE         42
+# define SSL3_AD_UNSUPPORTED_CERTIFICATE 43
+# define SSL3_AD_CERTIFICATE_REVOKED     44
+# define SSL3_AD_CERTIFICATE_EXPIRED     45
+# define SSL3_AD_CERTIFICATE_UNKNOWN     46
+# define SSL3_AD_ILLEGAL_PARAMETER       47/* fatal */
+
+# define TLS1_HB_REQUEST         1
+# define TLS1_HB_RESPONSE        2
+
+
+# define SSL3_CT_RSA_SIGN                        1
+# define SSL3_CT_DSS_SIGN                        2
+# define SSL3_CT_RSA_FIXED_DH                    3
+# define SSL3_CT_DSS_FIXED_DH                    4
+# define SSL3_CT_RSA_EPHEMERAL_DH                5
+# define SSL3_CT_DSS_EPHEMERAL_DH                6
+# define SSL3_CT_FORTEZZA_DMS                    20
+/*
+ * SSL3_CT_NUMBER is used to size arrays and it must be large enough to
+ * contain all of the cert types defined for *either* SSLv3 and TLSv1.
+ */
+# define SSL3_CT_NUMBER                  12
+
+# if defined(TLS_CT_NUMBER)
+#  if TLS_CT_NUMBER != SSL3_CT_NUMBER
+#    error "SSL/TLS CT_NUMBER values do not match"
+#  endif
+# endif
+
+/* No longer used as of OpenSSL 1.1.1 */
+# define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS       0x0001
+
+/* Removed from OpenSSL 1.1.0 */
+# define TLS1_FLAGS_TLS_PADDING_BUG              0x0
+
+# define TLS1_FLAGS_SKIP_CERT_VERIFY             0x0010
+
+/* Set if we encrypt then mac instead of usual mac then encrypt */
+# define TLS1_FLAGS_ENCRYPT_THEN_MAC_READ        0x0100
+# define TLS1_FLAGS_ENCRYPT_THEN_MAC             TLS1_FLAGS_ENCRYPT_THEN_MAC_READ
+
+/* Set if extended master secret extension received from peer */
+# define TLS1_FLAGS_RECEIVED_EXTMS               0x0200
+
+# define TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE       0x0400
+
+# define TLS1_FLAGS_STATELESS                    0x0800
+
+/* Set if extended master secret extension required on renegotiation */
+# define TLS1_FLAGS_REQUIRED_EXTMS               0x1000
+
+# define SSL3_MT_HELLO_REQUEST                   0
+# define SSL3_MT_CLIENT_HELLO                    1
+# define SSL3_MT_SERVER_HELLO                    2
+# define SSL3_MT_NEWSESSION_TICKET               4
+# define SSL3_MT_END_OF_EARLY_DATA               5
+# define SSL3_MT_ENCRYPTED_EXTENSIONS            8
+# define SSL3_MT_CERTIFICATE                     11
+# define SSL3_MT_SERVER_KEY_EXCHANGE             12
+# define SSL3_MT_CERTIFICATE_REQUEST             13
+# define SSL3_MT_SERVER_DONE                     14
+# define SSL3_MT_CERTIFICATE_VERIFY              15
+# define SSL3_MT_CLIENT_KEY_EXCHANGE             16
+# define SSL3_MT_FINISHED                        20
+# define SSL3_MT_CERTIFICATE_URL                 21
+# define SSL3_MT_CERTIFICATE_STATUS              22
+# define SSL3_MT_SUPPLEMENTAL_DATA               23
+# define SSL3_MT_KEY_UPDATE                      24
+# ifndef OPENSSL_NO_NEXTPROTONEG
+#  define SSL3_MT_NEXT_PROTO                     67
+# endif
+# define SSL3_MT_MESSAGE_HASH                    254
+# define DTLS1_MT_HELLO_VERIFY_REQUEST           3
+
+/* Dummy message type for handling CCS like a normal handshake message */
+# define SSL3_MT_CHANGE_CIPHER_SPEC              0x0101
+
+# define SSL3_MT_CCS                             1
+
+/* These are used when changing over to a new cipher */
+# define SSL3_CC_READ            0x001
+# define SSL3_CC_WRITE           0x002
+# define SSL3_CC_CLIENT          0x010
+# define SSL3_CC_SERVER          0x020
+# define SSL3_CC_EARLY           0x040
+# define SSL3_CC_HANDSHAKE       0x080
+# define SSL3_CC_APPLICATION     0x100
+# define SSL3_CHANGE_CIPHER_CLIENT_WRITE (SSL3_CC_CLIENT|SSL3_CC_WRITE)
+# define SSL3_CHANGE_CIPHER_SERVER_READ  (SSL3_CC_SERVER|SSL3_CC_READ)
+# define SSL3_CHANGE_CIPHER_CLIENT_READ  (SSL3_CC_CLIENT|SSL3_CC_READ)
+# define SSL3_CHANGE_CIPHER_SERVER_WRITE (SSL3_CC_SERVER|SSL3_CC_WRITE)
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/sslerr.h b/CAPI/cpp/grpc/include/openssl/sslerr.h
new file mode 100644
index 0000000..a4746d7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/sslerr.h
@@ -0,0 +1,343 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SSLERR_H
+# define OPENSSL_SSLERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/sslerr_legacy.h>
+
+
+
+/*
+ * SSL reason codes.
+ */
+# define SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY        291
+# define SSL_R_APP_DATA_IN_HANDSHAKE                      100
+# define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 272
+# define SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE     158
+# define SSL_R_BAD_CHANGE_CIPHER_SPEC                     103
+# define SSL_R_BAD_CIPHER                                 186
+# define SSL_R_BAD_DATA                                   390
+# define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK              106
+# define SSL_R_BAD_DECOMPRESSION                          107
+# define SSL_R_BAD_DH_VALUE                               102
+# define SSL_R_BAD_DIGEST_LENGTH                          111
+# define SSL_R_BAD_EARLY_DATA                             233
+# define SSL_R_BAD_ECC_CERT                               304
+# define SSL_R_BAD_ECPOINT                                306
+# define SSL_R_BAD_EXTENSION                              110
+# define SSL_R_BAD_HANDSHAKE_LENGTH                       332
+# define SSL_R_BAD_HANDSHAKE_STATE                        236
+# define SSL_R_BAD_HELLO_REQUEST                          105
+# define SSL_R_BAD_HRR_VERSION                            263
+# define SSL_R_BAD_KEY_SHARE                              108
+# define SSL_R_BAD_KEY_UPDATE                             122
+# define SSL_R_BAD_LEGACY_VERSION                         292
+# define SSL_R_BAD_LENGTH                                 271
+# define SSL_R_BAD_PACKET                                 240
+# define SSL_R_BAD_PACKET_LENGTH                          115
+# define SSL_R_BAD_PROTOCOL_VERSION_NUMBER                116
+# define SSL_R_BAD_PSK                                    219
+# define SSL_R_BAD_PSK_IDENTITY                           114
+# define SSL_R_BAD_RECORD_TYPE                            443
+# define SSL_R_BAD_RSA_ENCRYPT                            119
+# define SSL_R_BAD_SIGNATURE                              123
+# define SSL_R_BAD_SRP_A_LENGTH                           347
+# define SSL_R_BAD_SRP_PARAMETERS                         371
+# define SSL_R_BAD_SRTP_MKI_VALUE                         352
+# define SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST           353
+# define SSL_R_BAD_SSL_FILETYPE                           124
+# define SSL_R_BAD_VALUE                                  384
+# define SSL_R_BAD_WRITE_RETRY                            127
+# define SSL_R_BINDER_DOES_NOT_VERIFY                     253
+# define SSL_R_BIO_NOT_SET                                128
+# define SSL_R_BLOCK_CIPHER_PAD_IS_WRONG                  129
+# define SSL_R_BN_LIB                                     130
+# define SSL_R_CALLBACK_FAILED                            234
+# define SSL_R_CANNOT_CHANGE_CIPHER                       109
+# define SSL_R_CANNOT_GET_GROUP_NAME                      299
+# define SSL_R_CA_DN_LENGTH_MISMATCH                      131
+# define SSL_R_CA_KEY_TOO_SMALL                           397
+# define SSL_R_CA_MD_TOO_WEAK                             398
+# define SSL_R_CCS_RECEIVED_EARLY                         133
+# define SSL_R_CERTIFICATE_VERIFY_FAILED                  134
+# define SSL_R_CERT_CB_ERROR                              377
+# define SSL_R_CERT_LENGTH_MISMATCH                       135
+# define SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED             218
+# define SSL_R_CIPHER_CODE_WRONG_LENGTH                   137
+# define SSL_R_CLIENTHELLO_TLSEXT                         226
+# define SSL_R_COMPRESSED_LENGTH_TOO_LONG                 140
+# define SSL_R_COMPRESSION_DISABLED                       343
+# define SSL_R_COMPRESSION_FAILURE                        141
+# define SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE    307
+# define SSL_R_COMPRESSION_LIBRARY_ERROR                  142
+# define SSL_R_CONNECTION_TYPE_NOT_SET                    144
+# define SSL_R_CONTEXT_NOT_DANE_ENABLED                   167
+# define SSL_R_COOKIE_GEN_CALLBACK_FAILURE                400
+# define SSL_R_COOKIE_MISMATCH                            308
+# define SSL_R_COPY_PARAMETERS_FAILED                     296
+# define SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED       206
+# define SSL_R_DANE_ALREADY_ENABLED                       172
+# define SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL            173
+# define SSL_R_DANE_NOT_ENABLED                           175
+# define SSL_R_DANE_TLSA_BAD_CERTIFICATE                  180
+# define SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE            184
+# define SSL_R_DANE_TLSA_BAD_DATA_LENGTH                  189
+# define SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH                192
+# define SSL_R_DANE_TLSA_BAD_MATCHING_TYPE                200
+# define SSL_R_DANE_TLSA_BAD_PUBLIC_KEY                   201
+# define SSL_R_DANE_TLSA_BAD_SELECTOR                     202
+# define SSL_R_DANE_TLSA_NULL_DATA                        203
+# define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              145
+# define SSL_R_DATA_LENGTH_TOO_LONG                       146
+# define SSL_R_DECRYPTION_FAILED                          147
+# define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC        281
+# define SSL_R_DH_KEY_TOO_SMALL                           394
+# define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG            148
+# define SSL_R_DIGEST_CHECK_FAILED                        149
+# define SSL_R_DTLS_MESSAGE_TOO_BIG                       334
+# define SSL_R_DUPLICATE_COMPRESSION_ID                   309
+# define SSL_R_ECC_CERT_NOT_FOR_SIGNING                   318
+# define SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE              374
+# define SSL_R_EE_KEY_TOO_SMALL                           399
+# define SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST         354
+# define SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  150
+# define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              151
+# define SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN             204
+# define SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE                  194
+# define SSL_R_EXCESSIVE_MESSAGE_SIZE                     152
+# define SSL_R_EXTENSION_NOT_RECEIVED                     279
+# define SSL_R_EXTRA_DATA_IN_MESSAGE                      153
+# define SSL_R_EXT_LENGTH_MISMATCH                        163
+# define SSL_R_FAILED_TO_INIT_ASYNC                       405
+# define SSL_R_FRAGMENTED_CLIENT_HELLO                    401
+# define SSL_R_GOT_A_FIN_BEFORE_A_CCS                     154
+# define SSL_R_HTTPS_PROXY_REQUEST                        155
+# define SSL_R_HTTP_REQUEST                               156
+# define SSL_R_ILLEGAL_POINT_COMPRESSION                  162
+# define SSL_R_ILLEGAL_SUITEB_DIGEST                      380
+# define SSL_R_INAPPROPRIATE_FALLBACK                     373
+# define SSL_R_INCONSISTENT_COMPRESSION                   340
+# define SSL_R_INCONSISTENT_EARLY_DATA_ALPN               222
+# define SSL_R_INCONSISTENT_EARLY_DATA_SNI                231
+# define SSL_R_INCONSISTENT_EXTMS                         104
+# define SSL_R_INSUFFICIENT_SECURITY                      241
+# define SSL_R_INVALID_ALERT                              205
+# define SSL_R_INVALID_CCS_MESSAGE                        260
+# define SSL_R_INVALID_CERTIFICATE_OR_ALG                 238
+# define SSL_R_INVALID_COMMAND                            280
+# define SSL_R_INVALID_COMPRESSION_ALGORITHM              341
+# define SSL_R_INVALID_CONFIG                             283
+# define SSL_R_INVALID_CONFIGURATION_NAME                 113
+# define SSL_R_INVALID_CONTEXT                            282
+# define SSL_R_INVALID_CT_VALIDATION_TYPE                 212
+# define SSL_R_INVALID_KEY_UPDATE_TYPE                    120
+# define SSL_R_INVALID_MAX_EARLY_DATA                     174
+# define SSL_R_INVALID_NULL_CMD_NAME                      385
+# define SSL_R_INVALID_SEQUENCE_NUMBER                    402
+# define SSL_R_INVALID_SERVERINFO_DATA                    388
+# define SSL_R_INVALID_SESSION_ID                         999
+# define SSL_R_INVALID_SRP_USERNAME                       357
+# define SSL_R_INVALID_STATUS_RESPONSE                    328
+# define SSL_R_INVALID_TICKET_KEYS_LENGTH                 325
+# define SSL_R_LENGTH_MISMATCH                            159
+# define SSL_R_LENGTH_TOO_LONG                            404
+# define SSL_R_LENGTH_TOO_SHORT                           160
+# define SSL_R_LIBRARY_BUG                                274
+# define SSL_R_LIBRARY_HAS_NO_CIPHERS                     161
+# define SSL_R_MISSING_DSA_SIGNING_CERT                   165
+# define SSL_R_MISSING_ECDSA_SIGNING_CERT                 381
+# define SSL_R_MISSING_FATAL                              256
+# define SSL_R_MISSING_PARAMETERS                         290
+# define SSL_R_MISSING_PSK_KEX_MODES_EXTENSION            310
+# define SSL_R_MISSING_RSA_CERTIFICATE                    168
+# define SSL_R_MISSING_RSA_ENCRYPTING_CERT                169
+# define SSL_R_MISSING_RSA_SIGNING_CERT                   170
+# define SSL_R_MISSING_SIGALGS_EXTENSION                  112
+# define SSL_R_MISSING_SIGNING_CERT                       221
+# define SSL_R_MISSING_SRP_PARAM                          358
+# define SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION         209
+# define SSL_R_MISSING_TMP_DH_KEY                         171
+# define SSL_R_MISSING_TMP_ECDH_KEY                       311
+# define SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA     293
+# define SSL_R_NOT_ON_RECORD_BOUNDARY                     182
+# define SSL_R_NOT_REPLACING_CERTIFICATE                  289
+# define SSL_R_NOT_SERVER                                 284
+# define SSL_R_NO_APPLICATION_PROTOCOL                    235
+# define SSL_R_NO_CERTIFICATES_RETURNED                   176
+# define SSL_R_NO_CERTIFICATE_ASSIGNED                    177
+# define SSL_R_NO_CERTIFICATE_SET                         179
+# define SSL_R_NO_CHANGE_FOLLOWING_HRR                    214
+# define SSL_R_NO_CIPHERS_AVAILABLE                       181
+# define SSL_R_NO_CIPHERS_SPECIFIED                       183
+# define SSL_R_NO_CIPHER_MATCH                            185
+# define SSL_R_NO_CLIENT_CERT_METHOD                      331
+# define SSL_R_NO_COMPRESSION_SPECIFIED                   187
+# define SSL_R_NO_COOKIE_CALLBACK_SET                     287
+# define SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER           330
+# define SSL_R_NO_METHOD_SPECIFIED                        188
+# define SSL_R_NO_PEM_EXTENSIONS                          389
+# define SSL_R_NO_PRIVATE_KEY_ASSIGNED                    190
+# define SSL_R_NO_PROTOCOLS_AVAILABLE                     191
+# define SSL_R_NO_RENEGOTIATION                           339
+# define SSL_R_NO_REQUIRED_DIGEST                         324
+# define SSL_R_NO_SHARED_CIPHER                           193
+# define SSL_R_NO_SHARED_GROUPS                           410
+# define SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS             376
+# define SSL_R_NO_SRTP_PROFILES                           359
+# define SSL_R_NO_SUITABLE_DIGEST_ALGORITHM               297
+# define SSL_R_NO_SUITABLE_GROUPS                         295
+# define SSL_R_NO_SUITABLE_KEY_SHARE                      101
+# define SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM            118
+# define SSL_R_NO_VALID_SCTS                              216
+# define SSL_R_NO_VERIFY_COOKIE_CALLBACK                  403
+# define SSL_R_NULL_SSL_CTX                               195
+# define SSL_R_NULL_SSL_METHOD_PASSED                     196
+# define SSL_R_OCSP_CALLBACK_FAILURE                      305
+# define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED            197
+# define SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED 344
+# define SSL_R_OVERFLOW_ERROR                             237
+# define SSL_R_PACKET_LENGTH_TOO_LONG                     198
+# define SSL_R_PARSE_TLSEXT                               227
+# define SSL_R_PATH_TOO_LONG                              270
+# define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE          199
+# define SSL_R_PEM_NAME_BAD_PREFIX                        391
+# define SSL_R_PEM_NAME_TOO_SHORT                         392
+# define SSL_R_PIPELINE_FAILURE                           406
+# define SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR           278
+# define SSL_R_PRIVATE_KEY_MISMATCH                       288
+# define SSL_R_PROTOCOL_IS_SHUTDOWN                       207
+# define SSL_R_PSK_IDENTITY_NOT_FOUND                     223
+# define SSL_R_PSK_NO_CLIENT_CB                           224
+# define SSL_R_PSK_NO_SERVER_CB                           225
+# define SSL_R_READ_BIO_NOT_SET                           211
+# define SSL_R_READ_TIMEOUT_EXPIRED                       312
+# define SSL_R_RECORD_LENGTH_MISMATCH                     213
+# define SSL_R_RECORD_TOO_SMALL                           298
+# define SSL_R_RENEGOTIATE_EXT_TOO_LONG                   335
+# define SSL_R_RENEGOTIATION_ENCODING_ERR                 336
+# define SSL_R_RENEGOTIATION_MISMATCH                     337
+# define SSL_R_REQUEST_PENDING                            285
+# define SSL_R_REQUEST_SENT                               286
+# define SSL_R_REQUIRED_CIPHER_MISSING                    215
+# define SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING     342
+# define SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING           345
+# define SSL_R_SCT_VERIFICATION_FAILED                    208
+# define SSL_R_SERVERHELLO_TLSEXT                         275
+# define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED           277
+# define SSL_R_SHUTDOWN_WHILE_IN_INIT                     407
+# define SSL_R_SIGNATURE_ALGORITHMS_ERROR                 360
+# define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE      220
+# define SSL_R_SRP_A_CALC                                 361
+# define SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES           362
+# define SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG      363
+# define SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE            364
+# define SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH       232
+# define SSL_R_SSL3_EXT_INVALID_SERVERNAME                319
+# define SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE           320
+# define SSL_R_SSL3_SESSION_ID_TOO_LONG                   300
+# define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE                1042
+# define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC                 1020
+# define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED            1045
+# define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED            1044
+# define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN            1046
+# define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE          1030
+# define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE              1040
+# define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER              1047
+# define SSL_R_SSLV3_ALERT_NO_CERTIFICATE                 1041
+# define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE             1010
+# define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE        1043
+# define SSL_R_SSL_COMMAND_SECTION_EMPTY                  117
+# define SSL_R_SSL_COMMAND_SECTION_NOT_FOUND              125
+# define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION         228
+# define SSL_R_SSL_HANDSHAKE_FAILURE                      229
+# define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS                 230
+# define SSL_R_SSL_NEGATIVE_LENGTH                        372
+# define SSL_R_SSL_SECTION_EMPTY                          126
+# define SSL_R_SSL_SECTION_NOT_FOUND                      136
+# define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED             301
+# define SSL_R_SSL_SESSION_ID_CONFLICT                    302
+# define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG            273
+# define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH              303
+# define SSL_R_SSL_SESSION_ID_TOO_LONG                    408
+# define SSL_R_SSL_SESSION_VERSION_MISMATCH               210
+# define SSL_R_STILL_IN_INIT                              121
+# define SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED          1116
+# define SSL_R_TLSV13_ALERT_MISSING_EXTENSION             1109
+# define SSL_R_TLSV1_ALERT_ACCESS_DENIED                  1049
+# define SSL_R_TLSV1_ALERT_DECODE_ERROR                   1050
+# define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED              1021
+# define SSL_R_TLSV1_ALERT_DECRYPT_ERROR                  1051
+# define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION             1060
+# define SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK         1086
+# define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY          1071
+# define SSL_R_TLSV1_ALERT_INTERNAL_ERROR                 1080
+# define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION               1100
+# define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION               1070
+# define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW                1022
+# define SSL_R_TLSV1_ALERT_UNKNOWN_CA                     1048
+# define SSL_R_TLSV1_ALERT_USER_CANCELLED                 1090
+# define SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE           1114
+# define SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE      1113
+# define SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE             1111
+# define SSL_R_TLSV1_UNRECOGNIZED_NAME                    1112
+# define SSL_R_TLSV1_UNSUPPORTED_EXTENSION                1110
+# define SSL_R_TLS_ILLEGAL_EXPORTER_LABEL                 367
+# define SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST             157
+# define SSL_R_TOO_MANY_KEY_UPDATES                       132
+# define SSL_R_TOO_MANY_WARN_ALERTS                       409
+# define SSL_R_TOO_MUCH_EARLY_DATA                        164
+# define SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS             314
+# define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS       239
+# define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES           242
+# define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES          243
+# define SSL_R_UNEXPECTED_CCS_MESSAGE                     262
+# define SSL_R_UNEXPECTED_END_OF_EARLY_DATA               178
+# define SSL_R_UNEXPECTED_EOF_WHILE_READING               294
+# define SSL_R_UNEXPECTED_MESSAGE                         244
+# define SSL_R_UNEXPECTED_RECORD                          245
+# define SSL_R_UNINITIALIZED                              276
+# define SSL_R_UNKNOWN_ALERT_TYPE                         246
+# define SSL_R_UNKNOWN_CERTIFICATE_TYPE                   247
+# define SSL_R_UNKNOWN_CIPHER_RETURNED                    248
+# define SSL_R_UNKNOWN_CIPHER_TYPE                        249
+# define SSL_R_UNKNOWN_CMD_NAME                           386
+# define SSL_R_UNKNOWN_COMMAND                            139
+# define SSL_R_UNKNOWN_DIGEST                             368
+# define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE                  250
+# define SSL_R_UNKNOWN_PKEY_TYPE                          251
+# define SSL_R_UNKNOWN_PROTOCOL                           252
+# define SSL_R_UNKNOWN_SSL_VERSION                        254
+# define SSL_R_UNKNOWN_STATE                              255
+# define SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED       338
+# define SSL_R_UNSOLICITED_EXTENSION                      217
+# define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM          257
+# define SSL_R_UNSUPPORTED_ELLIPTIC_CURVE                 315
+# define SSL_R_UNSUPPORTED_PROTOCOL                       258
+# define SSL_R_UNSUPPORTED_SSL_VERSION                    259
+# define SSL_R_UNSUPPORTED_STATUS_TYPE                    329
+# define SSL_R_USE_SRTP_NOT_NEGOTIATED                    369
+# define SSL_R_VERSION_TOO_HIGH                           166
+# define SSL_R_VERSION_TOO_LOW                            396
+# define SSL_R_WRONG_CERTIFICATE_TYPE                     383
+# define SSL_R_WRONG_CIPHER_RETURNED                      261
+# define SSL_R_WRONG_CURVE                                378
+# define SSL_R_WRONG_SIGNATURE_LENGTH                     264
+# define SSL_R_WRONG_SIGNATURE_SIZE                       265
+# define SSL_R_WRONG_SIGNATURE_TYPE                       370
+# define SSL_R_WRONG_SSL_VERSION                          266
+# define SSL_R_WRONG_VERSION_NUMBER                       267
+# define SSL_R_X509_LIB                                   268
+# define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS           269
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/sslerr_legacy.h b/CAPI/cpp/grpc/include/openssl/sslerr_legacy.h
new file mode 100644
index 0000000..ccf6d3b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/sslerr_legacy.h
@@ -0,0 +1,468 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*
+ * This header file preserves symbols from pre-3.0 OpenSSL.
+ * It should never be included directly, as it's already included
+ * by the public sslerr.h headers, and since it will go away some
+ * time in the future.
+ */
+
+#ifndef OPENSSL_SSLERR_LEGACY_H
+# define OPENSSL_SSLERR_LEGACY_H
+# pragma once
+
+# include <openssl/macros.h>
+# include <openssl/symhacks.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int ERR_load_SSL_strings(void);
+
+/* Collected _F_ macros from OpenSSL 1.1.1 */
+
+/*
+ * SSL function codes.
+ */
+#  define SSL_F_ADD_CLIENT_KEY_SHARE_EXT                   0
+#  define SSL_F_ADD_KEY_SHARE                              0
+#  define SSL_F_BYTES_TO_CIPHER_LIST                       0
+#  define SSL_F_CHECK_SUITEB_CIPHER_LIST                   0
+#  define SSL_F_CIPHERSUITE_CB                             0
+#  define SSL_F_CONSTRUCT_CA_NAMES                         0
+#  define SSL_F_CONSTRUCT_KEY_EXCHANGE_TBS                 0
+#  define SSL_F_CONSTRUCT_STATEFUL_TICKET                  0
+#  define SSL_F_CONSTRUCT_STATELESS_TICKET                 0
+#  define SSL_F_CREATE_SYNTHETIC_MESSAGE_HASH              0
+#  define SSL_F_CREATE_TICKET_PREQUEL                      0
+#  define SSL_F_CT_MOVE_SCTS                               0
+#  define SSL_F_CT_STRICT                                  0
+#  define SSL_F_CUSTOM_EXT_ADD                             0
+#  define SSL_F_CUSTOM_EXT_PARSE                           0
+#  define SSL_F_D2I_SSL_SESSION                            0
+#  define SSL_F_DANE_CTX_ENABLE                            0
+#  define SSL_F_DANE_MTYPE_SET                             0
+#  define SSL_F_DANE_TLSA_ADD                              0
+#  define SSL_F_DERIVE_SECRET_KEY_AND_IV                   0
+#  define SSL_F_DO_DTLS1_WRITE                             0
+#  define SSL_F_DO_SSL3_WRITE                              0
+#  define SSL_F_DTLS1_BUFFER_RECORD                        0
+#  define SSL_F_DTLS1_CHECK_TIMEOUT_NUM                    0
+#  define SSL_F_DTLS1_HEARTBEAT                            0
+#  define SSL_F_DTLS1_HM_FRAGMENT_NEW                      0
+#  define SSL_F_DTLS1_PREPROCESS_FRAGMENT                  0
+#  define SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS             0
+#  define SSL_F_DTLS1_PROCESS_RECORD                       0
+#  define SSL_F_DTLS1_READ_BYTES                           0
+#  define SSL_F_DTLS1_READ_FAILED                          0
+#  define SSL_F_DTLS1_RETRANSMIT_MESSAGE                   0
+#  define SSL_F_DTLS1_WRITE_APP_DATA_BYTES                 0
+#  define SSL_F_DTLS1_WRITE_BYTES                          0
+#  define SSL_F_DTLSV1_LISTEN                              0
+#  define SSL_F_DTLS_CONSTRUCT_CHANGE_CIPHER_SPEC          0
+#  define SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST        0
+#  define SSL_F_DTLS_GET_REASSEMBLED_MESSAGE               0
+#  define SSL_F_DTLS_PROCESS_HELLO_VERIFY                  0
+#  define SSL_F_DTLS_RECORD_LAYER_NEW                      0
+#  define SSL_F_DTLS_WAIT_FOR_DRY                          0
+#  define SSL_F_EARLY_DATA_COUNT_OK                        0
+#  define SSL_F_FINAL_EARLY_DATA                           0
+#  define SSL_F_FINAL_EC_PT_FORMATS                        0
+#  define SSL_F_FINAL_EMS                                  0
+#  define SSL_F_FINAL_KEY_SHARE                            0
+#  define SSL_F_FINAL_MAXFRAGMENTLEN                       0
+#  define SSL_F_FINAL_RENEGOTIATE                          0
+#  define SSL_F_FINAL_SERVER_NAME                          0
+#  define SSL_F_FINAL_SIG_ALGS                             0
+#  define SSL_F_GET_CERT_VERIFY_TBS_DATA                   0
+#  define SSL_F_NSS_KEYLOG_INT                             0
+#  define SSL_F_OPENSSL_INIT_SSL                           0
+#  define SSL_F_OSSL_STATEM_CLIENT13_READ_TRANSITION       0
+#  define SSL_F_OSSL_STATEM_CLIENT13_WRITE_TRANSITION      0
+#  define SSL_F_OSSL_STATEM_CLIENT_CONSTRUCT_MESSAGE       0
+#  define SSL_F_OSSL_STATEM_CLIENT_POST_PROCESS_MESSAGE    0
+#  define SSL_F_OSSL_STATEM_CLIENT_PROCESS_MESSAGE         0
+#  define SSL_F_OSSL_STATEM_CLIENT_READ_TRANSITION         0
+#  define SSL_F_OSSL_STATEM_CLIENT_WRITE_TRANSITION        0
+#  define SSL_F_OSSL_STATEM_SERVER13_READ_TRANSITION       0
+#  define SSL_F_OSSL_STATEM_SERVER13_WRITE_TRANSITION      0
+#  define SSL_F_OSSL_STATEM_SERVER_CONSTRUCT_MESSAGE       0
+#  define SSL_F_OSSL_STATEM_SERVER_POST_PROCESS_MESSAGE    0
+#  define SSL_F_OSSL_STATEM_SERVER_POST_WORK               0
+#  define SSL_F_OSSL_STATEM_SERVER_PRE_WORK                0
+#  define SSL_F_OSSL_STATEM_SERVER_PROCESS_MESSAGE         0
+#  define SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION         0
+#  define SSL_F_OSSL_STATEM_SERVER_WRITE_TRANSITION        0
+#  define SSL_F_PARSE_CA_NAMES                             0
+#  define SSL_F_PITEM_NEW                                  0
+#  define SSL_F_PQUEUE_NEW                                 0
+#  define SSL_F_PROCESS_KEY_SHARE_EXT                      0
+#  define SSL_F_READ_STATE_MACHINE                         0
+#  define SSL_F_SET_CLIENT_CIPHERSUITE                     0
+#  define SSL_F_SRP_GENERATE_CLIENT_MASTER_SECRET          0
+#  define SSL_F_SRP_GENERATE_SERVER_MASTER_SECRET          0
+#  define SSL_F_SRP_VERIFY_SERVER_PARAM                    0
+#  define SSL_F_SSL3_CHANGE_CIPHER_STATE                   0
+#  define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM              0
+#  define SSL_F_SSL3_CTRL                                  0
+#  define SSL_F_SSL3_CTX_CTRL                              0
+#  define SSL_F_SSL3_DIGEST_CACHED_RECORDS                 0
+#  define SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC                 0
+#  define SSL_F_SSL3_ENC                                   0
+#  define SSL_F_SSL3_FINAL_FINISH_MAC                      0
+#  define SSL_F_SSL3_FINISH_MAC                            0
+#  define SSL_F_SSL3_GENERATE_KEY_BLOCK                    0
+#  define SSL_F_SSL3_GENERATE_MASTER_SECRET                0
+#  define SSL_F_SSL3_GET_RECORD                            0
+#  define SSL_F_SSL3_INIT_FINISHED_MAC                     0
+#  define SSL_F_SSL3_OUTPUT_CERT_CHAIN                     0
+#  define SSL_F_SSL3_READ_BYTES                            0
+#  define SSL_F_SSL3_READ_N                                0
+#  define SSL_F_SSL3_SETUP_KEY_BLOCK                       0
+#  define SSL_F_SSL3_SETUP_READ_BUFFER                     0
+#  define SSL_F_SSL3_SETUP_WRITE_BUFFER                    0
+#  define SSL_F_SSL3_WRITE_BYTES                           0
+#  define SSL_F_SSL3_WRITE_PENDING                         0
+#  define SSL_F_SSL_ADD_CERT_CHAIN                         0
+#  define SSL_F_SSL_ADD_CERT_TO_BUF                        0
+#  define SSL_F_SSL_ADD_CERT_TO_WPACKET                    0
+#  define SSL_F_SSL_ADD_CLIENTHELLO_RENEGOTIATE_EXT        0
+#  define SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT                 0
+#  define SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT           0
+#  define SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK         0
+#  define SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK        0
+#  define SSL_F_SSL_ADD_SERVERHELLO_RENEGOTIATE_EXT        0
+#  define SSL_F_SSL_ADD_SERVERHELLO_TLSEXT                 0
+#  define SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT           0
+#  define SSL_F_SSL_BAD_METHOD                             0
+#  define SSL_F_SSL_BUILD_CERT_CHAIN                       0
+#  define SSL_F_SSL_BYTES_TO_CIPHER_LIST                   0
+#  define SSL_F_SSL_CACHE_CIPHERLIST                       0
+#  define SSL_F_SSL_CERT_ADD0_CHAIN_CERT                   0
+#  define SSL_F_SSL_CERT_DUP                               0
+#  define SSL_F_SSL_CERT_NEW                               0
+#  define SSL_F_SSL_CERT_SET0_CHAIN                        0
+#  define SSL_F_SSL_CHECK_PRIVATE_KEY                      0
+#  define SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT               0
+#  define SSL_F_SSL_CHECK_SRP_EXT_CLIENTHELLO              0
+#  define SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG            0
+#  define SSL_F_SSL_CHOOSE_CLIENT_VERSION                  0
+#  define SSL_F_SSL_CIPHER_DESCRIPTION                     0
+#  define SSL_F_SSL_CIPHER_LIST_TO_BYTES                   0
+#  define SSL_F_SSL_CIPHER_PROCESS_RULESTR                 0
+#  define SSL_F_SSL_CIPHER_STRENGTH_SORT                   0
+#  define SSL_F_SSL_CLEAR                                  0
+#  define SSL_F_SSL_CLIENT_HELLO_GET1_EXTENSIONS_PRESENT   0
+#  define SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD            0
+#  define SSL_F_SSL_CONF_CMD                               0
+#  define SSL_F_SSL_CREATE_CIPHER_LIST                     0
+#  define SSL_F_SSL_CTRL                                   0
+#  define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY                  0
+#  define SSL_F_SSL_CTX_ENABLE_CT                          0
+#  define SSL_F_SSL_CTX_MAKE_PROFILES                      0
+#  define SSL_F_SSL_CTX_NEW                                0
+#  define SSL_F_SSL_CTX_SET_ALPN_PROTOS                    0
+#  define SSL_F_SSL_CTX_SET_CIPHER_LIST                    0
+#  define SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE             0
+#  define SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK         0
+#  define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT             0
+#  define SSL_F_SSL_CTX_SET_SSL_VERSION                    0
+#  define SSL_F_SSL_CTX_SET_TLSEXT_MAX_FRAGMENT_LENGTH     0
+#  define SSL_F_SSL_CTX_USE_CERTIFICATE                    0
+#  define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1               0
+#  define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE               0
+#  define SSL_F_SSL_CTX_USE_PRIVATEKEY                     0
+#  define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1                0
+#  define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE                0
+#  define SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT              0
+#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY                  0
+#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1             0
+#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE             0
+#  define SSL_F_SSL_CTX_USE_SERVERINFO                     0
+#  define SSL_F_SSL_CTX_USE_SERVERINFO_EX                  0
+#  define SSL_F_SSL_CTX_USE_SERVERINFO_FILE                0
+#  define SSL_F_SSL_DANE_DUP                               0
+#  define SSL_F_SSL_DANE_ENABLE                            0
+#  define SSL_F_SSL_DERIVE                                 0
+#  define SSL_F_SSL_DO_CONFIG                              0
+#  define SSL_F_SSL_DO_HANDSHAKE                           0
+#  define SSL_F_SSL_DUP_CA_LIST                            0
+#  define SSL_F_SSL_ENABLE_CT                              0
+#  define SSL_F_SSL_GENERATE_PKEY_GROUP                    0
+#  define SSL_F_SSL_GENERATE_SESSION_ID                    0
+#  define SSL_F_SSL_GET_NEW_SESSION                        0
+#  define SSL_F_SSL_GET_PREV_SESSION                       0
+#  define SSL_F_SSL_GET_SERVER_CERT_INDEX                  0
+#  define SSL_F_SSL_GET_SIGN_PKEY                          0
+#  define SSL_F_SSL_HANDSHAKE_HASH                         0
+#  define SSL_F_SSL_INIT_WBIO_BUFFER                       0
+#  define SSL_F_SSL_KEY_UPDATE                             0
+#  define SSL_F_SSL_LOAD_CLIENT_CA_FILE                    0
+#  define SSL_F_SSL_LOG_MASTER_SECRET                      0
+#  define SSL_F_SSL_LOG_RSA_CLIENT_KEY_EXCHANGE            0
+#  define SSL_F_SSL_MODULE_INIT                            0
+#  define SSL_F_SSL_NEW                                    0
+#  define SSL_F_SSL_NEXT_PROTO_VALIDATE                    0
+#  define SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT      0
+#  define SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT               0
+#  define SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT         0
+#  define SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT      0
+#  define SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT               0
+#  define SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT         0
+#  define SSL_F_SSL_PEEK                                   0
+#  define SSL_F_SSL_PEEK_EX                                0
+#  define SSL_F_SSL_PEEK_INTERNAL                          0
+#  define SSL_F_SSL_READ                                   0
+#  define SSL_F_SSL_READ_EARLY_DATA                        0
+#  define SSL_F_SSL_READ_EX                                0
+#  define SSL_F_SSL_READ_INTERNAL                          0
+#  define SSL_F_SSL_RENEGOTIATE                            0
+#  define SSL_F_SSL_RENEGOTIATE_ABBREVIATED                0
+#  define SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT                0
+#  define SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT                0
+#  define SSL_F_SSL_SESSION_DUP                            0
+#  define SSL_F_SSL_SESSION_NEW                            0
+#  define SSL_F_SSL_SESSION_PRINT_FP                       0
+#  define SSL_F_SSL_SESSION_SET1_ID                        0
+#  define SSL_F_SSL_SESSION_SET1_ID_CONTEXT                0
+#  define SSL_F_SSL_SET_ALPN_PROTOS                        0
+#  define SSL_F_SSL_SET_CERT                               0
+#  define SSL_F_SSL_SET_CERT_AND_KEY                       0
+#  define SSL_F_SSL_SET_CIPHER_LIST                        0
+#  define SSL_F_SSL_SET_CT_VALIDATION_CALLBACK             0
+#  define SSL_F_SSL_SET_FD                                 0
+#  define SSL_F_SSL_SET_PKEY                               0
+#  define SSL_F_SSL_SET_RFD                                0
+#  define SSL_F_SSL_SET_SESSION                            0
+#  define SSL_F_SSL_SET_SESSION_ID_CONTEXT                 0
+#  define SSL_F_SSL_SET_SESSION_TICKET_EXT                 0
+#  define SSL_F_SSL_SET_TLSEXT_MAX_FRAGMENT_LENGTH         0
+#  define SSL_F_SSL_SET_WFD                                0
+#  define SSL_F_SSL_SHUTDOWN                               0
+#  define SSL_F_SSL_SRP_CTX_INIT                           0
+#  define SSL_F_SSL_START_ASYNC_JOB                        0
+#  define SSL_F_SSL_UNDEFINED_FUNCTION                     0
+#  define SSL_F_SSL_UNDEFINED_VOID_FUNCTION                0
+#  define SSL_F_SSL_USE_CERTIFICATE                        0
+#  define SSL_F_SSL_USE_CERTIFICATE_ASN1                   0
+#  define SSL_F_SSL_USE_CERTIFICATE_FILE                   0
+#  define SSL_F_SSL_USE_PRIVATEKEY                         0
+#  define SSL_F_SSL_USE_PRIVATEKEY_ASN1                    0
+#  define SSL_F_SSL_USE_PRIVATEKEY_FILE                    0
+#  define SSL_F_SSL_USE_PSK_IDENTITY_HINT                  0
+#  define SSL_F_SSL_USE_RSAPRIVATEKEY                      0
+#  define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1                 0
+#  define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE                 0
+#  define SSL_F_SSL_VALIDATE_CT                            0
+#  define SSL_F_SSL_VERIFY_CERT_CHAIN                      0
+#  define SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE           0
+#  define SSL_F_SSL_WRITE                                  0
+#  define SSL_F_SSL_WRITE_EARLY_DATA                       0
+#  define SSL_F_SSL_WRITE_EARLY_FINISH                     0
+#  define SSL_F_SSL_WRITE_EX                               0
+#  define SSL_F_SSL_WRITE_INTERNAL                         0
+#  define SSL_F_STATE_MACHINE                              0
+#  define SSL_F_TLS12_CHECK_PEER_SIGALG                    0
+#  define SSL_F_TLS12_COPY_SIGALGS                         0
+#  define SSL_F_TLS13_CHANGE_CIPHER_STATE                  0
+#  define SSL_F_TLS13_ENC                                  0
+#  define SSL_F_TLS13_FINAL_FINISH_MAC                     0
+#  define SSL_F_TLS13_GENERATE_SECRET                      0
+#  define SSL_F_TLS13_HKDF_EXPAND                          0
+#  define SSL_F_TLS13_RESTORE_HANDSHAKE_DIGEST_FOR_PHA     0
+#  define SSL_F_TLS13_SAVE_HANDSHAKE_DIGEST_FOR_PHA        0
+#  define SSL_F_TLS13_SETUP_KEY_BLOCK                      0
+#  define SSL_F_TLS1_CHANGE_CIPHER_STATE                   0
+#  define SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS            0
+#  define SSL_F_TLS1_ENC                                   0
+#  define SSL_F_TLS1_EXPORT_KEYING_MATERIAL                0
+#  define SSL_F_TLS1_GET_CURVELIST                         0
+#  define SSL_F_TLS1_PRF                                   0
+#  define SSL_F_TLS1_SAVE_U16                              0
+#  define SSL_F_TLS1_SETUP_KEY_BLOCK                       0
+#  define SSL_F_TLS1_SET_GROUPS                            0
+#  define SSL_F_TLS1_SET_RAW_SIGALGS                       0
+#  define SSL_F_TLS1_SET_SERVER_SIGALGS                    0
+#  define SSL_F_TLS1_SET_SHARED_SIGALGS                    0
+#  define SSL_F_TLS1_SET_SIGALGS                           0
+#  define SSL_F_TLS_CHOOSE_SIGALG                          0
+#  define SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK          0
+#  define SSL_F_TLS_COLLECT_EXTENSIONS                     0
+#  define SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES      0
+#  define SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST          0
+#  define SSL_F_TLS_CONSTRUCT_CERT_STATUS                  0
+#  define SSL_F_TLS_CONSTRUCT_CERT_STATUS_BODY             0
+#  define SSL_F_TLS_CONSTRUCT_CERT_VERIFY                  0
+#  define SSL_F_TLS_CONSTRUCT_CHANGE_CIPHER_SPEC           0
+#  define SSL_F_TLS_CONSTRUCT_CKE_DHE                      0
+#  define SSL_F_TLS_CONSTRUCT_CKE_ECDHE                    0
+#  define SSL_F_TLS_CONSTRUCT_CKE_GOST                     0
+#  define SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE             0
+#  define SSL_F_TLS_CONSTRUCT_CKE_RSA                      0
+#  define SSL_F_TLS_CONSTRUCT_CKE_SRP                      0
+#  define SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE           0
+#  define SSL_F_TLS_CONSTRUCT_CLIENT_HELLO                 0
+#  define SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE          0
+#  define SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY                0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_ALPN                    0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_CERTIFICATE             0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_COOKIE                  0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA              0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_EC_PT_FORMATS           0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_EMS                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_ETM                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_HELLO                   0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_KEY_EXCHANGE            0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE               0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_MAXFRAGMENTLEN          0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_NPN                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_PADDING                 0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_POST_HANDSHAKE_AUTH     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_PSK                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_PSK_KEX_MODES           0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_RENEGOTIATE             0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SCT                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SERVER_NAME             0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET          0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SIG_ALGS                0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SRP                     0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST          0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS        0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS      0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP                0
+#  define SSL_F_TLS_CONSTRUCT_CTOS_VERIFY                  0
+#  define SSL_F_TLS_CONSTRUCT_ENCRYPTED_EXTENSIONS         0
+#  define SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA            0
+#  define SSL_F_TLS_CONSTRUCT_EXTENSIONS                   0
+#  define SSL_F_TLS_CONSTRUCT_FINISHED                     0
+#  define SSL_F_TLS_CONSTRUCT_HELLO_REQUEST                0
+#  define SSL_F_TLS_CONSTRUCT_HELLO_RETRY_REQUEST          0
+#  define SSL_F_TLS_CONSTRUCT_KEY_UPDATE                   0
+#  define SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET           0
+#  define SSL_F_TLS_CONSTRUCT_NEXT_PROTO                   0
+#  define SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE           0
+#  define SSL_F_TLS_CONSTRUCT_SERVER_HELLO                 0
+#  define SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_ALPN                    0
+#  define SSL_F_TLS_CONSTRUCT_STOC_CERTIFICATE             0
+#  define SSL_F_TLS_CONSTRUCT_STOC_COOKIE                  0
+#  define SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG           0
+#  define SSL_F_TLS_CONSTRUCT_STOC_DONE                    0
+#  define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA              0
+#  define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA_INFO         0
+#  define SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS           0
+#  define SSL_F_TLS_CONSTRUCT_STOC_EMS                     0
+#  define SSL_F_TLS_CONSTRUCT_STOC_ETM                     0
+#  define SSL_F_TLS_CONSTRUCT_STOC_HELLO                   0
+#  define SSL_F_TLS_CONSTRUCT_STOC_KEY_EXCHANGE            0
+#  define SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE               0
+#  define SSL_F_TLS_CONSTRUCT_STOC_MAXFRAGMENTLEN          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_PSK                     0
+#  define SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE             0
+#  define SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME             0
+#  define SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST          0
+#  define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS        0
+#  define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_VERSIONS      0
+#  define SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP                0
+#  define SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO        0
+#  define SSL_F_TLS_FINISH_HANDSHAKE                       0
+#  define SSL_F_TLS_GET_MESSAGE_BODY                       0
+#  define SSL_F_TLS_GET_MESSAGE_HEADER                     0
+#  define SSL_F_TLS_HANDLE_ALPN                            0
+#  define SSL_F_TLS_HANDLE_STATUS_REQUEST                  0
+#  define SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES          0
+#  define SSL_F_TLS_PARSE_CLIENTHELLO_TLSEXT               0
+#  define SSL_F_TLS_PARSE_CTOS_ALPN                        0
+#  define SSL_F_TLS_PARSE_CTOS_COOKIE                      0
+#  define SSL_F_TLS_PARSE_CTOS_EARLY_DATA                  0
+#  define SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS               0
+#  define SSL_F_TLS_PARSE_CTOS_EMS                         0
+#  define SSL_F_TLS_PARSE_CTOS_KEY_SHARE                   0
+#  define SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN              0
+#  define SSL_F_TLS_PARSE_CTOS_POST_HANDSHAKE_AUTH         0
+#  define SSL_F_TLS_PARSE_CTOS_PSK                         0
+#  define SSL_F_TLS_PARSE_CTOS_PSK_KEX_MODES               0
+#  define SSL_F_TLS_PARSE_CTOS_RENEGOTIATE                 0
+#  define SSL_F_TLS_PARSE_CTOS_SERVER_NAME                 0
+#  define SSL_F_TLS_PARSE_CTOS_SESSION_TICKET              0
+#  define SSL_F_TLS_PARSE_CTOS_SIG_ALGS                    0
+#  define SSL_F_TLS_PARSE_CTOS_SIG_ALGS_CERT               0
+#  define SSL_F_TLS_PARSE_CTOS_SRP                         0
+#  define SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST              0
+#  define SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS            0
+#  define SSL_F_TLS_PARSE_CTOS_USE_SRTP                    0
+#  define SSL_F_TLS_PARSE_STOC_ALPN                        0
+#  define SSL_F_TLS_PARSE_STOC_COOKIE                      0
+#  define SSL_F_TLS_PARSE_STOC_EARLY_DATA                  0
+#  define SSL_F_TLS_PARSE_STOC_EARLY_DATA_INFO             0
+#  define SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS               0
+#  define SSL_F_TLS_PARSE_STOC_KEY_SHARE                   0
+#  define SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN              0
+#  define SSL_F_TLS_PARSE_STOC_NPN                         0
+#  define SSL_F_TLS_PARSE_STOC_PSK                         0
+#  define SSL_F_TLS_PARSE_STOC_RENEGOTIATE                 0
+#  define SSL_F_TLS_PARSE_STOC_SCT                         0
+#  define SSL_F_TLS_PARSE_STOC_SERVER_NAME                 0
+#  define SSL_F_TLS_PARSE_STOC_SESSION_TICKET              0
+#  define SSL_F_TLS_PARSE_STOC_STATUS_REQUEST              0
+#  define SSL_F_TLS_PARSE_STOC_SUPPORTED_VERSIONS          0
+#  define SSL_F_TLS_PARSE_STOC_USE_SRTP                    0
+#  define SSL_F_TLS_POST_PROCESS_CLIENT_HELLO              0
+#  define SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE       0
+#  define SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE             0
+#  define SSL_F_TLS_PROCESS_AS_HELLO_RETRY_REQUEST         0
+#  define SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST            0
+#  define SSL_F_TLS_PROCESS_CERT_STATUS                    0
+#  define SSL_F_TLS_PROCESS_CERT_STATUS_BODY               0
+#  define SSL_F_TLS_PROCESS_CERT_VERIFY                    0
+#  define SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC             0
+#  define SSL_F_TLS_PROCESS_CKE_DHE                        0
+#  define SSL_F_TLS_PROCESS_CKE_ECDHE                      0
+#  define SSL_F_TLS_PROCESS_CKE_GOST                       0
+#  define SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE               0
+#  define SSL_F_TLS_PROCESS_CKE_RSA                        0
+#  define SSL_F_TLS_PROCESS_CKE_SRP                        0
+#  define SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE             0
+#  define SSL_F_TLS_PROCESS_CLIENT_HELLO                   0
+#  define SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE            0
+#  define SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS           0
+#  define SSL_F_TLS_PROCESS_END_OF_EARLY_DATA              0
+#  define SSL_F_TLS_PROCESS_FINISHED                       0
+#  define SSL_F_TLS_PROCESS_HELLO_REQ                      0
+#  define SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST            0
+#  define SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT          0
+#  define SSL_F_TLS_PROCESS_KEY_EXCHANGE                   0
+#  define SSL_F_TLS_PROCESS_KEY_UPDATE                     0
+#  define SSL_F_TLS_PROCESS_NEW_SESSION_TICKET             0
+#  define SSL_F_TLS_PROCESS_NEXT_PROTO                     0
+#  define SSL_F_TLS_PROCESS_SERVER_CERTIFICATE             0
+#  define SSL_F_TLS_PROCESS_SERVER_DONE                    0
+#  define SSL_F_TLS_PROCESS_SERVER_HELLO                   0
+#  define SSL_F_TLS_PROCESS_SKE_DHE                        0
+#  define SSL_F_TLS_PROCESS_SKE_ECDHE                      0
+#  define SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE               0
+#  define SSL_F_TLS_PROCESS_SKE_SRP                        0
+#  define SSL_F_TLS_PSK_DO_BINDER                          0
+#  define SSL_F_TLS_SCAN_CLIENTHELLO_TLSEXT                0
+#  define SSL_F_TLS_SETUP_HANDSHAKE                        0
+#  define SSL_F_USE_CERTIFICATE_CHAIN_FILE                 0
+#  define SSL_F_WPACKET_INTERN_INIT_LEN                    0
+#  define SSL_F_WPACKET_START_SUB_PACKET_LEN__             0
+#  define SSL_F_WRITE_STATE_MACHINE                        0
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/stack.h b/CAPI/cpp/grpc/include/openssl/stack.h
new file mode 100644
index 0000000..f0c5c54
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/stack.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_STACK_H
+# define OPENSSL_STACK_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_STACK_H
+# endif
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct stack_st OPENSSL_STACK; /* Use STACK_OF(...) instead */
+
+typedef int (*OPENSSL_sk_compfunc)(const void *, const void *);
+typedef void (*OPENSSL_sk_freefunc)(void *);
+typedef void *(*OPENSSL_sk_copyfunc)(const void *);
+
+int OPENSSL_sk_num(const OPENSSL_STACK *);
+void *OPENSSL_sk_value(const OPENSSL_STACK *, int);
+
+void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data);
+
+OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp);
+OPENSSL_STACK *OPENSSL_sk_new_null(void);
+OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n);
+int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n);
+void OPENSSL_sk_free(OPENSSL_STACK *);
+void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *));
+OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *,
+                                    OPENSSL_sk_copyfunc c,
+                                    OPENSSL_sk_freefunc f);
+int OPENSSL_sk_insert(OPENSSL_STACK *sk, const void *data, int where);
+void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc);
+void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p);
+int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data);
+int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data);
+int OPENSSL_sk_find_all(OPENSSL_STACK *st, const void *data, int *pnum);
+int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data);
+int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data);
+void *OPENSSL_sk_shift(OPENSSL_STACK *st);
+void *OPENSSL_sk_pop(OPENSSL_STACK *st);
+void OPENSSL_sk_zero(OPENSSL_STACK *st);
+OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk,
+                                            OPENSSL_sk_compfunc cmp);
+OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *st);
+void OPENSSL_sk_sort(OPENSSL_STACK *st);
+int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define _STACK OPENSSL_STACK
+#  define sk_num OPENSSL_sk_num
+#  define sk_value OPENSSL_sk_value
+#  define sk_set OPENSSL_sk_set
+#  define sk_new OPENSSL_sk_new
+#  define sk_new_null OPENSSL_sk_new_null
+#  define sk_free OPENSSL_sk_free
+#  define sk_pop_free OPENSSL_sk_pop_free
+#  define sk_deep_copy OPENSSL_sk_deep_copy
+#  define sk_insert OPENSSL_sk_insert
+#  define sk_delete OPENSSL_sk_delete
+#  define sk_delete_ptr OPENSSL_sk_delete_ptr
+#  define sk_find OPENSSL_sk_find
+#  define sk_find_ex OPENSSL_sk_find_ex
+#  define sk_push OPENSSL_sk_push
+#  define sk_unshift OPENSSL_sk_unshift
+#  define sk_shift OPENSSL_sk_shift
+#  define sk_pop OPENSSL_sk_pop
+#  define sk_zero OPENSSL_sk_zero
+#  define sk_set_cmp_func OPENSSL_sk_set_cmp_func
+#  define sk_dup OPENSSL_sk_dup
+#  define sk_sort OPENSSL_sk_sort
+#  define sk_is_sorted OPENSSL_sk_is_sorted
+# endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/store.h b/CAPI/cpp/grpc/include/openssl/store.h
new file mode 100644
index 0000000..3c1445e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/store.h
@@ -0,0 +1,369 @@
+/*
+ * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_STORE_H
+# define OPENSSL_STORE_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OSSL_STORE_H
+# endif
+
+# include <stdarg.h>
+# include <openssl/types.h>
+# include <openssl/pem.h>
+# include <openssl/storeerr.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*-
+ *  The main OSSL_STORE functions.
+ *  ------------------------------
+ *
+ *  These allow applications to open a channel to a resource with supported
+ *  data (keys, certs, crls, ...), read the data a piece at a time and decide
+ *  what to do with it, and finally close.
+ */
+
+typedef struct ossl_store_ctx_st OSSL_STORE_CTX;
+
+/*
+ * Typedef for the OSSL_STORE_INFO post processing callback.  This can be used
+ * to massage the given OSSL_STORE_INFO, or to drop it entirely (by returning
+ * NULL).
+ */
+typedef OSSL_STORE_INFO *(*OSSL_STORE_post_process_info_fn)(OSSL_STORE_INFO *,
+                                                            void *);
+
+/*
+ * Open a channel given a URI.  The given UI method will be used any time the
+ * loader needs extra input, for example when a password or pin is needed, and
+ * will be passed the same user data every time it's needed in this context.
+ *
+ * Returns a context reference which represents the channel to communicate
+ * through.
+ */
+OSSL_STORE_CTX *
+OSSL_STORE_open(const char *uri, const UI_METHOD *ui_method, void *ui_data,
+                OSSL_STORE_post_process_info_fn post_process,
+                void *post_process_data);
+OSSL_STORE_CTX *
+OSSL_STORE_open_ex(const char *uri, OSSL_LIB_CTX *libctx, const char *propq,
+                   const UI_METHOD *ui_method, void *ui_data,
+                   const OSSL_PARAM params[],
+                   OSSL_STORE_post_process_info_fn post_process,
+                   void *post_process_data);
+
+/*
+ * Control / fine tune the OSSL_STORE channel.  |cmd| determines what is to be
+ * done, and depends on the underlying loader (use OSSL_STORE_get0_scheme to
+ * determine which loader is used), except for common commands (see below).
+ * Each command takes different arguments.
+ */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int OSSL_STORE_ctrl(OSSL_STORE_CTX *ctx, int cmd,
+                                          ... /* args */);
+OSSL_DEPRECATEDIN_3_0 int OSSL_STORE_vctrl(OSSL_STORE_CTX *ctx, int cmd,
+                                           va_list args);
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+/*
+ * Common ctrl commands that different loaders may choose to support.
+ */
+/* int on = 0 or 1; STORE_ctrl(ctx, STORE_C_USE_SECMEM, &on); */
+# define OSSL_STORE_C_USE_SECMEM      1
+/* Where custom commands start */
+# define OSSL_STORE_C_CUSTOM_START    100
+
+# endif
+
+/*
+ * Read one data item (a key, a cert, a CRL) that is supported by the OSSL_STORE
+ * functionality, given a context.
+ * Returns a OSSL_STORE_INFO pointer, from which OpenSSL typed data can be
+ * extracted with OSSL_STORE_INFO_get0_PKEY(), OSSL_STORE_INFO_get0_CERT(), ...
+ * NULL is returned on error, which may include that the data found at the URI
+ * can't be figured out for certain or is ambiguous.
+ */
+OSSL_STORE_INFO *OSSL_STORE_load(OSSL_STORE_CTX *ctx);
+
+/*
+ * Check if end of data (end of file) is reached
+ * Returns 1 on end, 0 otherwise.
+ */
+int OSSL_STORE_eof(OSSL_STORE_CTX *ctx);
+
+/*
+ * Check if an error occurred
+ * Returns 1 if it did, 0 otherwise.
+ */
+int OSSL_STORE_error(OSSL_STORE_CTX *ctx);
+
+/*
+ * Close the channel
+ * Returns 1 on success, 0 on error.
+ */
+int OSSL_STORE_close(OSSL_STORE_CTX *ctx);
+
+/*
+ * Attach to a BIO.  This works like OSSL_STORE_open() except it takes a
+ * BIO instead of a uri, along with a scheme to use when reading.
+ * The given UI method will be used any time the loader needs extra input,
+ * for example when a password or pin is needed, and will be passed the
+ * same user data every time it's needed in this context.
+ *
+ * Returns a context reference which represents the channel to communicate
+ * through.
+ *
+ * Note that this function is considered unsafe, all depending on what the
+ * BIO actually reads.
+ */
+OSSL_STORE_CTX *OSSL_STORE_attach(BIO *bio, const char *scheme,
+                                  OSSL_LIB_CTX *libctx, const char *propq,
+                                  const UI_METHOD *ui_method, void *ui_data,
+                                  const OSSL_PARAM params[],
+                                  OSSL_STORE_post_process_info_fn post_process,
+                                  void *post_process_data);
+
+/*-
+ *  Extracting OpenSSL types from and creating new OSSL_STORE_INFOs
+ *  ---------------------------------------------------------------
+ */
+
+/*
+ * Types of data that can be ossl_stored in a OSSL_STORE_INFO.
+ * OSSL_STORE_INFO_NAME is typically found when getting a listing of
+ * available "files" / "tokens" / what have you.
+ */
+# define OSSL_STORE_INFO_NAME           1   /* char * */
+# define OSSL_STORE_INFO_PARAMS         2   /* EVP_PKEY * */
+# define OSSL_STORE_INFO_PUBKEY         3   /* EVP_PKEY * */
+# define OSSL_STORE_INFO_PKEY           4   /* EVP_PKEY * */
+# define OSSL_STORE_INFO_CERT           5   /* X509 * */
+# define OSSL_STORE_INFO_CRL            6   /* X509_CRL * */
+
+/*
+ * Functions to generate OSSL_STORE_INFOs, one function for each type we
+ * support having in them, as well as a generic constructor.
+ *
+ * In all cases, ownership of the object is transferred to the OSSL_STORE_INFO
+ * and will therefore be freed when the OSSL_STORE_INFO is freed.
+ */
+OSSL_STORE_INFO *OSSL_STORE_INFO_new(int type, void *data);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_NAME(char *name);
+int OSSL_STORE_INFO_set0_NAME_description(OSSL_STORE_INFO *info, char *desc);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_PARAMS(EVP_PKEY *params);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_PUBKEY(EVP_PKEY *pubkey);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_PKEY(EVP_PKEY *pkey);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_CERT(X509 *x509);
+OSSL_STORE_INFO *OSSL_STORE_INFO_new_CRL(X509_CRL *crl);
+
+/*
+ * Functions to try to extract data from a OSSL_STORE_INFO.
+ */
+int OSSL_STORE_INFO_get_type(const OSSL_STORE_INFO *info);
+void *OSSL_STORE_INFO_get0_data(int type, const OSSL_STORE_INFO *info);
+const char *OSSL_STORE_INFO_get0_NAME(const OSSL_STORE_INFO *info);
+char *OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO *info);
+const char *OSSL_STORE_INFO_get0_NAME_description(const OSSL_STORE_INFO *info);
+char *OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get0_PARAMS(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get1_PARAMS(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get0_PUBKEY(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get1_PUBKEY(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get0_PKEY(const OSSL_STORE_INFO *info);
+EVP_PKEY *OSSL_STORE_INFO_get1_PKEY(const OSSL_STORE_INFO *info);
+X509 *OSSL_STORE_INFO_get0_CERT(const OSSL_STORE_INFO *info);
+X509 *OSSL_STORE_INFO_get1_CERT(const OSSL_STORE_INFO *info);
+X509_CRL *OSSL_STORE_INFO_get0_CRL(const OSSL_STORE_INFO *info);
+X509_CRL *OSSL_STORE_INFO_get1_CRL(const OSSL_STORE_INFO *info);
+
+const char *OSSL_STORE_INFO_type_string(int type);
+
+/*
+ * Free the OSSL_STORE_INFO
+ */
+void OSSL_STORE_INFO_free(OSSL_STORE_INFO *info);
+
+
+/*-
+ *  Functions to construct a search URI from a base URI and search criteria
+ *  -----------------------------------------------------------------------
+ */
+
+/* OSSL_STORE search types */
+# define OSSL_STORE_SEARCH_BY_NAME              1 /* subject in certs, issuer in CRLs */
+# define OSSL_STORE_SEARCH_BY_ISSUER_SERIAL     2
+# define OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT   3
+# define OSSL_STORE_SEARCH_BY_ALIAS             4
+
+/* To check what search types the scheme handler supports */
+int OSSL_STORE_supports_search(OSSL_STORE_CTX *ctx, int search_type);
+
+/* Search term constructors */
+/*
+ * The input is considered to be owned by the caller, and must therefore
+ * remain present throughout the lifetime of the returned OSSL_STORE_SEARCH
+ */
+OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_name(X509_NAME *name);
+OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_issuer_serial(X509_NAME *name,
+                                                      const ASN1_INTEGER
+                                                      *serial);
+OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_key_fingerprint(const EVP_MD *digest,
+                                                        const unsigned char
+                                                        *bytes, size_t len);
+OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_alias(const char *alias);
+
+/* Search term destructor */
+void OSSL_STORE_SEARCH_free(OSSL_STORE_SEARCH *search);
+
+/* Search term accessors */
+int OSSL_STORE_SEARCH_get_type(const OSSL_STORE_SEARCH *criterion);
+X509_NAME *OSSL_STORE_SEARCH_get0_name(const OSSL_STORE_SEARCH *criterion);
+const ASN1_INTEGER *OSSL_STORE_SEARCH_get0_serial(const OSSL_STORE_SEARCH
+                                                  *criterion);
+const unsigned char *OSSL_STORE_SEARCH_get0_bytes(const OSSL_STORE_SEARCH
+                                                  *criterion, size_t *length);
+const char *OSSL_STORE_SEARCH_get0_string(const OSSL_STORE_SEARCH *criterion);
+const EVP_MD *OSSL_STORE_SEARCH_get0_digest(const OSSL_STORE_SEARCH *criterion);
+
+/*
+ * Add search criterion and expected return type (which can be unspecified)
+ * to the loading channel.  This MUST happen before the first OSSL_STORE_load().
+ */
+int OSSL_STORE_expect(OSSL_STORE_CTX *ctx, int expected_type);
+int OSSL_STORE_find(OSSL_STORE_CTX *ctx, const OSSL_STORE_SEARCH *search);
+
+
+/*-
+ *  Function to fetch a loader and extract data from it
+ *  ---------------------------------------------------
+ */
+
+typedef struct ossl_store_loader_st OSSL_STORE_LOADER;
+
+OSSL_STORE_LOADER *OSSL_STORE_LOADER_fetch(OSSL_LIB_CTX *libctx,
+                                           const char *scheme,
+                                           const char *properties);
+int OSSL_STORE_LOADER_up_ref(OSSL_STORE_LOADER *loader);
+void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader);
+const OSSL_PROVIDER *OSSL_STORE_LOADER_get0_provider(const OSSL_STORE_LOADER *
+                                                loader);
+const char *OSSL_STORE_LOADER_get0_properties(const OSSL_STORE_LOADER *loader);
+const char *OSSL_STORE_LOADER_get0_description(const OSSL_STORE_LOADER *loader);
+int OSSL_STORE_LOADER_is_a(const OSSL_STORE_LOADER *loader,
+                           const char *scheme);
+void OSSL_STORE_LOADER_do_all_provided(OSSL_LIB_CTX *libctx,
+                                       void (*fn)(OSSL_STORE_LOADER *loader,
+                                                  void *arg),
+                                       void *arg);
+int OSSL_STORE_LOADER_names_do_all(const OSSL_STORE_LOADER *loader,
+                                   void (*fn)(const char *name, void *data),
+                                   void *data);
+
+/*-
+ *  Function to register a loader for the given URI scheme.
+ *  -------------------------------------------------------
+ *
+ *  The loader receives all the main components of an URI except for the
+ *  scheme.
+ */
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+/* struct ossl_store_loader_ctx_st is defined differently by each loader */
+typedef struct ossl_store_loader_ctx_st OSSL_STORE_LOADER_CTX;
+typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_open_fn)
+    (const OSSL_STORE_LOADER *loader, const char *uri,
+     const UI_METHOD *ui_method, void *ui_data);
+typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_open_ex_fn)
+    (const OSSL_STORE_LOADER *loader,
+     const char *uri, OSSL_LIB_CTX *libctx, const char *propq,
+     const UI_METHOD *ui_method, void *ui_data);
+
+typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_attach_fn)
+    (const OSSL_STORE_LOADER *loader, BIO *bio,
+     OSSL_LIB_CTX *libctx, const char *propq,
+     const UI_METHOD *ui_method, void *ui_data);
+typedef int (*OSSL_STORE_ctrl_fn)
+    (OSSL_STORE_LOADER_CTX *ctx, int cmd, va_list args);
+typedef int (*OSSL_STORE_expect_fn)
+    (OSSL_STORE_LOADER_CTX *ctx, int expected);
+typedef int (*OSSL_STORE_find_fn)
+    (OSSL_STORE_LOADER_CTX *ctx, const OSSL_STORE_SEARCH *criteria);
+typedef OSSL_STORE_INFO *(*OSSL_STORE_load_fn)
+    (OSSL_STORE_LOADER_CTX *ctx, const UI_METHOD *ui_method, void *ui_data);
+typedef int (*OSSL_STORE_eof_fn)(OSSL_STORE_LOADER_CTX *ctx);
+typedef int (*OSSL_STORE_error_fn)(OSSL_STORE_LOADER_CTX *ctx);
+typedef int (*OSSL_STORE_close_fn)(OSSL_STORE_LOADER_CTX *ctx);
+
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader,
+                               OSSL_STORE_open_fn open_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_open_ex(OSSL_STORE_LOADER *loader,
+                                  OSSL_STORE_open_ex_fn open_ex_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_attach(OSSL_STORE_LOADER *loader,
+                                 OSSL_STORE_attach_fn attach_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader,
+                               OSSL_STORE_ctrl_fn ctrl_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader,
+                                 OSSL_STORE_expect_fn expect_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader,
+                               OSSL_STORE_find_fn find_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader,
+                               OSSL_STORE_load_fn load_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader,
+                              OSSL_STORE_eof_fn eof_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader,
+                                OSSL_STORE_error_fn error_function);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader,
+                                OSSL_STORE_close_fn close_function);
+OSSL_DEPRECATEDIN_3_0
+const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader);
+OSSL_DEPRECATEDIN_3_0
+const char * OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader);
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader);
+OSSL_DEPRECATEDIN_3_0
+OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme);
+# endif
+
+/*-
+ *  Functions to list STORE loaders
+ *  -------------------------------
+ */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int OSSL_STORE_do_all_loaders(void (*do_function)(const OSSL_STORE_LOADER *loader,
+                                                  void *do_arg),
+                              void *do_arg);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/storeerr.h b/CAPI/cpp/grpc/include/openssl/storeerr.h
new file mode 100644
index 0000000..00529c8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/storeerr.h
@@ -0,0 +1,49 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_STOREERR_H
+# define OPENSSL_STOREERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * OSSL_STORE reason codes.
+ */
+# define OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE              107
+# define OSSL_STORE_R_BAD_PASSWORD_READ                   115
+# define OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC          113
+# define OSSL_STORE_R_FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST 121
+# define OSSL_STORE_R_INVALID_SCHEME                      106
+# define OSSL_STORE_R_IS_NOT_A                            112
+# define OSSL_STORE_R_LOADER_INCOMPLETE                   116
+# define OSSL_STORE_R_LOADING_STARTED                     117
+# define OSSL_STORE_R_NOT_A_CERTIFICATE                   100
+# define OSSL_STORE_R_NOT_A_CRL                           101
+# define OSSL_STORE_R_NOT_A_NAME                          103
+# define OSSL_STORE_R_NOT_A_PRIVATE_KEY                   102
+# define OSSL_STORE_R_NOT_A_PUBLIC_KEY                    122
+# define OSSL_STORE_R_NOT_PARAMETERS                      104
+# define OSSL_STORE_R_NO_LOADERS_FOUND                    123
+# define OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR           114
+# define OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE               108
+# define OSSL_STORE_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES 119
+# define OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED 109
+# define OSSL_STORE_R_UNREGISTERED_SCHEME                 105
+# define OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE            110
+# define OSSL_STORE_R_UNSUPPORTED_OPERATION               118
+# define OSSL_STORE_R_UNSUPPORTED_SEARCH_TYPE             120
+# define OSSL_STORE_R_URI_AUTHORITY_UNSUPPORTED           111
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/symhacks.h b/CAPI/cpp/grpc/include/openssl/symhacks.h
new file mode 100644
index 0000000..816f8f9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/symhacks.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_SYMHACKS_H
+# define OPENSSL_SYMHACKS_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SYMHACKS_H
+# endif
+
+# include <openssl/e_os2.h>
+
+/* Case insensitive linking causes problems.... */
+# if defined(OPENSSL_SYS_VMS)
+#  undef ERR_load_CRYPTO_strings
+#  define ERR_load_CRYPTO_strings                 ERR_load_CRYPTOlib_strings
+#  undef OCSP_crlID_new
+#  define OCSP_crlID_new                          OCSP_crlID2_new
+
+#  undef d2i_ECPARAMETERS
+#  define d2i_ECPARAMETERS                        d2i_UC_ECPARAMETERS
+#  undef i2d_ECPARAMETERS
+#  define i2d_ECPARAMETERS                        i2d_UC_ECPARAMETERS
+#  undef d2i_ECPKPARAMETERS
+#  define d2i_ECPKPARAMETERS                      d2i_UC_ECPKPARAMETERS
+#  undef i2d_ECPKPARAMETERS
+#  define i2d_ECPKPARAMETERS                      i2d_UC_ECPKPARAMETERS
+
+# endif
+
+#endif                          /* ! defined HEADER_VMS_IDHACKS_H */
diff --git a/CAPI/cpp/grpc/include/openssl/tls1.h b/CAPI/cpp/grpc/include/openssl/tls1.h
new file mode 100644
index 0000000..d6e9331
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/tls1.h
@@ -0,0 +1,1223 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ * Copyright 2005 Nokia. All rights reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TLS1_H
+# define OPENSSL_TLS1_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_TLS1_H
+# endif
+
+# include <openssl/buffer.h>
+# include <openssl/x509.h>
+# include <openssl/prov_ssl.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Default security level if not overridden at config time */
+# ifndef OPENSSL_TLS_SECURITY_LEVEL
+#  define OPENSSL_TLS_SECURITY_LEVEL 1
+# endif
+
+/* TLS*_VERSION constants are defined in prov_ssl.h */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define TLS_MAX_VERSION                TLS1_3_VERSION
+# endif
+
+/* Special value for method supporting multiple versions */
+# define TLS_ANY_VERSION                 0x10000
+
+# define TLS1_VERSION_MAJOR              0x03
+# define TLS1_VERSION_MINOR              0x01
+
+# define TLS1_1_VERSION_MAJOR            0x03
+# define TLS1_1_VERSION_MINOR            0x02
+
+# define TLS1_2_VERSION_MAJOR            0x03
+# define TLS1_2_VERSION_MINOR            0x03
+
+# define TLS1_get_version(s) \
+        ((SSL_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_version(s) : 0)
+
+# define TLS1_get_client_version(s) \
+        ((SSL_client_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_client_version(s) : 0)
+
+# define TLS1_AD_DECRYPTION_FAILED       21
+# define TLS1_AD_RECORD_OVERFLOW         22
+# define TLS1_AD_UNKNOWN_CA              48/* fatal */
+# define TLS1_AD_ACCESS_DENIED           49/* fatal */
+# define TLS1_AD_DECODE_ERROR            50/* fatal */
+# define TLS1_AD_DECRYPT_ERROR           51
+# define TLS1_AD_EXPORT_RESTRICTION      60/* fatal */
+# define TLS1_AD_PROTOCOL_VERSION        70/* fatal */
+# define TLS1_AD_INSUFFICIENT_SECURITY   71/* fatal */
+# define TLS1_AD_INTERNAL_ERROR          80/* fatal */
+# define TLS1_AD_INAPPROPRIATE_FALLBACK  86/* fatal */
+# define TLS1_AD_USER_CANCELLED          90
+# define TLS1_AD_NO_RENEGOTIATION        100
+/* TLSv1.3 alerts */
+# define TLS13_AD_MISSING_EXTENSION      109 /* fatal */
+# define TLS13_AD_CERTIFICATE_REQUIRED   116 /* fatal */
+/* codes 110-114 are from RFC3546 */
+# define TLS1_AD_UNSUPPORTED_EXTENSION   110
+# define TLS1_AD_CERTIFICATE_UNOBTAINABLE 111
+# define TLS1_AD_UNRECOGNIZED_NAME       112
+# define TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE 113
+# define TLS1_AD_BAD_CERTIFICATE_HASH_VALUE 114
+# define TLS1_AD_UNKNOWN_PSK_IDENTITY    115/* fatal */
+# define TLS1_AD_NO_APPLICATION_PROTOCOL 120 /* fatal */
+
+/* ExtensionType values from RFC3546 / RFC4366 / RFC6066 */
+# define TLSEXT_TYPE_server_name                 0
+# define TLSEXT_TYPE_max_fragment_length         1
+# define TLSEXT_TYPE_client_certificate_url      2
+# define TLSEXT_TYPE_trusted_ca_keys             3
+# define TLSEXT_TYPE_truncated_hmac              4
+# define TLSEXT_TYPE_status_request              5
+/* ExtensionType values from RFC4681 */
+# define TLSEXT_TYPE_user_mapping                6
+/* ExtensionType values from RFC5878 */
+# define TLSEXT_TYPE_client_authz                7
+# define TLSEXT_TYPE_server_authz                8
+/* ExtensionType values from RFC6091 */
+# define TLSEXT_TYPE_cert_type           9
+
+/* ExtensionType values from RFC4492 */
+/*
+ * Prior to TLSv1.3 the supported_groups extension was known as
+ * elliptic_curves
+ */
+# define TLSEXT_TYPE_supported_groups            10
+# define TLSEXT_TYPE_elliptic_curves             TLSEXT_TYPE_supported_groups
+# define TLSEXT_TYPE_ec_point_formats            11
+
+
+/* ExtensionType value from RFC5054 */
+# define TLSEXT_TYPE_srp                         12
+
+/* ExtensionType values from RFC5246 */
+# define TLSEXT_TYPE_signature_algorithms        13
+
+/* ExtensionType value from RFC5764 */
+# define TLSEXT_TYPE_use_srtp    14
+
+/* ExtensionType value from RFC7301 */
+# define TLSEXT_TYPE_application_layer_protocol_negotiation 16
+
+/*
+ * Extension type for Certificate Transparency
+ * https://tools.ietf.org/html/rfc6962#section-3.3.1
+ */
+# define TLSEXT_TYPE_signed_certificate_timestamp    18
+
+/*
+ * ExtensionType value for TLS padding extension.
+ * http://tools.ietf.org/html/draft-agl-tls-padding
+ */
+# define TLSEXT_TYPE_padding     21
+
+/* ExtensionType value from RFC7366 */
+# define TLSEXT_TYPE_encrypt_then_mac    22
+
+/* ExtensionType value from RFC7627 */
+# define TLSEXT_TYPE_extended_master_secret      23
+
+/* ExtensionType value from RFC4507 */
+# define TLSEXT_TYPE_session_ticket              35
+
+/* As defined for TLS1.3 */
+# define TLSEXT_TYPE_psk                         41
+# define TLSEXT_TYPE_early_data                  42
+# define TLSEXT_TYPE_supported_versions          43
+# define TLSEXT_TYPE_cookie                      44
+# define TLSEXT_TYPE_psk_kex_modes               45
+# define TLSEXT_TYPE_certificate_authorities     47
+# define TLSEXT_TYPE_post_handshake_auth         49
+# define TLSEXT_TYPE_signature_algorithms_cert   50
+# define TLSEXT_TYPE_key_share                   51
+
+/* Temporary extension type */
+# define TLSEXT_TYPE_renegotiate                 0xff01
+
+# ifndef OPENSSL_NO_NEXTPROTONEG
+/* This is not an IANA defined extension number */
+#  define TLSEXT_TYPE_next_proto_neg              13172
+# endif
+
+/* NameType value from RFC3546 */
+# define TLSEXT_NAMETYPE_host_name 0
+/* status request value from RFC3546 */
+# define TLSEXT_STATUSTYPE_ocsp 1
+
+/* ECPointFormat values from RFC4492 */
+# define TLSEXT_ECPOINTFORMAT_first                      0
+# define TLSEXT_ECPOINTFORMAT_uncompressed               0
+# define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime  1
+# define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2  2
+# define TLSEXT_ECPOINTFORMAT_last                       2
+
+/* Signature and hash algorithms from RFC5246 */
+# define TLSEXT_signature_anonymous                      0
+# define TLSEXT_signature_rsa                            1
+# define TLSEXT_signature_dsa                            2
+# define TLSEXT_signature_ecdsa                          3
+# define TLSEXT_signature_gostr34102001                  237
+# define TLSEXT_signature_gostr34102012_256              238
+# define TLSEXT_signature_gostr34102012_512              239
+
+/* Total number of different signature algorithms */
+# define TLSEXT_signature_num                            7
+
+# define TLSEXT_hash_none                                0
+# define TLSEXT_hash_md5                                 1
+# define TLSEXT_hash_sha1                                2
+# define TLSEXT_hash_sha224                              3
+# define TLSEXT_hash_sha256                              4
+# define TLSEXT_hash_sha384                              5
+# define TLSEXT_hash_sha512                              6
+# define TLSEXT_hash_gostr3411                           237
+# define TLSEXT_hash_gostr34112012_256                   238
+# define TLSEXT_hash_gostr34112012_512                   239
+
+/* Total number of different digest algorithms */
+
+# define TLSEXT_hash_num                                 10
+
+/* Flag set for unrecognised algorithms */
+# define TLSEXT_nid_unknown                              0x1000000
+
+/* ECC curves */
+
+# define TLSEXT_curve_P_256                              23
+# define TLSEXT_curve_P_384                              24
+
+/* OpenSSL value to disable maximum fragment length extension */
+# define TLSEXT_max_fragment_length_DISABLED    0
+/* Allowed values for max fragment length extension */
+# define TLSEXT_max_fragment_length_512         1
+# define TLSEXT_max_fragment_length_1024        2
+# define TLSEXT_max_fragment_length_2048        3
+# define TLSEXT_max_fragment_length_4096        4
+
+int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX *ctx, uint8_t mode);
+int SSL_set_tlsext_max_fragment_length(SSL *ssl, uint8_t mode);
+
+# define TLSEXT_MAXLEN_host_name 255
+
+__owur const char *SSL_get_servername(const SSL *s, const int type);
+__owur int SSL_get_servername_type(const SSL *s);
+/*
+ * SSL_export_keying_material exports a value derived from the master secret,
+ * as specified in RFC 5705. It writes |olen| bytes to |out| given a label and
+ * optional context. (Since a zero length context is allowed, the |use_context|
+ * flag controls whether a context is included.) It returns 1 on success and
+ * 0 or -1 otherwise.
+ */
+__owur int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
+                                      const char *label, size_t llen,
+                                      const unsigned char *context,
+                                      size_t contextlen, int use_context);
+
+/*
+ * SSL_export_keying_material_early exports a value derived from the
+ * early exporter master secret, as specified in
+ * https://tools.ietf.org/html/draft-ietf-tls-tls13-23. It writes
+ * |olen| bytes to |out| given a label and optional context. It
+ * returns 1 on success and 0 otherwise.
+ */
+__owur int SSL_export_keying_material_early(SSL *s, unsigned char *out,
+                                            size_t olen, const char *label,
+                                            size_t llen,
+                                            const unsigned char *context,
+                                            size_t contextlen);
+
+int SSL_get_peer_signature_type_nid(const SSL *s, int *pnid);
+int SSL_get_signature_type_nid(const SSL *s, int *pnid);
+
+int SSL_get_sigalgs(SSL *s, int idx,
+                    int *psign, int *phash, int *psignandhash,
+                    unsigned char *rsig, unsigned char *rhash);
+
+int SSL_get_shared_sigalgs(SSL *s, int idx,
+                           int *psign, int *phash, int *psignandhash,
+                           unsigned char *rsig, unsigned char *rhash);
+
+__owur int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain);
+
+# define SSL_set_tlsext_host_name(s,name) \
+        SSL_ctrl(s,SSL_CTRL_SET_TLSEXT_HOSTNAME,TLSEXT_NAMETYPE_host_name,\
+                (void *)name)
+
+# define SSL_set_tlsext_debug_callback(ssl, cb) \
+        SSL_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_CB,\
+                (void (*)(void))cb)
+
+# define SSL_set_tlsext_debug_arg(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_ARG,0,arg)
+
+# define SSL_get_tlsext_status_type(ssl) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE,0,NULL)
+
+# define SSL_set_tlsext_status_type(ssl, type) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type,NULL)
+
+# define SSL_get_tlsext_status_exts(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS,0,arg)
+
+# define SSL_set_tlsext_status_exts(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS,0,arg)
+
+# define SSL_get_tlsext_status_ids(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS,0,arg)
+
+# define SSL_set_tlsext_status_ids(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS,0,arg)
+
+# define SSL_get_tlsext_status_ocsp_resp(ssl, arg) \
+        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP,0,arg)
+
+# define SSL_set_tlsext_status_ocsp_resp(ssl, arg, arglen) \
+        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP,arglen,arg)
+
+# define SSL_CTX_set_tlsext_servername_callback(ctx, cb) \
+        SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_CB,\
+                (void (*)(void))cb)
+
+# define SSL_TLSEXT_ERR_OK 0
+# define SSL_TLSEXT_ERR_ALERT_WARNING 1
+# define SSL_TLSEXT_ERR_ALERT_FATAL 2
+# define SSL_TLSEXT_ERR_NOACK 3
+
+# define SSL_CTX_set_tlsext_servername_arg(ctx, arg) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG,0,arg)
+
+# define SSL_CTX_get_tlsext_ticket_keys(ctx, keys, keylen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_TLSEXT_TICKET_KEYS,keylen,keys)
+# define SSL_CTX_set_tlsext_ticket_keys(ctx, keys, keylen) \
+        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_TICKET_KEYS,keylen,keys)
+
+# define SSL_CTX_get_tlsext_status_cb(ssl, cb) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB,0,(void *)cb)
+# define SSL_CTX_set_tlsext_status_cb(ssl, cb) \
+        SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB,\
+                (void (*)(void))cb)
+
+# define SSL_CTX_get_tlsext_status_arg(ssl, arg) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG,0,arg)
+# define SSL_CTX_set_tlsext_status_arg(ssl, arg) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG,0,arg)
+
+# define SSL_CTX_set_tlsext_status_type(ssl, type) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type,NULL)
+
+# define SSL_CTX_get_tlsext_status_type(ssl) \
+        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE,0,NULL)
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define SSL_CTX_set_tlsext_ticket_key_cb(ssl, cb) \
+        SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB,\
+                (void (*)(void))cb)
+# endif
+int SSL_CTX_set_tlsext_ticket_key_evp_cb
+    (SSL_CTX *ctx, int (*fp)(SSL *, unsigned char *, unsigned char *,
+                             EVP_CIPHER_CTX *, EVP_MAC_CTX *, int));
+
+/* PSK ciphersuites from 4279 */
+# define TLS1_CK_PSK_WITH_RC4_128_SHA                    0x0300008A
+# define TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA               0x0300008B
+# define TLS1_CK_PSK_WITH_AES_128_CBC_SHA                0x0300008C
+# define TLS1_CK_PSK_WITH_AES_256_CBC_SHA                0x0300008D
+# define TLS1_CK_DHE_PSK_WITH_RC4_128_SHA                0x0300008E
+# define TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA           0x0300008F
+# define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA            0x03000090
+# define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA            0x03000091
+# define TLS1_CK_RSA_PSK_WITH_RC4_128_SHA                0x03000092
+# define TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA           0x03000093
+# define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA            0x03000094
+# define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA            0x03000095
+
+/* PSK ciphersuites from 5487 */
+# define TLS1_CK_PSK_WITH_AES_128_GCM_SHA256             0x030000A8
+# define TLS1_CK_PSK_WITH_AES_256_GCM_SHA384             0x030000A9
+# define TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256         0x030000AA
+# define TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384         0x030000AB
+# define TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256         0x030000AC
+# define TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384         0x030000AD
+# define TLS1_CK_PSK_WITH_AES_128_CBC_SHA256             0x030000AE
+# define TLS1_CK_PSK_WITH_AES_256_CBC_SHA384             0x030000AF
+# define TLS1_CK_PSK_WITH_NULL_SHA256                    0x030000B0
+# define TLS1_CK_PSK_WITH_NULL_SHA384                    0x030000B1
+# define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256         0x030000B2
+# define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384         0x030000B3
+# define TLS1_CK_DHE_PSK_WITH_NULL_SHA256                0x030000B4
+# define TLS1_CK_DHE_PSK_WITH_NULL_SHA384                0x030000B5
+# define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256         0x030000B6
+# define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384         0x030000B7
+# define TLS1_CK_RSA_PSK_WITH_NULL_SHA256                0x030000B8
+# define TLS1_CK_RSA_PSK_WITH_NULL_SHA384                0x030000B9
+
+/* NULL PSK ciphersuites from RFC4785 */
+# define TLS1_CK_PSK_WITH_NULL_SHA                       0x0300002C
+# define TLS1_CK_DHE_PSK_WITH_NULL_SHA                   0x0300002D
+# define TLS1_CK_RSA_PSK_WITH_NULL_SHA                   0x0300002E
+
+/* AES ciphersuites from RFC3268 */
+# define TLS1_CK_RSA_WITH_AES_128_SHA                    0x0300002F
+# define TLS1_CK_DH_DSS_WITH_AES_128_SHA                 0x03000030
+# define TLS1_CK_DH_RSA_WITH_AES_128_SHA                 0x03000031
+# define TLS1_CK_DHE_DSS_WITH_AES_128_SHA                0x03000032
+# define TLS1_CK_DHE_RSA_WITH_AES_128_SHA                0x03000033
+# define TLS1_CK_ADH_WITH_AES_128_SHA                    0x03000034
+# define TLS1_CK_RSA_WITH_AES_256_SHA                    0x03000035
+# define TLS1_CK_DH_DSS_WITH_AES_256_SHA                 0x03000036
+# define TLS1_CK_DH_RSA_WITH_AES_256_SHA                 0x03000037
+# define TLS1_CK_DHE_DSS_WITH_AES_256_SHA                0x03000038
+# define TLS1_CK_DHE_RSA_WITH_AES_256_SHA                0x03000039
+# define TLS1_CK_ADH_WITH_AES_256_SHA                    0x0300003A
+
+/* TLS v1.2 ciphersuites */
+# define TLS1_CK_RSA_WITH_NULL_SHA256                    0x0300003B
+# define TLS1_CK_RSA_WITH_AES_128_SHA256                 0x0300003C
+# define TLS1_CK_RSA_WITH_AES_256_SHA256                 0x0300003D
+# define TLS1_CK_DH_DSS_WITH_AES_128_SHA256              0x0300003E
+# define TLS1_CK_DH_RSA_WITH_AES_128_SHA256              0x0300003F
+# define TLS1_CK_DHE_DSS_WITH_AES_128_SHA256             0x03000040
+
+/* Camellia ciphersuites from RFC4132 */
+# define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA           0x03000041
+# define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA        0x03000042
+# define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA        0x03000043
+# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA       0x03000044
+# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA       0x03000045
+# define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA           0x03000046
+
+/* TLS v1.2 ciphersuites */
+# define TLS1_CK_DHE_RSA_WITH_AES_128_SHA256             0x03000067
+# define TLS1_CK_DH_DSS_WITH_AES_256_SHA256              0x03000068
+# define TLS1_CK_DH_RSA_WITH_AES_256_SHA256              0x03000069
+# define TLS1_CK_DHE_DSS_WITH_AES_256_SHA256             0x0300006A
+# define TLS1_CK_DHE_RSA_WITH_AES_256_SHA256             0x0300006B
+# define TLS1_CK_ADH_WITH_AES_128_SHA256                 0x0300006C
+# define TLS1_CK_ADH_WITH_AES_256_SHA256                 0x0300006D
+
+/* Camellia ciphersuites from RFC4132 */
+# define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA           0x03000084
+# define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA        0x03000085
+# define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA        0x03000086
+# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA       0x03000087
+# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA       0x03000088
+# define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA           0x03000089
+
+/* SEED ciphersuites from RFC4162 */
+# define TLS1_CK_RSA_WITH_SEED_SHA                       0x03000096
+# define TLS1_CK_DH_DSS_WITH_SEED_SHA                    0x03000097
+# define TLS1_CK_DH_RSA_WITH_SEED_SHA                    0x03000098
+# define TLS1_CK_DHE_DSS_WITH_SEED_SHA                   0x03000099
+# define TLS1_CK_DHE_RSA_WITH_SEED_SHA                   0x0300009A
+# define TLS1_CK_ADH_WITH_SEED_SHA                       0x0300009B
+
+/* TLS v1.2 GCM ciphersuites from RFC5288 */
+# define TLS1_CK_RSA_WITH_AES_128_GCM_SHA256             0x0300009C
+# define TLS1_CK_RSA_WITH_AES_256_GCM_SHA384             0x0300009D
+# define TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256         0x0300009E
+# define TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384         0x0300009F
+# define TLS1_CK_DH_RSA_WITH_AES_128_GCM_SHA256          0x030000A0
+# define TLS1_CK_DH_RSA_WITH_AES_256_GCM_SHA384          0x030000A1
+# define TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256         0x030000A2
+# define TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384         0x030000A3
+# define TLS1_CK_DH_DSS_WITH_AES_128_GCM_SHA256          0x030000A4
+# define TLS1_CK_DH_DSS_WITH_AES_256_GCM_SHA384          0x030000A5
+# define TLS1_CK_ADH_WITH_AES_128_GCM_SHA256             0x030000A6
+# define TLS1_CK_ADH_WITH_AES_256_GCM_SHA384             0x030000A7
+
+/* CCM ciphersuites from RFC6655 */
+# define TLS1_CK_RSA_WITH_AES_128_CCM                    0x0300C09C
+# define TLS1_CK_RSA_WITH_AES_256_CCM                    0x0300C09D
+# define TLS1_CK_DHE_RSA_WITH_AES_128_CCM                0x0300C09E
+# define TLS1_CK_DHE_RSA_WITH_AES_256_CCM                0x0300C09F
+# define TLS1_CK_RSA_WITH_AES_128_CCM_8                  0x0300C0A0
+# define TLS1_CK_RSA_WITH_AES_256_CCM_8                  0x0300C0A1
+# define TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8              0x0300C0A2
+# define TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8              0x0300C0A3
+# define TLS1_CK_PSK_WITH_AES_128_CCM                    0x0300C0A4
+# define TLS1_CK_PSK_WITH_AES_256_CCM                    0x0300C0A5
+# define TLS1_CK_DHE_PSK_WITH_AES_128_CCM                0x0300C0A6
+# define TLS1_CK_DHE_PSK_WITH_AES_256_CCM                0x0300C0A7
+# define TLS1_CK_PSK_WITH_AES_128_CCM_8                  0x0300C0A8
+# define TLS1_CK_PSK_WITH_AES_256_CCM_8                  0x0300C0A9
+# define TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8              0x0300C0AA
+# define TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8              0x0300C0AB
+
+/* CCM ciphersuites from RFC7251 */
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM            0x0300C0AC
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM            0x0300C0AD
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8          0x0300C0AE
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8          0x0300C0AF
+
+/* TLS 1.2 Camellia SHA-256 ciphersuites from RFC5932 */
+# define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256                0x030000BA
+# define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256             0x030000BB
+# define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256             0x030000BC
+# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256            0x030000BD
+# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256            0x030000BE
+# define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256                0x030000BF
+
+# define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256                0x030000C0
+# define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256             0x030000C1
+# define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256             0x030000C2
+# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256            0x030000C3
+# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256            0x030000C4
+# define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256                0x030000C5
+
+/* ECC ciphersuites from RFC4492 */
+# define TLS1_CK_ECDH_ECDSA_WITH_NULL_SHA                0x0300C001
+# define TLS1_CK_ECDH_ECDSA_WITH_RC4_128_SHA             0x0300C002
+# define TLS1_CK_ECDH_ECDSA_WITH_DES_192_CBC3_SHA        0x0300C003
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_CBC_SHA         0x0300C004
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_CBC_SHA         0x0300C005
+
+# define TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA               0x0300C006
+# define TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA            0x0300C007
+# define TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA       0x0300C008
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA        0x0300C009
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA        0x0300C00A
+
+# define TLS1_CK_ECDH_RSA_WITH_NULL_SHA                  0x0300C00B
+# define TLS1_CK_ECDH_RSA_WITH_RC4_128_SHA               0x0300C00C
+# define TLS1_CK_ECDH_RSA_WITH_DES_192_CBC3_SHA          0x0300C00D
+# define TLS1_CK_ECDH_RSA_WITH_AES_128_CBC_SHA           0x0300C00E
+# define TLS1_CK_ECDH_RSA_WITH_AES_256_CBC_SHA           0x0300C00F
+
+# define TLS1_CK_ECDHE_RSA_WITH_NULL_SHA                 0x0300C010
+# define TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA              0x0300C011
+# define TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA         0x0300C012
+# define TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA          0x0300C013
+# define TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA          0x0300C014
+
+# define TLS1_CK_ECDH_anon_WITH_NULL_SHA                 0x0300C015
+# define TLS1_CK_ECDH_anon_WITH_RC4_128_SHA              0x0300C016
+# define TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA         0x0300C017
+# define TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA          0x0300C018
+# define TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA          0x0300C019
+
+/* SRP ciphersuites from RFC 5054 */
+# define TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA           0x0300C01A
+# define TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA       0x0300C01B
+# define TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA       0x0300C01C
+# define TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA            0x0300C01D
+# define TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA        0x0300C01E
+# define TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA        0x0300C01F
+# define TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA            0x0300C020
+# define TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA        0x0300C021
+# define TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA        0x0300C022
+
+/* ECDH HMAC based ciphersuites from RFC5289 */
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256         0x0300C023
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384         0x0300C024
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_SHA256          0x0300C025
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_SHA384          0x0300C026
+# define TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256           0x0300C027
+# define TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384           0x0300C028
+# define TLS1_CK_ECDH_RSA_WITH_AES_128_SHA256            0x0300C029
+# define TLS1_CK_ECDH_RSA_WITH_AES_256_SHA384            0x0300C02A
+
+/* ECDH GCM based ciphersuites from RFC5289 */
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256     0x0300C02B
+# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384     0x0300C02C
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_GCM_SHA256      0x0300C02D
+# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_GCM_SHA384      0x0300C02E
+# define TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256       0x0300C02F
+# define TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384       0x0300C030
+# define TLS1_CK_ECDH_RSA_WITH_AES_128_GCM_SHA256        0x0300C031
+# define TLS1_CK_ECDH_RSA_WITH_AES_256_GCM_SHA384        0x0300C032
+
+/* ECDHE PSK ciphersuites from RFC5489 */
+# define TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA              0x0300C033
+# define TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA         0x0300C034
+# define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA          0x0300C035
+# define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA          0x0300C036
+
+# define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256       0x0300C037
+# define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384       0x0300C038
+
+/* NULL PSK ciphersuites from RFC4785 */
+# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA                 0x0300C039
+# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256              0x0300C03A
+# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384              0x0300C03B
+
+/* Camellia-CBC ciphersuites from RFC6367 */
+# define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C072
+# define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C073
+# define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256  0x0300C074
+# define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384  0x0300C075
+# define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   0x0300C076
+# define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384   0x0300C077
+# define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256    0x0300C078
+# define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384    0x0300C079
+
+# define TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256         0x0300C094
+# define TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384         0x0300C095
+# define TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256     0x0300C096
+# define TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384     0x0300C097
+# define TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256     0x0300C098
+# define TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384     0x0300C099
+# define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256   0x0300C09A
+# define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384   0x0300C09B
+
+/* draft-ietf-tls-chacha20-poly1305-03 */
+# define TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305         0x0300CCA8
+# define TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305       0x0300CCA9
+# define TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305           0x0300CCAA
+# define TLS1_CK_PSK_WITH_CHACHA20_POLY1305               0x0300CCAB
+# define TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305         0x0300CCAC
+# define TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305           0x0300CCAD
+# define TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305           0x0300CCAE
+
+/* TLS v1.3 ciphersuites */
+# define TLS1_3_CK_AES_128_GCM_SHA256                     0x03001301
+# define TLS1_3_CK_AES_256_GCM_SHA384                     0x03001302
+# define TLS1_3_CK_CHACHA20_POLY1305_SHA256               0x03001303
+# define TLS1_3_CK_AES_128_CCM_SHA256                     0x03001304
+# define TLS1_3_CK_AES_128_CCM_8_SHA256                   0x03001305
+
+/* Aria ciphersuites from RFC6209 */
+# define TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256             0x0300C050
+# define TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384             0x0300C051
+# define TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256         0x0300C052
+# define TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384         0x0300C053
+# define TLS1_CK_DH_RSA_WITH_ARIA_128_GCM_SHA256          0x0300C054
+# define TLS1_CK_DH_RSA_WITH_ARIA_256_GCM_SHA384          0x0300C055
+# define TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256         0x0300C056
+# define TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384         0x0300C057
+# define TLS1_CK_DH_DSS_WITH_ARIA_128_GCM_SHA256          0x0300C058
+# define TLS1_CK_DH_DSS_WITH_ARIA_256_GCM_SHA384          0x0300C059
+# define TLS1_CK_DH_anon_WITH_ARIA_128_GCM_SHA256         0x0300C05A
+# define TLS1_CK_DH_anon_WITH_ARIA_256_GCM_SHA384         0x0300C05B
+# define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256     0x0300C05C
+# define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384     0x0300C05D
+# define TLS1_CK_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256      0x0300C05E
+# define TLS1_CK_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384      0x0300C05F
+# define TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256       0x0300C060
+# define TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384       0x0300C061
+# define TLS1_CK_ECDH_RSA_WITH_ARIA_128_GCM_SHA256        0x0300C062
+# define TLS1_CK_ECDH_RSA_WITH_ARIA_256_GCM_SHA384        0x0300C063
+# define TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256             0x0300C06A
+# define TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384             0x0300C06B
+# define TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256         0x0300C06C
+# define TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384         0x0300C06D
+# define TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256         0x0300C06E
+# define TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384         0x0300C06F
+
+/* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */
+# define TLS1_RFC_RSA_WITH_AES_128_SHA                   "TLS_RSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA               "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA               "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_AES_128_SHA                   "TLS_DH_anon_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_RSA_WITH_AES_256_SHA                   "TLS_RSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA               "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA               "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_AES_256_SHA                   "TLS_DH_anon_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_RSA_WITH_NULL_SHA256                   "TLS_RSA_WITH_NULL_SHA256"
+# define TLS1_RFC_RSA_WITH_AES_128_SHA256                "TLS_RSA_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_RSA_WITH_AES_256_SHA256                "TLS_RSA_WITH_AES_256_CBC_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256            "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256            "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256            "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256            "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"
+# define TLS1_RFC_ADH_WITH_AES_128_SHA256                "TLS_DH_anon_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_ADH_WITH_AES_256_SHA256                "TLS_DH_anon_WITH_AES_256_CBC_SHA256"
+# define TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256            "TLS_RSA_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384            "TLS_RSA_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256        "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384        "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256        "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384        "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256            "TLS_DH_anon_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384            "TLS_DH_anon_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_RSA_WITH_AES_128_CCM                   "TLS_RSA_WITH_AES_128_CCM"
+# define TLS1_RFC_RSA_WITH_AES_256_CCM                   "TLS_RSA_WITH_AES_256_CCM"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM               "TLS_DHE_RSA_WITH_AES_128_CCM"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM               "TLS_DHE_RSA_WITH_AES_256_CCM"
+# define TLS1_RFC_RSA_WITH_AES_128_CCM_8                 "TLS_RSA_WITH_AES_128_CCM_8"
+# define TLS1_RFC_RSA_WITH_AES_256_CCM_8                 "TLS_RSA_WITH_AES_256_CCM_8"
+# define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8             "TLS_DHE_RSA_WITH_AES_128_CCM_8"
+# define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8             "TLS_DHE_RSA_WITH_AES_256_CCM_8"
+# define TLS1_RFC_PSK_WITH_AES_128_CCM                   "TLS_PSK_WITH_AES_128_CCM"
+# define TLS1_RFC_PSK_WITH_AES_256_CCM                   "TLS_PSK_WITH_AES_256_CCM"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM               "TLS_DHE_PSK_WITH_AES_128_CCM"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM               "TLS_DHE_PSK_WITH_AES_256_CCM"
+# define TLS1_RFC_PSK_WITH_AES_128_CCM_8                 "TLS_PSK_WITH_AES_128_CCM_8"
+# define TLS1_RFC_PSK_WITH_AES_256_CCM_8                 "TLS_PSK_WITH_AES_256_CCM_8"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8             "TLS_PSK_DHE_WITH_AES_128_CCM_8"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8             "TLS_PSK_DHE_WITH_AES_256_CCM_8"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM           "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM           "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8         "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8         "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"
+# define TLS1_3_RFC_AES_128_GCM_SHA256                   "TLS_AES_128_GCM_SHA256"
+# define TLS1_3_RFC_AES_256_GCM_SHA384                   "TLS_AES_256_GCM_SHA384"
+# define TLS1_3_RFC_CHACHA20_POLY1305_SHA256             "TLS_CHACHA20_POLY1305_SHA256"
+# define TLS1_3_RFC_AES_128_CCM_SHA256                   "TLS_AES_128_CCM_SHA256"
+# define TLS1_3_RFC_AES_128_CCM_8_SHA256                 "TLS_AES_128_CCM_8_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA              "TLS_ECDHE_ECDSA_WITH_NULL_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA      "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA       "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA       "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA                "TLS_ECDHE_RSA_WITH_NULL_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA        "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA         "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA         "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_NULL_SHA                "TLS_ECDH_anon_WITH_NULL_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA        "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA         "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA         "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256        "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384        "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256          "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384          "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256    "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384    "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256      "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384      "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_PSK_WITH_NULL_SHA                      "TLS_PSK_WITH_NULL_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA                  "TLS_DHE_PSK_WITH_NULL_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA                  "TLS_RSA_PSK_WITH_NULL_SHA"
+# define TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA              "TLS_PSK_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA               "TLS_PSK_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA               "TLS_PSK_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA          "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA           "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA           "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA          "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA           "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA           "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256            "TLS_PSK_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384            "TLS_PSK_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256        "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384        "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256        "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384        "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"
+# define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256            "TLS_PSK_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384            "TLS_PSK_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_PSK_WITH_NULL_SHA256                   "TLS_PSK_WITH_NULL_SHA256"
+# define TLS1_RFC_PSK_WITH_NULL_SHA384                   "TLS_PSK_WITH_NULL_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256        "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384        "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA256               "TLS_DHE_PSK_WITH_NULL_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA384               "TLS_DHE_PSK_WITH_NULL_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256        "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384        "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA256               "TLS_RSA_PSK_WITH_NULL_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA384               "TLS_RSA_PSK_WITH_NULL_SHA384"
+# define TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA        "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA         "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA         "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256      "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384      "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA                "TLS_ECDHE_PSK_WITH_NULL_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256             "TLS_ECDHE_PSK_WITH_NULL_SHA256"
+# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384             "TLS_ECDHE_PSK_WITH_NULL_SHA384"
+# define TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA          "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA      "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA      "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA           "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA       "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA       "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA           "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA       "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA       "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305         "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305       "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305     "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_PSK_WITH_CHACHA20_POLY1305             "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305       "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305         "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305         "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"
+# define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256       "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256       "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256       "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256   "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256   "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"
+# define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256       "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"
+# define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA          "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA      "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA      "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA          "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"
+# define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA          "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA      "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA      "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA          "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256       "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384       "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384   "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256   "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384   "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+# define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+# define TLS1_RFC_RSA_WITH_SEED_SHA                      "TLS_RSA_WITH_SEED_CBC_SHA"
+# define TLS1_RFC_DHE_DSS_WITH_SEED_SHA                  "TLS_DHE_DSS_WITH_SEED_CBC_SHA"
+# define TLS1_RFC_DHE_RSA_WITH_SEED_SHA                  "TLS_DHE_RSA_WITH_SEED_CBC_SHA"
+# define TLS1_RFC_ADH_WITH_SEED_SHA                      "TLS_DH_anon_WITH_SEED_CBC_SHA"
+# define TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA             "TLS_ECDHE_PSK_WITH_RC4_128_SHA"
+# define TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA             "TLS_ECDH_anon_WITH_RC4_128_SHA"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA           "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"
+# define TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA             "TLS_ECDHE_RSA_WITH_RC4_128_SHA"
+# define TLS1_RFC_PSK_WITH_RC4_128_SHA                   "TLS_PSK_WITH_RC4_128_SHA"
+# define TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA               "TLS_RSA_PSK_WITH_RC4_128_SHA"
+# define TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA               "TLS_DHE_PSK_WITH_RC4_128_SHA"
+# define TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256           "TLS_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384           "TLS_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DH_RSA_WITH_ARIA_128_GCM_SHA256        "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DH_RSA_WITH_ARIA_256_GCM_SHA384        "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DH_DSS_WITH_ARIA_128_GCM_SHA256        "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DH_DSS_WITH_ARIA_256_GCM_SHA384        "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DH_anon_WITH_ARIA_128_GCM_SHA256       "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DH_anon_WITH_ARIA_256_GCM_SHA384       "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256   "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384   "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256    "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384    "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256     "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384     "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_ECDH_RSA_WITH_ARIA_128_GCM_SHA256      "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_ECDH_RSA_WITH_ARIA_256_GCM_SHA384      "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256           "TLS_PSK_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384           "TLS_PSK_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"
+# define TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256       "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"
+# define TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384       "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"
+
+
+/*
+ * XXX Backward compatibility alert: Older versions of OpenSSL gave some DHE
+ * ciphers names with "EDH" instead of "DHE".  Going forward, we should be
+ * using DHE everywhere, though we may indefinitely maintain aliases for
+ * users or configurations that used "EDH"
+ */
+# define TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA               "DHE-DSS-RC4-SHA"
+
+# define TLS1_TXT_PSK_WITH_NULL_SHA                      "PSK-NULL-SHA"
+# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA                  "DHE-PSK-NULL-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA                  "RSA-PSK-NULL-SHA"
+
+/* AES ciphersuites from RFC3268 */
+# define TLS1_TXT_RSA_WITH_AES_128_SHA                   "AES128-SHA"
+# define TLS1_TXT_DH_DSS_WITH_AES_128_SHA                "DH-DSS-AES128-SHA"
+# define TLS1_TXT_DH_RSA_WITH_AES_128_SHA                "DH-RSA-AES128-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA               "DHE-DSS-AES128-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA               "DHE-RSA-AES128-SHA"
+# define TLS1_TXT_ADH_WITH_AES_128_SHA                   "ADH-AES128-SHA"
+
+# define TLS1_TXT_RSA_WITH_AES_256_SHA                   "AES256-SHA"
+# define TLS1_TXT_DH_DSS_WITH_AES_256_SHA                "DH-DSS-AES256-SHA"
+# define TLS1_TXT_DH_RSA_WITH_AES_256_SHA                "DH-RSA-AES256-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA               "DHE-DSS-AES256-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA               "DHE-RSA-AES256-SHA"
+# define TLS1_TXT_ADH_WITH_AES_256_SHA                   "ADH-AES256-SHA"
+
+/* ECC ciphersuites from RFC4492 */
+# define TLS1_TXT_ECDH_ECDSA_WITH_NULL_SHA               "ECDH-ECDSA-NULL-SHA"
+# define TLS1_TXT_ECDH_ECDSA_WITH_RC4_128_SHA            "ECDH-ECDSA-RC4-SHA"
+# define TLS1_TXT_ECDH_ECDSA_WITH_DES_192_CBC3_SHA       "ECDH-ECDSA-DES-CBC3-SHA"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_CBC_SHA        "ECDH-ECDSA-AES128-SHA"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_CBC_SHA        "ECDH-ECDSA-AES256-SHA"
+
+# define TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA              "ECDHE-ECDSA-NULL-SHA"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA           "ECDHE-ECDSA-RC4-SHA"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA      "ECDHE-ECDSA-DES-CBC3-SHA"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA       "ECDHE-ECDSA-AES128-SHA"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA       "ECDHE-ECDSA-AES256-SHA"
+
+# define TLS1_TXT_ECDH_RSA_WITH_NULL_SHA                 "ECDH-RSA-NULL-SHA"
+# define TLS1_TXT_ECDH_RSA_WITH_RC4_128_SHA              "ECDH-RSA-RC4-SHA"
+# define TLS1_TXT_ECDH_RSA_WITH_DES_192_CBC3_SHA         "ECDH-RSA-DES-CBC3-SHA"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_128_CBC_SHA          "ECDH-RSA-AES128-SHA"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_256_CBC_SHA          "ECDH-RSA-AES256-SHA"
+
+# define TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA                "ECDHE-RSA-NULL-SHA"
+# define TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA             "ECDHE-RSA-RC4-SHA"
+# define TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA        "ECDHE-RSA-DES-CBC3-SHA"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA         "ECDHE-RSA-AES128-SHA"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA         "ECDHE-RSA-AES256-SHA"
+
+# define TLS1_TXT_ECDH_anon_WITH_NULL_SHA                "AECDH-NULL-SHA"
+# define TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA             "AECDH-RC4-SHA"
+# define TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA        "AECDH-DES-CBC3-SHA"
+# define TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA         "AECDH-AES128-SHA"
+# define TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA         "AECDH-AES256-SHA"
+
+/* PSK ciphersuites from RFC 4279 */
+# define TLS1_TXT_PSK_WITH_RC4_128_SHA                   "PSK-RC4-SHA"
+# define TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA              "PSK-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA               "PSK-AES128-CBC-SHA"
+# define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA               "PSK-AES256-CBC-SHA"
+
+# define TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA               "DHE-PSK-RC4-SHA"
+# define TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA          "DHE-PSK-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA           "DHE-PSK-AES128-CBC-SHA"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA           "DHE-PSK-AES256-CBC-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA               "RSA-PSK-RC4-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA          "RSA-PSK-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA           "RSA-PSK-AES128-CBC-SHA"
+# define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA           "RSA-PSK-AES256-CBC-SHA"
+
+/* PSK ciphersuites from RFC 5487 */
+# define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256            "PSK-AES128-GCM-SHA256"
+# define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384            "PSK-AES256-GCM-SHA384"
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256        "DHE-PSK-AES128-GCM-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384        "DHE-PSK-AES256-GCM-SHA384"
+# define TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256        "RSA-PSK-AES128-GCM-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384        "RSA-PSK-AES256-GCM-SHA384"
+
+# define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256            "PSK-AES128-CBC-SHA256"
+# define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384            "PSK-AES256-CBC-SHA384"
+# define TLS1_TXT_PSK_WITH_NULL_SHA256                   "PSK-NULL-SHA256"
+# define TLS1_TXT_PSK_WITH_NULL_SHA384                   "PSK-NULL-SHA384"
+
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256        "DHE-PSK-AES128-CBC-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384        "DHE-PSK-AES256-CBC-SHA384"
+# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA256               "DHE-PSK-NULL-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA384               "DHE-PSK-NULL-SHA384"
+
+# define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256        "RSA-PSK-AES128-CBC-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384        "RSA-PSK-AES256-CBC-SHA384"
+# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA256               "RSA-PSK-NULL-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA384               "RSA-PSK-NULL-SHA384"
+
+/* SRP ciphersuite from RFC 5054 */
+# define TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA          "SRP-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA      "SRP-RSA-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA      "SRP-DSS-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA           "SRP-AES-128-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA       "SRP-RSA-AES-128-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA       "SRP-DSS-AES-128-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA           "SRP-AES-256-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA       "SRP-RSA-AES-256-CBC-SHA"
+# define TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA       "SRP-DSS-AES-256-CBC-SHA"
+
+/* Camellia ciphersuites from RFC4132 */
+# define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA          "CAMELLIA128-SHA"
+# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA       "DH-DSS-CAMELLIA128-SHA"
+# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA       "DH-RSA-CAMELLIA128-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA      "DHE-DSS-CAMELLIA128-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA      "DHE-RSA-CAMELLIA128-SHA"
+# define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA          "ADH-CAMELLIA128-SHA"
+
+# define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA          "CAMELLIA256-SHA"
+# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA       "DH-DSS-CAMELLIA256-SHA"
+# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA       "DH-RSA-CAMELLIA256-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA      "DHE-DSS-CAMELLIA256-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA      "DHE-RSA-CAMELLIA256-SHA"
+# define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA          "ADH-CAMELLIA256-SHA"
+
+/* TLS 1.2 Camellia SHA-256 ciphersuites from RFC5932 */
+# define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256               "CAMELLIA128-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256            "DH-DSS-CAMELLIA128-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256            "DH-RSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256           "DHE-DSS-CAMELLIA128-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256           "DHE-RSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256               "ADH-CAMELLIA128-SHA256"
+
+# define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256               "CAMELLIA256-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256            "DH-DSS-CAMELLIA256-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256            "DH-RSA-CAMELLIA256-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256           "DHE-DSS-CAMELLIA256-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256           "DHE-RSA-CAMELLIA256-SHA256"
+# define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256               "ADH-CAMELLIA256-SHA256"
+
+# define TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256               "PSK-CAMELLIA128-SHA256"
+# define TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384               "PSK-CAMELLIA256-SHA384"
+# define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256           "DHE-PSK-CAMELLIA128-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384           "DHE-PSK-CAMELLIA256-SHA384"
+# define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256           "RSA-PSK-CAMELLIA128-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384           "RSA-PSK-CAMELLIA256-SHA384"
+# define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256         "ECDHE-PSK-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384         "ECDHE-PSK-CAMELLIA256-SHA384"
+
+/* SEED ciphersuites from RFC4162 */
+# define TLS1_TXT_RSA_WITH_SEED_SHA                      "SEED-SHA"
+# define TLS1_TXT_DH_DSS_WITH_SEED_SHA                   "DH-DSS-SEED-SHA"
+# define TLS1_TXT_DH_RSA_WITH_SEED_SHA                   "DH-RSA-SEED-SHA"
+# define TLS1_TXT_DHE_DSS_WITH_SEED_SHA                  "DHE-DSS-SEED-SHA"
+# define TLS1_TXT_DHE_RSA_WITH_SEED_SHA                  "DHE-RSA-SEED-SHA"
+# define TLS1_TXT_ADH_WITH_SEED_SHA                      "ADH-SEED-SHA"
+
+/* TLS v1.2 ciphersuites */
+# define TLS1_TXT_RSA_WITH_NULL_SHA256                   "NULL-SHA256"
+# define TLS1_TXT_RSA_WITH_AES_128_SHA256                "AES128-SHA256"
+# define TLS1_TXT_RSA_WITH_AES_256_SHA256                "AES256-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_AES_128_SHA256             "DH-DSS-AES128-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_AES_128_SHA256             "DH-RSA-AES128-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256            "DHE-DSS-AES128-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256            "DHE-RSA-AES128-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_AES_256_SHA256             "DH-DSS-AES256-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_AES_256_SHA256             "DH-RSA-AES256-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256            "DHE-DSS-AES256-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256            "DHE-RSA-AES256-SHA256"
+# define TLS1_TXT_ADH_WITH_AES_128_SHA256                "ADH-AES128-SHA256"
+# define TLS1_TXT_ADH_WITH_AES_256_SHA256                "ADH-AES256-SHA256"
+
+/* TLS v1.2 GCM ciphersuites from RFC5288 */
+# define TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256            "AES128-GCM-SHA256"
+# define TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384            "AES256-GCM-SHA384"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256        "DHE-RSA-AES128-GCM-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384        "DHE-RSA-AES256-GCM-SHA384"
+# define TLS1_TXT_DH_RSA_WITH_AES_128_GCM_SHA256         "DH-RSA-AES128-GCM-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_AES_256_GCM_SHA384         "DH-RSA-AES256-GCM-SHA384"
+# define TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256        "DHE-DSS-AES128-GCM-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384        "DHE-DSS-AES256-GCM-SHA384"
+# define TLS1_TXT_DH_DSS_WITH_AES_128_GCM_SHA256         "DH-DSS-AES128-GCM-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_AES_256_GCM_SHA384         "DH-DSS-AES256-GCM-SHA384"
+# define TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256            "ADH-AES128-GCM-SHA256"
+# define TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384            "ADH-AES256-GCM-SHA384"
+
+/* CCM ciphersuites from RFC6655 */
+# define TLS1_TXT_RSA_WITH_AES_128_CCM                   "AES128-CCM"
+# define TLS1_TXT_RSA_WITH_AES_256_CCM                   "AES256-CCM"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM               "DHE-RSA-AES128-CCM"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM               "DHE-RSA-AES256-CCM"
+
+# define TLS1_TXT_RSA_WITH_AES_128_CCM_8                 "AES128-CCM8"
+# define TLS1_TXT_RSA_WITH_AES_256_CCM_8                 "AES256-CCM8"
+# define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8             "DHE-RSA-AES128-CCM8"
+# define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8             "DHE-RSA-AES256-CCM8"
+
+# define TLS1_TXT_PSK_WITH_AES_128_CCM                   "PSK-AES128-CCM"
+# define TLS1_TXT_PSK_WITH_AES_256_CCM                   "PSK-AES256-CCM"
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM               "DHE-PSK-AES128-CCM"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM               "DHE-PSK-AES256-CCM"
+
+# define TLS1_TXT_PSK_WITH_AES_128_CCM_8                 "PSK-AES128-CCM8"
+# define TLS1_TXT_PSK_WITH_AES_256_CCM_8                 "PSK-AES256-CCM8"
+# define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8             "DHE-PSK-AES128-CCM8"
+# define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8             "DHE-PSK-AES256-CCM8"
+
+/* CCM ciphersuites from RFC7251 */
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM       "ECDHE-ECDSA-AES128-CCM"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM       "ECDHE-ECDSA-AES256-CCM"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8     "ECDHE-ECDSA-AES128-CCM8"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8     "ECDHE-ECDSA-AES256-CCM8"
+
+/* ECDH HMAC based ciphersuites from RFC5289 */
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256    "ECDHE-ECDSA-AES128-SHA256"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384    "ECDHE-ECDSA-AES256-SHA384"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_SHA256     "ECDH-ECDSA-AES128-SHA256"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_SHA384     "ECDH-ECDSA-AES256-SHA384"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256      "ECDHE-RSA-AES128-SHA256"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384      "ECDHE-RSA-AES256-SHA384"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_128_SHA256       "ECDH-RSA-AES128-SHA256"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_256_SHA384       "ECDH-RSA-AES256-SHA384"
+
+/* ECDH GCM based ciphersuites from RFC5289 */
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256    "ECDHE-ECDSA-AES128-GCM-SHA256"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384    "ECDHE-ECDSA-AES256-GCM-SHA384"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_GCM_SHA256     "ECDH-ECDSA-AES128-GCM-SHA256"
+# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_GCM_SHA384     "ECDH-ECDSA-AES256-GCM-SHA384"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256      "ECDHE-RSA-AES128-GCM-SHA256"
+# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384      "ECDHE-RSA-AES256-GCM-SHA384"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_128_GCM_SHA256       "ECDH-RSA-AES128-GCM-SHA256"
+# define TLS1_TXT_ECDH_RSA_WITH_AES_256_GCM_SHA384       "ECDH-RSA-AES256-GCM-SHA384"
+
+/* TLS v1.2 PSK GCM ciphersuites from RFC5487 */
+# define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256            "PSK-AES128-GCM-SHA256"
+# define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384            "PSK-AES256-GCM-SHA384"
+
+/* ECDHE PSK ciphersuites from RFC 5489 */
+# define TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA               "ECDHE-PSK-RC4-SHA"
+# define TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA          "ECDHE-PSK-3DES-EDE-CBC-SHA"
+# define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA           "ECDHE-PSK-AES128-CBC-SHA"
+# define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA           "ECDHE-PSK-AES256-CBC-SHA"
+
+# define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256        "ECDHE-PSK-AES128-CBC-SHA256"
+# define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384        "ECDHE-PSK-AES256-CBC-SHA384"
+
+# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA                  "ECDHE-PSK-NULL-SHA"
+# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256               "ECDHE-PSK-NULL-SHA256"
+# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384               "ECDHE-PSK-NULL-SHA384"
+
+/* Camellia-CBC ciphersuites from RFC6367 */
+# define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-ECDSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-ECDSA-CAMELLIA256-SHA384"
+# define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256  "ECDH-ECDSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384  "ECDH-ECDSA-CAMELLIA256-SHA384"
+# define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   "ECDHE-RSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384   "ECDHE-RSA-CAMELLIA256-SHA384"
+# define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256    "ECDH-RSA-CAMELLIA128-SHA256"
+# define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384    "ECDH-RSA-CAMELLIA256-SHA384"
+
+/* draft-ietf-tls-chacha20-poly1305-03 */
+# define TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305         "ECDHE-RSA-CHACHA20-POLY1305"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305       "ECDHE-ECDSA-CHACHA20-POLY1305"
+# define TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305           "DHE-RSA-CHACHA20-POLY1305"
+# define TLS1_TXT_PSK_WITH_CHACHA20_POLY1305               "PSK-CHACHA20-POLY1305"
+# define TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305         "ECDHE-PSK-CHACHA20-POLY1305"
+# define TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305           "DHE-PSK-CHACHA20-POLY1305"
+# define TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305           "RSA-PSK-CHACHA20-POLY1305"
+
+/* Aria ciphersuites from RFC6209 */
+# define TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256             "ARIA128-GCM-SHA256"
+# define TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384             "ARIA256-GCM-SHA384"
+# define TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256         "DHE-RSA-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384         "DHE-RSA-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DH_RSA_WITH_ARIA_128_GCM_SHA256          "DH-RSA-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DH_RSA_WITH_ARIA_256_GCM_SHA384          "DH-RSA-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256         "DHE-DSS-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384         "DHE-DSS-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DH_DSS_WITH_ARIA_128_GCM_SHA256          "DH-DSS-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DH_DSS_WITH_ARIA_256_GCM_SHA384          "DH-DSS-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DH_anon_WITH_ARIA_128_GCM_SHA256         "ADH-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DH_anon_WITH_ARIA_256_GCM_SHA384         "ADH-ARIA256-GCM-SHA384"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256     "ECDHE-ECDSA-ARIA128-GCM-SHA256"
+# define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384     "ECDHE-ECDSA-ARIA256-GCM-SHA384"
+# define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256      "ECDH-ECDSA-ARIA128-GCM-SHA256"
+# define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384      "ECDH-ECDSA-ARIA256-GCM-SHA384"
+# define TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256       "ECDHE-ARIA128-GCM-SHA256"
+# define TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384       "ECDHE-ARIA256-GCM-SHA384"
+# define TLS1_TXT_ECDH_RSA_WITH_ARIA_128_GCM_SHA256        "ECDH-ARIA128-GCM-SHA256"
+# define TLS1_TXT_ECDH_RSA_WITH_ARIA_256_GCM_SHA384        "ECDH-ARIA256-GCM-SHA384"
+# define TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256             "PSK-ARIA128-GCM-SHA256"
+# define TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384             "PSK-ARIA256-GCM-SHA384"
+# define TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256         "DHE-PSK-ARIA128-GCM-SHA256"
+# define TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384         "DHE-PSK-ARIA256-GCM-SHA384"
+# define TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256         "RSA-PSK-ARIA128-GCM-SHA256"
+# define TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384         "RSA-PSK-ARIA256-GCM-SHA384"
+
+# define TLS_CT_RSA_SIGN                 1
+# define TLS_CT_DSS_SIGN                 2
+# define TLS_CT_RSA_FIXED_DH             3
+# define TLS_CT_DSS_FIXED_DH             4
+# define TLS_CT_ECDSA_SIGN               64
+# define TLS_CT_RSA_FIXED_ECDH           65
+# define TLS_CT_ECDSA_FIXED_ECDH         66
+# define TLS_CT_GOST01_SIGN              22
+# define TLS_CT_GOST12_IANA_SIGN         67
+# define TLS_CT_GOST12_IANA_512_SIGN     68
+# define TLS_CT_GOST12_LEGACY_SIGN       238
+# define TLS_CT_GOST12_LEGACY_512_SIGN   239
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define TLS_CT_GOST12_SIGN TLS_CT_GOST12_LEGACY_SIGN
+#  define TLS_CT_GOST12_512_SIGN TLS_CT_GOST12_LEGACY_512_SIGN
+# endif
+
+/*
+ * when correcting this number, correct also SSL3_CT_NUMBER in ssl3.h (see
+ * comment there)
+ */
+# define TLS_CT_NUMBER                   12
+
+# if defined(SSL3_CT_NUMBER)
+#  if TLS_CT_NUMBER != SSL3_CT_NUMBER
+#    error "SSL/TLS CT_NUMBER values do not match"
+#  endif
+# endif
+
+# define TLS1_FINISH_MAC_LENGTH          12
+
+# define TLS_MD_MAX_CONST_SIZE                   22
+# define TLS_MD_CLIENT_FINISH_CONST              "client finished"
+# define TLS_MD_CLIENT_FINISH_CONST_SIZE         15
+# define TLS_MD_SERVER_FINISH_CONST              "server finished"
+# define TLS_MD_SERVER_FINISH_CONST_SIZE         15
+# define TLS_MD_KEY_EXPANSION_CONST              "key expansion"
+# define TLS_MD_KEY_EXPANSION_CONST_SIZE         13
+# define TLS_MD_CLIENT_WRITE_KEY_CONST           "client write key"
+# define TLS_MD_CLIENT_WRITE_KEY_CONST_SIZE      16
+# define TLS_MD_SERVER_WRITE_KEY_CONST           "server write key"
+# define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE      16
+# define TLS_MD_IV_BLOCK_CONST                   "IV block"
+# define TLS_MD_IV_BLOCK_CONST_SIZE              8
+# define TLS_MD_MASTER_SECRET_CONST              "master secret"
+# define TLS_MD_MASTER_SECRET_CONST_SIZE         13
+# define TLS_MD_EXTENDED_MASTER_SECRET_CONST     "extended master secret"
+# define TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE        22
+
+# ifdef CHARSET_EBCDIC
+#  undef TLS_MD_CLIENT_FINISH_CONST
+/*
+ * client finished
+ */
+#  define TLS_MD_CLIENT_FINISH_CONST    "\x63\x6c\x69\x65\x6e\x74\x20\x66\x69\x6e\x69\x73\x68\x65\x64"
+
+#  undef TLS_MD_SERVER_FINISH_CONST
+/*
+ * server finished
+ */
+#  define TLS_MD_SERVER_FINISH_CONST    "\x73\x65\x72\x76\x65\x72\x20\x66\x69\x6e\x69\x73\x68\x65\x64"
+
+#  undef TLS_MD_SERVER_WRITE_KEY_CONST
+/*
+ * server write key
+ */
+#  define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+
+#  undef TLS_MD_KEY_EXPANSION_CONST
+/*
+ * key expansion
+ */
+#  define TLS_MD_KEY_EXPANSION_CONST    "\x6b\x65\x79\x20\x65\x78\x70\x61\x6e\x73\x69\x6f\x6e"
+
+#  undef TLS_MD_CLIENT_WRITE_KEY_CONST
+/*
+ * client write key
+ */
+#  define TLS_MD_CLIENT_WRITE_KEY_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+
+#  undef TLS_MD_SERVER_WRITE_KEY_CONST
+/*
+ * server write key
+ */
+#  define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+
+#  undef TLS_MD_IV_BLOCK_CONST
+/*
+ * IV block
+ */
+#  define TLS_MD_IV_BLOCK_CONST         "\x49\x56\x20\x62\x6c\x6f\x63\x6b"
+
+#  undef TLS_MD_MASTER_SECRET_CONST
+/*
+ * master secret
+ */
+#  define TLS_MD_MASTER_SECRET_CONST    "\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"
+#  undef TLS_MD_EXTENDED_MASTER_SECRET_CONST
+/*
+ * extended master secret
+ */
+#  define TLS_MD_EXTENDED_MASTER_SECRET_CONST    "\x65\x78\x74\x65\x6e\x64\x65\x64\x20\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"
+# endif
+
+/* TLS Session Ticket extension struct */
+struct tls_session_ticket_ext_st {
+    unsigned short length;
+    void *data;
+};
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/trace.h b/CAPI/cpp/grpc/include/openssl/trace.h
new file mode 100644
index 0000000..2820013
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/trace.h
@@ -0,0 +1,312 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TRACE_H
+# define OPENSSL_TRACE_H
+# pragma once
+
+# include <stdarg.h>
+
+# include <openssl/bio.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * TRACE CATEGORIES
+ */
+
+/*
+ * The trace messages of the OpenSSL libraries are organized into different
+ * categories. For every trace category, the application can register a separate
+ * tracer callback. When a callback is registered, a so called trace channel is
+ * created for this category. This channel consists essentially of an internal
+ * BIO which sends all trace output it receives to the registered application
+ * callback.
+ *
+ * The ALL category can be used as a fallback category to register a single
+ * channel which receives the output from all categories. However, if the
+ * application intends to print the trace channel name in the line prefix,
+ * it is better to register channels for all categories separately.
+ * (This is how the openssl application does it.)
+ */
+# define OSSL_TRACE_CATEGORY_ALL                 0 /* The fallback */
+# define OSSL_TRACE_CATEGORY_TRACE               1
+# define OSSL_TRACE_CATEGORY_INIT                2
+# define OSSL_TRACE_CATEGORY_TLS                 3
+# define OSSL_TRACE_CATEGORY_TLS_CIPHER          4
+# define OSSL_TRACE_CATEGORY_CONF                5
+# ifndef OPENSSL_NO_ENGINE
+#  define OSSL_TRACE_CATEGORY_ENGINE_TABLE       6
+#  define OSSL_TRACE_CATEGORY_ENGINE_REF_COUNT   7
+# endif
+# define OSSL_TRACE_CATEGORY_PKCS5V2             8
+# define OSSL_TRACE_CATEGORY_PKCS12_KEYGEN       9
+# define OSSL_TRACE_CATEGORY_PKCS12_DECRYPT     10
+# define OSSL_TRACE_CATEGORY_X509V3_POLICY      11
+# define OSSL_TRACE_CATEGORY_BN_CTX             12
+# define OSSL_TRACE_CATEGORY_CMP                13
+# define OSSL_TRACE_CATEGORY_STORE              14
+# define OSSL_TRACE_CATEGORY_DECODER            15
+# define OSSL_TRACE_CATEGORY_ENCODER            16
+# define OSSL_TRACE_CATEGORY_REF_COUNT          17
+/* Count of available categories. */
+# define OSSL_TRACE_CATEGORY_NUM                18
+
+/* Returns the trace category number for the given |name| */
+int OSSL_trace_get_category_num(const char *name);
+
+/* Returns the trace category name for the given |num| */
+const char *OSSL_trace_get_category_name(int num);
+
+/*
+ * TRACE CONSUMERS
+ */
+
+/*
+ * Enables tracing for the given |category| by providing a BIO sink
+ * as |channel|. If a null pointer is passed as |channel|, an existing
+ * trace channel is removed and tracing for the category is disabled.
+ *
+ * Returns 1 on success and 0 on failure
+ */
+int OSSL_trace_set_channel(int category, BIO* channel);
+
+/*
+ * Attach a prefix and a suffix to the given |category|, to be printed at the
+ * beginning and at the end of each trace output group, i.e. when
+ * OSSL_trace_begin() and OSSL_trace_end() are called.
+ * If a null pointer is passed as argument, the existing prefix or suffix is
+ * removed.
+ *
+ * They return 1 on success and 0 on failure
+ */
+int OSSL_trace_set_prefix(int category, const char *prefix);
+int OSSL_trace_set_suffix(int category, const char *suffix);
+
+/*
+ * OSSL_trace_cb is the type tracing callback provided by the application.
+ * It MUST return the number of bytes written, or 0 on error (in other words,
+ * it can never write zero bytes).
+ *
+ * The |buffer| will always contain text, which may consist of several lines.
+ * The |data| argument points to whatever data was provided by the application
+ * when registering the tracer function.
+ *
+ * The |category| number is given, as well as a |cmd| number, described below.
+ */
+typedef size_t (*OSSL_trace_cb)(const char *buffer, size_t count,
+                                int category, int cmd, void *data);
+/*
+ * Possible |cmd| numbers.
+ */
+# define OSSL_TRACE_CTRL_BEGIN  0
+# define OSSL_TRACE_CTRL_WRITE  1
+# define OSSL_TRACE_CTRL_END    2
+
+/*
+ * Enables tracing for the given |category| by creating an internal
+ * trace channel which sends the output to the given |callback|.
+ * If a null pointer is passed as callback, an existing trace channel
+ * is removed and tracing for the category is disabled.
+ *
+ * NOTE: OSSL_trace_set_channel() and OSSL_trace_set_callback() are mutually
+ *       exclusive.
+ *
+ * Returns 1 on success and 0 on failure
+ */
+int OSSL_trace_set_callback(int category, OSSL_trace_cb callback, void *data);
+
+/*
+ * TRACE PRODUCERS
+ */
+
+/*
+ * Returns 1 if tracing for the specified category is enabled, otherwise 0
+ */
+int OSSL_trace_enabled(int category);
+
+/*
+ * Wrap a group of tracing output calls.  OSSL_trace_begin() locks tracing and
+ * returns the trace channel associated with the given category, or NULL if no
+ * channel is associated with the category.  OSSL_trace_end() unlocks tracing.
+ *
+ * Usage:
+ *
+ *    BIO *out;
+ *    if ((out = OSSL_trace_begin(category)) != NULL) {
+ *        ...
+ *        BIO_fprintf(out, ...);
+ *        ...
+ *        OSSL_trace_end(category, out);
+ *    }
+ *
+ * See also the convenience macros OSSL_TRACE_BEGIN and OSSL_TRACE_END below.
+ */
+BIO *OSSL_trace_begin(int category);
+void OSSL_trace_end(int category, BIO *channel);
+
+/*
+ * OSSL_TRACE* Convenience Macros
+ */
+
+/*
+ * When the tracing feature is disabled, these macros are defined to
+ * produce dead code, which a good compiler should eliminate.
+ */
+
+/*
+ * OSSL_TRACE_BEGIN, OSSL_TRACE_END - Define a Trace Group
+ *
+ * These two macros can be used to create a block which is executed only
+ * if the corresponding trace category is enabled. Inside this block, a
+ * local variable named |trc_out| is defined, which points to the channel
+ * associated with the given trace category.
+ *
+ * Usage: (using 'TLS' as an example category)
+ *
+ *     OSSL_TRACE_BEGIN(TLS) {
+ *
+ *         BIO_fprintf(trc_out, ... );
+ *
+ *     } OSSL_TRACE_END(TLS);
+ *
+ *
+ * This expands to the following code
+ *
+ *     do {
+ *         BIO *trc_out = OSSL_trace_begin(OSSL_TRACE_CATEGORY_TLS);
+ *         if (trc_out != NULL) {
+ *             ...
+ *             BIO_fprintf(trc_out, ...);
+ *         }
+ *         OSSL_trace_end(OSSL_TRACE_CATEGORY_TLS, trc_out);
+ *     } while (0);
+ *
+ * The use of the inner '{...}' group and the trailing ';' is enforced
+ * by the definition of the macros in order to make the code look as much
+ * like C code as possible.
+ *
+ * Before returning from inside the trace block, it is necessary to
+ * call OSSL_TRACE_CANCEL(category).
+ */
+
+# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+
+#  define OSSL_TRACE_BEGIN(category) \
+    do { \
+        BIO *trc_out = OSSL_trace_begin(OSSL_TRACE_CATEGORY_##category); \
+ \
+        if (trc_out != NULL)
+
+#  define OSSL_TRACE_END(category) \
+        OSSL_trace_end(OSSL_TRACE_CATEGORY_##category, trc_out); \
+    } while (0)
+
+#  define OSSL_TRACE_CANCEL(category) \
+        OSSL_trace_end(OSSL_TRACE_CATEGORY_##category, trc_out) \
+
+# else
+
+#  define OSSL_TRACE_BEGIN(category)           \
+    do {                                        \
+        BIO *trc_out = NULL;                    \
+        if (0)
+
+#  define OSSL_TRACE_END(category)             \
+    } while(0)
+
+#  define OSSL_TRACE_CANCEL(category)          \
+    ((void)0)
+
+# endif
+
+/*
+ * OSSL_TRACE_ENABLED() - Check whether tracing is enabled for |category|
+ *
+ * Usage:
+ *
+ *     if (OSSL_TRACE_ENABLED(TLS)) {
+ *         ...
+ *     }
+ */
+# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+
+#  define OSSL_TRACE_ENABLED(category) \
+    OSSL_trace_enabled(OSSL_TRACE_CATEGORY_##category)
+
+# else
+
+#  define OSSL_TRACE_ENABLED(category) (0)
+
+# endif
+
+/*
+ * OSSL_TRACE*() - OneShot Trace Macros
+ *
+ * These macros are intended to produce a simple printf-style trace output.
+ * Unfortunately, C90 macros don't support variable arguments, so the
+ * "vararg" OSSL_TRACEV() macro has a rather weird usage pattern:
+ *
+ *    OSSL_TRACEV(category, (trc_out, "format string", ...args...));
+ *
+ * Where 'channel' is the literal symbol of this name, not a variable.
+ * For that reason, it is currently not intended to be used directly,
+ * but only as helper macro for the other oneshot trace macros
+ * OSSL_TRACE(), OSSL_TRACE1(), OSSL_TRACE2(), ...
+ *
+ * Usage:
+ *
+ *    OSSL_TRACE(INIT, "Hello world!\n");
+ *    OSSL_TRACE1(TLS, "The answer is %d\n", 42);
+ *    OSSL_TRACE2(TLS, "The ultimate question to answer %d is '%s'\n",
+ *                42, "What do you get when you multiply six by nine?");
+ */
+
+# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+
+#  define OSSL_TRACEV(category, args) \
+    OSSL_TRACE_BEGIN(category) \
+        BIO_printf args; \
+    OSSL_TRACE_END(category)
+
+# else
+
+#  define OSSL_TRACEV(category, args) ((void)0)
+
+# endif
+
+# define OSSL_TRACE(category, text) \
+    OSSL_TRACEV(category, (trc_out, "%s", text))
+
+# define OSSL_TRACE1(category, format, arg1) \
+    OSSL_TRACEV(category, (trc_out, format, arg1))
+# define OSSL_TRACE2(category, format, arg1, arg2) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2))
+# define OSSL_TRACE3(category, format, arg1, arg2, arg3) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3))
+# define OSSL_TRACE4(category, format, arg1, arg2, arg3, arg4) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4))
+# define OSSL_TRACE5(category, format, arg1, arg2, arg3, arg4, arg5) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5))
+# define OSSL_TRACE6(category, format, arg1, arg2, arg3, arg4, arg5, arg6) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6))
+# define OSSL_TRACE7(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7))
+# define OSSL_TRACE8(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8))
+# define OSSL_TRACE9(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
+    OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9))
+
+# ifdef  __cplusplus
+}
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/ts.h b/CAPI/cpp/grpc/include/openssl/ts.h
new file mode 100644
index 0000000..5136e4e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ts.h
@@ -0,0 +1,503 @@
+/*
+ * Copyright 2006-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TS_H
+# define OPENSSL_TS_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_TS_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_TS
+# include <openssl/symhacks.h>
+# include <openssl/buffer.h>
+# include <openssl/evp.h>
+# include <openssl/bio.h>
+# include <openssl/asn1.h>
+# include <openssl/safestack.h>
+# include <openssl/rsa.h>
+# include <openssl/dsa.h>
+# include <openssl/dh.h>
+# include <openssl/tserr.h>
+# include <openssl/ess.h>
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# include <openssl/x509.h>
+# include <openssl/x509v3.h>
+
+typedef struct TS_msg_imprint_st TS_MSG_IMPRINT;
+typedef struct TS_req_st TS_REQ;
+typedef struct TS_accuracy_st TS_ACCURACY;
+typedef struct TS_tst_info_st TS_TST_INFO;
+
+/* Possible values for status. */
+# define TS_STATUS_GRANTED                       0
+# define TS_STATUS_GRANTED_WITH_MODS             1
+# define TS_STATUS_REJECTION                     2
+# define TS_STATUS_WAITING                       3
+# define TS_STATUS_REVOCATION_WARNING            4
+# define TS_STATUS_REVOCATION_NOTIFICATION       5
+
+/* Possible values for failure_info. */
+# define TS_INFO_BAD_ALG                 0
+# define TS_INFO_BAD_REQUEST             2
+# define TS_INFO_BAD_DATA_FORMAT         5
+# define TS_INFO_TIME_NOT_AVAILABLE      14
+# define TS_INFO_UNACCEPTED_POLICY       15
+# define TS_INFO_UNACCEPTED_EXTENSION    16
+# define TS_INFO_ADD_INFO_NOT_AVAILABLE  17
+# define TS_INFO_SYSTEM_FAILURE          25
+
+
+typedef struct TS_status_info_st TS_STATUS_INFO;
+
+typedef struct TS_resp_st TS_RESP;
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_REQ)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_REQ, TS_REQ)
+DECLARE_ASN1_DUP_FUNCTION(TS_REQ)
+
+#ifndef OPENSSL_NO_STDIO
+TS_REQ *d2i_TS_REQ_fp(FILE *fp, TS_REQ **a);
+int i2d_TS_REQ_fp(FILE *fp, const TS_REQ *a);
+#endif
+TS_REQ *d2i_TS_REQ_bio(BIO *fp, TS_REQ **a);
+int i2d_TS_REQ_bio(BIO *fp, const TS_REQ *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_MSG_IMPRINT)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_MSG_IMPRINT, TS_MSG_IMPRINT)
+DECLARE_ASN1_DUP_FUNCTION(TS_MSG_IMPRINT)
+
+#ifndef OPENSSL_NO_STDIO
+TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a);
+int i2d_TS_MSG_IMPRINT_fp(FILE *fp, const TS_MSG_IMPRINT *a);
+#endif
+TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_bio(BIO *bio, TS_MSG_IMPRINT **a);
+int i2d_TS_MSG_IMPRINT_bio(BIO *bio, const TS_MSG_IMPRINT *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_RESP)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_RESP, TS_RESP)
+DECLARE_ASN1_DUP_FUNCTION(TS_RESP)
+
+#ifndef OPENSSL_NO_STDIO
+TS_RESP *d2i_TS_RESP_fp(FILE *fp, TS_RESP **a);
+int i2d_TS_RESP_fp(FILE *fp, const TS_RESP *a);
+#endif
+TS_RESP *d2i_TS_RESP_bio(BIO *bio, TS_RESP **a);
+int i2d_TS_RESP_bio(BIO *bio, const TS_RESP *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_STATUS_INFO)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_STATUS_INFO, TS_STATUS_INFO)
+DECLARE_ASN1_DUP_FUNCTION(TS_STATUS_INFO)
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_TST_INFO)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_TST_INFO, TS_TST_INFO)
+DECLARE_ASN1_DUP_FUNCTION(TS_TST_INFO)
+TS_TST_INFO *PKCS7_to_TS_TST_INFO(PKCS7 *token);
+
+#ifndef OPENSSL_NO_STDIO
+TS_TST_INFO *d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a);
+int i2d_TS_TST_INFO_fp(FILE *fp, const TS_TST_INFO *a);
+#endif
+TS_TST_INFO *d2i_TS_TST_INFO_bio(BIO *bio, TS_TST_INFO **a);
+int i2d_TS_TST_INFO_bio(BIO *bio, const TS_TST_INFO *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TS_ACCURACY)
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_ACCURACY, TS_ACCURACY)
+DECLARE_ASN1_DUP_FUNCTION(TS_ACCURACY)
+
+int TS_REQ_set_version(TS_REQ *a, long version);
+long TS_REQ_get_version(const TS_REQ *a);
+
+int TS_STATUS_INFO_set_status(TS_STATUS_INFO *a, int i);
+const ASN1_INTEGER *TS_STATUS_INFO_get0_status(const TS_STATUS_INFO *a);
+
+const STACK_OF(ASN1_UTF8STRING) *
+TS_STATUS_INFO_get0_text(const TS_STATUS_INFO *a);
+
+const ASN1_BIT_STRING *
+TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO *a);
+
+int TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint);
+TS_MSG_IMPRINT *TS_REQ_get_msg_imprint(TS_REQ *a);
+
+int TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg);
+X509_ALGOR *TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a);
+
+int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len);
+ASN1_OCTET_STRING *TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a);
+
+int TS_REQ_set_policy_id(TS_REQ *a, const ASN1_OBJECT *policy);
+ASN1_OBJECT *TS_REQ_get_policy_id(TS_REQ *a);
+
+int TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce);
+const ASN1_INTEGER *TS_REQ_get_nonce(const TS_REQ *a);
+
+int TS_REQ_set_cert_req(TS_REQ *a, int cert_req);
+int TS_REQ_get_cert_req(const TS_REQ *a);
+
+STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a);
+void TS_REQ_ext_free(TS_REQ *a);
+int TS_REQ_get_ext_count(TS_REQ *a);
+int TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos);
+int TS_REQ_get_ext_by_OBJ(TS_REQ *a, const ASN1_OBJECT *obj, int lastpos);
+int TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos);
+X509_EXTENSION *TS_REQ_get_ext(TS_REQ *a, int loc);
+X509_EXTENSION *TS_REQ_delete_ext(TS_REQ *a, int loc);
+int TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc);
+void *TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx);
+
+/* Function declarations for TS_REQ defined in ts/ts_req_print.c */
+
+int TS_REQ_print_bio(BIO *bio, TS_REQ *a);
+
+/* Function declarations for TS_RESP defined in ts/ts_resp_utils.c */
+
+int TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *info);
+TS_STATUS_INFO *TS_RESP_get_status_info(TS_RESP *a);
+
+/* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */
+void TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info);
+PKCS7 *TS_RESP_get_token(TS_RESP *a);
+TS_TST_INFO *TS_RESP_get_tst_info(TS_RESP *a);
+
+int TS_TST_INFO_set_version(TS_TST_INFO *a, long version);
+long TS_TST_INFO_get_version(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy_id);
+ASN1_OBJECT *TS_TST_INFO_get_policy_id(TS_TST_INFO *a);
+
+int TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint);
+TS_MSG_IMPRINT *TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a);
+
+int TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial);
+const ASN1_INTEGER *TS_TST_INFO_get_serial(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime);
+const ASN1_GENERALIZEDTIME *TS_TST_INFO_get_time(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy);
+TS_ACCURACY *TS_TST_INFO_get_accuracy(TS_TST_INFO *a);
+
+int TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds);
+const ASN1_INTEGER *TS_ACCURACY_get_seconds(const TS_ACCURACY *a);
+
+int TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis);
+const ASN1_INTEGER *TS_ACCURACY_get_millis(const TS_ACCURACY *a);
+
+int TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros);
+const ASN1_INTEGER *TS_ACCURACY_get_micros(const TS_ACCURACY *a);
+
+int TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering);
+int TS_TST_INFO_get_ordering(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce);
+const ASN1_INTEGER *TS_TST_INFO_get_nonce(const TS_TST_INFO *a);
+
+int TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa);
+GENERAL_NAME *TS_TST_INFO_get_tsa(TS_TST_INFO *a);
+
+STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a);
+void TS_TST_INFO_ext_free(TS_TST_INFO *a);
+int TS_TST_INFO_get_ext_count(TS_TST_INFO *a);
+int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos);
+int TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, const ASN1_OBJECT *obj,
+                               int lastpos);
+int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos);
+X509_EXTENSION *TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc);
+X509_EXTENSION *TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc);
+int TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc);
+void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx);
+
+/*
+ * Declarations related to response generation, defined in ts/ts_resp_sign.c.
+ */
+
+/* Optional flags for response generation. */
+
+/* Don't include the TSA name in response. */
+# define TS_TSA_NAME             0x01
+
+/* Set ordering to true in response. */
+# define TS_ORDERING             0x02
+
+/*
+ * Include the signer certificate and the other specified certificates in
+ * the ESS signing certificate attribute beside the PKCS7 signed data.
+ * Only the signer certificates is included by default.
+ */
+# define TS_ESS_CERT_ID_CHAIN    0x04
+
+/* Forward declaration. */
+struct TS_resp_ctx;
+
+/* This must return a unique number less than 160 bits long. */
+typedef ASN1_INTEGER *(*TS_serial_cb) (struct TS_resp_ctx *, void *);
+
+/*
+ * This must return the seconds and microseconds since Jan 1, 1970 in the sec
+ * and usec variables allocated by the caller. Return non-zero for success
+ * and zero for failure.
+ */
+typedef int (*TS_time_cb) (struct TS_resp_ctx *, void *, long *sec,
+                           long *usec);
+
+/*
+ * This must process the given extension. It can modify the TS_TST_INFO
+ * object of the context. Return values: !0 (processed), 0 (error, it must
+ * set the status info/failure info of the response).
+ */
+typedef int (*TS_extension_cb) (struct TS_resp_ctx *, X509_EXTENSION *,
+                                void *);
+
+typedef struct TS_resp_ctx TS_RESP_CTX;
+
+/* Creates a response context that can be used for generating responses. */
+TS_RESP_CTX *TS_RESP_CTX_new(void);
+TS_RESP_CTX *TS_RESP_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+void TS_RESP_CTX_free(TS_RESP_CTX *ctx);
+
+/* This parameter must be set. */
+int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer);
+
+/* This parameter must be set. */
+int TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key);
+
+int TS_RESP_CTX_set_signer_digest(TS_RESP_CTX *ctx,
+                                  const EVP_MD *signer_digest);
+int TS_RESP_CTX_set_ess_cert_id_digest(TS_RESP_CTX *ctx, const EVP_MD *md);
+
+/* This parameter must be set. */
+int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *def_policy);
+
+/* No additional certs are included in the response by default. */
+int TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs);
+
+/*
+ * Adds a new acceptable policy, only the default policy is accepted by
+ * default.
+ */
+int TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *policy);
+
+/*
+ * Adds a new acceptable message digest. Note that no message digests are
+ * accepted by default. The md argument is shared with the caller.
+ */
+int TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md);
+
+/* Accuracy is not included by default. */
+int TS_RESP_CTX_set_accuracy(TS_RESP_CTX *ctx,
+                             int secs, int millis, int micros);
+
+/*
+ * Clock precision digits, i.e. the number of decimal digits: '0' means sec,
+ * '3' msec, '6' usec, and so on. Default is 0.
+ */
+int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx,
+                                           unsigned clock_precision_digits);
+/* At most we accept usec precision. */
+# define TS_MAX_CLOCK_PRECISION_DIGITS   6
+
+/* Maximum status message length */
+# define TS_MAX_STATUS_LENGTH   (1024 * 1024)
+
+/* No flags are set by default. */
+void TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags);
+
+/* Default callback always returns a constant. */
+void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data);
+
+/* Default callback uses the gettimeofday() and gmtime() system calls. */
+void TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data);
+
+/*
+ * Default callback rejects all extensions. The extension callback is called
+ * when the TS_TST_INFO object is already set up and not signed yet.
+ */
+/* FIXME: extension handling is not tested yet. */
+void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx,
+                                  TS_extension_cb cb, void *data);
+
+/* The following methods can be used in the callbacks. */
+int TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx,
+                                int status, const char *text);
+
+/* Sets the status info only if it is still TS_STATUS_GRANTED. */
+int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx,
+                                     int status, const char *text);
+
+int TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure);
+
+/* The get methods below can be used in the extension callback. */
+TS_REQ *TS_RESP_CTX_get_request(TS_RESP_CTX *ctx);
+
+TS_TST_INFO *TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx);
+
+/*
+ * Creates the signed TS_TST_INFO and puts it in TS_RESP.
+ * In case of errors it sets the status info properly.
+ * Returns NULL only in case of memory allocation/fatal error.
+ */
+TS_RESP *TS_RESP_create_response(TS_RESP_CTX *ctx, BIO *req_bio);
+
+/*
+ * Declarations related to response verification,
+ * they are defined in ts/ts_resp_verify.c.
+ */
+
+int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,
+                             X509_STORE *store, X509 **signer_out);
+
+/* Context structure for the generic verify method. */
+
+/* Verify the signer's certificate and the signature of the response. */
+# define TS_VFY_SIGNATURE        (1u << 0)
+/* Verify the version number of the response. */
+# define TS_VFY_VERSION          (1u << 1)
+/* Verify if the policy supplied by the user matches the policy of the TSA. */
+# define TS_VFY_POLICY           (1u << 2)
+/*
+ * Verify the message imprint provided by the user. This flag should not be
+ * specified with TS_VFY_DATA.
+ */
+# define TS_VFY_IMPRINT          (1u << 3)
+/*
+ * Verify the message imprint computed by the verify method from the user
+ * provided data and the MD algorithm of the response. This flag should not
+ * be specified with TS_VFY_IMPRINT.
+ */
+# define TS_VFY_DATA             (1u << 4)
+/* Verify the nonce value. */
+# define TS_VFY_NONCE            (1u << 5)
+/* Verify if the TSA name field matches the signer certificate. */
+# define TS_VFY_SIGNER           (1u << 6)
+/* Verify if the TSA name field equals to the user provided name. */
+# define TS_VFY_TSA_NAME         (1u << 7)
+
+/* You can use the following convenience constants. */
+# define TS_VFY_ALL_IMPRINT      (TS_VFY_SIGNATURE       \
+                                 | TS_VFY_VERSION       \
+                                 | TS_VFY_POLICY        \
+                                 | TS_VFY_IMPRINT       \
+                                 | TS_VFY_NONCE         \
+                                 | TS_VFY_SIGNER        \
+                                 | TS_VFY_TSA_NAME)
+# define TS_VFY_ALL_DATA         (TS_VFY_SIGNATURE       \
+                                 | TS_VFY_VERSION       \
+                                 | TS_VFY_POLICY        \
+                                 | TS_VFY_DATA          \
+                                 | TS_VFY_NONCE         \
+                                 | TS_VFY_SIGNER        \
+                                 | TS_VFY_TSA_NAME)
+
+typedef struct TS_verify_ctx TS_VERIFY_CTX;
+
+int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response);
+int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token);
+
+/*
+ * Declarations related to response verification context,
+ */
+TS_VERIFY_CTX *TS_VERIFY_CTX_new(void);
+void TS_VERIFY_CTX_init(TS_VERIFY_CTX *ctx);
+void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx);
+void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx);
+int TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int f);
+int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int f);
+BIO *TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *b);
+unsigned char *TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx,
+                                         unsigned char *hexstr, long len);
+X509_STORE *TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *s);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define TS_VERIFY_CTS_set_certs(ctx, cert) TS_VERIFY_CTX_set_certs(ctx,cert)
+# endif
+STACK_OF(X509) *TS_VERIFY_CTX_set_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs);
+
+/*-
+ * If ctx is NULL, it allocates and returns a new object, otherwise
+ * it returns ctx. It initialises all the members as follows:
+ * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE)
+ * certs = NULL
+ * store = NULL
+ * policy = policy from the request or NULL if absent (in this case
+ *      TS_VFY_POLICY is cleared from flags as well)
+ * md_alg = MD algorithm from request
+ * imprint, imprint_len = imprint from request
+ * data = NULL
+ * nonce, nonce_len = nonce from the request or NULL if absent (in this case
+ *      TS_VFY_NONCE is cleared from flags as well)
+ * tsa_name = NULL
+ * Important: after calling this method TS_VFY_SIGNATURE should be added!
+ */
+TS_VERIFY_CTX *TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx);
+
+/* Function declarations for TS_RESP defined in ts/ts_resp_print.c */
+
+int TS_RESP_print_bio(BIO *bio, TS_RESP *a);
+int TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a);
+int TS_TST_INFO_print_bio(BIO *bio, TS_TST_INFO *a);
+
+/* Common utility functions defined in ts/ts_lib.c */
+
+int TS_ASN1_INTEGER_print_bio(BIO *bio, const ASN1_INTEGER *num);
+int TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj);
+int TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions);
+int TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg);
+int TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *msg);
+
+/*
+ * Function declarations for handling configuration options, defined in
+ * ts/ts_conf.c
+ */
+
+X509 *TS_CONF_load_cert(const char *file);
+STACK_OF(X509) *TS_CONF_load_certs(const char *file);
+EVP_PKEY *TS_CONF_load_key(const char *file, const char *pass);
+const char *TS_CONF_get_tsa_section(CONF *conf, const char *section);
+int TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb,
+                       TS_RESP_CTX *ctx);
+#ifndef OPENSSL_NO_ENGINE
+int TS_CONF_set_crypto_device(CONF *conf, const char *section,
+                              const char *device);
+int TS_CONF_set_default_engine(const char *name);
+#endif
+int TS_CONF_set_signer_cert(CONF *conf, const char *section,
+                            const char *cert, TS_RESP_CTX *ctx);
+int TS_CONF_set_certs(CONF *conf, const char *section, const char *certs,
+                      TS_RESP_CTX *ctx);
+int TS_CONF_set_signer_key(CONF *conf, const char *section,
+                           const char *key, const char *pass,
+                           TS_RESP_CTX *ctx);
+int TS_CONF_set_signer_digest(CONF *conf, const char *section,
+                               const char *md, TS_RESP_CTX *ctx);
+int TS_CONF_set_def_policy(CONF *conf, const char *section,
+                           const char *policy, TS_RESP_CTX *ctx);
+int TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_clock_precision_digits(const CONF *conf, const char *section,
+                                       TS_RESP_CTX *ctx);
+int TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx);
+int TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section,
+                                  TS_RESP_CTX *ctx);
+int TS_CONF_set_ess_cert_id_digest(CONF *conf, const char *section,
+                                      TS_RESP_CTX *ctx);
+
+#  ifdef  __cplusplus
+}
+#  endif
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/tserr.h b/CAPI/cpp/grpc/include/openssl/tserr.h
new file mode 100644
index 0000000..e1b943e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/tserr.h
@@ -0,0 +1,67 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TSERR_H
+# define OPENSSL_TSERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+# ifndef OPENSSL_NO_TS
+
+
+/*
+ * TS reason codes.
+ */
+#  define TS_R_BAD_PKCS7_TYPE                              132
+#  define TS_R_BAD_TYPE                                    133
+#  define TS_R_CANNOT_LOAD_CERT                            137
+#  define TS_R_CANNOT_LOAD_KEY                             138
+#  define TS_R_CERTIFICATE_VERIFY_ERROR                    100
+#  define TS_R_COULD_NOT_SET_ENGINE                        127
+#  define TS_R_COULD_NOT_SET_TIME                          115
+#  define TS_R_DETACHED_CONTENT                            134
+#  define TS_R_ESS_ADD_SIGNING_CERT_ERROR                  116
+#  define TS_R_ESS_ADD_SIGNING_CERT_V2_ERROR               139
+#  define TS_R_ESS_SIGNING_CERTIFICATE_ERROR               101
+#  define TS_R_INVALID_NULL_POINTER                        102
+#  define TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE          117
+#  define TS_R_MESSAGE_IMPRINT_MISMATCH                    103
+#  define TS_R_NONCE_MISMATCH                              104
+#  define TS_R_NONCE_NOT_RETURNED                          105
+#  define TS_R_NO_CONTENT                                  106
+#  define TS_R_NO_TIME_STAMP_TOKEN                         107
+#  define TS_R_PKCS7_ADD_SIGNATURE_ERROR                   118
+#  define TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR                 119
+#  define TS_R_PKCS7_TO_TS_TST_INFO_FAILED                 129
+#  define TS_R_POLICY_MISMATCH                             108
+#  define TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE      120
+#  define TS_R_RESPONSE_SETUP_ERROR                        121
+#  define TS_R_SIGNATURE_FAILURE                           109
+#  define TS_R_THERE_MUST_BE_ONE_SIGNER                    110
+#  define TS_R_TIME_SYSCALL_ERROR                          122
+#  define TS_R_TOKEN_NOT_PRESENT                           130
+#  define TS_R_TOKEN_PRESENT                               131
+#  define TS_R_TSA_NAME_MISMATCH                           111
+#  define TS_R_TSA_UNTRUSTED                               112
+#  define TS_R_TST_INFO_SETUP_ERROR                        123
+#  define TS_R_TS_DATASIGN                                 124
+#  define TS_R_UNACCEPTABLE_POLICY                         125
+#  define TS_R_UNSUPPORTED_MD_ALGORITHM                    126
+#  define TS_R_UNSUPPORTED_VERSION                         113
+#  define TS_R_VAR_BAD_VALUE                               135
+#  define TS_R_VAR_LOOKUP_FAILURE                          136
+#  define TS_R_WRONG_CONTENT_TYPE                          114
+
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/txt_db.h b/CAPI/cpp/grpc/include/openssl/txt_db.h
new file mode 100644
index 0000000..af169a3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/txt_db.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TXT_DB_H
+# define OPENSSL_TXT_DB_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_TXT_DB_H
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/bio.h>
+# include <openssl/safestack.h>
+# include <openssl/lhash.h>
+
+# define DB_ERROR_OK                     0
+# define DB_ERROR_MALLOC                 1
+# define DB_ERROR_INDEX_CLASH            2
+# define DB_ERROR_INDEX_OUT_OF_RANGE     3
+# define DB_ERROR_NO_INDEX               4
+# define DB_ERROR_INSERT_INDEX_CLASH     5
+# define DB_ERROR_WRONG_NUM_FIELDS       6
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef OPENSSL_STRING *OPENSSL_PSTRING;
+DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
+
+typedef struct txt_db_st {
+    int num_fields;
+    STACK_OF(OPENSSL_PSTRING) *data;
+    LHASH_OF(OPENSSL_STRING) **index;
+    int (**qual) (OPENSSL_STRING *);
+    long error;
+    long arg1;
+    long arg2;
+    OPENSSL_STRING *arg_row;
+} TXT_DB;
+
+TXT_DB *TXT_DB_read(BIO *in, int num);
+long TXT_DB_write(BIO *out, TXT_DB *db);
+int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *),
+                        OPENSSL_LH_HASHFUNC hash, OPENSSL_LH_COMPFUNC cmp);
+void TXT_DB_free(TXT_DB *db);
+OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx,
+                                    OPENSSL_STRING *value);
+int TXT_DB_insert(TXT_DB *db, OPENSSL_STRING *value);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/types.h b/CAPI/cpp/grpc/include/openssl/types.h
new file mode 100644
index 0000000..de9f166
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/types.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright 2001-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_TYPES_H
+# define OPENSSL_TYPES_H
+# pragma once
+
+# include <limits.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/safestack.h>
+# include <openssl/macros.h>
+
+typedef struct ossl_provider_st OSSL_PROVIDER; /* Provider Object */
+
+# ifdef NO_ASN1_TYPEDEFS
+#  define ASN1_INTEGER            ASN1_STRING
+#  define ASN1_ENUMERATED         ASN1_STRING
+#  define ASN1_BIT_STRING         ASN1_STRING
+#  define ASN1_OCTET_STRING       ASN1_STRING
+#  define ASN1_PRINTABLESTRING    ASN1_STRING
+#  define ASN1_T61STRING          ASN1_STRING
+#  define ASN1_IA5STRING          ASN1_STRING
+#  define ASN1_UTCTIME            ASN1_STRING
+#  define ASN1_GENERALIZEDTIME    ASN1_STRING
+#  define ASN1_TIME               ASN1_STRING
+#  define ASN1_GENERALSTRING      ASN1_STRING
+#  define ASN1_UNIVERSALSTRING    ASN1_STRING
+#  define ASN1_BMPSTRING          ASN1_STRING
+#  define ASN1_VISIBLESTRING      ASN1_STRING
+#  define ASN1_UTF8STRING         ASN1_STRING
+#  define ASN1_BOOLEAN            int
+#  define ASN1_NULL               int
+# else
+typedef struct asn1_string_st ASN1_INTEGER;
+typedef struct asn1_string_st ASN1_ENUMERATED;
+typedef struct asn1_string_st ASN1_BIT_STRING;
+typedef struct asn1_string_st ASN1_OCTET_STRING;
+typedef struct asn1_string_st ASN1_PRINTABLESTRING;
+typedef struct asn1_string_st ASN1_T61STRING;
+typedef struct asn1_string_st ASN1_IA5STRING;
+typedef struct asn1_string_st ASN1_GENERALSTRING;
+typedef struct asn1_string_st ASN1_UNIVERSALSTRING;
+typedef struct asn1_string_st ASN1_BMPSTRING;
+typedef struct asn1_string_st ASN1_UTCTIME;
+typedef struct asn1_string_st ASN1_TIME;
+typedef struct asn1_string_st ASN1_GENERALIZEDTIME;
+typedef struct asn1_string_st ASN1_VISIBLESTRING;
+typedef struct asn1_string_st ASN1_UTF8STRING;
+typedef struct asn1_string_st ASN1_STRING;
+typedef int ASN1_BOOLEAN;
+typedef int ASN1_NULL;
+# endif
+
+typedef struct asn1_type_st ASN1_TYPE;
+typedef struct asn1_object_st ASN1_OBJECT;
+typedef struct asn1_string_table_st ASN1_STRING_TABLE;
+
+typedef struct ASN1_ITEM_st ASN1_ITEM;
+typedef struct asn1_pctx_st ASN1_PCTX;
+typedef struct asn1_sctx_st ASN1_SCTX;
+
+# ifdef _WIN32
+#  undef X509_NAME
+#  undef X509_EXTENSIONS
+#  undef PKCS7_ISSUER_AND_SERIAL
+#  undef PKCS7_SIGNER_INFO
+#  undef OCSP_REQUEST
+#  undef OCSP_RESPONSE
+# endif
+
+# ifdef BIGNUM
+#  undef BIGNUM
+# endif
+
+typedef struct bio_st BIO;
+typedef struct bignum_st BIGNUM;
+typedef struct bignum_ctx BN_CTX;
+typedef struct bn_blinding_st BN_BLINDING;
+typedef struct bn_mont_ctx_st BN_MONT_CTX;
+typedef struct bn_recp_ctx_st BN_RECP_CTX;
+typedef struct bn_gencb_st BN_GENCB;
+
+typedef struct buf_mem_st BUF_MEM;
+
+STACK_OF(BIGNUM);
+STACK_OF(BIGNUM_const);
+
+typedef struct err_state_st ERR_STATE;
+
+typedef struct evp_cipher_st EVP_CIPHER;
+typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
+typedef struct evp_md_st EVP_MD;
+typedef struct evp_md_ctx_st EVP_MD_CTX;
+typedef struct evp_mac_st EVP_MAC;
+typedef struct evp_mac_ctx_st EVP_MAC_CTX;
+typedef struct evp_pkey_st EVP_PKEY;
+
+typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD;
+
+typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
+typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
+
+typedef struct evp_keymgmt_st EVP_KEYMGMT;
+
+typedef struct evp_kdf_st EVP_KDF;
+typedef struct evp_kdf_ctx_st EVP_KDF_CTX;
+
+typedef struct evp_rand_st EVP_RAND;
+typedef struct evp_rand_ctx_st EVP_RAND_CTX;
+
+typedef struct evp_keyexch_st EVP_KEYEXCH;
+
+typedef struct evp_signature_st EVP_SIGNATURE;
+
+typedef struct evp_asym_cipher_st EVP_ASYM_CIPHER;
+
+typedef struct evp_kem_st EVP_KEM;
+
+typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX;
+
+typedef struct hmac_ctx_st HMAC_CTX;
+
+typedef struct dh_st DH;
+typedef struct dh_method DH_METHOD;
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct dsa_st DSA;
+typedef struct dsa_method DSA_METHOD;
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct rsa_st RSA;
+typedef struct rsa_meth_st RSA_METHOD;
+# endif
+typedef struct rsa_pss_params_st RSA_PSS_PARAMS;
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+typedef struct ec_key_st EC_KEY;
+typedef struct ec_key_method_st EC_KEY_METHOD;
+# endif
+
+typedef struct rand_meth_st RAND_METHOD;
+typedef struct rand_drbg_st RAND_DRBG;
+
+typedef struct ssl_dane_st SSL_DANE;
+typedef struct x509_st X509;
+typedef struct X509_algor_st X509_ALGOR;
+typedef struct X509_crl_st X509_CRL;
+typedef struct x509_crl_method_st X509_CRL_METHOD;
+typedef struct x509_revoked_st X509_REVOKED;
+typedef struct X509_name_st X509_NAME;
+typedef struct X509_pubkey_st X509_PUBKEY;
+typedef struct x509_store_st X509_STORE;
+typedef struct x509_store_ctx_st X509_STORE_CTX;
+
+typedef struct x509_object_st X509_OBJECT;
+typedef struct x509_lookup_st X509_LOOKUP;
+typedef struct x509_lookup_method_st X509_LOOKUP_METHOD;
+typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
+
+typedef struct x509_sig_info_st X509_SIG_INFO;
+
+typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
+
+typedef struct v3_ext_ctx X509V3_CTX;
+typedef struct conf_st CONF;
+typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;
+
+typedef struct ui_st UI;
+typedef struct ui_method_st UI_METHOD;
+
+typedef struct engine_st ENGINE;
+typedef struct ssl_st SSL;
+typedef struct ssl_ctx_st SSL_CTX;
+
+typedef struct comp_ctx_st COMP_CTX;
+typedef struct comp_method_st COMP_METHOD;
+
+typedef struct X509_POLICY_NODE_st X509_POLICY_NODE;
+typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL;
+typedef struct X509_POLICY_TREE_st X509_POLICY_TREE;
+typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE;
+
+typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID;
+typedef struct DIST_POINT_st DIST_POINT;
+typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT;
+typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS;
+
+typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
+
+typedef struct ossl_http_req_ctx_st OSSL_HTTP_REQ_CTX;
+typedef struct ocsp_response_st OCSP_RESPONSE;
+typedef struct ocsp_responder_id_st OCSP_RESPID;
+
+typedef struct sct_st SCT;
+typedef struct sct_ctx_st SCT_CTX;
+typedef struct ctlog_st CTLOG;
+typedef struct ctlog_store_st CTLOG_STORE;
+typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX;
+
+typedef struct ossl_store_info_st OSSL_STORE_INFO;
+typedef struct ossl_store_search_st OSSL_STORE_SEARCH;
+
+typedef struct ossl_lib_ctx_st OSSL_LIB_CTX;
+
+typedef struct ossl_dispatch_st OSSL_DISPATCH;
+typedef struct ossl_item_st OSSL_ITEM;
+typedef struct ossl_algorithm_st OSSL_ALGORITHM;
+typedef struct ossl_param_st OSSL_PARAM;
+typedef struct ossl_param_bld_st OSSL_PARAM_BLD;
+
+typedef int pem_password_cb (char *buf, int size, int rwflag, void *userdata);
+
+typedef struct ossl_encoder_st OSSL_ENCODER;
+typedef struct ossl_encoder_ctx_st OSSL_ENCODER_CTX;
+typedef struct ossl_decoder_st OSSL_DECODER;
+typedef struct ossl_decoder_ctx_st OSSL_DECODER_CTX;
+
+typedef struct ossl_self_test_st OSSL_SELF_TEST;
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* OPENSSL_TYPES_H */
diff --git a/CAPI/cpp/grpc/include/openssl/ui.h b/CAPI/cpp/grpc/include/openssl/ui.h
new file mode 100644
index 0000000..835b0eb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/ui.h
@@ -0,0 +1,407 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\ui.h.in
+ *
+ * Copyright 2001-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_UI_H
+# define OPENSSL_UI_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_UI_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/crypto.h>
+# endif
+# include <openssl/safestack.h>
+# include <openssl/pem.h>
+# include <openssl/types.h>
+# include <openssl/uierr.h>
+
+/* For compatibility reasons, the macro OPENSSL_NO_UI is currently retained */
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifdef OPENSSL_NO_UI_CONSOLE
+#   define OPENSSL_NO_UI
+#  endif
+# endif
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * All the following functions return -1 or NULL on error and in some cases
+ * (UI_process()) -2 if interrupted or in some other way cancelled. When
+ * everything is fine, they return 0, a positive value or a non-NULL pointer,
+ * all depending on their purpose.
+ */
+
+/* Creators and destructor.   */
+UI *UI_new(void);
+UI *UI_new_method(const UI_METHOD *method);
+void UI_free(UI *ui);
+
+/*-
+   The following functions are used to add strings to be printed and prompt
+   strings to prompt for data.  The names are UI_{add,dup}_<function>_string
+   and UI_{add,dup}_input_boolean.
+
+   UI_{add,dup}_<function>_string have the following meanings:
+        add     add a text or prompt string.  The pointers given to these
+                functions are used verbatim, no copying is done.
+        dup     make a copy of the text or prompt string, then add the copy
+                to the collection of strings in the user interface.
+        <function>
+                The function is a name for the functionality that the given
+                string shall be used for.  It can be one of:
+                        input   use the string as data prompt.
+                        verify  use the string as verification prompt.  This
+                                is used to verify a previous input.
+                        info    use the string for informational output.
+                        error   use the string for error output.
+   Honestly, there's currently no difference between info and error for the
+   moment.
+
+   UI_{add,dup}_input_boolean have the same semantics for "add" and "dup",
+   and are typically used when one wants to prompt for a yes/no response.
+
+   All of the functions in this group take a UI and a prompt string.
+   The string input and verify addition functions also take a flag argument,
+   a buffer for the result to end up with, a minimum input size and a maximum
+   input size (the result buffer MUST be large enough to be able to contain
+   the maximum number of characters).  Additionally, the verify addition
+   functions takes another buffer to compare the result against.
+   The boolean input functions take an action description string (which should
+   be safe to ignore if the expected user action is obvious, for example with
+   a dialog box with an OK button and a Cancel button), a string of acceptable
+   characters to mean OK and to mean Cancel.  The two last strings are checked
+   to make sure they don't have common characters.  Additionally, the same
+   flag argument as for the string input is taken, as well as a result buffer.
+   The result buffer is required to be at least one byte long.  Depending on
+   the answer, the first character from the OK or the Cancel character strings
+   will be stored in the first byte of the result buffer.  No NUL will be
+   added, so the result is *not* a string.
+
+   On success, the all return an index of the added information.  That index
+   is useful when retrieving results with UI_get0_result(). */
+int UI_add_input_string(UI *ui, const char *prompt, int flags,
+                        char *result_buf, int minsize, int maxsize);
+int UI_dup_input_string(UI *ui, const char *prompt, int flags,
+                        char *result_buf, int minsize, int maxsize);
+int UI_add_verify_string(UI *ui, const char *prompt, int flags,
+                         char *result_buf, int minsize, int maxsize,
+                         const char *test_buf);
+int UI_dup_verify_string(UI *ui, const char *prompt, int flags,
+                         char *result_buf, int minsize, int maxsize,
+                         const char *test_buf);
+int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
+                         const char *ok_chars, const char *cancel_chars,
+                         int flags, char *result_buf);
+int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
+                         const char *ok_chars, const char *cancel_chars,
+                         int flags, char *result_buf);
+int UI_add_info_string(UI *ui, const char *text);
+int UI_dup_info_string(UI *ui, const char *text);
+int UI_add_error_string(UI *ui, const char *text);
+int UI_dup_error_string(UI *ui, const char *text);
+
+/* These are the possible flags.  They can be or'ed together. */
+/* Use to have echoing of input */
+# define UI_INPUT_FLAG_ECHO              0x01
+/*
+ * Use a default password.  Where that password is found is completely up to
+ * the application, it might for example be in the user data set with
+ * UI_add_user_data().  It is not recommended to have more than one input in
+ * each UI being marked with this flag, or the application might get
+ * confused.
+ */
+# define UI_INPUT_FLAG_DEFAULT_PWD       0x02
+
+/*-
+ * The user of these routines may want to define flags of their own.  The core
+ * UI won't look at those, but will pass them on to the method routines.  They
+ * must use higher bits so they don't get confused with the UI bits above.
+ * UI_INPUT_FLAG_USER_BASE tells which is the lowest bit to use.  A good
+ * example of use is this:
+ *
+ *    #define MY_UI_FLAG1       (0x01 << UI_INPUT_FLAG_USER_BASE)
+ *
+*/
+# define UI_INPUT_FLAG_USER_BASE 16
+
+/*-
+ * The following function helps construct a prompt.
+ * phrase_desc is a textual short description of the phrase to enter,
+ * for example "pass phrase", and
+ * object_name is the name of the object
+ * (which might be a card name or a file name) or NULL.
+ * The returned string shall always be allocated on the heap with
+ * OPENSSL_malloc(), and need to be free'd with OPENSSL_free().
+ *
+ * If the ui_method doesn't contain a pointer to a user-defined prompt
+ * constructor, a default string is built, looking like this:
+ *
+ *       "Enter {phrase_desc} for {object_name}:"
+ *
+ * So, if phrase_desc has the value "pass phrase" and object_name has
+ * the value "foo.key", the resulting string is:
+ *
+ *       "Enter pass phrase for foo.key:"
+*/
+char *UI_construct_prompt(UI *ui_method,
+                          const char *phrase_desc, const char *object_name);
+
+/*
+ * The following function is used to store a pointer to user-specific data.
+ * Any previous such pointer will be returned and replaced.
+ *
+ * For callback purposes, this function makes a lot more sense than using
+ * ex_data, since the latter requires that different parts of OpenSSL or
+ * applications share the same ex_data index.
+ *
+ * Note that the UI_OpenSSL() method completely ignores the user data. Other
+ * methods may not, however.
+ */
+void *UI_add_user_data(UI *ui, void *user_data);
+/*
+ * Alternatively, this function is used to duplicate the user data.
+ * This uses the duplicator method function.  The destroy function will
+ * be used to free the user data in this case.
+ */
+int UI_dup_user_data(UI *ui, void *user_data);
+/* We need a user data retrieving function as well.  */
+void *UI_get0_user_data(UI *ui);
+
+/* Return the result associated with a prompt given with the index i. */
+const char *UI_get0_result(UI *ui, int i);
+int UI_get_result_length(UI *ui, int i);
+
+/* When all strings have been added, process the whole thing. */
+int UI_process(UI *ui);
+
+/*
+ * Give a user interface parameterised control commands.  This can be used to
+ * send down an integer, a data pointer or a function pointer, as well as be
+ * used to get information from a UI.
+ */
+int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void));
+
+/* The commands */
+/*
+ * Use UI_CONTROL_PRINT_ERRORS with the value 1 to have UI_process print the
+ * OpenSSL error stack before printing any info or added error messages and
+ * before any prompting.
+ */
+# define UI_CTRL_PRINT_ERRORS            1
+/*
+ * Check if a UI_process() is possible to do again with the same instance of
+ * a user interface.  This makes UI_ctrl() return 1 if it is redoable, and 0
+ * if not.
+ */
+# define UI_CTRL_IS_REDOABLE             2
+
+/* Some methods may use extra data */
+# define UI_set_app_data(s,arg)         UI_set_ex_data(s,0,arg)
+# define UI_get_app_data(s)             UI_get_ex_data(s,0)
+
+# define UI_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_UI, l, p, newf, dupf, freef)
+int UI_set_ex_data(UI *r, int idx, void *arg);
+void *UI_get_ex_data(const UI *r, int idx);
+
+/* Use specific methods instead of the built-in one */
+void UI_set_default_method(const UI_METHOD *meth);
+const UI_METHOD *UI_get_default_method(void);
+const UI_METHOD *UI_get_method(UI *ui);
+const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth);
+
+# ifndef OPENSSL_NO_UI_CONSOLE
+
+/* The method with all the built-in thingies */
+UI_METHOD *UI_OpenSSL(void);
+
+# endif
+
+/*
+ * NULL method.  Literally does nothing, but may serve as a placeholder
+ * to avoid internal default.
+ */
+const UI_METHOD *UI_null(void);
+
+/* ---------- For method writers ---------- */
+/*-
+   A method contains a number of functions that implement the low level
+   of the User Interface.  The functions are:
+
+        an opener       This function starts a session, maybe by opening
+                        a channel to a tty, or by opening a window.
+        a writer        This function is called to write a given string,
+                        maybe to the tty, maybe as a field label in a
+                        window.
+        a flusher       This function is called to flush everything that
+                        has been output so far.  It can be used to actually
+                        display a dialog box after it has been built.
+        a reader        This function is called to read a given prompt,
+                        maybe from the tty, maybe from a field in a
+                        window.  Note that it's called with all string
+                        structures, not only the prompt ones, so it must
+                        check such things itself.
+        a closer        This function closes the session, maybe by closing
+                        the channel to the tty, or closing the window.
+
+   All these functions are expected to return:
+
+        0       on error.
+        1       on success.
+        -1      on out-of-band events, for example if some prompting has
+                been canceled (by pressing Ctrl-C, for example).  This is
+                only checked when returned by the flusher or the reader.
+
+   The way this is used, the opener is first called, then the writer for all
+   strings, then the flusher, then the reader for all strings and finally the
+   closer.  Note that if you want to prompt from a terminal or other command
+   line interface, the best is to have the reader also write the prompts
+   instead of having the writer do it.  If you want to prompt from a dialog
+   box, the writer can be used to build up the contents of the box, and the
+   flusher to actually display the box and run the event loop until all data
+   has been given, after which the reader only grabs the given data and puts
+   them back into the UI strings.
+
+   All method functions take a UI as argument.  Additionally, the writer and
+   the reader take a UI_STRING.
+*/
+
+/*
+ * The UI_STRING type is the data structure that contains all the needed info
+ * about a string or a prompt, including test data for a verification prompt.
+ */
+typedef struct ui_string_st UI_STRING;
+
+SKM_DEFINE_STACK_OF_INTERNAL(UI_STRING, UI_STRING, UI_STRING)
+#define sk_UI_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_value(sk, idx) ((UI_STRING *)OPENSSL_sk_value(ossl_check_const_UI_STRING_sk_type(sk), (idx)))
+#define sk_UI_STRING_new(cmp) ((STACK_OF(UI_STRING) *)OPENSSL_sk_new(ossl_check_UI_STRING_compfunc_type(cmp)))
+#define sk_UI_STRING_new_null() ((STACK_OF(UI_STRING) *)OPENSSL_sk_new_null())
+#define sk_UI_STRING_new_reserve(cmp, n) ((STACK_OF(UI_STRING) *)OPENSSL_sk_new_reserve(ossl_check_UI_STRING_compfunc_type(cmp), (n)))
+#define sk_UI_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_UI_STRING_sk_type(sk), (n))
+#define sk_UI_STRING_free(sk) OPENSSL_sk_free(ossl_check_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_delete(sk, i) ((UI_STRING *)OPENSSL_sk_delete(ossl_check_UI_STRING_sk_type(sk), (i)))
+#define sk_UI_STRING_delete_ptr(sk, ptr) ((UI_STRING *)OPENSSL_sk_delete_ptr(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr)))
+#define sk_UI_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
+#define sk_UI_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
+#define sk_UI_STRING_pop(sk) ((UI_STRING *)OPENSSL_sk_pop(ossl_check_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_shift(sk) ((UI_STRING *)OPENSSL_sk_shift(ossl_check_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_UI_STRING_sk_type(sk),ossl_check_UI_STRING_freefunc_type(freefunc))
+#define sk_UI_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr), (idx))
+#define sk_UI_STRING_set(sk, idx, ptr) ((UI_STRING *)OPENSSL_sk_set(ossl_check_UI_STRING_sk_type(sk), (idx), ossl_check_UI_STRING_type(ptr)))
+#define sk_UI_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
+#define sk_UI_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
+#define sk_UI_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr), pnum)
+#define sk_UI_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_UI_STRING_sk_type(sk))
+#define sk_UI_STRING_dup(sk) ((STACK_OF(UI_STRING) *)OPENSSL_sk_dup(ossl_check_const_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(UI_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_UI_STRING_sk_type(sk), ossl_check_UI_STRING_copyfunc_type(copyfunc), ossl_check_UI_STRING_freefunc_type(freefunc)))
+#define sk_UI_STRING_set_cmp_func(sk, cmp) ((sk_UI_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_compfunc_type(cmp)))
+
+
+/*
+ * The different types of strings that are currently supported. This is only
+ * needed by method authors.
+ */
+enum UI_string_types {
+    UIT_NONE = 0,
+    UIT_PROMPT,                 /* Prompt for a string */
+    UIT_VERIFY,                 /* Prompt for a string and verify */
+    UIT_BOOLEAN,                /* Prompt for a yes/no response */
+    UIT_INFO,                   /* Send info to the user */
+    UIT_ERROR                   /* Send an error message to the user */
+};
+
+/* Create and manipulate methods */
+UI_METHOD *UI_create_method(const char *name);
+void UI_destroy_method(UI_METHOD *ui_method);
+int UI_method_set_opener(UI_METHOD *method, int (*opener) (UI *ui));
+int UI_method_set_writer(UI_METHOD *method,
+                         int (*writer) (UI *ui, UI_STRING *uis));
+int UI_method_set_flusher(UI_METHOD *method, int (*flusher) (UI *ui));
+int UI_method_set_reader(UI_METHOD *method,
+                         int (*reader) (UI *ui, UI_STRING *uis));
+int UI_method_set_closer(UI_METHOD *method, int (*closer) (UI *ui));
+int UI_method_set_data_duplicator(UI_METHOD *method,
+                                  void *(*duplicator) (UI *ui, void *ui_data),
+                                  void (*destructor)(UI *ui, void *ui_data));
+int UI_method_set_prompt_constructor(UI_METHOD *method,
+                                     char *(*prompt_constructor) (UI *ui,
+                                                                  const char
+                                                                  *phrase_desc,
+                                                                  const char
+                                                                  *object_name));
+int UI_method_set_ex_data(UI_METHOD *method, int idx, void *data);
+int (*UI_method_get_opener(const UI_METHOD *method)) (UI *);
+int (*UI_method_get_writer(const UI_METHOD *method)) (UI *, UI_STRING *);
+int (*UI_method_get_flusher(const UI_METHOD *method)) (UI *);
+int (*UI_method_get_reader(const UI_METHOD *method)) (UI *, UI_STRING *);
+int (*UI_method_get_closer(const UI_METHOD *method)) (UI *);
+char *(*UI_method_get_prompt_constructor(const UI_METHOD *method))
+    (UI *, const char *, const char *);
+void *(*UI_method_get_data_duplicator(const UI_METHOD *method)) (UI *, void *);
+void (*UI_method_get_data_destructor(const UI_METHOD *method)) (UI *, void *);
+const void *UI_method_get_ex_data(const UI_METHOD *method, int idx);
+
+/*
+ * The following functions are helpers for method writers to access relevant
+ * data from a UI_STRING.
+ */
+
+/* Return type of the UI_STRING */
+enum UI_string_types UI_get_string_type(UI_STRING *uis);
+/* Return input flags of the UI_STRING */
+int UI_get_input_flags(UI_STRING *uis);
+/* Return the actual string to output (the prompt, info or error) */
+const char *UI_get0_output_string(UI_STRING *uis);
+/*
+ * Return the optional action string to output (the boolean prompt
+ * instruction)
+ */
+const char *UI_get0_action_string(UI_STRING *uis);
+/* Return the result of a prompt */
+const char *UI_get0_result_string(UI_STRING *uis);
+int UI_get_result_string_length(UI_STRING *uis);
+/*
+ * Return the string to test the result against.  Only useful with verifies.
+ */
+const char *UI_get0_test_string(UI_STRING *uis);
+/* Return the required minimum size of the result */
+int UI_get_result_minsize(UI_STRING *uis);
+/* Return the required maximum size of the result */
+int UI_get_result_maxsize(UI_STRING *uis);
+/* Set the result of a UI_STRING. */
+int UI_set_result(UI *ui, UI_STRING *uis, const char *result);
+int UI_set_result_ex(UI *ui, UI_STRING *uis, const char *result, int len);
+
+/* A couple of popular utility functions */
+int UI_UTIL_read_pw_string(char *buf, int length, const char *prompt,
+                           int verify);
+int UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt,
+                    int verify);
+UI_METHOD *UI_UTIL_wrap_read_pem_callback(pem_password_cb *cb, int rwflag);
+
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/uierr.h b/CAPI/cpp/grpc/include/openssl/uierr.h
new file mode 100644
index 0000000..473b04e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/uierr.h
@@ -0,0 +1,38 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_UIERR_H
+# define OPENSSL_UIERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * UI reason codes.
+ */
+# define UI_R_COMMON_OK_AND_CANCEL_CHARACTERS             104
+# define UI_R_INDEX_TOO_LARGE                             102
+# define UI_R_INDEX_TOO_SMALL                             103
+# define UI_R_NO_RESULT_BUFFER                            105
+# define UI_R_PROCESSING_ERROR                            107
+# define UI_R_RESULT_TOO_LARGE                            100
+# define UI_R_RESULT_TOO_SMALL                            101
+# define UI_R_SYSASSIGN_ERROR                             109
+# define UI_R_SYSDASSGN_ERROR                             110
+# define UI_R_SYSQIOW_ERROR                               111
+# define UI_R_UNKNOWN_CONTROL_COMMAND                     106
+# define UI_R_UNKNOWN_TTYGET_ERRNO_VALUE                  108
+# define UI_R_USER_DATA_DUPLICATION_UNSUPPORTED           112
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/whrlpool.h b/CAPI/cpp/grpc/include/openssl/whrlpool.h
new file mode 100644
index 0000000..05ba463
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/whrlpool.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2005-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_WHRLPOOL_H
+# define OPENSSL_WHRLPOOL_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_WHRLPOOL_H
+# endif
+
+# include <openssl/opensslconf.h>
+
+# ifndef OPENSSL_NO_WHIRLPOOL
+#  include <openssl/e_os2.h>
+#  include <stddef.h>
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+
+#  define WHIRLPOOL_DIGEST_LENGTH (512/8)
+
+#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#   define WHIRLPOOL_BBLOCK        512
+#   define WHIRLPOOL_COUNTER       (256/8)
+
+typedef struct {
+    union {
+        unsigned char c[WHIRLPOOL_DIGEST_LENGTH];
+        /* double q is here to ensure 64-bit alignment */
+        double q[WHIRLPOOL_DIGEST_LENGTH / sizeof(double)];
+    } H;
+    unsigned char data[WHIRLPOOL_BBLOCK / 8];
+    unsigned int bitoff;
+    size_t bitlen[WHIRLPOOL_COUNTER / sizeof(size_t)];
+} WHIRLPOOL_CTX;
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Init(WHIRLPOOL_CTX *c);
+OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Update(WHIRLPOOL_CTX *c,
+                                           const void *inp, size_t bytes);
+OSSL_DEPRECATEDIN_3_0 void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c,
+                                               const void *inp, size_t bits);
+OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Final(unsigned char *md, WHIRLPOOL_CTX *c);
+OSSL_DEPRECATEDIN_3_0 unsigned char *WHIRLPOOL(const void *inp, size_t bytes,
+                                               unsigned char *md);
+#  endif
+
+#  ifdef __cplusplus
+}
+#  endif
+# endif
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509.h b/CAPI/cpp/grpc/include/openssl/x509.h
new file mode 100644
index 0000000..eda5d70
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/x509.h
@@ -0,0 +1,1276 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\x509.h.in
+ *
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_X509_H
+# define OPENSSL_X509_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_X509_H
+# endif
+
+# include <openssl/e_os2.h>
+# include <openssl/types.h>
+# include <openssl/symhacks.h>
+# include <openssl/buffer.h>
+# include <openssl/evp.h>
+# include <openssl/bio.h>
+# include <openssl/asn1.h>
+# include <openssl/safestack.h>
+# include <openssl/ec.h>
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  include <openssl/rsa.h>
+#  include <openssl/dsa.h>
+#  include <openssl/dh.h>
+# endif
+
+# include <openssl/sha.h>
+# include <openssl/x509err.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Needed stacks for types defined in other headers */
+SKM_DEFINE_STACK_OF_INTERNAL(X509_NAME, X509_NAME, X509_NAME)
+#define sk_X509_NAME_num(sk) OPENSSL_sk_num(ossl_check_const_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_value(sk, idx) ((X509_NAME *)OPENSSL_sk_value(ossl_check_const_X509_NAME_sk_type(sk), (idx)))
+#define sk_X509_NAME_new(cmp) ((STACK_OF(X509_NAME) *)OPENSSL_sk_new(ossl_check_X509_NAME_compfunc_type(cmp)))
+#define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)OPENSSL_sk_new_null())
+#define sk_X509_NAME_new_reserve(cmp, n) ((STACK_OF(X509_NAME) *)OPENSSL_sk_new_reserve(ossl_check_X509_NAME_compfunc_type(cmp), (n)))
+#define sk_X509_NAME_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_NAME_sk_type(sk), (n))
+#define sk_X509_NAME_free(sk) OPENSSL_sk_free(ossl_check_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_zero(sk) OPENSSL_sk_zero(ossl_check_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_delete(sk, i) ((X509_NAME *)OPENSSL_sk_delete(ossl_check_X509_NAME_sk_type(sk), (i)))
+#define sk_X509_NAME_delete_ptr(sk, ptr) ((X509_NAME *)OPENSSL_sk_delete_ptr(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr)))
+#define sk_X509_NAME_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
+#define sk_X509_NAME_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
+#define sk_X509_NAME_pop(sk) ((X509_NAME *)OPENSSL_sk_pop(ossl_check_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_shift(sk) ((X509_NAME *)OPENSSL_sk_shift(ossl_check_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_NAME_sk_type(sk),ossl_check_X509_NAME_freefunc_type(freefunc))
+#define sk_X509_NAME_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr), (idx))
+#define sk_X509_NAME_set(sk, idx, ptr) ((X509_NAME *)OPENSSL_sk_set(ossl_check_X509_NAME_sk_type(sk), (idx), ossl_check_X509_NAME_type(ptr)))
+#define sk_X509_NAME_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
+#define sk_X509_NAME_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
+#define sk_X509_NAME_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr), pnum)
+#define sk_X509_NAME_sort(sk) OPENSSL_sk_sort(ossl_check_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_NAME_sk_type(sk))
+#define sk_X509_NAME_dup(sk) ((STACK_OF(X509_NAME) *)OPENSSL_sk_dup(ossl_check_const_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_NAME) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_NAME_sk_type(sk), ossl_check_X509_NAME_copyfunc_type(copyfunc), ossl_check_X509_NAME_freefunc_type(freefunc)))
+#define sk_X509_NAME_set_cmp_func(sk, cmp) ((sk_X509_NAME_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509, X509, X509)
+#define sk_X509_num(sk) OPENSSL_sk_num(ossl_check_const_X509_sk_type(sk))
+#define sk_X509_value(sk, idx) ((X509 *)OPENSSL_sk_value(ossl_check_const_X509_sk_type(sk), (idx)))
+#define sk_X509_new(cmp) ((STACK_OF(X509) *)OPENSSL_sk_new(ossl_check_X509_compfunc_type(cmp)))
+#define sk_X509_new_null() ((STACK_OF(X509) *)OPENSSL_sk_new_null())
+#define sk_X509_new_reserve(cmp, n) ((STACK_OF(X509) *)OPENSSL_sk_new_reserve(ossl_check_X509_compfunc_type(cmp), (n)))
+#define sk_X509_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_sk_type(sk), (n))
+#define sk_X509_free(sk) OPENSSL_sk_free(ossl_check_X509_sk_type(sk))
+#define sk_X509_zero(sk) OPENSSL_sk_zero(ossl_check_X509_sk_type(sk))
+#define sk_X509_delete(sk, i) ((X509 *)OPENSSL_sk_delete(ossl_check_X509_sk_type(sk), (i)))
+#define sk_X509_delete_ptr(sk, ptr) ((X509 *)OPENSSL_sk_delete_ptr(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr)))
+#define sk_X509_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
+#define sk_X509_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
+#define sk_X509_pop(sk) ((X509 *)OPENSSL_sk_pop(ossl_check_X509_sk_type(sk)))
+#define sk_X509_shift(sk) ((X509 *)OPENSSL_sk_shift(ossl_check_X509_sk_type(sk)))
+#define sk_X509_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_sk_type(sk),ossl_check_X509_freefunc_type(freefunc))
+#define sk_X509_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr), (idx))
+#define sk_X509_set(sk, idx, ptr) ((X509 *)OPENSSL_sk_set(ossl_check_X509_sk_type(sk), (idx), ossl_check_X509_type(ptr)))
+#define sk_X509_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
+#define sk_X509_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
+#define sk_X509_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr), pnum)
+#define sk_X509_sort(sk) OPENSSL_sk_sort(ossl_check_X509_sk_type(sk))
+#define sk_X509_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_sk_type(sk))
+#define sk_X509_dup(sk) ((STACK_OF(X509) *)OPENSSL_sk_dup(ossl_check_const_X509_sk_type(sk)))
+#define sk_X509_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_sk_type(sk), ossl_check_X509_copyfunc_type(copyfunc), ossl_check_X509_freefunc_type(freefunc)))
+#define sk_X509_set_cmp_func(sk, cmp) ((sk_X509_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_sk_type(sk), ossl_check_X509_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509_REVOKED, X509_REVOKED, X509_REVOKED)
+#define sk_X509_REVOKED_num(sk) OPENSSL_sk_num(ossl_check_const_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_value(sk, idx) ((X509_REVOKED *)OPENSSL_sk_value(ossl_check_const_X509_REVOKED_sk_type(sk), (idx)))
+#define sk_X509_REVOKED_new(cmp) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new(ossl_check_X509_REVOKED_compfunc_type(cmp)))
+#define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new_null())
+#define sk_X509_REVOKED_new_reserve(cmp, n) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new_reserve(ossl_check_X509_REVOKED_compfunc_type(cmp), (n)))
+#define sk_X509_REVOKED_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_REVOKED_sk_type(sk), (n))
+#define sk_X509_REVOKED_free(sk) OPENSSL_sk_free(ossl_check_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_zero(sk) OPENSSL_sk_zero(ossl_check_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_delete(sk, i) ((X509_REVOKED *)OPENSSL_sk_delete(ossl_check_X509_REVOKED_sk_type(sk), (i)))
+#define sk_X509_REVOKED_delete_ptr(sk, ptr) ((X509_REVOKED *)OPENSSL_sk_delete_ptr(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr)))
+#define sk_X509_REVOKED_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
+#define sk_X509_REVOKED_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
+#define sk_X509_REVOKED_pop(sk) ((X509_REVOKED *)OPENSSL_sk_pop(ossl_check_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_shift(sk) ((X509_REVOKED *)OPENSSL_sk_shift(ossl_check_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_REVOKED_sk_type(sk),ossl_check_X509_REVOKED_freefunc_type(freefunc))
+#define sk_X509_REVOKED_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr), (idx))
+#define sk_X509_REVOKED_set(sk, idx, ptr) ((X509_REVOKED *)OPENSSL_sk_set(ossl_check_X509_REVOKED_sk_type(sk), (idx), ossl_check_X509_REVOKED_type(ptr)))
+#define sk_X509_REVOKED_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
+#define sk_X509_REVOKED_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
+#define sk_X509_REVOKED_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr), pnum)
+#define sk_X509_REVOKED_sort(sk) OPENSSL_sk_sort(ossl_check_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_REVOKED_sk_type(sk))
+#define sk_X509_REVOKED_dup(sk) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_dup(ossl_check_const_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_copyfunc_type(copyfunc), ossl_check_X509_REVOKED_freefunc_type(freefunc)))
+#define sk_X509_REVOKED_set_cmp_func(sk, cmp) ((sk_X509_REVOKED_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509_CRL, X509_CRL, X509_CRL)
+#define sk_X509_CRL_num(sk) OPENSSL_sk_num(ossl_check_const_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_value(sk, idx) ((X509_CRL *)OPENSSL_sk_value(ossl_check_const_X509_CRL_sk_type(sk), (idx)))
+#define sk_X509_CRL_new(cmp) ((STACK_OF(X509_CRL) *)OPENSSL_sk_new(ossl_check_X509_CRL_compfunc_type(cmp)))
+#define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)OPENSSL_sk_new_null())
+#define sk_X509_CRL_new_reserve(cmp, n) ((STACK_OF(X509_CRL) *)OPENSSL_sk_new_reserve(ossl_check_X509_CRL_compfunc_type(cmp), (n)))
+#define sk_X509_CRL_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_CRL_sk_type(sk), (n))
+#define sk_X509_CRL_free(sk) OPENSSL_sk_free(ossl_check_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_zero(sk) OPENSSL_sk_zero(ossl_check_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_delete(sk, i) ((X509_CRL *)OPENSSL_sk_delete(ossl_check_X509_CRL_sk_type(sk), (i)))
+#define sk_X509_CRL_delete_ptr(sk, ptr) ((X509_CRL *)OPENSSL_sk_delete_ptr(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr)))
+#define sk_X509_CRL_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
+#define sk_X509_CRL_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
+#define sk_X509_CRL_pop(sk) ((X509_CRL *)OPENSSL_sk_pop(ossl_check_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_shift(sk) ((X509_CRL *)OPENSSL_sk_shift(ossl_check_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_CRL_sk_type(sk),ossl_check_X509_CRL_freefunc_type(freefunc))
+#define sk_X509_CRL_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr), (idx))
+#define sk_X509_CRL_set(sk, idx, ptr) ((X509_CRL *)OPENSSL_sk_set(ossl_check_X509_CRL_sk_type(sk), (idx), ossl_check_X509_CRL_type(ptr)))
+#define sk_X509_CRL_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
+#define sk_X509_CRL_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
+#define sk_X509_CRL_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr), pnum)
+#define sk_X509_CRL_sort(sk) OPENSSL_sk_sort(ossl_check_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_CRL_sk_type(sk))
+#define sk_X509_CRL_dup(sk) ((STACK_OF(X509_CRL) *)OPENSSL_sk_dup(ossl_check_const_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_CRL) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_CRL_sk_type(sk), ossl_check_X509_CRL_copyfunc_type(copyfunc), ossl_check_X509_CRL_freefunc_type(freefunc)))
+#define sk_X509_CRL_set_cmp_func(sk, cmp) ((sk_X509_CRL_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_compfunc_type(cmp)))
+
+
+/* Flags for X509_get_signature_info() */
+/* Signature info is valid */
+# define X509_SIG_INFO_VALID     0x1
+/* Signature is suitable for TLS use */
+# define X509_SIG_INFO_TLS       0x2
+
+# define X509_FILETYPE_PEM       1
+# define X509_FILETYPE_ASN1      2
+# define X509_FILETYPE_DEFAULT   3
+
+# define X509v3_KU_DIGITAL_SIGNATURE     0x0080
+# define X509v3_KU_NON_REPUDIATION       0x0040
+# define X509v3_KU_KEY_ENCIPHERMENT      0x0020
+# define X509v3_KU_DATA_ENCIPHERMENT     0x0010
+# define X509v3_KU_KEY_AGREEMENT         0x0008
+# define X509v3_KU_KEY_CERT_SIGN         0x0004
+# define X509v3_KU_CRL_SIGN              0x0002
+# define X509v3_KU_ENCIPHER_ONLY         0x0001
+# define X509v3_KU_DECIPHER_ONLY         0x8000
+# define X509v3_KU_UNDEF                 0xffff
+
+struct X509_algor_st {
+    ASN1_OBJECT *algorithm;
+    ASN1_TYPE *parameter;
+} /* X509_ALGOR */ ;
+
+typedef STACK_OF(X509_ALGOR) X509_ALGORS;
+
+typedef struct X509_val_st {
+    ASN1_TIME *notBefore;
+    ASN1_TIME *notAfter;
+} X509_VAL;
+
+typedef struct X509_sig_st X509_SIG;
+
+typedef struct X509_name_entry_st X509_NAME_ENTRY;
+
+SKM_DEFINE_STACK_OF_INTERNAL(X509_NAME_ENTRY, X509_NAME_ENTRY, X509_NAME_ENTRY)
+#define sk_X509_NAME_ENTRY_num(sk) OPENSSL_sk_num(ossl_check_const_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_value(sk, idx) ((X509_NAME_ENTRY *)OPENSSL_sk_value(ossl_check_const_X509_NAME_ENTRY_sk_type(sk), (idx)))
+#define sk_X509_NAME_ENTRY_new(cmp) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new(ossl_check_X509_NAME_ENTRY_compfunc_type(cmp)))
+#define sk_X509_NAME_ENTRY_new_null() ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new_null())
+#define sk_X509_NAME_ENTRY_new_reserve(cmp, n) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new_reserve(ossl_check_X509_NAME_ENTRY_compfunc_type(cmp), (n)))
+#define sk_X509_NAME_ENTRY_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_NAME_ENTRY_sk_type(sk), (n))
+#define sk_X509_NAME_ENTRY_free(sk) OPENSSL_sk_free(ossl_check_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_zero(sk) OPENSSL_sk_zero(ossl_check_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_delete(sk, i) ((X509_NAME_ENTRY *)OPENSSL_sk_delete(ossl_check_X509_NAME_ENTRY_sk_type(sk), (i)))
+#define sk_X509_NAME_ENTRY_delete_ptr(sk, ptr) ((X509_NAME_ENTRY *)OPENSSL_sk_delete_ptr(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr)))
+#define sk_X509_NAME_ENTRY_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
+#define sk_X509_NAME_ENTRY_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
+#define sk_X509_NAME_ENTRY_pop(sk) ((X509_NAME_ENTRY *)OPENSSL_sk_pop(ossl_check_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_shift(sk) ((X509_NAME_ENTRY *)OPENSSL_sk_shift(ossl_check_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_NAME_ENTRY_sk_type(sk),ossl_check_X509_NAME_ENTRY_freefunc_type(freefunc))
+#define sk_X509_NAME_ENTRY_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr), (idx))
+#define sk_X509_NAME_ENTRY_set(sk, idx, ptr) ((X509_NAME_ENTRY *)OPENSSL_sk_set(ossl_check_X509_NAME_ENTRY_sk_type(sk), (idx), ossl_check_X509_NAME_ENTRY_type(ptr)))
+#define sk_X509_NAME_ENTRY_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
+#define sk_X509_NAME_ENTRY_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
+#define sk_X509_NAME_ENTRY_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr), pnum)
+#define sk_X509_NAME_ENTRY_sort(sk) OPENSSL_sk_sort(ossl_check_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_NAME_ENTRY_sk_type(sk))
+#define sk_X509_NAME_ENTRY_dup(sk) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_dup(ossl_check_const_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_copyfunc_type(copyfunc), ossl_check_X509_NAME_ENTRY_freefunc_type(freefunc)))
+#define sk_X509_NAME_ENTRY_set_cmp_func(sk, cmp) ((sk_X509_NAME_ENTRY_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_compfunc_type(cmp)))
+
+
+# define X509_EX_V_NETSCAPE_HACK         0x8000
+# define X509_EX_V_INIT                  0x0001
+typedef struct X509_extension_st X509_EXTENSION;
+SKM_DEFINE_STACK_OF_INTERNAL(X509_EXTENSION, X509_EXTENSION, X509_EXTENSION)
+#define sk_X509_EXTENSION_num(sk) OPENSSL_sk_num(ossl_check_const_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_value(sk, idx) ((X509_EXTENSION *)OPENSSL_sk_value(ossl_check_const_X509_EXTENSION_sk_type(sk), (idx)))
+#define sk_X509_EXTENSION_new(cmp) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new(ossl_check_X509_EXTENSION_compfunc_type(cmp)))
+#define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new_null())
+#define sk_X509_EXTENSION_new_reserve(cmp, n) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new_reserve(ossl_check_X509_EXTENSION_compfunc_type(cmp), (n)))
+#define sk_X509_EXTENSION_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_EXTENSION_sk_type(sk), (n))
+#define sk_X509_EXTENSION_free(sk) OPENSSL_sk_free(ossl_check_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_zero(sk) OPENSSL_sk_zero(ossl_check_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_delete(sk, i) ((X509_EXTENSION *)OPENSSL_sk_delete(ossl_check_X509_EXTENSION_sk_type(sk), (i)))
+#define sk_X509_EXTENSION_delete_ptr(sk, ptr) ((X509_EXTENSION *)OPENSSL_sk_delete_ptr(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr)))
+#define sk_X509_EXTENSION_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
+#define sk_X509_EXTENSION_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
+#define sk_X509_EXTENSION_pop(sk) ((X509_EXTENSION *)OPENSSL_sk_pop(ossl_check_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_shift(sk) ((X509_EXTENSION *)OPENSSL_sk_shift(ossl_check_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_EXTENSION_sk_type(sk),ossl_check_X509_EXTENSION_freefunc_type(freefunc))
+#define sk_X509_EXTENSION_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr), (idx))
+#define sk_X509_EXTENSION_set(sk, idx, ptr) ((X509_EXTENSION *)OPENSSL_sk_set(ossl_check_X509_EXTENSION_sk_type(sk), (idx), ossl_check_X509_EXTENSION_type(ptr)))
+#define sk_X509_EXTENSION_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
+#define sk_X509_EXTENSION_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
+#define sk_X509_EXTENSION_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr), pnum)
+#define sk_X509_EXTENSION_sort(sk) OPENSSL_sk_sort(ossl_check_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_EXTENSION_sk_type(sk))
+#define sk_X509_EXTENSION_dup(sk) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_dup(ossl_check_const_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_copyfunc_type(copyfunc), ossl_check_X509_EXTENSION_freefunc_type(freefunc)))
+#define sk_X509_EXTENSION_set_cmp_func(sk, cmp) ((sk_X509_EXTENSION_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_compfunc_type(cmp)))
+
+typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS;
+typedef struct x509_attributes_st X509_ATTRIBUTE;
+SKM_DEFINE_STACK_OF_INTERNAL(X509_ATTRIBUTE, X509_ATTRIBUTE, X509_ATTRIBUTE)
+#define sk_X509_ATTRIBUTE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_value(sk, idx) ((X509_ATTRIBUTE *)OPENSSL_sk_value(ossl_check_const_X509_ATTRIBUTE_sk_type(sk), (idx)))
+#define sk_X509_ATTRIBUTE_new(cmp) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new(ossl_check_X509_ATTRIBUTE_compfunc_type(cmp)))
+#define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new_null())
+#define sk_X509_ATTRIBUTE_new_reserve(cmp, n) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new_reserve(ossl_check_X509_ATTRIBUTE_compfunc_type(cmp), (n)))
+#define sk_X509_ATTRIBUTE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_ATTRIBUTE_sk_type(sk), (n))
+#define sk_X509_ATTRIBUTE_free(sk) OPENSSL_sk_free(ossl_check_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_delete(sk, i) ((X509_ATTRIBUTE *)OPENSSL_sk_delete(ossl_check_X509_ATTRIBUTE_sk_type(sk), (i)))
+#define sk_X509_ATTRIBUTE_delete_ptr(sk, ptr) ((X509_ATTRIBUTE *)OPENSSL_sk_delete_ptr(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr)))
+#define sk_X509_ATTRIBUTE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
+#define sk_X509_ATTRIBUTE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
+#define sk_X509_ATTRIBUTE_pop(sk) ((X509_ATTRIBUTE *)OPENSSL_sk_pop(ossl_check_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_shift(sk) ((X509_ATTRIBUTE *)OPENSSL_sk_shift(ossl_check_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ATTRIBUTE_sk_type(sk),ossl_check_X509_ATTRIBUTE_freefunc_type(freefunc))
+#define sk_X509_ATTRIBUTE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr), (idx))
+#define sk_X509_ATTRIBUTE_set(sk, idx, ptr) ((X509_ATTRIBUTE *)OPENSSL_sk_set(ossl_check_X509_ATTRIBUTE_sk_type(sk), (idx), ossl_check_X509_ATTRIBUTE_type(ptr)))
+#define sk_X509_ATTRIBUTE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
+#define sk_X509_ATTRIBUTE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
+#define sk_X509_ATTRIBUTE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr), pnum)
+#define sk_X509_ATTRIBUTE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_ATTRIBUTE_sk_type(sk))
+#define sk_X509_ATTRIBUTE_dup(sk) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_dup(ossl_check_const_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_copyfunc_type(copyfunc), ossl_check_X509_ATTRIBUTE_freefunc_type(freefunc)))
+#define sk_X509_ATTRIBUTE_set_cmp_func(sk, cmp) ((sk_X509_ATTRIBUTE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_compfunc_type(cmp)))
+
+typedef struct X509_req_info_st X509_REQ_INFO;
+typedef struct X509_req_st X509_REQ;
+typedef struct x509_cert_aux_st X509_CERT_AUX;
+typedef struct x509_cinf_st X509_CINF;
+
+/* Flags for X509_print_ex() */
+
+# define X509_FLAG_COMPAT                0
+# define X509_FLAG_NO_HEADER             1L
+# define X509_FLAG_NO_VERSION            (1L << 1)
+# define X509_FLAG_NO_SERIAL             (1L << 2)
+# define X509_FLAG_NO_SIGNAME            (1L << 3)
+# define X509_FLAG_NO_ISSUER             (1L << 4)
+# define X509_FLAG_NO_VALIDITY           (1L << 5)
+# define X509_FLAG_NO_SUBJECT            (1L << 6)
+# define X509_FLAG_NO_PUBKEY             (1L << 7)
+# define X509_FLAG_NO_EXTENSIONS         (1L << 8)
+# define X509_FLAG_NO_SIGDUMP            (1L << 9)
+# define X509_FLAG_NO_AUX                (1L << 10)
+# define X509_FLAG_NO_ATTRIBUTES         (1L << 11)
+# define X509_FLAG_NO_IDS                (1L << 12)
+# define X509_FLAG_EXTENSIONS_ONLY_KID   (1L << 13)
+
+/* Flags specific to X509_NAME_print_ex() */
+
+/* The field separator information */
+
+# define XN_FLAG_SEP_MASK        (0xf << 16)
+
+# define XN_FLAG_COMPAT          0/* Traditional; use old X509_NAME_print */
+# define XN_FLAG_SEP_COMMA_PLUS  (1 << 16)/* RFC2253 ,+ */
+# define XN_FLAG_SEP_CPLUS_SPC   (2 << 16)/* ,+ spaced: more readable */
+# define XN_FLAG_SEP_SPLUS_SPC   (3 << 16)/* ;+ spaced */
+# define XN_FLAG_SEP_MULTILINE   (4 << 16)/* One line per field */
+
+# define XN_FLAG_DN_REV          (1 << 20)/* Reverse DN order */
+
+/* How the field name is shown */
+
+# define XN_FLAG_FN_MASK         (0x3 << 21)
+
+# define XN_FLAG_FN_SN           0/* Object short name */
+# define XN_FLAG_FN_LN           (1 << 21)/* Object long name */
+# define XN_FLAG_FN_OID          (2 << 21)/* Always use OIDs */
+# define XN_FLAG_FN_NONE         (3 << 21)/* No field names */
+
+# define XN_FLAG_SPC_EQ          (1 << 23)/* Put spaces round '=' */
+
+/*
+ * This determines if we dump fields we don't recognise: RFC2253 requires
+ * this.
+ */
+
+# define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24)
+
+# define XN_FLAG_FN_ALIGN        (1 << 25)/* Align field names to 20
+                                           * characters */
+
+/* Complete set of RFC2253 flags */
+
+# define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | \
+                        XN_FLAG_SEP_COMMA_PLUS | \
+                        XN_FLAG_DN_REV | \
+                        XN_FLAG_FN_SN | \
+                        XN_FLAG_DUMP_UNKNOWN_FIELDS)
+
+/* readable oneline form */
+
+# define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | \
+                        ASN1_STRFLGS_ESC_QUOTE | \
+                        XN_FLAG_SEP_CPLUS_SPC | \
+                        XN_FLAG_SPC_EQ | \
+                        XN_FLAG_FN_SN)
+
+/* readable multiline form */
+
+# define XN_FLAG_MULTILINE (ASN1_STRFLGS_ESC_CTRL | \
+                        ASN1_STRFLGS_ESC_MSB | \
+                        XN_FLAG_SEP_MULTILINE | \
+                        XN_FLAG_SPC_EQ | \
+                        XN_FLAG_FN_LN | \
+                        XN_FLAG_FN_ALIGN)
+
+typedef struct X509_crl_info_st X509_CRL_INFO;
+
+typedef struct private_key_st {
+    int version;
+    /* The PKCS#8 data types */
+    X509_ALGOR *enc_algor;
+    ASN1_OCTET_STRING *enc_pkey; /* encrypted pub key */
+    /* When decrypted, the following will not be NULL */
+    EVP_PKEY *dec_pkey;
+    /* used to encrypt and decrypt */
+    int key_length;
+    char *key_data;
+    int key_free;               /* true if we should auto free key_data */
+    /* expanded version of 'enc_algor' */
+    EVP_CIPHER_INFO cipher;
+} X509_PKEY;
+
+typedef struct X509_info_st {
+    X509 *x509;
+    X509_CRL *crl;
+    X509_PKEY *x_pkey;
+    EVP_CIPHER_INFO enc_cipher;
+    int enc_len;
+    char *enc_data;
+} X509_INFO;
+SKM_DEFINE_STACK_OF_INTERNAL(X509_INFO, X509_INFO, X509_INFO)
+#define sk_X509_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_value(sk, idx) ((X509_INFO *)OPENSSL_sk_value(ossl_check_const_X509_INFO_sk_type(sk), (idx)))
+#define sk_X509_INFO_new(cmp) ((STACK_OF(X509_INFO) *)OPENSSL_sk_new(ossl_check_X509_INFO_compfunc_type(cmp)))
+#define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)OPENSSL_sk_new_null())
+#define sk_X509_INFO_new_reserve(cmp, n) ((STACK_OF(X509_INFO) *)OPENSSL_sk_new_reserve(ossl_check_X509_INFO_compfunc_type(cmp), (n)))
+#define sk_X509_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_INFO_sk_type(sk), (n))
+#define sk_X509_INFO_free(sk) OPENSSL_sk_free(ossl_check_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_delete(sk, i) ((X509_INFO *)OPENSSL_sk_delete(ossl_check_X509_INFO_sk_type(sk), (i)))
+#define sk_X509_INFO_delete_ptr(sk, ptr) ((X509_INFO *)OPENSSL_sk_delete_ptr(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr)))
+#define sk_X509_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
+#define sk_X509_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
+#define sk_X509_INFO_pop(sk) ((X509_INFO *)OPENSSL_sk_pop(ossl_check_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_shift(sk) ((X509_INFO *)OPENSSL_sk_shift(ossl_check_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_INFO_sk_type(sk),ossl_check_X509_INFO_freefunc_type(freefunc))
+#define sk_X509_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr), (idx))
+#define sk_X509_INFO_set(sk, idx, ptr) ((X509_INFO *)OPENSSL_sk_set(ossl_check_X509_INFO_sk_type(sk), (idx), ossl_check_X509_INFO_type(ptr)))
+#define sk_X509_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
+#define sk_X509_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
+#define sk_X509_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr), pnum)
+#define sk_X509_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_INFO_sk_type(sk))
+#define sk_X509_INFO_dup(sk) ((STACK_OF(X509_INFO) *)OPENSSL_sk_dup(ossl_check_const_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_INFO_sk_type(sk), ossl_check_X509_INFO_copyfunc_type(copyfunc), ossl_check_X509_INFO_freefunc_type(freefunc)))
+#define sk_X509_INFO_set_cmp_func(sk, cmp) ((sk_X509_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_compfunc_type(cmp)))
+
+
+/*
+ * The next 2 structures and their 8 routines are used to manipulate Netscape's
+ * spki structures - useful if you are writing a CA web page
+ */
+typedef struct Netscape_spkac_st {
+    X509_PUBKEY *pubkey;
+    ASN1_IA5STRING *challenge;  /* challenge sent in atlas >= PR2 */
+} NETSCAPE_SPKAC;
+
+typedef struct Netscape_spki_st {
+    NETSCAPE_SPKAC *spkac;      /* signed public key and challenge */
+    X509_ALGOR sig_algor;
+    ASN1_BIT_STRING *signature;
+} NETSCAPE_SPKI;
+
+/* Netscape certificate sequence structure */
+typedef struct Netscape_certificate_sequence {
+    ASN1_OBJECT *type;
+    STACK_OF(X509) *certs;
+} NETSCAPE_CERT_SEQUENCE;
+
+/*- Unused (and iv length is wrong)
+typedef struct CBCParameter_st
+        {
+        unsigned char iv[8];
+        } CBC_PARAM;
+*/
+
+/* Password based encryption structure */
+
+typedef struct PBEPARAM_st {
+    ASN1_OCTET_STRING *salt;
+    ASN1_INTEGER *iter;
+} PBEPARAM;
+
+/* Password based encryption V2 structures */
+
+typedef struct PBE2PARAM_st {
+    X509_ALGOR *keyfunc;
+    X509_ALGOR *encryption;
+} PBE2PARAM;
+
+typedef struct PBKDF2PARAM_st {
+/* Usually OCTET STRING but could be anything */
+    ASN1_TYPE *salt;
+    ASN1_INTEGER *iter;
+    ASN1_INTEGER *keylength;
+    X509_ALGOR *prf;
+} PBKDF2PARAM;
+
+#ifndef OPENSSL_NO_SCRYPT
+typedef struct SCRYPT_PARAMS_st {
+    ASN1_OCTET_STRING *salt;
+    ASN1_INTEGER *costParameter;
+    ASN1_INTEGER *blockSize;
+    ASN1_INTEGER *parallelizationParameter;
+    ASN1_INTEGER *keyLength;
+} SCRYPT_PARAMS;
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+# include <openssl/x509_vfy.h>
+# include <openssl/pkcs7.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+# define X509_EXT_PACK_UNKNOWN   1
+# define X509_EXT_PACK_STRING    2
+
+# define         X509_extract_key(x)     X509_get_pubkey(x)/*****/
+# define         X509_REQ_extract_key(a) X509_REQ_get_pubkey(a)
+# define         X509_name_cmp(a,b)      X509_NAME_cmp((a),(b))
+
+void X509_CRL_set_default_method(const X509_CRL_METHOD *meth);
+X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl),
+                                     int (*crl_free) (X509_CRL *crl),
+                                     int (*crl_lookup) (X509_CRL *crl,
+                                                        X509_REVOKED **ret,
+                                                        const
+                                                        ASN1_INTEGER *serial,
+                                                        const
+                                                        X509_NAME *issuer),
+                                     int (*crl_verify) (X509_CRL *crl,
+                                                        EVP_PKEY *pk));
+void X509_CRL_METHOD_free(X509_CRL_METHOD *m);
+
+void X509_CRL_set_meth_data(X509_CRL *crl, void *dat);
+void *X509_CRL_get_meth_data(X509_CRL *crl);
+
+const char *X509_verify_cert_error_string(long n);
+
+int X509_verify(X509 *a, EVP_PKEY *r);
+int X509_self_signed(X509 *cert, int verify_signature);
+
+int X509_REQ_verify_ex(X509_REQ *a, EVP_PKEY *r, OSSL_LIB_CTX *libctx,
+                       const char *propq);
+int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r);
+int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r);
+int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r);
+
+NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len);
+char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x);
+EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x);
+int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey);
+
+int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki);
+
+int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent);
+int X509_signature_print(BIO *bp, const X509_ALGOR *alg,
+                         const ASN1_STRING *sig);
+
+int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
+int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx);
+int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md);
+int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx);
+int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);
+int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx);
+int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);
+
+int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
+                       unsigned char *md, unsigned int *len);
+int X509_digest(const X509 *data, const EVP_MD *type,
+                unsigned char *md, unsigned int *len);
+ASN1_OCTET_STRING *X509_digest_sig(const X509 *cert,
+                                   EVP_MD **md_used, int *md_is_fallback);
+int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
+                    unsigned char *md, unsigned int *len);
+int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
+                    unsigned char *md, unsigned int *len);
+int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
+                     unsigned char *md, unsigned int *len);
+
+X509 *X509_load_http(const char *url, BIO *bio, BIO *rbio, int timeout);
+X509_CRL *X509_CRL_load_http(const char *url, BIO *bio, BIO *rbio, int timeout);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  include <openssl/http.h> /* OSSL_HTTP_REQ_CTX_nbio_d2i */
+#  define X509_http_nbio(rctx, pcert) \
+      OSSL_HTTP_REQ_CTX_nbio_d2i(rctx, pcert, ASN1_ITEM_rptr(X509))
+#  define X509_CRL_http_nbio(rctx, pcrl) \
+      OSSL_HTTP_REQ_CTX_nbio_d2i(rctx, pcrl, ASN1_ITEM_rptr(X509_CRL))
+# endif
+
+# ifndef OPENSSL_NO_STDIO
+X509 *d2i_X509_fp(FILE *fp, X509 **x509);
+int i2d_X509_fp(FILE *fp, const X509 *x509);
+X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl);
+int i2d_X509_CRL_fp(FILE *fp, const X509_CRL *crl);
+X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req);
+int i2d_X509_REQ_fp(FILE *fp, const X509_REQ *req);
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSAPrivateKey_fp(FILE *fp, const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSAPublicKey_fp(FILE *fp, const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSA_PUBKEY_fp(FILE *fp, const RSA *rsa);
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   ifndef OPENSSL_NO_DSA
+OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_DSA_PUBKEY_fp(FILE *fp, const DSA *dsa);
+OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_DSAPrivateKey_fp(FILE *fp, const DSA *dsa);
+#   endif
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   ifndef OPENSSL_NO_EC
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);
+OSSL_DEPRECATEDIN_3_0 int i2d_EC_PUBKEY_fp(FILE *fp, const EC_KEY *eckey);
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);
+OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey_fp(FILE *fp, const EC_KEY *eckey);
+#   endif /* OPENSSL_NO_EC */
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8);
+int i2d_PKCS8_fp(FILE *fp, const X509_SIG *p8);
+X509_PUBKEY *d2i_X509_PUBKEY_fp(FILE *fp, X509_PUBKEY **xpk);
+int i2d_X509_PUBKEY_fp(FILE *fp, const X509_PUBKEY *xpk);
+PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
+                                                PKCS8_PRIV_KEY_INFO **p8inf);
+int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, const PKCS8_PRIV_KEY_INFO *p8inf);
+int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, const EVP_PKEY *key);
+int i2d_PrivateKey_fp(FILE *fp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_PrivateKey_ex_fp(FILE *fp, EVP_PKEY **a, OSSL_LIB_CTX *libctx,
+                               const char *propq);
+EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a);
+int i2d_PUBKEY_fp(FILE *fp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a);
+# endif
+
+X509 *d2i_X509_bio(BIO *bp, X509 **x509);
+int i2d_X509_bio(BIO *bp, const X509 *x509);
+X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl);
+int i2d_X509_CRL_bio(BIO *bp, const X509_CRL *crl);
+X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req);
+int i2d_X509_REQ_bio(BIO *bp, const X509_REQ *req);
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSAPrivateKey_bio(BIO *bp, const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSAPublicKey_bio(BIO *bp, const RSA *rsa);
+OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_RSA_PUBKEY_bio(BIO *bp, const RSA *rsa);
+#  endif
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   ifndef OPENSSL_NO_DSA
+OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_DSA_PUBKEY_bio(BIO *bp, const DSA *dsa);
+OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);
+OSSL_DEPRECATEDIN_3_0 int i2d_DSAPrivateKey_bio(BIO *bp, const DSA *dsa);
+#   endif
+#  endif
+
+#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#   ifndef OPENSSL_NO_EC
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);
+OSSL_DEPRECATEDIN_3_0 int i2d_EC_PUBKEY_bio(BIO *bp, const EC_KEY *eckey);
+OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);
+OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey_bio(BIO *bp, const EC_KEY *eckey);
+#   endif /* OPENSSL_NO_EC */
+#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8);
+int i2d_PKCS8_bio(BIO *bp, const X509_SIG *p8);
+X509_PUBKEY *d2i_X509_PUBKEY_bio(BIO *bp, X509_PUBKEY **xpk);
+int i2d_X509_PUBKEY_bio(BIO *bp, const X509_PUBKEY *xpk);
+PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
+                                                 PKCS8_PRIV_KEY_INFO **p8inf);
+int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, const PKCS8_PRIV_KEY_INFO *p8inf);
+int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, const EVP_PKEY *key);
+int i2d_PrivateKey_bio(BIO *bp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_PrivateKey_ex_bio(BIO *bp, EVP_PKEY **a, OSSL_LIB_CTX *libctx,
+                                const char *propq);
+EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a);
+int i2d_PUBKEY_bio(BIO *bp, const EVP_PKEY *pkey);
+EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a);
+
+DECLARE_ASN1_DUP_FUNCTION(X509)
+DECLARE_ASN1_DUP_FUNCTION(X509_ALGOR)
+DECLARE_ASN1_DUP_FUNCTION(X509_ATTRIBUTE)
+DECLARE_ASN1_DUP_FUNCTION(X509_CRL)
+DECLARE_ASN1_DUP_FUNCTION(X509_EXTENSION)
+DECLARE_ASN1_DUP_FUNCTION(X509_PUBKEY)
+DECLARE_ASN1_DUP_FUNCTION(X509_REQ)
+DECLARE_ASN1_DUP_FUNCTION(X509_REVOKED)
+int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype,
+                    void *pval);
+void X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype,
+                     const void **ppval, const X509_ALGOR *algor);
+void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md);
+int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b);
+int X509_ALGOR_copy(X509_ALGOR *dest, const X509_ALGOR *src);
+
+DECLARE_ASN1_DUP_FUNCTION(X509_NAME)
+DECLARE_ASN1_DUP_FUNCTION(X509_NAME_ENTRY)
+
+int X509_cmp_time(const ASN1_TIME *s, time_t *t);
+int X509_cmp_current_time(const ASN1_TIME *s);
+int X509_cmp_timeframe(const X509_VERIFY_PARAM *vpm,
+                       const ASN1_TIME *start, const ASN1_TIME *end);
+ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *t);
+ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s,
+                            int offset_day, long offset_sec, time_t *t);
+ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj);
+
+const char *X509_get_default_cert_area(void);
+const char *X509_get_default_cert_dir(void);
+const char *X509_get_default_cert_file(void);
+const char *X509_get_default_cert_dir_env(void);
+const char *X509_get_default_cert_file_env(void);
+const char *X509_get_default_private_dir(void);
+
+X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
+X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey);
+
+DECLARE_ASN1_FUNCTIONS(X509_ALGOR)
+DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS)
+DECLARE_ASN1_FUNCTIONS(X509_VAL)
+
+DECLARE_ASN1_FUNCTIONS(X509_PUBKEY)
+
+X509_PUBKEY *X509_PUBKEY_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);
+EVP_PKEY *X509_PUBKEY_get0(const X509_PUBKEY *key);
+EVP_PKEY *X509_PUBKEY_get(const X509_PUBKEY *key);
+int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain);
+long X509_get_pathlen(X509 *x);
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(EVP_PKEY, PUBKEY)
+EVP_PKEY *d2i_PUBKEY_ex(EVP_PKEY **a, const unsigned char **pp, long length,
+                        OSSL_LIB_CTX *libctx, const char *propq);
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,RSA, RSA_PUBKEY)
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_DSA
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,DSA, DSA_PUBKEY)
+#  endif
+# endif
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  ifndef OPENSSL_NO_EC
+DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, EC_KEY, EC_PUBKEY)
+#  endif
+# endif
+
+DECLARE_ASN1_FUNCTIONS(X509_SIG)
+void X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg,
+                   const ASN1_OCTET_STRING **pdigest);
+void X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg,
+                   ASN1_OCTET_STRING **pdigest);
+
+DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO)
+DECLARE_ASN1_FUNCTIONS(X509_REQ)
+X509_REQ *X509_REQ_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE)
+X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value);
+
+DECLARE_ASN1_FUNCTIONS(X509_EXTENSION)
+DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS)
+
+DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY)
+
+DECLARE_ASN1_FUNCTIONS(X509_NAME)
+
+int X509_NAME_set(X509_NAME **xn, const X509_NAME *name);
+
+DECLARE_ASN1_FUNCTIONS(X509_CINF)
+DECLARE_ASN1_FUNCTIONS(X509)
+X509 *X509_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX)
+
+#define X509_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, l, p, newf, dupf, freef)
+int X509_set_ex_data(X509 *r, int idx, void *arg);
+void *X509_get_ex_data(const X509 *r, int idx);
+DECLARE_ASN1_ENCODE_FUNCTIONS_only(X509,X509_AUX)
+
+int i2d_re_X509_tbs(X509 *x, unsigned char **pp);
+
+int X509_SIG_INFO_get(const X509_SIG_INFO *siginf, int *mdnid, int *pknid,
+                      int *secbits, uint32_t *flags);
+void X509_SIG_INFO_set(X509_SIG_INFO *siginf, int mdnid, int pknid,
+                       int secbits, uint32_t flags);
+
+int X509_get_signature_info(X509 *x, int *mdnid, int *pknid, int *secbits,
+                            uint32_t *flags);
+
+void X509_get0_signature(const ASN1_BIT_STRING **psig,
+                         const X509_ALGOR **palg, const X509 *x);
+int X509_get_signature_nid(const X509 *x);
+
+void X509_set0_distinguishing_id(X509 *x, ASN1_OCTET_STRING *d_id);
+ASN1_OCTET_STRING *X509_get0_distinguishing_id(X509 *x);
+void X509_REQ_set0_distinguishing_id(X509_REQ *x, ASN1_OCTET_STRING *d_id);
+ASN1_OCTET_STRING *X509_REQ_get0_distinguishing_id(X509_REQ *x);
+
+int X509_alias_set1(X509 *x, const unsigned char *name, int len);
+int X509_keyid_set1(X509 *x, const unsigned char *id, int len);
+unsigned char *X509_alias_get0(X509 *x, int *len);
+unsigned char *X509_keyid_get0(X509 *x, int *len);
+
+DECLARE_ASN1_FUNCTIONS(X509_REVOKED)
+DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO)
+DECLARE_ASN1_FUNCTIONS(X509_CRL)
+X509_CRL *X509_CRL_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+
+int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev);
+int X509_CRL_get0_by_serial(X509_CRL *crl,
+                            X509_REVOKED **ret, const ASN1_INTEGER *serial);
+int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x);
+
+X509_PKEY *X509_PKEY_new(void);
+void X509_PKEY_free(X509_PKEY *a);
+
+DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI)
+DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC)
+DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE)
+
+X509_INFO *X509_INFO_new(void);
+void X509_INFO_free(X509_INFO *a);
+char *X509_NAME_oneline(const X509_NAME *a, char *buf, int size);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+OSSL_DEPRECATEDIN_3_0
+int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1,
+                ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey);
+OSSL_DEPRECATEDIN_3_0
+int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data,
+                unsigned char *md, unsigned int *len);
+OSSL_DEPRECATEDIN_3_0
+int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1, X509_ALGOR *algor2,
+              ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey,
+              const EVP_MD *type);
+#endif
+int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *data,
+                     unsigned char *md, unsigned int *len);
+int ASN1_item_verify(const ASN1_ITEM *it, const X509_ALGOR *alg,
+                     const ASN1_BIT_STRING *signature, const void *data,
+                     EVP_PKEY *pkey);
+int ASN1_item_verify_ctx(const ASN1_ITEM *it, const X509_ALGOR *alg,
+                         const ASN1_BIT_STRING *signature, const void *data,
+                         EVP_MD_CTX *ctx);
+int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
+                   ASN1_BIT_STRING *signature, const void *data,
+                   EVP_PKEY *pkey, const EVP_MD *md);
+int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1,
+                       X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
+                       const void *data, EVP_MD_CTX *ctx);
+
+#define X509_VERSION_1 0
+#define X509_VERSION_2 1
+#define X509_VERSION_3 2
+
+long X509_get_version(const X509 *x);
+int X509_set_version(X509 *x, long version);
+int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);
+ASN1_INTEGER *X509_get_serialNumber(X509 *x);
+const ASN1_INTEGER *X509_get0_serialNumber(const X509 *x);
+int X509_set_issuer_name(X509 *x, const X509_NAME *name);
+X509_NAME *X509_get_issuer_name(const X509 *a);
+int X509_set_subject_name(X509 *x, const X509_NAME *name);
+X509_NAME *X509_get_subject_name(const X509 *a);
+const ASN1_TIME * X509_get0_notBefore(const X509 *x);
+ASN1_TIME *X509_getm_notBefore(const X509 *x);
+int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm);
+const ASN1_TIME *X509_get0_notAfter(const X509 *x);
+ASN1_TIME *X509_getm_notAfter(const X509 *x);
+int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm);
+int X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
+int X509_up_ref(X509 *x);
+int X509_get_signature_type(const X509 *x);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define X509_get_notBefore X509_getm_notBefore
+#  define X509_get_notAfter X509_getm_notAfter
+#  define X509_set_notBefore X509_set1_notBefore
+#  define X509_set_notAfter X509_set1_notAfter
+#endif
+
+
+/*
+ * This one is only used so that a binary form can output, as in
+ * i2d_X509_PUBKEY(X509_get_X509_PUBKEY(x), &buf)
+ */
+X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x);
+const STACK_OF(X509_EXTENSION) *X509_get0_extensions(const X509 *x);
+void X509_get0_uids(const X509 *x, const ASN1_BIT_STRING **piuid,
+                    const ASN1_BIT_STRING **psuid);
+const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x);
+
+EVP_PKEY *X509_get0_pubkey(const X509 *x);
+EVP_PKEY *X509_get_pubkey(X509 *x);
+ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x);
+
+#define X509_REQ_VERSION_1 0
+
+long X509_REQ_get_version(const X509_REQ *req);
+int X509_REQ_set_version(X509_REQ *x, long version);
+X509_NAME *X509_REQ_get_subject_name(const X509_REQ *req);
+int X509_REQ_set_subject_name(X509_REQ *req, const X509_NAME *name);
+void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
+                             const X509_ALGOR **palg);
+void X509_REQ_set0_signature(X509_REQ *req, ASN1_BIT_STRING *psig);
+int X509_REQ_set1_signature_algo(X509_REQ *req, X509_ALGOR *palg);
+int X509_REQ_get_signature_nid(const X509_REQ *req);
+int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp);
+int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
+EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req);
+EVP_PKEY *X509_REQ_get0_pubkey(X509_REQ *req);
+X509_PUBKEY *X509_REQ_get_X509_PUBKEY(X509_REQ *req);
+int X509_REQ_extension_nid(int nid);
+int *X509_REQ_get_extension_nids(void);
+void X509_REQ_set_extension_nids(int *nids);
+STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req);
+int X509_REQ_add_extensions_nid(X509_REQ *req,
+                                const STACK_OF(X509_EXTENSION) *exts, int nid);
+int X509_REQ_add_extensions(X509_REQ *req, const STACK_OF(X509_EXTENSION) *ext);
+int X509_REQ_get_attr_count(const X509_REQ *req);
+int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos);
+int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
+                             int lastpos);
+X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc);
+X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc);
+int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr);
+int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
+                              const ASN1_OBJECT *obj, int type,
+                              const unsigned char *bytes, int len);
+int X509_REQ_add1_attr_by_NID(X509_REQ *req,
+                              int nid, int type,
+                              const unsigned char *bytes, int len);
+int X509_REQ_add1_attr_by_txt(X509_REQ *req,
+                              const char *attrname, int type,
+                              const unsigned char *bytes, int len);
+
+#define X509_CRL_VERSION_1 0
+#define X509_CRL_VERSION_2 1
+
+int X509_CRL_set_version(X509_CRL *x, long version);
+int X509_CRL_set_issuer_name(X509_CRL *x, const X509_NAME *name);
+int X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);
+int X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);
+int X509_CRL_sort(X509_CRL *crl);
+int X509_CRL_up_ref(X509_CRL *crl);
+
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define X509_CRL_set_lastUpdate X509_CRL_set1_lastUpdate
+#  define X509_CRL_set_nextUpdate X509_CRL_set1_nextUpdate
+#endif
+
+long X509_CRL_get_version(const X509_CRL *crl);
+const ASN1_TIME *X509_CRL_get0_lastUpdate(const X509_CRL *crl);
+const ASN1_TIME *X509_CRL_get0_nextUpdate(const X509_CRL *crl);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0 ASN1_TIME *X509_CRL_get_lastUpdate(X509_CRL *crl);
+OSSL_DEPRECATEDIN_1_1_0 ASN1_TIME *X509_CRL_get_nextUpdate(X509_CRL *crl);
+#endif
+X509_NAME *X509_CRL_get_issuer(const X509_CRL *crl);
+const STACK_OF(X509_EXTENSION) *X509_CRL_get0_extensions(const X509_CRL *crl);
+STACK_OF(X509_REVOKED) *X509_CRL_get_REVOKED(X509_CRL *crl);
+void X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
+                             const X509_ALGOR **palg);
+int X509_CRL_get_signature_nid(const X509_CRL *crl);
+int i2d_re_X509_CRL_tbs(X509_CRL *req, unsigned char **pp);
+
+const ASN1_INTEGER *X509_REVOKED_get0_serialNumber(const X509_REVOKED *x);
+int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial);
+const ASN1_TIME *X509_REVOKED_get0_revocationDate(const X509_REVOKED *x);
+int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm);
+const STACK_OF(X509_EXTENSION) *
+X509_REVOKED_get0_extensions(const X509_REVOKED *r);
+
+X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer,
+                        EVP_PKEY *skey, const EVP_MD *md, unsigned int flags);
+
+int X509_REQ_check_private_key(X509_REQ *x509, EVP_PKEY *pkey);
+
+int X509_check_private_key(const X509 *x509, const EVP_PKEY *pkey);
+int X509_chain_check_suiteb(int *perror_depth,
+                            X509 *x, STACK_OF(X509) *chain,
+                            unsigned long flags);
+int X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk, unsigned long flags);
+STACK_OF(X509) *X509_chain_up_ref(STACK_OF(X509) *chain);
+
+int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);
+unsigned long X509_issuer_and_serial_hash(X509 *a);
+
+int X509_issuer_name_cmp(const X509 *a, const X509 *b);
+unsigned long X509_issuer_name_hash(X509 *a);
+
+int X509_subject_name_cmp(const X509 *a, const X509 *b);
+unsigned long X509_subject_name_hash(X509 *x);
+
+# ifndef OPENSSL_NO_MD5
+unsigned long X509_issuer_name_hash_old(X509 *a);
+unsigned long X509_subject_name_hash_old(X509 *x);
+# endif
+
+# define X509_ADD_FLAG_DEFAULT  0
+# define X509_ADD_FLAG_UP_REF   0x1
+# define X509_ADD_FLAG_PREPEND  0x2
+# define X509_ADD_FLAG_NO_DUP   0x4
+# define X509_ADD_FLAG_NO_SS    0x8
+int X509_add_cert(STACK_OF(X509) *sk, X509 *cert, int flags);
+int X509_add_certs(STACK_OF(X509) *sk, STACK_OF(X509) *certs, int flags);
+
+int X509_cmp(const X509 *a, const X509 *b);
+int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+# define X509_NAME_hash(x) X509_NAME_hash_ex(x, NULL, NULL, NULL)
+OSSL_DEPRECATEDIN_3_0 int X509_certificate_type(const X509 *x,
+                                                const EVP_PKEY *pubkey);
+#endif
+unsigned long X509_NAME_hash_ex(const X509_NAME *x, OSSL_LIB_CTX *libctx,
+                                const char *propq, int *ok);
+unsigned long X509_NAME_hash_old(const X509_NAME *x);
+
+int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);
+int X509_CRL_match(const X509_CRL *a, const X509_CRL *b);
+int X509_aux_print(BIO *out, X509 *x, int indent);
+# ifndef OPENSSL_NO_STDIO
+int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag,
+                     unsigned long cflag);
+int X509_print_fp(FILE *bp, X509 *x);
+int X509_CRL_print_fp(FILE *bp, X509_CRL *x);
+int X509_REQ_print_fp(FILE *bp, X509_REQ *req);
+int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
+                          unsigned long flags);
+# endif
+
+int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase);
+int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent,
+                       unsigned long flags);
+int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag,
+                  unsigned long cflag);
+int X509_print(BIO *bp, X509 *x);
+int X509_ocspid_print(BIO *bp, X509 *x);
+int X509_CRL_print_ex(BIO *out, X509_CRL *x, unsigned long nmflag);
+int X509_CRL_print(BIO *bp, X509_CRL *x);
+int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag,
+                      unsigned long cflag);
+int X509_REQ_print(BIO *bp, X509_REQ *req);
+
+int X509_NAME_entry_count(const X509_NAME *name);
+int X509_NAME_get_text_by_NID(const X509_NAME *name, int nid,
+                              char *buf, int len);
+int X509_NAME_get_text_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
+                              char *buf, int len);
+
+/*
+ * NOTE: you should be passing -1, not 0 as lastpos. The functions that use
+ * lastpos, search after that position on.
+ */
+int X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos);
+int X509_NAME_get_index_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
+                               int lastpos);
+X509_NAME_ENTRY *X509_NAME_get_entry(const X509_NAME *name, int loc);
+X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);
+int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *ne,
+                        int loc, int set);
+int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
+                               const unsigned char *bytes, int len, int loc,
+                               int set);
+int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
+                               const unsigned char *bytes, int len, int loc,
+                               int set);
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
+                                               const char *field, int type,
+                                               const unsigned char *bytes,
+                                               int len);
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
+                                               int type,
+                                               const unsigned char *bytes,
+                                               int len);
+int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
+                               const unsigned char *bytes, int len, int loc,
+                               int set);
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
+                                               const ASN1_OBJECT *obj, int type,
+                                               const unsigned char *bytes,
+                                               int len);
+int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj);
+int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
+                             const unsigned char *bytes, int len);
+ASN1_OBJECT *X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne);
+ASN1_STRING * X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne);
+int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne);
+
+int X509_NAME_get0_der(const X509_NAME *nm, const unsigned char **pder,
+                       size_t *pderlen);
+
+int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x);
+int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x,
+                          int nid, int lastpos);
+int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x,
+                          const ASN1_OBJECT *obj, int lastpos);
+int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x,
+                               int crit, int lastpos);
+X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc);
+X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc);
+STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
+                                         X509_EXTENSION *ex, int loc);
+
+int X509_get_ext_count(const X509 *x);
+int X509_get_ext_by_NID(const X509 *x, int nid, int lastpos);
+int X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos);
+int X509_get_ext_by_critical(const X509 *x, int crit, int lastpos);
+X509_EXTENSION *X509_get_ext(const X509 *x, int loc);
+X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
+int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
+void *X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx);
+int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit,
+                      unsigned long flags);
+
+int X509_CRL_get_ext_count(const X509_CRL *x);
+int X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos);
+int X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj,
+                            int lastpos);
+int X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos);
+X509_EXTENSION *X509_CRL_get_ext(const X509_CRL *x, int loc);
+X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);
+int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);
+void *X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx);
+int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
+                          unsigned long flags);
+
+int X509_REVOKED_get_ext_count(const X509_REVOKED *x);
+int X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos);
+int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
+                                int lastpos);
+int X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit,
+                                     int lastpos);
+X509_EXTENSION *X509_REVOKED_get_ext(const X509_REVOKED *x, int loc);
+X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);
+int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc);
+void *X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit,
+                               int *idx);
+int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
+                              unsigned long flags);
+
+X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,
+                                             int nid, int crit,
+                                             ASN1_OCTET_STRING *data);
+X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
+                                             const ASN1_OBJECT *obj, int crit,
+                                             ASN1_OCTET_STRING *data);
+int X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj);
+int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);
+int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data);
+ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex);
+ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
+int X509_EXTENSION_get_critical(const X509_EXTENSION *ex);
+
+int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x);
+int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
+                           int lastpos);
+int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
+                           const ASN1_OBJECT *obj, int lastpos);
+X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc);
+X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc);
+STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
+                                           X509_ATTRIBUTE *attr);
+STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)
+                                                  **x, const ASN1_OBJECT *obj,
+                                                  int type,
+                                                  const unsigned char *bytes,
+                                                  int len);
+STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)
+                                                  **x, int nid, int type,
+                                                  const unsigned char *bytes,
+                                                  int len);
+STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)
+                                                  **x, const char *attrname,
+                                                  int type,
+                                                  const unsigned char *bytes,
+                                                  int len);
+void *X509at_get0_data_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *x,
+                              const ASN1_OBJECT *obj, int lastpos, int type);
+X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
+                                             int atrtype, const void *data,
+                                             int len);
+X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
+                                             const ASN1_OBJECT *obj,
+                                             int atrtype, const void *data,
+                                             int len);
+X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
+                                             const char *atrname, int type,
+                                             const unsigned char *bytes,
+                                             int len);
+int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj);
+int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
+                             const void *data, int len);
+void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype,
+                               void *data);
+int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr);
+ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr);
+ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx);
+
+int EVP_PKEY_get_attr_count(const EVP_PKEY *key);
+int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos);
+int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj,
+                             int lastpos);
+X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc);
+X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc);
+int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr);
+int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,
+                              const ASN1_OBJECT *obj, int type,
+                              const unsigned char *bytes, int len);
+int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,
+                              int nid, int type,
+                              const unsigned char *bytes, int len);
+int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,
+                              const char *attrname, int type,
+                              const unsigned char *bytes, int len);
+
+/* lookup a cert from a X509 STACK */
+X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, const X509_NAME *name,
+                                     const ASN1_INTEGER *serial);
+X509 *X509_find_by_subject(STACK_OF(X509) *sk, const X509_NAME *name);
+
+DECLARE_ASN1_FUNCTIONS(PBEPARAM)
+DECLARE_ASN1_FUNCTIONS(PBE2PARAM)
+DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM)
+#ifndef OPENSSL_NO_SCRYPT
+DECLARE_ASN1_FUNCTIONS(SCRYPT_PARAMS)
+#endif
+
+int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
+                         const unsigned char *salt, int saltlen);
+int PKCS5_pbe_set0_algor_ex(X509_ALGOR *algor, int alg, int iter,
+                            const unsigned char *salt, int saltlen,
+                            OSSL_LIB_CTX *libctx);
+
+X509_ALGOR *PKCS5_pbe_set(int alg, int iter,
+                          const unsigned char *salt, int saltlen);
+X509_ALGOR *PKCS5_pbe_set_ex(int alg, int iter,
+                             const unsigned char *salt, int saltlen,
+                             OSSL_LIB_CTX *libctx);
+
+X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
+                           unsigned char *salt, int saltlen);
+X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,
+                              unsigned char *salt, int saltlen,
+                              unsigned char *aiv, int prf_nid);
+X509_ALGOR *PKCS5_pbe2_set_iv_ex(const EVP_CIPHER *cipher, int iter,
+                                 unsigned char *salt, int saltlen,
+                                 unsigned char *aiv, int prf_nid,
+                                 OSSL_LIB_CTX *libctx);
+
+#ifndef OPENSSL_NO_SCRYPT
+X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher,
+                                  const unsigned char *salt, int saltlen,
+                                  unsigned char *aiv, uint64_t N, uint64_t r,
+                                  uint64_t p);
+#endif
+
+X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
+                             int prf_nid, int keylen);
+X509_ALGOR *PKCS5_pbkdf2_set_ex(int iter, unsigned char *salt, int saltlen,
+                                int prf_nid, int keylen,
+                                OSSL_LIB_CTX *libctx);
+
+/* PKCS#8 utilities */
+
+DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO)
+
+EVP_PKEY *EVP_PKCS82PKEY(const PKCS8_PRIV_KEY_INFO *p8);
+EVP_PKEY *EVP_PKCS82PKEY_ex(const PKCS8_PRIV_KEY_INFO *p8, OSSL_LIB_CTX *libctx,
+                            const char *propq);
+PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(const EVP_PKEY *pkey);
+
+int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj,
+                    int version, int ptype, void *pval,
+                    unsigned char *penc, int penclen);
+int PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg,
+                    const unsigned char **pk, int *ppklen,
+                    const X509_ALGOR **pa, const PKCS8_PRIV_KEY_INFO *p8);
+
+const STACK_OF(X509_ATTRIBUTE) *
+PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8);
+int PKCS8_pkey_add1_attr(PKCS8_PRIV_KEY_INFO *p8, X509_ATTRIBUTE *attr);
+int PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
+                                const unsigned char *bytes, int len);
+int PKCS8_pkey_add1_attr_by_OBJ(PKCS8_PRIV_KEY_INFO *p8, const ASN1_OBJECT *obj,
+                                int type, const unsigned char *bytes, int len);
+
+
+int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
+                           int ptype, void *pval,
+                           unsigned char *penc, int penclen);
+int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
+                           const unsigned char **pk, int *ppklen,
+                           X509_ALGOR **pa, const X509_PUBKEY *pub);
+int X509_PUBKEY_eq(const X509_PUBKEY *a, const X509_PUBKEY *b);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509_vfy.h b/CAPI/cpp/grpc/include/openssl/x509_vfy.h
new file mode 100644
index 0000000..e04df0d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/x509_vfy.h
@@ -0,0 +1,894 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\x509_vfy.h.in
+ *
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_X509_VFY_H
+# define OPENSSL_X509_VFY_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_X509_VFY_H
+# endif
+
+/*
+ * Protect against recursion, x509.h and x509_vfy.h each include the other.
+ */
+# ifndef OPENSSL_X509_H
+#  include <openssl/x509.h>
+# endif
+
+# include <openssl/opensslconf.h>
+# include <openssl/lhash.h>
+# include <openssl/bio.h>
+# include <openssl/crypto.h>
+# include <openssl/symhacks.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/*-
+SSL_CTX -> X509_STORE
+                -> X509_LOOKUP
+                        ->X509_LOOKUP_METHOD
+                -> X509_LOOKUP
+                        ->X509_LOOKUP_METHOD
+
+SSL     -> X509_STORE_CTX
+                ->X509_STORE
+
+The X509_STORE holds the tables etc for verification stuff.
+A X509_STORE_CTX is used while validating a single certificate.
+The X509_STORE has X509_LOOKUPs for looking up certs.
+The X509_STORE then calls a function to actually verify the
+certificate chain.
+*/
+
+typedef enum {
+    X509_LU_NONE = 0,
+    X509_LU_X509, X509_LU_CRL
+} X509_LOOKUP_TYPE;
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define X509_LU_RETRY   -1
+#define X509_LU_FAIL    0
+#endif
+
+SKM_DEFINE_STACK_OF_INTERNAL(X509_LOOKUP, X509_LOOKUP, X509_LOOKUP)
+#define sk_X509_LOOKUP_num(sk) OPENSSL_sk_num(ossl_check_const_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_value(sk, idx) ((X509_LOOKUP *)OPENSSL_sk_value(ossl_check_const_X509_LOOKUP_sk_type(sk), (idx)))
+#define sk_X509_LOOKUP_new(cmp) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new(ossl_check_X509_LOOKUP_compfunc_type(cmp)))
+#define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new_null())
+#define sk_X509_LOOKUP_new_reserve(cmp, n) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new_reserve(ossl_check_X509_LOOKUP_compfunc_type(cmp), (n)))
+#define sk_X509_LOOKUP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_LOOKUP_sk_type(sk), (n))
+#define sk_X509_LOOKUP_free(sk) OPENSSL_sk_free(ossl_check_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_zero(sk) OPENSSL_sk_zero(ossl_check_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_delete(sk, i) ((X509_LOOKUP *)OPENSSL_sk_delete(ossl_check_X509_LOOKUP_sk_type(sk), (i)))
+#define sk_X509_LOOKUP_delete_ptr(sk, ptr) ((X509_LOOKUP *)OPENSSL_sk_delete_ptr(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr)))
+#define sk_X509_LOOKUP_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
+#define sk_X509_LOOKUP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
+#define sk_X509_LOOKUP_pop(sk) ((X509_LOOKUP *)OPENSSL_sk_pop(ossl_check_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_shift(sk) ((X509_LOOKUP *)OPENSSL_sk_shift(ossl_check_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_LOOKUP_sk_type(sk),ossl_check_X509_LOOKUP_freefunc_type(freefunc))
+#define sk_X509_LOOKUP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr), (idx))
+#define sk_X509_LOOKUP_set(sk, idx, ptr) ((X509_LOOKUP *)OPENSSL_sk_set(ossl_check_X509_LOOKUP_sk_type(sk), (idx), ossl_check_X509_LOOKUP_type(ptr)))
+#define sk_X509_LOOKUP_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
+#define sk_X509_LOOKUP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
+#define sk_X509_LOOKUP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr), pnum)
+#define sk_X509_LOOKUP_sort(sk) OPENSSL_sk_sort(ossl_check_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_LOOKUP_sk_type(sk))
+#define sk_X509_LOOKUP_dup(sk) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_dup(ossl_check_const_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_copyfunc_type(copyfunc), ossl_check_X509_LOOKUP_freefunc_type(freefunc)))
+#define sk_X509_LOOKUP_set_cmp_func(sk, cmp) ((sk_X509_LOOKUP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509_OBJECT, X509_OBJECT, X509_OBJECT)
+#define sk_X509_OBJECT_num(sk) OPENSSL_sk_num(ossl_check_const_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_value(sk, idx) ((X509_OBJECT *)OPENSSL_sk_value(ossl_check_const_X509_OBJECT_sk_type(sk), (idx)))
+#define sk_X509_OBJECT_new(cmp) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new(ossl_check_X509_OBJECT_compfunc_type(cmp)))
+#define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new_null())
+#define sk_X509_OBJECT_new_reserve(cmp, n) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new_reserve(ossl_check_X509_OBJECT_compfunc_type(cmp), (n)))
+#define sk_X509_OBJECT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_OBJECT_sk_type(sk), (n))
+#define sk_X509_OBJECT_free(sk) OPENSSL_sk_free(ossl_check_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_zero(sk) OPENSSL_sk_zero(ossl_check_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_delete(sk, i) ((X509_OBJECT *)OPENSSL_sk_delete(ossl_check_X509_OBJECT_sk_type(sk), (i)))
+#define sk_X509_OBJECT_delete_ptr(sk, ptr) ((X509_OBJECT *)OPENSSL_sk_delete_ptr(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr)))
+#define sk_X509_OBJECT_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
+#define sk_X509_OBJECT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
+#define sk_X509_OBJECT_pop(sk) ((X509_OBJECT *)OPENSSL_sk_pop(ossl_check_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_shift(sk) ((X509_OBJECT *)OPENSSL_sk_shift(ossl_check_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_OBJECT_sk_type(sk),ossl_check_X509_OBJECT_freefunc_type(freefunc))
+#define sk_X509_OBJECT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr), (idx))
+#define sk_X509_OBJECT_set(sk, idx, ptr) ((X509_OBJECT *)OPENSSL_sk_set(ossl_check_X509_OBJECT_sk_type(sk), (idx), ossl_check_X509_OBJECT_type(ptr)))
+#define sk_X509_OBJECT_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
+#define sk_X509_OBJECT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
+#define sk_X509_OBJECT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr), pnum)
+#define sk_X509_OBJECT_sort(sk) OPENSSL_sk_sort(ossl_check_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_OBJECT_sk_type(sk))
+#define sk_X509_OBJECT_dup(sk) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_dup(ossl_check_const_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_copyfunc_type(copyfunc), ossl_check_X509_OBJECT_freefunc_type(freefunc)))
+#define sk_X509_OBJECT_set_cmp_func(sk, cmp) ((sk_X509_OBJECT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(X509_VERIFY_PARAM, X509_VERIFY_PARAM, X509_VERIFY_PARAM)
+#define sk_X509_VERIFY_PARAM_num(sk) OPENSSL_sk_num(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_value(sk, idx) ((X509_VERIFY_PARAM *)OPENSSL_sk_value(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk), (idx)))
+#define sk_X509_VERIFY_PARAM_new(cmp) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new(ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp)))
+#define sk_X509_VERIFY_PARAM_new_null() ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new_null())
+#define sk_X509_VERIFY_PARAM_new_reserve(cmp, n) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new_reserve(ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp), (n)))
+#define sk_X509_VERIFY_PARAM_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (n))
+#define sk_X509_VERIFY_PARAM_free(sk) OPENSSL_sk_free(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_zero(sk) OPENSSL_sk_zero(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_delete(sk, i) ((X509_VERIFY_PARAM *)OPENSSL_sk_delete(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (i)))
+#define sk_X509_VERIFY_PARAM_delete_ptr(sk, ptr) ((X509_VERIFY_PARAM *)OPENSSL_sk_delete_ptr(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr)))
+#define sk_X509_VERIFY_PARAM_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
+#define sk_X509_VERIFY_PARAM_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
+#define sk_X509_VERIFY_PARAM_pop(sk) ((X509_VERIFY_PARAM *)OPENSSL_sk_pop(ossl_check_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_shift(sk) ((X509_VERIFY_PARAM *)OPENSSL_sk_shift(ossl_check_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_VERIFY_PARAM_sk_type(sk),ossl_check_X509_VERIFY_PARAM_freefunc_type(freefunc))
+#define sk_X509_VERIFY_PARAM_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr), (idx))
+#define sk_X509_VERIFY_PARAM_set(sk, idx, ptr) ((X509_VERIFY_PARAM *)OPENSSL_sk_set(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (idx), ossl_check_X509_VERIFY_PARAM_type(ptr)))
+#define sk_X509_VERIFY_PARAM_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
+#define sk_X509_VERIFY_PARAM_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
+#define sk_X509_VERIFY_PARAM_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr), pnum)
+#define sk_X509_VERIFY_PARAM_sort(sk) OPENSSL_sk_sort(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk))
+#define sk_X509_VERIFY_PARAM_dup(sk) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_dup(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_copyfunc_type(copyfunc), ossl_check_X509_VERIFY_PARAM_freefunc_type(freefunc)))
+#define sk_X509_VERIFY_PARAM_set_cmp_func(sk, cmp) ((sk_X509_VERIFY_PARAM_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp)))
+
+
+/* This is used for a table of trust checking functions */
+typedef struct x509_trust_st {
+    int trust;
+    int flags;
+    int (*check_trust) (struct x509_trust_st *, X509 *, int);
+    char *name;
+    int arg1;
+    void *arg2;
+} X509_TRUST;
+SKM_DEFINE_STACK_OF_INTERNAL(X509_TRUST, X509_TRUST, X509_TRUST)
+#define sk_X509_TRUST_num(sk) OPENSSL_sk_num(ossl_check_const_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_value(sk, idx) ((X509_TRUST *)OPENSSL_sk_value(ossl_check_const_X509_TRUST_sk_type(sk), (idx)))
+#define sk_X509_TRUST_new(cmp) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new(ossl_check_X509_TRUST_compfunc_type(cmp)))
+#define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new_null())
+#define sk_X509_TRUST_new_reserve(cmp, n) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new_reserve(ossl_check_X509_TRUST_compfunc_type(cmp), (n)))
+#define sk_X509_TRUST_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_TRUST_sk_type(sk), (n))
+#define sk_X509_TRUST_free(sk) OPENSSL_sk_free(ossl_check_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_zero(sk) OPENSSL_sk_zero(ossl_check_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_delete(sk, i) ((X509_TRUST *)OPENSSL_sk_delete(ossl_check_X509_TRUST_sk_type(sk), (i)))
+#define sk_X509_TRUST_delete_ptr(sk, ptr) ((X509_TRUST *)OPENSSL_sk_delete_ptr(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr)))
+#define sk_X509_TRUST_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
+#define sk_X509_TRUST_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
+#define sk_X509_TRUST_pop(sk) ((X509_TRUST *)OPENSSL_sk_pop(ossl_check_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_shift(sk) ((X509_TRUST *)OPENSSL_sk_shift(ossl_check_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_TRUST_sk_type(sk),ossl_check_X509_TRUST_freefunc_type(freefunc))
+#define sk_X509_TRUST_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr), (idx))
+#define sk_X509_TRUST_set(sk, idx, ptr) ((X509_TRUST *)OPENSSL_sk_set(ossl_check_X509_TRUST_sk_type(sk), (idx), ossl_check_X509_TRUST_type(ptr)))
+#define sk_X509_TRUST_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
+#define sk_X509_TRUST_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
+#define sk_X509_TRUST_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr), pnum)
+#define sk_X509_TRUST_sort(sk) OPENSSL_sk_sort(ossl_check_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_TRUST_sk_type(sk))
+#define sk_X509_TRUST_dup(sk) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_dup(ossl_check_const_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_copyfunc_type(copyfunc), ossl_check_X509_TRUST_freefunc_type(freefunc)))
+#define sk_X509_TRUST_set_cmp_func(sk, cmp) ((sk_X509_TRUST_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_compfunc_type(cmp)))
+
+
+/* standard trust ids */
+# define X509_TRUST_DEFAULT      0 /* Only valid in purpose settings */
+# define X509_TRUST_COMPAT       1
+# define X509_TRUST_SSL_CLIENT   2
+# define X509_TRUST_SSL_SERVER   3
+# define X509_TRUST_EMAIL        4
+# define X509_TRUST_OBJECT_SIGN  5
+# define X509_TRUST_OCSP_SIGN    6
+# define X509_TRUST_OCSP_REQUEST 7
+# define X509_TRUST_TSA          8
+/* Keep these up to date! */
+# define X509_TRUST_MIN          1
+# define X509_TRUST_MAX          8
+
+/* trust_flags values */
+# define X509_TRUST_DYNAMIC      (1U << 0)
+# define X509_TRUST_DYNAMIC_NAME (1U << 1)
+/* No compat trust if self-signed, preempts "DO_SS" */
+# define X509_TRUST_NO_SS_COMPAT (1U << 2)
+/* Compat trust if no explicit accepted trust EKUs */
+# define X509_TRUST_DO_SS_COMPAT (1U << 3)
+/* Accept "anyEKU" as a wildcard rejection OID and as a wildcard trust OID */
+# define X509_TRUST_OK_ANY_EKU   (1U << 4)
+
+/* check_trust return codes */
+# define X509_TRUST_TRUSTED      1
+# define X509_TRUST_REJECTED     2
+# define X509_TRUST_UNTRUSTED    3
+
+int X509_TRUST_set(int *t, int trust);
+int X509_TRUST_get_count(void);
+X509_TRUST *X509_TRUST_get0(int idx);
+int X509_TRUST_get_by_id(int id);
+int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int),
+                   const char *name, int arg1, void *arg2);
+void X509_TRUST_cleanup(void);
+int X509_TRUST_get_flags(const X509_TRUST *xp);
+char *X509_TRUST_get0_name(const X509_TRUST *xp);
+int X509_TRUST_get_trust(const X509_TRUST *xp);
+
+int X509_trusted(const X509 *x);
+int X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj);
+int X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj);
+void X509_trust_clear(X509 *x);
+void X509_reject_clear(X509 *x);
+STACK_OF(ASN1_OBJECT) *X509_get0_trust_objects(X509 *x);
+STACK_OF(ASN1_OBJECT) *X509_get0_reject_objects(X509 *x);
+
+int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *,
+                                                                int);
+int X509_check_trust(X509 *x, int id, int flags);
+
+int X509_verify_cert(X509_STORE_CTX *ctx);
+int X509_STORE_CTX_verify(X509_STORE_CTX *ctx);
+STACK_OF(X509) *X509_build_chain(X509 *target, STACK_OF(X509) *certs,
+                                 X509_STORE *store, int with_self_signed,
+                                 OSSL_LIB_CTX *libctx, const char *propq);
+
+int X509_STORE_set_depth(X509_STORE *store, int depth);
+
+typedef int (*X509_STORE_CTX_verify_cb)(int, X509_STORE_CTX *);
+int X509_STORE_CTX_print_verify_cb(int ok, X509_STORE_CTX *ctx);
+typedef int (*X509_STORE_CTX_verify_fn)(X509_STORE_CTX *);
+typedef int (*X509_STORE_CTX_get_issuer_fn)(X509 **issuer,
+                                            X509_STORE_CTX *ctx, X509 *x);
+typedef int (*X509_STORE_CTX_check_issued_fn)(X509_STORE_CTX *ctx,
+                                              X509 *x, X509 *issuer);
+typedef int (*X509_STORE_CTX_check_revocation_fn)(X509_STORE_CTX *ctx);
+typedef int (*X509_STORE_CTX_get_crl_fn)(X509_STORE_CTX *ctx,
+                                         X509_CRL **crl, X509 *x);
+typedef int (*X509_STORE_CTX_check_crl_fn)(X509_STORE_CTX *ctx, X509_CRL *crl);
+typedef int (*X509_STORE_CTX_cert_crl_fn)(X509_STORE_CTX *ctx,
+                                          X509_CRL *crl, X509 *x);
+typedef int (*X509_STORE_CTX_check_policy_fn)(X509_STORE_CTX *ctx);
+typedef STACK_OF(X509)
+    *(*X509_STORE_CTX_lookup_certs_fn)(X509_STORE_CTX *ctx,
+                                       const X509_NAME *nm);
+typedef STACK_OF(X509_CRL)
+    *(*X509_STORE_CTX_lookup_crls_fn)(const X509_STORE_CTX *ctx,
+                                      const X509_NAME *nm);
+typedef int (*X509_STORE_CTX_cleanup_fn)(X509_STORE_CTX *ctx);
+
+void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth);
+
+# define X509_STORE_CTX_set_app_data(ctx,data) \
+        X509_STORE_CTX_set_ex_data(ctx,0,data)
+# define X509_STORE_CTX_get_app_data(ctx) \
+        X509_STORE_CTX_get_ex_data(ctx,0)
+
+# define X509_L_FILE_LOAD        1
+# define X509_L_ADD_DIR          2
+# define X509_L_ADD_STORE        3
+# define X509_L_LOAD_STORE       4
+
+# define X509_LOOKUP_load_file(x,name,type) \
+                X509_LOOKUP_ctrl((x),X509_L_FILE_LOAD,(name),(long)(type),NULL)
+
+# define X509_LOOKUP_add_dir(x,name,type) \
+                X509_LOOKUP_ctrl((x),X509_L_ADD_DIR,(name),(long)(type),NULL)
+
+# define X509_LOOKUP_add_store(x,name) \
+                X509_LOOKUP_ctrl((x),X509_L_ADD_STORE,(name),0,NULL)
+
+# define X509_LOOKUP_load_store(x,name) \
+                X509_LOOKUP_ctrl((x),X509_L_LOAD_STORE,(name),0,NULL)
+
+# define X509_LOOKUP_load_file_ex(x, name, type, libctx, propq)       \
+X509_LOOKUP_ctrl_ex((x), X509_L_FILE_LOAD, (name), (long)(type), NULL,\
+                    (libctx), (propq))
+
+# define X509_LOOKUP_load_store_ex(x, name, libctx, propq)            \
+X509_LOOKUP_ctrl_ex((x), X509_L_LOAD_STORE, (name), 0, NULL,          \
+                    (libctx), (propq))
+
+# define X509_LOOKUP_add_store_ex(x, name, libctx, propq)             \
+X509_LOOKUP_ctrl_ex((x), X509_L_ADD_STORE, (name), 0, NULL,           \
+                    (libctx), (propq))
+
+# define X509_V_OK                                       0
+# define X509_V_ERR_UNSPECIFIED                          1
+# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT            2
+# define X509_V_ERR_UNABLE_TO_GET_CRL                    3
+# define X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE     4
+# define X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE      5
+# define X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY   6
+# define X509_V_ERR_CERT_SIGNATURE_FAILURE               7
+# define X509_V_ERR_CRL_SIGNATURE_FAILURE                8
+# define X509_V_ERR_CERT_NOT_YET_VALID                   9
+# define X509_V_ERR_CERT_HAS_EXPIRED                     10
+# define X509_V_ERR_CRL_NOT_YET_VALID                    11
+# define X509_V_ERR_CRL_HAS_EXPIRED                      12
+# define X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD       13
+# define X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD        14
+# define X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD       15
+# define X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD       16
+# define X509_V_ERR_OUT_OF_MEM                           17
+# define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT          18
+# define X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN            19
+# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY    20
+# define X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE      21
+# define X509_V_ERR_CERT_CHAIN_TOO_LONG                  22
+# define X509_V_ERR_CERT_REVOKED                         23
+# define X509_V_ERR_NO_ISSUER_PUBLIC_KEY                 24
+# define X509_V_ERR_PATH_LENGTH_EXCEEDED                 25
+# define X509_V_ERR_INVALID_PURPOSE                      26
+# define X509_V_ERR_CERT_UNTRUSTED                       27
+# define X509_V_ERR_CERT_REJECTED                        28
+
+/* These are 'informational' when looking for issuer cert */
+# define X509_V_ERR_SUBJECT_ISSUER_MISMATCH              29
+# define X509_V_ERR_AKID_SKID_MISMATCH                   30
+# define X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH          31
+# define X509_V_ERR_KEYUSAGE_NO_CERTSIGN                 32
+# define X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER             33
+# define X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION         34
+# define X509_V_ERR_KEYUSAGE_NO_CRL_SIGN                 35
+# define X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION     36
+# define X509_V_ERR_INVALID_NON_CA                       37
+# define X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED           38
+# define X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE        39
+# define X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED       40
+# define X509_V_ERR_INVALID_EXTENSION                    41
+# define X509_V_ERR_INVALID_POLICY_EXTENSION             42
+# define X509_V_ERR_NO_EXPLICIT_POLICY                   43
+# define X509_V_ERR_DIFFERENT_CRL_SCOPE                  44
+# define X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE        45
+# define X509_V_ERR_UNNESTED_RESOURCE                    46
+# define X509_V_ERR_PERMITTED_VIOLATION                  47
+# define X509_V_ERR_EXCLUDED_VIOLATION                   48
+# define X509_V_ERR_SUBTREE_MINMAX                       49
+/* The application is not happy */
+# define X509_V_ERR_APPLICATION_VERIFICATION             50
+# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE          51
+# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX        52
+# define X509_V_ERR_UNSUPPORTED_NAME_SYNTAX              53
+# define X509_V_ERR_CRL_PATH_VALIDATION_ERROR            54
+/* Another issuer check debug option */
+# define X509_V_ERR_PATH_LOOP                            55
+/* Suite B mode algorithm violation */
+# define X509_V_ERR_SUITE_B_INVALID_VERSION              56
+# define X509_V_ERR_SUITE_B_INVALID_ALGORITHM            57
+# define X509_V_ERR_SUITE_B_INVALID_CURVE                58
+# define X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM  59
+# define X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED              60
+# define X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 61
+/* Host, email and IP check errors */
+# define X509_V_ERR_HOSTNAME_MISMATCH                    62
+# define X509_V_ERR_EMAIL_MISMATCH                       63
+# define X509_V_ERR_IP_ADDRESS_MISMATCH                  64
+/* DANE TLSA errors */
+# define X509_V_ERR_DANE_NO_MATCH                        65
+/* security level errors */
+# define X509_V_ERR_EE_KEY_TOO_SMALL                     66
+# define X509_V_ERR_CA_KEY_TOO_SMALL                     67
+# define X509_V_ERR_CA_MD_TOO_WEAK                       68
+/* Caller error */
+# define X509_V_ERR_INVALID_CALL                         69
+/* Issuer lookup error */
+# define X509_V_ERR_STORE_LOOKUP                         70
+/* Certificate transparency */
+# define X509_V_ERR_NO_VALID_SCTS                        71
+
+# define X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION         72
+/* OCSP status errors */
+# define X509_V_ERR_OCSP_VERIFY_NEEDED                   73  /* Need OCSP verification */
+# define X509_V_ERR_OCSP_VERIFY_FAILED                   74  /* Couldn't verify cert through OCSP */
+# define X509_V_ERR_OCSP_CERT_UNKNOWN                    75  /* Certificate wasn't recognized by the OCSP responder */
+
+# define X509_V_ERR_UNSUPPORTED_SIGNATURE_ALGORITHM      76
+# define X509_V_ERR_SIGNATURE_ALGORITHM_MISMATCH         77
+
+/* Errors in case a check in X509_V_FLAG_X509_STRICT mode fails */
+# define X509_V_ERR_SIGNATURE_ALGORITHM_INCONSISTENCY    78
+# define X509_V_ERR_INVALID_CA                           79
+# define X509_V_ERR_PATHLEN_INVALID_FOR_NON_CA           80
+# define X509_V_ERR_PATHLEN_WITHOUT_KU_KEY_CERT_SIGN     81
+# define X509_V_ERR_KU_KEY_CERT_SIGN_INVALID_FOR_NON_CA  82
+# define X509_V_ERR_ISSUER_NAME_EMPTY                    83
+# define X509_V_ERR_SUBJECT_NAME_EMPTY                   84
+# define X509_V_ERR_MISSING_AUTHORITY_KEY_IDENTIFIER     85
+# define X509_V_ERR_MISSING_SUBJECT_KEY_IDENTIFIER       86
+# define X509_V_ERR_EMPTY_SUBJECT_ALT_NAME               87
+# define X509_V_ERR_EMPTY_SUBJECT_SAN_NOT_CRITICAL       88
+# define X509_V_ERR_CA_BCONS_NOT_CRITICAL                89
+# define X509_V_ERR_AUTHORITY_KEY_IDENTIFIER_CRITICAL    90
+# define X509_V_ERR_SUBJECT_KEY_IDENTIFIER_CRITICAL      91
+# define X509_V_ERR_CA_CERT_MISSING_KEY_USAGE            92
+# define X509_V_ERR_EXTENSIONS_REQUIRE_VERSION_3         93
+# define X509_V_ERR_EC_KEY_EXPLICIT_PARAMS               94
+
+/* Certificate verify flags */
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#  define X509_V_FLAG_CB_ISSUER_CHECK             0x0   /* Deprecated */
+# endif
+/* Use check time instead of current time */
+# define X509_V_FLAG_USE_CHECK_TIME              0x2
+/* Lookup CRLs */
+# define X509_V_FLAG_CRL_CHECK                   0x4
+/* Lookup CRLs for whole chain */
+# define X509_V_FLAG_CRL_CHECK_ALL               0x8
+/* Ignore unhandled critical extensions */
+# define X509_V_FLAG_IGNORE_CRITICAL             0x10
+/* Disable workarounds for broken certificates */
+# define X509_V_FLAG_X509_STRICT                 0x20
+/* Enable proxy certificate validation */
+# define X509_V_FLAG_ALLOW_PROXY_CERTS           0x40
+/* Enable policy checking */
+# define X509_V_FLAG_POLICY_CHECK                0x80
+/* Policy variable require-explicit-policy */
+# define X509_V_FLAG_EXPLICIT_POLICY             0x100
+/* Policy variable inhibit-any-policy */
+# define X509_V_FLAG_INHIBIT_ANY                 0x200
+/* Policy variable inhibit-policy-mapping */
+# define X509_V_FLAG_INHIBIT_MAP                 0x400
+/* Notify callback that policy is OK */
+# define X509_V_FLAG_NOTIFY_POLICY               0x800
+/* Extended CRL features such as indirect CRLs, alternate CRL signing keys */
+# define X509_V_FLAG_EXTENDED_CRL_SUPPORT        0x1000
+/* Delta CRL support */
+# define X509_V_FLAG_USE_DELTAS                  0x2000
+/* Check self-signed CA signature */
+# define X509_V_FLAG_CHECK_SS_SIGNATURE          0x4000
+/* Use trusted store first */
+# define X509_V_FLAG_TRUSTED_FIRST               0x8000
+/* Suite B 128 bit only mode: not normally used */
+# define X509_V_FLAG_SUITEB_128_LOS_ONLY         0x10000
+/* Suite B 192 bit only mode */
+# define X509_V_FLAG_SUITEB_192_LOS              0x20000
+/* Suite B 128 bit mode allowing 192 bit algorithms */
+# define X509_V_FLAG_SUITEB_128_LOS              0x30000
+/* Allow partial chains if at least one certificate is in trusted store */
+# define X509_V_FLAG_PARTIAL_CHAIN               0x80000
+/*
+ * If the initial chain is not trusted, do not attempt to build an alternative
+ * chain. Alternate chain checking was introduced in 1.1.0. Setting this flag
+ * will force the behaviour to match that of previous versions.
+ */
+# define X509_V_FLAG_NO_ALT_CHAINS               0x100000
+/* Do not check certificate/CRL validity against current time */
+# define X509_V_FLAG_NO_CHECK_TIME               0x200000
+
+# define X509_VP_FLAG_DEFAULT                    0x1
+# define X509_VP_FLAG_OVERWRITE                  0x2
+# define X509_VP_FLAG_RESET_FLAGS                0x4
+# define X509_VP_FLAG_LOCKED                     0x8
+# define X509_VP_FLAG_ONCE                       0x10
+
+/* Internal use: mask of policy related options */
+# define X509_V_FLAG_POLICY_MASK (X509_V_FLAG_POLICY_CHECK \
+                                | X509_V_FLAG_EXPLICIT_POLICY \
+                                | X509_V_FLAG_INHIBIT_ANY \
+                                | X509_V_FLAG_INHIBIT_MAP)
+
+int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
+                               const X509_NAME *name);
+X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h,
+                                             X509_LOOKUP_TYPE type,
+                                             const X509_NAME *name);
+X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h,
+                                        X509_OBJECT *x);
+int X509_OBJECT_up_ref_count(X509_OBJECT *a);
+X509_OBJECT *X509_OBJECT_new(void);
+void X509_OBJECT_free(X509_OBJECT *a);
+X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a);
+X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a);
+int X509_OBJECT_set1_X509(X509_OBJECT *a, X509 *obj);
+X509_CRL *X509_OBJECT_get0_X509_CRL(const X509_OBJECT *a);
+int X509_OBJECT_set1_X509_CRL(X509_OBJECT *a, X509_CRL *obj);
+X509_STORE *X509_STORE_new(void);
+void X509_STORE_free(X509_STORE *v);
+int X509_STORE_lock(X509_STORE *ctx);
+int X509_STORE_unlock(X509_STORE *ctx);
+int X509_STORE_up_ref(X509_STORE *v);
+STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(const X509_STORE *v);
+STACK_OF(X509) *X509_STORE_get1_all_certs(X509_STORE *st);
+STACK_OF(X509) *X509_STORE_CTX_get1_certs(X509_STORE_CTX *st,
+                                          const X509_NAME *nm);
+STACK_OF(X509_CRL) *X509_STORE_CTX_get1_crls(const X509_STORE_CTX *st,
+                                             const X509_NAME *nm);
+int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags);
+int X509_STORE_set_purpose(X509_STORE *ctx, int purpose);
+int X509_STORE_set_trust(X509_STORE *ctx, int trust);
+int X509_STORE_set1_param(X509_STORE *ctx, const X509_VERIFY_PARAM *pm);
+X509_VERIFY_PARAM *X509_STORE_get0_param(const X509_STORE *ctx);
+
+void X509_STORE_set_verify(X509_STORE *ctx, X509_STORE_CTX_verify_fn verify);
+#define X509_STORE_set_verify_func(ctx, func) \
+            X509_STORE_set_verify((ctx),(func))
+void X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx,
+                               X509_STORE_CTX_verify_fn verify);
+X509_STORE_CTX_verify_fn X509_STORE_get_verify(const X509_STORE *ctx);
+void X509_STORE_set_verify_cb(X509_STORE *ctx,
+                              X509_STORE_CTX_verify_cb verify_cb);
+# define X509_STORE_set_verify_cb_func(ctx,func) \
+            X509_STORE_set_verify_cb((ctx),(func))
+X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(const X509_STORE *ctx);
+void X509_STORE_set_get_issuer(X509_STORE *ctx,
+                               X509_STORE_CTX_get_issuer_fn get_issuer);
+X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(const X509_STORE *ctx);
+void X509_STORE_set_check_issued(X509_STORE *ctx,
+                                 X509_STORE_CTX_check_issued_fn check_issued);
+X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(const X509_STORE *ctx);
+void X509_STORE_set_check_revocation(X509_STORE *ctx,
+                                     X509_STORE_CTX_check_revocation_fn check_revocation);
+X509_STORE_CTX_check_revocation_fn
+    X509_STORE_get_check_revocation(const X509_STORE *ctx);
+void X509_STORE_set_get_crl(X509_STORE *ctx,
+                            X509_STORE_CTX_get_crl_fn get_crl);
+X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(const X509_STORE *ctx);
+void X509_STORE_set_check_crl(X509_STORE *ctx,
+                              X509_STORE_CTX_check_crl_fn check_crl);
+X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(const X509_STORE *ctx);
+void X509_STORE_set_cert_crl(X509_STORE *ctx,
+                             X509_STORE_CTX_cert_crl_fn cert_crl);
+X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(const X509_STORE *ctx);
+void X509_STORE_set_check_policy(X509_STORE *ctx,
+                                 X509_STORE_CTX_check_policy_fn check_policy);
+X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(const X509_STORE *ctx);
+void X509_STORE_set_lookup_certs(X509_STORE *ctx,
+                                 X509_STORE_CTX_lookup_certs_fn lookup_certs);
+X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(const X509_STORE *ctx);
+void X509_STORE_set_lookup_crls(X509_STORE *ctx,
+                                X509_STORE_CTX_lookup_crls_fn lookup_crls);
+#define X509_STORE_set_lookup_crls_cb(ctx, func) \
+    X509_STORE_set_lookup_crls((ctx), (func))
+X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(const X509_STORE *ctx);
+void X509_STORE_set_cleanup(X509_STORE *ctx,
+                            X509_STORE_CTX_cleanup_fn cleanup);
+X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(const X509_STORE *ctx);
+
+#define X509_STORE_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE, l, p, newf, dupf, freef)
+int X509_STORE_set_ex_data(X509_STORE *ctx, int idx, void *data);
+void *X509_STORE_get_ex_data(const X509_STORE *ctx, int idx);
+
+X509_STORE_CTX *X509_STORE_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+X509_STORE_CTX *X509_STORE_CTX_new(void);
+
+int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x);
+
+void X509_STORE_CTX_free(X509_STORE_CTX *ctx);
+int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *trust_store,
+                        X509 *target, STACK_OF(X509) *untrusted);
+void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk);
+void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx);
+
+X509_STORE *X509_STORE_CTX_get0_store(const X509_STORE_CTX *ctx);
+X509 *X509_STORE_CTX_get0_cert(const X509_STORE_CTX *ctx);
+STACK_OF(X509)* X509_STORE_CTX_get0_untrusted(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk);
+void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
+                                  X509_STORE_CTX_verify_cb verify);
+X509_STORE_CTX_verify_cb X509_STORE_CTX_get_verify_cb(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_verify_fn X509_STORE_CTX_get_verify(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_get_issuer_fn X509_STORE_CTX_get_get_issuer(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_check_issued_fn X509_STORE_CTX_get_check_issued(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_check_revocation_fn X509_STORE_CTX_get_check_revocation(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_get_crl_fn X509_STORE_CTX_get_get_crl(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_check_crl_fn X509_STORE_CTX_get_check_crl(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_cert_crl_fn X509_STORE_CTX_get_cert_crl(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_check_policy_fn X509_STORE_CTX_get_check_policy(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_lookup_certs_fn X509_STORE_CTX_get_lookup_certs(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_lookup_crls_fn X509_STORE_CTX_get_lookup_crls(const X509_STORE_CTX *ctx);
+X509_STORE_CTX_cleanup_fn X509_STORE_CTX_get_cleanup(const X509_STORE_CTX *ctx);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+# define X509_STORE_CTX_get_chain X509_STORE_CTX_get0_chain
+# define X509_STORE_CTX_set_chain X509_STORE_CTX_set0_untrusted
+# define X509_STORE_CTX_trusted_stack X509_STORE_CTX_set0_trusted_stack
+# define X509_STORE_get_by_subject X509_STORE_CTX_get_by_subject
+# define X509_STORE_get1_certs X509_STORE_CTX_get1_certs
+# define X509_STORE_get1_crls X509_STORE_CTX_get1_crls
+/* the following macro is misspelled; use X509_STORE_get1_certs instead */
+# define X509_STORE_get1_cert X509_STORE_CTX_get1_certs
+/* the following macro is misspelled; use X509_STORE_get1_crls instead */
+# define X509_STORE_get1_crl X509_STORE_CTX_get1_crls
+#endif
+
+X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m);
+X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void);
+X509_LOOKUP_METHOD *X509_LOOKUP_file(void);
+X509_LOOKUP_METHOD *X509_LOOKUP_store(void);
+
+typedef int (*X509_LOOKUP_ctrl_fn)(X509_LOOKUP *ctx, int cmd, const char *argc,
+                                   long argl, char **ret);
+typedef int (*X509_LOOKUP_ctrl_ex_fn)(
+    X509_LOOKUP *ctx, int cmd, const char *argc, long argl, char **ret,
+    OSSL_LIB_CTX *libctx, const char *propq);
+
+typedef int (*X509_LOOKUP_get_by_subject_fn)(X509_LOOKUP *ctx,
+                                             X509_LOOKUP_TYPE type,
+                                             const X509_NAME *name,
+                                             X509_OBJECT *ret);
+typedef int (*X509_LOOKUP_get_by_subject_ex_fn)(X509_LOOKUP *ctx,
+                                                         X509_LOOKUP_TYPE type,
+                                                         const X509_NAME *name,
+                                                         X509_OBJECT *ret,
+                                                         OSSL_LIB_CTX *libctx,
+                                                         const char *propq);
+typedef int (*X509_LOOKUP_get_by_issuer_serial_fn)(X509_LOOKUP *ctx,
+                                                   X509_LOOKUP_TYPE type,
+                                                   const X509_NAME *name,
+                                                   const ASN1_INTEGER *serial,
+                                                   X509_OBJECT *ret);
+typedef int (*X509_LOOKUP_get_by_fingerprint_fn)(X509_LOOKUP *ctx,
+                                                 X509_LOOKUP_TYPE type,
+                                                 const unsigned char* bytes,
+                                                 int len,
+                                                 X509_OBJECT *ret);
+typedef int (*X509_LOOKUP_get_by_alias_fn)(X509_LOOKUP *ctx,
+                                           X509_LOOKUP_TYPE type,
+                                           const char *str,
+                                           int len,
+                                           X509_OBJECT *ret);
+
+X509_LOOKUP_METHOD *X509_LOOKUP_meth_new(const char *name);
+void X509_LOOKUP_meth_free(X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_new_item(X509_LOOKUP_METHOD *method,
+                                  int (*new_item) (X509_LOOKUP *ctx));
+int (*X509_LOOKUP_meth_get_new_item(const X509_LOOKUP_METHOD* method))
+    (X509_LOOKUP *ctx);
+
+int X509_LOOKUP_meth_set_free(X509_LOOKUP_METHOD *method,
+                              void (*free_fn) (X509_LOOKUP *ctx));
+void (*X509_LOOKUP_meth_get_free(const X509_LOOKUP_METHOD* method))
+    (X509_LOOKUP *ctx);
+
+int X509_LOOKUP_meth_set_init(X509_LOOKUP_METHOD *method,
+                              int (*init) (X509_LOOKUP *ctx));
+int (*X509_LOOKUP_meth_get_init(const X509_LOOKUP_METHOD* method))
+    (X509_LOOKUP *ctx);
+
+int X509_LOOKUP_meth_set_shutdown(X509_LOOKUP_METHOD *method,
+                                  int (*shutdown) (X509_LOOKUP *ctx));
+int (*X509_LOOKUP_meth_get_shutdown(const X509_LOOKUP_METHOD* method))
+    (X509_LOOKUP *ctx);
+
+int X509_LOOKUP_meth_set_ctrl(X509_LOOKUP_METHOD *method,
+                              X509_LOOKUP_ctrl_fn ctrl_fn);
+X509_LOOKUP_ctrl_fn X509_LOOKUP_meth_get_ctrl(const X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_get_by_subject(X509_LOOKUP_METHOD *method,
+                                        X509_LOOKUP_get_by_subject_fn fn);
+X509_LOOKUP_get_by_subject_fn X509_LOOKUP_meth_get_get_by_subject(
+    const X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_get_by_issuer_serial(X509_LOOKUP_METHOD *method,
+    X509_LOOKUP_get_by_issuer_serial_fn fn);
+X509_LOOKUP_get_by_issuer_serial_fn X509_LOOKUP_meth_get_get_by_issuer_serial(
+    const X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_get_by_fingerprint(X509_LOOKUP_METHOD *method,
+    X509_LOOKUP_get_by_fingerprint_fn fn);
+X509_LOOKUP_get_by_fingerprint_fn X509_LOOKUP_meth_get_get_by_fingerprint(
+    const X509_LOOKUP_METHOD *method);
+
+int X509_LOOKUP_meth_set_get_by_alias(X509_LOOKUP_METHOD *method,
+                                      X509_LOOKUP_get_by_alias_fn fn);
+X509_LOOKUP_get_by_alias_fn X509_LOOKUP_meth_get_get_by_alias(
+    const X509_LOOKUP_METHOD *method);
+
+
+int X509_STORE_add_cert(X509_STORE *ctx, X509 *x);
+int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x);
+
+int X509_STORE_CTX_get_by_subject(const X509_STORE_CTX *vs,
+                                  X509_LOOKUP_TYPE type,
+                                  const X509_NAME *name, X509_OBJECT *ret);
+X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs,
+                                               X509_LOOKUP_TYPE type,
+                                               const X509_NAME *name);
+
+int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc,
+                     long argl, char **ret);
+int X509_LOOKUP_ctrl_ex(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
+                        char **ret, OSSL_LIB_CTX *libctx, const char *propq);
+
+int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type);
+int X509_load_cert_file_ex(X509_LOOKUP *ctx, const char *file, int type,
+                           OSSL_LIB_CTX *libctx, const char *propq);
+int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type);
+int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type);
+int X509_load_cert_crl_file_ex(X509_LOOKUP *ctx, const char *file, int type,
+                               OSSL_LIB_CTX *libctx, const char *propq);
+
+X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method);
+void X509_LOOKUP_free(X509_LOOKUP *ctx);
+int X509_LOOKUP_init(X509_LOOKUP *ctx);
+int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                           const X509_NAME *name, X509_OBJECT *ret);
+int X509_LOOKUP_by_subject_ex(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                              const X509_NAME *name, X509_OBJECT *ret,
+                              OSSL_LIB_CTX *libctx, const char *propq);
+int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                                 const X509_NAME *name,
+                                 const ASN1_INTEGER *serial,
+                                 X509_OBJECT *ret);
+int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                               const unsigned char *bytes, int len,
+                               X509_OBJECT *ret);
+int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
+                         const char *str, int len, X509_OBJECT *ret);
+int X509_LOOKUP_set_method_data(X509_LOOKUP *ctx, void *data);
+void *X509_LOOKUP_get_method_data(const X509_LOOKUP *ctx);
+X509_STORE *X509_LOOKUP_get_store(const X509_LOOKUP *ctx);
+int X509_LOOKUP_shutdown(X509_LOOKUP *ctx);
+
+int X509_STORE_load_file(X509_STORE *ctx, const char *file);
+int X509_STORE_load_path(X509_STORE *ctx, const char *path);
+int X509_STORE_load_store(X509_STORE *ctx, const char *store);
+int X509_STORE_load_locations(X509_STORE *ctx,
+                                               const char *file,
+                                               const char *dir);
+int X509_STORE_set_default_paths(X509_STORE *ctx);
+
+int X509_STORE_load_file_ex(X509_STORE *ctx, const char *file,
+                            OSSL_LIB_CTX *libctx, const char *propq);
+int X509_STORE_load_store_ex(X509_STORE *ctx, const char *store,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+int X509_STORE_load_locations_ex(X509_STORE *ctx, const char *file,
+                                 const char *dir, OSSL_LIB_CTX *libctx,
+                                 const char *propq);
+int X509_STORE_set_default_paths_ex(X509_STORE *ctx, OSSL_LIB_CTX *libctx,
+                                    const char *propq);
+
+#define X509_STORE_CTX_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, l, p, newf, dupf, freef)
+int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data);
+void *X509_STORE_CTX_get_ex_data(const X509_STORE_CTX *ctx, int idx);
+int X509_STORE_CTX_get_error(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int s);
+int X509_STORE_CTX_get_error_depth(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth);
+X509 *X509_STORE_CTX_get_current_cert(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x);
+X509 *X509_STORE_CTX_get0_current_issuer(const X509_STORE_CTX *ctx);
+X509_CRL *X509_STORE_CTX_get0_current_crl(const X509_STORE_CTX *ctx);
+X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(const X509_STORE_CTX *ctx);
+STACK_OF(X509) *X509_STORE_CTX_get0_chain(const X509_STORE_CTX *ctx);
+STACK_OF(X509) *X509_STORE_CTX_get1_chain(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *target);
+void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *c, STACK_OF(X509) *sk);
+void X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk);
+int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose);
+int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust);
+int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
+                                   int purpose, int trust);
+void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags);
+void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags,
+                             time_t t);
+
+X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(const X509_STORE_CTX *ctx);
+int X509_STORE_CTX_get_explicit_policy(const X509_STORE_CTX *ctx);
+int X509_STORE_CTX_get_num_untrusted(const X509_STORE_CTX *ctx);
+
+X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(const X509_STORE_CTX *ctx);
+void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param);
+int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name);
+
+/*
+ * Bridge opacity barrier between libcrypt and libssl, also needed to support
+ * offline testing in test/danetest.c
+ */
+void X509_STORE_CTX_set0_dane(X509_STORE_CTX *ctx, SSL_DANE *dane);
+#define DANE_FLAG_NO_DANE_EE_NAMECHECKS (1L << 0)
+
+/* X509_VERIFY_PARAM functions */
+
+X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void);
+void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *to,
+                              const X509_VERIFY_PARAM *from);
+int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to,
+                           const X509_VERIFY_PARAM *from);
+int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name);
+int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param,
+                                unsigned long flags);
+int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param,
+                                  unsigned long flags);
+unsigned long X509_VERIFY_PARAM_get_flags(const X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose);
+int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust);
+void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth);
+void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level);
+time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param);
+void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t);
+int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param,
+                                  ASN1_OBJECT *policy);
+int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
+                                    STACK_OF(ASN1_OBJECT) *policies);
+
+int X509_VERIFY_PARAM_set_inh_flags(X509_VERIFY_PARAM *param,
+                                    uint32_t flags);
+uint32_t X509_VERIFY_PARAM_get_inh_flags(const X509_VERIFY_PARAM *param);
+
+char *X509_VERIFY_PARAM_get0_host(X509_VERIFY_PARAM *param, int idx);
+int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
+                                const char *name, size_t namelen);
+int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
+                                const char *name, size_t namelen);
+void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param,
+                                     unsigned int flags);
+unsigned int X509_VERIFY_PARAM_get_hostflags(const X509_VERIFY_PARAM *param);
+char *X509_VERIFY_PARAM_get0_peername(const X509_VERIFY_PARAM *param);
+void X509_VERIFY_PARAM_move_peername(X509_VERIFY_PARAM *, X509_VERIFY_PARAM *);
+char *X509_VERIFY_PARAM_get0_email(X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,
+                                 const char *email, size_t emaillen);
+char *X509_VERIFY_PARAM_get1_ip_asc(X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param,
+                              const unsigned char *ip, size_t iplen);
+int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param,
+                                  const char *ipasc);
+
+int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_get_auth_level(const X509_VERIFY_PARAM *param);
+const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param);
+
+int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param);
+int X509_VERIFY_PARAM_get_count(void);
+const X509_VERIFY_PARAM *X509_VERIFY_PARAM_get0(int id);
+const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name);
+void X509_VERIFY_PARAM_table_cleanup(void);
+
+/* Non positive return values are errors */
+#define X509_PCY_TREE_FAILURE  -2 /* Failure to satisfy explicit policy */
+#define X509_PCY_TREE_INVALID  -1 /* Inconsistent or invalid extensions */
+#define X509_PCY_TREE_INTERNAL  0 /* Internal error, most likely malloc */
+
+/*
+ * Positive return values form a bit mask, all but the first are internal to
+ * the library and don't appear in results from X509_policy_check().
+ */
+#define X509_PCY_TREE_VALID     1 /* The policy tree is valid */
+#define X509_PCY_TREE_EMPTY     2 /* The policy tree is empty */
+#define X509_PCY_TREE_EXPLICIT  4 /* Explicit policy required */
+
+int X509_policy_check(X509_POLICY_TREE **ptree, int *pexplicit_policy,
+                      STACK_OF(X509) *certs,
+                      STACK_OF(ASN1_OBJECT) *policy_oids, unsigned int flags);
+
+void X509_policy_tree_free(X509_POLICY_TREE *tree);
+
+int X509_policy_tree_level_count(const X509_POLICY_TREE *tree);
+X509_POLICY_LEVEL *X509_policy_tree_get0_level(const X509_POLICY_TREE *tree,
+                                               int i);
+
+STACK_OF(X509_POLICY_NODE)
+    *X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree);
+
+STACK_OF(X509_POLICY_NODE)
+    *X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree);
+
+int X509_policy_level_node_count(X509_POLICY_LEVEL *level);
+
+X509_POLICY_NODE *X509_policy_level_get0_node(const X509_POLICY_LEVEL *level,
+                                              int i);
+
+const ASN1_OBJECT *X509_policy_node_get0_policy(const X509_POLICY_NODE *node);
+
+STACK_OF(POLICYQUALINFO)
+    *X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node);
+const X509_POLICY_NODE
+    *X509_policy_node_get0_parent(const X509_POLICY_NODE *node);
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509err.h b/CAPI/cpp/grpc/include/openssl/x509err.h
new file mode 100644
index 0000000..a56facd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/x509err.h
@@ -0,0 +1,68 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_X509ERR_H
+# define OPENSSL_X509ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * X509 reason codes.
+ */
+# define X509_R_AKID_MISMATCH                             110
+# define X509_R_BAD_SELECTOR                              133
+# define X509_R_BAD_X509_FILETYPE                         100
+# define X509_R_BASE64_DECODE_ERROR                       118
+# define X509_R_CANT_CHECK_DH_KEY                         114
+# define X509_R_CERTIFICATE_VERIFICATION_FAILED           139
+# define X509_R_CERT_ALREADY_IN_HASH_TABLE                101
+# define X509_R_CRL_ALREADY_DELTA                         127
+# define X509_R_CRL_VERIFY_FAILURE                        131
+# define X509_R_ERROR_GETTING_MD_BY_NID                   141
+# define X509_R_ERROR_USING_SIGINF_SET                    142
+# define X509_R_IDP_MISMATCH                              128
+# define X509_R_INVALID_ATTRIBUTES                        138
+# define X509_R_INVALID_DIRECTORY                         113
+# define X509_R_INVALID_DISTPOINT                         143
+# define X509_R_INVALID_FIELD_NAME                        119
+# define X509_R_INVALID_TRUST                             123
+# define X509_R_ISSUER_MISMATCH                           129
+# define X509_R_KEY_TYPE_MISMATCH                         115
+# define X509_R_KEY_VALUES_MISMATCH                       116
+# define X509_R_LOADING_CERT_DIR                          103
+# define X509_R_LOADING_DEFAULTS                          104
+# define X509_R_METHOD_NOT_SUPPORTED                      124
+# define X509_R_NAME_TOO_LONG                             134
+# define X509_R_NEWER_CRL_NOT_NEWER                       132
+# define X509_R_NO_CERTIFICATE_FOUND                      135
+# define X509_R_NO_CERTIFICATE_OR_CRL_FOUND               136
+# define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY              105
+# define X509_R_NO_CRL_FOUND                              137
+# define X509_R_NO_CRL_NUMBER                             130
+# define X509_R_PUBLIC_KEY_DECODE_ERROR                   125
+# define X509_R_PUBLIC_KEY_ENCODE_ERROR                   126
+# define X509_R_SHOULD_RETRY                              106
+# define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN        107
+# define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY            108
+# define X509_R_UNKNOWN_KEY_TYPE                          117
+# define X509_R_UNKNOWN_NID                               109
+# define X509_R_UNKNOWN_PURPOSE_ID                        121
+# define X509_R_UNKNOWN_SIGID_ALGS                        144
+# define X509_R_UNKNOWN_TRUST_ID                          120
+# define X509_R_UNSUPPORTED_ALGORITHM                     111
+# define X509_R_WRONG_LOOKUP_TYPE                         112
+# define X509_R_WRONG_TYPE                                122
+
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509v3.h b/CAPI/cpp/grpc/include/openssl/x509v3.h
new file mode 100644
index 0000000..78c390b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/x509v3.h
@@ -0,0 +1,1450 @@
+/*
+ * WARNING: do not edit!
+ * Generated by makefile from include\openssl\x509v3.h.in
+ *
+ * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+
+
+#ifndef OPENSSL_X509V3_H
+# define OPENSSL_X509V3_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_X509V3_H
+# endif
+
+# include <openssl/bio.h>
+# include <openssl/x509.h>
+# include <openssl/conf.h>
+# include <openssl/x509v3err.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward reference */
+struct v3_ext_method;
+struct v3_ext_ctx;
+
+/* Useful typedefs */
+
+typedef void *(*X509V3_EXT_NEW)(void);
+typedef void (*X509V3_EXT_FREE) (void *);
+typedef void *(*X509V3_EXT_D2I)(void *, const unsigned char **, long);
+typedef int (*X509V3_EXT_I2D) (const void *, unsigned char **);
+typedef STACK_OF(CONF_VALUE) *
+    (*X509V3_EXT_I2V) (const struct v3_ext_method *method, void *ext,
+                       STACK_OF(CONF_VALUE) *extlist);
+typedef void *(*X509V3_EXT_V2I)(const struct v3_ext_method *method,
+                                struct v3_ext_ctx *ctx,
+                                STACK_OF(CONF_VALUE) *values);
+typedef char *(*X509V3_EXT_I2S)(const struct v3_ext_method *method,
+                                void *ext);
+typedef void *(*X509V3_EXT_S2I)(const struct v3_ext_method *method,
+                                struct v3_ext_ctx *ctx, const char *str);
+typedef int (*X509V3_EXT_I2R) (const struct v3_ext_method *method, void *ext,
+                               BIO *out, int indent);
+typedef void *(*X509V3_EXT_R2I)(const struct v3_ext_method *method,
+                                struct v3_ext_ctx *ctx, const char *str);
+
+/* V3 extension structure */
+
+struct v3_ext_method {
+    int ext_nid;
+    int ext_flags;
+/* If this is set the following four fields are ignored */
+    ASN1_ITEM_EXP *it;
+/* Old style ASN1 calls */
+    X509V3_EXT_NEW ext_new;
+    X509V3_EXT_FREE ext_free;
+    X509V3_EXT_D2I d2i;
+    X509V3_EXT_I2D i2d;
+/* The following pair is used for string extensions */
+    X509V3_EXT_I2S i2s;
+    X509V3_EXT_S2I s2i;
+/* The following pair is used for multi-valued extensions */
+    X509V3_EXT_I2V i2v;
+    X509V3_EXT_V2I v2i;
+/* The following are used for raw extensions */
+    X509V3_EXT_I2R i2r;
+    X509V3_EXT_R2I r2i;
+    void *usr_data;             /* Any extension specific data */
+};
+
+typedef struct X509V3_CONF_METHOD_st {
+    char *(*get_string) (void *db, const char *section, const char *value);
+    STACK_OF(CONF_VALUE) *(*get_section) (void *db, const char *section);
+    void (*free_string) (void *db, char *string);
+    void (*free_section) (void *db, STACK_OF(CONF_VALUE) *section);
+} X509V3_CONF_METHOD;
+
+/* Context specific info for producing X509 v3 extensions*/
+struct v3_ext_ctx {
+# define X509V3_CTX_TEST 0x1
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define CTX_TEST X509V3_CTX_TEST
+# endif
+# define X509V3_CTX_REPLACE 0x2
+    int flags;
+    X509 *issuer_cert;
+    X509 *subject_cert;
+    X509_REQ *subject_req;
+    X509_CRL *crl;
+    X509V3_CONF_METHOD *db_meth;
+    void *db;
+    EVP_PKEY *issuer_pkey;
+/* Maybe more here */
+};
+
+typedef struct v3_ext_method X509V3_EXT_METHOD;
+
+SKM_DEFINE_STACK_OF_INTERNAL(X509V3_EXT_METHOD, X509V3_EXT_METHOD, X509V3_EXT_METHOD)
+#define sk_X509V3_EXT_METHOD_num(sk) OPENSSL_sk_num(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_value(sk, idx) ((X509V3_EXT_METHOD *)OPENSSL_sk_value(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk), (idx)))
+#define sk_X509V3_EXT_METHOD_new(cmp) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new(ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp)))
+#define sk_X509V3_EXT_METHOD_new_null() ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new_null())
+#define sk_X509V3_EXT_METHOD_new_reserve(cmp, n) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new_reserve(ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp), (n)))
+#define sk_X509V3_EXT_METHOD_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (n))
+#define sk_X509V3_EXT_METHOD_free(sk) OPENSSL_sk_free(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_zero(sk) OPENSSL_sk_zero(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_delete(sk, i) ((X509V3_EXT_METHOD *)OPENSSL_sk_delete(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (i)))
+#define sk_X509V3_EXT_METHOD_delete_ptr(sk, ptr) ((X509V3_EXT_METHOD *)OPENSSL_sk_delete_ptr(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr)))
+#define sk_X509V3_EXT_METHOD_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
+#define sk_X509V3_EXT_METHOD_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
+#define sk_X509V3_EXT_METHOD_pop(sk) ((X509V3_EXT_METHOD *)OPENSSL_sk_pop(ossl_check_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_shift(sk) ((X509V3_EXT_METHOD *)OPENSSL_sk_shift(ossl_check_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509V3_EXT_METHOD_sk_type(sk),ossl_check_X509V3_EXT_METHOD_freefunc_type(freefunc))
+#define sk_X509V3_EXT_METHOD_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr), (idx))
+#define sk_X509V3_EXT_METHOD_set(sk, idx, ptr) ((X509V3_EXT_METHOD *)OPENSSL_sk_set(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (idx), ossl_check_X509V3_EXT_METHOD_type(ptr)))
+#define sk_X509V3_EXT_METHOD_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
+#define sk_X509V3_EXT_METHOD_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
+#define sk_X509V3_EXT_METHOD_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr), pnum)
+#define sk_X509V3_EXT_METHOD_sort(sk) OPENSSL_sk_sort(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk))
+#define sk_X509V3_EXT_METHOD_dup(sk) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_dup(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_deep_copy(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_copyfunc_type(copyfunc), ossl_check_X509V3_EXT_METHOD_freefunc_type(freefunc)))
+#define sk_X509V3_EXT_METHOD_set_cmp_func(sk, cmp) ((sk_X509V3_EXT_METHOD_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp)))
+
+
+/* ext_flags values */
+# define X509V3_EXT_DYNAMIC      0x1
+# define X509V3_EXT_CTX_DEP      0x2
+# define X509V3_EXT_MULTILINE    0x4
+
+typedef BIT_STRING_BITNAME ENUMERATED_NAMES;
+
+typedef struct BASIC_CONSTRAINTS_st {
+    int ca;
+    ASN1_INTEGER *pathlen;
+} BASIC_CONSTRAINTS;
+
+typedef struct PKEY_USAGE_PERIOD_st {
+    ASN1_GENERALIZEDTIME *notBefore;
+    ASN1_GENERALIZEDTIME *notAfter;
+} PKEY_USAGE_PERIOD;
+
+typedef struct otherName_st {
+    ASN1_OBJECT *type_id;
+    ASN1_TYPE *value;
+} OTHERNAME;
+
+typedef struct EDIPartyName_st {
+    ASN1_STRING *nameAssigner;
+    ASN1_STRING *partyName;
+} EDIPARTYNAME;
+
+typedef struct GENERAL_NAME_st {
+# define GEN_OTHERNAME   0
+# define GEN_EMAIL       1
+# define GEN_DNS         2
+# define GEN_X400        3
+# define GEN_DIRNAME     4
+# define GEN_EDIPARTY    5
+# define GEN_URI         6
+# define GEN_IPADD       7
+# define GEN_RID         8
+    int type;
+    union {
+        char *ptr;
+        OTHERNAME *otherName;   /* otherName */
+        ASN1_IA5STRING *rfc822Name;
+        ASN1_IA5STRING *dNSName;
+        ASN1_TYPE *x400Address;
+        X509_NAME *directoryName;
+        EDIPARTYNAME *ediPartyName;
+        ASN1_IA5STRING *uniformResourceIdentifier;
+        ASN1_OCTET_STRING *iPAddress;
+        ASN1_OBJECT *registeredID;
+        /* Old names */
+        ASN1_OCTET_STRING *ip;  /* iPAddress */
+        X509_NAME *dirn;        /* dirn */
+        ASN1_IA5STRING *ia5;    /* rfc822Name, dNSName,
+                                 * uniformResourceIdentifier */
+        ASN1_OBJECT *rid;       /* registeredID */
+        ASN1_TYPE *other;       /* x400Address */
+    } d;
+} GENERAL_NAME;
+
+typedef struct ACCESS_DESCRIPTION_st {
+    ASN1_OBJECT *method;
+    GENERAL_NAME *location;
+} ACCESS_DESCRIPTION;
+
+SKM_DEFINE_STACK_OF_INTERNAL(ACCESS_DESCRIPTION, ACCESS_DESCRIPTION, ACCESS_DESCRIPTION)
+#define sk_ACCESS_DESCRIPTION_num(sk) OPENSSL_sk_num(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_value(sk, idx) ((ACCESS_DESCRIPTION *)OPENSSL_sk_value(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk), (idx)))
+#define sk_ACCESS_DESCRIPTION_new(cmp) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new(ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp)))
+#define sk_ACCESS_DESCRIPTION_new_null() ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new_null())
+#define sk_ACCESS_DESCRIPTION_new_reserve(cmp, n) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new_reserve(ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp), (n)))
+#define sk_ACCESS_DESCRIPTION_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (n))
+#define sk_ACCESS_DESCRIPTION_free(sk) OPENSSL_sk_free(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_zero(sk) OPENSSL_sk_zero(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_delete(sk, i) ((ACCESS_DESCRIPTION *)OPENSSL_sk_delete(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (i)))
+#define sk_ACCESS_DESCRIPTION_delete_ptr(sk, ptr) ((ACCESS_DESCRIPTION *)OPENSSL_sk_delete_ptr(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr)))
+#define sk_ACCESS_DESCRIPTION_push(sk, ptr) OPENSSL_sk_push(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
+#define sk_ACCESS_DESCRIPTION_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
+#define sk_ACCESS_DESCRIPTION_pop(sk) ((ACCESS_DESCRIPTION *)OPENSSL_sk_pop(ossl_check_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_shift(sk) ((ACCESS_DESCRIPTION *)OPENSSL_sk_shift(ossl_check_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ACCESS_DESCRIPTION_sk_type(sk),ossl_check_ACCESS_DESCRIPTION_freefunc_type(freefunc))
+#define sk_ACCESS_DESCRIPTION_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr), (idx))
+#define sk_ACCESS_DESCRIPTION_set(sk, idx, ptr) ((ACCESS_DESCRIPTION *)OPENSSL_sk_set(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (idx), ossl_check_ACCESS_DESCRIPTION_type(ptr)))
+#define sk_ACCESS_DESCRIPTION_find(sk, ptr) OPENSSL_sk_find(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
+#define sk_ACCESS_DESCRIPTION_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
+#define sk_ACCESS_DESCRIPTION_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr), pnum)
+#define sk_ACCESS_DESCRIPTION_sort(sk) OPENSSL_sk_sort(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk))
+#define sk_ACCESS_DESCRIPTION_dup(sk) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_dup(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_deep_copy(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_copyfunc_type(copyfunc), ossl_check_ACCESS_DESCRIPTION_freefunc_type(freefunc)))
+#define sk_ACCESS_DESCRIPTION_set_cmp_func(sk, cmp) ((sk_ACCESS_DESCRIPTION_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_NAME, GENERAL_NAME, GENERAL_NAME)
+#define sk_GENERAL_NAME_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_value(sk, idx) ((GENERAL_NAME *)OPENSSL_sk_value(ossl_check_const_GENERAL_NAME_sk_type(sk), (idx)))
+#define sk_GENERAL_NAME_new(cmp) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new(ossl_check_GENERAL_NAME_compfunc_type(cmp)))
+#define sk_GENERAL_NAME_new_null() ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new_null())
+#define sk_GENERAL_NAME_new_reserve(cmp, n) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_NAME_compfunc_type(cmp), (n)))
+#define sk_GENERAL_NAME_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_NAME_sk_type(sk), (n))
+#define sk_GENERAL_NAME_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_delete(sk, i) ((GENERAL_NAME *)OPENSSL_sk_delete(ossl_check_GENERAL_NAME_sk_type(sk), (i)))
+#define sk_GENERAL_NAME_delete_ptr(sk, ptr) ((GENERAL_NAME *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr)))
+#define sk_GENERAL_NAME_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
+#define sk_GENERAL_NAME_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
+#define sk_GENERAL_NAME_pop(sk) ((GENERAL_NAME *)OPENSSL_sk_pop(ossl_check_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_shift(sk) ((GENERAL_NAME *)OPENSSL_sk_shift(ossl_check_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_NAME_sk_type(sk),ossl_check_GENERAL_NAME_freefunc_type(freefunc))
+#define sk_GENERAL_NAME_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr), (idx))
+#define sk_GENERAL_NAME_set(sk, idx, ptr) ((GENERAL_NAME *)OPENSSL_sk_set(ossl_check_GENERAL_NAME_sk_type(sk), (idx), ossl_check_GENERAL_NAME_type(ptr)))
+#define sk_GENERAL_NAME_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
+#define sk_GENERAL_NAME_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
+#define sk_GENERAL_NAME_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr), pnum)
+#define sk_GENERAL_NAME_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_NAME_sk_type(sk))
+#define sk_GENERAL_NAME_dup(sk) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_copyfunc_type(copyfunc), ossl_check_GENERAL_NAME_freefunc_type(freefunc)))
+#define sk_GENERAL_NAME_set_cmp_func(sk, cmp) ((sk_GENERAL_NAME_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_compfunc_type(cmp)))
+
+
+typedef STACK_OF(ACCESS_DESCRIPTION) AUTHORITY_INFO_ACCESS;
+typedef STACK_OF(ASN1_OBJECT) EXTENDED_KEY_USAGE;
+typedef STACK_OF(ASN1_INTEGER) TLS_FEATURE;
+typedef STACK_OF(GENERAL_NAME) GENERAL_NAMES;
+
+SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_NAMES, GENERAL_NAMES, GENERAL_NAMES)
+#define sk_GENERAL_NAMES_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_value(sk, idx) ((GENERAL_NAMES *)OPENSSL_sk_value(ossl_check_const_GENERAL_NAMES_sk_type(sk), (idx)))
+#define sk_GENERAL_NAMES_new(cmp) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new(ossl_check_GENERAL_NAMES_compfunc_type(cmp)))
+#define sk_GENERAL_NAMES_new_null() ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new_null())
+#define sk_GENERAL_NAMES_new_reserve(cmp, n) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_NAMES_compfunc_type(cmp), (n)))
+#define sk_GENERAL_NAMES_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_NAMES_sk_type(sk), (n))
+#define sk_GENERAL_NAMES_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_delete(sk, i) ((GENERAL_NAMES *)OPENSSL_sk_delete(ossl_check_GENERAL_NAMES_sk_type(sk), (i)))
+#define sk_GENERAL_NAMES_delete_ptr(sk, ptr) ((GENERAL_NAMES *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr)))
+#define sk_GENERAL_NAMES_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
+#define sk_GENERAL_NAMES_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
+#define sk_GENERAL_NAMES_pop(sk) ((GENERAL_NAMES *)OPENSSL_sk_pop(ossl_check_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_shift(sk) ((GENERAL_NAMES *)OPENSSL_sk_shift(ossl_check_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_NAMES_sk_type(sk),ossl_check_GENERAL_NAMES_freefunc_type(freefunc))
+#define sk_GENERAL_NAMES_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr), (idx))
+#define sk_GENERAL_NAMES_set(sk, idx, ptr) ((GENERAL_NAMES *)OPENSSL_sk_set(ossl_check_GENERAL_NAMES_sk_type(sk), (idx), ossl_check_GENERAL_NAMES_type(ptr)))
+#define sk_GENERAL_NAMES_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
+#define sk_GENERAL_NAMES_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
+#define sk_GENERAL_NAMES_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr), pnum)
+#define sk_GENERAL_NAMES_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_NAMES_sk_type(sk))
+#define sk_GENERAL_NAMES_dup(sk) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_copyfunc_type(copyfunc), ossl_check_GENERAL_NAMES_freefunc_type(freefunc)))
+#define sk_GENERAL_NAMES_set_cmp_func(sk, cmp) ((sk_GENERAL_NAMES_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_compfunc_type(cmp)))
+
+
+typedef struct DIST_POINT_NAME_st {
+    int type;
+    union {
+        GENERAL_NAMES *fullname;
+        STACK_OF(X509_NAME_ENTRY) *relativename;
+    } name;
+/* If relativename then this contains the full distribution point name */
+    X509_NAME *dpname;
+} DIST_POINT_NAME;
+/* All existing reasons */
+# define CRLDP_ALL_REASONS       0x807f
+
+# define CRL_REASON_NONE                         -1
+# define CRL_REASON_UNSPECIFIED                  0
+# define CRL_REASON_KEY_COMPROMISE               1
+# define CRL_REASON_CA_COMPROMISE                2
+# define CRL_REASON_AFFILIATION_CHANGED          3
+# define CRL_REASON_SUPERSEDED                   4
+# define CRL_REASON_CESSATION_OF_OPERATION       5
+# define CRL_REASON_CERTIFICATE_HOLD             6
+# define CRL_REASON_REMOVE_FROM_CRL              8
+# define CRL_REASON_PRIVILEGE_WITHDRAWN          9
+# define CRL_REASON_AA_COMPROMISE                10
+
+struct DIST_POINT_st {
+    DIST_POINT_NAME *distpoint;
+    ASN1_BIT_STRING *reasons;
+    GENERAL_NAMES *CRLissuer;
+    int dp_reasons;
+};
+
+SKM_DEFINE_STACK_OF_INTERNAL(DIST_POINT, DIST_POINT, DIST_POINT)
+#define sk_DIST_POINT_num(sk) OPENSSL_sk_num(ossl_check_const_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_value(sk, idx) ((DIST_POINT *)OPENSSL_sk_value(ossl_check_const_DIST_POINT_sk_type(sk), (idx)))
+#define sk_DIST_POINT_new(cmp) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new(ossl_check_DIST_POINT_compfunc_type(cmp)))
+#define sk_DIST_POINT_new_null() ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new_null())
+#define sk_DIST_POINT_new_reserve(cmp, n) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new_reserve(ossl_check_DIST_POINT_compfunc_type(cmp), (n)))
+#define sk_DIST_POINT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_DIST_POINT_sk_type(sk), (n))
+#define sk_DIST_POINT_free(sk) OPENSSL_sk_free(ossl_check_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_zero(sk) OPENSSL_sk_zero(ossl_check_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_delete(sk, i) ((DIST_POINT *)OPENSSL_sk_delete(ossl_check_DIST_POINT_sk_type(sk), (i)))
+#define sk_DIST_POINT_delete_ptr(sk, ptr) ((DIST_POINT *)OPENSSL_sk_delete_ptr(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr)))
+#define sk_DIST_POINT_push(sk, ptr) OPENSSL_sk_push(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
+#define sk_DIST_POINT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
+#define sk_DIST_POINT_pop(sk) ((DIST_POINT *)OPENSSL_sk_pop(ossl_check_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_shift(sk) ((DIST_POINT *)OPENSSL_sk_shift(ossl_check_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_DIST_POINT_sk_type(sk),ossl_check_DIST_POINT_freefunc_type(freefunc))
+#define sk_DIST_POINT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr), (idx))
+#define sk_DIST_POINT_set(sk, idx, ptr) ((DIST_POINT *)OPENSSL_sk_set(ossl_check_DIST_POINT_sk_type(sk), (idx), ossl_check_DIST_POINT_type(ptr)))
+#define sk_DIST_POINT_find(sk, ptr) OPENSSL_sk_find(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
+#define sk_DIST_POINT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
+#define sk_DIST_POINT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr), pnum)
+#define sk_DIST_POINT_sort(sk) OPENSSL_sk_sort(ossl_check_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_DIST_POINT_sk_type(sk))
+#define sk_DIST_POINT_dup(sk) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_dup(ossl_check_const_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_deep_copy(ossl_check_const_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_copyfunc_type(copyfunc), ossl_check_DIST_POINT_freefunc_type(freefunc)))
+#define sk_DIST_POINT_set_cmp_func(sk, cmp) ((sk_DIST_POINT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_compfunc_type(cmp)))
+
+
+typedef STACK_OF(DIST_POINT) CRL_DIST_POINTS;
+
+struct AUTHORITY_KEYID_st {
+    ASN1_OCTET_STRING *keyid;
+    GENERAL_NAMES *issuer;
+    ASN1_INTEGER *serial;
+};
+
+/* Strong extranet structures */
+
+typedef struct SXNET_ID_st {
+    ASN1_INTEGER *zone;
+    ASN1_OCTET_STRING *user;
+} SXNETID;
+
+SKM_DEFINE_STACK_OF_INTERNAL(SXNETID, SXNETID, SXNETID)
+#define sk_SXNETID_num(sk) OPENSSL_sk_num(ossl_check_const_SXNETID_sk_type(sk))
+#define sk_SXNETID_value(sk, idx) ((SXNETID *)OPENSSL_sk_value(ossl_check_const_SXNETID_sk_type(sk), (idx)))
+#define sk_SXNETID_new(cmp) ((STACK_OF(SXNETID) *)OPENSSL_sk_new(ossl_check_SXNETID_compfunc_type(cmp)))
+#define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)OPENSSL_sk_new_null())
+#define sk_SXNETID_new_reserve(cmp, n) ((STACK_OF(SXNETID) *)OPENSSL_sk_new_reserve(ossl_check_SXNETID_compfunc_type(cmp), (n)))
+#define sk_SXNETID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SXNETID_sk_type(sk), (n))
+#define sk_SXNETID_free(sk) OPENSSL_sk_free(ossl_check_SXNETID_sk_type(sk))
+#define sk_SXNETID_zero(sk) OPENSSL_sk_zero(ossl_check_SXNETID_sk_type(sk))
+#define sk_SXNETID_delete(sk, i) ((SXNETID *)OPENSSL_sk_delete(ossl_check_SXNETID_sk_type(sk), (i)))
+#define sk_SXNETID_delete_ptr(sk, ptr) ((SXNETID *)OPENSSL_sk_delete_ptr(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr)))
+#define sk_SXNETID_push(sk, ptr) OPENSSL_sk_push(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
+#define sk_SXNETID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
+#define sk_SXNETID_pop(sk) ((SXNETID *)OPENSSL_sk_pop(ossl_check_SXNETID_sk_type(sk)))
+#define sk_SXNETID_shift(sk) ((SXNETID *)OPENSSL_sk_shift(ossl_check_SXNETID_sk_type(sk)))
+#define sk_SXNETID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SXNETID_sk_type(sk),ossl_check_SXNETID_freefunc_type(freefunc))
+#define sk_SXNETID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr), (idx))
+#define sk_SXNETID_set(sk, idx, ptr) ((SXNETID *)OPENSSL_sk_set(ossl_check_SXNETID_sk_type(sk), (idx), ossl_check_SXNETID_type(ptr)))
+#define sk_SXNETID_find(sk, ptr) OPENSSL_sk_find(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
+#define sk_SXNETID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
+#define sk_SXNETID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr), pnum)
+#define sk_SXNETID_sort(sk) OPENSSL_sk_sort(ossl_check_SXNETID_sk_type(sk))
+#define sk_SXNETID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SXNETID_sk_type(sk))
+#define sk_SXNETID_dup(sk) ((STACK_OF(SXNETID) *)OPENSSL_sk_dup(ossl_check_const_SXNETID_sk_type(sk)))
+#define sk_SXNETID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SXNETID) *)OPENSSL_sk_deep_copy(ossl_check_const_SXNETID_sk_type(sk), ossl_check_SXNETID_copyfunc_type(copyfunc), ossl_check_SXNETID_freefunc_type(freefunc)))
+#define sk_SXNETID_set_cmp_func(sk, cmp) ((sk_SXNETID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_compfunc_type(cmp)))
+
+
+
+typedef struct SXNET_st {
+    ASN1_INTEGER *version;
+    STACK_OF(SXNETID) *ids;
+} SXNET;
+
+typedef struct ISSUER_SIGN_TOOL_st {
+    ASN1_UTF8STRING *signTool;
+    ASN1_UTF8STRING *cATool;
+    ASN1_UTF8STRING *signToolCert;
+    ASN1_UTF8STRING *cAToolCert;
+} ISSUER_SIGN_TOOL;
+
+typedef struct NOTICEREF_st {
+    ASN1_STRING *organization;
+    STACK_OF(ASN1_INTEGER) *noticenos;
+} NOTICEREF;
+
+typedef struct USERNOTICE_st {
+    NOTICEREF *noticeref;
+    ASN1_STRING *exptext;
+} USERNOTICE;
+
+typedef struct POLICYQUALINFO_st {
+    ASN1_OBJECT *pqualid;
+    union {
+        ASN1_IA5STRING *cpsuri;
+        USERNOTICE *usernotice;
+        ASN1_TYPE *other;
+    } d;
+} POLICYQUALINFO;
+
+SKM_DEFINE_STACK_OF_INTERNAL(POLICYQUALINFO, POLICYQUALINFO, POLICYQUALINFO)
+#define sk_POLICYQUALINFO_num(sk) OPENSSL_sk_num(ossl_check_const_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_value(sk, idx) ((POLICYQUALINFO *)OPENSSL_sk_value(ossl_check_const_POLICYQUALINFO_sk_type(sk), (idx)))
+#define sk_POLICYQUALINFO_new(cmp) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new(ossl_check_POLICYQUALINFO_compfunc_type(cmp)))
+#define sk_POLICYQUALINFO_new_null() ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new_null())
+#define sk_POLICYQUALINFO_new_reserve(cmp, n) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new_reserve(ossl_check_POLICYQUALINFO_compfunc_type(cmp), (n)))
+#define sk_POLICYQUALINFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICYQUALINFO_sk_type(sk), (n))
+#define sk_POLICYQUALINFO_free(sk) OPENSSL_sk_free(ossl_check_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_zero(sk) OPENSSL_sk_zero(ossl_check_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_delete(sk, i) ((POLICYQUALINFO *)OPENSSL_sk_delete(ossl_check_POLICYQUALINFO_sk_type(sk), (i)))
+#define sk_POLICYQUALINFO_delete_ptr(sk, ptr) ((POLICYQUALINFO *)OPENSSL_sk_delete_ptr(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr)))
+#define sk_POLICYQUALINFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
+#define sk_POLICYQUALINFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
+#define sk_POLICYQUALINFO_pop(sk) ((POLICYQUALINFO *)OPENSSL_sk_pop(ossl_check_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_shift(sk) ((POLICYQUALINFO *)OPENSSL_sk_shift(ossl_check_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICYQUALINFO_sk_type(sk),ossl_check_POLICYQUALINFO_freefunc_type(freefunc))
+#define sk_POLICYQUALINFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr), (idx))
+#define sk_POLICYQUALINFO_set(sk, idx, ptr) ((POLICYQUALINFO *)OPENSSL_sk_set(ossl_check_POLICYQUALINFO_sk_type(sk), (idx), ossl_check_POLICYQUALINFO_type(ptr)))
+#define sk_POLICYQUALINFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
+#define sk_POLICYQUALINFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
+#define sk_POLICYQUALINFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr), pnum)
+#define sk_POLICYQUALINFO_sort(sk) OPENSSL_sk_sort(ossl_check_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICYQUALINFO_sk_type(sk))
+#define sk_POLICYQUALINFO_dup(sk) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_dup(ossl_check_const_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_copyfunc_type(copyfunc), ossl_check_POLICYQUALINFO_freefunc_type(freefunc)))
+#define sk_POLICYQUALINFO_set_cmp_func(sk, cmp) ((sk_POLICYQUALINFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_compfunc_type(cmp)))
+
+
+
+typedef struct POLICYINFO_st {
+    ASN1_OBJECT *policyid;
+    STACK_OF(POLICYQUALINFO) *qualifiers;
+} POLICYINFO;
+
+SKM_DEFINE_STACK_OF_INTERNAL(POLICYINFO, POLICYINFO, POLICYINFO)
+#define sk_POLICYINFO_num(sk) OPENSSL_sk_num(ossl_check_const_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_value(sk, idx) ((POLICYINFO *)OPENSSL_sk_value(ossl_check_const_POLICYINFO_sk_type(sk), (idx)))
+#define sk_POLICYINFO_new(cmp) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new(ossl_check_POLICYINFO_compfunc_type(cmp)))
+#define sk_POLICYINFO_new_null() ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new_null())
+#define sk_POLICYINFO_new_reserve(cmp, n) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new_reserve(ossl_check_POLICYINFO_compfunc_type(cmp), (n)))
+#define sk_POLICYINFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICYINFO_sk_type(sk), (n))
+#define sk_POLICYINFO_free(sk) OPENSSL_sk_free(ossl_check_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_zero(sk) OPENSSL_sk_zero(ossl_check_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_delete(sk, i) ((POLICYINFO *)OPENSSL_sk_delete(ossl_check_POLICYINFO_sk_type(sk), (i)))
+#define sk_POLICYINFO_delete_ptr(sk, ptr) ((POLICYINFO *)OPENSSL_sk_delete_ptr(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr)))
+#define sk_POLICYINFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
+#define sk_POLICYINFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
+#define sk_POLICYINFO_pop(sk) ((POLICYINFO *)OPENSSL_sk_pop(ossl_check_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_shift(sk) ((POLICYINFO *)OPENSSL_sk_shift(ossl_check_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICYINFO_sk_type(sk),ossl_check_POLICYINFO_freefunc_type(freefunc))
+#define sk_POLICYINFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr), (idx))
+#define sk_POLICYINFO_set(sk, idx, ptr) ((POLICYINFO *)OPENSSL_sk_set(ossl_check_POLICYINFO_sk_type(sk), (idx), ossl_check_POLICYINFO_type(ptr)))
+#define sk_POLICYINFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
+#define sk_POLICYINFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
+#define sk_POLICYINFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr), pnum)
+#define sk_POLICYINFO_sort(sk) OPENSSL_sk_sort(ossl_check_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICYINFO_sk_type(sk))
+#define sk_POLICYINFO_dup(sk) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_dup(ossl_check_const_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_copyfunc_type(copyfunc), ossl_check_POLICYINFO_freefunc_type(freefunc)))
+#define sk_POLICYINFO_set_cmp_func(sk, cmp) ((sk_POLICYINFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_compfunc_type(cmp)))
+
+
+typedef STACK_OF(POLICYINFO) CERTIFICATEPOLICIES;
+
+typedef struct POLICY_MAPPING_st {
+    ASN1_OBJECT *issuerDomainPolicy;
+    ASN1_OBJECT *subjectDomainPolicy;
+} POLICY_MAPPING;
+
+SKM_DEFINE_STACK_OF_INTERNAL(POLICY_MAPPING, POLICY_MAPPING, POLICY_MAPPING)
+#define sk_POLICY_MAPPING_num(sk) OPENSSL_sk_num(ossl_check_const_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_value(sk, idx) ((POLICY_MAPPING *)OPENSSL_sk_value(ossl_check_const_POLICY_MAPPING_sk_type(sk), (idx)))
+#define sk_POLICY_MAPPING_new(cmp) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new(ossl_check_POLICY_MAPPING_compfunc_type(cmp)))
+#define sk_POLICY_MAPPING_new_null() ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new_null())
+#define sk_POLICY_MAPPING_new_reserve(cmp, n) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new_reserve(ossl_check_POLICY_MAPPING_compfunc_type(cmp), (n)))
+#define sk_POLICY_MAPPING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICY_MAPPING_sk_type(sk), (n))
+#define sk_POLICY_MAPPING_free(sk) OPENSSL_sk_free(ossl_check_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_zero(sk) OPENSSL_sk_zero(ossl_check_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_delete(sk, i) ((POLICY_MAPPING *)OPENSSL_sk_delete(ossl_check_POLICY_MAPPING_sk_type(sk), (i)))
+#define sk_POLICY_MAPPING_delete_ptr(sk, ptr) ((POLICY_MAPPING *)OPENSSL_sk_delete_ptr(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr)))
+#define sk_POLICY_MAPPING_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
+#define sk_POLICY_MAPPING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
+#define sk_POLICY_MAPPING_pop(sk) ((POLICY_MAPPING *)OPENSSL_sk_pop(ossl_check_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_shift(sk) ((POLICY_MAPPING *)OPENSSL_sk_shift(ossl_check_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICY_MAPPING_sk_type(sk),ossl_check_POLICY_MAPPING_freefunc_type(freefunc))
+#define sk_POLICY_MAPPING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr), (idx))
+#define sk_POLICY_MAPPING_set(sk, idx, ptr) ((POLICY_MAPPING *)OPENSSL_sk_set(ossl_check_POLICY_MAPPING_sk_type(sk), (idx), ossl_check_POLICY_MAPPING_type(ptr)))
+#define sk_POLICY_MAPPING_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
+#define sk_POLICY_MAPPING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
+#define sk_POLICY_MAPPING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr), pnum)
+#define sk_POLICY_MAPPING_sort(sk) OPENSSL_sk_sort(ossl_check_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICY_MAPPING_sk_type(sk))
+#define sk_POLICY_MAPPING_dup(sk) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_dup(ossl_check_const_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_copyfunc_type(copyfunc), ossl_check_POLICY_MAPPING_freefunc_type(freefunc)))
+#define sk_POLICY_MAPPING_set_cmp_func(sk, cmp) ((sk_POLICY_MAPPING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_compfunc_type(cmp)))
+
+
+typedef STACK_OF(POLICY_MAPPING) POLICY_MAPPINGS;
+
+typedef struct GENERAL_SUBTREE_st {
+    GENERAL_NAME *base;
+    ASN1_INTEGER *minimum;
+    ASN1_INTEGER *maximum;
+} GENERAL_SUBTREE;
+
+SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_SUBTREE, GENERAL_SUBTREE, GENERAL_SUBTREE)
+#define sk_GENERAL_SUBTREE_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_value(sk, idx) ((GENERAL_SUBTREE *)OPENSSL_sk_value(ossl_check_const_GENERAL_SUBTREE_sk_type(sk), (idx)))
+#define sk_GENERAL_SUBTREE_new(cmp) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new(ossl_check_GENERAL_SUBTREE_compfunc_type(cmp)))
+#define sk_GENERAL_SUBTREE_new_null() ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new_null())
+#define sk_GENERAL_SUBTREE_new_reserve(cmp, n) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_SUBTREE_compfunc_type(cmp), (n)))
+#define sk_GENERAL_SUBTREE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_SUBTREE_sk_type(sk), (n))
+#define sk_GENERAL_SUBTREE_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_delete(sk, i) ((GENERAL_SUBTREE *)OPENSSL_sk_delete(ossl_check_GENERAL_SUBTREE_sk_type(sk), (i)))
+#define sk_GENERAL_SUBTREE_delete_ptr(sk, ptr) ((GENERAL_SUBTREE *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr)))
+#define sk_GENERAL_SUBTREE_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
+#define sk_GENERAL_SUBTREE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
+#define sk_GENERAL_SUBTREE_pop(sk) ((GENERAL_SUBTREE *)OPENSSL_sk_pop(ossl_check_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_shift(sk) ((GENERAL_SUBTREE *)OPENSSL_sk_shift(ossl_check_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_SUBTREE_sk_type(sk),ossl_check_GENERAL_SUBTREE_freefunc_type(freefunc))
+#define sk_GENERAL_SUBTREE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr), (idx))
+#define sk_GENERAL_SUBTREE_set(sk, idx, ptr) ((GENERAL_SUBTREE *)OPENSSL_sk_set(ossl_check_GENERAL_SUBTREE_sk_type(sk), (idx), ossl_check_GENERAL_SUBTREE_type(ptr)))
+#define sk_GENERAL_SUBTREE_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
+#define sk_GENERAL_SUBTREE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
+#define sk_GENERAL_SUBTREE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr), pnum)
+#define sk_GENERAL_SUBTREE_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_SUBTREE_sk_type(sk))
+#define sk_GENERAL_SUBTREE_dup(sk) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_copyfunc_type(copyfunc), ossl_check_GENERAL_SUBTREE_freefunc_type(freefunc)))
+#define sk_GENERAL_SUBTREE_set_cmp_func(sk, cmp) ((sk_GENERAL_SUBTREE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_compfunc_type(cmp)))
+
+
+struct NAME_CONSTRAINTS_st {
+    STACK_OF(GENERAL_SUBTREE) *permittedSubtrees;
+    STACK_OF(GENERAL_SUBTREE) *excludedSubtrees;
+};
+
+typedef struct POLICY_CONSTRAINTS_st {
+    ASN1_INTEGER *requireExplicitPolicy;
+    ASN1_INTEGER *inhibitPolicyMapping;
+} POLICY_CONSTRAINTS;
+
+/* Proxy certificate structures, see RFC 3820 */
+typedef struct PROXY_POLICY_st {
+    ASN1_OBJECT *policyLanguage;
+    ASN1_OCTET_STRING *policy;
+} PROXY_POLICY;
+
+typedef struct PROXY_CERT_INFO_EXTENSION_st {
+    ASN1_INTEGER *pcPathLengthConstraint;
+    PROXY_POLICY *proxyPolicy;
+} PROXY_CERT_INFO_EXTENSION;
+
+DECLARE_ASN1_FUNCTIONS(PROXY_POLICY)
+DECLARE_ASN1_FUNCTIONS(PROXY_CERT_INFO_EXTENSION)
+
+struct ISSUING_DIST_POINT_st {
+    DIST_POINT_NAME *distpoint;
+    int onlyuser;
+    int onlyCA;
+    ASN1_BIT_STRING *onlysomereasons;
+    int indirectCRL;
+    int onlyattr;
+};
+
+/* Values in idp_flags field */
+/* IDP present */
+# define IDP_PRESENT     0x1
+/* IDP values inconsistent */
+# define IDP_INVALID     0x2
+/* onlyuser true */
+# define IDP_ONLYUSER    0x4
+/* onlyCA true */
+# define IDP_ONLYCA      0x8
+/* onlyattr true */
+# define IDP_ONLYATTR    0x10
+/* indirectCRL true */
+# define IDP_INDIRECT    0x20
+/* onlysomereasons present */
+# define IDP_REASONS     0x40
+
+# define X509V3_conf_err(val) ERR_add_error_data(6, \
+                        "section:", (val)->section, \
+                        ",name:", (val)->name, ",value:", (val)->value)
+
+# define X509V3_set_ctx_test(ctx) \
+    X509V3_set_ctx(ctx, NULL, NULL, NULL, NULL, X509V3_CTX_TEST)
+# define X509V3_set_ctx_nodb(ctx) (ctx)->db = NULL;
+
+# define EXT_BITSTRING(nid, table) { nid, 0, ASN1_ITEM_ref(ASN1_BIT_STRING), \
+                        0,0,0,0, \
+                        0,0, \
+                        (X509V3_EXT_I2V)i2v_ASN1_BIT_STRING, \
+                        (X509V3_EXT_V2I)v2i_ASN1_BIT_STRING, \
+                        NULL, NULL, \
+                        table}
+
+# define EXT_IA5STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_IA5STRING), \
+                        0,0,0,0, \
+                        (X509V3_EXT_I2S)i2s_ASN1_IA5STRING, \
+                        (X509V3_EXT_S2I)s2i_ASN1_IA5STRING, \
+                        0,0,0,0, \
+                        NULL}
+
+#define EXT_UTF8STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_UTF8STRING), \
+                        0,0,0,0, \
+                        (X509V3_EXT_I2S)i2s_ASN1_UTF8STRING, \
+                        (X509V3_EXT_S2I)s2i_ASN1_UTF8STRING, \
+                        0,0,0,0, \
+                        NULL}
+
+# define EXT_END { -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+/* X509_PURPOSE stuff */
+
+# define EXFLAG_BCONS            0x1
+# define EXFLAG_KUSAGE           0x2
+# define EXFLAG_XKUSAGE          0x4
+# define EXFLAG_NSCERT           0x8
+
+# define EXFLAG_CA               0x10
+# define EXFLAG_SI               0x20 /* self-issued, maybe not self-signed */
+# define EXFLAG_V1               0x40
+# define EXFLAG_INVALID          0x80
+/* EXFLAG_SET is set to indicate that some values have been precomputed */
+# define EXFLAG_SET              0x100
+# define EXFLAG_CRITICAL         0x200
+# define EXFLAG_PROXY            0x400
+
+# define EXFLAG_INVALID_POLICY   0x800
+# define EXFLAG_FRESHEST         0x1000
+# define EXFLAG_SS               0x2000 /* cert is apparently self-signed */
+
+# define EXFLAG_BCONS_CRITICAL   0x10000
+# define EXFLAG_AKID_CRITICAL    0x20000
+# define EXFLAG_SKID_CRITICAL    0x40000
+# define EXFLAG_SAN_CRITICAL     0x80000
+# define EXFLAG_NO_FINGERPRINT   0x100000
+
+# define KU_DIGITAL_SIGNATURE    0x0080
+# define KU_NON_REPUDIATION      0x0040
+# define KU_KEY_ENCIPHERMENT     0x0020
+# define KU_DATA_ENCIPHERMENT    0x0010
+# define KU_KEY_AGREEMENT        0x0008
+# define KU_KEY_CERT_SIGN        0x0004
+# define KU_CRL_SIGN             0x0002
+# define KU_ENCIPHER_ONLY        0x0001
+# define KU_DECIPHER_ONLY        0x8000
+
+# define NS_SSL_CLIENT           0x80
+# define NS_SSL_SERVER           0x40
+# define NS_SMIME                0x20
+# define NS_OBJSIGN              0x10
+# define NS_SSL_CA               0x04
+# define NS_SMIME_CA             0x02
+# define NS_OBJSIGN_CA           0x01
+# define NS_ANY_CA               (NS_SSL_CA|NS_SMIME_CA|NS_OBJSIGN_CA)
+
+# define XKU_SSL_SERVER          0x1
+# define XKU_SSL_CLIENT          0x2
+# define XKU_SMIME               0x4
+# define XKU_CODE_SIGN           0x8
+# define XKU_SGC                 0x10 /* Netscape or MS Server-Gated Crypto */
+# define XKU_OCSP_SIGN           0x20
+# define XKU_TIMESTAMP           0x40
+# define XKU_DVCS                0x80
+# define XKU_ANYEKU              0x100
+
+# define X509_PURPOSE_DYNAMIC    0x1
+# define X509_PURPOSE_DYNAMIC_NAME       0x2
+
+typedef struct x509_purpose_st {
+    int purpose;
+    int trust;                  /* Default trust ID */
+    int flags;
+    int (*check_purpose) (const struct x509_purpose_st *, const X509 *, int);
+    char *name;
+    char *sname;
+    void *usr_data;
+} X509_PURPOSE;
+
+SKM_DEFINE_STACK_OF_INTERNAL(X509_PURPOSE, X509_PURPOSE, X509_PURPOSE)
+#define sk_X509_PURPOSE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_value(sk, idx) ((X509_PURPOSE *)OPENSSL_sk_value(ossl_check_const_X509_PURPOSE_sk_type(sk), (idx)))
+#define sk_X509_PURPOSE_new(cmp) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new(ossl_check_X509_PURPOSE_compfunc_type(cmp)))
+#define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new_null())
+#define sk_X509_PURPOSE_new_reserve(cmp, n) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new_reserve(ossl_check_X509_PURPOSE_compfunc_type(cmp), (n)))
+#define sk_X509_PURPOSE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_PURPOSE_sk_type(sk), (n))
+#define sk_X509_PURPOSE_free(sk) OPENSSL_sk_free(ossl_check_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_delete(sk, i) ((X509_PURPOSE *)OPENSSL_sk_delete(ossl_check_X509_PURPOSE_sk_type(sk), (i)))
+#define sk_X509_PURPOSE_delete_ptr(sk, ptr) ((X509_PURPOSE *)OPENSSL_sk_delete_ptr(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr)))
+#define sk_X509_PURPOSE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
+#define sk_X509_PURPOSE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
+#define sk_X509_PURPOSE_pop(sk) ((X509_PURPOSE *)OPENSSL_sk_pop(ossl_check_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_shift(sk) ((X509_PURPOSE *)OPENSSL_sk_shift(ossl_check_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_PURPOSE_sk_type(sk),ossl_check_X509_PURPOSE_freefunc_type(freefunc))
+#define sk_X509_PURPOSE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr), (idx))
+#define sk_X509_PURPOSE_set(sk, idx, ptr) ((X509_PURPOSE *)OPENSSL_sk_set(ossl_check_X509_PURPOSE_sk_type(sk), (idx), ossl_check_X509_PURPOSE_type(ptr)))
+#define sk_X509_PURPOSE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
+#define sk_X509_PURPOSE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
+#define sk_X509_PURPOSE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr), pnum)
+#define sk_X509_PURPOSE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_PURPOSE_sk_type(sk))
+#define sk_X509_PURPOSE_dup(sk) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_dup(ossl_check_const_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_copyfunc_type(copyfunc), ossl_check_X509_PURPOSE_freefunc_type(freefunc)))
+#define sk_X509_PURPOSE_set_cmp_func(sk, cmp) ((sk_X509_PURPOSE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_compfunc_type(cmp)))
+
+
+
+# define X509_PURPOSE_SSL_CLIENT         1
+# define X509_PURPOSE_SSL_SERVER         2
+# define X509_PURPOSE_NS_SSL_SERVER      3
+# define X509_PURPOSE_SMIME_SIGN         4
+# define X509_PURPOSE_SMIME_ENCRYPT      5
+# define X509_PURPOSE_CRL_SIGN           6
+# define X509_PURPOSE_ANY                7
+# define X509_PURPOSE_OCSP_HELPER        8
+# define X509_PURPOSE_TIMESTAMP_SIGN     9
+
+# define X509_PURPOSE_MIN                1
+# define X509_PURPOSE_MAX                9
+
+/* Flags for X509V3_EXT_print() */
+
+# define X509V3_EXT_UNKNOWN_MASK         (0xfL << 16)
+/* Return error for unknown extensions */
+# define X509V3_EXT_DEFAULT              0
+/* Print error for unknown extensions */
+# define X509V3_EXT_ERROR_UNKNOWN        (1L << 16)
+/* ASN1 parse unknown extensions */
+# define X509V3_EXT_PARSE_UNKNOWN        (2L << 16)
+/* BIO_dump unknown extensions */
+# define X509V3_EXT_DUMP_UNKNOWN         (3L << 16)
+
+/* Flags for X509V3_add1_i2d */
+
+# define X509V3_ADD_OP_MASK              0xfL
+# define X509V3_ADD_DEFAULT              0L
+# define X509V3_ADD_APPEND               1L
+# define X509V3_ADD_REPLACE              2L
+# define X509V3_ADD_REPLACE_EXISTING     3L
+# define X509V3_ADD_KEEP_EXISTING        4L
+# define X509V3_ADD_DELETE               5L
+# define X509V3_ADD_SILENT               0x10
+
+DECLARE_ASN1_FUNCTIONS(BASIC_CONSTRAINTS)
+
+DECLARE_ASN1_FUNCTIONS(SXNET)
+DECLARE_ASN1_FUNCTIONS(SXNETID)
+
+DECLARE_ASN1_FUNCTIONS(ISSUER_SIGN_TOOL)
+
+int SXNET_add_id_asc(SXNET **psx, const char *zone, const char *user, int userlen);
+int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, const char *user,
+                       int userlen);
+int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *izone, const char *user,
+                         int userlen);
+
+ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, const char *zone);
+ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone);
+ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone);
+
+DECLARE_ASN1_FUNCTIONS(AUTHORITY_KEYID)
+
+DECLARE_ASN1_FUNCTIONS(PKEY_USAGE_PERIOD)
+
+DECLARE_ASN1_FUNCTIONS(GENERAL_NAME)
+DECLARE_ASN1_DUP_FUNCTION(GENERAL_NAME)
+int GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b);
+
+ASN1_BIT_STRING *v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
+                                     X509V3_CTX *ctx,
+                                     STACK_OF(CONF_VALUE) *nval);
+STACK_OF(CONF_VALUE) *i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
+                                          ASN1_BIT_STRING *bits,
+                                          STACK_OF(CONF_VALUE) *extlist);
+char *i2s_ASN1_IA5STRING(X509V3_EXT_METHOD *method, ASN1_IA5STRING *ia5);
+ASN1_IA5STRING *s2i_ASN1_IA5STRING(X509V3_EXT_METHOD *method,
+                                   X509V3_CTX *ctx, const char *str);
+char *i2s_ASN1_UTF8STRING(X509V3_EXT_METHOD *method, ASN1_UTF8STRING *utf8);
+ASN1_UTF8STRING *s2i_ASN1_UTF8STRING(X509V3_EXT_METHOD *method,
+                                   X509V3_CTX *ctx, const char *str);
+
+STACK_OF(CONF_VALUE) *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method,
+                                       GENERAL_NAME *gen,
+                                       STACK_OF(CONF_VALUE) *ret);
+int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen);
+
+DECLARE_ASN1_FUNCTIONS(GENERAL_NAMES)
+
+STACK_OF(CONF_VALUE) *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method,
+                                        GENERAL_NAMES *gen,
+                                        STACK_OF(CONF_VALUE) *extlist);
+GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method,
+                                 X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval);
+
+DECLARE_ASN1_FUNCTIONS(OTHERNAME)
+DECLARE_ASN1_FUNCTIONS(EDIPARTYNAME)
+int OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b);
+void GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value);
+void *GENERAL_NAME_get0_value(const GENERAL_NAME *a, int *ptype);
+int GENERAL_NAME_set0_othername(GENERAL_NAME *gen,
+                                ASN1_OBJECT *oid, ASN1_TYPE *value);
+int GENERAL_NAME_get0_otherName(const GENERAL_NAME *gen,
+                                ASN1_OBJECT **poid, ASN1_TYPE **pvalue);
+
+char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
+                            const ASN1_OCTET_STRING *ia5);
+ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
+                                         X509V3_CTX *ctx, const char *str);
+
+DECLARE_ASN1_FUNCTIONS(EXTENDED_KEY_USAGE)
+int i2a_ACCESS_DESCRIPTION(BIO *bp, const ACCESS_DESCRIPTION *a);
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(TLS_FEATURE)
+
+DECLARE_ASN1_FUNCTIONS(CERTIFICATEPOLICIES)
+DECLARE_ASN1_FUNCTIONS(POLICYINFO)
+DECLARE_ASN1_FUNCTIONS(POLICYQUALINFO)
+DECLARE_ASN1_FUNCTIONS(USERNOTICE)
+DECLARE_ASN1_FUNCTIONS(NOTICEREF)
+
+DECLARE_ASN1_FUNCTIONS(CRL_DIST_POINTS)
+DECLARE_ASN1_FUNCTIONS(DIST_POINT)
+DECLARE_ASN1_FUNCTIONS(DIST_POINT_NAME)
+DECLARE_ASN1_FUNCTIONS(ISSUING_DIST_POINT)
+
+int DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, const X509_NAME *iname);
+
+int NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc);
+int NAME_CONSTRAINTS_check_CN(X509 *x, NAME_CONSTRAINTS *nc);
+
+DECLARE_ASN1_FUNCTIONS(ACCESS_DESCRIPTION)
+DECLARE_ASN1_FUNCTIONS(AUTHORITY_INFO_ACCESS)
+
+DECLARE_ASN1_ITEM(POLICY_MAPPING)
+DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_MAPPING)
+DECLARE_ASN1_ITEM(POLICY_MAPPINGS)
+
+DECLARE_ASN1_ITEM(GENERAL_SUBTREE)
+DECLARE_ASN1_ALLOC_FUNCTIONS(GENERAL_SUBTREE)
+
+DECLARE_ASN1_ITEM(NAME_CONSTRAINTS)
+DECLARE_ASN1_ALLOC_FUNCTIONS(NAME_CONSTRAINTS)
+
+DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_CONSTRAINTS)
+DECLARE_ASN1_ITEM(POLICY_CONSTRAINTS)
+
+GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out,
+                               const X509V3_EXT_METHOD *method,
+                               X509V3_CTX *ctx, int gen_type,
+                               const char *value, int is_nc);
+
+# ifdef OPENSSL_CONF_H
+GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method,
+                               X509V3_CTX *ctx, CONF_VALUE *cnf);
+GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out,
+                                  const X509V3_EXT_METHOD *method,
+                                  X509V3_CTX *ctx, CONF_VALUE *cnf,
+                                  int is_nc);
+
+void X509V3_conf_free(CONF_VALUE *val);
+
+X509_EXTENSION *X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid,
+                                     const char *value);
+X509_EXTENSION *X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, const char *name,
+                                 const char *value);
+int X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, const char *section,
+                            STACK_OF(X509_EXTENSION) **sk);
+int X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
+                         X509 *cert);
+int X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
+                             X509_REQ *req);
+int X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
+                             X509_CRL *crl);
+
+X509_EXTENSION *X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf,
+                                    X509V3_CTX *ctx, int ext_nid,
+                                    const char *value);
+X509_EXTENSION *X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
+                                const char *name, const char *value);
+int X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
+                        const char *section, X509 *cert);
+int X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
+                            const char *section, X509_REQ *req);
+int X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
+                            const char *section, X509_CRL *crl);
+
+int X509V3_add_value_bool_nf(const char *name, int asn1_bool,
+                             STACK_OF(CONF_VALUE) **extlist);
+int X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool);
+int X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint);
+void X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf);
+void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash);
+# endif
+
+char *X509V3_get_string(X509V3_CTX *ctx, const char *name, const char *section);
+STACK_OF(CONF_VALUE) *X509V3_get_section(X509V3_CTX *ctx, const char *section);
+void X509V3_string_free(X509V3_CTX *ctx, char *str);
+void X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section);
+void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subject,
+                    X509_REQ *req, X509_CRL *crl, int flags);
+/* For API backward compatibility, this is separate from X509V3_set_ctx(): */
+int X509V3_set_issuer_pkey(X509V3_CTX *ctx, EVP_PKEY *pkey);
+
+int X509V3_add_value(const char *name, const char *value,
+                     STACK_OF(CONF_VALUE) **extlist);
+int X509V3_add_value_uchar(const char *name, const unsigned char *value,
+                           STACK_OF(CONF_VALUE) **extlist);
+int X509V3_add_value_bool(const char *name, int asn1_bool,
+                          STACK_OF(CONF_VALUE) **extlist);
+int X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
+                         STACK_OF(CONF_VALUE) **extlist);
+char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const ASN1_INTEGER *aint);
+ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const char *value);
+char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *meth, const ASN1_ENUMERATED *aint);
+char *i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *meth,
+                                const ASN1_ENUMERATED *aint);
+int X509V3_EXT_add(X509V3_EXT_METHOD *ext);
+int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist);
+int X509V3_EXT_add_alias(int nid_to, int nid_from);
+void X509V3_EXT_cleanup(void);
+
+const X509V3_EXT_METHOD *X509V3_EXT_get(X509_EXTENSION *ext);
+const X509V3_EXT_METHOD *X509V3_EXT_get_nid(int nid);
+int X509V3_add_standard_extensions(void);
+STACK_OF(CONF_VALUE) *X509V3_parse_list(const char *line);
+void *X509V3_EXT_d2i(X509_EXTENSION *ext);
+void *X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *x, int nid, int *crit,
+                     int *idx);
+
+X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc);
+int X509V3_add1_i2d(STACK_OF(X509_EXTENSION) **x, int nid, void *value,
+                    int crit, unsigned long flags);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+/* The new declarations are in crypto.h, but the old ones were here. */
+# define hex_to_string OPENSSL_buf2hexstr
+# define string_to_hex OPENSSL_hexstr2buf
+#endif
+
+void X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent,
+                        int ml);
+int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, unsigned long flag,
+                     int indent);
+#ifndef OPENSSL_NO_STDIO
+int X509V3_EXT_print_fp(FILE *out, X509_EXTENSION *ext, int flag, int indent);
+#endif
+int X509V3_extensions_print(BIO *out, const char *title,
+                            const STACK_OF(X509_EXTENSION) *exts,
+                            unsigned long flag, int indent);
+
+int X509_check_ca(X509 *x);
+int X509_check_purpose(X509 *x, int id, int ca);
+int X509_supported_extension(X509_EXTENSION *ex);
+int X509_PURPOSE_set(int *p, int purpose);
+int X509_check_issued(X509 *issuer, X509 *subject);
+int X509_check_akid(const X509 *issuer, const AUTHORITY_KEYID *akid);
+void X509_set_proxy_flag(X509 *x);
+void X509_set_proxy_pathlen(X509 *x, long l);
+long X509_get_proxy_pathlen(X509 *x);
+
+uint32_t X509_get_extension_flags(X509 *x);
+uint32_t X509_get_key_usage(X509 *x);
+uint32_t X509_get_extended_key_usage(X509 *x);
+const ASN1_OCTET_STRING *X509_get0_subject_key_id(X509 *x);
+const ASN1_OCTET_STRING *X509_get0_authority_key_id(X509 *x);
+const GENERAL_NAMES *X509_get0_authority_issuer(X509 *x);
+const ASN1_INTEGER *X509_get0_authority_serial(X509 *x);
+
+int X509_PURPOSE_get_count(void);
+X509_PURPOSE *X509_PURPOSE_get0(int idx);
+int X509_PURPOSE_get_by_sname(const char *sname);
+int X509_PURPOSE_get_by_id(int id);
+int X509_PURPOSE_add(int id, int trust, int flags,
+                     int (*ck) (const X509_PURPOSE *, const X509 *, int),
+                     const char *name, const char *sname, void *arg);
+char *X509_PURPOSE_get0_name(const X509_PURPOSE *xp);
+char *X509_PURPOSE_get0_sname(const X509_PURPOSE *xp);
+int X509_PURPOSE_get_trust(const X509_PURPOSE *xp);
+void X509_PURPOSE_cleanup(void);
+int X509_PURPOSE_get_id(const X509_PURPOSE *);
+
+STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x);
+STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x);
+void X509_email_free(STACK_OF(OPENSSL_STRING) *sk);
+STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x);
+/* Flags for X509_check_* functions */
+
+/*
+ * Always check subject name for host match even if subject alt names present
+ */
+# define X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT    0x1
+/* Disable wildcard matching for dnsName fields and common name. */
+# define X509_CHECK_FLAG_NO_WILDCARDS    0x2
+/* Wildcards must not match a partial label. */
+# define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0x4
+/* Allow (non-partial) wildcards to match multiple labels. */
+# define X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS 0x8
+/* Constraint verifier subdomain patterns to match a single labels. */
+# define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0x10
+/* Never check the subject CN */
+# define X509_CHECK_FLAG_NEVER_CHECK_SUBJECT    0x20
+/*
+ * Match reference identifiers starting with "." to any sub-domain.
+ * This is a non-public flag, turned on implicitly when the subject
+ * reference identity is a DNS name.
+ */
+# define _X509_CHECK_FLAG_DOT_SUBDOMAINS 0x8000
+
+int X509_check_host(X509 *x, const char *chk, size_t chklen,
+                    unsigned int flags, char **peername);
+int X509_check_email(X509 *x, const char *chk, size_t chklen,
+                     unsigned int flags);
+int X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
+                  unsigned int flags);
+int X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags);
+
+ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc);
+ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc);
+int X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE) *dn_sk,
+                             unsigned long chtype);
+
+void X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent);
+SKM_DEFINE_STACK_OF_INTERNAL(X509_POLICY_NODE, X509_POLICY_NODE, X509_POLICY_NODE)
+#define sk_X509_POLICY_NODE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_value(sk, idx) ((X509_POLICY_NODE *)OPENSSL_sk_value(ossl_check_const_X509_POLICY_NODE_sk_type(sk), (idx)))
+#define sk_X509_POLICY_NODE_new(cmp) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new(ossl_check_X509_POLICY_NODE_compfunc_type(cmp)))
+#define sk_X509_POLICY_NODE_new_null() ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new_null())
+#define sk_X509_POLICY_NODE_new_reserve(cmp, n) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new_reserve(ossl_check_X509_POLICY_NODE_compfunc_type(cmp), (n)))
+#define sk_X509_POLICY_NODE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_POLICY_NODE_sk_type(sk), (n))
+#define sk_X509_POLICY_NODE_free(sk) OPENSSL_sk_free(ossl_check_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_delete(sk, i) ((X509_POLICY_NODE *)OPENSSL_sk_delete(ossl_check_X509_POLICY_NODE_sk_type(sk), (i)))
+#define sk_X509_POLICY_NODE_delete_ptr(sk, ptr) ((X509_POLICY_NODE *)OPENSSL_sk_delete_ptr(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr)))
+#define sk_X509_POLICY_NODE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
+#define sk_X509_POLICY_NODE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
+#define sk_X509_POLICY_NODE_pop(sk) ((X509_POLICY_NODE *)OPENSSL_sk_pop(ossl_check_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_shift(sk) ((X509_POLICY_NODE *)OPENSSL_sk_shift(ossl_check_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_POLICY_NODE_sk_type(sk),ossl_check_X509_POLICY_NODE_freefunc_type(freefunc))
+#define sk_X509_POLICY_NODE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr), (idx))
+#define sk_X509_POLICY_NODE_set(sk, idx, ptr) ((X509_POLICY_NODE *)OPENSSL_sk_set(ossl_check_X509_POLICY_NODE_sk_type(sk), (idx), ossl_check_X509_POLICY_NODE_type(ptr)))
+#define sk_X509_POLICY_NODE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
+#define sk_X509_POLICY_NODE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
+#define sk_X509_POLICY_NODE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr), pnum)
+#define sk_X509_POLICY_NODE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_POLICY_NODE_sk_type(sk))
+#define sk_X509_POLICY_NODE_dup(sk) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_dup(ossl_check_const_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_copyfunc_type(copyfunc), ossl_check_X509_POLICY_NODE_freefunc_type(freefunc)))
+#define sk_X509_POLICY_NODE_set_cmp_func(sk, cmp) ((sk_X509_POLICY_NODE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_compfunc_type(cmp)))
+
+
+
+#ifndef OPENSSL_NO_RFC3779
+typedef struct ASRange_st {
+    ASN1_INTEGER *min, *max;
+} ASRange;
+
+# define ASIdOrRange_id          0
+# define ASIdOrRange_range       1
+
+typedef struct ASIdOrRange_st {
+    int type;
+    union {
+        ASN1_INTEGER *id;
+        ASRange *range;
+    } u;
+} ASIdOrRange;
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASIdOrRange, ASIdOrRange, ASIdOrRange)
+#define sk_ASIdOrRange_num(sk) OPENSSL_sk_num(ossl_check_const_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_value(sk, idx) ((ASIdOrRange *)OPENSSL_sk_value(ossl_check_const_ASIdOrRange_sk_type(sk), (idx)))
+#define sk_ASIdOrRange_new(cmp) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new(ossl_check_ASIdOrRange_compfunc_type(cmp)))
+#define sk_ASIdOrRange_new_null() ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new_null())
+#define sk_ASIdOrRange_new_reserve(cmp, n) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new_reserve(ossl_check_ASIdOrRange_compfunc_type(cmp), (n)))
+#define sk_ASIdOrRange_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASIdOrRange_sk_type(sk), (n))
+#define sk_ASIdOrRange_free(sk) OPENSSL_sk_free(ossl_check_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_zero(sk) OPENSSL_sk_zero(ossl_check_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_delete(sk, i) ((ASIdOrRange *)OPENSSL_sk_delete(ossl_check_ASIdOrRange_sk_type(sk), (i)))
+#define sk_ASIdOrRange_delete_ptr(sk, ptr) ((ASIdOrRange *)OPENSSL_sk_delete_ptr(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr)))
+#define sk_ASIdOrRange_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
+#define sk_ASIdOrRange_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
+#define sk_ASIdOrRange_pop(sk) ((ASIdOrRange *)OPENSSL_sk_pop(ossl_check_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_shift(sk) ((ASIdOrRange *)OPENSSL_sk_shift(ossl_check_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASIdOrRange_sk_type(sk),ossl_check_ASIdOrRange_freefunc_type(freefunc))
+#define sk_ASIdOrRange_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr), (idx))
+#define sk_ASIdOrRange_set(sk, idx, ptr) ((ASIdOrRange *)OPENSSL_sk_set(ossl_check_ASIdOrRange_sk_type(sk), (idx), ossl_check_ASIdOrRange_type(ptr)))
+#define sk_ASIdOrRange_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
+#define sk_ASIdOrRange_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
+#define sk_ASIdOrRange_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr), pnum)
+#define sk_ASIdOrRange_sort(sk) OPENSSL_sk_sort(ossl_check_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASIdOrRange_sk_type(sk))
+#define sk_ASIdOrRange_dup(sk) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_dup(ossl_check_const_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_deep_copy(ossl_check_const_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_copyfunc_type(copyfunc), ossl_check_ASIdOrRange_freefunc_type(freefunc)))
+#define sk_ASIdOrRange_set_cmp_func(sk, cmp) ((sk_ASIdOrRange_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_compfunc_type(cmp)))
+
+
+typedef STACK_OF(ASIdOrRange) ASIdOrRanges;
+
+# define ASIdentifierChoice_inherit              0
+# define ASIdentifierChoice_asIdsOrRanges        1
+
+typedef struct ASIdentifierChoice_st {
+    int type;
+    union {
+        ASN1_NULL *inherit;
+        ASIdOrRanges *asIdsOrRanges;
+    } u;
+} ASIdentifierChoice;
+
+typedef struct ASIdentifiers_st {
+    ASIdentifierChoice *asnum, *rdi;
+} ASIdentifiers;
+
+DECLARE_ASN1_FUNCTIONS(ASRange)
+DECLARE_ASN1_FUNCTIONS(ASIdOrRange)
+DECLARE_ASN1_FUNCTIONS(ASIdentifierChoice)
+DECLARE_ASN1_FUNCTIONS(ASIdentifiers)
+
+typedef struct IPAddressRange_st {
+    ASN1_BIT_STRING *min, *max;
+} IPAddressRange;
+
+# define IPAddressOrRange_addressPrefix  0
+# define IPAddressOrRange_addressRange   1
+
+typedef struct IPAddressOrRange_st {
+    int type;
+    union {
+        ASN1_BIT_STRING *addressPrefix;
+        IPAddressRange *addressRange;
+    } u;
+} IPAddressOrRange;
+
+SKM_DEFINE_STACK_OF_INTERNAL(IPAddressOrRange, IPAddressOrRange, IPAddressOrRange)
+#define sk_IPAddressOrRange_num(sk) OPENSSL_sk_num(ossl_check_const_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_value(sk, idx) ((IPAddressOrRange *)OPENSSL_sk_value(ossl_check_const_IPAddressOrRange_sk_type(sk), (idx)))
+#define sk_IPAddressOrRange_new(cmp) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new(ossl_check_IPAddressOrRange_compfunc_type(cmp)))
+#define sk_IPAddressOrRange_new_null() ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new_null())
+#define sk_IPAddressOrRange_new_reserve(cmp, n) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new_reserve(ossl_check_IPAddressOrRange_compfunc_type(cmp), (n)))
+#define sk_IPAddressOrRange_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_IPAddressOrRange_sk_type(sk), (n))
+#define sk_IPAddressOrRange_free(sk) OPENSSL_sk_free(ossl_check_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_zero(sk) OPENSSL_sk_zero(ossl_check_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_delete(sk, i) ((IPAddressOrRange *)OPENSSL_sk_delete(ossl_check_IPAddressOrRange_sk_type(sk), (i)))
+#define sk_IPAddressOrRange_delete_ptr(sk, ptr) ((IPAddressOrRange *)OPENSSL_sk_delete_ptr(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr)))
+#define sk_IPAddressOrRange_push(sk, ptr) OPENSSL_sk_push(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
+#define sk_IPAddressOrRange_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
+#define sk_IPAddressOrRange_pop(sk) ((IPAddressOrRange *)OPENSSL_sk_pop(ossl_check_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_shift(sk) ((IPAddressOrRange *)OPENSSL_sk_shift(ossl_check_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_IPAddressOrRange_sk_type(sk),ossl_check_IPAddressOrRange_freefunc_type(freefunc))
+#define sk_IPAddressOrRange_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr), (idx))
+#define sk_IPAddressOrRange_set(sk, idx, ptr) ((IPAddressOrRange *)OPENSSL_sk_set(ossl_check_IPAddressOrRange_sk_type(sk), (idx), ossl_check_IPAddressOrRange_type(ptr)))
+#define sk_IPAddressOrRange_find(sk, ptr) OPENSSL_sk_find(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
+#define sk_IPAddressOrRange_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
+#define sk_IPAddressOrRange_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr), pnum)
+#define sk_IPAddressOrRange_sort(sk) OPENSSL_sk_sort(ossl_check_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_IPAddressOrRange_sk_type(sk))
+#define sk_IPAddressOrRange_dup(sk) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_dup(ossl_check_const_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_deep_copy(ossl_check_const_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_copyfunc_type(copyfunc), ossl_check_IPAddressOrRange_freefunc_type(freefunc)))
+#define sk_IPAddressOrRange_set_cmp_func(sk, cmp) ((sk_IPAddressOrRange_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_compfunc_type(cmp)))
+
+
+typedef STACK_OF(IPAddressOrRange) IPAddressOrRanges;
+
+# define IPAddressChoice_inherit                 0
+# define IPAddressChoice_addressesOrRanges       1
+
+typedef struct IPAddressChoice_st {
+    int type;
+    union {
+        ASN1_NULL *inherit;
+        IPAddressOrRanges *addressesOrRanges;
+    } u;
+} IPAddressChoice;
+
+typedef struct IPAddressFamily_st {
+    ASN1_OCTET_STRING *addressFamily;
+    IPAddressChoice *ipAddressChoice;
+} IPAddressFamily;
+
+SKM_DEFINE_STACK_OF_INTERNAL(IPAddressFamily, IPAddressFamily, IPAddressFamily)
+#define sk_IPAddressFamily_num(sk) OPENSSL_sk_num(ossl_check_const_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_value(sk, idx) ((IPAddressFamily *)OPENSSL_sk_value(ossl_check_const_IPAddressFamily_sk_type(sk), (idx)))
+#define sk_IPAddressFamily_new(cmp) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new(ossl_check_IPAddressFamily_compfunc_type(cmp)))
+#define sk_IPAddressFamily_new_null() ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new_null())
+#define sk_IPAddressFamily_new_reserve(cmp, n) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new_reserve(ossl_check_IPAddressFamily_compfunc_type(cmp), (n)))
+#define sk_IPAddressFamily_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_IPAddressFamily_sk_type(sk), (n))
+#define sk_IPAddressFamily_free(sk) OPENSSL_sk_free(ossl_check_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_zero(sk) OPENSSL_sk_zero(ossl_check_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_delete(sk, i) ((IPAddressFamily *)OPENSSL_sk_delete(ossl_check_IPAddressFamily_sk_type(sk), (i)))
+#define sk_IPAddressFamily_delete_ptr(sk, ptr) ((IPAddressFamily *)OPENSSL_sk_delete_ptr(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr)))
+#define sk_IPAddressFamily_push(sk, ptr) OPENSSL_sk_push(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
+#define sk_IPAddressFamily_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
+#define sk_IPAddressFamily_pop(sk) ((IPAddressFamily *)OPENSSL_sk_pop(ossl_check_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_shift(sk) ((IPAddressFamily *)OPENSSL_sk_shift(ossl_check_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_IPAddressFamily_sk_type(sk),ossl_check_IPAddressFamily_freefunc_type(freefunc))
+#define sk_IPAddressFamily_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr), (idx))
+#define sk_IPAddressFamily_set(sk, idx, ptr) ((IPAddressFamily *)OPENSSL_sk_set(ossl_check_IPAddressFamily_sk_type(sk), (idx), ossl_check_IPAddressFamily_type(ptr)))
+#define sk_IPAddressFamily_find(sk, ptr) OPENSSL_sk_find(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
+#define sk_IPAddressFamily_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
+#define sk_IPAddressFamily_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr), pnum)
+#define sk_IPAddressFamily_sort(sk) OPENSSL_sk_sort(ossl_check_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_IPAddressFamily_sk_type(sk))
+#define sk_IPAddressFamily_dup(sk) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_dup(ossl_check_const_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_deep_copy(ossl_check_const_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_copyfunc_type(copyfunc), ossl_check_IPAddressFamily_freefunc_type(freefunc)))
+#define sk_IPAddressFamily_set_cmp_func(sk, cmp) ((sk_IPAddressFamily_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_compfunc_type(cmp)))
+
+
+
+typedef STACK_OF(IPAddressFamily) IPAddrBlocks;
+
+DECLARE_ASN1_FUNCTIONS(IPAddressRange)
+DECLARE_ASN1_FUNCTIONS(IPAddressOrRange)
+DECLARE_ASN1_FUNCTIONS(IPAddressChoice)
+DECLARE_ASN1_FUNCTIONS(IPAddressFamily)
+
+/*
+ * API tag for elements of the ASIdentifer SEQUENCE.
+ */
+# define V3_ASID_ASNUM   0
+# define V3_ASID_RDI     1
+
+/*
+ * AFI values, assigned by IANA.  It'd be nice to make the AFI
+ * handling code totally generic, but there are too many little things
+ * that would need to be defined for other address families for it to
+ * be worth the trouble.
+ */
+# define IANA_AFI_IPV4   1
+# define IANA_AFI_IPV6   2
+
+/*
+ * Utilities to construct and extract values from RFC3779 extensions,
+ * since some of the encodings (particularly for IP address prefixes
+ * and ranges) are a bit tedious to work with directly.
+ */
+int X509v3_asid_add_inherit(ASIdentifiers *asid, int which);
+int X509v3_asid_add_id_or_range(ASIdentifiers *asid, int which,
+                                ASN1_INTEGER *min, ASN1_INTEGER *max);
+int X509v3_addr_add_inherit(IPAddrBlocks *addr,
+                            const unsigned afi, const unsigned *safi);
+int X509v3_addr_add_prefix(IPAddrBlocks *addr,
+                           const unsigned afi, const unsigned *safi,
+                           unsigned char *a, const int prefixlen);
+int X509v3_addr_add_range(IPAddrBlocks *addr,
+                          const unsigned afi, const unsigned *safi,
+                          unsigned char *min, unsigned char *max);
+unsigned X509v3_addr_get_afi(const IPAddressFamily *f);
+int X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi,
+                          unsigned char *min, unsigned char *max,
+                          const int length);
+
+/*
+ * Canonical forms.
+ */
+int X509v3_asid_is_canonical(ASIdentifiers *asid);
+int X509v3_addr_is_canonical(IPAddrBlocks *addr);
+int X509v3_asid_canonize(ASIdentifiers *asid);
+int X509v3_addr_canonize(IPAddrBlocks *addr);
+
+/*
+ * Tests for inheritance and containment.
+ */
+int X509v3_asid_inherits(ASIdentifiers *asid);
+int X509v3_addr_inherits(IPAddrBlocks *addr);
+int X509v3_asid_subset(ASIdentifiers *a, ASIdentifiers *b);
+int X509v3_addr_subset(IPAddrBlocks *a, IPAddrBlocks *b);
+
+/*
+ * Check whether RFC 3779 extensions nest properly in chains.
+ */
+int X509v3_asid_validate_path(X509_STORE_CTX *);
+int X509v3_addr_validate_path(X509_STORE_CTX *);
+int X509v3_asid_validate_resource_set(STACK_OF(X509) *chain,
+                                      ASIdentifiers *ext,
+                                      int allow_inheritance);
+int X509v3_addr_validate_resource_set(STACK_OF(X509) *chain,
+                                      IPAddrBlocks *ext, int allow_inheritance);
+
+#endif                         /* OPENSSL_NO_RFC3779 */
+
+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING, ASN1_STRING, ASN1_STRING)
+#define sk_ASN1_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_value(sk, idx) ((ASN1_STRING *)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_sk_type(sk), (idx)))
+#define sk_ASN1_STRING_new(cmp) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new(ossl_check_ASN1_STRING_compfunc_type(cmp)))
+#define sk_ASN1_STRING_new_null() ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new_null())
+#define sk_ASN1_STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_STRING_sk_type(sk), (n))
+#define sk_ASN1_STRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_delete(sk, i) ((ASN1_STRING *)OPENSSL_sk_delete(ossl_check_ASN1_STRING_sk_type(sk), (i)))
+#define sk_ASN1_STRING_delete_ptr(sk, ptr) ((ASN1_STRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr)))
+#define sk_ASN1_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
+#define sk_ASN1_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
+#define sk_ASN1_STRING_pop(sk) ((ASN1_STRING *)OPENSSL_sk_pop(ossl_check_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_shift(sk) ((ASN1_STRING *)OPENSSL_sk_shift(ossl_check_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_sk_type(sk),ossl_check_ASN1_STRING_freefunc_type(freefunc))
+#define sk_ASN1_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr), (idx))
+#define sk_ASN1_STRING_set(sk, idx, ptr) ((ASN1_STRING *)OPENSSL_sk_set(ossl_check_ASN1_STRING_sk_type(sk), (idx), ossl_check_ASN1_STRING_type(ptr)))
+#define sk_ASN1_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
+#define sk_ASN1_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
+#define sk_ASN1_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr), pnum)
+#define sk_ASN1_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_STRING_sk_type(sk))
+#define sk_ASN1_STRING_dup(sk) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_freefunc_type(freefunc)))
+#define sk_ASN1_STRING_set_cmp_func(sk, cmp) ((sk_ASN1_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_compfunc_type(cmp)))
+
+
+/*
+ * Admission Syntax
+ */
+typedef struct NamingAuthority_st NAMING_AUTHORITY;
+typedef struct ProfessionInfo_st PROFESSION_INFO;
+typedef struct Admissions_st ADMISSIONS;
+typedef struct AdmissionSyntax_st ADMISSION_SYNTAX;
+DECLARE_ASN1_FUNCTIONS(NAMING_AUTHORITY)
+DECLARE_ASN1_FUNCTIONS(PROFESSION_INFO)
+DECLARE_ASN1_FUNCTIONS(ADMISSIONS)
+DECLARE_ASN1_FUNCTIONS(ADMISSION_SYNTAX)
+SKM_DEFINE_STACK_OF_INTERNAL(PROFESSION_INFO, PROFESSION_INFO, PROFESSION_INFO)
+#define sk_PROFESSION_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_value(sk, idx) ((PROFESSION_INFO *)OPENSSL_sk_value(ossl_check_const_PROFESSION_INFO_sk_type(sk), (idx)))
+#define sk_PROFESSION_INFO_new(cmp) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new(ossl_check_PROFESSION_INFO_compfunc_type(cmp)))
+#define sk_PROFESSION_INFO_new_null() ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new_null())
+#define sk_PROFESSION_INFO_new_reserve(cmp, n) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PROFESSION_INFO_compfunc_type(cmp), (n)))
+#define sk_PROFESSION_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PROFESSION_INFO_sk_type(sk), (n))
+#define sk_PROFESSION_INFO_free(sk) OPENSSL_sk_free(ossl_check_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_delete(sk, i) ((PROFESSION_INFO *)OPENSSL_sk_delete(ossl_check_PROFESSION_INFO_sk_type(sk), (i)))
+#define sk_PROFESSION_INFO_delete_ptr(sk, ptr) ((PROFESSION_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr)))
+#define sk_PROFESSION_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
+#define sk_PROFESSION_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
+#define sk_PROFESSION_INFO_pop(sk) ((PROFESSION_INFO *)OPENSSL_sk_pop(ossl_check_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_shift(sk) ((PROFESSION_INFO *)OPENSSL_sk_shift(ossl_check_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PROFESSION_INFO_sk_type(sk),ossl_check_PROFESSION_INFO_freefunc_type(freefunc))
+#define sk_PROFESSION_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr), (idx))
+#define sk_PROFESSION_INFO_set(sk, idx, ptr) ((PROFESSION_INFO *)OPENSSL_sk_set(ossl_check_PROFESSION_INFO_sk_type(sk), (idx), ossl_check_PROFESSION_INFO_type(ptr)))
+#define sk_PROFESSION_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
+#define sk_PROFESSION_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
+#define sk_PROFESSION_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr), pnum)
+#define sk_PROFESSION_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PROFESSION_INFO_sk_type(sk))
+#define sk_PROFESSION_INFO_dup(sk) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_dup(ossl_check_const_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_copyfunc_type(copyfunc), ossl_check_PROFESSION_INFO_freefunc_type(freefunc)))
+#define sk_PROFESSION_INFO_set_cmp_func(sk, cmp) ((sk_PROFESSION_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_compfunc_type(cmp)))
+SKM_DEFINE_STACK_OF_INTERNAL(ADMISSIONS, ADMISSIONS, ADMISSIONS)
+#define sk_ADMISSIONS_num(sk) OPENSSL_sk_num(ossl_check_const_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_value(sk, idx) ((ADMISSIONS *)OPENSSL_sk_value(ossl_check_const_ADMISSIONS_sk_type(sk), (idx)))
+#define sk_ADMISSIONS_new(cmp) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new(ossl_check_ADMISSIONS_compfunc_type(cmp)))
+#define sk_ADMISSIONS_new_null() ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new_null())
+#define sk_ADMISSIONS_new_reserve(cmp, n) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new_reserve(ossl_check_ADMISSIONS_compfunc_type(cmp), (n)))
+#define sk_ADMISSIONS_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ADMISSIONS_sk_type(sk), (n))
+#define sk_ADMISSIONS_free(sk) OPENSSL_sk_free(ossl_check_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_zero(sk) OPENSSL_sk_zero(ossl_check_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_delete(sk, i) ((ADMISSIONS *)OPENSSL_sk_delete(ossl_check_ADMISSIONS_sk_type(sk), (i)))
+#define sk_ADMISSIONS_delete_ptr(sk, ptr) ((ADMISSIONS *)OPENSSL_sk_delete_ptr(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr)))
+#define sk_ADMISSIONS_push(sk, ptr) OPENSSL_sk_push(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
+#define sk_ADMISSIONS_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
+#define sk_ADMISSIONS_pop(sk) ((ADMISSIONS *)OPENSSL_sk_pop(ossl_check_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_shift(sk) ((ADMISSIONS *)OPENSSL_sk_shift(ossl_check_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ADMISSIONS_sk_type(sk),ossl_check_ADMISSIONS_freefunc_type(freefunc))
+#define sk_ADMISSIONS_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr), (idx))
+#define sk_ADMISSIONS_set(sk, idx, ptr) ((ADMISSIONS *)OPENSSL_sk_set(ossl_check_ADMISSIONS_sk_type(sk), (idx), ossl_check_ADMISSIONS_type(ptr)))
+#define sk_ADMISSIONS_find(sk, ptr) OPENSSL_sk_find(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
+#define sk_ADMISSIONS_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
+#define sk_ADMISSIONS_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr), pnum)
+#define sk_ADMISSIONS_sort(sk) OPENSSL_sk_sort(ossl_check_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ADMISSIONS_sk_type(sk))
+#define sk_ADMISSIONS_dup(sk) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_dup(ossl_check_const_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_deep_copy(ossl_check_const_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_copyfunc_type(copyfunc), ossl_check_ADMISSIONS_freefunc_type(freefunc)))
+#define sk_ADMISSIONS_set_cmp_func(sk, cmp) ((sk_ADMISSIONS_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_compfunc_type(cmp)))
+
+typedef STACK_OF(PROFESSION_INFO) PROFESSION_INFOS;
+
+const ASN1_OBJECT *NAMING_AUTHORITY_get0_authorityId(
+    const NAMING_AUTHORITY *n);
+const ASN1_IA5STRING *NAMING_AUTHORITY_get0_authorityURL(
+    const NAMING_AUTHORITY *n);
+const ASN1_STRING *NAMING_AUTHORITY_get0_authorityText(
+    const NAMING_AUTHORITY *n);
+void NAMING_AUTHORITY_set0_authorityId(NAMING_AUTHORITY *n,
+    ASN1_OBJECT* namingAuthorityId);
+void NAMING_AUTHORITY_set0_authorityURL(NAMING_AUTHORITY *n,
+    ASN1_IA5STRING* namingAuthorityUrl);
+void NAMING_AUTHORITY_set0_authorityText(NAMING_AUTHORITY *n,
+    ASN1_STRING* namingAuthorityText);
+
+const GENERAL_NAME *ADMISSION_SYNTAX_get0_admissionAuthority(
+    const ADMISSION_SYNTAX *as);
+void ADMISSION_SYNTAX_set0_admissionAuthority(
+    ADMISSION_SYNTAX *as, GENERAL_NAME *aa);
+const STACK_OF(ADMISSIONS) *ADMISSION_SYNTAX_get0_contentsOfAdmissions(
+    const ADMISSION_SYNTAX *as);
+void ADMISSION_SYNTAX_set0_contentsOfAdmissions(
+    ADMISSION_SYNTAX *as, STACK_OF(ADMISSIONS) *a);
+const GENERAL_NAME *ADMISSIONS_get0_admissionAuthority(const ADMISSIONS *a);
+void ADMISSIONS_set0_admissionAuthority(ADMISSIONS *a, GENERAL_NAME *aa);
+const NAMING_AUTHORITY *ADMISSIONS_get0_namingAuthority(const ADMISSIONS *a);
+void ADMISSIONS_set0_namingAuthority(ADMISSIONS *a, NAMING_AUTHORITY *na);
+const PROFESSION_INFOS *ADMISSIONS_get0_professionInfos(const ADMISSIONS *a);
+void ADMISSIONS_set0_professionInfos(ADMISSIONS *a, PROFESSION_INFOS *pi);
+const ASN1_OCTET_STRING *PROFESSION_INFO_get0_addProfessionInfo(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_addProfessionInfo(
+    PROFESSION_INFO *pi, ASN1_OCTET_STRING *aos);
+const NAMING_AUTHORITY *PROFESSION_INFO_get0_namingAuthority(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_namingAuthority(
+    PROFESSION_INFO *pi, NAMING_AUTHORITY *na);
+const STACK_OF(ASN1_STRING) *PROFESSION_INFO_get0_professionItems(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_professionItems(
+    PROFESSION_INFO *pi, STACK_OF(ASN1_STRING) *as);
+const STACK_OF(ASN1_OBJECT) *PROFESSION_INFO_get0_professionOIDs(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_professionOIDs(
+    PROFESSION_INFO *pi, STACK_OF(ASN1_OBJECT) *po);
+const ASN1_PRINTABLESTRING *PROFESSION_INFO_get0_registrationNumber(
+    const PROFESSION_INFO *pi);
+void PROFESSION_INFO_set0_registrationNumber(
+    PROFESSION_INFO *pi, ASN1_PRINTABLESTRING *rn);
+
+# ifdef  __cplusplus
+}
+# endif
+#endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509v3err.h b/CAPI/cpp/grpc/include/openssl/x509v3err.h
new file mode 100644
index 0000000..1ae3a56
--- /dev/null
+++ b/CAPI/cpp/grpc/include/openssl/x509v3err.h
@@ -0,0 +1,93 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_X509V3ERR_H
+# define OPENSSL_X509V3ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * X509V3 reason codes.
+ */
+# define X509V3_R_BAD_IP_ADDRESS                          118
+# define X509V3_R_BAD_OBJECT                              119
+# define X509V3_R_BN_DEC2BN_ERROR                         100
+# define X509V3_R_BN_TO_ASN1_INTEGER_ERROR                101
+# define X509V3_R_DIRNAME_ERROR                           149
+# define X509V3_R_DISTPOINT_ALREADY_SET                   160
+# define X509V3_R_DUPLICATE_ZONE_ID                       133
+# define X509V3_R_EMPTY_KEY_USAGE                         169
+# define X509V3_R_ERROR_CONVERTING_ZONE                   131
+# define X509V3_R_ERROR_CREATING_EXTENSION                144
+# define X509V3_R_ERROR_IN_EXTENSION                      128
+# define X509V3_R_EXPECTED_A_SECTION_NAME                 137
+# define X509V3_R_EXTENSION_EXISTS                        145
+# define X509V3_R_EXTENSION_NAME_ERROR                    115
+# define X509V3_R_EXTENSION_NOT_FOUND                     102
+# define X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED         103
+# define X509V3_R_EXTENSION_VALUE_ERROR                   116
+# define X509V3_R_ILLEGAL_EMPTY_EXTENSION                 151
+# define X509V3_R_INCORRECT_POLICY_SYNTAX_TAG             152
+# define X509V3_R_INVALID_ASNUMBER                        162
+# define X509V3_R_INVALID_ASRANGE                         163
+# define X509V3_R_INVALID_BOOLEAN_STRING                  104
+# define X509V3_R_INVALID_CERTIFICATE                     158
+# define X509V3_R_INVALID_EMPTY_NAME                      108
+# define X509V3_R_INVALID_EXTENSION_STRING                105
+# define X509V3_R_INVALID_INHERITANCE                     165
+# define X509V3_R_INVALID_IPADDRESS                       166
+# define X509V3_R_INVALID_MULTIPLE_RDNS                   161
+# define X509V3_R_INVALID_NAME                            106
+# define X509V3_R_INVALID_NULL_ARGUMENT                   107
+# define X509V3_R_INVALID_NULL_VALUE                      109
+# define X509V3_R_INVALID_NUMBER                          140
+# define X509V3_R_INVALID_NUMBERS                         141
+# define X509V3_R_INVALID_OBJECT_IDENTIFIER               110
+# define X509V3_R_INVALID_OPTION                          138
+# define X509V3_R_INVALID_POLICY_IDENTIFIER               134
+# define X509V3_R_INVALID_PROXY_POLICY_SETTING            153
+# define X509V3_R_INVALID_PURPOSE                         146
+# define X509V3_R_INVALID_SAFI                            164
+# define X509V3_R_INVALID_SECTION                         135
+# define X509V3_R_INVALID_SYNTAX                          143
+# define X509V3_R_ISSUER_DECODE_ERROR                     126
+# define X509V3_R_MISSING_VALUE                           124
+# define X509V3_R_NEED_ORGANIZATION_AND_NUMBERS           142
+# define X509V3_R_NEGATIVE_PATHLEN                        168
+# define X509V3_R_NO_CONFIG_DATABASE                      136
+# define X509V3_R_NO_ISSUER_CERTIFICATE                   121
+# define X509V3_R_NO_ISSUER_DETAILS                       127
+# define X509V3_R_NO_POLICY_IDENTIFIER                    139
+# define X509V3_R_NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED   154
+# define X509V3_R_NO_PUBLIC_KEY                           114
+# define X509V3_R_NO_SUBJECT_DETAILS                      125
+# define X509V3_R_OPERATION_NOT_DEFINED                   148
+# define X509V3_R_OTHERNAME_ERROR                         147
+# define X509V3_R_POLICY_LANGUAGE_ALREADY_DEFINED         155
+# define X509V3_R_POLICY_PATH_LENGTH                      156
+# define X509V3_R_POLICY_PATH_LENGTH_ALREADY_DEFINED      157
+# define X509V3_R_POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY 159
+# define X509V3_R_SECTION_NOT_FOUND                       150
+# define X509V3_R_UNABLE_TO_GET_ISSUER_DETAILS            122
+# define X509V3_R_UNABLE_TO_GET_ISSUER_KEYID              123
+# define X509V3_R_UNKNOWN_BIT_STRING_ARGUMENT             111
+# define X509V3_R_UNKNOWN_EXTENSION                       129
+# define X509V3_R_UNKNOWN_EXTENSION_NAME                  130
+# define X509V3_R_UNKNOWN_OPTION                          120
+# define X509V3_R_UNSUPPORTED_OPTION                      117
+# define X509V3_R_UNSUPPORTED_TYPE                        167
+# define X509V3_R_USER_TOO_LONG                           132
+
+#endif
diff --git a/CAPI/cpp/grpc/include/re2/filtered_re2.h b/CAPI/cpp/grpc/include/re2/filtered_re2.h
new file mode 100644
index 0000000..dd618c7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/re2/filtered_re2.h
@@ -0,0 +1,114 @@
+// Copyright 2009 The RE2 Authors.  All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef RE2_FILTERED_RE2_H_
+#define RE2_FILTERED_RE2_H_
+
+// The class FilteredRE2 is used as a wrapper to multiple RE2 regexps.
+// It provides a prefilter mechanism that helps in cutting down the
+// number of regexps that need to be actually searched.
+//
+// By design, it does not include a string matching engine. This is to
+// allow the user of the class to use their favorite string matching
+// engine. The overall flow is: Add all the regexps using Add, then
+// Compile the FilteredRE2. Compile returns strings that need to be
+// matched. Note that the returned strings are lowercased and distinct.
+// For applying regexps to a search text, the caller does the string
+// matching using the returned strings. When doing the string match,
+// note that the caller has to do that in a case-insensitive way or
+// on a lowercased version of the search text. Then call FirstMatch
+// or AllMatches with a vector of indices of strings that were found
+// in the text to get the actual regexp matches.
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "re2/re2.h"
+
+namespace re2 {
+
+class PrefilterTree;
+
+class FilteredRE2 {
+ public:
+  FilteredRE2();
+  explicit FilteredRE2(int min_atom_len);
+  ~FilteredRE2();
+
+  // Not copyable.
+  FilteredRE2(const FilteredRE2&) = delete;
+  FilteredRE2& operator=(const FilteredRE2&) = delete;
+  // Movable.
+  FilteredRE2(FilteredRE2&& other);
+  FilteredRE2& operator=(FilteredRE2&& other);
+
+  // Uses RE2 constructor to create a RE2 object (re). Returns
+  // re->error_code(). If error_code is other than NoError, then re is
+  // deleted and not added to re2_vec_.
+  RE2::ErrorCode Add(const StringPiece& pattern,
+                     const RE2::Options& options,
+                     int* id);
+
+  // Prepares the regexps added by Add for filtering.  Returns a set
+  // of strings that the caller should check for in candidate texts.
+  // The returned strings are lowercased and distinct. When doing
+  // string matching, it should be performed in a case-insensitive
+  // way or the search text should be lowercased first.  Call after
+  // all Add calls are done.
+  void Compile(std::vector<std::string>* strings_to_match);
+
+  // Returns the index of the first matching regexp.
+  // Returns -1 on no match. Can be called prior to Compile.
+  // Does not do any filtering: simply tries to Match the
+  // regexps in a loop.
+  int SlowFirstMatch(const StringPiece& text) const;
+
+  // Returns the index of the first matching regexp.
+  // Returns -1 on no match. Compile has to be called before
+  // calling this.
+  int FirstMatch(const StringPiece& text,
+                 const std::vector<int>& atoms) const;
+
+  // Returns the indices of all matching regexps, after first clearing
+  // matched_regexps.
+  bool AllMatches(const StringPiece& text,
+                  const std::vector<int>& atoms,
+                  std::vector<int>* matching_regexps) const;
+
+  // Returns the indices of all potentially matching regexps after first
+  // clearing potential_regexps.
+  // A regexp is potentially matching if it passes the filter.
+  // If a regexp passes the filter it may still not match.
+  // A regexp that does not pass the filter is guaranteed to not match.
+  void AllPotentials(const std::vector<int>& atoms,
+                     std::vector<int>* potential_regexps) const;
+
+  // The number of regexps added.
+  int NumRegexps() const { return static_cast<int>(re2_vec_.size()); }
+
+  // Get the individual RE2 objects.
+  const RE2& GetRE2(int regexpid) const { return *re2_vec_[regexpid]; }
+
+ private:
+  // Print prefilter.
+  void PrintPrefilter(int regexpid);
+
+  // Useful for testing and debugging.
+  void RegexpsGivenStrings(const std::vector<int>& matched_atoms,
+                           std::vector<int>* passed_regexps);
+
+  // All the regexps in the FilteredRE2.
+  std::vector<RE2*> re2_vec_;
+
+  // Has the FilteredRE2 been compiled using Compile()
+  bool compiled_;
+
+  // An AND-OR tree of string atoms used for filtering regexps.
+  std::unique_ptr<PrefilterTree> prefilter_tree_;
+};
+
+}  // namespace re2
+
+#endif  // RE2_FILTERED_RE2_H_
diff --git a/CAPI/cpp/grpc/include/re2/re2.h b/CAPI/cpp/grpc/include/re2/re2.h
new file mode 100644
index 0000000..7fd2245
--- /dev/null
+++ b/CAPI/cpp/grpc/include/re2/re2.h
@@ -0,0 +1,1017 @@
+// Copyright 2003-2009 The RE2 Authors.  All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef RE2_RE2_H_
+#define RE2_RE2_H_
+
+// C++ interface to the re2 regular-expression library.
+// RE2 supports Perl-style regular expressions (with extensions like
+// \d, \w, \s, ...).
+//
+// -----------------------------------------------------------------------
+// REGEXP SYNTAX:
+//
+// This module uses the re2 library and hence supports
+// its syntax for regular expressions, which is similar to Perl's with
+// some of the more complicated things thrown away.  In particular,
+// backreferences and generalized assertions are not available, nor is \Z.
+//
+// See https://github.com/google/re2/wiki/Syntax for the syntax
+// supported by RE2, and a comparison with PCRE and PERL regexps.
+//
+// For those not familiar with Perl's regular expressions,
+// here are some examples of the most commonly used extensions:
+//
+//   "hello (\\w+) world"  -- \w matches a "word" character
+//   "version (\\d+)"      -- \d matches a digit
+//   "hello\\s+world"      -- \s matches any whitespace character
+//   "\\b(\\w+)\\b"        -- \b matches non-empty string at word boundary
+//   "(?i)hello"           -- (?i) turns on case-insensitive matching
+//   "/\\*(.*?)\\*/"       -- .*? matches . minimum no. of times possible
+//
+// The double backslashes are needed when writing C++ string literals.
+// However, they should NOT be used when writing C++11 raw string literals:
+//
+//   R"(hello (\w+) world)"  -- \w matches a "word" character
+//   R"(version (\d+))"      -- \d matches a digit
+//   R"(hello\s+world)"      -- \s matches any whitespace character
+//   R"(\b(\w+)\b)"          -- \b matches non-empty string at word boundary
+//   R"((?i)hello)"          -- (?i) turns on case-insensitive matching
+//   R"(/\*(.*?)\*/)"        -- .*? matches . minimum no. of times possible
+//
+// When using UTF-8 encoding, case-insensitive matching will perform
+// simple case folding, not full case folding.
+//
+// -----------------------------------------------------------------------
+// MATCHING INTERFACE:
+//
+// The "FullMatch" operation checks that supplied text matches a
+// supplied pattern exactly.
+//
+// Example: successful match
+//    CHECK(RE2::FullMatch("hello", "h.*o"));
+//
+// Example: unsuccessful match (requires full match):
+//    CHECK(!RE2::FullMatch("hello", "e"));
+//
+// -----------------------------------------------------------------------
+// UTF-8 AND THE MATCHING INTERFACE:
+//
+// By default, the pattern and input text are interpreted as UTF-8.
+// The RE2::Latin1 option causes them to be interpreted as Latin-1.
+//
+// Example:
+//    CHECK(RE2::FullMatch(utf8_string, RE2(utf8_pattern)));
+//    CHECK(RE2::FullMatch(latin1_string, RE2(latin1_pattern, RE2::Latin1)));
+//
+// -----------------------------------------------------------------------
+// MATCHING WITH SUBSTRING EXTRACTION:
+//
+// You can supply extra pointer arguments to extract matched substrings.
+// On match failure, none of the pointees will have been modified.
+// On match success, the substrings will be converted (as necessary) and
+// their values will be assigned to their pointees until all conversions
+// have succeeded or one conversion has failed.
+// On conversion failure, the pointees will be in an indeterminate state
+// because the caller has no way of knowing which conversion failed.
+// However, conversion cannot fail for types like string and StringPiece
+// that do not inspect the substring contents. Hence, in the common case
+// where all of the pointees are of such types, failure is always due to
+// match failure and thus none of the pointees will have been modified.
+//
+// Example: extracts "ruby" into "s" and 1234 into "i"
+//    int i;
+//    std::string s;
+//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s, &i));
+//
+// Example: fails because string cannot be stored in integer
+//    CHECK(!RE2::FullMatch("ruby", "(.*)", &i));
+//
+// Example: fails because there aren't enough sub-patterns
+//    CHECK(!RE2::FullMatch("ruby:1234", "\\w+:\\d+", &s));
+//
+// Example: does not try to extract any extra sub-patterns
+//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s));
+//
+// Example: does not try to extract into NULL
+//    CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", NULL, &i));
+//
+// Example: integer overflow causes failure
+//    CHECK(!RE2::FullMatch("ruby:1234567891234", "\\w+:(\\d+)", &i));
+//
+// NOTE(rsc): Asking for substrings slows successful matches quite a bit.
+// This may get a little faster in the future, but right now is slower
+// than PCRE.  On the other hand, failed matches run *very* fast (faster
+// than PCRE), as do matches without substring extraction.
+//
+// -----------------------------------------------------------------------
+// PARTIAL MATCHES
+//
+// You can use the "PartialMatch" operation when you want the pattern
+// to match any substring of the text.
+//
+// Example: simple search for a string:
+//      CHECK(RE2::PartialMatch("hello", "ell"));
+//
+// Example: find first number in a string
+//      int number;
+//      CHECK(RE2::PartialMatch("x*100 + 20", "(\\d+)", &number));
+//      CHECK_EQ(number, 100);
+//
+// -----------------------------------------------------------------------
+// PRE-COMPILED REGULAR EXPRESSIONS
+//
+// RE2 makes it easy to use any string as a regular expression, without
+// requiring a separate compilation step.
+//
+// If speed is of the essence, you can create a pre-compiled "RE2"
+// object from the pattern and use it multiple times.  If you do so,
+// you can typically parse text faster than with sscanf.
+//
+// Example: precompile pattern for faster matching:
+//    RE2 pattern("h.*o");
+//    while (ReadLine(&str)) {
+//      if (RE2::FullMatch(str, pattern)) ...;
+//    }
+//
+// -----------------------------------------------------------------------
+// SCANNING TEXT INCREMENTALLY
+//
+// The "Consume" operation may be useful if you want to repeatedly
+// match regular expressions at the front of a string and skip over
+// them as they match.  This requires use of the "StringPiece" type,
+// which represents a sub-range of a real string.
+//
+// Example: read lines of the form "var = value" from a string.
+//      std::string contents = ...;     // Fill string somehow
+//      StringPiece input(contents);    // Wrap a StringPiece around it
+//
+//      std::string var;
+//      int value;
+//      while (RE2::Consume(&input, "(\\w+) = (\\d+)\n", &var, &value)) {
+//        ...;
+//      }
+//
+// Each successful call to "Consume" will set "var/value", and also
+// advance "input" so it points past the matched text.  Note that if the
+// regular expression matches an empty string, input will advance
+// by 0 bytes.  If the regular expression being used might match
+// an empty string, the loop body must check for this case and either
+// advance the string or break out of the loop.
+//
+// The "FindAndConsume" operation is similar to "Consume" but does not
+// anchor your match at the beginning of the string.  For example, you
+// could extract all words from a string by repeatedly calling
+//     RE2::FindAndConsume(&input, "(\\w+)", &word)
+//
+// -----------------------------------------------------------------------
+// USING VARIABLE NUMBER OF ARGUMENTS
+//
+// The above operations require you to know the number of arguments
+// when you write the code.  This is not always possible or easy (for
+// example, the regular expression may be calculated at run time).
+// You can use the "N" version of the operations when the number of
+// match arguments are determined at run time.
+//
+// Example:
+//   const RE2::Arg* args[10];
+//   int n;
+//   // ... populate args with pointers to RE2::Arg values ...
+//   // ... set n to the number of RE2::Arg objects ...
+//   bool match = RE2::FullMatchN(input, pattern, args, n);
+//
+// The last statement is equivalent to
+//
+//   bool match = RE2::FullMatch(input, pattern,
+//                               *args[0], *args[1], ..., *args[n - 1]);
+//
+// -----------------------------------------------------------------------
+// PARSING HEX/OCTAL/C-RADIX NUMBERS
+//
+// By default, if you pass a pointer to a numeric value, the
+// corresponding text is interpreted as a base-10 number.  You can
+// instead wrap the pointer with a call to one of the operators Hex(),
+// Octal(), or CRadix() to interpret the text in another base.  The
+// CRadix operator interprets C-style "0" (base-8) and "0x" (base-16)
+// prefixes, but defaults to base-10.
+//
+// Example:
+//   int a, b, c, d;
+//   CHECK(RE2::FullMatch("100 40 0100 0x40", "(.*) (.*) (.*) (.*)",
+//         RE2::Octal(&a), RE2::Hex(&b), RE2::CRadix(&c), RE2::CRadix(&d));
+// will leave 64 in a, b, c, and d.
+
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <map>
+#include <mutex>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+#include "re2/stringpiece.h"
+
+namespace re2 {
+class Prog;
+class Regexp;
+}  // namespace re2
+
+namespace re2 {
+
+// Interface for regular expression matching.  Also corresponds to a
+// pre-compiled regular expression.  An "RE2" object is safe for
+// concurrent use by multiple threads.
+class RE2 {
+ public:
+  // We convert user-passed pointers into special Arg objects
+  class Arg;
+  class Options;
+
+  // Defined in set.h.
+  class Set;
+
+  enum ErrorCode {
+    NoError = 0,
+
+    // Unexpected error
+    ErrorInternal,
+
+    // Parse errors
+    ErrorBadEscape,          // bad escape sequence
+    ErrorBadCharClass,       // bad character class
+    ErrorBadCharRange,       // bad character class range
+    ErrorMissingBracket,     // missing closing ]
+    ErrorMissingParen,       // missing closing )
+    ErrorUnexpectedParen,    // unexpected closing )
+    ErrorTrailingBackslash,  // trailing \ at end of regexp
+    ErrorRepeatArgument,     // repeat argument missing, e.g. "*"
+    ErrorRepeatSize,         // bad repetition argument
+    ErrorRepeatOp,           // bad repetition operator
+    ErrorBadPerlOp,          // bad perl operator
+    ErrorBadUTF8,            // invalid UTF-8 in regexp
+    ErrorBadNamedCapture,    // bad named capture group
+    ErrorPatternTooLarge     // pattern too large (compile failed)
+  };
+
+  // Predefined common options.
+  // If you need more complicated things, instantiate
+  // an Option class, possibly passing one of these to
+  // the Option constructor, change the settings, and pass that
+  // Option class to the RE2 constructor.
+  enum CannedOptions {
+    DefaultOptions = 0,
+    Latin1, // treat input as Latin-1 (default UTF-8)
+    POSIX, // POSIX syntax, leftmost-longest match
+    Quiet // do not log about regexp parse errors
+  };
+
+  // Need to have the const char* and const std::string& forms for implicit
+  // conversions when passing string literals to FullMatch and PartialMatch.
+  // Otherwise the StringPiece form would be sufficient.
+#ifndef SWIG
+  RE2(const char* pattern);
+  RE2(const std::string& pattern);
+#endif
+  RE2(const StringPiece& pattern);
+  RE2(const StringPiece& pattern, const Options& options);
+  ~RE2();
+
+  // Returns whether RE2 was created properly.
+  bool ok() const { return error_code() == NoError; }
+
+  // The string specification for this RE2.  E.g.
+  //   RE2 re("ab*c?d+");
+  //   re.pattern();    // "ab*c?d+"
+  const std::string& pattern() const { return pattern_; }
+
+  // If RE2 could not be created properly, returns an error string.
+  // Else returns the empty string.
+  const std::string& error() const { return *error_; }
+
+  // If RE2 could not be created properly, returns an error code.
+  // Else returns RE2::NoError (== 0).
+  ErrorCode error_code() const { return error_code_; }
+
+  // If RE2 could not be created properly, returns the offending
+  // portion of the regexp.
+  const std::string& error_arg() const { return error_arg_; }
+
+  // Returns the program size, a very approximate measure of a regexp's "cost".
+  // Larger numbers are more expensive than smaller numbers.
+  int ProgramSize() const;
+  int ReverseProgramSize() const;
+
+  // If histogram is not null, outputs the program fanout
+  // as a histogram bucketed by powers of 2.
+  // Returns the number of the largest non-empty bucket.
+  int ProgramFanout(std::vector<int>* histogram) const;
+  int ReverseProgramFanout(std::vector<int>* histogram) const;
+
+  // Returns the underlying Regexp; not for general use.
+  // Returns entire_regexp_ so that callers don't need
+  // to know about prefix_ and prefix_foldcase_.
+  re2::Regexp* Regexp() const { return entire_regexp_; }
+
+  /***** The array-based matching interface ******/
+
+  // The functions here have names ending in 'N' and are used to implement
+  // the functions whose names are the prefix before the 'N'. It is sometimes
+  // useful to invoke them directly, but the syntax is awkward, so the 'N'-less
+  // versions should be preferred.
+  static bool FullMatchN(const StringPiece& text, const RE2& re,
+                         const Arg* const args[], int n);
+  static bool PartialMatchN(const StringPiece& text, const RE2& re,
+                            const Arg* const args[], int n);
+  static bool ConsumeN(StringPiece* input, const RE2& re,
+                       const Arg* const args[], int n);
+  static bool FindAndConsumeN(StringPiece* input, const RE2& re,
+                              const Arg* const args[], int n);
+
+#ifndef SWIG
+ private:
+  template <typename F, typename SP>
+  static inline bool Apply(F f, SP sp, const RE2& re) {
+    return f(sp, re, NULL, 0);
+  }
+
+  template <typename F, typename SP, typename... A>
+  static inline bool Apply(F f, SP sp, const RE2& re, const A&... a) {
+    const Arg* const args[] = {&a...};
+    const int n = sizeof...(a);
+    return f(sp, re, args, n);
+  }
+
+ public:
+  // In order to allow FullMatch() et al. to be called with a varying number
+  // of arguments of varying types, we use two layers of variadic templates.
+  // The first layer constructs the temporary Arg objects. The second layer
+  // (above) constructs the array of pointers to the temporary Arg objects.
+
+  /***** The useful part: the matching interface *****/
+
+  // Matches "text" against "re".  If pointer arguments are
+  // supplied, copies matched sub-patterns into them.
+  //
+  // You can pass in a "const char*" or a "std::string" for "text".
+  // You can pass in a "const char*" or a "std::string" or a "RE2" for "re".
+  //
+  // The provided pointer arguments can be pointers to any scalar numeric
+  // type, or one of:
+  //    std::string     (matched piece is copied to string)
+  //    StringPiece     (StringPiece is mutated to point to matched piece)
+  //    T               (where "bool T::ParseFrom(const char*, size_t)" exists)
+  //    (void*)NULL     (the corresponding matched sub-pattern is not copied)
+  //
+  // Returns true iff all of the following conditions are satisfied:
+  //   a. "text" matches "re" fully - from the beginning to the end of "text".
+  //   b. The number of matched sub-patterns is >= number of supplied pointers.
+  //   c. The "i"th argument has a suitable type for holding the
+  //      string captured as the "i"th sub-pattern.  If you pass in
+  //      NULL for the "i"th argument, or pass fewer arguments than
+  //      number of sub-patterns, the "i"th captured sub-pattern is
+  //      ignored.
+  //
+  // CAVEAT: An optional sub-pattern that does not exist in the
+  // matched string is assigned the empty string.  Therefore, the
+  // following will return false (because the empty string is not a
+  // valid number):
+  //    int number;
+  //    RE2::FullMatch("abc", "[a-z]+(\\d+)?", &number);
+  template <typename... A>
+  static bool FullMatch(const StringPiece& text, const RE2& re, A&&... a) {
+    return Apply(FullMatchN, text, re, Arg(std::forward<A>(a))...);
+  }
+
+  // Like FullMatch(), except that "re" is allowed to match a substring
+  // of "text".
+  //
+  // Returns true iff all of the following conditions are satisfied:
+  //   a. "text" matches "re" partially - for some substring of "text".
+  //   b. The number of matched sub-patterns is >= number of supplied pointers.
+  //   c. The "i"th argument has a suitable type for holding the
+  //      string captured as the "i"th sub-pattern.  If you pass in
+  //      NULL for the "i"th argument, or pass fewer arguments than
+  //      number of sub-patterns, the "i"th captured sub-pattern is
+  //      ignored.
+  template <typename... A>
+  static bool PartialMatch(const StringPiece& text, const RE2& re, A&&... a) {
+    return Apply(PartialMatchN, text, re, Arg(std::forward<A>(a))...);
+  }
+
+  // Like FullMatch() and PartialMatch(), except that "re" has to match
+  // a prefix of the text, and "input" is advanced past the matched
+  // text.  Note: "input" is modified iff this routine returns true
+  // and "re" matched a non-empty substring of "input".
+  //
+  // Returns true iff all of the following conditions are satisfied:
+  //   a. "input" matches "re" partially - for some prefix of "input".
+  //   b. The number of matched sub-patterns is >= number of supplied pointers.
+  //   c. The "i"th argument has a suitable type for holding the
+  //      string captured as the "i"th sub-pattern.  If you pass in
+  //      NULL for the "i"th argument, or pass fewer arguments than
+  //      number of sub-patterns, the "i"th captured sub-pattern is
+  //      ignored.
+  template <typename... A>
+  static bool Consume(StringPiece* input, const RE2& re, A&&... a) {
+    return Apply(ConsumeN, input, re, Arg(std::forward<A>(a))...);
+  }
+
+  // Like Consume(), but does not anchor the match at the beginning of
+  // the text.  That is, "re" need not start its match at the beginning
+  // of "input".  For example, "FindAndConsume(s, "(\\w+)", &word)" finds
+  // the next word in "s" and stores it in "word".
+  //
+  // Returns true iff all of the following conditions are satisfied:
+  //   a. "input" matches "re" partially - for some substring of "input".
+  //   b. The number of matched sub-patterns is >= number of supplied pointers.
+  //   c. The "i"th argument has a suitable type for holding the
+  //      string captured as the "i"th sub-pattern.  If you pass in
+  //      NULL for the "i"th argument, or pass fewer arguments than
+  //      number of sub-patterns, the "i"th captured sub-pattern is
+  //      ignored.
+  template <typename... A>
+  static bool FindAndConsume(StringPiece* input, const RE2& re, A&&... a) {
+    return Apply(FindAndConsumeN, input, re, Arg(std::forward<A>(a))...);
+  }
+#endif
+
+  // Replace the first match of "re" in "str" with "rewrite".
+  // Within "rewrite", backslash-escaped digits (\1 to \9) can be
+  // used to insert text matching corresponding parenthesized group
+  // from the pattern.  \0 in "rewrite" refers to the entire matching
+  // text.  E.g.,
+  //
+  //   std::string s = "yabba dabba doo";
+  //   CHECK(RE2::Replace(&s, "b+", "d"));
+  //
+  // will leave "s" containing "yada dabba doo"
+  //
+  // Returns true if the pattern matches and a replacement occurs,
+  // false otherwise.
+  static bool Replace(std::string* str,
+                      const RE2& re,
+                      const StringPiece& rewrite);
+
+  // Like Replace(), except replaces successive non-overlapping occurrences
+  // of the pattern in the string with the rewrite. E.g.
+  //
+  //   std::string s = "yabba dabba doo";
+  //   CHECK(RE2::GlobalReplace(&s, "b+", "d"));
+  //
+  // will leave "s" containing "yada dada doo"
+  // Replacements are not subject to re-matching.
+  //
+  // Because GlobalReplace only replaces non-overlapping matches,
+  // replacing "ana" within "banana" makes only one replacement, not two.
+  //
+  // Returns the number of replacements made.
+  static int GlobalReplace(std::string* str,
+                           const RE2& re,
+                           const StringPiece& rewrite);
+
+  // Like Replace, except that if the pattern matches, "rewrite"
+  // is copied into "out" with substitutions.  The non-matching
+  // portions of "text" are ignored.
+  //
+  // Returns true iff a match occurred and the extraction happened
+  // successfully;  if no match occurs, the string is left unaffected.
+  //
+  // REQUIRES: "text" must not alias any part of "*out".
+  static bool Extract(const StringPiece& text,
+                      const RE2& re,
+                      const StringPiece& rewrite,
+                      std::string* out);
+
+  // Escapes all potentially meaningful regexp characters in
+  // 'unquoted'.  The returned string, used as a regular expression,
+  // will match exactly the original string.  For example,
+  //           1.5-2.0?
+  // may become:
+  //           1\.5\-2\.0\?
+  static std::string QuoteMeta(const StringPiece& unquoted);
+
+  // Computes range for any strings matching regexp. The min and max can in
+  // some cases be arbitrarily precise, so the caller gets to specify the
+  // maximum desired length of string returned.
+  //
+  // Assuming PossibleMatchRange(&min, &max, N) returns successfully, any
+  // string s that is an anchored match for this regexp satisfies
+  //   min <= s && s <= max.
+  //
+  // Note that PossibleMatchRange() will only consider the first copy of an
+  // infinitely repeated element (i.e., any regexp element followed by a '*' or
+  // '+' operator). Regexps with "{N}" constructions are not affected, as those
+  // do not compile down to infinite repetitions.
+  //
+  // Returns true on success, false on error.
+  bool PossibleMatchRange(std::string* min, std::string* max,
+                          int maxlen) const;
+
+  // Generic matching interface
+
+  // Type of match.
+  enum Anchor {
+    UNANCHORED,         // No anchoring
+    ANCHOR_START,       // Anchor at start only
+    ANCHOR_BOTH         // Anchor at start and end
+  };
+
+  // Return the number of capturing subpatterns, or -1 if the
+  // regexp wasn't valid on construction.  The overall match ($0)
+  // does not count: if the regexp is "(a)(b)", returns 2.
+  int NumberOfCapturingGroups() const { return num_captures_; }
+
+  // Return a map from names to capturing indices.
+  // The map records the index of the leftmost group
+  // with the given name.
+  // Only valid until the re is deleted.
+  const std::map<std::string, int>& NamedCapturingGroups() const;
+
+  // Return a map from capturing indices to names.
+  // The map has no entries for unnamed groups.
+  // Only valid until the re is deleted.
+  const std::map<int, std::string>& CapturingGroupNames() const;
+
+  // General matching routine.
+  // Match against text starting at offset startpos
+  // and stopping the search at offset endpos.
+  // Returns true if match found, false if not.
+  // On a successful match, fills in submatch[] (up to nsubmatch entries)
+  // with information about submatches.
+  // I.e. matching RE2("(foo)|(bar)baz") on "barbazbla" will return true, with
+  // submatch[0] = "barbaz", submatch[1].data() = NULL, submatch[2] = "bar",
+  // submatch[3].data() = NULL, ..., up to submatch[nsubmatch-1].data() = NULL.
+  // Caveat: submatch[] may be clobbered even on match failure.
+  //
+  // Don't ask for more match information than you will use:
+  // runs much faster with nsubmatch == 1 than nsubmatch > 1, and
+  // runs even faster if nsubmatch == 0.
+  // Doesn't make sense to use nsubmatch > 1 + NumberOfCapturingGroups(),
+  // but will be handled correctly.
+  //
+  // Passing text == StringPiece(NULL, 0) will be handled like any other
+  // empty string, but note that on return, it will not be possible to tell
+  // whether submatch i matched the empty string or did not match:
+  // either way, submatch[i].data() == NULL.
+  bool Match(const StringPiece& text,
+             size_t startpos,
+             size_t endpos,
+             Anchor re_anchor,
+             StringPiece* submatch,
+             int nsubmatch) const;
+
+  // Check that the given rewrite string is suitable for use with this
+  // regular expression.  It checks that:
+  //   * The regular expression has enough parenthesized subexpressions
+  //     to satisfy all of the \N tokens in rewrite
+  //   * The rewrite string doesn't have any syntax errors.  E.g.,
+  //     '\' followed by anything other than a digit or '\'.
+  // A true return value guarantees that Replace() and Extract() won't
+  // fail because of a bad rewrite string.
+  bool CheckRewriteString(const StringPiece& rewrite,
+                          std::string* error) const;
+
+  // Returns the maximum submatch needed for the rewrite to be done by
+  // Replace(). E.g. if rewrite == "foo \\2,\\1", returns 2.
+  static int MaxSubmatch(const StringPiece& rewrite);
+
+  // Append the "rewrite" string, with backslash subsitutions from "vec",
+  // to string "out".
+  // Returns true on success.  This method can fail because of a malformed
+  // rewrite string.  CheckRewriteString guarantees that the rewrite will
+  // be sucessful.
+  bool Rewrite(std::string* out,
+               const StringPiece& rewrite,
+               const StringPiece* vec,
+               int veclen) const;
+
+  // Constructor options
+  class Options {
+   public:
+    // The options are (defaults in parentheses):
+    //
+    //   utf8             (true)  text and pattern are UTF-8; otherwise Latin-1
+    //   posix_syntax     (false) restrict regexps to POSIX egrep syntax
+    //   longest_match    (false) search for longest match, not first match
+    //   log_errors       (true)  log syntax and execution errors to ERROR
+    //   max_mem          (see below)  approx. max memory footprint of RE2
+    //   literal          (false) interpret string as literal, not regexp
+    //   never_nl         (false) never match \n, even if it is in regexp
+    //   dot_nl           (false) dot matches everything including new line
+    //   never_capture    (false) parse all parens as non-capturing
+    //   case_sensitive   (true)  match is case-sensitive (regexp can override
+    //                              with (?i) unless in posix_syntax mode)
+    //
+    // The following options are only consulted when posix_syntax == true.
+    // When posix_syntax == false, these features are always enabled and
+    // cannot be turned off; to perform multi-line matching in that case,
+    // begin the regexp with (?m).
+    //   perl_classes     (false) allow Perl's \d \s \w \D \S \W
+    //   word_boundary    (false) allow Perl's \b \B (word boundary and not)
+    //   one_line         (false) ^ and $ only match beginning and end of text
+    //
+    // The max_mem option controls how much memory can be used
+    // to hold the compiled form of the regexp (the Prog) and
+    // its cached DFA graphs.  Code Search placed limits on the number
+    // of Prog instructions and DFA states: 10,000 for both.
+    // In RE2, those limits would translate to about 240 KB per Prog
+    // and perhaps 2.5 MB per DFA (DFA state sizes vary by regexp; RE2 does a
+    // better job of keeping them small than Code Search did).
+    // Each RE2 has two Progs (one forward, one reverse), and each Prog
+    // can have two DFAs (one first match, one longest match).
+    // That makes 4 DFAs:
+    //
+    //   forward, first-match    - used for UNANCHORED or ANCHOR_START searches
+    //                               if opt.longest_match() == false
+    //   forward, longest-match  - used for all ANCHOR_BOTH searches,
+    //                               and the other two kinds if
+    //                               opt.longest_match() == true
+    //   reverse, first-match    - never used
+    //   reverse, longest-match  - used as second phase for unanchored searches
+    //
+    // The RE2 memory budget is statically divided between the two
+    // Progs and then the DFAs: two thirds to the forward Prog
+    // and one third to the reverse Prog.  The forward Prog gives half
+    // of what it has left over to each of its DFAs.  The reverse Prog
+    // gives it all to its longest-match DFA.
+    //
+    // Once a DFA fills its budget, it flushes its cache and starts over.
+    // If this happens too often, RE2 falls back on the NFA implementation.
+
+    // For now, make the default budget something close to Code Search.
+    static const int kDefaultMaxMem = 8<<20;
+
+    enum Encoding {
+      EncodingUTF8 = 1,
+      EncodingLatin1
+    };
+
+    Options() :
+      encoding_(EncodingUTF8),
+      posix_syntax_(false),
+      longest_match_(false),
+      log_errors_(true),
+      max_mem_(kDefaultMaxMem),
+      literal_(false),
+      never_nl_(false),
+      dot_nl_(false),
+      never_capture_(false),
+      case_sensitive_(true),
+      perl_classes_(false),
+      word_boundary_(false),
+      one_line_(false) {
+    }
+
+    /*implicit*/ Options(CannedOptions);
+
+    Encoding encoding() const { return encoding_; }
+    void set_encoding(Encoding encoding) { encoding_ = encoding; }
+
+    bool posix_syntax() const { return posix_syntax_; }
+    void set_posix_syntax(bool b) { posix_syntax_ = b; }
+
+    bool longest_match() const { return longest_match_; }
+    void set_longest_match(bool b) { longest_match_ = b; }
+
+    bool log_errors() const { return log_errors_; }
+    void set_log_errors(bool b) { log_errors_ = b; }
+
+    int64_t max_mem() const { return max_mem_; }
+    void set_max_mem(int64_t m) { max_mem_ = m; }
+
+    bool literal() const { return literal_; }
+    void set_literal(bool b) { literal_ = b; }
+
+    bool never_nl() const { return never_nl_; }
+    void set_never_nl(bool b) { never_nl_ = b; }
+
+    bool dot_nl() const { return dot_nl_; }
+    void set_dot_nl(bool b) { dot_nl_ = b; }
+
+    bool never_capture() const { return never_capture_; }
+    void set_never_capture(bool b) { never_capture_ = b; }
+
+    bool case_sensitive() const { return case_sensitive_; }
+    void set_case_sensitive(bool b) { case_sensitive_ = b; }
+
+    bool perl_classes() const { return perl_classes_; }
+    void set_perl_classes(bool b) { perl_classes_ = b; }
+
+    bool word_boundary() const { return word_boundary_; }
+    void set_word_boundary(bool b) { word_boundary_ = b; }
+
+    bool one_line() const { return one_line_; }
+    void set_one_line(bool b) { one_line_ = b; }
+
+    void Copy(const Options& src) {
+      *this = src;
+    }
+
+    int ParseFlags() const;
+
+   private:
+    Encoding encoding_;
+    bool posix_syntax_;
+    bool longest_match_;
+    bool log_errors_;
+    int64_t max_mem_;
+    bool literal_;
+    bool never_nl_;
+    bool dot_nl_;
+    bool never_capture_;
+    bool case_sensitive_;
+    bool perl_classes_;
+    bool word_boundary_;
+    bool one_line_;
+  };
+
+  // Returns the options set in the constructor.
+  const Options& options() const { return options_; }
+
+  // Argument converters; see below.
+  template <typename T>
+  static Arg CRadix(T* ptr);
+  template <typename T>
+  static Arg Hex(T* ptr);
+  template <typename T>
+  static Arg Octal(T* ptr);
+
+ private:
+  void Init(const StringPiece& pattern, const Options& options);
+
+  bool DoMatch(const StringPiece& text,
+               Anchor re_anchor,
+               size_t* consumed,
+               const Arg* const args[],
+               int n) const;
+
+  re2::Prog* ReverseProg() const;
+
+  std::string pattern_;         // string regular expression
+  Options options_;             // option flags
+  re2::Regexp* entire_regexp_;  // parsed regular expression
+  const std::string* error_;    // error indicator (or points to empty string)
+  ErrorCode error_code_;        // error code
+  std::string error_arg_;       // fragment of regexp showing error
+  std::string prefix_;          // required prefix (before suffix_regexp_)
+  bool prefix_foldcase_;        // prefix_ is ASCII case-insensitive
+  re2::Regexp* suffix_regexp_;  // parsed regular expression, prefix_ removed
+  re2::Prog* prog_;             // compiled program for regexp
+  int num_captures_;            // number of capturing groups
+  bool is_one_pass_;            // can use prog_->SearchOnePass?
+
+  // Reverse Prog for DFA execution only
+  mutable re2::Prog* rprog_;
+  // Map from capture names to indices
+  mutable const std::map<std::string, int>* named_groups_;
+  // Map from capture indices to names
+  mutable const std::map<int, std::string>* group_names_;
+
+  mutable std::once_flag rprog_once_;
+  mutable std::once_flag named_groups_once_;
+  mutable std::once_flag group_names_once_;
+
+  RE2(const RE2&) = delete;
+  RE2& operator=(const RE2&) = delete;
+};
+
+/***** Implementation details *****/
+
+namespace re2_internal {
+
+// Types for which the 3-ary Parse() function template has specializations.
+template <typename T> struct Parse3ary : public std::false_type {};
+template <> struct Parse3ary<void> : public std::true_type {};
+template <> struct Parse3ary<std::string> : public std::true_type {};
+template <> struct Parse3ary<StringPiece> : public std::true_type {};
+template <> struct Parse3ary<char> : public std::true_type {};
+template <> struct Parse3ary<signed char> : public std::true_type {};
+template <> struct Parse3ary<unsigned char> : public std::true_type {};
+template <> struct Parse3ary<float> : public std::true_type {};
+template <> struct Parse3ary<double> : public std::true_type {};
+
+template <typename T>
+bool Parse(const char* str, size_t n, T* dest);
+
+// Types for which the 4-ary Parse() function template has specializations.
+template <typename T> struct Parse4ary : public std::false_type {};
+template <> struct Parse4ary<long> : public std::true_type {};
+template <> struct Parse4ary<unsigned long> : public std::true_type {};
+template <> struct Parse4ary<short> : public std::true_type {};
+template <> struct Parse4ary<unsigned short> : public std::true_type {};
+template <> struct Parse4ary<int> : public std::true_type {};
+template <> struct Parse4ary<unsigned int> : public std::true_type {};
+template <> struct Parse4ary<long long> : public std::true_type {};
+template <> struct Parse4ary<unsigned long long> : public std::true_type {};
+
+template <typename T>
+bool Parse(const char* str, size_t n, T* dest, int radix);
+
+}  // namespace re2_internal
+
+class RE2::Arg {
+ private:
+  template <typename T>
+  using CanParse3ary = typename std::enable_if<
+      re2_internal::Parse3ary<T>::value,
+      int>::type;
+
+  template <typename T>
+  using CanParse4ary = typename std::enable_if<
+      re2_internal::Parse4ary<T>::value,
+      int>::type;
+
+#if !defined(_MSC_VER)
+  template <typename T>
+  using CanParseFrom = typename std::enable_if<
+      std::is_member_function_pointer<
+          decltype(static_cast<bool (T::*)(const char*, size_t)>(
+              &T::ParseFrom))>::value,
+      int>::type;
+#endif
+
+ public:
+  Arg() : Arg(nullptr) {}
+  Arg(std::nullptr_t ptr) : arg_(ptr), parser_(DoNothing) {}
+
+  template <typename T, CanParse3ary<T> = 0>
+  Arg(T* ptr) : arg_(ptr), parser_(DoParse3ary<T>) {}
+
+  template <typename T, CanParse4ary<T> = 0>
+  Arg(T* ptr) : arg_(ptr), parser_(DoParse4ary<T>) {}
+
+#if !defined(_MSC_VER)
+  template <typename T, CanParseFrom<T> = 0>
+  Arg(T* ptr) : arg_(ptr), parser_(DoParseFrom<T>) {}
+#endif
+
+  typedef bool (*Parser)(const char* str, size_t n, void* dest);
+
+  template <typename T>
+  Arg(T* ptr, Parser parser) : arg_(ptr), parser_(parser) {}
+
+  bool Parse(const char* str, size_t n) const {
+    return (*parser_)(str, n, arg_);
+  }
+
+ private:
+  static bool DoNothing(const char* /*str*/, size_t /*n*/, void* /*dest*/) {
+    return true;
+  }
+
+  template <typename T>
+  static bool DoParse3ary(const char* str, size_t n, void* dest) {
+    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest));
+  }
+
+  template <typename T>
+  static bool DoParse4ary(const char* str, size_t n, void* dest) {
+    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 10);
+  }
+
+#if !defined(_MSC_VER)
+  template <typename T>
+  static bool DoParseFrom(const char* str, size_t n, void* dest) {
+    if (dest == NULL) return true;
+    return reinterpret_cast<T*>(dest)->ParseFrom(str, n);
+  }
+#endif
+
+  void*         arg_;
+  Parser        parser_;
+};
+
+template <typename T>
+inline RE2::Arg RE2::CRadix(T* ptr) {
+  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
+    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 0);
+  });
+}
+
+template <typename T>
+inline RE2::Arg RE2::Hex(T* ptr) {
+  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
+    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 16);
+  });
+}
+
+template <typename T>
+inline RE2::Arg RE2::Octal(T* ptr) {
+  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
+    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 8);
+  });
+}
+
+#ifndef SWIG
+// Silence warnings about missing initializers for members of LazyRE2.
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 6
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+// Helper for writing global or static RE2s safely.
+// Write
+//     static LazyRE2 re = {".*"};
+// and then use *re instead of writing
+//     static RE2 re(".*");
+// The former is more careful about multithreaded
+// situations than the latter.
+//
+// N.B. This class never deletes the RE2 object that
+// it constructs: that's a feature, so that it can be used
+// for global and function static variables.
+class LazyRE2 {
+ private:
+  struct NoArg {};
+
+ public:
+  typedef RE2 element_type;  // support std::pointer_traits
+
+  // Constructor omitted to preserve braced initialization in C++98.
+
+  // Pretend to be a pointer to Type (never NULL due to on-demand creation):
+  RE2& operator*() const { return *get(); }
+  RE2* operator->() const { return get(); }
+
+  // Named accessor/initializer:
+  RE2* get() const {
+    std::call_once(once_, &LazyRE2::Init, this);
+    return ptr_;
+  }
+
+  // All data fields must be public to support {"foo"} initialization.
+  const char* pattern_;
+  RE2::CannedOptions options_;
+  NoArg barrier_against_excess_initializers_;
+
+  mutable RE2* ptr_;
+  mutable std::once_flag once_;
+
+ private:
+  static void Init(const LazyRE2* lazy_re2) {
+    lazy_re2->ptr_ = new RE2(lazy_re2->pattern_, lazy_re2->options_);
+  }
+
+  void operator=(const LazyRE2&);  // disallowed
+};
+#endif
+
+namespace hooks {
+
+// Most platforms support thread_local. Older versions of iOS don't support
+// thread_local, but for the sake of brevity, we lump together all versions
+// of Apple platforms that aren't macOS. If an iOS application really needs
+// the context pointee someday, we can get more specific then...
+//
+// As per https://github.com/google/re2/issues/325, thread_local support in
+// MinGW seems to be buggy. (FWIW, Abseil folks also avoid it.)
+#define RE2_HAVE_THREAD_LOCAL
+#if (defined(__APPLE__) && !TARGET_OS_OSX) || defined(__MINGW32__)
+#undef RE2_HAVE_THREAD_LOCAL
+#endif
+
+// A hook must not make any assumptions regarding the lifetime of the context
+// pointee beyond the current invocation of the hook. Pointers and references
+// obtained via the context pointee should be considered invalidated when the
+// hook returns. Hence, any data about the context pointee (e.g. its pattern)
+// would have to be copied in order for it to be kept for an indefinite time.
+//
+// A hook must not use RE2 for matching. Control flow reentering RE2::Match()
+// could result in infinite mutual recursion. To discourage that possibility,
+// RE2 will not maintain the context pointer correctly when used in that way.
+#ifdef RE2_HAVE_THREAD_LOCAL
+extern thread_local const RE2* context;
+#endif
+
+struct DFAStateCacheReset {
+  int64_t state_budget;
+  size_t state_cache_size;
+};
+
+struct DFASearchFailure {
+  // Nothing yet...
+};
+
+#define DECLARE_HOOK(type)                  \
+  using type##Callback = void(const type&); \
+  void Set##type##Hook(type##Callback* cb); \
+  type##Callback* Get##type##Hook();
+
+DECLARE_HOOK(DFAStateCacheReset)
+DECLARE_HOOK(DFASearchFailure)
+
+#undef DECLARE_HOOK
+
+}  // namespace hooks
+
+}  // namespace re2
+
+using re2::RE2;
+using re2::LazyRE2;
+
+#endif  // RE2_RE2_H_
diff --git a/CAPI/cpp/grpc/include/re2/set.h b/CAPI/cpp/grpc/include/re2/set.h
new file mode 100644
index 0000000..8d64f30
--- /dev/null
+++ b/CAPI/cpp/grpc/include/re2/set.h
@@ -0,0 +1,85 @@
+// Copyright 2010 The RE2 Authors.  All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef RE2_SET_H_
+#define RE2_SET_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "re2/re2.h"
+
+namespace re2 {
+class Prog;
+class Regexp;
+}  // namespace re2
+
+namespace re2 {
+
+// An RE2::Set represents a collection of regexps that can
+// be searched for simultaneously.
+class RE2::Set {
+ public:
+  enum ErrorKind {
+    kNoError = 0,
+    kNotCompiled,   // The set is not compiled.
+    kOutOfMemory,   // The DFA ran out of memory.
+    kInconsistent,  // The result is inconsistent. This should never happen.
+  };
+
+  struct ErrorInfo {
+    ErrorKind kind;
+  };
+
+  Set(const RE2::Options& options, RE2::Anchor anchor);
+  ~Set();
+
+  // Not copyable.
+  Set(const Set&) = delete;
+  Set& operator=(const Set&) = delete;
+  // Movable.
+  Set(Set&& other);
+  Set& operator=(Set&& other);
+
+  // Adds pattern to the set using the options passed to the constructor.
+  // Returns the index that will identify the regexp in the output of Match(),
+  // or -1 if the regexp cannot be parsed.
+  // Indices are assigned in sequential order starting from 0.
+  // Errors do not increment the index; if error is not NULL, *error will hold
+  // the error message from the parser.
+  int Add(const StringPiece& pattern, std::string* error);
+
+  // Compiles the set in preparation for matching.
+  // Returns false if the compiler runs out of memory.
+  // Add() must not be called again after Compile().
+  // Compile() must be called before Match().
+  bool Compile();
+
+  // Returns true if text matches at least one of the regexps in the set.
+  // Fills v (if not NULL) with the indices of the matching regexps.
+  // Callers must not expect v to be sorted.
+  bool Match(const StringPiece& text, std::vector<int>* v) const;
+
+  // As above, but populates error_info (if not NULL) when none of the regexps
+  // in the set matched. This can inform callers when DFA execution fails, for
+  // example, because they might wish to handle that case differently.
+  bool Match(const StringPiece& text, std::vector<int>* v,
+             ErrorInfo* error_info) const;
+
+ private:
+  typedef std::pair<std::string, re2::Regexp*> Elem;
+
+  RE2::Options options_;
+  RE2::Anchor anchor_;
+  std::vector<Elem> elem_;
+  bool compiled_;
+  int size_;
+  std::unique_ptr<re2::Prog> prog_;
+};
+
+}  // namespace re2
+
+#endif  // RE2_SET_H_
diff --git a/CAPI/cpp/grpc/include/re2/stringpiece.h b/CAPI/cpp/grpc/include/re2/stringpiece.h
new file mode 100644
index 0000000..1d9c2d3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/re2/stringpiece.h
@@ -0,0 +1,210 @@
+// Copyright 2001-2010 The RE2 Authors.  All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef RE2_STRINGPIECE_H_
+#define RE2_STRINGPIECE_H_
+
+// A string-like object that points to a sized piece of memory.
+//
+// Functions or methods may use const StringPiece& parameters to accept either
+// a "const char*" or a "string" value that will be implicitly converted to
+// a StringPiece.  The implicit conversion means that it is often appropriate
+// to include this .h file in other files rather than forward-declaring
+// StringPiece as would be appropriate for most other Google classes.
+//
+// Systematic usage of StringPiece is encouraged as it will reduce unnecessary
+// conversions from "const char*" to "string" and back again.
+//
+//
+// Arghh!  I wish C++ literals were "string".
+
+// Doing this simplifies the logic below.
+#ifndef __has_include
+#define __has_include(x) 0
+#endif
+
+#include <stddef.h>
+#include <string.h>
+#include <algorithm>
+#include <iosfwd>
+#include <iterator>
+#include <string>
+#if __has_include(<string_view>) && __cplusplus >= 201703L
+#include <string_view>
+#endif
+
+namespace re2 {
+
+class StringPiece {
+ public:
+  typedef std::char_traits<char> traits_type;
+  typedef char value_type;
+  typedef char* pointer;
+  typedef const char* const_pointer;
+  typedef char& reference;
+  typedef const char& const_reference;
+  typedef const char* const_iterator;
+  typedef const_iterator iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef const_reverse_iterator reverse_iterator;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  static const size_type npos = static_cast<size_type>(-1);
+
+  // We provide non-explicit singleton constructors so users can pass
+  // in a "const char*" or a "string" wherever a "StringPiece" is
+  // expected.
+  StringPiece()
+      : data_(NULL), size_(0) {}
+#if __has_include(<string_view>) && __cplusplus >= 201703L
+  StringPiece(const std::string_view& str)
+      : data_(str.data()), size_(str.size()) {}
+#endif
+  StringPiece(const std::string& str)
+      : data_(str.data()), size_(str.size()) {}
+  StringPiece(const char* str)
+      : data_(str), size_(str == NULL ? 0 : strlen(str)) {}
+  StringPiece(const char* str, size_type len)
+      : data_(str), size_(len) {}
+
+  const_iterator begin() const { return data_; }
+  const_iterator end() const { return data_ + size_; }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(data_ + size_);
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(data_);
+  }
+
+  size_type size() const { return size_; }
+  size_type length() const { return size_; }
+  bool empty() const { return size_ == 0; }
+
+  const_reference operator[](size_type i) const { return data_[i]; }
+  const_pointer data() const { return data_; }
+
+  void remove_prefix(size_type n) {
+    data_ += n;
+    size_ -= n;
+  }
+
+  void remove_suffix(size_type n) {
+    size_ -= n;
+  }
+
+  void set(const char* str) {
+    data_ = str;
+    size_ = str == NULL ? 0 : strlen(str);
+  }
+
+  void set(const char* str, size_type len) {
+    data_ = str;
+    size_ = len;
+  }
+
+  // Converts to `std::basic_string`.
+  template <typename A>
+  explicit operator std::basic_string<char, traits_type, A>() const {
+    if (!data_) return {};
+    return std::basic_string<char, traits_type, A>(data_, size_);
+  }
+
+  std::string as_string() const {
+    return std::string(data_, size_);
+  }
+
+  // We also define ToString() here, since many other string-like
+  // interfaces name the routine that converts to a C++ string
+  // "ToString", and it's confusing to have the method that does that
+  // for a StringPiece be called "as_string()".  We also leave the
+  // "as_string()" method defined here for existing code.
+  std::string ToString() const {
+    return std::string(data_, size_);
+  }
+
+  void CopyToString(std::string* target) const {
+    target->assign(data_, size_);
+  }
+
+  void AppendToString(std::string* target) const {
+    target->append(data_, size_);
+  }
+
+  size_type copy(char* buf, size_type n, size_type pos = 0) const;
+  StringPiece substr(size_type pos = 0, size_type n = npos) const;
+
+  int compare(const StringPiece& x) const {
+    size_type min_size = std::min(size(), x.size());
+    if (min_size > 0) {
+      int r = memcmp(data(), x.data(), min_size);
+      if (r < 0) return -1;
+      if (r > 0) return 1;
+    }
+    if (size() < x.size()) return -1;
+    if (size() > x.size()) return 1;
+    return 0;
+  }
+
+  // Does "this" start with "x"?
+  bool starts_with(const StringPiece& x) const {
+    return x.empty() ||
+           (size() >= x.size() && memcmp(data(), x.data(), x.size()) == 0);
+  }
+
+  // Does "this" end with "x"?
+  bool ends_with(const StringPiece& x) const {
+    return x.empty() ||
+           (size() >= x.size() &&
+            memcmp(data() + (size() - x.size()), x.data(), x.size()) == 0);
+  }
+
+  bool contains(const StringPiece& s) const {
+    return find(s) != npos;
+  }
+
+  size_type find(const StringPiece& s, size_type pos = 0) const;
+  size_type find(char c, size_type pos = 0) const;
+  size_type rfind(const StringPiece& s, size_type pos = npos) const;
+  size_type rfind(char c, size_type pos = npos) const;
+
+ private:
+  const_pointer data_;
+  size_type size_;
+};
+
+inline bool operator==(const StringPiece& x, const StringPiece& y) {
+  StringPiece::size_type len = x.size();
+  if (len != y.size()) return false;
+  return x.data() == y.data() || len == 0 ||
+         memcmp(x.data(), y.data(), len) == 0;
+}
+
+inline bool operator!=(const StringPiece& x, const StringPiece& y) {
+  return !(x == y);
+}
+
+inline bool operator<(const StringPiece& x, const StringPiece& y) {
+  StringPiece::size_type min_size = std::min(x.size(), y.size());
+  int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
+  return (r < 0) || (r == 0 && x.size() < y.size());
+}
+
+inline bool operator>(const StringPiece& x, const StringPiece& y) {
+  return y < x;
+}
+
+inline bool operator<=(const StringPiece& x, const StringPiece& y) {
+  return !(x > y);
+}
+
+inline bool operator>=(const StringPiece& x, const StringPiece& y) {
+  return !(x < y);
+}
+
+// Allow StringPiece to be logged.
+std::ostream& operator<<(std::ostream& o, const StringPiece& p);
+
+}  // namespace re2
+
+#endif  // RE2_STRINGPIECE_H_
diff --git a/CAPI/cpp/grpc/include/upb/arena.h b/CAPI/cpp/grpc/include/upb/arena.h
new file mode 100644
index 0000000..0c4fd1b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/arena.h
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_ARENA_H_
+#define UPB_ARENA_H_
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** upb_alloc *****************************************************************/
+
+/* A upb_alloc is a possibly-stateful allocator object.
+ *
+ * It could either be an arena allocator (which doesn't require individual
+ * free() calls) or a regular malloc() (which does).  The client must therefore
+ * free memory unless it knows that the allocator is an arena allocator. */
+
+struct upb_alloc;
+typedef struct upb_alloc upb_alloc;
+
+/* A malloc()/free() function.
+ * If "size" is 0 then the function acts like free(), otherwise it acts like
+ * realloc().  Only "oldsize" bytes from a previous allocation are preserved. */
+typedef void* upb_alloc_func(upb_alloc* alloc, void* ptr, size_t oldsize,
+                             size_t size);
+
+struct upb_alloc {
+  upb_alloc_func* func;
+};
+
+UPB_INLINE void* upb_malloc(upb_alloc* alloc, size_t size) {
+  UPB_ASSERT(alloc);
+  return alloc->func(alloc, NULL, 0, size);
+}
+
+UPB_INLINE void* upb_realloc(upb_alloc* alloc, void* ptr, size_t oldsize,
+                             size_t size) {
+  UPB_ASSERT(alloc);
+  return alloc->func(alloc, ptr, oldsize, size);
+}
+
+UPB_INLINE void upb_free(upb_alloc* alloc, void* ptr) {
+  assert(alloc);
+  alloc->func(alloc, ptr, 0, 0);
+}
+
+/* The global allocator used by upb.  Uses the standard malloc()/free(). */
+
+extern upb_alloc upb_alloc_global;
+
+/* Functions that hard-code the global malloc.
+ *
+ * We still get benefit because we can put custom logic into our global
+ * allocator, like injecting out-of-memory faults in debug/testing builds. */
+
+UPB_INLINE void* upb_gmalloc(size_t size) {
+  return upb_malloc(&upb_alloc_global, size);
+}
+
+UPB_INLINE void* upb_grealloc(void* ptr, size_t oldsize, size_t size) {
+  return upb_realloc(&upb_alloc_global, ptr, oldsize, size);
+}
+
+UPB_INLINE void upb_gfree(void* ptr) { upb_free(&upb_alloc_global, ptr); }
+
+/* upb_Arena ******************************************************************/
+
+/* upb_Arena is a specific allocator implementation that uses arena allocation.
+ * The user provides an allocator that will be used to allocate the underlying
+ * arena blocks.  Arenas by nature do not require the individual allocations
+ * to be freed.  However the Arena does allow users to register cleanup
+ * functions that will run when the arena is destroyed.
+ *
+ * A upb_Arena is *not* thread-safe.
+ *
+ * You could write a thread-safe arena allocator that satisfies the
+ * upb_alloc interface, but it would not be as efficient for the
+ * single-threaded case. */
+
+typedef void upb_CleanupFunc(void* ud);
+
+struct upb_Arena;
+typedef struct upb_Arena upb_Arena;
+
+typedef struct {
+  /* We implement the allocator interface.
+   * This must be the first member of upb_Arena!
+   * TODO(haberman): remove once handlers are gone. */
+  upb_alloc alloc;
+
+  char *ptr, *end;
+} _upb_ArenaHead;
+
+/* Creates an arena from the given initial block (if any -- n may be 0).
+ * Additional blocks will be allocated from |alloc|.  If |alloc| is NULL, this
+ * is a fixed-size arena and cannot grow. */
+upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc);
+void upb_Arena_Free(upb_Arena* a);
+bool upb_Arena_AddCleanup(upb_Arena* a, void* ud, upb_CleanupFunc* func);
+bool upb_Arena_Fuse(upb_Arena* a, upb_Arena* b);
+void* _upb_Arena_SlowMalloc(upb_Arena* a, size_t size);
+
+UPB_INLINE upb_alloc* upb_Arena_Alloc(upb_Arena* a) { return (upb_alloc*)a; }
+
+UPB_INLINE size_t _upb_ArenaHas(upb_Arena* a) {
+  _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+  return (size_t)(h->end - h->ptr);
+}
+
+UPB_INLINE void* _upb_Arena_FastMalloc(upb_Arena* a, size_t size) {
+  _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+  void* ret = h->ptr;
+  UPB_ASSERT(UPB_ALIGN_MALLOC((uintptr_t)ret) == (uintptr_t)ret);
+  UPB_ASSERT(UPB_ALIGN_MALLOC(size) == size);
+  UPB_UNPOISON_MEMORY_REGION(ret, size);
+
+  h->ptr += size;
+
+#if UPB_ASAN
+  {
+    size_t guard_size = 32;
+    if (_upb_ArenaHas(a) >= guard_size) {
+      h->ptr += guard_size;
+    } else {
+      h->ptr = h->end;
+    }
+  }
+#endif
+
+  return ret;
+}
+
+UPB_INLINE void* upb_Arena_Malloc(upb_Arena* a, size_t size) {
+  size = UPB_ALIGN_MALLOC(size);
+
+  if (UPB_UNLIKELY(_upb_ArenaHas(a) < size)) {
+    return _upb_Arena_SlowMalloc(a, size);
+  }
+
+  return _upb_Arena_FastMalloc(a, size);
+}
+
+// Shrinks the last alloc from arena.
+// REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena.
+// We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if
+// this was not the last alloc.
+UPB_INLINE void upb_Arena_ShrinkLast(upb_Arena* a, void* ptr, size_t oldsize,
+                                     size_t size) {
+  _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+  oldsize = UPB_ALIGN_MALLOC(oldsize);
+  size = UPB_ALIGN_MALLOC(size);
+  UPB_ASSERT((char*)ptr + oldsize == h->ptr);  // Must be the last alloc.
+  UPB_ASSERT(size <= oldsize);
+  h->ptr = (char*)ptr + size;
+}
+
+UPB_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize,
+                                   size_t size) {
+  _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+  oldsize = UPB_ALIGN_MALLOC(oldsize);
+  size = UPB_ALIGN_MALLOC(size);
+  bool is_most_recent_alloc = (uintptr_t)ptr + oldsize == (uintptr_t)h->ptr;
+
+  if (is_most_recent_alloc) {
+    ptrdiff_t diff = size - oldsize;
+    if ((ptrdiff_t)_upb_ArenaHas(a) >= diff) {
+      h->ptr += diff;
+      return ptr;
+    }
+  } else if (size <= oldsize) {
+    return ptr;
+  }
+
+  void* ret = upb_Arena_Malloc(a, size);
+
+  if (ret && oldsize > 0) {
+    memcpy(ret, ptr, UPB_MIN(oldsize, size));
+  }
+
+  return ret;
+}
+
+UPB_INLINE upb_Arena* upb_Arena_New(void) {
+  return upb_Arena_Init(NULL, 0, &upb_alloc_global);
+}
+
+#include "upb/port_undef.inc"
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_ARENA_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/array.h b/CAPI/cpp/grpc/include/upb/array.h
new file mode 100644
index 0000000..0715d58
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/array.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_ARRAY_H_
+#define UPB_ARRAY_H_
+
+#include "google/protobuf/descriptor.upb.h"
+#include "upb/message_value.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Creates a new array on the given arena that holds elements of this type. */
+upb_Array* upb_Array_New(upb_Arena* a, upb_CType type);
+
+/* Returns the size of the array. */
+size_t upb_Array_Size(const upb_Array* arr);
+
+/* Returns the given element, which must be within the array's current size. */
+upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i);
+
+/* Sets the given element, which must be within the array's current size. */
+void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val);
+
+/* Appends an element to the array.  Returns false on allocation failure. */
+bool upb_Array_Append(upb_Array* array, upb_MessageValue val, upb_Arena* arena);
+
+/* Moves elements within the array using memmove(). Like memmove(), the source
+ * and destination elements may be overlapping. */
+void upb_Array_Move(upb_Array* array, size_t dst_idx, size_t src_idx,
+                    size_t count);
+
+/* Inserts one or more empty elements into the array.  Existing elements are
+ * shifted right.  The new elements have undefined state and must be set with
+ * `upb_Array_Set()`.
+ * REQUIRES: `i <= upb_Array_Size(arr)` */
+bool upb_Array_Insert(upb_Array* array, size_t i, size_t count,
+                      upb_Arena* arena);
+
+/* Deletes one or more elements from the array.  Existing elements are shifted
+ * left.
+ * REQUIRES: `i + count <= upb_Array_Size(arr)` */
+void upb_Array_Delete(upb_Array* array, size_t i, size_t count);
+
+/* Changes the size of a vector.  New elements are initialized to empty/0.
+ * Returns false on allocation failure. */
+bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_ARRAY_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/bindings/lua/upb.h b/CAPI/cpp/grpc/include/upb/bindings/lua/upb.h
new file mode 100644
index 0000000..e0dc79e
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/bindings/lua/upb.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Shared definitions for upb Lua modules.
+ */
+
+#ifndef UPB_LUA_UPB_H_
+#define UPB_LUA_UPB_H_
+
+#include "lauxlib.h"
+#include "upb/def.h"
+#include "upb/msg.h"
+#include "upb/reflection.h"
+
+/* Lua changes its API in incompatible ways in every minor release.
+ * This is some shim code to paper over the differences. */
+
+#if LUA_VERSION_NUM == 501
+#define lua_rawlen lua_objlen
+#define lua_setuservalue(L, idx) lua_setfenv(L, idx)
+#define lua_getuservalue(L, idx) lua_getfenv(L, idx)
+#define lupb_setfuncs(L, l) luaL_register(L, NULL, l)
+#elif LUA_VERSION_NUM >= 502 && LUA_VERSION_NUM <= 504
+#define lupb_setfuncs(L, l) luaL_setfuncs(L, l, 0)
+#else
+#error Only Lua 5.1-5.4 are supported
+#endif
+
+/* Create a new userdata with the given type and |n| uservals, which are popped
+ * from the stack to initialize the userdata. */
+void* lupb_newuserdata(lua_State* L, size_t size, int n, const char* type);
+
+#if LUA_VERSION_NUM < 504
+/* Polyfills for this Lua 5.4 function.  Pushes userval |n| for the userdata at
+ * |index|. */
+int lua_setiuservalue(lua_State* L, int index, int n);
+int lua_getiuservalue(lua_State* L, int index, int n);
+#endif
+
+/* Registers a type with the given name, methods, and metamethods. */
+void lupb_register_type(lua_State* L, const char* name, const luaL_Reg* m,
+                        const luaL_Reg* mm);
+
+/* Checks the given upb_Status and throws a Lua error if it is not ok. */
+void lupb_checkstatus(lua_State* L, upb_Status* s);
+
+int luaopen_lupb(lua_State* L);
+
+/* C <-> Lua value conversions. ***********************************************/
+
+/* Custom check/push functions.  Unlike the Lua equivalents, they are pinned to
+ * specific C types (instead of lua_Number, etc), and do not allow any implicit
+ * conversion or data loss. */
+int64_t lupb_checkint64(lua_State* L, int narg);
+int32_t lupb_checkint32(lua_State* L, int narg);
+uint64_t lupb_checkuint64(lua_State* L, int narg);
+uint32_t lupb_checkuint32(lua_State* L, int narg);
+double lupb_checkdouble(lua_State* L, int narg);
+float lupb_checkfloat(lua_State* L, int narg);
+bool lupb_checkbool(lua_State* L, int narg);
+const char* lupb_checkstring(lua_State* L, int narg, size_t* len);
+const char* lupb_checkname(lua_State* L, int narg);
+
+void lupb_pushint64(lua_State* L, int64_t val);
+void lupb_pushint32(lua_State* L, int32_t val);
+void lupb_pushuint64(lua_State* L, uint64_t val);
+void lupb_pushuint32(lua_State* L, uint32_t val);
+
+/** From def.c. ***************************************************************/
+
+const upb_MessageDef* lupb_MessageDef_check(lua_State* L, int narg);
+const upb_EnumDef* lupb_EnumDef_check(lua_State* L, int narg);
+const upb_FieldDef* lupb_FieldDef_check(lua_State* L, int narg);
+upb_DefPool* lupb_DefPool_check(lua_State* L, int narg);
+void lupb_MessageDef_pushsubmsgdef(lua_State* L, const upb_FieldDef* f);
+
+void lupb_def_registertypes(lua_State* L);
+
+/** From msg.c. ***************************************************************/
+
+void lupb_pushmsgval(lua_State* L, int container, upb_CType type,
+                     upb_MessageValue val);
+int lupb_MessageDef_call(lua_State* L);
+upb_Arena* lupb_Arena_pushnew(lua_State* L);
+
+void lupb_msg_registertypes(lua_State* L);
+
+#define lupb_assert(L, predicate) \
+  if (!(predicate))               \
+    luaL_error(L, "internal error: %s, %s:%d ", #predicate, __FILE__, __LINE__);
+
+#define LUPB_UNUSED(var) (void)var
+
+#if defined(__GNUC__) || defined(__clang__)
+#define LUPB_UNREACHABLE()   \
+  do {                       \
+    assert(0);               \
+    __builtin_unreachable(); \
+  } while (0)
+#else
+#define LUPB_UNREACHABLE() \
+  do {                     \
+    assert(0);             \
+  } while (0)
+#endif
+
+#endif /* UPB_LUA_UPB_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/collections.h b/CAPI/cpp/grpc/include/upb/collections.h
new file mode 100644
index 0000000..81558dc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/collections.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_COLLECTIONS_H_
+#define UPB_COLLECTIONS_H_
+
+// TODO(b/232091617): Delete this entire header which currently exists only for
+// temporary backwards compatibility.
+#include "upb/array.h"
+#include "upb/map.h"
+
+#endif /* UPB_COLLECTIONS_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/decode.h b/CAPI/cpp/grpc/include/upb/decode.h
new file mode 100644
index 0000000..0c09497
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/decode.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * upb_decode: parsing into a upb_Message using a upb_MiniTable.
+ */
+
+#ifndef UPB_DECODE_H_
+#define UPB_DECODE_H_
+
+#include "upb/extension_registry.h"
+#include "upb/msg.h"
+
+/* Must be last. */
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  /* If set, strings will alias the input buffer instead of copying into the
+   * arena. */
+  kUpb_DecodeOption_AliasString = 1,
+
+  /* If set, the parse will return failure if any message is missing any
+   * required fields when the message data ends.  The parse will still continue,
+   * and the failure will only be reported at the end.
+   *
+   * IMPORTANT CAVEATS:
+   *
+   * 1. This can throw a false positive failure if an incomplete message is seen
+   *    on the wire but is later completed when the sub-message occurs again.
+   *    For this reason, a second pass is required to verify a failure, to be
+   *    truly robust.
+   *
+   * 2. This can return a false success if you are decoding into a message that
+   *    already has some sub-message fields present.  If the sub-message does
+   *    not occur in the binary payload, we will never visit it and discover the
+   *    incomplete sub-message.  For this reason, this check is only useful for
+   *    implemting ParseFromString() semantics.  For MergeFromString(), a
+   *    post-parse validation step will always be necessary. */
+  kUpb_DecodeOption_CheckRequired = 2,
+};
+
+#define UPB_DECODE_MAXDEPTH(depth) ((depth) << 16)
+
+typedef enum {
+  kUpb_DecodeStatus_Ok = 0,
+  kUpb_DecodeStatus_Malformed = 1,         // Wire format was corrupt
+  kUpb_DecodeStatus_OutOfMemory = 2,       // Arena alloc failed
+  kUpb_DecodeStatus_BadUtf8 = 3,           // String field had bad UTF-8
+  kUpb_DecodeStatus_MaxDepthExceeded = 4,  // Exceeded UPB_DECODE_MAXDEPTH
+
+  // kUpb_DecodeOption_CheckRequired failed (see above), but the parse otherwise
+  // succeeded.
+  kUpb_DecodeStatus_MissingRequired = 5,
+} upb_DecodeStatus;
+
+upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
+                            const upb_MiniTable* l,
+                            const upb_ExtensionRegistry* extreg, int options,
+                            upb_Arena* arena);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_DECODE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/decode_fast.h b/CAPI/cpp/grpc/include/upb/decode_fast.h
new file mode 100644
index 0000000..b04aeed
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/decode_fast.h
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// These are the specialized field parser functions for the fast parser.
+// Generated tables will refer to these by name.
+//
+// The function names are encoded with names like:
+//
+//   //  123 4
+//   upb_pss_1bt();   // Parse singular string, 1 byte tag.
+//
+// In position 1:
+//   - 'p' for parse, most function use this
+//   - 'c' for copy, for when we are copying strings instead of aliasing
+//
+// In position 2 (cardinality):
+//   - 's' for singular, with or without hasbit
+//   - 'o' for oneof
+//   - 'r' for non-packed repeated
+//   - 'p' for packed repeated
+//
+// In position 3 (type):
+//   - 'b1' for bool
+//   - 'v4' for 4-byte varint
+//   - 'v8' for 8-byte varint
+//   - 'z4' for zig-zag-encoded 4-byte varint
+//   - 'z8' for zig-zag-encoded 8-byte varint
+//   - 'f4' for 4-byte fixed
+//   - 'f8' for 8-byte fixed
+//   - 'm' for sub-message
+//   - 's' for string (validate UTF-8)
+//   - 'b' for bytes
+//
+// In position 4 (tag length):
+//   - '1' for one-byte tags (field numbers 1-15)
+//   - '2' for two-byte tags (field numbers 16-2048)
+
+#ifndef UPB_DECODE_FAST_H_
+#define UPB_DECODE_FAST_H_
+
+#include "upb/msg.h"
+
+struct upb_Decoder;
+
+// The fallback, generic parsing function that can handle any field type.
+// This just uses the regular (non-fast) parser to parse a single field.
+const char* fastdecode_generic(struct upb_Decoder* d, const char* ptr,
+                               upb_Message* msg, intptr_t table,
+                               uint64_t hasbits, uint64_t data);
+
+#define UPB_PARSE_PARAMS                                                    \
+  struct upb_Decoder *d, const char *ptr, upb_Message *msg, intptr_t table, \
+      uint64_t hasbits, uint64_t data
+
+/* primitive fields ***********************************************************/
+
+#define F(card, type, valbytes, tagbytes) \
+  const char* upb_p##card##type##valbytes##_##tagbytes##bt(UPB_PARSE_PARAMS);
+
+#define TYPES(card, tagbytes) \
+  F(card, b, 1, tagbytes)     \
+  F(card, v, 4, tagbytes)     \
+  F(card, v, 8, tagbytes)     \
+  F(card, z, 4, tagbytes)     \
+  F(card, z, 8, tagbytes)     \
+  F(card, f, 4, tagbytes)     \
+  F(card, f, 8, tagbytes)
+
+#define TAGBYTES(card) \
+  TYPES(card, 1)       \
+  TYPES(card, 2)
+
+TAGBYTES(s)
+TAGBYTES(o)
+TAGBYTES(r)
+TAGBYTES(p)
+
+#undef F
+#undef TYPES
+#undef TAGBYTES
+
+/* string fields **************************************************************/
+
+#define F(card, tagbytes, type)                                     \
+  const char* upb_p##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS); \
+  const char* upb_c##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS);
+
+#define UTF8(card, tagbytes) \
+  F(card, tagbytes, s)       \
+  F(card, tagbytes, b)
+
+#define TAGBYTES(card) \
+  UTF8(card, 1)        \
+  UTF8(card, 2)
+
+TAGBYTES(s)
+TAGBYTES(o)
+TAGBYTES(r)
+
+#undef F
+#undef TAGBYTES
+
+/* sub-message fields *********************************************************/
+
+#define F(card, tagbytes, size_ceil, ceil_arg) \
+  const char* upb_p##card##m_##tagbytes##bt_max##size_ceil##b(UPB_PARSE_PARAMS);
+
+#define SIZES(card, tagbytes) \
+  F(card, tagbytes, 64, 64)   \
+  F(card, tagbytes, 128, 128) \
+  F(card, tagbytes, 192, 192) \
+  F(card, tagbytes, 256, 256) \
+  F(card, tagbytes, max, -1)
+
+#define TAGBYTES(card) \
+  SIZES(card, 1)       \
+  SIZES(card, 2)
+
+TAGBYTES(s)
+TAGBYTES(o)
+TAGBYTES(r)
+
+#undef TAGBYTES
+#undef SIZES
+#undef F
+
+#undef UPB_PARSE_PARAMS
+
+#endif /* UPB_DECODE_FAST_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/decode_internal.h b/CAPI/cpp/grpc/include/upb/decode_internal.h
new file mode 100644
index 0000000..fe3cbc7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/decode_internal.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_DECODE_INT_H_
+#define UPB_DECODE_INT_H_
+
+// TODO(b/232091617): Delete this entire header which currently exists only for
+// temporary backwards compatibility.
+
+#include "upb/internal/decode.h"
+
+#endif /* UPB_DECODE_INT_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/def.h b/CAPI/cpp/grpc/include/upb/def.h
new file mode 100644
index 0000000..2cb312d
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/def.h
@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_DEF_H_
+#define UPB_DEF_H_
+
+#include "google/protobuf/descriptor.upb.h"
+#include "upb/internal/table.h"
+#include "upb/upb.h"
+
+/* Must be last. */
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+struct upb_EnumDef;
+typedef struct upb_EnumDef upb_EnumDef;
+struct upb_EnumValueDef;
+typedef struct upb_EnumValueDef upb_EnumValueDef;
+struct upb_ExtensionRange;
+typedef struct upb_ExtensionRange upb_ExtensionRange;
+struct upb_FieldDef;
+typedef struct upb_FieldDef upb_FieldDef;
+struct upb_FileDef;
+typedef struct upb_FileDef upb_FileDef;
+struct upb_MethodDef;
+typedef struct upb_MethodDef upb_MethodDef;
+struct upb_MessageDef;
+typedef struct upb_MessageDef upb_MessageDef;
+struct upb_OneofDef;
+typedef struct upb_OneofDef upb_OneofDef;
+struct upb_ServiceDef;
+typedef struct upb_ServiceDef upb_ServiceDef;
+struct upb_streamdef;
+typedef struct upb_streamdef upb_streamdef;
+struct upb_DefPool;
+typedef struct upb_DefPool upb_DefPool;
+
+typedef enum { kUpb_Syntax_Proto2 = 2, kUpb_Syntax_Proto3 = 3 } upb_Syntax;
+
+/* All the different kind of well known type messages. For simplicity of check,
+ * number wrappers and string wrappers are grouped together. Make sure the
+ * order and merber of these groups are not changed.
+ */
+typedef enum {
+  kUpb_WellKnown_Unspecified,
+  kUpb_WellKnown_Any,
+  kUpb_WellKnown_FieldMask,
+  kUpb_WellKnown_Duration,
+  kUpb_WellKnown_Timestamp,
+  /* number wrappers */
+  kUpb_WellKnown_DoubleValue,
+  kUpb_WellKnown_FloatValue,
+  kUpb_WellKnown_Int64Value,
+  kUpb_WellKnown_UInt64Value,
+  kUpb_WellKnown_Int32Value,
+  kUpb_WellKnown_UInt32Value,
+  /* string wrappers */
+  kUpb_WellKnown_StringValue,
+  kUpb_WellKnown_BytesValue,
+  kUpb_WellKnown_BoolValue,
+  kUpb_WellKnown_Value,
+  kUpb_WellKnown_ListValue,
+  kUpb_WellKnown_Struct
+} upb_WellKnown;
+
+/* upb_FieldDef ***************************************************************/
+
+/* Maximum field number allowed for FieldDefs.  This is an inherent limit of the
+ * protobuf wire format. */
+#define kUpb_MaxFieldNumber ((1 << 29) - 1)
+
+const google_protobuf_FieldOptions* upb_FieldDef_Options(const upb_FieldDef* f);
+bool upb_FieldDef_HasOptions(const upb_FieldDef* f);
+const char* upb_FieldDef_FullName(const upb_FieldDef* f);
+upb_CType upb_FieldDef_CType(const upb_FieldDef* f);
+upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f);
+upb_Label upb_FieldDef_Label(const upb_FieldDef* f);
+uint32_t upb_FieldDef_Number(const upb_FieldDef* f);
+const char* upb_FieldDef_Name(const upb_FieldDef* f);
+const char* upb_FieldDef_JsonName(const upb_FieldDef* f);
+bool upb_FieldDef_HasJsonName(const upb_FieldDef* f);
+bool upb_FieldDef_IsExtension(const upb_FieldDef* f);
+bool upb_FieldDef_IsPacked(const upb_FieldDef* f);
+const upb_FileDef* upb_FieldDef_File(const upb_FieldDef* f);
+const upb_MessageDef* upb_FieldDef_ContainingType(const upb_FieldDef* f);
+const upb_MessageDef* upb_FieldDef_ExtensionScope(const upb_FieldDef* f);
+const upb_OneofDef* upb_FieldDef_ContainingOneof(const upb_FieldDef* f);
+const upb_OneofDef* upb_FieldDef_RealContainingOneof(const upb_FieldDef* f);
+uint32_t upb_FieldDef_Index(const upb_FieldDef* f);
+bool upb_FieldDef_IsSubMessage(const upb_FieldDef* f);
+bool upb_FieldDef_IsString(const upb_FieldDef* f);
+bool upb_FieldDef_IsOptional(const upb_FieldDef* f);
+bool upb_FieldDef_IsRequired(const upb_FieldDef* f);
+bool upb_FieldDef_IsRepeated(const upb_FieldDef* f);
+bool upb_FieldDef_IsPrimitive(const upb_FieldDef* f);
+bool upb_FieldDef_IsMap(const upb_FieldDef* f);
+bool upb_FieldDef_HasDefault(const upb_FieldDef* f);
+bool upb_FieldDef_HasSubDef(const upb_FieldDef* f);
+bool upb_FieldDef_HasPresence(const upb_FieldDef* f);
+const upb_MessageDef* upb_FieldDef_MessageSubDef(const upb_FieldDef* f);
+const upb_EnumDef* upb_FieldDef_EnumSubDef(const upb_FieldDef* f);
+const upb_MiniTable_Field* upb_FieldDef_MiniTable(const upb_FieldDef* f);
+const upb_MiniTable_Extension* _upb_FieldDef_ExtensionMiniTable(
+    const upb_FieldDef* f);
+bool _upb_FieldDef_IsProto3Optional(const upb_FieldDef* f);
+
+/* upb_OneofDef ***************************************************************/
+
+const google_protobuf_OneofOptions* upb_OneofDef_Options(const upb_OneofDef* o);
+bool upb_OneofDef_HasOptions(const upb_OneofDef* o);
+const char* upb_OneofDef_Name(const upb_OneofDef* o);
+const upb_MessageDef* upb_OneofDef_ContainingType(const upb_OneofDef* o);
+uint32_t upb_OneofDef_Index(const upb_OneofDef* o);
+bool upb_OneofDef_IsSynthetic(const upb_OneofDef* o);
+int upb_OneofDef_FieldCount(const upb_OneofDef* o);
+const upb_FieldDef* upb_OneofDef_Field(const upb_OneofDef* o, int i);
+
+/* Oneof lookups:
+ * - ntof:  look up a field by name.
+ * - ntofz: look up a field by name (as a null-terminated string).
+ * - itof:  look up a field by number. */
+const upb_FieldDef* upb_OneofDef_LookupNameWithSize(const upb_OneofDef* o,
+                                                    const char* name,
+                                                    size_t length);
+UPB_INLINE const upb_FieldDef* upb_OneofDef_LookupName(const upb_OneofDef* o,
+                                                       const char* name) {
+  return upb_OneofDef_LookupNameWithSize(o, name, strlen(name));
+}
+const upb_FieldDef* upb_OneofDef_LookupNumber(const upb_OneofDef* o,
+                                              uint32_t num);
+
+/* upb_MessageDef *************************************************************/
+
+/* Well-known field tag numbers for map-entry messages. */
+#define kUpb_MapEntry_KeyFieldNumber 1
+#define kUpb_MapEntry_ValueFieldNumber 2
+
+/* Well-known field tag numbers for Any messages. */
+#define kUpb_Any_TypeFieldNumber 1
+#define kUpb_Any_ValueFieldNumber 2
+
+/* Well-known field tag numbers for duration messages. */
+#define kUpb_Duration_SecondsFieldNumber 1
+#define kUpb_Duration_NanosFieldNumber 2
+
+/* Well-known field tag numbers for timestamp messages. */
+#define kUpb_Timestamp_SecondsFieldNumber 1
+#define kUpb_Timestamp_NanosFieldNumber 2
+
+const google_protobuf_MessageOptions* upb_MessageDef_Options(
+    const upb_MessageDef* m);
+bool upb_MessageDef_HasOptions(const upb_MessageDef* m);
+const char* upb_MessageDef_FullName(const upb_MessageDef* m);
+const upb_FileDef* upb_MessageDef_File(const upb_MessageDef* m);
+const upb_MessageDef* upb_MessageDef_ContainingType(const upb_MessageDef* m);
+const char* upb_MessageDef_Name(const upb_MessageDef* m);
+upb_Syntax upb_MessageDef_Syntax(const upb_MessageDef* m);
+upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m);
+int upb_MessageDef_ExtensionRangeCount(const upb_MessageDef* m);
+int upb_MessageDef_FieldCount(const upb_MessageDef* m);
+int upb_MessageDef_OneofCount(const upb_MessageDef* m);
+const upb_ExtensionRange* upb_MessageDef_ExtensionRange(const upb_MessageDef* m,
+                                                        int i);
+const upb_FieldDef* upb_MessageDef_Field(const upb_MessageDef* m, int i);
+const upb_OneofDef* upb_MessageDef_Oneof(const upb_MessageDef* m, int i);
+const upb_FieldDef* upb_MessageDef_FindFieldByNumber(const upb_MessageDef* m,
+                                                     uint32_t i);
+const upb_FieldDef* upb_MessageDef_FindFieldByNameWithSize(
+    const upb_MessageDef* m, const char* name, size_t len);
+const upb_OneofDef* upb_MessageDef_FindOneofByNameWithSize(
+    const upb_MessageDef* m, const char* name, size_t len);
+const upb_MiniTable* upb_MessageDef_MiniTable(const upb_MessageDef* m);
+
+UPB_INLINE const upb_OneofDef* upb_MessageDef_FindOneofByName(
+    const upb_MessageDef* m, const char* name) {
+  return upb_MessageDef_FindOneofByNameWithSize(m, name, strlen(name));
+}
+
+UPB_INLINE const upb_FieldDef* upb_MessageDef_FindFieldByName(
+    const upb_MessageDef* m, const char* name) {
+  return upb_MessageDef_FindFieldByNameWithSize(m, name, strlen(name));
+}
+
+UPB_INLINE bool upb_MessageDef_IsMapEntry(const upb_MessageDef* m) {
+  return google_protobuf_MessageOptions_map_entry(upb_MessageDef_Options(m));
+}
+
+UPB_INLINE bool upb_MessageDef_IsMessageSet(const upb_MessageDef* m) {
+  return google_protobuf_MessageOptions_message_set_wire_format(
+      upb_MessageDef_Options(m));
+}
+
+/* Nested entities. */
+int upb_MessageDef_NestedMessageCount(const upb_MessageDef* m);
+int upb_MessageDef_NestedEnumCount(const upb_MessageDef* m);
+int upb_MessageDef_NestedExtensionCount(const upb_MessageDef* m);
+const upb_MessageDef* upb_MessageDef_NestedMessage(const upb_MessageDef* m,
+                                                   int i);
+const upb_EnumDef* upb_MessageDef_NestedEnum(const upb_MessageDef* m, int i);
+const upb_FieldDef* upb_MessageDef_NestedExtension(const upb_MessageDef* m,
+                                                   int i);
+
+/* Lookup of either field or oneof by name.  Returns whether either was found.
+ * If the return is true, then the found def will be set, and the non-found
+ * one set to NULL. */
+bool upb_MessageDef_FindByNameWithSize(const upb_MessageDef* m,
+                                       const char* name, size_t len,
+                                       const upb_FieldDef** f,
+                                       const upb_OneofDef** o);
+
+UPB_INLINE bool upb_MessageDef_FindByName(const upb_MessageDef* m,
+                                          const char* name,
+                                          const upb_FieldDef** f,
+                                          const upb_OneofDef** o) {
+  return upb_MessageDef_FindByNameWithSize(m, name, strlen(name), f, o);
+}
+
+/* Returns a field by either JSON name or regular proto name. */
+const upb_FieldDef* upb_MessageDef_FindByJsonNameWithSize(
+    const upb_MessageDef* m, const char* name, size_t len);
+UPB_INLINE const upb_FieldDef* upb_MessageDef_FindByJsonName(
+    const upb_MessageDef* m, const char* name) {
+  return upb_MessageDef_FindByJsonNameWithSize(m, name, strlen(name));
+}
+
+/* upb_ExtensionRange *********************************************************/
+
+const google_protobuf_ExtensionRangeOptions* upb_ExtensionRange_Options(
+    const upb_ExtensionRange* r);
+bool upb_ExtensionRange_HasOptions(const upb_ExtensionRange* r);
+int32_t upb_ExtensionRange_Start(const upb_ExtensionRange* r);
+int32_t upb_ExtensionRange_End(const upb_ExtensionRange* r);
+
+/* upb_EnumDef ****************************************************************/
+
+const google_protobuf_EnumOptions* upb_EnumDef_Options(const upb_EnumDef* e);
+bool upb_EnumDef_HasOptions(const upb_EnumDef* e);
+const char* upb_EnumDef_FullName(const upb_EnumDef* e);
+const char* upb_EnumDef_Name(const upb_EnumDef* e);
+const upb_FileDef* upb_EnumDef_File(const upb_EnumDef* e);
+const upb_MessageDef* upb_EnumDef_ContainingType(const upb_EnumDef* e);
+int32_t upb_EnumDef_Default(const upb_EnumDef* e);
+int upb_EnumDef_ValueCount(const upb_EnumDef* e);
+const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i);
+
+const upb_EnumValueDef* upb_EnumDef_FindValueByNameWithSize(
+    const upb_EnumDef* e, const char* name, size_t len);
+const upb_EnumValueDef* upb_EnumDef_FindValueByNumber(const upb_EnumDef* e,
+                                                      int32_t num);
+bool upb_EnumDef_CheckNumber(const upb_EnumDef* e, int32_t num);
+
+// Convenience wrapper.
+UPB_INLINE const upb_EnumValueDef* upb_EnumDef_FindValueByName(
+    const upb_EnumDef* e, const char* name) {
+  return upb_EnumDef_FindValueByNameWithSize(e, name, strlen(name));
+}
+
+/* upb_EnumValueDef ***********************************************************/
+
+const google_protobuf_EnumValueOptions* upb_EnumValueDef_Options(
+    const upb_EnumValueDef* e);
+bool upb_EnumValueDef_HasOptions(const upb_EnumValueDef* e);
+const char* upb_EnumValueDef_FullName(const upb_EnumValueDef* e);
+const char* upb_EnumValueDef_Name(const upb_EnumValueDef* e);
+int32_t upb_EnumValueDef_Number(const upb_EnumValueDef* e);
+uint32_t upb_EnumValueDef_Index(const upb_EnumValueDef* e);
+const upb_EnumDef* upb_EnumValueDef_Enum(const upb_EnumValueDef* e);
+
+/* upb_FileDef ****************************************************************/
+
+const google_protobuf_FileOptions* upb_FileDef_Options(const upb_FileDef* f);
+bool upb_FileDef_HasOptions(const upb_FileDef* f);
+const char* upb_FileDef_Name(const upb_FileDef* f);
+const char* upb_FileDef_Package(const upb_FileDef* f);
+upb_Syntax upb_FileDef_Syntax(const upb_FileDef* f);
+int upb_FileDef_DependencyCount(const upb_FileDef* f);
+int upb_FileDef_PublicDependencyCount(const upb_FileDef* f);
+int upb_FileDef_WeakDependencyCount(const upb_FileDef* f);
+int upb_FileDef_TopLevelMessageCount(const upb_FileDef* f);
+int upb_FileDef_TopLevelEnumCount(const upb_FileDef* f);
+int upb_FileDef_TopLevelExtensionCount(const upb_FileDef* f);
+int upb_FileDef_ServiceCount(const upb_FileDef* f);
+const upb_FileDef* upb_FileDef_Dependency(const upb_FileDef* f, int i);
+const upb_FileDef* upb_FileDef_PublicDependency(const upb_FileDef* f, int i);
+const upb_FileDef* upb_FileDef_WeakDependency(const upb_FileDef* f, int i);
+const upb_MessageDef* upb_FileDef_TopLevelMessage(const upb_FileDef* f, int i);
+const upb_EnumDef* upb_FileDef_TopLevelEnum(const upb_FileDef* f, int i);
+const upb_FieldDef* upb_FileDef_TopLevelExtension(const upb_FileDef* f, int i);
+const upb_ServiceDef* upb_FileDef_Service(const upb_FileDef* f, int i);
+const upb_DefPool* upb_FileDef_Pool(const upb_FileDef* f);
+const int32_t* _upb_FileDef_PublicDependencyIndexes(const upb_FileDef* f);
+const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f);
+
+/* upb_MethodDef **************************************************************/
+
+const google_protobuf_MethodOptions* upb_MethodDef_Options(
+    const upb_MethodDef* m);
+bool upb_MethodDef_HasOptions(const upb_MethodDef* m);
+const char* upb_MethodDef_FullName(const upb_MethodDef* m);
+int upb_MethodDef_Index(const upb_MethodDef* m);
+const char* upb_MethodDef_Name(const upb_MethodDef* m);
+const upb_ServiceDef* upb_MethodDef_Service(const upb_MethodDef* m);
+const upb_MessageDef* upb_MethodDef_InputType(const upb_MethodDef* m);
+const upb_MessageDef* upb_MethodDef_OutputType(const upb_MethodDef* m);
+bool upb_MethodDef_ClientStreaming(const upb_MethodDef* m);
+bool upb_MethodDef_ServerStreaming(const upb_MethodDef* m);
+
+/* upb_ServiceDef *************************************************************/
+
+const google_protobuf_ServiceOptions* upb_ServiceDef_Options(
+    const upb_ServiceDef* s);
+bool upb_ServiceDef_HasOptions(const upb_ServiceDef* s);
+const char* upb_ServiceDef_FullName(const upb_ServiceDef* s);
+const char* upb_ServiceDef_Name(const upb_ServiceDef* s);
+int upb_ServiceDef_Index(const upb_ServiceDef* s);
+const upb_FileDef* upb_ServiceDef_File(const upb_ServiceDef* s);
+int upb_ServiceDef_MethodCount(const upb_ServiceDef* s);
+const upb_MethodDef* upb_ServiceDef_Method(const upb_ServiceDef* s, int i);
+const upb_MethodDef* upb_ServiceDef_FindMethodByName(const upb_ServiceDef* s,
+                                                     const char* name);
+
+/* upb_DefPool ****************************************************************/
+
+upb_DefPool* upb_DefPool_New(void);
+void upb_DefPool_Free(upb_DefPool* s);
+const upb_MessageDef* upb_DefPool_FindMessageByName(const upb_DefPool* s,
+                                                    const char* sym);
+const upb_MessageDef* upb_DefPool_FindMessageByNameWithSize(
+    const upb_DefPool* s, const char* sym, size_t len);
+const upb_EnumDef* upb_DefPool_FindEnumByName(const upb_DefPool* s,
+                                              const char* sym);
+const upb_EnumValueDef* upb_DefPool_FindEnumByNameval(const upb_DefPool* s,
+                                                      const char* sym);
+const upb_FieldDef* upb_DefPool_FindExtensionByName(const upb_DefPool* s,
+                                                    const char* sym);
+const upb_FieldDef* upb_DefPool_FindExtensionByNameWithSize(
+    const upb_DefPool* s, const char* sym, size_t len);
+const upb_FileDef* upb_DefPool_FindFileByName(const upb_DefPool* s,
+                                              const char* name);
+const upb_ServiceDef* upb_DefPool_FindServiceByName(const upb_DefPool* s,
+                                                    const char* name);
+const upb_ServiceDef* upb_DefPool_FindServiceByNameWithSize(
+    const upb_DefPool* s, const char* name, size_t size);
+const upb_FileDef* upb_DefPool_FindFileContainingSymbol(const upb_DefPool* s,
+                                                        const char* name);
+const upb_FileDef* upb_DefPool_FindFileByNameWithSize(const upb_DefPool* s,
+                                                      const char* name,
+                                                      size_t len);
+const upb_FileDef* upb_DefPool_AddFile(
+    upb_DefPool* s, const google_protobuf_FileDescriptorProto* file,
+    upb_Status* status);
+size_t _upb_DefPool_BytesLoaded(const upb_DefPool* s);
+upb_Arena* _upb_DefPool_Arena(const upb_DefPool* s);
+const upb_FieldDef* _upb_DefPool_FindExtensionByMiniTable(
+    const upb_DefPool* s, const upb_MiniTable_Extension* ext);
+const upb_FieldDef* upb_DefPool_FindExtensionByNumber(const upb_DefPool* s,
+                                                      const upb_MessageDef* m,
+                                                      int32_t fieldnum);
+const upb_ExtensionRegistry* upb_DefPool_ExtensionRegistry(
+    const upb_DefPool* s);
+const upb_FieldDef** upb_DefPool_GetAllExtensions(const upb_DefPool* s,
+                                                  const upb_MessageDef* m,
+                                                  size_t* count);
+
+/* For generated code only: loads a generated descriptor. */
+typedef struct _upb_DefPool_Init {
+  struct _upb_DefPool_Init** deps; /* Dependencies of this file. */
+  const upb_MiniTable_File* layout;
+  const char* filename;
+  upb_StringView descriptor; /* Serialized descriptor. */
+} _upb_DefPool_Init;
+
+// Should only be directly called by tests.  This variant lets us suppress
+// the use of compiled-in tables, forcing a rebuild of the tables at runtime.
+bool _upb_DefPool_LoadDefInitEx(upb_DefPool* s, const _upb_DefPool_Init* init,
+                                bool rebuild_minitable);
+
+UPB_INLINE bool _upb_DefPool_LoadDefInit(upb_DefPool* s,
+                                         const _upb_DefPool_Init* init) {
+  return _upb_DefPool_LoadDefInitEx(s, init, false);
+}
+
+#include "upb/port_undef.inc"
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* UPB_DEF_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/def.hpp b/CAPI/cpp/grpc/include/upb/def.hpp
new file mode 100644
index 0000000..49cc560
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/def.hpp
@@ -0,0 +1,441 @@
+// Copyright (c) 2009-2021, Google LLC
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Google LLC nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef UPB_DEF_HPP_
+#define UPB_DEF_HPP_
+
+#include <cstring>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "upb/def.h"
+#include "upb/reflection.h"
+#include "upb/upb.hpp"
+
+namespace upb {
+
+typedef upb_MessageValue MessageValue;
+
+class EnumDefPtr;
+class FileDefPtr;
+class MessageDefPtr;
+class OneofDefPtr;
+
+// A upb::FieldDefPtr describes a single field in a message.  It is most often
+// found as a part of a upb_MessageDef, but can also stand alone to represent
+// an extension.
+class FieldDefPtr {
+ public:
+  FieldDefPtr() : ptr_(nullptr) {}
+  explicit FieldDefPtr(const upb_FieldDef* ptr) : ptr_(ptr) {}
+
+  const upb_FieldDef* ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
+
+  typedef upb_CType Type;
+  typedef upb_Label Label;
+  typedef upb_FieldType DescriptorType;
+
+  const char* full_name() const { return upb_FieldDef_FullName(ptr_); }
+
+  Type type() const { return upb_FieldDef_CType(ptr_); }
+  Label label() const { return upb_FieldDef_Label(ptr_); }
+  const char* name() const { return upb_FieldDef_Name(ptr_); }
+  const char* json_name() const { return upb_FieldDef_JsonName(ptr_); }
+  uint32_t number() const { return upb_FieldDef_Number(ptr_); }
+  bool is_extension() const { return upb_FieldDef_IsExtension(ptr_); }
+
+  // For non-string, non-submessage fields, this indicates whether binary
+  // protobufs are encoded in packed or non-packed format.
+  //
+  // Note: this accessor reflects the fact that "packed" has different defaults
+  // depending on whether the proto is proto2 or proto3.
+  bool packed() const { return upb_FieldDef_IsPacked(ptr_); }
+
+  // An integer that can be used as an index into an array of fields for
+  // whatever message this field belongs to.  Guaranteed to be less than
+  // f->containing_type()->field_count().  May only be accessed once the def has
+  // been finalized.
+  uint32_t index() const { return upb_FieldDef_Index(ptr_); }
+
+  // The MessageDef to which this field belongs.
+  //
+  // If this field has been added to a MessageDef, that message can be retrieved
+  // directly (this is always the case for frozen FieldDefs).
+  //
+  // If the field has not yet been added to a MessageDef, you can set the name
+  // of the containing type symbolically instead.  This is mostly useful for
+  // extensions, where the extension is declared separately from the message.
+  MessageDefPtr containing_type() const;
+
+  // The OneofDef to which this field belongs, or NULL if this field is not part
+  // of a oneof.
+  OneofDefPtr containing_oneof() const;
+
+  // The field's type according to the enum in descriptor.proto.  This is not
+  // the same as UPB_TYPE_*, because it distinguishes between (for example)
+  // INT32 and SINT32, whereas our "type" enum does not.  This return of
+  // descriptor_type() is a function of type(), integer_format(), and
+  // is_tag_delimited().
+  DescriptorType descriptor_type() const { return upb_FieldDef_Type(ptr_); }
+
+  // Convenient field type tests.
+  bool IsSubMessage() const { return upb_FieldDef_IsSubMessage(ptr_); }
+  bool IsString() const { return upb_FieldDef_IsString(ptr_); }
+  bool IsSequence() const { return upb_FieldDef_IsRepeated(ptr_); }
+  bool IsPrimitive() const { return upb_FieldDef_IsPrimitive(ptr_); }
+  bool IsMap() const { return upb_FieldDef_IsMap(ptr_); }
+
+  MessageValue default_value() const { return upb_FieldDef_Default(ptr_); }
+
+  // Returns the enum or submessage def for this field, if any.  The field's
+  // type must match (ie. you may only call enum_subdef() for fields where
+  // type() == kUpb_CType_Enum).
+  EnumDefPtr enum_subdef() const;
+  MessageDefPtr message_subdef() const;
+
+ private:
+  const upb_FieldDef* ptr_;
+};
+
+// Class that represents a oneof.
+class OneofDefPtr {
+ public:
+  OneofDefPtr() : ptr_(nullptr) {}
+  explicit OneofDefPtr(const upb_OneofDef* ptr) : ptr_(ptr) {}
+
+  const upb_OneofDef* ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
+
+  // Returns the MessageDef that contains this OneofDef.
+  MessageDefPtr containing_type() const;
+
+  // Returns the name of this oneof.
+  const char* name() const { return upb_OneofDef_Name(ptr_); }
+
+  // Returns the number of fields in the oneof.
+  int field_count() const { return upb_OneofDef_FieldCount(ptr_); }
+  FieldDefPtr field(int i) const {
+    return FieldDefPtr(upb_OneofDef_Field(ptr_, i));
+  }
+
+  // Looks up by name.
+  FieldDefPtr FindFieldByName(const char* name, size_t len) const {
+    return FieldDefPtr(upb_OneofDef_LookupNameWithSize(ptr_, name, len));
+  }
+  FieldDefPtr FindFieldByName(const char* name) const {
+    return FieldDefPtr(upb_OneofDef_LookupName(ptr_, name));
+  }
+
+  template <class T>
+  FieldDefPtr FindFieldByName(const T& str) const {
+    return FindFieldByName(str.c_str(), str.size());
+  }
+
+  // Looks up by tag number.
+  FieldDefPtr FindFieldByNumber(uint32_t num) const {
+    return FieldDefPtr(upb_OneofDef_LookupNumber(ptr_, num));
+  }
+
+ private:
+  const upb_OneofDef* ptr_;
+};
+
+// Structure that describes a single .proto message type.
+class MessageDefPtr {
+ public:
+  MessageDefPtr() : ptr_(nullptr) {}
+  explicit MessageDefPtr(const upb_MessageDef* ptr) : ptr_(ptr) {}
+
+  const upb_MessageDef* ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
+
+  FileDefPtr file() const;
+
+  const char* full_name() const { return upb_MessageDef_FullName(ptr_); }
+  const char* name() const { return upb_MessageDef_Name(ptr_); }
+
+  // The number of fields that belong to the MessageDef.
+  int field_count() const { return upb_MessageDef_FieldCount(ptr_); }
+  FieldDefPtr field(int i) const {
+    return FieldDefPtr(upb_MessageDef_Field(ptr_, i));
+  }
+
+  // The number of oneofs that belong to the MessageDef.
+  int oneof_count() const { return upb_MessageDef_OneofCount(ptr_); }
+  OneofDefPtr oneof(int i) const {
+    return OneofDefPtr(upb_MessageDef_Oneof(ptr_, i));
+  }
+
+  upb_Syntax syntax() const { return upb_MessageDef_Syntax(ptr_); }
+
+  // These return null pointers if the field is not found.
+  FieldDefPtr FindFieldByNumber(uint32_t number) const {
+    return FieldDefPtr(upb_MessageDef_FindFieldByNumber(ptr_, number));
+  }
+  FieldDefPtr FindFieldByName(const char* name, size_t len) const {
+    return FieldDefPtr(upb_MessageDef_FindFieldByNameWithSize(ptr_, name, len));
+  }
+  FieldDefPtr FindFieldByName(const char* name) const {
+    return FieldDefPtr(upb_MessageDef_FindFieldByName(ptr_, name));
+  }
+
+  template <class T>
+  FieldDefPtr FindFieldByName(const T& str) const {
+    return FindFieldByName(str.c_str(), str.size());
+  }
+
+  OneofDefPtr FindOneofByName(const char* name, size_t len) const {
+    return OneofDefPtr(upb_MessageDef_FindOneofByNameWithSize(ptr_, name, len));
+  }
+
+  OneofDefPtr FindOneofByName(const char* name) const {
+    return OneofDefPtr(upb_MessageDef_FindOneofByName(ptr_, name));
+  }
+
+  template <class T>
+  OneofDefPtr FindOneofByName(const T& str) const {
+    return FindOneofByName(str.c_str(), str.size());
+  }
+
+  // Is this message a map entry?
+  bool mapentry() const { return upb_MessageDef_IsMapEntry(ptr_); }
+
+  // Return the type of well known type message. kUpb_WellKnown_Unspecified for
+  // non-well-known message.
+  upb_WellKnown wellknowntype() const {
+    return upb_MessageDef_WellKnownType(ptr_);
+  }
+
+ private:
+  class FieldIter {
+   public:
+    explicit FieldIter(const upb_MessageDef* m, int i) : m_(m), i_(i) {}
+    void operator++() { i_++; }
+
+    FieldDefPtr operator*() {
+      return FieldDefPtr(upb_MessageDef_Field(m_, i_));
+    }
+    bool operator!=(const FieldIter& other) { return i_ != other.i_; }
+    bool operator==(const FieldIter& other) { return i_ == other.i_; }
+
+   private:
+    const upb_MessageDef* m_;
+    int i_;
+  };
+
+  class FieldAccessor {
+   public:
+    explicit FieldAccessor(const upb_MessageDef* md) : md_(md) {}
+    FieldIter begin() { return FieldIter(md_, 0); }
+    FieldIter end() { return FieldIter(md_, upb_MessageDef_FieldCount(md_)); }
+
+   private:
+    const upb_MessageDef* md_;
+  };
+
+  class OneofIter {
+   public:
+    explicit OneofIter(const upb_MessageDef* m, int i) : m_(m), i_(i) {}
+    void operator++() { i_++; }
+
+    OneofDefPtr operator*() {
+      return OneofDefPtr(upb_MessageDef_Oneof(m_, i_));
+    }
+    bool operator!=(const OneofIter& other) { return i_ != other.i_; }
+    bool operator==(const OneofIter& other) { return i_ == other.i_; }
+
+   private:
+    const upb_MessageDef* m_;
+    int i_;
+  };
+
+  class OneofAccessor {
+   public:
+    explicit OneofAccessor(const upb_MessageDef* md) : md_(md) {}
+    OneofIter begin() { return OneofIter(md_, 0); }
+    OneofIter end() { return OneofIter(md_, upb_MessageDef_OneofCount(md_)); }
+
+   private:
+    const upb_MessageDef* md_;
+  };
+
+ public:
+  FieldAccessor fields() const { return FieldAccessor(ptr()); }
+  OneofAccessor oneofs() const { return OneofAccessor(ptr()); }
+
+ private:
+  const upb_MessageDef* ptr_;
+};
+
+class EnumValDefPtr {
+ public:
+  EnumValDefPtr() : ptr_(nullptr) {}
+  explicit EnumValDefPtr(const upb_EnumValueDef* ptr) : ptr_(ptr) {}
+
+  int32_t number() const { return upb_EnumValueDef_Number(ptr_); }
+  const char* full_name() const { return upb_EnumValueDef_FullName(ptr_); }
+  const char* name() const { return upb_EnumValueDef_Name(ptr_); }
+
+ private:
+  const upb_EnumValueDef* ptr_;
+};
+
+class EnumDefPtr {
+ public:
+  EnumDefPtr() : ptr_(nullptr) {}
+  explicit EnumDefPtr(const upb_EnumDef* ptr) : ptr_(ptr) {}
+
+  const upb_EnumDef* ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
+
+  const char* full_name() const { return upb_EnumDef_FullName(ptr_); }
+  const char* name() const { return upb_EnumDef_Name(ptr_); }
+
+  // The value that is used as the default when no field default is specified.
+  // If not set explicitly, the first value that was added will be used.
+  // The default value must be a member of the enum.
+  // Requires that value_count() > 0.
+  int32_t default_value() const { return upb_EnumDef_Default(ptr_); }
+
+  // Returns the number of values currently defined in the enum.  Note that
+  // multiple names can refer to the same number, so this may be greater than
+  // the total number of unique numbers.
+  int value_count() const { return upb_EnumDef_ValueCount(ptr_); }
+
+  // Lookups from name to integer, returning true if found.
+  EnumValDefPtr FindValueByName(const char* name) const {
+    return EnumValDefPtr(upb_EnumDef_FindValueByName(ptr_, name));
+  }
+
+  // Finds the name corresponding to the given number, or NULL if none was
+  // found.  If more than one name corresponds to this number, returns the
+  // first one that was added.
+  EnumValDefPtr FindValueByNumber(int32_t num) const {
+    return EnumValDefPtr(upb_EnumDef_FindValueByNumber(ptr_, num));
+  }
+
+ private:
+  const upb_EnumDef* ptr_;
+};
+
+// Class that represents a .proto file with some things defined in it.
+//
+// Many users won't care about FileDefs, but they are necessary if you want to
+// read the values of file-level options.
+class FileDefPtr {
+ public:
+  explicit FileDefPtr(const upb_FileDef* ptr) : ptr_(ptr) {}
+
+  const upb_FileDef* ptr() const { return ptr_; }
+  explicit operator bool() const { return ptr_ != nullptr; }
+
+  // Get/set name of the file (eg. "foo/bar.proto").
+  const char* name() const { return upb_FileDef_Name(ptr_); }
+
+  // Package name for definitions inside the file (eg. "foo.bar").
+  const char* package() const { return upb_FileDef_Package(ptr_); }
+
+  // Syntax for the file.  Defaults to proto2.
+  upb_Syntax syntax() const { return upb_FileDef_Syntax(ptr_); }
+
+  // Get the list of dependencies from the file.  These are returned in the
+  // order that they were added to the FileDefPtr.
+  int dependency_count() const { return upb_FileDef_DependencyCount(ptr_); }
+  const FileDefPtr dependency(int index) const {
+    return FileDefPtr(upb_FileDef_Dependency(ptr_, index));
+  }
+
+ private:
+  const upb_FileDef* ptr_;
+};
+
+// Non-const methods in upb::DefPool are NOT thread-safe.
+class DefPool {
+ public:
+  DefPool() : ptr_(upb_DefPool_New(), upb_DefPool_Free) {}
+  explicit DefPool(upb_DefPool* s) : ptr_(s, upb_DefPool_Free) {}
+
+  const upb_DefPool* ptr() const { return ptr_.get(); }
+  upb_DefPool* ptr() { return ptr_.get(); }
+
+  // Finds an entry in the symbol table with this exact name.  If not found,
+  // returns NULL.
+  MessageDefPtr FindMessageByName(const char* sym) const {
+    return MessageDefPtr(upb_DefPool_FindMessageByName(ptr_.get(), sym));
+  }
+
+  EnumDefPtr FindEnumByName(const char* sym) const {
+    return EnumDefPtr(upb_DefPool_FindEnumByName(ptr_.get(), sym));
+  }
+
+  FileDefPtr FindFileByName(const char* name) const {
+    return FileDefPtr(upb_DefPool_FindFileByName(ptr_.get(), name));
+  }
+
+  // TODO: iteration?
+
+  // Adds the given serialized FileDescriptorProto to the pool.
+  FileDefPtr AddFile(const google_protobuf_FileDescriptorProto* file_proto,
+                     Status* status) {
+    return FileDefPtr(
+        upb_DefPool_AddFile(ptr_.get(), file_proto, status->ptr()));
+  }
+
+ private:
+  std::unique_ptr<upb_DefPool, decltype(&upb_DefPool_Free)> ptr_;
+};
+
+// TODO(b/236632406): This typedef is deprecated. Delete it.
+using SymbolTable = DefPool;
+
+inline FileDefPtr MessageDefPtr::file() const {
+  return FileDefPtr(upb_MessageDef_File(ptr_));
+}
+
+inline MessageDefPtr FieldDefPtr::message_subdef() const {
+  return MessageDefPtr(upb_FieldDef_MessageSubDef(ptr_));
+}
+
+inline MessageDefPtr FieldDefPtr::containing_type() const {
+  return MessageDefPtr(upb_FieldDef_ContainingType(ptr_));
+}
+
+inline MessageDefPtr OneofDefPtr::containing_type() const {
+  return MessageDefPtr(upb_OneofDef_ContainingType(ptr_));
+}
+
+inline OneofDefPtr FieldDefPtr::containing_oneof() const {
+  return OneofDefPtr(upb_FieldDef_ContainingOneof(ptr_));
+}
+
+inline EnumDefPtr FieldDefPtr::enum_subdef() const {
+  return EnumDefPtr(upb_FieldDef_EnumSubDef(ptr_));
+}
+
+}  // namespace upb
+
+#endif  // UPB_DEF_HPP_
diff --git a/CAPI/cpp/grpc/include/upb/encode.h b/CAPI/cpp/grpc/include/upb/encode.h
new file mode 100644
index 0000000..791d84a
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/encode.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * upb_Encode: parsing from a upb_Message using a upb_MiniTable.
+ */
+
+#ifndef UPB_ENCODE_H_
+#define UPB_ENCODE_H_
+
+#include "upb/msg.h"
+
+/* Must be last. */
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  /* If set, the results of serializing will be deterministic across all
+   * instances of this binary. There are no guarantees across different
+   * binary builds.
+   *
+   * If your proto contains maps, the encoder will need to malloc()/free()
+   * memory during encode. */
+  kUpb_EncodeOption_Deterministic = 1,
+
+  /* When set, unknown fields are not printed. */
+  kUpb_EncodeOption_SkipUnknown = 2,
+
+  /* When set, the encode will fail if any required fields are missing. */
+  kUpb_EncodeOption_CheckRequired = 4,
+};
+
+#define UPB_ENCODE_MAXDEPTH(depth) ((depth) << 16)
+
+typedef enum {
+  kUpb_EncodeStatus_Ok = 0,
+  kUpb_EncodeStatus_OutOfMemory = 1,       // Arena alloc failed
+  kUpb_EncodeStatus_MaxDepthExceeded = 2,  // Exceeded UPB_ENCODE_MAXDEPTH
+
+  // kUpb_EncodeOption_CheckRequired failed but the parse otherwise succeeded.
+  kUpb_EncodeStatus_MissingRequired = 3,
+} upb_EncodeStatus;
+
+upb_EncodeStatus upb_Encode(const void* msg, const upb_MiniTable* l,
+                            int options, upb_Arena* arena, char** buf,
+                            size_t* size);
+
+#include "upb/port_undef.inc"
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_ENCODE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/extension_registry.h b/CAPI/cpp/grpc/include/upb/extension_registry.h
new file mode 100644
index 0000000..0e0a444
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/extension_registry.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_EXTENSION_REGISTRY_H_
+#define UPB_EXTENSION_REGISTRY_H_
+
+#include <stddef.h>
+
+#include "upb/upb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Extension registry: a dynamic data structure that stores a map of:
+ *   (upb_MiniTable, number) -> extension info
+ *
+ * upb_decode() uses upb_ExtensionRegistry to look up extensions while parsing
+ * binary format.
+ *
+ * upb_ExtensionRegistry is part of the mini-table (msglayout) family of
+ * objects. Like all mini-table objects, it is suitable for reflection-less
+ * builds that do not want to expose names into the binary.
+ *
+ * Unlike most mini-table types, upb_ExtensionRegistry requires dynamic memory
+ * allocation and dynamic initialization:
+ * * If reflection is being used, then upb_DefPool will construct an appropriate
+ *   upb_ExtensionRegistry automatically.
+ * * For a mini-table only build, the user must manually construct the
+ *   upb_ExtensionRegistry and populate it with all of the extensions the user
+ * cares about.
+ * * A third alternative is to manually unpack relevant extensions after the
+ *   main parse is complete, similar to how Any works. This is perhaps the
+ *   nicest solution from the perspective of reducing dependencies, avoiding
+ *   dynamic memory allocation, and avoiding the need to parse uninteresting
+ *   extensions.  The downsides are:
+ *     (1) parse errors are not caught during the main parse
+ *     (2) the CPU hit of parsing comes during access, which could cause an
+ *         undesirable stutter in application performance.
+ *
+ * Users cannot directly get or put into this map. Users can only add the
+ * extensions from a generated module and pass the extension registry to the
+ * binary decoder.
+ *
+ * A upb_DefPool provides a upb_ExtensionRegistry, so any users who use
+ * reflection do not need to populate a upb_ExtensionRegistry directly.
+ */
+
+struct upb_ExtensionRegistry;
+typedef struct upb_ExtensionRegistry upb_ExtensionRegistry;
+
+/* Creates a upb_ExtensionRegistry in the given arena.  The arena must outlive
+ * any use of the extreg. */
+upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_EXTENSION_REGISTRY_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/internal/decode.h b/CAPI/cpp/grpc/include/upb/internal/decode.h
new file mode 100644
index 0000000..708874c
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/internal/decode.h
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Internal implementation details of the decoder that are shared between
+ * decode.c and decode_fast.c.
+ */
+
+#ifndef UPB_INTERNAL_DECODE_H_
+#define UPB_INTERNAL_DECODE_H_
+
+#include <setjmp.h>
+
+#include "upb/decode.h"
+#include "upb/internal/upb.h"
+#include "upb/msg_internal.h"
+#include "third_party/utf8_range/utf8_range.h"
+
+/* Must be last. */
+#include "upb/port_def.inc"
+
+#define DECODE_NOGROUP (uint32_t) - 1
+
+typedef struct upb_Decoder {
+  const char* end;          /* Can read up to 16 bytes slop beyond this. */
+  const char* limit_ptr;    /* = end + UPB_MIN(limit, 0) */
+  upb_Message* unknown_msg; /* If non-NULL, add unknown data at buffer flip. */
+  const char* unknown;      /* Start of unknown data. */
+  const upb_ExtensionRegistry*
+      extreg;         /* For looking up extensions during the parse. */
+  int limit;          /* Submessage limit relative to end. */
+  int depth;          /* Tracks recursion depth to bound stack usage. */
+  uint32_t end_group; /* field number of END_GROUP tag, else DECODE_NOGROUP */
+  uint16_t options;
+  bool missing_required;
+  char patch[32];
+  upb_Arena arena;
+  jmp_buf err;
+
+#ifndef NDEBUG
+  const char* debug_tagstart;
+  const char* debug_valstart;
+#endif
+} upb_Decoder;
+
+/* Error function that will abort decoding with longjmp(). We can't declare this
+ * UPB_NORETURN, even though it is appropriate, because if we do then compilers
+ * will "helpfully" refuse to tailcall to it
+ * (see: https://stackoverflow.com/a/55657013), which will defeat a major goal
+ * of our optimizations. That is also why we must declare it in a separate file,
+ * otherwise the compiler will see that it calls longjmp() and deduce that it is
+ * noreturn. */
+const char* fastdecode_err(upb_Decoder* d, int status);
+
+extern const uint8_t upb_utf8_offsets[];
+
+UPB_INLINE
+bool decode_verifyutf8_inl(const char* ptr, int len) {
+  const char* end = ptr + len;
+
+  // Check 8 bytes at a time for any non-ASCII char.
+  while (end - ptr >= 8) {
+    uint64_t data;
+    memcpy(&data, ptr, 8);
+    if (data & 0x8080808080808080) goto non_ascii;
+    ptr += 8;
+  }
+
+  // Check one byte at a time for non-ASCII.
+  while (ptr < end) {
+    if (*ptr & 0x80) goto non_ascii;
+    ptr++;
+  }
+
+  return true;
+
+non_ascii:
+  return utf8_range2((const unsigned char*)ptr, end - ptr) == 0;
+}
+
+const char* decode_checkrequired(upb_Decoder* d, const char* ptr,
+                                 const upb_Message* msg,
+                                 const upb_MiniTable* l);
+
+/* x86-64 pointers always have the high 16 bits matching. So we can shift
+ * left 8 and right 8 without loss of information. */
+UPB_INLINE intptr_t decode_totable(const upb_MiniTable* tablep) {
+  return ((intptr_t)tablep << 8) | tablep->table_mask;
+}
+
+UPB_INLINE const upb_MiniTable* decode_totablep(intptr_t table) {
+  return (const upb_MiniTable*)(table >> 8);
+}
+
+UPB_INLINE
+const char* decode_isdonefallback_inl(upb_Decoder* d, const char* ptr,
+                                      int overrun, int* status) {
+  if (overrun < d->limit) {
+    /* Need to copy remaining data into patch buffer. */
+    UPB_ASSERT(overrun < 16);
+    if (d->unknown_msg) {
+      if (!_upb_Message_AddUnknown(d->unknown_msg, d->unknown, ptr - d->unknown,
+                                   &d->arena)) {
+        *status = kUpb_DecodeStatus_OutOfMemory;
+        return NULL;
+      }
+      d->unknown = &d->patch[0] + overrun;
+    }
+    memset(d->patch + 16, 0, 16);
+    memcpy(d->patch, d->end, 16);
+    ptr = &d->patch[0] + overrun;
+    d->end = &d->patch[16];
+    d->limit -= 16;
+    d->limit_ptr = d->end + d->limit;
+    d->options &= ~kUpb_DecodeOption_AliasString;
+    UPB_ASSERT(ptr < d->limit_ptr);
+    return ptr;
+  } else {
+    *status = kUpb_DecodeStatus_Malformed;
+    return NULL;
+  }
+}
+
+const char* decode_isdonefallback(upb_Decoder* d, const char* ptr, int overrun);
+
+UPB_INLINE
+bool decode_isdone(upb_Decoder* d, const char** ptr) {
+  int overrun = *ptr - d->end;
+  if (UPB_LIKELY(*ptr < d->limit_ptr)) {
+    return false;
+  } else if (UPB_LIKELY(overrun == d->limit)) {
+    return true;
+  } else {
+    *ptr = decode_isdonefallback(d, *ptr, overrun);
+    return false;
+  }
+}
+
+#if UPB_FASTTABLE
+UPB_INLINE
+const char* fastdecode_tagdispatch(upb_Decoder* d, const char* ptr,
+                                   upb_Message* msg, intptr_t table,
+                                   uint64_t hasbits, uint64_t tag) {
+  const upb_MiniTable* table_p = decode_totablep(table);
+  uint8_t mask = table;
+  uint64_t data;
+  size_t idx = tag & mask;
+  UPB_ASSUME((idx & 7) == 0);
+  idx >>= 3;
+  data = table_p->fasttable[idx].field_data ^ tag;
+  UPB_MUSTTAIL return table_p->fasttable[idx].field_parser(d, ptr, msg, table,
+                                                           hasbits, data);
+}
+#endif
+
+UPB_INLINE uint32_t fastdecode_loadtag(const char* ptr) {
+  uint16_t tag;
+  memcpy(&tag, ptr, 2);
+  return tag;
+}
+
+UPB_INLINE void decode_checklimit(upb_Decoder* d) {
+  UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
+}
+
+UPB_INLINE int decode_pushlimit(upb_Decoder* d, const char* ptr, int size) {
+  int limit = size + (int)(ptr - d->end);
+  int delta = d->limit - limit;
+  decode_checklimit(d);
+  d->limit = limit;
+  d->limit_ptr = d->end + UPB_MIN(0, limit);
+  decode_checklimit(d);
+  return delta;
+}
+
+UPB_INLINE void decode_poplimit(upb_Decoder* d, const char* ptr,
+                                int saved_delta) {
+  UPB_ASSERT(ptr - d->end == d->limit);
+  decode_checklimit(d);
+  d->limit += saved_delta;
+  d->limit_ptr = d->end + UPB_MIN(0, d->limit);
+  decode_checklimit(d);
+}
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_INTERNAL_DECODE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/internal/mini_table_accessors.h b/CAPI/cpp/grpc/include/upb/internal/mini_table_accessors.h
new file mode 100644
index 0000000..23f694b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/internal/mini_table_accessors.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2009-2022, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_INTERNAL_MINI_TABLE_ACCESSORS_H_
+#define UPB_INTERNAL_MINI_TABLE_ACCESSORS_H_
+
+#include "upb/msg_internal.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+UPB_INLINE bool _upb_MiniTable_Field_InOneOf(const upb_MiniTable_Field* field) {
+  return field->presence < 0;
+}
+
+UPB_INLINE void _upb_MiniTable_SetPresence(upb_Message* msg,
+                                           const upb_MiniTable_Field* field) {
+  if (field->presence > 0) {
+    _upb_sethas_field(msg, field);
+  } else if (_upb_MiniTable_Field_InOneOf(field)) {
+    *_upb_oneofcase_field(msg, field) = field->number;
+  }
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif  // UPB_INTERNAL_MINI_TABLE_ACCESSORS_H_
diff --git a/CAPI/cpp/grpc/include/upb/internal/table.h b/CAPI/cpp/grpc/include/upb/internal/table.h
new file mode 100644
index 0000000..bc647be
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/internal/table.h
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * upb_table
+ *
+ * This header is INTERNAL-ONLY!  Its interfaces are not public or stable!
+ * This file defines very fast int->upb_value (inttable) and string->upb_value
+ * (strtable) hash tables.
+ *
+ * The table uses chained scatter with Brent's variation (inspired by the Lua
+ * implementation of hash tables).  The hash function for strings is Austin
+ * Appleby's "MurmurHash."
+ *
+ * The inttable uses uintptr_t as its key, which guarantees it can be used to
+ * store pointers or integers of at least 32 bits (upb isn't really useful on
+ * systems where sizeof(void*) < 4).
+ *
+ * The table must be homogeneous (all values of the same type).  In debug
+ * mode, we check this on insert and lookup.
+ */
+
+#ifndef UPB_INTERNAL_TABLE_H_
+#define UPB_INTERNAL_TABLE_H_
+
+#include <stdint.h>
+#include <string.h>
+
+#include "upb/upb.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* upb_value ******************************************************************/
+
+typedef struct {
+  uint64_t val;
+} upb_value;
+
+/* Variant that works with a length-delimited rather than NULL-delimited string,
+ * as supported by strtable. */
+char* upb_strdup2(const char* s, size_t len, upb_Arena* a);
+
+UPB_INLINE void _upb_value_setval(upb_value* v, uint64_t val) { v->val = val; }
+
+/* For each value ctype, define the following set of functions:
+ *
+ * // Get/set an int32 from a upb_value.
+ * int32_t upb_value_getint32(upb_value val);
+ * void upb_value_setint32(upb_value *val, int32_t cval);
+ *
+ * // Construct a new upb_value from an int32.
+ * upb_value upb_value_int32(int32_t val); */
+#define FUNCS(name, membername, type_t, converter, proto_type)       \
+  UPB_INLINE void upb_value_set##name(upb_value* val, type_t cval) { \
+    val->val = (converter)cval;                                      \
+  }                                                                  \
+  UPB_INLINE upb_value upb_value_##name(type_t val) {                \
+    upb_value ret;                                                   \
+    upb_value_set##name(&ret, val);                                  \
+    return ret;                                                      \
+  }                                                                  \
+  UPB_INLINE type_t upb_value_get##name(upb_value val) {             \
+    return (type_t)(converter)val.val;                               \
+  }
+
+FUNCS(int32, int32, int32_t, int32_t, UPB_CTYPE_INT32)
+FUNCS(int64, int64, int64_t, int64_t, UPB_CTYPE_INT64)
+FUNCS(uint32, uint32, uint32_t, uint32_t, UPB_CTYPE_UINT32)
+FUNCS(uint64, uint64, uint64_t, uint64_t, UPB_CTYPE_UINT64)
+FUNCS(bool, _bool, bool, bool, UPB_CTYPE_BOOL)
+FUNCS(cstr, cstr, char*, uintptr_t, UPB_CTYPE_CSTR)
+FUNCS(ptr, ptr, void*, uintptr_t, UPB_CTYPE_PTR)
+FUNCS(constptr, constptr, const void*, uintptr_t, UPB_CTYPE_CONSTPTR)
+
+#undef FUNCS
+
+UPB_INLINE void upb_value_setfloat(upb_value* val, float cval) {
+  memcpy(&val->val, &cval, sizeof(cval));
+}
+
+UPB_INLINE void upb_value_setdouble(upb_value* val, double cval) {
+  memcpy(&val->val, &cval, sizeof(cval));
+}
+
+UPB_INLINE upb_value upb_value_float(float cval) {
+  upb_value ret;
+  upb_value_setfloat(&ret, cval);
+  return ret;
+}
+
+UPB_INLINE upb_value upb_value_double(double cval) {
+  upb_value ret;
+  upb_value_setdouble(&ret, cval);
+  return ret;
+}
+
+#undef SET_TYPE
+
+/* upb_tabkey *****************************************************************/
+
+/* Either:
+ *   1. an actual integer key, or
+ *   2. a pointer to a string prefixed by its uint32_t length, owned by us.
+ *
+ * ...depending on whether this is a string table or an int table.  We would
+ * make this a union of those two types, but C89 doesn't support statically
+ * initializing a non-first union member. */
+typedef uintptr_t upb_tabkey;
+
+UPB_INLINE char* upb_tabstr(upb_tabkey key, uint32_t* len) {
+  char* mem = (char*)key;
+  if (len) memcpy(len, mem, sizeof(*len));
+  return mem + sizeof(*len);
+}
+
+UPB_INLINE upb_StringView upb_tabstrview(upb_tabkey key) {
+  upb_StringView ret;
+  uint32_t len;
+  ret.data = upb_tabstr(key, &len);
+  ret.size = len;
+  return ret;
+}
+
+/* upb_tabval *****************************************************************/
+
+typedef struct upb_tabval {
+  uint64_t val;
+} upb_tabval;
+
+#define UPB_TABVALUE_EMPTY_INIT \
+  { -1 }
+
+/* upb_table ******************************************************************/
+
+typedef struct _upb_tabent {
+  upb_tabkey key;
+  upb_tabval val;
+
+  /* Internal chaining.  This is const so we can create static initializers for
+   * tables.  We cast away const sometimes, but *only* when the containing
+   * upb_table is known to be non-const.  This requires a bit of care, but
+   * the subtlety is confined to table.c. */
+  const struct _upb_tabent* next;
+} upb_tabent;
+
+typedef struct {
+  size_t count;       /* Number of entries in the hash part. */
+  uint32_t mask;      /* Mask to turn hash value -> bucket. */
+  uint32_t max_count; /* Max count before we hit our load limit. */
+  uint8_t size_lg2;   /* Size of the hashtable part is 2^size_lg2 entries. */
+  upb_tabent* entries;
+} upb_table;
+
+typedef struct {
+  upb_table t;
+} upb_strtable;
+
+typedef struct {
+  upb_table t;             /* For entries that don't fit in the array part. */
+  const upb_tabval* array; /* Array part of the table. See const note above. */
+  size_t array_size;       /* Array part size. */
+  size_t array_count;      /* Array part number of elements. */
+} upb_inttable;
+
+UPB_INLINE size_t upb_table_size(const upb_table* t) {
+  if (t->size_lg2 == 0)
+    return 0;
+  else
+    return 1 << t->size_lg2;
+}
+
+/* Internal-only functions, in .h file only out of necessity. */
+UPB_INLINE bool upb_tabent_isempty(const upb_tabent* e) { return e->key == 0; }
+
+/* Initialize and uninitialize a table, respectively.  If memory allocation
+ * failed, false is returned that the table is uninitialized. */
+bool upb_inttable_init(upb_inttable* table, upb_Arena* a);
+bool upb_strtable_init(upb_strtable* table, size_t expected_size, upb_Arena* a);
+
+/* Returns the number of values in the table. */
+size_t upb_inttable_count(const upb_inttable* t);
+UPB_INLINE size_t upb_strtable_count(const upb_strtable* t) {
+  return t->t.count;
+}
+
+void upb_strtable_clear(upb_strtable* t);
+
+/* Inserts the given key into the hashtable with the given value.  The key must
+ * not already exist in the hash table.  For strtables, the key is not required
+ * to be NULL-terminated, and the table will make an internal copy of the key.
+ * Inttables must not insert a value of UINTPTR_MAX.
+ *
+ * If a table resize was required but memory allocation failed, false is
+ * returned and the table is unchanged. */
+bool upb_inttable_insert(upb_inttable* t, uintptr_t key, upb_value val,
+                         upb_Arena* a);
+bool upb_strtable_insert(upb_strtable* t, const char* key, size_t len,
+                         upb_value val, upb_Arena* a);
+
+/* Looks up key in this table, returning "true" if the key was found.
+ * If v is non-NULL, copies the value for this key into *v. */
+bool upb_inttable_lookup(const upb_inttable* t, uintptr_t key, upb_value* v);
+bool upb_strtable_lookup2(const upb_strtable* t, const char* key, size_t len,
+                          upb_value* v);
+
+/* For NULL-terminated strings. */
+UPB_INLINE bool upb_strtable_lookup(const upb_strtable* t, const char* key,
+                                    upb_value* v) {
+  return upb_strtable_lookup2(t, key, strlen(key), v);
+}
+
+/* Removes an item from the table.  Returns true if the remove was successful,
+ * and stores the removed item in *val if non-NULL. */
+bool upb_inttable_remove(upb_inttable* t, uintptr_t key, upb_value* val);
+bool upb_strtable_remove2(upb_strtable* t, const char* key, size_t len,
+                          upb_value* val);
+
+UPB_INLINE bool upb_strtable_remove(upb_strtable* t, const char* key,
+                                    upb_value* v) {
+  return upb_strtable_remove2(t, key, strlen(key), v);
+}
+
+/* Updates an existing entry in an inttable.  If the entry does not exist,
+ * returns false and does nothing.  Unlike insert/remove, this does not
+ * invalidate iterators. */
+bool upb_inttable_replace(upb_inttable* t, uintptr_t key, upb_value val);
+
+/* Optimizes the table for the current set of entries, for both memory use and
+ * lookup time.  Client should call this after all entries have been inserted;
+ * inserting more entries is legal, but will likely require a table resize. */
+void upb_inttable_compact(upb_inttable* t, upb_Arena* a);
+
+/* Exposed for testing only. */
+bool upb_strtable_resize(upb_strtable* t, size_t size_lg2, upb_Arena* a);
+
+/* Iterators ******************************************************************/
+
+/* Iteration over inttable.
+ *
+ *   intptr_t iter = UPB_INTTABLE_BEGIN;
+ *   uintptr_t key;
+ *   upb_value val;
+ *   while (upb_inttable_next2(t, &key, &val, &iter)) {
+ *      // ...
+ *   }
+ */
+
+#define UPB_INTTABLE_BEGIN -1
+
+bool upb_inttable_next2(const upb_inttable* t, uintptr_t* key, upb_value* val,
+                        intptr_t* iter);
+void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter);
+
+/* Iteration over strtable.
+ *
+ *   intptr_t iter = UPB_INTTABLE_BEGIN;
+ *   upb_StringView key;
+ *   upb_value val;
+ *   while (upb_strtable_next2(t, &key, &val, &iter)) {
+ *      // ...
+ *   }
+ */
+
+#define UPB_STRTABLE_BEGIN -1
+
+bool upb_strtable_next2(const upb_strtable* t, upb_StringView* key,
+                        upb_value* val, intptr_t* iter);
+void upb_strtable_removeiter(upb_strtable* t, intptr_t* iter);
+
+/* DEPRECATED iterators, slated for removal.
+ *
+ * Iterators for int and string tables.  We are subject to some kind of unusual
+ * design constraints:
+ *
+ * For high-level languages:
+ *  - we must be able to guarantee that we don't crash or corrupt memory even if
+ *    the program accesses an invalidated iterator.
+ *
+ * For C++11 range-based for:
+ *  - iterators must be copyable
+ *  - iterators must be comparable
+ *  - it must be possible to construct an "end" value.
+ *
+ * Iteration order is undefined.
+ *
+ * Modifying the table invalidates iterators.  upb_{str,int}table_done() is
+ * guaranteed to work even on an invalidated iterator, as long as the table it
+ * is iterating over has not been freed.  Calling next() or accessing data from
+ * an invalidated iterator yields unspecified elements from the table, but it is
+ * guaranteed not to crash and to return real table elements (except when done()
+ * is true). */
+
+/* upb_strtable_iter **********************************************************/
+
+/*   upb_strtable_iter i;
+ *   upb_strtable_begin(&i, t);
+ *   for(; !upb_strtable_done(&i); upb_strtable_next(&i)) {
+ *     const char *key = upb_strtable_iter_key(&i);
+ *     const upb_value val = upb_strtable_iter_value(&i);
+ *     // ...
+ *   }
+ */
+
+typedef struct {
+  const upb_strtable* t;
+  size_t index;
+} upb_strtable_iter;
+
+void upb_strtable_begin(upb_strtable_iter* i, const upb_strtable* t);
+void upb_strtable_next(upb_strtable_iter* i);
+bool upb_strtable_done(const upb_strtable_iter* i);
+upb_StringView upb_strtable_iter_key(const upb_strtable_iter* i);
+upb_value upb_strtable_iter_value(const upb_strtable_iter* i);
+void upb_strtable_iter_setdone(upb_strtable_iter* i);
+bool upb_strtable_iter_isequal(const upb_strtable_iter* i1,
+                               const upb_strtable_iter* i2);
+
+/* upb_inttable_iter **********************************************************/
+
+/*   upb_inttable_iter i;
+ *   upb_inttable_begin(&i, t);
+ *   for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
+ *     uintptr_t key = upb_inttable_iter_key(&i);
+ *     upb_value val = upb_inttable_iter_value(&i);
+ *     // ...
+ *   }
+ */
+
+typedef struct {
+  const upb_inttable* t;
+  size_t index;
+  bool array_part;
+} upb_inttable_iter;
+
+UPB_INLINE const upb_tabent* str_tabent(const upb_strtable_iter* i) {
+  return &i->t->t.entries[i->index];
+}
+
+void upb_inttable_begin(upb_inttable_iter* i, const upb_inttable* t);
+void upb_inttable_next(upb_inttable_iter* i);
+bool upb_inttable_done(const upb_inttable_iter* i);
+uintptr_t upb_inttable_iter_key(const upb_inttable_iter* i);
+upb_value upb_inttable_iter_value(const upb_inttable_iter* i);
+void upb_inttable_iter_setdone(upb_inttable_iter* i);
+bool upb_inttable_iter_isequal(const upb_inttable_iter* i1,
+                               const upb_inttable_iter* i2);
+
+uint32_t _upb_Hash(const void* p, size_t n, uint64_t seed);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_INTERNAL_TABLE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/internal/upb.h b/CAPI/cpp/grpc/include/upb/internal/upb.h
new file mode 100644
index 0000000..cdc8bfc
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/internal/upb.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_INTERNAL_UPB_H_
+#define UPB_INTERNAL_UPB_H_
+
+#include "upb/upb.h"
+
+struct mem_block;
+typedef struct mem_block mem_block;
+
+struct upb_Arena {
+  _upb_ArenaHead head;
+  /* Stores cleanup metadata for this arena.
+   * - a pointer to the current cleanup counter.
+   * - a boolean indicating if there is an unowned initial block.  */
+  uintptr_t cleanup_metadata;
+
+  /* Allocator to allocate arena blocks.  We are responsible for freeing these
+   * when we are destroyed. */
+  upb_alloc* block_alloc;
+  uint32_t last_size;
+
+  /* When multiple arenas are fused together, each arena points to a parent
+   * arena (root points to itself). The root tracks how many live arenas
+   * reference it. */
+  uint32_t refcount; /* Only used when a->parent == a */
+  struct upb_Arena* parent;
+
+  /* Linked list of blocks to free/cleanup. */
+  mem_block *freelist, *freelist_tail;
+};
+
+// Encodes a float or double that is round-trippable, but as short as possible.
+// These routines are not fully optimal (not guaranteed to be shortest), but are
+// short-ish and match the implementation that has been used in protobuf since
+// the beginning.
+//
+// The given buffer size must be at least kUpb_RoundTripBufferSize.
+enum { kUpb_RoundTripBufferSize = 32 };
+void _upb_EncodeRoundTripDouble(double val, char* buf, size_t size);
+void _upb_EncodeRoundTripFloat(float val, char* buf, size_t size);
+
+#endif /* UPB_INTERNAL_UPB_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/internal/vsnprintf_compat.h b/CAPI/cpp/grpc/include/upb/internal/vsnprintf_compat.h
new file mode 100644
index 0000000..a9d84bb
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/internal/vsnprintf_compat.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_INTERNAL_VSNPRINTF_COMPAT_H_
+#define UPB_INTERNAL_VSNPRINTF_COMPAT_H_
+
+#include <stdio.h>
+
+// Must be last.
+#include "upb/port_def.inc"
+
+UPB_INLINE int _upb_vsnprintf(char* buf, size_t size, const char* fmt,
+                              va_list ap) {
+#if defined(__MINGW64__) || defined(__MINGW32__) || defined(_MSC_VER)
+  // The msvc runtime has a non-conforming vsnprintf() that requires the
+  // following compatibility code to become conformant.
+  int n = -1;
+  if (size != 0) n = _vsnprintf_s(buf, size, _TRUNCATE, fmt, ap);
+  if (n == -1) n = _vscprintf(fmt, ap);
+  return n;
+#else
+  return vsnprintf(buf, size, fmt, ap);
+#endif
+}
+
+#include "upb/port_undef.inc"
+
+#endif  // UPB_INTERNAL_VSNPRINTF_COMPAT_H_
diff --git a/CAPI/cpp/grpc/include/upb/json_decode.h b/CAPI/cpp/grpc/include/upb/json_decode.h
new file mode 100644
index 0000000..848f4df
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/json_decode.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_JSONDECODE_H_
+#define UPB_JSONDECODE_H_
+
+#include "upb/def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum { upb_JsonDecode_IgnoreUnknown = 1 };
+
+bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
+                    const upb_MessageDef* m, const upb_DefPool* symtab,
+                    int options, upb_Arena* arena, upb_Status* status);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_JSONDECODE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/json_encode.h b/CAPI/cpp/grpc/include/upb/json_encode.h
new file mode 100644
index 0000000..6e0cac3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/json_encode.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_JSONENCODE_H_
+#define UPB_JSONENCODE_H_
+
+#include "upb/def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  /* When set, emits 0/default values.  TODO(haberman): proto3 only? */
+  upb_JsonEncode_EmitDefaults = 1 << 0,
+
+  /* When set, use normal (snake_case) field names instead of JSON (camelCase)
+     names. */
+  upb_JsonEncode_UseProtoNames = 1 << 1,
+
+  /* When set, emits enums as their integer values instead of as their names. */
+  upb_JsonEncode_FormatEnumsAsIntegers = 1 << 2
+};
+
+/* Encodes the given |msg| to JSON format.  The message's reflection is given in
+ * |m|.  The symtab in |symtab| is used to find extensions (if NULL, extensions
+ * will not be printed).
+ *
+ * Output is placed in the given buffer, and always NULL-terminated.  The output
+ * size (excluding NULL) is returned.  This means that a return value >= |size|
+ * implies that the output was truncated.  (These are the same semantics as
+ * snprintf()). */
+size_t upb_JsonEncode(const upb_Message* msg, const upb_MessageDef* m,
+                      const upb_DefPool* ext_pool, int options, char* buf,
+                      size_t size, upb_Status* status);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_JSONENCODE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/map.h b/CAPI/cpp/grpc/include/upb/map.h
new file mode 100644
index 0000000..8ee0ddd
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/map.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_MAP_H_
+#define UPB_MAP_H_
+
+#include "google/protobuf/descriptor.upb.h"
+#include "upb/message_value.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Creates a new map on the given arena with the given key/value size. */
+upb_Map* upb_Map_New(upb_Arena* a, upb_CType key_type, upb_CType value_type);
+
+/* Returns the number of entries in the map. */
+size_t upb_Map_Size(const upb_Map* map);
+
+/* Stores a value for the given key into |*val| (or the zero value if the key is
+ * not present).  Returns whether the key was present.  The |val| pointer may be
+ * NULL, in which case the function tests whether the given key is present.  */
+bool upb_Map_Get(const upb_Map* map, upb_MessageValue key,
+                 upb_MessageValue* val);
+
+/* Removes all entries in the map. */
+void upb_Map_Clear(upb_Map* map);
+
+typedef enum {
+  // LINT.IfChange
+  kUpb_MapInsertStatus_Inserted = 0,
+  kUpb_MapInsertStatus_Replaced = 1,
+  kUpb_MapInsertStatus_OutOfMemory = 2,
+  // LINT.ThenChange(//depot/google3/third_party/upb/upb/msg_internal.h)
+} upb_MapInsertStatus;
+
+/* Sets the given key to the given value, returning whether the key was inserted
+ * or replaced.  If the key was inserted, then any existing iterators will be
+ * invalidated. */
+upb_MapInsertStatus upb_Map_Insert(upb_Map* map, upb_MessageValue key,
+                                   upb_MessageValue val, upb_Arena* arena);
+
+/* Sets the given key to the given value.  Returns false if memory allocation
+ * failed. If the key is newly inserted, then any existing iterators will be
+ * invalidated. */
+UPB_INLINE bool upb_Map_Set(upb_Map* map, upb_MessageValue key,
+                            upb_MessageValue val, upb_Arena* arena) {
+  return upb_Map_Insert(map, key, val, arena) !=
+         kUpb_MapInsertStatus_OutOfMemory;
+}
+
+/* Deletes this key from the table.  Returns true if the key was present. */
+bool upb_Map_Delete(upb_Map* map, upb_MessageValue key);
+
+/* Map iteration:
+ *
+ * size_t iter = kUpb_Map_Begin;
+ * while (upb_MapIterator_Next(map, &iter)) {
+ *   upb_MessageValue key = upb_MapIterator_Key(map, iter);
+ *   upb_MessageValue val = upb_MapIterator_Value(map, iter);
+ *
+ *   // If mutating is desired.
+ *   upb_MapIterator_SetValue(map, iter, value2);
+ * }
+ */
+
+/* Advances to the next entry.  Returns false if no more entries are present. */
+bool upb_MapIterator_Next(const upb_Map* map, size_t* iter);
+
+/* Returns true if the iterator still points to a valid entry, or false if the
+ * iterator is past the last element. It is an error to call this function with
+ * kUpb_Map_Begin (you must call next() at least once first). */
+bool upb_MapIterator_Done(const upb_Map* map, size_t iter);
+
+/* Returns the key and value for this entry of the map. */
+upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter);
+upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter);
+
+/* Sets the value for this entry.  The iterator must not be done, and the
+ * iterator must not have been initialized const. */
+void upb_MapIterator_SetValue(upb_Map* map, size_t iter,
+                              upb_MessageValue value);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_MAP_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/message_value.h b/CAPI/cpp/grpc/include/upb/message_value.h
new file mode 100644
index 0000000..a08b90f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/message_value.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_MESSAGE_VALUE_H_
+#define UPB_MESSAGE_VALUE_H_
+
+#include "google/protobuf/descriptor.upb.h"
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Definitions commn to both upb_Array and upb_Map.
+
+typedef union {
+  bool bool_val;
+  float float_val;
+  double double_val;
+  int32_t int32_val;
+  int64_t int64_val;
+  uint32_t uint32_val;
+  uint64_t uint64_val;
+  const upb_Map* map_val;
+  const upb_Message* msg_val;
+  const upb_Array* array_val;
+  upb_StringView str_val;
+} upb_MessageValue;
+
+typedef union {
+  upb_Map* map;
+  upb_Message* msg;
+  upb_Array* array;
+} upb_MutableMessageValue;
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_MESSAGE_VALUE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/mini_descriptor.h b/CAPI/cpp/grpc/include/upb/mini_descriptor.h
new file mode 100644
index 0000000..829d008
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/mini_descriptor.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2009-2022, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_MINI_DESCRIPTOR_H_
+#define UPB_MINI_DESCRIPTOR_H_
+
+#include "upb/def.h"
+#include "upb/upb.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** upb_MiniDescriptor ********************************************************/
+
+upb_StringView upb_MiniDescriptor_EncodeEnum(const upb_EnumDef* enum_def,
+                                             upb_Arena* a);
+
+upb_StringView upb_MiniDescriptor_EncodeExtension(const upb_FieldDef* field_def,
+                                                  upb_Arena* a);
+
+upb_StringView upb_MiniDescriptor_EncodeMessage(
+    const upb_MessageDef* message_def, upb_Arena* a);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_MINI_DESCRIPTOR_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/mini_table.h b/CAPI/cpp/grpc/include/upb/mini_table.h
new file mode 100644
index 0000000..6c41f81
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/mini_table.h
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2009-2022, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_MINI_TABLE_H_
+#define UPB_MINI_TABLE_H_
+
+#include "upb/msg_internal.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const upb_MiniTable_Field* upb_MiniTable_FindFieldByNumber(
+    const upb_MiniTable* table, uint32_t number);
+
+UPB_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
+    const upb_MiniTable* mini_table, const upb_MiniTable_Field* field) {
+  return mini_table->subs[field->submsg_index].submsg;
+}
+
+UPB_INLINE bool upb_MiniTable_Enum_CheckValue(const upb_MiniTable_Enum* e,
+                                              int32_t val) {
+  uint32_t uval = (uint32_t)val;
+  if (uval < 64) return e->mask & (1ULL << uval);
+  // OPT: binary search long lists?
+  int n = e->value_count;
+  for (int i = 0; i < n; i++) {
+    if (e->values[i] == val) return true;
+  }
+  return false;
+}
+
+/** upb_MtDataEncoder *********************************************************/
+
+// Functions to encode a string in a format that can be loaded by
+// upb_MiniTable_Build().
+
+typedef enum {
+  kUpb_MessageModifier_ValidateUtf8 = 1 << 0,
+  kUpb_MessageModifier_DefaultIsPacked = 1 << 1,
+  kUpb_MessageModifier_IsExtendable = 1 << 2,
+} kUpb_MessageModifier;
+
+typedef enum {
+  kUpb_FieldModifier_IsRepeated = 1 << 0,
+  kUpb_FieldModifier_IsPacked = 1 << 1,
+  kUpb_FieldModifier_IsClosedEnum = 1 << 2,
+  kUpb_FieldModifier_IsProto3Singular = 1 << 3,
+  kUpb_FieldModifier_IsRequired = 1 << 4,
+} kUpb_FieldModifier;
+
+typedef struct {
+  char* end;  // Limit of the buffer passed as a parameter.
+  // Aliased to internal-only members in .cc.
+  char internal[32];
+} upb_MtDataEncoder;
+
+// If the input buffer has at least this many bytes available, the encoder call
+// is guaranteed to succeed (as long as field number order is maintained).
+#define kUpb_MtDataEncoder_MinSize 16
+
+// Encodes field/oneof information for a given message.  The sequence of calls
+// should look like:
+//
+//   upb_MtDataEncoder e;
+//   char buf[256];
+//   char* ptr = buf;
+//   e.end = ptr + sizeof(buf);
+//   ptr = upb_MtDataEncoder_StartMessage(&e, ptr);
+//   // Fields *must* be in field number order.
+//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+//
+//   // If oneofs are present.  Oneofs must be encoded after regular fields.
+//   ptr = upb_MiniTable_StartOneof(&e, ptr)
+//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//
+//   ptr = upb_MiniTable_StartOneof(&e, ptr);
+//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+//
+// Oneofs must be encoded after all regular fields.
+char* upb_MtDataEncoder_StartMessage(upb_MtDataEncoder* e, char* ptr,
+                                     uint64_t msg_mod);
+char* upb_MtDataEncoder_PutField(upb_MtDataEncoder* e, char* ptr,
+                                 upb_FieldType type, uint32_t field_num,
+                                 uint64_t field_mod);
+char* upb_MtDataEncoder_StartOneof(upb_MtDataEncoder* e, char* ptr);
+char* upb_MtDataEncoder_PutOneofField(upb_MtDataEncoder* e, char* ptr,
+                                      uint32_t field_num);
+
+// Encodes the set of values for a given enum.  The values must be given in
+// order (after casting to uint32_t), and repeats are not allowed.
+void upb_MtDataEncoder_StartEnum(upb_MtDataEncoder* e);
+char* upb_MtDataEncoder_PutEnumValue(upb_MtDataEncoder* e, char* ptr,
+                                     uint32_t val);
+char* upb_MtDataEncoder_EndEnum(upb_MtDataEncoder* e, char* ptr);
+
+/** upb_MiniTable *************************************************************/
+
+typedef enum {
+  kUpb_MiniTablePlatform_32Bit,
+  kUpb_MiniTablePlatform_64Bit,
+  kUpb_MiniTablePlatform_Native =
+      UPB_SIZE(kUpb_MiniTablePlatform_32Bit, kUpb_MiniTablePlatform_64Bit),
+} upb_MiniTablePlatform;
+
+// Builds a mini table from the data encoded in the buffer [data, len]. If any
+// errors occur, returns NULL and sets a status message. In the success case,
+// the caller must call upb_MiniTable_SetSub*() for all message or proto2 enum
+// fields to link the table to the appropriate sub-tables.
+upb_MiniTable* upb_MiniTable_Build(const char* data, size_t len,
+                                   upb_MiniTablePlatform platform,
+                                   upb_Arena* arena, upb_Status* status);
+void upb_MiniTable_SetSubMessage(upb_MiniTable* table,
+                                 upb_MiniTable_Field* field,
+                                 const upb_MiniTable* sub);
+void upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTable_Field* field,
+                              const upb_MiniTable_Enum* sub);
+
+bool upb_MiniTable_BuildExtension(const char* data, size_t len,
+                                  upb_MiniTable_Extension* ext,
+                                  upb_MiniTable_Sub sub, upb_Status* status);
+
+// Special-case functions for MessageSet layout and map entries.
+upb_MiniTable* upb_MiniTable_BuildMessageSet(upb_MiniTablePlatform platform,
+                                             upb_Arena* arena);
+upb_MiniTable* upb_MiniTable_BuildMapEntry(upb_FieldType key_type,
+                                           upb_FieldType value_type,
+                                           bool value_is_proto3_enum,
+                                           upb_MiniTablePlatform platform,
+                                           upb_Arena* arena);
+
+upb_MiniTable_Enum* upb_MiniTable_BuildEnum(const char* data, size_t len,
+                                            upb_Arena* arena,
+                                            upb_Status* status);
+
+// Like upb_MiniTable_Build(), but the user provides a buffer of layout data so
+// it can be reused from call to call, avoiding repeated realloc()/free().
+//
+// The caller owns `*buf` both before and after the call, and must free() it
+// when it is no longer in use.  The function will realloc() `*buf` as
+// necessary, updating `*size` accordingly.
+upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len,
+                                          upb_MiniTablePlatform platform,
+                                          upb_Arena* arena, void** buf,
+                                          size_t* buf_size, upb_Status* status);
+
+// For testing only.
+char upb_ToBase92(int8_t ch);
+char upb_FromBase92(uint8_t ch);
+bool upb_IsTypePackable(upb_FieldType type);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_MINI_TABLE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/mini_table.hpp b/CAPI/cpp/grpc/include/upb/mini_table.hpp
new file mode 100644
index 0000000..57de9e9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/mini_table.hpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_MINI_TABLE_HPP_
+#define UPB_MINI_TABLE_HPP_
+
+#include <assert.h>
+
+#include <string>
+
+#include "upb/mini_table.h"
+
+namespace upb {
+
+class MtDataEncoder {
+ public:
+  MtDataEncoder() : appender_(&encoder_) {}
+
+  bool StartMessage(uint64_t msg_mod) {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_StartMessage(&encoder_, buf, msg_mod);
+    });
+  }
+
+  bool PutField(upb_FieldType type, uint32_t field_num, uint64_t field_mod) {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_PutField(&encoder_, buf, type, field_num,
+                                        field_mod);
+    });
+  }
+
+  bool StartOneof() {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_StartOneof(&encoder_, buf);
+    });
+  }
+
+  bool PutOneofField(uint32_t field_num) {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_PutOneofField(&encoder_, buf, field_num);
+    });
+  }
+
+  void StartEnum() { upb_MtDataEncoder_StartEnum(&encoder_); }
+
+  bool PutEnumValue(uint32_t enum_value) {
+    return appender_([=](char* buf) {
+      return upb_MtDataEncoder_PutEnumValue(&encoder_, buf, enum_value);
+    });
+  }
+
+  bool EndEnum() {
+    return appender_(
+        [=](char* buf) { return upb_MtDataEncoder_EndEnum(&encoder_, buf); });
+  }
+
+  const std::string& data() const { return appender_.data(); }
+
+ private:
+  class StringAppender {
+   public:
+    StringAppender(upb_MtDataEncoder* e) { e->end = buf_ + sizeof(buf_); }
+
+    template <class T>
+    bool operator()(T&& func) {
+      char* end = func(buf_);
+      if (!end) return false;
+      // C++ does not guarantee that string has doubling growth behavior, but
+      // we need it to avoid O(n^2).
+      str_.reserve(_upb_Log2CeilingSize(str_.size() + (end - buf_)));
+      str_.append(buf_, end - buf_);
+      return true;
+    }
+
+    const std::string& data() const { return str_; }
+
+   private:
+    char buf_[kUpb_MtDataEncoder_MinSize];
+    std::string str_;
+  };
+
+  upb_MtDataEncoder encoder_;
+  StringAppender appender_;
+};
+
+}  // namespace upb
+
+#endif /* UPB_MINI_TABLE_HPP_ */
diff --git a/CAPI/cpp/grpc/include/upb/mini_table_accessors.h b/CAPI/cpp/grpc/include/upb/mini_table_accessors.h
new file mode 100644
index 0000000..750f66f
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/mini_table_accessors.h
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) 2009-2022, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_MINI_TABLE_ACCESSORS_H_
+#define UPB_MINI_TABLE_ACCESSORS_H_
+
+#include "upb/array.h"
+#include "upb/internal/mini_table_accessors.h"
+#include "upb/msg_internal.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool upb_MiniTable_HasField(const upb_Message* msg,
+                            const upb_MiniTable_Field* field);
+
+void upb_MiniTable_ClearField(upb_Message* msg,
+                              const upb_MiniTable_Field* field);
+
+UPB_INLINE bool upb_MiniTable_GetBool(const upb_Message* msg,
+                                      const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bool);
+  return *UPB_PTR_AT(msg, field->offset, bool);
+}
+
+UPB_INLINE void upb_MiniTable_SetBool(upb_Message* msg,
+                                      const upb_MiniTable_Field* field,
+                                      bool value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bool);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, bool) = value;
+}
+
+UPB_INLINE int32_t upb_MiniTable_GetInt32(const upb_Message* msg,
+                                          const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int32 ||
+             field->descriptortype == kUpb_FieldType_SInt32 ||
+             field->descriptortype == kUpb_FieldType_SFixed32);
+  return *UPB_PTR_AT(msg, field->offset, int32_t);
+}
+
+UPB_INLINE void upb_MiniTable_SetInt32(upb_Message* msg,
+                                       const upb_MiniTable_Field* field,
+                                       int32_t value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int32 ||
+             field->descriptortype == kUpb_FieldType_SInt32 ||
+             field->descriptortype == kUpb_FieldType_SFixed32);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, int32_t) = value;
+}
+
+UPB_INLINE uint32_t upb_MiniTable_GetUInt32(const upb_Message* msg,
+                                            const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt32 ||
+             field->descriptortype == kUpb_FieldType_Fixed32);
+  return *UPB_PTR_AT(msg, field->offset, uint32_t);
+}
+
+UPB_INLINE void upb_MiniTable_SetUInt32(upb_Message* msg,
+                                        const upb_MiniTable_Field* field,
+                                        uint32_t value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt32 ||
+             field->descriptortype == kUpb_FieldType_Fixed32);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, uint32_t) = value;
+}
+
+UPB_INLINE int32_t upb_MiniTable_GetEnum(const upb_Message* msg,
+                                         const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Enum);
+  return *UPB_PTR_AT(msg, field->offset, int32_t);
+}
+
+UPB_INLINE void upb_MiniTable_SetEnum(upb_Message* msg,
+                                      const upb_MiniTable_Field* field,
+                                      int32_t value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Enum);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, int32_t) = value;
+}
+
+UPB_INLINE int64_t upb_MiniTable_GetInt64(const upb_Message* msg,
+                                          const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int64 ||
+             field->descriptortype == kUpb_FieldType_SInt64 ||
+             field->descriptortype == kUpb_FieldType_SFixed64);
+  return *UPB_PTR_AT(msg, field->offset, int64_t);
+}
+
+UPB_INLINE void upb_MiniTable_SetInt64(upb_Message* msg,
+                                       const upb_MiniTable_Field* field,
+                                       int64_t value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int64 ||
+             field->descriptortype == kUpb_FieldType_SInt64 ||
+             field->descriptortype == kUpb_FieldType_SFixed64);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, int64_t) = value;
+}
+
+UPB_INLINE uint64_t upb_MiniTable_GetUInt64(const upb_Message* msg,
+                                            const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt64 ||
+             field->descriptortype == kUpb_FieldType_Fixed64);
+  return *UPB_PTR_AT(msg, field->offset, uint64_t);
+}
+
+UPB_INLINE void upb_MiniTable_SetUInt64(upb_Message* msg,
+                                        const upb_MiniTable_Field* field,
+                                        uint64_t value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt64 ||
+             field->descriptortype == kUpb_FieldType_Fixed64);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, uint64_t) = value;
+}
+
+UPB_INLINE float upb_MiniTable_GetFloat(const upb_Message* msg,
+                                        const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Float);
+  return *UPB_PTR_AT(msg, field->offset, float);
+}
+
+UPB_INLINE void upb_MiniTable_SetFloat(upb_Message* msg,
+                                       const upb_MiniTable_Field* field,
+                                       float value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Float);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, float) = value;
+}
+
+UPB_INLINE double upb_MiniTable_GetDouble(const upb_Message* msg,
+                                          const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Double);
+  return *UPB_PTR_AT(msg, field->offset, double);
+}
+
+UPB_INLINE void upb_MiniTable_SetDouble(upb_Message* msg,
+                                        const upb_MiniTable_Field* field,
+                                        double value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Double);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, double) = value;
+}
+
+UPB_INLINE upb_StringView upb_MiniTable_GetString(
+    const upb_Message* msg, const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bytes ||
+             field->descriptortype == kUpb_FieldType_String);
+  return *UPB_PTR_AT(msg, field->offset, upb_StringView);
+}
+
+UPB_INLINE void upb_MiniTable_SetString(upb_Message* msg,
+                                        const upb_MiniTable_Field* field,
+                                        upb_StringView value) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bytes ||
+             field->descriptortype == kUpb_FieldType_String);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, upb_StringView) = value;
+}
+
+UPB_INLINE const upb_Message* upb_MiniTable_GetMessage(
+    const upb_Message* msg, const upb_MiniTable_Field* field) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
+             field->descriptortype == kUpb_FieldType_Group);
+  return *UPB_PTR_AT(msg, field->offset, const upb_Message*);
+}
+
+UPB_INLINE void upb_MiniTable_SetMessage(upb_Message* msg,
+                                         const upb_MiniTable_Field* field,
+                                         upb_Message* sub_message) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
+             field->descriptortype == kUpb_FieldType_Group);
+  _upb_MiniTable_SetPresence(msg, field);
+  *UPB_PTR_AT(msg, field->offset, const upb_Message*) = sub_message;
+}
+
+UPB_INLINE upb_Message* upb_MiniTable_GetMutableMessage(
+    upb_Message* msg, const upb_MiniTable* mini_table,
+    const upb_MiniTable_Field* field, upb_Arena* arena) {
+  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
+             field->descriptortype == kUpb_FieldType_Group);
+  upb_Message* sub_message = *UPB_PTR_AT(msg, field->offset, upb_Message*);
+  if (!sub_message) {
+    sub_message =
+        _upb_Message_New(mini_table->subs[field->submsg_index].submsg, arena);
+    *UPB_PTR_AT(msg, field->offset, upb_Message*) = sub_message;
+    _upb_MiniTable_SetPresence(msg, field);
+  }
+  return sub_message;
+}
+
+UPB_INLINE const upb_Array* upb_MiniTable_GetArray(
+    const upb_Message* msg, const upb_MiniTable_Field* field) {
+  return (const upb_Array*)*UPB_PTR_AT(msg, field->offset, upb_Array*);
+}
+
+UPB_INLINE upb_Array* upb_MiniTable_GetMutableArray(
+    upb_Message* msg, const upb_MiniTable_Field* field) {
+  return (upb_Array*)*UPB_PTR_AT(msg, field->offset, upb_Array*);
+}
+
+void* upb_MiniTable_ResizeArray(upb_Message* msg,
+                                const upb_MiniTable_Field* field, size_t len,
+                                upb_Arena* arena);
+typedef enum {
+  kUpb_GetExtension_Ok,
+  kUpb_GetExtension_NotPresent,
+  kUpb_GetExtension_ParseError,
+  kUpb_GetExtension_OutOfMemory,
+} upb_GetExtension_Status;
+
+typedef enum {
+  kUpb_GetExtensionAsBytes_Ok,
+  kUpb_GetExtensionAsBytes_NotPresent,
+  kUpb_GetExtensionAsBytes_EncodeError,
+} upb_GetExtensionAsBytes_Status;
+
+// Returns a message extension or promotes an unknown field to
+// an extension.
+//
+// TODO(ferhat): Only supports extension fields that are messages,
+// expand support to include non-message types.
+upb_GetExtension_Status upb_MiniTable_GetOrPromoteExtension(
+    upb_Message* msg, const upb_MiniTable_Extension* ext_table,
+    int decode_options, upb_Arena* arena,
+    const upb_Message_Extension** extension);
+
+// Returns a message extension or unknown field matching the extension
+// data as bytes.
+//
+// If an extension has already been decoded it will be re-encoded
+// to bytes.
+upb_GetExtensionAsBytes_Status upb_MiniTable_GetExtensionAsBytes(
+    const upb_Message* msg, const upb_MiniTable_Extension* ext_table,
+    int encode_options, upb_Arena* arena, const char** extension_data,
+    size_t* len);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif  // UPB_MINI_TABLE_ACCESSORS_H_
diff --git a/CAPI/cpp/grpc/include/upb/mini_table_accessors_internal.h b/CAPI/cpp/grpc/include/upb/mini_table_accessors_internal.h
new file mode 100644
index 0000000..8368b65
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/mini_table_accessors_internal.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2009-2022, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_MINI_TABLE_ACCESSORS_INTERNAL_H_
+#define UPB_MINI_TABLE_ACCESSORS_INTERNAL_H_
+
+// TODO(b/232091617): Delete this entire header which currently exists only for
+// temporary backwards compatibility.
+
+#include "upb/internal/mini_table_accessors.h"
+
+#endif  // UPB_MINI_TABLE_ACCESSORS_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/upb/msg.h b/CAPI/cpp/grpc/include/upb/msg.h
new file mode 100644
index 0000000..5c1e8e8
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/msg.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Public APIs for message operations that do not require descriptors.
+ * These functions can be used even in build that does not want to depend on
+ * reflection or descriptors.
+ *
+ * Descriptor-based reflection functionality lives in reflection.h.
+ */
+
+#ifndef UPB_MSG_H_
+#define UPB_MSG_H_
+
+#include <stddef.h>
+
+// TODO(b/232091617): Remove this and fix everything that breaks as a result.
+#include "upb/extension_registry.h"
+#include "upb/upb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void upb_Message;
+
+/* For users these are opaque. They can be obtained from
+ * upb_MessageDef_MiniTable() but users cannot access any of the members. */
+struct upb_MiniTable;
+typedef struct upb_MiniTable upb_MiniTable;
+
+/* Adds unknown data (serialized protobuf data) to the given message.  The data
+ * is copied into the message instance. */
+void upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len,
+                            upb_Arena* arena);
+
+/* Returns a reference to the message's unknown data. */
+const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len);
+
+/* Returns the number of extensions present in this message. */
+size_t upb_Message_ExtensionCount(const upb_Message* msg);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_MSG_INT_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/msg_internal.h b/CAPI/cpp/grpc/include/upb/msg_internal.h
new file mode 100644
index 0000000..4f5c479
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/msg_internal.h
@@ -0,0 +1,837 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+** Our memory representation for parsing tables and messages themselves.
+** Functions in this file are used by generated code and possibly reflection.
+**
+** The definitions in this file are internal to upb.
+**/
+
+#ifndef UPB_MSG_INT_H_
+#define UPB_MSG_INT_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "upb/extension_registry.h"
+#include "upb/internal/table.h"
+#include "upb/msg.h"
+#include "upb/upb.h"
+
+/* Must be last. */
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** upb_*Int* conversion routines ********************************************/
+
+UPB_INLINE int32_t _upb_Int32_FromI(int v) { return (int32_t)v; }
+
+UPB_INLINE int64_t _upb_Int64_FromLL(long long v) { return (int64_t)v; }
+
+UPB_INLINE uint32_t _upb_UInt32_FromU(unsigned v) { return (uint32_t)v; }
+
+UPB_INLINE uint64_t _upb_UInt64_FromULL(unsigned long long v) {
+  return (uint64_t)v;
+}
+
+/** upb_MiniTable *************************************************************/
+
+/* upb_MiniTable represents the memory layout of a given upb_MessageDef.  The
+ * members are public so generated code can initialize them, but users MUST NOT
+ * read or write any of its members. */
+
+typedef struct {
+  uint32_t number;
+  uint16_t offset;
+  int16_t presence;       // If >0, hasbit_index.  If <0, ~oneof_index
+  uint16_t submsg_index;  // kUpb_NoSub if descriptortype != MESSAGE/GROUP/ENUM
+  uint8_t descriptortype;
+  uint8_t mode; /* upb_FieldMode | upb_LabelFlags |
+                   (upb_FieldRep << kUpb_FieldRep_Shift) */
+} upb_MiniTable_Field;
+
+#define kUpb_NoSub ((uint16_t)-1)
+
+typedef enum {
+  kUpb_FieldMode_Map = 0,
+  kUpb_FieldMode_Array = 1,
+  kUpb_FieldMode_Scalar = 2,
+} upb_FieldMode;
+
+// Mask to isolate the upb_FieldMode from field.mode.
+#define kUpb_FieldMode_Mask 3
+
+/* Extra flags on the mode field. */
+typedef enum {
+  kUpb_LabelFlags_IsPacked = 4,
+  kUpb_LabelFlags_IsExtension = 8,
+} upb_LabelFlags;
+
+// Note: we sort by this number when calculating layout order.
+typedef enum {
+  kUpb_FieldRep_1Byte = 0,
+  kUpb_FieldRep_4Byte = 1,
+  kUpb_FieldRep_StringView = 2,
+  kUpb_FieldRep_Pointer = 3,
+  kUpb_FieldRep_8Byte = 4,
+
+  kUpb_FieldRep_Shift = 5,  // Bit offset of the rep in upb_MiniTable_Field.mode
+  kUpb_FieldRep_Max = kUpb_FieldRep_8Byte,
+} upb_FieldRep;
+
+UPB_INLINE upb_FieldMode upb_FieldMode_Get(const upb_MiniTable_Field* field) {
+  return (upb_FieldMode)(field->mode & 3);
+}
+
+UPB_INLINE bool upb_IsRepeatedOrMap(const upb_MiniTable_Field* field) {
+  /* This works because upb_FieldMode has no value 3. */
+  return !(field->mode & kUpb_FieldMode_Scalar);
+}
+
+UPB_INLINE bool upb_IsSubMessage(const upb_MiniTable_Field* field) {
+  return field->descriptortype == kUpb_FieldType_Message ||
+         field->descriptortype == kUpb_FieldType_Group;
+}
+
+struct upb_Decoder;
+struct upb_MiniTable;
+
+typedef const char* _upb_FieldParser(struct upb_Decoder* d, const char* ptr,
+                                     upb_Message* msg, intptr_t table,
+                                     uint64_t hasbits, uint64_t data);
+
+typedef struct {
+  uint64_t field_data;
+  _upb_FieldParser* field_parser;
+} _upb_FastTable_Entry;
+
+typedef struct {
+  const int32_t* values;  // List of values <0 or >63
+  uint64_t mask;          // Bits are set for acceptable value 0 <= x < 64
+  int value_count;
+} upb_MiniTable_Enum;
+
+typedef union {
+  const struct upb_MiniTable* submsg;
+  const upb_MiniTable_Enum* subenum;
+} upb_MiniTable_Sub;
+
+typedef enum {
+  kUpb_ExtMode_NonExtendable = 0,  // Non-extendable message.
+  kUpb_ExtMode_Extendable = 1,     // Normal extendable message.
+  kUpb_ExtMode_IsMessageSet = 2,   // MessageSet message.
+  kUpb_ExtMode_IsMessageSet_ITEM =
+      3,  // MessageSet item (temporary only, see decode.c)
+
+  // During table building we steal a bit to indicate that the message is a map
+  // entry.  *Only* used during table building!
+  kUpb_ExtMode_IsMapEntry = 4,
+} upb_ExtMode;
+
+/* MessageSet wire format is:
+ *   message MessageSet {
+ *     repeated group Item = 1 {
+ *       required int32 type_id = 2;
+ *       required bytes message = 3;
+ *     }
+ *   }
+ */
+typedef enum {
+  _UPB_MSGSET_ITEM = 1,
+  _UPB_MSGSET_TYPEID = 2,
+  _UPB_MSGSET_MESSAGE = 3,
+} upb_msgext_fieldnum;
+
+struct upb_MiniTable {
+  const upb_MiniTable_Sub* subs;
+  const upb_MiniTable_Field* fields;
+  /* Must be aligned to sizeof(void*).  Doesn't include internal members like
+   * unknown fields, extension dict, pointer to msglayout, etc. */
+  uint16_t size;
+  uint16_t field_count;
+  uint8_t ext;  // upb_ExtMode, declared as uint8_t so sizeof(ext) == 1
+  uint8_t dense_below;
+  uint8_t table_mask;
+  uint8_t required_count;  // Required fields have the lowest hasbits.
+  /* To statically initialize the tables of variable length, we need a flexible
+   * array member, and we need to compile in gnu99 mode (constant initialization
+   * of flexible array members is a GNU extension, not in C99 unfortunately. */
+  _upb_FastTable_Entry fasttable[];
+};
+
+typedef struct {
+  upb_MiniTable_Field field;
+  const upb_MiniTable* extendee;
+  upb_MiniTable_Sub sub; /* NULL unless submessage or proto2 enum */
+} upb_MiniTable_Extension;
+
+typedef struct {
+  const upb_MiniTable** msgs;
+  const upb_MiniTable_Enum** enums;
+  const upb_MiniTable_Extension** exts;
+  int msg_count;
+  int enum_count;
+  int ext_count;
+} upb_MiniTable_File;
+
+// Computes a bitmask in which the |l->required_count| lowest bits are set,
+// except that we skip the lowest bit (because upb never uses hasbit 0).
+//
+// Sample output:
+//    requiredmask(1) => 0b10 (0x2)
+//    requiredmask(5) => 0b111110 (0x3e)
+UPB_INLINE uint64_t upb_MiniTable_requiredmask(const upb_MiniTable* l) {
+  int n = l->required_count;
+  assert(0 < n && n <= 63);
+  return ((1ULL << n) - 1) << 1;
+}
+
+/** upb_ExtensionRegistry *****************************************************/
+
+/* Adds the given extension info for message type |l| and field number |num|
+ * into the registry. Returns false if this message type and field number were
+ * already in the map, or if memory allocation fails. */
+bool _upb_extreg_add(upb_ExtensionRegistry* r,
+                     const upb_MiniTable_Extension** e, size_t count);
+
+/* Looks up the extension (if any) defined for message type |l| and field
+ * number |num|.  If an extension was found, copies the field info into |*ext|
+ * and returns true. Otherwise returns false. */
+const upb_MiniTable_Extension* _upb_extreg_get(const upb_ExtensionRegistry* r,
+                                               const upb_MiniTable* l,
+                                               uint32_t num);
+
+/** upb_Message ***************************************************************/
+
+/* Internal members of a upb_Message that track unknown fields and/or
+ * extensions. We can change this without breaking binary compatibility.  We put
+ * these before the user's data.  The user's upb_Message* points after the
+ * upb_Message_Internal. */
+
+typedef struct {
+  /* Total size of this structure, including the data that follows.
+   * Must be aligned to 8, which is alignof(upb_Message_Extension) */
+  uint32_t size;
+
+  /* Offsets relative to the beginning of this structure.
+   *
+   * Unknown data grows forward from the beginning to unknown_end.
+   * Extension data grows backward from size to ext_begin.
+   * When the two meet, we're out of data and have to realloc.
+   *
+   * If we imagine that the final member of this struct is:
+   *   char data[size - overhead];  // overhead =
+   * sizeof(upb_Message_InternalData)
+   *
+   * Then we have:
+   *   unknown data: data[0 .. (unknown_end - overhead)]
+   *   extensions data: data[(ext_begin - overhead) .. (size - overhead)] */
+  uint32_t unknown_end;
+  uint32_t ext_begin;
+  /* Data follows, as if there were an array:
+   *   char data[size - sizeof(upb_Message_InternalData)]; */
+} upb_Message_InternalData;
+
+typedef struct {
+  upb_Message_InternalData* internal;
+  /* Message data follows. */
+} upb_Message_Internal;
+
+/* Maps upb_CType -> memory size. */
+extern char _upb_CTypeo_size[12];
+
+UPB_INLINE size_t upb_msg_sizeof(const upb_MiniTable* l) {
+  return l->size + sizeof(upb_Message_Internal);
+}
+
+UPB_INLINE upb_Message* _upb_Message_New_inl(const upb_MiniTable* l,
+                                             upb_Arena* a) {
+  size_t size = upb_msg_sizeof(l);
+  void* mem = upb_Arena_Malloc(a, size + sizeof(upb_Message_Internal));
+  upb_Message* msg;
+  if (UPB_UNLIKELY(!mem)) return NULL;
+  msg = UPB_PTR_AT(mem, sizeof(upb_Message_Internal), upb_Message);
+  memset(mem, 0, size);
+  return msg;
+}
+
+/* Creates a new messages with the given layout on the given arena. */
+upb_Message* _upb_Message_New(const upb_MiniTable* l, upb_Arena* a);
+
+UPB_INLINE upb_Message_Internal* upb_Message_Getinternal(upb_Message* msg) {
+  ptrdiff_t size = sizeof(upb_Message_Internal);
+  return (upb_Message_Internal*)((char*)msg - size);
+}
+
+/* Clears the given message. */
+void _upb_Message_Clear(upb_Message* msg, const upb_MiniTable* l);
+
+/* Discards the unknown fields for this message only. */
+void _upb_Message_DiscardUnknown_shallow(upb_Message* msg);
+
+/* Adds unknown data (serialized protobuf data) to the given message.  The data
+ * is copied into the message instance. */
+bool _upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len,
+                             upb_Arena* arena);
+
+/** upb_Message_Extension *****************************************************/
+
+/* The internal representation of an extension is self-describing: it contains
+ * enough information that we can serialize it to binary format without needing
+ * to look it up in a upb_ExtensionRegistry.
+ *
+ * This representation allocates 16 bytes to data on 64-bit platforms.  This is
+ * rather wasteful for scalars (in the extreme case of bool, it wastes 15
+ * bytes). We accept this because we expect messages to be the most common
+ * extension type. */
+typedef struct {
+  const upb_MiniTable_Extension* ext;
+  union {
+    upb_StringView str;
+    void* ptr;
+    char scalar_data[8];
+  } data;
+} upb_Message_Extension;
+
+/* Adds the given extension data to the given message. |ext| is copied into the
+ * message instance. This logically replaces any previously-added extension with
+ * this number */
+upb_Message_Extension* _upb_Message_GetOrCreateExtension(
+    upb_Message* msg, const upb_MiniTable_Extension* ext, upb_Arena* arena);
+
+/* Returns an array of extensions for this message. Note: the array is
+ * ordered in reverse relative to the order of creation. */
+const upb_Message_Extension* _upb_Message_Getexts(const upb_Message* msg,
+                                                  size_t* count);
+
+/* Returns an extension for the given field number, or NULL if no extension
+ * exists for this field number. */
+const upb_Message_Extension* _upb_Message_Getext(
+    const upb_Message* msg, const upb_MiniTable_Extension* ext);
+
+void _upb_Message_Clearext(upb_Message* msg,
+                           const upb_MiniTable_Extension* ext);
+
+void _upb_Message_Clearext(upb_Message* msg,
+                           const upb_MiniTable_Extension* ext);
+
+/** Hasbit access *************************************************************/
+
+UPB_INLINE bool _upb_hasbit(const upb_Message* msg, size_t idx) {
+  return (*UPB_PTR_AT(msg, idx / 8, const char) & (1 << (idx % 8))) != 0;
+}
+
+UPB_INLINE void _upb_sethas(const upb_Message* msg, size_t idx) {
+  (*UPB_PTR_AT(msg, idx / 8, char)) |= (char)(1 << (idx % 8));
+}
+
+UPB_INLINE void _upb_clearhas(const upb_Message* msg, size_t idx) {
+  (*UPB_PTR_AT(msg, idx / 8, char)) &= (char)(~(1 << (idx % 8)));
+}
+
+UPB_INLINE size_t _upb_Message_Hasidx(const upb_MiniTable_Field* f) {
+  UPB_ASSERT(f->presence > 0);
+  return f->presence;
+}
+
+UPB_INLINE bool _upb_hasbit_field(const upb_Message* msg,
+                                  const upb_MiniTable_Field* f) {
+  return _upb_hasbit(msg, _upb_Message_Hasidx(f));
+}
+
+UPB_INLINE void _upb_sethas_field(const upb_Message* msg,
+                                  const upb_MiniTable_Field* f) {
+  _upb_sethas(msg, _upb_Message_Hasidx(f));
+}
+
+UPB_INLINE void _upb_clearhas_field(const upb_Message* msg,
+                                    const upb_MiniTable_Field* f) {
+  _upb_clearhas(msg, _upb_Message_Hasidx(f));
+}
+
+/** Oneof case access *********************************************************/
+
+UPB_INLINE uint32_t* _upb_oneofcase(upb_Message* msg, size_t case_ofs) {
+  return UPB_PTR_AT(msg, case_ofs, uint32_t);
+}
+
+UPB_INLINE uint32_t _upb_getoneofcase(const void* msg, size_t case_ofs) {
+  return *UPB_PTR_AT(msg, case_ofs, uint32_t);
+}
+
+UPB_INLINE size_t _upb_oneofcase_ofs(const upb_MiniTable_Field* f) {
+  UPB_ASSERT(f->presence < 0);
+  return ~(ptrdiff_t)f->presence;
+}
+
+UPB_INLINE uint32_t* _upb_oneofcase_field(upb_Message* msg,
+                                          const upb_MiniTable_Field* f) {
+  return _upb_oneofcase(msg, _upb_oneofcase_ofs(f));
+}
+
+UPB_INLINE uint32_t _upb_getoneofcase_field(const upb_Message* msg,
+                                            const upb_MiniTable_Field* f) {
+  return _upb_getoneofcase(msg, _upb_oneofcase_ofs(f));
+}
+
+UPB_INLINE bool _upb_has_submsg_nohasbit(const upb_Message* msg, size_t ofs) {
+  return *UPB_PTR_AT(msg, ofs, const upb_Message*) != NULL;
+}
+
+/** upb_Array *****************************************************************/
+
+/* Our internal representation for repeated fields.  */
+typedef struct {
+  uintptr_t data; /* Tagged ptr: low 3 bits of ptr are lg2(elem size). */
+  size_t len;     /* Measured in elements. */
+  size_t size;    /* Measured in elements. */
+  uint64_t junk;
+} upb_Array;
+
+UPB_INLINE const void* _upb_array_constptr(const upb_Array* arr) {
+  UPB_ASSERT((arr->data & 7) <= 4);
+  return (void*)(arr->data & ~(uintptr_t)7);
+}
+
+UPB_INLINE uintptr_t _upb_array_tagptr(void* ptr, int elem_size_lg2) {
+  UPB_ASSERT(elem_size_lg2 <= 4);
+  return (uintptr_t)ptr | elem_size_lg2;
+}
+
+UPB_INLINE void* _upb_array_ptr(upb_Array* arr) {
+  return (void*)_upb_array_constptr(arr);
+}
+
+UPB_INLINE uintptr_t _upb_tag_arrptr(void* ptr, int elem_size_lg2) {
+  UPB_ASSERT(elem_size_lg2 <= 4);
+  UPB_ASSERT(((uintptr_t)ptr & 7) == 0);
+  return (uintptr_t)ptr | (unsigned)elem_size_lg2;
+}
+
+UPB_INLINE upb_Array* _upb_Array_New(upb_Arena* a, size_t init_size,
+                                     int elem_size_lg2) {
+  const size_t arr_size = UPB_ALIGN_UP(sizeof(upb_Array), 8);
+  const size_t bytes = sizeof(upb_Array) + (init_size << elem_size_lg2);
+  upb_Array* arr = (upb_Array*)upb_Arena_Malloc(a, bytes);
+  if (!arr) return NULL;
+  arr->data = _upb_tag_arrptr(UPB_PTR_AT(arr, arr_size, void), elem_size_lg2);
+  arr->len = 0;
+  arr->size = init_size;
+  return arr;
+}
+
+/* Resizes the capacity of the array to be at least min_size. */
+bool _upb_array_realloc(upb_Array* arr, size_t min_size, upb_Arena* arena);
+
+/* Fallback functions for when the accessors require a resize. */
+void* _upb_Array_Resize_fallback(upb_Array** arr_ptr, size_t size,
+                                 int elem_size_lg2, upb_Arena* arena);
+bool _upb_Array_Append_fallback(upb_Array** arr_ptr, const void* value,
+                                int elem_size_lg2, upb_Arena* arena);
+
+UPB_INLINE bool _upb_array_reserve(upb_Array* arr, size_t size,
+                                   upb_Arena* arena) {
+  if (arr->size < size) return _upb_array_realloc(arr, size, arena);
+  return true;
+}
+
+UPB_INLINE bool _upb_Array_Resize(upb_Array* arr, size_t size,
+                                  upb_Arena* arena) {
+  if (!_upb_array_reserve(arr, size, arena)) return false;
+  arr->len = size;
+  return true;
+}
+
+UPB_INLINE void _upb_array_detach(const void* msg, size_t ofs) {
+  *UPB_PTR_AT(msg, ofs, upb_Array*) = NULL;
+}
+
+UPB_INLINE const void* _upb_array_accessor(const void* msg, size_t ofs,
+                                           size_t* size) {
+  const upb_Array* arr = *UPB_PTR_AT(msg, ofs, const upb_Array*);
+  if (arr) {
+    if (size) *size = arr->len;
+    return _upb_array_constptr(arr);
+  } else {
+    if (size) *size = 0;
+    return NULL;
+  }
+}
+
+UPB_INLINE void* _upb_array_mutable_accessor(void* msg, size_t ofs,
+                                             size_t* size) {
+  upb_Array* arr = *UPB_PTR_AT(msg, ofs, upb_Array*);
+  if (arr) {
+    if (size) *size = arr->len;
+    return _upb_array_ptr(arr);
+  } else {
+    if (size) *size = 0;
+    return NULL;
+  }
+}
+
+UPB_INLINE void* _upb_Array_Resize_accessor2(void* msg, size_t ofs, size_t size,
+                                             int elem_size_lg2,
+                                             upb_Arena* arena) {
+  upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
+  upb_Array* arr = *arr_ptr;
+  if (!arr || arr->size < size) {
+    return _upb_Array_Resize_fallback(arr_ptr, size, elem_size_lg2, arena);
+  }
+  arr->len = size;
+  return _upb_array_ptr(arr);
+}
+
+UPB_INLINE bool _upb_Array_Append_accessor2(void* msg, size_t ofs,
+                                            int elem_size_lg2,
+                                            const void* value,
+                                            upb_Arena* arena) {
+  upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
+  size_t elem_size = 1 << elem_size_lg2;
+  upb_Array* arr = *arr_ptr;
+  void* ptr;
+  if (!arr || arr->len == arr->size) {
+    return _upb_Array_Append_fallback(arr_ptr, value, elem_size_lg2, arena);
+  }
+  ptr = _upb_array_ptr(arr);
+  memcpy(UPB_PTR_AT(ptr, arr->len * elem_size, char), value, elem_size);
+  arr->len++;
+  return true;
+}
+
+/* Used by old generated code, remove once all code has been regenerated. */
+UPB_INLINE int _upb_sizelg2(upb_CType type) {
+  switch (type) {
+    case kUpb_CType_Bool:
+      return 0;
+    case kUpb_CType_Float:
+    case kUpb_CType_Int32:
+    case kUpb_CType_UInt32:
+    case kUpb_CType_Enum:
+      return 2;
+    case kUpb_CType_Message:
+      return UPB_SIZE(2, 3);
+    case kUpb_CType_Double:
+    case kUpb_CType_Int64:
+    case kUpb_CType_UInt64:
+      return 3;
+    case kUpb_CType_String:
+    case kUpb_CType_Bytes:
+      return UPB_SIZE(3, 4);
+  }
+  UPB_UNREACHABLE();
+}
+UPB_INLINE void* _upb_Array_Resize_accessor(void* msg, size_t ofs, size_t size,
+                                            upb_CType type, upb_Arena* arena) {
+  return _upb_Array_Resize_accessor2(msg, ofs, size, _upb_sizelg2(type), arena);
+}
+UPB_INLINE bool _upb_Array_Append_accessor(void* msg, size_t ofs,
+                                           size_t elem_size, upb_CType type,
+                                           const void* value,
+                                           upb_Arena* arena) {
+  (void)elem_size;
+  return _upb_Array_Append_accessor2(msg, ofs, _upb_sizelg2(type), value,
+                                     arena);
+}
+
+/** upb_Map *******************************************************************/
+
+/* Right now we use strmaps for everything.  We'll likely want to use
+ * integer-specific maps for integer-keyed maps.*/
+typedef struct {
+  /* Size of key and val, based on the map type.  Strings are represented as '0'
+   * because they must be handled specially. */
+  char key_size;
+  char val_size;
+
+  upb_strtable table;
+} upb_Map;
+
+/* Map entries aren't actually stored, they are only used during parsing.  For
+ * parsing, it helps a lot if all map entry messages have the same layout.
+ * The compiler and def.c must ensure that all map entries have this layout. */
+typedef struct {
+  upb_Message_Internal internal;
+  union {
+    upb_StringView str; /* For str/bytes. */
+    upb_value val;      /* For all other types. */
+  } k;
+  union {
+    upb_StringView str; /* For str/bytes. */
+    upb_value val;      /* For all other types. */
+  } v;
+} upb_MapEntry;
+
+/* Creates a new map on the given arena with this key/value type. */
+upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size);
+
+/* Converting between internal table representation and user values.
+ *
+ * _upb_map_tokey() and _upb_map_fromkey() are inverses.
+ * _upb_map_tovalue() and _upb_map_fromvalue() are inverses.
+ *
+ * These functions account for the fact that strings are treated differently
+ * from other types when stored in a map.
+ */
+
+UPB_INLINE upb_StringView _upb_map_tokey(const void* key, size_t size) {
+  if (size == UPB_MAPTYPE_STRING) {
+    return *(upb_StringView*)key;
+  } else {
+    return upb_StringView_FromDataAndSize((const char*)key, size);
+  }
+}
+
+UPB_INLINE void _upb_map_fromkey(upb_StringView key, void* out, size_t size) {
+  if (size == UPB_MAPTYPE_STRING) {
+    memcpy(out, &key, sizeof(key));
+  } else {
+    memcpy(out, key.data, size);
+  }
+}
+
+UPB_INLINE bool _upb_map_tovalue(const void* val, size_t size,
+                                 upb_value* msgval, upb_Arena* a) {
+  if (size == UPB_MAPTYPE_STRING) {
+    upb_StringView* strp = (upb_StringView*)upb_Arena_Malloc(a, sizeof(*strp));
+    if (!strp) return false;
+    *strp = *(upb_StringView*)val;
+    *msgval = upb_value_ptr(strp);
+  } else {
+    memcpy(msgval, val, size);
+  }
+  return true;
+}
+
+UPB_INLINE void _upb_map_fromvalue(upb_value val, void* out, size_t size) {
+  if (size == UPB_MAPTYPE_STRING) {
+    const upb_StringView* strp = (const upb_StringView*)upb_value_getptr(val);
+    memcpy(out, strp, sizeof(upb_StringView));
+  } else {
+    memcpy(out, &val, size);
+  }
+}
+
+/* Map operations, shared by reflection and generated code. */
+
+UPB_INLINE size_t _upb_Map_Size(const upb_Map* map) {
+  return map->table.t.count;
+}
+
+UPB_INLINE bool _upb_Map_Get(const upb_Map* map, const void* key,
+                             size_t key_size, void* val, size_t val_size) {
+  upb_value tabval;
+  upb_StringView k = _upb_map_tokey(key, key_size);
+  bool ret = upb_strtable_lookup2(&map->table, k.data, k.size, &tabval);
+  if (ret && val) {
+    _upb_map_fromvalue(tabval, val, val_size);
+  }
+  return ret;
+}
+
+UPB_INLINE void* _upb_map_next(const upb_Map* map, size_t* iter) {
+  upb_strtable_iter it;
+  it.t = &map->table;
+  it.index = *iter;
+  upb_strtable_next(&it);
+  *iter = it.index;
+  if (upb_strtable_done(&it)) return NULL;
+  return (void*)str_tabent(&it);
+}
+
+typedef enum {
+  // LINT.IfChange
+  _kUpb_MapInsertStatus_Inserted = 0,
+  _kUpb_MapInsertStatus_Replaced = 1,
+  _kUpb_MapInsertStatus_OutOfMemory = 2,
+  // LINT.ThenChange(//depot/google3/third_party/upb/upb/map.h)
+} _upb_MapInsertStatus;
+
+UPB_INLINE _upb_MapInsertStatus _upb_Map_Insert(upb_Map* map, const void* key,
+                                                size_t key_size, void* val,
+                                                size_t val_size, upb_Arena* a) {
+  upb_StringView strkey = _upb_map_tokey(key, key_size);
+  upb_value tabval = {0};
+  if (!_upb_map_tovalue(val, val_size, &tabval, a)) {
+    return _kUpb_MapInsertStatus_OutOfMemory;
+  }
+
+  /* TODO(haberman): add overwrite operation to minimize number of lookups. */
+  bool removed =
+      upb_strtable_remove2(&map->table, strkey.data, strkey.size, NULL);
+  if (!upb_strtable_insert(&map->table, strkey.data, strkey.size, tabval, a)) {
+    return _kUpb_MapInsertStatus_OutOfMemory;
+  }
+  return removed ? _kUpb_MapInsertStatus_Replaced
+                 : _kUpb_MapInsertStatus_Inserted;
+}
+
+UPB_INLINE bool _upb_Map_Delete(upb_Map* map, const void* key,
+                                size_t key_size) {
+  upb_StringView k = _upb_map_tokey(key, key_size);
+  return upb_strtable_remove2(&map->table, k.data, k.size, NULL);
+}
+
+UPB_INLINE void _upb_Map_Clear(upb_Map* map) {
+  upb_strtable_clear(&map->table);
+}
+
+/* Message map operations, these get the map from the message first. */
+
+UPB_INLINE size_t _upb_msg_map_size(const upb_Message* msg, size_t ofs) {
+  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+  return map ? _upb_Map_Size(map) : 0;
+}
+
+UPB_INLINE bool _upb_msg_map_get(const upb_Message* msg, size_t ofs,
+                                 const void* key, size_t key_size, void* val,
+                                 size_t val_size) {
+  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+  if (!map) return false;
+  return _upb_Map_Get(map, key, key_size, val, val_size);
+}
+
+UPB_INLINE void* _upb_msg_map_next(const upb_Message* msg, size_t ofs,
+                                   size_t* iter) {
+  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+  if (!map) return NULL;
+  return _upb_map_next(map, iter);
+}
+
+UPB_INLINE bool _upb_msg_map_set(upb_Message* msg, size_t ofs, const void* key,
+                                 size_t key_size, void* val, size_t val_size,
+                                 upb_Arena* arena) {
+  upb_Map** map = UPB_PTR_AT(msg, ofs, upb_Map*);
+  if (!*map) {
+    *map = _upb_Map_New(arena, key_size, val_size);
+  }
+  return _upb_Map_Insert(*map, key, key_size, val, val_size, arena) !=
+         _kUpb_MapInsertStatus_OutOfMemory;
+}
+
+UPB_INLINE bool _upb_msg_map_delete(upb_Message* msg, size_t ofs,
+                                    const void* key, size_t key_size) {
+  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+  if (!map) return false;
+  return _upb_Map_Delete(map, key, key_size);
+}
+
+UPB_INLINE void _upb_msg_map_clear(upb_Message* msg, size_t ofs) {
+  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+  if (!map) return;
+  _upb_Map_Clear(map);
+}
+
+/* Accessing map key/value from a pointer, used by generated code only. */
+
+UPB_INLINE void _upb_msg_map_key(const void* msg, void* key, size_t size) {
+  const upb_tabent* ent = (const upb_tabent*)msg;
+  uint32_t u32len;
+  upb_StringView k;
+  k.data = upb_tabstr(ent->key, &u32len);
+  k.size = u32len;
+  _upb_map_fromkey(k, key, size);
+}
+
+UPB_INLINE void _upb_msg_map_value(const void* msg, void* val, size_t size) {
+  const upb_tabent* ent = (const upb_tabent*)msg;
+  upb_value v = {ent->val.val};
+  _upb_map_fromvalue(v, val, size);
+}
+
+UPB_INLINE void _upb_msg_map_set_value(void* msg, const void* val,
+                                       size_t size) {
+  upb_tabent* ent = (upb_tabent*)msg;
+  /* This is like _upb_map_tovalue() except the entry already exists so we can
+   * reuse the allocated upb_StringView for string fields. */
+  if (size == UPB_MAPTYPE_STRING) {
+    upb_StringView* strp = (upb_StringView*)(uintptr_t)ent->val.val;
+    memcpy(strp, val, sizeof(*strp));
+  } else {
+    memcpy(&ent->val.val, val, size);
+  }
+}
+
+/** _upb_mapsorter ************************************************************/
+
+/* _upb_mapsorter sorts maps and provides ordered iteration over the entries.
+ * Since maps can be recursive (map values can be messages which contain other
+ * maps). _upb_mapsorter can contain a stack of maps. */
+
+typedef struct {
+  upb_tabent const** entries;
+  int size;
+  int cap;
+} _upb_mapsorter;
+
+typedef struct {
+  int start;
+  int pos;
+  int end;
+} _upb_sortedmap;
+
+UPB_INLINE void _upb_mapsorter_init(_upb_mapsorter* s) {
+  s->entries = NULL;
+  s->size = 0;
+  s->cap = 0;
+}
+
+UPB_INLINE void _upb_mapsorter_destroy(_upb_mapsorter* s) {
+  if (s->entries) free(s->entries);
+}
+
+bool _upb_mapsorter_pushmap(_upb_mapsorter* s, upb_FieldType key_type,
+                            const upb_Map* map, _upb_sortedmap* sorted);
+
+UPB_INLINE void _upb_mapsorter_popmap(_upb_mapsorter* s,
+                                      _upb_sortedmap* sorted) {
+  s->size = sorted->start;
+}
+
+UPB_INLINE bool _upb_sortedmap_next(_upb_mapsorter* s, const upb_Map* map,
+                                    _upb_sortedmap* sorted, upb_MapEntry* ent) {
+  if (sorted->pos == sorted->end) return false;
+  const upb_tabent* tabent = s->entries[sorted->pos++];
+  upb_StringView key = upb_tabstrview(tabent->key);
+  _upb_map_fromkey(key, &ent->k, map->key_size);
+  upb_value val = {tabent->val.val};
+  _upb_map_fromvalue(val, &ent->v, map->val_size);
+  return true;
+}
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_MSG_INT_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/port_def.inc b/CAPI/cpp/grpc/include/upb/port_def.inc
new file mode 100644
index 0000000..92e4bf2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/port_def.inc
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * This is where we define macros used across upb.
+ *
+ * All of these macros are undef'd in port_undef.inc to avoid leaking them to
+ * users.
+ *
+ * The correct usage is:
+ *
+ *   #include "upb/foobar.h"
+ *   #include "upb/baz.h"
+ *
+ *   // MUST be last included header.
+ *   #include "upb/port_def.inc"
+ *
+ *   // Code for this file.
+ *   // <...>
+ *
+ *   // Can be omitted for .c files, required for .h.
+ *   #include "upb/port_undef.inc"
+ *
+ * This file is private and must not be included by users!
+ */
+
+#if !((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \
+      (defined(__cplusplus) && __cplusplus >= 201103L) ||           \
+      (defined(_MSC_VER) && _MSC_VER >= 1900))
+#error upb requires C99 or C++11 or MSVC >= 2015.
+#endif
+
+#include <stdint.h>
+#include <stddef.h>
+
+#if UINTPTR_MAX == 0xffffffff
+#define UPB_SIZE(size32, size64) size32
+#else
+#define UPB_SIZE(size32, size64) size64
+#endif
+
+/* If we always read/write as a consistent type to each address, this shouldn't
+ * violate aliasing.
+ */
+#define UPB_PTR_AT(msg, ofs, type) ((type*)((char*)(msg) + (ofs)))
+
+#define UPB_READ_ONEOF(msg, fieldtype, offset, case_offset, case_val, default) \
+  *UPB_PTR_AT(msg, case_offset, int) == case_val                              \
+      ? *UPB_PTR_AT(msg, offset, fieldtype)                                   \
+      : default
+
+#define UPB_WRITE_ONEOF(msg, fieldtype, offset, value, case_offset, case_val) \
+  *UPB_PTR_AT(msg, case_offset, int) = case_val;                             \
+  *UPB_PTR_AT(msg, offset, fieldtype) = value;
+
+#define UPB_MAPTYPE_STRING 0
+
+/* UPB_INLINE: inline if possible, emit standalone code if required. */
+#ifdef __cplusplus
+#define UPB_INLINE inline
+#elif defined (__GNUC__) || defined(__clang__)
+#define UPB_INLINE static __inline__
+#else
+#define UPB_INLINE static
+#endif
+
+#define UPB_MALLOC_ALIGN 8
+#define UPB_ALIGN_UP(size, align) (((size) + (align) - 1) / (align) * (align))
+#define UPB_ALIGN_DOWN(size, align) ((size) / (align) * (align))
+#define UPB_ALIGN_MALLOC(size) UPB_ALIGN_UP(size, UPB_MALLOC_ALIGN)
+#define UPB_ALIGN_OF(type) offsetof (struct { char c; type member; }, member)
+
+/* Hints to the compiler about likely/unlikely branches. */
+#if defined (__GNUC__) || defined(__clang__)
+#define UPB_LIKELY(x) __builtin_expect((x),1)
+#define UPB_UNLIKELY(x) __builtin_expect((x),0)
+#else
+#define UPB_LIKELY(x) (x)
+#define UPB_UNLIKELY(x) (x)
+#endif
+
+/* Macros for function attributes on compilers that support them. */
+#ifdef __GNUC__
+#define UPB_FORCEINLINE __inline__ __attribute__((always_inline))
+#define UPB_NOINLINE __attribute__((noinline))
+#define UPB_NORETURN __attribute__((__noreturn__))
+#define UPB_PRINTF(str, first_vararg) __attribute__((format (printf, str, first_vararg)))
+#elif defined(_MSC_VER)
+#define UPB_NOINLINE
+#define UPB_FORCEINLINE
+#define UPB_NORETURN __declspec(noreturn)
+#define UPB_PRINTF(str, first_vararg)
+#else  /* !defined(__GNUC__) */
+#define UPB_FORCEINLINE
+#define UPB_NOINLINE
+#define UPB_NORETURN
+#define UPB_PRINTF(str, first_vararg)
+#endif
+
+#define UPB_MAX(x, y) ((x) > (y) ? (x) : (y))
+#define UPB_MIN(x, y) ((x) < (y) ? (x) : (y))
+
+#define UPB_UNUSED(var) (void)var
+
+/* UPB_ASSUME(): in release mode, we tell the compiler to assume this is true.
+ */
+#ifdef NDEBUG
+#ifdef __GNUC__
+#define UPB_ASSUME(expr) if (!(expr)) __builtin_unreachable()
+#elif defined _MSC_VER
+#define UPB_ASSUME(expr) if (!(expr)) __assume(0)
+#else
+#define UPB_ASSUME(expr) do {} while (false && (expr))
+#endif
+#else
+#define UPB_ASSUME(expr) assert(expr)
+#endif
+
+/* UPB_ASSERT(): in release mode, we use the expression without letting it be
+ * evaluated.  This prevents "unused variable" warnings. */
+#ifdef NDEBUG
+#define UPB_ASSERT(expr) do {} while (false && (expr))
+#else
+#define UPB_ASSERT(expr) assert(expr)
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define UPB_UNREACHABLE() do { assert(0); __builtin_unreachable(); } while(0)
+#else
+#define UPB_UNREACHABLE() do { assert(0); } while(0)
+#endif
+
+/* UPB_SETJMP() / UPB_LONGJMP(): avoid setting/restoring signal mask. */
+#ifdef __APPLE__
+#define UPB_SETJMP(buf) _setjmp(buf)
+#define UPB_LONGJMP(buf, val) _longjmp(buf, val)
+#else
+#define UPB_SETJMP(buf) setjmp(buf)
+#define UPB_LONGJMP(buf, val) longjmp(buf, val)
+#endif
+
+/* UPB_PTRADD(ptr, ofs): add pointer while avoiding "NULL + 0" UB */
+#define UPB_PTRADD(ptr, ofs) ((ofs) ? (ptr) + (ofs) : (ptr))
+
+/* Configure whether fasttable is switched on or not. *************************/
+
+#ifdef __has_attribute
+#define UPB_HAS_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define UPB_HAS_ATTRIBUTE(x) 0
+#endif
+
+#if UPB_HAS_ATTRIBUTE(musttail)
+#define UPB_MUSTTAIL __attribute__((musttail))
+#else
+#define UPB_MUSTTAIL
+#endif
+
+#undef UPB_HAS_ATTRIBUTE
+
+/* This check is not fully robust: it does not require that we have "musttail"
+ * support available. We need tail calls to avoid consuming arbitrary amounts
+ * of stack space.
+ *
+ * GCC/Clang can mostly be trusted to generate tail calls as long as
+ * optimization is enabled, but, debug builds will not generate tail calls
+ * unless "musttail" is available.
+ *
+ * We should probably either:
+ *   1. require that the compiler supports musttail.
+ *   2. add some fallback code for when musttail isn't available (ie. return
+ *      instead of tail calling). This is safe and portable, but this comes at
+ *      a CPU cost.
+ */
+#if (defined(__x86_64__) || defined(__aarch64__)) && defined(__GNUC__)
+#define UPB_FASTTABLE_SUPPORTED 1
+#else
+#define UPB_FASTTABLE_SUPPORTED 0
+#endif
+
+/* define UPB_ENABLE_FASTTABLE to force fast table support.
+ * This is useful when we want to ensure we are really getting fasttable,
+ * for example for testing or benchmarking. */
+#if defined(UPB_ENABLE_FASTTABLE)
+#if !UPB_FASTTABLE_SUPPORTED
+#error fasttable is x86-64/ARM64 only and requires GCC or Clang.
+#endif
+#define UPB_FASTTABLE 1
+/* Define UPB_TRY_ENABLE_FASTTABLE to use fasttable if possible.
+ * This is useful for releasing code that might be used on multiple platforms,
+ * for example the PHP or Ruby C extensions. */
+#elif defined(UPB_TRY_ENABLE_FASTTABLE)
+#define UPB_FASTTABLE UPB_FASTTABLE_SUPPORTED
+#else
+#define UPB_FASTTABLE 0
+#endif
+
+/* UPB_FASTTABLE_INIT() allows protos compiled for fasttable to gracefully
+ * degrade to non-fasttable if we are using UPB_TRY_ENABLE_FASTTABLE. */
+#if !UPB_FASTTABLE && defined(UPB_TRY_ENABLE_FASTTABLE)
+#define UPB_FASTTABLE_INIT(...)
+#else
+#define UPB_FASTTABLE_INIT(...) __VA_ARGS__
+#endif
+
+#undef UPB_FASTTABLE_SUPPORTED
+
+/* ASAN poisoning (for arena) *************************************************/
+
+#if defined(__SANITIZE_ADDRESS__)
+#define UPB_ASAN 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+void __asan_poison_memory_region(void const volatile *addr, size_t size);
+void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+#define UPB_POISON_MEMORY_REGION(addr, size) \
+  __asan_poison_memory_region((addr), (size))
+#define UPB_UNPOISON_MEMORY_REGION(addr, size) \
+  __asan_unpoison_memory_region((addr), (size))
+#else
+#define UPB_ASAN 0
+#define UPB_POISON_MEMORY_REGION(addr, size) \
+  ((void)(addr), (void)(size))
+#define UPB_UNPOISON_MEMORY_REGION(addr, size) \
+  ((void)(addr), (void)(size))
+#endif
+
+/* Disable proto2 arena behavior (TEMPORARY) **********************************/
+
+#ifdef UPB_DISABLE_PROTO2_ENUM_CHECKING
+#define UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 1
+#else
+#define UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3 0
+#endif
diff --git a/CAPI/cpp/grpc/include/upb/port_undef.inc b/CAPI/cpp/grpc/include/upb/port_undef.inc
new file mode 100644
index 0000000..1dff3d2
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/port_undef.inc
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* See port_def.inc.  This should #undef all macros #defined there. */
+
+#undef UPB_SIZE
+#undef UPB_PTR_AT
+#undef UPB_READ_ONEOF
+#undef UPB_WRITE_ONEOF
+#undef UPB_MAPTYPE_STRING
+#undef UPB_INLINE
+#undef UPB_ALIGN_UP
+#undef UPB_ALIGN_DOWN
+#undef UPB_ALIGN_MALLOC
+#undef UPB_ALIGN_OF
+#undef UPB_MALLOC_ALIGN
+#undef UPB_LIKELY
+#undef UPB_UNLIKELY
+#undef UPB_FORCEINLINE
+#undef UPB_NOINLINE
+#undef UPB_NORETURN
+#undef UPB_PRINTF
+#undef UPB_MAX
+#undef UPB_MIN
+#undef UPB_UNUSED
+#undef UPB_ASSUME
+#undef UPB_ASSERT
+#undef UPB_UNREACHABLE
+#undef UPB_SETJMP
+#undef UPB_LONGJMP
+#undef UPB_PTRADD
+#undef UPB_MUSTTAIL
+#undef UPB_FASTTABLE_SUPPORTED
+#undef UPB_FASTTABLE
+#undef UPB_FASTTABLE_INIT
+#undef UPB_POISON_MEMORY_REGION
+#undef UPB_UNPOISON_MEMORY_REGION
+#undef UPB_ASAN
+#undef UPB_TREAT_PROTO2_ENUMS_LIKE_PROTO3
diff --git a/CAPI/cpp/grpc/include/upb/reflection.h b/CAPI/cpp/grpc/include/upb/reflection.h
new file mode 100644
index 0000000..6071fba
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/reflection.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_REFLECTION_H_
+#define UPB_REFLECTION_H_
+
+#include "upb/array.h"
+#include "upb/def.h"
+#include "upb/map.h"
+#include "upb/msg.h"
+#include "upb/port_def.inc"
+#include "upb/upb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+upb_MessageValue upb_FieldDef_Default(const upb_FieldDef* f);
+
+/** upb_Message
+ * *******************************************************************/
+
+/* Creates a new message of the given type in the given arena. */
+upb_Message* upb_Message_New(const upb_MessageDef* m, upb_Arena* a);
+
+/* Returns the value associated with this field. */
+upb_MessageValue upb_Message_Get(const upb_Message* msg, const upb_FieldDef* f);
+
+/* Returns a mutable pointer to a map, array, or submessage value.  If the given
+ * arena is non-NULL this will construct a new object if it was not previously
+ * present.  May not be called for primitive fields. */
+upb_MutableMessageValue upb_Message_Mutable(upb_Message* msg,
+                                            const upb_FieldDef* f,
+                                            upb_Arena* a);
+
+/* May only be called for fields where upb_FieldDef_HasPresence(f) == true. */
+bool upb_Message_Has(const upb_Message* msg, const upb_FieldDef* f);
+
+/* Returns the field that is set in the oneof, or NULL if none are set. */
+const upb_FieldDef* upb_Message_WhichOneof(const upb_Message* msg,
+                                           const upb_OneofDef* o);
+
+/* Sets the given field to the given value.  For a msg/array/map/string, the
+ * caller must ensure that the target data outlives |msg| (by living either in
+ * the same arena or a different arena that outlives it).
+ *
+ * Returns false if allocation fails. */
+bool upb_Message_Set(upb_Message* msg, const upb_FieldDef* f,
+                     upb_MessageValue val, upb_Arena* a);
+
+/* Clears any field presence and sets the value back to its default. */
+void upb_Message_ClearField(upb_Message* msg, const upb_FieldDef* f);
+
+/* Clear all data and unknown fields. */
+void upb_Message_Clear(upb_Message* msg, const upb_MessageDef* m);
+
+/* Iterate over present fields.
+ *
+ * size_t iter = kUpb_Message_Begin;
+ * const upb_FieldDef *f;
+ * upb_MessageValue val;
+ * while (upb_Message_Next(msg, m, ext_pool, &f, &val, &iter)) {
+ *   process_field(f, val);
+ * }
+ *
+ * If ext_pool is NULL, no extensions will be returned.  If the given symtab
+ * returns extensions that don't match what is in this message, those extensions
+ * will be skipped.
+ */
+
+#define kUpb_Message_Begin -1
+bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
+                      const upb_DefPool* ext_pool, const upb_FieldDef** f,
+                      upb_MessageValue* val, size_t* iter);
+
+/* Clears all unknown field data from this message and all submessages. */
+bool upb_Message_DiscardUnknown(upb_Message* msg, const upb_MessageDef* m,
+                                int maxdepth);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_REFLECTION_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/reflection.hpp b/CAPI/cpp/grpc/include/upb/reflection.hpp
new file mode 100644
index 0000000..b653893
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/reflection.hpp
@@ -0,0 +1,37 @@
+// Copyright (c) 2009-2021, Google LLC
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Google LLC nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef UPB_REFLECTION_HPP_
+#define UPB_REFLECTION_HPP_
+
+#include "upb/reflection.h"
+
+namespace upb {
+
+typedef upb_MessageValue MessageValue;
+
+}  // namespace upb
+
+#endif  // UPB_REFLECTION_HPP_
diff --git a/CAPI/cpp/grpc/include/upb/status.h b/CAPI/cpp/grpc/include/upb/status.h
new file mode 100644
index 0000000..2c5c2a7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/status.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_STATUS_H_
+#define UPB_STATUS_H_
+
+#include <stdarg.h>
+#include <stdbool.h>
+
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define _kUpb_Status_MaxMessage 127
+
+typedef struct {
+  bool ok;
+  char msg[_kUpb_Status_MaxMessage]; /* Error message; NULL-terminated. */
+} upb_Status;
+
+const char* upb_Status_ErrorMessage(const upb_Status* status);
+bool upb_Status_IsOk(const upb_Status* status);
+
+/* These are no-op if |status| is NULL. */
+void upb_Status_Clear(upb_Status* status);
+void upb_Status_SetErrorMessage(upb_Status* status, const char* msg);
+void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...)
+    UPB_PRINTF(2, 3);
+void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt,
+                                va_list args) UPB_PRINTF(2, 0);
+void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt,
+                                   va_list args) UPB_PRINTF(2, 0);
+
+#include "upb/port_undef.inc"
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_STATUS_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/table_internal.h b/CAPI/cpp/grpc/include/upb/table_internal.h
new file mode 100644
index 0000000..7ac8bf7
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/table_internal.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_TABLE_H_
+#define UPB_TABLE_H_
+
+// TODO(b/232091617): Delete this entire header which currently exists only for
+// temporary backwards compatibility.
+
+#include "upb/internal/table.h"
+
+#endif /* UPB_TABLE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/text_encode.h b/CAPI/cpp/grpc/include/upb/text_encode.h
new file mode 100644
index 0000000..2e817a3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/text_encode.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_TEXTENCODE_H_
+#define UPB_TEXTENCODE_H_
+
+#include "upb/def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  /* When set, prints everything on a single line. */
+  UPB_TXTENC_SINGLELINE = 1,
+
+  /* When set, unknown fields are not printed. */
+  UPB_TXTENC_SKIPUNKNOWN = 2,
+
+  /* When set, maps are *not* sorted (this avoids allocating tmp mem). */
+  UPB_TXTENC_NOSORT = 4
+};
+
+/* Encodes the given |msg| to text format.  The message's reflection is given in
+ * |m|.  The symtab in |symtab| is used to find extensions (if NULL, extensions
+ * will not be printed).
+ *
+ * Output is placed in the given buffer, and always NULL-terminated.  The output
+ * size (excluding NULL) is returned.  This means that a return value >= |size|
+ * implies that the output was truncated.  (These are the same semantics as
+ * snprintf()). */
+size_t upb_TextEncode(const upb_Message* msg, const upb_MessageDef* m,
+                      const upb_DefPool* ext_pool, int options, char* buf,
+                      size_t size);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_TEXTENCODE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/upb.h b/CAPI/cpp/grpc/include/upb/upb.h
new file mode 100644
index 0000000..7398d09
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/upb.h
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * This file contains shared definitions that are widely used across upb.
+ */
+
+#ifndef UPB_H_
+#define UPB_H_
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+// TODO(b/232091617): Remove these and fix everything that breaks as a result.
+#include "upb/arena.h"
+#include "upb/status.h"
+
+// Must be last.
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** upb_StringView ************************************************************/
+
+typedef struct {
+  const char* data;
+  size_t size;
+} upb_StringView;
+
+UPB_INLINE upb_StringView upb_StringView_FromDataAndSize(const char* data,
+                                                         size_t size) {
+  upb_StringView ret;
+  ret.data = data;
+  ret.size = size;
+  return ret;
+}
+
+UPB_INLINE upb_StringView upb_StringView_FromString(const char* data) {
+  return upb_StringView_FromDataAndSize(data, strlen(data));
+}
+
+UPB_INLINE bool upb_StringView_IsEqual(upb_StringView a, upb_StringView b) {
+  return a.size == b.size && memcmp(a.data, b.data, a.size) == 0;
+}
+
+#define UPB_STRINGVIEW_INIT(ptr, len) \
+  { ptr, len }
+
+#define UPB_STRINGVIEW_FORMAT "%.*s"
+#define UPB_STRINGVIEW_ARGS(view) (int)(view).size, (view).data
+
+/* Constants ******************************************************************/
+
+/* A list of types as they are encoded on-the-wire. */
+typedef enum {
+  kUpb_WireType_Varint = 0,
+  kUpb_WireType_64Bit = 1,
+  kUpb_WireType_Delimited = 2,
+  kUpb_WireType_StartGroup = 3,
+  kUpb_WireType_EndGroup = 4,
+  kUpb_WireType_32Bit = 5
+} upb_WireType;
+
+/* The types a field can have.  Note that this list is not identical to the
+ * types defined in descriptor.proto, which gives INT32 and SINT32 separate
+ * types (we distinguish the two with the "integer encoding" enum below). */
+typedef enum {
+  kUpb_CType_Bool = 1,
+  kUpb_CType_Float = 2,
+  kUpb_CType_Int32 = 3,
+  kUpb_CType_UInt32 = 4,
+  kUpb_CType_Enum = 5, /* Enum values are int32. */
+  kUpb_CType_Message = 6,
+  kUpb_CType_Double = 7,
+  kUpb_CType_Int64 = 8,
+  kUpb_CType_UInt64 = 9,
+  kUpb_CType_String = 10,
+  kUpb_CType_Bytes = 11
+} upb_CType;
+
+/* The repeated-ness of each field; this matches descriptor.proto. */
+typedef enum {
+  kUpb_Label_Optional = 1,
+  kUpb_Label_Required = 2,
+  kUpb_Label_Repeated = 3
+} upb_Label;
+
+/* Descriptor types, as defined in descriptor.proto. */
+typedef enum {
+  kUpb_FieldType_Double = 1,
+  kUpb_FieldType_Float = 2,
+  kUpb_FieldType_Int64 = 3,
+  kUpb_FieldType_UInt64 = 4,
+  kUpb_FieldType_Int32 = 5,
+  kUpb_FieldType_Fixed64 = 6,
+  kUpb_FieldType_Fixed32 = 7,
+  kUpb_FieldType_Bool = 8,
+  kUpb_FieldType_String = 9,
+  kUpb_FieldType_Group = 10,
+  kUpb_FieldType_Message = 11,
+  kUpb_FieldType_Bytes = 12,
+  kUpb_FieldType_UInt32 = 13,
+  kUpb_FieldType_Enum = 14,
+  kUpb_FieldType_SFixed32 = 15,
+  kUpb_FieldType_SFixed64 = 16,
+  kUpb_FieldType_SInt32 = 17,
+  kUpb_FieldType_SInt64 = 18
+} upb_FieldType;
+
+#define kUpb_Map_Begin ((size_t)-1)
+
+UPB_INLINE bool _upb_IsLittleEndian(void) {
+  int x = 1;
+  return *(char*)&x == 1;
+}
+
+UPB_INLINE uint32_t _upb_BigEndian_Swap32(uint32_t val) {
+  if (_upb_IsLittleEndian()) {
+    return val;
+  } else {
+    return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
+           ((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
+  }
+}
+
+UPB_INLINE uint64_t _upb_BigEndian_Swap64(uint64_t val) {
+  if (_upb_IsLittleEndian()) {
+    return val;
+  } else {
+    return ((uint64_t)_upb_BigEndian_Swap32((uint32_t)val) << 32) |
+           _upb_BigEndian_Swap32((uint32_t)(val >> 32));
+  }
+}
+
+UPB_INLINE int _upb_Log2Ceiling(int x) {
+  if (x <= 1) return 0;
+#ifdef __GNUC__
+  return 32 - __builtin_clz(x - 1);
+#else
+  int lg2 = 0;
+  while (1 << lg2 < x) lg2++;
+  return lg2;
+#endif
+}
+
+UPB_INLINE int _upb_Log2CeilingSize(int x) { return 1 << _upb_Log2Ceiling(x); }
+
+#include "upb/port_undef.inc"
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/upb.hpp b/CAPI/cpp/grpc/include/upb/upb.hpp
new file mode 100644
index 0000000..2e4a21b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/upb.hpp
@@ -0,0 +1,115 @@
+// Copyright (c) 2009-2021, Google LLC
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of Google LLC nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef UPB_HPP_
+#define UPB_HPP_
+
+#include <memory>
+
+#include "upb/upb.h"
+
+namespace upb {
+
+class Status {
+ public:
+  Status() { upb_Status_Clear(&status_); }
+
+  upb_Status* ptr() { return &status_; }
+
+  // Returns true if there is no error.
+  bool ok() const { return upb_Status_IsOk(&status_); }
+
+  // Guaranteed to be NULL-terminated.
+  const char* error_message() const {
+    return upb_Status_ErrorMessage(&status_);
+  }
+
+  // The error message will be truncated if it is longer than
+  // _kUpb_Status_MaxMessage-4.
+  void SetErrorMessage(const char* msg) {
+    upb_Status_SetErrorMessage(&status_, msg);
+  }
+  void SetFormattedErrorMessage(const char* fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    upb_Status_VSetErrorFormat(&status_, fmt, args);
+    va_end(args);
+  }
+
+  // Resets the status to a successful state with no message.
+  void Clear() { upb_Status_Clear(&status_); }
+
+ private:
+  upb_Status status_;
+};
+
+class Arena {
+ public:
+  // A simple arena with no initial memory block and the default allocator.
+  Arena() : ptr_(upb_Arena_New(), upb_Arena_Free) {}
+  Arena(char* initial_block, size_t size)
+      : ptr_(upb_Arena_Init(initial_block, size, &upb_alloc_global),
+             upb_Arena_Free) {}
+
+  upb_Arena* ptr() { return ptr_.get(); }
+
+  // Allows this arena to be used as a generic allocator.
+  //
+  // The arena does not need free() calls so when using Arena as an allocator
+  // it is safe to skip them.  However they are no-ops so there is no harm in
+  // calling free() either.
+  upb_alloc* allocator() { return upb_Arena_Alloc(ptr_.get()); }
+
+  // Add a cleanup function to run when the arena is destroyed.
+  // Returns false on out-of-memory.
+  template <class T>
+  bool Own(T* obj) {
+    return upb_Arena_AddCleanup(ptr_.get(), obj,
+                                [](void* obj) { delete static_cast<T*>(obj); });
+  }
+
+  void Fuse(Arena& other) { upb_Arena_Fuse(ptr(), other.ptr()); }
+
+ private:
+  std::unique_ptr<upb_Arena, decltype(&upb_Arena_Free)> ptr_;
+};
+
+// InlinedArena seeds the arenas with a predefined amount of memory.  No
+// heap memory will be allocated until the initial block is exceeded.
+template <int N>
+class InlinedArena : public Arena {
+ public:
+  InlinedArena() : Arena(initial_block_, N) {}
+
+ private:
+  InlinedArena(const InlinedArena*) = delete;
+  InlinedArena& operator=(const InlinedArena*) = delete;
+
+  char initial_block_[N];
+};
+
+}  // namespace upb
+
+#endif  // UPB_HPP_
diff --git a/CAPI/cpp/grpc/include/upb/upb_internal.h b/CAPI/cpp/grpc/include/upb/upb_internal.h
new file mode 100644
index 0000000..6c1fec3
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/upb_internal.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_INT_H_
+#define UPB_INT_H_
+
+// TODO(b/232091617): Delete this entire header which currently exists only for
+// temporary backwards compatibility.
+
+#include "upb/internal/upb.h"
+
+#endif /* UPB_INT_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/util/compare.h b/CAPI/cpp/grpc/include/upb/util/compare.h
new file mode 100644
index 0000000..92f6d83
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/util/compare.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_UTIL_COMPARE_H_
+#define UPB_UTIL_COMPARE_H_
+
+#include "upb/def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Returns true if unknown fields from the two messages are equal when sorted
+// and varints are made canonical.
+//
+// This function is discouraged, as the comparison is inherently lossy without
+// schema data:
+//
+//  1. We don't know whether delimited fields are sub-messages. Unknown
+//     sub-messages will therefore not have their fields sorted and varints
+//     canonicalized.
+//  2. We don't know about oneof/non-repeated fields, which should semantically
+//     discard every value except the last.
+
+typedef enum {
+  kUpb_UnknownCompareResult_Equal = 0,
+  kUpb_UnknownCompareResult_NotEqual = 1,
+  kUpb_UnknownCompareResult_OutOfMemory = 2,
+  kUpb_UnknownCompareResult_MaxDepthExceeded = 3,
+} upb_UnknownCompareResult;
+
+upb_UnknownCompareResult upb_Message_UnknownFieldsAreEqual(const char* buf1,
+                                                           size_t size1,
+                                                           const char* buf2,
+                                                           size_t size2,
+                                                           int max_depth);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_UTIL_COMPARE_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/util/def_to_proto.h b/CAPI/cpp/grpc/include/upb/util/def_to_proto.h
new file mode 100644
index 0000000..24f65b9
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/util/def_to_proto.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_UTIL_DEF_TO_PROTO_H_
+#define UPB_UTIL_DEF_TO_PROTO_H_
+
+#include "upb/def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Functions for converting defs back to the equivalent descriptor proto.
+// Ultimately the goal is that a round-trip proto->def->proto is lossless.  Each
+// function returns a new proto created in arena `a`, or NULL if memory
+// allocation failed.
+google_protobuf_DescriptorProto* upb_MessageDef_ToProto(const upb_MessageDef* m,
+                                                        upb_Arena* a);
+google_protobuf_EnumDescriptorProto* upb_EnumDef_ToProto(const upb_EnumDef* e,
+                                                         upb_Arena* a);
+google_protobuf_EnumValueDescriptorProto* upb_EnumValueDef_ToProto(
+    const upb_EnumValueDef* e, upb_Arena* a);
+google_protobuf_FieldDescriptorProto* upb_FieldDef_ToProto(
+    const upb_FieldDef* f, upb_Arena* a);
+google_protobuf_OneofDescriptorProto* upb_OneofDef_ToProto(
+    const upb_OneofDef* o, upb_Arena* a);
+google_protobuf_FileDescriptorProto* upb_FileDef_ToProto(const upb_FileDef* f,
+                                                         upb_Arena* a);
+google_protobuf_MethodDescriptorProto* upb_MethodDef_ToProto(
+    const upb_MethodDef* m, upb_Arena* a);
+google_protobuf_ServiceDescriptorProto* upb_ServiceDef_ToProto(
+    const upb_ServiceDef* s, upb_Arena* a);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* UPB_UTIL_DEF_TO_PROTO_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/util/required_fields.h b/CAPI/cpp/grpc/include/upb/util/required_fields.h
new file mode 100644
index 0000000..874914b
--- /dev/null
+++ b/CAPI/cpp/grpc/include/upb/util/required_fields.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef UPB_UTIL_REQUIRED_FIELDS_H_
+#define UPB_UTIL_REQUIRED_FIELDS_H_
+
+#include "upb/def.h"
+#include "upb/reflection.h"
+
+/* Must be last. */
+#include "upb/port_def.inc"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// A FieldPath can be encoded as an array of upb_FieldPathEntry, in the
+// following format:
+//    { {.field = f1}, {.field = f2} }                      # f1.f2
+//    { {.field = f1}, {.index = 5}, {.field = f2} }        # f1[5].f2
+//    { {.field = f1}, {.key = "abc"}, {.field = f2} }      # f1["abc"].f2
+//
+// Users must look at the type of `field` to know if an index or map key
+// follows.
+//
+// A field path may be NULL-terminated, in which case a NULL field indicates
+// the end of the field path.
+typedef union {
+  const upb_FieldDef* field;
+  size_t array_index;
+  upb_MessageValue map_key;
+} upb_FieldPathEntry;
+
+// Writes a string representing `*path` to `buf` in the following textual
+// format:
+//    foo.bar                    # Regular fields
+//    repeated_baz[2].bar        # Repeated field
+//    int32_msg_map[5].bar       # Integer-keyed map
+//    string_msg_map["abc"]      # String-keyed map
+//    bool_msg_map[true]         # Bool-keyed map
+//
+// The input array `*path` must be NULL-terminated.  The pointer `*path` will be
+// updated to point to one past the terminating NULL pointer of the input array.
+//
+// The output buffer `buf` will always be NULL-terminated. If the output data
+// (including NULL terminator) exceeds `size`, the result will be truncated.
+// Returns the string length of the data we attempted to write, excluding the
+// terminating NULL.
+size_t upb_FieldPath_ToText(upb_FieldPathEntry** path, char* buf, size_t size);
+
+// Checks whether `msg` or any of its children has unset required fields,
+// returning `true` if any are found.  `msg` may be NULL, in which case the
+// message will be treated as empty.
+//
+// When this function returns true, `fields` is updated (if non-NULL) to point
+// to a heap-allocated array encoding the field paths of the required fields
+// that are missing.  Each path is terminated with {.field = NULL}, and a final
+// {.field = NULL} terminates the list of paths.  The caller is responsible for
+// freeing this array.
+bool upb_util_HasUnsetRequired(const upb_Message* msg, const upb_MessageDef* m,
+                               const upb_DefPool* ext_pool,
+                               upb_FieldPathEntry** fields);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#include "upb/port_undef.inc"
+
+#endif /* UPB_UTIL_REQUIRED_FIELDS_H_ */
diff --git a/CAPI/cpp/grpc/include/zconf.h b/CAPI/cpp/grpc/include/zconf.h
new file mode 100644
index 0000000..2536736
--- /dev/null
+++ b/CAPI/cpp/grpc/include/zconf.h
@@ -0,0 +1,544 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+/* #undef Z_PREFIX */
+/* #undef Z_HAVE_UNISTD_H */
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+#  define Z_PREFIX_SET
+
+/* all linked symbols and init macros */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_bits        z__tr_flush_bits
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define adler32_z             z_adler32_z
+#  ifndef Z_SOLO
+#    define compress              z_compress
+#    define compress2             z_compress2
+#    define compressBound         z_compressBound
+#  endif
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define crc32_z               z_crc32_z
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateGetDictionary  z_deflateGetDictionary
+#  define deflateInit           z_deflateInit
+#  define deflateInit2          z_deflateInit2
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePending        z_deflatePending
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateResetKeep      z_deflateResetKeep
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              z_gz_error
+#    define gz_intmax             z_gz_intmax
+#    define gz_strwinerror        z_gz_strwinerror
+#    define gzbuffer              z_gzbuffer
+#    define gzclearerr            z_gzclearerr
+#    define gzclose               z_gzclose
+#    define gzclose_r             z_gzclose_r
+#    define gzclose_w             z_gzclose_w
+#    define gzdirect              z_gzdirect
+#    define gzdopen               z_gzdopen
+#    define gzeof                 z_gzeof
+#    define gzerror               z_gzerror
+#    define gzflush               z_gzflush
+#    define gzfread               z_gzfread
+#    define gzfwrite              z_gzfwrite
+#    define gzgetc                z_gzgetc
+#    define gzgetc_               z_gzgetc_
+#    define gzgets                z_gzgets
+#    define gzoffset              z_gzoffset
+#    define gzoffset64            z_gzoffset64
+#    define gzopen                z_gzopen
+#    define gzopen64              z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              z_gzopen_w
+#    endif
+#    define gzprintf              z_gzprintf
+#    define gzputc                z_gzputc
+#    define gzputs                z_gzputs
+#    define gzread                z_gzread
+#    define gzrewind              z_gzrewind
+#    define gzseek                z_gzseek
+#    define gzseek64              z_gzseek64
+#    define gzsetparams           z_gzsetparams
+#    define gztell                z_gztell
+#    define gztell64              z_gztell64
+#    define gzungetc              z_gzungetc
+#    define gzvprintf             z_gzvprintf
+#    define gzwrite               z_gzwrite
+#  endif
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit       z_inflateBackInit
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCodesUsed      z_inflateCodesUsed
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetDictionary  z_inflateGetDictionary
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit           z_inflateInit
+#  define inflateInit2          z_inflateInit2
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateResetKeep      z_inflateResetKeep
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflateValidate       z_inflateValidate
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            z_uncompress
+#    define uncompress2           z_uncompress2
+#  endif
+#  define zError                z_zError
+#  ifndef Z_SOLO
+#    define zcalloc               z_zcalloc
+#    define zcfree                z_zcfree
+#  endif
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                z_gzFile
+#  endif
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+#ifdef Z_SOLO
+   typedef unsigned long z_size_t;
+#else
+#  define z_longlong long long
+#  if defined(NO_SIZE_T)
+     typedef unsigned NO_SIZE_T z_size_t;
+#  elif defined(STDC)
+#    include <stddef.h>
+     typedef size_t z_size_t;
+#  else
+     typedef unsigned long z_size_t;
+#  endif
+#  undef z_longlong
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  if ~(~HAVE_UNISTD_H + 0) == 0 && ~(~HAVE_UNISTD_H + 1) == 1
+#    define Z_HAVE_UNISTD_H
+#  elif HAVE_UNISTD_H != 0
+#    define Z_HAVE_UNISTD_H
+#  endif
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  if ~(~HAVE_STDARG_H + 0) == 0 && ~(~HAVE_STDARG_H + 1) == 1
+#    define Z_HAVE_STDARG_H
+#  elif HAVE_STDARG_H != 0
+#    define Z_HAVE_STDARG_H
+#  endif
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/CAPI/cpp/grpc/include/zlib.h b/CAPI/cpp/grpc/include/zlib.h
new file mode 100644
index 0000000..4a98e38
--- /dev/null
+++ b/CAPI/cpp/grpc/include/zlib.h
@@ -0,0 +1,1935 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.12, March 11th, 2022
+
+  Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
+  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.12"
+#define ZLIB_VERNUM 0x12c0
+#define ZLIB_VER_MAJOR 1
+#define ZLIB_VER_MINOR 2
+#define ZLIB_VER_REVISION 12
+#define ZLIB_VER_SUBREVISION 0
+
+/*
+    The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed data.
+  This version of the library supports only one compression method (deflation)
+  but other algorithms will be added later and will have the same stream
+  interface.
+
+    Compression can be done in a single step if the buffers are large enough,
+  or can be done by repeated calls of the compression function.  In the latter
+  case, the application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+    The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+    The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+    This library can optionally read and write gzip and raw deflate streams in
+  memory as well.
+
+    The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+    The library does not install any signal handler.  The decoder checks
+  the consistency of the compressed data, so the library should never crash
+  even in the case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    z_const Bytef *next_in;     /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total number of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte will go here */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total number of bytes output so far */
+
+    z_const char *msg;  /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text
+                           for deflate, or the decoding state for inflate */
+    uLong   adler;      /* Adler-32 or CRC-32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+     The application must update next_in and avail_in when avail_in has dropped
+   to zero.  It must update next_out and avail_out when avail_out has dropped
+   to zero.  The application must initialize zalloc, zfree and opaque before
+   calling the init function.  All other fields are set by the compression
+   library and must not be updated by the application.
+
+     The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree.  This can be useful for custom
+   memory management.  The compression library attaches no meaning to the
+   opaque value.
+
+     zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.  In that case, zlib is thread-safe.  When zalloc and zfree are
+   Z_NULL on entry to the initialization function, they are set to internal
+   routines that use the standard library functions malloc() and free().
+
+     On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this if
+   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
+   returned by zalloc for objects of exactly 65536 bytes *must* have their
+   offset normalized to zero.  The default allocation function provided by this
+   library ensures this (see zutil.c).  To reduce memory requirements and avoid
+   any allocation of 64K objects, at the expense of compression ratio, compile
+   the library with -DMAX_WBITS=14 (see zconf.h).
+
+     The fields total_in and total_out can be used for statistics or progress
+   reports.  After compression, total_in holds the total size of the
+   uncompressed data and may be saved for use by the decompressor (particularly
+   if the decompressor wants to decompress everything in a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+#define Z_TREES         6
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative values
+ * are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field for deflate() */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is not
+   compatible with the zlib.h header file used by the application.  This check
+   is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression.  The fields
+   zalloc, zfree and opaque must be initialized before by the caller.  If
+   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
+   allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at all
+   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
+   requests a default compromise between speed and compression (currently
+   equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if level is not a valid compression level, or
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
+   if there is no error message.  deflateInit does not perform any compression:
+   this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows.  deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Generate more output starting at next_out and update next_out and avail_out
+    accordingly.  This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary.  Some output may be provided even if
+    flush is zero.
+
+    Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating avail_in or avail_out accordingly; avail_out should
+  never be zero before the call.  The application can consume the compressed
+  output when it wants, for example when the output buffer is full (avail_out
+  == 0), or after each call of deflate().  If deflate returns Z_OK and with
+  zero avail_out, it must be called again after making room in the output
+  buffer because there might be more output pending. See deflatePending(),
+  which can be used if desired to determine whether or not there is more ouput
+  in that case.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumulate before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far.  (In
+  particular avail_in is zero after the call if enough output space has been
+  provided before the call.) Flushing may degrade compression for some
+  compression algorithms and so it should be used only when necessary.  This
+  completes the current deflate block and follows it with an empty stored block
+  that is three bits plus filler bits to the next byte, followed by four bytes
+  (00 00 ff ff).
+
+    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
+  output buffer, but the output is not aligned to a byte boundary.  All of the
+  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
+  This completes the current deflate block and follows it with an empty fixed
+  codes block that is 10 bits long.  This assures that enough bytes are output
+  in order for the decompressor to finish the block before the empty fixed
+  codes block.
+
+    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
+  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
+  seven bits of the current block are held to be written as the next byte after
+  the next deflate block is completed.  In this case, the decompressor may not
+  be provided enough bits at this point in order to complete decompression of
+  the data provided so far to the compressor.  It may need to wait for the next
+  block to be emitted.  This is for advanced applications that need to control
+  the emission of deflate blocks.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six to avoid repeated flush markers due to
+  avail_out == 0 on return.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there was
+  enough output space.  If deflate returns with Z_OK or Z_BUF_ERROR, this
+  function must be called again with Z_FINISH and more output space (updated
+  avail_out) but no more input data, until it returns with Z_STREAM_END or an
+  error.  After deflate has returned Z_STREAM_END, the only possible operations
+  on the stream are deflateReset or deflateEnd.
+
+    Z_FINISH can be used in the first deflate call after deflateInit if all the
+  compression is to be done in a single step.  In order to complete in one
+  call, avail_out must be at least the value returned by deflateBound (see
+  below).  Then deflate is guaranteed to return Z_STREAM_END.  If not enough
+  output space is provided, deflate will not return Z_STREAM_END, and it must
+  be called again as described above.
+
+    deflate() sets strm->adler to the Adler-32 checksum of all input read
+  so far (that is, total_in bytes).  If a gzip stream is being generated, then
+  strm->adler will be the CRC-32 checksum of the input read so far.  (See
+  deflateInit2 below.)
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT).  If in doubt, the data is
+  considered binary.  This field is only for information purposes and does not
+  affect the compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was Z_NULL or the state was inadvertently written over
+  by the application), or Z_BUF_ERROR if no progress is possible (for example
+  avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not fatal, and
+  deflate() can be called again with more input and more output space to
+  continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded).  In the error case, msg
+   may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression.  The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller.  In the current version of inflate, the provided input is not
+   read or consumed.  The allocation of a sliding window will be deferred to
+   the first call of inflate (if the decompression does not complete on the
+   first call).  If zalloc and zfree are set to Z_NULL, inflateInit updates
+   them to use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit does not perform any decompression.
+   Actual decompression will be done by inflate().  So next_in, and avail_in,
+   next_out, and avail_out are unused and unchanged.  The current
+   implementation of inflateInit() does not process any header information --
+   that is deferred until inflate() is called.
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows.  inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), then next_in and avail_in are updated
+    accordingly, and processing will resume at this point for the next call of
+    inflate().
+
+  - Generate more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there is
+    no more input data or no more space in the output buffer (see below about
+    the flush parameter).
+
+    Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating the next_* and avail_* values accordingly.  If the
+  caller of inflate() does not provide both available input and available
+  output space, it is possible that there will be no progress made.  The
+  application can consume the uncompressed output when it wants, for example
+  when the output buffer is full (avail_out == 0), or after each call of
+  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
+  called again after making room in the output buffer because there might be
+  more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
+  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer.  Z_BLOCK requests that inflate()
+  stop if and when it gets to the next deflate block boundary.  When decoding
+  the zlib or gzip format, this will cause inflate() to return immediately
+  after the header and before the first block.  When doing a raw inflate,
+  inflate() will go ahead and process the first block, and will return when it
+  gets to the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  To assist in this, on return inflate() always sets strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64 if
+  inflate() is currently decoding the last block in the deflate stream, plus
+  128 if inflate() returned immediately after decoding an end-of-block code or
+  decoding the complete header up to just before the first byte of the deflate
+  stream.  The end-of-block will not be indicated until all of the uncompressed
+  data from that block has been written to strm->next_out.  The number of
+  unused bits may in general be greater than seven, except when bit 7 of
+  data_type is set, in which case the number of unused bits will be less than
+  eight.  data_type is set as noted here every time inflate() returns for all
+  flush options, and so can be used to determine the amount of currently
+  consumed input in bits.
+
+    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
+  end of each deflate block header is reached, before any actual data in that
+  block is decoded.  This allows the caller to determine the length of the
+  deflate block header for later use in random access within a deflate block.
+  256 is added to the value of strm->data_type when inflate() returns
+  immediately after reaching the end of the deflate block header.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error.  However if all decompression is to be performed in a single step (a
+  single call of inflate), the parameter flush should be set to Z_FINISH.  In
+  this case all pending input is processed and all pending output is flushed;
+  avail_out must be large enough to hold all of the uncompressed data for the
+  operation to complete.  (The size of the uncompressed data may have been
+  saved by the compressor for this purpose.)  The use of Z_FINISH is not
+  required to perform an inflation in one step.  However it may be used to
+  inform inflate that a faster approach can be used for the single inflate()
+  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
+  stream completes, which reduces inflate's memory footprint.  If the stream
+  does not complete, either because not all of the stream is provided or not
+  enough output space is provided, then a sliding window will be allocated and
+  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
+  been used.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call.  So the effects of the flush parameter in this implementation are
+  on the return value of inflate() as noted below, when inflate() returns early
+  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
+  memory for a sliding window when Z_FINISH is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the Adler-32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below.  At the end of the stream, inflate() checks that its computed Adler-32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically, if requested when
+  initializing with inflateInit2().  Any information contained in the gzip
+  header is not retained unless inflateGetHeader() is used.  When processing
+  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
+  produced so far.  The CRC-32 is checked against the gzip trailer, as is the
+  uncompressed length, modulo 2^32.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value, in which case strm->msg points to a string with a more specific
+  error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  next_in or next_out was Z_NULL, or the state was inadvertently written over
+  by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
+  if no progress was possible or if there was not enough room in the output
+  buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing.  If Z_DATA_ERROR is returned, the application may
+  then call inflateSync() to look for a good compression block if a partial
+  recovery of the data is to be attempted.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
+   was inconsistent.
+*/
+
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options.  The
+   fields zalloc, zfree and opaque must be initialized before by the caller.
+
+     The method parameter is the compression method.  It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library.  Larger values of this parameter result in better
+   compression at the expense of memory usage.  The default value is 15 if
+   deflateInit is used instead.
+
+     For the current implementation of deflate(), a windowBits value of 8 (a
+   window size of 256 bytes) is not supported.  As a result, a request for 8
+   will result in 9 (a 512-byte window).  In that case, providing 8 to
+   inflateInit2() will result in an error when the zlib header with 9 is
+   checked against the initialization of inflate().  The remedy is to not use 8
+   with deflateInit2() with this initialization, or at least in that case use 9
+   with inflateInit2().
+
+     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
+   determines the window size.  deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute a check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding.  Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper.  The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero), no
+   header crc, and the operating system will be set to the appropriate value,
+   if the operating system was determined at compile time.  If a gzip stream is
+   being written, strm->adler is a CRC-32 instead of an Adler-32.
+
+     For raw deflate or gzip encoding, a request for a 256-byte window is
+   rejected as invalid, since only the zlib header provides a means of
+   transmitting the window size to the decompressor.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state.  memLevel=1 uses minimum memory but is
+   slow and reduces compression ratio; memLevel=9 uses maximum memory for
+   optimal speed.  The default value is 8.  See zconf.h for total memory usage
+   as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm.  Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding).  Filtered data consists mostly of small values with a somewhat
+   random distribution.  In this case, the compression algorithm is tuned to
+   compress them better.  The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
+   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
+   strategy parameter only affects the compression ratio but not the
+   correctness of the compressed output even if it is not set appropriately.
+   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
+   decoder for special applications.
+
+     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
+   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
+   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
+   set to null if there is no error message.  deflateInit2 does not perform any
+   compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output.  When using the zlib format, this
+   function must be called immediately after deflateInit, deflateInit2 or
+   deflateReset, and before any call of deflate.  When doing raw deflate, this
+   function must be called either before any call of deflate, or immediately
+   after the completion of a deflate block, i.e. after all input has been
+   consumed and all output has been delivered when using any of the flush
+   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
+   compressor and decompressor must use exactly the same dictionary (see
+   inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary.  Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size
+   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
+   useful should be put at the end of the dictionary, not at the front.  In
+   addition, the current implementation of deflate will use at most the window
+   size minus 262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the Adler-32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor.  (The Adler-32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   Adler-32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if not at a block boundary for raw deflate).  deflateSetDictionary does
+   not perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
+                                             Bytef *dictionary,
+                                             uInt  *dictLength));
+/*
+     Returns the sliding dictionary being maintained by deflate.  dictLength is
+   set to the number of bytes in the dictionary, and that many bytes are copied
+   to dictionary.  dictionary must have enough space, where 32768 bytes is
+   always enough.  If deflateGetDictionary() is called with dictionary equal to
+   Z_NULL, then only the dictionary length is returned, and nothing is copied.
+   Similary, if dictLength is Z_NULL, then it is not set.
+
+     deflateGetDictionary() may return a length less than the window size, even
+   when more than the window size in input has been provided. It may return up
+   to 258 bytes less in that case, due to how zlib's implementation of deflate
+   manages the sliding window and lookahead for matches, where matches can be
+   up to 258 bytes long. If the application needs the last window-size bytes of
+   input, then that would need to be saved by the application outside of zlib.
+
+     deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+   stream state is inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter.  The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and can
+   consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit, but
+   does not free and reallocate the internal compression state.  The stream
+   will leave the compression level and any other attributes that may have been
+   set unchanged.
+
+     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+                                      int level,
+                                      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2().  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different strategy.
+   If the compression approach (which is a function of the level) or the
+   strategy is changed, and if there have been any deflate() calls since the
+   state was initialized or reset, then the input available so far is
+   compressed with the old level and strategy using deflate(strm, Z_BLOCK).
+   There are three approaches for the compression levels 0, 1..3, and 4..9
+   respectively.  The new level and strategy will take effect at the next call
+   of deflate().
+
+     If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+   not have enough output space to complete, then the parameter change will not
+   take effect.  In this case, deflateParams() can be called again with the
+   same parameters and more output space to try again.
+
+     In order to assure a change in the parameters on the first try, the
+   deflate stream should be flushed using deflate() with Z_BLOCK or other flush
+   request until strm.avail_out is not zero, before calling deflateParams().
+   Then no more input data should be provided before the deflateParams() call.
+   If this is done, the old level and strategy will be applied to the data
+   compressed before deflateParams(), and the new level and strategy will be
+   applied to the the data compressed after deflateParams().
+
+     deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
+   state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
+   there was not enough output space to complete the compression of the
+   available input data before a change in the strategy or approach.  Note that
+   in the case of a Z_BUF_ERROR, the parameters are not changed.  A return
+   value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
+   retried with more output space.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+                                    int good_length,
+                                    int max_lazy,
+                                    int nice_length,
+                                    int max_chain));
+/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+                                       uLong sourceLen));
+/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit() or
+   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
+   to allocate an output buffer for deflation in a single pass, and so would be
+   called before deflate().  If that first deflate() call is provided the
+   sourceLen input bytes, an output buffer allocated to the size returned by
+   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
+   to return Z_STREAM_END.  Note that it is possible for the compressed size to
+   be larger than the value returned by deflateBound() if flush options other
+   than Z_FINISH or Z_NO_FLUSH are used.
+*/
+
+ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
+                                       unsigned *pending,
+                                       int *bits));
+/*
+     deflatePending() returns the number of bytes and bits of output that have
+   been generated, but not yet provided in the available output.  The bytes not
+   provided would be due to the available output space having being consumed.
+   The number of bits of output not provided are between 0 and 7, where they
+   await more bits to join them in order to fill out a full byte.  If pending
+   or bits are Z_NULL, then those values are not set.
+
+     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+ */
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+   is that this function is used to start off the deflate output with the bits
+   leftover from a previous deflate stream when appending to it.  As such, this
+   function can only be used for raw deflate, and must be used before the first
+   deflate() call after a deflateInit2() or deflateReset().  bits must be less
+   than or equal to 16, and that many of the least significant bits of value
+   will be inserted in the output.
+
+     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
+   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+     If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to 255, with no extra, name, or comment
+   fields.  The gzip header is returned to the default state by deflateReset().
+
+     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter.  The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library.  The default value is 15 if inflateInit is used
+   instead.  windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used.  If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be zero to request that inflate use the window size in
+   the zlib header of the compressed stream.
+
+     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
+   determines the window size.  inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream.  This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values.  If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an Adler-32 or a CRC-32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is.  Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding.  Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+   CRC-32 instead of an Adler-32.  Unlike the gunzip utility and gzread() (see
+   below), inflate() will *not* automatically decode concatenated gzip members.
+   inflate() will return Z_STREAM_END at the end of the gzip member.  The state
+   would need to be reset to continue decoding a subsequent gzip member.  This
+   *must* be done if there is more data after a gzip member, in order for the
+   decompression to be compliant with the gzip standard (RFC 1952).
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit2 does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit2() does not process any header information -- that is
+   deferred until inflate() is called.
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence.  This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
+   can be determined from the Adler-32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called at any
+   time to set the dictionary.  If the provided dictionary is smaller than the
+   window and there is already data in the window, then the provided dictionary
+   will amend what's there.  The application must insure that the dictionary
+   that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect Adler-32 value).  inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
+                                             Bytef *dictionary,
+                                             uInt  *dictLength));
+/*
+     Returns the sliding dictionary being maintained by inflate.  dictLength is
+   set to the number of bytes in the dictionary, and that many bytes are copied
+   to dictionary.  dictionary must have enough space, where 32768 bytes is
+   always enough.  If inflateGetDictionary() is called with dictionary equal to
+   Z_NULL, then only the dictionary length is returned, and nothing is copied.
+   Similary, if dictLength is Z_NULL, then it is not set.
+
+     inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+   stream state is inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+     Skips invalid compressed data until a possible full flush point (see above
+   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
+   available input is skipped.  No output is provided.
+
+     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
+   All full flush points have this pattern, but not all occurrences of this
+   pattern are full flush points.
+
+     inflateSync returns Z_OK if a possible full flush point has been found,
+   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
+   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
+   In the success case, the application may save the current current value of
+   total_in which indicates where valid compressed data was found.  In the
+   error case, the application may repeatedly call inflateSync, providing more
+   input each time, until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate the internal decompression state.  The
+   stream will keep attributes that may have been set by inflateInit2.
+
+     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
+                                      int windowBits));
+/*
+     This function is the same as inflateReset, but it also permits changing
+   the wrap and window size requests.  The windowBits parameter is interpreted
+   the same as it is for inflateInit2.  If the window size is changed, then the
+   memory allocated for the window is freed, and the window will be reallocated
+   by inflate() if needed.
+
+     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
+   the windowBits parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     This function inserts bits in the inflate input stream.  The intent is
+   that this function is used to start inflating at a bit position in the
+   middle of a byte.  The provided bits will be used before any bytes are used
+   from next_in.  This function should only be used with raw inflate, and
+   should be used before the first inflate() call after inflateInit2() or
+   inflateReset().  bits must be less than or equal to 16, and that many of the
+   least significant bits of value will be inserted in the input.
+
+     If bits is negative, then the input stream bit buffer is emptied.  Then
+   inflatePrime() can be called again to put bits in the buffer.  This is used
+   to clear out bits leftover after feeding inflate a block description prior
+   to feeding inflate codes.
+
+     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
+/*
+     This function returns two values, one in the lower 16 bits of the return
+   value, and the other in the remaining upper bits, obtained by shifting the
+   return value down 16 bits.  If the upper value is -1 and the lower value is
+   zero, then inflate() is currently decoding information outside of a block.
+   If the upper value is -1 and the lower value is non-zero, then inflate is in
+   the middle of a stored block, with the lower value equaling the number of
+   bytes from the input remaining to copy.  If the upper value is not -1, then
+   it is the number of bits back from the current bit position in the input of
+   the code (literal or length/distance pair) currently being processed.  In
+   that case the lower value is the number of bytes already emitted for that
+   code.
+
+     A code is being processed if inflate is waiting for more input to complete
+   decoding of the code, or if it has completed decoding but is waiting for
+   more output space to write the literal or match data.
+
+     inflateMark() is used to mark locations in the input data for random
+   access, which may be at bit positions, and to note those cases where the
+   output of a code may span boundaries of random access blocks.  The current
+   location in the input stream can be determined from avail_in and data_type
+   as noted in the description for the Z_BLOCK flush parameter for inflate.
+
+     inflateMark returns the value noted above, or -65536 if the provided
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
+   used to force inflate() to return immediately after header processing is
+   complete and before any actual data is decompressed.
+
+     The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+   contains the maximum number of bytes to write to extra.  Once done is true,
+   extra_len contains the actual extra field length, and extra contains the
+   extra field, or that field truncated if extra_max is less than extra_len.
+   If name is not Z_NULL, then up to name_max characters are written there,
+   terminated with a zero unless the length is greater than name_max.  If
+   comment is not Z_NULL, then up to comm_max characters are written there,
+   terminated with a zero unless the length is greater than comm_max.  When any
+   of extra, name, or comment are not Z_NULL and the respective field is not
+   present in the header, then that field is set to Z_NULL to signal its
+   absence.  This allows the use of deflateSetHeader() with the returned
+   structure to duplicate the header.  However if those fields are set to
+   allocated memory, then the application will need to save those pointers
+   elsewhere so that they can be eventually freed.
+
+     If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                        unsigned char FAR *window));
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
+   allocated, or Z_VERSION_ERROR if the version of the library does not match
+   the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *,
+                                z_const unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is potentially more efficient than
+   inflate() for file i/o applications, in that it avoids copying between the
+   output and the sliding window by simply making the window itself the output
+   buffer.  inflate() can be faster on modern CPUs when used with large
+   buffers.  inflateBack() trusts the application to not change the output
+   buffer passed by the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free the
+   allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects only
+   the raw deflate stream to decompress.  This is different from the default
+   behavior of inflate(), which expects a zlib header and trailer around the
+   deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero -- buf is ignored in that
+   case -- and inflateBack() will return a buffer error.  inflateBack() will
+   call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
+   out() should return zero on success, or non-zero on failure.  If out()
+   returns non-zero, inflateBack() will return with an error.  Neither in() nor
+   out() are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
+   in the deflate stream (in which case strm->msg is set to indicate the nature
+   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
+   In the case of Z_BUF_ERROR, an input or output error can be distinguished
+   using strm->next_in which will be Z_NULL only if in() returned an error.  If
+   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
+   non-zero.  (in() will always be called before out(), so strm->next_in is
+   assured to be defined if out() returns non-zero.)  Note that inflateBack()
+   cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: ZLIB_DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (zero is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+    Remainder:
+     27-31: 0 (reserved)
+ */
+
+#ifndef Z_SOLO
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the basic
+   stream-oriented functions.  To simplify the interface, some default options
+   are assumed (compression level and memory usage, standard memory allocation
+   functions).  The source code of these utility functions can be modified if
+   you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed data.  compress() is equivalent to compress2() with a level
+   parameter of Z_DEFAULT_COMPRESSION.
+
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer.  The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer.  Upon entry, destLen is the total size of the
+   destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed data.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before a
+   compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be large enough to hold the entire
+   uncompressed data.  (The size of the uncompressed data must have been saved
+   previously by the compressor and transmitted to the decompressor by some
+   mechanism outside the scope of this compression library.) Upon exit, destLen
+   is the actual size of the uncompressed data.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
+   the case where there is not enough room, uncompress() will fill the output
+   buffer with the uncompressed data up to that point.
+*/
+
+ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest,   uLongf *destLen,
+                                    const Bytef *source, uLong *sourceLen));
+/*
+     Same as uncompress, except that sourceLen is a pointer, where the
+   length of the source is *sourceLen.  On return, *sourceLen is the number of
+   source bytes consumed.
+*/
+
+                        /* gzip file access functions */
+
+/*
+     This library supports reading and writing files in gzip (.gz) format with
+   an interface similar to that of stdio, using the functions that start with
+   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
+   wrapper, documented in RFC 1952, wrapped around a deflate stream.
+*/
+
+typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */
+
+/*
+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+
+     Open the gzip (.gz) file at path for reading and decompressing, or
+   compressing and writing.  The mode parameter is as in fopen ("rb" or "wb")
+   but can also include a compression level ("wb9") or a strategy: 'f' for
+   filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h",
+   'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression
+   as in "wb9F".  (See the description of deflateInit2 for more information
+   about the strategy parameter.)  'T' will request transparent writing or
+   appending with no compression and not using the gzip format.
+
+     "a" can be used instead of "w" to request that the gzip stream that will
+   be written be appended to the file.  "+" will result in an error, since
+   reading and writing to the same gzip file is not supported.  The addition of
+   "x" when writing will create the file exclusively, which fails if the file
+   already exists.  On systems that support it, the addition of "e" when
+   reading or writing will set the flag to close the file on an execve() call.
+
+     These functions, as well as gzip, will read and decode a sequence of gzip
+   streams in a file.  The append function of gzopen() can be used to create
+   such a file.  (Also see gzflush() for another way to do this.)  When
+   appending, gzopen does not test whether the file begins with a gzip stream,
+   nor does it look for the end of the gzip streams to begin appending.  gzopen
+   will simply append a gzip stream to the existing file.
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.  When
+   reading, this will be detected automatically by looking for the magic two-
+   byte gzip header.
+
+     gzopen returns NULL if the file could not be opened, if there was
+   insufficient memory to allocate the gzFile state, or if an invalid mode was
+   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
+   errno can be checked to determine if the reason gzopen failed was that the
+   file could not be opened.
+*/
+
+ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+/*
+     Associate a gzFile with the file descriptor fd.  File descriptors are
+   obtained from calls like open, dup, creat, pipe or fileno (if the file has
+   been previously opened with fopen).  The mode parameter is as in gzopen.
+
+     The next call of gzclose on the returned gzFile will also close the file
+   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
+   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
+   mode);.  The duplicated descriptor should be saved to avoid a leak, since
+   gzdopen does not close fd if it fails.  If you are using fileno() to get the
+   file descriptor from a FILE *, then you will have to use dup() to avoid
+   double-close()ing the file descriptor.  Both gzclose() and fclose() will
+   close the associated file descriptor, so they need to have different file
+   descriptors.
+
+     gzdopen returns NULL if there was insufficient memory to allocate the
+   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
+   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
+   used until the next gz* read, write, seek, or close operation, so gzdopen
+   will not detect if fd is invalid (unless fd is -1).
+*/
+
+ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
+/*
+     Set the internal buffer size used by this library's functions for file to
+   size.  The default buffer size is 8192 bytes.  This function must be called
+   after gzopen() or gzdopen(), and before any other calls that read or write
+   the file.  The buffer memory allocation is always deferred to the first read
+   or write.  Three times that size in buffer space is allocated.  A larger
+   buffer size of, for example, 64K or 128K bytes will noticeably increase the
+   speed of decompression (reading).
+
+     The new buffer size also affects the maximum length for gzprintf().
+
+     gzbuffer() returns 0 on success, or -1 on failure, such as being called
+   too late.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level and strategy for file.  See the
+   description of deflateInit2 for the meaning of these parameters. Previously
+   provided data is flushed before applying the parameter changes.
+
+     gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
+   opened for writing, Z_ERRNO if there is an error writing the flushed data,
+   or Z_MEM_ERROR if there is a memory allocation error.
+*/
+
+ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+/*
+     Read and decompress up to len uncompressed bytes from file into buf.  If
+   the input file is not in gzip format, gzread copies the given number of
+   bytes into the buffer directly from the file.
+
+     After reaching the end of a gzip stream in the input, gzread will continue
+   to read, looking for another gzip stream.  Any number of gzip streams may be
+   concatenated in the input file, and will all be decompressed by gzread().
+   If something other than a gzip stream is encountered after a gzip stream,
+   that remaining trailing garbage is ignored (and no error is returned).
+
+     gzread can be used to read a gzip file that is being concurrently written.
+   Upon reaching the end of the input, gzread will return with the available
+   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
+   gzclearerr can be used to clear the end of file indicator in order to permit
+   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
+   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
+   middle of a gzip stream.  Note that gzread does not return -1 in the event
+   of an incomplete gzip stream.  This error is deferred until gzclose(), which
+   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
+   stream.  Alternatively, gzerror can be used before gzclose to detect this
+   case.
+
+     gzread returns the number of uncompressed bytes actually read, less than
+   len for end of file, or -1 for error.  If len is too large to fit in an int,
+   then nothing is read, -1 is returned, and the error state is set to
+   Z_STREAM_ERROR.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
+                                     gzFile file));
+/*
+     Read and decompress up to nitems items of size size from file into buf,
+   otherwise operating as gzread() does.  This duplicates the interface of
+   stdio's fread(), with size_t request and return types.  If the library
+   defines size_t, then z_size_t is identical to size_t.  If not, then z_size_t
+   is an unsigned integer type that can contain a pointer.
+
+     gzfread() returns the number of full items read of size size, or zero if
+   the end of the file was reached and a full item could not be read, or if
+   there was an error.  gzerror() must be consulted if zero is returned in
+   order to determine if there was an error.  If the multiplication of size and
+   nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
+   is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
+
+     In the event that the end of file is reached and only a partial item is
+   available at the end, i.e. the remaining uncompressed data length is not a
+   multiple of size, then the final partial item is nevetheless read into buf
+   and the end-of-file flag is set.  The length of the partial item read is not
+   provided, but could be inferred from the result of gztell().  This behavior
+   is the same as the behavior of fread() implementations in common libraries,
+   but it prevents the direct use of gzfread() to read a concurrently written
+   file, reseting and retrying on end-of-file, when size is not 1.
+*/
+
+ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len));
+/*
+     Compress and write the len uncompressed bytes at buf to file. gzwrite
+   returns the number of uncompressed bytes written or 0 in case of error.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
+                                      z_size_t nitems, gzFile file));
+/*
+     Compress and write nitems items of size size from buf to file, duplicating
+   the interface of stdio's fwrite(), with size_t request and return types.  If
+   the library defines size_t, then z_size_t is identical to size_t.  If not,
+   then z_size_t is an unsigned integer type that can contain a pointer.
+
+     gzfwrite() returns the number of full items written of size size, or zero
+   if there was an error.  If the multiplication of size and nitems overflows,
+   i.e. the product does not fit in a z_size_t, then nothing is written, zero
+   is returned, and the error state is set to Z_STREAM_ERROR.
+*/
+
+ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
+/*
+     Convert, format, compress, and write the arguments (...) to file under
+   control of the string format, as in fprintf.  gzprintf returns the number of
+   uncompressed bytes actually written, or a negative zlib error code in case
+   of error.  The number of uncompressed bytes written is limited to 8191, or
+   one less than the buffer size given to gzbuffer().  The caller should assure
+   that this limit is not exceeded.  If it is exceeded, then gzprintf() will
+   return an error (0) with nothing written.  In this case, there may also be a
+   buffer overflow with unpredictable consequences, which is possible only if
+   zlib was compiled with the insecure functions sprintf() or vsprintf(),
+   because the secure snprintf() or vsnprintf() functions were not available.
+   This can be determined using zlibCompileFlags().
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+     Compress and write the given null-terminated string s to file, excluding
+   the terminating null character.
+
+     gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+     Read and decompress bytes from file into buf, until len-1 characters are
+   read, or until a newline character is read and transferred to buf, or an
+   end-of-file condition is encountered.  If any characters are read or if len
+   is one, the string is terminated with a null character.  If no characters
+   are read due to an end-of-file or len is less than one, then the buffer is
+   left untouched.
+
+     gzgets returns buf which is a null-terminated string, or it returns NULL
+   for end-of-file or in case of error.  If there was an error, the contents at
+   buf are indeterminate.
+*/
+
+ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+/*
+     Compress and write c, converted to an unsigned char, into file.  gzputc
+   returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+/*
+     Read and decompress one byte from file.  gzgetc returns this byte or -1
+   in case of end of file or error.  This is implemented as a macro for speed.
+   As such, it does not do all of the checking the other functions do.  I.e.
+   it does not check to see if file is NULL, nor whether the structure file
+   points to has been clobbered or not.
+*/
+
+ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+/*
+     Push c back onto the stream for file to be read as the first character on
+   the next read.  At least one character of push-back is always allowed.
+   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
+   fail if c is -1, and may fail if a character has been pushed but not read
+   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
+   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
+   The pushed character will be discarded if the stream is repositioned with
+   gzseek() or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+/*
+     Flush all pending output to file.  The parameter flush is as in the
+   deflate() function.  The return value is the zlib error number (see function
+   gzerror below).  gzflush is only permitted when writing.
+
+     If the flush parameter is Z_FINISH, the remaining data is written and the
+   gzip stream is completed in the output.  If gzwrite() is called again, a new
+   gzip stream will be started in the output.  gzread() is able to read such
+   concatenated gzip streams.
+
+     gzflush should be called only when strictly necessary because it will
+   degrade compression if called too often.
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+                                   z_off_t offset, int whence));
+
+     Set the starting position to offset relative to whence for the next gzread
+   or gzwrite on file.  The offset represents a number of bytes in the
+   uncompressed data stream.  The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow.  If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+     gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewind file. This function is supported only for reading.
+
+     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET).
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+
+     Return the starting position for the next gzread or gzwrite on file.
+   This position represents a number of bytes in the uncompressed data stream,
+   and is zero when starting, even if appending or reading a gzip stream from
+   the middle of a file using gzdopen().
+
+     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
+
+     Return the current compressed (actual) read or write offset of file.  This
+   offset includes the count of bytes that precede the gzip stream, for example
+   when appending or when using gzdopen() for reading.  When reading, the
+   offset does not include as yet unused buffered input.  This information can
+   be used for a progress indicator.  On error, gzoffset() returns -1.
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Return true (1) if the end-of-file indicator for file has been set while
+   reading, false (0) otherwise.  Note that the end-of-file indicator is set
+   only if the read tried to go past the end of the input, but came up short.
+   Therefore, just like feof(), gzeof() may return false even if there is no
+   more data to read, in the event that the last read request was for the exact
+   number of bytes remaining in the input file.  This will happen if the input
+   file size is an exact multiple of the buffer size.
+
+     If gzeof() returns true, then the read functions will return no more data,
+   unless the end-of-file indicator is reset by gzclearerr() and the input file
+   has grown since the previous end of file was detected.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+     Return true (1) if file is being copied directly while reading, or false
+   (0) if file is a gzip stream being decompressed.
+
+     If the input file is empty, gzdirect() will return true, since the input
+   does not contain a gzip stream.
+
+     If gzdirect() is used immediately after gzopen() or gzdopen() it will
+   cause buffers to be allocated to allow reading the file to determine if it
+   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+   gzdirect().
+
+     When writing, gzdirect() returns true (1) if transparent writing was
+   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
+   gzdirect() is not needed when writing.  Transparent writing must be
+   explicitly requested, so the application already knows the answer.  When
+   linking statically, using gzdirect() will include all of the zlib code for
+   gzip file reading and decompression, which may not be desired.)
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flush all pending output for file, if necessary, close file and
+   deallocate the (de)compression state.  Note that once file is closed, you
+   cannot call gzerror with file, since its structures have been deallocated.
+   gzclose must not be called more than once on the same file, just as free
+   must not be called more than once on the same allocation.
+
+     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
+   last read ended in the middle of a gzip stream, or Z_OK on success.
+*/
+
+ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
+ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
+/*
+     Same as gzclose(), but gzclose_r() is only for use when reading, and
+   gzclose_w() is only for use when writing or appending.  The advantage to
+   using these instead of gzclose() is that they avoid linking in zlib
+   compression or decompression code that is not used when only reading or only
+   writing respectively.  If gzclose() is used, then both compression and
+   decompression code will be included the application when linking to a static
+   zlib library.
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Return the error message for the last error which occurred on file.
+   errnum is set to zlib error number.  If an error occurred in the file system
+   and not in the compression library, errnum is set to Z_ERRNO and the
+   application may consult errno to get the exact error code.
+
+     The application must not modify the returned string.  Future calls to
+   this function may invalidate the previously returned string.  If file is
+   closed, then the string previously returned by gzerror will no longer be
+   available.
+
+     gzerror() should be used to distinguish errors from end-of-file for those
+   functions above that do not distinguish those cases in their return values.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+     Clear the error and end-of-file flags for file.  This is analogous to the
+   clearerr() function in stdio.  This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+#endif /* !Z_SOLO */
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the compression
+   library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. An Adler-32 value is in the range of a 32-bit
+   unsigned integer. If buf is Z_NULL, this function returns the required
+   initial value for the checksum.
+
+     An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
+   much faster.
+
+   Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
+                                    z_size_t len));
+/*
+     Same as adler32(), but with a size_t length.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
+   that the z_off_t type (like off_t) is a signed integer.  If len2 is
+   negative, the result has no meaning or utility.
+*/
+
+ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer.
+   If buf is Z_NULL, this function returns the required initial value for the
+   crc. Pre- and post-conditioning (one's complement) is performed within this
+   function so it shouldn't be done by the application.
+
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32_z OF((uLong crc, const Bytef *buf,
+                                  z_size_t len));
+/*
+     Same as crc32(), but with a size_t length.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2));
+
+     Return the operator corresponding to length len2, to be used with
+   crc32_combine_op().
+*/
+
+ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op));
+/*
+     Give the same result as crc32_combine(), using op in place of len2. op is
+   is generated from len2 by crc32_combine_gen(). This will be faster than
+   crc32_combine() if the generated op is used more than once.
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#ifdef Z_PREFIX_SET
+#  define z_deflateInit(strm, level) \
+          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_inflateInit(strm) \
+          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define z_inflateInit2(strm, windowBits) \
+          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+                        (int)sizeof(z_stream))
+#  define z_inflateBackInit(strm, windowBits, window) \
+          inflateBackInit_((strm), (windowBits), (window), \
+                           ZLIB_VERSION, (int)sizeof(z_stream))
+#else
+#  define deflateInit(strm, level) \
+          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define inflateInit(strm) \
+          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#  define inflateInit2(strm, windowBits) \
+          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+                        (int)sizeof(z_stream))
+#  define inflateBackInit(strm, windowBits, window) \
+          inflateBackInit_((strm), (windowBits), (window), \
+                           ZLIB_VERSION, (int)sizeof(z_stream))
+#endif
+
+#ifndef Z_SOLO
+
+/* gzgetc() macro and its supporting function and exposed data structure.  Note
+ * that the real internal state is much larger than the exposed structure.
+ * This abbreviated structure exposes just enough for the gzgetc() macro.  The
+ * user should not mess with these exposed elements, since their names or
+ * behavior could change in the future, perhaps even capriciously.  They can
+ * only be used by the gzgetc() macro.  You have been warned.
+ */
+struct gzFile_s {
+    unsigned have;
+    unsigned char *next;
+    z_off64_t pos;
+};
+ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));  /* backward compatibility */
+#ifdef Z_PREFIX_SET
+#  undef z_gzgetc
+#  define z_gzgetc(g) \
+          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
+#else
+#  define gzgetc(g) \
+          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
+#endif
+
+/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
+ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
+ * both are true, the application gets the *64 functions, and the regular
+ * functions are changed to 64 bits) -- in case these are set on systems
+ * without large file support, _LFS64_LARGEFILE must also be true
+ */
+#ifdef Z_LARGE64
+   ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+   ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+   ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+   ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
+   ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
+   ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t));
+#endif
+
+#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
+#  ifdef Z_PREFIX_SET
+#    define z_gzopen z_gzopen64
+#    define z_gzseek z_gzseek64
+#    define z_gztell z_gztell64
+#    define z_gzoffset z_gzoffset64
+#    define z_adler32_combine z_adler32_combine64
+#    define z_crc32_combine z_crc32_combine64
+#    define z_crc32_combine_gen z_crc32_combine_gen64
+#  else
+#    define gzopen gzopen64
+#    define gzseek gzseek64
+#    define gztell gztell64
+#    define gzoffset gzoffset64
+#    define adler32_combine adler32_combine64
+#    define crc32_combine crc32_combine64
+#    define crc32_combine_gen crc32_combine_gen64
+#  endif
+#  ifndef Z_LARGE64
+     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+     ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
+     ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
+     ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
+     ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+     ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+     ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off_t));
+#  endif
+#else
+   ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
+   ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
+   ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
+   ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t));
+#endif
+
+#else /* Z_SOLO */
+
+   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t));
+
+#endif /* !Z_SOLO */
+
+/* undocumented functions */
+ZEXTERN const char   * ZEXPORT zError           OF((int));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
+ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table    OF((void));
+ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
+ZEXTERN int            ZEXPORT inflateValidate OF((z_streamp, int));
+ZEXTERN unsigned long  ZEXPORT inflateCodesUsed OF ((z_streamp));
+ZEXTERN int            ZEXPORT inflateResetKeep OF((z_streamp));
+ZEXTERN int            ZEXPORT deflateResetKeep OF((z_streamp));
+#if defined(_WIN32) && !defined(Z_SOLO)
+ZEXTERN gzFile         ZEXPORT gzopen_w OF((const wchar_t *path,
+                                            const char *mode));
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+ZEXTERN int            ZEXPORTVA gzvprintf Z_ARG((gzFile file,
+                                                  const char *format,
+                                                  va_list va));
+#  endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */

From c8e1fbe299c67a6e101fa02e85bcc971acd0f48b Mon Sep 17 00:00:00 2001
From: wihn <88038740+wihn2021@users.noreply.github.com>
Date: Sat, 15 Apr 2023 23:50:23 +0800
Subject: [PATCH 05/10] build: add msvc build system for windows

---
 CAPI/cpp/.gitattributes          |  4 +-
 CAPI/cpp/.gitignore              |  1 +
 CAPI/cpp/API/API.vcxproj         | 47 ++++++++++++++++++
 CAPI/cpp/API/API.vcxproj.filters | 85 ++++++++++++++++++++++++++++++++
 CAPI/cpp/CAPI.sln                | 31 ++++++++++++
 5 files changed, 167 insertions(+), 1 deletion(-)
 create mode 100644 CAPI/cpp/CAPI.sln

diff --git a/CAPI/cpp/.gitattributes b/CAPI/cpp/.gitattributes
index b7e6ab9..04c7ba5 100644
--- a/CAPI/cpp/.gitattributes
+++ b/CAPI/cpp/.gitattributes
@@ -1,6 +1,8 @@
-tclap/** linguist-vendored
+* text=auto
 
+tclap/** linguist-vendored
 spdlog/** linguist-vendored
+grpc/** linguist-vendored
 
 proto/** linguist-generated
 
diff --git a/CAPI/cpp/.gitignore b/CAPI/cpp/.gitignore
index 73487ce..291cf41 100644
--- a/CAPI/cpp/.gitignore
+++ b/CAPI/cpp/.gitignore
@@ -499,3 +499,4 @@ CTestTestfile.cmake
 _deps
 
 /build/
+/lib/
diff --git a/CAPI/cpp/API/API.vcxproj b/CAPI/cpp/API/API.vcxproj
index 33f7ab9..8416fe8 100644
--- a/CAPI/cpp/API/API.vcxproj
+++ b/CAPI/cpp/API/API.vcxproj
@@ -90,10 +90,15 @@
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpp17</LanguageStandard>
       <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <AdditionalIncludeDirectories>..\spdlog\include;..\tclap\include;..\grpc\include;..\proto;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/source-charset:utf-8 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\lib\debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>absl_bad_any_cast_impl.lib;absl_bad_optional_access.lib;absl_bad_variant_access.lib;absl_base.lib;absl_city.lib;absl_civil_time.lib;absl_cord.lib;absl_cordz_functions.lib;absl_cordz_handle.lib;absl_cordz_info.lib;absl_cordz_sample_token.lib;absl_cord_internal.lib;absl_debugging_internal.lib;absl_demangle_internal.lib;absl_examine_stack.lib;absl_exponential_biased.lib;absl_failure_signal_handler.lib;absl_flags.lib;absl_flags_commandlineflag.lib;absl_flags_commandlineflag_internal.lib;absl_flags_config.lib;absl_flags_internal.lib;absl_flags_marshalling.lib;absl_flags_parse.lib;absl_flags_private_handle_accessor.lib;absl_flags_program_name.lib;absl_flags_reflection.lib;absl_flags_usage.lib;absl_flags_usage_internal.lib;absl_graphcycles_internal.lib;absl_hash.lib;absl_hashtablez_sampler.lib;absl_int128.lib;absl_leak_check.lib;absl_log_severity.lib;absl_low_level_hash.lib;absl_malloc_internal.lib;absl_periodic_sampler.lib;absl_random_distributions.lib;absl_random_internal_distribution_test_util.lib;absl_random_internal_platform.lib;absl_random_internal_pool_urbg.lib;absl_random_internal_randen.lib;absl_random_internal_randen_hwaes.lib;absl_random_internal_randen_hwaes_impl.lib;absl_random_internal_randen_slow.lib;absl_random_internal_seed_material.lib;absl_random_seed_gen_exception.lib;absl_random_seed_sequences.lib;absl_raw_hash_set.lib;absl_raw_logging_internal.lib;absl_scoped_set_env.lib;absl_spinlock_wait.lib;absl_stacktrace.lib;absl_status.lib;absl_statusor.lib;absl_strerror.lib;absl_strings.lib;absl_strings_internal.lib;absl_str_format_internal.lib;absl_symbolize.lib;absl_synchronization.lib;absl_throw_delegate.lib;absl_time.lib;absl_time_zone.lib;address_sorting.lib;cares.lib;descriptor_upb_proto.lib;gpr.lib;grpc++.lib;grpc++_alts.lib;grpc++_error_details.lib;grpc++_unsecure.lib;grpc.lib;grpc_plugin_support.lib;grpc_unsecure.lib;libcrypto.lib;libprotobuf-lited.lib;libprotobufd.lib;libprotocd.lib;libssl.lib;re2.lib;upb.lib;upb_collections.lib;upb_extension_registry.lib;upb_fastdecode.lib;upb_json.lib;upb_mini_table.lib;upb_reflection.lib;upb_textformat.lib;upb_utf8_range.lib;zlibd.lib;Ws2_32.lib;Crypt32.lib;Iphlpapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -106,12 +111,17 @@
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpp17</LanguageStandard>
       <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <AdditionalIncludeDirectories>..\spdlog\include;..\tclap\include;..\grpc\include;..\proto;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/source-charset:utf-8 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>absl_bad_any_cast_impl.lib;absl_bad_optional_access.lib;absl_bad_variant_access.lib;absl_base.lib;absl_city.lib;absl_civil_time.lib;absl_cord.lib;absl_cordz_functions.lib;absl_cordz_handle.lib;absl_cordz_info.lib;absl_cordz_sample_token.lib;absl_cord_internal.lib;absl_debugging_internal.lib;absl_demangle_internal.lib;absl_examine_stack.lib;absl_exponential_biased.lib;absl_failure_signal_handler.lib;absl_flags.lib;absl_flags_commandlineflag.lib;absl_flags_commandlineflag_internal.lib;absl_flags_config.lib;absl_flags_internal.lib;absl_flags_marshalling.lib;absl_flags_parse.lib;absl_flags_private_handle_accessor.lib;absl_flags_program_name.lib;absl_flags_reflection.lib;absl_flags_usage.lib;absl_flags_usage_internal.lib;absl_graphcycles_internal.lib;absl_hash.lib;absl_hashtablez_sampler.lib;absl_int128.lib;absl_leak_check.lib;absl_log_severity.lib;absl_low_level_hash.lib;absl_malloc_internal.lib;absl_periodic_sampler.lib;absl_random_distributions.lib;absl_random_internal_distribution_test_util.lib;absl_random_internal_platform.lib;absl_random_internal_pool_urbg.lib;absl_random_internal_randen.lib;absl_random_internal_randen_hwaes.lib;absl_random_internal_randen_hwaes_impl.lib;absl_random_internal_randen_slow.lib;absl_random_internal_seed_material.lib;absl_random_seed_gen_exception.lib;absl_random_seed_sequences.lib;absl_raw_hash_set.lib;absl_raw_logging_internal.lib;absl_scoped_set_env.lib;absl_spinlock_wait.lib;absl_stacktrace.lib;absl_status.lib;absl_statusor.lib;absl_strerror.lib;absl_strings.lib;absl_strings_internal.lib;absl_str_format_internal.lib;absl_symbolize.lib;absl_synchronization.lib;absl_throw_delegate.lib;absl_time.lib;absl_time_zone.lib;address_sorting.lib;cares.lib;descriptor_upb_proto.lib;gpr.lib;grpc++.lib;grpc++_alts.lib;grpc++_error_details.lib;grpc++_unsecure.lib;grpc.lib;grpc_plugin_support.lib;grpc_unsecure.lib;libcrypto.lib;libprotobuf-lite.lib;libprotobuf.lib;libprotoc.lib;libssl.lib;re2.lib;upb.lib;upb_collections.lib;upb_extension_registry.lib;upb_fastdecode.lib;upb_json.lib;upb_mini_table.lib;upb_reflection.lib;upb_textformat.lib;upb_utf8_range.lib;zlib.lib;Ws2_32.lib;Crypt32.lib;Iphlpapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>..\lib\release;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -122,10 +132,15 @@
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpp17</LanguageStandard>
       <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <AdditionalIncludeDirectories>..\spdlog\include;..\tclap\include;..\grpc\include;..\proto;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/source-charset:utf-8 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\lib\debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>absl_bad_any_cast_impl.lib;absl_bad_optional_access.lib;absl_bad_variant_access.lib;absl_base.lib;absl_city.lib;absl_civil_time.lib;absl_cord.lib;absl_cordz_functions.lib;absl_cordz_handle.lib;absl_cordz_info.lib;absl_cordz_sample_token.lib;absl_cord_internal.lib;absl_debugging_internal.lib;absl_demangle_internal.lib;absl_examine_stack.lib;absl_exponential_biased.lib;absl_failure_signal_handler.lib;absl_flags.lib;absl_flags_commandlineflag.lib;absl_flags_commandlineflag_internal.lib;absl_flags_config.lib;absl_flags_internal.lib;absl_flags_marshalling.lib;absl_flags_parse.lib;absl_flags_private_handle_accessor.lib;absl_flags_program_name.lib;absl_flags_reflection.lib;absl_flags_usage.lib;absl_flags_usage_internal.lib;absl_graphcycles_internal.lib;absl_hash.lib;absl_hashtablez_sampler.lib;absl_int128.lib;absl_leak_check.lib;absl_log_severity.lib;absl_low_level_hash.lib;absl_malloc_internal.lib;absl_periodic_sampler.lib;absl_random_distributions.lib;absl_random_internal_distribution_test_util.lib;absl_random_internal_platform.lib;absl_random_internal_pool_urbg.lib;absl_random_internal_randen.lib;absl_random_internal_randen_hwaes.lib;absl_random_internal_randen_hwaes_impl.lib;absl_random_internal_randen_slow.lib;absl_random_internal_seed_material.lib;absl_random_seed_gen_exception.lib;absl_random_seed_sequences.lib;absl_raw_hash_set.lib;absl_raw_logging_internal.lib;absl_scoped_set_env.lib;absl_spinlock_wait.lib;absl_stacktrace.lib;absl_status.lib;absl_statusor.lib;absl_strerror.lib;absl_strings.lib;absl_strings_internal.lib;absl_str_format_internal.lib;absl_symbolize.lib;absl_synchronization.lib;absl_throw_delegate.lib;absl_time.lib;absl_time_zone.lib;address_sorting.lib;cares.lib;descriptor_upb_proto.lib;gpr.lib;grpc++.lib;grpc++_alts.lib;grpc++_error_details.lib;grpc++_unsecure.lib;grpc.lib;grpc_plugin_support.lib;grpc_unsecure.lib;libcrypto.lib;libprotobuf-lited.lib;libprotobufd.lib;libprotocd.lib;libssl.lib;re2.lib;upb.lib;upb_collections.lib;upb_extension_registry.lib;upb_fastdecode.lib;upb_json.lib;upb_mini_table.lib;upb_reflection.lib;upb_textformat.lib;upb_utf8_range.lib;zlibd.lib;Ws2_32.lib;Crypt32.lib;Iphlpapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -138,15 +153,47 @@
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpp17</LanguageStandard>
       <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <AdditionalIncludeDirectories>..\spdlog\include;..\tclap\include;..\grpc\include;..\proto;include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalOptions>/source-charset:utf-8 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>absl_bad_any_cast_impl.lib;absl_bad_optional_access.lib;absl_bad_variant_access.lib;absl_base.lib;absl_city.lib;absl_civil_time.lib;absl_cord.lib;absl_cordz_functions.lib;absl_cordz_handle.lib;absl_cordz_info.lib;absl_cordz_sample_token.lib;absl_cord_internal.lib;absl_debugging_internal.lib;absl_demangle_internal.lib;absl_examine_stack.lib;absl_exponential_biased.lib;absl_failure_signal_handler.lib;absl_flags.lib;absl_flags_commandlineflag.lib;absl_flags_commandlineflag_internal.lib;absl_flags_config.lib;absl_flags_internal.lib;absl_flags_marshalling.lib;absl_flags_parse.lib;absl_flags_private_handle_accessor.lib;absl_flags_program_name.lib;absl_flags_reflection.lib;absl_flags_usage.lib;absl_flags_usage_internal.lib;absl_graphcycles_internal.lib;absl_hash.lib;absl_hashtablez_sampler.lib;absl_int128.lib;absl_leak_check.lib;absl_log_severity.lib;absl_low_level_hash.lib;absl_malloc_internal.lib;absl_periodic_sampler.lib;absl_random_distributions.lib;absl_random_internal_distribution_test_util.lib;absl_random_internal_platform.lib;absl_random_internal_pool_urbg.lib;absl_random_internal_randen.lib;absl_random_internal_randen_hwaes.lib;absl_random_internal_randen_hwaes_impl.lib;absl_random_internal_randen_slow.lib;absl_random_internal_seed_material.lib;absl_random_seed_gen_exception.lib;absl_random_seed_sequences.lib;absl_raw_hash_set.lib;absl_raw_logging_internal.lib;absl_scoped_set_env.lib;absl_spinlock_wait.lib;absl_stacktrace.lib;absl_status.lib;absl_statusor.lib;absl_strerror.lib;absl_strings.lib;absl_strings_internal.lib;absl_str_format_internal.lib;absl_symbolize.lib;absl_synchronization.lib;absl_throw_delegate.lib;absl_time.lib;absl_time_zone.lib;address_sorting.lib;cares.lib;descriptor_upb_proto.lib;gpr.lib;grpc++.lib;grpc++_alts.lib;grpc++_error_details.lib;grpc++_unsecure.lib;grpc.lib;grpc_plugin_support.lib;grpc_unsecure.lib;libcrypto.lib;libprotobuf-lite.lib;libprotobuf.lib;libprotoc.lib;libssl.lib;re2.lib;upb.lib;upb_collections.lib;upb_extension_registry.lib;upb_fastdecode.lib;upb_json.lib;upb_mini_table.lib;upb_reflection.lib;upb_textformat.lib;upb_utf8_range.lib;zlib.lib;Ws2_32.lib;Crypt32.lib;Iphlpapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>..\lib\release;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="..\proto\Message2Clients.pb.cc" />
+    <ClCompile Include="..\proto\Message2Server.pb.cc" />
+    <ClCompile Include="..\proto\MessageType.pb.cc" />
+    <ClCompile Include="..\proto\Services.grpc.pb.cc" />
+    <ClCompile Include="..\proto\Services.pb.cc" />
+    <ClCompile Include="src\AI.cpp" />
+    <ClCompile Include="src\API.cpp" />
+    <ClCompile Include="src\Communication.cpp" />
+    <ClCompile Include="src\DebugAPI.cpp" />
+    <ClCompile Include="src\logic.cpp" />
+    <ClCompile Include="src\main.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\proto\Message2Clients.pb.h" />
+    <ClInclude Include="..\proto\Message2Server.pb.h" />
+    <ClInclude Include="..\proto\MessageType.pb.h" />
+    <ClInclude Include="..\proto\Services.grpc.pb.h" />
+    <ClInclude Include="..\proto\Services.pb.h" />
+    <ClInclude Include="include\AI.h" />
+    <ClInclude Include="include\API.h" />
+    <ClInclude Include="include\Communication.h" />
+    <ClInclude Include="include\ConcurrentQueue.hpp" />
+    <ClInclude Include="include\constants.h" />
+    <ClInclude Include="include\logic.h" />
+    <ClInclude Include="include\state.h" />
+    <ClInclude Include="include\structures.h" />
+    <ClInclude Include="include\utils.hpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
diff --git a/CAPI/cpp/API/API.vcxproj.filters b/CAPI/cpp/API/API.vcxproj.filters
index afef69e..7d36dca 100644
--- a/CAPI/cpp/API/API.vcxproj.filters
+++ b/CAPI/cpp/API/API.vcxproj.filters
@@ -13,5 +13,90 @@
       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
     </Filter>
+    <Filter Include="源文件\proto">
+      <UniqueIdentifier>{6aeaa732-c471-4ec4-9de4-1e6f8acc7e92}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="头文件\proto">
+      <UniqueIdentifier>{3de9b3fe-8273-490b-b433-5fde647f1a60}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\AI.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="src\API.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Communication.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="src\DebugAPI.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="src\logic.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="src\main.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="..\proto\Message2Clients.pb.cc">
+      <Filter>源文件\proto</Filter>
+    </ClCompile>
+    <ClCompile Include="..\proto\Message2Server.pb.cc">
+      <Filter>源文件\proto</Filter>
+    </ClCompile>
+    <ClCompile Include="..\proto\MessageType.pb.cc">
+      <Filter>源文件\proto</Filter>
+    </ClCompile>
+    <ClCompile Include="..\proto\Services.grpc.pb.cc">
+      <Filter>源文件\proto</Filter>
+    </ClCompile>
+    <ClCompile Include="..\proto\Services.pb.cc">
+      <Filter>源文件\proto</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="include\AI.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\API.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\Communication.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\ConcurrentQueue.hpp">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\constants.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\logic.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\state.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\structures.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="include\utils.hpp">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="..\proto\Message2Clients.pb.h">
+      <Filter>头文件\proto</Filter>
+    </ClInclude>
+    <ClInclude Include="..\proto\Message2Server.pb.h">
+      <Filter>头文件\proto</Filter>
+    </ClInclude>
+    <ClInclude Include="..\proto\MessageType.pb.h">
+      <Filter>头文件\proto</Filter>
+    </ClInclude>
+    <ClInclude Include="..\proto\Services.grpc.pb.h">
+      <Filter>头文件\proto</Filter>
+    </ClInclude>
+    <ClInclude Include="..\proto\Services.pb.h">
+      <Filter>头文件\proto</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/CAPI/cpp/CAPI.sln b/CAPI/cpp/CAPI.sln
new file mode 100644
index 0000000..9894854
--- /dev/null
+++ b/CAPI/cpp/CAPI.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.33424.131
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "API", "API\API.vcxproj", "{E1983CDE-00FA-474B-92DA-F4964660D7BA}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E1983CDE-00FA-474B-92DA-F4964660D7BA}.Debug|x64.ActiveCfg = Debug|x64
+		{E1983CDE-00FA-474B-92DA-F4964660D7BA}.Debug|x64.Build.0 = Debug|x64
+		{E1983CDE-00FA-474B-92DA-F4964660D7BA}.Debug|x86.ActiveCfg = Debug|Win32
+		{E1983CDE-00FA-474B-92DA-F4964660D7BA}.Debug|x86.Build.0 = Debug|Win32
+		{E1983CDE-00FA-474B-92DA-F4964660D7BA}.Release|x64.ActiveCfg = Release|x64
+		{E1983CDE-00FA-474B-92DA-F4964660D7BA}.Release|x64.Build.0 = Release|x64
+		{E1983CDE-00FA-474B-92DA-F4964660D7BA}.Release|x86.ActiveCfg = Release|Win32
+		{E1983CDE-00FA-474B-92DA-F4964660D7BA}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {5F032F3C-43BF-4F8F-B7F8-72A7354CF4A9}
+	EndGlobalSection
+EndGlobal

From 217d87aeedf6735e3257acb1e2c70574df45b823 Mon Sep 17 00:00:00 2001
From: DragonAura <dragonaurapvp@gmail.com>
Date: Sun, 16 Apr 2023 00:00:10 +0800
Subject: [PATCH 06/10] style: :art: format grpc

---
 .../grpc/include/absl/algorithm/algorithm.h   |   255 +-
 .../grpc/include/absl/algorithm/container.h   |  3279 +-
 CAPI/cpp/grpc/include/absl/base/attributes.h  |    45 +-
 CAPI/cpp/grpc/include/absl/base/call_once.h   |   357 +-
 CAPI/cpp/grpc/include/absl/base/casts.h       |   151 +-
 CAPI/cpp/grpc/include/absl/base/config.h      |    41 +-
 CAPI/cpp/grpc/include/absl/base/const_init.h  |    14 +-
 .../include/absl/base/dynamic_annotations.h   |   248 +-
 .../include/absl/base/internal/atomic_hook.h  |   297 +-
 .../base/internal/atomic_hook_test_helper.h   |    22 +-
 .../include/absl/base/internal/cycleclock.h   |   169 +-
 .../include/absl/base/internal/direct_mmap.h  |   122 +-
 .../absl/base/internal/dynamic_annotations.h  |   168 +-
 .../grpc/include/absl/base/internal/endian.h  |   606 +-
 .../include/absl/base/internal/errno_saver.h  |    50 +-
 .../base/internal/exception_safety_testing.h  |  2336 +-
 .../absl/base/internal/exception_testing.h    |     6 +-
 .../include/absl/base/internal/fast_type_id.h |    44 +-
 .../include/absl/base/internal/hide_ptr.h     |    59 +-
 .../include/absl/base/internal/identity.h     |    25 +-
 .../absl/base/internal/inline_variable.h      |    36 +-
 .../base/internal/inline_variable_testing.h   |    37 +-
 .../grpc/include/absl/base/internal/invoke.h  |   362 +-
 .../absl/base/internal/low_level_alloc.h      |   132 +-
 .../absl/base/internal/low_level_scheduling.h |   220 +-
 .../include/absl/base/internal/prefetch.h     |   116 +-
 .../include/absl/base/internal/raw_logging.h  |   257 +-
 .../absl/base/internal/scheduling_mode.h      |    65 +-
 .../absl/base/internal/scoped_set_env.h       |    41 +-
 .../include/absl/base/internal/spinlock.h     |   434 +-
 .../absl/base/internal/spinlock_wait.h        |    98 +-
 .../include/absl/base/internal/strerror.h     |    28 +-
 .../grpc/include/absl/base/internal/sysinfo.h |    46 +-
 .../absl/base/internal/thread_annotations.h   |    68 +-
 .../absl/base/internal/thread_identity.h      |   327 +-
 .../absl/base/internal/throw_delegate.h       |    90 +-
 .../absl/base/internal/unaligned_access.h     |    86 +-
 .../absl/base/internal/unscaledcycleclock.h   |    87 +-
 .../cpp/grpc/include/absl/base/log_severity.h |   289 +-
 CAPI/cpp/grpc/include/absl/base/macros.h      |    59 +-
 .../cpp/grpc/include/absl/base/optimization.h |    33 +-
 CAPI/cpp/grpc/include/absl/base/options.h     |     3 -
 .../include/absl/base/thread_annotations.h    |    54 +-
 CAPI/cpp/grpc/include/absl/cleanup/cleanup.h  |   108 +-
 .../include/absl/cleanup/internal/cleanup.h   |   160 +-
 .../grpc/include/absl/container/btree_map.h   |  1606 +-
 .../grpc/include/absl/container/btree_set.h   |  1497 +-
 .../grpc/include/absl/container/btree_test.h  |   315 +-
 .../grpc/include/absl/container/fixed_array.h |  1048 +-
 .../include/absl/container/flat_hash_map.h    |  1155 +-
 .../include/absl/container/flat_hash_set.h    |   951 +-
 .../include/absl/container/inlined_vector.h   |  1700 +-
 .../include/absl/container/internal/btree.h   |  6019 +--
 .../absl/container/internal/btree_container.h |  1498 +-
 .../include/absl/container/internal/common.h  |   413 +-
 .../container/internal/compressed_tuple.h     |   503 +-
 .../container/internal/container_memory.h     |   833 +-
 .../container/internal/counting_allocator.h   |   202 +-
 .../internal/hash_function_defaults.h         |   236 +-
 .../internal/hash_generator_testing.h         |   313 +-
 .../container/internal/hash_policy_testing.h  |   330 +-
 .../container/internal/hash_policy_traits.h   |   372 +-
 .../absl/container/internal/hashtable_debug.h |   134 +-
 .../internal/hashtable_debug_hooks.h          |   108 +-
 .../container/internal/hashtablez_sampler.h   |   488 +-
 .../absl/container/internal/inlined_vector.h  |  1964 +-
 .../include/absl/container/internal/layout.h  |  1152 +-
 .../container/internal/node_slot_policy.h     |    85 +-
 .../absl/container/internal/raw_hash_map.h    |   360 +-
 .../absl/container/internal/raw_hash_set.h    |  4601 +--
 .../internal/test_instance_tracker.h          |   564 +-
 .../include/absl/container/internal/tracked.h |   123 +-
 .../internal/unordered_map_constructor_test.h |   962 +-
 .../internal/unordered_map_lookup_test.h      |   174 +-
 .../internal/unordered_map_members_test.h     |   111 +-
 .../internal/unordered_map_modifiers_test.h   |   634 +-
 .../internal/unordered_set_constructor_test.h |   967 +-
 .../internal/unordered_set_lookup_test.h      |   121 +-
 .../internal/unordered_set_members_test.h     |   110 +-
 .../internal/unordered_set_modifiers_test.h   |   398 +-
 .../include/absl/container/node_hash_map.h    |  1114 +-
 .../include/absl/container/node_hash_set.h    |   915 +-
 .../absl/debugging/failure_signal_handler.h   |   127 +-
 .../debugging/internal/address_is_readable.h  |    18 +-
 .../absl/debugging/internal/demangle.h        |    20 +-
 .../absl/debugging/internal/elf_mem_image.h   |   181 +-
 .../absl/debugging/internal/examine_stack.h   |    75 +-
 .../debugging/internal/stack_consumption.h    |    30 +-
 .../debugging/internal/stacktrace_config.h    |    20 +-
 .../absl/debugging/internal/symbolize.h       |   172 +-
 .../absl/debugging/internal/vdso_support.h    |   207 +-
 .../grpc/include/absl/debugging/leak_check.h  |   173 +-
 .../grpc/include/absl/debugging/stacktrace.h  |   364 +-
 .../grpc/include/absl/debugging/symbolize.h   |    77 +-
 .../grpc/include/absl/flags/commandlineflag.h |   322 +-
 CAPI/cpp/grpc/include/absl/flags/config.h     |    30 +-
 CAPI/cpp/grpc/include/absl/flags/declare.h    |    38 +-
 CAPI/cpp/grpc/include/absl/flags/flag.h       |   227 +-
 .../absl/flags/internal/commandlineflag.h     |    81 +-
 .../grpc/include/absl/flags/internal/flag.h   |  1597 +-
 .../grpc/include/absl/flags/internal/parse.h  |    60 +-
 .../include/absl/flags/internal/path_util.h   |    76 +-
 .../flags/internal/private_handle_accessor.h  |    64 +-
 .../absl/flags/internal/program_name.h        |    44 +-
 .../include/absl/flags/internal/registry.h    |   136 +-
 .../absl/flags/internal/sequence_lock.h       |   331 +-
 .../grpc/include/absl/flags/internal/usage.h  |   145 +-
 .../cpp/grpc/include/absl/flags/marshalling.h |   250 +-
 CAPI/cpp/grpc/include/absl/flags/parse.h      |    51 +-
 CAPI/cpp/grpc/include/absl/flags/reflection.h |    97 +-
 CAPI/cpp/grpc/include/absl/flags/usage.h      |    33 +-
 .../grpc/include/absl/flags/usage_config.h    |   151 +-
 .../include/absl/functional/any_invocable.h   |   548 +-
 .../grpc/include/absl/functional/bind_front.h |    27 +-
 .../include/absl/functional/function_ref.h    |   157 +-
 .../absl/functional/internal/any_invocable.h  |  1405 +-
 .../absl/functional/internal/front_binder.h   |   129 +-
 .../absl/functional/internal/function_ref.h   |   172 +-
 CAPI/cpp/grpc/include/absl/hash/hash.h        |   643 +-
 .../cpp/grpc/include/absl/hash/hash_testing.h |   732 +-
 .../grpc/include/absl/hash/internal/city.h    |    33 +-
 .../grpc/include/absl/hash/internal/hash.h    |  2453 +-
 .../absl/hash/internal/low_level_hash.h       |    27 +-
 .../absl/hash/internal/spy_hash_state.h       |   505 +-
 CAPI/cpp/grpc/include/absl/memory/memory.h    |  1329 +-
 CAPI/cpp/grpc/include/absl/meta/type_traits.h |  1363 +-
 CAPI/cpp/grpc/include/absl/numeric/bits.h     |   237 +-
 CAPI/cpp/grpc/include/absl/numeric/int128.h   |  2109 +-
 .../grpc/include/absl/numeric/internal/bits.h |   503 +-
 .../absl/numeric/internal/representation.h    |    61 +-
 .../profiling/internal/exponential_biased.h   |   198 +-
 .../profiling/internal/periodic_sampler.h     |   376 +-
 .../absl/profiling/internal/sample_recorder.h |   437 +-
 .../absl/random/bernoulli_distribution.h      |   380 +-
 .../include/absl/random/beta_distribution.h   |   820 +-
 .../grpc/include/absl/random/bit_gen_ref.h    |   307 +-
 .../absl/random/discrete_distribution.h       |   460 +-
 .../grpc/include/absl/random/distributions.h  |   786 +-
 .../absl/random/exponential_distribution.h    |   299 +-
 .../absl/random/gaussian_distribution.h       |   526 +-
 .../include/absl/random/internal/chi_square.h |   106 +-
 .../random/internal/distribution_caller.h     |   123 +-
 .../random/internal/distribution_test_util.h  |   170 +-
 .../absl/random/internal/explicit_seed_seq.h  |   121 +-
 .../absl/random/internal/fast_uniform_bits.h  |   493 +-
 .../include/absl/random/internal/fastmath.h   |    61 +-
 .../absl/random/internal/generate_real.h      |   227 +-
 .../random/internal/iostream_state_saver.h    |   443 +-
 .../absl/random/internal/mock_helpers.h       |   201 +-
 .../absl/random/internal/mock_overload_set.h  |   130 +-
 .../absl/random/internal/nanobenchmark.h      |   229 +-
 .../absl/random/internal/nonsecure_base.h     |   287 +-
 .../include/absl/random/internal/pcg_engine.h |   579 +-
 .../include/absl/random/internal/pool_urbg.h  |   227 +-
 .../include/absl/random/internal/randen.h     |   115 +-
 .../absl/random/internal/randen_detect.h      |    20 +-
 .../absl/random/internal/randen_engine.h      |   448 +-
 .../absl/random/internal/randen_hwaes.h       |    49 +-
 .../absl/random/internal/randen_slow.h        |    31 +-
 .../absl/random/internal/randen_traits.h      |   103 +-
 .../absl/random/internal/salted_seed_seq.h    |   287 +-
 .../absl/random/internal/seed_material.h      |   151 +-
 .../absl/random/internal/sequence_urbg.h      |    82 +-
 .../include/absl/random/internal/traits.h     |   274 +-
 .../absl/random/internal/uniform_helper.h     |   448 +-
 .../absl/random/internal/wide_multiply.h      |   134 +-
 .../random/log_uniform_int_distribution.h     |   484 +-
 .../include/absl/random/mock_distributions.h  |   383 +-
 .../include/absl/random/mocking_bit_gen.h     |   387 +-
 .../absl/random/poisson_distribution.h        |   494 +-
 CAPI/cpp/grpc/include/absl/random/random.h    |   293 +-
 .../include/absl/random/seed_gen_exception.h  |    43 +-
 .../grpc/include/absl/random/seed_sequences.h |   138 +-
 .../absl/random/uniform_int_distribution.h    |   505 +-
 .../absl/random/uniform_real_distribution.h   |   349 +-
 .../include/absl/random/zipf_distribution.h   |   539 +-
 .../absl/status/internal/status_internal.h    |    79 +-
 .../absl/status/internal/statusor_internal.h  |   778 +-
 CAPI/cpp/grpc/include/absl/status/status.h    |  1704 +-
 .../absl/status/status_payload_printer.h      |    53 +-
 CAPI/cpp/grpc/include/absl/status/statusor.h  |  1516 +-
 CAPI/cpp/grpc/include/absl/strings/ascii.h    |   396 +-
 CAPI/cpp/grpc/include/absl/strings/charconv.h |   187 +-
 CAPI/cpp/grpc/include/absl/strings/cord.h     |  3341 +-
 .../grpc/include/absl/strings/cord_analysis.h |    37 +-
 .../grpc/include/absl/strings/cord_buffer.h   |  1082 +-
 .../include/absl/strings/cord_test_helpers.h  |   195 +-
 .../include/absl/strings/cordz_test_helpers.h |   257 +-
 CAPI/cpp/grpc/include/absl/strings/escaping.h |   256 +-
 .../include/absl/strings/internal/char_map.h  |   302 +-
 .../absl/strings/internal/charconv_bigint.h   |   848 +-
 .../absl/strings/internal/charconv_parse.h    |   135 +-
 .../absl/strings/internal/cord_data_edge.h    |    75 +-
 .../absl/strings/internal/cord_internal.h     |  1347 +-
 .../absl/strings/internal/cord_rep_btree.h    |  1853 +-
 .../internal/cord_rep_btree_navigator.h       |   516 +-
 .../strings/internal/cord_rep_btree_reader.h  |   392 +-
 .../absl/strings/internal/cord_rep_consume.h  |    52 +-
 .../absl/strings/internal/cord_rep_crc.h      |   150 +-
 .../absl/strings/internal/cord_rep_flat.h     |   335 +-
 .../absl/strings/internal/cord_rep_ring.h     |  1194 +-
 .../strings/internal/cord_rep_ring_reader.h   |   204 +-
 .../strings/internal/cord_rep_test_util.h     |   389 +-
 .../absl/strings/internal/cordz_functions.h   |    77 +-
 .../absl/strings/internal/cordz_handle.h      |   219 +-
 .../absl/strings/internal/cordz_info.h        |   535 +-
 .../strings/internal/cordz_sample_token.h     |   140 +-
 .../absl/strings/internal/cordz_statistics.h  |   130 +-
 .../strings/internal/cordz_update_scope.h     |    86 +-
 .../strings/internal/cordz_update_tracker.h   |   215 +-
 .../include/absl/strings/internal/escaping.h  |    70 +-
 .../strings/internal/escaping_test_common.h   |   221 +-
 .../include/absl/strings/internal/memutil.h   |   155 +-
 .../strings/internal/numbers_test_common.h    |   313 +-
 .../absl/strings/internal/ostringstream.h     |   128 +-
 .../absl/strings/internal/pow10_helper.h      |    20 +-
 .../strings/internal/resize_uninitialized.h   |   182 +-
 .../absl/strings/internal/stl_type_traits.h   |   401 +-
 .../absl/strings/internal/str_format/arg.h    |   989 +-
 .../absl/strings/internal/str_format/bind.h   |   458 +-
 .../strings/internal/str_format/checker.h     |   615 +-
 .../strings/internal/str_format/extension.h   |   867 +-
 .../internal/str_format/float_conversion.h    |    21 +-
 .../absl/strings/internal/str_format/output.h |   151 +-
 .../absl/strings/internal/str_format/parser.h |   743 +-
 .../absl/strings/internal/str_join_internal.h |   582 +-
 .../strings/internal/str_split_internal.h     |   854 +-
 .../absl/strings/internal/string_constant.h   |    89 +-
 .../grpc/include/absl/strings/internal/utf8.h |    47 +-
 CAPI/cpp/grpc/include/absl/strings/match.h    |    98 +-
 CAPI/cpp/grpc/include/absl/strings/numbers.h  |   503 +-
 CAPI/cpp/grpc/include/absl/strings/str_cat.h  |   745 +-
 .../grpc/include/absl/strings/str_format.h    |  1501 +-
 CAPI/cpp/grpc/include/absl/strings/str_join.h |   424 +-
 .../grpc/include/absl/strings/str_replace.h   |   349 +-
 .../cpp/grpc/include/absl/strings/str_split.h |  1013 +-
 .../grpc/include/absl/strings/string_view.h   |  1348 +-
 CAPI/cpp/grpc/include/absl/strings/strip.h    |   121 +-
 .../grpc/include/absl/strings/substitute.h    |  1189 +-
 .../include/absl/synchronization/barrier.h    |   101 +-
 .../absl/synchronization/blocking_counter.h   |   132 +-
 .../internal/create_thread_identity.h         |    50 +-
 .../absl/synchronization/internal/futex.h     |   140 +-
 .../synchronization/internal/graphcycles.h    |   198 +-
 .../synchronization/internal/kernel_timeout.h |   252 +-
 .../synchronization/internal/per_thread_sem.h |   131 +-
 .../synchronization/internal/thread_pool.h    |   123 +-
 .../absl/synchronization/internal/waiter.h    |   169 +-
 .../grpc/include/absl/synchronization/mutex.h |  2050 +-
 .../absl/synchronization/notification.h       |   117 +-
 CAPI/cpp/grpc/include/absl/time/civil_time.h  |   905 +-
 CAPI/cpp/grpc/include/absl/time/clock.h       |    56 +-
 .../internal/cctz/include/cctz/civil_time.h   |   609 +-
 .../cctz/include/cctz/civil_time_detail.h     |  1380 +-
 .../internal/cctz/include/cctz/time_zone.h    |   887 +-
 .../cctz/include/cctz/zone_info_source.h      |   140 +-
 .../time/internal/cctz/src/time_zone_fixed.h  |    53 +-
 .../time/internal/cctz/src/time_zone_if.h     |    89 +-
 .../time/internal/cctz/src/time_zone_impl.h   |   141 +-
 .../time/internal/cctz/src/time_zone_info.h   |   213 +-
 .../time/internal/cctz/src/time_zone_libc.h   |    63 +-
 .../time/internal/cctz/src/time_zone_posix.h  |   156 +-
 .../absl/time/internal/cctz/src/tzfile.h      |    21 +-
 .../include/absl/time/internal/test_util.h    |    16 +-
 CAPI/cpp/grpc/include/absl/time/time.h        |  3185 +-
 CAPI/cpp/grpc/include/absl/types/any.h        |   871 +-
 .../grpc/include/absl/types/bad_any_cast.h    |    66 +-
 .../include/absl/types/bad_optional_access.h  |    72 +-
 .../include/absl/types/bad_variant_access.h   |    80 +-
 CAPI/cpp/grpc/include/absl/types/compare.h    |  1135 +-
 .../absl/types/internal/conformance_aliases.h |   867 +-
 .../types/internal/conformance_archetype.h    |  1731 +-
 .../absl/types/internal/conformance_profile.h |  1710 +-
 .../absl/types/internal/conformance_testing.h |  2510 +-
 .../internal/conformance_testing_helpers.h    |   679 +-
 .../include/absl/types/internal/optional.h    |   711 +-
 .../grpc/include/absl/types/internal/span.h   |   210 +-
 .../absl/types/internal/transform_args.h      |   301 +-
 .../include/absl/types/internal/variant.h     |  3354 +-
 CAPI/cpp/grpc/include/absl/types/optional.h   |  1402 +-
 CAPI/cpp/grpc/include/absl/types/span.h       |  1421 +-
 CAPI/cpp/grpc/include/absl/types/variant.h    |  1629 +-
 CAPI/cpp/grpc/include/absl/utility/utility.h  |   579 +-
 CAPI/cpp/grpc/include/ares.h                  |  1106 +-
 CAPI/cpp/grpc/include/ares_build.h            |    11 +-
 CAPI/cpp/grpc/include/ares_dns.h              |   103 +-
 CAPI/cpp/grpc/include/ares_nameser.h          |   390 +-
 CAPI/cpp/grpc/include/ares_rules.h            |    25 +-
 CAPI/cpp/grpc/include/ares_version.h          |    12 +-
 CAPI/cpp/grpc/include/google/protobuf/any.h   |   221 +-
 .../cpp/grpc/include/google/protobuf/any.pb.h |   638 +-
 .../cpp/grpc/include/google/protobuf/api.pb.h |  2803 +-
 CAPI/cpp/grpc/include/google/protobuf/arena.h |  1661 +-
 .../grpc/include/google/protobuf/arena_impl.h |  1339 +-
 .../include/google/protobuf/arenastring.h     |   916 +-
 .../include/google/protobuf/arenaz_sampler.h  |   342 +-
 .../google/protobuf/compiler/code_generator.h |   319 +-
 .../compiler/command_line_interface.h         |   810 +-
 .../google/protobuf/compiler/cpp/file.h       |   320 +-
 .../google/protobuf/compiler/cpp/generator.h  |   121 +-
 .../google/protobuf/compiler/cpp/helpers.h    |  2129 +-
 .../google/protobuf/compiler/cpp/names.h      |    94 +-
 .../compiler/csharp/csharp_doc_comment.h      |    29 +-
 .../compiler/csharp/csharp_generator.h        |    50 +-
 .../protobuf/compiler/csharp/csharp_names.h   |   102 +-
 .../protobuf/compiler/csharp/csharp_options.h |    88 +-
 .../google/protobuf/compiler/importer.h       |   572 +-
 .../google/protobuf/compiler/java/generator.h |    48 +-
 .../protobuf/compiler/java/kotlin_generator.h |    48 +-
 .../google/protobuf/compiler/java/names.h     |    98 +-
 .../objectivec/objectivec_generator.h         |    59 +-
 .../compiler/objectivec/objectivec_helpers.h  |   623 +-
 .../include/google/protobuf/compiler/parser.h |  1023 +-
 .../protobuf/compiler/php/php_generator.h     |    84 +-
 .../include/google/protobuf/compiler/plugin.h |    35 +-
 .../google/protobuf/compiler/plugin.pb.h      |  4033 +-
 .../protobuf/compiler/python/generator.h      |   267 +-
 .../protobuf/compiler/python/pyi_generator.h  |   122 +-
 .../protobuf/compiler/ruby/ruby_generator.h   |    42 +-
 .../grpc/include/google/protobuf/descriptor.h |  4797 +--
 .../include/google/protobuf/descriptor.pb.h   | 30674 +++++++++-------
 .../google/protobuf/descriptor_database.h     |   657 +-
 .../include/google/protobuf/duration.pb.h     |   433 +-
 .../include/google/protobuf/dynamic_message.h |   339 +-
 .../grpc/include/google/protobuf/empty.pb.h   |   285 +-
 .../cpp/grpc/include/google/protobuf/endian.h |   181 +-
 .../google/protobuf/explicitly_constructed.h  |    99 +-
 .../include/google/protobuf/extension_set.h   |  2993 +-
 .../google/protobuf/extension_set_inl.h       |   483 +-
 .../google/protobuf/field_access_listener.h   |   295 +-
 .../include/google/protobuf/field_mask.pb.h   |   507 +-
 .../protobuf/generated_enum_reflection.h      |    81 +-
 .../google/protobuf/generated_enum_util.h     |    72 +-
 .../google/protobuf/generated_message_bases.h |    75 +-
 .../protobuf/generated_message_reflection.h   |   631 +-
 .../protobuf/generated_message_tctable_decl.h |   532 +-
 .../protobuf/generated_message_tctable_impl.h |   654 +-
 .../google/protobuf/generated_message_util.h  |   304 +-
 .../grpc/include/google/protobuf/has_bits.h   |   159 +-
 .../google/protobuf/implicit_weak_message.h   |   398 +-
 .../google/protobuf/inlined_string_field.h    |   966 +-
 .../include/google/protobuf/io/coded_stream.h |  3384 +-
 .../include/google/protobuf/io/gzip_stream.h  |   310 +-
 .../include/google/protobuf/io/io_win32.h     |   120 +-
 .../grpc/include/google/protobuf/io/printer.h |   685 +-
 .../grpc/include/google/protobuf/io/strtod.h  |    27 +-
 .../include/google/protobuf/io/tokenizer.h    |   801 +-
 .../google/protobuf/io/zero_copy_stream.h     |   266 +-
 .../protobuf/io/zero_copy_stream_impl.h       |   583 +-
 .../protobuf/io/zero_copy_stream_impl_lite.h  |   715 +-
 CAPI/cpp/grpc/include/google/protobuf/map.h   |  3077 +-
 .../grpc/include/google/protobuf/map_entry.h  |   152 +-
 .../include/google/protobuf/map_entry_lite.h  |  1171 +-
 .../grpc/include/google/protobuf/map_field.h  |  1878 +-
 .../include/google/protobuf/map_field_inl.h   |   686 +-
 .../include/google/protobuf/map_field_lite.h  |   333 +-
 .../google/protobuf/map_type_handler.h        |  1407 +-
 .../grpc/include/google/protobuf/message.h    |  2635 +-
 .../include/google/protobuf/message_lite.h    |  1089 +-
 .../include/google/protobuf/metadata_lite.h   |   586 +-
 .../include/google/protobuf/parse_context.h   |  2060 +-
 CAPI/cpp/grpc/include/google/protobuf/port.h  |    60 +-
 .../grpc/include/google/protobuf/reflection.h |  1165 +-
 .../include/google/protobuf/reflection_ops.h  |    67 +-
 .../include/google/protobuf/repeated_field.h  |  2446 +-
 .../google/protobuf/repeated_ptr_field.h      |  4108 ++-
 .../grpc/include/google/protobuf/service.h    |   366 +-
 .../google/protobuf/source_context.pb.h       |   443 +-
 .../grpc/include/google/protobuf/struct.pb.h  |  2293 +-
 .../google/protobuf/stubs/bytestream.h        |   610 +-
 .../include/google/protobuf/stubs/callback.h  |  1263 +-
 .../include/google/protobuf/stubs/casts.h     |   187 +-
 .../include/google/protobuf/stubs/common.h    |   206 +-
 .../grpc/include/google/protobuf/stubs/hash.h |   160 +-
 .../include/google/protobuf/stubs/logging.h   |   268 +-
 .../include/google/protobuf/stubs/macros.h    |    94 +-
 .../include/google/protobuf/stubs/map_util.h  |  1515 +-
 .../include/google/protobuf/stubs/mutex.h     |   318 +-
 .../grpc/include/google/protobuf/stubs/once.h |    28 +-
 .../google/protobuf/stubs/platform_macros.h   |    20 +-
 .../grpc/include/google/protobuf/stubs/port.h |   547 +-
 .../include/google/protobuf/stubs/status.h    |   320 +-
 .../include/google/protobuf/stubs/stl_util.h  |    83 +-
 .../google/protobuf/stubs/stringpiece.h       |   534 +-
 .../include/google/protobuf/stubs/strutil.h   |  1833 +-
 .../google/protobuf/stubs/template_util.h     |   176 +-
 .../include/google/protobuf/text_format.h     |  1292 +-
 .../include/google/protobuf/timestamp.pb.h    |   433 +-
 .../grpc/include/google/protobuf/type.pb.h    |  5053 +--
 .../google/protobuf/unknown_field_set.h       |   722 +-
 .../protobuf/util/delimited_message_util.h    |   121 +-
 .../google/protobuf/util/field_comparator.h   |   471 +-
 .../google/protobuf/util/field_mask_util.h    |   406 +-
 .../include/google/protobuf/util/json_util.h  |   312 +-
 .../protobuf/util/message_differencer.h       |  1816 +-
 .../include/google/protobuf/util/time_util.h  |   505 +-
 .../google/protobuf/util/type_resolver.h      |    52 +-
 .../google/protobuf/util/type_resolver_util.h |    26 +-
 .../include/google/protobuf/wire_format.h     |   704 +-
 .../google/protobuf/wire_format_lite.h        |  3829 +-
 .../include/google/protobuf/wrappers.pb.h     |  3431 +-
 CAPI/cpp/grpc/include/grpc/census.h           |    13 +-
 CAPI/cpp/grpc/include/grpc/compression.h      |    85 +-
 .../grpc/event_engine/endpoint_config.h       |    33 +-
 .../include/grpc/event_engine/event_engine.h  |   795 +-
 .../internal/memory_allocator_impl.h          |    69 +-
 .../grpc/event_engine/memory_allocator.h      |   409 +-
 .../grpc/event_engine/memory_request.h        |    85 +-
 .../grpc/include/grpc/event_engine/slice.h    |   600 +-
 .../include/grpc/event_engine/slice_buffer.h  |   192 +-
 CAPI/cpp/grpc/include/grpc/grpc.h             |  1096 +-
 CAPI/cpp/grpc/include/grpc/grpc_posix.h       |    52 +-
 CAPI/cpp/grpc/include/grpc/grpc_security.h    |  2476 +-
 .../include/grpc/grpc_security_constants.h    |   181 +-
 CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h |    10 +-
 .../grpc/impl/codegen/atm_gcc_atomic.h        |    85 +-
 .../include/grpc/impl/codegen/atm_gcc_sync.h  |    53 +-
 .../include/grpc/impl/codegen/atm_windows.h   |   122 +-
 .../include/grpc/impl/codegen/byte_buffer.h   |   133 +-
 .../grpc/impl/codegen/byte_buffer_reader.h    |    25 +-
 .../grpc/impl/codegen/compression_types.h     |   100 +-
 .../grpc/impl/codegen/connectivity_state.h    |    30 +-
 .../include/grpc/impl/codegen/gpr_types.h     |    53 +-
 .../include/grpc/impl/codegen/grpc_types.h    |   906 +-
 CAPI/cpp/grpc/include/grpc/impl/codegen/log.h |    93 +-
 .../include/grpc/impl/codegen/port_platform.h |    19 +-
 .../grpc/impl/codegen/propagation_bits.h      |    12 +-
 .../grpc/include/grpc/impl/codegen/slice.h    |    97 +-
 .../grpc/include/grpc/impl/codegen/status.h   |   250 +-
 .../cpp/grpc/include/grpc/impl/codegen/sync.h |     3 +-
 .../include/grpc/impl/codegen/sync_generic.h  |    23 +-
 .../include/grpc/impl/codegen/sync_posix.h    |    14 +-
 .../include/grpc/impl/codegen/sync_windows.h  |     7 +-
 CAPI/cpp/grpc/include/grpc/load_reporting.h   |     3 +-
 CAPI/cpp/grpc/include/grpc/slice.h            |   244 +-
 CAPI/cpp/grpc/include/grpc/slice_buffer.h     |    92 +-
 CAPI/cpp/grpc/include/grpc/support/alloc.h    |    37 +-
 CAPI/cpp/grpc/include/grpc/support/cpu.h      |    21 +-
 .../grpc/include/grpc/support/log_windows.h   |    13 +-
 .../grpc/include/grpc/support/string_util.h   |    27 +-
 CAPI/cpp/grpc/include/grpc/support/sync.h     |   229 +-
 CAPI/cpp/grpc/include/grpc/support/thd_id.h   |     9 +-
 CAPI/cpp/grpc/include/grpc/support/time.h     |    73 +-
 .../include/grpc/support/workaround_list.h    |     7 +-
 CAPI/cpp/grpc/include/grpcpp/alarm.h          |   141 +-
 CAPI/cpp/grpc/include/grpcpp/channel.h        |   164 +-
 CAPI/cpp/grpc/include/grpcpp/create_channel.h |    93 +-
 .../include/grpcpp/create_channel_binder.h    |   177 +-
 .../include/grpcpp/create_channel_posix.h     |    62 +-
 .../include/grpcpp/ext/call_metric_recorder.h |   122 +-
 ...alth_check_service_server_builder_option.h |    38 +-
 .../include/grpcpp/generic/generic_stub.h     |   274 +-
 CAPI/cpp/grpc/include/grpcpp/grpcpp.h         |     7 +-
 .../grpcpp/health_check_service_interface.h   |    67 +-
 .../grpcpp/impl/channel_argument_option.h     |    13 +-
 .../impl/codegen/async_generic_service.h      |   227 +-
 .../grpcpp/impl/codegen/async_stream.h        |  2284 +-
 .../grpcpp/impl/codegen/async_unary_call.h    |   787 +-
 .../include/grpcpp/impl/codegen/byte_buffer.h |   452 +-
 .../grpc/include/grpcpp/impl/codegen/call.h   |   138 +-
 .../include/grpcpp/impl/codegen/call_hook.h   |    29 +-
 .../include/grpcpp/impl/codegen/call_op_set.h |  2280 +-
 .../impl/codegen/call_op_set_interface.h      |    69 +-
 .../grpcpp/impl/codegen/callback_common.h     |   401 +-
 .../grpcpp/impl/codegen/channel_interface.h   |   270 +-
 .../grpcpp/impl/codegen/client_callback.h     |  2573 +-
 .../grpcpp/impl/codegen/client_context.h      |   968 +-
 .../grpcpp/impl/codegen/client_interceptor.h  |   358 +-
 .../grpcpp/impl/codegen/client_unary_call.h   |   132 +-
 .../grpcpp/impl/codegen/completion_queue.h    |   852 +-
 .../impl/codegen/completion_queue_tag.h       |    59 +-
 .../grpc/include/grpcpp/impl/codegen/config.h |    15 +-
 .../grpcpp/impl/codegen/config_protobuf.h     |    72 +-
 .../grpcpp/impl/codegen/core_codegen.h        |   183 +-
 .../impl/codegen/core_codegen_interface.h     |   241 +-
 .../grpcpp/impl/codegen/create_auth_context.h |     5 +-
 .../grpcpp/impl/codegen/delegating_channel.h  |   132 +-
 .../grpcpp/impl/codegen/grpc_library.h        |    73 +-
 .../grpcpp/impl/codegen/intercepted_channel.h |   126 +-
 .../include/grpcpp/impl/codegen/interceptor.h |   401 +-
 .../grpcpp/impl/codegen/interceptor_common.h  |  1117 +-
 .../grpcpp/impl/codegen/message_allocator.h   |   100 +-
 .../grpcpp/impl/codegen/metadata_map.h        |   173 +-
 .../grpcpp/impl/codegen/method_handler.h      |   772 +-
 .../grpcpp/impl/codegen/proto_buffer_reader.h |   260 +-
 .../grpcpp/impl/codegen/proto_buffer_writer.h |   307 +-
 .../include/grpcpp/impl/codegen/proto_utils.h |   132 +-
 .../include/grpcpp/impl/codegen/rpc_method.h  |   115 +-
 .../grpcpp/impl/codegen/rpc_service_method.h  |   255 +-
 .../impl/codegen/security/auth_context.h      |   133 +-
 .../impl/codegen/serialization_traits.h       |    72 +-
 .../grpcpp/impl/codegen/server_callback.h     |  1674 +-
 .../impl/codegen/server_callback_handlers.h   |  1879 +-
 .../grpcpp/impl/codegen/server_context.h      |  1316 +-
 .../grpcpp/impl/codegen/server_interceptor.h  |   243 +-
 .../grpcpp/impl/codegen/server_interface.h    |   647 +-
 .../grpcpp/impl/codegen/service_type.h        |   432 +-
 .../grpc/include/grpcpp/impl/codegen/slice.h  |   304 +-
 .../grpc/include/grpcpp/impl/codegen/status.h |   207 +-
 .../grpcpp/impl/codegen/status_code_enum.h    |   238 +-
 .../include/grpcpp/impl/codegen/string_ref.h  |   314 +-
 .../grpcpp/impl/codegen/stub_options.h        |    42 +-
 .../grpc/include/grpcpp/impl/codegen/sync.h   |   235 +-
 .../include/grpcpp/impl/codegen/sync_stream.h |  1924 +-
 .../grpc/include/grpcpp/impl/codegen/time.h   |   127 +-
 .../grpc/include/grpcpp/impl/grpc_library.h   |    74 +-
 .../grpcpp/impl/server_builder_option.h       |    27 +-
 .../grpcpp/impl/server_builder_plugin.h       |    70 +-
 .../include/grpcpp/impl/server_initializer.h  |    56 +-
 CAPI/cpp/grpc/include/grpcpp/resource_quota.h |    69 +-
 .../include/grpcpp/security/alts_context.h    |    71 +-
 .../grpc/include/grpcpp/security/alts_util.h  |    38 +-
 .../grpcpp/security/auth_metadata_processor.h |    80 +-
 .../security/authorization_policy_provider.h  |   136 +-
 .../grpcpp/security/binder_credentials.h      |    39 +-
 .../grpcpp/security/binder_security_policy.h  |    95 +-
 .../include/grpcpp/security/credentials.h     |   664 +-
 .../grpcpp/security/server_credentials.h      |   249 +-
 .../security/tls_certificate_provider.h       |   202 +-
 .../security/tls_certificate_verifier.h       |   401 +-
 .../grpcpp/security/tls_credentials_options.h |   236 +-
 CAPI/cpp/grpc/include/grpcpp/server.h         |   616 +-
 CAPI/cpp/grpc/include/grpcpp/server_builder.h |   798 +-
 CAPI/cpp/grpc/include/grpcpp/server_posix.h   |    15 +-
 .../grpcpp/support/channel_arguments.h        |   239 +-
 .../include/grpcpp/support/error_details.h    |   102 +-
 .../grpcpp/support/validate_service_config.h  |    18 +-
 .../grpc/include/grpcpp/xds_server_builder.h  |   209 +-
 .../include/openssl/__DECC_INCLUDE_EPILOGUE.H |     2 +-
 .../include/openssl/__DECC_INCLUDE_PROLOGUE.H |     4 +-
 CAPI/cpp/grpc/include/openssl/aes.h           |   151 +-
 CAPI/cpp/grpc/include/openssl/asn1.h          |  1689 +-
 CAPI/cpp/grpc/include/openssl/asn1err.h       |   242 +-
 CAPI/cpp/grpc/include/openssl/asn1t.h         |  1587 +-
 CAPI/cpp/grpc/include/openssl/async.h         |   114 +-
 CAPI/cpp/grpc/include/openssl/asyncerr.h      |    20 +-
 CAPI/cpp/grpc/include/openssl/bio.h           |  1410 +-
 CAPI/cpp/grpc/include/openssl/bioerr.h        |    92 +-
 CAPI/cpp/grpc/include/openssl/blowfish.h      |    87 +-
 CAPI/cpp/grpc/include/openssl/bn.h            |   984 +-
 CAPI/cpp/grpc/include/openssl/bnerr.h         |    56 +-
 CAPI/cpp/grpc/include/openssl/buffer.h        |    80 +-
 CAPI/cpp/grpc/include/openssl/buffererr.h     |    12 +-
 CAPI/cpp/grpc/include/openssl/camellia.h      |   142 +-
 CAPI/cpp/grpc/include/openssl/cast.h          |    91 +-
 CAPI/cpp/grpc/include/openssl/cmac.h          |    75 +-
 CAPI/cpp/grpc/include/openssl/cmp.h           |   707 +-
 CAPI/cpp/grpc/include/openssl/cmp_util.h      |    83 +-
 CAPI/cpp/grpc/include/openssl/cmperr.h        |   184 +-
 CAPI/cpp/grpc/include/openssl/cms.h           |   723 +-
 CAPI/cpp/grpc/include/openssl/cmserr.h        |   204 +-
 CAPI/cpp/grpc/include/openssl/comp.h          |    70 +-
 CAPI/cpp/grpc/include/openssl/comperr.h       |    22 +-
 CAPI/cpp/grpc/include/openssl/conf.h          |   270 +-
 CAPI/cpp/grpc/include/openssl/conf_api.h      |    50 +-
 CAPI/cpp/grpc/include/openssl/conferr.h       |    64 +-
 CAPI/cpp/grpc/include/openssl/configuration.h |   234 +-
 CAPI/cpp/grpc/include/openssl/conftypes.h     |    46 +-
 CAPI/cpp/grpc/include/openssl/core.h          |   306 +-
 CAPI/cpp/grpc/include/openssl/core_dispatch.h |  1378 +-
 CAPI/cpp/grpc/include/openssl/core_names.h    |   729 +-
 CAPI/cpp/grpc/include/openssl/core_object.h   |    31 +-
 CAPI/cpp/grpc/include/openssl/crmf.h          |   316 +-
 CAPI/cpp/grpc/include/openssl/crmferr.h       |    60 +-
 CAPI/cpp/grpc/include/openssl/crypto.h        |   889 +-
 CAPI/cpp/grpc/include/openssl/cryptoerr.h     |    54 +-
 .../grpc/include/openssl/cryptoerr_legacy.h   |  2641 +-
 CAPI/cpp/grpc/include/openssl/ct.h            |  1024 +-
 CAPI/cpp/grpc/include/openssl/cterr.h         |    50 +-
 CAPI/cpp/grpc/include/openssl/decoder.h       |   205 +-
 CAPI/cpp/grpc/include/openssl/decodererr.h    |    18 +-
 CAPI/cpp/grpc/include/openssl/des.h           |   300 +-
 CAPI/cpp/grpc/include/openssl/dh.h            |   510 +-
 CAPI/cpp/grpc/include/openssl/dherr.h         |    74 +-
 CAPI/cpp/grpc/include/openssl/dsa.h           |   444 +-
 CAPI/cpp/grpc/include/openssl/dsaerr.h        |    46 +-
 CAPI/cpp/grpc/include/openssl/dtls1.h         |    51 +-
 CAPI/cpp/grpc/include/openssl/e_os2.h         |   445 +-
 CAPI/cpp/grpc/include/openssl/ebcdic.h        |    37 +-
 CAPI/cpp/grpc/include/openssl/ec.h            |  2838 +-
 CAPI/cpp/grpc/include/openssl/ecerr.h         |   166 +-
 CAPI/cpp/grpc/include/openssl/encoder.h       |   191 +-
 CAPI/cpp/grpc/include/openssl/encodererr.h    |    18 +-
 CAPI/cpp/grpc/include/openssl/engine.h        |   978 +-
 CAPI/cpp/grpc/include/openssl/engineerr.h     |    86 +-
 CAPI/cpp/grpc/include/openssl/err.h           |   704 +-
 CAPI/cpp/grpc/include/openssl/ess.h           |   132 +-
 CAPI/cpp/grpc/include/openssl/esserr.h        |    28 +-
 CAPI/cpp/grpc/include/openssl/evp.h           |  3536 +-
 CAPI/cpp/grpc/include/openssl/evperr.h        |   230 +-
 CAPI/cpp/grpc/include/openssl/fips_names.h    |    27 +-
 CAPI/cpp/grpc/include/openssl/fipskey.h       |    15 +-
 CAPI/cpp/grpc/include/openssl/hmac.h          |    92 +-
 CAPI/cpp/grpc/include/openssl/http.h          |   133 +-
 CAPI/cpp/grpc/include/openssl/httperr.h       |    72 +-
 CAPI/cpp/grpc/include/openssl/idea.h          |    99 +-
 CAPI/cpp/grpc/include/openssl/kdf.h           |   198 +-
 CAPI/cpp/grpc/include/openssl/kdferr.h        |     4 +-
 CAPI/cpp/grpc/include/openssl/lhash.h         |   428 +-
 CAPI/cpp/grpc/include/openssl/macros.h        |   377 +-
 CAPI/cpp/grpc/include/openssl/md2.h           |    88 +-
 CAPI/cpp/grpc/include/openssl/md4.h           |    79 +-
 CAPI/cpp/grpc/include/openssl/md5.h           |    79 +-
 CAPI/cpp/grpc/include/openssl/mdc2.h          |    84 +-
 CAPI/cpp/grpc/include/openssl/modes.h         |   308 +-
 CAPI/cpp/grpc/include/openssl/obj_mac.h       | 10306 +++---
 CAPI/cpp/grpc/include/openssl/objects.h       |   299 +-
 CAPI/cpp/grpc/include/openssl/objectserr.h    |    18 +-
 CAPI/cpp/grpc/include/openssl/ocsp.h          |   698 +-
 CAPI/cpp/grpc/include/openssl/ocsperr.h       |    66 +-
 CAPI/cpp/grpc/include/openssl/opensslconf.h   |    10 +-
 CAPI/cpp/grpc/include/openssl/opensslv.h      |    72 +-
 CAPI/cpp/grpc/include/openssl/ossl_typ.h      |     2 +-
 CAPI/cpp/grpc/include/openssl/param_build.h   |    77 +-
 CAPI/cpp/grpc/include/openssl/params.h        |   239 +-
 CAPI/cpp/grpc/include/openssl/pem.h           |   784 +-
 CAPI/cpp/grpc/include/openssl/pem2.h          |    14 +-
 CAPI/cpp/grpc/include/openssl/pemerr.h        |    78 +-
 CAPI/cpp/grpc/include/openssl/pkcs12.h        |   469 +-
 CAPI/cpp/grpc/include/openssl/pkcs12err.h     |    52 +-
 CAPI/cpp/grpc/include/openssl/pkcs7.h         |   699 +-
 CAPI/cpp/grpc/include/openssl/pkcs7err.h      |    88 +-
 CAPI/cpp/grpc/include/openssl/prov_ssl.h      |    35 +-
 CAPI/cpp/grpc/include/openssl/proverr.h       |   258 +-
 CAPI/cpp/grpc/include/openssl/provider.h      |    85 +-
 CAPI/cpp/grpc/include/openssl/rand.h          |   191 +-
 CAPI/cpp/grpc/include/openssl/randerr.h       |    98 +-
 CAPI/cpp/grpc/include/openssl/rc2.h           |    82 +-
 CAPI/cpp/grpc/include/openssl/rc4.h           |    57 +-
 CAPI/cpp/grpc/include/openssl/rc5.h           |    93 +-
 CAPI/cpp/grpc/include/openssl/ripemd.h        |    93 +-
 CAPI/cpp/grpc/include/openssl/rsa.h           |   882 +-
 CAPI/cpp/grpc/include/openssl/rsaerr.h        |   176 +-
 CAPI/cpp/grpc/include/openssl/safestack.h     |   441 +-
 CAPI/cpp/grpc/include/openssl/seed.h          |   117 +-
 CAPI/cpp/grpc/include/openssl/self_test.h     |   134 +-
 CAPI/cpp/grpc/include/openssl/sha.h           |   205 +-
 CAPI/cpp/grpc/include/openssl/srp.h           |   406 +-
 CAPI/cpp/grpc/include/openssl/srtp.h          |    49 +-
 CAPI/cpp/grpc/include/openssl/ssl.h           |  4067 +-
 CAPI/cpp/grpc/include/openssl/ssl2.h          |    23 +-
 CAPI/cpp/grpc/include/openssl/ssl3.h          |   524 +-
 CAPI/cpp/grpc/include/openssl/sslerr.h        |   648 +-
 CAPI/cpp/grpc/include/openssl/sslerr_legacy.h |   879 +-
 CAPI/cpp/grpc/include/openssl/stack.h         |   130 +-
 CAPI/cpp/grpc/include/openssl/store.h         |   573 +-
 CAPI/cpp/grpc/include/openssl/storeerr.h      |    60 +-
 CAPI/cpp/grpc/include/openssl/symhacks.h      |    44 +-
 CAPI/cpp/grpc/include/openssl/tls1.h          |  1922 +-
 CAPI/cpp/grpc/include/openssl/trace.h         |   464 +-
 CAPI/cpp/grpc/include/openssl/ts.h            |   736 +-
 CAPI/cpp/grpc/include/openssl/tserr.h         |    94 +-
 CAPI/cpp/grpc/include/openssl/txt_db.h        |    94 +-
 CAPI/cpp/grpc/include/openssl/types.h         |   323 +-
 CAPI/cpp/grpc/include/openssl/ui.h            |   633 +-
 CAPI/cpp/grpc/include/openssl/uierr.h         |    38 +-
 CAPI/cpp/grpc/include/openssl/whrlpool.h      |    98 +-
 CAPI/cpp/grpc/include/openssl/x509.h          |  1977 +-
 CAPI/cpp/grpc/include/openssl/x509_vfy.h      |  1331 +-
 CAPI/cpp/grpc/include/openssl/x509err.h       |    98 +-
 CAPI/cpp/grpc/include/openssl/x509v3.h        |  2188 +-
 CAPI/cpp/grpc/include/openssl/x509v3err.h     |   148 +-
 CAPI/cpp/grpc/include/re2/filtered_re2.h      |   163 +-
 CAPI/cpp/grpc/include/re2/re2.h               |  1652 +-
 CAPI/cpp/grpc/include/re2/set.h               |   134 +-
 CAPI/cpp/grpc/include/re2/stringpiece.h       |   400 +-
 CAPI/cpp/grpc/include/upb/arena.h             |   325 +-
 CAPI/cpp/grpc/include/upb/array.h             |    55 +-
 CAPI/cpp/grpc/include/upb/bindings/lua/upb.h  |    28 +-
 CAPI/cpp/grpc/include/upb/decode.h            |    76 +-
 CAPI/cpp/grpc/include/upb/decode_fast.h       |    62 +-
 CAPI/cpp/grpc/include/upb/def.h               |   689 +-
 CAPI/cpp/grpc/include/upb/def.hpp             |  1068 +-
 CAPI/cpp/grpc/include/upb/encode.h            |    49 +-
 .../cpp/grpc/include/upb/extension_registry.h |    79 +-
 CAPI/cpp/grpc/include/upb/internal/decode.h   |   233 +-
 .../upb/internal/mini_table_accessors.h       |    31 +-
 CAPI/cpp/grpc/include/upb/internal/table.h    |   600 +-
 CAPI/cpp/grpc/include/upb/internal/upb.h      |    40 +-
 .../include/upb/internal/vsnprintf_compat.h   |    20 +-
 CAPI/cpp/grpc/include/upb/json_decode.h       |    12 +-
 CAPI/cpp/grpc/include/upb/json_encode.h       |    42 +-
 CAPI/cpp/grpc/include/upb/map.h               |   139 +-
 CAPI/cpp/grpc/include/upb/message_value.h     |    43 +-
 CAPI/cpp/grpc/include/upb/mini_descriptor.h   |    16 +-
 CAPI/cpp/grpc/include/upb/mini_table.h        |   265 +-
 CAPI/cpp/grpc/include/upb/mini_table.hpp      |   166 +-
 .../grpc/include/upb/mini_table_accessors.h   |   426 +-
 CAPI/cpp/grpc/include/upb/msg.h               |    28 +-
 CAPI/cpp/grpc/include/upb/msg_internal.h      |  1631 +-
 CAPI/cpp/grpc/include/upb/reflection.h        |    92 +-
 CAPI/cpp/grpc/include/upb/reflection.hpp      |     5 +-
 CAPI/cpp/grpc/include/upb/status.h            |    32 +-
 CAPI/cpp/grpc/include/upb/text_encode.h       |    40 +-
 CAPI/cpp/grpc/include/upb/upb.h               |   241 +-
 CAPI/cpp/grpc/include/upb/upb.hpp             |   194 +-
 CAPI/cpp/grpc/include/upb/util/compare.h      |    44 +-
 CAPI/cpp/grpc/include/upb/util/def_to_proto.h |    45 +-
 .../grpc/include/upb/util/required_fields.h   |    90 +-
 CAPI/cpp/grpc/include/zconf.h                 |   702 +-
 CAPI/cpp/grpc/include/zlib.h                  |  3600 +-
 701 files changed, 202321 insertions(+), 183979 deletions(-)

diff --git a/CAPI/cpp/grpc/include/absl/algorithm/algorithm.h b/CAPI/cpp/grpc/include/absl/algorithm/algorithm.h
index e9b4733..865b6d1 100644
--- a/CAPI/cpp/grpc/include/absl/algorithm/algorithm.h
+++ b/CAPI/cpp/grpc/include/absl/algorithm/algorithm.h
@@ -28,132 +28,135 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace algorithm_internal {
-
-// Performs comparisons with operator==, similar to C++14's `std::equal_to<>`.
-struct EqualTo {
-  template <typename T, typename U>
-  bool operator()(const T& a, const U& b) const {
-    return a == b;
-  }
-};
-
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
-               InputIter2 last2, Pred pred, std::input_iterator_tag,
-               std::input_iterator_tag) {
-  while (true) {
-    if (first1 == last1) return first2 == last2;
-    if (first2 == last2) return false;
-    if (!pred(*first1, *first2)) return false;
-    ++first1;
-    ++first2;
-  }
-}
-
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
-               InputIter2 last2, Pred&& pred, std::random_access_iterator_tag,
-               std::random_access_iterator_tag) {
-  return (last1 - first1 == last2 - first2) &&
-         std::equal(first1, last1, first2, std::forward<Pred>(pred));
-}
-
-// When we are using our own internal predicate that just applies operator==, we
-// forward to the non-predicate form of std::equal. This enables an optimization
-// in libstdc++ that can result in std::memcmp being used for integer types.
-template <typename InputIter1, typename InputIter2>
-bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
-               InputIter2 last2, algorithm_internal::EqualTo /* unused */,
-               std::random_access_iterator_tag,
-               std::random_access_iterator_tag) {
-  return (last1 - first1 == last2 - first2) &&
-         std::equal(first1, last1, first2);
-}
-
-template <typename It>
-It RotateImpl(It first, It middle, It last, std::true_type) {
-  return std::rotate(first, middle, last);
-}
-
-template <typename It>
-It RotateImpl(It first, It middle, It last, std::false_type) {
-  std::rotate(first, middle, last);
-  return std::next(first, std::distance(middle, last));
-}
-
-}  // namespace algorithm_internal
-
-// equal()
-//
-// Compares the equality of two ranges specified by pairs of iterators, using
-// the given predicate, returning true iff for each corresponding iterator i1
-// and i2 in the first and second range respectively, pred(*i1, *i2) == true
-//
-// This comparison takes at most min(`last1` - `first1`, `last2` - `first2`)
-// invocations of the predicate. Additionally, if InputIter1 and InputIter2 are
-// both random-access iterators, and `last1` - `first1` != `last2` - `first2`,
-// then the predicate is never invoked and the function returns false.
-//
-// This is a C++11-compatible implementation of C++14 `std::equal`.  See
-// https://en.cppreference.com/w/cpp/algorithm/equal for more information.
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
-           InputIter2 last2, Pred&& pred) {
-  return algorithm_internal::EqualImpl(
-      first1, last1, first2, last2, std::forward<Pred>(pred),
-      typename std::iterator_traits<InputIter1>::iterator_category{},
-      typename std::iterator_traits<InputIter2>::iterator_category{});
-}
-
-// Overload of equal() that performs comparison of two ranges specified by pairs
-// of iterators using operator==.
-template <typename InputIter1, typename InputIter2>
-bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
-           InputIter2 last2) {
-  return absl::equal(first1, last1, first2, last2,
-                     algorithm_internal::EqualTo{});
-}
-
-// linear_search()
-//
-// Performs a linear search for `value` using the iterator `first` up to
-// but not including `last`, returning true if [`first`, `last`) contains an
-// element equal to `value`.
-//
-// A linear search is of O(n) complexity which is guaranteed to make at most
-// n = (`last` - `first`) comparisons. A linear search over short containers
-// may be faster than a binary search, even when the container is sorted.
-template <typename InputIterator, typename EqualityComparable>
-bool linear_search(InputIterator first, InputIterator last,
-                   const EqualityComparable& value) {
-  return std::find(first, last, value) != last;
-}
-
-// rotate()
-//
-// Performs a left rotation on a range of elements (`first`, `last`) such that
-// `middle` is now the first element. `rotate()` returns an iterator pointing to
-// the first element before rotation. This function is exactly the same as
-// `std::rotate`, but fixes a bug in gcc
-// <= 4.9 where `std::rotate` returns `void` instead of an iterator.
-//
-// The complexity of this algorithm is the same as that of `std::rotate`, but if
-// `ForwardIterator` is not a random-access iterator, then `absl::rotate`
-// performs an additional pass over the range to construct the return value.
-template <typename ForwardIterator>
-ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
-                       ForwardIterator last) {
-  return algorithm_internal::RotateImpl(
-      first, middle, last,
-      std::is_same<decltype(std::rotate(first, middle, last)),
-                   ForwardIterator>());
-}
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    namespace algorithm_internal
+    {
+
+        // Performs comparisons with operator==, similar to C++14's `std::equal_to<>`.
+        struct EqualTo
+        {
+            template<typename T, typename U>
+            bool operator()(const T& a, const U& b) const
+            {
+                return a == b;
+            }
+        };
+
+        template<typename InputIter1, typename InputIter2, typename Pred>
+        bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, Pred pred, std::input_iterator_tag, std::input_iterator_tag)
+        {
+            while (true)
+            {
+                if (first1 == last1)
+                    return first2 == last2;
+                if (first2 == last2)
+                    return false;
+                if (!pred(*first1, *first2))
+                    return false;
+                ++first1;
+                ++first2;
+            }
+        }
+
+        template<typename InputIter1, typename InputIter2, typename Pred>
+        bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, Pred&& pred, std::random_access_iterator_tag, std::random_access_iterator_tag)
+        {
+            return (last1 - first1 == last2 - first2) &&
+                   std::equal(first1, last1, first2, std::forward<Pred>(pred));
+        }
+
+        // When we are using our own internal predicate that just applies operator==, we
+        // forward to the non-predicate form of std::equal. This enables an optimization
+        // in libstdc++ that can result in std::memcmp being used for integer types.
+        template<typename InputIter1, typename InputIter2>
+        bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, algorithm_internal::EqualTo /* unused */, std::random_access_iterator_tag, std::random_access_iterator_tag)
+        {
+            return (last1 - first1 == last2 - first2) &&
+                   std::equal(first1, last1, first2);
+        }
+
+        template<typename It>
+        It RotateImpl(It first, It middle, It last, std::true_type)
+        {
+            return std::rotate(first, middle, last);
+        }
+
+        template<typename It>
+        It RotateImpl(It first, It middle, It last, std::false_type)
+        {
+            std::rotate(first, middle, last);
+            return std::next(first, std::distance(middle, last));
+        }
+
+    }  // namespace algorithm_internal
+
+    // equal()
+    //
+    // Compares the equality of two ranges specified by pairs of iterators, using
+    // the given predicate, returning true iff for each corresponding iterator i1
+    // and i2 in the first and second range respectively, pred(*i1, *i2) == true
+    //
+    // This comparison takes at most min(`last1` - `first1`, `last2` - `first2`)
+    // invocations of the predicate. Additionally, if InputIter1 and InputIter2 are
+    // both random-access iterators, and `last1` - `first1` != `last2` - `first2`,
+    // then the predicate is never invoked and the function returns false.
+    //
+    // This is a C++11-compatible implementation of C++14 `std::equal`.  See
+    // https://en.cppreference.com/w/cpp/algorithm/equal for more information.
+    template<typename InputIter1, typename InputIter2, typename Pred>
+    bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, Pred&& pred)
+    {
+        return algorithm_internal::EqualImpl(
+            first1, last1, first2, last2, std::forward<Pred>(pred), typename std::iterator_traits<InputIter1>::iterator_category{}, typename std::iterator_traits<InputIter2>::iterator_category{}
+        );
+    }
+
+    // Overload of equal() that performs comparison of two ranges specified by pairs
+    // of iterators using operator==.
+    template<typename InputIter1, typename InputIter2>
+    bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2)
+    {
+        return absl::equal(first1, last1, first2, last2, algorithm_internal::EqualTo{});
+    }
+
+    // linear_search()
+    //
+    // Performs a linear search for `value` using the iterator `first` up to
+    // but not including `last`, returning true if [`first`, `last`) contains an
+    // element equal to `value`.
+    //
+    // A linear search is of O(n) complexity which is guaranteed to make at most
+    // n = (`last` - `first`) comparisons. A linear search over short containers
+    // may be faster than a binary search, even when the container is sorted.
+    template<typename InputIterator, typename EqualityComparable>
+    bool linear_search(InputIterator first, InputIterator last, const EqualityComparable& value)
+    {
+        return std::find(first, last, value) != last;
+    }
+
+    // rotate()
+    //
+    // Performs a left rotation on a range of elements (`first`, `last`) such that
+    // `middle` is now the first element. `rotate()` returns an iterator pointing to
+    // the first element before rotation. This function is exactly the same as
+    // `std::rotate`, but fixes a bug in gcc
+    // <= 4.9 where `std::rotate` returns `void` instead of an iterator.
+    //
+    // The complexity of this algorithm is the same as that of `std::rotate`, but if
+    // `ForwardIterator` is not a random-access iterator, then `absl::rotate`
+    // performs an additional pass over the range to construct the return value.
+    template<typename ForwardIterator>
+    ForwardIterator rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last)
+    {
+        return algorithm_internal::RotateImpl(
+            first, middle, last, std::is_same<decltype(std::rotate(first, middle, last)), ForwardIterator>()
+        );
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_ALGORITHM_ALGORITHM_H_
diff --git a/CAPI/cpp/grpc/include/absl/algorithm/container.h b/CAPI/cpp/grpc/include/absl/algorithm/container.h
index 26b1952..3ffb238 100644
--- a/CAPI/cpp/grpc/include/absl/algorithm/container.h
+++ b/CAPI/cpp/grpc/include/absl/algorithm/container.h
@@ -54,1721 +54,1570 @@
 #include "absl/base/macros.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_algorithm_internal {
-
-// NOTE: it is important to defer to ADL lookup for building with C++ modules,
-// especially for headers like <valarray> which are not visible from this file
-// but specialize std::begin and std::end.
-using std::begin;
-using std::end;
-
-// The type of the iterator given by begin(c) (possibly std::begin(c)).
-// ContainerIter<const vector<T>> gives vector<T>::const_iterator,
-// while ContainerIter<vector<T>> gives vector<T>::iterator.
-template <typename C>
-using ContainerIter = decltype(begin(std::declval<C&>()));
-
-// An MSVC bug involving template parameter substitution requires us to use
-// decltype() here instead of just std::pair.
-template <typename C1, typename C2>
-using ContainerIterPairType =
-    decltype(std::make_pair(ContainerIter<C1>(), ContainerIter<C2>()));
-
-template <typename C>
-using ContainerDifferenceType =
-    decltype(std::distance(std::declval<ContainerIter<C>>(),
-                           std::declval<ContainerIter<C>>()));
-
-template <typename C>
-using ContainerPointerType =
-    typename std::iterator_traits<ContainerIter<C>>::pointer;
-
-// container_algorithm_internal::c_begin and
-// container_algorithm_internal::c_end are abbreviations for proper ADL
-// lookup of std::begin and std::end, i.e.
-//   using std::begin;
-//   using std::end;
-//   std::foo(begin(c), end(c));
-// becomes
-//   std::foo(container_algorithm_internal::begin(c),
-//            container_algorithm_internal::end(c));
-// These are meant for internal use only.
-
-template <typename C>
-ContainerIter<C> c_begin(C& c) { return begin(c); }
-
-template <typename C>
-ContainerIter<C> c_end(C& c) { return end(c); }
-
-template <typename T>
-struct IsUnorderedContainer : std::false_type {};
-
-template <class Key, class T, class Hash, class KeyEqual, class Allocator>
-struct IsUnorderedContainer<
-    std::unordered_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {};
-
-template <class Key, class Hash, class KeyEqual, class Allocator>
-struct IsUnorderedContainer<std::unordered_set<Key, Hash, KeyEqual, Allocator>>
-    : std::true_type {};
-
-// container_algorithm_internal::c_size. It is meant for internal use only.
-
-template <class C>
-auto c_size(C& c) -> decltype(c.size()) {
-  return c.size();
-}
-
-template <class T, std::size_t N>
-constexpr std::size_t c_size(T (&)[N]) {
-  return N;
-}
-
-}  // namespace container_algorithm_internal
-
-// PUBLIC API
-
-//------------------------------------------------------------------------------
-// Abseil algorithm.h functions
-//------------------------------------------------------------------------------
-
-// c_linear_search()
-//
-// Container-based version of absl::linear_search() for performing a linear
-// search within a container.
-template <typename C, typename EqualityComparable>
-bool c_linear_search(const C& c, EqualityComparable&& value) {
-  return linear_search(container_algorithm_internal::c_begin(c),
-                       container_algorithm_internal::c_end(c),
-                       std::forward<EqualityComparable>(value));
-}
-
-//------------------------------------------------------------------------------
-// <iterator> algorithms
-//------------------------------------------------------------------------------
-
-// c_distance()
-//
-// Container-based version of the <iterator> `std::distance()` function to
-// return the number of elements within a container.
-template <typename C>
-container_algorithm_internal::ContainerDifferenceType<const C> c_distance(
-    const C& c) {
-  return std::distance(container_algorithm_internal::c_begin(c),
-                       container_algorithm_internal::c_end(c));
-}
-
-//------------------------------------------------------------------------------
-// <algorithm> Non-modifying sequence operations
-//------------------------------------------------------------------------------
-
-// c_all_of()
-//
-// Container-based version of the <algorithm> `std::all_of()` function to
-// test if all elements within a container satisfy a condition.
-template <typename C, typename Pred>
-bool c_all_of(const C& c, Pred&& pred) {
-  return std::all_of(container_algorithm_internal::c_begin(c),
-                     container_algorithm_internal::c_end(c),
-                     std::forward<Pred>(pred));
-}
-
-// c_any_of()
-//
-// Container-based version of the <algorithm> `std::any_of()` function to
-// test if any element in a container fulfills a condition.
-template <typename C, typename Pred>
-bool c_any_of(const C& c, Pred&& pred) {
-  return std::any_of(container_algorithm_internal::c_begin(c),
-                     container_algorithm_internal::c_end(c),
-                     std::forward<Pred>(pred));
-}
-
-// c_none_of()
-//
-// Container-based version of the <algorithm> `std::none_of()` function to
-// test if no elements in a container fulfill a condition.
-template <typename C, typename Pred>
-bool c_none_of(const C& c, Pred&& pred) {
-  return std::none_of(container_algorithm_internal::c_begin(c),
-                      container_algorithm_internal::c_end(c),
-                      std::forward<Pred>(pred));
-}
-
-// c_for_each()
-//
-// Container-based version of the <algorithm> `std::for_each()` function to
-// apply a function to a container's elements.
-template <typename C, typename Function>
-decay_t<Function> c_for_each(C&& c, Function&& f) {
-  return std::for_each(container_algorithm_internal::c_begin(c),
-                       container_algorithm_internal::c_end(c),
-                       std::forward<Function>(f));
-}
-
-// c_find()
-//
-// Container-based version of the <algorithm> `std::find()` function to find
-// the first element containing the passed value within a container value.
-template <typename C, typename T>
-container_algorithm_internal::ContainerIter<C> c_find(C& c, T&& value) {
-  return std::find(container_algorithm_internal::c_begin(c),
-                   container_algorithm_internal::c_end(c),
-                   std::forward<T>(value));
-}
-
-// c_find_if()
-//
-// Container-based version of the <algorithm> `std::find_if()` function to find
-// the first element in a container matching the given condition.
-template <typename C, typename Pred>
-container_algorithm_internal::ContainerIter<C> c_find_if(C& c, Pred&& pred) {
-  return std::find_if(container_algorithm_internal::c_begin(c),
-                      container_algorithm_internal::c_end(c),
-                      std::forward<Pred>(pred));
-}
-
-// c_find_if_not()
-//
-// Container-based version of the <algorithm> `std::find_if_not()` function to
-// find the first element in a container not matching the given condition.
-template <typename C, typename Pred>
-container_algorithm_internal::ContainerIter<C> c_find_if_not(C& c,
-                                                             Pred&& pred) {
-  return std::find_if_not(container_algorithm_internal::c_begin(c),
-                          container_algorithm_internal::c_end(c),
-                          std::forward<Pred>(pred));
-}
-
-// c_find_end()
-//
-// Container-based version of the <algorithm> `std::find_end()` function to
-// find the last subsequence within a container.
-template <typename Sequence1, typename Sequence2>
-container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
-    Sequence1& sequence, Sequence2& subsequence) {
-  return std::find_end(container_algorithm_internal::c_begin(sequence),
-                       container_algorithm_internal::c_end(sequence),
-                       container_algorithm_internal::c_begin(subsequence),
-                       container_algorithm_internal::c_end(subsequence));
-}
-
-// Overload of c_find_end() for using a predicate evaluation other than `==` as
-// the function's test condition.
-template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
-container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
-    Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
-  return std::find_end(container_algorithm_internal::c_begin(sequence),
-                       container_algorithm_internal::c_end(sequence),
-                       container_algorithm_internal::c_begin(subsequence),
-                       container_algorithm_internal::c_end(subsequence),
-                       std::forward<BinaryPredicate>(pred));
-}
-
-// c_find_first_of()
-//
-// Container-based version of the <algorithm> `std::find_first_of()` function to
-// find the first element within the container that is also within the options
-// container.
-template <typename C1, typename C2>
-container_algorithm_internal::ContainerIter<C1> c_find_first_of(C1& container,
-                                                                C2& options) {
-  return std::find_first_of(container_algorithm_internal::c_begin(container),
-                            container_algorithm_internal::c_end(container),
-                            container_algorithm_internal::c_begin(options),
-                            container_algorithm_internal::c_end(options));
-}
-
-// Overload of c_find_first_of() for using a predicate evaluation other than
-// `==` as the function's test condition.
-template <typename C1, typename C2, typename BinaryPredicate>
-container_algorithm_internal::ContainerIter<C1> c_find_first_of(
-    C1& container, C2& options, BinaryPredicate&& pred) {
-  return std::find_first_of(container_algorithm_internal::c_begin(container),
-                            container_algorithm_internal::c_end(container),
-                            container_algorithm_internal::c_begin(options),
-                            container_algorithm_internal::c_end(options),
-                            std::forward<BinaryPredicate>(pred));
-}
-
-// c_adjacent_find()
-//
-// Container-based version of the <algorithm> `std::adjacent_find()` function to
-// find equal adjacent elements within a container.
-template <typename Sequence>
-container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
-    Sequence& sequence) {
-  return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
-                            container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_adjacent_find() for using a predicate evaluation other than
-// `==` as the function's test condition.
-template <typename Sequence, typename BinaryPredicate>
-container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
-    Sequence& sequence, BinaryPredicate&& pred) {
-  return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
-                            container_algorithm_internal::c_end(sequence),
-                            std::forward<BinaryPredicate>(pred));
-}
-
-// c_count()
-//
-// Container-based version of the <algorithm> `std::count()` function to count
-// values that match within a container.
-template <typename C, typename T>
-container_algorithm_internal::ContainerDifferenceType<const C> c_count(
-    const C& c, T&& value) {
-  return std::count(container_algorithm_internal::c_begin(c),
-                    container_algorithm_internal::c_end(c),
-                    std::forward<T>(value));
-}
-
-// c_count_if()
-//
-// Container-based version of the <algorithm> `std::count_if()` function to
-// count values matching a condition within a container.
-template <typename C, typename Pred>
-container_algorithm_internal::ContainerDifferenceType<const C> c_count_if(
-    const C& c, Pred&& pred) {
-  return std::count_if(container_algorithm_internal::c_begin(c),
-                       container_algorithm_internal::c_end(c),
-                       std::forward<Pred>(pred));
-}
-
-// c_mismatch()
-//
-// Container-based version of the <algorithm> `std::mismatch()` function to
-// return the first element where two ordered containers differ. Applies `==` to
-// the first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
-template <typename C1, typename C2>
-container_algorithm_internal::ContainerIterPairType<C1, C2>
-c_mismatch(C1& c1, C2& c2) {
-  auto first1 = container_algorithm_internal::c_begin(c1);
-  auto last1 = container_algorithm_internal::c_end(c1);
-  auto first2 = container_algorithm_internal::c_begin(c2);
-  auto last2 = container_algorithm_internal::c_end(c2);
-
-  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
-    // Negates equality because Cpp17EqualityComparable doesn't require clients
-    // to overload both `operator==` and `operator!=`.
-    if (!(*first1 == *first2)) {
-      break;
-    }
-  }
-
-  return std::make_pair(first1, first2);
-}
-
-// Overload of c_mismatch() for using a predicate evaluation other than `==` as
-// the function's test condition. Applies `pred`to the first N elements of `c1`
-// and `c2`, where N = min(size(c1), size(c2)).
-template <typename C1, typename C2, typename BinaryPredicate>
-container_algorithm_internal::ContainerIterPairType<C1, C2>
-c_mismatch(C1& c1, C2& c2, BinaryPredicate pred) {
-  auto first1 = container_algorithm_internal::c_begin(c1);
-  auto last1 = container_algorithm_internal::c_end(c1);
-  auto first2 = container_algorithm_internal::c_begin(c2);
-  auto last2 = container_algorithm_internal::c_end(c2);
-
-  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
-    if (!pred(*first1, *first2)) {
-      break;
-    }
-  }
-
-  return std::make_pair(first1, first2);
-}
-
-// c_equal()
-//
-// Container-based version of the <algorithm> `std::equal()` function to
-// test whether two containers are equal.
-//
-// NOTE: the semantics of c_equal() are slightly different than those of
-// equal(): while the latter iterates over the second container only up to the
-// size of the first container, c_equal() also checks whether the container
-// sizes are equal.  This better matches expectations about c_equal() based on
-// its signature.
-//
-// Example:
-//   vector v1 = <1, 2, 3>;
-//   vector v2 = <1, 2, 3, 4>;
-//   equal(std::begin(v1), std::end(v1), std::begin(v2)) returns true
-//   c_equal(v1, v2) returns false
-
-template <typename C1, typename C2>
-bool c_equal(const C1& c1, const C2& c2) {
-  return ((container_algorithm_internal::c_size(c1) ==
-           container_algorithm_internal::c_size(c2)) &&
-          std::equal(container_algorithm_internal::c_begin(c1),
-                     container_algorithm_internal::c_end(c1),
-                     container_algorithm_internal::c_begin(c2)));
-}
-
-// Overload of c_equal() for using a predicate evaluation other than `==` as
-// the function's test condition.
-template <typename C1, typename C2, typename BinaryPredicate>
-bool c_equal(const C1& c1, const C2& c2, BinaryPredicate&& pred) {
-  return ((container_algorithm_internal::c_size(c1) ==
-           container_algorithm_internal::c_size(c2)) &&
-          std::equal(container_algorithm_internal::c_begin(c1),
-                     container_algorithm_internal::c_end(c1),
-                     container_algorithm_internal::c_begin(c2),
-                     std::forward<BinaryPredicate>(pred)));
-}
-
-// c_is_permutation()
-//
-// Container-based version of the <algorithm> `std::is_permutation()` function
-// to test whether a container is a permutation of another.
-template <typename C1, typename C2>
-bool c_is_permutation(const C1& c1, const C2& c2) {
-  using std::begin;
-  using std::end;
-  return c1.size() == c2.size() &&
-         std::is_permutation(begin(c1), end(c1), begin(c2));
-}
-
-// Overload of c_is_permutation() for using a predicate evaluation other than
-// `==` as the function's test condition.
-template <typename C1, typename C2, typename BinaryPredicate>
-bool c_is_permutation(const C1& c1, const C2& c2, BinaryPredicate&& pred) {
-  using std::begin;
-  using std::end;
-  return c1.size() == c2.size() &&
-         std::is_permutation(begin(c1), end(c1), begin(c2),
-                             std::forward<BinaryPredicate>(pred));
-}
-
-// c_search()
-//
-// Container-based version of the <algorithm> `std::search()` function to search
-// a container for a subsequence.
-template <typename Sequence1, typename Sequence2>
-container_algorithm_internal::ContainerIter<Sequence1> c_search(
-    Sequence1& sequence, Sequence2& subsequence) {
-  return std::search(container_algorithm_internal::c_begin(sequence),
-                     container_algorithm_internal::c_end(sequence),
-                     container_algorithm_internal::c_begin(subsequence),
-                     container_algorithm_internal::c_end(subsequence));
-}
-
-// Overload of c_search() for using a predicate evaluation other than
-// `==` as the function's test condition.
-template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
-container_algorithm_internal::ContainerIter<Sequence1> c_search(
-    Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
-  return std::search(container_algorithm_internal::c_begin(sequence),
-                     container_algorithm_internal::c_end(sequence),
-                     container_algorithm_internal::c_begin(subsequence),
-                     container_algorithm_internal::c_end(subsequence),
-                     std::forward<BinaryPredicate>(pred));
-}
-
-// c_search_n()
-//
-// Container-based version of the <algorithm> `std::search_n()` function to
-// search a container for the first sequence of N elements.
-template <typename Sequence, typename Size, typename T>
-container_algorithm_internal::ContainerIter<Sequence> c_search_n(
-    Sequence& sequence, Size count, T&& value) {
-  return std::search_n(container_algorithm_internal::c_begin(sequence),
-                       container_algorithm_internal::c_end(sequence), count,
-                       std::forward<T>(value));
-}
-
-// Overload of c_search_n() for using a predicate evaluation other than
-// `==` as the function's test condition.
-template <typename Sequence, typename Size, typename T,
-          typename BinaryPredicate>
-container_algorithm_internal::ContainerIter<Sequence> c_search_n(
-    Sequence& sequence, Size count, T&& value, BinaryPredicate&& pred) {
-  return std::search_n(container_algorithm_internal::c_begin(sequence),
-                       container_algorithm_internal::c_end(sequence), count,
-                       std::forward<T>(value),
-                       std::forward<BinaryPredicate>(pred));
-}
-
-//------------------------------------------------------------------------------
-// <algorithm> Modifying sequence operations
-//------------------------------------------------------------------------------
-
-// c_copy()
-//
-// Container-based version of the <algorithm> `std::copy()` function to copy a
-// container's elements into an iterator.
-template <typename InputSequence, typename OutputIterator>
-OutputIterator c_copy(const InputSequence& input, OutputIterator output) {
-  return std::copy(container_algorithm_internal::c_begin(input),
-                   container_algorithm_internal::c_end(input), output);
-}
-
-// c_copy_n()
-//
-// Container-based version of the <algorithm> `std::copy_n()` function to copy a
-// container's first N elements into an iterator.
-template <typename C, typename Size, typename OutputIterator>
-OutputIterator c_copy_n(const C& input, Size n, OutputIterator output) {
-  return std::copy_n(container_algorithm_internal::c_begin(input), n, output);
-}
-
-// c_copy_if()
-//
-// Container-based version of the <algorithm> `std::copy_if()` function to copy
-// a container's elements satisfying some condition into an iterator.
-template <typename InputSequence, typename OutputIterator, typename Pred>
-OutputIterator c_copy_if(const InputSequence& input, OutputIterator output,
-                         Pred&& pred) {
-  return std::copy_if(container_algorithm_internal::c_begin(input),
-                      container_algorithm_internal::c_end(input), output,
-                      std::forward<Pred>(pred));
-}
-
-// c_copy_backward()
-//
-// Container-based version of the <algorithm> `std::copy_backward()` function to
-// copy a container's elements in reverse order into an iterator.
-template <typename C, typename BidirectionalIterator>
-BidirectionalIterator c_copy_backward(const C& src,
-                                      BidirectionalIterator dest) {
-  return std::copy_backward(container_algorithm_internal::c_begin(src),
-                            container_algorithm_internal::c_end(src), dest);
-}
-
-// c_move()
-//
-// Container-based version of the <algorithm> `std::move()` function to move
-// a container's elements into an iterator.
-template <typename C, typename OutputIterator>
-OutputIterator c_move(C&& src, OutputIterator dest) {
-  return std::move(container_algorithm_internal::c_begin(src),
-                   container_algorithm_internal::c_end(src), dest);
-}
-
-// c_move_backward()
-//
-// Container-based version of the <algorithm> `std::move_backward()` function to
-// move a container's elements into an iterator in reverse order.
-template <typename C, typename BidirectionalIterator>
-BidirectionalIterator c_move_backward(C&& src, BidirectionalIterator dest) {
-  return std::move_backward(container_algorithm_internal::c_begin(src),
-                            container_algorithm_internal::c_end(src), dest);
-}
-
-// c_swap_ranges()
-//
-// Container-based version of the <algorithm> `std::swap_ranges()` function to
-// swap a container's elements with another container's elements. Swaps the
-// first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
-template <typename C1, typename C2>
-container_algorithm_internal::ContainerIter<C2> c_swap_ranges(C1& c1, C2& c2) {
-  auto first1 = container_algorithm_internal::c_begin(c1);
-  auto last1 = container_algorithm_internal::c_end(c1);
-  auto first2 = container_algorithm_internal::c_begin(c2);
-  auto last2 = container_algorithm_internal::c_end(c2);
-
-  using std::swap;
-  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
-    swap(*first1, *first2);
-  }
-  return first2;
-}
-
-// c_transform()
-//
-// Container-based version of the <algorithm> `std::transform()` function to
-// transform a container's elements using the unary operation, storing the
-// result in an iterator pointing to the last transformed element in the output
-// range.
-template <typename InputSequence, typename OutputIterator, typename UnaryOp>
-OutputIterator c_transform(const InputSequence& input, OutputIterator output,
-                           UnaryOp&& unary_op) {
-  return std::transform(container_algorithm_internal::c_begin(input),
-                        container_algorithm_internal::c_end(input), output,
-                        std::forward<UnaryOp>(unary_op));
-}
-
-// Overload of c_transform() for performing a transformation using a binary
-// predicate. Applies `binary_op` to the first N elements of `c1` and `c2`,
-// where N = min(size(c1), size(c2)).
-template <typename InputSequence1, typename InputSequence2,
-          typename OutputIterator, typename BinaryOp>
-OutputIterator c_transform(const InputSequence1& input1,
-                           const InputSequence2& input2, OutputIterator output,
-                           BinaryOp&& binary_op) {
-  auto first1 = container_algorithm_internal::c_begin(input1);
-  auto last1 = container_algorithm_internal::c_end(input1);
-  auto first2 = container_algorithm_internal::c_begin(input2);
-  auto last2 = container_algorithm_internal::c_end(input2);
-  for (; first1 != last1 && first2 != last2;
-       ++first1, (void)++first2, ++output) {
-    *output = binary_op(*first1, *first2);
-  }
-
-  return output;
-}
-
-// c_replace()
-//
-// Container-based version of the <algorithm> `std::replace()` function to
-// replace a container's elements of some value with a new value. The container
-// is modified in place.
-template <typename Sequence, typename T>
-void c_replace(Sequence& sequence, const T& old_value, const T& new_value) {
-  std::replace(container_algorithm_internal::c_begin(sequence),
-               container_algorithm_internal::c_end(sequence), old_value,
-               new_value);
-}
-
-// c_replace_if()
-//
-// Container-based version of the <algorithm> `std::replace_if()` function to
-// replace a container's elements of some value with a new value based on some
-// condition. The container is modified in place.
-template <typename C, typename Pred, typename T>
-void c_replace_if(C& c, Pred&& pred, T&& new_value) {
-  std::replace_if(container_algorithm_internal::c_begin(c),
-                  container_algorithm_internal::c_end(c),
-                  std::forward<Pred>(pred), std::forward<T>(new_value));
-}
-
-// c_replace_copy()
-//
-// Container-based version of the <algorithm> `std::replace_copy()` function to
-// replace a container's elements of some value with a new value  and return the
-// results within an iterator.
-template <typename C, typename OutputIterator, typename T>
-OutputIterator c_replace_copy(const C& c, OutputIterator result, T&& old_value,
-                              T&& new_value) {
-  return std::replace_copy(container_algorithm_internal::c_begin(c),
-                           container_algorithm_internal::c_end(c), result,
-                           std::forward<T>(old_value),
-                           std::forward<T>(new_value));
-}
-
-// c_replace_copy_if()
-//
-// Container-based version of the <algorithm> `std::replace_copy_if()` function
-// to replace a container's elements of some value with a new value based on
-// some condition, and return the results within an iterator.
-template <typename C, typename OutputIterator, typename Pred, typename T>
-OutputIterator c_replace_copy_if(const C& c, OutputIterator result, Pred&& pred,
-                                 T&& new_value) {
-  return std::replace_copy_if(container_algorithm_internal::c_begin(c),
-                              container_algorithm_internal::c_end(c), result,
-                              std::forward<Pred>(pred),
-                              std::forward<T>(new_value));
-}
-
-// c_fill()
-//
-// Container-based version of the <algorithm> `std::fill()` function to fill a
-// container with some value.
-template <typename C, typename T>
-void c_fill(C& c, T&& value) {
-  std::fill(container_algorithm_internal::c_begin(c),
-            container_algorithm_internal::c_end(c), std::forward<T>(value));
-}
-
-// c_fill_n()
-//
-// Container-based version of the <algorithm> `std::fill_n()` function to fill
-// the first N elements in a container with some value.
-template <typename C, typename Size, typename T>
-void c_fill_n(C& c, Size n, T&& value) {
-  std::fill_n(container_algorithm_internal::c_begin(c), n,
-              std::forward<T>(value));
-}
-
-// c_generate()
-//
-// Container-based version of the <algorithm> `std::generate()` function to
-// assign a container's elements to the values provided by the given generator.
-template <typename C, typename Generator>
-void c_generate(C& c, Generator&& gen) {
-  std::generate(container_algorithm_internal::c_begin(c),
-                container_algorithm_internal::c_end(c),
-                std::forward<Generator>(gen));
-}
-
-// c_generate_n()
-//
-// Container-based version of the <algorithm> `std::generate_n()` function to
-// assign a container's first N elements to the values provided by the given
-// generator.
-template <typename C, typename Size, typename Generator>
-container_algorithm_internal::ContainerIter<C> c_generate_n(C& c, Size n,
-                                                            Generator&& gen) {
-  return std::generate_n(container_algorithm_internal::c_begin(c), n,
-                         std::forward<Generator>(gen));
-}
-
-// Note: `c_xx()` <algorithm> container versions for `remove()`, `remove_if()`,
-// and `unique()` are omitted, because it's not clear whether or not such
-// functions should call erase on their supplied sequences afterwards. Either
-// behavior would be surprising for a different set of users.
-
-// c_remove_copy()
-//
-// Container-based version of the <algorithm> `std::remove_copy()` function to
-// copy a container's elements while removing any elements matching the given
-// `value`.
-template <typename C, typename OutputIterator, typename T>
-OutputIterator c_remove_copy(const C& c, OutputIterator result, T&& value) {
-  return std::remove_copy(container_algorithm_internal::c_begin(c),
-                          container_algorithm_internal::c_end(c), result,
-                          std::forward<T>(value));
-}
-
-// c_remove_copy_if()
-//
-// Container-based version of the <algorithm> `std::remove_copy_if()` function
-// to copy a container's elements while removing any elements matching the given
-// condition.
-template <typename C, typename OutputIterator, typename Pred>
-OutputIterator c_remove_copy_if(const C& c, OutputIterator result,
-                                Pred&& pred) {
-  return std::remove_copy_if(container_algorithm_internal::c_begin(c),
-                             container_algorithm_internal::c_end(c), result,
-                             std::forward<Pred>(pred));
-}
-
-// c_unique_copy()
-//
-// Container-based version of the <algorithm> `std::unique_copy()` function to
-// copy a container's elements while removing any elements containing duplicate
-// values.
-template <typename C, typename OutputIterator>
-OutputIterator c_unique_copy(const C& c, OutputIterator result) {
-  return std::unique_copy(container_algorithm_internal::c_begin(c),
-                          container_algorithm_internal::c_end(c), result);
-}
-
-// Overload of c_unique_copy() for using a predicate evaluation other than
-// `==` for comparing uniqueness of the element values.
-template <typename C, typename OutputIterator, typename BinaryPredicate>
-OutputIterator c_unique_copy(const C& c, OutputIterator result,
-                             BinaryPredicate&& pred) {
-  return std::unique_copy(container_algorithm_internal::c_begin(c),
-                          container_algorithm_internal::c_end(c), result,
-                          std::forward<BinaryPredicate>(pred));
-}
-
-// c_reverse()
-//
-// Container-based version of the <algorithm> `std::reverse()` function to
-// reverse a container's elements.
-template <typename Sequence>
-void c_reverse(Sequence& sequence) {
-  std::reverse(container_algorithm_internal::c_begin(sequence),
-               container_algorithm_internal::c_end(sequence));
-}
-
-// c_reverse_copy()
-//
-// Container-based version of the <algorithm> `std::reverse()` function to
-// reverse a container's elements and write them to an iterator range.
-template <typename C, typename OutputIterator>
-OutputIterator c_reverse_copy(const C& sequence, OutputIterator result) {
-  return std::reverse_copy(container_algorithm_internal::c_begin(sequence),
-                           container_algorithm_internal::c_end(sequence),
-                           result);
-}
-
-// c_rotate()
-//
-// Container-based version of the <algorithm> `std::rotate()` function to
-// shift a container's elements leftward such that the `middle` element becomes
-// the first element in the container.
-template <typename C,
-          typename Iterator = container_algorithm_internal::ContainerIter<C>>
-Iterator c_rotate(C& sequence, Iterator middle) {
-  return absl::rotate(container_algorithm_internal::c_begin(sequence), middle,
-                      container_algorithm_internal::c_end(sequence));
-}
-
-// c_rotate_copy()
-//
-// Container-based version of the <algorithm> `std::rotate_copy()` function to
-// shift a container's elements leftward such that the `middle` element becomes
-// the first element in a new iterator range.
-template <typename C, typename OutputIterator>
-OutputIterator c_rotate_copy(
-    const C& sequence,
-    container_algorithm_internal::ContainerIter<const C> middle,
-    OutputIterator result) {
-  return std::rotate_copy(container_algorithm_internal::c_begin(sequence),
-                          middle, container_algorithm_internal::c_end(sequence),
-                          result);
-}
-
-// c_shuffle()
-//
-// Container-based version of the <algorithm> `std::shuffle()` function to
-// randomly shuffle elements within the container using a `gen()` uniform random
-// number generator.
-template <typename RandomAccessContainer, typename UniformRandomBitGenerator>
-void c_shuffle(RandomAccessContainer& c, UniformRandomBitGenerator&& gen) {
-  std::shuffle(container_algorithm_internal::c_begin(c),
-               container_algorithm_internal::c_end(c),
-               std::forward<UniformRandomBitGenerator>(gen));
-}
-
-//------------------------------------------------------------------------------
-// <algorithm> Partition functions
-//------------------------------------------------------------------------------
-
-// c_is_partitioned()
-//
-// Container-based version of the <algorithm> `std::is_partitioned()` function
-// to test whether all elements in the container for which `pred` returns `true`
-// precede those for which `pred` is `false`.
-template <typename C, typename Pred>
-bool c_is_partitioned(const C& c, Pred&& pred) {
-  return std::is_partitioned(container_algorithm_internal::c_begin(c),
-                             container_algorithm_internal::c_end(c),
-                             std::forward<Pred>(pred));
-}
-
-// c_partition()
-//
-// Container-based version of the <algorithm> `std::partition()` function
-// to rearrange all elements in a container in such a way that all elements for
-// which `pred` returns `true` precede all those for which it returns `false`,
-// returning an iterator to the first element of the second group.
-template <typename C, typename Pred>
-container_algorithm_internal::ContainerIter<C> c_partition(C& c, Pred&& pred) {
-  return std::partition(container_algorithm_internal::c_begin(c),
-                        container_algorithm_internal::c_end(c),
-                        std::forward<Pred>(pred));
-}
-
-// c_stable_partition()
-//
-// Container-based version of the <algorithm> `std::stable_partition()` function
-// to rearrange all elements in a container in such a way that all elements for
-// which `pred` returns `true` precede all those for which it returns `false`,
-// preserving the relative ordering between the two groups. The function returns
-// an iterator to the first element of the second group.
-template <typename C, typename Pred>
-container_algorithm_internal::ContainerIter<C> c_stable_partition(C& c,
-                                                                  Pred&& pred) {
-  return std::stable_partition(container_algorithm_internal::c_begin(c),
-                               container_algorithm_internal::c_end(c),
-                               std::forward<Pred>(pred));
-}
-
-// c_partition_copy()
-//
-// Container-based version of the <algorithm> `std::partition_copy()` function
-// to partition a container's elements and return them into two iterators: one
-// for which `pred` returns `true`, and one for which `pred` returns `false.`
-
-template <typename C, typename OutputIterator1, typename OutputIterator2,
-          typename Pred>
-std::pair<OutputIterator1, OutputIterator2> c_partition_copy(
-    const C& c, OutputIterator1 out_true, OutputIterator2 out_false,
-    Pred&& pred) {
-  return std::partition_copy(container_algorithm_internal::c_begin(c),
-                             container_algorithm_internal::c_end(c), out_true,
-                             out_false, std::forward<Pred>(pred));
-}
-
-// c_partition_point()
-//
-// Container-based version of the <algorithm> `std::partition_point()` function
-// to return the first element of an already partitioned container for which
-// the given `pred` is not `true`.
-template <typename C, typename Pred>
-container_algorithm_internal::ContainerIter<C> c_partition_point(C& c,
-                                                                 Pred&& pred) {
-  return std::partition_point(container_algorithm_internal::c_begin(c),
-                              container_algorithm_internal::c_end(c),
-                              std::forward<Pred>(pred));
-}
-
-//------------------------------------------------------------------------------
-// <algorithm> Sorting functions
-//------------------------------------------------------------------------------
-
-// c_sort()
-//
-// Container-based version of the <algorithm> `std::sort()` function
-// to sort elements in ascending order of their values.
-template <typename C>
-void c_sort(C& c) {
-  std::sort(container_algorithm_internal::c_begin(c),
-            container_algorithm_internal::c_end(c));
-}
-
-// Overload of c_sort() for performing a `comp` comparison other than the
-// default `operator<`.
-template <typename C, typename LessThan>
-void c_sort(C& c, LessThan&& comp) {
-  std::sort(container_algorithm_internal::c_begin(c),
-            container_algorithm_internal::c_end(c),
-            std::forward<LessThan>(comp));
-}
-
-// c_stable_sort()
-//
-// Container-based version of the <algorithm> `std::stable_sort()` function
-// to sort elements in ascending order of their values, preserving the order
-// of equivalents.
-template <typename C>
-void c_stable_sort(C& c) {
-  std::stable_sort(container_algorithm_internal::c_begin(c),
-                   container_algorithm_internal::c_end(c));
-}
-
-// Overload of c_stable_sort() for performing a `comp` comparison other than the
-// default `operator<`.
-template <typename C, typename LessThan>
-void c_stable_sort(C& c, LessThan&& comp) {
-  std::stable_sort(container_algorithm_internal::c_begin(c),
-                   container_algorithm_internal::c_end(c),
-                   std::forward<LessThan>(comp));
-}
-
-// c_is_sorted()
-//
-// Container-based version of the <algorithm> `std::is_sorted()` function
-// to evaluate whether the given container is sorted in ascending order.
-template <typename C>
-bool c_is_sorted(const C& c) {
-  return std::is_sorted(container_algorithm_internal::c_begin(c),
-                        container_algorithm_internal::c_end(c));
-}
-
-// c_is_sorted() overload for performing a `comp` comparison other than the
-// default `operator<`.
-template <typename C, typename LessThan>
-bool c_is_sorted(const C& c, LessThan&& comp) {
-  return std::is_sorted(container_algorithm_internal::c_begin(c),
-                        container_algorithm_internal::c_end(c),
-                        std::forward<LessThan>(comp));
-}
-
-// c_partial_sort()
-//
-// Container-based version of the <algorithm> `std::partial_sort()` function
-// to rearrange elements within a container such that elements before `middle`
-// are sorted in ascending order.
-template <typename RandomAccessContainer>
-void c_partial_sort(
-    RandomAccessContainer& sequence,
-    container_algorithm_internal::ContainerIter<RandomAccessContainer> middle) {
-  std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
-                    container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_partial_sort() for performing a `comp` comparison other than
-// the default `operator<`.
-template <typename RandomAccessContainer, typename LessThan>
-void c_partial_sort(
-    RandomAccessContainer& sequence,
-    container_algorithm_internal::ContainerIter<RandomAccessContainer> middle,
-    LessThan&& comp) {
-  std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
-                    container_algorithm_internal::c_end(sequence),
-                    std::forward<LessThan>(comp));
-}
-
-// c_partial_sort_copy()
-//
-// Container-based version of the <algorithm> `std::partial_sort_copy()`
-// function to sort the elements in the given range `result` within the larger
-// `sequence` in ascending order (and using `result` as the output parameter).
-// At most min(result.last - result.first, sequence.last - sequence.first)
-// elements from the sequence will be stored in the result.
-template <typename C, typename RandomAccessContainer>
-container_algorithm_internal::ContainerIter<RandomAccessContainer>
-c_partial_sort_copy(const C& sequence, RandomAccessContainer& result) {
-  return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
-                                container_algorithm_internal::c_end(sequence),
-                                container_algorithm_internal::c_begin(result),
-                                container_algorithm_internal::c_end(result));
-}
-
-// Overload of c_partial_sort_copy() for performing a `comp` comparison other
-// than the default `operator<`.
-template <typename C, typename RandomAccessContainer, typename LessThan>
-container_algorithm_internal::ContainerIter<RandomAccessContainer>
-c_partial_sort_copy(const C& sequence, RandomAccessContainer& result,
-                    LessThan&& comp) {
-  return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
-                                container_algorithm_internal::c_end(sequence),
-                                container_algorithm_internal::c_begin(result),
-                                container_algorithm_internal::c_end(result),
-                                std::forward<LessThan>(comp));
-}
-
-// c_is_sorted_until()
-//
-// Container-based version of the <algorithm> `std::is_sorted_until()` function
-// to return the first element within a container that is not sorted in
-// ascending order as an iterator.
-template <typename C>
-container_algorithm_internal::ContainerIter<C> c_is_sorted_until(C& c) {
-  return std::is_sorted_until(container_algorithm_internal::c_begin(c),
-                              container_algorithm_internal::c_end(c));
-}
-
-// Overload of c_is_sorted_until() for performing a `comp` comparison other than
-// the default `operator<`.
-template <typename C, typename LessThan>
-container_algorithm_internal::ContainerIter<C> c_is_sorted_until(
-    C& c, LessThan&& comp) {
-  return std::is_sorted_until(container_algorithm_internal::c_begin(c),
-                              container_algorithm_internal::c_end(c),
-                              std::forward<LessThan>(comp));
-}
-
-// c_nth_element()
-//
-// Container-based version of the <algorithm> `std::nth_element()` function
-// to rearrange the elements within a container such that the `nth` element
-// would be in that position in an ordered sequence; other elements may be in
-// any order, except that all preceding `nth` will be less than that element,
-// and all following `nth` will be greater than that element.
-template <typename RandomAccessContainer>
-void c_nth_element(
-    RandomAccessContainer& sequence,
-    container_algorithm_internal::ContainerIter<RandomAccessContainer> nth) {
-  std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
-                   container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_nth_element() for performing a `comp` comparison other than
-// the default `operator<`.
-template <typename RandomAccessContainer, typename LessThan>
-void c_nth_element(
-    RandomAccessContainer& sequence,
-    container_algorithm_internal::ContainerIter<RandomAccessContainer> nth,
-    LessThan&& comp) {
-  std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
-                   container_algorithm_internal::c_end(sequence),
-                   std::forward<LessThan>(comp));
-}
-
-//------------------------------------------------------------------------------
-// <algorithm> Binary Search
-//------------------------------------------------------------------------------
-
-// c_lower_bound()
-//
-// Container-based version of the <algorithm> `std::lower_bound()` function
-// to return an iterator pointing to the first element in a sorted container
-// which does not compare less than `value`.
-template <typename Sequence, typename T>
-container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
-    Sequence& sequence, T&& value) {
-  return std::lower_bound(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence),
-                          std::forward<T>(value));
-}
-
-// Overload of c_lower_bound() for performing a `comp` comparison other than
-// the default `operator<`.
-template <typename Sequence, typename T, typename LessThan>
-container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
-    Sequence& sequence, T&& value, LessThan&& comp) {
-  return std::lower_bound(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence),
-                          std::forward<T>(value), std::forward<LessThan>(comp));
-}
-
-// c_upper_bound()
-//
-// Container-based version of the <algorithm> `std::upper_bound()` function
-// to return an iterator pointing to the first element in a sorted container
-// which is greater than `value`.
-template <typename Sequence, typename T>
-container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
-    Sequence& sequence, T&& value) {
-  return std::upper_bound(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence),
-                          std::forward<T>(value));
-}
-
-// Overload of c_upper_bound() for performing a `comp` comparison other than
-// the default `operator<`.
-template <typename Sequence, typename T, typename LessThan>
-container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
-    Sequence& sequence, T&& value, LessThan&& comp) {
-  return std::upper_bound(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence),
-                          std::forward<T>(value), std::forward<LessThan>(comp));
-}
-
-// c_equal_range()
-//
-// Container-based version of the <algorithm> `std::equal_range()` function
-// to return an iterator pair pointing to the first and last elements in a
-// sorted container which compare equal to `value`.
-template <typename Sequence, typename T>
-container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
-c_equal_range(Sequence& sequence, T&& value) {
-  return std::equal_range(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence),
-                          std::forward<T>(value));
-}
-
-// Overload of c_equal_range() for performing a `comp` comparison other than
-// the default `operator<`.
-template <typename Sequence, typename T, typename LessThan>
-container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
-c_equal_range(Sequence& sequence, T&& value, LessThan&& comp) {
-  return std::equal_range(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence),
-                          std::forward<T>(value), std::forward<LessThan>(comp));
-}
-
-// c_binary_search()
-//
-// Container-based version of the <algorithm> `std::binary_search()` function
-// to test if any element in the sorted container contains a value equivalent to
-// 'value'.
-template <typename Sequence, typename T>
-bool c_binary_search(Sequence&& sequence, T&& value) {
-  return std::binary_search(container_algorithm_internal::c_begin(sequence),
-                            container_algorithm_internal::c_end(sequence),
-                            std::forward<T>(value));
-}
-
-// Overload of c_binary_search() for performing a `comp` comparison other than
-// the default `operator<`.
-template <typename Sequence, typename T, typename LessThan>
-bool c_binary_search(Sequence&& sequence, T&& value, LessThan&& comp) {
-  return std::binary_search(container_algorithm_internal::c_begin(sequence),
-                            container_algorithm_internal::c_end(sequence),
-                            std::forward<T>(value),
-                            std::forward<LessThan>(comp));
-}
-
-//------------------------------------------------------------------------------
-// <algorithm> Merge functions
-//------------------------------------------------------------------------------
-
-// c_merge()
-//
-// Container-based version of the <algorithm> `std::merge()` function
-// to merge two sorted containers into a single sorted iterator.
-template <typename C1, typename C2, typename OutputIterator>
-OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result) {
-  return std::merge(container_algorithm_internal::c_begin(c1),
-                    container_algorithm_internal::c_end(c1),
-                    container_algorithm_internal::c_begin(c2),
-                    container_algorithm_internal::c_end(c2), result);
-}
-
-// Overload of c_merge() for performing a `comp` comparison other than
-// the default `operator<`.
-template <typename C1, typename C2, typename OutputIterator, typename LessThan>
-OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result,
-                       LessThan&& comp) {
-  return std::merge(container_algorithm_internal::c_begin(c1),
-                    container_algorithm_internal::c_end(c1),
-                    container_algorithm_internal::c_begin(c2),
-                    container_algorithm_internal::c_end(c2), result,
-                    std::forward<LessThan>(comp));
-}
-
-// c_inplace_merge()
-//
-// Container-based version of the <algorithm> `std::inplace_merge()` function
-// to merge a supplied iterator `middle` into a container.
-template <typename C>
-void c_inplace_merge(C& c,
-                     container_algorithm_internal::ContainerIter<C> middle) {
-  std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
-                     container_algorithm_internal::c_end(c));
-}
-
-// Overload of c_inplace_merge() for performing a merge using a `comp` other
-// than `operator<`.
-template <typename C, typename LessThan>
-void c_inplace_merge(C& c,
-                     container_algorithm_internal::ContainerIter<C> middle,
-                     LessThan&& comp) {
-  std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
-                     container_algorithm_internal::c_end(c),
-                     std::forward<LessThan>(comp));
-}
-
-// c_includes()
-//
-// Container-based version of the <algorithm> `std::includes()` function
-// to test whether a sorted container `c1` entirely contains another sorted
-// container `c2`.
-template <typename C1, typename C2>
-bool c_includes(const C1& c1, const C2& c2) {
-  return std::includes(container_algorithm_internal::c_begin(c1),
-                       container_algorithm_internal::c_end(c1),
-                       container_algorithm_internal::c_begin(c2),
-                       container_algorithm_internal::c_end(c2));
-}
-
-// Overload of c_includes() for performing a merge using a `comp` other than
-// `operator<`.
-template <typename C1, typename C2, typename LessThan>
-bool c_includes(const C1& c1, const C2& c2, LessThan&& comp) {
-  return std::includes(container_algorithm_internal::c_begin(c1),
-                       container_algorithm_internal::c_end(c1),
-                       container_algorithm_internal::c_begin(c2),
-                       container_algorithm_internal::c_end(c2),
-                       std::forward<LessThan>(comp));
-}
-
-// c_set_union()
-//
-// Container-based version of the <algorithm> `std::set_union()` function
-// to return an iterator containing the union of two containers; duplicate
-// values are not copied into the output.
-template <typename C1, typename C2, typename OutputIterator,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
-              void>::type,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
-              void>::type>
-OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output) {
-  return std::set_union(container_algorithm_internal::c_begin(c1),
-                        container_algorithm_internal::c_end(c1),
-                        container_algorithm_internal::c_begin(c2),
-                        container_algorithm_internal::c_end(c2), output);
-}
-
-// Overload of c_set_union() for performing a merge using a `comp` other than
-// `operator<`.
-template <typename C1, typename C2, typename OutputIterator, typename LessThan,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
-              void>::type,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
-              void>::type>
-OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output,
-                           LessThan&& comp) {
-  return std::set_union(container_algorithm_internal::c_begin(c1),
-                        container_algorithm_internal::c_end(c1),
-                        container_algorithm_internal::c_begin(c2),
-                        container_algorithm_internal::c_end(c2), output,
-                        std::forward<LessThan>(comp));
-}
-
-// c_set_intersection()
-//
-// Container-based version of the <algorithm> `std::set_intersection()` function
-// to return an iterator containing the intersection of two sorted containers.
-template <typename C1, typename C2, typename OutputIterator,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
-              void>::type,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
-              void>::type>
-OutputIterator c_set_intersection(const C1& c1, const C2& c2,
-                                  OutputIterator output) {
-  // In debug builds, ensure that both containers are sorted with respect to the
-  // default comparator. std::set_intersection requires the containers be sorted
-  // using operator<.
-  assert(absl::c_is_sorted(c1));
-  assert(absl::c_is_sorted(c2));
-  return std::set_intersection(container_algorithm_internal::c_begin(c1),
-                               container_algorithm_internal::c_end(c1),
-                               container_algorithm_internal::c_begin(c2),
-                               container_algorithm_internal::c_end(c2), output);
-}
-
-// Overload of c_set_intersection() for performing a merge using a `comp` other
-// than `operator<`.
-template <typename C1, typename C2, typename OutputIterator, typename LessThan,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
-              void>::type,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
-              void>::type>
-OutputIterator c_set_intersection(const C1& c1, const C2& c2,
-                                  OutputIterator output, LessThan&& comp) {
-  // In debug builds, ensure that both containers are sorted with respect to the
-  // default comparator. std::set_intersection requires the containers be sorted
-  // using the same comparator.
-  assert(absl::c_is_sorted(c1, comp));
-  assert(absl::c_is_sorted(c2, comp));
-  return std::set_intersection(container_algorithm_internal::c_begin(c1),
-                               container_algorithm_internal::c_end(c1),
-                               container_algorithm_internal::c_begin(c2),
-                               container_algorithm_internal::c_end(c2), output,
-                               std::forward<LessThan>(comp));
-}
-
-// c_set_difference()
-//
-// Container-based version of the <algorithm> `std::set_difference()` function
-// to return an iterator containing elements present in the first container but
-// not in the second.
-template <typename C1, typename C2, typename OutputIterator,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
-              void>::type,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
-              void>::type>
-OutputIterator c_set_difference(const C1& c1, const C2& c2,
-                                OutputIterator output) {
-  return std::set_difference(container_algorithm_internal::c_begin(c1),
-                             container_algorithm_internal::c_end(c1),
-                             container_algorithm_internal::c_begin(c2),
-                             container_algorithm_internal::c_end(c2), output);
-}
-
-// Overload of c_set_difference() for performing a merge using a `comp` other
-// than `operator<`.
-template <typename C1, typename C2, typename OutputIterator, typename LessThan,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
-              void>::type,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
-              void>::type>
-OutputIterator c_set_difference(const C1& c1, const C2& c2,
-                                OutputIterator output, LessThan&& comp) {
-  return std::set_difference(container_algorithm_internal::c_begin(c1),
-                             container_algorithm_internal::c_end(c1),
-                             container_algorithm_internal::c_begin(c2),
-                             container_algorithm_internal::c_end(c2), output,
-                             std::forward<LessThan>(comp));
-}
-
-// c_set_symmetric_difference()
-//
-// Container-based version of the <algorithm> `std::set_symmetric_difference()`
-// function to return an iterator containing elements present in either one
-// container or the other, but not both.
-template <typename C1, typename C2, typename OutputIterator,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
-              void>::type,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
-              void>::type>
-OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2,
-                                          OutputIterator output) {
-  return std::set_symmetric_difference(
-      container_algorithm_internal::c_begin(c1),
-      container_algorithm_internal::c_end(c1),
-      container_algorithm_internal::c_begin(c2),
-      container_algorithm_internal::c_end(c2), output);
-}
-
-// Overload of c_set_symmetric_difference() for performing a merge using a
-// `comp` other than `operator<`.
-template <typename C1, typename C2, typename OutputIterator, typename LessThan,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C1>::value,
-              void>::type,
-          typename = typename std::enable_if<
-              !container_algorithm_internal::IsUnorderedContainer<C2>::value,
-              void>::type>
-OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2,
-                                          OutputIterator output,
-                                          LessThan&& comp) {
-  return std::set_symmetric_difference(
-      container_algorithm_internal::c_begin(c1),
-      container_algorithm_internal::c_end(c1),
-      container_algorithm_internal::c_begin(c2),
-      container_algorithm_internal::c_end(c2), output,
-      std::forward<LessThan>(comp));
-}
-
-//------------------------------------------------------------------------------
-// <algorithm> Heap functions
-//------------------------------------------------------------------------------
-
-// c_push_heap()
-//
-// Container-based version of the <algorithm> `std::push_heap()` function
-// to push a value onto a container heap.
-template <typename RandomAccessContainer>
-void c_push_heap(RandomAccessContainer& sequence) {
-  std::push_heap(container_algorithm_internal::c_begin(sequence),
-                 container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_push_heap() for performing a push operation on a heap using a
-// `comp` other than `operator<`.
-template <typename RandomAccessContainer, typename LessThan>
-void c_push_heap(RandomAccessContainer& sequence, LessThan&& comp) {
-  std::push_heap(container_algorithm_internal::c_begin(sequence),
-                 container_algorithm_internal::c_end(sequence),
-                 std::forward<LessThan>(comp));
-}
-
-// c_pop_heap()
-//
-// Container-based version of the <algorithm> `std::pop_heap()` function
-// to pop a value from a heap container.
-template <typename RandomAccessContainer>
-void c_pop_heap(RandomAccessContainer& sequence) {
-  std::pop_heap(container_algorithm_internal::c_begin(sequence),
-                container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_pop_heap() for performing a pop operation on a heap using a
-// `comp` other than `operator<`.
-template <typename RandomAccessContainer, typename LessThan>
-void c_pop_heap(RandomAccessContainer& sequence, LessThan&& comp) {
-  std::pop_heap(container_algorithm_internal::c_begin(sequence),
-                container_algorithm_internal::c_end(sequence),
-                std::forward<LessThan>(comp));
-}
-
-// c_make_heap()
-//
-// Container-based version of the <algorithm> `std::make_heap()` function
-// to make a container a heap.
-template <typename RandomAccessContainer>
-void c_make_heap(RandomAccessContainer& sequence) {
-  std::make_heap(container_algorithm_internal::c_begin(sequence),
-                 container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_make_heap() for performing heap comparisons using a
-// `comp` other than `operator<`
-template <typename RandomAccessContainer, typename LessThan>
-void c_make_heap(RandomAccessContainer& sequence, LessThan&& comp) {
-  std::make_heap(container_algorithm_internal::c_begin(sequence),
-                 container_algorithm_internal::c_end(sequence),
-                 std::forward<LessThan>(comp));
-}
-
-// c_sort_heap()
-//
-// Container-based version of the <algorithm> `std::sort_heap()` function
-// to sort a heap into ascending order (after which it is no longer a heap).
-template <typename RandomAccessContainer>
-void c_sort_heap(RandomAccessContainer& sequence) {
-  std::sort_heap(container_algorithm_internal::c_begin(sequence),
-                 container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_sort_heap() for performing heap comparisons using a
-// `comp` other than `operator<`
-template <typename RandomAccessContainer, typename LessThan>
-void c_sort_heap(RandomAccessContainer& sequence, LessThan&& comp) {
-  std::sort_heap(container_algorithm_internal::c_begin(sequence),
-                 container_algorithm_internal::c_end(sequence),
-                 std::forward<LessThan>(comp));
-}
-
-// c_is_heap()
-//
-// Container-based version of the <algorithm> `std::is_heap()` function
-// to check whether the given container is a heap.
-template <typename RandomAccessContainer>
-bool c_is_heap(const RandomAccessContainer& sequence) {
-  return std::is_heap(container_algorithm_internal::c_begin(sequence),
-                      container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_is_heap() for performing heap comparisons using a
-// `comp` other than `operator<`
-template <typename RandomAccessContainer, typename LessThan>
-bool c_is_heap(const RandomAccessContainer& sequence, LessThan&& comp) {
-  return std::is_heap(container_algorithm_internal::c_begin(sequence),
-                      container_algorithm_internal::c_end(sequence),
-                      std::forward<LessThan>(comp));
-}
-
-// c_is_heap_until()
-//
-// Container-based version of the <algorithm> `std::is_heap_until()` function
-// to find the first element in a given container which is not in heap order.
-template <typename RandomAccessContainer>
-container_algorithm_internal::ContainerIter<RandomAccessContainer>
-c_is_heap_until(RandomAccessContainer& sequence) {
-  return std::is_heap_until(container_algorithm_internal::c_begin(sequence),
-                            container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_is_heap_until() for performing heap comparisons using a
-// `comp` other than `operator<`
-template <typename RandomAccessContainer, typename LessThan>
-container_algorithm_internal::ContainerIter<RandomAccessContainer>
-c_is_heap_until(RandomAccessContainer& sequence, LessThan&& comp) {
-  return std::is_heap_until(container_algorithm_internal::c_begin(sequence),
-                            container_algorithm_internal::c_end(sequence),
-                            std::forward<LessThan>(comp));
-}
-
-//------------------------------------------------------------------------------
-//  <algorithm> Min/max
-//------------------------------------------------------------------------------
-
-// c_min_element()
-//
-// Container-based version of the <algorithm> `std::min_element()` function
-// to return an iterator pointing to the element with the smallest value, using
-// `operator<` to make the comparisons.
-template <typename Sequence>
-container_algorithm_internal::ContainerIter<Sequence> c_min_element(
-    Sequence& sequence) {
-  return std::min_element(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_min_element() for performing a `comp` comparison other than
-// `operator<`.
-template <typename Sequence, typename LessThan>
-container_algorithm_internal::ContainerIter<Sequence> c_min_element(
-    Sequence& sequence, LessThan&& comp) {
-  return std::min_element(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence),
-                          std::forward<LessThan>(comp));
-}
-
-// c_max_element()
-//
-// Container-based version of the <algorithm> `std::max_element()` function
-// to return an iterator pointing to the element with the largest value, using
-// `operator<` to make the comparisons.
-template <typename Sequence>
-container_algorithm_internal::ContainerIter<Sequence> c_max_element(
-    Sequence& sequence) {
-  return std::max_element(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence));
-}
-
-// Overload of c_max_element() for performing a `comp` comparison other than
-// `operator<`.
-template <typename Sequence, typename LessThan>
-container_algorithm_internal::ContainerIter<Sequence> c_max_element(
-    Sequence& sequence, LessThan&& comp) {
-  return std::max_element(container_algorithm_internal::c_begin(sequence),
-                          container_algorithm_internal::c_end(sequence),
-                          std::forward<LessThan>(comp));
-}
-
-// c_minmax_element()
-//
-// Container-based version of the <algorithm> `std::minmax_element()` function
-// to return a pair of iterators pointing to the elements containing the
-// smallest and largest values, respectively, using `operator<` to make the
-// comparisons.
-template <typename C>
-container_algorithm_internal::ContainerIterPairType<C, C>
-c_minmax_element(C& c) {
-  return std::minmax_element(container_algorithm_internal::c_begin(c),
-                             container_algorithm_internal::c_end(c));
-}
-
-// Overload of c_minmax_element() for performing `comp` comparisons other than
-// `operator<`.
-template <typename C, typename LessThan>
-container_algorithm_internal::ContainerIterPairType<C, C>
-c_minmax_element(C& c, LessThan&& comp) {
-  return std::minmax_element(container_algorithm_internal::c_begin(c),
-                             container_algorithm_internal::c_end(c),
-                             std::forward<LessThan>(comp));
-}
-
-//------------------------------------------------------------------------------
-//  <algorithm> Lexicographical Comparisons
-//------------------------------------------------------------------------------
-
-// c_lexicographical_compare()
-//
-// Container-based version of the <algorithm> `std::lexicographical_compare()`
-// function to lexicographically compare (e.g. sort words alphabetically) two
-// container sequences. The comparison is performed using `operator<`. Note
-// that capital letters ("A-Z") have ASCII values less than lowercase letters
-// ("a-z").
-template <typename Sequence1, typename Sequence2>
-bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2) {
-  return std::lexicographical_compare(
-      container_algorithm_internal::c_begin(sequence1),
-      container_algorithm_internal::c_end(sequence1),
-      container_algorithm_internal::c_begin(sequence2),
-      container_algorithm_internal::c_end(sequence2));
-}
-
-// Overload of c_lexicographical_compare() for performing a lexicographical
-// comparison using a `comp` operator instead of `operator<`.
-template <typename Sequence1, typename Sequence2, typename LessThan>
-bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2,
-                               LessThan&& comp) {
-  return std::lexicographical_compare(
-      container_algorithm_internal::c_begin(sequence1),
-      container_algorithm_internal::c_end(sequence1),
-      container_algorithm_internal::c_begin(sequence2),
-      container_algorithm_internal::c_end(sequence2),
-      std::forward<LessThan>(comp));
-}
-
-// c_next_permutation()
-//
-// Container-based version of the <algorithm> `std::next_permutation()` function
-// to rearrange a container's elements into the next lexicographically greater
-// permutation.
-template <typename C>
-bool c_next_permutation(C& c) {
-  return std::next_permutation(container_algorithm_internal::c_begin(c),
-                               container_algorithm_internal::c_end(c));
-}
-
-// Overload of c_next_permutation() for performing a lexicographical
-// comparison using a `comp` operator instead of `operator<`.
-template <typename C, typename LessThan>
-bool c_next_permutation(C& c, LessThan&& comp) {
-  return std::next_permutation(container_algorithm_internal::c_begin(c),
-                               container_algorithm_internal::c_end(c),
-                               std::forward<LessThan>(comp));
-}
-
-// c_prev_permutation()
-//
-// Container-based version of the <algorithm> `std::prev_permutation()` function
-// to rearrange a container's elements into the next lexicographically lesser
-// permutation.
-template <typename C>
-bool c_prev_permutation(C& c) {
-  return std::prev_permutation(container_algorithm_internal::c_begin(c),
-                               container_algorithm_internal::c_end(c));
-}
-
-// Overload of c_prev_permutation() for performing a lexicographical
-// comparison using a `comp` operator instead of `operator<`.
-template <typename C, typename LessThan>
-bool c_prev_permutation(C& c, LessThan&& comp) {
-  return std::prev_permutation(container_algorithm_internal::c_begin(c),
-                               container_algorithm_internal::c_end(c),
-                               std::forward<LessThan>(comp));
-}
-
-//------------------------------------------------------------------------------
-// <numeric> algorithms
-//------------------------------------------------------------------------------
-
-// c_iota()
-//
-// Container-based version of the <algorithm> `std::iota()` function
-// to compute successive values of `value`, as if incremented with `++value`
-// after each element is written. and write them to the container.
-template <typename Sequence, typename T>
-void c_iota(Sequence& sequence, T&& value) {
-  std::iota(container_algorithm_internal::c_begin(sequence),
-            container_algorithm_internal::c_end(sequence),
-            std::forward<T>(value));
-}
-// c_accumulate()
-//
-// Container-based version of the <algorithm> `std::accumulate()` function
-// to accumulate the element values of a container to `init` and return that
-// accumulation by value.
-//
-// Note: Due to a language technicality this function has return type
-// absl::decay_t<T>. As a user of this function you can casually read
-// this as "returns T by value" and assume it does the right thing.
-template <typename Sequence, typename T>
-decay_t<T> c_accumulate(const Sequence& sequence, T&& init) {
-  return std::accumulate(container_algorithm_internal::c_begin(sequence),
-                         container_algorithm_internal::c_end(sequence),
-                         std::forward<T>(init));
-}
-
-// Overload of c_accumulate() for using a binary operations other than
-// addition for computing the accumulation.
-template <typename Sequence, typename T, typename BinaryOp>
-decay_t<T> c_accumulate(const Sequence& sequence, T&& init,
-                        BinaryOp&& binary_op) {
-  return std::accumulate(container_algorithm_internal::c_begin(sequence),
-                         container_algorithm_internal::c_end(sequence),
-                         std::forward<T>(init),
-                         std::forward<BinaryOp>(binary_op));
-}
-
-// c_inner_product()
-//
-// Container-based version of the <algorithm> `std::inner_product()` function
-// to compute the cumulative inner product of container element pairs.
-//
-// Note: Due to a language technicality this function has return type
-// absl::decay_t<T>. As a user of this function you can casually read
-// this as "returns T by value" and assume it does the right thing.
-template <typename Sequence1, typename Sequence2, typename T>
-decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2,
-                           T&& sum) {
-  return std::inner_product(container_algorithm_internal::c_begin(factors1),
-                            container_algorithm_internal::c_end(factors1),
-                            container_algorithm_internal::c_begin(factors2),
-                            std::forward<T>(sum));
-}
-
-// Overload of c_inner_product() for using binary operations other than
-// `operator+` (for computing the accumulation) and `operator*` (for computing
-// the product between the two container's element pair).
-template <typename Sequence1, typename Sequence2, typename T,
-          typename BinaryOp1, typename BinaryOp2>
-decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2,
-                           T&& sum, BinaryOp1&& op1, BinaryOp2&& op2) {
-  return std::inner_product(container_algorithm_internal::c_begin(factors1),
-                            container_algorithm_internal::c_end(factors1),
-                            container_algorithm_internal::c_begin(factors2),
-                            std::forward<T>(sum), std::forward<BinaryOp1>(op1),
-                            std::forward<BinaryOp2>(op2));
-}
-
-// c_adjacent_difference()
-//
-// Container-based version of the <algorithm> `std::adjacent_difference()`
-// function to compute the difference between each element and the one preceding
-// it and write it to an iterator.
-template <typename InputSequence, typename OutputIt>
-OutputIt c_adjacent_difference(const InputSequence& input,
-                               OutputIt output_first) {
-  return std::adjacent_difference(container_algorithm_internal::c_begin(input),
-                                  container_algorithm_internal::c_end(input),
-                                  output_first);
-}
-
-// Overload of c_adjacent_difference() for using a binary operation other than
-// subtraction to compute the adjacent difference.
-template <typename InputSequence, typename OutputIt, typename BinaryOp>
-OutputIt c_adjacent_difference(const InputSequence& input,
-                               OutputIt output_first, BinaryOp&& op) {
-  return std::adjacent_difference(container_algorithm_internal::c_begin(input),
-                                  container_algorithm_internal::c_end(input),
-                                  output_first, std::forward<BinaryOp>(op));
-}
-
-// c_partial_sum()
-//
-// Container-based version of the <algorithm> `std::partial_sum()` function
-// to compute the partial sum of the elements in a sequence and write them
-// to an iterator. The partial sum is the sum of all element values so far in
-// the sequence.
-template <typename InputSequence, typename OutputIt>
-OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first) {
-  return std::partial_sum(container_algorithm_internal::c_begin(input),
-                          container_algorithm_internal::c_end(input),
-                          output_first);
-}
-
-// Overload of c_partial_sum() for using a binary operation other than addition
-// to compute the "partial sum".
-template <typename InputSequence, typename OutputIt, typename BinaryOp>
-OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first,
-                       BinaryOp&& op) {
-  return std::partial_sum(container_algorithm_internal::c_begin(input),
-                          container_algorithm_internal::c_end(input),
-                          output_first, std::forward<BinaryOp>(op));
-}
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_algorithm_internal
+    {
+
+        // NOTE: it is important to defer to ADL lookup for building with C++ modules,
+        // especially for headers like <valarray> which are not visible from this file
+        // but specialize std::begin and std::end.
+        using std::begin;
+        using std::end;
+
+        // The type of the iterator given by begin(c) (possibly std::begin(c)).
+        // ContainerIter<const vector<T>> gives vector<T>::const_iterator,
+        // while ContainerIter<vector<T>> gives vector<T>::iterator.
+        template<typename C>
+        using ContainerIter = decltype(begin(std::declval<C&>()));
+
+        // An MSVC bug involving template parameter substitution requires us to use
+        // decltype() here instead of just std::pair.
+        template<typename C1, typename C2>
+        using ContainerIterPairType =
+            decltype(std::make_pair(ContainerIter<C1>(), ContainerIter<C2>()));
+
+        template<typename C>
+        using ContainerDifferenceType =
+            decltype(std::distance(std::declval<ContainerIter<C>>(), std::declval<ContainerIter<C>>()));
+
+        template<typename C>
+        using ContainerPointerType =
+            typename std::iterator_traits<ContainerIter<C>>::pointer;
+
+        // container_algorithm_internal::c_begin and
+        // container_algorithm_internal::c_end are abbreviations for proper ADL
+        // lookup of std::begin and std::end, i.e.
+        //   using std::begin;
+        //   using std::end;
+        //   std::foo(begin(c), end(c));
+        // becomes
+        //   std::foo(container_algorithm_internal::begin(c),
+        //            container_algorithm_internal::end(c));
+        // These are meant for internal use only.
+
+        template<typename C>
+        ContainerIter<C> c_begin(C& c)
+        {
+            return begin(c);
+        }
+
+        template<typename C>
+        ContainerIter<C> c_end(C& c)
+        {
+            return end(c);
+        }
+
+        template<typename T>
+        struct IsUnorderedContainer : std::false_type
+        {
+        };
+
+        template<class Key, class T, class Hash, class KeyEqual, class Allocator>
+        struct IsUnorderedContainer<
+            std::unordered_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type
+        {
+        };
+
+        template<class Key, class Hash, class KeyEqual, class Allocator>
+        struct IsUnorderedContainer<std::unordered_set<Key, Hash, KeyEqual, Allocator>> : std::true_type
+        {
+        };
+
+        // container_algorithm_internal::c_size. It is meant for internal use only.
+
+        template<class C>
+        auto c_size(C& c) -> decltype(c.size())
+        {
+            return c.size();
+        }
+
+        template<class T, std::size_t N>
+        constexpr std::size_t c_size(T (&)[N])
+        {
+            return N;
+        }
+
+    }  // namespace container_algorithm_internal
+
+    // PUBLIC API
+
+    //------------------------------------------------------------------------------
+    // Abseil algorithm.h functions
+    //------------------------------------------------------------------------------
+
+    // c_linear_search()
+    //
+    // Container-based version of absl::linear_search() for performing a linear
+    // search within a container.
+    template<typename C, typename EqualityComparable>
+    bool c_linear_search(const C& c, EqualityComparable&& value)
+    {
+        return linear_search(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<EqualityComparable>(value));
+    }
+
+    //------------------------------------------------------------------------------
+    // <iterator> algorithms
+    //------------------------------------------------------------------------------
+
+    // c_distance()
+    //
+    // Container-based version of the <iterator> `std::distance()` function to
+    // return the number of elements within a container.
+    template<typename C>
+    container_algorithm_internal::ContainerDifferenceType<const C> c_distance(
+        const C& c
+    )
+    {
+        return std::distance(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c));
+    }
+
+    //------------------------------------------------------------------------------
+    // <algorithm> Non-modifying sequence operations
+    //------------------------------------------------------------------------------
+
+    // c_all_of()
+    //
+    // Container-based version of the <algorithm> `std::all_of()` function to
+    // test if all elements within a container satisfy a condition.
+    template<typename C, typename Pred>
+    bool c_all_of(const C& c, Pred&& pred)
+    {
+        return std::all_of(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_any_of()
+    //
+    // Container-based version of the <algorithm> `std::any_of()` function to
+    // test if any element in a container fulfills a condition.
+    template<typename C, typename Pred>
+    bool c_any_of(const C& c, Pred&& pred)
+    {
+        return std::any_of(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_none_of()
+    //
+    // Container-based version of the <algorithm> `std::none_of()` function to
+    // test if no elements in a container fulfill a condition.
+    template<typename C, typename Pred>
+    bool c_none_of(const C& c, Pred&& pred)
+    {
+        return std::none_of(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_for_each()
+    //
+    // Container-based version of the <algorithm> `std::for_each()` function to
+    // apply a function to a container's elements.
+    template<typename C, typename Function>
+    decay_t<Function> c_for_each(C&& c, Function&& f)
+    {
+        return std::for_each(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Function>(f));
+    }
+
+    // c_find()
+    //
+    // Container-based version of the <algorithm> `std::find()` function to find
+    // the first element containing the passed value within a container value.
+    template<typename C, typename T>
+    container_algorithm_internal::ContainerIter<C> c_find(C& c, T&& value)
+    {
+        return std::find(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<T>(value));
+    }
+
+    // c_find_if()
+    //
+    // Container-based version of the <algorithm> `std::find_if()` function to find
+    // the first element in a container matching the given condition.
+    template<typename C, typename Pred>
+    container_algorithm_internal::ContainerIter<C> c_find_if(C& c, Pred&& pred)
+    {
+        return std::find_if(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_find_if_not()
+    //
+    // Container-based version of the <algorithm> `std::find_if_not()` function to
+    // find the first element in a container not matching the given condition.
+    template<typename C, typename Pred>
+    container_algorithm_internal::ContainerIter<C> c_find_if_not(C& c, Pred&& pred)
+    {
+        return std::find_if_not(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_find_end()
+    //
+    // Container-based version of the <algorithm> `std::find_end()` function to
+    // find the last subsequence within a container.
+    template<typename Sequence1, typename Sequence2>
+    container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
+        Sequence1& sequence, Sequence2& subsequence
+    )
+    {
+        return std::find_end(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), container_algorithm_internal::c_begin(subsequence), container_algorithm_internal::c_end(subsequence));
+    }
+
+    // Overload of c_find_end() for using a predicate evaluation other than `==` as
+    // the function's test condition.
+    template<typename Sequence1, typename Sequence2, typename BinaryPredicate>
+    container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
+        Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred
+    )
+    {
+        return std::find_end(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), container_algorithm_internal::c_begin(subsequence), container_algorithm_internal::c_end(subsequence), std::forward<BinaryPredicate>(pred));
+    }
+
+    // c_find_first_of()
+    //
+    // Container-based version of the <algorithm> `std::find_first_of()` function to
+    // find the first element within the container that is also within the options
+    // container.
+    template<typename C1, typename C2>
+    container_algorithm_internal::ContainerIter<C1> c_find_first_of(C1& container, C2& options)
+    {
+        return std::find_first_of(container_algorithm_internal::c_begin(container), container_algorithm_internal::c_end(container), container_algorithm_internal::c_begin(options), container_algorithm_internal::c_end(options));
+    }
+
+    // Overload of c_find_first_of() for using a predicate evaluation other than
+    // `==` as the function's test condition.
+    template<typename C1, typename C2, typename BinaryPredicate>
+    container_algorithm_internal::ContainerIter<C1> c_find_first_of(
+        C1& container, C2& options, BinaryPredicate&& pred
+    )
+    {
+        return std::find_first_of(container_algorithm_internal::c_begin(container), container_algorithm_internal::c_end(container), container_algorithm_internal::c_begin(options), container_algorithm_internal::c_end(options), std::forward<BinaryPredicate>(pred));
+    }
+
+    // c_adjacent_find()
+    //
+    // Container-based version of the <algorithm> `std::adjacent_find()` function to
+    // find equal adjacent elements within a container.
+    template<typename Sequence>
+    container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
+        Sequence& sequence
+    )
+    {
+        return std::adjacent_find(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_adjacent_find() for using a predicate evaluation other than
+    // `==` as the function's test condition.
+    template<typename Sequence, typename BinaryPredicate>
+    container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
+        Sequence& sequence, BinaryPredicate&& pred
+    )
+    {
+        return std::adjacent_find(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<BinaryPredicate>(pred));
+    }
+
+    // c_count()
+    //
+    // Container-based version of the <algorithm> `std::count()` function to count
+    // values that match within a container.
+    template<typename C, typename T>
+    container_algorithm_internal::ContainerDifferenceType<const C> c_count(
+        const C& c, T&& value
+    )
+    {
+        return std::count(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<T>(value));
+    }
+
+    // c_count_if()
+    //
+    // Container-based version of the <algorithm> `std::count_if()` function to
+    // count values matching a condition within a container.
+    template<typename C, typename Pred>
+    container_algorithm_internal::ContainerDifferenceType<const C> c_count_if(
+        const C& c, Pred&& pred
+    )
+    {
+        return std::count_if(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_mismatch()
+    //
+    // Container-based version of the <algorithm> `std::mismatch()` function to
+    // return the first element where two ordered containers differ. Applies `==` to
+    // the first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
+    template<typename C1, typename C2>
+    container_algorithm_internal::ContainerIterPairType<C1, C2>
+        c_mismatch(C1& c1, C2& c2)
+    {
+        auto first1 = container_algorithm_internal::c_begin(c1);
+        auto last1 = container_algorithm_internal::c_end(c1);
+        auto first2 = container_algorithm_internal::c_begin(c2);
+        auto last2 = container_algorithm_internal::c_end(c2);
+
+        for (; first1 != last1 && first2 != last2; ++first1, (void)++first2)
+        {
+            // Negates equality because Cpp17EqualityComparable doesn't require clients
+            // to overload both `operator==` and `operator!=`.
+            if (!(*first1 == *first2))
+            {
+                break;
+            }
+        }
+
+        return std::make_pair(first1, first2);
+    }
+
+    // Overload of c_mismatch() for using a predicate evaluation other than `==` as
+    // the function's test condition. Applies `pred`to the first N elements of `c1`
+    // and `c2`, where N = min(size(c1), size(c2)).
+    template<typename C1, typename C2, typename BinaryPredicate>
+    container_algorithm_internal::ContainerIterPairType<C1, C2>
+        c_mismatch(C1& c1, C2& c2, BinaryPredicate pred)
+    {
+        auto first1 = container_algorithm_internal::c_begin(c1);
+        auto last1 = container_algorithm_internal::c_end(c1);
+        auto first2 = container_algorithm_internal::c_begin(c2);
+        auto last2 = container_algorithm_internal::c_end(c2);
+
+        for (; first1 != last1 && first2 != last2; ++first1, (void)++first2)
+        {
+            if (!pred(*first1, *first2))
+            {
+                break;
+            }
+        }
+
+        return std::make_pair(first1, first2);
+    }
+
+    // c_equal()
+    //
+    // Container-based version of the <algorithm> `std::equal()` function to
+    // test whether two containers are equal.
+    //
+    // NOTE: the semantics of c_equal() are slightly different than those of
+    // equal(): while the latter iterates over the second container only up to the
+    // size of the first container, c_equal() also checks whether the container
+    // sizes are equal.  This better matches expectations about c_equal() based on
+    // its signature.
+    //
+    // Example:
+    //   vector v1 = <1, 2, 3>;
+    //   vector v2 = <1, 2, 3, 4>;
+    //   equal(std::begin(v1), std::end(v1), std::begin(v2)) returns true
+    //   c_equal(v1, v2) returns false
+
+    template<typename C1, typename C2>
+    bool c_equal(const C1& c1, const C2& c2)
+    {
+        return ((container_algorithm_internal::c_size(c1) == container_algorithm_internal::c_size(c2)) && std::equal(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2)));
+    }
+
+    // Overload of c_equal() for using a predicate evaluation other than `==` as
+    // the function's test condition.
+    template<typename C1, typename C2, typename BinaryPredicate>
+    bool c_equal(const C1& c1, const C2& c2, BinaryPredicate&& pred)
+    {
+        return ((container_algorithm_internal::c_size(c1) == container_algorithm_internal::c_size(c2)) && std::equal(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), std::forward<BinaryPredicate>(pred)));
+    }
+
+    // c_is_permutation()
+    //
+    // Container-based version of the <algorithm> `std::is_permutation()` function
+    // to test whether a container is a permutation of another.
+    template<typename C1, typename C2>
+    bool c_is_permutation(const C1& c1, const C2& c2)
+    {
+        using std::begin;
+        using std::end;
+        return c1.size() == c2.size() &&
+               std::is_permutation(begin(c1), end(c1), begin(c2));
+    }
+
+    // Overload of c_is_permutation() for using a predicate evaluation other than
+    // `==` as the function's test condition.
+    template<typename C1, typename C2, typename BinaryPredicate>
+    bool c_is_permutation(const C1& c1, const C2& c2, BinaryPredicate&& pred)
+    {
+        using std::begin;
+        using std::end;
+        return c1.size() == c2.size() &&
+               std::is_permutation(begin(c1), end(c1), begin(c2), std::forward<BinaryPredicate>(pred));
+    }
+
+    // c_search()
+    //
+    // Container-based version of the <algorithm> `std::search()` function to search
+    // a container for a subsequence.
+    template<typename Sequence1, typename Sequence2>
+    container_algorithm_internal::ContainerIter<Sequence1> c_search(
+        Sequence1& sequence, Sequence2& subsequence
+    )
+    {
+        return std::search(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), container_algorithm_internal::c_begin(subsequence), container_algorithm_internal::c_end(subsequence));
+    }
+
+    // Overload of c_search() for using a predicate evaluation other than
+    // `==` as the function's test condition.
+    template<typename Sequence1, typename Sequence2, typename BinaryPredicate>
+    container_algorithm_internal::ContainerIter<Sequence1> c_search(
+        Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred
+    )
+    {
+        return std::search(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), container_algorithm_internal::c_begin(subsequence), container_algorithm_internal::c_end(subsequence), std::forward<BinaryPredicate>(pred));
+    }
+
+    // c_search_n()
+    //
+    // Container-based version of the <algorithm> `std::search_n()` function to
+    // search a container for the first sequence of N elements.
+    template<typename Sequence, typename Size, typename T>
+    container_algorithm_internal::ContainerIter<Sequence> c_search_n(
+        Sequence& sequence, Size count, T&& value
+    )
+    {
+        return std::search_n(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), count, std::forward<T>(value));
+    }
+
+    // Overload of c_search_n() for using a predicate evaluation other than
+    // `==` as the function's test condition.
+    template<typename Sequence, typename Size, typename T, typename BinaryPredicate>
+    container_algorithm_internal::ContainerIter<Sequence> c_search_n(
+        Sequence& sequence, Size count, T&& value, BinaryPredicate&& pred
+    )
+    {
+        return std::search_n(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), count, std::forward<T>(value), std::forward<BinaryPredicate>(pred));
+    }
+
+    //------------------------------------------------------------------------------
+    // <algorithm> Modifying sequence operations
+    //------------------------------------------------------------------------------
+
+    // c_copy()
+    //
+    // Container-based version of the <algorithm> `std::copy()` function to copy a
+    // container's elements into an iterator.
+    template<typename InputSequence, typename OutputIterator>
+    OutputIterator c_copy(const InputSequence& input, OutputIterator output)
+    {
+        return std::copy(container_algorithm_internal::c_begin(input), container_algorithm_internal::c_end(input), output);
+    }
+
+    // c_copy_n()
+    //
+    // Container-based version of the <algorithm> `std::copy_n()` function to copy a
+    // container's first N elements into an iterator.
+    template<typename C, typename Size, typename OutputIterator>
+    OutputIterator c_copy_n(const C& input, Size n, OutputIterator output)
+    {
+        return std::copy_n(container_algorithm_internal::c_begin(input), n, output);
+    }
+
+    // c_copy_if()
+    //
+    // Container-based version of the <algorithm> `std::copy_if()` function to copy
+    // a container's elements satisfying some condition into an iterator.
+    template<typename InputSequence, typename OutputIterator, typename Pred>
+    OutputIterator c_copy_if(const InputSequence& input, OutputIterator output, Pred&& pred)
+    {
+        return std::copy_if(container_algorithm_internal::c_begin(input), container_algorithm_internal::c_end(input), output, std::forward<Pred>(pred));
+    }
+
+    // c_copy_backward()
+    //
+    // Container-based version of the <algorithm> `std::copy_backward()` function to
+    // copy a container's elements in reverse order into an iterator.
+    template<typename C, typename BidirectionalIterator>
+    BidirectionalIterator c_copy_backward(const C& src, BidirectionalIterator dest)
+    {
+        return std::copy_backward(container_algorithm_internal::c_begin(src), container_algorithm_internal::c_end(src), dest);
+    }
+
+    // c_move()
+    //
+    // Container-based version of the <algorithm> `std::move()` function to move
+    // a container's elements into an iterator.
+    template<typename C, typename OutputIterator>
+    OutputIterator c_move(C&& src, OutputIterator dest)
+    {
+        return std::move(container_algorithm_internal::c_begin(src), container_algorithm_internal::c_end(src), dest);
+    }
+
+    // c_move_backward()
+    //
+    // Container-based version of the <algorithm> `std::move_backward()` function to
+    // move a container's elements into an iterator in reverse order.
+    template<typename C, typename BidirectionalIterator>
+    BidirectionalIterator c_move_backward(C&& src, BidirectionalIterator dest)
+    {
+        return std::move_backward(container_algorithm_internal::c_begin(src), container_algorithm_internal::c_end(src), dest);
+    }
+
+    // c_swap_ranges()
+    //
+    // Container-based version of the <algorithm> `std::swap_ranges()` function to
+    // swap a container's elements with another container's elements. Swaps the
+    // first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
+    template<typename C1, typename C2>
+    container_algorithm_internal::ContainerIter<C2> c_swap_ranges(C1& c1, C2& c2)
+    {
+        auto first1 = container_algorithm_internal::c_begin(c1);
+        auto last1 = container_algorithm_internal::c_end(c1);
+        auto first2 = container_algorithm_internal::c_begin(c2);
+        auto last2 = container_algorithm_internal::c_end(c2);
+
+        using std::swap;
+        for (; first1 != last1 && first2 != last2; ++first1, (void)++first2)
+        {
+            swap(*first1, *first2);
+        }
+        return first2;
+    }
+
+    // c_transform()
+    //
+    // Container-based version of the <algorithm> `std::transform()` function to
+    // transform a container's elements using the unary operation, storing the
+    // result in an iterator pointing to the last transformed element in the output
+    // range.
+    template<typename InputSequence, typename OutputIterator, typename UnaryOp>
+    OutputIterator c_transform(const InputSequence& input, OutputIterator output, UnaryOp&& unary_op)
+    {
+        return std::transform(container_algorithm_internal::c_begin(input), container_algorithm_internal::c_end(input), output, std::forward<UnaryOp>(unary_op));
+    }
+
+    // Overload of c_transform() for performing a transformation using a binary
+    // predicate. Applies `binary_op` to the first N elements of `c1` and `c2`,
+    // where N = min(size(c1), size(c2)).
+    template<typename InputSequence1, typename InputSequence2, typename OutputIterator, typename BinaryOp>
+    OutputIterator c_transform(const InputSequence1& input1, const InputSequence2& input2, OutputIterator output, BinaryOp&& binary_op)
+    {
+        auto first1 = container_algorithm_internal::c_begin(input1);
+        auto last1 = container_algorithm_internal::c_end(input1);
+        auto first2 = container_algorithm_internal::c_begin(input2);
+        auto last2 = container_algorithm_internal::c_end(input2);
+        for (; first1 != last1 && first2 != last2;
+             ++first1, (void)++first2, ++output)
+        {
+            *output = binary_op(*first1, *first2);
+        }
+
+        return output;
+    }
+
+    // c_replace()
+    //
+    // Container-based version of the <algorithm> `std::replace()` function to
+    // replace a container's elements of some value with a new value. The container
+    // is modified in place.
+    template<typename Sequence, typename T>
+    void c_replace(Sequence& sequence, const T& old_value, const T& new_value)
+    {
+        std::replace(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), old_value, new_value);
+    }
+
+    // c_replace_if()
+    //
+    // Container-based version of the <algorithm> `std::replace_if()` function to
+    // replace a container's elements of some value with a new value based on some
+    // condition. The container is modified in place.
+    template<typename C, typename Pred, typename T>
+    void c_replace_if(C& c, Pred&& pred, T&& new_value)
+    {
+        std::replace_if(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred), std::forward<T>(new_value));
+    }
+
+    // c_replace_copy()
+    //
+    // Container-based version of the <algorithm> `std::replace_copy()` function to
+    // replace a container's elements of some value with a new value  and return the
+    // results within an iterator.
+    template<typename C, typename OutputIterator, typename T>
+    OutputIterator c_replace_copy(const C& c, OutputIterator result, T&& old_value, T&& new_value)
+    {
+        return std::replace_copy(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), result, std::forward<T>(old_value), std::forward<T>(new_value));
+    }
+
+    // c_replace_copy_if()
+    //
+    // Container-based version of the <algorithm> `std::replace_copy_if()` function
+    // to replace a container's elements of some value with a new value based on
+    // some condition, and return the results within an iterator.
+    template<typename C, typename OutputIterator, typename Pred, typename T>
+    OutputIterator c_replace_copy_if(const C& c, OutputIterator result, Pred&& pred, T&& new_value)
+    {
+        return std::replace_copy_if(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), result, std::forward<Pred>(pred), std::forward<T>(new_value));
+    }
+
+    // c_fill()
+    //
+    // Container-based version of the <algorithm> `std::fill()` function to fill a
+    // container with some value.
+    template<typename C, typename T>
+    void c_fill(C& c, T&& value)
+    {
+        std::fill(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<T>(value));
+    }
+
+    // c_fill_n()
+    //
+    // Container-based version of the <algorithm> `std::fill_n()` function to fill
+    // the first N elements in a container with some value.
+    template<typename C, typename Size, typename T>
+    void c_fill_n(C& c, Size n, T&& value)
+    {
+        std::fill_n(container_algorithm_internal::c_begin(c), n, std::forward<T>(value));
+    }
+
+    // c_generate()
+    //
+    // Container-based version of the <algorithm> `std::generate()` function to
+    // assign a container's elements to the values provided by the given generator.
+    template<typename C, typename Generator>
+    void c_generate(C& c, Generator&& gen)
+    {
+        std::generate(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Generator>(gen));
+    }
+
+    // c_generate_n()
+    //
+    // Container-based version of the <algorithm> `std::generate_n()` function to
+    // assign a container's first N elements to the values provided by the given
+    // generator.
+    template<typename C, typename Size, typename Generator>
+    container_algorithm_internal::ContainerIter<C> c_generate_n(C& c, Size n, Generator&& gen)
+    {
+        return std::generate_n(container_algorithm_internal::c_begin(c), n, std::forward<Generator>(gen));
+    }
+
+    // Note: `c_xx()` <algorithm> container versions for `remove()`, `remove_if()`,
+    // and `unique()` are omitted, because it's not clear whether or not such
+    // functions should call erase on their supplied sequences afterwards. Either
+    // behavior would be surprising for a different set of users.
+
+    // c_remove_copy()
+    //
+    // Container-based version of the <algorithm> `std::remove_copy()` function to
+    // copy a container's elements while removing any elements matching the given
+    // `value`.
+    template<typename C, typename OutputIterator, typename T>
+    OutputIterator c_remove_copy(const C& c, OutputIterator result, T&& value)
+    {
+        return std::remove_copy(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), result, std::forward<T>(value));
+    }
+
+    // c_remove_copy_if()
+    //
+    // Container-based version of the <algorithm> `std::remove_copy_if()` function
+    // to copy a container's elements while removing any elements matching the given
+    // condition.
+    template<typename C, typename OutputIterator, typename Pred>
+    OutputIterator c_remove_copy_if(const C& c, OutputIterator result, Pred&& pred)
+    {
+        return std::remove_copy_if(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), result, std::forward<Pred>(pred));
+    }
+
+    // c_unique_copy()
+    //
+    // Container-based version of the <algorithm> `std::unique_copy()` function to
+    // copy a container's elements while removing any elements containing duplicate
+    // values.
+    template<typename C, typename OutputIterator>
+    OutputIterator c_unique_copy(const C& c, OutputIterator result)
+    {
+        return std::unique_copy(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), result);
+    }
+
+    // Overload of c_unique_copy() for using a predicate evaluation other than
+    // `==` for comparing uniqueness of the element values.
+    template<typename C, typename OutputIterator, typename BinaryPredicate>
+    OutputIterator c_unique_copy(const C& c, OutputIterator result, BinaryPredicate&& pred)
+    {
+        return std::unique_copy(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), result, std::forward<BinaryPredicate>(pred));
+    }
+
+    // c_reverse()
+    //
+    // Container-based version of the <algorithm> `std::reverse()` function to
+    // reverse a container's elements.
+    template<typename Sequence>
+    void c_reverse(Sequence& sequence)
+    {
+        std::reverse(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // c_reverse_copy()
+    //
+    // Container-based version of the <algorithm> `std::reverse()` function to
+    // reverse a container's elements and write them to an iterator range.
+    template<typename C, typename OutputIterator>
+    OutputIterator c_reverse_copy(const C& sequence, OutputIterator result)
+    {
+        return std::reverse_copy(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), result);
+    }
+
+    // c_rotate()
+    //
+    // Container-based version of the <algorithm> `std::rotate()` function to
+    // shift a container's elements leftward such that the `middle` element becomes
+    // the first element in the container.
+    template<typename C, typename Iterator = container_algorithm_internal::ContainerIter<C>>
+    Iterator c_rotate(C& sequence, Iterator middle)
+    {
+        return absl::rotate(container_algorithm_internal::c_begin(sequence), middle, container_algorithm_internal::c_end(sequence));
+    }
+
+    // c_rotate_copy()
+    //
+    // Container-based version of the <algorithm> `std::rotate_copy()` function to
+    // shift a container's elements leftward such that the `middle` element becomes
+    // the first element in a new iterator range.
+    template<typename C, typename OutputIterator>
+    OutputIterator c_rotate_copy(
+        const C& sequence,
+        container_algorithm_internal::ContainerIter<const C> middle,
+        OutputIterator result
+    )
+    {
+        return std::rotate_copy(container_algorithm_internal::c_begin(sequence), middle, container_algorithm_internal::c_end(sequence), result);
+    }
+
+    // c_shuffle()
+    //
+    // Container-based version of the <algorithm> `std::shuffle()` function to
+    // randomly shuffle elements within the container using a `gen()` uniform random
+    // number generator.
+    template<typename RandomAccessContainer, typename UniformRandomBitGenerator>
+    void c_shuffle(RandomAccessContainer& c, UniformRandomBitGenerator&& gen)
+    {
+        std::shuffle(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<UniformRandomBitGenerator>(gen));
+    }
+
+    //------------------------------------------------------------------------------
+    // <algorithm> Partition functions
+    //------------------------------------------------------------------------------
+
+    // c_is_partitioned()
+    //
+    // Container-based version of the <algorithm> `std::is_partitioned()` function
+    // to test whether all elements in the container for which `pred` returns `true`
+    // precede those for which `pred` is `false`.
+    template<typename C, typename Pred>
+    bool c_is_partitioned(const C& c, Pred&& pred)
+    {
+        return std::is_partitioned(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_partition()
+    //
+    // Container-based version of the <algorithm> `std::partition()` function
+    // to rearrange all elements in a container in such a way that all elements for
+    // which `pred` returns `true` precede all those for which it returns `false`,
+    // returning an iterator to the first element of the second group.
+    template<typename C, typename Pred>
+    container_algorithm_internal::ContainerIter<C> c_partition(C& c, Pred&& pred)
+    {
+        return std::partition(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_stable_partition()
+    //
+    // Container-based version of the <algorithm> `std::stable_partition()` function
+    // to rearrange all elements in a container in such a way that all elements for
+    // which `pred` returns `true` precede all those for which it returns `false`,
+    // preserving the relative ordering between the two groups. The function returns
+    // an iterator to the first element of the second group.
+    template<typename C, typename Pred>
+    container_algorithm_internal::ContainerIter<C> c_stable_partition(C& c, Pred&& pred)
+    {
+        return std::stable_partition(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    // c_partition_copy()
+    //
+    // Container-based version of the <algorithm> `std::partition_copy()` function
+    // to partition a container's elements and return them into two iterators: one
+    // for which `pred` returns `true`, and one for which `pred` returns `false.`
+
+    template<typename C, typename OutputIterator1, typename OutputIterator2, typename Pred>
+    std::pair<OutputIterator1, OutputIterator2> c_partition_copy(
+        const C& c, OutputIterator1 out_true, OutputIterator2 out_false, Pred&& pred
+    )
+    {
+        return std::partition_copy(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), out_true, out_false, std::forward<Pred>(pred));
+    }
+
+    // c_partition_point()
+    //
+    // Container-based version of the <algorithm> `std::partition_point()` function
+    // to return the first element of an already partitioned container for which
+    // the given `pred` is not `true`.
+    template<typename C, typename Pred>
+    container_algorithm_internal::ContainerIter<C> c_partition_point(C& c, Pred&& pred)
+    {
+        return std::partition_point(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<Pred>(pred));
+    }
+
+    //------------------------------------------------------------------------------
+    // <algorithm> Sorting functions
+    //------------------------------------------------------------------------------
+
+    // c_sort()
+    //
+    // Container-based version of the <algorithm> `std::sort()` function
+    // to sort elements in ascending order of their values.
+    template<typename C>
+    void c_sort(C& c)
+    {
+        std::sort(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c));
+    }
+
+    // Overload of c_sort() for performing a `comp` comparison other than the
+    // default `operator<`.
+    template<typename C, typename LessThan>
+    void c_sort(C& c, LessThan&& comp)
+    {
+        std::sort(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<LessThan>(comp));
+    }
+
+    // c_stable_sort()
+    //
+    // Container-based version of the <algorithm> `std::stable_sort()` function
+    // to sort elements in ascending order of their values, preserving the order
+    // of equivalents.
+    template<typename C>
+    void c_stable_sort(C& c)
+    {
+        std::stable_sort(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c));
+    }
+
+    // Overload of c_stable_sort() for performing a `comp` comparison other than the
+    // default `operator<`.
+    template<typename C, typename LessThan>
+    void c_stable_sort(C& c, LessThan&& comp)
+    {
+        std::stable_sort(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<LessThan>(comp));
+    }
+
+    // c_is_sorted()
+    //
+    // Container-based version of the <algorithm> `std::is_sorted()` function
+    // to evaluate whether the given container is sorted in ascending order.
+    template<typename C>
+    bool c_is_sorted(const C& c)
+    {
+        return std::is_sorted(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c));
+    }
+
+    // c_is_sorted() overload for performing a `comp` comparison other than the
+    // default `operator<`.
+    template<typename C, typename LessThan>
+    bool c_is_sorted(const C& c, LessThan&& comp)
+    {
+        return std::is_sorted(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<LessThan>(comp));
+    }
+
+    // c_partial_sort()
+    //
+    // Container-based version of the <algorithm> `std::partial_sort()` function
+    // to rearrange elements within a container such that elements before `middle`
+    // are sorted in ascending order.
+    template<typename RandomAccessContainer>
+    void c_partial_sort(
+        RandomAccessContainer& sequence,
+        container_algorithm_internal::ContainerIter<RandomAccessContainer> middle
+    )
+    {
+        std::partial_sort(container_algorithm_internal::c_begin(sequence), middle, container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_partial_sort() for performing a `comp` comparison other than
+    // the default `operator<`.
+    template<typename RandomAccessContainer, typename LessThan>
+    void c_partial_sort(
+        RandomAccessContainer& sequence,
+        container_algorithm_internal::ContainerIter<RandomAccessContainer> middle,
+        LessThan&& comp
+    )
+    {
+        std::partial_sort(container_algorithm_internal::c_begin(sequence), middle, container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    // c_partial_sort_copy()
+    //
+    // Container-based version of the <algorithm> `std::partial_sort_copy()`
+    // function to sort the elements in the given range `result` within the larger
+    // `sequence` in ascending order (and using `result` as the output parameter).
+    // At most min(result.last - result.first, sequence.last - sequence.first)
+    // elements from the sequence will be stored in the result.
+    template<typename C, typename RandomAccessContainer>
+    container_algorithm_internal::ContainerIter<RandomAccessContainer>
+        c_partial_sort_copy(const C& sequence, RandomAccessContainer& result)
+    {
+        return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), container_algorithm_internal::c_begin(result), container_algorithm_internal::c_end(result));
+    }
+
+    // Overload of c_partial_sort_copy() for performing a `comp` comparison other
+    // than the default `operator<`.
+    template<typename C, typename RandomAccessContainer, typename LessThan>
+    container_algorithm_internal::ContainerIter<RandomAccessContainer>
+        c_partial_sort_copy(const C& sequence, RandomAccessContainer& result, LessThan&& comp)
+    {
+        return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), container_algorithm_internal::c_begin(result), container_algorithm_internal::c_end(result), std::forward<LessThan>(comp));
+    }
+
+    // c_is_sorted_until()
+    //
+    // Container-based version of the <algorithm> `std::is_sorted_until()` function
+    // to return the first element within a container that is not sorted in
+    // ascending order as an iterator.
+    template<typename C>
+    container_algorithm_internal::ContainerIter<C> c_is_sorted_until(C& c)
+    {
+        return std::is_sorted_until(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c));
+    }
+
+    // Overload of c_is_sorted_until() for performing a `comp` comparison other than
+    // the default `operator<`.
+    template<typename C, typename LessThan>
+    container_algorithm_internal::ContainerIter<C> c_is_sorted_until(
+        C& c, LessThan&& comp
+    )
+    {
+        return std::is_sorted_until(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<LessThan>(comp));
+    }
+
+    // c_nth_element()
+    //
+    // Container-based version of the <algorithm> `std::nth_element()` function
+    // to rearrange the elements within a container such that the `nth` element
+    // would be in that position in an ordered sequence; other elements may be in
+    // any order, except that all preceding `nth` will be less than that element,
+    // and all following `nth` will be greater than that element.
+    template<typename RandomAccessContainer>
+    void c_nth_element(
+        RandomAccessContainer& sequence,
+        container_algorithm_internal::ContainerIter<RandomAccessContainer> nth
+    )
+    {
+        std::nth_element(container_algorithm_internal::c_begin(sequence), nth, container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_nth_element() for performing a `comp` comparison other than
+    // the default `operator<`.
+    template<typename RandomAccessContainer, typename LessThan>
+    void c_nth_element(
+        RandomAccessContainer& sequence,
+        container_algorithm_internal::ContainerIter<RandomAccessContainer> nth,
+        LessThan&& comp
+    )
+    {
+        std::nth_element(container_algorithm_internal::c_begin(sequence), nth, container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    //------------------------------------------------------------------------------
+    // <algorithm> Binary Search
+    //------------------------------------------------------------------------------
+
+    // c_lower_bound()
+    //
+    // Container-based version of the <algorithm> `std::lower_bound()` function
+    // to return an iterator pointing to the first element in a sorted container
+    // which does not compare less than `value`.
+    template<typename Sequence, typename T>
+    container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
+        Sequence& sequence, T&& value
+    )
+    {
+        return std::lower_bound(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value));
+    }
+
+    // Overload of c_lower_bound() for performing a `comp` comparison other than
+    // the default `operator<`.
+    template<typename Sequence, typename T, typename LessThan>
+    container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
+        Sequence& sequence, T&& value, LessThan&& comp
+    )
+    {
+        return std::lower_bound(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value), std::forward<LessThan>(comp));
+    }
+
+    // c_upper_bound()
+    //
+    // Container-based version of the <algorithm> `std::upper_bound()` function
+    // to return an iterator pointing to the first element in a sorted container
+    // which is greater than `value`.
+    template<typename Sequence, typename T>
+    container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
+        Sequence& sequence, T&& value
+    )
+    {
+        return std::upper_bound(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value));
+    }
+
+    // Overload of c_upper_bound() for performing a `comp` comparison other than
+    // the default `operator<`.
+    template<typename Sequence, typename T, typename LessThan>
+    container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
+        Sequence& sequence, T&& value, LessThan&& comp
+    )
+    {
+        return std::upper_bound(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value), std::forward<LessThan>(comp));
+    }
+
+    // c_equal_range()
+    //
+    // Container-based version of the <algorithm> `std::equal_range()` function
+    // to return an iterator pair pointing to the first and last elements in a
+    // sorted container which compare equal to `value`.
+    template<typename Sequence, typename T>
+    container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
+        c_equal_range(Sequence& sequence, T&& value)
+    {
+        return std::equal_range(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value));
+    }
+
+    // Overload of c_equal_range() for performing a `comp` comparison other than
+    // the default `operator<`.
+    template<typename Sequence, typename T, typename LessThan>
+    container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
+        c_equal_range(Sequence& sequence, T&& value, LessThan&& comp)
+    {
+        return std::equal_range(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value), std::forward<LessThan>(comp));
+    }
+
+    // c_binary_search()
+    //
+    // Container-based version of the <algorithm> `std::binary_search()` function
+    // to test if any element in the sorted container contains a value equivalent to
+    // 'value'.
+    template<typename Sequence, typename T>
+    bool c_binary_search(Sequence&& sequence, T&& value)
+    {
+        return std::binary_search(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value));
+    }
+
+    // Overload of c_binary_search() for performing a `comp` comparison other than
+    // the default `operator<`.
+    template<typename Sequence, typename T, typename LessThan>
+    bool c_binary_search(Sequence&& sequence, T&& value, LessThan&& comp)
+    {
+        return std::binary_search(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value), std::forward<LessThan>(comp));
+    }
+
+    //------------------------------------------------------------------------------
+    // <algorithm> Merge functions
+    //------------------------------------------------------------------------------
+
+    // c_merge()
+    //
+    // Container-based version of the <algorithm> `std::merge()` function
+    // to merge two sorted containers into a single sorted iterator.
+    template<typename C1, typename C2, typename OutputIterator>
+    OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result)
+    {
+        return std::merge(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), result);
+    }
+
+    // Overload of c_merge() for performing a `comp` comparison other than
+    // the default `operator<`.
+    template<typename C1, typename C2, typename OutputIterator, typename LessThan>
+    OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result, LessThan&& comp)
+    {
+        return std::merge(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), result, std::forward<LessThan>(comp));
+    }
+
+    // c_inplace_merge()
+    //
+    // Container-based version of the <algorithm> `std::inplace_merge()` function
+    // to merge a supplied iterator `middle` into a container.
+    template<typename C>
+    void c_inplace_merge(C& c, container_algorithm_internal::ContainerIter<C> middle)
+    {
+        std::inplace_merge(container_algorithm_internal::c_begin(c), middle, container_algorithm_internal::c_end(c));
+    }
+
+    // Overload of c_inplace_merge() for performing a merge using a `comp` other
+    // than `operator<`.
+    template<typename C, typename LessThan>
+    void c_inplace_merge(C& c, container_algorithm_internal::ContainerIter<C> middle, LessThan&& comp)
+    {
+        std::inplace_merge(container_algorithm_internal::c_begin(c), middle, container_algorithm_internal::c_end(c), std::forward<LessThan>(comp));
+    }
+
+    // c_includes()
+    //
+    // Container-based version of the <algorithm> `std::includes()` function
+    // to test whether a sorted container `c1` entirely contains another sorted
+    // container `c2`.
+    template<typename C1, typename C2>
+    bool c_includes(const C1& c1, const C2& c2)
+    {
+        return std::includes(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2));
+    }
+
+    // Overload of c_includes() for performing a merge using a `comp` other than
+    // `operator<`.
+    template<typename C1, typename C2, typename LessThan>
+    bool c_includes(const C1& c1, const C2& c2, LessThan&& comp)
+    {
+        return std::includes(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), std::forward<LessThan>(comp));
+    }
+
+    // c_set_union()
+    //
+    // Container-based version of the <algorithm> `std::set_union()` function
+    // to return an iterator containing the union of two containers; duplicate
+    // values are not copied into the output.
+    template<typename C1, typename C2, typename OutputIterator, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
+    OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output)
+    {
+        return std::set_union(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), output);
+    }
+
+    // Overload of c_set_union() for performing a merge using a `comp` other than
+    // `operator<`.
+    template<typename C1, typename C2, typename OutputIterator, typename LessThan, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
+    OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp)
+    {
+        return std::set_union(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), output, std::forward<LessThan>(comp));
+    }
+
+    // c_set_intersection()
+    //
+    // Container-based version of the <algorithm> `std::set_intersection()` function
+    // to return an iterator containing the intersection of two sorted containers.
+    template<typename C1, typename C2, typename OutputIterator, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
+    OutputIterator c_set_intersection(const C1& c1, const C2& c2, OutputIterator output)
+    {
+        // In debug builds, ensure that both containers are sorted with respect to the
+        // default comparator. std::set_intersection requires the containers be sorted
+        // using operator<.
+        assert(absl::c_is_sorted(c1));
+        assert(absl::c_is_sorted(c2));
+        return std::set_intersection(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), output);
+    }
+
+    // Overload of c_set_intersection() for performing a merge using a `comp` other
+    // than `operator<`.
+    template<typename C1, typename C2, typename OutputIterator, typename LessThan, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
+    OutputIterator c_set_intersection(const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp)
+    {
+        // In debug builds, ensure that both containers are sorted with respect to the
+        // default comparator. std::set_intersection requires the containers be sorted
+        // using the same comparator.
+        assert(absl::c_is_sorted(c1, comp));
+        assert(absl::c_is_sorted(c2, comp));
+        return std::set_intersection(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), output, std::forward<LessThan>(comp));
+    }
+
+    // c_set_difference()
+    //
+    // Container-based version of the <algorithm> `std::set_difference()` function
+    // to return an iterator containing elements present in the first container but
+    // not in the second.
+    template<typename C1, typename C2, typename OutputIterator, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
+    OutputIterator c_set_difference(const C1& c1, const C2& c2, OutputIterator output)
+    {
+        return std::set_difference(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), output);
+    }
+
+    // Overload of c_set_difference() for performing a merge using a `comp` other
+    // than `operator<`.
+    template<typename C1, typename C2, typename OutputIterator, typename LessThan, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
+    OutputIterator c_set_difference(const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp)
+    {
+        return std::set_difference(container_algorithm_internal::c_begin(c1), container_algorithm_internal::c_end(c1), container_algorithm_internal::c_begin(c2), container_algorithm_internal::c_end(c2), output, std::forward<LessThan>(comp));
+    }
+
+    // c_set_symmetric_difference()
+    //
+    // Container-based version of the <algorithm> `std::set_symmetric_difference()`
+    // function to return an iterator containing elements present in either one
+    // container or the other, but not both.
+    template<typename C1, typename C2, typename OutputIterator, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
+    OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2, OutputIterator output)
+    {
+        return std::set_symmetric_difference(
+            container_algorithm_internal::c_begin(c1),
+            container_algorithm_internal::c_end(c1),
+            container_algorithm_internal::c_begin(c2),
+            container_algorithm_internal::c_end(c2),
+            output
+        );
+    }
+
+    // Overload of c_set_symmetric_difference() for performing a merge using a
+    // `comp` other than `operator<`.
+    template<typename C1, typename C2, typename OutputIterator, typename LessThan, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if<!container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
+    OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp)
+    {
+        return std::set_symmetric_difference(
+            container_algorithm_internal::c_begin(c1),
+            container_algorithm_internal::c_end(c1),
+            container_algorithm_internal::c_begin(c2),
+            container_algorithm_internal::c_end(c2),
+            output,
+            std::forward<LessThan>(comp)
+        );
+    }
+
+    //------------------------------------------------------------------------------
+    // <algorithm> Heap functions
+    //------------------------------------------------------------------------------
+
+    // c_push_heap()
+    //
+    // Container-based version of the <algorithm> `std::push_heap()` function
+    // to push a value onto a container heap.
+    template<typename RandomAccessContainer>
+    void c_push_heap(RandomAccessContainer& sequence)
+    {
+        std::push_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_push_heap() for performing a push operation on a heap using a
+    // `comp` other than `operator<`.
+    template<typename RandomAccessContainer, typename LessThan>
+    void c_push_heap(RandomAccessContainer& sequence, LessThan&& comp)
+    {
+        std::push_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    // c_pop_heap()
+    //
+    // Container-based version of the <algorithm> `std::pop_heap()` function
+    // to pop a value from a heap container.
+    template<typename RandomAccessContainer>
+    void c_pop_heap(RandomAccessContainer& sequence)
+    {
+        std::pop_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_pop_heap() for performing a pop operation on a heap using a
+    // `comp` other than `operator<`.
+    template<typename RandomAccessContainer, typename LessThan>
+    void c_pop_heap(RandomAccessContainer& sequence, LessThan&& comp)
+    {
+        std::pop_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    // c_make_heap()
+    //
+    // Container-based version of the <algorithm> `std::make_heap()` function
+    // to make a container a heap.
+    template<typename RandomAccessContainer>
+    void c_make_heap(RandomAccessContainer& sequence)
+    {
+        std::make_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_make_heap() for performing heap comparisons using a
+    // `comp` other than `operator<`
+    template<typename RandomAccessContainer, typename LessThan>
+    void c_make_heap(RandomAccessContainer& sequence, LessThan&& comp)
+    {
+        std::make_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    // c_sort_heap()
+    //
+    // Container-based version of the <algorithm> `std::sort_heap()` function
+    // to sort a heap into ascending order (after which it is no longer a heap).
+    template<typename RandomAccessContainer>
+    void c_sort_heap(RandomAccessContainer& sequence)
+    {
+        std::sort_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_sort_heap() for performing heap comparisons using a
+    // `comp` other than `operator<`
+    template<typename RandomAccessContainer, typename LessThan>
+    void c_sort_heap(RandomAccessContainer& sequence, LessThan&& comp)
+    {
+        std::sort_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    // c_is_heap()
+    //
+    // Container-based version of the <algorithm> `std::is_heap()` function
+    // to check whether the given container is a heap.
+    template<typename RandomAccessContainer>
+    bool c_is_heap(const RandomAccessContainer& sequence)
+    {
+        return std::is_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_is_heap() for performing heap comparisons using a
+    // `comp` other than `operator<`
+    template<typename RandomAccessContainer, typename LessThan>
+    bool c_is_heap(const RandomAccessContainer& sequence, LessThan&& comp)
+    {
+        return std::is_heap(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    // c_is_heap_until()
+    //
+    // Container-based version of the <algorithm> `std::is_heap_until()` function
+    // to find the first element in a given container which is not in heap order.
+    template<typename RandomAccessContainer>
+    container_algorithm_internal::ContainerIter<RandomAccessContainer>
+        c_is_heap_until(RandomAccessContainer& sequence)
+    {
+        return std::is_heap_until(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_is_heap_until() for performing heap comparisons using a
+    // `comp` other than `operator<`
+    template<typename RandomAccessContainer, typename LessThan>
+    container_algorithm_internal::ContainerIter<RandomAccessContainer>
+        c_is_heap_until(RandomAccessContainer& sequence, LessThan&& comp)
+    {
+        return std::is_heap_until(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    //------------------------------------------------------------------------------
+    //  <algorithm> Min/max
+    //------------------------------------------------------------------------------
+
+    // c_min_element()
+    //
+    // Container-based version of the <algorithm> `std::min_element()` function
+    // to return an iterator pointing to the element with the smallest value, using
+    // `operator<` to make the comparisons.
+    template<typename Sequence>
+    container_algorithm_internal::ContainerIter<Sequence> c_min_element(
+        Sequence& sequence
+    )
+    {
+        return std::min_element(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_min_element() for performing a `comp` comparison other than
+    // `operator<`.
+    template<typename Sequence, typename LessThan>
+    container_algorithm_internal::ContainerIter<Sequence> c_min_element(
+        Sequence& sequence, LessThan&& comp
+    )
+    {
+        return std::min_element(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    // c_max_element()
+    //
+    // Container-based version of the <algorithm> `std::max_element()` function
+    // to return an iterator pointing to the element with the largest value, using
+    // `operator<` to make the comparisons.
+    template<typename Sequence>
+    container_algorithm_internal::ContainerIter<Sequence> c_max_element(
+        Sequence& sequence
+    )
+    {
+        return std::max_element(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence));
+    }
+
+    // Overload of c_max_element() for performing a `comp` comparison other than
+    // `operator<`.
+    template<typename Sequence, typename LessThan>
+    container_algorithm_internal::ContainerIter<Sequence> c_max_element(
+        Sequence& sequence, LessThan&& comp
+    )
+    {
+        return std::max_element(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<LessThan>(comp));
+    }
+
+    // c_minmax_element()
+    //
+    // Container-based version of the <algorithm> `std::minmax_element()` function
+    // to return a pair of iterators pointing to the elements containing the
+    // smallest and largest values, respectively, using `operator<` to make the
+    // comparisons.
+    template<typename C>
+    container_algorithm_internal::ContainerIterPairType<C, C>
+        c_minmax_element(C& c)
+    {
+        return std::minmax_element(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c));
+    }
+
+    // Overload of c_minmax_element() for performing `comp` comparisons other than
+    // `operator<`.
+    template<typename C, typename LessThan>
+    container_algorithm_internal::ContainerIterPairType<C, C>
+        c_minmax_element(C& c, LessThan&& comp)
+    {
+        return std::minmax_element(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<LessThan>(comp));
+    }
+
+    //------------------------------------------------------------------------------
+    //  <algorithm> Lexicographical Comparisons
+    //------------------------------------------------------------------------------
+
+    // c_lexicographical_compare()
+    //
+    // Container-based version of the <algorithm> `std::lexicographical_compare()`
+    // function to lexicographically compare (e.g. sort words alphabetically) two
+    // container sequences. The comparison is performed using `operator<`. Note
+    // that capital letters ("A-Z") have ASCII values less than lowercase letters
+    // ("a-z").
+    template<typename Sequence1, typename Sequence2>
+    bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2)
+    {
+        return std::lexicographical_compare(
+            container_algorithm_internal::c_begin(sequence1),
+            container_algorithm_internal::c_end(sequence1),
+            container_algorithm_internal::c_begin(sequence2),
+            container_algorithm_internal::c_end(sequence2)
+        );
+    }
+
+    // Overload of c_lexicographical_compare() for performing a lexicographical
+    // comparison using a `comp` operator instead of `operator<`.
+    template<typename Sequence1, typename Sequence2, typename LessThan>
+    bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2, LessThan&& comp)
+    {
+        return std::lexicographical_compare(
+            container_algorithm_internal::c_begin(sequence1),
+            container_algorithm_internal::c_end(sequence1),
+            container_algorithm_internal::c_begin(sequence2),
+            container_algorithm_internal::c_end(sequence2),
+            std::forward<LessThan>(comp)
+        );
+    }
+
+    // c_next_permutation()
+    //
+    // Container-based version of the <algorithm> `std::next_permutation()` function
+    // to rearrange a container's elements into the next lexicographically greater
+    // permutation.
+    template<typename C>
+    bool c_next_permutation(C& c)
+    {
+        return std::next_permutation(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c));
+    }
+
+    // Overload of c_next_permutation() for performing a lexicographical
+    // comparison using a `comp` operator instead of `operator<`.
+    template<typename C, typename LessThan>
+    bool c_next_permutation(C& c, LessThan&& comp)
+    {
+        return std::next_permutation(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<LessThan>(comp));
+    }
+
+    // c_prev_permutation()
+    //
+    // Container-based version of the <algorithm> `std::prev_permutation()` function
+    // to rearrange a container's elements into the next lexicographically lesser
+    // permutation.
+    template<typename C>
+    bool c_prev_permutation(C& c)
+    {
+        return std::prev_permutation(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c));
+    }
+
+    // Overload of c_prev_permutation() for performing a lexicographical
+    // comparison using a `comp` operator instead of `operator<`.
+    template<typename C, typename LessThan>
+    bool c_prev_permutation(C& c, LessThan&& comp)
+    {
+        return std::prev_permutation(container_algorithm_internal::c_begin(c), container_algorithm_internal::c_end(c), std::forward<LessThan>(comp));
+    }
+
+    //------------------------------------------------------------------------------
+    // <numeric> algorithms
+    //------------------------------------------------------------------------------
+
+    // c_iota()
+    //
+    // Container-based version of the <algorithm> `std::iota()` function
+    // to compute successive values of `value`, as if incremented with `++value`
+    // after each element is written. and write them to the container.
+    template<typename Sequence, typename T>
+    void c_iota(Sequence& sequence, T&& value)
+    {
+        std::iota(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(value));
+    }
+    // c_accumulate()
+    //
+    // Container-based version of the <algorithm> `std::accumulate()` function
+    // to accumulate the element values of a container to `init` and return that
+    // accumulation by value.
+    //
+    // Note: Due to a language technicality this function has return type
+    // absl::decay_t<T>. As a user of this function you can casually read
+    // this as "returns T by value" and assume it does the right thing.
+    template<typename Sequence, typename T>
+    decay_t<T> c_accumulate(const Sequence& sequence, T&& init)
+    {
+        return std::accumulate(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(init));
+    }
+
+    // Overload of c_accumulate() for using a binary operations other than
+    // addition for computing the accumulation.
+    template<typename Sequence, typename T, typename BinaryOp>
+    decay_t<T> c_accumulate(const Sequence& sequence, T&& init, BinaryOp&& binary_op)
+    {
+        return std::accumulate(container_algorithm_internal::c_begin(sequence), container_algorithm_internal::c_end(sequence), std::forward<T>(init), std::forward<BinaryOp>(binary_op));
+    }
+
+    // c_inner_product()
+    //
+    // Container-based version of the <algorithm> `std::inner_product()` function
+    // to compute the cumulative inner product of container element pairs.
+    //
+    // Note: Due to a language technicality this function has return type
+    // absl::decay_t<T>. As a user of this function you can casually read
+    // this as "returns T by value" and assume it does the right thing.
+    template<typename Sequence1, typename Sequence2, typename T>
+    decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2, T&& sum)
+    {
+        return std::inner_product(container_algorithm_internal::c_begin(factors1), container_algorithm_internal::c_end(factors1), container_algorithm_internal::c_begin(factors2), std::forward<T>(sum));
+    }
+
+    // Overload of c_inner_product() for using binary operations other than
+    // `operator+` (for computing the accumulation) and `operator*` (for computing
+    // the product between the two container's element pair).
+    template<typename Sequence1, typename Sequence2, typename T, typename BinaryOp1, typename BinaryOp2>
+    decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2, T&& sum, BinaryOp1&& op1, BinaryOp2&& op2)
+    {
+        return std::inner_product(container_algorithm_internal::c_begin(factors1), container_algorithm_internal::c_end(factors1), container_algorithm_internal::c_begin(factors2), std::forward<T>(sum), std::forward<BinaryOp1>(op1), std::forward<BinaryOp2>(op2));
+    }
+
+    // c_adjacent_difference()
+    //
+    // Container-based version of the <algorithm> `std::adjacent_difference()`
+    // function to compute the difference between each element and the one preceding
+    // it and write it to an iterator.
+    template<typename InputSequence, typename OutputIt>
+    OutputIt c_adjacent_difference(const InputSequence& input, OutputIt output_first)
+    {
+        return std::adjacent_difference(container_algorithm_internal::c_begin(input), container_algorithm_internal::c_end(input), output_first);
+    }
+
+    // Overload of c_adjacent_difference() for using a binary operation other than
+    // subtraction to compute the adjacent difference.
+    template<typename InputSequence, typename OutputIt, typename BinaryOp>
+    OutputIt c_adjacent_difference(const InputSequence& input, OutputIt output_first, BinaryOp&& op)
+    {
+        return std::adjacent_difference(container_algorithm_internal::c_begin(input), container_algorithm_internal::c_end(input), output_first, std::forward<BinaryOp>(op));
+    }
+
+    // c_partial_sum()
+    //
+    // Container-based version of the <algorithm> `std::partial_sum()` function
+    // to compute the partial sum of the elements in a sequence and write them
+    // to an iterator. The partial sum is the sum of all element values so far in
+    // the sequence.
+    template<typename InputSequence, typename OutputIt>
+    OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first)
+    {
+        return std::partial_sum(container_algorithm_internal::c_begin(input), container_algorithm_internal::c_end(input), output_first);
+    }
+
+    // Overload of c_partial_sum() for using a binary operation other than addition
+    // to compute the "partial sum".
+    template<typename InputSequence, typename OutputIt, typename BinaryOp>
+    OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first, BinaryOp&& op)
+    {
+        return std::partial_sum(container_algorithm_internal::c_begin(input), container_algorithm_internal::c_end(input), output_first, std::forward<BinaryOp>(op));
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_ALGORITHM_CONTAINER_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/attributes.h b/CAPI/cpp/grpc/include/absl/base/attributes.h
index e4e7a3d..9908348 100644
--- a/CAPI/cpp/grpc/include/absl/base/attributes.h
+++ b/CAPI/cpp/grpc/include/absl/base/attributes.h
@@ -85,9 +85,9 @@
 // should be counted from two, not one."
 #if ABSL_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))
 #define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check) \
-  __attribute__((__format__(__printf__, string_index, first_to_check)))
+    __attribute__((__format__(__printf__, string_index, first_to_check)))
 #define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check) \
-  __attribute__((__format__(__scanf__, string_index, first_to_check)))
+    __attribute__((__format__(__scanf__, string_index, first_to_check)))
 #else
 #define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check)
 #define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check)
@@ -122,7 +122,7 @@
 #elif defined(__GNUC__) && !defined(__clang__) && !defined(__e2k__)
 #define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
 #define ABSL_ATTRIBUTE_NO_TAIL_CALL \
-  __attribute__((optimize("no-optimize-sibling-calls")))
+    __attribute__((optimize("no-optimize-sibling-calls")))
 #else
 #define ABSL_ATTRIBUTE_NO_TAIL_CALL
 #define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 0
@@ -136,9 +136,8 @@
 // for further information.
 // The MinGW compiler doesn't complain about the weak attribute until the link
 // step, presumably because Windows doesn't use ELF binaries.
-#if (ABSL_HAVE_ATTRIBUTE(weak) ||                                         \
-     (defined(__GNUC__) && !defined(__clang__))) &&                       \
-    (!defined(_WIN32) || (defined(__clang__) && __clang_major__ >= 9)) && \
+#if (ABSL_HAVE_ATTRIBUTE(weak) || (defined(__GNUC__) && !defined(__clang__))) && \
+    (!defined(_WIN32) || (defined(__clang__) && __clang_major__ >= 9)) &&        \
     !defined(__MINGW32__)
 #undef ABSL_ATTRIBUTE_WEAK
 #define ABSL_ATTRIBUTE_WEAK __attribute__((weak))
@@ -253,10 +252,10 @@
 // https://gcc.gnu.org/gcc-4.9/changes.html
 #if ABSL_HAVE_ATTRIBUTE(no_sanitize_undefined)
 #define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
-  __attribute__((no_sanitize_undefined))
+    __attribute__((no_sanitize_undefined))
 #elif ABSL_HAVE_ATTRIBUTE(no_sanitize)
 #define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
-  __attribute__((no_sanitize("undefined")))
+    __attribute__((no_sanitize("undefined")))
 #else
 #define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
 #endif
@@ -277,7 +276,7 @@
 // See https://clang.llvm.org/docs/SafeStack.html for details.
 #if ABSL_HAVE_ATTRIBUTE(no_sanitize)
 #define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK \
-  __attribute__((no_sanitize("safe-stack")))
+    __attribute__((no_sanitize("safe-stack")))
 #else
 #define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
 #endif
@@ -297,8 +296,7 @@
 // a prerequisite. Labeled sections are not supported on Darwin/iOS.
 #ifdef ABSL_HAVE_ATTRIBUTE_SECTION
 #error ABSL_HAVE_ATTRIBUTE_SECTION cannot be directly set
-#elif (ABSL_HAVE_ATTRIBUTE(section) ||                \
-       (defined(__GNUC__) && !defined(__clang__))) && \
+#elif (ABSL_HAVE_ATTRIBUTE(section) || (defined(__GNUC__) && !defined(__clang__))) && \
     !defined(__APPLE__) && ABSL_HAVE_ATTRIBUTE_WEAK
 #define ABSL_HAVE_ATTRIBUTE_SECTION 1
 
@@ -312,7 +310,7 @@
 //
 #ifndef ABSL_ATTRIBUTE_SECTION
 #define ABSL_ATTRIBUTE_SECTION(name) \
-  __attribute__((section(#name))) __attribute__((noinline))
+    __attribute__((section(#name))) __attribute__((noinline))
 #endif
 
 // ABSL_ATTRIBUTE_SECTION_VARIABLE
@@ -341,9 +339,9 @@
 // a no-op on ELF but not on Mach-O.
 //
 #ifndef ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
-#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)   \
-  extern char __start_##name[] ABSL_ATTRIBUTE_WEAK; \
-  extern char __stop_##name[] ABSL_ATTRIBUTE_WEAK
+#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)     \
+    extern char __start_##name[] ABSL_ATTRIBUTE_WEAK; \
+    extern char __stop_##name[] ABSL_ATTRIBUTE_WEAK
 #endif
 #ifndef ABSL_DEFINE_ATTRIBUTE_SECTION_VARS
 #define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
@@ -359,9 +357,9 @@
 // link.
 //
 #define ABSL_ATTRIBUTE_SECTION_START(name) \
-  (reinterpret_cast<void *>(__start_##name))
+    (reinterpret_cast<void*>(__start_##name))
 #define ABSL_ATTRIBUTE_SECTION_STOP(name) \
-  (reinterpret_cast<void *>(__stop_##name))
+    (reinterpret_cast<void*>(__stop_##name))
 
 #else  // !ABSL_HAVE_ATTRIBUTE_SECTION
 
@@ -373,8 +371,8 @@
 #define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
 #define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
 #define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void *>(0))
-#define ABSL_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void *>(0))
+#define ABSL_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void*>(0))
+#define ABSL_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void*>(0))
 
 #endif  // ABSL_ATTRIBUTE_SECTION
 
@@ -385,7 +383,7 @@
     (defined(__GNUC__) && !defined(__clang__))
 #if defined(__i386__)
 #define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC \
-  __attribute__((force_align_arg_pointer))
+    __attribute__((force_align_arg_pointer))
 #define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
 #elif defined(__x86_64__)
 #define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)
@@ -505,7 +503,7 @@
 #define ABSL_XRAY_NEVER_INSTRUMENT [[clang::xray_never_instrument]]
 #if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_log_args)
 #define ABSL_XRAY_LOG_ARGS(N) \
-  [[clang::xray_always_instrument, clang::xray_log_args(N)]]
+    [[clang::xray_always_instrument, clang::xray_log_args(N)]]
 #else
 #define ABSL_XRAY_LOG_ARGS(N) [[clang::xray_always_instrument]]
 #endif
@@ -639,8 +637,9 @@
 #define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
 #else
 #define ABSL_FALLTHROUGH_INTENDED \
-  do {                            \
-  } while (0)
+    do                            \
+    {                             \
+    } while (0)
 #endif
 
 // ABSL_DEPRECATED()
diff --git a/CAPI/cpp/grpc/include/absl/base/call_once.h b/CAPI/cpp/grpc/include/absl/base/call_once.h
index 96109f5..e520b89 100644
--- a/CAPI/cpp/grpc/include/absl/base/call_once.h
+++ b/CAPI/cpp/grpc/include/absl/base/call_once.h
@@ -40,180 +40,195 @@
 #include "absl/base/optimization.h"
 #include "absl/base/port.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class once_flag;
-
-namespace base_internal {
-std::atomic<uint32_t>* ControlWord(absl::once_flag* flag);
-}  // namespace base_internal
-
-// call_once()
-//
-// For all invocations using a given `once_flag`, invokes a given `fn` exactly
-// once across all threads. The first call to `call_once()` with a particular
-// `once_flag` argument (that does not throw an exception) will run the
-// specified function with the provided `args`; other calls with the same
-// `once_flag` argument will not run the function, but will wait
-// for the provided function to finish running (if it is still running).
-//
-// This mechanism provides a safe, simple, and fast mechanism for one-time
-// initialization in a multi-threaded process.
-//
-// Example:
-//
-// class MyInitClass {
-//  public:
-//  ...
-//  mutable absl::once_flag once_;
-//
-//  MyInitClass* init() const {
-//    absl::call_once(once_, &MyInitClass::Init, this);
-//    return ptr_;
-//  }
-//
-template <typename Callable, typename... Args>
-void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args);
-
-// once_flag
-//
-// Objects of this type are used to distinguish calls to `call_once()` and
-// ensure the provided function is only invoked once across all threads. This
-// type is not copyable or movable. However, it has a `constexpr`
-// constructor, and is safe to use as a namespace-scoped global variable.
-class once_flag {
- public:
-  constexpr once_flag() : control_(0) {}
-  once_flag(const once_flag&) = delete;
-  once_flag& operator=(const once_flag&) = delete;
-
- private:
-  friend std::atomic<uint32_t>* base_internal::ControlWord(once_flag* flag);
-  std::atomic<uint32_t> control_;
-};
-
-//------------------------------------------------------------------------------
-// End of public interfaces.
-// Implementation details follow.
-//------------------------------------------------------------------------------
-
-namespace base_internal {
-
-// Like call_once, but uses KERNEL_ONLY scheduling. Intended to be used to
-// initialize entities used by the scheduler implementation.
-template <typename Callable, typename... Args>
-void LowLevelCallOnce(absl::once_flag* flag, Callable&& fn, Args&&... args);
-
-// Disables scheduling while on stack when scheduling mode is non-cooperative.
-// No effect for cooperative scheduling modes.
-class SchedulingHelper {
- public:
-  explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
-    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
-      guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
-    }
-  }
-
-  ~SchedulingHelper() {
-    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
-      base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
-    }
-  }
-
- private:
-  base_internal::SchedulingMode mode_;
-  bool guard_result_;
-};
-
-// Bit patterns for call_once state machine values.  Internal implementation
-// detail, not for use by clients.
-//
-// The bit patterns are arbitrarily chosen from unlikely values, to aid in
-// debugging.  However, kOnceInit must be 0, so that a zero-initialized
-// once_flag will be valid for immediate use.
-enum {
-  kOnceInit = 0,
-  kOnceRunning = 0x65C2937B,
-  kOnceWaiter = 0x05A308D2,
-  // A very small constant is chosen for kOnceDone so that it fit in a single
-  // compare with immediate instruction for most common ISAs.  This is verified
-  // for x86, POWER and ARM.
-  kOnceDone = 221,    // Random Number
-};
-
-template <typename Callable, typename... Args>
-ABSL_ATTRIBUTE_NOINLINE
-void CallOnceImpl(std::atomic<uint32_t>* control,
-                  base_internal::SchedulingMode scheduling_mode, Callable&& fn,
-                  Args&&... args) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class once_flag;
+
+    namespace base_internal
+    {
+        std::atomic<uint32_t>* ControlWord(absl::once_flag* flag);
+    }  // namespace base_internal
+
+    // call_once()
+    //
+    // For all invocations using a given `once_flag`, invokes a given `fn` exactly
+    // once across all threads. The first call to `call_once()` with a particular
+    // `once_flag` argument (that does not throw an exception) will run the
+    // specified function with the provided `args`; other calls with the same
+    // `once_flag` argument will not run the function, but will wait
+    // for the provided function to finish running (if it is still running).
+    //
+    // This mechanism provides a safe, simple, and fast mechanism for one-time
+    // initialization in a multi-threaded process.
+    //
+    // Example:
+    //
+    // class MyInitClass {
+    //  public:
+    //  ...
+    //  mutable absl::once_flag once_;
+    //
+    //  MyInitClass* init() const {
+    //    absl::call_once(once_, &MyInitClass::Init, this);
+    //    return ptr_;
+    //  }
+    //
+    template<typename Callable, typename... Args>
+    void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args);
+
+    // once_flag
+    //
+    // Objects of this type are used to distinguish calls to `call_once()` and
+    // ensure the provided function is only invoked once across all threads. This
+    // type is not copyable or movable. However, it has a `constexpr`
+    // constructor, and is safe to use as a namespace-scoped global variable.
+    class once_flag
+    {
+    public:
+        constexpr once_flag() :
+            control_(0)
+        {
+        }
+        once_flag(const once_flag&) = delete;
+        once_flag& operator=(const once_flag&) = delete;
+
+    private:
+        friend std::atomic<uint32_t>* base_internal::ControlWord(once_flag* flag);
+        std::atomic<uint32_t> control_;
+    };
+
+    //------------------------------------------------------------------------------
+    // End of public interfaces.
+    // Implementation details follow.
+    //------------------------------------------------------------------------------
+
+    namespace base_internal
+    {
+
+        // Like call_once, but uses KERNEL_ONLY scheduling. Intended to be used to
+        // initialize entities used by the scheduler implementation.
+        template<typename Callable, typename... Args>
+        void LowLevelCallOnce(absl::once_flag* flag, Callable&& fn, Args&&... args);
+
+        // Disables scheduling while on stack when scheduling mode is non-cooperative.
+        // No effect for cooperative scheduling modes.
+        class SchedulingHelper
+        {
+        public:
+            explicit SchedulingHelper(base_internal::SchedulingMode mode) :
+                mode_(mode)
+            {
+                if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY)
+                {
+                    guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
+                }
+            }
+
+            ~SchedulingHelper()
+            {
+                if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY)
+                {
+                    base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
+                }
+            }
+
+        private:
+            base_internal::SchedulingMode mode_;
+            bool guard_result_;
+        };
+
+        // Bit patterns for call_once state machine values.  Internal implementation
+        // detail, not for use by clients.
+        //
+        // The bit patterns are arbitrarily chosen from unlikely values, to aid in
+        // debugging.  However, kOnceInit must be 0, so that a zero-initialized
+        // once_flag will be valid for immediate use.
+        enum
+        {
+            kOnceInit = 0,
+            kOnceRunning = 0x65C2937B,
+            kOnceWaiter = 0x05A308D2,
+            // A very small constant is chosen for kOnceDone so that it fit in a single
+            // compare with immediate instruction for most common ISAs.  This is verified
+            // for x86, POWER and ARM.
+            kOnceDone = 221,  // Random Number
+        };
+
+        template<typename Callable, typename... Args>
+        ABSL_ATTRIBUTE_NOINLINE void CallOnceImpl(std::atomic<uint32_t>* control, base_internal::SchedulingMode scheduling_mode, Callable&& fn, Args&&... args)
+        {
 #ifndef NDEBUG
-  {
-    uint32_t old_control = control->load(std::memory_order_relaxed);
-    if (old_control != kOnceInit &&
-        old_control != kOnceRunning &&
-        old_control != kOnceWaiter &&
-        old_control != kOnceDone) {
-      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
-                   static_cast<unsigned long>(old_control));  // NOLINT
-    }
-  }
+            {
+                uint32_t old_control = control->load(std::memory_order_relaxed);
+                if (old_control != kOnceInit &&
+                    old_control != kOnceRunning &&
+                    old_control != kOnceWaiter &&
+                    old_control != kOnceDone)
+                {
+                    ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
+                                 static_cast<unsigned long>(old_control));  // NOLINT
+                }
+            }
 #endif  // NDEBUG
-  static const base_internal::SpinLockWaitTransition trans[] = {
-      {kOnceInit, kOnceRunning, true},
-      {kOnceRunning, kOnceWaiter, false},
-      {kOnceDone, kOnceDone, true}};
-
-  // Must do this before potentially modifying control word's state.
-  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
-  // Short circuit the simplest case to avoid procedure call overhead.
-  // The base_internal::SpinLockWait() call returns either kOnceInit or
-  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
-  // with std::memory_order_acquire and seen a value of kOnceDone.
-  uint32_t old_control = kOnceInit;
-  if (control->compare_exchange_strong(old_control, kOnceRunning,
-                                       std::memory_order_relaxed) ||
-      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
-                                  scheduling_mode) == kOnceInit) {
-    base_internal::invoke(std::forward<Callable>(fn),
-                          std::forward<Args>(args)...);
-    old_control =
-        control->exchange(base_internal::kOnceDone, std::memory_order_release);
-    if (old_control == base_internal::kOnceWaiter) {
-      base_internal::SpinLockWake(control, true);
+            static const base_internal::SpinLockWaitTransition trans[] = {
+                {kOnceInit, kOnceRunning, true},
+                {kOnceRunning, kOnceWaiter, false},
+                {kOnceDone, kOnceDone, true}};
+
+            // Must do this before potentially modifying control word's state.
+            base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
+            // Short circuit the simplest case to avoid procedure call overhead.
+            // The base_internal::SpinLockWait() call returns either kOnceInit or
+            // kOnceDone. If it returns kOnceDone, it must have loaded the control word
+            // with std::memory_order_acquire and seen a value of kOnceDone.
+            uint32_t old_control = kOnceInit;
+            if (control->compare_exchange_strong(old_control, kOnceRunning, std::memory_order_relaxed) ||
+                base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans, scheduling_mode) == kOnceInit)
+            {
+                base_internal::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
+                old_control =
+                    control->exchange(base_internal::kOnceDone, std::memory_order_release);
+                if (old_control == base_internal::kOnceWaiter)
+                {
+                    base_internal::SpinLockWake(control, true);
+                }
+            }  // else *control is already kOnceDone
+        }
+
+        inline std::atomic<uint32_t>* ControlWord(once_flag* flag)
+        {
+            return &flag->control_;
+        }
+
+        template<typename Callable, typename... Args>
+        void LowLevelCallOnce(absl::once_flag* flag, Callable&& fn, Args&&... args)
+        {
+            std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
+            uint32_t s = once->load(std::memory_order_acquire);
+            if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone))
+            {
+                base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY, std::forward<Callable>(fn), std::forward<Args>(args)...);
+            }
+        }
+
+    }  // namespace base_internal
+
+    template<typename Callable, typename... Args>
+    void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args)
+    {
+        std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
+        uint32_t s = once->load(std::memory_order_acquire);
+        if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone))
+        {
+            base_internal::CallOnceImpl(
+                once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL, std::forward<Callable>(fn), std::forward<Args>(args)...
+            );
+        }
     }
-  }  // else *control is already kOnceDone
-}
-
-inline std::atomic<uint32_t>* ControlWord(once_flag* flag) {
-  return &flag->control_;
-}
-
-template <typename Callable, typename... Args>
-void LowLevelCallOnce(absl::once_flag* flag, Callable&& fn, Args&&... args) {
-  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
-  uint32_t s = once->load(std::memory_order_acquire);
-  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
-    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
-                                std::forward<Callable>(fn),
-                                std::forward<Args>(args)...);
-  }
-}
-
-}  // namespace base_internal
-
-template <typename Callable, typename... Args>
-void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
-  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
-  uint32_t s = once->load(std::memory_order_acquire);
-  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
-    base_internal::CallOnceImpl(
-        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
-        std::forward<Callable>(fn), std::forward<Args>(args)...);
-  }
-}
-
-ABSL_NAMESPACE_END
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_CALL_ONCE_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/casts.h b/CAPI/cpp/grpc/include/absl/base/casts.h
index b99adb0..2ebd9e4 100644
--- a/CAPI/cpp/grpc/include/absl/base/casts.h
+++ b/CAPI/cpp/grpc/include/absl/base/casts.h
@@ -31,68 +31,70 @@
 
 #if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
 #include <bit>  // For std::bit_cast.
-#endif  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+#endif          // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
 
 #include "absl/base/internal/identity.h"
 #include "absl/base/macros.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// implicit_cast()
-//
-// Performs an implicit conversion between types following the language
-// rules for implicit conversion; if an implicit conversion is otherwise
-// allowed by the language in the given context, this function performs such an
-// implicit conversion.
-//
-// Example:
-//
-//   // If the context allows implicit conversion:
-//   From from;
-//   To to = from;
-//
-//   // Such code can be replaced by:
-//   implicit_cast<To>(from);
-//
-// An `implicit_cast()` may also be used to annotate numeric type conversions
-// that, although safe, may produce compiler warnings (such as `long` to `int`).
-// Additionally, an `implicit_cast()` is also useful within return statements to
-// indicate a specific implicit conversion is being undertaken.
-//
-// Example:
-//
-//   return implicit_cast<double>(size_in_bytes) / capacity_;
-//
-// Annotating code with `implicit_cast()` allows you to explicitly select
-// particular overloads and template instantiations, while providing a safer
-// cast than `reinterpret_cast()` or `static_cast()`.
-//
-// Additionally, an `implicit_cast()` can be used to allow upcasting within a
-// type hierarchy where incorrect use of `static_cast()` could accidentally
-// allow downcasting.
-//
-// Finally, an `implicit_cast()` can be used to perform implicit conversions
-// from unrelated types that otherwise couldn't be implicitly cast directly;
-// C++ will normally only implicitly cast "one step" in such conversions.
-//
-// That is, if C is a type which can be implicitly converted to B, with B being
-// a type that can be implicitly converted to A, an `implicit_cast()` can be
-// used to convert C to B (which the compiler can then implicitly convert to A
-// using language rules).
-//
-// Example:
-//
-//   // Assume an object C is convertible to B, which is implicitly convertible
-//   // to A
-//   A a = implicit_cast<B>(C);
-//
-// Such implicit cast chaining may be useful within template logic.
-template <typename To>
-constexpr To implicit_cast(typename absl::internal::identity_t<To> to) {
-  return to;
-}
+    // implicit_cast()
+    //
+    // Performs an implicit conversion between types following the language
+    // rules for implicit conversion; if an implicit conversion is otherwise
+    // allowed by the language in the given context, this function performs such an
+    // implicit conversion.
+    //
+    // Example:
+    //
+    //   // If the context allows implicit conversion:
+    //   From from;
+    //   To to = from;
+    //
+    //   // Such code can be replaced by:
+    //   implicit_cast<To>(from);
+    //
+    // An `implicit_cast()` may also be used to annotate numeric type conversions
+    // that, although safe, may produce compiler warnings (such as `long` to `int`).
+    // Additionally, an `implicit_cast()` is also useful within return statements to
+    // indicate a specific implicit conversion is being undertaken.
+    //
+    // Example:
+    //
+    //   return implicit_cast<double>(size_in_bytes) / capacity_;
+    //
+    // Annotating code with `implicit_cast()` allows you to explicitly select
+    // particular overloads and template instantiations, while providing a safer
+    // cast than `reinterpret_cast()` or `static_cast()`.
+    //
+    // Additionally, an `implicit_cast()` can be used to allow upcasting within a
+    // type hierarchy where incorrect use of `static_cast()` could accidentally
+    // allow downcasting.
+    //
+    // Finally, an `implicit_cast()` can be used to perform implicit conversions
+    // from unrelated types that otherwise couldn't be implicitly cast directly;
+    // C++ will normally only implicitly cast "one step" in such conversions.
+    //
+    // That is, if C is a type which can be implicitly converted to B, with B being
+    // a type that can be implicitly converted to A, an `implicit_cast()` can be
+    // used to convert C to B (which the compiler can then implicitly convert to A
+    // using language rules).
+    //
+    // Example:
+    //
+    //   // Assume an object C is convertible to B, which is implicitly convertible
+    //   // to A
+    //   A a = implicit_cast<B>(C);
+    //
+    // Such implicit cast chaining may be useful within template logic.
+    template<typename To>
+    constexpr To implicit_cast(typename absl::internal::identity_t<To> to)
+    {
+        return to;
+    }
 
 // bit_cast()
 //
@@ -145,36 +147,33 @@ constexpr To implicit_cast(typename absl::internal::identity_t<To> to) {
 // `std::bit_cast`.
 #if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
 
-using std::bit_cast;
+    using std::bit_cast;
 
 #else  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
 
-template <typename Dest, typename Source,
-          typename std::enable_if<
-              sizeof(Dest) == sizeof(Source) &&
-                  type_traits_internal::is_trivially_copyable<Source>::value &&
-                  type_traits_internal::is_trivially_copyable<Dest>::value
+    template<typename Dest, typename Source, typename std::enable_if<sizeof(Dest) == sizeof(Source) && type_traits_internal::is_trivially_copyable<Source>::value && type_traits_internal::is_trivially_copyable<Dest>::value
 #if !ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-                  && std::is_default_constructible<Dest>::value
+                                                                         && std::is_default_constructible<Dest>::value
 #endif  // !ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-              ,
-              int>::type = 0>
+                                                                     ,
+                                                                     int>::type = 0>
 #if ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-inline constexpr Dest bit_cast(const Source& source) {
-  return __builtin_bit_cast(Dest, source);
-}
-#else  // ABSL_HAVE_BUILTIN(__builtin_bit_cast)
-inline Dest bit_cast(const Source& source) {
-  Dest dest;
-  memcpy(static_cast<void*>(std::addressof(dest)),
-         static_cast<const void*>(std::addressof(source)), sizeof(dest));
-  return dest;
-}
+    inline constexpr Dest bit_cast(const Source& source)
+    {
+        return __builtin_bit_cast(Dest, source);
+    }
+#else   // ABSL_HAVE_BUILTIN(__builtin_bit_cast)
+    inline Dest bit_cast(const Source& source)
+    {
+        Dest dest;
+        memcpy(static_cast<void*>(std::addressof(dest)), static_cast<const void*>(std::addressof(source)), sizeof(dest));
+        return dest;
+    }
 #endif  // ABSL_HAVE_BUILTIN(__builtin_bit_cast)
 
 #endif  // defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_CASTS_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/config.h b/CAPI/cpp/grpc/include/absl/base/config.h
index 705ecea..3c5dab8 100644
--- a/CAPI/cpp/grpc/include/absl/base/config.h
+++ b/CAPI/cpp/grpc/include/absl/base/config.h
@@ -151,18 +151,12 @@
 #if defined(__cplusplus) && ABSL_OPTION_USE_INLINE_NAMESPACE == 1
 
 #define ABSL_INTERNAL_INLINE_NAMESPACE_STR \
-  ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME)
+    ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME)
 
-static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != '\0',
-              "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
-              "not be empty.");
-static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[1] != 'e' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[2] != 'a' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[3] != 'd' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[4] != '\0',
-              "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
-              "be changed to a new, unique identifier name.");
+static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != '\0', "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
+                                                             "not be empty.");
+static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' || ABSL_INTERNAL_INLINE_NAMESPACE_STR[1] != 'e' || ABSL_INTERNAL_INLINE_NAMESPACE_STR[2] != 'a' || ABSL_INTERNAL_INLINE_NAMESPACE_STR[3] != 'd' || ABSL_INTERNAL_INLINE_NAMESPACE_STR[4] != '\0', "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
+                                                                                                                                                                                                                                                             "be changed to a new, unique identifier name.");
 
 #endif
 
@@ -171,14 +165,15 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_NAMESPACE_END
 #define ABSL_INTERNAL_C_SYMBOL(x) x
 #elif ABSL_OPTION_USE_INLINE_NAMESPACE == 1
-#define ABSL_NAMESPACE_BEGIN \
-  inline namespace ABSL_OPTION_INLINE_NAMESPACE_NAME {
+#define ABSL_NAMESPACE_BEGIN                           \
+    inline namespace ABSL_OPTION_INLINE_NAMESPACE_NAME \
+    {
 #define ABSL_NAMESPACE_END }
 #define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
 #define ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, v) \
-  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
+    ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
 #define ABSL_INTERNAL_C_SYMBOL(x) \
-  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
+    ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
 #else
 #error options.h is misconfigured.
 #endif
@@ -212,14 +207,14 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
 #if defined(__GNUC__) && defined(__GNUC_MINOR__)
 #define ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) \
-  (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
+    (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
 #else
 #define ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) 0
 #endif
 
 #if defined(__clang__) && defined(__clang_major__) && defined(__clang_minor__)
 #define ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) \
-  (__clang_major__ > (x) || __clang_major__ == (x) && __clang_minor__ >= (y))
+    (__clang_major__ > (x) || __clang_major__ == (x) && __clang_minor__ >= (y))
 #else
 #define ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) 0
 #endif
@@ -336,8 +331,8 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #ifdef ABSL_HAVE_INTRINSIC_INT128
 #error ABSL_HAVE_INTRINSIC_INT128 cannot be directly set
 #elif defined(__SIZEOF_INT128__)
-#if (defined(__clang__) && !defined(_WIN32)) || \
-    (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) ||                \
+#if (defined(__clang__) && !defined(_WIN32)) ||           \
+    (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) || \
     (defined(__GNUC__) && !defined(__clang__) && !defined(__CUDACC__))
 #define ABSL_HAVE_INTRINSIC_INT128 1
 #elif defined(__CUDACC__)
@@ -511,8 +506,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #error "ABSL_IS_LITTLE_ENDIAN cannot be directly set."
 #endif
 
-#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
-     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
 #define ABSL_IS_LITTLE_ENDIAN 1
 #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
     __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
@@ -721,8 +715,9 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_INTERNAL_MANGLED_NS "absl"
 #define ABSL_INTERNAL_MANGLED_BACKREFERENCE "5"
 #else
-#define ABSL_INTERNAL_MANGLED_NS \
-  ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME) "@absl"
+#define ABSL_INTERNAL_MANGLED_NS                               \
+    ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME) \
+    "@absl"
 #define ABSL_INTERNAL_MANGLED_BACKREFERENCE "6"
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/absl/base/const_init.h b/CAPI/cpp/grpc/include/absl/base/const_init.h
index 16520b6..4a0ef13 100644
--- a/CAPI/cpp/grpc/include/absl/base/const_init.h
+++ b/CAPI/cpp/grpc/include/absl/base/const_init.h
@@ -63,14 +63,16 @@
 // The absl::kConstInit tag should only be used to define objects with static
 // or thread_local storage duration.
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-enum ConstInitType {
-  kConstInit,
-};
+    enum ConstInitType
+    {
+        kConstInit,
+    };
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_CONST_INIT_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/dynamic_annotations.h b/CAPI/cpp/grpc/include/absl/base/dynamic_annotations.h
index 3ea7c15..82db73b 100644
--- a/CAPI/cpp/grpc/include/absl/base/dynamic_annotations.h
+++ b/CAPI/cpp/grpc/include/absl/base/dynamic_annotations.h
@@ -90,12 +90,14 @@
 
 // Read/write annotations are enabled in Annotalysis mode; disabled otherwise.
 #define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \
-  ABSL_INTERNAL_ANNOTALYSIS_ENABLED
+    ABSL_INTERNAL_ANNOTALYSIS_ENABLED
 
 #endif  // ABSL_HAVE_THREAD_SANITIZER
 
 #ifdef __cplusplus
-#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
+#define ABSL_INTERNAL_BEGIN_EXTERN_C \
+    extern "C"                       \
+    {
 #define ABSL_INTERNAL_END_EXTERN_C }  // extern "C"
 #define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
 #define ABSL_INTERNAL_STATIC_INLINE inline
@@ -123,29 +125,30 @@
 // "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the
 // point where `pointer` has been allocated, preferably close to the point
 // where the race happens. See also ABSL_ANNOTATE_BENIGN_RACE_STATIC.
-#define ABSL_ANNOTATE_BENIGN_RACE(pointer, description) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)  \
-  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
+#define ABSL_ANNOTATE_BENIGN_RACE(pointer, description)  \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized) \
+    (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
 
 // Same as ABSL_ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
 // the memory range [`address`, `address`+`size`).
 #define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)              \
-  (__FILE__, __LINE__, address, size, description)
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)            \
+    (__FILE__, __LINE__, address, size, description)
 
 // Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads.
 // This annotation could be useful if you want to skip expensive race analysis
 // during some period of program execution, e.g. during initialization.
-#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)        \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
-  (__FILE__, __LINE__, enable)
+#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)          \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
+    (__FILE__, __LINE__, enable)
 
 // -------------------------------------------------------------
 // Annotations useful for debugging.
 
 // Report the current thread `name` to a race detector.
-#define ABSL_ANNOTATE_THREAD_NAME(name) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
+#define ABSL_ANNOTATE_THREAD_NAME(name)             \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName) \
+    (__FILE__, __LINE__, name)
 
 // -------------------------------------------------------------
 // Annotations useful when implementing locks. They are not normally needed by
@@ -153,66 +156,62 @@
 // object.
 
 // Report that a lock has been created at address `lock`.
-#define ABSL_ANNOTATE_RWLOCK_CREATE(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
+#define ABSL_ANNOTATE_RWLOCK_CREATE(lock)             \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate) \
+    (__FILE__, __LINE__, lock)
 
 // Report that a linker initialized lock has been created at address `lock`.
 #ifdef ABSL_HAVE_THREAD_SANITIZER
-#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
-  (__FILE__, __LINE__, lock)
+#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)            \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
+    (__FILE__, __LINE__, lock)
 #else
 #define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock) \
-  ABSL_ANNOTATE_RWLOCK_CREATE(lock)
+    ABSL_ANNOTATE_RWLOCK_CREATE(lock)
 #endif
 
 // Report that the lock at address `lock` is about to be destroyed.
-#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
+#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock)             \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy) \
+    (__FILE__, __LINE__, lock)
 
 // Report that the lock at address `lock` has been acquired.
 // `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \
-  (__FILE__, __LINE__, lock, is_w)
+#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)       \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \
+    (__FILE__, __LINE__, lock, is_w)
 
 // Report that the lock at address `lock` is about to be released.
 // `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
-  (__FILE__, __LINE__, lock, is_w)
+#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)       \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
+    (__FILE__, __LINE__, lock, is_w)
 
 // Apply ABSL_ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
-#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)      \
-  namespace {                                                          \
-  class static_var##_annotator {                                       \
-   public:                                                             \
-    static_var##_annotator() {                                         \
-      ABSL_ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \
-                                      #static_var ": " description);   \
-    }                                                                  \
-  };                                                                   \
-  static static_var##_annotator the##static_var##_annotator;           \
-  }  // namespace
+#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)                                               \
+    namespace                                                                                                   \
+    {                                                                                                           \
+        class static_var##_annotator                                                                            \
+        {                                                                                                       \
+        public:                                                                                                 \
+            static_var##_annotator()                                                                            \
+            {                                                                                                   \
+                ABSL_ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), #static_var ": " description); \
+            }                                                                                                   \
+        };                                                                                                      \
+        static static_var##_annotator the##static_var##_annotator;                                              \
+    }  // namespace
 
 // Function prototypes of annotations provided by the compiler-based sanitizer
 // implementation.
 ABSL_INTERNAL_BEGIN_EXTERN_C
-void AnnotateRWLockCreate(const char* file, int line,
-                          const volatile void* lock);
-void AnnotateRWLockCreateStatic(const char* file, int line,
-                                const volatile void* lock);
-void AnnotateRWLockDestroy(const char* file, int line,
-                           const volatile void* lock);
-void AnnotateRWLockAcquired(const char* file, int line,
-                            const volatile void* lock, long is_w);  // NOLINT
-void AnnotateRWLockReleased(const char* file, int line,
-                            const volatile void* lock, long is_w);  // NOLINT
-void AnnotateBenignRace(const char* file, int line,
-                        const volatile void* address, const char* description);
-void AnnotateBenignRaceSized(const char* file, int line,
-                             const volatile void* address, size_t size,
-                             const char* description);
+void AnnotateRWLockCreate(const char* file, int line, const volatile void* lock);
+void AnnotateRWLockCreateStatic(const char* file, int line, const volatile void* lock);
+void AnnotateRWLockDestroy(const char* file, int line, const volatile void* lock);
+void AnnotateRWLockAcquired(const char* file, int line, const volatile void* lock, long is_w);  // NOLINT
+void AnnotateRWLockReleased(const char* file, int line, const volatile void* lock, long is_w);  // NOLINT
+void AnnotateBenignRace(const char* file, int line, const volatile void* address, const char* description);
+void AnnotateBenignRaceSized(const char* file, int line, const volatile void* address, size_t size, const char* description);
 void AnnotateThreadName(const char* file, int line, const char* name);
 void AnnotateEnableRaceDetection(const char* file, int line, int enable);
 ABSL_INTERNAL_END_EXTERN_C
@@ -240,25 +239,27 @@ ABSL_INTERNAL_END_EXTERN_C
 #include <sanitizer/msan_interface.h>
 
 #define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-  __msan_unpoison(address, size)
+    __msan_unpoison(address, size)
 
 #define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
-  __msan_allocated_memory(address, size)
+    __msan_allocated_memory(address, size)
 
 #else  // !defined(ABSL_HAVE_MEMORY_SANITIZER)
 
 // TODO(rogeeff): remove this branch
 #ifdef ABSL_HAVE_THREAD_SANITIZER
 #define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-  do {                                                     \
-    (void)(address);                                       \
-    (void)(size);                                          \
-  } while (0)
+    do                                                     \
+    {                                                      \
+        (void)(address);                                   \
+        (void)(size);                                      \
+    } while (0)
 #define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
-  do {                                                       \
-    (void)(address);                                         \
-    (void)(size);                                            \
-  } while (0)
+    do                                                       \
+    {                                                        \
+        (void)(address);                                     \
+        (void)(size);                                        \
+    } while (0)
 #else
 
 #define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty
@@ -274,9 +275,9 @@ ABSL_INTERNAL_END_EXTERN_C
 #if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
 #define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
-  __attribute((exclusive_lock_function("*")))
+    __attribute((exclusive_lock_function("*")))
 #define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
-  __attribute((unlock_function("*")))
+    __attribute((unlock_function("*")))
 
 #else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
@@ -297,22 +298,21 @@ ABSL_INTERNAL_END_EXTERN_C
 // ABSL_ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey
 // reads, while still checking other reads and all writes.
 // See also ABSL_ANNOTATE_UNPROTECTED_READ.
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()              \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin) \
-  (__FILE__, __LINE__)
+#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin) \
+    (__FILE__, __LINE__)
 
 // Stop ignoring reads.
-#define ABSL_ANNOTATE_IGNORE_READS_END()              \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \
-  (__FILE__, __LINE__)
+#define ABSL_ANNOTATE_IGNORE_READS_END()                \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \
+    (__FILE__, __LINE__)
 
 // Function prototypes of annotations provided by the compiler-based sanitizer
 // implementation.
 ABSL_INTERNAL_BEGIN_EXTERN_C
 void AnnotateIgnoreReadsBegin(const char* file, int line)
     ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE;
-void AnnotateIgnoreReadsEnd(const char* file,
-                            int line) ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE;
+void AnnotateIgnoreReadsEnd(const char* file, int line) ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE;
 ABSL_INTERNAL_END_EXTERN_C
 
 #elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
@@ -324,23 +324,31 @@ ABSL_INTERNAL_END_EXTERN_C
 // TODO(delesley) -- The exclusive lock here ignores writes as well, but
 // allows IGNORE_READS_AND_WRITES to work properly.
 
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
-  ()
+#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                           \
+    ABSL_INTERNAL_GLOBAL_SCOPED(                                     \
+        ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin) \
+    )                                                                \
+    ()
 
-#define ABSL_ANNOTATE_IGNORE_READS_END()                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
-  ()
+#define ABSL_ANNOTATE_IGNORE_READS_END()                           \
+    ABSL_INTERNAL_GLOBAL_SCOPED(                                   \
+        ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd) \
+    )                                                              \
+    ()
 
 ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
-    AbslInternalAnnotateIgnoreReadsBegin)()
-    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE {}
+    AbslInternalAnnotateIgnoreReadsBegin
+)()
+    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE
+{
+}
 
 ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
-    AbslInternalAnnotateIgnoreReadsEnd)()
-    ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE {}
+    AbslInternalAnnotateIgnoreReadsEnd
+)()
+    ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE
+{
+}
 
 #else
 
@@ -355,12 +363,14 @@ ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
 #if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
 
 // Similar to ABSL_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
-#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
+#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN()                \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin) \
+    (__FILE__, __LINE__)
 
 // Stop ignoring writes.
-#define ABSL_ANNOTATE_IGNORE_WRITES_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
+#define ABSL_ANNOTATE_IGNORE_WRITES_END()                \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd) \
+    (__FILE__, __LINE__)
 
 // Function prototypes of annotations provided by the compiler-based sanitizer
 // implementation.
@@ -391,37 +401,42 @@ ABSL_INTERNAL_END_EXTERN_C
 
 // Start ignoring all memory accesses (both reads and writes).
 #define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
-  do {                                                \
-    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
-    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
-  } while (0)
+    do                                                \
+    {                                                 \
+        ABSL_ANNOTATE_IGNORE_READS_BEGIN();           \
+        ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();          \
+    } while (0)
 
 // Stop ignoring both reads and writes.
 #define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END() \
-  do {                                              \
-    ABSL_ANNOTATE_IGNORE_WRITES_END();              \
-    ABSL_ANNOTATE_IGNORE_READS_END();               \
-  } while (0)
+    do                                              \
+    {                                               \
+        ABSL_ANNOTATE_IGNORE_WRITES_END();          \
+        ABSL_ANNOTATE_IGNORE_READS_END();           \
+    } while (0)
 
 #ifdef __cplusplus
 // ABSL_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
 #define ABSL_ANNOTATE_UNPROTECTED_READ(x) \
-  absl::base_internal::AnnotateUnprotectedRead(x)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-template <typename T>
-inline T AnnotateUnprotectedRead(const volatile T& x) {  // NOLINT
-  ABSL_ANNOTATE_IGNORE_READS_BEGIN();
-  T res = x;
-  ABSL_ANNOTATE_IGNORE_READS_END();
-  return res;
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    absl::base_internal::AnnotateUnprotectedRead(x)
+
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        template<typename T>
+        inline T AnnotateUnprotectedRead(const volatile T& x)
+        {  // NOLINT
+            ABSL_ANNOTATE_IGNORE_READS_BEGIN();
+            T res = x;
+            ABSL_ANNOTATE_IGNORE_READS_END();
+            return res;
+        }
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 #endif
 
@@ -443,11 +458,12 @@ ABSL_NAMESPACE_END
 #include <sanitizer/common_interface_defs.h>
 
 #define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \
-  __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
+    __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
 #define ABSL_ADDRESS_SANITIZER_REDZONE(name) \
-  struct {                                   \
-    alignas(8) char x[8];                    \
-  } name
+    struct                                   \
+    {                                        \
+        alignas(8) char x[8];                \
+    } name
 
 #else
 
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook.h b/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook.h
index ae21cd7..8cef0e1 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook.h
@@ -35,12 +35,14 @@
 #define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-template <typename T>
-class AtomicHook;
+        template<typename T>
+        class AtomicHook;
 
 // To workaround AtomicHook not being constant-initializable on some platforms,
 // prefer to annotate instances with `ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES`
@@ -51,150 +53,173 @@ class AtomicHook;
 #define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
 #endif
 
-// `AtomicHook` is a helper class, templatized on a raw function pointer type,
-// for implementing Abseil customization hooks.  It is a callable object that
-// dispatches to the registered hook.  Objects of type `AtomicHook` must have
-// static or thread storage duration.
-//
-// A default constructed object performs a no-op (and returns a default
-// constructed object) if no hook has been registered.
-//
-// Hooks can be pre-registered via constant initialization, for example:
-//
-// ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void(*)()>
-//     my_hook(DefaultAction);
-//
-// and then changed at runtime via a call to `Store()`.
-//
-// Reads and writes guarantee memory_order_acquire/memory_order_release
-// semantics.
-template <typename ReturnType, typename... Args>
-class AtomicHook<ReturnType (*)(Args...)> {
- public:
-  using FnPtr = ReturnType (*)(Args...);
-
-  // Constructs an object that by default performs a no-op (and
-  // returns a default constructed object) when no hook as been registered.
-  constexpr AtomicHook() : AtomicHook(DummyFunction) {}
-
-  // Constructs an object that by default dispatches to/returns the
-  // pre-registered default_fn when no hook has been registered at runtime.
+        // `AtomicHook` is a helper class, templatized on a raw function pointer type,
+        // for implementing Abseil customization hooks.  It is a callable object that
+        // dispatches to the registered hook.  Objects of type `AtomicHook` must have
+        // static or thread storage duration.
+        //
+        // A default constructed object performs a no-op (and returns a default
+        // constructed object) if no hook has been registered.
+        //
+        // Hooks can be pre-registered via constant initialization, for example:
+        //
+        // ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void(*)()>
+        //     my_hook(DefaultAction);
+        //
+        // and then changed at runtime via a call to `Store()`.
+        //
+        // Reads and writes guarantee memory_order_acquire/memory_order_release
+        // semantics.
+        template<typename ReturnType, typename... Args>
+        class AtomicHook<ReturnType (*)(Args...)>
+        {
+        public:
+            using FnPtr = ReturnType (*)(Args...);
+
+            // Constructs an object that by default performs a no-op (and
+            // returns a default constructed object) when no hook as been registered.
+            constexpr AtomicHook() :
+                AtomicHook(DummyFunction)
+            {
+            }
+
+            // Constructs an object that by default dispatches to/returns the
+            // pre-registered default_fn when no hook has been registered at runtime.
 #if ABSL_HAVE_WORKING_ATOMIC_POINTER && ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
-  explicit constexpr AtomicHook(FnPtr default_fn)
-      : hook_(default_fn), default_fn_(default_fn) {}
+            explicit constexpr AtomicHook(FnPtr default_fn) :
+                hook_(default_fn),
+                default_fn_(default_fn)
+            {
+            }
 #elif ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
-  explicit constexpr AtomicHook(FnPtr default_fn)
-      : hook_(kUninitialized), default_fn_(default_fn) {}
+            explicit constexpr AtomicHook(FnPtr default_fn) :
+                hook_(kUninitialized),
+                default_fn_(default_fn)
+            {
+            }
 #else
-  // As of January 2020, on all known versions of MSVC this constructor runs in
-  // the global constructor sequence.  If `Store()` is called by a dynamic
-  // initializer, we want to preserve the value, even if this constructor runs
-  // after the call to `Store()`.  If not, `hook_` will be
-  // zero-initialized by the linker and we have no need to set it.
-  // https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html
-  explicit constexpr AtomicHook(FnPtr default_fn)
-      : /* hook_(deliberately omitted), */ default_fn_(default_fn) {
-    static_assert(kUninitialized == 0, "here we rely on zero-initialization");
-  }
+            // As of January 2020, on all known versions of MSVC this constructor runs in
+            // the global constructor sequence.  If `Store()` is called by a dynamic
+            // initializer, we want to preserve the value, even if this constructor runs
+            // after the call to `Store()`.  If not, `hook_` will be
+            // zero-initialized by the linker and we have no need to set it.
+            // https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html
+            explicit constexpr AtomicHook(FnPtr default_fn) :
+                /* hook_(deliberately omitted), */ default_fn_(default_fn)
+            {
+                static_assert(kUninitialized == 0, "here we rely on zero-initialization");
+            }
 #endif
 
-  // Stores the provided function pointer as the value for this hook.
-  //
-  // This is intended to be called once.  Multiple calls are legal only if the
-  // same function pointer is provided for each call.  The store is implemented
-  // as a memory_order_release operation, and read accesses are implemented as
-  // memory_order_acquire.
-  void Store(FnPtr fn) {
-    bool success = DoStore(fn);
-    static_cast<void>(success);
-    assert(success);
-  }
-
-  // Invokes the registered callback.  If no callback has yet been registered, a
-  // default-constructed object of the appropriate type is returned instead.
-  template <typename... CallArgs>
-  ReturnType operator()(CallArgs&&... args) const {
-    return DoLoad()(std::forward<CallArgs>(args)...);
-  }
-
-  // Returns the registered callback, or nullptr if none has been registered.
-  // Useful if client code needs to conditionalize behavior based on whether a
-  // callback was registered.
-  //
-  // Note that atomic_hook.Load()() and atomic_hook() have different semantics:
-  // operator()() will perform a no-op if no callback was registered, while
-  // Load()() will dereference a null function pointer.  Prefer operator()() to
-  // Load()() unless you must conditionalize behavior on whether a hook was
-  // registered.
-  FnPtr Load() const {
-    FnPtr ptr = DoLoad();
-    return (ptr == DummyFunction) ? nullptr : ptr;
-  }
-
- private:
-  static ReturnType DummyFunction(Args...) {
-    return ReturnType();
-  }
-
-  // Current versions of MSVC (as of September 2017) have a broken
-  // implementation of std::atomic<T*>:  Its constructor attempts to do the
-  // equivalent of a reinterpret_cast in a constexpr context, which is not
-  // allowed.
-  //
-  // This causes an issue when building with LLVM under Windows.  To avoid this,
-  // we use a less-efficient, intptr_t-based implementation on Windows.
+            // Stores the provided function pointer as the value for this hook.
+            //
+            // This is intended to be called once.  Multiple calls are legal only if the
+            // same function pointer is provided for each call.  The store is implemented
+            // as a memory_order_release operation, and read accesses are implemented as
+            // memory_order_acquire.
+            void Store(FnPtr fn)
+            {
+                bool success = DoStore(fn);
+                static_cast<void>(success);
+                assert(success);
+            }
+
+            // Invokes the registered callback.  If no callback has yet been registered, a
+            // default-constructed object of the appropriate type is returned instead.
+            template<typename... CallArgs>
+            ReturnType operator()(CallArgs&&... args) const
+            {
+                return DoLoad()(std::forward<CallArgs>(args)...);
+            }
+
+            // Returns the registered callback, or nullptr if none has been registered.
+            // Useful if client code needs to conditionalize behavior based on whether a
+            // callback was registered.
+            //
+            // Note that atomic_hook.Load()() and atomic_hook() have different semantics:
+            // operator()() will perform a no-op if no callback was registered, while
+            // Load()() will dereference a null function pointer.  Prefer operator()() to
+            // Load()() unless you must conditionalize behavior on whether a hook was
+            // registered.
+            FnPtr Load() const
+            {
+                FnPtr ptr = DoLoad();
+                return (ptr == DummyFunction) ? nullptr : ptr;
+            }
+
+        private:
+            static ReturnType DummyFunction(Args...)
+            {
+                return ReturnType();
+            }
+
+            // Current versions of MSVC (as of September 2017) have a broken
+            // implementation of std::atomic<T*>:  Its constructor attempts to do the
+            // equivalent of a reinterpret_cast in a constexpr context, which is not
+            // allowed.
+            //
+            // This causes an issue when building with LLVM under Windows.  To avoid this,
+            // we use a less-efficient, intptr_t-based implementation on Windows.
 #if ABSL_HAVE_WORKING_ATOMIC_POINTER
-  // Return the stored value, or DummyFunction if no value has been stored.
-  FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }
-
-  // Store the given value.  Returns false if a different value was already
-  // stored to this object.
-  bool DoStore(FnPtr fn) {
-    assert(fn);
-    FnPtr expected = default_fn_;
-    const bool store_succeeded = hook_.compare_exchange_strong(
-        expected, fn, std::memory_order_acq_rel, std::memory_order_acquire);
-    const bool same_value_already_stored = (expected == fn);
-    return store_succeeded || same_value_already_stored;
-  }
-
-  std::atomic<FnPtr> hook_;
+            // Return the stored value, or DummyFunction if no value has been stored.
+            FnPtr DoLoad() const
+            {
+                return hook_.load(std::memory_order_acquire);
+            }
+
+            // Store the given value.  Returns false if a different value was already
+            // stored to this object.
+            bool DoStore(FnPtr fn)
+            {
+                assert(fn);
+                FnPtr expected = default_fn_;
+                const bool store_succeeded = hook_.compare_exchange_strong(
+                    expected, fn, std::memory_order_acq_rel, std::memory_order_acquire
+                );
+                const bool same_value_already_stored = (expected == fn);
+                return store_succeeded || same_value_already_stored;
+            }
+
+            std::atomic<FnPtr> hook_;
 #else  // !ABSL_HAVE_WORKING_ATOMIC_POINTER
-  // Use a sentinel value unlikely to be the address of an actual function.
-  static constexpr intptr_t kUninitialized = 0;
-
-  static_assert(sizeof(intptr_t) >= sizeof(FnPtr),
-                "intptr_t can't contain a function pointer");
-
-  FnPtr DoLoad() const {
-    const intptr_t value = hook_.load(std::memory_order_acquire);
-    if (value == kUninitialized) {
-      return default_fn_;
-    }
-    return reinterpret_cast<FnPtr>(value);
-  }
-
-  bool DoStore(FnPtr fn) {
-    assert(fn);
-    const auto value = reinterpret_cast<intptr_t>(fn);
-    intptr_t expected = kUninitialized;
-    const bool store_succeeded = hook_.compare_exchange_strong(
-        expected, value, std::memory_order_acq_rel, std::memory_order_acquire);
-    const bool same_value_already_stored = (expected == value);
-    return store_succeeded || same_value_already_stored;
-  }
-
-  std::atomic<intptr_t> hook_;
+       // Use a sentinel value unlikely to be the address of an actual function.
+            static constexpr intptr_t kUninitialized = 0;
+
+            static_assert(sizeof(intptr_t) >= sizeof(FnPtr), "intptr_t can't contain a function pointer");
+
+            FnPtr DoLoad() const
+            {
+                const intptr_t value = hook_.load(std::memory_order_acquire);
+                if (value == kUninitialized)
+                {
+                    return default_fn_;
+                }
+                return reinterpret_cast<FnPtr>(value);
+            }
+
+            bool DoStore(FnPtr fn)
+            {
+                assert(fn);
+                const auto value = reinterpret_cast<intptr_t>(fn);
+                intptr_t expected = kUninitialized;
+                const bool store_succeeded = hook_.compare_exchange_strong(
+                    expected, value, std::memory_order_acq_rel, std::memory_order_acquire
+                );
+                const bool same_value_already_stored = (expected == value);
+                return store_succeeded || same_value_already_stored;
+            }
+
+            std::atomic<intptr_t> hook_;
 #endif
 
-  const FnPtr default_fn_;
-};
+            const FnPtr default_fn_;
+        };
 
 #undef ABSL_HAVE_WORKING_ATOMIC_POINTER
 #undef ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook_test_helper.h b/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook_test_helper.h
index 3e72b49..1df0513 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook_test_helper.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/atomic_hook_test_helper.h
@@ -17,18 +17,20 @@
 
 #include "absl/base/internal/atomic_hook.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace atomic_hook_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace atomic_hook_internal
+    {
 
-using VoidF = void (*)();
-extern absl::base_internal::AtomicHook<VoidF> func;
-extern int default_func_calls;
-void DefaultFunc();
-void RegisterFunc(VoidF func);
+        using VoidF = void (*)();
+        extern absl::base_internal::AtomicHook<VoidF> func;
+        extern int default_func_calls;
+        void DefaultFunc();
+        void RegisterFunc(VoidF func);
 
-}  // namespace atomic_hook_internal
-ABSL_NAMESPACE_END
+    }  // namespace atomic_hook_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/cycleclock.h b/CAPI/cpp/grpc/include/absl/base/internal/cycleclock.h
index 9704e38..9656963 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/cycleclock.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/cycleclock.h
@@ -49,111 +49,120 @@
 #include "absl/base/config.h"
 #include "absl/base/internal/unscaledcycleclock.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-using CycleClockSourceFunc = int64_t (*)();
-
-// -----------------------------------------------------------------------------
-// CycleClock
-// -----------------------------------------------------------------------------
-class CycleClock {
- public:
-  // CycleClock::Now()
-  //
-  // Returns the value of a cycle counter that counts at a rate that is
-  // approximately constant.
-  static int64_t Now();
-
-  // CycleClock::Frequency()
-  //
-  // Returns the amount by which `CycleClock::Now()` increases per second. Note
-  // that this value may not necessarily match the core CPU clock frequency.
-  static double Frequency();
-
- private:
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        using CycleClockSourceFunc = int64_t (*)();
+
+        // -----------------------------------------------------------------------------
+        // CycleClock
+        // -----------------------------------------------------------------------------
+        class CycleClock
+        {
+        public:
+            // CycleClock::Now()
+            //
+            // Returns the value of a cycle counter that counts at a rate that is
+            // approximately constant.
+            static int64_t Now();
+
+            // CycleClock::Frequency()
+            //
+            // Returns the amount by which `CycleClock::Now()` increases per second. Note
+            // that this value may not necessarily match the core CPU clock frequency.
+            static double Frequency();
+
+        private:
 #if ABSL_USE_UNSCALED_CYCLECLOCK
-  static CycleClockSourceFunc LoadCycleClockSource();
+            static CycleClockSourceFunc LoadCycleClockSource();
 
 #ifdef NDEBUG
 #ifdef ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
-  // Not debug mode and the UnscaledCycleClock frequency is the CPU
-  // frequency.  Scale the CycleClock to prevent overflow if someone
-  // tries to represent the time as cycles since the Unix epoch.
-  static constexpr int32_t kShift = 1;
+            // Not debug mode and the UnscaledCycleClock frequency is the CPU
+            // frequency.  Scale the CycleClock to prevent overflow if someone
+            // tries to represent the time as cycles since the Unix epoch.
+            static constexpr int32_t kShift = 1;
 #else
-  // Not debug mode and the UnscaledCycleClock isn't operating at the
-  // raw CPU frequency. There is no need to do any scaling, so don't
-  // needlessly sacrifice precision.
-  static constexpr int32_t kShift = 0;
+            // Not debug mode and the UnscaledCycleClock isn't operating at the
+            // raw CPU frequency. There is no need to do any scaling, so don't
+            // needlessly sacrifice precision.
+            static constexpr int32_t kShift = 0;
 #endif
 #else   // NDEBUG
-  // In debug mode use a different shift to discourage depending on a
-  // particular shift value.
-  static constexpr int32_t kShift = 2;
+        // In debug mode use a different shift to discourage depending on a
+        // particular shift value.
+            static constexpr int32_t kShift = 2;
 #endif  // NDEBUG
 
-  static constexpr double kFrequencyScale = 1.0 / (1 << kShift);
-  ABSL_CONST_INIT static std::atomic<CycleClockSourceFunc> cycle_clock_source_;
+            static constexpr double kFrequencyScale = 1.0 / (1 << kShift);
+            ABSL_CONST_INIT static std::atomic<CycleClockSourceFunc> cycle_clock_source_;
 #endif  //  ABSL_USE_UNSCALED_CYCLECLOC
 
-  CycleClock() = delete;  // no instances
-  CycleClock(const CycleClock&) = delete;
-  CycleClock& operator=(const CycleClock&) = delete;
-
-  friend class CycleClockSource;
-};
-
-class CycleClockSource {
- private:
-  // CycleClockSource::Register()
-  //
-  // Register a function that provides an alternate source for the unscaled CPU
-  // cycle count value. The source function must be async signal safe, must not
-  // call CycleClock::Now(), and must have a frequency that matches that of the
-  // unscaled clock used by CycleClock. A nullptr value resets CycleClock to use
-  // the default source.
-  static void Register(CycleClockSourceFunc source);
-};
+            CycleClock() = delete;  // no instances
+            CycleClock(const CycleClock&) = delete;
+            CycleClock& operator=(const CycleClock&) = delete;
+
+            friend class CycleClockSource;
+        };
+
+        class CycleClockSource
+        {
+        private:
+            // CycleClockSource::Register()
+            //
+            // Register a function that provides an alternate source for the unscaled CPU
+            // cycle count value. The source function must be async signal safe, must not
+            // call CycleClock::Now(), and must have a frequency that matches that of the
+            // unscaled clock used by CycleClock. A nullptr value resets CycleClock to use
+            // the default source.
+            static void Register(CycleClockSourceFunc source);
+        };
 
 #if ABSL_USE_UNSCALED_CYCLECLOCK
 
-inline CycleClockSourceFunc CycleClock::LoadCycleClockSource() {
+        inline CycleClockSourceFunc CycleClock::LoadCycleClockSource()
+        {
 #if !defined(__x86_64__)
-  // Optimize for the common case (no callback) by first doing a relaxed load;
-  // this is significantly faster on non-x86 platforms.
-  if (cycle_clock_source_.load(std::memory_order_relaxed) == nullptr) {
-    return nullptr;
-  }
+            // Optimize for the common case (no callback) by first doing a relaxed load;
+            // this is significantly faster on non-x86 platforms.
+            if (cycle_clock_source_.load(std::memory_order_relaxed) == nullptr)
+            {
+                return nullptr;
+            }
 #endif  // !defined(__x86_64__)
 
-  // This corresponds to the store(std::memory_order_release) in
-  // CycleClockSource::Register, and makes sure that any updates made prior to
-  // registering the callback are visible to this thread before the callback
-  // is invoked.
-  return cycle_clock_source_.load(std::memory_order_acquire);
-}
+            // This corresponds to the store(std::memory_order_release) in
+            // CycleClockSource::Register, and makes sure that any updates made prior to
+            // registering the callback are visible to this thread before the callback
+            // is invoked.
+            return cycle_clock_source_.load(std::memory_order_acquire);
+        }
 
 // Accessing globals in inlined code in Window DLLs is problematic.
 #ifndef _WIN32
-inline int64_t CycleClock::Now() {
-  auto fn = LoadCycleClockSource();
-  if (fn == nullptr) {
-    return base_internal::UnscaledCycleClock::Now() >> kShift;
-  }
-  return fn() >> kShift;
-}
+        inline int64_t CycleClock::Now()
+        {
+            auto fn = LoadCycleClockSource();
+            if (fn == nullptr)
+            {
+                return base_internal::UnscaledCycleClock::Now() >> kShift;
+            }
+            return fn() >> kShift;
+        }
 #endif
 
-inline double CycleClock::Frequency() {
-  return kFrequencyScale * base_internal::UnscaledCycleClock::Frequency();
-}
+        inline double CycleClock::Frequency()
+        {
+            return kFrequencyScale * base_internal::UnscaledCycleClock::Frequency();
+        }
 
 #endif  // ABSL_USE_UNSCALED_CYCLECLOCK
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_CYCLECLOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/direct_mmap.h b/CAPI/cpp/grpc/include/absl/base/internal/direct_mmap.h
index e492bb0..4d7476b 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/direct_mmap.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/direct_mmap.h
@@ -65,14 +65,16 @@ extern "C" void* __mmap2(void*, size_t, int, int, int, size_t);
 #define SYS_mmap2 __NR_mmap2
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Platform specific logic extracted from
-// https://chromium.googlesource.com/linux-syscall-support/+/master/linux_syscall_support.h
-inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
-                        off64_t offset) noexcept {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        // Platform specific logic extracted from
+        // https://chromium.googlesource.com/linux-syscall-support/+/master/linux_syscall_support.h
+        inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd, off64_t offset) noexcept
+        {
 #if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \
     defined(__m68k__) || defined(__sh__) ||                                  \
     (defined(__hppa__) && !defined(__LP64__)) ||                             \
@@ -81,37 +83,39 @@ inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
     (defined(__riscv) && __riscv_xlen == 32) ||                              \
     (defined(__s390__) && !defined(__s390x__)) ||                            \
     (defined(__sparc__) && !defined(__arch64__))
-  // On these architectures, implement mmap with mmap2.
-  static int pagesize = 0;
-  if (pagesize == 0) {
+            // On these architectures, implement mmap with mmap2.
+            static int pagesize = 0;
+            if (pagesize == 0)
+            {
 #if defined(__wasm__) || defined(__asmjs__)
-    pagesize = getpagesize();
+                pagesize = getpagesize();
 #else
-    pagesize = sysconf(_SC_PAGESIZE);
+                pagesize = sysconf(_SC_PAGESIZE);
 #endif
-  }
-  if (offset < 0 || offset % pagesize != 0) {
-    errno = EINVAL;
-    return MAP_FAILED;
-  }
+            }
+            if (offset < 0 || offset % pagesize != 0)
+            {
+                errno = EINVAL;
+                return MAP_FAILED;
+            }
 #ifdef __BIONIC__
-  // SYS_mmap2 has problems on Android API level <= 16.
-  // Workaround by invoking __mmap2() instead.
-  return __mmap2(start, length, prot, flags, fd, offset / pagesize);
+            // SYS_mmap2 has problems on Android API level <= 16.
+            // Workaround by invoking __mmap2() instead.
+            return __mmap2(start, length, prot, flags, fd, offset / pagesize);
 #else
-  return reinterpret_cast<void*>(
-      syscall(SYS_mmap2, start, length, prot, flags, fd,
-              static_cast<off_t>(offset / pagesize)));
+            return reinterpret_cast<void*>(
+                syscall(SYS_mmap2, start, length, prot, flags, fd, static_cast<off_t>(offset / pagesize))
+            );
 #endif
 #elif defined(__s390x__)
-  // On s390x, mmap() arguments are passed in memory.
-  unsigned long buf[6] = {reinterpret_cast<unsigned long>(start),  // NOLINT
-                          static_cast<unsigned long>(length),      // NOLINT
-                          static_cast<unsigned long>(prot),        // NOLINT
-                          static_cast<unsigned long>(flags),       // NOLINT
-                          static_cast<unsigned long>(fd),          // NOLINT
-                          static_cast<unsigned long>(offset)};     // NOLINT
-  return reinterpret_cast<void*>(syscall(SYS_mmap, buf));
+            // On s390x, mmap() arguments are passed in memory.
+            unsigned long buf[6] = {reinterpret_cast<unsigned long>(start),  // NOLINT
+                                    static_cast<unsigned long>(length),      // NOLINT
+                                    static_cast<unsigned long>(prot),        // NOLINT
+                                    static_cast<unsigned long>(flags),       // NOLINT
+                                    static_cast<unsigned long>(fd),          // NOLINT
+                                    static_cast<unsigned long>(offset)};     // NOLINT
+            return reinterpret_cast<void*>(syscall(SYS_mmap, buf));
 #elif defined(__x86_64__)
 // The x32 ABI has 32 bit longs, but the syscall interface is 64 bit.
 // We need to explicitly cast to an unsigned 64 bit type to avoid implicit
@@ -120,24 +124,25 @@ inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
 // to an integer of a different size. We also need to make sure __off64_t
 // isn't truncated to 32-bits under x32.
 #define MMAP_SYSCALL_ARG(x) ((uint64_t)(uintptr_t)(x))
-  return reinterpret_cast<void*>(
-      syscall(SYS_mmap, MMAP_SYSCALL_ARG(start), MMAP_SYSCALL_ARG(length),
-              MMAP_SYSCALL_ARG(prot), MMAP_SYSCALL_ARG(flags),
-              MMAP_SYSCALL_ARG(fd), static_cast<uint64_t>(offset)));
+            return reinterpret_cast<void*>(
+                syscall(SYS_mmap, MMAP_SYSCALL_ARG(start), MMAP_SYSCALL_ARG(length), MMAP_SYSCALL_ARG(prot), MMAP_SYSCALL_ARG(flags), MMAP_SYSCALL_ARG(fd), static_cast<uint64_t>(offset))
+            );
 #undef MMAP_SYSCALL_ARG
 #else  // Remaining 64-bit aritectures.
-  static_assert(sizeof(unsigned long) == 8, "Platform is not 64-bit");
-  return reinterpret_cast<void*>(
-      syscall(SYS_mmap, start, length, prot, flags, fd, offset));
+            static_assert(sizeof(unsigned long) == 8, "Platform is not 64-bit");
+            return reinterpret_cast<void*>(
+                syscall(SYS_mmap, start, length, prot, flags, fd, offset)
+            );
 #endif
-}
+        }
 
-inline int DirectMunmap(void* start, size_t length) {
-  return static_cast<int>(syscall(SYS_munmap, start, length));
-}
+        inline int DirectMunmap(void* start, size_t length)
+        {
+            return static_cast<int>(syscall(SYS_munmap, start, length));
+        }
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // !__linux__
@@ -145,21 +150,24 @@ ABSL_NAMESPACE_END
 // For non-linux platforms where we have mmap, just dispatch directly to the
 // actual mmap()/munmap() methods.
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
-                        off_t offset) {
-  return mmap(start, length, prot, flags, fd, offset);
-}
+        inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd, off_t offset)
+        {
+            return mmap(start, length, prot, flags, fd, offset);
+        }
 
-inline int DirectMunmap(void* start, size_t length) {
-  return munmap(start, length);
-}
+        inline int DirectMunmap(void* start, size_t length)
+        {
+            return munmap(start, length);
+        }
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // __linux__
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/dynamic_annotations.h b/CAPI/cpp/grpc/include/absl/base/internal/dynamic_annotations.h
index b23c5ec..4fb5e13 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/dynamic_annotations.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/dynamic_annotations.h
@@ -82,10 +82,10 @@
 
 // ANNOTALYSIS_ENABLED == 1 when IGNORE_READ_ATTRIBUTE_ENABLED == 1
 #define ABSL_INTERNAL_ANNOTALYSIS_ENABLED \
-  defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+    defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 // Read/write annotations are enabled in Annotalysis mode; disabled otherwise.
 #define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \
-  ABSL_INTERNAL_ANNOTALYSIS_ENABLED
+    ABSL_INTERNAL_ANNOTALYSIS_ENABLED
 #endif
 
 // Memory annotations are also made available to LLVM's Memory Sanitizer
@@ -98,7 +98,9 @@
 #endif
 
 #ifdef __cplusplus
-#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
+#define ABSL_INTERNAL_BEGIN_EXTERN_C \
+    extern "C"                       \
+    {
 #define ABSL_INTERNAL_END_EXTERN_C }  // extern "C"
 #define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
 #define ABSL_INTERNAL_STATIC_INLINE inline
@@ -123,29 +125,30 @@
 // "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the
 // point where `pointer` has been allocated, preferably close to the point
 // where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC.
-#define ANNOTATE_BENIGN_RACE(pointer, description)     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized) \
-  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
+#define ANNOTATE_BENIGN_RACE(pointer, description)       \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized) \
+    (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
 
 // Same as ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
 // the memory range [`address`, `address`+`size`).
 #define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)         \
-  (__FILE__, __LINE__, address, size, description)
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)       \
+    (__FILE__, __LINE__, address, size, description)
 
 // Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads.
 // This annotation could be useful if you want to skip expensive race analysis
 // during some period of program execution, e.g. during initialization.
-#define ANNOTATE_ENABLE_RACE_DETECTION(enable)             \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
-  (__FILE__, __LINE__, enable)
+#define ANNOTATE_ENABLE_RACE_DETECTION(enable)               \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
+    (__FILE__, __LINE__, enable)
 
 // -------------------------------------------------------------
 // Annotations useful for debugging.
 
 // Report the current thread `name` to a race detector.
-#define ANNOTATE_THREAD_NAME(name) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
+#define ANNOTATE_THREAD_NAME(name)                  \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName) \
+    (__FILE__, __LINE__, name)
 
 // -------------------------------------------------------------
 // Annotations useful when implementing locks. They are not normally needed by
@@ -153,46 +156,50 @@
 // object.
 
 // Report that a lock has been created at address `lock`.
-#define ANNOTATE_RWLOCK_CREATE(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
+#define ANNOTATE_RWLOCK_CREATE(lock)                  \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate) \
+    (__FILE__, __LINE__, lock)
 
 // Report that a linker initialized lock has been created at address `lock`.
 #ifdef ABSL_HAVE_THREAD_SANITIZER
-#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)               \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
-  (__FILE__, __LINE__, lock)
+#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)                 \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
+    (__FILE__, __LINE__, lock)
 #else
 #define ANNOTATE_RWLOCK_CREATE_STATIC(lock) ANNOTATE_RWLOCK_CREATE(lock)
 #endif
 
 // Report that the lock at address `lock` is about to be destroyed.
-#define ANNOTATE_RWLOCK_DESTROY(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
+#define ANNOTATE_RWLOCK_DESTROY(lock)                  \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy) \
+    (__FILE__, __LINE__, lock)
 
 // Report that the lock at address `lock` has been acquired.
 // `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \
-  (__FILE__, __LINE__, lock, is_w)
+#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)            \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \
+    (__FILE__, __LINE__, lock, is_w)
 
 // Report that the lock at address `lock` is about to be released.
 // `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
-  (__FILE__, __LINE__, lock, is_w)
+#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)            \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
+    (__FILE__, __LINE__, lock, is_w)
 
 // Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
-#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)      \
-  namespace {                                                     \
-  class static_var##_annotator {                                  \
-   public:                                                        \
-    static_var##_annotator() {                                    \
-      ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \
-                                 #static_var ": " description);   \
-    }                                                             \
-  };                                                              \
-  static static_var##_annotator the##static_var##_annotator;      \
-  }  // namespace
+#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)                                               \
+    namespace                                                                                              \
+    {                                                                                                      \
+        class static_var##_annotator                                                                       \
+        {                                                                                                  \
+        public:                                                                                            \
+            static_var##_annotator()                                                                       \
+            {                                                                                              \
+                ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), #static_var ": " description); \
+            }                                                                                              \
+        };                                                                                                 \
+        static static_var##_annotator the##static_var##_annotator;                                         \
+    }  // namespace
 
 #else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
 
@@ -217,24 +224,26 @@
 #include <sanitizer/msan_interface.h>
 
 #define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-  __msan_unpoison(address, size)
+    __msan_unpoison(address, size)
 
 #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
-  __msan_allocated_memory(address, size)
+    __msan_allocated_memory(address, size)
 
 #else  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 0
 
 #if DYNAMIC_ANNOTATIONS_ENABLED == 1
 #define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-  do {                                                \
-    (void)(address);                                  \
-    (void)(size);                                     \
-  } while (0)
+    do                                                \
+    {                                                 \
+        (void)(address);                              \
+        (void)(size);                                 \
+    } while (0)
 #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
-  do {                                                  \
-    (void)(address);                                    \
-    (void)(size);                                       \
-  } while (0)
+    do                                                  \
+    {                                                   \
+        (void)(address);                                \
+        (void)(size);                                   \
+    } while (0)
 #else
 #define ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty
 #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty
@@ -248,9 +257,9 @@
 #if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
 #define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
-  __attribute((exclusive_lock_function("*")))
+    __attribute((exclusive_lock_function("*")))
 #define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
-  __attribute((unlock_function("*")))
+    __attribute((unlock_function("*")))
 
 #else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
@@ -268,12 +277,14 @@
 // ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey
 // reads, while still checking other reads and all writes.
 // See also ANNOTATE_UNPROTECTED_READ.
-#define ANNOTATE_IGNORE_READS_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin)(__FILE__, __LINE__)
+#define ANNOTATE_IGNORE_READS_BEGIN()                     \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin) \
+    (__FILE__, __LINE__)
 
 // Stop ignoring reads.
-#define ANNOTATE_IGNORE_READS_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd)(__FILE__, __LINE__)
+#define ANNOTATE_IGNORE_READS_END()                     \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \
+    (__FILE__, __LINE__)
 
 #elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
 
@@ -284,11 +295,13 @@
 // TODO(delesley) -- The exclusive lock here ignores writes as well, but
 // allows IGNORE_READS_AND_WRITES to work properly.
 
-#define ANNOTATE_IGNORE_READS_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsBegin)()
+#define ANNOTATE_IGNORE_READS_BEGIN()                                 \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsBegin) \
+    ()
 
-#define ANNOTATE_IGNORE_READS_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsEnd)()
+#define ANNOTATE_IGNORE_READS_END()                                 \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsEnd) \
+    ()
 
 #else
 
@@ -303,12 +316,14 @@
 #if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
 
 // Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
-#define ANNOTATE_IGNORE_WRITES_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
+#define ANNOTATE_IGNORE_WRITES_BEGIN()                     \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin) \
+    (__FILE__, __LINE__)
 
 // Stop ignoring writes.
-#define ANNOTATE_IGNORE_WRITES_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
+#define ANNOTATE_IGNORE_WRITES_END()                     \
+    ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd) \
+    (__FILE__, __LINE__)
 
 #else
 
@@ -332,22 +347,24 @@
 
 // Start ignoring all memory accesses (both reads and writes).
 #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
-  do {                                           \
-    ANNOTATE_IGNORE_READS_BEGIN();               \
-    ANNOTATE_IGNORE_WRITES_BEGIN();              \
-  } while (0)
+    do                                           \
+    {                                            \
+        ANNOTATE_IGNORE_READS_BEGIN();           \
+        ANNOTATE_IGNORE_WRITES_BEGIN();          \
+    } while (0)
 
 // Stop ignoring both reads and writes.
 #define ANNOTATE_IGNORE_READS_AND_WRITES_END() \
-  do {                                         \
-    ANNOTATE_IGNORE_WRITES_END();              \
-    ANNOTATE_IGNORE_READS_END();               \
-  } while (0)
+    do                                         \
+    {                                          \
+        ANNOTATE_IGNORE_WRITES_END();          \
+        ANNOTATE_IGNORE_READS_END();           \
+    } while (0)
 
 #ifdef __cplusplus
 // ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
 #define ANNOTATE_UNPROTECTED_READ(x) \
-  absl::base_internal::AnnotateUnprotectedRead(x)
+    absl::base_internal::AnnotateUnprotectedRead(x)
 
 #endif
 
@@ -369,11 +386,12 @@
 #include <sanitizer/common_interface_defs.h>
 
 #define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \
-  __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
-#define ADDRESS_SANITIZER_REDZONE(name)    \
-  struct {                                 \
-    char x[8] __attribute__((aligned(8))); \
-  } name
+    __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
+#define ADDRESS_SANITIZER_REDZONE(name)        \
+    struct                                     \
+    {                                          \
+        char x[8] __attribute__((aligned(8))); \
+    } name
 
 #else
 
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/endian.h b/CAPI/cpp/grpc/include/absl/base/internal/endian.h
index 50747d7..4079f84 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/endian.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/endian.h
@@ -24,66 +24,77 @@
 #include "absl/base/internal/unaligned_access.h"
 #include "absl/base/port.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-inline uint64_t gbswap_64(uint64_t host_int) {
+    inline uint64_t gbswap_64(uint64_t host_int)
+    {
 #if ABSL_HAVE_BUILTIN(__builtin_bswap64) || defined(__GNUC__)
-  return __builtin_bswap64(host_int);
+        return __builtin_bswap64(host_int);
 #elif defined(_MSC_VER)
-  return _byteswap_uint64(host_int);
+        return _byteswap_uint64(host_int);
 #else
-  return (((host_int & uint64_t{0xFF}) << 56) |
-          ((host_int & uint64_t{0xFF00}) << 40) |
-          ((host_int & uint64_t{0xFF0000}) << 24) |
-          ((host_int & uint64_t{0xFF000000}) << 8) |
-          ((host_int & uint64_t{0xFF00000000}) >> 8) |
-          ((host_int & uint64_t{0xFF0000000000}) >> 24) |
-          ((host_int & uint64_t{0xFF000000000000}) >> 40) |
-          ((host_int & uint64_t{0xFF00000000000000}) >> 56));
+        return (((host_int & uint64_t{0xFF}) << 56) | ((host_int & uint64_t{0xFF00}) << 40) | ((host_int & uint64_t{0xFF0000}) << 24) | ((host_int & uint64_t{0xFF000000}) << 8) | ((host_int & uint64_t{0xFF00000000}) >> 8) | ((host_int & uint64_t{0xFF0000000000}) >> 24) | ((host_int & uint64_t{0xFF000000000000}) >> 40) | ((host_int & uint64_t{0xFF00000000000000}) >> 56));
 #endif
-}
+    }
 
-inline uint32_t gbswap_32(uint32_t host_int) {
+    inline uint32_t gbswap_32(uint32_t host_int)
+    {
 #if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)
-  return __builtin_bswap32(host_int);
+        return __builtin_bswap32(host_int);
 #elif defined(_MSC_VER)
-  return _byteswap_ulong(host_int);
+        return _byteswap_ulong(host_int);
 #else
-  return (((host_int & uint32_t{0xFF}) << 24) |
-          ((host_int & uint32_t{0xFF00}) << 8) |
-          ((host_int & uint32_t{0xFF0000}) >> 8) |
-          ((host_int & uint32_t{0xFF000000}) >> 24));
+        return (((host_int & uint32_t{0xFF}) << 24) | ((host_int & uint32_t{0xFF00}) << 8) | ((host_int & uint32_t{0xFF0000}) >> 8) | ((host_int & uint32_t{0xFF000000}) >> 24));
 #endif
-}
+    }
 
-inline uint16_t gbswap_16(uint16_t host_int) {
+    inline uint16_t gbswap_16(uint16_t host_int)
+    {
 #if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)
-  return __builtin_bswap16(host_int);
+        return __builtin_bswap16(host_int);
 #elif defined(_MSC_VER)
-  return _byteswap_ushort(host_int);
+        return _byteswap_ushort(host_int);
 #else
-  return (((host_int & uint16_t{0xFF}) << 8) |
-          ((host_int & uint16_t{0xFF00}) >> 8));
+        return (((host_int & uint16_t{0xFF}) << 8) | ((host_int & uint16_t{0xFF00}) >> 8));
 #endif
-}
+    }
 
 #ifdef ABSL_IS_LITTLE_ENDIAN
 
-// Portable definitions for htonl (host-to-network) and friends on little-endian
-// architectures.
-inline uint16_t ghtons(uint16_t x) { return gbswap_16(x); }
-inline uint32_t ghtonl(uint32_t x) { return gbswap_32(x); }
-inline uint64_t ghtonll(uint64_t x) { return gbswap_64(x); }
+    // Portable definitions for htonl (host-to-network) and friends on little-endian
+    // architectures.
+    inline uint16_t ghtons(uint16_t x)
+    {
+        return gbswap_16(x);
+    }
+    inline uint32_t ghtonl(uint32_t x)
+    {
+        return gbswap_32(x);
+    }
+    inline uint64_t ghtonll(uint64_t x)
+    {
+        return gbswap_64(x);
+    }
 
 #elif defined ABSL_IS_BIG_ENDIAN
 
-// Portable definitions for htonl (host-to-network) etc on big-endian
-// architectures. These definitions are simpler since the host byte order is the
-// same as network byte order.
-inline uint16_t ghtons(uint16_t x) { return x; }
-inline uint32_t ghtonl(uint32_t x) { return x; }
-inline uint64_t ghtonll(uint64_t x) { return x; }
+    // Portable definitions for htonl (host-to-network) etc on big-endian
+    // architectures. These definitions are simpler since the host byte order is the
+    // same as network byte order.
+    inline uint16_t ghtons(uint16_t x)
+    {
+        return x;
+    }
+    inline uint32_t ghtonl(uint32_t x)
+    {
+        return x;
+    }
+    inline uint64_t ghtonll(uint64_t x)
+    {
+        return x;
+    }
 
 #else
 #error \
@@ -91,192 +102,371 @@ inline uint64_t ghtonll(uint64_t x) { return x; }
        "ABSL_IS_LITTLE_ENDIAN must be defined"
 #endif  // byte order
 
-inline uint16_t gntohs(uint16_t x) { return ghtons(x); }
-inline uint32_t gntohl(uint32_t x) { return ghtonl(x); }
-inline uint64_t gntohll(uint64_t x) { return ghtonll(x); }
-
-// Utilities to convert numbers between the current hosts's native byte
-// order and little-endian byte order
-//
-// Load/Store methods are alignment safe
-namespace little_endian {
+    inline uint16_t gntohs(uint16_t x)
+    {
+        return ghtons(x);
+    }
+    inline uint32_t gntohl(uint32_t x)
+    {
+        return ghtonl(x);
+    }
+    inline uint64_t gntohll(uint64_t x)
+    {
+        return ghtonll(x);
+    }
+
+    // Utilities to convert numbers between the current hosts's native byte
+    // order and little-endian byte order
+    //
+    // Load/Store methods are alignment safe
+    namespace little_endian
+    {
 // Conversion functions.
 #ifdef ABSL_IS_LITTLE_ENDIAN
 
-inline uint16_t FromHost16(uint16_t x) { return x; }
-inline uint16_t ToHost16(uint16_t x) { return x; }
-
-inline uint32_t FromHost32(uint32_t x) { return x; }
-inline uint32_t ToHost32(uint32_t x) { return x; }
-
-inline uint64_t FromHost64(uint64_t x) { return x; }
-inline uint64_t ToHost64(uint64_t x) { return x; }
-
-inline constexpr bool IsLittleEndian() { return true; }
+        inline uint16_t FromHost16(uint16_t x)
+        {
+            return x;
+        }
+        inline uint16_t ToHost16(uint16_t x)
+        {
+            return x;
+        }
+
+        inline uint32_t FromHost32(uint32_t x)
+        {
+            return x;
+        }
+        inline uint32_t ToHost32(uint32_t x)
+        {
+            return x;
+        }
+
+        inline uint64_t FromHost64(uint64_t x)
+        {
+            return x;
+        }
+        inline uint64_t ToHost64(uint64_t x)
+        {
+            return x;
+        }
+
+        inline constexpr bool IsLittleEndian()
+        {
+            return true;
+        }
 
 #elif defined ABSL_IS_BIG_ENDIAN
 
-inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
-inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
-
-inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
-inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
-
-inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
-inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
-
-inline constexpr bool IsLittleEndian() { return false; }
+        inline uint16_t FromHost16(uint16_t x)
+        {
+            return gbswap_16(x);
+        }
+        inline uint16_t ToHost16(uint16_t x)
+        {
+            return gbswap_16(x);
+        }
+
+        inline uint32_t FromHost32(uint32_t x)
+        {
+            return gbswap_32(x);
+        }
+        inline uint32_t ToHost32(uint32_t x)
+        {
+            return gbswap_32(x);
+        }
+
+        inline uint64_t FromHost64(uint64_t x)
+        {
+            return gbswap_64(x);
+        }
+        inline uint64_t ToHost64(uint64_t x)
+        {
+            return gbswap_64(x);
+        }
+
+        inline constexpr bool IsLittleEndian()
+        {
+            return false;
+        }
 
 #endif /* ENDIAN */
 
-inline uint8_t FromHost(uint8_t x) { return x; }
-inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
-inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
-inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
-inline uint8_t ToHost(uint8_t x) { return x; }
-inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
-inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
-inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
-
-inline int8_t FromHost(int8_t x) { return x; }
-inline int16_t FromHost(int16_t x) {
-  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t FromHost(int32_t x) {
-  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t FromHost(int64_t x) {
-  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
-}
-inline int8_t ToHost(int8_t x) { return x; }
-inline int16_t ToHost(int16_t x) {
-  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t ToHost(int32_t x) {
-  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t ToHost(int64_t x) {
-  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
-}
-
-// Functions to do unaligned loads and stores in little-endian order.
-inline uint16_t Load16(const void *p) {
-  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
-}
-
-inline void Store16(void *p, uint16_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
-}
-
-inline uint32_t Load32(const void *p) {
-  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
-}
-
-inline void Store32(void *p, uint32_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
-}
-
-inline uint64_t Load64(const void *p) {
-  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
-}
-
-inline void Store64(void *p, uint64_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
-}
-
-}  // namespace little_endian
-
-// Utilities to convert numbers between the current hosts's native byte
-// order and big-endian byte order (same as network byte order)
-//
-// Load/Store methods are alignment safe
-namespace big_endian {
+        inline uint8_t FromHost(uint8_t x)
+        {
+            return x;
+        }
+        inline uint16_t FromHost(uint16_t x)
+        {
+            return FromHost16(x);
+        }
+        inline uint32_t FromHost(uint32_t x)
+        {
+            return FromHost32(x);
+        }
+        inline uint64_t FromHost(uint64_t x)
+        {
+            return FromHost64(x);
+        }
+        inline uint8_t ToHost(uint8_t x)
+        {
+            return x;
+        }
+        inline uint16_t ToHost(uint16_t x)
+        {
+            return ToHost16(x);
+        }
+        inline uint32_t ToHost(uint32_t x)
+        {
+            return ToHost32(x);
+        }
+        inline uint64_t ToHost(uint64_t x)
+        {
+            return ToHost64(x);
+        }
+
+        inline int8_t FromHost(int8_t x)
+        {
+            return x;
+        }
+        inline int16_t FromHost(int16_t x)
+        {
+            return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
+        }
+        inline int32_t FromHost(int32_t x)
+        {
+            return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
+        }
+        inline int64_t FromHost(int64_t x)
+        {
+            return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
+        }
+        inline int8_t ToHost(int8_t x)
+        {
+            return x;
+        }
+        inline int16_t ToHost(int16_t x)
+        {
+            return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
+        }
+        inline int32_t ToHost(int32_t x)
+        {
+            return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
+        }
+        inline int64_t ToHost(int64_t x)
+        {
+            return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
+        }
+
+        // Functions to do unaligned loads and stores in little-endian order.
+        inline uint16_t Load16(const void* p)
+        {
+            return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
+        }
+
+        inline void Store16(void* p, uint16_t v)
+        {
+            ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+        }
+
+        inline uint32_t Load32(const void* p)
+        {
+            return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+        }
+
+        inline void Store32(void* p, uint32_t v)
+        {
+            ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+        }
+
+        inline uint64_t Load64(const void* p)
+        {
+            return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+        }
+
+        inline void Store64(void* p, uint64_t v)
+        {
+            ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+        }
+
+    }  // namespace little_endian
+
+    // Utilities to convert numbers between the current hosts's native byte
+    // order and big-endian byte order (same as network byte order)
+    //
+    // Load/Store methods are alignment safe
+    namespace big_endian
+    {
 #ifdef ABSL_IS_LITTLE_ENDIAN
 
-inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
-inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
-
-inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
-inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
-
-inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
-inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
-
-inline constexpr bool IsLittleEndian() { return true; }
+        inline uint16_t FromHost16(uint16_t x)
+        {
+            return gbswap_16(x);
+        }
+        inline uint16_t ToHost16(uint16_t x)
+        {
+            return gbswap_16(x);
+        }
+
+        inline uint32_t FromHost32(uint32_t x)
+        {
+            return gbswap_32(x);
+        }
+        inline uint32_t ToHost32(uint32_t x)
+        {
+            return gbswap_32(x);
+        }
+
+        inline uint64_t FromHost64(uint64_t x)
+        {
+            return gbswap_64(x);
+        }
+        inline uint64_t ToHost64(uint64_t x)
+        {
+            return gbswap_64(x);
+        }
+
+        inline constexpr bool IsLittleEndian()
+        {
+            return true;
+        }
 
 #elif defined ABSL_IS_BIG_ENDIAN
 
-inline uint16_t FromHost16(uint16_t x) { return x; }
-inline uint16_t ToHost16(uint16_t x) { return x; }
-
-inline uint32_t FromHost32(uint32_t x) { return x; }
-inline uint32_t ToHost32(uint32_t x) { return x; }
-
-inline uint64_t FromHost64(uint64_t x) { return x; }
-inline uint64_t ToHost64(uint64_t x) { return x; }
-
-inline constexpr bool IsLittleEndian() { return false; }
+        inline uint16_t FromHost16(uint16_t x)
+        {
+            return x;
+        }
+        inline uint16_t ToHost16(uint16_t x)
+        {
+            return x;
+        }
+
+        inline uint32_t FromHost32(uint32_t x)
+        {
+            return x;
+        }
+        inline uint32_t ToHost32(uint32_t x)
+        {
+            return x;
+        }
+
+        inline uint64_t FromHost64(uint64_t x)
+        {
+            return x;
+        }
+        inline uint64_t ToHost64(uint64_t x)
+        {
+            return x;
+        }
+
+        inline constexpr bool IsLittleEndian()
+        {
+            return false;
+        }
 
 #endif /* ENDIAN */
 
-inline uint8_t FromHost(uint8_t x) { return x; }
-inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
-inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
-inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
-inline uint8_t ToHost(uint8_t x) { return x; }
-inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
-inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
-inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
-
-inline int8_t FromHost(int8_t x) { return x; }
-inline int16_t FromHost(int16_t x) {
-  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t FromHost(int32_t x) {
-  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t FromHost(int64_t x) {
-  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
-}
-inline int8_t ToHost(int8_t x) { return x; }
-inline int16_t ToHost(int16_t x) {
-  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t ToHost(int32_t x) {
-  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t ToHost(int64_t x) {
-  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
-}
-
-// Functions to do unaligned loads and stores in big-endian order.
-inline uint16_t Load16(const void *p) {
-  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
-}
-
-inline void Store16(void *p, uint16_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
-}
-
-inline uint32_t Load32(const void *p) {
-  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
-}
-
-inline void Store32(void *p, uint32_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
-}
-
-inline uint64_t Load64(const void *p) {
-  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
-}
-
-inline void Store64(void *p, uint64_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
-}
-
-}  // namespace big_endian
-
-ABSL_NAMESPACE_END
+        inline uint8_t FromHost(uint8_t x)
+        {
+            return x;
+        }
+        inline uint16_t FromHost(uint16_t x)
+        {
+            return FromHost16(x);
+        }
+        inline uint32_t FromHost(uint32_t x)
+        {
+            return FromHost32(x);
+        }
+        inline uint64_t FromHost(uint64_t x)
+        {
+            return FromHost64(x);
+        }
+        inline uint8_t ToHost(uint8_t x)
+        {
+            return x;
+        }
+        inline uint16_t ToHost(uint16_t x)
+        {
+            return ToHost16(x);
+        }
+        inline uint32_t ToHost(uint32_t x)
+        {
+            return ToHost32(x);
+        }
+        inline uint64_t ToHost(uint64_t x)
+        {
+            return ToHost64(x);
+        }
+
+        inline int8_t FromHost(int8_t x)
+        {
+            return x;
+        }
+        inline int16_t FromHost(int16_t x)
+        {
+            return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
+        }
+        inline int32_t FromHost(int32_t x)
+        {
+            return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
+        }
+        inline int64_t FromHost(int64_t x)
+        {
+            return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
+        }
+        inline int8_t ToHost(int8_t x)
+        {
+            return x;
+        }
+        inline int16_t ToHost(int16_t x)
+        {
+            return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
+        }
+        inline int32_t ToHost(int32_t x)
+        {
+            return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
+        }
+        inline int64_t ToHost(int64_t x)
+        {
+            return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
+        }
+
+        // Functions to do unaligned loads and stores in big-endian order.
+        inline uint16_t Load16(const void* p)
+        {
+            return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
+        }
+
+        inline void Store16(void* p, uint16_t v)
+        {
+            ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+        }
+
+        inline uint32_t Load32(const void* p)
+        {
+            return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+        }
+
+        inline void Store32(void* p, uint32_t v)
+        {
+            ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+        }
+
+        inline uint64_t Load64(const void* p)
+        {
+            return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+        }
+
+        inline void Store64(void* p, uint64_t v)
+        {
+            ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+        }
+
+    }  // namespace big_endian
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_ENDIAN_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/errno_saver.h b/CAPI/cpp/grpc/include/absl/base/internal/errno_saver.h
index 251de51..4140bef 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/errno_saver.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/errno_saver.h
@@ -19,25 +19,37 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// `ErrnoSaver` captures the value of `errno` upon construction and restores it
-// upon deletion.  It is used in low-level code and must be super fast.  Do not
-// add instrumentation, even in debug modes.
-class ErrnoSaver {
- public:
-  ErrnoSaver() : saved_errno_(errno) {}
-  ~ErrnoSaver() { errno = saved_errno_; }
-  int operator()() const { return saved_errno_; }
-
- private:
-  const int saved_errno_;
-};
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        // `ErrnoSaver` captures the value of `errno` upon construction and restores it
+        // upon deletion.  It is used in low-level code and must be super fast.  Do not
+        // add instrumentation, even in debug modes.
+        class ErrnoSaver
+        {
+        public:
+            ErrnoSaver() :
+                saved_errno_(errno)
+            {
+            }
+            ~ErrnoSaver()
+            {
+                errno = saved_errno_;
+            }
+            int operator()() const
+            {
+                return saved_errno_;
+            }
+
+        private:
+            const int saved_errno_;
+        };
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/exception_safety_testing.h b/CAPI/cpp/grpc/include/absl/base/internal/exception_safety_testing.h
index 77a5aec..741a8c9 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/exception_safety_testing.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/exception_safety_testing.h
@@ -38,1069 +38,1305 @@
 #include "absl/strings/substitute.h"
 #include "absl/utility/utility.h"
 
-namespace testing {
-
-enum class TypeSpec;
-enum class AllocSpec;
-
-constexpr TypeSpec operator|(TypeSpec a, TypeSpec b) {
-  using T = absl::underlying_type_t<TypeSpec>;
-  return static_cast<TypeSpec>(static_cast<T>(a) | static_cast<T>(b));
-}
-
-constexpr TypeSpec operator&(TypeSpec a, TypeSpec b) {
-  using T = absl::underlying_type_t<TypeSpec>;
-  return static_cast<TypeSpec>(static_cast<T>(a) & static_cast<T>(b));
-}
-
-constexpr AllocSpec operator|(AllocSpec a, AllocSpec b) {
-  using T = absl::underlying_type_t<AllocSpec>;
-  return static_cast<AllocSpec>(static_cast<T>(a) | static_cast<T>(b));
-}
-
-constexpr AllocSpec operator&(AllocSpec a, AllocSpec b) {
-  using T = absl::underlying_type_t<AllocSpec>;
-  return static_cast<AllocSpec>(static_cast<T>(a) & static_cast<T>(b));
-}
-
-namespace exceptions_internal {
-
-std::string GetSpecString(TypeSpec);
-std::string GetSpecString(AllocSpec);
-
-struct NoThrowTag {};
-struct StrongGuaranteeTagType {};
-
-// A simple exception class.  We throw this so that test code can catch
-// exceptions specifically thrown by ThrowingValue.
-class TestException {
- public:
-  explicit TestException(absl::string_view msg) : msg_(msg) {}
-  virtual ~TestException() {}
-  virtual const char* what() const noexcept { return msg_.c_str(); }
-
- private:
-  std::string msg_;
-};
-
-// TestBadAllocException exists because allocation functions must throw an
-// exception which can be caught by a handler of std::bad_alloc.  We use a child
-// class of std::bad_alloc so we can customise the error message, and also
-// derive from TestException so we don't accidentally end up catching an actual
-// bad_alloc exception in TestExceptionSafety.
-class TestBadAllocException : public std::bad_alloc, public TestException {
- public:
-  explicit TestBadAllocException(absl::string_view msg) : TestException(msg) {}
-  using TestException::what;
-};
-
-extern int countdown;
-
-// Allows the countdown variable to be set manually (defaulting to the initial
-// value of 0)
-inline void SetCountdown(int i = 0) { countdown = i; }
-// Sets the countdown to the terminal value -1
-inline void UnsetCountdown() { SetCountdown(-1); }
-
-void MaybeThrow(absl::string_view msg, bool throw_bad_alloc = false);
-
-testing::AssertionResult FailureMessage(const TestException& e,
-                                        int countdown) noexcept;
-
-struct TrackedAddress {
-  bool is_alive;
-  std::string description;
-};
-
-// Inspects the constructions and destructions of anything inheriting from
-// TrackedObject. This allows us to safely "leak" TrackedObjects, as
-// ConstructorTracker will destroy everything left over in its destructor.
-class ConstructorTracker {
- public:
-  explicit ConstructorTracker(int count) : countdown_(count) {
-    assert(current_tracker_instance_ == nullptr);
-    current_tracker_instance_ = this;
-  }
-
-  ~ConstructorTracker() {
-    assert(current_tracker_instance_ == this);
-    current_tracker_instance_ = nullptr;
-
-    for (auto& it : address_map_) {
-      void* address = it.first;
-      TrackedAddress& tracked_address = it.second;
-      if (tracked_address.is_alive) {
-        ADD_FAILURE() << ErrorMessage(address, tracked_address.description,
-                                      countdown_, "Object was not destroyed.");
-      }
-    }
-  }
-
-  static void ObjectConstructed(void* address, std::string description) {
-    if (!CurrentlyTracking()) return;
-
-    TrackedAddress& tracked_address =
-        current_tracker_instance_->address_map_[address];
-    if (tracked_address.is_alive) {
-      ADD_FAILURE() << ErrorMessage(
-          address, tracked_address.description,
-          current_tracker_instance_->countdown_,
-          "Object was re-constructed. Current object was constructed by " +
-              description);
-    }
-    tracked_address = {true, std::move(description)};
-  }
+namespace testing
+{
 
-  static void ObjectDestructed(void* address) {
-    if (!CurrentlyTracking()) return;
+    enum class TypeSpec;
+    enum class AllocSpec;
 
-    auto it = current_tracker_instance_->address_map_.find(address);
-    // Not tracked. Ignore.
-    if (it == current_tracker_instance_->address_map_.end()) return;
+    constexpr TypeSpec operator|(TypeSpec a, TypeSpec b)
+    {
+        using T = absl::underlying_type_t<TypeSpec>;
+        return static_cast<TypeSpec>(static_cast<T>(a) | static_cast<T>(b));
+    }
 
-    TrackedAddress& tracked_address = it->second;
-    if (!tracked_address.is_alive) {
-      ADD_FAILURE() << ErrorMessage(address, tracked_address.description,
-                                    current_tracker_instance_->countdown_,
-                                    "Object was re-destroyed.");
+    constexpr TypeSpec operator&(TypeSpec a, TypeSpec b)
+    {
+        using T = absl::underlying_type_t<TypeSpec>;
+        return static_cast<TypeSpec>(static_cast<T>(a) & static_cast<T>(b));
     }
-    tracked_address.is_alive = false;
-  }
-
- private:
-  static bool CurrentlyTracking() {
-    return current_tracker_instance_ != nullptr;
-  }
-
-  static std::string ErrorMessage(void* address,
-                                  const std::string& address_description,
-                                  int countdown,
-                                  const std::string& error_description) {
-    return absl::Substitute(
-        "With coundtown at $0:\n"
-        "  $1\n"
-        "  Object originally constructed by $2\n"
-        "  Object address: $3\n",
-        countdown, error_description, address_description, address);
-  }
-
-  std::unordered_map<void*, TrackedAddress> address_map_;
-  int countdown_;
-
-  static ConstructorTracker* current_tracker_instance_;
-};
-
-class TrackedObject {
- public:
-  TrackedObject(const TrackedObject&) = delete;
-  TrackedObject(TrackedObject&&) = delete;
-
- protected:
-  explicit TrackedObject(std::string description) {
-    ConstructorTracker::ObjectConstructed(this, std::move(description));
-  }
-
-  ~TrackedObject() noexcept { ConstructorTracker::ObjectDestructed(this); }
-};
-}  // namespace exceptions_internal
-
-extern exceptions_internal::NoThrowTag nothrow_ctor;
-
-extern exceptions_internal::StrongGuaranteeTagType strong_guarantee;
-
-// A test class which is convertible to bool.  The conversion can be
-// instrumented to throw at a controlled time.
-class ThrowingBool {
- public:
-  ThrowingBool(bool b) noexcept : b_(b) {}  // NOLINT(runtime/explicit)
-  operator bool() const {                   // NOLINT
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return b_;
-  }
-
- private:
-  bool b_;
-};
-
-/*
- * Configuration enum for the ThrowingValue type that defines behavior for the
- * lifetime of the instance. Use testing::nothrow_ctor to prevent the integer
- * constructor from throwing.
- *
- * kEverythingThrows: Every operation can throw an exception
- * kNoThrowCopy: Copy construction and copy assignment will not throw
- * kNoThrowMove: Move construction and move assignment will not throw
- * kNoThrowNew: Overloaded operators new and new[] will not throw
- */
-enum class TypeSpec {
-  kEverythingThrows = 0,
-  kNoThrowCopy = 1,
-  kNoThrowMove = 1 << 1,
-  kNoThrowNew = 1 << 2,
-};
-
-/*
- * A testing class instrumented to throw an exception at a controlled time.
- *
- * ThrowingValue implements a slightly relaxed version of the Regular concept --
- * that is it's a value type with the expected semantics.  It also implements
- * arithmetic operations.  It doesn't implement member and pointer operators
- * like operator-> or operator[].
- *
- * ThrowingValue can be instrumented to have certain operations be noexcept by
- * using compile-time bitfield template arguments.  That is, to make an
- * ThrowingValue which has noexcept move construction/assignment and noexcept
- * copy construction/assignment, use the following:
- *   ThrowingValue<testing::kNoThrowMove | testing::kNoThrowCopy> my_thrwr{val};
- */
-template <TypeSpec Spec = TypeSpec::kEverythingThrows>
-class ThrowingValue : private exceptions_internal::TrackedObject {
-  static constexpr bool IsSpecified(TypeSpec spec) {
-    return static_cast<bool>(Spec & spec);
-  }
-
-  static constexpr int kDefaultValue = 0;
-  static constexpr int kBadValue = 938550620;
-
- public:
-  ThrowingValue() : TrackedObject(GetInstanceString(kDefaultValue)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ = kDefaultValue;
-  }
-
-  ThrowingValue(const ThrowingValue& other) noexcept(
-      IsSpecified(TypeSpec::kNoThrowCopy))
-      : TrackedObject(GetInstanceString(other.dummy_)) {
-    if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+
+    constexpr AllocSpec operator|(AllocSpec a, AllocSpec b)
+    {
+        using T = absl::underlying_type_t<AllocSpec>;
+        return static_cast<AllocSpec>(static_cast<T>(a) | static_cast<T>(b));
     }
-    dummy_ = other.dummy_;
-  }
-
-  ThrowingValue(ThrowingValue&& other) noexcept(
-      IsSpecified(TypeSpec::kNoThrowMove))
-      : TrackedObject(GetInstanceString(other.dummy_)) {
-    if (!IsSpecified(TypeSpec::kNoThrowMove)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+
+    constexpr AllocSpec operator&(AllocSpec a, AllocSpec b)
+    {
+        using T = absl::underlying_type_t<AllocSpec>;
+        return static_cast<AllocSpec>(static_cast<T>(a) & static_cast<T>(b));
     }
-    dummy_ = other.dummy_;
-  }
 
-  explicit ThrowingValue(int i) : TrackedObject(GetInstanceString(i)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ = i;
-  }
+    namespace exceptions_internal
+    {
+
+        std::string GetSpecString(TypeSpec);
+        std::string GetSpecString(AllocSpec);
+
+        struct NoThrowTag
+        {
+        };
+        struct StrongGuaranteeTagType
+        {
+        };
+
+        // A simple exception class.  We throw this so that test code can catch
+        // exceptions specifically thrown by ThrowingValue.
+        class TestException
+        {
+        public:
+            explicit TestException(absl::string_view msg) :
+                msg_(msg)
+            {
+            }
+            virtual ~TestException()
+            {
+            }
+            virtual const char* what() const noexcept
+            {
+                return msg_.c_str();
+            }
+
+        private:
+            std::string msg_;
+        };
+
+        // TestBadAllocException exists because allocation functions must throw an
+        // exception which can be caught by a handler of std::bad_alloc.  We use a child
+        // class of std::bad_alloc so we can customise the error message, and also
+        // derive from TestException so we don't accidentally end up catching an actual
+        // bad_alloc exception in TestExceptionSafety.
+        class TestBadAllocException : public std::bad_alloc, public TestException
+        {
+        public:
+            explicit TestBadAllocException(absl::string_view msg) :
+                TestException(msg)
+            {
+            }
+            using TestException::what;
+        };
+
+        extern int countdown;
+
+        // Allows the countdown variable to be set manually (defaulting to the initial
+        // value of 0)
+        inline void SetCountdown(int i = 0)
+        {
+            countdown = i;
+        }
+        // Sets the countdown to the terminal value -1
+        inline void UnsetCountdown()
+        {
+            SetCountdown(-1);
+        }
 
-  ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept
-      : TrackedObject(GetInstanceString(i)), dummy_(i) {}
+        void MaybeThrow(absl::string_view msg, bool throw_bad_alloc = false);
+
+        testing::AssertionResult FailureMessage(const TestException& e, int countdown) noexcept;
+
+        struct TrackedAddress
+        {
+            bool is_alive;
+            std::string description;
+        };
+
+        // Inspects the constructions and destructions of anything inheriting from
+        // TrackedObject. This allows us to safely "leak" TrackedObjects, as
+        // ConstructorTracker will destroy everything left over in its destructor.
+        class ConstructorTracker
+        {
+        public:
+            explicit ConstructorTracker(int count) :
+                countdown_(count)
+            {
+                assert(current_tracker_instance_ == nullptr);
+                current_tracker_instance_ = this;
+            }
+
+            ~ConstructorTracker()
+            {
+                assert(current_tracker_instance_ == this);
+                current_tracker_instance_ = nullptr;
+
+                for (auto& it : address_map_)
+                {
+                    void* address = it.first;
+                    TrackedAddress& tracked_address = it.second;
+                    if (tracked_address.is_alive)
+                    {
+                        ADD_FAILURE() << ErrorMessage(address, tracked_address.description, countdown_, "Object was not destroyed.");
+                    }
+                }
+            }
+
+            static void ObjectConstructed(void* address, std::string description)
+            {
+                if (!CurrentlyTracking())
+                    return;
+
+                TrackedAddress& tracked_address =
+                    current_tracker_instance_->address_map_[address];
+                if (tracked_address.is_alive)
+                {
+                    ADD_FAILURE() << ErrorMessage(
+                        address, tracked_address.description, current_tracker_instance_->countdown_, "Object was re-constructed. Current object was constructed by " + description
+                    );
+                }
+                tracked_address = {true, std::move(description)};
+            }
+
+            static void ObjectDestructed(void* address)
+            {
+                if (!CurrentlyTracking())
+                    return;
+
+                auto it = current_tracker_instance_->address_map_.find(address);
+                // Not tracked. Ignore.
+                if (it == current_tracker_instance_->address_map_.end())
+                    return;
+
+                TrackedAddress& tracked_address = it->second;
+                if (!tracked_address.is_alive)
+                {
+                    ADD_FAILURE() << ErrorMessage(address, tracked_address.description, current_tracker_instance_->countdown_, "Object was re-destroyed.");
+                }
+                tracked_address.is_alive = false;
+            }
+
+        private:
+            static bool CurrentlyTracking()
+            {
+                return current_tracker_instance_ != nullptr;
+            }
+
+            static std::string ErrorMessage(void* address, const std::string& address_description, int countdown, const std::string& error_description)
+            {
+                return absl::Substitute(
+                    "With coundtown at $0:\n"
+                    "  $1\n"
+                    "  Object originally constructed by $2\n"
+                    "  Object address: $3\n",
+                    countdown,
+                    error_description,
+                    address_description,
+                    address
+                );
+            }
+
+            std::unordered_map<void*, TrackedAddress> address_map_;
+            int countdown_;
+
+            static ConstructorTracker* current_tracker_instance_;
+        };
+
+        class TrackedObject
+        {
+        public:
+            TrackedObject(const TrackedObject&) = delete;
+            TrackedObject(TrackedObject&&) = delete;
+
+        protected:
+            explicit TrackedObject(std::string description)
+            {
+                ConstructorTracker::ObjectConstructed(this, std::move(description));
+            }
+
+            ~TrackedObject() noexcept
+            {
+                ConstructorTracker::ObjectDestructed(this);
+            }
+        };
+    }  // namespace exceptions_internal
+
+    extern exceptions_internal::NoThrowTag nothrow_ctor;
+
+    extern exceptions_internal::StrongGuaranteeTagType strong_guarantee;
+
+    // A test class which is convertible to bool.  The conversion can be
+    // instrumented to throw at a controlled time.
+    class ThrowingBool
+    {
+    public:
+        ThrowingBool(bool b) noexcept :
+            b_(b)
+        {
+        }  // NOLINT(runtime/explicit)
+        operator bool() const
+        {  // NOLINT
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return b_;
+        }
 
-  // absl expects nothrow destructors
-  ~ThrowingValue() noexcept = default;
+    private:
+        bool b_;
+    };
+
+    /*
+     * Configuration enum for the ThrowingValue type that defines behavior for the
+     * lifetime of the instance. Use testing::nothrow_ctor to prevent the integer
+     * constructor from throwing.
+     *
+     * kEverythingThrows: Every operation can throw an exception
+     * kNoThrowCopy: Copy construction and copy assignment will not throw
+     * kNoThrowMove: Move construction and move assignment will not throw
+     * kNoThrowNew: Overloaded operators new and new[] will not throw
+     */
+    enum class TypeSpec
+    {
+        kEverythingThrows = 0,
+        kNoThrowCopy = 1,
+        kNoThrowMove = 1 << 1,
+        kNoThrowNew = 1 << 2,
+    };
+
+    /*
+     * A testing class instrumented to throw an exception at a controlled time.
+     *
+     * ThrowingValue implements a slightly relaxed version of the Regular concept --
+     * that is it's a value type with the expected semantics.  It also implements
+     * arithmetic operations.  It doesn't implement member and pointer operators
+     * like operator-> or operator[].
+     *
+     * ThrowingValue can be instrumented to have certain operations be noexcept by
+     * using compile-time bitfield template arguments.  That is, to make an
+     * ThrowingValue which has noexcept move construction/assignment and noexcept
+     * copy construction/assignment, use the following:
+     *   ThrowingValue<testing::kNoThrowMove | testing::kNoThrowCopy> my_thrwr{val};
+     */
+    template<TypeSpec Spec = TypeSpec::kEverythingThrows>
+    class ThrowingValue : private exceptions_internal::TrackedObject
+    {
+        static constexpr bool IsSpecified(TypeSpec spec)
+        {
+            return static_cast<bool>(Spec & spec);
+        }
 
-  ThrowingValue& operator=(const ThrowingValue& other) noexcept(
-      IsSpecified(TypeSpec::kNoThrowCopy)) {
-    dummy_ = kBadValue;
-    if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    }
-    dummy_ = other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator=(ThrowingValue&& other) noexcept(
-      IsSpecified(TypeSpec::kNoThrowMove)) {
-    dummy_ = kBadValue;
-    if (!IsSpecified(TypeSpec::kNoThrowMove)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    }
-    dummy_ = other.dummy_;
-    return *this;
-  }
-
-  // Arithmetic Operators
-  ThrowingValue operator+(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ + other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator+() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator-(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ - other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator-() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(-dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue& operator++() {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    ++dummy_;
-    return *this;
-  }
-
-  ThrowingValue operator++(int) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    auto out = ThrowingValue(dummy_, nothrow_ctor);
-    ++dummy_;
-    return out;
-  }
-
-  ThrowingValue& operator--() {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    --dummy_;
-    return *this;
-  }
-
-  ThrowingValue operator--(int) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    auto out = ThrowingValue(dummy_, nothrow_ctor);
-    --dummy_;
-    return out;
-  }
-
-  ThrowingValue operator*(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ * other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator/(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ / other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator%(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ % other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator<<(int shift) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ << shift, nothrow_ctor);
-  }
-
-  ThrowingValue operator>>(int shift) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ >> shift, nothrow_ctor);
-  }
-
-  // Comparison Operators
-  // NOTE: We use `ThrowingBool` instead of `bool` because most STL
-  // types/containers requires T to be convertible to bool.
-  friend ThrowingBool operator==(const ThrowingValue& a,
-                                 const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ == b.dummy_;
-  }
-  friend ThrowingBool operator!=(const ThrowingValue& a,
-                                 const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ != b.dummy_;
-  }
-  friend ThrowingBool operator<(const ThrowingValue& a,
-                                const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ < b.dummy_;
-  }
-  friend ThrowingBool operator<=(const ThrowingValue& a,
-                                 const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ <= b.dummy_;
-  }
-  friend ThrowingBool operator>(const ThrowingValue& a,
-                                const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ > b.dummy_;
-  }
-  friend ThrowingBool operator>=(const ThrowingValue& a,
-                                 const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return a.dummy_ >= b.dummy_;
-  }
-
-  // Logical Operators
-  ThrowingBool operator!() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return !dummy_;
-  }
-
-  ThrowingBool operator&&(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return dummy_ && other.dummy_;
-  }
-
-  ThrowingBool operator||(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return dummy_ || other.dummy_;
-  }
-
-  // Bitwise Logical Operators
-  ThrowingValue operator~() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(~dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator&(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ & other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator|(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ | other.dummy_, nothrow_ctor);
-  }
-
-  ThrowingValue operator^(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return ThrowingValue(dummy_ ^ other.dummy_, nothrow_ctor);
-  }
-
-  // Compound Assignment operators
-  ThrowingValue& operator+=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ += other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator-=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ -= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator*=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ *= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator/=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ /= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator%=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ %= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator&=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ &= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator|=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ |= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator^=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ ^= other.dummy_;
-    return *this;
-  }
-
-  ThrowingValue& operator<<=(int shift) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ <<= shift;
-    return *this;
-  }
-
-  ThrowingValue& operator>>=(int shift) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ >>= shift;
-    return *this;
-  }
-
-  // Pointer operators
-  void operator&() const = delete;  // NOLINT(runtime/operator)
-
-  // Stream operators
-  friend std::ostream& operator<<(std::ostream& os, const ThrowingValue& tv) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return os << GetInstanceString(tv.dummy_);
-  }
-
-  friend std::istream& operator>>(std::istream& is, const ThrowingValue&) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    return is;
-  }
-
-  // Memory management operators
-  static void* operator new(size_t s) noexcept(
-      IsSpecified(TypeSpec::kNoThrowNew)) {
-    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
-    }
-    return ::operator new(s);
-  }
+        static constexpr int kDefaultValue = 0;
+        static constexpr int kBadValue = 938550620;
 
-  static void* operator new[](size_t s) noexcept(
-      IsSpecified(TypeSpec::kNoThrowNew)) {
-    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
-    }
-    return ::operator new[](s);
-  }
-
-  template <typename... Args>
-  static void* operator new(size_t s, Args&&... args) noexcept(
-      IsSpecified(TypeSpec::kNoThrowNew)) {
-    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
-    }
-    return ::operator new(s, std::forward<Args>(args)...);
-  }
-
-  template <typename... Args>
-  static void* operator new[](size_t s, Args&&... args) noexcept(
-      IsSpecified(TypeSpec::kNoThrowNew)) {
-    if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
-    }
-    return ::operator new[](s, std::forward<Args>(args)...);
-  }
-
-  // Abseil doesn't support throwing overloaded operator delete.  These are
-  // provided so a throwing operator-new can clean up after itself.
-  void operator delete(void* p) noexcept { ::operator delete(p); }
-
-  template <typename... Args>
-  void operator delete(void* p, Args&&... args) noexcept {
-    ::operator delete(p, std::forward<Args>(args)...);
-  }
-
-  void operator delete[](void* p) noexcept { return ::operator delete[](p); }
-
-  template <typename... Args>
-  void operator delete[](void* p, Args&&... args) noexcept {
-    return ::operator delete[](p, std::forward<Args>(args)...);
-  }
-
-  // Non-standard access to the actual contained value.  No need for this to
-  // throw.
-  int& Get() noexcept { return dummy_; }
-  const int& Get() const noexcept { return dummy_; }
-
- private:
-  static std::string GetInstanceString(int dummy) {
-    return absl::StrCat("ThrowingValue<",
-                        exceptions_internal::GetSpecString(Spec), ">(", dummy,
-                        ")");
-  }
-
-  int dummy_;
-};
-// While not having to do with exceptions, explicitly delete comma operator, to
-// make sure we don't use it on user-supplied types.
-template <TypeSpec Spec, typename T>
-void operator,(const ThrowingValue<Spec>&, T&&) = delete;
-template <TypeSpec Spec, typename T>
-void operator,(T&&, const ThrowingValue<Spec>&) = delete;
-
-/*
- * Configuration enum for the ThrowingAllocator type that defines behavior for
- * the lifetime of the instance.
- *
- * kEverythingThrows: Calls to the member functions may throw
- * kNoThrowAllocate: Calls to the member functions will not throw
- */
-enum class AllocSpec {
-  kEverythingThrows = 0,
-  kNoThrowAllocate = 1,
-};
-
-/*
- * An allocator type which is instrumented to throw at a controlled time, or not
- * to throw, using AllocSpec. The supported settings are the default of every
- * function which is allowed to throw in a conforming allocator possibly
- * throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS
- * configuration macro.
- */
-template <typename T, AllocSpec Spec = AllocSpec::kEverythingThrows>
-class ThrowingAllocator : private exceptions_internal::TrackedObject {
-  static constexpr bool IsSpecified(AllocSpec spec) {
-    return static_cast<bool>(Spec & spec);
-  }
-
- public:
-  using pointer = T*;
-  using const_pointer = const T*;
-  using reference = T&;
-  using const_reference = const T&;
-  using void_pointer = void*;
-  using const_void_pointer = const void*;
-  using value_type = T;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-
-  using is_nothrow =
-      std::integral_constant<bool, Spec == AllocSpec::kNoThrowAllocate>;
-  using propagate_on_container_copy_assignment = std::true_type;
-  using propagate_on_container_move_assignment = std::true_type;
-  using propagate_on_container_swap = std::true_type;
-  using is_always_equal = std::false_type;
-
-  ThrowingAllocator() : TrackedObject(GetInstanceString(next_id_)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
-    dummy_ = std::make_shared<const int>(next_id_++);
-  }
-
-  template <typename U>
-  ThrowingAllocator(const ThrowingAllocator<U, Spec>& other) noexcept  // NOLINT
-      : TrackedObject(GetInstanceString(*other.State())),
-        dummy_(other.State()) {}
-
-  // According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of
-  // allocator shall not exit via an exception, thus they are marked noexcept.
-  ThrowingAllocator(const ThrowingAllocator& other) noexcept
-      : TrackedObject(GetInstanceString(*other.State())),
-        dummy_(other.State()) {}
-
-  template <typename U>
-  ThrowingAllocator(ThrowingAllocator<U, Spec>&& other) noexcept  // NOLINT
-      : TrackedObject(GetInstanceString(*other.State())),
-        dummy_(std::move(other.State())) {}
-
-  ThrowingAllocator(ThrowingAllocator&& other) noexcept
-      : TrackedObject(GetInstanceString(*other.State())),
-        dummy_(std::move(other.State())) {}
-
-  ~ThrowingAllocator() noexcept = default;
-
-  ThrowingAllocator& operator=(const ThrowingAllocator& other) noexcept {
-    dummy_ = other.State();
-    return *this;
-  }
-
-  template <typename U>
-  ThrowingAllocator& operator=(
-      const ThrowingAllocator<U, Spec>& other) noexcept {
-    dummy_ = other.State();
-    return *this;
-  }
-
-  template <typename U>
-  ThrowingAllocator& operator=(ThrowingAllocator<U, Spec>&& other) noexcept {
-    dummy_ = std::move(other.State());
-    return *this;
-  }
-
-  template <typename U>
-  struct rebind {
-    using other = ThrowingAllocator<U, Spec>;
-  };
-
-  pointer allocate(size_type n) noexcept(
-      IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
-    return static_cast<pointer>(::operator new(n * sizeof(T)));
-  }
-
-  pointer allocate(size_type n, const_void_pointer) noexcept(
-      IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    return allocate(n);
-  }
-
-  void deallocate(pointer ptr, size_type) noexcept {
-    ReadState();
-    ::operator delete(static_cast<void*>(ptr));
-  }
-
-  template <typename U, typename... Args>
-  void construct(U* ptr, Args&&... args) noexcept(
-      IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
-    ::new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
-  }
-
-  template <typename U>
-  void destroy(U* p) noexcept {
-    ReadState();
-    p->~U();
-  }
-
-  size_type max_size() const noexcept {
-    return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
-  }
-
-  ThrowingAllocator select_on_container_copy_construction() noexcept(
-      IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
-    return *this;
-  }
-
-  template <typename U>
-  bool operator==(const ThrowingAllocator<U, Spec>& other) const noexcept {
-    return dummy_ == other.dummy_;
-  }
-
-  template <typename U>
-  bool operator!=(const ThrowingAllocator<U, Spec>& other) const noexcept {
-    return dummy_ != other.dummy_;
-  }
-
-  template <typename, AllocSpec>
-  friend class ThrowingAllocator;
-
- private:
-  static std::string GetInstanceString(int dummy) {
-    return absl::StrCat("ThrowingAllocator<",
-                        exceptions_internal::GetSpecString(Spec), ">(", dummy,
-                        ")");
-  }
-
-  const std::shared_ptr<const int>& State() const { return dummy_; }
-  std::shared_ptr<const int>& State() { return dummy_; }
-
-  void ReadState() {
-    // we know that this will never be true, but the compiler doesn't, so this
-    // should safely force a read of the value.
-    if (*dummy_ < 0) std::abort();
-  }
-
-  void ReadStateAndMaybeThrow(absl::string_view msg) const {
-    if (!IsSpecified(AllocSpec::kNoThrowAllocate)) {
-      exceptions_internal::MaybeThrow(
-          absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg));
-    }
-  }
-
-  static int next_id_;
-  std::shared_ptr<const int> dummy_;
-};
-
-template <typename T, AllocSpec Spec>
-int ThrowingAllocator<T, Spec>::next_id_ = 0;
-
-// Tests for resource leaks by attempting to construct a T using args repeatedly
-// until successful, using the countdown method.  Side effects can then be
-// tested for resource leaks.
-template <typename T, typename... Args>
-void TestThrowingCtor(Args&&... args) {
-  struct Cleanup {
-    ~Cleanup() { exceptions_internal::UnsetCountdown(); }
-  } c;
-  for (int count = 0;; ++count) {
-    exceptions_internal::ConstructorTracker ct(count);
-    exceptions_internal::SetCountdown(count);
-    try {
-      T temp(std::forward<Args>(args)...);
-      static_cast<void>(temp);
-      break;
-    } catch (const exceptions_internal::TestException&) {
+    public:
+        ThrowingValue() :
+            TrackedObject(GetInstanceString(kDefaultValue))
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ = kDefaultValue;
+        }
+
+        ThrowingValue(const ThrowingValue& other) noexcept(
+            IsSpecified(TypeSpec::kNoThrowCopy)
+        ) :
+            TrackedObject(GetInstanceString(other.dummy_))
+        {
+            if (!IsSpecified(TypeSpec::kNoThrowCopy))
+            {
+                exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            }
+            dummy_ = other.dummy_;
+        }
+
+        ThrowingValue(ThrowingValue&& other) noexcept(
+            IsSpecified(TypeSpec::kNoThrowMove)
+        ) :
+            TrackedObject(GetInstanceString(other.dummy_))
+        {
+            if (!IsSpecified(TypeSpec::kNoThrowMove))
+            {
+                exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            }
+            dummy_ = other.dummy_;
+        }
+
+        explicit ThrowingValue(int i) :
+            TrackedObject(GetInstanceString(i))
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ = i;
+        }
+
+        ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept
+            :
+            TrackedObject(GetInstanceString(i)),
+            dummy_(i)
+        {
+        }
+
+        // absl expects nothrow destructors
+        ~ThrowingValue() noexcept = default;
+
+        ThrowingValue& operator=(const ThrowingValue& other) noexcept(
+            IsSpecified(TypeSpec::kNoThrowCopy)
+        )
+        {
+            dummy_ = kBadValue;
+            if (!IsSpecified(TypeSpec::kNoThrowCopy))
+            {
+                exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            }
+            dummy_ = other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator=(ThrowingValue&& other) noexcept(
+            IsSpecified(TypeSpec::kNoThrowMove)
+        )
+        {
+            dummy_ = kBadValue;
+            if (!IsSpecified(TypeSpec::kNoThrowMove))
+            {
+                exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            }
+            dummy_ = other.dummy_;
+            return *this;
+        }
+
+        // Arithmetic Operators
+        ThrowingValue operator+(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ + other.dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator+() const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator-(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ - other.dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator-() const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(-dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue& operator++()
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            ++dummy_;
+            return *this;
+        }
+
+        ThrowingValue operator++(int)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            auto out = ThrowingValue(dummy_, nothrow_ctor);
+            ++dummy_;
+            return out;
+        }
+
+        ThrowingValue& operator--()
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            --dummy_;
+            return *this;
+        }
+
+        ThrowingValue operator--(int)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            auto out = ThrowingValue(dummy_, nothrow_ctor);
+            --dummy_;
+            return out;
+        }
+
+        ThrowingValue operator*(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ * other.dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator/(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ / other.dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator%(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ % other.dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator<<(int shift) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ << shift, nothrow_ctor);
+        }
+
+        ThrowingValue operator>>(int shift) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ >> shift, nothrow_ctor);
+        }
+
+        // Comparison Operators
+        // NOTE: We use `ThrowingBool` instead of `bool` because most STL
+        // types/containers requires T to be convertible to bool.
+        friend ThrowingBool operator==(const ThrowingValue& a, const ThrowingValue& b)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return a.dummy_ == b.dummy_;
+        }
+        friend ThrowingBool operator!=(const ThrowingValue& a, const ThrowingValue& b)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return a.dummy_ != b.dummy_;
+        }
+        friend ThrowingBool operator<(const ThrowingValue& a, const ThrowingValue& b)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return a.dummy_ < b.dummy_;
+        }
+        friend ThrowingBool operator<=(const ThrowingValue& a, const ThrowingValue& b)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return a.dummy_ <= b.dummy_;
+        }
+        friend ThrowingBool operator>(const ThrowingValue& a, const ThrowingValue& b)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return a.dummy_ > b.dummy_;
+        }
+        friend ThrowingBool operator>=(const ThrowingValue& a, const ThrowingValue& b)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return a.dummy_ >= b.dummy_;
+        }
+
+        // Logical Operators
+        ThrowingBool operator!() const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return !dummy_;
+        }
+
+        ThrowingBool operator&&(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return dummy_ && other.dummy_;
+        }
+
+        ThrowingBool operator||(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return dummy_ || other.dummy_;
+        }
+
+        // Bitwise Logical Operators
+        ThrowingValue operator~() const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(~dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator&(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ & other.dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator|(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ | other.dummy_, nothrow_ctor);
+        }
+
+        ThrowingValue operator^(const ThrowingValue& other) const
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return ThrowingValue(dummy_ ^ other.dummy_, nothrow_ctor);
+        }
+
+        // Compound Assignment operators
+        ThrowingValue& operator+=(const ThrowingValue& other)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ += other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator-=(const ThrowingValue& other)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ -= other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator*=(const ThrowingValue& other)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ *= other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator/=(const ThrowingValue& other)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ /= other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator%=(const ThrowingValue& other)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ %= other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator&=(const ThrowingValue& other)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ &= other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator|=(const ThrowingValue& other)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ |= other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator^=(const ThrowingValue& other)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ ^= other.dummy_;
+            return *this;
+        }
+
+        ThrowingValue& operator<<=(int shift)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ <<= shift;
+            return *this;
+        }
+
+        ThrowingValue& operator>>=(int shift)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ >>= shift;
+            return *this;
+        }
+
+        // Pointer operators
+        void operator&() const = delete;  // NOLINT(runtime/operator)
+
+        // Stream operators
+        friend std::ostream& operator<<(std::ostream& os, const ThrowingValue& tv)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return os << GetInstanceString(tv.dummy_);
+        }
+
+        friend std::istream& operator>>(std::istream& is, const ThrowingValue&)
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            return is;
+        }
+
+        // Memory management operators
+        static void* operator new(size_t s) noexcept(
+            IsSpecified(TypeSpec::kNoThrowNew)
+        )
+        {
+            if (!IsSpecified(TypeSpec::kNoThrowNew))
+            {
+                exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+            }
+            return ::operator new(s);
+        }
+
+        static void* operator new[](size_t s) noexcept(
+            IsSpecified(TypeSpec::kNoThrowNew)
+        )
+        {
+            if (!IsSpecified(TypeSpec::kNoThrowNew))
+            {
+                exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+            }
+            return ::operator new[](s);
+        }
+
+        template<typename... Args>
+        static void* operator new(size_t s, Args&&... args) noexcept(
+            IsSpecified(TypeSpec::kNoThrowNew)
+        )
+        {
+            if (!IsSpecified(TypeSpec::kNoThrowNew))
+            {
+                exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+            }
+            return ::operator new(s, std::forward<Args>(args)...);
+        }
+
+        template<typename... Args>
+        static void* operator new[](size_t s, Args&&... args) noexcept(
+            IsSpecified(TypeSpec::kNoThrowNew)
+        )
+        {
+            if (!IsSpecified(TypeSpec::kNoThrowNew))
+            {
+                exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+            }
+            return ::operator new[](s, std::forward<Args>(args)...);
+        }
+
+        // Abseil doesn't support throwing overloaded operator delete.  These are
+        // provided so a throwing operator-new can clean up after itself.
+        void operator delete(void* p) noexcept
+        {
+            ::operator delete(p);
+        }
+
+        template<typename... Args>
+        void operator delete(void* p, Args&&... args) noexcept
+        {
+            ::operator delete(p, std::forward<Args>(args)...);
+        }
+
+        void operator delete[](void* p) noexcept
+        {
+            return ::operator delete[](p);
+        }
+
+        template<typename... Args>
+        void operator delete[](void* p, Args&&... args) noexcept
+        {
+            return ::operator delete[](p, std::forward<Args>(args)...);
+        }
+
+        // Non-standard access to the actual contained value.  No need for this to
+        // throw.
+        int& Get() noexcept
+        {
+            return dummy_;
+        }
+        const int& Get() const noexcept
+        {
+            return dummy_;
+        }
+
+    private:
+        static std::string GetInstanceString(int dummy)
+        {
+            return absl::StrCat("ThrowingValue<", exceptions_internal::GetSpecString(Spec), ">(", dummy, ")");
+        }
+
+        int dummy_;
+    };
+    // While not having to do with exceptions, explicitly delete comma operator, to
+    // make sure we don't use it on user-supplied types.
+    template<TypeSpec Spec, typename T>
+    void operator,(const ThrowingValue<Spec>&, T&&) = delete;
+    template<TypeSpec Spec, typename T>
+    void operator,(T&&, const ThrowingValue<Spec>&) = delete;
+
+    /*
+     * Configuration enum for the ThrowingAllocator type that defines behavior for
+     * the lifetime of the instance.
+     *
+     * kEverythingThrows: Calls to the member functions may throw
+     * kNoThrowAllocate: Calls to the member functions will not throw
+     */
+    enum class AllocSpec
+    {
+        kEverythingThrows = 0,
+        kNoThrowAllocate = 1,
+    };
+
+    /*
+     * An allocator type which is instrumented to throw at a controlled time, or not
+     * to throw, using AllocSpec. The supported settings are the default of every
+     * function which is allowed to throw in a conforming allocator possibly
+     * throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS
+     * configuration macro.
+     */
+    template<typename T, AllocSpec Spec = AllocSpec::kEverythingThrows>
+    class ThrowingAllocator : private exceptions_internal::TrackedObject
+    {
+        static constexpr bool IsSpecified(AllocSpec spec)
+        {
+            return static_cast<bool>(Spec & spec);
+        }
+
+    public:
+        using pointer = T*;
+        using const_pointer = const T*;
+        using reference = T&;
+        using const_reference = const T&;
+        using void_pointer = void*;
+        using const_void_pointer = const void*;
+        using value_type = T;
+        using size_type = size_t;
+        using difference_type = ptrdiff_t;
+
+        using is_nothrow =
+            std::integral_constant<bool, Spec == AllocSpec::kNoThrowAllocate>;
+        using propagate_on_container_copy_assignment = std::true_type;
+        using propagate_on_container_move_assignment = std::true_type;
+        using propagate_on_container_swap = std::true_type;
+        using is_always_equal = std::false_type;
+
+        ThrowingAllocator() :
+            TrackedObject(GetInstanceString(next_id_))
+        {
+            exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+            dummy_ = std::make_shared<const int>(next_id_++);
+        }
+
+        template<typename U>
+        ThrowingAllocator(const ThrowingAllocator<U, Spec>& other) noexcept  // NOLINT
+            :
+            TrackedObject(GetInstanceString(*other.State())),
+            dummy_(other.State())
+        {
+        }
+
+        // According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of
+        // allocator shall not exit via an exception, thus they are marked noexcept.
+        ThrowingAllocator(const ThrowingAllocator& other) noexcept
+            :
+            TrackedObject(GetInstanceString(*other.State())),
+            dummy_(other.State())
+        {
+        }
+
+        template<typename U>
+        ThrowingAllocator(ThrowingAllocator<U, Spec>&& other) noexcept  // NOLINT
+            :
+            TrackedObject(GetInstanceString(*other.State())),
+            dummy_(std::move(other.State()))
+        {
+        }
+
+        ThrowingAllocator(ThrowingAllocator&& other) noexcept
+            :
+            TrackedObject(GetInstanceString(*other.State())),
+            dummy_(std::move(other.State()))
+        {
+        }
+
+        ~ThrowingAllocator() noexcept = default;
+
+        ThrowingAllocator& operator=(const ThrowingAllocator& other) noexcept
+        {
+            dummy_ = other.State();
+            return *this;
+        }
+
+        template<typename U>
+        ThrowingAllocator& operator=(
+            const ThrowingAllocator<U, Spec>& other
+        ) noexcept
+        {
+            dummy_ = other.State();
+            return *this;
+        }
+
+        template<typename U>
+        ThrowingAllocator& operator=(ThrowingAllocator<U, Spec>&& other) noexcept
+        {
+            dummy_ = std::move(other.State());
+            return *this;
+        }
+
+        template<typename U>
+        struct rebind
+        {
+            using other = ThrowingAllocator<U, Spec>;
+        };
+
+        pointer allocate(size_type n) noexcept(
+            IsSpecified(AllocSpec::kNoThrowAllocate)
+        )
+        {
+            ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+            return static_cast<pointer>(::operator new(n * sizeof(T)));
+        }
+
+        pointer allocate(size_type n, const_void_pointer) noexcept(
+            IsSpecified(AllocSpec::kNoThrowAllocate)
+        )
+        {
+            return allocate(n);
+        }
+
+        void deallocate(pointer ptr, size_type) noexcept
+        {
+            ReadState();
+            ::operator delete(static_cast<void*>(ptr));
+        }
+
+        template<typename U, typename... Args>
+        void construct(U* ptr, Args&&... args) noexcept(
+            IsSpecified(AllocSpec::kNoThrowAllocate)
+        )
+        {
+            ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+            ::new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
+        }
+
+        template<typename U>
+        void destroy(U* p) noexcept
+        {
+            ReadState();
+            p->~U();
+        }
+
+        size_type max_size() const noexcept
+        {
+            return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
+        }
+
+        ThrowingAllocator select_on_container_copy_construction() noexcept(
+            IsSpecified(AllocSpec::kNoThrowAllocate)
+        )
+        {
+            ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+            return *this;
+        }
+
+        template<typename U>
+        bool operator==(const ThrowingAllocator<U, Spec>& other) const noexcept
+        {
+            return dummy_ == other.dummy_;
+        }
+
+        template<typename U>
+        bool operator!=(const ThrowingAllocator<U, Spec>& other) const noexcept
+        {
+            return dummy_ != other.dummy_;
+        }
+
+        template<typename, AllocSpec>
+        friend class ThrowingAllocator;
+
+    private:
+        static std::string GetInstanceString(int dummy)
+        {
+            return absl::StrCat("ThrowingAllocator<", exceptions_internal::GetSpecString(Spec), ">(", dummy, ")");
+        }
+
+        const std::shared_ptr<const int>& State() const
+        {
+            return dummy_;
+        }
+        std::shared_ptr<const int>& State()
+        {
+            return dummy_;
+        }
+
+        void ReadState()
+        {
+            // we know that this will never be true, but the compiler doesn't, so this
+            // should safely force a read of the value.
+            if (*dummy_ < 0)
+                std::abort();
+        }
+
+        void ReadStateAndMaybeThrow(absl::string_view msg) const
+        {
+            if (!IsSpecified(AllocSpec::kNoThrowAllocate))
+            {
+                exceptions_internal::MaybeThrow(
+                    absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg)
+                );
+            }
+        }
+
+        static int next_id_;
+        std::shared_ptr<const int> dummy_;
+    };
+
+    template<typename T, AllocSpec Spec>
+    int ThrowingAllocator<T, Spec>::next_id_ = 0;
+
+    // Tests for resource leaks by attempting to construct a T using args repeatedly
+    // until successful, using the countdown method.  Side effects can then be
+    // tested for resource leaks.
+    template<typename T, typename... Args>
+    void TestThrowingCtor(Args&&... args)
+    {
+        struct Cleanup
+        {
+            ~Cleanup()
+            {
+                exceptions_internal::UnsetCountdown();
+            }
+        } c;
+        for (int count = 0;; ++count)
+        {
+            exceptions_internal::ConstructorTracker ct(count);
+            exceptions_internal::SetCountdown(count);
+            try
+            {
+                T temp(std::forward<Args>(args)...);
+                static_cast<void>(temp);
+                break;
+            }
+            catch (const exceptions_internal::TestException&)
+            {
+            }
+        }
     }
-  }
-}
-
-// Tests the nothrow guarantee of the provided nullary operation. If the an
-// exception is thrown, the result will be AssertionFailure(). Otherwise, it
-// will be AssertionSuccess().
-template <typename Operation>
-testing::AssertionResult TestNothrowOp(const Operation& operation) {
-  struct Cleanup {
-    Cleanup() { exceptions_internal::SetCountdown(); }
-    ~Cleanup() { exceptions_internal::UnsetCountdown(); }
-  } c;
-  try {
-    operation();
-    return testing::AssertionSuccess();
-  } catch (const exceptions_internal::TestException&) {
-    return testing::AssertionFailure()
-           << "TestException thrown during call to operation() when nothrow "
-              "guarantee was expected.";
-  } catch (...) {
-    return testing::AssertionFailure()
-           << "Unknown exception thrown during call to operation() when "
-              "nothrow guarantee was expected.";
-  }
-}
-
-namespace exceptions_internal {
-
-// Dummy struct for ExceptionSafetyTestBuilder<> partial state.
-struct UninitializedT {};
-
-template <typename T>
-class DefaultFactory {
- public:
-  explicit DefaultFactory(const T& t) : t_(t) {}
-  std::unique_ptr<T> operator()() const { return absl::make_unique<T>(t_); }
-
- private:
-  T t_;
-};
-
-template <size_t LazyContractsCount, typename LazyFactory,
-          typename LazyOperation>
-using EnableIfTestable = typename absl::enable_if_t<
-    LazyContractsCount != 0 &&
-    !std::is_same<LazyFactory, UninitializedT>::value &&
-    !std::is_same<LazyOperation, UninitializedT>::value>;
-
-template <typename Factory = UninitializedT,
-          typename Operation = UninitializedT, typename... Contracts>
-class ExceptionSafetyTestBuilder;
-
-}  // namespace exceptions_internal
-
-/*
- * Constructs an empty ExceptionSafetyTestBuilder. All
- * ExceptionSafetyTestBuilder objects are immutable and all With[thing] mutation
- * methods return new instances of ExceptionSafetyTestBuilder.
- *
- * In order to test a T for exception safety, a factory for that T, a testable
- * operation, and at least one contract callback returning an assertion
- * result must be applied using the respective methods.
- */
-exceptions_internal::ExceptionSafetyTestBuilder<> MakeExceptionSafetyTester();
-
-namespace exceptions_internal {
-template <typename T>
-struct IsUniquePtr : std::false_type {};
-
-template <typename T, typename D>
-struct IsUniquePtr<std::unique_ptr<T, D>> : std::true_type {};
-
-template <typename Factory>
-struct FactoryPtrTypeHelper {
-  using type = decltype(std::declval<const Factory&>()());
-
-  static_assert(IsUniquePtr<type>::value, "Factories must return a unique_ptr");
-};
-
-template <typename Factory>
-using FactoryPtrType = typename FactoryPtrTypeHelper<Factory>::type;
-
-template <typename Factory>
-using FactoryElementType = typename FactoryPtrType<Factory>::element_type;
-
-template <typename T>
-class ExceptionSafetyTest {
-  using Factory = std::function<std::unique_ptr<T>()>;
-  using Operation = std::function<void(T*)>;
-  using Contract = std::function<AssertionResult(T*)>;
-
- public:
-  template <typename... Contracts>
-  explicit ExceptionSafetyTest(const Factory& f, const Operation& op,
-                               const Contracts&... contracts)
-      : factory_(f), operation_(op), contracts_{WrapContract(contracts)...} {}
-
-  AssertionResult Test() const {
-    for (int count = 0;; ++count) {
-      exceptions_internal::ConstructorTracker ct(count);
-
-      for (const auto& contract : contracts_) {
-        auto t_ptr = factory_();
-        try {
-          SetCountdown(count);
-          operation_(t_ptr.get());
-          // Unset for the case that the operation throws no exceptions, which
-          // would leave the countdown set and break the *next* exception safety
-          // test after this one.
-          UnsetCountdown();
-          return AssertionSuccess();
-        } catch (const exceptions_internal::TestException& e) {
-          if (!contract(t_ptr.get())) {
-            return AssertionFailure() << e.what() << " failed contract check";
-          }
-        }
-      }
+
+    // Tests the nothrow guarantee of the provided nullary operation. If the an
+    // exception is thrown, the result will be AssertionFailure(). Otherwise, it
+    // will be AssertionSuccess().
+    template<typename Operation>
+    testing::AssertionResult TestNothrowOp(const Operation& operation)
+    {
+        struct Cleanup
+        {
+            Cleanup()
+            {
+                exceptions_internal::SetCountdown();
+            }
+            ~Cleanup()
+            {
+                exceptions_internal::UnsetCountdown();
+            }
+        } c;
+        try
+        {
+            operation();
+            return testing::AssertionSuccess();
+        }
+        catch (const exceptions_internal::TestException&)
+        {
+            return testing::AssertionFailure()
+                   << "TestException thrown during call to operation() when nothrow "
+                      "guarantee was expected.";
+        }
+        catch (...)
+        {
+            return testing::AssertionFailure()
+                   << "Unknown exception thrown during call to operation() when "
+                      "nothrow guarantee was expected.";
+        }
     }
-  }
-
- private:
-  template <typename ContractFn>
-  Contract WrapContract(const ContractFn& contract) {
-    return [contract](T* t_ptr) { return AssertionResult(contract(t_ptr)); };
-  }
-
-  Contract WrapContract(StrongGuaranteeTagType) {
-    return [this](T* t_ptr) { return AssertionResult(*factory_() == *t_ptr); };
-  }
-
-  Factory factory_;
-  Operation operation_;
-  std::vector<Contract> contracts_;
-};
-
-/*
- * Builds a tester object that tests if performing a operation on a T follows
- * exception safety guarantees. Verification is done via contract assertion
- * callbacks applied to T instances post-throw.
- *
- * Template parameters for ExceptionSafetyTestBuilder:
- *
- * - Factory: The factory object (passed in via tester.WithFactory(...) or
- *   tester.WithInitialValue(...)) must be invocable with the signature
- *   `std::unique_ptr<T> operator()() const` where T is the type being tested.
- *   It is used for reliably creating identical T instances to test on.
- *
- * - Operation: The operation object (passsed in via tester.WithOperation(...)
- *   or tester.Test(...)) must be invocable with the signature
- *   `void operator()(T*) const` where T is the type being tested. It is used
- *   for performing steps on a T instance that may throw and that need to be
- *   checked for exception safety. Each call to the operation will receive a
- *   fresh T instance so it's free to modify and destroy the T instances as it
- *   pleases.
- *
- * - Contracts...: The contract assertion callback objects (passed in via
- *   tester.WithContracts(...)) must be invocable with the signature
- *   `testing::AssertionResult operator()(T*) const` where T is the type being
- *   tested. Contract assertion callbacks are provided T instances post-throw.
- *   They must return testing::AssertionSuccess when the type contracts of the
- *   provided T instance hold. If the type contracts of the T instance do not
- *   hold, they must return testing::AssertionFailure. Execution order of
- *   Contracts... is unspecified. They will each individually get a fresh T
- *   instance so they are free to modify and destroy the T instances as they
- *   please.
- */
-template <typename Factory, typename Operation, typename... Contracts>
-class ExceptionSafetyTestBuilder {
- public:
-  /*
-   * Returns a new ExceptionSafetyTestBuilder with an included T factory based
-   * on the provided T instance. The existing factory will not be included in
-   * the newly created tester instance. The created factory returns a new T
-   * instance by copy-constructing the provided const T& t.
-   *
-   * Preconditions for tester.WithInitialValue(const T& t):
-   *
-   * - The const T& t object must be copy-constructible where T is the type
-   *   being tested. For non-copy-constructible objects, use the method
-   *   tester.WithFactory(...).
-   */
-  template <typename T>
-  ExceptionSafetyTestBuilder<DefaultFactory<T>, Operation, Contracts...>
-  WithInitialValue(const T& t) const {
-    return WithFactory(DefaultFactory<T>(t));
-  }
-
-  /*
-   * Returns a new ExceptionSafetyTestBuilder with the provided T factory
-   * included. The existing factory will not be included in the newly-created
-   * tester instance. This method is intended for use with types lacking a copy
-   * constructor. Types that can be copy-constructed should instead use the
-   * method tester.WithInitialValue(...).
-   */
-  template <typename NewFactory>
-  ExceptionSafetyTestBuilder<absl::decay_t<NewFactory>, Operation, Contracts...>
-  WithFactory(const NewFactory& new_factory) const {
-    return {new_factory, operation_, contracts_};
-  }
-
-  /*
-   * Returns a new ExceptionSafetyTestBuilder with the provided testable
-   * operation included. The existing operation will not be included in the
-   * newly created tester.
-   */
-  template <typename NewOperation>
-  ExceptionSafetyTestBuilder<Factory, absl::decay_t<NewOperation>, Contracts...>
-  WithOperation(const NewOperation& new_operation) const {
-    return {factory_, new_operation, contracts_};
-  }
-
-  /*
-   * Returns a new ExceptionSafetyTestBuilder with the provided MoreContracts...
-   * combined with the Contracts... that were already included in the instance
-   * on which the method was called. Contracts... cannot be removed or replaced
-   * once added to an ExceptionSafetyTestBuilder instance. A fresh object must
-   * be created in order to get an empty Contracts... list.
-   *
-   * In addition to passing in custom contract assertion callbacks, this method
-   * accepts `testing::strong_guarantee` as an argument which checks T instances
-   * post-throw against freshly created T instances via operator== to verify
-   * that any state changes made during the execution of the operation were
-   * properly rolled back.
-   */
-  template <typename... MoreContracts>
-  ExceptionSafetyTestBuilder<Factory, Operation, Contracts...,
-                             absl::decay_t<MoreContracts>...>
-  WithContracts(const MoreContracts&... more_contracts) const {
-    return {
-        factory_, operation_,
-        std::tuple_cat(contracts_, std::tuple<absl::decay_t<MoreContracts>...>(
-                                       more_contracts...))};
-  }
-
-  /*
-   * Returns a testing::AssertionResult that is the reduced result of the
-   * exception safety algorithm. The algorithm short circuits and returns
-   * AssertionFailure after the first contract callback returns an
-   * AssertionFailure. Otherwise, if all contract callbacks return an
-   * AssertionSuccess, the reduced result is AssertionSuccess.
-   *
-   * The passed-in testable operation will not be saved in a new tester instance
-   * nor will it modify/replace the existing tester instance. This is useful
-   * when each operation being tested is unique and does not need to be reused.
-   *
-   * Preconditions for tester.Test(const NewOperation& new_operation):
-   *
-   * - May only be called after at least one contract assertion callback and a
-   *   factory or initial value have been provided.
-   */
-  template <
-      typename NewOperation,
-      typename = EnableIfTestable<sizeof...(Contracts), Factory, NewOperation>>
-  testing::AssertionResult Test(const NewOperation& new_operation) const {
-    return TestImpl(new_operation, absl::index_sequence_for<Contracts...>());
-  }
-
-  /*
-   * Returns a testing::AssertionResult that is the reduced result of the
-   * exception safety algorithm. The algorithm short circuits and returns
-   * AssertionFailure after the first contract callback returns an
-   * AssertionFailure. Otherwise, if all contract callbacks return an
-   * AssertionSuccess, the reduced result is AssertionSuccess.
-   *
-   * Preconditions for tester.Test():
-   *
-   * - May only be called after at least one contract assertion callback, a
-   *   factory or initial value and a testable operation have been provided.
-   */
-  template <
-      typename LazyOperation = Operation,
-      typename = EnableIfTestable<sizeof...(Contracts), Factory, LazyOperation>>
-  testing::AssertionResult Test() const {
-    return Test(operation_);
-  }
-
- private:
-  template <typename, typename, typename...>
-  friend class ExceptionSafetyTestBuilder;
-
-  friend ExceptionSafetyTestBuilder<> testing::MakeExceptionSafetyTester();
-
-  ExceptionSafetyTestBuilder() {}
-
-  ExceptionSafetyTestBuilder(const Factory& f, const Operation& o,
-                             const std::tuple<Contracts...>& i)
-      : factory_(f), operation_(o), contracts_(i) {}
-
-  template <typename SelectedOperation, size_t... Indices>
-  testing::AssertionResult TestImpl(SelectedOperation selected_operation,
-                                    absl::index_sequence<Indices...>) const {
-    return ExceptionSafetyTest<FactoryElementType<Factory>>(
-               factory_, selected_operation, std::get<Indices>(contracts_)...)
-        .Test();
-  }
-
-  Factory factory_;
-  Operation operation_;
-  std::tuple<Contracts...> contracts_;
-};
-
-}  // namespace exceptions_internal
+
+    namespace exceptions_internal
+    {
+
+        // Dummy struct for ExceptionSafetyTestBuilder<> partial state.
+        struct UninitializedT
+        {
+        };
+
+        template<typename T>
+        class DefaultFactory
+        {
+        public:
+            explicit DefaultFactory(const T& t) :
+                t_(t)
+            {
+            }
+            std::unique_ptr<T> operator()() const
+            {
+                return absl::make_unique<T>(t_);
+            }
+
+        private:
+            T t_;
+        };
+
+        template<size_t LazyContractsCount, typename LazyFactory, typename LazyOperation>
+        using EnableIfTestable = typename absl::enable_if_t<
+            LazyContractsCount != 0 &&
+            !std::is_same<LazyFactory, UninitializedT>::value &&
+            !std::is_same<LazyOperation, UninitializedT>::value>;
+
+        template<typename Factory = UninitializedT, typename Operation = UninitializedT, typename... Contracts>
+        class ExceptionSafetyTestBuilder;
+
+    }  // namespace exceptions_internal
+
+    /*
+     * Constructs an empty ExceptionSafetyTestBuilder. All
+     * ExceptionSafetyTestBuilder objects are immutable and all With[thing] mutation
+     * methods return new instances of ExceptionSafetyTestBuilder.
+     *
+     * In order to test a T for exception safety, a factory for that T, a testable
+     * operation, and at least one contract callback returning an assertion
+     * result must be applied using the respective methods.
+     */
+    exceptions_internal::ExceptionSafetyTestBuilder<> MakeExceptionSafetyTester();
+
+    namespace exceptions_internal
+    {
+        template<typename T>
+        struct IsUniquePtr : std::false_type
+        {
+        };
+
+        template<typename T, typename D>
+        struct IsUniquePtr<std::unique_ptr<T, D>> : std::true_type
+        {
+        };
+
+        template<typename Factory>
+        struct FactoryPtrTypeHelper
+        {
+            using type = decltype(std::declval<const Factory&>()());
+
+            static_assert(IsUniquePtr<type>::value, "Factories must return a unique_ptr");
+        };
+
+        template<typename Factory>
+        using FactoryPtrType = typename FactoryPtrTypeHelper<Factory>::type;
+
+        template<typename Factory>
+        using FactoryElementType = typename FactoryPtrType<Factory>::element_type;
+
+        template<typename T>
+        class ExceptionSafetyTest
+        {
+            using Factory = std::function<std::unique_ptr<T>()>;
+            using Operation = std::function<void(T*)>;
+            using Contract = std::function<AssertionResult(T*)>;
+
+        public:
+            template<typename... Contracts>
+            explicit ExceptionSafetyTest(const Factory& f, const Operation& op, const Contracts&... contracts) :
+                factory_(f),
+                operation_(op),
+                contracts_{WrapContract(contracts)...}
+            {
+            }
+
+            AssertionResult Test() const
+            {
+                for (int count = 0;; ++count)
+                {
+                    exceptions_internal::ConstructorTracker ct(count);
+
+                    for (const auto& contract : contracts_)
+                    {
+                        auto t_ptr = factory_();
+                        try
+                        {
+                            SetCountdown(count);
+                            operation_(t_ptr.get());
+                            // Unset for the case that the operation throws no exceptions, which
+                            // would leave the countdown set and break the *next* exception safety
+                            // test after this one.
+                            UnsetCountdown();
+                            return AssertionSuccess();
+                        }
+                        catch (const exceptions_internal::TestException& e)
+                        {
+                            if (!contract(t_ptr.get()))
+                            {
+                                return AssertionFailure() << e.what() << " failed contract check";
+                            }
+                        }
+                    }
+                }
+            }
+
+        private:
+            template<typename ContractFn>
+            Contract WrapContract(const ContractFn& contract)
+            {
+                return [contract](T* t_ptr)
+                { return AssertionResult(contract(t_ptr)); };
+            }
+
+            Contract WrapContract(StrongGuaranteeTagType)
+            {
+                return [this](T* t_ptr)
+                { return AssertionResult(*factory_() == *t_ptr); };
+            }
+
+            Factory factory_;
+            Operation operation_;
+            std::vector<Contract> contracts_;
+        };
+
+        /*
+         * Builds a tester object that tests if performing a operation on a T follows
+         * exception safety guarantees. Verification is done via contract assertion
+         * callbacks applied to T instances post-throw.
+         *
+         * Template parameters for ExceptionSafetyTestBuilder:
+         *
+         * - Factory: The factory object (passed in via tester.WithFactory(...) or
+         *   tester.WithInitialValue(...)) must be invocable with the signature
+         *   `std::unique_ptr<T> operator()() const` where T is the type being tested.
+         *   It is used for reliably creating identical T instances to test on.
+         *
+         * - Operation: The operation object (passsed in via tester.WithOperation(...)
+         *   or tester.Test(...)) must be invocable with the signature
+         *   `void operator()(T*) const` where T is the type being tested. It is used
+         *   for performing steps on a T instance that may throw and that need to be
+         *   checked for exception safety. Each call to the operation will receive a
+         *   fresh T instance so it's free to modify and destroy the T instances as it
+         *   pleases.
+         *
+         * - Contracts...: The contract assertion callback objects (passed in via
+         *   tester.WithContracts(...)) must be invocable with the signature
+         *   `testing::AssertionResult operator()(T*) const` where T is the type being
+         *   tested. Contract assertion callbacks are provided T instances post-throw.
+         *   They must return testing::AssertionSuccess when the type contracts of the
+         *   provided T instance hold. If the type contracts of the T instance do not
+         *   hold, they must return testing::AssertionFailure. Execution order of
+         *   Contracts... is unspecified. They will each individually get a fresh T
+         *   instance so they are free to modify and destroy the T instances as they
+         *   please.
+         */
+        template<typename Factory, typename Operation, typename... Contracts>
+        class ExceptionSafetyTestBuilder
+        {
+        public:
+            /*
+             * Returns a new ExceptionSafetyTestBuilder with an included T factory based
+             * on the provided T instance. The existing factory will not be included in
+             * the newly created tester instance. The created factory returns a new T
+             * instance by copy-constructing the provided const T& t.
+             *
+             * Preconditions for tester.WithInitialValue(const T& t):
+             *
+             * - The const T& t object must be copy-constructible where T is the type
+             *   being tested. For non-copy-constructible objects, use the method
+             *   tester.WithFactory(...).
+             */
+            template<typename T>
+            ExceptionSafetyTestBuilder<DefaultFactory<T>, Operation, Contracts...>
+                WithInitialValue(const T& t) const
+            {
+                return WithFactory(DefaultFactory<T>(t));
+            }
+
+            /*
+             * Returns a new ExceptionSafetyTestBuilder with the provided T factory
+             * included. The existing factory will not be included in the newly-created
+             * tester instance. This method is intended for use with types lacking a copy
+             * constructor. Types that can be copy-constructed should instead use the
+             * method tester.WithInitialValue(...).
+             */
+            template<typename NewFactory>
+            ExceptionSafetyTestBuilder<absl::decay_t<NewFactory>, Operation, Contracts...>
+                WithFactory(const NewFactory& new_factory) const
+            {
+                return {new_factory, operation_, contracts_};
+            }
+
+            /*
+             * Returns a new ExceptionSafetyTestBuilder with the provided testable
+             * operation included. The existing operation will not be included in the
+             * newly created tester.
+             */
+            template<typename NewOperation>
+            ExceptionSafetyTestBuilder<Factory, absl::decay_t<NewOperation>, Contracts...>
+                WithOperation(const NewOperation& new_operation) const
+            {
+                return {factory_, new_operation, contracts_};
+            }
+
+            /*
+             * Returns a new ExceptionSafetyTestBuilder with the provided MoreContracts...
+             * combined with the Contracts... that were already included in the instance
+             * on which the method was called. Contracts... cannot be removed or replaced
+             * once added to an ExceptionSafetyTestBuilder instance. A fresh object must
+             * be created in order to get an empty Contracts... list.
+             *
+             * In addition to passing in custom contract assertion callbacks, this method
+             * accepts `testing::strong_guarantee` as an argument which checks T instances
+             * post-throw against freshly created T instances via operator== to verify
+             * that any state changes made during the execution of the operation were
+             * properly rolled back.
+             */
+            template<typename... MoreContracts>
+            ExceptionSafetyTestBuilder<Factory, Operation, Contracts..., absl::decay_t<MoreContracts>...>
+                WithContracts(const MoreContracts&... more_contracts) const
+            {
+                return {
+                    factory_, operation_, std::tuple_cat(contracts_, std::tuple<absl::decay_t<MoreContracts>...>(more_contracts...))};
+            }
+
+            /*
+             * Returns a testing::AssertionResult that is the reduced result of the
+             * exception safety algorithm. The algorithm short circuits and returns
+             * AssertionFailure after the first contract callback returns an
+             * AssertionFailure. Otherwise, if all contract callbacks return an
+             * AssertionSuccess, the reduced result is AssertionSuccess.
+             *
+             * The passed-in testable operation will not be saved in a new tester instance
+             * nor will it modify/replace the existing tester instance. This is useful
+             * when each operation being tested is unique and does not need to be reused.
+             *
+             * Preconditions for tester.Test(const NewOperation& new_operation):
+             *
+             * - May only be called after at least one contract assertion callback and a
+             *   factory or initial value have been provided.
+             */
+            template<
+                typename NewOperation,
+                typename = EnableIfTestable<sizeof...(Contracts), Factory, NewOperation>>
+            testing::AssertionResult Test(const NewOperation& new_operation) const
+            {
+                return TestImpl(new_operation, absl::index_sequence_for<Contracts...>());
+            }
+
+            /*
+             * Returns a testing::AssertionResult that is the reduced result of the
+             * exception safety algorithm. The algorithm short circuits and returns
+             * AssertionFailure after the first contract callback returns an
+             * AssertionFailure. Otherwise, if all contract callbacks return an
+             * AssertionSuccess, the reduced result is AssertionSuccess.
+             *
+             * Preconditions for tester.Test():
+             *
+             * - May only be called after at least one contract assertion callback, a
+             *   factory or initial value and a testable operation have been provided.
+             */
+            template<
+                typename LazyOperation = Operation,
+                typename = EnableIfTestable<sizeof...(Contracts), Factory, LazyOperation>>
+            testing::AssertionResult Test() const
+            {
+                return Test(operation_);
+            }
+
+        private:
+            template<typename, typename, typename...>
+            friend class ExceptionSafetyTestBuilder;
+
+            friend ExceptionSafetyTestBuilder<> testing::MakeExceptionSafetyTester();
+
+            ExceptionSafetyTestBuilder()
+            {
+            }
+
+            ExceptionSafetyTestBuilder(const Factory& f, const Operation& o, const std::tuple<Contracts...>& i) :
+                factory_(f),
+                operation_(o),
+                contracts_(i)
+            {
+            }
+
+            template<typename SelectedOperation, size_t... Indices>
+            testing::AssertionResult TestImpl(SelectedOperation selected_operation, absl::index_sequence<Indices...>) const
+            {
+                return ExceptionSafetyTest<FactoryElementType<Factory>>(
+                           factory_, selected_operation, std::get<Indices>(contracts_)...
+                )
+                    .Test();
+            }
+
+            Factory factory_;
+            Operation operation_;
+            std::tuple<Contracts...> contracts_;
+        };
+
+    }  // namespace exceptions_internal
 
 }  // namespace testing
 
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/exception_testing.h b/CAPI/cpp/grpc/include/absl/base/internal/exception_testing.h
index 01b5465..4ac46ad 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/exception_testing.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/exception_testing.h
@@ -26,16 +26,16 @@
 #ifdef ABSL_HAVE_EXCEPTIONS
 
 #define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
-  EXPECT_THROW(expr, exception_t)
+    EXPECT_THROW(expr, exception_t)
 
 #elif defined(__ANDROID__)
 // Android asserts do not log anywhere that gtest can currently inspect.
 // So we expect exit, but cannot match the message.
 #define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
-  EXPECT_DEATH(expr, ".*")
+    EXPECT_DEATH(expr, ".*")
 #else
 #define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
-  EXPECT_DEATH_IF_SUPPORTED(expr, text)
+    EXPECT_DEATH_IF_SUPPORTED(expr, text)
 
 #endif
 
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/fast_type_id.h b/CAPI/cpp/grpc/include/absl/base/internal/fast_type_id.h
index a547b3a..6f199d1 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/fast_type_id.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/fast_type_id.h
@@ -19,32 +19,36 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-template <typename Type>
-struct FastTypeTag {
-  constexpr static char dummy_var = 0;
-};
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        template<typename Type>
+        struct FastTypeTag
+        {
+            constexpr static char dummy_var = 0;
+        };
 
 #ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-template <typename Type>
-constexpr char FastTypeTag<Type>::dummy_var;
+        template<typename Type>
+        constexpr char FastTypeTag<Type>::dummy_var;
 #endif
 
-// FastTypeId<Type>() evaluates at compile/link-time to a unique pointer for the
-// passed-in type. These are meant to be good match for keys into maps or
-// straight up comparisons.
-using FastTypeIdType = const void*;
+        // FastTypeId<Type>() evaluates at compile/link-time to a unique pointer for the
+        // passed-in type. These are meant to be good match for keys into maps or
+        // straight up comparisons.
+        using FastTypeIdType = const void*;
 
-template <typename Type>
-constexpr inline FastTypeIdType FastTypeId() {
-  return &FastTypeTag<Type>::dummy_var;
-}
+        template<typename Type>
+        constexpr inline FastTypeIdType FastTypeId()
+        {
+            return &FastTypeTag<Type>::dummy_var;
+        }
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/hide_ptr.h b/CAPI/cpp/grpc/include/absl/base/internal/hide_ptr.h
index 1dba809..4249bc2 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/hide_ptr.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/hide_ptr.h
@@ -19,33 +19,38 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// Arbitrary value with high bits set. Xor'ing with it is unlikely
-// to map one valid pointer to another valid pointer.
-constexpr uintptr_t HideMask() {
-  return (uintptr_t{0xF03A5F7BU} << (sizeof(uintptr_t) - 4) * 8) | 0xF03A5F7BU;
-}
-
-// Hide a pointer from the leak checker. For internal use only.
-// Differs from absl::IgnoreLeak(ptr) in that absl::IgnoreLeak(ptr) causes ptr
-// and all objects reachable from ptr to be ignored by the leak checker.
-template <class T>
-inline uintptr_t HidePtr(T* ptr) {
-  return reinterpret_cast<uintptr_t>(ptr) ^ HideMask();
-}
-
-// Return a pointer that has been hidden from the leak checker.
-// For internal use only.
-template <class T>
-inline T* UnhidePtr(uintptr_t hidden) {
-  return reinterpret_cast<T*>(hidden ^ HideMask());
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        // Arbitrary value with high bits set. Xor'ing with it is unlikely
+        // to map one valid pointer to another valid pointer.
+        constexpr uintptr_t HideMask()
+        {
+            return (uintptr_t{0xF03A5F7BU} << (sizeof(uintptr_t) - 4) * 8) | 0xF03A5F7BU;
+        }
+
+        // Hide a pointer from the leak checker. For internal use only.
+        // Differs from absl::IgnoreLeak(ptr) in that absl::IgnoreLeak(ptr) causes ptr
+        // and all objects reachable from ptr to be ignored by the leak checker.
+        template<class T>
+        inline uintptr_t HidePtr(T* ptr)
+        {
+            return reinterpret_cast<uintptr_t>(ptr) ^ HideMask();
+        }
+
+        // Return a pointer that has been hidden from the leak checker.
+        // For internal use only.
+        template<class T>
+        inline T* UnhidePtr(uintptr_t hidden)
+        {
+            return reinterpret_cast<T*>(hidden ^ HideMask());
+        }
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_HIDE_PTR_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/identity.h b/CAPI/cpp/grpc/include/absl/base/internal/identity.h
index a3154ed..d62e556 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/identity.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/identity.h
@@ -18,20 +18,23 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace internal
+    {
 
-template <typename T>
-struct identity {
-  typedef T type;
-};
+        template<typename T>
+        struct identity
+        {
+            typedef T type;
+        };
 
-template <typename T>
-using identity_t = typename identity<T>::type;
+        template<typename T>
+        using identity_t = typename identity<T>::type;
 
-}  // namespace internal
-ABSL_NAMESPACE_END
+    }  // namespace internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_IDENTITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/inline_variable.h b/CAPI/cpp/grpc/include/absl/base/internal/inline_variable.h
index 130d8c2..1ebd4b7 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/inline_variable.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/inline_variable.h
@@ -68,15 +68,15 @@
 //   types, etc..
 #if defined(__clang__)
 #define ABSL_INTERNAL_EXTERN_DECL(type, name) \
-  extern const ::absl::internal::identity_t<type> name;
+    extern const ::absl::internal::identity_t<type> name;
 #else  // Otherwise, just define the macro to do nothing.
 #define ABSL_INTERNAL_EXTERN_DECL(type, name)
 #endif  // defined(__clang__)
 
 // See above comment at top of file for details.
 #define ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
-  ABSL_INTERNAL_EXTERN_DECL(type, name)                  \
-  inline constexpr ::absl::internal::identity_t<type> name = init
+    ABSL_INTERNAL_EXTERN_DECL(type, name)                \
+    inline constexpr ::absl::internal::identity_t<type> name = init
 
 #else
 
@@ -86,21 +86,21 @@
 //   identity_t is used here so that the const and name are in the
 //   appropriate place for pointer types, reference types, function pointer
 //   types, etc..
-#define ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                  \
-  template <class /*AbslInternalDummy*/ = void>                               \
-  struct AbslInternalInlineVariableHolder##name {                             \
-    static constexpr ::absl::internal::identity_t<var_type> kInstance = init; \
-  };                                                                          \
-                                                                              \
-  template <class AbslInternalDummy>                                          \
-  constexpr ::absl::internal::identity_t<var_type>                            \
-      AbslInternalInlineVariableHolder##name<AbslInternalDummy>::kInstance;   \
-                                                                              \
-  static constexpr const ::absl::internal::identity_t<var_type>&              \
-      name = /* NOLINT */                                                     \
-      AbslInternalInlineVariableHolder##name<>::kInstance;                    \
-  static_assert(sizeof(void (*)(decltype(name))) != 0,                        \
-                "Silence unused variable warnings.")
+#define ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                      \
+    template<class /*AbslInternalDummy*/ = void>                                  \
+    struct AbslInternalInlineVariableHolder##name                                 \
+    {                                                                             \
+        static constexpr ::absl::internal::identity_t<var_type> kInstance = init; \
+    };                                                                            \
+                                                                                  \
+    template<class AbslInternalDummy>                                             \
+    constexpr ::absl::internal::identity_t<var_type>                              \
+        AbslInternalInlineVariableHolder##name<AbslInternalDummy>::kInstance;     \
+                                                                                  \
+    static constexpr const ::absl::internal::identity_t<var_type>&                \
+        name = /* NOLINT */                                                       \
+        AbslInternalInlineVariableHolder##name<>::kInstance;                      \
+    static_assert(sizeof(void (*)(decltype(name))) != 0, "Silence unused variable warnings.")
 
 #endif  // __cpp_inline_variables
 
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/inline_variable_testing.h b/CAPI/cpp/grpc/include/absl/base/internal/inline_variable_testing.h
index 3856b9f..a9878f5 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/inline_variable_testing.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/inline_variable_testing.h
@@ -17,30 +17,33 @@
 
 #include "absl/base/internal/inline_variable.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace inline_variable_testing_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace inline_variable_testing_internal
+    {
 
-struct Foo {
-  int value = 5;
-};
+        struct Foo
+        {
+            int value = 5;
+        };
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, inline_variable_foo, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, other_inline_variable_foo, {});
+        ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, inline_variable_foo, {});
+        ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, other_inline_variable_foo, {});
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(int, inline_variable_int, 5);
-ABSL_INTERNAL_INLINE_CONSTEXPR(int, other_inline_variable_int, 5);
+        ABSL_INTERNAL_INLINE_CONSTEXPR(int, inline_variable_int, 5);
+        ABSL_INTERNAL_INLINE_CONSTEXPR(int, other_inline_variable_int, 5);
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(void(*)(), inline_variable_fun_ptr, nullptr);
+        ABSL_INTERNAL_INLINE_CONSTEXPR(void (*)(), inline_variable_fun_ptr, nullptr);
 
-const Foo& get_foo_a();
-const Foo& get_foo_b();
+        const Foo& get_foo_a();
+        const Foo& get_foo_b();
 
-const int& get_int_a();
-const int& get_int_b();
+        const int& get_int_a();
+        const int& get_int_b();
 
-}  // namespace inline_variable_testing_internal
-ABSL_NAMESPACE_END
+    }  // namespace inline_variable_testing_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INLINE_VARIABLE_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/invoke.h b/CAPI/cpp/grpc/include/absl/base/internal/invoke.h
index 643c2a4..2316378 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/invoke.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/invoke.h
@@ -43,16 +43,18 @@
 
 #include <functional>
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-using std::invoke;
-using std::invoke_result_t;
-using std::is_invocable_r;
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        using std::invoke;
+        using std::invoke_result_t;
+        using std::is_invocable_r;
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
@@ -66,42 +68,48 @@ ABSL_NAMESPACE_END
 // The following code is internal implementation detail.  See the comment at the
 // top of this file for the API documentation.
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// The five classes below each implement one of the clauses from the definition
-// of INVOKE. The inner class template Accept<F, Args...> checks whether the
-// clause is applicable; static function template Invoke(f, args...) does the
-// invocation.
-//
-// By separating the clause selection logic from invocation we make sure that
-// Invoke() does exactly what the standard says.
-
-template <typename Derived>
-struct StrippedAccept {
-  template <typename... Args>
-  struct Accept : Derived::template AcceptImpl<typename std::remove_cv<
-                      typename std::remove_reference<Args>::type>::type...> {};
-};
-
-// (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
-// and t1 is an object of type T or a reference to an object of type T or a
-// reference to an object of a type derived from T.
-struct MemFunAndRef : StrippedAccept<MemFunAndRef> {
-  template <typename... Args>
-  struct AcceptImpl : std::false_type {};
-
-  template <typename MemFunType, typename C, typename Obj, typename... Args>
-  struct AcceptImpl<MemFunType C::*, Obj, Args...>
-      : std::integral_constant<bool, std::is_base_of<C, Obj>::value &&
-                                         absl::is_function<MemFunType>::value> {
-  };
-
-  template <typename MemFun, typename Obj, typename... Args>
-  static decltype((std::declval<Obj>().*
-                   std::declval<MemFun>())(std::declval<Args>()...))
-  Invoke(MemFun&& mem_fun, Obj&& obj, Args&&... args) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        // The five classes below each implement one of the clauses from the definition
+        // of INVOKE. The inner class template Accept<F, Args...> checks whether the
+        // clause is applicable; static function template Invoke(f, args...) does the
+        // invocation.
+        //
+        // By separating the clause selection logic from invocation we make sure that
+        // Invoke() does exactly what the standard says.
+
+        template<typename Derived>
+        struct StrippedAccept
+        {
+            template<typename... Args>
+            struct Accept : Derived::template AcceptImpl<typename std::remove_cv<typename std::remove_reference<Args>::type>::type...>
+            {
+            };
+        };
+
+        // (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
+        // and t1 is an object of type T or a reference to an object of type T or a
+        // reference to an object of a type derived from T.
+        struct MemFunAndRef : StrippedAccept<MemFunAndRef>
+        {
+            template<typename... Args>
+            struct AcceptImpl : std::false_type
+            {
+            };
+
+            template<typename MemFunType, typename C, typename Obj, typename... Args>
+            struct AcceptImpl<MemFunType C::*, Obj, Args...> : std::integral_constant<bool, std::is_base_of<C, Obj>::value && absl::is_function<MemFunType>::value>
+            {
+            };
+
+            template<typename MemFun, typename Obj, typename... Args>
+            static decltype((std::declval<Obj>().*std::declval<MemFun>())(std::declval<Args>()...))
+                Invoke(MemFun&& mem_fun, Obj&& obj, Args&&... args)
+            {
 // Ignore bogus GCC warnings on this line.
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101436 for similar example.
 #if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(11, 0)
@@ -109,131 +117,149 @@ struct MemFunAndRef : StrippedAccept<MemFunAndRef> {
 #pragma GCC diagnostic ignored "-Warray-bounds"
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #endif
-    return (std::forward<Obj>(obj).*
-            std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+                return (std::forward<Obj>(obj).*std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
 #if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(11, 0)
 #pragma GCC diagnostic pop
 #endif
-  }
-};
-
-// ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
-// class T and t1 is not one of the types described in the previous item.
-struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> {
-  template <typename... Args>
-  struct AcceptImpl : std::false_type {};
-
-  template <typename MemFunType, typename C, typename Ptr, typename... Args>
-  struct AcceptImpl<MemFunType C::*, Ptr, Args...>
-      : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value &&
-                                         absl::is_function<MemFunType>::value> {
-  };
-
-  template <typename MemFun, typename Ptr, typename... Args>
-  static decltype(((*std::declval<Ptr>()).*
-                   std::declval<MemFun>())(std::declval<Args>()...))
-  Invoke(MemFun&& mem_fun, Ptr&& ptr, Args&&... args) {
-    return ((*std::forward<Ptr>(ptr)).*
-            std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
-  }
-};
-
-// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
-// an object of type T or a reference to an object of type T or a reference
-// to an object of a type derived from T.
-struct DataMemAndRef : StrippedAccept<DataMemAndRef> {
-  template <typename... Args>
-  struct AcceptImpl : std::false_type {};
-
-  template <typename R, typename C, typename Obj>
-  struct AcceptImpl<R C::*, Obj>
-      : std::integral_constant<bool, std::is_base_of<C, Obj>::value &&
-                                         !absl::is_function<R>::value> {};
-
-  template <typename DataMem, typename Ref>
-  static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke(
-      DataMem&& data_mem, Ref&& ref) {
-    return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
-  }
-};
-
-// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
-// is not one of the types described in the previous item.
-struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> {
-  template <typename... Args>
-  struct AcceptImpl : std::false_type {};
-
-  template <typename R, typename C, typename Ptr>
-  struct AcceptImpl<R C::*, Ptr>
-      : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value &&
-                                         !absl::is_function<R>::value> {};
-
-  template <typename DataMem, typename Ptr>
-  static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke(
-      DataMem&& data_mem, Ptr&& ptr) {
-    return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
-  }
-};
-
-// f(t1, t2, ..., tN) in all other cases.
-struct Callable {
-  // Callable doesn't have Accept because it's the last clause that gets picked
-  // when none of the previous clauses are applicable.
-  template <typename F, typename... Args>
-  static decltype(std::declval<F>()(std::declval<Args>()...)) Invoke(
-      F&& f, Args&&... args) {
-    return std::forward<F>(f)(std::forward<Args>(args)...);
-  }
-};
-
-// Resolves to the first matching clause.
-template <typename... Args>
-struct Invoker {
-  typedef typename std::conditional<
-      MemFunAndRef::Accept<Args...>::value, MemFunAndRef,
-      typename std::conditional<
-          MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr,
-          typename std::conditional<
-              DataMemAndRef::Accept<Args...>::value, DataMemAndRef,
-              typename std::conditional<DataMemAndPtr::Accept<Args...>::value,
-                                        DataMemAndPtr, Callable>::type>::type>::
-          type>::type type;
-};
-
-// The result type of Invoke<F, Args...>.
-template <typename F, typename... Args>
-using invoke_result_t = decltype(Invoker<F, Args...>::type::Invoke(
-    std::declval<F>(), std::declval<Args>()...));
-
-// Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
-// [func.require] of the C++ standard.
-template <typename F, typename... Args>
-invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) {
-  return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
-                                           std::forward<Args>(args)...);
-}
-
-template <typename AlwaysVoid, typename, typename, typename...>
-struct IsInvocableRImpl : std::false_type {};
-
-template <typename R, typename F, typename... Args>
-struct IsInvocableRImpl<
-    absl::void_t<absl::base_internal::invoke_result_t<F, Args...> >, R, F,
-    Args...>
-    : std::integral_constant<
-          bool,
-          std::is_convertible<absl::base_internal::invoke_result_t<F, Args...>,
-                              R>::value ||
-              std::is_void<R>::value> {};
-
-// Type trait whose member `value` is true if invoking `F` with `Args` is valid,
-// and either the return type is convertible to `R`, or `R` is void.
-// C++11-compatible version of `std::is_invocable_r`.
-template <typename R, typename F, typename... Args>
-using is_invocable_r = IsInvocableRImpl<void, R, F, Args...>;
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+            }
+        };
+
+        // ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
+        // class T and t1 is not one of the types described in the previous item.
+        struct MemFunAndPtr : StrippedAccept<MemFunAndPtr>
+        {
+            template<typename... Args>
+            struct AcceptImpl : std::false_type
+            {
+            };
+
+            template<typename MemFunType, typename C, typename Ptr, typename... Args>
+            struct AcceptImpl<MemFunType C::*, Ptr, Args...> : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value && absl::is_function<MemFunType>::value>
+            {
+            };
+
+            template<typename MemFun, typename Ptr, typename... Args>
+            static decltype(((*std::declval<Ptr>()).*std::declval<MemFun>())(std::declval<Args>()...))
+                Invoke(MemFun&& mem_fun, Ptr&& ptr, Args&&... args)
+            {
+                return ((*std::forward<Ptr>(ptr)).*std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+            }
+        };
+
+        // t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
+        // an object of type T or a reference to an object of type T or a reference
+        // to an object of a type derived from T.
+        struct DataMemAndRef : StrippedAccept<DataMemAndRef>
+        {
+            template<typename... Args>
+            struct AcceptImpl : std::false_type
+            {
+            };
+
+            template<typename R, typename C, typename Obj>
+            struct AcceptImpl<R C::*, Obj> : std::integral_constant<bool, std::is_base_of<C, Obj>::value && !absl::is_function<R>::value>
+            {
+            };
+
+            template<typename DataMem, typename Ref>
+            static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke(
+                DataMem&& data_mem, Ref&& ref
+            )
+            {
+                return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
+            }
+        };
+
+        // (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
+        // is not one of the types described in the previous item.
+        struct DataMemAndPtr : StrippedAccept<DataMemAndPtr>
+        {
+            template<typename... Args>
+            struct AcceptImpl : std::false_type
+            {
+            };
+
+            template<typename R, typename C, typename Ptr>
+            struct AcceptImpl<R C::*, Ptr> : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value && !absl::is_function<R>::value>
+            {
+            };
+
+            template<typename DataMem, typename Ptr>
+            static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke(
+                DataMem&& data_mem, Ptr&& ptr
+            )
+            {
+                return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
+            }
+        };
+
+        // f(t1, t2, ..., tN) in all other cases.
+        struct Callable
+        {
+            // Callable doesn't have Accept because it's the last clause that gets picked
+            // when none of the previous clauses are applicable.
+            template<typename F, typename... Args>
+            static decltype(std::declval<F>()(std::declval<Args>()...)) Invoke(
+                F&& f, Args&&... args
+            )
+            {
+                return std::forward<F>(f)(std::forward<Args>(args)...);
+            }
+        };
+
+        // Resolves to the first matching clause.
+        template<typename... Args>
+        struct Invoker
+        {
+            typedef typename std::conditional<
+                MemFunAndRef::Accept<Args...>::value,
+                MemFunAndRef,
+                typename std::conditional<
+                    MemFunAndPtr::Accept<Args...>::value,
+                    MemFunAndPtr,
+                    typename std::conditional<
+                        DataMemAndRef::Accept<Args...>::value,
+                        DataMemAndRef,
+                        typename std::conditional<DataMemAndPtr::Accept<Args...>::value, DataMemAndPtr, Callable>::type>::type>::
+                    type>::type type;
+        };
+
+        // The result type of Invoke<F, Args...>.
+        template<typename F, typename... Args>
+        using invoke_result_t = decltype(Invoker<F, Args...>::type::Invoke(
+            std::declval<F>(), std::declval<Args>()...
+        ));
+
+        // Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
+        // [func.require] of the C++ standard.
+        template<typename F, typename... Args>
+        invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
+        {
+            return Invoker<F, Args...>::type::Invoke(std::forward<F>(f), std::forward<Args>(args)...);
+        }
+
+        template<typename AlwaysVoid, typename, typename, typename...>
+        struct IsInvocableRImpl : std::false_type
+        {
+        };
+
+        template<typename R, typename F, typename... Args>
+        struct IsInvocableRImpl<
+            absl::void_t<absl::base_internal::invoke_result_t<F, Args...>>,
+            R,
+            F,
+            Args...> : std::integral_constant<bool, std::is_convertible<absl::base_internal::invoke_result_t<F, Args...>, R>::value || std::is_void<R>::value>
+        {
+        };
+
+        // Type trait whose member `value` is true if invoking `F` with `Args` is valid,
+        // and either the return type is convertible to `R`, or `R` is void.
+        // C++11-compatible version of `std::is_invocable_r`.
+        template<typename R, typename F, typename... Args>
+        using is_invocable_r = IsInvocableRImpl<void, R, F, Args...>;
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/low_level_alloc.h b/CAPI/cpp/grpc/include/absl/base/internal/low_level_alloc.h
index db91951..95a2d1f 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/low_level_alloc.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/low_level_alloc.h
@@ -54,73 +54,77 @@
 
 #include "absl/base/port.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class LowLevelAlloc {
- public:
-  struct Arena;       // an arena from which memory may be allocated
-
-  // Returns a pointer to a block of at least "request" bytes
-  // that have been newly allocated from the specific arena.
-  // for Alloc() call the DefaultArena() is used.
-  // Returns 0 if passed request==0.
-  // Does not return 0 under other circumstances; it crashes if memory
-  // is not available.
-  static void *Alloc(size_t request) ABSL_ATTRIBUTE_SECTION(malloc_hook);
-  static void *AllocWithArena(size_t request, Arena *arena)
-      ABSL_ATTRIBUTE_SECTION(malloc_hook);
-
-  // Deallocates a region of memory that was previously allocated with
-  // Alloc().   Does nothing if passed 0.   "s" must be either 0,
-  // or must have been returned from a call to Alloc() and not yet passed to
-  // Free() since that call to Alloc().  The space is returned to the arena
-  // from which it was allocated.
-  static void Free(void *s) ABSL_ATTRIBUTE_SECTION(malloc_hook);
-
-  // ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
-  // are to put all callers of MallocHook::Invoke* in this module
-  // into special section,
-  // so that MallocHook::GetCallerStackTrace can function accurately.
-
-  // Create a new arena.
-  // The root metadata for the new arena is allocated in the
-  // meta_data_arena; the DefaultArena() can be passed for meta_data_arena.
-  // These values may be ored into flags:
-  enum {
-    // Report calls to Alloc() and Free() via the MallocHook interface.
-    // Set in the DefaultArena.
-    kCallMallocHook = 0x0001,
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        class LowLevelAlloc
+        {
+        public:
+            struct Arena;  // an arena from which memory may be allocated
+
+            // Returns a pointer to a block of at least "request" bytes
+            // that have been newly allocated from the specific arena.
+            // for Alloc() call the DefaultArena() is used.
+            // Returns 0 if passed request==0.
+            // Does not return 0 under other circumstances; it crashes if memory
+            // is not available.
+            static void* Alloc(size_t request) ABSL_ATTRIBUTE_SECTION(malloc_hook);
+            static void* AllocWithArena(size_t request, Arena* arena)
+                ABSL_ATTRIBUTE_SECTION(malloc_hook);
+
+            // Deallocates a region of memory that was previously allocated with
+            // Alloc().   Does nothing if passed 0.   "s" must be either 0,
+            // or must have been returned from a call to Alloc() and not yet passed to
+            // Free() since that call to Alloc().  The space is returned to the arena
+            // from which it was allocated.
+            static void Free(void* s) ABSL_ATTRIBUTE_SECTION(malloc_hook);
+
+            // ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
+            // are to put all callers of MallocHook::Invoke* in this module
+            // into special section,
+            // so that MallocHook::GetCallerStackTrace can function accurately.
+
+            // Create a new arena.
+            // The root metadata for the new arena is allocated in the
+            // meta_data_arena; the DefaultArena() can be passed for meta_data_arena.
+            // These values may be ored into flags:
+            enum
+            {
+                // Report calls to Alloc() and Free() via the MallocHook interface.
+                // Set in the DefaultArena.
+                kCallMallocHook = 0x0001,
 
 #ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
-    // Make calls to Alloc(), Free() be async-signal-safe. Not set in
-    // DefaultArena(). Not supported on all platforms.
-    kAsyncSignalSafe = 0x0002,
+                // Make calls to Alloc(), Free() be async-signal-safe. Not set in
+                // DefaultArena(). Not supported on all platforms.
+                kAsyncSignalSafe = 0x0002,
 #endif
-  };
-  // Construct a new arena.  The allocation of the underlying metadata honors
-  // the provided flags.  For example, the call NewArena(kAsyncSignalSafe)
-  // is itself async-signal-safe, as well as generatating an arena that provides
-  // async-signal-safe Alloc/Free.
-  static Arena *NewArena(int32_t flags);
-
-  // Destroys an arena allocated by NewArena and returns true,
-  // provided no allocated blocks remain in the arena.
-  // If allocated blocks remain in the arena, does nothing and
-  // returns false.
-  // It is illegal to attempt to destroy the DefaultArena().
-  static bool DeleteArena(Arena *arena);
-
-  // The default arena that always exists.
-  static Arena *DefaultArena();
-
- private:
-  LowLevelAlloc();      // no instances
-};
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+            };
+            // Construct a new arena.  The allocation of the underlying metadata honors
+            // the provided flags.  For example, the call NewArena(kAsyncSignalSafe)
+            // is itself async-signal-safe, as well as generatating an arena that provides
+            // async-signal-safe Alloc/Free.
+            static Arena* NewArena(int32_t flags);
+
+            // Destroys an arena allocated by NewArena and returns true,
+            // provided no allocated blocks remain in the arena.
+            // If allocated blocks remain in the arena, does nothing and
+            // returns false.
+            // It is illegal to attempt to destroy the DefaultArena().
+            static bool DeleteArena(Arena* arena);
+
+            // The default arena that always exists.
+            static Arena* DefaultArena();
+
+        private:
+            LowLevelAlloc();  // no instances
+        };
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/low_level_scheduling.h b/CAPI/cpp/grpc/include/absl/base/internal/low_level_scheduling.h
index 9baccc0..ed2f311 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/low_level_scheduling.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/low_level_scheduling.h
@@ -28,107 +28,125 @@
 extern "C" bool __google_disable_rescheduling(void);
 extern "C" void __google_enable_rescheduling(bool disable_result);
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-class CondVar;
-class Mutex;
-
-namespace synchronization_internal {
-int MutexDelay(int32_t c, int mode);
-}  // namespace synchronization_internal
-
-namespace base_internal {
-
-class SchedulingHelper;  // To allow use of SchedulingGuard.
-class SpinLock;          // To allow use of SchedulingGuard.
-
-// SchedulingGuard
-// Provides guard semantics that may be used to disable cooperative rescheduling
-// of the calling thread within specific program blocks.  This is used to
-// protect resources (e.g. low-level SpinLocks or Domain code) that cooperative
-// scheduling depends on.
-//
-// Domain implementations capable of rescheduling in reaction to involuntary
-// kernel thread actions (e.g blocking due to a pagefault or syscall) must
-// guarantee that an annotated thread is not allowed to (cooperatively)
-// reschedule until the annotated region is complete.
-//
-// It is an error to attempt to use a cooperatively scheduled resource (e.g.
-// Mutex) within a rescheduling-disabled region.
-//
-// All methods are async-signal safe.
-class SchedulingGuard {
- public:
-  // Returns true iff the calling thread may be cooperatively rescheduled.
-  static bool ReschedulingIsAllowed();
-  SchedulingGuard(const SchedulingGuard&) = delete;
-  SchedulingGuard& operator=(const SchedulingGuard&) = delete;
-
- private:
-  // Disable cooperative rescheduling of the calling thread.  It may still
-  // initiate scheduling operations (e.g. wake-ups), however, it may not itself
-  // reschedule.  Nestable.  The returned result is opaque, clients should not
-  // attempt to interpret it.
-  // REQUIRES: Result must be passed to a pairing EnableScheduling().
-  static bool DisableRescheduling();
-
-  // Marks the end of a rescheduling disabled region, previously started by
-  // DisableRescheduling().
-  // REQUIRES: Pairs with innermost call (and result) of DisableRescheduling().
-  static void EnableRescheduling(bool disable_result);
-
-  // A scoped helper for {Disable, Enable}Rescheduling().
-  // REQUIRES: destructor must run in same thread as constructor.
-  struct ScopedDisable {
-    ScopedDisable() { disabled = SchedulingGuard::DisableRescheduling(); }
-    ~ScopedDisable() { SchedulingGuard::EnableRescheduling(disabled); }
-
-    bool disabled;
-  };
-
-  // A scoped helper to enable rescheduling temporarily.
-  // REQUIRES: destructor must run in same thread as constructor.
-  class ScopedEnable {
-   public:
-    ScopedEnable();
-    ~ScopedEnable();
-
-   private:
-    int scheduling_disabled_depth_;
-  };
-
-  // Access to SchedulingGuard is explicitly permitted.
-  friend class absl::CondVar;
-  friend class absl::Mutex;
-  friend class SchedulingHelper;
-  friend class SpinLock;
-  friend int absl::synchronization_internal::MutexDelay(int32_t c, int mode);
-};
-
-//------------------------------------------------------------------------------
-// End of public interfaces.
-//------------------------------------------------------------------------------
-
-inline bool SchedulingGuard::ReschedulingIsAllowed() {
-  return false;
-}
-
-inline bool SchedulingGuard::DisableRescheduling() {
-  return false;
-}
-
-inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
-  return;
-}
-
-inline SchedulingGuard::ScopedEnable::ScopedEnable()
-    : scheduling_disabled_depth_(0) {}
-inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
-  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    class CondVar;
+    class Mutex;
+
+    namespace synchronization_internal
+    {
+        int MutexDelay(int32_t c, int mode);
+    }  // namespace synchronization_internal
+
+    namespace base_internal
+    {
+
+        class SchedulingHelper;  // To allow use of SchedulingGuard.
+        class SpinLock;          // To allow use of SchedulingGuard.
+
+        // SchedulingGuard
+        // Provides guard semantics that may be used to disable cooperative rescheduling
+        // of the calling thread within specific program blocks.  This is used to
+        // protect resources (e.g. low-level SpinLocks or Domain code) that cooperative
+        // scheduling depends on.
+        //
+        // Domain implementations capable of rescheduling in reaction to involuntary
+        // kernel thread actions (e.g blocking due to a pagefault or syscall) must
+        // guarantee that an annotated thread is not allowed to (cooperatively)
+        // reschedule until the annotated region is complete.
+        //
+        // It is an error to attempt to use a cooperatively scheduled resource (e.g.
+        // Mutex) within a rescheduling-disabled region.
+        //
+        // All methods are async-signal safe.
+        class SchedulingGuard
+        {
+        public:
+            // Returns true iff the calling thread may be cooperatively rescheduled.
+            static bool ReschedulingIsAllowed();
+            SchedulingGuard(const SchedulingGuard&) = delete;
+            SchedulingGuard& operator=(const SchedulingGuard&) = delete;
+
+        private:
+            // Disable cooperative rescheduling of the calling thread.  It may still
+            // initiate scheduling operations (e.g. wake-ups), however, it may not itself
+            // reschedule.  Nestable.  The returned result is opaque, clients should not
+            // attempt to interpret it.
+            // REQUIRES: Result must be passed to a pairing EnableScheduling().
+            static bool DisableRescheduling();
+
+            // Marks the end of a rescheduling disabled region, previously started by
+            // DisableRescheduling().
+            // REQUIRES: Pairs with innermost call (and result) of DisableRescheduling().
+            static void EnableRescheduling(bool disable_result);
+
+            // A scoped helper for {Disable, Enable}Rescheduling().
+            // REQUIRES: destructor must run in same thread as constructor.
+            struct ScopedDisable
+            {
+                ScopedDisable()
+                {
+                    disabled = SchedulingGuard::DisableRescheduling();
+                }
+                ~ScopedDisable()
+                {
+                    SchedulingGuard::EnableRescheduling(disabled);
+                }
+
+                bool disabled;
+            };
+
+            // A scoped helper to enable rescheduling temporarily.
+            // REQUIRES: destructor must run in same thread as constructor.
+            class ScopedEnable
+            {
+            public:
+                ScopedEnable();
+                ~ScopedEnable();
+
+            private:
+                int scheduling_disabled_depth_;
+            };
+
+            // Access to SchedulingGuard is explicitly permitted.
+            friend class absl::CondVar;
+            friend class absl::Mutex;
+            friend class SchedulingHelper;
+            friend class SpinLock;
+            friend int absl::synchronization_internal::MutexDelay(int32_t c, int mode);
+        };
+
+        //------------------------------------------------------------------------------
+        // End of public interfaces.
+        //------------------------------------------------------------------------------
+
+        inline bool SchedulingGuard::ReschedulingIsAllowed()
+        {
+            return false;
+        }
+
+        inline bool SchedulingGuard::DisableRescheduling()
+        {
+            return false;
+        }
+
+        inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */)
+        {
+            return;
+        }
+
+        inline SchedulingGuard::ScopedEnable::ScopedEnable() :
+            scheduling_disabled_depth_(0)
+        {
+        }
+        inline SchedulingGuard::ScopedEnable::~ScopedEnable()
+        {
+            ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
+        }
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/prefetch.h b/CAPI/cpp/grpc/include/absl/base/internal/prefetch.h
index 0641928..4176d0b 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/prefetch.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/prefetch.h
@@ -68,71 +68,89 @@
 //
 // SNB = Sandy Bridge, SKL = Skylake, SKX = Skylake Xeon.
 //
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-void PrefetchT0(const void* addr);
-void PrefetchT1(const void* addr);
-void PrefetchT2(const void* addr);
-void PrefetchNta(const void* addr);
+        void PrefetchT0(const void* addr);
+        void PrefetchT1(const void* addr);
+        void PrefetchT2(const void* addr);
+        void PrefetchNta(const void* addr);
 
-// Implementation details follow.
+        // Implementation details follow.
 
 #if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 
 #define ABSL_INTERNAL_HAVE_PREFETCH 1
 
-// See __builtin_prefetch:
-// https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html.
-//
-// These functions speculatively load for read only. This is
-// safe for all currently supported platforms. However, prefetch for
-// store may have problems depending on the target platform.
-//
-inline void PrefetchT0(const void* addr) {
-  // Note: this uses prefetcht0 on Intel.
-  __builtin_prefetch(addr, 0, 3);
-}
-inline void PrefetchT1(const void* addr) {
-  // Note: this uses prefetcht1 on Intel.
-  __builtin_prefetch(addr, 0, 2);
-}
-inline void PrefetchT2(const void* addr) {
-  // Note: this uses prefetcht2 on Intel.
-  __builtin_prefetch(addr, 0, 1);
-}
-inline void PrefetchNta(const void* addr) {
-  // Note: this uses prefetchtnta on Intel.
-  __builtin_prefetch(addr, 0, 0);
-}
+        // See __builtin_prefetch:
+        // https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html.
+        //
+        // These functions speculatively load for read only. This is
+        // safe for all currently supported platforms. However, prefetch for
+        // store may have problems depending on the target platform.
+        //
+        inline void PrefetchT0(const void* addr)
+        {
+            // Note: this uses prefetcht0 on Intel.
+            __builtin_prefetch(addr, 0, 3);
+        }
+        inline void PrefetchT1(const void* addr)
+        {
+            // Note: this uses prefetcht1 on Intel.
+            __builtin_prefetch(addr, 0, 2);
+        }
+        inline void PrefetchT2(const void* addr)
+        {
+            // Note: this uses prefetcht2 on Intel.
+            __builtin_prefetch(addr, 0, 1);
+        }
+        inline void PrefetchNta(const void* addr)
+        {
+            // Note: this uses prefetchtnta on Intel.
+            __builtin_prefetch(addr, 0, 0);
+        }
 
 #elif defined(ABSL_INTERNAL_HAVE_SSE)
 
 #define ABSL_INTERNAL_HAVE_PREFETCH 1
 
-inline void PrefetchT0(const void* addr) {
-  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T0);
-}
-inline void PrefetchT1(const void* addr) {
-  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T1);
-}
-inline void PrefetchT2(const void* addr) {
-  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T2);
-}
-inline void PrefetchNta(const void* addr) {
-  _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_NTA);
-}
+        inline void PrefetchT0(const void* addr)
+        {
+            _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T0);
+        }
+        inline void PrefetchT1(const void* addr)
+        {
+            _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T1);
+        }
+        inline void PrefetchT2(const void* addr)
+        {
+            _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_T2);
+        }
+        inline void PrefetchNta(const void* addr)
+        {
+            _mm_prefetch(reinterpret_cast<const char*>(addr), _MM_HINT_NTA);
+        }
 
 #else
-inline void PrefetchT0(const void*) {}
-inline void PrefetchT1(const void*) {}
-inline void PrefetchT2(const void*) {}
-inline void PrefetchNta(const void*) {}
+        inline void PrefetchT0(const void*)
+        {
+        }
+        inline void PrefetchT1(const void*)
+        {
+        }
+        inline void PrefetchT2(const void*)
+        {
+        }
+        inline void PrefetchNta(const void*)
+        {
+        }
 #endif
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_PREFETCH_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h b/CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h
index 0747c9d..1752d34 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/raw_logging.h
@@ -41,27 +41,27 @@
 // This will print an almost standard log line like this to stderr only:
 //   E0821 211317 file.cc:123] RAW: Failed foo with 22: bad_file
 
-#define ABSL_RAW_LOG(severity, ...)                                            \
-  do {                                                                         \
-    constexpr const char* absl_raw_logging_internal_basename =                 \
-        ::absl::raw_logging_internal::Basename(__FILE__,                       \
-                                               sizeof(__FILE__) - 1);          \
-    ::absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, \
-                                         absl_raw_logging_internal_basename,   \
-                                         __LINE__, __VA_ARGS__);               \
-  } while (0)
+#define ABSL_RAW_LOG(severity, ...)                                                                                                            \
+    do                                                                                                                                         \
+    {                                                                                                                                          \
+        constexpr const char* absl_raw_logging_internal_basename =                                                                             \
+            ::absl::raw_logging_internal::Basename(__FILE__, sizeof(__FILE__) - 1);                                                            \
+        ::absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, absl_raw_logging_internal_basename, __LINE__, __VA_ARGS__); \
+    } while (0)
 
 // Similar to CHECK(condition) << message, but for low-level modules:
 // we use only ABSL_RAW_LOG that does not allocate memory.
 // We do not want to provide args list here to encourage this usage:
 //   if (!cond)  ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
 // so that the args are not computed when not needed.
-#define ABSL_RAW_CHECK(condition, message)                             \
-  do {                                                                 \
-    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
-      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
-    }                                                                  \
-  } while (0)
+#define ABSL_RAW_CHECK(condition, message)                                   \
+    do                                                                       \
+    {                                                                        \
+        if (ABSL_PREDICT_FALSE(!(condition)))                                \
+        {                                                                    \
+            ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
+        }                                                                    \
+    } while (0)
 
 // ABSL_INTERNAL_LOG and ABSL_INTERNAL_CHECK work like the RAW variants above,
 // except that if the richer log library is linked into the binary, we dispatch
@@ -72,125 +72,126 @@
 //
 // The API is a subset of the above: each macro only takes two arguments.  Use
 // StrCat if you need to build a richer message.
-#define ABSL_INTERNAL_LOG(severity, message)                                 \
-  do {                                                                       \
-    constexpr const char* absl_raw_logging_internal_filename = __FILE__;     \
-    ::absl::raw_logging_internal::internal_log_function(                     \
-        ABSL_RAW_LOGGING_INTERNAL_##severity,                                \
-        absl_raw_logging_internal_filename, __LINE__, message);              \
-    if (ABSL_RAW_LOGGING_INTERNAL_##severity == ::absl::LogSeverity::kFatal) \
-      ABSL_INTERNAL_UNREACHABLE;                                             \
-  } while (0)
-
-#define ABSL_INTERNAL_CHECK(condition, message)                    \
-  do {                                                             \
-    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
-      std::string death_message = "Check " #condition " failed: "; \
-      death_message += std::string(message);                       \
-      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
-    }                                                              \
-  } while (0)
+#define ABSL_INTERNAL_LOG(severity, message)                                     \
+    do                                                                           \
+    {                                                                            \
+        constexpr const char* absl_raw_logging_internal_filename = __FILE__;     \
+        ::absl::raw_logging_internal::internal_log_function(                     \
+            ABSL_RAW_LOGGING_INTERNAL_##severity,                                \
+            absl_raw_logging_internal_filename,                                  \
+            __LINE__,                                                            \
+            message                                                              \
+        );                                                                       \
+        if (ABSL_RAW_LOGGING_INTERNAL_##severity == ::absl::LogSeverity::kFatal) \
+            ABSL_INTERNAL_UNREACHABLE;                                           \
+    } while (0)
+
+#define ABSL_INTERNAL_CHECK(condition, message)                          \
+    do                                                                   \
+    {                                                                    \
+        if (ABSL_PREDICT_FALSE(!(condition)))                            \
+        {                                                                \
+            std::string death_message = "Check " #condition " failed: "; \
+            death_message += std::string(message);                       \
+            ABSL_INTERNAL_LOG(FATAL, death_message);                     \
+        }                                                                \
+    } while (0)
 
 #define ABSL_RAW_LOGGING_INTERNAL_INFO ::absl::LogSeverity::kInfo
 #define ABSL_RAW_LOGGING_INTERNAL_WARNING ::absl::LogSeverity::kWarning
 #define ABSL_RAW_LOGGING_INTERNAL_ERROR ::absl::LogSeverity::kError
 #define ABSL_RAW_LOGGING_INTERNAL_FATAL ::absl::LogSeverity::kFatal
 #define ABSL_RAW_LOGGING_INTERNAL_LEVEL(severity) \
-  ::absl::NormalizeLogSeverity(severity)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace raw_logging_internal {
-
-// Helper function to implement ABSL_RAW_LOG
-// Logs format... at "severity" level, reporting it
-// as called from file:line.
-// This does not allocate memory or acquire locks.
-void RawLog(absl::LogSeverity severity, const char* file, int line,
-            const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
-
-// Writes the provided buffer directly to stderr, in a signal-safe, low-level
-// manner.
-void AsyncSignalSafeWriteToStderr(const char* s, size_t len);
-
-// compile-time function to get the "base" filename, that is, the part of
-// a filename after the last "/" or "\" path separator.  The search starts at
-// the end of the string; the second parameter is the length of the string.
-constexpr const char* Basename(const char* fname, int offset) {
-  return offset == 0 || fname[offset - 1] == '/' || fname[offset - 1] == '\\'
-             ? fname + offset
-             : Basename(fname, offset - 1);
-}
-
-// For testing only.
-// Returns true if raw logging is fully supported. When it is not
-// fully supported, no messages will be emitted, but a log at FATAL
-// severity will cause an abort.
-//
-// TODO(gfalcon): Come up with a better name for this method.
-bool RawLoggingFullySupported();
-
-// Function type for a raw_logging customization hook for suppressing messages
-// by severity, and for writing custom prefixes on non-suppressed messages.
-//
-// The installed hook is called for every raw log invocation.  The message will
-// be logged to stderr only if the hook returns true.  FATAL errors will cause
-// the process to abort, even if writing to stderr is suppressed.  The hook is
-// also provided with an output buffer, where it can write a custom log message
-// prefix.
-//
-// The raw_logging system does not allocate memory or grab locks.  User-provided
-// hooks must avoid these operations, and must not throw exceptions.
-//
-// 'severity' is the severity level of the message being written.
-// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
-// was located.
-// 'buf' and 'buf_size' are pointers to the buffer and buffer size.  If the
-// hook writes a prefix, it must increment *buf and decrement *buf_size
-// accordingly.
-using LogFilterAndPrefixHook = bool (*)(absl::LogSeverity severity,
-                                        const char* file, int line, char** buf,
-                                        int* buf_size);
-
-// Function type for a raw_logging customization hook called to abort a process
-// when a FATAL message is logged.  If the provided AbortHook() returns, the
-// logging system will call abort().
-//
-// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
-// was located.
-// The NUL-terminated logged message lives in the buffer between 'buf_start'
-// and 'buf_end'.  'prefix_end' points to the first non-prefix character of the
-// buffer (as written by the LogFilterAndPrefixHook.)
-//
-// The lifetime of the filename and message buffers will not end while the
-// process remains alive.
-using AbortHook = void (*)(const char* file, int line, const char* buf_start,
-                           const char* prefix_end, const char* buf_end);
-
-// Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
-//
-// TODO(gfalcon): When string_view no longer depends on base, change this
-// interface to take its message as a string_view instead.
-using InternalLogFunction = void (*)(absl::LogSeverity severity,
-                                     const char* file, int line,
-                                     const std::string& message);
-
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL extern base_internal::AtomicHook<
-    InternalLogFunction>
-    internal_log_function;
-
-// Registers hooks of the above types.  Only a single hook of each type may be
-// registered.  It is an error to call these functions multiple times with
-// different input arguments.
-//
-// These functions are safe to call at any point during initialization; they do
-// not block or malloc, and are async-signal safe.
-void RegisterLogFilterAndPrefixHook(LogFilterAndPrefixHook func);
-void RegisterAbortHook(AbortHook func);
-void RegisterInternalLogFunction(InternalLogFunction func);
-
-}  // namespace raw_logging_internal
-ABSL_NAMESPACE_END
+    ::absl::NormalizeLogSeverity(severity)
+
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace raw_logging_internal
+    {
+
+        // Helper function to implement ABSL_RAW_LOG
+        // Logs format... at "severity" level, reporting it
+        // as called from file:line.
+        // This does not allocate memory or acquire locks.
+        void RawLog(absl::LogSeverity severity, const char* file, int line, const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
+
+        // Writes the provided buffer directly to stderr, in a signal-safe, low-level
+        // manner.
+        void AsyncSignalSafeWriteToStderr(const char* s, size_t len);
+
+        // compile-time function to get the "base" filename, that is, the part of
+        // a filename after the last "/" or "\" path separator.  The search starts at
+        // the end of the string; the second parameter is the length of the string.
+        constexpr const char* Basename(const char* fname, int offset)
+        {
+            return offset == 0 || fname[offset - 1] == '/' || fname[offset - 1] == '\\' ? fname + offset : Basename(fname, offset - 1);
+        }
+
+        // For testing only.
+        // Returns true if raw logging is fully supported. When it is not
+        // fully supported, no messages will be emitted, but a log at FATAL
+        // severity will cause an abort.
+        //
+        // TODO(gfalcon): Come up with a better name for this method.
+        bool RawLoggingFullySupported();
+
+        // Function type for a raw_logging customization hook for suppressing messages
+        // by severity, and for writing custom prefixes on non-suppressed messages.
+        //
+        // The installed hook is called for every raw log invocation.  The message will
+        // be logged to stderr only if the hook returns true.  FATAL errors will cause
+        // the process to abort, even if writing to stderr is suppressed.  The hook is
+        // also provided with an output buffer, where it can write a custom log message
+        // prefix.
+        //
+        // The raw_logging system does not allocate memory or grab locks.  User-provided
+        // hooks must avoid these operations, and must not throw exceptions.
+        //
+        // 'severity' is the severity level of the message being written.
+        // 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
+        // was located.
+        // 'buf' and 'buf_size' are pointers to the buffer and buffer size.  If the
+        // hook writes a prefix, it must increment *buf and decrement *buf_size
+        // accordingly.
+        using LogFilterAndPrefixHook = bool (*)(absl::LogSeverity severity, const char* file, int line, char** buf, int* buf_size);
+
+        // Function type for a raw_logging customization hook called to abort a process
+        // when a FATAL message is logged.  If the provided AbortHook() returns, the
+        // logging system will call abort().
+        //
+        // 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
+        // was located.
+        // The NUL-terminated logged message lives in the buffer between 'buf_start'
+        // and 'buf_end'.  'prefix_end' points to the first non-prefix character of the
+        // buffer (as written by the LogFilterAndPrefixHook.)
+        //
+        // The lifetime of the filename and message buffers will not end while the
+        // process remains alive.
+        using AbortHook = void (*)(const char* file, int line, const char* buf_start, const char* prefix_end, const char* buf_end);
+
+        // Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
+        //
+        // TODO(gfalcon): When string_view no longer depends on base, change this
+        // interface to take its message as a string_view instead.
+        using InternalLogFunction = void (*)(absl::LogSeverity severity, const char* file, int line, const std::string& message);
+
+        ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL extern base_internal::AtomicHook<
+            InternalLogFunction>
+            internal_log_function;
+
+        // Registers hooks of the above types.  Only a single hook of each type may be
+        // registered.  It is an error to call these functions multiple times with
+        // different input arguments.
+        //
+        // These functions are safe to call at any point during initialization; they do
+        // not block or malloc, and are async-signal safe.
+        void RegisterLogFilterAndPrefixHook(LogFilterAndPrefixHook func);
+        void RegisterAbortHook(AbortHook func);
+        void RegisterInternalLogFunction(InternalLogFunction func);
+
+    }  // namespace raw_logging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_RAW_LOGGING_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/scheduling_mode.h b/CAPI/cpp/grpc/include/absl/base/internal/scheduling_mode.h
index 8be5ab6..15091e9 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/scheduling_mode.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/scheduling_mode.h
@@ -20,39 +20,42 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-// Used to describe how a thread may be scheduled.  Typically associated with
-// the declaration of a resource supporting synchronized access.
-//
-// SCHEDULE_COOPERATIVE_AND_KERNEL:
-// Specifies that when waiting, a cooperative thread (e.g. a Fiber) may
-// reschedule (using base::scheduling semantics); allowing other cooperative
-// threads to proceed.
-//
-// SCHEDULE_KERNEL_ONLY: (Also described as "non-cooperative")
-// Specifies that no cooperative scheduling semantics may be used, even if the
-// current thread is itself cooperatively scheduled.  This means that
-// cooperative threads will NOT allow other cooperative threads to execute in
-// their place while waiting for a resource of this type.  Host operating system
-// semantics (e.g. a futex) may still be used.
-//
-// When optional, clients should strongly prefer SCHEDULE_COOPERATIVE_AND_KERNEL
-// by default.  SCHEDULE_KERNEL_ONLY should only be used for resources on which
-// base::scheduling (e.g. the implementation of a Scheduler) may depend.
-//
-// NOTE: Cooperative resources may not be nested below non-cooperative ones.
-// This means that it is invalid to to acquire a SCHEDULE_COOPERATIVE_AND_KERNEL
-// resource if a SCHEDULE_KERNEL_ONLY resource is already held.
-enum SchedulingMode {
-  SCHEDULE_KERNEL_ONLY = 0,         // Allow scheduling only the host OS.
-  SCHEDULE_COOPERATIVE_AND_KERNEL,  // Also allow cooperative scheduling.
-};
+        // Used to describe how a thread may be scheduled.  Typically associated with
+        // the declaration of a resource supporting synchronized access.
+        //
+        // SCHEDULE_COOPERATIVE_AND_KERNEL:
+        // Specifies that when waiting, a cooperative thread (e.g. a Fiber) may
+        // reschedule (using base::scheduling semantics); allowing other cooperative
+        // threads to proceed.
+        //
+        // SCHEDULE_KERNEL_ONLY: (Also described as "non-cooperative")
+        // Specifies that no cooperative scheduling semantics may be used, even if the
+        // current thread is itself cooperatively scheduled.  This means that
+        // cooperative threads will NOT allow other cooperative threads to execute in
+        // their place while waiting for a resource of this type.  Host operating system
+        // semantics (e.g. a futex) may still be used.
+        //
+        // When optional, clients should strongly prefer SCHEDULE_COOPERATIVE_AND_KERNEL
+        // by default.  SCHEDULE_KERNEL_ONLY should only be used for resources on which
+        // base::scheduling (e.g. the implementation of a Scheduler) may depend.
+        //
+        // NOTE: Cooperative resources may not be nested below non-cooperative ones.
+        // This means that it is invalid to to acquire a SCHEDULE_COOPERATIVE_AND_KERNEL
+        // resource if a SCHEDULE_KERNEL_ONLY resource is already held.
+        enum SchedulingMode
+        {
+            SCHEDULE_KERNEL_ONLY = 0,         // Allow scheduling only the host OS.
+            SCHEDULE_COOPERATIVE_AND_KERNEL,  // Also allow cooperative scheduling.
+        };
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/scoped_set_env.h b/CAPI/cpp/grpc/include/absl/base/internal/scoped_set_env.h
index 19ec7b5..8471b59 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/scoped_set_env.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/scoped_set_env.h
@@ -21,25 +21,28 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class ScopedSetEnv {
- public:
-  ScopedSetEnv(const char* var_name, const char* new_value);
-  ~ScopedSetEnv();
-
- private:
-  std::string var_name_;
-  std::string old_value_;
-
-  // True if the environment variable was initially not set.
-  bool was_unset_;
-};
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        class ScopedSetEnv
+        {
+        public:
+            ScopedSetEnv(const char* var_name, const char* new_value);
+            ~ScopedSetEnv();
+
+        private:
+            std::string var_name_;
+            std::string old_value_;
+
+            // True if the environment variable was initially not set.
+            bool was_unset_;
+        };
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/spinlock.h b/CAPI/cpp/grpc/include/absl/base/internal/spinlock.h
index 6d8d8dd..0cb41fc 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/spinlock.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/spinlock.h
@@ -45,212 +45,242 @@
 #include "absl/base/port.h"
 #include "absl/base/thread_annotations.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-class ABSL_LOCKABLE SpinLock {
- public:
-  SpinLock() : lockword_(kSpinLockCooperative) {
-    ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
-  }
-
-  // Constructors that allow non-cooperative spinlocks to be created for use
-  // inside thread schedulers.  Normal clients should not use these.
-  explicit SpinLock(base_internal::SchedulingMode mode);
-
-  // Constructor for global SpinLock instances.  See absl/base/const_init.h.
-  constexpr SpinLock(absl::ConstInitType, base_internal::SchedulingMode mode)
-      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {}
-
-  // For global SpinLock instances prefer trivial destructor when possible.
-  // Default but non-trivial destructor in some build configurations causes an
-  // extra static initializer.
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        class ABSL_LOCKABLE SpinLock
+        {
+        public:
+            SpinLock() :
+                lockword_(kSpinLockCooperative)
+            {
+                ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+            }
+
+            // Constructors that allow non-cooperative spinlocks to be created for use
+            // inside thread schedulers.  Normal clients should not use these.
+            explicit SpinLock(base_internal::SchedulingMode mode);
+
+            // Constructor for global SpinLock instances.  See absl/base/const_init.h.
+            constexpr SpinLock(absl::ConstInitType, base_internal::SchedulingMode mode) :
+                lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0)
+            {
+            }
+
+            // For global SpinLock instances prefer trivial destructor when possible.
+            // Default but non-trivial destructor in some build configurations causes an
+            // extra static initializer.
 #ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
-  ~SpinLock() { ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static); }
+            ~SpinLock()
+            {
+                ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static);
+            }
 #else
-  ~SpinLock() = default;
+            ~SpinLock() = default;
 #endif
 
-  // Acquire this SpinLock.
-  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
-    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
-    if (!TryLockImpl()) {
-      SlowLock();
-    }
-    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
-  }
-
-  // Try to acquire this SpinLock without blocking and return true if the
-  // acquisition was successful.  If the lock was not acquired, false is
-  // returned.  If this SpinLock is free at the time of the call, TryLock
-  // will return true with high probability.
-  inline bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
-    ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
-    bool res = TryLockImpl();
-    ABSL_TSAN_MUTEX_POST_LOCK(
-        this, __tsan_mutex_try_lock | (res ? 0 : __tsan_mutex_try_lock_failed),
-        0);
-    return res;
-  }
-
-  // Release this SpinLock, which must be held by the calling thread.
-  inline void Unlock() ABSL_UNLOCK_FUNCTION() {
-    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
-    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
-    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
-                                    std::memory_order_release);
-
-    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
-      base_internal::SchedulingGuard::EnableRescheduling(true);
-    }
-    if ((lock_value & kWaitTimeMask) != 0) {
-      // Collect contentionz profile info, and speed the wakeup of any waiter.
-      // The wait_cycles value indicates how long this thread spent waiting
-      // for the lock.
-      SlowUnlock(lock_value);
-    }
-    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
-  }
-
-  // Determine if the lock is held.  When the lock is held by the invoking
-  // thread, true will always be returned. Intended to be used as
-  // CHECK(lock.IsHeld()).
-  inline bool IsHeld() const {
-    return (lockword_.load(std::memory_order_relaxed) & kSpinLockHeld) != 0;
-  }
-
-  // Return immediately if this thread holds the SpinLock exclusively.
-  // Otherwise, report an error by crashing with a diagnostic.
-  inline void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK() {
-    if (!IsHeld()) {
-      ABSL_RAW_LOG(FATAL, "thread should hold the lock on SpinLock");
-    }
-  }
-
- protected:
-  // These should not be exported except for testing.
-
-  // Store number of cycles between wait_start_time and wait_end_time in a
-  // lock value.
-  static uint32_t EncodeWaitCycles(int64_t wait_start_time,
-                                   int64_t wait_end_time);
-
-  // Extract number of wait cycles in a lock value.
-  static uint64_t DecodeWaitCycles(uint32_t lock_value);
-
-  // Provide access to protected method above.  Use for testing only.
-  friend struct SpinLockTest;
-
- private:
-  // lockword_ is used to store the following:
-  //
-  // bit[0] encodes whether a lock is being held.
-  // bit[1] encodes whether a lock uses cooperative scheduling.
-  // bit[2] encodes whether the current lock holder disabled scheduling when
-  //        acquiring the lock. Only set when kSpinLockHeld is also set.
-  // bit[3:31] encodes time a lock spent on waiting as a 29-bit unsigned int.
-  //        This is set by the lock holder to indicate how long it waited on
-  //        the lock before eventually acquiring it. The number of cycles is
-  //        encoded as a 29-bit unsigned int, or in the case that the current
-  //        holder did not wait but another waiter is queued, the LSB
-  //        (kSpinLockSleeper) is set. The implementation does not explicitly
-  //        track the number of queued waiters beyond this. It must always be
-  //        assumed that waiters may exist if the current holder was required to
-  //        queue.
-  //
-  // Invariant: if the lock is not held, the value is either 0 or
-  // kSpinLockCooperative.
-  static constexpr uint32_t kSpinLockHeld = 1;
-  static constexpr uint32_t kSpinLockCooperative = 2;
-  static constexpr uint32_t kSpinLockDisabledScheduling = 4;
-  static constexpr uint32_t kSpinLockSleeper = 8;
-  // Includes kSpinLockSleeper.
-  static constexpr uint32_t kWaitTimeMask =
-      ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling);
-
-  // Returns true if the provided scheduling mode is cooperative.
-  static constexpr bool IsCooperative(
-      base_internal::SchedulingMode scheduling_mode) {
-    return scheduling_mode == base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
-  }
-
-  uint32_t TryLockInternal(uint32_t lock_value, uint32_t wait_cycles);
-  void SlowLock() ABSL_ATTRIBUTE_COLD;
-  void SlowUnlock(uint32_t lock_value) ABSL_ATTRIBUTE_COLD;
-  uint32_t SpinLoop();
-
-  inline bool TryLockImpl() {
-    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
-    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
-  }
-
-  std::atomic<uint32_t> lockword_;
-
-  SpinLock(const SpinLock&) = delete;
-  SpinLock& operator=(const SpinLock&) = delete;
-};
-
-// Corresponding locker object that arranges to acquire a spinlock for
-// the duration of a C++ scope.
-class ABSL_SCOPED_LOCKABLE SpinLockHolder {
- public:
-  inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
-      : lock_(l) {
-    l->Lock();
-  }
-  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
-
-  SpinLockHolder(const SpinLockHolder&) = delete;
-  SpinLockHolder& operator=(const SpinLockHolder&) = delete;
-
- private:
-  SpinLock* lock_;
-};
-
-// Register a hook for profiling support.
-//
-// The function pointer registered here will be called whenever a spinlock is
-// contended.  The callback is given an opaque handle to the contended spinlock
-// and the number of wait cycles.  This is thread-safe, but only a single
-// profiler can be registered.  It is an error to call this function multiple
-// times with different arguments.
-void RegisterSpinLockProfiler(void (*fn)(const void* lock,
-                                         int64_t wait_cycles));
-
-//------------------------------------------------------------------------------
-// Public interface ends here.
-//------------------------------------------------------------------------------
-
-// If (result & kSpinLockHeld) == 0, then *this was successfully locked.
-// Otherwise, returns last observed value for lockword_.
-inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
-                                          uint32_t wait_cycles) {
-  if ((lock_value & kSpinLockHeld) != 0) {
-    return lock_value;
-  }
-
-  uint32_t sched_disabled_bit = 0;
-  if ((lock_value & kSpinLockCooperative) == 0) {
-    // For non-cooperative locks we must make sure we mark ourselves as
-    // non-reschedulable before we attempt to CompareAndSwap.
-    if (base_internal::SchedulingGuard::DisableRescheduling()) {
-      sched_disabled_bit = kSpinLockDisabledScheduling;
-    }
-  }
-
-  if (!lockword_.compare_exchange_strong(
-          lock_value,
-          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
-          std::memory_order_acquire, std::memory_order_relaxed)) {
-    base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
-  }
-
-  return lock_value;
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+            // Acquire this SpinLock.
+            inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION()
+            {
+                ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+                if (!TryLockImpl())
+                {
+                    SlowLock();
+                }
+                ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+            }
+
+            // Try to acquire this SpinLock without blocking and return true if the
+            // acquisition was successful.  If the lock was not acquired, false is
+            // returned.  If this SpinLock is free at the time of the call, TryLock
+            // will return true with high probability.
+            inline bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true)
+            {
+                ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
+                bool res = TryLockImpl();
+                ABSL_TSAN_MUTEX_POST_LOCK(
+                    this, __tsan_mutex_try_lock | (res ? 0 : __tsan_mutex_try_lock_failed), 0
+                );
+                return res;
+            }
+
+            // Release this SpinLock, which must be held by the calling thread.
+            inline void Unlock() ABSL_UNLOCK_FUNCTION()
+            {
+                ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
+                uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
+                lock_value = lockword_.exchange(lock_value & kSpinLockCooperative, std::memory_order_release);
+
+                if ((lock_value & kSpinLockDisabledScheduling) != 0)
+                {
+                    base_internal::SchedulingGuard::EnableRescheduling(true);
+                }
+                if ((lock_value & kWaitTimeMask) != 0)
+                {
+                    // Collect contentionz profile info, and speed the wakeup of any waiter.
+                    // The wait_cycles value indicates how long this thread spent waiting
+                    // for the lock.
+                    SlowUnlock(lock_value);
+                }
+                ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
+            }
+
+            // Determine if the lock is held.  When the lock is held by the invoking
+            // thread, true will always be returned. Intended to be used as
+            // CHECK(lock.IsHeld()).
+            inline bool IsHeld() const
+            {
+                return (lockword_.load(std::memory_order_relaxed) & kSpinLockHeld) != 0;
+            }
+
+            // Return immediately if this thread holds the SpinLock exclusively.
+            // Otherwise, report an error by crashing with a diagnostic.
+            inline void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK()
+            {
+                if (!IsHeld())
+                {
+                    ABSL_RAW_LOG(FATAL, "thread should hold the lock on SpinLock");
+                }
+            }
+
+        protected:
+            // These should not be exported except for testing.
+
+            // Store number of cycles between wait_start_time and wait_end_time in a
+            // lock value.
+            static uint32_t EncodeWaitCycles(int64_t wait_start_time, int64_t wait_end_time);
+
+            // Extract number of wait cycles in a lock value.
+            static uint64_t DecodeWaitCycles(uint32_t lock_value);
+
+            // Provide access to protected method above.  Use for testing only.
+            friend struct SpinLockTest;
+
+        private:
+            // lockword_ is used to store the following:
+            //
+            // bit[0] encodes whether a lock is being held.
+            // bit[1] encodes whether a lock uses cooperative scheduling.
+            // bit[2] encodes whether the current lock holder disabled scheduling when
+            //        acquiring the lock. Only set when kSpinLockHeld is also set.
+            // bit[3:31] encodes time a lock spent on waiting as a 29-bit unsigned int.
+            //        This is set by the lock holder to indicate how long it waited on
+            //        the lock before eventually acquiring it. The number of cycles is
+            //        encoded as a 29-bit unsigned int, or in the case that the current
+            //        holder did not wait but another waiter is queued, the LSB
+            //        (kSpinLockSleeper) is set. The implementation does not explicitly
+            //        track the number of queued waiters beyond this. It must always be
+            //        assumed that waiters may exist if the current holder was required to
+            //        queue.
+            //
+            // Invariant: if the lock is not held, the value is either 0 or
+            // kSpinLockCooperative.
+            static constexpr uint32_t kSpinLockHeld = 1;
+            static constexpr uint32_t kSpinLockCooperative = 2;
+            static constexpr uint32_t kSpinLockDisabledScheduling = 4;
+            static constexpr uint32_t kSpinLockSleeper = 8;
+            // Includes kSpinLockSleeper.
+            static constexpr uint32_t kWaitTimeMask =
+                ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling);
+
+            // Returns true if the provided scheduling mode is cooperative.
+            static constexpr bool IsCooperative(
+                base_internal::SchedulingMode scheduling_mode
+            )
+            {
+                return scheduling_mode == base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
+            }
+
+            uint32_t TryLockInternal(uint32_t lock_value, uint32_t wait_cycles);
+            void SlowLock() ABSL_ATTRIBUTE_COLD;
+            void SlowUnlock(uint32_t lock_value) ABSL_ATTRIBUTE_COLD;
+            uint32_t SpinLoop();
+
+            inline bool TryLockImpl()
+            {
+                uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
+                return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
+            }
+
+            std::atomic<uint32_t> lockword_;
+
+            SpinLock(const SpinLock&) = delete;
+            SpinLock& operator=(const SpinLock&) = delete;
+        };
+
+        // Corresponding locker object that arranges to acquire a spinlock for
+        // the duration of a C++ scope.
+        class ABSL_SCOPED_LOCKABLE SpinLockHolder
+        {
+        public:
+            inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l) :
+                lock_(l)
+            {
+                l->Lock();
+            }
+            inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION()
+            {
+                lock_->Unlock();
+            }
+
+            SpinLockHolder(const SpinLockHolder&) = delete;
+            SpinLockHolder& operator=(const SpinLockHolder&) = delete;
+
+        private:
+            SpinLock* lock_;
+        };
+
+        // Register a hook for profiling support.
+        //
+        // The function pointer registered here will be called whenever a spinlock is
+        // contended.  The callback is given an opaque handle to the contended spinlock
+        // and the number of wait cycles.  This is thread-safe, but only a single
+        // profiler can be registered.  It is an error to call this function multiple
+        // times with different arguments.
+        void RegisterSpinLockProfiler(void (*fn)(const void* lock, int64_t wait_cycles));
+
+        //------------------------------------------------------------------------------
+        // Public interface ends here.
+        //------------------------------------------------------------------------------
+
+        // If (result & kSpinLockHeld) == 0, then *this was successfully locked.
+        // Otherwise, returns last observed value for lockword_.
+        inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value, uint32_t wait_cycles)
+        {
+            if ((lock_value & kSpinLockHeld) != 0)
+            {
+                return lock_value;
+            }
+
+            uint32_t sched_disabled_bit = 0;
+            if ((lock_value & kSpinLockCooperative) == 0)
+            {
+                // For non-cooperative locks we must make sure we mark ourselves as
+                // non-reschedulable before we attempt to CompareAndSwap.
+                if (base_internal::SchedulingGuard::DisableRescheduling())
+                {
+                    sched_disabled_bit = kSpinLockDisabledScheduling;
+                }
+            }
+
+            if (!lockword_.compare_exchange_strong(
+                    lock_value,
+                    kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
+                    std::memory_order_acquire,
+                    std::memory_order_relaxed
+                ))
+            {
+                base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
+            }
+
+            return lock_value;
+        }
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_SPINLOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/spinlock_wait.h b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_wait.h
index 9a1adcd..a36b6e1 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/spinlock_wait.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/spinlock_wait.h
@@ -23,47 +23,47 @@
 
 #include "absl/base/internal/scheduling_mode.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-// SpinLockWait() waits until it can perform one of several transitions from
-// "from" to "to".  It returns when it performs a transition where done==true.
-struct SpinLockWaitTransition {
-  uint32_t from;
-  uint32_t to;
-  bool done;
-};
+        // SpinLockWait() waits until it can perform one of several transitions from
+        // "from" to "to".  It returns when it performs a transition where done==true.
+        struct SpinLockWaitTransition
+        {
+            uint32_t from;
+            uint32_t to;
+            bool done;
+        };
 
-// Wait until *w can transition from trans[i].from to trans[i].to for some i
-// satisfying 0<=i<n && trans[i].done, atomically make the transition,
-// then return the old value of *w.   Make any other atomic transitions
-// where !trans[i].done, but continue waiting.
-//
-// Wakeups for threads blocked on SpinLockWait do not respect priorities.
-uint32_t SpinLockWait(std::atomic<uint32_t> *w, int n,
-                      const SpinLockWaitTransition trans[],
-                      SchedulingMode scheduling_mode);
+        // Wait until *w can transition from trans[i].from to trans[i].to for some i
+        // satisfying 0<=i<n && trans[i].done, atomically make the transition,
+        // then return the old value of *w.   Make any other atomic transitions
+        // where !trans[i].done, but continue waiting.
+        //
+        // Wakeups for threads blocked on SpinLockWait do not respect priorities.
+        uint32_t SpinLockWait(std::atomic<uint32_t>* w, int n, const SpinLockWaitTransition trans[], SchedulingMode scheduling_mode);
 
-// If possible, wake some thread that has called SpinLockDelay(w, ...). If `all`
-// is true, wake all such threads. On some systems, this may be a no-op; on
-// those systems, threads calling SpinLockDelay() will always wake eventually
-// even if SpinLockWake() is never called.
-void SpinLockWake(std::atomic<uint32_t> *w, bool all);
+        // If possible, wake some thread that has called SpinLockDelay(w, ...). If `all`
+        // is true, wake all such threads. On some systems, this may be a no-op; on
+        // those systems, threads calling SpinLockDelay() will always wake eventually
+        // even if SpinLockWake() is never called.
+        void SpinLockWake(std::atomic<uint32_t>* w, bool all);
 
-// Wait for an appropriate spin delay on iteration "loop" of a
-// spin loop on location *w, whose previously observed value was "value".
-// SpinLockDelay() may do nothing, may yield the CPU, may sleep a clock tick,
-// or may wait for a call to SpinLockWake(w).
-void SpinLockDelay(std::atomic<uint32_t> *w, uint32_t value, int loop,
-                   base_internal::SchedulingMode scheduling_mode);
+        // Wait for an appropriate spin delay on iteration "loop" of a
+        // spin loop on location *w, whose previously observed value was "value".
+        // SpinLockDelay() may do nothing, may yield the CPU, may sleep a clock tick,
+        // or may wait for a call to SpinLockWake(w).
+        void SpinLockDelay(std::atomic<uint32_t>* w, uint32_t value, int loop, base_internal::SchedulingMode scheduling_mode);
 
-// Helper used by AbslInternalSpinLockDelay.
-// Returns a suggested delay in nanoseconds for iteration number "loop".
-int SpinLockSuggestedDelayNS(int loop);
+        // Helper used by AbslInternalSpinLockDelay.
+        // Returns a suggested delay in nanoseconds for iteration number "loop".
+        int SpinLockSuggestedDelayNS(int loop);
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // In some build configurations we pass --detect-odr-violations to the
@@ -72,24 +72,26 @@ ABSL_NAMESPACE_END
 // --detect-odr-violations ignores symbols not mangled with C++ names.
 // By changing our extension points to be extern "C", we dodge this
 // check.
-extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(std::atomic<uint32_t> *w,
-                                                      bool all);
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
-    std::atomic<uint32_t> *w, uint32_t value, int loop,
-    absl::base_internal::SchedulingMode scheduling_mode);
+extern "C"
+{
+    void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(std::atomic<uint32_t>* w, bool all);
+    void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+        std::atomic<uint32_t>* w, uint32_t value, int loop, absl::base_internal::SchedulingMode scheduling_mode
+    );
 }
 
-inline void absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w,
-                                              bool all) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(w, all);
+inline void absl::base_internal::SpinLockWake(std::atomic<uint32_t>* w, bool all)
+{
+    ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)
+    (w, all);
 }
 
 inline void absl::base_internal::SpinLockDelay(
-    std::atomic<uint32_t> *w, uint32_t value, int loop,
-    absl::base_internal::SchedulingMode scheduling_mode) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)
-  (w, value, loop, scheduling_mode);
+    std::atomic<uint32_t>* w, uint32_t value, int loop, absl::base_internal::SchedulingMode scheduling_mode
+)
+{
+    ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)
+    (w, value, loop, scheduling_mode);
 }
 
 #endif  // ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/strerror.h b/CAPI/cpp/grpc/include/absl/base/internal/strerror.h
index 3500973..5f79457 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/strerror.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/strerror.h
@@ -19,21 +19,23 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-// A portable and thread-safe alternative to C89's `strerror`.
-//
-// The C89 specification of `strerror` is not suitable for use in a
-// multi-threaded application as the returned string may be changed by calls to
-// `strerror` from another thread.  The many non-stdlib alternatives differ
-// enough in their names, availability, and semantics to justify this wrapper
-// around them.  `errno` will not be modified by a call to `absl::StrError`.
-std::string StrError(int errnum);
+        // A portable and thread-safe alternative to C89's `strerror`.
+        //
+        // The C89 specification of `strerror` is not suitable for use in a
+        // multi-threaded application as the returned string may be changed by calls to
+        // `strerror` from another thread.  The many non-stdlib alternatives differ
+        // enough in their names, availability, and semantics to justify this wrapper
+        // around them.  `errno` will not be modified by a call to `absl::StrError`.
+        std::string StrError(int errnum);
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_STRERROR_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/sysinfo.h b/CAPI/cpp/grpc/include/absl/base/internal/sysinfo.h
index 119cf1f..ee27ec7 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/sysinfo.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/sysinfo.h
@@ -33,17 +33,19 @@
 #include "absl/base/config.h"
 #include "absl/base/port.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-// Nominal core processor cycles per second of each processor.   This is _not_
-// necessarily the frequency of the CycleClock counter (see cycleclock.h)
-// Thread-safe.
-double NominalCPUFrequency();
+        // Nominal core processor cycles per second of each processor.   This is _not_
+        // necessarily the frequency of the CycleClock counter (see cycleclock.h)
+        // Thread-safe.
+        double NominalCPUFrequency();
 
-// Number of logical processors (hyperthreads) in system. Thread-safe.
-int NumCPUs();
+        // Number of logical processors (hyperthreads) in system. Thread-safe.
+        int NumCPUs();
 
 // Return the thread id of the current thread, as told by the system.
 // No two currently-live threads implemented by the OS shall have the same ID.
@@ -53,22 +55,22 @@ int NumCPUs();
 // On Linux, you may send a signal to the resulting ID with kill().  However,
 // it is recommended for portability that you use pthread_kill() instead.
 #ifdef _WIN32
-// On Windows, process id and thread id are of the same type according to the
-// return types of GetProcessId() and GetThreadId() are both DWORD, an unsigned
-// 32-bit type.
-using pid_t = uint32_t;
+        // On Windows, process id and thread id are of the same type according to the
+        // return types of GetProcessId() and GetThreadId() are both DWORD, an unsigned
+        // 32-bit type.
+        using pid_t = uint32_t;
 #endif
-pid_t GetTID();
+        pid_t GetTID();
 
-// Like GetTID(), but caches the result in thread-local storage in order
-// to avoid unnecessary system calls. Note that there are some cases where
-// one must call through to GetTID directly, which is why this exists as a
-// separate function. For example, GetCachedTID() is not safe to call in
-// an asynchronous signal-handling context nor right after a call to fork().
-pid_t GetCachedTID();
+        // Like GetTID(), but caches the result in thread-local storage in order
+        // to avoid unnecessary system calls. Note that there are some cases where
+        // one must call through to GetTID directly, which is why this exists as a
+        // separate function. For example, GetCachedTID() is not safe to call in
+        // an asynchronous signal-handling context nor right after a call to fork().
+        pid_t GetCachedTID();
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_SYSINFO_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/thread_annotations.h b/CAPI/cpp/grpc/include/absl/base/internal/thread_annotations.h
index 4dab6a9..9ce05ae 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/thread_annotations.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/thread_annotations.h
@@ -39,9 +39,9 @@
 #define ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
 
 #if defined(__clang__)
-#define THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
+#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
 #else
-#define THREAD_ANNOTATION_ATTRIBUTE__(x)   // no-op
+#define THREAD_ANNOTATION_ATTRIBUTE__(x)  // no-op
 #endif
 
 // GUARDED_BY()
@@ -101,10 +101,10 @@
 //   Mutex m1_;
 //   Mutex m2_ ACQUIRED_AFTER(m1_);
 #define ACQUIRED_AFTER(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
 
 #define ACQUIRED_BEFORE(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
 
 // EXCLUSIVE_LOCKS_REQUIRED() / SHARED_LOCKS_REQUIRED()
 //
@@ -130,10 +130,10 @@
 //   void foo() EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... }
 //   void bar() const SHARED_LOCKS_REQUIRED(mu1, mu2) { ... }
 #define EXCLUSIVE_LOCKS_REQUIRED(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
 
 #define SHARED_LOCKS_REQUIRED(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
 
 // LOCKS_EXCLUDED()
 //
@@ -141,7 +141,7 @@
 // cannot be held when calling this function (as Abseil's `Mutex` locks are
 // non-reentrant).
 #define LOCKS_EXCLUDED(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
 
 // LOCK_RETURNED()
 //
@@ -149,13 +149,13 @@
 // a public getter method that returns a pointer to a private mutex should
 // be annotated with LOCK_RETURNED.
 #define LOCK_RETURNED(x) \
-  THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+    THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
 
 // LOCKABLE
 //
 // Documents if a class/type is a lockable type (such as the `Mutex` class).
 #define LOCKABLE \
-  THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+    THREAD_ANNOTATION_ATTRIBUTE__(lockable)
 
 // SCOPED_LOCKABLE
 //
@@ -165,28 +165,28 @@
 // arguments; the analysis will assume that the destructor unlocks whatever the
 // constructor locked.
 #define SCOPED_LOCKABLE \
-  THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+    THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
 
 // EXCLUSIVE_LOCK_FUNCTION()
 //
 // Documents functions that acquire a lock in the body of a function, and do
 // not release it.
 #define EXCLUSIVE_LOCK_FUNCTION(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
 
 // SHARED_LOCK_FUNCTION()
 //
 // Documents functions that acquire a shared (reader) lock in the body of a
 // function, and do not release it.
 #define SHARED_LOCK_FUNCTION(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
 
 // UNLOCK_FUNCTION()
 //
 // Documents functions that expect a lock to be held on entry to the function,
 // and release it in the body of the function.
 #define UNLOCK_FUNCTION(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
 
 // EXCLUSIVE_TRYLOCK_FUNCTION() / SHARED_TRYLOCK_FUNCTION()
 //
@@ -197,20 +197,20 @@
 // argument specifies the mutex that is locked on success. If unspecified, this
 // mutex is assumed to be `this`.
 #define EXCLUSIVE_TRYLOCK_FUNCTION(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
 
 #define SHARED_TRYLOCK_FUNCTION(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
 
 // ASSERT_EXCLUSIVE_LOCK() / ASSERT_SHARED_LOCK()
 //
 // Documents functions that dynamically check to see if a lock is held, and fail
 // if it is not held.
 #define ASSERT_EXCLUSIVE_LOCK(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
 
 #define ASSERT_SHARED_LOCK(...) \
-  THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
+    THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
 
 // NO_THREAD_SAFETY_ANALYSIS
 //
@@ -218,7 +218,7 @@
 // This annotation is used to mark functions that are known to be correct, but
 // the locking behavior is more complicated than the analyzer can handle.
 #define NO_THREAD_SAFETY_ANALYSIS \
-  THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+    THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
 
 //------------------------------------------------------------------------------
 // Tool-Supplied Annotations
@@ -239,7 +239,7 @@
 // that are incorrect and need to be fixed.  It is used by automated tools to
 // avoid breaking the build when the analysis is updated.
 // Code owners are expected to eventually fix the routine.
-#define NO_THREAD_SAFETY_ANALYSIS_FIXME  NO_THREAD_SAFETY_ANALYSIS
+#define NO_THREAD_SAFETY_ANALYSIS_FIXME NO_THREAD_SAFETY_ANALYSIS
 
 // Similar to NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a GUARDED_BY
 // annotation that needs to be fixed, because it is producing thread safety
@@ -251,20 +251,22 @@
 // but the compiler cannot confirm that.
 #define TS_UNCHECKED_READ(x) thread_safety_analysis::ts_unchecked_read(x)
 
-
-namespace thread_safety_analysis {
-
-// Takes a reference to a guarded data member, and returns an unguarded
-// reference.
-template <typename T>
-inline const T& ts_unchecked_read(const T& v) NO_THREAD_SAFETY_ANALYSIS {
-  return v;
-}
-
-template <typename T>
-inline T& ts_unchecked_read(T& v) NO_THREAD_SAFETY_ANALYSIS {
-  return v;
-}
+namespace thread_safety_analysis
+{
+
+    // Takes a reference to a guarded data member, and returns an unguarded
+    // reference.
+    template<typename T>
+    inline const T& ts_unchecked_read(const T& v) NO_THREAD_SAFETY_ANALYSIS
+    {
+        return v;
+    }
+
+    template<typename T>
+    inline T& ts_unchecked_read(T& v) NO_THREAD_SAFETY_ANALYSIS
+    {
+        return v;
+    }
 
 }  // namespace thread_safety_analysis
 
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/thread_identity.h b/CAPI/cpp/grpc/include/absl/base/internal/thread_identity.h
index 659694b..63852d8 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/thread_identity.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/thread_identity.h
@@ -34,156 +34,162 @@
 #include "absl/base/internal/per_thread_tls.h"
 #include "absl/base/optimization.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-struct SynchLocksHeld;
-struct SynchWaitParams;
-
-namespace base_internal {
-
-class SpinLock;
-struct ThreadIdentity;
-
-// Used by the implementation of absl::Mutex and absl::CondVar.
-struct PerThreadSynch {
-  // The internal representation of absl::Mutex and absl::CondVar rely
-  // on the alignment of PerThreadSynch. Both store the address of the
-  // PerThreadSynch in the high-order bits of their internal state,
-  // which means the low kLowZeroBits of the address of PerThreadSynch
-  // must be zero.
-  static constexpr int kLowZeroBits = 8;
-  static constexpr int kAlignment = 1 << kLowZeroBits;
-
-  // Returns the associated ThreadIdentity.
-  // This can be implemented as a cast because we guarantee
-  // PerThreadSynch is the first element of ThreadIdentity.
-  ThreadIdentity* thread_identity() {
-    return reinterpret_cast<ThreadIdentity*>(this);
-  }
-
-  PerThreadSynch *next;  // Circular waiter queue; initialized to 0.
-  PerThreadSynch *skip;  // If non-zero, all entries in Mutex queue
-                         // up to and including "skip" have same
-                         // condition as this, and will be woken later
-  bool may_skip;         // if false while on mutex queue, a mutex unlocker
-                         // is using this PerThreadSynch as a terminator.  Its
-                         // skip field must not be filled in because the loop
-                         // might then skip over the terminator.
-  bool wake;             // This thread is to be woken from a Mutex.
-  // If "x" is on a waiter list for a mutex, "x->cond_waiter" is true iff the
-  // waiter is waiting on the mutex as part of a CV Wait or Mutex Await.
-  //
-  // The value of "x->cond_waiter" is meaningless if "x" is not on a
-  // Mutex waiter list.
-  bool cond_waiter;
-  bool maybe_unlocking;  // Valid at head of Mutex waiter queue;
-                         // true if UnlockSlow could be searching
-                         // for a waiter to wake.  Used for an optimization
-                         // in Enqueue().  true is always a valid value.
-                         // Can be reset to false when the unlocker or any
-                         // writer releases the lock, or a reader fully
-                         // releases the lock.  It may not be set to false
-                         // by a reader that decrements the count to
-                         // non-zero. protected by mutex spinlock
-  bool suppress_fatal_errors;  // If true, try to proceed even in the face
-                               // of broken invariants.  This is used within
-                               // fatal signal handlers to improve the
-                               // chances of debug logging information being
-                               // output successfully.
-  int priority;                // Priority of thread (updated every so often).
-
-  // State values:
-  //   kAvailable: This PerThreadSynch is available.
-  //   kQueued: This PerThreadSynch is unavailable, it's currently queued on a
-  //            Mutex or CondVar waistlist.
-  //
-  // Transitions from kQueued to kAvailable require a release
-  // barrier. This is needed as a waiter may use "state" to
-  // independently observe that it's no longer queued.
-  //
-  // Transitions from kAvailable to kQueued require no barrier, they
-  // are externally ordered by the Mutex.
-  enum State {
-    kAvailable,
-    kQueued
-  };
-  std::atomic<State> state;
-
-  // The wait parameters of the current wait.  waitp is null if the
-  // thread is not waiting. Transitions from null to non-null must
-  // occur before the enqueue commit point (state = kQueued in
-  // Enqueue() and CondVarEnqueue()). Transitions from non-null to
-  // null must occur after the wait is finished (state = kAvailable in
-  // Mutex::Block() and CondVar::WaitCommon()). This field may be
-  // changed only by the thread that describes this PerThreadSynch.  A
-  // special case is Fer(), which calls Enqueue() on another thread,
-  // but with an identical SynchWaitParams pointer, thus leaving the
-  // pointer unchanged.
-  SynchWaitParams* waitp;
-
-  intptr_t readers;     // Number of readers in mutex.
-
-  // When priority will next be read (cycles).
-  int64_t next_priority_read_cycles;
-
-  // Locks held; used during deadlock detection.
-  // Allocated in Synch_GetAllLocks() and freed in ReclaimThreadIdentity().
-  SynchLocksHeld *all_locks;
-};
-
-// The instances of this class are allocated in NewThreadIdentity() with an
-// alignment of PerThreadSynch::kAlignment.
-struct ThreadIdentity {
-  // Must be the first member.  The Mutex implementation requires that
-  // the PerThreadSynch object associated with each thread is
-  // PerThreadSynch::kAlignment aligned.  We provide this alignment on
-  // ThreadIdentity itself.
-  PerThreadSynch per_thread_synch;
-
-  // Private: Reserved for absl::synchronization_internal::Waiter.
-  struct WaiterState {
-    alignas(void*) char data[128];
-  } waiter_state;
-
-  // Used by PerThreadSem::{Get,Set}ThreadBlockedCounter().
-  std::atomic<int>* blocked_count_ptr;
-
-  // The following variables are mostly read/written just by the
-  // thread itself.  The only exception is that these are read by
-  // a ticker thread as a hint.
-  std::atomic<int> ticker;      // Tick counter, incremented once per second.
-  std::atomic<int> wait_start;  // Ticker value when thread started waiting.
-  std::atomic<bool> is_idle;    // Has thread become idle yet?
-
-  ThreadIdentity* next;
-};
-
-// Returns the ThreadIdentity object representing the calling thread; guaranteed
-// to be unique for its lifetime.  The returned object will remain valid for the
-// program's lifetime; although it may be re-assigned to a subsequent thread.
-// If one does not exist, return nullptr instead.
-//
-// Does not malloc(*), and is async-signal safe.
-// [*] Technically pthread_setspecific() does malloc on first use; however this
-// is handled internally within tcmalloc's initialization already.
-//
-// New ThreadIdentity objects can be constructed and associated with a thread
-// by calling GetOrCreateCurrentThreadIdentity() in per-thread-sem.h.
-ThreadIdentity* CurrentThreadIdentityIfPresent();
-
-using ThreadIdentityReclaimerFunction = void (*)(void*);
-
-// Sets the current thread identity to the given value.  'reclaimer' is a
-// pointer to the global function for cleaning up instances on thread
-// destruction.
-void SetCurrentThreadIdentity(ThreadIdentity* identity,
-                              ThreadIdentityReclaimerFunction reclaimer);
-
-// Removes the currently associated ThreadIdentity from the running thread.
-// This must be called from inside the ThreadIdentityReclaimerFunction, and only
-// from that function.
-void ClearCurrentThreadIdentity();
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    struct SynchLocksHeld;
+    struct SynchWaitParams;
+
+    namespace base_internal
+    {
+
+        class SpinLock;
+        struct ThreadIdentity;
+
+        // Used by the implementation of absl::Mutex and absl::CondVar.
+        struct PerThreadSynch
+        {
+            // The internal representation of absl::Mutex and absl::CondVar rely
+            // on the alignment of PerThreadSynch. Both store the address of the
+            // PerThreadSynch in the high-order bits of their internal state,
+            // which means the low kLowZeroBits of the address of PerThreadSynch
+            // must be zero.
+            static constexpr int kLowZeroBits = 8;
+            static constexpr int kAlignment = 1 << kLowZeroBits;
+
+            // Returns the associated ThreadIdentity.
+            // This can be implemented as a cast because we guarantee
+            // PerThreadSynch is the first element of ThreadIdentity.
+            ThreadIdentity* thread_identity()
+            {
+                return reinterpret_cast<ThreadIdentity*>(this);
+            }
+
+            PerThreadSynch* next;  // Circular waiter queue; initialized to 0.
+            PerThreadSynch* skip;  // If non-zero, all entries in Mutex queue
+                                   // up to and including "skip" have same
+                                   // condition as this, and will be woken later
+            bool may_skip;         // if false while on mutex queue, a mutex unlocker
+                                   // is using this PerThreadSynch as a terminator.  Its
+                                   // skip field must not be filled in because the loop
+                                   // might then skip over the terminator.
+            bool wake;             // This thread is to be woken from a Mutex.
+            // If "x" is on a waiter list for a mutex, "x->cond_waiter" is true iff the
+            // waiter is waiting on the mutex as part of a CV Wait or Mutex Await.
+            //
+            // The value of "x->cond_waiter" is meaningless if "x" is not on a
+            // Mutex waiter list.
+            bool cond_waiter;
+            bool maybe_unlocking;        // Valid at head of Mutex waiter queue;
+                                         // true if UnlockSlow could be searching
+                                         // for a waiter to wake.  Used for an optimization
+                                         // in Enqueue().  true is always a valid value.
+                                         // Can be reset to false when the unlocker or any
+                                         // writer releases the lock, or a reader fully
+                                         // releases the lock.  It may not be set to false
+                                         // by a reader that decrements the count to
+                                         // non-zero. protected by mutex spinlock
+            bool suppress_fatal_errors;  // If true, try to proceed even in the face
+                                         // of broken invariants.  This is used within
+                                         // fatal signal handlers to improve the
+                                         // chances of debug logging information being
+                                         // output successfully.
+            int priority;                // Priority of thread (updated every so often).
+
+            // State values:
+            //   kAvailable: This PerThreadSynch is available.
+            //   kQueued: This PerThreadSynch is unavailable, it's currently queued on a
+            //            Mutex or CondVar waistlist.
+            //
+            // Transitions from kQueued to kAvailable require a release
+            // barrier. This is needed as a waiter may use "state" to
+            // independently observe that it's no longer queued.
+            //
+            // Transitions from kAvailable to kQueued require no barrier, they
+            // are externally ordered by the Mutex.
+            enum State
+            {
+                kAvailable,
+                kQueued
+            };
+            std::atomic<State> state;
+
+            // The wait parameters of the current wait.  waitp is null if the
+            // thread is not waiting. Transitions from null to non-null must
+            // occur before the enqueue commit point (state = kQueued in
+            // Enqueue() and CondVarEnqueue()). Transitions from non-null to
+            // null must occur after the wait is finished (state = kAvailable in
+            // Mutex::Block() and CondVar::WaitCommon()). This field may be
+            // changed only by the thread that describes this PerThreadSynch.  A
+            // special case is Fer(), which calls Enqueue() on another thread,
+            // but with an identical SynchWaitParams pointer, thus leaving the
+            // pointer unchanged.
+            SynchWaitParams* waitp;
+
+            intptr_t readers;  // Number of readers in mutex.
+
+            // When priority will next be read (cycles).
+            int64_t next_priority_read_cycles;
+
+            // Locks held; used during deadlock detection.
+            // Allocated in Synch_GetAllLocks() and freed in ReclaimThreadIdentity().
+            SynchLocksHeld* all_locks;
+        };
+
+        // The instances of this class are allocated in NewThreadIdentity() with an
+        // alignment of PerThreadSynch::kAlignment.
+        struct ThreadIdentity
+        {
+            // Must be the first member.  The Mutex implementation requires that
+            // the PerThreadSynch object associated with each thread is
+            // PerThreadSynch::kAlignment aligned.  We provide this alignment on
+            // ThreadIdentity itself.
+            PerThreadSynch per_thread_synch;
+
+            // Private: Reserved for absl::synchronization_internal::Waiter.
+            struct WaiterState
+            {
+                alignas(void*) char data[128];
+            } waiter_state;
+
+            // Used by PerThreadSem::{Get,Set}ThreadBlockedCounter().
+            std::atomic<int>* blocked_count_ptr;
+
+            // The following variables are mostly read/written just by the
+            // thread itself.  The only exception is that these are read by
+            // a ticker thread as a hint.
+            std::atomic<int> ticker;      // Tick counter, incremented once per second.
+            std::atomic<int> wait_start;  // Ticker value when thread started waiting.
+            std::atomic<bool> is_idle;    // Has thread become idle yet?
+
+            ThreadIdentity* next;
+        };
+
+        // Returns the ThreadIdentity object representing the calling thread; guaranteed
+        // to be unique for its lifetime.  The returned object will remain valid for the
+        // program's lifetime; although it may be re-assigned to a subsequent thread.
+        // If one does not exist, return nullptr instead.
+        //
+        // Does not malloc(*), and is async-signal safe.
+        // [*] Technically pthread_setspecific() does malloc on first use; however this
+        // is handled internally within tcmalloc's initialization already.
+        //
+        // New ThreadIdentity objects can be constructed and associated with a thread
+        // by calling GetOrCreateCurrentThreadIdentity() in per-thread-sem.h.
+        ThreadIdentity* CurrentThreadIdentityIfPresent();
+
+        using ThreadIdentityReclaimerFunction = void (*)(void*);
+
+        // Sets the current thread identity to the given value.  'reclaimer' is a
+        // pointer to the global function for cleaning up instances on thread
+        // destruction.
+        void SetCurrentThreadIdentity(ThreadIdentity* identity, ThreadIdentityReclaimerFunction reclaimer);
+
+        // Removes the currently associated ThreadIdentity from the running thread.
+        // This must be called from inside the ThreadIdentityReclaimerFunction, and only
+        // from that function.
+        void ClearCurrentThreadIdentity();
 
 // May be chosen at compile time via: -DABSL_FORCE_THREAD_IDENTITY_MODE=<mode
 // index>
@@ -213,7 +219,7 @@ void ClearCurrentThreadIdentity();
 #define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
 #elif defined(__APPLE__) && defined(ABSL_HAVE_THREAD_LOCAL)
 #define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
-#elif ABSL_PER_THREAD_TLS && defined(__GOOGLE_GRTE_VERSION__) &&        \
+#elif ABSL_PER_THREAD_TLS && defined(__GOOGLE_GRTE_VERSION__) && \
     (__GOOGLE_GRTE_VERSION__ >= 20140228L)
 // Support for async-safe TLS was specifically added in GRTEv4.  It's not
 // present in the upstream eglibc.
@@ -221,17 +227,17 @@ void ClearCurrentThreadIdentity();
 #define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_TLS
 #else
 #define ABSL_THREAD_IDENTITY_MODE \
-  ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+    ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
 #endif
 
 #if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
     ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
 
 #if ABSL_PER_THREAD_TLS
-ABSL_CONST_INIT extern ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity*
-    thread_identity_ptr;
+        ABSL_CONST_INIT extern ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity*
+            thread_identity_ptr;
 #elif defined(ABSL_HAVE_THREAD_LOCAL)
-ABSL_CONST_INIT extern thread_local ThreadIdentity* thread_identity_ptr;
+        ABSL_CONST_INIT extern thread_local ThreadIdentity* thread_identity_ptr;
 #else
 #error Thread-local storage not detected on this platform
 #endif
@@ -248,9 +254,10 @@ ABSL_CONST_INIT extern thread_local ThreadIdentity* thread_identity_ptr;
 #endif
 
 #ifdef ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT
-inline ThreadIdentity* CurrentThreadIdentityIfPresent() {
-  return thread_identity_ptr;
-}
+        inline ThreadIdentity* CurrentThreadIdentityIfPresent()
+        {
+            return thread_identity_ptr;
+        }
 #endif
 
 #elif ABSL_THREAD_IDENTITY_MODE != \
@@ -258,8 +265,8 @@ inline ThreadIdentity* CurrentThreadIdentityIfPresent() {
 #error Unknown ABSL_THREAD_IDENTITY_MODE
 #endif
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/throw_delegate.h b/CAPI/cpp/grpc/include/absl/base/internal/throw_delegate.h
index 075f527..379d81d 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/throw_delegate.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/throw_delegate.h
@@ -21,55 +21,57 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-// Helper functions that allow throwing exceptions consistently from anywhere.
-// The main use case is for header-based libraries (eg templates), as they will
-// be built by many different targets with their own compiler options.
-// In particular, this will allow a safe way to throw exceptions even if the
-// caller is compiled with -fno-exceptions.  This is intended for implementing
-// things like map<>::at(), which the standard documents as throwing an
-// exception on error.
-//
-// Using other techniques like #if tricks could lead to ODR violations.
-//
-// You shouldn't use it unless you're writing code that you know will be built
-// both with and without exceptions and you need to conform to an interface
-// that uses exceptions.
+        // Helper functions that allow throwing exceptions consistently from anywhere.
+        // The main use case is for header-based libraries (eg templates), as they will
+        // be built by many different targets with their own compiler options.
+        // In particular, this will allow a safe way to throw exceptions even if the
+        // caller is compiled with -fno-exceptions.  This is intended for implementing
+        // things like map<>::at(), which the standard documents as throwing an
+        // exception on error.
+        //
+        // Using other techniques like #if tricks could lead to ODR violations.
+        //
+        // You shouldn't use it unless you're writing code that you know will be built
+        // both with and without exceptions and you need to conform to an interface
+        // that uses exceptions.
 
-[[noreturn]] void ThrowStdLogicError(const std::string& what_arg);
-[[noreturn]] void ThrowStdLogicError(const char* what_arg);
-[[noreturn]] void ThrowStdInvalidArgument(const std::string& what_arg);
-[[noreturn]] void ThrowStdInvalidArgument(const char* what_arg);
-[[noreturn]] void ThrowStdDomainError(const std::string& what_arg);
-[[noreturn]] void ThrowStdDomainError(const char* what_arg);
-[[noreturn]] void ThrowStdLengthError(const std::string& what_arg);
-[[noreturn]] void ThrowStdLengthError(const char* what_arg);
-[[noreturn]] void ThrowStdOutOfRange(const std::string& what_arg);
-[[noreturn]] void ThrowStdOutOfRange(const char* what_arg);
-[[noreturn]] void ThrowStdRuntimeError(const std::string& what_arg);
-[[noreturn]] void ThrowStdRuntimeError(const char* what_arg);
-[[noreturn]] void ThrowStdRangeError(const std::string& what_arg);
-[[noreturn]] void ThrowStdRangeError(const char* what_arg);
-[[noreturn]] void ThrowStdOverflowError(const std::string& what_arg);
-[[noreturn]] void ThrowStdOverflowError(const char* what_arg);
-[[noreturn]] void ThrowStdUnderflowError(const std::string& what_arg);
-[[noreturn]] void ThrowStdUnderflowError(const char* what_arg);
+        [[noreturn]] void ThrowStdLogicError(const std::string& what_arg);
+        [[noreturn]] void ThrowStdLogicError(const char* what_arg);
+        [[noreturn]] void ThrowStdInvalidArgument(const std::string& what_arg);
+        [[noreturn]] void ThrowStdInvalidArgument(const char* what_arg);
+        [[noreturn]] void ThrowStdDomainError(const std::string& what_arg);
+        [[noreturn]] void ThrowStdDomainError(const char* what_arg);
+        [[noreturn]] void ThrowStdLengthError(const std::string& what_arg);
+        [[noreturn]] void ThrowStdLengthError(const char* what_arg);
+        [[noreturn]] void ThrowStdOutOfRange(const std::string& what_arg);
+        [[noreturn]] void ThrowStdOutOfRange(const char* what_arg);
+        [[noreturn]] void ThrowStdRuntimeError(const std::string& what_arg);
+        [[noreturn]] void ThrowStdRuntimeError(const char* what_arg);
+        [[noreturn]] void ThrowStdRangeError(const std::string& what_arg);
+        [[noreturn]] void ThrowStdRangeError(const char* what_arg);
+        [[noreturn]] void ThrowStdOverflowError(const std::string& what_arg);
+        [[noreturn]] void ThrowStdOverflowError(const char* what_arg);
+        [[noreturn]] void ThrowStdUnderflowError(const std::string& what_arg);
+        [[noreturn]] void ThrowStdUnderflowError(const char* what_arg);
 
-[[noreturn]] void ThrowStdBadFunctionCall();
-[[noreturn]] void ThrowStdBadAlloc();
+        [[noreturn]] void ThrowStdBadFunctionCall();
+        [[noreturn]] void ThrowStdBadAlloc();
 
-// ThrowStdBadArrayNewLength() cannot be consistently supported because
-// std::bad_array_new_length is missing in libstdc++ until 4.9.0.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.3/libstdc++/api/a01379_source.html
-// https://gcc.gnu.org/onlinedocs/gcc-4.9.0/libstdc++/api/a01327_source.html
-// libcxx (as of 3.2) and msvc (as of 2015) both have it.
-// [[noreturn]] void ThrowStdBadArrayNewLength();
+        // ThrowStdBadArrayNewLength() cannot be consistently supported because
+        // std::bad_array_new_length is missing in libstdc++ until 4.9.0.
+        // https://gcc.gnu.org/onlinedocs/gcc-4.8.3/libstdc++/api/a01379_source.html
+        // https://gcc.gnu.org/onlinedocs/gcc-4.9.0/libstdc++/api/a01327_source.html
+        // libcxx (as of 3.2) and msvc (as of 2015) both have it.
+        // [[noreturn]] void ThrowStdBadArrayNewLength();
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/unaligned_access.h b/CAPI/cpp/grpc/include/absl/base/internal/unaligned_access.h
index 093dd9b..524e7c4 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/unaligned_access.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/unaligned_access.h
@@ -31,51 +31,65 @@
 // The unaligned API is C++ only.  The declarations use C++ features
 // (namespaces, inline) which are absent or incompatible in C.
 #if defined(__cplusplus)
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-inline uint16_t UnalignedLoad16(const void *p) {
-  uint16_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline uint32_t UnalignedLoad32(const void *p) {
-  uint32_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline uint64_t UnalignedLoad64(const void *p) {
-  uint64_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline void UnalignedStore16(void *p, uint16_t v) { memcpy(p, &v, sizeof v); }
-
-inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); }
-
-inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
+
+        inline uint16_t UnalignedLoad16(const void* p)
+        {
+            uint16_t t;
+            memcpy(&t, p, sizeof t);
+            return t;
+        }
+
+        inline uint32_t UnalignedLoad32(const void* p)
+        {
+            uint32_t t;
+            memcpy(&t, p, sizeof t);
+            return t;
+        }
+
+        inline uint64_t UnalignedLoad64(const void* p)
+        {
+            uint64_t t;
+            memcpy(&t, p, sizeof t);
+            return t;
+        }
+
+        inline void UnalignedStore16(void* p, uint16_t v)
+        {
+            memcpy(p, &v, sizeof v);
+        }
+
+        inline void UnalignedStore32(void* p, uint32_t v)
+        {
+            memcpy(p, &v, sizeof v);
+        }
+
+        inline void UnalignedStore64(void* p, uint64_t v)
+        {
+            memcpy(p, &v, sizeof v);
+        }
+
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) \
-  (absl::base_internal::UnalignedLoad16(_p))
+    (absl::base_internal::UnalignedLoad16(_p))
 #define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) \
-  (absl::base_internal::UnalignedLoad32(_p))
+    (absl::base_internal::UnalignedLoad32(_p))
 #define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) \
-  (absl::base_internal::UnalignedLoad64(_p))
+    (absl::base_internal::UnalignedLoad64(_p))
 
 #define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
-  (absl::base_internal::UnalignedStore16(_p, _val))
+    (absl::base_internal::UnalignedStore16(_p, _val))
 #define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
-  (absl::base_internal::UnalignedStore32(_p, _val))
+    (absl::base_internal::UnalignedStore32(_p, _val))
 #define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
-  (absl::base_internal::UnalignedStore64(_p, _val))
+    (absl::base_internal::UnalignedStore64(_p, _val))
 
 #endif  // defined(__cplusplus), end of unaligned API
 
diff --git a/CAPI/cpp/grpc/include/absl/base/internal/unscaledcycleclock.h b/CAPI/cpp/grpc/include/absl/base/internal/unscaledcycleclock.h
index 2cbeae3..d7af4bc 100644
--- a/CAPI/cpp/grpc/include/absl/base/internal/unscaledcycleclock.h
+++ b/CAPI/cpp/grpc/include/absl/base/internal/unscaledcycleclock.h
@@ -70,62 +70,67 @@
 // Use "#if ABSL_USE_UNSCALED_CYCLECLOCK" to test for its presence.
 // Can be overridden at compile-time via -DABSL_USE_UNSCALED_CYCLECLOCK=0|1
 #if !defined(ABSL_USE_UNSCALED_CYCLECLOCK)
-#define ABSL_USE_UNSCALED_CYCLECLOCK               \
-  (ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION && \
-   ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT)
+#define ABSL_USE_UNSCALED_CYCLECLOCK                 \
+    (ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION && \
+     ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT)
 #endif
 
 #if ABSL_USE_UNSCALED_CYCLECLOCK
 
 // This macro can be used to test if UnscaledCycleClock::Frequency()
 // is NominalCPUFrequency() on a particular platform.
-#if (defined(__i386__) || defined(__x86_64__) || defined(__riscv) || \
-     defined(_M_IX86) || defined(_M_X64))
+#if (defined(__i386__) || defined(__x86_64__) || defined(__riscv) || defined(_M_IX86) || defined(_M_X64))
 #define ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-class UnscaledCycleClockWrapperForGetCurrentTime;
-}  // namespace time_internal
-
-namespace base_internal {
-class CycleClock;
-class UnscaledCycleClockWrapperForInitializeFrequency;
-
-class UnscaledCycleClock {
- private:
-  UnscaledCycleClock() = delete;
-
-  // Return the value of a cycle counter that counts at a rate that is
-  // approximately constant.
-  static int64_t Now();
-
-  // Return the how much UnscaledCycleClock::Now() increases per second.
-  // This is not necessarily the core CPU clock frequency.
-  // It may be the nominal value report by the kernel, rather than a measured
-  // value.
-  static double Frequency();
-
-  // Allowed users
-  friend class base_internal::CycleClock;
-  friend class time_internal::UnscaledCycleClockWrapperForGetCurrentTime;
-  friend class base_internal::UnscaledCycleClockWrapperForInitializeFrequency;
-};
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        class UnscaledCycleClockWrapperForGetCurrentTime;
+    }  // namespace time_internal
+
+    namespace base_internal
+    {
+        class CycleClock;
+        class UnscaledCycleClockWrapperForInitializeFrequency;
+
+        class UnscaledCycleClock
+        {
+        private:
+            UnscaledCycleClock() = delete;
+
+            // Return the value of a cycle counter that counts at a rate that is
+            // approximately constant.
+            static int64_t Now();
+
+            // Return the how much UnscaledCycleClock::Now() increases per second.
+            // This is not necessarily the core CPU clock frequency.
+            // It may be the nominal value report by the kernel, rather than a measured
+            // value.
+            static double Frequency();
+
+            // Allowed users
+            friend class base_internal::CycleClock;
+            friend class time_internal::UnscaledCycleClockWrapperForGetCurrentTime;
+            friend class base_internal::UnscaledCycleClockWrapperForInitializeFrequency;
+        };
 
 #if defined(__x86_64__)
 
-inline int64_t UnscaledCycleClock::Now() {
-  uint64_t low, high;
-  __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
-  return (high << 32) | low;
-}
+        inline int64_t UnscaledCycleClock::Now()
+        {
+            uint64_t low, high;
+            __asm__ volatile("rdtsc"
+                             : "=a"(low), "=d"(high));
+            return (high << 32) | low;
+        }
 
 #endif
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_USE_UNSCALED_CYCLECLOCK
diff --git a/CAPI/cpp/grpc/include/absl/base/log_severity.h b/CAPI/cpp/grpc/include/absl/base/log_severity.h
index 8bdca38..ba503a0 100644
--- a/CAPI/cpp/grpc/include/absl/base/log_severity.h
+++ b/CAPI/cpp/grpc/include/absl/base/log_severity.h
@@ -21,152 +21,157 @@
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::LogSeverity
-//
-// Four severity levels are defined. Logging APIs should terminate the program
-// when a message is logged at severity `kFatal`; the other levels have no
-// special semantics.
-//
-// Values other than the four defined levels (e.g. produced by `static_cast`)
-// are valid, but their semantics when passed to a function, macro, or flag
-// depend on the function, macro, or flag. The usual behavior is to normalize
-// such values to a defined severity level, however in some cases values other
-// than the defined levels are useful for comparison.
-//
-// Example:
-//
-//   // Effectively disables all logging:
-//   SetMinLogLevel(static_cast<absl::LogSeverity>(100));
-//
-// Abseil flags may be defined with type `LogSeverity`. Dependency layering
-// constraints require that the `AbslParseFlag()` overload be declared and
-// defined in the flags library itself rather than here. The `AbslUnparseFlag()`
-// overload is defined there as well for consistency.
-//
-// absl::LogSeverity Flag String Representation
-//
-// An `absl::LogSeverity` has a string representation used for parsing
-// command-line flags based on the enumerator name (e.g. `kFatal`) or
-// its unprefixed name (without the `k`) in any case-insensitive form. (E.g.
-// "FATAL", "fatal" or "Fatal" are all valid.) Unparsing such flags produces an
-// unprefixed string representation in all caps (e.g. "FATAL") or an integer.
-//
-// Additionally, the parser accepts arbitrary integers (as if the type were
-// `int`).
-//
-// Examples:
-//
-//   --my_log_level=kInfo
-//   --my_log_level=INFO
-//   --my_log_level=info
-//   --my_log_level=0
-//
-// Unparsing a flag produces the same result as `absl::LogSeverityName()` for
-// the standard levels and a base-ten integer otherwise.
-enum class LogSeverity : int {
-  kInfo = 0,
-  kWarning = 1,
-  kError = 2,
-  kFatal = 3,
-};
-
-// LogSeverities()
-//
-// Returns an iterable of all standard `absl::LogSeverity` values, ordered from
-// least to most severe.
-constexpr std::array<absl::LogSeverity, 4> LogSeverities() {
-  return {{absl::LogSeverity::kInfo, absl::LogSeverity::kWarning,
-           absl::LogSeverity::kError, absl::LogSeverity::kFatal}};
-}
-
-// LogSeverityName()
-//
-// Returns the all-caps string representation (e.g. "INFO") of the specified
-// severity level if it is one of the standard levels and "UNKNOWN" otherwise.
-constexpr const char* LogSeverityName(absl::LogSeverity s) {
-  return s == absl::LogSeverity::kInfo
-             ? "INFO"
-             : s == absl::LogSeverity::kWarning
-                   ? "WARNING"
-                   : s == absl::LogSeverity::kError
-                         ? "ERROR"
-                         : s == absl::LogSeverity::kFatal ? "FATAL" : "UNKNOWN";
-}
-
-// NormalizeLogSeverity()
-//
-// Values less than `kInfo` normalize to `kInfo`; values greater than `kFatal`
-// normalize to `kError` (**NOT** `kFatal`).
-constexpr absl::LogSeverity NormalizeLogSeverity(absl::LogSeverity s) {
-  return s < absl::LogSeverity::kInfo
-             ? absl::LogSeverity::kInfo
-             : s > absl::LogSeverity::kFatal ? absl::LogSeverity::kError : s;
-}
-constexpr absl::LogSeverity NormalizeLogSeverity(int s) {
-  return absl::NormalizeLogSeverity(static_cast<absl::LogSeverity>(s));
-}
-
-// operator<<
-//
-// The exact representation of a streamed `absl::LogSeverity` is deliberately
-// unspecified; do not rely on it.
-std::ostream& operator<<(std::ostream& os, absl::LogSeverity s);
-
-// Enums representing a lower bound for LogSeverity. APIs that only operate on
-// messages of at least a certain level (for example, `SetMinLogLevel()`) use
-// this type to specify that level. absl::LogSeverityAtLeast::kInfinity is
-// a level above all threshold levels and therefore no log message will
-// ever meet this threshold.
-enum class LogSeverityAtLeast : int {
-  kInfo = static_cast<int>(absl::LogSeverity::kInfo),
-  kWarning = static_cast<int>(absl::LogSeverity::kWarning),
-  kError = static_cast<int>(absl::LogSeverity::kError),
-  kFatal = static_cast<int>(absl::LogSeverity::kFatal),
-  kInfinity = 1000,
-};
-
-std::ostream& operator<<(std::ostream& os, absl::LogSeverityAtLeast s);
-
-// Enums representing an upper bound for LogSeverity. APIs that only operate on
-// messages of at most a certain level (for example, buffer all messages at or
-// below a certain level) use this type to specify that level.
-// absl::LogSeverityAtMost::kNegativeInfinity is a level below all threshold
-// levels and therefore will exclude all log messages.
-enum class LogSeverityAtMost : int {
-  kNegativeInfinity = -1000,
-  kInfo = static_cast<int>(absl::LogSeverity::kInfo),
-  kWarning = static_cast<int>(absl::LogSeverity::kWarning),
-  kError = static_cast<int>(absl::LogSeverity::kError),
-  kFatal = static_cast<int>(absl::LogSeverity::kFatal),
-};
-
-std::ostream& operator<<(std::ostream& os, absl::LogSeverityAtMost s);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::LogSeverity
+    //
+    // Four severity levels are defined. Logging APIs should terminate the program
+    // when a message is logged at severity `kFatal`; the other levels have no
+    // special semantics.
+    //
+    // Values other than the four defined levels (e.g. produced by `static_cast`)
+    // are valid, but their semantics when passed to a function, macro, or flag
+    // depend on the function, macro, or flag. The usual behavior is to normalize
+    // such values to a defined severity level, however in some cases values other
+    // than the defined levels are useful for comparison.
+    //
+    // Example:
+    //
+    //   // Effectively disables all logging:
+    //   SetMinLogLevel(static_cast<absl::LogSeverity>(100));
+    //
+    // Abseil flags may be defined with type `LogSeverity`. Dependency layering
+    // constraints require that the `AbslParseFlag()` overload be declared and
+    // defined in the flags library itself rather than here. The `AbslUnparseFlag()`
+    // overload is defined there as well for consistency.
+    //
+    // absl::LogSeverity Flag String Representation
+    //
+    // An `absl::LogSeverity` has a string representation used for parsing
+    // command-line flags based on the enumerator name (e.g. `kFatal`) or
+    // its unprefixed name (without the `k`) in any case-insensitive form. (E.g.
+    // "FATAL", "fatal" or "Fatal" are all valid.) Unparsing such flags produces an
+    // unprefixed string representation in all caps (e.g. "FATAL") or an integer.
+    //
+    // Additionally, the parser accepts arbitrary integers (as if the type were
+    // `int`).
+    //
+    // Examples:
+    //
+    //   --my_log_level=kInfo
+    //   --my_log_level=INFO
+    //   --my_log_level=info
+    //   --my_log_level=0
+    //
+    // Unparsing a flag produces the same result as `absl::LogSeverityName()` for
+    // the standard levels and a base-ten integer otherwise.
+    enum class LogSeverity : int
+    {
+        kInfo = 0,
+        kWarning = 1,
+        kError = 2,
+        kFatal = 3,
+    };
+
+    // LogSeverities()
+    //
+    // Returns an iterable of all standard `absl::LogSeverity` values, ordered from
+    // least to most severe.
+    constexpr std::array<absl::LogSeverity, 4> LogSeverities()
+    {
+        return {{absl::LogSeverity::kInfo, absl::LogSeverity::kWarning, absl::LogSeverity::kError, absl::LogSeverity::kFatal}};
+    }
+
+    // LogSeverityName()
+    //
+    // Returns the all-caps string representation (e.g. "INFO") of the specified
+    // severity level if it is one of the standard levels and "UNKNOWN" otherwise.
+    constexpr const char* LogSeverityName(absl::LogSeverity s)
+    {
+        return s == absl::LogSeverity::kInfo ? "INFO" : s == absl::LogSeverity::kWarning ? "WARNING" :
+                                                    s == absl::LogSeverity::kError       ? "ERROR" :
+                                                    s == absl::LogSeverity::kFatal       ? "FATAL" :
+                                                                                           "UNKNOWN";
+    }
+
+    // NormalizeLogSeverity()
+    //
+    // Values less than `kInfo` normalize to `kInfo`; values greater than `kFatal`
+    // normalize to `kError` (**NOT** `kFatal`).
+    constexpr absl::LogSeverity NormalizeLogSeverity(absl::LogSeverity s)
+    {
+        return s < absl::LogSeverity::kInfo ? absl::LogSeverity::kInfo : s > absl::LogSeverity::kFatal ? absl::LogSeverity::kError :
+                                                                                                         s;
+    }
+    constexpr absl::LogSeverity NormalizeLogSeverity(int s)
+    {
+        return absl::NormalizeLogSeverity(static_cast<absl::LogSeverity>(s));
+    }
+
+    // operator<<
+    //
+    // The exact representation of a streamed `absl::LogSeverity` is deliberately
+    // unspecified; do not rely on it.
+    std::ostream& operator<<(std::ostream& os, absl::LogSeverity s);
+
+    // Enums representing a lower bound for LogSeverity. APIs that only operate on
+    // messages of at least a certain level (for example, `SetMinLogLevel()`) use
+    // this type to specify that level. absl::LogSeverityAtLeast::kInfinity is
+    // a level above all threshold levels and therefore no log message will
+    // ever meet this threshold.
+    enum class LogSeverityAtLeast : int
+    {
+        kInfo = static_cast<int>(absl::LogSeverity::kInfo),
+        kWarning = static_cast<int>(absl::LogSeverity::kWarning),
+        kError = static_cast<int>(absl::LogSeverity::kError),
+        kFatal = static_cast<int>(absl::LogSeverity::kFatal),
+        kInfinity = 1000,
+    };
+
+    std::ostream& operator<<(std::ostream& os, absl::LogSeverityAtLeast s);
+
+    // Enums representing an upper bound for LogSeverity. APIs that only operate on
+    // messages of at most a certain level (for example, buffer all messages at or
+    // below a certain level) use this type to specify that level.
+    // absl::LogSeverityAtMost::kNegativeInfinity is a level below all threshold
+    // levels and therefore will exclude all log messages.
+    enum class LogSeverityAtMost : int
+    {
+        kNegativeInfinity = -1000,
+        kInfo = static_cast<int>(absl::LogSeverity::kInfo),
+        kWarning = static_cast<int>(absl::LogSeverity::kWarning),
+        kError = static_cast<int>(absl::LogSeverity::kError),
+        kFatal = static_cast<int>(absl::LogSeverity::kFatal),
+    };
+
+    std::ostream& operator<<(std::ostream& os, absl::LogSeverityAtMost s);
 
 #define COMPOP(op1, op2, T)                                         \
-  constexpr bool operator op1(absl::T lhs, absl::LogSeverity rhs) { \
-    return static_cast<absl::LogSeverity>(lhs) op1 rhs;             \
-  }                                                                 \
-  constexpr bool operator op2(absl::LogSeverity lhs, absl::T rhs) { \
-    return lhs op2 static_cast<absl::LogSeverity>(rhs);             \
-  }
-
-// Comparisons between `LogSeverity` and `LogSeverityAtLeast`/
-// `LogSeverityAtMost` are only supported in one direction.
-// Valid checks are:
-//   LogSeverity >= LogSeverityAtLeast
-//   LogSeverity < LogSeverityAtLeast
-//   LogSeverity <= LogSeverityAtMost
-//   LogSeverity > LogSeverityAtMost
-COMPOP(>, <, LogSeverityAtLeast)
-COMPOP(<=, >=, LogSeverityAtLeast)
-COMPOP(<, >, LogSeverityAtMost)
-COMPOP(>=, <=, LogSeverityAtMost)
+    constexpr bool operator op1(absl::T lhs, absl::LogSeverity rhs) \
+    {                                                               \
+        return static_cast<absl::LogSeverity>(lhs) op1 rhs;         \
+    }                                                               \
+    constexpr bool operator op2(absl::LogSeverity lhs, absl::T rhs) \
+    {                                                               \
+        return lhs op2 static_cast<absl::LogSeverity>(rhs);         \
+    }
+
+    // Comparisons between `LogSeverity` and `LogSeverityAtLeast`/
+    // `LogSeverityAtMost` are only supported in one direction.
+    // Valid checks are:
+    //   LogSeverity >= LogSeverityAtLeast
+    //   LogSeverity < LogSeverityAtLeast
+    //   LogSeverity <= LogSeverityAtMost
+    //   LogSeverity > LogSeverityAtMost
+    COMPOP(>, <, LogSeverityAtLeast)
+    COMPOP(<=, >=, LogSeverityAtLeast)
+    COMPOP(<, >, LogSeverityAtMost)
+    COMPOP(>=, <=, LogSeverityAtMost)
 #undef COMPOP
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_LOG_SEVERITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/base/macros.h b/CAPI/cpp/grpc/include/absl/base/macros.h
index 3e085a9..e9a7e7a 100644
--- a/CAPI/cpp/grpc/include/absl/base/macros.h
+++ b/CAPI/cpp/grpc/include/absl/base/macros.h
@@ -42,17 +42,19 @@
 // can be used in defining new arrays. If you use this macro on a pointer by
 // mistake, you will get a compile-time error.
 #define ABSL_ARRAYSIZE(array) \
-  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
+    (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace macros_internal {
-// Note: this internal template function declaration is used by ABSL_ARRAYSIZE.
-// The function doesn't need a definition, as we only use its type.
-template <typename T, size_t N>
-auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
-}  // namespace macros_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace macros_internal
+    {
+        // Note: this internal template function declaration is used by ABSL_ARRAYSIZE.
+        // The function doesn't need a definition, as we only use its type.
+        template<typename T, size_t N>
+        auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
+    }  // namespace macros_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // ABSL_BAD_CALL_IF()
@@ -75,7 +77,7 @@ ABSL_NAMESPACE_END
 //   #endif // ABSL_BAD_CALL_IF
 #if ABSL_HAVE_ATTRIBUTE(enable_if)
 #define ABSL_BAD_CALL_IF(expr, msg) \
-  __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
+    __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
 #endif
 
 // ABSL_ASSERT()
@@ -92,25 +94,24 @@ ABSL_NAMESPACE_END
 // https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
 #if defined(NDEBUG)
 #define ABSL_ASSERT(expr) \
-  (false ? static_cast<void>(expr) : static_cast<void>(0))
+    (false ? static_cast<void>(expr) : static_cast<void>(0))
 #else
-#define ABSL_ASSERT(expr)                           \
-  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
-                             : [] { assert(false && #expr); }())  // NOLINT
+#define ABSL_ASSERT(expr) \
+    (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) : [] { assert(false && #expr); }())  // NOLINT
 #endif
 
 // `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`
 // aborts the program in release mode (when NDEBUG is defined). The
 // implementation should abort the program as quickly as possible and ideally it
 // should not be possible to ignore the abort request.
-#if (ABSL_HAVE_BUILTIN(__builtin_trap) &&         \
-     ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
+#if (ABSL_HAVE_BUILTIN(__builtin_trap) && ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
     (defined(__GNUC__) && !defined(__clang__))
 #define ABSL_INTERNAL_HARDENING_ABORT() \
-  do {                                  \
-    __builtin_trap();                   \
-    __builtin_unreachable();            \
-  } while (false)
+    do                                  \
+    {                                   \
+        __builtin_trap();               \
+        __builtin_unreachable();        \
+    } while (false)
 #else
 #define ABSL_INTERNAL_HARDENING_ABORT() abort()
 #endif
@@ -127,9 +128,8 @@ ABSL_NAMESPACE_END
 // See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
 // hardened mode.
 #if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
-#define ABSL_HARDENING_ASSERT(expr)                 \
-  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
-                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
+#define ABSL_HARDENING_ASSERT(expr) \
+    (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
 #else
 #define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
 #endif
@@ -137,11 +137,18 @@ ABSL_NAMESPACE_END
 #ifdef ABSL_HAVE_EXCEPTIONS
 #define ABSL_INTERNAL_TRY try
 #define ABSL_INTERNAL_CATCH_ANY catch (...)
-#define ABSL_INTERNAL_RETHROW do { throw; } while (false)
+#define ABSL_INTERNAL_RETHROW \
+    do                        \
+    {                         \
+        throw;                \
+    } while (false)
 #else  // ABSL_HAVE_EXCEPTIONS
 #define ABSL_INTERNAL_TRY if (true)
 #define ABSL_INTERNAL_CATCH_ANY else if (false)
-#define ABSL_INTERNAL_RETHROW do {} while (false)
+#define ABSL_INTERNAL_RETHROW \
+    do                        \
+    {                         \
+    } while (false)
 #endif  // ABSL_HAVE_EXCEPTIONS
 
 // `ABSL_INTERNAL_UNREACHABLE` is an unreachable statement.  A program which
diff --git a/CAPI/cpp/grpc/include/absl/base/optimization.h b/CAPI/cpp/grpc/include/absl/base/optimization.h
index db5cc09..77592b0 100644
--- a/CAPI/cpp/grpc/include/absl/base/optimization.h
+++ b/CAPI/cpp/grpc/include/absl/base/optimization.h
@@ -40,7 +40,11 @@
 //     return result;
 //   }
 #if defined(__pnacl__)
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() \
+    if (volatile int x = 0)                 \
+    {                                       \
+        (void)x;                            \
+    }
 #elif defined(__clang__)
 // Clang will not tail call given inline volatile assembly.
 #define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
@@ -52,7 +56,11 @@
 // The __nop() intrinsic blocks the optimisation.
 #define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
 #else
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() \
+    if (volatile int x = 0)                 \
+    {                                       \
+        (void)x;                            \
+    }
 #endif
 
 // ABSL_CACHELINE_SIZE
@@ -210,17 +218,20 @@
 #elif ABSL_HAVE_BUILTIN(__builtin_assume)
 #define ABSL_ASSUME(cond) __builtin_assume(cond)
 #elif defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable)
-#define ABSL_ASSUME(cond)                 \
-  do {                                    \
-    if (!(cond)) __builtin_unreachable(); \
-  } while (0)
+#define ABSL_ASSUME(cond)            \
+    do                               \
+    {                                \
+        if (!(cond))                 \
+            __builtin_unreachable(); \
+    } while (0)
 #elif defined(_MSC_VER)
 #define ABSL_ASSUME(cond) __assume(cond)
 #else
-#define ABSL_ASSUME(cond)               \
-  do {                                  \
-    static_cast<void>(false && (cond)); \
-  } while (0)
+#define ABSL_ASSUME(cond)                   \
+    do                                      \
+    {                                       \
+        static_cast<void>(false && (cond)); \
+    } while (0)
 #endif
 
 // ABSL_INTERNAL_UNIQUE_SMALL_NAME(cond)
@@ -244,7 +255,7 @@
 #define ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x) #x
 #define ABSL_INTERNAL_UNIQUE_SMALL_NAME1(x) ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x)
 #define ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
-  asm(ABSL_INTERNAL_UNIQUE_SMALL_NAME1(.absl.__COUNTER__))
+    asm(ABSL_INTERNAL_UNIQUE_SMALL_NAME1(.absl.__COUNTER__))
 #else
 #define ABSL_INTERNAL_UNIQUE_SMALL_NAME()
 #endif
diff --git a/CAPI/cpp/grpc/include/absl/base/options.h b/CAPI/cpp/grpc/include/absl/base/options.h
index 13aeda3..cc589bb 100644
--- a/CAPI/cpp/grpc/include/absl/base/options.h
+++ b/CAPI/cpp/grpc/include/absl/base/options.h
@@ -102,7 +102,6 @@
 
 #define ABSL_OPTION_USE_STD_ANY 0
 
-
 // ABSL_OPTION_USE_STD_OPTIONAL
 //
 // This option controls whether absl::optional is implemented as an alias to
@@ -129,7 +128,6 @@
 
 #define ABSL_OPTION_USE_STD_OPTIONAL 0
 
-
 // ABSL_OPTION_USE_STD_STRING_VIEW
 //
 // This option controls whether absl::string_view is implemented as an alias to
@@ -182,7 +180,6 @@
 
 #define ABSL_OPTION_USE_STD_VARIANT 0
 
-
 // ABSL_OPTION_USE_INLINE_NAMESPACE
 // ABSL_OPTION_INLINE_NAMESPACE_NAME
 //
diff --git a/CAPI/cpp/grpc/include/absl/base/thread_annotations.h b/CAPI/cpp/grpc/include/absl/base/thread_annotations.h
index bc8a620..fc2fc2c 100644
--- a/CAPI/cpp/grpc/include/absl/base/thread_annotations.h
+++ b/CAPI/cpp/grpc/include/absl/base/thread_annotations.h
@@ -140,14 +140,14 @@
 //   void bar() const ABSL_SHARED_LOCKS_REQUIRED(mu1, mu2) { ... }
 #if ABSL_HAVE_ATTRIBUTE(exclusive_locks_required)
 #define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) \
-  __attribute__((exclusive_locks_required(__VA_ARGS__)))
+    __attribute__((exclusive_locks_required(__VA_ARGS__)))
 #else
 #define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...)
 #endif
 
 #if ABSL_HAVE_ATTRIBUTE(shared_locks_required)
 #define ABSL_SHARED_LOCKS_REQUIRED(...) \
-  __attribute__((shared_locks_required(__VA_ARGS__)))
+    __attribute__((shared_locks_required(__VA_ARGS__)))
 #else
 #define ABSL_SHARED_LOCKS_REQUIRED(...)
 #endif
@@ -202,7 +202,7 @@
 // not release it.
 #if ABSL_HAVE_ATTRIBUTE(exclusive_lock_function)
 #define ABSL_EXCLUSIVE_LOCK_FUNCTION(...) \
-  __attribute__((exclusive_lock_function(__VA_ARGS__)))
+    __attribute__((exclusive_lock_function(__VA_ARGS__)))
 #else
 #define ABSL_EXCLUSIVE_LOCK_FUNCTION(...)
 #endif
@@ -213,7 +213,7 @@
 // function, and do not release it.
 #if ABSL_HAVE_ATTRIBUTE(shared_lock_function)
 #define ABSL_SHARED_LOCK_FUNCTION(...) \
-  __attribute__((shared_lock_function(__VA_ARGS__)))
+    __attribute__((shared_lock_function(__VA_ARGS__)))
 #else
 #define ABSL_SHARED_LOCK_FUNCTION(...)
 #endif
@@ -238,14 +238,14 @@
 // mutex is assumed to be `this`.
 #if ABSL_HAVE_ATTRIBUTE(exclusive_trylock_function)
 #define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
-  __attribute__((exclusive_trylock_function(__VA_ARGS__)))
+    __attribute__((exclusive_trylock_function(__VA_ARGS__)))
 #else
 #define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...)
 #endif
 
 #if ABSL_HAVE_ATTRIBUTE(shared_trylock_function)
 #define ABSL_SHARED_TRYLOCK_FUNCTION(...) \
-  __attribute__((shared_trylock_function(__VA_ARGS__)))
+    __attribute__((shared_trylock_function(__VA_ARGS__)))
 #else
 #define ABSL_SHARED_TRYLOCK_FUNCTION(...)
 #endif
@@ -256,14 +256,14 @@
 // if it is not held.
 #if ABSL_HAVE_ATTRIBUTE(assert_exclusive_lock)
 #define ABSL_ASSERT_EXCLUSIVE_LOCK(...) \
-  __attribute__((assert_exclusive_lock(__VA_ARGS__)))
+    __attribute__((assert_exclusive_lock(__VA_ARGS__)))
 #else
 #define ABSL_ASSERT_EXCLUSIVE_LOCK(...)
 #endif
 
 #if ABSL_HAVE_ATTRIBUTE(assert_shared_lock)
 #define ABSL_ASSERT_SHARED_LOCK(...) \
-  __attribute__((assert_shared_lock(__VA_ARGS__)))
+    __attribute__((assert_shared_lock(__VA_ARGS__)))
 #else
 #define ABSL_ASSERT_SHARED_LOCK(...)
 #endif
@@ -275,7 +275,7 @@
 // the locking behavior is more complicated than the analyzer can handle.
 #if ABSL_HAVE_ATTRIBUTE(no_thread_safety_analysis)
 #define ABSL_NO_THREAD_SAFETY_ANALYSIS \
-  __attribute__((no_thread_safety_analysis))
+    __attribute__((no_thread_safety_analysis))
 #else
 #define ABSL_NO_THREAD_SAFETY_ANALYSIS
 #endif
@@ -311,25 +311,29 @@
 // but the compiler cannot confirm that.
 #define ABSL_TS_UNCHECKED_READ(x) absl::base_internal::ts_unchecked_read(x)
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace base_internal
+    {
 
-// Takes a reference to a guarded data member, and returns an unguarded
-// reference.
-// Do not use this function directly, use ABSL_TS_UNCHECKED_READ instead.
-template <typename T>
-inline const T& ts_unchecked_read(const T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  return v;
-}
+        // Takes a reference to a guarded data member, and returns an unguarded
+        // reference.
+        // Do not use this function directly, use ABSL_TS_UNCHECKED_READ instead.
+        template<typename T>
+        inline const T& ts_unchecked_read(const T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS
+        {
+            return v;
+        }
 
-template <typename T>
-inline T& ts_unchecked_read(T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  return v;
-}
+        template<typename T>
+        inline T& ts_unchecked_read(T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS
+        {
+            return v;
+        }
 
-}  // namespace base_internal
-ABSL_NAMESPACE_END
+    }  // namespace base_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_BASE_THREAD_ANNOTATIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/cleanup/cleanup.h b/CAPI/cpp/grpc/include/absl/cleanup/cleanup.h
index 960ccd0..e4a38c3 100644
--- a/CAPI/cpp/grpc/include/absl/cleanup/cleanup.h
+++ b/CAPI/cpp/grpc/include/absl/cleanup/cleanup.h
@@ -74,67 +74,73 @@
 #include "absl/base/macros.h"
 #include "absl/cleanup/internal/cleanup.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename Arg, typename Callback = void()>
-class ABSL_MUST_USE_RESULT Cleanup final {
-  static_assert(cleanup_internal::WasDeduced<Arg>(),
-                "Explicit template parameters are not supported.");
-
-  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
-                "Callbacks that return values are not supported.");
-
- public:
-  Cleanup(Callback callback) : storage_(std::move(callback)) {}  // NOLINT
-
-  Cleanup(Cleanup&& other) = default;
-
-  void Cancel() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
-    storage_.DestroyCallback();
-  }
-
-  void Invoke() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
-    storage_.InvokeCallback();
-    storage_.DestroyCallback();
-  }
-
-  ~Cleanup() {
-    if (storage_.IsCallbackEngaged()) {
-      storage_.InvokeCallback();
-      storage_.DestroyCallback();
-    }
-  }
-
- private:
-  cleanup_internal::Storage<Callback> storage_;
-};
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    template<typename Arg, typename Callback = void()>
+    class ABSL_MUST_USE_RESULT Cleanup final
+    {
+        static_assert(cleanup_internal::WasDeduced<Arg>(), "Explicit template parameters are not supported.");
+
+        static_assert(cleanup_internal::ReturnsVoid<Callback>(), "Callbacks that return values are not supported.");
+
+    public:
+        Cleanup(Callback callback) :
+            storage_(std::move(callback))
+        {
+        }  // NOLINT
+
+        Cleanup(Cleanup&& other) = default;
+
+        void Cancel() &&
+        {
+            ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+            storage_.DestroyCallback();
+        }
+
+        void Invoke() &&
+        {
+            ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+            storage_.InvokeCallback();
+            storage_.DestroyCallback();
+        }
+
+        ~Cleanup()
+        {
+            if (storage_.IsCallbackEngaged())
+            {
+                storage_.InvokeCallback();
+                storage_.DestroyCallback();
+            }
+        }
+
+    private:
+        cleanup_internal::Storage<Callback> storage_;
+    };
 
 // `absl::Cleanup c = /* callback */;`
 //
 // C++17 type deduction API for creating an instance of `absl::Cleanup`
 #if defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
-template <typename Callback>
-Cleanup(Callback callback) -> Cleanup<cleanup_internal::Tag, Callback>;
+    template<typename Callback>
+    Cleanup(Callback callback) -> Cleanup<cleanup_internal::Tag, Callback>;
 #endif  // defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
 
-// `auto c = absl::MakeCleanup(/* callback */);`
-//
-// C++11 type deduction API for creating an instance of `absl::Cleanup`
-template <typename... Args, typename Callback>
-absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
-  static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(),
-                "Explicit template parameters are not supported.");
+    // `auto c = absl::MakeCleanup(/* callback */);`
+    //
+    // C++11 type deduction API for creating an instance of `absl::Cleanup`
+    template<typename... Args, typename Callback>
+    absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback)
+    {
+        static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(), "Explicit template parameters are not supported.");
 
-  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
-                "Callbacks that return values are not supported.");
+        static_assert(cleanup_internal::ReturnsVoid<Callback>(), "Callbacks that return values are not supported.");
 
-  return {std::move(callback)};
-}
+        return {std::move(callback)};
+    }
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CLEANUP_CLEANUP_H_
diff --git a/CAPI/cpp/grpc/include/absl/cleanup/internal/cleanup.h b/CAPI/cpp/grpc/include/absl/cleanup/internal/cleanup.h
index 2783fcb..d493035 100644
--- a/CAPI/cpp/grpc/include/absl/cleanup/internal/cleanup.h
+++ b/CAPI/cpp/grpc/include/absl/cleanup/internal/cleanup.h
@@ -24,77 +24,95 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace cleanup_internal {
-
-struct Tag {};
-
-template <typename Arg, typename... Args>
-constexpr bool WasDeduced() {
-  return (std::is_same<cleanup_internal::Tag, Arg>::value) &&
-         (sizeof...(Args) == 0);
-}
-
-template <typename Callback>
-constexpr bool ReturnsVoid() {
-  return (std::is_same<base_internal::invoke_result_t<Callback>, void>::value);
-}
-
-template <typename Callback>
-class Storage {
- public:
-  Storage() = delete;
-
-  explicit Storage(Callback callback) {
-    // Placement-new into a character buffer is used for eager destruction when
-    // the cleanup is invoked or cancelled. To ensure this optimizes well, the
-    // behavior is implemented locally instead of using an absl::optional.
-    ::new (GetCallbackBuffer()) Callback(std::move(callback));
-    is_callback_engaged_ = true;
-  }
-
-  Storage(Storage&& other) {
-    ABSL_HARDENING_ASSERT(other.IsCallbackEngaged());
-
-    ::new (GetCallbackBuffer()) Callback(std::move(other.GetCallback()));
-    is_callback_engaged_ = true;
-
-    other.DestroyCallback();
-  }
-
-  Storage(const Storage& other) = delete;
-
-  Storage& operator=(Storage&& other) = delete;
-
-  Storage& operator=(const Storage& other) = delete;
-
-  void* GetCallbackBuffer() { return static_cast<void*>(+callback_buffer_); }
-
-  Callback& GetCallback() {
-    return *reinterpret_cast<Callback*>(GetCallbackBuffer());
-  }
-
-  bool IsCallbackEngaged() const { return is_callback_engaged_; }
-
-  void DestroyCallback() {
-    is_callback_engaged_ = false;
-    GetCallback().~Callback();
-  }
-
-  void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS {
-    std::move(GetCallback())();
-  }
-
- private:
-  bool is_callback_engaged_;
-  alignas(Callback) char callback_buffer_[sizeof(Callback)];
-};
-
-}  // namespace cleanup_internal
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    namespace cleanup_internal
+    {
+
+        struct Tag
+        {
+        };
+
+        template<typename Arg, typename... Args>
+        constexpr bool WasDeduced()
+        {
+            return (std::is_same<cleanup_internal::Tag, Arg>::value) &&
+                   (sizeof...(Args) == 0);
+        }
+
+        template<typename Callback>
+        constexpr bool ReturnsVoid()
+        {
+            return (std::is_same<base_internal::invoke_result_t<Callback>, void>::value);
+        }
+
+        template<typename Callback>
+        class Storage
+        {
+        public:
+            Storage() = delete;
+
+            explicit Storage(Callback callback)
+            {
+                // Placement-new into a character buffer is used for eager destruction when
+                // the cleanup is invoked or cancelled. To ensure this optimizes well, the
+                // behavior is implemented locally instead of using an absl::optional.
+                ::new (GetCallbackBuffer()) Callback(std::move(callback));
+                is_callback_engaged_ = true;
+            }
+
+            Storage(Storage&& other)
+            {
+                ABSL_HARDENING_ASSERT(other.IsCallbackEngaged());
+
+                ::new (GetCallbackBuffer()) Callback(std::move(other.GetCallback()));
+                is_callback_engaged_ = true;
+
+                other.DestroyCallback();
+            }
+
+            Storage(const Storage& other) = delete;
+
+            Storage& operator=(Storage&& other) = delete;
+
+            Storage& operator=(const Storage& other) = delete;
+
+            void* GetCallbackBuffer()
+            {
+                return static_cast<void*>(+callback_buffer_);
+            }
+
+            Callback& GetCallback()
+            {
+                return *reinterpret_cast<Callback*>(GetCallbackBuffer());
+            }
+
+            bool IsCallbackEngaged() const
+            {
+                return is_callback_engaged_;
+            }
+
+            void DestroyCallback()
+            {
+                is_callback_engaged_ = false;
+                GetCallback().~Callback();
+            }
+
+            void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS
+            {
+                std::move(GetCallback())();
+            }
+
+        private:
+            bool is_callback_engaged_;
+            alignas(Callback) char callback_buffer_[sizeof(Callback)];
+        };
+
+    }  // namespace cleanup_internal
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CLEANUP_INTERNAL_CLEANUP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/btree_map.h b/CAPI/cpp/grpc/include/absl/container/btree_map.h
index 286817f..2de7106 100644
--- a/CAPI/cpp/grpc/include/absl/container/btree_map.h
+++ b/CAPI/cpp/grpc/include/absl/container/btree_map.h
@@ -50,802 +50,820 @@
 #ifndef ABSL_CONTAINER_BTREE_MAP_H_
 #define ABSL_CONTAINER_BTREE_MAP_H_
 
-#include "absl/container/internal/btree.h"  // IWYU pragma: export
+#include "absl/container/internal/btree.h"            // IWYU pragma: export
 #include "absl/container/internal/btree_container.h"  // IWYU pragma: export
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace container_internal {
-
-template <typename Key, typename Data, typename Compare, typename Alloc,
-          int TargetNodeSize, bool IsMulti>
-struct map_params;
-
-}  // namespace container_internal
-
-// absl::btree_map<>
-//
-// An `absl::btree_map<K, V>` is an ordered associative container of
-// unique keys and associated values designed to be a more efficient replacement
-// for `std::map` (in most cases).
-//
-// Keys are sorted using an (optional) comparison function, which defaults to
-// `std::less<K>`.
-//
-// An `absl::btree_map<K, V>` uses a default allocator of
-// `std::allocator<std::pair<const K, V>>` to allocate (and deallocate)
-// nodes, and construct and destruct values within those nodes. You may
-// instead specify a custom allocator `A` (which in turn requires specifying a
-// custom comparator `C`) as in `absl::btree_map<K, V, C, A>`.
-//
-template <typename Key, typename Value, typename Compare = std::less<Key>,
-          typename Alloc = std::allocator<std::pair<const Key, Value>>>
-class btree_map
-    : public container_internal::btree_map_container<
-          container_internal::btree<container_internal::map_params<
-              Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
-              /*IsMulti=*/false>>> {
-  using Base = typename btree_map::btree_map_container;
-
- public:
-  // Constructors and Assignment Operators
-  //
-  // A `btree_map` supports the same overload set as `std::map`
-  // for construction and assignment:
-  //
-  // * Default constructor
-  //
-  //   absl::btree_map<int, std::string> map1;
-  //
-  // * Initializer List constructor
-  //
-  //   absl::btree_map<int, std::string> map2 =
-  //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
-  //
-  // * Copy constructor
-  //
-  //   absl::btree_map<int, std::string> map3(map2);
-  //
-  // * Copy assignment operator
-  //
-  //  absl::btree_map<int, std::string> map4;
-  //  map4 = map3;
-  //
-  // * Move constructor
-  //
-  //   // Move is guaranteed efficient
-  //   absl::btree_map<int, std::string> map5(std::move(map4));
-  //
-  // * Move assignment operator
-  //
-  //   // May be efficient if allocators are compatible
-  //   absl::btree_map<int, std::string> map6;
-  //   map6 = std::move(map5);
-  //
-  // * Range constructor
-  //
-  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
-  //   absl::btree_map<int, std::string> map7(v.begin(), v.end());
-  btree_map() {}
-  using Base::Base;
-
-  // btree_map::begin()
-  //
-  // Returns an iterator to the beginning of the `btree_map`.
-  using Base::begin;
-
-  // btree_map::cbegin()
-  //
-  // Returns a const iterator to the beginning of the `btree_map`.
-  using Base::cbegin;
-
-  // btree_map::end()
-  //
-  // Returns an iterator to the end of the `btree_map`.
-  using Base::end;
-
-  // btree_map::cend()
-  //
-  // Returns a const iterator to the end of the `btree_map`.
-  using Base::cend;
-
-  // btree_map::empty()
-  //
-  // Returns whether or not the `btree_map` is empty.
-  using Base::empty;
-
-  // btree_map::max_size()
-  //
-  // Returns the largest theoretical possible number of elements within a
-  // `btree_map` under current memory constraints. This value can be thought
-  // of as the largest value of `std::distance(begin(), end())` for a
-  // `btree_map<Key, T>`.
-  using Base::max_size;
-
-  // btree_map::size()
-  //
-  // Returns the number of elements currently within the `btree_map`.
-  using Base::size;
-
-  // btree_map::clear()
-  //
-  // Removes all elements from the `btree_map`. Invalidates any references,
-  // pointers, or iterators referring to contained elements.
-  using Base::clear;
-
-  // btree_map::erase()
-  //
-  // Erases elements within the `btree_map`. If an erase occurs, any references,
-  // pointers, or iterators are invalidated.
-  // Overloads are listed below.
-  //
-  // iterator erase(iterator position):
-  // iterator erase(const_iterator position):
-  //
-  //   Erases the element at `position` of the `btree_map`, returning
-  //   the iterator pointing to the element after the one that was erased
-  //   (or end() if none exists).
-  //
-  // iterator erase(const_iterator first, const_iterator last):
-  //
-  //   Erases the elements in the open interval [`first`, `last`), returning
-  //   the iterator pointing to the element after the interval that was erased
-  //   (or end() if none exists).
-  //
-  // template <typename K> size_type erase(const K& key):
-  //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
-  using Base::erase;
-
-  // btree_map::insert()
-  //
-  // Inserts an element of the specified value into the `btree_map`,
-  // returning an iterator pointing to the newly inserted element, provided that
-  // an element with the given key does not already exist. If an insertion
-  // occurs, any references, pointers, or iterators are invalidated.
-  // Overloads are listed below.
-  //
-  // std::pair<iterator,bool> insert(const value_type& value):
-  //
-  //   Inserts a value into the `btree_map`. Returns a pair consisting of an
-  //   iterator to the inserted element (or to the element that prevented the
-  //   insertion) and a bool denoting whether the insertion took place.
-  //
-  // std::pair<iterator,bool> insert(value_type&& value):
-  //
-  //   Inserts a moveable value into the `btree_map`. Returns a pair
-  //   consisting of an iterator to the inserted element (or to the element that
-  //   prevented the insertion) and a bool denoting whether the insertion took
-  //   place.
-  //
-  // iterator insert(const_iterator hint, const value_type& value):
-  // iterator insert(const_iterator hint, value_type&& value):
-  //
-  //   Inserts a value, using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search. Returns an iterator to the
-  //   inserted element, or to the existing element that prevented the
-  //   insertion.
-  //
-  // void insert(InputIterator first, InputIterator last):
-  //
-  //   Inserts a range of values [`first`, `last`).
-  //
-  // void insert(std::initializer_list<init_type> ilist):
-  //
-  //   Inserts the elements within the initializer list `ilist`.
-  using Base::insert;
-
-  // btree_map::insert_or_assign()
-  //
-  // Inserts an element of the specified value into the `btree_map` provided
-  // that a value with the given key does not already exist, or replaces the
-  // corresponding mapped type with the forwarded `obj` argument if a key for
-  // that value already exists, returning an iterator pointing to the newly
-  // inserted element. Overloads are listed below.
-  //
-  // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj):
-  // pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj):
-  //
-  //   Inserts/Assigns (or moves) the element of the specified key into the
-  //   `btree_map`. If the returned bool is true, insertion took place, and if
-  //   it's false, assignment took place.
-  //
-  // iterator insert_or_assign(const_iterator hint,
-  //                           const key_type& k, M&& obj):
-  // iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj):
-  //
-  //   Inserts/Assigns (or moves) the element of the specified key into the
-  //   `btree_map` using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search.
-  using Base::insert_or_assign;
-
-  // btree_map::emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_map`, provided that no element with the given key
-  // already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately. Prefer `try_emplace()` unless your key is not
-  // copyable or moveable.
-  //
-  // If an insertion occurs, any references, pointers, or iterators are
-  // invalidated.
-  using Base::emplace;
-
-  // btree_map::emplace_hint()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_map`, using the position of `hint` as a non-binding
-  // suggestion for where to begin the insertion search, and only inserts
-  // provided that no element with the given key already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately. Prefer `try_emplace()` unless your key is not
-  // copyable or moveable.
-  //
-  // If an insertion occurs, any references, pointers, or iterators are
-  // invalidated.
-  using Base::emplace_hint;
-
-  // btree_map::try_emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_map`, provided that no element with the given key
-  // already exists. Unlike `emplace()`, if an element with the given key
-  // already exists, we guarantee that no element is constructed.
-  //
-  // If an insertion occurs, any references, pointers, or iterators are
-  // invalidated.
-  //
-  // Overloads are listed below.
-  //
-  //   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
-  //   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
-  //
-  // Inserts (via copy or move) the element of the specified key into the
-  // `btree_map`.
-  //
-  //   iterator try_emplace(const_iterator hint,
-  //                        const key_type& k, Args&&... args):
-  //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
-  //
-  // Inserts (via copy or move) the element of the specified key into the
-  // `btree_map` using the position of `hint` as a non-binding suggestion
-  // for where to begin the insertion search.
-  using Base::try_emplace;
-
-  // btree_map::extract()
-  //
-  // Extracts the indicated element, erasing it in the process, and returns it
-  // as a C++17-compatible node handle. Overloads are listed below.
-  //
-  // node_type extract(const_iterator position):
-  //
-  //   Extracts the element at the indicated position and returns a node handle
-  //   owning that extracted data.
-  //
-  // template <typename K> node_type extract(const K& k):
-  //
-  //   Extracts the element with the key matching the passed key value and
-  //   returns a node handle owning that extracted data. If the `btree_map`
-  //   does not contain an element with a matching key, this function returns an
-  //   empty node handle.
-  //
-  // NOTE: when compiled in an earlier version of C++ than C++17,
-  // `node_type::key()` returns a const reference to the key instead of a
-  // mutable reference. We cannot safely return a mutable reference without
-  // std::launder (which is not available before C++17).
-  //
-  // NOTE: In this context, `node_type` refers to the C++17 concept of a
-  // move-only type that owns and provides access to the elements in associative
-  // containers (https://en.cppreference.com/w/cpp/container/node_handle).
-  // It does NOT refer to the data layout of the underlying btree.
-  using Base::extract;
-
-  // btree_map::merge()
-  //
-  // Extracts elements from a given `source` btree_map into this
-  // `btree_map`. If the destination `btree_map` already contains an
-  // element with an equivalent key, that element is not extracted.
-  using Base::merge;
-
-  // btree_map::swap(btree_map& other)
-  //
-  // Exchanges the contents of this `btree_map` with those of the `other`
-  // btree_map, avoiding invocation of any move, copy, or swap operations on
-  // individual elements.
-  //
-  // All iterators and references on the `btree_map` remain valid, excepting
-  // for the past-the-end iterator, which is invalidated.
-  using Base::swap;
-
-  // btree_map::at()
-  //
-  // Returns a reference to the mapped value of the element with key equivalent
-  // to the passed key.
-  using Base::at;
-
-  // btree_map::contains()
-  //
-  // template <typename K> bool contains(const K& key) const:
-  //
-  // Determines whether an element comparing equal to the given `key` exists
-  // within the `btree_map`, returning `true` if so or `false` otherwise.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::contains;
-
-  // btree_map::count()
-  //
-  // template <typename K> size_type count(const K& key) const:
-  //
-  // Returns the number of elements comparing equal to the given `key` within
-  // the `btree_map`. Note that this function will return either `1` or `0`
-  // since duplicate elements are not allowed within a `btree_map`.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::count;
-
-  // btree_map::equal_range()
-  //
-  // Returns a half-open range [first, last), defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the `btree_map`.
-  using Base::equal_range;
-
-  // btree_map::find()
-  //
-  // template <typename K> iterator find(const K& key):
-  // template <typename K> const_iterator find(const K& key) const:
-  //
-  // Finds an element with the passed `key` within the `btree_map`.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::find;
-
-  // btree_map::lower_bound()
-  //
-  // template <typename K> iterator lower_bound(const K& key):
-  // template <typename K> const_iterator lower_bound(const K& key) const:
-  //
-  // Finds the first element with a key that is not less than `key` within the
-  // `btree_map`.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::lower_bound;
-
-  // btree_map::upper_bound()
-  //
-  // template <typename K> iterator upper_bound(const K& key):
-  // template <typename K> const_iterator upper_bound(const K& key) const:
-  //
-  // Finds the first element with a key that is greater than `key` within the
-  // `btree_map`.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::upper_bound;
-
-  // btree_map::operator[]()
-  //
-  // Returns a reference to the value mapped to the passed key within the
-  // `btree_map`, performing an `insert()` if the key does not already
-  // exist.
-  //
-  // If an insertion occurs, any references, pointers, or iterators are
-  // invalidated. Otherwise iterators are not affected and references are not
-  // invalidated. Overloads are listed below.
-  //
-  // T& operator[](key_type&& key):
-  // T& operator[](const key_type& key):
-  //
-  //   Inserts a value_type object constructed in-place if the element with the
-  //   given key does not exist.
-  using Base::operator[];
-
-  // btree_map::get_allocator()
-  //
-  // Returns the allocator function associated with this `btree_map`.
-  using Base::get_allocator;
-
-  // btree_map::key_comp();
-  //
-  // Returns the key comparator associated with this `btree_map`.
-  using Base::key_comp;
-
-  // btree_map::value_comp();
-  //
-  // Returns the value comparator associated with this `btree_map`.
-  using Base::value_comp;
-};
-
-// absl::swap(absl::btree_map<>, absl::btree_map<>)
-//
-// Swaps the contents of two `absl::btree_map` containers.
-template <typename K, typename V, typename C, typename A>
-void swap(btree_map<K, V, C, A> &x, btree_map<K, V, C, A> &y) {
-  return x.swap(y);
-}
-
-// absl::erase_if(absl::btree_map<>, Pred)
-//
-// Erases all elements that satisfy the predicate pred from the container.
-// Returns the number of erased elements.
-template <typename K, typename V, typename C, typename A, typename Pred>
-typename btree_map<K, V, C, A>::size_type erase_if(
-    btree_map<K, V, C, A> &map, Pred pred) {
-  return container_internal::btree_access::erase_if(map, std::move(pred));
-}
-
-// absl::btree_multimap
-//
-// An `absl::btree_multimap<K, V>` is an ordered associative container of
-// keys and associated values designed to be a more efficient replacement for
-// `std::multimap` (in most cases). Unlike `absl::btree_map`, a B-tree multimap
-// allows multiple elements with equivalent keys.
-//
-// Keys are sorted using an (optional) comparison function, which defaults to
-// `std::less<K>`.
-//
-// An `absl::btree_multimap<K, V>` uses a default allocator of
-// `std::allocator<std::pair<const K, V>>` to allocate (and deallocate)
-// nodes, and construct and destruct values within those nodes. You may
-// instead specify a custom allocator `A` (which in turn requires specifying a
-// custom comparator `C`) as in `absl::btree_multimap<K, V, C, A>`.
-//
-template <typename Key, typename Value, typename Compare = std::less<Key>,
-          typename Alloc = std::allocator<std::pair<const Key, Value>>>
-class btree_multimap
-    : public container_internal::btree_multimap_container<
-          container_internal::btree<container_internal::map_params<
-              Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
-              /*IsMulti=*/true>>> {
-  using Base = typename btree_multimap::btree_multimap_container;
-
- public:
-  // Constructors and Assignment Operators
-  //
-  // A `btree_multimap` supports the same overload set as `std::multimap`
-  // for construction and assignment:
-  //
-  // * Default constructor
-  //
-  //   absl::btree_multimap<int, std::string> map1;
-  //
-  // * Initializer List constructor
-  //
-  //   absl::btree_multimap<int, std::string> map2 =
-  //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
-  //
-  // * Copy constructor
-  //
-  //   absl::btree_multimap<int, std::string> map3(map2);
-  //
-  // * Copy assignment operator
-  //
-  //  absl::btree_multimap<int, std::string> map4;
-  //  map4 = map3;
-  //
-  // * Move constructor
-  //
-  //   // Move is guaranteed efficient
-  //   absl::btree_multimap<int, std::string> map5(std::move(map4));
-  //
-  // * Move assignment operator
-  //
-  //   // May be efficient if allocators are compatible
-  //   absl::btree_multimap<int, std::string> map6;
-  //   map6 = std::move(map5);
-  //
-  // * Range constructor
-  //
-  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
-  //   absl::btree_multimap<int, std::string> map7(v.begin(), v.end());
-  btree_multimap() {}
-  using Base::Base;
-
-  // btree_multimap::begin()
-  //
-  // Returns an iterator to the beginning of the `btree_multimap`.
-  using Base::begin;
-
-  // btree_multimap::cbegin()
-  //
-  // Returns a const iterator to the beginning of the `btree_multimap`.
-  using Base::cbegin;
-
-  // btree_multimap::end()
-  //
-  // Returns an iterator to the end of the `btree_multimap`.
-  using Base::end;
-
-  // btree_multimap::cend()
-  //
-  // Returns a const iterator to the end of the `btree_multimap`.
-  using Base::cend;
-
-  // btree_multimap::empty()
-  //
-  // Returns whether or not the `btree_multimap` is empty.
-  using Base::empty;
-
-  // btree_multimap::max_size()
-  //
-  // Returns the largest theoretical possible number of elements within a
-  // `btree_multimap` under current memory constraints. This value can be
-  // thought of as the largest value of `std::distance(begin(), end())` for a
-  // `btree_multimap<Key, T>`.
-  using Base::max_size;
-
-  // btree_multimap::size()
-  //
-  // Returns the number of elements currently within the `btree_multimap`.
-  using Base::size;
-
-  // btree_multimap::clear()
-  //
-  // Removes all elements from the `btree_multimap`. Invalidates any references,
-  // pointers, or iterators referring to contained elements.
-  using Base::clear;
-
-  // btree_multimap::erase()
-  //
-  // Erases elements within the `btree_multimap`. If an erase occurs, any
-  // references, pointers, or iterators are invalidated.
-  // Overloads are listed below.
-  //
-  // iterator erase(iterator position):
-  // iterator erase(const_iterator position):
-  //
-  //   Erases the element at `position` of the `btree_multimap`, returning
-  //   the iterator pointing to the element after the one that was erased
-  //   (or end() if none exists).
-  //
-  // iterator erase(const_iterator first, const_iterator last):
-  //
-  //   Erases the elements in the open interval [`first`, `last`), returning
-  //   the iterator pointing to the element after the interval that was erased
-  //   (or end() if none exists).
-  //
-  // template <typename K> size_type erase(const K& key):
-  //
-  //   Erases the elements matching the key, if any exist, returning the
-  //   number of elements erased.
-  using Base::erase;
-
-  // btree_multimap::insert()
-  //
-  // Inserts an element of the specified value into the `btree_multimap`,
-  // returning an iterator pointing to the newly inserted element.
-  // Any references, pointers, or iterators are invalidated.  Overloads are
-  // listed below.
-  //
-  // iterator insert(const value_type& value):
-  //
-  //   Inserts a value into the `btree_multimap`, returning an iterator to the
-  //   inserted element.
-  //
-  // iterator insert(value_type&& value):
-  //
-  //   Inserts a moveable value into the `btree_multimap`, returning an iterator
-  //   to the inserted element.
-  //
-  // iterator insert(const_iterator hint, const value_type& value):
-  // iterator insert(const_iterator hint, value_type&& value):
-  //
-  //   Inserts a value, using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search. Returns an iterator to the
-  //   inserted element.
-  //
-  // void insert(InputIterator first, InputIterator last):
-  //
-  //   Inserts a range of values [`first`, `last`).
-  //
-  // void insert(std::initializer_list<init_type> ilist):
-  //
-  //   Inserts the elements within the initializer list `ilist`.
-  using Base::insert;
-
-  // btree_multimap::emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_multimap`. Any references, pointers, or iterators are
-  // invalidated.
-  using Base::emplace;
-
-  // btree_multimap::emplace_hint()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_multimap`, using the position of `hint` as a non-binding
-  // suggestion for where to begin the insertion search.
-  //
-  // Any references, pointers, or iterators are invalidated.
-  using Base::emplace_hint;
-
-  // btree_multimap::extract()
-  //
-  // Extracts the indicated element, erasing it in the process, and returns it
-  // as a C++17-compatible node handle. Overloads are listed below.
-  //
-  // node_type extract(const_iterator position):
-  //
-  //   Extracts the element at the indicated position and returns a node handle
-  //   owning that extracted data.
-  //
-  // template <typename K> node_type extract(const K& k):
-  //
-  //   Extracts the element with the key matching the passed key value and
-  //   returns a node handle owning that extracted data. If the `btree_multimap`
-  //   does not contain an element with a matching key, this function returns an
-  //   empty node handle.
-  //
-  // NOTE: when compiled in an earlier version of C++ than C++17,
-  // `node_type::key()` returns a const reference to the key instead of a
-  // mutable reference. We cannot safely return a mutable reference without
-  // std::launder (which is not available before C++17).
-  //
-  // NOTE: In this context, `node_type` refers to the C++17 concept of a
-  // move-only type that owns and provides access to the elements in associative
-  // containers (https://en.cppreference.com/w/cpp/container/node_handle).
-  // It does NOT refer to the data layout of the underlying btree.
-  using Base::extract;
-
-  // btree_multimap::merge()
-  //
-  // Extracts all elements from a given `source` btree_multimap into this
-  // `btree_multimap`.
-  using Base::merge;
-
-  // btree_multimap::swap(btree_multimap& other)
-  //
-  // Exchanges the contents of this `btree_multimap` with those of the `other`
-  // btree_multimap, avoiding invocation of any move, copy, or swap operations
-  // on individual elements.
-  //
-  // All iterators and references on the `btree_multimap` remain valid,
-  // excepting for the past-the-end iterator, which is invalidated.
-  using Base::swap;
-
-  // btree_multimap::contains()
-  //
-  // template <typename K> bool contains(const K& key) const:
-  //
-  // Determines whether an element comparing equal to the given `key` exists
-  // within the `btree_multimap`, returning `true` if so or `false` otherwise.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::contains;
-
-  // btree_multimap::count()
-  //
-  // template <typename K> size_type count(const K& key) const:
-  //
-  // Returns the number of elements comparing equal to the given `key` within
-  // the `btree_multimap`.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::count;
-
-  // btree_multimap::equal_range()
-  //
-  // Returns a half-open range [first, last), defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the
-  // `btree_multimap`.
-  using Base::equal_range;
-
-  // btree_multimap::find()
-  //
-  // template <typename K> iterator find(const K& key):
-  // template <typename K> const_iterator find(const K& key) const:
-  //
-  // Finds an element with the passed `key` within the `btree_multimap`.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::find;
-
-  // btree_multimap::lower_bound()
-  //
-  // template <typename K> iterator lower_bound(const K& key):
-  // template <typename K> const_iterator lower_bound(const K& key) const:
-  //
-  // Finds the first element with a key that is not less than `key` within the
-  // `btree_multimap`.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::lower_bound;
-
-  // btree_multimap::upper_bound()
-  //
-  // template <typename K> iterator upper_bound(const K& key):
-  // template <typename K> const_iterator upper_bound(const K& key) const:
-  //
-  // Finds the first element with a key that is greater than `key` within the
-  // `btree_multimap`.
-  //
-  // Supports heterogeneous lookup, provided that the map has a compatible
-  // heterogeneous comparator.
-  using Base::upper_bound;
-
-  // btree_multimap::get_allocator()
-  //
-  // Returns the allocator function associated with this `btree_multimap`.
-  using Base::get_allocator;
-
-  // btree_multimap::key_comp();
-  //
-  // Returns the key comparator associated with this `btree_multimap`.
-  using Base::key_comp;
-
-  // btree_multimap::value_comp();
-  //
-  // Returns the value comparator associated with this `btree_multimap`.
-  using Base::value_comp;
-};
-
-// absl::swap(absl::btree_multimap<>, absl::btree_multimap<>)
-//
-// Swaps the contents of two `absl::btree_multimap` containers.
-template <typename K, typename V, typename C, typename A>
-void swap(btree_multimap<K, V, C, A> &x, btree_multimap<K, V, C, A> &y) {
-  return x.swap(y);
-}
-
-// absl::erase_if(absl::btree_multimap<>, Pred)
-//
-// Erases all elements that satisfy the predicate pred from the container.
-// Returns the number of erased elements.
-template <typename K, typename V, typename C, typename A, typename Pred>
-typename btree_multimap<K, V, C, A>::size_type erase_if(
-    btree_multimap<K, V, C, A> &map, Pred pred) {
-  return container_internal::btree_access::erase_if(map, std::move(pred));
-}
-
-namespace container_internal {
-
-// A parameters structure for holding the type parameters for a btree_map.
-// Compare and Alloc should be nothrow copy-constructible.
-template <typename Key, typename Data, typename Compare, typename Alloc,
-          int TargetNodeSize, bool IsMulti>
-struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
-                                  /*IsMap=*/true, map_slot_policy<Key, Data>> {
-  using super_type = typename map_params::common_params;
-  using mapped_type = Data;
-  // This type allows us to move keys when it is safe to do so. It is safe
-  // for maps in which value_type and mutable_value_type are layout compatible.
-  using slot_policy = typename super_type::slot_policy;
-  using slot_type = typename super_type::slot_type;
-  using value_type = typename super_type::value_type;
-  using init_type = typename super_type::init_type;
-
-  template <typename V>
-  static auto key(const V &value) -> decltype(value.first) {
-    return value.first;
-  }
-  static const Key &key(const slot_type *s) { return slot_policy::key(s); }
-  static const Key &key(slot_type *s) { return slot_policy::key(s); }
-  // For use in node handle.
-  static auto mutable_key(slot_type *s)
-      -> decltype(slot_policy::mutable_key(s)) {
-    return slot_policy::mutable_key(s);
-  }
-  static mapped_type &value(value_type *value) { return value->second; }
-};
-
-}  // namespace container_internal
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    namespace container_internal
+    {
+
+        template<typename Key, typename Data, typename Compare, typename Alloc, int TargetNodeSize, bool IsMulti>
+        struct map_params;
+
+    }  // namespace container_internal
+
+    // absl::btree_map<>
+    //
+    // An `absl::btree_map<K, V>` is an ordered associative container of
+    // unique keys and associated values designed to be a more efficient replacement
+    // for `std::map` (in most cases).
+    //
+    // Keys are sorted using an (optional) comparison function, which defaults to
+    // `std::less<K>`.
+    //
+    // An `absl::btree_map<K, V>` uses a default allocator of
+    // `std::allocator<std::pair<const K, V>>` to allocate (and deallocate)
+    // nodes, and construct and destruct values within those nodes. You may
+    // instead specify a custom allocator `A` (which in turn requires specifying a
+    // custom comparator `C`) as in `absl::btree_map<K, V, C, A>`.
+    //
+    template<typename Key, typename Value, typename Compare = std::less<Key>, typename Alloc = std::allocator<std::pair<const Key, Value>>>
+    class btree_map : public container_internal::btree_map_container<container_internal::btree<container_internal::map_params<Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
+                                                                                                                              /*IsMulti=*/false>>>
+    {
+        using Base = typename btree_map::btree_map_container;
+
+    public:
+        // Constructors and Assignment Operators
+        //
+        // A `btree_map` supports the same overload set as `std::map`
+        // for construction and assignment:
+        //
+        // * Default constructor
+        //
+        //   absl::btree_map<int, std::string> map1;
+        //
+        // * Initializer List constructor
+        //
+        //   absl::btree_map<int, std::string> map2 =
+        //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
+        //
+        // * Copy constructor
+        //
+        //   absl::btree_map<int, std::string> map3(map2);
+        //
+        // * Copy assignment operator
+        //
+        //  absl::btree_map<int, std::string> map4;
+        //  map4 = map3;
+        //
+        // * Move constructor
+        //
+        //   // Move is guaranteed efficient
+        //   absl::btree_map<int, std::string> map5(std::move(map4));
+        //
+        // * Move assignment operator
+        //
+        //   // May be efficient if allocators are compatible
+        //   absl::btree_map<int, std::string> map6;
+        //   map6 = std::move(map5);
+        //
+        // * Range constructor
+        //
+        //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+        //   absl::btree_map<int, std::string> map7(v.begin(), v.end());
+        btree_map()
+        {
+        }
+        using Base::Base;
+
+        // btree_map::begin()
+        //
+        // Returns an iterator to the beginning of the `btree_map`.
+        using Base::begin;
+
+        // btree_map::cbegin()
+        //
+        // Returns a const iterator to the beginning of the `btree_map`.
+        using Base::cbegin;
+
+        // btree_map::end()
+        //
+        // Returns an iterator to the end of the `btree_map`.
+        using Base::end;
+
+        // btree_map::cend()
+        //
+        // Returns a const iterator to the end of the `btree_map`.
+        using Base::cend;
+
+        // btree_map::empty()
+        //
+        // Returns whether or not the `btree_map` is empty.
+        using Base::empty;
+
+        // btree_map::max_size()
+        //
+        // Returns the largest theoretical possible number of elements within a
+        // `btree_map` under current memory constraints. This value can be thought
+        // of as the largest value of `std::distance(begin(), end())` for a
+        // `btree_map<Key, T>`.
+        using Base::max_size;
+
+        // btree_map::size()
+        //
+        // Returns the number of elements currently within the `btree_map`.
+        using Base::size;
+
+        // btree_map::clear()
+        //
+        // Removes all elements from the `btree_map`. Invalidates any references,
+        // pointers, or iterators referring to contained elements.
+        using Base::clear;
+
+        // btree_map::erase()
+        //
+        // Erases elements within the `btree_map`. If an erase occurs, any references,
+        // pointers, or iterators are invalidated.
+        // Overloads are listed below.
+        //
+        // iterator erase(iterator position):
+        // iterator erase(const_iterator position):
+        //
+        //   Erases the element at `position` of the `btree_map`, returning
+        //   the iterator pointing to the element after the one that was erased
+        //   (or end() if none exists).
+        //
+        // iterator erase(const_iterator first, const_iterator last):
+        //
+        //   Erases the elements in the open interval [`first`, `last`), returning
+        //   the iterator pointing to the element after the interval that was erased
+        //   (or end() if none exists).
+        //
+        // template <typename K> size_type erase(const K& key):
+        //
+        //   Erases the element with the matching key, if it exists, returning the
+        //   number of elements erased (0 or 1).
+        using Base::erase;
+
+        // btree_map::insert()
+        //
+        // Inserts an element of the specified value into the `btree_map`,
+        // returning an iterator pointing to the newly inserted element, provided that
+        // an element with the given key does not already exist. If an insertion
+        // occurs, any references, pointers, or iterators are invalidated.
+        // Overloads are listed below.
+        //
+        // std::pair<iterator,bool> insert(const value_type& value):
+        //
+        //   Inserts a value into the `btree_map`. Returns a pair consisting of an
+        //   iterator to the inserted element (or to the element that prevented the
+        //   insertion) and a bool denoting whether the insertion took place.
+        //
+        // std::pair<iterator,bool> insert(value_type&& value):
+        //
+        //   Inserts a moveable value into the `btree_map`. Returns a pair
+        //   consisting of an iterator to the inserted element (or to the element that
+        //   prevented the insertion) and a bool denoting whether the insertion took
+        //   place.
+        //
+        // iterator insert(const_iterator hint, const value_type& value):
+        // iterator insert(const_iterator hint, value_type&& value):
+        //
+        //   Inserts a value, using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search. Returns an iterator to the
+        //   inserted element, or to the existing element that prevented the
+        //   insertion.
+        //
+        // void insert(InputIterator first, InputIterator last):
+        //
+        //   Inserts a range of values [`first`, `last`).
+        //
+        // void insert(std::initializer_list<init_type> ilist):
+        //
+        //   Inserts the elements within the initializer list `ilist`.
+        using Base::insert;
+
+        // btree_map::insert_or_assign()
+        //
+        // Inserts an element of the specified value into the `btree_map` provided
+        // that a value with the given key does not already exist, or replaces the
+        // corresponding mapped type with the forwarded `obj` argument if a key for
+        // that value already exists, returning an iterator pointing to the newly
+        // inserted element. Overloads are listed below.
+        //
+        // pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj):
+        // pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj):
+        //
+        //   Inserts/Assigns (or moves) the element of the specified key into the
+        //   `btree_map`. If the returned bool is true, insertion took place, and if
+        //   it's false, assignment took place.
+        //
+        // iterator insert_or_assign(const_iterator hint,
+        //                           const key_type& k, M&& obj):
+        // iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj):
+        //
+        //   Inserts/Assigns (or moves) the element of the specified key into the
+        //   `btree_map` using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search.
+        using Base::insert_or_assign;
+
+        // btree_map::emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_map`, provided that no element with the given key
+        // already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately. Prefer `try_emplace()` unless your key is not
+        // copyable or moveable.
+        //
+        // If an insertion occurs, any references, pointers, or iterators are
+        // invalidated.
+        using Base::emplace;
+
+        // btree_map::emplace_hint()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_map`, using the position of `hint` as a non-binding
+        // suggestion for where to begin the insertion search, and only inserts
+        // provided that no element with the given key already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately. Prefer `try_emplace()` unless your key is not
+        // copyable or moveable.
+        //
+        // If an insertion occurs, any references, pointers, or iterators are
+        // invalidated.
+        using Base::emplace_hint;
+
+        // btree_map::try_emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_map`, provided that no element with the given key
+        // already exists. Unlike `emplace()`, if an element with the given key
+        // already exists, we guarantee that no element is constructed.
+        //
+        // If an insertion occurs, any references, pointers, or iterators are
+        // invalidated.
+        //
+        // Overloads are listed below.
+        //
+        //   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
+        //   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
+        //
+        // Inserts (via copy or move) the element of the specified key into the
+        // `btree_map`.
+        //
+        //   iterator try_emplace(const_iterator hint,
+        //                        const key_type& k, Args&&... args):
+        //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
+        //
+        // Inserts (via copy or move) the element of the specified key into the
+        // `btree_map` using the position of `hint` as a non-binding suggestion
+        // for where to begin the insertion search.
+        using Base::try_emplace;
+
+        // btree_map::extract()
+        //
+        // Extracts the indicated element, erasing it in the process, and returns it
+        // as a C++17-compatible node handle. Overloads are listed below.
+        //
+        // node_type extract(const_iterator position):
+        //
+        //   Extracts the element at the indicated position and returns a node handle
+        //   owning that extracted data.
+        //
+        // template <typename K> node_type extract(const K& k):
+        //
+        //   Extracts the element with the key matching the passed key value and
+        //   returns a node handle owning that extracted data. If the `btree_map`
+        //   does not contain an element with a matching key, this function returns an
+        //   empty node handle.
+        //
+        // NOTE: when compiled in an earlier version of C++ than C++17,
+        // `node_type::key()` returns a const reference to the key instead of a
+        // mutable reference. We cannot safely return a mutable reference without
+        // std::launder (which is not available before C++17).
+        //
+        // NOTE: In this context, `node_type` refers to the C++17 concept of a
+        // move-only type that owns and provides access to the elements in associative
+        // containers (https://en.cppreference.com/w/cpp/container/node_handle).
+        // It does NOT refer to the data layout of the underlying btree.
+        using Base::extract;
+
+        // btree_map::merge()
+        //
+        // Extracts elements from a given `source` btree_map into this
+        // `btree_map`. If the destination `btree_map` already contains an
+        // element with an equivalent key, that element is not extracted.
+        using Base::merge;
+
+        // btree_map::swap(btree_map& other)
+        //
+        // Exchanges the contents of this `btree_map` with those of the `other`
+        // btree_map, avoiding invocation of any move, copy, or swap operations on
+        // individual elements.
+        //
+        // All iterators and references on the `btree_map` remain valid, excepting
+        // for the past-the-end iterator, which is invalidated.
+        using Base::swap;
+
+        // btree_map::at()
+        //
+        // Returns a reference to the mapped value of the element with key equivalent
+        // to the passed key.
+        using Base::at;
+
+        // btree_map::contains()
+        //
+        // template <typename K> bool contains(const K& key) const:
+        //
+        // Determines whether an element comparing equal to the given `key` exists
+        // within the `btree_map`, returning `true` if so or `false` otherwise.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::contains;
+
+        // btree_map::count()
+        //
+        // template <typename K> size_type count(const K& key) const:
+        //
+        // Returns the number of elements comparing equal to the given `key` within
+        // the `btree_map`. Note that this function will return either `1` or `0`
+        // since duplicate elements are not allowed within a `btree_map`.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::count;
+
+        // btree_map::equal_range()
+        //
+        // Returns a half-open range [first, last), defined by a `std::pair` of two
+        // iterators, containing all elements with the passed key in the `btree_map`.
+        using Base::equal_range;
+
+        // btree_map::find()
+        //
+        // template <typename K> iterator find(const K& key):
+        // template <typename K> const_iterator find(const K& key) const:
+        //
+        // Finds an element with the passed `key` within the `btree_map`.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::find;
+
+        // btree_map::lower_bound()
+        //
+        // template <typename K> iterator lower_bound(const K& key):
+        // template <typename K> const_iterator lower_bound(const K& key) const:
+        //
+        // Finds the first element with a key that is not less than `key` within the
+        // `btree_map`.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::lower_bound;
+
+        // btree_map::upper_bound()
+        //
+        // template <typename K> iterator upper_bound(const K& key):
+        // template <typename K> const_iterator upper_bound(const K& key) const:
+        //
+        // Finds the first element with a key that is greater than `key` within the
+        // `btree_map`.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::upper_bound;
+
+        // btree_map::operator[]()
+        //
+        // Returns a reference to the value mapped to the passed key within the
+        // `btree_map`, performing an `insert()` if the key does not already
+        // exist.
+        //
+        // If an insertion occurs, any references, pointers, or iterators are
+        // invalidated. Otherwise iterators are not affected and references are not
+        // invalidated. Overloads are listed below.
+        //
+        // T& operator[](key_type&& key):
+        // T& operator[](const key_type& key):
+        //
+        //   Inserts a value_type object constructed in-place if the element with the
+        //   given key does not exist.
+        using Base::operator[];
+
+        // btree_map::get_allocator()
+        //
+        // Returns the allocator function associated with this `btree_map`.
+        using Base::get_allocator;
+
+        // btree_map::key_comp();
+        //
+        // Returns the key comparator associated with this `btree_map`.
+        using Base::key_comp;
+
+        // btree_map::value_comp();
+        //
+        // Returns the value comparator associated with this `btree_map`.
+        using Base::value_comp;
+    };
+
+    // absl::swap(absl::btree_map<>, absl::btree_map<>)
+    //
+    // Swaps the contents of two `absl::btree_map` containers.
+    template<typename K, typename V, typename C, typename A>
+    void swap(btree_map<K, V, C, A>& x, btree_map<K, V, C, A>& y)
+    {
+        return x.swap(y);
+    }
+
+    // absl::erase_if(absl::btree_map<>, Pred)
+    //
+    // Erases all elements that satisfy the predicate pred from the container.
+    // Returns the number of erased elements.
+    template<typename K, typename V, typename C, typename A, typename Pred>
+    typename btree_map<K, V, C, A>::size_type erase_if(
+        btree_map<K, V, C, A>& map, Pred pred
+    )
+    {
+        return container_internal::btree_access::erase_if(map, std::move(pred));
+    }
+
+    // absl::btree_multimap
+    //
+    // An `absl::btree_multimap<K, V>` is an ordered associative container of
+    // keys and associated values designed to be a more efficient replacement for
+    // `std::multimap` (in most cases). Unlike `absl::btree_map`, a B-tree multimap
+    // allows multiple elements with equivalent keys.
+    //
+    // Keys are sorted using an (optional) comparison function, which defaults to
+    // `std::less<K>`.
+    //
+    // An `absl::btree_multimap<K, V>` uses a default allocator of
+    // `std::allocator<std::pair<const K, V>>` to allocate (and deallocate)
+    // nodes, and construct and destruct values within those nodes. You may
+    // instead specify a custom allocator `A` (which in turn requires specifying a
+    // custom comparator `C`) as in `absl::btree_multimap<K, V, C, A>`.
+    //
+    template<typename Key, typename Value, typename Compare = std::less<Key>, typename Alloc = std::allocator<std::pair<const Key, Value>>>
+    class btree_multimap : public container_internal::btree_multimap_container<container_internal::btree<container_internal::map_params<Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
+                                                                                                                                        /*IsMulti=*/true>>>
+    {
+        using Base = typename btree_multimap::btree_multimap_container;
+
+    public:
+        // Constructors and Assignment Operators
+        //
+        // A `btree_multimap` supports the same overload set as `std::multimap`
+        // for construction and assignment:
+        //
+        // * Default constructor
+        //
+        //   absl::btree_multimap<int, std::string> map1;
+        //
+        // * Initializer List constructor
+        //
+        //   absl::btree_multimap<int, std::string> map2 =
+        //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
+        //
+        // * Copy constructor
+        //
+        //   absl::btree_multimap<int, std::string> map3(map2);
+        //
+        // * Copy assignment operator
+        //
+        //  absl::btree_multimap<int, std::string> map4;
+        //  map4 = map3;
+        //
+        // * Move constructor
+        //
+        //   // Move is guaranteed efficient
+        //   absl::btree_multimap<int, std::string> map5(std::move(map4));
+        //
+        // * Move assignment operator
+        //
+        //   // May be efficient if allocators are compatible
+        //   absl::btree_multimap<int, std::string> map6;
+        //   map6 = std::move(map5);
+        //
+        // * Range constructor
+        //
+        //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+        //   absl::btree_multimap<int, std::string> map7(v.begin(), v.end());
+        btree_multimap()
+        {
+        }
+        using Base::Base;
+
+        // btree_multimap::begin()
+        //
+        // Returns an iterator to the beginning of the `btree_multimap`.
+        using Base::begin;
+
+        // btree_multimap::cbegin()
+        //
+        // Returns a const iterator to the beginning of the `btree_multimap`.
+        using Base::cbegin;
+
+        // btree_multimap::end()
+        //
+        // Returns an iterator to the end of the `btree_multimap`.
+        using Base::end;
+
+        // btree_multimap::cend()
+        //
+        // Returns a const iterator to the end of the `btree_multimap`.
+        using Base::cend;
+
+        // btree_multimap::empty()
+        //
+        // Returns whether or not the `btree_multimap` is empty.
+        using Base::empty;
+
+        // btree_multimap::max_size()
+        //
+        // Returns the largest theoretical possible number of elements within a
+        // `btree_multimap` under current memory constraints. This value can be
+        // thought of as the largest value of `std::distance(begin(), end())` for a
+        // `btree_multimap<Key, T>`.
+        using Base::max_size;
+
+        // btree_multimap::size()
+        //
+        // Returns the number of elements currently within the `btree_multimap`.
+        using Base::size;
+
+        // btree_multimap::clear()
+        //
+        // Removes all elements from the `btree_multimap`. Invalidates any references,
+        // pointers, or iterators referring to contained elements.
+        using Base::clear;
+
+        // btree_multimap::erase()
+        //
+        // Erases elements within the `btree_multimap`. If an erase occurs, any
+        // references, pointers, or iterators are invalidated.
+        // Overloads are listed below.
+        //
+        // iterator erase(iterator position):
+        // iterator erase(const_iterator position):
+        //
+        //   Erases the element at `position` of the `btree_multimap`, returning
+        //   the iterator pointing to the element after the one that was erased
+        //   (or end() if none exists).
+        //
+        // iterator erase(const_iterator first, const_iterator last):
+        //
+        //   Erases the elements in the open interval [`first`, `last`), returning
+        //   the iterator pointing to the element after the interval that was erased
+        //   (or end() if none exists).
+        //
+        // template <typename K> size_type erase(const K& key):
+        //
+        //   Erases the elements matching the key, if any exist, returning the
+        //   number of elements erased.
+        using Base::erase;
+
+        // btree_multimap::insert()
+        //
+        // Inserts an element of the specified value into the `btree_multimap`,
+        // returning an iterator pointing to the newly inserted element.
+        // Any references, pointers, or iterators are invalidated.  Overloads are
+        // listed below.
+        //
+        // iterator insert(const value_type& value):
+        //
+        //   Inserts a value into the `btree_multimap`, returning an iterator to the
+        //   inserted element.
+        //
+        // iterator insert(value_type&& value):
+        //
+        //   Inserts a moveable value into the `btree_multimap`, returning an iterator
+        //   to the inserted element.
+        //
+        // iterator insert(const_iterator hint, const value_type& value):
+        // iterator insert(const_iterator hint, value_type&& value):
+        //
+        //   Inserts a value, using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search. Returns an iterator to the
+        //   inserted element.
+        //
+        // void insert(InputIterator first, InputIterator last):
+        //
+        //   Inserts a range of values [`first`, `last`).
+        //
+        // void insert(std::initializer_list<init_type> ilist):
+        //
+        //   Inserts the elements within the initializer list `ilist`.
+        using Base::insert;
+
+        // btree_multimap::emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_multimap`. Any references, pointers, or iterators are
+        // invalidated.
+        using Base::emplace;
+
+        // btree_multimap::emplace_hint()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_multimap`, using the position of `hint` as a non-binding
+        // suggestion for where to begin the insertion search.
+        //
+        // Any references, pointers, or iterators are invalidated.
+        using Base::emplace_hint;
+
+        // btree_multimap::extract()
+        //
+        // Extracts the indicated element, erasing it in the process, and returns it
+        // as a C++17-compatible node handle. Overloads are listed below.
+        //
+        // node_type extract(const_iterator position):
+        //
+        //   Extracts the element at the indicated position and returns a node handle
+        //   owning that extracted data.
+        //
+        // template <typename K> node_type extract(const K& k):
+        //
+        //   Extracts the element with the key matching the passed key value and
+        //   returns a node handle owning that extracted data. If the `btree_multimap`
+        //   does not contain an element with a matching key, this function returns an
+        //   empty node handle.
+        //
+        // NOTE: when compiled in an earlier version of C++ than C++17,
+        // `node_type::key()` returns a const reference to the key instead of a
+        // mutable reference. We cannot safely return a mutable reference without
+        // std::launder (which is not available before C++17).
+        //
+        // NOTE: In this context, `node_type` refers to the C++17 concept of a
+        // move-only type that owns and provides access to the elements in associative
+        // containers (https://en.cppreference.com/w/cpp/container/node_handle).
+        // It does NOT refer to the data layout of the underlying btree.
+        using Base::extract;
+
+        // btree_multimap::merge()
+        //
+        // Extracts all elements from a given `source` btree_multimap into this
+        // `btree_multimap`.
+        using Base::merge;
+
+        // btree_multimap::swap(btree_multimap& other)
+        //
+        // Exchanges the contents of this `btree_multimap` with those of the `other`
+        // btree_multimap, avoiding invocation of any move, copy, or swap operations
+        // on individual elements.
+        //
+        // All iterators and references on the `btree_multimap` remain valid,
+        // excepting for the past-the-end iterator, which is invalidated.
+        using Base::swap;
+
+        // btree_multimap::contains()
+        //
+        // template <typename K> bool contains(const K& key) const:
+        //
+        // Determines whether an element comparing equal to the given `key` exists
+        // within the `btree_multimap`, returning `true` if so or `false` otherwise.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::contains;
+
+        // btree_multimap::count()
+        //
+        // template <typename K> size_type count(const K& key) const:
+        //
+        // Returns the number of elements comparing equal to the given `key` within
+        // the `btree_multimap`.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::count;
+
+        // btree_multimap::equal_range()
+        //
+        // Returns a half-open range [first, last), defined by a `std::pair` of two
+        // iterators, containing all elements with the passed key in the
+        // `btree_multimap`.
+        using Base::equal_range;
+
+        // btree_multimap::find()
+        //
+        // template <typename K> iterator find(const K& key):
+        // template <typename K> const_iterator find(const K& key) const:
+        //
+        // Finds an element with the passed `key` within the `btree_multimap`.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::find;
+
+        // btree_multimap::lower_bound()
+        //
+        // template <typename K> iterator lower_bound(const K& key):
+        // template <typename K> const_iterator lower_bound(const K& key) const:
+        //
+        // Finds the first element with a key that is not less than `key` within the
+        // `btree_multimap`.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::lower_bound;
+
+        // btree_multimap::upper_bound()
+        //
+        // template <typename K> iterator upper_bound(const K& key):
+        // template <typename K> const_iterator upper_bound(const K& key) const:
+        //
+        // Finds the first element with a key that is greater than `key` within the
+        // `btree_multimap`.
+        //
+        // Supports heterogeneous lookup, provided that the map has a compatible
+        // heterogeneous comparator.
+        using Base::upper_bound;
+
+        // btree_multimap::get_allocator()
+        //
+        // Returns the allocator function associated with this `btree_multimap`.
+        using Base::get_allocator;
+
+        // btree_multimap::key_comp();
+        //
+        // Returns the key comparator associated with this `btree_multimap`.
+        using Base::key_comp;
+
+        // btree_multimap::value_comp();
+        //
+        // Returns the value comparator associated with this `btree_multimap`.
+        using Base::value_comp;
+    };
+
+    // absl::swap(absl::btree_multimap<>, absl::btree_multimap<>)
+    //
+    // Swaps the contents of two `absl::btree_multimap` containers.
+    template<typename K, typename V, typename C, typename A>
+    void swap(btree_multimap<K, V, C, A>& x, btree_multimap<K, V, C, A>& y)
+    {
+        return x.swap(y);
+    }
+
+    // absl::erase_if(absl::btree_multimap<>, Pred)
+    //
+    // Erases all elements that satisfy the predicate pred from the container.
+    // Returns the number of erased elements.
+    template<typename K, typename V, typename C, typename A, typename Pred>
+    typename btree_multimap<K, V, C, A>::size_type erase_if(
+        btree_multimap<K, V, C, A>& map, Pred pred
+    )
+    {
+        return container_internal::btree_access::erase_if(map, std::move(pred));
+    }
+
+    namespace container_internal
+    {
+
+        // A parameters structure for holding the type parameters for a btree_map.
+        // Compare and Alloc should be nothrow copy-constructible.
+        template<typename Key, typename Data, typename Compare, typename Alloc, int TargetNodeSize, bool IsMulti>
+        struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
+                                          /*IsMap=*/true,
+                                          map_slot_policy<Key, Data>>
+        {
+            using super_type = typename map_params::common_params;
+            using mapped_type = Data;
+            // This type allows us to move keys when it is safe to do so. It is safe
+            // for maps in which value_type and mutable_value_type are layout compatible.
+            using slot_policy = typename super_type::slot_policy;
+            using slot_type = typename super_type::slot_type;
+            using value_type = typename super_type::value_type;
+            using init_type = typename super_type::init_type;
+
+            template<typename V>
+            static auto key(const V& value) -> decltype(value.first)
+            {
+                return value.first;
+            }
+            static const Key& key(const slot_type* s)
+            {
+                return slot_policy::key(s);
+            }
+            static const Key& key(slot_type* s)
+            {
+                return slot_policy::key(s);
+            }
+            // For use in node handle.
+            static auto mutable_key(slot_type* s)
+                -> decltype(slot_policy::mutable_key(s))
+            {
+                return slot_policy::mutable_key(s);
+            }
+            static mapped_type& value(value_type* value)
+            {
+                return value->second;
+            }
+        };
+
+    }  // namespace container_internal
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_BTREE_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/btree_set.h b/CAPI/cpp/grpc/include/absl/container/btree_set.h
index 695b09f..863000a 100644
--- a/CAPI/cpp/grpc/include/absl/container/btree_set.h
+++ b/CAPI/cpp/grpc/include/absl/container/btree_set.h
@@ -49,745 +49,768 @@
 #ifndef ABSL_CONTAINER_BTREE_SET_H_
 #define ABSL_CONTAINER_BTREE_SET_H_
 
-#include "absl/container/internal/btree.h"  // IWYU pragma: export
+#include "absl/container/internal/btree.h"            // IWYU pragma: export
 #include "absl/container/internal/btree_container.h"  // IWYU pragma: export
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace container_internal {
-
-template <typename Key>
-struct set_slot_policy;
-
-template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
-          bool IsMulti>
-struct set_params;
-
-}  // namespace container_internal
-
-// absl::btree_set<>
-//
-// An `absl::btree_set<K>` is an ordered associative container of unique key
-// values designed to be a more efficient replacement for `std::set` (in most
-// cases).
-//
-// Keys are sorted using an (optional) comparison function, which defaults to
-// `std::less<K>`.
-//
-// An `absl::btree_set<K>` uses a default allocator of `std::allocator<K>` to
-// allocate (and deallocate) nodes, and construct and destruct values within
-// those nodes. You may instead specify a custom allocator `A` (which in turn
-// requires specifying a custom comparator `C`) as in
-// `absl::btree_set<K, C, A>`.
-//
-template <typename Key, typename Compare = std::less<Key>,
-          typename Alloc = std::allocator<Key>>
-class btree_set
-    : public container_internal::btree_set_container<
-          container_internal::btree<container_internal::set_params<
-              Key, Compare, Alloc, /*TargetNodeSize=*/256,
-              /*IsMulti=*/false>>> {
-  using Base = typename btree_set::btree_set_container;
-
- public:
-  // Constructors and Assignment Operators
-  //
-  // A `btree_set` supports the same overload set as `std::set`
-  // for construction and assignment:
-  //
-  // * Default constructor
-  //
-  //   absl::btree_set<std::string> set1;
-  //
-  // * Initializer List constructor
-  //
-  //   absl::btree_set<std::string> set2 =
-  //       {{"huey"}, {"dewey"}, {"louie"},};
-  //
-  // * Copy constructor
-  //
-  //   absl::btree_set<std::string> set3(set2);
-  //
-  // * Copy assignment operator
-  //
-  //  absl::btree_set<std::string> set4;
-  //  set4 = set3;
-  //
-  // * Move constructor
-  //
-  //   // Move is guaranteed efficient
-  //   absl::btree_set<std::string> set5(std::move(set4));
-  //
-  // * Move assignment operator
-  //
-  //   // May be efficient if allocators are compatible
-  //   absl::btree_set<std::string> set6;
-  //   set6 = std::move(set5);
-  //
-  // * Range constructor
-  //
-  //   std::vector<std::string> v = {"a", "b"};
-  //   absl::btree_set<std::string> set7(v.begin(), v.end());
-  btree_set() {}
-  using Base::Base;
-
-  // btree_set::begin()
-  //
-  // Returns an iterator to the beginning of the `btree_set`.
-  using Base::begin;
-
-  // btree_set::cbegin()
-  //
-  // Returns a const iterator to the beginning of the `btree_set`.
-  using Base::cbegin;
-
-  // btree_set::end()
-  //
-  // Returns an iterator to the end of the `btree_set`.
-  using Base::end;
-
-  // btree_set::cend()
-  //
-  // Returns a const iterator to the end of the `btree_set`.
-  using Base::cend;
-
-  // btree_set::empty()
-  //
-  // Returns whether or not the `btree_set` is empty.
-  using Base::empty;
-
-  // btree_set::max_size()
-  //
-  // Returns the largest theoretical possible number of elements within a
-  // `btree_set` under current memory constraints. This value can be thought
-  // of as the largest value of `std::distance(begin(), end())` for a
-  // `btree_set<Key>`.
-  using Base::max_size;
-
-  // btree_set::size()
-  //
-  // Returns the number of elements currently within the `btree_set`.
-  using Base::size;
-
-  // btree_set::clear()
-  //
-  // Removes all elements from the `btree_set`. Invalidates any references,
-  // pointers, or iterators referring to contained elements.
-  using Base::clear;
-
-  // btree_set::erase()
-  //
-  // Erases elements within the `btree_set`. Overloads are listed below.
-  //
-  // iterator erase(iterator position):
-  // iterator erase(const_iterator position):
-  //
-  //   Erases the element at `position` of the `btree_set`, returning
-  //   the iterator pointing to the element after the one that was erased
-  //   (or end() if none exists).
-  //
-  // iterator erase(const_iterator first, const_iterator last):
-  //
-  //   Erases the elements in the open interval [`first`, `last`), returning
-  //   the iterator pointing to the element after the interval that was erased
-  //   (or end() if none exists).
-  //
-  // template <typename K> size_type erase(const K& key):
-  //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
-  using Base::erase;
-
-  // btree_set::insert()
-  //
-  // Inserts an element of the specified value into the `btree_set`,
-  // returning an iterator pointing to the newly inserted element, provided that
-  // an element with the given key does not already exist. If an insertion
-  // occurs, any references, pointers, or iterators are invalidated.
-  // Overloads are listed below.
-  //
-  // std::pair<iterator,bool> insert(const value_type& value):
-  //
-  //   Inserts a value into the `btree_set`. Returns a pair consisting of an
-  //   iterator to the inserted element (or to the element that prevented the
-  //   insertion) and a bool denoting whether the insertion took place.
-  //
-  // std::pair<iterator,bool> insert(value_type&& value):
-  //
-  //   Inserts a moveable value into the `btree_set`. Returns a pair
-  //   consisting of an iterator to the inserted element (or to the element that
-  //   prevented the insertion) and a bool denoting whether the insertion took
-  //   place.
-  //
-  // iterator insert(const_iterator hint, const value_type& value):
-  // iterator insert(const_iterator hint, value_type&& value):
-  //
-  //   Inserts a value, using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search. Returns an iterator to the
-  //   inserted element, or to the existing element that prevented the
-  //   insertion.
-  //
-  // void insert(InputIterator first, InputIterator last):
-  //
-  //   Inserts a range of values [`first`, `last`).
-  //
-  // void insert(std::initializer_list<init_type> ilist):
-  //
-  //   Inserts the elements within the initializer list `ilist`.
-  using Base::insert;
-
-  // btree_set::emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_set`, provided that no element with the given key
-  // already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately.
-  //
-  // If an insertion occurs, any references, pointers, or iterators are
-  // invalidated.
-  using Base::emplace;
-
-  // btree_set::emplace_hint()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_set`, using the position of `hint` as a non-binding
-  // suggestion for where to begin the insertion search, and only inserts
-  // provided that no element with the given key already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately.
-  //
-  // If an insertion occurs, any references, pointers, or iterators are
-  // invalidated.
-  using Base::emplace_hint;
-
-  // btree_set::extract()
-  //
-  // Extracts the indicated element, erasing it in the process, and returns it
-  // as a C++17-compatible node handle. Overloads are listed below.
-  //
-  // node_type extract(const_iterator position):
-  //
-  //   Extracts the element at the indicated position and returns a node handle
-  //   owning that extracted data.
-  //
-  // template <typename K> node_type extract(const K& k):
-  //
-  //   Extracts the element with the key matching the passed key value and
-  //   returns a node handle owning that extracted data. If the `btree_set`
-  //   does not contain an element with a matching key, this function returns an
-  //   empty node handle.
-  //
-  // NOTE: In this context, `node_type` refers to the C++17 concept of a
-  // move-only type that owns and provides access to the elements in associative
-  // containers (https://en.cppreference.com/w/cpp/container/node_handle).
-  // It does NOT refer to the data layout of the underlying btree.
-  using Base::extract;
-
-  // btree_set::merge()
-  //
-  // Extracts elements from a given `source` btree_set into this
-  // `btree_set`. If the destination `btree_set` already contains an
-  // element with an equivalent key, that element is not extracted.
-  using Base::merge;
-
-  // btree_set::swap(btree_set& other)
-  //
-  // Exchanges the contents of this `btree_set` with those of the `other`
-  // btree_set, avoiding invocation of any move, copy, or swap operations on
-  // individual elements.
-  //
-  // All iterators and references on the `btree_set` remain valid, excepting
-  // for the past-the-end iterator, which is invalidated.
-  using Base::swap;
-
-  // btree_set::contains()
-  //
-  // template <typename K> bool contains(const K& key) const:
-  //
-  // Determines whether an element comparing equal to the given `key` exists
-  // within the `btree_set`, returning `true` if so or `false` otherwise.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::contains;
-
-  // btree_set::count()
-  //
-  // template <typename K> size_type count(const K& key) const:
-  //
-  // Returns the number of elements comparing equal to the given `key` within
-  // the `btree_set`. Note that this function will return either `1` or `0`
-  // since duplicate elements are not allowed within a `btree_set`.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::count;
-
-  // btree_set::equal_range()
-  //
-  // Returns a closed range [first, last], defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the
-  // `btree_set`.
-  using Base::equal_range;
-
-  // btree_set::find()
-  //
-  // template <typename K> iterator find(const K& key):
-  // template <typename K> const_iterator find(const K& key) const:
-  //
-  // Finds an element with the passed `key` within the `btree_set`.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::find;
-
-  // btree_set::lower_bound()
-  //
-  // template <typename K> iterator lower_bound(const K& key):
-  // template <typename K> const_iterator lower_bound(const K& key) const:
-  //
-  // Finds the first element that is not less than `key` within the `btree_set`.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::lower_bound;
-
-  // btree_set::upper_bound()
-  //
-  // template <typename K> iterator upper_bound(const K& key):
-  // template <typename K> const_iterator upper_bound(const K& key) const:
-  //
-  // Finds the first element that is greater than `key` within the `btree_set`.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::upper_bound;
-
-  // btree_set::get_allocator()
-  //
-  // Returns the allocator function associated with this `btree_set`.
-  using Base::get_allocator;
-
-  // btree_set::key_comp();
-  //
-  // Returns the key comparator associated with this `btree_set`.
-  using Base::key_comp;
-
-  // btree_set::value_comp();
-  //
-  // Returns the value comparator associated with this `btree_set`. The keys to
-  // sort the elements are the values themselves, therefore `value_comp` and its
-  // sibling member function `key_comp` are equivalent.
-  using Base::value_comp;
-};
-
-// absl::swap(absl::btree_set<>, absl::btree_set<>)
-//
-// Swaps the contents of two `absl::btree_set` containers.
-template <typename K, typename C, typename A>
-void swap(btree_set<K, C, A> &x, btree_set<K, C, A> &y) {
-  return x.swap(y);
-}
-
-// absl::erase_if(absl::btree_set<>, Pred)
-//
-// Erases all elements that satisfy the predicate pred from the container.
-// Returns the number of erased elements.
-template <typename K, typename C, typename A, typename Pred>
-typename btree_set<K, C, A>::size_type erase_if(btree_set<K, C, A> &set,
-                                                Pred pred) {
-  return container_internal::btree_access::erase_if(set, std::move(pred));
-}
-
-// absl::btree_multiset<>
-//
-// An `absl::btree_multiset<K>` is an ordered associative container of
-// keys and associated values designed to be a more efficient replacement
-// for `std::multiset` (in most cases). Unlike `absl::btree_set`, a B-tree
-// multiset allows equivalent elements.
-//
-// Keys are sorted using an (optional) comparison function, which defaults to
-// `std::less<K>`.
-//
-// An `absl::btree_multiset<K>` uses a default allocator of `std::allocator<K>`
-// to allocate (and deallocate) nodes, and construct and destruct values within
-// those nodes. You may instead specify a custom allocator `A` (which in turn
-// requires specifying a custom comparator `C`) as in
-// `absl::btree_multiset<K, C, A>`.
-//
-template <typename Key, typename Compare = std::less<Key>,
-          typename Alloc = std::allocator<Key>>
-class btree_multiset
-    : public container_internal::btree_multiset_container<
-          container_internal::btree<container_internal::set_params<
-              Key, Compare, Alloc, /*TargetNodeSize=*/256,
-              /*IsMulti=*/true>>> {
-  using Base = typename btree_multiset::btree_multiset_container;
-
- public:
-  // Constructors and Assignment Operators
-  //
-  // A `btree_multiset` supports the same overload set as `std::set`
-  // for construction and assignment:
-  //
-  // * Default constructor
-  //
-  //   absl::btree_multiset<std::string> set1;
-  //
-  // * Initializer List constructor
-  //
-  //   absl::btree_multiset<std::string> set2 =
-  //       {{"huey"}, {"dewey"}, {"louie"},};
-  //
-  // * Copy constructor
-  //
-  //   absl::btree_multiset<std::string> set3(set2);
-  //
-  // * Copy assignment operator
-  //
-  //  absl::btree_multiset<std::string> set4;
-  //  set4 = set3;
-  //
-  // * Move constructor
-  //
-  //   // Move is guaranteed efficient
-  //   absl::btree_multiset<std::string> set5(std::move(set4));
-  //
-  // * Move assignment operator
-  //
-  //   // May be efficient if allocators are compatible
-  //   absl::btree_multiset<std::string> set6;
-  //   set6 = std::move(set5);
-  //
-  // * Range constructor
-  //
-  //   std::vector<std::string> v = {"a", "b"};
-  //   absl::btree_multiset<std::string> set7(v.begin(), v.end());
-  btree_multiset() {}
-  using Base::Base;
-
-  // btree_multiset::begin()
-  //
-  // Returns an iterator to the beginning of the `btree_multiset`.
-  using Base::begin;
-
-  // btree_multiset::cbegin()
-  //
-  // Returns a const iterator to the beginning of the `btree_multiset`.
-  using Base::cbegin;
-
-  // btree_multiset::end()
-  //
-  // Returns an iterator to the end of the `btree_multiset`.
-  using Base::end;
-
-  // btree_multiset::cend()
-  //
-  // Returns a const iterator to the end of the `btree_multiset`.
-  using Base::cend;
-
-  // btree_multiset::empty()
-  //
-  // Returns whether or not the `btree_multiset` is empty.
-  using Base::empty;
-
-  // btree_multiset::max_size()
-  //
-  // Returns the largest theoretical possible number of elements within a
-  // `btree_multiset` under current memory constraints. This value can be
-  // thought of as the largest value of `std::distance(begin(), end())` for a
-  // `btree_multiset<Key>`.
-  using Base::max_size;
-
-  // btree_multiset::size()
-  //
-  // Returns the number of elements currently within the `btree_multiset`.
-  using Base::size;
-
-  // btree_multiset::clear()
-  //
-  // Removes all elements from the `btree_multiset`. Invalidates any references,
-  // pointers, or iterators referring to contained elements.
-  using Base::clear;
-
-  // btree_multiset::erase()
-  //
-  // Erases elements within the `btree_multiset`. Overloads are listed below.
-  //
-  // iterator erase(iterator position):
-  // iterator erase(const_iterator position):
-  //
-  //   Erases the element at `position` of the `btree_multiset`, returning
-  //   the iterator pointing to the element after the one that was erased
-  //   (or end() if none exists).
-  //
-  // iterator erase(const_iterator first, const_iterator last):
-  //
-  //   Erases the elements in the open interval [`first`, `last`), returning
-  //   the iterator pointing to the element after the interval that was erased
-  //   (or end() if none exists).
-  //
-  // template <typename K> size_type erase(const K& key):
-  //
-  //   Erases the elements matching the key, if any exist, returning the
-  //   number of elements erased.
-  using Base::erase;
-
-  // btree_multiset::insert()
-  //
-  // Inserts an element of the specified value into the `btree_multiset`,
-  // returning an iterator pointing to the newly inserted element.
-  // Any references, pointers, or iterators are invalidated.  Overloads are
-  // listed below.
-  //
-  // iterator insert(const value_type& value):
-  //
-  //   Inserts a value into the `btree_multiset`, returning an iterator to the
-  //   inserted element.
-  //
-  // iterator insert(value_type&& value):
-  //
-  //   Inserts a moveable value into the `btree_multiset`, returning an iterator
-  //   to the inserted element.
-  //
-  // iterator insert(const_iterator hint, const value_type& value):
-  // iterator insert(const_iterator hint, value_type&& value):
-  //
-  //   Inserts a value, using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search. Returns an iterator to the
-  //   inserted element.
-  //
-  // void insert(InputIterator first, InputIterator last):
-  //
-  //   Inserts a range of values [`first`, `last`).
-  //
-  // void insert(std::initializer_list<init_type> ilist):
-  //
-  //   Inserts the elements within the initializer list `ilist`.
-  using Base::insert;
-
-  // btree_multiset::emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_multiset`. Any references, pointers, or iterators are
-  // invalidated.
-  using Base::emplace;
-
-  // btree_multiset::emplace_hint()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `btree_multiset`, using the position of `hint` as a non-binding
-  // suggestion for where to begin the insertion search.
-  //
-  // Any references, pointers, or iterators are invalidated.
-  using Base::emplace_hint;
-
-  // btree_multiset::extract()
-  //
-  // Extracts the indicated element, erasing it in the process, and returns it
-  // as a C++17-compatible node handle. Overloads are listed below.
-  //
-  // node_type extract(const_iterator position):
-  //
-  //   Extracts the element at the indicated position and returns a node handle
-  //   owning that extracted data.
-  //
-  // template <typename K> node_type extract(const K& k):
-  //
-  //   Extracts the element with the key matching the passed key value and
-  //   returns a node handle owning that extracted data. If the `btree_multiset`
-  //   does not contain an element with a matching key, this function returns an
-  //   empty node handle.
-  //
-  // NOTE: In this context, `node_type` refers to the C++17 concept of a
-  // move-only type that owns and provides access to the elements in associative
-  // containers (https://en.cppreference.com/w/cpp/container/node_handle).
-  // It does NOT refer to the data layout of the underlying btree.
-  using Base::extract;
-
-  // btree_multiset::merge()
-  //
-  // Extracts all elements from a given `source` btree_multiset into this
-  // `btree_multiset`.
-  using Base::merge;
-
-  // btree_multiset::swap(btree_multiset& other)
-  //
-  // Exchanges the contents of this `btree_multiset` with those of the `other`
-  // btree_multiset, avoiding invocation of any move, copy, or swap operations
-  // on individual elements.
-  //
-  // All iterators and references on the `btree_multiset` remain valid,
-  // excepting for the past-the-end iterator, which is invalidated.
-  using Base::swap;
-
-  // btree_multiset::contains()
-  //
-  // template <typename K> bool contains(const K& key) const:
-  //
-  // Determines whether an element comparing equal to the given `key` exists
-  // within the `btree_multiset`, returning `true` if so or `false` otherwise.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::contains;
-
-  // btree_multiset::count()
-  //
-  // template <typename K> size_type count(const K& key) const:
-  //
-  // Returns the number of elements comparing equal to the given `key` within
-  // the `btree_multiset`.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::count;
-
-  // btree_multiset::equal_range()
-  //
-  // Returns a closed range [first, last], defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the
-  // `btree_multiset`.
-  using Base::equal_range;
-
-  // btree_multiset::find()
-  //
-  // template <typename K> iterator find(const K& key):
-  // template <typename K> const_iterator find(const K& key) const:
-  //
-  // Finds an element with the passed `key` within the `btree_multiset`.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::find;
-
-  // btree_multiset::lower_bound()
-  //
-  // template <typename K> iterator lower_bound(const K& key):
-  // template <typename K> const_iterator lower_bound(const K& key) const:
-  //
-  // Finds the first element that is not less than `key` within the
-  // `btree_multiset`.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::lower_bound;
-
-  // btree_multiset::upper_bound()
-  //
-  // template <typename K> iterator upper_bound(const K& key):
-  // template <typename K> const_iterator upper_bound(const K& key) const:
-  //
-  // Finds the first element that is greater than `key` within the
-  // `btree_multiset`.
-  //
-  // Supports heterogeneous lookup, provided that the set has a compatible
-  // heterogeneous comparator.
-  using Base::upper_bound;
-
-  // btree_multiset::get_allocator()
-  //
-  // Returns the allocator function associated with this `btree_multiset`.
-  using Base::get_allocator;
-
-  // btree_multiset::key_comp();
-  //
-  // Returns the key comparator associated with this `btree_multiset`.
-  using Base::key_comp;
-
-  // btree_multiset::value_comp();
-  //
-  // Returns the value comparator associated with this `btree_multiset`. The
-  // keys to sort the elements are the values themselves, therefore `value_comp`
-  // and its sibling member function `key_comp` are equivalent.
-  using Base::value_comp;
-};
-
-// absl::swap(absl::btree_multiset<>, absl::btree_multiset<>)
-//
-// Swaps the contents of two `absl::btree_multiset` containers.
-template <typename K, typename C, typename A>
-void swap(btree_multiset<K, C, A> &x, btree_multiset<K, C, A> &y) {
-  return x.swap(y);
-}
-
-// absl::erase_if(absl::btree_multiset<>, Pred)
-//
-// Erases all elements that satisfy the predicate pred from the container.
-// Returns the number of erased elements.
-template <typename K, typename C, typename A, typename Pred>
-typename btree_multiset<K, C, A>::size_type erase_if(
-   btree_multiset<K, C, A> & set, Pred pred) {
-  return container_internal::btree_access::erase_if(set, std::move(pred));
-}
-
-namespace container_internal {
-
-// This type implements the necessary functions from the
-// absl::container_internal::slot_type interface for btree_(multi)set.
-template <typename Key>
-struct set_slot_policy {
-  using slot_type = Key;
-  using value_type = Key;
-  using mutable_value_type = Key;
-
-  static value_type &element(slot_type *slot) { return *slot; }
-  static const value_type &element(const slot_type *slot) { return *slot; }
-
-  template <typename Alloc, class... Args>
-  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
-    absl::allocator_traits<Alloc>::construct(*alloc, slot,
-                                             std::forward<Args>(args)...);
-  }
-
-  template <typename Alloc>
-  static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
-    absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
-  }
-
-  template <typename Alloc>
-  static void construct(Alloc *alloc, slot_type *slot, const slot_type *other) {
-    absl::allocator_traits<Alloc>::construct(*alloc, slot, *other);
-  }
-
-  template <typename Alloc>
-  static void destroy(Alloc *alloc, slot_type *slot) {
-    absl::allocator_traits<Alloc>::destroy(*alloc, slot);
-  }
-
-  template <typename Alloc>
-  static void transfer(Alloc *alloc, slot_type *new_slot, slot_type *old_slot) {
-    construct(alloc, new_slot, old_slot);
-    destroy(alloc, old_slot);
-  }
-};
-
-// A parameters structure for holding the type parameters for a btree_set.
-// Compare and Alloc should be nothrow copy-constructible.
-template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
-          bool IsMulti>
-struct set_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
-                                  /*IsMap=*/false, set_slot_policy<Key>> {
-  using value_type = Key;
-  using slot_type = typename set_params::common_params::slot_type;
-
-  template <typename V>
-  static const V &key(const V &value) {
-    return value;
-  }
-  static const Key &key(const slot_type *slot) { return *slot; }
-  static const Key &key(slot_type *slot) { return *slot; }
-};
-
-}  // namespace container_internal
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    namespace container_internal
+    {
+
+        template<typename Key>
+        struct set_slot_policy;
+
+        template<typename Key, typename Compare, typename Alloc, int TargetNodeSize, bool IsMulti>
+        struct set_params;
+
+    }  // namespace container_internal
+
+    // absl::btree_set<>
+    //
+    // An `absl::btree_set<K>` is an ordered associative container of unique key
+    // values designed to be a more efficient replacement for `std::set` (in most
+    // cases).
+    //
+    // Keys are sorted using an (optional) comparison function, which defaults to
+    // `std::less<K>`.
+    //
+    // An `absl::btree_set<K>` uses a default allocator of `std::allocator<K>` to
+    // allocate (and deallocate) nodes, and construct and destruct values within
+    // those nodes. You may instead specify a custom allocator `A` (which in turn
+    // requires specifying a custom comparator `C`) as in
+    // `absl::btree_set<K, C, A>`.
+    //
+    template<typename Key, typename Compare = std::less<Key>, typename Alloc = std::allocator<Key>>
+    class btree_set : public container_internal::btree_set_container<container_internal::btree<container_internal::set_params<Key, Compare, Alloc, /*TargetNodeSize=*/256,
+                                                                                                                              /*IsMulti=*/false>>>
+    {
+        using Base = typename btree_set::btree_set_container;
+
+    public:
+        // Constructors and Assignment Operators
+        //
+        // A `btree_set` supports the same overload set as `std::set`
+        // for construction and assignment:
+        //
+        // * Default constructor
+        //
+        //   absl::btree_set<std::string> set1;
+        //
+        // * Initializer List constructor
+        //
+        //   absl::btree_set<std::string> set2 =
+        //       {{"huey"}, {"dewey"}, {"louie"},};
+        //
+        // * Copy constructor
+        //
+        //   absl::btree_set<std::string> set3(set2);
+        //
+        // * Copy assignment operator
+        //
+        //  absl::btree_set<std::string> set4;
+        //  set4 = set3;
+        //
+        // * Move constructor
+        //
+        //   // Move is guaranteed efficient
+        //   absl::btree_set<std::string> set5(std::move(set4));
+        //
+        // * Move assignment operator
+        //
+        //   // May be efficient if allocators are compatible
+        //   absl::btree_set<std::string> set6;
+        //   set6 = std::move(set5);
+        //
+        // * Range constructor
+        //
+        //   std::vector<std::string> v = {"a", "b"};
+        //   absl::btree_set<std::string> set7(v.begin(), v.end());
+        btree_set()
+        {
+        }
+        using Base::Base;
+
+        // btree_set::begin()
+        //
+        // Returns an iterator to the beginning of the `btree_set`.
+        using Base::begin;
+
+        // btree_set::cbegin()
+        //
+        // Returns a const iterator to the beginning of the `btree_set`.
+        using Base::cbegin;
+
+        // btree_set::end()
+        //
+        // Returns an iterator to the end of the `btree_set`.
+        using Base::end;
+
+        // btree_set::cend()
+        //
+        // Returns a const iterator to the end of the `btree_set`.
+        using Base::cend;
+
+        // btree_set::empty()
+        //
+        // Returns whether or not the `btree_set` is empty.
+        using Base::empty;
+
+        // btree_set::max_size()
+        //
+        // Returns the largest theoretical possible number of elements within a
+        // `btree_set` under current memory constraints. This value can be thought
+        // of as the largest value of `std::distance(begin(), end())` for a
+        // `btree_set<Key>`.
+        using Base::max_size;
+
+        // btree_set::size()
+        //
+        // Returns the number of elements currently within the `btree_set`.
+        using Base::size;
+
+        // btree_set::clear()
+        //
+        // Removes all elements from the `btree_set`. Invalidates any references,
+        // pointers, or iterators referring to contained elements.
+        using Base::clear;
+
+        // btree_set::erase()
+        //
+        // Erases elements within the `btree_set`. Overloads are listed below.
+        //
+        // iterator erase(iterator position):
+        // iterator erase(const_iterator position):
+        //
+        //   Erases the element at `position` of the `btree_set`, returning
+        //   the iterator pointing to the element after the one that was erased
+        //   (or end() if none exists).
+        //
+        // iterator erase(const_iterator first, const_iterator last):
+        //
+        //   Erases the elements in the open interval [`first`, `last`), returning
+        //   the iterator pointing to the element after the interval that was erased
+        //   (or end() if none exists).
+        //
+        // template <typename K> size_type erase(const K& key):
+        //
+        //   Erases the element with the matching key, if it exists, returning the
+        //   number of elements erased (0 or 1).
+        using Base::erase;
+
+        // btree_set::insert()
+        //
+        // Inserts an element of the specified value into the `btree_set`,
+        // returning an iterator pointing to the newly inserted element, provided that
+        // an element with the given key does not already exist. If an insertion
+        // occurs, any references, pointers, or iterators are invalidated.
+        // Overloads are listed below.
+        //
+        // std::pair<iterator,bool> insert(const value_type& value):
+        //
+        //   Inserts a value into the `btree_set`. Returns a pair consisting of an
+        //   iterator to the inserted element (or to the element that prevented the
+        //   insertion) and a bool denoting whether the insertion took place.
+        //
+        // std::pair<iterator,bool> insert(value_type&& value):
+        //
+        //   Inserts a moveable value into the `btree_set`. Returns a pair
+        //   consisting of an iterator to the inserted element (or to the element that
+        //   prevented the insertion) and a bool denoting whether the insertion took
+        //   place.
+        //
+        // iterator insert(const_iterator hint, const value_type& value):
+        // iterator insert(const_iterator hint, value_type&& value):
+        //
+        //   Inserts a value, using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search. Returns an iterator to the
+        //   inserted element, or to the existing element that prevented the
+        //   insertion.
+        //
+        // void insert(InputIterator first, InputIterator last):
+        //
+        //   Inserts a range of values [`first`, `last`).
+        //
+        // void insert(std::initializer_list<init_type> ilist):
+        //
+        //   Inserts the elements within the initializer list `ilist`.
+        using Base::insert;
+
+        // btree_set::emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_set`, provided that no element with the given key
+        // already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately.
+        //
+        // If an insertion occurs, any references, pointers, or iterators are
+        // invalidated.
+        using Base::emplace;
+
+        // btree_set::emplace_hint()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_set`, using the position of `hint` as a non-binding
+        // suggestion for where to begin the insertion search, and only inserts
+        // provided that no element with the given key already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately.
+        //
+        // If an insertion occurs, any references, pointers, or iterators are
+        // invalidated.
+        using Base::emplace_hint;
+
+        // btree_set::extract()
+        //
+        // Extracts the indicated element, erasing it in the process, and returns it
+        // as a C++17-compatible node handle. Overloads are listed below.
+        //
+        // node_type extract(const_iterator position):
+        //
+        //   Extracts the element at the indicated position and returns a node handle
+        //   owning that extracted data.
+        //
+        // template <typename K> node_type extract(const K& k):
+        //
+        //   Extracts the element with the key matching the passed key value and
+        //   returns a node handle owning that extracted data. If the `btree_set`
+        //   does not contain an element with a matching key, this function returns an
+        //   empty node handle.
+        //
+        // NOTE: In this context, `node_type` refers to the C++17 concept of a
+        // move-only type that owns and provides access to the elements in associative
+        // containers (https://en.cppreference.com/w/cpp/container/node_handle).
+        // It does NOT refer to the data layout of the underlying btree.
+        using Base::extract;
+
+        // btree_set::merge()
+        //
+        // Extracts elements from a given `source` btree_set into this
+        // `btree_set`. If the destination `btree_set` already contains an
+        // element with an equivalent key, that element is not extracted.
+        using Base::merge;
+
+        // btree_set::swap(btree_set& other)
+        //
+        // Exchanges the contents of this `btree_set` with those of the `other`
+        // btree_set, avoiding invocation of any move, copy, or swap operations on
+        // individual elements.
+        //
+        // All iterators and references on the `btree_set` remain valid, excepting
+        // for the past-the-end iterator, which is invalidated.
+        using Base::swap;
+
+        // btree_set::contains()
+        //
+        // template <typename K> bool contains(const K& key) const:
+        //
+        // Determines whether an element comparing equal to the given `key` exists
+        // within the `btree_set`, returning `true` if so or `false` otherwise.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::contains;
+
+        // btree_set::count()
+        //
+        // template <typename K> size_type count(const K& key) const:
+        //
+        // Returns the number of elements comparing equal to the given `key` within
+        // the `btree_set`. Note that this function will return either `1` or `0`
+        // since duplicate elements are not allowed within a `btree_set`.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::count;
+
+        // btree_set::equal_range()
+        //
+        // Returns a closed range [first, last], defined by a `std::pair` of two
+        // iterators, containing all elements with the passed key in the
+        // `btree_set`.
+        using Base::equal_range;
+
+        // btree_set::find()
+        //
+        // template <typename K> iterator find(const K& key):
+        // template <typename K> const_iterator find(const K& key) const:
+        //
+        // Finds an element with the passed `key` within the `btree_set`.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::find;
+
+        // btree_set::lower_bound()
+        //
+        // template <typename K> iterator lower_bound(const K& key):
+        // template <typename K> const_iterator lower_bound(const K& key) const:
+        //
+        // Finds the first element that is not less than `key` within the `btree_set`.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::lower_bound;
+
+        // btree_set::upper_bound()
+        //
+        // template <typename K> iterator upper_bound(const K& key):
+        // template <typename K> const_iterator upper_bound(const K& key) const:
+        //
+        // Finds the first element that is greater than `key` within the `btree_set`.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::upper_bound;
+
+        // btree_set::get_allocator()
+        //
+        // Returns the allocator function associated with this `btree_set`.
+        using Base::get_allocator;
+
+        // btree_set::key_comp();
+        //
+        // Returns the key comparator associated with this `btree_set`.
+        using Base::key_comp;
+
+        // btree_set::value_comp();
+        //
+        // Returns the value comparator associated with this `btree_set`. The keys to
+        // sort the elements are the values themselves, therefore `value_comp` and its
+        // sibling member function `key_comp` are equivalent.
+        using Base::value_comp;
+    };
+
+    // absl::swap(absl::btree_set<>, absl::btree_set<>)
+    //
+    // Swaps the contents of two `absl::btree_set` containers.
+    template<typename K, typename C, typename A>
+    void swap(btree_set<K, C, A>& x, btree_set<K, C, A>& y)
+    {
+        return x.swap(y);
+    }
+
+    // absl::erase_if(absl::btree_set<>, Pred)
+    //
+    // Erases all elements that satisfy the predicate pred from the container.
+    // Returns the number of erased elements.
+    template<typename K, typename C, typename A, typename Pred>
+    typename btree_set<K, C, A>::size_type erase_if(btree_set<K, C, A>& set, Pred pred)
+    {
+        return container_internal::btree_access::erase_if(set, std::move(pred));
+    }
+
+    // absl::btree_multiset<>
+    //
+    // An `absl::btree_multiset<K>` is an ordered associative container of
+    // keys and associated values designed to be a more efficient replacement
+    // for `std::multiset` (in most cases). Unlike `absl::btree_set`, a B-tree
+    // multiset allows equivalent elements.
+    //
+    // Keys are sorted using an (optional) comparison function, which defaults to
+    // `std::less<K>`.
+    //
+    // An `absl::btree_multiset<K>` uses a default allocator of `std::allocator<K>`
+    // to allocate (and deallocate) nodes, and construct and destruct values within
+    // those nodes. You may instead specify a custom allocator `A` (which in turn
+    // requires specifying a custom comparator `C`) as in
+    // `absl::btree_multiset<K, C, A>`.
+    //
+    template<typename Key, typename Compare = std::less<Key>, typename Alloc = std::allocator<Key>>
+    class btree_multiset : public container_internal::btree_multiset_container<container_internal::btree<container_internal::set_params<Key, Compare, Alloc, /*TargetNodeSize=*/256,
+                                                                                                                                        /*IsMulti=*/true>>>
+    {
+        using Base = typename btree_multiset::btree_multiset_container;
+
+    public:
+        // Constructors and Assignment Operators
+        //
+        // A `btree_multiset` supports the same overload set as `std::set`
+        // for construction and assignment:
+        //
+        // * Default constructor
+        //
+        //   absl::btree_multiset<std::string> set1;
+        //
+        // * Initializer List constructor
+        //
+        //   absl::btree_multiset<std::string> set2 =
+        //       {{"huey"}, {"dewey"}, {"louie"},};
+        //
+        // * Copy constructor
+        //
+        //   absl::btree_multiset<std::string> set3(set2);
+        //
+        // * Copy assignment operator
+        //
+        //  absl::btree_multiset<std::string> set4;
+        //  set4 = set3;
+        //
+        // * Move constructor
+        //
+        //   // Move is guaranteed efficient
+        //   absl::btree_multiset<std::string> set5(std::move(set4));
+        //
+        // * Move assignment operator
+        //
+        //   // May be efficient if allocators are compatible
+        //   absl::btree_multiset<std::string> set6;
+        //   set6 = std::move(set5);
+        //
+        // * Range constructor
+        //
+        //   std::vector<std::string> v = {"a", "b"};
+        //   absl::btree_multiset<std::string> set7(v.begin(), v.end());
+        btree_multiset()
+        {
+        }
+        using Base::Base;
+
+        // btree_multiset::begin()
+        //
+        // Returns an iterator to the beginning of the `btree_multiset`.
+        using Base::begin;
+
+        // btree_multiset::cbegin()
+        //
+        // Returns a const iterator to the beginning of the `btree_multiset`.
+        using Base::cbegin;
+
+        // btree_multiset::end()
+        //
+        // Returns an iterator to the end of the `btree_multiset`.
+        using Base::end;
+
+        // btree_multiset::cend()
+        //
+        // Returns a const iterator to the end of the `btree_multiset`.
+        using Base::cend;
+
+        // btree_multiset::empty()
+        //
+        // Returns whether or not the `btree_multiset` is empty.
+        using Base::empty;
+
+        // btree_multiset::max_size()
+        //
+        // Returns the largest theoretical possible number of elements within a
+        // `btree_multiset` under current memory constraints. This value can be
+        // thought of as the largest value of `std::distance(begin(), end())` for a
+        // `btree_multiset<Key>`.
+        using Base::max_size;
+
+        // btree_multiset::size()
+        //
+        // Returns the number of elements currently within the `btree_multiset`.
+        using Base::size;
+
+        // btree_multiset::clear()
+        //
+        // Removes all elements from the `btree_multiset`. Invalidates any references,
+        // pointers, or iterators referring to contained elements.
+        using Base::clear;
+
+        // btree_multiset::erase()
+        //
+        // Erases elements within the `btree_multiset`. Overloads are listed below.
+        //
+        // iterator erase(iterator position):
+        // iterator erase(const_iterator position):
+        //
+        //   Erases the element at `position` of the `btree_multiset`, returning
+        //   the iterator pointing to the element after the one that was erased
+        //   (or end() if none exists).
+        //
+        // iterator erase(const_iterator first, const_iterator last):
+        //
+        //   Erases the elements in the open interval [`first`, `last`), returning
+        //   the iterator pointing to the element after the interval that was erased
+        //   (or end() if none exists).
+        //
+        // template <typename K> size_type erase(const K& key):
+        //
+        //   Erases the elements matching the key, if any exist, returning the
+        //   number of elements erased.
+        using Base::erase;
+
+        // btree_multiset::insert()
+        //
+        // Inserts an element of the specified value into the `btree_multiset`,
+        // returning an iterator pointing to the newly inserted element.
+        // Any references, pointers, or iterators are invalidated.  Overloads are
+        // listed below.
+        //
+        // iterator insert(const value_type& value):
+        //
+        //   Inserts a value into the `btree_multiset`, returning an iterator to the
+        //   inserted element.
+        //
+        // iterator insert(value_type&& value):
+        //
+        //   Inserts a moveable value into the `btree_multiset`, returning an iterator
+        //   to the inserted element.
+        //
+        // iterator insert(const_iterator hint, const value_type& value):
+        // iterator insert(const_iterator hint, value_type&& value):
+        //
+        //   Inserts a value, using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search. Returns an iterator to the
+        //   inserted element.
+        //
+        // void insert(InputIterator first, InputIterator last):
+        //
+        //   Inserts a range of values [`first`, `last`).
+        //
+        // void insert(std::initializer_list<init_type> ilist):
+        //
+        //   Inserts the elements within the initializer list `ilist`.
+        using Base::insert;
+
+        // btree_multiset::emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_multiset`. Any references, pointers, or iterators are
+        // invalidated.
+        using Base::emplace;
+
+        // btree_multiset::emplace_hint()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `btree_multiset`, using the position of `hint` as a non-binding
+        // suggestion for where to begin the insertion search.
+        //
+        // Any references, pointers, or iterators are invalidated.
+        using Base::emplace_hint;
+
+        // btree_multiset::extract()
+        //
+        // Extracts the indicated element, erasing it in the process, and returns it
+        // as a C++17-compatible node handle. Overloads are listed below.
+        //
+        // node_type extract(const_iterator position):
+        //
+        //   Extracts the element at the indicated position and returns a node handle
+        //   owning that extracted data.
+        //
+        // template <typename K> node_type extract(const K& k):
+        //
+        //   Extracts the element with the key matching the passed key value and
+        //   returns a node handle owning that extracted data. If the `btree_multiset`
+        //   does not contain an element with a matching key, this function returns an
+        //   empty node handle.
+        //
+        // NOTE: In this context, `node_type` refers to the C++17 concept of a
+        // move-only type that owns and provides access to the elements in associative
+        // containers (https://en.cppreference.com/w/cpp/container/node_handle).
+        // It does NOT refer to the data layout of the underlying btree.
+        using Base::extract;
+
+        // btree_multiset::merge()
+        //
+        // Extracts all elements from a given `source` btree_multiset into this
+        // `btree_multiset`.
+        using Base::merge;
+
+        // btree_multiset::swap(btree_multiset& other)
+        //
+        // Exchanges the contents of this `btree_multiset` with those of the `other`
+        // btree_multiset, avoiding invocation of any move, copy, or swap operations
+        // on individual elements.
+        //
+        // All iterators and references on the `btree_multiset` remain valid,
+        // excepting for the past-the-end iterator, which is invalidated.
+        using Base::swap;
+
+        // btree_multiset::contains()
+        //
+        // template <typename K> bool contains(const K& key) const:
+        //
+        // Determines whether an element comparing equal to the given `key` exists
+        // within the `btree_multiset`, returning `true` if so or `false` otherwise.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::contains;
+
+        // btree_multiset::count()
+        //
+        // template <typename K> size_type count(const K& key) const:
+        //
+        // Returns the number of elements comparing equal to the given `key` within
+        // the `btree_multiset`.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::count;
+
+        // btree_multiset::equal_range()
+        //
+        // Returns a closed range [first, last], defined by a `std::pair` of two
+        // iterators, containing all elements with the passed key in the
+        // `btree_multiset`.
+        using Base::equal_range;
+
+        // btree_multiset::find()
+        //
+        // template <typename K> iterator find(const K& key):
+        // template <typename K> const_iterator find(const K& key) const:
+        //
+        // Finds an element with the passed `key` within the `btree_multiset`.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::find;
+
+        // btree_multiset::lower_bound()
+        //
+        // template <typename K> iterator lower_bound(const K& key):
+        // template <typename K> const_iterator lower_bound(const K& key) const:
+        //
+        // Finds the first element that is not less than `key` within the
+        // `btree_multiset`.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::lower_bound;
+
+        // btree_multiset::upper_bound()
+        //
+        // template <typename K> iterator upper_bound(const K& key):
+        // template <typename K> const_iterator upper_bound(const K& key) const:
+        //
+        // Finds the first element that is greater than `key` within the
+        // `btree_multiset`.
+        //
+        // Supports heterogeneous lookup, provided that the set has a compatible
+        // heterogeneous comparator.
+        using Base::upper_bound;
+
+        // btree_multiset::get_allocator()
+        //
+        // Returns the allocator function associated with this `btree_multiset`.
+        using Base::get_allocator;
+
+        // btree_multiset::key_comp();
+        //
+        // Returns the key comparator associated with this `btree_multiset`.
+        using Base::key_comp;
+
+        // btree_multiset::value_comp();
+        //
+        // Returns the value comparator associated with this `btree_multiset`. The
+        // keys to sort the elements are the values themselves, therefore `value_comp`
+        // and its sibling member function `key_comp` are equivalent.
+        using Base::value_comp;
+    };
+
+    // absl::swap(absl::btree_multiset<>, absl::btree_multiset<>)
+    //
+    // Swaps the contents of two `absl::btree_multiset` containers.
+    template<typename K, typename C, typename A>
+    void swap(btree_multiset<K, C, A>& x, btree_multiset<K, C, A>& y)
+    {
+        return x.swap(y);
+    }
+
+    // absl::erase_if(absl::btree_multiset<>, Pred)
+    //
+    // Erases all elements that satisfy the predicate pred from the container.
+    // Returns the number of erased elements.
+    template<typename K, typename C, typename A, typename Pred>
+    typename btree_multiset<K, C, A>::size_type erase_if(
+        btree_multiset<K, C, A>& set, Pred pred
+    )
+    {
+        return container_internal::btree_access::erase_if(set, std::move(pred));
+    }
+
+    namespace container_internal
+    {
+
+        // This type implements the necessary functions from the
+        // absl::container_internal::slot_type interface for btree_(multi)set.
+        template<typename Key>
+        struct set_slot_policy
+        {
+            using slot_type = Key;
+            using value_type = Key;
+            using mutable_value_type = Key;
+
+            static value_type& element(slot_type* slot)
+            {
+                return *slot;
+            }
+            static const value_type& element(const slot_type* slot)
+            {
+                return *slot;
+            }
+
+            template<typename Alloc, class... Args>
+            static void construct(Alloc* alloc, slot_type* slot, Args&&... args)
+            {
+                absl::allocator_traits<Alloc>::construct(*alloc, slot, std::forward<Args>(args)...);
+            }
+
+            template<typename Alloc>
+            static void construct(Alloc* alloc, slot_type* slot, slot_type* other)
+            {
+                absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
+            }
+
+            template<typename Alloc>
+            static void construct(Alloc* alloc, slot_type* slot, const slot_type* other)
+            {
+                absl::allocator_traits<Alloc>::construct(*alloc, slot, *other);
+            }
+
+            template<typename Alloc>
+            static void destroy(Alloc* alloc, slot_type* slot)
+            {
+                absl::allocator_traits<Alloc>::destroy(*alloc, slot);
+            }
+
+            template<typename Alloc>
+            static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot)
+            {
+                construct(alloc, new_slot, old_slot);
+                destroy(alloc, old_slot);
+            }
+        };
+
+        // A parameters structure for holding the type parameters for a btree_set.
+        // Compare and Alloc should be nothrow copy-constructible.
+        template<typename Key, typename Compare, typename Alloc, int TargetNodeSize, bool IsMulti>
+        struct set_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
+                                          /*IsMap=*/false,
+                                          set_slot_policy<Key>>
+        {
+            using value_type = Key;
+            using slot_type = typename set_params::common_params::slot_type;
+
+            template<typename V>
+            static const V& key(const V& value)
+            {
+                return value;
+            }
+            static const Key& key(const slot_type* slot)
+            {
+                return *slot;
+            }
+            static const Key& key(slot_type* slot)
+            {
+                return *slot;
+            }
+        };
+
+    }  // namespace container_internal
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_BTREE_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/btree_test.h b/CAPI/cpp/grpc/include/absl/container/btree_test.h
index 6249080..7739ea8 100644
--- a/CAPI/cpp/grpc/include/absl/container/btree_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/btree_test.h
@@ -28,139 +28,188 @@
 #include "absl/strings/cord.h"
 #include "absl/time/time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// Like remove_const but propagates the removal through std::pair.
-template <typename T>
-struct remove_pair_const {
-  using type = typename std::remove_const<T>::type;
-};
-template <typename T, typename U>
-struct remove_pair_const<std::pair<T, U> > {
-  using type = std::pair<typename remove_pair_const<T>::type,
-                         typename remove_pair_const<U>::type>;
-};
-
-// Utility class to provide an accessor for a key given a value. The default
-// behavior is to treat the value as a pair and return the first element.
-template <typename K, typename V>
-struct KeyOfValue {
-  struct type {
-    const K& operator()(const V& p) const { return p.first; }
-  };
-};
-
-// Partial specialization of KeyOfValue class for when the key and value are
-// the same type such as in set<> and btree_set<>.
-template <typename K>
-struct KeyOfValue<K, K> {
-  struct type {
-    const K& operator()(const K& k) const { return k; }
-  };
-};
-
-inline char* GenerateDigits(char buf[16], unsigned val, unsigned maxval) {
-  assert(val <= maxval);
-  constexpr unsigned kBase = 64;  // avoid integer division.
-  unsigned p = 15;
-  buf[p--] = 0;
-  while (maxval > 0) {
-    buf[p--] = ' ' + (val % kBase);
-    val /= kBase;
-    maxval /= kBase;
-  }
-  return buf + p + 1;
-}
-
-template <typename K>
-struct Generator {
-  int maxval;
-  explicit Generator(int m) : maxval(m) {}
-  K operator()(int i) const {
-    assert(i <= maxval);
-    return K(i);
-  }
-};
-
-template <>
-struct Generator<absl::Time> {
-  int maxval;
-  explicit Generator(int m) : maxval(m) {}
-  absl::Time operator()(int i) const { return absl::FromUnixMillis(i); }
-};
-
-template <>
-struct Generator<std::string> {
-  int maxval;
-  explicit Generator(int m) : maxval(m) {}
-  std::string operator()(int i) const {
-    char buf[16];
-    return GenerateDigits(buf, i, maxval);
-  }
-};
-
-template <>
-struct Generator<Cord> {
-  int maxval;
-  explicit Generator(int m) : maxval(m) {}
-  Cord operator()(int i) const {
-    char buf[16];
-    return Cord(GenerateDigits(buf, i, maxval));
-  }
-};
-
-template <typename T, typename U>
-struct Generator<std::pair<T, U> > {
-  Generator<typename remove_pair_const<T>::type> tgen;
-  Generator<typename remove_pair_const<U>::type> ugen;
-
-  explicit Generator(int m) : tgen(m), ugen(m) {}
-  std::pair<T, U> operator()(int i) const {
-    return std::make_pair(tgen(i), ugen(i));
-  }
-};
-
-// Generate n values for our tests and benchmarks. Value range is [0, maxval].
-inline std::vector<int> GenerateNumbersWithSeed(int n, int maxval, int seed) {
-  // NOTE: Some tests rely on generated numbers not changing between test runs.
-  // We use std::minstd_rand0 because it is well-defined, but don't use
-  // std::uniform_int_distribution because platforms use different algorithms.
-  std::minstd_rand0 rng(seed);
-
-  std::vector<int> values;
-  absl::flat_hash_set<int> unique_values;
-  if (values.size() < n) {
-    for (int i = values.size(); i < n; i++) {
-      int value;
-      do {
-        value = static_cast<int>(rng()) % (maxval + 1);
-      } while (!unique_values.insert(value).second);
-
-      values.push_back(value);
-    }
-  }
-  return values;
-}
-
-// Generates n values in the range [0, maxval].
-template <typename V>
-std::vector<V> GenerateValuesWithSeed(int n, int maxval, int seed) {
-  const std::vector<int> nums = GenerateNumbersWithSeed(n, maxval, seed);
-  Generator<V> gen(maxval);
-  std::vector<V> vec;
-
-  vec.reserve(n);
-  for (int i = 0; i < n; i++) {
-    vec.push_back(gen(nums[i]));
-  }
-
-  return vec;
-}
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        // Like remove_const but propagates the removal through std::pair.
+        template<typename T>
+        struct remove_pair_const
+        {
+            using type = typename std::remove_const<T>::type;
+        };
+        template<typename T, typename U>
+        struct remove_pair_const<std::pair<T, U>>
+        {
+            using type = std::pair<typename remove_pair_const<T>::type, typename remove_pair_const<U>::type>;
+        };
+
+        // Utility class to provide an accessor for a key given a value. The default
+        // behavior is to treat the value as a pair and return the first element.
+        template<typename K, typename V>
+        struct KeyOfValue
+        {
+            struct type
+            {
+                const K& operator()(const V& p) const
+                {
+                    return p.first;
+                }
+            };
+        };
+
+        // Partial specialization of KeyOfValue class for when the key and value are
+        // the same type such as in set<> and btree_set<>.
+        template<typename K>
+        struct KeyOfValue<K, K>
+        {
+            struct type
+            {
+                const K& operator()(const K& k) const
+                {
+                    return k;
+                }
+            };
+        };
+
+        inline char* GenerateDigits(char buf[16], unsigned val, unsigned maxval)
+        {
+            assert(val <= maxval);
+            constexpr unsigned kBase = 64;  // avoid integer division.
+            unsigned p = 15;
+            buf[p--] = 0;
+            while (maxval > 0)
+            {
+                buf[p--] = ' ' + (val % kBase);
+                val /= kBase;
+                maxval /= kBase;
+            }
+            return buf + p + 1;
+        }
+
+        template<typename K>
+        struct Generator
+        {
+            int maxval;
+            explicit Generator(int m) :
+                maxval(m)
+            {
+            }
+            K operator()(int i) const
+            {
+                assert(i <= maxval);
+                return K(i);
+            }
+        };
+
+        template<>
+        struct Generator<absl::Time>
+        {
+            int maxval;
+            explicit Generator(int m) :
+                maxval(m)
+            {
+            }
+            absl::Time operator()(int i) const
+            {
+                return absl::FromUnixMillis(i);
+            }
+        };
+
+        template<>
+        struct Generator<std::string>
+        {
+            int maxval;
+            explicit Generator(int m) :
+                maxval(m)
+            {
+            }
+            std::string operator()(int i) const
+            {
+                char buf[16];
+                return GenerateDigits(buf, i, maxval);
+            }
+        };
+
+        template<>
+        struct Generator<Cord>
+        {
+            int maxval;
+            explicit Generator(int m) :
+                maxval(m)
+            {
+            }
+            Cord operator()(int i) const
+            {
+                char buf[16];
+                return Cord(GenerateDigits(buf, i, maxval));
+            }
+        };
+
+        template<typename T, typename U>
+        struct Generator<std::pair<T, U>>
+        {
+            Generator<typename remove_pair_const<T>::type> tgen;
+            Generator<typename remove_pair_const<U>::type> ugen;
+
+            explicit Generator(int m) :
+                tgen(m),
+                ugen(m)
+            {
+            }
+            std::pair<T, U> operator()(int i) const
+            {
+                return std::make_pair(tgen(i), ugen(i));
+            }
+        };
+
+        // Generate n values for our tests and benchmarks. Value range is [0, maxval].
+        inline std::vector<int> GenerateNumbersWithSeed(int n, int maxval, int seed)
+        {
+            // NOTE: Some tests rely on generated numbers not changing between test runs.
+            // We use std::minstd_rand0 because it is well-defined, but don't use
+            // std::uniform_int_distribution because platforms use different algorithms.
+            std::minstd_rand0 rng(seed);
+
+            std::vector<int> values;
+            absl::flat_hash_set<int> unique_values;
+            if (values.size() < n)
+            {
+                for (int i = values.size(); i < n; i++)
+                {
+                    int value;
+                    do
+                    {
+                        value = static_cast<int>(rng()) % (maxval + 1);
+                    } while (!unique_values.insert(value).second);
+
+                    values.push_back(value);
+                }
+            }
+            return values;
+        }
+
+        // Generates n values in the range [0, maxval].
+        template<typename V>
+        std::vector<V> GenerateValuesWithSeed(int n, int maxval, int seed)
+        {
+            const std::vector<int> nums = GenerateNumbersWithSeed(n, maxval, seed);
+            Generator<V> gen(maxval);
+            std::vector<V> vec;
+
+            vec.reserve(n);
+            for (int i = 0; i < n; i++)
+            {
+                vec.push_back(gen(nums[i]));
+            }
+
+            return vec;
+        }
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_BTREE_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/fixed_array.h b/CAPI/cpp/grpc/include/absl/container/fixed_array.h
index 2aefae3..4100c92 100644
--- a/CAPI/cpp/grpc/include/absl/container/fixed_array.h
+++ b/CAPI/cpp/grpc/include/absl/container/fixed_array.h
@@ -50,480 +50,604 @@
 #include "absl/container/internal/compressed_tuple.h"
 #include "absl/memory/memory.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1);
-
-// -----------------------------------------------------------------------------
-// FixedArray
-// -----------------------------------------------------------------------------
-//
-// A `FixedArray` provides a run-time fixed-size array, allocating a small array
-// inline for efficiency.
-//
-// Most users should not specify an `inline_elements` argument and let
-// `FixedArray` automatically determine the number of elements
-// to store inline based on `sizeof(T)`. If `inline_elements` is specified, the
-// `FixedArray` implementation will use inline storage for arrays with a
-// length <= `inline_elements`.
-//
-// Note that a `FixedArray` constructed with a `size_type` argument will
-// default-initialize its values by leaving trivially constructible types
-// uninitialized (e.g. int, int[4], double), and others default-constructed.
-// This matches the behavior of c-style arrays and `std::array`, but not
-// `std::vector`.
-template <typename T, size_t N = kFixedArrayUseDefault,
-          typename A = std::allocator<T>>
-class FixedArray {
-  static_assert(!std::is_array<T>::value || std::extent<T>::value > 0,
-                "Arrays with unknown bounds cannot be used with FixedArray.");
-
-  static constexpr size_t kInlineBytesDefault = 256;
-
-  using AllocatorTraits = std::allocator_traits<A>;
-  // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17,
-  // but this seems to be mostly pedantic.
-  template <typename Iterator>
-  using EnableIfForwardIterator = absl::enable_if_t<std::is_convertible<
-      typename std::iterator_traits<Iterator>::iterator_category,
-      std::forward_iterator_tag>::value>;
-  static constexpr bool NoexceptCopyable() {
-    return std::is_nothrow_copy_constructible<StorageElement>::value &&
-           absl::allocator_is_nothrow<allocator_type>::value;
-  }
-  static constexpr bool NoexceptMovable() {
-    return std::is_nothrow_move_constructible<StorageElement>::value &&
-           absl::allocator_is_nothrow<allocator_type>::value;
-  }
-  static constexpr bool DefaultConstructorIsNonTrivial() {
-    return !absl::is_trivially_default_constructible<StorageElement>::value;
-  }
-
- public:
-  using allocator_type = typename AllocatorTraits::allocator_type;
-  using value_type = typename AllocatorTraits::value_type;
-  using pointer = typename AllocatorTraits::pointer;
-  using const_pointer = typename AllocatorTraits::const_pointer;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-  using size_type = typename AllocatorTraits::size_type;
-  using difference_type = typename AllocatorTraits::difference_type;
-  using iterator = pointer;
-  using const_iterator = const_pointer;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-  static constexpr size_type inline_elements =
-      (N == kFixedArrayUseDefault ? kInlineBytesDefault / sizeof(value_type)
-                                  : static_cast<size_type>(N));
-
-  FixedArray(
-      const FixedArray& other,
-      const allocator_type& a = allocator_type()) noexcept(NoexceptCopyable())
-      : FixedArray(other.begin(), other.end(), a) {}
-
-  FixedArray(
-      FixedArray&& other,
-      const allocator_type& a = allocator_type()) noexcept(NoexceptMovable())
-      : FixedArray(std::make_move_iterator(other.begin()),
-                   std::make_move_iterator(other.end()), a) {}
-
-  // Creates an array object that can store `n` elements.
-  // Note that trivially constructible elements will be uninitialized.
-  explicit FixedArray(size_type n, const allocator_type& a = allocator_type())
-      : storage_(n, a) {
-    if (DefaultConstructorIsNonTrivial()) {
-      memory_internal::ConstructRange(storage_.alloc(), storage_.begin(),
-                                      storage_.end());
-    }
-  }
-
-  // Creates an array initialized with `n` copies of `val`.
-  FixedArray(size_type n, const value_type& val,
-             const allocator_type& a = allocator_type())
-      : storage_(n, a) {
-    memory_internal::ConstructRange(storage_.alloc(), storage_.begin(),
-                                    storage_.end(), val);
-  }
-
-  // Creates an array initialized with the size and contents of `init_list`.
-  FixedArray(std::initializer_list<value_type> init_list,
-             const allocator_type& a = allocator_type())
-      : FixedArray(init_list.begin(), init_list.end(), a) {}
-
-  // Creates an array initialized with the elements from the input
-  // range. The array's size will always be `std::distance(first, last)`.
-  // REQUIRES: Iterator must be a forward_iterator or better.
-  template <typename Iterator, EnableIfForwardIterator<Iterator>* = nullptr>
-  FixedArray(Iterator first, Iterator last,
-             const allocator_type& a = allocator_type())
-      : storage_(std::distance(first, last), a) {
-    memory_internal::CopyRange(storage_.alloc(), storage_.begin(), first, last);
-  }
-
-  ~FixedArray() noexcept {
-    for (auto* cur = storage_.begin(); cur != storage_.end(); ++cur) {
-      AllocatorTraits::destroy(storage_.alloc(), cur);
-    }
-  }
-
-  // Assignments are deleted because they break the invariant that the size of a
-  // `FixedArray` never changes.
-  void operator=(FixedArray&&) = delete;
-  void operator=(const FixedArray&) = delete;
-
-  // FixedArray::size()
-  //
-  // Returns the length of the fixed array.
-  size_type size() const { return storage_.size(); }
-
-  // FixedArray::max_size()
-  //
-  // Returns the largest possible value of `std::distance(begin(), end())` for a
-  // `FixedArray<T>`. This is equivalent to the most possible addressable bytes
-  // over the number of bytes taken by T.
-  constexpr size_type max_size() const {
-    return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
-  }
-
-  // FixedArray::empty()
-  //
-  // Returns whether or not the fixed array is empty.
-  bool empty() const { return size() == 0; }
-
-  // FixedArray::memsize()
-  //
-  // Returns the memory size of the fixed array in bytes.
-  size_t memsize() const { return size() * sizeof(value_type); }
-
-  // FixedArray::data()
-  //
-  // Returns a const T* pointer to elements of the `FixedArray`. This pointer
-  // can be used to access (but not modify) the contained elements.
-  const_pointer data() const { return AsValueType(storage_.begin()); }
-
-  // Overload of FixedArray::data() to return a T* pointer to elements of the
-  // fixed array. This pointer can be used to access and modify the contained
-  // elements.
-  pointer data() { return AsValueType(storage_.begin()); }
-
-  // FixedArray::operator[]
-  //
-  // Returns a reference the ith element of the fixed array.
-  // REQUIRES: 0 <= i < size()
-  reference operator[](size_type i) {
-    ABSL_HARDENING_ASSERT(i < size());
-    return data()[i];
-  }
-
-  // Overload of FixedArray::operator()[] to return a const reference to the
-  // ith element of the fixed array.
-  // REQUIRES: 0 <= i < size()
-  const_reference operator[](size_type i) const {
-    ABSL_HARDENING_ASSERT(i < size());
-    return data()[i];
-  }
-
-  // FixedArray::at
-  //
-  // Bounds-checked access.  Returns a reference to the ith element of the fixed
-  // array, or throws std::out_of_range
-  reference at(size_type i) {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
-    }
-    return data()[i];
-  }
-
-  // Overload of FixedArray::at() to return a const reference to the ith element
-  // of the fixed array.
-  const_reference at(size_type i) const {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
-    }
-    return data()[i];
-  }
-
-  // FixedArray::front()
-  //
-  // Returns a reference to the first element of the fixed array.
-  reference front() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[0];
-  }
-
-  // Overload of FixedArray::front() to return a reference to the first element
-  // of a fixed array of const values.
-  const_reference front() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[0];
-  }
-
-  // FixedArray::back()
-  //
-  // Returns a reference to the last element of the fixed array.
-  reference back() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[size() - 1];
-  }
-
-  // Overload of FixedArray::back() to return a reference to the last element
-  // of a fixed array of const values.
-  const_reference back() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[size() - 1];
-  }
-
-  // FixedArray::begin()
-  //
-  // Returns an iterator to the beginning of the fixed array.
-  iterator begin() { return data(); }
-
-  // Overload of FixedArray::begin() to return a const iterator to the
-  // beginning of the fixed array.
-  const_iterator begin() const { return data(); }
-
-  // FixedArray::cbegin()
-  //
-  // Returns a const iterator to the beginning of the fixed array.
-  const_iterator cbegin() const { return begin(); }
-
-  // FixedArray::end()
-  //
-  // Returns an iterator to the end of the fixed array.
-  iterator end() { return data() + size(); }
-
-  // Overload of FixedArray::end() to return a const iterator to the end of the
-  // fixed array.
-  const_iterator end() const { return data() + size(); }
-
-  // FixedArray::cend()
-  //
-  // Returns a const iterator to the end of the fixed array.
-  const_iterator cend() const { return end(); }
-
-  // FixedArray::rbegin()
-  //
-  // Returns a reverse iterator from the end of the fixed array.
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-
-  // Overload of FixedArray::rbegin() to return a const reverse iterator from
-  // the end of the fixed array.
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-
-  // FixedArray::crbegin()
-  //
-  // Returns a const reverse iterator from the end of the fixed array.
-  const_reverse_iterator crbegin() const { return rbegin(); }
-
-  // FixedArray::rend()
-  //
-  // Returns a reverse iterator from the beginning of the fixed array.
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-
-  // Overload of FixedArray::rend() for returning a const reverse iterator
-  // from the beginning of the fixed array.
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  // FixedArray::crend()
-  //
-  // Returns a reverse iterator from the beginning of the fixed array.
-  const_reverse_iterator crend() const { return rend(); }
-
-  // FixedArray::fill()
-  //
-  // Assigns the given `value` to all elements in the fixed array.
-  void fill(const value_type& val) { std::fill(begin(), end(), val); }
-
-  // Relational operators. Equality operators are elementwise using
-  // `operator==`, while order operators order FixedArrays lexicographically.
-  friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) {
-    return absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
-  }
-
-  friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) {
-    return !(lhs == rhs);
-  }
-
-  friend bool operator<(const FixedArray& lhs, const FixedArray& rhs) {
-    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(),
-                                        rhs.end());
-  }
-
-  friend bool operator>(const FixedArray& lhs, const FixedArray& rhs) {
-    return rhs < lhs;
-  }
-
-  friend bool operator<=(const FixedArray& lhs, const FixedArray& rhs) {
-    return !(rhs < lhs);
-  }
-
-  friend bool operator>=(const FixedArray& lhs, const FixedArray& rhs) {
-    return !(lhs < rhs);
-  }
-
-  template <typename H>
-  friend H AbslHashValue(H h, const FixedArray& v) {
-    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
-                      v.size());
-  }
-
- private:
-  // StorageElement
-  //
-  // For FixedArrays with a C-style-array value_type, StorageElement is a POD
-  // wrapper struct called StorageElementWrapper that holds the value_type
-  // instance inside. This is needed for construction and destruction of the
-  // entire array regardless of how many dimensions it has. For all other cases,
-  // StorageElement is just an alias of value_type.
-  //
-  // Maintainer's Note: The simpler solution would be to simply wrap value_type
-  // in a struct whether it's an array or not. That causes some paranoid
-  // diagnostics to misfire, believing that 'data()' returns a pointer to a
-  // single element, rather than the packed array that it really is.
-  // e.g.:
-  //
-  //     FixedArray<char> buf(1);
-  //     sprintf(buf.data(), "foo");
-  //
-  //     error: call to int __builtin___sprintf_chk(etc...)
-  //     will always overflow destination buffer [-Werror]
-  //
-  template <typename OuterT, typename InnerT = absl::remove_extent_t<OuterT>,
-            size_t InnerN = std::extent<OuterT>::value>
-  struct StorageElementWrapper {
-    InnerT array[InnerN];
-  };
-
-  using StorageElement =
-      absl::conditional_t<std::is_array<value_type>::value,
-                          StorageElementWrapper<value_type>, value_type>;
-
-  static pointer AsValueType(pointer ptr) { return ptr; }
-  static pointer AsValueType(StorageElementWrapper<value_type>* ptr) {
-    return std::addressof(ptr->array);
-  }
-
-  static_assert(sizeof(StorageElement) == sizeof(value_type), "");
-  static_assert(alignof(StorageElement) == alignof(value_type), "");
-
-  class NonEmptyInlinedStorage {
-   public:
-    StorageElement* data() { return reinterpret_cast<StorageElement*>(buff_); }
-    void AnnotateConstruct(size_type n);
-    void AnnotateDestruct(size_type n);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1);
+
+    // -----------------------------------------------------------------------------
+    // FixedArray
+    // -----------------------------------------------------------------------------
+    //
+    // A `FixedArray` provides a run-time fixed-size array, allocating a small array
+    // inline for efficiency.
+    //
+    // Most users should not specify an `inline_elements` argument and let
+    // `FixedArray` automatically determine the number of elements
+    // to store inline based on `sizeof(T)`. If `inline_elements` is specified, the
+    // `FixedArray` implementation will use inline storage for arrays with a
+    // length <= `inline_elements`.
+    //
+    // Note that a `FixedArray` constructed with a `size_type` argument will
+    // default-initialize its values by leaving trivially constructible types
+    // uninitialized (e.g. int, int[4], double), and others default-constructed.
+    // This matches the behavior of c-style arrays and `std::array`, but not
+    // `std::vector`.
+    template<typename T, size_t N = kFixedArrayUseDefault, typename A = std::allocator<T>>
+    class FixedArray
+    {
+        static_assert(!std::is_array<T>::value || std::extent<T>::value > 0, "Arrays with unknown bounds cannot be used with FixedArray.");
+
+        static constexpr size_t kInlineBytesDefault = 256;
+
+        using AllocatorTraits = std::allocator_traits<A>;
+        // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17,
+        // but this seems to be mostly pedantic.
+        template<typename Iterator>
+        using EnableIfForwardIterator = absl::enable_if_t<std::is_convertible<
+            typename std::iterator_traits<Iterator>::iterator_category,
+            std::forward_iterator_tag>::value>;
+        static constexpr bool NoexceptCopyable()
+        {
+            return std::is_nothrow_copy_constructible<StorageElement>::value &&
+                   absl::allocator_is_nothrow<allocator_type>::value;
+        }
+        static constexpr bool NoexceptMovable()
+        {
+            return std::is_nothrow_move_constructible<StorageElement>::value &&
+                   absl::allocator_is_nothrow<allocator_type>::value;
+        }
+        static constexpr bool DefaultConstructorIsNonTrivial()
+        {
+            return !absl::is_trivially_default_constructible<StorageElement>::value;
+        }
+
+    public:
+        using allocator_type = typename AllocatorTraits::allocator_type;
+        using value_type = typename AllocatorTraits::value_type;
+        using pointer = typename AllocatorTraits::pointer;
+        using const_pointer = typename AllocatorTraits::const_pointer;
+        using reference = value_type&;
+        using const_reference = const value_type&;
+        using size_type = typename AllocatorTraits::size_type;
+        using difference_type = typename AllocatorTraits::difference_type;
+        using iterator = pointer;
+        using const_iterator = const_pointer;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+        static constexpr size_type inline_elements =
+            (N == kFixedArrayUseDefault ? kInlineBytesDefault / sizeof(value_type) : static_cast<size_type>(N));
+
+        FixedArray(
+            const FixedArray& other,
+            const allocator_type& a = allocator_type()
+        ) noexcept(NoexceptCopyable()) :
+            FixedArray(other.begin(), other.end(), a)
+        {
+        }
+
+        FixedArray(
+            FixedArray&& other,
+            const allocator_type& a = allocator_type()
+        ) noexcept(NoexceptMovable()) :
+            FixedArray(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()), a)
+        {
+        }
+
+        // Creates an array object that can store `n` elements.
+        // Note that trivially constructible elements will be uninitialized.
+        explicit FixedArray(size_type n, const allocator_type& a = allocator_type()) :
+            storage_(n, a)
+        {
+            if (DefaultConstructorIsNonTrivial())
+            {
+                memory_internal::ConstructRange(storage_.alloc(), storage_.begin(), storage_.end());
+            }
+        }
+
+        // Creates an array initialized with `n` copies of `val`.
+        FixedArray(size_type n, const value_type& val, const allocator_type& a = allocator_type()) :
+            storage_(n, a)
+        {
+            memory_internal::ConstructRange(storage_.alloc(), storage_.begin(), storage_.end(), val);
+        }
+
+        // Creates an array initialized with the size and contents of `init_list`.
+        FixedArray(std::initializer_list<value_type> init_list, const allocator_type& a = allocator_type()) :
+            FixedArray(init_list.begin(), init_list.end(), a)
+        {
+        }
+
+        // Creates an array initialized with the elements from the input
+        // range. The array's size will always be `std::distance(first, last)`.
+        // REQUIRES: Iterator must be a forward_iterator or better.
+        template<typename Iterator, EnableIfForwardIterator<Iterator>* = nullptr>
+        FixedArray(Iterator first, Iterator last, const allocator_type& a = allocator_type()) :
+            storage_(std::distance(first, last), a)
+        {
+            memory_internal::CopyRange(storage_.alloc(), storage_.begin(), first, last);
+        }
+
+        ~FixedArray() noexcept
+        {
+            for (auto* cur = storage_.begin(); cur != storage_.end(); ++cur)
+            {
+                AllocatorTraits::destroy(storage_.alloc(), cur);
+            }
+        }
+
+        // Assignments are deleted because they break the invariant that the size of a
+        // `FixedArray` never changes.
+        void operator=(FixedArray&&) = delete;
+        void operator=(const FixedArray&) = delete;
+
+        // FixedArray::size()
+        //
+        // Returns the length of the fixed array.
+        size_type size() const
+        {
+            return storage_.size();
+        }
+
+        // FixedArray::max_size()
+        //
+        // Returns the largest possible value of `std::distance(begin(), end())` for a
+        // `FixedArray<T>`. This is equivalent to the most possible addressable bytes
+        // over the number of bytes taken by T.
+        constexpr size_type max_size() const
+        {
+            return (std::numeric_limits<difference_type>::max)() / sizeof(value_type);
+        }
+
+        // FixedArray::empty()
+        //
+        // Returns whether or not the fixed array is empty.
+        bool empty() const
+        {
+            return size() == 0;
+        }
+
+        // FixedArray::memsize()
+        //
+        // Returns the memory size of the fixed array in bytes.
+        size_t memsize() const
+        {
+            return size() * sizeof(value_type);
+        }
+
+        // FixedArray::data()
+        //
+        // Returns a const T* pointer to elements of the `FixedArray`. This pointer
+        // can be used to access (but not modify) the contained elements.
+        const_pointer data() const
+        {
+            return AsValueType(storage_.begin());
+        }
+
+        // Overload of FixedArray::data() to return a T* pointer to elements of the
+        // fixed array. This pointer can be used to access and modify the contained
+        // elements.
+        pointer data()
+        {
+            return AsValueType(storage_.begin());
+        }
+
+        // FixedArray::operator[]
+        //
+        // Returns a reference the ith element of the fixed array.
+        // REQUIRES: 0 <= i < size()
+        reference operator[](size_type i)
+        {
+            ABSL_HARDENING_ASSERT(i < size());
+            return data()[i];
+        }
+
+        // Overload of FixedArray::operator()[] to return a const reference to the
+        // ith element of the fixed array.
+        // REQUIRES: 0 <= i < size()
+        const_reference operator[](size_type i) const
+        {
+            ABSL_HARDENING_ASSERT(i < size());
+            return data()[i];
+        }
+
+        // FixedArray::at
+        //
+        // Bounds-checked access.  Returns a reference to the ith element of the fixed
+        // array, or throws std::out_of_range
+        reference at(size_type i)
+        {
+            if (ABSL_PREDICT_FALSE(i >= size()))
+            {
+                base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
+            }
+            return data()[i];
+        }
+
+        // Overload of FixedArray::at() to return a const reference to the ith element
+        // of the fixed array.
+        const_reference at(size_type i) const
+        {
+            if (ABSL_PREDICT_FALSE(i >= size()))
+            {
+                base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
+            }
+            return data()[i];
+        }
+
+        // FixedArray::front()
+        //
+        // Returns a reference to the first element of the fixed array.
+        reference front()
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+            return data()[0];
+        }
+
+        // Overload of FixedArray::front() to return a reference to the first element
+        // of a fixed array of const values.
+        const_reference front() const
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+            return data()[0];
+        }
+
+        // FixedArray::back()
+        //
+        // Returns a reference to the last element of the fixed array.
+        reference back()
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+            return data()[size() - 1];
+        }
+
+        // Overload of FixedArray::back() to return a reference to the last element
+        // of a fixed array of const values.
+        const_reference back() const
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+            return data()[size() - 1];
+        }
+
+        // FixedArray::begin()
+        //
+        // Returns an iterator to the beginning of the fixed array.
+        iterator begin()
+        {
+            return data();
+        }
+
+        // Overload of FixedArray::begin() to return a const iterator to the
+        // beginning of the fixed array.
+        const_iterator begin() const
+        {
+            return data();
+        }
+
+        // FixedArray::cbegin()
+        //
+        // Returns a const iterator to the beginning of the fixed array.
+        const_iterator cbegin() const
+        {
+            return begin();
+        }
+
+        // FixedArray::end()
+        //
+        // Returns an iterator to the end of the fixed array.
+        iterator end()
+        {
+            return data() + size();
+        }
+
+        // Overload of FixedArray::end() to return a const iterator to the end of the
+        // fixed array.
+        const_iterator end() const
+        {
+            return data() + size();
+        }
+
+        // FixedArray::cend()
+        //
+        // Returns a const iterator to the end of the fixed array.
+        const_iterator cend() const
+        {
+            return end();
+        }
+
+        // FixedArray::rbegin()
+        //
+        // Returns a reverse iterator from the end of the fixed array.
+        reverse_iterator rbegin()
+        {
+            return reverse_iterator(end());
+        }
+
+        // Overload of FixedArray::rbegin() to return a const reverse iterator from
+        // the end of the fixed array.
+        const_reverse_iterator rbegin() const
+        {
+            return const_reverse_iterator(end());
+        }
+
+        // FixedArray::crbegin()
+        //
+        // Returns a const reverse iterator from the end of the fixed array.
+        const_reverse_iterator crbegin() const
+        {
+            return rbegin();
+        }
+
+        // FixedArray::rend()
+        //
+        // Returns a reverse iterator from the beginning of the fixed array.
+        reverse_iterator rend()
+        {
+            return reverse_iterator(begin());
+        }
+
+        // Overload of FixedArray::rend() for returning a const reverse iterator
+        // from the beginning of the fixed array.
+        const_reverse_iterator rend() const
+        {
+            return const_reverse_iterator(begin());
+        }
+
+        // FixedArray::crend()
+        //
+        // Returns a reverse iterator from the beginning of the fixed array.
+        const_reverse_iterator crend() const
+        {
+            return rend();
+        }
+
+        // FixedArray::fill()
+        //
+        // Assigns the given `value` to all elements in the fixed array.
+        void fill(const value_type& val)
+        {
+            std::fill(begin(), end(), val);
+        }
+
+        // Relational operators. Equality operators are elementwise using
+        // `operator==`, while order operators order FixedArrays lexicographically.
+        friend bool operator==(const FixedArray& lhs, const FixedArray& rhs)
+        {
+            return absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+        }
+
+        friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        friend bool operator<(const FixedArray& lhs, const FixedArray& rhs)
+        {
+            return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+        }
+
+        friend bool operator>(const FixedArray& lhs, const FixedArray& rhs)
+        {
+            return rhs < lhs;
+        }
+
+        friend bool operator<=(const FixedArray& lhs, const FixedArray& rhs)
+        {
+            return !(rhs < lhs);
+        }
+
+        friend bool operator>=(const FixedArray& lhs, const FixedArray& rhs)
+        {
+            return !(lhs < rhs);
+        }
+
+        template<typename H>
+        friend H AbslHashValue(H h, const FixedArray& v)
+        {
+            return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()), v.size());
+        }
+
+    private:
+        // StorageElement
+        //
+        // For FixedArrays with a C-style-array value_type, StorageElement is a POD
+        // wrapper struct called StorageElementWrapper that holds the value_type
+        // instance inside. This is needed for construction and destruction of the
+        // entire array regardless of how many dimensions it has. For all other cases,
+        // StorageElement is just an alias of value_type.
+        //
+        // Maintainer's Note: The simpler solution would be to simply wrap value_type
+        // in a struct whether it's an array or not. That causes some paranoid
+        // diagnostics to misfire, believing that 'data()' returns a pointer to a
+        // single element, rather than the packed array that it really is.
+        // e.g.:
+        //
+        //     FixedArray<char> buf(1);
+        //     sprintf(buf.data(), "foo");
+        //
+        //     error: call to int __builtin___sprintf_chk(etc...)
+        //     will always overflow destination buffer [-Werror]
+        //
+        template<typename OuterT, typename InnerT = absl::remove_extent_t<OuterT>, size_t InnerN = std::extent<OuterT>::value>
+        struct StorageElementWrapper
+        {
+            InnerT array[InnerN];
+        };
+
+        using StorageElement =
+            absl::conditional_t<std::is_array<value_type>::value, StorageElementWrapper<value_type>, value_type>;
+
+        static pointer AsValueType(pointer ptr)
+        {
+            return ptr;
+        }
+        static pointer AsValueType(StorageElementWrapper<value_type>* ptr)
+        {
+            return std::addressof(ptr->array);
+        }
+
+        static_assert(sizeof(StorageElement) == sizeof(value_type), "");
+        static_assert(alignof(StorageElement) == alignof(value_type), "");
+
+        class NonEmptyInlinedStorage
+        {
+        public:
+            StorageElement* data()
+            {
+                return reinterpret_cast<StorageElement*>(buff_);
+            }
+            void AnnotateConstruct(size_type n);
+            void AnnotateDestruct(size_type n);
 
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-    void* RedzoneBegin() { return &redzone_begin_; }
-    void* RedzoneEnd() { return &redzone_end_ + 1; }
+            void* RedzoneBegin()
+            {
+                return &redzone_begin_;
+            }
+            void* RedzoneEnd()
+            {
+                return &redzone_end_ + 1;
+            }
 #endif  // ABSL_HAVE_ADDRESS_SANITIZER
 
-   private:
-    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
-    alignas(StorageElement) char buff_[sizeof(StorageElement[inline_elements])];
-    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_);
-  };
-
-  class EmptyInlinedStorage {
-   public:
-    StorageElement* data() { return nullptr; }
-    void AnnotateConstruct(size_type) {}
-    void AnnotateDestruct(size_type) {}
-  };
-
-  using InlinedStorage =
-      absl::conditional_t<inline_elements == 0, EmptyInlinedStorage,
-                          NonEmptyInlinedStorage>;
-
-  // Storage
-  //
-  // An instance of Storage manages the inline and out-of-line memory for
-  // instances of FixedArray. This guarantees that even when construction of
-  // individual elements fails in the FixedArray constructor body, the
-  // destructor for Storage will still be called and out-of-line memory will be
-  // properly deallocated.
-  //
-  class Storage : public InlinedStorage {
-   public:
-    Storage(size_type n, const allocator_type& a)
-        : size_alloc_(n, a), data_(InitializeData()) {}
-
-    ~Storage() noexcept {
-      if (UsingInlinedStorage(size())) {
-        InlinedStorage::AnnotateDestruct(size());
-      } else {
-        AllocatorTraits::deallocate(alloc(), AsValueType(begin()), size());
-      }
-    }
-
-    size_type size() const { return size_alloc_.template get<0>(); }
-    StorageElement* begin() const { return data_; }
-    StorageElement* end() const { return begin() + size(); }
-    allocator_type& alloc() { return size_alloc_.template get<1>(); }
-
-   private:
-    static bool UsingInlinedStorage(size_type n) {
-      return n <= inline_elements;
-    }
-
-    StorageElement* InitializeData() {
-      if (UsingInlinedStorage(size())) {
-        InlinedStorage::AnnotateConstruct(size());
-        return InlinedStorage::data();
-      } else {
-        return reinterpret_cast<StorageElement*>(
-            AllocatorTraits::allocate(alloc(), size()));
-      }
-    }
-
-    // `CompressedTuple` takes advantage of EBCO for stateless `allocator_type`s
-    container_internal::CompressedTuple<size_type, allocator_type> size_alloc_;
-    StorageElement* data_;
-  };
-
-  Storage storage_;
-};
+        private:
+            ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
+            alignas(StorageElement) char buff_[sizeof(StorageElement[inline_elements])];
+            ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_);
+        };
+
+        class EmptyInlinedStorage
+        {
+        public:
+            StorageElement* data()
+            {
+                return nullptr;
+            }
+            void AnnotateConstruct(size_type)
+            {
+            }
+            void AnnotateDestruct(size_type)
+            {
+            }
+        };
+
+        using InlinedStorage =
+            absl::conditional_t<inline_elements == 0, EmptyInlinedStorage, NonEmptyInlinedStorage>;
+
+        // Storage
+        //
+        // An instance of Storage manages the inline and out-of-line memory for
+        // instances of FixedArray. This guarantees that even when construction of
+        // individual elements fails in the FixedArray constructor body, the
+        // destructor for Storage will still be called and out-of-line memory will be
+        // properly deallocated.
+        //
+        class Storage : public InlinedStorage
+        {
+        public:
+            Storage(size_type n, const allocator_type& a) :
+                size_alloc_(n, a),
+                data_(InitializeData())
+            {
+            }
+
+            ~Storage() noexcept
+            {
+                if (UsingInlinedStorage(size()))
+                {
+                    InlinedStorage::AnnotateDestruct(size());
+                }
+                else
+                {
+                    AllocatorTraits::deallocate(alloc(), AsValueType(begin()), size());
+                }
+            }
+
+            size_type size() const
+            {
+                return size_alloc_.template get<0>();
+            }
+            StorageElement* begin() const
+            {
+                return data_;
+            }
+            StorageElement* end() const
+            {
+                return begin() + size();
+            }
+            allocator_type& alloc()
+            {
+                return size_alloc_.template get<1>();
+            }
+
+        private:
+            static bool UsingInlinedStorage(size_type n)
+            {
+                return n <= inline_elements;
+            }
+
+            StorageElement* InitializeData()
+            {
+                if (UsingInlinedStorage(size()))
+                {
+                    InlinedStorage::AnnotateConstruct(size());
+                    return InlinedStorage::data();
+                }
+                else
+                {
+                    return reinterpret_cast<StorageElement*>(
+                        AllocatorTraits::allocate(alloc(), size())
+                    );
+                }
+            }
+
+            // `CompressedTuple` takes advantage of EBCO for stateless `allocator_type`s
+            container_internal::CompressedTuple<size_type, allocator_type> size_alloc_;
+            StorageElement* data_;
+        };
+
+        Storage storage_;
+    };
 
 #ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-template <typename T, size_t N, typename A>
-constexpr size_t FixedArray<T, N, A>::kInlineBytesDefault;
+    template<typename T, size_t N, typename A>
+    constexpr size_t FixedArray<T, N, A>::kInlineBytesDefault;
 
-template <typename T, size_t N, typename A>
-constexpr typename FixedArray<T, N, A>::size_type
-    FixedArray<T, N, A>::inline_elements;
+    template<typename T, size_t N, typename A>
+    constexpr typename FixedArray<T, N, A>::size_type
+        FixedArray<T, N, A>::inline_elements;
 #endif
 
-template <typename T, size_t N, typename A>
-void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct(
-    typename FixedArray<T, N, A>::size_type n) {
+    template<typename T, size_t N, typename A>
+    void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct(
+        typename FixedArray<T, N, A>::size_type n
+    )
+    {
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-  if (!n) return;
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(),
-                                     data() + n);
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(),
-                                     RedzoneBegin());
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
-  static_cast<void>(n);  // Mark used when not in asan mode
-}
+        if (!n)
+            return;
+        ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(), data() + n);
+        ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(), RedzoneBegin());
+#endif                         // ABSL_HAVE_ADDRESS_SANITIZER
+        static_cast<void>(n);  // Mark used when not in asan mode
+    }
 
-template <typename T, size_t N, typename A>
-void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct(
-    typename FixedArray<T, N, A>::size_type n) {
+    template<typename T, size_t N, typename A>
+    void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct(
+        typename FixedArray<T, N, A>::size_type n
+    )
+    {
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-  if (!n) return;
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n,
-                                     RedzoneEnd());
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(),
-                                     data());
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
-  static_cast<void>(n);  // Mark used when not in asan mode
-}
-ABSL_NAMESPACE_END
+        if (!n)
+            return;
+        ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n, RedzoneEnd());
+        ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(), data());
+#endif                         // ABSL_HAVE_ADDRESS_SANITIZER
+        static_cast<void>(n);  // Mark used when not in asan mode
+    }
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_FIXED_ARRAY_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/flat_hash_map.h b/CAPI/cpp/grpc/include/absl/container/flat_hash_map.h
index e6bdbd9..d2fbdbf 100644
--- a/CAPI/cpp/grpc/include/absl/container/flat_hash_map.h
+++ b/CAPI/cpp/grpc/include/absl/container/flat_hash_map.h
@@ -39,575 +39,596 @@
 #include "absl/base/macros.h"
 #include "absl/container/internal/container_memory.h"
 #include "absl/container/internal/hash_function_defaults.h"  // IWYU pragma: export
-#include "absl/container/internal/raw_hash_map.h"  // IWYU pragma: export
+#include "absl/container/internal/raw_hash_map.h"            // IWYU pragma: export
 #include "absl/memory/memory.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-template <class K, class V>
-struct FlatHashMapPolicy;
-}  // namespace container_internal
-
-// -----------------------------------------------------------------------------
-// absl::flat_hash_map
-// -----------------------------------------------------------------------------
-//
-// An `absl::flat_hash_map<K, V>` is an unordered associative container which
-// has been optimized for both speed and memory footprint in most common use
-// cases. Its interface is similar to that of `std::unordered_map<K, V>` with
-// the following notable differences:
-//
-// * Requires keys that are CopyConstructible
-// * Requires values that are MoveConstructible
-// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
-//   `insert()`, provided that the map is provided a compatible heterogeneous
-//   hashing function and equality operator.
-// * Invalidates any references and pointers to elements within the table after
-//   `rehash()`.
-// * Contains a `capacity()` member function indicating the number of element
-//   slots (open, deleted, and empty) within the hash map.
-// * Returns `void` from the `erase(iterator)` overload.
-//
-// By default, `flat_hash_map` uses the `absl::Hash` hashing framework.
-// All fundamental and Abseil types that support the `absl::Hash` framework have
-// a compatible equality operator for comparing insertions into `flat_hash_map`.
-// If your type is not yet supported by the `absl::Hash` framework, see
-// absl/hash/hash.h for information on extending Abseil hashing to user-defined
-// types.
-//
-// Using `absl::flat_hash_map` at interface boundaries in dynamically loaded
-// libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
-// be randomized across dynamically loaded libraries.
-//
-// NOTE: A `flat_hash_map` stores its value types directly inside its
-// implementation array to avoid memory indirection. Because a `flat_hash_map`
-// is designed to move data when rehashed, map values will not retain pointer
-// stability. If you require pointer stability, or if your values are large,
-// consider using `absl::flat_hash_map<Key, std::unique_ptr<Value>>` instead.
-// If your types are not moveable or you require pointer stability for keys,
-// consider `absl::node_hash_map`.
-//
-// Example:
-//
-//   // Create a flat hash map of three strings (that map to strings)
-//   absl::flat_hash_map<std::string, std::string> ducks =
-//     {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}};
-//
-//  // Insert a new element into the flat hash map
-//  ducks.insert({"d", "donald"});
-//
-//  // Force a rehash of the flat hash map
-//  ducks.rehash(0);
-//
-//  // Find the element with the key "b"
-//  std::string search_key = "b";
-//  auto result = ducks.find(search_key);
-//  if (result != ducks.end()) {
-//    std::cout << "Result: " << result->second << std::endl;
-//  }
-template <class K, class V,
-          class Hash = absl::container_internal::hash_default_hash<K>,
-          class Eq = absl::container_internal::hash_default_eq<K>,
-          class Allocator = std::allocator<std::pair<const K, V>>>
-class flat_hash_map : public absl::container_internal::raw_hash_map<
-                          absl::container_internal::FlatHashMapPolicy<K, V>,
-                          Hash, Eq, Allocator> {
-  using Base = typename flat_hash_map::raw_hash_map;
-
- public:
-  // Constructors and Assignment Operators
-  //
-  // A flat_hash_map supports the same overload set as `std::unordered_map`
-  // for construction and assignment:
-  //
-  // *  Default constructor
-  //
-  //    // No allocation for the table's elements is made.
-  //    absl::flat_hash_map<int, std::string> map1;
-  //
-  // * Initializer List constructor
-  //
-  //   absl::flat_hash_map<int, std::string> map2 =
-  //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
-  //
-  // * Copy constructor
-  //
-  //   absl::flat_hash_map<int, std::string> map3(map2);
-  //
-  // * Copy assignment operator
-  //
-  //  // Hash functor and Comparator are copied as well
-  //  absl::flat_hash_map<int, std::string> map4;
-  //  map4 = map3;
-  //
-  // * Move constructor
-  //
-  //   // Move is guaranteed efficient
-  //   absl::flat_hash_map<int, std::string> map5(std::move(map4));
-  //
-  // * Move assignment operator
-  //
-  //   // May be efficient if allocators are compatible
-  //   absl::flat_hash_map<int, std::string> map6;
-  //   map6 = std::move(map5);
-  //
-  // * Range constructor
-  //
-  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
-  //   absl::flat_hash_map<int, std::string> map7(v.begin(), v.end());
-  flat_hash_map() {}
-  using Base::Base;
-
-  // flat_hash_map::begin()
-  //
-  // Returns an iterator to the beginning of the `flat_hash_map`.
-  using Base::begin;
-
-  // flat_hash_map::cbegin()
-  //
-  // Returns a const iterator to the beginning of the `flat_hash_map`.
-  using Base::cbegin;
-
-  // flat_hash_map::cend()
-  //
-  // Returns a const iterator to the end of the `flat_hash_map`.
-  using Base::cend;
-
-  // flat_hash_map::end()
-  //
-  // Returns an iterator to the end of the `flat_hash_map`.
-  using Base::end;
-
-  // flat_hash_map::capacity()
-  //
-  // Returns the number of element slots (assigned, deleted, and empty)
-  // available within the `flat_hash_map`.
-  //
-  // NOTE: this member function is particular to `absl::flat_hash_map` and is
-  // not provided in the `std::unordered_map` API.
-  using Base::capacity;
-
-  // flat_hash_map::empty()
-  //
-  // Returns whether or not the `flat_hash_map` is empty.
-  using Base::empty;
-
-  // flat_hash_map::max_size()
-  //
-  // Returns the largest theoretical possible number of elements within a
-  // `flat_hash_map` under current memory constraints. This value can be thought
-  // of the largest value of `std::distance(begin(), end())` for a
-  // `flat_hash_map<K, V>`.
-  using Base::max_size;
-
-  // flat_hash_map::size()
-  //
-  // Returns the number of elements currently within the `flat_hash_map`.
-  using Base::size;
-
-  // flat_hash_map::clear()
-  //
-  // Removes all elements from the `flat_hash_map`. Invalidates any references,
-  // pointers, or iterators referring to contained elements.
-  //
-  // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
-  // the underlying buffer call `erase(begin(), end())`.
-  using Base::clear;
-
-  // flat_hash_map::erase()
-  //
-  // Erases elements within the `flat_hash_map`. Erasing does not trigger a
-  // rehash. Overloads are listed below.
-  //
-  // void erase(const_iterator pos):
-  //
-  //   Erases the element at `position` of the `flat_hash_map`, returning
-  //   `void`.
-  //
-  //   NOTE: returning `void` in this case is different than that of STL
-  //   containers in general and `std::unordered_map` in particular (which
-  //   return an iterator to the element following the erased element). If that
-  //   iterator is needed, simply post increment the iterator:
-  //
-  //     map.erase(it++);
-  //
-  // iterator erase(const_iterator first, const_iterator last):
-  //
-  //   Erases the elements in the open interval [`first`, `last`), returning an
-  //   iterator pointing to `last`.
-  //
-  // size_type erase(const key_type& key):
-  //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
-  using Base::erase;
-
-  // flat_hash_map::insert()
-  //
-  // Inserts an element of the specified value into the `flat_hash_map`,
-  // returning an iterator pointing to the newly inserted element, provided that
-  // an element with the given key does not already exist. If rehashing occurs
-  // due to the insertion, all iterators are invalidated. Overloads are listed
-  // below.
-  //
-  // std::pair<iterator,bool> insert(const init_type& value):
-  //
-  //   Inserts a value into the `flat_hash_map`. Returns a pair consisting of an
-  //   iterator to the inserted element (or to the element that prevented the
-  //   insertion) and a bool denoting whether the insertion took place.
-  //
-  // std::pair<iterator,bool> insert(T&& value):
-  // std::pair<iterator,bool> insert(init_type&& value):
-  //
-  //   Inserts a moveable value into the `flat_hash_map`. Returns a pair
-  //   consisting of an iterator to the inserted element (or to the element that
-  //   prevented the insertion) and a bool denoting whether the insertion took
-  //   place.
-  //
-  // iterator insert(const_iterator hint, const init_type& value):
-  // iterator insert(const_iterator hint, T&& value):
-  // iterator insert(const_iterator hint, init_type&& value);
-  //
-  //   Inserts a value, using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search. Returns an iterator to the
-  //   inserted element, or to the existing element that prevented the
-  //   insertion.
-  //
-  // void insert(InputIterator first, InputIterator last):
-  //
-  //   Inserts a range of values [`first`, `last`).
-  //
-  //   NOTE: Although the STL does not specify which element may be inserted if
-  //   multiple keys compare equivalently, for `flat_hash_map` we guarantee the
-  //   first match is inserted.
-  //
-  // void insert(std::initializer_list<init_type> ilist):
-  //
-  //   Inserts the elements within the initializer list `ilist`.
-  //
-  //   NOTE: Although the STL does not specify which element may be inserted if
-  //   multiple keys compare equivalently within the initializer list, for
-  //   `flat_hash_map` we guarantee the first match is inserted.
-  using Base::insert;
-
-  // flat_hash_map::insert_or_assign()
-  //
-  // Inserts an element of the specified value into the `flat_hash_map` provided
-  // that a value with the given key does not already exist, or replaces it with
-  // the element value if a key for that value already exists, returning an
-  // iterator pointing to the newly inserted element.  If rehashing occurs due
-  // to the insertion, all existing iterators are invalidated. Overloads are
-  // listed below.
-  //
-  // pair<iterator, bool> insert_or_assign(const init_type& k, T&& obj):
-  // pair<iterator, bool> insert_or_assign(init_type&& k, T&& obj):
-  //
-  //   Inserts/Assigns (or moves) the element of the specified key into the
-  //   `flat_hash_map`.
-  //
-  // iterator insert_or_assign(const_iterator hint,
-  //                           const init_type& k, T&& obj):
-  // iterator insert_or_assign(const_iterator hint, init_type&& k, T&& obj):
-  //
-  //   Inserts/Assigns (or moves) the element of the specified key into the
-  //   `flat_hash_map` using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search.
-  using Base::insert_or_assign;
-
-  // flat_hash_map::emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `flat_hash_map`, provided that no element with the given key
-  // already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately. Prefer `try_emplace()` unless your key is not
-  // copyable or moveable.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  using Base::emplace;
-
-  // flat_hash_map::emplace_hint()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `flat_hash_map`, using the position of `hint` as a non-binding
-  // suggestion for where to begin the insertion search, and only inserts
-  // provided that no element with the given key already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately. Prefer `try_emplace()` unless your key is not
-  // copyable or moveable.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  using Base::emplace_hint;
-
-  // flat_hash_map::try_emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `flat_hash_map`, provided that no element with the given key
-  // already exists. Unlike `emplace()`, if an element with the given key
-  // already exists, we guarantee that no element is constructed.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  // Overloads are listed below.
-  //
-  //   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
-  //   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
-  //
-  // Inserts (via copy or move) the element of the specified key into the
-  // `flat_hash_map`.
-  //
-  //   iterator try_emplace(const_iterator hint,
-  //                        const key_type& k, Args&&... args):
-  //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
-  //
-  // Inserts (via copy or move) the element of the specified key into the
-  // `flat_hash_map` using the position of `hint` as a non-binding suggestion
-  // for where to begin the insertion search.
-  //
-  // All `try_emplace()` overloads make the same guarantees regarding rvalue
-  // arguments as `std::unordered_map::try_emplace()`, namely that these
-  // functions will not move from rvalue arguments if insertions do not happen.
-  using Base::try_emplace;
-
-  // flat_hash_map::extract()
-  //
-  // Extracts the indicated element, erasing it in the process, and returns it
-  // as a C++17-compatible node handle. Overloads are listed below.
-  //
-  // node_type extract(const_iterator position):
-  //
-  //   Extracts the key,value pair of the element at the indicated position and
-  //   returns a node handle owning that extracted data.
-  //
-  // node_type extract(const key_type& x):
-  //
-  //   Extracts the key,value pair of the element with a key matching the passed
-  //   key value and returns a node handle owning that extracted data. If the
-  //   `flat_hash_map` does not contain an element with a matching key, this
-  //   function returns an empty node handle.
-  //
-  // NOTE: when compiled in an earlier version of C++ than C++17,
-  // `node_type::key()` returns a const reference to the key instead of a
-  // mutable reference. We cannot safely return a mutable reference without
-  // std::launder (which is not available before C++17).
-  using Base::extract;
-
-  // flat_hash_map::merge()
-  //
-  // Extracts elements from a given `source` flat hash map into this
-  // `flat_hash_map`. If the destination `flat_hash_map` already contains an
-  // element with an equivalent key, that element is not extracted.
-  using Base::merge;
-
-  // flat_hash_map::swap(flat_hash_map& other)
-  //
-  // Exchanges the contents of this `flat_hash_map` with those of the `other`
-  // flat hash map, avoiding invocation of any move, copy, or swap operations on
-  // individual elements.
-  //
-  // All iterators and references on the `flat_hash_map` remain valid, excepting
-  // for the past-the-end iterator, which is invalidated.
-  //
-  // `swap()` requires that the flat hash map's hashing and key equivalence
-  // functions be Swappable, and are exchanged using unqualified calls to
-  // non-member `swap()`. If the map's allocator has
-  // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
-  // set to `true`, the allocators are also exchanged using an unqualified call
-  // to non-member `swap()`; otherwise, the allocators are not swapped.
-  using Base::swap;
-
-  // flat_hash_map::rehash(count)
-  //
-  // Rehashes the `flat_hash_map`, setting the number of slots to be at least
-  // the passed value. If the new number of slots increases the load factor more
-  // than the current maximum load factor
-  // (`count` < `size()` / `max_load_factor()`), then the new number of slots
-  // will be at least `size()` / `max_load_factor()`.
-  //
-  // To force a rehash, pass rehash(0).
-  //
-  // NOTE: unlike behavior in `std::unordered_map`, references are also
-  // invalidated upon a `rehash()`.
-  using Base::rehash;
-
-  // flat_hash_map::reserve(count)
-  //
-  // Sets the number of slots in the `flat_hash_map` to the number needed to
-  // accommodate at least `count` total elements without exceeding the current
-  // maximum load factor, and may rehash the container if needed.
-  using Base::reserve;
-
-  // flat_hash_map::at()
-  //
-  // Returns a reference to the mapped value of the element with key equivalent
-  // to the passed key.
-  using Base::at;
-
-  // flat_hash_map::contains()
-  //
-  // Determines whether an element with a key comparing equal to the given `key`
-  // exists within the `flat_hash_map`, returning `true` if so or `false`
-  // otherwise.
-  using Base::contains;
-
-  // flat_hash_map::count(const Key& key) const
-  //
-  // Returns the number of elements with a key comparing equal to the given
-  // `key` within the `flat_hash_map`. note that this function will return
-  // either `1` or `0` since duplicate keys are not allowed within a
-  // `flat_hash_map`.
-  using Base::count;
-
-  // flat_hash_map::equal_range()
-  //
-  // Returns a closed range [first, last], defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the
-  // `flat_hash_map`.
-  using Base::equal_range;
-
-  // flat_hash_map::find()
-  //
-  // Finds an element with the passed `key` within the `flat_hash_map`.
-  using Base::find;
-
-  // flat_hash_map::operator[]()
-  //
-  // Returns a reference to the value mapped to the passed key within the
-  // `flat_hash_map`, performing an `insert()` if the key does not already
-  // exist.
-  //
-  // If an insertion occurs and results in a rehashing of the container, all
-  // iterators are invalidated. Otherwise iterators are not affected and
-  // references are not invalidated. Overloads are listed below.
-  //
-  // T& operator[](const Key& key):
-  //
-  //   Inserts an init_type object constructed in-place if the element with the
-  //   given key does not exist.
-  //
-  // T& operator[](Key&& key):
-  //
-  //   Inserts an init_type object constructed in-place provided that an element
-  //   with the given key does not exist.
-  using Base::operator[];
-
-  // flat_hash_map::bucket_count()
-  //
-  // Returns the number of "buckets" within the `flat_hash_map`. Note that
-  // because a flat hash map contains all elements within its internal storage,
-  // this value simply equals the current capacity of the `flat_hash_map`.
-  using Base::bucket_count;
-
-  // flat_hash_map::load_factor()
-  //
-  // Returns the current load factor of the `flat_hash_map` (the average number
-  // of slots occupied with a value within the hash map).
-  using Base::load_factor;
-
-  // flat_hash_map::max_load_factor()
-  //
-  // Manages the maximum load factor of the `flat_hash_map`. Overloads are
-  // listed below.
-  //
-  // float flat_hash_map::max_load_factor()
-  //
-  //   Returns the current maximum load factor of the `flat_hash_map`.
-  //
-  // void flat_hash_map::max_load_factor(float ml)
-  //
-  //   Sets the maximum load factor of the `flat_hash_map` to the passed value.
-  //
-  //   NOTE: This overload is provided only for API compatibility with the STL;
-  //   `flat_hash_map` will ignore any set load factor and manage its rehashing
-  //   internally as an implementation detail.
-  using Base::max_load_factor;
-
-  // flat_hash_map::get_allocator()
-  //
-  // Returns the allocator function associated with this `flat_hash_map`.
-  using Base::get_allocator;
-
-  // flat_hash_map::hash_function()
-  //
-  // Returns the hashing function used to hash the keys within this
-  // `flat_hash_map`.
-  using Base::hash_function;
-
-  // flat_hash_map::key_eq()
-  //
-  // Returns the function used for comparing keys equality.
-  using Base::key_eq;
-};
-
-// erase_if(flat_hash_map<>, Pred)
-//
-// Erases all elements that satisfy the predicate `pred` from the container `c`.
-// Returns the number of erased elements.
-template <typename K, typename V, typename H, typename E, typename A,
-          typename Predicate>
-typename flat_hash_map<K, V, H, E, A>::size_type erase_if(
-    flat_hash_map<K, V, H, E, A>& c, Predicate pred) {
-  return container_internal::EraseIf(pred, &c);
-}
-
-namespace container_internal {
-
-template <class K, class V>
-struct FlatHashMapPolicy {
-  using slot_policy = container_internal::map_slot_policy<K, V>;
-  using slot_type = typename slot_policy::slot_type;
-  using key_type = K;
-  using mapped_type = V;
-  using init_type = std::pair</*non const*/ key_type, mapped_type>;
-
-  template <class Allocator, class... Args>
-  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
-    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
-  }
-
-  template <class Allocator>
-  static void destroy(Allocator* alloc, slot_type* slot) {
-    slot_policy::destroy(alloc, slot);
-  }
-
-  template <class Allocator>
-  static void transfer(Allocator* alloc, slot_type* new_slot,
-                       slot_type* old_slot) {
-    slot_policy::transfer(alloc, new_slot, old_slot);
-  }
-
-  template <class F, class... Args>
-  static decltype(absl::container_internal::DecomposePair(
-      std::declval<F>(), std::declval<Args>()...))
-  apply(F&& f, Args&&... args) {
-    return absl::container_internal::DecomposePair(std::forward<F>(f),
-                                                   std::forward<Args>(args)...);
-  }
-
-  static size_t space_used(const slot_type*) { return 0; }
-
-  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
-
-  static V& value(std::pair<const K, V>* kv) { return kv->second; }
-  static const V& value(const std::pair<const K, V>* kv) { return kv->second; }
-};
-
-}  // namespace container_internal
-
-namespace container_algorithm_internal {
-
-// Specialization of trait in absl/algorithm/container.h
-template <class Key, class T, class Hash, class KeyEqual, class Allocator>
-struct IsUnorderedContainer<
-    absl::flat_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {};
-
-}  // namespace container_algorithm_internal
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+        template<class K, class V>
+        struct FlatHashMapPolicy;
+    }  // namespace container_internal
+
+    // -----------------------------------------------------------------------------
+    // absl::flat_hash_map
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::flat_hash_map<K, V>` is an unordered associative container which
+    // has been optimized for both speed and memory footprint in most common use
+    // cases. Its interface is similar to that of `std::unordered_map<K, V>` with
+    // the following notable differences:
+    //
+    // * Requires keys that are CopyConstructible
+    // * Requires values that are MoveConstructible
+    // * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+    //   `insert()`, provided that the map is provided a compatible heterogeneous
+    //   hashing function and equality operator.
+    // * Invalidates any references and pointers to elements within the table after
+    //   `rehash()`.
+    // * Contains a `capacity()` member function indicating the number of element
+    //   slots (open, deleted, and empty) within the hash map.
+    // * Returns `void` from the `erase(iterator)` overload.
+    //
+    // By default, `flat_hash_map` uses the `absl::Hash` hashing framework.
+    // All fundamental and Abseil types that support the `absl::Hash` framework have
+    // a compatible equality operator for comparing insertions into `flat_hash_map`.
+    // If your type is not yet supported by the `absl::Hash` framework, see
+    // absl/hash/hash.h for information on extending Abseil hashing to user-defined
+    // types.
+    //
+    // Using `absl::flat_hash_map` at interface boundaries in dynamically loaded
+    // libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
+    // be randomized across dynamically loaded libraries.
+    //
+    // NOTE: A `flat_hash_map` stores its value types directly inside its
+    // implementation array to avoid memory indirection. Because a `flat_hash_map`
+    // is designed to move data when rehashed, map values will not retain pointer
+    // stability. If you require pointer stability, or if your values are large,
+    // consider using `absl::flat_hash_map<Key, std::unique_ptr<Value>>` instead.
+    // If your types are not moveable or you require pointer stability for keys,
+    // consider `absl::node_hash_map`.
+    //
+    // Example:
+    //
+    //   // Create a flat hash map of three strings (that map to strings)
+    //   absl::flat_hash_map<std::string, std::string> ducks =
+    //     {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}};
+    //
+    //  // Insert a new element into the flat hash map
+    //  ducks.insert({"d", "donald"});
+    //
+    //  // Force a rehash of the flat hash map
+    //  ducks.rehash(0);
+    //
+    //  // Find the element with the key "b"
+    //  std::string search_key = "b";
+    //  auto result = ducks.find(search_key);
+    //  if (result != ducks.end()) {
+    //    std::cout << "Result: " << result->second << std::endl;
+    //  }
+    template<class K, class V, class Hash = absl::container_internal::hash_default_hash<K>, class Eq = absl::container_internal::hash_default_eq<K>, class Allocator = std::allocator<std::pair<const K, V>>>
+    class flat_hash_map : public absl::container_internal::raw_hash_map<absl::container_internal::FlatHashMapPolicy<K, V>, Hash, Eq, Allocator>
+    {
+        using Base = typename flat_hash_map::raw_hash_map;
+
+    public:
+        // Constructors and Assignment Operators
+        //
+        // A flat_hash_map supports the same overload set as `std::unordered_map`
+        // for construction and assignment:
+        //
+        // *  Default constructor
+        //
+        //    // No allocation for the table's elements is made.
+        //    absl::flat_hash_map<int, std::string> map1;
+        //
+        // * Initializer List constructor
+        //
+        //   absl::flat_hash_map<int, std::string> map2 =
+        //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
+        //
+        // * Copy constructor
+        //
+        //   absl::flat_hash_map<int, std::string> map3(map2);
+        //
+        // * Copy assignment operator
+        //
+        //  // Hash functor and Comparator are copied as well
+        //  absl::flat_hash_map<int, std::string> map4;
+        //  map4 = map3;
+        //
+        // * Move constructor
+        //
+        //   // Move is guaranteed efficient
+        //   absl::flat_hash_map<int, std::string> map5(std::move(map4));
+        //
+        // * Move assignment operator
+        //
+        //   // May be efficient if allocators are compatible
+        //   absl::flat_hash_map<int, std::string> map6;
+        //   map6 = std::move(map5);
+        //
+        // * Range constructor
+        //
+        //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+        //   absl::flat_hash_map<int, std::string> map7(v.begin(), v.end());
+        flat_hash_map()
+        {
+        }
+        using Base::Base;
+
+        // flat_hash_map::begin()
+        //
+        // Returns an iterator to the beginning of the `flat_hash_map`.
+        using Base::begin;
+
+        // flat_hash_map::cbegin()
+        //
+        // Returns a const iterator to the beginning of the `flat_hash_map`.
+        using Base::cbegin;
+
+        // flat_hash_map::cend()
+        //
+        // Returns a const iterator to the end of the `flat_hash_map`.
+        using Base::cend;
+
+        // flat_hash_map::end()
+        //
+        // Returns an iterator to the end of the `flat_hash_map`.
+        using Base::end;
+
+        // flat_hash_map::capacity()
+        //
+        // Returns the number of element slots (assigned, deleted, and empty)
+        // available within the `flat_hash_map`.
+        //
+        // NOTE: this member function is particular to `absl::flat_hash_map` and is
+        // not provided in the `std::unordered_map` API.
+        using Base::capacity;
+
+        // flat_hash_map::empty()
+        //
+        // Returns whether or not the `flat_hash_map` is empty.
+        using Base::empty;
+
+        // flat_hash_map::max_size()
+        //
+        // Returns the largest theoretical possible number of elements within a
+        // `flat_hash_map` under current memory constraints. This value can be thought
+        // of the largest value of `std::distance(begin(), end())` for a
+        // `flat_hash_map<K, V>`.
+        using Base::max_size;
+
+        // flat_hash_map::size()
+        //
+        // Returns the number of elements currently within the `flat_hash_map`.
+        using Base::size;
+
+        // flat_hash_map::clear()
+        //
+        // Removes all elements from the `flat_hash_map`. Invalidates any references,
+        // pointers, or iterators referring to contained elements.
+        //
+        // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
+        // the underlying buffer call `erase(begin(), end())`.
+        using Base::clear;
+
+        // flat_hash_map::erase()
+        //
+        // Erases elements within the `flat_hash_map`. Erasing does not trigger a
+        // rehash. Overloads are listed below.
+        //
+        // void erase(const_iterator pos):
+        //
+        //   Erases the element at `position` of the `flat_hash_map`, returning
+        //   `void`.
+        //
+        //   NOTE: returning `void` in this case is different than that of STL
+        //   containers in general and `std::unordered_map` in particular (which
+        //   return an iterator to the element following the erased element). If that
+        //   iterator is needed, simply post increment the iterator:
+        //
+        //     map.erase(it++);
+        //
+        // iterator erase(const_iterator first, const_iterator last):
+        //
+        //   Erases the elements in the open interval [`first`, `last`), returning an
+        //   iterator pointing to `last`.
+        //
+        // size_type erase(const key_type& key):
+        //
+        //   Erases the element with the matching key, if it exists, returning the
+        //   number of elements erased (0 or 1).
+        using Base::erase;
+
+        // flat_hash_map::insert()
+        //
+        // Inserts an element of the specified value into the `flat_hash_map`,
+        // returning an iterator pointing to the newly inserted element, provided that
+        // an element with the given key does not already exist. If rehashing occurs
+        // due to the insertion, all iterators are invalidated. Overloads are listed
+        // below.
+        //
+        // std::pair<iterator,bool> insert(const init_type& value):
+        //
+        //   Inserts a value into the `flat_hash_map`. Returns a pair consisting of an
+        //   iterator to the inserted element (or to the element that prevented the
+        //   insertion) and a bool denoting whether the insertion took place.
+        //
+        // std::pair<iterator,bool> insert(T&& value):
+        // std::pair<iterator,bool> insert(init_type&& value):
+        //
+        //   Inserts a moveable value into the `flat_hash_map`. Returns a pair
+        //   consisting of an iterator to the inserted element (or to the element that
+        //   prevented the insertion) and a bool denoting whether the insertion took
+        //   place.
+        //
+        // iterator insert(const_iterator hint, const init_type& value):
+        // iterator insert(const_iterator hint, T&& value):
+        // iterator insert(const_iterator hint, init_type&& value);
+        //
+        //   Inserts a value, using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search. Returns an iterator to the
+        //   inserted element, or to the existing element that prevented the
+        //   insertion.
+        //
+        // void insert(InputIterator first, InputIterator last):
+        //
+        //   Inserts a range of values [`first`, `last`).
+        //
+        //   NOTE: Although the STL does not specify which element may be inserted if
+        //   multiple keys compare equivalently, for `flat_hash_map` we guarantee the
+        //   first match is inserted.
+        //
+        // void insert(std::initializer_list<init_type> ilist):
+        //
+        //   Inserts the elements within the initializer list `ilist`.
+        //
+        //   NOTE: Although the STL does not specify which element may be inserted if
+        //   multiple keys compare equivalently within the initializer list, for
+        //   `flat_hash_map` we guarantee the first match is inserted.
+        using Base::insert;
+
+        // flat_hash_map::insert_or_assign()
+        //
+        // Inserts an element of the specified value into the `flat_hash_map` provided
+        // that a value with the given key does not already exist, or replaces it with
+        // the element value if a key for that value already exists, returning an
+        // iterator pointing to the newly inserted element.  If rehashing occurs due
+        // to the insertion, all existing iterators are invalidated. Overloads are
+        // listed below.
+        //
+        // pair<iterator, bool> insert_or_assign(const init_type& k, T&& obj):
+        // pair<iterator, bool> insert_or_assign(init_type&& k, T&& obj):
+        //
+        //   Inserts/Assigns (or moves) the element of the specified key into the
+        //   `flat_hash_map`.
+        //
+        // iterator insert_or_assign(const_iterator hint,
+        //                           const init_type& k, T&& obj):
+        // iterator insert_or_assign(const_iterator hint, init_type&& k, T&& obj):
+        //
+        //   Inserts/Assigns (or moves) the element of the specified key into the
+        //   `flat_hash_map` using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search.
+        using Base::insert_or_assign;
+
+        // flat_hash_map::emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `flat_hash_map`, provided that no element with the given key
+        // already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately. Prefer `try_emplace()` unless your key is not
+        // copyable or moveable.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        using Base::emplace;
+
+        // flat_hash_map::emplace_hint()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `flat_hash_map`, using the position of `hint` as a non-binding
+        // suggestion for where to begin the insertion search, and only inserts
+        // provided that no element with the given key already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately. Prefer `try_emplace()` unless your key is not
+        // copyable or moveable.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        using Base::emplace_hint;
+
+        // flat_hash_map::try_emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `flat_hash_map`, provided that no element with the given key
+        // already exists. Unlike `emplace()`, if an element with the given key
+        // already exists, we guarantee that no element is constructed.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        // Overloads are listed below.
+        //
+        //   pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
+        //   pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
+        //
+        // Inserts (via copy or move) the element of the specified key into the
+        // `flat_hash_map`.
+        //
+        //   iterator try_emplace(const_iterator hint,
+        //                        const key_type& k, Args&&... args):
+        //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
+        //
+        // Inserts (via copy or move) the element of the specified key into the
+        // `flat_hash_map` using the position of `hint` as a non-binding suggestion
+        // for where to begin the insertion search.
+        //
+        // All `try_emplace()` overloads make the same guarantees regarding rvalue
+        // arguments as `std::unordered_map::try_emplace()`, namely that these
+        // functions will not move from rvalue arguments if insertions do not happen.
+        using Base::try_emplace;
+
+        // flat_hash_map::extract()
+        //
+        // Extracts the indicated element, erasing it in the process, and returns it
+        // as a C++17-compatible node handle. Overloads are listed below.
+        //
+        // node_type extract(const_iterator position):
+        //
+        //   Extracts the key,value pair of the element at the indicated position and
+        //   returns a node handle owning that extracted data.
+        //
+        // node_type extract(const key_type& x):
+        //
+        //   Extracts the key,value pair of the element with a key matching the passed
+        //   key value and returns a node handle owning that extracted data. If the
+        //   `flat_hash_map` does not contain an element with a matching key, this
+        //   function returns an empty node handle.
+        //
+        // NOTE: when compiled in an earlier version of C++ than C++17,
+        // `node_type::key()` returns a const reference to the key instead of a
+        // mutable reference. We cannot safely return a mutable reference without
+        // std::launder (which is not available before C++17).
+        using Base::extract;
+
+        // flat_hash_map::merge()
+        //
+        // Extracts elements from a given `source` flat hash map into this
+        // `flat_hash_map`. If the destination `flat_hash_map` already contains an
+        // element with an equivalent key, that element is not extracted.
+        using Base::merge;
+
+        // flat_hash_map::swap(flat_hash_map& other)
+        //
+        // Exchanges the contents of this `flat_hash_map` with those of the `other`
+        // flat hash map, avoiding invocation of any move, copy, or swap operations on
+        // individual elements.
+        //
+        // All iterators and references on the `flat_hash_map` remain valid, excepting
+        // for the past-the-end iterator, which is invalidated.
+        //
+        // `swap()` requires that the flat hash map's hashing and key equivalence
+        // functions be Swappable, and are exchanged using unqualified calls to
+        // non-member `swap()`. If the map's allocator has
+        // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
+        // set to `true`, the allocators are also exchanged using an unqualified call
+        // to non-member `swap()`; otherwise, the allocators are not swapped.
+        using Base::swap;
+
+        // flat_hash_map::rehash(count)
+        //
+        // Rehashes the `flat_hash_map`, setting the number of slots to be at least
+        // the passed value. If the new number of slots increases the load factor more
+        // than the current maximum load factor
+        // (`count` < `size()` / `max_load_factor()`), then the new number of slots
+        // will be at least `size()` / `max_load_factor()`.
+        //
+        // To force a rehash, pass rehash(0).
+        //
+        // NOTE: unlike behavior in `std::unordered_map`, references are also
+        // invalidated upon a `rehash()`.
+        using Base::rehash;
+
+        // flat_hash_map::reserve(count)
+        //
+        // Sets the number of slots in the `flat_hash_map` to the number needed to
+        // accommodate at least `count` total elements without exceeding the current
+        // maximum load factor, and may rehash the container if needed.
+        using Base::reserve;
+
+        // flat_hash_map::at()
+        //
+        // Returns a reference to the mapped value of the element with key equivalent
+        // to the passed key.
+        using Base::at;
+
+        // flat_hash_map::contains()
+        //
+        // Determines whether an element with a key comparing equal to the given `key`
+        // exists within the `flat_hash_map`, returning `true` if so or `false`
+        // otherwise.
+        using Base::contains;
+
+        // flat_hash_map::count(const Key& key) const
+        //
+        // Returns the number of elements with a key comparing equal to the given
+        // `key` within the `flat_hash_map`. note that this function will return
+        // either `1` or `0` since duplicate keys are not allowed within a
+        // `flat_hash_map`.
+        using Base::count;
+
+        // flat_hash_map::equal_range()
+        //
+        // Returns a closed range [first, last], defined by a `std::pair` of two
+        // iterators, containing all elements with the passed key in the
+        // `flat_hash_map`.
+        using Base::equal_range;
+
+        // flat_hash_map::find()
+        //
+        // Finds an element with the passed `key` within the `flat_hash_map`.
+        using Base::find;
+
+        // flat_hash_map::operator[]()
+        //
+        // Returns a reference to the value mapped to the passed key within the
+        // `flat_hash_map`, performing an `insert()` if the key does not already
+        // exist.
+        //
+        // If an insertion occurs and results in a rehashing of the container, all
+        // iterators are invalidated. Otherwise iterators are not affected and
+        // references are not invalidated. Overloads are listed below.
+        //
+        // T& operator[](const Key& key):
+        //
+        //   Inserts an init_type object constructed in-place if the element with the
+        //   given key does not exist.
+        //
+        // T& operator[](Key&& key):
+        //
+        //   Inserts an init_type object constructed in-place provided that an element
+        //   with the given key does not exist.
+        using Base::operator[];
+
+        // flat_hash_map::bucket_count()
+        //
+        // Returns the number of "buckets" within the `flat_hash_map`. Note that
+        // because a flat hash map contains all elements within its internal storage,
+        // this value simply equals the current capacity of the `flat_hash_map`.
+        using Base::bucket_count;
+
+        // flat_hash_map::load_factor()
+        //
+        // Returns the current load factor of the `flat_hash_map` (the average number
+        // of slots occupied with a value within the hash map).
+        using Base::load_factor;
+
+        // flat_hash_map::max_load_factor()
+        //
+        // Manages the maximum load factor of the `flat_hash_map`. Overloads are
+        // listed below.
+        //
+        // float flat_hash_map::max_load_factor()
+        //
+        //   Returns the current maximum load factor of the `flat_hash_map`.
+        //
+        // void flat_hash_map::max_load_factor(float ml)
+        //
+        //   Sets the maximum load factor of the `flat_hash_map` to the passed value.
+        //
+        //   NOTE: This overload is provided only for API compatibility with the STL;
+        //   `flat_hash_map` will ignore any set load factor and manage its rehashing
+        //   internally as an implementation detail.
+        using Base::max_load_factor;
+
+        // flat_hash_map::get_allocator()
+        //
+        // Returns the allocator function associated with this `flat_hash_map`.
+        using Base::get_allocator;
+
+        // flat_hash_map::hash_function()
+        //
+        // Returns the hashing function used to hash the keys within this
+        // `flat_hash_map`.
+        using Base::hash_function;
+
+        // flat_hash_map::key_eq()
+        //
+        // Returns the function used for comparing keys equality.
+        using Base::key_eq;
+    };
+
+    // erase_if(flat_hash_map<>, Pred)
+    //
+    // Erases all elements that satisfy the predicate `pred` from the container `c`.
+    // Returns the number of erased elements.
+    template<typename K, typename V, typename H, typename E, typename A, typename Predicate>
+    typename flat_hash_map<K, V, H, E, A>::size_type erase_if(
+        flat_hash_map<K, V, H, E, A>& c, Predicate pred
+    )
+    {
+        return container_internal::EraseIf(pred, &c);
+    }
+
+    namespace container_internal
+    {
+
+        template<class K, class V>
+        struct FlatHashMapPolicy
+        {
+            using slot_policy = container_internal::map_slot_policy<K, V>;
+            using slot_type = typename slot_policy::slot_type;
+            using key_type = K;
+            using mapped_type = V;
+            using init_type = std::pair</*non const*/ key_type, mapped_type>;
+
+            template<class Allocator, class... Args>
+            static void construct(Allocator* alloc, slot_type* slot, Args&&... args)
+            {
+                slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
+            }
+
+            template<class Allocator>
+            static void destroy(Allocator* alloc, slot_type* slot)
+            {
+                slot_policy::destroy(alloc, slot);
+            }
+
+            template<class Allocator>
+            static void transfer(Allocator* alloc, slot_type* new_slot, slot_type* old_slot)
+            {
+                slot_policy::transfer(alloc, new_slot, old_slot);
+            }
+
+            template<class F, class... Args>
+            static decltype(absl::container_internal::DecomposePair(
+                std::declval<F>(), std::declval<Args>()...
+            ))
+                apply(F&& f, Args&&... args)
+            {
+                return absl::container_internal::DecomposePair(std::forward<F>(f), std::forward<Args>(args)...);
+            }
+
+            static size_t space_used(const slot_type*)
+            {
+                return 0;
+            }
+
+            static std::pair<const K, V>& element(slot_type* slot)
+            {
+                return slot->value;
+            }
+
+            static V& value(std::pair<const K, V>* kv)
+            {
+                return kv->second;
+            }
+            static const V& value(const std::pair<const K, V>* kv)
+            {
+                return kv->second;
+            }
+        };
+
+    }  // namespace container_internal
+
+    namespace container_algorithm_internal
+    {
+
+        // Specialization of trait in absl/algorithm/container.h
+        template<class Key, class T, class Hash, class KeyEqual, class Allocator>
+        struct IsUnorderedContainer<
+            absl::flat_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type
+        {
+        };
+
+    }  // namespace container_algorithm_internal
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_FLAT_HASH_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/flat_hash_set.h b/CAPI/cpp/grpc/include/absl/container/flat_hash_set.h
index 4938c70..15f96ad 100644
--- a/CAPI/cpp/grpc/include/absl/container/flat_hash_set.h
+++ b/CAPI/cpp/grpc/include/absl/container/flat_hash_set.h
@@ -36,475 +36,492 @@
 #include "absl/base/macros.h"
 #include "absl/container/internal/container_memory.h"
 #include "absl/container/internal/hash_function_defaults.h"  // IWYU pragma: export
-#include "absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
+#include "absl/container/internal/raw_hash_set.h"            // IWYU pragma: export
 #include "absl/memory/memory.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-template <typename T>
-struct FlatHashSetPolicy;
-}  // namespace container_internal
-
-// -----------------------------------------------------------------------------
-// absl::flat_hash_set
-// -----------------------------------------------------------------------------
-//
-// An `absl::flat_hash_set<T>` is an unordered associative container which has
-// been optimized for both speed and memory footprint in most common use cases.
-// Its interface is similar to that of `std::unordered_set<T>` with the
-// following notable differences:
-//
-// * Requires keys that are CopyConstructible
-// * Supports heterogeneous lookup, through `find()` and `insert()`, provided
-//   that the set is provided a compatible heterogeneous hashing function and
-//   equality operator.
-// * Invalidates any references and pointers to elements within the table after
-//   `rehash()`.
-// * Contains a `capacity()` member function indicating the number of element
-//   slots (open, deleted, and empty) within the hash set.
-// * Returns `void` from the `erase(iterator)` overload.
-//
-// By default, `flat_hash_set` uses the `absl::Hash` hashing framework. All
-// fundamental and Abseil types that support the `absl::Hash` framework have a
-// compatible equality operator for comparing insertions into `flat_hash_set`.
-// If your type is not yet supported by the `absl::Hash` framework, see
-// absl/hash/hash.h for information on extending Abseil hashing to user-defined
-// types.
-//
-// Using `absl::flat_hash_set` at interface boundaries in dynamically loaded
-// libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
-// be randomized across dynamically loaded libraries.
-//
-// NOTE: A `flat_hash_set` stores its keys directly inside its implementation
-// array to avoid memory indirection. Because a `flat_hash_set` is designed to
-// move data when rehashed, set keys will not retain pointer stability. If you
-// require pointer stability, consider using
-// `absl::flat_hash_set<std::unique_ptr<T>>`. If your type is not moveable and
-// you require pointer stability, consider `absl::node_hash_set` instead.
-//
-// Example:
-//
-//   // Create a flat hash set of three strings
-//   absl::flat_hash_set<std::string> ducks =
-//     {"huey", "dewey", "louie"};
-//
-//  // Insert a new element into the flat hash set
-//  ducks.insert("donald");
-//
-//  // Force a rehash of the flat hash set
-//  ducks.rehash(0);
-//
-//  // See if "dewey" is present
-//  if (ducks.contains("dewey")) {
-//    std::cout << "We found dewey!" << std::endl;
-//  }
-template <class T, class Hash = absl::container_internal::hash_default_hash<T>,
-          class Eq = absl::container_internal::hash_default_eq<T>,
-          class Allocator = std::allocator<T>>
-class flat_hash_set
-    : public absl::container_internal::raw_hash_set<
-          absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator> {
-  using Base = typename flat_hash_set::raw_hash_set;
-
- public:
-  // Constructors and Assignment Operators
-  //
-  // A flat_hash_set supports the same overload set as `std::unordered_set`
-  // for construction and assignment:
-  //
-  // *  Default constructor
-  //
-  //    // No allocation for the table's elements is made.
-  //    absl::flat_hash_set<std::string> set1;
-  //
-  // * Initializer List constructor
-  //
-  //   absl::flat_hash_set<std::string> set2 =
-  //       {{"huey"}, {"dewey"}, {"louie"},};
-  //
-  // * Copy constructor
-  //
-  //   absl::flat_hash_set<std::string> set3(set2);
-  //
-  // * Copy assignment operator
-  //
-  //  // Hash functor and Comparator are copied as well
-  //  absl::flat_hash_set<std::string> set4;
-  //  set4 = set3;
-  //
-  // * Move constructor
-  //
-  //   // Move is guaranteed efficient
-  //   absl::flat_hash_set<std::string> set5(std::move(set4));
-  //
-  // * Move assignment operator
-  //
-  //   // May be efficient if allocators are compatible
-  //   absl::flat_hash_set<std::string> set6;
-  //   set6 = std::move(set5);
-  //
-  // * Range constructor
-  //
-  //   std::vector<std::string> v = {"a", "b"};
-  //   absl::flat_hash_set<std::string> set7(v.begin(), v.end());
-  flat_hash_set() {}
-  using Base::Base;
-
-  // flat_hash_set::begin()
-  //
-  // Returns an iterator to the beginning of the `flat_hash_set`.
-  using Base::begin;
-
-  // flat_hash_set::cbegin()
-  //
-  // Returns a const iterator to the beginning of the `flat_hash_set`.
-  using Base::cbegin;
-
-  // flat_hash_set::cend()
-  //
-  // Returns a const iterator to the end of the `flat_hash_set`.
-  using Base::cend;
-
-  // flat_hash_set::end()
-  //
-  // Returns an iterator to the end of the `flat_hash_set`.
-  using Base::end;
-
-  // flat_hash_set::capacity()
-  //
-  // Returns the number of element slots (assigned, deleted, and empty)
-  // available within the `flat_hash_set`.
-  //
-  // NOTE: this member function is particular to `absl::flat_hash_set` and is
-  // not provided in the `std::unordered_set` API.
-  using Base::capacity;
-
-  // flat_hash_set::empty()
-  //
-  // Returns whether or not the `flat_hash_set` is empty.
-  using Base::empty;
-
-  // flat_hash_set::max_size()
-  //
-  // Returns the largest theoretical possible number of elements within a
-  // `flat_hash_set` under current memory constraints. This value can be thought
-  // of the largest value of `std::distance(begin(), end())` for a
-  // `flat_hash_set<T>`.
-  using Base::max_size;
-
-  // flat_hash_set::size()
-  //
-  // Returns the number of elements currently within the `flat_hash_set`.
-  using Base::size;
-
-  // flat_hash_set::clear()
-  //
-  // Removes all elements from the `flat_hash_set`. Invalidates any references,
-  // pointers, or iterators referring to contained elements.
-  //
-  // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
-  // the underlying buffer call `erase(begin(), end())`.
-  using Base::clear;
-
-  // flat_hash_set::erase()
-  //
-  // Erases elements within the `flat_hash_set`. Erasing does not trigger a
-  // rehash. Overloads are listed below.
-  //
-  // void erase(const_iterator pos):
-  //
-  //   Erases the element at `position` of the `flat_hash_set`, returning
-  //   `void`.
-  //
-  //   NOTE: returning `void` in this case is different than that of STL
-  //   containers in general and `std::unordered_set` in particular (which
-  //   return an iterator to the element following the erased element). If that
-  //   iterator is needed, simply post increment the iterator:
-  //
-  //     set.erase(it++);
-  //
-  // iterator erase(const_iterator first, const_iterator last):
-  //
-  //   Erases the elements in the open interval [`first`, `last`), returning an
-  //   iterator pointing to `last`.
-  //
-  // size_type erase(const key_type& key):
-  //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
-  using Base::erase;
-
-  // flat_hash_set::insert()
-  //
-  // Inserts an element of the specified value into the `flat_hash_set`,
-  // returning an iterator pointing to the newly inserted element, provided that
-  // an element with the given key does not already exist. If rehashing occurs
-  // due to the insertion, all iterators are invalidated. Overloads are listed
-  // below.
-  //
-  // std::pair<iterator,bool> insert(const T& value):
-  //
-  //   Inserts a value into the `flat_hash_set`. Returns a pair consisting of an
-  //   iterator to the inserted element (or to the element that prevented the
-  //   insertion) and a bool denoting whether the insertion took place.
-  //
-  // std::pair<iterator,bool> insert(T&& value):
-  //
-  //   Inserts a moveable value into the `flat_hash_set`. Returns a pair
-  //   consisting of an iterator to the inserted element (or to the element that
-  //   prevented the insertion) and a bool denoting whether the insertion took
-  //   place.
-  //
-  // iterator insert(const_iterator hint, const T& value):
-  // iterator insert(const_iterator hint, T&& value):
-  //
-  //   Inserts a value, using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search. Returns an iterator to the
-  //   inserted element, or to the existing element that prevented the
-  //   insertion.
-  //
-  // void insert(InputIterator first, InputIterator last):
-  //
-  //   Inserts a range of values [`first`, `last`).
-  //
-  //   NOTE: Although the STL does not specify which element may be inserted if
-  //   multiple keys compare equivalently, for `flat_hash_set` we guarantee the
-  //   first match is inserted.
-  //
-  // void insert(std::initializer_list<T> ilist):
-  //
-  //   Inserts the elements within the initializer list `ilist`.
-  //
-  //   NOTE: Although the STL does not specify which element may be inserted if
-  //   multiple keys compare equivalently within the initializer list, for
-  //   `flat_hash_set` we guarantee the first match is inserted.
-  using Base::insert;
-
-  // flat_hash_set::emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `flat_hash_set`, provided that no element with the given key
-  // already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  using Base::emplace;
-
-  // flat_hash_set::emplace_hint()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `flat_hash_set`, using the position of `hint` as a non-binding
-  // suggestion for where to begin the insertion search, and only inserts
-  // provided that no element with the given key already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  using Base::emplace_hint;
-
-  // flat_hash_set::extract()
-  //
-  // Extracts the indicated element, erasing it in the process, and returns it
-  // as a C++17-compatible node handle. Overloads are listed below.
-  //
-  // node_type extract(const_iterator position):
-  //
-  //   Extracts the element at the indicated position and returns a node handle
-  //   owning that extracted data.
-  //
-  // node_type extract(const key_type& x):
-  //
-  //   Extracts the element with the key matching the passed key value and
-  //   returns a node handle owning that extracted data. If the `flat_hash_set`
-  //   does not contain an element with a matching key, this function returns an
-  //   empty node handle.
-  using Base::extract;
-
-  // flat_hash_set::merge()
-  //
-  // Extracts elements from a given `source` flat hash set into this
-  // `flat_hash_set`. If the destination `flat_hash_set` already contains an
-  // element with an equivalent key, that element is not extracted.
-  using Base::merge;
-
-  // flat_hash_set::swap(flat_hash_set& other)
-  //
-  // Exchanges the contents of this `flat_hash_set` with those of the `other`
-  // flat hash set, avoiding invocation of any move, copy, or swap operations on
-  // individual elements.
-  //
-  // All iterators and references on the `flat_hash_set` remain valid, excepting
-  // for the past-the-end iterator, which is invalidated.
-  //
-  // `swap()` requires that the flat hash set's hashing and key equivalence
-  // functions be Swappable, and are exchaged using unqualified calls to
-  // non-member `swap()`. If the set's allocator has
-  // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
-  // set to `true`, the allocators are also exchanged using an unqualified call
-  // to non-member `swap()`; otherwise, the allocators are not swapped.
-  using Base::swap;
-
-  // flat_hash_set::rehash(count)
-  //
-  // Rehashes the `flat_hash_set`, setting the number of slots to be at least
-  // the passed value. If the new number of slots increases the load factor more
-  // than the current maximum load factor
-  // (`count` < `size()` / `max_load_factor()`), then the new number of slots
-  // will be at least `size()` / `max_load_factor()`.
-  //
-  // To force a rehash, pass rehash(0).
-  //
-  // NOTE: unlike behavior in `std::unordered_set`, references are also
-  // invalidated upon a `rehash()`.
-  using Base::rehash;
-
-  // flat_hash_set::reserve(count)
-  //
-  // Sets the number of slots in the `flat_hash_set` to the number needed to
-  // accommodate at least `count` total elements without exceeding the current
-  // maximum load factor, and may rehash the container if needed.
-  using Base::reserve;
-
-  // flat_hash_set::contains()
-  //
-  // Determines whether an element comparing equal to the given `key` exists
-  // within the `flat_hash_set`, returning `true` if so or `false` otherwise.
-  using Base::contains;
-
-  // flat_hash_set::count(const Key& key) const
-  //
-  // Returns the number of elements comparing equal to the given `key` within
-  // the `flat_hash_set`. note that this function will return either `1` or `0`
-  // since duplicate elements are not allowed within a `flat_hash_set`.
-  using Base::count;
-
-  // flat_hash_set::equal_range()
-  //
-  // Returns a closed range [first, last], defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the
-  // `flat_hash_set`.
-  using Base::equal_range;
-
-  // flat_hash_set::find()
-  //
-  // Finds an element with the passed `key` within the `flat_hash_set`.
-  using Base::find;
-
-  // flat_hash_set::bucket_count()
-  //
-  // Returns the number of "buckets" within the `flat_hash_set`. Note that
-  // because a flat hash set contains all elements within its internal storage,
-  // this value simply equals the current capacity of the `flat_hash_set`.
-  using Base::bucket_count;
-
-  // flat_hash_set::load_factor()
-  //
-  // Returns the current load factor of the `flat_hash_set` (the average number
-  // of slots occupied with a value within the hash set).
-  using Base::load_factor;
-
-  // flat_hash_set::max_load_factor()
-  //
-  // Manages the maximum load factor of the `flat_hash_set`. Overloads are
-  // listed below.
-  //
-  // float flat_hash_set::max_load_factor()
-  //
-  //   Returns the current maximum load factor of the `flat_hash_set`.
-  //
-  // void flat_hash_set::max_load_factor(float ml)
-  //
-  //   Sets the maximum load factor of the `flat_hash_set` to the passed value.
-  //
-  //   NOTE: This overload is provided only for API compatibility with the STL;
-  //   `flat_hash_set` will ignore any set load factor and manage its rehashing
-  //   internally as an implementation detail.
-  using Base::max_load_factor;
-
-  // flat_hash_set::get_allocator()
-  //
-  // Returns the allocator function associated with this `flat_hash_set`.
-  using Base::get_allocator;
-
-  // flat_hash_set::hash_function()
-  //
-  // Returns the hashing function used to hash the keys within this
-  // `flat_hash_set`.
-  using Base::hash_function;
-
-  // flat_hash_set::key_eq()
-  //
-  // Returns the function used for comparing keys equality.
-  using Base::key_eq;
-};
-
-// erase_if(flat_hash_set<>, Pred)
-//
-// Erases all elements that satisfy the predicate `pred` from the container `c`.
-// Returns the number of erased elements.
-template <typename T, typename H, typename E, typename A, typename Predicate>
-typename flat_hash_set<T, H, E, A>::size_type erase_if(
-    flat_hash_set<T, H, E, A>& c, Predicate pred) {
-  return container_internal::EraseIf(pred, &c);
-}
-
-namespace container_internal {
-
-template <class T>
-struct FlatHashSetPolicy {
-  using slot_type = T;
-  using key_type = T;
-  using init_type = T;
-  using constant_iterators = std::true_type;
-
-  template <class Allocator, class... Args>
-  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
-    absl::allocator_traits<Allocator>::construct(*alloc, slot,
-                                                 std::forward<Args>(args)...);
-  }
-
-  template <class Allocator>
-  static void destroy(Allocator* alloc, slot_type* slot) {
-    absl::allocator_traits<Allocator>::destroy(*alloc, slot);
-  }
-
-  template <class Allocator>
-  static void transfer(Allocator* alloc, slot_type* new_slot,
-                       slot_type* old_slot) {
-    construct(alloc, new_slot, std::move(*old_slot));
-    destroy(alloc, old_slot);
-  }
-
-  static T& element(slot_type* slot) { return *slot; }
-
-  template <class F, class... Args>
-  static decltype(absl::container_internal::DecomposeValue(
-      std::declval<F>(), std::declval<Args>()...))
-  apply(F&& f, Args&&... args) {
-    return absl::container_internal::DecomposeValue(
-        std::forward<F>(f), std::forward<Args>(args)...);
-  }
-
-  static size_t space_used(const T*) { return 0; }
-};
-}  // namespace container_internal
-
-namespace container_algorithm_internal {
-
-// Specialization of trait in absl/algorithm/container.h
-template <class Key, class Hash, class KeyEqual, class Allocator>
-struct IsUnorderedContainer<absl::flat_hash_set<Key, Hash, KeyEqual, Allocator>>
-    : std::true_type {};
-
-}  // namespace container_algorithm_internal
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+        template<typename T>
+        struct FlatHashSetPolicy;
+    }  // namespace container_internal
+
+    // -----------------------------------------------------------------------------
+    // absl::flat_hash_set
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::flat_hash_set<T>` is an unordered associative container which has
+    // been optimized for both speed and memory footprint in most common use cases.
+    // Its interface is similar to that of `std::unordered_set<T>` with the
+    // following notable differences:
+    //
+    // * Requires keys that are CopyConstructible
+    // * Supports heterogeneous lookup, through `find()` and `insert()`, provided
+    //   that the set is provided a compatible heterogeneous hashing function and
+    //   equality operator.
+    // * Invalidates any references and pointers to elements within the table after
+    //   `rehash()`.
+    // * Contains a `capacity()` member function indicating the number of element
+    //   slots (open, deleted, and empty) within the hash set.
+    // * Returns `void` from the `erase(iterator)` overload.
+    //
+    // By default, `flat_hash_set` uses the `absl::Hash` hashing framework. All
+    // fundamental and Abseil types that support the `absl::Hash` framework have a
+    // compatible equality operator for comparing insertions into `flat_hash_set`.
+    // If your type is not yet supported by the `absl::Hash` framework, see
+    // absl/hash/hash.h for information on extending Abseil hashing to user-defined
+    // types.
+    //
+    // Using `absl::flat_hash_set` at interface boundaries in dynamically loaded
+    // libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
+    // be randomized across dynamically loaded libraries.
+    //
+    // NOTE: A `flat_hash_set` stores its keys directly inside its implementation
+    // array to avoid memory indirection. Because a `flat_hash_set` is designed to
+    // move data when rehashed, set keys will not retain pointer stability. If you
+    // require pointer stability, consider using
+    // `absl::flat_hash_set<std::unique_ptr<T>>`. If your type is not moveable and
+    // you require pointer stability, consider `absl::node_hash_set` instead.
+    //
+    // Example:
+    //
+    //   // Create a flat hash set of three strings
+    //   absl::flat_hash_set<std::string> ducks =
+    //     {"huey", "dewey", "louie"};
+    //
+    //  // Insert a new element into the flat hash set
+    //  ducks.insert("donald");
+    //
+    //  // Force a rehash of the flat hash set
+    //  ducks.rehash(0);
+    //
+    //  // See if "dewey" is present
+    //  if (ducks.contains("dewey")) {
+    //    std::cout << "We found dewey!" << std::endl;
+    //  }
+    template<class T, class Hash = absl::container_internal::hash_default_hash<T>, class Eq = absl::container_internal::hash_default_eq<T>, class Allocator = std::allocator<T>>
+    class flat_hash_set : public absl::container_internal::raw_hash_set<absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator>
+    {
+        using Base = typename flat_hash_set::raw_hash_set;
+
+    public:
+        // Constructors and Assignment Operators
+        //
+        // A flat_hash_set supports the same overload set as `std::unordered_set`
+        // for construction and assignment:
+        //
+        // *  Default constructor
+        //
+        //    // No allocation for the table's elements is made.
+        //    absl::flat_hash_set<std::string> set1;
+        //
+        // * Initializer List constructor
+        //
+        //   absl::flat_hash_set<std::string> set2 =
+        //       {{"huey"}, {"dewey"}, {"louie"},};
+        //
+        // * Copy constructor
+        //
+        //   absl::flat_hash_set<std::string> set3(set2);
+        //
+        // * Copy assignment operator
+        //
+        //  // Hash functor and Comparator are copied as well
+        //  absl::flat_hash_set<std::string> set4;
+        //  set4 = set3;
+        //
+        // * Move constructor
+        //
+        //   // Move is guaranteed efficient
+        //   absl::flat_hash_set<std::string> set5(std::move(set4));
+        //
+        // * Move assignment operator
+        //
+        //   // May be efficient if allocators are compatible
+        //   absl::flat_hash_set<std::string> set6;
+        //   set6 = std::move(set5);
+        //
+        // * Range constructor
+        //
+        //   std::vector<std::string> v = {"a", "b"};
+        //   absl::flat_hash_set<std::string> set7(v.begin(), v.end());
+        flat_hash_set()
+        {
+        }
+        using Base::Base;
+
+        // flat_hash_set::begin()
+        //
+        // Returns an iterator to the beginning of the `flat_hash_set`.
+        using Base::begin;
+
+        // flat_hash_set::cbegin()
+        //
+        // Returns a const iterator to the beginning of the `flat_hash_set`.
+        using Base::cbegin;
+
+        // flat_hash_set::cend()
+        //
+        // Returns a const iterator to the end of the `flat_hash_set`.
+        using Base::cend;
+
+        // flat_hash_set::end()
+        //
+        // Returns an iterator to the end of the `flat_hash_set`.
+        using Base::end;
+
+        // flat_hash_set::capacity()
+        //
+        // Returns the number of element slots (assigned, deleted, and empty)
+        // available within the `flat_hash_set`.
+        //
+        // NOTE: this member function is particular to `absl::flat_hash_set` and is
+        // not provided in the `std::unordered_set` API.
+        using Base::capacity;
+
+        // flat_hash_set::empty()
+        //
+        // Returns whether or not the `flat_hash_set` is empty.
+        using Base::empty;
+
+        // flat_hash_set::max_size()
+        //
+        // Returns the largest theoretical possible number of elements within a
+        // `flat_hash_set` under current memory constraints. This value can be thought
+        // of the largest value of `std::distance(begin(), end())` for a
+        // `flat_hash_set<T>`.
+        using Base::max_size;
+
+        // flat_hash_set::size()
+        //
+        // Returns the number of elements currently within the `flat_hash_set`.
+        using Base::size;
+
+        // flat_hash_set::clear()
+        //
+        // Removes all elements from the `flat_hash_set`. Invalidates any references,
+        // pointers, or iterators referring to contained elements.
+        //
+        // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
+        // the underlying buffer call `erase(begin(), end())`.
+        using Base::clear;
+
+        // flat_hash_set::erase()
+        //
+        // Erases elements within the `flat_hash_set`. Erasing does not trigger a
+        // rehash. Overloads are listed below.
+        //
+        // void erase(const_iterator pos):
+        //
+        //   Erases the element at `position` of the `flat_hash_set`, returning
+        //   `void`.
+        //
+        //   NOTE: returning `void` in this case is different than that of STL
+        //   containers in general and `std::unordered_set` in particular (which
+        //   return an iterator to the element following the erased element). If that
+        //   iterator is needed, simply post increment the iterator:
+        //
+        //     set.erase(it++);
+        //
+        // iterator erase(const_iterator first, const_iterator last):
+        //
+        //   Erases the elements in the open interval [`first`, `last`), returning an
+        //   iterator pointing to `last`.
+        //
+        // size_type erase(const key_type& key):
+        //
+        //   Erases the element with the matching key, if it exists, returning the
+        //   number of elements erased (0 or 1).
+        using Base::erase;
+
+        // flat_hash_set::insert()
+        //
+        // Inserts an element of the specified value into the `flat_hash_set`,
+        // returning an iterator pointing to the newly inserted element, provided that
+        // an element with the given key does not already exist. If rehashing occurs
+        // due to the insertion, all iterators are invalidated. Overloads are listed
+        // below.
+        //
+        // std::pair<iterator,bool> insert(const T& value):
+        //
+        //   Inserts a value into the `flat_hash_set`. Returns a pair consisting of an
+        //   iterator to the inserted element (or to the element that prevented the
+        //   insertion) and a bool denoting whether the insertion took place.
+        //
+        // std::pair<iterator,bool> insert(T&& value):
+        //
+        //   Inserts a moveable value into the `flat_hash_set`. Returns a pair
+        //   consisting of an iterator to the inserted element (or to the element that
+        //   prevented the insertion) and a bool denoting whether the insertion took
+        //   place.
+        //
+        // iterator insert(const_iterator hint, const T& value):
+        // iterator insert(const_iterator hint, T&& value):
+        //
+        //   Inserts a value, using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search. Returns an iterator to the
+        //   inserted element, or to the existing element that prevented the
+        //   insertion.
+        //
+        // void insert(InputIterator first, InputIterator last):
+        //
+        //   Inserts a range of values [`first`, `last`).
+        //
+        //   NOTE: Although the STL does not specify which element may be inserted if
+        //   multiple keys compare equivalently, for `flat_hash_set` we guarantee the
+        //   first match is inserted.
+        //
+        // void insert(std::initializer_list<T> ilist):
+        //
+        //   Inserts the elements within the initializer list `ilist`.
+        //
+        //   NOTE: Although the STL does not specify which element may be inserted if
+        //   multiple keys compare equivalently within the initializer list, for
+        //   `flat_hash_set` we guarantee the first match is inserted.
+        using Base::insert;
+
+        // flat_hash_set::emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `flat_hash_set`, provided that no element with the given key
+        // already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        using Base::emplace;
+
+        // flat_hash_set::emplace_hint()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `flat_hash_set`, using the position of `hint` as a non-binding
+        // suggestion for where to begin the insertion search, and only inserts
+        // provided that no element with the given key already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        using Base::emplace_hint;
+
+        // flat_hash_set::extract()
+        //
+        // Extracts the indicated element, erasing it in the process, and returns it
+        // as a C++17-compatible node handle. Overloads are listed below.
+        //
+        // node_type extract(const_iterator position):
+        //
+        //   Extracts the element at the indicated position and returns a node handle
+        //   owning that extracted data.
+        //
+        // node_type extract(const key_type& x):
+        //
+        //   Extracts the element with the key matching the passed key value and
+        //   returns a node handle owning that extracted data. If the `flat_hash_set`
+        //   does not contain an element with a matching key, this function returns an
+        //   empty node handle.
+        using Base::extract;
+
+        // flat_hash_set::merge()
+        //
+        // Extracts elements from a given `source` flat hash set into this
+        // `flat_hash_set`. If the destination `flat_hash_set` already contains an
+        // element with an equivalent key, that element is not extracted.
+        using Base::merge;
+
+        // flat_hash_set::swap(flat_hash_set& other)
+        //
+        // Exchanges the contents of this `flat_hash_set` with those of the `other`
+        // flat hash set, avoiding invocation of any move, copy, or swap operations on
+        // individual elements.
+        //
+        // All iterators and references on the `flat_hash_set` remain valid, excepting
+        // for the past-the-end iterator, which is invalidated.
+        //
+        // `swap()` requires that the flat hash set's hashing and key equivalence
+        // functions be Swappable, and are exchaged using unqualified calls to
+        // non-member `swap()`. If the set's allocator has
+        // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
+        // set to `true`, the allocators are also exchanged using an unqualified call
+        // to non-member `swap()`; otherwise, the allocators are not swapped.
+        using Base::swap;
+
+        // flat_hash_set::rehash(count)
+        //
+        // Rehashes the `flat_hash_set`, setting the number of slots to be at least
+        // the passed value. If the new number of slots increases the load factor more
+        // than the current maximum load factor
+        // (`count` < `size()` / `max_load_factor()`), then the new number of slots
+        // will be at least `size()` / `max_load_factor()`.
+        //
+        // To force a rehash, pass rehash(0).
+        //
+        // NOTE: unlike behavior in `std::unordered_set`, references are also
+        // invalidated upon a `rehash()`.
+        using Base::rehash;
+
+        // flat_hash_set::reserve(count)
+        //
+        // Sets the number of slots in the `flat_hash_set` to the number needed to
+        // accommodate at least `count` total elements without exceeding the current
+        // maximum load factor, and may rehash the container if needed.
+        using Base::reserve;
+
+        // flat_hash_set::contains()
+        //
+        // Determines whether an element comparing equal to the given `key` exists
+        // within the `flat_hash_set`, returning `true` if so or `false` otherwise.
+        using Base::contains;
+
+        // flat_hash_set::count(const Key& key) const
+        //
+        // Returns the number of elements comparing equal to the given `key` within
+        // the `flat_hash_set`. note that this function will return either `1` or `0`
+        // since duplicate elements are not allowed within a `flat_hash_set`.
+        using Base::count;
+
+        // flat_hash_set::equal_range()
+        //
+        // Returns a closed range [first, last], defined by a `std::pair` of two
+        // iterators, containing all elements with the passed key in the
+        // `flat_hash_set`.
+        using Base::equal_range;
+
+        // flat_hash_set::find()
+        //
+        // Finds an element with the passed `key` within the `flat_hash_set`.
+        using Base::find;
+
+        // flat_hash_set::bucket_count()
+        //
+        // Returns the number of "buckets" within the `flat_hash_set`. Note that
+        // because a flat hash set contains all elements within its internal storage,
+        // this value simply equals the current capacity of the `flat_hash_set`.
+        using Base::bucket_count;
+
+        // flat_hash_set::load_factor()
+        //
+        // Returns the current load factor of the `flat_hash_set` (the average number
+        // of slots occupied with a value within the hash set).
+        using Base::load_factor;
+
+        // flat_hash_set::max_load_factor()
+        //
+        // Manages the maximum load factor of the `flat_hash_set`. Overloads are
+        // listed below.
+        //
+        // float flat_hash_set::max_load_factor()
+        //
+        //   Returns the current maximum load factor of the `flat_hash_set`.
+        //
+        // void flat_hash_set::max_load_factor(float ml)
+        //
+        //   Sets the maximum load factor of the `flat_hash_set` to the passed value.
+        //
+        //   NOTE: This overload is provided only for API compatibility with the STL;
+        //   `flat_hash_set` will ignore any set load factor and manage its rehashing
+        //   internally as an implementation detail.
+        using Base::max_load_factor;
+
+        // flat_hash_set::get_allocator()
+        //
+        // Returns the allocator function associated with this `flat_hash_set`.
+        using Base::get_allocator;
+
+        // flat_hash_set::hash_function()
+        //
+        // Returns the hashing function used to hash the keys within this
+        // `flat_hash_set`.
+        using Base::hash_function;
+
+        // flat_hash_set::key_eq()
+        //
+        // Returns the function used for comparing keys equality.
+        using Base::key_eq;
+    };
+
+    // erase_if(flat_hash_set<>, Pred)
+    //
+    // Erases all elements that satisfy the predicate `pred` from the container `c`.
+    // Returns the number of erased elements.
+    template<typename T, typename H, typename E, typename A, typename Predicate>
+    typename flat_hash_set<T, H, E, A>::size_type erase_if(
+        flat_hash_set<T, H, E, A>& c, Predicate pred
+    )
+    {
+        return container_internal::EraseIf(pred, &c);
+    }
+
+    namespace container_internal
+    {
+
+        template<class T>
+        struct FlatHashSetPolicy
+        {
+            using slot_type = T;
+            using key_type = T;
+            using init_type = T;
+            using constant_iterators = std::true_type;
+
+            template<class Allocator, class... Args>
+            static void construct(Allocator* alloc, slot_type* slot, Args&&... args)
+            {
+                absl::allocator_traits<Allocator>::construct(*alloc, slot, std::forward<Args>(args)...);
+            }
+
+            template<class Allocator>
+            static void destroy(Allocator* alloc, slot_type* slot)
+            {
+                absl::allocator_traits<Allocator>::destroy(*alloc, slot);
+            }
+
+            template<class Allocator>
+            static void transfer(Allocator* alloc, slot_type* new_slot, slot_type* old_slot)
+            {
+                construct(alloc, new_slot, std::move(*old_slot));
+                destroy(alloc, old_slot);
+            }
+
+            static T& element(slot_type* slot)
+            {
+                return *slot;
+            }
+
+            template<class F, class... Args>
+            static decltype(absl::container_internal::DecomposeValue(
+                std::declval<F>(), std::declval<Args>()...
+            ))
+                apply(F&& f, Args&&... args)
+            {
+                return absl::container_internal::DecomposeValue(
+                    std::forward<F>(f), std::forward<Args>(args)...
+                );
+            }
+
+            static size_t space_used(const T*)
+            {
+                return 0;
+            }
+        };
+    }  // namespace container_internal
+
+    namespace container_algorithm_internal
+    {
+
+        // Specialization of trait in absl/algorithm/container.h
+        template<class Key, class Hash, class KeyEqual, class Allocator>
+        struct IsUnorderedContainer<absl::flat_hash_set<Key, Hash, KeyEqual, Allocator>> : std::true_type
+        {
+        };
+
+    }  // namespace container_algorithm_internal
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_FLAT_HASH_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/inlined_vector.h b/CAPI/cpp/grpc/include/absl/container/inlined_vector.h
index bc1c4a7..cc2c39b 100644
--- a/CAPI/cpp/grpc/include/absl/container/inlined_vector.h
+++ b/CAPI/cpp/grpc/include/absl/container/inlined_vector.h
@@ -53,814 +53,932 @@
 #include "absl/container/internal/inlined_vector.h"
 #include "absl/memory/memory.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-// -----------------------------------------------------------------------------
-// InlinedVector
-// -----------------------------------------------------------------------------
-//
-// An `absl::InlinedVector` is designed to be a drop-in replacement for
-// `std::vector` for use cases where the vector's size is sufficiently small
-// that it can be inlined. If the inlined vector does grow beyond its estimated
-// capacity, it will trigger an initial allocation on the heap, and will behave
-// as a `std::vector`. The API of the `absl::InlinedVector` within this file is
-// designed to cover the same API footprint as covered by `std::vector`.
-template <typename T, size_t N, typename A = std::allocator<T>>
-class InlinedVector {
-  static_assert(N > 0, "`absl::InlinedVector` requires an inlined capacity.");
-
-  using Storage = inlined_vector_internal::Storage<T, N, A>;
-
-  template <typename TheA>
-  using AllocatorTraits = inlined_vector_internal::AllocatorTraits<TheA>;
-  template <typename TheA>
-  using MoveIterator = inlined_vector_internal::MoveIterator<TheA>;
-  template <typename TheA>
-  using IsMemcpyOk = inlined_vector_internal::IsMemcpyOk<TheA>;
-
-  template <typename TheA, typename Iterator>
-  using IteratorValueAdapter =
-      inlined_vector_internal::IteratorValueAdapter<TheA, Iterator>;
-  template <typename TheA>
-  using CopyValueAdapter = inlined_vector_internal::CopyValueAdapter<TheA>;
-  template <typename TheA>
-  using DefaultValueAdapter =
-      inlined_vector_internal::DefaultValueAdapter<TheA>;
-
-  template <typename Iterator>
-  using EnableIfAtLeastForwardIterator = absl::enable_if_t<
-      inlined_vector_internal::IsAtLeastForwardIterator<Iterator>::value, int>;
-  template <typename Iterator>
-  using DisableIfAtLeastForwardIterator = absl::enable_if_t<
-      !inlined_vector_internal::IsAtLeastForwardIterator<Iterator>::value, int>;
-
- public:
-  using allocator_type = A;
-  using value_type = inlined_vector_internal::ValueType<A>;
-  using pointer = inlined_vector_internal::Pointer<A>;
-  using const_pointer = inlined_vector_internal::ConstPointer<A>;
-  using size_type = inlined_vector_internal::SizeType<A>;
-  using difference_type = inlined_vector_internal::DifferenceType<A>;
-  using reference = inlined_vector_internal::Reference<A>;
-  using const_reference = inlined_vector_internal::ConstReference<A>;
-  using iterator = inlined_vector_internal::Iterator<A>;
-  using const_iterator = inlined_vector_internal::ConstIterator<A>;
-  using reverse_iterator = inlined_vector_internal::ReverseIterator<A>;
-  using const_reverse_iterator =
-      inlined_vector_internal::ConstReverseIterator<A>;
-
-  // ---------------------------------------------------------------------------
-  // InlinedVector Constructors and Destructor
-  // ---------------------------------------------------------------------------
-
-  // Creates an empty inlined vector with a value-initialized allocator.
-  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
-
-  // Creates an empty inlined vector with a copy of `allocator`.
-  explicit InlinedVector(const allocator_type& allocator) noexcept
-      : storage_(allocator) {}
-
-  // Creates an inlined vector with `n` copies of `value_type()`.
-  explicit InlinedVector(size_type n,
-                         const allocator_type& allocator = allocator_type())
-      : storage_(allocator) {
-    storage_.Initialize(DefaultValueAdapter<A>(), n);
-  }
-
-  // Creates an inlined vector with `n` copies of `v`.
-  InlinedVector(size_type n, const_reference v,
-                const allocator_type& allocator = allocator_type())
-      : storage_(allocator) {
-    storage_.Initialize(CopyValueAdapter<A>(std::addressof(v)), n);
-  }
-
-  // Creates an inlined vector with copies of the elements of `list`.
-  InlinedVector(std::initializer_list<value_type> list,
-                const allocator_type& allocator = allocator_type())
-      : InlinedVector(list.begin(), list.end(), allocator) {}
-
-  // Creates an inlined vector with elements constructed from the provided
-  // forward iterator range [`first`, `last`).
-  //
-  // NOTE: the `enable_if` prevents ambiguous interpretation between a call to
-  // this constructor with two integral arguments and a call to the above
-  // `InlinedVector(size_type, const_reference)` constructor.
-  template <typename ForwardIterator,
-            EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
-  InlinedVector(ForwardIterator first, ForwardIterator last,
-                const allocator_type& allocator = allocator_type())
-      : storage_(allocator) {
-    storage_.Initialize(IteratorValueAdapter<A, ForwardIterator>(first),
-                        static_cast<size_t>(std::distance(first, last)));
-  }
-
-  // Creates an inlined vector with elements constructed from the provided input
-  // iterator range [`first`, `last`).
-  template <typename InputIterator,
-            DisableIfAtLeastForwardIterator<InputIterator> = 0>
-  InlinedVector(InputIterator first, InputIterator last,
-                const allocator_type& allocator = allocator_type())
-      : storage_(allocator) {
-    std::copy(first, last, std::back_inserter(*this));
-  }
-
-  // Creates an inlined vector by copying the contents of `other` using
-  // `other`'s allocator.
-  InlinedVector(const InlinedVector& other)
-      : InlinedVector(other, other.storage_.GetAllocator()) {}
-
-  // Creates an inlined vector by copying the contents of `other` using the
-  // provided `allocator`.
-  InlinedVector(const InlinedVector& other, const allocator_type& allocator)
-      : storage_(allocator) {
-    if (other.empty()) {
-      // Empty; nothing to do.
-    } else if (IsMemcpyOk<A>::value && !other.storage_.GetIsAllocated()) {
-      // Memcpy-able and do not need allocation.
-      storage_.MemcpyFrom(other.storage_);
-    } else {
-      storage_.InitFrom(other.storage_);
-    }
-  }
-
-  // Creates an inlined vector by moving in the contents of `other` without
-  // allocating. If `other` contains allocated memory, the newly-created inlined
-  // vector will take ownership of that memory. However, if `other` does not
-  // contain allocated memory, the newly-created inlined vector will perform
-  // element-wise move construction of the contents of `other`.
-  //
-  // NOTE: since no allocation is performed for the inlined vector in either
-  // case, the `noexcept(...)` specification depends on whether moving the
-  // underlying objects can throw. It is assumed assumed that...
-  //  a) move constructors should only throw due to allocation failure.
-  //  b) if `value_type`'s move constructor allocates, it uses the same
-  //     allocation function as the inlined vector's allocator.
-  // Thus, the move constructor is non-throwing if the allocator is non-throwing
-  // or `value_type`'s move constructor is specified as `noexcept`.
-  InlinedVector(InlinedVector&& other) noexcept(
-      absl::allocator_is_nothrow<allocator_type>::value ||
-      std::is_nothrow_move_constructible<value_type>::value)
-      : storage_(other.storage_.GetAllocator()) {
-    if (IsMemcpyOk<A>::value) {
-      storage_.MemcpyFrom(other.storage_);
-
-      other.storage_.SetInlinedSize(0);
-    } else if (other.storage_.GetIsAllocated()) {
-      storage_.SetAllocation({other.storage_.GetAllocatedData(),
-                              other.storage_.GetAllocatedCapacity()});
-      storage_.SetAllocatedSize(other.storage_.GetSize());
-
-      other.storage_.SetInlinedSize(0);
-    } else {
-      IteratorValueAdapter<A, MoveIterator<A>> other_values(
-          MoveIterator<A>(other.storage_.GetInlinedData()));
-
-      inlined_vector_internal::ConstructElements<A>(
-          storage_.GetAllocator(), storage_.GetInlinedData(), other_values,
-          other.storage_.GetSize());
-
-      storage_.SetInlinedSize(other.storage_.GetSize());
-    }
-  }
-
-  // Creates an inlined vector by moving in the contents of `other` with a copy
-  // of `allocator`.
-  //
-  // NOTE: if `other`'s allocator is not equal to `allocator`, even if `other`
-  // contains allocated memory, this move constructor will still allocate. Since
-  // allocation is performed, this constructor can only be `noexcept` if the
-  // specified allocator is also `noexcept`.
-  InlinedVector(
-      InlinedVector&& other,
-      const allocator_type&
-          allocator) noexcept(absl::allocator_is_nothrow<allocator_type>::value)
-      : storage_(allocator) {
-    if (IsMemcpyOk<A>::value) {
-      storage_.MemcpyFrom(other.storage_);
-
-      other.storage_.SetInlinedSize(0);
-    } else if ((storage_.GetAllocator() == other.storage_.GetAllocator()) &&
-               other.storage_.GetIsAllocated()) {
-      storage_.SetAllocation({other.storage_.GetAllocatedData(),
-                              other.storage_.GetAllocatedCapacity()});
-      storage_.SetAllocatedSize(other.storage_.GetSize());
-
-      other.storage_.SetInlinedSize(0);
-    } else {
-      storage_.Initialize(IteratorValueAdapter<A, MoveIterator<A>>(
-                              MoveIterator<A>(other.data())),
-                          other.size());
-    }
-  }
-
-  ~InlinedVector() {}
-
-  // ---------------------------------------------------------------------------
-  // InlinedVector Member Accessors
-  // ---------------------------------------------------------------------------
-
-  // `InlinedVector::empty()`
-  //
-  // Returns whether the inlined vector contains no elements.
-  bool empty() const noexcept { return !size(); }
-
-  // `InlinedVector::size()`
-  //
-  // Returns the number of elements in the inlined vector.
-  size_type size() const noexcept { return storage_.GetSize(); }
-
-  // `InlinedVector::max_size()`
-  //
-  // Returns the maximum number of elements the inlined vector can hold.
-  size_type max_size() const noexcept {
-    // One bit of the size storage is used to indicate whether the inlined
-    // vector contains allocated memory. As a result, the maximum size that the
-    // inlined vector can express is half of the max for `size_type`.
-    return (std::numeric_limits<size_type>::max)() / 2;
-  }
-
-  // `InlinedVector::capacity()`
-  //
-  // Returns the number of elements that could be stored in the inlined vector
-  // without requiring a reallocation.
-  //
-  // NOTE: for most inlined vectors, `capacity()` should be equal to the
-  // template parameter `N`. For inlined vectors which exceed this capacity,
-  // they will no longer be inlined and `capacity()` will equal the capactity of
-  // the allocated memory.
-  size_type capacity() const noexcept {
-    return storage_.GetIsAllocated() ? storage_.GetAllocatedCapacity()
-                                     : storage_.GetInlinedCapacity();
-  }
-
-  // `InlinedVector::data()`
-  //
-  // Returns a `pointer` to the elements of the inlined vector. This pointer
-  // can be used to access and modify the contained elements.
-  //
-  // NOTE: only elements within [`data()`, `data() + size()`) are valid.
-  pointer data() noexcept {
-    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
-                                     : storage_.GetInlinedData();
-  }
-
-  // Overload of `InlinedVector::data()` that returns a `const_pointer` to the
-  // elements of the inlined vector. This pointer can be used to access but not
-  // modify the contained elements.
-  //
-  // NOTE: only elements within [`data()`, `data() + size()`) are valid.
-  const_pointer data() const noexcept {
-    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
-                                     : storage_.GetInlinedData();
-  }
-
-  // `InlinedVector::operator[](...)`
-  //
-  // Returns a `reference` to the `i`th element of the inlined vector.
-  reference operator[](size_type i) {
-    ABSL_HARDENING_ASSERT(i < size());
-    return data()[i];
-  }
-
-  // Overload of `InlinedVector::operator[](...)` that returns a
-  // `const_reference` to the `i`th element of the inlined vector.
-  const_reference operator[](size_type i) const {
-    ABSL_HARDENING_ASSERT(i < size());
-    return data()[i];
-  }
-
-  // `InlinedVector::at(...)`
-  //
-  // Returns a `reference` to the `i`th element of the inlined vector.
-  //
-  // NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,
-  // in both debug and non-debug builds, `std::out_of_range` will be thrown.
-  reference at(size_type i) {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange(
-          "`InlinedVector::at(size_type)` failed bounds check");
-    }
-    return data()[i];
-  }
-
-  // Overload of `InlinedVector::at(...)` that returns a `const_reference` to
-  // the `i`th element of the inlined vector.
-  //
-  // NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,
-  // in both debug and non-debug builds, `std::out_of_range` will be thrown.
-  const_reference at(size_type i) const {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange(
-          "`InlinedVector::at(size_type) const` failed bounds check");
-    }
-    return data()[i];
-  }
-
-  // `InlinedVector::front()`
-  //
-  // Returns a `reference` to the first element of the inlined vector.
-  reference front() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[0];
-  }
-
-  // Overload of `InlinedVector::front()` that returns a `const_reference` to
-  // the first element of the inlined vector.
-  const_reference front() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[0];
-  }
-
-  // `InlinedVector::back()`
-  //
-  // Returns a `reference` to the last element of the inlined vector.
-  reference back() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[size() - 1];
-  }
-
-  // Overload of `InlinedVector::back()` that returns a `const_reference` to the
-  // last element of the inlined vector.
-  const_reference back() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[size() - 1];
-  }
-
-  // `InlinedVector::begin()`
-  //
-  // Returns an `iterator` to the beginning of the inlined vector.
-  iterator begin() noexcept { return data(); }
-
-  // Overload of `InlinedVector::begin()` that returns a `const_iterator` to
-  // the beginning of the inlined vector.
-  const_iterator begin() const noexcept { return data(); }
-
-  // `InlinedVector::end()`
-  //
-  // Returns an `iterator` to the end of the inlined vector.
-  iterator end() noexcept { return data() + size(); }
-
-  // Overload of `InlinedVector::end()` that returns a `const_iterator` to the
-  // end of the inlined vector.
-  const_iterator end() const noexcept { return data() + size(); }
-
-  // `InlinedVector::cbegin()`
-  //
-  // Returns a `const_iterator` to the beginning of the inlined vector.
-  const_iterator cbegin() const noexcept { return begin(); }
-
-  // `InlinedVector::cend()`
-  //
-  // Returns a `const_iterator` to the end of the inlined vector.
-  const_iterator cend() const noexcept { return end(); }
-
-  // `InlinedVector::rbegin()`
-  //
-  // Returns a `reverse_iterator` from the end of the inlined vector.
-  reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
-
-  // Overload of `InlinedVector::rbegin()` that returns a
-  // `const_reverse_iterator` from the end of the inlined vector.
-  const_reverse_iterator rbegin() const noexcept {
-    return const_reverse_iterator(end());
-  }
-
-  // `InlinedVector::rend()`
-  //
-  // Returns a `reverse_iterator` from the beginning of the inlined vector.
-  reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
-
-  // Overload of `InlinedVector::rend()` that returns a `const_reverse_iterator`
-  // from the beginning of the inlined vector.
-  const_reverse_iterator rend() const noexcept {
-    return const_reverse_iterator(begin());
-  }
-
-  // `InlinedVector::crbegin()`
-  //
-  // Returns a `const_reverse_iterator` from the end of the inlined vector.
-  const_reverse_iterator crbegin() const noexcept { return rbegin(); }
-
-  // `InlinedVector::crend()`
-  //
-  // Returns a `const_reverse_iterator` from the beginning of the inlined
-  // vector.
-  const_reverse_iterator crend() const noexcept { return rend(); }
-
-  // `InlinedVector::get_allocator()`
-  //
-  // Returns a copy of the inlined vector's allocator.
-  allocator_type get_allocator() const { return storage_.GetAllocator(); }
-
-  // ---------------------------------------------------------------------------
-  // InlinedVector Member Mutators
-  // ---------------------------------------------------------------------------
-
-  // `InlinedVector::operator=(...)`
-  //
-  // Replaces the elements of the inlined vector with copies of the elements of
-  // `list`.
-  InlinedVector& operator=(std::initializer_list<value_type> list) {
-    assign(list.begin(), list.end());
-
-    return *this;
-  }
-
-  // Overload of `InlinedVector::operator=(...)` that replaces the elements of
-  // the inlined vector with copies of the elements of `other`.
-  InlinedVector& operator=(const InlinedVector& other) {
-    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
-      const_pointer other_data = other.data();
-      assign(other_data, other_data + other.size());
-    }
-
-    return *this;
-  }
-
-  // Overload of `InlinedVector::operator=(...)` that moves the elements of
-  // `other` into the inlined vector.
-  //
-  // NOTE: as a result of calling this overload, `other` is left in a valid but
-  // unspecified state.
-  InlinedVector& operator=(InlinedVector&& other) {
-    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
-      if (IsMemcpyOk<A>::value || other.storage_.GetIsAllocated()) {
-        inlined_vector_internal::DestroyAdapter<A>::DestroyElements(
-            storage_.GetAllocator(), data(), size());
-        storage_.DeallocateIfAllocated();
-        storage_.MemcpyFrom(other.storage_);
-
-        other.storage_.SetInlinedSize(0);
-      } else {
-        storage_.Assign(IteratorValueAdapter<A, MoveIterator<A>>(
-                            MoveIterator<A>(other.storage_.GetInlinedData())),
-                        other.size());
-      }
-    }
-
-    return *this;
-  }
-
-  // `InlinedVector::assign(...)`
-  //
-  // Replaces the contents of the inlined vector with `n` copies of `v`.
-  void assign(size_type n, const_reference v) {
-    storage_.Assign(CopyValueAdapter<A>(std::addressof(v)), n);
-  }
-
-  // Overload of `InlinedVector::assign(...)` that replaces the contents of the
-  // inlined vector with copies of the elements of `list`.
-  void assign(std::initializer_list<value_type> list) {
-    assign(list.begin(), list.end());
-  }
-
-  // Overload of `InlinedVector::assign(...)` to replace the contents of the
-  // inlined vector with the range [`first`, `last`).
-  //
-  // NOTE: this overload is for iterators that are "forward" category or better.
-  template <typename ForwardIterator,
-            EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
-  void assign(ForwardIterator first, ForwardIterator last) {
-    storage_.Assign(IteratorValueAdapter<A, ForwardIterator>(first),
-                    static_cast<size_t>(std::distance(first, last)));
-  }
-
-  // Overload of `InlinedVector::assign(...)` to replace the contents of the
-  // inlined vector with the range [`first`, `last`).
-  //
-  // NOTE: this overload is for iterators that are "input" category.
-  template <typename InputIterator,
-            DisableIfAtLeastForwardIterator<InputIterator> = 0>
-  void assign(InputIterator first, InputIterator last) {
-    size_type i = 0;
-    for (; i < size() && first != last; ++i, static_cast<void>(++first)) {
-      data()[i] = *first;
-    }
-
-    erase(data() + i, data() + size());
-    std::copy(first, last, std::back_inserter(*this));
-  }
-
-  // `InlinedVector::resize(...)`
-  //
-  // Resizes the inlined vector to contain `n` elements.
-  //
-  // NOTE: If `n` is smaller than `size()`, extra elements are destroyed. If `n`
-  // is larger than `size()`, new elements are value-initialized.
-  void resize(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= max_size());
-    storage_.Resize(DefaultValueAdapter<A>(), n);
-  }
-
-  // Overload of `InlinedVector::resize(...)` that resizes the inlined vector to
-  // contain `n` elements.
-  //
-  // NOTE: if `n` is smaller than `size()`, extra elements are destroyed. If `n`
-  // is larger than `size()`, new elements are copied-constructed from `v`.
-  void resize(size_type n, const_reference v) {
-    ABSL_HARDENING_ASSERT(n <= max_size());
-    storage_.Resize(CopyValueAdapter<A>(std::addressof(v)), n);
-  }
-
-  // `InlinedVector::insert(...)`
-  //
-  // Inserts a copy of `v` at `pos`, returning an `iterator` to the newly
-  // inserted element.
-  iterator insert(const_iterator pos, const_reference v) {
-    return emplace(pos, v);
-  }
-
-  // Overload of `InlinedVector::insert(...)` that inserts `v` at `pos` using
-  // move semantics, returning an `iterator` to the newly inserted element.
-  iterator insert(const_iterator pos, value_type&& v) {
-    return emplace(pos, std::move(v));
-  }
-
-  // Overload of `InlinedVector::insert(...)` that inserts `n` contiguous copies
-  // of `v` starting at `pos`, returning an `iterator` pointing to the first of
-  // the newly inserted elements.
-  iterator insert(const_iterator pos, size_type n, const_reference v) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
-
-    if (ABSL_PREDICT_TRUE(n != 0)) {
-      value_type dealias = v;
-      // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102329#c2
-      // It appears that GCC thinks that since `pos` is a const pointer and may
-      // point to uninitialized memory at this point, a warning should be
-      // issued. But `pos` is actually only used to compute an array index to
-      // write to.
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    // -----------------------------------------------------------------------------
+    // InlinedVector
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::InlinedVector` is designed to be a drop-in replacement for
+    // `std::vector` for use cases where the vector's size is sufficiently small
+    // that it can be inlined. If the inlined vector does grow beyond its estimated
+    // capacity, it will trigger an initial allocation on the heap, and will behave
+    // as a `std::vector`. The API of the `absl::InlinedVector` within this file is
+    // designed to cover the same API footprint as covered by `std::vector`.
+    template<typename T, size_t N, typename A = std::allocator<T>>
+    class InlinedVector
+    {
+        static_assert(N > 0, "`absl::InlinedVector` requires an inlined capacity.");
+
+        using Storage = inlined_vector_internal::Storage<T, N, A>;
+
+        template<typename TheA>
+        using AllocatorTraits = inlined_vector_internal::AllocatorTraits<TheA>;
+        template<typename TheA>
+        using MoveIterator = inlined_vector_internal::MoveIterator<TheA>;
+        template<typename TheA>
+        using IsMemcpyOk = inlined_vector_internal::IsMemcpyOk<TheA>;
+
+        template<typename TheA, typename Iterator>
+        using IteratorValueAdapter =
+            inlined_vector_internal::IteratorValueAdapter<TheA, Iterator>;
+        template<typename TheA>
+        using CopyValueAdapter = inlined_vector_internal::CopyValueAdapter<TheA>;
+        template<typename TheA>
+        using DefaultValueAdapter =
+            inlined_vector_internal::DefaultValueAdapter<TheA>;
+
+        template<typename Iterator>
+        using EnableIfAtLeastForwardIterator = absl::enable_if_t<
+            inlined_vector_internal::IsAtLeastForwardIterator<Iterator>::value,
+            int>;
+        template<typename Iterator>
+        using DisableIfAtLeastForwardIterator = absl::enable_if_t<
+            !inlined_vector_internal::IsAtLeastForwardIterator<Iterator>::value,
+            int>;
+
+    public:
+        using allocator_type = A;
+        using value_type = inlined_vector_internal::ValueType<A>;
+        using pointer = inlined_vector_internal::Pointer<A>;
+        using const_pointer = inlined_vector_internal::ConstPointer<A>;
+        using size_type = inlined_vector_internal::SizeType<A>;
+        using difference_type = inlined_vector_internal::DifferenceType<A>;
+        using reference = inlined_vector_internal::Reference<A>;
+        using const_reference = inlined_vector_internal::ConstReference<A>;
+        using iterator = inlined_vector_internal::Iterator<A>;
+        using const_iterator = inlined_vector_internal::ConstIterator<A>;
+        using reverse_iterator = inlined_vector_internal::ReverseIterator<A>;
+        using const_reverse_iterator =
+            inlined_vector_internal::ConstReverseIterator<A>;
+
+        // ---------------------------------------------------------------------------
+        // InlinedVector Constructors and Destructor
+        // ---------------------------------------------------------------------------
+
+        // Creates an empty inlined vector with a value-initialized allocator.
+        InlinedVector() noexcept(noexcept(allocator_type())) :
+            storage_()
+        {
+        }
+
+        // Creates an empty inlined vector with a copy of `allocator`.
+        explicit InlinedVector(const allocator_type& allocator) noexcept
+            :
+            storage_(allocator)
+        {
+        }
+
+        // Creates an inlined vector with `n` copies of `value_type()`.
+        explicit InlinedVector(size_type n, const allocator_type& allocator = allocator_type()) :
+            storage_(allocator)
+        {
+            storage_.Initialize(DefaultValueAdapter<A>(), n);
+        }
+
+        // Creates an inlined vector with `n` copies of `v`.
+        InlinedVector(size_type n, const_reference v, const allocator_type& allocator = allocator_type()) :
+            storage_(allocator)
+        {
+            storage_.Initialize(CopyValueAdapter<A>(std::addressof(v)), n);
+        }
+
+        // Creates an inlined vector with copies of the elements of `list`.
+        InlinedVector(std::initializer_list<value_type> list, const allocator_type& allocator = allocator_type()) :
+            InlinedVector(list.begin(), list.end(), allocator)
+        {
+        }
+
+        // Creates an inlined vector with elements constructed from the provided
+        // forward iterator range [`first`, `last`).
+        //
+        // NOTE: the `enable_if` prevents ambiguous interpretation between a call to
+        // this constructor with two integral arguments and a call to the above
+        // `InlinedVector(size_type, const_reference)` constructor.
+        template<typename ForwardIterator, EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
+        InlinedVector(ForwardIterator first, ForwardIterator last, const allocator_type& allocator = allocator_type()) :
+            storage_(allocator)
+        {
+            storage_.Initialize(IteratorValueAdapter<A, ForwardIterator>(first), static_cast<size_t>(std::distance(first, last)));
+        }
+
+        // Creates an inlined vector with elements constructed from the provided input
+        // iterator range [`first`, `last`).
+        template<typename InputIterator, DisableIfAtLeastForwardIterator<InputIterator> = 0>
+        InlinedVector(InputIterator first, InputIterator last, const allocator_type& allocator = allocator_type()) :
+            storage_(allocator)
+        {
+            std::copy(first, last, std::back_inserter(*this));
+        }
+
+        // Creates an inlined vector by copying the contents of `other` using
+        // `other`'s allocator.
+        InlinedVector(const InlinedVector& other) :
+            InlinedVector(other, other.storage_.GetAllocator())
+        {
+        }
+
+        // Creates an inlined vector by copying the contents of `other` using the
+        // provided `allocator`.
+        InlinedVector(const InlinedVector& other, const allocator_type& allocator) :
+            storage_(allocator)
+        {
+            if (other.empty())
+            {
+                // Empty; nothing to do.
+            }
+            else if (IsMemcpyOk<A>::value && !other.storage_.GetIsAllocated())
+            {
+                // Memcpy-able and do not need allocation.
+                storage_.MemcpyFrom(other.storage_);
+            }
+            else
+            {
+                storage_.InitFrom(other.storage_);
+            }
+        }
+
+        // Creates an inlined vector by moving in the contents of `other` without
+        // allocating. If `other` contains allocated memory, the newly-created inlined
+        // vector will take ownership of that memory. However, if `other` does not
+        // contain allocated memory, the newly-created inlined vector will perform
+        // element-wise move construction of the contents of `other`.
+        //
+        // NOTE: since no allocation is performed for the inlined vector in either
+        // case, the `noexcept(...)` specification depends on whether moving the
+        // underlying objects can throw. It is assumed assumed that...
+        //  a) move constructors should only throw due to allocation failure.
+        //  b) if `value_type`'s move constructor allocates, it uses the same
+        //     allocation function as the inlined vector's allocator.
+        // Thus, the move constructor is non-throwing if the allocator is non-throwing
+        // or `value_type`'s move constructor is specified as `noexcept`.
+        InlinedVector(InlinedVector&& other) noexcept(
+            absl::allocator_is_nothrow<allocator_type>::value ||
+            std::is_nothrow_move_constructible<value_type>::value
+        ) :
+            storage_(other.storage_.GetAllocator())
+        {
+            if (IsMemcpyOk<A>::value)
+            {
+                storage_.MemcpyFrom(other.storage_);
+
+                other.storage_.SetInlinedSize(0);
+            }
+            else if (other.storage_.GetIsAllocated())
+            {
+                storage_.SetAllocation({other.storage_.GetAllocatedData(), other.storage_.GetAllocatedCapacity()});
+                storage_.SetAllocatedSize(other.storage_.GetSize());
+
+                other.storage_.SetInlinedSize(0);
+            }
+            else
+            {
+                IteratorValueAdapter<A, MoveIterator<A>> other_values(
+                    MoveIterator<A>(other.storage_.GetInlinedData())
+                );
+
+                inlined_vector_internal::ConstructElements<A>(
+                    storage_.GetAllocator(), storage_.GetInlinedData(), other_values, other.storage_.GetSize()
+                );
+
+                storage_.SetInlinedSize(other.storage_.GetSize());
+            }
+        }
+
+        // Creates an inlined vector by moving in the contents of `other` with a copy
+        // of `allocator`.
+        //
+        // NOTE: if `other`'s allocator is not equal to `allocator`, even if `other`
+        // contains allocated memory, this move constructor will still allocate. Since
+        // allocation is performed, this constructor can only be `noexcept` if the
+        // specified allocator is also `noexcept`.
+        InlinedVector(
+            InlinedVector&& other,
+            const allocator_type&
+                allocator
+        ) noexcept(absl::allocator_is_nothrow<allocator_type>::value) :
+            storage_(allocator)
+        {
+            if (IsMemcpyOk<A>::value)
+            {
+                storage_.MemcpyFrom(other.storage_);
+
+                other.storage_.SetInlinedSize(0);
+            }
+            else if ((storage_.GetAllocator() == other.storage_.GetAllocator()) && other.storage_.GetIsAllocated())
+            {
+                storage_.SetAllocation({other.storage_.GetAllocatedData(), other.storage_.GetAllocatedCapacity()});
+                storage_.SetAllocatedSize(other.storage_.GetSize());
+
+                other.storage_.SetInlinedSize(0);
+            }
+            else
+            {
+                storage_.Initialize(IteratorValueAdapter<A, MoveIterator<A>>(MoveIterator<A>(other.data())), other.size());
+            }
+        }
+
+        ~InlinedVector()
+        {
+        }
+
+        // ---------------------------------------------------------------------------
+        // InlinedVector Member Accessors
+        // ---------------------------------------------------------------------------
+
+        // `InlinedVector::empty()`
+        //
+        // Returns whether the inlined vector contains no elements.
+        bool empty() const noexcept
+        {
+            return !size();
+        }
+
+        // `InlinedVector::size()`
+        //
+        // Returns the number of elements in the inlined vector.
+        size_type size() const noexcept
+        {
+            return storage_.GetSize();
+        }
+
+        // `InlinedVector::max_size()`
+        //
+        // Returns the maximum number of elements the inlined vector can hold.
+        size_type max_size() const noexcept
+        {
+            // One bit of the size storage is used to indicate whether the inlined
+            // vector contains allocated memory. As a result, the maximum size that the
+            // inlined vector can express is half of the max for `size_type`.
+            return (std::numeric_limits<size_type>::max)() / 2;
+        }
+
+        // `InlinedVector::capacity()`
+        //
+        // Returns the number of elements that could be stored in the inlined vector
+        // without requiring a reallocation.
+        //
+        // NOTE: for most inlined vectors, `capacity()` should be equal to the
+        // template parameter `N`. For inlined vectors which exceed this capacity,
+        // they will no longer be inlined and `capacity()` will equal the capactity of
+        // the allocated memory.
+        size_type capacity() const noexcept
+        {
+            return storage_.GetIsAllocated() ? storage_.GetAllocatedCapacity() : storage_.GetInlinedCapacity();
+        }
+
+        // `InlinedVector::data()`
+        //
+        // Returns a `pointer` to the elements of the inlined vector. This pointer
+        // can be used to access and modify the contained elements.
+        //
+        // NOTE: only elements within [`data()`, `data() + size()`) are valid.
+        pointer data() noexcept
+        {
+            return storage_.GetIsAllocated() ? storage_.GetAllocatedData() : storage_.GetInlinedData();
+        }
+
+        // Overload of `InlinedVector::data()` that returns a `const_pointer` to the
+        // elements of the inlined vector. This pointer can be used to access but not
+        // modify the contained elements.
+        //
+        // NOTE: only elements within [`data()`, `data() + size()`) are valid.
+        const_pointer data() const noexcept
+        {
+            return storage_.GetIsAllocated() ? storage_.GetAllocatedData() : storage_.GetInlinedData();
+        }
+
+        // `InlinedVector::operator[](...)`
+        //
+        // Returns a `reference` to the `i`th element of the inlined vector.
+        reference operator[](size_type i)
+        {
+            ABSL_HARDENING_ASSERT(i < size());
+            return data()[i];
+        }
+
+        // Overload of `InlinedVector::operator[](...)` that returns a
+        // `const_reference` to the `i`th element of the inlined vector.
+        const_reference operator[](size_type i) const
+        {
+            ABSL_HARDENING_ASSERT(i < size());
+            return data()[i];
+        }
+
+        // `InlinedVector::at(...)`
+        //
+        // Returns a `reference` to the `i`th element of the inlined vector.
+        //
+        // NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,
+        // in both debug and non-debug builds, `std::out_of_range` will be thrown.
+        reference at(size_type i)
+        {
+            if (ABSL_PREDICT_FALSE(i >= size()))
+            {
+                base_internal::ThrowStdOutOfRange(
+                    "`InlinedVector::at(size_type)` failed bounds check"
+                );
+            }
+            return data()[i];
+        }
+
+        // Overload of `InlinedVector::at(...)` that returns a `const_reference` to
+        // the `i`th element of the inlined vector.
+        //
+        // NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,
+        // in both debug and non-debug builds, `std::out_of_range` will be thrown.
+        const_reference at(size_type i) const
+        {
+            if (ABSL_PREDICT_FALSE(i >= size()))
+            {
+                base_internal::ThrowStdOutOfRange(
+                    "`InlinedVector::at(size_type) const` failed bounds check"
+                );
+            }
+            return data()[i];
+        }
+
+        // `InlinedVector::front()`
+        //
+        // Returns a `reference` to the first element of the inlined vector.
+        reference front()
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+            return data()[0];
+        }
+
+        // Overload of `InlinedVector::front()` that returns a `const_reference` to
+        // the first element of the inlined vector.
+        const_reference front() const
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+            return data()[0];
+        }
+
+        // `InlinedVector::back()`
+        //
+        // Returns a `reference` to the last element of the inlined vector.
+        reference back()
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+            return data()[size() - 1];
+        }
+
+        // Overload of `InlinedVector::back()` that returns a `const_reference` to the
+        // last element of the inlined vector.
+        const_reference back() const
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+            return data()[size() - 1];
+        }
+
+        // `InlinedVector::begin()`
+        //
+        // Returns an `iterator` to the beginning of the inlined vector.
+        iterator begin() noexcept
+        {
+            return data();
+        }
+
+        // Overload of `InlinedVector::begin()` that returns a `const_iterator` to
+        // the beginning of the inlined vector.
+        const_iterator begin() const noexcept
+        {
+            return data();
+        }
+
+        // `InlinedVector::end()`
+        //
+        // Returns an `iterator` to the end of the inlined vector.
+        iterator end() noexcept
+        {
+            return data() + size();
+        }
+
+        // Overload of `InlinedVector::end()` that returns a `const_iterator` to the
+        // end of the inlined vector.
+        const_iterator end() const noexcept
+        {
+            return data() + size();
+        }
+
+        // `InlinedVector::cbegin()`
+        //
+        // Returns a `const_iterator` to the beginning of the inlined vector.
+        const_iterator cbegin() const noexcept
+        {
+            return begin();
+        }
+
+        // `InlinedVector::cend()`
+        //
+        // Returns a `const_iterator` to the end of the inlined vector.
+        const_iterator cend() const noexcept
+        {
+            return end();
+        }
+
+        // `InlinedVector::rbegin()`
+        //
+        // Returns a `reverse_iterator` from the end of the inlined vector.
+        reverse_iterator rbegin() noexcept
+        {
+            return reverse_iterator(end());
+        }
+
+        // Overload of `InlinedVector::rbegin()` that returns a
+        // `const_reverse_iterator` from the end of the inlined vector.
+        const_reverse_iterator rbegin() const noexcept
+        {
+            return const_reverse_iterator(end());
+        }
+
+        // `InlinedVector::rend()`
+        //
+        // Returns a `reverse_iterator` from the beginning of the inlined vector.
+        reverse_iterator rend() noexcept
+        {
+            return reverse_iterator(begin());
+        }
+
+        // Overload of `InlinedVector::rend()` that returns a `const_reverse_iterator`
+        // from the beginning of the inlined vector.
+        const_reverse_iterator rend() const noexcept
+        {
+            return const_reverse_iterator(begin());
+        }
+
+        // `InlinedVector::crbegin()`
+        //
+        // Returns a `const_reverse_iterator` from the end of the inlined vector.
+        const_reverse_iterator crbegin() const noexcept
+        {
+            return rbegin();
+        }
+
+        // `InlinedVector::crend()`
+        //
+        // Returns a `const_reverse_iterator` from the beginning of the inlined
+        // vector.
+        const_reverse_iterator crend() const noexcept
+        {
+            return rend();
+        }
+
+        // `InlinedVector::get_allocator()`
+        //
+        // Returns a copy of the inlined vector's allocator.
+        allocator_type get_allocator() const
+        {
+            return storage_.GetAllocator();
+        }
+
+        // ---------------------------------------------------------------------------
+        // InlinedVector Member Mutators
+        // ---------------------------------------------------------------------------
+
+        // `InlinedVector::operator=(...)`
+        //
+        // Replaces the elements of the inlined vector with copies of the elements of
+        // `list`.
+        InlinedVector& operator=(std::initializer_list<value_type> list)
+        {
+            assign(list.begin(), list.end());
+
+            return *this;
+        }
+
+        // Overload of `InlinedVector::operator=(...)` that replaces the elements of
+        // the inlined vector with copies of the elements of `other`.
+        InlinedVector& operator=(const InlinedVector& other)
+        {
+            if (ABSL_PREDICT_TRUE(this != std::addressof(other)))
+            {
+                const_pointer other_data = other.data();
+                assign(other_data, other_data + other.size());
+            }
+
+            return *this;
+        }
+
+        // Overload of `InlinedVector::operator=(...)` that moves the elements of
+        // `other` into the inlined vector.
+        //
+        // NOTE: as a result of calling this overload, `other` is left in a valid but
+        // unspecified state.
+        InlinedVector& operator=(InlinedVector&& other)
+        {
+            if (ABSL_PREDICT_TRUE(this != std::addressof(other)))
+            {
+                if (IsMemcpyOk<A>::value || other.storage_.GetIsAllocated())
+                {
+                    inlined_vector_internal::DestroyAdapter<A>::DestroyElements(
+                        storage_.GetAllocator(), data(), size()
+                    );
+                    storage_.DeallocateIfAllocated();
+                    storage_.MemcpyFrom(other.storage_);
+
+                    other.storage_.SetInlinedSize(0);
+                }
+                else
+                {
+                    storage_.Assign(IteratorValueAdapter<A, MoveIterator<A>>(MoveIterator<A>(other.storage_.GetInlinedData())), other.size());
+                }
+            }
+
+            return *this;
+        }
+
+        // `InlinedVector::assign(...)`
+        //
+        // Replaces the contents of the inlined vector with `n` copies of `v`.
+        void assign(size_type n, const_reference v)
+        {
+            storage_.Assign(CopyValueAdapter<A>(std::addressof(v)), n);
+        }
+
+        // Overload of `InlinedVector::assign(...)` that replaces the contents of the
+        // inlined vector with copies of the elements of `list`.
+        void assign(std::initializer_list<value_type> list)
+        {
+            assign(list.begin(), list.end());
+        }
+
+        // Overload of `InlinedVector::assign(...)` to replace the contents of the
+        // inlined vector with the range [`first`, `last`).
+        //
+        // NOTE: this overload is for iterators that are "forward" category or better.
+        template<typename ForwardIterator, EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
+        void assign(ForwardIterator first, ForwardIterator last)
+        {
+            storage_.Assign(IteratorValueAdapter<A, ForwardIterator>(first), static_cast<size_t>(std::distance(first, last)));
+        }
+
+        // Overload of `InlinedVector::assign(...)` to replace the contents of the
+        // inlined vector with the range [`first`, `last`).
+        //
+        // NOTE: this overload is for iterators that are "input" category.
+        template<typename InputIterator, DisableIfAtLeastForwardIterator<InputIterator> = 0>
+        void assign(InputIterator first, InputIterator last)
+        {
+            size_type i = 0;
+            for (; i < size() && first != last; ++i, static_cast<void>(++first))
+            {
+                data()[i] = *first;
+            }
+
+            erase(data() + i, data() + size());
+            std::copy(first, last, std::back_inserter(*this));
+        }
+
+        // `InlinedVector::resize(...)`
+        //
+        // Resizes the inlined vector to contain `n` elements.
+        //
+        // NOTE: If `n` is smaller than `size()`, extra elements are destroyed. If `n`
+        // is larger than `size()`, new elements are value-initialized.
+        void resize(size_type n)
+        {
+            ABSL_HARDENING_ASSERT(n <= max_size());
+            storage_.Resize(DefaultValueAdapter<A>(), n);
+        }
+
+        // Overload of `InlinedVector::resize(...)` that resizes the inlined vector to
+        // contain `n` elements.
+        //
+        // NOTE: if `n` is smaller than `size()`, extra elements are destroyed. If `n`
+        // is larger than `size()`, new elements are copied-constructed from `v`.
+        void resize(size_type n, const_reference v)
+        {
+            ABSL_HARDENING_ASSERT(n <= max_size());
+            storage_.Resize(CopyValueAdapter<A>(std::addressof(v)), n);
+        }
+
+        // `InlinedVector::insert(...)`
+        //
+        // Inserts a copy of `v` at `pos`, returning an `iterator` to the newly
+        // inserted element.
+        iterator insert(const_iterator pos, const_reference v)
+        {
+            return emplace(pos, v);
+        }
+
+        // Overload of `InlinedVector::insert(...)` that inserts `v` at `pos` using
+        // move semantics, returning an `iterator` to the newly inserted element.
+        iterator insert(const_iterator pos, value_type&& v)
+        {
+            return emplace(pos, std::move(v));
+        }
+
+        // Overload of `InlinedVector::insert(...)` that inserts `n` contiguous copies
+        // of `v` starting at `pos`, returning an `iterator` pointing to the first of
+        // the newly inserted elements.
+        iterator insert(const_iterator pos, size_type n, const_reference v)
+        {
+            ABSL_HARDENING_ASSERT(pos >= begin());
+            ABSL_HARDENING_ASSERT(pos <= end());
+
+            if (ABSL_PREDICT_TRUE(n != 0))
+            {
+                value_type dealias = v;
+                // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102329#c2
+                // It appears that GCC thinks that since `pos` is a const pointer and may
+                // point to uninitialized memory at this point, a warning should be
+                // issued. But `pos` is actually only used to compute an array index to
+                // write to.
 #if !defined(__clang__) && defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #endif
-      return storage_.Insert(pos, CopyValueAdapter<A>(std::addressof(dealias)),
-                             n);
+                return storage_.Insert(pos, CopyValueAdapter<A>(std::addressof(dealias)), n);
 #if !defined(__clang__) && defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-    } else {
-      return const_cast<iterator>(pos);
+            }
+            else
+            {
+                return const_cast<iterator>(pos);
+            }
+        }
+
+        // Overload of `InlinedVector::insert(...)` that inserts copies of the
+        // elements of `list` starting at `pos`, returning an `iterator` pointing to
+        // the first of the newly inserted elements.
+        iterator insert(const_iterator pos, std::initializer_list<value_type> list)
+        {
+            return insert(pos, list.begin(), list.end());
+        }
+
+        // Overload of `InlinedVector::insert(...)` that inserts the range [`first`,
+        // `last`) starting at `pos`, returning an `iterator` pointing to the first
+        // of the newly inserted elements.
+        //
+        // NOTE: this overload is for iterators that are "forward" category or better.
+        template<typename ForwardIterator, EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
+        iterator insert(const_iterator pos, ForwardIterator first, ForwardIterator last)
+        {
+            ABSL_HARDENING_ASSERT(pos >= begin());
+            ABSL_HARDENING_ASSERT(pos <= end());
+
+            if (ABSL_PREDICT_TRUE(first != last))
+            {
+                return storage_.Insert(pos, IteratorValueAdapter<A, ForwardIterator>(first), std::distance(first, last));
+            }
+            else
+            {
+                return const_cast<iterator>(pos);
+            }
+        }
+
+        // Overload of `InlinedVector::insert(...)` that inserts the range [`first`,
+        // `last`) starting at `pos`, returning an `iterator` pointing to the first
+        // of the newly inserted elements.
+        //
+        // NOTE: this overload is for iterators that are "input" category.
+        template<typename InputIterator, DisableIfAtLeastForwardIterator<InputIterator> = 0>
+        iterator insert(const_iterator pos, InputIterator first, InputIterator last)
+        {
+            ABSL_HARDENING_ASSERT(pos >= begin());
+            ABSL_HARDENING_ASSERT(pos <= end());
+
+            size_type index = std::distance(cbegin(), pos);
+            for (size_type i = index; first != last; ++i, static_cast<void>(++first))
+            {
+                insert(data() + i, *first);
+            }
+
+            return iterator(data() + index);
+        }
+
+        // `InlinedVector::emplace(...)`
+        //
+        // Constructs and inserts an element using `args...` in the inlined vector at
+        // `pos`, returning an `iterator` pointing to the newly emplaced element.
+        template<typename... Args>
+        iterator emplace(const_iterator pos, Args&&... args)
+        {
+            ABSL_HARDENING_ASSERT(pos >= begin());
+            ABSL_HARDENING_ASSERT(pos <= end());
+
+            value_type dealias(std::forward<Args>(args)...);
+            return storage_.Insert(pos, IteratorValueAdapter<A, MoveIterator<A>>(MoveIterator<A>(std::addressof(dealias))), 1);
+        }
+
+        // `InlinedVector::emplace_back(...)`
+        //
+        // Constructs and inserts an element using `args...` in the inlined vector at
+        // `end()`, returning a `reference` to the newly emplaced element.
+        template<typename... Args>
+        reference emplace_back(Args&&... args)
+        {
+            return storage_.EmplaceBack(std::forward<Args>(args)...);
+        }
+
+        // `InlinedVector::push_back(...)`
+        //
+        // Inserts a copy of `v` in the inlined vector at `end()`.
+        void push_back(const_reference v)
+        {
+            static_cast<void>(emplace_back(v));
+        }
+
+        // Overload of `InlinedVector::push_back(...)` for inserting `v` at `end()`
+        // using move semantics.
+        void push_back(value_type&& v)
+        {
+            static_cast<void>(emplace_back(std::move(v)));
+        }
+
+        // `InlinedVector::pop_back()`
+        //
+        // Destroys the element at `back()`, reducing the size by `1`.
+        void pop_back() noexcept
+        {
+            ABSL_HARDENING_ASSERT(!empty());
+
+            AllocatorTraits<A>::destroy(storage_.GetAllocator(), data() + (size() - 1));
+            storage_.SubtractSize(1);
+        }
+
+        // `InlinedVector::erase(...)`
+        //
+        // Erases the element at `pos`, returning an `iterator` pointing to where the
+        // erased element was located.
+        //
+        // NOTE: may return `end()`, which is not dereferencable.
+        iterator erase(const_iterator pos)
+        {
+            ABSL_HARDENING_ASSERT(pos >= begin());
+            ABSL_HARDENING_ASSERT(pos < end());
+
+            return storage_.Erase(pos, pos + 1);
+        }
+
+        // Overload of `InlinedVector::erase(...)` that erases every element in the
+        // range [`from`, `to`), returning an `iterator` pointing to where the first
+        // erased element was located.
+        //
+        // NOTE: may return `end()`, which is not dereferencable.
+        iterator erase(const_iterator from, const_iterator to)
+        {
+            ABSL_HARDENING_ASSERT(from >= begin());
+            ABSL_HARDENING_ASSERT(from <= to);
+            ABSL_HARDENING_ASSERT(to <= end());
+
+            if (ABSL_PREDICT_TRUE(from != to))
+            {
+                return storage_.Erase(from, to);
+            }
+            else
+            {
+                return const_cast<iterator>(from);
+            }
+        }
+
+        // `InlinedVector::clear()`
+        //
+        // Destroys all elements in the inlined vector, setting the size to `0` and
+        // deallocating any held memory.
+        void clear() noexcept
+        {
+            inlined_vector_internal::DestroyAdapter<A>::DestroyElements(
+                storage_.GetAllocator(), data(), size()
+            );
+            storage_.DeallocateIfAllocated();
+
+            storage_.SetInlinedSize(0);
+        }
+
+        // `InlinedVector::reserve(...)`
+        //
+        // Ensures that there is enough room for at least `n` elements.
+        void reserve(size_type n)
+        {
+            storage_.Reserve(n);
+        }
+
+        // `InlinedVector::shrink_to_fit()`
+        //
+        // Attempts to reduce memory usage by moving elements to (or keeping elements
+        // in) the smallest available buffer sufficient for containing `size()`
+        // elements.
+        //
+        // If `size()` is sufficiently small, the elements will be moved into (or kept
+        // in) the inlined space.
+        void shrink_to_fit()
+        {
+            if (storage_.GetIsAllocated())
+            {
+                storage_.ShrinkToFit();
+            }
+        }
+
+        // `InlinedVector::swap(...)`
+        //
+        // Swaps the contents of the inlined vector with `other`.
+        void swap(InlinedVector& other)
+        {
+            if (ABSL_PREDICT_TRUE(this != std::addressof(other)))
+            {
+                storage_.Swap(std::addressof(other.storage_));
+            }
+        }
+
+    private:
+        template<typename H, typename TheT, size_t TheN, typename TheA>
+        friend H AbslHashValue(H h, const absl::InlinedVector<TheT, TheN, TheA>& a);
+
+        Storage storage_;
+    };
+
+    // -----------------------------------------------------------------------------
+    // InlinedVector Non-Member Functions
+    // -----------------------------------------------------------------------------
+
+    // `swap(...)`
+    //
+    // Swaps the contents of two inlined vectors.
+    template<typename T, size_t N, typename A>
+    void swap(absl::InlinedVector<T, N, A>& a, absl::InlinedVector<T, N, A>& b) noexcept(noexcept(a.swap(b)))
+    {
+        a.swap(b);
     }
-  }
-
-  // Overload of `InlinedVector::insert(...)` that inserts copies of the
-  // elements of `list` starting at `pos`, returning an `iterator` pointing to
-  // the first of the newly inserted elements.
-  iterator insert(const_iterator pos, std::initializer_list<value_type> list) {
-    return insert(pos, list.begin(), list.end());
-  }
-
-  // Overload of `InlinedVector::insert(...)` that inserts the range [`first`,
-  // `last`) starting at `pos`, returning an `iterator` pointing to the first
-  // of the newly inserted elements.
-  //
-  // NOTE: this overload is for iterators that are "forward" category or better.
-  template <typename ForwardIterator,
-            EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
-  iterator insert(const_iterator pos, ForwardIterator first,
-                  ForwardIterator last) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
-
-    if (ABSL_PREDICT_TRUE(first != last)) {
-      return storage_.Insert(pos,
-                             IteratorValueAdapter<A, ForwardIterator>(first),
-                             std::distance(first, last));
-    } else {
-      return const_cast<iterator>(pos);
-    }
-  }
-
-  // Overload of `InlinedVector::insert(...)` that inserts the range [`first`,
-  // `last`) starting at `pos`, returning an `iterator` pointing to the first
-  // of the newly inserted elements.
-  //
-  // NOTE: this overload is for iterators that are "input" category.
-  template <typename InputIterator,
-            DisableIfAtLeastForwardIterator<InputIterator> = 0>
-  iterator insert(const_iterator pos, InputIterator first, InputIterator last) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
-
-    size_type index = std::distance(cbegin(), pos);
-    for (size_type i = index; first != last; ++i, static_cast<void>(++first)) {
-      insert(data() + i, *first);
+
+    // `operator==(...)`
+    //
+    // Tests for value-equality of two inlined vectors.
+    template<typename T, size_t N, typename A>
+    bool operator==(const absl::InlinedVector<T, N, A>& a, const absl::InlinedVector<T, N, A>& b)
+    {
+        auto a_data = a.data();
+        auto b_data = b.data();
+        return absl::equal(a_data, a_data + a.size(), b_data, b_data + b.size());
     }
 
-    return iterator(data() + index);
-  }
-
-  // `InlinedVector::emplace(...)`
-  //
-  // Constructs and inserts an element using `args...` in the inlined vector at
-  // `pos`, returning an `iterator` pointing to the newly emplaced element.
-  template <typename... Args>
-  iterator emplace(const_iterator pos, Args&&... args) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
-
-    value_type dealias(std::forward<Args>(args)...);
-    return storage_.Insert(pos,
-                           IteratorValueAdapter<A, MoveIterator<A>>(
-                               MoveIterator<A>(std::addressof(dealias))),
-                           1);
-  }
-
-  // `InlinedVector::emplace_back(...)`
-  //
-  // Constructs and inserts an element using `args...` in the inlined vector at
-  // `end()`, returning a `reference` to the newly emplaced element.
-  template <typename... Args>
-  reference emplace_back(Args&&... args) {
-    return storage_.EmplaceBack(std::forward<Args>(args)...);
-  }
-
-  // `InlinedVector::push_back(...)`
-  //
-  // Inserts a copy of `v` in the inlined vector at `end()`.
-  void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
-
-  // Overload of `InlinedVector::push_back(...)` for inserting `v` at `end()`
-  // using move semantics.
-  void push_back(value_type&& v) {
-    static_cast<void>(emplace_back(std::move(v)));
-  }
-
-  // `InlinedVector::pop_back()`
-  //
-  // Destroys the element at `back()`, reducing the size by `1`.
-  void pop_back() noexcept {
-    ABSL_HARDENING_ASSERT(!empty());
-
-    AllocatorTraits<A>::destroy(storage_.GetAllocator(), data() + (size() - 1));
-    storage_.SubtractSize(1);
-  }
-
-  // `InlinedVector::erase(...)`
-  //
-  // Erases the element at `pos`, returning an `iterator` pointing to where the
-  // erased element was located.
-  //
-  // NOTE: may return `end()`, which is not dereferencable.
-  iterator erase(const_iterator pos) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos < end());
-
-    return storage_.Erase(pos, pos + 1);
-  }
-
-  // Overload of `InlinedVector::erase(...)` that erases every element in the
-  // range [`from`, `to`), returning an `iterator` pointing to where the first
-  // erased element was located.
-  //
-  // NOTE: may return `end()`, which is not dereferencable.
-  iterator erase(const_iterator from, const_iterator to) {
-    ABSL_HARDENING_ASSERT(from >= begin());
-    ABSL_HARDENING_ASSERT(from <= to);
-    ABSL_HARDENING_ASSERT(to <= end());
-
-    if (ABSL_PREDICT_TRUE(from != to)) {
-      return storage_.Erase(from, to);
-    } else {
-      return const_cast<iterator>(from);
+    // `operator!=(...)`
+    //
+    // Tests for value-inequality of two inlined vectors.
+    template<typename T, size_t N, typename A>
+    bool operator!=(const absl::InlinedVector<T, N, A>& a, const absl::InlinedVector<T, N, A>& b)
+    {
+        return !(a == b);
     }
-  }
-
-  // `InlinedVector::clear()`
-  //
-  // Destroys all elements in the inlined vector, setting the size to `0` and
-  // deallocating any held memory.
-  void clear() noexcept {
-    inlined_vector_internal::DestroyAdapter<A>::DestroyElements(
-        storage_.GetAllocator(), data(), size());
-    storage_.DeallocateIfAllocated();
-
-    storage_.SetInlinedSize(0);
-  }
-
-  // `InlinedVector::reserve(...)`
-  //
-  // Ensures that there is enough room for at least `n` elements.
-  void reserve(size_type n) { storage_.Reserve(n); }
-
-  // `InlinedVector::shrink_to_fit()`
-  //
-  // Attempts to reduce memory usage by moving elements to (or keeping elements
-  // in) the smallest available buffer sufficient for containing `size()`
-  // elements.
-  //
-  // If `size()` is sufficiently small, the elements will be moved into (or kept
-  // in) the inlined space.
-  void shrink_to_fit() {
-    if (storage_.GetIsAllocated()) {
-      storage_.ShrinkToFit();
+
+    // `operator<(...)`
+    //
+    // Tests whether the value of an inlined vector is less than the value of
+    // another inlined vector using a lexicographical comparison algorithm.
+    template<typename T, size_t N, typename A>
+    bool operator<(const absl::InlinedVector<T, N, A>& a, const absl::InlinedVector<T, N, A>& b)
+    {
+        auto a_data = a.data();
+        auto b_data = b.data();
+        return std::lexicographical_compare(a_data, a_data + a.size(), b_data, b_data + b.size());
     }
-  }
-
-  // `InlinedVector::swap(...)`
-  //
-  // Swaps the contents of the inlined vector with `other`.
-  void swap(InlinedVector& other) {
-    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
-      storage_.Swap(std::addressof(other.storage_));
+
+    // `operator>(...)`
+    //
+    // Tests whether the value of an inlined vector is greater than the value of
+    // another inlined vector using a lexicographical comparison algorithm.
+    template<typename T, size_t N, typename A>
+    bool operator>(const absl::InlinedVector<T, N, A>& a, const absl::InlinedVector<T, N, A>& b)
+    {
+        return b < a;
     }
-  }
 
- private:
-  template <typename H, typename TheT, size_t TheN, typename TheA>
-  friend H AbslHashValue(H h, const absl::InlinedVector<TheT, TheN, TheA>& a);
+    // `operator<=(...)`
+    //
+    // Tests whether the value of an inlined vector is less than or equal to the
+    // value of another inlined vector using a lexicographical comparison algorithm.
+    template<typename T, size_t N, typename A>
+    bool operator<=(const absl::InlinedVector<T, N, A>& a, const absl::InlinedVector<T, N, A>& b)
+    {
+        return !(b < a);
+    }
 
-  Storage storage_;
-};
+    // `operator>=(...)`
+    //
+    // Tests whether the value of an inlined vector is greater than or equal to the
+    // value of another inlined vector using a lexicographical comparison algorithm.
+    template<typename T, size_t N, typename A>
+    bool operator>=(const absl::InlinedVector<T, N, A>& a, const absl::InlinedVector<T, N, A>& b)
+    {
+        return !(a < b);
+    }
 
-// -----------------------------------------------------------------------------
-// InlinedVector Non-Member Functions
-// -----------------------------------------------------------------------------
+    // `AbslHashValue(...)`
+    //
+    // Provides `absl::Hash` support for `absl::InlinedVector`. It is uncommon to
+    // call this directly.
+    template<typename H, typename T, size_t N, typename A>
+    H AbslHashValue(H h, const absl::InlinedVector<T, N, A>& a)
+    {
+        auto size = a.size();
+        return H::combine(H::combine_contiguous(std::move(h), a.data(), size), size);
+    }
 
-// `swap(...)`
-//
-// Swaps the contents of two inlined vectors.
-template <typename T, size_t N, typename A>
-void swap(absl::InlinedVector<T, N, A>& a,
-          absl::InlinedVector<T, N, A>& b) noexcept(noexcept(a.swap(b))) {
-  a.swap(b);
-}
-
-// `operator==(...)`
-//
-// Tests for value-equality of two inlined vectors.
-template <typename T, size_t N, typename A>
-bool operator==(const absl::InlinedVector<T, N, A>& a,
-                const absl::InlinedVector<T, N, A>& b) {
-  auto a_data = a.data();
-  auto b_data = b.data();
-  return absl::equal(a_data, a_data + a.size(), b_data, b_data + b.size());
-}
-
-// `operator!=(...)`
-//
-// Tests for value-inequality of two inlined vectors.
-template <typename T, size_t N, typename A>
-bool operator!=(const absl::InlinedVector<T, N, A>& a,
-                const absl::InlinedVector<T, N, A>& b) {
-  return !(a == b);
-}
-
-// `operator<(...)`
-//
-// Tests whether the value of an inlined vector is less than the value of
-// another inlined vector using a lexicographical comparison algorithm.
-template <typename T, size_t N, typename A>
-bool operator<(const absl::InlinedVector<T, N, A>& a,
-               const absl::InlinedVector<T, N, A>& b) {
-  auto a_data = a.data();
-  auto b_data = b.data();
-  return std::lexicographical_compare(a_data, a_data + a.size(), b_data,
-                                      b_data + b.size());
-}
-
-// `operator>(...)`
-//
-// Tests whether the value of an inlined vector is greater than the value of
-// another inlined vector using a lexicographical comparison algorithm.
-template <typename T, size_t N, typename A>
-bool operator>(const absl::InlinedVector<T, N, A>& a,
-               const absl::InlinedVector<T, N, A>& b) {
-  return b < a;
-}
-
-// `operator<=(...)`
-//
-// Tests whether the value of an inlined vector is less than or equal to the
-// value of another inlined vector using a lexicographical comparison algorithm.
-template <typename T, size_t N, typename A>
-bool operator<=(const absl::InlinedVector<T, N, A>& a,
-                const absl::InlinedVector<T, N, A>& b) {
-  return !(b < a);
-}
-
-// `operator>=(...)`
-//
-// Tests whether the value of an inlined vector is greater than or equal to the
-// value of another inlined vector using a lexicographical comparison algorithm.
-template <typename T, size_t N, typename A>
-bool operator>=(const absl::InlinedVector<T, N, A>& a,
-                const absl::InlinedVector<T, N, A>& b) {
-  return !(a < b);
-}
-
-// `AbslHashValue(...)`
-//
-// Provides `absl::Hash` support for `absl::InlinedVector`. It is uncommon to
-// call this directly.
-template <typename H, typename T, size_t N, typename A>
-H AbslHashValue(H h, const absl::InlinedVector<T, N, A>& a) {
-  auto size = a.size();
-  return H::combine(H::combine_contiguous(std::move(h), a.data(), size), size);
-}
-
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INLINED_VECTOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/btree.h b/CAPI/cpp/grpc/include/absl/container/internal/btree.h
index 01f4e74..f6fc781 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/btree.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/btree.h
@@ -71,9 +71,11 @@
 #include "absl/types/compare.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
 
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
 #error ABSL_BTREE_ENABLE_GENERATIONS cannot be directly set
@@ -85,2770 +87,3333 @@ namespace container_internal {
 #define ABSL_BTREE_ENABLE_GENERATIONS
 #endif
 
-template <typename Compare, typename T, typename U>
-using compare_result_t = absl::result_of_t<const Compare(const T &, const U &)>;
-
-// A helper class that indicates if the Compare parameter is a key-compare-to
-// comparator.
-template <typename Compare, typename T>
-using btree_is_key_compare_to =
-    std::is_convertible<compare_result_t<Compare, T, T>, absl::weak_ordering>;
-
-struct StringBtreeDefaultLess {
-  using is_transparent = void;
-
-  StringBtreeDefaultLess() = default;
-
-  // Compatibility constructor.
-  StringBtreeDefaultLess(std::less<std::string>) {}  // NOLINT
-  StringBtreeDefaultLess(std::less<absl::string_view>) {}  // NOLINT
-
-  // Allow converting to std::less for use in key_comp()/value_comp().
-  explicit operator std::less<std::string>() const { return {}; }
-  explicit operator std::less<absl::string_view>() const { return {}; }
-  explicit operator std::less<absl::Cord>() const { return {}; }
-
-  absl::weak_ordering operator()(absl::string_view lhs,
-                                 absl::string_view rhs) const {
-    return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
-  }
-  StringBtreeDefaultLess(std::less<absl::Cord>) {}  // NOLINT
-  absl::weak_ordering operator()(const absl::Cord &lhs,
-                                 const absl::Cord &rhs) const {
-    return compare_internal::compare_result_as_ordering(lhs.Compare(rhs));
-  }
-  absl::weak_ordering operator()(const absl::Cord &lhs,
-                                 absl::string_view rhs) const {
-    return compare_internal::compare_result_as_ordering(lhs.Compare(rhs));
-  }
-  absl::weak_ordering operator()(absl::string_view lhs,
-                                 const absl::Cord &rhs) const {
-    return compare_internal::compare_result_as_ordering(-rhs.Compare(lhs));
-  }
-};
-
-struct StringBtreeDefaultGreater {
-  using is_transparent = void;
-
-  StringBtreeDefaultGreater() = default;
-
-  StringBtreeDefaultGreater(std::greater<std::string>) {}  // NOLINT
-  StringBtreeDefaultGreater(std::greater<absl::string_view>) {}  // NOLINT
-
-  // Allow converting to std::greater for use in key_comp()/value_comp().
-  explicit operator std::greater<std::string>() const { return {}; }
-  explicit operator std::greater<absl::string_view>() const { return {}; }
-  explicit operator std::greater<absl::Cord>() const { return {}; }
-
-  absl::weak_ordering operator()(absl::string_view lhs,
-                                 absl::string_view rhs) const {
-    return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
-  }
-  StringBtreeDefaultGreater(std::greater<absl::Cord>) {}  // NOLINT
-  absl::weak_ordering operator()(const absl::Cord &lhs,
-                                 const absl::Cord &rhs) const {
-    return compare_internal::compare_result_as_ordering(rhs.Compare(lhs));
-  }
-  absl::weak_ordering operator()(const absl::Cord &lhs,
-                                 absl::string_view rhs) const {
-    return compare_internal::compare_result_as_ordering(-lhs.Compare(rhs));
-  }
-  absl::weak_ordering operator()(absl::string_view lhs,
-                                 const absl::Cord &rhs) const {
-    return compare_internal::compare_result_as_ordering(rhs.Compare(lhs));
-  }
-};
-
-// See below comments for checked_compare.
-template <typename Compare, bool is_class = std::is_class<Compare>::value>
-struct checked_compare_base : Compare {
-  using Compare::Compare;
-  explicit checked_compare_base(Compare c) : Compare(std::move(c)) {}
-  const Compare &comp() const { return *this; }
-};
-template <typename Compare>
-struct checked_compare_base<Compare, false> {
-  explicit checked_compare_base(Compare c) : compare(std::move(c)) {}
-  const Compare &comp() const { return compare; }
-  Compare compare;
-};
-
-// A mechanism for opting out of checked_compare for use only in btree_test.cc.
-struct BtreeTestOnlyCheckedCompareOptOutBase {};
-
-// A helper class to adapt the specified comparator for two use cases:
-// (1) When using common Abseil string types with common comparison functors,
-// convert a boolean comparison into a three-way comparison that returns an
-// `absl::weak_ordering`. This helper class is specialized for
-// less<std::string>, greater<std::string>, less<string_view>,
-// greater<string_view>, less<absl::Cord>, and greater<absl::Cord>.
-// (2) Adapt the comparator to diagnose cases of non-strict-weak-ordering (see
-// https://en.cppreference.com/w/cpp/named_req/Compare) in debug mode. Whenever
-// a comparison is made, we will make assertions to verify that the comparator
-// is valid.
-template <typename Compare, typename Key>
-struct key_compare_adapter {
-  // Inherit from checked_compare_base to support function pointers and also
-  // keep empty-base-optimization (EBO) support for classes.
-  // Note: we can't use CompressedTuple here because that would interfere
-  // with the EBO for `btree::rightmost_`. `btree::rightmost_` is itself a
-  // CompressedTuple and nested `CompressedTuple`s don't support EBO.
-  // TODO(b/214288561): use CompressedTuple instead once it supports EBO for
-  // nested `CompressedTuple`s.
-  struct checked_compare : checked_compare_base<Compare> {
-   private:
-    using Base = typename checked_compare::checked_compare_base;
-    using Base::comp;
-
-    // If possible, returns whether `t` is equivalent to itself. We can only do
-    // this for `Key`s because we can't be sure that it's safe to call
-    // `comp()(k, k)` otherwise. Even if SFINAE allows it, there could be a
-    // compilation failure inside the implementation of the comparison operator.
-    bool is_self_equivalent(const Key &k) const {
-      // Note: this works for both boolean and three-way comparators.
-      return comp()(k, k) == 0;
-    }
-    // If we can't compare `t` with itself, returns true unconditionally.
-    template <typename T>
-    bool is_self_equivalent(const T &) const {
-      return true;
-    }
-
-   public:
-    using Base::Base;
-    checked_compare(Compare comp) : Base(std::move(comp)) {}  // NOLINT
-
-    // Allow converting to Compare for use in key_comp()/value_comp().
-    explicit operator Compare() const { return comp(); }
-
-    template <typename T, typename U,
-              absl::enable_if_t<
-                  std::is_same<bool, compare_result_t<Compare, T, U>>::value,
-                  int> = 0>
-    bool operator()(const T &lhs, const U &rhs) const {
-      // NOTE: if any of these assertions fail, then the comparator does not
-      // establish a strict-weak-ordering (see
-      // https://en.cppreference.com/w/cpp/named_req/Compare).
-      assert(is_self_equivalent(lhs));
-      assert(is_self_equivalent(rhs));
-      const bool lhs_comp_rhs = comp()(lhs, rhs);
-      assert(!lhs_comp_rhs || !comp()(rhs, lhs));
-      return lhs_comp_rhs;
-    }
-
-    template <
-        typename T, typename U,
-        absl::enable_if_t<std::is_convertible<compare_result_t<Compare, T, U>,
-                                              absl::weak_ordering>::value,
-                          int> = 0>
-    absl::weak_ordering operator()(const T &lhs, const U &rhs) const {
-      // NOTE: if any of these assertions fail, then the comparator does not
-      // establish a strict-weak-ordering (see
-      // https://en.cppreference.com/w/cpp/named_req/Compare).
-      assert(is_self_equivalent(lhs));
-      assert(is_self_equivalent(rhs));
-      const absl::weak_ordering lhs_comp_rhs = comp()(lhs, rhs);
+        template<typename Compare, typename T, typename U>
+        using compare_result_t = absl::result_of_t<const Compare(const T&, const U&)>;
+
+        // A helper class that indicates if the Compare parameter is a key-compare-to
+        // comparator.
+        template<typename Compare, typename T>
+        using btree_is_key_compare_to =
+            std::is_convertible<compare_result_t<Compare, T, T>, absl::weak_ordering>;
+
+        struct StringBtreeDefaultLess
+        {
+            using is_transparent = void;
+
+            StringBtreeDefaultLess() = default;
+
+            // Compatibility constructor.
+            StringBtreeDefaultLess(std::less<std::string>)
+            {
+            }  // NOLINT
+            StringBtreeDefaultLess(std::less<absl::string_view>)
+            {
+            }  // NOLINT
+
+            // Allow converting to std::less for use in key_comp()/value_comp().
+            explicit operator std::less<std::string>() const
+            {
+                return {};
+            }
+            explicit operator std::less<absl::string_view>() const
+            {
+                return {};
+            }
+            explicit operator std::less<absl::Cord>() const
+            {
+                return {};
+            }
+
+            absl::weak_ordering operator()(absl::string_view lhs, absl::string_view rhs) const
+            {
+                return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
+            }
+            StringBtreeDefaultLess(std::less<absl::Cord>)
+            {
+            }  // NOLINT
+            absl::weak_ordering operator()(const absl::Cord& lhs, const absl::Cord& rhs) const
+            {
+                return compare_internal::compare_result_as_ordering(lhs.Compare(rhs));
+            }
+            absl::weak_ordering operator()(const absl::Cord& lhs, absl::string_view rhs) const
+            {
+                return compare_internal::compare_result_as_ordering(lhs.Compare(rhs));
+            }
+            absl::weak_ordering operator()(absl::string_view lhs, const absl::Cord& rhs) const
+            {
+                return compare_internal::compare_result_as_ordering(-rhs.Compare(lhs));
+            }
+        };
+
+        struct StringBtreeDefaultGreater
+        {
+            using is_transparent = void;
+
+            StringBtreeDefaultGreater() = default;
+
+            StringBtreeDefaultGreater(std::greater<std::string>)
+            {
+            }  // NOLINT
+            StringBtreeDefaultGreater(std::greater<absl::string_view>)
+            {
+            }  // NOLINT
+
+            // Allow converting to std::greater for use in key_comp()/value_comp().
+            explicit operator std::greater<std::string>() const
+            {
+                return {};
+            }
+            explicit operator std::greater<absl::string_view>() const
+            {
+                return {};
+            }
+            explicit operator std::greater<absl::Cord>() const
+            {
+                return {};
+            }
+
+            absl::weak_ordering operator()(absl::string_view lhs, absl::string_view rhs) const
+            {
+                return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
+            }
+            StringBtreeDefaultGreater(std::greater<absl::Cord>)
+            {
+            }  // NOLINT
+            absl::weak_ordering operator()(const absl::Cord& lhs, const absl::Cord& rhs) const
+            {
+                return compare_internal::compare_result_as_ordering(rhs.Compare(lhs));
+            }
+            absl::weak_ordering operator()(const absl::Cord& lhs, absl::string_view rhs) const
+            {
+                return compare_internal::compare_result_as_ordering(-lhs.Compare(rhs));
+            }
+            absl::weak_ordering operator()(absl::string_view lhs, const absl::Cord& rhs) const
+            {
+                return compare_internal::compare_result_as_ordering(rhs.Compare(lhs));
+            }
+        };
+
+        // See below comments for checked_compare.
+        template<typename Compare, bool is_class = std::is_class<Compare>::value>
+        struct checked_compare_base : Compare
+        {
+            using Compare::Compare;
+            explicit checked_compare_base(Compare c) :
+                Compare(std::move(c))
+            {
+            }
+            const Compare& comp() const
+            {
+                return *this;
+            }
+        };
+        template<typename Compare>
+        struct checked_compare_base<Compare, false>
+        {
+            explicit checked_compare_base(Compare c) :
+                compare(std::move(c))
+            {
+            }
+            const Compare& comp() const
+            {
+                return compare;
+            }
+            Compare compare;
+        };
+
+        // A mechanism for opting out of checked_compare for use only in btree_test.cc.
+        struct BtreeTestOnlyCheckedCompareOptOutBase
+        {
+        };
+
+        // A helper class to adapt the specified comparator for two use cases:
+        // (1) When using common Abseil string types with common comparison functors,
+        // convert a boolean comparison into a three-way comparison that returns an
+        // `absl::weak_ordering`. This helper class is specialized for
+        // less<std::string>, greater<std::string>, less<string_view>,
+        // greater<string_view>, less<absl::Cord>, and greater<absl::Cord>.
+        // (2) Adapt the comparator to diagnose cases of non-strict-weak-ordering (see
+        // https://en.cppreference.com/w/cpp/named_req/Compare) in debug mode. Whenever
+        // a comparison is made, we will make assertions to verify that the comparator
+        // is valid.
+        template<typename Compare, typename Key>
+        struct key_compare_adapter
+        {
+            // Inherit from checked_compare_base to support function pointers and also
+            // keep empty-base-optimization (EBO) support for classes.
+            // Note: we can't use CompressedTuple here because that would interfere
+            // with the EBO for `btree::rightmost_`. `btree::rightmost_` is itself a
+            // CompressedTuple and nested `CompressedTuple`s don't support EBO.
+            // TODO(b/214288561): use CompressedTuple instead once it supports EBO for
+            // nested `CompressedTuple`s.
+            struct checked_compare : checked_compare_base<Compare>
+            {
+            private:
+                using Base = typename checked_compare::checked_compare_base;
+                using Base::comp;
+
+                // If possible, returns whether `t` is equivalent to itself. We can only do
+                // this for `Key`s because we can't be sure that it's safe to call
+                // `comp()(k, k)` otherwise. Even if SFINAE allows it, there could be a
+                // compilation failure inside the implementation of the comparison operator.
+                bool is_self_equivalent(const Key& k) const
+                {
+                    // Note: this works for both boolean and three-way comparators.
+                    return comp()(k, k) == 0;
+                }
+                // If we can't compare `t` with itself, returns true unconditionally.
+                template<typename T>
+                bool is_self_equivalent(const T&) const
+                {
+                    return true;
+                }
+
+            public:
+                using Base::Base;
+                checked_compare(Compare comp) :
+                    Base(std::move(comp))
+                {
+                }  // NOLINT
+
+                // Allow converting to Compare for use in key_comp()/value_comp().
+                explicit operator Compare() const
+                {
+                    return comp();
+                }
+
+                template<typename T, typename U, absl::enable_if_t<std::is_same<bool, compare_result_t<Compare, T, U>>::value, int> = 0>
+                bool operator()(const T& lhs, const U& rhs) const
+                {
+                    // NOTE: if any of these assertions fail, then the comparator does not
+                    // establish a strict-weak-ordering (see
+                    // https://en.cppreference.com/w/cpp/named_req/Compare).
+                    assert(is_self_equivalent(lhs));
+                    assert(is_self_equivalent(rhs));
+                    const bool lhs_comp_rhs = comp()(lhs, rhs);
+                    assert(!lhs_comp_rhs || !comp()(rhs, lhs));
+                    return lhs_comp_rhs;
+                }
+
+                template<
+                    typename T,
+                    typename U,
+                    absl::enable_if_t<std::is_convertible<compare_result_t<Compare, T, U>, absl::weak_ordering>::value, int> = 0>
+                absl::weak_ordering operator()(const T& lhs, const U& rhs) const
+                {
+                    // NOTE: if any of these assertions fail, then the comparator does not
+                    // establish a strict-weak-ordering (see
+                    // https://en.cppreference.com/w/cpp/named_req/Compare).
+                    assert(is_self_equivalent(lhs));
+                    assert(is_self_equivalent(rhs));
+                    const absl::weak_ordering lhs_comp_rhs = comp()(lhs, rhs);
 #ifndef NDEBUG
-      const absl::weak_ordering rhs_comp_lhs = comp()(rhs, lhs);
-      if (lhs_comp_rhs > 0) {
-        assert(rhs_comp_lhs < 0 && "lhs_comp_rhs > 0 -> rhs_comp_lhs < 0");
-      } else if (lhs_comp_rhs == 0) {
-        assert(rhs_comp_lhs == 0 && "lhs_comp_rhs == 0 -> rhs_comp_lhs == 0");
-      } else {
-        assert(rhs_comp_lhs > 0 && "lhs_comp_rhs < 0 -> rhs_comp_lhs > 0");
-      }
+                    const absl::weak_ordering rhs_comp_lhs = comp()(rhs, lhs);
+                    if (lhs_comp_rhs > 0)
+                    {
+                        assert(rhs_comp_lhs < 0 && "lhs_comp_rhs > 0 -> rhs_comp_lhs < 0");
+                    }
+                    else if (lhs_comp_rhs == 0)
+                    {
+                        assert(rhs_comp_lhs == 0 && "lhs_comp_rhs == 0 -> rhs_comp_lhs == 0");
+                    }
+                    else
+                    {
+                        assert(rhs_comp_lhs > 0 && "lhs_comp_rhs < 0 -> rhs_comp_lhs > 0");
+                    }
 #endif
-      return lhs_comp_rhs;
-    }
-  };
-  using type = absl::conditional_t<
-      std::is_base_of<BtreeTestOnlyCheckedCompareOptOutBase, Compare>::value,
-      Compare, checked_compare>;
-};
-
-template <>
-struct key_compare_adapter<std::less<std::string>, std::string> {
-  using type = StringBtreeDefaultLess;
-};
-
-template <>
-struct key_compare_adapter<std::greater<std::string>, std::string> {
-  using type = StringBtreeDefaultGreater;
-};
-
-template <>
-struct key_compare_adapter<std::less<absl::string_view>, absl::string_view> {
-  using type = StringBtreeDefaultLess;
-};
-
-template <>
-struct key_compare_adapter<std::greater<absl::string_view>, absl::string_view> {
-  using type = StringBtreeDefaultGreater;
-};
-
-template <>
-struct key_compare_adapter<std::less<absl::Cord>, absl::Cord> {
-  using type = StringBtreeDefaultLess;
-};
-
-template <>
-struct key_compare_adapter<std::greater<absl::Cord>, absl::Cord> {
-  using type = StringBtreeDefaultGreater;
-};
-
-// Detects an 'absl_btree_prefer_linear_node_search' member. This is
-// a protocol used as an opt-in or opt-out of linear search.
-//
-//  For example, this would be useful for key types that wrap an integer
-//  and define their own cheap operator<(). For example:
-//
-//   class K {
-//    public:
-//     using absl_btree_prefer_linear_node_search = std::true_type;
-//     ...
-//    private:
-//     friend bool operator<(K a, K b) { return a.k_ < b.k_; }
-//     int k_;
-//   };
-//
-//   btree_map<K, V> m;  // Uses linear search
-//
-// If T has the preference tag, then it has a preference.
-// Btree will use the tag's truth value.
-template <typename T, typename = void>
-struct has_linear_node_search_preference : std::false_type {};
-template <typename T, typename = void>
-struct prefers_linear_node_search : std::false_type {};
-template <typename T>
-struct has_linear_node_search_preference<
-    T, absl::void_t<typename T::absl_btree_prefer_linear_node_search>>
-    : std::true_type {};
-template <typename T>
-struct prefers_linear_node_search<
-    T, absl::void_t<typename T::absl_btree_prefer_linear_node_search>>
-    : T::absl_btree_prefer_linear_node_search {};
-
-template <typename Compare, typename Key>
-constexpr bool compare_has_valid_result_type() {
-  using compare_result_type = compare_result_t<Compare, Key, Key>;
-  return std::is_same<compare_result_type, bool>::value ||
-         std::is_convertible<compare_result_type, absl::weak_ordering>::value;
-}
-
-template <typename original_key_compare, typename value_type>
-class map_value_compare {
-  template <typename Params>
-  friend class btree;
-
-  // Note: this `protected` is part of the API of std::map::value_compare. See
-  // https://en.cppreference.com/w/cpp/container/map/value_compare.
- protected:
-  explicit map_value_compare(original_key_compare c) : comp(std::move(c)) {}
-
-  original_key_compare comp;  // NOLINT
-
- public:
-  auto operator()(const value_type &lhs, const value_type &rhs) const
-      -> decltype(comp(lhs.first, rhs.first)) {
-    return comp(lhs.first, rhs.first);
-  }
-};
-
-template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
-          bool IsMulti, bool IsMap, typename SlotPolicy>
-struct common_params {
-  using original_key_compare = Compare;
-
-  // If Compare is a common comparator for a string-like type, then we adapt it
-  // to use heterogeneous lookup and to be a key-compare-to comparator.
-  // We also adapt the comparator to diagnose invalid comparators in debug mode.
-  // We disable this when `Compare` is invalid in a way that will cause
-  // adaptation to fail (having invalid return type) so that we can give a
-  // better compilation failure in static_assert_validation. If we don't do
-  // this, then there will be cascading compilation failures that are confusing
-  // for users.
-  using key_compare =
-      absl::conditional_t<!compare_has_valid_result_type<Compare, Key>(),
-                          Compare,
-                          typename key_compare_adapter<Compare, Key>::type>;
-
-  static constexpr bool kIsKeyCompareStringAdapted =
-      std::is_same<key_compare, StringBtreeDefaultLess>::value ||
-      std::is_same<key_compare, StringBtreeDefaultGreater>::value;
-  static constexpr bool kIsKeyCompareTransparent =
-      IsTransparent<original_key_compare>::value ||
-      kIsKeyCompareStringAdapted;
-  static constexpr bool kEnableGenerations =
+                    return lhs_comp_rhs;
+                }
+            };
+            using type = absl::conditional_t<
+                std::is_base_of<BtreeTestOnlyCheckedCompareOptOutBase, Compare>::value,
+                Compare,
+                checked_compare>;
+        };
+
+        template<>
+        struct key_compare_adapter<std::less<std::string>, std::string>
+        {
+            using type = StringBtreeDefaultLess;
+        };
+
+        template<>
+        struct key_compare_adapter<std::greater<std::string>, std::string>
+        {
+            using type = StringBtreeDefaultGreater;
+        };
+
+        template<>
+        struct key_compare_adapter<std::less<absl::string_view>, absl::string_view>
+        {
+            using type = StringBtreeDefaultLess;
+        };
+
+        template<>
+        struct key_compare_adapter<std::greater<absl::string_view>, absl::string_view>
+        {
+            using type = StringBtreeDefaultGreater;
+        };
+
+        template<>
+        struct key_compare_adapter<std::less<absl::Cord>, absl::Cord>
+        {
+            using type = StringBtreeDefaultLess;
+        };
+
+        template<>
+        struct key_compare_adapter<std::greater<absl::Cord>, absl::Cord>
+        {
+            using type = StringBtreeDefaultGreater;
+        };
+
+        // Detects an 'absl_btree_prefer_linear_node_search' member. This is
+        // a protocol used as an opt-in or opt-out of linear search.
+        //
+        //  For example, this would be useful for key types that wrap an integer
+        //  and define their own cheap operator<(). For example:
+        //
+        //   class K {
+        //    public:
+        //     using absl_btree_prefer_linear_node_search = std::true_type;
+        //     ...
+        //    private:
+        //     friend bool operator<(K a, K b) { return a.k_ < b.k_; }
+        //     int k_;
+        //   };
+        //
+        //   btree_map<K, V> m;  // Uses linear search
+        //
+        // If T has the preference tag, then it has a preference.
+        // Btree will use the tag's truth value.
+        template<typename T, typename = void>
+        struct has_linear_node_search_preference : std::false_type
+        {
+        };
+        template<typename T, typename = void>
+        struct prefers_linear_node_search : std::false_type
+        {
+        };
+        template<typename T>
+        struct has_linear_node_search_preference<
+            T,
+            absl::void_t<typename T::absl_btree_prefer_linear_node_search>> : std::true_type
+        {
+        };
+        template<typename T>
+        struct prefers_linear_node_search<
+            T,
+            absl::void_t<typename T::absl_btree_prefer_linear_node_search>> : T::absl_btree_prefer_linear_node_search
+        {
+        };
+
+        template<typename Compare, typename Key>
+        constexpr bool compare_has_valid_result_type()
+        {
+            using compare_result_type = compare_result_t<Compare, Key, Key>;
+            return std::is_same<compare_result_type, bool>::value ||
+                   std::is_convertible<compare_result_type, absl::weak_ordering>::value;
+        }
+
+        template<typename original_key_compare, typename value_type>
+        class map_value_compare
+        {
+            template<typename Params>
+            friend class btree;
+
+            // Note: this `protected` is part of the API of std::map::value_compare. See
+            // https://en.cppreference.com/w/cpp/container/map/value_compare.
+
+        protected:
+            explicit map_value_compare(original_key_compare c) :
+                comp(std::move(c))
+            {
+            }
+
+            original_key_compare comp;  // NOLINT
+
+        public:
+            auto operator()(const value_type& lhs, const value_type& rhs) const
+                -> decltype(comp(lhs.first, rhs.first))
+            {
+                return comp(lhs.first, rhs.first);
+            }
+        };
+
+        template<typename Key, typename Compare, typename Alloc, int TargetNodeSize, bool IsMulti, bool IsMap, typename SlotPolicy>
+        struct common_params
+        {
+            using original_key_compare = Compare;
+
+            // If Compare is a common comparator for a string-like type, then we adapt it
+            // to use heterogeneous lookup and to be a key-compare-to comparator.
+            // We also adapt the comparator to diagnose invalid comparators in debug mode.
+            // We disable this when `Compare` is invalid in a way that will cause
+            // adaptation to fail (having invalid return type) so that we can give a
+            // better compilation failure in static_assert_validation. If we don't do
+            // this, then there will be cascading compilation failures that are confusing
+            // for users.
+            using key_compare =
+                absl::conditional_t<!compare_has_valid_result_type<Compare, Key>(), Compare, typename key_compare_adapter<Compare, Key>::type>;
+
+            static constexpr bool kIsKeyCompareStringAdapted =
+                std::is_same<key_compare, StringBtreeDefaultLess>::value ||
+                std::is_same<key_compare, StringBtreeDefaultGreater>::value;
+            static constexpr bool kIsKeyCompareTransparent =
+                IsTransparent<original_key_compare>::value ||
+                kIsKeyCompareStringAdapted;
+            static constexpr bool kEnableGenerations =
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-      true;
+                true;
 #else
-      false;
+                false;
 #endif
 
-  // A type which indicates if we have a key-compare-to functor or a plain old
-  // key-compare functor.
-  using is_key_compare_to = btree_is_key_compare_to<key_compare, Key>;
-
-  using allocator_type = Alloc;
-  using key_type = Key;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-
-  using slot_policy = SlotPolicy;
-  using slot_type = typename slot_policy::slot_type;
-  using value_type = typename slot_policy::value_type;
-  using init_type = typename slot_policy::mutable_value_type;
-  using pointer = value_type *;
-  using const_pointer = const value_type *;
-  using reference = value_type &;
-  using const_reference = const value_type &;
-
-  using value_compare =
-      absl::conditional_t<IsMap,
-                          map_value_compare<original_key_compare, value_type>,
-                          original_key_compare>;
-  using is_map_container = std::integral_constant<bool, IsMap>;
-
-  // For the given lookup key type, returns whether we can have multiple
-  // equivalent keys in the btree. If this is a multi-container, then we can.
-  // Otherwise, we can have multiple equivalent keys only if all of the
-  // following conditions are met:
-  // - The comparator is transparent.
-  // - The lookup key type is not the same as key_type.
-  // - The comparator is not a StringBtreeDefault{Less,Greater} comparator
-  //   that we know has the same equivalence classes for all lookup types.
-  template <typename LookupKey>
-  constexpr static bool can_have_multiple_equivalent_keys() {
-    return IsMulti || (IsTransparent<key_compare>::value &&
-                       !std::is_same<LookupKey, Key>::value &&
-                       !kIsKeyCompareStringAdapted);
-  }
-
-  enum {
-    kTargetNodeSize = TargetNodeSize,
-
-    // Upper bound for the available space for slots. This is largest for leaf
-    // nodes, which have overhead of at least a pointer + 4 bytes (for storing
-    // 3 field_types and an enum).
-    kNodeSlotSpace =
-        TargetNodeSize - /*minimum overhead=*/(sizeof(void *) + 4),
-  };
-
-  // This is an integral type large enough to hold as many slots as will fit a
-  // node of TargetNodeSize bytes.
-  using node_count_type =
-      absl::conditional_t<(kNodeSlotSpace / sizeof(slot_type) >
-                           (std::numeric_limits<uint8_t>::max)()),
-                          uint16_t, uint8_t>;  // NOLINT
-
-  // The following methods are necessary for passing this struct as PolicyTraits
-  // for node_handle and/or are used within btree.
-  static value_type &element(slot_type *slot) {
-    return slot_policy::element(slot);
-  }
-  static const value_type &element(const slot_type *slot) {
-    return slot_policy::element(slot);
-  }
-  template <class... Args>
-  static void construct(Alloc *alloc, slot_type *slot, Args &&... args) {
-    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
-  }
-  static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
-    slot_policy::construct(alloc, slot, other);
-  }
-  static void destroy(Alloc *alloc, slot_type *slot) {
-    slot_policy::destroy(alloc, slot);
-  }
-  static void transfer(Alloc *alloc, slot_type *new_slot, slot_type *old_slot) {
-    slot_policy::transfer(alloc, new_slot, old_slot);
-  }
-};
-
-// An adapter class that converts a lower-bound compare into an upper-bound
-// compare. Note: there is no need to make a version of this adapter specialized
-// for key-compare-to functors because the upper-bound (the first value greater
-// than the input) is never an exact match.
-template <typename Compare>
-struct upper_bound_adapter {
-  explicit upper_bound_adapter(const Compare &c) : comp(c) {}
-  template <typename K1, typename K2>
-  bool operator()(const K1 &a, const K2 &b) const {
-    // Returns true when a is not greater than b.
-    return !compare_internal::compare_result_as_less_than(comp(b, a));
-  }
-
- private:
-  Compare comp;
-};
-
-enum class MatchKind : uint8_t { kEq, kNe };
-
-template <typename V, bool IsCompareTo>
-struct SearchResult {
-  V value;
-  MatchKind match;
-
-  static constexpr bool HasMatch() { return true; }
-  bool IsEq() const { return match == MatchKind::kEq; }
-};
-
-// When we don't use CompareTo, `match` is not present.
-// This ensures that callers can't use it accidentally when it provides no
-// useful information.
-template <typename V>
-struct SearchResult<V, false> {
-  SearchResult() {}
-  explicit SearchResult(V v) : value(v) {}
-  SearchResult(V v, MatchKind /*match*/) : value(v) {}
-
-  V value;
-
-  static constexpr bool HasMatch() { return false; }
-  static constexpr bool IsEq() { return false; }
-};
-
-// A node in the btree holding. The same node type is used for both internal
-// and leaf nodes in the btree, though the nodes are allocated in such a way
-// that the children array is only valid in internal nodes.
-template <typename Params>
-class btree_node {
-  using is_key_compare_to = typename Params::is_key_compare_to;
-  using field_type = typename Params::node_count_type;
-  using allocator_type = typename Params::allocator_type;
-  using slot_type = typename Params::slot_type;
-  using original_key_compare = typename Params::original_key_compare;
-
- public:
-  using params_type = Params;
-  using key_type = typename Params::key_type;
-  using value_type = typename Params::value_type;
-  using pointer = typename Params::pointer;
-  using const_pointer = typename Params::const_pointer;
-  using reference = typename Params::reference;
-  using const_reference = typename Params::const_reference;
-  using key_compare = typename Params::key_compare;
-  using size_type = typename Params::size_type;
-  using difference_type = typename Params::difference_type;
-
-  // Btree decides whether to use linear node search as follows:
-  //   - If the comparator expresses a preference, use that.
-  //   - If the key expresses a preference, use that.
-  //   - If the key is arithmetic and the comparator is std::less or
-  //     std::greater, choose linear.
-  //   - Otherwise, choose binary.
-  // TODO(ezb): Might make sense to add condition(s) based on node-size.
-  using use_linear_search = std::integral_constant<
-      bool, has_linear_node_search_preference<original_key_compare>::value
-                ? prefers_linear_node_search<original_key_compare>::value
-            : has_linear_node_search_preference<key_type>::value
-                ? prefers_linear_node_search<key_type>::value
-                : std::is_arithmetic<key_type>::value &&
-                      (std::is_same<std::less<key_type>,
-                                    original_key_compare>::value ||
-                       std::is_same<std::greater<key_type>,
-                                    original_key_compare>::value)>;
-
-  // This class is organized by absl::container_internal::Layout as if it had
-  // the following structure:
-  //   // A pointer to the node's parent.
-  //   btree_node *parent;
-  //
-  //   // When ABSL_BTREE_ENABLE_GENERATIONS is defined, we also have a
-  //   // generation integer in order to check that when iterators are
-  //   // used, they haven't been invalidated already. Only the generation on
-  //   // the root is used, but we have one on each node because whether a node
-  //   // is root or not can change.
-  //   uint32_t generation;
-  //
-  //   // The position of the node in the node's parent.
-  //   field_type position;
-  //   // The index of the first populated value in `values`.
-  //   // TODO(ezb): right now, `start` is always 0. Update insertion/merge
-  //   // logic to allow for floating storage within nodes.
-  //   field_type start;
-  //   // The index after the last populated value in `values`. Currently, this
-  //   // is the same as the count of values.
-  //   field_type finish;
-  //   // The maximum number of values the node can hold. This is an integer in
-  //   // [1, kNodeSlots] for root leaf nodes, kNodeSlots for non-root leaf
-  //   // nodes, and kInternalNodeMaxCount (as a sentinel value) for internal
-  //   // nodes (even though there are still kNodeSlots values in the node).
-  //   // TODO(ezb): make max_count use only 4 bits and record log2(capacity)
-  //   // to free extra bits for is_root, etc.
-  //   field_type max_count;
-  //
-  //   // The array of values. The capacity is `max_count` for leaf nodes and
-  //   // kNodeSlots for internal nodes. Only the values in
-  //   // [start, finish) have been initialized and are valid.
-  //   slot_type values[max_count];
-  //
-  //   // The array of child pointers. The keys in children[i] are all less
-  //   // than key(i). The keys in children[i + 1] are all greater than key(i).
-  //   // There are 0 children for leaf nodes and kNodeSlots + 1 children for
-  //   // internal nodes.
-  //   btree_node *children[kNodeSlots + 1];
-  //
-  // This class is only constructed by EmptyNodeType. Normally, pointers to the
-  // layout above are allocated, cast to btree_node*, and de-allocated within
-  // the btree implementation.
-  ~btree_node() = default;
-  btree_node(btree_node const &) = delete;
-  btree_node &operator=(btree_node const &) = delete;
-
-  // Public for EmptyNodeType.
-  constexpr static size_type Alignment() {
-    static_assert(LeafLayout(1).Alignment() == InternalLayout().Alignment(),
-                  "Alignment of all nodes must be equal.");
-    return InternalLayout().Alignment();
-  }
-
- protected:
-  btree_node() = default;
-
- private:
-  using layout_type =
-      absl::container_internal::Layout<btree_node *, uint32_t, field_type,
-                                       slot_type, btree_node *>;
-  constexpr static size_type SizeWithNSlots(size_type n) {
-    return layout_type(
-               /*parent*/ 1,
-               /*generation*/ params_type::kEnableGenerations ? 1 : 0,
-               /*position, start, finish, max_count*/ 4,
-               /*slots*/ n,
-               /*children*/ 0)
-        .AllocSize();
-  }
-  // A lower bound for the overhead of fields other than slots in a leaf node.
-  constexpr static size_type MinimumOverhead() {
-    return SizeWithNSlots(1) - sizeof(slot_type);
-  }
-
-  // Compute how many values we can fit onto a leaf node taking into account
-  // padding.
-  constexpr static size_type NodeTargetSlots(const size_type begin,
-                                             const size_type end) {
-    return begin == end ? begin
-                        : SizeWithNSlots((begin + end) / 2 + 1) >
-                                  params_type::kTargetNodeSize
-                              ? NodeTargetSlots(begin, (begin + end) / 2)
-                              : NodeTargetSlots((begin + end) / 2 + 1, end);
-  }
-
-  enum {
-    kTargetNodeSize = params_type::kTargetNodeSize,
-    kNodeTargetSlots = NodeTargetSlots(0, params_type::kTargetNodeSize),
-
-    // We need a minimum of 3 slots per internal node in order to perform
-    // splitting (1 value for the two nodes involved in the split and 1 value
-    // propagated to the parent as the delimiter for the split). For performance
-    // reasons, we don't allow 3 slots-per-node due to bad worst case occupancy
-    // of 1/3 (for a node, not a b-tree).
-    kMinNodeSlots = 4,
-
-    kNodeSlots =
-        kNodeTargetSlots >= kMinNodeSlots ? kNodeTargetSlots : kMinNodeSlots,
-
-    // The node is internal (i.e. is not a leaf node) if and only if `max_count`
-    // has this value.
-    kInternalNodeMaxCount = 0,
-  };
-
-  // Leaves can have less than kNodeSlots values.
-  constexpr static layout_type LeafLayout(const int slot_count = kNodeSlots) {
-    return layout_type(
-        /*parent*/ 1,
-        /*generation*/ params_type::kEnableGenerations ? 1 : 0,
-        /*position, start, finish, max_count*/ 4,
-        /*slots*/ slot_count,
-        /*children*/ 0);
-  }
-  constexpr static layout_type InternalLayout() {
-    return layout_type(
-        /*parent*/ 1,
-        /*generation*/ params_type::kEnableGenerations ? 1 : 0,
-        /*position, start, finish, max_count*/ 4,
-        /*slots*/ kNodeSlots,
-        /*children*/ kNodeSlots + 1);
-  }
-  constexpr static size_type LeafSize(const int slot_count = kNodeSlots) {
-    return LeafLayout(slot_count).AllocSize();
-  }
-  constexpr static size_type InternalSize() {
-    return InternalLayout().AllocSize();
-  }
-
-  // N is the index of the type in the Layout definition.
-  // ElementType<N> is the Nth type in the Layout definition.
-  template <size_type N>
-  inline typename layout_type::template ElementType<N> *GetField() {
-    // We assert that we don't read from values that aren't there.
-    assert(N < 4 || is_internal());
-    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
-  }
-  template <size_type N>
-  inline const typename layout_type::template ElementType<N> *GetField() const {
-    assert(N < 4 || is_internal());
-    return InternalLayout().template Pointer<N>(
-        reinterpret_cast<const char *>(this));
-  }
-  void set_parent(btree_node *p) { *GetField<0>() = p; }
-  field_type &mutable_finish() { return GetField<2>()[2]; }
-  slot_type *slot(int i) { return &GetField<3>()[i]; }
-  slot_type *start_slot() { return slot(start()); }
-  slot_type *finish_slot() { return slot(finish()); }
-  const slot_type *slot(int i) const { return &GetField<3>()[i]; }
-  void set_position(field_type v) { GetField<2>()[0] = v; }
-  void set_start(field_type v) { GetField<2>()[1] = v; }
-  void set_finish(field_type v) { GetField<2>()[2] = v; }
-  // This method is only called by the node init methods.
-  void set_max_count(field_type v) { GetField<2>()[3] = v; }
-
- public:
-  // Whether this is a leaf node or not. This value doesn't change after the
-  // node is created.
-  bool is_leaf() const { return GetField<2>()[3] != kInternalNodeMaxCount; }
-  // Whether this is an internal node or not. This value doesn't change after
-  // the node is created.
-  bool is_internal() const { return !is_leaf(); }
-
-  // Getter for the position of this node in its parent.
-  field_type position() const { return GetField<2>()[0]; }
-
-  // Getter for the offset of the first value in the `values` array.
-  field_type start() const {
-    // TODO(ezb): when floating storage is implemented, return GetField<2>()[1];
-    assert(GetField<2>()[1] == 0);
-    return 0;
-  }
-
-  // Getter for the offset after the last value in the `values` array.
-  field_type finish() const { return GetField<2>()[2]; }
-
-  // Getters for the number of values stored in this node.
-  field_type count() const {
-    assert(finish() >= start());
-    return finish() - start();
-  }
-  field_type max_count() const {
-    // Internal nodes have max_count==kInternalNodeMaxCount.
-    // Leaf nodes have max_count in [1, kNodeSlots].
-    const field_type max_count = GetField<2>()[3];
-    return max_count == field_type{kInternalNodeMaxCount}
-               ? field_type{kNodeSlots}
-               : max_count;
-  }
-
-  // Getter for the parent of this node.
-  btree_node *parent() const { return *GetField<0>(); }
-  // Getter for whether the node is the root of the tree. The parent of the
-  // root of the tree is the leftmost node in the tree which is guaranteed to
-  // be a leaf.
-  bool is_root() const { return parent()->is_leaf(); }
-  void make_root() {
-    assert(parent()->is_root());
-    set_generation(parent()->generation());
-    set_parent(parent()->parent());
-  }
-
-  // Gets the root node's generation integer, which is the one used by the tree.
-  uint32_t *get_root_generation() const {
-    assert(params_type::kEnableGenerations);
-    const btree_node *curr = this;
-    for (; !curr->is_root(); curr = curr->parent()) continue;
-    return const_cast<uint32_t *>(&curr->GetField<1>()[0]);
-  }
-
-  // Returns the generation for iterator validation.
-  uint32_t generation() const {
-    return params_type::kEnableGenerations ? *get_root_generation() : 0;
-  }
-  // Updates generation. Should only be called on a root node or during node
-  // initialization.
-  void set_generation(uint32_t generation) {
-    if (params_type::kEnableGenerations) GetField<1>()[0] = generation;
-  }
-  // Updates the generation. We do this whenever the node is mutated.
-  void next_generation() {
-    if (params_type::kEnableGenerations) ++*get_root_generation();
-  }
-
-  // Getters for the key/value at position i in the node.
-  const key_type &key(int i) const { return params_type::key(slot(i)); }
-  reference value(int i) { return params_type::element(slot(i)); }
-  const_reference value(int i) const { return params_type::element(slot(i)); }
-
-  // Getters/setter for the child at position i in the node.
-  btree_node *child(int i) const { return GetField<4>()[i]; }
-  btree_node *start_child() const { return child(start()); }
-  btree_node *&mutable_child(int i) { return GetField<4>()[i]; }
-  void clear_child(int i) {
-    absl::container_internal::SanitizerPoisonObject(&mutable_child(i));
-  }
-  void set_child(int i, btree_node *c) {
-    absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i));
-    mutable_child(i) = c;
-    c->set_position(i);
-  }
-  void init_child(int i, btree_node *c) {
-    set_child(i, c);
-    c->set_parent(this);
-  }
-
-  // Returns the position of the first value whose key is not less than k.
-  template <typename K>
-  SearchResult<int, is_key_compare_to::value> lower_bound(
-      const K &k, const key_compare &comp) const {
-    return use_linear_search::value ? linear_search(k, comp)
-                                    : binary_search(k, comp);
-  }
-  // Returns the position of the first value whose key is greater than k.
-  template <typename K>
-  int upper_bound(const K &k, const key_compare &comp) const {
-    auto upper_compare = upper_bound_adapter<key_compare>(comp);
-    return use_linear_search::value ? linear_search(k, upper_compare).value
-                                    : binary_search(k, upper_compare).value;
-  }
-
-  template <typename K, typename Compare>
-  SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
-  linear_search(const K &k, const Compare &comp) const {
-    return linear_search_impl(k, start(), finish(), comp,
-                              btree_is_key_compare_to<Compare, key_type>());
-  }
-
-  template <typename K, typename Compare>
-  SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
-  binary_search(const K &k, const Compare &comp) const {
-    return binary_search_impl(k, start(), finish(), comp,
-                              btree_is_key_compare_to<Compare, key_type>());
-  }
-
-  // Returns the position of the first value whose key is not less than k using
-  // linear search performed using plain compare.
-  template <typename K, typename Compare>
-  SearchResult<int, false> linear_search_impl(
-      const K &k, int s, const int e, const Compare &comp,
-      std::false_type /* IsCompareTo */) const {
-    while (s < e) {
-      if (!comp(key(s), k)) {
-        break;
-      }
-      ++s;
-    }
-    return SearchResult<int, false>{s};
-  }
-
-  // Returns the position of the first value whose key is not less than k using
-  // linear search performed using compare-to.
-  template <typename K, typename Compare>
-  SearchResult<int, true> linear_search_impl(
-      const K &k, int s, const int e, const Compare &comp,
-      std::true_type /* IsCompareTo */) const {
-    while (s < e) {
-      const absl::weak_ordering c = comp(key(s), k);
-      if (c == 0) {
-        return {s, MatchKind::kEq};
-      } else if (c > 0) {
-        break;
-      }
-      ++s;
-    }
-    return {s, MatchKind::kNe};
-  }
-
-  // Returns the position of the first value whose key is not less than k using
-  // binary search performed using plain compare.
-  template <typename K, typename Compare>
-  SearchResult<int, false> binary_search_impl(
-      const K &k, int s, int e, const Compare &comp,
-      std::false_type /* IsCompareTo */) const {
-    while (s != e) {
-      const int mid = (s + e) >> 1;
-      if (comp(key(mid), k)) {
-        s = mid + 1;
-      } else {
-        e = mid;
-      }
-    }
-    return SearchResult<int, false>{s};
-  }
-
-  // Returns the position of the first value whose key is not less than k using
-  // binary search performed using compare-to.
-  template <typename K, typename CompareTo>
-  SearchResult<int, true> binary_search_impl(
-      const K &k, int s, int e, const CompareTo &comp,
-      std::true_type /* IsCompareTo */) const {
-    if (params_type::template can_have_multiple_equivalent_keys<K>()) {
-      MatchKind exact_match = MatchKind::kNe;
-      while (s != e) {
-        const int mid = (s + e) >> 1;
-        const absl::weak_ordering c = comp(key(mid), k);
-        if (c < 0) {
-          s = mid + 1;
-        } else {
-          e = mid;
-          if (c == 0) {
-            // Need to return the first value whose key is not less than k,
-            // which requires continuing the binary search if there could be
-            // multiple equivalent keys.
-            exact_match = MatchKind::kEq;
-          }
-        }
-      }
-      return {s, exact_match};
-    } else {  // Can't have multiple equivalent keys.
-      while (s != e) {
-        const int mid = (s + e) >> 1;
-        const absl::weak_ordering c = comp(key(mid), k);
-        if (c < 0) {
-          s = mid + 1;
-        } else if (c > 0) {
-          e = mid;
-        } else {
-          return {mid, MatchKind::kEq};
-        }
-      }
-      return {s, MatchKind::kNe};
-    }
-  }
-
-  // Emplaces a value at position i, shifting all existing values and
-  // children at positions >= i to the right by 1.
-  template <typename... Args>
-  void emplace_value(size_type i, allocator_type *alloc, Args &&... args);
-
-  // Removes the values at positions [i, i + to_erase), shifting all existing
-  // values and children after that range to the left by to_erase. Clears all
-  // children between [i, i + to_erase).
-  void remove_values(field_type i, field_type to_erase, allocator_type *alloc);
-
-  // Rebalances a node with its right sibling.
-  void rebalance_right_to_left(int to_move, btree_node *right,
-                               allocator_type *alloc);
-  void rebalance_left_to_right(int to_move, btree_node *right,
-                               allocator_type *alloc);
-
-  // Splits a node, moving a portion of the node's values to its right sibling.
-  void split(int insert_position, btree_node *dest, allocator_type *alloc);
-
-  // Merges a node with its right sibling, moving all of the values and the
-  // delimiting key in the parent node onto itself, and deleting the src node.
-  void merge(btree_node *src, allocator_type *alloc);
-
-  // Node allocation/deletion routines.
-  void init_leaf(int max_count, btree_node *parent) {
-    set_generation(0);
-    set_parent(parent);
-    set_position(0);
-    set_start(0);
-    set_finish(0);
-    set_max_count(max_count);
-    absl::container_internal::SanitizerPoisonMemoryRegion(
-        start_slot(), max_count * sizeof(slot_type));
-  }
-  void init_internal(btree_node *parent) {
-    init_leaf(kNodeSlots, parent);
-    // Set `max_count` to a sentinel value to indicate that this node is
-    // internal.
-    set_max_count(kInternalNodeMaxCount);
-    absl::container_internal::SanitizerPoisonMemoryRegion(
-        &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *));
-  }
-
-  static void deallocate(const size_type size, btree_node *node,
-                         allocator_type *alloc) {
-    absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
-  }
-
-  // Deletes a node and all of its children.
-  static void clear_and_delete(btree_node *node, allocator_type *alloc);
-
- private:
-  template <typename... Args>
-  void value_init(const field_type i, allocator_type *alloc, Args &&... args) {
-    next_generation();
-    absl::container_internal::SanitizerUnpoisonObject(slot(i));
-    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
-  }
-  void value_destroy(const field_type i, allocator_type *alloc) {
-    next_generation();
-    params_type::destroy(alloc, slot(i));
-    absl::container_internal::SanitizerPoisonObject(slot(i));
-  }
-  void value_destroy_n(const field_type i, const field_type n,
-                       allocator_type *alloc) {
-    next_generation();
-    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) {
-      params_type::destroy(alloc, s);
-      absl::container_internal::SanitizerPoisonObject(s);
-    }
-  }
-
-  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) {
-    absl::container_internal::SanitizerUnpoisonObject(dest);
-    params_type::transfer(alloc, dest, src);
-    absl::container_internal::SanitizerPoisonObject(src);
-  }
-
-  // Transfers value from slot `src_i` in `src_node` to slot `dest_i` in `this`.
-  void transfer(const size_type dest_i, const size_type src_i,
-                btree_node *src_node, allocator_type *alloc) {
-    next_generation();
-    transfer(slot(dest_i), src_node->slot(src_i), alloc);
-  }
-
-  // Transfers `n` values starting at value `src_i` in `src_node` into the
-  // values starting at value `dest_i` in `this`.
-  void transfer_n(const size_type n, const size_type dest_i,
-                  const size_type src_i, btree_node *src_node,
-                  allocator_type *alloc) {
-    next_generation();
-    for (slot_type *src = src_node->slot(src_i), *end = src + n,
-                   *dest = slot(dest_i);
-         src != end; ++src, ++dest) {
-      transfer(dest, src, alloc);
-    }
-  }
-
-  // Same as above, except that we start at the end and work our way to the
-  // beginning.
-  void transfer_n_backward(const size_type n, const size_type dest_i,
-                           const size_type src_i, btree_node *src_node,
-                           allocator_type *alloc) {
-    next_generation();
-    for (slot_type *src = src_node->slot(src_i + n - 1), *end = src - n,
-                   *dest = slot(dest_i + n - 1);
-         src != end; --src, --dest) {
-      transfer(dest, src, alloc);
-    }
-  }
-
-  template <typename P>
-  friend class btree;
-  template <typename N, typename R, typename P>
-  friend class btree_iterator;
-  friend class BtreeNodePeer;
-  friend struct btree_access;
-};
-
-template <typename Node, typename Reference, typename Pointer>
-class btree_iterator {
-  using key_type = typename Node::key_type;
-  using size_type = typename Node::size_type;
-  using params_type = typename Node::params_type;
-  using is_map_container = typename params_type::is_map_container;
-
-  using node_type = Node;
-  using normal_node = typename std::remove_const<Node>::type;
-  using const_node = const Node;
-  using normal_pointer = typename params_type::pointer;
-  using normal_reference = typename params_type::reference;
-  using const_pointer = typename params_type::const_pointer;
-  using const_reference = typename params_type::const_reference;
-  using slot_type = typename params_type::slot_type;
-
-  using iterator =
-     btree_iterator<normal_node, normal_reference, normal_pointer>;
-  using const_iterator =
-      btree_iterator<const_node, const_reference, const_pointer>;
-
- public:
-  // These aliases are public for std::iterator_traits.
-  using difference_type = typename Node::difference_type;
-  using value_type = typename params_type::value_type;
-  using pointer = Pointer;
-  using reference = Reference;
-  using iterator_category = std::bidirectional_iterator_tag;
-
-  btree_iterator() : btree_iterator(nullptr, -1) {}
-  explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
-  btree_iterator(Node *n, int p) : node_(n), position_(p) {
+            // A type which indicates if we have a key-compare-to functor or a plain old
+            // key-compare functor.
+            using is_key_compare_to = btree_is_key_compare_to<key_compare, Key>;
+
+            using allocator_type = Alloc;
+            using key_type = Key;
+            using size_type = size_t;
+            using difference_type = ptrdiff_t;
+
+            using slot_policy = SlotPolicy;
+            using slot_type = typename slot_policy::slot_type;
+            using value_type = typename slot_policy::value_type;
+            using init_type = typename slot_policy::mutable_value_type;
+            using pointer = value_type*;
+            using const_pointer = const value_type*;
+            using reference = value_type&;
+            using const_reference = const value_type&;
+
+            using value_compare =
+                absl::conditional_t<IsMap, map_value_compare<original_key_compare, value_type>, original_key_compare>;
+            using is_map_container = std::integral_constant<bool, IsMap>;
+
+            // For the given lookup key type, returns whether we can have multiple
+            // equivalent keys in the btree. If this is a multi-container, then we can.
+            // Otherwise, we can have multiple equivalent keys only if all of the
+            // following conditions are met:
+            // - The comparator is transparent.
+            // - The lookup key type is not the same as key_type.
+            // - The comparator is not a StringBtreeDefault{Less,Greater} comparator
+            //   that we know has the same equivalence classes for all lookup types.
+            template<typename LookupKey>
+            constexpr static bool can_have_multiple_equivalent_keys()
+            {
+                return IsMulti || (IsTransparent<key_compare>::value &&
+                                   !std::is_same<LookupKey, Key>::value &&
+                                   !kIsKeyCompareStringAdapted);
+            }
+
+            enum
+            {
+                kTargetNodeSize = TargetNodeSize,
+
+                // Upper bound for the available space for slots. This is largest for leaf
+                // nodes, which have overhead of at least a pointer + 4 bytes (for storing
+                // 3 field_types and an enum).
+                kNodeSlotSpace =
+                    TargetNodeSize - /*minimum overhead=*/(sizeof(void*) + 4),
+            };
+
+            // This is an integral type large enough to hold as many slots as will fit a
+            // node of TargetNodeSize bytes.
+            using node_count_type =
+                absl::conditional_t<(kNodeSlotSpace / sizeof(slot_type) > (std::numeric_limits<uint8_t>::max)()), uint16_t, uint8_t>;  // NOLINT
+
+            // The following methods are necessary for passing this struct as PolicyTraits
+            // for node_handle and/or are used within btree.
+            static value_type& element(slot_type* slot)
+            {
+                return slot_policy::element(slot);
+            }
+            static const value_type& element(const slot_type* slot)
+            {
+                return slot_policy::element(slot);
+            }
+            template<class... Args>
+            static void construct(Alloc* alloc, slot_type* slot, Args&&... args)
+            {
+                slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
+            }
+            static void construct(Alloc* alloc, slot_type* slot, slot_type* other)
+            {
+                slot_policy::construct(alloc, slot, other);
+            }
+            static void destroy(Alloc* alloc, slot_type* slot)
+            {
+                slot_policy::destroy(alloc, slot);
+            }
+            static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot)
+            {
+                slot_policy::transfer(alloc, new_slot, old_slot);
+            }
+        };
+
+        // An adapter class that converts a lower-bound compare into an upper-bound
+        // compare. Note: there is no need to make a version of this adapter specialized
+        // for key-compare-to functors because the upper-bound (the first value greater
+        // than the input) is never an exact match.
+        template<typename Compare>
+        struct upper_bound_adapter
+        {
+            explicit upper_bound_adapter(const Compare& c) :
+                comp(c)
+            {
+            }
+            template<typename K1, typename K2>
+            bool operator()(const K1& a, const K2& b) const
+            {
+                // Returns true when a is not greater than b.
+                return !compare_internal::compare_result_as_less_than(comp(b, a));
+            }
+
+        private:
+            Compare comp;
+        };
+
+        enum class MatchKind : uint8_t
+        {
+            kEq,
+            kNe
+        };
+
+        template<typename V, bool IsCompareTo>
+        struct SearchResult
+        {
+            V value;
+            MatchKind match;
+
+            static constexpr bool HasMatch()
+            {
+                return true;
+            }
+            bool IsEq() const
+            {
+                return match == MatchKind::kEq;
+            }
+        };
+
+        // When we don't use CompareTo, `match` is not present.
+        // This ensures that callers can't use it accidentally when it provides no
+        // useful information.
+        template<typename V>
+        struct SearchResult<V, false>
+        {
+            SearchResult()
+            {
+            }
+            explicit SearchResult(V v) :
+                value(v)
+            {
+            }
+            SearchResult(V v, MatchKind /*match*/) :
+                value(v)
+            {
+            }
+
+            V value;
+
+            static constexpr bool HasMatch()
+            {
+                return false;
+            }
+            static constexpr bool IsEq()
+            {
+                return false;
+            }
+        };
+
+        // A node in the btree holding. The same node type is used for both internal
+        // and leaf nodes in the btree, though the nodes are allocated in such a way
+        // that the children array is only valid in internal nodes.
+        template<typename Params>
+        class btree_node
+        {
+            using is_key_compare_to = typename Params::is_key_compare_to;
+            using field_type = typename Params::node_count_type;
+            using allocator_type = typename Params::allocator_type;
+            using slot_type = typename Params::slot_type;
+            using original_key_compare = typename Params::original_key_compare;
+
+        public:
+            using params_type = Params;
+            using key_type = typename Params::key_type;
+            using value_type = typename Params::value_type;
+            using pointer = typename Params::pointer;
+            using const_pointer = typename Params::const_pointer;
+            using reference = typename Params::reference;
+            using const_reference = typename Params::const_reference;
+            using key_compare = typename Params::key_compare;
+            using size_type = typename Params::size_type;
+            using difference_type = typename Params::difference_type;
+
+            // Btree decides whether to use linear node search as follows:
+            //   - If the comparator expresses a preference, use that.
+            //   - If the key expresses a preference, use that.
+            //   - If the key is arithmetic and the comparator is std::less or
+            //     std::greater, choose linear.
+            //   - Otherwise, choose binary.
+            // TODO(ezb): Might make sense to add condition(s) based on node-size.
+            using use_linear_search = std::integral_constant<
+                bool,
+                has_linear_node_search_preference<original_key_compare>::value ? prefers_linear_node_search<original_key_compare>::value : has_linear_node_search_preference<key_type>::value ? prefers_linear_node_search<key_type>::value :
+                                                                                                                                                                                                std::is_arithmetic<key_type>::value && (std::is_same<std::less<key_type>, original_key_compare>::value || std::is_same<std::greater<key_type>, original_key_compare>::value)>;
+
+            // This class is organized by absl::container_internal::Layout as if it had
+            // the following structure:
+            //   // A pointer to the node's parent.
+            //   btree_node *parent;
+            //
+            //   // When ABSL_BTREE_ENABLE_GENERATIONS is defined, we also have a
+            //   // generation integer in order to check that when iterators are
+            //   // used, they haven't been invalidated already. Only the generation on
+            //   // the root is used, but we have one on each node because whether a node
+            //   // is root or not can change.
+            //   uint32_t generation;
+            //
+            //   // The position of the node in the node's parent.
+            //   field_type position;
+            //   // The index of the first populated value in `values`.
+            //   // TODO(ezb): right now, `start` is always 0. Update insertion/merge
+            //   // logic to allow for floating storage within nodes.
+            //   field_type start;
+            //   // The index after the last populated value in `values`. Currently, this
+            //   // is the same as the count of values.
+            //   field_type finish;
+            //   // The maximum number of values the node can hold. This is an integer in
+            //   // [1, kNodeSlots] for root leaf nodes, kNodeSlots for non-root leaf
+            //   // nodes, and kInternalNodeMaxCount (as a sentinel value) for internal
+            //   // nodes (even though there are still kNodeSlots values in the node).
+            //   // TODO(ezb): make max_count use only 4 bits and record log2(capacity)
+            //   // to free extra bits for is_root, etc.
+            //   field_type max_count;
+            //
+            //   // The array of values. The capacity is `max_count` for leaf nodes and
+            //   // kNodeSlots for internal nodes. Only the values in
+            //   // [start, finish) have been initialized and are valid.
+            //   slot_type values[max_count];
+            //
+            //   // The array of child pointers. The keys in children[i] are all less
+            //   // than key(i). The keys in children[i + 1] are all greater than key(i).
+            //   // There are 0 children for leaf nodes and kNodeSlots + 1 children for
+            //   // internal nodes.
+            //   btree_node *children[kNodeSlots + 1];
+            //
+            // This class is only constructed by EmptyNodeType. Normally, pointers to the
+            // layout above are allocated, cast to btree_node*, and de-allocated within
+            // the btree implementation.
+            ~btree_node() = default;
+            btree_node(btree_node const&) = delete;
+            btree_node& operator=(btree_node const&) = delete;
+
+            // Public for EmptyNodeType.
+            constexpr static size_type Alignment()
+            {
+                static_assert(LeafLayout(1).Alignment() == InternalLayout().Alignment(), "Alignment of all nodes must be equal.");
+                return InternalLayout().Alignment();
+            }
+
+        protected:
+            btree_node() = default;
+
+        private:
+            using layout_type =
+                absl::container_internal::Layout<btree_node*, uint32_t, field_type, slot_type, btree_node*>;
+            constexpr static size_type SizeWithNSlots(size_type n)
+            {
+                return layout_type(
+                           /*parent*/ 1,
+                           /*generation*/ params_type::kEnableGenerations ? 1 : 0,
+                           /*position, start, finish, max_count*/ 4,
+                           /*slots*/ n,
+                           /*children*/ 0
+                )
+                    .AllocSize();
+            }
+            // A lower bound for the overhead of fields other than slots in a leaf node.
+            constexpr static size_type MinimumOverhead()
+            {
+                return SizeWithNSlots(1) - sizeof(slot_type);
+            }
+
+            // Compute how many values we can fit onto a leaf node taking into account
+            // padding.
+            constexpr static size_type NodeTargetSlots(const size_type begin, const size_type end)
+            {
+                return begin == end ? begin : SizeWithNSlots((begin + end) / 2 + 1) > params_type::kTargetNodeSize ? NodeTargetSlots(begin, (begin + end) / 2) :
+                                                                                                                     NodeTargetSlots((begin + end) / 2 + 1, end);
+            }
+
+            enum
+            {
+                kTargetNodeSize = params_type::kTargetNodeSize,
+                kNodeTargetSlots = NodeTargetSlots(0, params_type::kTargetNodeSize),
+
+                // We need a minimum of 3 slots per internal node in order to perform
+                // splitting (1 value for the two nodes involved in the split and 1 value
+                // propagated to the parent as the delimiter for the split). For performance
+                // reasons, we don't allow 3 slots-per-node due to bad worst case occupancy
+                // of 1/3 (for a node, not a b-tree).
+                kMinNodeSlots = 4,
+
+                kNodeSlots =
+                    kNodeTargetSlots >= kMinNodeSlots ? kNodeTargetSlots : kMinNodeSlots,
+
+                // The node is internal (i.e. is not a leaf node) if and only if `max_count`
+                // has this value.
+                kInternalNodeMaxCount = 0,
+            };
+
+            // Leaves can have less than kNodeSlots values.
+            constexpr static layout_type LeafLayout(const int slot_count = kNodeSlots)
+            {
+                return layout_type(
+                    /*parent*/ 1,
+                    /*generation*/ params_type::kEnableGenerations ? 1 : 0,
+                    /*position, start, finish, max_count*/ 4,
+                    /*slots*/ slot_count,
+                    /*children*/ 0
+                );
+            }
+            constexpr static layout_type InternalLayout()
+            {
+                return layout_type(
+                    /*parent*/ 1,
+                    /*generation*/ params_type::kEnableGenerations ? 1 : 0,
+                    /*position, start, finish, max_count*/ 4,
+                    /*slots*/ kNodeSlots,
+                    /*children*/ kNodeSlots + 1
+                );
+            }
+            constexpr static size_type LeafSize(const int slot_count = kNodeSlots)
+            {
+                return LeafLayout(slot_count).AllocSize();
+            }
+            constexpr static size_type InternalSize()
+            {
+                return InternalLayout().AllocSize();
+            }
+
+            // N is the index of the type in the Layout definition.
+            // ElementType<N> is the Nth type in the Layout definition.
+            template<size_type N>
+            inline typename layout_type::template ElementType<N>* GetField()
+            {
+                // We assert that we don't read from values that aren't there.
+                assert(N < 4 || is_internal());
+                return InternalLayout().template Pointer<N>(reinterpret_cast<char*>(this));
+            }
+            template<size_type N>
+            inline const typename layout_type::template ElementType<N>* GetField() const
+            {
+                assert(N < 4 || is_internal());
+                return InternalLayout().template Pointer<N>(
+                    reinterpret_cast<const char*>(this)
+                );
+            }
+            void set_parent(btree_node* p)
+            {
+                *GetField<0>() = p;
+            }
+            field_type& mutable_finish()
+            {
+                return GetField<2>()[2];
+            }
+            slot_type* slot(int i)
+            {
+                return &GetField<3>()[i];
+            }
+            slot_type* start_slot()
+            {
+                return slot(start());
+            }
+            slot_type* finish_slot()
+            {
+                return slot(finish());
+            }
+            const slot_type* slot(int i) const
+            {
+                return &GetField<3>()[i];
+            }
+            void set_position(field_type v)
+            {
+                GetField<2>()[0] = v;
+            }
+            void set_start(field_type v)
+            {
+                GetField<2>()[1] = v;
+            }
+            void set_finish(field_type v)
+            {
+                GetField<2>()[2] = v;
+            }
+            // This method is only called by the node init methods.
+            void set_max_count(field_type v)
+            {
+                GetField<2>()[3] = v;
+            }
+
+        public:
+            // Whether this is a leaf node or not. This value doesn't change after the
+            // node is created.
+            bool is_leaf() const
+            {
+                return GetField<2>()[3] != kInternalNodeMaxCount;
+            }
+            // Whether this is an internal node or not. This value doesn't change after
+            // the node is created.
+            bool is_internal() const
+            {
+                return !is_leaf();
+            }
+
+            // Getter for the position of this node in its parent.
+            field_type position() const
+            {
+                return GetField<2>()[0];
+            }
+
+            // Getter for the offset of the first value in the `values` array.
+            field_type start() const
+            {
+                // TODO(ezb): when floating storage is implemented, return GetField<2>()[1];
+                assert(GetField<2>()[1] == 0);
+                return 0;
+            }
+
+            // Getter for the offset after the last value in the `values` array.
+            field_type finish() const
+            {
+                return GetField<2>()[2];
+            }
+
+            // Getters for the number of values stored in this node.
+            field_type count() const
+            {
+                assert(finish() >= start());
+                return finish() - start();
+            }
+            field_type max_count() const
+            {
+                // Internal nodes have max_count==kInternalNodeMaxCount.
+                // Leaf nodes have max_count in [1, kNodeSlots].
+                const field_type max_count = GetField<2>()[3];
+                return max_count == field_type{kInternalNodeMaxCount} ? field_type{kNodeSlots} : max_count;
+            }
+
+            // Getter for the parent of this node.
+            btree_node* parent() const
+            {
+                return *GetField<0>();
+            }
+            // Getter for whether the node is the root of the tree. The parent of the
+            // root of the tree is the leftmost node in the tree which is guaranteed to
+            // be a leaf.
+            bool is_root() const
+            {
+                return parent()->is_leaf();
+            }
+            void make_root()
+            {
+                assert(parent()->is_root());
+                set_generation(parent()->generation());
+                set_parent(parent()->parent());
+            }
+
+            // Gets the root node's generation integer, which is the one used by the tree.
+            uint32_t* get_root_generation() const
+            {
+                assert(params_type::kEnableGenerations);
+                const btree_node* curr = this;
+                for (; !curr->is_root(); curr = curr->parent())
+                    continue;
+                return const_cast<uint32_t*>(&curr->GetField<1>()[0]);
+            }
+
+            // Returns the generation for iterator validation.
+            uint32_t generation() const
+            {
+                return params_type::kEnableGenerations ? *get_root_generation() : 0;
+            }
+            // Updates generation. Should only be called on a root node or during node
+            // initialization.
+            void set_generation(uint32_t generation)
+            {
+                if (params_type::kEnableGenerations)
+                    GetField<1>()[0] = generation;
+            }
+            // Updates the generation. We do this whenever the node is mutated.
+            void next_generation()
+            {
+                if (params_type::kEnableGenerations)
+                    ++*get_root_generation();
+            }
+
+            // Getters for the key/value at position i in the node.
+            const key_type& key(int i) const
+            {
+                return params_type::key(slot(i));
+            }
+            reference value(int i)
+            {
+                return params_type::element(slot(i));
+            }
+            const_reference value(int i) const
+            {
+                return params_type::element(slot(i));
+            }
+
+            // Getters/setter for the child at position i in the node.
+            btree_node* child(int i) const
+            {
+                return GetField<4>()[i];
+            }
+            btree_node* start_child() const
+            {
+                return child(start());
+            }
+            btree_node*& mutable_child(int i)
+            {
+                return GetField<4>()[i];
+            }
+            void clear_child(int i)
+            {
+                absl::container_internal::SanitizerPoisonObject(&mutable_child(i));
+            }
+            void set_child(int i, btree_node* c)
+            {
+                absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i));
+                mutable_child(i) = c;
+                c->set_position(i);
+            }
+            void init_child(int i, btree_node* c)
+            {
+                set_child(i, c);
+                c->set_parent(this);
+            }
+
+            // Returns the position of the first value whose key is not less than k.
+            template<typename K>
+            SearchResult<int, is_key_compare_to::value> lower_bound(
+                const K& k, const key_compare& comp
+            ) const
+            {
+                return use_linear_search::value ? linear_search(k, comp) : binary_search(k, comp);
+            }
+            // Returns the position of the first value whose key is greater than k.
+            template<typename K>
+            int upper_bound(const K& k, const key_compare& comp) const
+            {
+                auto upper_compare = upper_bound_adapter<key_compare>(comp);
+                return use_linear_search::value ? linear_search(k, upper_compare).value : binary_search(k, upper_compare).value;
+            }
+
+            template<typename K, typename Compare>
+            SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
+                linear_search(const K& k, const Compare& comp) const
+            {
+                return linear_search_impl(k, start(), finish(), comp, btree_is_key_compare_to<Compare, key_type>());
+            }
+
+            template<typename K, typename Compare>
+            SearchResult<int, btree_is_key_compare_to<Compare, key_type>::value>
+                binary_search(const K& k, const Compare& comp) const
+            {
+                return binary_search_impl(k, start(), finish(), comp, btree_is_key_compare_to<Compare, key_type>());
+            }
+
+            // Returns the position of the first value whose key is not less than k using
+            // linear search performed using plain compare.
+            template<typename K, typename Compare>
+            SearchResult<int, false> linear_search_impl(
+                const K& k, int s, const int e, const Compare& comp, std::false_type /* IsCompareTo */
+            ) const
+            {
+                while (s < e)
+                {
+                    if (!comp(key(s), k))
+                    {
+                        break;
+                    }
+                    ++s;
+                }
+                return SearchResult<int, false>{s};
+            }
+
+            // Returns the position of the first value whose key is not less than k using
+            // linear search performed using compare-to.
+            template<typename K, typename Compare>
+            SearchResult<int, true> linear_search_impl(
+                const K& k, int s, const int e, const Compare& comp, std::true_type /* IsCompareTo */
+            ) const
+            {
+                while (s < e)
+                {
+                    const absl::weak_ordering c = comp(key(s), k);
+                    if (c == 0)
+                    {
+                        return {s, MatchKind::kEq};
+                    }
+                    else if (c > 0)
+                    {
+                        break;
+                    }
+                    ++s;
+                }
+                return {s, MatchKind::kNe};
+            }
+
+            // Returns the position of the first value whose key is not less than k using
+            // binary search performed using plain compare.
+            template<typename K, typename Compare>
+            SearchResult<int, false> binary_search_impl(
+                const K& k, int s, int e, const Compare& comp, std::false_type /* IsCompareTo */
+            ) const
+            {
+                while (s != e)
+                {
+                    const int mid = (s + e) >> 1;
+                    if (comp(key(mid), k))
+                    {
+                        s = mid + 1;
+                    }
+                    else
+                    {
+                        e = mid;
+                    }
+                }
+                return SearchResult<int, false>{s};
+            }
+
+            // Returns the position of the first value whose key is not less than k using
+            // binary search performed using compare-to.
+            template<typename K, typename CompareTo>
+            SearchResult<int, true> binary_search_impl(
+                const K& k, int s, int e, const CompareTo& comp, std::true_type /* IsCompareTo */
+            ) const
+            {
+                if (params_type::template can_have_multiple_equivalent_keys<K>())
+                {
+                    MatchKind exact_match = MatchKind::kNe;
+                    while (s != e)
+                    {
+                        const int mid = (s + e) >> 1;
+                        const absl::weak_ordering c = comp(key(mid), k);
+                        if (c < 0)
+                        {
+                            s = mid + 1;
+                        }
+                        else
+                        {
+                            e = mid;
+                            if (c == 0)
+                            {
+                                // Need to return the first value whose key is not less than k,
+                                // which requires continuing the binary search if there could be
+                                // multiple equivalent keys.
+                                exact_match = MatchKind::kEq;
+                            }
+                        }
+                    }
+                    return {s, exact_match};
+                }
+                else
+                {  // Can't have multiple equivalent keys.
+                    while (s != e)
+                    {
+                        const int mid = (s + e) >> 1;
+                        const absl::weak_ordering c = comp(key(mid), k);
+                        if (c < 0)
+                        {
+                            s = mid + 1;
+                        }
+                        else if (c > 0)
+                        {
+                            e = mid;
+                        }
+                        else
+                        {
+                            return {mid, MatchKind::kEq};
+                        }
+                    }
+                    return {s, MatchKind::kNe};
+                }
+            }
+
+            // Emplaces a value at position i, shifting all existing values and
+            // children at positions >= i to the right by 1.
+            template<typename... Args>
+            void emplace_value(size_type i, allocator_type* alloc, Args&&... args);
+
+            // Removes the values at positions [i, i + to_erase), shifting all existing
+            // values and children after that range to the left by to_erase. Clears all
+            // children between [i, i + to_erase).
+            void remove_values(field_type i, field_type to_erase, allocator_type* alloc);
+
+            // Rebalances a node with its right sibling.
+            void rebalance_right_to_left(int to_move, btree_node* right, allocator_type* alloc);
+            void rebalance_left_to_right(int to_move, btree_node* right, allocator_type* alloc);
+
+            // Splits a node, moving a portion of the node's values to its right sibling.
+            void split(int insert_position, btree_node* dest, allocator_type* alloc);
+
+            // Merges a node with its right sibling, moving all of the values and the
+            // delimiting key in the parent node onto itself, and deleting the src node.
+            void merge(btree_node* src, allocator_type* alloc);
+
+            // Node allocation/deletion routines.
+            void init_leaf(int max_count, btree_node* parent)
+            {
+                set_generation(0);
+                set_parent(parent);
+                set_position(0);
+                set_start(0);
+                set_finish(0);
+                set_max_count(max_count);
+                absl::container_internal::SanitizerPoisonMemoryRegion(
+                    start_slot(), max_count * sizeof(slot_type)
+                );
+            }
+            void init_internal(btree_node* parent)
+            {
+                init_leaf(kNodeSlots, parent);
+                // Set `max_count` to a sentinel value to indicate that this node is
+                // internal.
+                set_max_count(kInternalNodeMaxCount);
+                absl::container_internal::SanitizerPoisonMemoryRegion(
+                    &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node*)
+                );
+            }
+
+            static void deallocate(const size_type size, btree_node* node, allocator_type* alloc)
+            {
+                absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
+            }
+
+            // Deletes a node and all of its children.
+            static void clear_and_delete(btree_node* node, allocator_type* alloc);
+
+        private:
+            template<typename... Args>
+            void value_init(const field_type i, allocator_type* alloc, Args&&... args)
+            {
+                next_generation();
+                absl::container_internal::SanitizerUnpoisonObject(slot(i));
+                params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
+            }
+            void value_destroy(const field_type i, allocator_type* alloc)
+            {
+                next_generation();
+                params_type::destroy(alloc, slot(i));
+                absl::container_internal::SanitizerPoisonObject(slot(i));
+            }
+            void value_destroy_n(const field_type i, const field_type n, allocator_type* alloc)
+            {
+                next_generation();
+                for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s)
+                {
+                    params_type::destroy(alloc, s);
+                    absl::container_internal::SanitizerPoisonObject(s);
+                }
+            }
+
+            static void transfer(slot_type* dest, slot_type* src, allocator_type* alloc)
+            {
+                absl::container_internal::SanitizerUnpoisonObject(dest);
+                params_type::transfer(alloc, dest, src);
+                absl::container_internal::SanitizerPoisonObject(src);
+            }
+
+            // Transfers value from slot `src_i` in `src_node` to slot `dest_i` in `this`.
+            void transfer(const size_type dest_i, const size_type src_i, btree_node* src_node, allocator_type* alloc)
+            {
+                next_generation();
+                transfer(slot(dest_i), src_node->slot(src_i), alloc);
+            }
+
+            // Transfers `n` values starting at value `src_i` in `src_node` into the
+            // values starting at value `dest_i` in `this`.
+            void transfer_n(const size_type n, const size_type dest_i, const size_type src_i, btree_node* src_node, allocator_type* alloc)
+            {
+                next_generation();
+                for (slot_type *src = src_node->slot(src_i), *end = src + n, *dest = slot(dest_i);
+                     src != end;
+                     ++src, ++dest)
+                {
+                    transfer(dest, src, alloc);
+                }
+            }
+
+            // Same as above, except that we start at the end and work our way to the
+            // beginning.
+            void transfer_n_backward(const size_type n, const size_type dest_i, const size_type src_i, btree_node* src_node, allocator_type* alloc)
+            {
+                next_generation();
+                for (slot_type *src = src_node->slot(src_i + n - 1), *end = src - n, *dest = slot(dest_i + n - 1);
+                     src != end;
+                     --src, --dest)
+                {
+                    transfer(dest, src, alloc);
+                }
+            }
+
+            template<typename P>
+            friend class btree;
+            template<typename N, typename R, typename P>
+            friend class btree_iterator;
+            friend class BtreeNodePeer;
+            friend struct btree_access;
+        };
+
+        template<typename Node, typename Reference, typename Pointer>
+        class btree_iterator
+        {
+            using key_type = typename Node::key_type;
+            using size_type = typename Node::size_type;
+            using params_type = typename Node::params_type;
+            using is_map_container = typename params_type::is_map_container;
+
+            using node_type = Node;
+            using normal_node = typename std::remove_const<Node>::type;
+            using const_node = const Node;
+            using normal_pointer = typename params_type::pointer;
+            using normal_reference = typename params_type::reference;
+            using const_pointer = typename params_type::const_pointer;
+            using const_reference = typename params_type::const_reference;
+            using slot_type = typename params_type::slot_type;
+
+            using iterator =
+                btree_iterator<normal_node, normal_reference, normal_pointer>;
+            using const_iterator =
+                btree_iterator<const_node, const_reference, const_pointer>;
+
+        public:
+            // These aliases are public for std::iterator_traits.
+            using difference_type = typename Node::difference_type;
+            using value_type = typename params_type::value_type;
+            using pointer = Pointer;
+            using reference = Reference;
+            using iterator_category = std::bidirectional_iterator_tag;
+
+            btree_iterator() :
+                btree_iterator(nullptr, -1)
+            {
+            }
+            explicit btree_iterator(Node* n) :
+                btree_iterator(n, n->start())
+            {
+            }
+            btree_iterator(Node* n, int p) :
+                node_(n),
+                position_(p)
+            {
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-    // Use `~uint32_t{}` as a sentinel value for iterator generations so it
-    // doesn't match the initial value for the actual generation.
-    generation_ = n != nullptr ? n->generation() : ~uint32_t{};
+                // Use `~uint32_t{}` as a sentinel value for iterator generations so it
+                // doesn't match the initial value for the actual generation.
+                generation_ = n != nullptr ? n->generation() : ~uint32_t{};
 #endif
-  }
-
-  // NOTE: this SFINAE allows for implicit conversions from iterator to
-  // const_iterator, but it specifically avoids hiding the copy constructor so
-  // that the trivial one will be used when possible.
-  template <typename N, typename R, typename P,
-            absl::enable_if_t<
-                std::is_same<btree_iterator<N, R, P>, iterator>::value &&
-                    std::is_same<btree_iterator, const_iterator>::value,
-                int> = 0>
-  btree_iterator(const btree_iterator<N, R, P> other)  // NOLINT
-      : node_(other.node_), position_(other.position_) {
+            }
+
+            // NOTE: this SFINAE allows for implicit conversions from iterator to
+            // const_iterator, but it specifically avoids hiding the copy constructor so
+            // that the trivial one will be used when possible.
+            template<typename N, typename R, typename P, absl::enable_if_t<std::is_same<btree_iterator<N, R, P>, iterator>::value && std::is_same<btree_iterator, const_iterator>::value, int> = 0>
+            btree_iterator(const btree_iterator<N, R, P> other)  // NOLINT
+                :
+                node_(other.node_),
+                position_(other.position_)
+            {
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-    generation_ = other.generation_;
+                generation_ = other.generation_;
 #endif
-  }
-
-  bool operator==(const iterator &other) const {
-    return node_ == other.node_ && position_ == other.position_;
-  }
-  bool operator==(const const_iterator &other) const {
-    return node_ == other.node_ && position_ == other.position_;
-  }
-  bool operator!=(const iterator &other) const {
-    return node_ != other.node_ || position_ != other.position_;
-  }
-  bool operator!=(const const_iterator &other) const {
-    return node_ != other.node_ || position_ != other.position_;
-  }
-
-  // Accessors for the key/value the iterator is pointing at.
-  reference operator*() const {
-    ABSL_HARDENING_ASSERT(node_ != nullptr);
-    ABSL_HARDENING_ASSERT(node_->start() <= position_);
-    ABSL_HARDENING_ASSERT(node_->finish() > position_);
-    assert_valid_generation();
-    return node_->value(position_);
-  }
-  pointer operator->() const { return &operator*(); }
-
-  btree_iterator &operator++() {
-    increment();
-    return *this;
-  }
-  btree_iterator &operator--() {
-    decrement();
-    return *this;
-  }
-  btree_iterator operator++(int) {
-    btree_iterator tmp = *this;
-    ++*this;
-    return tmp;
-  }
-  btree_iterator operator--(int) {
-    btree_iterator tmp = *this;
-    --*this;
-    return tmp;
-  }
-
- private:
-  friend iterator;
-  friend const_iterator;
-  template <typename Params>
-  friend class btree;
-  template <typename Tree>
-  friend class btree_container;
-  template <typename Tree>
-  friend class btree_set_container;
-  template <typename Tree>
-  friend class btree_map_container;
-  template <typename Tree>
-  friend class btree_multiset_container;
-  template <typename TreeType, typename CheckerType>
-  friend class base_checker;
-  friend struct btree_access;
-
-  // This SFINAE allows explicit conversions from const_iterator to
-  // iterator, but also avoids hiding the copy constructor.
-  // NOTE: the const_cast is safe because this constructor is only called by
-  // non-const methods and the container owns the nodes.
-  template <typename N, typename R, typename P,
-            absl::enable_if_t<
-                std::is_same<btree_iterator<N, R, P>, const_iterator>::value &&
-                    std::is_same<btree_iterator, iterator>::value,
-                int> = 0>
-  explicit btree_iterator(const btree_iterator<N, R, P> other)
-      : node_(const_cast<node_type *>(other.node_)),
-        position_(other.position_) {
+            }
+
+            bool operator==(const iterator& other) const
+            {
+                return node_ == other.node_ && position_ == other.position_;
+            }
+            bool operator==(const const_iterator& other) const
+            {
+                return node_ == other.node_ && position_ == other.position_;
+            }
+            bool operator!=(const iterator& other) const
+            {
+                return node_ != other.node_ || position_ != other.position_;
+            }
+            bool operator!=(const const_iterator& other) const
+            {
+                return node_ != other.node_ || position_ != other.position_;
+            }
+
+            // Accessors for the key/value the iterator is pointing at.
+            reference operator*() const
+            {
+                ABSL_HARDENING_ASSERT(node_ != nullptr);
+                ABSL_HARDENING_ASSERT(node_->start() <= position_);
+                ABSL_HARDENING_ASSERT(node_->finish() > position_);
+                assert_valid_generation();
+                return node_->value(position_);
+            }
+            pointer operator->() const
+            {
+                return &operator*();
+            }
+
+            btree_iterator& operator++()
+            {
+                increment();
+                return *this;
+            }
+            btree_iterator& operator--()
+            {
+                decrement();
+                return *this;
+            }
+            btree_iterator operator++(int)
+            {
+                btree_iterator tmp = *this;
+                ++*this;
+                return tmp;
+            }
+            btree_iterator operator--(int)
+            {
+                btree_iterator tmp = *this;
+                --*this;
+                return tmp;
+            }
+
+        private:
+            friend iterator;
+            friend const_iterator;
+            template<typename Params>
+            friend class btree;
+            template<typename Tree>
+            friend class btree_container;
+            template<typename Tree>
+            friend class btree_set_container;
+            template<typename Tree>
+            friend class btree_map_container;
+            template<typename Tree>
+            friend class btree_multiset_container;
+            template<typename TreeType, typename CheckerType>
+            friend class base_checker;
+            friend struct btree_access;
+
+            // This SFINAE allows explicit conversions from const_iterator to
+            // iterator, but also avoids hiding the copy constructor.
+            // NOTE: the const_cast is safe because this constructor is only called by
+            // non-const methods and the container owns the nodes.
+            template<typename N, typename R, typename P, absl::enable_if_t<std::is_same<btree_iterator<N, R, P>, const_iterator>::value && std::is_same<btree_iterator, iterator>::value, int> = 0>
+            explicit btree_iterator(const btree_iterator<N, R, P> other) :
+                node_(const_cast<node_type*>(other.node_)),
+                position_(other.position_)
+            {
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-    generation_ = other.generation_;
+                generation_ = other.generation_;
 #endif
-  }
-
-  // Increment/decrement the iterator.
-  void increment() {
-    assert_valid_generation();
-    if (node_->is_leaf() && ++position_ < node_->finish()) {
-      return;
-    }
-    increment_slow();
-  }
-  void increment_slow();
-
-  void decrement() {
-    assert_valid_generation();
-    if (node_->is_leaf() && --position_ >= node_->start()) {
-      return;
-    }
-    decrement_slow();
-  }
-  void decrement_slow();
-
-  // Updates the generation. For use internally right before we return an
-  // iterator to the user.
-  void update_generation() {
+            }
+
+            // Increment/decrement the iterator.
+            void increment()
+            {
+                assert_valid_generation();
+                if (node_->is_leaf() && ++position_ < node_->finish())
+                {
+                    return;
+                }
+                increment_slow();
+            }
+            void increment_slow();
+
+            void decrement()
+            {
+                assert_valid_generation();
+                if (node_->is_leaf() && --position_ >= node_->start())
+                {
+                    return;
+                }
+                decrement_slow();
+            }
+            void decrement_slow();
+
+            // Updates the generation. For use internally right before we return an
+            // iterator to the user.
+            void update_generation()
+            {
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-    if (node_ != nullptr) generation_ = node_->generation();
+                if (node_ != nullptr)
+                    generation_ = node_->generation();
 #endif
-  }
-
-  const key_type &key() const { return node_->key(position_); }
-  decltype(std::declval<Node *>()->slot(0)) slot() {
-    return node_->slot(position_);
-  }
-
-  void assert_valid_generation() const {
+            }
+
+            const key_type& key() const
+            {
+                return node_->key(position_);
+            }
+            decltype(std::declval<Node*>()->slot(0)) slot()
+            {
+                return node_->slot(position_);
+            }
+
+            void assert_valid_generation() const
+            {
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-    if (node_ != nullptr && node_->generation() != generation_) {
-      ABSL_INTERNAL_LOG(
-          FATAL,
-          "Attempting to use an invalidated iterator. The corresponding b-tree "
-          "container has been mutated since this iterator was constructed.");
-    }
+                if (node_ != nullptr && node_->generation() != generation_)
+                {
+                    ABSL_INTERNAL_LOG(
+                        FATAL,
+                        "Attempting to use an invalidated iterator. The corresponding b-tree "
+                        "container has been mutated since this iterator was constructed."
+                    );
+                }
 #endif
-  }
-
-  // The node in the tree the iterator is pointing at.
-  Node *node_;
-  // The position within the node of the tree the iterator is pointing at.
-  // NOTE: this is an int rather than a field_type because iterators can point
-  // to invalid positions (such as -1) in certain circumstances.
-  int position_;
+            }
+
+            // The node in the tree the iterator is pointing at.
+            Node* node_;
+            // The position within the node of the tree the iterator is pointing at.
+            // NOTE: this is an int rather than a field_type because iterators can point
+            // to invalid positions (such as -1) in certain circumstances.
+            int position_;
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-  // Used to check that the iterator hasn't been invalidated.
-  uint32_t generation_;
+            // Used to check that the iterator hasn't been invalidated.
+            uint32_t generation_;
 #endif
-};
-
-template <typename Params>
-class btree {
-  using node_type = btree_node<Params>;
-  using is_key_compare_to = typename Params::is_key_compare_to;
-  using field_type = typename node_type::field_type;
-
-  // We use a static empty node for the root/leftmost/rightmost of empty btrees
-  // in order to avoid branching in begin()/end().
-  struct alignas(node_type::Alignment()) EmptyNodeType : node_type {
-    using field_type = typename node_type::field_type;
-    node_type *parent;
+        };
+
+        template<typename Params>
+        class btree
+        {
+            using node_type = btree_node<Params>;
+            using is_key_compare_to = typename Params::is_key_compare_to;
+            using field_type = typename node_type::field_type;
+
+            // We use a static empty node for the root/leftmost/rightmost of empty btrees
+            // in order to avoid branching in begin()/end().
+            struct alignas(node_type::Alignment()) EmptyNodeType : node_type
+            {
+                using field_type = typename node_type::field_type;
+                node_type* parent;
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-    uint32_t generation = 0;
+                uint32_t generation = 0;
 #endif
-    field_type position = 0;
-    field_type start = 0;
-    field_type finish = 0;
-    // max_count must be != kInternalNodeMaxCount (so that this node is regarded
-    // as a leaf node). max_count() is never called when the tree is empty.
-    field_type max_count = node_type::kInternalNodeMaxCount + 1;
+                field_type position = 0;
+                field_type start = 0;
+                field_type finish = 0;
+                // max_count must be != kInternalNodeMaxCount (so that this node is regarded
+                // as a leaf node). max_count() is never called when the tree is empty.
+                field_type max_count = node_type::kInternalNodeMaxCount + 1;
 
 #ifdef _MSC_VER
-    // MSVC has constexpr code generations bugs here.
-    EmptyNodeType() : parent(this) {}
+                // MSVC has constexpr code generations bugs here.
+                EmptyNodeType() :
+                    parent(this)
+                {
+                }
 #else
-    constexpr EmptyNodeType(node_type *p) : parent(p) {}
+                constexpr EmptyNodeType(node_type* p) :
+                    parent(p)
+                {
+                }
 #endif
-  };
+            };
 
-  static node_type *EmptyNode() {
+            static node_type* EmptyNode()
+            {
 #ifdef _MSC_VER
-    static EmptyNodeType *empty_node = new EmptyNodeType;
-    // This assert fails on some other construction methods.
-    assert(empty_node->parent == empty_node);
-    return empty_node;
+                static EmptyNodeType* empty_node = new EmptyNodeType;
+                // This assert fails on some other construction methods.
+                assert(empty_node->parent == empty_node);
+                return empty_node;
 #else
-    static constexpr EmptyNodeType empty_node(
-        const_cast<EmptyNodeType *>(&empty_node));
-    return const_cast<EmptyNodeType *>(&empty_node);
+                static constexpr EmptyNodeType empty_node(
+                    const_cast<EmptyNodeType*>(&empty_node)
+                );
+                return const_cast<EmptyNodeType*>(&empty_node);
 #endif
-  }
-
-  enum : uint32_t {
-    kNodeSlots = node_type::kNodeSlots,
-    kMinNodeValues = kNodeSlots / 2,
-  };
-
-  struct node_stats {
-    using size_type = typename Params::size_type;
-
-    node_stats(size_type l, size_type i) : leaf_nodes(l), internal_nodes(i) {}
-
-    node_stats &operator+=(const node_stats &other) {
-      leaf_nodes += other.leaf_nodes;
-      internal_nodes += other.internal_nodes;
-      return *this;
-    }
-
-    size_type leaf_nodes;
-    size_type internal_nodes;
-  };
-
- public:
-  using key_type = typename Params::key_type;
-  using value_type = typename Params::value_type;
-  using size_type = typename Params::size_type;
-  using difference_type = typename Params::difference_type;
-  using key_compare = typename Params::key_compare;
-  using original_key_compare = typename Params::original_key_compare;
-  using value_compare = typename Params::value_compare;
-  using allocator_type = typename Params::allocator_type;
-  using reference = typename Params::reference;
-  using const_reference = typename Params::const_reference;
-  using pointer = typename Params::pointer;
-  using const_pointer = typename Params::const_pointer;
-  using iterator =
-      typename btree_iterator<node_type, reference, pointer>::iterator;
-  using const_iterator = typename iterator::const_iterator;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using node_handle_type = node_handle<Params, Params, allocator_type>;
-
-  // Internal types made public for use by btree_container types.
-  using params_type = Params;
-  using slot_type = typename Params::slot_type;
-
- private:
-  // Copies or moves (depending on the template parameter) the values in
-  // other into this btree in their order in other. This btree must be empty
-  // before this method is called. This method is used in copy construction,
-  // copy assignment, and move assignment.
-  template <typename Btree>
-  void copy_or_move_values_in_order(Btree &other);
-
-  // Validates that various assumptions/requirements are true at compile time.
-  constexpr static bool static_assert_validation();
-
- public:
-  btree(const key_compare &comp, const allocator_type &alloc)
-      : root_(EmptyNode()), rightmost_(comp, alloc, EmptyNode()), size_(0) {}
-
-  btree(const btree &other) : btree(other, other.allocator()) {}
-  btree(const btree &other, const allocator_type &alloc)
-      : btree(other.key_comp(), alloc) {
-    copy_or_move_values_in_order(other);
-  }
-  btree(btree &&other) noexcept
-      : root_(absl::exchange(other.root_, EmptyNode())),
-        rightmost_(std::move(other.rightmost_)),
-        size_(absl::exchange(other.size_, 0)) {
-    other.mutable_rightmost() = EmptyNode();
-  }
-  btree(btree &&other, const allocator_type &alloc)
-      : btree(other.key_comp(), alloc) {
-    if (alloc == other.allocator()) {
-      swap(other);
-    } else {
-      // Move values from `other` one at a time when allocators are different.
-      copy_or_move_values_in_order(other);
-    }
-  }
-
-  ~btree() {
-    // Put static_asserts in destructor to avoid triggering them before the type
-    // is complete.
-    static_assert(static_assert_validation(), "This call must be elided.");
-    clear();
-  }
-
-  // Assign the contents of other to *this.
-  btree &operator=(const btree &other);
-  btree &operator=(btree &&other) noexcept;
-
-  iterator begin() { return iterator(leftmost()); }
-  const_iterator begin() const { return const_iterator(leftmost()); }
-  iterator end() { return iterator(rightmost(), rightmost()->finish()); }
-  const_iterator end() const {
-    return const_iterator(rightmost(), rightmost()->finish());
-  }
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  // Finds the first element whose key is not less than `key`.
-  template <typename K>
-  iterator lower_bound(const K &key) {
-    return internal_end(internal_lower_bound(key).value);
-  }
-  template <typename K>
-  const_iterator lower_bound(const K &key) const {
-    return internal_end(internal_lower_bound(key).value);
-  }
-
-  // Finds the first element whose key is not less than `key` and also returns
-  // whether that element is equal to `key`.
-  template <typename K>
-  std::pair<iterator, bool> lower_bound_equal(const K &key) const;
-
-  // Finds the first element whose key is greater than `key`.
-  template <typename K>
-  iterator upper_bound(const K &key) {
-    return internal_end(internal_upper_bound(key));
-  }
-  template <typename K>
-  const_iterator upper_bound(const K &key) const {
-    return internal_end(internal_upper_bound(key));
-  }
-
-  // Finds the range of values which compare equal to key. The first member of
-  // the returned pair is equal to lower_bound(key). The second member of the
-  // pair is equal to upper_bound(key).
-  template <typename K>
-  std::pair<iterator, iterator> equal_range(const K &key);
-  template <typename K>
-  std::pair<const_iterator, const_iterator> equal_range(const K &key) const {
-    return const_cast<btree *>(this)->equal_range(key);
-  }
-
-  // Inserts a value into the btree only if it does not already exist. The
-  // boolean return value indicates whether insertion succeeded or failed.
-  // Requirement: if `key` already exists in the btree, does not consume `args`.
-  // Requirement: `key` is never referenced after consuming `args`.
-  template <typename K, typename... Args>
-  std::pair<iterator, bool> insert_unique(const K &key, Args &&... args);
-
-  // Inserts with hint. Checks to see if the value should be placed immediately
-  // before `position` in the tree. If so, then the insertion will take
-  // amortized constant time. If not, the insertion will take amortized
-  // logarithmic time as if a call to insert_unique() were made.
-  // Requirement: if `key` already exists in the btree, does not consume `args`.
-  // Requirement: `key` is never referenced after consuming `args`.
-  template <typename K, typename... Args>
-  std::pair<iterator, bool> insert_hint_unique(iterator position,
-                                               const K &key,
-                                               Args &&... args);
-
-  // Insert a range of values into the btree.
-  // Note: the first overload avoids constructing a value_type if the key
-  // already exists in the btree.
-  template <typename InputIterator,
-            typename = decltype(std::declval<const key_compare &>()(
-                params_type::key(*std::declval<InputIterator>()),
-                std::declval<const key_type &>()))>
-  void insert_iterator_unique(InputIterator b, InputIterator e, int);
-  // We need the second overload for cases in which we need to construct a
-  // value_type in order to compare it with the keys already in the btree.
-  template <typename InputIterator>
-  void insert_iterator_unique(InputIterator b, InputIterator e, char);
-
-  // Inserts a value into the btree.
-  template <typename ValueType>
-  iterator insert_multi(const key_type &key, ValueType &&v);
-
-  // Inserts a value into the btree.
-  template <typename ValueType>
-  iterator insert_multi(ValueType &&v) {
-    return insert_multi(params_type::key(v), std::forward<ValueType>(v));
-  }
-
-  // Insert with hint. Check to see if the value should be placed immediately
-  // before position in the tree. If it does, then the insertion will take
-  // amortized constant time. If not, the insertion will take amortized
-  // logarithmic time as if a call to insert_multi(v) were made.
-  template <typename ValueType>
-  iterator insert_hint_multi(iterator position, ValueType &&v);
-
-  // Insert a range of values into the btree.
-  template <typename InputIterator>
-  void insert_iterator_multi(InputIterator b, InputIterator e);
-
-  // Erase the specified iterator from the btree. The iterator must be valid
-  // (i.e. not equal to end()).  Return an iterator pointing to the node after
-  // the one that was erased (or end() if none exists).
-  // Requirement: does not read the value at `*iter`.
-  iterator erase(iterator iter);
-
-  // Erases range. Returns the number of keys erased and an iterator pointing
-  // to the element after the last erased element.
-  std::pair<size_type, iterator> erase_range(iterator begin, iterator end);
-
-  // Finds an element with key equivalent to `key` or returns `end()` if `key`
-  // is not present.
-  template <typename K>
-  iterator find(const K &key) {
-    return internal_end(internal_find(key));
-  }
-  template <typename K>
-  const_iterator find(const K &key) const {
-    return internal_end(internal_find(key));
-  }
-
-  // Clear the btree, deleting all of the values it contains.
-  void clear();
-
-  // Swaps the contents of `this` and `other`.
-  void swap(btree &other);
-
-  const key_compare &key_comp() const noexcept {
-    return rightmost_.template get<0>();
-  }
-  template <typename K1, typename K2>
-  bool compare_keys(const K1 &a, const K2 &b) const {
-    return compare_internal::compare_result_as_less_than(key_comp()(a, b));
-  }
-
-  value_compare value_comp() const {
-    return value_compare(original_key_compare(key_comp()));
-  }
-
-  // Verifies the structure of the btree.
-  void verify() const;
-
-  // Size routines.
-  size_type size() const { return size_; }
-  size_type max_size() const { return (std::numeric_limits<size_type>::max)(); }
-  bool empty() const { return size_ == 0; }
-
-  // The height of the btree. An empty tree will have height 0.
-  size_type height() const {
-    size_type h = 0;
-    if (!empty()) {
-      // Count the length of the chain from the leftmost node up to the
-      // root. We actually count from the root back around to the level below
-      // the root, but the calculation is the same because of the circularity
-      // of that traversal.
-      const node_type *n = root();
-      do {
-        ++h;
-        n = n->parent();
-      } while (n != root());
-    }
-    return h;
-  }
-
-  // The number of internal, leaf and total nodes used by the btree.
-  size_type leaf_nodes() const { return internal_stats(root()).leaf_nodes; }
-  size_type internal_nodes() const {
-    return internal_stats(root()).internal_nodes;
-  }
-  size_type nodes() const {
-    node_stats stats = internal_stats(root());
-    return stats.leaf_nodes + stats.internal_nodes;
-  }
-
-  // The total number of bytes used by the btree.
-  // TODO(b/169338300): update to support node_btree_*.
-  size_type bytes_used() const {
-    node_stats stats = internal_stats(root());
-    if (stats.leaf_nodes == 1 && stats.internal_nodes == 0) {
-      return sizeof(*this) + node_type::LeafSize(root()->max_count());
-    } else {
-      return sizeof(*this) + stats.leaf_nodes * node_type::LeafSize() +
-             stats.internal_nodes * node_type::InternalSize();
-    }
-  }
-
-  // The average number of bytes used per value stored in the btree assuming
-  // random insertion order.
-  static double average_bytes_per_value() {
-    // The expected number of values per node with random insertion order is the
-    // average of the maximum and minimum numbers of values per node.
-    const double expected_values_per_node =
-        (kNodeSlots + kMinNodeValues) / 2.0;
-    return node_type::LeafSize() / expected_values_per_node;
-  }
-
-  // The fullness of the btree. Computed as the number of elements in the btree
-  // divided by the maximum number of elements a tree with the current number
-  // of nodes could hold. A value of 1 indicates perfect space
-  // utilization. Smaller values indicate space wastage.
-  // Returns 0 for empty trees.
-  double fullness() const {
-    if (empty()) return 0.0;
-    return static_cast<double>(size()) / (nodes() * kNodeSlots);
-  }
-  // The overhead of the btree structure in bytes per node. Computed as the
-  // total number of bytes used by the btree minus the number of bytes used for
-  // storing elements divided by the number of elements.
-  // Returns 0 for empty trees.
-  double overhead() const {
-    if (empty()) return 0.0;
-    return (bytes_used() - size() * sizeof(value_type)) /
-           static_cast<double>(size());
-  }
-
-  // The allocator used by the btree.
-  allocator_type get_allocator() const { return allocator(); }
-
- private:
-  friend struct btree_access;
-
-  // Internal accessor routines.
-  node_type *root() { return root_; }
-  const node_type *root() const { return root_; }
-  node_type *&mutable_root() noexcept { return root_; }
-  node_type *rightmost() { return rightmost_.template get<2>(); }
-  const node_type *rightmost() const { return rightmost_.template get<2>(); }
-  node_type *&mutable_rightmost() noexcept {
-    return rightmost_.template get<2>();
-  }
-  key_compare *mutable_key_comp() noexcept {
-    return &rightmost_.template get<0>();
-  }
-
-  // The leftmost node is stored as the parent of the root node.
-  node_type *leftmost() { return root()->parent(); }
-  const node_type *leftmost() const { return root()->parent(); }
-
-  // Allocator routines.
-  allocator_type *mutable_allocator() noexcept {
-    return &rightmost_.template get<1>();
-  }
-  const allocator_type &allocator() const noexcept {
-    return rightmost_.template get<1>();
-  }
-
-  // Allocates a correctly aligned node of at least size bytes using the
-  // allocator.
-  node_type *allocate(const size_type size) {
-    return reinterpret_cast<node_type *>(
-        absl::container_internal::Allocate<node_type::Alignment()>(
-            mutable_allocator(), size));
-  }
-
-  // Node creation/deletion routines.
-  node_type *new_internal_node(node_type *parent) {
-    node_type *n = allocate(node_type::InternalSize());
-    n->init_internal(parent);
-    return n;
-  }
-  node_type *new_leaf_node(node_type *parent) {
-    node_type *n = allocate(node_type::LeafSize());
-    n->init_leaf(kNodeSlots, parent);
-    return n;
-  }
-  node_type *new_leaf_root_node(const int max_count) {
-    node_type *n = allocate(node_type::LeafSize(max_count));
-    n->init_leaf(max_count, /*parent=*/n);
-    return n;
-  }
-
-  // Deletion helper routines.
-  iterator rebalance_after_delete(iterator iter);
-
-  // Rebalances or splits the node iter points to.
-  void rebalance_or_split(iterator *iter);
-
-  // Merges the values of left, right and the delimiting key on their parent
-  // onto left, removing the delimiting key and deleting right.
-  void merge_nodes(node_type *left, node_type *right);
-
-  // Tries to merge node with its left or right sibling, and failing that,
-  // rebalance with its left or right sibling. Returns true if a merge
-  // occurred, at which point it is no longer valid to access node. Returns
-  // false if no merging took place.
-  bool try_merge_or_rebalance(iterator *iter);
-
-  // Tries to shrink the height of the tree by 1.
-  void try_shrink();
-
-  iterator internal_end(iterator iter) {
-    return iter.node_ != nullptr ? iter : end();
-  }
-  const_iterator internal_end(const_iterator iter) const {
-    return iter.node_ != nullptr ? iter : end();
-  }
-
-  // Emplaces a value into the btree immediately before iter. Requires that
-  // key(v) <= iter.key() and (--iter).key() <= key(v).
-  template <typename... Args>
-  iterator internal_emplace(iterator iter, Args &&... args);
-
-  // Returns an iterator pointing to the first value >= the value "iter" is
-  // pointing at. Note that "iter" might be pointing to an invalid location such
-  // as iter.position_ == iter.node_->finish(). This routine simply moves iter
-  // up in the tree to a valid location. Requires: iter.node_ is non-null.
-  template <typename IterType>
-  static IterType internal_last(IterType iter);
-
-  // Returns an iterator pointing to the leaf position at which key would
-  // reside in the tree, unless there is an exact match - in which case, the
-  // result may not be on a leaf. When there's a three-way comparator, we can
-  // return whether there was an exact match. This allows the caller to avoid a
-  // subsequent comparison to determine if an exact match was made, which is
-  // important for keys with expensive comparison, such as strings.
-  template <typename K>
-  SearchResult<iterator, is_key_compare_to::value> internal_locate(
-      const K &key) const;
-
-  // Internal routine which implements lower_bound().
-  template <typename K>
-  SearchResult<iterator, is_key_compare_to::value> internal_lower_bound(
-      const K &key) const;
-
-  // Internal routine which implements upper_bound().
-  template <typename K>
-  iterator internal_upper_bound(const K &key) const;
-
-  // Internal routine which implements find().
-  template <typename K>
-  iterator internal_find(const K &key) const;
-
-  // Verifies the tree structure of node.
-  int internal_verify(const node_type *node, const key_type *lo,
-                      const key_type *hi) const;
-
-  node_stats internal_stats(const node_type *node) const {
-    // The root can be a static empty node.
-    if (node == nullptr || (node == root() && empty())) {
-      return node_stats(0, 0);
-    }
-    if (node->is_leaf()) {
-      return node_stats(1, 0);
-    }
-    node_stats res(0, 1);
-    for (int i = node->start(); i <= node->finish(); ++i) {
-      res += internal_stats(node->child(i));
-    }
-    return res;
-  }
-
-  node_type *root_;
-
-  // A pointer to the rightmost node. Note that the leftmost node is stored as
-  // the root's parent. We use compressed tuple in order to save space because
-  // key_compare and allocator_type are usually empty.
-  absl::container_internal::CompressedTuple<key_compare, allocator_type,
-                                            node_type *>
-      rightmost_;
-
-  // Number of values.
-  size_type size_;
-};
-
-////
-// btree_node methods
-template <typename P>
-template <typename... Args>
-inline void btree_node<P>::emplace_value(const size_type i,
-                                         allocator_type *alloc,
-                                         Args &&... args) {
-  assert(i >= start());
-  assert(i <= finish());
-  // Shift old values to create space for new value and then construct it in
-  // place.
-  if (i < finish()) {
-    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
-                        alloc);
-  }
-  value_init(i, alloc, std::forward<Args>(args)...);
-  set_finish(finish() + 1);
-
-  if (is_internal() && finish() > i + 1) {
-    for (field_type j = finish(); j > i + 1; --j) {
-      set_child(j, child(j - 1));
-    }
-    clear_child(i + 1);
-  }
-}
-
-template <typename P>
-inline void btree_node<P>::remove_values(const field_type i,
-                                         const field_type to_erase,
-                                         allocator_type *alloc) {
-  // Transfer values after the removed range into their new places.
-  value_destroy_n(i, to_erase, alloc);
-  const field_type orig_finish = finish();
-  const field_type src_i = i + to_erase;
-  transfer_n(orig_finish - src_i, i, src_i, this, alloc);
-
-  if (is_internal()) {
-    // Delete all children between begin and end.
-    for (int j = 0; j < to_erase; ++j) {
-      clear_and_delete(child(i + j + 1), alloc);
-    }
-    // Rotate children after end into new positions.
-    for (int j = i + to_erase + 1; j <= orig_finish; ++j) {
-      set_child(j - to_erase, child(j));
-      clear_child(j);
-    }
-  }
-  set_finish(orig_finish - to_erase);
-}
-
-template <typename P>
-void btree_node<P>::rebalance_right_to_left(const int to_move,
-                                            btree_node *right,
-                                            allocator_type *alloc) {
-  assert(parent() == right->parent());
-  assert(position() + 1 == right->position());
-  assert(right->count() >= count());
-  assert(to_move >= 1);
-  assert(to_move <= right->count());
-
-  // 1) Move the delimiting value in the parent to the left node.
-  transfer(finish(), position(), parent(), alloc);
-
-  // 2) Move the (to_move - 1) values from the right node to the left node.
-  transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc);
-
-  // 3) Move the new delimiting value to the parent from the right node.
-  parent()->transfer(position(), right->start() + to_move - 1, right, alloc);
-
-  // 4) Shift the values in the right node to their correct positions.
-  right->transfer_n(right->count() - to_move, right->start(),
-                    right->start() + to_move, right, alloc);
-
-  if (is_internal()) {
-    // Move the child pointers from the right to the left node.
-    for (int i = 0; i < to_move; ++i) {
-      init_child(finish() + i + 1, right->child(i));
-    }
-    for (int i = right->start(); i <= right->finish() - to_move; ++i) {
-      assert(i + to_move <= right->max_count());
-      right->init_child(i, right->child(i + to_move));
-      right->clear_child(i + to_move);
-    }
-  }
-
-  // Fixup `finish` on the left and right nodes.
-  set_finish(finish() + to_move);
-  right->set_finish(right->finish() - to_move);
-}
-
-template <typename P>
-void btree_node<P>::rebalance_left_to_right(const int to_move,
-                                            btree_node *right,
-                                            allocator_type *alloc) {
-  assert(parent() == right->parent());
-  assert(position() + 1 == right->position());
-  assert(count() >= right->count());
-  assert(to_move >= 1);
-  assert(to_move <= count());
-
-  // Values in the right node are shifted to the right to make room for the
-  // new to_move values. Then, the delimiting value in the parent and the
-  // other (to_move - 1) values in the left node are moved into the right node.
-  // Lastly, a new delimiting value is moved from the left node into the
-  // parent, and the remaining empty left node entries are destroyed.
-
-  // 1) Shift existing values in the right node to their correct positions.
-  right->transfer_n_backward(right->count(), right->start() + to_move,
-                             right->start(), right, alloc);
-
-  // 2) Move the delimiting value in the parent to the right node.
-  right->transfer(right->start() + to_move - 1, position(), parent(), alloc);
-
-  // 3) Move the (to_move - 1) values from the left node to the right node.
-  right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this,
-                    alloc);
-
-  // 4) Move the new delimiting value to the parent from the left node.
-  parent()->transfer(position(), finish() - to_move, this, alloc);
-
-  if (is_internal()) {
-    // Move the child pointers from the left to the right node.
-    for (int i = right->finish(); i >= right->start(); --i) {
-      right->init_child(i + to_move, right->child(i));
-      right->clear_child(i);
-    }
-    for (int i = 1; i <= to_move; ++i) {
-      right->init_child(i - 1, child(finish() - to_move + i));
-      clear_child(finish() - to_move + i);
-    }
-  }
-
-  // Fixup the counts on the left and right nodes.
-  set_finish(finish() - to_move);
-  right->set_finish(right->finish() + to_move);
-}
-
-template <typename P>
-void btree_node<P>::split(const int insert_position, btree_node *dest,
-                          allocator_type *alloc) {
-  assert(dest->count() == 0);
-  assert(max_count() == kNodeSlots);
-
-  // We bias the split based on the position being inserted. If we're
-  // inserting at the beginning of the left node then bias the split to put
-  // more values on the right node. If we're inserting at the end of the
-  // right node then bias the split to put more values on the left node.
-  if (insert_position == start()) {
-    dest->set_finish(dest->start() + finish() - 1);
-  } else if (insert_position == kNodeSlots) {
-    dest->set_finish(dest->start());
-  } else {
-    dest->set_finish(dest->start() + count() / 2);
-  }
-  set_finish(finish() - dest->count());
-  assert(count() >= 1);
-
-  // Move values from the left sibling to the right sibling.
-  dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc);
-
-  // The split key is the largest value in the left sibling.
-  --mutable_finish();
-  parent()->emplace_value(position(), alloc, finish_slot());
-  value_destroy(finish(), alloc);
-  parent()->init_child(position() + 1, dest);
-
-  if (is_internal()) {
-    for (int i = dest->start(), j = finish() + 1; i <= dest->finish();
-         ++i, ++j) {
-      assert(child(j) != nullptr);
-      dest->init_child(i, child(j));
-      clear_child(j);
-    }
-  }
-}
-
-template <typename P>
-void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
-  assert(parent() == src->parent());
-  assert(position() + 1 == src->position());
-
-  // Move the delimiting value to the left node.
-  value_init(finish(), alloc, parent()->slot(position()));
-
-  // Move the values from the right to the left node.
-  transfer_n(src->count(), finish() + 1, src->start(), src, alloc);
-
-  if (is_internal()) {
-    // Move the child pointers from the right to the left node.
-    for (int i = src->start(), j = finish() + 1; i <= src->finish(); ++i, ++j) {
-      init_child(j, src->child(i));
-      src->clear_child(i);
-    }
-  }
-
-  // Fixup `finish` on the src and dest nodes.
-  set_finish(start() + 1 + count() + src->count());
-  src->set_finish(src->start());
-
-  // Remove the value on the parent node and delete the src node.
-  parent()->remove_values(position(), /*to_erase=*/1, alloc);
-}
-
-template <typename P>
-void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
-  if (node->is_leaf()) {
-    node->value_destroy_n(node->start(), node->count(), alloc);
-    deallocate(LeafSize(node->max_count()), node, alloc);
-    return;
-  }
-  if (node->count() == 0) {
-    deallocate(InternalSize(), node, alloc);
-    return;
-  }
-
-  // The parent of the root of the subtree we are deleting.
-  btree_node *delete_root_parent = node->parent();
-
-  // Navigate to the leftmost leaf under node, and then delete upwards.
-  while (node->is_internal()) node = node->start_child();
+            }
+
+            enum : uint32_t
+            {
+                kNodeSlots = node_type::kNodeSlots,
+                kMinNodeValues = kNodeSlots / 2,
+            };
+
+            struct node_stats
+            {
+                using size_type = typename Params::size_type;
+
+                node_stats(size_type l, size_type i) :
+                    leaf_nodes(l),
+                    internal_nodes(i)
+                {
+                }
+
+                node_stats& operator+=(const node_stats& other)
+                {
+                    leaf_nodes += other.leaf_nodes;
+                    internal_nodes += other.internal_nodes;
+                    return *this;
+                }
+
+                size_type leaf_nodes;
+                size_type internal_nodes;
+            };
+
+        public:
+            using key_type = typename Params::key_type;
+            using value_type = typename Params::value_type;
+            using size_type = typename Params::size_type;
+            using difference_type = typename Params::difference_type;
+            using key_compare = typename Params::key_compare;
+            using original_key_compare = typename Params::original_key_compare;
+            using value_compare = typename Params::value_compare;
+            using allocator_type = typename Params::allocator_type;
+            using reference = typename Params::reference;
+            using const_reference = typename Params::const_reference;
+            using pointer = typename Params::pointer;
+            using const_pointer = typename Params::const_pointer;
+            using iterator =
+                typename btree_iterator<node_type, reference, pointer>::iterator;
+            using const_iterator = typename iterator::const_iterator;
+            using reverse_iterator = std::reverse_iterator<iterator>;
+            using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+            using node_handle_type = node_handle<Params, Params, allocator_type>;
+
+            // Internal types made public for use by btree_container types.
+            using params_type = Params;
+            using slot_type = typename Params::slot_type;
+
+        private:
+            // Copies or moves (depending on the template parameter) the values in
+            // other into this btree in their order in other. This btree must be empty
+            // before this method is called. This method is used in copy construction,
+            // copy assignment, and move assignment.
+            template<typename Btree>
+            void copy_or_move_values_in_order(Btree& other);
+
+            // Validates that various assumptions/requirements are true at compile time.
+            constexpr static bool static_assert_validation();
+
+        public:
+            btree(const key_compare& comp, const allocator_type& alloc) :
+                root_(EmptyNode()),
+                rightmost_(comp, alloc, EmptyNode()),
+                size_(0)
+            {
+            }
+
+            btree(const btree& other) :
+                btree(other, other.allocator())
+            {
+            }
+            btree(const btree& other, const allocator_type& alloc) :
+                btree(other.key_comp(), alloc)
+            {
+                copy_or_move_values_in_order(other);
+            }
+            btree(btree&& other) noexcept
+                :
+                root_(absl::exchange(other.root_, EmptyNode())),
+                rightmost_(std::move(other.rightmost_)),
+                size_(absl::exchange(other.size_, 0))
+            {
+                other.mutable_rightmost() = EmptyNode();
+            }
+            btree(btree&& other, const allocator_type& alloc) :
+                btree(other.key_comp(), alloc)
+            {
+                if (alloc == other.allocator())
+                {
+                    swap(other);
+                }
+                else
+                {
+                    // Move values from `other` one at a time when allocators are different.
+                    copy_or_move_values_in_order(other);
+                }
+            }
+
+            ~btree()
+            {
+                // Put static_asserts in destructor to avoid triggering them before the type
+                // is complete.
+                static_assert(static_assert_validation(), "This call must be elided.");
+                clear();
+            }
+
+            // Assign the contents of other to *this.
+            btree& operator=(const btree& other);
+            btree& operator=(btree&& other) noexcept;
+
+            iterator begin()
+            {
+                return iterator(leftmost());
+            }
+            const_iterator begin() const
+            {
+                return const_iterator(leftmost());
+            }
+            iterator end()
+            {
+                return iterator(rightmost(), rightmost()->finish());
+            }
+            const_iterator end() const
+            {
+                return const_iterator(rightmost(), rightmost()->finish());
+            }
+            reverse_iterator rbegin()
+            {
+                return reverse_iterator(end());
+            }
+            const_reverse_iterator rbegin() const
+            {
+                return const_reverse_iterator(end());
+            }
+            reverse_iterator rend()
+            {
+                return reverse_iterator(begin());
+            }
+            const_reverse_iterator rend() const
+            {
+                return const_reverse_iterator(begin());
+            }
+
+            // Finds the first element whose key is not less than `key`.
+            template<typename K>
+            iterator lower_bound(const K& key)
+            {
+                return internal_end(internal_lower_bound(key).value);
+            }
+            template<typename K>
+            const_iterator lower_bound(const K& key) const
+            {
+                return internal_end(internal_lower_bound(key).value);
+            }
+
+            // Finds the first element whose key is not less than `key` and also returns
+            // whether that element is equal to `key`.
+            template<typename K>
+            std::pair<iterator, bool> lower_bound_equal(const K& key) const;
+
+            // Finds the first element whose key is greater than `key`.
+            template<typename K>
+            iterator upper_bound(const K& key)
+            {
+                return internal_end(internal_upper_bound(key));
+            }
+            template<typename K>
+            const_iterator upper_bound(const K& key) const
+            {
+                return internal_end(internal_upper_bound(key));
+            }
+
+            // Finds the range of values which compare equal to key. The first member of
+            // the returned pair is equal to lower_bound(key). The second member of the
+            // pair is equal to upper_bound(key).
+            template<typename K>
+            std::pair<iterator, iterator> equal_range(const K& key);
+            template<typename K>
+            std::pair<const_iterator, const_iterator> equal_range(const K& key) const
+            {
+                return const_cast<btree*>(this)->equal_range(key);
+            }
+
+            // Inserts a value into the btree only if it does not already exist. The
+            // boolean return value indicates whether insertion succeeded or failed.
+            // Requirement: if `key` already exists in the btree, does not consume `args`.
+            // Requirement: `key` is never referenced after consuming `args`.
+            template<typename K, typename... Args>
+            std::pair<iterator, bool> insert_unique(const K& key, Args&&... args);
+
+            // Inserts with hint. Checks to see if the value should be placed immediately
+            // before `position` in the tree. If so, then the insertion will take
+            // amortized constant time. If not, the insertion will take amortized
+            // logarithmic time as if a call to insert_unique() were made.
+            // Requirement: if `key` already exists in the btree, does not consume `args`.
+            // Requirement: `key` is never referenced after consuming `args`.
+            template<typename K, typename... Args>
+            std::pair<iterator, bool> insert_hint_unique(iterator position, const K& key, Args&&... args);
+
+            // Insert a range of values into the btree.
+            // Note: the first overload avoids constructing a value_type if the key
+            // already exists in the btree.
+            template<typename InputIterator, typename = decltype(std::declval<const key_compare&>()(params_type::key(*std::declval<InputIterator>()), std::declval<const key_type&>()))>
+            void insert_iterator_unique(InputIterator b, InputIterator e, int);
+            // We need the second overload for cases in which we need to construct a
+            // value_type in order to compare it with the keys already in the btree.
+            template<typename InputIterator>
+            void insert_iterator_unique(InputIterator b, InputIterator e, char);
+
+            // Inserts a value into the btree.
+            template<typename ValueType>
+            iterator insert_multi(const key_type& key, ValueType&& v);
+
+            // Inserts a value into the btree.
+            template<typename ValueType>
+            iterator insert_multi(ValueType&& v)
+            {
+                return insert_multi(params_type::key(v), std::forward<ValueType>(v));
+            }
+
+            // Insert with hint. Check to see if the value should be placed immediately
+            // before position in the tree. If it does, then the insertion will take
+            // amortized constant time. If not, the insertion will take amortized
+            // logarithmic time as if a call to insert_multi(v) were made.
+            template<typename ValueType>
+            iterator insert_hint_multi(iterator position, ValueType&& v);
+
+            // Insert a range of values into the btree.
+            template<typename InputIterator>
+            void insert_iterator_multi(InputIterator b, InputIterator e);
+
+            // Erase the specified iterator from the btree. The iterator must be valid
+            // (i.e. not equal to end()).  Return an iterator pointing to the node after
+            // the one that was erased (or end() if none exists).
+            // Requirement: does not read the value at `*iter`.
+            iterator erase(iterator iter);
+
+            // Erases range. Returns the number of keys erased and an iterator pointing
+            // to the element after the last erased element.
+            std::pair<size_type, iterator> erase_range(iterator begin, iterator end);
+
+            // Finds an element with key equivalent to `key` or returns `end()` if `key`
+            // is not present.
+            template<typename K>
+            iterator find(const K& key)
+            {
+                return internal_end(internal_find(key));
+            }
+            template<typename K>
+            const_iterator find(const K& key) const
+            {
+                return internal_end(internal_find(key));
+            }
+
+            // Clear the btree, deleting all of the values it contains.
+            void clear();
+
+            // Swaps the contents of `this` and `other`.
+            void swap(btree& other);
+
+            const key_compare& key_comp() const noexcept
+            {
+                return rightmost_.template get<0>();
+            }
+            template<typename K1, typename K2>
+            bool compare_keys(const K1& a, const K2& b) const
+            {
+                return compare_internal::compare_result_as_less_than(key_comp()(a, b));
+            }
+
+            value_compare value_comp() const
+            {
+                return value_compare(original_key_compare(key_comp()));
+            }
+
+            // Verifies the structure of the btree.
+            void verify() const;
+
+            // Size routines.
+            size_type size() const
+            {
+                return size_;
+            }
+            size_type max_size() const
+            {
+                return (std::numeric_limits<size_type>::max)();
+            }
+            bool empty() const
+            {
+                return size_ == 0;
+            }
+
+            // The height of the btree. An empty tree will have height 0.
+            size_type height() const
+            {
+                size_type h = 0;
+                if (!empty())
+                {
+                    // Count the length of the chain from the leftmost node up to the
+                    // root. We actually count from the root back around to the level below
+                    // the root, but the calculation is the same because of the circularity
+                    // of that traversal.
+                    const node_type* n = root();
+                    do
+                    {
+                        ++h;
+                        n = n->parent();
+                    } while (n != root());
+                }
+                return h;
+            }
+
+            // The number of internal, leaf and total nodes used by the btree.
+            size_type leaf_nodes() const
+            {
+                return internal_stats(root()).leaf_nodes;
+            }
+            size_type internal_nodes() const
+            {
+                return internal_stats(root()).internal_nodes;
+            }
+            size_type nodes() const
+            {
+                node_stats stats = internal_stats(root());
+                return stats.leaf_nodes + stats.internal_nodes;
+            }
+
+            // The total number of bytes used by the btree.
+            // TODO(b/169338300): update to support node_btree_*.
+            size_type bytes_used() const
+            {
+                node_stats stats = internal_stats(root());
+                if (stats.leaf_nodes == 1 && stats.internal_nodes == 0)
+                {
+                    return sizeof(*this) + node_type::LeafSize(root()->max_count());
+                }
+                else
+                {
+                    return sizeof(*this) + stats.leaf_nodes * node_type::LeafSize() +
+                           stats.internal_nodes * node_type::InternalSize();
+                }
+            }
+
+            // The average number of bytes used per value stored in the btree assuming
+            // random insertion order.
+            static double average_bytes_per_value()
+            {
+                // The expected number of values per node with random insertion order is the
+                // average of the maximum and minimum numbers of values per node.
+                const double expected_values_per_node =
+                    (kNodeSlots + kMinNodeValues) / 2.0;
+                return node_type::LeafSize() / expected_values_per_node;
+            }
+
+            // The fullness of the btree. Computed as the number of elements in the btree
+            // divided by the maximum number of elements a tree with the current number
+            // of nodes could hold. A value of 1 indicates perfect space
+            // utilization. Smaller values indicate space wastage.
+            // Returns 0 for empty trees.
+            double fullness() const
+            {
+                if (empty())
+                    return 0.0;
+                return static_cast<double>(size()) / (nodes() * kNodeSlots);
+            }
+            // The overhead of the btree structure in bytes per node. Computed as the
+            // total number of bytes used by the btree minus the number of bytes used for
+            // storing elements divided by the number of elements.
+            // Returns 0 for empty trees.
+            double overhead() const
+            {
+                if (empty())
+                    return 0.0;
+                return (bytes_used() - size() * sizeof(value_type)) /
+                       static_cast<double>(size());
+            }
+
+            // The allocator used by the btree.
+            allocator_type get_allocator() const
+            {
+                return allocator();
+            }
+
+        private:
+            friend struct btree_access;
+
+            // Internal accessor routines.
+            node_type* root()
+            {
+                return root_;
+            }
+            const node_type* root() const
+            {
+                return root_;
+            }
+            node_type*& mutable_root() noexcept
+            {
+                return root_;
+            }
+            node_type* rightmost()
+            {
+                return rightmost_.template get<2>();
+            }
+            const node_type* rightmost() const
+            {
+                return rightmost_.template get<2>();
+            }
+            node_type*& mutable_rightmost() noexcept
+            {
+                return rightmost_.template get<2>();
+            }
+            key_compare* mutable_key_comp() noexcept
+            {
+                return &rightmost_.template get<0>();
+            }
+
+            // The leftmost node is stored as the parent of the root node.
+            node_type* leftmost()
+            {
+                return root()->parent();
+            }
+            const node_type* leftmost() const
+            {
+                return root()->parent();
+            }
+
+            // Allocator routines.
+            allocator_type* mutable_allocator() noexcept
+            {
+                return &rightmost_.template get<1>();
+            }
+            const allocator_type& allocator() const noexcept
+            {
+                return rightmost_.template get<1>();
+            }
+
+            // Allocates a correctly aligned node of at least size bytes using the
+            // allocator.
+            node_type* allocate(const size_type size)
+            {
+                return reinterpret_cast<node_type*>(
+                    absl::container_internal::Allocate<node_type::Alignment()>(
+                        mutable_allocator(), size
+                    )
+                );
+            }
+
+            // Node creation/deletion routines.
+            node_type* new_internal_node(node_type* parent)
+            {
+                node_type* n = allocate(node_type::InternalSize());
+                n->init_internal(parent);
+                return n;
+            }
+            node_type* new_leaf_node(node_type* parent)
+            {
+                node_type* n = allocate(node_type::LeafSize());
+                n->init_leaf(kNodeSlots, parent);
+                return n;
+            }
+            node_type* new_leaf_root_node(const int max_count)
+            {
+                node_type* n = allocate(node_type::LeafSize(max_count));
+                n->init_leaf(max_count, /*parent=*/n);
+                return n;
+            }
+
+            // Deletion helper routines.
+            iterator rebalance_after_delete(iterator iter);
+
+            // Rebalances or splits the node iter points to.
+            void rebalance_or_split(iterator* iter);
+
+            // Merges the values of left, right and the delimiting key on their parent
+            // onto left, removing the delimiting key and deleting right.
+            void merge_nodes(node_type* left, node_type* right);
+
+            // Tries to merge node with its left or right sibling, and failing that,
+            // rebalance with its left or right sibling. Returns true if a merge
+            // occurred, at which point it is no longer valid to access node. Returns
+            // false if no merging took place.
+            bool try_merge_or_rebalance(iterator* iter);
+
+            // Tries to shrink the height of the tree by 1.
+            void try_shrink();
+
+            iterator internal_end(iterator iter)
+            {
+                return iter.node_ != nullptr ? iter : end();
+            }
+            const_iterator internal_end(const_iterator iter) const
+            {
+                return iter.node_ != nullptr ? iter : end();
+            }
+
+            // Emplaces a value into the btree immediately before iter. Requires that
+            // key(v) <= iter.key() and (--iter).key() <= key(v).
+            template<typename... Args>
+            iterator internal_emplace(iterator iter, Args&&... args);
+
+            // Returns an iterator pointing to the first value >= the value "iter" is
+            // pointing at. Note that "iter" might be pointing to an invalid location such
+            // as iter.position_ == iter.node_->finish(). This routine simply moves iter
+            // up in the tree to a valid location. Requires: iter.node_ is non-null.
+            template<typename IterType>
+            static IterType internal_last(IterType iter);
+
+            // Returns an iterator pointing to the leaf position at which key would
+            // reside in the tree, unless there is an exact match - in which case, the
+            // result may not be on a leaf. When there's a three-way comparator, we can
+            // return whether there was an exact match. This allows the caller to avoid a
+            // subsequent comparison to determine if an exact match was made, which is
+            // important for keys with expensive comparison, such as strings.
+            template<typename K>
+            SearchResult<iterator, is_key_compare_to::value> internal_locate(
+                const K& key
+            ) const;
+
+            // Internal routine which implements lower_bound().
+            template<typename K>
+            SearchResult<iterator, is_key_compare_to::value> internal_lower_bound(
+                const K& key
+            ) const;
+
+            // Internal routine which implements upper_bound().
+            template<typename K>
+            iterator internal_upper_bound(const K& key) const;
+
+            // Internal routine which implements find().
+            template<typename K>
+            iterator internal_find(const K& key) const;
+
+            // Verifies the tree structure of node.
+            int internal_verify(const node_type* node, const key_type* lo, const key_type* hi) const;
+
+            node_stats internal_stats(const node_type* node) const
+            {
+                // The root can be a static empty node.
+                if (node == nullptr || (node == root() && empty()))
+                {
+                    return node_stats(0, 0);
+                }
+                if (node->is_leaf())
+                {
+                    return node_stats(1, 0);
+                }
+                node_stats res(0, 1);
+                for (int i = node->start(); i <= node->finish(); ++i)
+                {
+                    res += internal_stats(node->child(i));
+                }
+                return res;
+            }
+
+            node_type* root_;
+
+            // A pointer to the rightmost node. Note that the leftmost node is stored as
+            // the root's parent. We use compressed tuple in order to save space because
+            // key_compare and allocator_type are usually empty.
+            absl::container_internal::CompressedTuple<key_compare, allocator_type, node_type*>
+                rightmost_;
+
+            // Number of values.
+            size_type size_;
+        };
+
+        ////
+        // btree_node methods
+        template<typename P>
+        template<typename... Args>
+        inline void btree_node<P>::emplace_value(const size_type i, allocator_type* alloc, Args&&... args)
+        {
+            assert(i >= start());
+            assert(i <= finish());
+            // Shift old values to create space for new value and then construct it in
+            // place.
+            if (i < finish())
+            {
+                transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this, alloc);
+            }
+            value_init(i, alloc, std::forward<Args>(args)...);
+            set_finish(finish() + 1);
+
+            if (is_internal() && finish() > i + 1)
+            {
+                for (field_type j = finish(); j > i + 1; --j)
+                {
+                    set_child(j, child(j - 1));
+                }
+                clear_child(i + 1);
+            }
+        }
+
+        template<typename P>
+        inline void btree_node<P>::remove_values(const field_type i, const field_type to_erase, allocator_type* alloc)
+        {
+            // Transfer values after the removed range into their new places.
+            value_destroy_n(i, to_erase, alloc);
+            const field_type orig_finish = finish();
+            const field_type src_i = i + to_erase;
+            transfer_n(orig_finish - src_i, i, src_i, this, alloc);
+
+            if (is_internal())
+            {
+                // Delete all children between begin and end.
+                for (int j = 0; j < to_erase; ++j)
+                {
+                    clear_and_delete(child(i + j + 1), alloc);
+                }
+                // Rotate children after end into new positions.
+                for (int j = i + to_erase + 1; j <= orig_finish; ++j)
+                {
+                    set_child(j - to_erase, child(j));
+                    clear_child(j);
+                }
+            }
+            set_finish(orig_finish - to_erase);
+        }
+
+        template<typename P>
+        void btree_node<P>::rebalance_right_to_left(const int to_move, btree_node* right, allocator_type* alloc)
+        {
+            assert(parent() == right->parent());
+            assert(position() + 1 == right->position());
+            assert(right->count() >= count());
+            assert(to_move >= 1);
+            assert(to_move <= right->count());
+
+            // 1) Move the delimiting value in the parent to the left node.
+            transfer(finish(), position(), parent(), alloc);
+
+            // 2) Move the (to_move - 1) values from the right node to the left node.
+            transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc);
+
+            // 3) Move the new delimiting value to the parent from the right node.
+            parent()->transfer(position(), right->start() + to_move - 1, right, alloc);
+
+            // 4) Shift the values in the right node to their correct positions.
+            right->transfer_n(right->count() - to_move, right->start(), right->start() + to_move, right, alloc);
+
+            if (is_internal())
+            {
+                // Move the child pointers from the right to the left node.
+                for (int i = 0; i < to_move; ++i)
+                {
+                    init_child(finish() + i + 1, right->child(i));
+                }
+                for (int i = right->start(); i <= right->finish() - to_move; ++i)
+                {
+                    assert(i + to_move <= right->max_count());
+                    right->init_child(i, right->child(i + to_move));
+                    right->clear_child(i + to_move);
+                }
+            }
+
+            // Fixup `finish` on the left and right nodes.
+            set_finish(finish() + to_move);
+            right->set_finish(right->finish() - to_move);
+        }
+
+        template<typename P>
+        void btree_node<P>::rebalance_left_to_right(const int to_move, btree_node* right, allocator_type* alloc)
+        {
+            assert(parent() == right->parent());
+            assert(position() + 1 == right->position());
+            assert(count() >= right->count());
+            assert(to_move >= 1);
+            assert(to_move <= count());
+
+            // Values in the right node are shifted to the right to make room for the
+            // new to_move values. Then, the delimiting value in the parent and the
+            // other (to_move - 1) values in the left node are moved into the right node.
+            // Lastly, a new delimiting value is moved from the left node into the
+            // parent, and the remaining empty left node entries are destroyed.
+
+            // 1) Shift existing values in the right node to their correct positions.
+            right->transfer_n_backward(right->count(), right->start() + to_move, right->start(), right, alloc);
+
+            // 2) Move the delimiting value in the parent to the right node.
+            right->transfer(right->start() + to_move - 1, position(), parent(), alloc);
+
+            // 3) Move the (to_move - 1) values from the left node to the right node.
+            right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this, alloc);
+
+            // 4) Move the new delimiting value to the parent from the left node.
+            parent()->transfer(position(), finish() - to_move, this, alloc);
+
+            if (is_internal())
+            {
+                // Move the child pointers from the left to the right node.
+                for (int i = right->finish(); i >= right->start(); --i)
+                {
+                    right->init_child(i + to_move, right->child(i));
+                    right->clear_child(i);
+                }
+                for (int i = 1; i <= to_move; ++i)
+                {
+                    right->init_child(i - 1, child(finish() - to_move + i));
+                    clear_child(finish() - to_move + i);
+                }
+            }
+
+            // Fixup the counts on the left and right nodes.
+            set_finish(finish() - to_move);
+            right->set_finish(right->finish() + to_move);
+        }
+
+        template<typename P>
+        void btree_node<P>::split(const int insert_position, btree_node* dest, allocator_type* alloc)
+        {
+            assert(dest->count() == 0);
+            assert(max_count() == kNodeSlots);
+
+            // We bias the split based on the position being inserted. If we're
+            // inserting at the beginning of the left node then bias the split to put
+            // more values on the right node. If we're inserting at the end of the
+            // right node then bias the split to put more values on the left node.
+            if (insert_position == start())
+            {
+                dest->set_finish(dest->start() + finish() - 1);
+            }
+            else if (insert_position == kNodeSlots)
+            {
+                dest->set_finish(dest->start());
+            }
+            else
+            {
+                dest->set_finish(dest->start() + count() / 2);
+            }
+            set_finish(finish() - dest->count());
+            assert(count() >= 1);
+
+            // Move values from the left sibling to the right sibling.
+            dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc);
+
+            // The split key is the largest value in the left sibling.
+            --mutable_finish();
+            parent()->emplace_value(position(), alloc, finish_slot());
+            value_destroy(finish(), alloc);
+            parent()->init_child(position() + 1, dest);
+
+            if (is_internal())
+            {
+                for (int i = dest->start(), j = finish() + 1; i <= dest->finish();
+                     ++i, ++j)
+                {
+                    assert(child(j) != nullptr);
+                    dest->init_child(i, child(j));
+                    clear_child(j);
+                }
+            }
+        }
+
+        template<typename P>
+        void btree_node<P>::merge(btree_node* src, allocator_type* alloc)
+        {
+            assert(parent() == src->parent());
+            assert(position() + 1 == src->position());
+
+            // Move the delimiting value to the left node.
+            value_init(finish(), alloc, parent()->slot(position()));
+
+            // Move the values from the right to the left node.
+            transfer_n(src->count(), finish() + 1, src->start(), src, alloc);
+
+            if (is_internal())
+            {
+                // Move the child pointers from the right to the left node.
+                for (int i = src->start(), j = finish() + 1; i <= src->finish(); ++i, ++j)
+                {
+                    init_child(j, src->child(i));
+                    src->clear_child(i);
+                }
+            }
+
+            // Fixup `finish` on the src and dest nodes.
+            set_finish(start() + 1 + count() + src->count());
+            src->set_finish(src->start());
+
+            // Remove the value on the parent node and delete the src node.
+            parent()->remove_values(position(), /*to_erase=*/1, alloc);
+        }
+
+        template<typename P>
+        void btree_node<P>::clear_and_delete(btree_node* node, allocator_type* alloc)
+        {
+            if (node->is_leaf())
+            {
+                node->value_destroy_n(node->start(), node->count(), alloc);
+                deallocate(LeafSize(node->max_count()), node, alloc);
+                return;
+            }
+            if (node->count() == 0)
+            {
+                deallocate(InternalSize(), node, alloc);
+                return;
+            }
+
+            // The parent of the root of the subtree we are deleting.
+            btree_node* delete_root_parent = node->parent();
+
+            // Navigate to the leftmost leaf under node, and then delete upwards.
+            while (node->is_internal())
+                node = node->start_child();
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-  // When generations are enabled, we delete the leftmost leaf last in case it's
-  // the parent of the root and we need to check whether it's a leaf before we
-  // can update the root's generation.
-  // TODO(ezb): if we change btree_node::is_root to check a bool inside the node
-  // instead of checking whether the parent is a leaf, we can remove this logic.
-  btree_node *leftmost_leaf = node;
+            // When generations are enabled, we delete the leftmost leaf last in case it's
+            // the parent of the root and we need to check whether it's a leaf before we
+            // can update the root's generation.
+            // TODO(ezb): if we change btree_node::is_root to check a bool inside the node
+            // instead of checking whether the parent is a leaf, we can remove this logic.
+            btree_node* leftmost_leaf = node;
 #endif
-  // Use `int` because `pos` needs to be able to hold `kNodeSlots+1`, which
-  // isn't guaranteed to be a valid `field_type`.
-  int pos = node->position();
-  btree_node *parent = node->parent();
-  for (;;) {
-    // In each iteration of the next loop, we delete one leaf node and go right.
-    assert(pos <= parent->finish());
-    do {
-      node = parent->child(pos);
-      if (node->is_internal()) {
-        // Navigate to the leftmost leaf under node.
-        while (node->is_internal()) node = node->start_child();
-        pos = node->position();
-        parent = node->parent();
-      }
-      node->value_destroy_n(node->start(), node->count(), alloc);
+            // Use `int` because `pos` needs to be able to hold `kNodeSlots+1`, which
+            // isn't guaranteed to be a valid `field_type`.
+            int pos = node->position();
+            btree_node* parent = node->parent();
+            for (;;)
+            {
+                // In each iteration of the next loop, we delete one leaf node and go right.
+                assert(pos <= parent->finish());
+                do
+                {
+                    node = parent->child(pos);
+                    if (node->is_internal())
+                    {
+                        // Navigate to the leftmost leaf under node.
+                        while (node->is_internal())
+                            node = node->start_child();
+                        pos = node->position();
+                        parent = node->parent();
+                    }
+                    node->value_destroy_n(node->start(), node->count(), alloc);
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-      if (leftmost_leaf != node)
+                    if (leftmost_leaf != node)
 #endif
-        deallocate(LeafSize(node->max_count()), node, alloc);
-      ++pos;
-    } while (pos <= parent->finish());
-
-    // Once we've deleted all children of parent, delete parent and go up/right.
-    assert(pos > parent->finish());
-    do {
-      node = parent;
-      pos = node->position();
-      parent = node->parent();
-      node->value_destroy_n(node->start(), node->count(), alloc);
-      deallocate(InternalSize(), node, alloc);
-      if (parent == delete_root_parent) {
+                        deallocate(LeafSize(node->max_count()), node, alloc);
+                    ++pos;
+                } while (pos <= parent->finish());
+
+                // Once we've deleted all children of parent, delete parent and go up/right.
+                assert(pos > parent->finish());
+                do
+                {
+                    node = parent;
+                    pos = node->position();
+                    parent = node->parent();
+                    node->value_destroy_n(node->start(), node->count(), alloc);
+                    deallocate(InternalSize(), node, alloc);
+                    if (parent == delete_root_parent)
+                    {
 #ifdef ABSL_BTREE_ENABLE_GENERATIONS
-        deallocate(LeafSize(leftmost_leaf->max_count()), leftmost_leaf, alloc);
+                        deallocate(LeafSize(leftmost_leaf->max_count()), leftmost_leaf, alloc);
 #endif
-        return;
-      }
-      ++pos;
-    } while (pos > parent->finish());
-  }
-}
-
-////
-// btree_iterator methods
-template <typename N, typename R, typename P>
-void btree_iterator<N, R, P>::increment_slow() {
-  if (node_->is_leaf()) {
-    assert(position_ >= node_->finish());
-    btree_iterator save(*this);
-    while (position_ == node_->finish() && !node_->is_root()) {
-      assert(node_->parent()->child(node_->position()) == node_);
-      position_ = node_->position();
-      node_ = node_->parent();
-    }
-    // TODO(ezb): assert we aren't incrementing end() instead of handling.
-    if (position_ == node_->finish()) {
-      *this = save;
-    }
-  } else {
-    assert(position_ < node_->finish());
-    node_ = node_->child(position_ + 1);
-    while (node_->is_internal()) {
-      node_ = node_->start_child();
-    }
-    position_ = node_->start();
-  }
-}
-
-template <typename N, typename R, typename P>
-void btree_iterator<N, R, P>::decrement_slow() {
-  if (node_->is_leaf()) {
-    assert(position_ <= -1);
-    btree_iterator save(*this);
-    while (position_ < node_->start() && !node_->is_root()) {
-      assert(node_->parent()->child(node_->position()) == node_);
-      position_ = node_->position() - 1;
-      node_ = node_->parent();
-    }
-    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
-    if (position_ < node_->start()) {
-      *this = save;
-    }
-  } else {
-    assert(position_ >= node_->start());
-    node_ = node_->child(position_);
-    while (node_->is_internal()) {
-      node_ = node_->child(node_->finish());
-    }
-    position_ = node_->finish() - 1;
-  }
-}
-
-////
-// btree methods
-template <typename P>
-template <typename Btree>
-void btree<P>::copy_or_move_values_in_order(Btree &other) {
-  static_assert(std::is_same<btree, Btree>::value ||
-                    std::is_same<const btree, Btree>::value,
-                "Btree type must be same or const.");
-  assert(empty());
-
-  // We can avoid key comparisons because we know the order of the
-  // values is the same order we'll store them in.
-  auto iter = other.begin();
-  if (iter == other.end()) return;
-  insert_multi(iter.slot());
-  ++iter;
-  for (; iter != other.end(); ++iter) {
-    // If the btree is not empty, we can just insert the new value at the end
-    // of the tree.
-    internal_emplace(end(), iter.slot());
-  }
-}
-
-template <typename P>
-constexpr bool btree<P>::static_assert_validation() {
-  static_assert(std::is_nothrow_copy_constructible<key_compare>::value,
-                "Key comparison must be nothrow copy constructible");
-  static_assert(std::is_nothrow_copy_constructible<allocator_type>::value,
-                "Allocator must be nothrow copy constructible");
-  static_assert(type_traits_internal::is_trivially_copyable<iterator>::value,
-                "iterator not trivially copyable.");
-
-  // Note: We assert that kTargetValues, which is computed from
-  // Params::kTargetNodeSize, must fit the node_type::field_type.
-  static_assert(
-      kNodeSlots < (1 << (8 * sizeof(typename node_type::field_type))),
-      "target node size too large");
-
-  // Verify that key_compare returns an absl::{weak,strong}_ordering or bool.
-  static_assert(
-      compare_has_valid_result_type<key_compare, key_type>(),
-      "key comparison function must return absl::{weak,strong}_ordering or "
-      "bool.");
-
-  // Test the assumption made in setting kNodeSlotSpace.
-  static_assert(node_type::MinimumOverhead() >= sizeof(void *) + 4,
-                "node space assumption incorrect");
-
-  return true;
-}
-
-template <typename P>
-template <typename K>
-auto btree<P>::lower_bound_equal(const K &key) const
-    -> std::pair<iterator, bool> {
-  const SearchResult<iterator, is_key_compare_to::value> res =
-      internal_lower_bound(key);
-  const iterator lower = iterator(internal_end(res.value));
-  const bool equal = res.HasMatch()
-                         ? res.IsEq()
-                         : lower != end() && !compare_keys(key, lower.key());
-  return {lower, equal};
-}
-
-template <typename P>
-template <typename K>
-auto btree<P>::equal_range(const K &key) -> std::pair<iterator, iterator> {
-  const std::pair<iterator, bool> lower_and_equal = lower_bound_equal(key);
-  const iterator lower = lower_and_equal.first;
-  if (!lower_and_equal.second) {
-    return {lower, lower};
-  }
-
-  const iterator next = std::next(lower);
-  if (!params_type::template can_have_multiple_equivalent_keys<K>()) {
-    // The next iterator after lower must point to a key greater than `key`.
-    // Note: if this assert fails, then it may indicate that the comparator does
-    // not meet the equivalence requirements for Compare
-    // (see https://en.cppreference.com/w/cpp/named_req/Compare).
-    assert(next == end() || compare_keys(key, next.key()));
-    return {lower, next};
-  }
-  // Try once more to avoid the call to upper_bound() if there's only one
-  // equivalent key. This should prevent all calls to upper_bound() in cases of
-  // unique-containers with heterogeneous comparators in which all comparison
-  // operators have the same equivalence classes.
-  if (next == end() || compare_keys(key, next.key())) return {lower, next};
-
-  // In this case, we need to call upper_bound() to avoid worst case O(N)
-  // behavior if we were to iterate over equal keys.
-  return {lower, upper_bound(key)};
-}
-
-template <typename P>
-template <typename K, typename... Args>
-auto btree<P>::insert_unique(const K &key, Args &&... args)
-    -> std::pair<iterator, bool> {
-  if (empty()) {
-    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
-  }
-
-  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
-  iterator iter = res.value;
-
-  if (res.HasMatch()) {
-    if (res.IsEq()) {
-      // The key already exists in the tree, do nothing.
-      return {iter, false};
-    }
-  } else {
-    iterator last = internal_last(iter);
-    if (last.node_ && !compare_keys(key, last.key())) {
-      // The key already exists in the tree, do nothing.
-      return {last, false};
-    }
-  }
-  return {internal_emplace(iter, std::forward<Args>(args)...), true};
-}
-
-template <typename P>
-template <typename K, typename... Args>
-inline auto btree<P>::insert_hint_unique(iterator position, const K &key,
-                                         Args &&... args)
-    -> std::pair<iterator, bool> {
-  if (!empty()) {
-    if (position == end() || compare_keys(key, position.key())) {
-      if (position == begin() || compare_keys(std::prev(position).key(), key)) {
-        // prev.key() < key < position.key()
-        return {internal_emplace(position, std::forward<Args>(args)...), true};
-      }
-    } else if (compare_keys(position.key(), key)) {
-      ++position;
-      if (position == end() || compare_keys(key, position.key())) {
-        // {original `position`}.key() < key < {current `position`}.key()
-        return {internal_emplace(position, std::forward<Args>(args)...), true};
-      }
-    } else {
-      // position.key() == key
-      return {position, false};
-    }
-  }
-  return insert_unique(key, std::forward<Args>(args)...);
-}
-
-template <typename P>
-template <typename InputIterator, typename>
-void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, int) {
-  for (; b != e; ++b) {
-    insert_hint_unique(end(), params_type::key(*b), *b);
-  }
-}
-
-template <typename P>
-template <typename InputIterator>
-void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, char) {
-  for (; b != e; ++b) {
-    // Use a node handle to manage a temp slot.
-    auto node_handle =
-        CommonAccess::Construct<node_handle_type>(get_allocator(), *b);
-    slot_type *slot = CommonAccess::GetSlot(node_handle);
-    insert_hint_unique(end(), params_type::key(slot), slot);
-  }
-}
-
-template <typename P>
-template <typename ValueType>
-auto btree<P>::insert_multi(const key_type &key, ValueType &&v) -> iterator {
-  if (empty()) {
-    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
-  }
-
-  iterator iter = internal_upper_bound(key);
-  if (iter.node_ == nullptr) {
-    iter = end();
-  }
-  return internal_emplace(iter, std::forward<ValueType>(v));
-}
-
-template <typename P>
-template <typename ValueType>
-auto btree<P>::insert_hint_multi(iterator position, ValueType &&v) -> iterator {
-  if (!empty()) {
-    const key_type &key = params_type::key(v);
-    if (position == end() || !compare_keys(position.key(), key)) {
-      if (position == begin() ||
-          !compare_keys(key, std::prev(position).key())) {
-        // prev.key() <= key <= position.key()
-        return internal_emplace(position, std::forward<ValueType>(v));
-      }
-    } else {
-      ++position;
-      if (position == end() || !compare_keys(position.key(), key)) {
-        // {original `position`}.key() < key < {current `position`}.key()
-        return internal_emplace(position, std::forward<ValueType>(v));
-      }
-    }
-  }
-  return insert_multi(std::forward<ValueType>(v));
-}
-
-template <typename P>
-template <typename InputIterator>
-void btree<P>::insert_iterator_multi(InputIterator b, InputIterator e) {
-  for (; b != e; ++b) {
-    insert_hint_multi(end(), *b);
-  }
-}
-
-template <typename P>
-auto btree<P>::operator=(const btree &other) -> btree & {
-  if (this != &other) {
-    clear();
-
-    *mutable_key_comp() = other.key_comp();
-    if (absl::allocator_traits<
-            allocator_type>::propagate_on_container_copy_assignment::value) {
-      *mutable_allocator() = other.allocator();
-    }
-
-    copy_or_move_values_in_order(other);
-  }
-  return *this;
-}
-
-template <typename P>
-auto btree<P>::operator=(btree &&other) noexcept -> btree & {
-  if (this != &other) {
-    clear();
-
-    using std::swap;
-    if (absl::allocator_traits<
-            allocator_type>::propagate_on_container_copy_assignment::value) {
-      swap(root_, other.root_);
-      // Note: `rightmost_` also contains the allocator and the key comparator.
-      swap(rightmost_, other.rightmost_);
-      swap(size_, other.size_);
-    } else {
-      if (allocator() == other.allocator()) {
-        swap(mutable_root(), other.mutable_root());
-        swap(*mutable_key_comp(), *other.mutable_key_comp());
-        swap(mutable_rightmost(), other.mutable_rightmost());
-        swap(size_, other.size_);
-      } else {
-        // We aren't allowed to propagate the allocator and the allocator is
-        // different so we can't take over its memory. We must move each element
-        // individually. We need both `other` and `this` to have `other`s key
-        // comparator while moving the values so we can't swap the key
-        // comparators.
-        *mutable_key_comp() = other.key_comp();
-        copy_or_move_values_in_order(other);
-      }
-    }
-  }
-  return *this;
-}
-
-template <typename P>
-auto btree<P>::erase(iterator iter) -> iterator {
-  iter.node_->value_destroy(iter.position_, mutable_allocator());
-  iter.update_generation();
-
-  const bool internal_delete = iter.node_->is_internal();
-  if (internal_delete) {
-    // Deletion of a value on an internal node. First, transfer the largest
-    // value from our left child here, then erase/rebalance from that position.
-    // We can get to the largest value from our left child by decrementing iter.
-    iterator internal_iter(iter);
-    --iter;
-    assert(iter.node_->is_leaf());
-    internal_iter.node_->transfer(internal_iter.position_, iter.position_,
-                                  iter.node_, mutable_allocator());
-  } else {
-    // Shift values after erased position in leaf. In the internal case, we
-    // don't need to do this because the leaf position is the end of the node.
-    const field_type transfer_from = iter.position_ + 1;
-    const field_type num_to_transfer = iter.node_->finish() - transfer_from;
-    iter.node_->transfer_n(num_to_transfer, iter.position_, transfer_from,
-                           iter.node_, mutable_allocator());
-  }
-  // Update node finish and container size.
-  iter.node_->set_finish(iter.node_->finish() - 1);
-  --size_;
-
-  // We want to return the next value after the one we just erased. If we
-  // erased from an internal node (internal_delete == true), then the next
-  // value is ++(++iter). If we erased from a leaf node (internal_delete ==
-  // false) then the next value is ++iter. Note that ++iter may point to an
-  // internal node and the value in the internal node may move to a leaf node
-  // (iter.node_) when rebalancing is performed at the leaf level.
-
-  iterator res = rebalance_after_delete(iter);
-
-  // If we erased from an internal node, advance the iterator.
-  if (internal_delete) {
-    ++res;
-  }
-  return res;
-}
-
-template <typename P>
-auto btree<P>::rebalance_after_delete(iterator iter) -> iterator {
-  // Merge/rebalance as we walk back up the tree.
-  iterator res(iter);
-  bool first_iteration = true;
-  for (;;) {
-    if (iter.node_ == root()) {
-      try_shrink();
-      if (empty()) {
-        return end();
-      }
-      break;
-    }
-    if (iter.node_->count() >= kMinNodeValues) {
-      break;
-    }
-    bool merged = try_merge_or_rebalance(&iter);
-    // On the first iteration, we should update `res` with `iter` because `res`
-    // may have been invalidated.
-    if (first_iteration) {
-      res = iter;
-      first_iteration = false;
-    }
-    if (!merged) {
-      break;
-    }
-    iter.position_ = iter.node_->position();
-    iter.node_ = iter.node_->parent();
-  }
-  res.update_generation();
-
-  // Adjust our return value. If we're pointing at the end of a node, advance
-  // the iterator.
-  if (res.position_ == res.node_->finish()) {
-    res.position_ = res.node_->finish() - 1;
-    ++res;
-  }
-
-  return res;
-}
-
-template <typename P>
-auto btree<P>::erase_range(iterator begin, iterator end)
-    -> std::pair<size_type, iterator> {
-  difference_type count = std::distance(begin, end);
-  assert(count >= 0);
-
-  if (count == 0) {
-    return {0, begin};
-  }
-
-  if (static_cast<size_type>(count) == size_) {
-    clear();
-    return {count, this->end()};
-  }
-
-  if (begin.node_ == end.node_) {
-    assert(end.position_ > begin.position_);
-    begin.node_->remove_values(begin.position_, end.position_ - begin.position_,
-                               mutable_allocator());
-    size_ -= count;
-    return {count, rebalance_after_delete(begin)};
-  }
-
-  const size_type target_size = size_ - count;
-  while (size_ > target_size) {
-    if (begin.node_->is_leaf()) {
-      const size_type remaining_to_erase = size_ - target_size;
-      const size_type remaining_in_node =
-          begin.node_->finish() - begin.position_;
-      const size_type to_erase =
-          (std::min)(remaining_to_erase, remaining_in_node);
-      begin.node_->remove_values(begin.position_, to_erase,
-                                 mutable_allocator());
-      size_ -= to_erase;
-      begin = rebalance_after_delete(begin);
-    } else {
-      begin = erase(begin);
-    }
-  }
-  begin.update_generation();
-  return {count, begin};
-}
-
-template <typename P>
-void btree<P>::clear() {
-  if (!empty()) {
-    node_type::clear_and_delete(root(), mutable_allocator());
-  }
-  mutable_root() = mutable_rightmost() = EmptyNode();
-  size_ = 0;
-}
-
-template <typename P>
-void btree<P>::swap(btree &other) {
-  using std::swap;
-  if (absl::allocator_traits<
-          allocator_type>::propagate_on_container_swap::value) {
-    // Note: `rightmost_` also contains the allocator and the key comparator.
-    swap(rightmost_, other.rightmost_);
-  } else {
-    // It's undefined behavior if the allocators are unequal here.
-    assert(allocator() == other.allocator());
-    swap(mutable_rightmost(), other.mutable_rightmost());
-    swap(*mutable_key_comp(), *other.mutable_key_comp());
-  }
-  swap(mutable_root(), other.mutable_root());
-  swap(size_, other.size_);
-}
-
-template <typename P>
-void btree<P>::verify() const {
-  assert(root() != nullptr);
-  assert(leftmost() != nullptr);
-  assert(rightmost() != nullptr);
-  assert(empty() || size() == internal_verify(root(), nullptr, nullptr));
-  assert(leftmost() == (++const_iterator(root(), -1)).node_);
-  assert(rightmost() == (--const_iterator(root(), root()->finish())).node_);
-  assert(leftmost()->is_leaf());
-  assert(rightmost()->is_leaf());
-}
-
-template <typename P>
-void btree<P>::rebalance_or_split(iterator *iter) {
-  node_type *&node = iter->node_;
-  int &insert_position = iter->position_;
-  assert(node->count() == node->max_count());
-  assert(kNodeSlots == node->max_count());
-
-  // First try to make room on the node by rebalancing.
-  node_type *parent = node->parent();
-  if (node != root()) {
-    if (node->position() > parent->start()) {
-      // Try rebalancing with our left sibling.
-      node_type *left = parent->child(node->position() - 1);
-      assert(left->max_count() == kNodeSlots);
-      if (left->count() < kNodeSlots) {
-        // We bias rebalancing based on the position being inserted. If we're
-        // inserting at the end of the right node then we bias rebalancing to
-        // fill up the left node.
-        int to_move = (kNodeSlots - left->count()) /
-                      (1 + (insert_position < static_cast<int>(kNodeSlots)));
-        to_move = (std::max)(1, to_move);
-
-        if (insert_position - to_move >= node->start() ||
-            left->count() + to_move < static_cast<int>(kNodeSlots)) {
-          left->rebalance_right_to_left(to_move, node, mutable_allocator());
-
-          assert(node->max_count() - node->count() == to_move);
-          insert_position = insert_position - to_move;
-          if (insert_position < node->start()) {
-            insert_position = insert_position + left->count() + 1;
-            node = left;
-          }
-
-          assert(node->count() < node->max_count());
-          return;
+                        return;
+                    }
+                    ++pos;
+                } while (pos > parent->finish());
+            }
         }
-      }
-    }
-
-    if (node->position() < parent->finish()) {
-      // Try rebalancing with our right sibling.
-      node_type *right = parent->child(node->position() + 1);
-      assert(right->max_count() == kNodeSlots);
-      if (right->count() < kNodeSlots) {
-        // We bias rebalancing based on the position being inserted. If we're
-        // inserting at the beginning of the left node then we bias rebalancing
-        // to fill up the right node.
-        int to_move = (static_cast<int>(kNodeSlots) - right->count()) /
-                      (1 + (insert_position > node->start()));
-        to_move = (std::max)(1, to_move);
-
-        if (insert_position <= node->finish() - to_move ||
-            right->count() + to_move < static_cast<int>(kNodeSlots)) {
-          node->rebalance_left_to_right(to_move, right, mutable_allocator());
-
-          if (insert_position > node->finish()) {
-            insert_position = insert_position - node->count() - 1;
-            node = right;
-          }
-
-          assert(node->count() < node->max_count());
-          return;
+
+        ////
+        // btree_iterator methods
+        template<typename N, typename R, typename P>
+        void btree_iterator<N, R, P>::increment_slow()
+        {
+            if (node_->is_leaf())
+            {
+                assert(position_ >= node_->finish());
+                btree_iterator save(*this);
+                while (position_ == node_->finish() && !node_->is_root())
+                {
+                    assert(node_->parent()->child(node_->position()) == node_);
+                    position_ = node_->position();
+                    node_ = node_->parent();
+                }
+                // TODO(ezb): assert we aren't incrementing end() instead of handling.
+                if (position_ == node_->finish())
+                {
+                    *this = save;
+                }
+            }
+            else
+            {
+                assert(position_ < node_->finish());
+                node_ = node_->child(position_ + 1);
+                while (node_->is_internal())
+                {
+                    node_ = node_->start_child();
+                }
+                position_ = node_->start();
+            }
+        }
+
+        template<typename N, typename R, typename P>
+        void btree_iterator<N, R, P>::decrement_slow()
+        {
+            if (node_->is_leaf())
+            {
+                assert(position_ <= -1);
+                btree_iterator save(*this);
+                while (position_ < node_->start() && !node_->is_root())
+                {
+                    assert(node_->parent()->child(node_->position()) == node_);
+                    position_ = node_->position() - 1;
+                    node_ = node_->parent();
+                }
+                // TODO(ezb): assert we aren't decrementing begin() instead of handling.
+                if (position_ < node_->start())
+                {
+                    *this = save;
+                }
+            }
+            else
+            {
+                assert(position_ >= node_->start());
+                node_ = node_->child(position_);
+                while (node_->is_internal())
+                {
+                    node_ = node_->child(node_->finish());
+                }
+                position_ = node_->finish() - 1;
+            }
         }
-      }
-    }
-
-    // Rebalancing failed, make sure there is room on the parent node for a new
-    // value.
-    assert(parent->max_count() == kNodeSlots);
-    if (parent->count() == kNodeSlots) {
-      iterator parent_iter(node->parent(), node->position());
-      rebalance_or_split(&parent_iter);
-    }
-  } else {
-    // Rebalancing not possible because this is the root node.
-    // Create a new root node and set the current root node as the child of the
-    // new root.
-    parent = new_internal_node(parent);
-    parent->set_generation(root()->generation());
-    parent->init_child(parent->start(), root());
-    mutable_root() = parent;
-    // If the former root was a leaf node, then it's now the rightmost node.
-    assert(parent->start_child()->is_internal() ||
-           parent->start_child() == rightmost());
-  }
-
-  // Split the node.
-  node_type *split_node;
-  if (node->is_leaf()) {
-    split_node = new_leaf_node(parent);
-    node->split(insert_position, split_node, mutable_allocator());
-    if (rightmost() == node) mutable_rightmost() = split_node;
-  } else {
-    split_node = new_internal_node(parent);
-    node->split(insert_position, split_node, mutable_allocator());
-  }
-
-  if (insert_position > node->finish()) {
-    insert_position = insert_position - node->count() - 1;
-    node = split_node;
-  }
-}
-
-template <typename P>
-void btree<P>::merge_nodes(node_type *left, node_type *right) {
-  left->merge(right, mutable_allocator());
-  if (rightmost() == right) mutable_rightmost() = left;
-}
-
-template <typename P>
-bool btree<P>::try_merge_or_rebalance(iterator *iter) {
-  node_type *parent = iter->node_->parent();
-  if (iter->node_->position() > parent->start()) {
-    // Try merging with our left sibling.
-    node_type *left = parent->child(iter->node_->position() - 1);
-    assert(left->max_count() == kNodeSlots);
-    if (1U + left->count() + iter->node_->count() <= kNodeSlots) {
-      iter->position_ += 1 + left->count();
-      merge_nodes(left, iter->node_);
-      iter->node_ = left;
-      return true;
-    }
-  }
-  if (iter->node_->position() < parent->finish()) {
-    // Try merging with our right sibling.
-    node_type *right = parent->child(iter->node_->position() + 1);
-    assert(right->max_count() == kNodeSlots);
-    if (1U + iter->node_->count() + right->count() <= kNodeSlots) {
-      merge_nodes(iter->node_, right);
-      return true;
-    }
-    // Try rebalancing with our right sibling. We don't perform rebalancing if
-    // we deleted the first element from iter->node_ and the node is not
-    // empty. This is a small optimization for the common pattern of deleting
-    // from the front of the tree.
-    if (right->count() > kMinNodeValues &&
-        (iter->node_->count() == 0 || iter->position_ > iter->node_->start())) {
-      int to_move = (right->count() - iter->node_->count()) / 2;
-      to_move = (std::min)(to_move, right->count() - 1);
-      iter->node_->rebalance_right_to_left(to_move, right, mutable_allocator());
-      return false;
-    }
-  }
-  if (iter->node_->position() > parent->start()) {
-    // Try rebalancing with our left sibling. We don't perform rebalancing if
-    // we deleted the last element from iter->node_ and the node is not
-    // empty. This is a small optimization for the common pattern of deleting
-    // from the back of the tree.
-    node_type *left = parent->child(iter->node_->position() - 1);
-    if (left->count() > kMinNodeValues &&
-        (iter->node_->count() == 0 ||
-         iter->position_ < iter->node_->finish())) {
-      int to_move = (left->count() - iter->node_->count()) / 2;
-      to_move = (std::min)(to_move, left->count() - 1);
-      left->rebalance_left_to_right(to_move, iter->node_, mutable_allocator());
-      iter->position_ += to_move;
-      return false;
-    }
-  }
-  return false;
-}
-
-template <typename P>
-void btree<P>::try_shrink() {
-  node_type *orig_root = root();
-  if (orig_root->count() > 0) {
-    return;
-  }
-  // Deleted the last item on the root node, shrink the height of the tree.
-  if (orig_root->is_leaf()) {
-    assert(size() == 0);
-    mutable_root() = mutable_rightmost() = EmptyNode();
-  } else {
-    node_type *child = orig_root->start_child();
-    child->make_root();
-    mutable_root() = child;
-  }
-  node_type::clear_and_delete(orig_root, mutable_allocator());
-}
-
-template <typename P>
-template <typename IterType>
-inline IterType btree<P>::internal_last(IterType iter) {
-  assert(iter.node_ != nullptr);
-  while (iter.position_ == iter.node_->finish()) {
-    iter.position_ = iter.node_->position();
-    iter.node_ = iter.node_->parent();
-    if (iter.node_->is_leaf()) {
-      iter.node_ = nullptr;
-      break;
-    }
-  }
-  iter.update_generation();
-  return iter;
-}
-
-template <typename P>
-template <typename... Args>
-inline auto btree<P>::internal_emplace(iterator iter, Args &&... args)
-    -> iterator {
-  if (iter.node_->is_internal()) {
-    // We can't insert on an internal node. Instead, we'll insert after the
-    // previous value which is guaranteed to be on a leaf node.
-    --iter;
-    ++iter.position_;
-  }
-  const field_type max_count = iter.node_->max_count();
-  allocator_type *alloc = mutable_allocator();
-  if (iter.node_->count() == max_count) {
-    // Make room in the leaf for the new item.
-    if (max_count < kNodeSlots) {
-      // Insertion into the root where the root is smaller than the full node
-      // size. Simply grow the size of the root node.
-      assert(iter.node_ == root());
-      iter.node_ =
-          new_leaf_root_node((std::min<int>)(kNodeSlots, 2 * max_count));
-      // Transfer the values from the old root to the new root.
-      node_type *old_root = root();
-      node_type *new_root = iter.node_;
-      new_root->transfer_n(old_root->count(), new_root->start(),
-                           old_root->start(), old_root, alloc);
-      new_root->set_finish(old_root->finish());
-      old_root->set_finish(old_root->start());
-      new_root->set_generation(old_root->generation());
-      node_type::clear_and_delete(old_root, alloc);
-      mutable_root() = mutable_rightmost() = new_root;
-    } else {
-      rebalance_or_split(&iter);
-    }
-  }
-  iter.node_->emplace_value(iter.position_, alloc, std::forward<Args>(args)...);
-  ++size_;
-  iter.update_generation();
-  return iter;
-}
-
-template <typename P>
-template <typename K>
-inline auto btree<P>::internal_locate(const K &key) const
-    -> SearchResult<iterator, is_key_compare_to::value> {
-  iterator iter(const_cast<node_type *>(root()));
-  for (;;) {
-    SearchResult<int, is_key_compare_to::value> res =
-        iter.node_->lower_bound(key, key_comp());
-    iter.position_ = res.value;
-    if (res.IsEq()) {
-      return {iter, MatchKind::kEq};
-    }
-    // Note: in the non-key-compare-to case, we don't need to walk all the way
-    // down the tree if the keys are equal, but determining equality would
-    // require doing an extra comparison on each node on the way down, and we
-    // will need to go all the way to the leaf node in the expected case.
-    if (iter.node_->is_leaf()) {
-      break;
-    }
-    iter.node_ = iter.node_->child(iter.position_);
-  }
-  // Note: in the non-key-compare-to case, the key may actually be equivalent
-  // here (and the MatchKind::kNe is ignored).
-  return {iter, MatchKind::kNe};
-}
-
-template <typename P>
-template <typename K>
-auto btree<P>::internal_lower_bound(const K &key) const
-    -> SearchResult<iterator, is_key_compare_to::value> {
-  if (!params_type::template can_have_multiple_equivalent_keys<K>()) {
-    SearchResult<iterator, is_key_compare_to::value> ret = internal_locate(key);
-    ret.value = internal_last(ret.value);
-    return ret;
-  }
-  iterator iter(const_cast<node_type *>(root()));
-  SearchResult<int, is_key_compare_to::value> res;
-  bool seen_eq = false;
-  for (;;) {
-    res = iter.node_->lower_bound(key, key_comp());
-    iter.position_ = res.value;
-    if (iter.node_->is_leaf()) {
-      break;
-    }
-    seen_eq = seen_eq || res.IsEq();
-    iter.node_ = iter.node_->child(iter.position_);
-  }
-  if (res.IsEq()) return {iter, MatchKind::kEq};
-  return {internal_last(iter), seen_eq ? MatchKind::kEq : MatchKind::kNe};
-}
-
-template <typename P>
-template <typename K>
-auto btree<P>::internal_upper_bound(const K &key) const -> iterator {
-  iterator iter(const_cast<node_type *>(root()));
-  for (;;) {
-    iter.position_ = iter.node_->upper_bound(key, key_comp());
-    if (iter.node_->is_leaf()) {
-      break;
-    }
-    iter.node_ = iter.node_->child(iter.position_);
-  }
-  return internal_last(iter);
-}
-
-template <typename P>
-template <typename K>
-auto btree<P>::internal_find(const K &key) const -> iterator {
-  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
-  if (res.HasMatch()) {
-    if (res.IsEq()) {
-      return res.value;
-    }
-  } else {
-    const iterator iter = internal_last(res.value);
-    if (iter.node_ != nullptr && !compare_keys(key, iter.key())) {
-      return iter;
-    }
-  }
-  return {nullptr, 0};
-}
-
-template <typename P>
-int btree<P>::internal_verify(const node_type *node, const key_type *lo,
-                              const key_type *hi) const {
-  assert(node->count() > 0);
-  assert(node->count() <= node->max_count());
-  if (lo) {
-    assert(!compare_keys(node->key(node->start()), *lo));
-  }
-  if (hi) {
-    assert(!compare_keys(*hi, node->key(node->finish() - 1)));
-  }
-  for (int i = node->start() + 1; i < node->finish(); ++i) {
-    assert(!compare_keys(node->key(i), node->key(i - 1)));
-  }
-  int count = node->count();
-  if (node->is_internal()) {
-    for (int i = node->start(); i <= node->finish(); ++i) {
-      assert(node->child(i) != nullptr);
-      assert(node->child(i)->parent() == node);
-      assert(node->child(i)->position() == i);
-      count += internal_verify(node->child(i),
-                               i == node->start() ? lo : &node->key(i - 1),
-                               i == node->finish() ? hi : &node->key(i));
-    }
-  }
-  return count;
-}
-
-struct btree_access {
-  template <typename BtreeContainer, typename Pred>
-  static auto erase_if(BtreeContainer &container, Pred pred)
-      -> typename BtreeContainer::size_type {
-    const auto initial_size = container.size();
-    auto &tree = container.tree_;
-    auto *alloc = tree.mutable_allocator();
-    for (auto it = container.begin(); it != container.end();) {
-      if (!pred(*it)) {
-        ++it;
-        continue;
-      }
-      auto *node = it.node_;
-      if (node->is_internal()) {
-        // Handle internal nodes normally.
-        it = container.erase(it);
-        continue;
-      }
-      // If this is a leaf node, then we do all the erases from this node
-      // at once before doing rebalancing.
-
-      // The current position to transfer slots to.
-      int to_pos = it.position_;
-      node->value_destroy(it.position_, alloc);
-      while (++it.position_ < node->finish()) {
-        it.update_generation();
-        if (pred(*it)) {
-          node->value_destroy(it.position_, alloc);
-        } else {
-          node->transfer(node->slot(to_pos++), node->slot(it.position_), alloc);
+
+        ////
+        // btree methods
+        template<typename P>
+        template<typename Btree>
+        void btree<P>::copy_or_move_values_in_order(Btree& other)
+        {
+            static_assert(std::is_same<btree, Btree>::value || std::is_same<const btree, Btree>::value, "Btree type must be same or const.");
+            assert(empty());
+
+            // We can avoid key comparisons because we know the order of the
+            // values is the same order we'll store them in.
+            auto iter = other.begin();
+            if (iter == other.end())
+                return;
+            insert_multi(iter.slot());
+            ++iter;
+            for (; iter != other.end(); ++iter)
+            {
+                // If the btree is not empty, we can just insert the new value at the end
+                // of the tree.
+                internal_emplace(end(), iter.slot());
+            }
+        }
+
+        template<typename P>
+        constexpr bool btree<P>::static_assert_validation()
+        {
+            static_assert(std::is_nothrow_copy_constructible<key_compare>::value, "Key comparison must be nothrow copy constructible");
+            static_assert(std::is_nothrow_copy_constructible<allocator_type>::value, "Allocator must be nothrow copy constructible");
+            static_assert(type_traits_internal::is_trivially_copyable<iterator>::value, "iterator not trivially copyable.");
+
+            // Note: We assert that kTargetValues, which is computed from
+            // Params::kTargetNodeSize, must fit the node_type::field_type.
+            static_assert(
+                kNodeSlots < (1 << (8 * sizeof(typename node_type::field_type))),
+                "target node size too large"
+            );
+
+            // Verify that key_compare returns an absl::{weak,strong}_ordering or bool.
+            static_assert(
+                compare_has_valid_result_type<key_compare, key_type>(),
+                "key comparison function must return absl::{weak,strong}_ordering or "
+                "bool."
+            );
+
+            // Test the assumption made in setting kNodeSlotSpace.
+            static_assert(node_type::MinimumOverhead() >= sizeof(void*) + 4, "node space assumption incorrect");
+
+            return true;
         }
-      }
-      const int num_deleted = node->finish() - to_pos;
-      tree.size_ -= num_deleted;
-      node->set_finish(to_pos);
-      it.position_ = to_pos;
-      it = tree.rebalance_after_delete(it);
-    }
-    return initial_size - container.size();
-  }
-};
+
+        template<typename P>
+        template<typename K>
+        auto btree<P>::lower_bound_equal(const K& key) const
+            -> std::pair<iterator, bool>
+        {
+            const SearchResult<iterator, is_key_compare_to::value> res =
+                internal_lower_bound(key);
+            const iterator lower = iterator(internal_end(res.value));
+            const bool equal = res.HasMatch() ? res.IsEq() : lower != end() && !compare_keys(key, lower.key());
+            return {lower, equal};
+        }
+
+        template<typename P>
+        template<typename K>
+        auto btree<P>::equal_range(const K& key) -> std::pair<iterator, iterator>
+        {
+            const std::pair<iterator, bool> lower_and_equal = lower_bound_equal(key);
+            const iterator lower = lower_and_equal.first;
+            if (!lower_and_equal.second)
+            {
+                return {lower, lower};
+            }
+
+            const iterator next = std::next(lower);
+            if (!params_type::template can_have_multiple_equivalent_keys<K>())
+            {
+                // The next iterator after lower must point to a key greater than `key`.
+                // Note: if this assert fails, then it may indicate that the comparator does
+                // not meet the equivalence requirements for Compare
+                // (see https://en.cppreference.com/w/cpp/named_req/Compare).
+                assert(next == end() || compare_keys(key, next.key()));
+                return {lower, next};
+            }
+            // Try once more to avoid the call to upper_bound() if there's only one
+            // equivalent key. This should prevent all calls to upper_bound() in cases of
+            // unique-containers with heterogeneous comparators in which all comparison
+            // operators have the same equivalence classes.
+            if (next == end() || compare_keys(key, next.key()))
+                return {lower, next};
+
+            // In this case, we need to call upper_bound() to avoid worst case O(N)
+            // behavior if we were to iterate over equal keys.
+            return {lower, upper_bound(key)};
+        }
+
+        template<typename P>
+        template<typename K, typename... Args>
+        auto btree<P>::insert_unique(const K& key, Args&&... args)
+            -> std::pair<iterator, bool>
+        {
+            if (empty())
+            {
+                mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
+            }
+
+            SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
+            iterator iter = res.value;
+
+            if (res.HasMatch())
+            {
+                if (res.IsEq())
+                {
+                    // The key already exists in the tree, do nothing.
+                    return {iter, false};
+                }
+            }
+            else
+            {
+                iterator last = internal_last(iter);
+                if (last.node_ && !compare_keys(key, last.key()))
+                {
+                    // The key already exists in the tree, do nothing.
+                    return {last, false};
+                }
+            }
+            return {internal_emplace(iter, std::forward<Args>(args)...), true};
+        }
+
+        template<typename P>
+        template<typename K, typename... Args>
+        inline auto btree<P>::insert_hint_unique(iterator position, const K& key, Args&&... args)
+            -> std::pair<iterator, bool>
+        {
+            if (!empty())
+            {
+                if (position == end() || compare_keys(key, position.key()))
+                {
+                    if (position == begin() || compare_keys(std::prev(position).key(), key))
+                    {
+                        // prev.key() < key < position.key()
+                        return {internal_emplace(position, std::forward<Args>(args)...), true};
+                    }
+                }
+                else if (compare_keys(position.key(), key))
+                {
+                    ++position;
+                    if (position == end() || compare_keys(key, position.key()))
+                    {
+                        // {original `position`}.key() < key < {current `position`}.key()
+                        return {internal_emplace(position, std::forward<Args>(args)...), true};
+                    }
+                }
+                else
+                {
+                    // position.key() == key
+                    return {position, false};
+                }
+            }
+            return insert_unique(key, std::forward<Args>(args)...);
+        }
+
+        template<typename P>
+        template<typename InputIterator, typename>
+        void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, int)
+        {
+            for (; b != e; ++b)
+            {
+                insert_hint_unique(end(), params_type::key(*b), *b);
+            }
+        }
+
+        template<typename P>
+        template<typename InputIterator>
+        void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, char)
+        {
+            for (; b != e; ++b)
+            {
+                // Use a node handle to manage a temp slot.
+                auto node_handle =
+                    CommonAccess::Construct<node_handle_type>(get_allocator(), *b);
+                slot_type* slot = CommonAccess::GetSlot(node_handle);
+                insert_hint_unique(end(), params_type::key(slot), slot);
+            }
+        }
+
+        template<typename P>
+        template<typename ValueType>
+        auto btree<P>::insert_multi(const key_type& key, ValueType&& v) -> iterator
+        {
+            if (empty())
+            {
+                mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
+            }
+
+            iterator iter = internal_upper_bound(key);
+            if (iter.node_ == nullptr)
+            {
+                iter = end();
+            }
+            return internal_emplace(iter, std::forward<ValueType>(v));
+        }
+
+        template<typename P>
+        template<typename ValueType>
+        auto btree<P>::insert_hint_multi(iterator position, ValueType&& v) -> iterator
+        {
+            if (!empty())
+            {
+                const key_type& key = params_type::key(v);
+                if (position == end() || !compare_keys(position.key(), key))
+                {
+                    if (position == begin() ||
+                        !compare_keys(key, std::prev(position).key()))
+                    {
+                        // prev.key() <= key <= position.key()
+                        return internal_emplace(position, std::forward<ValueType>(v));
+                    }
+                }
+                else
+                {
+                    ++position;
+                    if (position == end() || !compare_keys(position.key(), key))
+                    {
+                        // {original `position`}.key() < key < {current `position`}.key()
+                        return internal_emplace(position, std::forward<ValueType>(v));
+                    }
+                }
+            }
+            return insert_multi(std::forward<ValueType>(v));
+        }
+
+        template<typename P>
+        template<typename InputIterator>
+        void btree<P>::insert_iterator_multi(InputIterator b, InputIterator e)
+        {
+            for (; b != e; ++b)
+            {
+                insert_hint_multi(end(), *b);
+            }
+        }
+
+        template<typename P>
+        auto btree<P>::operator=(const btree& other) -> btree&
+        {
+            if (this != &other)
+            {
+                clear();
+
+                *mutable_key_comp() = other.key_comp();
+                if (absl::allocator_traits<
+                        allocator_type>::propagate_on_container_copy_assignment::value)
+                {
+                    *mutable_allocator() = other.allocator();
+                }
+
+                copy_or_move_values_in_order(other);
+            }
+            return *this;
+        }
+
+        template<typename P>
+        auto btree<P>::operator=(btree&& other) noexcept -> btree&
+        {
+            if (this != &other)
+            {
+                clear();
+
+                using std::swap;
+                if (absl::allocator_traits<
+                        allocator_type>::propagate_on_container_copy_assignment::value)
+                {
+                    swap(root_, other.root_);
+                    // Note: `rightmost_` also contains the allocator and the key comparator.
+                    swap(rightmost_, other.rightmost_);
+                    swap(size_, other.size_);
+                }
+                else
+                {
+                    if (allocator() == other.allocator())
+                    {
+                        swap(mutable_root(), other.mutable_root());
+                        swap(*mutable_key_comp(), *other.mutable_key_comp());
+                        swap(mutable_rightmost(), other.mutable_rightmost());
+                        swap(size_, other.size_);
+                    }
+                    else
+                    {
+                        // We aren't allowed to propagate the allocator and the allocator is
+                        // different so we can't take over its memory. We must move each element
+                        // individually. We need both `other` and `this` to have `other`s key
+                        // comparator while moving the values so we can't swap the key
+                        // comparators.
+                        *mutable_key_comp() = other.key_comp();
+                        copy_or_move_values_in_order(other);
+                    }
+                }
+            }
+            return *this;
+        }
+
+        template<typename P>
+        auto btree<P>::erase(iterator iter) -> iterator
+        {
+            iter.node_->value_destroy(iter.position_, mutable_allocator());
+            iter.update_generation();
+
+            const bool internal_delete = iter.node_->is_internal();
+            if (internal_delete)
+            {
+                // Deletion of a value on an internal node. First, transfer the largest
+                // value from our left child here, then erase/rebalance from that position.
+                // We can get to the largest value from our left child by decrementing iter.
+                iterator internal_iter(iter);
+                --iter;
+                assert(iter.node_->is_leaf());
+                internal_iter.node_->transfer(internal_iter.position_, iter.position_, iter.node_, mutable_allocator());
+            }
+            else
+            {
+                // Shift values after erased position in leaf. In the internal case, we
+                // don't need to do this because the leaf position is the end of the node.
+                const field_type transfer_from = iter.position_ + 1;
+                const field_type num_to_transfer = iter.node_->finish() - transfer_from;
+                iter.node_->transfer_n(num_to_transfer, iter.position_, transfer_from, iter.node_, mutable_allocator());
+            }
+            // Update node finish and container size.
+            iter.node_->set_finish(iter.node_->finish() - 1);
+            --size_;
+
+            // We want to return the next value after the one we just erased. If we
+            // erased from an internal node (internal_delete == true), then the next
+            // value is ++(++iter). If we erased from a leaf node (internal_delete ==
+            // false) then the next value is ++iter. Note that ++iter may point to an
+            // internal node and the value in the internal node may move to a leaf node
+            // (iter.node_) when rebalancing is performed at the leaf level.
+
+            iterator res = rebalance_after_delete(iter);
+
+            // If we erased from an internal node, advance the iterator.
+            if (internal_delete)
+            {
+                ++res;
+            }
+            return res;
+        }
+
+        template<typename P>
+        auto btree<P>::rebalance_after_delete(iterator iter) -> iterator
+        {
+            // Merge/rebalance as we walk back up the tree.
+            iterator res(iter);
+            bool first_iteration = true;
+            for (;;)
+            {
+                if (iter.node_ == root())
+                {
+                    try_shrink();
+                    if (empty())
+                    {
+                        return end();
+                    }
+                    break;
+                }
+                if (iter.node_->count() >= kMinNodeValues)
+                {
+                    break;
+                }
+                bool merged = try_merge_or_rebalance(&iter);
+                // On the first iteration, we should update `res` with `iter` because `res`
+                // may have been invalidated.
+                if (first_iteration)
+                {
+                    res = iter;
+                    first_iteration = false;
+                }
+                if (!merged)
+                {
+                    break;
+                }
+                iter.position_ = iter.node_->position();
+                iter.node_ = iter.node_->parent();
+            }
+            res.update_generation();
+
+            // Adjust our return value. If we're pointing at the end of a node, advance
+            // the iterator.
+            if (res.position_ == res.node_->finish())
+            {
+                res.position_ = res.node_->finish() - 1;
+                ++res;
+            }
+
+            return res;
+        }
+
+        template<typename P>
+        auto btree<P>::erase_range(iterator begin, iterator end)
+            -> std::pair<size_type, iterator>
+        {
+            difference_type count = std::distance(begin, end);
+            assert(count >= 0);
+
+            if (count == 0)
+            {
+                return {0, begin};
+            }
+
+            if (static_cast<size_type>(count) == size_)
+            {
+                clear();
+                return {count, this->end()};
+            }
+
+            if (begin.node_ == end.node_)
+            {
+                assert(end.position_ > begin.position_);
+                begin.node_->remove_values(begin.position_, end.position_ - begin.position_, mutable_allocator());
+                size_ -= count;
+                return {count, rebalance_after_delete(begin)};
+            }
+
+            const size_type target_size = size_ - count;
+            while (size_ > target_size)
+            {
+                if (begin.node_->is_leaf())
+                {
+                    const size_type remaining_to_erase = size_ - target_size;
+                    const size_type remaining_in_node =
+                        begin.node_->finish() - begin.position_;
+                    const size_type to_erase =
+                        (std::min)(remaining_to_erase, remaining_in_node);
+                    begin.node_->remove_values(begin.position_, to_erase, mutable_allocator());
+                    size_ -= to_erase;
+                    begin = rebalance_after_delete(begin);
+                }
+                else
+                {
+                    begin = erase(begin);
+                }
+            }
+            begin.update_generation();
+            return {count, begin};
+        }
+
+        template<typename P>
+        void btree<P>::clear()
+        {
+            if (!empty())
+            {
+                node_type::clear_and_delete(root(), mutable_allocator());
+            }
+            mutable_root() = mutable_rightmost() = EmptyNode();
+            size_ = 0;
+        }
+
+        template<typename P>
+        void btree<P>::swap(btree& other)
+        {
+            using std::swap;
+            if (absl::allocator_traits<
+                    allocator_type>::propagate_on_container_swap::value)
+            {
+                // Note: `rightmost_` also contains the allocator and the key comparator.
+                swap(rightmost_, other.rightmost_);
+            }
+            else
+            {
+                // It's undefined behavior if the allocators are unequal here.
+                assert(allocator() == other.allocator());
+                swap(mutable_rightmost(), other.mutable_rightmost());
+                swap(*mutable_key_comp(), *other.mutable_key_comp());
+            }
+            swap(mutable_root(), other.mutable_root());
+            swap(size_, other.size_);
+        }
+
+        template<typename P>
+        void btree<P>::verify() const
+        {
+            assert(root() != nullptr);
+            assert(leftmost() != nullptr);
+            assert(rightmost() != nullptr);
+            assert(empty() || size() == internal_verify(root(), nullptr, nullptr));
+            assert(leftmost() == (++const_iterator(root(), -1)).node_);
+            assert(rightmost() == (--const_iterator(root(), root()->finish())).node_);
+            assert(leftmost()->is_leaf());
+            assert(rightmost()->is_leaf());
+        }
+
+        template<typename P>
+        void btree<P>::rebalance_or_split(iterator* iter)
+        {
+            node_type*& node = iter->node_;
+            int& insert_position = iter->position_;
+            assert(node->count() == node->max_count());
+            assert(kNodeSlots == node->max_count());
+
+            // First try to make room on the node by rebalancing.
+            node_type* parent = node->parent();
+            if (node != root())
+            {
+                if (node->position() > parent->start())
+                {
+                    // Try rebalancing with our left sibling.
+                    node_type* left = parent->child(node->position() - 1);
+                    assert(left->max_count() == kNodeSlots);
+                    if (left->count() < kNodeSlots)
+                    {
+                        // We bias rebalancing based on the position being inserted. If we're
+                        // inserting at the end of the right node then we bias rebalancing to
+                        // fill up the left node.
+                        int to_move = (kNodeSlots - left->count()) /
+                                      (1 + (insert_position < static_cast<int>(kNodeSlots)));
+                        to_move = (std::max)(1, to_move);
+
+                        if (insert_position - to_move >= node->start() ||
+                            left->count() + to_move < static_cast<int>(kNodeSlots))
+                        {
+                            left->rebalance_right_to_left(to_move, node, mutable_allocator());
+
+                            assert(node->max_count() - node->count() == to_move);
+                            insert_position = insert_position - to_move;
+                            if (insert_position < node->start())
+                            {
+                                insert_position = insert_position + left->count() + 1;
+                                node = left;
+                            }
+
+                            assert(node->count() < node->max_count());
+                            return;
+                        }
+                    }
+                }
+
+                if (node->position() < parent->finish())
+                {
+                    // Try rebalancing with our right sibling.
+                    node_type* right = parent->child(node->position() + 1);
+                    assert(right->max_count() == kNodeSlots);
+                    if (right->count() < kNodeSlots)
+                    {
+                        // We bias rebalancing based on the position being inserted. If we're
+                        // inserting at the beginning of the left node then we bias rebalancing
+                        // to fill up the right node.
+                        int to_move = (static_cast<int>(kNodeSlots) - right->count()) /
+                                      (1 + (insert_position > node->start()));
+                        to_move = (std::max)(1, to_move);
+
+                        if (insert_position <= node->finish() - to_move ||
+                            right->count() + to_move < static_cast<int>(kNodeSlots))
+                        {
+                            node->rebalance_left_to_right(to_move, right, mutable_allocator());
+
+                            if (insert_position > node->finish())
+                            {
+                                insert_position = insert_position - node->count() - 1;
+                                node = right;
+                            }
+
+                            assert(node->count() < node->max_count());
+                            return;
+                        }
+                    }
+                }
+
+                // Rebalancing failed, make sure there is room on the parent node for a new
+                // value.
+                assert(parent->max_count() == kNodeSlots);
+                if (parent->count() == kNodeSlots)
+                {
+                    iterator parent_iter(node->parent(), node->position());
+                    rebalance_or_split(&parent_iter);
+                }
+            }
+            else
+            {
+                // Rebalancing not possible because this is the root node.
+                // Create a new root node and set the current root node as the child of the
+                // new root.
+                parent = new_internal_node(parent);
+                parent->set_generation(root()->generation());
+                parent->init_child(parent->start(), root());
+                mutable_root() = parent;
+                // If the former root was a leaf node, then it's now the rightmost node.
+                assert(parent->start_child()->is_internal() || parent->start_child() == rightmost());
+            }
+
+            // Split the node.
+            node_type* split_node;
+            if (node->is_leaf())
+            {
+                split_node = new_leaf_node(parent);
+                node->split(insert_position, split_node, mutable_allocator());
+                if (rightmost() == node)
+                    mutable_rightmost() = split_node;
+            }
+            else
+            {
+                split_node = new_internal_node(parent);
+                node->split(insert_position, split_node, mutable_allocator());
+            }
+
+            if (insert_position > node->finish())
+            {
+                insert_position = insert_position - node->count() - 1;
+                node = split_node;
+            }
+        }
+
+        template<typename P>
+        void btree<P>::merge_nodes(node_type* left, node_type* right)
+        {
+            left->merge(right, mutable_allocator());
+            if (rightmost() == right)
+                mutable_rightmost() = left;
+        }
+
+        template<typename P>
+        bool btree<P>::try_merge_or_rebalance(iterator* iter)
+        {
+            node_type* parent = iter->node_->parent();
+            if (iter->node_->position() > parent->start())
+            {
+                // Try merging with our left sibling.
+                node_type* left = parent->child(iter->node_->position() - 1);
+                assert(left->max_count() == kNodeSlots);
+                if (1U + left->count() + iter->node_->count() <= kNodeSlots)
+                {
+                    iter->position_ += 1 + left->count();
+                    merge_nodes(left, iter->node_);
+                    iter->node_ = left;
+                    return true;
+                }
+            }
+            if (iter->node_->position() < parent->finish())
+            {
+                // Try merging with our right sibling.
+                node_type* right = parent->child(iter->node_->position() + 1);
+                assert(right->max_count() == kNodeSlots);
+                if (1U + iter->node_->count() + right->count() <= kNodeSlots)
+                {
+                    merge_nodes(iter->node_, right);
+                    return true;
+                }
+                // Try rebalancing with our right sibling. We don't perform rebalancing if
+                // we deleted the first element from iter->node_ and the node is not
+                // empty. This is a small optimization for the common pattern of deleting
+                // from the front of the tree.
+                if (right->count() > kMinNodeValues &&
+                    (iter->node_->count() == 0 || iter->position_ > iter->node_->start()))
+                {
+                    int to_move = (right->count() - iter->node_->count()) / 2;
+                    to_move = (std::min)(to_move, right->count() - 1);
+                    iter->node_->rebalance_right_to_left(to_move, right, mutable_allocator());
+                    return false;
+                }
+            }
+            if (iter->node_->position() > parent->start())
+            {
+                // Try rebalancing with our left sibling. We don't perform rebalancing if
+                // we deleted the last element from iter->node_ and the node is not
+                // empty. This is a small optimization for the common pattern of deleting
+                // from the back of the tree.
+                node_type* left = parent->child(iter->node_->position() - 1);
+                if (left->count() > kMinNodeValues &&
+                    (iter->node_->count() == 0 ||
+                     iter->position_ < iter->node_->finish()))
+                {
+                    int to_move = (left->count() - iter->node_->count()) / 2;
+                    to_move = (std::min)(to_move, left->count() - 1);
+                    left->rebalance_left_to_right(to_move, iter->node_, mutable_allocator());
+                    iter->position_ += to_move;
+                    return false;
+                }
+            }
+            return false;
+        }
+
+        template<typename P>
+        void btree<P>::try_shrink()
+        {
+            node_type* orig_root = root();
+            if (orig_root->count() > 0)
+            {
+                return;
+            }
+            // Deleted the last item on the root node, shrink the height of the tree.
+            if (orig_root->is_leaf())
+            {
+                assert(size() == 0);
+                mutable_root() = mutable_rightmost() = EmptyNode();
+            }
+            else
+            {
+                node_type* child = orig_root->start_child();
+                child->make_root();
+                mutable_root() = child;
+            }
+            node_type::clear_and_delete(orig_root, mutable_allocator());
+        }
+
+        template<typename P>
+        template<typename IterType>
+        inline IterType btree<P>::internal_last(IterType iter)
+        {
+            assert(iter.node_ != nullptr);
+            while (iter.position_ == iter.node_->finish())
+            {
+                iter.position_ = iter.node_->position();
+                iter.node_ = iter.node_->parent();
+                if (iter.node_->is_leaf())
+                {
+                    iter.node_ = nullptr;
+                    break;
+                }
+            }
+            iter.update_generation();
+            return iter;
+        }
+
+        template<typename P>
+        template<typename... Args>
+        inline auto btree<P>::internal_emplace(iterator iter, Args&&... args)
+            -> iterator
+        {
+            if (iter.node_->is_internal())
+            {
+                // We can't insert on an internal node. Instead, we'll insert after the
+                // previous value which is guaranteed to be on a leaf node.
+                --iter;
+                ++iter.position_;
+            }
+            const field_type max_count = iter.node_->max_count();
+            allocator_type* alloc = mutable_allocator();
+            if (iter.node_->count() == max_count)
+            {
+                // Make room in the leaf for the new item.
+                if (max_count < kNodeSlots)
+                {
+                    // Insertion into the root where the root is smaller than the full node
+                    // size. Simply grow the size of the root node.
+                    assert(iter.node_ == root());
+                    iter.node_ =
+                        new_leaf_root_node((std::min<int>)(kNodeSlots, 2 * max_count));
+                    // Transfer the values from the old root to the new root.
+                    node_type* old_root = root();
+                    node_type* new_root = iter.node_;
+                    new_root->transfer_n(old_root->count(), new_root->start(), old_root->start(), old_root, alloc);
+                    new_root->set_finish(old_root->finish());
+                    old_root->set_finish(old_root->start());
+                    new_root->set_generation(old_root->generation());
+                    node_type::clear_and_delete(old_root, alloc);
+                    mutable_root() = mutable_rightmost() = new_root;
+                }
+                else
+                {
+                    rebalance_or_split(&iter);
+                }
+            }
+            iter.node_->emplace_value(iter.position_, alloc, std::forward<Args>(args)...);
+            ++size_;
+            iter.update_generation();
+            return iter;
+        }
+
+        template<typename P>
+        template<typename K>
+        inline auto btree<P>::internal_locate(const K& key) const
+            -> SearchResult<iterator, is_key_compare_to::value>
+        {
+            iterator iter(const_cast<node_type*>(root()));
+            for (;;)
+            {
+                SearchResult<int, is_key_compare_to::value> res =
+                    iter.node_->lower_bound(key, key_comp());
+                iter.position_ = res.value;
+                if (res.IsEq())
+                {
+                    return {iter, MatchKind::kEq};
+                }
+                // Note: in the non-key-compare-to case, we don't need to walk all the way
+                // down the tree if the keys are equal, but determining equality would
+                // require doing an extra comparison on each node on the way down, and we
+                // will need to go all the way to the leaf node in the expected case.
+                if (iter.node_->is_leaf())
+                {
+                    break;
+                }
+                iter.node_ = iter.node_->child(iter.position_);
+            }
+            // Note: in the non-key-compare-to case, the key may actually be equivalent
+            // here (and the MatchKind::kNe is ignored).
+            return {iter, MatchKind::kNe};
+        }
+
+        template<typename P>
+        template<typename K>
+        auto btree<P>::internal_lower_bound(const K& key) const
+            -> SearchResult<iterator, is_key_compare_to::value>
+        {
+            if (!params_type::template can_have_multiple_equivalent_keys<K>())
+            {
+                SearchResult<iterator, is_key_compare_to::value> ret = internal_locate(key);
+                ret.value = internal_last(ret.value);
+                return ret;
+            }
+            iterator iter(const_cast<node_type*>(root()));
+            SearchResult<int, is_key_compare_to::value> res;
+            bool seen_eq = false;
+            for (;;)
+            {
+                res = iter.node_->lower_bound(key, key_comp());
+                iter.position_ = res.value;
+                if (iter.node_->is_leaf())
+                {
+                    break;
+                }
+                seen_eq = seen_eq || res.IsEq();
+                iter.node_ = iter.node_->child(iter.position_);
+            }
+            if (res.IsEq())
+                return {iter, MatchKind::kEq};
+            return {internal_last(iter), seen_eq ? MatchKind::kEq : MatchKind::kNe};
+        }
+
+        template<typename P>
+        template<typename K>
+        auto btree<P>::internal_upper_bound(const K& key) const -> iterator
+        {
+            iterator iter(const_cast<node_type*>(root()));
+            for (;;)
+            {
+                iter.position_ = iter.node_->upper_bound(key, key_comp());
+                if (iter.node_->is_leaf())
+                {
+                    break;
+                }
+                iter.node_ = iter.node_->child(iter.position_);
+            }
+            return internal_last(iter);
+        }
+
+        template<typename P>
+        template<typename K>
+        auto btree<P>::internal_find(const K& key) const -> iterator
+        {
+            SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
+            if (res.HasMatch())
+            {
+                if (res.IsEq())
+                {
+                    return res.value;
+                }
+            }
+            else
+            {
+                const iterator iter = internal_last(res.value);
+                if (iter.node_ != nullptr && !compare_keys(key, iter.key()))
+                {
+                    return iter;
+                }
+            }
+            return {nullptr, 0};
+        }
+
+        template<typename P>
+        int btree<P>::internal_verify(const node_type* node, const key_type* lo, const key_type* hi) const
+        {
+            assert(node->count() > 0);
+            assert(node->count() <= node->max_count());
+            if (lo)
+            {
+                assert(!compare_keys(node->key(node->start()), *lo));
+            }
+            if (hi)
+            {
+                assert(!compare_keys(*hi, node->key(node->finish() - 1)));
+            }
+            for (int i = node->start() + 1; i < node->finish(); ++i)
+            {
+                assert(!compare_keys(node->key(i), node->key(i - 1)));
+            }
+            int count = node->count();
+            if (node->is_internal())
+            {
+                for (int i = node->start(); i <= node->finish(); ++i)
+                {
+                    assert(node->child(i) != nullptr);
+                    assert(node->child(i)->parent() == node);
+                    assert(node->child(i)->position() == i);
+                    count += internal_verify(node->child(i), i == node->start() ? lo : &node->key(i - 1), i == node->finish() ? hi : &node->key(i));
+                }
+            }
+            return count;
+        }
+
+        struct btree_access
+        {
+            template<typename BtreeContainer, typename Pred>
+            static auto erase_if(BtreeContainer& container, Pred pred)
+                -> typename BtreeContainer::size_type
+            {
+                const auto initial_size = container.size();
+                auto& tree = container.tree_;
+                auto* alloc = tree.mutable_allocator();
+                for (auto it = container.begin(); it != container.end();)
+                {
+                    if (!pred(*it))
+                    {
+                        ++it;
+                        continue;
+                    }
+                    auto* node = it.node_;
+                    if (node->is_internal())
+                    {
+                        // Handle internal nodes normally.
+                        it = container.erase(it);
+                        continue;
+                    }
+                    // If this is a leaf node, then we do all the erases from this node
+                    // at once before doing rebalancing.
+
+                    // The current position to transfer slots to.
+                    int to_pos = it.position_;
+                    node->value_destroy(it.position_, alloc);
+                    while (++it.position_ < node->finish())
+                    {
+                        it.update_generation();
+                        if (pred(*it))
+                        {
+                            node->value_destroy(it.position_, alloc);
+                        }
+                        else
+                        {
+                            node->transfer(node->slot(to_pos++), node->slot(it.position_), alloc);
+                        }
+                    }
+                    const int num_deleted = node->finish() - to_pos;
+                    tree.size_ -= num_deleted;
+                    node->set_finish(to_pos);
+                    it.position_ = to_pos;
+                    it = tree.rebalance_after_delete(it);
+                }
+                return initial_size - container.size();
+            }
+        };
 
 #undef ABSL_BTREE_ENABLE_GENERATIONS
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_BTREE_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/btree_container.h b/CAPI/cpp/grpc/include/absl/container/internal/btree_container.h
index fc2f740..679b1ae 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/btree_container.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/btree_container.h
@@ -27,673 +27,837 @@
 #include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// A common base class for btree_set, btree_map, btree_multiset, and
-// btree_multimap.
-template <typename Tree>
-class btree_container {
-  using params_type = typename Tree::params_type;
-
- protected:
-  // Alias used for heterogeneous lookup functions.
-  // `key_arg<K>` evaluates to `K` when the functors are transparent and to
-  // `key_type` otherwise. It permits template argument deduction on `K` for the
-  // transparent case.
-  template <class K>
-  using key_arg =
-      typename KeyArg<params_type::kIsKeyCompareTransparent>::template type<
-          K, typename Tree::key_type>;
-
- public:
-  using key_type = typename Tree::key_type;
-  using value_type = typename Tree::value_type;
-  using size_type = typename Tree::size_type;
-  using difference_type = typename Tree::difference_type;
-  using key_compare = typename Tree::original_key_compare;
-  using value_compare = typename Tree::value_compare;
-  using allocator_type = typename Tree::allocator_type;
-  using reference = typename Tree::reference;
-  using const_reference = typename Tree::const_reference;
-  using pointer = typename Tree::pointer;
-  using const_pointer = typename Tree::const_pointer;
-  using iterator = typename Tree::iterator;
-  using const_iterator = typename Tree::const_iterator;
-  using reverse_iterator = typename Tree::reverse_iterator;
-  using const_reverse_iterator = typename Tree::const_reverse_iterator;
-  using node_type = typename Tree::node_handle_type;
-
-  // Constructors/assignments.
-  btree_container() : tree_(key_compare(), allocator_type()) {}
-  explicit btree_container(const key_compare &comp,
-                           const allocator_type &alloc = allocator_type())
-      : tree_(comp, alloc) {}
-  explicit btree_container(const allocator_type &alloc)
-      : tree_(key_compare(), alloc) {}
-
-  btree_container(const btree_container &other)
-      : btree_container(other, absl::allocator_traits<allocator_type>::
-                                   select_on_container_copy_construction(
-                                       other.get_allocator())) {}
-  btree_container(const btree_container &other, const allocator_type &alloc)
-      : tree_(other.tree_, alloc) {}
-
-  btree_container(btree_container &&other) noexcept(
-      std::is_nothrow_move_constructible<Tree>::value) = default;
-  btree_container(btree_container &&other, const allocator_type &alloc)
-      : tree_(std::move(other.tree_), alloc) {}
-
-  btree_container &operator=(const btree_container &other) = default;
-  btree_container &operator=(btree_container &&other) noexcept(
-      std::is_nothrow_move_assignable<Tree>::value) = default;
-
-  // Iterator routines.
-  iterator begin() { return tree_.begin(); }
-  const_iterator begin() const { return tree_.begin(); }
-  const_iterator cbegin() const { return tree_.begin(); }
-  iterator end() { return tree_.end(); }
-  const_iterator end() const { return tree_.end(); }
-  const_iterator cend() const { return tree_.end(); }
-  reverse_iterator rbegin() { return tree_.rbegin(); }
-  const_reverse_iterator rbegin() const { return tree_.rbegin(); }
-  const_reverse_iterator crbegin() const { return tree_.rbegin(); }
-  reverse_iterator rend() { return tree_.rend(); }
-  const_reverse_iterator rend() const { return tree_.rend(); }
-  const_reverse_iterator crend() const { return tree_.rend(); }
-
-  // Lookup routines.
-  template <typename K = key_type>
-  size_type count(const key_arg<K> &key) const {
-    auto equal_range = this->equal_range(key);
-    return std::distance(equal_range.first, equal_range.second);
-  }
-  template <typename K = key_type>
-  iterator find(const key_arg<K> &key) {
-    return tree_.find(key);
-  }
-  template <typename K = key_type>
-  const_iterator find(const key_arg<K> &key) const {
-    return tree_.find(key);
-  }
-  template <typename K = key_type>
-  bool contains(const key_arg<K> &key) const {
-    return find(key) != end();
-  }
-  template <typename K = key_type>
-  iterator lower_bound(const key_arg<K> &key) {
-    return tree_.lower_bound(key);
-  }
-  template <typename K = key_type>
-  const_iterator lower_bound(const key_arg<K> &key) const {
-    return tree_.lower_bound(key);
-  }
-  template <typename K = key_type>
-  iterator upper_bound(const key_arg<K> &key) {
-    return tree_.upper_bound(key);
-  }
-  template <typename K = key_type>
-  const_iterator upper_bound(const key_arg<K> &key) const {
-    return tree_.upper_bound(key);
-  }
-  template <typename K = key_type>
-  std::pair<iterator, iterator> equal_range(const key_arg<K> &key) {
-    return tree_.equal_range(key);
-  }
-  template <typename K = key_type>
-  std::pair<const_iterator, const_iterator> equal_range(
-      const key_arg<K> &key) const {
-    return tree_.equal_range(key);
-  }
-
-  // Deletion routines. Note that there is also a deletion routine that is
-  // specific to btree_set_container/btree_multiset_container.
-
-  // Erase the specified iterator from the btree. The iterator must be valid
-  // (i.e. not equal to end()).  Return an iterator pointing to the node after
-  // the one that was erased (or end() if none exists).
-  iterator erase(const_iterator iter) { return tree_.erase(iterator(iter)); }
-  iterator erase(iterator iter) { return tree_.erase(iter); }
-  iterator erase(const_iterator first, const_iterator last) {
-    return tree_.erase_range(iterator(first), iterator(last)).second;
-  }
-  template <typename K = key_type>
-  size_type erase(const key_arg<K> &key) {
-    auto equal_range = this->equal_range(key);
-    return tree_.erase_range(equal_range.first, equal_range.second).first;
-  }
-
-  // Extract routines.
-  node_type extract(iterator position) {
-    // Use Construct instead of Transfer because the rebalancing code will
-    // destroy the slot later.
-    auto node =
-        CommonAccess::Construct<node_type>(get_allocator(), position.slot());
-    erase(position);
-    return node;
-  }
-  node_type extract(const_iterator position) {
-    return extract(iterator(position));
-  }
-
-  // Utility routines.
-  ABSL_ATTRIBUTE_REINITIALIZES void clear() { tree_.clear(); }
-  void swap(btree_container &other) { tree_.swap(other.tree_); }
-  void verify() const { tree_.verify(); }
-
-  // Size routines.
-  size_type size() const { return tree_.size(); }
-  size_type max_size() const { return tree_.max_size(); }
-  bool empty() const { return tree_.empty(); }
-
-  friend bool operator==(const btree_container &x, const btree_container &y) {
-    if (x.size() != y.size()) return false;
-    return std::equal(x.begin(), x.end(), y.begin());
-  }
-
-  friend bool operator!=(const btree_container &x, const btree_container &y) {
-    return !(x == y);
-  }
-
-  friend bool operator<(const btree_container &x, const btree_container &y) {
-    return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
-  }
-
-  friend bool operator>(const btree_container &x, const btree_container &y) {
-    return y < x;
-  }
-
-  friend bool operator<=(const btree_container &x, const btree_container &y) {
-    return !(y < x);
-  }
-
-  friend bool operator>=(const btree_container &x, const btree_container &y) {
-    return !(x < y);
-  }
-
-  // The allocator used by the btree.
-  allocator_type get_allocator() const { return tree_.get_allocator(); }
-
-  // The key comparator used by the btree.
-  key_compare key_comp() const { return key_compare(tree_.key_comp()); }
-  value_compare value_comp() const { return tree_.value_comp(); }
-
-  // Support absl::Hash.
-  template <typename State>
-  friend State AbslHashValue(State h, const btree_container &b) {
-    for (const auto &v : b) {
-      h = State::combine(std::move(h), v);
-    }
-    return State::combine(std::move(h), b.size());
-  }
-
- protected:
-  friend struct btree_access;
-  Tree tree_;
-};
-
-// A common base class for btree_set and btree_map.
-template <typename Tree>
-class btree_set_container : public btree_container<Tree> {
-  using super_type = btree_container<Tree>;
-  using params_type = typename Tree::params_type;
-  using init_type = typename params_type::init_type;
-  using is_key_compare_to = typename params_type::is_key_compare_to;
-  friend class BtreeNodePeer;
-
- protected:
-  template <class K>
-  using key_arg = typename super_type::template key_arg<K>;
-
- public:
-  using key_type = typename Tree::key_type;
-  using value_type = typename Tree::value_type;
-  using size_type = typename Tree::size_type;
-  using key_compare = typename Tree::original_key_compare;
-  using allocator_type = typename Tree::allocator_type;
-  using iterator = typename Tree::iterator;
-  using const_iterator = typename Tree::const_iterator;
-  using node_type = typename super_type::node_type;
-  using insert_return_type = InsertReturnType<iterator, node_type>;
-
-  // Inherit constructors.
-  using super_type::super_type;
-  btree_set_container() {}
-
-  // Range constructors.
-  template <class InputIterator>
-  btree_set_container(InputIterator b, InputIterator e,
-                      const key_compare &comp = key_compare(),
-                      const allocator_type &alloc = allocator_type())
-      : super_type(comp, alloc) {
-    insert(b, e);
-  }
-  template <class InputIterator>
-  btree_set_container(InputIterator b, InputIterator e,
-                      const allocator_type &alloc)
-      : btree_set_container(b, e, key_compare(), alloc) {}
-
-  // Initializer list constructors.
-  btree_set_container(std::initializer_list<init_type> init,
-                      const key_compare &comp = key_compare(),
-                      const allocator_type &alloc = allocator_type())
-      : btree_set_container(init.begin(), init.end(), comp, alloc) {}
-  btree_set_container(std::initializer_list<init_type> init,
-                      const allocator_type &alloc)
-      : btree_set_container(init.begin(), init.end(), alloc) {}
-
-  // Insertion routines.
-  std::pair<iterator, bool> insert(const value_type &v) {
-    return this->tree_.insert_unique(params_type::key(v), v);
-  }
-  std::pair<iterator, bool> insert(value_type &&v) {
-    return this->tree_.insert_unique(params_type::key(v), std::move(v));
-  }
-  template <typename... Args>
-  std::pair<iterator, bool> emplace(Args &&... args) {
-    // Use a node handle to manage a temp slot.
-    auto node = CommonAccess::Construct<node_type>(this->get_allocator(),
-                                                   std::forward<Args>(args)...);
-    auto *slot = CommonAccess::GetSlot(node);
-    return this->tree_.insert_unique(params_type::key(slot), slot);
-  }
-  iterator insert(const_iterator hint, const value_type &v) {
-    return this->tree_
-        .insert_hint_unique(iterator(hint), params_type::key(v), v)
-        .first;
-  }
-  iterator insert(const_iterator hint, value_type &&v) {
-    return this->tree_
-        .insert_hint_unique(iterator(hint), params_type::key(v), std::move(v))
-        .first;
-  }
-  template <typename... Args>
-  iterator emplace_hint(const_iterator hint, Args &&... args) {
-    // Use a node handle to manage a temp slot.
-    auto node = CommonAccess::Construct<node_type>(this->get_allocator(),
-                                                   std::forward<Args>(args)...);
-    auto *slot = CommonAccess::GetSlot(node);
-    return this->tree_
-        .insert_hint_unique(iterator(hint), params_type::key(slot), slot)
-        .first;
-  }
-  template <typename InputIterator>
-  void insert(InputIterator b, InputIterator e) {
-    this->tree_.insert_iterator_unique(b, e, 0);
-  }
-  void insert(std::initializer_list<init_type> init) {
-    this->tree_.insert_iterator_unique(init.begin(), init.end(), 0);
-  }
-  insert_return_type insert(node_type &&node) {
-    if (!node) return {this->end(), false, node_type()};
-    std::pair<iterator, bool> res =
-        this->tree_.insert_unique(params_type::key(CommonAccess::GetSlot(node)),
-                                  CommonAccess::GetSlot(node));
-    if (res.second) {
-      CommonAccess::Destroy(&node);
-      return {res.first, true, node_type()};
-    } else {
-      return {res.first, false, std::move(node)};
-    }
-  }
-  iterator insert(const_iterator hint, node_type &&node) {
-    if (!node) return this->end();
-    std::pair<iterator, bool> res = this->tree_.insert_hint_unique(
-        iterator(hint), params_type::key(CommonAccess::GetSlot(node)),
-        CommonAccess::GetSlot(node));
-    if (res.second) CommonAccess::Destroy(&node);
-    return res.first;
-  }
-
-  // Node extraction routines.
-  template <typename K = key_type>
-  node_type extract(const key_arg<K> &key) {
-    const std::pair<iterator, bool> lower_and_equal =
-        this->tree_.lower_bound_equal(key);
-    return lower_and_equal.second ? extract(lower_and_equal.first)
-                                  : node_type();
-  }
-  using super_type::extract;
-
-  // Merge routines.
-  // Moves elements from `src` into `this`. If the element already exists in
-  // `this`, it is left unmodified in `src`.
-  template <
-      typename T,
-      typename absl::enable_if_t<
-          absl::conjunction<
-              std::is_same<value_type, typename T::value_type>,
-              std::is_same<allocator_type, typename T::allocator_type>,
-              std::is_same<typename params_type::is_map_container,
-                           typename T::params_type::is_map_container>>::value,
-          int> = 0>
-  void merge(btree_container<T> &src) {  // NOLINT
-    for (auto src_it = src.begin(); src_it != src.end();) {
-      if (insert(std::move(params_type::element(src_it.slot()))).second) {
-        src_it = src.erase(src_it);
-      } else {
-        ++src_it;
-      }
-    }
-  }
-
-  template <
-      typename T,
-      typename absl::enable_if_t<
-          absl::conjunction<
-              std::is_same<value_type, typename T::value_type>,
-              std::is_same<allocator_type, typename T::allocator_type>,
-              std::is_same<typename params_type::is_map_container,
-                           typename T::params_type::is_map_container>>::value,
-          int> = 0>
-  void merge(btree_container<T> &&src) {
-    merge(src);
-  }
-};
-
-// Base class for btree_map.
-template <typename Tree>
-class btree_map_container : public btree_set_container<Tree> {
-  using super_type = btree_set_container<Tree>;
-  using params_type = typename Tree::params_type;
-  friend class BtreeNodePeer;
-
- private:
-  template <class K>
-  using key_arg = typename super_type::template key_arg<K>;
-
- public:
-  using key_type = typename Tree::key_type;
-  using mapped_type = typename params_type::mapped_type;
-  using value_type = typename Tree::value_type;
-  using key_compare = typename Tree::original_key_compare;
-  using allocator_type = typename Tree::allocator_type;
-  using iterator = typename Tree::iterator;
-  using const_iterator = typename Tree::const_iterator;
-
-  // Inherit constructors.
-  using super_type::super_type;
-  btree_map_container() {}
-
-  // Insertion routines.
-  // Note: the nullptr template arguments and extra `const M&` overloads allow
-  // for supporting bitfield arguments.
-  template <typename K = key_type, class M>
-  std::pair<iterator, bool> insert_or_assign(const key_arg<K> &k,
-                                             const M &obj) {
-    return insert_or_assign_impl(k, obj);
-  }
-  template <typename K = key_type, class M, K * = nullptr>
-  std::pair<iterator, bool> insert_or_assign(key_arg<K> &&k, const M &obj) {
-    return insert_or_assign_impl(std::forward<K>(k), obj);
-  }
-  template <typename K = key_type, class M, M * = nullptr>
-  std::pair<iterator, bool> insert_or_assign(const key_arg<K> &k, M &&obj) {
-    return insert_or_assign_impl(k, std::forward<M>(obj));
-  }
-  template <typename K = key_type, class M, K * = nullptr, M * = nullptr>
-  std::pair<iterator, bool> insert_or_assign(key_arg<K> &&k, M &&obj) {
-    return insert_or_assign_impl(std::forward<K>(k), std::forward<M>(obj));
-  }
-  template <typename K = key_type, class M>
-  iterator insert_or_assign(const_iterator hint, const key_arg<K> &k,
-                            const M &obj) {
-    return insert_or_assign_hint_impl(hint, k, obj);
-  }
-  template <typename K = key_type, class M, K * = nullptr>
-  iterator insert_or_assign(const_iterator hint, key_arg<K> &&k, const M &obj) {
-    return insert_or_assign_hint_impl(hint, std::forward<K>(k), obj);
-  }
-  template <typename K = key_type, class M, M * = nullptr>
-  iterator insert_or_assign(const_iterator hint, const key_arg<K> &k, M &&obj) {
-    return insert_or_assign_hint_impl(hint, k, std::forward<M>(obj));
-  }
-  template <typename K = key_type, class M, K * = nullptr, M * = nullptr>
-  iterator insert_or_assign(const_iterator hint, key_arg<K> &&k, M &&obj) {
-    return insert_or_assign_hint_impl(hint, std::forward<K>(k),
-                                      std::forward<M>(obj));
-  }
-
-  template <typename K = key_type, typename... Args,
-            typename absl::enable_if_t<
-                !std::is_convertible<K, const_iterator>::value, int> = 0>
-  std::pair<iterator, bool> try_emplace(const key_arg<K> &k, Args &&... args) {
-    return try_emplace_impl(k, std::forward<Args>(args)...);
-  }
-  template <typename K = key_type, typename... Args,
-            typename absl::enable_if_t<
-                !std::is_convertible<K, const_iterator>::value, int> = 0>
-  std::pair<iterator, bool> try_emplace(key_arg<K> &&k, Args &&... args) {
-    return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
-  }
-  template <typename K = key_type, typename... Args>
-  iterator try_emplace(const_iterator hint, const key_arg<K> &k,
-                       Args &&... args) {
-    return try_emplace_hint_impl(hint, k, std::forward<Args>(args)...);
-  }
-  template <typename K = key_type, typename... Args>
-  iterator try_emplace(const_iterator hint, key_arg<K> &&k, Args &&... args) {
-    return try_emplace_hint_impl(hint, std::forward<K>(k),
-                                 std::forward<Args>(args)...);
-  }
-
-  template <typename K = key_type>
-  mapped_type &operator[](const key_arg<K> &k) {
-    return try_emplace(k).first->second;
-  }
-  template <typename K = key_type>
-  mapped_type &operator[](key_arg<K> &&k) {
-    return try_emplace(std::forward<K>(k)).first->second;
-  }
-
-  template <typename K = key_type>
-  mapped_type &at(const key_arg<K> &key) {
-    auto it = this->find(key);
-    if (it == this->end())
-      base_internal::ThrowStdOutOfRange("absl::btree_map::at");
-    return it->second;
-  }
-  template <typename K = key_type>
-  const mapped_type &at(const key_arg<K> &key) const {
-    auto it = this->find(key);
-    if (it == this->end())
-      base_internal::ThrowStdOutOfRange("absl::btree_map::at");
-    return it->second;
-  }
-
- private:
-  // Note: when we call `std::forward<M>(obj)` twice, it's safe because
-  // insert_unique/insert_hint_unique are guaranteed to not consume `obj` when
-  // `ret.second` is false.
-  template <class K, class M>
-  std::pair<iterator, bool> insert_or_assign_impl(K &&k, M &&obj) {
-    const std::pair<iterator, bool> ret =
-        this->tree_.insert_unique(k, std::forward<K>(k), std::forward<M>(obj));
-    if (!ret.second) ret.first->second = std::forward<M>(obj);
-    return ret;
-  }
-  template <class K, class M>
-  iterator insert_or_assign_hint_impl(const_iterator hint, K &&k, M &&obj) {
-    const std::pair<iterator, bool> ret = this->tree_.insert_hint_unique(
-        iterator(hint), k, std::forward<K>(k), std::forward<M>(obj));
-    if (!ret.second) ret.first->second = std::forward<M>(obj);
-    return ret.first;
-  }
-
-  template <class K, class... Args>
-  std::pair<iterator, bool> try_emplace_impl(K &&k, Args &&... args) {
-    return this->tree_.insert_unique(
-        k, std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)),
-        std::forward_as_tuple(std::forward<Args>(args)...));
-  }
-  template <class K, class... Args>
-  iterator try_emplace_hint_impl(const_iterator hint, K &&k, Args &&... args) {
-    return this->tree_
-        .insert_hint_unique(iterator(hint), k, std::piecewise_construct,
-                            std::forward_as_tuple(std::forward<K>(k)),
-                            std::forward_as_tuple(std::forward<Args>(args)...))
-        .first;
-  }
-};
-
-// A common base class for btree_multiset and btree_multimap.
-template <typename Tree>
-class btree_multiset_container : public btree_container<Tree> {
-  using super_type = btree_container<Tree>;
-  using params_type = typename Tree::params_type;
-  using init_type = typename params_type::init_type;
-  using is_key_compare_to = typename params_type::is_key_compare_to;
-  friend class BtreeNodePeer;
-
-  template <class K>
-  using key_arg = typename super_type::template key_arg<K>;
-
- public:
-  using key_type = typename Tree::key_type;
-  using value_type = typename Tree::value_type;
-  using size_type = typename Tree::size_type;
-  using key_compare = typename Tree::original_key_compare;
-  using allocator_type = typename Tree::allocator_type;
-  using iterator = typename Tree::iterator;
-  using const_iterator = typename Tree::const_iterator;
-  using node_type = typename super_type::node_type;
-
-  // Inherit constructors.
-  using super_type::super_type;
-  btree_multiset_container() {}
-
-  // Range constructors.
-  template <class InputIterator>
-  btree_multiset_container(InputIterator b, InputIterator e,
-                           const key_compare &comp = key_compare(),
-                           const allocator_type &alloc = allocator_type())
-      : super_type(comp, alloc) {
-    insert(b, e);
-  }
-  template <class InputIterator>
-  btree_multiset_container(InputIterator b, InputIterator e,
-                           const allocator_type &alloc)
-      : btree_multiset_container(b, e, key_compare(), alloc) {}
-
-  // Initializer list constructors.
-  btree_multiset_container(std::initializer_list<init_type> init,
-                           const key_compare &comp = key_compare(),
-                           const allocator_type &alloc = allocator_type())
-      : btree_multiset_container(init.begin(), init.end(), comp, alloc) {}
-  btree_multiset_container(std::initializer_list<init_type> init,
-                           const allocator_type &alloc)
-      : btree_multiset_container(init.begin(), init.end(), alloc) {}
-
-  // Insertion routines.
-  iterator insert(const value_type &v) { return this->tree_.insert_multi(v); }
-  iterator insert(value_type &&v) {
-    return this->tree_.insert_multi(std::move(v));
-  }
-  iterator insert(const_iterator hint, const value_type &v) {
-    return this->tree_.insert_hint_multi(iterator(hint), v);
-  }
-  iterator insert(const_iterator hint, value_type &&v) {
-    return this->tree_.insert_hint_multi(iterator(hint), std::move(v));
-  }
-  template <typename InputIterator>
-  void insert(InputIterator b, InputIterator e) {
-    this->tree_.insert_iterator_multi(b, e);
-  }
-  void insert(std::initializer_list<init_type> init) {
-    this->tree_.insert_iterator_multi(init.begin(), init.end());
-  }
-  template <typename... Args>
-  iterator emplace(Args &&... args) {
-    // Use a node handle to manage a temp slot.
-    auto node = CommonAccess::Construct<node_type>(this->get_allocator(),
-                                                   std::forward<Args>(args)...);
-    return this->tree_.insert_multi(CommonAccess::GetSlot(node));
-  }
-  template <typename... Args>
-  iterator emplace_hint(const_iterator hint, Args &&... args) {
-    // Use a node handle to manage a temp slot.
-    auto node = CommonAccess::Construct<node_type>(this->get_allocator(),
-                                                   std::forward<Args>(args)...);
-    return this->tree_.insert_hint_multi(iterator(hint),
-                                         CommonAccess::GetSlot(node));
-  }
-  iterator insert(node_type &&node) {
-    if (!node) return this->end();
-    iterator res =
-        this->tree_.insert_multi(params_type::key(CommonAccess::GetSlot(node)),
-                                 CommonAccess::GetSlot(node));
-    CommonAccess::Destroy(&node);
-    return res;
-  }
-  iterator insert(const_iterator hint, node_type &&node) {
-    if (!node) return this->end();
-    iterator res = this->tree_.insert_hint_multi(
-        iterator(hint),
-        std::move(params_type::element(CommonAccess::GetSlot(node))));
-    CommonAccess::Destroy(&node);
-    return res;
-  }
-
-  // Node extraction routines.
-  template <typename K = key_type>
-  node_type extract(const key_arg<K> &key) {
-    const std::pair<iterator, bool> lower_and_equal =
-        this->tree_.lower_bound_equal(key);
-    return lower_and_equal.second ? extract(lower_and_equal.first)
-                                  : node_type();
-  }
-  using super_type::extract;
-
-  // Merge routines.
-  // Moves all elements from `src` into `this`.
-  template <
-      typename T,
-      typename absl::enable_if_t<
-          absl::conjunction<
-              std::is_same<value_type, typename T::value_type>,
-              std::is_same<allocator_type, typename T::allocator_type>,
-              std::is_same<typename params_type::is_map_container,
-                           typename T::params_type::is_map_container>>::value,
-          int> = 0>
-  void merge(btree_container<T> &src) {  // NOLINT
-    for (auto src_it = src.begin(), end = src.end(); src_it != end; ++src_it) {
-      insert(std::move(params_type::element(src_it.slot())));
-    }
-    src.clear();
-  }
-
-  template <
-      typename T,
-      typename absl::enable_if_t<
-          absl::conjunction<
-              std::is_same<value_type, typename T::value_type>,
-              std::is_same<allocator_type, typename T::allocator_type>,
-              std::is_same<typename params_type::is_map_container,
-                           typename T::params_type::is_map_container>>::value,
-          int> = 0>
-  void merge(btree_container<T> &&src) {
-    merge(src);
-  }
-};
-
-// A base class for btree_multimap.
-template <typename Tree>
-class btree_multimap_container : public btree_multiset_container<Tree> {
-  using super_type = btree_multiset_container<Tree>;
-  using params_type = typename Tree::params_type;
-  friend class BtreeNodePeer;
-
- public:
-  using mapped_type = typename params_type::mapped_type;
-
-  // Inherit constructors.
-  using super_type::super_type;
-  btree_multimap_container() {}
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        // A common base class for btree_set, btree_map, btree_multiset, and
+        // btree_multimap.
+        template<typename Tree>
+        class btree_container
+        {
+            using params_type = typename Tree::params_type;
+
+        protected:
+            // Alias used for heterogeneous lookup functions.
+            // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+            // `key_type` otherwise. It permits template argument deduction on `K` for the
+            // transparent case.
+            template<class K>
+            using key_arg =
+                typename KeyArg<params_type::kIsKeyCompareTransparent>::template type<
+                    K,
+                    typename Tree::key_type>;
+
+        public:
+            using key_type = typename Tree::key_type;
+            using value_type = typename Tree::value_type;
+            using size_type = typename Tree::size_type;
+            using difference_type = typename Tree::difference_type;
+            using key_compare = typename Tree::original_key_compare;
+            using value_compare = typename Tree::value_compare;
+            using allocator_type = typename Tree::allocator_type;
+            using reference = typename Tree::reference;
+            using const_reference = typename Tree::const_reference;
+            using pointer = typename Tree::pointer;
+            using const_pointer = typename Tree::const_pointer;
+            using iterator = typename Tree::iterator;
+            using const_iterator = typename Tree::const_iterator;
+            using reverse_iterator = typename Tree::reverse_iterator;
+            using const_reverse_iterator = typename Tree::const_reverse_iterator;
+            using node_type = typename Tree::node_handle_type;
+
+            // Constructors/assignments.
+            btree_container() :
+                tree_(key_compare(), allocator_type())
+            {
+            }
+            explicit btree_container(const key_compare& comp, const allocator_type& alloc = allocator_type()) :
+                tree_(comp, alloc)
+            {
+            }
+            explicit btree_container(const allocator_type& alloc) :
+                tree_(key_compare(), alloc)
+            {
+            }
+
+            btree_container(const btree_container& other) :
+                btree_container(other, absl::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator()))
+            {
+            }
+            btree_container(const btree_container& other, const allocator_type& alloc) :
+                tree_(other.tree_, alloc)
+            {
+            }
+
+            btree_container(btree_container&& other) noexcept(
+                std::is_nothrow_move_constructible<Tree>::value
+            ) = default;
+            btree_container(btree_container&& other, const allocator_type& alloc) :
+                tree_(std::move(other.tree_), alloc)
+            {
+            }
+
+            btree_container& operator=(const btree_container& other) = default;
+            btree_container& operator=(btree_container&& other) noexcept(
+                std::is_nothrow_move_assignable<Tree>::value
+            ) = default;
+
+            // Iterator routines.
+            iterator begin()
+            {
+                return tree_.begin();
+            }
+            const_iterator begin() const
+            {
+                return tree_.begin();
+            }
+            const_iterator cbegin() const
+            {
+                return tree_.begin();
+            }
+            iterator end()
+            {
+                return tree_.end();
+            }
+            const_iterator end() const
+            {
+                return tree_.end();
+            }
+            const_iterator cend() const
+            {
+                return tree_.end();
+            }
+            reverse_iterator rbegin()
+            {
+                return tree_.rbegin();
+            }
+            const_reverse_iterator rbegin() const
+            {
+                return tree_.rbegin();
+            }
+            const_reverse_iterator crbegin() const
+            {
+                return tree_.rbegin();
+            }
+            reverse_iterator rend()
+            {
+                return tree_.rend();
+            }
+            const_reverse_iterator rend() const
+            {
+                return tree_.rend();
+            }
+            const_reverse_iterator crend() const
+            {
+                return tree_.rend();
+            }
+
+            // Lookup routines.
+            template<typename K = key_type>
+            size_type count(const key_arg<K>& key) const
+            {
+                auto equal_range = this->equal_range(key);
+                return std::distance(equal_range.first, equal_range.second);
+            }
+            template<typename K = key_type>
+            iterator find(const key_arg<K>& key)
+            {
+                return tree_.find(key);
+            }
+            template<typename K = key_type>
+            const_iterator find(const key_arg<K>& key) const
+            {
+                return tree_.find(key);
+            }
+            template<typename K = key_type>
+            bool contains(const key_arg<K>& key) const
+            {
+                return find(key) != end();
+            }
+            template<typename K = key_type>
+            iterator lower_bound(const key_arg<K>& key)
+            {
+                return tree_.lower_bound(key);
+            }
+            template<typename K = key_type>
+            const_iterator lower_bound(const key_arg<K>& key) const
+            {
+                return tree_.lower_bound(key);
+            }
+            template<typename K = key_type>
+            iterator upper_bound(const key_arg<K>& key)
+            {
+                return tree_.upper_bound(key);
+            }
+            template<typename K = key_type>
+            const_iterator upper_bound(const key_arg<K>& key) const
+            {
+                return tree_.upper_bound(key);
+            }
+            template<typename K = key_type>
+            std::pair<iterator, iterator> equal_range(const key_arg<K>& key)
+            {
+                return tree_.equal_range(key);
+            }
+            template<typename K = key_type>
+            std::pair<const_iterator, const_iterator> equal_range(
+                const key_arg<K>& key
+            ) const
+            {
+                return tree_.equal_range(key);
+            }
+
+            // Deletion routines. Note that there is also a deletion routine that is
+            // specific to btree_set_container/btree_multiset_container.
+
+            // Erase the specified iterator from the btree. The iterator must be valid
+            // (i.e. not equal to end()).  Return an iterator pointing to the node after
+            // the one that was erased (or end() if none exists).
+            iterator erase(const_iterator iter)
+            {
+                return tree_.erase(iterator(iter));
+            }
+            iterator erase(iterator iter)
+            {
+                return tree_.erase(iter);
+            }
+            iterator erase(const_iterator first, const_iterator last)
+            {
+                return tree_.erase_range(iterator(first), iterator(last)).second;
+            }
+            template<typename K = key_type>
+            size_type erase(const key_arg<K>& key)
+            {
+                auto equal_range = this->equal_range(key);
+                return tree_.erase_range(equal_range.first, equal_range.second).first;
+            }
+
+            // Extract routines.
+            node_type extract(iterator position)
+            {
+                // Use Construct instead of Transfer because the rebalancing code will
+                // destroy the slot later.
+                auto node =
+                    CommonAccess::Construct<node_type>(get_allocator(), position.slot());
+                erase(position);
+                return node;
+            }
+            node_type extract(const_iterator position)
+            {
+                return extract(iterator(position));
+            }
+
+            // Utility routines.
+            ABSL_ATTRIBUTE_REINITIALIZES void clear()
+            {
+                tree_.clear();
+            }
+            void swap(btree_container& other)
+            {
+                tree_.swap(other.tree_);
+            }
+            void verify() const
+            {
+                tree_.verify();
+            }
+
+            // Size routines.
+            size_type size() const
+            {
+                return tree_.size();
+            }
+            size_type max_size() const
+            {
+                return tree_.max_size();
+            }
+            bool empty() const
+            {
+                return tree_.empty();
+            }
+
+            friend bool operator==(const btree_container& x, const btree_container& y)
+            {
+                if (x.size() != y.size())
+                    return false;
+                return std::equal(x.begin(), x.end(), y.begin());
+            }
+
+            friend bool operator!=(const btree_container& x, const btree_container& y)
+            {
+                return !(x == y);
+            }
+
+            friend bool operator<(const btree_container& x, const btree_container& y)
+            {
+                return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
+            }
+
+            friend bool operator>(const btree_container& x, const btree_container& y)
+            {
+                return y < x;
+            }
+
+            friend bool operator<=(const btree_container& x, const btree_container& y)
+            {
+                return !(y < x);
+            }
+
+            friend bool operator>=(const btree_container& x, const btree_container& y)
+            {
+                return !(x < y);
+            }
+
+            // The allocator used by the btree.
+            allocator_type get_allocator() const
+            {
+                return tree_.get_allocator();
+            }
+
+            // The key comparator used by the btree.
+            key_compare key_comp() const
+            {
+                return key_compare(tree_.key_comp());
+            }
+            value_compare value_comp() const
+            {
+                return tree_.value_comp();
+            }
+
+            // Support absl::Hash.
+            template<typename State>
+            friend State AbslHashValue(State h, const btree_container& b)
+            {
+                for (const auto& v : b)
+                {
+                    h = State::combine(std::move(h), v);
+                }
+                return State::combine(std::move(h), b.size());
+            }
+
+        protected:
+            friend struct btree_access;
+            Tree tree_;
+        };
+
+        // A common base class for btree_set and btree_map.
+        template<typename Tree>
+        class btree_set_container : public btree_container<Tree>
+        {
+            using super_type = btree_container<Tree>;
+            using params_type = typename Tree::params_type;
+            using init_type = typename params_type::init_type;
+            using is_key_compare_to = typename params_type::is_key_compare_to;
+            friend class BtreeNodePeer;
+
+        protected:
+            template<class K>
+            using key_arg = typename super_type::template key_arg<K>;
+
+        public:
+            using key_type = typename Tree::key_type;
+            using value_type = typename Tree::value_type;
+            using size_type = typename Tree::size_type;
+            using key_compare = typename Tree::original_key_compare;
+            using allocator_type = typename Tree::allocator_type;
+            using iterator = typename Tree::iterator;
+            using const_iterator = typename Tree::const_iterator;
+            using node_type = typename super_type::node_type;
+            using insert_return_type = InsertReturnType<iterator, node_type>;
+
+            // Inherit constructors.
+            using super_type::super_type;
+            btree_set_container()
+            {
+            }
+
+            // Range constructors.
+            template<class InputIterator>
+            btree_set_container(InputIterator b, InputIterator e, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type()) :
+                super_type(comp, alloc)
+            {
+                insert(b, e);
+            }
+            template<class InputIterator>
+            btree_set_container(InputIterator b, InputIterator e, const allocator_type& alloc) :
+                btree_set_container(b, e, key_compare(), alloc)
+            {
+            }
+
+            // Initializer list constructors.
+            btree_set_container(std::initializer_list<init_type> init, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type()) :
+                btree_set_container(init.begin(), init.end(), comp, alloc)
+            {
+            }
+            btree_set_container(std::initializer_list<init_type> init, const allocator_type& alloc) :
+                btree_set_container(init.begin(), init.end(), alloc)
+            {
+            }
+
+            // Insertion routines.
+            std::pair<iterator, bool> insert(const value_type& v)
+            {
+                return this->tree_.insert_unique(params_type::key(v), v);
+            }
+            std::pair<iterator, bool> insert(value_type&& v)
+            {
+                return this->tree_.insert_unique(params_type::key(v), std::move(v));
+            }
+            template<typename... Args>
+            std::pair<iterator, bool> emplace(Args&&... args)
+            {
+                // Use a node handle to manage a temp slot.
+                auto node = CommonAccess::Construct<node_type>(this->get_allocator(), std::forward<Args>(args)...);
+                auto* slot = CommonAccess::GetSlot(node);
+                return this->tree_.insert_unique(params_type::key(slot), slot);
+            }
+            iterator insert(const_iterator hint, const value_type& v)
+            {
+                return this->tree_
+                    .insert_hint_unique(iterator(hint), params_type::key(v), v)
+                    .first;
+            }
+            iterator insert(const_iterator hint, value_type&& v)
+            {
+                return this->tree_
+                    .insert_hint_unique(iterator(hint), params_type::key(v), std::move(v))
+                    .first;
+            }
+            template<typename... Args>
+            iterator emplace_hint(const_iterator hint, Args&&... args)
+            {
+                // Use a node handle to manage a temp slot.
+                auto node = CommonAccess::Construct<node_type>(this->get_allocator(), std::forward<Args>(args)...);
+                auto* slot = CommonAccess::GetSlot(node);
+                return this->tree_
+                    .insert_hint_unique(iterator(hint), params_type::key(slot), slot)
+                    .first;
+            }
+            template<typename InputIterator>
+            void insert(InputIterator b, InputIterator e)
+            {
+                this->tree_.insert_iterator_unique(b, e, 0);
+            }
+            void insert(std::initializer_list<init_type> init)
+            {
+                this->tree_.insert_iterator_unique(init.begin(), init.end(), 0);
+            }
+            insert_return_type insert(node_type&& node)
+            {
+                if (!node)
+                    return {this->end(), false, node_type()};
+                std::pair<iterator, bool> res =
+                    this->tree_.insert_unique(params_type::key(CommonAccess::GetSlot(node)), CommonAccess::GetSlot(node));
+                if (res.second)
+                {
+                    CommonAccess::Destroy(&node);
+                    return {res.first, true, node_type()};
+                }
+                else
+                {
+                    return {res.first, false, std::move(node)};
+                }
+            }
+            iterator insert(const_iterator hint, node_type&& node)
+            {
+                if (!node)
+                    return this->end();
+                std::pair<iterator, bool> res = this->tree_.insert_hint_unique(
+                    iterator(hint), params_type::key(CommonAccess::GetSlot(node)), CommonAccess::GetSlot(node)
+                );
+                if (res.second)
+                    CommonAccess::Destroy(&node);
+                return res.first;
+            }
+
+            // Node extraction routines.
+            template<typename K = key_type>
+            node_type extract(const key_arg<K>& key)
+            {
+                const std::pair<iterator, bool> lower_and_equal =
+                    this->tree_.lower_bound_equal(key);
+                return lower_and_equal.second ? extract(lower_and_equal.first) : node_type();
+            }
+            using super_type::extract;
+
+            // Merge routines.
+            // Moves elements from `src` into `this`. If the element already exists in
+            // `this`, it is left unmodified in `src`.
+            template<
+                typename T,
+                typename absl::enable_if_t<
+                    absl::conjunction<
+                        std::is_same<value_type, typename T::value_type>,
+                        std::is_same<allocator_type, typename T::allocator_type>,
+                        std::is_same<typename params_type::is_map_container, typename T::params_type::is_map_container>>::value,
+                    int> = 0>
+            void merge(btree_container<T>& src)
+            {  // NOLINT
+                for (auto src_it = src.begin(); src_it != src.end();)
+                {
+                    if (insert(std::move(params_type::element(src_it.slot()))).second)
+                    {
+                        src_it = src.erase(src_it);
+                    }
+                    else
+                    {
+                        ++src_it;
+                    }
+                }
+            }
+
+            template<
+                typename T,
+                typename absl::enable_if_t<
+                    absl::conjunction<
+                        std::is_same<value_type, typename T::value_type>,
+                        std::is_same<allocator_type, typename T::allocator_type>,
+                        std::is_same<typename params_type::is_map_container, typename T::params_type::is_map_container>>::value,
+                    int> = 0>
+            void merge(btree_container<T>&& src)
+            {
+                merge(src);
+            }
+        };
+
+        // Base class for btree_map.
+        template<typename Tree>
+        class btree_map_container : public btree_set_container<Tree>
+        {
+            using super_type = btree_set_container<Tree>;
+            using params_type = typename Tree::params_type;
+            friend class BtreeNodePeer;
+
+        private:
+            template<class K>
+            using key_arg = typename super_type::template key_arg<K>;
+
+        public:
+            using key_type = typename Tree::key_type;
+            using mapped_type = typename params_type::mapped_type;
+            using value_type = typename Tree::value_type;
+            using key_compare = typename Tree::original_key_compare;
+            using allocator_type = typename Tree::allocator_type;
+            using iterator = typename Tree::iterator;
+            using const_iterator = typename Tree::const_iterator;
+
+            // Inherit constructors.
+            using super_type::super_type;
+            btree_map_container()
+            {
+            }
+
+            // Insertion routines.
+            // Note: the nullptr template arguments and extra `const M&` overloads allow
+            // for supporting bitfield arguments.
+            template<typename K = key_type, class M>
+            std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const M& obj)
+            {
+                return insert_or_assign_impl(k, obj);
+            }
+            template<typename K = key_type, class M, K* = nullptr>
+            std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const M& obj)
+            {
+                return insert_or_assign_impl(std::forward<K>(k), obj);
+            }
+            template<typename K = key_type, class M, M* = nullptr>
+            std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, M&& obj)
+            {
+                return insert_or_assign_impl(k, std::forward<M>(obj));
+            }
+            template<typename K = key_type, class M, K* = nullptr, M* = nullptr>
+            std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, M&& obj)
+            {
+                return insert_or_assign_impl(std::forward<K>(k), std::forward<M>(obj));
+            }
+            template<typename K = key_type, class M>
+            iterator insert_or_assign(const_iterator hint, const key_arg<K>& k, const M& obj)
+            {
+                return insert_or_assign_hint_impl(hint, k, obj);
+            }
+            template<typename K = key_type, class M, K* = nullptr>
+            iterator insert_or_assign(const_iterator hint, key_arg<K>&& k, const M& obj)
+            {
+                return insert_or_assign_hint_impl(hint, std::forward<K>(k), obj);
+            }
+            template<typename K = key_type, class M, M* = nullptr>
+            iterator insert_or_assign(const_iterator hint, const key_arg<K>& k, M&& obj)
+            {
+                return insert_or_assign_hint_impl(hint, k, std::forward<M>(obj));
+            }
+            template<typename K = key_type, class M, K* = nullptr, M* = nullptr>
+            iterator insert_or_assign(const_iterator hint, key_arg<K>&& k, M&& obj)
+            {
+                return insert_or_assign_hint_impl(hint, std::forward<K>(k), std::forward<M>(obj));
+            }
+
+            template<typename K = key_type, typename... Args, typename absl::enable_if_t<!std::is_convertible<K, const_iterator>::value, int> = 0>
+            std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args)
+            {
+                return try_emplace_impl(k, std::forward<Args>(args)...);
+            }
+            template<typename K = key_type, typename... Args, typename absl::enable_if_t<!std::is_convertible<K, const_iterator>::value, int> = 0>
+            std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args)
+            {
+                return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+            }
+            template<typename K = key_type, typename... Args>
+            iterator try_emplace(const_iterator hint, const key_arg<K>& k, Args&&... args)
+            {
+                return try_emplace_hint_impl(hint, k, std::forward<Args>(args)...);
+            }
+            template<typename K = key_type, typename... Args>
+            iterator try_emplace(const_iterator hint, key_arg<K>&& k, Args&&... args)
+            {
+                return try_emplace_hint_impl(hint, std::forward<K>(k), std::forward<Args>(args)...);
+            }
+
+            template<typename K = key_type>
+            mapped_type& operator[](const key_arg<K>& k)
+            {
+                return try_emplace(k).first->second;
+            }
+            template<typename K = key_type>
+            mapped_type& operator[](key_arg<K>&& k)
+            {
+                return try_emplace(std::forward<K>(k)).first->second;
+            }
+
+            template<typename K = key_type>
+            mapped_type& at(const key_arg<K>& key)
+            {
+                auto it = this->find(key);
+                if (it == this->end())
+                    base_internal::ThrowStdOutOfRange("absl::btree_map::at");
+                return it->second;
+            }
+            template<typename K = key_type>
+            const mapped_type& at(const key_arg<K>& key) const
+            {
+                auto it = this->find(key);
+                if (it == this->end())
+                    base_internal::ThrowStdOutOfRange("absl::btree_map::at");
+                return it->second;
+            }
+
+        private:
+            // Note: when we call `std::forward<M>(obj)` twice, it's safe because
+            // insert_unique/insert_hint_unique are guaranteed to not consume `obj` when
+            // `ret.second` is false.
+            template<class K, class M>
+            std::pair<iterator, bool> insert_or_assign_impl(K&& k, M&& obj)
+            {
+                const std::pair<iterator, bool> ret =
+                    this->tree_.insert_unique(k, std::forward<K>(k), std::forward<M>(obj));
+                if (!ret.second)
+                    ret.first->second = std::forward<M>(obj);
+                return ret;
+            }
+            template<class K, class M>
+            iterator insert_or_assign_hint_impl(const_iterator hint, K&& k, M&& obj)
+            {
+                const std::pair<iterator, bool> ret = this->tree_.insert_hint_unique(
+                    iterator(hint), k, std::forward<K>(k), std::forward<M>(obj)
+                );
+                if (!ret.second)
+                    ret.first->second = std::forward<M>(obj);
+                return ret.first;
+            }
+
+            template<class K, class... Args>
+            std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args)
+            {
+                return this->tree_.insert_unique(
+                    k, std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)
+                );
+            }
+            template<class K, class... Args>
+            iterator try_emplace_hint_impl(const_iterator hint, K&& k, Args&&... args)
+            {
+                return this->tree_
+                    .insert_hint_unique(iterator(hint), k, std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...))
+                    .first;
+            }
+        };
+
+        // A common base class for btree_multiset and btree_multimap.
+        template<typename Tree>
+        class btree_multiset_container : public btree_container<Tree>
+        {
+            using super_type = btree_container<Tree>;
+            using params_type = typename Tree::params_type;
+            using init_type = typename params_type::init_type;
+            using is_key_compare_to = typename params_type::is_key_compare_to;
+            friend class BtreeNodePeer;
+
+            template<class K>
+            using key_arg = typename super_type::template key_arg<K>;
+
+        public:
+            using key_type = typename Tree::key_type;
+            using value_type = typename Tree::value_type;
+            using size_type = typename Tree::size_type;
+            using key_compare = typename Tree::original_key_compare;
+            using allocator_type = typename Tree::allocator_type;
+            using iterator = typename Tree::iterator;
+            using const_iterator = typename Tree::const_iterator;
+            using node_type = typename super_type::node_type;
+
+            // Inherit constructors.
+            using super_type::super_type;
+            btree_multiset_container()
+            {
+            }
+
+            // Range constructors.
+            template<class InputIterator>
+            btree_multiset_container(InputIterator b, InputIterator e, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type()) :
+                super_type(comp, alloc)
+            {
+                insert(b, e);
+            }
+            template<class InputIterator>
+            btree_multiset_container(InputIterator b, InputIterator e, const allocator_type& alloc) :
+                btree_multiset_container(b, e, key_compare(), alloc)
+            {
+            }
+
+            // Initializer list constructors.
+            btree_multiset_container(std::initializer_list<init_type> init, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type()) :
+                btree_multiset_container(init.begin(), init.end(), comp, alloc)
+            {
+            }
+            btree_multiset_container(std::initializer_list<init_type> init, const allocator_type& alloc) :
+                btree_multiset_container(init.begin(), init.end(), alloc)
+            {
+            }
+
+            // Insertion routines.
+            iterator insert(const value_type& v)
+            {
+                return this->tree_.insert_multi(v);
+            }
+            iterator insert(value_type&& v)
+            {
+                return this->tree_.insert_multi(std::move(v));
+            }
+            iterator insert(const_iterator hint, const value_type& v)
+            {
+                return this->tree_.insert_hint_multi(iterator(hint), v);
+            }
+            iterator insert(const_iterator hint, value_type&& v)
+            {
+                return this->tree_.insert_hint_multi(iterator(hint), std::move(v));
+            }
+            template<typename InputIterator>
+            void insert(InputIterator b, InputIterator e)
+            {
+                this->tree_.insert_iterator_multi(b, e);
+            }
+            void insert(std::initializer_list<init_type> init)
+            {
+                this->tree_.insert_iterator_multi(init.begin(), init.end());
+            }
+            template<typename... Args>
+            iterator emplace(Args&&... args)
+            {
+                // Use a node handle to manage a temp slot.
+                auto node = CommonAccess::Construct<node_type>(this->get_allocator(), std::forward<Args>(args)...);
+                return this->tree_.insert_multi(CommonAccess::GetSlot(node));
+            }
+            template<typename... Args>
+            iterator emplace_hint(const_iterator hint, Args&&... args)
+            {
+                // Use a node handle to manage a temp slot.
+                auto node = CommonAccess::Construct<node_type>(this->get_allocator(), std::forward<Args>(args)...);
+                return this->tree_.insert_hint_multi(iterator(hint), CommonAccess::GetSlot(node));
+            }
+            iterator insert(node_type&& node)
+            {
+                if (!node)
+                    return this->end();
+                iterator res =
+                    this->tree_.insert_multi(params_type::key(CommonAccess::GetSlot(node)), CommonAccess::GetSlot(node));
+                CommonAccess::Destroy(&node);
+                return res;
+            }
+            iterator insert(const_iterator hint, node_type&& node)
+            {
+                if (!node)
+                    return this->end();
+                iterator res = this->tree_.insert_hint_multi(
+                    iterator(hint),
+                    std::move(params_type::element(CommonAccess::GetSlot(node)))
+                );
+                CommonAccess::Destroy(&node);
+                return res;
+            }
+
+            // Node extraction routines.
+            template<typename K = key_type>
+            node_type extract(const key_arg<K>& key)
+            {
+                const std::pair<iterator, bool> lower_and_equal =
+                    this->tree_.lower_bound_equal(key);
+                return lower_and_equal.second ? extract(lower_and_equal.first) : node_type();
+            }
+            using super_type::extract;
+
+            // Merge routines.
+            // Moves all elements from `src` into `this`.
+            template<
+                typename T,
+                typename absl::enable_if_t<
+                    absl::conjunction<
+                        std::is_same<value_type, typename T::value_type>,
+                        std::is_same<allocator_type, typename T::allocator_type>,
+                        std::is_same<typename params_type::is_map_container, typename T::params_type::is_map_container>>::value,
+                    int> = 0>
+            void merge(btree_container<T>& src)
+            {  // NOLINT
+                for (auto src_it = src.begin(), end = src.end(); src_it != end; ++src_it)
+                {
+                    insert(std::move(params_type::element(src_it.slot())));
+                }
+                src.clear();
+            }
+
+            template<
+                typename T,
+                typename absl::enable_if_t<
+                    absl::conjunction<
+                        std::is_same<value_type, typename T::value_type>,
+                        std::is_same<allocator_type, typename T::allocator_type>,
+                        std::is_same<typename params_type::is_map_container, typename T::params_type::is_map_container>>::value,
+                    int> = 0>
+            void merge(btree_container<T>&& src)
+            {
+                merge(src);
+            }
+        };
+
+        // A base class for btree_multimap.
+        template<typename Tree>
+        class btree_multimap_container : public btree_multiset_container<Tree>
+        {
+            using super_type = btree_multiset_container<Tree>;
+            using params_type = typename Tree::params_type;
+            friend class BtreeNodePeer;
+
+        public:
+            using mapped_type = typename params_type::mapped_type;
+
+            // Inherit constructors.
+            using super_type::super_type;
+            btree_multimap_container()
+            {
+            }
+        };
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/common.h b/CAPI/cpp/grpc/include/absl/container/internal/common.h
index 416d9aa..5a1f424 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/common.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/common.h
@@ -21,187 +21,238 @@
 #include "absl/meta/type_traits.h"
 #include "absl/types/optional.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class, class = void>
-struct IsTransparent : std::false_type {};
-template <class T>
-struct IsTransparent<T, absl::void_t<typename T::is_transparent>>
-    : std::true_type {};
-
-template <bool is_transparent>
-struct KeyArg {
-  // Transparent. Forward `K`.
-  template <typename K, typename key_type>
-  using type = K;
-};
-
-template <>
-struct KeyArg<false> {
-  // Not transparent. Always use `key_type`.
-  template <typename K, typename key_type>
-  using type = key_type;
-};
-
-// The node_handle concept from C++17.
-// We specialize node_handle for sets and maps. node_handle_base holds the
-// common API of both.
-template <typename PolicyTraits, typename Alloc>
-class node_handle_base {
- protected:
-  using slot_type = typename PolicyTraits::slot_type;
-
- public:
-  using allocator_type = Alloc;
-
-  constexpr node_handle_base() = default;
-  node_handle_base(node_handle_base&& other) noexcept {
-    *this = std::move(other);
-  }
-  ~node_handle_base() { destroy(); }
-  node_handle_base& operator=(node_handle_base&& other) noexcept {
-    destroy();
-    if (!other.empty()) {
-      alloc_ = other.alloc_;
-      PolicyTraits::transfer(alloc(), slot(), other.slot());
-      other.reset();
-    }
-    return *this;
-  }
-
-  bool empty() const noexcept { return !alloc_; }
-  explicit operator bool() const noexcept { return !empty(); }
-  allocator_type get_allocator() const { return *alloc_; }
-
- protected:
-  friend struct CommonAccess;
-
-  struct transfer_tag_t {};
-  node_handle_base(transfer_tag_t, const allocator_type& a, slot_type* s)
-      : alloc_(a) {
-    PolicyTraits::transfer(alloc(), slot(), s);
-  }
-
-  struct construct_tag_t {};
-  template <typename... Args>
-  node_handle_base(construct_tag_t, const allocator_type& a, Args&&... args)
-      : alloc_(a) {
-    PolicyTraits::construct(alloc(), slot(), std::forward<Args>(args)...);
-  }
-
-  void destroy() {
-    if (!empty()) {
-      PolicyTraits::destroy(alloc(), slot());
-      reset();
-    }
-  }
-
-  void reset() {
-    assert(alloc_.has_value());
-    alloc_ = absl::nullopt;
-  }
-
-  slot_type* slot() const {
-    assert(!empty());
-    return reinterpret_cast<slot_type*>(std::addressof(slot_space_));
-  }
-  allocator_type* alloc() { return std::addressof(*alloc_); }
-
- private:
-  absl::optional<allocator_type> alloc_ = {};
-  alignas(slot_type) mutable unsigned char slot_space_[sizeof(slot_type)] = {};
-};
-
-// For sets.
-template <typename Policy, typename PolicyTraits, typename Alloc,
-          typename = void>
-class node_handle : public node_handle_base<PolicyTraits, Alloc> {
-  using Base = node_handle_base<PolicyTraits, Alloc>;
-
- public:
-  using value_type = typename PolicyTraits::value_type;
-
-  constexpr node_handle() {}
-
-  value_type& value() const { return PolicyTraits::element(this->slot()); }
-
- private:
-  friend struct CommonAccess;
-
-  using Base::Base;
-};
-
-// For maps.
-template <typename Policy, typename PolicyTraits, typename Alloc>
-class node_handle<Policy, PolicyTraits, Alloc,
-                  absl::void_t<typename Policy::mapped_type>>
-    : public node_handle_base<PolicyTraits, Alloc> {
-  using Base = node_handle_base<PolicyTraits, Alloc>;
-  using slot_type = typename PolicyTraits::slot_type;
-
- public:
-  using key_type = typename Policy::key_type;
-  using mapped_type = typename Policy::mapped_type;
-
-  constexpr node_handle() {}
-
-  // When C++17 is available, we can use std::launder to provide mutable
-  // access to the key. Otherwise, we provide const access.
-  auto key() const
-      -> decltype(PolicyTraits::mutable_key(std::declval<slot_type*>())) {
-    return PolicyTraits::mutable_key(this->slot());
-  }
-
-  mapped_type& mapped() const {
-    return PolicyTraits::value(&PolicyTraits::element(this->slot()));
-  }
-
- private:
-  friend struct CommonAccess;
-
-  using Base::Base;
-};
-
-// Provide access to non-public node-handle functions.
-struct CommonAccess {
-  template <typename Node>
-  static auto GetSlot(const Node& node) -> decltype(node.slot()) {
-    return node.slot();
-  }
-
-  template <typename Node>
-  static void Destroy(Node* node) {
-    node->destroy();
-  }
-
-  template <typename Node>
-  static void Reset(Node* node) {
-    node->reset();
-  }
-
-  template <typename T, typename... Args>
-  static T Transfer(Args&&... args) {
-    return T(typename T::transfer_tag_t{}, std::forward<Args>(args)...);
-  }
-
-  template <typename T, typename... Args>
-  static T Construct(Args&&... args) {
-    return T(typename T::construct_tag_t{}, std::forward<Args>(args)...);
-  }
-};
-
-// Implement the insert_return_type<> concept of C++17.
-template <class Iterator, class NodeType>
-struct InsertReturnType {
-  Iterator position;
-  bool inserted;
-  NodeType node;
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<class, class = void>
+        struct IsTransparent : std::false_type
+        {
+        };
+        template<class T>
+        struct IsTransparent<T, absl::void_t<typename T::is_transparent>> : std::true_type
+        {
+        };
+
+        template<bool is_transparent>
+        struct KeyArg
+        {
+            // Transparent. Forward `K`.
+            template<typename K, typename key_type>
+            using type = K;
+        };
+
+        template<>
+        struct KeyArg<false>
+        {
+            // Not transparent. Always use `key_type`.
+            template<typename K, typename key_type>
+            using type = key_type;
+        };
+
+        // The node_handle concept from C++17.
+        // We specialize node_handle for sets and maps. node_handle_base holds the
+        // common API of both.
+        template<typename PolicyTraits, typename Alloc>
+        class node_handle_base
+        {
+        protected:
+            using slot_type = typename PolicyTraits::slot_type;
+
+        public:
+            using allocator_type = Alloc;
+
+            constexpr node_handle_base() = default;
+            node_handle_base(node_handle_base&& other) noexcept
+            {
+                *this = std::move(other);
+            }
+            ~node_handle_base()
+            {
+                destroy();
+            }
+            node_handle_base& operator=(node_handle_base&& other) noexcept
+            {
+                destroy();
+                if (!other.empty())
+                {
+                    alloc_ = other.alloc_;
+                    PolicyTraits::transfer(alloc(), slot(), other.slot());
+                    other.reset();
+                }
+                return *this;
+            }
+
+            bool empty() const noexcept
+            {
+                return !alloc_;
+            }
+            explicit operator bool() const noexcept
+            {
+                return !empty();
+            }
+            allocator_type get_allocator() const
+            {
+                return *alloc_;
+            }
+
+        protected:
+            friend struct CommonAccess;
+
+            struct transfer_tag_t
+            {
+            };
+            node_handle_base(transfer_tag_t, const allocator_type& a, slot_type* s) :
+                alloc_(a)
+            {
+                PolicyTraits::transfer(alloc(), slot(), s);
+            }
+
+            struct construct_tag_t
+            {
+            };
+            template<typename... Args>
+            node_handle_base(construct_tag_t, const allocator_type& a, Args&&... args) :
+                alloc_(a)
+            {
+                PolicyTraits::construct(alloc(), slot(), std::forward<Args>(args)...);
+            }
+
+            void destroy()
+            {
+                if (!empty())
+                {
+                    PolicyTraits::destroy(alloc(), slot());
+                    reset();
+                }
+            }
+
+            void reset()
+            {
+                assert(alloc_.has_value());
+                alloc_ = absl::nullopt;
+            }
+
+            slot_type* slot() const
+            {
+                assert(!empty());
+                return reinterpret_cast<slot_type*>(std::addressof(slot_space_));
+            }
+            allocator_type* alloc()
+            {
+                return std::addressof(*alloc_);
+            }
+
+        private:
+            absl::optional<allocator_type> alloc_ = {};
+            alignas(slot_type) mutable unsigned char slot_space_[sizeof(slot_type)] = {};
+        };
+
+        // For sets.
+        template<typename Policy, typename PolicyTraits, typename Alloc, typename = void>
+        class node_handle : public node_handle_base<PolicyTraits, Alloc>
+        {
+            using Base = node_handle_base<PolicyTraits, Alloc>;
+
+        public:
+            using value_type = typename PolicyTraits::value_type;
+
+            constexpr node_handle()
+            {
+            }
+
+            value_type& value() const
+            {
+                return PolicyTraits::element(this->slot());
+            }
+
+        private:
+            friend struct CommonAccess;
+
+            using Base::Base;
+        };
+
+        // For maps.
+        template<typename Policy, typename PolicyTraits, typename Alloc>
+        class node_handle<Policy, PolicyTraits, Alloc, absl::void_t<typename Policy::mapped_type>> : public node_handle_base<PolicyTraits, Alloc>
+        {
+            using Base = node_handle_base<PolicyTraits, Alloc>;
+            using slot_type = typename PolicyTraits::slot_type;
+
+        public:
+            using key_type = typename Policy::key_type;
+            using mapped_type = typename Policy::mapped_type;
+
+            constexpr node_handle()
+            {
+            }
+
+            // When C++17 is available, we can use std::launder to provide mutable
+            // access to the key. Otherwise, we provide const access.
+            auto key() const
+                -> decltype(PolicyTraits::mutable_key(std::declval<slot_type*>()))
+            {
+                return PolicyTraits::mutable_key(this->slot());
+            }
+
+            mapped_type& mapped() const
+            {
+                return PolicyTraits::value(&PolicyTraits::element(this->slot()));
+            }
+
+        private:
+            friend struct CommonAccess;
+
+            using Base::Base;
+        };
+
+        // Provide access to non-public node-handle functions.
+        struct CommonAccess
+        {
+            template<typename Node>
+            static auto GetSlot(const Node& node) -> decltype(node.slot())
+            {
+                return node.slot();
+            }
+
+            template<typename Node>
+            static void Destroy(Node* node)
+            {
+                node->destroy();
+            }
+
+            template<typename Node>
+            static void Reset(Node* node)
+            {
+                node->reset();
+            }
+
+            template<typename T, typename... Args>
+            static T Transfer(Args&&... args)
+            {
+                return T(typename T::transfer_tag_t{}, std::forward<Args>(args)...);
+            }
+
+            template<typename T, typename... Args>
+            static T Construct(Args&&... args)
+            {
+                return T(typename T::construct_tag_t{}, std::forward<Args>(args)...);
+            }
+        };
+
+        // Implement the insert_return_type<> concept of C++17.
+        template<class Iterator, class NodeType>
+        struct InsertReturnType
+        {
+            Iterator position;
+            bool inserted;
+            NodeType node;
+        };
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_CONTAINER_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/compressed_tuple.h b/CAPI/cpp/grpc/include/absl/container/internal/compressed_tuple.h
index 5ebe164..022e663 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/compressed_tuple.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/compressed_tuple.h
@@ -47,242 +47,291 @@
 #define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <typename... Ts>
-class CompressedTuple;
-
-namespace internal_compressed_tuple {
-
-template <typename D, size_t I>
-struct Elem;
-template <typename... B, size_t I>
-struct Elem<CompressedTuple<B...>, I>
-    : std::tuple_element<I, std::tuple<B...>> {};
-template <typename D, size_t I>
-using ElemT = typename Elem<D, I>::type;
-
-// Use the __is_final intrinsic if available. Where it's not available, classes
-// declared with the 'final' specifier cannot be used as CompressedTuple
-// elements.
-// TODO(sbenza): Replace this with std::is_final in C++14.
-template <typename T>
-constexpr bool IsFinal() {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<typename... Ts>
+        class CompressedTuple;
+
+        namespace internal_compressed_tuple
+        {
+
+            template<typename D, size_t I>
+            struct Elem;
+            template<typename... B, size_t I>
+            struct Elem<CompressedTuple<B...>, I> : std::tuple_element<I, std::tuple<B...>>
+            {
+            };
+            template<typename D, size_t I>
+            using ElemT = typename Elem<D, I>::type;
+
+            // Use the __is_final intrinsic if available. Where it's not available, classes
+            // declared with the 'final' specifier cannot be used as CompressedTuple
+            // elements.
+            // TODO(sbenza): Replace this with std::is_final in C++14.
+            template<typename T>
+            constexpr bool IsFinal()
+            {
 #if defined(__clang__) || defined(__GNUC__)
-  return __is_final(T);
+                return __is_final(T);
 #else
-  return false;
+                return false;
 #endif
-}
-
-// We can't use EBCO on other CompressedTuples because that would mean that we
-// derive from multiple Storage<> instantiations with the same I parameter,
-// and potentially from multiple identical Storage<> instantiations.  So anytime
-// we use type inheritance rather than encapsulation, we mark
-// CompressedTupleImpl, to make this easy to detect.
-struct uses_inheritance {};
-
-template <typename T>
-constexpr bool ShouldUseBase() {
-  return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>() &&
-         !std::is_base_of<uses_inheritance, T>::value;
-}
-
-// The storage class provides two specializations:
-//  - For empty classes, it stores T as a base class.
-//  - For everything else, it stores T as a member.
-template <typename T, size_t I,
+            }
+
+            // We can't use EBCO on other CompressedTuples because that would mean that we
+            // derive from multiple Storage<> instantiations with the same I parameter,
+            // and potentially from multiple identical Storage<> instantiations.  So anytime
+            // we use type inheritance rather than encapsulation, we mark
+            // CompressedTupleImpl, to make this easy to detect.
+            struct uses_inheritance
+            {
+            };
+
+            template<typename T>
+            constexpr bool ShouldUseBase()
+            {
+                return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>() &&
+                       !std::is_base_of<uses_inheritance, T>::value;
+            }
+
+            // The storage class provides two specializations:
+            //  - For empty classes, it stores T as a base class.
+            //  - For everything else, it stores T as a member.
+            template<typename T, size_t I,
 #if defined(_MSC_VER)
-          bool UseBase =
-              ShouldUseBase<typename std::enable_if<true, T>::type>()>
+                     bool UseBase = ShouldUseBase<typename std::enable_if<true, T>::type>()>
 #else
-          bool UseBase = ShouldUseBase<T>()>
+                     bool UseBase = ShouldUseBase<T>()>
 #endif
-struct Storage {
-  T value;
-  constexpr Storage() = default;
-  template <typename V>
-  explicit constexpr Storage(absl::in_place_t, V&& v)
-      : value(absl::forward<V>(v)) {}
-  constexpr const T& get() const& { return value; }
-  T& get() & { return value; }
-  constexpr const T&& get() const&& { return absl::move(*this).value; }
-  T&& get() && { return std::move(*this).value; }
-};
-
-template <typename T, size_t I>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T {
-  constexpr Storage() = default;
-
-  template <typename V>
-  explicit constexpr Storage(absl::in_place_t, V&& v)
-      : T(absl::forward<V>(v)) {}
-
-  constexpr const T& get() const& { return *this; }
-  T& get() & { return *this; }
-  constexpr const T&& get() const&& { return absl::move(*this); }
-  T&& get() && { return std::move(*this); }
-};
-
-template <typename D, typename I, bool ShouldAnyUseBase>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
-
-template <typename... Ts, size_t... I, bool ShouldAnyUseBase>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
-    CompressedTuple<Ts...>, absl::index_sequence<I...>, ShouldAnyUseBase>
-    // We use the dummy identity function through std::integral_constant to
-    // convince MSVC of accepting and expanding I in that context. Without it
-    // you would get:
-    //   error C3548: 'I': parameter pack cannot be used in this context
-    : uses_inheritance,
-      Storage<Ts, std::integral_constant<size_t, I>::value>... {
-  constexpr CompressedTupleImpl() = default;
-  template <typename... Vs>
-  explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args)
-      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
-  friend CompressedTuple<Ts...>;
-};
-
-template <typename... Ts, size_t... I>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
-    CompressedTuple<Ts...>, absl::index_sequence<I...>, false>
-    // We use the dummy identity function as above...
-    : Storage<Ts, std::integral_constant<size_t, I>::value, false>... {
-  constexpr CompressedTupleImpl() = default;
-  template <typename... Vs>
-  explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args)
-      : Storage<Ts, I, false>(absl::in_place, absl::forward<Vs>(args))... {}
-  friend CompressedTuple<Ts...>;
-};
-
-std::false_type Or(std::initializer_list<std::false_type>);
-std::true_type Or(std::initializer_list<bool>);
-
-// MSVC requires this to be done separately rather than within the declaration
-// of CompressedTuple below.
-template <typename... Ts>
-constexpr bool ShouldAnyUseBase() {
-  return decltype(
-      Or({std::integral_constant<bool, ShouldUseBase<Ts>()>()...})){};
-}
-
-template <typename T, typename V>
-using TupleElementMoveConstructible =
-    typename std::conditional<std::is_reference<T>::value,
-                              std::is_convertible<V, T>,
-                              std::is_constructible<T, V&&>>::type;
-
-template <bool SizeMatches, class T, class... Vs>
-struct TupleMoveConstructible : std::false_type {};
-
-template <class... Ts, class... Vs>
-struct TupleMoveConstructible<true, CompressedTuple<Ts...>, Vs...>
-    : std::integral_constant<
-          bool, absl::conjunction<
-                    TupleElementMoveConstructible<Ts, Vs&&>...>::value> {};
-
-template <typename T>
-struct compressed_tuple_size;
-
-template <typename... Es>
-struct compressed_tuple_size<CompressedTuple<Es...>>
-    : public std::integral_constant<std::size_t, sizeof...(Es)> {};
-
-template <class T, class... Vs>
-struct TupleItemsMoveConstructible
-    : std::integral_constant<
-          bool, TupleMoveConstructible<compressed_tuple_size<T>::value ==
-                                           sizeof...(Vs),
-                                       T, Vs...>::value> {};
-
-}  // namespace internal_compressed_tuple
-
-// Helper class to perform the Empty Base Class Optimization.
-// Ts can contain classes and non-classes, empty or not. For the ones that
-// are empty classes, we perform the CompressedTuple. If all types in Ts are
-// empty classes, then CompressedTuple<Ts...> is itself an empty class.  (This
-// does not apply when one or more of those empty classes is itself an empty
-// CompressedTuple.)
-//
-// To access the members, use member .get<N>() function.
-//
-// Eg:
-//   absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
-//                                                                    t3);
-//   assert(value.get<0>() == 7);
-//   T1& t1 = value.get<1>();
-//   const T2& t2 = value.get<2>();
-//   ...
-//
-// https://en.cppreference.com/w/cpp/language/ebo
-template <typename... Ts>
-class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
-    : private internal_compressed_tuple::CompressedTupleImpl<
-          CompressedTuple<Ts...>, absl::index_sequence_for<Ts...>,
-          internal_compressed_tuple::ShouldAnyUseBase<Ts...>()> {
- private:
-  template <int I>
-  using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
-
-  template <int I>
-  using StorageT = internal_compressed_tuple::Storage<ElemT<I>, I>;
-
- public:
-  // There seems to be a bug in MSVC dealing in which using '=default' here will
-  // cause the compiler to ignore the body of other constructors. The work-
-  // around is to explicitly implement the default constructor.
+            struct Storage
+            {
+                T value;
+                constexpr Storage() = default;
+                template<typename V>
+                explicit constexpr Storage(absl::in_place_t, V&& v) :
+                    value(absl::forward<V>(v))
+                {
+                }
+                constexpr const T& get() const&
+                {
+                    return value;
+                }
+                T& get() &
+                {
+                    return value;
+                }
+                constexpr const T&& get() const&&
+                {
+                    return absl::move(*this).value;
+                }
+                T&& get() &&
+                {
+                    return std::move(*this).value;
+                }
+            };
+
+            template<typename T, size_t I>
+            struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T
+            {
+                constexpr Storage() = default;
+
+                template<typename V>
+                explicit constexpr Storage(absl::in_place_t, V&& v) :
+                    T(absl::forward<V>(v))
+                {
+                }
+
+                constexpr const T& get() const&
+                {
+                    return *this;
+                }
+                T& get() &
+                {
+                    return *this;
+                }
+                constexpr const T&& get() const&&
+                {
+                    return absl::move(*this);
+                }
+                T&& get() &&
+                {
+                    return std::move(*this);
+                }
+            };
+
+            template<typename D, typename I, bool ShouldAnyUseBase>
+            struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
+
+            template<typename... Ts, size_t... I, bool ShouldAnyUseBase>
+            struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
+                CompressedTuple<Ts...>,
+                absl::index_sequence<I...>,
+                ShouldAnyUseBase>
+                // We use the dummy identity function through std::integral_constant to
+                // convince MSVC of accepting and expanding I in that context. Without it
+                // you would get:
+                //   error C3548: 'I': parameter pack cannot be used in this context
+                : uses_inheritance, Storage<Ts, std::integral_constant<size_t, I>::value>...
+            {
+                constexpr CompressedTupleImpl() = default;
+                template<typename... Vs>
+                explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args) :
+                    Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))...
+                {
+                }
+                friend CompressedTuple<Ts...>;
+            };
+
+            template<typename... Ts, size_t... I>
+            struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
+                CompressedTuple<Ts...>,
+                absl::index_sequence<I...>,
+                false>
+                // We use the dummy identity function as above...
+                : Storage<Ts, std::integral_constant<size_t, I>::value, false>...
+            {
+                constexpr CompressedTupleImpl() = default;
+                template<typename... Vs>
+                explicit constexpr CompressedTupleImpl(absl::in_place_t, Vs&&... args) :
+                    Storage<Ts, I, false>(absl::in_place, absl::forward<Vs>(args))...
+                {
+                }
+                friend CompressedTuple<Ts...>;
+            };
+
+            std::false_type Or(std::initializer_list<std::false_type>);
+            std::true_type Or(std::initializer_list<bool>);
+
+            // MSVC requires this to be done separately rather than within the declaration
+            // of CompressedTuple below.
+            template<typename... Ts>
+            constexpr bool ShouldAnyUseBase()
+            {
+                return decltype(Or({std::integral_constant<bool, ShouldUseBase<Ts>()>()...})){};
+            }
+
+            template<typename T, typename V>
+            using TupleElementMoveConstructible =
+                typename std::conditional<std::is_reference<T>::value, std::is_convertible<V, T>, std::is_constructible<T, V&&>>::type;
+
+            template<bool SizeMatches, class T, class... Vs>
+            struct TupleMoveConstructible : std::false_type
+            {
+            };
+
+            template<class... Ts, class... Vs>
+            struct TupleMoveConstructible<true, CompressedTuple<Ts...>, Vs...> : std::integral_constant<bool, absl::conjunction<TupleElementMoveConstructible<Ts, Vs&&>...>::value>
+            {
+            };
+
+            template<typename T>
+            struct compressed_tuple_size;
+
+            template<typename... Es>
+            struct compressed_tuple_size<CompressedTuple<Es...>> : public std::integral_constant<std::size_t, sizeof...(Es)>
+            {
+            };
+
+            template<class T, class... Vs>
+            struct TupleItemsMoveConstructible : std::integral_constant<bool, TupleMoveConstructible<compressed_tuple_size<T>::value == sizeof...(Vs), T, Vs...>::value>
+            {
+            };
+
+        }  // namespace internal_compressed_tuple
+
+        // Helper class to perform the Empty Base Class Optimization.
+        // Ts can contain classes and non-classes, empty or not. For the ones that
+        // are empty classes, we perform the CompressedTuple. If all types in Ts are
+        // empty classes, then CompressedTuple<Ts...> is itself an empty class.  (This
+        // does not apply when one or more of those empty classes is itself an empty
+        // CompressedTuple.)
+        //
+        // To access the members, use member .get<N>() function.
+        //
+        // Eg:
+        //   absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
+        //                                                                    t3);
+        //   assert(value.get<0>() == 7);
+        //   T1& t1 = value.get<1>();
+        //   const T2& t2 = value.get<2>();
+        //   ...
+        //
+        // https://en.cppreference.com/w/cpp/language/ebo
+        template<typename... Ts>
+        class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple : private internal_compressed_tuple::CompressedTupleImpl<CompressedTuple<Ts...>, absl::index_sequence_for<Ts...>, internal_compressed_tuple::ShouldAnyUseBase<Ts...>()>
+        {
+        private:
+            template<int I>
+            using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
+
+            template<int I>
+            using StorageT = internal_compressed_tuple::Storage<ElemT<I>, I>;
+
+        public:
+            // There seems to be a bug in MSVC dealing in which using '=default' here will
+            // cause the compiler to ignore the body of other constructors. The work-
+            // around is to explicitly implement the default constructor.
 #if defined(_MSC_VER)
-  constexpr CompressedTuple() : CompressedTuple::CompressedTupleImpl() {}
+            constexpr CompressedTuple() :
+                CompressedTuple::CompressedTupleImpl()
+            {
+            }
 #else
-  constexpr CompressedTuple() = default;
+            constexpr CompressedTuple() = default;
 #endif
-  explicit constexpr CompressedTuple(const Ts&... base)
-      : CompressedTuple::CompressedTupleImpl(absl::in_place, base...) {}
-
-  template <typename First, typename... Vs,
-            absl::enable_if_t<
-                absl::conjunction<
-                    // Ensure we are not hiding default copy/move constructors.
-                    absl::negation<std::is_same<void(CompressedTuple),
-                                                void(absl::decay_t<First>)>>,
-                    internal_compressed_tuple::TupleItemsMoveConstructible<
-                        CompressedTuple<Ts...>, First, Vs...>>::value,
-                bool> = true>
-  explicit constexpr CompressedTuple(First&& first, Vs&&... base)
-      : CompressedTuple::CompressedTupleImpl(absl::in_place,
-                                             absl::forward<First>(first),
-                                             absl::forward<Vs>(base)...) {}
-
-  template <int I>
-  ElemT<I>& get() & {
-    return StorageT<I>::get();
-  }
-
-  template <int I>
-  constexpr const ElemT<I>& get() const& {
-    return StorageT<I>::get();
-  }
-
-  template <int I>
-  ElemT<I>&& get() && {
-    return std::move(*this).StorageT<I>::get();
-  }
-
-  template <int I>
-  constexpr const ElemT<I>&& get() const&& {
-    return absl::move(*this).StorageT<I>::get();
-  }
-};
-
-// Explicit specialization for a zero-element tuple
-// (needed to avoid ambiguous overloads for the default constructor).
-template <>
-class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+            explicit constexpr CompressedTuple(const Ts&... base) :
+                CompressedTuple::CompressedTupleImpl(absl::in_place, base...)
+            {
+            }
+
+            template<typename First, typename... Vs, absl::enable_if_t<absl::conjunction<
+                                                                           // Ensure we are not hiding default copy/move constructors.
+                                                                           absl::negation<std::is_same<void(CompressedTuple), void(absl::decay_t<First>)>>,
+                                                                           internal_compressed_tuple::TupleItemsMoveConstructible<CompressedTuple<Ts...>, First, Vs...>>::value,
+                                                                       bool> = true>
+            explicit constexpr CompressedTuple(First&& first, Vs&&... base) :
+                CompressedTuple::CompressedTupleImpl(absl::in_place, absl::forward<First>(first), absl::forward<Vs>(base)...)
+            {
+            }
+
+            template<int I>
+            ElemT<I>& get() &
+            {
+                return StorageT<I>::get();
+            }
+
+            template<int I>
+            constexpr const ElemT<I>& get() const&
+            {
+                return StorageT<I>::get();
+            }
+
+            template<int I>
+            ElemT<I>&& get() &&
+            {
+                return std::move(*this).StorageT<I>::get();
+            }
+
+            template<int I>
+            constexpr const ElemT<I>&& get() const&&
+            {
+                return absl::move(*this).StorageT<I>::get();
+            }
+        };
+
+        // Explicit specialization for a zero-element tuple
+        // (needed to avoid ambiguous overloads for the default constructor).
+        template<>
+        class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<>
+        {
+        };
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #undef ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/container_memory.h b/CAPI/cpp/grpc/include/absl/container/internal/container_memory.h
index 00e9f6d..fa795ac 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/container_memory.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/container_memory.h
@@ -36,407 +36,464 @@
 #include <sanitizer/msan_interface.h>
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <size_t Alignment>
-struct alignas(Alignment) AlignedType {};
-
-// Allocates at least n bytes aligned to the specified alignment.
-// Alignment must be a power of 2. It must be positive.
-//
-// Note that many allocators don't honor alignment requirements above certain
-// threshold (usually either alignof(std::max_align_t) or alignof(void*)).
-// Allocate() doesn't apply alignment corrections. If the underlying allocator
-// returns insufficiently alignment pointer, that's what you are going to get.
-template <size_t Alignment, class Alloc>
-void* Allocate(Alloc* alloc, size_t n) {
-  static_assert(Alignment > 0, "");
-  assert(n && "n must be positive");
-  using M = AlignedType<Alignment>;
-  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
-  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
-  // On macOS, "mem_alloc" is a #define with one argument defined in
-  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
-  // with the "foo(bar)" syntax.
-  A my_mem_alloc(*alloc);
-  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
-  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
-         "allocator does not respect alignment");
-  return p;
-}
-
-// The pointer must have been previously obtained by calling
-// Allocate<Alignment>(alloc, n).
-template <size_t Alignment, class Alloc>
-void Deallocate(Alloc* alloc, void* p, size_t n) {
-  static_assert(Alignment > 0, "");
-  assert(n && "n must be positive");
-  using M = AlignedType<Alignment>;
-  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
-  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
-  // On macOS, "mem_alloc" is a #define with one argument defined in
-  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
-  // with the "foo(bar)" syntax.
-  A my_mem_alloc(*alloc);
-  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
-                 (n + sizeof(M) - 1) / sizeof(M));
-}
-
-namespace memory_internal {
-
-// Constructs T into uninitialized storage pointed by `ptr` using the args
-// specified in the tuple.
-template <class Alloc, class T, class Tuple, size_t... I>
-void ConstructFromTupleImpl(Alloc* alloc, T* ptr, Tuple&& t,
-                            absl::index_sequence<I...>) {
-  absl::allocator_traits<Alloc>::construct(
-      *alloc, ptr, std::get<I>(std::forward<Tuple>(t))...);
-}
-
-template <class T, class F>
-struct WithConstructedImplF {
-  template <class... Args>
-  decltype(std::declval<F>()(std::declval<T>())) operator()(
-      Args&&... args) const {
-    return std::forward<F>(f)(T(std::forward<Args>(args)...));
-  }
-  F&& f;
-};
-
-template <class T, class Tuple, size_t... Is, class F>
-decltype(std::declval<F>()(std::declval<T>())) WithConstructedImpl(
-    Tuple&& t, absl::index_sequence<Is...>, F&& f) {
-  return WithConstructedImplF<T, F>{std::forward<F>(f)}(
-      std::get<Is>(std::forward<Tuple>(t))...);
-}
-
-template <class T, size_t... Is>
-auto TupleRefImpl(T&& t, absl::index_sequence<Is...>)
-    -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...)) {
-  return std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...);
-}
-
-// Returns a tuple of references to the elements of the input tuple. T must be a
-// tuple.
-template <class T>
-auto TupleRef(T&& t) -> decltype(
-    TupleRefImpl(std::forward<T>(t),
-                 absl::make_index_sequence<
-                     std::tuple_size<typename std::decay<T>::type>::value>())) {
-  return TupleRefImpl(
-      std::forward<T>(t),
-      absl::make_index_sequence<
-          std::tuple_size<typename std::decay<T>::type>::value>());
-}
-
-template <class F, class K, class V>
-decltype(std::declval<F>()(std::declval<const K&>(), std::piecewise_construct,
-                           std::declval<std::tuple<K>>(), std::declval<V>()))
-DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
-  const auto& key = std::get<0>(p.first);
-  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
-                            std::move(p.second));
-}
-
-}  // namespace memory_internal
-
-// Constructs T into uninitialized storage pointed by `ptr` using the args
-// specified in the tuple.
-template <class Alloc, class T, class Tuple>
-void ConstructFromTuple(Alloc* alloc, T* ptr, Tuple&& t) {
-  memory_internal::ConstructFromTupleImpl(
-      alloc, ptr, std::forward<Tuple>(t),
-      absl::make_index_sequence<
-          std::tuple_size<typename std::decay<Tuple>::type>::value>());
-}
-
-// Constructs T using the args specified in the tuple and calls F with the
-// constructed value.
-template <class T, class Tuple, class F>
-decltype(std::declval<F>()(std::declval<T>())) WithConstructed(
-    Tuple&& t, F&& f) {
-  return memory_internal::WithConstructedImpl<T>(
-      std::forward<Tuple>(t),
-      absl::make_index_sequence<
-          std::tuple_size<typename std::decay<Tuple>::type>::value>(),
-      std::forward<F>(f));
-}
-
-// Given arguments of an std::pair's consructor, PairArgs() returns a pair of
-// tuples with references to the passed arguments. The tuples contain
-// constructor arguments for the first and the second elements of the pair.
-//
-// The following two snippets are equivalent.
-//
-// 1. std::pair<F, S> p(args...);
-//
-// 2. auto a = PairArgs(args...);
-//    std::pair<F, S> p(std::piecewise_construct,
-//                      std::move(a.first), std::move(a.second));
-inline std::pair<std::tuple<>, std::tuple<>> PairArgs() { return {}; }
-template <class F, class S>
-std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
-  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
-          std::forward_as_tuple(std::forward<S>(s))};
-}
-template <class F, class S>
-std::pair<std::tuple<const F&>, std::tuple<const S&>> PairArgs(
-    const std::pair<F, S>& p) {
-  return PairArgs(p.first, p.second);
-}
-template <class F, class S>
-std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
-  return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
-}
-template <class F, class S>
-auto PairArgs(std::piecewise_construct_t, F&& f, S&& s)
-    -> decltype(std::make_pair(memory_internal::TupleRef(std::forward<F>(f)),
-                               memory_internal::TupleRef(std::forward<S>(s)))) {
-  return std::make_pair(memory_internal::TupleRef(std::forward<F>(f)),
-                        memory_internal::TupleRef(std::forward<S>(s)));
-}
-
-// A helper function for implementing apply() in map policies.
-template <class F, class... Args>
-auto DecomposePair(F&& f, Args&&... args)
-    -> decltype(memory_internal::DecomposePairImpl(
-        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
-  return memory_internal::DecomposePairImpl(
-      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
-}
-
-// A helper function for implementing apply() in set policies.
-template <class F, class Arg>
-decltype(std::declval<F>()(std::declval<const Arg&>(), std::declval<Arg>()))
-DecomposeValue(F&& f, Arg&& arg) {
-  const auto& key = arg;
-  return std::forward<F>(f)(key, std::forward<Arg>(arg));
-}
-
-// Helper functions for asan and msan.
-inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<size_t Alignment>
+        struct alignas(Alignment) AlignedType
+        {
+        };
+
+        // Allocates at least n bytes aligned to the specified alignment.
+        // Alignment must be a power of 2. It must be positive.
+        //
+        // Note that many allocators don't honor alignment requirements above certain
+        // threshold (usually either alignof(std::max_align_t) or alignof(void*)).
+        // Allocate() doesn't apply alignment corrections. If the underlying allocator
+        // returns insufficiently alignment pointer, that's what you are going to get.
+        template<size_t Alignment, class Alloc>
+        void* Allocate(Alloc* alloc, size_t n)
+        {
+            static_assert(Alignment > 0, "");
+            assert(n && "n must be positive");
+            using M = AlignedType<Alignment>;
+            using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
+            using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
+            // On macOS, "mem_alloc" is a #define with one argument defined in
+            // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
+            // with the "foo(bar)" syntax.
+            A my_mem_alloc(*alloc);
+            void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
+            assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 && "allocator does not respect alignment");
+            return p;
+        }
+
+        // The pointer must have been previously obtained by calling
+        // Allocate<Alignment>(alloc, n).
+        template<size_t Alignment, class Alloc>
+        void Deallocate(Alloc* alloc, void* p, size_t n)
+        {
+            static_assert(Alignment > 0, "");
+            assert(n && "n must be positive");
+            using M = AlignedType<Alignment>;
+            using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
+            using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
+            // On macOS, "mem_alloc" is a #define with one argument defined in
+            // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
+            // with the "foo(bar)" syntax.
+            A my_mem_alloc(*alloc);
+            AT::deallocate(my_mem_alloc, static_cast<M*>(p), (n + sizeof(M) - 1) / sizeof(M));
+        }
+
+        namespace memory_internal
+        {
+
+            // Constructs T into uninitialized storage pointed by `ptr` using the args
+            // specified in the tuple.
+            template<class Alloc, class T, class Tuple, size_t... I>
+            void ConstructFromTupleImpl(Alloc* alloc, T* ptr, Tuple&& t, absl::index_sequence<I...>)
+            {
+                absl::allocator_traits<Alloc>::construct(
+                    *alloc, ptr, std::get<I>(std::forward<Tuple>(t))...
+                );
+            }
+
+            template<class T, class F>
+            struct WithConstructedImplF
+            {
+                template<class... Args>
+                decltype(std::declval<F>()(std::declval<T>())) operator()(
+                    Args&&... args
+                ) const
+                {
+                    return std::forward<F>(f)(T(std::forward<Args>(args)...));
+                }
+                F&& f;
+            };
+
+            template<class T, class Tuple, size_t... Is, class F>
+            decltype(std::declval<F>()(std::declval<T>())) WithConstructedImpl(
+                Tuple&& t, absl::index_sequence<Is...>, F&& f
+            )
+            {
+                return WithConstructedImplF<T, F>{std::forward<F>(f)}(
+                    std::get<Is>(std::forward<Tuple>(t))...
+                );
+            }
+
+            template<class T, size_t... Is>
+            auto TupleRefImpl(T&& t, absl::index_sequence<Is...>)
+                -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...))
+            {
+                return std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...);
+            }
+
+            // Returns a tuple of references to the elements of the input tuple. T must be a
+            // tuple.
+            template<class T>
+            auto TupleRef(T&& t) -> decltype(TupleRefImpl(std::forward<T>(t), absl::make_index_sequence<std::tuple_size<typename std::decay<T>::type>::value>()))
+            {
+                return TupleRefImpl(
+                    std::forward<T>(t),
+                    absl::make_index_sequence<
+                        std::tuple_size<typename std::decay<T>::type>::value>()
+                );
+            }
+
+            template<class F, class K, class V>
+            decltype(std::declval<F>()(std::declval<const K&>(), std::piecewise_construct, std::declval<std::tuple<K>>(), std::declval<V>()))
+                DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p)
+            {
+                const auto& key = std::get<0>(p.first);
+                return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first), std::move(p.second));
+            }
+
+        }  // namespace memory_internal
+
+        // Constructs T into uninitialized storage pointed by `ptr` using the args
+        // specified in the tuple.
+        template<class Alloc, class T, class Tuple>
+        void ConstructFromTuple(Alloc* alloc, T* ptr, Tuple&& t)
+        {
+            memory_internal::ConstructFromTupleImpl(
+                alloc, ptr, std::forward<Tuple>(t), absl::make_index_sequence<std::tuple_size<typename std::decay<Tuple>::type>::value>()
+            );
+        }
+
+        // Constructs T using the args specified in the tuple and calls F with the
+        // constructed value.
+        template<class T, class Tuple, class F>
+        decltype(std::declval<F>()(std::declval<T>())) WithConstructed(
+            Tuple&& t, F&& f
+        )
+        {
+            return memory_internal::WithConstructedImpl<T>(
+                std::forward<Tuple>(t),
+                absl::make_index_sequence<
+                    std::tuple_size<typename std::decay<Tuple>::type>::value>(),
+                std::forward<F>(f)
+            );
+        }
+
+        // Given arguments of an std::pair's consructor, PairArgs() returns a pair of
+        // tuples with references to the passed arguments. The tuples contain
+        // constructor arguments for the first and the second elements of the pair.
+        //
+        // The following two snippets are equivalent.
+        //
+        // 1. std::pair<F, S> p(args...);
+        //
+        // 2. auto a = PairArgs(args...);
+        //    std::pair<F, S> p(std::piecewise_construct,
+        //                      std::move(a.first), std::move(a.second));
+        inline std::pair<std::tuple<>, std::tuple<>> PairArgs()
+        {
+            return {};
+        }
+        template<class F, class S>
+        std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s)
+        {
+            return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)), std::forward_as_tuple(std::forward<S>(s))};
+        }
+        template<class F, class S>
+        std::pair<std::tuple<const F&>, std::tuple<const S&>> PairArgs(
+            const std::pair<F, S>& p
+        )
+        {
+            return PairArgs(p.first, p.second);
+        }
+        template<class F, class S>
+        std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p)
+        {
+            return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
+        }
+        template<class F, class S>
+        auto PairArgs(std::piecewise_construct_t, F&& f, S&& s)
+            -> decltype(std::make_pair(memory_internal::TupleRef(std::forward<F>(f)), memory_internal::TupleRef(std::forward<S>(s))))
+        {
+            return std::make_pair(memory_internal::TupleRef(std::forward<F>(f)), memory_internal::TupleRef(std::forward<S>(s)));
+        }
+
+        // A helper function for implementing apply() in map policies.
+        template<class F, class... Args>
+        auto DecomposePair(F&& f, Args&&... args)
+            -> decltype(memory_internal::DecomposePairImpl(
+                std::forward<F>(f), PairArgs(std::forward<Args>(args)...)
+            ))
+        {
+            return memory_internal::DecomposePairImpl(
+                std::forward<F>(f), PairArgs(std::forward<Args>(args)...)
+            );
+        }
+
+        // A helper function for implementing apply() in set policies.
+        template<class F, class Arg>
+        decltype(std::declval<F>()(std::declval<const Arg&>(), std::declval<Arg>()))
+            DecomposeValue(F&& f, Arg&& arg)
+        {
+            const auto& key = arg;
+            return std::forward<F>(f)(key, std::forward<Arg>(arg));
+        }
+
+        // Helper functions for asan and msan.
+        inline void SanitizerPoisonMemoryRegion(const void* m, size_t s)
+        {
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-  ASAN_POISON_MEMORY_REGION(m, s);
+            ASAN_POISON_MEMORY_REGION(m, s);
 #endif
 #ifdef ABSL_HAVE_MEMORY_SANITIZER
-  __msan_poison(m, s);
+            __msan_poison(m, s);
 #endif
-  (void)m;
-  (void)s;
-}
+            (void)m;
+            (void)s;
+        }
 
-inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
+        inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s)
+        {
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-  ASAN_UNPOISON_MEMORY_REGION(m, s);
+            ASAN_UNPOISON_MEMORY_REGION(m, s);
 #endif
 #ifdef ABSL_HAVE_MEMORY_SANITIZER
-  __msan_unpoison(m, s);
+            __msan_unpoison(m, s);
 #endif
-  (void)m;
-  (void)s;
-}
-
-template <typename T>
-inline void SanitizerPoisonObject(const T* object) {
-  SanitizerPoisonMemoryRegion(object, sizeof(T));
-}
-
-template <typename T>
-inline void SanitizerUnpoisonObject(const T* object) {
-  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
-}
-
-namespace memory_internal {
-
-// If Pair is a standard-layout type, OffsetOf<Pair>::kFirst and
-// OffsetOf<Pair>::kSecond are equivalent to offsetof(Pair, first) and
-// offsetof(Pair, second) respectively. Otherwise they are -1.
-//
-// The purpose of OffsetOf is to avoid calling offsetof() on non-standard-layout
-// type, which is non-portable.
-template <class Pair, class = std::true_type>
-struct OffsetOf {
-  static constexpr size_t kFirst = static_cast<size_t>(-1);
-  static constexpr size_t kSecond = static_cast<size_t>(-1);
-};
-
-template <class Pair>
-struct OffsetOf<Pair, typename std::is_standard_layout<Pair>::type> {
-  static constexpr size_t kFirst = offsetof(Pair, first);
-  static constexpr size_t kSecond = offsetof(Pair, second);
-};
-
-template <class K, class V>
-struct IsLayoutCompatible {
- private:
-  struct Pair {
-    K first;
-    V second;
-  };
-
-  // Is P layout-compatible with Pair?
-  template <class P>
-  static constexpr bool LayoutCompatible() {
-    return std::is_standard_layout<P>() && sizeof(P) == sizeof(Pair) &&
-           alignof(P) == alignof(Pair) &&
-           memory_internal::OffsetOf<P>::kFirst ==
-               memory_internal::OffsetOf<Pair>::kFirst &&
-           memory_internal::OffsetOf<P>::kSecond ==
-               memory_internal::OffsetOf<Pair>::kSecond;
-  }
-
- public:
-  // Whether pair<const K, V> and pair<K, V> are layout-compatible. If they are,
-  // then it is safe to store them in a union and read from either.
-  static constexpr bool value = std::is_standard_layout<K>() &&
-                                std::is_standard_layout<Pair>() &&
-                                memory_internal::OffsetOf<Pair>::kFirst == 0 &&
-                                LayoutCompatible<std::pair<K, V>>() &&
-                                LayoutCompatible<std::pair<const K, V>>();
-};
-
-}  // namespace memory_internal
-
-// The internal storage type for key-value containers like flat_hash_map.
-//
-// It is convenient for the value_type of a flat_hash_map<K, V> to be
-// pair<const K, V>; the "const K" prevents accidental modification of the key
-// when dealing with the reference returned from find() and similar methods.
-// However, this creates other problems; we want to be able to emplace(K, V)
-// efficiently with move operations, and similarly be able to move a
-// pair<K, V> in insert().
-//
-// The solution is this union, which aliases the const and non-const versions
-// of the pair. This also allows flat_hash_map<const K, V> to work, even though
-// that has the same efficiency issues with move in emplace() and insert() -
-// but people do it anyway.
-//
-// If kMutableKeys is false, only the value member can be accessed.
-//
-// If kMutableKeys is true, key can be accessed through all slots while value
-// and mutable_value must be accessed only via INITIALIZED slots. Slots are
-// created and destroyed via mutable_value so that the key can be moved later.
-//
-// Accessing one of the union fields while the other is active is safe as
-// long as they are layout-compatible, which is guaranteed by the definition of
-// kMutableKeys. For C++11, the relevant section of the standard is
-// https://timsong-cpp.github.io/cppwp/n3337/class.mem#19 (9.2.19)
-template <class K, class V>
-union map_slot_type {
-  map_slot_type() {}
-  ~map_slot_type() = delete;
-  using value_type = std::pair<const K, V>;
-  using mutable_value_type =
-      std::pair<absl::remove_const_t<K>, absl::remove_const_t<V>>;
-
-  value_type value;
-  mutable_value_type mutable_value;
-  absl::remove_const_t<K> key;
-};
-
-template <class K, class V>
-struct map_slot_policy {
-  using slot_type = map_slot_type<K, V>;
-  using value_type = std::pair<const K, V>;
-  using mutable_value_type = std::pair<K, V>;
-
- private:
-  static void emplace(slot_type* slot) {
-    // The construction of union doesn't do anything at runtime but it allows us
-    // to access its members without violating aliasing rules.
-    new (slot) slot_type;
-  }
-  // If pair<const K, V> and pair<K, V> are layout-compatible, we can accept one
-  // or the other via slot_type. We are also free to access the key via
-  // slot_type::key in this case.
-  using kMutableKeys = memory_internal::IsLayoutCompatible<K, V>;
-
- public:
-  static value_type& element(slot_type* slot) { return slot->value; }
-  static const value_type& element(const slot_type* slot) {
-    return slot->value;
-  }
-
-  // When C++17 is available, we can use std::launder to provide mutable
-  // access to the key for use in node handle.
+            (void)m;
+            (void)s;
+        }
+
+        template<typename T>
+        inline void SanitizerPoisonObject(const T* object)
+        {
+            SanitizerPoisonMemoryRegion(object, sizeof(T));
+        }
+
+        template<typename T>
+        inline void SanitizerUnpoisonObject(const T* object)
+        {
+            SanitizerUnpoisonMemoryRegion(object, sizeof(T));
+        }
+
+        namespace memory_internal
+        {
+
+            // If Pair is a standard-layout type, OffsetOf<Pair>::kFirst and
+            // OffsetOf<Pair>::kSecond are equivalent to offsetof(Pair, first) and
+            // offsetof(Pair, second) respectively. Otherwise they are -1.
+            //
+            // The purpose of OffsetOf is to avoid calling offsetof() on non-standard-layout
+            // type, which is non-portable.
+            template<class Pair, class = std::true_type>
+            struct OffsetOf
+            {
+                static constexpr size_t kFirst = static_cast<size_t>(-1);
+                static constexpr size_t kSecond = static_cast<size_t>(-1);
+            };
+
+            template<class Pair>
+            struct OffsetOf<Pair, typename std::is_standard_layout<Pair>::type>
+            {
+                static constexpr size_t kFirst = offsetof(Pair, first);
+                static constexpr size_t kSecond = offsetof(Pair, second);
+            };
+
+            template<class K, class V>
+            struct IsLayoutCompatible
+            {
+            private:
+                struct Pair
+                {
+                    K first;
+                    V second;
+                };
+
+                // Is P layout-compatible with Pair?
+                template<class P>
+                static constexpr bool LayoutCompatible()
+                {
+                    return std::is_standard_layout<P>() && sizeof(P) == sizeof(Pair) &&
+                           alignof(P) == alignof(Pair) &&
+                           memory_internal::OffsetOf<P>::kFirst ==
+                               memory_internal::OffsetOf<Pair>::kFirst &&
+                           memory_internal::OffsetOf<P>::kSecond ==
+                               memory_internal::OffsetOf<Pair>::kSecond;
+                }
+
+            public:
+                // Whether pair<const K, V> and pair<K, V> are layout-compatible. If they are,
+                // then it is safe to store them in a union and read from either.
+                static constexpr bool value = std::is_standard_layout<K>() &&
+                                              std::is_standard_layout<Pair>() &&
+                                              memory_internal::OffsetOf<Pair>::kFirst == 0 &&
+                                              LayoutCompatible<std::pair<K, V>>() &&
+                                              LayoutCompatible<std::pair<const K, V>>();
+            };
+
+        }  // namespace memory_internal
+
+        // The internal storage type for key-value containers like flat_hash_map.
+        //
+        // It is convenient for the value_type of a flat_hash_map<K, V> to be
+        // pair<const K, V>; the "const K" prevents accidental modification of the key
+        // when dealing with the reference returned from find() and similar methods.
+        // However, this creates other problems; we want to be able to emplace(K, V)
+        // efficiently with move operations, and similarly be able to move a
+        // pair<K, V> in insert().
+        //
+        // The solution is this union, which aliases the const and non-const versions
+        // of the pair. This also allows flat_hash_map<const K, V> to work, even though
+        // that has the same efficiency issues with move in emplace() and insert() -
+        // but people do it anyway.
+        //
+        // If kMutableKeys is false, only the value member can be accessed.
+        //
+        // If kMutableKeys is true, key can be accessed through all slots while value
+        // and mutable_value must be accessed only via INITIALIZED slots. Slots are
+        // created and destroyed via mutable_value so that the key can be moved later.
+        //
+        // Accessing one of the union fields while the other is active is safe as
+        // long as they are layout-compatible, which is guaranteed by the definition of
+        // kMutableKeys. For C++11, the relevant section of the standard is
+        // https://timsong-cpp.github.io/cppwp/n3337/class.mem#19 (9.2.19)
+        template<class K, class V>
+        union map_slot_type
+        {
+            map_slot_type()
+            {
+            }
+            ~map_slot_type() = delete;
+            using value_type = std::pair<const K, V>;
+            using mutable_value_type =
+                std::pair<absl::remove_const_t<K>, absl::remove_const_t<V>>;
+
+            value_type value;
+            mutable_value_type mutable_value;
+            absl::remove_const_t<K> key;
+        };
+
+        template<class K, class V>
+        struct map_slot_policy
+        {
+            using slot_type = map_slot_type<K, V>;
+            using value_type = std::pair<const K, V>;
+            using mutable_value_type = std::pair<K, V>;
+
+        private:
+            static void emplace(slot_type* slot)
+            {
+                // The construction of union doesn't do anything at runtime but it allows us
+                // to access its members without violating aliasing rules.
+                new (slot) slot_type;
+            }
+            // If pair<const K, V> and pair<K, V> are layout-compatible, we can accept one
+            // or the other via slot_type. We are also free to access the key via
+            // slot_type::key in this case.
+            using kMutableKeys = memory_internal::IsLayoutCompatible<K, V>;
+
+        public:
+            static value_type& element(slot_type* slot)
+            {
+                return slot->value;
+            }
+            static const value_type& element(const slot_type* slot)
+            {
+                return slot->value;
+            }
+
+            // When C++17 is available, we can use std::launder to provide mutable
+            // access to the key for use in node handle.
 #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
-  static K& mutable_key(slot_type* slot) {
-    // Still check for kMutableKeys so that we can avoid calling std::launder
-    // unless necessary because it can interfere with optimizations.
-    return kMutableKeys::value ? slot->key
-                               : *std::launder(const_cast<K*>(
-                                     std::addressof(slot->value.first)));
-  }
+            static K& mutable_key(slot_type* slot)
+            {
+                // Still check for kMutableKeys so that we can avoid calling std::launder
+                // unless necessary because it can interfere with optimizations.
+                return kMutableKeys::value ? slot->key : *std::launder(const_cast<K*>(std::addressof(slot->value.first)));
+            }
 #else  // !(defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606)
-  static const K& mutable_key(slot_type* slot) { return key(slot); }
+            static const K& mutable_key(slot_type* slot)
+            {
+                return key(slot);
+            }
 #endif
 
-  static const K& key(const slot_type* slot) {
-    return kMutableKeys::value ? slot->key : slot->value.first;
-  }
-
-  template <class Allocator, class... Args>
-  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
-    emplace(slot);
-    if (kMutableKeys::value) {
-      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
-                                                   std::forward<Args>(args)...);
-    } else {
-      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
-                                                   std::forward<Args>(args)...);
-    }
-  }
-
-  // Construct this slot by moving from another slot.
-  template <class Allocator>
-  static void construct(Allocator* alloc, slot_type* slot, slot_type* other) {
-    emplace(slot);
-    if (kMutableKeys::value) {
-      absl::allocator_traits<Allocator>::construct(
-          *alloc, &slot->mutable_value, std::move(other->mutable_value));
-    } else {
-      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
-                                                   std::move(other->value));
-    }
-  }
-
-  // Construct this slot by copying from another slot.
-  template <class Allocator>
-  static void construct(Allocator* alloc, slot_type* slot,
-                        const slot_type* other) {
-    emplace(slot);
-    absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
-                                                 other->value);
-  }
-
-  template <class Allocator>
-  static void destroy(Allocator* alloc, slot_type* slot) {
-    if (kMutableKeys::value) {
-      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
-    } else {
-      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
-    }
-  }
-
-  template <class Allocator>
-  static void transfer(Allocator* alloc, slot_type* new_slot,
-                       slot_type* old_slot) {
-    emplace(new_slot);
-    if (kMutableKeys::value) {
-      absl::allocator_traits<Allocator>::construct(
-          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
-    } else {
-      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
-                                                   std::move(old_slot->value));
-    }
-    destroy(alloc, old_slot);
-  }
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+            static const K& key(const slot_type* slot)
+            {
+                return kMutableKeys::value ? slot->key : slot->value.first;
+            }
+
+            template<class Allocator, class... Args>
+            static void construct(Allocator* alloc, slot_type* slot, Args&&... args)
+            {
+                emplace(slot);
+                if (kMutableKeys::value)
+                {
+                    absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value, std::forward<Args>(args)...);
+                }
+                else
+                {
+                    absl::allocator_traits<Allocator>::construct(*alloc, &slot->value, std::forward<Args>(args)...);
+                }
+            }
+
+            // Construct this slot by moving from another slot.
+            template<class Allocator>
+            static void construct(Allocator* alloc, slot_type* slot, slot_type* other)
+            {
+                emplace(slot);
+                if (kMutableKeys::value)
+                {
+                    absl::allocator_traits<Allocator>::construct(
+                        *alloc, &slot->mutable_value, std::move(other->mutable_value)
+                    );
+                }
+                else
+                {
+                    absl::allocator_traits<Allocator>::construct(*alloc, &slot->value, std::move(other->value));
+                }
+            }
+
+            // Construct this slot by copying from another slot.
+            template<class Allocator>
+            static void construct(Allocator* alloc, slot_type* slot, const slot_type* other)
+            {
+                emplace(slot);
+                absl::allocator_traits<Allocator>::construct(*alloc, &slot->value, other->value);
+            }
+
+            template<class Allocator>
+            static void destroy(Allocator* alloc, slot_type* slot)
+            {
+                if (kMutableKeys::value)
+                {
+                    absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
+                }
+                else
+                {
+                    absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
+                }
+            }
+
+            template<class Allocator>
+            static void transfer(Allocator* alloc, slot_type* new_slot, slot_type* old_slot)
+            {
+                emplace(new_slot);
+                if (kMutableKeys::value)
+                {
+                    absl::allocator_traits<Allocator>::construct(
+                        *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value)
+                    );
+                }
+                else
+                {
+                    absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value, std::move(old_slot->value));
+                }
+                destroy(alloc, old_slot);
+            }
+        };
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/counting_allocator.h b/CAPI/cpp/grpc/include/absl/container/internal/counting_allocator.h
index 66068a5..01c5dd3 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/counting_allocator.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/counting_allocator.h
@@ -20,103 +20,125 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// This is a stateful allocator, but the state lives outside of the
-// allocator (in whatever test is using the allocator). This is odd
-// but helps in tests where the allocator is propagated into nested
-// containers - that chain of allocators uses the same state and is
-// thus easier to query for aggregate allocation information.
-template <typename T>
-class CountingAllocator {
- public:
-  using Allocator = std::allocator<T>;
-  using AllocatorTraits = std::allocator_traits<Allocator>;
-  using value_type = typename AllocatorTraits::value_type;
-  using pointer = typename AllocatorTraits::pointer;
-  using const_pointer = typename AllocatorTraits::const_pointer;
-  using size_type = typename AllocatorTraits::size_type;
-  using difference_type = typename AllocatorTraits::difference_type;
-
-  CountingAllocator() = default;
-  explicit CountingAllocator(int64_t* bytes_used) : bytes_used_(bytes_used) {}
-  CountingAllocator(int64_t* bytes_used, int64_t* instance_count)
-      : bytes_used_(bytes_used), instance_count_(instance_count) {}
-
-  template <typename U>
-  CountingAllocator(const CountingAllocator<U>& x)
-      : bytes_used_(x.bytes_used_), instance_count_(x.instance_count_) {}
-
-  pointer allocate(
-      size_type n,
-      typename AllocatorTraits::const_void_pointer hint = nullptr) {
-    Allocator allocator;
-    pointer ptr = AllocatorTraits::allocate(allocator, n, hint);
-    if (bytes_used_ != nullptr) {
-      *bytes_used_ += n * sizeof(T);
-    }
-    return ptr;
-  }
-
-  void deallocate(pointer p, size_type n) {
-    Allocator allocator;
-    AllocatorTraits::deallocate(allocator, p, n);
-    if (bytes_used_ != nullptr) {
-      *bytes_used_ -= n * sizeof(T);
-    }
-  }
-
-  template <typename U, typename... Args>
-  void construct(U* p, Args&&... args) {
-    Allocator allocator;
-    AllocatorTraits::construct(allocator, p, std::forward<Args>(args)...);
-    if (instance_count_ != nullptr) {
-      *instance_count_ += 1;
-    }
-  }
-
-  template <typename U>
-  void destroy(U* p) {
-    Allocator allocator;
-    // Ignore GCC warning bug.
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        // This is a stateful allocator, but the state lives outside of the
+        // allocator (in whatever test is using the allocator). This is odd
+        // but helps in tests where the allocator is propagated into nested
+        // containers - that chain of allocators uses the same state and is
+        // thus easier to query for aggregate allocation information.
+        template<typename T>
+        class CountingAllocator
+        {
+        public:
+            using Allocator = std::allocator<T>;
+            using AllocatorTraits = std::allocator_traits<Allocator>;
+            using value_type = typename AllocatorTraits::value_type;
+            using pointer = typename AllocatorTraits::pointer;
+            using const_pointer = typename AllocatorTraits::const_pointer;
+            using size_type = typename AllocatorTraits::size_type;
+            using difference_type = typename AllocatorTraits::difference_type;
+
+            CountingAllocator() = default;
+            explicit CountingAllocator(int64_t* bytes_used) :
+                bytes_used_(bytes_used)
+            {
+            }
+            CountingAllocator(int64_t* bytes_used, int64_t* instance_count) :
+                bytes_used_(bytes_used),
+                instance_count_(instance_count)
+            {
+            }
+
+            template<typename U>
+            CountingAllocator(const CountingAllocator<U>& x) :
+                bytes_used_(x.bytes_used_),
+                instance_count_(x.instance_count_)
+            {
+            }
+
+            pointer allocate(
+                size_type n,
+                typename AllocatorTraits::const_void_pointer hint = nullptr
+            )
+            {
+                Allocator allocator;
+                pointer ptr = AllocatorTraits::allocate(allocator, n, hint);
+                if (bytes_used_ != nullptr)
+                {
+                    *bytes_used_ += n * sizeof(T);
+                }
+                return ptr;
+            }
+
+            void deallocate(pointer p, size_type n)
+            {
+                Allocator allocator;
+                AllocatorTraits::deallocate(allocator, p, n);
+                if (bytes_used_ != nullptr)
+                {
+                    *bytes_used_ -= n * sizeof(T);
+                }
+            }
+
+            template<typename U, typename... Args>
+            void construct(U* p, Args&&... args)
+            {
+                Allocator allocator;
+                AllocatorTraits::construct(allocator, p, std::forward<Args>(args)...);
+                if (instance_count_ != nullptr)
+                {
+                    *instance_count_ += 1;
+                }
+            }
+
+            template<typename U>
+            void destroy(U* p)
+            {
+                Allocator allocator;
+                // Ignore GCC warning bug.
 #if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wuse-after-free"
 #endif
-    AllocatorTraits::destroy(allocator, p);
+                AllocatorTraits::destroy(allocator, p);
 #if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
 #pragma GCC diagnostic pop
 #endif
-    if (instance_count_ != nullptr) {
-      *instance_count_ -= 1;
-    }
-  }
-
-  template <typename U>
-  class rebind {
-   public:
-    using other = CountingAllocator<U>;
-  };
-
-  friend bool operator==(const CountingAllocator& a,
-                         const CountingAllocator& b) {
-    return a.bytes_used_ == b.bytes_used_ &&
-           a.instance_count_ == b.instance_count_;
-  }
-
-  friend bool operator!=(const CountingAllocator& a,
-                         const CountingAllocator& b) {
-    return !(a == b);
-  }
-
-  int64_t* bytes_used_ = nullptr;
-  int64_t* instance_count_ = nullptr;
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+                if (instance_count_ != nullptr)
+                {
+                    *instance_count_ -= 1;
+                }
+            }
+
+            template<typename U>
+            class rebind
+            {
+            public:
+                using other = CountingAllocator<U>;
+            };
+
+            friend bool operator==(const CountingAllocator& a, const CountingAllocator& b)
+            {
+                return a.bytes_used_ == b.bytes_used_ &&
+                       a.instance_count_ == b.instance_count_;
+            }
+
+            friend bool operator!=(const CountingAllocator& a, const CountingAllocator& b)
+            {
+                return !(a == b);
+            }
+
+            int64_t* bytes_used_ = nullptr;
+            int64_t* instance_count_ = nullptr;
+        };
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hash_function_defaults.h b/CAPI/cpp/grpc/include/absl/container/internal/hash_function_defaults.h
index 250e662..a664482 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/hash_function_defaults.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hash_function_defaults.h
@@ -56,108 +56,140 @@
 #include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// The hash of an object of type T is computed by using absl::Hash.
-template <class T, class E = void>
-struct HashEq {
-  using Hash = absl::Hash<T>;
-  using Eq = std::equal_to<T>;
-};
-
-struct StringHash {
-  using is_transparent = void;
-
-  size_t operator()(absl::string_view v) const {
-    return absl::Hash<absl::string_view>{}(v);
-  }
-  size_t operator()(const absl::Cord& v) const {
-    return absl::Hash<absl::Cord>{}(v);
-  }
-};
-
-struct StringEq {
-  using is_transparent = void;
-  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
-    return lhs == rhs;
-  }
-  bool operator()(const absl::Cord& lhs, const absl::Cord& rhs) const {
-    return lhs == rhs;
-  }
-  bool operator()(const absl::Cord& lhs, absl::string_view rhs) const {
-    return lhs == rhs;
-  }
-  bool operator()(absl::string_view lhs, const absl::Cord& rhs) const {
-    return lhs == rhs;
-  }
-};
-
-// Supports heterogeneous lookup for string-like elements.
-struct StringHashEq {
-  using Hash = StringHash;
-  using Eq = StringEq;
-};
-
-template <>
-struct HashEq<std::string> : StringHashEq {};
-template <>
-struct HashEq<absl::string_view> : StringHashEq {};
-template <>
-struct HashEq<absl::Cord> : StringHashEq {};
-
-// Supports heterogeneous lookup for pointers and smart pointers.
-template <class T>
-struct HashEq<T*> {
-  struct Hash {
-    using is_transparent = void;
-    template <class U>
-    size_t operator()(const U& ptr) const {
-      return absl::Hash<const T*>{}(HashEq::ToPtr(ptr));
-    }
-  };
-  struct Eq {
-    using is_transparent = void;
-    template <class A, class B>
-    bool operator()(const A& a, const B& b) const {
-      return HashEq::ToPtr(a) == HashEq::ToPtr(b);
-    }
-  };
-
- private:
-  static const T* ToPtr(const T* ptr) { return ptr; }
-  template <class U, class D>
-  static const T* ToPtr(const std::unique_ptr<U, D>& ptr) {
-    return ptr.get();
-  }
-  template <class U>
-  static const T* ToPtr(const std::shared_ptr<U>& ptr) {
-    return ptr.get();
-  }
-};
-
-template <class T, class D>
-struct HashEq<std::unique_ptr<T, D>> : HashEq<T*> {};
-template <class T>
-struct HashEq<std::shared_ptr<T>> : HashEq<T*> {};
-
-// This header's visibility is restricted.  If you need to access the default
-// hasher please use the container's ::hasher alias instead.
-//
-// Example: typename Hash = typename absl::flat_hash_map<K, V>::hasher
-template <class T>
-using hash_default_hash = typename container_internal::HashEq<T>::Hash;
-
-// This header's visibility is restricted.  If you need to access the default
-// key equal please use the container's ::key_equal alias instead.
-//
-// Example: typename Eq = typename absl::flat_hash_map<K, V, Hash>::key_equal
-template <class T>
-using hash_default_eq = typename container_internal::HashEq<T>::Eq;
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        // The hash of an object of type T is computed by using absl::Hash.
+        template<class T, class E = void>
+        struct HashEq
+        {
+            using Hash = absl::Hash<T>;
+            using Eq = std::equal_to<T>;
+        };
+
+        struct StringHash
+        {
+            using is_transparent = void;
+
+            size_t operator()(absl::string_view v) const
+            {
+                return absl::Hash<absl::string_view>{}(v);
+            }
+            size_t operator()(const absl::Cord& v) const
+            {
+                return absl::Hash<absl::Cord>{}(v);
+            }
+        };
+
+        struct StringEq
+        {
+            using is_transparent = void;
+            bool operator()(absl::string_view lhs, absl::string_view rhs) const
+            {
+                return lhs == rhs;
+            }
+            bool operator()(const absl::Cord& lhs, const absl::Cord& rhs) const
+            {
+                return lhs == rhs;
+            }
+            bool operator()(const absl::Cord& lhs, absl::string_view rhs) const
+            {
+                return lhs == rhs;
+            }
+            bool operator()(absl::string_view lhs, const absl::Cord& rhs) const
+            {
+                return lhs == rhs;
+            }
+        };
+
+        // Supports heterogeneous lookup for string-like elements.
+        struct StringHashEq
+        {
+            using Hash = StringHash;
+            using Eq = StringEq;
+        };
+
+        template<>
+        struct HashEq<std::string> : StringHashEq
+        {
+        };
+        template<>
+        struct HashEq<absl::string_view> : StringHashEq
+        {
+        };
+        template<>
+        struct HashEq<absl::Cord> : StringHashEq
+        {
+        };
+
+        // Supports heterogeneous lookup for pointers and smart pointers.
+        template<class T>
+        struct HashEq<T*>
+        {
+            struct Hash
+            {
+                using is_transparent = void;
+                template<class U>
+                size_t operator()(const U& ptr) const
+                {
+                    return absl::Hash<const T*>{}(HashEq::ToPtr(ptr));
+                }
+            };
+            struct Eq
+            {
+                using is_transparent = void;
+                template<class A, class B>
+                bool operator()(const A& a, const B& b) const
+                {
+                    return HashEq::ToPtr(a) == HashEq::ToPtr(b);
+                }
+            };
+
+        private:
+            static const T* ToPtr(const T* ptr)
+            {
+                return ptr;
+            }
+            template<class U, class D>
+            static const T* ToPtr(const std::unique_ptr<U, D>& ptr)
+            {
+                return ptr.get();
+            }
+            template<class U>
+            static const T* ToPtr(const std::shared_ptr<U>& ptr)
+            {
+                return ptr.get();
+            }
+        };
+
+        template<class T, class D>
+        struct HashEq<std::unique_ptr<T, D>> : HashEq<T*>
+        {
+        };
+        template<class T>
+        struct HashEq<std::shared_ptr<T>> : HashEq<T*>
+        {
+        };
+
+        // This header's visibility is restricted.  If you need to access the default
+        // hasher please use the container's ::hasher alias instead.
+        //
+        // Example: typename Hash = typename absl::flat_hash_map<K, V>::hasher
+        template<class T>
+        using hash_default_hash = typename container_internal::HashEq<T>::Hash;
+
+        // This header's visibility is restricted.  If you need to access the default
+        // key equal please use the container's ::key_equal alias instead.
+        //
+        // Example: typename Eq = typename absl::flat_hash_map<K, V, Hash>::key_equal
+        template<class T>
+        using hash_default_eq = typename container_internal::HashEq<T>::Eq;
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hash_generator_testing.h b/CAPI/cpp/grpc/include/absl/container/internal/hash_generator_testing.h
index f1f555a..a565748 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/hash_generator_testing.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hash_generator_testing.h
@@ -34,149 +34,176 @@
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-namespace hash_internal {
-namespace generator_internal {
-
-template <class Container, class = void>
-struct IsMap : std::false_type {};
-
-template <class Map>
-struct IsMap<Map, absl::void_t<typename Map::mapped_type>> : std::true_type {};
-
-}  // namespace generator_internal
-
-std::mt19937_64* GetSharedRng();
-
-enum Enum {
-  kEnumEmpty,
-  kEnumDeleted,
-};
-
-enum class EnumClass : uint64_t {
-  kEmpty,
-  kDeleted,
-};
-
-inline std::ostream& operator<<(std::ostream& o, const EnumClass& ec) {
-  return o << static_cast<uint64_t>(ec);
-}
-
-template <class T, class E = void>
-struct Generator;
-
-template <class T>
-struct Generator<T, typename std::enable_if<std::is_integral<T>::value>::type> {
-  T operator()() const {
-    std::uniform_int_distribution<T> dist;
-    return dist(*GetSharedRng());
-  }
-};
-
-template <>
-struct Generator<Enum> {
-  Enum operator()() const {
-    std::uniform_int_distribution<typename std::underlying_type<Enum>::type>
-        dist;
-    while (true) {
-      auto variate = dist(*GetSharedRng());
-      if (variate != kEnumEmpty && variate != kEnumDeleted)
-        return static_cast<Enum>(variate);
-    }
-  }
-};
-
-template <>
-struct Generator<EnumClass> {
-  EnumClass operator()() const {
-    std::uniform_int_distribution<
-        typename std::underlying_type<EnumClass>::type>
-        dist;
-    while (true) {
-      EnumClass variate = static_cast<EnumClass>(dist(*GetSharedRng()));
-      if (variate != EnumClass::kEmpty && variate != EnumClass::kDeleted)
-        return static_cast<EnumClass>(variate);
-    }
-  }
-};
-
-template <>
-struct Generator<std::string> {
-  std::string operator()() const;
-};
-
-template <>
-struct Generator<absl::string_view> {
-  absl::string_view operator()() const;
-};
-
-template <>
-struct Generator<NonStandardLayout> {
-  NonStandardLayout operator()() const {
-    return NonStandardLayout(Generator<std::string>()());
-  }
-};
-
-template <class K, class V>
-struct Generator<std::pair<K, V>> {
-  std::pair<K, V> operator()() const {
-    return std::pair<K, V>(Generator<typename std::decay<K>::type>()(),
-                           Generator<typename std::decay<V>::type>()());
-  }
-};
-
-template <class... Ts>
-struct Generator<std::tuple<Ts...>> {
-  std::tuple<Ts...> operator()() const {
-    return std::tuple<Ts...>(Generator<typename std::decay<Ts>::type>()()...);
-  }
-};
-
-template <class T>
-struct Generator<std::unique_ptr<T>> {
-  std::unique_ptr<T> operator()() const {
-    return absl::make_unique<T>(Generator<T>()());
-  }
-};
-
-template <class U>
-struct Generator<U, absl::void_t<decltype(std::declval<U&>().key()),
-                                decltype(std::declval<U&>().value())>>
-    : Generator<std::pair<
-          typename std::decay<decltype(std::declval<U&>().key())>::type,
-          typename std::decay<decltype(std::declval<U&>().value())>::type>> {};
-
-template <class Container>
-using GeneratedType = decltype(
-    std::declval<const Generator<
-        typename std::conditional<generator_internal::IsMap<Container>::value,
-                                  typename Container::value_type,
-                                  typename Container::key_type>::type>&>()());
-
-// Naive wrapper that performs a linear search of previous values.
-// Beware this is O(SQR), which is reasonable for smaller kMaxValues.
-template <class T, size_t kMaxValues = 64, class E = void>
-struct UniqueGenerator {
-  Generator<T, E> gen;
-  std::vector<T> values;
-
-  T operator()() {
-    assert(values.size() < kMaxValues);
-    for (;;) {
-      T value = gen();
-      if (std::find(values.begin(), values.end(), value) == values.end()) {
-        values.push_back(value);
-        return value;
-      }
-    }
-  }
-};
-
-}  // namespace hash_internal
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+        namespace hash_internal
+        {
+            namespace generator_internal
+            {
+
+                template<class Container, class = void>
+                struct IsMap : std::false_type
+                {
+                };
+
+                template<class Map>
+                struct IsMap<Map, absl::void_t<typename Map::mapped_type>> : std::true_type
+                {
+                };
+
+            }  // namespace generator_internal
+
+            std::mt19937_64* GetSharedRng();
+
+            enum Enum
+            {
+                kEnumEmpty,
+                kEnumDeleted,
+            };
+
+            enum class EnumClass : uint64_t
+            {
+                kEmpty,
+                kDeleted,
+            };
+
+            inline std::ostream& operator<<(std::ostream& o, const EnumClass& ec)
+            {
+                return o << static_cast<uint64_t>(ec);
+            }
+
+            template<class T, class E = void>
+            struct Generator;
+
+            template<class T>
+            struct Generator<T, typename std::enable_if<std::is_integral<T>::value>::type>
+            {
+                T operator()() const
+                {
+                    std::uniform_int_distribution<T> dist;
+                    return dist(*GetSharedRng());
+                }
+            };
+
+            template<>
+            struct Generator<Enum>
+            {
+                Enum operator()() const
+                {
+                    std::uniform_int_distribution<typename std::underlying_type<Enum>::type>
+                        dist;
+                    while (true)
+                    {
+                        auto variate = dist(*GetSharedRng());
+                        if (variate != kEnumEmpty && variate != kEnumDeleted)
+                            return static_cast<Enum>(variate);
+                    }
+                }
+            };
+
+            template<>
+            struct Generator<EnumClass>
+            {
+                EnumClass operator()() const
+                {
+                    std::uniform_int_distribution<
+                        typename std::underlying_type<EnumClass>::type>
+                        dist;
+                    while (true)
+                    {
+                        EnumClass variate = static_cast<EnumClass>(dist(*GetSharedRng()));
+                        if (variate != EnumClass::kEmpty && variate != EnumClass::kDeleted)
+                            return static_cast<EnumClass>(variate);
+                    }
+                }
+            };
+
+            template<>
+            struct Generator<std::string>
+            {
+                std::string operator()() const;
+            };
+
+            template<>
+            struct Generator<absl::string_view>
+            {
+                absl::string_view operator()() const;
+            };
+
+            template<>
+            struct Generator<NonStandardLayout>
+            {
+                NonStandardLayout operator()() const
+                {
+                    return NonStandardLayout(Generator<std::string>()());
+                }
+            };
+
+            template<class K, class V>
+            struct Generator<std::pair<K, V>>
+            {
+                std::pair<K, V> operator()() const
+                {
+                    return std::pair<K, V>(Generator<typename std::decay<K>::type>()(), Generator<typename std::decay<V>::type>()());
+                }
+            };
+
+            template<class... Ts>
+            struct Generator<std::tuple<Ts...>>
+            {
+                std::tuple<Ts...> operator()() const
+                {
+                    return std::tuple<Ts...>(Generator<typename std::decay<Ts>::type>()()...);
+                }
+            };
+
+            template<class T>
+            struct Generator<std::unique_ptr<T>>
+            {
+                std::unique_ptr<T> operator()() const
+                {
+                    return absl::make_unique<T>(Generator<T>()());
+                }
+            };
+
+            template<class U>
+            struct Generator<U, absl::void_t<decltype(std::declval<U&>().key()), decltype(std::declval<U&>().value())>> : Generator<std::pair<typename std::decay<decltype(std::declval<U&>().key())>::type, typename std::decay<decltype(std::declval<U&>().value())>::type>>
+            {
+            };
+
+            template<class Container>
+            using GeneratedType = decltype(std::declval<const Generator<
+                                               typename std::conditional<generator_internal::IsMap<Container>::value, typename Container::value_type, typename Container::key_type>::type>&>()());
+
+            // Naive wrapper that performs a linear search of previous values.
+            // Beware this is O(SQR), which is reasonable for smaller kMaxValues.
+            template<class T, size_t kMaxValues = 64, class E = void>
+            struct UniqueGenerator
+            {
+                Generator<T, E> gen;
+                std::vector<T> values;
+
+                T operator()()
+                {
+                    assert(values.size() < kMaxValues);
+                    for (;;)
+                    {
+                        T value = gen();
+                        if (std::find(values.begin(), values.end(), value) == values.end())
+                        {
+                            values.push_back(value);
+                            return value;
+                        }
+                    }
+                }
+            };
+
+        }  // namespace hash_internal
+    }      // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_testing.h b/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_testing.h
index 01c40d2..5577ab7 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_testing.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_testing.h
@@ -29,141 +29,197 @@
 #include "absl/hash/hash.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-namespace hash_testing_internal {
-
-template <class Derived>
-struct WithId {
-  WithId() : id_(next_id<Derived>()) {}
-  WithId(const WithId& that) : id_(that.id_) {}
-  WithId(WithId&& that) : id_(that.id_) { that.id_ = 0; }
-  WithId& operator=(const WithId& that) {
-    id_ = that.id_;
-    return *this;
-  }
-  WithId& operator=(WithId&& that) {
-    id_ = that.id_;
-    that.id_ = 0;
-    return *this;
-  }
-
-  size_t id() const { return id_; }
-
-  friend bool operator==(const WithId& a, const WithId& b) {
-    return a.id_ == b.id_;
-  }
-  friend bool operator!=(const WithId& a, const WithId& b) { return !(a == b); }
-
- protected:
-  explicit WithId(size_t id) : id_(id) {}
-
- private:
-  size_t id_;
-
-  template <class T>
-  static size_t next_id() {
-    // 0 is reserved for moved from state.
-    static size_t gId = 1;
-    return gId++;
-  }
-};
-
-}  // namespace hash_testing_internal
-
-struct NonStandardLayout {
-  NonStandardLayout() {}
-  explicit NonStandardLayout(std::string s) : value(std::move(s)) {}
-  virtual ~NonStandardLayout() {}
-
-  friend bool operator==(const NonStandardLayout& a,
-                         const NonStandardLayout& b) {
-    return a.value == b.value;
-  }
-  friend bool operator!=(const NonStandardLayout& a,
-                         const NonStandardLayout& b) {
-    return a.value != b.value;
-  }
-
-  template <typename H>
-  friend H AbslHashValue(H h, const NonStandardLayout& v) {
-    return H::combine(std::move(h), v.value);
-  }
-
-  std::string value;
-};
-
-struct StatefulTestingHash
-    : absl::container_internal::hash_testing_internal::WithId<
-          StatefulTestingHash> {
-  template <class T>
-  size_t operator()(const T& t) const {
-    return absl::Hash<T>{}(t);
-  }
-};
-
-struct StatefulTestingEqual
-    : absl::container_internal::hash_testing_internal::WithId<
-          StatefulTestingEqual> {
-  template <class T, class U>
-  bool operator()(const T& t, const U& u) const {
-    return t == u;
-  }
-};
-
-// It is expected that Alloc() == Alloc() for all allocators so we cannot use
-// WithId base. We need to explicitly assign ids.
-template <class T = int>
-struct Alloc : std::allocator<T> {
-  using propagate_on_container_swap = std::true_type;
-
-  // Using old paradigm for this to ensure compatibility.
-  explicit Alloc(size_t id = 0) : id_(id) {}
-
-  Alloc(const Alloc&) = default;
-  Alloc& operator=(const Alloc&) = default;
-
-  template <class U>
-  Alloc(const Alloc<U>& that) : std::allocator<T>(that), id_(that.id()) {}
-
-  template <class U>
-  struct rebind {
-    using other = Alloc<U>;
-  };
-
-  size_t id() const { return id_; }
-
-  friend bool operator==(const Alloc& a, const Alloc& b) {
-    return a.id_ == b.id_;
-  }
-  friend bool operator!=(const Alloc& a, const Alloc& b) { return !(a == b); }
-
- private:
-  size_t id_ = (std::numeric_limits<size_t>::max)();
-};
-
-template <class Map>
-auto items(const Map& m) -> std::vector<
-    std::pair<typename Map::key_type, typename Map::mapped_type>> {
-  using std::get;
-  std::vector<std::pair<typename Map::key_type, typename Map::mapped_type>> res;
-  res.reserve(m.size());
-  for (const auto& v : m) res.emplace_back(get<0>(v), get<1>(v));
-  return res;
-}
-
-template <class Set>
-auto keys(const Set& s)
-    -> std::vector<typename std::decay<typename Set::key_type>::type> {
-  std::vector<typename std::decay<typename Set::key_type>::type> res;
-  res.reserve(s.size());
-  for (const auto& v : s) res.emplace_back(v);
-  return res;
-}
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+        namespace hash_testing_internal
+        {
+
+            template<class Derived>
+            struct WithId
+            {
+                WithId() :
+                    id_(next_id<Derived>())
+                {
+                }
+                WithId(const WithId& that) :
+                    id_(that.id_)
+                {
+                }
+                WithId(WithId&& that) :
+                    id_(that.id_)
+                {
+                    that.id_ = 0;
+                }
+                WithId& operator=(const WithId& that)
+                {
+                    id_ = that.id_;
+                    return *this;
+                }
+                WithId& operator=(WithId&& that)
+                {
+                    id_ = that.id_;
+                    that.id_ = 0;
+                    return *this;
+                }
+
+                size_t id() const
+                {
+                    return id_;
+                }
+
+                friend bool operator==(const WithId& a, const WithId& b)
+                {
+                    return a.id_ == b.id_;
+                }
+                friend bool operator!=(const WithId& a, const WithId& b)
+                {
+                    return !(a == b);
+                }
+
+            protected:
+                explicit WithId(size_t id) :
+                    id_(id)
+                {
+                }
+
+            private:
+                size_t id_;
+
+                template<class T>
+                static size_t next_id()
+                {
+                    // 0 is reserved for moved from state.
+                    static size_t gId = 1;
+                    return gId++;
+                }
+            };
+
+        }  // namespace hash_testing_internal
+
+        struct NonStandardLayout
+        {
+            NonStandardLayout()
+            {
+            }
+            explicit NonStandardLayout(std::string s) :
+                value(std::move(s))
+            {
+            }
+            virtual ~NonStandardLayout()
+            {
+            }
+
+            friend bool operator==(const NonStandardLayout& a, const NonStandardLayout& b)
+            {
+                return a.value == b.value;
+            }
+            friend bool operator!=(const NonStandardLayout& a, const NonStandardLayout& b)
+            {
+                return a.value != b.value;
+            }
+
+            template<typename H>
+            friend H AbslHashValue(H h, const NonStandardLayout& v)
+            {
+                return H::combine(std::move(h), v.value);
+            }
+
+            std::string value;
+        };
+
+        struct StatefulTestingHash : absl::container_internal::hash_testing_internal::WithId<StatefulTestingHash>
+        {
+            template<class T>
+            size_t operator()(const T& t) const
+            {
+                return absl::Hash<T>{}(t);
+            }
+        };
+
+        struct StatefulTestingEqual : absl::container_internal::hash_testing_internal::WithId<StatefulTestingEqual>
+        {
+            template<class T, class U>
+            bool operator()(const T& t, const U& u) const
+            {
+                return t == u;
+            }
+        };
+
+        // It is expected that Alloc() == Alloc() for all allocators so we cannot use
+        // WithId base. We need to explicitly assign ids.
+        template<class T = int>
+        struct Alloc : std::allocator<T>
+        {
+            using propagate_on_container_swap = std::true_type;
+
+            // Using old paradigm for this to ensure compatibility.
+            explicit Alloc(size_t id = 0) :
+                id_(id)
+            {
+            }
+
+            Alloc(const Alloc&) = default;
+            Alloc& operator=(const Alloc&) = default;
+
+            template<class U>
+            Alloc(const Alloc<U>& that) :
+                std::allocator<T>(that),
+                id_(that.id())
+            {
+            }
+
+            template<class U>
+            struct rebind
+            {
+                using other = Alloc<U>;
+            };
+
+            size_t id() const
+            {
+                return id_;
+            }
+
+            friend bool operator==(const Alloc& a, const Alloc& b)
+            {
+                return a.id_ == b.id_;
+            }
+            friend bool operator!=(const Alloc& a, const Alloc& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            size_t id_ = (std::numeric_limits<size_t>::max)();
+        };
+
+        template<class Map>
+        auto items(const Map& m) -> std::vector<
+            std::pair<typename Map::key_type, typename Map::mapped_type>>
+        {
+            using std::get;
+            std::vector<std::pair<typename Map::key_type, typename Map::mapped_type>> res;
+            res.reserve(m.size());
+            for (const auto& v : m)
+                res.emplace_back(get<0>(v), get<1>(v));
+            return res;
+        }
+
+        template<class Set>
+        auto keys(const Set& s)
+            -> std::vector<typename std::decay<typename Set::key_type>::type>
+        {
+            std::vector<typename std::decay<typename Set::key_type>::type> res;
+            res.reserve(s.size());
+            for (const auto& v : s)
+                res.emplace_back(v);
+            return res;
+        }
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS is false for glibcxx versions
@@ -174,8 +230,8 @@ ABSL_NAMESPACE_END
 // From GCC-4.9 Changelog: (src: https://gcc.gnu.org/gcc-4.9/changes.html)
 // "the unordered associative containers in <unordered_map> and <unordered_set>
 // meet the allocator-aware container requirements;"
-#if (defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425 ) || \
-( __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9 ))
+#if (defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425) || \
+    (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9))
 #define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 0
 #else
 #define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 1
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_traits.h b/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_traits.h
index 46c97b1..11e9ea3 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_traits.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hash_policy_traits.h
@@ -23,186 +23,204 @@
 
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// Defines how slots are initialized/destroyed/moved.
-template <class Policy, class = void>
-struct hash_policy_traits {
-  // The type of the keys stored in the hashtable.
-  using key_type = typename Policy::key_type;
-
- private:
-  struct ReturnKey {
-    // When C++17 is available, we can use std::launder to provide mutable
-    // access to the key for use in node handle.
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        // Defines how slots are initialized/destroyed/moved.
+        template<class Policy, class = void>
+        struct hash_policy_traits
+        {
+            // The type of the keys stored in the hashtable.
+            using key_type = typename Policy::key_type;
+
+        private:
+            struct ReturnKey
+            {
+                // When C++17 is available, we can use std::launder to provide mutable
+                // access to the key for use in node handle.
 #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
-    template <class Key,
-              absl::enable_if_t<std::is_lvalue_reference<Key>::value, int> = 0>
-    static key_type& Impl(Key&& k, int) {
-      return *std::launder(
-          const_cast<key_type*>(std::addressof(std::forward<Key>(k))));
-    }
+                template<class Key, absl::enable_if_t<std::is_lvalue_reference<Key>::value, int> = 0>
+                static key_type& Impl(Key&& k, int)
+                {
+                    return *std::launder(
+                        const_cast<key_type*>(std::addressof(std::forward<Key>(k)))
+                    );
+                }
 #endif
 
-    template <class Key>
-    static Key Impl(Key&& k, char) {
-      return std::forward<Key>(k);
-    }
-
-    // When Key=T&, we forward the lvalue reference.
-    // When Key=T, we return by value to avoid a dangling reference.
-    // eg, for string_hash_map.
-    template <class Key, class... Args>
-    auto operator()(Key&& k, const Args&...) const
-        -> decltype(Impl(std::forward<Key>(k), 0)) {
-      return Impl(std::forward<Key>(k), 0);
-    }
-  };
-
-  template <class P = Policy, class = void>
-  struct ConstantIteratorsImpl : std::false_type {};
-
-  template <class P>
-  struct ConstantIteratorsImpl<P, absl::void_t<typename P::constant_iterators>>
-      : P::constant_iterators {};
-
- public:
-  // The actual object stored in the hash table.
-  using slot_type = typename Policy::slot_type;
-
-  // The argument type for insertions into the hashtable. This is different
-  // from value_type for increased performance. See initializer_list constructor
-  // and insert() member functions for more details.
-  using init_type = typename Policy::init_type;
-
-  using reference = decltype(Policy::element(std::declval<slot_type*>()));
-  using pointer = typename std::remove_reference<reference>::type*;
-  using value_type = typename std::remove_reference<reference>::type;
-
-  // Policies can set this variable to tell raw_hash_set that all iterators
-  // should be constant, even `iterator`. This is useful for set-like
-  // containers.
-  // Defaults to false if not provided by the policy.
-  using constant_iterators = ConstantIteratorsImpl<>;
-
-  // PRECONDITION: `slot` is UNINITIALIZED
-  // POSTCONDITION: `slot` is INITIALIZED
-  template <class Alloc, class... Args>
-  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
-    Policy::construct(alloc, slot, std::forward<Args>(args)...);
-  }
-
-  // PRECONDITION: `slot` is INITIALIZED
-  // POSTCONDITION: `slot` is UNINITIALIZED
-  template <class Alloc>
-  static void destroy(Alloc* alloc, slot_type* slot) {
-    Policy::destroy(alloc, slot);
-  }
-
-  // Transfers the `old_slot` to `new_slot`. Any memory allocated by the
-  // allocator inside `old_slot` to `new_slot` can be transferred.
-  //
-  // OPTIONAL: defaults to:
-  //
-  //     clone(new_slot, std::move(*old_slot));
-  //     destroy(old_slot);
-  //
-  // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED
-  // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is
-  //                UNINITIALIZED
-  template <class Alloc>
-  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
-    transfer_impl(alloc, new_slot, old_slot, 0);
-  }
-
-  // PRECONDITION: `slot` is INITIALIZED
-  // POSTCONDITION: `slot` is INITIALIZED
-  template <class P = Policy>
-  static auto element(slot_type* slot) -> decltype(P::element(slot)) {
-    return P::element(slot);
-  }
-
-  // Returns the amount of memory owned by `slot`, exclusive of `sizeof(*slot)`.
-  //
-  // If `slot` is nullptr, returns the constant amount of memory owned by any
-  // full slot or -1 if slots own variable amounts of memory.
-  //
-  // PRECONDITION: `slot` is INITIALIZED or nullptr
-  template <class P = Policy>
-  static size_t space_used(const slot_type* slot) {
-    return P::space_used(slot);
-  }
-
-  // Provides generalized access to the key for elements, both for elements in
-  // the table and for elements that have not yet been inserted (or even
-  // constructed).  We would like an API that allows us to say: `key(args...)`
-  // but we cannot do that for all cases, so we use this more general API that
-  // can be used for many things, including the following:
-  //
-  //   - Given an element in a table, get its key.
-  //   - Given an element initializer, get its key.
-  //   - Given `emplace()` arguments, get the element key.
-  //
-  // Implementations of this must adhere to a very strict technical
-  // specification around aliasing and consuming arguments:
-  //
-  // Let `value_type` be the result type of `element()` without ref- and
-  // cv-qualifiers. The first argument is a functor, the rest are constructor
-  // arguments for `value_type`. Returns `std::forward<F>(f)(k, xs...)`, where
-  // `k` is the element key, and `xs...` are the new constructor arguments for
-  // `value_type`. It's allowed for `k` to alias `xs...`, and for both to alias
-  // `ts...`. The key won't be touched once `xs...` are used to construct an
-  // element; `ts...` won't be touched at all, which allows `apply()` to consume
-  // any rvalues among them.
-  //
-  // If `value_type` is constructible from `Ts&&...`, `Policy::apply()` must not
-  // trigger a hard compile error unless it originates from `f`. In other words,
-  // `Policy::apply()` must be SFINAE-friendly. If `value_type` is not
-  // constructible from `Ts&&...`, either SFINAE or a hard compile error is OK.
-  //
-  // If `Ts...` is `[cv] value_type[&]` or `[cv] init_type[&]`,
-  // `Policy::apply()` must work. A compile error is not allowed, SFINAE or not.
-  template <class F, class... Ts, class P = Policy>
-  static auto apply(F&& f, Ts&&... ts)
-      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
-    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
-  }
-
-  // Returns the "key" portion of the slot.
-  // Used for node handle manipulation.
-  template <class P = Policy>
-  static auto mutable_key(slot_type* slot)
-      -> decltype(P::apply(ReturnKey(), element(slot))) {
-    return P::apply(ReturnKey(), element(slot));
-  }
-
-  // Returns the "value" (as opposed to the "key") portion of the element. Used
-  // by maps to implement `operator[]`, `at()` and `insert_or_assign()`.
-  template <class T, class P = Policy>
-  static auto value(T* elem) -> decltype(P::value(elem)) {
-    return P::value(elem);
-  }
-
- private:
-  // Use auto -> decltype as an enabler.
-  template <class Alloc, class P = Policy>
-  static auto transfer_impl(Alloc* alloc, slot_type* new_slot,
-                            slot_type* old_slot, int)
-      -> decltype((void)P::transfer(alloc, new_slot, old_slot)) {
-    P::transfer(alloc, new_slot, old_slot);
-  }
-  template <class Alloc>
-  static void transfer_impl(Alloc* alloc, slot_type* new_slot,
-                            slot_type* old_slot, char) {
-    construct(alloc, new_slot, std::move(element(old_slot)));
-    destroy(alloc, old_slot);
-  }
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+                template<class Key>
+                static Key Impl(Key&& k, char)
+                {
+                    return std::forward<Key>(k);
+                }
+
+                // When Key=T&, we forward the lvalue reference.
+                // When Key=T, we return by value to avoid a dangling reference.
+                // eg, for string_hash_map.
+                template<class Key, class... Args>
+                auto operator()(Key&& k, const Args&...) const
+                    -> decltype(Impl(std::forward<Key>(k), 0))
+                {
+                    return Impl(std::forward<Key>(k), 0);
+                }
+            };
+
+            template<class P = Policy, class = void>
+            struct ConstantIteratorsImpl : std::false_type
+            {
+            };
+
+            template<class P>
+            struct ConstantIteratorsImpl<P, absl::void_t<typename P::constant_iterators>> : P::constant_iterators
+            {
+            };
+
+        public:
+            // The actual object stored in the hash table.
+            using slot_type = typename Policy::slot_type;
+
+            // The argument type for insertions into the hashtable. This is different
+            // from value_type for increased performance. See initializer_list constructor
+            // and insert() member functions for more details.
+            using init_type = typename Policy::init_type;
+
+            using reference = decltype(Policy::element(std::declval<slot_type*>()));
+            using pointer = typename std::remove_reference<reference>::type*;
+            using value_type = typename std::remove_reference<reference>::type;
+
+            // Policies can set this variable to tell raw_hash_set that all iterators
+            // should be constant, even `iterator`. This is useful for set-like
+            // containers.
+            // Defaults to false if not provided by the policy.
+            using constant_iterators = ConstantIteratorsImpl<>;
+
+            // PRECONDITION: `slot` is UNINITIALIZED
+            // POSTCONDITION: `slot` is INITIALIZED
+            template<class Alloc, class... Args>
+            static void construct(Alloc* alloc, slot_type* slot, Args&&... args)
+            {
+                Policy::construct(alloc, slot, std::forward<Args>(args)...);
+            }
+
+            // PRECONDITION: `slot` is INITIALIZED
+            // POSTCONDITION: `slot` is UNINITIALIZED
+            template<class Alloc>
+            static void destroy(Alloc* alloc, slot_type* slot)
+            {
+                Policy::destroy(alloc, slot);
+            }
+
+            // Transfers the `old_slot` to `new_slot`. Any memory allocated by the
+            // allocator inside `old_slot` to `new_slot` can be transferred.
+            //
+            // OPTIONAL: defaults to:
+            //
+            //     clone(new_slot, std::move(*old_slot));
+            //     destroy(old_slot);
+            //
+            // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED
+            // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is
+            //                UNINITIALIZED
+            template<class Alloc>
+            static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot)
+            {
+                transfer_impl(alloc, new_slot, old_slot, 0);
+            }
+
+            // PRECONDITION: `slot` is INITIALIZED
+            // POSTCONDITION: `slot` is INITIALIZED
+            template<class P = Policy>
+            static auto element(slot_type* slot) -> decltype(P::element(slot))
+            {
+                return P::element(slot);
+            }
+
+            // Returns the amount of memory owned by `slot`, exclusive of `sizeof(*slot)`.
+            //
+            // If `slot` is nullptr, returns the constant amount of memory owned by any
+            // full slot or -1 if slots own variable amounts of memory.
+            //
+            // PRECONDITION: `slot` is INITIALIZED or nullptr
+            template<class P = Policy>
+            static size_t space_used(const slot_type* slot)
+            {
+                return P::space_used(slot);
+            }
+
+            // Provides generalized access to the key for elements, both for elements in
+            // the table and for elements that have not yet been inserted (or even
+            // constructed).  We would like an API that allows us to say: `key(args...)`
+            // but we cannot do that for all cases, so we use this more general API that
+            // can be used for many things, including the following:
+            //
+            //   - Given an element in a table, get its key.
+            //   - Given an element initializer, get its key.
+            //   - Given `emplace()` arguments, get the element key.
+            //
+            // Implementations of this must adhere to a very strict technical
+            // specification around aliasing and consuming arguments:
+            //
+            // Let `value_type` be the result type of `element()` without ref- and
+            // cv-qualifiers. The first argument is a functor, the rest are constructor
+            // arguments for `value_type`. Returns `std::forward<F>(f)(k, xs...)`, where
+            // `k` is the element key, and `xs...` are the new constructor arguments for
+            // `value_type`. It's allowed for `k` to alias `xs...`, and for both to alias
+            // `ts...`. The key won't be touched once `xs...` are used to construct an
+            // element; `ts...` won't be touched at all, which allows `apply()` to consume
+            // any rvalues among them.
+            //
+            // If `value_type` is constructible from `Ts&&...`, `Policy::apply()` must not
+            // trigger a hard compile error unless it originates from `f`. In other words,
+            // `Policy::apply()` must be SFINAE-friendly. If `value_type` is not
+            // constructible from `Ts&&...`, either SFINAE or a hard compile error is OK.
+            //
+            // If `Ts...` is `[cv] value_type[&]` or `[cv] init_type[&]`,
+            // `Policy::apply()` must work. A compile error is not allowed, SFINAE or not.
+            template<class F, class... Ts, class P = Policy>
+            static auto apply(F&& f, Ts&&... ts)
+                -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...))
+            {
+                return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
+            }
+
+            // Returns the "key" portion of the slot.
+            // Used for node handle manipulation.
+            template<class P = Policy>
+            static auto mutable_key(slot_type* slot)
+                -> decltype(P::apply(ReturnKey(), element(slot)))
+            {
+                return P::apply(ReturnKey(), element(slot));
+            }
+
+            // Returns the "value" (as opposed to the "key") portion of the element. Used
+            // by maps to implement `operator[]`, `at()` and `insert_or_assign()`.
+            template<class T, class P = Policy>
+            static auto value(T* elem) -> decltype(P::value(elem))
+            {
+                return P::value(elem);
+            }
+
+        private:
+            // Use auto -> decltype as an enabler.
+            template<class Alloc, class P = Policy>
+            static auto transfer_impl(Alloc* alloc, slot_type* new_slot, slot_type* old_slot, int)
+                -> decltype((void)P::transfer(alloc, new_slot, old_slot))
+            {
+                P::transfer(alloc, new_slot, old_slot);
+            }
+            template<class Alloc>
+            static void transfer_impl(Alloc* alloc, slot_type* new_slot, slot_type* old_slot, char)
+            {
+                construct(alloc, new_slot, std::move(element(old_slot)));
+                destroy(alloc, old_slot);
+            }
+        };
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug.h b/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug.h
index 19d5212..6da7252 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug.h
@@ -37,74 +37,86 @@
 
 #include "absl/container/internal/hashtable_debug_hooks.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
 
-// Returns the number of probes required to lookup `key`.  Returns 0 for a
-// search with no collisions.  Higher values mean more hash collisions occurred;
-// however, the exact meaning of this number varies according to the container
-// type.
-template <typename C>
-size_t GetHashtableDebugNumProbes(
-    const C& c, const typename C::key_type& key) {
-  return absl::container_internal::hashtable_debug_internal::
-      HashtableDebugAccess<C>::GetNumProbes(c, key);
-}
+        // Returns the number of probes required to lookup `key`.  Returns 0 for a
+        // search with no collisions.  Higher values mean more hash collisions occurred;
+        // however, the exact meaning of this number varies according to the container
+        // type.
+        template<typename C>
+        size_t GetHashtableDebugNumProbes(
+            const C& c, const typename C::key_type& key
+        )
+        {
+            return absl::container_internal::hashtable_debug_internal::
+                HashtableDebugAccess<C>::GetNumProbes(c, key);
+        }
 
-// Gets a histogram of the number of probes for each elements in the container.
-// The sum of all the values in the vector is equal to container.size().
-template <typename C>
-std::vector<size_t> GetHashtableDebugNumProbesHistogram(const C& container) {
-  std::vector<size_t> v;
-  for (auto it = container.begin(); it != container.end(); ++it) {
-    size_t num_probes = GetHashtableDebugNumProbes(
-        container,
-        absl::container_internal::hashtable_debug_internal::GetKey<C>(*it, 0));
-    v.resize((std::max)(v.size(), num_probes + 1));
-    v[num_probes]++;
-  }
-  return v;
-}
+        // Gets a histogram of the number of probes for each elements in the container.
+        // The sum of all the values in the vector is equal to container.size().
+        template<typename C>
+        std::vector<size_t> GetHashtableDebugNumProbesHistogram(const C& container)
+        {
+            std::vector<size_t> v;
+            for (auto it = container.begin(); it != container.end(); ++it)
+            {
+                size_t num_probes = GetHashtableDebugNumProbes(
+                    container,
+                    absl::container_internal::hashtable_debug_internal::GetKey<C>(*it, 0)
+                );
+                v.resize((std::max)(v.size(), num_probes + 1));
+                v[num_probes]++;
+            }
+            return v;
+        }
 
-struct HashtableDebugProbeSummary {
-  size_t total_elements;
-  size_t total_num_probes;
-  double mean;
-};
+        struct HashtableDebugProbeSummary
+        {
+            size_t total_elements;
+            size_t total_num_probes;
+            double mean;
+        };
 
-// Gets a summary of the probe count distribution for the elements in the
-// container.
-template <typename C>
-HashtableDebugProbeSummary GetHashtableDebugProbeSummary(const C& container) {
-  auto probes = GetHashtableDebugNumProbesHistogram(container);
-  HashtableDebugProbeSummary summary = {};
-  for (size_t i = 0; i < probes.size(); ++i) {
-    summary.total_elements += probes[i];
-    summary.total_num_probes += probes[i] * i;
-  }
-  summary.mean = 1.0 * summary.total_num_probes / summary.total_elements;
-  return summary;
-}
+        // Gets a summary of the probe count distribution for the elements in the
+        // container.
+        template<typename C>
+        HashtableDebugProbeSummary GetHashtableDebugProbeSummary(const C& container)
+        {
+            auto probes = GetHashtableDebugNumProbesHistogram(container);
+            HashtableDebugProbeSummary summary = {};
+            for (size_t i = 0; i < probes.size(); ++i)
+            {
+                summary.total_elements += probes[i];
+                summary.total_num_probes += probes[i] * i;
+            }
+            summary.mean = 1.0 * summary.total_num_probes / summary.total_elements;
+            return summary;
+        }
 
-// Returns the number of bytes requested from the allocator by the container
-// and not freed.
-template <typename C>
-size_t AllocatedByteSize(const C& c) {
-  return absl::container_internal::hashtable_debug_internal::
-      HashtableDebugAccess<C>::AllocatedByteSize(c);
-}
+        // Returns the number of bytes requested from the allocator by the container
+        // and not freed.
+        template<typename C>
+        size_t AllocatedByteSize(const C& c)
+        {
+            return absl::container_internal::hashtable_debug_internal::
+                HashtableDebugAccess<C>::AllocatedByteSize(c);
+        }
 
-// Returns a tight lower bound for AllocatedByteSize(c) where `c` is of type `C`
-// and `c.size()` is equal to `num_elements`.
-template <typename C>
-size_t LowerBoundAllocatedByteSize(size_t num_elements) {
-  return absl::container_internal::hashtable_debug_internal::
-      HashtableDebugAccess<C>::LowerBoundAllocatedByteSize(num_elements);
-}
+        // Returns a tight lower bound for AllocatedByteSize(c) where `c` is of type `C`
+        // and `c.size()` is equal to `num_elements`.
+        template<typename C>
+        size_t LowerBoundAllocatedByteSize(size_t num_elements)
+        {
+            return absl::container_internal::hashtable_debug_internal::
+                HashtableDebugAccess<C>::LowerBoundAllocatedByteSize(num_elements);
+        }
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug_hooks.h b/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug_hooks.h
index 3e9ea59..4f0d211 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug_hooks.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hashtable_debug_hooks.h
@@ -25,61 +25,71 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-namespace hashtable_debug_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+        namespace hashtable_debug_internal
+        {
 
-// If it is a map, call get<0>().
-using std::get;
-template <typename T, typename = typename T::mapped_type>
-auto GetKey(const typename T::value_type& pair, int) -> decltype(get<0>(pair)) {
-  return get<0>(pair);
-}
+            // If it is a map, call get<0>().
+            using std::get;
+            template<typename T, typename = typename T::mapped_type>
+            auto GetKey(const typename T::value_type& pair, int) -> decltype(get<0>(pair))
+            {
+                return get<0>(pair);
+            }
 
-// If it is not a map, return the value directly.
-template <typename T>
-const typename T::key_type& GetKey(const typename T::key_type& key, char) {
-  return key;
-}
+            // If it is not a map, return the value directly.
+            template<typename T>
+            const typename T::key_type& GetKey(const typename T::key_type& key, char)
+            {
+                return key;
+            }
 
-// Containers should specialize this to provide debug information for that
-// container.
-template <class Container, typename Enabler = void>
-struct HashtableDebugAccess {
-  // Returns the number of probes required to find `key` in `c`.  The "number of
-  // probes" is a concept that can vary by container.  Implementations should
-  // return 0 when `key` was found in the minimum number of operations and
-  // should increment the result for each non-trivial operation required to find
-  // `key`.
-  //
-  // The default implementation uses the bucket api from the standard and thus
-  // works for `std::unordered_*` containers.
-  static size_t GetNumProbes(const Container& c,
-                             const typename Container::key_type& key) {
-    if (!c.bucket_count()) return {};
-    size_t num_probes = 0;
-    size_t bucket = c.bucket(key);
-    for (auto it = c.begin(bucket), e = c.end(bucket);; ++it, ++num_probes) {
-      if (it == e) return num_probes;
-      if (c.key_eq()(key, GetKey<Container>(*it, 0))) return num_probes;
-    }
-  }
+            // Containers should specialize this to provide debug information for that
+            // container.
+            template<class Container, typename Enabler = void>
+            struct HashtableDebugAccess
+            {
+                // Returns the number of probes required to find `key` in `c`.  The "number of
+                // probes" is a concept that can vary by container.  Implementations should
+                // return 0 when `key` was found in the minimum number of operations and
+                // should increment the result for each non-trivial operation required to find
+                // `key`.
+                //
+                // The default implementation uses the bucket api from the standard and thus
+                // works for `std::unordered_*` containers.
+                static size_t GetNumProbes(const Container& c, const typename Container::key_type& key)
+                {
+                    if (!c.bucket_count())
+                        return {};
+                    size_t num_probes = 0;
+                    size_t bucket = c.bucket(key);
+                    for (auto it = c.begin(bucket), e = c.end(bucket);; ++it, ++num_probes)
+                    {
+                        if (it == e)
+                            return num_probes;
+                        if (c.key_eq()(key, GetKey<Container>(*it, 0)))
+                            return num_probes;
+                    }
+                }
 
-  // Returns the number of bytes requested from the allocator by the container
-  // and not freed.
-  //
-  // static size_t AllocatedByteSize(const Container& c);
+                // Returns the number of bytes requested from the allocator by the container
+                // and not freed.
+                //
+                // static size_t AllocatedByteSize(const Container& c);
 
-  // Returns a tight lower bound for AllocatedByteSize(c) where `c` is of type
-  // `Container` and `c.size()` is equal to `num_elements`.
-  //
-  // static size_t LowerBoundAllocatedByteSize(size_t num_elements);
-};
+                // Returns a tight lower bound for AllocatedByteSize(c) where `c` is of type
+                // `Container` and `c.size()` is equal to `num_elements`.
+                //
+                // static size_t LowerBoundAllocatedByteSize(size_t num_elements);
+            };
 
-}  // namespace hashtable_debug_internal
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+        }  // namespace hashtable_debug_internal
+    }      // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/hashtablez_sampler.h b/CAPI/cpp/grpc/include/absl/container/internal/hashtablez_sampler.h
index d4016d8..40c1507 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/hashtablez_sampler.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/hashtablez_sampler.h
@@ -51,249 +51,303 @@
 #include "absl/synchronization/mutex.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// Stores information about a sampled hashtable.  All mutations to this *must*
-// be made through `Record*` functions below.  All reads from this *must* only
-// occur in the callback to `HashtablezSampler::Iterate`.
-struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
-  // Constructs the object but does not fill in any fields.
-  HashtablezInfo();
-  ~HashtablezInfo();
-  HashtablezInfo(const HashtablezInfo&) = delete;
-  HashtablezInfo& operator=(const HashtablezInfo&) = delete;
-
-  // Puts the object into a clean state, fills in the logically `const` members,
-  // blocking for any readers that are currently sampling the object.
-  void PrepareForSampling(int64_t stride, size_t inline_element_size_value)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
-
-  // These fields are mutated by the various Record* APIs and need to be
-  // thread-safe.
-  std::atomic<size_t> capacity;
-  std::atomic<size_t> size;
-  std::atomic<size_t> num_erases;
-  std::atomic<size_t> num_rehashes;
-  std::atomic<size_t> max_probe_length;
-  std::atomic<size_t> total_probe_length;
-  std::atomic<size_t> hashes_bitwise_or;
-  std::atomic<size_t> hashes_bitwise_and;
-  std::atomic<size_t> hashes_bitwise_xor;
-  std::atomic<size_t> max_reserve;
-
-  // All of the fields below are set by `PrepareForSampling`, they must not be
-  // mutated in `Record*` functions.  They are logically `const` in that sense.
-  // These are guarded by init_mu, but that is not externalized to clients,
-  // which can read them only during `SampleRecorder::Iterate` which will hold
-  // the lock.
-  static constexpr int kMaxStackDepth = 64;
-  absl::Time create_time;
-  int32_t depth;
-  void* stack[kMaxStackDepth];
-  size_t inline_element_size;  // How big is the slot?
-};
-
-inline void RecordRehashSlow(HashtablezInfo* info, size_t total_probe_length) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        // Stores information about a sampled hashtable.  All mutations to this *must*
+        // be made through `Record*` functions below.  All reads from this *must* only
+        // occur in the callback to `HashtablezSampler::Iterate`.
+        struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo>
+        {
+            // Constructs the object but does not fill in any fields.
+            HashtablezInfo();
+            ~HashtablezInfo();
+            HashtablezInfo(const HashtablezInfo&) = delete;
+            HashtablezInfo& operator=(const HashtablezInfo&) = delete;
+
+            // Puts the object into a clean state, fills in the logically `const` members,
+            // blocking for any readers that are currently sampling the object.
+            void PrepareForSampling(int64_t stride, size_t inline_element_size_value)
+                ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
+
+            // These fields are mutated by the various Record* APIs and need to be
+            // thread-safe.
+            std::atomic<size_t> capacity;
+            std::atomic<size_t> size;
+            std::atomic<size_t> num_erases;
+            std::atomic<size_t> num_rehashes;
+            std::atomic<size_t> max_probe_length;
+            std::atomic<size_t> total_probe_length;
+            std::atomic<size_t> hashes_bitwise_or;
+            std::atomic<size_t> hashes_bitwise_and;
+            std::atomic<size_t> hashes_bitwise_xor;
+            std::atomic<size_t> max_reserve;
+
+            // All of the fields below are set by `PrepareForSampling`, they must not be
+            // mutated in `Record*` functions.  They are logically `const` in that sense.
+            // These are guarded by init_mu, but that is not externalized to clients,
+            // which can read them only during `SampleRecorder::Iterate` which will hold
+            // the lock.
+            static constexpr int kMaxStackDepth = 64;
+            absl::Time create_time;
+            int32_t depth;
+            void* stack[kMaxStackDepth];
+            size_t inline_element_size;  // How big is the slot?
+        };
+
+        inline void RecordRehashSlow(HashtablezInfo* info, size_t total_probe_length)
+        {
 #ifdef ABSL_INTERNAL_HAVE_SSE2
-  total_probe_length /= 16;
+            total_probe_length /= 16;
 #else
-  total_probe_length /= 8;
+            total_probe_length /= 8;
 #endif
-  info->total_probe_length.store(total_probe_length, std::memory_order_relaxed);
-  info->num_erases.store(0, std::memory_order_relaxed);
-  // There is only one concurrent writer, so `load` then `store` is sufficient
-  // instead of using `fetch_add`.
-  info->num_rehashes.store(
-      1 + info->num_rehashes.load(std::memory_order_relaxed),
-      std::memory_order_relaxed);
-}
-
-inline void RecordReservationSlow(HashtablezInfo* info,
-                                  size_t target_capacity) {
-  info->max_reserve.store(
-      (std::max)(info->max_reserve.load(std::memory_order_relaxed),
-                 target_capacity),
-      std::memory_order_relaxed);
-}
-
-inline void RecordClearedReservationSlow(HashtablezInfo* info) {
-  info->max_reserve.store(0, std::memory_order_relaxed);
-}
-
-inline void RecordStorageChangedSlow(HashtablezInfo* info, size_t size,
-                                     size_t capacity) {
-  info->size.store(size, std::memory_order_relaxed);
-  info->capacity.store(capacity, std::memory_order_relaxed);
-  if (size == 0) {
-    // This is a clear, reset the total/num_erases too.
-    info->total_probe_length.store(0, std::memory_order_relaxed);
-    info->num_erases.store(0, std::memory_order_relaxed);
-  }
-}
-
-void RecordInsertSlow(HashtablezInfo* info, size_t hash,
-                      size_t distance_from_desired);
-
-inline void RecordEraseSlow(HashtablezInfo* info) {
-  info->size.fetch_sub(1, std::memory_order_relaxed);
-  // There is only one concurrent writer, so `load` then `store` is sufficient
-  // instead of using `fetch_add`.
-  info->num_erases.store(
-      1 + info->num_erases.load(std::memory_order_relaxed),
-      std::memory_order_relaxed);
-}
-
-struct SamplingState {
-  int64_t next_sample;
-  // When we make a sampling decision, we record that distance so we can weight
-  // each sample.
-  int64_t sample_stride;
-};
-
-HashtablezInfo* SampleSlow(SamplingState& next_sample,
-                           size_t inline_element_size);
-void UnsampleSlow(HashtablezInfo* info);
+            info->total_probe_length.store(total_probe_length, std::memory_order_relaxed);
+            info->num_erases.store(0, std::memory_order_relaxed);
+            // There is only one concurrent writer, so `load` then `store` is sufficient
+            // instead of using `fetch_add`.
+            info->num_rehashes.store(
+                1 + info->num_rehashes.load(std::memory_order_relaxed),
+                std::memory_order_relaxed
+            );
+        }
+
+        inline void RecordReservationSlow(HashtablezInfo* info, size_t target_capacity)
+        {
+            info->max_reserve.store(
+                (std::max)(info->max_reserve.load(std::memory_order_relaxed), target_capacity),
+                std::memory_order_relaxed
+            );
+        }
+
+        inline void RecordClearedReservationSlow(HashtablezInfo* info)
+        {
+            info->max_reserve.store(0, std::memory_order_relaxed);
+        }
+
+        inline void RecordStorageChangedSlow(HashtablezInfo* info, size_t size, size_t capacity)
+        {
+            info->size.store(size, std::memory_order_relaxed);
+            info->capacity.store(capacity, std::memory_order_relaxed);
+            if (size == 0)
+            {
+                // This is a clear, reset the total/num_erases too.
+                info->total_probe_length.store(0, std::memory_order_relaxed);
+                info->num_erases.store(0, std::memory_order_relaxed);
+            }
+        }
+
+        void RecordInsertSlow(HashtablezInfo* info, size_t hash, size_t distance_from_desired);
+
+        inline void RecordEraseSlow(HashtablezInfo* info)
+        {
+            info->size.fetch_sub(1, std::memory_order_relaxed);
+            // There is only one concurrent writer, so `load` then `store` is sufficient
+            // instead of using `fetch_add`.
+            info->num_erases.store(
+                1 + info->num_erases.load(std::memory_order_relaxed),
+                std::memory_order_relaxed
+            );
+        }
+
+        struct SamplingState
+        {
+            int64_t next_sample;
+            // When we make a sampling decision, we record that distance so we can weight
+            // each sample.
+            int64_t sample_stride;
+        };
+
+        HashtablezInfo* SampleSlow(SamplingState& next_sample, size_t inline_element_size);
+        void UnsampleSlow(HashtablezInfo* info);
 
 #if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 #error ABSL_INTERNAL_HASHTABLEZ_SAMPLE cannot be directly set
 #endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 
 #if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-class HashtablezInfoHandle {
- public:
-  explicit HashtablezInfoHandle() : info_(nullptr) {}
-  explicit HashtablezInfoHandle(HashtablezInfo* info) : info_(info) {}
-  ~HashtablezInfoHandle() {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    UnsampleSlow(info_);
-  }
-
-  HashtablezInfoHandle(const HashtablezInfoHandle&) = delete;
-  HashtablezInfoHandle& operator=(const HashtablezInfoHandle&) = delete;
-
-  HashtablezInfoHandle(HashtablezInfoHandle&& o) noexcept
-      : info_(absl::exchange(o.info_, nullptr)) {}
-  HashtablezInfoHandle& operator=(HashtablezInfoHandle&& o) noexcept {
-    if (ABSL_PREDICT_FALSE(info_ != nullptr)) {
-      UnsampleSlow(info_);
-    }
-    info_ = absl::exchange(o.info_, nullptr);
-    return *this;
-  }
-
-  inline void RecordStorageChanged(size_t size, size_t capacity) {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordStorageChangedSlow(info_, size, capacity);
-  }
-
-  inline void RecordRehash(size_t total_probe_length) {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordRehashSlow(info_, total_probe_length);
-  }
-
-  inline void RecordReservation(size_t target_capacity) {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordReservationSlow(info_, target_capacity);
-  }
-
-  inline void RecordClearedReservation() {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordClearedReservationSlow(info_);
-  }
-
-  inline void RecordInsert(size_t hash, size_t distance_from_desired) {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordInsertSlow(info_, hash, distance_from_desired);
-  }
-
-  inline void RecordErase() {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordEraseSlow(info_);
-  }
-
-  friend inline void swap(HashtablezInfoHandle& lhs,
-                          HashtablezInfoHandle& rhs) {
-    std::swap(lhs.info_, rhs.info_);
-  }
-
- private:
-  friend class HashtablezInfoHandlePeer;
-  HashtablezInfo* info_;
-};
+        class HashtablezInfoHandle
+        {
+        public:
+            explicit HashtablezInfoHandle() :
+                info_(nullptr)
+            {
+            }
+            explicit HashtablezInfoHandle(HashtablezInfo* info) :
+                info_(info)
+            {
+            }
+            ~HashtablezInfoHandle()
+            {
+                if (ABSL_PREDICT_TRUE(info_ == nullptr))
+                    return;
+                UnsampleSlow(info_);
+            }
+
+            HashtablezInfoHandle(const HashtablezInfoHandle&) = delete;
+            HashtablezInfoHandle& operator=(const HashtablezInfoHandle&) = delete;
+
+            HashtablezInfoHandle(HashtablezInfoHandle&& o) noexcept
+                :
+                info_(absl::exchange(o.info_, nullptr))
+            {
+            }
+            HashtablezInfoHandle& operator=(HashtablezInfoHandle&& o) noexcept
+            {
+                if (ABSL_PREDICT_FALSE(info_ != nullptr))
+                {
+                    UnsampleSlow(info_);
+                }
+                info_ = absl::exchange(o.info_, nullptr);
+                return *this;
+            }
+
+            inline void RecordStorageChanged(size_t size, size_t capacity)
+            {
+                if (ABSL_PREDICT_TRUE(info_ == nullptr))
+                    return;
+                RecordStorageChangedSlow(info_, size, capacity);
+            }
+
+            inline void RecordRehash(size_t total_probe_length)
+            {
+                if (ABSL_PREDICT_TRUE(info_ == nullptr))
+                    return;
+                RecordRehashSlow(info_, total_probe_length);
+            }
+
+            inline void RecordReservation(size_t target_capacity)
+            {
+                if (ABSL_PREDICT_TRUE(info_ == nullptr))
+                    return;
+                RecordReservationSlow(info_, target_capacity);
+            }
+
+            inline void RecordClearedReservation()
+            {
+                if (ABSL_PREDICT_TRUE(info_ == nullptr))
+                    return;
+                RecordClearedReservationSlow(info_);
+            }
+
+            inline void RecordInsert(size_t hash, size_t distance_from_desired)
+            {
+                if (ABSL_PREDICT_TRUE(info_ == nullptr))
+                    return;
+                RecordInsertSlow(info_, hash, distance_from_desired);
+            }
+
+            inline void RecordErase()
+            {
+                if (ABSL_PREDICT_TRUE(info_ == nullptr))
+                    return;
+                RecordEraseSlow(info_);
+            }
+
+            friend inline void swap(HashtablezInfoHandle& lhs, HashtablezInfoHandle& rhs)
+            {
+                std::swap(lhs.info_, rhs.info_);
+            }
+
+        private:
+            friend class HashtablezInfoHandlePeer;
+            HashtablezInfo* info_;
+        };
 #else
-// Ensure that when Hashtablez is turned off at compile time, HashtablezInfo can
-// be removed by the linker, in order to reduce the binary size.
-class HashtablezInfoHandle {
- public:
-  explicit HashtablezInfoHandle() = default;
-  explicit HashtablezInfoHandle(std::nullptr_t) {}
-
-  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
-  inline void RecordRehash(size_t /*total_probe_length*/) {}
-  inline void RecordReservation(size_t /*target_capacity*/) {}
-  inline void RecordClearedReservation() {}
-  inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {}
-  inline void RecordErase() {}
-
-  friend inline void swap(HashtablezInfoHandle& /*lhs*/,
-                          HashtablezInfoHandle& /*rhs*/) {}
-};
+        // Ensure that when Hashtablez is turned off at compile time, HashtablezInfo can
+        // be removed by the linker, in order to reduce the binary size.
+        class HashtablezInfoHandle
+        {
+        public:
+            explicit HashtablezInfoHandle() = default;
+            explicit HashtablezInfoHandle(std::nullptr_t)
+            {
+            }
+
+            inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/)
+            {
+            }
+            inline void RecordRehash(size_t /*total_probe_length*/)
+            {
+            }
+            inline void RecordReservation(size_t /*target_capacity*/)
+            {
+            }
+            inline void RecordClearedReservation()
+            {
+            }
+            inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/)
+            {
+            }
+            inline void RecordErase()
+            {
+            }
+
+            friend inline void swap(HashtablezInfoHandle& /*lhs*/, HashtablezInfoHandle& /*rhs*/)
+            {
+            }
+        };
 #endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 
 #if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-extern ABSL_PER_THREAD_TLS_KEYWORD SamplingState global_next_sample;
+        extern ABSL_PER_THREAD_TLS_KEYWORD SamplingState global_next_sample;
 #endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 
-// Returns an RAII sampling handle that manages registration and unregistation
-// with the global sampler.
-inline HashtablezInfoHandle Sample(
-    size_t inline_element_size ABSL_ATTRIBUTE_UNUSED) {
+        // Returns an RAII sampling handle that manages registration and unregistation
+        // with the global sampler.
+        inline HashtablezInfoHandle Sample(
+            size_t inline_element_size ABSL_ATTRIBUTE_UNUSED
+        )
+        {
 #if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
-    return HashtablezInfoHandle(nullptr);
-  }
-  return HashtablezInfoHandle(
-      SampleSlow(global_next_sample, inline_element_size));
+            if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0))
+            {
+                return HashtablezInfoHandle(nullptr);
+            }
+            return HashtablezInfoHandle(
+                SampleSlow(global_next_sample, inline_element_size)
+            );
 #else
-  return HashtablezInfoHandle(nullptr);
+            return HashtablezInfoHandle(nullptr);
 #endif  // !ABSL_PER_THREAD_TLS
-}
+        }
 
-using HashtablezSampler =
-    ::absl::profiling_internal::SampleRecorder<HashtablezInfo>;
+        using HashtablezSampler =
+            ::absl::profiling_internal::SampleRecorder<HashtablezInfo>;
 
-// Returns a global Sampler.
-HashtablezSampler& GlobalHashtablezSampler();
+        // Returns a global Sampler.
+        HashtablezSampler& GlobalHashtablezSampler();
 
-using HashtablezConfigListener = void (*)();
-void SetHashtablezConfigListener(HashtablezConfigListener l);
+        using HashtablezConfigListener = void (*)();
+        void SetHashtablezConfigListener(HashtablezConfigListener l);
 
-// Enables or disables sampling for Swiss tables.
-bool IsHashtablezEnabled();
-void SetHashtablezEnabled(bool enabled);
-void SetHashtablezEnabledInternal(bool enabled);
+        // Enables or disables sampling for Swiss tables.
+        bool IsHashtablezEnabled();
+        void SetHashtablezEnabled(bool enabled);
+        void SetHashtablezEnabledInternal(bool enabled);
 
-// Sets the rate at which Swiss tables will be sampled.
-int32_t GetHashtablezSampleParameter();
-void SetHashtablezSampleParameter(int32_t rate);
-void SetHashtablezSampleParameterInternal(int32_t rate);
+        // Sets the rate at which Swiss tables will be sampled.
+        int32_t GetHashtablezSampleParameter();
+        void SetHashtablezSampleParameter(int32_t rate);
+        void SetHashtablezSampleParameterInternal(int32_t rate);
 
-// Sets a soft max for the number of samples that will be kept.
-int32_t GetHashtablezMaxSamples();
-void SetHashtablezMaxSamples(int32_t max);
-void SetHashtablezMaxSamplesInternal(int32_t max);
+        // Sets a soft max for the number of samples that will be kept.
+        int32_t GetHashtablezMaxSamples();
+        void SetHashtablezMaxSamples(int32_t max);
+        void SetHashtablezMaxSamplesInternal(int32_t max);
 
-// Configuration override.
-// This allows process-wide sampling without depending on order of
-// initialization of static storage duration objects.
-// The definition of this constant is weak, which allows us to inject a
-// different value for it at link time.
-extern "C" bool ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)();
+        // Configuration override.
+        // This allows process-wide sampling without depending on order of
+        // initialization of static storage duration objects.
+        // The definition of this constant is weak, which allows us to inject a
+        // different value for it at link time.
+        extern "C" bool ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)();
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/inlined_vector.h b/CAPI/cpp/grpc/include/absl/container/internal/inlined_vector.h
index 54c92a0..a44b9ca 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/inlined_vector.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/inlined_vector.h
@@ -32,9 +32,11 @@
 #include "absl/meta/type_traits.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace inlined_vector_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace inlined_vector_internal
+    {
 
 // GCC does not deal very well with the below code
 #if !defined(__clang__) && defined(__GNUC__)
@@ -42,912 +44,1068 @@ namespace inlined_vector_internal {
 #pragma GCC diagnostic ignored "-Warray-bounds"
 #endif
 
-template <typename A>
-using AllocatorTraits = std::allocator_traits<A>;
-template <typename A>
-using ValueType = typename AllocatorTraits<A>::value_type;
-template <typename A>
-using SizeType = typename AllocatorTraits<A>::size_type;
-template <typename A>
-using Pointer = typename AllocatorTraits<A>::pointer;
-template <typename A>
-using ConstPointer = typename AllocatorTraits<A>::const_pointer;
-template <typename A>
-using SizeType = typename AllocatorTraits<A>::size_type;
-template <typename A>
-using DifferenceType = typename AllocatorTraits<A>::difference_type;
-template <typename A>
-using Reference = ValueType<A>&;
-template <typename A>
-using ConstReference = const ValueType<A>&;
-template <typename A>
-using Iterator = Pointer<A>;
-template <typename A>
-using ConstIterator = ConstPointer<A>;
-template <typename A>
-using ReverseIterator = typename std::reverse_iterator<Iterator<A>>;
-template <typename A>
-using ConstReverseIterator = typename std::reverse_iterator<ConstIterator<A>>;
-template <typename A>
-using MoveIterator = typename std::move_iterator<Iterator<A>>;
-
-template <typename Iterator>
-using IsAtLeastForwardIterator = std::is_convertible<
-    typename std::iterator_traits<Iterator>::iterator_category,
-    std::forward_iterator_tag>;
-
-template <typename A>
-using IsMemcpyOk =
-    absl::conjunction<std::is_same<A, std::allocator<ValueType<A>>>,
-                      absl::is_trivially_copy_constructible<ValueType<A>>,
-                      absl::is_trivially_copy_assignable<ValueType<A>>,
-                      absl::is_trivially_destructible<ValueType<A>>>;
-
-template <typename T>
-struct TypeIdentity {
-  using type = T;
-};
-
-// Used for function arguments in template functions to prevent ADL by forcing
-// callers to explicitly specify the template parameter.
-template <typename T>
-using NoTypeDeduction = typename TypeIdentity<T>::type;
-
-template <typename A, bool IsTriviallyDestructible =
-                          absl::is_trivially_destructible<ValueType<A>>::value>
-struct DestroyAdapter;
-
-template <typename A>
-struct DestroyAdapter<A, /* IsTriviallyDestructible */ false> {
-  static void DestroyElements(A& allocator, Pointer<A> destroy_first,
-                              SizeType<A> destroy_size) {
-    for (SizeType<A> i = destroy_size; i != 0;) {
-      --i;
-      AllocatorTraits<A>::destroy(allocator, destroy_first + i);
-    }
-  }
-};
-
-template <typename A>
-struct DestroyAdapter<A, /* IsTriviallyDestructible */ true> {
-  static void DestroyElements(A& allocator, Pointer<A> destroy_first,
-                              SizeType<A> destroy_size) {
-    static_cast<void>(allocator);
-    static_cast<void>(destroy_first);
-    static_cast<void>(destroy_size);
-  }
-};
-
-template <typename A>
-struct Allocation {
-  Pointer<A> data;
-  SizeType<A> capacity;
-};
-
-template <typename A,
-          bool IsOverAligned =
-              (alignof(ValueType<A>) > ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT)>
-struct MallocAdapter {
-  static Allocation<A> Allocate(A& allocator, SizeType<A> requested_capacity) {
-    return {AllocatorTraits<A>::allocate(allocator, requested_capacity),
-            requested_capacity};
-  }
-
-  static void Deallocate(A& allocator, Pointer<A> pointer,
-                         SizeType<A> capacity) {
-    AllocatorTraits<A>::deallocate(allocator, pointer, capacity);
-  }
-};
-
-template <typename A, typename ValueAdapter>
-void ConstructElements(NoTypeDeduction<A>& allocator,
-                       Pointer<A> construct_first, ValueAdapter& values,
-                       SizeType<A> construct_size) {
-  for (SizeType<A> i = 0; i < construct_size; ++i) {
-    ABSL_INTERNAL_TRY { values.ConstructNext(allocator, construct_first + i); }
-    ABSL_INTERNAL_CATCH_ANY {
-      DestroyAdapter<A>::DestroyElements(allocator, construct_first, i);
-      ABSL_INTERNAL_RETHROW;
-    }
-  }
-}
-
-template <typename A, typename ValueAdapter>
-void AssignElements(Pointer<A> assign_first, ValueAdapter& values,
-                    SizeType<A> assign_size) {
-  for (SizeType<A> i = 0; i < assign_size; ++i) {
-    values.AssignNext(assign_first + i);
-  }
-}
-
-template <typename A>
-struct StorageView {
-  Pointer<A> data;
-  SizeType<A> size;
-  SizeType<A> capacity;
-};
-
-template <typename A, typename Iterator>
-class IteratorValueAdapter {
- public:
-  explicit IteratorValueAdapter(const Iterator& it) : it_(it) {}
-
-  void ConstructNext(A& allocator, Pointer<A> construct_at) {
-    AllocatorTraits<A>::construct(allocator, construct_at, *it_);
-    ++it_;
-  }
-
-  void AssignNext(Pointer<A> assign_at) {
-    *assign_at = *it_;
-    ++it_;
-  }
-
- private:
-  Iterator it_;
-};
-
-template <typename A>
-class CopyValueAdapter {
- public:
-  explicit CopyValueAdapter(ConstPointer<A> p) : ptr_(p) {}
-
-  void ConstructNext(A& allocator, Pointer<A> construct_at) {
-    AllocatorTraits<A>::construct(allocator, construct_at, *ptr_);
-  }
-
-  void AssignNext(Pointer<A> assign_at) { *assign_at = *ptr_; }
-
- private:
-  ConstPointer<A> ptr_;
-};
-
-template <typename A>
-class DefaultValueAdapter {
- public:
-  explicit DefaultValueAdapter() {}
-
-  void ConstructNext(A& allocator, Pointer<A> construct_at) {
-    AllocatorTraits<A>::construct(allocator, construct_at);
-  }
-
-  void AssignNext(Pointer<A> assign_at) { *assign_at = ValueType<A>(); }
-};
-
-template <typename A>
-class AllocationTransaction {
- public:
-  explicit AllocationTransaction(A& allocator)
-      : allocator_data_(allocator, nullptr), capacity_(0) {}
-
-  ~AllocationTransaction() {
-    if (DidAllocate()) {
-      MallocAdapter<A>::Deallocate(GetAllocator(), GetData(), GetCapacity());
-    }
-  }
-
-  AllocationTransaction(const AllocationTransaction&) = delete;
-  void operator=(const AllocationTransaction&) = delete;
-
-  A& GetAllocator() { return allocator_data_.template get<0>(); }
-  Pointer<A>& GetData() { return allocator_data_.template get<1>(); }
-  SizeType<A>& GetCapacity() { return capacity_; }
-
-  bool DidAllocate() { return GetData() != nullptr; }
-
-  Pointer<A> Allocate(SizeType<A> requested_capacity) {
-    Allocation<A> result =
-        MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
-    GetData() = result.data;
-    GetCapacity() = result.capacity;
-    return result.data;
-  }
-
-  ABSL_MUST_USE_RESULT Allocation<A> Release() && {
-    Allocation<A> result = {GetData(), GetCapacity()};
-    Reset();
-    return result;
-  }
-
- private:
-  void Reset() {
-    GetData() = nullptr;
-    GetCapacity() = 0;
-  }
-
-  container_internal::CompressedTuple<A, Pointer<A>> allocator_data_;
-  SizeType<A> capacity_;
-};
-
-template <typename A>
-class ConstructionTransaction {
- public:
-  explicit ConstructionTransaction(A& allocator)
-      : allocator_data_(allocator, nullptr), size_(0) {}
-
-  ~ConstructionTransaction() {
-    if (DidConstruct()) {
-      DestroyAdapter<A>::DestroyElements(GetAllocator(), GetData(), GetSize());
-    }
-  }
-
-  ConstructionTransaction(const ConstructionTransaction&) = delete;
-  void operator=(const ConstructionTransaction&) = delete;
-
-  A& GetAllocator() { return allocator_data_.template get<0>(); }
-  Pointer<A>& GetData() { return allocator_data_.template get<1>(); }
-  SizeType<A>& GetSize() { return size_; }
-
-  bool DidConstruct() { return GetData() != nullptr; }
-  template <typename ValueAdapter>
-  void Construct(Pointer<A> data, ValueAdapter& values, SizeType<A> size) {
-    ConstructElements<A>(GetAllocator(), data, values, size);
-    GetData() = data;
-    GetSize() = size;
-  }
-  void Commit() && {
-    GetData() = nullptr;
-    GetSize() = 0;
-  }
-
- private:
-  container_internal::CompressedTuple<A, Pointer<A>> allocator_data_;
-  SizeType<A> size_;
-};
-
-template <typename T, size_t N, typename A>
-class Storage {
- public:
-  static SizeType<A> NextCapacity(SizeType<A> current_capacity) {
-    return current_capacity * 2;
-  }
-
-  static SizeType<A> ComputeCapacity(SizeType<A> current_capacity,
-                                     SizeType<A> requested_capacity) {
-    return (std::max)(NextCapacity(current_capacity), requested_capacity);
-  }
-
-  // ---------------------------------------------------------------------------
-  // Storage Constructors and Destructor
-  // ---------------------------------------------------------------------------
-
-  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
-
-  explicit Storage(const A& allocator)
-      : metadata_(allocator, /* size and is_allocated */ 0u) {}
-
-  ~Storage() {
-    if (GetSizeAndIsAllocated() == 0) {
-      // Empty and not allocated; nothing to do.
-    } else if (IsMemcpyOk<A>::value) {
-      // No destructors need to be run; just deallocate if necessary.
-      DeallocateIfAllocated();
-    } else {
-      DestroyContents();
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Storage Member Accessors
-  // ---------------------------------------------------------------------------
-
-  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
-
-  const SizeType<A>& GetSizeAndIsAllocated() const {
-    return metadata_.template get<1>();
-  }
-
-  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
-
-  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
-
-  Pointer<A> GetAllocatedData() { return data_.allocated.allocated_data; }
-
-  ConstPointer<A> GetAllocatedData() const {
-    return data_.allocated.allocated_data;
-  }
-
-  Pointer<A> GetInlinedData() {
-    return reinterpret_cast<Pointer<A>>(
-        std::addressof(data_.inlined.inlined_data[0]));
-  }
-
-  ConstPointer<A> GetInlinedData() const {
-    return reinterpret_cast<ConstPointer<A>>(
-        std::addressof(data_.inlined.inlined_data[0]));
-  }
-
-  SizeType<A> GetAllocatedCapacity() const {
-    return data_.allocated.allocated_capacity;
-  }
-
-  SizeType<A> GetInlinedCapacity() const { return static_cast<SizeType<A>>(N); }
-
-  StorageView<A> MakeStorageView() {
-    return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(),
-                                             GetAllocatedCapacity()}
-                            : StorageView<A>{GetInlinedData(), GetSize(),
-                                             GetInlinedCapacity()};
-  }
-
-  A& GetAllocator() { return metadata_.template get<0>(); }
-
-  const A& GetAllocator() const { return metadata_.template get<0>(); }
-
-  // ---------------------------------------------------------------------------
-  // Storage Member Mutators
-  // ---------------------------------------------------------------------------
-
-  ABSL_ATTRIBUTE_NOINLINE void InitFrom(const Storage& other);
-
-  template <typename ValueAdapter>
-  void Initialize(ValueAdapter values, SizeType<A> new_size);
-
-  template <typename ValueAdapter>
-  void Assign(ValueAdapter values, SizeType<A> new_size);
-
-  template <typename ValueAdapter>
-  void Resize(ValueAdapter values, SizeType<A> new_size);
-
-  template <typename ValueAdapter>
-  Iterator<A> Insert(ConstIterator<A> pos, ValueAdapter values,
-                     SizeType<A> insert_count);
-
-  template <typename... Args>
-  Reference<A> EmplaceBack(Args&&... args);
-
-  Iterator<A> Erase(ConstIterator<A> from, ConstIterator<A> to);
-
-  void Reserve(SizeType<A> requested_capacity);
-
-  void ShrinkToFit();
-
-  void Swap(Storage* other_storage_ptr);
-
-  void SetIsAllocated() {
-    GetSizeAndIsAllocated() |= static_cast<SizeType<A>>(1);
-  }
-
-  void UnsetIsAllocated() {
-    GetSizeAndIsAllocated() &= ((std::numeric_limits<SizeType<A>>::max)() - 1);
-  }
-
-  void SetSize(SizeType<A> size) {
-    GetSizeAndIsAllocated() =
-        (size << 1) | static_cast<SizeType<A>>(GetIsAllocated());
-  }
-
-  void SetAllocatedSize(SizeType<A> size) {
-    GetSizeAndIsAllocated() = (size << 1) | static_cast<SizeType<A>>(1);
-  }
-
-  void SetInlinedSize(SizeType<A> size) {
-    GetSizeAndIsAllocated() = size << static_cast<SizeType<A>>(1);
-  }
-
-  void AddSize(SizeType<A> count) {
-    GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
-  }
-
-  void SubtractSize(SizeType<A> count) {
-    ABSL_HARDENING_ASSERT(count <= GetSize());
-
-    GetSizeAndIsAllocated() -= count << static_cast<SizeType<A>>(1);
-  }
-
-  void SetAllocation(Allocation<A> allocation) {
-    data_.allocated.allocated_data = allocation.data;
-    data_.allocated.allocated_capacity = allocation.capacity;
-  }
-
-  void MemcpyFrom(const Storage& other_storage) {
-    ABSL_HARDENING_ASSERT(IsMemcpyOk<A>::value ||
-                          other_storage.GetIsAllocated());
-
-    GetSizeAndIsAllocated() = other_storage.GetSizeAndIsAllocated();
-    data_ = other_storage.data_;
-  }
-
-  void DeallocateIfAllocated() {
-    if (GetIsAllocated()) {
-      MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(),
-                                   GetAllocatedCapacity());
-    }
-  }
-
- private:
-  ABSL_ATTRIBUTE_NOINLINE void DestroyContents();
-
-  using Metadata = container_internal::CompressedTuple<A, SizeType<A>>;
-
-  struct Allocated {
-    Pointer<A> allocated_data;
-    SizeType<A> allocated_capacity;
-  };
-
-  struct Inlined {
-    alignas(ValueType<A>) char inlined_data[sizeof(ValueType<A>[N])];
-  };
-
-  union Data {
-    Allocated allocated;
-    Inlined inlined;
-  };
-
-  template <typename... Args>
-  ABSL_ATTRIBUTE_NOINLINE Reference<A> EmplaceBackSlow(Args&&... args);
-
-  Metadata metadata_;
-  Data data_;
-};
-
-template <typename T, size_t N, typename A>
-void Storage<T, N, A>::DestroyContents() {
-  Pointer<A> data = GetIsAllocated() ? GetAllocatedData() : GetInlinedData();
-  DestroyAdapter<A>::DestroyElements(GetAllocator(), data, GetSize());
-  DeallocateIfAllocated();
-}
-
-template <typename T, size_t N, typename A>
-void Storage<T, N, A>::InitFrom(const Storage& other) {
-  const SizeType<A> n = other.GetSize();
-  ABSL_HARDENING_ASSERT(n > 0);  // Empty sources handled handled in caller.
-  ConstPointer<A> src;
-  Pointer<A> dst;
-  if (!other.GetIsAllocated()) {
-    dst = GetInlinedData();
-    src = other.GetInlinedData();
-  } else {
-    // Because this is only called from the `InlinedVector` constructors, it's
-    // safe to take on the allocation with size `0`. If `ConstructElements(...)`
-    // throws, deallocation will be automatically handled by `~Storage()`.
-    SizeType<A> requested_capacity = ComputeCapacity(GetInlinedCapacity(), n);
-    Allocation<A> allocation =
-        MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
-    SetAllocation(allocation);
-    dst = allocation.data;
-    src = other.GetAllocatedData();
-  }
-  if (IsMemcpyOk<A>::value) {
-    std::memcpy(reinterpret_cast<char*>(dst),
-                reinterpret_cast<const char*>(src), n * sizeof(ValueType<A>));
-  } else {
-    auto values = IteratorValueAdapter<A, ConstPointer<A>>(src);
-    ConstructElements<A>(GetAllocator(), dst, values, n);
-  }
-  GetSizeAndIsAllocated() = other.GetSizeAndIsAllocated();
-}
-
-template <typename T, size_t N, typename A>
-template <typename ValueAdapter>
-auto Storage<T, N, A>::Initialize(ValueAdapter values, SizeType<A> new_size)
-    -> void {
-  // Only callable from constructors!
-  ABSL_HARDENING_ASSERT(!GetIsAllocated());
-  ABSL_HARDENING_ASSERT(GetSize() == 0);
-
-  Pointer<A> construct_data;
-  if (new_size > GetInlinedCapacity()) {
-    // Because this is only called from the `InlinedVector` constructors, it's
-    // safe to take on the allocation with size `0`. If `ConstructElements(...)`
-    // throws, deallocation will be automatically handled by `~Storage()`.
-    SizeType<A> requested_capacity =
-        ComputeCapacity(GetInlinedCapacity(), new_size);
-    Allocation<A> allocation =
-        MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
-    construct_data = allocation.data;
-    SetAllocation(allocation);
-    SetIsAllocated();
-  } else {
-    construct_data = GetInlinedData();
-  }
-
-  ConstructElements<A>(GetAllocator(), construct_data, values, new_size);
-
-  // Since the initial size was guaranteed to be `0` and the allocated bit is
-  // already correct for either case, *adding* `new_size` gives us the correct
-  // result faster than setting it directly.
-  AddSize(new_size);
-}
-
-template <typename T, size_t N, typename A>
-template <typename ValueAdapter>
-auto Storage<T, N, A>::Assign(ValueAdapter values, SizeType<A> new_size)
-    -> void {
-  StorageView<A> storage_view = MakeStorageView();
-
-  AllocationTransaction<A> allocation_tx(GetAllocator());
-
-  absl::Span<ValueType<A>> assign_loop;
-  absl::Span<ValueType<A>> construct_loop;
-  absl::Span<ValueType<A>> destroy_loop;
-
-  if (new_size > storage_view.capacity) {
-    SizeType<A> requested_capacity =
-        ComputeCapacity(storage_view.capacity, new_size);
-    construct_loop = {allocation_tx.Allocate(requested_capacity), new_size};
-    destroy_loop = {storage_view.data, storage_view.size};
-  } else if (new_size > storage_view.size) {
-    assign_loop = {storage_view.data, storage_view.size};
-    construct_loop = {storage_view.data + storage_view.size,
-                      new_size - storage_view.size};
-  } else {
-    assign_loop = {storage_view.data, new_size};
-    destroy_loop = {storage_view.data + new_size, storage_view.size - new_size};
-  }
-
-  AssignElements<A>(assign_loop.data(), values, assign_loop.size());
-
-  ConstructElements<A>(GetAllocator(), construct_loop.data(), values,
-                       construct_loop.size());
-
-  DestroyAdapter<A>::DestroyElements(GetAllocator(), destroy_loop.data(),
-                                     destroy_loop.size());
-
-  if (allocation_tx.DidAllocate()) {
-    DeallocateIfAllocated();
-    SetAllocation(std::move(allocation_tx).Release());
-    SetIsAllocated();
-  }
-
-  SetSize(new_size);
-}
-
-template <typename T, size_t N, typename A>
-template <typename ValueAdapter>
-auto Storage<T, N, A>::Resize(ValueAdapter values, SizeType<A> new_size)
-    -> void {
-  StorageView<A> storage_view = MakeStorageView();
-  Pointer<A> const base = storage_view.data;
-  const SizeType<A> size = storage_view.size;
-  A& alloc = GetAllocator();
-  if (new_size <= size) {
-    // Destroy extra old elements.
-    DestroyAdapter<A>::DestroyElements(alloc, base + new_size, size - new_size);
-  } else if (new_size <= storage_view.capacity) {
-    // Construct new elements in place.
-    ConstructElements<A>(alloc, base + size, values, new_size - size);
-  } else {
-    // Steps:
-    //  a. Allocate new backing store.
-    //  b. Construct new elements in new backing store.
-    //  c. Move existing elements from old backing store to new backing store.
-    //  d. Destroy all elements in old backing store.
-    // Use transactional wrappers for the first two steps so we can roll
-    // back if necessary due to exceptions.
-    AllocationTransaction<A> allocation_tx(alloc);
-    SizeType<A> requested_capacity =
-        ComputeCapacity(storage_view.capacity, new_size);
-    Pointer<A> new_data = allocation_tx.Allocate(requested_capacity);
-
-    ConstructionTransaction<A> construction_tx(alloc);
-    construction_tx.Construct(new_data + size, values, new_size - size);
-
-    IteratorValueAdapter<A, MoveIterator<A>> move_values(
-        (MoveIterator<A>(base)));
-    ConstructElements<A>(alloc, new_data, move_values, size);
-
-    DestroyAdapter<A>::DestroyElements(alloc, base, size);
-    std::move(construction_tx).Commit();
-    DeallocateIfAllocated();
-    SetAllocation(std::move(allocation_tx).Release());
-    SetIsAllocated();
-  }
-  SetSize(new_size);
-}
-
-template <typename T, size_t N, typename A>
-template <typename ValueAdapter>
-auto Storage<T, N, A>::Insert(ConstIterator<A> pos, ValueAdapter values,
-                              SizeType<A> insert_count) -> Iterator<A> {
-  StorageView<A> storage_view = MakeStorageView();
-
-  SizeType<A> insert_index =
-      std::distance(ConstIterator<A>(storage_view.data), pos);
-  SizeType<A> insert_end_index = insert_index + insert_count;
-  SizeType<A> new_size = storage_view.size + insert_count;
-
-  if (new_size > storage_view.capacity) {
-    AllocationTransaction<A> allocation_tx(GetAllocator());
-    ConstructionTransaction<A> construction_tx(GetAllocator());
-    ConstructionTransaction<A> move_construction_tx(GetAllocator());
-
-    IteratorValueAdapter<A, MoveIterator<A>> move_values(
-        MoveIterator<A>(storage_view.data));
-
-    SizeType<A> requested_capacity =
-        ComputeCapacity(storage_view.capacity, new_size);
-    Pointer<A> new_data = allocation_tx.Allocate(requested_capacity);
-
-    construction_tx.Construct(new_data + insert_index, values, insert_count);
-
-    move_construction_tx.Construct(new_data, move_values, insert_index);
-
-    ConstructElements<A>(GetAllocator(), new_data + insert_end_index,
-                         move_values, storage_view.size - insert_index);
-
-    DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
-                                       storage_view.size);
-
-    std::move(construction_tx).Commit();
-    std::move(move_construction_tx).Commit();
-    DeallocateIfAllocated();
-    SetAllocation(std::move(allocation_tx).Release());
-
-    SetAllocatedSize(new_size);
-    return Iterator<A>(new_data + insert_index);
-  } else {
-    SizeType<A> move_construction_destination_index =
-        (std::max)(insert_end_index, storage_view.size);
-
-    ConstructionTransaction<A> move_construction_tx(GetAllocator());
-
-    IteratorValueAdapter<A, MoveIterator<A>> move_construction_values(
-        MoveIterator<A>(storage_view.data +
-                        (move_construction_destination_index - insert_count)));
-    absl::Span<ValueType<A>> move_construction = {
-        storage_view.data + move_construction_destination_index,
-        new_size - move_construction_destination_index};
-
-    Pointer<A> move_assignment_values = storage_view.data + insert_index;
-    absl::Span<ValueType<A>> move_assignment = {
-        storage_view.data + insert_end_index,
-        move_construction_destination_index - insert_end_index};
-
-    absl::Span<ValueType<A>> insert_assignment = {move_assignment_values,
-                                                  move_construction.size()};
-
-    absl::Span<ValueType<A>> insert_construction = {
-        insert_assignment.data() + insert_assignment.size(),
-        insert_count - insert_assignment.size()};
-
-    move_construction_tx.Construct(move_construction.data(),
-                                   move_construction_values,
-                                   move_construction.size());
-
-    for (Pointer<A>
-             destination = move_assignment.data() + move_assignment.size(),
-             last_destination = move_assignment.data(),
-             source = move_assignment_values + move_assignment.size();
-         ;) {
-      --destination;
-      --source;
-      if (destination < last_destination) break;
-      *destination = std::move(*source);
-    }
-
-    AssignElements<A>(insert_assignment.data(), values,
-                      insert_assignment.size());
-
-    ConstructElements<A>(GetAllocator(), insert_construction.data(), values,
-                         insert_construction.size());
-
-    std::move(move_construction_tx).Commit();
-
-    AddSize(insert_count);
-    return Iterator<A>(storage_view.data + insert_index);
-  }
-}
-
-template <typename T, size_t N, typename A>
-template <typename... Args>
-auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
-  StorageView<A> storage_view = MakeStorageView();
-  const SizeType<A> n = storage_view.size;
-  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
-    // Fast path; new element fits.
-    Pointer<A> last_ptr = storage_view.data + n;
-    AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
-                                  std::forward<Args>(args)...);
-    AddSize(1);
-    return *last_ptr;
-  }
-  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
-  return EmplaceBackSlow(std::forward<Args>(args)...);
-}
-
-template <typename T, size_t N, typename A>
-template <typename... Args>
-auto Storage<T, N, A>::EmplaceBackSlow(Args&&... args) -> Reference<A> {
-  StorageView<A> storage_view = MakeStorageView();
-  AllocationTransaction<A> allocation_tx(GetAllocator());
-  IteratorValueAdapter<A, MoveIterator<A>> move_values(
-      MoveIterator<A>(storage_view.data));
-  SizeType<A> requested_capacity = NextCapacity(storage_view.capacity);
-  Pointer<A> construct_data = allocation_tx.Allocate(requested_capacity);
-  Pointer<A> last_ptr = construct_data + storage_view.size;
-
-  // Construct new element.
-  AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
-                                std::forward<Args>(args)...);
-  // Move elements from old backing store to new backing store.
-  ABSL_INTERNAL_TRY {
-    ConstructElements<A>(GetAllocator(), allocation_tx.GetData(), move_values,
-                         storage_view.size);
-  }
-  ABSL_INTERNAL_CATCH_ANY {
-    AllocatorTraits<A>::destroy(GetAllocator(), last_ptr);
-    ABSL_INTERNAL_RETHROW;
-  }
-  // Destroy elements in old backing store.
-  DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
-                                     storage_view.size);
-
-  DeallocateIfAllocated();
-  SetAllocation(std::move(allocation_tx).Release());
-  SetIsAllocated();
-  AddSize(1);
-  return *last_ptr;
-}
-
-template <typename T, size_t N, typename A>
-auto Storage<T, N, A>::Erase(ConstIterator<A> from, ConstIterator<A> to)
-    -> Iterator<A> {
-  StorageView<A> storage_view = MakeStorageView();
-
-  SizeType<A> erase_size = std::distance(from, to);
-  SizeType<A> erase_index =
-      std::distance(ConstIterator<A>(storage_view.data), from);
-  SizeType<A> erase_end_index = erase_index + erase_size;
-
-  IteratorValueAdapter<A, MoveIterator<A>> move_values(
-      MoveIterator<A>(storage_view.data + erase_end_index));
-
-  AssignElements<A>(storage_view.data + erase_index, move_values,
-                    storage_view.size - erase_end_index);
-
-  DestroyAdapter<A>::DestroyElements(
-      GetAllocator(), storage_view.data + (storage_view.size - erase_size),
-      erase_size);
-
-  SubtractSize(erase_size);
-  return Iterator<A>(storage_view.data + erase_index);
-}
-
-template <typename T, size_t N, typename A>
-auto Storage<T, N, A>::Reserve(SizeType<A> requested_capacity) -> void {
-  StorageView<A> storage_view = MakeStorageView();
-
-  if (ABSL_PREDICT_FALSE(requested_capacity <= storage_view.capacity)) return;
-
-  AllocationTransaction<A> allocation_tx(GetAllocator());
-
-  IteratorValueAdapter<A, MoveIterator<A>> move_values(
-      MoveIterator<A>(storage_view.data));
-
-  SizeType<A> new_requested_capacity =
-      ComputeCapacity(storage_view.capacity, requested_capacity);
-  Pointer<A> new_data = allocation_tx.Allocate(new_requested_capacity);
-
-  ConstructElements<A>(GetAllocator(), new_data, move_values,
-                       storage_view.size);
-
-  DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
-                                     storage_view.size);
-
-  DeallocateIfAllocated();
-  SetAllocation(std::move(allocation_tx).Release());
-  SetIsAllocated();
-}
-
-template <typename T, size_t N, typename A>
-auto Storage<T, N, A>::ShrinkToFit() -> void {
-  // May only be called on allocated instances!
-  ABSL_HARDENING_ASSERT(GetIsAllocated());
-
-  StorageView<A> storage_view{GetAllocatedData(), GetSize(),
-                              GetAllocatedCapacity()};
-
-  if (ABSL_PREDICT_FALSE(storage_view.size == storage_view.capacity)) return;
-
-  AllocationTransaction<A> allocation_tx(GetAllocator());
-
-  IteratorValueAdapter<A, MoveIterator<A>> move_values(
-      MoveIterator<A>(storage_view.data));
-
-  Pointer<A> construct_data;
-  if (storage_view.size > GetInlinedCapacity()) {
-    SizeType<A> requested_capacity = storage_view.size;
-    construct_data = allocation_tx.Allocate(requested_capacity);
-    if (allocation_tx.GetCapacity() >= storage_view.capacity) {
-      // Already using the smallest available heap allocation.
-      return;
-    }
-  } else {
-    construct_data = GetInlinedData();
-  }
-
-  ABSL_INTERNAL_TRY {
-    ConstructElements<A>(GetAllocator(), construct_data, move_values,
-                         storage_view.size);
-  }
-  ABSL_INTERNAL_CATCH_ANY {
-    SetAllocation({storage_view.data, storage_view.capacity});
-    ABSL_INTERNAL_RETHROW;
-  }
-
-  DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
-                                     storage_view.size);
-
-  MallocAdapter<A>::Deallocate(GetAllocator(), storage_view.data,
-                               storage_view.capacity);
-
-  if (allocation_tx.DidAllocate()) {
-    SetAllocation(std::move(allocation_tx).Release());
-  } else {
-    UnsetIsAllocated();
-  }
-}
-
-template <typename T, size_t N, typename A>
-auto Storage<T, N, A>::Swap(Storage* other_storage_ptr) -> void {
-  using std::swap;
-  ABSL_HARDENING_ASSERT(this != other_storage_ptr);
-
-  if (GetIsAllocated() && other_storage_ptr->GetIsAllocated()) {
-    swap(data_.allocated, other_storage_ptr->data_.allocated);
-  } else if (!GetIsAllocated() && !other_storage_ptr->GetIsAllocated()) {
-    Storage* small_ptr = this;
-    Storage* large_ptr = other_storage_ptr;
-    if (small_ptr->GetSize() > large_ptr->GetSize()) swap(small_ptr, large_ptr);
-
-    for (SizeType<A> i = 0; i < small_ptr->GetSize(); ++i) {
-      swap(small_ptr->GetInlinedData()[i], large_ptr->GetInlinedData()[i]);
-    }
-
-    IteratorValueAdapter<A, MoveIterator<A>> move_values(
-        MoveIterator<A>(large_ptr->GetInlinedData() + small_ptr->GetSize()));
-
-    ConstructElements<A>(large_ptr->GetAllocator(),
-                         small_ptr->GetInlinedData() + small_ptr->GetSize(),
-                         move_values,
-                         large_ptr->GetSize() - small_ptr->GetSize());
-
-    DestroyAdapter<A>::DestroyElements(
-        large_ptr->GetAllocator(),
-        large_ptr->GetInlinedData() + small_ptr->GetSize(),
-        large_ptr->GetSize() - small_ptr->GetSize());
-  } else {
-    Storage* allocated_ptr = this;
-    Storage* inlined_ptr = other_storage_ptr;
-    if (!allocated_ptr->GetIsAllocated()) swap(allocated_ptr, inlined_ptr);
-
-    StorageView<A> allocated_storage_view{
-        allocated_ptr->GetAllocatedData(), allocated_ptr->GetSize(),
-        allocated_ptr->GetAllocatedCapacity()};
-
-    IteratorValueAdapter<A, MoveIterator<A>> move_values(
-        MoveIterator<A>(inlined_ptr->GetInlinedData()));
-
-    ABSL_INTERNAL_TRY {
-      ConstructElements<A>(inlined_ptr->GetAllocator(),
-                           allocated_ptr->GetInlinedData(), move_values,
-                           inlined_ptr->GetSize());
-    }
-    ABSL_INTERNAL_CATCH_ANY {
-      allocated_ptr->SetAllocation(Allocation<A>{
-          allocated_storage_view.data, allocated_storage_view.capacity});
-      ABSL_INTERNAL_RETHROW;
-    }
-
-    DestroyAdapter<A>::DestroyElements(inlined_ptr->GetAllocator(),
-                                       inlined_ptr->GetInlinedData(),
-                                       inlined_ptr->GetSize());
-
-    inlined_ptr->SetAllocation(Allocation<A>{allocated_storage_view.data,
-                                             allocated_storage_view.capacity});
-  }
-
-  swap(GetSizeAndIsAllocated(), other_storage_ptr->GetSizeAndIsAllocated());
-  swap(GetAllocator(), other_storage_ptr->GetAllocator());
-}
+        template<typename A>
+        using AllocatorTraits = std::allocator_traits<A>;
+        template<typename A>
+        using ValueType = typename AllocatorTraits<A>::value_type;
+        template<typename A>
+        using SizeType = typename AllocatorTraits<A>::size_type;
+        template<typename A>
+        using Pointer = typename AllocatorTraits<A>::pointer;
+        template<typename A>
+        using ConstPointer = typename AllocatorTraits<A>::const_pointer;
+        template<typename A>
+        using SizeType = typename AllocatorTraits<A>::size_type;
+        template<typename A>
+        using DifferenceType = typename AllocatorTraits<A>::difference_type;
+        template<typename A>
+        using Reference = ValueType<A>&;
+        template<typename A>
+        using ConstReference = const ValueType<A>&;
+        template<typename A>
+        using Iterator = Pointer<A>;
+        template<typename A>
+        using ConstIterator = ConstPointer<A>;
+        template<typename A>
+        using ReverseIterator = typename std::reverse_iterator<Iterator<A>>;
+        template<typename A>
+        using ConstReverseIterator = typename std::reverse_iterator<ConstIterator<A>>;
+        template<typename A>
+        using MoveIterator = typename std::move_iterator<Iterator<A>>;
+
+        template<typename Iterator>
+        using IsAtLeastForwardIterator = std::is_convertible<
+            typename std::iterator_traits<Iterator>::iterator_category,
+            std::forward_iterator_tag>;
+
+        template<typename A>
+        using IsMemcpyOk =
+            absl::conjunction<std::is_same<A, std::allocator<ValueType<A>>>, absl::is_trivially_copy_constructible<ValueType<A>>, absl::is_trivially_copy_assignable<ValueType<A>>, absl::is_trivially_destructible<ValueType<A>>>;
+
+        template<typename T>
+        struct TypeIdentity
+        {
+            using type = T;
+        };
+
+        // Used for function arguments in template functions to prevent ADL by forcing
+        // callers to explicitly specify the template parameter.
+        template<typename T>
+        using NoTypeDeduction = typename TypeIdentity<T>::type;
+
+        template<typename A, bool IsTriviallyDestructible = absl::is_trivially_destructible<ValueType<A>>::value>
+        struct DestroyAdapter;
+
+        template<typename A>
+        struct DestroyAdapter<A, /* IsTriviallyDestructible */ false>
+        {
+            static void DestroyElements(A& allocator, Pointer<A> destroy_first, SizeType<A> destroy_size)
+            {
+                for (SizeType<A> i = destroy_size; i != 0;)
+                {
+                    --i;
+                    AllocatorTraits<A>::destroy(allocator, destroy_first + i);
+                }
+            }
+        };
+
+        template<typename A>
+        struct DestroyAdapter<A, /* IsTriviallyDestructible */ true>
+        {
+            static void DestroyElements(A& allocator, Pointer<A> destroy_first, SizeType<A> destroy_size)
+            {
+                static_cast<void>(allocator);
+                static_cast<void>(destroy_first);
+                static_cast<void>(destroy_size);
+            }
+        };
+
+        template<typename A>
+        struct Allocation
+        {
+            Pointer<A> data;
+            SizeType<A> capacity;
+        };
+
+        template<typename A, bool IsOverAligned = (alignof(ValueType<A>) > ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT)>
+        struct MallocAdapter
+        {
+            static Allocation<A> Allocate(A& allocator, SizeType<A> requested_capacity)
+            {
+                return {AllocatorTraits<A>::allocate(allocator, requested_capacity), requested_capacity};
+            }
+
+            static void Deallocate(A& allocator, Pointer<A> pointer, SizeType<A> capacity)
+            {
+                AllocatorTraits<A>::deallocate(allocator, pointer, capacity);
+            }
+        };
+
+        template<typename A, typename ValueAdapter>
+        void ConstructElements(NoTypeDeduction<A>& allocator, Pointer<A> construct_first, ValueAdapter& values, SizeType<A> construct_size)
+        {
+            for (SizeType<A> i = 0; i < construct_size; ++i)
+            {
+                ABSL_INTERNAL_TRY
+                {
+                    values.ConstructNext(allocator, construct_first + i);
+                }
+                ABSL_INTERNAL_CATCH_ANY
+                {
+                    DestroyAdapter<A>::DestroyElements(allocator, construct_first, i);
+                    ABSL_INTERNAL_RETHROW;
+                }
+            }
+        }
+
+        template<typename A, typename ValueAdapter>
+        void AssignElements(Pointer<A> assign_first, ValueAdapter& values, SizeType<A> assign_size)
+        {
+            for (SizeType<A> i = 0; i < assign_size; ++i)
+            {
+                values.AssignNext(assign_first + i);
+            }
+        }
+
+        template<typename A>
+        struct StorageView
+        {
+            Pointer<A> data;
+            SizeType<A> size;
+            SizeType<A> capacity;
+        };
+
+        template<typename A, typename Iterator>
+        class IteratorValueAdapter
+        {
+        public:
+            explicit IteratorValueAdapter(const Iterator& it) :
+                it_(it)
+            {
+            }
+
+            void ConstructNext(A& allocator, Pointer<A> construct_at)
+            {
+                AllocatorTraits<A>::construct(allocator, construct_at, *it_);
+                ++it_;
+            }
+
+            void AssignNext(Pointer<A> assign_at)
+            {
+                *assign_at = *it_;
+                ++it_;
+            }
+
+        private:
+            Iterator it_;
+        };
+
+        template<typename A>
+        class CopyValueAdapter
+        {
+        public:
+            explicit CopyValueAdapter(ConstPointer<A> p) :
+                ptr_(p)
+            {
+            }
+
+            void ConstructNext(A& allocator, Pointer<A> construct_at)
+            {
+                AllocatorTraits<A>::construct(allocator, construct_at, *ptr_);
+            }
+
+            void AssignNext(Pointer<A> assign_at)
+            {
+                *assign_at = *ptr_;
+            }
+
+        private:
+            ConstPointer<A> ptr_;
+        };
+
+        template<typename A>
+        class DefaultValueAdapter
+        {
+        public:
+            explicit DefaultValueAdapter()
+            {
+            }
+
+            void ConstructNext(A& allocator, Pointer<A> construct_at)
+            {
+                AllocatorTraits<A>::construct(allocator, construct_at);
+            }
+
+            void AssignNext(Pointer<A> assign_at)
+            {
+                *assign_at = ValueType<A>();
+            }
+        };
+
+        template<typename A>
+        class AllocationTransaction
+        {
+        public:
+            explicit AllocationTransaction(A& allocator) :
+                allocator_data_(allocator, nullptr),
+                capacity_(0)
+            {
+            }
+
+            ~AllocationTransaction()
+            {
+                if (DidAllocate())
+                {
+                    MallocAdapter<A>::Deallocate(GetAllocator(), GetData(), GetCapacity());
+                }
+            }
+
+            AllocationTransaction(const AllocationTransaction&) = delete;
+            void operator=(const AllocationTransaction&) = delete;
+
+            A& GetAllocator()
+            {
+                return allocator_data_.template get<0>();
+            }
+            Pointer<A>& GetData()
+            {
+                return allocator_data_.template get<1>();
+            }
+            SizeType<A>& GetCapacity()
+            {
+                return capacity_;
+            }
+
+            bool DidAllocate()
+            {
+                return GetData() != nullptr;
+            }
+
+            Pointer<A> Allocate(SizeType<A> requested_capacity)
+            {
+                Allocation<A> result =
+                    MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
+                GetData() = result.data;
+                GetCapacity() = result.capacity;
+                return result.data;
+            }
+
+            ABSL_MUST_USE_RESULT Allocation<A> Release() &&
+            {
+                Allocation<A> result = {GetData(), GetCapacity()};
+                Reset();
+                return result;
+            }
+
+        private:
+            void Reset()
+            {
+                GetData() = nullptr;
+                GetCapacity() = 0;
+            }
+
+            container_internal::CompressedTuple<A, Pointer<A>> allocator_data_;
+            SizeType<A> capacity_;
+        };
+
+        template<typename A>
+        class ConstructionTransaction
+        {
+        public:
+            explicit ConstructionTransaction(A& allocator) :
+                allocator_data_(allocator, nullptr),
+                size_(0)
+            {
+            }
+
+            ~ConstructionTransaction()
+            {
+                if (DidConstruct())
+                {
+                    DestroyAdapter<A>::DestroyElements(GetAllocator(), GetData(), GetSize());
+                }
+            }
+
+            ConstructionTransaction(const ConstructionTransaction&) = delete;
+            void operator=(const ConstructionTransaction&) = delete;
+
+            A& GetAllocator()
+            {
+                return allocator_data_.template get<0>();
+            }
+            Pointer<A>& GetData()
+            {
+                return allocator_data_.template get<1>();
+            }
+            SizeType<A>& GetSize()
+            {
+                return size_;
+            }
+
+            bool DidConstruct()
+            {
+                return GetData() != nullptr;
+            }
+            template<typename ValueAdapter>
+            void Construct(Pointer<A> data, ValueAdapter& values, SizeType<A> size)
+            {
+                ConstructElements<A>(GetAllocator(), data, values, size);
+                GetData() = data;
+                GetSize() = size;
+            }
+            void Commit() &&
+            {
+                GetData() = nullptr;
+                GetSize() = 0;
+            }
+
+        private:
+            container_internal::CompressedTuple<A, Pointer<A>> allocator_data_;
+            SizeType<A> size_;
+        };
+
+        template<typename T, size_t N, typename A>
+        class Storage
+        {
+        public:
+            static SizeType<A> NextCapacity(SizeType<A> current_capacity)
+            {
+                return current_capacity * 2;
+            }
+
+            static SizeType<A> ComputeCapacity(SizeType<A> current_capacity, SizeType<A> requested_capacity)
+            {
+                return (std::max)(NextCapacity(current_capacity), requested_capacity);
+            }
+
+            // ---------------------------------------------------------------------------
+            // Storage Constructors and Destructor
+            // ---------------------------------------------------------------------------
+
+            Storage() :
+                metadata_(A(), /* size and is_allocated */ 0u)
+            {
+            }
+
+            explicit Storage(const A& allocator) :
+                metadata_(allocator, /* size and is_allocated */ 0u)
+            {
+            }
+
+            ~Storage()
+            {
+                if (GetSizeAndIsAllocated() == 0)
+                {
+                    // Empty and not allocated; nothing to do.
+                }
+                else if (IsMemcpyOk<A>::value)
+                {
+                    // No destructors need to be run; just deallocate if necessary.
+                    DeallocateIfAllocated();
+                }
+                else
+                {
+                    DestroyContents();
+                }
+            }
+
+            // ---------------------------------------------------------------------------
+            // Storage Member Accessors
+            // ---------------------------------------------------------------------------
+
+            SizeType<A>& GetSizeAndIsAllocated()
+            {
+                return metadata_.template get<1>();
+            }
+
+            const SizeType<A>& GetSizeAndIsAllocated() const
+            {
+                return metadata_.template get<1>();
+            }
+
+            SizeType<A> GetSize() const
+            {
+                return GetSizeAndIsAllocated() >> 1;
+            }
+
+            bool GetIsAllocated() const
+            {
+                return GetSizeAndIsAllocated() & 1;
+            }
+
+            Pointer<A> GetAllocatedData()
+            {
+                return data_.allocated.allocated_data;
+            }
+
+            ConstPointer<A> GetAllocatedData() const
+            {
+                return data_.allocated.allocated_data;
+            }
+
+            Pointer<A> GetInlinedData()
+            {
+                return reinterpret_cast<Pointer<A>>(
+                    std::addressof(data_.inlined.inlined_data[0])
+                );
+            }
+
+            ConstPointer<A> GetInlinedData() const
+            {
+                return reinterpret_cast<ConstPointer<A>>(
+                    std::addressof(data_.inlined.inlined_data[0])
+                );
+            }
+
+            SizeType<A> GetAllocatedCapacity() const
+            {
+                return data_.allocated.allocated_capacity;
+            }
+
+            SizeType<A> GetInlinedCapacity() const
+            {
+                return static_cast<SizeType<A>>(N);
+            }
+
+            StorageView<A> MakeStorageView()
+            {
+                return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(), GetAllocatedCapacity()} : StorageView<A>{GetInlinedData(), GetSize(), GetInlinedCapacity()};
+            }
+
+            A& GetAllocator()
+            {
+                return metadata_.template get<0>();
+            }
+
+            const A& GetAllocator() const
+            {
+                return metadata_.template get<0>();
+            }
+
+            // ---------------------------------------------------------------------------
+            // Storage Member Mutators
+            // ---------------------------------------------------------------------------
+
+            ABSL_ATTRIBUTE_NOINLINE void InitFrom(const Storage& other);
+
+            template<typename ValueAdapter>
+            void Initialize(ValueAdapter values, SizeType<A> new_size);
+
+            template<typename ValueAdapter>
+            void Assign(ValueAdapter values, SizeType<A> new_size);
+
+            template<typename ValueAdapter>
+            void Resize(ValueAdapter values, SizeType<A> new_size);
+
+            template<typename ValueAdapter>
+            Iterator<A> Insert(ConstIterator<A> pos, ValueAdapter values, SizeType<A> insert_count);
+
+            template<typename... Args>
+            Reference<A> EmplaceBack(Args&&... args);
+
+            Iterator<A> Erase(ConstIterator<A> from, ConstIterator<A> to);
+
+            void Reserve(SizeType<A> requested_capacity);
+
+            void ShrinkToFit();
+
+            void Swap(Storage* other_storage_ptr);
+
+            void SetIsAllocated()
+            {
+                GetSizeAndIsAllocated() |= static_cast<SizeType<A>>(1);
+            }
+
+            void UnsetIsAllocated()
+            {
+                GetSizeAndIsAllocated() &= ((std::numeric_limits<SizeType<A>>::max)() - 1);
+            }
+
+            void SetSize(SizeType<A> size)
+            {
+                GetSizeAndIsAllocated() =
+                    (size << 1) | static_cast<SizeType<A>>(GetIsAllocated());
+            }
+
+            void SetAllocatedSize(SizeType<A> size)
+            {
+                GetSizeAndIsAllocated() = (size << 1) | static_cast<SizeType<A>>(1);
+            }
+
+            void SetInlinedSize(SizeType<A> size)
+            {
+                GetSizeAndIsAllocated() = size << static_cast<SizeType<A>>(1);
+            }
+
+            void AddSize(SizeType<A> count)
+            {
+                GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
+            }
+
+            void SubtractSize(SizeType<A> count)
+            {
+                ABSL_HARDENING_ASSERT(count <= GetSize());
+
+                GetSizeAndIsAllocated() -= count << static_cast<SizeType<A>>(1);
+            }
+
+            void SetAllocation(Allocation<A> allocation)
+            {
+                data_.allocated.allocated_data = allocation.data;
+                data_.allocated.allocated_capacity = allocation.capacity;
+            }
+
+            void MemcpyFrom(const Storage& other_storage)
+            {
+                ABSL_HARDENING_ASSERT(IsMemcpyOk<A>::value || other_storage.GetIsAllocated());
+
+                GetSizeAndIsAllocated() = other_storage.GetSizeAndIsAllocated();
+                data_ = other_storage.data_;
+            }
+
+            void DeallocateIfAllocated()
+            {
+                if (GetIsAllocated())
+                {
+                    MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(), GetAllocatedCapacity());
+                }
+            }
+
+        private:
+            ABSL_ATTRIBUTE_NOINLINE void DestroyContents();
+
+            using Metadata = container_internal::CompressedTuple<A, SizeType<A>>;
+
+            struct Allocated
+            {
+                Pointer<A> allocated_data;
+                SizeType<A> allocated_capacity;
+            };
+
+            struct Inlined
+            {
+                alignas(ValueType<A>) char inlined_data[sizeof(ValueType<A>[N])];
+            };
+
+            union Data
+            {
+                Allocated allocated;
+                Inlined inlined;
+            };
+
+            template<typename... Args>
+            ABSL_ATTRIBUTE_NOINLINE Reference<A> EmplaceBackSlow(Args&&... args);
+
+            Metadata metadata_;
+            Data data_;
+        };
+
+        template<typename T, size_t N, typename A>
+        void Storage<T, N, A>::DestroyContents()
+        {
+            Pointer<A> data = GetIsAllocated() ? GetAllocatedData() : GetInlinedData();
+            DestroyAdapter<A>::DestroyElements(GetAllocator(), data, GetSize());
+            DeallocateIfAllocated();
+        }
+
+        template<typename T, size_t N, typename A>
+        void Storage<T, N, A>::InitFrom(const Storage& other)
+        {
+            const SizeType<A> n = other.GetSize();
+            ABSL_HARDENING_ASSERT(n > 0);  // Empty sources handled handled in caller.
+            ConstPointer<A> src;
+            Pointer<A> dst;
+            if (!other.GetIsAllocated())
+            {
+                dst = GetInlinedData();
+                src = other.GetInlinedData();
+            }
+            else
+            {
+                // Because this is only called from the `InlinedVector` constructors, it's
+                // safe to take on the allocation with size `0`. If `ConstructElements(...)`
+                // throws, deallocation will be automatically handled by `~Storage()`.
+                SizeType<A> requested_capacity = ComputeCapacity(GetInlinedCapacity(), n);
+                Allocation<A> allocation =
+                    MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
+                SetAllocation(allocation);
+                dst = allocation.data;
+                src = other.GetAllocatedData();
+            }
+            if (IsMemcpyOk<A>::value)
+            {
+                std::memcpy(reinterpret_cast<char*>(dst), reinterpret_cast<const char*>(src), n * sizeof(ValueType<A>));
+            }
+            else
+            {
+                auto values = IteratorValueAdapter<A, ConstPointer<A>>(src);
+                ConstructElements<A>(GetAllocator(), dst, values, n);
+            }
+            GetSizeAndIsAllocated() = other.GetSizeAndIsAllocated();
+        }
+
+        template<typename T, size_t N, typename A>
+        template<typename ValueAdapter>
+        auto Storage<T, N, A>::Initialize(ValueAdapter values, SizeType<A> new_size)
+            -> void
+        {
+            // Only callable from constructors!
+            ABSL_HARDENING_ASSERT(!GetIsAllocated());
+            ABSL_HARDENING_ASSERT(GetSize() == 0);
+
+            Pointer<A> construct_data;
+            if (new_size > GetInlinedCapacity())
+            {
+                // Because this is only called from the `InlinedVector` constructors, it's
+                // safe to take on the allocation with size `0`. If `ConstructElements(...)`
+                // throws, deallocation will be automatically handled by `~Storage()`.
+                SizeType<A> requested_capacity =
+                    ComputeCapacity(GetInlinedCapacity(), new_size);
+                Allocation<A> allocation =
+                    MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
+                construct_data = allocation.data;
+                SetAllocation(allocation);
+                SetIsAllocated();
+            }
+            else
+            {
+                construct_data = GetInlinedData();
+            }
+
+            ConstructElements<A>(GetAllocator(), construct_data, values, new_size);
+
+            // Since the initial size was guaranteed to be `0` and the allocated bit is
+            // already correct for either case, *adding* `new_size` gives us the correct
+            // result faster than setting it directly.
+            AddSize(new_size);
+        }
+
+        template<typename T, size_t N, typename A>
+        template<typename ValueAdapter>
+        auto Storage<T, N, A>::Assign(ValueAdapter values, SizeType<A> new_size)
+            -> void
+        {
+            StorageView<A> storage_view = MakeStorageView();
+
+            AllocationTransaction<A> allocation_tx(GetAllocator());
+
+            absl::Span<ValueType<A>> assign_loop;
+            absl::Span<ValueType<A>> construct_loop;
+            absl::Span<ValueType<A>> destroy_loop;
+
+            if (new_size > storage_view.capacity)
+            {
+                SizeType<A> requested_capacity =
+                    ComputeCapacity(storage_view.capacity, new_size);
+                construct_loop = {allocation_tx.Allocate(requested_capacity), new_size};
+                destroy_loop = {storage_view.data, storage_view.size};
+            }
+            else if (new_size > storage_view.size)
+            {
+                assign_loop = {storage_view.data, storage_view.size};
+                construct_loop = {storage_view.data + storage_view.size, new_size - storage_view.size};
+            }
+            else
+            {
+                assign_loop = {storage_view.data, new_size};
+                destroy_loop = {storage_view.data + new_size, storage_view.size - new_size};
+            }
+
+            AssignElements<A>(assign_loop.data(), values, assign_loop.size());
+
+            ConstructElements<A>(GetAllocator(), construct_loop.data(), values, construct_loop.size());
+
+            DestroyAdapter<A>::DestroyElements(GetAllocator(), destroy_loop.data(), destroy_loop.size());
+
+            if (allocation_tx.DidAllocate())
+            {
+                DeallocateIfAllocated();
+                SetAllocation(std::move(allocation_tx).Release());
+                SetIsAllocated();
+            }
+
+            SetSize(new_size);
+        }
+
+        template<typename T, size_t N, typename A>
+        template<typename ValueAdapter>
+        auto Storage<T, N, A>::Resize(ValueAdapter values, SizeType<A> new_size)
+            -> void
+        {
+            StorageView<A> storage_view = MakeStorageView();
+            Pointer<A> const base = storage_view.data;
+            const SizeType<A> size = storage_view.size;
+            A& alloc = GetAllocator();
+            if (new_size <= size)
+            {
+                // Destroy extra old elements.
+                DestroyAdapter<A>::DestroyElements(alloc, base + new_size, size - new_size);
+            }
+            else if (new_size <= storage_view.capacity)
+            {
+                // Construct new elements in place.
+                ConstructElements<A>(alloc, base + size, values, new_size - size);
+            }
+            else
+            {
+                // Steps:
+                //  a. Allocate new backing store.
+                //  b. Construct new elements in new backing store.
+                //  c. Move existing elements from old backing store to new backing store.
+                //  d. Destroy all elements in old backing store.
+                // Use transactional wrappers for the first two steps so we can roll
+                // back if necessary due to exceptions.
+                AllocationTransaction<A> allocation_tx(alloc);
+                SizeType<A> requested_capacity =
+                    ComputeCapacity(storage_view.capacity, new_size);
+                Pointer<A> new_data = allocation_tx.Allocate(requested_capacity);
+
+                ConstructionTransaction<A> construction_tx(alloc);
+                construction_tx.Construct(new_data + size, values, new_size - size);
+
+                IteratorValueAdapter<A, MoveIterator<A>> move_values(
+                    (MoveIterator<A>(base))
+                );
+                ConstructElements<A>(alloc, new_data, move_values, size);
+
+                DestroyAdapter<A>::DestroyElements(alloc, base, size);
+                std::move(construction_tx).Commit();
+                DeallocateIfAllocated();
+                SetAllocation(std::move(allocation_tx).Release());
+                SetIsAllocated();
+            }
+            SetSize(new_size);
+        }
+
+        template<typename T, size_t N, typename A>
+        template<typename ValueAdapter>
+        auto Storage<T, N, A>::Insert(ConstIterator<A> pos, ValueAdapter values, SizeType<A> insert_count) -> Iterator<A>
+        {
+            StorageView<A> storage_view = MakeStorageView();
+
+            SizeType<A> insert_index =
+                std::distance(ConstIterator<A>(storage_view.data), pos);
+            SizeType<A> insert_end_index = insert_index + insert_count;
+            SizeType<A> new_size = storage_view.size + insert_count;
+
+            if (new_size > storage_view.capacity)
+            {
+                AllocationTransaction<A> allocation_tx(GetAllocator());
+                ConstructionTransaction<A> construction_tx(GetAllocator());
+                ConstructionTransaction<A> move_construction_tx(GetAllocator());
+
+                IteratorValueAdapter<A, MoveIterator<A>> move_values(
+                    MoveIterator<A>(storage_view.data)
+                );
+
+                SizeType<A> requested_capacity =
+                    ComputeCapacity(storage_view.capacity, new_size);
+                Pointer<A> new_data = allocation_tx.Allocate(requested_capacity);
+
+                construction_tx.Construct(new_data + insert_index, values, insert_count);
+
+                move_construction_tx.Construct(new_data, move_values, insert_index);
+
+                ConstructElements<A>(GetAllocator(), new_data + insert_end_index, move_values, storage_view.size - insert_index);
+
+                DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data, storage_view.size);
+
+                std::move(construction_tx).Commit();
+                std::move(move_construction_tx).Commit();
+                DeallocateIfAllocated();
+                SetAllocation(std::move(allocation_tx).Release());
+
+                SetAllocatedSize(new_size);
+                return Iterator<A>(new_data + insert_index);
+            }
+            else
+            {
+                SizeType<A> move_construction_destination_index =
+                    (std::max)(insert_end_index, storage_view.size);
+
+                ConstructionTransaction<A> move_construction_tx(GetAllocator());
+
+                IteratorValueAdapter<A, MoveIterator<A>> move_construction_values(
+                    MoveIterator<A>(storage_view.data + (move_construction_destination_index - insert_count))
+                );
+                absl::Span<ValueType<A>> move_construction = {
+                    storage_view.data + move_construction_destination_index,
+                    new_size - move_construction_destination_index};
+
+                Pointer<A> move_assignment_values = storage_view.data + insert_index;
+                absl::Span<ValueType<A>> move_assignment = {
+                    storage_view.data + insert_end_index,
+                    move_construction_destination_index - insert_end_index};
+
+                absl::Span<ValueType<A>> insert_assignment = {move_assignment_values, move_construction.size()};
+
+                absl::Span<ValueType<A>> insert_construction = {
+                    insert_assignment.data() + insert_assignment.size(),
+                    insert_count - insert_assignment.size()};
+
+                move_construction_tx.Construct(move_construction.data(), move_construction_values, move_construction.size());
+
+                for (Pointer<A>
+                         destination = move_assignment.data() + move_assignment.size(),
+                         last_destination = move_assignment.data(),
+                         source = move_assignment_values + move_assignment.size();
+                     ;)
+                {
+                    --destination;
+                    --source;
+                    if (destination < last_destination)
+                        break;
+                    *destination = std::move(*source);
+                }
+
+                AssignElements<A>(insert_assignment.data(), values, insert_assignment.size());
+
+                ConstructElements<A>(GetAllocator(), insert_construction.data(), values, insert_construction.size());
+
+                std::move(move_construction_tx).Commit();
+
+                AddSize(insert_count);
+                return Iterator<A>(storage_view.data + insert_index);
+            }
+        }
+
+        template<typename T, size_t N, typename A>
+        template<typename... Args>
+        auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A>
+        {
+            StorageView<A> storage_view = MakeStorageView();
+            const SizeType<A> n = storage_view.size;
+            if (ABSL_PREDICT_TRUE(n != storage_view.capacity))
+            {
+                // Fast path; new element fits.
+                Pointer<A> last_ptr = storage_view.data + n;
+                AllocatorTraits<A>::construct(GetAllocator(), last_ptr, std::forward<Args>(args)...);
+                AddSize(1);
+                return *last_ptr;
+            }
+            // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
+            return EmplaceBackSlow(std::forward<Args>(args)...);
+        }
+
+        template<typename T, size_t N, typename A>
+        template<typename... Args>
+        auto Storage<T, N, A>::EmplaceBackSlow(Args&&... args) -> Reference<A>
+        {
+            StorageView<A> storage_view = MakeStorageView();
+            AllocationTransaction<A> allocation_tx(GetAllocator());
+            IteratorValueAdapter<A, MoveIterator<A>> move_values(
+                MoveIterator<A>(storage_view.data)
+            );
+            SizeType<A> requested_capacity = NextCapacity(storage_view.capacity);
+            Pointer<A> construct_data = allocation_tx.Allocate(requested_capacity);
+            Pointer<A> last_ptr = construct_data + storage_view.size;
+
+            // Construct new element.
+            AllocatorTraits<A>::construct(GetAllocator(), last_ptr, std::forward<Args>(args)...);
+            // Move elements from old backing store to new backing store.
+            ABSL_INTERNAL_TRY
+            {
+                ConstructElements<A>(GetAllocator(), allocation_tx.GetData(), move_values, storage_view.size);
+            }
+            ABSL_INTERNAL_CATCH_ANY
+            {
+                AllocatorTraits<A>::destroy(GetAllocator(), last_ptr);
+                ABSL_INTERNAL_RETHROW;
+            }
+            // Destroy elements in old backing store.
+            DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data, storage_view.size);
+
+            DeallocateIfAllocated();
+            SetAllocation(std::move(allocation_tx).Release());
+            SetIsAllocated();
+            AddSize(1);
+            return *last_ptr;
+        }
+
+        template<typename T, size_t N, typename A>
+        auto Storage<T, N, A>::Erase(ConstIterator<A> from, ConstIterator<A> to)
+            -> Iterator<A>
+        {
+            StorageView<A> storage_view = MakeStorageView();
+
+            SizeType<A> erase_size = std::distance(from, to);
+            SizeType<A> erase_index =
+                std::distance(ConstIterator<A>(storage_view.data), from);
+            SizeType<A> erase_end_index = erase_index + erase_size;
+
+            IteratorValueAdapter<A, MoveIterator<A>> move_values(
+                MoveIterator<A>(storage_view.data + erase_end_index)
+            );
+
+            AssignElements<A>(storage_view.data + erase_index, move_values, storage_view.size - erase_end_index);
+
+            DestroyAdapter<A>::DestroyElements(
+                GetAllocator(), storage_view.data + (storage_view.size - erase_size), erase_size
+            );
+
+            SubtractSize(erase_size);
+            return Iterator<A>(storage_view.data + erase_index);
+        }
+
+        template<typename T, size_t N, typename A>
+        auto Storage<T, N, A>::Reserve(SizeType<A> requested_capacity) -> void
+        {
+            StorageView<A> storage_view = MakeStorageView();
+
+            if (ABSL_PREDICT_FALSE(requested_capacity <= storage_view.capacity))
+                return;
+
+            AllocationTransaction<A> allocation_tx(GetAllocator());
+
+            IteratorValueAdapter<A, MoveIterator<A>> move_values(
+                MoveIterator<A>(storage_view.data)
+            );
+
+            SizeType<A> new_requested_capacity =
+                ComputeCapacity(storage_view.capacity, requested_capacity);
+            Pointer<A> new_data = allocation_tx.Allocate(new_requested_capacity);
+
+            ConstructElements<A>(GetAllocator(), new_data, move_values, storage_view.size);
+
+            DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data, storage_view.size);
+
+            DeallocateIfAllocated();
+            SetAllocation(std::move(allocation_tx).Release());
+            SetIsAllocated();
+        }
+
+        template<typename T, size_t N, typename A>
+        auto Storage<T, N, A>::ShrinkToFit() -> void
+        {
+            // May only be called on allocated instances!
+            ABSL_HARDENING_ASSERT(GetIsAllocated());
+
+            StorageView<A> storage_view{GetAllocatedData(), GetSize(), GetAllocatedCapacity()};
+
+            if (ABSL_PREDICT_FALSE(storage_view.size == storage_view.capacity))
+                return;
+
+            AllocationTransaction<A> allocation_tx(GetAllocator());
+
+            IteratorValueAdapter<A, MoveIterator<A>> move_values(
+                MoveIterator<A>(storage_view.data)
+            );
+
+            Pointer<A> construct_data;
+            if (storage_view.size > GetInlinedCapacity())
+            {
+                SizeType<A> requested_capacity = storage_view.size;
+                construct_data = allocation_tx.Allocate(requested_capacity);
+                if (allocation_tx.GetCapacity() >= storage_view.capacity)
+                {
+                    // Already using the smallest available heap allocation.
+                    return;
+                }
+            }
+            else
+            {
+                construct_data = GetInlinedData();
+            }
+
+            ABSL_INTERNAL_TRY
+            {
+                ConstructElements<A>(GetAllocator(), construct_data, move_values, storage_view.size);
+            }
+            ABSL_INTERNAL_CATCH_ANY
+            {
+                SetAllocation({storage_view.data, storage_view.capacity});
+                ABSL_INTERNAL_RETHROW;
+            }
+
+            DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data, storage_view.size);
+
+            MallocAdapter<A>::Deallocate(GetAllocator(), storage_view.data, storage_view.capacity);
+
+            if (allocation_tx.DidAllocate())
+            {
+                SetAllocation(std::move(allocation_tx).Release());
+            }
+            else
+            {
+                UnsetIsAllocated();
+            }
+        }
+
+        template<typename T, size_t N, typename A>
+        auto Storage<T, N, A>::Swap(Storage* other_storage_ptr) -> void
+        {
+            using std::swap;
+            ABSL_HARDENING_ASSERT(this != other_storage_ptr);
+
+            if (GetIsAllocated() && other_storage_ptr->GetIsAllocated())
+            {
+                swap(data_.allocated, other_storage_ptr->data_.allocated);
+            }
+            else if (!GetIsAllocated() && !other_storage_ptr->GetIsAllocated())
+            {
+                Storage* small_ptr = this;
+                Storage* large_ptr = other_storage_ptr;
+                if (small_ptr->GetSize() > large_ptr->GetSize())
+                    swap(small_ptr, large_ptr);
+
+                for (SizeType<A> i = 0; i < small_ptr->GetSize(); ++i)
+                {
+                    swap(small_ptr->GetInlinedData()[i], large_ptr->GetInlinedData()[i]);
+                }
+
+                IteratorValueAdapter<A, MoveIterator<A>> move_values(
+                    MoveIterator<A>(large_ptr->GetInlinedData() + small_ptr->GetSize())
+                );
+
+                ConstructElements<A>(large_ptr->GetAllocator(), small_ptr->GetInlinedData() + small_ptr->GetSize(), move_values, large_ptr->GetSize() - small_ptr->GetSize());
+
+                DestroyAdapter<A>::DestroyElements(
+                    large_ptr->GetAllocator(),
+                    large_ptr->GetInlinedData() + small_ptr->GetSize(),
+                    large_ptr->GetSize() - small_ptr->GetSize()
+                );
+            }
+            else
+            {
+                Storage* allocated_ptr = this;
+                Storage* inlined_ptr = other_storage_ptr;
+                if (!allocated_ptr->GetIsAllocated())
+                    swap(allocated_ptr, inlined_ptr);
+
+                StorageView<A> allocated_storage_view{
+                    allocated_ptr->GetAllocatedData(), allocated_ptr->GetSize(), allocated_ptr->GetAllocatedCapacity()};
+
+                IteratorValueAdapter<A, MoveIterator<A>> move_values(
+                    MoveIterator<A>(inlined_ptr->GetInlinedData())
+                );
+
+                ABSL_INTERNAL_TRY
+                {
+                    ConstructElements<A>(inlined_ptr->GetAllocator(), allocated_ptr->GetInlinedData(), move_values, inlined_ptr->GetSize());
+                }
+                ABSL_INTERNAL_CATCH_ANY
+                {
+                    allocated_ptr->SetAllocation(Allocation<A>{
+                        allocated_storage_view.data, allocated_storage_view.capacity});
+                    ABSL_INTERNAL_RETHROW;
+                }
+
+                DestroyAdapter<A>::DestroyElements(inlined_ptr->GetAllocator(), inlined_ptr->GetInlinedData(), inlined_ptr->GetSize());
+
+                inlined_ptr->SetAllocation(Allocation<A>{allocated_storage_view.data, allocated_storage_view.capacity});
+            }
+
+            swap(GetSizeAndIsAllocated(), other_storage_ptr->GetSizeAndIsAllocated());
+            swap(GetAllocator(), other_storage_ptr->GetAllocator());
+        }
 
 // End ignore "array-bounds"
 #if !defined(__clang__) && defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
 
-}  // namespace inlined_vector_internal
-ABSL_NAMESPACE_END
+    }  // namespace inlined_vector_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/layout.h b/CAPI/cpp/grpc/include/absl/container/internal/layout.h
index a59a243..c37e8b5 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/layout.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/layout.h
@@ -189,555 +189,621 @@
 #include <cxxabi.h>
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// A type wrapper that instructs `Layout` to use the specific alignment for the
-// array. `Layout<..., Aligned<T, N>, ...>` has exactly the same API
-// and behavior as `Layout<..., T, ...>` except that the first element of the
-// array of `T` is aligned to `N` (the rest of the elements follow without
-// padding).
-//
-// Requires: `N >= alignof(T)` and `N` is a power of 2.
-template <class T, size_t N>
-struct Aligned;
-
-namespace internal_layout {
-
-template <class T>
-struct NotAligned {};
-
-template <class T, size_t N>
-struct NotAligned<const Aligned<T, N>> {
-  static_assert(sizeof(T) == 0, "Aligned<T, N> cannot be const-qualified");
-};
-
-template <size_t>
-using IntToSize = size_t;
-
-template <class>
-using TypeToSize = size_t;
-
-template <class T>
-struct Type : NotAligned<T> {
-  using type = T;
-};
-
-template <class T, size_t N>
-struct Type<Aligned<T, N>> {
-  using type = T;
-};
-
-template <class T>
-struct SizeOf : NotAligned<T>, std::integral_constant<size_t, sizeof(T)> {};
-
-template <class T, size_t N>
-struct SizeOf<Aligned<T, N>> : std::integral_constant<size_t, sizeof(T)> {};
-
-// Note: workaround for https://gcc.gnu.org/PR88115
-template <class T>
-struct AlignOf : NotAligned<T> {
-  static constexpr size_t value = alignof(T);
-};
-
-template <class T, size_t N>
-struct AlignOf<Aligned<T, N>> {
-  static_assert(N % alignof(T) == 0,
-                "Custom alignment can't be lower than the type's alignment");
-  static constexpr size_t value = N;
-};
-
-// Does `Ts...` contain `T`?
-template <class T, class... Ts>
-using Contains = absl::disjunction<std::is_same<T, Ts>...>;
-
-template <class From, class To>
-using CopyConst =
-    typename std::conditional<std::is_const<From>::value, const To, To>::type;
-
-// Note: We're not qualifying this with absl:: because it doesn't compile under
-// MSVC.
-template <class T>
-using SliceType = Span<T>;
-
-// This namespace contains no types. It prevents functions defined in it from
-// being found by ADL.
-namespace adl_barrier {
-
-template <class Needle, class... Ts>
-constexpr size_t Find(Needle, Needle, Ts...) {
-  static_assert(!Contains<Needle, Ts...>(), "Duplicate element type");
-  return 0;
-}
-
-template <class Needle, class T, class... Ts>
-constexpr size_t Find(Needle, T, Ts...) {
-  return adl_barrier::Find(Needle(), Ts()...) + 1;
-}
-
-constexpr bool IsPow2(size_t n) { return !(n & (n - 1)); }
-
-// Returns `q * m` for the smallest `q` such that `q * m >= n`.
-// Requires: `m` is a power of two. It's enforced by IsLegalElementType below.
-constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
-
-constexpr size_t Min(size_t a, size_t b) { return b < a ? b : a; }
-
-constexpr size_t Max(size_t a) { return a; }
-
-template <class... Ts>
-constexpr size_t Max(size_t a, size_t b, Ts... rest) {
-  return adl_barrier::Max(b < a ? a : b, rest...);
-}
-
-template <class T>
-std::string TypeName() {
-  std::string out;
-  int status = 0;
-  char* demangled = nullptr;
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        // A type wrapper that instructs `Layout` to use the specific alignment for the
+        // array. `Layout<..., Aligned<T, N>, ...>` has exactly the same API
+        // and behavior as `Layout<..., T, ...>` except that the first element of the
+        // array of `T` is aligned to `N` (the rest of the elements follow without
+        // padding).
+        //
+        // Requires: `N >= alignof(T)` and `N` is a power of 2.
+        template<class T, size_t N>
+        struct Aligned;
+
+        namespace internal_layout
+        {
+
+            template<class T>
+            struct NotAligned
+            {
+            };
+
+            template<class T, size_t N>
+            struct NotAligned<const Aligned<T, N>>
+            {
+                static_assert(sizeof(T) == 0, "Aligned<T, N> cannot be const-qualified");
+            };
+
+            template<size_t>
+            using IntToSize = size_t;
+
+            template<class>
+            using TypeToSize = size_t;
+
+            template<class T>
+            struct Type : NotAligned<T>
+            {
+                using type = T;
+            };
+
+            template<class T, size_t N>
+            struct Type<Aligned<T, N>>
+            {
+                using type = T;
+            };
+
+            template<class T>
+            struct SizeOf : NotAligned<T>, std::integral_constant<size_t, sizeof(T)>
+            {
+            };
+
+            template<class T, size_t N>
+            struct SizeOf<Aligned<T, N>> : std::integral_constant<size_t, sizeof(T)>
+            {
+            };
+
+            // Note: workaround for https://gcc.gnu.org/PR88115
+            template<class T>
+            struct AlignOf : NotAligned<T>
+            {
+                static constexpr size_t value = alignof(T);
+            };
+
+            template<class T, size_t N>
+            struct AlignOf<Aligned<T, N>>
+            {
+                static_assert(N % alignof(T) == 0, "Custom alignment can't be lower than the type's alignment");
+                static constexpr size_t value = N;
+            };
+
+            // Does `Ts...` contain `T`?
+            template<class T, class... Ts>
+            using Contains = absl::disjunction<std::is_same<T, Ts>...>;
+
+            template<class From, class To>
+            using CopyConst =
+                typename std::conditional<std::is_const<From>::value, const To, To>::type;
+
+            // Note: We're not qualifying this with absl:: because it doesn't compile under
+            // MSVC.
+            template<class T>
+            using SliceType = Span<T>;
+
+            // This namespace contains no types. It prevents functions defined in it from
+            // being found by ADL.
+            namespace adl_barrier
+            {
+
+                template<class Needle, class... Ts>
+                constexpr size_t Find(Needle, Needle, Ts...)
+                {
+                    static_assert(!Contains<Needle, Ts...>(), "Duplicate element type");
+                    return 0;
+                }
+
+                template<class Needle, class T, class... Ts>
+                constexpr size_t Find(Needle, T, Ts...)
+                {
+                    return adl_barrier::Find(Needle(), Ts()...) + 1;
+                }
+
+                constexpr bool IsPow2(size_t n)
+                {
+                    return !(n & (n - 1));
+                }
+
+                // Returns `q * m` for the smallest `q` such that `q * m >= n`.
+                // Requires: `m` is a power of two. It's enforced by IsLegalElementType below.
+                constexpr size_t Align(size_t n, size_t m)
+                {
+                    return (n + m - 1) & ~(m - 1);
+                }
+
+                constexpr size_t Min(size_t a, size_t b)
+                {
+                    return b < a ? b : a;
+                }
+
+                constexpr size_t Max(size_t a)
+                {
+                    return a;
+                }
+
+                template<class... Ts>
+                constexpr size_t Max(size_t a, size_t b, Ts... rest)
+                {
+                    return adl_barrier::Max(b < a ? a : b, rest...);
+                }
+
+                template<class T>
+                std::string TypeName()
+                {
+                    std::string out;
+                    int status = 0;
+                    char* demangled = nullptr;
 #ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
-  demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
+                    demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
 #endif
-  if (status == 0 && demangled != nullptr) {  // Demangling succeeded.
-    absl::StrAppend(&out, "<", demangled, ">");
-    free(demangled);
-  } else {
+                    if (status == 0 && demangled != nullptr)
+                    {  // Demangling succeeded.
+                        absl::StrAppend(&out, "<", demangled, ">");
+                        free(demangled);
+                    }
+                    else
+                    {
 #if defined(__GXX_RTTI) || defined(_CPPRTTI)
-    absl::StrAppend(&out, "<", typeid(T).name(), ">");
+                        absl::StrAppend(&out, "<", typeid(T).name(), ">");
 #endif
-  }
-  return out;
-}
-
-}  // namespace adl_barrier
-
-template <bool C>
-using EnableIf = typename std::enable_if<C, int>::type;
-
-// Can `T` be a template argument of `Layout`?
-template <class T>
-using IsLegalElementType = std::integral_constant<
-    bool, !std::is_reference<T>::value && !std::is_volatile<T>::value &&
-              !std::is_reference<typename Type<T>::type>::value &&
-              !std::is_volatile<typename Type<T>::type>::value &&
-              adl_barrier::IsPow2(AlignOf<T>::value)>;
-
-template <class Elements, class SizeSeq, class OffsetSeq>
-class LayoutImpl;
-
-// Public base class of `Layout` and the result type of `Layout::Partial()`.
-//
-// `Elements...` contains all template arguments of `Layout` that created this
-// instance.
-//
-// `SizeSeq...` is `[0, NumSizes)` where `NumSizes` is the number of arguments
-// passed to `Layout::Partial()` or `Layout::Layout()`.
-//
-// `OffsetSeq...` is `[0, NumOffsets)` where `NumOffsets` is
-// `Min(sizeof...(Elements), NumSizes + 1)` (the number of arrays for which we
-// can compute offsets).
-template <class... Elements, size_t... SizeSeq, size_t... OffsetSeq>
-class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
-                 absl::index_sequence<OffsetSeq...>> {
- private:
-  static_assert(sizeof...(Elements) > 0, "At least one field is required");
-  static_assert(absl::conjunction<IsLegalElementType<Elements>...>::value,
-                "Invalid element type (see IsLegalElementType)");
-
-  enum {
-    NumTypes = sizeof...(Elements),
-    NumSizes = sizeof...(SizeSeq),
-    NumOffsets = sizeof...(OffsetSeq),
-  };
-
-  // These are guaranteed by `Layout`.
-  static_assert(NumOffsets == adl_barrier::Min(NumTypes, NumSizes + 1),
-                "Internal error");
-  static_assert(NumTypes > 0, "Internal error");
-
-  // Returns the index of `T` in `Elements...`. Results in a compilation error
-  // if `Elements...` doesn't contain exactly one instance of `T`.
-  template <class T>
-  static constexpr size_t ElementIndex() {
-    static_assert(Contains<Type<T>, Type<typename Type<Elements>::type>...>(),
-                  "Type not found");
-    return adl_barrier::Find(Type<T>(),
-                             Type<typename Type<Elements>::type>()...);
-  }
-
-  template <size_t N>
-  using ElementAlignment =
-      AlignOf<typename std::tuple_element<N, std::tuple<Elements...>>::type>;
-
- public:
-  // Element types of all arrays packed in a tuple.
-  using ElementTypes = std::tuple<typename Type<Elements>::type...>;
-
-  // Element type of the Nth array.
-  template <size_t N>
-  using ElementType = typename std::tuple_element<N, ElementTypes>::type;
-
-  constexpr explicit LayoutImpl(IntToSize<SizeSeq>... sizes)
-      : size_{sizes...} {}
-
-  // Alignment of the layout, equal to the strictest alignment of all elements.
-  // All pointers passed to the methods of layout must be aligned to this value.
-  static constexpr size_t Alignment() {
-    return adl_barrier::Max(AlignOf<Elements>::value...);
-  }
-
-  // Offset in bytes of the Nth array.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   assert(x.Offset<0>() == 0);   // The ints starts from 0.
-  //   assert(x.Offset<1>() == 16);  // The doubles starts from 16.
-  //
-  // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
-  template <size_t N, EnableIf<N == 0> = 0>
-  constexpr size_t Offset() const {
-    return 0;
-  }
-
-  template <size_t N, EnableIf<N != 0> = 0>
-  constexpr size_t Offset() const {
-    static_assert(N < NumOffsets, "Index out of bounds");
-    return adl_barrier::Align(
-        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
-        ElementAlignment<N>::value);
-  }
-
-  // Offset in bytes of the array with the specified element type. There must
-  // be exactly one such array and its zero-based index must be at most
-  // `NumSizes`.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   assert(x.Offset<int>() == 0);      // The ints starts from 0.
-  //   assert(x.Offset<double>() == 16);  // The doubles starts from 16.
-  template <class T>
-  constexpr size_t Offset() const {
-    return Offset<ElementIndex<T>()>();
-  }
-
-  // Offsets in bytes of all arrays for which the offsets are known.
-  constexpr std::array<size_t, NumOffsets> Offsets() const {
-    return {{Offset<OffsetSeq>()...}};
-  }
-
-  // The number of elements in the Nth array. This is the Nth argument of
-  // `Layout::Partial()` or `Layout::Layout()` (zero-based).
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   assert(x.Size<0>() == 3);
-  //   assert(x.Size<1>() == 4);
-  //
-  // Requires: `N < NumSizes`.
-  template <size_t N>
-  constexpr size_t Size() const {
-    static_assert(N < NumSizes, "Index out of bounds");
-    return size_[N];
-  }
-
-  // The number of elements in the array with the specified element type.
-  // There must be exactly one such array and its zero-based index must be
-  // at most `NumSizes`.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   assert(x.Size<int>() == 3);
-  //   assert(x.Size<double>() == 4);
-  template <class T>
-  constexpr size_t Size() const {
-    return Size<ElementIndex<T>()>();
-  }
-
-  // The number of elements of all arrays for which they are known.
-  constexpr std::array<size_t, NumSizes> Sizes() const {
-    return {{Size<SizeSeq>()...}};
-  }
-
-  // Pointer to the beginning of the Nth array.
-  //
-  // `Char` must be `[const] [signed|unsigned] char`.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   unsigned char* p = new unsigned char[x.AllocSize()];
-  //   int* ints = x.Pointer<0>(p);
-  //   double* doubles = x.Pointer<1>(p);
-  //
-  // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
-  // Requires: `p` is aligned to `Alignment()`.
-  template <size_t N, class Char>
-  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
-    using C = typename std::remove_const<Char>::type;
-    static_assert(
-        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
-            std::is_same<C, signed char>(),
-        "The argument must be a pointer to [const] [signed|unsigned] char");
-    constexpr size_t alignment = Alignment();
-    (void)alignment;
-    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
-    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
-  }
-
-  // Pointer to the beginning of the array with the specified element type.
-  // There must be exactly one such array and its zero-based index must be at
-  // most `NumSizes`.
-  //
-  // `Char` must be `[const] [signed|unsigned] char`.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   unsigned char* p = new unsigned char[x.AllocSize()];
-  //   int* ints = x.Pointer<int>(p);
-  //   double* doubles = x.Pointer<double>(p);
-  //
-  // Requires: `p` is aligned to `Alignment()`.
-  template <class T, class Char>
-  CopyConst<Char, T>* Pointer(Char* p) const {
-    return Pointer<ElementIndex<T>()>(p);
-  }
-
-  // Pointers to all arrays for which pointers are known.
-  //
-  // `Char` must be `[const] [signed|unsigned] char`.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   unsigned char* p = new unsigned char[x.AllocSize()];
-  //
-  //   int* ints;
-  //   double* doubles;
-  //   std::tie(ints, doubles) = x.Pointers(p);
-  //
-  // Requires: `p` is aligned to `Alignment()`.
-  //
-  // Note: We're not using ElementType alias here because it does not compile
-  // under MSVC.
-  template <class Char>
-  std::tuple<CopyConst<
-      Char, typename std::tuple_element<OffsetSeq, ElementTypes>::type>*...>
-  Pointers(Char* p) const {
-    return std::tuple<CopyConst<Char, ElementType<OffsetSeq>>*...>(
-        Pointer<OffsetSeq>(p)...);
-  }
-
-  // The Nth array.
-  //
-  // `Char` must be `[const] [signed|unsigned] char`.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   unsigned char* p = new unsigned char[x.AllocSize()];
-  //   Span<int> ints = x.Slice<0>(p);
-  //   Span<double> doubles = x.Slice<1>(p);
-  //
-  // Requires: `N < NumSizes`.
-  // Requires: `p` is aligned to `Alignment()`.
-  template <size_t N, class Char>
-  SliceType<CopyConst<Char, ElementType<N>>> Slice(Char* p) const {
-    return SliceType<CopyConst<Char, ElementType<N>>>(Pointer<N>(p), Size<N>());
-  }
-
-  // The array with the specified element type. There must be exactly one
-  // such array and its zero-based index must be less than `NumSizes`.
-  //
-  // `Char` must be `[const] [signed|unsigned] char`.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   unsigned char* p = new unsigned char[x.AllocSize()];
-  //   Span<int> ints = x.Slice<int>(p);
-  //   Span<double> doubles = x.Slice<double>(p);
-  //
-  // Requires: `p` is aligned to `Alignment()`.
-  template <class T, class Char>
-  SliceType<CopyConst<Char, T>> Slice(Char* p) const {
-    return Slice<ElementIndex<T>()>(p);
-  }
-
-  // All arrays with known sizes.
-  //
-  // `Char` must be `[const] [signed|unsigned] char`.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   unsigned char* p = new unsigned char[x.AllocSize()];
-  //
-  //   Span<int> ints;
-  //   Span<double> doubles;
-  //   std::tie(ints, doubles) = x.Slices(p);
-  //
-  // Requires: `p` is aligned to `Alignment()`.
-  //
-  // Note: We're not using ElementType alias here because it does not compile
-  // under MSVC.
-  template <class Char>
-  std::tuple<SliceType<CopyConst<
-      Char, typename std::tuple_element<SizeSeq, ElementTypes>::type>>...>
-  Slices(Char* p) const {
-    // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63875 (fixed
-    // in 6.1).
-    (void)p;
-    return std::tuple<SliceType<CopyConst<Char, ElementType<SizeSeq>>>...>(
-        Slice<SizeSeq>(p)...);
-  }
-
-  // The size of the allocation that fits all arrays.
-  //
-  //   // int[3], 4 bytes of padding, double[4].
-  //   Layout<int, double> x(3, 4);
-  //   unsigned char* p = new unsigned char[x.AllocSize()];  // 48 bytes
-  //
-  // Requires: `NumSizes == sizeof...(Ts)`.
-  constexpr size_t AllocSize() const {
-    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
-    return Offset<NumTypes - 1>() +
-        SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1];
-  }
-
-  // If built with --config=asan, poisons padding bytes (if any) in the
-  // allocation. The pointer must point to a memory block at least
-  // `AllocSize()` bytes in length.
-  //
-  // `Char` must be `[const] [signed|unsigned] char`.
-  //
-  // Requires: `p` is aligned to `Alignment()`.
-  template <class Char, size_t N = NumOffsets - 1, EnableIf<N == 0> = 0>
-  void PoisonPadding(const Char* p) const {
-    Pointer<0>(p);  // verify the requirements on `Char` and `p`
-  }
-
-  template <class Char, size_t N = NumOffsets - 1, EnableIf<N != 0> = 0>
-  void PoisonPadding(const Char* p) const {
-    static_assert(N < NumOffsets, "Index out of bounds");
-    (void)p;
+                    }
+                    return out;
+                }
+
+            }  // namespace adl_barrier
+
+            template<bool C>
+            using EnableIf = typename std::enable_if<C, int>::type;
+
+            // Can `T` be a template argument of `Layout`?
+            template<class T>
+            using IsLegalElementType = std::integral_constant<
+                bool,
+                !std::is_reference<T>::value && !std::is_volatile<T>::value &&
+                    !std::is_reference<typename Type<T>::type>::value &&
+                    !std::is_volatile<typename Type<T>::type>::value &&
+                    adl_barrier::IsPow2(AlignOf<T>::value)>;
+
+            template<class Elements, class SizeSeq, class OffsetSeq>
+            class LayoutImpl;
+
+            // Public base class of `Layout` and the result type of `Layout::Partial()`.
+            //
+            // `Elements...` contains all template arguments of `Layout` that created this
+            // instance.
+            //
+            // `SizeSeq...` is `[0, NumSizes)` where `NumSizes` is the number of arguments
+            // passed to `Layout::Partial()` or `Layout::Layout()`.
+            //
+            // `OffsetSeq...` is `[0, NumOffsets)` where `NumOffsets` is
+            // `Min(sizeof...(Elements), NumSizes + 1)` (the number of arrays for which we
+            // can compute offsets).
+            template<class... Elements, size_t... SizeSeq, size_t... OffsetSeq>
+            class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>, absl::index_sequence<OffsetSeq...>>
+            {
+            private:
+                static_assert(sizeof...(Elements) > 0, "At least one field is required");
+                static_assert(absl::conjunction<IsLegalElementType<Elements>...>::value, "Invalid element type (see IsLegalElementType)");
+
+                enum
+                {
+                    NumTypes = sizeof...(Elements),
+                    NumSizes = sizeof...(SizeSeq),
+                    NumOffsets = sizeof...(OffsetSeq),
+                };
+
+                // These are guaranteed by `Layout`.
+                static_assert(NumOffsets == adl_barrier::Min(NumTypes, NumSizes + 1), "Internal error");
+                static_assert(NumTypes > 0, "Internal error");
+
+                // Returns the index of `T` in `Elements...`. Results in a compilation error
+                // if `Elements...` doesn't contain exactly one instance of `T`.
+                template<class T>
+                static constexpr size_t ElementIndex()
+                {
+                    static_assert(Contains<Type<T>, Type<typename Type<Elements>::type>...>(), "Type not found");
+                    return adl_barrier::Find(Type<T>(), Type<typename Type<Elements>::type>()...);
+                }
+
+                template<size_t N>
+                using ElementAlignment =
+                    AlignOf<typename std::tuple_element<N, std::tuple<Elements...>>::type>;
+
+            public:
+                // Element types of all arrays packed in a tuple.
+                using ElementTypes = std::tuple<typename Type<Elements>::type...>;
+
+                // Element type of the Nth array.
+                template<size_t N>
+                using ElementType = typename std::tuple_element<N, ElementTypes>::type;
+
+                constexpr explicit LayoutImpl(IntToSize<SizeSeq>... sizes) :
+                    size_{sizes...}
+                {
+                }
+
+                // Alignment of the layout, equal to the strictest alignment of all elements.
+                // All pointers passed to the methods of layout must be aligned to this value.
+                static constexpr size_t Alignment()
+                {
+                    return adl_barrier::Max(AlignOf<Elements>::value...);
+                }
+
+                // Offset in bytes of the Nth array.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   assert(x.Offset<0>() == 0);   // The ints starts from 0.
+                //   assert(x.Offset<1>() == 16);  // The doubles starts from 16.
+                //
+                // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
+                template<size_t N, EnableIf<N == 0> = 0>
+                constexpr size_t Offset() const
+                {
+                    return 0;
+                }
+
+                template<size_t N, EnableIf<N != 0> = 0>
+                constexpr size_t Offset() const
+                {
+                    static_assert(N < NumOffsets, "Index out of bounds");
+                    return adl_barrier::Align(
+                        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
+                        ElementAlignment<N>::value
+                    );
+                }
+
+                // Offset in bytes of the array with the specified element type. There must
+                // be exactly one such array and its zero-based index must be at most
+                // `NumSizes`.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   assert(x.Offset<int>() == 0);      // The ints starts from 0.
+                //   assert(x.Offset<double>() == 16);  // The doubles starts from 16.
+                template<class T>
+                constexpr size_t Offset() const
+                {
+                    return Offset<ElementIndex<T>()>();
+                }
+
+                // Offsets in bytes of all arrays for which the offsets are known.
+                constexpr std::array<size_t, NumOffsets> Offsets() const
+                {
+                    return {{Offset<OffsetSeq>()...}};
+                }
+
+                // The number of elements in the Nth array. This is the Nth argument of
+                // `Layout::Partial()` or `Layout::Layout()` (zero-based).
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   assert(x.Size<0>() == 3);
+                //   assert(x.Size<1>() == 4);
+                //
+                // Requires: `N < NumSizes`.
+                template<size_t N>
+                constexpr size_t Size() const
+                {
+                    static_assert(N < NumSizes, "Index out of bounds");
+                    return size_[N];
+                }
+
+                // The number of elements in the array with the specified element type.
+                // There must be exactly one such array and its zero-based index must be
+                // at most `NumSizes`.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   assert(x.Size<int>() == 3);
+                //   assert(x.Size<double>() == 4);
+                template<class T>
+                constexpr size_t Size() const
+                {
+                    return Size<ElementIndex<T>()>();
+                }
+
+                // The number of elements of all arrays for which they are known.
+                constexpr std::array<size_t, NumSizes> Sizes() const
+                {
+                    return {{Size<SizeSeq>()...}};
+                }
+
+                // Pointer to the beginning of the Nth array.
+                //
+                // `Char` must be `[const] [signed|unsigned] char`.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   unsigned char* p = new unsigned char[x.AllocSize()];
+                //   int* ints = x.Pointer<0>(p);
+                //   double* doubles = x.Pointer<1>(p);
+                //
+                // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
+                // Requires: `p` is aligned to `Alignment()`.
+                template<size_t N, class Char>
+                CopyConst<Char, ElementType<N>>* Pointer(Char* p) const
+                {
+                    using C = typename std::remove_const<Char>::type;
+                    static_assert(
+                        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
+                            std::is_same<C, signed char>(),
+                        "The argument must be a pointer to [const] [signed|unsigned] char"
+                    );
+                    constexpr size_t alignment = Alignment();
+                    (void)alignment;
+                    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
+                    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
+                }
+
+                // Pointer to the beginning of the array with the specified element type.
+                // There must be exactly one such array and its zero-based index must be at
+                // most `NumSizes`.
+                //
+                // `Char` must be `[const] [signed|unsigned] char`.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   unsigned char* p = new unsigned char[x.AllocSize()];
+                //   int* ints = x.Pointer<int>(p);
+                //   double* doubles = x.Pointer<double>(p);
+                //
+                // Requires: `p` is aligned to `Alignment()`.
+                template<class T, class Char>
+                CopyConst<Char, T>* Pointer(Char* p) const
+                {
+                    return Pointer<ElementIndex<T>()>(p);
+                }
+
+                // Pointers to all arrays for which pointers are known.
+                //
+                // `Char` must be `[const] [signed|unsigned] char`.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   unsigned char* p = new unsigned char[x.AllocSize()];
+                //
+                //   int* ints;
+                //   double* doubles;
+                //   std::tie(ints, doubles) = x.Pointers(p);
+                //
+                // Requires: `p` is aligned to `Alignment()`.
+                //
+                // Note: We're not using ElementType alias here because it does not compile
+                // under MSVC.
+                template<class Char>
+                std::tuple<CopyConst<
+                    Char,
+                    typename std::tuple_element<OffsetSeq, ElementTypes>::type>*...>
+                    Pointers(Char* p) const
+                {
+                    return std::tuple<CopyConst<Char, ElementType<OffsetSeq>>*...>(
+                        Pointer<OffsetSeq>(p)...
+                    );
+                }
+
+                // The Nth array.
+                //
+                // `Char` must be `[const] [signed|unsigned] char`.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   unsigned char* p = new unsigned char[x.AllocSize()];
+                //   Span<int> ints = x.Slice<0>(p);
+                //   Span<double> doubles = x.Slice<1>(p);
+                //
+                // Requires: `N < NumSizes`.
+                // Requires: `p` is aligned to `Alignment()`.
+                template<size_t N, class Char>
+                SliceType<CopyConst<Char, ElementType<N>>> Slice(Char* p) const
+                {
+                    return SliceType<CopyConst<Char, ElementType<N>>>(Pointer<N>(p), Size<N>());
+                }
+
+                // The array with the specified element type. There must be exactly one
+                // such array and its zero-based index must be less than `NumSizes`.
+                //
+                // `Char` must be `[const] [signed|unsigned] char`.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   unsigned char* p = new unsigned char[x.AllocSize()];
+                //   Span<int> ints = x.Slice<int>(p);
+                //   Span<double> doubles = x.Slice<double>(p);
+                //
+                // Requires: `p` is aligned to `Alignment()`.
+                template<class T, class Char>
+                SliceType<CopyConst<Char, T>> Slice(Char* p) const
+                {
+                    return Slice<ElementIndex<T>()>(p);
+                }
+
+                // All arrays with known sizes.
+                //
+                // `Char` must be `[const] [signed|unsigned] char`.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   unsigned char* p = new unsigned char[x.AllocSize()];
+                //
+                //   Span<int> ints;
+                //   Span<double> doubles;
+                //   std::tie(ints, doubles) = x.Slices(p);
+                //
+                // Requires: `p` is aligned to `Alignment()`.
+                //
+                // Note: We're not using ElementType alias here because it does not compile
+                // under MSVC.
+                template<class Char>
+                std::tuple<SliceType<CopyConst<
+                    Char,
+                    typename std::tuple_element<SizeSeq, ElementTypes>::type>>...>
+                    Slices(Char* p) const
+                {
+                    // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63875 (fixed
+                    // in 6.1).
+                    (void)p;
+                    return std::tuple<SliceType<CopyConst<Char, ElementType<SizeSeq>>>...>(
+                        Slice<SizeSeq>(p)...
+                    );
+                }
+
+                // The size of the allocation that fits all arrays.
+                //
+                //   // int[3], 4 bytes of padding, double[4].
+                //   Layout<int, double> x(3, 4);
+                //   unsigned char* p = new unsigned char[x.AllocSize()];  // 48 bytes
+                //
+                // Requires: `NumSizes == sizeof...(Ts)`.
+                constexpr size_t AllocSize() const
+                {
+                    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
+                    return Offset<NumTypes - 1>() +
+                           SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1];
+                }
+
+                // If built with --config=asan, poisons padding bytes (if any) in the
+                // allocation. The pointer must point to a memory block at least
+                // `AllocSize()` bytes in length.
+                //
+                // `Char` must be `[const] [signed|unsigned] char`.
+                //
+                // Requires: `p` is aligned to `Alignment()`.
+                template<class Char, size_t N = NumOffsets - 1, EnableIf<N == 0> = 0>
+                void PoisonPadding(const Char* p) const
+                {
+                    Pointer<0>(p);  // verify the requirements on `Char` and `p`
+                }
+
+                template<class Char, size_t N = NumOffsets - 1, EnableIf<N != 0> = 0>
+                void PoisonPadding(const Char* p) const
+                {
+                    static_assert(N < NumOffsets, "Index out of bounds");
+                    (void)p;
 #ifdef ABSL_HAVE_ADDRESS_SANITIZER
-    PoisonPadding<Char, N - 1>(p);
-    // The `if` is an optimization. It doesn't affect the observable behaviour.
-    if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value) {
-      size_t start =
-          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1];
-      ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start);
-    }
+                    PoisonPadding<Char, N - 1>(p);
+                    // The `if` is an optimization. It doesn't affect the observable behaviour.
+                    if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value)
+                    {
+                        size_t start =
+                            Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1];
+                        ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start);
+                    }
 #endif
-  }
-
-  // Human-readable description of the memory layout. Useful for debugging.
-  // Slow.
-  //
-  //   // char[5], 3 bytes of padding, int[3], 4 bytes of padding, followed
-  //   // by an unknown number of doubles.
-  //   auto x = Layout<char, int, double>::Partial(5, 3);
-  //   assert(x.DebugString() ==
-  //          "@0<char>(1)[5]; @8<int>(4)[3]; @24<double>(8)");
-  //
-  // Each field is in the following format: @offset<type>(sizeof)[size] (<type>
-  // may be missing depending on the target platform). For example,
-  // @8<int>(4)[3] means that at offset 8 we have an array of ints, where each
-  // int is 4 bytes, and we have 3 of those ints. The size of the last field may
-  // be missing (as in the example above). Only fields with known offsets are
-  // described. Type names may differ across platforms: one compiler might
-  // produce "unsigned*" where another produces "unsigned int *".
-  std::string DebugString() const {
-    const auto offsets = Offsets();
-    const size_t sizes[] = {SizeOf<ElementType<OffsetSeq>>::value...};
-    const std::string types[] = {
-        adl_barrier::TypeName<ElementType<OffsetSeq>>()...};
-    std::string res = absl::StrCat("@0", types[0], "(", sizes[0], ")");
-    for (size_t i = 0; i != NumOffsets - 1; ++i) {
-      absl::StrAppend(&res, "[", size_[i], "]; @", offsets[i + 1], types[i + 1],
-                      "(", sizes[i + 1], ")");
-    }
-    // NumSizes is a constant that may be zero. Some compilers cannot see that
-    // inside the if statement "size_[NumSizes - 1]" must be valid.
-    int last = static_cast<int>(NumSizes) - 1;
-    if (NumTypes == NumSizes && last >= 0) {
-      absl::StrAppend(&res, "[", size_[last], "]");
-    }
-    return res;
-  }
-
- private:
-  // Arguments of `Layout::Partial()` or `Layout::Layout()`.
-  size_t size_[NumSizes > 0 ? NumSizes : 1];
-};
-
-template <size_t NumSizes, class... Ts>
-using LayoutType = LayoutImpl<
-    std::tuple<Ts...>, absl::make_index_sequence<NumSizes>,
-    absl::make_index_sequence<adl_barrier::Min(sizeof...(Ts), NumSizes + 1)>>;
-
-}  // namespace internal_layout
-
-// Descriptor of arrays of various types and sizes laid out in memory one after
-// another. See the top of the file for documentation.
-//
-// Check out the public API of internal_layout::LayoutImpl above. The type is
-// internal to the library but its methods are public, and they are inherited
-// by `Layout`.
-template <class... Ts>
-class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> {
- public:
-  static_assert(sizeof...(Ts) > 0, "At least one field is required");
-  static_assert(
-      absl::conjunction<internal_layout::IsLegalElementType<Ts>...>::value,
-      "Invalid element type (see IsLegalElementType)");
-
-  // The result type of `Partial()` with `NumSizes` arguments.
-  template <size_t NumSizes>
-  using PartialType = internal_layout::LayoutType<NumSizes, Ts...>;
-
-  // `Layout` knows the element types of the arrays we want to lay out in
-  // memory but not the number of elements in each array.
-  // `Partial(size1, ..., sizeN)` allows us to specify the latter. The
-  // resulting immutable object can be used to obtain pointers to the
-  // individual arrays.
-  //
-  // It's allowed to pass fewer array sizes than the number of arrays. E.g.,
-  // if all you need is to the offset of the second array, you only need to
-  // pass one argument -- the number of elements in the first array.
-  //
-  //   // int[3] followed by 4 bytes of padding and an unknown number of
-  //   // doubles.
-  //   auto x = Layout<int, double>::Partial(3);
-  //   // doubles start at byte 16.
-  //   assert(x.Offset<1>() == 16);
-  //
-  // If you know the number of elements in all arrays, you can still call
-  // `Partial()` but it's more convenient to use the constructor of `Layout`.
-  //
-  //   Layout<int, double> x(3, 5);
-  //
-  // Note: The sizes of the arrays must be specified in number of elements,
-  // not in bytes.
-  //
-  // Requires: `sizeof...(Sizes) <= sizeof...(Ts)`.
-  // Requires: all arguments are convertible to `size_t`.
-  template <class... Sizes>
-  static constexpr PartialType<sizeof...(Sizes)> Partial(Sizes&&... sizes) {
-    static_assert(sizeof...(Sizes) <= sizeof...(Ts), "");
-    return PartialType<sizeof...(Sizes)>(absl::forward<Sizes>(sizes)...);
-  }
-
-  // Creates a layout with the sizes of all arrays specified. If you know
-  // only the sizes of the first N arrays (where N can be zero), you can use
-  // `Partial()` defined above. The constructor is essentially equivalent to
-  // calling `Partial()` and passing in all array sizes; the constructor is
-  // provided as a convenient abbreviation.
-  //
-  // Note: The sizes of the arrays must be specified in number of elements,
-  // not in bytes.
-  constexpr explicit Layout(internal_layout::TypeToSize<Ts>... sizes)
-      : internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+                }
+
+                // Human-readable description of the memory layout. Useful for debugging.
+                // Slow.
+                //
+                //   // char[5], 3 bytes of padding, int[3], 4 bytes of padding, followed
+                //   // by an unknown number of doubles.
+                //   auto x = Layout<char, int, double>::Partial(5, 3);
+                //   assert(x.DebugString() ==
+                //          "@0<char>(1)[5]; @8<int>(4)[3]; @24<double>(8)");
+                //
+                // Each field is in the following format: @offset<type>(sizeof)[size] (<type>
+                // may be missing depending on the target platform). For example,
+                // @8<int>(4)[3] means that at offset 8 we have an array of ints, where each
+                // int is 4 bytes, and we have 3 of those ints. The size of the last field may
+                // be missing (as in the example above). Only fields with known offsets are
+                // described. Type names may differ across platforms: one compiler might
+                // produce "unsigned*" where another produces "unsigned int *".
+                std::string DebugString() const
+                {
+                    const auto offsets = Offsets();
+                    const size_t sizes[] = {SizeOf<ElementType<OffsetSeq>>::value...};
+                    const std::string types[] = {
+                        adl_barrier::TypeName<ElementType<OffsetSeq>>()...};
+                    std::string res = absl::StrCat("@0", types[0], "(", sizes[0], ")");
+                    for (size_t i = 0; i != NumOffsets - 1; ++i)
+                    {
+                        absl::StrAppend(&res, "[", size_[i], "]; @", offsets[i + 1], types[i + 1], "(", sizes[i + 1], ")");
+                    }
+                    // NumSizes is a constant that may be zero. Some compilers cannot see that
+                    // inside the if statement "size_[NumSizes - 1]" must be valid.
+                    int last = static_cast<int>(NumSizes) - 1;
+                    if (NumTypes == NumSizes && last >= 0)
+                    {
+                        absl::StrAppend(&res, "[", size_[last], "]");
+                    }
+                    return res;
+                }
+
+            private:
+                // Arguments of `Layout::Partial()` or `Layout::Layout()`.
+                size_t size_[NumSizes > 0 ? NumSizes : 1];
+            };
+
+            template<size_t NumSizes, class... Ts>
+            using LayoutType = LayoutImpl<
+                std::tuple<Ts...>,
+                absl::make_index_sequence<NumSizes>,
+                absl::make_index_sequence<adl_barrier::Min(sizeof...(Ts), NumSizes + 1)>>;
+
+        }  // namespace internal_layout
+
+        // Descriptor of arrays of various types and sizes laid out in memory one after
+        // another. See the top of the file for documentation.
+        //
+        // Check out the public API of internal_layout::LayoutImpl above. The type is
+        // internal to the library but its methods are public, and they are inherited
+        // by `Layout`.
+        template<class... Ts>
+        class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...>
+        {
+        public:
+            static_assert(sizeof...(Ts) > 0, "At least one field is required");
+            static_assert(
+                absl::conjunction<internal_layout::IsLegalElementType<Ts>...>::value,
+                "Invalid element type (see IsLegalElementType)"
+            );
+
+            // The result type of `Partial()` with `NumSizes` arguments.
+            template<size_t NumSizes>
+            using PartialType = internal_layout::LayoutType<NumSizes, Ts...>;
+
+            // `Layout` knows the element types of the arrays we want to lay out in
+            // memory but not the number of elements in each array.
+            // `Partial(size1, ..., sizeN)` allows us to specify the latter. The
+            // resulting immutable object can be used to obtain pointers to the
+            // individual arrays.
+            //
+            // It's allowed to pass fewer array sizes than the number of arrays. E.g.,
+            // if all you need is to the offset of the second array, you only need to
+            // pass one argument -- the number of elements in the first array.
+            //
+            //   // int[3] followed by 4 bytes of padding and an unknown number of
+            //   // doubles.
+            //   auto x = Layout<int, double>::Partial(3);
+            //   // doubles start at byte 16.
+            //   assert(x.Offset<1>() == 16);
+            //
+            // If you know the number of elements in all arrays, you can still call
+            // `Partial()` but it's more convenient to use the constructor of `Layout`.
+            //
+            //   Layout<int, double> x(3, 5);
+            //
+            // Note: The sizes of the arrays must be specified in number of elements,
+            // not in bytes.
+            //
+            // Requires: `sizeof...(Sizes) <= sizeof...(Ts)`.
+            // Requires: all arguments are convertible to `size_t`.
+            template<class... Sizes>
+            static constexpr PartialType<sizeof...(Sizes)> Partial(Sizes&&... sizes)
+            {
+                static_assert(sizeof...(Sizes) <= sizeof...(Ts), "");
+                return PartialType<sizeof...(Sizes)>(absl::forward<Sizes>(sizes)...);
+            }
+
+            // Creates a layout with the sizes of all arrays specified. If you know
+            // only the sizes of the first N arrays (where N can be zero), you can use
+            // `Partial()` defined above. The constructor is essentially equivalent to
+            // calling `Partial()` and passing in all array sizes; the constructor is
+            // provided as a convenient abbreviation.
+            //
+            // Note: The sizes of the arrays must be specified in number of elements,
+            // not in bytes.
+            constexpr explicit Layout(internal_layout::TypeToSize<Ts>... sizes) :
+                internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...)
+            {
+            }
+        };
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_LAYOUT_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/node_slot_policy.h b/CAPI/cpp/grpc/include/absl/container/internal/node_slot_policy.h
index baba574..4ab459f 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/node_slot_policy.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/node_slot_policy.h
@@ -41,52 +41,65 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
 
-template <class Reference, class Policy>
-struct node_slot_policy {
-  static_assert(std::is_lvalue_reference<Reference>::value, "");
+        template<class Reference, class Policy>
+        struct node_slot_policy
+        {
+            static_assert(std::is_lvalue_reference<Reference>::value, "");
 
-  using slot_type = typename std::remove_cv<
-      typename std::remove_reference<Reference>::type>::type*;
+            using slot_type = typename std::remove_cv<
+                typename std::remove_reference<Reference>::type>::type*;
 
-  template <class Alloc, class... Args>
-  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
-    *slot = Policy::new_element(alloc, std::forward<Args>(args)...);
-  }
+            template<class Alloc, class... Args>
+            static void construct(Alloc* alloc, slot_type* slot, Args&&... args)
+            {
+                *slot = Policy::new_element(alloc, std::forward<Args>(args)...);
+            }
 
-  template <class Alloc>
-  static void destroy(Alloc* alloc, slot_type* slot) {
-    Policy::delete_element(alloc, *slot);
-  }
+            template<class Alloc>
+            static void destroy(Alloc* alloc, slot_type* slot)
+            {
+                Policy::delete_element(alloc, *slot);
+            }
 
-  template <class Alloc>
-  static void transfer(Alloc*, slot_type* new_slot, slot_type* old_slot) {
-    *new_slot = *old_slot;
-  }
+            template<class Alloc>
+            static void transfer(Alloc*, slot_type* new_slot, slot_type* old_slot)
+            {
+                *new_slot = *old_slot;
+            }
 
-  static size_t space_used(const slot_type* slot) {
-    if (slot == nullptr) return Policy::element_space_used(nullptr);
-    return Policy::element_space_used(*slot);
-  }
+            static size_t space_used(const slot_type* slot)
+            {
+                if (slot == nullptr)
+                    return Policy::element_space_used(nullptr);
+                return Policy::element_space_used(*slot);
+            }
 
-  static Reference element(slot_type* slot) { return **slot; }
+            static Reference element(slot_type* slot)
+            {
+                return **slot;
+            }
 
-  template <class T, class P = Policy>
-  static auto value(T* elem) -> decltype(P::value(elem)) {
-    return P::value(elem);
-  }
+            template<class T, class P = Policy>
+            static auto value(T* elem) -> decltype(P::value(elem))
+            {
+                return P::value(elem);
+            }
 
-  template <class... Ts, class P = Policy>
-  static auto apply(Ts&&... ts) -> decltype(P::apply(std::forward<Ts>(ts)...)) {
-    return P::apply(std::forward<Ts>(ts)...);
-  }
-};
+            template<class... Ts, class P = Policy>
+            static auto apply(Ts&&... ts) -> decltype(P::apply(std::forward<Ts>(ts)...))
+            {
+                return P::apply(std::forward<Ts>(ts)...);
+            }
+        };
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_NODE_SLOT_POLICY_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_map.h b/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_map.h
index c7df2ef..705eec4 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_map.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_map.h
@@ -23,176 +23,196 @@
 #include "absl/container/internal/container_memory.h"
 #include "absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class Policy, class Hash, class Eq, class Alloc>
-class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
-  // P is Policy. It's passed as a template argument to support maps that have
-  // incomplete types as values, as in unordered_map<K, IncompleteType>.
-  // MappedReference<> may be a non-reference type.
-  template <class P>
-  using MappedReference = decltype(P::value(
-      std::addressof(std::declval<typename raw_hash_map::reference>())));
-
-  // MappedConstReference<> may be a non-reference type.
-  template <class P>
-  using MappedConstReference = decltype(P::value(
-      std::addressof(std::declval<typename raw_hash_map::const_reference>())));
-
-  using KeyArgImpl =
-      KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
-
- public:
-  using key_type = typename Policy::key_type;
-  using mapped_type = typename Policy::mapped_type;
-  template <class K>
-  using key_arg = typename KeyArgImpl::template type<K, key_type>;
-
-  static_assert(!std::is_reference<key_type>::value, "");
-
-  // TODO(b/187807849): Evaluate whether to support reference mapped_type and
-  // remove this assertion if/when it is supported.
-  static_assert(!std::is_reference<mapped_type>::value, "");
-
-  using iterator = typename raw_hash_map::raw_hash_set::iterator;
-  using const_iterator = typename raw_hash_map::raw_hash_set::const_iterator;
-
-  raw_hash_map() {}
-  using raw_hash_map::raw_hash_set::raw_hash_set;
-
-  // The last two template parameters ensure that both arguments are rvalues
-  // (lvalue arguments are handled by the overloads below). This is necessary
-  // for supporting bitfield arguments.
-  //
-  //   union { int n : 1; };
-  //   flat_hash_map<int, int> m;
-  //   m.insert_or_assign(n, n);
-  template <class K = key_type, class V = mapped_type, K* = nullptr,
-            V* = nullptr>
-  std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, V&& v) {
-    return insert_or_assign_impl(std::forward<K>(k), std::forward<V>(v));
-  }
-
-  template <class K = key_type, class V = mapped_type, K* = nullptr>
-  std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const V& v) {
-    return insert_or_assign_impl(std::forward<K>(k), v);
-  }
-
-  template <class K = key_type, class V = mapped_type, V* = nullptr>
-  std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, V&& v) {
-    return insert_or_assign_impl(k, std::forward<V>(v));
-  }
-
-  template <class K = key_type, class V = mapped_type>
-  std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const V& v) {
-    return insert_or_assign_impl(k, v);
-  }
-
-  template <class K = key_type, class V = mapped_type, K* = nullptr,
-            V* = nullptr>
-  iterator insert_or_assign(const_iterator, key_arg<K>&& k, V&& v) {
-    return insert_or_assign(std::forward<K>(k), std::forward<V>(v)).first;
-  }
-
-  template <class K = key_type, class V = mapped_type, K* = nullptr>
-  iterator insert_or_assign(const_iterator, key_arg<K>&& k, const V& v) {
-    return insert_or_assign(std::forward<K>(k), v).first;
-  }
-
-  template <class K = key_type, class V = mapped_type, V* = nullptr>
-  iterator insert_or_assign(const_iterator, const key_arg<K>& k, V&& v) {
-    return insert_or_assign(k, std::forward<V>(v)).first;
-  }
-
-  template <class K = key_type, class V = mapped_type>
-  iterator insert_or_assign(const_iterator, const key_arg<K>& k, const V& v) {
-    return insert_or_assign(k, v).first;
-  }
-
-  // All `try_emplace()` overloads make the same guarantees regarding rvalue
-  // arguments as `std::unordered_map::try_emplace()`, namely that these
-  // functions will not move from rvalue arguments if insertions do not happen.
-  template <class K = key_type, class... Args,
-            typename std::enable_if<
-                !std::is_convertible<K, const_iterator>::value, int>::type = 0,
-            K* = nullptr>
-  std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args) {
-    return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
-  }
-
-  template <class K = key_type, class... Args,
-            typename std::enable_if<
-                !std::is_convertible<K, const_iterator>::value, int>::type = 0>
-  std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args) {
-    return try_emplace_impl(k, std::forward<Args>(args)...);
-  }
-
-  template <class K = key_type, class... Args, K* = nullptr>
-  iterator try_emplace(const_iterator, key_arg<K>&& k, Args&&... args) {
-    return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
-  }
-
-  template <class K = key_type, class... Args>
-  iterator try_emplace(const_iterator, const key_arg<K>& k, Args&&... args) {
-    return try_emplace(k, std::forward<Args>(args)...).first;
-  }
-
-  template <class K = key_type, class P = Policy>
-  MappedReference<P> at(const key_arg<K>& key) {
-    auto it = this->find(key);
-    if (it == this->end()) {
-      base_internal::ThrowStdOutOfRange(
-          "absl::container_internal::raw_hash_map<>::at");
-    }
-    return Policy::value(&*it);
-  }
-
-  template <class K = key_type, class P = Policy>
-  MappedConstReference<P> at(const key_arg<K>& key) const {
-    auto it = this->find(key);
-    if (it == this->end()) {
-      base_internal::ThrowStdOutOfRange(
-          "absl::container_internal::raw_hash_map<>::at");
-    }
-    return Policy::value(&*it);
-  }
-
-  template <class K = key_type, class P = Policy, K* = nullptr>
-  MappedReference<P> operator[](key_arg<K>&& key) {
-    return Policy::value(&*try_emplace(std::forward<K>(key)).first);
-  }
-
-  template <class K = key_type, class P = Policy>
-  MappedReference<P> operator[](const key_arg<K>& key) {
-    return Policy::value(&*try_emplace(key).first);
-  }
-
- private:
-  template <class K, class V>
-  std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v) {
-    auto res = this->find_or_prepare_insert(k);
-    if (res.second)
-      this->emplace_at(res.first, std::forward<K>(k), std::forward<V>(v));
-    else
-      Policy::value(&*this->iterator_at(res.first)) = std::forward<V>(v);
-    return {this->iterator_at(res.first), res.second};
-  }
-
-  template <class K = key_type, class... Args>
-  std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
-    auto res = this->find_or_prepare_insert(k);
-    if (res.second)
-      this->emplace_at(res.first, std::piecewise_construct,
-                       std::forward_as_tuple(std::forward<K>(k)),
-                       std::forward_as_tuple(std::forward<Args>(args)...));
-    return {this->iterator_at(res.first), res.second};
-  }
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<class Policy, class Hash, class Eq, class Alloc>
+        class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc>
+        {
+            // P is Policy. It's passed as a template argument to support maps that have
+            // incomplete types as values, as in unordered_map<K, IncompleteType>.
+            // MappedReference<> may be a non-reference type.
+            template<class P>
+            using MappedReference = decltype(P::value(
+                std::addressof(std::declval<typename raw_hash_map::reference>())
+            ));
+
+            // MappedConstReference<> may be a non-reference type.
+            template<class P>
+            using MappedConstReference = decltype(P::value(
+                std::addressof(std::declval<typename raw_hash_map::const_reference>())
+            ));
+
+            using KeyArgImpl =
+                KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+        public:
+            using key_type = typename Policy::key_type;
+            using mapped_type = typename Policy::mapped_type;
+            template<class K>
+            using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+            static_assert(!std::is_reference<key_type>::value, "");
+
+            // TODO(b/187807849): Evaluate whether to support reference mapped_type and
+            // remove this assertion if/when it is supported.
+            static_assert(!std::is_reference<mapped_type>::value, "");
+
+            using iterator = typename raw_hash_map::raw_hash_set::iterator;
+            using const_iterator = typename raw_hash_map::raw_hash_set::const_iterator;
+
+            raw_hash_map()
+            {
+            }
+            using raw_hash_map::raw_hash_set::raw_hash_set;
+
+            // The last two template parameters ensure that both arguments are rvalues
+            // (lvalue arguments are handled by the overloads below). This is necessary
+            // for supporting bitfield arguments.
+            //
+            //   union { int n : 1; };
+            //   flat_hash_map<int, int> m;
+            //   m.insert_or_assign(n, n);
+            template<class K = key_type, class V = mapped_type, K* = nullptr, V* = nullptr>
+            std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, V&& v)
+            {
+                return insert_or_assign_impl(std::forward<K>(k), std::forward<V>(v));
+            }
+
+            template<class K = key_type, class V = mapped_type, K* = nullptr>
+            std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const V& v)
+            {
+                return insert_or_assign_impl(std::forward<K>(k), v);
+            }
+
+            template<class K = key_type, class V = mapped_type, V* = nullptr>
+            std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, V&& v)
+            {
+                return insert_or_assign_impl(k, std::forward<V>(v));
+            }
+
+            template<class K = key_type, class V = mapped_type>
+            std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const V& v)
+            {
+                return insert_or_assign_impl(k, v);
+            }
+
+            template<class K = key_type, class V = mapped_type, K* = nullptr, V* = nullptr>
+            iterator insert_or_assign(const_iterator, key_arg<K>&& k, V&& v)
+            {
+                return insert_or_assign(std::forward<K>(k), std::forward<V>(v)).first;
+            }
+
+            template<class K = key_type, class V = mapped_type, K* = nullptr>
+            iterator insert_or_assign(const_iterator, key_arg<K>&& k, const V& v)
+            {
+                return insert_or_assign(std::forward<K>(k), v).first;
+            }
+
+            template<class K = key_type, class V = mapped_type, V* = nullptr>
+            iterator insert_or_assign(const_iterator, const key_arg<K>& k, V&& v)
+            {
+                return insert_or_assign(k, std::forward<V>(v)).first;
+            }
+
+            template<class K = key_type, class V = mapped_type>
+            iterator insert_or_assign(const_iterator, const key_arg<K>& k, const V& v)
+            {
+                return insert_or_assign(k, v).first;
+            }
+
+            // All `try_emplace()` overloads make the same guarantees regarding rvalue
+            // arguments as `std::unordered_map::try_emplace()`, namely that these
+            // functions will not move from rvalue arguments if insertions do not happen.
+            template<class K = key_type, class... Args, typename std::enable_if<!std::is_convertible<K, const_iterator>::value, int>::type = 0, K* = nullptr>
+            std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args)
+            {
+                return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
+            }
+
+            template<class K = key_type, class... Args, typename std::enable_if<!std::is_convertible<K, const_iterator>::value, int>::type = 0>
+            std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args)
+            {
+                return try_emplace_impl(k, std::forward<Args>(args)...);
+            }
+
+            template<class K = key_type, class... Args, K* = nullptr>
+            iterator try_emplace(const_iterator, key_arg<K>&& k, Args&&... args)
+            {
+                return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
+            }
+
+            template<class K = key_type, class... Args>
+            iterator try_emplace(const_iterator, const key_arg<K>& k, Args&&... args)
+            {
+                return try_emplace(k, std::forward<Args>(args)...).first;
+            }
+
+            template<class K = key_type, class P = Policy>
+            MappedReference<P> at(const key_arg<K>& key)
+            {
+                auto it = this->find(key);
+                if (it == this->end())
+                {
+                    base_internal::ThrowStdOutOfRange(
+                        "absl::container_internal::raw_hash_map<>::at"
+                    );
+                }
+                return Policy::value(&*it);
+            }
+
+            template<class K = key_type, class P = Policy>
+            MappedConstReference<P> at(const key_arg<K>& key) const
+            {
+                auto it = this->find(key);
+                if (it == this->end())
+                {
+                    base_internal::ThrowStdOutOfRange(
+                        "absl::container_internal::raw_hash_map<>::at"
+                    );
+                }
+                return Policy::value(&*it);
+            }
+
+            template<class K = key_type, class P = Policy, K* = nullptr>
+            MappedReference<P> operator[](key_arg<K>&& key)
+            {
+                return Policy::value(&*try_emplace(std::forward<K>(key)).first);
+            }
+
+            template<class K = key_type, class P = Policy>
+            MappedReference<P> operator[](const key_arg<K>& key)
+            {
+                return Policy::value(&*try_emplace(key).first);
+            }
+
+        private:
+            template<class K, class V>
+            std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v)
+            {
+                auto res = this->find_or_prepare_insert(k);
+                if (res.second)
+                    this->emplace_at(res.first, std::forward<K>(k), std::forward<V>(v));
+                else
+                    Policy::value(&*this->iterator_at(res.first)) = std::forward<V>(v);
+                return {this->iterator_at(res.first), res.second};
+            }
+
+            template<class K = key_type, class... Args>
+            std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args)
+            {
+                auto res = this->find_or_prepare_insert(k);
+                if (res.second)
+                    this->emplace_at(res.first, std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...));
+                return {this->iterator_at(res.first), res.second};
+            }
+        };
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_set.h b/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_set.h
index ea912f8..eecf77a 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_set.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/raw_hash_set.h
@@ -215,2149 +215,2532 @@
 #include <arm_neon.h>
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <typename AllocType>
-void SwapAlloc(AllocType& lhs, AllocType& rhs,
-               std::true_type /* propagate_on_container_swap */) {
-  using std::swap;
-  swap(lhs, rhs);
-}
-template <typename AllocType>
-void SwapAlloc(AllocType& /*lhs*/, AllocType& /*rhs*/,
-               std::false_type /* propagate_on_container_swap */) {}
-
-// The state for a probe sequence.
-//
-// Currently, the sequence is a triangular progression of the form
-//
-//   p(i) := Width * (i^2 + i)/2 + hash (mod mask + 1)
-//
-// The use of `Width` ensures that each probe step does not overlap groups;
-// the sequence effectively outputs the addresses of *groups* (although not
-// necessarily aligned to any boundary). The `Group` machinery allows us
-// to check an entire group with minimal branching.
-//
-// Wrapping around at `mask + 1` is important, but not for the obvious reason.
-// As described above, the first few entries of the control byte array
-// are mirrored at the end of the array, which `Group` will find and use
-// for selecting candidates. However, when those candidates' slots are
-// actually inspected, there are no corresponding slots for the cloned bytes,
-// so we need to make sure we've treated those offsets as "wrapping around".
-//
-// It turns out that this probe sequence visits every group exactly once if the
-// number of groups is a power of two, since (i^2+i)/2 is a bijection in
-// Z/(2^m). See https://en.wikipedia.org/wiki/Quadratic_probing
-template <size_t Width>
-class probe_seq {
- public:
-  // Creates a new probe sequence using `hash` as the initial value of the
-  // sequence and `mask` (usually the capacity of the table) as the mask to
-  // apply to each value in the progression.
-  probe_seq(size_t hash, size_t mask) {
-    assert(((mask + 1) & mask) == 0 && "not a mask");
-    mask_ = mask;
-    offset_ = hash & mask_;
-  }
-
-  // The offset within the table, i.e., the value `p(i)` above.
-  size_t offset() const { return offset_; }
-  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
-
-  void next() {
-    index_ += Width;
-    offset_ += index_;
-    offset_ &= mask_;
-  }
-  // 0-based probe index, a multiple of `Width`.
-  size_t index() const { return index_; }
-
- private:
-  size_t mask_;
-  size_t offset_;
-  size_t index_ = 0;
-};
-
-template <class ContainerKey, class Hash, class Eq>
-struct RequireUsableKey {
-  template <class PassedKey, class... Args>
-  std::pair<
-      decltype(std::declval<const Hash&>()(std::declval<const PassedKey&>())),
-      decltype(std::declval<const Eq&>()(std::declval<const ContainerKey&>(),
-                                         std::declval<const PassedKey&>()))>*
-  operator()(const PassedKey&, const Args&...) const;
-};
-
-template <class E, class Policy, class Hash, class Eq, class... Ts>
-struct IsDecomposable : std::false_type {};
-
-template <class Policy, class Hash, class Eq, class... Ts>
-struct IsDecomposable<
-    absl::void_t<decltype(Policy::apply(
-        RequireUsableKey<typename Policy::key_type, Hash, Eq>(),
-        std::declval<Ts>()...))>,
-    Policy, Hash, Eq, Ts...> : std::true_type {};
-
-// TODO(alkis): Switch to std::is_nothrow_swappable when gcc/clang supports it.
-template <class T>
-constexpr bool IsNoThrowSwappable(std::true_type = {} /* is_swappable */) {
-  using std::swap;
-  return noexcept(swap(std::declval<T&>(), std::declval<T&>()));
-}
-template <class T>
-constexpr bool IsNoThrowSwappable(std::false_type /* is_swappable */) {
-  return false;
-}
-
-template <typename T>
-uint32_t TrailingZeros(T x) {
-  ABSL_ASSUME(x != 0);
-  return static_cast<uint32_t>(countr_zero(x));
-}
-
-// An abstract bitmask, such as that emitted by a SIMD instruction.
-//
-// Specifically, this type implements a simple bitset whose representation is
-// controlled by `SignificantBits` and `Shift`. `SignificantBits` is the number
-// of abstract bits in the bitset, while `Shift` is the log-base-two of the
-// width of an abstract bit in the representation.
-// This mask provides operations for any number of real bits set in an abstract
-// bit. To add iteration on top of that, implementation must guarantee no more
-// than one real bit is set in an abstract bit.
-template <class T, int SignificantBits, int Shift = 0>
-class NonIterableBitMask {
- public:
-  explicit NonIterableBitMask(T mask) : mask_(mask) {}
-
-  explicit operator bool() const { return this->mask_ != 0; }
-
-  // Returns the index of the lowest *abstract* bit set in `self`.
-  uint32_t LowestBitSet() const {
-    return container_internal::TrailingZeros(mask_) >> Shift;
-  }
-
-  // Returns the index of the highest *abstract* bit set in `self`.
-  uint32_t HighestBitSet() const {
-    return static_cast<uint32_t>((bit_width(mask_) - 1) >> Shift);
-  }
-
-  // Return the number of trailing zero *abstract* bits.
-  uint32_t TrailingZeros() const {
-    return container_internal::TrailingZeros(mask_) >> Shift;
-  }
-
-  // Return the number of leading zero *abstract* bits.
-  uint32_t LeadingZeros() const {
-    constexpr int total_significant_bits = SignificantBits << Shift;
-    constexpr int extra_bits = sizeof(T) * 8 - total_significant_bits;
-    return static_cast<uint32_t>(countl_zero(mask_ << extra_bits)) >> Shift;
-  }
-
-  T mask_;
-};
-
-// Mask that can be iterable
-//
-// For example, when `SignificantBits` is 16 and `Shift` is zero, this is just
-// an ordinary 16-bit bitset occupying the low 16 bits of `mask`. When
-// `SignificantBits` is 8 and `Shift` is 3, abstract bits are represented as
-// the bytes `0x00` and `0x80`, and it occupies all 64 bits of the bitmask.
-//
-// For example:
-//   for (int i : BitMask<uint32_t, 16>(0b101)) -> yields 0, 2
-//   for (int i : BitMask<uint64_t, 8, 3>(0x0000000080800000)) -> yields 2, 3
-template <class T, int SignificantBits, int Shift = 0>
-class BitMask : public NonIterableBitMask<T, SignificantBits, Shift> {
-  using Base = NonIterableBitMask<T, SignificantBits, Shift>;
-  static_assert(std::is_unsigned<T>::value, "");
-  static_assert(Shift == 0 || Shift == 3, "");
-
- public:
-  explicit BitMask(T mask) : Base(mask) {}
-  // BitMask is an iterator over the indices of its abstract bits.
-  using value_type = int;
-  using iterator = BitMask;
-  using const_iterator = BitMask;
-
-  BitMask& operator++() {
-    this->mask_ &= (this->mask_ - 1);
-    return *this;
-  }
-
-  uint32_t operator*() const { return Base::LowestBitSet(); }
-
-  BitMask begin() const { return *this; }
-  BitMask end() const { return BitMask(0); }
-
- private:
-  friend bool operator==(const BitMask& a, const BitMask& b) {
-    return a.mask_ == b.mask_;
-  }
-  friend bool operator!=(const BitMask& a, const BitMask& b) {
-    return a.mask_ != b.mask_;
-  }
-};
-
-using h2_t = uint8_t;
-
-// The values here are selected for maximum performance. See the static asserts
-// below for details.
-
-// A `ctrl_t` is a single control byte, which can have one of four
-// states: empty, deleted, full (which has an associated seven-bit h2_t value)
-// and the sentinel. They have the following bit patterns:
-//
-//      empty: 1 0 0 0 0 0 0 0
-//    deleted: 1 1 1 1 1 1 1 0
-//       full: 0 h h h h h h h  // h represents the hash bits.
-//   sentinel: 1 1 1 1 1 1 1 1
-//
-// These values are specifically tuned for SSE-flavored SIMD.
-// The static_asserts below detail the source of these choices.
-//
-// We use an enum class so that when strict aliasing is enabled, the compiler
-// knows ctrl_t doesn't alias other types.
-enum class ctrl_t : int8_t {
-  kEmpty = -128,   // 0b10000000
-  kDeleted = -2,   // 0b11111110
-  kSentinel = -1,  // 0b11111111
-};
-static_assert(
-    (static_cast<int8_t>(ctrl_t::kEmpty) &
-     static_cast<int8_t>(ctrl_t::kDeleted) &
-     static_cast<int8_t>(ctrl_t::kSentinel) & 0x80) != 0,
-    "Special markers need to have the MSB to make checking for them efficient");
-static_assert(
-    ctrl_t::kEmpty < ctrl_t::kSentinel && ctrl_t::kDeleted < ctrl_t::kSentinel,
-    "ctrl_t::kEmpty and ctrl_t::kDeleted must be smaller than "
-    "ctrl_t::kSentinel to make the SIMD test of IsEmptyOrDeleted() efficient");
-static_assert(
-    ctrl_t::kSentinel == static_cast<ctrl_t>(-1),
-    "ctrl_t::kSentinel must be -1 to elide loading it from memory into SIMD "
-    "registers (pcmpeqd xmm, xmm)");
-static_assert(ctrl_t::kEmpty == static_cast<ctrl_t>(-128),
-              "ctrl_t::kEmpty must be -128 to make the SIMD check for its "
-              "existence efficient (psignb xmm, xmm)");
-static_assert(
-    (~static_cast<int8_t>(ctrl_t::kEmpty) &
-     ~static_cast<int8_t>(ctrl_t::kDeleted) &
-     static_cast<int8_t>(ctrl_t::kSentinel) & 0x7F) != 0,
-    "ctrl_t::kEmpty and ctrl_t::kDeleted must share an unset bit that is not "
-    "shared by ctrl_t::kSentinel to make the scalar test for "
-    "MaskEmptyOrDeleted() efficient");
-static_assert(ctrl_t::kDeleted == static_cast<ctrl_t>(-2),
-              "ctrl_t::kDeleted must be -2 to make the implementation of "
-              "ConvertSpecialToEmptyAndFullToDeleted efficient");
-
-ABSL_DLL extern const ctrl_t kEmptyGroup[16];
-
-// Returns a pointer to a control byte group that can be used by empty tables.
-inline ctrl_t* EmptyGroup() {
-  // Const must be cast away here; no uses of this function will actually write
-  // to it, because it is only used for empty tables.
-  return const_cast<ctrl_t*>(kEmptyGroup);
-}
-
-// Mixes a randomly generated per-process seed with `hash` and `ctrl` to
-// randomize insertion order within groups.
-bool ShouldInsertBackwards(size_t hash, const ctrl_t* ctrl);
-
-// Returns a per-table, hash salt, which changes on resize. This gets mixed into
-// H1 to randomize iteration order per-table.
-//
-// The seed consists of the ctrl_ pointer, which adds enough entropy to ensure
-// non-determinism of iteration order in most cases.
-inline size_t PerTableSalt(const ctrl_t* ctrl) {
-  // The low bits of the pointer have little or no entropy because of
-  // alignment. We shift the pointer to try to use higher entropy bits. A
-  // good number seems to be 12 bits, because that aligns with page size.
-  return reinterpret_cast<uintptr_t>(ctrl) >> 12;
-}
-// Extracts the H1 portion of a hash: 57 bits mixed with a per-table salt.
-inline size_t H1(size_t hash, const ctrl_t* ctrl) {
-  return (hash >> 7) ^ PerTableSalt(ctrl);
-}
-
-// Extracts the H2 portion of a hash: the 7 bits not used for H1.
-//
-// These are used as an occupied control byte.
-inline h2_t H2(size_t hash) { return hash & 0x7F; }
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<typename AllocType>
+        void SwapAlloc(AllocType& lhs, AllocType& rhs, std::true_type /* propagate_on_container_swap */)
+        {
+            using std::swap;
+            swap(lhs, rhs);
+        }
+        template<typename AllocType>
+        void SwapAlloc(AllocType& /*lhs*/, AllocType& /*rhs*/, std::false_type /* propagate_on_container_swap */)
+        {
+        }
 
-// Helpers for checking the state of a control byte.
-inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
-inline bool IsFull(ctrl_t c) { return c >= static_cast<ctrl_t>(0); }
-inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
-inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
+        // The state for a probe sequence.
+        //
+        // Currently, the sequence is a triangular progression of the form
+        //
+        //   p(i) := Width * (i^2 + i)/2 + hash (mod mask + 1)
+        //
+        // The use of `Width` ensures that each probe step does not overlap groups;
+        // the sequence effectively outputs the addresses of *groups* (although not
+        // necessarily aligned to any boundary). The `Group` machinery allows us
+        // to check an entire group with minimal branching.
+        //
+        // Wrapping around at `mask + 1` is important, but not for the obvious reason.
+        // As described above, the first few entries of the control byte array
+        // are mirrored at the end of the array, which `Group` will find and use
+        // for selecting candidates. However, when those candidates' slots are
+        // actually inspected, there are no corresponding slots for the cloned bytes,
+        // so we need to make sure we've treated those offsets as "wrapping around".
+        //
+        // It turns out that this probe sequence visits every group exactly once if the
+        // number of groups is a power of two, since (i^2+i)/2 is a bijection in
+        // Z/(2^m). See https://en.wikipedia.org/wiki/Quadratic_probing
+        template<size_t Width>
+        class probe_seq
+        {
+        public:
+            // Creates a new probe sequence using `hash` as the initial value of the
+            // sequence and `mask` (usually the capacity of the table) as the mask to
+            // apply to each value in the progression.
+            probe_seq(size_t hash, size_t mask)
+            {
+                assert(((mask + 1) & mask) == 0 && "not a mask");
+                mask_ = mask;
+                offset_ = hash & mask_;
+            }
+
+            // The offset within the table, i.e., the value `p(i)` above.
+            size_t offset() const
+            {
+                return offset_;
+            }
+            size_t offset(size_t i) const
+            {
+                return (offset_ + i) & mask_;
+            }
+
+            void next()
+            {
+                index_ += Width;
+                offset_ += index_;
+                offset_ &= mask_;
+            }
+            // 0-based probe index, a multiple of `Width`.
+            size_t index() const
+            {
+                return index_;
+            }
+
+        private:
+            size_t mask_;
+            size_t offset_;
+            size_t index_ = 0;
+        };
+
+        template<class ContainerKey, class Hash, class Eq>
+        struct RequireUsableKey
+        {
+            template<class PassedKey, class... Args>
+            std::pair<
+                decltype(std::declval<const Hash&>()(std::declval<const PassedKey&>())),
+                decltype(std::declval<const Eq&>()(std::declval<const ContainerKey&>(), std::declval<const PassedKey&>()))>*
+                operator()(const PassedKey&, const Args&...) const;
+        };
+
+        template<class E, class Policy, class Hash, class Eq, class... Ts>
+        struct IsDecomposable : std::false_type
+        {
+        };
+
+        template<class Policy, class Hash, class Eq, class... Ts>
+        struct IsDecomposable<
+            absl::void_t<decltype(Policy::apply(
+                RequireUsableKey<typename Policy::key_type, Hash, Eq>(),
+                std::declval<Ts>()...
+            ))>,
+            Policy,
+            Hash,
+            Eq,
+            Ts...> : std::true_type
+        {
+        };
+
+        // TODO(alkis): Switch to std::is_nothrow_swappable when gcc/clang supports it.
+        template<class T>
+        constexpr bool IsNoThrowSwappable(std::true_type = {} /* is_swappable */)
+        {
+            using std::swap;
+            return noexcept(swap(std::declval<T&>(), std::declval<T&>()));
+        }
+        template<class T>
+        constexpr bool IsNoThrowSwappable(std::false_type /* is_swappable */)
+        {
+            return false;
+        }
 
-#ifdef ABSL_INTERNAL_HAVE_SSE2
-// Quick reference guide for intrinsics used below:
-//
-// * __m128i: An XMM (128-bit) word.
-//
-// * _mm_setzero_si128: Returns a zero vector.
-// * _mm_set1_epi8:     Returns a vector with the same i8 in each lane.
-//
-// * _mm_subs_epi8:    Saturating-subtracts two i8 vectors.
-// * _mm_and_si128:    Ands two i128s together.
-// * _mm_or_si128:     Ors two i128s together.
-// * _mm_andnot_si128: And-nots two i128s together.
-//
-// * _mm_cmpeq_epi8: Component-wise compares two i8 vectors for equality,
-//                   filling each lane with 0x00 or 0xff.
-// * _mm_cmpgt_epi8: Same as above, but using > rather than ==.
-//
-// * _mm_loadu_si128:  Performs an unaligned load of an i128.
-// * _mm_storeu_si128: Performs an unaligned store of an i128.
-//
-// * _mm_sign_epi8:     Retains, negates, or zeroes each i8 lane of the first
-//                      argument if the corresponding lane of the second
-//                      argument is positive, negative, or zero, respectively.
-// * _mm_movemask_epi8: Selects the sign bit out of each i8 lane and produces a
-//                      bitmask consisting of those bits.
-// * _mm_shuffle_epi8:  Selects i8s from the first argument, using the low
-//                      four bits of each i8 lane in the second argument as
-//                      indices.
-
-// https://github.com/abseil/abseil-cpp/issues/209
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87853
-// _mm_cmpgt_epi8 is broken under GCC with -funsigned-char
-// Work around this by using the portable implementation of Group
-// when using -funsigned-char under GCC.
-inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
-#if defined(__GNUC__) && !defined(__clang__)
-  if (std::is_unsigned<char>::value) {
-    const __m128i mask = _mm_set1_epi8(0x80);
-    const __m128i diff = _mm_subs_epi8(b, a);
-    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
-  }
-#endif
-  return _mm_cmpgt_epi8(a, b);
-}
+        template<typename T>
+        uint32_t TrailingZeros(T x)
+        {
+            ABSL_ASSUME(x != 0);
+            return static_cast<uint32_t>(countr_zero(x));
+        }
+
+        // An abstract bitmask, such as that emitted by a SIMD instruction.
+        //
+        // Specifically, this type implements a simple bitset whose representation is
+        // controlled by `SignificantBits` and `Shift`. `SignificantBits` is the number
+        // of abstract bits in the bitset, while `Shift` is the log-base-two of the
+        // width of an abstract bit in the representation.
+        // This mask provides operations for any number of real bits set in an abstract
+        // bit. To add iteration on top of that, implementation must guarantee no more
+        // than one real bit is set in an abstract bit.
+        template<class T, int SignificantBits, int Shift = 0>
+        class NonIterableBitMask
+        {
+        public:
+            explicit NonIterableBitMask(T mask) :
+                mask_(mask)
+            {
+            }
+
+            explicit operator bool() const
+            {
+                return this->mask_ != 0;
+            }
+
+            // Returns the index of the lowest *abstract* bit set in `self`.
+            uint32_t LowestBitSet() const
+            {
+                return container_internal::TrailingZeros(mask_) >> Shift;
+            }
+
+            // Returns the index of the highest *abstract* bit set in `self`.
+            uint32_t HighestBitSet() const
+            {
+                return static_cast<uint32_t>((bit_width(mask_) - 1) >> Shift);
+            }
+
+            // Return the number of trailing zero *abstract* bits.
+            uint32_t TrailingZeros() const
+            {
+                return container_internal::TrailingZeros(mask_) >> Shift;
+            }
+
+            // Return the number of leading zero *abstract* bits.
+            uint32_t LeadingZeros() const
+            {
+                constexpr int total_significant_bits = SignificantBits << Shift;
+                constexpr int extra_bits = sizeof(T) * 8 - total_significant_bits;
+                return static_cast<uint32_t>(countl_zero(mask_ << extra_bits)) >> Shift;
+            }
+
+            T mask_;
+        };
+
+        // Mask that can be iterable
+        //
+        // For example, when `SignificantBits` is 16 and `Shift` is zero, this is just
+        // an ordinary 16-bit bitset occupying the low 16 bits of `mask`. When
+        // `SignificantBits` is 8 and `Shift` is 3, abstract bits are represented as
+        // the bytes `0x00` and `0x80`, and it occupies all 64 bits of the bitmask.
+        //
+        // For example:
+        //   for (int i : BitMask<uint32_t, 16>(0b101)) -> yields 0, 2
+        //   for (int i : BitMask<uint64_t, 8, 3>(0x0000000080800000)) -> yields 2, 3
+        template<class T, int SignificantBits, int Shift = 0>
+        class BitMask : public NonIterableBitMask<T, SignificantBits, Shift>
+        {
+            using Base = NonIterableBitMask<T, SignificantBits, Shift>;
+            static_assert(std::is_unsigned<T>::value, "");
+            static_assert(Shift == 0 || Shift == 3, "");
+
+        public:
+            explicit BitMask(T mask) :
+                Base(mask)
+            {
+            }
+            // BitMask is an iterator over the indices of its abstract bits.
+            using value_type = int;
+            using iterator = BitMask;
+            using const_iterator = BitMask;
+
+            BitMask& operator++()
+            {
+                this->mask_ &= (this->mask_ - 1);
+                return *this;
+            }
+
+            uint32_t operator*() const
+            {
+                return Base::LowestBitSet();
+            }
+
+            BitMask begin() const
+            {
+                return *this;
+            }
+            BitMask end() const
+            {
+                return BitMask(0);
+            }
+
+        private:
+            friend bool operator==(const BitMask& a, const BitMask& b)
+            {
+                return a.mask_ == b.mask_;
+            }
+            friend bool operator!=(const BitMask& a, const BitMask& b)
+            {
+                return a.mask_ != b.mask_;
+            }
+        };
+
+        using h2_t = uint8_t;
+
+        // The values here are selected for maximum performance. See the static asserts
+        // below for details.
+
+        // A `ctrl_t` is a single control byte, which can have one of four
+        // states: empty, deleted, full (which has an associated seven-bit h2_t value)
+        // and the sentinel. They have the following bit patterns:
+        //
+        //      empty: 1 0 0 0 0 0 0 0
+        //    deleted: 1 1 1 1 1 1 1 0
+        //       full: 0 h h h h h h h  // h represents the hash bits.
+        //   sentinel: 1 1 1 1 1 1 1 1
+        //
+        // These values are specifically tuned for SSE-flavored SIMD.
+        // The static_asserts below detail the source of these choices.
+        //
+        // We use an enum class so that when strict aliasing is enabled, the compiler
+        // knows ctrl_t doesn't alias other types.
+        enum class ctrl_t : int8_t
+        {
+            kEmpty = -128,   // 0b10000000
+            kDeleted = -2,   // 0b11111110
+            kSentinel = -1,  // 0b11111111
+        };
+        static_assert(
+            (static_cast<int8_t>(ctrl_t::kEmpty) &
+             static_cast<int8_t>(ctrl_t::kDeleted) &
+             static_cast<int8_t>(ctrl_t::kSentinel) & 0x80) != 0,
+            "Special markers need to have the MSB to make checking for them efficient"
+        );
+        static_assert(
+            ctrl_t::kEmpty < ctrl_t::kSentinel && ctrl_t::kDeleted < ctrl_t::kSentinel,
+            "ctrl_t::kEmpty and ctrl_t::kDeleted must be smaller than "
+            "ctrl_t::kSentinel to make the SIMD test of IsEmptyOrDeleted() efficient"
+        );
+        static_assert(
+            ctrl_t::kSentinel == static_cast<ctrl_t>(-1),
+            "ctrl_t::kSentinel must be -1 to elide loading it from memory into SIMD "
+            "registers (pcmpeqd xmm, xmm)"
+        );
+        static_assert(ctrl_t::kEmpty == static_cast<ctrl_t>(-128), "ctrl_t::kEmpty must be -128 to make the SIMD check for its "
+                                                                   "existence efficient (psignb xmm, xmm)");
+        static_assert(
+            (~static_cast<int8_t>(ctrl_t::kEmpty) &
+             ~static_cast<int8_t>(ctrl_t::kDeleted) &
+             static_cast<int8_t>(ctrl_t::kSentinel) & 0x7F) != 0,
+            "ctrl_t::kEmpty and ctrl_t::kDeleted must share an unset bit that is not "
+            "shared by ctrl_t::kSentinel to make the scalar test for "
+            "MaskEmptyOrDeleted() efficient"
+        );
+        static_assert(ctrl_t::kDeleted == static_cast<ctrl_t>(-2), "ctrl_t::kDeleted must be -2 to make the implementation of "
+                                                                   "ConvertSpecialToEmptyAndFullToDeleted efficient");
+
+        ABSL_DLL extern const ctrl_t kEmptyGroup[16];
+
+        // Returns a pointer to a control byte group that can be used by empty tables.
+        inline ctrl_t* EmptyGroup()
+        {
+            // Const must be cast away here; no uses of this function will actually write
+            // to it, because it is only used for empty tables.
+            return const_cast<ctrl_t*>(kEmptyGroup);
+        }
+
+        // Mixes a randomly generated per-process seed with `hash` and `ctrl` to
+        // randomize insertion order within groups.
+        bool ShouldInsertBackwards(size_t hash, const ctrl_t* ctrl);
+
+        // Returns a per-table, hash salt, which changes on resize. This gets mixed into
+        // H1 to randomize iteration order per-table.
+        //
+        // The seed consists of the ctrl_ pointer, which adds enough entropy to ensure
+        // non-determinism of iteration order in most cases.
+        inline size_t PerTableSalt(const ctrl_t* ctrl)
+        {
+            // The low bits of the pointer have little or no entropy because of
+            // alignment. We shift the pointer to try to use higher entropy bits. A
+            // good number seems to be 12 bits, because that aligns with page size.
+            return reinterpret_cast<uintptr_t>(ctrl) >> 12;
+        }
+        // Extracts the H1 portion of a hash: 57 bits mixed with a per-table salt.
+        inline size_t H1(size_t hash, const ctrl_t* ctrl)
+        {
+            return (hash >> 7) ^ PerTableSalt(ctrl);
+        }
 
-struct GroupSse2Impl {
-  static constexpr size_t kWidth = 16;  // the number of slots per group
+        // Extracts the H2 portion of a hash: the 7 bits not used for H1.
+        //
+        // These are used as an occupied control byte.
+        inline h2_t H2(size_t hash)
+        {
+            return hash & 0x7F;
+        }
 
-  explicit GroupSse2Impl(const ctrl_t* pos) {
-    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
-  }
+        // Helpers for checking the state of a control byte.
+        inline bool IsEmpty(ctrl_t c)
+        {
+            return c == ctrl_t::kEmpty;
+        }
+        inline bool IsFull(ctrl_t c)
+        {
+            return c >= static_cast<ctrl_t>(0);
+        }
+        inline bool IsDeleted(ctrl_t c)
+        {
+            return c == ctrl_t::kDeleted;
+        }
+        inline bool IsEmptyOrDeleted(ctrl_t c)
+        {
+            return c < ctrl_t::kSentinel;
+        }
 
-  // Returns a bitmask representing the positions of slots that match hash.
-  BitMask<uint32_t, kWidth> Match(h2_t hash) const {
-    auto match = _mm_set1_epi8(hash);
-    return BitMask<uint32_t, kWidth>(
-        static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
-  }
+#ifdef ABSL_INTERNAL_HAVE_SSE2
+        // Quick reference guide for intrinsics used below:
+        //
+        // * __m128i: An XMM (128-bit) word.
+        //
+        // * _mm_setzero_si128: Returns a zero vector.
+        // * _mm_set1_epi8:     Returns a vector with the same i8 in each lane.
+        //
+        // * _mm_subs_epi8:    Saturating-subtracts two i8 vectors.
+        // * _mm_and_si128:    Ands two i128s together.
+        // * _mm_or_si128:     Ors two i128s together.
+        // * _mm_andnot_si128: And-nots two i128s together.
+        //
+        // * _mm_cmpeq_epi8: Component-wise compares two i8 vectors for equality,
+        //                   filling each lane with 0x00 or 0xff.
+        // * _mm_cmpgt_epi8: Same as above, but using > rather than ==.
+        //
+        // * _mm_loadu_si128:  Performs an unaligned load of an i128.
+        // * _mm_storeu_si128: Performs an unaligned store of an i128.
+        //
+        // * _mm_sign_epi8:     Retains, negates, or zeroes each i8 lane of the first
+        //                      argument if the corresponding lane of the second
+        //                      argument is positive, negative, or zero, respectively.
+        // * _mm_movemask_epi8: Selects the sign bit out of each i8 lane and produces a
+        //                      bitmask consisting of those bits.
+        // * _mm_shuffle_epi8:  Selects i8s from the first argument, using the low
+        //                      four bits of each i8 lane in the second argument as
+        //                      indices.
+
+        // https://github.com/abseil/abseil-cpp/issues/209
+        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87853
+        // _mm_cmpgt_epi8 is broken under GCC with -funsigned-char
+        // Work around this by using the portable implementation of Group
+        // when using -funsigned-char under GCC.
+        inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b)
+        {
+#if defined(__GNUC__) && !defined(__clang__)
+            if (std::is_unsigned<char>::value)
+            {
+                const __m128i mask = _mm_set1_epi8(0x80);
+                const __m128i diff = _mm_subs_epi8(b, a);
+                return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
+            }
+#endif
+            return _mm_cmpgt_epi8(a, b);
+        }
 
-  // Returns a bitmask representing the positions of empty slots.
-  NonIterableBitMask<uint32_t, kWidth> MaskEmpty() const {
+        struct GroupSse2Impl
+        {
+            static constexpr size_t kWidth = 16;  // the number of slots per group
+
+            explicit GroupSse2Impl(const ctrl_t* pos)
+            {
+                ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
+            }
+
+            // Returns a bitmask representing the positions of slots that match hash.
+            BitMask<uint32_t, kWidth> Match(h2_t hash) const
+            {
+                auto match = _mm_set1_epi8(hash);
+                return BitMask<uint32_t, kWidth>(
+                    static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl)))
+                );
+            }
+
+            // Returns a bitmask representing the positions of empty slots.
+            NonIterableBitMask<uint32_t, kWidth> MaskEmpty() const
+            {
 #ifdef ABSL_INTERNAL_HAVE_SSSE3
-    // This only works because ctrl_t::kEmpty is -128.
-    return NonIterableBitMask<uint32_t, kWidth>(
-        static_cast<uint32_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
+                // This only works because ctrl_t::kEmpty is -128.
+                return NonIterableBitMask<uint32_t, kWidth>(
+                    static_cast<uint32_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl)))
+                );
 #else
-    auto match = _mm_set1_epi8(static_cast<h2_t>(ctrl_t::kEmpty));
-    return NonIterableBitMask<uint32_t, kWidth>(
-        static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
+                auto match = _mm_set1_epi8(static_cast<h2_t>(ctrl_t::kEmpty));
+                return NonIterableBitMask<uint32_t, kWidth>(
+                    static_cast<uint32_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl)))
+                );
 #endif
-  }
-
-  // Returns a bitmask representing the positions of empty or deleted slots.
-  NonIterableBitMask<uint32_t, kWidth> MaskEmptyOrDeleted() const {
-    auto special = _mm_set1_epi8(static_cast<uint8_t>(ctrl_t::kSentinel));
-    return NonIterableBitMask<uint32_t, kWidth>(static_cast<uint32_t>(
-        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
-  }
-
-  // Returns the number of trailing empty or deleted elements in the group.
-  uint32_t CountLeadingEmptyOrDeleted() const {
-    auto special = _mm_set1_epi8(static_cast<uint8_t>(ctrl_t::kSentinel));
-    return TrailingZeros(static_cast<uint32_t>(
-        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
-  }
-
-  void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
-    auto msbs = _mm_set1_epi8(static_cast<char>(-128));
-    auto x126 = _mm_set1_epi8(126);
+            }
+
+            // Returns a bitmask representing the positions of empty or deleted slots.
+            NonIterableBitMask<uint32_t, kWidth> MaskEmptyOrDeleted() const
+            {
+                auto special = _mm_set1_epi8(static_cast<uint8_t>(ctrl_t::kSentinel));
+                return NonIterableBitMask<uint32_t, kWidth>(static_cast<uint32_t>(
+                    _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))
+                ));
+            }
+
+            // Returns the number of trailing empty or deleted elements in the group.
+            uint32_t CountLeadingEmptyOrDeleted() const
+            {
+                auto special = _mm_set1_epi8(static_cast<uint8_t>(ctrl_t::kSentinel));
+                return TrailingZeros(static_cast<uint32_t>(
+                    _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1
+                ));
+            }
+
+            void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const
+            {
+                auto msbs = _mm_set1_epi8(static_cast<char>(-128));
+                auto x126 = _mm_set1_epi8(126);
 #ifdef ABSL_INTERNAL_HAVE_SSSE3
-    auto res = _mm_or_si128(_mm_shuffle_epi8(x126, ctrl), msbs);
+                auto res = _mm_or_si128(_mm_shuffle_epi8(x126, ctrl), msbs);
 #else
-    auto zero = _mm_setzero_si128();
-    auto special_mask = _mm_cmpgt_epi8_fixed(zero, ctrl);
-    auto res = _mm_or_si128(msbs, _mm_andnot_si128(special_mask, x126));
+                auto zero = _mm_setzero_si128();
+                auto special_mask = _mm_cmpgt_epi8_fixed(zero, ctrl);
+                auto res = _mm_or_si128(msbs, _mm_andnot_si128(special_mask, x126));
 #endif
-    _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
-  }
+                _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
+            }
 
-  __m128i ctrl;
-};
+            __m128i ctrl;
+        };
 #endif  // ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
 
 #if defined(ABSL_INTERNAL_HAVE_ARM_NEON) && defined(ABSL_IS_LITTLE_ENDIAN)
-struct GroupAArch64Impl {
-  static constexpr size_t kWidth = 8;
-
-  explicit GroupAArch64Impl(const ctrl_t* pos) {
-    ctrl = vld1_u8(reinterpret_cast<const uint8_t*>(pos));
-  }
-
-  BitMask<uint64_t, kWidth, 3> Match(h2_t hash) const {
-    uint8x8_t dup = vdup_n_u8(hash);
-    auto mask = vceq_u8(ctrl, dup);
-    constexpr uint64_t msbs = 0x8080808080808080ULL;
-    return BitMask<uint64_t, kWidth, 3>(
-        vget_lane_u64(vreinterpret_u64_u8(mask), 0) & msbs);
-  }
-
-  NonIterableBitMask<uint64_t, kWidth, 3> MaskEmpty() const {
-    uint64_t mask =
-        vget_lane_u64(vreinterpret_u64_u8(
-                          vceq_s8(vdup_n_s8(static_cast<h2_t>(ctrl_t::kEmpty)),
-                                  vreinterpret_s8_u8(ctrl))),
-                      0);
-    return NonIterableBitMask<uint64_t, kWidth, 3>(mask);
-  }
-
-  NonIterableBitMask<uint64_t, kWidth, 3> MaskEmptyOrDeleted() const {
-    uint64_t mask =
-        vget_lane_u64(vreinterpret_u64_u8(vcgt_s8(
-                          vdup_n_s8(static_cast<int8_t>(ctrl_t::kSentinel)),
-                          vreinterpret_s8_u8(ctrl))),
-                      0);
-    return NonIterableBitMask<uint64_t, kWidth, 3>(mask);
-  }
-
-  uint32_t CountLeadingEmptyOrDeleted() const {
-    uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(ctrl), 0);
-    // ctrl | ~(ctrl >> 7) will have the lowest bit set to zero for kEmpty and
-    // kDeleted. We lower all other bits and count number of trailing zeros.
-    // Clang and GCC optimize countr_zero to rbit+clz without any check for 0,
-    // so we should be fine.
-    constexpr uint64_t bits = 0x0101010101010101ULL;
-    return countr_zero((mask | ~(mask >> 7)) & bits) >> 3;
-  }
-
-  void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
-    uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(ctrl), 0);
-    constexpr uint64_t msbs = 0x8080808080808080ULL;
-    constexpr uint64_t lsbs = 0x0101010101010101ULL;
-    auto x = mask & msbs;
-    auto res = (~x + (x >> 7)) & ~lsbs;
-    little_endian::Store64(dst, res);
-  }
-
-  uint8x8_t ctrl;
-};
+        struct GroupAArch64Impl
+        {
+            static constexpr size_t kWidth = 8;
+
+            explicit GroupAArch64Impl(const ctrl_t* pos)
+            {
+                ctrl = vld1_u8(reinterpret_cast<const uint8_t*>(pos));
+            }
+
+            BitMask<uint64_t, kWidth, 3> Match(h2_t hash) const
+            {
+                uint8x8_t dup = vdup_n_u8(hash);
+                auto mask = vceq_u8(ctrl, dup);
+                constexpr uint64_t msbs = 0x8080808080808080ULL;
+                return BitMask<uint64_t, kWidth, 3>(
+                    vget_lane_u64(vreinterpret_u64_u8(mask), 0) & msbs
+                );
+            }
+
+            NonIterableBitMask<uint64_t, kWidth, 3> MaskEmpty() const
+            {
+                uint64_t mask =
+                    vget_lane_u64(vreinterpret_u64_u8(vceq_s8(vdup_n_s8(static_cast<h2_t>(ctrl_t::kEmpty)), vreinterpret_s8_u8(ctrl))), 0);
+                return NonIterableBitMask<uint64_t, kWidth, 3>(mask);
+            }
+
+            NonIterableBitMask<uint64_t, kWidth, 3> MaskEmptyOrDeleted() const
+            {
+                uint64_t mask =
+                    vget_lane_u64(vreinterpret_u64_u8(vcgt_s8(vdup_n_s8(static_cast<int8_t>(ctrl_t::kSentinel)), vreinterpret_s8_u8(ctrl))), 0);
+                return NonIterableBitMask<uint64_t, kWidth, 3>(mask);
+            }
+
+            uint32_t CountLeadingEmptyOrDeleted() const
+            {
+                uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(ctrl), 0);
+                // ctrl | ~(ctrl >> 7) will have the lowest bit set to zero for kEmpty and
+                // kDeleted. We lower all other bits and count number of trailing zeros.
+                // Clang and GCC optimize countr_zero to rbit+clz without any check for 0,
+                // so we should be fine.
+                constexpr uint64_t bits = 0x0101010101010101ULL;
+                return countr_zero((mask | ~(mask >> 7)) & bits) >> 3;
+            }
+
+            void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const
+            {
+                uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(ctrl), 0);
+                constexpr uint64_t msbs = 0x8080808080808080ULL;
+                constexpr uint64_t lsbs = 0x0101010101010101ULL;
+                auto x = mask & msbs;
+                auto res = (~x + (x >> 7)) & ~lsbs;
+                little_endian::Store64(dst, res);
+            }
+
+            uint8x8_t ctrl;
+        };
 #endif  // ABSL_INTERNAL_HAVE_ARM_NEON && ABSL_IS_LITTLE_ENDIAN
 
-struct GroupPortableImpl {
-  static constexpr size_t kWidth = 8;
-
-  explicit GroupPortableImpl(const ctrl_t* pos)
-      : ctrl(little_endian::Load64(pos)) {}
-
-  BitMask<uint64_t, kWidth, 3> Match(h2_t hash) const {
-    // For the technique, see:
-    // http://graphics.stanford.edu/~seander/bithacks.html##ValueInWord
-    // (Determine if a word has a byte equal to n).
-    //
-    // Caveat: there are false positives but:
-    // - they only occur if there is a real match
-    // - they never occur on ctrl_t::kEmpty, ctrl_t::kDeleted, ctrl_t::kSentinel
-    // - they will be handled gracefully by subsequent checks in code
-    //
-    // Example:
-    //   v = 0x1716151413121110
-    //   hash = 0x12
-    //   retval = (v - lsbs) & ~v & msbs = 0x0000000080800000
-    constexpr uint64_t msbs = 0x8080808080808080ULL;
-    constexpr uint64_t lsbs = 0x0101010101010101ULL;
-    auto x = ctrl ^ (lsbs * hash);
-    return BitMask<uint64_t, kWidth, 3>((x - lsbs) & ~x & msbs);
-  }
-
-  NonIterableBitMask<uint64_t, kWidth, 3> MaskEmpty() const {
-    constexpr uint64_t msbs = 0x8080808080808080ULL;
-    return NonIterableBitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 6)) &
-                                                   msbs);
-  }
-
-  NonIterableBitMask<uint64_t, kWidth, 3> MaskEmptyOrDeleted() const {
-    constexpr uint64_t msbs = 0x8080808080808080ULL;
-    return NonIterableBitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 7)) &
-                                                   msbs);
-  }
-
-  uint32_t CountLeadingEmptyOrDeleted() const {
-    // ctrl | ~(ctrl >> 7) will have the lowest bit set to zero for kEmpty and
-    // kDeleted. We lower all other bits and count number of trailing zeros.
-    constexpr uint64_t bits = 0x0101010101010101ULL;
-    return countr_zero((ctrl | ~(ctrl >> 7)) & bits) >> 3;
-  }
-
-  void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
-    constexpr uint64_t msbs = 0x8080808080808080ULL;
-    constexpr uint64_t lsbs = 0x0101010101010101ULL;
-    auto x = ctrl & msbs;
-    auto res = (~x + (x >> 7)) & ~lsbs;
-    little_endian::Store64(dst, res);
-  }
-
-  uint64_t ctrl;
-};
+        struct GroupPortableImpl
+        {
+            static constexpr size_t kWidth = 8;
+
+            explicit GroupPortableImpl(const ctrl_t* pos) :
+                ctrl(little_endian::Load64(pos))
+            {
+            }
+
+            BitMask<uint64_t, kWidth, 3> Match(h2_t hash) const
+            {
+                // For the technique, see:
+                // http://graphics.stanford.edu/~seander/bithacks.html##ValueInWord
+                // (Determine if a word has a byte equal to n).
+                //
+                // Caveat: there are false positives but:
+                // - they only occur if there is a real match
+                // - they never occur on ctrl_t::kEmpty, ctrl_t::kDeleted, ctrl_t::kSentinel
+                // - they will be handled gracefully by subsequent checks in code
+                //
+                // Example:
+                //   v = 0x1716151413121110
+                //   hash = 0x12
+                //   retval = (v - lsbs) & ~v & msbs = 0x0000000080800000
+                constexpr uint64_t msbs = 0x8080808080808080ULL;
+                constexpr uint64_t lsbs = 0x0101010101010101ULL;
+                auto x = ctrl ^ (lsbs * hash);
+                return BitMask<uint64_t, kWidth, 3>((x - lsbs) & ~x & msbs);
+            }
+
+            NonIterableBitMask<uint64_t, kWidth, 3> MaskEmpty() const
+            {
+                constexpr uint64_t msbs = 0x8080808080808080ULL;
+                return NonIterableBitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 6)) & msbs);
+            }
+
+            NonIterableBitMask<uint64_t, kWidth, 3> MaskEmptyOrDeleted() const
+            {
+                constexpr uint64_t msbs = 0x8080808080808080ULL;
+                return NonIterableBitMask<uint64_t, kWidth, 3>((ctrl & (~ctrl << 7)) & msbs);
+            }
+
+            uint32_t CountLeadingEmptyOrDeleted() const
+            {
+                // ctrl | ~(ctrl >> 7) will have the lowest bit set to zero for kEmpty and
+                // kDeleted. We lower all other bits and count number of trailing zeros.
+                constexpr uint64_t bits = 0x0101010101010101ULL;
+                return countr_zero((ctrl | ~(ctrl >> 7)) & bits) >> 3;
+            }
+
+            void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const
+            {
+                constexpr uint64_t msbs = 0x8080808080808080ULL;
+                constexpr uint64_t lsbs = 0x0101010101010101ULL;
+                auto x = ctrl & msbs;
+                auto res = (~x + (x >> 7)) & ~lsbs;
+                little_endian::Store64(dst, res);
+            }
+
+            uint64_t ctrl;
+        };
 
 #ifdef ABSL_INTERNAL_HAVE_SSE2
-using Group = GroupSse2Impl;
+        using Group = GroupSse2Impl;
 #elif defined(ABSL_INTERNAL_HAVE_ARM_NEON) && defined(ABSL_IS_LITTLE_ENDIAN)
-using Group = GroupAArch64Impl;
+        using Group = GroupAArch64Impl;
 #else
-using Group = GroupPortableImpl;
+        using Group = GroupPortableImpl;
 #endif
 
-// Returns he number of "cloned control bytes".
-//
-// This is the number of control bytes that are present both at the beginning
-// of the control byte array and at the end, such that we can create a
-// `Group::kWidth`-width probe window starting from any control byte.
-constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
+        // Returns he number of "cloned control bytes".
+        //
+        // This is the number of control bytes that are present both at the beginning
+        // of the control byte array and at the end, such that we can create a
+        // `Group::kWidth`-width probe window starting from any control byte.
+        constexpr size_t NumClonedBytes()
+        {
+            return Group::kWidth - 1;
+        }
 
-template <class Policy, class Hash, class Eq, class Alloc>
-class raw_hash_set;
+        template<class Policy, class Hash, class Eq, class Alloc>
+        class raw_hash_set;
 
-// Returns whether `n` is a valid capacity (i.e., number of slots).
-//
-// A valid capacity is a non-zero integer `2^m - 1`.
-inline bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
-
-// Applies the following mapping to every byte in the control array:
-//   * kDeleted -> kEmpty
-//   * kEmpty -> kEmpty
-//   * _ -> kDeleted
-// PRECONDITION:
-//   IsValidCapacity(capacity)
-//   ctrl[capacity] == ctrl_t::kSentinel
-//   ctrl[i] != ctrl_t::kSentinel for all i < capacity
-void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity);
-
-// Converts `n` into the next valid capacity, per `IsValidCapacity`.
-inline size_t NormalizeCapacity(size_t n) {
-  return n ? ~size_t{} >> countl_zero(n) : 1;
-}
-
-// General notes on capacity/growth methods below:
-// - We use 7/8th as maximum load factor. For 16-wide groups, that gives an
-//   average of two empty slots per group.
-// - For (capacity+1) >= Group::kWidth, growth is 7/8*capacity.
-// - For (capacity+1) < Group::kWidth, growth == capacity. In this case, we
-//   never need to probe (the whole table fits in one group) so we don't need a
-//   load factor less than 1.
-
-// Given `capacity`, applies the load factor; i.e., it returns the maximum
-// number of values we should put into the table before a resizing rehash.
-inline size_t CapacityToGrowth(size_t capacity) {
-  assert(IsValidCapacity(capacity));
-  // `capacity*7/8`
-  if (Group::kWidth == 8 && capacity == 7) {
-    // x-x/8 does not work when x==7.
-    return 6;
-  }
-  return capacity - capacity / 8;
-}
-
-// Given `growth`, "unapplies" the load factor to find how large the capacity
-// should be to stay within the load factor.
-//
-// This might not be a valid capacity and `NormalizeCapacity()` should be
-// called on this.
-inline size_t GrowthToLowerboundCapacity(size_t growth) {
-  // `growth*8/7`
-  if (Group::kWidth == 8 && growth == 7) {
-    // x+(x-1)/7 does not work when x==7.
-    return 8;
-  }
-  return growth + static_cast<size_t>((static_cast<int64_t>(growth) - 1) / 7);
-}
-
-template <class InputIter>
-size_t SelectBucketCountForIterRange(InputIter first, InputIter last,
-                                     size_t bucket_count) {
-  if (bucket_count != 0) {
-    return bucket_count;
-  }
-  using InputIterCategory =
-      typename std::iterator_traits<InputIter>::iterator_category;
-  if (std::is_base_of<std::random_access_iterator_tag,
-                      InputIterCategory>::value) {
-    return GrowthToLowerboundCapacity(
-        static_cast<size_t>(std::distance(first, last)));
-  }
-  return 0;
-}
+        // Returns whether `n` is a valid capacity (i.e., number of slots).
+        //
+        // A valid capacity is a non-zero integer `2^m - 1`.
+        inline bool IsValidCapacity(size_t n)
+        {
+            return ((n + 1) & n) == 0 && n > 0;
+        }
+
+        // Applies the following mapping to every byte in the control array:
+        //   * kDeleted -> kEmpty
+        //   * kEmpty -> kEmpty
+        //   * _ -> kDeleted
+        // PRECONDITION:
+        //   IsValidCapacity(capacity)
+        //   ctrl[capacity] == ctrl_t::kSentinel
+        //   ctrl[i] != ctrl_t::kSentinel for all i < capacity
+        void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity);
+
+        // Converts `n` into the next valid capacity, per `IsValidCapacity`.
+        inline size_t NormalizeCapacity(size_t n)
+        {
+            return n ? ~size_t{} >> countl_zero(n) : 1;
+        }
+
+        // General notes on capacity/growth methods below:
+        // - We use 7/8th as maximum load factor. For 16-wide groups, that gives an
+        //   average of two empty slots per group.
+        // - For (capacity+1) >= Group::kWidth, growth is 7/8*capacity.
+        // - For (capacity+1) < Group::kWidth, growth == capacity. In this case, we
+        //   never need to probe (the whole table fits in one group) so we don't need a
+        //   load factor less than 1.
+
+        // Given `capacity`, applies the load factor; i.e., it returns the maximum
+        // number of values we should put into the table before a resizing rehash.
+        inline size_t CapacityToGrowth(size_t capacity)
+        {
+            assert(IsValidCapacity(capacity));
+            // `capacity*7/8`
+            if (Group::kWidth == 8 && capacity == 7)
+            {
+                // x-x/8 does not work when x==7.
+                return 6;
+            }
+            return capacity - capacity / 8;
+        }
+
+        // Given `growth`, "unapplies" the load factor to find how large the capacity
+        // should be to stay within the load factor.
+        //
+        // This might not be a valid capacity and `NormalizeCapacity()` should be
+        // called on this.
+        inline size_t GrowthToLowerboundCapacity(size_t growth)
+        {
+            // `growth*8/7`
+            if (Group::kWidth == 8 && growth == 7)
+            {
+                // x+(x-1)/7 does not work when x==7.
+                return 8;
+            }
+            return growth + static_cast<size_t>((static_cast<int64_t>(growth) - 1) / 7);
+        }
+
+        template<class InputIter>
+        size_t SelectBucketCountForIterRange(InputIter first, InputIter last, size_t bucket_count)
+        {
+            if (bucket_count != 0)
+            {
+                return bucket_count;
+            }
+            using InputIterCategory =
+                typename std::iterator_traits<InputIter>::iterator_category;
+            if (std::is_base_of<std::random_access_iterator_tag, InputIterCategory>::value)
+            {
+                return GrowthToLowerboundCapacity(
+                    static_cast<size_t>(std::distance(first, last))
+                );
+            }
+            return 0;
+        }
 
 #define ABSL_INTERNAL_ASSERT_IS_FULL(ctrl, msg) \
-  ABSL_HARDENING_ASSERT((ctrl != nullptr && IsFull(*ctrl)) && msg)
-
-inline void AssertIsValid(ctrl_t* ctrl) {
-  ABSL_HARDENING_ASSERT(
-      (ctrl == nullptr || IsFull(*ctrl)) &&
-      "Invalid operation on iterator. The element might have "
-      "been erased, the table might have rehashed, or this may "
-      "be an end() iterator.");
-}
-
-struct FindInfo {
-  size_t offset;
-  size_t probe_length;
-};
-
-// Whether a table is "small". A small table fits entirely into a probing
-// group, i.e., has a capacity < `Group::kWidth`.
-//
-// In small mode we are able to use the whole capacity. The extra control
-// bytes give us at least one "empty" control byte to stop the iteration.
-// This is important to make 1 a valid capacity.
-//
-// In small mode only the first `capacity` control bytes after the sentinel
-// are valid. The rest contain dummy ctrl_t::kEmpty values that do not
-// represent a real slot. This is important to take into account on
-// `find_first_non_full()`, where we never try
-// `ShouldInsertBackwards()` for small tables.
-inline bool is_small(size_t capacity) { return capacity < Group::kWidth - 1; }
-
-// Begins a probing operation on `ctrl`, using `hash`.
-inline probe_seq<Group::kWidth> probe(const ctrl_t* ctrl, size_t hash,
-                                      size_t capacity) {
-  return probe_seq<Group::kWidth>(H1(hash, ctrl), capacity);
-}
-
-// Probes an array of control bits using a probe sequence derived from `hash`,
-// and returns the offset corresponding to the first deleted or empty slot.
-//
-// Behavior when the entire table is full is undefined.
-//
-// NOTE: this function must work with tables having both empty and deleted
-// slots in the same group. Such tables appear during `erase()`.
-template <typename = void>
-inline FindInfo find_first_non_full(const ctrl_t* ctrl, size_t hash,
-                                    size_t capacity) {
-  auto seq = probe(ctrl, hash, capacity);
-  while (true) {
-    Group g{ctrl + seq.offset()};
-    auto mask = g.MaskEmptyOrDeleted();
-    if (mask) {
+    ABSL_HARDENING_ASSERT((ctrl != nullptr && IsFull(*ctrl)) && msg)
+
+        inline void AssertIsValid(ctrl_t* ctrl)
+        {
+            ABSL_HARDENING_ASSERT(
+                (ctrl == nullptr || IsFull(*ctrl)) &&
+                "Invalid operation on iterator. The element might have "
+                "been erased, the table might have rehashed, or this may "
+                "be an end() iterator."
+            );
+        }
+
+        struct FindInfo
+        {
+            size_t offset;
+            size_t probe_length;
+        };
+
+        // Whether a table is "small". A small table fits entirely into a probing
+        // group, i.e., has a capacity < `Group::kWidth`.
+        //
+        // In small mode we are able to use the whole capacity. The extra control
+        // bytes give us at least one "empty" control byte to stop the iteration.
+        // This is important to make 1 a valid capacity.
+        //
+        // In small mode only the first `capacity` control bytes after the sentinel
+        // are valid. The rest contain dummy ctrl_t::kEmpty values that do not
+        // represent a real slot. This is important to take into account on
+        // `find_first_non_full()`, where we never try
+        // `ShouldInsertBackwards()` for small tables.
+        inline bool is_small(size_t capacity)
+        {
+            return capacity < Group::kWidth - 1;
+        }
+
+        // Begins a probing operation on `ctrl`, using `hash`.
+        inline probe_seq<Group::kWidth> probe(const ctrl_t* ctrl, size_t hash, size_t capacity)
+        {
+            return probe_seq<Group::kWidth>(H1(hash, ctrl), capacity);
+        }
+
+        // Probes an array of control bits using a probe sequence derived from `hash`,
+        // and returns the offset corresponding to the first deleted or empty slot.
+        //
+        // Behavior when the entire table is full is undefined.
+        //
+        // NOTE: this function must work with tables having both empty and deleted
+        // slots in the same group. Such tables appear during `erase()`.
+        template<typename = void>
+        inline FindInfo find_first_non_full(const ctrl_t* ctrl, size_t hash, size_t capacity)
+        {
+            auto seq = probe(ctrl, hash, capacity);
+            while (true)
+            {
+                Group g{ctrl + seq.offset()};
+                auto mask = g.MaskEmptyOrDeleted();
+                if (mask)
+                {
 #if !defined(NDEBUG)
-      // We want to add entropy even when ASLR is not enabled.
-      // In debug build we will randomly insert in either the front or back of
-      // the group.
-      // TODO(kfm,sbenza): revisit after we do unconditional mixing
-      if (!is_small(capacity) && ShouldInsertBackwards(hash, ctrl)) {
-        return {seq.offset(mask.HighestBitSet()), seq.index()};
-      }
+                    // We want to add entropy even when ASLR is not enabled.
+                    // In debug build we will randomly insert in either the front or back of
+                    // the group.
+                    // TODO(kfm,sbenza): revisit after we do unconditional mixing
+                    if (!is_small(capacity) && ShouldInsertBackwards(hash, ctrl))
+                    {
+                        return {seq.offset(mask.HighestBitSet()), seq.index()};
+                    }
 #endif
-      return {seq.offset(mask.LowestBitSet()), seq.index()};
-    }
-    seq.next();
-    assert(seq.index() <= capacity && "full table!");
-  }
-}
-
-// Extern template for inline function keep possibility of inlining.
-// When compiler decided to not inline, no symbols will be added to the
-// corresponding translation unit.
-extern template FindInfo find_first_non_full(const ctrl_t*, size_t, size_t);
-
-// Sets `ctrl` to `{kEmpty, kSentinel, ..., kEmpty}`, marking the entire
-// array as marked as empty.
-inline void ResetCtrl(size_t capacity, ctrl_t* ctrl, const void* slot,
-                      size_t slot_size) {
-  std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
-              capacity + 1 + NumClonedBytes());
-  ctrl[capacity] = ctrl_t::kSentinel;
-  SanitizerPoisonMemoryRegion(slot, slot_size * capacity);
-}
-
-// Sets `ctrl[i]` to `h`.
-//
-// Unlike setting it directly, this function will perform bounds checks and
-// mirror the value to the cloned tail if necessary.
-inline void SetCtrl(size_t i, ctrl_t h, size_t capacity, ctrl_t* ctrl,
-                    const void* slot, size_t slot_size) {
-  assert(i < capacity);
-
-  auto* slot_i = static_cast<const char*>(slot) + i * slot_size;
-  if (IsFull(h)) {
-    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
-  } else {
-    SanitizerPoisonMemoryRegion(slot_i, slot_size);
-  }
-
-  ctrl[i] = h;
-  ctrl[((i - NumClonedBytes()) & capacity) + (NumClonedBytes() & capacity)] = h;
-}
-
-// Overload for setting to an occupied `h2_t` rather than a special `ctrl_t`.
-inline void SetCtrl(size_t i, h2_t h, size_t capacity, ctrl_t* ctrl,
-                    const void* slot, size_t slot_size) {
-  SetCtrl(i, static_cast<ctrl_t>(h), capacity, ctrl, slot, slot_size);
-}
-
-// Given the capacity of a table, computes the offset (from the start of the
-// backing allocation) at which the slots begin.
-inline size_t SlotOffset(size_t capacity, size_t slot_align) {
-  assert(IsValidCapacity(capacity));
-  const size_t num_control_bytes = capacity + 1 + NumClonedBytes();
-  return (num_control_bytes + slot_align - 1) & (~slot_align + 1);
-}
-
-// Given the capacity of a table, computes the total size of the backing
-// array.
-inline size_t AllocSize(size_t capacity, size_t slot_size, size_t slot_align) {
-  return SlotOffset(capacity, slot_align) + capacity * slot_size;
-}
-
-// A SwissTable.
-//
-// Policy: a policy defines how to perform different operations on
-// the slots of the hashtable (see hash_policy_traits.h for the full interface
-// of policy).
-//
-// Hash: a (possibly polymorphic) functor that hashes keys of the hashtable. The
-// functor should accept a key and return size_t as hash. For best performance
-// it is important that the hash function provides high entropy across all bits
-// of the hash.
-//
-// Eq: a (possibly polymorphic) functor that compares two keys for equality. It
-// should accept two (of possibly different type) keys and return a bool: true
-// if they are equal, false if they are not. If two keys compare equal, then
-// their hash values as defined by Hash MUST be equal.
-//
-// Allocator: an Allocator
-// [https://en.cppreference.com/w/cpp/named_req/Allocator] with which
-// the storage of the hashtable will be allocated and the elements will be
-// constructed and destroyed.
-template <class Policy, class Hash, class Eq, class Alloc>
-class raw_hash_set {
-  using PolicyTraits = hash_policy_traits<Policy>;
-  using KeyArgImpl =
-      KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
-
- public:
-  using init_type = typename PolicyTraits::init_type;
-  using key_type = typename PolicyTraits::key_type;
-  // TODO(sbenza): Hide slot_type as it is an implementation detail. Needs user
-  // code fixes!
-  using slot_type = typename PolicyTraits::slot_type;
-  using allocator_type = Alloc;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-  using hasher = Hash;
-  using key_equal = Eq;
-  using policy_type = Policy;
-  using value_type = typename PolicyTraits::value_type;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-  using pointer = typename absl::allocator_traits<
-      allocator_type>::template rebind_traits<value_type>::pointer;
-  using const_pointer = typename absl::allocator_traits<
-      allocator_type>::template rebind_traits<value_type>::const_pointer;
-
-  // Alias used for heterogeneous lookup functions.
-  // `key_arg<K>` evaluates to `K` when the functors are transparent and to
-  // `key_type` otherwise. It permits template argument deduction on `K` for the
-  // transparent case.
-  template <class K>
-  using key_arg = typename KeyArgImpl::template type<K, key_type>;
-
- private:
-  // Give an early error when key_type is not hashable/eq.
-  auto KeyTypeCanBeHashed(const Hash& h, const key_type& k) -> decltype(h(k));
-  auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k));
-
-  using AllocTraits = absl::allocator_traits<allocator_type>;
-  using SlotAlloc = typename absl::allocator_traits<
-      allocator_type>::template rebind_alloc<slot_type>;
-  using SlotAllocTraits = typename absl::allocator_traits<
-      allocator_type>::template rebind_traits<slot_type>;
-
-  static_assert(std::is_lvalue_reference<reference>::value,
-                "Policy::element() must return a reference");
-
-  template <typename T>
-  struct SameAsElementReference
-      : std::is_same<typename std::remove_cv<
-                         typename std::remove_reference<reference>::type>::type,
-                     typename std::remove_cv<
-                         typename std::remove_reference<T>::type>::type> {};
-
-  // An enabler for insert(T&&): T must be convertible to init_type or be the
-  // same as [cv] value_type [ref].
-  // Note: we separate SameAsElementReference into its own type to avoid using
-  // reference unless we need to. MSVC doesn't seem to like it in some
-  // cases.
-  template <class T>
-  using RequiresInsertable = typename std::enable_if<
-      absl::disjunction<std::is_convertible<T, init_type>,
-                        SameAsElementReference<T>>::value,
-      int>::type;
-
-  // RequiresNotInit is a workaround for gcc prior to 7.1.
-  // See https://godbolt.org/g/Y4xsUh.
-  template <class T>
-  using RequiresNotInit =
-      typename std::enable_if<!std::is_same<T, init_type>::value, int>::type;
-
-  template <class... Ts>
-  using IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>;
-
- public:
-  static_assert(std::is_same<pointer, value_type*>::value,
-                "Allocators with custom pointer types are not supported");
-  static_assert(std::is_same<const_pointer, const value_type*>::value,
-                "Allocators with custom pointer types are not supported");
-
-  class iterator {
-    friend class raw_hash_set;
-
-   public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = typename raw_hash_set::value_type;
-    using reference =
-        absl::conditional_t<PolicyTraits::constant_iterators::value,
-                            const value_type&, value_type&>;
-    using pointer = absl::remove_reference_t<reference>*;
-    using difference_type = typename raw_hash_set::difference_type;
-
-    iterator() {}
-
-    // PRECONDITION: not an end() iterator.
-    reference operator*() const {
-      ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_,
-                                   "operator*() called on invalid iterator.");
-      return PolicyTraits::element(slot_);
-    }
-
-    // PRECONDITION: not an end() iterator.
-    pointer operator->() const {
-      ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_,
-                                   "operator-> called on invalid iterator.");
-      return &operator*();
-    }
-
-    // PRECONDITION: not an end() iterator.
-    iterator& operator++() {
-      ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_,
-                                   "operator++ called on invalid iterator.");
-      ++ctrl_;
-      ++slot_;
-      skip_empty_or_deleted();
-      return *this;
-    }
-    // PRECONDITION: not an end() iterator.
-    iterator operator++(int) {
-      auto tmp = *this;
-      ++*this;
-      return tmp;
-    }
-
-    friend bool operator==(const iterator& a, const iterator& b) {
-      AssertIsValid(a.ctrl_);
-      AssertIsValid(b.ctrl_);
-      return a.ctrl_ == b.ctrl_;
-    }
-    friend bool operator!=(const iterator& a, const iterator& b) {
-      return !(a == b);
-    }
-
-   private:
-    iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {
-      // This assumption helps the compiler know that any non-end iterator is
-      // not equal to any end iterator.
-      ABSL_ASSUME(ctrl != nullptr);
-    }
-
-    // Fixes up `ctrl_` to point to a full by advancing it and `slot_` until
-    // they reach one.
-    //
-    // If a sentinel is reached, we null both of them out instead.
-    void skip_empty_or_deleted() {
-      while (IsEmptyOrDeleted(*ctrl_)) {
-        uint32_t shift = Group{ctrl_}.CountLeadingEmptyOrDeleted();
-        ctrl_ += shift;
-        slot_ += shift;
-      }
-      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
-    }
-
-    ctrl_t* ctrl_ = nullptr;
-    // To avoid uninitialized member warnings, put slot_ in an anonymous union.
-    // The member is not initialized on singleton and end iterators.
-    union {
-      slot_type* slot_;
-    };
-  };
-
-  class const_iterator {
-    friend class raw_hash_set;
-
-   public:
-    using iterator_category = typename iterator::iterator_category;
-    using value_type = typename raw_hash_set::value_type;
-    using reference = typename raw_hash_set::const_reference;
-    using pointer = typename raw_hash_set::const_pointer;
-    using difference_type = typename raw_hash_set::difference_type;
-
-    const_iterator() {}
-    // Implicit construction from iterator.
-    const_iterator(iterator i) : inner_(std::move(i)) {}
-
-    reference operator*() const { return *inner_; }
-    pointer operator->() const { return inner_.operator->(); }
-
-    const_iterator& operator++() {
-      ++inner_;
-      return *this;
-    }
-    const_iterator operator++(int) { return inner_++; }
-
-    friend bool operator==(const const_iterator& a, const const_iterator& b) {
-      return a.inner_ == b.inner_;
-    }
-    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
-      return !(a == b);
-    }
-
-   private:
-    const_iterator(const ctrl_t* ctrl, const slot_type* slot)
-        : inner_(const_cast<ctrl_t*>(ctrl), const_cast<slot_type*>(slot)) {}
-
-    iterator inner_;
-  };
-
-  using node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>;
-  using insert_return_type = InsertReturnType<iterator, node_type>;
-
-  raw_hash_set() noexcept(
-      std::is_nothrow_default_constructible<hasher>::value&&
-          std::is_nothrow_default_constructible<key_equal>::value&&
-              std::is_nothrow_default_constructible<allocator_type>::value) {}
-
-  explicit raw_hash_set(size_t bucket_count, const hasher& hash = hasher(),
-                        const key_equal& eq = key_equal(),
-                        const allocator_type& alloc = allocator_type())
-      : ctrl_(EmptyGroup()),
-        settings_(0, HashtablezInfoHandle(), hash, eq, alloc) {
-    if (bucket_count) {
-      capacity_ = NormalizeCapacity(bucket_count);
-      initialize_slots();
-    }
-  }
-
-  raw_hash_set(size_t bucket_count, const hasher& hash,
-               const allocator_type& alloc)
-      : raw_hash_set(bucket_count, hash, key_equal(), alloc) {}
-
-  raw_hash_set(size_t bucket_count, const allocator_type& alloc)
-      : raw_hash_set(bucket_count, hasher(), key_equal(), alloc) {}
-
-  explicit raw_hash_set(const allocator_type& alloc)
-      : raw_hash_set(0, hasher(), key_equal(), alloc) {}
-
-  template <class InputIter>
-  raw_hash_set(InputIter first, InputIter last, size_t bucket_count = 0,
-               const hasher& hash = hasher(), const key_equal& eq = key_equal(),
-               const allocator_type& alloc = allocator_type())
-      : raw_hash_set(SelectBucketCountForIterRange(first, last, bucket_count),
-                     hash, eq, alloc) {
-    insert(first, last);
-  }
-
-  template <class InputIter>
-  raw_hash_set(InputIter first, InputIter last, size_t bucket_count,
-               const hasher& hash, const allocator_type& alloc)
-      : raw_hash_set(first, last, bucket_count, hash, key_equal(), alloc) {}
-
-  template <class InputIter>
-  raw_hash_set(InputIter first, InputIter last, size_t bucket_count,
-               const allocator_type& alloc)
-      : raw_hash_set(first, last, bucket_count, hasher(), key_equal(), alloc) {}
-
-  template <class InputIter>
-  raw_hash_set(InputIter first, InputIter last, const allocator_type& alloc)
-      : raw_hash_set(first, last, 0, hasher(), key_equal(), alloc) {}
-
-  // Instead of accepting std::initializer_list<value_type> as the first
-  // argument like std::unordered_set<value_type> does, we have two overloads
-  // that accept std::initializer_list<T> and std::initializer_list<init_type>.
-  // This is advantageous for performance.
-  //
-  //   // Turns {"abc", "def"} into std::initializer_list<std::string>, then
-  //   // copies the strings into the set.
-  //   std::unordered_set<std::string> s = {"abc", "def"};
-  //
-  //   // Turns {"abc", "def"} into std::initializer_list<const char*>, then
-  //   // copies the strings into the set.
-  //   absl::flat_hash_set<std::string> s = {"abc", "def"};
-  //
-  // The same trick is used in insert().
-  //
-  // The enabler is necessary to prevent this constructor from triggering where
-  // the copy constructor is meant to be called.
-  //
-  //   absl::flat_hash_set<int> a, b{a};
-  //
-  // RequiresNotInit<T> is a workaround for gcc prior to 7.1.
-  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
-  raw_hash_set(std::initializer_list<T> init, size_t bucket_count = 0,
-               const hasher& hash = hasher(), const key_equal& eq = key_equal(),
-               const allocator_type& alloc = allocator_type())
-      : raw_hash_set(init.begin(), init.end(), bucket_count, hash, eq, alloc) {}
-
-  raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count = 0,
-               const hasher& hash = hasher(), const key_equal& eq = key_equal(),
-               const allocator_type& alloc = allocator_type())
-      : raw_hash_set(init.begin(), init.end(), bucket_count, hash, eq, alloc) {}
-
-  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
-  raw_hash_set(std::initializer_list<T> init, size_t bucket_count,
-               const hasher& hash, const allocator_type& alloc)
-      : raw_hash_set(init, bucket_count, hash, key_equal(), alloc) {}
-
-  raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count,
-               const hasher& hash, const allocator_type& alloc)
-      : raw_hash_set(init, bucket_count, hash, key_equal(), alloc) {}
-
-  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
-  raw_hash_set(std::initializer_list<T> init, size_t bucket_count,
-               const allocator_type& alloc)
-      : raw_hash_set(init, bucket_count, hasher(), key_equal(), alloc) {}
-
-  raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count,
-               const allocator_type& alloc)
-      : raw_hash_set(init, bucket_count, hasher(), key_equal(), alloc) {}
-
-  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
-  raw_hash_set(std::initializer_list<T> init, const allocator_type& alloc)
-      : raw_hash_set(init, 0, hasher(), key_equal(), alloc) {}
-
-  raw_hash_set(std::initializer_list<init_type> init,
-               const allocator_type& alloc)
-      : raw_hash_set(init, 0, hasher(), key_equal(), alloc) {}
-
-  raw_hash_set(const raw_hash_set& that)
-      : raw_hash_set(that, AllocTraits::select_on_container_copy_construction(
-                               that.alloc_ref())) {}
-
-  raw_hash_set(const raw_hash_set& that, const allocator_type& a)
-      : raw_hash_set(0, that.hash_ref(), that.eq_ref(), a) {
-    reserve(that.size());
-    // Because the table is guaranteed to be empty, we can do something faster
-    // than a full `insert`.
-    for (const auto& v : that) {
-      const size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, v);
-      auto target = find_first_non_full(ctrl_, hash, capacity_);
-      SetCtrl(target.offset, H2(hash), capacity_, ctrl_, slots_,
-              sizeof(slot_type));
-      emplace_at(target.offset, v);
-      infoz().RecordInsert(hash, target.probe_length);
-    }
-    size_ = that.size();
-    growth_left() -= that.size();
-  }
-
-  raw_hash_set(raw_hash_set&& that) noexcept(
-      std::is_nothrow_copy_constructible<hasher>::value&&
-          std::is_nothrow_copy_constructible<key_equal>::value&&
-              std::is_nothrow_copy_constructible<allocator_type>::value)
-      : ctrl_(absl::exchange(that.ctrl_, EmptyGroup())),
-        slots_(absl::exchange(that.slots_, nullptr)),
-        size_(absl::exchange(that.size_, 0)),
-        capacity_(absl::exchange(that.capacity_, 0)),
-        // Hash, equality and allocator are copied instead of moved because
-        // `that` must be left valid. If Hash is std::function<Key>, moving it
-        // would create a nullptr functor that cannot be called.
-        settings_(absl::exchange(that.growth_left(), 0),
-                  absl::exchange(that.infoz(), HashtablezInfoHandle()),
-                  that.hash_ref(), that.eq_ref(), that.alloc_ref()) {}
-
-  raw_hash_set(raw_hash_set&& that, const allocator_type& a)
-      : ctrl_(EmptyGroup()),
-        slots_(nullptr),
-        size_(0),
-        capacity_(0),
-        settings_(0, HashtablezInfoHandle(), that.hash_ref(), that.eq_ref(),
-                  a) {
-    if (a == that.alloc_ref()) {
-      std::swap(ctrl_, that.ctrl_);
-      std::swap(slots_, that.slots_);
-      std::swap(size_, that.size_);
-      std::swap(capacity_, that.capacity_);
-      std::swap(growth_left(), that.growth_left());
-      std::swap(infoz(), that.infoz());
-    } else {
-      reserve(that.size());
-      // Note: this will copy elements of dense_set and unordered_set instead of
-      // moving them. This can be fixed if it ever becomes an issue.
-      for (auto& elem : that) insert(std::move(elem));
-    }
-  }
-
-  raw_hash_set& operator=(const raw_hash_set& that) {
-    raw_hash_set tmp(that,
-                     AllocTraits::propagate_on_container_copy_assignment::value
-                         ? that.alloc_ref()
-                         : alloc_ref());
-    swap(tmp);
-    return *this;
-  }
-
-  raw_hash_set& operator=(raw_hash_set&& that) noexcept(
-      absl::allocator_traits<allocator_type>::is_always_equal::value&&
-          std::is_nothrow_move_assignable<hasher>::value&&
-              std::is_nothrow_move_assignable<key_equal>::value) {
-    // TODO(sbenza): We should only use the operations from the noexcept clause
-    // to make sure we actually adhere to that contract.
-    return move_assign(
-        std::move(that),
-        typename AllocTraits::propagate_on_container_move_assignment());
-  }
-
-  ~raw_hash_set() { destroy_slots(); }
-
-  iterator begin() {
-    auto it = iterator_at(0);
-    it.skip_empty_or_deleted();
-    return it;
-  }
-  iterator end() { return {}; }
-
-  const_iterator begin() const {
-    return const_cast<raw_hash_set*>(this)->begin();
-  }
-  const_iterator end() const { return {}; }
-  const_iterator cbegin() const { return begin(); }
-  const_iterator cend() const { return end(); }
-
-  bool empty() const { return !size(); }
-  size_t size() const { return size_; }
-  size_t capacity() const { return capacity_; }
-  size_t max_size() const { return (std::numeric_limits<size_t>::max)(); }
-
-  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
-    // Iterating over this container is O(bucket_count()). When bucket_count()
-    // is much greater than size(), iteration becomes prohibitively expensive.
-    // For clear() it is more important to reuse the allocated array when the
-    // container is small because allocation takes comparatively long time
-    // compared to destruction of the elements of the container. So we pick the
-    // largest bucket_count() threshold for which iteration is still fast and
-    // past that we simply deallocate the array.
-    if (capacity_ > 127) {
-      destroy_slots();
-
-      infoz().RecordClearedReservation();
-    } else if (capacity_) {
-      for (size_t i = 0; i != capacity_; ++i) {
-        if (IsFull(ctrl_[i])) {
-          PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+                    return {seq.offset(mask.LowestBitSet()), seq.index()};
+                }
+                seq.next();
+                assert(seq.index() <= capacity && "full table!");
+            }
+        }
+
+        // Extern template for inline function keep possibility of inlining.
+        // When compiler decided to not inline, no symbols will be added to the
+        // corresponding translation unit.
+        extern template FindInfo find_first_non_full(const ctrl_t*, size_t, size_t);
+
+        // Sets `ctrl` to `{kEmpty, kSentinel, ..., kEmpty}`, marking the entire
+        // array as marked as empty.
+        inline void ResetCtrl(size_t capacity, ctrl_t* ctrl, const void* slot, size_t slot_size)
+        {
+            std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty), capacity + 1 + NumClonedBytes());
+            ctrl[capacity] = ctrl_t::kSentinel;
+            SanitizerPoisonMemoryRegion(slot, slot_size * capacity);
         }
-      }
-      size_ = 0;
-      ResetCtrl(capacity_, ctrl_, slots_, sizeof(slot_type));
-      reset_growth_left();
-    }
-    assert(empty());
-    infoz().RecordStorageChanged(0, capacity_);
-  }
-
-  // This overload kicks in when the argument is an rvalue of insertable and
-  // decomposable type other than init_type.
-  //
-  //   flat_hash_map<std::string, int> m;
-  //   m.insert(std::make_pair("abc", 42));
-  // TODO(cheshire): A type alias T2 is introduced as a workaround for the nvcc
-  // bug.
-  template <class T, RequiresInsertable<T> = 0, class T2 = T,
-            typename std::enable_if<IsDecomposable<T2>::value, int>::type = 0,
-            T* = nullptr>
-  std::pair<iterator, bool> insert(T&& value) {
-    return emplace(std::forward<T>(value));
-  }
-
-  // This overload kicks in when the argument is a bitfield or an lvalue of
-  // insertable and decomposable type.
-  //
-  //   union { int n : 1; };
-  //   flat_hash_set<int> s;
-  //   s.insert(n);
-  //
-  //   flat_hash_set<std::string> s;
-  //   const char* p = "hello";
-  //   s.insert(p);
-  //
-  // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
-  // RequiresInsertable<T> with RequiresInsertable<const T&>.
-  // We are hitting this bug: https://godbolt.org/g/1Vht4f.
-  template <
-      class T, RequiresInsertable<T> = 0,
-      typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
-  std::pair<iterator, bool> insert(const T& value) {
-    return emplace(value);
-  }
-
-  // This overload kicks in when the argument is an rvalue of init_type. Its
-  // purpose is to handle brace-init-list arguments.
-  //
-  //   flat_hash_map<std::string, int> s;
-  //   s.insert({"abc", 42});
-  std::pair<iterator, bool> insert(init_type&& value) {
-    return emplace(std::move(value));
-  }
-
-  // TODO(cheshire): A type alias T2 is introduced as a workaround for the nvcc
-  // bug.
-  template <class T, RequiresInsertable<T> = 0, class T2 = T,
-            typename std::enable_if<IsDecomposable<T2>::value, int>::type = 0,
-            T* = nullptr>
-  iterator insert(const_iterator, T&& value) {
-    return insert(std::forward<T>(value)).first;
-  }
-
-  // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
-  // RequiresInsertable<T> with RequiresInsertable<const T&>.
-  // We are hitting this bug: https://godbolt.org/g/1Vht4f.
-  template <
-      class T, RequiresInsertable<T> = 0,
-      typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
-  iterator insert(const_iterator, const T& value) {
-    return insert(value).first;
-  }
-
-  iterator insert(const_iterator, init_type&& value) {
-    return insert(std::move(value)).first;
-  }
-
-  template <class InputIt>
-  void insert(InputIt first, InputIt last) {
-    for (; first != last; ++first) emplace(*first);
-  }
-
-  template <class T, RequiresNotInit<T> = 0, RequiresInsertable<const T&> = 0>
-  void insert(std::initializer_list<T> ilist) {
-    insert(ilist.begin(), ilist.end());
-  }
-
-  void insert(std::initializer_list<init_type> ilist) {
-    insert(ilist.begin(), ilist.end());
-  }
-
-  insert_return_type insert(node_type&& node) {
-    if (!node) return {end(), false, node_type()};
-    const auto& elem = PolicyTraits::element(CommonAccess::GetSlot(node));
-    auto res = PolicyTraits::apply(
-        InsertSlot<false>{*this, std::move(*CommonAccess::GetSlot(node))},
-        elem);
-    if (res.second) {
-      CommonAccess::Reset(&node);
-      return {res.first, true, node_type()};
-    } else {
-      return {res.first, false, std::move(node)};
-    }
-  }
-
-  iterator insert(const_iterator, node_type&& node) {
-    auto res = insert(std::move(node));
-    node = std::move(res.node);
-    return res.position;
-  }
-
-  // This overload kicks in if we can deduce the key from args. This enables us
-  // to avoid constructing value_type if an entry with the same key already
-  // exists.
-  //
-  // For example:
-  //
-  //   flat_hash_map<std::string, std::string> m = {{"abc", "def"}};
-  //   // Creates no std::string copies and makes no heap allocations.
-  //   m.emplace("abc", "xyz");
-  template <class... Args, typename std::enable_if<
-                               IsDecomposable<Args...>::value, int>::type = 0>
-  std::pair<iterator, bool> emplace(Args&&... args) {
-    return PolicyTraits::apply(EmplaceDecomposable{*this},
-                               std::forward<Args>(args)...);
-  }
-
-  // This overload kicks in if we cannot deduce the key from args. It constructs
-  // value_type unconditionally and then either moves it into the table or
-  // destroys.
-  template <class... Args, typename std::enable_if<
-                               !IsDecomposable<Args...>::value, int>::type = 0>
-  std::pair<iterator, bool> emplace(Args&&... args) {
-    alignas(slot_type) unsigned char raw[sizeof(slot_type)];
-    slot_type* slot = reinterpret_cast<slot_type*>(&raw);
-
-    PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
-    const auto& elem = PolicyTraits::element(slot);
-    return PolicyTraits::apply(InsertSlot<true>{*this, std::move(*slot)}, elem);
-  }
-
-  template <class... Args>
-  iterator emplace_hint(const_iterator, Args&&... args) {
-    return emplace(std::forward<Args>(args)...).first;
-  }
-
-  // Extension API: support for lazy emplace.
-  //
-  // Looks up key in the table. If found, returns the iterator to the element.
-  // Otherwise calls `f` with one argument of type `raw_hash_set::constructor`.
-  //
-  // `f` must abide by several restrictions:
-  //  - it MUST call `raw_hash_set::constructor` with arguments as if a
-  //    `raw_hash_set::value_type` is constructed,
-  //  - it MUST NOT access the container before the call to
-  //    `raw_hash_set::constructor`, and
-  //  - it MUST NOT erase the lazily emplaced element.
-  // Doing any of these is undefined behavior.
-  //
-  // For example:
-  //
-  //   std::unordered_set<ArenaString> s;
-  //   // Makes ArenaStr even if "abc" is in the map.
-  //   s.insert(ArenaString(&arena, "abc"));
-  //
-  //   flat_hash_set<ArenaStr> s;
-  //   // Makes ArenaStr only if "abc" is not in the map.
-  //   s.lazy_emplace("abc", [&](const constructor& ctor) {
-  //     ctor(&arena, "abc");
-  //   });
-  //
-  // WARNING: This API is currently experimental. If there is a way to implement
-  // the same thing with the rest of the API, prefer that.
-  class constructor {
-    friend class raw_hash_set;
-
-   public:
-    template <class... Args>
-    void operator()(Args&&... args) const {
-      assert(*slot_);
-      PolicyTraits::construct(alloc_, *slot_, std::forward<Args>(args)...);
-      *slot_ = nullptr;
-    }
-
-   private:
-    constructor(allocator_type* a, slot_type** slot) : alloc_(a), slot_(slot) {}
-
-    allocator_type* alloc_;
-    slot_type** slot_;
-  };
-
-  template <class K = key_type, class F>
-  iterator lazy_emplace(const key_arg<K>& key, F&& f) {
-    auto res = find_or_prepare_insert(key);
-    if (res.second) {
-      slot_type* slot = slots_ + res.first;
-      std::forward<F>(f)(constructor(&alloc_ref(), &slot));
-      assert(!slot);
-    }
-    return iterator_at(res.first);
-  }
-
-  // Extension API: support for heterogeneous keys.
-  //
-  //   std::unordered_set<std::string> s;
-  //   // Turns "abc" into std::string.
-  //   s.erase("abc");
-  //
-  //   flat_hash_set<std::string> s;
-  //   // Uses "abc" directly without copying it into std::string.
-  //   s.erase("abc");
-  template <class K = key_type>
-  size_type erase(const key_arg<K>& key) {
-    auto it = find(key);
-    if (it == end()) return 0;
-    erase(it);
-    return 1;
-  }
-
-  // Erases the element pointed to by `it`.  Unlike `std::unordered_set::erase`,
-  // this method returns void to reduce algorithmic complexity to O(1).  The
-  // iterator is invalidated, so any increment should be done before calling
-  // erase.  In order to erase while iterating across a map, use the following
-  // idiom (which also works for standard containers):
-  //
-  // for (auto it = m.begin(), end = m.end(); it != end;) {
-  //   // `erase()` will invalidate `it`, so advance `it` first.
-  //   auto copy_it = it++;
-  //   if (<pred>) {
-  //     m.erase(copy_it);
-  //   }
-  // }
-  void erase(const_iterator cit) { erase(cit.inner_); }
-
-  // This overload is necessary because otherwise erase<K>(const K&) would be
-  // a better match if non-const iterator is passed as an argument.
-  void erase(iterator it) {
-    ABSL_INTERNAL_ASSERT_IS_FULL(it.ctrl_,
-                                 "erase() called on invalid iterator.");
-    PolicyTraits::destroy(&alloc_ref(), it.slot_);
-    erase_meta_only(it);
-  }
-
-  iterator erase(const_iterator first, const_iterator last) {
-    while (first != last) {
-      erase(first++);
-    }
-    return last.inner_;
-  }
-
-  // Moves elements from `src` into `this`.
-  // If the element already exists in `this`, it is left unmodified in `src`.
-  template <typename H, typename E>
-  void merge(raw_hash_set<Policy, H, E, Alloc>& src) {  // NOLINT
-    assert(this != &src);
-    for (auto it = src.begin(), e = src.end(); it != e;) {
-      auto next = std::next(it);
-      if (PolicyTraits::apply(InsertSlot<false>{*this, std::move(*it.slot_)},
-                              PolicyTraits::element(it.slot_))
-              .second) {
-        src.erase_meta_only(it);
-      }
-      it = next;
-    }
-  }
-
-  template <typename H, typename E>
-  void merge(raw_hash_set<Policy, H, E, Alloc>&& src) {
-    merge(src);
-  }
-
-  node_type extract(const_iterator position) {
-    ABSL_INTERNAL_ASSERT_IS_FULL(position.inner_.ctrl_,
-                                 "extract() called on invalid iterator.");
-    auto node =
-        CommonAccess::Transfer<node_type>(alloc_ref(), position.inner_.slot_);
-    erase_meta_only(position);
-    return node;
-  }
-
-  template <
-      class K = key_type,
-      typename std::enable_if<!std::is_same<K, iterator>::value, int>::type = 0>
-  node_type extract(const key_arg<K>& key) {
-    auto it = find(key);
-    return it == end() ? node_type() : extract(const_iterator{it});
-  }
-
-  void swap(raw_hash_set& that) noexcept(
-      IsNoThrowSwappable<hasher>() && IsNoThrowSwappable<key_equal>() &&
-      IsNoThrowSwappable<allocator_type>(
-          typename AllocTraits::propagate_on_container_swap{})) {
-    using std::swap;
-    swap(ctrl_, that.ctrl_);
-    swap(slots_, that.slots_);
-    swap(size_, that.size_);
-    swap(capacity_, that.capacity_);
-    swap(growth_left(), that.growth_left());
-    swap(hash_ref(), that.hash_ref());
-    swap(eq_ref(), that.eq_ref());
-    swap(infoz(), that.infoz());
-    SwapAlloc(alloc_ref(), that.alloc_ref(),
-              typename AllocTraits::propagate_on_container_swap{});
-  }
-
-  void rehash(size_t n) {
-    if (n == 0 && capacity_ == 0) return;
-    if (n == 0 && size_ == 0) {
-      destroy_slots();
-      infoz().RecordStorageChanged(0, 0);
-      infoz().RecordClearedReservation();
-      return;
-    }
-
-    // bitor is a faster way of doing `max` here. We will round up to the next
-    // power-of-2-minus-1, so bitor is good enough.
-    auto m = NormalizeCapacity(n | GrowthToLowerboundCapacity(size()));
-    // n == 0 unconditionally rehashes as per the standard.
-    if (n == 0 || m > capacity_) {
-      resize(m);
-
-      // This is after resize, to ensure that we have completed the allocation
-      // and have potentially sampled the hashtable.
-      infoz().RecordReservation(n);
-    }
-  }
-
-  void reserve(size_t n) {
-    if (n > size() + growth_left()) {
-      size_t m = GrowthToLowerboundCapacity(n);
-      resize(NormalizeCapacity(m));
-
-      // This is after resize, to ensure that we have completed the allocation
-      // and have potentially sampled the hashtable.
-      infoz().RecordReservation(n);
-    }
-  }
-
-  // Extension API: support for heterogeneous keys.
-  //
-  //   std::unordered_set<std::string> s;
-  //   // Turns "abc" into std::string.
-  //   s.count("abc");
-  //
-  //   ch_set<std::string> s;
-  //   // Uses "abc" directly without copying it into std::string.
-  //   s.count("abc");
-  template <class K = key_type>
-  size_t count(const key_arg<K>& key) const {
-    return find(key) == end() ? 0 : 1;
-  }
-
-  // Issues CPU prefetch instructions for the memory needed to find or insert
-  // a key.  Like all lookup functions, this support heterogeneous keys.
-  //
-  // NOTE: This is a very low level operation and should not be used without
-  // specific benchmarks indicating its importance.
-  template <class K = key_type>
-  void prefetch(const key_arg<K>& key) const {
-    (void)key;
-    // Avoid probing if we won't be able to prefetch the addresses received.
+
+        // Sets `ctrl[i]` to `h`.
+        //
+        // Unlike setting it directly, this function will perform bounds checks and
+        // mirror the value to the cloned tail if necessary.
+        inline void SetCtrl(size_t i, ctrl_t h, size_t capacity, ctrl_t* ctrl, const void* slot, size_t slot_size)
+        {
+            assert(i < capacity);
+
+            auto* slot_i = static_cast<const char*>(slot) + i * slot_size;
+            if (IsFull(h))
+            {
+                SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
+            }
+            else
+            {
+                SanitizerPoisonMemoryRegion(slot_i, slot_size);
+            }
+
+            ctrl[i] = h;
+            ctrl[((i - NumClonedBytes()) & capacity) + (NumClonedBytes() & capacity)] = h;
+        }
+
+        // Overload for setting to an occupied `h2_t` rather than a special `ctrl_t`.
+        inline void SetCtrl(size_t i, h2_t h, size_t capacity, ctrl_t* ctrl, const void* slot, size_t slot_size)
+        {
+            SetCtrl(i, static_cast<ctrl_t>(h), capacity, ctrl, slot, slot_size);
+        }
+
+        // Given the capacity of a table, computes the offset (from the start of the
+        // backing allocation) at which the slots begin.
+        inline size_t SlotOffset(size_t capacity, size_t slot_align)
+        {
+            assert(IsValidCapacity(capacity));
+            const size_t num_control_bytes = capacity + 1 + NumClonedBytes();
+            return (num_control_bytes + slot_align - 1) & (~slot_align + 1);
+        }
+
+        // Given the capacity of a table, computes the total size of the backing
+        // array.
+        inline size_t AllocSize(size_t capacity, size_t slot_size, size_t slot_align)
+        {
+            return SlotOffset(capacity, slot_align) + capacity * slot_size;
+        }
+
+        // A SwissTable.
+        //
+        // Policy: a policy defines how to perform different operations on
+        // the slots of the hashtable (see hash_policy_traits.h for the full interface
+        // of policy).
+        //
+        // Hash: a (possibly polymorphic) functor that hashes keys of the hashtable. The
+        // functor should accept a key and return size_t as hash. For best performance
+        // it is important that the hash function provides high entropy across all bits
+        // of the hash.
+        //
+        // Eq: a (possibly polymorphic) functor that compares two keys for equality. It
+        // should accept two (of possibly different type) keys and return a bool: true
+        // if they are equal, false if they are not. If two keys compare equal, then
+        // their hash values as defined by Hash MUST be equal.
+        //
+        // Allocator: an Allocator
+        // [https://en.cppreference.com/w/cpp/named_req/Allocator] with which
+        // the storage of the hashtable will be allocated and the elements will be
+        // constructed and destroyed.
+        template<class Policy, class Hash, class Eq, class Alloc>
+        class raw_hash_set
+        {
+            using PolicyTraits = hash_policy_traits<Policy>;
+            using KeyArgImpl =
+                KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
+
+        public:
+            using init_type = typename PolicyTraits::init_type;
+            using key_type = typename PolicyTraits::key_type;
+            // TODO(sbenza): Hide slot_type as it is an implementation detail. Needs user
+            // code fixes!
+            using slot_type = typename PolicyTraits::slot_type;
+            using allocator_type = Alloc;
+            using size_type = size_t;
+            using difference_type = ptrdiff_t;
+            using hasher = Hash;
+            using key_equal = Eq;
+            using policy_type = Policy;
+            using value_type = typename PolicyTraits::value_type;
+            using reference = value_type&;
+            using const_reference = const value_type&;
+            using pointer = typename absl::allocator_traits<
+                allocator_type>::template rebind_traits<value_type>::pointer;
+            using const_pointer = typename absl::allocator_traits<
+                allocator_type>::template rebind_traits<value_type>::const_pointer;
+
+            // Alias used for heterogeneous lookup functions.
+            // `key_arg<K>` evaluates to `K` when the functors are transparent and to
+            // `key_type` otherwise. It permits template argument deduction on `K` for the
+            // transparent case.
+            template<class K>
+            using key_arg = typename KeyArgImpl::template type<K, key_type>;
+
+        private:
+            // Give an early error when key_type is not hashable/eq.
+            auto KeyTypeCanBeHashed(const Hash& h, const key_type& k) -> decltype(h(k));
+            auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k));
+
+            using AllocTraits = absl::allocator_traits<allocator_type>;
+            using SlotAlloc = typename absl::allocator_traits<
+                allocator_type>::template rebind_alloc<slot_type>;
+            using SlotAllocTraits = typename absl::allocator_traits<
+                allocator_type>::template rebind_traits<slot_type>;
+
+            static_assert(std::is_lvalue_reference<reference>::value, "Policy::element() must return a reference");
+
+            template<typename T>
+            struct SameAsElementReference : std::is_same<typename std::remove_cv<typename std::remove_reference<reference>::type>::type, typename std::remove_cv<typename std::remove_reference<T>::type>::type>
+            {
+            };
+
+            // An enabler for insert(T&&): T must be convertible to init_type or be the
+            // same as [cv] value_type [ref].
+            // Note: we separate SameAsElementReference into its own type to avoid using
+            // reference unless we need to. MSVC doesn't seem to like it in some
+            // cases.
+            template<class T>
+            using RequiresInsertable = typename std::enable_if<
+                absl::disjunction<std::is_convertible<T, init_type>, SameAsElementReference<T>>::value,
+                int>::type;
+
+            // RequiresNotInit is a workaround for gcc prior to 7.1.
+            // See https://godbolt.org/g/Y4xsUh.
+            template<class T>
+            using RequiresNotInit =
+                typename std::enable_if<!std::is_same<T, init_type>::value, int>::type;
+
+            template<class... Ts>
+            using IsDecomposable = IsDecomposable<void, PolicyTraits, Hash, Eq, Ts...>;
+
+        public:
+            static_assert(std::is_same<pointer, value_type*>::value, "Allocators with custom pointer types are not supported");
+            static_assert(std::is_same<const_pointer, const value_type*>::value, "Allocators with custom pointer types are not supported");
+
+            class iterator
+            {
+                friend class raw_hash_set;
+
+            public:
+                using iterator_category = std::forward_iterator_tag;
+                using value_type = typename raw_hash_set::value_type;
+                using reference =
+                    absl::conditional_t<PolicyTraits::constant_iterators::value, const value_type&, value_type&>;
+                using pointer = absl::remove_reference_t<reference>*;
+                using difference_type = typename raw_hash_set::difference_type;
+
+                iterator()
+                {
+                }
+
+                // PRECONDITION: not an end() iterator.
+                reference operator*() const
+                {
+                    ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_, "operator*() called on invalid iterator.");
+                    return PolicyTraits::element(slot_);
+                }
+
+                // PRECONDITION: not an end() iterator.
+                pointer operator->() const
+                {
+                    ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_, "operator-> called on invalid iterator.");
+                    return &operator*();
+                }
+
+                // PRECONDITION: not an end() iterator.
+                iterator& operator++()
+                {
+                    ABSL_INTERNAL_ASSERT_IS_FULL(ctrl_, "operator++ called on invalid iterator.");
+                    ++ctrl_;
+                    ++slot_;
+                    skip_empty_or_deleted();
+                    return *this;
+                }
+                // PRECONDITION: not an end() iterator.
+                iterator operator++(int)
+                {
+                    auto tmp = *this;
+                    ++*this;
+                    return tmp;
+                }
+
+                friend bool operator==(const iterator& a, const iterator& b)
+                {
+                    AssertIsValid(a.ctrl_);
+                    AssertIsValid(b.ctrl_);
+                    return a.ctrl_ == b.ctrl_;
+                }
+                friend bool operator!=(const iterator& a, const iterator& b)
+                {
+                    return !(a == b);
+                }
+
+            private:
+                iterator(ctrl_t* ctrl, slot_type* slot) :
+                    ctrl_(ctrl),
+                    slot_(slot)
+                {
+                    // This assumption helps the compiler know that any non-end iterator is
+                    // not equal to any end iterator.
+                    ABSL_ASSUME(ctrl != nullptr);
+                }
+
+                // Fixes up `ctrl_` to point to a full by advancing it and `slot_` until
+                // they reach one.
+                //
+                // If a sentinel is reached, we null both of them out instead.
+                void skip_empty_or_deleted()
+                {
+                    while (IsEmptyOrDeleted(*ctrl_))
+                    {
+                        uint32_t shift = Group{ctrl_}.CountLeadingEmptyOrDeleted();
+                        ctrl_ += shift;
+                        slot_ += shift;
+                    }
+                    if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel))
+                        ctrl_ = nullptr;
+                }
+
+                ctrl_t* ctrl_ = nullptr;
+                // To avoid uninitialized member warnings, put slot_ in an anonymous union.
+                // The member is not initialized on singleton and end iterators.
+                union
+                {
+                    slot_type* slot_;
+                };
+            };
+
+            class const_iterator
+            {
+                friend class raw_hash_set;
+
+            public:
+                using iterator_category = typename iterator::iterator_category;
+                using value_type = typename raw_hash_set::value_type;
+                using reference = typename raw_hash_set::const_reference;
+                using pointer = typename raw_hash_set::const_pointer;
+                using difference_type = typename raw_hash_set::difference_type;
+
+                const_iterator()
+                {
+                }
+                // Implicit construction from iterator.
+                const_iterator(iterator i) :
+                    inner_(std::move(i))
+                {
+                }
+
+                reference operator*() const
+                {
+                    return *inner_;
+                }
+                pointer operator->() const
+                {
+                    return inner_.operator->();
+                }
+
+                const_iterator& operator++()
+                {
+                    ++inner_;
+                    return *this;
+                }
+                const_iterator operator++(int)
+                {
+                    return inner_++;
+                }
+
+                friend bool operator==(const const_iterator& a, const const_iterator& b)
+                {
+                    return a.inner_ == b.inner_;
+                }
+                friend bool operator!=(const const_iterator& a, const const_iterator& b)
+                {
+                    return !(a == b);
+                }
+
+            private:
+                const_iterator(const ctrl_t* ctrl, const slot_type* slot) :
+                    inner_(const_cast<ctrl_t*>(ctrl), const_cast<slot_type*>(slot))
+                {
+                }
+
+                iterator inner_;
+            };
+
+            using node_type = node_handle<Policy, hash_policy_traits<Policy>, Alloc>;
+            using insert_return_type = InsertReturnType<iterator, node_type>;
+
+            raw_hash_set() noexcept(
+                std::is_nothrow_default_constructible<hasher>::value&&
+                    std::is_nothrow_default_constructible<key_equal>::value&&
+                        std::is_nothrow_default_constructible<allocator_type>::value
+            )
+            {
+            }
+
+            explicit raw_hash_set(size_t bucket_count, const hasher& hash = hasher(), const key_equal& eq = key_equal(), const allocator_type& alloc = allocator_type()) :
+                ctrl_(EmptyGroup()),
+                settings_(0, HashtablezInfoHandle(), hash, eq, alloc)
+            {
+                if (bucket_count)
+                {
+                    capacity_ = NormalizeCapacity(bucket_count);
+                    initialize_slots();
+                }
+            }
+
+            raw_hash_set(size_t bucket_count, const hasher& hash, const allocator_type& alloc) :
+                raw_hash_set(bucket_count, hash, key_equal(), alloc)
+            {
+            }
+
+            raw_hash_set(size_t bucket_count, const allocator_type& alloc) :
+                raw_hash_set(bucket_count, hasher(), key_equal(), alloc)
+            {
+            }
+
+            explicit raw_hash_set(const allocator_type& alloc) :
+                raw_hash_set(0, hasher(), key_equal(), alloc)
+            {
+            }
+
+            template<class InputIter>
+            raw_hash_set(InputIter first, InputIter last, size_t bucket_count = 0, const hasher& hash = hasher(), const key_equal& eq = key_equal(), const allocator_type& alloc = allocator_type()) :
+                raw_hash_set(SelectBucketCountForIterRange(first, last, bucket_count), hash, eq, alloc)
+            {
+                insert(first, last);
+            }
+
+            template<class InputIter>
+            raw_hash_set(InputIter first, InputIter last, size_t bucket_count, const hasher& hash, const allocator_type& alloc) :
+                raw_hash_set(first, last, bucket_count, hash, key_equal(), alloc)
+            {
+            }
+
+            template<class InputIter>
+            raw_hash_set(InputIter first, InputIter last, size_t bucket_count, const allocator_type& alloc) :
+                raw_hash_set(first, last, bucket_count, hasher(), key_equal(), alloc)
+            {
+            }
+
+            template<class InputIter>
+            raw_hash_set(InputIter first, InputIter last, const allocator_type& alloc) :
+                raw_hash_set(first, last, 0, hasher(), key_equal(), alloc)
+            {
+            }
+
+            // Instead of accepting std::initializer_list<value_type> as the first
+            // argument like std::unordered_set<value_type> does, we have two overloads
+            // that accept std::initializer_list<T> and std::initializer_list<init_type>.
+            // This is advantageous for performance.
+            //
+            //   // Turns {"abc", "def"} into std::initializer_list<std::string>, then
+            //   // copies the strings into the set.
+            //   std::unordered_set<std::string> s = {"abc", "def"};
+            //
+            //   // Turns {"abc", "def"} into std::initializer_list<const char*>, then
+            //   // copies the strings into the set.
+            //   absl::flat_hash_set<std::string> s = {"abc", "def"};
+            //
+            // The same trick is used in insert().
+            //
+            // The enabler is necessary to prevent this constructor from triggering where
+            // the copy constructor is meant to be called.
+            //
+            //   absl::flat_hash_set<int> a, b{a};
+            //
+            // RequiresNotInit<T> is a workaround for gcc prior to 7.1.
+            template<class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+            raw_hash_set(std::initializer_list<T> init, size_t bucket_count = 0, const hasher& hash = hasher(), const key_equal& eq = key_equal(), const allocator_type& alloc = allocator_type()) :
+                raw_hash_set(init.begin(), init.end(), bucket_count, hash, eq, alloc)
+            {
+            }
+
+            raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count = 0, const hasher& hash = hasher(), const key_equal& eq = key_equal(), const allocator_type& alloc = allocator_type()) :
+                raw_hash_set(init.begin(), init.end(), bucket_count, hash, eq, alloc)
+            {
+            }
+
+            template<class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+            raw_hash_set(std::initializer_list<T> init, size_t bucket_count, const hasher& hash, const allocator_type& alloc) :
+                raw_hash_set(init, bucket_count, hash, key_equal(), alloc)
+            {
+            }
+
+            raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count, const hasher& hash, const allocator_type& alloc) :
+                raw_hash_set(init, bucket_count, hash, key_equal(), alloc)
+            {
+            }
+
+            template<class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+            raw_hash_set(std::initializer_list<T> init, size_t bucket_count, const allocator_type& alloc) :
+                raw_hash_set(init, bucket_count, hasher(), key_equal(), alloc)
+            {
+            }
+
+            raw_hash_set(std::initializer_list<init_type> init, size_t bucket_count, const allocator_type& alloc) :
+                raw_hash_set(init, bucket_count, hasher(), key_equal(), alloc)
+            {
+            }
+
+            template<class T, RequiresNotInit<T> = 0, RequiresInsertable<T> = 0>
+            raw_hash_set(std::initializer_list<T> init, const allocator_type& alloc) :
+                raw_hash_set(init, 0, hasher(), key_equal(), alloc)
+            {
+            }
+
+            raw_hash_set(std::initializer_list<init_type> init, const allocator_type& alloc) :
+                raw_hash_set(init, 0, hasher(), key_equal(), alloc)
+            {
+            }
+
+            raw_hash_set(const raw_hash_set& that) :
+                raw_hash_set(that, AllocTraits::select_on_container_copy_construction(that.alloc_ref()))
+            {
+            }
+
+            raw_hash_set(const raw_hash_set& that, const allocator_type& a) :
+                raw_hash_set(0, that.hash_ref(), that.eq_ref(), a)
+            {
+                reserve(that.size());
+                // Because the table is guaranteed to be empty, we can do something faster
+                // than a full `insert`.
+                for (const auto& v : that)
+                {
+                    const size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, v);
+                    auto target = find_first_non_full(ctrl_, hash, capacity_);
+                    SetCtrl(target.offset, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+                    emplace_at(target.offset, v);
+                    infoz().RecordInsert(hash, target.probe_length);
+                }
+                size_ = that.size();
+                growth_left() -= that.size();
+            }
+
+            raw_hash_set(raw_hash_set&& that) noexcept(
+                std::is_nothrow_copy_constructible<hasher>::value&&
+                    std::is_nothrow_copy_constructible<key_equal>::value&&
+                        std::is_nothrow_copy_constructible<allocator_type>::value
+            ) :
+                ctrl_(absl::exchange(that.ctrl_, EmptyGroup())),
+                slots_(absl::exchange(that.slots_, nullptr)),
+                size_(absl::exchange(that.size_, 0)),
+                capacity_(absl::exchange(that.capacity_, 0)),
+                // Hash, equality and allocator are copied instead of moved because
+                // `that` must be left valid. If Hash is std::function<Key>, moving it
+                // would create a nullptr functor that cannot be called.
+                settings_(absl::exchange(that.growth_left(), 0), absl::exchange(that.infoz(), HashtablezInfoHandle()), that.hash_ref(), that.eq_ref(), that.alloc_ref())
+            {
+            }
+
+            raw_hash_set(raw_hash_set&& that, const allocator_type& a) :
+                ctrl_(EmptyGroup()),
+                slots_(nullptr),
+                size_(0),
+                capacity_(0),
+                settings_(0, HashtablezInfoHandle(), that.hash_ref(), that.eq_ref(), a)
+            {
+                if (a == that.alloc_ref())
+                {
+                    std::swap(ctrl_, that.ctrl_);
+                    std::swap(slots_, that.slots_);
+                    std::swap(size_, that.size_);
+                    std::swap(capacity_, that.capacity_);
+                    std::swap(growth_left(), that.growth_left());
+                    std::swap(infoz(), that.infoz());
+                }
+                else
+                {
+                    reserve(that.size());
+                    // Note: this will copy elements of dense_set and unordered_set instead of
+                    // moving them. This can be fixed if it ever becomes an issue.
+                    for (auto& elem : that)
+                        insert(std::move(elem));
+                }
+            }
+
+            raw_hash_set& operator=(const raw_hash_set& that)
+            {
+                raw_hash_set tmp(that, AllocTraits::propagate_on_container_copy_assignment::value ? that.alloc_ref() : alloc_ref());
+                swap(tmp);
+                return *this;
+            }
+
+            raw_hash_set& operator=(raw_hash_set&& that) noexcept(
+                absl::allocator_traits<allocator_type>::is_always_equal::value&&
+                    std::is_nothrow_move_assignable<hasher>::value&&
+                        std::is_nothrow_move_assignable<key_equal>::value
+            )
+            {
+                // TODO(sbenza): We should only use the operations from the noexcept clause
+                // to make sure we actually adhere to that contract.
+                return move_assign(
+                    std::move(that),
+                    typename AllocTraits::propagate_on_container_move_assignment()
+                );
+            }
+
+            ~raw_hash_set()
+            {
+                destroy_slots();
+            }
+
+            iterator begin()
+            {
+                auto it = iterator_at(0);
+                it.skip_empty_or_deleted();
+                return it;
+            }
+            iterator end()
+            {
+                return {};
+            }
+
+            const_iterator begin() const
+            {
+                return const_cast<raw_hash_set*>(this)->begin();
+            }
+            const_iterator end() const
+            {
+                return {};
+            }
+            const_iterator cbegin() const
+            {
+                return begin();
+            }
+            const_iterator cend() const
+            {
+                return end();
+            }
+
+            bool empty() const
+            {
+                return !size();
+            }
+            size_t size() const
+            {
+                return size_;
+            }
+            size_t capacity() const
+            {
+                return capacity_;
+            }
+            size_t max_size() const
+            {
+                return (std::numeric_limits<size_t>::max)();
+            }
+
+            ABSL_ATTRIBUTE_REINITIALIZES void clear()
+            {
+                // Iterating over this container is O(bucket_count()). When bucket_count()
+                // is much greater than size(), iteration becomes prohibitively expensive.
+                // For clear() it is more important to reuse the allocated array when the
+                // container is small because allocation takes comparatively long time
+                // compared to destruction of the elements of the container. So we pick the
+                // largest bucket_count() threshold for which iteration is still fast and
+                // past that we simply deallocate the array.
+                if (capacity_ > 127)
+                {
+                    destroy_slots();
+
+                    infoz().RecordClearedReservation();
+                }
+                else if (capacity_)
+                {
+                    for (size_t i = 0; i != capacity_; ++i)
+                    {
+                        if (IsFull(ctrl_[i]))
+                        {
+                            PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+                        }
+                    }
+                    size_ = 0;
+                    ResetCtrl(capacity_, ctrl_, slots_, sizeof(slot_type));
+                    reset_growth_left();
+                }
+                assert(empty());
+                infoz().RecordStorageChanged(0, capacity_);
+            }
+
+            // This overload kicks in when the argument is an rvalue of insertable and
+            // decomposable type other than init_type.
+            //
+            //   flat_hash_map<std::string, int> m;
+            //   m.insert(std::make_pair("abc", 42));
+            // TODO(cheshire): A type alias T2 is introduced as a workaround for the nvcc
+            // bug.
+            template<class T, RequiresInsertable<T> = 0, class T2 = T, typename std::enable_if<IsDecomposable<T2>::value, int>::type = 0, T* = nullptr>
+            std::pair<iterator, bool> insert(T&& value)
+            {
+                return emplace(std::forward<T>(value));
+            }
+
+            // This overload kicks in when the argument is a bitfield or an lvalue of
+            // insertable and decomposable type.
+            //
+            //   union { int n : 1; };
+            //   flat_hash_set<int> s;
+            //   s.insert(n);
+            //
+            //   flat_hash_set<std::string> s;
+            //   const char* p = "hello";
+            //   s.insert(p);
+            //
+            // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+            // RequiresInsertable<T> with RequiresInsertable<const T&>.
+            // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+            template<
+                class T,
+                RequiresInsertable<T> = 0,
+                typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+            std::pair<iterator, bool> insert(const T& value)
+            {
+                return emplace(value);
+            }
+
+            // This overload kicks in when the argument is an rvalue of init_type. Its
+            // purpose is to handle brace-init-list arguments.
+            //
+            //   flat_hash_map<std::string, int> s;
+            //   s.insert({"abc", 42});
+            std::pair<iterator, bool> insert(init_type&& value)
+            {
+                return emplace(std::move(value));
+            }
+
+            // TODO(cheshire): A type alias T2 is introduced as a workaround for the nvcc
+            // bug.
+            template<class T, RequiresInsertable<T> = 0, class T2 = T, typename std::enable_if<IsDecomposable<T2>::value, int>::type = 0, T* = nullptr>
+            iterator insert(const_iterator, T&& value)
+            {
+                return insert(std::forward<T>(value)).first;
+            }
+
+            // TODO(romanp): Once we stop supporting gcc 5.1 and below, replace
+            // RequiresInsertable<T> with RequiresInsertable<const T&>.
+            // We are hitting this bug: https://godbolt.org/g/1Vht4f.
+            template<
+                class T,
+                RequiresInsertable<T> = 0,
+                typename std::enable_if<IsDecomposable<const T&>::value, int>::type = 0>
+            iterator insert(const_iterator, const T& value)
+            {
+                return insert(value).first;
+            }
+
+            iterator insert(const_iterator, init_type&& value)
+            {
+                return insert(std::move(value)).first;
+            }
+
+            template<class InputIt>
+            void insert(InputIt first, InputIt last)
+            {
+                for (; first != last; ++first)
+                    emplace(*first);
+            }
+
+            template<class T, RequiresNotInit<T> = 0, RequiresInsertable<const T&> = 0>
+            void insert(std::initializer_list<T> ilist)
+            {
+                insert(ilist.begin(), ilist.end());
+            }
+
+            void insert(std::initializer_list<init_type> ilist)
+            {
+                insert(ilist.begin(), ilist.end());
+            }
+
+            insert_return_type insert(node_type&& node)
+            {
+                if (!node)
+                    return {end(), false, node_type()};
+                const auto& elem = PolicyTraits::element(CommonAccess::GetSlot(node));
+                auto res = PolicyTraits::apply(
+                    InsertSlot<false>{*this, std::move(*CommonAccess::GetSlot(node))},
+                    elem
+                );
+                if (res.second)
+                {
+                    CommonAccess::Reset(&node);
+                    return {res.first, true, node_type()};
+                }
+                else
+                {
+                    return {res.first, false, std::move(node)};
+                }
+            }
+
+            iterator insert(const_iterator, node_type&& node)
+            {
+                auto res = insert(std::move(node));
+                node = std::move(res.node);
+                return res.position;
+            }
+
+            // This overload kicks in if we can deduce the key from args. This enables us
+            // to avoid constructing value_type if an entry with the same key already
+            // exists.
+            //
+            // For example:
+            //
+            //   flat_hash_map<std::string, std::string> m = {{"abc", "def"}};
+            //   // Creates no std::string copies and makes no heap allocations.
+            //   m.emplace("abc", "xyz");
+            template<class... Args, typename std::enable_if<IsDecomposable<Args...>::value, int>::type = 0>
+            std::pair<iterator, bool> emplace(Args&&... args)
+            {
+                return PolicyTraits::apply(EmplaceDecomposable{*this}, std::forward<Args>(args)...);
+            }
+
+            // This overload kicks in if we cannot deduce the key from args. It constructs
+            // value_type unconditionally and then either moves it into the table or
+            // destroys.
+            template<class... Args, typename std::enable_if<!IsDecomposable<Args...>::value, int>::type = 0>
+            std::pair<iterator, bool> emplace(Args&&... args)
+            {
+                alignas(slot_type) unsigned char raw[sizeof(slot_type)];
+                slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+
+                PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
+                const auto& elem = PolicyTraits::element(slot);
+                return PolicyTraits::apply(InsertSlot<true>{*this, std::move(*slot)}, elem);
+            }
+
+            template<class... Args>
+            iterator emplace_hint(const_iterator, Args&&... args)
+            {
+                return emplace(std::forward<Args>(args)...).first;
+            }
+
+            // Extension API: support for lazy emplace.
+            //
+            // Looks up key in the table. If found, returns the iterator to the element.
+            // Otherwise calls `f` with one argument of type `raw_hash_set::constructor`.
+            //
+            // `f` must abide by several restrictions:
+            //  - it MUST call `raw_hash_set::constructor` with arguments as if a
+            //    `raw_hash_set::value_type` is constructed,
+            //  - it MUST NOT access the container before the call to
+            //    `raw_hash_set::constructor`, and
+            //  - it MUST NOT erase the lazily emplaced element.
+            // Doing any of these is undefined behavior.
+            //
+            // For example:
+            //
+            //   std::unordered_set<ArenaString> s;
+            //   // Makes ArenaStr even if "abc" is in the map.
+            //   s.insert(ArenaString(&arena, "abc"));
+            //
+            //   flat_hash_set<ArenaStr> s;
+            //   // Makes ArenaStr only if "abc" is not in the map.
+            //   s.lazy_emplace("abc", [&](const constructor& ctor) {
+            //     ctor(&arena, "abc");
+            //   });
+            //
+            // WARNING: This API is currently experimental. If there is a way to implement
+            // the same thing with the rest of the API, prefer that.
+            class constructor
+            {
+                friend class raw_hash_set;
+
+            public:
+                template<class... Args>
+                void operator()(Args&&... args) const
+                {
+                    assert(*slot_);
+                    PolicyTraits::construct(alloc_, *slot_, std::forward<Args>(args)...);
+                    *slot_ = nullptr;
+                }
+
+            private:
+                constructor(allocator_type* a, slot_type** slot) :
+                    alloc_(a),
+                    slot_(slot)
+                {
+                }
+
+                allocator_type* alloc_;
+                slot_type** slot_;
+            };
+
+            template<class K = key_type, class F>
+            iterator lazy_emplace(const key_arg<K>& key, F&& f)
+            {
+                auto res = find_or_prepare_insert(key);
+                if (res.second)
+                {
+                    slot_type* slot = slots_ + res.first;
+                    std::forward<F>(f)(constructor(&alloc_ref(), &slot));
+                    assert(!slot);
+                }
+                return iterator_at(res.first);
+            }
+
+            // Extension API: support for heterogeneous keys.
+            //
+            //   std::unordered_set<std::string> s;
+            //   // Turns "abc" into std::string.
+            //   s.erase("abc");
+            //
+            //   flat_hash_set<std::string> s;
+            //   // Uses "abc" directly without copying it into std::string.
+            //   s.erase("abc");
+            template<class K = key_type>
+            size_type erase(const key_arg<K>& key)
+            {
+                auto it = find(key);
+                if (it == end())
+                    return 0;
+                erase(it);
+                return 1;
+            }
+
+            // Erases the element pointed to by `it`.  Unlike `std::unordered_set::erase`,
+            // this method returns void to reduce algorithmic complexity to O(1).  The
+            // iterator is invalidated, so any increment should be done before calling
+            // erase.  In order to erase while iterating across a map, use the following
+            // idiom (which also works for standard containers):
+            //
+            // for (auto it = m.begin(), end = m.end(); it != end;) {
+            //   // `erase()` will invalidate `it`, so advance `it` first.
+            //   auto copy_it = it++;
+            //   if (<pred>) {
+            //     m.erase(copy_it);
+            //   }
+            // }
+            void erase(const_iterator cit)
+            {
+                erase(cit.inner_);
+            }
+
+            // This overload is necessary because otherwise erase<K>(const K&) would be
+            // a better match if non-const iterator is passed as an argument.
+            void erase(iterator it)
+            {
+                ABSL_INTERNAL_ASSERT_IS_FULL(it.ctrl_, "erase() called on invalid iterator.");
+                PolicyTraits::destroy(&alloc_ref(), it.slot_);
+                erase_meta_only(it);
+            }
+
+            iterator erase(const_iterator first, const_iterator last)
+            {
+                while (first != last)
+                {
+                    erase(first++);
+                }
+                return last.inner_;
+            }
+
+            // Moves elements from `src` into `this`.
+            // If the element already exists in `this`, it is left unmodified in `src`.
+            template<typename H, typename E>
+            void merge(raw_hash_set<Policy, H, E, Alloc>& src)
+            {  // NOLINT
+                assert(this != &src);
+                for (auto it = src.begin(), e = src.end(); it != e;)
+                {
+                    auto next = std::next(it);
+                    if (PolicyTraits::apply(InsertSlot<false>{*this, std::move(*it.slot_)}, PolicyTraits::element(it.slot_))
+                            .second)
+                    {
+                        src.erase_meta_only(it);
+                    }
+                    it = next;
+                }
+            }
+
+            template<typename H, typename E>
+            void merge(raw_hash_set<Policy, H, E, Alloc>&& src)
+            {
+                merge(src);
+            }
+
+            node_type extract(const_iterator position)
+            {
+                ABSL_INTERNAL_ASSERT_IS_FULL(position.inner_.ctrl_, "extract() called on invalid iterator.");
+                auto node =
+                    CommonAccess::Transfer<node_type>(alloc_ref(), position.inner_.slot_);
+                erase_meta_only(position);
+                return node;
+            }
+
+            template<
+                class K = key_type,
+                typename std::enable_if<!std::is_same<K, iterator>::value, int>::type = 0>
+            node_type extract(const key_arg<K>& key)
+            {
+                auto it = find(key);
+                return it == end() ? node_type() : extract(const_iterator{it});
+            }
+
+            void swap(raw_hash_set& that) noexcept(
+                IsNoThrowSwappable<hasher>() && IsNoThrowSwappable<key_equal>() &&
+                IsNoThrowSwappable<allocator_type>(
+                    typename AllocTraits::propagate_on_container_swap{}
+                )
+            )
+            {
+                using std::swap;
+                swap(ctrl_, that.ctrl_);
+                swap(slots_, that.slots_);
+                swap(size_, that.size_);
+                swap(capacity_, that.capacity_);
+                swap(growth_left(), that.growth_left());
+                swap(hash_ref(), that.hash_ref());
+                swap(eq_ref(), that.eq_ref());
+                swap(infoz(), that.infoz());
+                SwapAlloc(alloc_ref(), that.alloc_ref(), typename AllocTraits::propagate_on_container_swap{});
+            }
+
+            void rehash(size_t n)
+            {
+                if (n == 0 && capacity_ == 0)
+                    return;
+                if (n == 0 && size_ == 0)
+                {
+                    destroy_slots();
+                    infoz().RecordStorageChanged(0, 0);
+                    infoz().RecordClearedReservation();
+                    return;
+                }
+
+                // bitor is a faster way of doing `max` here. We will round up to the next
+                // power-of-2-minus-1, so bitor is good enough.
+                auto m = NormalizeCapacity(n | GrowthToLowerboundCapacity(size()));
+                // n == 0 unconditionally rehashes as per the standard.
+                if (n == 0 || m > capacity_)
+                {
+                    resize(m);
+
+                    // This is after resize, to ensure that we have completed the allocation
+                    // and have potentially sampled the hashtable.
+                    infoz().RecordReservation(n);
+                }
+            }
+
+            void reserve(size_t n)
+            {
+                if (n > size() + growth_left())
+                {
+                    size_t m = GrowthToLowerboundCapacity(n);
+                    resize(NormalizeCapacity(m));
+
+                    // This is after resize, to ensure that we have completed the allocation
+                    // and have potentially sampled the hashtable.
+                    infoz().RecordReservation(n);
+                }
+            }
+
+            // Extension API: support for heterogeneous keys.
+            //
+            //   std::unordered_set<std::string> s;
+            //   // Turns "abc" into std::string.
+            //   s.count("abc");
+            //
+            //   ch_set<std::string> s;
+            //   // Uses "abc" directly without copying it into std::string.
+            //   s.count("abc");
+            template<class K = key_type>
+            size_t count(const key_arg<K>& key) const
+            {
+                return find(key) == end() ? 0 : 1;
+            }
+
+            // Issues CPU prefetch instructions for the memory needed to find or insert
+            // a key.  Like all lookup functions, this support heterogeneous keys.
+            //
+            // NOTE: This is a very low level operation and should not be used without
+            // specific benchmarks indicating its importance.
+            template<class K = key_type>
+            void prefetch(const key_arg<K>& key) const
+            {
+                (void)key;
+                // Avoid probing if we won't be able to prefetch the addresses received.
 #ifdef ABSL_INTERNAL_HAVE_PREFETCH
-    prefetch_heap_block();
-    auto seq = probe(ctrl_, hash_ref()(key), capacity_);
-    base_internal::PrefetchT0(ctrl_ + seq.offset());
-    base_internal::PrefetchT0(slots_ + seq.offset());
+                prefetch_heap_block();
+                auto seq = probe(ctrl_, hash_ref()(key), capacity_);
+                base_internal::PrefetchT0(ctrl_ + seq.offset());
+                base_internal::PrefetchT0(slots_ + seq.offset());
 #endif  // ABSL_INTERNAL_HAVE_PREFETCH
-  }
-
-  // The API of find() has two extensions.
-  //
-  // 1. The hash can be passed by the user. It must be equal to the hash of the
-  // key.
-  //
-  // 2. The type of the key argument doesn't have to be key_type. This is so
-  // called heterogeneous key support.
-  template <class K = key_type>
-  iterator find(const key_arg<K>& key, size_t hash) {
-    auto seq = probe(ctrl_, hash, capacity_);
-    while (true) {
-      Group g{ctrl_ + seq.offset()};
-      for (uint32_t i : g.Match(H2(hash))) {
-        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
-                EqualElement<K>{key, eq_ref()},
-                PolicyTraits::element(slots_ + seq.offset(i)))))
-          return iterator_at(seq.offset(i));
-      }
-      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
-      seq.next();
-      assert(seq.index() <= capacity_ && "full table!");
-    }
-  }
-  template <class K = key_type>
-  iterator find(const key_arg<K>& key) {
-    prefetch_heap_block();
-    return find(key, hash_ref()(key));
-  }
-
-  template <class K = key_type>
-  const_iterator find(const key_arg<K>& key, size_t hash) const {
-    return const_cast<raw_hash_set*>(this)->find(key, hash);
-  }
-  template <class K = key_type>
-  const_iterator find(const key_arg<K>& key) const {
-    prefetch_heap_block();
-    return find(key, hash_ref()(key));
-  }
-
-  template <class K = key_type>
-  bool contains(const key_arg<K>& key) const {
-    return find(key) != end();
-  }
-
-  template <class K = key_type>
-  std::pair<iterator, iterator> equal_range(const key_arg<K>& key) {
-    auto it = find(key);
-    if (it != end()) return {it, std::next(it)};
-    return {it, it};
-  }
-  template <class K = key_type>
-  std::pair<const_iterator, const_iterator> equal_range(
-      const key_arg<K>& key) const {
-    auto it = find(key);
-    if (it != end()) return {it, std::next(it)};
-    return {it, it};
-  }
-
-  size_t bucket_count() const { return capacity_; }
-  float load_factor() const {
-    return capacity_ ? static_cast<double>(size()) / capacity_ : 0.0;
-  }
-  float max_load_factor() const { return 1.0f; }
-  void max_load_factor(float) {
-    // Does nothing.
-  }
-
-  hasher hash_function() const { return hash_ref(); }
-  key_equal key_eq() const { return eq_ref(); }
-  allocator_type get_allocator() const { return alloc_ref(); }
-
-  friend bool operator==(const raw_hash_set& a, const raw_hash_set& b) {
-    if (a.size() != b.size()) return false;
-    const raw_hash_set* outer = &a;
-    const raw_hash_set* inner = &b;
-    if (outer->capacity() > inner->capacity()) std::swap(outer, inner);
-    for (const value_type& elem : *outer)
-      if (!inner->has_element(elem)) return false;
-    return true;
-  }
-
-  friend bool operator!=(const raw_hash_set& a, const raw_hash_set& b) {
-    return !(a == b);
-  }
-
-  template <typename H>
-  friend typename std::enable_if<H::template is_hashable<value_type>::value,
-                                 H>::type
-  AbslHashValue(H h, const raw_hash_set& s) {
-    return H::combine(H::combine_unordered(std::move(h), s.begin(), s.end()),
-                      s.size());
-  }
-
-  friend void swap(raw_hash_set& a,
-                   raw_hash_set& b) noexcept(noexcept(a.swap(b))) {
-    a.swap(b);
-  }
-
- private:
-  template <class Container, typename Enabler>
-  friend struct absl::container_internal::hashtable_debug_internal::
-      HashtableDebugAccess;
-
-  struct FindElement {
-    template <class K, class... Args>
-    const_iterator operator()(const K& key, Args&&...) const {
-      return s.find(key);
-    }
-    const raw_hash_set& s;
-  };
-
-  struct HashElement {
-    template <class K, class... Args>
-    size_t operator()(const K& key, Args&&...) const {
-      return h(key);
-    }
-    const hasher& h;
-  };
-
-  template <class K1>
-  struct EqualElement {
-    template <class K2, class... Args>
-    bool operator()(const K2& lhs, Args&&...) const {
-      return eq(lhs, rhs);
-    }
-    const K1& rhs;
-    const key_equal& eq;
-  };
-
-  struct EmplaceDecomposable {
-    template <class K, class... Args>
-    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
-      auto res = s.find_or_prepare_insert(key);
-      if (res.second) {
-        s.emplace_at(res.first, std::forward<Args>(args)...);
-      }
-      return {s.iterator_at(res.first), res.second};
-    }
-    raw_hash_set& s;
-  };
-
-  template <bool do_destroy>
-  struct InsertSlot {
-    template <class K, class... Args>
-    std::pair<iterator, bool> operator()(const K& key, Args&&...) && {
-      auto res = s.find_or_prepare_insert(key);
-      if (res.second) {
-        PolicyTraits::transfer(&s.alloc_ref(), s.slots_ + res.first, &slot);
-      } else if (do_destroy) {
-        PolicyTraits::destroy(&s.alloc_ref(), &slot);
-      }
-      return {s.iterator_at(res.first), res.second};
-    }
-    raw_hash_set& s;
-    // Constructed slot. Either moved into place or destroyed.
-    slot_type&& slot;
-  };
-
-  // Erases, but does not destroy, the value pointed to by `it`.
-  //
-  // This merely updates the pertinent control byte. This can be used in
-  // conjunction with Policy::transfer to move the object to another place.
-  void erase_meta_only(const_iterator it) {
-    assert(IsFull(*it.inner_.ctrl_) && "erasing a dangling iterator");
-    --size_;
-    const size_t index = static_cast<size_t>(it.inner_.ctrl_ - ctrl_);
-    const size_t index_before = (index - Group::kWidth) & capacity_;
-    const auto empty_after = Group(it.inner_.ctrl_).MaskEmpty();
-    const auto empty_before = Group(ctrl_ + index_before).MaskEmpty();
-
-    // We count how many consecutive non empties we have to the right and to the
-    // left of `it`. If the sum is >= kWidth then there is at least one probe
-    // window that might have seen a full group.
-    bool was_never_full =
-        empty_before && empty_after &&
-        static_cast<size_t>(empty_after.TrailingZeros() +
-                            empty_before.LeadingZeros()) < Group::kWidth;
-
-    SetCtrl(index, was_never_full ? ctrl_t::kEmpty : ctrl_t::kDeleted,
-            capacity_, ctrl_, slots_, sizeof(slot_type));
-    growth_left() += was_never_full;
-    infoz().RecordErase();
-  }
-
-  // Allocates a backing array for `self` and initializes its control bytes.
-  // This reads `capacity_` and updates all other fields based on the result of
-  // the allocation.
-  //
-  // This does not free the currently held array; `capacity_` must be nonzero.
-  void initialize_slots() {
-    assert(capacity_);
-    // Folks with custom allocators often make unwarranted assumptions about the
-    // behavior of their classes vis-a-vis trivial destructability and what
-    // calls they will or wont make.  Avoid sampling for people with custom
-    // allocators to get us out of this mess.  This is not a hard guarantee but
-    // a workaround while we plan the exact guarantee we want to provide.
-    //
-    // People are often sloppy with the exact type of their allocator (sometimes
-    // it has an extra const or is missing the pair, but rebinds made it work
-    // anyway).  To avoid the ambiguity, we work off SlotAlloc which we have
-    // bound more carefully.
-    if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value &&
-        slots_ == nullptr) {
-      infoz() = Sample(sizeof(slot_type));
-    }
-
-    char* mem = static_cast<char*>(Allocate<alignof(slot_type)>(
-        &alloc_ref(),
-        AllocSize(capacity_, sizeof(slot_type), alignof(slot_type))));
-    ctrl_ = reinterpret_cast<ctrl_t*>(mem);
-    slots_ = reinterpret_cast<slot_type*>(
-        mem + SlotOffset(capacity_, alignof(slot_type)));
-    ResetCtrl(capacity_, ctrl_, slots_, sizeof(slot_type));
-    reset_growth_left();
-    infoz().RecordStorageChanged(size_, capacity_);
-  }
-
-  // Destroys all slots in the backing array, frees the backing array, and
-  // clears all top-level book-keeping data.
-  //
-  // This essentially implements `map = raw_hash_set();`.
-  void destroy_slots() {
-    if (!capacity_) return;
-    for (size_t i = 0; i != capacity_; ++i) {
-      if (IsFull(ctrl_[i])) {
-        PolicyTraits::destroy(&alloc_ref(), slots_ + i);
-      }
-    }
-
-    // Unpoison before returning the memory to the allocator.
-    SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
-    Deallocate<alignof(slot_type)>(
-        &alloc_ref(), ctrl_,
-        AllocSize(capacity_, sizeof(slot_type), alignof(slot_type)));
-    ctrl_ = EmptyGroup();
-    slots_ = nullptr;
-    size_ = 0;
-    capacity_ = 0;
-    growth_left() = 0;
-  }
-
-  void resize(size_t new_capacity) {
-    assert(IsValidCapacity(new_capacity));
-    auto* old_ctrl = ctrl_;
-    auto* old_slots = slots_;
-    const size_t old_capacity = capacity_;
-    capacity_ = new_capacity;
-    initialize_slots();
-
-    size_t total_probe_length = 0;
-    for (size_t i = 0; i != old_capacity; ++i) {
-      if (IsFull(old_ctrl[i])) {
-        size_t hash = PolicyTraits::apply(HashElement{hash_ref()},
-                                          PolicyTraits::element(old_slots + i));
-        auto target = find_first_non_full(ctrl_, hash, capacity_);
-        size_t new_i = target.offset;
-        total_probe_length += target.probe_length;
-        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
-        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, old_slots + i);
-      }
-    }
-    if (old_capacity) {
-      SanitizerUnpoisonMemoryRegion(old_slots,
-                                    sizeof(slot_type) * old_capacity);
-      Deallocate<alignof(slot_type)>(
-          &alloc_ref(), old_ctrl,
-          AllocSize(old_capacity, sizeof(slot_type), alignof(slot_type)));
-    }
-    infoz().RecordRehash(total_probe_length);
-  }
-
-  // Prunes control bytes to remove as many tombstones as possible.
-  //
-  // See the comment on `rehash_and_grow_if_necessary()`.
-  void drop_deletes_without_resize() ABSL_ATTRIBUTE_NOINLINE {
-    assert(IsValidCapacity(capacity_));
-    assert(!is_small(capacity_));
-    // Algorithm:
-    // - mark all DELETED slots as EMPTY
-    // - mark all FULL slots as DELETED
-    // - for each slot marked as DELETED
-    //     hash = Hash(element)
-    //     target = find_first_non_full(hash)
-    //     if target is in the same group
-    //       mark slot as FULL
-    //     else if target is EMPTY
-    //       transfer element to target
-    //       mark slot as EMPTY
-    //       mark target as FULL
-    //     else if target is DELETED
-    //       swap current element with target element
-    //       mark target as FULL
-    //       repeat procedure for current slot with moved from element (target)
-    ConvertDeletedToEmptyAndFullToDeleted(ctrl_, capacity_);
-    alignas(slot_type) unsigned char raw[sizeof(slot_type)];
-    size_t total_probe_length = 0;
-    slot_type* slot = reinterpret_cast<slot_type*>(&raw);
-    for (size_t i = 0; i != capacity_; ++i) {
-      if (!IsDeleted(ctrl_[i])) continue;
-      const size_t hash = PolicyTraits::apply(
-          HashElement{hash_ref()}, PolicyTraits::element(slots_ + i));
-      const FindInfo target = find_first_non_full(ctrl_, hash, capacity_);
-      const size_t new_i = target.offset;
-      total_probe_length += target.probe_length;
-
-      // Verify if the old and new i fall within the same group wrt the hash.
-      // If they do, we don't need to move the object as it falls already in the
-      // best probe we can.
-      const size_t probe_offset = probe(ctrl_, hash, capacity_).offset();
-      const auto probe_index = [probe_offset, this](size_t pos) {
-        return ((pos - probe_offset) & capacity_) / Group::kWidth;
-      };
-
-      // Element doesn't move.
-      if (ABSL_PREDICT_TRUE(probe_index(new_i) == probe_index(i))) {
-        SetCtrl(i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
-        continue;
-      }
-      if (IsEmpty(ctrl_[new_i])) {
-        // Transfer element to the empty spot.
-        // SetCtrl poisons/unpoisons the slots so we have to call it at the
-        // right time.
-        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
-        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slots_ + i);
-        SetCtrl(i, ctrl_t::kEmpty, capacity_, ctrl_, slots_, sizeof(slot_type));
-      } else {
-        assert(IsDeleted(ctrl_[new_i]));
-        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
-        // Until we are done rehashing, DELETED marks previously FULL slots.
-        // Swap i and new_i elements.
-        PolicyTraits::transfer(&alloc_ref(), slot, slots_ + i);
-        PolicyTraits::transfer(&alloc_ref(), slots_ + i, slots_ + new_i);
-        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slot);
-        --i;  // repeat
-      }
-    }
-    reset_growth_left();
-    infoz().RecordRehash(total_probe_length);
-  }
-
-  // Called whenever the table *might* need to conditionally grow.
-  //
-  // This function is an optimization opportunity to perform a rehash even when
-  // growth is unnecessary, because vacating tombstones is beneficial for
-  // performance in the long-run.
-  void rehash_and_grow_if_necessary() {
-    if (capacity_ == 0) {
-      resize(1);
-    } else if (capacity_ > Group::kWidth &&
-               // Do these calcuations in 64-bit to avoid overflow.
-               size() * uint64_t{32} <= capacity_ * uint64_t{25}) {
-      // Squash DELETED without growing if there is enough capacity.
-      //
-      // Rehash in place if the current size is <= 25/32 of capacity_.
-      // Rationale for such a high factor: 1) drop_deletes_without_resize() is
-      // faster than resize, and 2) it takes quite a bit of work to add
-      // tombstones.  In the worst case, seems to take approximately 4
-      // insert/erase pairs to create a single tombstone and so if we are
-      // rehashing because of tombstones, we can afford to rehash-in-place as
-      // long as we are reclaiming at least 1/8 the capacity without doing more
-      // than 2X the work.  (Where "work" is defined to be size() for rehashing
-      // or rehashing in place, and 1 for an insert or erase.)  But rehashing in
-      // place is faster per operation than inserting or even doubling the size
-      // of the table, so we actually afford to reclaim even less space from a
-      // resize-in-place.  The decision is to rehash in place if we can reclaim
-      // at about 1/8th of the usable capacity (specifically 3/28 of the
-      // capacity) which means that the total cost of rehashing will be a small
-      // fraction of the total work.
-      //
-      // Here is output of an experiment using the BM_CacheInSteadyState
-      // benchmark running the old case (where we rehash-in-place only if we can
-      // reclaim at least 7/16*capacity_) vs. this code (which rehashes in place
-      // if we can recover 3/32*capacity_).
-      //
-      // Note that although in the worst-case number of rehashes jumped up from
-      // 15 to 190, but the number of operations per second is almost the same.
-      //
-      // Abridged output of running BM_CacheInSteadyState benchmark from
-      // raw_hash_set_benchmark.   N is the number of insert/erase operations.
-      //
-      //      | OLD (recover >= 7/16        | NEW (recover >= 3/32)
-      // size |    N/s LoadFactor NRehashes |    N/s LoadFactor NRehashes
-      //  448 | 145284       0.44        18 | 140118       0.44        19
-      //  493 | 152546       0.24        11 | 151417       0.48        28
-      //  538 | 151439       0.26        11 | 151152       0.53        38
-      //  583 | 151765       0.28        11 | 150572       0.57        50
-      //  628 | 150241       0.31        11 | 150853       0.61        66
-      //  672 | 149602       0.33        12 | 150110       0.66        90
-      //  717 | 149998       0.35        12 | 149531       0.70       129
-      //  762 | 149836       0.37        13 | 148559       0.74       190
-      //  807 | 149736       0.39        14 | 151107       0.39        14
-      //  852 | 150204       0.42        15 | 151019       0.42        15
-      drop_deletes_without_resize();
-    } else {
-      // Otherwise grow the container.
-      resize(capacity_ * 2 + 1);
-    }
-  }
-
-  bool has_element(const value_type& elem) const {
-    size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, elem);
-    auto seq = probe(ctrl_, hash, capacity_);
-    while (true) {
-      Group g{ctrl_ + seq.offset()};
-      for (uint32_t i : g.Match(H2(hash))) {
-        if (ABSL_PREDICT_TRUE(PolicyTraits::element(slots_ + seq.offset(i)) ==
-                              elem))
-          return true;
-      }
-      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return false;
-      seq.next();
-      assert(seq.index() <= capacity_ && "full table!");
-    }
-    return false;
-  }
-
-  // TODO(alkis): Optimize this assuming *this and that don't overlap.
-  raw_hash_set& move_assign(raw_hash_set&& that, std::true_type) {
-    raw_hash_set tmp(std::move(that));
-    swap(tmp);
-    return *this;
-  }
-  raw_hash_set& move_assign(raw_hash_set&& that, std::false_type) {
-    raw_hash_set tmp(std::move(that), alloc_ref());
-    swap(tmp);
-    return *this;
-  }
-
- protected:
-  // Attempts to find `key` in the table; if it isn't found, returns a slot that
-  // the value can be inserted into, with the control byte already set to
-  // `key`'s H2.
-  template <class K>
-  std::pair<size_t, bool> find_or_prepare_insert(const K& key) {
-    prefetch_heap_block();
-    auto hash = hash_ref()(key);
-    auto seq = probe(ctrl_, hash, capacity_);
-    while (true) {
-      Group g{ctrl_ + seq.offset()};
-      for (uint32_t i : g.Match(H2(hash))) {
-        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
-                EqualElement<K>{key, eq_ref()},
-                PolicyTraits::element(slots_ + seq.offset(i)))))
-          return {seq.offset(i), false};
-      }
-      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) break;
-      seq.next();
-      assert(seq.index() <= capacity_ && "full table!");
-    }
-    return {prepare_insert(hash), true};
-  }
-
-  // Given the hash of a value not currently in the table, finds the next
-  // viable slot index to insert it at.
-  //
-  // REQUIRES: At least one non-full slot available.
-  size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE {
-    auto target = find_first_non_full(ctrl_, hash, capacity_);
-    if (ABSL_PREDICT_FALSE(growth_left() == 0 &&
-                           !IsDeleted(ctrl_[target.offset]))) {
-      rehash_and_grow_if_necessary();
-      target = find_first_non_full(ctrl_, hash, capacity_);
-    }
-    ++size_;
-    growth_left() -= IsEmpty(ctrl_[target.offset]);
-    SetCtrl(target.offset, H2(hash), capacity_, ctrl_, slots_,
-            sizeof(slot_type));
-    infoz().RecordInsert(hash, target.probe_length);
-    return target.offset;
-  }
-
-  // Constructs the value in the space pointed by the iterator. This only works
-  // after an unsuccessful find_or_prepare_insert() and before any other
-  // modifications happen in the raw_hash_set.
-  //
-  // PRECONDITION: i is an index returned from find_or_prepare_insert(k), where
-  // k is the key decomposed from `forward<Args>(args)...`, and the bool
-  // returned by find_or_prepare_insert(k) was true.
-  // POSTCONDITION: *m.iterator_at(i) == value_type(forward<Args>(args)...).
-  template <class... Args>
-  void emplace_at(size_t i, Args&&... args) {
-    PolicyTraits::construct(&alloc_ref(), slots_ + i,
-                            std::forward<Args>(args)...);
-
-    assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
-               iterator_at(i) &&
-           "constructed value does not match the lookup key");
-  }
-
-  iterator iterator_at(size_t i) { return {ctrl_ + i, slots_ + i}; }
-  const_iterator iterator_at(size_t i) const { return {ctrl_ + i, slots_ + i}; }
-
- private:
-  friend struct RawHashSetTestOnlyAccess;
-
-  void reset_growth_left() {
-    growth_left() = CapacityToGrowth(capacity()) - size_;
-  }
-
-  // The number of slots we can still fill without needing to rehash.
-  //
-  // This is stored separately due to tombstones: we do not include tombstones
-  // in the growth capacity, because we'd like to rehash when the table is
-  // otherwise filled with tombstones: otherwise, probe sequences might get
-  // unacceptably long without triggering a rehash. Callers can also force a
-  // rehash via the standard `rehash(0)`, which will recompute this value as a
-  // side-effect.
-  //
-  // See `CapacityToGrowth()`.
-  size_t& growth_left() { return settings_.template get<0>(); }
-
-  // Prefetch the heap-allocated memory region to resolve potential TLB misses.
-  // This is intended to overlap with execution of calculating the hash for a
-  // key.
-  void prefetch_heap_block() const {
-    base_internal::PrefetchT2(ctrl_);
-  }
-
-  HashtablezInfoHandle& infoz() { return settings_.template get<1>(); }
-
-  hasher& hash_ref() { return settings_.template get<2>(); }
-  const hasher& hash_ref() const { return settings_.template get<2>(); }
-  key_equal& eq_ref() { return settings_.template get<3>(); }
-  const key_equal& eq_ref() const { return settings_.template get<3>(); }
-  allocator_type& alloc_ref() { return settings_.template get<4>(); }
-  const allocator_type& alloc_ref() const {
-    return settings_.template get<4>();
-  }
-
-  // TODO(alkis): Investigate removing some of these fields:
-  // - ctrl/slots can be derived from each other
-  // - size can be moved into the slot array
-
-  // The control bytes (and, also, a pointer to the base of the backing array).
-  //
-  // This contains `capacity_ + 1 + NumClonedBytes()` entries, even
-  // when the table is empty (hence EmptyGroup).
-  ctrl_t* ctrl_ = EmptyGroup();
-  // The beginning of the slots, located at `SlotOffset()` bytes after
-  // `ctrl_`. May be null for empty tables.
-  slot_type* slots_ = nullptr;
-
-  // The number of filled slots.
-  size_t size_ = 0;
-
-  // The total number of available slots.
-  size_t capacity_ = 0;
-  absl::container_internal::CompressedTuple<size_t /* growth_left */,
-                                            HashtablezInfoHandle, hasher,
-                                            key_equal, allocator_type>
-      settings_{0u, HashtablezInfoHandle{}, hasher{}, key_equal{},
-                allocator_type{}};
-};
-
-// Erases all elements that satisfy the predicate `pred` from the container `c`.
-template <typename P, typename H, typename E, typename A, typename Predicate>
-typename raw_hash_set<P, H, E, A>::size_type EraseIf(
-    Predicate& pred, raw_hash_set<P, H, E, A>* c) {
-  const auto initial_size = c->size();
-  for (auto it = c->begin(), last = c->end(); it != last;) {
-    if (pred(*it)) {
-      c->erase(it++);
-    } else {
-      ++it;
-    }
-  }
-  return initial_size - c->size();
-}
-
-namespace hashtable_debug_internal {
-template <typename Set>
-struct HashtableDebugAccess<Set, absl::void_t<typename Set::raw_hash_set>> {
-  using Traits = typename Set::PolicyTraits;
-  using Slot = typename Traits::slot_type;
-
-  static size_t GetNumProbes(const Set& set,
-                             const typename Set::key_type& key) {
-    size_t num_probes = 0;
-    size_t hash = set.hash_ref()(key);
-    auto seq = probe(set.ctrl_, hash, set.capacity_);
-    while (true) {
-      container_internal::Group g{set.ctrl_ + seq.offset()};
-      for (uint32_t i : g.Match(container_internal::H2(hash))) {
-        if (Traits::apply(
-                typename Set::template EqualElement<typename Set::key_type>{
-                    key, set.eq_ref()},
-                Traits::element(set.slots_ + seq.offset(i))))
-          return num_probes;
-        ++num_probes;
-      }
-      if (g.MaskEmpty()) return num_probes;
-      seq.next();
-      ++num_probes;
-    }
-  }
-
-  static size_t AllocatedByteSize(const Set& c) {
-    size_t capacity = c.capacity_;
-    if (capacity == 0) return 0;
-    size_t m = AllocSize(capacity, sizeof(Slot), alignof(Slot));
-
-    size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
-    if (per_slot != ~size_t{}) {
-      m += per_slot * c.size();
-    } else {
-      for (size_t i = 0; i != capacity; ++i) {
-        if (container_internal::IsFull(c.ctrl_[i])) {
-          m += Traits::space_used(c.slots_ + i);
+            }
+
+            // The API of find() has two extensions.
+            //
+            // 1. The hash can be passed by the user. It must be equal to the hash of the
+            // key.
+            //
+            // 2. The type of the key argument doesn't have to be key_type. This is so
+            // called heterogeneous key support.
+            template<class K = key_type>
+            iterator find(const key_arg<K>& key, size_t hash)
+            {
+                auto seq = probe(ctrl_, hash, capacity_);
+                while (true)
+                {
+                    Group g{ctrl_ + seq.offset()};
+                    for (uint32_t i : g.Match(H2(hash)))
+                    {
+                        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
+                                EqualElement<K>{key, eq_ref()},
+                                PolicyTraits::element(slots_ + seq.offset(i))
+                            )))
+                            return iterator_at(seq.offset(i));
+                    }
+                    if (ABSL_PREDICT_TRUE(g.MaskEmpty()))
+                        return end();
+                    seq.next();
+                    assert(seq.index() <= capacity_ && "full table!");
+                }
+            }
+            template<class K = key_type>
+            iterator find(const key_arg<K>& key)
+            {
+                prefetch_heap_block();
+                return find(key, hash_ref()(key));
+            }
+
+            template<class K = key_type>
+            const_iterator find(const key_arg<K>& key, size_t hash) const
+            {
+                return const_cast<raw_hash_set*>(this)->find(key, hash);
+            }
+            template<class K = key_type>
+            const_iterator find(const key_arg<K>& key) const
+            {
+                prefetch_heap_block();
+                return find(key, hash_ref()(key));
+            }
+
+            template<class K = key_type>
+            bool contains(const key_arg<K>& key) const
+            {
+                return find(key) != end();
+            }
+
+            template<class K = key_type>
+            std::pair<iterator, iterator> equal_range(const key_arg<K>& key)
+            {
+                auto it = find(key);
+                if (it != end())
+                    return {it, std::next(it)};
+                return {it, it};
+            }
+            template<class K = key_type>
+            std::pair<const_iterator, const_iterator> equal_range(
+                const key_arg<K>& key
+            ) const
+            {
+                auto it = find(key);
+                if (it != end())
+                    return {it, std::next(it)};
+                return {it, it};
+            }
+
+            size_t bucket_count() const
+            {
+                return capacity_;
+            }
+            float load_factor() const
+            {
+                return capacity_ ? static_cast<double>(size()) / capacity_ : 0.0;
+            }
+            float max_load_factor() const
+            {
+                return 1.0f;
+            }
+            void max_load_factor(float)
+            {
+                // Does nothing.
+            }
+
+            hasher hash_function() const
+            {
+                return hash_ref();
+            }
+            key_equal key_eq() const
+            {
+                return eq_ref();
+            }
+            allocator_type get_allocator() const
+            {
+                return alloc_ref();
+            }
+
+            friend bool operator==(const raw_hash_set& a, const raw_hash_set& b)
+            {
+                if (a.size() != b.size())
+                    return false;
+                const raw_hash_set* outer = &a;
+                const raw_hash_set* inner = &b;
+                if (outer->capacity() > inner->capacity())
+                    std::swap(outer, inner);
+                for (const value_type& elem : *outer)
+                    if (!inner->has_element(elem))
+                        return false;
+                return true;
+            }
+
+            friend bool operator!=(const raw_hash_set& a, const raw_hash_set& b)
+            {
+                return !(a == b);
+            }
+
+            template<typename H>
+            friend typename std::enable_if<H::template is_hashable<value_type>::value, H>::type
+                AbslHashValue(H h, const raw_hash_set& s)
+            {
+                return H::combine(H::combine_unordered(std::move(h), s.begin(), s.end()), s.size());
+            }
+
+            friend void swap(raw_hash_set& a, raw_hash_set& b) noexcept(noexcept(a.swap(b)))
+            {
+                a.swap(b);
+            }
+
+        private:
+            template<class Container, typename Enabler>
+            friend struct absl::container_internal::hashtable_debug_internal::
+                HashtableDebugAccess;
+
+            struct FindElement
+            {
+                template<class K, class... Args>
+                const_iterator operator()(const K& key, Args&&...) const
+                {
+                    return s.find(key);
+                }
+                const raw_hash_set& s;
+            };
+
+            struct HashElement
+            {
+                template<class K, class... Args>
+                size_t operator()(const K& key, Args&&...) const
+                {
+                    return h(key);
+                }
+                const hasher& h;
+            };
+
+            template<class K1>
+            struct EqualElement
+            {
+                template<class K2, class... Args>
+                bool operator()(const K2& lhs, Args&&...) const
+                {
+                    return eq(lhs, rhs);
+                }
+                const K1& rhs;
+                const key_equal& eq;
+            };
+
+            struct EmplaceDecomposable
+            {
+                template<class K, class... Args>
+                std::pair<iterator, bool> operator()(const K& key, Args&&... args) const
+                {
+                    auto res = s.find_or_prepare_insert(key);
+                    if (res.second)
+                    {
+                        s.emplace_at(res.first, std::forward<Args>(args)...);
+                    }
+                    return {s.iterator_at(res.first), res.second};
+                }
+                raw_hash_set& s;
+            };
+
+            template<bool do_destroy>
+            struct InsertSlot
+            {
+                template<class K, class... Args>
+                std::pair<iterator, bool> operator()(const K& key, Args&&...) &&
+                {
+                    auto res = s.find_or_prepare_insert(key);
+                    if (res.second)
+                    {
+                        PolicyTraits::transfer(&s.alloc_ref(), s.slots_ + res.first, &slot);
+                    }
+                    else if (do_destroy)
+                    {
+                        PolicyTraits::destroy(&s.alloc_ref(), &slot);
+                    }
+                    return {s.iterator_at(res.first), res.second};
+                }
+                raw_hash_set& s;
+                // Constructed slot. Either moved into place or destroyed.
+                slot_type&& slot;
+            };
+
+            // Erases, but does not destroy, the value pointed to by `it`.
+            //
+            // This merely updates the pertinent control byte. This can be used in
+            // conjunction with Policy::transfer to move the object to another place.
+            void erase_meta_only(const_iterator it)
+            {
+                assert(IsFull(*it.inner_.ctrl_) && "erasing a dangling iterator");
+                --size_;
+                const size_t index = static_cast<size_t>(it.inner_.ctrl_ - ctrl_);
+                const size_t index_before = (index - Group::kWidth) & capacity_;
+                const auto empty_after = Group(it.inner_.ctrl_).MaskEmpty();
+                const auto empty_before = Group(ctrl_ + index_before).MaskEmpty();
+
+                // We count how many consecutive non empties we have to the right and to the
+                // left of `it`. If the sum is >= kWidth then there is at least one probe
+                // window that might have seen a full group.
+                bool was_never_full =
+                    empty_before && empty_after &&
+                    static_cast<size_t>(empty_after.TrailingZeros() + empty_before.LeadingZeros()) < Group::kWidth;
+
+                SetCtrl(index, was_never_full ? ctrl_t::kEmpty : ctrl_t::kDeleted, capacity_, ctrl_, slots_, sizeof(slot_type));
+                growth_left() += was_never_full;
+                infoz().RecordErase();
+            }
+
+            // Allocates a backing array for `self` and initializes its control bytes.
+            // This reads `capacity_` and updates all other fields based on the result of
+            // the allocation.
+            //
+            // This does not free the currently held array; `capacity_` must be nonzero.
+            void initialize_slots()
+            {
+                assert(capacity_);
+                // Folks with custom allocators often make unwarranted assumptions about the
+                // behavior of their classes vis-a-vis trivial destructability and what
+                // calls they will or wont make.  Avoid sampling for people with custom
+                // allocators to get us out of this mess.  This is not a hard guarantee but
+                // a workaround while we plan the exact guarantee we want to provide.
+                //
+                // People are often sloppy with the exact type of their allocator (sometimes
+                // it has an extra const or is missing the pair, but rebinds made it work
+                // anyway).  To avoid the ambiguity, we work off SlotAlloc which we have
+                // bound more carefully.
+                if (std::is_same<SlotAlloc, std::allocator<slot_type>>::value &&
+                    slots_ == nullptr)
+                {
+                    infoz() = Sample(sizeof(slot_type));
+                }
+
+                char* mem = static_cast<char*>(Allocate<alignof(slot_type)>(
+                    &alloc_ref(),
+                    AllocSize(capacity_, sizeof(slot_type), alignof(slot_type))
+                ));
+                ctrl_ = reinterpret_cast<ctrl_t*>(mem);
+                slots_ = reinterpret_cast<slot_type*>(
+                    mem + SlotOffset(capacity_, alignof(slot_type))
+                );
+                ResetCtrl(capacity_, ctrl_, slots_, sizeof(slot_type));
+                reset_growth_left();
+                infoz().RecordStorageChanged(size_, capacity_);
+            }
+
+            // Destroys all slots in the backing array, frees the backing array, and
+            // clears all top-level book-keeping data.
+            //
+            // This essentially implements `map = raw_hash_set();`.
+            void destroy_slots()
+            {
+                if (!capacity_)
+                    return;
+                for (size_t i = 0; i != capacity_; ++i)
+                {
+                    if (IsFull(ctrl_[i]))
+                    {
+                        PolicyTraits::destroy(&alloc_ref(), slots_ + i);
+                    }
+                }
+
+                // Unpoison before returning the memory to the allocator.
+                SanitizerUnpoisonMemoryRegion(slots_, sizeof(slot_type) * capacity_);
+                Deallocate<alignof(slot_type)>(
+                    &alloc_ref(), ctrl_, AllocSize(capacity_, sizeof(slot_type), alignof(slot_type))
+                );
+                ctrl_ = EmptyGroup();
+                slots_ = nullptr;
+                size_ = 0;
+                capacity_ = 0;
+                growth_left() = 0;
+            }
+
+            void resize(size_t new_capacity)
+            {
+                assert(IsValidCapacity(new_capacity));
+                auto* old_ctrl = ctrl_;
+                auto* old_slots = slots_;
+                const size_t old_capacity = capacity_;
+                capacity_ = new_capacity;
+                initialize_slots();
+
+                size_t total_probe_length = 0;
+                for (size_t i = 0; i != old_capacity; ++i)
+                {
+                    if (IsFull(old_ctrl[i]))
+                    {
+                        size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, PolicyTraits::element(old_slots + i));
+                        auto target = find_first_non_full(ctrl_, hash, capacity_);
+                        size_t new_i = target.offset;
+                        total_probe_length += target.probe_length;
+                        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+                        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, old_slots + i);
+                    }
+                }
+                if (old_capacity)
+                {
+                    SanitizerUnpoisonMemoryRegion(old_slots, sizeof(slot_type) * old_capacity);
+                    Deallocate<alignof(slot_type)>(
+                        &alloc_ref(), old_ctrl, AllocSize(old_capacity, sizeof(slot_type), alignof(slot_type))
+                    );
+                }
+                infoz().RecordRehash(total_probe_length);
+            }
+
+            // Prunes control bytes to remove as many tombstones as possible.
+            //
+            // See the comment on `rehash_and_grow_if_necessary()`.
+            void drop_deletes_without_resize() ABSL_ATTRIBUTE_NOINLINE
+            {
+                assert(IsValidCapacity(capacity_));
+                assert(!is_small(capacity_));
+                // Algorithm:
+                // - mark all DELETED slots as EMPTY
+                // - mark all FULL slots as DELETED
+                // - for each slot marked as DELETED
+                //     hash = Hash(element)
+                //     target = find_first_non_full(hash)
+                //     if target is in the same group
+                //       mark slot as FULL
+                //     else if target is EMPTY
+                //       transfer element to target
+                //       mark slot as EMPTY
+                //       mark target as FULL
+                //     else if target is DELETED
+                //       swap current element with target element
+                //       mark target as FULL
+                //       repeat procedure for current slot with moved from element (target)
+                ConvertDeletedToEmptyAndFullToDeleted(ctrl_, capacity_);
+                alignas(slot_type) unsigned char raw[sizeof(slot_type)];
+                size_t total_probe_length = 0;
+                slot_type* slot = reinterpret_cast<slot_type*>(&raw);
+                for (size_t i = 0; i != capacity_; ++i)
+                {
+                    if (!IsDeleted(ctrl_[i]))
+                        continue;
+                    const size_t hash = PolicyTraits::apply(
+                        HashElement{hash_ref()}, PolicyTraits::element(slots_ + i)
+                    );
+                    const FindInfo target = find_first_non_full(ctrl_, hash, capacity_);
+                    const size_t new_i = target.offset;
+                    total_probe_length += target.probe_length;
+
+                    // Verify if the old and new i fall within the same group wrt the hash.
+                    // If they do, we don't need to move the object as it falls already in the
+                    // best probe we can.
+                    const size_t probe_offset = probe(ctrl_, hash, capacity_).offset();
+                    const auto probe_index = [probe_offset, this](size_t pos)
+                    {
+                        return ((pos - probe_offset) & capacity_) / Group::kWidth;
+                    };
+
+                    // Element doesn't move.
+                    if (ABSL_PREDICT_TRUE(probe_index(new_i) == probe_index(i)))
+                    {
+                        SetCtrl(i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+                        continue;
+                    }
+                    if (IsEmpty(ctrl_[new_i]))
+                    {
+                        // Transfer element to the empty spot.
+                        // SetCtrl poisons/unpoisons the slots so we have to call it at the
+                        // right time.
+                        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+                        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slots_ + i);
+                        SetCtrl(i, ctrl_t::kEmpty, capacity_, ctrl_, slots_, sizeof(slot_type));
+                    }
+                    else
+                    {
+                        assert(IsDeleted(ctrl_[new_i]));
+                        SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+                        // Until we are done rehashing, DELETED marks previously FULL slots.
+                        // Swap i and new_i elements.
+                        PolicyTraits::transfer(&alloc_ref(), slot, slots_ + i);
+                        PolicyTraits::transfer(&alloc_ref(), slots_ + i, slots_ + new_i);
+                        PolicyTraits::transfer(&alloc_ref(), slots_ + new_i, slot);
+                        --i;  // repeat
+                    }
+                }
+                reset_growth_left();
+                infoz().RecordRehash(total_probe_length);
+            }
+
+            // Called whenever the table *might* need to conditionally grow.
+            //
+            // This function is an optimization opportunity to perform a rehash even when
+            // growth is unnecessary, because vacating tombstones is beneficial for
+            // performance in the long-run.
+            void rehash_and_grow_if_necessary()
+            {
+                if (capacity_ == 0)
+                {
+                    resize(1);
+                }
+                else if (capacity_ > Group::kWidth &&
+                         // Do these calcuations in 64-bit to avoid overflow.
+                         size() * uint64_t{32} <= capacity_ * uint64_t{25})
+                {
+                    // Squash DELETED without growing if there is enough capacity.
+                    //
+                    // Rehash in place if the current size is <= 25/32 of capacity_.
+                    // Rationale for such a high factor: 1) drop_deletes_without_resize() is
+                    // faster than resize, and 2) it takes quite a bit of work to add
+                    // tombstones.  In the worst case, seems to take approximately 4
+                    // insert/erase pairs to create a single tombstone and so if we are
+                    // rehashing because of tombstones, we can afford to rehash-in-place as
+                    // long as we are reclaiming at least 1/8 the capacity without doing more
+                    // than 2X the work.  (Where "work" is defined to be size() for rehashing
+                    // or rehashing in place, and 1 for an insert or erase.)  But rehashing in
+                    // place is faster per operation than inserting or even doubling the size
+                    // of the table, so we actually afford to reclaim even less space from a
+                    // resize-in-place.  The decision is to rehash in place if we can reclaim
+                    // at about 1/8th of the usable capacity (specifically 3/28 of the
+                    // capacity) which means that the total cost of rehashing will be a small
+                    // fraction of the total work.
+                    //
+                    // Here is output of an experiment using the BM_CacheInSteadyState
+                    // benchmark running the old case (where we rehash-in-place only if we can
+                    // reclaim at least 7/16*capacity_) vs. this code (which rehashes in place
+                    // if we can recover 3/32*capacity_).
+                    //
+                    // Note that although in the worst-case number of rehashes jumped up from
+                    // 15 to 190, but the number of operations per second is almost the same.
+                    //
+                    // Abridged output of running BM_CacheInSteadyState benchmark from
+                    // raw_hash_set_benchmark.   N is the number of insert/erase operations.
+                    //
+                    //      | OLD (recover >= 7/16        | NEW (recover >= 3/32)
+                    // size |    N/s LoadFactor NRehashes |    N/s LoadFactor NRehashes
+                    //  448 | 145284       0.44        18 | 140118       0.44        19
+                    //  493 | 152546       0.24        11 | 151417       0.48        28
+                    //  538 | 151439       0.26        11 | 151152       0.53        38
+                    //  583 | 151765       0.28        11 | 150572       0.57        50
+                    //  628 | 150241       0.31        11 | 150853       0.61        66
+                    //  672 | 149602       0.33        12 | 150110       0.66        90
+                    //  717 | 149998       0.35        12 | 149531       0.70       129
+                    //  762 | 149836       0.37        13 | 148559       0.74       190
+                    //  807 | 149736       0.39        14 | 151107       0.39        14
+                    //  852 | 150204       0.42        15 | 151019       0.42        15
+                    drop_deletes_without_resize();
+                }
+                else
+                {
+                    // Otherwise grow the container.
+                    resize(capacity_ * 2 + 1);
+                }
+            }
+
+            bool has_element(const value_type& elem) const
+            {
+                size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, elem);
+                auto seq = probe(ctrl_, hash, capacity_);
+                while (true)
+                {
+                    Group g{ctrl_ + seq.offset()};
+                    for (uint32_t i : g.Match(H2(hash)))
+                    {
+                        if (ABSL_PREDICT_TRUE(PolicyTraits::element(slots_ + seq.offset(i)) == elem))
+                            return true;
+                    }
+                    if (ABSL_PREDICT_TRUE(g.MaskEmpty()))
+                        return false;
+                    seq.next();
+                    assert(seq.index() <= capacity_ && "full table!");
+                }
+                return false;
+            }
+
+            // TODO(alkis): Optimize this assuming *this and that don't overlap.
+            raw_hash_set& move_assign(raw_hash_set&& that, std::true_type)
+            {
+                raw_hash_set tmp(std::move(that));
+                swap(tmp);
+                return *this;
+            }
+            raw_hash_set& move_assign(raw_hash_set&& that, std::false_type)
+            {
+                raw_hash_set tmp(std::move(that), alloc_ref());
+                swap(tmp);
+                return *this;
+            }
+
+        protected:
+            // Attempts to find `key` in the table; if it isn't found, returns a slot that
+            // the value can be inserted into, with the control byte already set to
+            // `key`'s H2.
+            template<class K>
+            std::pair<size_t, bool> find_or_prepare_insert(const K& key)
+            {
+                prefetch_heap_block();
+                auto hash = hash_ref()(key);
+                auto seq = probe(ctrl_, hash, capacity_);
+                while (true)
+                {
+                    Group g{ctrl_ + seq.offset()};
+                    for (uint32_t i : g.Match(H2(hash)))
+                    {
+                        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
+                                EqualElement<K>{key, eq_ref()},
+                                PolicyTraits::element(slots_ + seq.offset(i))
+                            )))
+                            return {seq.offset(i), false};
+                    }
+                    if (ABSL_PREDICT_TRUE(g.MaskEmpty()))
+                        break;
+                    seq.next();
+                    assert(seq.index() <= capacity_ && "full table!");
+                }
+                return {prepare_insert(hash), true};
+            }
+
+            // Given the hash of a value not currently in the table, finds the next
+            // viable slot index to insert it at.
+            //
+            // REQUIRES: At least one non-full slot available.
+            size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE
+            {
+                auto target = find_first_non_full(ctrl_, hash, capacity_);
+                if (ABSL_PREDICT_FALSE(growth_left() == 0 && !IsDeleted(ctrl_[target.offset])))
+                {
+                    rehash_and_grow_if_necessary();
+                    target = find_first_non_full(ctrl_, hash, capacity_);
+                }
+                ++size_;
+                growth_left() -= IsEmpty(ctrl_[target.offset]);
+                SetCtrl(target.offset, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
+                infoz().RecordInsert(hash, target.probe_length);
+                return target.offset;
+            }
+
+            // Constructs the value in the space pointed by the iterator. This only works
+            // after an unsuccessful find_or_prepare_insert() and before any other
+            // modifications happen in the raw_hash_set.
+            //
+            // PRECONDITION: i is an index returned from find_or_prepare_insert(k), where
+            // k is the key decomposed from `forward<Args>(args)...`, and the bool
+            // returned by find_or_prepare_insert(k) was true.
+            // POSTCONDITION: *m.iterator_at(i) == value_type(forward<Args>(args)...).
+            template<class... Args>
+            void emplace_at(size_t i, Args&&... args)
+            {
+                PolicyTraits::construct(&alloc_ref(), slots_ + i, std::forward<Args>(args)...);
+
+                assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) == iterator_at(i) && "constructed value does not match the lookup key");
+            }
+
+            iterator iterator_at(size_t i)
+            {
+                return {ctrl_ + i, slots_ + i};
+            }
+            const_iterator iterator_at(size_t i) const
+            {
+                return {ctrl_ + i, slots_ + i};
+            }
+
+        private:
+            friend struct RawHashSetTestOnlyAccess;
+
+            void reset_growth_left()
+            {
+                growth_left() = CapacityToGrowth(capacity()) - size_;
+            }
+
+            // The number of slots we can still fill without needing to rehash.
+            //
+            // This is stored separately due to tombstones: we do not include tombstones
+            // in the growth capacity, because we'd like to rehash when the table is
+            // otherwise filled with tombstones: otherwise, probe sequences might get
+            // unacceptably long without triggering a rehash. Callers can also force a
+            // rehash via the standard `rehash(0)`, which will recompute this value as a
+            // side-effect.
+            //
+            // See `CapacityToGrowth()`.
+            size_t& growth_left()
+            {
+                return settings_.template get<0>();
+            }
+
+            // Prefetch the heap-allocated memory region to resolve potential TLB misses.
+            // This is intended to overlap with execution of calculating the hash for a
+            // key.
+            void prefetch_heap_block() const
+            {
+                base_internal::PrefetchT2(ctrl_);
+            }
+
+            HashtablezInfoHandle& infoz()
+            {
+                return settings_.template get<1>();
+            }
+
+            hasher& hash_ref()
+            {
+                return settings_.template get<2>();
+            }
+            const hasher& hash_ref() const
+            {
+                return settings_.template get<2>();
+            }
+            key_equal& eq_ref()
+            {
+                return settings_.template get<3>();
+            }
+            const key_equal& eq_ref() const
+            {
+                return settings_.template get<3>();
+            }
+            allocator_type& alloc_ref()
+            {
+                return settings_.template get<4>();
+            }
+            const allocator_type& alloc_ref() const
+            {
+                return settings_.template get<4>();
+            }
+
+            // TODO(alkis): Investigate removing some of these fields:
+            // - ctrl/slots can be derived from each other
+            // - size can be moved into the slot array
+
+            // The control bytes (and, also, a pointer to the base of the backing array).
+            //
+            // This contains `capacity_ + 1 + NumClonedBytes()` entries, even
+            // when the table is empty (hence EmptyGroup).
+            ctrl_t* ctrl_ = EmptyGroup();
+            // The beginning of the slots, located at `SlotOffset()` bytes after
+            // `ctrl_`. May be null for empty tables.
+            slot_type* slots_ = nullptr;
+
+            // The number of filled slots.
+            size_t size_ = 0;
+
+            // The total number of available slots.
+            size_t capacity_ = 0;
+            absl::container_internal::CompressedTuple<size_t /* growth_left */, HashtablezInfoHandle, hasher, key_equal, allocator_type>
+                settings_{0u, HashtablezInfoHandle{}, hasher{}, key_equal{}, allocator_type{}};
+        };
+
+        // Erases all elements that satisfy the predicate `pred` from the container `c`.
+        template<typename P, typename H, typename E, typename A, typename Predicate>
+        typename raw_hash_set<P, H, E, A>::size_type EraseIf(
+            Predicate& pred, raw_hash_set<P, H, E, A>* c
+        )
+        {
+            const auto initial_size = c->size();
+            for (auto it = c->begin(), last = c->end(); it != last;)
+            {
+                if (pred(*it))
+                {
+                    c->erase(it++);
+                }
+                else
+                {
+                    ++it;
+                }
+            }
+            return initial_size - c->size();
         }
-      }
-    }
-    return m;
-  }
-
-  static size_t LowerBoundAllocatedByteSize(size_t size) {
-    size_t capacity = GrowthToLowerboundCapacity(size);
-    if (capacity == 0) return 0;
-    size_t m =
-        AllocSize(NormalizeCapacity(capacity), sizeof(Slot), alignof(Slot));
-    size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
-    if (per_slot != ~size_t{}) {
-      m += per_slot * size;
-    }
-    return m;
-  }
-};
-
-}  // namespace hashtable_debug_internal
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+
+        namespace hashtable_debug_internal
+        {
+            template<typename Set>
+            struct HashtableDebugAccess<Set, absl::void_t<typename Set::raw_hash_set>>
+            {
+                using Traits = typename Set::PolicyTraits;
+                using Slot = typename Traits::slot_type;
+
+                static size_t GetNumProbes(const Set& set, const typename Set::key_type& key)
+                {
+                    size_t num_probes = 0;
+                    size_t hash = set.hash_ref()(key);
+                    auto seq = probe(set.ctrl_, hash, set.capacity_);
+                    while (true)
+                    {
+                        container_internal::Group g{set.ctrl_ + seq.offset()};
+                        for (uint32_t i : g.Match(container_internal::H2(hash)))
+                        {
+                            if (Traits::apply(
+                                    typename Set::template EqualElement<typename Set::key_type>{
+                                        key, set.eq_ref()},
+                                    Traits::element(set.slots_ + seq.offset(i))
+                                ))
+                                return num_probes;
+                            ++num_probes;
+                        }
+                        if (g.MaskEmpty())
+                            return num_probes;
+                        seq.next();
+                        ++num_probes;
+                    }
+                }
+
+                static size_t AllocatedByteSize(const Set& c)
+                {
+                    size_t capacity = c.capacity_;
+                    if (capacity == 0)
+                        return 0;
+                    size_t m = AllocSize(capacity, sizeof(Slot), alignof(Slot));
+
+                    size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
+                    if (per_slot != ~size_t{})
+                    {
+                        m += per_slot * c.size();
+                    }
+                    else
+                    {
+                        for (size_t i = 0; i != capacity; ++i)
+                        {
+                            if (container_internal::IsFull(c.ctrl_[i]))
+                            {
+                                m += Traits::space_used(c.slots_ + i);
+                            }
+                        }
+                    }
+                    return m;
+                }
+
+                static size_t LowerBoundAllocatedByteSize(size_t size)
+                {
+                    size_t capacity = GrowthToLowerboundCapacity(size);
+                    if (capacity == 0)
+                        return 0;
+                    size_t m =
+                        AllocSize(NormalizeCapacity(capacity), sizeof(Slot), alignof(Slot));
+                    size_t per_slot = Traits::space_used(static_cast<const Slot*>(nullptr));
+                    if (per_slot != ~size_t{})
+                    {
+                        m += per_slot * size;
+                    }
+                    return m;
+                }
+            };
+
+        }  // namespace hashtable_debug_internal
+    }      // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #undef ABSL_INTERNAL_ASSERT_IS_FULL
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/test_instance_tracker.h b/CAPI/cpp/grpc/include/absl/container/internal/test_instance_tracker.h
index 5ff6fd7..46f3b17 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/test_instance_tracker.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/test_instance_tracker.h
@@ -20,255 +20,321 @@
 
 #include "absl/types/compare.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace test_internal {
-
-// A type that counts number of occurrences of the type, the live occurrences of
-// the type, as well as the number of copies, moves, swaps, and comparisons that
-// have occurred on the type. This is used as a base class for the copyable,
-// copyable+movable, and movable types below that are used in actual tests. Use
-// InstanceTracker in tests to track the number of instances.
-class BaseCountedInstance {
- public:
-  explicit BaseCountedInstance(int x) : value_(x) {
-    ++num_instances_;
-    ++num_live_instances_;
-  }
-  BaseCountedInstance(const BaseCountedInstance& x)
-      : value_(x.value_), is_live_(x.is_live_) {
-    ++num_instances_;
-    if (is_live_) ++num_live_instances_;
-    ++num_copies_;
-  }
-  BaseCountedInstance(BaseCountedInstance&& x)
-      : value_(x.value_), is_live_(x.is_live_) {
-    x.is_live_ = false;
-    ++num_instances_;
-    ++num_moves_;
-  }
-  ~BaseCountedInstance() {
-    --num_instances_;
-    if (is_live_) --num_live_instances_;
-  }
-
-  BaseCountedInstance& operator=(const BaseCountedInstance& x) {
-    value_ = x.value_;
-    if (is_live_) --num_live_instances_;
-    is_live_ = x.is_live_;
-    if (is_live_) ++num_live_instances_;
-    ++num_copies_;
-    return *this;
-  }
-  BaseCountedInstance& operator=(BaseCountedInstance&& x) {
-    value_ = x.value_;
-    if (is_live_) --num_live_instances_;
-    is_live_ = x.is_live_;
-    x.is_live_ = false;
-    ++num_moves_;
-    return *this;
-  }
-
-  bool operator==(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ == x.value_;
-  }
-
-  bool operator!=(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ != x.value_;
-  }
-
-  bool operator<(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ < x.value_;
-  }
-
-  bool operator>(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ > x.value_;
-  }
-
-  bool operator<=(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ <= x.value_;
-  }
-
-  bool operator>=(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ >= x.value_;
-  }
-
-  absl::weak_ordering compare(const BaseCountedInstance& x) const {
-    ++num_comparisons_;
-    return value_ < x.value_
-               ? absl::weak_ordering::less
-               : value_ == x.value_ ? absl::weak_ordering::equivalent
-                                    : absl::weak_ordering::greater;
-  }
-
-  int value() const {
-    if (!is_live_) std::abort();
-    return value_;
-  }
-
-  friend std::ostream& operator<<(std::ostream& o,
-                                  const BaseCountedInstance& v) {
-    return o << "[value:" << v.value() << "]";
-  }
-
-  // Implementation of efficient swap() that counts swaps.
-  static void SwapImpl(
-      BaseCountedInstance& lhs,    // NOLINT(runtime/references)
-      BaseCountedInstance& rhs) {  // NOLINT(runtime/references)
-    using std::swap;
-    swap(lhs.value_, rhs.value_);
-    swap(lhs.is_live_, rhs.is_live_);
-    ++BaseCountedInstance::num_swaps_;
-  }
-
- private:
-  friend class InstanceTracker;
-
-  int value_;
-
-  // Indicates if the value is live, ie it hasn't been moved away from.
-  bool is_live_ = true;
-
-  // Number of instances.
-  static int num_instances_;
-
-  // Number of live instances (those that have not been moved away from.)
-  static int num_live_instances_;
-
-  // Number of times that BaseCountedInstance objects were moved.
-  static int num_moves_;
-
-  // Number of times that BaseCountedInstance objects were copied.
-  static int num_copies_;
-
-  // Number of times that BaseCountedInstance objects were swapped.
-  static int num_swaps_;
-
-  // Number of times that BaseCountedInstance objects were compared.
-  static int num_comparisons_;
-};
-
-// Helper to track the BaseCountedInstance instance counters. Expects that the
-// number of instances and live_instances are the same when it is constructed
-// and when it is destructed.
-class InstanceTracker {
- public:
-  InstanceTracker()
-      : start_instances_(BaseCountedInstance::num_instances_),
-        start_live_instances_(BaseCountedInstance::num_live_instances_) {
-    ResetCopiesMovesSwaps();
-  }
-  ~InstanceTracker() {
-    if (instances() != 0) std::abort();
-    if (live_instances() != 0) std::abort();
-  }
-
-  // Returns the number of BaseCountedInstance instances both containing valid
-  // values and those moved away from compared to when the InstanceTracker was
-  // constructed
-  int instances() const {
-    return BaseCountedInstance::num_instances_ - start_instances_;
-  }
-
-  // Returns the number of live BaseCountedInstance instances compared to when
-  // the InstanceTracker was constructed
-  int live_instances() const {
-    return BaseCountedInstance::num_live_instances_ - start_live_instances_;
-  }
-
-  // Returns the number of moves on BaseCountedInstance objects since
-  // construction or since the last call to ResetCopiesMovesSwaps().
-  int moves() const { return BaseCountedInstance::num_moves_ - start_moves_; }
-
-  // Returns the number of copies on BaseCountedInstance objects since
-  // construction or the last call to ResetCopiesMovesSwaps().
-  int copies() const {
-    return BaseCountedInstance::num_copies_ - start_copies_;
-  }
-
-  // Returns the number of swaps on BaseCountedInstance objects since
-  // construction or the last call to ResetCopiesMovesSwaps().
-  int swaps() const { return BaseCountedInstance::num_swaps_ - start_swaps_; }
-
-  // Returns the number of comparisons on BaseCountedInstance objects since
-  // construction or the last call to ResetCopiesMovesSwaps().
-  int comparisons() const {
-    return BaseCountedInstance::num_comparisons_ - start_comparisons_;
-  }
-
-  // Resets the base values for moves, copies, comparisons, and swaps to the
-  // current values, so that subsequent Get*() calls for moves, copies,
-  // comparisons, and swaps will compare to the situation at the point of this
-  // call.
-  void ResetCopiesMovesSwaps() {
-    start_moves_ = BaseCountedInstance::num_moves_;
-    start_copies_ = BaseCountedInstance::num_copies_;
-    start_swaps_ = BaseCountedInstance::num_swaps_;
-    start_comparisons_ = BaseCountedInstance::num_comparisons_;
-  }
-
- private:
-  int start_instances_;
-  int start_live_instances_;
-  int start_moves_;
-  int start_copies_;
-  int start_swaps_;
-  int start_comparisons_;
-};
-
-// Copyable, not movable.
-class CopyableOnlyInstance : public BaseCountedInstance {
- public:
-  explicit CopyableOnlyInstance(int x) : BaseCountedInstance(x) {}
-  CopyableOnlyInstance(const CopyableOnlyInstance& rhs) = default;
-  CopyableOnlyInstance& operator=(const CopyableOnlyInstance& rhs) = default;
-
-  friend void swap(CopyableOnlyInstance& lhs, CopyableOnlyInstance& rhs) {
-    BaseCountedInstance::SwapImpl(lhs, rhs);
-  }
-
-  static bool supports_move() { return false; }
-};
-
-// Copyable and movable.
-class CopyableMovableInstance : public BaseCountedInstance {
- public:
-  explicit CopyableMovableInstance(int x) : BaseCountedInstance(x) {}
-  CopyableMovableInstance(const CopyableMovableInstance& rhs) = default;
-  CopyableMovableInstance(CopyableMovableInstance&& rhs) = default;
-  CopyableMovableInstance& operator=(const CopyableMovableInstance& rhs) =
-      default;
-  CopyableMovableInstance& operator=(CopyableMovableInstance&& rhs) = default;
-
-  friend void swap(CopyableMovableInstance& lhs, CopyableMovableInstance& rhs) {
-    BaseCountedInstance::SwapImpl(lhs, rhs);
-  }
-
-  static bool supports_move() { return true; }
-};
-
-// Only movable, not default-constructible.
-class MovableOnlyInstance : public BaseCountedInstance {
- public:
-  explicit MovableOnlyInstance(int x) : BaseCountedInstance(x) {}
-  MovableOnlyInstance(MovableOnlyInstance&& other) = default;
-  MovableOnlyInstance& operator=(MovableOnlyInstance&& other) = default;
-
-  friend void swap(MovableOnlyInstance& lhs, MovableOnlyInstance& rhs) {
-    BaseCountedInstance::SwapImpl(lhs, rhs);
-  }
-
-  static bool supports_move() { return true; }
-};
-
-}  // namespace test_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace test_internal
+    {
+
+        // A type that counts number of occurrences of the type, the live occurrences of
+        // the type, as well as the number of copies, moves, swaps, and comparisons that
+        // have occurred on the type. This is used as a base class for the copyable,
+        // copyable+movable, and movable types below that are used in actual tests. Use
+        // InstanceTracker in tests to track the number of instances.
+        class BaseCountedInstance
+        {
+        public:
+            explicit BaseCountedInstance(int x) :
+                value_(x)
+            {
+                ++num_instances_;
+                ++num_live_instances_;
+            }
+            BaseCountedInstance(const BaseCountedInstance& x) :
+                value_(x.value_),
+                is_live_(x.is_live_)
+            {
+                ++num_instances_;
+                if (is_live_)
+                    ++num_live_instances_;
+                ++num_copies_;
+            }
+            BaseCountedInstance(BaseCountedInstance&& x) :
+                value_(x.value_),
+                is_live_(x.is_live_)
+            {
+                x.is_live_ = false;
+                ++num_instances_;
+                ++num_moves_;
+            }
+            ~BaseCountedInstance()
+            {
+                --num_instances_;
+                if (is_live_)
+                    --num_live_instances_;
+            }
+
+            BaseCountedInstance& operator=(const BaseCountedInstance& x)
+            {
+                value_ = x.value_;
+                if (is_live_)
+                    --num_live_instances_;
+                is_live_ = x.is_live_;
+                if (is_live_)
+                    ++num_live_instances_;
+                ++num_copies_;
+                return *this;
+            }
+            BaseCountedInstance& operator=(BaseCountedInstance&& x)
+            {
+                value_ = x.value_;
+                if (is_live_)
+                    --num_live_instances_;
+                is_live_ = x.is_live_;
+                x.is_live_ = false;
+                ++num_moves_;
+                return *this;
+            }
+
+            bool operator==(const BaseCountedInstance& x) const
+            {
+                ++num_comparisons_;
+                return value_ == x.value_;
+            }
+
+            bool operator!=(const BaseCountedInstance& x) const
+            {
+                ++num_comparisons_;
+                return value_ != x.value_;
+            }
+
+            bool operator<(const BaseCountedInstance& x) const
+            {
+                ++num_comparisons_;
+                return value_ < x.value_;
+            }
+
+            bool operator>(const BaseCountedInstance& x) const
+            {
+                ++num_comparisons_;
+                return value_ > x.value_;
+            }
+
+            bool operator<=(const BaseCountedInstance& x) const
+            {
+                ++num_comparisons_;
+                return value_ <= x.value_;
+            }
+
+            bool operator>=(const BaseCountedInstance& x) const
+            {
+                ++num_comparisons_;
+                return value_ >= x.value_;
+            }
+
+            absl::weak_ordering compare(const BaseCountedInstance& x) const
+            {
+                ++num_comparisons_;
+                return value_ < x.value_ ? absl::weak_ordering::less : value_ == x.value_ ? absl::weak_ordering::equivalent :
+                                                                                            absl::weak_ordering::greater;
+            }
+
+            int value() const
+            {
+                if (!is_live_)
+                    std::abort();
+                return value_;
+            }
+
+            friend std::ostream& operator<<(std::ostream& o, const BaseCountedInstance& v)
+            {
+                return o << "[value:" << v.value() << "]";
+            }
+
+            // Implementation of efficient swap() that counts swaps.
+            static void SwapImpl(
+                BaseCountedInstance& lhs,  // NOLINT(runtime/references)
+                BaseCountedInstance& rhs
+            )
+            {  // NOLINT(runtime/references)
+                using std::swap;
+                swap(lhs.value_, rhs.value_);
+                swap(lhs.is_live_, rhs.is_live_);
+                ++BaseCountedInstance::num_swaps_;
+            }
+
+        private:
+            friend class InstanceTracker;
+
+            int value_;
+
+            // Indicates if the value is live, ie it hasn't been moved away from.
+            bool is_live_ = true;
+
+            // Number of instances.
+            static int num_instances_;
+
+            // Number of live instances (those that have not been moved away from.)
+            static int num_live_instances_;
+
+            // Number of times that BaseCountedInstance objects were moved.
+            static int num_moves_;
+
+            // Number of times that BaseCountedInstance objects were copied.
+            static int num_copies_;
+
+            // Number of times that BaseCountedInstance objects were swapped.
+            static int num_swaps_;
+
+            // Number of times that BaseCountedInstance objects were compared.
+            static int num_comparisons_;
+        };
+
+        // Helper to track the BaseCountedInstance instance counters. Expects that the
+        // number of instances and live_instances are the same when it is constructed
+        // and when it is destructed.
+        class InstanceTracker
+        {
+        public:
+            InstanceTracker() :
+                start_instances_(BaseCountedInstance::num_instances_),
+                start_live_instances_(BaseCountedInstance::num_live_instances_)
+            {
+                ResetCopiesMovesSwaps();
+            }
+            ~InstanceTracker()
+            {
+                if (instances() != 0)
+                    std::abort();
+                if (live_instances() != 0)
+                    std::abort();
+            }
+
+            // Returns the number of BaseCountedInstance instances both containing valid
+            // values and those moved away from compared to when the InstanceTracker was
+            // constructed
+            int instances() const
+            {
+                return BaseCountedInstance::num_instances_ - start_instances_;
+            }
+
+            // Returns the number of live BaseCountedInstance instances compared to when
+            // the InstanceTracker was constructed
+            int live_instances() const
+            {
+                return BaseCountedInstance::num_live_instances_ - start_live_instances_;
+            }
+
+            // Returns the number of moves on BaseCountedInstance objects since
+            // construction or since the last call to ResetCopiesMovesSwaps().
+            int moves() const
+            {
+                return BaseCountedInstance::num_moves_ - start_moves_;
+            }
+
+            // Returns the number of copies on BaseCountedInstance objects since
+            // construction or the last call to ResetCopiesMovesSwaps().
+            int copies() const
+            {
+                return BaseCountedInstance::num_copies_ - start_copies_;
+            }
+
+            // Returns the number of swaps on BaseCountedInstance objects since
+            // construction or the last call to ResetCopiesMovesSwaps().
+            int swaps() const
+            {
+                return BaseCountedInstance::num_swaps_ - start_swaps_;
+            }
+
+            // Returns the number of comparisons on BaseCountedInstance objects since
+            // construction or the last call to ResetCopiesMovesSwaps().
+            int comparisons() const
+            {
+                return BaseCountedInstance::num_comparisons_ - start_comparisons_;
+            }
+
+            // Resets the base values for moves, copies, comparisons, and swaps to the
+            // current values, so that subsequent Get*() calls for moves, copies,
+            // comparisons, and swaps will compare to the situation at the point of this
+            // call.
+            void ResetCopiesMovesSwaps()
+            {
+                start_moves_ = BaseCountedInstance::num_moves_;
+                start_copies_ = BaseCountedInstance::num_copies_;
+                start_swaps_ = BaseCountedInstance::num_swaps_;
+                start_comparisons_ = BaseCountedInstance::num_comparisons_;
+            }
+
+        private:
+            int start_instances_;
+            int start_live_instances_;
+            int start_moves_;
+            int start_copies_;
+            int start_swaps_;
+            int start_comparisons_;
+        };
+
+        // Copyable, not movable.
+        class CopyableOnlyInstance : public BaseCountedInstance
+        {
+        public:
+            explicit CopyableOnlyInstance(int x) :
+                BaseCountedInstance(x)
+            {
+            }
+            CopyableOnlyInstance(const CopyableOnlyInstance& rhs) = default;
+            CopyableOnlyInstance& operator=(const CopyableOnlyInstance& rhs) = default;
+
+            friend void swap(CopyableOnlyInstance& lhs, CopyableOnlyInstance& rhs)
+            {
+                BaseCountedInstance::SwapImpl(lhs, rhs);
+            }
+
+            static bool supports_move()
+            {
+                return false;
+            }
+        };
+
+        // Copyable and movable.
+        class CopyableMovableInstance : public BaseCountedInstance
+        {
+        public:
+            explicit CopyableMovableInstance(int x) :
+                BaseCountedInstance(x)
+            {
+            }
+            CopyableMovableInstance(const CopyableMovableInstance& rhs) = default;
+            CopyableMovableInstance(CopyableMovableInstance&& rhs) = default;
+            CopyableMovableInstance& operator=(const CopyableMovableInstance& rhs) =
+                default;
+            CopyableMovableInstance& operator=(CopyableMovableInstance&& rhs) = default;
+
+            friend void swap(CopyableMovableInstance& lhs, CopyableMovableInstance& rhs)
+            {
+                BaseCountedInstance::SwapImpl(lhs, rhs);
+            }
+
+            static bool supports_move()
+            {
+                return true;
+            }
+        };
+
+        // Only movable, not default-constructible.
+        class MovableOnlyInstance : public BaseCountedInstance
+        {
+        public:
+            explicit MovableOnlyInstance(int x) :
+                BaseCountedInstance(x)
+            {
+            }
+            MovableOnlyInstance(MovableOnlyInstance&& other) = default;
+            MovableOnlyInstance& operator=(MovableOnlyInstance&& other) = default;
+
+            friend void swap(MovableOnlyInstance& lhs, MovableOnlyInstance& rhs)
+            {
+                BaseCountedInstance::SwapImpl(lhs, rhs);
+            }
+
+            static bool supports_move()
+            {
+                return true;
+            }
+        };
+
+    }  // namespace test_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/tracked.h b/CAPI/cpp/grpc/include/absl/container/internal/tracked.h
index 29f5829..84c9bd1 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/tracked.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/tracked.h
@@ -22,62 +22,85 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
 
-// A class that tracks its copies and moves so that it can be queried in tests.
-template <class T>
-class Tracked {
- public:
-  Tracked() {}
-  // NOLINTNEXTLINE(runtime/explicit)
-  Tracked(const T& val) : val_(val) {}
-  Tracked(const Tracked& that)
-      : val_(that.val_),
-        num_moves_(that.num_moves_),
-        num_copies_(that.num_copies_) {
-    ++(*num_copies_);
-  }
-  Tracked(Tracked&& that)
-      : val_(std::move(that.val_)),
-        num_moves_(std::move(that.num_moves_)),
-        num_copies_(std::move(that.num_copies_)) {
-    ++(*num_moves_);
-  }
-  Tracked& operator=(const Tracked& that) {
-    val_ = that.val_;
-    num_moves_ = that.num_moves_;
-    num_copies_ = that.num_copies_;
-    ++(*num_copies_);
-  }
-  Tracked& operator=(Tracked&& that) {
-    val_ = std::move(that.val_);
-    num_moves_ = std::move(that.num_moves_);
-    num_copies_ = std::move(that.num_copies_);
-    ++(*num_moves_);
-  }
+        // A class that tracks its copies and moves so that it can be queried in tests.
+        template<class T>
+        class Tracked
+        {
+        public:
+            Tracked()
+            {
+            }
+            // NOLINTNEXTLINE(runtime/explicit)
+            Tracked(const T& val) :
+                val_(val)
+            {
+            }
+            Tracked(const Tracked& that) :
+                val_(that.val_),
+                num_moves_(that.num_moves_),
+                num_copies_(that.num_copies_)
+            {
+                ++(*num_copies_);
+            }
+            Tracked(Tracked&& that) :
+                val_(std::move(that.val_)),
+                num_moves_(std::move(that.num_moves_)),
+                num_copies_(std::move(that.num_copies_))
+            {
+                ++(*num_moves_);
+            }
+            Tracked& operator=(const Tracked& that)
+            {
+                val_ = that.val_;
+                num_moves_ = that.num_moves_;
+                num_copies_ = that.num_copies_;
+                ++(*num_copies_);
+            }
+            Tracked& operator=(Tracked&& that)
+            {
+                val_ = std::move(that.val_);
+                num_moves_ = std::move(that.num_moves_);
+                num_copies_ = std::move(that.num_copies_);
+                ++(*num_moves_);
+            }
 
-  const T& val() const { return val_; }
+            const T& val() const
+            {
+                return val_;
+            }
 
-  friend bool operator==(const Tracked& a, const Tracked& b) {
-    return a.val_ == b.val_;
-  }
-  friend bool operator!=(const Tracked& a, const Tracked& b) {
-    return !(a == b);
-  }
+            friend bool operator==(const Tracked& a, const Tracked& b)
+            {
+                return a.val_ == b.val_;
+            }
+            friend bool operator!=(const Tracked& a, const Tracked& b)
+            {
+                return !(a == b);
+            }
 
-  size_t num_copies() { return *num_copies_; }
-  size_t num_moves() { return *num_moves_; }
+            size_t num_copies()
+            {
+                return *num_copies_;
+            }
+            size_t num_moves()
+            {
+                return *num_moves_;
+            }
 
- private:
-  T val_;
-  std::shared_ptr<size_t> num_moves_ = std::make_shared<size_t>(0);
-  std::shared_ptr<size_t> num_copies_ = std::make_shared<size_t>(0);
-};
+        private:
+            T val_;
+            std::shared_ptr<size_t> num_moves_ = std::make_shared<size_t>(0);
+            std::shared_ptr<size_t> num_copies_ = std::make_shared<size_t>(0);
+        };
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_TRACKED_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_constructor_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_constructor_test.h
index 7e84dc2..00248e1 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_constructor_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_constructor_test.h
@@ -24,471 +24,523 @@
 #include "absl/container/internal/hash_generator_testing.h"
 #include "absl/container/internal/hash_policy_testing.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordMap>
-class ConstructorTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(ConstructorTest);
-
-TYPED_TEST_P(ConstructorTest, NoArgs) {
-  TypeParam m;
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCount) {
-  TypeParam m(123);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHash) {
-  using H = typename TypeParam::hasher;
-  H hasher;
-  TypeParam m(123, hasher);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashEqual) {
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  H hasher;
-  E equal;
-  TypeParam m(123, hasher, equal);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashEqualAlloc) {
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename T>
-struct is_std_unordered_map : std::false_type {};
-
-template <typename... T>
-struct is_std_unordered_map<std::unordered_map<T...>> : std::true_type {};
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<class UnordMap>
+        class ConstructorTest : public ::testing::Test
+        {
+        };
+
+        TYPED_TEST_SUITE_P(ConstructorTest);
+
+        TYPED_TEST_P(ConstructorTest, NoArgs)
+        {
+            TypeParam m;
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCount)
+        {
+            TypeParam m(123);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountHash)
+        {
+            using H = typename TypeParam::hasher;
+            H hasher;
+            TypeParam m(123, hasher);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountHashEqual)
+        {
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            H hasher;
+            E equal;
+            TypeParam m(123, hasher, equal);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.key_eq(), equal);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountHashEqualAlloc)
+        {
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            TypeParam m(123, hasher, equal, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.key_eq(), equal);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        template<typename T>
+        struct is_std_unordered_map : std::false_type
+        {
+        };
+
+        template<typename... T>
+        struct is_std_unordered_map<std::unordered_map<T...>> : std::true_type
+        {
+        };
 
 #if defined(UNORDERED_MAP_CXX14) || defined(UNORDERED_MAP_CXX17)
-using has_cxx14_std_apis = std::true_type;
+        using has_cxx14_std_apis = std::true_type;
 #else
-using has_cxx14_std_apis = std::false_type;
+        using has_cxx14_std_apis = std::false_type;
 #endif
 
-template <typename T>
-using expect_cxx14_apis =
-    absl::disjunction<absl::negation<is_std_unordered_map<T>>,
-                      has_cxx14_std_apis>;
-
-template <typename TypeParam>
-void BucketCountAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void BucketCountAllocTest(std::true_type) {
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  TypeParam m(123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountAlloc) {
-  BucketCountAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void BucketCountHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void BucketCountHashAllocTest(std::true_type) {
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  TypeParam m(123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc) {
-  BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
+        template<typename T>
+        using expect_cxx14_apis =
+            absl::disjunction<absl::negation<is_std_unordered_map<T>>, has_cxx14_std_apis>;
+
+        template<typename TypeParam>
+        void BucketCountAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void BucketCountAllocTest(std::true_type)
+        {
+            using A = typename TypeParam::allocator_type;
+            A alloc(0);
+            TypeParam m(123, alloc);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountAlloc)
+        {
+            BucketCountAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        template<typename TypeParam>
+        void BucketCountHashAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void BucketCountHashAllocTest(std::true_type)
+        {
+            using H = typename TypeParam::hasher;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            A alloc(0);
+            TypeParam m(123, hasher, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc)
+        {
+            BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
 
 #if ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
-using has_alloc_std_constructors = std::true_type;
+        using has_alloc_std_constructors = std::true_type;
 #else
-using has_alloc_std_constructors = std::false_type;
+        using has_alloc_std_constructors = std::false_type;
 #endif
 
-template <typename T>
-using expect_alloc_constructors =
-    absl::disjunction<absl::negation<is_std_unordered_map<T>>,
-                      has_alloc_std_constructors>;
-
-template <typename TypeParam>
-void AllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void AllocTest(std::true_type) {
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  TypeParam m(alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(m, ::testing::UnorderedElementsAre());
-}
-
-TYPED_TEST_P(ConstructorTest, Alloc) {
-  AllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashEqualAlloc) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::UniqueGenerator<T>());
-  TypeParam m(values.begin(), values.end(), 123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename TypeParam>
-void InputIteratorBucketAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InputIteratorBucketAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::UniqueGenerator<T>());
-  TypeParam m(values.begin(), values.end(), 123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketAlloc) {
-  InputIteratorBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void InputIteratorBucketHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InputIteratorBucketHashAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::UniqueGenerator<T>());
-  TypeParam m(values.begin(), values.end(), 123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashAlloc) {
-  InputIteratorBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, CopyConstructor) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(gen());
-  TypeParam n(m);
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-template <typename TypeParam>
-void CopyConstructorAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void CopyConstructorAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(gen());
-  TypeParam n(m, A(11));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_NE(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, CopyConstructorAlloc) {
-  CopyConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-// TODO(alkis): Test non-propagating allocators on copy constructors.
-
-TYPED_TEST_P(ConstructorTest, MoveConstructor) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(gen());
-  TypeParam t(m);
-  TypeParam n(std::move(t));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-template <typename TypeParam>
-void MoveConstructorAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void MoveConstructorAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(gen());
-  TypeParam t(m);
-  TypeParam n(std::move(t), A(1));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_NE(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, MoveConstructorAlloc) {
-  MoveConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-// TODO(alkis): Test non-propagating allocators on move constructors.
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketHashEqualAlloc) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(values, 123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename TypeParam>
-void InitializerListBucketAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InitializerListBucketAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using A = typename TypeParam::allocator_type;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  A alloc(0);
-  TypeParam m(values, 123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketAlloc) {
-  InitializerListBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void InitializerListBucketHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InitializerListBucketHashAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m(values, 123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketHashAlloc) {
-  InitializerListBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, Assignment) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
-  TypeParam n;
-  n = m;
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m, n);
-}
-
-// TODO(alkis): Test [non-]propagating allocators on move/copy assignments
-// (it depends on traits).
-
-TYPED_TEST_P(ConstructorTest, MoveAssignment) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
-  TypeParam t(m);
-  TypeParam n;
-  n = std::move(t);
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m;
-  m = values;
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m({gen(), gen(), gen()});
-  TypeParam n({gen()});
-  n = m;
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, MoveAssignmentOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  TypeParam m({gen(), gen(), gen()});
-  TypeParam t(m);
-  TypeParam n({gen()});
-  n = std::move(t);
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerListOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m;
-  m = values;
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentOnSelf) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::UniqueGenerator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m(values);
-  m = *&m;  // Avoid -Wself-assign
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-// We cannot test self move as standard states that it leaves standard
-// containers in unspecified state (and in practice in causes memory-leak
-// according to heap-checker!).
-
-REGISTER_TYPED_TEST_SUITE_P(
-    ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
-    BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
-    InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,
-    InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc,
-    MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc,
-    InitializerListBucketAlloc, InitializerListBucketHashAlloc, Assignment,
-    MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting,
-    MoveAssignmentOverwritesExisting,
-    AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+        template<typename T>
+        using expect_alloc_constructors =
+            absl::disjunction<absl::negation<is_std_unordered_map<T>>, has_alloc_std_constructors>;
+
+        template<typename TypeParam>
+        void AllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void AllocTest(std::true_type)
+        {
+            using A = typename TypeParam::allocator_type;
+            A alloc(0);
+            TypeParam m(alloc);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(m, ::testing::UnorderedElementsAre());
+        }
+
+        TYPED_TEST_P(ConstructorTest, Alloc)
+        {
+            AllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+        }
+
+        TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashEqualAlloc)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::UniqueGenerator<T>());
+            TypeParam m(values.begin(), values.end(), 123, hasher, equal, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.key_eq(), equal);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        template<typename TypeParam>
+        void InputIteratorBucketAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void InputIteratorBucketAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using A = typename TypeParam::allocator_type;
+            A alloc(0);
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::UniqueGenerator<T>());
+            TypeParam m(values.begin(), values.end(), 123, alloc);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, InputIteratorBucketAlloc)
+        {
+            InputIteratorBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        template<typename TypeParam>
+        void InputIteratorBucketHashAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void InputIteratorBucketHashAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            A alloc(0);
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::UniqueGenerator<T>());
+            TypeParam m(values.begin(), values.end(), 123, hasher, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashAlloc)
+        {
+            InputIteratorBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        TYPED_TEST_P(ConstructorTest, CopyConstructor)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            hash_internal::UniqueGenerator<T> gen;
+            TypeParam m(123, hasher, equal, alloc);
+            for (size_t i = 0; i != 10; ++i)
+                m.insert(gen());
+            TypeParam n(m);
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_EQ(m.get_allocator(), n.get_allocator());
+            EXPECT_EQ(m, n);
+        }
+
+        template<typename TypeParam>
+        void CopyConstructorAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void CopyConstructorAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            hash_internal::UniqueGenerator<T> gen;
+            TypeParam m(123, hasher, equal, alloc);
+            for (size_t i = 0; i != 10; ++i)
+                m.insert(gen());
+            TypeParam n(m, A(11));
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_NE(m.get_allocator(), n.get_allocator());
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, CopyConstructorAlloc)
+        {
+            CopyConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+        }
+
+        // TODO(alkis): Test non-propagating allocators on copy constructors.
+
+        TYPED_TEST_P(ConstructorTest, MoveConstructor)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            hash_internal::UniqueGenerator<T> gen;
+            TypeParam m(123, hasher, equal, alloc);
+            for (size_t i = 0; i != 10; ++i)
+                m.insert(gen());
+            TypeParam t(m);
+            TypeParam n(std::move(t));
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_EQ(m.get_allocator(), n.get_allocator());
+            EXPECT_EQ(m, n);
+        }
+
+        template<typename TypeParam>
+        void MoveConstructorAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void MoveConstructorAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            hash_internal::UniqueGenerator<T> gen;
+            TypeParam m(123, hasher, equal, alloc);
+            for (size_t i = 0; i != 10; ++i)
+                m.insert(gen());
+            TypeParam t(m);
+            TypeParam n(std::move(t), A(1));
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_NE(m.get_allocator(), n.get_allocator());
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, MoveConstructorAlloc)
+        {
+            MoveConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+        }
+
+        // TODO(alkis): Test non-propagating allocators on move constructors.
+
+        TYPED_TEST_P(ConstructorTest, InitializerListBucketHashEqualAlloc)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::UniqueGenerator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            TypeParam m(values, 123, hasher, equal, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.key_eq(), equal);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        template<typename TypeParam>
+        void InitializerListBucketAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void InitializerListBucketAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using A = typename TypeParam::allocator_type;
+            hash_internal::UniqueGenerator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            A alloc(0);
+            TypeParam m(values, 123, alloc);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, InitializerListBucketAlloc)
+        {
+            InitializerListBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        template<typename TypeParam>
+        void InitializerListBucketHashAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void InitializerListBucketHashAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            A alloc(0);
+            hash_internal::UniqueGenerator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            TypeParam m(values, 123, hasher, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, InitializerListBucketHashAlloc)
+        {
+            InitializerListBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        TYPED_TEST_P(ConstructorTest, Assignment)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            hash_internal::UniqueGenerator<T> gen;
+            TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
+            TypeParam n;
+            n = m;
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_EQ(m, n);
+        }
+
+        // TODO(alkis): Test [non-]propagating allocators on move/copy assignments
+        // (it depends on traits).
+
+        TYPED_TEST_P(ConstructorTest, MoveAssignment)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            hash_internal::UniqueGenerator<T> gen;
+            TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
+            TypeParam t(m);
+            TypeParam n;
+            n = std::move(t);
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::UniqueGenerator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            TypeParam m;
+            m = values;
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+        }
+
+        TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::UniqueGenerator<T> gen;
+            TypeParam m({gen(), gen(), gen()});
+            TypeParam n({gen()});
+            n = m;
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, MoveAssignmentOverwritesExisting)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::UniqueGenerator<T> gen;
+            TypeParam m({gen(), gen(), gen()});
+            TypeParam t(m);
+            TypeParam n({gen()});
+            n = std::move(t);
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerListOverwritesExisting)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::UniqueGenerator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            TypeParam m;
+            m = values;
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+        }
+
+        TYPED_TEST_P(ConstructorTest, AssignmentOnSelf)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::UniqueGenerator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            TypeParam m(values);
+            m = *&m;  // Avoid -Wself-assign
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+        }
+
+        // We cannot test self move as standard states that it leaves standard
+        // containers in unspecified state (and in practice in causes memory-leak
+        // according to heap-checker!).
+
+        REGISTER_TYPED_TEST_SUITE_P(
+            ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual, BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc, InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc, InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc, MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc, InitializerListBucketAlloc, InitializerListBucketHashAlloc, Assignment, MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting, MoveAssignmentOverwritesExisting, AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf
+        );
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_lookup_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_lookup_test.h
index 3713cd9..17241b8 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_lookup_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_lookup_test.h
@@ -20,98 +20,106 @@
 #include "absl/container/internal/hash_generator_testing.h"
 #include "absl/container/internal/hash_policy_testing.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
 
-template <class UnordMap>
-class LookupTest : public ::testing::Test {};
+        template<class UnordMap>
+        class LookupTest : public ::testing::Test
+        {
+        };
 
-TYPED_TEST_SUITE_P(LookupTest);
+        TYPED_TEST_SUITE_P(LookupTest);
 
-TYPED_TEST_P(LookupTest, At) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  for (const auto& p : values) {
-    const auto& val = m.at(p.first);
-    EXPECT_EQ(p.second, val) << ::testing::PrintToString(p.first);
-  }
-}
+        TYPED_TEST_P(LookupTest, At)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            for (const auto& p : values)
+            {
+                const auto& val = m.at(p.first);
+                EXPECT_EQ(p.second, val) << ::testing::PrintToString(p.first);
+            }
+        }
 
-TYPED_TEST_P(LookupTest, OperatorBracket) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& p : values) {
-    auto& val = m[p.first];
-    EXPECT_EQ(V(), val) << ::testing::PrintToString(p.first);
-    val = p.second;
-  }
-  for (const auto& p : values)
-    EXPECT_EQ(p.second, m[p.first]) << ::testing::PrintToString(p.first);
-}
+        TYPED_TEST_P(LookupTest, OperatorBracket)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            for (const auto& p : values)
+            {
+                auto& val = m[p.first];
+                EXPECT_EQ(V(), val) << ::testing::PrintToString(p.first);
+                val = p.second;
+            }
+            for (const auto& p : values)
+                EXPECT_EQ(p.second, m[p.first]) << ::testing::PrintToString(p.first);
+        }
 
-TYPED_TEST_P(LookupTest, Count) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& p : values)
-    EXPECT_EQ(0, m.count(p.first)) << ::testing::PrintToString(p.first);
-  m.insert(values.begin(), values.end());
-  for (const auto& p : values)
-    EXPECT_EQ(1, m.count(p.first)) << ::testing::PrintToString(p.first);
-}
+        TYPED_TEST_P(LookupTest, Count)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            for (const auto& p : values)
+                EXPECT_EQ(0, m.count(p.first)) << ::testing::PrintToString(p.first);
+            m.insert(values.begin(), values.end());
+            for (const auto& p : values)
+                EXPECT_EQ(1, m.count(p.first)) << ::testing::PrintToString(p.first);
+        }
 
-TYPED_TEST_P(LookupTest, Find) {
-  using std::get;
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& p : values)
-    EXPECT_TRUE(m.end() == m.find(p.first))
-        << ::testing::PrintToString(p.first);
-  m.insert(values.begin(), values.end());
-  for (const auto& p : values) {
-    auto it = m.find(p.first);
-    EXPECT_TRUE(m.end() != it) << ::testing::PrintToString(p.first);
-    EXPECT_EQ(p.second, get<1>(*it)) << ::testing::PrintToString(p.first);
-  }
-}
+        TYPED_TEST_P(LookupTest, Find)
+        {
+            using std::get;
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            for (const auto& p : values)
+                EXPECT_TRUE(m.end() == m.find(p.first))
+                    << ::testing::PrintToString(p.first);
+            m.insert(values.begin(), values.end());
+            for (const auto& p : values)
+            {
+                auto it = m.find(p.first);
+                EXPECT_TRUE(m.end() != it) << ::testing::PrintToString(p.first);
+                EXPECT_EQ(p.second, get<1>(*it)) << ::testing::PrintToString(p.first);
+            }
+        }
 
-TYPED_TEST_P(LookupTest, EqualRange) {
-  using std::get;
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& p : values) {
-    auto r = m.equal_range(p.first);
-    ASSERT_EQ(0, std::distance(r.first, r.second));
-  }
-  m.insert(values.begin(), values.end());
-  for (const auto& p : values) {
-    auto r = m.equal_range(p.first);
-    ASSERT_EQ(1, std::distance(r.first, r.second));
-    EXPECT_EQ(p.second, get<1>(*r.first)) << ::testing::PrintToString(p.first);
-  }
-}
+        TYPED_TEST_P(LookupTest, EqualRange)
+        {
+            using std::get;
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            for (const auto& p : values)
+            {
+                auto r = m.equal_range(p.first);
+                ASSERT_EQ(0, std::distance(r.first, r.second));
+            }
+            m.insert(values.begin(), values.end());
+            for (const auto& p : values)
+            {
+                auto r = m.equal_range(p.first);
+                ASSERT_EQ(1, std::distance(r.first, r.second));
+                EXPECT_EQ(p.second, get<1>(*r.first)) << ::testing::PrintToString(p.first);
+            }
+        }
 
-REGISTER_TYPED_TEST_SUITE_P(LookupTest, At, OperatorBracket, Count, Find,
-                            EqualRange);
+        REGISTER_TYPED_TEST_SUITE_P(LookupTest, At, OperatorBracket, Count, Find, EqualRange);
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_members_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_members_test.h
index 7d48cdb..631606d 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_members_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_members_test.h
@@ -20,68 +20,71 @@
 #include "gtest/gtest.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
 
-template <class UnordMap>
-class MembersTest : public ::testing::Test {};
+        template<class UnordMap>
+        class MembersTest : public ::testing::Test
+        {
+        };
 
-TYPED_TEST_SUITE_P(MembersTest);
+        TYPED_TEST_SUITE_P(MembersTest);
 
-template <typename T>
-void UseType() {}
+        template<typename T>
+        void UseType()
+        {
+        }
 
-TYPED_TEST_P(MembersTest, Typedefs) {
-  EXPECT_TRUE((std::is_same<std::pair<const typename TypeParam::key_type,
-                                      typename TypeParam::mapped_type>,
-                            typename TypeParam::value_type>()));
-  EXPECT_TRUE((absl::conjunction<
-               absl::negation<std::is_signed<typename TypeParam::size_type>>,
-               std::is_integral<typename TypeParam::size_type>>()));
-  EXPECT_TRUE((absl::conjunction<
-               std::is_signed<typename TypeParam::difference_type>,
-               std::is_integral<typename TypeParam::difference_type>>()));
-  EXPECT_TRUE((std::is_convertible<
-               decltype(std::declval<const typename TypeParam::hasher&>()(
-                   std::declval<const typename TypeParam::key_type&>())),
-               size_t>()));
-  EXPECT_TRUE((std::is_convertible<
-               decltype(std::declval<const typename TypeParam::key_equal&>()(
-                   std::declval<const typename TypeParam::key_type&>(),
-                   std::declval<const typename TypeParam::key_type&>())),
-               bool>()));
-  EXPECT_TRUE((std::is_same<typename TypeParam::allocator_type::value_type,
-                            typename TypeParam::value_type>()));
-  EXPECT_TRUE((std::is_same<typename TypeParam::value_type&,
-                            typename TypeParam::reference>()));
-  EXPECT_TRUE((std::is_same<const typename TypeParam::value_type&,
-                            typename TypeParam::const_reference>()));
-  EXPECT_TRUE((std::is_same<typename std::allocator_traits<
-                                typename TypeParam::allocator_type>::pointer,
-                            typename TypeParam::pointer>()));
-  EXPECT_TRUE(
-      (std::is_same<typename std::allocator_traits<
-                        typename TypeParam::allocator_type>::const_pointer,
-                    typename TypeParam::const_pointer>()));
-}
+        TYPED_TEST_P(MembersTest, Typedefs)
+        {
+            EXPECT_TRUE((std::is_same<std::pair<const typename TypeParam::key_type, typename TypeParam::mapped_type>, typename TypeParam::value_type>()));
+            EXPECT_TRUE((absl::conjunction<
+                         absl::negation<std::is_signed<typename TypeParam::size_type>>,
+                         std::is_integral<typename TypeParam::size_type>>()));
+            EXPECT_TRUE((absl::conjunction<
+                         std::is_signed<typename TypeParam::difference_type>,
+                         std::is_integral<typename TypeParam::difference_type>>()));
+            EXPECT_TRUE((std::is_convertible<
+                         decltype(std::declval<const typename TypeParam::hasher&>()(
+                             std::declval<const typename TypeParam::key_type&>()
+                         )),
+                         size_t>()));
+            EXPECT_TRUE((std::is_convertible<
+                         decltype(std::declval<const typename TypeParam::key_equal&>()(
+                             std::declval<const typename TypeParam::key_type&>(),
+                             std::declval<const typename TypeParam::key_type&>()
+                         )),
+                         bool>()));
+            EXPECT_TRUE((std::is_same<typename TypeParam::allocator_type::value_type, typename TypeParam::value_type>()));
+            EXPECT_TRUE((std::is_same<typename TypeParam::value_type&, typename TypeParam::reference>()));
+            EXPECT_TRUE((std::is_same<const typename TypeParam::value_type&, typename TypeParam::const_reference>()));
+            EXPECT_TRUE((std::is_same<typename std::allocator_traits<typename TypeParam::allocator_type>::pointer, typename TypeParam::pointer>()));
+            EXPECT_TRUE(
+                (std::is_same<typename std::allocator_traits<typename TypeParam::allocator_type>::const_pointer, typename TypeParam::const_pointer>())
+            );
+        }
 
-TYPED_TEST_P(MembersTest, SimpleFunctions) {
-  EXPECT_GT(TypeParam().max_size(), 0);
-}
+        TYPED_TEST_P(MembersTest, SimpleFunctions)
+        {
+            EXPECT_GT(TypeParam().max_size(), 0);
+        }
 
-TYPED_TEST_P(MembersTest, BeginEnd) {
-  TypeParam t = {typename TypeParam::value_type{}};
-  EXPECT_EQ(t.begin(), t.cbegin());
-  EXPECT_EQ(t.end(), t.cend());
-  EXPECT_NE(t.begin(), t.end());
-  EXPECT_NE(t.cbegin(), t.cend());
-}
+        TYPED_TEST_P(MembersTest, BeginEnd)
+        {
+            TypeParam t = {typename TypeParam::value_type{}};
+            EXPECT_EQ(t.begin(), t.cbegin());
+            EXPECT_EQ(t.end(), t.cend());
+            EXPECT_NE(t.begin(), t.end());
+            EXPECT_NE(t.cbegin(), t.cend());
+        }
 
-REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
+        REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_modifiers_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_modifiers_test.h
index 4d9ab30..fea5d50 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_modifiers_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_map_modifiers_test.h
@@ -22,331 +22,349 @@
 #include "absl/container/internal/hash_generator_testing.h"
 #include "absl/container/internal/hash_policy_testing.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordMap>
-class ModifiersTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(ModifiersTest);
-
-TYPED_TEST_P(ModifiersTest, Clear) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  m.clear();
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAre());
-  EXPECT_TRUE(m.empty());
-}
-
-TYPED_TEST_P(ModifiersTest, Insert) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto p = m.insert(val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  p = m.insert(val2);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(val, *p.first);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertHint) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto it = m.insert(m.end(), val);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(val, *it);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  it = m.insert(it, val2);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(val, *it);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  m.insert(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ModifiersTest, InsertWithinCapacity) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  m.reserve(10);
-  const size_t original_capacity = m.bucket_count();
-  m.insert(val);
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  m.insert(val2);
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertRangeWithinCapacity) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<class UnordMap>
+        class ModifiersTest : public ::testing::Test
+        {
+        };
+
+        TYPED_TEST_SUITE_P(ModifiersTest);
+
+        TYPED_TEST_P(ModifiersTest, Clear)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            m.clear();
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAre());
+            EXPECT_TRUE(m.empty());
+        }
+
+        TYPED_TEST_P(ModifiersTest, Insert)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            auto p = m.insert(val);
+            EXPECT_TRUE(p.second);
+            EXPECT_EQ(val, *p.first);
+            T val2 = {val.first, hash_internal::Generator<V>()()};
+            p = m.insert(val2);
+            EXPECT_FALSE(p.second);
+            EXPECT_EQ(val, *p.first);
+        }
+
+        TYPED_TEST_P(ModifiersTest, InsertHint)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            auto it = m.insert(m.end(), val);
+            EXPECT_TRUE(it != m.end());
+            EXPECT_EQ(val, *it);
+            T val2 = {val.first, hash_internal::Generator<V>()()};
+            it = m.insert(it, val2);
+            EXPECT_TRUE(it != m.end());
+            EXPECT_EQ(val, *it);
+        }
+
+        TYPED_TEST_P(ModifiersTest, InsertRange)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            m.insert(values.begin(), values.end());
+            ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+        }
+
+        TYPED_TEST_P(ModifiersTest, InsertWithinCapacity)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            m.reserve(10);
+            const size_t original_capacity = m.bucket_count();
+            m.insert(val);
+            EXPECT_EQ(m.bucket_count(), original_capacity);
+            T val2 = {val.first, hash_internal::Generator<V>()()};
+            m.insert(val2);
+            EXPECT_EQ(m.bucket_count(), original_capacity);
+        }
+
+        TYPED_TEST_P(ModifiersTest, InsertRangeWithinCapacity)
+        {
 #if !defined(__GLIBCXX__)
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> base_values;
-  std::generate_n(std::back_inserter(base_values), 10,
-                  hash_internal::Generator<T>());
-  std::vector<T> values;
-  while (values.size() != 100) {
-    std::copy_n(base_values.begin(), 10, std::back_inserter(values));
-  }
-  TypeParam m;
-  m.reserve(10);
-  const size_t original_capacity = m.bucket_count();
-  m.insert(values.begin(), values.end());
-  EXPECT_EQ(m.bucket_count(), original_capacity);
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> base_values;
+            std::generate_n(std::back_inserter(base_values), 10, hash_internal::Generator<T>());
+            std::vector<T> values;
+            while (values.size() != 100)
+            {
+                std::copy_n(base_values.begin(), 10, std::back_inserter(values));
+            }
+            TypeParam m;
+            m.reserve(10);
+            const size_t original_capacity = m.bucket_count();
+            m.insert(values.begin(), values.end());
+            EXPECT_EQ(m.bucket_count(), original_capacity);
 #endif
-}
+        }
 
-TYPED_TEST_P(ModifiersTest, InsertOrAssign) {
+        TYPED_TEST_P(ModifiersTest, InsertOrAssign)
+        {
 #ifdef UNORDERED_MAP_CXX17
-  using std::get;
-  using K = typename TypeParam::key_type;
-  using V = typename TypeParam::mapped_type;
-  K k = hash_internal::Generator<K>()();
-  V val = hash_internal::Generator<V>()();
-  TypeParam m;
-  auto p = m.insert_or_assign(k, val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(k, get<0>(*p.first));
-  EXPECT_EQ(val, get<1>(*p.first));
-  V val2 = hash_internal::Generator<V>()();
-  p = m.insert_or_assign(k, val2);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(k, get<0>(*p.first));
-  EXPECT_EQ(val2, get<1>(*p.first));
+            using std::get;
+            using K = typename TypeParam::key_type;
+            using V = typename TypeParam::mapped_type;
+            K k = hash_internal::Generator<K>()();
+            V val = hash_internal::Generator<V>()();
+            TypeParam m;
+            auto p = m.insert_or_assign(k, val);
+            EXPECT_TRUE(p.second);
+            EXPECT_EQ(k, get<0>(*p.first));
+            EXPECT_EQ(val, get<1>(*p.first));
+            V val2 = hash_internal::Generator<V>()();
+            p = m.insert_or_assign(k, val2);
+            EXPECT_FALSE(p.second);
+            EXPECT_EQ(k, get<0>(*p.first));
+            EXPECT_EQ(val2, get<1>(*p.first));
 #endif
-}
+        }
 
-TYPED_TEST_P(ModifiersTest, InsertOrAssignHint) {
+        TYPED_TEST_P(ModifiersTest, InsertOrAssignHint)
+        {
 #ifdef UNORDERED_MAP_CXX17
-  using std::get;
-  using K = typename TypeParam::key_type;
-  using V = typename TypeParam::mapped_type;
-  K k = hash_internal::Generator<K>()();
-  V val = hash_internal::Generator<V>()();
-  TypeParam m;
-  auto it = m.insert_or_assign(m.end(), k, val);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(k, get<0>(*it));
-  EXPECT_EQ(val, get<1>(*it));
-  V val2 = hash_internal::Generator<V>()();
-  it = m.insert_or_assign(it, k, val2);
-  EXPECT_EQ(k, get<0>(*it));
-  EXPECT_EQ(val2, get<1>(*it));
+            using std::get;
+            using K = typename TypeParam::key_type;
+            using V = typename TypeParam::mapped_type;
+            K k = hash_internal::Generator<K>()();
+            V val = hash_internal::Generator<V>()();
+            TypeParam m;
+            auto it = m.insert_or_assign(m.end(), k, val);
+            EXPECT_TRUE(it != m.end());
+            EXPECT_EQ(k, get<0>(*it));
+            EXPECT_EQ(val, get<1>(*it));
+            V val2 = hash_internal::Generator<V>()();
+            it = m.insert_or_assign(it, k, val2);
+            EXPECT_EQ(k, get<0>(*it));
+            EXPECT_EQ(val2, get<1>(*it));
 #endif
-}
-
-TYPED_TEST_P(ModifiersTest, Emplace) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto p = m.emplace(val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  p = m.emplace(val2);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(val, *p.first);
-}
-
-TYPED_TEST_P(ModifiersTest, EmplaceHint) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto it = m.emplace_hint(m.end(), val);
-  EXPECT_EQ(val, *it);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  it = m.emplace_hint(it, val2);
-  EXPECT_EQ(val, *it);
-}
-
-TYPED_TEST_P(ModifiersTest, TryEmplace) {
+        }
+
+        TYPED_TEST_P(ModifiersTest, Emplace)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+            // with test traits/policy.
+            auto p = m.emplace(val);
+            EXPECT_TRUE(p.second);
+            EXPECT_EQ(val, *p.first);
+            T val2 = {val.first, hash_internal::Generator<V>()()};
+            p = m.emplace(val2);
+            EXPECT_FALSE(p.second);
+            EXPECT_EQ(val, *p.first);
+        }
+
+        TYPED_TEST_P(ModifiersTest, EmplaceHint)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+            // with test traits/policy.
+            auto it = m.emplace_hint(m.end(), val);
+            EXPECT_EQ(val, *it);
+            T val2 = {val.first, hash_internal::Generator<V>()()};
+            it = m.emplace_hint(it, val2);
+            EXPECT_EQ(val, *it);
+        }
+
+        TYPED_TEST_P(ModifiersTest, TryEmplace)
+        {
 #ifdef UNORDERED_MAP_CXX17
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto p = m.try_emplace(val.first, val.second);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  p = m.try_emplace(val2.first, val2.second);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(val, *p.first);
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+            // with test traits/policy.
+            auto p = m.try_emplace(val.first, val.second);
+            EXPECT_TRUE(p.second);
+            EXPECT_EQ(val, *p.first);
+            T val2 = {val.first, hash_internal::Generator<V>()()};
+            p = m.try_emplace(val2.first, val2.second);
+            EXPECT_FALSE(p.second);
+            EXPECT_EQ(val, *p.first);
 #endif
-}
+        }
 
-TYPED_TEST_P(ModifiersTest, TryEmplaceHint) {
+        TYPED_TEST_P(ModifiersTest, TryEmplaceHint)
+        {
 #ifdef UNORDERED_MAP_CXX17
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto it = m.try_emplace(m.end(), val.first, val.second);
-  EXPECT_EQ(val, *it);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  it = m.try_emplace(it, val2.first, val2.second);
-  EXPECT_EQ(val, *it);
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+            // with test traits/policy.
+            auto it = m.try_emplace(m.end(), val.first, val.second);
+            EXPECT_EQ(val, *it);
+            T val2 = {val.first, hash_internal::Generator<V>()()};
+            it = m.try_emplace(it, val2.first, val2.second);
+            EXPECT_EQ(val, *it);
 #endif
-}
-
-template <class V>
-using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
-
-// In openmap we chose not to return the iterator from erase because that's
-// more expensive. As such we adapt erase to return an iterator here.
-struct EraseFirst {
-  template <class Map>
-  auto operator()(Map* m, int) const
-      -> IfNotVoid<decltype(m->erase(m->begin()))> {
-    return m->erase(m->begin());
-  }
-  template <class Map>
-  typename Map::iterator operator()(Map* m, ...) const {
-    auto it = m->begin();
-    m->erase(it++);
-    return it;
-  }
-};
-
-TYPED_TEST_P(ModifiersTest, Erase) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using std::get;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  auto& first = *m.begin();
-  std::vector<T> values2;
-  for (const auto& val : values)
-    if (get<0>(val) != get<0>(first)) values2.push_back(val);
-  auto it = EraseFirst()(&m, 0);
-  ASSERT_TRUE(it != m.end());
-  EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values2.begin(),
-                                                             values2.end()));
-}
-
-TYPED_TEST_P(ModifiersTest, EraseRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  auto it = m.erase(m.begin(), m.end());
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAre());
-  EXPECT_TRUE(it == m.end());
-}
-
-TYPED_TEST_P(ModifiersTest, EraseKey) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_EQ(1, m.erase(values[0].first));
-  EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
-  EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values.begin() + 1,
-                                                             values.end()));
-}
-
-TYPED_TEST_P(ModifiersTest, Swap) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> v1;
-  std::vector<T> v2;
-  std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
-  std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
-  TypeParam m1(v1.begin(), v1.end());
-  TypeParam m2(v2.begin(), v2.end());
-  EXPECT_THAT(items(m1), ::testing::UnorderedElementsAreArray(v1));
-  EXPECT_THAT(items(m2), ::testing::UnorderedElementsAreArray(v2));
-  m1.swap(m2);
-  EXPECT_THAT(items(m1), ::testing::UnorderedElementsAreArray(v2));
-  EXPECT_THAT(items(m2), ::testing::UnorderedElementsAreArray(v1));
-}
-
-// TODO(alkis): Write tests for extract.
-// TODO(alkis): Write tests for merge.
-
-REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint,
-                            InsertRange, InsertWithinCapacity,
-                            InsertRangeWithinCapacity, InsertOrAssign,
-                            InsertOrAssignHint, Emplace, EmplaceHint,
-                            TryEmplace, TryEmplaceHint, Erase, EraseRange,
-                            EraseKey, Swap);
-
-template <typename Type>
-struct is_unique_ptr : std::false_type {};
-
-template <typename Type>
-struct is_unique_ptr<std::unique_ptr<Type>> : std::true_type {};
-
-template <class UnordMap>
-class UniquePtrModifiersTest : public ::testing::Test {
- protected:
-  UniquePtrModifiersTest() {
-    static_assert(is_unique_ptr<typename UnordMap::mapped_type>::value,
-                  "UniquePtrModifiersTyest may only be called with a "
-                  "std::unique_ptr value type.");
-  }
-};
-
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UniquePtrModifiersTest);
-
-TYPED_TEST_SUITE_P(UniquePtrModifiersTest);
-
-// Test that we do not move from rvalue arguments if an insertion does not
-// happen.
-TYPED_TEST_P(UniquePtrModifiersTest, TryEmplace) {
+        }
+
+        template<class V>
+        using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
+
+        // In openmap we chose not to return the iterator from erase because that's
+        // more expensive. As such we adapt erase to return an iterator here.
+        struct EraseFirst
+        {
+            template<class Map>
+            auto operator()(Map* m, int) const
+                -> IfNotVoid<decltype(m->erase(m->begin()))>
+            {
+                return m->erase(m->begin());
+            }
+            template<class Map>
+            typename Map::iterator operator()(Map* m, ...) const
+            {
+                auto it = m->begin();
+                m->erase(it++);
+                return it;
+            }
+        };
+
+        TYPED_TEST_P(ModifiersTest, Erase)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using std::get;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            auto& first = *m.begin();
+            std::vector<T> values2;
+            for (const auto& val : values)
+                if (get<0>(val) != get<0>(first))
+                    values2.push_back(val);
+            auto it = EraseFirst()(&m, 0);
+            ASSERT_TRUE(it != m.end());
+            EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values2.begin(), values2.end()));
+        }
+
+        TYPED_TEST_P(ModifiersTest, EraseRange)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            auto it = m.erase(m.begin(), m.end());
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAre());
+            EXPECT_TRUE(it == m.end());
+        }
+
+        TYPED_TEST_P(ModifiersTest, EraseKey)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            ASSERT_THAT(items(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_EQ(1, m.erase(values[0].first));
+            EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
+            EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values.begin() + 1, values.end()));
+        }
+
+        TYPED_TEST_P(ModifiersTest, Swap)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> v1;
+            std::vector<T> v2;
+            std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
+            std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
+            TypeParam m1(v1.begin(), v1.end());
+            TypeParam m2(v2.begin(), v2.end());
+            EXPECT_THAT(items(m1), ::testing::UnorderedElementsAreArray(v1));
+            EXPECT_THAT(items(m2), ::testing::UnorderedElementsAreArray(v2));
+            m1.swap(m2);
+            EXPECT_THAT(items(m1), ::testing::UnorderedElementsAreArray(v2));
+            EXPECT_THAT(items(m2), ::testing::UnorderedElementsAreArray(v1));
+        }
+
+        // TODO(alkis): Write tests for extract.
+        // TODO(alkis): Write tests for merge.
+
+        REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint, InsertRange, InsertWithinCapacity, InsertRangeWithinCapacity, InsertOrAssign, InsertOrAssignHint, Emplace, EmplaceHint, TryEmplace, TryEmplaceHint, Erase, EraseRange, EraseKey, Swap);
+
+        template<typename Type>
+        struct is_unique_ptr : std::false_type
+        {
+        };
+
+        template<typename Type>
+        struct is_unique_ptr<std::unique_ptr<Type>> : std::true_type
+        {
+        };
+
+        template<class UnordMap>
+        class UniquePtrModifiersTest : public ::testing::Test
+        {
+        protected:
+            UniquePtrModifiersTest()
+            {
+                static_assert(is_unique_ptr<typename UnordMap::mapped_type>::value, "UniquePtrModifiersTyest may only be called with a "
+                                                                                    "std::unique_ptr value type.");
+            }
+        };
+
+        GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UniquePtrModifiersTest);
+
+        TYPED_TEST_SUITE_P(UniquePtrModifiersTest);
+
+        // Test that we do not move from rvalue arguments if an insertion does not
+        // happen.
+        TYPED_TEST_P(UniquePtrModifiersTest, TryEmplace)
+        {
 #ifdef UNORDERED_MAP_CXX17
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using V = typename TypeParam::mapped_type;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto p = m.try_emplace(val.first, std::move(val.second));
-  EXPECT_TRUE(p.second);
-  // A moved from std::unique_ptr is guaranteed to be nullptr.
-  EXPECT_EQ(val.second, nullptr);
-  T val2 = {val.first, hash_internal::Generator<V>()()};
-  p = m.try_emplace(val2.first, std::move(val2.second));
-  EXPECT_FALSE(p.second);
-  EXPECT_NE(val2.second, nullptr);
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using V = typename TypeParam::mapped_type;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            auto p = m.try_emplace(val.first, std::move(val.second));
+            EXPECT_TRUE(p.second);
+            // A moved from std::unique_ptr is guaranteed to be nullptr.
+            EXPECT_EQ(val.second, nullptr);
+            T val2 = {val.first, hash_internal::Generator<V>()()};
+            p = m.try_emplace(val2.first, std::move(val2.second));
+            EXPECT_FALSE(p.second);
+            EXPECT_NE(val2.second, nullptr);
 #endif
-}
+        }
 
-REGISTER_TYPED_TEST_SUITE_P(UniquePtrModifiersTest, TryEmplace);
+        REGISTER_TYPED_TEST_SUITE_P(UniquePtrModifiersTest, TryEmplace);
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_constructor_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_constructor_test.h
index af1116e..4496996 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_constructor_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_constructor_test.h
@@ -25,472 +25,527 @@
 #include "absl/container/internal/hash_policy_testing.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordMap>
-class ConstructorTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(ConstructorTest);
-
-TYPED_TEST_P(ConstructorTest, NoArgs) {
-  TypeParam m;
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCount) {
-  TypeParam m(123);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHash) {
-  using H = typename TypeParam::hasher;
-  H hasher;
-  TypeParam m(123, hasher);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashEqual) {
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  H hasher;
-  E equal;
-  TypeParam m(123, hasher, equal);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashEqualAlloc) {
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-
-  const auto& cm = m;
-  EXPECT_EQ(cm.hash_function(), hasher);
-  EXPECT_EQ(cm.key_eq(), equal);
-  EXPECT_EQ(cm.get_allocator(), alloc);
-  EXPECT_TRUE(cm.empty());
-  EXPECT_THAT(keys(cm), ::testing::UnorderedElementsAre());
-  EXPECT_GE(cm.bucket_count(), 123);
-}
-
-template <typename T>
-struct is_std_unordered_set : std::false_type {};
-
-template <typename... T>
-struct is_std_unordered_set<std::unordered_set<T...>> : std::true_type {};
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<class UnordMap>
+        class ConstructorTest : public ::testing::Test
+        {
+        };
+
+        TYPED_TEST_SUITE_P(ConstructorTest);
+
+        TYPED_TEST_P(ConstructorTest, NoArgs)
+        {
+            TypeParam m;
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCount)
+        {
+            TypeParam m(123);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountHash)
+        {
+            using H = typename TypeParam::hasher;
+            H hasher;
+            TypeParam m(123, hasher);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountHashEqual)
+        {
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            H hasher;
+            E equal;
+            TypeParam m(123, hasher, equal);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.key_eq(), equal);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountHashEqualAlloc)
+        {
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            TypeParam m(123, hasher, equal, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.key_eq(), equal);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+
+            const auto& cm = m;
+            EXPECT_EQ(cm.hash_function(), hasher);
+            EXPECT_EQ(cm.key_eq(), equal);
+            EXPECT_EQ(cm.get_allocator(), alloc);
+            EXPECT_TRUE(cm.empty());
+            EXPECT_THAT(keys(cm), ::testing::UnorderedElementsAre());
+            EXPECT_GE(cm.bucket_count(), 123);
+        }
+
+        template<typename T>
+        struct is_std_unordered_set : std::false_type
+        {
+        };
+
+        template<typename... T>
+        struct is_std_unordered_set<std::unordered_set<T...>> : std::true_type
+        {
+        };
 
 #if defined(UNORDERED_SET_CXX14) || defined(UNORDERED_SET_CXX17)
-using has_cxx14_std_apis = std::true_type;
+        using has_cxx14_std_apis = std::true_type;
 #else
-using has_cxx14_std_apis = std::false_type;
+        using has_cxx14_std_apis = std::false_type;
 #endif
 
-template <typename T>
-using expect_cxx14_apis =
-    absl::disjunction<absl::negation<is_std_unordered_set<T>>,
-                      has_cxx14_std_apis>;
-
-template <typename TypeParam>
-void BucketCountAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void BucketCountAllocTest(std::true_type) {
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  TypeParam m(123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountAlloc) {
-  BucketCountAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void BucketCountHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void BucketCountHashAllocTest(std::true_type) {
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  TypeParam m(123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc) {
-  BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
+        template<typename T>
+        using expect_cxx14_apis =
+            absl::disjunction<absl::negation<is_std_unordered_set<T>>, has_cxx14_std_apis>;
+
+        template<typename TypeParam>
+        void BucketCountAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void BucketCountAllocTest(std::true_type)
+        {
+            using A = typename TypeParam::allocator_type;
+            A alloc(0);
+            TypeParam m(123, alloc);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountAlloc)
+        {
+            BucketCountAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        template<typename TypeParam>
+        void BucketCountHashAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void BucketCountHashAllocTest(std::true_type)
+        {
+            using H = typename TypeParam::hasher;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            A alloc(0);
+            TypeParam m(123, hasher, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc)
+        {
+            BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
 
 #if ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
-using has_alloc_std_constructors = std::true_type;
+        using has_alloc_std_constructors = std::true_type;
 #else
-using has_alloc_std_constructors = std::false_type;
+        using has_alloc_std_constructors = std::false_type;
 #endif
 
-template <typename T>
-using expect_alloc_constructors =
-    absl::disjunction<absl::negation<is_std_unordered_set<T>>,
-                      has_alloc_std_constructors>;
-
-template <typename TypeParam>
-void AllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void AllocTest(std::true_type) {
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  TypeParam m(alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_TRUE(m.empty());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-}
-
-TYPED_TEST_P(ConstructorTest, Alloc) {
-  AllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashEqualAlloc) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  std::vector<T> values;
-  for (size_t i = 0; i != 10; ++i)
-    values.push_back(hash_internal::Generator<T>()());
-  TypeParam m(values.begin(), values.end(), 123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename TypeParam>
-void InputIteratorBucketAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InputIteratorBucketAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using A = typename TypeParam::allocator_type;
-  A alloc(0);
-  std::vector<T> values;
-  for (size_t i = 0; i != 10; ++i)
-    values.push_back(hash_internal::Generator<T>()());
-  TypeParam m(values.begin(), values.end(), 123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketAlloc) {
-  InputIteratorBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void InputIteratorBucketHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InputIteratorBucketHashAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  std::vector<T> values;
-  for (size_t i = 0; i != 10; ++i)
-    values.push_back(hash_internal::Generator<T>()());
-  TypeParam m(values.begin(), values.end(), 123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashAlloc) {
-  InputIteratorBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, CopyConstructor) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
-  TypeParam n(m);
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-  EXPECT_NE(TypeParam(0, hasher, equal, alloc), n);
-}
-
-template <typename TypeParam>
-void CopyConstructorAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void CopyConstructorAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
-  TypeParam n(m, A(11));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_NE(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, CopyConstructorAlloc) {
-  CopyConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-// TODO(alkis): Test non-propagating allocators on copy constructors.
-
-TYPED_TEST_P(ConstructorTest, MoveConstructor) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
-  TypeParam t(m);
-  TypeParam n(std::move(t));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-template <typename TypeParam>
-void MoveConstructorAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void MoveConstructorAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(123, hasher, equal, alloc);
-  for (size_t i = 0; i != 10; ++i) m.insert(hash_internal::Generator<T>()());
-  TypeParam t(m);
-  TypeParam n(std::move(t), A(1));
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_NE(m.get_allocator(), n.get_allocator());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, MoveConstructorAlloc) {
-  MoveConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
-}
-
-// TODO(alkis): Test non-propagating allocators on move constructors.
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketHashEqualAlloc) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  TypeParam m(values, 123, hasher, equal, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.key_eq(), equal);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-template <typename TypeParam>
-void InitializerListBucketAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InitializerListBucketAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using A = typename TypeParam::allocator_type;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  A alloc(0);
-  TypeParam m(values, 123, alloc);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketAlloc) {
-  InitializerListBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-template <typename TypeParam>
-void InitializerListBucketHashAllocTest(std::false_type) {}
-
-template <typename TypeParam>
-void InitializerListBucketHashAllocTest(std::true_type) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  A alloc(0);
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m(values, 123, hasher, alloc);
-  EXPECT_EQ(m.hash_function(), hasher);
-  EXPECT_EQ(m.get_allocator(), alloc);
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_GE(m.bucket_count(), 123);
-}
-
-TYPED_TEST_P(ConstructorTest, InitializerListBucketHashAlloc) {
-  InitializerListBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
-}
-
-TYPED_TEST_P(ConstructorTest, CopyAssignment) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::Generator<T> gen;
-  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
-  TypeParam n;
-  n = m;
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m, n);
-}
-
-// TODO(alkis): Test [non-]propagating allocators on move/copy assignments
-// (it depends on traits).
-
-TYPED_TEST_P(ConstructorTest, MoveAssignment) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  using H = typename TypeParam::hasher;
-  using E = typename TypeParam::key_equal;
-  using A = typename TypeParam::allocator_type;
-  H hasher;
-  E equal;
-  A alloc(0);
-  hash_internal::Generator<T> gen;
-  TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
-  TypeParam t(m);
-  TypeParam n;
-  n = std::move(t);
-  EXPECT_EQ(m.hash_function(), n.hash_function());
-  EXPECT_EQ(m.key_eq(), n.key_eq());
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m;
-  m = values;
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  TypeParam m({gen(), gen(), gen()});
-  TypeParam n({gen()});
-  n = m;
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, MoveAssignmentOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  TypeParam m({gen(), gen(), gen()});
-  TypeParam t(m);
-  TypeParam n({gen()});
-  n = std::move(t);
-  EXPECT_EQ(m, n);
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerListOverwritesExisting) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m;
-  m = values;
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ConstructorTest, AssignmentOnSelf) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  hash_internal::Generator<T> gen;
-  std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
-  TypeParam m(values);
-  m = *&m;  // Avoid -Wself-assign.
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-REGISTER_TYPED_TEST_SUITE_P(
-    ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual,
-    BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc,
-    InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc,
-    InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc,
-    MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc,
-    InitializerListBucketAlloc, InitializerListBucketHashAlloc, CopyAssignment,
-    MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting,
-    MoveAssignmentOverwritesExisting,
-    AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+        template<typename T>
+        using expect_alloc_constructors =
+            absl::disjunction<absl::negation<is_std_unordered_set<T>>, has_alloc_std_constructors>;
+
+        template<typename TypeParam>
+        void AllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void AllocTest(std::true_type)
+        {
+            using A = typename TypeParam::allocator_type;
+            A alloc(0);
+            TypeParam m(alloc);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_TRUE(m.empty());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+        }
+
+        TYPED_TEST_P(ConstructorTest, Alloc)
+        {
+            AllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+        }
+
+        TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashEqualAlloc)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            std::vector<T> values;
+            for (size_t i = 0; i != 10; ++i)
+                values.push_back(hash_internal::Generator<T>()());
+            TypeParam m(values.begin(), values.end(), 123, hasher, equal, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.key_eq(), equal);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        template<typename TypeParam>
+        void InputIteratorBucketAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void InputIteratorBucketAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using A = typename TypeParam::allocator_type;
+            A alloc(0);
+            std::vector<T> values;
+            for (size_t i = 0; i != 10; ++i)
+                values.push_back(hash_internal::Generator<T>()());
+            TypeParam m(values.begin(), values.end(), 123, alloc);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, InputIteratorBucketAlloc)
+        {
+            InputIteratorBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        template<typename TypeParam>
+        void InputIteratorBucketHashAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void InputIteratorBucketHashAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            A alloc(0);
+            std::vector<T> values;
+            for (size_t i = 0; i != 10; ++i)
+                values.push_back(hash_internal::Generator<T>()());
+            TypeParam m(values.begin(), values.end(), 123, hasher, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, InputIteratorBucketHashAlloc)
+        {
+            InputIteratorBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        TYPED_TEST_P(ConstructorTest, CopyConstructor)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            TypeParam m(123, hasher, equal, alloc);
+            for (size_t i = 0; i != 10; ++i)
+                m.insert(hash_internal::Generator<T>()());
+            TypeParam n(m);
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_EQ(m.get_allocator(), n.get_allocator());
+            EXPECT_EQ(m, n);
+            EXPECT_NE(TypeParam(0, hasher, equal, alloc), n);
+        }
+
+        template<typename TypeParam>
+        void CopyConstructorAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void CopyConstructorAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            TypeParam m(123, hasher, equal, alloc);
+            for (size_t i = 0; i != 10; ++i)
+                m.insert(hash_internal::Generator<T>()());
+            TypeParam n(m, A(11));
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_NE(m.get_allocator(), n.get_allocator());
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, CopyConstructorAlloc)
+        {
+            CopyConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+        }
+
+        // TODO(alkis): Test non-propagating allocators on copy constructors.
+
+        TYPED_TEST_P(ConstructorTest, MoveConstructor)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            TypeParam m(123, hasher, equal, alloc);
+            for (size_t i = 0; i != 10; ++i)
+                m.insert(hash_internal::Generator<T>()());
+            TypeParam t(m);
+            TypeParam n(std::move(t));
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_EQ(m.get_allocator(), n.get_allocator());
+            EXPECT_EQ(m, n);
+        }
+
+        template<typename TypeParam>
+        void MoveConstructorAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void MoveConstructorAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            TypeParam m(123, hasher, equal, alloc);
+            for (size_t i = 0; i != 10; ++i)
+                m.insert(hash_internal::Generator<T>()());
+            TypeParam t(m);
+            TypeParam n(std::move(t), A(1));
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_NE(m.get_allocator(), n.get_allocator());
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, MoveConstructorAlloc)
+        {
+            MoveConstructorAllocTest<TypeParam>(expect_alloc_constructors<TypeParam>());
+        }
+
+        // TODO(alkis): Test non-propagating allocators on move constructors.
+
+        TYPED_TEST_P(ConstructorTest, InitializerListBucketHashEqualAlloc)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::Generator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            TypeParam m(values, 123, hasher, equal, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.key_eq(), equal);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        template<typename TypeParam>
+        void InitializerListBucketAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void InitializerListBucketAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using A = typename TypeParam::allocator_type;
+            hash_internal::Generator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            A alloc(0);
+            TypeParam m(values, 123, alloc);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, InitializerListBucketAlloc)
+        {
+            InitializerListBucketAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        template<typename TypeParam>
+        void InitializerListBucketHashAllocTest(std::false_type)
+        {
+        }
+
+        template<typename TypeParam>
+        void InitializerListBucketHashAllocTest(std::true_type)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            A alloc(0);
+            hash_internal::Generator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            TypeParam m(values, 123, hasher, alloc);
+            EXPECT_EQ(m.hash_function(), hasher);
+            EXPECT_EQ(m.get_allocator(), alloc);
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_GE(m.bucket_count(), 123);
+        }
+
+        TYPED_TEST_P(ConstructorTest, InitializerListBucketHashAlloc)
+        {
+            InitializerListBucketHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
+        }
+
+        TYPED_TEST_P(ConstructorTest, CopyAssignment)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            hash_internal::Generator<T> gen;
+            TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
+            TypeParam n;
+            n = m;
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_EQ(m, n);
+        }
+
+        // TODO(alkis): Test [non-]propagating allocators on move/copy assignments
+        // (it depends on traits).
+
+        TYPED_TEST_P(ConstructorTest, MoveAssignment)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            using H = typename TypeParam::hasher;
+            using E = typename TypeParam::key_equal;
+            using A = typename TypeParam::allocator_type;
+            H hasher;
+            E equal;
+            A alloc(0);
+            hash_internal::Generator<T> gen;
+            TypeParam m({gen(), gen(), gen()}, 123, hasher, equal, alloc);
+            TypeParam t(m);
+            TypeParam n;
+            n = std::move(t);
+            EXPECT_EQ(m.hash_function(), n.hash_function());
+            EXPECT_EQ(m.key_eq(), n.key_eq());
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::Generator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            TypeParam m;
+            m = values;
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+        }
+
+        TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::Generator<T> gen;
+            TypeParam m({gen(), gen(), gen()});
+            TypeParam n({gen()});
+            n = m;
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, MoveAssignmentOverwritesExisting)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::Generator<T> gen;
+            TypeParam m({gen(), gen(), gen()});
+            TypeParam t(m);
+            TypeParam n({gen()});
+            n = std::move(t);
+            EXPECT_EQ(m, n);
+        }
+
+        TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerListOverwritesExisting)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::Generator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            TypeParam m;
+            m = values;
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+        }
+
+        TYPED_TEST_P(ConstructorTest, AssignmentOnSelf)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            hash_internal::Generator<T> gen;
+            std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
+            TypeParam m(values);
+            m = *&m;  // Avoid -Wself-assign.
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+        }
+
+        REGISTER_TYPED_TEST_SUITE_P(
+            ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual, BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc, InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc, InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc, MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc, InitializerListBucketAlloc, InitializerListBucketHashAlloc, CopyAssignment, MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting, MoveAssignmentOverwritesExisting, AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf
+        );
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_lookup_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_lookup_test.h
index b35f766..7775f6d 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_lookup_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_lookup_test.h
@@ -20,72 +20,75 @@
 #include "absl/container/internal/hash_generator_testing.h"
 #include "absl/container/internal/hash_policy_testing.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
 
-template <class UnordSet>
-class LookupTest : public ::testing::Test {};
+        template<class UnordSet>
+        class LookupTest : public ::testing::Test
+        {
+        };
 
-TYPED_TEST_SUITE_P(LookupTest);
+        TYPED_TEST_SUITE_P(LookupTest);
 
-TYPED_TEST_P(LookupTest, Count) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& v : values)
-    EXPECT_EQ(0, m.count(v)) << ::testing::PrintToString(v);
-  m.insert(values.begin(), values.end());
-  for (const auto& v : values)
-    EXPECT_EQ(1, m.count(v)) << ::testing::PrintToString(v);
-}
+        TYPED_TEST_P(LookupTest, Count)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            for (const auto& v : values)
+                EXPECT_EQ(0, m.count(v)) << ::testing::PrintToString(v);
+            m.insert(values.begin(), values.end());
+            for (const auto& v : values)
+                EXPECT_EQ(1, m.count(v)) << ::testing::PrintToString(v);
+        }
 
-TYPED_TEST_P(LookupTest, Find) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& v : values)
-    EXPECT_TRUE(m.end() == m.find(v)) << ::testing::PrintToString(v);
-  m.insert(values.begin(), values.end());
-  for (const auto& v : values) {
-    typename TypeParam::iterator it = m.find(v);
-    static_assert(std::is_same<const typename TypeParam::value_type&,
-                               decltype(*it)>::value,
-                  "");
-    static_assert(std::is_same<const typename TypeParam::value_type*,
-                               decltype(it.operator->())>::value,
-                  "");
-    EXPECT_TRUE(m.end() != it) << ::testing::PrintToString(v);
-    EXPECT_EQ(v, *it) << ::testing::PrintToString(v);
-  }
-}
+        TYPED_TEST_P(LookupTest, Find)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            for (const auto& v : values)
+                EXPECT_TRUE(m.end() == m.find(v)) << ::testing::PrintToString(v);
+            m.insert(values.begin(), values.end());
+            for (const auto& v : values)
+            {
+                typename TypeParam::iterator it = m.find(v);
+                static_assert(std::is_same<const typename TypeParam::value_type&, decltype(*it)>::value, "");
+                static_assert(std::is_same<const typename TypeParam::value_type*, decltype(it.operator->())>::value, "");
+                EXPECT_TRUE(m.end() != it) << ::testing::PrintToString(v);
+                EXPECT_EQ(v, *it) << ::testing::PrintToString(v);
+            }
+        }
 
-TYPED_TEST_P(LookupTest, EqualRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  for (const auto& v : values) {
-    auto r = m.equal_range(v);
-    ASSERT_EQ(0, std::distance(r.first, r.second));
-  }
-  m.insert(values.begin(), values.end());
-  for (const auto& v : values) {
-    auto r = m.equal_range(v);
-    ASSERT_EQ(1, std::distance(r.first, r.second));
-    EXPECT_EQ(v, *r.first);
-  }
-}
+        TYPED_TEST_P(LookupTest, EqualRange)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            for (const auto& v : values)
+            {
+                auto r = m.equal_range(v);
+                ASSERT_EQ(0, std::distance(r.first, r.second));
+            }
+            m.insert(values.begin(), values.end());
+            for (const auto& v : values)
+            {
+                auto r = m.equal_range(v);
+                ASSERT_EQ(1, std::distance(r.first, r.second));
+                EXPECT_EQ(v, *r.first);
+            }
+        }
 
-REGISTER_TYPED_TEST_SUITE_P(LookupTest, Count, Find, EqualRange);
+        REGISTER_TYPED_TEST_SUITE_P(LookupTest, Count, Find, EqualRange);
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_members_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_members_test.h
index 4c5e104..ccc772f 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_members_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_members_test.h
@@ -20,67 +20,71 @@
 #include "gtest/gtest.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
 
-template <class UnordSet>
-class MembersTest : public ::testing::Test {};
+        template<class UnordSet>
+        class MembersTest : public ::testing::Test
+        {
+        };
 
-TYPED_TEST_SUITE_P(MembersTest);
+        TYPED_TEST_SUITE_P(MembersTest);
 
-template <typename T>
-void UseType() {}
+        template<typename T>
+        void UseType()
+        {
+        }
 
-TYPED_TEST_P(MembersTest, Typedefs) {
-  EXPECT_TRUE((std::is_same<typename TypeParam::key_type,
-                            typename TypeParam::value_type>()));
-  EXPECT_TRUE((absl::conjunction<
-               absl::negation<std::is_signed<typename TypeParam::size_type>>,
-               std::is_integral<typename TypeParam::size_type>>()));
-  EXPECT_TRUE((absl::conjunction<
-               std::is_signed<typename TypeParam::difference_type>,
-               std::is_integral<typename TypeParam::difference_type>>()));
-  EXPECT_TRUE((std::is_convertible<
-               decltype(std::declval<const typename TypeParam::hasher&>()(
-                   std::declval<const typename TypeParam::key_type&>())),
-               size_t>()));
-  EXPECT_TRUE((std::is_convertible<
-               decltype(std::declval<const typename TypeParam::key_equal&>()(
-                   std::declval<const typename TypeParam::key_type&>(),
-                   std::declval<const typename TypeParam::key_type&>())),
-               bool>()));
-  EXPECT_TRUE((std::is_same<typename TypeParam::allocator_type::value_type,
-                            typename TypeParam::value_type>()));
-  EXPECT_TRUE((std::is_same<typename TypeParam::value_type&,
-                            typename TypeParam::reference>()));
-  EXPECT_TRUE((std::is_same<const typename TypeParam::value_type&,
-                            typename TypeParam::const_reference>()));
-  EXPECT_TRUE((std::is_same<typename std::allocator_traits<
-                                typename TypeParam::allocator_type>::pointer,
-                            typename TypeParam::pointer>()));
-  EXPECT_TRUE(
-      (std::is_same<typename std::allocator_traits<
-                        typename TypeParam::allocator_type>::const_pointer,
-                    typename TypeParam::const_pointer>()));
-}
+        TYPED_TEST_P(MembersTest, Typedefs)
+        {
+            EXPECT_TRUE((std::is_same<typename TypeParam::key_type, typename TypeParam::value_type>()));
+            EXPECT_TRUE((absl::conjunction<
+                         absl::negation<std::is_signed<typename TypeParam::size_type>>,
+                         std::is_integral<typename TypeParam::size_type>>()));
+            EXPECT_TRUE((absl::conjunction<
+                         std::is_signed<typename TypeParam::difference_type>,
+                         std::is_integral<typename TypeParam::difference_type>>()));
+            EXPECT_TRUE((std::is_convertible<
+                         decltype(std::declval<const typename TypeParam::hasher&>()(
+                             std::declval<const typename TypeParam::key_type&>()
+                         )),
+                         size_t>()));
+            EXPECT_TRUE((std::is_convertible<
+                         decltype(std::declval<const typename TypeParam::key_equal&>()(
+                             std::declval<const typename TypeParam::key_type&>(),
+                             std::declval<const typename TypeParam::key_type&>()
+                         )),
+                         bool>()));
+            EXPECT_TRUE((std::is_same<typename TypeParam::allocator_type::value_type, typename TypeParam::value_type>()));
+            EXPECT_TRUE((std::is_same<typename TypeParam::value_type&, typename TypeParam::reference>()));
+            EXPECT_TRUE((std::is_same<const typename TypeParam::value_type&, typename TypeParam::const_reference>()));
+            EXPECT_TRUE((std::is_same<typename std::allocator_traits<typename TypeParam::allocator_type>::pointer, typename TypeParam::pointer>()));
+            EXPECT_TRUE(
+                (std::is_same<typename std::allocator_traits<typename TypeParam::allocator_type>::const_pointer, typename TypeParam::const_pointer>())
+            );
+        }
 
-TYPED_TEST_P(MembersTest, SimpleFunctions) {
-  EXPECT_GT(TypeParam().max_size(), 0);
-}
+        TYPED_TEST_P(MembersTest, SimpleFunctions)
+        {
+            EXPECT_GT(TypeParam().max_size(), 0);
+        }
 
-TYPED_TEST_P(MembersTest, BeginEnd) {
-  TypeParam t = {typename TypeParam::value_type{}};
-  EXPECT_EQ(t.begin(), t.cbegin());
-  EXPECT_EQ(t.end(), t.cend());
-  EXPECT_NE(t.begin(), t.end());
-  EXPECT_NE(t.cbegin(), t.cend());
-}
+        TYPED_TEST_P(MembersTest, BeginEnd)
+        {
+            TypeParam t = {typename TypeParam::value_type{}};
+            EXPECT_EQ(t.begin(), t.cbegin());
+            EXPECT_EQ(t.end(), t.cend());
+            EXPECT_NE(t.begin(), t.end());
+            EXPECT_NE(t.cbegin(), t.cend());
+        }
 
-REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
+        REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
 
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_modifiers_test.h b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_modifiers_test.h
index d8864bb..92137f4 100644
--- a/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_modifiers_test.h
+++ b/CAPI/cpp/grpc/include/absl/container/internal/unordered_set_modifiers_test.h
@@ -20,202 +20,212 @@
 #include "absl/container/internal/hash_generator_testing.h"
 #include "absl/container/internal/hash_policy_testing.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class UnordSet>
-class ModifiersTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE_P(ModifiersTest);
-
-TYPED_TEST_P(ModifiersTest, Clear) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  m.clear();
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_TRUE(m.empty());
-}
-
-TYPED_TEST_P(ModifiersTest, Insert) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto p = m.insert(val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  p = m.insert(val);
-  EXPECT_FALSE(p.second);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertHint) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  auto it = m.insert(m.end(), val);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(val, *it);
-  it = m.insert(it, val);
-  EXPECT_TRUE(it != m.end());
-  EXPECT_EQ(val, *it);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m;
-  m.insert(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-}
-
-TYPED_TEST_P(ModifiersTest, InsertWithinCapacity) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  m.reserve(10);
-  const size_t original_capacity = m.bucket_count();
-  m.insert(val);
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-  m.insert(val);
-  EXPECT_EQ(m.bucket_count(), original_capacity);
-}
-
-TYPED_TEST_P(ModifiersTest, InsertRangeWithinCapacity) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+
+        template<class UnordSet>
+        class ModifiersTest : public ::testing::Test
+        {
+        };
+
+        TYPED_TEST_SUITE_P(ModifiersTest);
+
+        TYPED_TEST_P(ModifiersTest, Clear)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            m.clear();
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+            EXPECT_TRUE(m.empty());
+        }
+
+        TYPED_TEST_P(ModifiersTest, Insert)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            auto p = m.insert(val);
+            EXPECT_TRUE(p.second);
+            EXPECT_EQ(val, *p.first);
+            p = m.insert(val);
+            EXPECT_FALSE(p.second);
+        }
+
+        TYPED_TEST_P(ModifiersTest, InsertHint)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            auto it = m.insert(m.end(), val);
+            EXPECT_TRUE(it != m.end());
+            EXPECT_EQ(val, *it);
+            it = m.insert(it, val);
+            EXPECT_TRUE(it != m.end());
+            EXPECT_EQ(val, *it);
+        }
+
+        TYPED_TEST_P(ModifiersTest, InsertRange)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m;
+            m.insert(values.begin(), values.end());
+            ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+        }
+
+        TYPED_TEST_P(ModifiersTest, InsertWithinCapacity)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            m.reserve(10);
+            const size_t original_capacity = m.bucket_count();
+            m.insert(val);
+            EXPECT_EQ(m.bucket_count(), original_capacity);
+            m.insert(val);
+            EXPECT_EQ(m.bucket_count(), original_capacity);
+        }
+
+        TYPED_TEST_P(ModifiersTest, InsertRangeWithinCapacity)
+        {
 #if !defined(__GLIBCXX__)
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> base_values;
-  std::generate_n(std::back_inserter(base_values), 10,
-                  hash_internal::Generator<T>());
-  std::vector<T> values;
-  while (values.size() != 100) {
-    values.insert(values.end(), base_values.begin(), base_values.end());
-  }
-  TypeParam m;
-  m.reserve(10);
-  const size_t original_capacity = m.bucket_count();
-  m.insert(values.begin(), values.end());
-  EXPECT_EQ(m.bucket_count(), original_capacity);
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> base_values;
+            std::generate_n(std::back_inserter(base_values), 10, hash_internal::Generator<T>());
+            std::vector<T> values;
+            while (values.size() != 100)
+            {
+                values.insert(values.end(), base_values.begin(), base_values.end());
+            }
+            TypeParam m;
+            m.reserve(10);
+            const size_t original_capacity = m.bucket_count();
+            m.insert(values.begin(), values.end());
+            EXPECT_EQ(m.bucket_count(), original_capacity);
 #endif
-}
-
-TYPED_TEST_P(ModifiersTest, Emplace) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto p = m.emplace(val);
-  EXPECT_TRUE(p.second);
-  EXPECT_EQ(val, *p.first);
-  p = m.emplace(val);
-  EXPECT_FALSE(p.second);
-  EXPECT_EQ(val, *p.first);
-}
-
-TYPED_TEST_P(ModifiersTest, EmplaceHint) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  T val = hash_internal::Generator<T>()();
-  TypeParam m;
-  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
-  // with test traits/policy.
-  auto it = m.emplace_hint(m.end(), val);
-  EXPECT_EQ(val, *it);
-  it = m.emplace_hint(it, val);
-  EXPECT_EQ(val, *it);
-}
-
-template <class V>
-using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
-
-// In openmap we chose not to return the iterator from erase because that's
-// more expensive. As such we adapt erase to return an iterator here.
-struct EraseFirst {
-  template <class Map>
-  auto operator()(Map* m, int) const
-      -> IfNotVoid<decltype(m->erase(m->begin()))> {
-    return m->erase(m->begin());
-  }
-  template <class Map>
-  typename Map::iterator operator()(Map* m, ...) const {
-    auto it = m->begin();
-    m->erase(it++);
-    return it;
-  }
-};
-
-TYPED_TEST_P(ModifiersTest, Erase) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  std::vector<T> values2;
-  for (const auto& val : values)
-    if (val != *m.begin()) values2.push_back(val);
-  auto it = EraseFirst()(&m, 0);
-  ASSERT_TRUE(it != m.end());
-  EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values2.begin(),
-                                                            values2.end()));
-}
-
-TYPED_TEST_P(ModifiersTest, EraseRange) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  auto it = m.erase(m.begin(), m.end());
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
-  EXPECT_TRUE(it == m.end());
-}
-
-TYPED_TEST_P(ModifiersTest, EraseKey) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> values;
-  std::generate_n(std::back_inserter(values), 10,
-                  hash_internal::Generator<T>());
-  TypeParam m(values.begin(), values.end());
-  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
-  EXPECT_EQ(1, m.erase(values[0]));
-  EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
-  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values.begin() + 1,
-                                                            values.end()));
-}
-
-TYPED_TEST_P(ModifiersTest, Swap) {
-  using T = hash_internal::GeneratedType<TypeParam>;
-  std::vector<T> v1;
-  std::vector<T> v2;
-  std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
-  std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
-  TypeParam m1(v1.begin(), v1.end());
-  TypeParam m2(v2.begin(), v2.end());
-  EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v1));
-  EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v2));
-  m1.swap(m2);
-  EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v2));
-  EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v1));
-}
-
-// TODO(alkis): Write tests for extract.
-// TODO(alkis): Write tests for merge.
-
-REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint,
-                            InsertRange, InsertWithinCapacity,
-                            InsertRangeWithinCapacity, Emplace, EmplaceHint,
-                            Erase, EraseRange, EraseKey, Swap);
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
+        }
+
+        TYPED_TEST_P(ModifiersTest, Emplace)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+            // with test traits/policy.
+            auto p = m.emplace(val);
+            EXPECT_TRUE(p.second);
+            EXPECT_EQ(val, *p.first);
+            p = m.emplace(val);
+            EXPECT_FALSE(p.second);
+            EXPECT_EQ(val, *p.first);
+        }
+
+        TYPED_TEST_P(ModifiersTest, EmplaceHint)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            T val = hash_internal::Generator<T>()();
+            TypeParam m;
+            // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
+            // with test traits/policy.
+            auto it = m.emplace_hint(m.end(), val);
+            EXPECT_EQ(val, *it);
+            it = m.emplace_hint(it, val);
+            EXPECT_EQ(val, *it);
+        }
+
+        template<class V>
+        using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
+
+        // In openmap we chose not to return the iterator from erase because that's
+        // more expensive. As such we adapt erase to return an iterator here.
+        struct EraseFirst
+        {
+            template<class Map>
+            auto operator()(Map* m, int) const
+                -> IfNotVoid<decltype(m->erase(m->begin()))>
+            {
+                return m->erase(m->begin());
+            }
+            template<class Map>
+            typename Map::iterator operator()(Map* m, ...) const
+            {
+                auto it = m->begin();
+                m->erase(it++);
+                return it;
+            }
+        };
+
+        TYPED_TEST_P(ModifiersTest, Erase)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            std::vector<T> values2;
+            for (const auto& val : values)
+                if (val != *m.begin())
+                    values2.push_back(val);
+            auto it = EraseFirst()(&m, 0);
+            ASSERT_TRUE(it != m.end());
+            EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values2.begin(), values2.end()));
+        }
+
+        TYPED_TEST_P(ModifiersTest, EraseRange)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            auto it = m.erase(m.begin(), m.end());
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
+            EXPECT_TRUE(it == m.end());
+        }
+
+        TYPED_TEST_P(ModifiersTest, EraseKey)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> values;
+            std::generate_n(std::back_inserter(values), 10, hash_internal::Generator<T>());
+            TypeParam m(values.begin(), values.end());
+            ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
+            EXPECT_EQ(1, m.erase(values[0]));
+            EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
+            EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values.begin() + 1, values.end()));
+        }
+
+        TYPED_TEST_P(ModifiersTest, Swap)
+        {
+            using T = hash_internal::GeneratedType<TypeParam>;
+            std::vector<T> v1;
+            std::vector<T> v2;
+            std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
+            std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
+            TypeParam m1(v1.begin(), v1.end());
+            TypeParam m2(v2.begin(), v2.end());
+            EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v1));
+            EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v2));
+            m1.swap(m2);
+            EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v2));
+            EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v1));
+        }
+
+        // TODO(alkis): Write tests for extract.
+        // TODO(alkis): Write tests for merge.
+
+        REGISTER_TYPED_TEST_SUITE_P(ModifiersTest, Clear, Insert, InsertHint, InsertRange, InsertWithinCapacity, InsertRangeWithinCapacity, Emplace, EmplaceHint, Erase, EraseRange, EraseKey, Swap);
+
+    }  // namespace container_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/node_hash_map.h b/CAPI/cpp/grpc/include/absl/container/node_hash_map.h
index 6868e63..183709b 100644
--- a/CAPI/cpp/grpc/include/absl/container/node_hash_map.h
+++ b/CAPI/cpp/grpc/include/absl/container/node_hash_map.h
@@ -48,557 +48,569 @@
 #include "absl/container/internal/raw_hash_map.h"  // IWYU pragma: export
 #include "absl/memory/memory.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-template <class Key, class Value>
-class NodeHashMapPolicy;
-}  // namespace container_internal
-
-// -----------------------------------------------------------------------------
-// absl::node_hash_map
-// -----------------------------------------------------------------------------
-//
-// An `absl::node_hash_map<K, V>` is an unordered associative container which
-// has been optimized for both speed and memory footprint in most common use
-// cases. Its interface is similar to that of `std::unordered_map<K, V>` with
-// the following notable differences:
-//
-// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
-//   `insert()`, provided that the map is provided a compatible heterogeneous
-//   hashing function and equality operator.
-// * Contains a `capacity()` member function indicating the number of element
-//   slots (open, deleted, and empty) within the hash map.
-// * Returns `void` from the `erase(iterator)` overload.
-//
-// By default, `node_hash_map` uses the `absl::Hash` hashing framework.
-// All fundamental and Abseil types that support the `absl::Hash` framework have
-// a compatible equality operator for comparing insertions into `node_hash_map`.
-// If your type is not yet supported by the `absl::Hash` framework, see
-// absl/hash/hash.h for information on extending Abseil hashing to user-defined
-// types.
-//
-// Using `absl::node_hash_map` at interface boundaries in dynamically loaded
-// libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
-// be randomized across dynamically loaded libraries.
-//
-// Example:
-//
-//   // Create a node hash map of three strings (that map to strings)
-//   absl::node_hash_map<std::string, std::string> ducks =
-//     {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}};
-//
-//  // Insert a new element into the node hash map
-//  ducks.insert({"d", "donald"}};
-//
-//  // Force a rehash of the node hash map
-//  ducks.rehash(0);
-//
-//  // Find the element with the key "b"
-//  std::string search_key = "b";
-//  auto result = ducks.find(search_key);
-//  if (result != ducks.end()) {
-//    std::cout << "Result: " << result->second << std::endl;
-//  }
-template <class Key, class Value,
-          class Hash = absl::container_internal::hash_default_hash<Key>,
-          class Eq = absl::container_internal::hash_default_eq<Key>,
-          class Alloc = std::allocator<std::pair<const Key, Value>>>
-class node_hash_map
-    : public absl::container_internal::raw_hash_map<
-          absl::container_internal::NodeHashMapPolicy<Key, Value>, Hash, Eq,
-          Alloc> {
-  using Base = typename node_hash_map::raw_hash_map;
-
- public:
-  // Constructors and Assignment Operators
-  //
-  // A node_hash_map supports the same overload set as `std::unordered_map`
-  // for construction and assignment:
-  //
-  // *  Default constructor
-  //
-  //    // No allocation for the table's elements is made.
-  //    absl::node_hash_map<int, std::string> map1;
-  //
-  // * Initializer List constructor
-  //
-  //   absl::node_hash_map<int, std::string> map2 =
-  //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
-  //
-  // * Copy constructor
-  //
-  //   absl::node_hash_map<int, std::string> map3(map2);
-  //
-  // * Copy assignment operator
-  //
-  //  // Hash functor and Comparator are copied as well
-  //  absl::node_hash_map<int, std::string> map4;
-  //  map4 = map3;
-  //
-  // * Move constructor
-  //
-  //   // Move is guaranteed efficient
-  //   absl::node_hash_map<int, std::string> map5(std::move(map4));
-  //
-  // * Move assignment operator
-  //
-  //   // May be efficient if allocators are compatible
-  //   absl::node_hash_map<int, std::string> map6;
-  //   map6 = std::move(map5);
-  //
-  // * Range constructor
-  //
-  //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
-  //   absl::node_hash_map<int, std::string> map7(v.begin(), v.end());
-  node_hash_map() {}
-  using Base::Base;
-
-  // node_hash_map::begin()
-  //
-  // Returns an iterator to the beginning of the `node_hash_map`.
-  using Base::begin;
-
-  // node_hash_map::cbegin()
-  //
-  // Returns a const iterator to the beginning of the `node_hash_map`.
-  using Base::cbegin;
-
-  // node_hash_map::cend()
-  //
-  // Returns a const iterator to the end of the `node_hash_map`.
-  using Base::cend;
-
-  // node_hash_map::end()
-  //
-  // Returns an iterator to the end of the `node_hash_map`.
-  using Base::end;
-
-  // node_hash_map::capacity()
-  //
-  // Returns the number of element slots (assigned, deleted, and empty)
-  // available within the `node_hash_map`.
-  //
-  // NOTE: this member function is particular to `absl::node_hash_map` and is
-  // not provided in the `std::unordered_map` API.
-  using Base::capacity;
-
-  // node_hash_map::empty()
-  //
-  // Returns whether or not the `node_hash_map` is empty.
-  using Base::empty;
-
-  // node_hash_map::max_size()
-  //
-  // Returns the largest theoretical possible number of elements within a
-  // `node_hash_map` under current memory constraints. This value can be thought
-  // of as the largest value of `std::distance(begin(), end())` for a
-  // `node_hash_map<K, V>`.
-  using Base::max_size;
-
-  // node_hash_map::size()
-  //
-  // Returns the number of elements currently within the `node_hash_map`.
-  using Base::size;
-
-  // node_hash_map::clear()
-  //
-  // Removes all elements from the `node_hash_map`. Invalidates any references,
-  // pointers, or iterators referring to contained elements.
-  //
-  // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
-  // the underlying buffer call `erase(begin(), end())`.
-  using Base::clear;
-
-  // node_hash_map::erase()
-  //
-  // Erases elements within the `node_hash_map`. Erasing does not trigger a
-  // rehash. Overloads are listed below.
-  //
-  // void erase(const_iterator pos):
-  //
-  //   Erases the element at `position` of the `node_hash_map`, returning
-  //   `void`.
-  //
-  //   NOTE: this return behavior is different than that of STL containers in
-  //   general and `std::unordered_map` in particular.
-  //
-  // iterator erase(const_iterator first, const_iterator last):
-  //
-  //   Erases the elements in the open interval [`first`, `last`), returning an
-  //   iterator pointing to `last`.
-  //
-  // size_type erase(const key_type& key):
-  //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
-  using Base::erase;
-
-  // node_hash_map::insert()
-  //
-  // Inserts an element of the specified value into the `node_hash_map`,
-  // returning an iterator pointing to the newly inserted element, provided that
-  // an element with the given key does not already exist. If rehashing occurs
-  // due to the insertion, all iterators are invalidated. Overloads are listed
-  // below.
-  //
-  // std::pair<iterator,bool> insert(const init_type& value):
-  //
-  //   Inserts a value into the `node_hash_map`. Returns a pair consisting of an
-  //   iterator to the inserted element (or to the element that prevented the
-  //   insertion) and a `bool` denoting whether the insertion took place.
-  //
-  // std::pair<iterator,bool> insert(T&& value):
-  // std::pair<iterator,bool> insert(init_type&& value):
-  //
-  //   Inserts a moveable value into the `node_hash_map`. Returns a `std::pair`
-  //   consisting of an iterator to the inserted element (or to the element that
-  //   prevented the insertion) and a `bool` denoting whether the insertion took
-  //   place.
-  //
-  // iterator insert(const_iterator hint, const init_type& value):
-  // iterator insert(const_iterator hint, T&& value):
-  // iterator insert(const_iterator hint, init_type&& value);
-  //
-  //   Inserts a value, using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search. Returns an iterator to the
-  //   inserted element, or to the existing element that prevented the
-  //   insertion.
-  //
-  // void insert(InputIterator first, InputIterator last):
-  //
-  //   Inserts a range of values [`first`, `last`).
-  //
-  //   NOTE: Although the STL does not specify which element may be inserted if
-  //   multiple keys compare equivalently, for `node_hash_map` we guarantee the
-  //   first match is inserted.
-  //
-  // void insert(std::initializer_list<init_type> ilist):
-  //
-  //   Inserts the elements within the initializer list `ilist`.
-  //
-  //   NOTE: Although the STL does not specify which element may be inserted if
-  //   multiple keys compare equivalently within the initializer list, for
-  //   `node_hash_map` we guarantee the first match is inserted.
-  using Base::insert;
-
-  // node_hash_map::insert_or_assign()
-  //
-  // Inserts an element of the specified value into the `node_hash_map` provided
-  // that a value with the given key does not already exist, or replaces it with
-  // the element value if a key for that value already exists, returning an
-  // iterator pointing to the newly inserted element. If rehashing occurs due to
-  // the insertion, all iterators are invalidated. Overloads are listed
-  // below.
-  //
-  // std::pair<iterator, bool> insert_or_assign(const init_type& k, T&& obj):
-  // std::pair<iterator, bool> insert_or_assign(init_type&& k, T&& obj):
-  //
-  //   Inserts/Assigns (or moves) the element of the specified key into the
-  //   `node_hash_map`.
-  //
-  // iterator insert_or_assign(const_iterator hint,
-  //                           const init_type& k, T&& obj):
-  // iterator insert_or_assign(const_iterator hint, init_type&& k, T&& obj):
-  //
-  //   Inserts/Assigns (or moves) the element of the specified key into the
-  //   `node_hash_map` using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search.
-  using Base::insert_or_assign;
-
-  // node_hash_map::emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `node_hash_map`, provided that no element with the given key
-  // already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately. Prefer `try_emplace()` unless your key is not
-  // copyable or moveable.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  using Base::emplace;
-
-  // node_hash_map::emplace_hint()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `node_hash_map`, using the position of `hint` as a non-binding
-  // suggestion for where to begin the insertion search, and only inserts
-  // provided that no element with the given key already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately. Prefer `try_emplace()` unless your key is not
-  // copyable or moveable.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  using Base::emplace_hint;
-
-  // node_hash_map::try_emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `node_hash_map`, provided that no element with the given key
-  // already exists. Unlike `emplace()`, if an element with the given key
-  // already exists, we guarantee that no element is constructed.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  // Overloads are listed below.
-  //
-  //   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
-  //   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
-  //
-  // Inserts (via copy or move) the element of the specified key into the
-  // `node_hash_map`.
-  //
-  //   iterator try_emplace(const_iterator hint,
-  //                        const key_type& k, Args&&... args):
-  //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
-  //
-  // Inserts (via copy or move) the element of the specified key into the
-  // `node_hash_map` using the position of `hint` as a non-binding suggestion
-  // for where to begin the insertion search.
-  //
-  // All `try_emplace()` overloads make the same guarantees regarding rvalue
-  // arguments as `std::unordered_map::try_emplace()`, namely that these
-  // functions will not move from rvalue arguments if insertions do not happen.
-  using Base::try_emplace;
-
-  // node_hash_map::extract()
-  //
-  // Extracts the indicated element, erasing it in the process, and returns it
-  // as a C++17-compatible node handle. Overloads are listed below.
-  //
-  // node_type extract(const_iterator position):
-  //
-  //   Extracts the key,value pair of the element at the indicated position and
-  //   returns a node handle owning that extracted data.
-  //
-  // node_type extract(const key_type& x):
-  //
-  //   Extracts the key,value pair of the element with a key matching the passed
-  //   key value and returns a node handle owning that extracted data. If the
-  //   `node_hash_map` does not contain an element with a matching key, this
-  //   function returns an empty node handle.
-  //
-  // NOTE: when compiled in an earlier version of C++ than C++17,
-  // `node_type::key()` returns a const reference to the key instead of a
-  // mutable reference. We cannot safely return a mutable reference without
-  // std::launder (which is not available before C++17).
-  using Base::extract;
-
-  // node_hash_map::merge()
-  //
-  // Extracts elements from a given `source` node hash map into this
-  // `node_hash_map`. If the destination `node_hash_map` already contains an
-  // element with an equivalent key, that element is not extracted.
-  using Base::merge;
-
-  // node_hash_map::swap(node_hash_map& other)
-  //
-  // Exchanges the contents of this `node_hash_map` with those of the `other`
-  // node hash map, avoiding invocation of any move, copy, or swap operations on
-  // individual elements.
-  //
-  // All iterators and references on the `node_hash_map` remain valid, excepting
-  // for the past-the-end iterator, which is invalidated.
-  //
-  // `swap()` requires that the node hash map's hashing and key equivalence
-  // functions be Swappable, and are exchaged using unqualified calls to
-  // non-member `swap()`. If the map's allocator has
-  // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
-  // set to `true`, the allocators are also exchanged using an unqualified call
-  // to non-member `swap()`; otherwise, the allocators are not swapped.
-  using Base::swap;
-
-  // node_hash_map::rehash(count)
-  //
-  // Rehashes the `node_hash_map`, setting the number of slots to be at least
-  // the passed value. If the new number of slots increases the load factor more
-  // than the current maximum load factor
-  // (`count` < `size()` / `max_load_factor()`), then the new number of slots
-  // will be at least `size()` / `max_load_factor()`.
-  //
-  // To force a rehash, pass rehash(0).
-  using Base::rehash;
-
-  // node_hash_map::reserve(count)
-  //
-  // Sets the number of slots in the `node_hash_map` to the number needed to
-  // accommodate at least `count` total elements without exceeding the current
-  // maximum load factor, and may rehash the container if needed.
-  using Base::reserve;
-
-  // node_hash_map::at()
-  //
-  // Returns a reference to the mapped value of the element with key equivalent
-  // to the passed key.
-  using Base::at;
-
-  // node_hash_map::contains()
-  //
-  // Determines whether an element with a key comparing equal to the given `key`
-  // exists within the `node_hash_map`, returning `true` if so or `false`
-  // otherwise.
-  using Base::contains;
-
-  // node_hash_map::count(const Key& key) const
-  //
-  // Returns the number of elements with a key comparing equal to the given
-  // `key` within the `node_hash_map`. note that this function will return
-  // either `1` or `0` since duplicate keys are not allowed within a
-  // `node_hash_map`.
-  using Base::count;
-
-  // node_hash_map::equal_range()
-  //
-  // Returns a closed range [first, last], defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the
-  // `node_hash_map`.
-  using Base::equal_range;
-
-  // node_hash_map::find()
-  //
-  // Finds an element with the passed `key` within the `node_hash_map`.
-  using Base::find;
-
-  // node_hash_map::operator[]()
-  //
-  // Returns a reference to the value mapped to the passed key within the
-  // `node_hash_map`, performing an `insert()` if the key does not already
-  // exist. If an insertion occurs and results in a rehashing of the container,
-  // all iterators are invalidated. Otherwise iterators are not affected and
-  // references are not invalidated. Overloads are listed below.
-  //
-  // T& operator[](const Key& key):
-  //
-  //   Inserts an init_type object constructed in-place if the element with the
-  //   given key does not exist.
-  //
-  // T& operator[](Key&& key):
-  //
-  //   Inserts an init_type object constructed in-place provided that an element
-  //   with the given key does not exist.
-  using Base::operator[];
-
-  // node_hash_map::bucket_count()
-  //
-  // Returns the number of "buckets" within the `node_hash_map`.
-  using Base::bucket_count;
-
-  // node_hash_map::load_factor()
-  //
-  // Returns the current load factor of the `node_hash_map` (the average number
-  // of slots occupied with a value within the hash map).
-  using Base::load_factor;
-
-  // node_hash_map::max_load_factor()
-  //
-  // Manages the maximum load factor of the `node_hash_map`. Overloads are
-  // listed below.
-  //
-  // float node_hash_map::max_load_factor()
-  //
-  //   Returns the current maximum load factor of the `node_hash_map`.
-  //
-  // void node_hash_map::max_load_factor(float ml)
-  //
-  //   Sets the maximum load factor of the `node_hash_map` to the passed value.
-  //
-  //   NOTE: This overload is provided only for API compatibility with the STL;
-  //   `node_hash_map` will ignore any set load factor and manage its rehashing
-  //   internally as an implementation detail.
-  using Base::max_load_factor;
-
-  // node_hash_map::get_allocator()
-  //
-  // Returns the allocator function associated with this `node_hash_map`.
-  using Base::get_allocator;
-
-  // node_hash_map::hash_function()
-  //
-  // Returns the hashing function used to hash the keys within this
-  // `node_hash_map`.
-  using Base::hash_function;
-
-  // node_hash_map::key_eq()
-  //
-  // Returns the function used for comparing keys equality.
-  using Base::key_eq;
-};
-
-// erase_if(node_hash_map<>, Pred)
-//
-// Erases all elements that satisfy the predicate `pred` from the container `c`.
-// Returns the number of erased elements.
-template <typename K, typename V, typename H, typename E, typename A,
-          typename Predicate>
-typename node_hash_map<K, V, H, E, A>::size_type erase_if(
-    node_hash_map<K, V, H, E, A>& c, Predicate pred) {
-  return container_internal::EraseIf(pred, &c);
-}
-
-namespace container_internal {
-
-template <class Key, class Value>
-class NodeHashMapPolicy
-    : public absl::container_internal::node_slot_policy<
-          std::pair<const Key, Value>&, NodeHashMapPolicy<Key, Value>> {
-  using value_type = std::pair<const Key, Value>;
-
- public:
-  using key_type = Key;
-  using mapped_type = Value;
-  using init_type = std::pair</*non const*/ key_type, mapped_type>;
-
-  template <class Allocator, class... Args>
-  static value_type* new_element(Allocator* alloc, Args&&... args) {
-    using PairAlloc = typename absl::allocator_traits<
-        Allocator>::template rebind_alloc<value_type>;
-    PairAlloc pair_alloc(*alloc);
-    value_type* res =
-        absl::allocator_traits<PairAlloc>::allocate(pair_alloc, 1);
-    absl::allocator_traits<PairAlloc>::construct(pair_alloc, res,
-                                                 std::forward<Args>(args)...);
-    return res;
-  }
-
-  template <class Allocator>
-  static void delete_element(Allocator* alloc, value_type* pair) {
-    using PairAlloc = typename absl::allocator_traits<
-        Allocator>::template rebind_alloc<value_type>;
-    PairAlloc pair_alloc(*alloc);
-    absl::allocator_traits<PairAlloc>::destroy(pair_alloc, pair);
-    absl::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1);
-  }
-
-  template <class F, class... Args>
-  static decltype(absl::container_internal::DecomposePair(
-      std::declval<F>(), std::declval<Args>()...))
-  apply(F&& f, Args&&... args) {
-    return absl::container_internal::DecomposePair(std::forward<F>(f),
-                                                   std::forward<Args>(args)...);
-  }
-
-  static size_t element_space_used(const value_type*) {
-    return sizeof(value_type);
-  }
-
-  static Value& value(value_type* elem) { return elem->second; }
-  static const Value& value(const value_type* elem) { return elem->second; }
-};
-}  // namespace container_internal
-
-namespace container_algorithm_internal {
-
-// Specialization of trait in absl/algorithm/container.h
-template <class Key, class T, class Hash, class KeyEqual, class Allocator>
-struct IsUnorderedContainer<
-    absl::node_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {};
-
-}  // namespace container_algorithm_internal
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+        template<class Key, class Value>
+        class NodeHashMapPolicy;
+    }  // namespace container_internal
+
+    // -----------------------------------------------------------------------------
+    // absl::node_hash_map
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::node_hash_map<K, V>` is an unordered associative container which
+    // has been optimized for both speed and memory footprint in most common use
+    // cases. Its interface is similar to that of `std::unordered_map<K, V>` with
+    // the following notable differences:
+    //
+    // * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+    //   `insert()`, provided that the map is provided a compatible heterogeneous
+    //   hashing function and equality operator.
+    // * Contains a `capacity()` member function indicating the number of element
+    //   slots (open, deleted, and empty) within the hash map.
+    // * Returns `void` from the `erase(iterator)` overload.
+    //
+    // By default, `node_hash_map` uses the `absl::Hash` hashing framework.
+    // All fundamental and Abseil types that support the `absl::Hash` framework have
+    // a compatible equality operator for comparing insertions into `node_hash_map`.
+    // If your type is not yet supported by the `absl::Hash` framework, see
+    // absl/hash/hash.h for information on extending Abseil hashing to user-defined
+    // types.
+    //
+    // Using `absl::node_hash_map` at interface boundaries in dynamically loaded
+    // libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
+    // be randomized across dynamically loaded libraries.
+    //
+    // Example:
+    //
+    //   // Create a node hash map of three strings (that map to strings)
+    //   absl::node_hash_map<std::string, std::string> ducks =
+    //     {{"a", "huey"}, {"b", "dewey"}, {"c", "louie"}};
+    //
+    //  // Insert a new element into the node hash map
+    //  ducks.insert({"d", "donald"}};
+    //
+    //  // Force a rehash of the node hash map
+    //  ducks.rehash(0);
+    //
+    //  // Find the element with the key "b"
+    //  std::string search_key = "b";
+    //  auto result = ducks.find(search_key);
+    //  if (result != ducks.end()) {
+    //    std::cout << "Result: " << result->second << std::endl;
+    //  }
+    template<class Key, class Value, class Hash = absl::container_internal::hash_default_hash<Key>, class Eq = absl::container_internal::hash_default_eq<Key>, class Alloc = std::allocator<std::pair<const Key, Value>>>
+    class node_hash_map : public absl::container_internal::raw_hash_map<absl::container_internal::NodeHashMapPolicy<Key, Value>, Hash, Eq, Alloc>
+    {
+        using Base = typename node_hash_map::raw_hash_map;
+
+    public:
+        // Constructors and Assignment Operators
+        //
+        // A node_hash_map supports the same overload set as `std::unordered_map`
+        // for construction and assignment:
+        //
+        // *  Default constructor
+        //
+        //    // No allocation for the table's elements is made.
+        //    absl::node_hash_map<int, std::string> map1;
+        //
+        // * Initializer List constructor
+        //
+        //   absl::node_hash_map<int, std::string> map2 =
+        //       {{1, "huey"}, {2, "dewey"}, {3, "louie"},};
+        //
+        // * Copy constructor
+        //
+        //   absl::node_hash_map<int, std::string> map3(map2);
+        //
+        // * Copy assignment operator
+        //
+        //  // Hash functor and Comparator are copied as well
+        //  absl::node_hash_map<int, std::string> map4;
+        //  map4 = map3;
+        //
+        // * Move constructor
+        //
+        //   // Move is guaranteed efficient
+        //   absl::node_hash_map<int, std::string> map5(std::move(map4));
+        //
+        // * Move assignment operator
+        //
+        //   // May be efficient if allocators are compatible
+        //   absl::node_hash_map<int, std::string> map6;
+        //   map6 = std::move(map5);
+        //
+        // * Range constructor
+        //
+        //   std::vector<std::pair<int, std::string>> v = {{1, "a"}, {2, "b"}};
+        //   absl::node_hash_map<int, std::string> map7(v.begin(), v.end());
+        node_hash_map()
+        {
+        }
+        using Base::Base;
+
+        // node_hash_map::begin()
+        //
+        // Returns an iterator to the beginning of the `node_hash_map`.
+        using Base::begin;
+
+        // node_hash_map::cbegin()
+        //
+        // Returns a const iterator to the beginning of the `node_hash_map`.
+        using Base::cbegin;
+
+        // node_hash_map::cend()
+        //
+        // Returns a const iterator to the end of the `node_hash_map`.
+        using Base::cend;
+
+        // node_hash_map::end()
+        //
+        // Returns an iterator to the end of the `node_hash_map`.
+        using Base::end;
+
+        // node_hash_map::capacity()
+        //
+        // Returns the number of element slots (assigned, deleted, and empty)
+        // available within the `node_hash_map`.
+        //
+        // NOTE: this member function is particular to `absl::node_hash_map` and is
+        // not provided in the `std::unordered_map` API.
+        using Base::capacity;
+
+        // node_hash_map::empty()
+        //
+        // Returns whether or not the `node_hash_map` is empty.
+        using Base::empty;
+
+        // node_hash_map::max_size()
+        //
+        // Returns the largest theoretical possible number of elements within a
+        // `node_hash_map` under current memory constraints. This value can be thought
+        // of as the largest value of `std::distance(begin(), end())` for a
+        // `node_hash_map<K, V>`.
+        using Base::max_size;
+
+        // node_hash_map::size()
+        //
+        // Returns the number of elements currently within the `node_hash_map`.
+        using Base::size;
+
+        // node_hash_map::clear()
+        //
+        // Removes all elements from the `node_hash_map`. Invalidates any references,
+        // pointers, or iterators referring to contained elements.
+        //
+        // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
+        // the underlying buffer call `erase(begin(), end())`.
+        using Base::clear;
+
+        // node_hash_map::erase()
+        //
+        // Erases elements within the `node_hash_map`. Erasing does not trigger a
+        // rehash. Overloads are listed below.
+        //
+        // void erase(const_iterator pos):
+        //
+        //   Erases the element at `position` of the `node_hash_map`, returning
+        //   `void`.
+        //
+        //   NOTE: this return behavior is different than that of STL containers in
+        //   general and `std::unordered_map` in particular.
+        //
+        // iterator erase(const_iterator first, const_iterator last):
+        //
+        //   Erases the elements in the open interval [`first`, `last`), returning an
+        //   iterator pointing to `last`.
+        //
+        // size_type erase(const key_type& key):
+        //
+        //   Erases the element with the matching key, if it exists, returning the
+        //   number of elements erased (0 or 1).
+        using Base::erase;
+
+        // node_hash_map::insert()
+        //
+        // Inserts an element of the specified value into the `node_hash_map`,
+        // returning an iterator pointing to the newly inserted element, provided that
+        // an element with the given key does not already exist. If rehashing occurs
+        // due to the insertion, all iterators are invalidated. Overloads are listed
+        // below.
+        //
+        // std::pair<iterator,bool> insert(const init_type& value):
+        //
+        //   Inserts a value into the `node_hash_map`. Returns a pair consisting of an
+        //   iterator to the inserted element (or to the element that prevented the
+        //   insertion) and a `bool` denoting whether the insertion took place.
+        //
+        // std::pair<iterator,bool> insert(T&& value):
+        // std::pair<iterator,bool> insert(init_type&& value):
+        //
+        //   Inserts a moveable value into the `node_hash_map`. Returns a `std::pair`
+        //   consisting of an iterator to the inserted element (or to the element that
+        //   prevented the insertion) and a `bool` denoting whether the insertion took
+        //   place.
+        //
+        // iterator insert(const_iterator hint, const init_type& value):
+        // iterator insert(const_iterator hint, T&& value):
+        // iterator insert(const_iterator hint, init_type&& value);
+        //
+        //   Inserts a value, using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search. Returns an iterator to the
+        //   inserted element, or to the existing element that prevented the
+        //   insertion.
+        //
+        // void insert(InputIterator first, InputIterator last):
+        //
+        //   Inserts a range of values [`first`, `last`).
+        //
+        //   NOTE: Although the STL does not specify which element may be inserted if
+        //   multiple keys compare equivalently, for `node_hash_map` we guarantee the
+        //   first match is inserted.
+        //
+        // void insert(std::initializer_list<init_type> ilist):
+        //
+        //   Inserts the elements within the initializer list `ilist`.
+        //
+        //   NOTE: Although the STL does not specify which element may be inserted if
+        //   multiple keys compare equivalently within the initializer list, for
+        //   `node_hash_map` we guarantee the first match is inserted.
+        using Base::insert;
+
+        // node_hash_map::insert_or_assign()
+        //
+        // Inserts an element of the specified value into the `node_hash_map` provided
+        // that a value with the given key does not already exist, or replaces it with
+        // the element value if a key for that value already exists, returning an
+        // iterator pointing to the newly inserted element. If rehashing occurs due to
+        // the insertion, all iterators are invalidated. Overloads are listed
+        // below.
+        //
+        // std::pair<iterator, bool> insert_or_assign(const init_type& k, T&& obj):
+        // std::pair<iterator, bool> insert_or_assign(init_type&& k, T&& obj):
+        //
+        //   Inserts/Assigns (or moves) the element of the specified key into the
+        //   `node_hash_map`.
+        //
+        // iterator insert_or_assign(const_iterator hint,
+        //                           const init_type& k, T&& obj):
+        // iterator insert_or_assign(const_iterator hint, init_type&& k, T&& obj):
+        //
+        //   Inserts/Assigns (or moves) the element of the specified key into the
+        //   `node_hash_map` using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search.
+        using Base::insert_or_assign;
+
+        // node_hash_map::emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `node_hash_map`, provided that no element with the given key
+        // already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately. Prefer `try_emplace()` unless your key is not
+        // copyable or moveable.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        using Base::emplace;
+
+        // node_hash_map::emplace_hint()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `node_hash_map`, using the position of `hint` as a non-binding
+        // suggestion for where to begin the insertion search, and only inserts
+        // provided that no element with the given key already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately. Prefer `try_emplace()` unless your key is not
+        // copyable or moveable.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        using Base::emplace_hint;
+
+        // node_hash_map::try_emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `node_hash_map`, provided that no element with the given key
+        // already exists. Unlike `emplace()`, if an element with the given key
+        // already exists, we guarantee that no element is constructed.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        // Overloads are listed below.
+        //
+        //   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args):
+        //   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args):
+        //
+        // Inserts (via copy or move) the element of the specified key into the
+        // `node_hash_map`.
+        //
+        //   iterator try_emplace(const_iterator hint,
+        //                        const key_type& k, Args&&... args):
+        //   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args):
+        //
+        // Inserts (via copy or move) the element of the specified key into the
+        // `node_hash_map` using the position of `hint` as a non-binding suggestion
+        // for where to begin the insertion search.
+        //
+        // All `try_emplace()` overloads make the same guarantees regarding rvalue
+        // arguments as `std::unordered_map::try_emplace()`, namely that these
+        // functions will not move from rvalue arguments if insertions do not happen.
+        using Base::try_emplace;
+
+        // node_hash_map::extract()
+        //
+        // Extracts the indicated element, erasing it in the process, and returns it
+        // as a C++17-compatible node handle. Overloads are listed below.
+        //
+        // node_type extract(const_iterator position):
+        //
+        //   Extracts the key,value pair of the element at the indicated position and
+        //   returns a node handle owning that extracted data.
+        //
+        // node_type extract(const key_type& x):
+        //
+        //   Extracts the key,value pair of the element with a key matching the passed
+        //   key value and returns a node handle owning that extracted data. If the
+        //   `node_hash_map` does not contain an element with a matching key, this
+        //   function returns an empty node handle.
+        //
+        // NOTE: when compiled in an earlier version of C++ than C++17,
+        // `node_type::key()` returns a const reference to the key instead of a
+        // mutable reference. We cannot safely return a mutable reference without
+        // std::launder (which is not available before C++17).
+        using Base::extract;
+
+        // node_hash_map::merge()
+        //
+        // Extracts elements from a given `source` node hash map into this
+        // `node_hash_map`. If the destination `node_hash_map` already contains an
+        // element with an equivalent key, that element is not extracted.
+        using Base::merge;
+
+        // node_hash_map::swap(node_hash_map& other)
+        //
+        // Exchanges the contents of this `node_hash_map` with those of the `other`
+        // node hash map, avoiding invocation of any move, copy, or swap operations on
+        // individual elements.
+        //
+        // All iterators and references on the `node_hash_map` remain valid, excepting
+        // for the past-the-end iterator, which is invalidated.
+        //
+        // `swap()` requires that the node hash map's hashing and key equivalence
+        // functions be Swappable, and are exchaged using unqualified calls to
+        // non-member `swap()`. If the map's allocator has
+        // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
+        // set to `true`, the allocators are also exchanged using an unqualified call
+        // to non-member `swap()`; otherwise, the allocators are not swapped.
+        using Base::swap;
+
+        // node_hash_map::rehash(count)
+        //
+        // Rehashes the `node_hash_map`, setting the number of slots to be at least
+        // the passed value. If the new number of slots increases the load factor more
+        // than the current maximum load factor
+        // (`count` < `size()` / `max_load_factor()`), then the new number of slots
+        // will be at least `size()` / `max_load_factor()`.
+        //
+        // To force a rehash, pass rehash(0).
+        using Base::rehash;
+
+        // node_hash_map::reserve(count)
+        //
+        // Sets the number of slots in the `node_hash_map` to the number needed to
+        // accommodate at least `count` total elements without exceeding the current
+        // maximum load factor, and may rehash the container if needed.
+        using Base::reserve;
+
+        // node_hash_map::at()
+        //
+        // Returns a reference to the mapped value of the element with key equivalent
+        // to the passed key.
+        using Base::at;
+
+        // node_hash_map::contains()
+        //
+        // Determines whether an element with a key comparing equal to the given `key`
+        // exists within the `node_hash_map`, returning `true` if so or `false`
+        // otherwise.
+        using Base::contains;
+
+        // node_hash_map::count(const Key& key) const
+        //
+        // Returns the number of elements with a key comparing equal to the given
+        // `key` within the `node_hash_map`. note that this function will return
+        // either `1` or `0` since duplicate keys are not allowed within a
+        // `node_hash_map`.
+        using Base::count;
+
+        // node_hash_map::equal_range()
+        //
+        // Returns a closed range [first, last], defined by a `std::pair` of two
+        // iterators, containing all elements with the passed key in the
+        // `node_hash_map`.
+        using Base::equal_range;
+
+        // node_hash_map::find()
+        //
+        // Finds an element with the passed `key` within the `node_hash_map`.
+        using Base::find;
+
+        // node_hash_map::operator[]()
+        //
+        // Returns a reference to the value mapped to the passed key within the
+        // `node_hash_map`, performing an `insert()` if the key does not already
+        // exist. If an insertion occurs and results in a rehashing of the container,
+        // all iterators are invalidated. Otherwise iterators are not affected and
+        // references are not invalidated. Overloads are listed below.
+        //
+        // T& operator[](const Key& key):
+        //
+        //   Inserts an init_type object constructed in-place if the element with the
+        //   given key does not exist.
+        //
+        // T& operator[](Key&& key):
+        //
+        //   Inserts an init_type object constructed in-place provided that an element
+        //   with the given key does not exist.
+        using Base::operator[];
+
+        // node_hash_map::bucket_count()
+        //
+        // Returns the number of "buckets" within the `node_hash_map`.
+        using Base::bucket_count;
+
+        // node_hash_map::load_factor()
+        //
+        // Returns the current load factor of the `node_hash_map` (the average number
+        // of slots occupied with a value within the hash map).
+        using Base::load_factor;
+
+        // node_hash_map::max_load_factor()
+        //
+        // Manages the maximum load factor of the `node_hash_map`. Overloads are
+        // listed below.
+        //
+        // float node_hash_map::max_load_factor()
+        //
+        //   Returns the current maximum load factor of the `node_hash_map`.
+        //
+        // void node_hash_map::max_load_factor(float ml)
+        //
+        //   Sets the maximum load factor of the `node_hash_map` to the passed value.
+        //
+        //   NOTE: This overload is provided only for API compatibility with the STL;
+        //   `node_hash_map` will ignore any set load factor and manage its rehashing
+        //   internally as an implementation detail.
+        using Base::max_load_factor;
+
+        // node_hash_map::get_allocator()
+        //
+        // Returns the allocator function associated with this `node_hash_map`.
+        using Base::get_allocator;
+
+        // node_hash_map::hash_function()
+        //
+        // Returns the hashing function used to hash the keys within this
+        // `node_hash_map`.
+        using Base::hash_function;
+
+        // node_hash_map::key_eq()
+        //
+        // Returns the function used for comparing keys equality.
+        using Base::key_eq;
+    };
+
+    // erase_if(node_hash_map<>, Pred)
+    //
+    // Erases all elements that satisfy the predicate `pred` from the container `c`.
+    // Returns the number of erased elements.
+    template<typename K, typename V, typename H, typename E, typename A, typename Predicate>
+    typename node_hash_map<K, V, H, E, A>::size_type erase_if(
+        node_hash_map<K, V, H, E, A>& c, Predicate pred
+    )
+    {
+        return container_internal::EraseIf(pred, &c);
+    }
+
+    namespace container_internal
+    {
+
+        template<class Key, class Value>
+        class NodeHashMapPolicy : public absl::container_internal::node_slot_policy<std::pair<const Key, Value>&, NodeHashMapPolicy<Key, Value>>
+        {
+            using value_type = std::pair<const Key, Value>;
+
+        public:
+            using key_type = Key;
+            using mapped_type = Value;
+            using init_type = std::pair</*non const*/ key_type, mapped_type>;
+
+            template<class Allocator, class... Args>
+            static value_type* new_element(Allocator* alloc, Args&&... args)
+            {
+                using PairAlloc = typename absl::allocator_traits<
+                    Allocator>::template rebind_alloc<value_type>;
+                PairAlloc pair_alloc(*alloc);
+                value_type* res =
+                    absl::allocator_traits<PairAlloc>::allocate(pair_alloc, 1);
+                absl::allocator_traits<PairAlloc>::construct(pair_alloc, res, std::forward<Args>(args)...);
+                return res;
+            }
+
+            template<class Allocator>
+            static void delete_element(Allocator* alloc, value_type* pair)
+            {
+                using PairAlloc = typename absl::allocator_traits<
+                    Allocator>::template rebind_alloc<value_type>;
+                PairAlloc pair_alloc(*alloc);
+                absl::allocator_traits<PairAlloc>::destroy(pair_alloc, pair);
+                absl::allocator_traits<PairAlloc>::deallocate(pair_alloc, pair, 1);
+            }
+
+            template<class F, class... Args>
+            static decltype(absl::container_internal::DecomposePair(
+                std::declval<F>(), std::declval<Args>()...
+            ))
+                apply(F&& f, Args&&... args)
+            {
+                return absl::container_internal::DecomposePair(std::forward<F>(f), std::forward<Args>(args)...);
+            }
+
+            static size_t element_space_used(const value_type*)
+            {
+                return sizeof(value_type);
+            }
+
+            static Value& value(value_type* elem)
+            {
+                return elem->second;
+            }
+            static const Value& value(const value_type* elem)
+            {
+                return elem->second;
+            }
+        };
+    }  // namespace container_internal
+
+    namespace container_algorithm_internal
+    {
+
+        // Specialization of trait in absl/algorithm/container.h
+        template<class Key, class T, class Hash, class KeyEqual, class Allocator>
+        struct IsUnorderedContainer<
+            absl::node_hash_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type
+        {
+        };
+
+    }  // namespace container_algorithm_internal
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_NODE_HASH_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/container/node_hash_set.h b/CAPI/cpp/grpc/include/absl/container/node_hash_set.h
index f2cc70c..f4cd06c 100644
--- a/CAPI/cpp/grpc/include/absl/container/node_hash_set.h
+++ b/CAPI/cpp/grpc/include/absl/container/node_hash_set.h
@@ -44,457 +44,470 @@
 #include "absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
 #include "absl/memory/memory.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-template <typename T>
-struct NodeHashSetPolicy;
-}  // namespace container_internal
-
-// -----------------------------------------------------------------------------
-// absl::node_hash_set
-// -----------------------------------------------------------------------------
-//
-// An `absl::node_hash_set<T>` is an unordered associative container which
-// has been optimized for both speed and memory footprint in most common use
-// cases. Its interface is similar to that of `std::unordered_set<T>` with the
-// following notable differences:
-//
-// * Supports heterogeneous lookup, through `find()`, `operator[]()` and
-//   `insert()`, provided that the set is provided a compatible heterogeneous
-//   hashing function and equality operator.
-// * Contains a `capacity()` member function indicating the number of element
-//   slots (open, deleted, and empty) within the hash set.
-// * Returns `void` from the `erase(iterator)` overload.
-//
-// By default, `node_hash_set` uses the `absl::Hash` hashing framework.
-// All fundamental and Abseil types that support the `absl::Hash` framework have
-// a compatible equality operator for comparing insertions into `node_hash_set`.
-// If your type is not yet supported by the `absl::Hash` framework, see
-// absl/hash/hash.h for information on extending Abseil hashing to user-defined
-// types.
-//
-// Using `absl::node_hash_set` at interface boundaries in dynamically loaded
-// libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
-// be randomized across dynamically loaded libraries.
-//
-// Example:
-//
-//   // Create a node hash set of three strings
-//   absl::node_hash_set<std::string> ducks =
-//     {"huey", "dewey", "louie"};
-//
-//  // Insert a new element into the node hash set
-//  ducks.insert("donald");
-//
-//  // Force a rehash of the node hash set
-//  ducks.rehash(0);
-//
-//  // See if "dewey" is present
-//  if (ducks.contains("dewey")) {
-//    std::cout << "We found dewey!" << std::endl;
-//  }
-template <class T, class Hash = absl::container_internal::hash_default_hash<T>,
-          class Eq = absl::container_internal::hash_default_eq<T>,
-          class Alloc = std::allocator<T>>
-class node_hash_set
-    : public absl::container_internal::raw_hash_set<
-          absl::container_internal::NodeHashSetPolicy<T>, Hash, Eq, Alloc> {
-  using Base = typename node_hash_set::raw_hash_set;
-
- public:
-  // Constructors and Assignment Operators
-  //
-  // A node_hash_set supports the same overload set as `std::unordered_set`
-  // for construction and assignment:
-  //
-  // *  Default constructor
-  //
-  //    // No allocation for the table's elements is made.
-  //    absl::node_hash_set<std::string> set1;
-  //
-  // * Initializer List constructor
-  //
-  //   absl::node_hash_set<std::string> set2 =
-  //       {{"huey"}, {"dewey"}, {"louie"}};
-  //
-  // * Copy constructor
-  //
-  //   absl::node_hash_set<std::string> set3(set2);
-  //
-  // * Copy assignment operator
-  //
-  //  // Hash functor and Comparator are copied as well
-  //  absl::node_hash_set<std::string> set4;
-  //  set4 = set3;
-  //
-  // * Move constructor
-  //
-  //   // Move is guaranteed efficient
-  //   absl::node_hash_set<std::string> set5(std::move(set4));
-  //
-  // * Move assignment operator
-  //
-  //   // May be efficient if allocators are compatible
-  //   absl::node_hash_set<std::string> set6;
-  //   set6 = std::move(set5);
-  //
-  // * Range constructor
-  //
-  //   std::vector<std::string> v = {"a", "b"};
-  //   absl::node_hash_set<std::string> set7(v.begin(), v.end());
-  node_hash_set() {}
-  using Base::Base;
-
-  // node_hash_set::begin()
-  //
-  // Returns an iterator to the beginning of the `node_hash_set`.
-  using Base::begin;
-
-  // node_hash_set::cbegin()
-  //
-  // Returns a const iterator to the beginning of the `node_hash_set`.
-  using Base::cbegin;
-
-  // node_hash_set::cend()
-  //
-  // Returns a const iterator to the end of the `node_hash_set`.
-  using Base::cend;
-
-  // node_hash_set::end()
-  //
-  // Returns an iterator to the end of the `node_hash_set`.
-  using Base::end;
-
-  // node_hash_set::capacity()
-  //
-  // Returns the number of element slots (assigned, deleted, and empty)
-  // available within the `node_hash_set`.
-  //
-  // NOTE: this member function is particular to `absl::node_hash_set` and is
-  // not provided in the `std::unordered_set` API.
-  using Base::capacity;
-
-  // node_hash_set::empty()
-  //
-  // Returns whether or not the `node_hash_set` is empty.
-  using Base::empty;
-
-  // node_hash_set::max_size()
-  //
-  // Returns the largest theoretical possible number of elements within a
-  // `node_hash_set` under current memory constraints. This value can be thought
-  // of the largest value of `std::distance(begin(), end())` for a
-  // `node_hash_set<T>`.
-  using Base::max_size;
-
-  // node_hash_set::size()
-  //
-  // Returns the number of elements currently within the `node_hash_set`.
-  using Base::size;
-
-  // node_hash_set::clear()
-  //
-  // Removes all elements from the `node_hash_set`. Invalidates any references,
-  // pointers, or iterators referring to contained elements.
-  //
-  // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
-  // the underlying buffer call `erase(begin(), end())`.
-  using Base::clear;
-
-  // node_hash_set::erase()
-  //
-  // Erases elements within the `node_hash_set`. Erasing does not trigger a
-  // rehash. Overloads are listed below.
-  //
-  // void erase(const_iterator pos):
-  //
-  //   Erases the element at `position` of the `node_hash_set`, returning
-  //   `void`.
-  //
-  //   NOTE: this return behavior is different than that of STL containers in
-  //   general and `std::unordered_set` in particular.
-  //
-  // iterator erase(const_iterator first, const_iterator last):
-  //
-  //   Erases the elements in the open interval [`first`, `last`), returning an
-  //   iterator pointing to `last`.
-  //
-  // size_type erase(const key_type& key):
-  //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
-  using Base::erase;
-
-  // node_hash_set::insert()
-  //
-  // Inserts an element of the specified value into the `node_hash_set`,
-  // returning an iterator pointing to the newly inserted element, provided that
-  // an element with the given key does not already exist. If rehashing occurs
-  // due to the insertion, all iterators are invalidated. Overloads are listed
-  // below.
-  //
-  // std::pair<iterator,bool> insert(const T& value):
-  //
-  //   Inserts a value into the `node_hash_set`. Returns a pair consisting of an
-  //   iterator to the inserted element (or to the element that prevented the
-  //   insertion) and a bool denoting whether the insertion took place.
-  //
-  // std::pair<iterator,bool> insert(T&& value):
-  //
-  //   Inserts a moveable value into the `node_hash_set`. Returns a pair
-  //   consisting of an iterator to the inserted element (or to the element that
-  //   prevented the insertion) and a bool denoting whether the insertion took
-  //   place.
-  //
-  // iterator insert(const_iterator hint, const T& value):
-  // iterator insert(const_iterator hint, T&& value):
-  //
-  //   Inserts a value, using the position of `hint` as a non-binding suggestion
-  //   for where to begin the insertion search. Returns an iterator to the
-  //   inserted element, or to the existing element that prevented the
-  //   insertion.
-  //
-  // void insert(InputIterator first, InputIterator last):
-  //
-  //   Inserts a range of values [`first`, `last`).
-  //
-  //   NOTE: Although the STL does not specify which element may be inserted if
-  //   multiple keys compare equivalently, for `node_hash_set` we guarantee the
-  //   first match is inserted.
-  //
-  // void insert(std::initializer_list<T> ilist):
-  //
-  //   Inserts the elements within the initializer list `ilist`.
-  //
-  //   NOTE: Although the STL does not specify which element may be inserted if
-  //   multiple keys compare equivalently within the initializer list, for
-  //   `node_hash_set` we guarantee the first match is inserted.
-  using Base::insert;
-
-  // node_hash_set::emplace()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `node_hash_set`, provided that no element with the given key
-  // already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  using Base::emplace;
-
-  // node_hash_set::emplace_hint()
-  //
-  // Inserts an element of the specified value by constructing it in-place
-  // within the `node_hash_set`, using the position of `hint` as a non-binding
-  // suggestion for where to begin the insertion search, and only inserts
-  // provided that no element with the given key already exists.
-  //
-  // The element may be constructed even if there already is an element with the
-  // key in the container, in which case the newly constructed element will be
-  // destroyed immediately.
-  //
-  // If rehashing occurs due to the insertion, all iterators are invalidated.
-  using Base::emplace_hint;
-
-  // node_hash_set::extract()
-  //
-  // Extracts the indicated element, erasing it in the process, and returns it
-  // as a C++17-compatible node handle. Overloads are listed below.
-  //
-  // node_type extract(const_iterator position):
-  //
-  //   Extracts the element at the indicated position and returns a node handle
-  //   owning that extracted data.
-  //
-  // node_type extract(const key_type& x):
-  //
-  //   Extracts the element with the key matching the passed key value and
-  //   returns a node handle owning that extracted data. If the `node_hash_set`
-  //   does not contain an element with a matching key, this function returns an
-  // empty node handle.
-  using Base::extract;
-
-  // node_hash_set::merge()
-  //
-  // Extracts elements from a given `source` node hash set into this
-  // `node_hash_set`. If the destination `node_hash_set` already contains an
-  // element with an equivalent key, that element is not extracted.
-  using Base::merge;
-
-  // node_hash_set::swap(node_hash_set& other)
-  //
-  // Exchanges the contents of this `node_hash_set` with those of the `other`
-  // node hash set, avoiding invocation of any move, copy, or swap operations on
-  // individual elements.
-  //
-  // All iterators and references on the `node_hash_set` remain valid, excepting
-  // for the past-the-end iterator, which is invalidated.
-  //
-  // `swap()` requires that the node hash set's hashing and key equivalence
-  // functions be Swappable, and are exchaged using unqualified calls to
-  // non-member `swap()`. If the set's allocator has
-  // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
-  // set to `true`, the allocators are also exchanged using an unqualified call
-  // to non-member `swap()`; otherwise, the allocators are not swapped.
-  using Base::swap;
-
-  // node_hash_set::rehash(count)
-  //
-  // Rehashes the `node_hash_set`, setting the number of slots to be at least
-  // the passed value. If the new number of slots increases the load factor more
-  // than the current maximum load factor
-  // (`count` < `size()` / `max_load_factor()`), then the new number of slots
-  // will be at least `size()` / `max_load_factor()`.
-  //
-  // To force a rehash, pass rehash(0).
-  //
-  // NOTE: unlike behavior in `std::unordered_set`, references are also
-  // invalidated upon a `rehash()`.
-  using Base::rehash;
-
-  // node_hash_set::reserve(count)
-  //
-  // Sets the number of slots in the `node_hash_set` to the number needed to
-  // accommodate at least `count` total elements without exceeding the current
-  // maximum load factor, and may rehash the container if needed.
-  using Base::reserve;
-
-  // node_hash_set::contains()
-  //
-  // Determines whether an element comparing equal to the given `key` exists
-  // within the `node_hash_set`, returning `true` if so or `false` otherwise.
-  using Base::contains;
-
-  // node_hash_set::count(const Key& key) const
-  //
-  // Returns the number of elements comparing equal to the given `key` within
-  // the `node_hash_set`. note that this function will return either `1` or `0`
-  // since duplicate elements are not allowed within a `node_hash_set`.
-  using Base::count;
-
-  // node_hash_set::equal_range()
-  //
-  // Returns a closed range [first, last], defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the
-  // `node_hash_set`.
-  using Base::equal_range;
-
-  // node_hash_set::find()
-  //
-  // Finds an element with the passed `key` within the `node_hash_set`.
-  using Base::find;
-
-  // node_hash_set::bucket_count()
-  //
-  // Returns the number of "buckets" within the `node_hash_set`. Note that
-  // because a node hash set contains all elements within its internal storage,
-  // this value simply equals the current capacity of the `node_hash_set`.
-  using Base::bucket_count;
-
-  // node_hash_set::load_factor()
-  //
-  // Returns the current load factor of the `node_hash_set` (the average number
-  // of slots occupied with a value within the hash set).
-  using Base::load_factor;
-
-  // node_hash_set::max_load_factor()
-  //
-  // Manages the maximum load factor of the `node_hash_set`. Overloads are
-  // listed below.
-  //
-  // float node_hash_set::max_load_factor()
-  //
-  //   Returns the current maximum load factor of the `node_hash_set`.
-  //
-  // void node_hash_set::max_load_factor(float ml)
-  //
-  //   Sets the maximum load factor of the `node_hash_set` to the passed value.
-  //
-  //   NOTE: This overload is provided only for API compatibility with the STL;
-  //   `node_hash_set` will ignore any set load factor and manage its rehashing
-  //   internally as an implementation detail.
-  using Base::max_load_factor;
-
-  // node_hash_set::get_allocator()
-  //
-  // Returns the allocator function associated with this `node_hash_set`.
-  using Base::get_allocator;
-
-  // node_hash_set::hash_function()
-  //
-  // Returns the hashing function used to hash the keys within this
-  // `node_hash_set`.
-  using Base::hash_function;
-
-  // node_hash_set::key_eq()
-  //
-  // Returns the function used for comparing keys equality.
-  using Base::key_eq;
-};
-
-// erase_if(node_hash_set<>, Pred)
-//
-// Erases all elements that satisfy the predicate `pred` from the container `c`.
-// Returns the number of erased elements.
-template <typename T, typename H, typename E, typename A, typename Predicate>
-typename node_hash_set<T, H, E, A>::size_type erase_if(
-    node_hash_set<T, H, E, A>& c, Predicate pred) {
-  return container_internal::EraseIf(pred, &c);
-}
-
-namespace container_internal {
-
-template <class T>
-struct NodeHashSetPolicy
-    : absl::container_internal::node_slot_policy<T&, NodeHashSetPolicy<T>> {
-  using key_type = T;
-  using init_type = T;
-  using constant_iterators = std::true_type;
-
-  template <class Allocator, class... Args>
-  static T* new_element(Allocator* alloc, Args&&... args) {
-    using ValueAlloc =
-        typename absl::allocator_traits<Allocator>::template rebind_alloc<T>;
-    ValueAlloc value_alloc(*alloc);
-    T* res = absl::allocator_traits<ValueAlloc>::allocate(value_alloc, 1);
-    absl::allocator_traits<ValueAlloc>::construct(value_alloc, res,
-                                                  std::forward<Args>(args)...);
-    return res;
-  }
-
-  template <class Allocator>
-  static void delete_element(Allocator* alloc, T* elem) {
-    using ValueAlloc =
-        typename absl::allocator_traits<Allocator>::template rebind_alloc<T>;
-    ValueAlloc value_alloc(*alloc);
-    absl::allocator_traits<ValueAlloc>::destroy(value_alloc, elem);
-    absl::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1);
-  }
-
-  template <class F, class... Args>
-  static decltype(absl::container_internal::DecomposeValue(
-      std::declval<F>(), std::declval<Args>()...))
-  apply(F&& f, Args&&... args) {
-    return absl::container_internal::DecomposeValue(
-        std::forward<F>(f), std::forward<Args>(args)...);
-  }
-
-  static size_t element_space_used(const T*) { return sizeof(T); }
-};
-}  // namespace container_internal
-
-namespace container_algorithm_internal {
-
-// Specialization of trait in absl/algorithm/container.h
-template <class Key, class Hash, class KeyEqual, class Allocator>
-struct IsUnorderedContainer<absl::node_hash_set<Key, Hash, KeyEqual, Allocator>>
-    : std::true_type {};
-
-}  // namespace container_algorithm_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace container_internal
+    {
+        template<typename T>
+        struct NodeHashSetPolicy;
+    }  // namespace container_internal
+
+    // -----------------------------------------------------------------------------
+    // absl::node_hash_set
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::node_hash_set<T>` is an unordered associative container which
+    // has been optimized for both speed and memory footprint in most common use
+    // cases. Its interface is similar to that of `std::unordered_set<T>` with the
+    // following notable differences:
+    //
+    // * Supports heterogeneous lookup, through `find()`, `operator[]()` and
+    //   `insert()`, provided that the set is provided a compatible heterogeneous
+    //   hashing function and equality operator.
+    // * Contains a `capacity()` member function indicating the number of element
+    //   slots (open, deleted, and empty) within the hash set.
+    // * Returns `void` from the `erase(iterator)` overload.
+    //
+    // By default, `node_hash_set` uses the `absl::Hash` hashing framework.
+    // All fundamental and Abseil types that support the `absl::Hash` framework have
+    // a compatible equality operator for comparing insertions into `node_hash_set`.
+    // If your type is not yet supported by the `absl::Hash` framework, see
+    // absl/hash/hash.h for information on extending Abseil hashing to user-defined
+    // types.
+    //
+    // Using `absl::node_hash_set` at interface boundaries in dynamically loaded
+    // libraries (e.g. .dll, .so) is unsupported due to way `absl::Hash` values may
+    // be randomized across dynamically loaded libraries.
+    //
+    // Example:
+    //
+    //   // Create a node hash set of three strings
+    //   absl::node_hash_set<std::string> ducks =
+    //     {"huey", "dewey", "louie"};
+    //
+    //  // Insert a new element into the node hash set
+    //  ducks.insert("donald");
+    //
+    //  // Force a rehash of the node hash set
+    //  ducks.rehash(0);
+    //
+    //  // See if "dewey" is present
+    //  if (ducks.contains("dewey")) {
+    //    std::cout << "We found dewey!" << std::endl;
+    //  }
+    template<class T, class Hash = absl::container_internal::hash_default_hash<T>, class Eq = absl::container_internal::hash_default_eq<T>, class Alloc = std::allocator<T>>
+    class node_hash_set : public absl::container_internal::raw_hash_set<absl::container_internal::NodeHashSetPolicy<T>, Hash, Eq, Alloc>
+    {
+        using Base = typename node_hash_set::raw_hash_set;
+
+    public:
+        // Constructors and Assignment Operators
+        //
+        // A node_hash_set supports the same overload set as `std::unordered_set`
+        // for construction and assignment:
+        //
+        // *  Default constructor
+        //
+        //    // No allocation for the table's elements is made.
+        //    absl::node_hash_set<std::string> set1;
+        //
+        // * Initializer List constructor
+        //
+        //   absl::node_hash_set<std::string> set2 =
+        //       {{"huey"}, {"dewey"}, {"louie"}};
+        //
+        // * Copy constructor
+        //
+        //   absl::node_hash_set<std::string> set3(set2);
+        //
+        // * Copy assignment operator
+        //
+        //  // Hash functor and Comparator are copied as well
+        //  absl::node_hash_set<std::string> set4;
+        //  set4 = set3;
+        //
+        // * Move constructor
+        //
+        //   // Move is guaranteed efficient
+        //   absl::node_hash_set<std::string> set5(std::move(set4));
+        //
+        // * Move assignment operator
+        //
+        //   // May be efficient if allocators are compatible
+        //   absl::node_hash_set<std::string> set6;
+        //   set6 = std::move(set5);
+        //
+        // * Range constructor
+        //
+        //   std::vector<std::string> v = {"a", "b"};
+        //   absl::node_hash_set<std::string> set7(v.begin(), v.end());
+        node_hash_set()
+        {
+        }
+        using Base::Base;
+
+        // node_hash_set::begin()
+        //
+        // Returns an iterator to the beginning of the `node_hash_set`.
+        using Base::begin;
+
+        // node_hash_set::cbegin()
+        //
+        // Returns a const iterator to the beginning of the `node_hash_set`.
+        using Base::cbegin;
+
+        // node_hash_set::cend()
+        //
+        // Returns a const iterator to the end of the `node_hash_set`.
+        using Base::cend;
+
+        // node_hash_set::end()
+        //
+        // Returns an iterator to the end of the `node_hash_set`.
+        using Base::end;
+
+        // node_hash_set::capacity()
+        //
+        // Returns the number of element slots (assigned, deleted, and empty)
+        // available within the `node_hash_set`.
+        //
+        // NOTE: this member function is particular to `absl::node_hash_set` and is
+        // not provided in the `std::unordered_set` API.
+        using Base::capacity;
+
+        // node_hash_set::empty()
+        //
+        // Returns whether or not the `node_hash_set` is empty.
+        using Base::empty;
+
+        // node_hash_set::max_size()
+        //
+        // Returns the largest theoretical possible number of elements within a
+        // `node_hash_set` under current memory constraints. This value can be thought
+        // of the largest value of `std::distance(begin(), end())` for a
+        // `node_hash_set<T>`.
+        using Base::max_size;
+
+        // node_hash_set::size()
+        //
+        // Returns the number of elements currently within the `node_hash_set`.
+        using Base::size;
+
+        // node_hash_set::clear()
+        //
+        // Removes all elements from the `node_hash_set`. Invalidates any references,
+        // pointers, or iterators referring to contained elements.
+        //
+        // NOTE: this operation may shrink the underlying buffer. To avoid shrinking
+        // the underlying buffer call `erase(begin(), end())`.
+        using Base::clear;
+
+        // node_hash_set::erase()
+        //
+        // Erases elements within the `node_hash_set`. Erasing does not trigger a
+        // rehash. Overloads are listed below.
+        //
+        // void erase(const_iterator pos):
+        //
+        //   Erases the element at `position` of the `node_hash_set`, returning
+        //   `void`.
+        //
+        //   NOTE: this return behavior is different than that of STL containers in
+        //   general and `std::unordered_set` in particular.
+        //
+        // iterator erase(const_iterator first, const_iterator last):
+        //
+        //   Erases the elements in the open interval [`first`, `last`), returning an
+        //   iterator pointing to `last`.
+        //
+        // size_type erase(const key_type& key):
+        //
+        //   Erases the element with the matching key, if it exists, returning the
+        //   number of elements erased (0 or 1).
+        using Base::erase;
+
+        // node_hash_set::insert()
+        //
+        // Inserts an element of the specified value into the `node_hash_set`,
+        // returning an iterator pointing to the newly inserted element, provided that
+        // an element with the given key does not already exist. If rehashing occurs
+        // due to the insertion, all iterators are invalidated. Overloads are listed
+        // below.
+        //
+        // std::pair<iterator,bool> insert(const T& value):
+        //
+        //   Inserts a value into the `node_hash_set`. Returns a pair consisting of an
+        //   iterator to the inserted element (or to the element that prevented the
+        //   insertion) and a bool denoting whether the insertion took place.
+        //
+        // std::pair<iterator,bool> insert(T&& value):
+        //
+        //   Inserts a moveable value into the `node_hash_set`. Returns a pair
+        //   consisting of an iterator to the inserted element (or to the element that
+        //   prevented the insertion) and a bool denoting whether the insertion took
+        //   place.
+        //
+        // iterator insert(const_iterator hint, const T& value):
+        // iterator insert(const_iterator hint, T&& value):
+        //
+        //   Inserts a value, using the position of `hint` as a non-binding suggestion
+        //   for where to begin the insertion search. Returns an iterator to the
+        //   inserted element, or to the existing element that prevented the
+        //   insertion.
+        //
+        // void insert(InputIterator first, InputIterator last):
+        //
+        //   Inserts a range of values [`first`, `last`).
+        //
+        //   NOTE: Although the STL does not specify which element may be inserted if
+        //   multiple keys compare equivalently, for `node_hash_set` we guarantee the
+        //   first match is inserted.
+        //
+        // void insert(std::initializer_list<T> ilist):
+        //
+        //   Inserts the elements within the initializer list `ilist`.
+        //
+        //   NOTE: Although the STL does not specify which element may be inserted if
+        //   multiple keys compare equivalently within the initializer list, for
+        //   `node_hash_set` we guarantee the first match is inserted.
+        using Base::insert;
+
+        // node_hash_set::emplace()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `node_hash_set`, provided that no element with the given key
+        // already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        using Base::emplace;
+
+        // node_hash_set::emplace_hint()
+        //
+        // Inserts an element of the specified value by constructing it in-place
+        // within the `node_hash_set`, using the position of `hint` as a non-binding
+        // suggestion for where to begin the insertion search, and only inserts
+        // provided that no element with the given key already exists.
+        //
+        // The element may be constructed even if there already is an element with the
+        // key in the container, in which case the newly constructed element will be
+        // destroyed immediately.
+        //
+        // If rehashing occurs due to the insertion, all iterators are invalidated.
+        using Base::emplace_hint;
+
+        // node_hash_set::extract()
+        //
+        // Extracts the indicated element, erasing it in the process, and returns it
+        // as a C++17-compatible node handle. Overloads are listed below.
+        //
+        // node_type extract(const_iterator position):
+        //
+        //   Extracts the element at the indicated position and returns a node handle
+        //   owning that extracted data.
+        //
+        // node_type extract(const key_type& x):
+        //
+        //   Extracts the element with the key matching the passed key value and
+        //   returns a node handle owning that extracted data. If the `node_hash_set`
+        //   does not contain an element with a matching key, this function returns an
+        // empty node handle.
+        using Base::extract;
+
+        // node_hash_set::merge()
+        //
+        // Extracts elements from a given `source` node hash set into this
+        // `node_hash_set`. If the destination `node_hash_set` already contains an
+        // element with an equivalent key, that element is not extracted.
+        using Base::merge;
+
+        // node_hash_set::swap(node_hash_set& other)
+        //
+        // Exchanges the contents of this `node_hash_set` with those of the `other`
+        // node hash set, avoiding invocation of any move, copy, or swap operations on
+        // individual elements.
+        //
+        // All iterators and references on the `node_hash_set` remain valid, excepting
+        // for the past-the-end iterator, which is invalidated.
+        //
+        // `swap()` requires that the node hash set's hashing and key equivalence
+        // functions be Swappable, and are exchaged using unqualified calls to
+        // non-member `swap()`. If the set's allocator has
+        // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
+        // set to `true`, the allocators are also exchanged using an unqualified call
+        // to non-member `swap()`; otherwise, the allocators are not swapped.
+        using Base::swap;
+
+        // node_hash_set::rehash(count)
+        //
+        // Rehashes the `node_hash_set`, setting the number of slots to be at least
+        // the passed value. If the new number of slots increases the load factor more
+        // than the current maximum load factor
+        // (`count` < `size()` / `max_load_factor()`), then the new number of slots
+        // will be at least `size()` / `max_load_factor()`.
+        //
+        // To force a rehash, pass rehash(0).
+        //
+        // NOTE: unlike behavior in `std::unordered_set`, references are also
+        // invalidated upon a `rehash()`.
+        using Base::rehash;
+
+        // node_hash_set::reserve(count)
+        //
+        // Sets the number of slots in the `node_hash_set` to the number needed to
+        // accommodate at least `count` total elements without exceeding the current
+        // maximum load factor, and may rehash the container if needed.
+        using Base::reserve;
+
+        // node_hash_set::contains()
+        //
+        // Determines whether an element comparing equal to the given `key` exists
+        // within the `node_hash_set`, returning `true` if so or `false` otherwise.
+        using Base::contains;
+
+        // node_hash_set::count(const Key& key) const
+        //
+        // Returns the number of elements comparing equal to the given `key` within
+        // the `node_hash_set`. note that this function will return either `1` or `0`
+        // since duplicate elements are not allowed within a `node_hash_set`.
+        using Base::count;
+
+        // node_hash_set::equal_range()
+        //
+        // Returns a closed range [first, last], defined by a `std::pair` of two
+        // iterators, containing all elements with the passed key in the
+        // `node_hash_set`.
+        using Base::equal_range;
+
+        // node_hash_set::find()
+        //
+        // Finds an element with the passed `key` within the `node_hash_set`.
+        using Base::find;
+
+        // node_hash_set::bucket_count()
+        //
+        // Returns the number of "buckets" within the `node_hash_set`. Note that
+        // because a node hash set contains all elements within its internal storage,
+        // this value simply equals the current capacity of the `node_hash_set`.
+        using Base::bucket_count;
+
+        // node_hash_set::load_factor()
+        //
+        // Returns the current load factor of the `node_hash_set` (the average number
+        // of slots occupied with a value within the hash set).
+        using Base::load_factor;
+
+        // node_hash_set::max_load_factor()
+        //
+        // Manages the maximum load factor of the `node_hash_set`. Overloads are
+        // listed below.
+        //
+        // float node_hash_set::max_load_factor()
+        //
+        //   Returns the current maximum load factor of the `node_hash_set`.
+        //
+        // void node_hash_set::max_load_factor(float ml)
+        //
+        //   Sets the maximum load factor of the `node_hash_set` to the passed value.
+        //
+        //   NOTE: This overload is provided only for API compatibility with the STL;
+        //   `node_hash_set` will ignore any set load factor and manage its rehashing
+        //   internally as an implementation detail.
+        using Base::max_load_factor;
+
+        // node_hash_set::get_allocator()
+        //
+        // Returns the allocator function associated with this `node_hash_set`.
+        using Base::get_allocator;
+
+        // node_hash_set::hash_function()
+        //
+        // Returns the hashing function used to hash the keys within this
+        // `node_hash_set`.
+        using Base::hash_function;
+
+        // node_hash_set::key_eq()
+        //
+        // Returns the function used for comparing keys equality.
+        using Base::key_eq;
+    };
+
+    // erase_if(node_hash_set<>, Pred)
+    //
+    // Erases all elements that satisfy the predicate `pred` from the container `c`.
+    // Returns the number of erased elements.
+    template<typename T, typename H, typename E, typename A, typename Predicate>
+    typename node_hash_set<T, H, E, A>::size_type erase_if(
+        node_hash_set<T, H, E, A>& c, Predicate pred
+    )
+    {
+        return container_internal::EraseIf(pred, &c);
+    }
+
+    namespace container_internal
+    {
+
+        template<class T>
+        struct NodeHashSetPolicy : absl::container_internal::node_slot_policy<T&, NodeHashSetPolicy<T>>
+        {
+            using key_type = T;
+            using init_type = T;
+            using constant_iterators = std::true_type;
+
+            template<class Allocator, class... Args>
+            static T* new_element(Allocator* alloc, Args&&... args)
+            {
+                using ValueAlloc =
+                    typename absl::allocator_traits<Allocator>::template rebind_alloc<T>;
+                ValueAlloc value_alloc(*alloc);
+                T* res = absl::allocator_traits<ValueAlloc>::allocate(value_alloc, 1);
+                absl::allocator_traits<ValueAlloc>::construct(value_alloc, res, std::forward<Args>(args)...);
+                return res;
+            }
+
+            template<class Allocator>
+            static void delete_element(Allocator* alloc, T* elem)
+            {
+                using ValueAlloc =
+                    typename absl::allocator_traits<Allocator>::template rebind_alloc<T>;
+                ValueAlloc value_alloc(*alloc);
+                absl::allocator_traits<ValueAlloc>::destroy(value_alloc, elem);
+                absl::allocator_traits<ValueAlloc>::deallocate(value_alloc, elem, 1);
+            }
+
+            template<class F, class... Args>
+            static decltype(absl::container_internal::DecomposeValue(
+                std::declval<F>(), std::declval<Args>()...
+            ))
+                apply(F&& f, Args&&... args)
+            {
+                return absl::container_internal::DecomposeValue(
+                    std::forward<F>(f), std::forward<Args>(args)...
+                );
+            }
+
+            static size_t element_space_used(const T*)
+            {
+                return sizeof(T);
+            }
+        };
+    }  // namespace container_internal
+
+    namespace container_algorithm_internal
+    {
+
+        // Specialization of trait in absl/algorithm/container.h
+        template<class Key, class Hash, class KeyEqual, class Allocator>
+        struct IsUnorderedContainer<absl::node_hash_set<Key, Hash, KeyEqual, Allocator>> : std::true_type
+        {
+        };
+
+    }  // namespace container_algorithm_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_CONTAINER_NODE_HASH_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/failure_signal_handler.h b/CAPI/cpp/grpc/include/absl/debugging/failure_signal_handler.h
index 500115c..9fa63b0 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/failure_signal_handler.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/failure_signal_handler.h
@@ -46,76 +46,79 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// FailureSignalHandlerOptions
-//
-// Struct for holding `absl::InstallFailureSignalHandler()` configuration
-// options.
-struct FailureSignalHandlerOptions {
-  // If true, try to symbolize the stacktrace emitted on failure, provided that
-  // you have initialized a symbolizer for that purpose. (See symbolize.h for
-  // more information.)
-  bool symbolize_stacktrace = true;
+    // FailureSignalHandlerOptions
+    //
+    // Struct for holding `absl::InstallFailureSignalHandler()` configuration
+    // options.
+    struct FailureSignalHandlerOptions
+    {
+        // If true, try to symbolize the stacktrace emitted on failure, provided that
+        // you have initialized a symbolizer for that purpose. (See symbolize.h for
+        // more information.)
+        bool symbolize_stacktrace = true;
 
-  // If true, try to run signal handlers on an alternate stack (if supported on
-  // the given platform). An alternate stack is useful for program crashes due
-  // to a stack overflow; by running on a alternate stack, the signal handler
-  // may run even when normal stack space has been exausted. The downside of
-  // using an alternate stack is that extra memory for the alternate stack needs
-  // to be pre-allocated.
-  bool use_alternate_stack = true;
+        // If true, try to run signal handlers on an alternate stack (if supported on
+        // the given platform). An alternate stack is useful for program crashes due
+        // to a stack overflow; by running on a alternate stack, the signal handler
+        // may run even when normal stack space has been exausted. The downside of
+        // using an alternate stack is that extra memory for the alternate stack needs
+        // to be pre-allocated.
+        bool use_alternate_stack = true;
 
-  // If positive, indicates the number of seconds after which the failure signal
-  // handler is invoked to abort the program. Setting such an alarm is useful in
-  // cases where the failure signal handler itself may become hung or
-  // deadlocked.
-  int alarm_on_failure_secs = 3;
+        // If positive, indicates the number of seconds after which the failure signal
+        // handler is invoked to abort the program. Setting such an alarm is useful in
+        // cases where the failure signal handler itself may become hung or
+        // deadlocked.
+        int alarm_on_failure_secs = 3;
 
-  // If true, call the previously registered signal handler for the signal that
-  // was received (if one was registered) after the existing signal handler
-  // runs. This mechanism can be used to chain signal handlers together.
-  //
-  // If false, the signal is raised to the default handler for that signal
-  // (which normally terminates the program).
-  //
-  // IMPORTANT: If true, the chained fatal signal handlers must not try to
-  // recover from the fatal signal. Instead, they should terminate the program
-  // via some mechanism, like raising the default handler for the signal, or by
-  // calling `_exit()`. Note that the failure signal handler may put parts of
-  // the Abseil library into a state from which they cannot recover.
-  bool call_previous_handler = false;
+        // If true, call the previously registered signal handler for the signal that
+        // was received (if one was registered) after the existing signal handler
+        // runs. This mechanism can be used to chain signal handlers together.
+        //
+        // If false, the signal is raised to the default handler for that signal
+        // (which normally terminates the program).
+        //
+        // IMPORTANT: If true, the chained fatal signal handlers must not try to
+        // recover from the fatal signal. Instead, they should terminate the program
+        // via some mechanism, like raising the default handler for the signal, or by
+        // calling `_exit()`. Note that the failure signal handler may put parts of
+        // the Abseil library into a state from which they cannot recover.
+        bool call_previous_handler = false;
 
-  // If non-null, indicates a pointer to a callback function that will be called
-  // upon failure, with a string argument containing failure data. This function
-  // may be used as a hook to write failure data to a secondary location, such
-  // as a log file. This function will also be called with null data, as a hint
-  // to flush any buffered data before the program may be terminated. Consider
-  // flushing any buffered data in all calls to this function.
-  //
-  // Since this function runs within a signal handler, it should be
-  // async-signal-safe if possible.
-  // See http://man7.org/linux/man-pages/man7/signal-safety.7.html
-  void (*writerfn)(const char*) = nullptr;
-};
+        // If non-null, indicates a pointer to a callback function that will be called
+        // upon failure, with a string argument containing failure data. This function
+        // may be used as a hook to write failure data to a secondary location, such
+        // as a log file. This function will also be called with null data, as a hint
+        // to flush any buffered data before the program may be terminated. Consider
+        // flushing any buffered data in all calls to this function.
+        //
+        // Since this function runs within a signal handler, it should be
+        // async-signal-safe if possible.
+        // See http://man7.org/linux/man-pages/man7/signal-safety.7.html
+        void (*writerfn)(const char*) = nullptr;
+    };
 
-// InstallFailureSignalHandler()
-//
-// Installs a signal handler for the common failure signals `SIGSEGV`, `SIGILL`,
-// `SIGFPE`, `SIGABRT`, `SIGTERM`, `SIGBUG`, and `SIGTRAP` (provided they exist
-// on the given platform). The failure signal handler dumps program failure data
-// useful for debugging in an unspecified format to stderr. This data may
-// include the program counter, a stacktrace, and register information on some
-// systems; do not rely on an exact format for the output, as it is subject to
-// change.
-void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options);
+    // InstallFailureSignalHandler()
+    //
+    // Installs a signal handler for the common failure signals `SIGSEGV`, `SIGILL`,
+    // `SIGFPE`, `SIGABRT`, `SIGTERM`, `SIGBUG`, and `SIGTRAP` (provided they exist
+    // on the given platform). The failure signal handler dumps program failure data
+    // useful for debugging in an unspecified format to stderr. This data may
+    // include the program counter, a stacktrace, and register information on some
+    // systems; do not rely on an exact format for the output, as it is subject to
+    // change.
+    void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options);
 
-namespace debugging_internal {
-const char* FailureSignalToString(int signo);
-}  // namespace debugging_internal
+    namespace debugging_internal
+    {
+        const char* FailureSignalToString(int signo);
+    }  // namespace debugging_internal
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/address_is_readable.h b/CAPI/cpp/grpc/include/absl/debugging/internal/address_is_readable.h
index 4bbaf4d..6c2403d 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/internal/address_is_readable.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/address_is_readable.h
@@ -17,16 +17,18 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace debugging_internal
+    {
 
-// Return whether the byte at *addr is readable, without faulting.
-// Save and restores errno.
-bool AddressIsReadable(const void *addr);
+        // Return whether the byte at *addr is readable, without faulting.
+        // Save and restores errno.
+        bool AddressIsReadable(const void* addr);
 
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/demangle.h b/CAPI/cpp/grpc/include/absl/debugging/internal/demangle.h
index c314d9b..126a886 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/internal/demangle.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/demangle.h
@@ -55,17 +55,19 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace debugging_internal
+    {
 
-// Demangle `mangled`.  On success, return true and write the
-// demangled symbol name to `out`.  Otherwise, return false.
-// `out` is modified even if demangling is unsuccessful.
-bool Demangle(const char *mangled, char *out, int out_size);
+        // Demangle `mangled`.  On success, return true and write the
+        // demangled symbol name to `out`.  Otherwise, return false.
+        // `out` is modified even if demangling is unsuccessful.
+        bool Demangle(const char* mangled, char* out, int out_size);
 
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/elf_mem_image.h b/CAPI/cpp/grpc/include/absl/debugging/internal/elf_mem_image.h
index 113071a..bde026f 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/internal/elf_mem_image.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/elf_mem_image.h
@@ -45,93 +45,100 @@
 #define ElfW(x) __ElfN(x)
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// An in-memory ELF image (may not exist on disk).
-class ElfMemImage {
- private:
-  // Sentinel: there could never be an elf image at &kInvalidBaseSentinel.
-  static const int kInvalidBaseSentinel;
-
- public:
-  // Sentinel: there could never be an elf image at this address.
-  static constexpr const void *const kInvalidBase =
-    static_cast<const void*>(&kInvalidBaseSentinel);
-
-  // Information about a single vdso symbol.
-  // All pointers are into .dynsym, .dynstr, or .text of the VDSO.
-  // Do not free() them or modify through them.
-  struct SymbolInfo {
-    const char      *name;      // E.g. "__vdso_getcpu"
-    const char      *version;   // E.g. "LINUX_2.6", could be ""
-                                // for unversioned symbol.
-    const void      *address;   // Relocated symbol address.
-    const ElfW(Sym) *symbol;    // Symbol in the dynamic symbol table.
-  };
-
-  // Supports iteration over all dynamic symbols.
-  class SymbolIterator {
-   public:
-    friend class ElfMemImage;
-    const SymbolInfo *operator->() const;
-    const SymbolInfo &operator*() const;
-    SymbolIterator& operator++();
-    bool operator!=(const SymbolIterator &rhs) const;
-    bool operator==(const SymbolIterator &rhs) const;
-   private:
-    SymbolIterator(const void *const image, int index);
-    void Update(int incr);
-    SymbolInfo info_;
-    int index_;
-    const void *const image_;
-  };
-
-
-  explicit ElfMemImage(const void *base);
-  void                 Init(const void *base);
-  bool                 IsPresent() const { return ehdr_ != nullptr; }
-  const ElfW(Phdr)*    GetPhdr(int index) const;
-  const ElfW(Sym)*     GetDynsym(int index) const;
-  const ElfW(Versym)*  GetVersym(int index) const;
-  const ElfW(Verdef)*  GetVerdef(int index) const;
-  const ElfW(Verdaux)* GetVerdefAux(const ElfW(Verdef) *verdef) const;
-  const char*          GetDynstr(ElfW(Word) offset) const;
-  const void*          GetSymAddr(const ElfW(Sym) *sym) const;
-  const char*          GetVerstr(ElfW(Word) offset) const;
-  int                  GetNumSymbols() const;
-
-  SymbolIterator begin() const;
-  SymbolIterator end() const;
-
-  // Look up versioned dynamic symbol in the image.
-  // Returns false if image is not present, or doesn't contain given
-  // symbol/version/type combination.
-  // If info_out is non-null, additional details are filled in.
-  bool LookupSymbol(const char *name, const char *version,
-                    int symbol_type, SymbolInfo *info_out) const;
-
-  // Find info about symbol (if any) which overlaps given address.
-  // Returns true if symbol was found; false if image isn't present
-  // or doesn't have a symbol overlapping given address.
-  // If info_out is non-null, additional details are filled in.
-  bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const;
-
- private:
-  const ElfW(Ehdr) *ehdr_;
-  const ElfW(Sym) *dynsym_;
-  const ElfW(Versym) *versym_;
-  const ElfW(Verdef) *verdef_;
-  const ElfW(Word) *hash_;
-  const char *dynstr_;
-  size_t strsize_;
-  size_t verdefnum_;
-  ElfW(Addr) link_base_;     // Link-time base (p_vaddr of first PT_LOAD).
-};
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace debugging_internal
+    {
+
+        // An in-memory ELF image (may not exist on disk).
+        class ElfMemImage
+        {
+        private:
+            // Sentinel: there could never be an elf image at &kInvalidBaseSentinel.
+            static const int kInvalidBaseSentinel;
+
+        public:
+            // Sentinel: there could never be an elf image at this address.
+            static constexpr const void* const kInvalidBase =
+                static_cast<const void*>(&kInvalidBaseSentinel);
+
+            // Information about a single vdso symbol.
+            // All pointers are into .dynsym, .dynstr, or .text of the VDSO.
+            // Do not free() them or modify through them.
+            struct SymbolInfo
+            {
+                const char* name;          // E.g. "__vdso_getcpu"
+                const char* version;       // E.g. "LINUX_2.6", could be ""
+                                           // for unversioned symbol.
+                const void* address;       // Relocated symbol address.
+                const ElfW(Sym) * symbol;  // Symbol in the dynamic symbol table.
+            };
+
+            // Supports iteration over all dynamic symbols.
+            class SymbolIterator
+            {
+            public:
+                friend class ElfMemImage;
+                const SymbolInfo* operator->() const;
+                const SymbolInfo& operator*() const;
+                SymbolIterator& operator++();
+                bool operator!=(const SymbolIterator& rhs) const;
+                bool operator==(const SymbolIterator& rhs) const;
+
+            private:
+                SymbolIterator(const void* const image, int index);
+                void Update(int incr);
+                SymbolInfo info_;
+                int index_;
+                const void* const image_;
+            };
+
+            explicit ElfMemImage(const void* base);
+            void Init(const void* base);
+            bool IsPresent() const
+            {
+                return ehdr_ != nullptr;
+            }
+            const ElfW(Phdr) * GetPhdr(int index) const;
+            const ElfW(Sym) * GetDynsym(int index) const;
+            const ElfW(Versym) * GetVersym(int index) const;
+            const ElfW(Verdef) * GetVerdef(int index) const;
+            const ElfW(Verdaux) * GetVerdefAux(const ElfW(Verdef) * verdef) const;
+            const char* GetDynstr(ElfW(Word) offset) const;
+            const void* GetSymAddr(const ElfW(Sym) * sym) const;
+            const char* GetVerstr(ElfW(Word) offset) const;
+            int GetNumSymbols() const;
+
+            SymbolIterator begin() const;
+            SymbolIterator end() const;
+
+            // Look up versioned dynamic symbol in the image.
+            // Returns false if image is not present, or doesn't contain given
+            // symbol/version/type combination.
+            // If info_out is non-null, additional details are filled in.
+            bool LookupSymbol(const char* name, const char* version, int symbol_type, SymbolInfo* info_out) const;
+
+            // Find info about symbol (if any) which overlaps given address.
+            // Returns true if symbol was found; false if image isn't present
+            // or doesn't have a symbol overlapping given address.
+            // If info_out is non-null, additional details are filled in.
+            bool LookupSymbolByAddress(const void* address, SymbolInfo* info_out) const;
+
+        private:
+            const ElfW(Ehdr) * ehdr_;
+            const ElfW(Sym) * dynsym_;
+            const ElfW(Versym) * versym_;
+            const ElfW(Verdef) * verdef_;
+            const ElfW(Word) * hash_;
+            const char* dynstr_;
+            size_t strsize_;
+            size_t verdefnum_;
+            ElfW(Addr) link_base_;  // Link-time base (p_vaddr of first PT_LOAD).
+        };
+
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_HAVE_ELF_MEM_IMAGE
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/examine_stack.h b/CAPI/cpp/grpc/include/absl/debugging/internal/examine_stack.h
index 190af87..914290e 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/internal/examine_stack.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/examine_stack.h
@@ -19,46 +19,41 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// Type of function used for printing in stack trace dumping, etc.
-// We avoid closures to keep things simple.
-typedef void OutputWriter(const char*, void*);
-
-// RegisterDebugStackTraceHook() allows to register a single routine
-// `hook` that is called each time DumpStackTrace() is called.
-// `hook` may be called from a signal handler.
-typedef void (*SymbolizeUrlEmitter)(void* const stack[], int depth,
-                                    OutputWriter* writer, void* writer_arg);
-
-// Registration of SymbolizeUrlEmitter for use inside of a signal handler.
-// This is inherently unsafe and must be signal safe code.
-void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook);
-SymbolizeUrlEmitter GetDebugStackTraceHook();
-
-// Returns the program counter from signal context, or nullptr if
-// unknown. `vuc` is a ucontext_t*. We use void* to avoid the use of
-// ucontext_t on non-POSIX systems.
-void* GetProgramCounter(void* const vuc);
-
-// Uses `writer` to dump the program counter, stack trace, and stack
-// frame sizes.
-void DumpPCAndFrameSizesAndStackTrace(void* const pc, void* const stack[],
-                                      int frame_sizes[], int depth,
-                                      int min_dropped_frames,
-                                      bool symbolize_stacktrace,
-                                      OutputWriter* writer, void* writer_arg);
-
-// Dump current stack trace omitting the topmost `min_dropped_frames` stack
-// frames.
-void DumpStackTrace(int min_dropped_frames, int max_num_frames,
-                    bool symbolize_stacktrace, OutputWriter* writer,
-                    void* writer_arg);
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace debugging_internal
+    {
+
+        // Type of function used for printing in stack trace dumping, etc.
+        // We avoid closures to keep things simple.
+        typedef void OutputWriter(const char*, void*);
+
+        // RegisterDebugStackTraceHook() allows to register a single routine
+        // `hook` that is called each time DumpStackTrace() is called.
+        // `hook` may be called from a signal handler.
+        typedef void (*SymbolizeUrlEmitter)(void* const stack[], int depth, OutputWriter* writer, void* writer_arg);
+
+        // Registration of SymbolizeUrlEmitter for use inside of a signal handler.
+        // This is inherently unsafe and must be signal safe code.
+        void RegisterDebugStackTraceHook(SymbolizeUrlEmitter hook);
+        SymbolizeUrlEmitter GetDebugStackTraceHook();
+
+        // Returns the program counter from signal context, or nullptr if
+        // unknown. `vuc` is a ucontext_t*. We use void* to avoid the use of
+        // ucontext_t on non-POSIX systems.
+        void* GetProgramCounter(void* const vuc);
+
+        // Uses `writer` to dump the program counter, stack trace, and stack
+        // frame sizes.
+        void DumpPCAndFrameSizesAndStackTrace(void* const pc, void* const stack[], int frame_sizes[], int depth, int min_dropped_frames, bool symbolize_stacktrace, OutputWriter* writer, void* writer_arg);
+
+        // Dump current stack trace omitting the topmost `min_dropped_frames` stack
+        // frames.
+        void DumpStackTrace(int min_dropped_frames, int max_num_frames, bool symbolize_stacktrace, OutputWriter* writer, void* writer_arg);
+
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stack_consumption.h b/CAPI/cpp/grpc/include/absl/debugging/internal/stack_consumption.h
index f41b64c..2afbeee 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/internal/stack_consumption.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stack_consumption.h
@@ -29,20 +29,22 @@
      defined(__aarch64__) || defined(__riscv))
 #define ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// Returns the stack consumption in bytes for the code exercised by
-// signal_handler.  To measure stack consumption, signal_handler is registered
-// as a signal handler, so the code that it exercises must be async-signal
-// safe.  The argument of signal_handler is an implementation detail of signal
-// handlers and should ignored by the code for signal_handler.  Use global
-// variables to pass information between your test code and signal_handler.
-int GetSignalHandlerStackConsumption(void (*signal_handler)(int));
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace debugging_internal
+    {
+
+        // Returns the stack consumption in bytes for the code exercised by
+        // signal_handler.  To measure stack consumption, signal_handler is registered
+        // as a signal handler, so the code that it exercises must be async-signal
+        // safe.  The argument of signal_handler is an implementation detail of signal
+        // handlers and should ignored by the code for signal_handler.  Use global
+        // variables to pass information between your test code and signal_handler.
+        int GetSignalHandlerStackConsumption(void (*signal_handler)(int));
+
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_config.h b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_config.h
index 3929b1b..5f0ff7a 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_config.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/stacktrace_config.h
@@ -34,13 +34,13 @@
 #ifdef ABSL_HAVE_THREAD_LOCAL
 // Thread local support required for UnwindImpl.
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_generic-inl.inc"
+    "absl/debugging/internal/stacktrace_generic-inl.inc"
 #endif  // defined(ABSL_HAVE_THREAD_LOCAL)
 
 // Emscripten stacktraces rely on JS. Do not use them in standalone mode.
 #elif defined(__EMSCRIPTEN__) && !defined(STANDALONE_WASM)
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_emscripten-inl.inc"
+    "absl/debugging/internal/stacktrace_emscripten-inl.inc"
 
 #elif defined(__linux__) && !defined(__ANDROID__)
 
@@ -49,31 +49,31 @@
 // Note: The libunwind-based implementation is not available to open-source
 // users.
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_libunwind-inl.inc"
+    "absl/debugging/internal/stacktrace_libunwind-inl.inc"
 #define STACKTRACE_USES_LIBUNWIND 1
 #elif defined(NO_FRAME_POINTER) && defined(__has_include)
 #if __has_include(<execinfo.h>)
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_generic-inl.inc"
+    "absl/debugging/internal/stacktrace_generic-inl.inc"
 #endif  // __has_include(<execinfo.h>)
 #elif defined(__i386__) || defined(__x86_64__)
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_x86-inl.inc"
+    "absl/debugging/internal/stacktrace_x86-inl.inc"
 #elif defined(__ppc__) || defined(__PPC__)
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_powerpc-inl.inc"
+    "absl/debugging/internal/stacktrace_powerpc-inl.inc"
 #elif defined(__aarch64__)
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_aarch64-inl.inc"
+    "absl/debugging/internal/stacktrace_aarch64-inl.inc"
 #elif defined(__riscv)
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_riscv-inl.inc"
+    "absl/debugging/internal/stacktrace_riscv-inl.inc"
 #elif defined(__has_include)
 #if __has_include(<execinfo.h>)
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_generic-inl.inc"
+    "absl/debugging/internal/stacktrace_generic-inl.inc"
 #endif  // __has_include(<execinfo.h>)
 #endif  // defined(__has_include)
 
@@ -82,7 +82,7 @@
 // Fallback to the empty implementation.
 #if !defined(ABSL_STACKTRACE_INL_HEADER)
 #define ABSL_STACKTRACE_INL_HEADER \
-  "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+    "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
 #endif
 
 #endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/symbolize.h b/CAPI/cpp/grpc/include/absl/debugging/internal/symbolize.h
index 27d5e65..0430a58 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/internal/symbolize.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/symbolize.h
@@ -28,8 +28,7 @@
 
 #ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
 #error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
-#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) \
-      && !defined(__asmjs__) && !defined(__wasm__)
+#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) && !defined(__asmjs__) && !defined(__wasm__)
 #define ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1
 
 #include <elf.h>
@@ -37,27 +36,26 @@
 #include <functional>
 #include <string>
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// Iterates over all sections, invoking callback on each with the section name
-// and the section header.
-//
-// Returns true on success; otherwise returns false in case of errors.
-//
-// This is not async-signal-safe.
-bool ForEachSection(int fd,
-                    const std::function<bool(absl::string_view name,
-                                             const ElfW(Shdr) &)>& callback);
-
-// Gets the section header for the given name, if it exists. Returns true on
-// success. Otherwise, returns false.
-bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
-                            ElfW(Shdr) *out);
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace debugging_internal
+    {
+
+        // Iterates over all sections, invoking callback on each with the section name
+        // and the section header.
+        //
+        // Returns true on success; otherwise returns false in case of errors.
+        //
+        // This is not async-signal-safe.
+        bool ForEachSection(int fd, const std::function<bool(absl::string_view name, const ElfW(Shdr) &)>& callback);
+
+        // Gets the section header for the given name, if it exists. Returns true on
+        // success. Otherwise, returns false.
+        bool GetSectionHeaderByName(int fd, const char* name, size_t name_len, ElfW(Shdr) * out);
+
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
@@ -74,68 +72,69 @@ ABSL_NAMESPACE_END
 #define ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-struct SymbolDecoratorArgs {
-  // The program counter we are getting symbolic name for.
-  const void *pc;
-  // 0 for main executable, load address for shared libraries.
-  ptrdiff_t relocation;
-  // Read-only file descriptor for ELF image covering "pc",
-  // or -1 if no such ELF image exists in /proc/self/maps.
-  int fd;
-  // Output buffer, size.
-  // Note: the buffer may not be empty -- default symbolizer may have already
-  // produced some output, and earlier decorators may have adorned it in
-  // some way. You are free to replace or augment the contents (within the
-  // symbol_buf_size limit).
-  char *const symbol_buf;
-  size_t symbol_buf_size;
-  // Temporary scratch space, size.
-  // Use that space in preference to allocating your own stack buffer to
-  // conserve stack.
-  char *const tmp_buf;
-  size_t tmp_buf_size;
-  // User-provided argument
-  void* arg;
-};
-using SymbolDecorator = void (*)(const SymbolDecoratorArgs *);
-
-// Installs a function-pointer as a decorator. Returns a value less than zero
-// if the system cannot install the decorator. Otherwise, returns a unique
-// identifier corresponding to the decorator. This identifier can be used to
-// uninstall the decorator - See RemoveSymbolDecorator() below.
-int InstallSymbolDecorator(SymbolDecorator decorator, void* arg);
-
-// Removes a previously installed function-pointer decorator. Parameter "ticket"
-// is the return-value from calling InstallSymbolDecorator().
-bool RemoveSymbolDecorator(int ticket);
-
-// Remove all installed decorators.  Returns true if successful, false if
-// symbolization is currently in progress.
-bool RemoveAllSymbolDecorators(void);
-
-// Registers an address range to a file mapping.
-//
-// Preconditions:
-//   start <= end
-//   filename != nullptr
-//
-// Returns true if the file was successfully registered.
-bool RegisterFileMappingHint(const void* start, const void* end,
-                             uint64_t offset, const char* filename);
-
-// Looks up the file mapping registered by RegisterFileMappingHint for an
-// address range. If there is one, the file name is stored in *filename and
-// *start and *end are modified to reflect the registered mapping. Returns
-// whether any hint was found.
-bool GetFileMappingHint(const void** start, const void** end, uint64_t* offset,
-                        const char** filename);
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace debugging_internal
+    {
+
+        struct SymbolDecoratorArgs
+        {
+            // The program counter we are getting symbolic name for.
+            const void* pc;
+            // 0 for main executable, load address for shared libraries.
+            ptrdiff_t relocation;
+            // Read-only file descriptor for ELF image covering "pc",
+            // or -1 if no such ELF image exists in /proc/self/maps.
+            int fd;
+            // Output buffer, size.
+            // Note: the buffer may not be empty -- default symbolizer may have already
+            // produced some output, and earlier decorators may have adorned it in
+            // some way. You are free to replace or augment the contents (within the
+            // symbol_buf_size limit).
+            char* const symbol_buf;
+            size_t symbol_buf_size;
+            // Temporary scratch space, size.
+            // Use that space in preference to allocating your own stack buffer to
+            // conserve stack.
+            char* const tmp_buf;
+            size_t tmp_buf_size;
+            // User-provided argument
+            void* arg;
+        };
+        using SymbolDecorator = void (*)(const SymbolDecoratorArgs*);
+
+        // Installs a function-pointer as a decorator. Returns a value less than zero
+        // if the system cannot install the decorator. Otherwise, returns a unique
+        // identifier corresponding to the decorator. This identifier can be used to
+        // uninstall the decorator - See RemoveSymbolDecorator() below.
+        int InstallSymbolDecorator(SymbolDecorator decorator, void* arg);
+
+        // Removes a previously installed function-pointer decorator. Parameter "ticket"
+        // is the return-value from calling InstallSymbolDecorator().
+        bool RemoveSymbolDecorator(int ticket);
+
+        // Remove all installed decorators.  Returns true if successful, false if
+        // symbolization is currently in progress.
+        bool RemoveAllSymbolDecorators(void);
+
+        // Registers an address range to a file mapping.
+        //
+        // Preconditions:
+        //   start <= end
+        //   filename != nullptr
+        //
+        // Returns true if the file was successfully registered.
+        bool RegisterFileMappingHint(const void* start, const void* end, uint64_t offset, const char* filename);
+
+        // Looks up the file mapping registered by RegisterFileMappingHint for an
+        // address range. If there is one, the file name is stored in *filename and
+        // *start and *end are modified to reflect the registered mapping. Returns
+        // whether any hint was found.
+        bool GetFileMappingHint(const void** start, const void** end, uint64_t* offset, const char** filename);
+
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // __cplusplus
@@ -147,7 +146,6 @@ extern "C"
 #endif  // __cplusplus
 
     bool
-    AbslInternalGetFileMappingHint(const void** start, const void** end,
-                                   uint64_t* offset, const char** filename);
+    AbslInternalGetFileMappingHint(const void** start, const void** end, uint64_t* offset, const char** filename);
 
 #endif  // ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/internal/vdso_support.h b/CAPI/cpp/grpc/include/absl/debugging/internal/vdso_support.h
index 6562c6c..6707098 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/internal/vdso_support.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/internal/vdso_support.h
@@ -52,105 +52,122 @@
 #define ABSL_HAVE_VDSO_SUPPORT 1
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// NOTE: this class may be used from within tcmalloc, and can not
-// use any memory allocation routines.
-class VDSOSupport {
- public:
-  VDSOSupport();
-
-  typedef ElfMemImage::SymbolInfo SymbolInfo;
-  typedef ElfMemImage::SymbolIterator SymbolIterator;
-
-  // On PowerPC64 VDSO symbols can either be of type STT_FUNC or STT_NOTYPE
-  // depending on how the kernel is built.  The kernel is normally built with
-  // STT_NOTYPE type VDSO symbols.  Let's make things simpler first by using a
-  // compile-time constant.
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace debugging_internal
+    {
+
+        // NOTE: this class may be used from within tcmalloc, and can not
+        // use any memory allocation routines.
+        class VDSOSupport
+        {
+        public:
+            VDSOSupport();
+
+            typedef ElfMemImage::SymbolInfo SymbolInfo;
+            typedef ElfMemImage::SymbolIterator SymbolIterator;
+
+            // On PowerPC64 VDSO symbols can either be of type STT_FUNC or STT_NOTYPE
+            // depending on how the kernel is built.  The kernel is normally built with
+            // STT_NOTYPE type VDSO symbols.  Let's make things simpler first by using a
+            // compile-time constant.
 #ifdef __powerpc64__
-  enum { kVDSOSymbolType = STT_NOTYPE };
+            enum
+            {
+                kVDSOSymbolType = STT_NOTYPE
+            };
 #else
-  enum { kVDSOSymbolType = STT_FUNC };
+            enum
+            {
+                kVDSOSymbolType = STT_FUNC
+            };
 #endif
 
-  // Answers whether we have a vdso at all.
-  bool IsPresent() const { return image_.IsPresent(); }
-
-  // Allow to iterate over all VDSO symbols.
-  SymbolIterator begin() const { return image_.begin(); }
-  SymbolIterator end() const { return image_.end(); }
-
-  // Look up versioned dynamic symbol in the kernel VDSO.
-  // Returns false if VDSO is not present, or doesn't contain given
-  // symbol/version/type combination.
-  // If info_out != nullptr, additional details are filled in.
-  bool LookupSymbol(const char *name, const char *version,
-                    int symbol_type, SymbolInfo *info_out) const;
-
-  // Find info about symbol (if any) which overlaps given address.
-  // Returns true if symbol was found; false if VDSO isn't present
-  // or doesn't have a symbol overlapping given address.
-  // If info_out != nullptr, additional details are filled in.
-  bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const;
-
-  // Used only for testing. Replace real VDSO base with a mock.
-  // Returns previous value of vdso_base_. After you are done testing,
-  // you are expected to call SetBase() with previous value, in order to
-  // reset state to the way it was.
-  const void *SetBase(const void *s);
-
-  // Computes vdso_base_ and returns it. Should be called as early as
-  // possible; before any thread creation, chroot or setuid.
-  static const void *Init();
-
- private:
-  // image_ represents VDSO ELF image in memory.
-  // image_.ehdr_ == nullptr implies there is no VDSO.
-  ElfMemImage image_;
-
-  // Cached value of auxv AT_SYSINFO_EHDR, computed once.
-  // This is a tri-state:
-  //   kInvalidBase   => value hasn't been determined yet.
-  //              0   => there is no VDSO.
-  //           else   => vma of VDSO Elf{32,64}_Ehdr.
-  //
-  // When testing with mock VDSO, low bit is set.
-  // The low bit is always available because vdso_base_ is
-  // page-aligned.
-  static std::atomic<const void *> vdso_base_;
-
-  // NOLINT on 'long' because these routines mimic kernel api.
-  // The 'cache' parameter may be used by some versions of the kernel,
-  // and should be nullptr or point to a static buffer containing at
-  // least two 'long's.
-  static long InitAndGetCPU(unsigned *cpu, void *cache,     // NOLINT 'long'.
-                            void *unused);
-  static long GetCPUViaSyscall(unsigned *cpu, void *cache,  // NOLINT 'long'.
-                               void *unused);
-  typedef long (*GetCpuFn)(unsigned *cpu, void *cache,      // NOLINT 'long'.
-                           void *unused);
-
-  // This function pointer may point to InitAndGetCPU,
-  // GetCPUViaSyscall, or __vdso_getcpu at different stages of initialization.
-  ABSL_CONST_INIT static std::atomic<GetCpuFn> getcpu_fn_;
-
-  friend int GetCPU(void);  // Needs access to getcpu_fn_.
-
-  VDSOSupport(const VDSOSupport&) = delete;
-  VDSOSupport& operator=(const VDSOSupport&) = delete;
-};
-
-// Same as sched_getcpu() on later glibc versions.
-// Return current CPU, using (fast) __vdso_getcpu@LINUX_2.6 if present,
-// otherwise use syscall(SYS_getcpu,...).
-// May return -1 with errno == ENOSYS if the kernel doesn't
-// support SYS_getcpu.
-int GetCPU();
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+            // Answers whether we have a vdso at all.
+            bool IsPresent() const
+            {
+                return image_.IsPresent();
+            }
+
+            // Allow to iterate over all VDSO symbols.
+            SymbolIterator begin() const
+            {
+                return image_.begin();
+            }
+            SymbolIterator end() const
+            {
+                return image_.end();
+            }
+
+            // Look up versioned dynamic symbol in the kernel VDSO.
+            // Returns false if VDSO is not present, or doesn't contain given
+            // symbol/version/type combination.
+            // If info_out != nullptr, additional details are filled in.
+            bool LookupSymbol(const char* name, const char* version, int symbol_type, SymbolInfo* info_out) const;
+
+            // Find info about symbol (if any) which overlaps given address.
+            // Returns true if symbol was found; false if VDSO isn't present
+            // or doesn't have a symbol overlapping given address.
+            // If info_out != nullptr, additional details are filled in.
+            bool LookupSymbolByAddress(const void* address, SymbolInfo* info_out) const;
+
+            // Used only for testing. Replace real VDSO base with a mock.
+            // Returns previous value of vdso_base_. After you are done testing,
+            // you are expected to call SetBase() with previous value, in order to
+            // reset state to the way it was.
+            const void* SetBase(const void* s);
+
+            // Computes vdso_base_ and returns it. Should be called as early as
+            // possible; before any thread creation, chroot or setuid.
+            static const void* Init();
+
+        private:
+            // image_ represents VDSO ELF image in memory.
+            // image_.ehdr_ == nullptr implies there is no VDSO.
+            ElfMemImage image_;
+
+            // Cached value of auxv AT_SYSINFO_EHDR, computed once.
+            // This is a tri-state:
+            //   kInvalidBase   => value hasn't been determined yet.
+            //              0   => there is no VDSO.
+            //           else   => vma of VDSO Elf{32,64}_Ehdr.
+            //
+            // When testing with mock VDSO, low bit is set.
+            // The low bit is always available because vdso_base_ is
+            // page-aligned.
+            static std::atomic<const void*> vdso_base_;
+
+            // NOLINT on 'long' because these routines mimic kernel api.
+            // The 'cache' parameter may be used by some versions of the kernel,
+            // and should be nullptr or point to a static buffer containing at
+            // least two 'long's.
+            static long InitAndGetCPU(unsigned* cpu, void* cache,  // NOLINT 'long'.
+                                      void* unused);
+            static long GetCPUViaSyscall(unsigned* cpu, void* cache,  // NOLINT 'long'.
+                                         void* unused);
+            typedef long (*GetCpuFn)(unsigned* cpu, void* cache,  // NOLINT 'long'.
+                                     void* unused);
+
+            // This function pointer may point to InitAndGetCPU,
+            // GetCPUViaSyscall, or __vdso_getcpu at different stages of initialization.
+            ABSL_CONST_INIT static std::atomic<GetCpuFn> getcpu_fn_;
+
+            friend int GetCPU(void);  // Needs access to getcpu_fn_.
+
+            VDSOSupport(const VDSOSupport&) = delete;
+            VDSOSupport& operator=(const VDSOSupport&) = delete;
+        };
+
+        // Same as sched_getcpu() on later glibc versions.
+        // Return current CPU, using (fast) __vdso_getcpu@LINUX_2.6 if present,
+        // otherwise use syscall(SYS_getcpu,...).
+        // May return -1 with errno == ENOSYS if the kernel doesn't
+        // support SYS_getcpu.
+        int GetCPU();
+
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_HAVE_ELF_MEM_IMAGE
diff --git a/CAPI/cpp/grpc/include/absl/debugging/leak_check.h b/CAPI/cpp/grpc/include/absl/debugging/leak_check.h
index eff162f..10d21e1 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/leak_check.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/leak_check.h
@@ -51,100 +51,103 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// HaveLeakSanitizer()
-//
-// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
-// currently built into this target.
-bool HaveLeakSanitizer();
+    // HaveLeakSanitizer()
+    //
+    // Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
+    // currently built into this target.
+    bool HaveLeakSanitizer();
 
-// LeakCheckerIsActive()
-//
-// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
-// currently built into this target and is turned on.
-bool LeakCheckerIsActive();
+    // LeakCheckerIsActive()
+    //
+    // Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
+    // currently built into this target and is turned on.
+    bool LeakCheckerIsActive();
 
-// DoIgnoreLeak()
-//
-// Implements `IgnoreLeak()` below. This function should usually
-// not be called directly; calling `IgnoreLeak()` is preferred.
-void DoIgnoreLeak(const void* ptr);
+    // DoIgnoreLeak()
+    //
+    // Implements `IgnoreLeak()` below. This function should usually
+    // not be called directly; calling `IgnoreLeak()` is preferred.
+    void DoIgnoreLeak(const void* ptr);
 
-// IgnoreLeak()
-//
-// Instruct the leak sanitizer to ignore leak warnings on the object referenced
-// by the passed pointer, as well as all heap objects transitively referenced
-// by it. The passed object pointer can point to either the beginning of the
-// object or anywhere within it.
-//
-// Example:
-//
-//   static T* obj = IgnoreLeak(new T(...));
-//
-// If the passed `ptr` does not point to an actively allocated object at the
-// time `IgnoreLeak()` is called, the call is a no-op; if it is actively
-// allocated, leak sanitizer will assume this object is referenced even if
-// there is no actual reference in user memory.
-//
-template <typename T>
-T* IgnoreLeak(T* ptr) {
-  DoIgnoreLeak(ptr);
-  return ptr;
-}
+    // IgnoreLeak()
+    //
+    // Instruct the leak sanitizer to ignore leak warnings on the object referenced
+    // by the passed pointer, as well as all heap objects transitively referenced
+    // by it. The passed object pointer can point to either the beginning of the
+    // object or anywhere within it.
+    //
+    // Example:
+    //
+    //   static T* obj = IgnoreLeak(new T(...));
+    //
+    // If the passed `ptr` does not point to an actively allocated object at the
+    // time `IgnoreLeak()` is called, the call is a no-op; if it is actively
+    // allocated, leak sanitizer will assume this object is referenced even if
+    // there is no actual reference in user memory.
+    //
+    template<typename T>
+    T* IgnoreLeak(T* ptr)
+    {
+        DoIgnoreLeak(ptr);
+        return ptr;
+    }
 
-// FindAndReportLeaks()
-//
-// If any leaks are detected, prints a leak report and returns true.  This
-// function may be called repeatedly, and does not affect end-of-process leak
-// checking.
-//
-// Example:
-// if (FindAndReportLeaks()) {
-//   ... diagnostic already printed. Exit with failure code.
-//   exit(1)
-// }
-bool FindAndReportLeaks();
+    // FindAndReportLeaks()
+    //
+    // If any leaks are detected, prints a leak report and returns true.  This
+    // function may be called repeatedly, and does not affect end-of-process leak
+    // checking.
+    //
+    // Example:
+    // if (FindAndReportLeaks()) {
+    //   ... diagnostic already printed. Exit with failure code.
+    //   exit(1)
+    // }
+    bool FindAndReportLeaks();
 
-// LeakCheckDisabler
-//
-// This helper class indicates that any heap allocations done in the code block
-// covered by the scoped object, which should be allocated on the stack, will
-// not be reported as leaks. Leak check disabling will occur within the code
-// block and any nested function calls within the code block.
-//
-// Example:
-//
-//   void Foo() {
-//     LeakCheckDisabler disabler;
-//     ... code that allocates objects whose leaks should be ignored ...
-//   }
-//
-// REQUIRES: Destructor runs in same thread as constructor
-class LeakCheckDisabler {
- public:
-  LeakCheckDisabler();
-  LeakCheckDisabler(const LeakCheckDisabler&) = delete;
-  LeakCheckDisabler& operator=(const LeakCheckDisabler&) = delete;
-  ~LeakCheckDisabler();
-};
+    // LeakCheckDisabler
+    //
+    // This helper class indicates that any heap allocations done in the code block
+    // covered by the scoped object, which should be allocated on the stack, will
+    // not be reported as leaks. Leak check disabling will occur within the code
+    // block and any nested function calls within the code block.
+    //
+    // Example:
+    //
+    //   void Foo() {
+    //     LeakCheckDisabler disabler;
+    //     ... code that allocates objects whose leaks should be ignored ...
+    //   }
+    //
+    // REQUIRES: Destructor runs in same thread as constructor
+    class LeakCheckDisabler
+    {
+    public:
+        LeakCheckDisabler();
+        LeakCheckDisabler(const LeakCheckDisabler&) = delete;
+        LeakCheckDisabler& operator=(const LeakCheckDisabler&) = delete;
+        ~LeakCheckDisabler();
+    };
 
-// RegisterLivePointers()
-//
-// Registers `ptr[0,size-1]` as pointers to memory that is still actively being
-// referenced and for which leak checking should be ignored. This function is
-// useful if you store pointers in mapped memory, for memory ranges that we know
-// are correct but for which normal analysis would flag as leaked code.
-void RegisterLivePointers(const void* ptr, size_t size);
+    // RegisterLivePointers()
+    //
+    // Registers `ptr[0,size-1]` as pointers to memory that is still actively being
+    // referenced and for which leak checking should be ignored. This function is
+    // useful if you store pointers in mapped memory, for memory ranges that we know
+    // are correct but for which normal analysis would flag as leaked code.
+    void RegisterLivePointers(const void* ptr, size_t size);
 
-// UnRegisterLivePointers()
-//
-// Deregisters the pointers previously marked as active in
-// `RegisterLivePointers()`, enabling leak checking of those pointers.
-void UnRegisterLivePointers(const void* ptr, size_t size);
+    // UnRegisterLivePointers()
+    //
+    // Deregisters the pointers previously marked as active in
+    // `RegisterLivePointers()`, enabling leak checking of those pointers.
+    void UnRegisterLivePointers(const void* ptr, size_t size);
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_DEBUGGING_LEAK_CHECK_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/stacktrace.h b/CAPI/cpp/grpc/include/absl/debugging/stacktrace.h
index 0ec0ffd..28c7598 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/stacktrace.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/stacktrace.h
@@ -33,199 +33,191 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// GetStackFrames()
-//
-// Records program counter values for up to `max_depth` frames, skipping the
-// most recent `skip_count` stack frames, stores their corresponding values
-// and sizes in `results` and `sizes` buffers, and returns the number of frames
-// stored. (Note that the frame generated for the `absl::GetStackFrames()`
-// routine itself is also skipped.)
-//
-// Example:
-//
-//      main() { foo(); }
-//      foo() { bar(); }
-//      bar() {
-//        void* result[10];
-//        int sizes[10];
-//        int depth = absl::GetStackFrames(result, sizes, 10, 1);
-//      }
-//
-// The current stack frame would consist of three function calls: `bar()`,
-// `foo()`, and then `main()`; however, since the `GetStackFrames()` call sets
-// `skip_count` to `1`, it will skip the frame for `bar()`, the most recently
-// invoked function call. It will therefore return 2 and fill `result` with
-// program counters within the following functions:
-//
-//      result[0]       foo()
-//      result[1]       main()
-//
-// (Note: in practice, a few more entries after `main()` may be added to account
-// for startup processes.)
-//
-// Corresponding stack frame sizes will also be recorded:
-//
-//    sizes[0]       16
-//    sizes[1]       16
-//
-// (Stack frame sizes of `16` above are just for illustration purposes.)
-//
-// Stack frame sizes of 0 or less indicate that those frame sizes couldn't
-// be identified.
-//
-// This routine may return fewer stack frame entries than are
-// available. Also note that `result` and `sizes` must both be non-null.
-extern int GetStackFrames(void** result, int* sizes, int max_depth,
-                          int skip_count);
+    // GetStackFrames()
+    //
+    // Records program counter values for up to `max_depth` frames, skipping the
+    // most recent `skip_count` stack frames, stores their corresponding values
+    // and sizes in `results` and `sizes` buffers, and returns the number of frames
+    // stored. (Note that the frame generated for the `absl::GetStackFrames()`
+    // routine itself is also skipped.)
+    //
+    // Example:
+    //
+    //      main() { foo(); }
+    //      foo() { bar(); }
+    //      bar() {
+    //        void* result[10];
+    //        int sizes[10];
+    //        int depth = absl::GetStackFrames(result, sizes, 10, 1);
+    //      }
+    //
+    // The current stack frame would consist of three function calls: `bar()`,
+    // `foo()`, and then `main()`; however, since the `GetStackFrames()` call sets
+    // `skip_count` to `1`, it will skip the frame for `bar()`, the most recently
+    // invoked function call. It will therefore return 2 and fill `result` with
+    // program counters within the following functions:
+    //
+    //      result[0]       foo()
+    //      result[1]       main()
+    //
+    // (Note: in practice, a few more entries after `main()` may be added to account
+    // for startup processes.)
+    //
+    // Corresponding stack frame sizes will also be recorded:
+    //
+    //    sizes[0]       16
+    //    sizes[1]       16
+    //
+    // (Stack frame sizes of `16` above are just for illustration purposes.)
+    //
+    // Stack frame sizes of 0 or less indicate that those frame sizes couldn't
+    // be identified.
+    //
+    // This routine may return fewer stack frame entries than are
+    // available. Also note that `result` and `sizes` must both be non-null.
+    extern int GetStackFrames(void** result, int* sizes, int max_depth, int skip_count);
 
-// GetStackFramesWithContext()
-//
-// Records program counter values obtained from a signal handler. Records
-// program counter values for up to `max_depth` frames, skipping the most recent
-// `skip_count` stack frames, stores their corresponding values and sizes in
-// `results` and `sizes` buffers, and returns the number of frames stored. (Note
-// that the frame generated for the `absl::GetStackFramesWithContext()` routine
-// itself is also skipped.)
-//
-// The `uc` parameter, if non-null, should be a pointer to a `ucontext_t` value
-// passed to a signal handler registered via the `sa_sigaction` field of a
-// `sigaction` struct. (See
-// http://man7.org/linux/man-pages/man2/sigaction.2.html.) The `uc` value may
-// help a stack unwinder to provide a better stack trace under certain
-// conditions. `uc` may safely be null.
-//
-// The `min_dropped_frames` output parameter, if non-null, points to the
-// location to note any dropped stack frames, if any, due to buffer limitations
-// or other reasons. (This value will be set to `0` if no frames were dropped.)
-// The number of total stack frames is guaranteed to be >= skip_count +
-// max_depth + *min_dropped_frames.
-extern int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
-                                     int skip_count, const void* uc,
-                                     int* min_dropped_frames);
+    // GetStackFramesWithContext()
+    //
+    // Records program counter values obtained from a signal handler. Records
+    // program counter values for up to `max_depth` frames, skipping the most recent
+    // `skip_count` stack frames, stores their corresponding values and sizes in
+    // `results` and `sizes` buffers, and returns the number of frames stored. (Note
+    // that the frame generated for the `absl::GetStackFramesWithContext()` routine
+    // itself is also skipped.)
+    //
+    // The `uc` parameter, if non-null, should be a pointer to a `ucontext_t` value
+    // passed to a signal handler registered via the `sa_sigaction` field of a
+    // `sigaction` struct. (See
+    // http://man7.org/linux/man-pages/man2/sigaction.2.html.) The `uc` value may
+    // help a stack unwinder to provide a better stack trace under certain
+    // conditions. `uc` may safely be null.
+    //
+    // The `min_dropped_frames` output parameter, if non-null, points to the
+    // location to note any dropped stack frames, if any, due to buffer limitations
+    // or other reasons. (This value will be set to `0` if no frames were dropped.)
+    // The number of total stack frames is guaranteed to be >= skip_count +
+    // max_depth + *min_dropped_frames.
+    extern int GetStackFramesWithContext(void** result, int* sizes, int max_depth, int skip_count, const void* uc, int* min_dropped_frames);
 
-// GetStackTrace()
-//
-// Records program counter values for up to `max_depth` frames, skipping the
-// most recent `skip_count` stack frames, stores their corresponding values
-// in `results`, and returns the number of frames
-// stored. Note that this function is similar to `absl::GetStackFrames()`
-// except that it returns the stack trace only, and not stack frame sizes.
-//
-// Example:
-//
-//      main() { foo(); }
-//      foo() { bar(); }
-//      bar() {
-//        void* result[10];
-//        int depth = absl::GetStackTrace(result, 10, 1);
-//      }
-//
-// This produces:
-//
-//      result[0]       foo
-//      result[1]       main
-//           ....       ...
-//
-// `result` must not be null.
-extern int GetStackTrace(void** result, int max_depth, int skip_count);
+    // GetStackTrace()
+    //
+    // Records program counter values for up to `max_depth` frames, skipping the
+    // most recent `skip_count` stack frames, stores their corresponding values
+    // in `results`, and returns the number of frames
+    // stored. Note that this function is similar to `absl::GetStackFrames()`
+    // except that it returns the stack trace only, and not stack frame sizes.
+    //
+    // Example:
+    //
+    //      main() { foo(); }
+    //      foo() { bar(); }
+    //      bar() {
+    //        void* result[10];
+    //        int depth = absl::GetStackTrace(result, 10, 1);
+    //      }
+    //
+    // This produces:
+    //
+    //      result[0]       foo
+    //      result[1]       main
+    //           ....       ...
+    //
+    // `result` must not be null.
+    extern int GetStackTrace(void** result, int max_depth, int skip_count);
 
-// GetStackTraceWithContext()
-//
-// Records program counter values obtained from a signal handler. Records
-// program counter values for up to `max_depth` frames, skipping the most recent
-// `skip_count` stack frames, stores their corresponding values in `results`,
-// and returns the number of frames stored. (Note that the frame generated for
-// the `absl::GetStackFramesWithContext()` routine itself is also skipped.)
-//
-// The `uc` parameter, if non-null, should be a pointer to a `ucontext_t` value
-// passed to a signal handler registered via the `sa_sigaction` field of a
-// `sigaction` struct. (See
-// http://man7.org/linux/man-pages/man2/sigaction.2.html.) The `uc` value may
-// help a stack unwinder to provide a better stack trace under certain
-// conditions. `uc` may safely be null.
-//
-// The `min_dropped_frames` output parameter, if non-null, points to the
-// location to note any dropped stack frames, if any, due to buffer limitations
-// or other reasons. (This value will be set to `0` if no frames were dropped.)
-// The number of total stack frames is guaranteed to be >= skip_count +
-// max_depth + *min_dropped_frames.
-extern int GetStackTraceWithContext(void** result, int max_depth,
-                                    int skip_count, const void* uc,
-                                    int* min_dropped_frames);
+    // GetStackTraceWithContext()
+    //
+    // Records program counter values obtained from a signal handler. Records
+    // program counter values for up to `max_depth` frames, skipping the most recent
+    // `skip_count` stack frames, stores their corresponding values in `results`,
+    // and returns the number of frames stored. (Note that the frame generated for
+    // the `absl::GetStackFramesWithContext()` routine itself is also skipped.)
+    //
+    // The `uc` parameter, if non-null, should be a pointer to a `ucontext_t` value
+    // passed to a signal handler registered via the `sa_sigaction` field of a
+    // `sigaction` struct. (See
+    // http://man7.org/linux/man-pages/man2/sigaction.2.html.) The `uc` value may
+    // help a stack unwinder to provide a better stack trace under certain
+    // conditions. `uc` may safely be null.
+    //
+    // The `min_dropped_frames` output parameter, if non-null, points to the
+    // location to note any dropped stack frames, if any, due to buffer limitations
+    // or other reasons. (This value will be set to `0` if no frames were dropped.)
+    // The number of total stack frames is guaranteed to be >= skip_count +
+    // max_depth + *min_dropped_frames.
+    extern int GetStackTraceWithContext(void** result, int max_depth, int skip_count, const void* uc, int* min_dropped_frames);
 
-// SetStackUnwinder()
-//
-// Provides a custom function for unwinding stack frames that will be used in
-// place of the default stack unwinder when invoking the static
-// GetStack{Frames,Trace}{,WithContext}() functions above.
-//
-// The arguments passed to the unwinder function will match the
-// arguments passed to `absl::GetStackFramesWithContext()` except that sizes
-// will be non-null iff the caller is interested in frame sizes.
-//
-// If unwinder is set to null, we revert to the default stack-tracing behavior.
-//
-// *****************************************************************************
-// WARNING
-// *****************************************************************************
-//
-// absl::SetStackUnwinder is not suitable for general purpose use.  It is
-// provided for custom runtimes.
-// Some things to watch out for when calling `absl::SetStackUnwinder()`:
-//
-// (a) The unwinder may be called from within signal handlers and
-// therefore must be async-signal-safe.
-//
-// (b) Even after a custom stack unwinder has been unregistered, other
-// threads may still be in the process of using that unwinder.
-// Therefore do not clean up any state that may be needed by an old
-// unwinder.
-// *****************************************************************************
-extern void SetStackUnwinder(int (*unwinder)(void** pcs, int* sizes,
-                                             int max_depth, int skip_count,
-                                             const void* uc,
-                                             int* min_dropped_frames));
+    // SetStackUnwinder()
+    //
+    // Provides a custom function for unwinding stack frames that will be used in
+    // place of the default stack unwinder when invoking the static
+    // GetStack{Frames,Trace}{,WithContext}() functions above.
+    //
+    // The arguments passed to the unwinder function will match the
+    // arguments passed to `absl::GetStackFramesWithContext()` except that sizes
+    // will be non-null iff the caller is interested in frame sizes.
+    //
+    // If unwinder is set to null, we revert to the default stack-tracing behavior.
+    //
+    // *****************************************************************************
+    // WARNING
+    // *****************************************************************************
+    //
+    // absl::SetStackUnwinder is not suitable for general purpose use.  It is
+    // provided for custom runtimes.
+    // Some things to watch out for when calling `absl::SetStackUnwinder()`:
+    //
+    // (a) The unwinder may be called from within signal handlers and
+    // therefore must be async-signal-safe.
+    //
+    // (b) Even after a custom stack unwinder has been unregistered, other
+    // threads may still be in the process of using that unwinder.
+    // Therefore do not clean up any state that may be needed by an old
+    // unwinder.
+    // *****************************************************************************
+    extern void SetStackUnwinder(int (*unwinder)(void** pcs, int* sizes, int max_depth, int skip_count, const void* uc, int* min_dropped_frames));
 
-// DefaultStackUnwinder()
-//
-// Records program counter values of up to `max_depth` frames, skipping the most
-// recent `skip_count` stack frames, and stores their corresponding values in
-// `pcs`. (Note that the frame generated for this call itself is also skipped.)
-// This function acts as a generic stack-unwinder; prefer usage of the more
-// specific `GetStack{Trace,Frames}{,WithContext}()` functions above.
-//
-// If you have set your own stack unwinder (with the `SetStackUnwinder()`
-// function above, you can still get the default stack unwinder by calling
-// `DefaultStackUnwinder()`, which will ignore any previously set stack unwinder
-// and use the default one instead.
-//
-// Because this function is generic, only `pcs` is guaranteed to be non-null
-// upon return. It is legal for `sizes`, `uc`, and `min_dropped_frames` to all
-// be null when called.
-//
-// The semantics are the same as the corresponding `GetStack*()` function in the
-// case where `absl::SetStackUnwinder()` was never called. Equivalents are:
-//
-//                       null sizes         |        non-nullptr sizes
-//             |==========================================================|
-//     null uc | GetStackTrace()            | GetStackFrames()            |
-// non-null uc | GetStackTraceWithContext() | GetStackFramesWithContext() |
-//             |==========================================================|
-extern int DefaultStackUnwinder(void** pcs, int* sizes, int max_depth,
-                                int skip_count, const void* uc,
-                                int* min_dropped_frames);
+    // DefaultStackUnwinder()
+    //
+    // Records program counter values of up to `max_depth` frames, skipping the most
+    // recent `skip_count` stack frames, and stores their corresponding values in
+    // `pcs`. (Note that the frame generated for this call itself is also skipped.)
+    // This function acts as a generic stack-unwinder; prefer usage of the more
+    // specific `GetStack{Trace,Frames}{,WithContext}()` functions above.
+    //
+    // If you have set your own stack unwinder (with the `SetStackUnwinder()`
+    // function above, you can still get the default stack unwinder by calling
+    // `DefaultStackUnwinder()`, which will ignore any previously set stack unwinder
+    // and use the default one instead.
+    //
+    // Because this function is generic, only `pcs` is guaranteed to be non-null
+    // upon return. It is legal for `sizes`, `uc`, and `min_dropped_frames` to all
+    // be null when called.
+    //
+    // The semantics are the same as the corresponding `GetStack*()` function in the
+    // case where `absl::SetStackUnwinder()` was never called. Equivalents are:
+    //
+    //                       null sizes         |        non-nullptr sizes
+    //             |==========================================================|
+    //     null uc | GetStackTrace()            | GetStackFrames()            |
+    // non-null uc | GetStackTraceWithContext() | GetStackFramesWithContext() |
+    //             |==========================================================|
+    extern int DefaultStackUnwinder(void** pcs, int* sizes, int max_depth, int skip_count, const void* uc, int* min_dropped_frames);
 
-namespace debugging_internal {
-// Returns true for platforms which are expected to have functioning stack trace
-// implementations. Intended to be used for tests which want to exclude
-// verification of logic known to be broken because stack traces are not
-// working.
-extern bool StackTraceWorksForTest();
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
+    namespace debugging_internal
+    {
+        // Returns true for platforms which are expected to have functioning stack trace
+        // implementations. Intended to be used for tests which want to exclude
+        // verification of logic known to be broken because stack traces are not
+        // working.
+        extern bool StackTraceWorksForTest();
+    }  // namespace debugging_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_DEBUGGING_STACKTRACE_H_
diff --git a/CAPI/cpp/grpc/include/absl/debugging/symbolize.h b/CAPI/cpp/grpc/include/absl/debugging/symbolize.h
index 43d93a8..db68479 100644
--- a/CAPI/cpp/grpc/include/absl/debugging/symbolize.h
+++ b/CAPI/cpp/grpc/include/absl/debugging/symbolize.h
@@ -54,46 +54,47 @@
 
 #include "absl/debugging/internal/symbolize.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// InitializeSymbolizer()
-//
-// Initializes the program counter symbolizer, given the path of the program
-// (typically obtained through `main()`s `argv[0]`). The Abseil symbolizer
-// allows you to read program counters (instruction pointer values) using their
-// human-readable names within output such as stack traces.
-//
-// Example:
-//
-// int main(int argc, char *argv[]) {
-//   absl::InitializeSymbolizer(argv[0]);
-//   // Now you can use the symbolizer
-// }
-void InitializeSymbolizer(const char* argv0);
-//
-// Symbolize()
-//
-// Symbolizes a program counter (instruction pointer value) `pc` and, on
-// success, writes the name to `out`. The symbol name is demangled, if possible.
-// Note that the symbolized name may be truncated and will be NUL-terminated.
-// Demangling is supported for symbols generated by GCC 3.x or newer). Returns
-// `false` on failure.
-//
-// Example:
-//
-//   // Print a program counter and its symbol name.
-//   static void DumpPCAndSymbol(void *pc) {
-//     char tmp[1024];
-//     const char *symbol = "(unknown)";
-//     if (absl::Symbolize(pc, tmp, sizeof(tmp))) {
-//       symbol = tmp;
-//     }
-//     absl::PrintF("%p  %s\n", pc, symbol);
-//  }
-bool Symbolize(const void *pc, char *out, int out_size);
+    // InitializeSymbolizer()
+    //
+    // Initializes the program counter symbolizer, given the path of the program
+    // (typically obtained through `main()`s `argv[0]`). The Abseil symbolizer
+    // allows you to read program counters (instruction pointer values) using their
+    // human-readable names within output such as stack traces.
+    //
+    // Example:
+    //
+    // int main(int argc, char *argv[]) {
+    //   absl::InitializeSymbolizer(argv[0]);
+    //   // Now you can use the symbolizer
+    // }
+    void InitializeSymbolizer(const char* argv0);
+    //
+    // Symbolize()
+    //
+    // Symbolizes a program counter (instruction pointer value) `pc` and, on
+    // success, writes the name to `out`. The symbol name is demangled, if possible.
+    // Note that the symbolized name may be truncated and will be NUL-terminated.
+    // Demangling is supported for symbols generated by GCC 3.x or newer). Returns
+    // `false` on failure.
+    //
+    // Example:
+    //
+    //   // Print a program counter and its symbol name.
+    //   static void DumpPCAndSymbol(void *pc) {
+    //     char tmp[1024];
+    //     const char *symbol = "(unknown)";
+    //     if (absl::Symbolize(pc, tmp, sizeof(tmp))) {
+    //       symbol = tmp;
+    //     }
+    //     absl::PrintF("%p  %s\n", pc, symbol);
+    //  }
+    bool Symbolize(const void* pc, char* out, int out_size);
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_DEBUGGING_SYMBOLIZE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/commandlineflag.h b/CAPI/cpp/grpc/include/absl/flags/commandlineflag.h
index f2fa089..7208510 100644
--- a/CAPI/cpp/grpc/include/absl/flags/commandlineflag.h
+++ b/CAPI/cpp/grpc/include/absl/flags/commandlineflag.h
@@ -35,166 +35,176 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-class PrivateHandleAccessor;
-}  // namespace flags_internal
-
-// CommandLineFlag
-//
-// This type acts as a type-erased handle for an instance of an Abseil Flag and
-// holds reflection information pertaining to that flag. Use CommandLineFlag to
-// access a flag's name, location, help string etc.
-//
-// To obtain an absl::CommandLineFlag, invoke `absl::FindCommandLineFlag()`
-// passing it the flag name string.
-//
-// Example:
-//
-//   // Obtain reflection handle for a flag named "flagname".
-//   const absl::CommandLineFlag* my_flag_data =
-//        absl::FindCommandLineFlag("flagname");
-//
-//   // Now you can get flag info from that reflection handle.
-//   std::string flag_location = my_flag_data->Filename();
-//   ...
-class CommandLineFlag {
- public:
-  constexpr CommandLineFlag() = default;
-
-  // Not copyable/assignable.
-  CommandLineFlag(const CommandLineFlag&) = delete;
-  CommandLineFlag& operator=(const CommandLineFlag&) = delete;
-
-  // absl::CommandLineFlag::IsOfType()
-  //
-  // Return true iff flag has type T.
-  template <typename T>
-  inline bool IsOfType() const {
-    return TypeId() == base_internal::FastTypeId<T>();
-  }
-
-  // absl::CommandLineFlag::TryGet()
-  //
-  // Attempts to retrieve the flag value. Returns value on success,
-  // absl::nullopt otherwise.
-  template <typename T>
-  absl::optional<T> TryGet() const {
-    if (IsRetired() || !IsOfType<T>()) {
-      return absl::nullopt;
-    }
-
-    // Implementation notes:
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+        class PrivateHandleAccessor;
+    }  // namespace flags_internal
+
+    // CommandLineFlag
+    //
+    // This type acts as a type-erased handle for an instance of an Abseil Flag and
+    // holds reflection information pertaining to that flag. Use CommandLineFlag to
+    // access a flag's name, location, help string etc.
     //
-    // We are wrapping a union around the value of `T` to serve three purposes:
+    // To obtain an absl::CommandLineFlag, invoke `absl::FindCommandLineFlag()`
+    // passing it the flag name string.
     //
-    //  1. `U.value` has correct size and alignment for a value of type `T`
-    //  2. The `U.value` constructor is not invoked since U's constructor does
-    //     not do it explicitly.
-    //  3. The `U.value` destructor is invoked since U's destructor does it
-    //     explicitly. This makes `U` a kind of RAII wrapper around non default
-    //     constructible value of T, which is destructed when we leave the
-    //     scope. We do need to destroy U.value, which is constructed by
-    //     CommandLineFlag::Read even though we left it in a moved-from state
-    //     after std::move.
+    // Example:
     //
-    // All of this serves to avoid requiring `T` being default constructible.
-    union U {
-      T value;
-      U() {}
-      ~U() { value.~T(); }
+    //   // Obtain reflection handle for a flag named "flagname".
+    //   const absl::CommandLineFlag* my_flag_data =
+    //        absl::FindCommandLineFlag("flagname");
+    //
+    //   // Now you can get flag info from that reflection handle.
+    //   std::string flag_location = my_flag_data->Filename();
+    //   ...
+    class CommandLineFlag
+    {
+    public:
+        constexpr CommandLineFlag() = default;
+
+        // Not copyable/assignable.
+        CommandLineFlag(const CommandLineFlag&) = delete;
+        CommandLineFlag& operator=(const CommandLineFlag&) = delete;
+
+        // absl::CommandLineFlag::IsOfType()
+        //
+        // Return true iff flag has type T.
+        template<typename T>
+        inline bool IsOfType() const
+        {
+            return TypeId() == base_internal::FastTypeId<T>();
+        }
+
+        // absl::CommandLineFlag::TryGet()
+        //
+        // Attempts to retrieve the flag value. Returns value on success,
+        // absl::nullopt otherwise.
+        template<typename T>
+        absl::optional<T> TryGet() const
+        {
+            if (IsRetired() || !IsOfType<T>())
+            {
+                return absl::nullopt;
+            }
+
+            // Implementation notes:
+            //
+            // We are wrapping a union around the value of `T` to serve three purposes:
+            //
+            //  1. `U.value` has correct size and alignment for a value of type `T`
+            //  2. The `U.value` constructor is not invoked since U's constructor does
+            //     not do it explicitly.
+            //  3. The `U.value` destructor is invoked since U's destructor does it
+            //     explicitly. This makes `U` a kind of RAII wrapper around non default
+            //     constructible value of T, which is destructed when we leave the
+            //     scope. We do need to destroy U.value, which is constructed by
+            //     CommandLineFlag::Read even though we left it in a moved-from state
+            //     after std::move.
+            //
+            // All of this serves to avoid requiring `T` being default constructible.
+            union U
+            {
+                T value;
+                U()
+                {
+                }
+                ~U()
+                {
+                    value.~T();
+                }
+            };
+            U u;
+
+            Read(&u.value);
+            // allow retired flags to be "read", so we can report invalid access.
+            if (IsRetired())
+            {
+                return absl::nullopt;
+            }
+            return std::move(u.value);
+        }
+
+        // absl::CommandLineFlag::Name()
+        //
+        // Returns name of this flag.
+        virtual absl::string_view Name() const = 0;
+
+        // absl::CommandLineFlag::Filename()
+        //
+        // Returns name of the file where this flag is defined.
+        virtual std::string Filename() const = 0;
+
+        // absl::CommandLineFlag::Help()
+        //
+        // Returns help message associated with this flag.
+        virtual std::string Help() const = 0;
+
+        // absl::CommandLineFlag::IsRetired()
+        //
+        // Returns true iff this object corresponds to retired flag.
+        virtual bool IsRetired() const;
+
+        // absl::CommandLineFlag::DefaultValue()
+        //
+        // Returns the default value for this flag.
+        virtual std::string DefaultValue() const = 0;
+
+        // absl::CommandLineFlag::CurrentValue()
+        //
+        // Returns the current value for this flag.
+        virtual std::string CurrentValue() const = 0;
+
+        // absl::CommandLineFlag::ParseFrom()
+        //
+        // Sets the value of the flag based on specified string `value`. If the flag
+        // was successfully set to new value, it returns true. Otherwise, sets `error`
+        // to indicate the error, leaves the flag unchanged, and returns false.
+        bool ParseFrom(absl::string_view value, std::string* error);
+
+    protected:
+        ~CommandLineFlag() = default;
+
+    private:
+        friend class flags_internal::PrivateHandleAccessor;
+
+        // Sets the value of the flag based on specified string `value`. If the flag
+        // was successfully set to new value, it returns true. Otherwise, sets `error`
+        // to indicate the error, leaves the flag unchanged, and returns false. There
+        // are three ways to set the flag's value:
+        //  * Update the current flag value
+        //  * Update the flag's default value
+        //  * Update the current flag value if it was never set before
+        // The mode is selected based on `set_mode` parameter.
+        virtual bool ParseFrom(absl::string_view value, flags_internal::FlagSettingMode set_mode, flags_internal::ValueSource source, std::string& error) = 0;
+
+        // Returns id of the flag's value type.
+        virtual flags_internal::FlagFastTypeId TypeId() const = 0;
+
+        // Interface to save flag to some persistent state. Returns current flag state
+        // or nullptr if flag does not support saving and restoring a state.
+        virtual std::unique_ptr<flags_internal::FlagStateInterface> SaveState() = 0;
+
+        // Copy-construct a new value of the flag's type in a memory referenced by
+        // the dst based on the current flag's value.
+        virtual void Read(void* dst) const = 0;
+
+        // To be deleted. Used to return true if flag's current value originated from
+        // command line.
+        virtual bool IsSpecifiedOnCommandLine() const = 0;
+
+        // Validates supplied value usign validator or parseflag routine
+        virtual bool ValidateInputValue(absl::string_view value) const = 0;
+
+        // Checks that flags default value can be converted to string and back to the
+        // flag's value type.
+        virtual void CheckDefaultValueParsingRoundtrip() const = 0;
     };
-    U u;
-
-    Read(&u.value);
-    // allow retired flags to be "read", so we can report invalid access.
-    if (IsRetired()) {
-      return absl::nullopt;
-    }
-    return std::move(u.value);
-  }
-
-  // absl::CommandLineFlag::Name()
-  //
-  // Returns name of this flag.
-  virtual absl::string_view Name() const = 0;
-
-  // absl::CommandLineFlag::Filename()
-  //
-  // Returns name of the file where this flag is defined.
-  virtual std::string Filename() const = 0;
-
-  // absl::CommandLineFlag::Help()
-  //
-  // Returns help message associated with this flag.
-  virtual std::string Help() const = 0;
-
-  // absl::CommandLineFlag::IsRetired()
-  //
-  // Returns true iff this object corresponds to retired flag.
-  virtual bool IsRetired() const;
-
-  // absl::CommandLineFlag::DefaultValue()
-  //
-  // Returns the default value for this flag.
-  virtual std::string DefaultValue() const = 0;
-
-  // absl::CommandLineFlag::CurrentValue()
-  //
-  // Returns the current value for this flag.
-  virtual std::string CurrentValue() const = 0;
-
-  // absl::CommandLineFlag::ParseFrom()
-  //
-  // Sets the value of the flag based on specified string `value`. If the flag
-  // was successfully set to new value, it returns true. Otherwise, sets `error`
-  // to indicate the error, leaves the flag unchanged, and returns false.
-  bool ParseFrom(absl::string_view value, std::string* error);
-
- protected:
-  ~CommandLineFlag() = default;
-
- private:
-  friend class flags_internal::PrivateHandleAccessor;
-
-  // Sets the value of the flag based on specified string `value`. If the flag
-  // was successfully set to new value, it returns true. Otherwise, sets `error`
-  // to indicate the error, leaves the flag unchanged, and returns false. There
-  // are three ways to set the flag's value:
-  //  * Update the current flag value
-  //  * Update the flag's default value
-  //  * Update the current flag value if it was never set before
-  // The mode is selected based on `set_mode` parameter.
-  virtual bool ParseFrom(absl::string_view value,
-                         flags_internal::FlagSettingMode set_mode,
-                         flags_internal::ValueSource source,
-                         std::string& error) = 0;
-
-  // Returns id of the flag's value type.
-  virtual flags_internal::FlagFastTypeId TypeId() const = 0;
-
-  // Interface to save flag to some persistent state. Returns current flag state
-  // or nullptr if flag does not support saving and restoring a state.
-  virtual std::unique_ptr<flags_internal::FlagStateInterface> SaveState() = 0;
-
-  // Copy-construct a new value of the flag's type in a memory referenced by
-  // the dst based on the current flag's value.
-  virtual void Read(void* dst) const = 0;
-
-  // To be deleted. Used to return true if flag's current value originated from
-  // command line.
-  virtual bool IsSpecifiedOnCommandLine() const = 0;
-
-  // Validates supplied value usign validator or parseflag routine
-  virtual bool ValidateInputValue(absl::string_view value) const = 0;
-
-  // Checks that flags default value can be converted to string and back to the
-  // flag's value type.
-  virtual void CheckDefaultValueParsingRoundtrip() const = 0;
-};
-
-ABSL_NAMESPACE_END
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_COMMANDLINEFLAG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/config.h b/CAPI/cpp/grpc/include/absl/flags/config.h
index 14c4235..9565e48 100644
--- a/CAPI/cpp/grpc/include/absl/flags/config.h
+++ b/CAPI/cpp/grpc/include/absl/flags/config.h
@@ -47,22 +47,22 @@
 
 // These macros represent the "source of truth" for the list of supported
 // built-in types.
-#define ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A) \
-  A(bool, bool)                              \
-  A(short, short)                            \
-  A(unsigned short, unsigned_short)          \
-  A(int, int)                                \
-  A(unsigned int, unsigned_int)              \
-  A(long, long)                              \
-  A(unsigned long, unsigned_long)            \
-  A(long long, long_long)                    \
-  A(unsigned long long, unsigned_long_long)  \
-  A(double, double)                          \
-  A(float, float)
+#define ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A)  \
+    A(bool, bool)                             \
+    A(short, short)                           \
+    A(unsigned short, unsigned_short)         \
+    A(int, int)                               \
+    A(unsigned int, unsigned_int)             \
+    A(long, long)                             \
+    A(unsigned long, unsigned_long)           \
+    A(long long, long_long)                   \
+    A(unsigned long long, unsigned_long_long) \
+    A(double, double)                         \
+    A(float, float)
 
 #define ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(A) \
-  ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A)         \
-  A(std::string, std_string)                   \
-  A(std::vector<std::string>, std_vector_of_string)
+    ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(A)       \
+    A(std::string, std_string)                 \
+    A(std::vector<std::string>, std_vector_of_string)
 
 #endif  // ABSL_FLAGS_CONFIG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/declare.h b/CAPI/cpp/grpc/include/absl/flags/declare.h
index d1437bb..d9d50fa 100644
--- a/CAPI/cpp/grpc/include/absl/flags/declare.h
+++ b/CAPI/cpp/grpc/include/absl/flags/declare.h
@@ -27,28 +27,30 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
 
-// absl::Flag<T> represents a flag of type 'T' created by ABSL_FLAG.
-template <typename T>
-class Flag;
+        // absl::Flag<T> represents a flag of type 'T' created by ABSL_FLAG.
+        template<typename T>
+        class Flag;
 
-}  // namespace flags_internal
+    }  // namespace flags_internal
 
 // Flag
 //
 // Forward declaration of the `absl::Flag` type for use in defining the macro.
 #if defined(_MSC_VER) && !defined(__clang__)
-template <typename T>
-class Flag;
+    template<typename T>
+    class Flag;
 #else
-template <typename T>
-using Flag = flags_internal::Flag<T>;
+    template<typename T>
+    using Flag = flags_internal::Flag<T>;
 #endif
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // ABSL_DECLARE_FLAG()
@@ -64,10 +66,12 @@ ABSL_NAMESPACE_END
 
 // Internal implementation of ABSL_DECLARE_FLAG to allow macro expansion of its
 // arguments. Clients must use ABSL_DECLARE_FLAG instead.
-#define ABSL_DECLARE_FLAG_INTERNAL(type, name)               \
-  extern absl::Flag<type> FLAGS_##name;                      \
-  namespace absl /* block flags in namespaces */ {}          \
-  /* second redeclaration is to allow applying attributes */ \
-  extern absl::Flag<type> FLAGS_##name
+#define ABSL_DECLARE_FLAG_INTERNAL(type, name)                 \
+    extern absl::Flag<type> FLAGS_##name;                      \
+    namespace absl /* block flags in namespaces */             \
+    {                                                          \
+    }                                                          \
+    /* second redeclaration is to allow applying attributes */ \
+    extern absl::Flag<type> FLAGS_##name
 
 #endif  // ABSL_FLAGS_DECLARE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/flag.h b/CAPI/cpp/grpc/include/absl/flags/flag.h
index b7f94be..7ce03a4 100644
--- a/CAPI/cpp/grpc/include/absl/flags/flag.h
+++ b/CAPI/cpp/grpc/include/absl/flags/flag.h
@@ -40,8 +40,9 @@
 #include "absl/flags/internal/registry.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
 // Flag
 //
@@ -72,73 +73,76 @@ ABSL_NAMESPACE_BEGIN
 // discusses supported standard types, optional flags, and additional Abseil
 // type support.
 #if !defined(_MSC_VER) || defined(__clang__)
-template <typename T>
-using Flag = flags_internal::Flag<T>;
+    template<typename T>
+    using Flag = flags_internal::Flag<T>;
 #else
 #include "absl/flags/internal/flag_msvc.inc"
 #endif
 
-// GetFlag()
-//
-// Returns the value (of type `T`) of an `absl::Flag<T>` instance, by value. Do
-// not construct an `absl::Flag<T>` directly and call `absl::GetFlag()`;
-// instead, refer to flag's constructed variable name (e.g. `FLAGS_name`).
-// Because this function returns by value and not by reference, it is
-// thread-safe, but note that the operation may be expensive; as a result, avoid
-// `absl::GetFlag()` within any tight loops.
-//
-// Example:
-//
-//   // FLAGS_count is a Flag of type `int`
-//   int my_count = absl::GetFlag(FLAGS_count);
-//
-//   // FLAGS_firstname is a Flag of type `std::string`
-//   std::string first_name = absl::GetFlag(FLAGS_firstname);
-template <typename T>
-ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
-  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
-}
+    // GetFlag()
+    //
+    // Returns the value (of type `T`) of an `absl::Flag<T>` instance, by value. Do
+    // not construct an `absl::Flag<T>` directly and call `absl::GetFlag()`;
+    // instead, refer to flag's constructed variable name (e.g. `FLAGS_name`).
+    // Because this function returns by value and not by reference, it is
+    // thread-safe, but note that the operation may be expensive; as a result, avoid
+    // `absl::GetFlag()` within any tight loops.
+    //
+    // Example:
+    //
+    //   // FLAGS_count is a Flag of type `int`
+    //   int my_count = absl::GetFlag(FLAGS_count);
+    //
+    //   // FLAGS_firstname is a Flag of type `std::string`
+    //   std::string first_name = absl::GetFlag(FLAGS_firstname);
+    template<typename T>
+    ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag)
+    {
+        return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
+    }
 
-// SetFlag()
-//
-// Sets the value of an `absl::Flag` to the value `v`. Do not construct an
-// `absl::Flag<T>` directly and call `absl::SetFlag()`; instead, use the
-// flag's variable name (e.g. `FLAGS_name`). This function is
-// thread-safe, but is potentially expensive. Avoid setting flags in general,
-// but especially within performance-critical code.
-template <typename T>
-void SetFlag(absl::Flag<T>* flag, const T& v) {
-  flags_internal::FlagImplPeer::InvokeSet(*flag, v);
-}
+    // SetFlag()
+    //
+    // Sets the value of an `absl::Flag` to the value `v`. Do not construct an
+    // `absl::Flag<T>` directly and call `absl::SetFlag()`; instead, use the
+    // flag's variable name (e.g. `FLAGS_name`). This function is
+    // thread-safe, but is potentially expensive. Avoid setting flags in general,
+    // but especially within performance-critical code.
+    template<typename T>
+    void SetFlag(absl::Flag<T>* flag, const T& v)
+    {
+        flags_internal::FlagImplPeer::InvokeSet(*flag, v);
+    }
 
-// Overload of `SetFlag()` to allow callers to pass in a value that is
-// convertible to `T`. E.g., use this overload to pass a "const char*" when `T`
-// is `std::string`.
-template <typename T, typename V>
-void SetFlag(absl::Flag<T>* flag, const V& v) {
-  T value(v);
-  flags_internal::FlagImplPeer::InvokeSet(*flag, value);
-}
+    // Overload of `SetFlag()` to allow callers to pass in a value that is
+    // convertible to `T`. E.g., use this overload to pass a "const char*" when `T`
+    // is `std::string`.
+    template<typename T, typename V>
+    void SetFlag(absl::Flag<T>* flag, const V& v)
+    {
+        T value(v);
+        flags_internal::FlagImplPeer::InvokeSet(*flag, value);
+    }
 
-// GetFlagReflectionHandle()
-//
-// Returns the reflection handle corresponding to specified Abseil Flag
-// instance. Use this handle to access flag's reflection information, like name,
-// location, default value etc.
-//
-// Example:
-//
-//   std::string = absl::GetFlagReflectionHandle(FLAGS_count).DefaultValue();
+    // GetFlagReflectionHandle()
+    //
+    // Returns the reflection handle corresponding to specified Abseil Flag
+    // instance. Use this handle to access flag's reflection information, like name,
+    // location, default value etc.
+    //
+    // Example:
+    //
+    //   std::string = absl::GetFlagReflectionHandle(FLAGS_count).DefaultValue();
 
-template <typename T>
-const CommandLineFlag& GetFlagReflectionHandle(const absl::Flag<T>& f) {
-  return flags_internal::FlagImplPeer::InvokeReflect(f);
-}
+    template<typename T>
+    const CommandLineFlag& GetFlagReflectionHandle(const absl::Flag<T>& f)
+    {
+        return flags_internal::FlagImplPeer::InvokeReflect(f);
+    }
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
-
 // ABSL_FLAG()
 //
 // This macro defines an `absl::Flag<T>` instance of a specified type `T`:
@@ -167,7 +171,7 @@ ABSL_NAMESPACE_END
 // Note: do not construct objects of type `absl::Flag<T>` directly. Only use the
 // `ABSL_FLAG()` macro for such construction.
 #define ABSL_FLAG(Type, name, default_value, help) \
-  ABSL_FLAG_IMPL(Type, name, default_value, help)
+    ABSL_FLAG_IMPL(Type, name, default_value, help)
 
 // ABSL_FLAG().OnUpdate()
 //
@@ -198,11 +202,12 @@ ABSL_NAMESPACE_END
 // ABSL_FLAG_IMPL macro definition conditional on ABSL_FLAGS_STRIP_NAMES
 #if !defined(_MSC_VER) || defined(__clang__)
 #define ABSL_FLAG_IMPL_FLAG_PTR(flag) flag
-#define ABSL_FLAG_IMPL_HELP_ARG(name)                      \
-  absl::flags_internal::HelpArg<AbslFlagHelpGenFor##name>( \
-      FLAGS_help_storage_##name)
+#define ABSL_FLAG_IMPL_HELP_ARG(name)                        \
+    absl::flags_internal::HelpArg<AbslFlagHelpGenFor##name>( \
+        FLAGS_help_storage_##name                            \
+    )
 #define ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name) \
-  absl::flags_internal::DefaultArg<Type, AbslFlagDefaultGenFor##name>(0)
+    absl::flags_internal::DefaultArg<Type, AbslFlagDefaultGenFor##name>(0)
 #else
 #define ABSL_FLAG_IMPL_FLAG_PTR(flag) flag.GetImpl()
 #define ABSL_FLAG_IMPL_HELP_ARG(name) &AbslFlagHelpGenFor##name::NonConst
@@ -212,15 +217,13 @@ ABSL_NAMESPACE_END
 #if ABSL_FLAGS_STRIP_NAMES
 #define ABSL_FLAG_IMPL_FLAGNAME(txt) ""
 #define ABSL_FLAG_IMPL_FILENAME() ""
-#define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                      \
-  absl::flags_internal::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
-                                                nullptr)
+#define ABSL_FLAG_IMPL_REGISTRAR(T, flag) \
+    absl::flags_internal::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(flag), nullptr)
 #else
 #define ABSL_FLAG_IMPL_FLAGNAME(txt) txt
 #define ABSL_FLAG_IMPL_FILENAME() __FILE__
-#define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                     \
-  absl::flags_internal::FlagRegistrar<T, true>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
-                                               __FILE__)
+#define ABSL_FLAG_IMPL_REGISTRAR(T, flag) \
+    absl::flags_internal::FlagRegistrar<T, true>(ABSL_FLAG_IMPL_FLAG_PTR(flag), __FILE__)
 #endif
 
 // ABSL_FLAG_IMPL macro definition conditional on ABSL_FLAGS_STRIP_HELP
@@ -239,46 +242,56 @@ ABSL_NAMESPACE_END
 // TODO(rogeeff): place these generated structs into local namespace and apply
 // ABSL_INTERNAL_UNIQUE_SHORT_NAME.
 // TODO(rogeeff): Apply __attribute__((nodebug)) to FLAGS_help_storage_##name
-#define ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, txt)                       \
-  struct AbslFlagHelpGenFor##name {                                          \
-    /* The expression is run in the caller as part of the   */               \
-    /* default value argument. That keeps temporaries alive */               \
-    /* long enough for NonConst to work correctly.          */               \
-    static constexpr absl::string_view Value(                                \
-        absl::string_view absl_flag_help = ABSL_FLAG_IMPL_FLAGHELP(txt)) {   \
-      return absl_flag_help;                                                 \
-    }                                                                        \
-    static std::string NonConst() { return std::string(Value()); }           \
-  };                                                                         \
-  constexpr auto FLAGS_help_storage_##name ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
-      ABSL_ATTRIBUTE_SECTION_VARIABLE(flags_help_cold) =                     \
-          absl::flags_internal::HelpStringAsArray<AbslFlagHelpGenFor##name>( \
-              0);
+#define ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, txt)                         \
+    struct AbslFlagHelpGenFor##name                                            \
+    {                                                                          \
+        /* The expression is run in the caller as part of the   */             \
+        /* default value argument. That keeps temporaries alive */             \
+        /* long enough for NonConst to work correctly.          */             \
+        static constexpr absl::string_view Value(                              \
+            absl::string_view absl_flag_help = ABSL_FLAG_IMPL_FLAGHELP(txt)    \
+        )                                                                      \
+        {                                                                      \
+            return absl_flag_help;                                             \
+        }                                                                      \
+        static std::string NonConst()                                          \
+        {                                                                      \
+            return std::string(Value());                                       \
+        }                                                                      \
+    };                                                                         \
+    constexpr auto FLAGS_help_storage_##name ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
+        ABSL_ATTRIBUTE_SECTION_VARIABLE(flags_help_cold) =                     \
+            absl::flags_internal::HelpStringAsArray<AbslFlagHelpGenFor##name>( \
+                0                                                              \
+            );
 
-#define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)     \
-  struct AbslFlagDefaultGenFor##name {                                        \
-    Type value = absl::flags_internal::InitDefaultValue<Type>(default_value); \
-    static void Gen(void* absl_flag_default_loc) {                            \
-      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
-    }                                                                         \
-  };
+#define ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)          \
+    struct AbslFlagDefaultGenFor##name                                             \
+    {                                                                              \
+        Type value = absl::flags_internal::InitDefaultValue<Type>(default_value);  \
+        static void Gen(void* absl_flag_default_loc)                               \
+        {                                                                          \
+            new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \
+        }                                                                          \
+    };
 
 // ABSL_FLAG_IMPL
 //
 // Note: Name of registrar object is not arbitrary. It is used to "grab"
 // global name for FLAGS_no<flag_name> symbol, thus preventing the possibility
 // of defining two flags with names foo and nofoo.
-#define ABSL_FLAG_IMPL(Type, name, default_value, help)                       \
-  extern ::absl::Flag<Type> FLAGS_##name;                                     \
-  namespace absl /* block flags in namespaces */ {}                           \
-  ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)           \
-  ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help)                             \
-  ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{                              \
-      ABSL_FLAG_IMPL_FLAGNAME(#name), ABSL_FLAG_IMPL_FILENAME(),              \
-      ABSL_FLAG_IMPL_HELP_ARG(name), ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name)}; \
-  extern absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name;             \
-  absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name =                   \
-      ABSL_FLAG_IMPL_REGISTRAR(Type, FLAGS_##name)
+#define ABSL_FLAG_IMPL(Type, name, default_value, help)                                                                                    \
+    extern ::absl::Flag<Type> FLAGS_##name;                                                                                                \
+    namespace absl /* block flags in namespaces */                                                                                         \
+    {                                                                                                                                      \
+    }                                                                                                                                      \
+    ABSL_FLAG_IMPL_DECLARE_DEF_VAL_WRAPPER(name, Type, default_value)                                                                      \
+    ABSL_FLAG_IMPL_DECLARE_HELP_WRAPPER(name, help)                                                                                        \
+    ABSL_CONST_INIT absl::Flag<Type> FLAGS_##name{                                                                                         \
+        ABSL_FLAG_IMPL_FLAGNAME(#name), ABSL_FLAG_IMPL_FILENAME(), ABSL_FLAG_IMPL_HELP_ARG(name), ABSL_FLAG_IMPL_DEFAULT_ARG(Type, name)}; \
+    extern absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name;                                                                        \
+    absl::flags_internal::FlagRegistrarEmpty FLAGS_no##name =                                                                              \
+        ABSL_FLAG_IMPL_REGISTRAR(Type, FLAGS_##name)
 
 // ABSL_RETIRED_FLAG
 //
@@ -301,10 +314,10 @@ ABSL_NAMESPACE_END
 // unused.
 // TODO(rogeeff): replace RETIRED_FLAGS with FLAGS once forward declarations of
 // retired flags are cleaned up.
-#define ABSL_RETIRED_FLAG(type, name, default_value, explanation)      \
-  static absl::flags_internal::RetiredFlag<type> RETIRED_FLAGS_##name; \
-  ABSL_ATTRIBUTE_UNUSED static const auto RETIRED_FLAGS_REG_##name =   \
-      (RETIRED_FLAGS_##name.Retire(#name),                             \
-       ::absl::flags_internal::FlagRegistrarEmpty{})
+#define ABSL_RETIRED_FLAG(type, name, default_value, explanation)        \
+    static absl::flags_internal::RetiredFlag<type> RETIRED_FLAGS_##name; \
+    ABSL_ATTRIBUTE_UNUSED static const auto RETIRED_FLAGS_REG_##name =   \
+        (RETIRED_FLAGS_##name.Retire(#name),                             \
+         ::absl::flags_internal::FlagRegistrarEmpty{})
 
 #endif  // ABSL_FLAGS_FLAG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/commandlineflag.h b/CAPI/cpp/grpc/include/absl/flags/internal/commandlineflag.h
index ebfe81b..b05099e 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/commandlineflag.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/commandlineflag.h
@@ -19,50 +19,55 @@
 #include "absl/base/config.h"
 #include "absl/base/internal/fast_type_id.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
 
-// An alias for flag fast type id. This value identifies the flag value type
-// similarly to typeid(T), without relying on RTTI being available. In most
-// cases this id is enough to uniquely identify the flag's value type. In a few
-// cases we'll have to resort to using actual RTTI implementation if it is
-// available.
-using FlagFastTypeId = absl::base_internal::FastTypeIdType;
+        // An alias for flag fast type id. This value identifies the flag value type
+        // similarly to typeid(T), without relying on RTTI being available. In most
+        // cases this id is enough to uniquely identify the flag's value type. In a few
+        // cases we'll have to resort to using actual RTTI implementation if it is
+        // available.
+        using FlagFastTypeId = absl::base_internal::FastTypeIdType;
 
-// Options that control SetCommandLineOptionWithMode.
-enum FlagSettingMode {
-  // update the flag's value unconditionally (can call this multiple times).
-  SET_FLAGS_VALUE,
-  // update the flag's value, but *only if* it has not yet been updated
-  // with SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef".
-  SET_FLAG_IF_DEFAULT,
-  // set the flag's default value to this.  If the flag has not been updated
-  // yet (via SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef")
-  // change the flag's current value to the new default value as well.
-  SET_FLAGS_DEFAULT
-};
+        // Options that control SetCommandLineOptionWithMode.
+        enum FlagSettingMode
+        {
+            // update the flag's value unconditionally (can call this multiple times).
+            SET_FLAGS_VALUE,
+            // update the flag's value, but *only if* it has not yet been updated
+            // with SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef".
+            SET_FLAG_IF_DEFAULT,
+            // set the flag's default value to this.  If the flag has not been updated
+            // yet (via SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef")
+            // change the flag's current value to the new default value as well.
+            SET_FLAGS_DEFAULT
+        };
 
-// Options that control ParseFrom: Source of a value.
-enum ValueSource {
-  // Flag is being set by value specified on a command line.
-  kCommandLine,
-  // Flag is being set by value specified in the code.
-  kProgrammaticChange,
-};
+        // Options that control ParseFrom: Source of a value.
+        enum ValueSource
+        {
+            // Flag is being set by value specified on a command line.
+            kCommandLine,
+            // Flag is being set by value specified in the code.
+            kProgrammaticChange,
+        };
 
-// Handle to FlagState objects. Specific flag state objects will restore state
-// of a flag produced this flag state from method CommandLineFlag::SaveState().
-class FlagStateInterface {
- public:
-  virtual ~FlagStateInterface();
+        // Handle to FlagState objects. Specific flag state objects will restore state
+        // of a flag produced this flag state from method CommandLineFlag::SaveState().
+        class FlagStateInterface
+        {
+        public:
+            virtual ~FlagStateInterface();
 
-  // Restores the flag originated this object to the saved state.
-  virtual void Restore() const = 0;
-};
+            // Restores the flag originated this object to the saved state.
+            virtual void Restore() const = 0;
+        };
 
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_COMMANDLINEFLAG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/flag.h b/CAPI/cpp/grpc/include/absl/flags/internal/flag.h
index 6154638..683f91f 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/flag.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/flag.h
@@ -44,757 +44,880 @@
 #include "absl/synchronization/mutex.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Forward declaration of absl::Flag<T> public API.
-namespace flags_internal {
-template <typename T>
-class Flag;
-}  // namespace flags_internal
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // Forward declaration of absl::Flag<T> public API.
+    namespace flags_internal
+    {
+        template<typename T>
+        class Flag;
+    }  // namespace flags_internal
 
 #if defined(_MSC_VER) && !defined(__clang__)
-template <typename T>
-class Flag;
+    template<typename T>
+    class Flag;
 #else
-template <typename T>
-using Flag = flags_internal::Flag<T>;
+    template<typename T>
+    using Flag = flags_internal::Flag<T>;
 #endif
 
-template <typename T>
-ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag);
-
-template <typename T>
-void SetFlag(absl::Flag<T>* flag, const T& v);
-
-template <typename T, typename V>
-void SetFlag(absl::Flag<T>* flag, const V& v);
-
-template <typename U>
-const CommandLineFlag& GetFlagReflectionHandle(const absl::Flag<U>& f);
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag value type operations, eg., parsing, copying, etc. are provided
-// by function specific to that type with a signature matching FlagOpFn.
-
-namespace flags_internal {
-
-enum class FlagOp {
-  kAlloc,
-  kDelete,
-  kCopy,
-  kCopyConstruct,
-  kSizeof,
-  kFastTypeId,
-  kRuntimeTypeId,
-  kParse,
-  kUnparse,
-  kValueOffset,
-};
-using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*);
-
-// Forward declaration for Flag value specific operations.
-template <typename T>
-void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3);
-
-// Allocate aligned memory for a flag value.
-inline void* Alloc(FlagOpFn op) {
-  return op(FlagOp::kAlloc, nullptr, nullptr, nullptr);
-}
-// Deletes memory interpreting obj as flag value type pointer.
-inline void Delete(FlagOpFn op, void* obj) {
-  op(FlagOp::kDelete, nullptr, obj, nullptr);
-}
-// Copies src to dst interpreting as flag value type pointers.
-inline void Copy(FlagOpFn op, const void* src, void* dst) {
-  op(FlagOp::kCopy, src, dst, nullptr);
-}
-// Construct a copy of flag value in a location pointed by dst
-// based on src - pointer to the flag's value.
-inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) {
-  op(FlagOp::kCopyConstruct, src, dst, nullptr);
-}
-// Makes a copy of flag value pointed by obj.
-inline void* Clone(FlagOpFn op, const void* obj) {
-  void* res = flags_internal::Alloc(op);
-  flags_internal::CopyConstruct(op, obj, res);
-  return res;
-}
-// Returns true if parsing of input text is successfull.
-inline bool Parse(FlagOpFn op, absl::string_view text, void* dst,
-                  std::string* error) {
-  return op(FlagOp::kParse, &text, dst, error) != nullptr;
-}
-// Returns string representing supplied value.
-inline std::string Unparse(FlagOpFn op, const void* val) {
-  std::string result;
-  op(FlagOp::kUnparse, val, &result, nullptr);
-  return result;
-}
-// Returns size of flag value type.
-inline size_t Sizeof(FlagOpFn op) {
-  // This sequence of casts reverses the sequence from
-  // `flags_internal::FlagOps()`
-  return static_cast<size_t>(reinterpret_cast<intptr_t>(
-      op(FlagOp::kSizeof, nullptr, nullptr, nullptr)));
-}
-// Returns fast type id coresponding to the value type.
-inline FlagFastTypeId FastTypeId(FlagOpFn op) {
-  return reinterpret_cast<FlagFastTypeId>(
-      op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr));
-}
-// Returns fast type id coresponding to the value type.
-inline const std::type_info* RuntimeTypeId(FlagOpFn op) {
-  return reinterpret_cast<const std::type_info*>(
-      op(FlagOp::kRuntimeTypeId, nullptr, nullptr, nullptr));
-}
-// Returns offset of the field value_ from the field impl_ inside of
-// absl::Flag<T> data. Given FlagImpl pointer p you can get the
-// location of the corresponding value as:
-//      reinterpret_cast<char*>(p) + ValueOffset().
-inline ptrdiff_t ValueOffset(FlagOpFn op) {
-  // This sequence of casts reverses the sequence from
-  // `flags_internal::FlagOps()`
-  return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
-      op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
-}
-
-// Returns an address of RTTI's typeid(T).
-template <typename T>
-inline const std::type_info* GenRuntimeTypeId() {
+    template<typename T>
+    ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag);
+
+    template<typename T>
+    void SetFlag(absl::Flag<T>* flag, const T& v);
+
+    template<typename T, typename V>
+    void SetFlag(absl::Flag<T>* flag, const V& v);
+
+    template<typename U>
+    const CommandLineFlag& GetFlagReflectionHandle(const absl::Flag<U>& f);
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // Flag value type operations, eg., parsing, copying, etc. are provided
+    // by function specific to that type with a signature matching FlagOpFn.
+
+    namespace flags_internal
+    {
+
+        enum class FlagOp
+        {
+            kAlloc,
+            kDelete,
+            kCopy,
+            kCopyConstruct,
+            kSizeof,
+            kFastTypeId,
+            kRuntimeTypeId,
+            kParse,
+            kUnparse,
+            kValueOffset,
+        };
+        using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*);
+
+        // Forward declaration for Flag value specific operations.
+        template<typename T>
+        void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3);
+
+        // Allocate aligned memory for a flag value.
+        inline void* Alloc(FlagOpFn op)
+        {
+            return op(FlagOp::kAlloc, nullptr, nullptr, nullptr);
+        }
+        // Deletes memory interpreting obj as flag value type pointer.
+        inline void Delete(FlagOpFn op, void* obj)
+        {
+            op(FlagOp::kDelete, nullptr, obj, nullptr);
+        }
+        // Copies src to dst interpreting as flag value type pointers.
+        inline void Copy(FlagOpFn op, const void* src, void* dst)
+        {
+            op(FlagOp::kCopy, src, dst, nullptr);
+        }
+        // Construct a copy of flag value in a location pointed by dst
+        // based on src - pointer to the flag's value.
+        inline void CopyConstruct(FlagOpFn op, const void* src, void* dst)
+        {
+            op(FlagOp::kCopyConstruct, src, dst, nullptr);
+        }
+        // Makes a copy of flag value pointed by obj.
+        inline void* Clone(FlagOpFn op, const void* obj)
+        {
+            void* res = flags_internal::Alloc(op);
+            flags_internal::CopyConstruct(op, obj, res);
+            return res;
+        }
+        // Returns true if parsing of input text is successfull.
+        inline bool Parse(FlagOpFn op, absl::string_view text, void* dst, std::string* error)
+        {
+            return op(FlagOp::kParse, &text, dst, error) != nullptr;
+        }
+        // Returns string representing supplied value.
+        inline std::string Unparse(FlagOpFn op, const void* val)
+        {
+            std::string result;
+            op(FlagOp::kUnparse, val, &result, nullptr);
+            return result;
+        }
+        // Returns size of flag value type.
+        inline size_t Sizeof(FlagOpFn op)
+        {
+            // This sequence of casts reverses the sequence from
+            // `flags_internal::FlagOps()`
+            return static_cast<size_t>(reinterpret_cast<intptr_t>(
+                op(FlagOp::kSizeof, nullptr, nullptr, nullptr)
+            ));
+        }
+        // Returns fast type id coresponding to the value type.
+        inline FlagFastTypeId FastTypeId(FlagOpFn op)
+        {
+            return reinterpret_cast<FlagFastTypeId>(
+                op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr)
+            );
+        }
+        // Returns fast type id coresponding to the value type.
+        inline const std::type_info* RuntimeTypeId(FlagOpFn op)
+        {
+            return reinterpret_cast<const std::type_info*>(
+                op(FlagOp::kRuntimeTypeId, nullptr, nullptr, nullptr)
+            );
+        }
+        // Returns offset of the field value_ from the field impl_ inside of
+        // absl::Flag<T> data. Given FlagImpl pointer p you can get the
+        // location of the corresponding value as:
+        //      reinterpret_cast<char*>(p) + ValueOffset().
+        inline ptrdiff_t ValueOffset(FlagOpFn op)
+        {
+            // This sequence of casts reverses the sequence from
+            // `flags_internal::FlagOps()`
+            return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
+                op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)
+            ));
+        }
+
+        // Returns an address of RTTI's typeid(T).
+        template<typename T>
+        inline const std::type_info* GenRuntimeTypeId()
+        {
 #ifdef ABSL_INTERNAL_HAS_RTTI
-  return &typeid(T);
+            return &typeid(T);
 #else
-  return nullptr;
+            return nullptr;
 #endif
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag help auxiliary structs.
-
-// This is help argument for absl::Flag encapsulating the string literal pointer
-// or pointer to function generating it as well as enum descriminating two
-// cases.
-using HelpGenFunc = std::string (*)();
-
-template <size_t N>
-struct FixedCharArray {
-  char value[N];
-
-  template <size_t... I>
-  static constexpr FixedCharArray<N> FromLiteralString(
-      absl::string_view str, absl::index_sequence<I...>) {
-    return (void)str, FixedCharArray<N>({{str[I]..., '\0'}});
-  }
-};
-
-template <typename Gen, size_t N = Gen::Value().size()>
-constexpr FixedCharArray<N + 1> HelpStringAsArray(int) {
-  return FixedCharArray<N + 1>::FromLiteralString(
-      Gen::Value(), absl::make_index_sequence<N>{});
-}
-
-template <typename Gen>
-constexpr std::false_type HelpStringAsArray(char) {
-  return std::false_type{};
-}
-
-union FlagHelpMsg {
-  constexpr explicit FlagHelpMsg(const char* help_msg) : literal(help_msg) {}
-  constexpr explicit FlagHelpMsg(HelpGenFunc help_gen) : gen_func(help_gen) {}
-
-  const char* literal;
-  HelpGenFunc gen_func;
-};
-
-enum class FlagHelpKind : uint8_t { kLiteral = 0, kGenFunc = 1 };
-
-struct FlagHelpArg {
-  FlagHelpMsg source;
-  FlagHelpKind kind;
-};
-
-extern const char kStrippedFlagHelp[];
-
-// These two HelpArg overloads allows us to select at compile time one of two
-// way to pass Help argument to absl::Flag. We'll be passing
-// AbslFlagHelpGenFor##name as Gen and integer 0 as a single argument to prefer
-// first overload if possible. If help message is evaluatable on constexpr
-// context We'll be able to make FixedCharArray out of it and we'll choose first
-// overload. In this case the help message expression is immediately evaluated
-// and is used to construct the absl::Flag. No additionl code is generated by
-// ABSL_FLAG Otherwise SFINAE kicks in and first overload is dropped from the
-// consideration, in which case the second overload will be used. The second
-// overload does not attempt to evaluate the help message expression
-// immediately and instead delays the evaluation by returing the function
-// pointer (&T::NonConst) genering the help message when necessary. This is
-// evaluatable in constexpr context, but the cost is an extra function being
-// generated in the ABSL_FLAG code.
-template <typename Gen, size_t N>
-constexpr FlagHelpArg HelpArg(const FixedCharArray<N>& value) {
-  return {FlagHelpMsg(value.value), FlagHelpKind::kLiteral};
-}
-
-template <typename Gen>
-constexpr FlagHelpArg HelpArg(std::false_type) {
-  return {FlagHelpMsg(&Gen::NonConst), FlagHelpKind::kGenFunc};
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag default value auxiliary structs.
-
-// Signature for the function generating the initial flag value (usually
-// based on default value supplied in flag's definition)
-using FlagDfltGenFunc = void (*)(void*);
-
-union FlagDefaultSrc {
-  constexpr explicit FlagDefaultSrc(FlagDfltGenFunc gen_func_arg)
-      : gen_func(gen_func_arg) {}
-
-#define ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE(T, name) \
-  T name##_value;                                  \
-  constexpr explicit FlagDefaultSrc(T value) : name##_value(value) {}  // NOLINT
-  ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE)
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Flag help auxiliary structs.
+
+        // This is help argument for absl::Flag encapsulating the string literal pointer
+        // or pointer to function generating it as well as enum descriminating two
+        // cases.
+        using HelpGenFunc = std::string (*)();
+
+        template<size_t N>
+        struct FixedCharArray
+        {
+            char value[N];
+
+            template<size_t... I>
+            static constexpr FixedCharArray<N> FromLiteralString(
+                absl::string_view str, absl::index_sequence<I...>
+            )
+            {
+                return (void)str, FixedCharArray<N>({{str[I]..., '\0'}});
+            }
+        };
+
+        template<typename Gen, size_t N = Gen::Value().size()>
+        constexpr FixedCharArray<N + 1> HelpStringAsArray(int)
+        {
+            return FixedCharArray<N + 1>::FromLiteralString(
+                Gen::Value(), absl::make_index_sequence<N>{}
+            );
+        }
+
+        template<typename Gen>
+        constexpr std::false_type HelpStringAsArray(char)
+        {
+            return std::false_type{};
+        }
+
+        union FlagHelpMsg
+        {
+            constexpr explicit FlagHelpMsg(const char* help_msg) :
+                literal(help_msg)
+            {
+            }
+            constexpr explicit FlagHelpMsg(HelpGenFunc help_gen) :
+                gen_func(help_gen)
+            {
+            }
+
+            const char* literal;
+            HelpGenFunc gen_func;
+        };
+
+        enum class FlagHelpKind : uint8_t
+        {
+            kLiteral = 0,
+            kGenFunc = 1
+        };
+
+        struct FlagHelpArg
+        {
+            FlagHelpMsg source;
+            FlagHelpKind kind;
+        };
+
+        extern const char kStrippedFlagHelp[];
+
+        // These two HelpArg overloads allows us to select at compile time one of two
+        // way to pass Help argument to absl::Flag. We'll be passing
+        // AbslFlagHelpGenFor##name as Gen and integer 0 as a single argument to prefer
+        // first overload if possible. If help message is evaluatable on constexpr
+        // context We'll be able to make FixedCharArray out of it and we'll choose first
+        // overload. In this case the help message expression is immediately evaluated
+        // and is used to construct the absl::Flag. No additionl code is generated by
+        // ABSL_FLAG Otherwise SFINAE kicks in and first overload is dropped from the
+        // consideration, in which case the second overload will be used. The second
+        // overload does not attempt to evaluate the help message expression
+        // immediately and instead delays the evaluation by returing the function
+        // pointer (&T::NonConst) genering the help message when necessary. This is
+        // evaluatable in constexpr context, but the cost is an extra function being
+        // generated in the ABSL_FLAG code.
+        template<typename Gen, size_t N>
+        constexpr FlagHelpArg HelpArg(const FixedCharArray<N>& value)
+        {
+            return {FlagHelpMsg(value.value), FlagHelpKind::kLiteral};
+        }
+
+        template<typename Gen>
+        constexpr FlagHelpArg HelpArg(std::false_type)
+        {
+            return {FlagHelpMsg(&Gen::NonConst), FlagHelpKind::kGenFunc};
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Flag default value auxiliary structs.
+
+        // Signature for the function generating the initial flag value (usually
+        // based on default value supplied in flag's definition)
+        using FlagDfltGenFunc = void (*)(void*);
+
+        union FlagDefaultSrc
+        {
+            constexpr explicit FlagDefaultSrc(FlagDfltGenFunc gen_func_arg) :
+                gen_func(gen_func_arg)
+            {
+            }
+
+#define ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE(T, name)                   \
+    T name##_value;                                                  \
+    constexpr explicit FlagDefaultSrc(T value) : name##_value(value) \
+    {                                                                \
+    }  // NOLINT
+            ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE)
 #undef ABSL_FLAGS_INTERNAL_DFLT_FOR_TYPE
 
-  void* dynamic_value;
-  FlagDfltGenFunc gen_func;
-};
-
-enum class FlagDefaultKind : uint8_t {
-  kDynamicValue = 0,
-  kGenFunc = 1,
-  kOneWord = 2  // for default values UP to one word in size
-};
-
-struct FlagDefaultArg {
-  FlagDefaultSrc source;
-  FlagDefaultKind kind;
-};
-
-// This struct and corresponding overload to InitDefaultValue are used to
-// facilitate usage of {} as default value in ABSL_FLAG macro.
-// TODO(rogeeff): Fix handling types with explicit constructors.
-struct EmptyBraces {};
-
-template <typename T>
-constexpr T InitDefaultValue(T t) {
-  return t;
-}
-
-template <typename T>
-constexpr T InitDefaultValue(EmptyBraces) {
-  return T{};
-}
-
-template <typename ValueT, typename GenT,
-          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
-              ((void)GenT{}, 0)>
-constexpr FlagDefaultArg DefaultArg(int) {
-  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
-}
-
-template <typename ValueT, typename GenT>
-constexpr FlagDefaultArg DefaultArg(char) {
-  return {FlagDefaultSrc(&GenT::Gen), FlagDefaultKind::kGenFunc};
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag current value auxiliary structs.
-
-constexpr int64_t UninitializedFlagValue() {
-  return static_cast<int64_t>(0xababababababababll);
-}
-
-template <typename T>
-using FlagUseValueAndInitBitStorage = std::integral_constant<
-    bool, absl::type_traits_internal::is_trivially_copyable<T>::value &&
-              std::is_default_constructible<T>::value && (sizeof(T) < 8)>;
-
-template <typename T>
-using FlagUseOneWordStorage = std::integral_constant<
-    bool, absl::type_traits_internal::is_trivially_copyable<T>::value &&
-              (sizeof(T) <= 8)>;
-
-template <class T>
-using FlagUseSequenceLockStorage = std::integral_constant<
-    bool, absl::type_traits_internal::is_trivially_copyable<T>::value &&
-              (sizeof(T) > 8)>;
-
-enum class FlagValueStorageKind : uint8_t {
-  kValueAndInitBit = 0,
-  kOneWordAtomic = 1,
-  kSequenceLocked = 2,
-  kAlignedBuffer = 3,
-};
-
-template <typename T>
-static constexpr FlagValueStorageKind StorageKind() {
-  return FlagUseValueAndInitBitStorage<T>::value
-             ? FlagValueStorageKind::kValueAndInitBit
-         : FlagUseOneWordStorage<T>::value
-             ? FlagValueStorageKind::kOneWordAtomic
-         : FlagUseSequenceLockStorage<T>::value
-             ? FlagValueStorageKind::kSequenceLocked
-             : FlagValueStorageKind::kAlignedBuffer;
-}
-
-struct FlagOneWordValue {
-  constexpr explicit FlagOneWordValue(int64_t v) : value(v) {}
-  std::atomic<int64_t> value;
-};
-
-template <typename T>
-struct alignas(8) FlagValueAndInitBit {
-  T value;
-  // Use an int instead of a bool to guarantee that a non-zero value has
-  // a bit set.
-  uint8_t init;
-};
-
-template <typename T,
-          FlagValueStorageKind Kind = flags_internal::StorageKind<T>()>
-struct FlagValue;
-
-template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kValueAndInitBit> : FlagOneWordValue {
-  constexpr FlagValue() : FlagOneWordValue(0) {}
-  bool Get(const SequenceLock&, T& dst) const {
-    int64_t storage = value.load(std::memory_order_acquire);
-    if (ABSL_PREDICT_FALSE(storage == 0)) {
-      return false;
-    }
-    dst = absl::bit_cast<FlagValueAndInitBit<T>>(storage).value;
-    return true;
-  }
-};
-
-template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kOneWordAtomic> : FlagOneWordValue {
-  constexpr FlagValue() : FlagOneWordValue(UninitializedFlagValue()) {}
-  bool Get(const SequenceLock&, T& dst) const {
-    int64_t one_word_val = value.load(std::memory_order_acquire);
-    if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
-      return false;
-    }
-    std::memcpy(&dst, static_cast<const void*>(&one_word_val), sizeof(T));
-    return true;
-  }
-};
-
-template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kSequenceLocked> {
-  bool Get(const SequenceLock& lock, T& dst) const {
-    return lock.TryRead(&dst, value_words, sizeof(T));
-  }
-
-  static constexpr int kNumWords =
-      flags_internal::AlignUp(sizeof(T), sizeof(uint64_t)) / sizeof(uint64_t);
-
-  alignas(T) alignas(
-      std::atomic<uint64_t>) std::atomic<uint64_t> value_words[kNumWords];
-};
-
-template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kAlignedBuffer> {
-  bool Get(const SequenceLock&, T&) const { return false; }
-
-  alignas(T) char value[sizeof(T)];
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag callback auxiliary structs.
-
-// Signature for the mutation callback used by watched Flags
-// The callback is noexcept.
-// TODO(rogeeff): add noexcept after C++17 support is added.
-using FlagCallbackFunc = void (*)();
-
-struct FlagCallback {
-  FlagCallbackFunc func;
-  absl::Mutex guard;  // Guard for concurrent callback invocations.
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Flag implementation, which does not depend on flag value type.
-// The class encapsulates the Flag's data and access to it.
-
-struct DynValueDeleter {
-  explicit DynValueDeleter(FlagOpFn op_arg = nullptr);
-  void operator()(void* ptr) const;
-
-  FlagOpFn op;
-};
-
-class FlagState;
-
-class FlagImpl final : public CommandLineFlag {
- public:
-  constexpr FlagImpl(const char* name, const char* filename, FlagOpFn op,
-                     FlagHelpArg help, FlagValueStorageKind value_kind,
-                     FlagDefaultArg default_arg)
-      : name_(name),
-        filename_(filename),
-        op_(op),
-        help_(help.source),
-        help_source_kind_(static_cast<uint8_t>(help.kind)),
-        value_storage_kind_(static_cast<uint8_t>(value_kind)),
-        def_kind_(static_cast<uint8_t>(default_arg.kind)),
-        modified_(false),
-        on_command_line_(false),
-        callback_(nullptr),
-        default_value_(default_arg.source),
-        data_guard_{} {}
-
-  // Constant access methods
-  int64_t ReadOneWord() const ABSL_LOCKS_EXCLUDED(*DataGuard());
-  bool ReadOneBool() const ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void Read(void* dst) const override ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void Read(bool* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
-    *value = ReadOneBool();
-  }
-  template <typename T,
-            absl::enable_if_t<flags_internal::StorageKind<T>() ==
-                                  FlagValueStorageKind::kOneWordAtomic,
-                              int> = 0>
-  void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
-    int64_t v = ReadOneWord();
-    std::memcpy(value, static_cast<const void*>(&v), sizeof(T));
-  }
-  template <typename T,
-            typename std::enable_if<flags_internal::StorageKind<T>() ==
-                                        FlagValueStorageKind::kValueAndInitBit,
-                                    int>::type = 0>
-  void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
-    *value = absl::bit_cast<FlagValueAndInitBit<T>>(ReadOneWord()).value;
-  }
-
-  // Mutating access methods
-  void Write(const void* src) ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  // Interfaces to operate on callbacks.
-  void SetCallback(const FlagCallbackFunc mutation_callback)
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void InvokeCallback() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-
-  // Used in read/write operations to validate source/target has correct type.
-  // For example if flag is declared as absl::Flag<int> FLAGS_foo, a call to
-  // absl::GetFlag(FLAGS_foo) validates that the type of FLAGS_foo is indeed
-  // int. To do that we pass the "assumed" type id (which is deduced from type
-  // int) as an argument `type_id`, which is in turn is validated against the
-  // type id stored in flag object by flag definition statement.
-  void AssertValidType(FlagFastTypeId type_id,
-                       const std::type_info* (*gen_rtti)()) const;
-
- private:
-  template <typename T>
-  friend class Flag;
-  friend class FlagState;
-
-  // Ensures that `data_guard_` is initialized and returns it.
-  absl::Mutex* DataGuard() const
-      ABSL_LOCK_RETURNED(reinterpret_cast<absl::Mutex*>(data_guard_));
-  // Returns heap allocated value of type T initialized with default value.
-  std::unique_ptr<void, DynValueDeleter> MakeInitValue() const
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-  // Flag initialization called via absl::call_once.
-  void Init();
-
-  // Offset value access methods. One per storage kind. These methods to not
-  // respect const correctness, so be very carefull using them.
-
-  // This is a shared helper routine which encapsulates most of the magic. Since
-  // it is only used inside the three routines below, which are defined in
-  // flag.cc, we can define it in that file as well.
-  template <typename StorageT>
-  StorageT* OffsetValue() const;
-  // This is an accessor for a value stored in an aligned buffer storage
-  // used for non-trivially-copyable data types.
-  // Returns a mutable pointer to the start of a buffer.
-  void* AlignedBufferValue() const;
-
-  // The same as above, but used for sequencelock-protected storage.
-  std::atomic<uint64_t>* AtomicBufferValue() const;
-
-  // This is an accessor for a value stored as one word atomic. Returns a
-  // mutable reference to an atomic value.
-  std::atomic<int64_t>& OneWordValue() const;
-
-  // Attempts to parse supplied `value` string. If parsing is successful,
-  // returns new value. Otherwise returns nullptr.
-  std::unique_ptr<void, DynValueDeleter> TryParse(absl::string_view value,
-                                                  std::string& err) const
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-  // Stores the flag value based on the pointer to the source.
-  void StoreValue(const void* src) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-
-  // Copy the flag data, protected by `seq_lock_` into `dst`.
-  //
-  // REQUIRES: ValueStorageKind() == kSequenceLocked.
-  void ReadSequenceLockedData(void* dst) const
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  FlagHelpKind HelpSourceKind() const {
-    return static_cast<FlagHelpKind>(help_source_kind_);
-  }
-  FlagValueStorageKind ValueStorageKind() const {
-    return static_cast<FlagValueStorageKind>(value_storage_kind_);
-  }
-  FlagDefaultKind DefaultKind() const
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()) {
-    return static_cast<FlagDefaultKind>(def_kind_);
-  }
-
-  // CommandLineFlag interface implementation
-  absl::string_view Name() const override;
-  std::string Filename() const override;
-  std::string Help() const override;
-  FlagFastTypeId TypeId() const override;
-  bool IsSpecifiedOnCommandLine() const override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-  std::string DefaultValue() const override ABSL_LOCKS_EXCLUDED(*DataGuard());
-  std::string CurrentValue() const override ABSL_LOCKS_EXCLUDED(*DataGuard());
-  bool ValidateInputValue(absl::string_view value) const override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-  void CheckDefaultValueParsingRoundtrip() const override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  int64_t ModificationCount() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-
-  // Interfaces to save and restore flags to/from persistent state.
-  // Returns current flag state or nullptr if flag does not support
-  // saving and restoring a state.
-  std::unique_ptr<FlagStateInterface> SaveState() override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  // Restores the flag state to the supplied state object. If there is
-  // nothing to restore returns false. Otherwise returns true.
-  bool RestoreState(const FlagState& flag_state)
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  bool ParseFrom(absl::string_view value, FlagSettingMode set_mode,
-                 ValueSource source, std::string& error) override
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-
-  // Immutable flag's state.
-
-  // Flags name passed to ABSL_FLAG as second arg.
-  const char* const name_;
-  // The file name where ABSL_FLAG resides.
-  const char* const filename_;
-  // Type-specific operations "vtable".
-  const FlagOpFn op_;
-  // Help message literal or function to generate it.
-  const FlagHelpMsg help_;
-  // Indicates if help message was supplied as literal or generator func.
-  const uint8_t help_source_kind_ : 1;
-  // Kind of storage this flag is using for the flag's value.
-  const uint8_t value_storage_kind_ : 2;
-
-  uint8_t : 0;  // The bytes containing the const bitfields must not be
-                // shared with bytes containing the mutable bitfields.
-
-  // Mutable flag's state (guarded by `data_guard_`).
-
-  // def_kind_ is not guard by DataGuard() since it is accessed in Init without
-  // locks.
-  uint8_t def_kind_ : 2;
-  // Has this flag's value been modified?
-  bool modified_ : 1 ABSL_GUARDED_BY(*DataGuard());
-  // Has this flag been specified on command line.
-  bool on_command_line_ : 1 ABSL_GUARDED_BY(*DataGuard());
-
-  // Unique tag for absl::call_once call to initialize this flag.
-  absl::once_flag init_control_;
-
-  // Sequence lock / mutation counter.
-  flags_internal::SequenceLock seq_lock_;
-
-  // Optional flag's callback and absl::Mutex to guard the invocations.
-  FlagCallback* callback_ ABSL_GUARDED_BY(*DataGuard());
-  // Either a pointer to the function generating the default value based on the
-  // value specified in ABSL_FLAG or pointer to the dynamically set default
-  // value via SetCommandLineOptionWithMode. def_kind_ is used to distinguish
-  // these two cases.
-  FlagDefaultSrc default_value_;
-
-  // This is reserved space for an absl::Mutex to guard flag data. It will be
-  // initialized in FlagImpl::Init via placement new.
-  // We can't use "absl::Mutex data_guard_", since this class is not literal.
-  // We do not want to use "absl::Mutex* data_guard_", since this would require
-  // heap allocation during initialization, which is both slows program startup
-  // and can fail. Using reserved space + placement new allows us to avoid both
-  // problems.
-  alignas(absl::Mutex) mutable char data_guard_[sizeof(absl::Mutex)];
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// The Flag object parameterized by the flag's value type. This class implements
-// flag reflection handle interface.
-
-template <typename T>
-class Flag {
- public:
-  constexpr Flag(const char* name, const char* filename, FlagHelpArg help,
-                 const FlagDefaultArg default_arg)
-      : impl_(name, filename, &FlagOps<T>, help,
-              flags_internal::StorageKind<T>(), default_arg),
-        value_() {}
-
-  // CommandLineFlag interface
-  absl::string_view Name() const { return impl_.Name(); }
-  std::string Filename() const { return impl_.Filename(); }
-  std::string Help() const { return impl_.Help(); }
-  // Do not use. To be removed.
-  bool IsSpecifiedOnCommandLine() const {
-    return impl_.IsSpecifiedOnCommandLine();
-  }
-  std::string DefaultValue() const { return impl_.DefaultValue(); }
-  std::string CurrentValue() const { return impl_.CurrentValue(); }
-
- private:
-  template <typename, bool>
-  friend class FlagRegistrar;
-  friend class FlagImplPeer;
-
-  T Get() const {
-    // See implementation notes in CommandLineFlag::Get().
-    union U {
-      T value;
-      U() {}
-      ~U() { value.~T(); }
-    };
-    U u;
+            void* dynamic_value;
+            FlagDfltGenFunc gen_func;
+        };
+
+        enum class FlagDefaultKind : uint8_t
+        {
+            kDynamicValue = 0,
+            kGenFunc = 1,
+            kOneWord = 2  // for default values UP to one word in size
+        };
+
+        struct FlagDefaultArg
+        {
+            FlagDefaultSrc source;
+            FlagDefaultKind kind;
+        };
+
+        // This struct and corresponding overload to InitDefaultValue are used to
+        // facilitate usage of {} as default value in ABSL_FLAG macro.
+        // TODO(rogeeff): Fix handling types with explicit constructors.
+        struct EmptyBraces
+        {
+        };
+
+        template<typename T>
+        constexpr T InitDefaultValue(T t)
+        {
+            return t;
+        }
+
+        template<typename T>
+        constexpr T InitDefaultValue(EmptyBraces)
+        {
+            return T{};
+        }
+
+        template<typename ValueT, typename GenT, typename std::enable_if<std::is_integral<ValueT>::value, int>::type = ((void)GenT{}, 0)>
+        constexpr FlagDefaultArg DefaultArg(int)
+        {
+            return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
+        }
+
+        template<typename ValueT, typename GenT>
+        constexpr FlagDefaultArg DefaultArg(char)
+        {
+            return {FlagDefaultSrc(&GenT::Gen), FlagDefaultKind::kGenFunc};
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Flag current value auxiliary structs.
+
+        constexpr int64_t UninitializedFlagValue()
+        {
+            return static_cast<int64_t>(0xababababababababll);
+        }
+
+        template<typename T>
+        using FlagUseValueAndInitBitStorage = std::integral_constant<
+            bool,
+            absl::type_traits_internal::is_trivially_copyable<T>::value &&
+                std::is_default_constructible<T>::value && (sizeof(T) < 8)>;
+
+        template<typename T>
+        using FlagUseOneWordStorage = std::integral_constant<
+            bool,
+            absl::type_traits_internal::is_trivially_copyable<T>::value &&
+                (sizeof(T) <= 8)>;
+
+        template<class T>
+        using FlagUseSequenceLockStorage = std::integral_constant<
+            bool,
+            absl::type_traits_internal::is_trivially_copyable<T>::value &&
+                (sizeof(T) > 8)>;
+
+        enum class FlagValueStorageKind : uint8_t
+        {
+            kValueAndInitBit = 0,
+            kOneWordAtomic = 1,
+            kSequenceLocked = 2,
+            kAlignedBuffer = 3,
+        };
+
+        template<typename T>
+        static constexpr FlagValueStorageKind StorageKind()
+        {
+            return FlagUseValueAndInitBitStorage<T>::value ? FlagValueStorageKind::kValueAndInitBit : FlagUseOneWordStorage<T>::value  ? FlagValueStorageKind::kOneWordAtomic :
+                                                                                                  FlagUseSequenceLockStorage<T>::value ? FlagValueStorageKind::kSequenceLocked :
+                                                                                                                                         FlagValueStorageKind::kAlignedBuffer;
+        }
+
+        struct FlagOneWordValue
+        {
+            constexpr explicit FlagOneWordValue(int64_t v) :
+                value(v)
+            {
+            }
+            std::atomic<int64_t> value;
+        };
+
+        template<typename T>
+        struct alignas(8) FlagValueAndInitBit
+        {
+            T value;
+            // Use an int instead of a bool to guarantee that a non-zero value has
+            // a bit set.
+            uint8_t init;
+        };
+
+        template<typename T, FlagValueStorageKind Kind = flags_internal::StorageKind<T>()>
+        struct FlagValue;
+
+        template<typename T>
+        struct FlagValue<T, FlagValueStorageKind::kValueAndInitBit> : FlagOneWordValue
+        {
+            constexpr FlagValue() :
+                FlagOneWordValue(0)
+            {
+            }
+            bool Get(const SequenceLock&, T& dst) const
+            {
+                int64_t storage = value.load(std::memory_order_acquire);
+                if (ABSL_PREDICT_FALSE(storage == 0))
+                {
+                    return false;
+                }
+                dst = absl::bit_cast<FlagValueAndInitBit<T>>(storage).value;
+                return true;
+            }
+        };
+
+        template<typename T>
+        struct FlagValue<T, FlagValueStorageKind::kOneWordAtomic> : FlagOneWordValue
+        {
+            constexpr FlagValue() :
+                FlagOneWordValue(UninitializedFlagValue())
+            {
+            }
+            bool Get(const SequenceLock&, T& dst) const
+            {
+                int64_t one_word_val = value.load(std::memory_order_acquire);
+                if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue()))
+                {
+                    return false;
+                }
+                std::memcpy(&dst, static_cast<const void*>(&one_word_val), sizeof(T));
+                return true;
+            }
+        };
+
+        template<typename T>
+        struct FlagValue<T, FlagValueStorageKind::kSequenceLocked>
+        {
+            bool Get(const SequenceLock& lock, T& dst) const
+            {
+                return lock.TryRead(&dst, value_words, sizeof(T));
+            }
+
+            static constexpr int kNumWords =
+                flags_internal::AlignUp(sizeof(T), sizeof(uint64_t)) / sizeof(uint64_t);
+
+            alignas(T) alignas(
+                std::atomic<uint64_t>
+            ) std::atomic<uint64_t> value_words[kNumWords];
+        };
+
+        template<typename T>
+        struct FlagValue<T, FlagValueStorageKind::kAlignedBuffer>
+        {
+            bool Get(const SequenceLock&, T&) const
+            {
+                return false;
+            }
+
+            alignas(T) char value[sizeof(T)];
+        };
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Flag callback auxiliary structs.
+
+        // Signature for the mutation callback used by watched Flags
+        // The callback is noexcept.
+        // TODO(rogeeff): add noexcept after C++17 support is added.
+        using FlagCallbackFunc = void (*)();
+
+        struct FlagCallback
+        {
+            FlagCallbackFunc func;
+            absl::Mutex guard;  // Guard for concurrent callback invocations.
+        };
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Flag implementation, which does not depend on flag value type.
+        // The class encapsulates the Flag's data and access to it.
+
+        struct DynValueDeleter
+        {
+            explicit DynValueDeleter(FlagOpFn op_arg = nullptr);
+            void operator()(void* ptr) const;
+
+            FlagOpFn op;
+        };
+
+        class FlagState;
+
+        class FlagImpl final : public CommandLineFlag
+        {
+        public:
+            constexpr FlagImpl(const char* name, const char* filename, FlagOpFn op, FlagHelpArg help, FlagValueStorageKind value_kind, FlagDefaultArg default_arg) :
+                name_(name),
+                filename_(filename),
+                op_(op),
+                help_(help.source),
+                help_source_kind_(static_cast<uint8_t>(help.kind)),
+                value_storage_kind_(static_cast<uint8_t>(value_kind)),
+                def_kind_(static_cast<uint8_t>(default_arg.kind)),
+                modified_(false),
+                on_command_line_(false),
+                callback_(nullptr),
+                default_value_(default_arg.source),
+                data_guard_{}
+            {
+            }
+
+            // Constant access methods
+            int64_t ReadOneWord() const ABSL_LOCKS_EXCLUDED(*DataGuard());
+            bool ReadOneBool() const ABSL_LOCKS_EXCLUDED(*DataGuard());
+            void Read(void* dst) const override ABSL_LOCKS_EXCLUDED(*DataGuard());
+            void Read(bool* value) const ABSL_LOCKS_EXCLUDED(*DataGuard())
+            {
+                *value = ReadOneBool();
+            }
+            template<typename T, absl::enable_if_t<flags_internal::StorageKind<T>() == FlagValueStorageKind::kOneWordAtomic, int> = 0>
+            void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard())
+            {
+                int64_t v = ReadOneWord();
+                std::memcpy(value, static_cast<const void*>(&v), sizeof(T));
+            }
+            template<typename T, typename std::enable_if<flags_internal::StorageKind<T>() == FlagValueStorageKind::kValueAndInitBit, int>::type = 0>
+            void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard())
+            {
+                *value = absl::bit_cast<FlagValueAndInitBit<T>>(ReadOneWord()).value;
+            }
+
+            // Mutating access methods
+            void Write(const void* src) ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+            // Interfaces to operate on callbacks.
+            void SetCallback(const FlagCallbackFunc mutation_callback)
+                ABSL_LOCKS_EXCLUDED(*DataGuard());
+            void InvokeCallback() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+
+            // Used in read/write operations to validate source/target has correct type.
+            // For example if flag is declared as absl::Flag<int> FLAGS_foo, a call to
+            // absl::GetFlag(FLAGS_foo) validates that the type of FLAGS_foo is indeed
+            // int. To do that we pass the "assumed" type id (which is deduced from type
+            // int) as an argument `type_id`, which is in turn is validated against the
+            // type id stored in flag object by flag definition statement.
+            void AssertValidType(FlagFastTypeId type_id, const std::type_info* (*gen_rtti)()) const;
+
+        private:
+            template<typename T>
+            friend class Flag;
+            friend class FlagState;
+
+            // Ensures that `data_guard_` is initialized and returns it.
+            absl::Mutex* DataGuard() const
+                ABSL_LOCK_RETURNED(reinterpret_cast<absl::Mutex*>(data_guard_));
+            // Returns heap allocated value of type T initialized with default value.
+            std::unique_ptr<void, DynValueDeleter> MakeInitValue() const
+                ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+            // Flag initialization called via absl::call_once.
+            void Init();
+
+            // Offset value access methods. One per storage kind. These methods to not
+            // respect const correctness, so be very carefull using them.
+
+            // This is a shared helper routine which encapsulates most of the magic. Since
+            // it is only used inside the three routines below, which are defined in
+            // flag.cc, we can define it in that file as well.
+            template<typename StorageT>
+            StorageT* OffsetValue() const;
+            // This is an accessor for a value stored in an aligned buffer storage
+            // used for non-trivially-copyable data types.
+            // Returns a mutable pointer to the start of a buffer.
+            void* AlignedBufferValue() const;
+
+            // The same as above, but used for sequencelock-protected storage.
+            std::atomic<uint64_t>* AtomicBufferValue() const;
+
+            // This is an accessor for a value stored as one word atomic. Returns a
+            // mutable reference to an atomic value.
+            std::atomic<int64_t>& OneWordValue() const;
+
+            // Attempts to parse supplied `value` string. If parsing is successful,
+            // returns new value. Otherwise returns nullptr.
+            std::unique_ptr<void, DynValueDeleter> TryParse(absl::string_view value, std::string& err) const
+                ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+            // Stores the flag value based on the pointer to the source.
+            void StoreValue(const void* src) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+
+            // Copy the flag data, protected by `seq_lock_` into `dst`.
+            //
+            // REQUIRES: ValueStorageKind() == kSequenceLocked.
+            void ReadSequenceLockedData(void* dst) const
+                ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+            FlagHelpKind HelpSourceKind() const
+            {
+                return static_cast<FlagHelpKind>(help_source_kind_);
+            }
+            FlagValueStorageKind ValueStorageKind() const
+            {
+                return static_cast<FlagValueStorageKind>(value_storage_kind_);
+            }
+            FlagDefaultKind DefaultKind() const
+                ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard())
+            {
+                return static_cast<FlagDefaultKind>(def_kind_);
+            }
+
+            // CommandLineFlag interface implementation
+            absl::string_view Name() const override;
+            std::string Filename() const override;
+            std::string Help() const override;
+            FlagFastTypeId TypeId() const override;
+            bool IsSpecifiedOnCommandLine() const override
+                ABSL_LOCKS_EXCLUDED(*DataGuard());
+            std::string DefaultValue() const override ABSL_LOCKS_EXCLUDED(*DataGuard());
+            std::string CurrentValue() const override ABSL_LOCKS_EXCLUDED(*DataGuard());
+            bool ValidateInputValue(absl::string_view value) const override
+                ABSL_LOCKS_EXCLUDED(*DataGuard());
+            void CheckDefaultValueParsingRoundtrip() const override
+                ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+            int64_t ModificationCount() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+
+            // Interfaces to save and restore flags to/from persistent state.
+            // Returns current flag state or nullptr if flag does not support
+            // saving and restoring a state.
+            std::unique_ptr<FlagStateInterface> SaveState() override
+                ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+            // Restores the flag state to the supplied state object. If there is
+            // nothing to restore returns false. Otherwise returns true.
+            bool RestoreState(const FlagState& flag_state)
+                ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+            bool ParseFrom(absl::string_view value, FlagSettingMode set_mode, ValueSource source, std::string& error) override
+                ABSL_LOCKS_EXCLUDED(*DataGuard());
+
+            // Immutable flag's state.
+
+            // Flags name passed to ABSL_FLAG as second arg.
+            const char* const name_;
+            // The file name where ABSL_FLAG resides.
+            const char* const filename_;
+            // Type-specific operations "vtable".
+            const FlagOpFn op_;
+            // Help message literal or function to generate it.
+            const FlagHelpMsg help_;
+            // Indicates if help message was supplied as literal or generator func.
+            const uint8_t help_source_kind_ : 1;
+            // Kind of storage this flag is using for the flag's value.
+            const uint8_t value_storage_kind_ : 2;
+
+            uint8_t : 0;  // The bytes containing the const bitfields must not be
+                          // shared with bytes containing the mutable bitfields.
+
+            // Mutable flag's state (guarded by `data_guard_`).
+
+            // def_kind_ is not guard by DataGuard() since it is accessed in Init without
+            // locks.
+            uint8_t def_kind_ : 2;
+            // Has this flag's value been modified?
+            bool modified_ : 1 ABSL_GUARDED_BY(*DataGuard());
+            // Has this flag been specified on command line.
+            bool on_command_line_ : 1 ABSL_GUARDED_BY(*DataGuard());
+
+            // Unique tag for absl::call_once call to initialize this flag.
+            absl::once_flag init_control_;
+
+            // Sequence lock / mutation counter.
+            flags_internal::SequenceLock seq_lock_;
+
+            // Optional flag's callback and absl::Mutex to guard the invocations.
+            FlagCallback* callback_ ABSL_GUARDED_BY(*DataGuard());
+            // Either a pointer to the function generating the default value based on the
+            // value specified in ABSL_FLAG or pointer to the dynamically set default
+            // value via SetCommandLineOptionWithMode. def_kind_ is used to distinguish
+            // these two cases.
+            FlagDefaultSrc default_value_;
+
+            // This is reserved space for an absl::Mutex to guard flag data. It will be
+            // initialized in FlagImpl::Init via placement new.
+            // We can't use "absl::Mutex data_guard_", since this class is not literal.
+            // We do not want to use "absl::Mutex* data_guard_", since this would require
+            // heap allocation during initialization, which is both slows program startup
+            // and can fail. Using reserved space + placement new allows us to avoid both
+            // problems.
+            alignas(absl::Mutex) mutable char data_guard_[sizeof(absl::Mutex)];
+        };
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // The Flag object parameterized by the flag's value type. This class implements
+        // flag reflection handle interface.
+
+        template<typename T>
+        class Flag
+        {
+        public:
+            constexpr Flag(const char* name, const char* filename, FlagHelpArg help, const FlagDefaultArg default_arg) :
+                impl_(name, filename, &FlagOps<T>, help, flags_internal::StorageKind<T>(), default_arg),
+                value_()
+            {
+            }
+
+            // CommandLineFlag interface
+            absl::string_view Name() const
+            {
+                return impl_.Name();
+            }
+            std::string Filename() const
+            {
+                return impl_.Filename();
+            }
+            std::string Help() const
+            {
+                return impl_.Help();
+            }
+            // Do not use. To be removed.
+            bool IsSpecifiedOnCommandLine() const
+            {
+                return impl_.IsSpecifiedOnCommandLine();
+            }
+            std::string DefaultValue() const
+            {
+                return impl_.DefaultValue();
+            }
+            std::string CurrentValue() const
+            {
+                return impl_.CurrentValue();
+            }
+
+        private:
+            template<typename, bool>
+            friend class FlagRegistrar;
+            friend class FlagImplPeer;
+
+            T Get() const
+            {
+                // See implementation notes in CommandLineFlag::Get().
+                union U
+                {
+                    T value;
+                    U()
+                    {
+                    }
+                    ~U()
+                    {
+                        value.~T();
+                    }
+                };
+                U u;
 
 #if !defined(NDEBUG)
-    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+                impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
 #endif
 
-    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
-      impl_.Read(&u.value);
-    }
-    return std::move(u.value);
-  }
-  void Set(const T& v) {
-    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
-    impl_.Write(&v);
-  }
-
-  // Access to the reflection.
-  const CommandLineFlag& Reflect() const { return impl_; }
-
-  // Flag's data
-  // The implementation depends on value_ field to be placed exactly after the
-  // impl_ field, so that impl_ can figure out the offset to the value and
-  // access it.
-  FlagImpl impl_;
-  FlagValue<T> value_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Trampoline for friend access
-
-class FlagImplPeer {
- public:
-  template <typename T, typename FlagType>
-  static T InvokeGet(const FlagType& flag) {
-    return flag.Get();
-  }
-  template <typename FlagType, typename T>
-  static void InvokeSet(FlagType& flag, const T& v) {
-    flag.Set(v);
-  }
-  template <typename FlagType>
-  static const CommandLineFlag& InvokeReflect(const FlagType& f) {
-    return f.Reflect();
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Implementation of Flag value specific operations routine.
-template <typename T>
-void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
-  switch (op) {
-    case FlagOp::kAlloc: {
-      std::allocator<T> alloc;
-      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
-    }
-    case FlagOp::kDelete: {
-      T* p = static_cast<T*>(v2);
-      p->~T();
-      std::allocator<T> alloc;
-      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
-      return nullptr;
-    }
-    case FlagOp::kCopy:
-      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
-      return nullptr;
-    case FlagOp::kCopyConstruct:
-      new (v2) T(*static_cast<const T*>(v1));
-      return nullptr;
-    case FlagOp::kSizeof:
-      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
-    case FlagOp::kFastTypeId:
-      return const_cast<void*>(base_internal::FastTypeId<T>());
-    case FlagOp::kRuntimeTypeId:
-      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
-    case FlagOp::kParse: {
-      // Initialize the temporary instance of type T based on current value in
-      // destination (which is going to be flag's default value).
-      T temp(*static_cast<T*>(v2));
-      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
-                              static_cast<std::string*>(v3))) {
-        return nullptr;
-      }
-      *static_cast<T*>(v2) = std::move(temp);
-      return v2;
-    }
-    case FlagOp::kUnparse:
-      *static_cast<std::string*>(v2) =
-          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
-      return nullptr;
-    case FlagOp::kValueOffset: {
-      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
-      // offset of the data.
-      size_t round_to = alignof(FlagValue<T>);
-      size_t offset =
-          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
-      return reinterpret_cast<void*>(offset);
-    }
-  }
-  return nullptr;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// This class facilitates Flag object registration and tail expression-based
-// flag definition, for example:
-// ABSL_FLAG(int, foo, 42, "Foo help").OnUpdate(NotifyFooWatcher);
-struct FlagRegistrarEmpty {};
-template <typename T, bool do_register>
-class FlagRegistrar {
- public:
-  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
-    if (do_register)
-      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
-  }
-
-  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
-    flag_.impl_.SetCallback(cb);
-    return *this;
-  }
-
-  // Make the registrar "die" gracefully as an empty struct on a line where
-  // registration happens. Registrar objects are intended to live only as
-  // temporary.
-  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
-
- private:
-  Flag<T>& flag_;  // Flag being registered (not owned).
-};
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+                if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value)))
+                {
+                    impl_.Read(&u.value);
+                }
+                return std::move(u.value);
+            }
+            void Set(const T& v)
+            {
+                impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
+                impl_.Write(&v);
+            }
+
+            // Access to the reflection.
+            const CommandLineFlag& Reflect() const
+            {
+                return impl_;
+            }
+
+            // Flag's data
+            // The implementation depends on value_ field to be placed exactly after the
+            // impl_ field, so that impl_ can figure out the offset to the value and
+            // access it.
+            FlagImpl impl_;
+            FlagValue<T> value_;
+        };
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Trampoline for friend access
+
+        class FlagImplPeer
+        {
+        public:
+            template<typename T, typename FlagType>
+            static T InvokeGet(const FlagType& flag)
+            {
+                return flag.Get();
+            }
+            template<typename FlagType, typename T>
+            static void InvokeSet(FlagType& flag, const T& v)
+            {
+                flag.Set(v);
+            }
+            template<typename FlagType>
+            static const CommandLineFlag& InvokeReflect(const FlagType& f)
+            {
+                return f.Reflect();
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // Implementation of Flag value specific operations routine.
+        template<typename T>
+        void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3)
+        {
+            switch (op)
+            {
+                case FlagOp::kAlloc:
+                    {
+                        std::allocator<T> alloc;
+                        return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
+                    }
+                case FlagOp::kDelete:
+                    {
+                        T* p = static_cast<T*>(v2);
+                        p->~T();
+                        std::allocator<T> alloc;
+                        std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
+                        return nullptr;
+                    }
+                case FlagOp::kCopy:
+                    *static_cast<T*>(v2) = *static_cast<const T*>(v1);
+                    return nullptr;
+                case FlagOp::kCopyConstruct:
+                    new (v2) T(*static_cast<const T*>(v1));
+                    return nullptr;
+                case FlagOp::kSizeof:
+                    return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
+                case FlagOp::kFastTypeId:
+                    return const_cast<void*>(base_internal::FastTypeId<T>());
+                case FlagOp::kRuntimeTypeId:
+                    return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
+                case FlagOp::kParse:
+                    {
+                        // Initialize the temporary instance of type T based on current value in
+                        // destination (which is going to be flag's default value).
+                        T temp(*static_cast<T*>(v2));
+                        if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp, static_cast<std::string*>(v3)))
+                        {
+                            return nullptr;
+                        }
+                        *static_cast<T*>(v2) = std::move(temp);
+                        return v2;
+                    }
+                case FlagOp::kUnparse:
+                    *static_cast<std::string*>(v2) =
+                        absl::UnparseFlag<T>(*static_cast<const T*>(v1));
+                    return nullptr;
+                case FlagOp::kValueOffset:
+                    {
+                        // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
+                        // offset of the data.
+                        size_t round_to = alignof(FlagValue<T>);
+                        size_t offset =
+                            (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
+                        return reinterpret_cast<void*>(offset);
+                    }
+            }
+            return nullptr;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // This class facilitates Flag object registration and tail expression-based
+        // flag definition, for example:
+        // ABSL_FLAG(int, foo, 42, "Foo help").OnUpdate(NotifyFooWatcher);
+        struct FlagRegistrarEmpty
+        {
+        };
+        template<typename T, bool do_register>
+        class FlagRegistrar
+        {
+        public:
+            explicit FlagRegistrar(Flag<T>& flag, const char* filename) :
+                flag_(flag)
+            {
+                if (do_register)
+                    flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
+            }
+
+            FlagRegistrar OnUpdate(FlagCallbackFunc cb) &&
+            {
+                flag_.impl_.SetCallback(cb);
+                return *this;
+            }
+
+            // Make the registrar "die" gracefully as an empty struct on a line where
+            // registration happens. Registrar objects are intended to live only as
+            // temporary.
+            operator FlagRegistrarEmpty() const
+            {
+                return {};
+            }  // NOLINT
+
+        private:
+            Flag<T>& flag_;  // Flag being registered (not owned).
+        };
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_FLAG_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/parse.h b/CAPI/cpp/grpc/include/absl/flags/internal/parse.h
index de706c8..5340dbe 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/parse.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/parse.h
@@ -28,32 +28,40 @@ ABSL_DECLARE_FLAG(std::vector<std::string>, fromenv);
 ABSL_DECLARE_FLAG(std::vector<std::string>, tryfromenv);
 ABSL_DECLARE_FLAG(std::vector<std::string>, undefok);
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-enum class ArgvListAction { kRemoveParsedArgs, kKeepParsedArgs };
-enum class UsageFlagsAction { kHandleUsage, kIgnoreUsage };
-enum class OnUndefinedFlag {
-  kIgnoreUndefined,
-  kReportUndefined,
-  kAbortIfUndefined
-};
-
-std::vector<char*> ParseCommandLineImpl(int argc, char* argv[],
-                                        ArgvListAction arg_list_act,
-                                        UsageFlagsAction usage_flag_act,
-                                        OnUndefinedFlag on_undef_flag);
-
-// --------------------------------------------------------------------
-// Inspect original command line
-
-// Returns true if flag with specified name was either present on the original
-// command line or specified in flag file present on the original command line.
-bool WasPresentOnCommandLine(absl::string_view flag_name);
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+
+        enum class ArgvListAction
+        {
+            kRemoveParsedArgs,
+            kKeepParsedArgs
+        };
+        enum class UsageFlagsAction
+        {
+            kHandleUsage,
+            kIgnoreUsage
+        };
+        enum class OnUndefinedFlag
+        {
+            kIgnoreUndefined,
+            kReportUndefined,
+            kAbortIfUndefined
+        };
+
+        std::vector<char*> ParseCommandLineImpl(int argc, char* argv[], ArgvListAction arg_list_act, UsageFlagsAction usage_flag_act, OnUndefinedFlag on_undef_flag);
+
+        // --------------------------------------------------------------------
+        // Inspect original command line
+
+        // Returns true if flag with specified name was either present on the original
+        // command line or specified in flag file present on the original command line.
+        bool WasPresentOnCommandLine(absl::string_view flag_name);
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_PARSE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/path_util.h b/CAPI/cpp/grpc/include/absl/flags/internal/path_util.h
index a6594d3..c80eb59 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/path_util.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/path_util.h
@@ -19,44 +19,44 @@
 #include "absl/base/config.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// A portable interface that returns the basename of the filename passed as an
-// argument. It is similar to basename(3)
-// <https://linux.die.net/man/3/basename>.
-// For example:
-//     flags_internal::Basename("a/b/prog/file.cc")
-// returns "file.cc"
-//     flags_internal::Basename("file.cc")
-// returns "file.cc"
-inline absl::string_view Basename(absl::string_view filename) {
-  auto last_slash_pos = filename.find_last_of("/\\");
-
-  return last_slash_pos == absl::string_view::npos
-             ? filename
-             : filename.substr(last_slash_pos + 1);
-}
-
-// A portable interface that returns the directory name of the filename
-// passed as an argument, including the trailing slash.
-// Returns the empty string if a slash is not found in the input file name.
-// For example:
-//      flags_internal::Package("a/b/prog/file.cc")
-// returns "a/b/prog/"
-//      flags_internal::Package("file.cc")
-// returns ""
-inline absl::string_view Package(absl::string_view filename) {
-  auto last_slash_pos = filename.find_last_of("/\\");
-
-  return last_slash_pos == absl::string_view::npos
-             ? absl::string_view()
-             : filename.substr(0, last_slash_pos + 1);
-}
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+
+        // A portable interface that returns the basename of the filename passed as an
+        // argument. It is similar to basename(3)
+        // <https://linux.die.net/man/3/basename>.
+        // For example:
+        //     flags_internal::Basename("a/b/prog/file.cc")
+        // returns "file.cc"
+        //     flags_internal::Basename("file.cc")
+        // returns "file.cc"
+        inline absl::string_view Basename(absl::string_view filename)
+        {
+            auto last_slash_pos = filename.find_last_of("/\\");
+
+            return last_slash_pos == absl::string_view::npos ? filename : filename.substr(last_slash_pos + 1);
+        }
+
+        // A portable interface that returns the directory name of the filename
+        // passed as an argument, including the trailing slash.
+        // Returns the empty string if a slash is not found in the input file name.
+        // For example:
+        //      flags_internal::Package("a/b/prog/file.cc")
+        // returns "a/b/prog/"
+        //      flags_internal::Package("file.cc")
+        // returns ""
+        inline absl::string_view Package(absl::string_view filename)
+        {
+            auto last_slash_pos = filename.find_last_of("/\\");
+
+            return last_slash_pos == absl::string_view::npos ? absl::string_view() : filename.substr(0, last_slash_pos + 1);
+        }
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_PATH_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/private_handle_accessor.h b/CAPI/cpp/grpc/include/absl/flags/internal/private_handle_accessor.h
index c64435c..dcbd4c1 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/private_handle_accessor.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/private_handle_accessor.h
@@ -24,38 +24,38 @@
 #include "absl/flags/internal/commandlineflag.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// This class serves as a trampoline to access private methods of
-// CommandLineFlag. This class is intended for use exclusively internally inside
-// of the Abseil Flags implementation.
-class PrivateHandleAccessor {
- public:
-  // Access to CommandLineFlag::TypeId.
-  static FlagFastTypeId TypeId(const CommandLineFlag& flag);
-
-  // Access to CommandLineFlag::SaveState.
-  static std::unique_ptr<FlagStateInterface> SaveState(CommandLineFlag& flag);
-
-  // Access to CommandLineFlag::IsSpecifiedOnCommandLine.
-  static bool IsSpecifiedOnCommandLine(const CommandLineFlag& flag);
-
-  // Access to CommandLineFlag::ValidateInputValue.
-  static bool ValidateInputValue(const CommandLineFlag& flag,
-                                 absl::string_view value);
-
-  // Access to CommandLineFlag::CheckDefaultValueParsingRoundtrip.
-  static void CheckDefaultValueParsingRoundtrip(const CommandLineFlag& flag);
-
-  static bool ParseFrom(CommandLineFlag& flag, absl::string_view value,
-                        flags_internal::FlagSettingMode set_mode,
-                        flags_internal::ValueSource source, std::string& error);
-};
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+
+        // This class serves as a trampoline to access private methods of
+        // CommandLineFlag. This class is intended for use exclusively internally inside
+        // of the Abseil Flags implementation.
+        class PrivateHandleAccessor
+        {
+        public:
+            // Access to CommandLineFlag::TypeId.
+            static FlagFastTypeId TypeId(const CommandLineFlag& flag);
+
+            // Access to CommandLineFlag::SaveState.
+            static std::unique_ptr<FlagStateInterface> SaveState(CommandLineFlag& flag);
+
+            // Access to CommandLineFlag::IsSpecifiedOnCommandLine.
+            static bool IsSpecifiedOnCommandLine(const CommandLineFlag& flag);
+
+            // Access to CommandLineFlag::ValidateInputValue.
+            static bool ValidateInputValue(const CommandLineFlag& flag, absl::string_view value);
+
+            // Access to CommandLineFlag::CheckDefaultValueParsingRoundtrip.
+            static void CheckDefaultValueParsingRoundtrip(const CommandLineFlag& flag);
+
+            static bool ParseFrom(CommandLineFlag& flag, absl::string_view value, flags_internal::FlagSettingMode set_mode, flags_internal::ValueSource source, std::string& error);
+        };
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_PRIVATE_HANDLE_ACCESSOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/program_name.h b/CAPI/cpp/grpc/include/absl/flags/internal/program_name.h
index b99b94f..6e983d1 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/program_name.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/program_name.h
@@ -24,27 +24,29 @@
 // --------------------------------------------------------------------
 // Program name
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// Returns program invocation name or "UNKNOWN" if `SetProgramInvocationName()`
-// is never called. At the moment this is always set to argv[0] as part of
-// library initialization.
-std::string ProgramInvocationName();
-
-// Returns base name for program invocation name. For example, if
-//   ProgramInvocationName() == "a/b/mybinary"
-// then
-//   ShortProgramInvocationName() == "mybinary"
-std::string ShortProgramInvocationName();
-
-// Sets program invocation name to a new value. Should only be called once
-// during program initialization, before any threads are spawned.
-void SetProgramInvocationName(absl::string_view prog_name_str);
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+
+        // Returns program invocation name or "UNKNOWN" if `SetProgramInvocationName()`
+        // is never called. At the moment this is always set to argv[0] as part of
+        // library initialization.
+        std::string ProgramInvocationName();
+
+        // Returns base name for program invocation name. For example, if
+        //   ProgramInvocationName() == "a/b/mybinary"
+        // then
+        //   ShortProgramInvocationName() == "mybinary"
+        std::string ShortProgramInvocationName();
+
+        // Sets program invocation name to a new value. Should only be called once
+        // during program initialization, before any threads are spawned.
+        void SetProgramInvocationName(absl::string_view prog_name_str);
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_PROGRAM_NAME_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/registry.h b/CAPI/cpp/grpc/include/absl/flags/internal/registry.h
index 4b68c85..72d9f74 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/registry.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/registry.h
@@ -26,72 +26,76 @@
 // --------------------------------------------------------------------
 // Global flags registry API.
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// Executes specified visitor for each non-retired flag in the registry. While
-// callback are executed, the registry is locked and can't be changed.
-void ForEachFlag(std::function<void(CommandLineFlag&)> visitor);
-
-//-----------------------------------------------------------------------------
-
-bool RegisterCommandLineFlag(CommandLineFlag&, const char* filename);
-
-void FinalizeRegistry();
-
-//-----------------------------------------------------------------------------
-// Retired registrations:
-//
-// Retired flag registrations are treated specially. A 'retired' flag is
-// provided only for compatibility with automated invocations that still
-// name it.  A 'retired' flag:
-//   - is not bound to a C++ FLAGS_ reference.
-//   - has a type and a value, but that value is intentionally inaccessible.
-//   - does not appear in --help messages.
-//   - is fully supported by _all_ flag parsing routines.
-//   - consumes args normally, and complains about type mismatches in its
-//     argument.
-//   - emits a complaint but does not die (e.g. LOG(ERROR)) if it is
-//     accessed by name through the flags API for parsing or otherwise.
-//
-// The registrations for a flag happen in an unspecified order as the
-// initializers for the namespace-scope objects of a program are run.
-// Any number of weak registrations for a flag can weakly define the flag.
-// One non-weak registration will upgrade the flag from weak to non-weak.
-// Further weak registrations of a non-weak flag are ignored.
-//
-// This mechanism is designed to support moving dead flags into a
-// 'graveyard' library.  An example migration:
-//
-//   0: Remove references to this FLAGS_flagname in the C++ codebase.
-//   1: Register as 'retired' in old_lib.
-//   2: Make old_lib depend on graveyard.
-//   3: Add a redundant 'retired' registration to graveyard.
-//   4: Remove the old_lib 'retired' registration.
-//   5: Eventually delete the graveyard registration entirely.
-//
-
-// Retire flag with name "name" and type indicated by ops.
-void Retire(const char* name, FlagFastTypeId type_id, char* buf);
-
-constexpr size_t kRetiredFlagObjSize = 3 * sizeof(void*);
-constexpr size_t kRetiredFlagObjAlignment = alignof(void*);
-
-// Registered a retired flag with name 'flag_name' and type 'T'.
-template <typename T>
-class RetiredFlag {
- public:
-  void Retire(const char* flag_name) {
-    flags_internal::Retire(flag_name, base_internal::FastTypeId<T>(), buf_);
-  }
-
- private:
-  alignas(kRetiredFlagObjAlignment) char buf_[kRetiredFlagObjSize];
-};
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+
+        // Executes specified visitor for each non-retired flag in the registry. While
+        // callback are executed, the registry is locked and can't be changed.
+        void ForEachFlag(std::function<void(CommandLineFlag&)> visitor);
+
+        //-----------------------------------------------------------------------------
+
+        bool RegisterCommandLineFlag(CommandLineFlag&, const char* filename);
+
+        void FinalizeRegistry();
+
+        //-----------------------------------------------------------------------------
+        // Retired registrations:
+        //
+        // Retired flag registrations are treated specially. A 'retired' flag is
+        // provided only for compatibility with automated invocations that still
+        // name it.  A 'retired' flag:
+        //   - is not bound to a C++ FLAGS_ reference.
+        //   - has a type and a value, but that value is intentionally inaccessible.
+        //   - does not appear in --help messages.
+        //   - is fully supported by _all_ flag parsing routines.
+        //   - consumes args normally, and complains about type mismatches in its
+        //     argument.
+        //   - emits a complaint but does not die (e.g. LOG(ERROR)) if it is
+        //     accessed by name through the flags API for parsing or otherwise.
+        //
+        // The registrations for a flag happen in an unspecified order as the
+        // initializers for the namespace-scope objects of a program are run.
+        // Any number of weak registrations for a flag can weakly define the flag.
+        // One non-weak registration will upgrade the flag from weak to non-weak.
+        // Further weak registrations of a non-weak flag are ignored.
+        //
+        // This mechanism is designed to support moving dead flags into a
+        // 'graveyard' library.  An example migration:
+        //
+        //   0: Remove references to this FLAGS_flagname in the C++ codebase.
+        //   1: Register as 'retired' in old_lib.
+        //   2: Make old_lib depend on graveyard.
+        //   3: Add a redundant 'retired' registration to graveyard.
+        //   4: Remove the old_lib 'retired' registration.
+        //   5: Eventually delete the graveyard registration entirely.
+        //
+
+        // Retire flag with name "name" and type indicated by ops.
+        void Retire(const char* name, FlagFastTypeId type_id, char* buf);
+
+        constexpr size_t kRetiredFlagObjSize = 3 * sizeof(void*);
+        constexpr size_t kRetiredFlagObjAlignment = alignof(void*);
+
+        // Registered a retired flag with name 'flag_name' and type 'T'.
+        template<typename T>
+        class RetiredFlag
+        {
+        public:
+            void Retire(const char* flag_name)
+            {
+                flags_internal::Retire(flag_name, base_internal::FastTypeId<T>(), buf_);
+            }
+
+        private:
+            alignas(kRetiredFlagObjAlignment) char buf_[kRetiredFlagObjSize];
+        };
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_REGISTRY_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/sequence_lock.h b/CAPI/cpp/grpc/include/absl/flags/internal/sequence_lock.h
index 36318ab..893258c 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/sequence_lock.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/sequence_lock.h
@@ -25,163 +25,180 @@
 
 #include "absl/base/optimization.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// Align 'x' up to the nearest 'align' bytes.
-inline constexpr size_t AlignUp(size_t x, size_t align) {
-  return align * ((x + align - 1) / align);
-}
-
-// A SequenceLock implements lock-free reads. A sequence counter is incremented
-// before and after each write, and readers access the counter before and after
-// accessing the protected data. If the counter is verified to not change during
-// the access, and the sequence counter value was even, then the reader knows
-// that the read was race-free and valid. Otherwise, the reader must fall back
-// to a Mutex-based code path.
-//
-// This particular SequenceLock starts in an "uninitialized" state in which
-// TryRead() returns false. It must be enabled by calling MarkInitialized().
-// This serves as a marker that the associated flag value has not yet been
-// initialized and a slow path needs to be taken.
-//
-// The memory reads and writes protected by this lock must use the provided
-// `TryRead()` and `Write()` functions. These functions behave similarly to
-// `memcpy()`, with one oddity: the protected data must be an array of
-// `std::atomic<uint64>`. This is to comply with the C++ standard, which
-// considers data races on non-atomic objects to be undefined behavior. See "Can
-// Seqlocks Get Along With Programming Language Memory Models?"[1] by Hans J.
-// Boehm for more details.
-//
-// [1] https://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf
-class SequenceLock {
- public:
-  constexpr SequenceLock() : lock_(kUninitialized) {}
-
-  // Mark that this lock is ready for use.
-  void MarkInitialized() {
-    assert(lock_.load(std::memory_order_relaxed) == kUninitialized);
-    lock_.store(0, std::memory_order_release);
-  }
-
-  // Copy "size" bytes of data from "src" to "dst", protected as a read-side
-  // critical section of the sequence lock.
-  //
-  // Unlike traditional sequence lock implementations which loop until getting a
-  // clean read, this implementation returns false in the case of concurrent
-  // calls to `Write`. In such a case, the caller should fall back to a
-  // locking-based slow path.
-  //
-  // Returns false if the sequence lock was not yet marked as initialized.
-  //
-  // NOTE: If this returns false, "dst" may be overwritten with undefined
-  // (potentially uninitialized) data.
-  bool TryRead(void* dst, const std::atomic<uint64_t>* src, size_t size) const {
-    // Acquire barrier ensures that no loads done by f() are reordered
-    // above the first load of the sequence counter.
-    int64_t seq_before = lock_.load(std::memory_order_acquire);
-    if (ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false;
-    RelaxedCopyFromAtomic(dst, src, size);
-    // Another acquire fence ensures that the load of 'lock_' below is
-    // strictly ordered after the RelaxedCopyToAtomic call above.
-    std::atomic_thread_fence(std::memory_order_acquire);
-    int64_t seq_after = lock_.load(std::memory_order_relaxed);
-    return ABSL_PREDICT_TRUE(seq_before == seq_after);
-  }
-
-  // Copy "size" bytes from "src" to "dst" as a write-side critical section
-  // of the sequence lock. Any concurrent readers will be forced to retry
-  // until they get a read that does not conflict with this write.
-  //
-  // This call must be externally synchronized against other calls to Write,
-  // but may proceed concurrently with reads.
-  void Write(std::atomic<uint64_t>* dst, const void* src, size_t size) {
-    // We can use relaxed instructions to increment the counter since we
-    // are extenally synchronized. The std::atomic_thread_fence below
-    // ensures that the counter updates don't get interleaved with the
-    // copy to the data.
-    int64_t orig_seq = lock_.load(std::memory_order_relaxed);
-    assert((orig_seq & 1) == 0);  // Must be initially unlocked.
-    lock_.store(orig_seq + 1, std::memory_order_relaxed);
-
-    // We put a release fence between update to lock_ and writes to shared data.
-    // Thus all stores to shared data are effectively release operations and
-    // update to lock_ above cannot be re-ordered past any of them. Note that
-    // this barrier is not for the fetch_add above.  A release barrier for the
-    // fetch_add would be before it, not after.
-    std::atomic_thread_fence(std::memory_order_release);
-    RelaxedCopyToAtomic(dst, src, size);
-    // "Release" semantics ensure that none of the writes done by
-    // RelaxedCopyToAtomic() can be reordered after the following modification.
-    lock_.store(orig_seq + 2, std::memory_order_release);
-  }
-
-  // Return the number of times that Write() has been called.
-  //
-  // REQUIRES: This must be externally synchronized against concurrent calls to
-  // `Write()` or `IncrementModificationCount()`.
-  // REQUIRES: `MarkInitialized()` must have been previously called.
-  int64_t ModificationCount() const {
-    int64_t val = lock_.load(std::memory_order_relaxed);
-    assert(val != kUninitialized && (val & 1) == 0);
-    return val / 2;
-  }
-
-  // REQUIRES: This must be externally synchronized against concurrent calls to
-  // `Write()` or `ModificationCount()`.
-  // REQUIRES: `MarkInitialized()` must have been previously called.
-  void IncrementModificationCount() {
-    int64_t val = lock_.load(std::memory_order_relaxed);
-    assert(val != kUninitialized);
-    lock_.store(val + 2, std::memory_order_relaxed);
-  }
-
- private:
-  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
-  // atomics.
-  static void RelaxedCopyFromAtomic(void* dst, const std::atomic<uint64_t>* src,
-                                    size_t size) {
-    char* dst_byte = static_cast<char*>(dst);
-    while (size >= sizeof(uint64_t)) {
-      uint64_t word = src->load(std::memory_order_relaxed);
-      std::memcpy(dst_byte, &word, sizeof(word));
-      dst_byte += sizeof(word);
-      src++;
-      size -= sizeof(word);
-    }
-    if (size > 0) {
-      uint64_t word = src->load(std::memory_order_relaxed);
-      std::memcpy(dst_byte, &word, size);
-    }
-  }
-
-  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
-  // atomics.
-  static void RelaxedCopyToAtomic(std::atomic<uint64_t>* dst, const void* src,
-                                  size_t size) {
-    const char* src_byte = static_cast<const char*>(src);
-    while (size >= sizeof(uint64_t)) {
-      uint64_t word;
-      std::memcpy(&word, src_byte, sizeof(word));
-      dst->store(word, std::memory_order_relaxed);
-      src_byte += sizeof(word);
-      dst++;
-      size -= sizeof(word);
-    }
-    if (size > 0) {
-      uint64_t word = 0;
-      std::memcpy(&word, src_byte, size);
-      dst->store(word, std::memory_order_relaxed);
-    }
-  }
-
-  static constexpr int64_t kUninitialized = -1;
-  std::atomic<int64_t> lock_;
-};
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+
+        // Align 'x' up to the nearest 'align' bytes.
+        inline constexpr size_t AlignUp(size_t x, size_t align)
+        {
+            return align * ((x + align - 1) / align);
+        }
+
+        // A SequenceLock implements lock-free reads. A sequence counter is incremented
+        // before and after each write, and readers access the counter before and after
+        // accessing the protected data. If the counter is verified to not change during
+        // the access, and the sequence counter value was even, then the reader knows
+        // that the read was race-free and valid. Otherwise, the reader must fall back
+        // to a Mutex-based code path.
+        //
+        // This particular SequenceLock starts in an "uninitialized" state in which
+        // TryRead() returns false. It must be enabled by calling MarkInitialized().
+        // This serves as a marker that the associated flag value has not yet been
+        // initialized and a slow path needs to be taken.
+        //
+        // The memory reads and writes protected by this lock must use the provided
+        // `TryRead()` and `Write()` functions. These functions behave similarly to
+        // `memcpy()`, with one oddity: the protected data must be an array of
+        // `std::atomic<uint64>`. This is to comply with the C++ standard, which
+        // considers data races on non-atomic objects to be undefined behavior. See "Can
+        // Seqlocks Get Along With Programming Language Memory Models?"[1] by Hans J.
+        // Boehm for more details.
+        //
+        // [1] https://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf
+        class SequenceLock
+        {
+        public:
+            constexpr SequenceLock() :
+                lock_(kUninitialized)
+            {
+            }
+
+            // Mark that this lock is ready for use.
+            void MarkInitialized()
+            {
+                assert(lock_.load(std::memory_order_relaxed) == kUninitialized);
+                lock_.store(0, std::memory_order_release);
+            }
+
+            // Copy "size" bytes of data from "src" to "dst", protected as a read-side
+            // critical section of the sequence lock.
+            //
+            // Unlike traditional sequence lock implementations which loop until getting a
+            // clean read, this implementation returns false in the case of concurrent
+            // calls to `Write`. In such a case, the caller should fall back to a
+            // locking-based slow path.
+            //
+            // Returns false if the sequence lock was not yet marked as initialized.
+            //
+            // NOTE: If this returns false, "dst" may be overwritten with undefined
+            // (potentially uninitialized) data.
+            bool TryRead(void* dst, const std::atomic<uint64_t>* src, size_t size) const
+            {
+                // Acquire barrier ensures that no loads done by f() are reordered
+                // above the first load of the sequence counter.
+                int64_t seq_before = lock_.load(std::memory_order_acquire);
+                if (ABSL_PREDICT_FALSE(seq_before & 1) == 1)
+                    return false;
+                RelaxedCopyFromAtomic(dst, src, size);
+                // Another acquire fence ensures that the load of 'lock_' below is
+                // strictly ordered after the RelaxedCopyToAtomic call above.
+                std::atomic_thread_fence(std::memory_order_acquire);
+                int64_t seq_after = lock_.load(std::memory_order_relaxed);
+                return ABSL_PREDICT_TRUE(seq_before == seq_after);
+            }
+
+            // Copy "size" bytes from "src" to "dst" as a write-side critical section
+            // of the sequence lock. Any concurrent readers will be forced to retry
+            // until they get a read that does not conflict with this write.
+            //
+            // This call must be externally synchronized against other calls to Write,
+            // but may proceed concurrently with reads.
+            void Write(std::atomic<uint64_t>* dst, const void* src, size_t size)
+            {
+                // We can use relaxed instructions to increment the counter since we
+                // are extenally synchronized. The std::atomic_thread_fence below
+                // ensures that the counter updates don't get interleaved with the
+                // copy to the data.
+                int64_t orig_seq = lock_.load(std::memory_order_relaxed);
+                assert((orig_seq & 1) == 0);  // Must be initially unlocked.
+                lock_.store(orig_seq + 1, std::memory_order_relaxed);
+
+                // We put a release fence between update to lock_ and writes to shared data.
+                // Thus all stores to shared data are effectively release operations and
+                // update to lock_ above cannot be re-ordered past any of them. Note that
+                // this barrier is not for the fetch_add above.  A release barrier for the
+                // fetch_add would be before it, not after.
+                std::atomic_thread_fence(std::memory_order_release);
+                RelaxedCopyToAtomic(dst, src, size);
+                // "Release" semantics ensure that none of the writes done by
+                // RelaxedCopyToAtomic() can be reordered after the following modification.
+                lock_.store(orig_seq + 2, std::memory_order_release);
+            }
+
+            // Return the number of times that Write() has been called.
+            //
+            // REQUIRES: This must be externally synchronized against concurrent calls to
+            // `Write()` or `IncrementModificationCount()`.
+            // REQUIRES: `MarkInitialized()` must have been previously called.
+            int64_t ModificationCount() const
+            {
+                int64_t val = lock_.load(std::memory_order_relaxed);
+                assert(val != kUninitialized && (val & 1) == 0);
+                return val / 2;
+            }
+
+            // REQUIRES: This must be externally synchronized against concurrent calls to
+            // `Write()` or `ModificationCount()`.
+            // REQUIRES: `MarkInitialized()` must have been previously called.
+            void IncrementModificationCount()
+            {
+                int64_t val = lock_.load(std::memory_order_relaxed);
+                assert(val != kUninitialized);
+                lock_.store(val + 2, std::memory_order_relaxed);
+            }
+
+        private:
+            // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
+            // atomics.
+            static void RelaxedCopyFromAtomic(void* dst, const std::atomic<uint64_t>* src, size_t size)
+            {
+                char* dst_byte = static_cast<char*>(dst);
+                while (size >= sizeof(uint64_t))
+                {
+                    uint64_t word = src->load(std::memory_order_relaxed);
+                    std::memcpy(dst_byte, &word, sizeof(word));
+                    dst_byte += sizeof(word);
+                    src++;
+                    size -= sizeof(word);
+                }
+                if (size > 0)
+                {
+                    uint64_t word = src->load(std::memory_order_relaxed);
+                    std::memcpy(dst_byte, &word, size);
+                }
+            }
+
+            // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
+            // atomics.
+            static void RelaxedCopyToAtomic(std::atomic<uint64_t>* dst, const void* src, size_t size)
+            {
+                const char* src_byte = static_cast<const char*>(src);
+                while (size >= sizeof(uint64_t))
+                {
+                    uint64_t word;
+                    std::memcpy(&word, src_byte, sizeof(word));
+                    dst->store(word, std::memory_order_relaxed);
+                    src_byte += sizeof(word);
+                    dst++;
+                    size -= sizeof(word);
+                }
+                if (size > 0)
+                {
+                    uint64_t word = 0;
+                    std::memcpy(&word, src_byte, size);
+                    dst->store(word, std::memory_order_relaxed);
+                }
+            }
+
+            static constexpr int64_t kUninitialized = -1;
+            std::atomic<int64_t> lock_;
+        };
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/internal/usage.h b/CAPI/cpp/grpc/include/absl/flags/internal/usage.h
index c0bcac5..d350789 100644
--- a/CAPI/cpp/grpc/include/absl/flags/internal/usage.h
+++ b/CAPI/cpp/grpc/include/absl/flags/internal/usage.h
@@ -27,78 +27,79 @@
 // --------------------------------------------------------------------
 // Usage reporting interfaces
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// The format to report the help messages in.
-enum class HelpFormat {
-  kHumanReadable,
-};
-
-// Streams the help message describing `flag` to `out`.
-// The default value for `flag` is included in the output.
-void FlagHelp(std::ostream& out, const CommandLineFlag& flag,
-              HelpFormat format = HelpFormat::kHumanReadable);
-
-// Produces the help messages for all flags matching the filter. A flag matches
-// the filter if it is defined in a file with a filename which includes
-// filter string as a substring. You can use '/' and '.' to restrict the
-// matching to a specific file names. For example:
-//   FlagsHelp(out, "/path/to/file.");
-// restricts help to only flags which resides in files named like:
-//  .../path/to/file.<ext>
-// for any extension 'ext'. If the filter is empty this function produces help
-// messages for all flags.
-void FlagsHelp(std::ostream& out, absl::string_view filter,
-               HelpFormat format, absl::string_view program_usage_message);
-
-// --------------------------------------------------------------------
-
-// If any of the 'usage' related command line flags (listed on the bottom of
-// this file) has been set this routine produces corresponding help message in
-// the specified output stream and returns:
-//  0 - if "version" or "only_check_flags" flags were set and handled.
-//  1 - if some other 'usage' related flag was set and handled.
-// -1 - if no usage flags were set on a commmand line.
-// Non negative return values are expected to be used as an exit code for a
-// binary.
-int HandleUsageFlags(std::ostream& out,
-                     absl::string_view program_usage_message);
-
-// --------------------------------------------------------------------
-// Globals representing usage reporting flags
-
-enum class HelpMode {
-  kNone,
-  kImportant,
-  kShort,
-  kFull,
-  kPackage,
-  kMatch,
-  kVersion,
-  kOnlyCheckArgs
-};
-
-// Returns substring to filter help output (--help=substr argument)
-std::string GetFlagsHelpMatchSubstr();
-// Returns the requested help mode.
-HelpMode GetFlagsHelpMode();
-// Returns the requested help format.
-HelpFormat GetFlagsHelpFormat();
-
-// These are corresponding setters to the attributes above.
-void SetFlagsHelpMatchSubstr(absl::string_view);
-void SetFlagsHelpMode(HelpMode);
-void SetFlagsHelpFormat(HelpFormat);
-
-// Deduces usage flags from the input argument in a form --name=value or
-// --name. argument is already split into name and value before we call this
-// function.
-bool DeduceUsageFlags(absl::string_view name, absl::string_view value);
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+
+        // The format to report the help messages in.
+        enum class HelpFormat
+        {
+            kHumanReadable,
+        };
+
+        // Streams the help message describing `flag` to `out`.
+        // The default value for `flag` is included in the output.
+        void FlagHelp(std::ostream& out, const CommandLineFlag& flag, HelpFormat format = HelpFormat::kHumanReadable);
+
+        // Produces the help messages for all flags matching the filter. A flag matches
+        // the filter if it is defined in a file with a filename which includes
+        // filter string as a substring. You can use '/' and '.' to restrict the
+        // matching to a specific file names. For example:
+        //   FlagsHelp(out, "/path/to/file.");
+        // restricts help to only flags which resides in files named like:
+        //  .../path/to/file.<ext>
+        // for any extension 'ext'. If the filter is empty this function produces help
+        // messages for all flags.
+        void FlagsHelp(std::ostream& out, absl::string_view filter, HelpFormat format, absl::string_view program_usage_message);
+
+        // --------------------------------------------------------------------
+
+        // If any of the 'usage' related command line flags (listed on the bottom of
+        // this file) has been set this routine produces corresponding help message in
+        // the specified output stream and returns:
+        //  0 - if "version" or "only_check_flags" flags were set and handled.
+        //  1 - if some other 'usage' related flag was set and handled.
+        // -1 - if no usage flags were set on a commmand line.
+        // Non negative return values are expected to be used as an exit code for a
+        // binary.
+        int HandleUsageFlags(std::ostream& out, absl::string_view program_usage_message);
+
+        // --------------------------------------------------------------------
+        // Globals representing usage reporting flags
+
+        enum class HelpMode
+        {
+            kNone,
+            kImportant,
+            kShort,
+            kFull,
+            kPackage,
+            kMatch,
+            kVersion,
+            kOnlyCheckArgs
+        };
+
+        // Returns substring to filter help output (--help=substr argument)
+        std::string GetFlagsHelpMatchSubstr();
+        // Returns the requested help mode.
+        HelpMode GetFlagsHelpMode();
+        // Returns the requested help format.
+        HelpFormat GetFlagsHelpFormat();
+
+        // These are corresponding setters to the attributes above.
+        void SetFlagsHelpMatchSubstr(absl::string_view);
+        void SetFlagsHelpMode(HelpMode);
+        void SetFlagsHelpFormat(HelpFormat);
+
+        // Deduces usage flags from the input argument in a form --name=value or
+        // --name. argument is already split into name and value before we call this
+        // function.
+        bool DeduceUsageFlags(absl::string_view name, absl::string_view value);
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_INTERNAL_USAGE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/marshalling.h b/CAPI/cpp/grpc/include/absl/flags/marshalling.h
index b1e2ffa..05ed353 100644
--- a/CAPI/cpp/grpc/include/absl/flags/marshalling.h
+++ b/CAPI/cpp/grpc/include/absl/flags/marshalling.h
@@ -210,147 +210,159 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// Forward declaration to be used inside composable flag parse/unparse
-// implementations
-template <typename T>
-inline bool ParseFlag(absl::string_view input, T* dst, std::string* error);
-template <typename T>
-inline std::string UnparseFlag(const T& v);
+    // Forward declaration to be used inside composable flag parse/unparse
+    // implementations
+    template<typename T>
+    inline bool ParseFlag(absl::string_view input, T* dst, std::string* error);
+    template<typename T>
+    inline std::string UnparseFlag(const T& v);
 
-namespace flags_internal {
+    namespace flags_internal
+    {
 
-// Overloads of `AbslParseFlag()` and `AbslUnparseFlag()` for fundamental types.
-bool AbslParseFlag(absl::string_view, bool*, std::string*);
-bool AbslParseFlag(absl::string_view, short*, std::string*);           // NOLINT
-bool AbslParseFlag(absl::string_view, unsigned short*, std::string*);  // NOLINT
-bool AbslParseFlag(absl::string_view, int*, std::string*);             // NOLINT
-bool AbslParseFlag(absl::string_view, unsigned int*, std::string*);    // NOLINT
-bool AbslParseFlag(absl::string_view, long*, std::string*);            // NOLINT
-bool AbslParseFlag(absl::string_view, unsigned long*, std::string*);   // NOLINT
-bool AbslParseFlag(absl::string_view, long long*, std::string*);       // NOLINT
-bool AbslParseFlag(absl::string_view, unsigned long long*,             // NOLINT
-                   std::string*);
-bool AbslParseFlag(absl::string_view, float*, std::string*);
-bool AbslParseFlag(absl::string_view, double*, std::string*);
-bool AbslParseFlag(absl::string_view, std::string*, std::string*);
-bool AbslParseFlag(absl::string_view, std::vector<std::string>*, std::string*);
+        // Overloads of `AbslParseFlag()` and `AbslUnparseFlag()` for fundamental types.
+        bool AbslParseFlag(absl::string_view, bool*, std::string*);
+        bool AbslParseFlag(absl::string_view, short*, std::string*);           // NOLINT
+        bool AbslParseFlag(absl::string_view, unsigned short*, std::string*);  // NOLINT
+        bool AbslParseFlag(absl::string_view, int*, std::string*);             // NOLINT
+        bool AbslParseFlag(absl::string_view, unsigned int*, std::string*);    // NOLINT
+        bool AbslParseFlag(absl::string_view, long*, std::string*);            // NOLINT
+        bool AbslParseFlag(absl::string_view, unsigned long*, std::string*);   // NOLINT
+        bool AbslParseFlag(absl::string_view, long long*, std::string*);       // NOLINT
+        bool AbslParseFlag(absl::string_view, unsigned long long*,             // NOLINT
+                           std::string*);
+        bool AbslParseFlag(absl::string_view, float*, std::string*);
+        bool AbslParseFlag(absl::string_view, double*, std::string*);
+        bool AbslParseFlag(absl::string_view, std::string*, std::string*);
+        bool AbslParseFlag(absl::string_view, std::vector<std::string>*, std::string*);
 
-template <typename T>
-bool AbslParseFlag(absl::string_view text, absl::optional<T>* f,
-                   std::string* err) {
-  if (text.empty()) {
-    *f = absl::nullopt;
-    return true;
-  }
-  T value;
-  if (!absl::ParseFlag(text, &value, err)) return false;
+        template<typename T>
+        bool AbslParseFlag(absl::string_view text, absl::optional<T>* f, std::string* err)
+        {
+            if (text.empty())
+            {
+                *f = absl::nullopt;
+                return true;
+            }
+            T value;
+            if (!absl::ParseFlag(text, &value, err))
+                return false;
 
-  *f = std::move(value);
-  return true;
-}
+            *f = std::move(value);
+            return true;
+        }
 
 #if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
-template <typename T>
-bool AbslParseFlag(absl::string_view text, std::optional<T>* f,
-                   std::string* err) {
-  if (text.empty()) {
-    *f = std::nullopt;
-    return true;
-  }
-  T value;
-  if (!absl::ParseFlag(text, &value, err)) return false;
+        template<typename T>
+        bool AbslParseFlag(absl::string_view text, std::optional<T>* f, std::string* err)
+        {
+            if (text.empty())
+            {
+                *f = std::nullopt;
+                return true;
+            }
+            T value;
+            if (!absl::ParseFlag(text, &value, err))
+                return false;
 
-  *f = std::move(value);
-  return true;
-}
+            *f = std::move(value);
+            return true;
+        }
 #endif
 
-template <typename T>
-bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) {
-  // Comment on next line provides a good compiler error message if T
-  // does not have AbslParseFlag(absl::string_view, T*, std::string*).
-  return AbslParseFlag(input, dst, err);  // Is T missing AbslParseFlag?
-}
+        template<typename T>
+        bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err)
+        {
+            // Comment on next line provides a good compiler error message if T
+            // does not have AbslParseFlag(absl::string_view, T*, std::string*).
+            return AbslParseFlag(input, dst, err);  // Is T missing AbslParseFlag?
+        }
 
-// Strings and std:: containers do not have the same overload resolution
-// considerations as fundamental types. Naming these 'AbslUnparseFlag' means we
-// can avoid the need for additional specializations of Unparse (below).
-std::string AbslUnparseFlag(absl::string_view v);
-std::string AbslUnparseFlag(const std::vector<std::string>&);
+        // Strings and std:: containers do not have the same overload resolution
+        // considerations as fundamental types. Naming these 'AbslUnparseFlag' means we
+        // can avoid the need for additional specializations of Unparse (below).
+        std::string AbslUnparseFlag(absl::string_view v);
+        std::string AbslUnparseFlag(const std::vector<std::string>&);
 
-template <typename T>
-std::string AbslUnparseFlag(const absl::optional<T>& f) {
-  return f.has_value() ? absl::UnparseFlag(*f) : "";
-}
+        template<typename T>
+        std::string AbslUnparseFlag(const absl::optional<T>& f)
+        {
+            return f.has_value() ? absl::UnparseFlag(*f) : "";
+        }
 
 #if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
-template <typename T>
-std::string AbslUnparseFlag(const std::optional<T>& f) {
-  return f.has_value() ? absl::UnparseFlag(*f) : "";
-}
+        template<typename T>
+        std::string AbslUnparseFlag(const std::optional<T>& f)
+        {
+            return f.has_value() ? absl::UnparseFlag(*f) : "";
+        }
 #endif
 
-template <typename T>
-std::string Unparse(const T& v) {
-  // Comment on next line provides a good compiler error message if T does not
-  // have UnparseFlag.
-  return AbslUnparseFlag(v);  // Is T missing AbslUnparseFlag?
-}
+        template<typename T>
+        std::string Unparse(const T& v)
+        {
+            // Comment on next line provides a good compiler error message if T does not
+            // have UnparseFlag.
+            return AbslUnparseFlag(v);  // Is T missing AbslUnparseFlag?
+        }
 
-// Overloads for builtin types.
-std::string Unparse(bool v);
-std::string Unparse(short v);               // NOLINT
-std::string Unparse(unsigned short v);      // NOLINT
-std::string Unparse(int v);                 // NOLINT
-std::string Unparse(unsigned int v);        // NOLINT
-std::string Unparse(long v);                // NOLINT
-std::string Unparse(unsigned long v);       // NOLINT
-std::string Unparse(long long v);           // NOLINT
-std::string Unparse(unsigned long long v);  // NOLINT
-std::string Unparse(float v);
-std::string Unparse(double v);
+        // Overloads for builtin types.
+        std::string Unparse(bool v);
+        std::string Unparse(short v);               // NOLINT
+        std::string Unparse(unsigned short v);      // NOLINT
+        std::string Unparse(int v);                 // NOLINT
+        std::string Unparse(unsigned int v);        // NOLINT
+        std::string Unparse(long v);                // NOLINT
+        std::string Unparse(unsigned long v);       // NOLINT
+        std::string Unparse(long long v);           // NOLINT
+        std::string Unparse(unsigned long long v);  // NOLINT
+        std::string Unparse(float v);
+        std::string Unparse(double v);
 
-}  // namespace flags_internal
+    }  // namespace flags_internal
 
-// ParseFlag()
-//
-// Parses a string value into a flag value of type `T`. Do not add overloads of
-// this function for your type directly; instead, add an `AbslParseFlag()`
-// free function as documented above.
-//
-// Some implementations of `AbslParseFlag()` for types which consist of other,
-// constituent types which already have Abseil flag support, may need to call
-// `absl::ParseFlag()` on those consituent string values. (See above.)
-template <typename T>
-inline bool ParseFlag(absl::string_view input, T* dst, std::string* error) {
-  return flags_internal::InvokeParseFlag(input, dst, error);
-}
+    // ParseFlag()
+    //
+    // Parses a string value into a flag value of type `T`. Do not add overloads of
+    // this function for your type directly; instead, add an `AbslParseFlag()`
+    // free function as documented above.
+    //
+    // Some implementations of `AbslParseFlag()` for types which consist of other,
+    // constituent types which already have Abseil flag support, may need to call
+    // `absl::ParseFlag()` on those consituent string values. (See above.)
+    template<typename T>
+    inline bool ParseFlag(absl::string_view input, T* dst, std::string* error)
+    {
+        return flags_internal::InvokeParseFlag(input, dst, error);
+    }
 
-// UnparseFlag()
-//
-// Unparses a flag value of type `T` into a string value. Do not add overloads
-// of this function for your type directly; instead, add an `AbslUnparseFlag()`
-// free function as documented above.
-//
-// Some implementations of `AbslUnparseFlag()` for types which consist of other,
-// constituent types which already have Abseil flag support, may want to call
-// `absl::UnparseFlag()` on those constituent types. (See above.)
-template <typename T>
-inline std::string UnparseFlag(const T& v) {
-  return flags_internal::Unparse(v);
-}
+    // UnparseFlag()
+    //
+    // Unparses a flag value of type `T` into a string value. Do not add overloads
+    // of this function for your type directly; instead, add an `AbslUnparseFlag()`
+    // free function as documented above.
+    //
+    // Some implementations of `AbslUnparseFlag()` for types which consist of other,
+    // constituent types which already have Abseil flag support, may want to call
+    // `absl::UnparseFlag()` on those constituent types. (See above.)
+    template<typename T>
+    inline std::string UnparseFlag(const T& v)
+    {
+        return flags_internal::Unparse(v);
+    }
 
-// Overloads for `absl::LogSeverity` can't (easily) appear alongside that type's
-// definition because it is layered below flags.  See proper documentation in
-// base/log_severity.h.
-enum class LogSeverity : int;
-bool AbslParseFlag(absl::string_view, absl::LogSeverity*, std::string*);
-std::string AbslUnparseFlag(absl::LogSeverity);
+    // Overloads for `absl::LogSeverity` can't (easily) appear alongside that type's
+    // definition because it is layered below flags.  See proper documentation in
+    // base/log_severity.h.
+    enum class LogSeverity : int;
+    bool AbslParseFlag(absl::string_view, absl::LogSeverity*, std::string*);
+    std::string AbslUnparseFlag(absl::LogSeverity);
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_MARSHALLING_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/parse.h b/CAPI/cpp/grpc/include/absl/flags/parse.h
index 929de2c..275e3c5 100644
--- a/CAPI/cpp/grpc/include/absl/flags/parse.h
+++ b/CAPI/cpp/grpc/include/absl/flags/parse.h
@@ -28,33 +28,34 @@
 #include "absl/base/config.h"
 #include "absl/flags/internal/parse.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// ParseCommandLine()
-//
-// Parses the set of command-line arguments passed in the `argc` (argument
-// count) and `argv[]` (argument vector) parameters from `main()`, assigning
-// values to any defined Abseil flags. (Any arguments passed after the
-// flag-terminating delimiter (`--`) are treated as positional arguments and
-// ignored.)
-//
-// Any command-line flags (and arguments to those flags) are parsed into Abseil
-// Flag values, if those flags are defined. Any undefined flags will either
-// return an error, or be ignored if that flag is designated using `undefok` to
-// indicate "undefined is OK."
-//
-// Any command-line positional arguments not part of any command-line flag (or
-// arguments to a flag) are returned in a vector, with the program invocation
-// name at position 0 of that vector. (Note that this includes positional
-// arguments after the flag-terminating delimiter `--`.)
-//
-// After all flags and flag arguments are parsed, this function looks for any
-// built-in usage flags (e.g. `--help`), and if any were specified, it reports
-// help messages and then exits the program.
-std::vector<char*> ParseCommandLine(int argc, char* argv[]);
+    // ParseCommandLine()
+    //
+    // Parses the set of command-line arguments passed in the `argc` (argument
+    // count) and `argv[]` (argument vector) parameters from `main()`, assigning
+    // values to any defined Abseil flags. (Any arguments passed after the
+    // flag-terminating delimiter (`--`) are treated as positional arguments and
+    // ignored.)
+    //
+    // Any command-line flags (and arguments to those flags) are parsed into Abseil
+    // Flag values, if those flags are defined. Any undefined flags will either
+    // return an error, or be ignored if that flag is designated using `undefok` to
+    // indicate "undefined is OK."
+    //
+    // Any command-line positional arguments not part of any command-line flag (or
+    // arguments to a flag) are returned in a vector, with the program invocation
+    // name at position 0 of that vector. (Note that this includes positional
+    // arguments after the flag-terminating delimiter `--`.)
+    //
+    // After all flags and flag arguments are parsed, this function looks for any
+    // built-in usage flags (e.g. `--help`), and if any were specified, it reports
+    // help messages and then exits the program.
+    std::vector<char*> ParseCommandLine(int argc, char* argv[]);
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_PARSE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/reflection.h b/CAPI/cpp/grpc/include/absl/flags/reflection.h
index e6baf5d..8806abf 100644
--- a/CAPI/cpp/grpc/include/absl/flags/reflection.h
+++ b/CAPI/cpp/grpc/include/absl/flags/reflection.h
@@ -30,61 +30,64 @@
 #include "absl/flags/commandlineflag.h"
 #include "absl/flags/internal/commandlineflag.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-class FlagSaverImpl;
-}  // namespace flags_internal
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace flags_internal
+    {
+        class FlagSaverImpl;
+    }  // namespace flags_internal
 
-// FindCommandLineFlag()
-//
-// Returns the reflection handle of an Abseil flag of the specified name, or
-// `nullptr` if not found. This function will emit a warning if the name of a
-// 'retired' flag is specified.
-absl::CommandLineFlag* FindCommandLineFlag(absl::string_view name);
+    // FindCommandLineFlag()
+    //
+    // Returns the reflection handle of an Abseil flag of the specified name, or
+    // `nullptr` if not found. This function will emit a warning if the name of a
+    // 'retired' flag is specified.
+    absl::CommandLineFlag* FindCommandLineFlag(absl::string_view name);
 
-// Returns current state of the Flags registry in a form of mapping from flag
-// name to a flag reflection handle.
-absl::flat_hash_map<absl::string_view, absl::CommandLineFlag*> GetAllFlags();
+    // Returns current state of the Flags registry in a form of mapping from flag
+    // name to a flag reflection handle.
+    absl::flat_hash_map<absl::string_view, absl::CommandLineFlag*> GetAllFlags();
 
-//------------------------------------------------------------------------------
-// FlagSaver
-//------------------------------------------------------------------------------
-//
-// A FlagSaver object stores the state of flags in the scope where the FlagSaver
-// is defined, allowing modification of those flags within that scope and
-// automatic restoration of the flags to their previous state upon leaving the
-// scope.
-//
-// A FlagSaver can be used within tests to temporarily change the test
-// environment and restore the test case to its previous state.
-//
-// Example:
-//
-//   void MyFunc() {
-//    absl::FlagSaver fs;
-//    ...
-//    absl::SetFlag(&FLAGS_myFlag, otherValue);
-//    ...
-//  } // scope of FlagSaver left, flags return to previous state
-//
-// This class is thread-safe.
+    //------------------------------------------------------------------------------
+    // FlagSaver
+    //------------------------------------------------------------------------------
+    //
+    // A FlagSaver object stores the state of flags in the scope where the FlagSaver
+    // is defined, allowing modification of those flags within that scope and
+    // automatic restoration of the flags to their previous state upon leaving the
+    // scope.
+    //
+    // A FlagSaver can be used within tests to temporarily change the test
+    // environment and restore the test case to its previous state.
+    //
+    // Example:
+    //
+    //   void MyFunc() {
+    //    absl::FlagSaver fs;
+    //    ...
+    //    absl::SetFlag(&FLAGS_myFlag, otherValue);
+    //    ...
+    //  } // scope of FlagSaver left, flags return to previous state
+    //
+    // This class is thread-safe.
 
-class FlagSaver {
- public:
-  FlagSaver();
-  ~FlagSaver();
+    class FlagSaver
+    {
+    public:
+        FlagSaver();
+        ~FlagSaver();
 
-  FlagSaver(const FlagSaver&) = delete;
-  void operator=(const FlagSaver&) = delete;
+        FlagSaver(const FlagSaver&) = delete;
+        void operator=(const FlagSaver&) = delete;
 
- private:
-  flags_internal::FlagSaverImpl* impl_;
-};
+    private:
+        flags_internal::FlagSaverImpl* impl_;
+    };
 
-//-----------------------------------------------------------------------------
+    //-----------------------------------------------------------------------------
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_REFLECTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/usage.h b/CAPI/cpp/grpc/include/absl/flags/usage.h
index ad12ab7..1838689 100644
--- a/CAPI/cpp/grpc/include/absl/flags/usage.h
+++ b/CAPI/cpp/grpc/include/absl/flags/usage.h
@@ -22,22 +22,23 @@
 // --------------------------------------------------------------------
 // Usage reporting interfaces
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Sets the "usage" message to be used by help reporting routines.
-// For example:
-//  absl::SetProgramUsageMessage(
-//      absl::StrCat("This program does nothing.  Sample usage:\n", argv[0],
-//                   " <uselessarg1> <uselessarg2>"));
-// Do not include commandline flags in the usage: we do that for you!
-// Note: Calling SetProgramUsageMessage twice will trigger a call to std::exit.
-void SetProgramUsageMessage(absl::string_view new_usage_message);
-
-// Returns the usage message set by SetProgramUsageMessage().
-absl::string_view ProgramUsageMessage();
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // Sets the "usage" message to be used by help reporting routines.
+    // For example:
+    //  absl::SetProgramUsageMessage(
+    //      absl::StrCat("This program does nothing.  Sample usage:\n", argv[0],
+    //                   " <uselessarg1> <uselessarg2>"));
+    // Do not include commandline flags in the usage: we do that for you!
+    // Note: Calling SetProgramUsageMessage twice will trigger a call to std::exit.
+    void SetProgramUsageMessage(absl::string_view new_usage_message);
+
+    // Returns the usage message set by SetProgramUsageMessage().
+    absl::string_view ProgramUsageMessage();
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FLAGS_USAGE_H_
diff --git a/CAPI/cpp/grpc/include/absl/flags/usage_config.h b/CAPI/cpp/grpc/include/absl/flags/usage_config.h
index ded7030..8f8439a 100644
--- a/CAPI/cpp/grpc/include/absl/flags/usage_config.h
+++ b/CAPI/cpp/grpc/include/absl/flags/usage_config.h
@@ -54,81 +54,86 @@
 // * --helpmatch
 //     Shows help on modules whose name contains the specified substring
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace flags_internal {
-using FlagKindFilter = std::function<bool (absl::string_view)>;
-}  // namespace flags_internal
-
-// FlagsUsageConfig
-//
-// This structure contains the collection of callbacks for changing the behavior
-// of the usage reporting routines in Abseil Flags.
-struct FlagsUsageConfig {
-  // Returns true if flags defined in the given source code file should be
-  // reported with --helpshort flag. For example, if the file
-  // "path/to/my/code.cc" defines the flag "--my_flag", and
-  // contains_helpshort_flags("path/to/my/code.cc") returns true, invoking the
-  // program with --helpshort will include information about --my_flag in the
-  // program output.
-  flags_internal::FlagKindFilter contains_helpshort_flags;
-
-  // Returns true if flags defined in the filename should be reported with
-  // --help flag. For example, if the file
-  // "path/to/my/code.cc" defines the flag "--my_flag", and
-  // contains_help_flags("path/to/my/code.cc") returns true, invoking the
-  // program with --help will include information about --my_flag in the
-  // program output.
-  flags_internal::FlagKindFilter contains_help_flags;
-
-  // Returns true if flags defined in the filename should be reported with
-  // --helppackage flag. For example, if the file
-  // "path/to/my/code.cc" defines the flag "--my_flag", and
-  // contains_helppackage_flags("path/to/my/code.cc") returns true, invoking the
-  // program with --helppackage will include information about --my_flag in the
-  // program output.
-  flags_internal::FlagKindFilter contains_helppackage_flags;
-
-  // Generates string containing program version. This is the string reported
-  // when user specifies --version in a command line.
-  std::function<std::string()> version_string;
-
-  // Normalizes the filename specific to the build system/filesystem used. This
-  // routine is used when we report the information about the flag definition
-  // location. For instance, if your build resides at some location you do not
-  // want to expose in the usage output, you can trim it to show only relevant
-  // part.
-  // For example:
-  //   normalize_filename("/my_company/some_long_path/src/project/file.cc")
-  // might produce
-  //   "project/file.cc".
-  std::function<std::string(absl::string_view)> normalize_filename;
-};
-
-// SetFlagsUsageConfig()
-//
-// Sets the usage reporting configuration callbacks. If any of the callbacks are
-// not set in usage_config instance, then the default value of the callback is
-// used.
-void SetFlagsUsageConfig(FlagsUsageConfig usage_config);
-
-namespace flags_internal {
-
-FlagsUsageConfig GetUsageConfig();
-
-void ReportUsageError(absl::string_view msg, bool is_fatal);
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    namespace flags_internal
+    {
+        using FlagKindFilter = std::function<bool(absl::string_view)>;
+    }  // namespace flags_internal
+
+    // FlagsUsageConfig
+    //
+    // This structure contains the collection of callbacks for changing the behavior
+    // of the usage reporting routines in Abseil Flags.
+    struct FlagsUsageConfig
+    {
+        // Returns true if flags defined in the given source code file should be
+        // reported with --helpshort flag. For example, if the file
+        // "path/to/my/code.cc" defines the flag "--my_flag", and
+        // contains_helpshort_flags("path/to/my/code.cc") returns true, invoking the
+        // program with --helpshort will include information about --my_flag in the
+        // program output.
+        flags_internal::FlagKindFilter contains_helpshort_flags;
+
+        // Returns true if flags defined in the filename should be reported with
+        // --help flag. For example, if the file
+        // "path/to/my/code.cc" defines the flag "--my_flag", and
+        // contains_help_flags("path/to/my/code.cc") returns true, invoking the
+        // program with --help will include information about --my_flag in the
+        // program output.
+        flags_internal::FlagKindFilter contains_help_flags;
+
+        // Returns true if flags defined in the filename should be reported with
+        // --helppackage flag. For example, if the file
+        // "path/to/my/code.cc" defines the flag "--my_flag", and
+        // contains_helppackage_flags("path/to/my/code.cc") returns true, invoking the
+        // program with --helppackage will include information about --my_flag in the
+        // program output.
+        flags_internal::FlagKindFilter contains_helppackage_flags;
+
+        // Generates string containing program version. This is the string reported
+        // when user specifies --version in a command line.
+        std::function<std::string()> version_string;
+
+        // Normalizes the filename specific to the build system/filesystem used. This
+        // routine is used when we report the information about the flag definition
+        // location. For instance, if your build resides at some location you do not
+        // want to expose in the usage output, you can trim it to show only relevant
+        // part.
+        // For example:
+        //   normalize_filename("/my_company/some_long_path/src/project/file.cc")
+        // might produce
+        //   "project/file.cc".
+        std::function<std::string(absl::string_view)> normalize_filename;
+    };
+
+    // SetFlagsUsageConfig()
+    //
+    // Sets the usage reporting configuration callbacks. If any of the callbacks are
+    // not set in usage_config instance, then the default value of the callback is
+    // used.
+    void SetFlagsUsageConfig(FlagsUsageConfig usage_config);
+
+    namespace flags_internal
+    {
+
+        FlagsUsageConfig GetUsageConfig();
+
+        void ReportUsageError(absl::string_view msg, bool is_fatal);
+
+    }  // namespace flags_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
-extern "C" {
-
-// Additional report of fatal usage error message before we std::exit. Error is
-// fatal if is_fatal argument to ReportUsageError is true.
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)(
-    absl::string_view);
+extern "C"
+{
+    // Additional report of fatal usage error message before we std::exit. Error is
+    // fatal if is_fatal argument to ReportUsageError is true.
+    void ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)(
+        absl::string_view
+    );
 
 }  // extern "C"
 
diff --git a/CAPI/cpp/grpc/include/absl/functional/any_invocable.h b/CAPI/cpp/grpc/include/absl/functional/any_invocable.h
index 0c5faca..ba0d844 100644
--- a/CAPI/cpp/grpc/include/absl/functional/any_invocable.h
+++ b/CAPI/cpp/grpc/include/absl/functional/any_invocable.h
@@ -40,274 +40,288 @@
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::AnyInvocable
-//
-// `absl::AnyInvocable` is a functional wrapper type, like `std::function`, that
-// assumes ownership of an invocable object. Unlike `std::function`, an
-// `absl::AnyInvocable` is more type-safe and provides the following additional
-// benefits:
-//
-// * Properly adheres to const correctness of the underlying type
-// * Is move-only so avoids concurrency problems with copied invocables and
-//   unnecessary copies in general.
-// * Supports reference qualifiers allowing it to perform unique actions (noted
-//   below).
-//
-// `absl::AnyInvocable` is a template, and an `absl::AnyInvocable` instantiation
-// may wrap any invocable object with a compatible function signature, e.g.
-// having arguments and return types convertible to types matching the
-// `absl::AnyInvocable` signature, and also matching any stated reference
-// qualifiers, as long as that type is moveable. It therefore provides broad
-// type erasure for functional objects.
-//
-// An `absl::AnyInvocable` is typically used as a type-erased function parameter
-// for accepting various functional objects:
-//
-// // Define a function taking an AnyInvocable parameter.
-// void my_func(absl::AnyInvocable<int()> f) {
-//   ...
-// };
-//
-// // That function can accept any invocable type:
-//
-// // Accept a function reference. We don't need to move a reference.
-// int func1() { return 0; };
-// my_func(func1);
-//
-// // Accept a lambda. We use std::move here because otherwise my_func would
-// // copy the lambda.
-// auto lambda = []() { return 0; };
-// my_func(std::move(lambda));
-//
-// // Accept a function pointer. We don't need to move a function pointer.
-// func2 = &func1;
-// my_func(func2);
-//
-// // Accept an std::function by moving it. Note that the lambda is copyable
-// // (satisfying std::function requirements) and moveable (satisfying
-// // absl::AnyInvocable requirements).
-// std::function<int()> func6 = []() { return 0; };
-// my_func(std::move(func6));
-//
-// `AnyInvocable` also properly respects `const` qualifiers, reference
-// qualifiers, and the `noexcept` specification (only in C++ 17 and beyond) as
-// part of the user-specified function type (e.g.
-// `AnyInvocable<void()&& const noexcept>`). These qualifiers will be applied to
-// the `AnyInvocable` object's `operator()`, and the underlying invocable must
-// be compatible with those qualifiers.
-//
-// Comparison of const and non-const function types:
-//
-//   // Store a closure inside of `func` with the function type `int()`.
-//   // Note that we have made `func` itself `const`.
-//   const AnyInvocable<int()> func = [](){ return 0; };
-//
-//   func();  // Compile-error: the passed type `int()` isn't `const`.
-//
-//   // Store a closure inside of `const_func` with the function type
-//   // `int() const`.
-//   // Note that we have also made `const_func` itself `const`.
-//   const AnyInvocable<int() const> const_func = [](){ return 0; };
-//
-//   const_func();  // Fine: `int() const` is `const`.
-//
-// In the above example, the call `func()` would have compiled if
-// `std::function` were used even though the types are not const compatible.
-// This is a bug, and using `absl::AnyInvocable` properly detects that bug.
-//
-// In addition to affecting the signature of `operator()`, the `const` and
-// reference qualifiers of the function type also appropriately constrain which
-// kinds of invocable objects you are allowed to place into the `AnyInvocable`
-// instance. If you specify a function type that is const-qualified, then
-// anything that you attempt to put into the `AnyInvocable` must be callable on
-// a `const` instance of that type.
-//
-// Constraint example:
-//
-//   // Fine because the lambda is callable when `const`.
-//   AnyInvocable<int() const> func = [=](){ return 0; };
-//
-//   // This is a compile-error because the lambda isn't callable when `const`.
-//   AnyInvocable<int() const> error = [=]() mutable { return 0; };
-//
-// An `&&` qualifier can be used to express that an `absl::AnyInvocable`
-// instance should be invoked at most once:
-//
-//   // Invokes `continuation` with the logical result of an operation when
-//   // that operation completes (common in asynchronous code).
-//   void CallOnCompletion(AnyInvocable<void(int)&&> continuation) {
-//     int result_of_foo = foo();
-//
-//     // `std::move` is required because the `operator()` of `continuation` is
-//     // rvalue-reference qualified.
-//     std::move(continuation)(result_of_foo);
-//   }
-//
-// Credits to Matt Calabrese (https://github.com/mattcalabrese) for the original
-// implementation.
-template <class Sig>
-class AnyInvocable : private internal_any_invocable::Impl<Sig> {
- private:
-  static_assert(
-      std::is_function<Sig>::value,
-      "The template argument of AnyInvocable must be a function type.");
-
-  using Impl = internal_any_invocable::Impl<Sig>;
-
- public:
-  // The return type of Sig
-  using result_type = typename Impl::result_type;
-
-  // Constructors
-
-  // Constructs the `AnyInvocable` in an empty state.
-  AnyInvocable() noexcept = default;
-  AnyInvocable(std::nullptr_t) noexcept {}  // NOLINT
-
-  // Constructs the `AnyInvocable` from an existing `AnyInvocable` by a move.
-  // Note that `f` is not guaranteed to be empty after move-construction,
-  // although it may be.
-  AnyInvocable(AnyInvocable&& /*f*/) noexcept = default;
-
-  // Constructs an `AnyInvocable` from an invocable object.
-  //
-  // Upon construction, `*this` is only empty if `f` is a function pointer or
-  // member pointer type and is null, or if `f` is an `AnyInvocable` that is
-  // empty.
-  template <class F, typename = absl::enable_if_t<
-                         internal_any_invocable::CanConvert<Sig, F>::value>>
-  AnyInvocable(F&& f)  // NOLINT
-      : Impl(internal_any_invocable::ConversionConstruct(),
-             std::forward<F>(f)) {}
-
-  // Constructs an `AnyInvocable` that holds an invocable object of type `T`,
-  // which is constructed in-place from the given arguments.
-  //
-  // Example:
-  //
-  //   AnyInvocable<int(int)> func(
-  //       absl::in_place_type<PossiblyImmovableType>, arg1, arg2);
-  //
-  template <class T, class... Args,
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::AnyInvocable
+    //
+    // `absl::AnyInvocable` is a functional wrapper type, like `std::function`, that
+    // assumes ownership of an invocable object. Unlike `std::function`, an
+    // `absl::AnyInvocable` is more type-safe and provides the following additional
+    // benefits:
+    //
+    // * Properly adheres to const correctness of the underlying type
+    // * Is move-only so avoids concurrency problems with copied invocables and
+    //   unnecessary copies in general.
+    // * Supports reference qualifiers allowing it to perform unique actions (noted
+    //   below).
+    //
+    // `absl::AnyInvocable` is a template, and an `absl::AnyInvocable` instantiation
+    // may wrap any invocable object with a compatible function signature, e.g.
+    // having arguments and return types convertible to types matching the
+    // `absl::AnyInvocable` signature, and also matching any stated reference
+    // qualifiers, as long as that type is moveable. It therefore provides broad
+    // type erasure for functional objects.
+    //
+    // An `absl::AnyInvocable` is typically used as a type-erased function parameter
+    // for accepting various functional objects:
+    //
+    // // Define a function taking an AnyInvocable parameter.
+    // void my_func(absl::AnyInvocable<int()> f) {
+    //   ...
+    // };
+    //
+    // // That function can accept any invocable type:
+    //
+    // // Accept a function reference. We don't need to move a reference.
+    // int func1() { return 0; };
+    // my_func(func1);
+    //
+    // // Accept a lambda. We use std::move here because otherwise my_func would
+    // // copy the lambda.
+    // auto lambda = []() { return 0; };
+    // my_func(std::move(lambda));
+    //
+    // // Accept a function pointer. We don't need to move a function pointer.
+    // func2 = &func1;
+    // my_func(func2);
+    //
+    // // Accept an std::function by moving it. Note that the lambda is copyable
+    // // (satisfying std::function requirements) and moveable (satisfying
+    // // absl::AnyInvocable requirements).
+    // std::function<int()> func6 = []() { return 0; };
+    // my_func(std::move(func6));
+    //
+    // `AnyInvocable` also properly respects `const` qualifiers, reference
+    // qualifiers, and the `noexcept` specification (only in C++ 17 and beyond) as
+    // part of the user-specified function type (e.g.
+    // `AnyInvocable<void()&& const noexcept>`). These qualifiers will be applied to
+    // the `AnyInvocable` object's `operator()`, and the underlying invocable must
+    // be compatible with those qualifiers.
+    //
+    // Comparison of const and non-const function types:
+    //
+    //   // Store a closure inside of `func` with the function type `int()`.
+    //   // Note that we have made `func` itself `const`.
+    //   const AnyInvocable<int()> func = [](){ return 0; };
+    //
+    //   func();  // Compile-error: the passed type `int()` isn't `const`.
+    //
+    //   // Store a closure inside of `const_func` with the function type
+    //   // `int() const`.
+    //   // Note that we have also made `const_func` itself `const`.
+    //   const AnyInvocable<int() const> const_func = [](){ return 0; };
+    //
+    //   const_func();  // Fine: `int() const` is `const`.
+    //
+    // In the above example, the call `func()` would have compiled if
+    // `std::function` were used even though the types are not const compatible.
+    // This is a bug, and using `absl::AnyInvocable` properly detects that bug.
+    //
+    // In addition to affecting the signature of `operator()`, the `const` and
+    // reference qualifiers of the function type also appropriately constrain which
+    // kinds of invocable objects you are allowed to place into the `AnyInvocable`
+    // instance. If you specify a function type that is const-qualified, then
+    // anything that you attempt to put into the `AnyInvocable` must be callable on
+    // a `const` instance of that type.
+    //
+    // Constraint example:
+    //
+    //   // Fine because the lambda is callable when `const`.
+    //   AnyInvocable<int() const> func = [=](){ return 0; };
+    //
+    //   // This is a compile-error because the lambda isn't callable when `const`.
+    //   AnyInvocable<int() const> error = [=]() mutable { return 0; };
+    //
+    // An `&&` qualifier can be used to express that an `absl::AnyInvocable`
+    // instance should be invoked at most once:
+    //
+    //   // Invokes `continuation` with the logical result of an operation when
+    //   // that operation completes (common in asynchronous code).
+    //   void CallOnCompletion(AnyInvocable<void(int)&&> continuation) {
+    //     int result_of_foo = foo();
+    //
+    //     // `std::move` is required because the `operator()` of `continuation` is
+    //     // rvalue-reference qualified.
+    //     std::move(continuation)(result_of_foo);
+    //   }
+    //
+    // Credits to Matt Calabrese (https://github.com/mattcalabrese) for the original
+    // implementation.
+    template<class Sig>
+    class AnyInvocable : private internal_any_invocable::Impl<Sig>
+    {
+    private:
+        static_assert(
+            std::is_function<Sig>::value,
+            "The template argument of AnyInvocable must be a function type."
+        );
+
+        using Impl = internal_any_invocable::Impl<Sig>;
+
+    public:
+        // The return type of Sig
+        using result_type = typename Impl::result_type;
+
+        // Constructors
+
+        // Constructs the `AnyInvocable` in an empty state.
+        AnyInvocable() noexcept = default;
+        AnyInvocable(std::nullptr_t) noexcept
+        {
+        }  // NOLINT
+
+        // Constructs the `AnyInvocable` from an existing `AnyInvocable` by a move.
+        // Note that `f` is not guaranteed to be empty after move-construction,
+        // although it may be.
+        AnyInvocable(AnyInvocable&& /*f*/) noexcept = default;
+
+        // Constructs an `AnyInvocable` from an invocable object.
+        //
+        // Upon construction, `*this` is only empty if `f` is a function pointer or
+        // member pointer type and is null, or if `f` is an `AnyInvocable` that is
+        // empty.
+        template<class F, typename = absl::enable_if_t<internal_any_invocable::CanConvert<Sig, F>::value>>
+        AnyInvocable(F&& f)  // NOLINT
+            :
+            Impl(internal_any_invocable::ConversionConstruct(), std::forward<F>(f))
+        {
+        }
+
+        // Constructs an `AnyInvocable` that holds an invocable object of type `T`,
+        // which is constructed in-place from the given arguments.
+        //
+        // Example:
+        //
+        //   AnyInvocable<int(int)> func(
+        //       absl::in_place_type<PossiblyImmovableType>, arg1, arg2);
+        //
+        template<class T, class... Args, typename = absl::enable_if_t<internal_any_invocable::CanEmplace<Sig, T, Args...>::value>>
+        explicit AnyInvocable(absl::in_place_type_t<T>, Args&&... args) :
+            Impl(absl::in_place_type<absl::decay_t<T>>, std::forward<Args>(args)...)
+        {
+            static_assert(std::is_same<T, absl::decay_t<T>>::value, "The explicit template argument of in_place_type is required "
+                                                                    "to be an unqualified object type.");
+        }
+
+        // Overload of the above constructor to support list-initialization.
+        template<class T, class U, class... Args, typename = absl::enable_if_t<internal_any_invocable::CanEmplace<Sig, T, std::initializer_list<U>&, Args...>::value>>
+        explicit AnyInvocable(absl::in_place_type_t<T>, std::initializer_list<U> ilist, Args&&... args) :
+            Impl(absl::in_place_type<absl::decay_t<T>>, ilist, std::forward<Args>(args)...)
+        {
+            static_assert(std::is_same<T, absl::decay_t<T>>::value, "The explicit template argument of in_place_type is required "
+                                                                    "to be an unqualified object type.");
+        }
+
+        // Assignment Operators
+
+        // Assigns an `AnyInvocable` through move-assignment.
+        // Note that `f` is not guaranteed to be empty after move-assignment
+        // although it may be.
+        AnyInvocable& operator=(AnyInvocable&& /*f*/) noexcept = default;
+
+        // Assigns an `AnyInvocable` from a nullptr, clearing the `AnyInvocable`. If
+        // not empty, destroys the target, putting `*this` into an empty state.
+        AnyInvocable& operator=(std::nullptr_t) noexcept
+        {
+            this->Clear();
+            return *this;
+        }
+
+        // Assigns an `AnyInvocable` from an existing `AnyInvocable` instance.
+        //
+        // Upon assignment, `*this` is only empty if `f` is a function pointer or
+        // member pointer type and is null, or if `f` is an `AnyInvocable` that is
+        // empty.
+        template<class F, typename = absl::enable_if_t<internal_any_invocable::CanAssign<Sig, F>::value>>
+        AnyInvocable& operator=(F&& f)
+        {
+            *this = AnyInvocable(std::forward<F>(f));
+            return *this;
+        }
+
+        // Assigns an `AnyInvocable` from a reference to an invocable object.
+        // Upon assignment, stores a reference to the invocable object in the
+        // `AnyInvocable` instance.
+        template<
+            class F,
             typename = absl::enable_if_t<
-                internal_any_invocable::CanEmplace<Sig, T, Args...>::value>>
-  explicit AnyInvocable(absl::in_place_type_t<T>, Args&&... args)
-      : Impl(absl::in_place_type<absl::decay_t<T>>,
-             std::forward<Args>(args)...) {
-    static_assert(std::is_same<T, absl::decay_t<T>>::value,
-                  "The explicit template argument of in_place_type is required "
-                  "to be an unqualified object type.");
-  }
-
-  // Overload of the above constructor to support list-initialization.
-  template <class T, class U, class... Args,
-            typename = absl::enable_if_t<internal_any_invocable::CanEmplace<
-                Sig, T, std::initializer_list<U>&, Args...>::value>>
-  explicit AnyInvocable(absl::in_place_type_t<T>,
-                        std::initializer_list<U> ilist, Args&&... args)
-      : Impl(absl::in_place_type<absl::decay_t<T>>, ilist,
-             std::forward<Args>(args)...) {
-    static_assert(std::is_same<T, absl::decay_t<T>>::value,
-                  "The explicit template argument of in_place_type is required "
-                  "to be an unqualified object type.");
-  }
-
-  // Assignment Operators
-
-  // Assigns an `AnyInvocable` through move-assignment.
-  // Note that `f` is not guaranteed to be empty after move-assignment
-  // although it may be.
-  AnyInvocable& operator=(AnyInvocable&& /*f*/) noexcept = default;
-
-  // Assigns an `AnyInvocable` from a nullptr, clearing the `AnyInvocable`. If
-  // not empty, destroys the target, putting `*this` into an empty state.
-  AnyInvocable& operator=(std::nullptr_t) noexcept {
-    this->Clear();
-    return *this;
-  }
-
-  // Assigns an `AnyInvocable` from an existing `AnyInvocable` instance.
-  //
-  // Upon assignment, `*this` is only empty if `f` is a function pointer or
-  // member pointer type and is null, or if `f` is an `AnyInvocable` that is
-  // empty.
-  template <class F, typename = absl::enable_if_t<
-                         internal_any_invocable::CanAssign<Sig, F>::value>>
-  AnyInvocable& operator=(F&& f) {
-    *this = AnyInvocable(std::forward<F>(f));
-    return *this;
-  }
-
-  // Assigns an `AnyInvocable` from a reference to an invocable object.
-  // Upon assignment, stores a reference to the invocable object in the
-  // `AnyInvocable` instance.
-  template <
-      class F,
-      typename = absl::enable_if_t<
-          internal_any_invocable::CanAssignReferenceWrapper<Sig, F>::value>>
-  AnyInvocable& operator=(std::reference_wrapper<F> f) noexcept {
-    *this = AnyInvocable(f);
-    return *this;
-  }
-
-  // Destructor
-
-  // If not empty, destroys the target.
-  ~AnyInvocable() = default;
-
-  // absl::AnyInvocable::swap()
-  //
-  // Exchanges the targets of `*this` and `other`.
-  void swap(AnyInvocable& other) noexcept { std::swap(*this, other); }
-
-  // abl::AnyInvocable::operator bool()
-  //
-  // Returns `true` if `*this` is not empty.
-  explicit operator bool() const noexcept { return this->HasValue(); }
-
-  // Invokes the target object of `*this`. `*this` must not be empty.
-  //
-  // Note: The signature of this function call operator is the same as the
-  //       template parameter `Sig`.
-  using Impl::operator();
-
-  // Equality operators
-
-  // Returns `true` if `*this` is empty.
-  friend bool operator==(const AnyInvocable& f, std::nullptr_t) noexcept {
-    return !f.HasValue();
-  }
-
-  // Returns `true` if `*this` is empty.
-  friend bool operator==(std::nullptr_t, const AnyInvocable& f) noexcept {
-    return !f.HasValue();
-  }
-
-  // Returns `false` if `*this` is empty.
-  friend bool operator!=(const AnyInvocable& f, std::nullptr_t) noexcept {
-    return f.HasValue();
-  }
-
-  // Returns `false` if `*this` is empty.
-  friend bool operator!=(std::nullptr_t, const AnyInvocable& f) noexcept {
-    return f.HasValue();
-  }
-
-  // swap()
-  //
-  // Exchanges the targets of `f1` and `f2`.
-  friend void swap(AnyInvocable& f1, AnyInvocable& f2) noexcept { f1.swap(f2); }
-
- private:
-  // Friending other instantiations is necessary for conversions.
-  template <bool /*SigIsNoexcept*/, class /*ReturnType*/, class... /*P*/>
-  friend class internal_any_invocable::CoreImpl;
-};
-
-ABSL_NAMESPACE_END
+                internal_any_invocable::CanAssignReferenceWrapper<Sig, F>::value>>
+        AnyInvocable& operator=(std::reference_wrapper<F> f) noexcept
+        {
+            *this = AnyInvocable(f);
+            return *this;
+        }
+
+        // Destructor
+
+        // If not empty, destroys the target.
+        ~AnyInvocable() = default;
+
+        // absl::AnyInvocable::swap()
+        //
+        // Exchanges the targets of `*this` and `other`.
+        void swap(AnyInvocable& other) noexcept
+        {
+            std::swap(*this, other);
+        }
+
+        // abl::AnyInvocable::operator bool()
+        //
+        // Returns `true` if `*this` is not empty.
+        explicit operator bool() const noexcept
+        {
+            return this->HasValue();
+        }
+
+        // Invokes the target object of `*this`. `*this` must not be empty.
+        //
+        // Note: The signature of this function call operator is the same as the
+        //       template parameter `Sig`.
+        using Impl::operator();
+
+        // Equality operators
+
+        // Returns `true` if `*this` is empty.
+        friend bool operator==(const AnyInvocable& f, std::nullptr_t) noexcept
+        {
+            return !f.HasValue();
+        }
+
+        // Returns `true` if `*this` is empty.
+        friend bool operator==(std::nullptr_t, const AnyInvocable& f) noexcept
+        {
+            return !f.HasValue();
+        }
+
+        // Returns `false` if `*this` is empty.
+        friend bool operator!=(const AnyInvocable& f, std::nullptr_t) noexcept
+        {
+            return f.HasValue();
+        }
+
+        // Returns `false` if `*this` is empty.
+        friend bool operator!=(std::nullptr_t, const AnyInvocable& f) noexcept
+        {
+            return f.HasValue();
+        }
+
+        // swap()
+        //
+        // Exchanges the targets of `f1` and `f2`.
+        friend void swap(AnyInvocable& f1, AnyInvocable& f2) noexcept
+        {
+            f1.swap(f2);
+        }
+
+    private:
+        // Friending other instantiations is necessary for conversions.
+        template<bool /*SigIsNoexcept*/, class /*ReturnType*/, class... /*P*/>
+        friend class internal_any_invocable::CoreImpl;
+    };
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FUNCTIONAL_ANY_INVOCABLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/bind_front.h b/CAPI/cpp/grpc/include/absl/functional/bind_front.h
index f9075bd..db4b964 100644
--- a/CAPI/cpp/grpc/include/absl/functional/bind_front.h
+++ b/CAPI/cpp/grpc/include/absl/functional/bind_front.h
@@ -32,13 +32,14 @@
 
 #if defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
 #include <functional>  // For std::bind_front.
-#endif  // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
+#endif                 // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
 
 #include "absl/functional/internal/front_binder.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
 // bind_front()
 //
@@ -176,18 +177,20 @@ ABSL_NAMESPACE_BEGIN
 //   absl::bind_front(Print, absl::string_view(hi))("Chuk");
 //
 #if defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
-using std::bind_front;
+    using std::bind_front;
 #else   // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
-template <class F, class... BoundArgs>
-constexpr functional_internal::bind_front_t<F, BoundArgs...> bind_front(
-    F&& func, BoundArgs&&... args) {
-  return functional_internal::bind_front_t<F, BoundArgs...>(
-      absl::in_place, absl::forward<F>(func),
-      absl::forward<BoundArgs>(args)...);
-}
+    template<class F, class... BoundArgs>
+    constexpr functional_internal::bind_front_t<F, BoundArgs...> bind_front(
+        F&& func, BoundArgs&&... args
+    )
+    {
+        return functional_internal::bind_front_t<F, BoundArgs...>(
+            absl::in_place, absl::forward<F>(func), absl::forward<BoundArgs>(args)...
+        );
+    }
 #endif  // defined(__cpp_lib_bind_front) && __cpp_lib_bind_front >= 201907L
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FUNCTIONAL_BIND_FRONT_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/function_ref.h b/CAPI/cpp/grpc/include/absl/functional/function_ref.h
index f977960..d00ec26 100644
--- a/CAPI/cpp/grpc/include/absl/functional/function_ref.h
+++ b/CAPI/cpp/grpc/include/absl/functional/function_ref.h
@@ -54,90 +54,95 @@
 #include "absl/functional/internal/function_ref.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// FunctionRef
-//
-// Dummy class declaration to allow the partial specialization based on function
-// types below.
-template <typename T>
-class FunctionRef;
+    // FunctionRef
+    //
+    // Dummy class declaration to allow the partial specialization based on function
+    // types below.
+    template<typename T>
+    class FunctionRef;
 
-// FunctionRef
-//
-// An `absl::FunctionRef` is a lightweight wrapper to any invokable object with
-// a compatible signature. Generally, an `absl::FunctionRef` should only be used
-// as an argument type and should be preferred as an argument over a const
-// reference to a `std::function`. `absl::FunctionRef` itself does not allocate,
-// although the wrapped invokable may.
-//
-// Example:
-//
-//   // The following function takes a function callback by const reference
-//   bool Visitor(const std::function<void(my_proto&,
-//                                         absl::string_view)>& callback);
-//
-//   // Assuming that the function is not stored or otherwise copied, it can be
-//   // replaced by an `absl::FunctionRef`:
-//   bool Visitor(absl::FunctionRef<void(my_proto&, absl::string_view)>
-//                  callback);
-//
-// Note: the assignment operator within an `absl::FunctionRef` is intentionally
-// deleted to prevent misuse; because the `absl::FunctionRef` does not own the
-// underlying type, assignment likely indicates misuse.
-template <typename R, typename... Args>
-class FunctionRef<R(Args...)> {
- private:
-  // Used to disable constructors for objects that are not compatible with the
-  // signature of this FunctionRef.
-  template <typename F,
-            typename FR = absl::base_internal::invoke_result_t<F, Args&&...>>
-  using EnableIfCompatible =
-      typename std::enable_if<std::is_void<R>::value ||
-                              std::is_convertible<FR, R>::value>::type;
+    // FunctionRef
+    //
+    // An `absl::FunctionRef` is a lightweight wrapper to any invokable object with
+    // a compatible signature. Generally, an `absl::FunctionRef` should only be used
+    // as an argument type and should be preferred as an argument over a const
+    // reference to a `std::function`. `absl::FunctionRef` itself does not allocate,
+    // although the wrapped invokable may.
+    //
+    // Example:
+    //
+    //   // The following function takes a function callback by const reference
+    //   bool Visitor(const std::function<void(my_proto&,
+    //                                         absl::string_view)>& callback);
+    //
+    //   // Assuming that the function is not stored or otherwise copied, it can be
+    //   // replaced by an `absl::FunctionRef`:
+    //   bool Visitor(absl::FunctionRef<void(my_proto&, absl::string_view)>
+    //                  callback);
+    //
+    // Note: the assignment operator within an `absl::FunctionRef` is intentionally
+    // deleted to prevent misuse; because the `absl::FunctionRef` does not own the
+    // underlying type, assignment likely indicates misuse.
+    template<typename R, typename... Args>
+    class FunctionRef<R(Args...)>
+    {
+    private:
+        // Used to disable constructors for objects that are not compatible with the
+        // signature of this FunctionRef.
+        template<typename F, typename FR = absl::base_internal::invoke_result_t<F, Args&&...>>
+        using EnableIfCompatible =
+            typename std::enable_if<std::is_void<R>::value || std::is_convertible<FR, R>::value>::type;
 
- public:
-  // Constructs a FunctionRef from any invokable type.
-  template <typename F, typename = EnableIfCompatible<const F&>>
-  // NOLINTNEXTLINE(runtime/explicit)
-  FunctionRef(const F& f ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) {
-    absl::functional_internal::AssertNonNull(f);
-    ptr_.obj = &f;
-  }
+    public:
+        // Constructs a FunctionRef from any invokable type.
+        template<typename F, typename = EnableIfCompatible<const F&>>
+        // NOLINTNEXTLINE(runtime/explicit)
+        FunctionRef(const F& f ABSL_ATTRIBUTE_LIFETIME_BOUND) :
+            invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>)
+        {
+            absl::functional_internal::AssertNonNull(f);
+            ptr_.obj = &f;
+        }
 
-  // Overload for function pointers. This eliminates a level of indirection that
-  // would happen if the above overload was used (it lets us store the pointer
-  // instead of a pointer to a pointer).
-  //
-  // This overload is also used for references to functions, since references to
-  // functions can decay to function pointers implicitly.
-  template <
-      typename F, typename = EnableIfCompatible<F*>,
-      absl::functional_internal::EnableIf<absl::is_function<F>::value> = 0>
-  FunctionRef(F* f)  // NOLINT(runtime/explicit)
-      : invoker_(&absl::functional_internal::InvokeFunction<F*, R, Args...>) {
-    assert(f != nullptr);
-    ptr_.fun = reinterpret_cast<decltype(ptr_.fun)>(f);
-  }
+        // Overload for function pointers. This eliminates a level of indirection that
+        // would happen if the above overload was used (it lets us store the pointer
+        // instead of a pointer to a pointer).
+        //
+        // This overload is also used for references to functions, since references to
+        // functions can decay to function pointers implicitly.
+        template<
+            typename F,
+            typename = EnableIfCompatible<F*>,
+            absl::functional_internal::EnableIf<absl::is_function<F>::value> = 0>
+        FunctionRef(F* f)  // NOLINT(runtime/explicit)
+            :
+            invoker_(&absl::functional_internal::InvokeFunction<F*, R, Args...>)
+        {
+            assert(f != nullptr);
+            ptr_.fun = reinterpret_cast<decltype(ptr_.fun)>(f);
+        }
 
-  // To help prevent subtle lifetime bugs, FunctionRef is not assignable.
-  // Typically, it should only be used as an argument type.
-  FunctionRef& operator=(const FunctionRef& rhs) = delete;
-  FunctionRef(const FunctionRef& rhs) = default;
+        // To help prevent subtle lifetime bugs, FunctionRef is not assignable.
+        // Typically, it should only be used as an argument type.
+        FunctionRef& operator=(const FunctionRef& rhs) = delete;
+        FunctionRef(const FunctionRef& rhs) = default;
 
-  // Call the underlying object.
-  R operator()(Args... args) const {
-    return invoker_(ptr_, std::forward<Args>(args)...);
-  }
+        // Call the underlying object.
+        R operator()(Args... args) const
+        {
+            return invoker_(ptr_, std::forward<Args>(args)...);
+        }
 
- private:
-  absl::functional_internal::VoidPtr ptr_;
-  absl::functional_internal::Invoker<R, Args...> invoker_;
-};
+    private:
+        absl::functional_internal::VoidPtr ptr_;
+        absl::functional_internal::Invoker<R, Args...> invoker_;
+    };
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FUNCTIONAL_FUNCTION_REF_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h b/CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h
index f353139..fad75c3 100644
--- a/CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h
+++ b/CAPI/cpp/grpc/include/absl/functional/internal/any_invocable.h
@@ -69,8 +69,9 @@
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
 // Helper macro used to prevent spelling `noexcept` in language versions older
 // than C++17, where it is not part of the type system, in order to avoid
@@ -81,436 +82,485 @@ ABSL_NAMESPACE_BEGIN
 #define ABSL_INTERNAL_NOEXCEPT_SPEC(noex)
 #endif
 
-// Defined in functional/any_invocable.h
-template <class Sig>
-class AnyInvocable;
-
-namespace internal_any_invocable {
-
-// Constants relating to the small-object-storage for AnyInvocable
-enum StorageProperty : std::size_t {
-  kAlignment = alignof(std::max_align_t),  // The alignment of the storage
-  kStorageSize = sizeof(void*) * 2         // The size of the storage
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction for checking if a type is an AnyInvocable instantiation.
-// This is used during conversion operations.
-template <class T>
-struct IsAnyInvocable : std::false_type {};
-
-template <class Sig>
-struct IsAnyInvocable<AnyInvocable<Sig>> : std::true_type {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A type trait that tells us whether or not a target function type should be
-// stored locally in the small object optimization storage
-template <class T>
-using IsStoredLocally = std::integral_constant<
-    bool, sizeof(T) <= kStorageSize && alignof(T) <= kAlignment &&
-              kAlignment % alignof(T) == 0 &&
-              std::is_nothrow_move_constructible<T>::value>;
-
-// An implementation of std::remove_cvref_t of C++20.
-template <class T>
-using RemoveCVRef =
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// An implementation of the C++ standard INVOKE<R> pseudo-macro, operation is
-// equivalent to std::invoke except that it forces an implicit conversion to the
-// specified return type. If "R" is void, the function is executed and the
-// return value is simply ignored.
-template <class ReturnType, class F, class... P,
-          typename = absl::enable_if_t<std::is_void<ReturnType>::value>>
-void InvokeR(F&& f, P&&... args) {
-  absl::base_internal::invoke(std::forward<F>(f), std::forward<P>(args)...);
-}
-
-template <class ReturnType, class F, class... P,
-          absl::enable_if_t<!std::is_void<ReturnType>::value, int> = 0>
-ReturnType InvokeR(F&& f, P&&... args) {
-  return absl::base_internal::invoke(std::forward<F>(f),
-                                     std::forward<P>(args)...);
-}
-
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-///
-// A metafunction that takes a "T" corresponding to a parameter type of the
-// user's specified function type, and yields the parameter type to use for the
-// type-erased invoker. In order to prevent observable moves, this must be
-// either a reference or, if the type is trivial, the original parameter type
-// itself. Since the parameter type may be incomplete at the point that this
-// metafunction is used, we can only do this optimization for scalar types
-// rather than for any trivial type.
-template <typename T>
-T ForwardImpl(std::true_type);
-
-template <typename T>
-T&& ForwardImpl(std::false_type);
-
-// NOTE: We deliberately use an intermediate struct instead of a direct alias,
-// as a workaround for b/206991861 on MSVC versions < 1924.
-template <class T>
-struct ForwardedParameter {
-  using type = decltype((
-      ForwardImpl<T>)(std::integral_constant<bool,
-                                             std::is_scalar<T>::value>()));
-};
-
-template <class T>
-using ForwardedParameterType = typename ForwardedParameter<T>::type;
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A discriminator when calling the "manager" function that describes operation
-// type-erased operation should be invoked.
-//
-// "relocate_from_to" specifies that the manager should perform a move.
-//
-// "dispose" specifies that the manager should perform a destroy.
-enum class FunctionToCall : bool { relocate_from_to, dispose };
-
-// The portion of `AnyInvocable` state that contains either a pointer to the
-// target object or the object itself in local storage
-union TypeErasedState {
-  struct {
-    // A pointer to the type-erased object when remotely stored
-    void* target;
-    // The size of the object for `RemoteManagerTrivial`
-    std::size_t size;
-  } remote;
-
-  // Local-storage for the type-erased object when small and trivial enough
-  alignas(kAlignment) char storage[kStorageSize];
-};
-
-// A typed accessor for the object in `TypeErasedState` storage
-template <class T>
-T& ObjectInLocalStorage(TypeErasedState* const state) {
-  // We launder here because the storage may be reused with the same type.
+    // Defined in functional/any_invocable.h
+    template<class Sig>
+    class AnyInvocable;
+
+    namespace internal_any_invocable
+    {
+
+        // Constants relating to the small-object-storage for AnyInvocable
+        enum StorageProperty : std::size_t
+        {
+            kAlignment = alignof(std::max_align_t),  // The alignment of the storage
+            kStorageSize = sizeof(void*) * 2         // The size of the storage
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction for checking if a type is an AnyInvocable instantiation.
+        // This is used during conversion operations.
+        template<class T>
+        struct IsAnyInvocable : std::false_type
+        {
+        };
+
+        template<class Sig>
+        struct IsAnyInvocable<AnyInvocable<Sig>> : std::true_type
+        {
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // A type trait that tells us whether or not a target function type should be
+        // stored locally in the small object optimization storage
+        template<class T>
+        using IsStoredLocally = std::integral_constant<
+            bool,
+            sizeof(T) <= kStorageSize && alignof(T) <= kAlignment &&
+                kAlignment % alignof(T) == 0 &&
+                std::is_nothrow_move_constructible<T>::value>;
+
+        // An implementation of std::remove_cvref_t of C++20.
+        template<class T>
+        using RemoveCVRef =
+            typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // An implementation of the C++ standard INVOKE<R> pseudo-macro, operation is
+        // equivalent to std::invoke except that it forces an implicit conversion to the
+        // specified return type. If "R" is void, the function is executed and the
+        // return value is simply ignored.
+        template<class ReturnType, class F, class... P, typename = absl::enable_if_t<std::is_void<ReturnType>::value>>
+        void InvokeR(F&& f, P&&... args)
+        {
+            absl::base_internal::invoke(std::forward<F>(f), std::forward<P>(args)...);
+        }
+
+        template<class ReturnType, class F, class... P, absl::enable_if_t<!std::is_void<ReturnType>::value, int> = 0>
+        ReturnType InvokeR(F&& f, P&&... args)
+        {
+            return absl::base_internal::invoke(std::forward<F>(f), std::forward<P>(args)...);
+        }
+
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////////
+        ///
+        // A metafunction that takes a "T" corresponding to a parameter type of the
+        // user's specified function type, and yields the parameter type to use for the
+        // type-erased invoker. In order to prevent observable moves, this must be
+        // either a reference or, if the type is trivial, the original parameter type
+        // itself. Since the parameter type may be incomplete at the point that this
+        // metafunction is used, we can only do this optimization for scalar types
+        // rather than for any trivial type.
+        template<typename T>
+        T ForwardImpl(std::true_type);
+
+        template<typename T>
+        T&& ForwardImpl(std::false_type);
+
+        // NOTE: We deliberately use an intermediate struct instead of a direct alias,
+        // as a workaround for b/206991861 on MSVC versions < 1924.
+        template<class T>
+        struct ForwardedParameter
+        {
+            using type = decltype((
+                ForwardImpl<T>
+            )(std::integral_constant<bool, std::is_scalar<T>::value>()));
+        };
+
+        template<class T>
+        using ForwardedParameterType = typename ForwardedParameter<T>::type;
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // A discriminator when calling the "manager" function that describes operation
+        // type-erased operation should be invoked.
+        //
+        // "relocate_from_to" specifies that the manager should perform a move.
+        //
+        // "dispose" specifies that the manager should perform a destroy.
+        enum class FunctionToCall : bool
+        {
+            relocate_from_to,
+            dispose
+        };
+
+        // The portion of `AnyInvocable` state that contains either a pointer to the
+        // target object or the object itself in local storage
+        union TypeErasedState
+        {
+            struct
+            {
+                // A pointer to the type-erased object when remotely stored
+                void* target;
+                // The size of the object for `RemoteManagerTrivial`
+                std::size_t size;
+            } remote;
+
+            // Local-storage for the type-erased object when small and trivial enough
+            alignas(kAlignment) char storage[kStorageSize];
+        };
+
+        // A typed accessor for the object in `TypeErasedState` storage
+        template<class T>
+        T& ObjectInLocalStorage(TypeErasedState* const state)
+        {
+            // We launder here because the storage may be reused with the same type.
 #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
-  return *std::launder(reinterpret_cast<T*>(&state->storage));
+            return *std::launder(reinterpret_cast<T*>(&state->storage));
 #elif ABSL_HAVE_BUILTIN(__builtin_launder)
-  return *__builtin_launder(reinterpret_cast<T*>(&state->storage));
+            return *__builtin_launder(reinterpret_cast<T*>(&state->storage));
 #else
 
-  // When `std::launder` or equivalent are not available, we rely on undefined
-  // behavior, which works as intended on Abseil's officially supported
-  // platforms as of Q2 2022.
+            // When `std::launder` or equivalent are not available, we rely on undefined
+            // behavior, which works as intended on Abseil's officially supported
+            // platforms as of Q2 2022.
 #if !defined(__clang__) && defined(__GNUC__)
 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #pragma GCC diagnostic push
 #endif
-  return *reinterpret_cast<T*>(&state->storage);
+            return *reinterpret_cast<T*>(&state->storage);
 #if !defined(__clang__) && defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
 
 #endif
-}
-
-// The type for functions issuing lifetime-related operations: move and dispose
-// A pointer to such a function is contained in each `AnyInvocable` instance.
-// NOTE: When specifying `FunctionToCall::`dispose, the same state must be
-// passed as both "from" and "to".
-using ManagerType = void(FunctionToCall /*operation*/,
-                         TypeErasedState* /*from*/, TypeErasedState* /*to*/)
-    ABSL_INTERNAL_NOEXCEPT_SPEC(true);
-
-// The type for functions issuing the actual invocation of the object
-// A pointer to such a function is contained in each AnyInvocable instance.
-template <bool SigIsNoexcept, class ReturnType, class... P>
-using InvokerType = ReturnType(TypeErasedState*, ForwardedParameterType<P>...)
-    ABSL_INTERNAL_NOEXCEPT_SPEC(SigIsNoexcept);
-
-// The manager that is used when AnyInvocable is empty
-inline void EmptyManager(FunctionToCall /*operation*/,
-                         TypeErasedState* /*from*/,
-                         TypeErasedState* /*to*/) noexcept {}
-
-// The manager that is used when a target function is in local storage and is
-// a trivially copyable type.
-inline void LocalManagerTrivial(FunctionToCall /*operation*/,
-                                TypeErasedState* const from,
-                                TypeErasedState* const to) noexcept {
-  // This single statement without branching handles both possible operations.
-  //
-  // For FunctionToCall::dispose, "from" and "to" point to the same state, and
-  // so this assignment logically would do nothing.
-  //
-  // Note: Correctness here relies on http://wg21.link/p0593, which has only
-  // become standard in C++20, though implementations do not break it in
-  // practice for earlier versions of C++.
-  //
-  // The correct way to do this without that paper is to first placement-new a
-  // default-constructed T in "to->storage" prior to the memmove, but doing so
-  // requires a different function to be created for each T that is stored
-  // locally, which can cause unnecessary bloat and be less cache friendly.
-  *to = *from;
-
-  // Note: Because the type is trivially copyable, the destructor does not need
-  // to be called ("trivially copyable" requires a trivial destructor).
-}
-
-// The manager that is used when a target function is in local storage and is
-// not a trivially copyable type.
-template <class T>
-void LocalManagerNontrivial(FunctionToCall operation,
-                            TypeErasedState* const from,
-                            TypeErasedState* const to) noexcept {
-  static_assert(IsStoredLocally<T>::value,
-                "Local storage must only be used for supported types.");
-  static_assert(!std::is_trivially_copyable<T>::value,
-                "Locally stored types must be trivially copyable.");
-
-  T& from_object = (ObjectInLocalStorage<T>)(from);
-
-  switch (operation) {
-    case FunctionToCall::relocate_from_to:
-      // NOTE: Requires that the left-hand operand is already empty.
-      ::new (static_cast<void*>(&to->storage)) T(std::move(from_object));
-      ABSL_FALLTHROUGH_INTENDED;
-    case FunctionToCall::dispose:
-      from_object.~T();  // Must not throw. // NOLINT
-      return;
-  }
-  ABSL_INTERNAL_UNREACHABLE;
-}
-
-// The invoker that is used when a target function is in local storage
-// Note: QualTRef here is the target function type along with cv and reference
-// qualifiers that must be used when calling the function.
-template <bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
-ReturnType LocalInvoker(
-    TypeErasedState* const state,
-    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
-  using RawT = RemoveCVRef<QualTRef>;
-  static_assert(
-      IsStoredLocally<RawT>::value,
-      "Target object must be in local storage in order to be invoked from it.");
-
-  auto& f = (ObjectInLocalStorage<RawT>)(state);
-  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
-                               static_cast<ForwardedParameterType<P>>(args)...);
-}
-
-// The manager that is used when a target function is in remote storage and it
-// has a trivial destructor
-inline void RemoteManagerTrivial(FunctionToCall operation,
-                                 TypeErasedState* const from,
-                                 TypeErasedState* const to) noexcept {
-  switch (operation) {
-    case FunctionToCall::relocate_from_to:
-      // NOTE: Requires that the left-hand operand is already empty.
-      to->remote = from->remote;
-      return;
-    case FunctionToCall::dispose:
+        }
+
+        // The type for functions issuing lifetime-related operations: move and dispose
+        // A pointer to such a function is contained in each `AnyInvocable` instance.
+        // NOTE: When specifying `FunctionToCall::`dispose, the same state must be
+        // passed as both "from" and "to".
+        using ManagerType = void(FunctionToCall /*operation*/, TypeErasedState* /*from*/, TypeErasedState* /*to*/)
+            ABSL_INTERNAL_NOEXCEPT_SPEC(true);
+
+        // The type for functions issuing the actual invocation of the object
+        // A pointer to such a function is contained in each AnyInvocable instance.
+        template<bool SigIsNoexcept, class ReturnType, class... P>
+        using InvokerType = ReturnType(TypeErasedState*, ForwardedParameterType<P>...)
+            ABSL_INTERNAL_NOEXCEPT_SPEC(SigIsNoexcept);
+
+        // The manager that is used when AnyInvocable is empty
+        inline void EmptyManager(FunctionToCall /*operation*/, TypeErasedState* /*from*/, TypeErasedState* /*to*/) noexcept
+        {
+        }
+
+        // The manager that is used when a target function is in local storage and is
+        // a trivially copyable type.
+        inline void LocalManagerTrivial(FunctionToCall /*operation*/, TypeErasedState* const from, TypeErasedState* const to) noexcept
+        {
+            // This single statement without branching handles both possible operations.
+            //
+            // For FunctionToCall::dispose, "from" and "to" point to the same state, and
+            // so this assignment logically would do nothing.
+            //
+            // Note: Correctness here relies on http://wg21.link/p0593, which has only
+            // become standard in C++20, though implementations do not break it in
+            // practice for earlier versions of C++.
+            //
+            // The correct way to do this without that paper is to first placement-new a
+            // default-constructed T in "to->storage" prior to the memmove, but doing so
+            // requires a different function to be created for each T that is stored
+            // locally, which can cause unnecessary bloat and be less cache friendly.
+            *to = *from;
+
+            // Note: Because the type is trivially copyable, the destructor does not need
+            // to be called ("trivially copyable" requires a trivial destructor).
+        }
+
+        // The manager that is used when a target function is in local storage and is
+        // not a trivially copyable type.
+        template<class T>
+        void LocalManagerNontrivial(FunctionToCall operation, TypeErasedState* const from, TypeErasedState* const to) noexcept
+        {
+            static_assert(IsStoredLocally<T>::value, "Local storage must only be used for supported types.");
+            static_assert(!std::is_trivially_copyable<T>::value, "Locally stored types must be trivially copyable.");
+
+            T& from_object = (ObjectInLocalStorage<T>)(from);
+
+            switch (operation)
+            {
+                case FunctionToCall::relocate_from_to:
+                    // NOTE: Requires that the left-hand operand is already empty.
+                    ::new (static_cast<void*>(&to->storage)) T(std::move(from_object));
+                    ABSL_FALLTHROUGH_INTENDED;
+                case FunctionToCall::dispose:
+                    from_object.~T();  // Must not throw. // NOLINT
+                    return;
+            }
+            ABSL_INTERNAL_UNREACHABLE;
+        }
+
+        // The invoker that is used when a target function is in local storage
+        // Note: QualTRef here is the target function type along with cv and reference
+        // qualifiers that must be used when calling the function.
+        template<bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
+        ReturnType LocalInvoker(
+            TypeErasedState* const state,
+            ForwardedParameterType<P>... args
+        ) noexcept(SigIsNoexcept)
+        {
+            using RawT = RemoveCVRef<QualTRef>;
+            static_assert(
+                IsStoredLocally<RawT>::value,
+                "Target object must be in local storage in order to be invoked from it."
+            );
+
+            auto& f = (ObjectInLocalStorage<RawT>)(state);
+            return (InvokeR<ReturnType>)(static_cast<QualTRef>(f), static_cast<ForwardedParameterType<P>>(args)...);
+        }
+
+        // The manager that is used when a target function is in remote storage and it
+        // has a trivial destructor
+        inline void RemoteManagerTrivial(FunctionToCall operation, TypeErasedState* const from, TypeErasedState* const to) noexcept
+        {
+            switch (operation)
+            {
+                case FunctionToCall::relocate_from_to:
+                    // NOTE: Requires that the left-hand operand is already empty.
+                    to->remote = from->remote;
+                    return;
+                case FunctionToCall::dispose:
 #if defined(__cpp_sized_deallocation)
-      ::operator delete(from->remote.target, from->remote.size);
+                    ::operator delete(from->remote.target, from->remote.size);
 #else   // __cpp_sized_deallocation
-      ::operator delete(from->remote.target);
+                    ::operator delete(from->remote.target);
 #endif  // __cpp_sized_deallocation
-      return;
-  }
-  ABSL_INTERNAL_UNREACHABLE;
-}
-
-// The manager that is used when a target function is in remote storage and the
-// destructor of the type is not trivial
-template <class T>
-void RemoteManagerNontrivial(FunctionToCall operation,
-                             TypeErasedState* const from,
-                             TypeErasedState* const to) noexcept {
-  static_assert(!IsStoredLocally<T>::value,
-                "Remote storage must only be used for types that do not "
-                "qualify for local storage.");
-
-  switch (operation) {
-    case FunctionToCall::relocate_from_to:
-      // NOTE: Requires that the left-hand operand is already empty.
-      to->remote.target = from->remote.target;
-      return;
-    case FunctionToCall::dispose:
-      ::delete static_cast<T*>(from->remote.target);  // Must not throw.
-      return;
-  }
-  ABSL_INTERNAL_UNREACHABLE;
-}
-
-// The invoker that is used when a target function is in remote storage
-template <bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
-ReturnType RemoteInvoker(
-    TypeErasedState* const state,
-    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
-  using RawT = RemoveCVRef<QualTRef>;
-  static_assert(!IsStoredLocally<RawT>::value,
-                "Target object must be in remote storage in order to be "
-                "invoked from it.");
-
-  auto& f = *static_cast<RawT*>(state->remote.target);
-  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
-                               static_cast<ForwardedParameterType<P>>(args)...);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction that checks if a type T is an instantiation of
-// absl::in_place_type_t (needed for constructor constraints of AnyInvocable).
-template <class T>
-struct IsInPlaceType : std::false_type {};
-
-template <class T>
-struct IsInPlaceType<absl::in_place_type_t<T>> : std::true_type {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A constructor name-tag used with CoreImpl (below) to request the
-// conversion-constructor. QualDecayedTRef is the decayed-type of the object to
-// wrap, along with the cv and reference qualifiers that must be applied when
-// performing an invocation of the wrapped object.
-template <class QualDecayedTRef>
-struct TypedConversionConstruct {};
-
-// A helper base class for all core operations of AnyInvocable. Most notably,
-// this class creates the function call operator and constraint-checkers so that
-// the top-level class does not have to be a series of partial specializations.
-//
-// Note: This definition exists (as opposed to being a declaration) so that if
-// the user of the top-level template accidentally passes a template argument
-// that is not a function type, they will get a static_assert in AnyInvocable's
-// class body rather than an error stating that Impl is not defined.
-template <class Sig>
-class Impl {};  // Note: This is partially-specialized later.
+                    return;
+            }
+            ABSL_INTERNAL_UNREACHABLE;
+        }
+
+        // The manager that is used when a target function is in remote storage and the
+        // destructor of the type is not trivial
+        template<class T>
+        void RemoteManagerNontrivial(FunctionToCall operation, TypeErasedState* const from, TypeErasedState* const to) noexcept
+        {
+            static_assert(!IsStoredLocally<T>::value, "Remote storage must only be used for types that do not "
+                                                      "qualify for local storage.");
+
+            switch (operation)
+            {
+                case FunctionToCall::relocate_from_to:
+                    // NOTE: Requires that the left-hand operand is already empty.
+                    to->remote.target = from->remote.target;
+                    return;
+                case FunctionToCall::dispose:
+                    ::delete static_cast<T*>(from->remote.target);  // Must not throw.
+                    return;
+            }
+            ABSL_INTERNAL_UNREACHABLE;
+        }
+
+        // The invoker that is used when a target function is in remote storage
+        template<bool SigIsNoexcept, class ReturnType, class QualTRef, class... P>
+        ReturnType RemoteInvoker(
+            TypeErasedState* const state,
+            ForwardedParameterType<P>... args
+        ) noexcept(SigIsNoexcept)
+        {
+            using RawT = RemoveCVRef<QualTRef>;
+            static_assert(!IsStoredLocally<RawT>::value, "Target object must be in remote storage in order to be "
+                                                         "invoked from it.");
+
+            auto& f = *static_cast<RawT*>(state->remote.target);
+            return (InvokeR<ReturnType>)(static_cast<QualTRef>(f), static_cast<ForwardedParameterType<P>>(args)...);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction that checks if a type T is an instantiation of
+        // absl::in_place_type_t (needed for constructor constraints of AnyInvocable).
+        template<class T>
+        struct IsInPlaceType : std::false_type
+        {
+        };
+
+        template<class T>
+        struct IsInPlaceType<absl::in_place_type_t<T>> : std::true_type
+        {
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // A constructor name-tag used with CoreImpl (below) to request the
+        // conversion-constructor. QualDecayedTRef is the decayed-type of the object to
+        // wrap, along with the cv and reference qualifiers that must be applied when
+        // performing an invocation of the wrapped object.
+        template<class QualDecayedTRef>
+        struct TypedConversionConstruct
+        {
+        };
+
+        // A helper base class for all core operations of AnyInvocable. Most notably,
+        // this class creates the function call operator and constraint-checkers so that
+        // the top-level class does not have to be a series of partial specializations.
+        //
+        // Note: This definition exists (as opposed to being a declaration) so that if
+        // the user of the top-level template accidentally passes a template argument
+        // that is not a function type, they will get a static_assert in AnyInvocable's
+        // class body rather than an error stating that Impl is not defined.
+        template<class Sig>
+        class Impl
+        {
+        };  // Note: This is partially-specialized later.
 
 // A std::unique_ptr deleter that deletes memory allocated via ::operator new.
 #if defined(__cpp_sized_deallocation)
-class TrivialDeleter {
- public:
-  explicit TrivialDeleter(std::size_t size) : size_(size) {}
-
-  void operator()(void* target) const {
-    ::operator delete(target, size_);
-  }
-
- private:
-  std::size_t size_;
-};
+        class TrivialDeleter
+        {
+        public:
+            explicit TrivialDeleter(std::size_t size) :
+                size_(size)
+            {
+            }
+
+            void operator()(void* target) const
+            {
+                ::operator delete(target, size_);
+            }
+
+        private:
+            std::size_t size_;
+        };
 #else   // __cpp_sized_deallocation
-class TrivialDeleter {
- public:
-  explicit TrivialDeleter(std::size_t) {}
-
-  void operator()(void* target) const { ::operator delete(target); }
-};
+        class TrivialDeleter
+        {
+        public:
+            explicit TrivialDeleter(std::size_t)
+            {
+            }
+
+            void operator()(void* target) const
+            {
+                ::operator delete(target);
+            }
+        };
 #endif  // __cpp_sized_deallocation
 
-template <bool SigIsNoexcept, class ReturnType, class... P>
-class CoreImpl;
-
-constexpr bool IsCompatibleConversion(void*, void*) { return false; }
-template <bool NoExceptSrc, bool NoExceptDest, class... T>
-constexpr bool IsCompatibleConversion(CoreImpl<NoExceptSrc, T...>*,
-                                      CoreImpl<NoExceptDest, T...>*) {
-  return !NoExceptDest || NoExceptSrc;
-}
-
-// A helper base class for all core operations of AnyInvocable that do not
-// depend on the cv/ref qualifiers of the function type.
-template <bool SigIsNoexcept, class ReturnType, class... P>
-class CoreImpl {
- public:
-  using result_type = ReturnType;
-
-  CoreImpl() noexcept : manager_(EmptyManager), invoker_(nullptr) {}
-
-  enum class TargetType : int {
-    kPointer = 0,
-    kCompatibleAnyInvocable = 1,
-    kIncompatibleAnyInvocable = 2,
-    kOther = 3,
-  };
-
-  // Note: QualDecayedTRef here includes the cv-ref qualifiers associated with
-  // the invocation of the Invocable. The unqualified type is the target object
-  // type to be stored.
-  template <class QualDecayedTRef, class F>
-  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
-    using DecayedT = RemoveCVRef<QualDecayedTRef>;
-
-    constexpr TargetType kTargetType =
-        (std::is_pointer<DecayedT>::value ||
-         std::is_member_pointer<DecayedT>::value)
-            ? TargetType::kPointer
-        : IsCompatibleAnyInvocable<DecayedT>::value
-            ? TargetType::kCompatibleAnyInvocable
-        : IsAnyInvocable<DecayedT>::value
-            ? TargetType::kIncompatibleAnyInvocable
-            : TargetType::kOther;
-    // NOTE: We only use integers instead of enums as template parameters in
-    // order to work around a bug on C++14 under MSVC 2017.
-    // See b/236131881.
-    Initialize<static_cast<int>(kTargetType), QualDecayedTRef>(
-        std::forward<F>(f));
-  }
-
-  // Note: QualTRef here includes the cv-ref qualifiers associated with the
-  // invocation of the Invocable. The unqualified type is the target object
-  // type to be stored.
-  template <class QualTRef, class... Args>
-  explicit CoreImpl(absl::in_place_type_t<QualTRef>, Args&&... args) {
-    InitializeStorage<QualTRef>(std::forward<Args>(args)...);
-  }
-
-  CoreImpl(CoreImpl&& other) noexcept {
-    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
-    manager_ = other.manager_;
-    invoker_ = other.invoker_;
-    other.manager_ = EmptyManager;
-    other.invoker_ = nullptr;
-  }
-
-  CoreImpl& operator=(CoreImpl&& other) noexcept {
-    // Put the left-hand operand in an empty state.
-    //
-    // Note: A full reset that leaves us with an object that has its invariants
-    // intact is necessary in order to handle self-move. This is required by
-    // types that are used with certain operations of the standard library, such
-    // as the default definition of std::swap when both operands target the same
-    // object.
-    Clear();
-
-    // Perform the actual move/destory operation on the target function.
-    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
-    manager_ = other.manager_;
-    invoker_ = other.invoker_;
-    other.manager_ = EmptyManager;
-    other.invoker_ = nullptr;
-
-    return *this;
-  }
-
-  ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); }
-
-  // Check whether or not the AnyInvocable is in the empty state.
-  bool HasValue() const { return invoker_ != nullptr; }
-
-  // Effects: Puts the object into its empty state.
-  void Clear() {
-    manager_(FunctionToCall::dispose, &state_, &state_);
-    manager_ = EmptyManager;
-    invoker_ = nullptr;
-  }
-
-  template <int target_type, class QualDecayedTRef, class F,
-            absl::enable_if_t<target_type == 0, int> = 0>
-  void Initialize(F&& f) {
+        template<bool SigIsNoexcept, class ReturnType, class... P>
+        class CoreImpl;
+
+        constexpr bool IsCompatibleConversion(void*, void*)
+        {
+            return false;
+        }
+        template<bool NoExceptSrc, bool NoExceptDest, class... T>
+        constexpr bool IsCompatibleConversion(CoreImpl<NoExceptSrc, T...>*, CoreImpl<NoExceptDest, T...>*)
+        {
+            return !NoExceptDest || NoExceptSrc;
+        }
+
+        // A helper base class for all core operations of AnyInvocable that do not
+        // depend on the cv/ref qualifiers of the function type.
+        template<bool SigIsNoexcept, class ReturnType, class... P>
+        class CoreImpl
+        {
+        public:
+            using result_type = ReturnType;
+
+            CoreImpl() noexcept :
+                manager_(EmptyManager),
+                invoker_(nullptr)
+            {
+            }
+
+            enum class TargetType : int
+            {
+                kPointer = 0,
+                kCompatibleAnyInvocable = 1,
+                kIncompatibleAnyInvocable = 2,
+                kOther = 3,
+            };
+
+            // Note: QualDecayedTRef here includes the cv-ref qualifiers associated with
+            // the invocation of the Invocable. The unqualified type is the target object
+            // type to be stored.
+            template<class QualDecayedTRef, class F>
+            explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f)
+            {
+                using DecayedT = RemoveCVRef<QualDecayedTRef>;
+
+                constexpr TargetType kTargetType =
+                    (std::is_pointer<DecayedT>::value ||
+                     std::is_member_pointer<DecayedT>::value) ?
+                        TargetType::kPointer :
+                    IsCompatibleAnyInvocable<DecayedT>::value ? TargetType::kCompatibleAnyInvocable :
+                    IsAnyInvocable<DecayedT>::value           ? TargetType::kIncompatibleAnyInvocable :
+                                                                TargetType::kOther;
+                // NOTE: We only use integers instead of enums as template parameters in
+                // order to work around a bug on C++14 under MSVC 2017.
+                // See b/236131881.
+                Initialize<static_cast<int>(kTargetType), QualDecayedTRef>(
+                    std::forward<F>(f)
+                );
+            }
+
+            // Note: QualTRef here includes the cv-ref qualifiers associated with the
+            // invocation of the Invocable. The unqualified type is the target object
+            // type to be stored.
+            template<class QualTRef, class... Args>
+            explicit CoreImpl(absl::in_place_type_t<QualTRef>, Args&&... args)
+            {
+                InitializeStorage<QualTRef>(std::forward<Args>(args)...);
+            }
+
+            CoreImpl(CoreImpl&& other) noexcept
+            {
+                other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
+                manager_ = other.manager_;
+                invoker_ = other.invoker_;
+                other.manager_ = EmptyManager;
+                other.invoker_ = nullptr;
+            }
+
+            CoreImpl& operator=(CoreImpl&& other) noexcept
+            {
+                // Put the left-hand operand in an empty state.
+                //
+                // Note: A full reset that leaves us with an object that has its invariants
+                // intact is necessary in order to handle self-move. This is required by
+                // types that are used with certain operations of the standard library, such
+                // as the default definition of std::swap when both operands target the same
+                // object.
+                Clear();
+
+                // Perform the actual move/destory operation on the target function.
+                other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
+                manager_ = other.manager_;
+                invoker_ = other.invoker_;
+                other.manager_ = EmptyManager;
+                other.invoker_ = nullptr;
+
+                return *this;
+            }
+
+            ~CoreImpl()
+            {
+                manager_(FunctionToCall::dispose, &state_, &state_);
+            }
+
+            // Check whether or not the AnyInvocable is in the empty state.
+            bool HasValue() const
+            {
+                return invoker_ != nullptr;
+            }
+
+            // Effects: Puts the object into its empty state.
+            void Clear()
+            {
+                manager_(FunctionToCall::dispose, &state_, &state_);
+                manager_ = EmptyManager;
+                invoker_ = nullptr;
+            }
+
+            template<int target_type, class QualDecayedTRef, class F, absl::enable_if_t<target_type == 0, int> = 0>
+            void Initialize(F&& f)
+            {
 // This condition handles types that decay into pointers, which includes
 // function references. Since function references cannot be null, GCC warns
 // against comparing their decayed form with nullptr.
@@ -522,206 +572,196 @@ class CoreImpl {
 #pragma GCC diagnostic ignored "-Wnonnull-compare"
 #pragma GCC diagnostic push
 #endif
-    if (static_cast<RemoveCVRef<QualDecayedTRef>>(f) == nullptr) {
+                if (static_cast<RemoveCVRef<QualDecayedTRef>>(f) == nullptr)
+                {
 #if !defined(__clang__) && defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
-      manager_ = EmptyManager;
-      invoker_ = nullptr;
-      return;
-    }
-    InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
-  }
-
-  template <int target_type, class QualDecayedTRef, class F,
-            absl::enable_if_t<target_type == 1, int> = 0>
-  void Initialize(F&& f) {
-    // In this case we can "steal the guts" of the other AnyInvocable.
-    f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
-    manager_ = f.manager_;
-    invoker_ = f.invoker_;
-
-    f.manager_ = EmptyManager;
-    f.invoker_ = nullptr;
-  }
-
-  template <int target_type, class QualDecayedTRef, class F,
-            absl::enable_if_t<target_type == 2, int> = 0>
-  void Initialize(F&& f) {
-    if (f.HasValue()) {
-      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
-    } else {
-      manager_ = EmptyManager;
-      invoker_ = nullptr;
-    }
-  }
-
-  template <int target_type, class QualDecayedTRef, class F,
-            typename = absl::enable_if_t<target_type == 3>>
-  void Initialize(F&& f) {
-    InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
-  }
-
-  // Use local (inline) storage for applicable target object types.
-  template <class QualTRef, class... Args,
-            typename = absl::enable_if_t<
-                IsStoredLocally<RemoveCVRef<QualTRef>>::value>>
-  void InitializeStorage(Args&&... args) {
-    using RawT = RemoveCVRef<QualTRef>;
-    ::new (static_cast<void*>(&state_.storage))
-        RawT(std::forward<Args>(args)...);
-
-    invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
-    // We can simplify our manager if we know the type is trivially copyable.
-    InitializeLocalManager<RawT>();
-  }
-
-  // Use remote storage for target objects that cannot be stored locally.
-  template <class QualTRef, class... Args,
-            absl::enable_if_t<!IsStoredLocally<RemoveCVRef<QualTRef>>::value,
-                              int> = 0>
-  void InitializeStorage(Args&&... args) {
-    InitializeRemoteManager<RemoveCVRef<QualTRef>>(std::forward<Args>(args)...);
-    // This is set after everything else in case an exception is thrown in an
-    // earlier step of the initialization.
-    invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
-  }
-
-  template <class T,
-            typename = absl::enable_if_t<std::is_trivially_copyable<T>::value>>
-  void InitializeLocalManager() {
-    manager_ = LocalManagerTrivial;
-  }
-
-  template <class T,
-            absl::enable_if_t<!std::is_trivially_copyable<T>::value, int> = 0>
-  void InitializeLocalManager() {
-    manager_ = LocalManagerNontrivial<T>;
-  }
-
-  template <class T>
-  using HasTrivialRemoteStorage =
-      std::integral_constant<bool, std::is_trivially_destructible<T>::value &&
-                                       alignof(T) <=
-                                           ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT>;
-
-  template <class T, class... Args,
-            typename = absl::enable_if_t<HasTrivialRemoteStorage<T>::value>>
-  void InitializeRemoteManager(Args&&... args) {
-    // unique_ptr is used for exception-safety in case construction throws.
-    std::unique_ptr<void, TrivialDeleter> uninitialized_target(
-        ::operator new(sizeof(T)), TrivialDeleter(sizeof(T)));
-    ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
-    state_.remote.target = uninitialized_target.release();
-    state_.remote.size = sizeof(T);
-    manager_ = RemoteManagerTrivial;
-  }
-
-  template <class T, class... Args,
-            absl::enable_if_t<!HasTrivialRemoteStorage<T>::value, int> = 0>
-  void InitializeRemoteManager(Args&&... args) {
-    state_.remote.target = ::new T(std::forward<Args>(args)...);
-    manager_ = RemoteManagerNontrivial<T>;
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  //
-  // Type trait to determine if the template argument is an AnyInvocable whose
-  // function type is compatible enough with ours such that we can
-  // "move the guts" out of it when moving, rather than having to place a new
-  // object into remote storage.
-
-  template <typename Other>
-  struct IsCompatibleAnyInvocable {
-    static constexpr bool value = false;
-  };
-
-  template <typename Sig>
-  struct IsCompatibleAnyInvocable<AnyInvocable<Sig>> {
-    static constexpr bool value =
-        (IsCompatibleConversion)(static_cast<
-                                     typename AnyInvocable<Sig>::CoreImpl*>(
-                                     nullptr),
-                                 static_cast<CoreImpl*>(nullptr));
-  };
-
-  //
-  //////////////////////////////////////////////////////////////////////////////
-
-  TypeErasedState state_;
-  ManagerType* manager_;
-  InvokerType<SigIsNoexcept, ReturnType, P...>* invoker_;
-};
-
-// A constructor name-tag used with Impl to request the
-// conversion-constructor
-struct ConversionConstruct {};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction that is normally an identity metafunction except that when
-// given a std::reference_wrapper<T>, it yields T&. This is necessary because
-// currently std::reference_wrapper's operator() is not conditionally noexcept,
-// so when checking if such an Invocable is nothrow-invocable, we must pull out
-// the underlying type.
-template <class T>
-struct UnwrapStdReferenceWrapperImpl {
-  using type = T;
-};
-
-template <class T>
-struct UnwrapStdReferenceWrapperImpl<std::reference_wrapper<T>> {
-  using type = T&;
-};
-
-template <class T>
-using UnwrapStdReferenceWrapper =
-    typename UnwrapStdReferenceWrapperImpl<T>::type;
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// An alias that always yields std::true_type (used with constraints) where
-// substitution failures happen when forming the template arguments.
-template <class... T>
-using True =
-    std::integral_constant<bool, sizeof(absl::void_t<T...>*) != 0>;
-
-/*SFINAE constraints for the conversion-constructor.*/
-template <class Sig, class F,
-          class = absl::enable_if_t<
-              !std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
-using CanConvert =
-    True<absl::enable_if_t<!IsInPlaceType<RemoveCVRef<F>>::value>,
-         absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
-         absl::enable_if_t<
-             Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
-         absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;
-
-/*SFINAE constraints for the std::in_place constructors.*/
-template <class Sig, class F, class... Args>
-using CanEmplace = True<
-    absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
-    absl::enable_if_t<
-        Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
-    absl::enable_if_t<std::is_constructible<absl::decay_t<F>, Args...>::value>>;
-
-/*SFINAE constraints for the conversion-assign operator.*/
-template <class Sig, class F,
-          class = absl::enable_if_t<
-              !std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
-using CanAssign =
-    True<absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
-         absl::enable_if_t<
-             Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
-         absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;
-
-/*SFINAE constraints for the reference-wrapper conversion-assign operator.*/
-template <class Sig, class F>
-using CanAssignReferenceWrapper =
-    True<absl::enable_if_t<
-             Impl<Sig>::template CallIsValid<std::reference_wrapper<F>>::value>,
-         absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<
-             std::reference_wrapper<F>>::value>>;
+                    manager_ = EmptyManager;
+                    invoker_ = nullptr;
+                    return;
+                }
+                InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
+            }
+
+            template<int target_type, class QualDecayedTRef, class F, absl::enable_if_t<target_type == 1, int> = 0>
+            void Initialize(F&& f)
+            {
+                // In this case we can "steal the guts" of the other AnyInvocable.
+                f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
+                manager_ = f.manager_;
+                invoker_ = f.invoker_;
+
+                f.manager_ = EmptyManager;
+                f.invoker_ = nullptr;
+            }
+
+            template<int target_type, class QualDecayedTRef, class F, absl::enable_if_t<target_type == 2, int> = 0>
+            void Initialize(F&& f)
+            {
+                if (f.HasValue())
+                {
+                    InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
+                }
+                else
+                {
+                    manager_ = EmptyManager;
+                    invoker_ = nullptr;
+                }
+            }
+
+            template<int target_type, class QualDecayedTRef, class F, typename = absl::enable_if_t<target_type == 3>>
+            void Initialize(F&& f)
+            {
+                InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
+            }
+
+            // Use local (inline) storage for applicable target object types.
+            template<class QualTRef, class... Args, typename = absl::enable_if_t<IsStoredLocally<RemoveCVRef<QualTRef>>::value>>
+            void InitializeStorage(Args&&... args)
+            {
+                using RawT = RemoveCVRef<QualTRef>;
+                ::new (static_cast<void*>(&state_.storage))
+                    RawT(std::forward<Args>(args)...);
+
+                invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
+                // We can simplify our manager if we know the type is trivially copyable.
+                InitializeLocalManager<RawT>();
+            }
+
+            // Use remote storage for target objects that cannot be stored locally.
+            template<class QualTRef, class... Args, absl::enable_if_t<!IsStoredLocally<RemoveCVRef<QualTRef>>::value, int> = 0>
+            void InitializeStorage(Args&&... args)
+            {
+                InitializeRemoteManager<RemoveCVRef<QualTRef>>(std::forward<Args>(args)...);
+                // This is set after everything else in case an exception is thrown in an
+                // earlier step of the initialization.
+                invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
+            }
+
+            template<class T, typename = absl::enable_if_t<std::is_trivially_copyable<T>::value>>
+            void InitializeLocalManager()
+            {
+                manager_ = LocalManagerTrivial;
+            }
+
+            template<class T, absl::enable_if_t<!std::is_trivially_copyable<T>::value, int> = 0>
+            void InitializeLocalManager()
+            {
+                manager_ = LocalManagerNontrivial<T>;
+            }
+
+            template<class T>
+            using HasTrivialRemoteStorage =
+                std::integral_constant<bool, std::is_trivially_destructible<T>::value && alignof(T) <= ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT>;
+
+            template<class T, class... Args, typename = absl::enable_if_t<HasTrivialRemoteStorage<T>::value>>
+            void InitializeRemoteManager(Args&&... args)
+            {
+                // unique_ptr is used for exception-safety in case construction throws.
+                std::unique_ptr<void, TrivialDeleter> uninitialized_target(
+                    ::operator new(sizeof(T)), TrivialDeleter(sizeof(T))
+                );
+                ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
+                state_.remote.target = uninitialized_target.release();
+                state_.remote.size = sizeof(T);
+                manager_ = RemoteManagerTrivial;
+            }
+
+            template<class T, class... Args, absl::enable_if_t<!HasTrivialRemoteStorage<T>::value, int> = 0>
+            void InitializeRemoteManager(Args&&... args)
+            {
+                state_.remote.target = ::new T(std::forward<Args>(args)...);
+                manager_ = RemoteManagerNontrivial<T>;
+            }
+
+            //////////////////////////////////////////////////////////////////////////////
+            //
+            // Type trait to determine if the template argument is an AnyInvocable whose
+            // function type is compatible enough with ours such that we can
+            // "move the guts" out of it when moving, rather than having to place a new
+            // object into remote storage.
+
+            template<typename Other>
+            struct IsCompatibleAnyInvocable
+            {
+                static constexpr bool value = false;
+            };
+
+            template<typename Sig>
+            struct IsCompatibleAnyInvocable<AnyInvocable<Sig>>
+            {
+                static constexpr bool value =
+                    (IsCompatibleConversion)(static_cast<typename AnyInvocable<Sig>::CoreImpl*>(nullptr), static_cast<CoreImpl*>(nullptr));
+            };
+
+            //
+            //////////////////////////////////////////////////////////////////////////////
+
+            TypeErasedState state_;
+            ManagerType* manager_;
+            InvokerType<SigIsNoexcept, ReturnType, P...>* invoker_;
+        };
+
+        // A constructor name-tag used with Impl to request the
+        // conversion-constructor
+        struct ConversionConstruct
+        {
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction that is normally an identity metafunction except that when
+        // given a std::reference_wrapper<T>, it yields T&. This is necessary because
+        // currently std::reference_wrapper's operator() is not conditionally noexcept,
+        // so when checking if such an Invocable is nothrow-invocable, we must pull out
+        // the underlying type.
+        template<class T>
+        struct UnwrapStdReferenceWrapperImpl
+        {
+            using type = T;
+        };
+
+        template<class T>
+        struct UnwrapStdReferenceWrapperImpl<std::reference_wrapper<T>>
+        {
+            using type = T&;
+        };
+
+        template<class T>
+        using UnwrapStdReferenceWrapper =
+            typename UnwrapStdReferenceWrapperImpl<T>::type;
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // An alias that always yields std::true_type (used with constraints) where
+        // substitution failures happen when forming the template arguments.
+        template<class... T>
+        using True =
+            std::integral_constant<bool, sizeof(absl::void_t<T...>*) != 0>;
+
+        /*SFINAE constraints for the conversion-constructor.*/
+        template<class Sig, class F, class = absl::enable_if_t<!std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
+        using CanConvert =
+            True<absl::enable_if_t<!IsInPlaceType<RemoveCVRef<F>>::value>, absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>, absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>, absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;
+
+        /*SFINAE constraints for the std::in_place constructors.*/
+        template<class Sig, class F, class... Args>
+        using CanEmplace = True<
+            absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>,
+            absl::enable_if_t<
+                Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>,
+            absl::enable_if_t<std::is_constructible<absl::decay_t<F>, Args...>::value>>;
+
+        /*SFINAE constraints for the conversion-assign operator.*/
+        template<class Sig, class F, class = absl::enable_if_t<!std::is_same<RemoveCVRef<F>, AnyInvocable<Sig>>::value>>
+        using CanAssign =
+            True<absl::enable_if_t<Impl<Sig>::template CallIsValid<F>::value>, absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<F>::value>, absl::enable_if_t<std::is_constructible<absl::decay_t<F>, F>::value>>;
+
+        /*SFINAE constraints for the reference-wrapper conversion-assign operator.*/
+        template<class Sig, class F>
+        using CanAssignReferenceWrapper =
+            True<absl::enable_if_t<Impl<Sig>::template CallIsValid<std::reference_wrapper<F>>::value>, absl::enable_if_t<Impl<Sig>::template CallIsNoexceptIfSigIsNoexcept<std::reference_wrapper<F>>::value>>;
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -732,25 +772,27 @@ using CanAssignReferenceWrapper =
 // cases where the user did not specify a noexcept function type.
 //
 #define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT(inv_quals, noex) \
-  ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_##noex(inv_quals)
+    ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_##noex(inv_quals)
 
 // The disjunction below is because we can't rely on std::is_nothrow_invocable_r
 // to give the right result when ReturnType is non-moveable in toolchains that
 // don't treat non-moveable result types correctly. For example this was the
 // case in libc++ before commit c3a24882 (2022-05).
-#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true(inv_quals)      \
-  absl::enable_if_t<absl::disjunction<                                       \
-      std::is_nothrow_invocable_r<                                           \
-          ReturnType, UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, \
-          P...>,                                                             \
-      std::conjunction<                                                      \
-          std::is_nothrow_invocable<                                         \
-              UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, P...>,  \
-          std::is_same<                                                      \
-              ReturnType,                                                    \
-              absl::base_internal::invoke_result_t<                          \
-                  UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals,     \
-                  P...>>>>::value>
+#define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_true(inv_quals)    \
+    absl::enable_if_t<absl::disjunction<                                   \
+        std::is_nothrow_invocable_r<                                       \
+            ReturnType,                                                    \
+            UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals,         \
+            P...>,                                                         \
+        std::conjunction<                                                  \
+            std::is_nothrow_invocable<                                     \
+                UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals,     \
+                P...>,                                                     \
+            std::is_same<                                                  \
+                ReturnType,                                                \
+                absl::base_internal::invoke_result_t<                      \
+                    UnwrapStdReferenceWrapper<absl::decay_t<F>> inv_quals, \
+                    P...>>>>::value>
 
 #define ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT_false(inv_quals)
 //
@@ -768,79 +810,74 @@ using CanAssignReferenceWrapper =
 // right result when ReturnType is non-moveable in toolchains that don't treat
 // non-moveable result types correctly. For example this was the case in libc++
 // before commit c3a24882 (2022-05).
-#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, noex)            \
-  template <class ReturnType, class... P>                                      \
-  class Impl<ReturnType(P...) cv ref ABSL_INTERNAL_NOEXCEPT_SPEC(noex)>        \
-      : public CoreImpl<noex, ReturnType, P...> {                              \
-   public:                                                                     \
-    /*The base class, which contains the datamembers and core operations*/     \
-    using Core = CoreImpl<noex, ReturnType, P...>;                             \
-                                                                               \
-    /*SFINAE constraint to check if F is invocable with the proper signature*/ \
-    template <class F>                                                         \
-    using CallIsValid = True<absl::enable_if_t<absl::disjunction<              \
-        absl::base_internal::is_invocable_r<ReturnType,                        \
-                                            absl::decay_t<F> inv_quals, P...>, \
-        std::is_same<ReturnType,                                               \
-                     absl::base_internal::invoke_result_t<                     \
-                         absl::decay_t<F> inv_quals, P...>>>::value>>;         \
-                                                                               \
-    /*SFINAE constraint to check if F is nothrow-invocable when necessary*/    \
-    template <class F>                                                         \
-    using CallIsNoexceptIfSigIsNoexcept =                                      \
-        True<ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT(inv_quals,        \
-                                                             noex)>;           \
-                                                                               \
-    /*Put the AnyInvocable into an empty state.*/                              \
-    Impl() = default;                                                          \
-                                                                               \
-    /*The implementation of a conversion-constructor from "f*/                 \
-    /*This forwards to Core, attaching inv_quals so that the base class*/      \
-    /*knows how to properly type-erase the invocation.*/                       \
-    template <class F>                                                         \
-    explicit Impl(ConversionConstruct, F&& f)                                  \
-        : Core(TypedConversionConstruct<                                       \
-                   typename std::decay<F>::type inv_quals>(),                  \
-               std::forward<F>(f)) {}                                          \
-                                                                               \
-    /*Forward along the in-place construction parameters.*/                    \
-    template <class T, class... Args>                                          \
-    explicit Impl(absl::in_place_type_t<T>, Args&&... args)                    \
-        : Core(absl::in_place_type<absl::decay_t<T> inv_quals>,                \
-               std::forward<Args>(args)...) {}                                 \
-                                                                               \
-    /*The actual invocation operation with the proper signature*/              \
-    ReturnType operator()(P... args) cv ref noexcept(noex) {                   \
-      assert(this->invoker_ != nullptr);                                       \
-      return this->invoker_(const_cast<TypeErasedState*>(&this->state_),       \
-                            static_cast<ForwardedParameterType<P>>(args)...);  \
-    }                                                                          \
-  }
+#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, noex)                                                                                  \
+    template<class ReturnType, class... P>                                                                                                           \
+    class Impl<ReturnType(P...) cv ref ABSL_INTERNAL_NOEXCEPT_SPEC(noex)> : public CoreImpl<noex, ReturnType, P...>                                  \
+    {                                                                                                                                                \
+    public:                                                                                                                                          \
+        /*The base class, which contains the datamembers and core operations*/                                                                       \
+        using Core = CoreImpl<noex, ReturnType, P...>;                                                                                               \
+                                                                                                                                                     \
+        /*SFINAE constraint to check if F is invocable with the proper signature*/                                                                   \
+        template<class F>                                                                                                                            \
+        using CallIsValid = True<absl::enable_if_t<absl::disjunction<                                                                                \
+            absl::base_internal::is_invocable_r<ReturnType, absl::decay_t<F> inv_quals, P...>,                                                       \
+            std::is_same<ReturnType, absl::base_internal::invoke_result_t<absl::decay_t<F> inv_quals, P...>>>::value>>;                              \
+                                                                                                                                                     \
+        /*SFINAE constraint to check if F is nothrow-invocable when necessary*/                                                                      \
+        template<class F>                                                                                                                            \
+        using CallIsNoexceptIfSigIsNoexcept =                                                                                                        \
+            True<ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT(inv_quals, noex)>;                                                                  \
+                                                                                                                                                     \
+        /*Put the AnyInvocable into an empty state.*/                                                                                                \
+        Impl() = default;                                                                                                                            \
+                                                                                                                                                     \
+        /*The implementation of a conversion-constructor from "f*/                                                                                   \
+        /*This forwards to Core, attaching inv_quals so that the base class*/                                                                        \
+        /*knows how to properly type-erase the invocation.*/                                                                                         \
+        template<class F>                                                                                                                            \
+        explicit Impl(ConversionConstruct, F&& f) : Core(TypedConversionConstruct<typename std::decay<F>::type inv_quals>(), std::forward<F>(f))     \
+        {                                                                                                                                            \
+        }                                                                                                                                            \
+                                                                                                                                                     \
+        /*Forward along the in-place construction parameters.*/                                                                                      \
+        template<class T, class... Args>                                                                                                             \
+        explicit Impl(absl::in_place_type_t<T>, Args&&... args) : Core(absl::in_place_type<absl::decay_t<T> inv_quals>, std::forward<Args>(args)...) \
+        {                                                                                                                                            \
+        }                                                                                                                                            \
+                                                                                                                                                     \
+        /*The actual invocation operation with the proper signature*/                                                                                \
+        ReturnType operator()(P... args) cv ref noexcept(noex)                                                                                       \
+        {                                                                                                                                            \
+            assert(this->invoker_ != nullptr);                                                                                                       \
+            return this->invoker_(const_cast<TypeErasedState*>(&this->state_), static_cast<ForwardedParameterType<P>>(args)...);                     \
+        }                                                                                                                                            \
+    }
 
 // Define the `noexcept(true)` specialization only for C++17 and beyond, when
 // `noexcept` is part of the type system.
 #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L
 // A convenience macro that defines specializations for the noexcept(true) and
 // noexcept(false) forms, given the other properties.
-#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL(cv, ref, inv_quals)    \
-  ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false); \
-  ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, true)
+#define ABSL_INTERNAL_ANY_INVOCABLE_IMPL(cv, ref, inv_quals)      \
+    ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false); \
+    ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, true)
 #else
 #define ABSL_INTERNAL_ANY_INVOCABLE_IMPL(cv, ref, inv_quals) \
-  ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false)
+    ABSL_INTERNAL_ANY_INVOCABLE_IMPL_(cv, ref, inv_quals, false)
 #endif
 
-// Non-ref-qualified partial specializations
-ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, , &);
-ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, , const&);
+        // Non-ref-qualified partial specializations
+        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, , &);
+        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, , const&);
 
-// Lvalue-ref-qualified partial specializations
-ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, &, &);
-ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &, const&);
+        // Lvalue-ref-qualified partial specializations
+        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, &, &);
+        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &, const&);
 
-// Rvalue-ref-qualified partial specializations
-ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, &&, &&);
-ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &&, const&&);
+        // Rvalue-ref-qualified partial specializations
+        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(, &&, &&);
+        ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &&, const&&);
 
 // Undef the detail-only macros.
 #undef ABSL_INTERNAL_ANY_INVOCABLE_IMPL
@@ -850,8 +887,8 @@ ABSL_INTERNAL_ANY_INVOCABLE_IMPL(const, &&, const&&);
 #undef ABSL_INTERNAL_ANY_INVOCABLE_NOEXCEPT_CONSTRAINT
 #undef ABSL_INTERNAL_NOEXCEPT_SPEC
 
-}  // namespace internal_any_invocable
-ABSL_NAMESPACE_END
+    }  // namespace internal_any_invocable
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FUNCTIONAL_INTERNAL_ANY_INVOCABLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/internal/front_binder.h b/CAPI/cpp/grpc/include/absl/functional/internal/front_binder.h
index 45f52de..78e352f 100644
--- a/CAPI/cpp/grpc/include/absl/functional/internal/front_binder.h
+++ b/CAPI/cpp/grpc/include/absl/functional/internal/front_binder.h
@@ -26,70 +26,71 @@
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace functional_internal {
-
-// Invoke the method, expanding the tuple of bound arguments.
-template <class R, class Tuple, size_t... Idx, class... Args>
-R Apply(Tuple&& bound, absl::index_sequence<Idx...>, Args&&... free) {
-  return base_internal::invoke(
-      absl::forward<Tuple>(bound).template get<Idx>()...,
-      absl::forward<Args>(free)...);
-}
-
-template <class F, class... BoundArgs>
-class FrontBinder {
-  using BoundArgsT = absl::container_internal::CompressedTuple<F, BoundArgs...>;
-  using Idx = absl::make_index_sequence<sizeof...(BoundArgs) + 1>;
-
-  BoundArgsT bound_args_;
-
- public:
-  template <class... Ts>
-  constexpr explicit FrontBinder(absl::in_place_t, Ts&&... ts)
-      : bound_args_(absl::forward<Ts>(ts)...) {}
-
-  template <class... FreeArgs, class R = base_internal::invoke_result_t<
-                                   F&, BoundArgs&..., FreeArgs&&...>>
-  R operator()(FreeArgs&&... free_args) & {
-    return functional_internal::Apply<R>(bound_args_, Idx(),
-                                         absl::forward<FreeArgs>(free_args)...);
-  }
-
-  template <class... FreeArgs,
-            class R = base_internal::invoke_result_t<
-                const F&, const BoundArgs&..., FreeArgs&&...>>
-  R operator()(FreeArgs&&... free_args) const& {
-    return functional_internal::Apply<R>(bound_args_, Idx(),
-                                         absl::forward<FreeArgs>(free_args)...);
-  }
-
-  template <class... FreeArgs, class R = base_internal::invoke_result_t<
-                                   F&&, BoundArgs&&..., FreeArgs&&...>>
-  R operator()(FreeArgs&&... free_args) && {
-    // This overload is called when *this is an rvalue. If some of the bound
-    // arguments are stored by value or rvalue reference, we move them.
-    return functional_internal::Apply<R>(absl::move(bound_args_), Idx(),
-                                         absl::forward<FreeArgs>(free_args)...);
-  }
-
-  template <class... FreeArgs,
-            class R = base_internal::invoke_result_t<
-                const F&&, const BoundArgs&&..., FreeArgs&&...>>
-  R operator()(FreeArgs&&... free_args) const&& {
-    // This overload is called when *this is an rvalue. If some of the bound
-    // arguments are stored by value or rvalue reference, we move them.
-    return functional_internal::Apply<R>(absl::move(bound_args_), Idx(),
-                                         absl::forward<FreeArgs>(free_args)...);
-  }
-};
-
-template <class F, class... BoundArgs>
-using bind_front_t = FrontBinder<decay_t<F>, absl::decay_t<BoundArgs>...>;
-
-}  // namespace functional_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace functional_internal
+    {
+
+        // Invoke the method, expanding the tuple of bound arguments.
+        template<class R, class Tuple, size_t... Idx, class... Args>
+        R Apply(Tuple&& bound, absl::index_sequence<Idx...>, Args&&... free)
+        {
+            return base_internal::invoke(
+                absl::forward<Tuple>(bound).template get<Idx>()...,
+                absl::forward<Args>(free)...
+            );
+        }
+
+        template<class F, class... BoundArgs>
+        class FrontBinder
+        {
+            using BoundArgsT = absl::container_internal::CompressedTuple<F, BoundArgs...>;
+            using Idx = absl::make_index_sequence<sizeof...(BoundArgs) + 1>;
+
+            BoundArgsT bound_args_;
+
+        public:
+            template<class... Ts>
+            constexpr explicit FrontBinder(absl::in_place_t, Ts&&... ts) :
+                bound_args_(absl::forward<Ts>(ts)...)
+            {
+            }
+
+            template<class... FreeArgs, class R = base_internal::invoke_result_t<F&, BoundArgs&..., FreeArgs&&...>>
+            R operator()(FreeArgs&&... free_args) &
+            {
+                return functional_internal::Apply<R>(bound_args_, Idx(), absl::forward<FreeArgs>(free_args)...);
+            }
+
+            template<class... FreeArgs, class R = base_internal::invoke_result_t<const F&, const BoundArgs&..., FreeArgs&&...>>
+            R operator()(FreeArgs&&... free_args) const&
+            {
+                return functional_internal::Apply<R>(bound_args_, Idx(), absl::forward<FreeArgs>(free_args)...);
+            }
+
+            template<class... FreeArgs, class R = base_internal::invoke_result_t<F&&, BoundArgs&&..., FreeArgs&&...>>
+            R operator()(FreeArgs&&... free_args) &&
+            {
+                // This overload is called when *this is an rvalue. If some of the bound
+                // arguments are stored by value or rvalue reference, we move them.
+                return functional_internal::Apply<R>(absl::move(bound_args_), Idx(), absl::forward<FreeArgs>(free_args)...);
+            }
+
+            template<class... FreeArgs, class R = base_internal::invoke_result_t<const F&&, const BoundArgs&&..., FreeArgs&&...>>
+            R operator()(FreeArgs&&... free_args) const&&
+            {
+                // This overload is called when *this is an rvalue. If some of the bound
+                // arguments are stored by value or rvalue reference, we move them.
+                return functional_internal::Apply<R>(absl::move(bound_args_), Idx(), absl::forward<FreeArgs>(free_args)...);
+            }
+        };
+
+        template<class F, class... BoundArgs>
+        using bind_front_t = FrontBinder<decay_t<F>, absl::decay_t<BoundArgs>...>;
+
+    }  // namespace functional_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
diff --git a/CAPI/cpp/grpc/include/absl/functional/internal/function_ref.h b/CAPI/cpp/grpc/include/absl/functional/internal/function_ref.h
index b5bb8b4..a3a5a31 100644
--- a/CAPI/cpp/grpc/include/absl/functional/internal/function_ref.h
+++ b/CAPI/cpp/grpc/include/absl/functional/internal/function_ref.h
@@ -22,85 +22,99 @@
 #include "absl/base/internal/invoke.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace functional_internal {
-
-// Like a void* that can handle function pointers as well. The standard does not
-// allow function pointers to round-trip through void*, but void(*)() is fine.
-//
-// Note: It's important that this class remains trivial and is the same size as
-// a pointer, since this allows the compiler to perform tail-call optimizations
-// when the underlying function is a callable object with a matching signature.
-union VoidPtr {
-  const void* obj;
-  void (*fun)();
-};
-
-// Chooses the best type for passing T as an argument.
-// Attempt to be close to SystemV AMD64 ABI. Objects with trivial copy ctor are
-// passed by value.
-template <typename T>
-constexpr bool PassByValue() {
-  return !std::is_lvalue_reference<T>::value &&
-         absl::is_trivially_copy_constructible<T>::value &&
-         absl::is_trivially_copy_assignable<
-             typename std::remove_cv<T>::type>::value &&
-         std::is_trivially_destructible<T>::value &&
-         sizeof(T) <= 2 * sizeof(void*);
-}
-
-template <typename T>
-struct ForwardT : std::conditional<PassByValue<T>(), T, T&&> {};
-
-// An Invoker takes a pointer to the type-erased invokable object, followed by
-// the arguments that the invokable object expects.
-//
-// Note: The order of arguments here is an optimization, since member functions
-// have an implicit "this" pointer as their first argument, putting VoidPtr
-// first allows the compiler to perform tail-call optimization in many cases.
-template <typename R, typename... Args>
-using Invoker = R (*)(VoidPtr, typename ForwardT<Args>::type...);
-
-//
-// InvokeObject and InvokeFunction provide static "Invoke" functions that can be
-// used as Invokers for objects or functions respectively.
-//
-// static_cast<R> handles the case the return type is void.
-template <typename Obj, typename R, typename... Args>
-R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
-  auto o = static_cast<const Obj*>(ptr.obj);
-  return static_cast<R>(
-      absl::base_internal::invoke(*o, std::forward<Args>(args)...));
-}
-
-template <typename Fun, typename R, typename... Args>
-R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
-  auto f = reinterpret_cast<Fun>(ptr.fun);
-  return static_cast<R>(
-      absl::base_internal::invoke(f, std::forward<Args>(args)...));
-}
-
-template <typename Sig>
-void AssertNonNull(const std::function<Sig>& f) {
-  assert(f != nullptr);
-  (void)f;
-}
-
-template <typename F>
-void AssertNonNull(const F&) {}
-
-template <typename F, typename C>
-void AssertNonNull(F C::*f) {
-  assert(f != nullptr);
-  (void)f;
-}
-
-template <bool C>
-using EnableIf = typename ::std::enable_if<C, int>::type;
-
-}  // namespace functional_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace functional_internal
+    {
+
+        // Like a void* that can handle function pointers as well. The standard does not
+        // allow function pointers to round-trip through void*, but void(*)() is fine.
+        //
+        // Note: It's important that this class remains trivial and is the same size as
+        // a pointer, since this allows the compiler to perform tail-call optimizations
+        // when the underlying function is a callable object with a matching signature.
+        union VoidPtr
+        {
+            const void* obj;
+            void (*fun)();
+        };
+
+        // Chooses the best type for passing T as an argument.
+        // Attempt to be close to SystemV AMD64 ABI. Objects with trivial copy ctor are
+        // passed by value.
+        template<typename T>
+        constexpr bool PassByValue()
+        {
+            return !std::is_lvalue_reference<T>::value &&
+                   absl::is_trivially_copy_constructible<T>::value &&
+                   absl::is_trivially_copy_assignable<
+                       typename std::remove_cv<T>::type>::value &&
+                   std::is_trivially_destructible<T>::value &&
+                   sizeof(T) <= 2 * sizeof(void*);
+        }
+
+        template<typename T>
+        struct ForwardT : std::conditional<PassByValue<T>(), T, T&&>
+        {
+        };
+
+        // An Invoker takes a pointer to the type-erased invokable object, followed by
+        // the arguments that the invokable object expects.
+        //
+        // Note: The order of arguments here is an optimization, since member functions
+        // have an implicit "this" pointer as their first argument, putting VoidPtr
+        // first allows the compiler to perform tail-call optimization in many cases.
+        template<typename R, typename... Args>
+        using Invoker = R (*)(VoidPtr, typename ForwardT<Args>::type...);
+
+        //
+        // InvokeObject and InvokeFunction provide static "Invoke" functions that can be
+        // used as Invokers for objects or functions respectively.
+        //
+        // static_cast<R> handles the case the return type is void.
+        template<typename Obj, typename R, typename... Args>
+        R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args)
+        {
+            auto o = static_cast<const Obj*>(ptr.obj);
+            return static_cast<R>(
+                absl::base_internal::invoke(*o, std::forward<Args>(args)...)
+            );
+        }
+
+        template<typename Fun, typename R, typename... Args>
+        R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args)
+        {
+            auto f = reinterpret_cast<Fun>(ptr.fun);
+            return static_cast<R>(
+                absl::base_internal::invoke(f, std::forward<Args>(args)...)
+            );
+        }
+
+        template<typename Sig>
+        void AssertNonNull(const std::function<Sig>& f)
+        {
+            assert(f != nullptr);
+            (void)f;
+        }
+
+        template<typename F>
+        void AssertNonNull(const F&)
+        {
+        }
+
+        template<typename F, typename C>
+        void AssertNonNull(F C::*f)
+        {
+            assert(f != nullptr);
+            (void)f;
+        }
+
+        template<bool C>
+        using EnableIf = typename ::std::enable_if<C, int>::type;
+
+    }  // namespace functional_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/hash.h b/CAPI/cpp/grpc/include/absl/hash/hash.h
index 74e2d7c..5e462c8 100644
--- a/CAPI/cpp/grpc/include/absl/hash/hash.h
+++ b/CAPI/cpp/grpc/include/absl/hash/hash.h
@@ -84,338 +84,353 @@
 #include "absl/functional/function_ref.h"
 #include "absl/hash/internal/hash.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// -----------------------------------------------------------------------------
-// `absl::Hash`
-// -----------------------------------------------------------------------------
-//
-// `absl::Hash<T>` is a convenient general-purpose hash functor for any type `T`
-// satisfying any of the following conditions (in order):
-//
-//  * T is an arithmetic or pointer type
-//  * T defines an overload for `AbslHashValue(H, const T&)` for an arbitrary
-//    hash state `H`.
-//  - T defines a specialization of `std::hash<T>`
-//
-// `absl::Hash` intrinsically supports the following types:
-//
-//   * All integral types (including bool)
-//   * All enum types
-//   * All floating-point types (although hashing them is discouraged)
-//   * All pointer types, including nullptr_t
-//   * std::pair<T1, T2>, if T1 and T2 are hashable
-//   * std::tuple<Ts...>, if all the Ts... are hashable
-//   * std::unique_ptr and std::shared_ptr
-//   * All string-like types including:
-//     * absl::Cord
-//     * std::string
-//     * std::string_view (as well as any instance of std::basic_string that
-//       uses char and std::char_traits)
-//  * All the standard sequence containers (provided the elements are hashable)
-//  * All the standard associative containers (provided the elements are
-//    hashable)
-//  * absl types such as the following:
-//    * absl::string_view
-//    * absl::uint128
-//    * absl::Time, absl::Duration, and absl::TimeZone
-//  * absl containers (provided the elements are hashable) such as the
-//    following:
-//    * absl::flat_hash_set, absl::node_hash_set, absl::btree_set
-//    * absl::flat_hash_map, absl::node_hash_map, absl::btree_map
-//    * absl::btree_multiset, absl::btree_multimap
-//    * absl::InlinedVector
-//    * absl::FixedArray
-//
-// When absl::Hash is used to hash an unordered container with a custom hash
-// functor, the elements are hashed using default absl::Hash semantics, not
-// the custom hash functor.  This is consistent with the behavior of
-// operator==() on unordered containers, which compares elements pairwise with
-// operator==() rather than the custom equality functor.  It is usually a
-// mistake to use either operator==() or absl::Hash on unordered collections
-// that use functors incompatible with operator==() equality.
-//
-// Note: the list above is not meant to be exhaustive. Additional type support
-// may be added, in which case the above list will be updated.
-//
-// -----------------------------------------------------------------------------
-// absl::Hash Invocation Evaluation
-// -----------------------------------------------------------------------------
-//
-// When invoked, `absl::Hash<T>` searches for supplied hash functions in the
-// following order:
-//
-//   * Natively supported types out of the box (see above)
-//   * Types for which an `AbslHashValue()` overload is provided (such as
-//     user-defined types). See "Adding Type Support to `absl::Hash`" below.
-//   * Types which define a `std::hash<T>` specialization
-//
-// The fallback to legacy hash functions exists mainly for backwards
-// compatibility. If you have a choice, prefer defining an `AbslHashValue`
-// overload instead of specializing any legacy hash functors.
-//
-// -----------------------------------------------------------------------------
-// The Hash State Concept, and using `HashState` for Type Erasure
-// -----------------------------------------------------------------------------
-//
-// The `absl::Hash` framework relies on the Concept of a "hash state." Such a
-// hash state is used in several places:
-//
-// * Within existing implementations of `absl::Hash<T>` to store the hashed
-//   state of an object. Note that it is up to the implementation how it stores
-//   such state. A hash table, for example, may mix the state to produce an
-//   integer value; a testing framework may simply hold a vector of that state.
-// * Within implementations of `AbslHashValue()` used to extend user-defined
-//   types. (See "Adding Type Support to absl::Hash" below.)
-// * Inside a `HashState`, providing type erasure for the concept of a hash
-//   state, which you can use to extend the `absl::Hash` framework for types
-//   that are otherwise difficult to extend using `AbslHashValue()`. (See the
-//   `HashState` class below.)
-//
-// The "hash state" concept contains three member functions for mixing hash
-// state:
-//
-// * `H::combine(state, values...)`
-//
-//   Combines an arbitrary number of values into a hash state, returning the
-//   updated state. Note that the existing hash state is move-only and must be
-//   passed by value.
-//
-//   Each of the value types T must be hashable by H.
-//
-//   NOTE:
-//
-//     state = H::combine(std::move(state), value1, value2, value3);
-//
-//   must be guaranteed to produce the same hash expansion as
-//
-//     state = H::combine(std::move(state), value1);
-//     state = H::combine(std::move(state), value2);
-//     state = H::combine(std::move(state), value3);
-//
-// * `H::combine_contiguous(state, data, size)`
-//
-//    Combines a contiguous array of `size` elements into a hash state,
-//    returning the updated state. Note that the existing hash state is
-//    move-only and must be passed by value.
-//
-//    NOTE:
-//
-//      state = H::combine_contiguous(std::move(state), data, size);
-//
-//    need NOT be guaranteed to produce the same hash expansion as a loop
-//    (it may perform internal optimizations). If you need this guarantee, use a
-//    loop instead.
-//
-// * `H::combine_unordered(state, begin, end)`
-//
-//    Combines a set of elements denoted by an iterator pair into a hash
-//    state, returning the updated state.  Note that the existing hash
-//    state is move-only and must be passed by value.
-//
-//    Unlike the other two methods, the hashing is order-independent.
-//    This can be used to hash unordered collections.
-//
-// -----------------------------------------------------------------------------
-// Adding Type Support to `absl::Hash`
-// -----------------------------------------------------------------------------
-//
-// To add support for your user-defined type, add a proper `AbslHashValue()`
-// overload as a free (non-member) function. The overload will take an
-// existing hash state and should combine that state with state from the type.
-//
-// Example:
-//
-//   template <typename H>
-//   H AbslHashValue(H state, const MyType& v) {
-//     return H::combine(std::move(state), v.field1, ..., v.fieldN);
-//   }
-//
-// where `(field1, ..., fieldN)` are the members you would use on your
-// `operator==` to define equality.
-//
-// Notice that `AbslHashValue` is not a class member, but an ordinary function.
-// An `AbslHashValue` overload for a type should only be declared in the same
-// file and namespace as said type. The proper `AbslHashValue` implementation
-// for a given type will be discovered via ADL.
-//
-// Note: unlike `std::hash', `absl::Hash` should never be specialized. It must
-// only be extended by adding `AbslHashValue()` overloads.
-//
-template <typename T>
-using Hash = absl::hash_internal::Hash<T>;
+    // -----------------------------------------------------------------------------
+    // `absl::Hash`
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::Hash<T>` is a convenient general-purpose hash functor for any type `T`
+    // satisfying any of the following conditions (in order):
+    //
+    //  * T is an arithmetic or pointer type
+    //  * T defines an overload for `AbslHashValue(H, const T&)` for an arbitrary
+    //    hash state `H`.
+    //  - T defines a specialization of `std::hash<T>`
+    //
+    // `absl::Hash` intrinsically supports the following types:
+    //
+    //   * All integral types (including bool)
+    //   * All enum types
+    //   * All floating-point types (although hashing them is discouraged)
+    //   * All pointer types, including nullptr_t
+    //   * std::pair<T1, T2>, if T1 and T2 are hashable
+    //   * std::tuple<Ts...>, if all the Ts... are hashable
+    //   * std::unique_ptr and std::shared_ptr
+    //   * All string-like types including:
+    //     * absl::Cord
+    //     * std::string
+    //     * std::string_view (as well as any instance of std::basic_string that
+    //       uses char and std::char_traits)
+    //  * All the standard sequence containers (provided the elements are hashable)
+    //  * All the standard associative containers (provided the elements are
+    //    hashable)
+    //  * absl types such as the following:
+    //    * absl::string_view
+    //    * absl::uint128
+    //    * absl::Time, absl::Duration, and absl::TimeZone
+    //  * absl containers (provided the elements are hashable) such as the
+    //    following:
+    //    * absl::flat_hash_set, absl::node_hash_set, absl::btree_set
+    //    * absl::flat_hash_map, absl::node_hash_map, absl::btree_map
+    //    * absl::btree_multiset, absl::btree_multimap
+    //    * absl::InlinedVector
+    //    * absl::FixedArray
+    //
+    // When absl::Hash is used to hash an unordered container with a custom hash
+    // functor, the elements are hashed using default absl::Hash semantics, not
+    // the custom hash functor.  This is consistent with the behavior of
+    // operator==() on unordered containers, which compares elements pairwise with
+    // operator==() rather than the custom equality functor.  It is usually a
+    // mistake to use either operator==() or absl::Hash on unordered collections
+    // that use functors incompatible with operator==() equality.
+    //
+    // Note: the list above is not meant to be exhaustive. Additional type support
+    // may be added, in which case the above list will be updated.
+    //
+    // -----------------------------------------------------------------------------
+    // absl::Hash Invocation Evaluation
+    // -----------------------------------------------------------------------------
+    //
+    // When invoked, `absl::Hash<T>` searches for supplied hash functions in the
+    // following order:
+    //
+    //   * Natively supported types out of the box (see above)
+    //   * Types for which an `AbslHashValue()` overload is provided (such as
+    //     user-defined types). See "Adding Type Support to `absl::Hash`" below.
+    //   * Types which define a `std::hash<T>` specialization
+    //
+    // The fallback to legacy hash functions exists mainly for backwards
+    // compatibility. If you have a choice, prefer defining an `AbslHashValue`
+    // overload instead of specializing any legacy hash functors.
+    //
+    // -----------------------------------------------------------------------------
+    // The Hash State Concept, and using `HashState` for Type Erasure
+    // -----------------------------------------------------------------------------
+    //
+    // The `absl::Hash` framework relies on the Concept of a "hash state." Such a
+    // hash state is used in several places:
+    //
+    // * Within existing implementations of `absl::Hash<T>` to store the hashed
+    //   state of an object. Note that it is up to the implementation how it stores
+    //   such state. A hash table, for example, may mix the state to produce an
+    //   integer value; a testing framework may simply hold a vector of that state.
+    // * Within implementations of `AbslHashValue()` used to extend user-defined
+    //   types. (See "Adding Type Support to absl::Hash" below.)
+    // * Inside a `HashState`, providing type erasure for the concept of a hash
+    //   state, which you can use to extend the `absl::Hash` framework for types
+    //   that are otherwise difficult to extend using `AbslHashValue()`. (See the
+    //   `HashState` class below.)
+    //
+    // The "hash state" concept contains three member functions for mixing hash
+    // state:
+    //
+    // * `H::combine(state, values...)`
+    //
+    //   Combines an arbitrary number of values into a hash state, returning the
+    //   updated state. Note that the existing hash state is move-only and must be
+    //   passed by value.
+    //
+    //   Each of the value types T must be hashable by H.
+    //
+    //   NOTE:
+    //
+    //     state = H::combine(std::move(state), value1, value2, value3);
+    //
+    //   must be guaranteed to produce the same hash expansion as
+    //
+    //     state = H::combine(std::move(state), value1);
+    //     state = H::combine(std::move(state), value2);
+    //     state = H::combine(std::move(state), value3);
+    //
+    // * `H::combine_contiguous(state, data, size)`
+    //
+    //    Combines a contiguous array of `size` elements into a hash state,
+    //    returning the updated state. Note that the existing hash state is
+    //    move-only and must be passed by value.
+    //
+    //    NOTE:
+    //
+    //      state = H::combine_contiguous(std::move(state), data, size);
+    //
+    //    need NOT be guaranteed to produce the same hash expansion as a loop
+    //    (it may perform internal optimizations). If you need this guarantee, use a
+    //    loop instead.
+    //
+    // * `H::combine_unordered(state, begin, end)`
+    //
+    //    Combines a set of elements denoted by an iterator pair into a hash
+    //    state, returning the updated state.  Note that the existing hash
+    //    state is move-only and must be passed by value.
+    //
+    //    Unlike the other two methods, the hashing is order-independent.
+    //    This can be used to hash unordered collections.
+    //
+    // -----------------------------------------------------------------------------
+    // Adding Type Support to `absl::Hash`
+    // -----------------------------------------------------------------------------
+    //
+    // To add support for your user-defined type, add a proper `AbslHashValue()`
+    // overload as a free (non-member) function. The overload will take an
+    // existing hash state and should combine that state with state from the type.
+    //
+    // Example:
+    //
+    //   template <typename H>
+    //   H AbslHashValue(H state, const MyType& v) {
+    //     return H::combine(std::move(state), v.field1, ..., v.fieldN);
+    //   }
+    //
+    // where `(field1, ..., fieldN)` are the members you would use on your
+    // `operator==` to define equality.
+    //
+    // Notice that `AbslHashValue` is not a class member, but an ordinary function.
+    // An `AbslHashValue` overload for a type should only be declared in the same
+    // file and namespace as said type. The proper `AbslHashValue` implementation
+    // for a given type will be discovered via ADL.
+    //
+    // Note: unlike `std::hash', `absl::Hash` should never be specialized. It must
+    // only be extended by adding `AbslHashValue()` overloads.
+    //
+    template<typename T>
+    using Hash = absl::hash_internal::Hash<T>;
 
-// HashOf
-//
-// absl::HashOf() is a helper that generates a hash from the values of its
-// arguments.  It dispatches to absl::Hash directly, as follows:
-//  * HashOf(t) == absl::Hash<T>{}(t)
-//  * HashOf(a, b, c) == HashOf(std::make_tuple(a, b, c))
-//
-// HashOf(a1, a2, ...) == HashOf(b1, b2, ...) is guaranteed when
-//  * The argument lists have pairwise identical C++ types
-//  * a1 == b1 && a2 == b2 && ...
-//
-// The requirement that the arguments match in both type and value is critical.
-// It means that `a == b` does not necessarily imply `HashOf(a) == HashOf(b)` if
-// `a` and `b` have different types. For example, `HashOf(2) != HashOf(2.0)`.
-template <int&... ExplicitArgumentBarrier, typename... Types>
-size_t HashOf(const Types&... values) {
-  auto tuple = std::tie(values...);
-  return absl::Hash<decltype(tuple)>{}(tuple);
-}
+    // HashOf
+    //
+    // absl::HashOf() is a helper that generates a hash from the values of its
+    // arguments.  It dispatches to absl::Hash directly, as follows:
+    //  * HashOf(t) == absl::Hash<T>{}(t)
+    //  * HashOf(a, b, c) == HashOf(std::make_tuple(a, b, c))
+    //
+    // HashOf(a1, a2, ...) == HashOf(b1, b2, ...) is guaranteed when
+    //  * The argument lists have pairwise identical C++ types
+    //  * a1 == b1 && a2 == b2 && ...
+    //
+    // The requirement that the arguments match in both type and value is critical.
+    // It means that `a == b` does not necessarily imply `HashOf(a) == HashOf(b)` if
+    // `a` and `b` have different types. For example, `HashOf(2) != HashOf(2.0)`.
+    template<int&... ExplicitArgumentBarrier, typename... Types>
+    size_t HashOf(const Types&... values)
+    {
+        auto tuple = std::tie(values...);
+        return absl::Hash<decltype(tuple)>{}(tuple);
+    }
 
-// HashState
-//
-// A type erased version of the hash state concept, for use in user-defined
-// `AbslHashValue` implementations that can't use templates (such as PImpl
-// classes, virtual functions, etc.). The type erasure adds overhead so it
-// should be avoided unless necessary.
-//
-// Note: This wrapper will only erase calls to
-//     combine_contiguous(H, const unsigned char*, size_t)
-//     RunCombineUnordered(H, CombinerF)
-//
-// All other calls will be handled internally and will not invoke overloads
-// provided by the wrapped class.
-//
-// Users of this class should still define a template `AbslHashValue` function,
-// but can use `absl::HashState::Create(&state)` to erase the type of the hash
-// state and dispatch to their private hashing logic.
-//
-// This state can be used like any other hash state. In particular, you can call
-// `HashState::combine()` and `HashState::combine_contiguous()` on it.
-//
-// Example:
-//
-//   class Interface {
-//    public:
-//     template <typename H>
-//     friend H AbslHashValue(H state, const Interface& value) {
-//       state = H::combine(std::move(state), std::type_index(typeid(*this)));
-//       value.HashValue(absl::HashState::Create(&state));
-//       return state;
-//     }
-//    private:
-//     virtual void HashValue(absl::HashState state) const = 0;
-//   };
-//
-//   class Impl : Interface {
-//    private:
-//     void HashValue(absl::HashState state) const override {
-//       absl::HashState::combine(std::move(state), v1_, v2_);
-//     }
-//     int v1_;
-//     std::string v2_;
-//   };
-class HashState : public hash_internal::HashStateBase<HashState> {
- public:
-  // HashState::Create()
-  //
-  // Create a new `HashState` instance that wraps `state`. All calls to
-  // `combine()` and `combine_contiguous()` on the new instance will be
-  // redirected to the original `state` object. The `state` object must outlive
-  // the `HashState` instance.
-  template <typename T>
-  static HashState Create(T* state) {
-    HashState s;
-    s.Init(state);
-    return s;
-  }
+    // HashState
+    //
+    // A type erased version of the hash state concept, for use in user-defined
+    // `AbslHashValue` implementations that can't use templates (such as PImpl
+    // classes, virtual functions, etc.). The type erasure adds overhead so it
+    // should be avoided unless necessary.
+    //
+    // Note: This wrapper will only erase calls to
+    //     combine_contiguous(H, const unsigned char*, size_t)
+    //     RunCombineUnordered(H, CombinerF)
+    //
+    // All other calls will be handled internally and will not invoke overloads
+    // provided by the wrapped class.
+    //
+    // Users of this class should still define a template `AbslHashValue` function,
+    // but can use `absl::HashState::Create(&state)` to erase the type of the hash
+    // state and dispatch to their private hashing logic.
+    //
+    // This state can be used like any other hash state. In particular, you can call
+    // `HashState::combine()` and `HashState::combine_contiguous()` on it.
+    //
+    // Example:
+    //
+    //   class Interface {
+    //    public:
+    //     template <typename H>
+    //     friend H AbslHashValue(H state, const Interface& value) {
+    //       state = H::combine(std::move(state), std::type_index(typeid(*this)));
+    //       value.HashValue(absl::HashState::Create(&state));
+    //       return state;
+    //     }
+    //    private:
+    //     virtual void HashValue(absl::HashState state) const = 0;
+    //   };
+    //
+    //   class Impl : Interface {
+    //    private:
+    //     void HashValue(absl::HashState state) const override {
+    //       absl::HashState::combine(std::move(state), v1_, v2_);
+    //     }
+    //     int v1_;
+    //     std::string v2_;
+    //   };
+    class HashState : public hash_internal::HashStateBase<HashState>
+    {
+    public:
+        // HashState::Create()
+        //
+        // Create a new `HashState` instance that wraps `state`. All calls to
+        // `combine()` and `combine_contiguous()` on the new instance will be
+        // redirected to the original `state` object. The `state` object must outlive
+        // the `HashState` instance.
+        template<typename T>
+        static HashState Create(T* state)
+        {
+            HashState s;
+            s.Init(state);
+            return s;
+        }
 
-  HashState(const HashState&) = delete;
-  HashState& operator=(const HashState&) = delete;
-  HashState(HashState&&) = default;
-  HashState& operator=(HashState&&) = default;
+        HashState(const HashState&) = delete;
+        HashState& operator=(const HashState&) = delete;
+        HashState(HashState&&) = default;
+        HashState& operator=(HashState&&) = default;
 
-  // HashState::combine()
-  //
-  // Combines an arbitrary number of values into a hash state, returning the
-  // updated state.
-  using HashState::HashStateBase::combine;
+        // HashState::combine()
+        //
+        // Combines an arbitrary number of values into a hash state, returning the
+        // updated state.
+        using HashState::HashStateBase::combine;
 
-  // HashState::combine_contiguous()
-  //
-  // Combines a contiguous array of `size` elements into a hash state, returning
-  // the updated state.
-  static HashState combine_contiguous(HashState hash_state,
-                                      const unsigned char* first, size_t size) {
-    hash_state.combine_contiguous_(hash_state.state_, first, size);
-    return hash_state;
-  }
-  using HashState::HashStateBase::combine_contiguous;
+        // HashState::combine_contiguous()
+        //
+        // Combines a contiguous array of `size` elements into a hash state, returning
+        // the updated state.
+        static HashState combine_contiguous(HashState hash_state, const unsigned char* first, size_t size)
+        {
+            hash_state.combine_contiguous_(hash_state.state_, first, size);
+            return hash_state;
+        }
+        using HashState::HashStateBase::combine_contiguous;
 
- private:
-  HashState() = default;
+    private:
+        HashState() = default;
 
-  friend class HashState::HashStateBase;
+        friend class HashState::HashStateBase;
 
-  template <typename T>
-  static void CombineContiguousImpl(void* p, const unsigned char* first,
-                                    size_t size) {
-    T& state = *static_cast<T*>(p);
-    state = T::combine_contiguous(std::move(state), first, size);
-  }
+        template<typename T>
+        static void CombineContiguousImpl(void* p, const unsigned char* first, size_t size)
+        {
+            T& state = *static_cast<T*>(p);
+            state = T::combine_contiguous(std::move(state), first, size);
+        }
 
-  template <typename T>
-  void Init(T* state) {
-    state_ = state;
-    combine_contiguous_ = &CombineContiguousImpl<T>;
-    run_combine_unordered_ = &RunCombineUnorderedImpl<T>;
-  }
+        template<typename T>
+        void Init(T* state)
+        {
+            state_ = state;
+            combine_contiguous_ = &CombineContiguousImpl<T>;
+            run_combine_unordered_ = &RunCombineUnorderedImpl<T>;
+        }
 
-  template <typename HS>
-  struct CombineUnorderedInvoker {
-    template <typename T, typename ConsumerT>
-    void operator()(T inner_state, ConsumerT inner_cb) {
-      f(HashState::Create(&inner_state),
-        [&](HashState& inner_erased) { inner_cb(inner_erased.Real<T>()); });
-    }
+        template<typename HS>
+        struct CombineUnorderedInvoker
+        {
+            template<typename T, typename ConsumerT>
+            void operator()(T inner_state, ConsumerT inner_cb)
+            {
+                f(HashState::Create(&inner_state),
+                  [&](HashState& inner_erased)
+                  { inner_cb(inner_erased.Real<T>()); });
+            }
 
-    absl::FunctionRef<void(HS, absl::FunctionRef<void(HS&)>)> f;
-  };
+            absl::FunctionRef<void(HS, absl::FunctionRef<void(HS&)>)> f;
+        };
 
-  template <typename T>
-  static HashState RunCombineUnorderedImpl(
-      HashState state,
-      absl::FunctionRef<void(HashState, absl::FunctionRef<void(HashState&)>)>
-          f) {
-    // Note that this implementation assumes that inner_state and outer_state
-    // are the same type.  This isn't true in the SpyHash case, but SpyHash
-    // types are move-convertible to each other, so this still works.
-    T& real_state = state.Real<T>();
-    real_state = T::RunCombineUnordered(
-        std::move(real_state), CombineUnorderedInvoker<HashState>{f});
-    return state;
-  }
+        template<typename T>
+        static HashState RunCombineUnorderedImpl(
+            HashState state,
+            absl::FunctionRef<void(HashState, absl::FunctionRef<void(HashState&)>)>
+                f
+        )
+        {
+            // Note that this implementation assumes that inner_state and outer_state
+            // are the same type.  This isn't true in the SpyHash case, but SpyHash
+            // types are move-convertible to each other, so this still works.
+            T& real_state = state.Real<T>();
+            real_state = T::RunCombineUnordered(
+                std::move(real_state), CombineUnorderedInvoker<HashState>{f}
+            );
+            return state;
+        }
 
-  template <typename CombinerT>
-  static HashState RunCombineUnordered(HashState state, CombinerT combiner) {
-    auto* run = state.run_combine_unordered_;
-    return run(std::move(state), std::ref(combiner));
-  }
+        template<typename CombinerT>
+        static HashState RunCombineUnordered(HashState state, CombinerT combiner)
+        {
+            auto* run = state.run_combine_unordered_;
+            return run(std::move(state), std::ref(combiner));
+        }
 
-  // Do not erase an already erased state.
-  void Init(HashState* state) {
-    state_ = state->state_;
-    combine_contiguous_ = state->combine_contiguous_;
-    run_combine_unordered_ = state->run_combine_unordered_;
-  }
+        // Do not erase an already erased state.
+        void Init(HashState* state)
+        {
+            state_ = state->state_;
+            combine_contiguous_ = state->combine_contiguous_;
+            run_combine_unordered_ = state->run_combine_unordered_;
+        }
 
-  template <typename T>
-  T& Real() {
-    return *static_cast<T*>(state_);
-  }
+        template<typename T>
+        T& Real()
+        {
+            return *static_cast<T*>(state_);
+        }
 
-  void* state_;
-  void (*combine_contiguous_)(void*, const unsigned char*, size_t);
-  HashState (*run_combine_unordered_)(
-      HashState state,
-      absl::FunctionRef<void(HashState, absl::FunctionRef<void(HashState&)>)>);
-};
+        void* state_;
+        void (*combine_contiguous_)(void*, const unsigned char*, size_t);
+        HashState (*run_combine_unordered_)(
+            HashState state,
+            absl::FunctionRef<void(HashState, absl::FunctionRef<void(HashState&)>)>
+        );
+    };
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_HASH_HASH_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/hash_testing.h b/CAPI/cpp/grpc/include/absl/hash/hash_testing.h
index 1e1c574..5852ded 100644
--- a/CAPI/cpp/grpc/include/absl/hash/hash_testing.h
+++ b/CAPI/cpp/grpc/include/absl/hash/hash_testing.h
@@ -27,352 +27,404 @@
 #include "absl/strings/str_cat.h"
 #include "absl/types/variant.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Run the absl::Hash algorithm over all the elements passed in and verify that
-// their hash expansion is congruent with their `==` operator.
-//
-// It is used in conjunction with EXPECT_TRUE. Failures will output information
-// on what requirement failed and on which objects.
-//
-// Users should pass a collection of types as either an initializer list or a
-// container of cases.
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       {v1, v2, ..., vN}));
-//
-//   std::vector<MyType> cases;
-//   // Fill cases...
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(cases));
-//
-// Users can pass a variety of types for testing heterogeneous lookup with
-// `std::make_tuple`:
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       std::make_tuple(v1, v2, ..., vN)));
-//
-//
-// Ideally, the values passed should provide enough coverage of the `==`
-// operator and the AbslHashValue implementations.
-// For dynamically sized types, the empty state should usually be included in
-// the values.
-//
-// The function accepts an optional comparator function, in case that `==` is
-// not enough for the values provided.
-//
-// Usage:
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       std::make_tuple(v1, v2, ..., vN), MyCustomEq{}));
-//
-// It checks the following requirements:
-//   1. The expansion for a value is deterministic.
-//   2. For any two objects `a` and `b` in the sequence, if `a == b` evaluates
-//      to true, then their hash expansion must be equal.
-//   3. If `a == b` evaluates to false their hash expansion must be unequal.
-//   4. If `a == b` evaluates to false neither hash expansion can be a
-//      suffix of the other.
-//   5. AbslHashValue overloads should not be called by the user. They are only
-//      meant to be called by the framework. Users should call H::combine() and
-//      H::combine_contiguous().
-//   6. No moved-from instance of the hash state is used in the implementation
-//      of AbslHashValue.
-//
-// The values do not have to have the same type. This can be useful for
-// equivalent types that support heterogeneous lookup.
-//
-// A possible reason for breaking (2) is combining state in the hash expansion
-// that was not used in `==`.
-// For example:
-//
-// struct Bad2 {
-//   int a, b;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad2 x) {
-//     // Uses a and b.
-//     return H::combine(std::move(state), x.a, x.b);
-//   }
-//   friend bool operator==(Bad2 x, Bad2 y) {
-//     // Only uses a.
-//     return x.a == y.a;
-//   }
-// };
-//
-// As for (3), breaking this usually means that there is state being passed to
-// the `==` operator that is not used in the hash expansion.
-// For example:
-//
-// struct Bad3 {
-//   int a, b;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad3 x) {
-//     // Only uses a.
-//     return H::combine(std::move(state), x.a);
-//   }
-//   friend bool operator==(Bad3 x, Bad3 y) {
-//     // Uses a and b.
-//     return x.a == y.a && x.b == y.b;
-//   }
-// };
-//
-// Finally, a common way to break 4 is by combining dynamic ranges without
-// combining the size of the range.
-// For example:
-//
-// struct Bad4 {
-//   int *p, size;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad4 x) {
-//     return H::combine_contiguous(std::move(state), x.p, x.p + x.size);
-//   }
-//   friend bool operator==(Bad4 x, Bad4 y) {
-//    // Compare two ranges for equality. C++14 code can instead use std::equal.
-//     return absl::equal(x.p, x.p + x.size, y.p, y.p + y.size);
-//   }
-// };
-//
-// An easy solution to this is to combine the size after combining the range,
-// like so:
-// template <typename H>
-// friend H AbslHashValue(H state, Bad4 x) {
-//   return H::combine(
-//       H::combine_contiguous(std::move(state), x.p, x.p + x.size), x.size);
-// }
-//
-template <int&... ExplicitBarrier, typename Container>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values);
-
-template <int&... ExplicitBarrier, typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals);
-
-template <int&..., typename T>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values);
-
-template <int&..., typename T, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
-                                      Eq equals);
-
-namespace hash_internal {
-
-struct PrintVisitor {
-  size_t index;
-  template <typename T>
-  std::string operator()(const T* value) const {
-    return absl::StrCat("#", index, "(", testing::PrintToString(*value), ")");
-  }
-};
-
-template <typename Eq>
-struct EqVisitor {
-  Eq eq;
-  template <typename T, typename U>
-  bool operator()(const T* t, const U* u) const {
-    return eq(*t, *u);
-  }
-};
-
-struct ExpandVisitor {
-  template <typename T>
-  SpyHashState operator()(const T* value) const {
-    return SpyHashState::combine(SpyHashState(), *value);
-  }
-};
-
-template <typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
-  using V = typename Container::value_type;
-
-  struct Info {
-    const V& value;
-    size_t index;
-    std::string ToString() const {
-      return absl::visit(PrintVisitor{index}, value);
-    }
-    SpyHashState expand() const { return absl::visit(ExpandVisitor{}, value); }
-  };
-
-  using EqClass = std::vector<Info>;
-  std::vector<EqClass> classes;
-
-  // Gather the values in equivalence classes.
-  size_t i = 0;
-  for (const auto& value : values) {
-    EqClass* c = nullptr;
-    for (auto& eqclass : classes) {
-      if (absl::visit(EqVisitor<Eq>{equals}, value, eqclass[0].value)) {
-        c = &eqclass;
-        break;
-      }
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // Run the absl::Hash algorithm over all the elements passed in and verify that
+    // their hash expansion is congruent with their `==` operator.
+    //
+    // It is used in conjunction with EXPECT_TRUE. Failures will output information
+    // on what requirement failed and on which objects.
+    //
+    // Users should pass a collection of types as either an initializer list or a
+    // container of cases.
+    //
+    //   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
+    //       {v1, v2, ..., vN}));
+    //
+    //   std::vector<MyType> cases;
+    //   // Fill cases...
+    //   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(cases));
+    //
+    // Users can pass a variety of types for testing heterogeneous lookup with
+    // `std::make_tuple`:
+    //
+    //   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
+    //       std::make_tuple(v1, v2, ..., vN)));
+    //
+    //
+    // Ideally, the values passed should provide enough coverage of the `==`
+    // operator and the AbslHashValue implementations.
+    // For dynamically sized types, the empty state should usually be included in
+    // the values.
+    //
+    // The function accepts an optional comparator function, in case that `==` is
+    // not enough for the values provided.
+    //
+    // Usage:
+    //
+    //   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
+    //       std::make_tuple(v1, v2, ..., vN), MyCustomEq{}));
+    //
+    // It checks the following requirements:
+    //   1. The expansion for a value is deterministic.
+    //   2. For any two objects `a` and `b` in the sequence, if `a == b` evaluates
+    //      to true, then their hash expansion must be equal.
+    //   3. If `a == b` evaluates to false their hash expansion must be unequal.
+    //   4. If `a == b` evaluates to false neither hash expansion can be a
+    //      suffix of the other.
+    //   5. AbslHashValue overloads should not be called by the user. They are only
+    //      meant to be called by the framework. Users should call H::combine() and
+    //      H::combine_contiguous().
+    //   6. No moved-from instance of the hash state is used in the implementation
+    //      of AbslHashValue.
+    //
+    // The values do not have to have the same type. This can be useful for
+    // equivalent types that support heterogeneous lookup.
+    //
+    // A possible reason for breaking (2) is combining state in the hash expansion
+    // that was not used in `==`.
+    // For example:
+    //
+    // struct Bad2 {
+    //   int a, b;
+    //   template <typename H>
+    //   friend H AbslHashValue(H state, Bad2 x) {
+    //     // Uses a and b.
+    //     return H::combine(std::move(state), x.a, x.b);
+    //   }
+    //   friend bool operator==(Bad2 x, Bad2 y) {
+    //     // Only uses a.
+    //     return x.a == y.a;
+    //   }
+    // };
+    //
+    // As for (3), breaking this usually means that there is state being passed to
+    // the `==` operator that is not used in the hash expansion.
+    // For example:
+    //
+    // struct Bad3 {
+    //   int a, b;
+    //   template <typename H>
+    //   friend H AbslHashValue(H state, Bad3 x) {
+    //     // Only uses a.
+    //     return H::combine(std::move(state), x.a);
+    //   }
+    //   friend bool operator==(Bad3 x, Bad3 y) {
+    //     // Uses a and b.
+    //     return x.a == y.a && x.b == y.b;
+    //   }
+    // };
+    //
+    // Finally, a common way to break 4 is by combining dynamic ranges without
+    // combining the size of the range.
+    // For example:
+    //
+    // struct Bad4 {
+    //   int *p, size;
+    //   template <typename H>
+    //   friend H AbslHashValue(H state, Bad4 x) {
+    //     return H::combine_contiguous(std::move(state), x.p, x.p + x.size);
+    //   }
+    //   friend bool operator==(Bad4 x, Bad4 y) {
+    //    // Compare two ranges for equality. C++14 code can instead use std::equal.
+    //     return absl::equal(x.p, x.p + x.size, y.p, y.p + y.size);
+    //   }
+    // };
+    //
+    // An easy solution to this is to combine the size after combining the range,
+    // like so:
+    // template <typename H>
+    // friend H AbslHashValue(H state, Bad4 x) {
+    //   return H::combine(
+    //       H::combine_contiguous(std::move(state), x.p, x.p + x.size), x.size);
+    // }
+    //
+    template<int&... ExplicitBarrier, typename Container>
+    ABSL_MUST_USE_RESULT testing::AssertionResult
+        VerifyTypeImplementsAbslHashCorrectly(const Container& values);
+
+    template<int&... ExplicitBarrier, typename Container, typename Eq>
+    ABSL_MUST_USE_RESULT testing::AssertionResult
+        VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals);
+
+    template<int&..., typename T>
+    ABSL_MUST_USE_RESULT testing::AssertionResult
+        VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values);
+
+    template<int&..., typename T, typename Eq>
+    ABSL_MUST_USE_RESULT testing::AssertionResult
+        VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values, Eq equals);
+
+    namespace hash_internal
+    {
+
+        struct PrintVisitor
+        {
+            size_t index;
+            template<typename T>
+            std::string operator()(const T* value) const
+            {
+                return absl::StrCat("#", index, "(", testing::PrintToString(*value), ")");
+            }
+        };
+
+        template<typename Eq>
+        struct EqVisitor
+        {
+            Eq eq;
+            template<typename T, typename U>
+            bool operator()(const T* t, const U* u) const
+            {
+                return eq(*t, *u);
+            }
+        };
+
+        struct ExpandVisitor
+        {
+            template<typename T>
+            SpyHashState operator()(const T* value) const
+            {
+                return SpyHashState::combine(SpyHashState(), *value);
+            }
+        };
+
+        template<typename Container, typename Eq>
+        ABSL_MUST_USE_RESULT testing::AssertionResult
+            VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals)
+        {
+            using V = typename Container::value_type;
+
+            struct Info
+            {
+                const V& value;
+                size_t index;
+                std::string ToString() const
+                {
+                    return absl::visit(PrintVisitor{index}, value);
+                }
+                SpyHashState expand() const
+                {
+                    return absl::visit(ExpandVisitor{}, value);
+                }
+            };
+
+            using EqClass = std::vector<Info>;
+            std::vector<EqClass> classes;
+
+            // Gather the values in equivalence classes.
+            size_t i = 0;
+            for (const auto& value : values)
+            {
+                EqClass* c = nullptr;
+                for (auto& eqclass : classes)
+                {
+                    if (absl::visit(EqVisitor<Eq>{equals}, value, eqclass[0].value))
+                    {
+                        c = &eqclass;
+                        break;
+                    }
+                }
+                if (c == nullptr)
+                {
+                    classes.emplace_back();
+                    c = &classes.back();
+                }
+                c->push_back({value, i});
+                ++i;
+
+                // Verify potential errors captured by SpyHashState.
+                if (auto error = c->back().expand().error())
+                {
+                    return testing::AssertionFailure() << *error;
+                }
+            }
+
+            if (classes.size() < 2)
+            {
+                return testing::AssertionFailure()
+                       << "At least two equivalence classes are expected.";
+            }
+
+            // We assume that equality is correctly implemented.
+            // Now we verify that AbslHashValue is also correctly implemented.
+
+            for (const auto& c : classes)
+            {
+                // All elements of the equivalence class must have the same hash
+                // expansion.
+                const SpyHashState expected = c[0].expand();
+                for (const Info& v : c)
+                {
+                    if (v.expand() != v.expand())
+                    {
+                        return testing::AssertionFailure()
+                               << "Hash expansion for " << v.ToString()
+                               << " is non-deterministic.";
+                    }
+                    if (v.expand() != expected)
+                    {
+                        return testing::AssertionFailure()
+                               << "Values " << c[0].ToString() << " and " << v.ToString()
+                               << " evaluate as equal but have an unequal hash expansion.";
+                    }
+                }
+
+                // Elements from other classes must have different hash expansion.
+                for (const auto& c2 : classes)
+                {
+                    if (&c == &c2)
+                        continue;
+                    const SpyHashState c2_hash = c2[0].expand();
+                    switch (SpyHashState::Compare(expected, c2_hash))
+                    {
+                        case SpyHashState::CompareResult::kEqual:
+                            return testing::AssertionFailure()
+                                   << "Values " << c[0].ToString() << " and " << c2[0].ToString()
+                                   << " evaluate as unequal but have an equal hash expansion.";
+                        case SpyHashState::CompareResult::kBSuffixA:
+                            return testing::AssertionFailure()
+                                   << "Hash expansion of " << c2[0].ToString()
+                                   << " is a suffix of the hash expansion of " << c[0].ToString()
+                                   << ".";
+                        case SpyHashState::CompareResult::kASuffixB:
+                            return testing::AssertionFailure()
+                                   << "Hash expansion of " << c[0].ToString()
+                                   << " is a suffix of the hash expansion of " << c2[0].ToString()
+                                   << ".";
+                        case SpyHashState::CompareResult::kUnequal:
+                            break;
+                    }
+                }
+            }
+            return testing::AssertionSuccess();
+        }
+
+        template<typename... T>
+        struct TypeSet
+        {
+            template<typename U, bool = disjunction<std::is_same<T, U>...>::value>
+            struct Insert
+            {
+                using type = TypeSet<U, T...>;
+            };
+            template<typename U>
+            struct Insert<U, true>
+            {
+                using type = TypeSet;
+            };
+
+            template<template<typename...> class C>
+            using apply = C<T...>;
+        };
+
+        template<typename... T>
+        struct MakeTypeSet : TypeSet<>
+        {
+        };
+        template<typename T, typename... Ts>
+        struct MakeTypeSet<T, Ts...> : MakeTypeSet<Ts...>::template Insert<T>::type
+        {
+        };
+
+        template<typename... T>
+        using VariantForTypes = typename MakeTypeSet<
+            const typename std::decay<T>::type*...>::template apply<absl::variant>;
+
+        template<typename Container>
+        struct ContainerAsVector
+        {
+            using V = absl::variant<const typename Container::value_type*>;
+            using Out = std::vector<V>;
+
+            static Out Do(const Container& values)
+            {
+                Out out;
+                for (const auto& v : values)
+                    out.push_back(&v);
+                return out;
+            }
+        };
+
+        template<typename... T>
+        struct ContainerAsVector<std::tuple<T...>>
+        {
+            using V = VariantForTypes<T...>;
+            using Out = std::vector<V>;
+
+            template<size_t... I>
+            static Out DoImpl(const std::tuple<T...>& tuple, absl::index_sequence<I...>)
+            {
+                return Out{&std::get<I>(tuple)...};
+            }
+
+            static Out Do(const std::tuple<T...>& values)
+            {
+                return DoImpl(values, absl::index_sequence_for<T...>());
+            }
+        };
+
+        template<>
+        struct ContainerAsVector<std::tuple<>>
+        {
+            static std::vector<VariantForTypes<int>> Do(std::tuple<>)
+            {
+                return {};
+            }
+        };
+
+        struct DefaultEquals
+        {
+            template<typename T, typename U>
+            bool operator()(const T& t, const U& u) const
+            {
+                return t == u;
+            }
+        };
+
+    }  // namespace hash_internal
+
+    template<int&..., typename Container>
+    ABSL_MUST_USE_RESULT testing::AssertionResult
+        VerifyTypeImplementsAbslHashCorrectly(const Container& values)
+    {
+        return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
+            hash_internal::ContainerAsVector<Container>::Do(values),
+            hash_internal::DefaultEquals{}
+        );
     }
-    if (c == nullptr) {
-      classes.emplace_back();
-      c = &classes.back();
-    }
-    c->push_back({value, i});
-    ++i;
 
-    // Verify potential errors captured by SpyHashState.
-    if (auto error = c->back().expand().error()) {
-      return testing::AssertionFailure() << *error;
+    template<int&..., typename Container, typename Eq>
+    ABSL_MUST_USE_RESULT testing::AssertionResult
+        VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals)
+    {
+        return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
+            hash_internal::ContainerAsVector<Container>::Do(values), equals
+        );
     }
-  }
-
-  if (classes.size() < 2) {
-    return testing::AssertionFailure()
-           << "At least two equivalence classes are expected.";
-  }
-
-  // We assume that equality is correctly implemented.
-  // Now we verify that AbslHashValue is also correctly implemented.
-
-  for (const auto& c : classes) {
-    // All elements of the equivalence class must have the same hash
-    // expansion.
-    const SpyHashState expected = c[0].expand();
-    for (const Info& v : c) {
-      if (v.expand() != v.expand()) {
-        return testing::AssertionFailure()
-               << "Hash expansion for " << v.ToString()
-               << " is non-deterministic.";
-      }
-      if (v.expand() != expected) {
-        return testing::AssertionFailure()
-               << "Values " << c[0].ToString() << " and " << v.ToString()
-               << " evaluate as equal but have an unequal hash expansion.";
-      }
+
+    template<int&..., typename T>
+    ABSL_MUST_USE_RESULT testing::AssertionResult
+        VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values)
+    {
+        return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
+            hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
+            hash_internal::DefaultEquals{}
+        );
     }
 
-    // Elements from other classes must have different hash expansion.
-    for (const auto& c2 : classes) {
-      if (&c == &c2) continue;
-      const SpyHashState c2_hash = c2[0].expand();
-      switch (SpyHashState::Compare(expected, c2_hash)) {
-        case SpyHashState::CompareResult::kEqual:
-          return testing::AssertionFailure()
-                 << "Values " << c[0].ToString() << " and " << c2[0].ToString()
-                 << " evaluate as unequal but have an equal hash expansion.";
-        case SpyHashState::CompareResult::kBSuffixA:
-          return testing::AssertionFailure()
-                 << "Hash expansion of " << c2[0].ToString()
-                 << " is a suffix of the hash expansion of " << c[0].ToString()
-                 << ".";
-        case SpyHashState::CompareResult::kASuffixB:
-          return testing::AssertionFailure()
-                 << "Hash expansion of " << c[0].ToString()
-                 << " is a suffix of the hash expansion of " << c2[0].ToString()
-                 << ".";
-        case SpyHashState::CompareResult::kUnequal:
-          break;
-      }
+    template<int&..., typename T, typename Eq>
+    ABSL_MUST_USE_RESULT testing::AssertionResult
+        VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values, Eq equals)
+    {
+        return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
+            hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
+            equals
+        );
     }
-  }
-  return testing::AssertionSuccess();
-}
-
-template <typename... T>
-struct TypeSet {
-  template <typename U, bool = disjunction<std::is_same<T, U>...>::value>
-  struct Insert {
-    using type = TypeSet<U, T...>;
-  };
-  template <typename U>
-  struct Insert<U, true> {
-    using type = TypeSet;
-  };
-
-  template <template <typename...> class C>
-  using apply = C<T...>;
-};
-
-template <typename... T>
-struct MakeTypeSet : TypeSet<> {};
-template <typename T, typename... Ts>
-struct MakeTypeSet<T, Ts...> : MakeTypeSet<Ts...>::template Insert<T>::type {};
-
-template <typename... T>
-using VariantForTypes = typename MakeTypeSet<
-    const typename std::decay<T>::type*...>::template apply<absl::variant>;
-
-template <typename Container>
-struct ContainerAsVector {
-  using V = absl::variant<const typename Container::value_type*>;
-  using Out = std::vector<V>;
-
-  static Out Do(const Container& values) {
-    Out out;
-    for (const auto& v : values) out.push_back(&v);
-    return out;
-  }
-};
-
-template <typename... T>
-struct ContainerAsVector<std::tuple<T...>> {
-  using V = VariantForTypes<T...>;
-  using Out = std::vector<V>;
-
-  template <size_t... I>
-  static Out DoImpl(const std::tuple<T...>& tuple, absl::index_sequence<I...>) {
-    return Out{&std::get<I>(tuple)...};
-  }
-
-  static Out Do(const std::tuple<T...>& values) {
-    return DoImpl(values, absl::index_sequence_for<T...>());
-  }
-};
-
-template <>
-struct ContainerAsVector<std::tuple<>> {
-  static std::vector<VariantForTypes<int>> Do(std::tuple<>) { return {}; }
-};
-
-struct DefaultEquals {
-  template <typename T, typename U>
-  bool operator()(const T& t, const U& u) const {
-    return t == u;
-  }
-};
-
-}  // namespace hash_internal
-
-template <int&..., typename Container>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<Container>::Do(values),
-      hash_internal::DefaultEquals{});
-}
-
-template <int&..., typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<Container>::Do(values), equals);
-}
-
-template <int&..., typename T>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
-      hash_internal::DefaultEquals{});
-}
-
-template <int&..., typename T, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
-                                      Eq equals) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
-      equals);
-}
-
-ABSL_NAMESPACE_END
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_HASH_HASH_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/internal/city.h b/CAPI/cpp/grpc/include/absl/hash/internal/city.h
index 393da0b..0639424 100644
--- a/CAPI/cpp/grpc/include/absl/hash/internal/city.h
+++ b/CAPI/cpp/grpc/include/absl/hash/internal/city.h
@@ -52,27 +52,28 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace hash_internal
+    {
 
-// Hash function for a byte array.
-uint64_t CityHash64(const char *s, size_t len);
+        // Hash function for a byte array.
+        uint64_t CityHash64(const char* s, size_t len);
 
-// Hash function for a byte array.  For convenience, a 64-bit seed is also
-// hashed into the result.
-uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed);
+        // Hash function for a byte array.  For convenience, a 64-bit seed is also
+        // hashed into the result.
+        uint64_t CityHash64WithSeed(const char* s, size_t len, uint64_t seed);
 
-// Hash function for a byte array.  For convenience, two seeds are also
-// hashed into the result.
-uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
-                             uint64_t seed1);
+        // Hash function for a byte array.  For convenience, two seeds are also
+        // hashed into the result.
+        uint64_t CityHash64WithSeeds(const char* s, size_t len, uint64_t seed0, uint64_t seed1);
 
-// Hash function for a byte array.  Most useful in 32-bit binaries.
-uint32_t CityHash32(const char *s, size_t len);
+        // Hash function for a byte array.  Most useful in 32-bit binaries.
+        uint32_t CityHash32(const char* s, size_t len);
 
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
+    }  // namespace hash_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_HASH_INTERNAL_CITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/internal/hash.h b/CAPI/cpp/grpc/include/absl/hash/internal/hash.h
index 45dfdd4..da58a48 100644
--- a/CAPI/cpp/grpc/include/absl/hash/internal/hash.h
+++ b/CAPI/cpp/grpc/include/absl/hash/internal/hash.h
@@ -55,779 +55,845 @@
 #include "absl/types/variant.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class HashState;
-
-namespace hash_internal {
-
-// Internal detail: Large buffers are hashed in smaller chunks.  This function
-// returns the size of these chunks.
-constexpr size_t PiecewiseChunkSize() { return 1024; }
-
-// PiecewiseCombiner
-//
-// PiecewiseCombiner is an internal-only helper class for hashing a piecewise
-// buffer of `char` or `unsigned char` as though it were contiguous.  This class
-// provides two methods:
-//
-//   H add_buffer(state, data, size)
-//   H finalize(state)
-//
-// `add_buffer` can be called zero or more times, followed by a single call to
-// `finalize`.  This will produce the same hash expansion as concatenating each
-// buffer piece into a single contiguous buffer, and passing this to
-// `H::combine_contiguous`.
-//
-//  Example usage:
-//    PiecewiseCombiner combiner;
-//    for (const auto& piece : pieces) {
-//      state = combiner.add_buffer(std::move(state), piece.data, piece.size);
-//    }
-//    return combiner.finalize(std::move(state));
-class PiecewiseCombiner {
- public:
-  PiecewiseCombiner() : position_(0) {}
-  PiecewiseCombiner(const PiecewiseCombiner&) = delete;
-  PiecewiseCombiner& operator=(const PiecewiseCombiner&) = delete;
-
-  // PiecewiseCombiner::add_buffer()
-  //
-  // Appends the given range of bytes to the sequence to be hashed, which may
-  // modify the provided hash state.
-  template <typename H>
-  H add_buffer(H state, const unsigned char* data, size_t size);
-  template <typename H>
-  H add_buffer(H state, const char* data, size_t size) {
-    return add_buffer(std::move(state),
-                      reinterpret_cast<const unsigned char*>(data), size);
-  }
-
-  // PiecewiseCombiner::finalize()
-  //
-  // Finishes combining the hash sequence, which may may modify the provided
-  // hash state.
-  //
-  // Once finalize() is called, add_buffer() may no longer be called. The
-  // resulting hash state will be the same as if the pieces passed to
-  // add_buffer() were concatenated into a single flat buffer, and then provided
-  // to H::combine_contiguous().
-  template <typename H>
-  H finalize(H state);
-
- private:
-  unsigned char buf_[PiecewiseChunkSize()];
-  size_t position_;
-};
-
-// is_hashable()
-//
-// Trait class which returns true if T is hashable by the absl::Hash framework.
-// Used for the AbslHashValue implementations for composite types below.
-template <typename T>
-struct is_hashable;
-
-// HashStateBase
-//
-// An internal implementation detail that contains common implementation details
-// for all of the "hash state objects" objects generated by Abseil.  This is not
-// a public API; users should not create classes that inherit from this.
-//
-// A hash state object is the template argument `H` passed to `AbslHashValue`.
-// It represents an intermediate state in the computation of an unspecified hash
-// algorithm. `HashStateBase` provides a CRTP style base class for hash state
-// implementations. Developers adding type support for `absl::Hash` should not
-// rely on any parts of the state object other than the following member
-// functions:
-//
-//   * HashStateBase::combine()
-//   * HashStateBase::combine_contiguous()
-//   * HashStateBase::combine_unordered()
-//
-// A derived hash state class of type `H` must provide a public member function
-// with a signature similar to the following:
-//
-//    `static H combine_contiguous(H state, const unsigned char*, size_t)`.
-//
-// It must also provide a private template method named RunCombineUnordered.
-//
-// A "consumer" is a 1-arg functor returning void.  Its argument is a reference
-// to an inner hash state object, and it may be called multiple times.  When
-// called, the functor consumes the entropy from the provided state object,
-// and resets that object to its empty state.
-//
-// A "combiner" is a stateless 2-arg functor returning void.  Its arguments are
-// an inner hash state object and an ElementStateConsumer functor.  A combiner
-// uses the provided inner hash state object to hash each element of the
-// container, passing the inner hash state object to the consumer after hashing
-// each element.
-//
-// Given these definitions, a derived hash state class of type H
-// must provide a private template method with a signature similar to the
-// following:
-//
-//    `template <typename CombinerT>`
-//    `static H RunCombineUnordered(H outer_state, CombinerT combiner)`
-//
-// This function is responsible for constructing the inner state object and
-// providing a consumer to the combiner.  It uses side effects of the consumer
-// and combiner to mix the state of each element in an order-independent manner,
-// and uses this to return an updated value of `outer_state`.
-//
-// This inside-out approach generates efficient object code in the normal case,
-// but allows us to use stack storage to implement the absl::HashState type
-// erasure mechanism (avoiding heap allocations while hashing).
-//
-// `HashStateBase` will provide a complete implementation for a hash state
-// object in terms of these two methods.
-//
-// Example:
-//
-//   // Use CRTP to define your derived class.
-//   struct MyHashState : HashStateBase<MyHashState> {
-//       static H combine_contiguous(H state, const unsigned char*, size_t);
-//       using MyHashState::HashStateBase::combine;
-//       using MyHashState::HashStateBase::combine_contiguous;
-//       using MyHashState::HashStateBase::combine_unordered;
-//     private:
-//       template <typename CombinerT>
-//       static H RunCombineUnordered(H state, CombinerT combiner);
-//   };
-template <typename H>
-class HashStateBase {
- public:
-  // HashStateBase::combine()
-  //
-  // Combines an arbitrary number of values into a hash state, returning the
-  // updated state.
-  //
-  // Each of the value types `T` must be separately hashable by the Abseil
-  // hashing framework.
-  //
-  // NOTE:
-  //
-  //   state = H::combine(std::move(state), value1, value2, value3);
-  //
-  // is guaranteed to produce the same hash expansion as:
-  //
-  //   state = H::combine(std::move(state), value1);
-  //   state = H::combine(std::move(state), value2);
-  //   state = H::combine(std::move(state), value3);
-  template <typename T, typename... Ts>
-  static H combine(H state, const T& value, const Ts&... values);
-  static H combine(H state) { return state; }
-
-  // HashStateBase::combine_contiguous()
-  //
-  // Combines a contiguous array of `size` elements into a hash state, returning
-  // the updated state.
-  //
-  // NOTE:
-  //
-  //   state = H::combine_contiguous(std::move(state), data, size);
-  //
-  // is NOT guaranteed to produce the same hash expansion as a for-loop (it may
-  // perform internal optimizations).  If you need this guarantee, use the
-  // for-loop instead.
-  template <typename T>
-  static H combine_contiguous(H state, const T* data, size_t size);
-
-  template <typename I>
-  static H combine_unordered(H state, I begin, I end);
-
-  using AbslInternalPiecewiseCombiner = PiecewiseCombiner;
-
-  template <typename T>
-  using is_hashable = absl::hash_internal::is_hashable<T>;
-
- private:
-  // Common implementation of the iteration step of a "combiner", as described
-  // above.
-  template <typename I>
-  struct CombineUnorderedCallback {
-    I begin;
-    I end;
-
-    template <typename InnerH, typename ElementStateConsumer>
-    void operator()(InnerH inner_state, ElementStateConsumer cb) {
-      for (; begin != end; ++begin) {
-        inner_state = H::combine(std::move(inner_state), *begin);
-        cb(inner_state);
-      }
-    }
-  };
-};
-
-// is_uniquely_represented
-//
-// `is_uniquely_represented<T>` is a trait class that indicates whether `T`
-// is uniquely represented.
-//
-// A type is "uniquely represented" if two equal values of that type are
-// guaranteed to have the same bytes in their underlying storage. In other
-// words, if `a == b`, then `memcmp(&a, &b, sizeof(T))` is guaranteed to be
-// zero. This property cannot be detected automatically, so this trait is false
-// by default, but can be specialized by types that wish to assert that they are
-// uniquely represented. This makes them eligible for certain optimizations.
-//
-// If you have any doubt whatsoever, do not specialize this template.
-// The default is completely safe, and merely disables some optimizations
-// that will not matter for most types. Specializing this template,
-// on the other hand, can be very hazardous.
-//
-// To be uniquely represented, a type must not have multiple ways of
-// representing the same value; for example, float and double are not
-// uniquely represented, because they have distinct representations for
-// +0 and -0. Furthermore, the type's byte representation must consist
-// solely of user-controlled data, with no padding bits and no compiler-
-// controlled data such as vptrs or sanitizer metadata. This is usually
-// very difficult to guarantee, because in most cases the compiler can
-// insert data and padding bits at its own discretion.
-//
-// If you specialize this template for a type `T`, you must do so in the file
-// that defines that type (or in this file). If you define that specialization
-// anywhere else, `is_uniquely_represented<T>` could have different meanings
-// in different places.
-//
-// The Enable parameter is meaningless; it is provided as a convenience,
-// to support certain SFINAE techniques when defining specializations.
-template <typename T, typename Enable = void>
-struct is_uniquely_represented : std::false_type {};
-
-// is_uniquely_represented<unsigned char>
-//
-// unsigned char is a synonym for "byte", so it is guaranteed to be
-// uniquely represented.
-template <>
-struct is_uniquely_represented<unsigned char> : std::true_type {};
-
-// is_uniquely_represented for non-standard integral types
-//
-// Integral types other than bool should be uniquely represented on any
-// platform that this will plausibly be ported to.
-template <typename Integral>
-struct is_uniquely_represented<
-    Integral, typename std::enable_if<std::is_integral<Integral>::value>::type>
-    : std::true_type {};
-
-// is_uniquely_represented<bool>
-//
-//
-template <>
-struct is_uniquely_represented<bool> : std::false_type {};
-
-// hash_bytes()
-//
-// Convenience function that combines `hash_state` with the byte representation
-// of `value`.
-template <typename H, typename T>
-H hash_bytes(H hash_state, const T& value) {
-  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
-  return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Basic Types
-// -----------------------------------------------------------------------------
-
-// Note: Default `AbslHashValue` implementations live in `hash_internal`. This
-// allows us to block lexical scope lookup when doing an unqualified call to
-// `AbslHashValue` below. User-defined implementations of `AbslHashValue` can
-// only be found via ADL.
-
-// AbslHashValue() for hashing bool values
-//
-// We use SFINAE to ensure that this overload only accepts bool, not types that
-// are convertible to bool.
-template <typename H, typename B>
-typename std::enable_if<std::is_same<B, bool>::value, H>::type AbslHashValue(
-    H hash_state, B value) {
-  return H::combine(std::move(hash_state),
-                    static_cast<unsigned char>(value ? 1 : 0));
-}
-
-// AbslHashValue() for hashing enum values
-template <typename H, typename Enum>
-typename std::enable_if<std::is_enum<Enum>::value, H>::type AbslHashValue(
-    H hash_state, Enum e) {
-  // In practice, we could almost certainly just invoke hash_bytes directly,
-  // but it's possible that a sanitizer might one day want to
-  // store data in the unused bits of an enum. To avoid that risk, we
-  // convert to the underlying type before hashing. Hopefully this will get
-  // optimized away; if not, we can reopen discussion with c-toolchain-team.
-  return H::combine(std::move(hash_state),
-                    static_cast<typename std::underlying_type<Enum>::type>(e));
-}
-// AbslHashValue() for hashing floating-point values
-template <typename H, typename Float>
-typename std::enable_if<std::is_same<Float, float>::value ||
-                            std::is_same<Float, double>::value,
-                        H>::type
-AbslHashValue(H hash_state, Float value) {
-  return hash_internal::hash_bytes(std::move(hash_state),
-                                   value == 0 ? 0 : value);
-}
-
-// Long double has the property that it might have extra unused bytes in it.
-// For example, in x86 sizeof(long double)==16 but it only really uses 80-bits
-// of it. This means we can't use hash_bytes on a long double and have to
-// convert it to something else first.
-template <typename H, typename LongDouble>
-typename std::enable_if<std::is_same<LongDouble, long double>::value, H>::type
-AbslHashValue(H hash_state, LongDouble value) {
-  const int category = std::fpclassify(value);
-  switch (category) {
-    case FP_INFINITE:
-      // Add the sign bit to differentiate between +Inf and -Inf
-      hash_state = H::combine(std::move(hash_state), std::signbit(value));
-      break;
-
-    case FP_NAN:
-    case FP_ZERO:
-    default:
-      // Category is enough for these.
-      break;
-
-    case FP_NORMAL:
-    case FP_SUBNORMAL:
-      // We can't convert `value` directly to double because this would have
-      // undefined behavior if the value is out of range.
-      // std::frexp gives us a value in the range (-1, -.5] or [.5, 1) that is
-      // guaranteed to be in range for `double`. The truncation is
-      // implementation defined, but that works as long as it is deterministic.
-      int exp;
-      auto mantissa = static_cast<double>(std::frexp(value, &exp));
-      hash_state = H::combine(std::move(hash_state), mantissa, exp);
-  }
-
-  return H::combine(std::move(hash_state), category);
-}
-
-// AbslHashValue() for hashing pointers
-template <typename H, typename T>
-H AbslHashValue(H hash_state, T* ptr) {
-  auto v = reinterpret_cast<uintptr_t>(ptr);
-  // Due to alignment, pointers tend to have low bits as zero, and the next few
-  // bits follow a pattern since they are also multiples of some base value.
-  // Mixing the pointer twice helps prevent stuck low bits for certain alignment
-  // values.
-  return H::combine(std::move(hash_state), v, v);
-}
-
-// AbslHashValue() for hashing nullptr_t
-template <typename H>
-H AbslHashValue(H hash_state, std::nullptr_t) {
-  return H::combine(std::move(hash_state), static_cast<void*>(nullptr));
-}
-
-// AbslHashValue() for hashing pointers-to-member
-template <typename H, typename T, typename C>
-H AbslHashValue(H hash_state, T C::* ptr) {
-  auto salient_ptm_size = [](std::size_t n) -> std::size_t {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class HashState;
+
+    namespace hash_internal
+    {
+
+        // Internal detail: Large buffers are hashed in smaller chunks.  This function
+        // returns the size of these chunks.
+        constexpr size_t PiecewiseChunkSize()
+        {
+            return 1024;
+        }
+
+        // PiecewiseCombiner
+        //
+        // PiecewiseCombiner is an internal-only helper class for hashing a piecewise
+        // buffer of `char` or `unsigned char` as though it were contiguous.  This class
+        // provides two methods:
+        //
+        //   H add_buffer(state, data, size)
+        //   H finalize(state)
+        //
+        // `add_buffer` can be called zero or more times, followed by a single call to
+        // `finalize`.  This will produce the same hash expansion as concatenating each
+        // buffer piece into a single contiguous buffer, and passing this to
+        // `H::combine_contiguous`.
+        //
+        //  Example usage:
+        //    PiecewiseCombiner combiner;
+        //    for (const auto& piece : pieces) {
+        //      state = combiner.add_buffer(std::move(state), piece.data, piece.size);
+        //    }
+        //    return combiner.finalize(std::move(state));
+        class PiecewiseCombiner
+        {
+        public:
+            PiecewiseCombiner() :
+                position_(0)
+            {
+            }
+            PiecewiseCombiner(const PiecewiseCombiner&) = delete;
+            PiecewiseCombiner& operator=(const PiecewiseCombiner&) = delete;
+
+            // PiecewiseCombiner::add_buffer()
+            //
+            // Appends the given range of bytes to the sequence to be hashed, which may
+            // modify the provided hash state.
+            template<typename H>
+            H add_buffer(H state, const unsigned char* data, size_t size);
+            template<typename H>
+            H add_buffer(H state, const char* data, size_t size)
+            {
+                return add_buffer(std::move(state), reinterpret_cast<const unsigned char*>(data), size);
+            }
+
+            // PiecewiseCombiner::finalize()
+            //
+            // Finishes combining the hash sequence, which may may modify the provided
+            // hash state.
+            //
+            // Once finalize() is called, add_buffer() may no longer be called. The
+            // resulting hash state will be the same as if the pieces passed to
+            // add_buffer() were concatenated into a single flat buffer, and then provided
+            // to H::combine_contiguous().
+            template<typename H>
+            H finalize(H state);
+
+        private:
+            unsigned char buf_[PiecewiseChunkSize()];
+            size_t position_;
+        };
+
+        // is_hashable()
+        //
+        // Trait class which returns true if T is hashable by the absl::Hash framework.
+        // Used for the AbslHashValue implementations for composite types below.
+        template<typename T>
+        struct is_hashable;
+
+        // HashStateBase
+        //
+        // An internal implementation detail that contains common implementation details
+        // for all of the "hash state objects" objects generated by Abseil.  This is not
+        // a public API; users should not create classes that inherit from this.
+        //
+        // A hash state object is the template argument `H` passed to `AbslHashValue`.
+        // It represents an intermediate state in the computation of an unspecified hash
+        // algorithm. `HashStateBase` provides a CRTP style base class for hash state
+        // implementations. Developers adding type support for `absl::Hash` should not
+        // rely on any parts of the state object other than the following member
+        // functions:
+        //
+        //   * HashStateBase::combine()
+        //   * HashStateBase::combine_contiguous()
+        //   * HashStateBase::combine_unordered()
+        //
+        // A derived hash state class of type `H` must provide a public member function
+        // with a signature similar to the following:
+        //
+        //    `static H combine_contiguous(H state, const unsigned char*, size_t)`.
+        //
+        // It must also provide a private template method named RunCombineUnordered.
+        //
+        // A "consumer" is a 1-arg functor returning void.  Its argument is a reference
+        // to an inner hash state object, and it may be called multiple times.  When
+        // called, the functor consumes the entropy from the provided state object,
+        // and resets that object to its empty state.
+        //
+        // A "combiner" is a stateless 2-arg functor returning void.  Its arguments are
+        // an inner hash state object and an ElementStateConsumer functor.  A combiner
+        // uses the provided inner hash state object to hash each element of the
+        // container, passing the inner hash state object to the consumer after hashing
+        // each element.
+        //
+        // Given these definitions, a derived hash state class of type H
+        // must provide a private template method with a signature similar to the
+        // following:
+        //
+        //    `template <typename CombinerT>`
+        //    `static H RunCombineUnordered(H outer_state, CombinerT combiner)`
+        //
+        // This function is responsible for constructing the inner state object and
+        // providing a consumer to the combiner.  It uses side effects of the consumer
+        // and combiner to mix the state of each element in an order-independent manner,
+        // and uses this to return an updated value of `outer_state`.
+        //
+        // This inside-out approach generates efficient object code in the normal case,
+        // but allows us to use stack storage to implement the absl::HashState type
+        // erasure mechanism (avoiding heap allocations while hashing).
+        //
+        // `HashStateBase` will provide a complete implementation for a hash state
+        // object in terms of these two methods.
+        //
+        // Example:
+        //
+        //   // Use CRTP to define your derived class.
+        //   struct MyHashState : HashStateBase<MyHashState> {
+        //       static H combine_contiguous(H state, const unsigned char*, size_t);
+        //       using MyHashState::HashStateBase::combine;
+        //       using MyHashState::HashStateBase::combine_contiguous;
+        //       using MyHashState::HashStateBase::combine_unordered;
+        //     private:
+        //       template <typename CombinerT>
+        //       static H RunCombineUnordered(H state, CombinerT combiner);
+        //   };
+        template<typename H>
+        class HashStateBase
+        {
+        public:
+            // HashStateBase::combine()
+            //
+            // Combines an arbitrary number of values into a hash state, returning the
+            // updated state.
+            //
+            // Each of the value types `T` must be separately hashable by the Abseil
+            // hashing framework.
+            //
+            // NOTE:
+            //
+            //   state = H::combine(std::move(state), value1, value2, value3);
+            //
+            // is guaranteed to produce the same hash expansion as:
+            //
+            //   state = H::combine(std::move(state), value1);
+            //   state = H::combine(std::move(state), value2);
+            //   state = H::combine(std::move(state), value3);
+            template<typename T, typename... Ts>
+            static H combine(H state, const T& value, const Ts&... values);
+            static H combine(H state)
+            {
+                return state;
+            }
+
+            // HashStateBase::combine_contiguous()
+            //
+            // Combines a contiguous array of `size` elements into a hash state, returning
+            // the updated state.
+            //
+            // NOTE:
+            //
+            //   state = H::combine_contiguous(std::move(state), data, size);
+            //
+            // is NOT guaranteed to produce the same hash expansion as a for-loop (it may
+            // perform internal optimizations).  If you need this guarantee, use the
+            // for-loop instead.
+            template<typename T>
+            static H combine_contiguous(H state, const T* data, size_t size);
+
+            template<typename I>
+            static H combine_unordered(H state, I begin, I end);
+
+            using AbslInternalPiecewiseCombiner = PiecewiseCombiner;
+
+            template<typename T>
+            using is_hashable = absl::hash_internal::is_hashable<T>;
+
+        private:
+            // Common implementation of the iteration step of a "combiner", as described
+            // above.
+            template<typename I>
+            struct CombineUnorderedCallback
+            {
+                I begin;
+                I end;
+
+                template<typename InnerH, typename ElementStateConsumer>
+                void operator()(InnerH inner_state, ElementStateConsumer cb)
+                {
+                    for (; begin != end; ++begin)
+                    {
+                        inner_state = H::combine(std::move(inner_state), *begin);
+                        cb(inner_state);
+                    }
+                }
+            };
+        };
+
+        // is_uniquely_represented
+        //
+        // `is_uniquely_represented<T>` is a trait class that indicates whether `T`
+        // is uniquely represented.
+        //
+        // A type is "uniquely represented" if two equal values of that type are
+        // guaranteed to have the same bytes in their underlying storage. In other
+        // words, if `a == b`, then `memcmp(&a, &b, sizeof(T))` is guaranteed to be
+        // zero. This property cannot be detected automatically, so this trait is false
+        // by default, but can be specialized by types that wish to assert that they are
+        // uniquely represented. This makes them eligible for certain optimizations.
+        //
+        // If you have any doubt whatsoever, do not specialize this template.
+        // The default is completely safe, and merely disables some optimizations
+        // that will not matter for most types. Specializing this template,
+        // on the other hand, can be very hazardous.
+        //
+        // To be uniquely represented, a type must not have multiple ways of
+        // representing the same value; for example, float and double are not
+        // uniquely represented, because they have distinct representations for
+        // +0 and -0. Furthermore, the type's byte representation must consist
+        // solely of user-controlled data, with no padding bits and no compiler-
+        // controlled data such as vptrs or sanitizer metadata. This is usually
+        // very difficult to guarantee, because in most cases the compiler can
+        // insert data and padding bits at its own discretion.
+        //
+        // If you specialize this template for a type `T`, you must do so in the file
+        // that defines that type (or in this file). If you define that specialization
+        // anywhere else, `is_uniquely_represented<T>` could have different meanings
+        // in different places.
+        //
+        // The Enable parameter is meaningless; it is provided as a convenience,
+        // to support certain SFINAE techniques when defining specializations.
+        template<typename T, typename Enable = void>
+        struct is_uniquely_represented : std::false_type
+        {
+        };
+
+        // is_uniquely_represented<unsigned char>
+        //
+        // unsigned char is a synonym for "byte", so it is guaranteed to be
+        // uniquely represented.
+        template<>
+        struct is_uniquely_represented<unsigned char> : std::true_type
+        {
+        };
+
+        // is_uniquely_represented for non-standard integral types
+        //
+        // Integral types other than bool should be uniquely represented on any
+        // platform that this will plausibly be ported to.
+        template<typename Integral>
+        struct is_uniquely_represented<
+            Integral,
+            typename std::enable_if<std::is_integral<Integral>::value>::type> : std::true_type
+        {
+        };
+
+        // is_uniquely_represented<bool>
+        //
+        //
+        template<>
+        struct is_uniquely_represented<bool> : std::false_type
+        {
+        };
+
+        // hash_bytes()
+        //
+        // Convenience function that combines `hash_state` with the byte representation
+        // of `value`.
+        template<typename H, typename T>
+        H hash_bytes(H hash_state, const T& value)
+        {
+            const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
+            return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
+        }
+
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for Basic Types
+        // -----------------------------------------------------------------------------
+
+        // Note: Default `AbslHashValue` implementations live in `hash_internal`. This
+        // allows us to block lexical scope lookup when doing an unqualified call to
+        // `AbslHashValue` below. User-defined implementations of `AbslHashValue` can
+        // only be found via ADL.
+
+        // AbslHashValue() for hashing bool values
+        //
+        // We use SFINAE to ensure that this overload only accepts bool, not types that
+        // are convertible to bool.
+        template<typename H, typename B>
+        typename std::enable_if<std::is_same<B, bool>::value, H>::type AbslHashValue(
+            H hash_state, B value
+        )
+        {
+            return H::combine(std::move(hash_state), static_cast<unsigned char>(value ? 1 : 0));
+        }
+
+        // AbslHashValue() for hashing enum values
+        template<typename H, typename Enum>
+        typename std::enable_if<std::is_enum<Enum>::value, H>::type AbslHashValue(
+            H hash_state, Enum e
+        )
+        {
+            // In practice, we could almost certainly just invoke hash_bytes directly,
+            // but it's possible that a sanitizer might one day want to
+            // store data in the unused bits of an enum. To avoid that risk, we
+            // convert to the underlying type before hashing. Hopefully this will get
+            // optimized away; if not, we can reopen discussion with c-toolchain-team.
+            return H::combine(std::move(hash_state), static_cast<typename std::underlying_type<Enum>::type>(e));
+        }
+        // AbslHashValue() for hashing floating-point values
+        template<typename H, typename Float>
+        typename std::enable_if<std::is_same<Float, float>::value || std::is_same<Float, double>::value, H>::type
+            AbslHashValue(H hash_state, Float value)
+        {
+            return hash_internal::hash_bytes(std::move(hash_state), value == 0 ? 0 : value);
+        }
+
+        // Long double has the property that it might have extra unused bytes in it.
+        // For example, in x86 sizeof(long double)==16 but it only really uses 80-bits
+        // of it. This means we can't use hash_bytes on a long double and have to
+        // convert it to something else first.
+        template<typename H, typename LongDouble>
+        typename std::enable_if<std::is_same<LongDouble, long double>::value, H>::type
+            AbslHashValue(H hash_state, LongDouble value)
+        {
+            const int category = std::fpclassify(value);
+            switch (category)
+            {
+                case FP_INFINITE:
+                    // Add the sign bit to differentiate between +Inf and -Inf
+                    hash_state = H::combine(std::move(hash_state), std::signbit(value));
+                    break;
+
+                case FP_NAN:
+                case FP_ZERO:
+                default:
+                    // Category is enough for these.
+                    break;
+
+                case FP_NORMAL:
+                case FP_SUBNORMAL:
+                    // We can't convert `value` directly to double because this would have
+                    // undefined behavior if the value is out of range.
+                    // std::frexp gives us a value in the range (-1, -.5] or [.5, 1) that is
+                    // guaranteed to be in range for `double`. The truncation is
+                    // implementation defined, but that works as long as it is deterministic.
+                    int exp;
+                    auto mantissa = static_cast<double>(std::frexp(value, &exp));
+                    hash_state = H::combine(std::move(hash_state), mantissa, exp);
+            }
+
+            return H::combine(std::move(hash_state), category);
+        }
+
+        // AbslHashValue() for hashing pointers
+        template<typename H, typename T>
+        H AbslHashValue(H hash_state, T* ptr)
+        {
+            auto v = reinterpret_cast<uintptr_t>(ptr);
+            // Due to alignment, pointers tend to have low bits as zero, and the next few
+            // bits follow a pattern since they are also multiples of some base value.
+            // Mixing the pointer twice helps prevent stuck low bits for certain alignment
+            // values.
+            return H::combine(std::move(hash_state), v, v);
+        }
+
+        // AbslHashValue() for hashing nullptr_t
+        template<typename H>
+        H AbslHashValue(H hash_state, std::nullptr_t)
+        {
+            return H::combine(std::move(hash_state), static_cast<void*>(nullptr));
+        }
+
+        // AbslHashValue() for hashing pointers-to-member
+        template<typename H, typename T, typename C>
+        H AbslHashValue(H hash_state, T C::*ptr)
+        {
+            auto salient_ptm_size = [](std::size_t n) -> std::size_t
+            {
 #if defined(_MSC_VER)
-    // Pointers-to-member-function on MSVC consist of one pointer plus 0, 1, 2,
-    // or 3 ints. In 64-bit mode, they are 8-byte aligned and thus can contain
-    // padding (namely when they have 1 or 3 ints). The value below is a lower
-    // bound on the number of salient, non-padding bytes that we use for
-    // hashing.
-    if (alignof(T C::*) == alignof(int)) {
-      // No padding when all subobjects have the same size as the total
-      // alignment. This happens in 32-bit mode.
-      return n;
-    } else {
-      // Padding for 1 int (size 16) or 3 ints (size 24).
-      // With 2 ints, the size is 16 with no padding, which we pessimize.
-      return n == 24 ? 20 : n == 16 ? 12 : n;
-    }
+                // Pointers-to-member-function on MSVC consist of one pointer plus 0, 1, 2,
+                // or 3 ints. In 64-bit mode, they are 8-byte aligned and thus can contain
+                // padding (namely when they have 1 or 3 ints). The value below is a lower
+                // bound on the number of salient, non-padding bytes that we use for
+                // hashing.
+                if (alignof(T C::*) == alignof(int))
+                {
+                    // No padding when all subobjects have the same size as the total
+                    // alignment. This happens in 32-bit mode.
+                    return n;
+                }
+                else
+                {
+                    // Padding for 1 int (size 16) or 3 ints (size 24).
+                    // With 2 ints, the size is 16 with no padding, which we pessimize.
+                    return n == 24 ? 20 : n == 16 ? 12 :
+                                                    n;
+                }
 #else
-    // On other platforms, we assume that pointers-to-members do not have
-    // padding.
+            // On other platforms, we assume that pointers-to-members do not have
+            // padding.
 #ifdef __cpp_lib_has_unique_object_representations
-    static_assert(std::has_unique_object_representations_v<T C::*>);
+                static_assert(std::has_unique_object_representations_v<T C::*>);
 #endif  // __cpp_lib_has_unique_object_representations
-    return n;
+                return n;
 #endif
-  };
-  return H::combine_contiguous(std::move(hash_state),
-                               reinterpret_cast<unsigned char*>(&ptr),
-                               salient_ptm_size(sizeof ptr));
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Composite Types
-// -----------------------------------------------------------------------------
-
-// AbslHashValue() for hashing pairs
-template <typename H, typename T1, typename T2>
-typename std::enable_if<is_hashable<T1>::value && is_hashable<T2>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::pair<T1, T2>& p) {
-  return H::combine(std::move(hash_state), p.first, p.second);
-}
-
-// hash_tuple()
-//
-// Helper function for hashing a tuple. The third argument should
-// be an index_sequence running from 0 to tuple_size<Tuple> - 1.
-template <typename H, typename Tuple, size_t... Is>
-H hash_tuple(H hash_state, const Tuple& t, absl::index_sequence<Is...>) {
-  return H::combine(std::move(hash_state), std::get<Is>(t)...);
-}
-
-// AbslHashValue for hashing tuples
-template <typename H, typename... Ts>
+            };
+            return H::combine_contiguous(std::move(hash_state), reinterpret_cast<unsigned char*>(&ptr), salient_ptm_size(sizeof ptr));
+        }
+
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for Composite Types
+        // -----------------------------------------------------------------------------
+
+        // AbslHashValue() for hashing pairs
+        template<typename H, typename T1, typename T2>
+        typename std::enable_if<is_hashable<T1>::value && is_hashable<T2>::value, H>::type
+            AbslHashValue(H hash_state, const std::pair<T1, T2>& p)
+        {
+            return H::combine(std::move(hash_state), p.first, p.second);
+        }
+
+        // hash_tuple()
+        //
+        // Helper function for hashing a tuple. The third argument should
+        // be an index_sequence running from 0 to tuple_size<Tuple> - 1.
+        template<typename H, typename Tuple, size_t... Is>
+        H hash_tuple(H hash_state, const Tuple& t, absl::index_sequence<Is...>)
+        {
+            return H::combine(std::move(hash_state), std::get<Is>(t)...);
+        }
+
+        // AbslHashValue for hashing tuples
+        template<typename H, typename... Ts>
 #if defined(_MSC_VER)
-// This SFINAE gets MSVC confused under some conditions. Let's just disable it
-// for now.
-H
+        // This SFINAE gets MSVC confused under some conditions. Let's just disable it
+        // for now.
+        H
 #else   // _MSC_VER
-typename std::enable_if<absl::conjunction<is_hashable<Ts>...>::value, H>::type
+        typename std::enable_if<absl::conjunction<is_hashable<Ts>...>::value, H>::type
 #endif  // _MSC_VER
-AbslHashValue(H hash_state, const std::tuple<Ts...>& t) {
-  return hash_internal::hash_tuple(std::move(hash_state), t,
-                                   absl::make_index_sequence<sizeof...(Ts)>());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Pointers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing unique_ptr
-template <typename H, typename T, typename D>
-H AbslHashValue(H hash_state, const std::unique_ptr<T, D>& ptr) {
-  return H::combine(std::move(hash_state), ptr.get());
-}
-
-// AbslHashValue for hashing shared_ptr
-template <typename H, typename T>
-H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr) {
-  return H::combine(std::move(hash_state), ptr.get());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for String-Like Types
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing strings
-//
-// All the string-like types supported here provide the same hash expansion for
-// the same character sequence. These types are:
-//
-//  - `absl::Cord`
-//  - `std::string` (and std::basic_string<char, std::char_traits<char>, A> for
-//      any allocator A)
-//  - `absl::string_view` and `std::string_view`
-//
-// For simplicity, we currently support only `char` strings. This support may
-// be broadened, if necessary, but with some caution - this overload would
-// misbehave in cases where the traits' `eq()` member isn't equivalent to `==`
-// on the underlying character type.
-template <typename H>
-H AbslHashValue(H hash_state, absl::string_view str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      str.size());
-}
-
-// Support std::wstring, std::u16string and std::u32string.
-template <typename Char, typename Alloc, typename H,
-          typename = absl::enable_if_t<std::is_same<Char, wchar_t>::value ||
-                                       std::is_same<Char, char16_t>::value ||
-                                       std::is_same<Char, char32_t>::value>>
-H AbslHashValue(
-    H hash_state,
-    const std::basic_string<Char, std::char_traits<Char>, Alloc>& str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      str.size());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Sequence Containers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::array
-template <typename H, typename T, size_t N>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::array<T, N>& array) {
-  return H::combine_contiguous(std::move(hash_state), array.data(),
-                               array.size());
-}
-
-// AbslHashValue for hashing std::deque
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::deque<T, Allocator>& deque) {
-  // TODO(gromer): investigate a more efficient implementation taking
-  // advantage of the chunk structure.
-  for (const auto& t : deque) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), deque.size());
-}
-
-// AbslHashValue for hashing std::forward_list
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::forward_list<T, Allocator>& list) {
-  size_t size = 0;
-  for (const T& t : list) {
-    hash_state = H::combine(std::move(hash_state), t);
-    ++size;
-  }
-  return H::combine(std::move(hash_state), size);
-}
-
-// AbslHashValue for hashing std::list
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::list<T, Allocator>& list) {
-  for (const auto& t : list) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), list.size());
-}
-
-// AbslHashValue for hashing std::vector
-//
-// Do not use this for vector<bool> on platforms that have a working
-// implementation of std::hash. It does not have a .data(), and a fallback for
-// std::hash<> is most likely faster.
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
-  return H::combine(H::combine_contiguous(std::move(hash_state), vector.data(),
-                                          vector.size()),
-                    vector.size());
-}
-
-// AbslHashValue special cases for hashing std::vector<bool>
+            AbslHashValue(H hash_state, const std::tuple<Ts...>& t)
+        {
+            return hash_internal::hash_tuple(std::move(hash_state), t, absl::make_index_sequence<sizeof...(Ts)>());
+        }
+
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for Pointers
+        // -----------------------------------------------------------------------------
+
+        // AbslHashValue for hashing unique_ptr
+        template<typename H, typename T, typename D>
+        H AbslHashValue(H hash_state, const std::unique_ptr<T, D>& ptr)
+        {
+            return H::combine(std::move(hash_state), ptr.get());
+        }
+
+        // AbslHashValue for hashing shared_ptr
+        template<typename H, typename T>
+        H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr)
+        {
+            return H::combine(std::move(hash_state), ptr.get());
+        }
+
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for String-Like Types
+        // -----------------------------------------------------------------------------
+
+        // AbslHashValue for hashing strings
+        //
+        // All the string-like types supported here provide the same hash expansion for
+        // the same character sequence. These types are:
+        //
+        //  - `absl::Cord`
+        //  - `std::string` (and std::basic_string<char, std::char_traits<char>, A> for
+        //      any allocator A)
+        //  - `absl::string_view` and `std::string_view`
+        //
+        // For simplicity, we currently support only `char` strings. This support may
+        // be broadened, if necessary, but with some caution - this overload would
+        // misbehave in cases where the traits' `eq()` member isn't equivalent to `==`
+        // on the underlying character type.
+        template<typename H>
+        H AbslHashValue(H hash_state, absl::string_view str)
+        {
+            return H::combine(
+                H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
+                str.size()
+            );
+        }
+
+        // Support std::wstring, std::u16string and std::u32string.
+        template<typename Char, typename Alloc, typename H, typename = absl::enable_if_t<std::is_same<Char, wchar_t>::value || std::is_same<Char, char16_t>::value || std::is_same<Char, char32_t>::value>>
+        H AbslHashValue(
+            H hash_state,
+            const std::basic_string<Char, std::char_traits<Char>, Alloc>& str
+        )
+        {
+            return H::combine(
+                H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
+                str.size()
+            );
+        }
+
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for Sequence Containers
+        // -----------------------------------------------------------------------------
+
+        // AbslHashValue for hashing std::array
+        template<typename H, typename T, size_t N>
+        typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+            H hash_state, const std::array<T, N>& array
+        )
+        {
+            return H::combine_contiguous(std::move(hash_state), array.data(), array.size());
+        }
+
+        // AbslHashValue for hashing std::deque
+        template<typename H, typename T, typename Allocator>
+        typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+            H hash_state, const std::deque<T, Allocator>& deque
+        )
+        {
+            // TODO(gromer): investigate a more efficient implementation taking
+            // advantage of the chunk structure.
+            for (const auto& t : deque)
+            {
+                hash_state = H::combine(std::move(hash_state), t);
+            }
+            return H::combine(std::move(hash_state), deque.size());
+        }
+
+        // AbslHashValue for hashing std::forward_list
+        template<typename H, typename T, typename Allocator>
+        typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+            H hash_state, const std::forward_list<T, Allocator>& list
+        )
+        {
+            size_t size = 0;
+            for (const T& t : list)
+            {
+                hash_state = H::combine(std::move(hash_state), t);
+                ++size;
+            }
+            return H::combine(std::move(hash_state), size);
+        }
+
+        // AbslHashValue for hashing std::list
+        template<typename H, typename T, typename Allocator>
+        typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+            H hash_state, const std::list<T, Allocator>& list
+        )
+        {
+            for (const auto& t : list)
+            {
+                hash_state = H::combine(std::move(hash_state), t);
+            }
+            return H::combine(std::move(hash_state), list.size());
+        }
+
+        // AbslHashValue for hashing std::vector
+        //
+        // Do not use this for vector<bool> on platforms that have a working
+        // implementation of std::hash. It does not have a .data(), and a fallback for
+        // std::hash<> is most likely faster.
+        template<typename H, typename T, typename Allocator>
+        typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value, H>::type
+            AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector)
+        {
+            return H::combine(H::combine_contiguous(std::move(hash_state), vector.data(), vector.size()), vector.size());
+        }
+
+        // AbslHashValue special cases for hashing std::vector<bool>
 
 #if defined(ABSL_IS_BIG_ENDIAN) && \
     (defined(__GLIBCXX__) || defined(__GLIBCPP__))
 
-// std::hash in libstdc++ does not work correctly with vector<bool> on Big
-// Endian platforms therefore we need to implement a custom AbslHashValue for
-// it. More details on the bug:
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
-  typename H::AbslInternalPiecewiseCombiner combiner;
-  for (const auto& i : vector) {
-    unsigned char c = static_cast<unsigned char>(i);
-    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
-  }
-  return H::combine(combiner.finalize(std::move(hash_state)), vector.size());
-}
+        // std::hash in libstdc++ does not work correctly with vector<bool> on Big
+        // Endian platforms therefore we need to implement a custom AbslHashValue for
+        // it. More details on the bug:
+        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
+        template<typename H, typename T, typename Allocator>
+        typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value, H>::type
+            AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector)
+        {
+            typename H::AbslInternalPiecewiseCombiner combiner;
+            for (const auto& i : vector)
+            {
+                unsigned char c = static_cast<unsigned char>(i);
+                hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
+            }
+            return H::combine(combiner.finalize(std::move(hash_state)), vector.size());
+        }
 #else
-// When not working around the libstdc++ bug above, we still have to contend
-// with the fact that std::hash<vector<bool>> is often poor quality, hashing
-// directly on the internal words and on no other state.  On these platforms,
-// vector<bool>{1, 1} and vector<bool>{1, 1, 0} hash to the same value.
-//
-// Mixing in the size (as we do in our other vector<> implementations) on top
-// of the library-provided hash implementation avoids this QOI issue.
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
-  return H::combine(std::move(hash_state),
-                    std::hash<std::vector<T, Allocator>>{}(vector),
-                    vector.size());
-}
+        // When not working around the libstdc++ bug above, we still have to contend
+        // with the fact that std::hash<vector<bool>> is often poor quality, hashing
+        // directly on the internal words and on no other state.  On these platforms,
+        // vector<bool>{1, 1} and vector<bool>{1, 1, 0} hash to the same value.
+        //
+        // Mixing in the size (as we do in our other vector<> implementations) on top
+        // of the library-provided hash implementation avoids this QOI issue.
+        template<typename H, typename T, typename Allocator>
+        typename std::enable_if<is_hashable<T>::value && std::is_same<T, bool>::value, H>::type
+            AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector)
+        {
+            return H::combine(std::move(hash_state), std::hash<std::vector<T, Allocator>>{}(vector), vector.size());
+        }
 #endif
 
-// -----------------------------------------------------------------------------
-// AbslHashValue for Ordered Associative Containers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::map
-template <typename H, typename Key, typename T, typename Compare,
-          typename Allocator>
-typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::map<Key, T, Compare, Allocator>& map) {
-  for (const auto& t : map) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), map.size());
-}
-
-// AbslHashValue for hashing std::multimap
-template <typename H, typename Key, typename T, typename Compare,
-          typename Allocator>
-typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
-                        H>::type
-AbslHashValue(H hash_state,
-              const std::multimap<Key, T, Compare, Allocator>& map) {
-  for (const auto& t : map) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), map.size());
-}
-
-// AbslHashValue for hashing std::set
-template <typename H, typename Key, typename Compare, typename Allocator>
-typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
-    H hash_state, const std::set<Key, Compare, Allocator>& set) {
-  for (const auto& t : set) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), set.size());
-}
-
-// AbslHashValue for hashing std::multiset
-template <typename H, typename Key, typename Compare, typename Allocator>
-typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
-    H hash_state, const std::multiset<Key, Compare, Allocator>& set) {
-  for (const auto& t : set) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), set.size());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Unordered Associative Containers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::unordered_set
-template <typename H, typename Key, typename Hash, typename KeyEqual,
-          typename Alloc>
-typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
-    H hash_state, const std::unordered_set<Key, Hash, KeyEqual, Alloc>& s) {
-  return H::combine(
-      H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
-      s.size());
-}
-
-// AbslHashValue for hashing std::unordered_multiset
-template <typename H, typename Key, typename Hash, typename KeyEqual,
-          typename Alloc>
-typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
-    H hash_state,
-    const std::unordered_multiset<Key, Hash, KeyEqual, Alloc>& s) {
-  return H::combine(
-      H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
-      s.size());
-}
-
-// AbslHashValue for hashing std::unordered_set
-template <typename H, typename Key, typename T, typename Hash,
-          typename KeyEqual, typename Alloc>
-typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
-                        H>::type
-AbslHashValue(H hash_state,
-              const std::unordered_map<Key, T, Hash, KeyEqual, Alloc>& s) {
-  return H::combine(
-      H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
-      s.size());
-}
-
-// AbslHashValue for hashing std::unordered_multiset
-template <typename H, typename Key, typename T, typename Hash,
-          typename KeyEqual, typename Alloc>
-typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
-                        H>::type
-AbslHashValue(H hash_state,
-              const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& s) {
-  return H::combine(
-      H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
-      s.size());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Wrapper Types
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::reference_wrapper
-template <typename H, typename T>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, std::reference_wrapper<T> opt) {
-  return H::combine(std::move(hash_state), opt.get());
-}
-
-// AbslHashValue for hashing absl::optional
-template <typename H, typename T>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const absl::optional<T>& opt) {
-  if (opt) hash_state = H::combine(std::move(hash_state), *opt);
-  return H::combine(std::move(hash_state), opt.has_value());
-}
-
-// VariantVisitor
-template <typename H>
-struct VariantVisitor {
-  H&& hash_state;
-  template <typename T>
-  H operator()(const T& t) const {
-    return H::combine(std::move(hash_state), t);
-  }
-};
-
-// AbslHashValue for hashing absl::variant
-template <typename H, typename... T>
-typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type
-AbslHashValue(H hash_state, const absl::variant<T...>& v) {
-  if (!v.valueless_by_exception()) {
-    hash_state = absl::visit(VariantVisitor<H>{std::move(hash_state)}, v);
-  }
-  return H::combine(std::move(hash_state), v.index());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Other Types
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::bitset is not defined on Little Endian
-// platforms, for the same reason as for vector<bool> (see std::vector above):
-// It does not expose the raw bytes, and a fallback to std::hash<> is most
-// likely faster.
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for Ordered Associative Containers
+        // -----------------------------------------------------------------------------
+
+        // AbslHashValue for hashing std::map
+        template<typename H, typename Key, typename T, typename Compare, typename Allocator>
+        typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value, H>::type
+            AbslHashValue(H hash_state, const std::map<Key, T, Compare, Allocator>& map)
+        {
+            for (const auto& t : map)
+            {
+                hash_state = H::combine(std::move(hash_state), t);
+            }
+            return H::combine(std::move(hash_state), map.size());
+        }
+
+        // AbslHashValue for hashing std::multimap
+        template<typename H, typename Key, typename T, typename Compare, typename Allocator>
+        typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value, H>::type
+            AbslHashValue(H hash_state, const std::multimap<Key, T, Compare, Allocator>& map)
+        {
+            for (const auto& t : map)
+            {
+                hash_state = H::combine(std::move(hash_state), t);
+            }
+            return H::combine(std::move(hash_state), map.size());
+        }
+
+        // AbslHashValue for hashing std::set
+        template<typename H, typename Key, typename Compare, typename Allocator>
+        typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
+            H hash_state, const std::set<Key, Compare, Allocator>& set
+        )
+        {
+            for (const auto& t : set)
+            {
+                hash_state = H::combine(std::move(hash_state), t);
+            }
+            return H::combine(std::move(hash_state), set.size());
+        }
+
+        // AbslHashValue for hashing std::multiset
+        template<typename H, typename Key, typename Compare, typename Allocator>
+        typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
+            H hash_state, const std::multiset<Key, Compare, Allocator>& set
+        )
+        {
+            for (const auto& t : set)
+            {
+                hash_state = H::combine(std::move(hash_state), t);
+            }
+            return H::combine(std::move(hash_state), set.size());
+        }
+
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for Unordered Associative Containers
+        // -----------------------------------------------------------------------------
+
+        // AbslHashValue for hashing std::unordered_set
+        template<typename H, typename Key, typename Hash, typename KeyEqual, typename Alloc>
+        typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
+            H hash_state, const std::unordered_set<Key, Hash, KeyEqual, Alloc>& s
+        )
+        {
+            return H::combine(
+                H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
+                s.size()
+            );
+        }
+
+        // AbslHashValue for hashing std::unordered_multiset
+        template<typename H, typename Key, typename Hash, typename KeyEqual, typename Alloc>
+        typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
+            H hash_state,
+            const std::unordered_multiset<Key, Hash, KeyEqual, Alloc>& s
+        )
+        {
+            return H::combine(
+                H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
+                s.size()
+            );
+        }
+
+        // AbslHashValue for hashing std::unordered_set
+        template<typename H, typename Key, typename T, typename Hash, typename KeyEqual, typename Alloc>
+        typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value, H>::type
+            AbslHashValue(H hash_state, const std::unordered_map<Key, T, Hash, KeyEqual, Alloc>& s)
+        {
+            return H::combine(
+                H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
+                s.size()
+            );
+        }
+
+        // AbslHashValue for hashing std::unordered_multiset
+        template<typename H, typename Key, typename T, typename Hash, typename KeyEqual, typename Alloc>
+        typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value, H>::type
+            AbslHashValue(H hash_state, const std::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& s)
+        {
+            return H::combine(
+                H::combine_unordered(std::move(hash_state), s.begin(), s.end()),
+                s.size()
+            );
+        }
+
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for Wrapper Types
+        // -----------------------------------------------------------------------------
+
+        // AbslHashValue for hashing std::reference_wrapper
+        template<typename H, typename T>
+        typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+            H hash_state, std::reference_wrapper<T> opt
+        )
+        {
+            return H::combine(std::move(hash_state), opt.get());
+        }
+
+        // AbslHashValue for hashing absl::optional
+        template<typename H, typename T>
+        typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+            H hash_state, const absl::optional<T>& opt
+        )
+        {
+            if (opt)
+                hash_state = H::combine(std::move(hash_state), *opt);
+            return H::combine(std::move(hash_state), opt.has_value());
+        }
+
+        // VariantVisitor
+        template<typename H>
+        struct VariantVisitor
+        {
+            H&& hash_state;
+            template<typename T>
+            H operator()(const T& t) const
+            {
+                return H::combine(std::move(hash_state), t);
+            }
+        };
+
+        // AbslHashValue for hashing absl::variant
+        template<typename H, typename... T>
+        typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type
+            AbslHashValue(H hash_state, const absl::variant<T...>& v)
+        {
+            if (!v.valueless_by_exception())
+            {
+                hash_state = absl::visit(VariantVisitor<H>{std::move(hash_state)}, v);
+            }
+            return H::combine(std::move(hash_state), v.index());
+        }
+
+        // -----------------------------------------------------------------------------
+        // AbslHashValue for Other Types
+        // -----------------------------------------------------------------------------
+
+        // AbslHashValue for hashing std::bitset is not defined on Little Endian
+        // platforms, for the same reason as for vector<bool> (see std::vector above):
+        // It does not expose the raw bytes, and a fallback to std::hash<> is most
+        // likely faster.
 
 #if defined(ABSL_IS_BIG_ENDIAN) && \
     (defined(__GLIBCXX__) || defined(__GLIBCPP__))
-// AbslHashValue for hashing std::bitset
-//
-// std::hash in libstdc++ does not work correctly with std::bitset on Big Endian
-// platforms therefore we need to implement a custom AbslHashValue for it. More
-// details on the bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
-template <typename H, size_t N>
-H AbslHashValue(H hash_state, const std::bitset<N>& set) {
-  typename H::AbslInternalPiecewiseCombiner combiner;
-  for (int i = 0; i < N; i++) {
-    unsigned char c = static_cast<unsigned char>(set[i]);
-    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
-  }
-  return H::combine(combiner.finalize(std::move(hash_state)), N);
-}
+        // AbslHashValue for hashing std::bitset
+        //
+        // std::hash in libstdc++ does not work correctly with std::bitset on Big Endian
+        // platforms therefore we need to implement a custom AbslHashValue for it. More
+        // details on the bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
+        template<typename H, size_t N>
+        H AbslHashValue(H hash_state, const std::bitset<N>& set)
+        {
+            typename H::AbslInternalPiecewiseCombiner combiner;
+            for (int i = 0; i < N; i++)
+            {
+                unsigned char c = static_cast<unsigned char>(set[i]);
+                hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
+            }
+            return H::combine(combiner.finalize(std::move(hash_state)), N);
+        }
 #endif
 
-// -----------------------------------------------------------------------------
-
-// hash_range_or_bytes()
-//
-// Mixes all values in the range [data, data+size) into the hash state.
-// This overload accepts only uniquely-represented types, and hashes them by
-// hashing the entire range of bytes.
-template <typename H, typename T>
-typename std::enable_if<is_uniquely_represented<T>::value, H>::type
-hash_range_or_bytes(H hash_state, const T* data, size_t size) {
-  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
-  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
-}
-
-// hash_range_or_bytes()
-template <typename H, typename T>
-typename std::enable_if<!is_uniquely_represented<T>::value, H>::type
-hash_range_or_bytes(H hash_state, const T* data, size_t size) {
-  for (const auto end = data + size; data < end; ++data) {
-    hash_state = H::combine(std::move(hash_state), *data);
-  }
-  return hash_state;
-}
+        // -----------------------------------------------------------------------------
+
+        // hash_range_or_bytes()
+        //
+        // Mixes all values in the range [data, data+size) into the hash state.
+        // This overload accepts only uniquely-represented types, and hashes them by
+        // hashing the entire range of bytes.
+        template<typename H, typename T>
+        typename std::enable_if<is_uniquely_represented<T>::value, H>::type
+            hash_range_or_bytes(H hash_state, const T* data, size_t size)
+        {
+            const auto* bytes = reinterpret_cast<const unsigned char*>(data);
+            return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
+        }
+
+        // hash_range_or_bytes()
+        template<typename H, typename T>
+        typename std::enable_if<!is_uniquely_represented<T>::value, H>::type
+            hash_range_or_bytes(H hash_state, const T* data, size_t size)
+        {
+            for (const auto end = data + size; data < end; ++data)
+            {
+                hash_state = H::combine(std::move(hash_state), *data);
+            }
+            return hash_state;
+        }
 
 #if defined(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE) && \
     ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
@@ -836,159 +902,174 @@ hash_range_or_bytes(H hash_state, const T* data, size_t size) {
 #define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 0
 #endif
 
-// HashSelect
-//
-// Type trait to select the appropriate hash implementation to use.
-// HashSelect::type<T> will give the proper hash implementation, to be invoked
-// as:
-//   HashSelect::type<T>::Invoke(state, value)
-// Also, HashSelect::type<T>::value is a boolean equal to `true` if there is a
-// valid `Invoke` function. Types that are not hashable will have a ::value of
-// `false`.
-struct HashSelect {
- private:
-  struct State : HashStateBase<State> {
-    static State combine_contiguous(State hash_state, const unsigned char*,
-                                    size_t);
-    using State::HashStateBase::combine_contiguous;
-  };
-
-  struct UniquelyRepresentedProbe {
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value)
-        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
-      return hash_internal::hash_bytes(std::move(state), value);
-    }
-  };
-
-  struct HashValueProbe {
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value) -> absl::enable_if_t<
-        std::is_same<H,
-                     decltype(AbslHashValue(std::move(state), value))>::value,
-        H> {
-      return AbslHashValue(std::move(state), value);
-    }
-  };
-
-  struct LegacyHashProbe {
+        // HashSelect
+        //
+        // Type trait to select the appropriate hash implementation to use.
+        // HashSelect::type<T> will give the proper hash implementation, to be invoked
+        // as:
+        //   HashSelect::type<T>::Invoke(state, value)
+        // Also, HashSelect::type<T>::value is a boolean equal to `true` if there is a
+        // valid `Invoke` function. Types that are not hashable will have a ::value of
+        // `false`.
+        struct HashSelect
+        {
+        private:
+            struct State : HashStateBase<State>
+            {
+                static State combine_contiguous(State hash_state, const unsigned char*, size_t);
+                using State::HashStateBase::combine_contiguous;
+            };
+
+            struct UniquelyRepresentedProbe
+            {
+                template<typename H, typename T>
+                static auto Invoke(H state, const T& value)
+                    -> absl::enable_if_t<is_uniquely_represented<T>::value, H>
+                {
+                    return hash_internal::hash_bytes(std::move(state), value);
+                }
+            };
+
+            struct HashValueProbe
+            {
+                template<typename H, typename T>
+                static auto Invoke(H state, const T& value) -> absl::enable_if_t<
+                    std::is_same<H, decltype(AbslHashValue(std::move(state), value))>::value,
+                    H>
+                {
+                    return AbslHashValue(std::move(state), value);
+                }
+            };
+
+            struct LegacyHashProbe
+            {
 #if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value) -> absl::enable_if_t<
-        std::is_convertible<
-            decltype(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>()(value)),
-            size_t>::value,
-        H> {
-      return hash_internal::hash_bytes(
-          std::move(state),
-          ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>{}(value));
-    }
+                template<typename H, typename T>
+                static auto Invoke(H state, const T& value) -> absl::enable_if_t<
+                    std::is_convertible<
+                        decltype(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>()(value)),
+                        size_t>::value,
+                    H>
+                {
+                    return hash_internal::hash_bytes(
+                        std::move(state),
+                        ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>{}(value)
+                    );
+                }
 #endif  // ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-  };
-
-  struct StdHashProbe {
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value)
-        -> absl::enable_if_t<type_traits_internal::IsHashable<T>::value, H> {
-      return hash_internal::hash_bytes(std::move(state), std::hash<T>{}(value));
-    }
-  };
-
-  template <typename Hash, typename T>
-  struct Probe : Hash {
-   private:
-    template <typename H, typename = decltype(H::Invoke(
-                              std::declval<State>(), std::declval<const T&>()))>
-    static std::true_type Test(int);
-    template <typename U>
-    static std::false_type Test(char);
-
-   public:
-    static constexpr bool value = decltype(Test<Hash>(0))::value;
-  };
-
- public:
-  // Probe each implementation in order.
-  // disjunction provides short circuiting wrt instantiation.
-  template <typename T>
-  using Apply = absl::disjunction<         //
-      Probe<UniquelyRepresentedProbe, T>,  //
-      Probe<HashValueProbe, T>,            //
-      Probe<LegacyHashProbe, T>,           //
-      Probe<StdHashProbe, T>,              //
-      std::false_type>;
-};
-
-template <typename T>
-struct is_hashable
-    : std::integral_constant<bool, HashSelect::template Apply<T>::value> {};
-
-// MixingHashState
-class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
-  // absl::uint128 is not an alias or a thin wrapper around the intrinsic.
-  // We use the intrinsic when available to improve performance.
+            };
+
+            struct StdHashProbe
+            {
+                template<typename H, typename T>
+                static auto Invoke(H state, const T& value)
+                    -> absl::enable_if_t<type_traits_internal::IsHashable<T>::value, H>
+                {
+                    return hash_internal::hash_bytes(std::move(state), std::hash<T>{}(value));
+                }
+            };
+
+            template<typename Hash, typename T>
+            struct Probe : Hash
+            {
+            private:
+                template<typename H, typename = decltype(H::Invoke(std::declval<State>(), std::declval<const T&>()))>
+                static std::true_type Test(int);
+                template<typename U>
+                static std::false_type Test(char);
+
+            public:
+                static constexpr bool value = decltype(Test<Hash>(0))::value;
+            };
+
+        public:
+            // Probe each implementation in order.
+            // disjunction provides short circuiting wrt instantiation.
+            template<typename T>
+            using Apply = absl::disjunction<         //
+                Probe<UniquelyRepresentedProbe, T>,  //
+                Probe<HashValueProbe, T>,            //
+                Probe<LegacyHashProbe, T>,           //
+                Probe<StdHashProbe, T>,              //
+                std::false_type>;
+        };
+
+        template<typename T>
+        struct is_hashable : std::integral_constant<bool, HashSelect::template Apply<T>::value>
+        {
+        };
+
+        // MixingHashState
+        class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState>
+        {
+            // absl::uint128 is not an alias or a thin wrapper around the intrinsic.
+            // We use the intrinsic when available to improve performance.
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  using uint128 = __uint128_t;
+            using uint128 = __uint128_t;
 #else   // ABSL_HAVE_INTRINSIC_INT128
-  using uint128 = absl::uint128;
+            using uint128 = absl::uint128;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
-  static constexpr uint64_t kMul =
-      sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51}
-                          : uint64_t{0x9ddfea08eb382d69};
-
-  template <typename T>
-  using IntegralFastPath =
-      conjunction<std::is_integral<T>, is_uniquely_represented<T>>;
-
- public:
-  // Move only
-  MixingHashState(MixingHashState&&) = default;
-  MixingHashState& operator=(MixingHashState&&) = default;
-
-  // MixingHashState::combine_contiguous()
-  //
-  // Fundamental base case for hash recursion: mixes the given range of bytes
-  // into the hash state.
-  static MixingHashState combine_contiguous(MixingHashState hash_state,
-                                            const unsigned char* first,
-                                            size_t size) {
-    return MixingHashState(
-        CombineContiguousImpl(hash_state.state_, first, size,
-                              std::integral_constant<int, sizeof(size_t)>{}));
-  }
-  using MixingHashState::HashStateBase::combine_contiguous;
-
-  // MixingHashState::hash()
-  //
-  // For performance reasons in non-opt mode, we specialize this for
-  // integral types.
-  // Otherwise we would be instantiating and calling dozens of functions for
-  // something that is just one multiplication and a couple xor's.
-  // The result should be the same as running the whole algorithm, but faster.
-  template <typename T, absl::enable_if_t<IntegralFastPath<T>::value, int> = 0>
-  static size_t hash(T value) {
-    return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value)));
-  }
-
-  // Overload of MixingHashState::hash()
-  template <typename T, absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0>
-  static size_t hash(const T& value) {
-    return static_cast<size_t>(combine(MixingHashState{}, value).state_);
-  }
-
- private:
-  // Invoked only once for a given argument; that plus the fact that this is
-  // move-only ensures that there is only one non-moved-from object.
-  MixingHashState() : state_(Seed()) {}
-
-  friend class MixingHashState::HashStateBase;
-
-  template <typename CombinerT>
-  static MixingHashState RunCombineUnordered(MixingHashState state,
-                                             CombinerT combiner) {
-    uint64_t unordered_state = 0;
-    combiner(MixingHashState{}, [&](MixingHashState& inner_state) {
+            static constexpr uint64_t kMul =
+                sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51} : uint64_t{0x9ddfea08eb382d69};
+
+            template<typename T>
+            using IntegralFastPath =
+                conjunction<std::is_integral<T>, is_uniquely_represented<T>>;
+
+        public:
+            // Move only
+            MixingHashState(MixingHashState&&) = default;
+            MixingHashState& operator=(MixingHashState&&) = default;
+
+            // MixingHashState::combine_contiguous()
+            //
+            // Fundamental base case for hash recursion: mixes the given range of bytes
+            // into the hash state.
+            static MixingHashState combine_contiguous(MixingHashState hash_state, const unsigned char* first, size_t size)
+            {
+                return MixingHashState(
+                    CombineContiguousImpl(hash_state.state_, first, size, std::integral_constant<int, sizeof(size_t)>{})
+                );
+            }
+            using MixingHashState::HashStateBase::combine_contiguous;
+
+            // MixingHashState::hash()
+            //
+            // For performance reasons in non-opt mode, we specialize this for
+            // integral types.
+            // Otherwise we would be instantiating and calling dozens of functions for
+            // something that is just one multiplication and a couple xor's.
+            // The result should be the same as running the whole algorithm, but faster.
+            template<typename T, absl::enable_if_t<IntegralFastPath<T>::value, int> = 0>
+            static size_t hash(T value)
+            {
+                return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value)));
+            }
+
+            // Overload of MixingHashState::hash()
+            template<typename T, absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0>
+            static size_t hash(const T& value)
+            {
+                return static_cast<size_t>(combine(MixingHashState{}, value).state_);
+            }
+
+        private:
+            // Invoked only once for a given argument; that plus the fact that this is
+            // move-only ensures that there is only one non-moved-from object.
+            MixingHashState() :
+                state_(Seed())
+            {
+            }
+
+            friend class MixingHashState::HashStateBase;
+
+            template<typename CombinerT>
+            static MixingHashState RunCombineUnordered(MixingHashState state, CombinerT combiner)
+            {
+                uint64_t unordered_state = 0;
+                combiner(MixingHashState{}, [&](MixingHashState& inner_state)
+                         {
       // Add the hash state of the element to the running total, but mix the
       // carry bit back into the low bit.  This in intended to avoid losing
       // entropy to overflow, especially when unordered_multisets contain
@@ -998,294 +1079,322 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
       if (unordered_state < element_state) {
         ++unordered_state;
       }
-      inner_state = MixingHashState{};
-    });
-    return MixingHashState::combine(std::move(state), unordered_state);
-  }
-
-  // Allow the HashState type-erasure implementation to invoke
-  // RunCombinedUnordered() directly.
-  friend class absl::HashState;
-
-  // Workaround for MSVC bug.
-  // We make the type copyable to fix the calling convention, even though we
-  // never actually copy it. Keep it private to not affect the public API of the
-  // type.
-  MixingHashState(const MixingHashState&) = default;
-
-  explicit MixingHashState(uint64_t state) : state_(state) {}
-
-  // Implementation of the base case for combine_contiguous where we actually
-  // mix the bytes into the state.
-  // Dispatch to different implementations of the combine_contiguous depending
-  // on the value of `sizeof(size_t)`.
-  static uint64_t CombineContiguousImpl(uint64_t state,
-                                        const unsigned char* first, size_t len,
-                                        std::integral_constant<int, 4>
-                                        /* sizeof_size_t */);
-  static uint64_t CombineContiguousImpl(uint64_t state,
-                                        const unsigned char* first, size_t len,
-                                        std::integral_constant<int, 8>
-                                        /* sizeof_size_t */);
-
-  // Slow dispatch path for calls to CombineContiguousImpl with a size argument
-  // larger than PiecewiseChunkSize().  Has the same effect as calling
-  // CombineContiguousImpl() repeatedly with the chunk stride size.
-  static uint64_t CombineLargeContiguousImpl32(uint64_t state,
-                                               const unsigned char* first,
-                                               size_t len);
-  static uint64_t CombineLargeContiguousImpl64(uint64_t state,
-                                               const unsigned char* first,
-                                               size_t len);
-
-  // Reads 9 to 16 bytes from p.
-  // The least significant 8 bytes are in .first, the rest (zero padded) bytes
-  // are in .second.
-  static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
-                                                 size_t len) {
-    uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
-    uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
+      inner_state = MixingHashState{}; });
+                return MixingHashState::combine(std::move(state), unordered_state);
+            }
+
+            // Allow the HashState type-erasure implementation to invoke
+            // RunCombinedUnordered() directly.
+            friend class absl::HashState;
+
+            // Workaround for MSVC bug.
+            // We make the type copyable to fix the calling convention, even though we
+            // never actually copy it. Keep it private to not affect the public API of the
+            // type.
+            MixingHashState(const MixingHashState&) = default;
+
+            explicit MixingHashState(uint64_t state) :
+                state_(state)
+            {
+            }
+
+            // Implementation of the base case for combine_contiguous where we actually
+            // mix the bytes into the state.
+            // Dispatch to different implementations of the combine_contiguous depending
+            // on the value of `sizeof(size_t)`.
+            static uint64_t CombineContiguousImpl(uint64_t state, const unsigned char* first, size_t len, std::integral_constant<int, 4>
+                                                  /* sizeof_size_t */);
+            static uint64_t CombineContiguousImpl(uint64_t state, const unsigned char* first, size_t len, std::integral_constant<int, 8>
+                                                  /* sizeof_size_t */);
+
+            // Slow dispatch path for calls to CombineContiguousImpl with a size argument
+            // larger than PiecewiseChunkSize().  Has the same effect as calling
+            // CombineContiguousImpl() repeatedly with the chunk stride size.
+            static uint64_t CombineLargeContiguousImpl32(uint64_t state, const unsigned char* first, size_t len);
+            static uint64_t CombineLargeContiguousImpl64(uint64_t state, const unsigned char* first, size_t len);
+
+            // Reads 9 to 16 bytes from p.
+            // The least significant 8 bytes are in .first, the rest (zero padded) bytes
+            // are in .second.
+            static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p, size_t len)
+            {
+                uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
+                uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
 #ifdef ABSL_IS_LITTLE_ENDIAN
-    uint64_t most_significant = high_mem;
-    uint64_t least_significant = low_mem;
+                uint64_t most_significant = high_mem;
+                uint64_t least_significant = low_mem;
 #else
-    uint64_t most_significant = low_mem;
-    uint64_t least_significant = high_mem;
+                uint64_t most_significant = low_mem;
+                uint64_t least_significant = high_mem;
 #endif
-    return {least_significant, most_significant >> (128 - len * 8)};
-  }
-
-  // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
-  static uint64_t Read4To8(const unsigned char* p, size_t len) {
-    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
-    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
+                return {least_significant, most_significant >> (128 - len * 8)};
+            }
+
+            // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
+            static uint64_t Read4To8(const unsigned char* p, size_t len)
+            {
+                uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
+                uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
 #ifdef ABSL_IS_LITTLE_ENDIAN
-    uint32_t most_significant = high_mem;
-    uint32_t least_significant = low_mem;
+                uint32_t most_significant = high_mem;
+                uint32_t least_significant = low_mem;
 #else
-    uint32_t most_significant = low_mem;
-    uint32_t least_significant = high_mem;
+                uint32_t most_significant = low_mem;
+                uint32_t least_significant = high_mem;
 #endif
-    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
-           least_significant;
-  }
-
-  // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
-  static uint32_t Read1To3(const unsigned char* p, size_t len) {
-    unsigned char mem0 = p[0];
-    unsigned char mem1 = p[len / 2];
-    unsigned char mem2 = p[len - 1];
+                return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
+                       least_significant;
+            }
+
+            // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
+            static uint32_t Read1To3(const unsigned char* p, size_t len)
+            {
+                unsigned char mem0 = p[0];
+                unsigned char mem1 = p[len / 2];
+                unsigned char mem2 = p[len - 1];
 #ifdef ABSL_IS_LITTLE_ENDIAN
-    unsigned char significant2 = mem2;
-    unsigned char significant1 = mem1;
-    unsigned char significant0 = mem0;
+                unsigned char significant2 = mem2;
+                unsigned char significant1 = mem1;
+                unsigned char significant0 = mem0;
 #else
-    unsigned char significant2 = mem0;
-    unsigned char significant1 = mem1;
-    unsigned char significant0 = mem2;
+                unsigned char significant2 = mem0;
+                unsigned char significant1 = mem1;
+                unsigned char significant0 = mem2;
 #endif
-    return static_cast<uint32_t>(significant0 |                     //
-                                 (significant1 << (len / 2 * 8)) |  //
-                                 (significant2 << ((len - 1) * 8)));
-  }
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
-    // Though the 128-bit product on AArch64 needs two instructions, it is
-    // still a good balance between speed and hash quality.
-    using MultType =
-        absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
-    // We do the addition in 64-bit space to make sure the 128-bit
-    // multiplication is fast. If we were to do it as MultType the compiler has
-    // to assume that the high word is non-zero and needs to perform 2
-    // multiplications instead of one.
-    MultType m = state + v;
-    m *= kMul;
-    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
-  }
-
-  // An extern to avoid bloat on a direct call to LowLevelHash() with fixed
-  // values for both the seed and salt parameters.
-  static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data,
-                                                      size_t len) {
+                return static_cast<uint32_t>(significant0 |                     //
+                                             (significant1 << (len / 2 * 8)) |  //
+                                             (significant2 << ((len - 1) * 8)));
+            }
+
+            ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v)
+            {
+                // Though the 128-bit product on AArch64 needs two instructions, it is
+                // still a good balance between speed and hash quality.
+                using MultType =
+                    absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
+                // We do the addition in 64-bit space to make sure the 128-bit
+                // multiplication is fast. If we were to do it as MultType the compiler has
+                // to assume that the high word is non-zero and needs to perform 2
+                // multiplications instead of one.
+                MultType m = state + v;
+                m *= kMul;
+                return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
+            }
+
+            // An extern to avoid bloat on a direct call to LowLevelHash() with fixed
+            // values for both the seed and salt parameters.
+            static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
+
+            ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data, size_t len)
+            {
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-    return LowLevelHashImpl(data, len);
+                return LowLevelHashImpl(data, len);
 #else
-    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
+                return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
 #endif
-  }
-
-  // Seed()
-  //
-  // A non-deterministic seed.
-  //
-  // The current purpose of this seed is to generate non-deterministic results
-  // and prevent having users depend on the particular hash values.
-  // It is not meant as a security feature right now, but it leaves the door
-  // open to upgrade it to a true per-process random seed. A true random seed
-  // costs more and we don't need to pay for that right now.
-  //
-  // On platforms with ASLR, we take advantage of it to make a per-process
-  // random value.
-  // See https://en.wikipedia.org/wiki/Address_space_layout_randomization
-  //
-  // On other platforms this is still going to be non-deterministic but most
-  // probably per-build and not per-process.
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
+            }
+
+            // Seed()
+            //
+            // A non-deterministic seed.
+            //
+            // The current purpose of this seed is to generate non-deterministic results
+            // and prevent having users depend on the particular hash values.
+            // It is not meant as a security feature right now, but it leaves the door
+            // open to upgrade it to a true per-process random seed. A true random seed
+            // costs more and we don't need to pay for that right now.
+            //
+            // On platforms with ASLR, we take advantage of it to make a per-process
+            // random value.
+            // See https://en.wikipedia.org/wiki/Address_space_layout_randomization
+            //
+            // On other platforms this is still going to be non-deterministic but most
+            // probably per-build and not per-process.
+            ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed()
+            {
 #if (!defined(__clang__) || __clang_major__ > 11) && \
     !defined(__apple_build_version__)
-    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
+                return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
 #else
-    // Workaround the absence of
-    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
-    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
+                // Workaround the absence of
+                // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
+                return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
 #endif
-  }
-  static const void* const kSeed;
-
-  uint64_t state_;
-};
-
-// MixingHashState::CombineContiguousImpl()
-inline uint64_t MixingHashState::CombineContiguousImpl(
-    uint64_t state, const unsigned char* first, size_t len,
-    std::integral_constant<int, 4> /* sizeof_size_t */) {
-  // For large values we use CityHash, for small ones we just use a
-  // multiplicative hash.
-  uint64_t v;
-  if (len > 8) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
-      return CombineLargeContiguousImpl32(state, first, len);
-    }
-    v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
-  } else if (len >= 4) {
-    v = Read4To8(first, len);
-  } else if (len > 0) {
-    v = Read1To3(first, len);
-  } else {
-    // Empty ranges have no effect.
-    return state;
-  }
-  return Mix(state, v);
-}
-
-// Overload of MixingHashState::CombineContiguousImpl()
-inline uint64_t MixingHashState::CombineContiguousImpl(
-    uint64_t state, const unsigned char* first, size_t len,
-    std::integral_constant<int, 8> /* sizeof_size_t */) {
-  // For large values we use LowLevelHash or CityHash depending on the platform,
-  // for small ones we just use a multiplicative hash.
-  uint64_t v;
-  if (len > 16) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
-      return CombineLargeContiguousImpl64(state, first, len);
-    }
-    v = Hash64(first, len);
-  } else if (len > 8) {
-    auto p = Read9To16(first, len);
-    state = Mix(state, p.first);
-    v = p.second;
-  } else if (len >= 4) {
-    v = Read4To8(first, len);
-  } else if (len > 0) {
-    v = Read1To3(first, len);
-  } else {
-    // Empty ranges have no effect.
-    return state;
-  }
-  return Mix(state, v);
-}
-
-struct AggregateBarrier {};
-
-// HashImpl
-
-// Add a private base class to make sure this type is not an aggregate.
-// Aggregates can be aggregate initialized even if the default constructor is
-// deleted.
-struct PoisonedHash : private AggregateBarrier {
-  PoisonedHash() = delete;
-  PoisonedHash(const PoisonedHash&) = delete;
-  PoisonedHash& operator=(const PoisonedHash&) = delete;
-};
-
-template <typename T>
-struct HashImpl {
-  size_t operator()(const T& value) const {
-    return MixingHashState::hash(value);
-  }
-};
-
-template <typename T>
-struct Hash
-    : absl::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash> {};
-
-template <typename H>
-template <typename T, typename... Ts>
-H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
-  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
-                        std::move(state), value),
-                    values...);
-}
-
-// HashStateBase::combine_contiguous()
-template <typename H>
-template <typename T>
-H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
-  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
-}
-
-// HashStateBase::combine_unordered()
-template <typename H>
-template <typename I>
-H HashStateBase<H>::combine_unordered(H state, I begin, I end) {
-  return H::RunCombineUnordered(std::move(state),
-                                CombineUnorderedCallback<I>{begin, end});
-}
-
-// HashStateBase::PiecewiseCombiner::add_buffer()
-template <typename H>
-H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
-                                size_t size) {
-  if (position_ + size < PiecewiseChunkSize()) {
-    // This partial chunk does not fill our existing buffer
-    memcpy(buf_ + position_, data, size);
-    position_ += size;
-    return state;
-  }
-
-  // If the buffer is partially filled we need to complete the buffer
-  // and hash it.
-  if (position_ != 0) {
-    const size_t bytes_needed = PiecewiseChunkSize() - position_;
-    memcpy(buf_ + position_, data, bytes_needed);
-    state = H::combine_contiguous(std::move(state), buf_, PiecewiseChunkSize());
-    data += bytes_needed;
-    size -= bytes_needed;
-  }
-
-  // Hash whatever chunks we can without copying
-  while (size >= PiecewiseChunkSize()) {
-    state = H::combine_contiguous(std::move(state), data, PiecewiseChunkSize());
-    data += PiecewiseChunkSize();
-    size -= PiecewiseChunkSize();
-  }
-  // Fill the buffer with the remainder
-  memcpy(buf_, data, size);
-  position_ = size;
-  return state;
-}
-
-// HashStateBase::PiecewiseCombiner::finalize()
-template <typename H>
-H PiecewiseCombiner::finalize(H state) {
-  // Hash the remainder left in the buffer, which may be empty
-  return H::combine_contiguous(std::move(state), buf_, position_);
-}
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
+            }
+            static const void* const kSeed;
+
+            uint64_t state_;
+        };
+
+        // MixingHashState::CombineContiguousImpl()
+        inline uint64_t MixingHashState::CombineContiguousImpl(
+            uint64_t state, const unsigned char* first, size_t len, std::integral_constant<int, 4> /* sizeof_size_t */
+        )
+        {
+            // For large values we use CityHash, for small ones we just use a
+            // multiplicative hash.
+            uint64_t v;
+            if (len > 8)
+            {
+                if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize()))
+                {
+                    return CombineLargeContiguousImpl32(state, first, len);
+                }
+                v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
+            }
+            else if (len >= 4)
+            {
+                v = Read4To8(first, len);
+            }
+            else if (len > 0)
+            {
+                v = Read1To3(first, len);
+            }
+            else
+            {
+                // Empty ranges have no effect.
+                return state;
+            }
+            return Mix(state, v);
+        }
+
+        // Overload of MixingHashState::CombineContiguousImpl()
+        inline uint64_t MixingHashState::CombineContiguousImpl(
+            uint64_t state, const unsigned char* first, size_t len, std::integral_constant<int, 8> /* sizeof_size_t */
+        )
+        {
+            // For large values we use LowLevelHash or CityHash depending on the platform,
+            // for small ones we just use a multiplicative hash.
+            uint64_t v;
+            if (len > 16)
+            {
+                if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize()))
+                {
+                    return CombineLargeContiguousImpl64(state, first, len);
+                }
+                v = Hash64(first, len);
+            }
+            else if (len > 8)
+            {
+                auto p = Read9To16(first, len);
+                state = Mix(state, p.first);
+                v = p.second;
+            }
+            else if (len >= 4)
+            {
+                v = Read4To8(first, len);
+            }
+            else if (len > 0)
+            {
+                v = Read1To3(first, len);
+            }
+            else
+            {
+                // Empty ranges have no effect.
+                return state;
+            }
+            return Mix(state, v);
+        }
+
+        struct AggregateBarrier
+        {
+        };
+
+        // HashImpl
+
+        // Add a private base class to make sure this type is not an aggregate.
+        // Aggregates can be aggregate initialized even if the default constructor is
+        // deleted.
+        struct PoisonedHash : private AggregateBarrier
+        {
+            PoisonedHash() = delete;
+            PoisonedHash(const PoisonedHash&) = delete;
+            PoisonedHash& operator=(const PoisonedHash&) = delete;
+        };
+
+        template<typename T>
+        struct HashImpl
+        {
+            size_t operator()(const T& value) const
+            {
+                return MixingHashState::hash(value);
+            }
+        };
+
+        template<typename T>
+        struct Hash : absl::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash>
+        {
+        };
+
+        template<typename H>
+        template<typename T, typename... Ts>
+        H HashStateBase<H>::combine(H state, const T& value, const Ts&... values)
+        {
+            return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(std::move(state), value), values...);
+        }
+
+        // HashStateBase::combine_contiguous()
+        template<typename H>
+        template<typename T>
+        H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size)
+        {
+            return hash_internal::hash_range_or_bytes(std::move(state), data, size);
+        }
+
+        // HashStateBase::combine_unordered()
+        template<typename H>
+        template<typename I>
+        H HashStateBase<H>::combine_unordered(H state, I begin, I end)
+        {
+            return H::RunCombineUnordered(std::move(state), CombineUnorderedCallback<I>{begin, end});
+        }
+
+        // HashStateBase::PiecewiseCombiner::add_buffer()
+        template<typename H>
+        H PiecewiseCombiner::add_buffer(H state, const unsigned char* data, size_t size)
+        {
+            if (position_ + size < PiecewiseChunkSize())
+            {
+                // This partial chunk does not fill our existing buffer
+                memcpy(buf_ + position_, data, size);
+                position_ += size;
+                return state;
+            }
+
+            // If the buffer is partially filled we need to complete the buffer
+            // and hash it.
+            if (position_ != 0)
+            {
+                const size_t bytes_needed = PiecewiseChunkSize() - position_;
+                memcpy(buf_ + position_, data, bytes_needed);
+                state = H::combine_contiguous(std::move(state), buf_, PiecewiseChunkSize());
+                data += bytes_needed;
+                size -= bytes_needed;
+            }
+
+            // Hash whatever chunks we can without copying
+            while (size >= PiecewiseChunkSize())
+            {
+                state = H::combine_contiguous(std::move(state), data, PiecewiseChunkSize());
+                data += PiecewiseChunkSize();
+                size -= PiecewiseChunkSize();
+            }
+            // Fill the buffer with the remainder
+            memcpy(buf_, data, size);
+            position_ = size;
+            return state;
+        }
+
+        // HashStateBase::PiecewiseCombiner::finalize()
+        template<typename H>
+        H PiecewiseCombiner::finalize(H state)
+        {
+            // Hash the remainder left in the buffer, which may be empty
+            return H::combine_contiguous(std::move(state), buf_, position_);
+        }
+
+    }  // namespace hash_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_HASH_INTERNAL_HASH_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/internal/low_level_hash.h b/CAPI/cpp/grpc/include/absl/hash/internal/low_level_hash.h
index 439968a..025c477 100644
--- a/CAPI/cpp/grpc/include/absl/hash/internal/low_level_hash.h
+++ b/CAPI/cpp/grpc/include/absl/hash/internal/low_level_hash.h
@@ -30,21 +30,22 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace hash_internal
+    {
 
-// Hash function for a byte array. A 64-bit seed and a set of five 64-bit
-// integers are hashed into the result.
-//
-// To allow all hashable types (including string_view and Span) to depend on
-// this algorithm, we keep the API low-level, with as few dependencies as
-// possible.
-uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
-                      const uint64_t salt[5]);
+        // Hash function for a byte array. A 64-bit seed and a set of five 64-bit
+        // integers are hashed into the result.
+        //
+        // To allow all hashable types (including string_view and Span) to depend on
+        // this algorithm, we keep the API low-level, with as few dependencies as
+        // possible.
+        uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed, const uint64_t salt[5]);
 
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
+    }  // namespace hash_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
diff --git a/CAPI/cpp/grpc/include/absl/hash/internal/spy_hash_state.h b/CAPI/cpp/grpc/include/absl/hash/internal/spy_hash_state.h
index 0972826..bb95e36 100644
--- a/CAPI/cpp/grpc/include/absl/hash/internal/spy_hash_state.h
+++ b/CAPI/cpp/grpc/include/absl/hash/internal/spy_hash_state.h
@@ -25,242 +25,275 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// SpyHashState is an implementation of the HashState API that simply
-// accumulates all input bytes in an internal buffer. This makes it useful
-// for testing AbslHashValue overloads (so long as they are templated on the
-// HashState parameter), since it can report the exact hash representation
-// that the AbslHashValue overload produces.
-//
-// Sample usage:
-// EXPECT_EQ(SpyHashState::combine(SpyHashState(), foo),
-//           SpyHashState::combine(SpyHashState(), bar));
-template <typename T>
-class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> {
- public:
-  SpyHashStateImpl() : error_(std::make_shared<absl::optional<std::string>>()) {
-    static_assert(std::is_void<T>::value, "");
-  }
-
-  // Move-only
-  SpyHashStateImpl(const SpyHashStateImpl&) = delete;
-  SpyHashStateImpl& operator=(const SpyHashStateImpl&) = delete;
-
-  SpyHashStateImpl(SpyHashStateImpl&& other) noexcept {
-    *this = std::move(other);
-  }
-
-  SpyHashStateImpl& operator=(SpyHashStateImpl&& other) noexcept {
-    hash_representation_ = std::move(other.hash_representation_);
-    error_ = other.error_;
-    moved_from_ = other.moved_from_;
-    other.moved_from_ = true;
-    return *this;
-  }
-
-  template <typename U>
-  SpyHashStateImpl(SpyHashStateImpl<U>&& other) {  // NOLINT
-    hash_representation_ = std::move(other.hash_representation_);
-    error_ = other.error_;
-    moved_from_ = other.moved_from_;
-    other.moved_from_ = true;
-  }
-
-  template <typename A, typename... Args>
-  static SpyHashStateImpl combine(SpyHashStateImpl s, const A& a,
-                                  const Args&... args) {
-    // Pass an instance of SpyHashStateImpl<A> when trying to combine `A`. This
-    // allows us to test that the user only uses this instance for combine calls
-    // and does not call AbslHashValue directly.
-    // See AbslHashValue implementation at the bottom.
-    s = SpyHashStateImpl<A>::HashStateBase::combine(std::move(s), a);
-    return SpyHashStateImpl::combine(std::move(s), args...);
-  }
-  static SpyHashStateImpl combine(SpyHashStateImpl s) {
-    if (direct_absl_hash_value_error_) {
-      *s.error_ = "AbslHashValue should not be invoked directly.";
-    } else if (s.moved_from_) {
-      *s.error_ = "Used moved-from instance of the hash state object.";
-    }
-    return s;
-  }
-
-  static void SetDirectAbslHashValueError() {
-    direct_absl_hash_value_error_ = true;
-  }
-
-  // Two SpyHashStateImpl objects are equal if they hold equal hash
-  // representations.
-  friend bool operator==(const SpyHashStateImpl& lhs,
-                         const SpyHashStateImpl& rhs) {
-    return lhs.hash_representation_ == rhs.hash_representation_;
-  }
-
-  friend bool operator!=(const SpyHashStateImpl& lhs,
-                         const SpyHashStateImpl& rhs) {
-    return !(lhs == rhs);
-  }
-
-  enum class CompareResult {
-    kEqual,
-    kASuffixB,
-    kBSuffixA,
-    kUnequal,
-  };
-
-  static CompareResult Compare(const SpyHashStateImpl& a,
-                               const SpyHashStateImpl& b) {
-    const std::string a_flat = absl::StrJoin(a.hash_representation_, "");
-    const std::string b_flat = absl::StrJoin(b.hash_representation_, "");
-    if (a_flat == b_flat) return CompareResult::kEqual;
-    if (absl::EndsWith(a_flat, b_flat)) return CompareResult::kBSuffixA;
-    if (absl::EndsWith(b_flat, a_flat)) return CompareResult::kASuffixB;
-    return CompareResult::kUnequal;
-  }
-
-  // operator<< prints the hash representation as a hex and ASCII dump, to
-  // facilitate debugging.
-  friend std::ostream& operator<<(std::ostream& out,
-                                  const SpyHashStateImpl& hash_state) {
-    out << "[\n";
-    for (auto& s : hash_state.hash_representation_) {
-      size_t offset = 0;
-      for (char c : s) {
-        if (offset % 16 == 0) {
-          out << absl::StreamFormat("\n0x%04x: ", offset);
-        }
-        if (offset % 2 == 0) {
-          out << " ";
-        }
-        out << absl::StreamFormat("%02x", c);
-        ++offset;
-      }
-      out << "\n";
-    }
-    return out << "]";
-  }
-
-  // The base case of the combine recursion, which writes raw bytes into the
-  // internal buffer.
-  static SpyHashStateImpl combine_contiguous(SpyHashStateImpl hash_state,
-                                             const unsigned char* begin,
-                                             size_t size) {
-    const size_t large_chunk_stride = PiecewiseChunkSize();
-    if (size > large_chunk_stride) {
-      // Combining a large contiguous buffer must have the same effect as
-      // doing it piecewise by the stride length, followed by the (possibly
-      // empty) remainder.
-      while (size >= large_chunk_stride) {
-        hash_state = SpyHashStateImpl::combine_contiguous(
-            std::move(hash_state), begin, large_chunk_stride);
-        begin += large_chunk_stride;
-        size -= large_chunk_stride;
-      }
-    }
-
-    hash_state.hash_representation_.emplace_back(
-        reinterpret_cast<const char*>(begin), size);
-    return hash_state;
-  }
-
-  using SpyHashStateImpl::HashStateBase::combine_contiguous;
-
-  template <typename CombinerT>
-  static SpyHashStateImpl RunCombineUnordered(SpyHashStateImpl state,
-                                              CombinerT combiner) {
-    UnorderedCombinerCallback cb;
-
-    combiner(SpyHashStateImpl<void>{}, std::ref(cb));
-
-    std::sort(cb.element_hash_representations.begin(),
-              cb.element_hash_representations.end());
-    state.hash_representation_.insert(state.hash_representation_.end(),
-                                      cb.element_hash_representations.begin(),
-                                      cb.element_hash_representations.end());
-    if (cb.error && cb.error->has_value()) {
-      state.error_ = std::move(cb.error);
-    }
-    return state;
-  }
-
-  absl::optional<std::string> error() const {
-    if (moved_from_) {
-      return "Returned a moved-from instance of the hash state object.";
-    }
-    return *error_;
-  }
-
- private:
-  template <typename U>
-  friend class SpyHashStateImpl;
-
-  struct UnorderedCombinerCallback {
-    std::vector<std::string> element_hash_representations;
-    std::shared_ptr<absl::optional<std::string>> error;
-
-    // The inner spy can have a different type.
-    template <typename U>
-    void operator()(SpyHashStateImpl<U>& inner) {
-      element_hash_representations.push_back(
-          absl::StrJoin(inner.hash_representation_, ""));
-      if (inner.error_->has_value()) {
-        error = std::move(inner.error_);
-      }
-      inner = SpyHashStateImpl<void>{};
-    }
-  };
-
-  // This is true if SpyHashStateImpl<T> has been passed to a call of
-  // AbslHashValue with the wrong type. This detects that the user called
-  // AbslHashValue directly (because the hash state type does not match).
-  static bool direct_absl_hash_value_error_;
-
-  std::vector<std::string> hash_representation_;
-  // This is a shared_ptr because we want all instances of the particular
-  // SpyHashState run to share the field. This way we can set the error for
-  // use-after-move and all the copies will see it.
-  std::shared_ptr<absl::optional<std::string>> error_;
-  bool moved_from_ = false;
-};
-
-template <typename T>
-bool SpyHashStateImpl<T>::direct_absl_hash_value_error_;
-
-template <bool& B>
-struct OdrUse {
-  constexpr OdrUse() {}
-  bool& b = B;
-};
-
-template <void (*)()>
-struct RunOnStartup {
-  static bool run;
-  static constexpr OdrUse<run> kOdrUse{};
-};
-
-template <void (*f)()>
-bool RunOnStartup<f>::run = (f(), true);
-
-template <
-    typename T, typename U,
-    // Only trigger for when (T != U),
-    typename = absl::enable_if_t<!std::is_same<T, U>::value>,
-    // This statement works in two ways:
-    //  - First, it instantiates RunOnStartup and forces the initialization of
-    //    `run`, which set the global variable.
-    //  - Second, it triggers a SFINAE error disabling the overload to prevent
-    //    compile time errors. If we didn't disable the overload we would get
-    //    ambiguous overload errors, which we don't want.
-    int = RunOnStartup<SpyHashStateImpl<T>::SetDirectAbslHashValueError>::run>
-void AbslHashValue(SpyHashStateImpl<T>, const U&);
-
-using SpyHashState = SpyHashStateImpl<void>;
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace hash_internal
+    {
+
+        // SpyHashState is an implementation of the HashState API that simply
+        // accumulates all input bytes in an internal buffer. This makes it useful
+        // for testing AbslHashValue overloads (so long as they are templated on the
+        // HashState parameter), since it can report the exact hash representation
+        // that the AbslHashValue overload produces.
+        //
+        // Sample usage:
+        // EXPECT_EQ(SpyHashState::combine(SpyHashState(), foo),
+        //           SpyHashState::combine(SpyHashState(), bar));
+        template<typename T>
+        class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>>
+        {
+        public:
+            SpyHashStateImpl() :
+                error_(std::make_shared<absl::optional<std::string>>())
+            {
+                static_assert(std::is_void<T>::value, "");
+            }
+
+            // Move-only
+            SpyHashStateImpl(const SpyHashStateImpl&) = delete;
+            SpyHashStateImpl& operator=(const SpyHashStateImpl&) = delete;
+
+            SpyHashStateImpl(SpyHashStateImpl&& other) noexcept
+            {
+                *this = std::move(other);
+            }
+
+            SpyHashStateImpl& operator=(SpyHashStateImpl&& other) noexcept
+            {
+                hash_representation_ = std::move(other.hash_representation_);
+                error_ = other.error_;
+                moved_from_ = other.moved_from_;
+                other.moved_from_ = true;
+                return *this;
+            }
+
+            template<typename U>
+            SpyHashStateImpl(SpyHashStateImpl<U>&& other)
+            {  // NOLINT
+                hash_representation_ = std::move(other.hash_representation_);
+                error_ = other.error_;
+                moved_from_ = other.moved_from_;
+                other.moved_from_ = true;
+            }
+
+            template<typename A, typename... Args>
+            static SpyHashStateImpl combine(SpyHashStateImpl s, const A& a, const Args&... args)
+            {
+                // Pass an instance of SpyHashStateImpl<A> when trying to combine `A`. This
+                // allows us to test that the user only uses this instance for combine calls
+                // and does not call AbslHashValue directly.
+                // See AbslHashValue implementation at the bottom.
+                s = SpyHashStateImpl<A>::HashStateBase::combine(std::move(s), a);
+                return SpyHashStateImpl::combine(std::move(s), args...);
+            }
+            static SpyHashStateImpl combine(SpyHashStateImpl s)
+            {
+                if (direct_absl_hash_value_error_)
+                {
+                    *s.error_ = "AbslHashValue should not be invoked directly.";
+                }
+                else if (s.moved_from_)
+                {
+                    *s.error_ = "Used moved-from instance of the hash state object.";
+                }
+                return s;
+            }
+
+            static void SetDirectAbslHashValueError()
+            {
+                direct_absl_hash_value_error_ = true;
+            }
+
+            // Two SpyHashStateImpl objects are equal if they hold equal hash
+            // representations.
+            friend bool operator==(const SpyHashStateImpl& lhs, const SpyHashStateImpl& rhs)
+            {
+                return lhs.hash_representation_ == rhs.hash_representation_;
+            }
+
+            friend bool operator!=(const SpyHashStateImpl& lhs, const SpyHashStateImpl& rhs)
+            {
+                return !(lhs == rhs);
+            }
+
+            enum class CompareResult
+            {
+                kEqual,
+                kASuffixB,
+                kBSuffixA,
+                kUnequal,
+            };
+
+            static CompareResult Compare(const SpyHashStateImpl& a, const SpyHashStateImpl& b)
+            {
+                const std::string a_flat = absl::StrJoin(a.hash_representation_, "");
+                const std::string b_flat = absl::StrJoin(b.hash_representation_, "");
+                if (a_flat == b_flat)
+                    return CompareResult::kEqual;
+                if (absl::EndsWith(a_flat, b_flat))
+                    return CompareResult::kBSuffixA;
+                if (absl::EndsWith(b_flat, a_flat))
+                    return CompareResult::kASuffixB;
+                return CompareResult::kUnequal;
+            }
+
+            // operator<< prints the hash representation as a hex and ASCII dump, to
+            // facilitate debugging.
+            friend std::ostream& operator<<(std::ostream& out, const SpyHashStateImpl& hash_state)
+            {
+                out << "[\n";
+                for (auto& s : hash_state.hash_representation_)
+                {
+                    size_t offset = 0;
+                    for (char c : s)
+                    {
+                        if (offset % 16 == 0)
+                        {
+                            out << absl::StreamFormat("\n0x%04x: ", offset);
+                        }
+                        if (offset % 2 == 0)
+                        {
+                            out << " ";
+                        }
+                        out << absl::StreamFormat("%02x", c);
+                        ++offset;
+                    }
+                    out << "\n";
+                }
+                return out << "]";
+            }
+
+            // The base case of the combine recursion, which writes raw bytes into the
+            // internal buffer.
+            static SpyHashStateImpl combine_contiguous(SpyHashStateImpl hash_state, const unsigned char* begin, size_t size)
+            {
+                const size_t large_chunk_stride = PiecewiseChunkSize();
+                if (size > large_chunk_stride)
+                {
+                    // Combining a large contiguous buffer must have the same effect as
+                    // doing it piecewise by the stride length, followed by the (possibly
+                    // empty) remainder.
+                    while (size >= large_chunk_stride)
+                    {
+                        hash_state = SpyHashStateImpl::combine_contiguous(
+                            std::move(hash_state), begin, large_chunk_stride
+                        );
+                        begin += large_chunk_stride;
+                        size -= large_chunk_stride;
+                    }
+                }
+
+                hash_state.hash_representation_.emplace_back(
+                    reinterpret_cast<const char*>(begin), size
+                );
+                return hash_state;
+            }
+
+            using SpyHashStateImpl::HashStateBase::combine_contiguous;
+
+            template<typename CombinerT>
+            static SpyHashStateImpl RunCombineUnordered(SpyHashStateImpl state, CombinerT combiner)
+            {
+                UnorderedCombinerCallback cb;
+
+                combiner(SpyHashStateImpl<void>{}, std::ref(cb));
+
+                std::sort(cb.element_hash_representations.begin(), cb.element_hash_representations.end());
+                state.hash_representation_.insert(state.hash_representation_.end(), cb.element_hash_representations.begin(), cb.element_hash_representations.end());
+                if (cb.error && cb.error->has_value())
+                {
+                    state.error_ = std::move(cb.error);
+                }
+                return state;
+            }
+
+            absl::optional<std::string> error() const
+            {
+                if (moved_from_)
+                {
+                    return "Returned a moved-from instance of the hash state object.";
+                }
+                return *error_;
+            }
+
+        private:
+            template<typename U>
+            friend class SpyHashStateImpl;
+
+            struct UnorderedCombinerCallback
+            {
+                std::vector<std::string> element_hash_representations;
+                std::shared_ptr<absl::optional<std::string>> error;
+
+                // The inner spy can have a different type.
+                template<typename U>
+                void operator()(SpyHashStateImpl<U>& inner)
+                {
+                    element_hash_representations.push_back(
+                        absl::StrJoin(inner.hash_representation_, "")
+                    );
+                    if (inner.error_->has_value())
+                    {
+                        error = std::move(inner.error_);
+                    }
+                    inner = SpyHashStateImpl<void>{};
+                }
+            };
+
+            // This is true if SpyHashStateImpl<T> has been passed to a call of
+            // AbslHashValue with the wrong type. This detects that the user called
+            // AbslHashValue directly (because the hash state type does not match).
+            static bool direct_absl_hash_value_error_;
+
+            std::vector<std::string> hash_representation_;
+            // This is a shared_ptr because we want all instances of the particular
+            // SpyHashState run to share the field. This way we can set the error for
+            // use-after-move and all the copies will see it.
+            std::shared_ptr<absl::optional<std::string>> error_;
+            bool moved_from_ = false;
+        };
+
+        template<typename T>
+        bool SpyHashStateImpl<T>::direct_absl_hash_value_error_;
+
+        template<bool& B>
+        struct OdrUse
+        {
+            constexpr OdrUse()
+            {
+            }
+            bool& b = B;
+        };
+
+        template<void (*)()>
+        struct RunOnStartup
+        {
+            static bool run;
+            static constexpr OdrUse<run> kOdrUse{};
+        };
+
+        template<void (*f)()>
+        bool RunOnStartup<f>::run = (f(), true);
+
+        template<
+            typename T,
+            typename U,
+            // Only trigger for when (T != U),
+            typename = absl::enable_if_t<!std::is_same<T, U>::value>,
+            // This statement works in two ways:
+            //  - First, it instantiates RunOnStartup and forces the initialization of
+            //    `run`, which set the global variable.
+            //  - Second, it triggers a SFINAE error disabling the overload to prevent
+            //    compile time errors. If we didn't disable the overload we would get
+            //    ambiguous overload errors, which we don't want.
+            int = RunOnStartup<SpyHashStateImpl<T>::SetDirectAbslHashValueError>::run>
+        void AbslHashValue(SpyHashStateImpl<T>, const U&);
+
+        using SpyHashState = SpyHashStateImpl<void>;
+
+    }  // namespace hash_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
diff --git a/CAPI/cpp/grpc/include/absl/memory/memory.h b/CAPI/cpp/grpc/include/absl/memory/memory.h
index d633260..45a6e4a 100644
--- a/CAPI/cpp/grpc/include/absl/memory/memory.h
+++ b/CAPI/cpp/grpc/include/absl/memory/memory.h
@@ -33,65 +33,71 @@
 #include "absl/base/macros.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // -----------------------------------------------------------------------------
+    // Function Template: WrapUnique()
+    // -----------------------------------------------------------------------------
+    //
+    // Adopts ownership from a raw pointer and transfers it to the returned
+    // `std::unique_ptr`, whose type is deduced. Because of this deduction, *do not*
+    // specify the template type `T` when calling `WrapUnique`.
+    //
+    // Example:
+    //   X* NewX(int, int);
+    //   auto x = WrapUnique(NewX(1, 2));  // 'x' is std::unique_ptr<X>.
+    //
+    // Do not call WrapUnique with an explicit type, as in
+    // `WrapUnique<X>(NewX(1, 2))`.  The purpose of WrapUnique is to automatically
+    // deduce the pointer type. If you wish to make the type explicit, just use
+    // `std::unique_ptr` directly.
+    //
+    //   auto x = std::unique_ptr<X>(NewX(1, 2));
+    //                  - or -
+    //   std::unique_ptr<X> x(NewX(1, 2));
+    //
+    // While `absl::WrapUnique` is useful for capturing the output of a raw
+    // pointer factory, prefer 'absl::make_unique<T>(args...)' over
+    // 'absl::WrapUnique(new T(args...))'.
+    //
+    //   auto x = WrapUnique(new X(1, 2));  // works, but nonideal.
+    //   auto x = make_unique<X>(1, 2);     // safer, standard, avoids raw 'new'.
+    //
+    // Note that `absl::WrapUnique(p)` is valid only if `delete p` is a valid
+    // expression. In particular, `absl::WrapUnique()` cannot wrap pointers to
+    // arrays, functions or void, and it must not be used to capture pointers
+    // obtained from array-new expressions (even though that would compile!).
+    template<typename T>
+    std::unique_ptr<T> WrapUnique(T* ptr)
+    {
+        static_assert(!std::is_array<T>::value, "array types are unsupported");
+        static_assert(std::is_object<T>::value, "non-object types are unsupported");
+        return std::unique_ptr<T>(ptr);
+    }
 
-// -----------------------------------------------------------------------------
-// Function Template: WrapUnique()
-// -----------------------------------------------------------------------------
-//
-// Adopts ownership from a raw pointer and transfers it to the returned
-// `std::unique_ptr`, whose type is deduced. Because of this deduction, *do not*
-// specify the template type `T` when calling `WrapUnique`.
-//
-// Example:
-//   X* NewX(int, int);
-//   auto x = WrapUnique(NewX(1, 2));  // 'x' is std::unique_ptr<X>.
-//
-// Do not call WrapUnique with an explicit type, as in
-// `WrapUnique<X>(NewX(1, 2))`.  The purpose of WrapUnique is to automatically
-// deduce the pointer type. If you wish to make the type explicit, just use
-// `std::unique_ptr` directly.
-//
-//   auto x = std::unique_ptr<X>(NewX(1, 2));
-//                  - or -
-//   std::unique_ptr<X> x(NewX(1, 2));
-//
-// While `absl::WrapUnique` is useful for capturing the output of a raw
-// pointer factory, prefer 'absl::make_unique<T>(args...)' over
-// 'absl::WrapUnique(new T(args...))'.
-//
-//   auto x = WrapUnique(new X(1, 2));  // works, but nonideal.
-//   auto x = make_unique<X>(1, 2);     // safer, standard, avoids raw 'new'.
-//
-// Note that `absl::WrapUnique(p)` is valid only if `delete p` is a valid
-// expression. In particular, `absl::WrapUnique()` cannot wrap pointers to
-// arrays, functions or void, and it must not be used to capture pointers
-// obtained from array-new expressions (even though that would compile!).
-template <typename T>
-std::unique_ptr<T> WrapUnique(T* ptr) {
-  static_assert(!std::is_array<T>::value, "array types are unsupported");
-  static_assert(std::is_object<T>::value, "non-object types are unsupported");
-  return std::unique_ptr<T>(ptr);
-}
-
-namespace memory_internal {
-
-// Traits to select proper overload and return type for `absl::make_unique<>`.
-template <typename T>
-struct MakeUniqueResult {
-  using scalar = std::unique_ptr<T>;
-};
-template <typename T>
-struct MakeUniqueResult<T[]> {
-  using array = std::unique_ptr<T[]>;
-};
-template <typename T, size_t N>
-struct MakeUniqueResult<T[N]> {
-  using invalid = void;
-};
-
-}  // namespace memory_internal
+    namespace memory_internal
+    {
+
+        // Traits to select proper overload and return type for `absl::make_unique<>`.
+        template<typename T>
+        struct MakeUniqueResult
+        {
+            using scalar = std::unique_ptr<T>;
+        };
+        template<typename T>
+        struct MakeUniqueResult<T[]>
+        {
+            using array = std::unique_ptr<T[]>;
+        };
+        template<typename T, size_t N>
+        struct MakeUniqueResult<T[N]>
+        {
+            using invalid = void;
+        };
+
+    }  // namespace memory_internal
 
 // gcc 4.8 has __cplusplus at 201301 but the libstdc++ shipped with it doesn't
 // define make_unique.  Other supported compilers either just define __cplusplus
@@ -99,320 +105,345 @@ struct MakeUniqueResult<T[N]> {
 // __cplusplus > 201103 (clang).
 #if (__cplusplus > 201103L || defined(_MSC_VER)) && \
     !(defined(__GLIBCXX__) && !defined(__cpp_lib_make_unique))
-using std::make_unique;
+    using std::make_unique;
 #else
-// -----------------------------------------------------------------------------
-// Function Template: make_unique<T>()
-// -----------------------------------------------------------------------------
-//
-// Creates a `std::unique_ptr<>`, while avoiding issues creating temporaries
-// during the construction process. `absl::make_unique<>` also avoids redundant
-// type declarations, by avoiding the need to explicitly use the `new` operator.
-//
-// This implementation of `absl::make_unique<>` is designed for C++11 code and
-// will be replaced in C++14 by the equivalent `std::make_unique<>` abstraction.
-// `absl::make_unique<>` is designed to be 100% compatible with
-// `std::make_unique<>` so that the eventual migration will involve a simple
-// rename operation.
-//
-// For more background on why `std::unique_ptr<T>(new T(a,b))` is problematic,
-// see Herb Sutter's explanation on
-// (Exception-Safe Function Calls)[https://herbsutter.com/gotw/_102/].
-// (In general, reviewers should treat `new T(a,b)` with scrutiny.)
-//
-// Example usage:
-//
-//    auto p = make_unique<X>(args...);  // 'p'  is a std::unique_ptr<X>
-//    auto pa = make_unique<X[]>(5);     // 'pa' is a std::unique_ptr<X[]>
-//
-// Three overloads of `absl::make_unique` are required:
-//
-//   - For non-array T:
-//
-//       Allocates a T with `new T(std::forward<Args> args...)`,
-//       forwarding all `args` to T's constructor.
-//       Returns a `std::unique_ptr<T>` owning that object.
-//
-//   - For an array of unknown bounds T[]:
-//
-//       `absl::make_unique<>` will allocate an array T of type U[] with
-//       `new U[n]()` and return a `std::unique_ptr<U[]>` owning that array.
-//
-//       Note that 'U[n]()' is different from 'U[n]', and elements will be
-//       value-initialized. Note as well that `std::unique_ptr` will perform its
-//       own destruction of the array elements upon leaving scope, even though
-//       the array [] does not have a default destructor.
-//
-//       NOTE: an array of unknown bounds T[] may still be (and often will be)
-//       initialized to have a size, and will still use this overload. E.g:
-//
-//         auto my_array = absl::make_unique<int[]>(10);
-//
-//   - For an array of known bounds T[N]:
-//
-//       `absl::make_unique<>` is deleted (like with `std::make_unique<>`) as
-//       this overload is not useful.
-//
-//       NOTE: an array of known bounds T[N] is not considered a useful
-//       construction, and may cause undefined behavior in templates. E.g:
-//
-//         auto my_array = absl::make_unique<int[10]>();
-//
-//       In those cases, of course, you can still use the overload above and
-//       simply initialize it to its desired size:
-//
-//         auto my_array = absl::make_unique<int[]>(10);
-
-// `absl::make_unique` overload for non-array types.
-template <typename T, typename... Args>
-typename memory_internal::MakeUniqueResult<T>::scalar make_unique(
-    Args&&... args) {
-  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-// `absl::make_unique` overload for an array T[] of unknown bounds.
-// The array allocation needs to use the `new T[size]` form and cannot take
-// element constructor arguments. The `std::unique_ptr` will manage destructing
-// these array elements.
-template <typename T>
-typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n) {
-  return std::unique_ptr<T>(new typename absl::remove_extent_t<T>[n]());
-}
-
-// `absl::make_unique` overload for an array T[N] of known bounds.
-// This construction will be rejected.
-template <typename T, typename... Args>
-typename memory_internal::MakeUniqueResult<T>::invalid make_unique(
-    Args&&... /* args */) = delete;
-#endif
-
-// -----------------------------------------------------------------------------
-// Function Template: RawPtr()
-// -----------------------------------------------------------------------------
-//
-// Extracts the raw pointer from a pointer-like value `ptr`. `absl::RawPtr` is
-// useful within templates that need to handle a complement of raw pointers,
-// `std::nullptr_t`, and smart pointers.
-template <typename T>
-auto RawPtr(T&& ptr) -> decltype(std::addressof(*ptr)) {
-  // ptr is a forwarding reference to support Ts with non-const operators.
-  return (ptr != nullptr) ? std::addressof(*ptr) : nullptr;
-}
-inline std::nullptr_t RawPtr(std::nullptr_t) { return nullptr; }
-
-// -----------------------------------------------------------------------------
-// Function Template: ShareUniquePtr()
-// -----------------------------------------------------------------------------
-//
-// Adopts a `std::unique_ptr` rvalue and returns a `std::shared_ptr` of deduced
-// type. Ownership (if any) of the held value is transferred to the returned
-// shared pointer.
-//
-// Example:
-//
-//     auto up = absl::make_unique<int>(10);
-//     auto sp = absl::ShareUniquePtr(std::move(up));  // shared_ptr<int>
-//     CHECK_EQ(*sp, 10);
-//     CHECK(up == nullptr);
-//
-// Note that this conversion is correct even when T is an array type, and more
-// generally it works for *any* deleter of the `unique_ptr` (single-object
-// deleter, array deleter, or any custom deleter), since the deleter is adopted
-// by the shared pointer as well. The deleter is copied (unless it is a
-// reference).
-//
-// Implements the resolution of [LWG 2415](http://wg21.link/lwg2415), by which a
-// null shared pointer does not attempt to call the deleter.
-template <typename T, typename D>
-std::shared_ptr<T> ShareUniquePtr(std::unique_ptr<T, D>&& ptr) {
-  return ptr ? std::shared_ptr<T>(std::move(ptr)) : std::shared_ptr<T>();
-}
-
-// -----------------------------------------------------------------------------
-// Function Template: WeakenPtr()
-// -----------------------------------------------------------------------------
-//
-// Creates a weak pointer associated with a given shared pointer. The returned
-// value is a `std::weak_ptr` of deduced type.
-//
-// Example:
-//
-//    auto sp = std::make_shared<int>(10);
-//    auto wp = absl::WeakenPtr(sp);
-//    CHECK_EQ(sp.get(), wp.lock().get());
-//    sp.reset();
-//    CHECK(wp.lock() == nullptr);
-//
-template <typename T>
-std::weak_ptr<T> WeakenPtr(const std::shared_ptr<T>& ptr) {
-  return std::weak_ptr<T>(ptr);
-}
-
-namespace memory_internal {
-
-// ExtractOr<E, O, D>::type evaluates to E<O> if possible. Otherwise, D.
-template <template <typename> class Extract, typename Obj, typename Default,
-          typename>
-struct ExtractOr {
-  using type = Default;
-};
-
-template <template <typename> class Extract, typename Obj, typename Default>
-struct ExtractOr<Extract, Obj, Default, void_t<Extract<Obj>>> {
-  using type = Extract<Obj>;
-};
-
-template <template <typename> class Extract, typename Obj, typename Default>
-using ExtractOrT = typename ExtractOr<Extract, Obj, Default, void>::type;
-
-// Extractors for the features of allocators.
-template <typename T>
-using GetPointer = typename T::pointer;
-
-template <typename T>
-using GetConstPointer = typename T::const_pointer;
-
-template <typename T>
-using GetVoidPointer = typename T::void_pointer;
-
-template <typename T>
-using GetConstVoidPointer = typename T::const_void_pointer;
-
-template <typename T>
-using GetDifferenceType = typename T::difference_type;
-
-template <typename T>
-using GetSizeType = typename T::size_type;
-
-template <typename T>
-using GetPropagateOnContainerCopyAssignment =
-    typename T::propagate_on_container_copy_assignment;
-
-template <typename T>
-using GetPropagateOnContainerMoveAssignment =
-    typename T::propagate_on_container_move_assignment;
-
-template <typename T>
-using GetPropagateOnContainerSwap = typename T::propagate_on_container_swap;
-
-template <typename T>
-using GetIsAlwaysEqual = typename T::is_always_equal;
-
-template <typename T>
-struct GetFirstArg;
-
-template <template <typename...> class Class, typename T, typename... Args>
-struct GetFirstArg<Class<T, Args...>> {
-  using type = T;
-};
-
-template <typename Ptr, typename = void>
-struct ElementType {
-  using type = typename GetFirstArg<Ptr>::type;
-};
-
-template <typename T>
-struct ElementType<T, void_t<typename T::element_type>> {
-  using type = typename T::element_type;
-};
-
-template <typename T, typename U>
-struct RebindFirstArg;
-
-template <template <typename...> class Class, typename T, typename... Args,
-          typename U>
-struct RebindFirstArg<Class<T, Args...>, U> {
-  using type = Class<U, Args...>;
-};
-
-template <typename T, typename U, typename = void>
-struct RebindPtr {
-  using type = typename RebindFirstArg<T, U>::type;
-};
-
-template <typename T, typename U>
-struct RebindPtr<T, U, void_t<typename T::template rebind<U>>> {
-  using type = typename T::template rebind<U>;
-};
-
-template <typename T, typename U>
-constexpr bool HasRebindAlloc(...) {
-  return false;
-}
+    // -----------------------------------------------------------------------------
+    // Function Template: make_unique<T>()
+    // -----------------------------------------------------------------------------
+    //
+    // Creates a `std::unique_ptr<>`, while avoiding issues creating temporaries
+    // during the construction process. `absl::make_unique<>` also avoids redundant
+    // type declarations, by avoiding the need to explicitly use the `new` operator.
+    //
+    // This implementation of `absl::make_unique<>` is designed for C++11 code and
+    // will be replaced in C++14 by the equivalent `std::make_unique<>` abstraction.
+    // `absl::make_unique<>` is designed to be 100% compatible with
+    // `std::make_unique<>` so that the eventual migration will involve a simple
+    // rename operation.
+    //
+    // For more background on why `std::unique_ptr<T>(new T(a,b))` is problematic,
+    // see Herb Sutter's explanation on
+    // (Exception-Safe Function Calls)[https://herbsutter.com/gotw/_102/].
+    // (In general, reviewers should treat `new T(a,b)` with scrutiny.)
+    //
+    // Example usage:
+    //
+    //    auto p = make_unique<X>(args...);  // 'p'  is a std::unique_ptr<X>
+    //    auto pa = make_unique<X[]>(5);     // 'pa' is a std::unique_ptr<X[]>
+    //
+    // Three overloads of `absl::make_unique` are required:
+    //
+    //   - For non-array T:
+    //
+    //       Allocates a T with `new T(std::forward<Args> args...)`,
+    //       forwarding all `args` to T's constructor.
+    //       Returns a `std::unique_ptr<T>` owning that object.
+    //
+    //   - For an array of unknown bounds T[]:
+    //
+    //       `absl::make_unique<>` will allocate an array T of type U[] with
+    //       `new U[n]()` and return a `std::unique_ptr<U[]>` owning that array.
+    //
+    //       Note that 'U[n]()' is different from 'U[n]', and elements will be
+    //       value-initialized. Note as well that `std::unique_ptr` will perform its
+    //       own destruction of the array elements upon leaving scope, even though
+    //       the array [] does not have a default destructor.
+    //
+    //       NOTE: an array of unknown bounds T[] may still be (and often will be)
+    //       initialized to have a size, and will still use this overload. E.g:
+    //
+    //         auto my_array = absl::make_unique<int[]>(10);
+    //
+    //   - For an array of known bounds T[N]:
+    //
+    //       `absl::make_unique<>` is deleted (like with `std::make_unique<>`) as
+    //       this overload is not useful.
+    //
+    //       NOTE: an array of known bounds T[N] is not considered a useful
+    //       construction, and may cause undefined behavior in templates. E.g:
+    //
+    //         auto my_array = absl::make_unique<int[10]>();
+    //
+    //       In those cases, of course, you can still use the overload above and
+    //       simply initialize it to its desired size:
+    //
+    //         auto my_array = absl::make_unique<int[]>(10);
+
+    // `absl::make_unique` overload for non-array types.
+    template<typename T, typename... Args>
+    typename memory_internal::MakeUniqueResult<T>::scalar make_unique(
+        Args&&... args
+    )
+    {
+        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
 
-template <typename T, typename U>
-constexpr bool HasRebindAlloc(typename T::template rebind<U>::other*) {
-  return true;
-}
+    // `absl::make_unique` overload for an array T[] of unknown bounds.
+    // The array allocation needs to use the `new T[size]` form and cannot take
+    // element constructor arguments. The `std::unique_ptr` will manage destructing
+    // these array elements.
+    template<typename T>
+    typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n)
+    {
+        return std::unique_ptr<T>(new typename absl::remove_extent_t<T>[n]());
+    }
 
-template <typename T, typename U, bool = HasRebindAlloc<T, U>(nullptr)>
-struct RebindAlloc {
-  using type = typename RebindFirstArg<T, U>::type;
-};
+    // `absl::make_unique` overload for an array T[N] of known bounds.
+    // This construction will be rejected.
+    template<typename T, typename... Args>
+    typename memory_internal::MakeUniqueResult<T>::invalid make_unique(
+        Args&&... /* args */
+    ) = delete;
+#endif
 
-template <typename T, typename U>
-struct RebindAlloc<T, U, true> {
-  using type = typename T::template rebind<U>::other;
-};
+    // -----------------------------------------------------------------------------
+    // Function Template: RawPtr()
+    // -----------------------------------------------------------------------------
+    //
+    // Extracts the raw pointer from a pointer-like value `ptr`. `absl::RawPtr` is
+    // useful within templates that need to handle a complement of raw pointers,
+    // `std::nullptr_t`, and smart pointers.
+    template<typename T>
+    auto RawPtr(T&& ptr) -> decltype(std::addressof(*ptr))
+    {
+        // ptr is a forwarding reference to support Ts with non-const operators.
+        return (ptr != nullptr) ? std::addressof(*ptr) : nullptr;
+    }
+    inline std::nullptr_t RawPtr(std::nullptr_t)
+    {
+        return nullptr;
+    }
 
-}  // namespace memory_internal
+    // -----------------------------------------------------------------------------
+    // Function Template: ShareUniquePtr()
+    // -----------------------------------------------------------------------------
+    //
+    // Adopts a `std::unique_ptr` rvalue and returns a `std::shared_ptr` of deduced
+    // type. Ownership (if any) of the held value is transferred to the returned
+    // shared pointer.
+    //
+    // Example:
+    //
+    //     auto up = absl::make_unique<int>(10);
+    //     auto sp = absl::ShareUniquePtr(std::move(up));  // shared_ptr<int>
+    //     CHECK_EQ(*sp, 10);
+    //     CHECK(up == nullptr);
+    //
+    // Note that this conversion is correct even when T is an array type, and more
+    // generally it works for *any* deleter of the `unique_ptr` (single-object
+    // deleter, array deleter, or any custom deleter), since the deleter is adopted
+    // by the shared pointer as well. The deleter is copied (unless it is a
+    // reference).
+    //
+    // Implements the resolution of [LWG 2415](http://wg21.link/lwg2415), by which a
+    // null shared pointer does not attempt to call the deleter.
+    template<typename T, typename D>
+    std::shared_ptr<T> ShareUniquePtr(std::unique_ptr<T, D>&& ptr)
+    {
+        return ptr ? std::shared_ptr<T>(std::move(ptr)) : std::shared_ptr<T>();
+    }
 
-// -----------------------------------------------------------------------------
-// Class Template: pointer_traits
-// -----------------------------------------------------------------------------
-//
-// An implementation of C++11's std::pointer_traits.
-//
-// Provided for portability on toolchains that have a working C++11 compiler,
-// but the standard library is lacking in C++11 support. For example, some
-// version of the Android NDK.
-//
+    // -----------------------------------------------------------------------------
+    // Function Template: WeakenPtr()
+    // -----------------------------------------------------------------------------
+    //
+    // Creates a weak pointer associated with a given shared pointer. The returned
+    // value is a `std::weak_ptr` of deduced type.
+    //
+    // Example:
+    //
+    //    auto sp = std::make_shared<int>(10);
+    //    auto wp = absl::WeakenPtr(sp);
+    //    CHECK_EQ(sp.get(), wp.lock().get());
+    //    sp.reset();
+    //    CHECK(wp.lock() == nullptr);
+    //
+    template<typename T>
+    std::weak_ptr<T> WeakenPtr(const std::shared_ptr<T>& ptr)
+    {
+        return std::weak_ptr<T>(ptr);
+    }
 
-template <typename Ptr>
-struct pointer_traits {
-  using pointer = Ptr;
-
-  // element_type:
-  // Ptr::element_type if present. Otherwise T if Ptr is a template
-  // instantiation Template<T, Args...>
-  using element_type = typename memory_internal::ElementType<Ptr>::type;
-
-  // difference_type:
-  // Ptr::difference_type if present, otherwise std::ptrdiff_t
-  using difference_type =
-      memory_internal::ExtractOrT<memory_internal::GetDifferenceType, Ptr,
-                                  std::ptrdiff_t>;
-
-  // rebind:
-  // Ptr::rebind<U> if exists, otherwise Template<U, Args...> if Ptr is a
-  // template instantiation Template<T, Args...>
-  template <typename U>
-  using rebind = typename memory_internal::RebindPtr<Ptr, U>::type;
-
-  // pointer_to:
-  // Calls Ptr::pointer_to(r)
-  static pointer pointer_to(element_type& r) {  // NOLINT(runtime/references)
-    return Ptr::pointer_to(r);
-  }
-};
-
-// Specialization for T*.
-template <typename T>
-struct pointer_traits<T*> {
-  using pointer = T*;
-  using element_type = T;
-  using difference_type = std::ptrdiff_t;
-
-  template <typename U>
-  using rebind = U*;
-
-  // pointer_to:
-  // Calls std::addressof(r)
-  static pointer pointer_to(
-      element_type& r) noexcept {  // NOLINT(runtime/references)
-    return std::addressof(r);
-  }
-};
+    namespace memory_internal
+    {
+
+        // ExtractOr<E, O, D>::type evaluates to E<O> if possible. Otherwise, D.
+        template<template<typename> class Extract, typename Obj, typename Default, typename>
+        struct ExtractOr
+        {
+            using type = Default;
+        };
+
+        template<template<typename> class Extract, typename Obj, typename Default>
+        struct ExtractOr<Extract, Obj, Default, void_t<Extract<Obj>>>
+        {
+            using type = Extract<Obj>;
+        };
+
+        template<template<typename> class Extract, typename Obj, typename Default>
+        using ExtractOrT = typename ExtractOr<Extract, Obj, Default, void>::type;
+
+        // Extractors for the features of allocators.
+        template<typename T>
+        using GetPointer = typename T::pointer;
+
+        template<typename T>
+        using GetConstPointer = typename T::const_pointer;
+
+        template<typename T>
+        using GetVoidPointer = typename T::void_pointer;
+
+        template<typename T>
+        using GetConstVoidPointer = typename T::const_void_pointer;
+
+        template<typename T>
+        using GetDifferenceType = typename T::difference_type;
+
+        template<typename T>
+        using GetSizeType = typename T::size_type;
+
+        template<typename T>
+        using GetPropagateOnContainerCopyAssignment =
+            typename T::propagate_on_container_copy_assignment;
+
+        template<typename T>
+        using GetPropagateOnContainerMoveAssignment =
+            typename T::propagate_on_container_move_assignment;
+
+        template<typename T>
+        using GetPropagateOnContainerSwap = typename T::propagate_on_container_swap;
+
+        template<typename T>
+        using GetIsAlwaysEqual = typename T::is_always_equal;
+
+        template<typename T>
+        struct GetFirstArg;
+
+        template<template<typename...> class Class, typename T, typename... Args>
+        struct GetFirstArg<Class<T, Args...>>
+        {
+            using type = T;
+        };
+
+        template<typename Ptr, typename = void>
+        struct ElementType
+        {
+            using type = typename GetFirstArg<Ptr>::type;
+        };
+
+        template<typename T>
+        struct ElementType<T, void_t<typename T::element_type>>
+        {
+            using type = typename T::element_type;
+        };
+
+        template<typename T, typename U>
+        struct RebindFirstArg;
+
+        template<template<typename...> class Class, typename T, typename... Args, typename U>
+        struct RebindFirstArg<Class<T, Args...>, U>
+        {
+            using type = Class<U, Args...>;
+        };
+
+        template<typename T, typename U, typename = void>
+        struct RebindPtr
+        {
+            using type = typename RebindFirstArg<T, U>::type;
+        };
+
+        template<typename T, typename U>
+        struct RebindPtr<T, U, void_t<typename T::template rebind<U>>>
+        {
+            using type = typename T::template rebind<U>;
+        };
+
+        template<typename T, typename U>
+        constexpr bool HasRebindAlloc(...)
+        {
+            return false;
+        }
+
+        template<typename T, typename U>
+        constexpr bool HasRebindAlloc(typename T::template rebind<U>::other*)
+        {
+            return true;
+        }
+
+        template<typename T, typename U, bool = HasRebindAlloc<T, U>(nullptr)>
+        struct RebindAlloc
+        {
+            using type = typename RebindFirstArg<T, U>::type;
+        };
+
+        template<typename T, typename U>
+        struct RebindAlloc<T, U, true>
+        {
+            using type = typename T::template rebind<U>::other;
+        };
+
+    }  // namespace memory_internal
+
+    // -----------------------------------------------------------------------------
+    // Class Template: pointer_traits
+    // -----------------------------------------------------------------------------
+    //
+    // An implementation of C++11's std::pointer_traits.
+    //
+    // Provided for portability on toolchains that have a working C++11 compiler,
+    // but the standard library is lacking in C++11 support. For example, some
+    // version of the Android NDK.
+    //
+
+    template<typename Ptr>
+    struct pointer_traits
+    {
+        using pointer = Ptr;
+
+        // element_type:
+        // Ptr::element_type if present. Otherwise T if Ptr is a template
+        // instantiation Template<T, Args...>
+        using element_type = typename memory_internal::ElementType<Ptr>::type;
+
+        // difference_type:
+        // Ptr::difference_type if present, otherwise std::ptrdiff_t
+        using difference_type =
+            memory_internal::ExtractOrT<memory_internal::GetDifferenceType, Ptr, std::ptrdiff_t>;
+
+        // rebind:
+        // Ptr::rebind<U> if exists, otherwise Template<U, Args...> if Ptr is a
+        // template instantiation Template<T, Args...>
+        template<typename U>
+        using rebind = typename memory_internal::RebindPtr<Ptr, U>::type;
+
+        // pointer_to:
+        // Calls Ptr::pointer_to(r)
+        static pointer pointer_to(element_type& r)
+        {  // NOLINT(runtime/references)
+            return Ptr::pointer_to(r);
+        }
+    };
+
+    // Specialization for T*.
+    template<typename T>
+    struct pointer_traits<T*>
+    {
+        using pointer = T*;
+        using element_type = T;
+        using difference_type = std::ptrdiff_t;
+
+        template<typename U>
+        using rebind = U*;
+
+        // pointer_to:
+        // Calls std::addressof(r)
+        static pointer pointer_to(
+            element_type& r
+        ) noexcept
+        {  // NOLINT(runtime/references)
+            return std::addressof(r);
+        }
+    };
 
 // -----------------------------------------------------------------------------
 // Class Template: allocator_traits
@@ -421,279 +452,315 @@ struct pointer_traits<T*> {
 // A C++11 compatible implementation of C++17's std::allocator_traits.
 //
 #if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-using std::allocator_traits;
-#else  // __cplusplus >= 201703L
-template <typename Alloc>
-struct allocator_traits {
-  using allocator_type = Alloc;
-
-  // value_type:
-  // Alloc::value_type
-  using value_type = typename Alloc::value_type;
-
-  // pointer:
-  // Alloc::pointer if present, otherwise value_type*
-  using pointer = memory_internal::ExtractOrT<memory_internal::GetPointer,
-                                              Alloc, value_type*>;
-
-  // const_pointer:
-  // Alloc::const_pointer if present, otherwise
-  // absl::pointer_traits<pointer>::rebind<const value_type>
-  using const_pointer =
-      memory_internal::ExtractOrT<memory_internal::GetConstPointer, Alloc,
-                                  typename absl::pointer_traits<pointer>::
-                                      template rebind<const value_type>>;
-
-  // void_pointer:
-  // Alloc::void_pointer if present, otherwise
-  // absl::pointer_traits<pointer>::rebind<void>
-  using void_pointer = memory_internal::ExtractOrT<
-      memory_internal::GetVoidPointer, Alloc,
-      typename absl::pointer_traits<pointer>::template rebind<void>>;
-
-  // const_void_pointer:
-  // Alloc::const_void_pointer if present, otherwise
-  // absl::pointer_traits<pointer>::rebind<const void>
-  using const_void_pointer = memory_internal::ExtractOrT<
-      memory_internal::GetConstVoidPointer, Alloc,
-      typename absl::pointer_traits<pointer>::template rebind<const void>>;
-
-  // difference_type:
-  // Alloc::difference_type if present, otherwise
-  // absl::pointer_traits<pointer>::difference_type
-  using difference_type = memory_internal::ExtractOrT<
-      memory_internal::GetDifferenceType, Alloc,
-      typename absl::pointer_traits<pointer>::difference_type>;
-
-  // size_type:
-  // Alloc::size_type if present, otherwise
-  // std::make_unsigned<difference_type>::type
-  using size_type = memory_internal::ExtractOrT<
-      memory_internal::GetSizeType, Alloc,
-      typename std::make_unsigned<difference_type>::type>;
-
-  // propagate_on_container_copy_assignment:
-  // Alloc::propagate_on_container_copy_assignment if present, otherwise
-  // std::false_type
-  using propagate_on_container_copy_assignment = memory_internal::ExtractOrT<
-      memory_internal::GetPropagateOnContainerCopyAssignment, Alloc,
-      std::false_type>;
-
-  // propagate_on_container_move_assignment:
-  // Alloc::propagate_on_container_move_assignment if present, otherwise
-  // std::false_type
-  using propagate_on_container_move_assignment = memory_internal::ExtractOrT<
-      memory_internal::GetPropagateOnContainerMoveAssignment, Alloc,
-      std::false_type>;
-
-  // propagate_on_container_swap:
-  // Alloc::propagate_on_container_swap if present, otherwise std::false_type
-  using propagate_on_container_swap =
-      memory_internal::ExtractOrT<memory_internal::GetPropagateOnContainerSwap,
-                                  Alloc, std::false_type>;
-
-  // is_always_equal:
-  // Alloc::is_always_equal if present, otherwise std::is_empty<Alloc>::type
-  using is_always_equal =
-      memory_internal::ExtractOrT<memory_internal::GetIsAlwaysEqual, Alloc,
-                                  typename std::is_empty<Alloc>::type>;
-
-  // rebind_alloc:
-  // Alloc::rebind<T>::other if present, otherwise Alloc<T, Args> if this Alloc
-  // is Alloc<U, Args>
-  template <typename T>
-  using rebind_alloc = typename memory_internal::RebindAlloc<Alloc, T>::type;
-
-  // rebind_traits:
-  // absl::allocator_traits<rebind_alloc<T>>
-  template <typename T>
-  using rebind_traits = absl::allocator_traits<rebind_alloc<T>>;
-
-  // allocate(Alloc& a, size_type n):
-  // Calls a.allocate(n)
-  static pointer allocate(Alloc& a,  // NOLINT(runtime/references)
-                          size_type n) {
-    return a.allocate(n);
-  }
-
-  // allocate(Alloc& a, size_type n, const_void_pointer hint):
-  // Calls a.allocate(n, hint) if possible.
-  // If not possible, calls a.allocate(n)
-  static pointer allocate(Alloc& a, size_type n,  // NOLINT(runtime/references)
-                          const_void_pointer hint) {
-    return allocate_impl(0, a, n, hint);
-  }
-
-  // deallocate(Alloc& a, pointer p, size_type n):
-  // Calls a.deallocate(p, n)
-  static void deallocate(Alloc& a, pointer p,  // NOLINT(runtime/references)
-                         size_type n) {
-    a.deallocate(p, n);
-  }
-
-  // construct(Alloc& a, T* p, Args&&... args):
-  // Calls a.construct(p, std::forward<Args>(args)...) if possible.
-  // If not possible, calls
-  //   ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)
-  template <typename T, typename... Args>
-  static void construct(Alloc& a, T* p,  // NOLINT(runtime/references)
-                        Args&&... args) {
-    construct_impl(0, a, p, std::forward<Args>(args)...);
-  }
-
-  // destroy(Alloc& a, T* p):
-  // Calls a.destroy(p) if possible. If not possible, calls p->~T().
-  template <typename T>
-  static void destroy(Alloc& a, T* p) {  // NOLINT(runtime/references)
-    destroy_impl(0, a, p);
-  }
-
-  // max_size(const Alloc& a):
-  // Returns a.max_size() if possible. If not possible, returns
-  //   std::numeric_limits<size_type>::max() / sizeof(value_type)
-  static size_type max_size(const Alloc& a) { return max_size_impl(0, a); }
-
-  // select_on_container_copy_construction(const Alloc& a):
-  // Returns a.select_on_container_copy_construction() if possible.
-  // If not possible, returns a.
-  static Alloc select_on_container_copy_construction(const Alloc& a) {
-    return select_on_container_copy_construction_impl(0, a);
-  }
-
- private:
-  template <typename A>
-  static auto allocate_impl(int, A& a,  // NOLINT(runtime/references)
-                            size_type n, const_void_pointer hint)
-      -> decltype(a.allocate(n, hint)) {
-    return a.allocate(n, hint);
-  }
-  static pointer allocate_impl(char, Alloc& a,  // NOLINT(runtime/references)
-                               size_type n, const_void_pointer) {
-    return a.allocate(n);
-  }
-
-  template <typename A, typename... Args>
-  static auto construct_impl(int, A& a,  // NOLINT(runtime/references)
-                             Args&&... args)
-      -> decltype(a.construct(std::forward<Args>(args)...)) {
-    a.construct(std::forward<Args>(args)...);
-  }
-
-  template <typename T, typename... Args>
-  static void construct_impl(char, Alloc&, T* p, Args&&... args) {
-    ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
-  }
-
-  template <typename A, typename T>
-  static auto destroy_impl(int, A& a,  // NOLINT(runtime/references)
-                           T* p) -> decltype(a.destroy(p)) {
-    a.destroy(p);
-  }
-  template <typename T>
-  static void destroy_impl(char, Alloc&, T* p) {
-    p->~T();
-  }
-
-  template <typename A>
-  static auto max_size_impl(int, const A& a) -> decltype(a.max_size()) {
-    return a.max_size();
-  }
-  static size_type max_size_impl(char, const Alloc&) {
-    return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
-  }
-
-  template <typename A>
-  static auto select_on_container_copy_construction_impl(int, const A& a)
-      -> decltype(a.select_on_container_copy_construction()) {
-    return a.select_on_container_copy_construction();
-  }
-  static Alloc select_on_container_copy_construction_impl(char,
-                                                          const Alloc& a) {
-    return a;
-  }
-};
+    using std::allocator_traits;
+#else   // __cplusplus >= 201703L
+    template<typename Alloc>
+    struct allocator_traits
+    {
+        using allocator_type = Alloc;
+
+        // value_type:
+        // Alloc::value_type
+        using value_type = typename Alloc::value_type;
+
+        // pointer:
+        // Alloc::pointer if present, otherwise value_type*
+        using pointer = memory_internal::ExtractOrT<memory_internal::GetPointer, Alloc, value_type*>;
+
+        // const_pointer:
+        // Alloc::const_pointer if present, otherwise
+        // absl::pointer_traits<pointer>::rebind<const value_type>
+        using const_pointer =
+            memory_internal::ExtractOrT<memory_internal::GetConstPointer, Alloc, typename absl::pointer_traits<pointer>::template rebind<const value_type>>;
+
+        // void_pointer:
+        // Alloc::void_pointer if present, otherwise
+        // absl::pointer_traits<pointer>::rebind<void>
+        using void_pointer = memory_internal::ExtractOrT<
+            memory_internal::GetVoidPointer,
+            Alloc,
+            typename absl::pointer_traits<pointer>::template rebind<void>>;
+
+        // const_void_pointer:
+        // Alloc::const_void_pointer if present, otherwise
+        // absl::pointer_traits<pointer>::rebind<const void>
+        using const_void_pointer = memory_internal::ExtractOrT<
+            memory_internal::GetConstVoidPointer,
+            Alloc,
+            typename absl::pointer_traits<pointer>::template rebind<const void>>;
+
+        // difference_type:
+        // Alloc::difference_type if present, otherwise
+        // absl::pointer_traits<pointer>::difference_type
+        using difference_type = memory_internal::ExtractOrT<
+            memory_internal::GetDifferenceType,
+            Alloc,
+            typename absl::pointer_traits<pointer>::difference_type>;
+
+        // size_type:
+        // Alloc::size_type if present, otherwise
+        // std::make_unsigned<difference_type>::type
+        using size_type = memory_internal::ExtractOrT<
+            memory_internal::GetSizeType,
+            Alloc,
+            typename std::make_unsigned<difference_type>::type>;
+
+        // propagate_on_container_copy_assignment:
+        // Alloc::propagate_on_container_copy_assignment if present, otherwise
+        // std::false_type
+        using propagate_on_container_copy_assignment = memory_internal::ExtractOrT<
+            memory_internal::GetPropagateOnContainerCopyAssignment,
+            Alloc,
+            std::false_type>;
+
+        // propagate_on_container_move_assignment:
+        // Alloc::propagate_on_container_move_assignment if present, otherwise
+        // std::false_type
+        using propagate_on_container_move_assignment = memory_internal::ExtractOrT<
+            memory_internal::GetPropagateOnContainerMoveAssignment,
+            Alloc,
+            std::false_type>;
+
+        // propagate_on_container_swap:
+        // Alloc::propagate_on_container_swap if present, otherwise std::false_type
+        using propagate_on_container_swap =
+            memory_internal::ExtractOrT<memory_internal::GetPropagateOnContainerSwap, Alloc, std::false_type>;
+
+        // is_always_equal:
+        // Alloc::is_always_equal if present, otherwise std::is_empty<Alloc>::type
+        using is_always_equal =
+            memory_internal::ExtractOrT<memory_internal::GetIsAlwaysEqual, Alloc, typename std::is_empty<Alloc>::type>;
+
+        // rebind_alloc:
+        // Alloc::rebind<T>::other if present, otherwise Alloc<T, Args> if this Alloc
+        // is Alloc<U, Args>
+        template<typename T>
+        using rebind_alloc = typename memory_internal::RebindAlloc<Alloc, T>::type;
+
+        // rebind_traits:
+        // absl::allocator_traits<rebind_alloc<T>>
+        template<typename T>
+        using rebind_traits = absl::allocator_traits<rebind_alloc<T>>;
+
+        // allocate(Alloc& a, size_type n):
+        // Calls a.allocate(n)
+        static pointer allocate(Alloc& a,  // NOLINT(runtime/references)
+                                size_type n)
+        {
+            return a.allocate(n);
+        }
+
+        // allocate(Alloc& a, size_type n, const_void_pointer hint):
+        // Calls a.allocate(n, hint) if possible.
+        // If not possible, calls a.allocate(n)
+        static pointer allocate(Alloc& a, size_type n,  // NOLINT(runtime/references)
+                                const_void_pointer hint)
+        {
+            return allocate_impl(0, a, n, hint);
+        }
+
+        // deallocate(Alloc& a, pointer p, size_type n):
+        // Calls a.deallocate(p, n)
+        static void deallocate(Alloc& a, pointer p,  // NOLINT(runtime/references)
+                               size_type n)
+        {
+            a.deallocate(p, n);
+        }
+
+        // construct(Alloc& a, T* p, Args&&... args):
+        // Calls a.construct(p, std::forward<Args>(args)...) if possible.
+        // If not possible, calls
+        //   ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)
+        template<typename T, typename... Args>
+        static void construct(Alloc& a, T* p,  // NOLINT(runtime/references)
+                              Args&&... args)
+        {
+            construct_impl(0, a, p, std::forward<Args>(args)...);
+        }
+
+        // destroy(Alloc& a, T* p):
+        // Calls a.destroy(p) if possible. If not possible, calls p->~T().
+        template<typename T>
+        static void destroy(Alloc& a, T* p)
+        {  // NOLINT(runtime/references)
+            destroy_impl(0, a, p);
+        }
+
+        // max_size(const Alloc& a):
+        // Returns a.max_size() if possible. If not possible, returns
+        //   std::numeric_limits<size_type>::max() / sizeof(value_type)
+        static size_type max_size(const Alloc& a)
+        {
+            return max_size_impl(0, a);
+        }
+
+        // select_on_container_copy_construction(const Alloc& a):
+        // Returns a.select_on_container_copy_construction() if possible.
+        // If not possible, returns a.
+        static Alloc select_on_container_copy_construction(const Alloc& a)
+        {
+            return select_on_container_copy_construction_impl(0, a);
+        }
+
+    private:
+        template<typename A>
+        static auto allocate_impl(int, A& a,  // NOLINT(runtime/references)
+                                  size_type n,
+                                  const_void_pointer hint)
+            -> decltype(a.allocate(n, hint))
+        {
+            return a.allocate(n, hint);
+        }
+        static pointer allocate_impl(char, Alloc& a,  // NOLINT(runtime/references)
+                                     size_type n,
+                                     const_void_pointer)
+        {
+            return a.allocate(n);
+        }
+
+        template<typename A, typename... Args>
+        static auto construct_impl(int, A& a,  // NOLINT(runtime/references)
+                                   Args&&... args)
+            -> decltype(a.construct(std::forward<Args>(args)...))
+        {
+            a.construct(std::forward<Args>(args)...);
+        }
+
+        template<typename T, typename... Args>
+        static void construct_impl(char, Alloc&, T* p, Args&&... args)
+        {
+            ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+        }
+
+        template<typename A, typename T>
+        static auto destroy_impl(int, A& a,  // NOLINT(runtime/references)
+                                 T* p) -> decltype(a.destroy(p))
+        {
+            a.destroy(p);
+        }
+        template<typename T>
+        static void destroy_impl(char, Alloc&, T* p)
+        {
+            p->~T();
+        }
+
+        template<typename A>
+        static auto max_size_impl(int, const A& a) -> decltype(a.max_size())
+        {
+            return a.max_size();
+        }
+        static size_type max_size_impl(char, const Alloc&)
+        {
+            return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
+        }
+
+        template<typename A>
+        static auto select_on_container_copy_construction_impl(int, const A& a)
+            -> decltype(a.select_on_container_copy_construction())
+        {
+            return a.select_on_container_copy_construction();
+        }
+        static Alloc select_on_container_copy_construction_impl(char, const Alloc& a)
+        {
+            return a;
+        }
+    };
 #endif  // __cplusplus >= 201703L
 
-namespace memory_internal {
-
-// This template alias transforms Alloc::is_nothrow into a metafunction with
-// Alloc as a parameter so it can be used with ExtractOrT<>.
-template <typename Alloc>
-using GetIsNothrow = typename Alloc::is_nothrow;
-
-}  // namespace memory_internal
-
-// ABSL_ALLOCATOR_NOTHROW is a build time configuration macro for user to
-// specify whether the default allocation function can throw or never throws.
-// If the allocation function never throws, user should define it to a non-zero
-// value (e.g. via `-DABSL_ALLOCATOR_NOTHROW`).
-// If the allocation function can throw, user should leave it undefined or
-// define it to zero.
-//
-// allocator_is_nothrow<Alloc> is a traits class that derives from
-// Alloc::is_nothrow if present, otherwise std::false_type. It's specialized
-// for Alloc = std::allocator<T> for any type T according to the state of
-// ABSL_ALLOCATOR_NOTHROW.
-//
-// default_allocator_is_nothrow is a class that derives from std::true_type
-// when the default allocator (global operator new) never throws, and
-// std::false_type when it can throw. It is a convenience shorthand for writing
-// allocator_is_nothrow<std::allocator<T>> (T can be any type).
-// NOTE: allocator_is_nothrow<std::allocator<T>> is guaranteed to derive from
-// the same type for all T, because users should specialize neither
-// allocator_is_nothrow nor std::allocator.
-template <typename Alloc>
-struct allocator_is_nothrow
-    : memory_internal::ExtractOrT<memory_internal::GetIsNothrow, Alloc,
-                                  std::false_type> {};
+    namespace memory_internal
+    {
+
+        // This template alias transforms Alloc::is_nothrow into a metafunction with
+        // Alloc as a parameter so it can be used with ExtractOrT<>.
+        template<typename Alloc>
+        using GetIsNothrow = typename Alloc::is_nothrow;
+
+    }  // namespace memory_internal
+
+    // ABSL_ALLOCATOR_NOTHROW is a build time configuration macro for user to
+    // specify whether the default allocation function can throw or never throws.
+    // If the allocation function never throws, user should define it to a non-zero
+    // value (e.g. via `-DABSL_ALLOCATOR_NOTHROW`).
+    // If the allocation function can throw, user should leave it undefined or
+    // define it to zero.
+    //
+    // allocator_is_nothrow<Alloc> is a traits class that derives from
+    // Alloc::is_nothrow if present, otherwise std::false_type. It's specialized
+    // for Alloc = std::allocator<T> for any type T according to the state of
+    // ABSL_ALLOCATOR_NOTHROW.
+    //
+    // default_allocator_is_nothrow is a class that derives from std::true_type
+    // when the default allocator (global operator new) never throws, and
+    // std::false_type when it can throw. It is a convenience shorthand for writing
+    // allocator_is_nothrow<std::allocator<T>> (T can be any type).
+    // NOTE: allocator_is_nothrow<std::allocator<T>> is guaranteed to derive from
+    // the same type for all T, because users should specialize neither
+    // allocator_is_nothrow nor std::allocator.
+    template<typename Alloc>
+    struct allocator_is_nothrow : memory_internal::ExtractOrT<memory_internal::GetIsNothrow, Alloc, std::false_type>
+    {
+    };
 
 #if defined(ABSL_ALLOCATOR_NOTHROW) && ABSL_ALLOCATOR_NOTHROW
-template <typename T>
-struct allocator_is_nothrow<std::allocator<T>> : std::true_type {};
-struct default_allocator_is_nothrow : std::true_type {};
+    template<typename T>
+    struct allocator_is_nothrow<std::allocator<T>> : std::true_type
+    {
+    };
+    struct default_allocator_is_nothrow : std::true_type
+    {
+    };
 #else
-struct default_allocator_is_nothrow : std::false_type {};
+    struct default_allocator_is_nothrow : std::false_type
+    {
+    };
 #endif
 
-namespace memory_internal {
-template <typename Allocator, typename Iterator, typename... Args>
-void ConstructRange(Allocator& alloc, Iterator first, Iterator last,
-                    const Args&... args) {
-  for (Iterator cur = first; cur != last; ++cur) {
-    ABSL_INTERNAL_TRY {
-      std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
-                                                  args...);
-    }
-    ABSL_INTERNAL_CATCH_ANY {
-      while (cur != first) {
-        --cur;
-        std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
-      }
-      ABSL_INTERNAL_RETHROW;
-    }
-  }
-}
-
-template <typename Allocator, typename Iterator, typename InputIterator>
-void CopyRange(Allocator& alloc, Iterator destination, InputIterator first,
-               InputIterator last) {
-  for (Iterator cur = destination; first != last;
-       static_cast<void>(++cur), static_cast<void>(++first)) {
-    ABSL_INTERNAL_TRY {
-      std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
-                                                  *first);
-    }
-    ABSL_INTERNAL_CATCH_ANY {
-      while (cur != destination) {
-        --cur;
-        std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
-      }
-      ABSL_INTERNAL_RETHROW;
-    }
-  }
-}
-}  // namespace memory_internal
-ABSL_NAMESPACE_END
+    namespace memory_internal
+    {
+        template<typename Allocator, typename Iterator, typename... Args>
+        void ConstructRange(Allocator& alloc, Iterator first, Iterator last, const Args&... args)
+        {
+            for (Iterator cur = first; cur != last; ++cur)
+            {
+                ABSL_INTERNAL_TRY
+                {
+                    std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur), args...);
+                }
+                ABSL_INTERNAL_CATCH_ANY
+                {
+                    while (cur != first)
+                    {
+                        --cur;
+                        std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
+                    }
+                    ABSL_INTERNAL_RETHROW;
+                }
+            }
+        }
+
+        template<typename Allocator, typename Iterator, typename InputIterator>
+        void CopyRange(Allocator& alloc, Iterator destination, InputIterator first, InputIterator last)
+        {
+            for (Iterator cur = destination; first != last;
+                 static_cast<void>(++cur), static_cast<void>(++first))
+            {
+                ABSL_INTERNAL_TRY
+                {
+                    std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur), *first);
+                }
+                ABSL_INTERNAL_CATCH_ANY
+                {
+                    while (cur != destination)
+                    {
+                        --cur;
+                        std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
+                    }
+                    ABSL_INTERNAL_RETHROW;
+                }
+            }
+        }
+    }  // namespace memory_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_MEMORY_MEMORY_H_
diff --git a/CAPI/cpp/grpc/include/absl/meta/type_traits.h b/CAPI/cpp/grpc/include/absl/meta/type_traits.h
index d886cb3..be3b5e5 100644
--- a/CAPI/cpp/grpc/include/absl/meta/type_traits.h
+++ b/CAPI/cpp/grpc/include/absl/meta/type_traits.h
@@ -55,18 +55,20 @@
 #define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT alignof(std::max_align_t)
 #endif  // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// Defined and documented later on in this file.
-template <typename T>
-struct is_trivially_destructible;
+    // Defined and documented later on in this file.
+    template<typename T>
+    struct is_trivially_destructible;
 
-// Defined and documented later on in this file.
-template <typename T>
-struct is_trivially_move_assignable;
+    // Defined and documented later on in this file.
+    template<typename T>
+    struct is_trivially_move_assignable;
 
-namespace type_traits_internal {
+    namespace type_traits_internal
+    {
 
 // Silence MSVC warnings about the destructor being defined as deleted.
 #if defined(_MSC_VER) && !defined(__GNUC__)
@@ -74,590 +76,601 @@ namespace type_traits_internal {
 #pragma warning(disable : 4624)
 #endif  // defined(_MSC_VER) && !defined(__GNUC__)
 
-template <class T>
-union SingleMemberUnion {
-  T t;
-};
+        template<class T>
+        union SingleMemberUnion
+        {
+            T t;
+        };
 
 // Restore the state of the destructor warning that was silenced above.
 #if defined(_MSC_VER) && !defined(__GNUC__)
 #pragma warning(pop)
 #endif  // defined(_MSC_VER) && !defined(__GNUC__)
 
-template <class T>
-struct IsTriviallyMoveConstructibleObject
-    : std::integral_constant<
-          bool, std::is_move_constructible<
-                    type_traits_internal::SingleMemberUnion<T>>::value &&
-                    absl::is_trivially_destructible<T>::value> {};
-
-template <class T>
-struct IsTriviallyCopyConstructibleObject
-    : std::integral_constant<
-          bool, std::is_copy_constructible<
-                    type_traits_internal::SingleMemberUnion<T>>::value &&
-                    absl::is_trivially_destructible<T>::value> {};
-
-template <class T>
-struct IsTriviallyMoveAssignableReference : std::false_type {};
-
-template <class T>
-struct IsTriviallyMoveAssignableReference<T&>
-    : absl::is_trivially_move_assignable<T>::type {};
-
-template <class T>
-struct IsTriviallyMoveAssignableReference<T&&>
-    : absl::is_trivially_move_assignable<T>::type {};
-
-template <typename... Ts>
-struct VoidTImpl {
-  using type = void;
-};
-
-// This trick to retrieve a default alignment is necessary for our
-// implementation of aligned_storage_t to be consistent with any implementation
-// of std::aligned_storage.
-template <size_t Len, typename T = std::aligned_storage<Len>>
-struct default_alignment_of_aligned_storage;
-
-template <size_t Len, size_t Align>
-struct default_alignment_of_aligned_storage<Len,
-                                            std::aligned_storage<Len, Align>> {
-  static constexpr size_t value = Align;
-};
-
-////////////////////////////////
-// Library Fundamentals V2 TS //
-////////////////////////////////
-
-// NOTE: The `is_detected` family of templates here differ from the library
-// fundamentals specification in that for library fundamentals, `Op<Args...>` is
-// evaluated as soon as the type `is_detected<Op, Args...>` undergoes
-// substitution, regardless of whether or not the `::value` is accessed. That
-// is inconsistent with all other standard traits and prevents lazy evaluation
-// in larger contexts (such as if the `is_detected` check is a trailing argument
-// of a `conjunction`. This implementation opts to instead be lazy in the same
-// way that the standard traits are (this "defect" of the detection idiom
-// specifications has been reported).
-
-template <class Enabler, template <class...> class Op, class... Args>
-struct is_detected_impl {
-  using type = std::false_type;
-};
-
-template <template <class...> class Op, class... Args>
-struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...> {
-  using type = std::true_type;
-};
-
-template <template <class...> class Op, class... Args>
-struct is_detected : is_detected_impl<void, Op, Args...>::type {};
-
-template <class Enabler, class To, template <class...> class Op, class... Args>
-struct is_detected_convertible_impl {
-  using type = std::false_type;
-};
-
-template <class To, template <class...> class Op, class... Args>
-struct is_detected_convertible_impl<
-    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
-    To, Op, Args...> {
-  using type = std::true_type;
-};
-
-template <class To, template <class...> class Op, class... Args>
-struct is_detected_convertible
-    : is_detected_convertible_impl<void, To, Op, Args...>::type {};
-
-template <typename T>
-using IsCopyAssignableImpl =
-    decltype(std::declval<T&>() = std::declval<const T&>());
-
-template <typename T>
-using IsMoveAssignableImpl = decltype(std::declval<T&>() = std::declval<T&&>());
-
-}  // namespace type_traits_internal
+        template<class T>
+        struct IsTriviallyMoveConstructibleObject : std::integral_constant<bool, std::is_move_constructible<type_traits_internal::SingleMemberUnion<T>>::value && absl::is_trivially_destructible<T>::value>
+        {
+        };
+
+        template<class T>
+        struct IsTriviallyCopyConstructibleObject : std::integral_constant<bool, std::is_copy_constructible<type_traits_internal::SingleMemberUnion<T>>::value && absl::is_trivially_destructible<T>::value>
+        {
+        };
+
+        template<class T>
+        struct IsTriviallyMoveAssignableReference : std::false_type
+        {
+        };
+
+        template<class T>
+        struct IsTriviallyMoveAssignableReference<T&> : absl::is_trivially_move_assignable<T>::type
+        {
+        };
+
+        template<class T>
+        struct IsTriviallyMoveAssignableReference<T&&> : absl::is_trivially_move_assignable<T>::type
+        {
+        };
+
+        template<typename... Ts>
+        struct VoidTImpl
+        {
+            using type = void;
+        };
+
+        // This trick to retrieve a default alignment is necessary for our
+        // implementation of aligned_storage_t to be consistent with any implementation
+        // of std::aligned_storage.
+        template<size_t Len, typename T = std::aligned_storage<Len>>
+        struct default_alignment_of_aligned_storage;
+
+        template<size_t Len, size_t Align>
+        struct default_alignment_of_aligned_storage<Len, std::aligned_storage<Len, Align>>
+        {
+            static constexpr size_t value = Align;
+        };
+
+        ////////////////////////////////
+        // Library Fundamentals V2 TS //
+        ////////////////////////////////
+
+        // NOTE: The `is_detected` family of templates here differ from the library
+        // fundamentals specification in that for library fundamentals, `Op<Args...>` is
+        // evaluated as soon as the type `is_detected<Op, Args...>` undergoes
+        // substitution, regardless of whether or not the `::value` is accessed. That
+        // is inconsistent with all other standard traits and prevents lazy evaluation
+        // in larger contexts (such as if the `is_detected` check is a trailing argument
+        // of a `conjunction`. This implementation opts to instead be lazy in the same
+        // way that the standard traits are (this "defect" of the detection idiom
+        // specifications has been reported).
+
+        template<class Enabler, template<class...> class Op, class... Args>
+        struct is_detected_impl
+        {
+            using type = std::false_type;
+        };
+
+        template<template<class...> class Op, class... Args>
+        struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...>
+        {
+            using type = std::true_type;
+        };
+
+        template<template<class...> class Op, class... Args>
+        struct is_detected : is_detected_impl<void, Op, Args...>::type
+        {
+        };
+
+        template<class Enabler, class To, template<class...> class Op, class... Args>
+        struct is_detected_convertible_impl
+        {
+            using type = std::false_type;
+        };
+
+        template<class To, template<class...> class Op, class... Args>
+        struct is_detected_convertible_impl<
+            typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
+            To,
+            Op,
+            Args...>
+        {
+            using type = std::true_type;
+        };
+
+        template<class To, template<class...> class Op, class... Args>
+        struct is_detected_convertible : is_detected_convertible_impl<void, To, Op, Args...>::type
+        {
+        };
+
+        template<typename T>
+        using IsCopyAssignableImpl =
+            decltype(std::declval<T&>() = std::declval<const T&>());
+
+        template<typename T>
+        using IsMoveAssignableImpl = decltype(std::declval<T&>() = std::declval<T&&>());
+
+    }  // namespace type_traits_internal
 
 // MSVC 19.20 has a regression that causes our workarounds to fail, but their
 // std forms now appear to be compliant.
 #if defined(_MSC_VER) && !defined(__clang__) && (_MSC_VER >= 1920)
 
-template <typename T>
-using is_copy_assignable = std::is_copy_assignable<T>;
+    template<typename T>
+    using is_copy_assignable = std::is_copy_assignable<T>;
 
-template <typename T>
-using is_move_assignable = std::is_move_assignable<T>;
+    template<typename T>
+    using is_move_assignable = std::is_move_assignable<T>;
 
 #else
 
-template <typename T>
-struct is_copy_assignable : type_traits_internal::is_detected<
-                                type_traits_internal::IsCopyAssignableImpl, T> {
-};
+    template<typename T>
+    struct is_copy_assignable : type_traits_internal::is_detected<type_traits_internal::IsCopyAssignableImpl, T>
+    {
+    };
 
-template <typename T>
-struct is_move_assignable : type_traits_internal::is_detected<
-                                type_traits_internal::IsMoveAssignableImpl, T> {
-};
+    template<typename T>
+    struct is_move_assignable : type_traits_internal::is_detected<type_traits_internal::IsMoveAssignableImpl, T>
+    {
+    };
 
 #endif
 
-// void_t()
-//
-// Ignores the type of any its arguments and returns `void`. In general, this
-// metafunction allows you to create a general case that maps to `void` while
-// allowing specializations that map to specific types.
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::void_t` metafunction.
-//
-// NOTE: `absl::void_t` does not use the standard-specified implementation so
-// that it can remain compatible with gcc < 5.1. This can introduce slightly
-// different behavior, such as when ordering partial specializations.
-template <typename... Ts>
-using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
-
-// conjunction
-//
-// Performs a compile-time logical AND operation on the passed types (which
-// must have  `::value` members convertible to `bool`. Short-circuits if it
-// encounters any `false` members (and does not compare the `::value` members
-// of any remaining arguments).
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::conjunction` metafunction.
-template <typename... Ts>
-struct conjunction : std::true_type {};
-
-template <typename T, typename... Ts>
-struct conjunction<T, Ts...>
-    : std::conditional<T::value, conjunction<Ts...>, T>::type {};
-
-template <typename T>
-struct conjunction<T> : T {};
-
-// disjunction
-//
-// Performs a compile-time logical OR operation on the passed types (which
-// must have  `::value` members convertible to `bool`. Short-circuits if it
-// encounters any `true` members (and does not compare the `::value` members
-// of any remaining arguments).
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::disjunction` metafunction.
-template <typename... Ts>
-struct disjunction : std::false_type {};
-
-template <typename T, typename... Ts>
-struct disjunction<T, Ts...> :
-      std::conditional<T::value, T, disjunction<Ts...>>::type {};
-
-template <typename T>
-struct disjunction<T> : T {};
-
-// negation
-//
-// Performs a compile-time logical NOT operation on the passed type (which
-// must have  `::value` members convertible to `bool`.
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::negation` metafunction.
-template <typename T>
-struct negation : std::integral_constant<bool, !T::value> {};
-
-// is_function()
-//
-// Determines whether the passed type `T` is a function type.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_function()` metafunction for platforms that have incomplete C++11
-// support (such as libstdc++ 4.x).
-//
-// This metafunction works because appending `const` to a type does nothing to
-// function types and reference types (and forms a const-qualified type
-// otherwise).
-template <typename T>
-struct is_function
-    : std::integral_constant<
-          bool, !(std::is_reference<T>::value ||
-                  std::is_const<typename std::add_const<T>::type>::value)> {};
-
-// is_trivially_destructible()
-//
-// Determines whether the passed type `T` is trivially destructible.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_trivially_destructible()` metafunction for platforms that have
-// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
-// fully support C++11, we check whether this yields the same result as the std
-// implementation.
-//
-// NOTE: the extensions (__has_trivial_xxx) are implemented in gcc (version >=
-// 4.3) and clang. Since we are supporting libstdc++ > 4.7, they should always
-// be present. These  extensions are documented at
-// https://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html#Type-Traits.
-template <typename T>
-struct is_trivially_destructible
-    : std::integral_constant<bool, __has_trivial_destructor(T) &&
-                                   std::is_destructible<T>::value> {
+    // void_t()
+    //
+    // Ignores the type of any its arguments and returns `void`. In general, this
+    // metafunction allows you to create a general case that maps to `void` while
+    // allowing specializations that map to specific types.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++17
+    // `std::void_t` metafunction.
+    //
+    // NOTE: `absl::void_t` does not use the standard-specified implementation so
+    // that it can remain compatible with gcc < 5.1. This can introduce slightly
+    // different behavior, such as when ordering partial specializations.
+    template<typename... Ts>
+    using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
+
+    // conjunction
+    //
+    // Performs a compile-time logical AND operation on the passed types (which
+    // must have  `::value` members convertible to `bool`. Short-circuits if it
+    // encounters any `false` members (and does not compare the `::value` members
+    // of any remaining arguments).
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++17
+    // `std::conjunction` metafunction.
+    template<typename... Ts>
+    struct conjunction : std::true_type
+    {
+    };
+
+    template<typename T, typename... Ts>
+    struct conjunction<T, Ts...> : std::conditional<T::value, conjunction<Ts...>, T>::type
+    {
+    };
+
+    template<typename T>
+    struct conjunction<T> : T
+    {
+    };
+
+    // disjunction
+    //
+    // Performs a compile-time logical OR operation on the passed types (which
+    // must have  `::value` members convertible to `bool`. Short-circuits if it
+    // encounters any `true` members (and does not compare the `::value` members
+    // of any remaining arguments).
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++17
+    // `std::disjunction` metafunction.
+    template<typename... Ts>
+    struct disjunction : std::false_type
+    {
+    };
+
+    template<typename T, typename... Ts>
+    struct disjunction<T, Ts...> :
+        std::conditional<T::value, T, disjunction<Ts...>>::type
+    {
+    };
+
+    template<typename T>
+    struct disjunction<T> : T
+    {
+    };
+
+    // negation
+    //
+    // Performs a compile-time logical NOT operation on the passed type (which
+    // must have  `::value` members convertible to `bool`.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++17
+    // `std::negation` metafunction.
+    template<typename T>
+    struct negation : std::integral_constant<bool, !T::value>
+    {
+    };
+
+    // is_function()
+    //
+    // Determines whether the passed type `T` is a function type.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++11
+    // `std::is_function()` metafunction for platforms that have incomplete C++11
+    // support (such as libstdc++ 4.x).
+    //
+    // This metafunction works because appending `const` to a type does nothing to
+    // function types and reference types (and forms a const-qualified type
+    // otherwise).
+    template<typename T>
+    struct is_function : std::integral_constant<bool, !(std::is_reference<T>::value || std::is_const<typename std::add_const<T>::type>::value)>
+    {
+    };
+
+    // is_trivially_destructible()
+    //
+    // Determines whether the passed type `T` is trivially destructible.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++11
+    // `std::is_trivially_destructible()` metafunction for platforms that have
+    // incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+    // fully support C++11, we check whether this yields the same result as the std
+    // implementation.
+    //
+    // NOTE: the extensions (__has_trivial_xxx) are implemented in gcc (version >=
+    // 4.3) and clang. Since we are supporting libstdc++ > 4.7, they should always
+    // be present. These  extensions are documented at
+    // https://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html#Type-Traits.
+    template<typename T>
+    struct is_trivially_destructible : std::integral_constant<bool, __has_trivial_destructor(T) && std::is_destructible<T>::value>
+    {
 #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
- private:
-  static constexpr bool compliant = std::is_trivially_destructible<T>::value ==
-                                    is_trivially_destructible::value;
-  static_assert(compliant || std::is_trivially_destructible<T>::value,
-                "Not compliant with std::is_trivially_destructible; "
-                "Standard: false, Implementation: true");
-  static_assert(compliant || !std::is_trivially_destructible<T>::value,
-                "Not compliant with std::is_trivially_destructible; "
-                "Standard: true, Implementation: false");
-#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
-};
 
-// is_trivially_default_constructible()
-//
-// Determines whether the passed type `T` is trivially default constructible.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_trivially_default_constructible()` metafunction for platforms that
-// have incomplete C++11 support (such as libstdc++ 4.x). On any platforms that
-// do fully support C++11, we check whether this yields the same result as the
-// std implementation.
-//
-// NOTE: according to the C++ standard, Section: 20.15.4.3 [meta.unary.prop]
-// "The predicate condition for a template specialization is_constructible<T,
-// Args...> shall be satisfied if and only if the following variable
-// definition would be well-formed for some invented variable t:
-//
-// T t(declval<Args>()...);
-//
-// is_trivially_constructible<T, Args...> additionally requires that the
-// variable definition does not call any operation that is not trivial.
-// For the purposes of this check, the call to std::declval is considered
-// trivial."
-//
-// Notes from https://en.cppreference.com/w/cpp/types/is_constructible:
-// In many implementations, is_nothrow_constructible also checks if the
-// destructor throws because it is effectively noexcept(T(arg)). Same
-// applies to is_trivially_constructible, which, in these implementations, also
-// requires that the destructor is trivial.
-// GCC bug 51452: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452
-// LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116.
-//
-// "T obj();" need to be well-formed and not call any nontrivial operation.
-// Nontrivially destructible types will cause the expression to be nontrivial.
-template <typename T>
-struct is_trivially_default_constructible
-    : std::integral_constant<bool, __has_trivial_constructor(T) &&
-                                   std::is_default_constructible<T>::value &&
-                                   is_trivially_destructible<T>::value> {
-#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
-    !defined(                                            \
-        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
- private:
-  static constexpr bool compliant =
-      std::is_trivially_default_constructible<T>::value ==
-      is_trivially_default_constructible::value;
-  static_assert(compliant || std::is_trivially_default_constructible<T>::value,
-                "Not compliant with std::is_trivially_default_constructible; "
-                "Standard: false, Implementation: true");
-  static_assert(compliant || !std::is_trivially_default_constructible<T>::value,
-                "Not compliant with std::is_trivially_default_constructible; "
-                "Standard: true, Implementation: false");
+    private:
+        static constexpr bool compliant = std::is_trivially_destructible<T>::value ==
+                                          is_trivially_destructible::value;
+        static_assert(compliant || std::is_trivially_destructible<T>::value, "Not compliant with std::is_trivially_destructible; "
+                                                                             "Standard: false, Implementation: true");
+        static_assert(compliant || !std::is_trivially_destructible<T>::value, "Not compliant with std::is_trivially_destructible; "
+                                                                              "Standard: true, Implementation: false");
+#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+    };
+
+    // is_trivially_default_constructible()
+    //
+    // Determines whether the passed type `T` is trivially default constructible.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++11
+    // `std::is_trivially_default_constructible()` metafunction for platforms that
+    // have incomplete C++11 support (such as libstdc++ 4.x). On any platforms that
+    // do fully support C++11, we check whether this yields the same result as the
+    // std implementation.
+    //
+    // NOTE: according to the C++ standard, Section: 20.15.4.3 [meta.unary.prop]
+    // "The predicate condition for a template specialization is_constructible<T,
+    // Args...> shall be satisfied if and only if the following variable
+    // definition would be well-formed for some invented variable t:
+    //
+    // T t(declval<Args>()...);
+    //
+    // is_trivially_constructible<T, Args...> additionally requires that the
+    // variable definition does not call any operation that is not trivial.
+    // For the purposes of this check, the call to std::declval is considered
+    // trivial."
+    //
+    // Notes from https://en.cppreference.com/w/cpp/types/is_constructible:
+    // In many implementations, is_nothrow_constructible also checks if the
+    // destructor throws because it is effectively noexcept(T(arg)). Same
+    // applies to is_trivially_constructible, which, in these implementations, also
+    // requires that the destructor is trivial.
+    // GCC bug 51452: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452
+    // LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116.
+    //
+    // "T obj();" need to be well-formed and not call any nontrivial operation.
+    // Nontrivially destructible types will cause the expression to be nontrivial.
+    template<typename T>
+    struct is_trivially_default_constructible : std::integral_constant<bool, __has_trivial_constructor(T) && std::is_default_constructible<T>::value && is_trivially_destructible<T>::value>
+    {
+#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) &&                  \
+    !defined(                                                             \
+        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION \
+    )
+
+    private:
+        static constexpr bool compliant =
+            std::is_trivially_default_constructible<T>::value ==
+            is_trivially_default_constructible::value;
+        static_assert(compliant || std::is_trivially_default_constructible<T>::value, "Not compliant with std::is_trivially_default_constructible; "
+                                                                                      "Standard: false, Implementation: true");
+        static_assert(compliant || !std::is_trivially_default_constructible<T>::value, "Not compliant with std::is_trivially_default_constructible; "
+                                                                                       "Standard: true, Implementation: false");
 #endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
-};
-
-// is_trivially_move_constructible()
-//
-// Determines whether the passed type `T` is trivially move constructible.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_trivially_move_constructible()` metafunction for platforms that have
-// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
-// fully support C++11, we check whether this yields the same result as the std
-// implementation.
-//
-// NOTE: `T obj(declval<T>());` needs to be well-formed and not call any
-// nontrivial operation.  Nontrivially destructible types will cause the
-// expression to be nontrivial.
-template <typename T>
-struct is_trivially_move_constructible
-    : std::conditional<
-          std::is_object<T>::value && !std::is_array<T>::value,
-          type_traits_internal::IsTriviallyMoveConstructibleObject<T>,
-          std::is_reference<T>>::type::type {
-#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
-    !defined(                                            \
-        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
- private:
-  static constexpr bool compliant =
-      std::is_trivially_move_constructible<T>::value ==
-      is_trivially_move_constructible::value;
-  static_assert(compliant || std::is_trivially_move_constructible<T>::value,
-                "Not compliant with std::is_trivially_move_constructible; "
-                "Standard: false, Implementation: true");
-  static_assert(compliant || !std::is_trivially_move_constructible<T>::value,
-                "Not compliant with std::is_trivially_move_constructible; "
-                "Standard: true, Implementation: false");
+    };
+
+    // is_trivially_move_constructible()
+    //
+    // Determines whether the passed type `T` is trivially move constructible.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++11
+    // `std::is_trivially_move_constructible()` metafunction for platforms that have
+    // incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+    // fully support C++11, we check whether this yields the same result as the std
+    // implementation.
+    //
+    // NOTE: `T obj(declval<T>());` needs to be well-formed and not call any
+    // nontrivial operation.  Nontrivially destructible types will cause the
+    // expression to be nontrivial.
+    template<typename T>
+    struct is_trivially_move_constructible : std::conditional<std::is_object<T>::value && !std::is_array<T>::value, type_traits_internal::IsTriviallyMoveConstructibleObject<T>, std::is_reference<T>>::type::type
+    {
+#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) &&                  \
+    !defined(                                                             \
+        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION \
+    )
+
+    private:
+        static constexpr bool compliant =
+            std::is_trivially_move_constructible<T>::value ==
+            is_trivially_move_constructible::value;
+        static_assert(compliant || std::is_trivially_move_constructible<T>::value, "Not compliant with std::is_trivially_move_constructible; "
+                                                                                   "Standard: false, Implementation: true");
+        static_assert(compliant || !std::is_trivially_move_constructible<T>::value, "Not compliant with std::is_trivially_move_constructible; "
+                                                                                    "Standard: true, Implementation: false");
 #endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
-};
-
-// is_trivially_copy_constructible()
-//
-// Determines whether the passed type `T` is trivially copy constructible.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_trivially_copy_constructible()` metafunction for platforms that have
-// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
-// fully support C++11, we check whether this yields the same result as the std
-// implementation.
-//
-// NOTE: `T obj(declval<const T&>());` needs to be well-formed and not call any
-// nontrivial operation.  Nontrivially destructible types will cause the
-// expression to be nontrivial.
-template <typename T>
-struct is_trivially_copy_constructible
-    : std::conditional<
-          std::is_object<T>::value && !std::is_array<T>::value,
-          type_traits_internal::IsTriviallyCopyConstructibleObject<T>,
-          std::is_lvalue_reference<T>>::type::type {
-#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
-    !defined(                                            \
-        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
- private:
-  static constexpr bool compliant =
-      std::is_trivially_copy_constructible<T>::value ==
-      is_trivially_copy_constructible::value;
-  static_assert(compliant || std::is_trivially_copy_constructible<T>::value,
-                "Not compliant with std::is_trivially_copy_constructible; "
-                "Standard: false, Implementation: true");
-  static_assert(compliant || !std::is_trivially_copy_constructible<T>::value,
-                "Not compliant with std::is_trivially_copy_constructible; "
-                "Standard: true, Implementation: false");
+    };
+
+    // is_trivially_copy_constructible()
+    //
+    // Determines whether the passed type `T` is trivially copy constructible.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++11
+    // `std::is_trivially_copy_constructible()` metafunction for platforms that have
+    // incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+    // fully support C++11, we check whether this yields the same result as the std
+    // implementation.
+    //
+    // NOTE: `T obj(declval<const T&>());` needs to be well-formed and not call any
+    // nontrivial operation.  Nontrivially destructible types will cause the
+    // expression to be nontrivial.
+    template<typename T>
+    struct is_trivially_copy_constructible : std::conditional<std::is_object<T>::value && !std::is_array<T>::value, type_traits_internal::IsTriviallyCopyConstructibleObject<T>, std::is_lvalue_reference<T>>::type::type
+    {
+#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) &&                  \
+    !defined(                                                             \
+        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION \
+    )
+
+    private:
+        static constexpr bool compliant =
+            std::is_trivially_copy_constructible<T>::value ==
+            is_trivially_copy_constructible::value;
+        static_assert(compliant || std::is_trivially_copy_constructible<T>::value, "Not compliant with std::is_trivially_copy_constructible; "
+                                                                                   "Standard: false, Implementation: true");
+        static_assert(compliant || !std::is_trivially_copy_constructible<T>::value, "Not compliant with std::is_trivially_copy_constructible; "
+                                                                                    "Standard: true, Implementation: false");
 #endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
-};
-
-// is_trivially_move_assignable()
-//
-// Determines whether the passed type `T` is trivially move assignable.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_trivially_move_assignable()` metafunction for platforms that have
-// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
-// fully support C++11, we check whether this yields the same result as the std
-// implementation.
-//
-// NOTE: `is_assignable<T, U>::value` is `true` if the expression
-// `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
-// operand. `is_trivially_assignable<T, U>` requires the assignment to call no
-// operation that is not trivial. `is_trivially_copy_assignable<T>` is simply
-// `is_trivially_assignable<T&, T>`.
-template <typename T>
-struct is_trivially_move_assignable
-    : std::conditional<
-          std::is_object<T>::value && !std::is_array<T>::value &&
-              std::is_move_assignable<T>::value,
-          std::is_move_assignable<type_traits_internal::SingleMemberUnion<T>>,
-          type_traits_internal::IsTriviallyMoveAssignableReference<T>>::type::
-          type {
+    };
+
+    // is_trivially_move_assignable()
+    //
+    // Determines whether the passed type `T` is trivially move assignable.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++11
+    // `std::is_trivially_move_assignable()` metafunction for platforms that have
+    // incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+    // fully support C++11, we check whether this yields the same result as the std
+    // implementation.
+    //
+    // NOTE: `is_assignable<T, U>::value` is `true` if the expression
+    // `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
+    // operand. `is_trivially_assignable<T, U>` requires the assignment to call no
+    // operation that is not trivial. `is_trivially_copy_assignable<T>` is simply
+    // `is_trivially_assignable<T&, T>`.
+    template<typename T>
+    struct is_trivially_move_assignable : std::conditional<std::is_object<T>::value && !std::is_array<T>::value && std::is_move_assignable<T>::value, std::is_move_assignable<type_traits_internal::SingleMemberUnion<T>>, type_traits_internal::IsTriviallyMoveAssignableReference<T>>::type::type
+    {
 #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
- private:
-  static constexpr bool compliant =
-      std::is_trivially_move_assignable<T>::value ==
-      is_trivially_move_assignable::value;
-  static_assert(compliant || std::is_trivially_move_assignable<T>::value,
-                "Not compliant with std::is_trivially_move_assignable; "
-                "Standard: false, Implementation: true");
-  static_assert(compliant || !std::is_trivially_move_assignable<T>::value,
-                "Not compliant with std::is_trivially_move_assignable; "
-                "Standard: true, Implementation: false");
-#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
-};
 
-// is_trivially_copy_assignable()
-//
-// Determines whether the passed type `T` is trivially copy assignable.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_trivially_copy_assignable()` metafunction for platforms that have
-// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
-// fully support C++11, we check whether this yields the same result as the std
-// implementation.
-//
-// NOTE: `is_assignable<T, U>::value` is `true` if the expression
-// `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
-// operand. `is_trivially_assignable<T, U>` requires the assignment to call no
-// operation that is not trivial. `is_trivially_copy_assignable<T>` is simply
-// `is_trivially_assignable<T&, const T&>`.
-template <typename T>
-struct is_trivially_copy_assignable
-    : std::integral_constant<
-          bool, __has_trivial_assign(typename std::remove_reference<T>::type) &&
-                    absl::is_copy_assignable<T>::value> {
+    private:
+        static constexpr bool compliant =
+            std::is_trivially_move_assignable<T>::value ==
+            is_trivially_move_assignable::value;
+        static_assert(compliant || std::is_trivially_move_assignable<T>::value, "Not compliant with std::is_trivially_move_assignable; "
+                                                                                "Standard: false, Implementation: true");
+        static_assert(compliant || !std::is_trivially_move_assignable<T>::value, "Not compliant with std::is_trivially_move_assignable; "
+                                                                                 "Standard: true, Implementation: false");
+#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+    };
+
+    // is_trivially_copy_assignable()
+    //
+    // Determines whether the passed type `T` is trivially copy assignable.
+    //
+    // This metafunction is designed to be a drop-in replacement for the C++11
+    // `std::is_trivially_copy_assignable()` metafunction for platforms that have
+    // incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+    // fully support C++11, we check whether this yields the same result as the std
+    // implementation.
+    //
+    // NOTE: `is_assignable<T, U>::value` is `true` if the expression
+    // `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
+    // operand. `is_trivially_assignable<T, U>` requires the assignment to call no
+    // operation that is not trivial. `is_trivially_copy_assignable<T>` is simply
+    // `is_trivially_assignable<T&, const T&>`.
+    template<typename T>
+    struct is_trivially_copy_assignable : std::integral_constant<bool, __has_trivial_assign(typename std::remove_reference<T>::type) && absl::is_copy_assignable<T>::value>
+    {
 #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
- private:
-  static constexpr bool compliant =
-      std::is_trivially_copy_assignable<T>::value ==
-      is_trivially_copy_assignable::value;
-  static_assert(compliant || std::is_trivially_copy_assignable<T>::value,
-                "Not compliant with std::is_trivially_copy_assignable; "
-                "Standard: false, Implementation: true");
-  static_assert(compliant || !std::is_trivially_copy_assignable<T>::value,
-                "Not compliant with std::is_trivially_copy_assignable; "
-                "Standard: true, Implementation: false");
+
+    private:
+        static constexpr bool compliant =
+            std::is_trivially_copy_assignable<T>::value ==
+            is_trivially_copy_assignable::value;
+        static_assert(compliant || std::is_trivially_copy_assignable<T>::value, "Not compliant with std::is_trivially_copy_assignable; "
+                                                                                "Standard: false, Implementation: true");
+        static_assert(compliant || !std::is_trivially_copy_assignable<T>::value, "Not compliant with std::is_trivially_copy_assignable; "
+                                                                                 "Standard: true, Implementation: false");
 #endif  // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
-};
+    };
 
 #if defined(__cpp_lib_remove_cvref) && __cpp_lib_remove_cvref >= 201711L
-template <typename T>
-using remove_cvref = std::remove_cvref<T>;
+    template<typename T>
+    using remove_cvref = std::remove_cvref<T>;
 
-template <typename T>
-using remove_cvref_t = typename std::remove_cvref<T>::type;
+    template<typename T>
+    using remove_cvref_t = typename std::remove_cvref<T>::type;
 #else
-// remove_cvref()
-//
-// C++11 compatible implementation of std::remove_cvref which was added in
-// C++20.
-template <typename T>
-struct remove_cvref {
-  using type =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-};
-
-template <typename T>
-using remove_cvref_t = typename remove_cvref<T>::type;
+    // remove_cvref()
+    //
+    // C++11 compatible implementation of std::remove_cvref which was added in
+    // C++20.
+    template<typename T>
+    struct remove_cvref
+    {
+        using type =
+            typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+    };
+
+    template<typename T>
+    using remove_cvref_t = typename remove_cvref<T>::type;
 #endif
 
-namespace type_traits_internal {
-// is_trivially_copyable()
-//
-// Determines whether the passed type `T` is trivially copyable.
-//
-// This metafunction is designed to be a drop-in replacement for the C++11
-// `std::is_trivially_copyable()` metafunction for platforms that have
-// incomplete C++11 support (such as libstdc++ 4.x). We use the C++17 definition
-// of TriviallyCopyable.
-//
-// NOTE: `is_trivially_copyable<T>::value` is `true` if all of T's copy/move
-// constructors/assignment operators are trivial or deleted, T has at least
-// one non-deleted copy/move constructor/assignment operator, and T is trivially
-// destructible. Arrays of trivially copyable types are trivially copyable.
-//
-// We expose this metafunction only for internal use within absl.
-template <typename T>
-class is_trivially_copyable_impl {
-  using ExtentsRemoved = typename std::remove_all_extents<T>::type;
-  static constexpr bool kIsCopyOrMoveConstructible =
-      std::is_copy_constructible<ExtentsRemoved>::value ||
-      std::is_move_constructible<ExtentsRemoved>::value;
-  static constexpr bool kIsCopyOrMoveAssignable =
-      absl::is_copy_assignable<ExtentsRemoved>::value ||
-      absl::is_move_assignable<ExtentsRemoved>::value;
-
- public:
-  static constexpr bool kValue =
-      (__has_trivial_copy(ExtentsRemoved) || !kIsCopyOrMoveConstructible) &&
-      (__has_trivial_assign(ExtentsRemoved) || !kIsCopyOrMoveAssignable) &&
-      (kIsCopyOrMoveConstructible || kIsCopyOrMoveAssignable) &&
-      is_trivially_destructible<ExtentsRemoved>::value &&
-      // We need to check for this explicitly because otherwise we'll say
-      // references are trivial copyable when compiled by MSVC.
-      !std::is_reference<ExtentsRemoved>::value;
-};
-
-template <typename T>
-struct is_trivially_copyable
-    : std::integral_constant<
-          bool, type_traits_internal::is_trivially_copyable_impl<T>::kValue> {};
-}  // namespace type_traits_internal
-
-// -----------------------------------------------------------------------------
-// C++14 "_t" trait aliases
-// -----------------------------------------------------------------------------
-
-template <typename T>
-using remove_cv_t = typename std::remove_cv<T>::type;
-
-template <typename T>
-using remove_const_t = typename std::remove_const<T>::type;
-
-template <typename T>
-using remove_volatile_t = typename std::remove_volatile<T>::type;
-
-template <typename T>
-using add_cv_t = typename std::add_cv<T>::type;
-
-template <typename T>
-using add_const_t = typename std::add_const<T>::type;
-
-template <typename T>
-using add_volatile_t = typename std::add_volatile<T>::type;
-
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-
-template <typename T>
-using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
-
-template <typename T>
-using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
+    namespace type_traits_internal
+    {
+        // is_trivially_copyable()
+        //
+        // Determines whether the passed type `T` is trivially copyable.
+        //
+        // This metafunction is designed to be a drop-in replacement for the C++11
+        // `std::is_trivially_copyable()` metafunction for platforms that have
+        // incomplete C++11 support (such as libstdc++ 4.x). We use the C++17 definition
+        // of TriviallyCopyable.
+        //
+        // NOTE: `is_trivially_copyable<T>::value` is `true` if all of T's copy/move
+        // constructors/assignment operators are trivial or deleted, T has at least
+        // one non-deleted copy/move constructor/assignment operator, and T is trivially
+        // destructible. Arrays of trivially copyable types are trivially copyable.
+        //
+        // We expose this metafunction only for internal use within absl.
+        template<typename T>
+        class is_trivially_copyable_impl
+        {
+            using ExtentsRemoved = typename std::remove_all_extents<T>::type;
+            static constexpr bool kIsCopyOrMoveConstructible =
+                std::is_copy_constructible<ExtentsRemoved>::value ||
+                std::is_move_constructible<ExtentsRemoved>::value;
+            static constexpr bool kIsCopyOrMoveAssignable =
+                absl::is_copy_assignable<ExtentsRemoved>::value ||
+                absl::is_move_assignable<ExtentsRemoved>::value;
+
+        public:
+            static constexpr bool kValue =
+                (__has_trivial_copy(ExtentsRemoved) || !kIsCopyOrMoveConstructible) &&
+                (__has_trivial_assign(ExtentsRemoved) || !kIsCopyOrMoveAssignable) &&
+                (kIsCopyOrMoveConstructible || kIsCopyOrMoveAssignable) &&
+                is_trivially_destructible<ExtentsRemoved>::value &&
+                // We need to check for this explicitly because otherwise we'll say
+                // references are trivial copyable when compiled by MSVC.
+                !std::is_reference<ExtentsRemoved>::value;
+        };
+
+        template<typename T>
+        struct is_trivially_copyable : std::integral_constant<bool, type_traits_internal::is_trivially_copyable_impl<T>::kValue>
+        {
+        };
+    }  // namespace type_traits_internal
+
+    // -----------------------------------------------------------------------------
+    // C++14 "_t" trait aliases
+    // -----------------------------------------------------------------------------
+
+    template<typename T>
+    using remove_cv_t = typename std::remove_cv<T>::type;
+
+    template<typename T>
+    using remove_const_t = typename std::remove_const<T>::type;
+
+    template<typename T>
+    using remove_volatile_t = typename std::remove_volatile<T>::type;
+
+    template<typename T>
+    using add_cv_t = typename std::add_cv<T>::type;
+
+    template<typename T>
+    using add_const_t = typename std::add_const<T>::type;
+
+    template<typename T>
+    using add_volatile_t = typename std::add_volatile<T>::type;
+
+    template<typename T>
+    using remove_reference_t = typename std::remove_reference<T>::type;
+
+    template<typename T>
+    using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
+
+    template<typename T>
+    using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
+
+    template<typename T>
+    using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+    template<typename T>
+    using add_pointer_t = typename std::add_pointer<T>::type;
+
+    template<typename T>
+    using make_signed_t = typename std::make_signed<T>::type;
+
+    template<typename T>
+    using make_unsigned_t = typename std::make_unsigned<T>::type;
+
+    template<typename T>
+    using remove_extent_t = typename std::remove_extent<T>::type;
+
+    template<typename T>
+    using remove_all_extents_t = typename std::remove_all_extents<T>::type;
+
+    template<size_t Len, size_t Align = type_traits_internal::default_alignment_of_aligned_storage<Len>::value>
+    using aligned_storage_t = typename std::aligned_storage<Len, Align>::type;
+
+    template<typename T>
+    using decay_t = typename std::decay<T>::type;
+
+    template<bool B, typename T = void>
+    using enable_if_t = typename std::enable_if<B, T>::type;
+
+    template<bool B, typename T, typename F>
+    using conditional_t = typename std::conditional<B, T, F>::type;
+
+    template<typename... T>
+    using common_type_t = typename std::common_type<T...>::type;
 
-template <typename T>
-using remove_pointer_t = typename std::remove_pointer<T>::type;
+    template<typename T>
+    using underlying_type_t = typename std::underlying_type<T>::type;
 
-template <typename T>
-using add_pointer_t = typename std::add_pointer<T>::type;
-
-template <typename T>
-using make_signed_t = typename std::make_signed<T>::type;
-
-template <typename T>
-using make_unsigned_t = typename std::make_unsigned<T>::type;
-
-template <typename T>
-using remove_extent_t = typename std::remove_extent<T>::type;
-
-template <typename T>
-using remove_all_extents_t = typename std::remove_all_extents<T>::type;
-
-template <size_t Len, size_t Align = type_traits_internal::
-                          default_alignment_of_aligned_storage<Len>::value>
-using aligned_storage_t = typename std::aligned_storage<Len, Align>::type;
-
-template <typename T>
-using decay_t = typename std::decay<T>::type;
-
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-template <bool B, typename T, typename F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-
-template <typename... T>
-using common_type_t = typename std::common_type<T...>::type;
-
-template <typename T>
-using underlying_type_t = typename std::underlying_type<T>::type;
-
-
-namespace type_traits_internal {
+    namespace type_traits_internal
+    {
 
 #if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \
     (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-// std::result_of is deprecated (C++17) or removed (C++20)
-template<typename> struct result_of;
-template<typename F, typename... Args>
-struct result_of<F(Args...)> : std::invoke_result<F, Args...> {};
+        // std::result_of is deprecated (C++17) or removed (C++20)
+        template<typename>
+        struct result_of;
+        template<typename F, typename... Args>
+        struct result_of<F(Args...)> : std::invoke_result<F, Args...>
+        {
+        };
 #else
-template<typename F> using result_of = std::result_of<F>;
+        template<typename F>
+        using result_of = std::result_of<F>;
 #endif
 
-}  // namespace type_traits_internal
+    }  // namespace type_traits_internal
 
-template<typename F>
-using result_of_t = typename type_traits_internal::result_of<F>::type;
+    template<typename F>
+    using result_of_t = typename type_traits_internal::result_of<F>::type;
 
-namespace type_traits_internal {
+    namespace type_traits_internal
+    {
 // In MSVC we can't probe std::hash or stdext::hash because it triggers a
 // static_assert instead of failing substitution. Libc++ prior to 4.0
 // also used a static_assert.
@@ -670,128 +683,142 @@ namespace type_traits_internal {
 #endif
 
 #if !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-template <typename Key, typename = size_t>
-struct IsHashable : std::true_type {};
+        template<typename Key, typename = size_t>
+        struct IsHashable : std::true_type
+        {
+        };
 #else   // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-template <typename Key, typename = void>
-struct IsHashable : std::false_type {};
-
-template <typename Key>
-struct IsHashable<
-    Key,
-    absl::enable_if_t<std::is_convertible<
-        decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
-        std::size_t>::value>> : std::true_type {};
+        template<typename Key, typename = void>
+        struct IsHashable : std::false_type
+        {
+        };
+
+        template<typename Key>
+        struct IsHashable<
+            Key,
+            absl::enable_if_t<std::is_convertible<
+                decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
+                std::size_t>::value>> : std::true_type
+        {
+        };
 #endif  // !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
 
-struct AssertHashEnabledHelper {
- private:
-  static void Sink(...) {}
-  struct NAT {};
-
-  template <class Key>
-  static auto GetReturnType(int)
-      -> decltype(std::declval<std::hash<Key>>()(std::declval<Key const&>()));
-  template <class Key>
-  static NAT GetReturnType(...);
-
-  template <class Key>
-  static std::nullptr_t DoIt() {
-    static_assert(IsHashable<Key>::value,
-                  "std::hash<Key> does not provide a call operator");
-    static_assert(
-        std::is_default_constructible<std::hash<Key>>::value,
-        "std::hash<Key> must be default constructible when it is enabled");
-    static_assert(
-        std::is_copy_constructible<std::hash<Key>>::value,
-        "std::hash<Key> must be copy constructible when it is enabled");
-    static_assert(absl::is_copy_assignable<std::hash<Key>>::value,
-                  "std::hash<Key> must be copy assignable when it is enabled");
-    // is_destructible is unchecked as it's implied by each of the
-    // is_constructible checks.
-    using ReturnType = decltype(GetReturnType<Key>(0));
-    static_assert(std::is_same<ReturnType, NAT>::value ||
-                      std::is_same<ReturnType, size_t>::value,
-                  "std::hash<Key> must return size_t");
-    return nullptr;
-  }
-
-  template <class... Ts>
-  friend void AssertHashEnabled();
-};
-
-template <class... Ts>
-inline void AssertHashEnabled() {
-  using Helper = AssertHashEnabledHelper;
-  Helper::Sink(Helper::DoIt<Ts>()...);
-}
-
-}  // namespace type_traits_internal
-
-// An internal namespace that is required to implement the C++17 swap traits.
-// It is not further nested in type_traits_internal to avoid long symbol names.
-namespace swap_internal {
-
-// Necessary for the traits.
-using std::swap;
-
-// This declaration prevents global `swap` and `absl::swap` overloads from being
-// considered unless ADL picks them up.
-void swap();
-
-template <class T>
-using IsSwappableImpl = decltype(swap(std::declval<T&>(), std::declval<T&>()));
-
-// NOTE: This dance with the default template parameter is for MSVC.
-template <class T,
-          class IsNoexcept = std::integral_constant<
-              bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>>
-using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type;
-
-// IsSwappable
-//
-// Determines whether the standard swap idiom is a valid expression for
-// arguments of type `T`.
-template <class T>
-struct IsSwappable
-    : absl::type_traits_internal::is_detected<IsSwappableImpl, T> {};
-
-// IsNothrowSwappable
-//
-// Determines whether the standard swap idiom is a valid expression for
-// arguments of type `T` and is noexcept.
-template <class T>
-struct IsNothrowSwappable
-    : absl::type_traits_internal::is_detected<IsNothrowSwappableImpl, T> {};
-
-// Swap()
-//
-// Performs the swap idiom from a namespace where valid candidates may only be
-// found in `std` or via ADL.
-template <class T, absl::enable_if_t<IsSwappable<T>::value, int> = 0>
-void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value) {
-  swap(lhs, rhs);
-}
-
-// StdSwapIsUnconstrained
-//
-// Some standard library implementations are broken in that they do not
-// constrain `std::swap`. This will effectively tell us if we are dealing with
-// one of those implementations.
-using StdSwapIsUnconstrained = IsSwappable<void()>;
-
-}  // namespace swap_internal
-
-namespace type_traits_internal {
-
-// Make the swap-related traits/function accessible from this namespace.
-using swap_internal::IsNothrowSwappable;
-using swap_internal::IsSwappable;
-using swap_internal::Swap;
-using swap_internal::StdSwapIsUnconstrained;
-
-}  // namespace type_traits_internal
-ABSL_NAMESPACE_END
+        struct AssertHashEnabledHelper
+        {
+        private:
+            static void Sink(...)
+            {
+            }
+            struct NAT
+            {
+            };
+
+            template<class Key>
+            static auto GetReturnType(int)
+                -> decltype(std::declval<std::hash<Key>>()(std::declval<Key const&>()));
+            template<class Key>
+            static NAT GetReturnType(...);
+
+            template<class Key>
+            static std::nullptr_t DoIt()
+            {
+                static_assert(IsHashable<Key>::value, "std::hash<Key> does not provide a call operator");
+                static_assert(
+                    std::is_default_constructible<std::hash<Key>>::value,
+                    "std::hash<Key> must be default constructible when it is enabled"
+                );
+                static_assert(
+                    std::is_copy_constructible<std::hash<Key>>::value,
+                    "std::hash<Key> must be copy constructible when it is enabled"
+                );
+                static_assert(absl::is_copy_assignable<std::hash<Key>>::value, "std::hash<Key> must be copy assignable when it is enabled");
+                // is_destructible is unchecked as it's implied by each of the
+                // is_constructible checks.
+                using ReturnType = decltype(GetReturnType<Key>(0));
+                static_assert(std::is_same<ReturnType, NAT>::value || std::is_same<ReturnType, size_t>::value, "std::hash<Key> must return size_t");
+                return nullptr;
+            }
+
+            template<class... Ts>
+            friend void AssertHashEnabled();
+        };
+
+        template<class... Ts>
+        inline void AssertHashEnabled()
+        {
+            using Helper = AssertHashEnabledHelper;
+            Helper::Sink(Helper::DoIt<Ts>()...);
+        }
+
+    }  // namespace type_traits_internal
+
+    // An internal namespace that is required to implement the C++17 swap traits.
+    // It is not further nested in type_traits_internal to avoid long symbol names.
+    namespace swap_internal
+    {
+
+        // Necessary for the traits.
+        using std::swap;
+
+        // This declaration prevents global `swap` and `absl::swap` overloads from being
+        // considered unless ADL picks them up.
+        void swap();
+
+        template<class T>
+        using IsSwappableImpl = decltype(swap(std::declval<T&>(), std::declval<T&>()));
+
+        // NOTE: This dance with the default template parameter is for MSVC.
+        template<class T, class IsNoexcept = std::integral_constant<bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>>
+        using IsNothrowSwappableImpl = typename std::enable_if<IsNoexcept::value>::type;
+
+        // IsSwappable
+        //
+        // Determines whether the standard swap idiom is a valid expression for
+        // arguments of type `T`.
+        template<class T>
+        struct IsSwappable : absl::type_traits_internal::is_detected<IsSwappableImpl, T>
+        {
+        };
+
+        // IsNothrowSwappable
+        //
+        // Determines whether the standard swap idiom is a valid expression for
+        // arguments of type `T` and is noexcept.
+        template<class T>
+        struct IsNothrowSwappable : absl::type_traits_internal::is_detected<IsNothrowSwappableImpl, T>
+        {
+        };
+
+        // Swap()
+        //
+        // Performs the swap idiom from a namespace where valid candidates may only be
+        // found in `std` or via ADL.
+        template<class T, absl::enable_if_t<IsSwappable<T>::value, int> = 0>
+        void Swap(T& lhs, T& rhs) noexcept(IsNothrowSwappable<T>::value)
+        {
+            swap(lhs, rhs);
+        }
+
+        // StdSwapIsUnconstrained
+        //
+        // Some standard library implementations are broken in that they do not
+        // constrain `std::swap`. This will effectively tell us if we are dealing with
+        // one of those implementations.
+        using StdSwapIsUnconstrained = IsSwappable<void()>;
+
+    }  // namespace swap_internal
+
+    namespace type_traits_internal
+    {
+
+        // Make the swap-related traits/function accessible from this namespace.
+        using swap_internal::IsNothrowSwappable;
+        using swap_internal::IsSwappable;
+        using swap_internal::StdSwapIsUnconstrained;
+        using swap_internal::Swap;
+
+    }  // namespace type_traits_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_META_TYPE_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/numeric/bits.h b/CAPI/cpp/grpc/include/absl/numeric/bits.h
index 628cdf5..3b1bf36 100644
--- a/CAPI/cpp/grpc/include/absl/numeric/bits.h
+++ b/CAPI/cpp/grpc/include/absl/numeric/bits.h
@@ -47,132 +47,143 @@
 #include "absl/base/config.h"
 #include "absl/numeric/internal/bits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
 #if !(defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L)
-// rotating
-template <class T>
-ABSL_MUST_USE_RESULT constexpr
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    rotl(T x, int s) noexcept {
-  return numeric_internal::RotateLeft(x, s);
-}
-
-template <class T>
-ABSL_MUST_USE_RESULT constexpr
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    rotr(T x, int s) noexcept {
-  return numeric_internal::RotateRight(x, s);
-}
-
-// Counting functions
-//
-// While these functions are typically constexpr, on some platforms, they may
-// not be marked as constexpr due to constraints of the compiler/available
-// intrinsics.
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    countl_zero(T x) noexcept {
-  return numeric_internal::CountLeadingZeroes(x);
-}
-
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    countl_one(T x) noexcept {
-  // Avoid integer promotion to a wider type
-  return countl_zero(static_cast<T>(~x));
-}
-
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CTZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    countr_zero(T x) noexcept {
-  return numeric_internal::CountTrailingZeroes(x);
-}
-
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CTZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    countr_one(T x) noexcept {
-  // Avoid integer promotion to a wider type
-  return countr_zero(static_cast<T>(~x));
-}
-
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    popcount(T x) noexcept {
-  return numeric_internal::Popcount(x);
-}
+    // rotating
+    template<class T>
+    ABSL_MUST_USE_RESULT constexpr
+        typename std::enable_if<std::is_unsigned<T>::value, T>::type
+        rotl(T x, int s) noexcept
+    {
+        return numeric_internal::RotateLeft(x, s);
+    }
+
+    template<class T>
+    ABSL_MUST_USE_RESULT constexpr
+        typename std::enable_if<std::is_unsigned<T>::value, T>::type
+        rotr(T x, int s) noexcept
+    {
+        return numeric_internal::RotateRight(x, s);
+    }
+
+    // Counting functions
+    //
+    // While these functions are typically constexpr, on some platforms, they may
+    // not be marked as constexpr due to constraints of the compiler/available
+    // intrinsics.
+    template<class T>
+    ABSL_INTERNAL_CONSTEXPR_CLZ inline
+        typename std::enable_if<std::is_unsigned<T>::value, int>::type
+        countl_zero(T x) noexcept
+    {
+        return numeric_internal::CountLeadingZeroes(x);
+    }
+
+    template<class T>
+    ABSL_INTERNAL_CONSTEXPR_CLZ inline
+        typename std::enable_if<std::is_unsigned<T>::value, int>::type
+        countl_one(T x) noexcept
+    {
+        // Avoid integer promotion to a wider type
+        return countl_zero(static_cast<T>(~x));
+    }
+
+    template<class T>
+    ABSL_INTERNAL_CONSTEXPR_CTZ inline
+        typename std::enable_if<std::is_unsigned<T>::value, int>::type
+        countr_zero(T x) noexcept
+    {
+        return numeric_internal::CountTrailingZeroes(x);
+    }
+
+    template<class T>
+    ABSL_INTERNAL_CONSTEXPR_CTZ inline
+        typename std::enable_if<std::is_unsigned<T>::value, int>::type
+        countr_one(T x) noexcept
+    {
+        // Avoid integer promotion to a wider type
+        return countr_zero(static_cast<T>(~x));
+    }
+
+    template<class T>
+    ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline
+        typename std::enable_if<std::is_unsigned<T>::value, int>::type
+        popcount(T x) noexcept
+    {
+        return numeric_internal::Popcount(x);
+    }
 #else  // defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L
 
-using std::countl_one;
-using std::countl_zero;
-using std::countr_one;
-using std::countr_zero;
-using std::popcount;
-using std::rotl;
-using std::rotr;
+    using std::countl_one;
+    using std::countl_zero;
+    using std::countr_one;
+    using std::countr_zero;
+    using std::popcount;
+    using std::rotl;
+    using std::rotr;
 
 #endif
 
 #if !(defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L)
-// Returns: true if x is an integral power of two; false otherwise.
-template <class T>
-constexpr inline typename std::enable_if<std::is_unsigned<T>::value, bool>::type
-has_single_bit(T x) noexcept {
-  return x != 0 && (x & (x - 1)) == 0;
-}
-
-// Returns: If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any
-// fractional part discarded.
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    bit_width(T x) noexcept {
-  return std::numeric_limits<T>::digits -
-         static_cast<unsigned int>(countl_zero(x));
-}
-
-// Returns: If x == 0, 0; otherwise the maximal value y such that
-// has_single_bit(y) is true and y <= x.
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    bit_floor(T x) noexcept {
-  return x == 0 ? 0 : T{1} << (bit_width(x) - 1);
-}
-
-// Returns: N, where N is the smallest power of 2 greater than or equal to x.
-//
-// Preconditions: N is representable as a value of type T.
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    bit_ceil(T x) {
-  // If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
-  // want to force it to wraparound so that bit_ceil of an invalid value are not
-  // core constant expressions.
-  //
-  // BitCeilNonPowerOf2 triggers an overflow in constexpr contexts if we would
-  // undergo promotion to unsigned but not fit the result into T without
-  // truncation.
-  return has_single_bit(x) ? T{1} << (bit_width(x) - 1)
-                           : numeric_internal::BitCeilNonPowerOf2(x);
-}
+    // Returns: true if x is an integral power of two; false otherwise.
+    template<class T>
+    constexpr inline typename std::enable_if<std::is_unsigned<T>::value, bool>::type
+        has_single_bit(T x) noexcept
+    {
+        return x != 0 && (x & (x - 1)) == 0;
+    }
+
+    // Returns: If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any
+    // fractional part discarded.
+    template<class T>
+    ABSL_INTERNAL_CONSTEXPR_CLZ inline
+        typename std::enable_if<std::is_unsigned<T>::value, T>::type
+        bit_width(T x) noexcept
+    {
+        return std::numeric_limits<T>::digits -
+               static_cast<unsigned int>(countl_zero(x));
+    }
+
+    // Returns: If x == 0, 0; otherwise the maximal value y such that
+    // has_single_bit(y) is true and y <= x.
+    template<class T>
+    ABSL_INTERNAL_CONSTEXPR_CLZ inline
+        typename std::enable_if<std::is_unsigned<T>::value, T>::type
+        bit_floor(T x) noexcept
+    {
+        return x == 0 ? 0 : T{1} << (bit_width(x) - 1);
+    }
+
+    // Returns: N, where N is the smallest power of 2 greater than or equal to x.
+    //
+    // Preconditions: N is representable as a value of type T.
+    template<class T>
+    ABSL_INTERNAL_CONSTEXPR_CLZ inline
+        typename std::enable_if<std::is_unsigned<T>::value, T>::type
+        bit_ceil(T x)
+    {
+        // If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
+        // want to force it to wraparound so that bit_ceil of an invalid value are not
+        // core constant expressions.
+        //
+        // BitCeilNonPowerOf2 triggers an overflow in constexpr contexts if we would
+        // undergo promotion to unsigned but not fit the result into T without
+        // truncation.
+        return has_single_bit(x) ? T{1} << (bit_width(x) - 1) : numeric_internal::BitCeilNonPowerOf2(x);
+    }
 #else  // defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L
 
-using std::bit_ceil;
-using std::bit_floor;
-using std::bit_width;
-using std::has_single_bit;
+    using std::bit_ceil;
+    using std::bit_floor;
+    using std::bit_width;
+    using std::has_single_bit;
 
 #endif
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_NUMERIC_BITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/numeric/int128.h b/CAPI/cpp/grpc/include/absl/numeric/int128.h
index 7a899ee..32f10e8 100644
--- a/CAPI/cpp/grpc/include/absl/numeric/int128.h
+++ b/CAPI/cpp/grpc/include/absl/numeric/int128.h
@@ -52,1112 +52,1333 @@
 #define ABSL_INTERNAL_WCHAR_T wchar_t
 #endif  // defined(_MSC_VER)
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class int128;
-
-// uint128
-//
-// An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type
-// as closely as is practical, including exhibiting undefined behavior in
-// analogous cases (e.g. division by zero). This type is intended to be a
-// drop-in replacement once C++ supports an intrinsic `uint128_t` type; when
-// that occurs, existing well-behaved uses of `uint128` will continue to work
-// using that new type.
-//
-// Note: code written with this type will continue to compile once `uint128_t`
-// is introduced, provided the replacement helper functions
-// `Uint128(Low|High)64()` and `MakeUint128()` are made.
-//
-// A `uint128` supports the following:
-//
-//   * Implicit construction from integral types
-//   * Explicit conversion to integral types
-//
-// Additionally, if your compiler supports `__int128`, `uint128` is
-// interoperable with that type. (Abseil checks for this compatibility through
-// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
-//
-// However, a `uint128` differs from intrinsic integral types in the following
-// ways:
-//
-//   * Errors on implicit conversions that do not preserve value (such as
-//     loss of precision when converting to float values).
-//   * Requires explicit construction from and conversion to floating point
-//     types.
-//   * Conversion to integral types requires an explicit static_cast() to
-//     mimic use of the `-Wnarrowing` compiler flag.
-//   * The alignment requirement of `uint128` may differ from that of an
-//     intrinsic 128-bit integer type depending on platform and build
-//     configuration.
-//
-// Example:
-//
-//     float y = absl::Uint128Max();  // Error. uint128 cannot be implicitly
-//                                    // converted to float.
-//
-//     absl::uint128 v;
-//     uint64_t i = v;                         // Error
-//     uint64_t i = static_cast<uint64_t>(v);  // OK
-//
-class
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class int128;
+
+    // uint128
+    //
+    // An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type
+    // as closely as is practical, including exhibiting undefined behavior in
+    // analogous cases (e.g. division by zero). This type is intended to be a
+    // drop-in replacement once C++ supports an intrinsic `uint128_t` type; when
+    // that occurs, existing well-behaved uses of `uint128` will continue to work
+    // using that new type.
+    //
+    // Note: code written with this type will continue to compile once `uint128_t`
+    // is introduced, provided the replacement helper functions
+    // `Uint128(Low|High)64()` and `MakeUint128()` are made.
+    //
+    // A `uint128` supports the following:
+    //
+    //   * Implicit construction from integral types
+    //   * Explicit conversion to integral types
+    //
+    // Additionally, if your compiler supports `__int128`, `uint128` is
+    // interoperable with that type. (Abseil checks for this compatibility through
+    // the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+    //
+    // However, a `uint128` differs from intrinsic integral types in the following
+    // ways:
+    //
+    //   * Errors on implicit conversions that do not preserve value (such as
+    //     loss of precision when converting to float values).
+    //   * Requires explicit construction from and conversion to floating point
+    //     types.
+    //   * Conversion to integral types requires an explicit static_cast() to
+    //     mimic use of the `-Wnarrowing` compiler flag.
+    //   * The alignment requirement of `uint128` may differ from that of an
+    //     intrinsic 128-bit integer type depending on platform and build
+    //     configuration.
+    //
+    // Example:
+    //
+    //     float y = absl::Uint128Max();  // Error. uint128 cannot be implicitly
+    //                                    // converted to float.
+    //
+    //     absl::uint128 v;
+    //     uint64_t i = v;                         // Error
+    //     uint64_t i = static_cast<uint64_t>(v);  // OK
+    //
+    class
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-    alignas(unsigned __int128)
+        alignas(unsigned __int128)
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-        uint128 {
- public:
-  uint128() = default;
-
-  // Constructors from arithmetic types
-  constexpr uint128(int v);                 // NOLINT(runtime/explicit)
-  constexpr uint128(unsigned int v);        // NOLINT(runtime/explicit)
-  constexpr uint128(long v);                // NOLINT(runtime/int)
-  constexpr uint128(unsigned long v);       // NOLINT(runtime/int)
-  constexpr uint128(long long v);           // NOLINT(runtime/int)
-  constexpr uint128(unsigned long long v);  // NOLINT(runtime/int)
+            uint128
+    {
+    public:
+        uint128() = default;
+
+        // Constructors from arithmetic types
+        constexpr uint128(int v);                 // NOLINT(runtime/explicit)
+        constexpr uint128(unsigned int v);        // NOLINT(runtime/explicit)
+        constexpr uint128(long v);                // NOLINT(runtime/int)
+        constexpr uint128(unsigned long v);       // NOLINT(runtime/int)
+        constexpr uint128(long long v);           // NOLINT(runtime/int)
+        constexpr uint128(unsigned long long v);  // NOLINT(runtime/int)
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  constexpr uint128(__int128 v);           // NOLINT(runtime/explicit)
-  constexpr uint128(unsigned __int128 v);  // NOLINT(runtime/explicit)
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  constexpr uint128(int128 v);  // NOLINT(runtime/explicit)
-  explicit uint128(float v);
-  explicit uint128(double v);
-  explicit uint128(long double v);
-
-  // Assignment operators from arithmetic types
-  uint128& operator=(int v);
-  uint128& operator=(unsigned int v);
-  uint128& operator=(long v);                // NOLINT(runtime/int)
-  uint128& operator=(unsigned long v);       // NOLINT(runtime/int)
-  uint128& operator=(long long v);           // NOLINT(runtime/int)
-  uint128& operator=(unsigned long long v);  // NOLINT(runtime/int)
+        constexpr uint128(__int128 v);           // NOLINT(runtime/explicit)
+        constexpr uint128(unsigned __int128 v);  // NOLINT(runtime/explicit)
+#endif                                           // ABSL_HAVE_INTRINSIC_INT128
+        constexpr uint128(int128 v);             // NOLINT(runtime/explicit)
+        explicit uint128(float v);
+        explicit uint128(double v);
+        explicit uint128(long double v);
+
+        // Assignment operators from arithmetic types
+        uint128& operator=(int v);
+        uint128& operator=(unsigned int v);
+        uint128& operator=(long v);                // NOLINT(runtime/int)
+        uint128& operator=(unsigned long v);       // NOLINT(runtime/int)
+        uint128& operator=(long long v);           // NOLINT(runtime/int)
+        uint128& operator=(unsigned long long v);  // NOLINT(runtime/int)
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  uint128& operator=(__int128 v);
-  uint128& operator=(unsigned __int128 v);
+        uint128& operator=(__int128 v);
+        uint128& operator=(unsigned __int128 v);
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  uint128& operator=(int128 v);
-
-  // Conversion operators to other arithmetic types
-  constexpr explicit operator bool() const;
-  constexpr explicit operator char() const;
-  constexpr explicit operator signed char() const;
-  constexpr explicit operator unsigned char() const;
-  constexpr explicit operator char16_t() const;
-  constexpr explicit operator char32_t() const;
-  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
-  constexpr explicit operator short() const;  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned short() const;
-  constexpr explicit operator int() const;
-  constexpr explicit operator unsigned int() const;
-  constexpr explicit operator long() const;  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned long() const;
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator long long() const;
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned long long() const;
+        uint128& operator=(int128 v);
+
+        // Conversion operators to other arithmetic types
+        constexpr explicit operator bool() const;
+        constexpr explicit operator char() const;
+        constexpr explicit operator signed char() const;
+        constexpr explicit operator unsigned char() const;
+        constexpr explicit operator char16_t() const;
+        constexpr explicit operator char32_t() const;
+        constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
+        constexpr explicit operator short() const;  // NOLINT(runtime/int)
+        // NOLINTNEXTLINE(runtime/int)
+        constexpr explicit operator unsigned short() const;
+        constexpr explicit operator int() const;
+        constexpr explicit operator unsigned int() const;
+        constexpr explicit operator long() const;  // NOLINT(runtime/int)
+        // NOLINTNEXTLINE(runtime/int)
+        constexpr explicit operator unsigned long() const;
+        // NOLINTNEXTLINE(runtime/int)
+        constexpr explicit operator long long() const;
+        // NOLINTNEXTLINE(runtime/int)
+        constexpr explicit operator unsigned long long() const;
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  constexpr explicit operator __int128() const;
-  constexpr explicit operator unsigned __int128() const;
+        constexpr explicit operator __int128() const;
+        constexpr explicit operator unsigned __int128() const;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  explicit operator float() const;
-  explicit operator double() const;
-  explicit operator long double() const;
-
-  // Trivial copy constructor, assignment operator and destructor.
-
-  // Arithmetic operators.
-  uint128& operator+=(uint128 other);
-  uint128& operator-=(uint128 other);
-  uint128& operator*=(uint128 other);
-  // Long division/modulo for uint128.
-  uint128& operator/=(uint128 other);
-  uint128& operator%=(uint128 other);
-  uint128 operator++(int);
-  uint128 operator--(int);
-  uint128& operator<<=(int);
-  uint128& operator>>=(int);
-  uint128& operator&=(uint128 other);
-  uint128& operator|=(uint128 other);
-  uint128& operator^=(uint128 other);
-  uint128& operator++();
-  uint128& operator--();
-
-  // Uint128Low64()
-  //
-  // Returns the lower 64-bit value of a `uint128` value.
-  friend constexpr uint64_t Uint128Low64(uint128 v);
-
-  // Uint128High64()
-  //
-  // Returns the higher 64-bit value of a `uint128` value.
-  friend constexpr uint64_t Uint128High64(uint128 v);
-
-  // MakeUInt128()
-  //
-  // Constructs a `uint128` numeric value from two 64-bit unsigned integers.
-  // Note that this factory function is the only way to construct a `uint128`
-  // from integer values greater than 2^64.
-  //
-  // Example:
-  //
-  //   absl::uint128 big = absl::MakeUint128(1, 0);
-  friend constexpr uint128 MakeUint128(uint64_t high, uint64_t low);
-
-  // Uint128Max()
-  //
-  // Returns the highest value for a 128-bit unsigned integer.
-  friend constexpr uint128 Uint128Max();
-
-  // Support for absl::Hash.
-  template <typename H>
-  friend H AbslHashValue(H h, uint128 v) {
-    return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v));
-  }
-
- private:
-  constexpr uint128(uint64_t high, uint64_t low);
-
-  // TODO(strel) Update implementation to use __int128 once all users of
-  // uint128 are fixed to not depend on alignof(uint128) == 8. Also add
-  // alignas(16) to class definition to keep alignment consistent across
-  // platforms.
+        explicit operator float() const;
+        explicit operator double() const;
+        explicit operator long double() const;
+
+        // Trivial copy constructor, assignment operator and destructor.
+
+        // Arithmetic operators.
+        uint128& operator+=(uint128 other);
+        uint128& operator-=(uint128 other);
+        uint128& operator*=(uint128 other);
+        // Long division/modulo for uint128.
+        uint128& operator/=(uint128 other);
+        uint128& operator%=(uint128 other);
+        uint128 operator++(int);
+        uint128 operator--(int);
+        uint128& operator<<=(int);
+        uint128& operator>>=(int);
+        uint128& operator&=(uint128 other);
+        uint128& operator|=(uint128 other);
+        uint128& operator^=(uint128 other);
+        uint128& operator++();
+        uint128& operator--();
+
+        // Uint128Low64()
+        //
+        // Returns the lower 64-bit value of a `uint128` value.
+        friend constexpr uint64_t Uint128Low64(uint128 v);
+
+        // Uint128High64()
+        //
+        // Returns the higher 64-bit value of a `uint128` value.
+        friend constexpr uint64_t Uint128High64(uint128 v);
+
+        // MakeUInt128()
+        //
+        // Constructs a `uint128` numeric value from two 64-bit unsigned integers.
+        // Note that this factory function is the only way to construct a `uint128`
+        // from integer values greater than 2^64.
+        //
+        // Example:
+        //
+        //   absl::uint128 big = absl::MakeUint128(1, 0);
+        friend constexpr uint128 MakeUint128(uint64_t high, uint64_t low);
+
+        // Uint128Max()
+        //
+        // Returns the highest value for a 128-bit unsigned integer.
+        friend constexpr uint128 Uint128Max();
+
+        // Support for absl::Hash.
+        template<typename H>
+        friend H AbslHashValue(H h, uint128 v)
+        {
+            return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v));
+        }
+
+    private:
+        constexpr uint128(uint64_t high, uint64_t low);
+
+        // TODO(strel) Update implementation to use __int128 once all users of
+        // uint128 are fixed to not depend on alignof(uint128) == 8. Also add
+        // alignas(16) to class definition to keep alignment consistent across
+        // platforms.
 #if defined(ABSL_IS_LITTLE_ENDIAN)
-  uint64_t lo_;
-  uint64_t hi_;
+        uint64_t lo_;
+        uint64_t hi_;
 #elif defined(ABSL_IS_BIG_ENDIAN)
-  uint64_t hi_;
-  uint64_t lo_;
+        uint64_t hi_;
+        uint64_t lo_;
 #else  // byte order
 #error "Unsupported byte order: must be little-endian or big-endian."
 #endif  // byte order
-};
+    };
 
-// Prefer to use the constexpr `Uint128Max()`.
-//
-// TODO(absl-team) deprecate kuint128max once migration tool is released.
-ABSL_DLL extern const uint128 kuint128max;
+    // Prefer to use the constexpr `Uint128Max()`.
+    //
+    // TODO(absl-team) deprecate kuint128max once migration tool is released.
+    ABSL_DLL extern const uint128 kuint128max;
 
-// allow uint128 to be logged
-std::ostream& operator<<(std::ostream& os, uint128 v);
+    // allow uint128 to be logged
+    std::ostream& operator<<(std::ostream& os, uint128 v);
 
-// TODO(strel) add operator>>(std::istream&, uint128)
+    // TODO(strel) add operator>>(std::istream&, uint128)
 
-constexpr uint128 Uint128Max() {
-  return uint128((std::numeric_limits<uint64_t>::max)(),
-                 (std::numeric_limits<uint64_t>::max)());
-}
+    constexpr uint128 Uint128Max()
+    {
+        return uint128((std::numeric_limits<uint64_t>::max)(), (std::numeric_limits<uint64_t>::max)());
+    }
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // Specialized numeric_limits for uint128.
-namespace std {
-template <>
-class numeric_limits<absl::uint128> {
- public:
-  static constexpr bool is_specialized = true;
-  static constexpr bool is_signed = false;
-  static constexpr bool is_integer = true;
-  static constexpr bool is_exact = true;
-  static constexpr bool has_infinity = false;
-  static constexpr bool has_quiet_NaN = false;
-  static constexpr bool has_signaling_NaN = false;
-  static constexpr float_denorm_style has_denorm = denorm_absent;
-  static constexpr bool has_denorm_loss = false;
-  static constexpr float_round_style round_style = round_toward_zero;
-  static constexpr bool is_iec559 = false;
-  static constexpr bool is_bounded = true;
-  static constexpr bool is_modulo = true;
-  static constexpr int digits = 128;
-  static constexpr int digits10 = 38;
-  static constexpr int max_digits10 = 0;
-  static constexpr int radix = 2;
-  static constexpr int min_exponent = 0;
-  static constexpr int min_exponent10 = 0;
-  static constexpr int max_exponent = 0;
-  static constexpr int max_exponent10 = 0;
+namespace std
+{
+    template<>
+    class numeric_limits<absl::uint128>
+    {
+    public:
+        static constexpr bool is_specialized = true;
+        static constexpr bool is_signed = false;
+        static constexpr bool is_integer = true;
+        static constexpr bool is_exact = true;
+        static constexpr bool has_infinity = false;
+        static constexpr bool has_quiet_NaN = false;
+        static constexpr bool has_signaling_NaN = false;
+        static constexpr float_denorm_style has_denorm = denorm_absent;
+        static constexpr bool has_denorm_loss = false;
+        static constexpr float_round_style round_style = round_toward_zero;
+        static constexpr bool is_iec559 = false;
+        static constexpr bool is_bounded = true;
+        static constexpr bool is_modulo = true;
+        static constexpr int digits = 128;
+        static constexpr int digits10 = 38;
+        static constexpr int max_digits10 = 0;
+        static constexpr int radix = 2;
+        static constexpr int min_exponent = 0;
+        static constexpr int min_exponent10 = 0;
+        static constexpr int max_exponent = 0;
+        static constexpr int max_exponent10 = 0;
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool traps = numeric_limits<unsigned __int128>::traps;
+        static constexpr bool traps = numeric_limits<unsigned __int128>::traps;
 #else   // ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool traps = numeric_limits<uint64_t>::traps;
+        static constexpr bool traps = numeric_limits<uint64_t>::traps;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool tinyness_before = false;
-
-  static constexpr absl::uint128 (min)() { return 0; }
-  static constexpr absl::uint128 lowest() { return 0; }
-  static constexpr absl::uint128 (max)() { return absl::Uint128Max(); }
-  static constexpr absl::uint128 epsilon() { return 0; }
-  static constexpr absl::uint128 round_error() { return 0; }
-  static constexpr absl::uint128 infinity() { return 0; }
-  static constexpr absl::uint128 quiet_NaN() { return 0; }
-  static constexpr absl::uint128 signaling_NaN() { return 0; }
-  static constexpr absl::uint128 denorm_min() { return 0; }
-};
+        static constexpr bool tinyness_before = false;
+
+        static constexpr absl::uint128(min)()
+        {
+            return 0;
+        }
+        static constexpr absl::uint128 lowest()
+        {
+            return 0;
+        }
+        static constexpr absl::uint128(max)()
+        {
+            return absl::Uint128Max();
+        }
+        static constexpr absl::uint128 epsilon()
+        {
+            return 0;
+        }
+        static constexpr absl::uint128 round_error()
+        {
+            return 0;
+        }
+        static constexpr absl::uint128 infinity()
+        {
+            return 0;
+        }
+        static constexpr absl::uint128 quiet_NaN()
+        {
+            return 0;
+        }
+        static constexpr absl::uint128 signaling_NaN()
+        {
+            return 0;
+        }
+        static constexpr absl::uint128 denorm_min()
+        {
+            return 0;
+        }
+    };
 }  // namespace std
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// int128
-//
-// A signed 128-bit integer type. The API is meant to mimic an intrinsic
-// integral type as closely as is practical, including exhibiting undefined
-// behavior in analogous cases (e.g. division by zero).
-//
-// An `int128` supports the following:
-//
-//   * Implicit construction from integral types
-//   * Explicit conversion to integral types
-//
-// However, an `int128` differs from intrinsic integral types in the following
-// ways:
-//
-//   * It is not implicitly convertible to other integral types.
-//   * Requires explicit construction from and conversion to floating point
-//     types.
-
-// Additionally, if your compiler supports `__int128`, `int128` is
-// interoperable with that type. (Abseil checks for this compatibility through
-// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
-//
-// The design goal for `int128` is that it will be compatible with a future
-// `int128_t`, if that type becomes a part of the standard.
-//
-// Example:
-//
-//     float y = absl::int128(17);  // Error. int128 cannot be implicitly
-//                                  // converted to float.
-//
-//     absl::int128 v;
-//     int64_t i = v;                        // Error
-//     int64_t i = static_cast<int64_t>(v);  // OK
-//
-class int128 {
- public:
-  int128() = default;
-
-  // Constructors from arithmetic types
-  constexpr int128(int v);                 // NOLINT(runtime/explicit)
-  constexpr int128(unsigned int v);        // NOLINT(runtime/explicit)
-  constexpr int128(long v);                // NOLINT(runtime/int)
-  constexpr int128(unsigned long v);       // NOLINT(runtime/int)
-  constexpr int128(long long v);           // NOLINT(runtime/int)
-  constexpr int128(unsigned long long v);  // NOLINT(runtime/int)
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // int128
+    //
+    // A signed 128-bit integer type. The API is meant to mimic an intrinsic
+    // integral type as closely as is practical, including exhibiting undefined
+    // behavior in analogous cases (e.g. division by zero).
+    //
+    // An `int128` supports the following:
+    //
+    //   * Implicit construction from integral types
+    //   * Explicit conversion to integral types
+    //
+    // However, an `int128` differs from intrinsic integral types in the following
+    // ways:
+    //
+    //   * It is not implicitly convertible to other integral types.
+    //   * Requires explicit construction from and conversion to floating point
+    //     types.
+
+    // Additionally, if your compiler supports `__int128`, `int128` is
+    // interoperable with that type. (Abseil checks for this compatibility through
+    // the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+    //
+    // The design goal for `int128` is that it will be compatible with a future
+    // `int128_t`, if that type becomes a part of the standard.
+    //
+    // Example:
+    //
+    //     float y = absl::int128(17);  // Error. int128 cannot be implicitly
+    //                                  // converted to float.
+    //
+    //     absl::int128 v;
+    //     int64_t i = v;                        // Error
+    //     int64_t i = static_cast<int64_t>(v);  // OK
+    //
+    class int128
+    {
+    public:
+        int128() = default;
+
+        // Constructors from arithmetic types
+        constexpr int128(int v);                 // NOLINT(runtime/explicit)
+        constexpr int128(unsigned int v);        // NOLINT(runtime/explicit)
+        constexpr int128(long v);                // NOLINT(runtime/int)
+        constexpr int128(unsigned long v);       // NOLINT(runtime/int)
+        constexpr int128(long long v);           // NOLINT(runtime/int)
+        constexpr int128(unsigned long long v);  // NOLINT(runtime/int)
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  constexpr int128(__int128 v);  // NOLINT(runtime/explicit)
-  constexpr explicit int128(unsigned __int128 v);
+        constexpr int128(__int128 v);  // NOLINT(runtime/explicit)
+        constexpr explicit int128(unsigned __int128 v);
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  constexpr explicit int128(uint128 v);
-  explicit int128(float v);
-  explicit int128(double v);
-  explicit int128(long double v);
-
-  // Assignment operators from arithmetic types
-  int128& operator=(int v);
-  int128& operator=(unsigned int v);
-  int128& operator=(long v);                // NOLINT(runtime/int)
-  int128& operator=(unsigned long v);       // NOLINT(runtime/int)
-  int128& operator=(long long v);           // NOLINT(runtime/int)
-  int128& operator=(unsigned long long v);  // NOLINT(runtime/int)
+        constexpr explicit int128(uint128 v);
+        explicit int128(float v);
+        explicit int128(double v);
+        explicit int128(long double v);
+
+        // Assignment operators from arithmetic types
+        int128& operator=(int v);
+        int128& operator=(unsigned int v);
+        int128& operator=(long v);                // NOLINT(runtime/int)
+        int128& operator=(unsigned long v);       // NOLINT(runtime/int)
+        int128& operator=(long long v);           // NOLINT(runtime/int)
+        int128& operator=(unsigned long long v);  // NOLINT(runtime/int)
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  int128& operator=(__int128 v);
+        int128& operator=(__int128 v);
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
-  // Conversion operators to other arithmetic types
-  constexpr explicit operator bool() const;
-  constexpr explicit operator char() const;
-  constexpr explicit operator signed char() const;
-  constexpr explicit operator unsigned char() const;
-  constexpr explicit operator char16_t() const;
-  constexpr explicit operator char32_t() const;
-  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
-  constexpr explicit operator short() const;  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned short() const;
-  constexpr explicit operator int() const;
-  constexpr explicit operator unsigned int() const;
-  constexpr explicit operator long() const;  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned long() const;
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator long long() const;
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned long long() const;
+        // Conversion operators to other arithmetic types
+        constexpr explicit operator bool() const;
+        constexpr explicit operator char() const;
+        constexpr explicit operator signed char() const;
+        constexpr explicit operator unsigned char() const;
+        constexpr explicit operator char16_t() const;
+        constexpr explicit operator char32_t() const;
+        constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
+        constexpr explicit operator short() const;  // NOLINT(runtime/int)
+        // NOLINTNEXTLINE(runtime/int)
+        constexpr explicit operator unsigned short() const;
+        constexpr explicit operator int() const;
+        constexpr explicit operator unsigned int() const;
+        constexpr explicit operator long() const;  // NOLINT(runtime/int)
+        // NOLINTNEXTLINE(runtime/int)
+        constexpr explicit operator unsigned long() const;
+        // NOLINTNEXTLINE(runtime/int)
+        constexpr explicit operator long long() const;
+        // NOLINTNEXTLINE(runtime/int)
+        constexpr explicit operator unsigned long long() const;
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  constexpr explicit operator __int128() const;
-  constexpr explicit operator unsigned __int128() const;
+        constexpr explicit operator __int128() const;
+        constexpr explicit operator unsigned __int128() const;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  explicit operator float() const;
-  explicit operator double() const;
-  explicit operator long double() const;
-
-  // Trivial copy constructor, assignment operator and destructor.
-
-  // Arithmetic operators
-  int128& operator+=(int128 other);
-  int128& operator-=(int128 other);
-  int128& operator*=(int128 other);
-  int128& operator/=(int128 other);
-  int128& operator%=(int128 other);
-  int128 operator++(int);  // postfix increment: i++
-  int128 operator--(int);  // postfix decrement: i--
-  int128& operator++();    // prefix increment:  ++i
-  int128& operator--();    // prefix decrement:  --i
-  int128& operator&=(int128 other);
-  int128& operator|=(int128 other);
-  int128& operator^=(int128 other);
-  int128& operator<<=(int amount);
-  int128& operator>>=(int amount);
-
-  // Int128Low64()
-  //
-  // Returns the lower 64-bit value of a `int128` value.
-  friend constexpr uint64_t Int128Low64(int128 v);
-
-  // Int128High64()
-  //
-  // Returns the higher 64-bit value of a `int128` value.
-  friend constexpr int64_t Int128High64(int128 v);
-
-  // MakeInt128()
-  //
-  // Constructs a `int128` numeric value from two 64-bit integers. Note that
-  // signedness is conveyed in the upper `high` value.
-  //
-  //   (absl::int128(1) << 64) * high + low
-  //
-  // Note that this factory function is the only way to construct a `int128`
-  // from integer values greater than 2^64 or less than -2^64.
-  //
-  // Example:
-  //
-  //   absl::int128 big = absl::MakeInt128(1, 0);
-  //   absl::int128 big_n = absl::MakeInt128(-1, 0);
-  friend constexpr int128 MakeInt128(int64_t high, uint64_t low);
-
-  // Int128Max()
-  //
-  // Returns the maximum value for a 128-bit signed integer.
-  friend constexpr int128 Int128Max();
-
-  // Int128Min()
-  //
-  // Returns the minimum value for a 128-bit signed integer.
-  friend constexpr int128 Int128Min();
-
-  // Support for absl::Hash.
-  template <typename H>
-  friend H AbslHashValue(H h, int128 v) {
-    return H::combine(std::move(h), Int128High64(v), Int128Low64(v));
-  }
-
- private:
-  constexpr int128(int64_t high, uint64_t low);
+        explicit operator float() const;
+        explicit operator double() const;
+        explicit operator long double() const;
+
+        // Trivial copy constructor, assignment operator and destructor.
+
+        // Arithmetic operators
+        int128& operator+=(int128 other);
+        int128& operator-=(int128 other);
+        int128& operator*=(int128 other);
+        int128& operator/=(int128 other);
+        int128& operator%=(int128 other);
+        int128 operator++(int);  // postfix increment: i++
+        int128 operator--(int);  // postfix decrement: i--
+        int128& operator++();    // prefix increment:  ++i
+        int128& operator--();    // prefix decrement:  --i
+        int128& operator&=(int128 other);
+        int128& operator|=(int128 other);
+        int128& operator^=(int128 other);
+        int128& operator<<=(int amount);
+        int128& operator>>=(int amount);
+
+        // Int128Low64()
+        //
+        // Returns the lower 64-bit value of a `int128` value.
+        friend constexpr uint64_t Int128Low64(int128 v);
+
+        // Int128High64()
+        //
+        // Returns the higher 64-bit value of a `int128` value.
+        friend constexpr int64_t Int128High64(int128 v);
+
+        // MakeInt128()
+        //
+        // Constructs a `int128` numeric value from two 64-bit integers. Note that
+        // signedness is conveyed in the upper `high` value.
+        //
+        //   (absl::int128(1) << 64) * high + low
+        //
+        // Note that this factory function is the only way to construct a `int128`
+        // from integer values greater than 2^64 or less than -2^64.
+        //
+        // Example:
+        //
+        //   absl::int128 big = absl::MakeInt128(1, 0);
+        //   absl::int128 big_n = absl::MakeInt128(-1, 0);
+        friend constexpr int128 MakeInt128(int64_t high, uint64_t low);
+
+        // Int128Max()
+        //
+        // Returns the maximum value for a 128-bit signed integer.
+        friend constexpr int128 Int128Max();
+
+        // Int128Min()
+        //
+        // Returns the minimum value for a 128-bit signed integer.
+        friend constexpr int128 Int128Min();
+
+        // Support for absl::Hash.
+        template<typename H>
+        friend H AbslHashValue(H h, int128 v)
+        {
+            return H::combine(std::move(h), Int128High64(v), Int128Low64(v));
+        }
+
+    private:
+        constexpr int128(int64_t high, uint64_t low);
 
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  __int128 v_;
+        __int128 v_;
 #else  // ABSL_HAVE_INTRINSIC_INT128
 #if defined(ABSL_IS_LITTLE_ENDIAN)
-  uint64_t lo_;
-  int64_t hi_;
+        uint64_t lo_;
+        int64_t hi_;
 #elif defined(ABSL_IS_BIG_ENDIAN)
-  int64_t hi_;
-  uint64_t lo_;
+        int64_t hi_;
+        uint64_t lo_;
 #else  // byte order
 #error "Unsupported byte order: must be little-endian or big-endian."
 #endif  // byte order
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-};
+    };
 
-std::ostream& operator<<(std::ostream& os, int128 v);
+    std::ostream& operator<<(std::ostream& os, int128 v);
 
-// TODO(absl-team) add operator>>(std::istream&, int128)
+    // TODO(absl-team) add operator>>(std::istream&, int128)
 
-constexpr int128 Int128Max() {
-  return int128((std::numeric_limits<int64_t>::max)(),
-                (std::numeric_limits<uint64_t>::max)());
-}
+    constexpr int128 Int128Max()
+    {
+        return int128((std::numeric_limits<int64_t>::max)(), (std::numeric_limits<uint64_t>::max)());
+    }
 
-constexpr int128 Int128Min() {
-  return int128((std::numeric_limits<int64_t>::min)(), 0);
-}
+    constexpr int128 Int128Min()
+    {
+        return int128((std::numeric_limits<int64_t>::min)(), 0);
+    }
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // Specialized numeric_limits for int128.
-namespace std {
-template <>
-class numeric_limits<absl::int128> {
- public:
-  static constexpr bool is_specialized = true;
-  static constexpr bool is_signed = true;
-  static constexpr bool is_integer = true;
-  static constexpr bool is_exact = true;
-  static constexpr bool has_infinity = false;
-  static constexpr bool has_quiet_NaN = false;
-  static constexpr bool has_signaling_NaN = false;
-  static constexpr float_denorm_style has_denorm = denorm_absent;
-  static constexpr bool has_denorm_loss = false;
-  static constexpr float_round_style round_style = round_toward_zero;
-  static constexpr bool is_iec559 = false;
-  static constexpr bool is_bounded = true;
-  static constexpr bool is_modulo = false;
-  static constexpr int digits = 127;
-  static constexpr int digits10 = 38;
-  static constexpr int max_digits10 = 0;
-  static constexpr int radix = 2;
-  static constexpr int min_exponent = 0;
-  static constexpr int min_exponent10 = 0;
-  static constexpr int max_exponent = 0;
-  static constexpr int max_exponent10 = 0;
+namespace std
+{
+    template<>
+    class numeric_limits<absl::int128>
+    {
+    public:
+        static constexpr bool is_specialized = true;
+        static constexpr bool is_signed = true;
+        static constexpr bool is_integer = true;
+        static constexpr bool is_exact = true;
+        static constexpr bool has_infinity = false;
+        static constexpr bool has_quiet_NaN = false;
+        static constexpr bool has_signaling_NaN = false;
+        static constexpr float_denorm_style has_denorm = denorm_absent;
+        static constexpr bool has_denorm_loss = false;
+        static constexpr float_round_style round_style = round_toward_zero;
+        static constexpr bool is_iec559 = false;
+        static constexpr bool is_bounded = true;
+        static constexpr bool is_modulo = false;
+        static constexpr int digits = 127;
+        static constexpr int digits10 = 38;
+        static constexpr int max_digits10 = 0;
+        static constexpr int radix = 2;
+        static constexpr int min_exponent = 0;
+        static constexpr int min_exponent10 = 0;
+        static constexpr int max_exponent = 0;
+        static constexpr int max_exponent10 = 0;
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool traps = numeric_limits<__int128>::traps;
+        static constexpr bool traps = numeric_limits<__int128>::traps;
 #else   // ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool traps = numeric_limits<uint64_t>::traps;
+        static constexpr bool traps = numeric_limits<uint64_t>::traps;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool tinyness_before = false;
-
-  static constexpr absl::int128 (min)() { return absl::Int128Min(); }
-  static constexpr absl::int128 lowest() { return absl::Int128Min(); }
-  static constexpr absl::int128 (max)() { return absl::Int128Max(); }
-  static constexpr absl::int128 epsilon() { return 0; }
-  static constexpr absl::int128 round_error() { return 0; }
-  static constexpr absl::int128 infinity() { return 0; }
-  static constexpr absl::int128 quiet_NaN() { return 0; }
-  static constexpr absl::int128 signaling_NaN() { return 0; }
-  static constexpr absl::int128 denorm_min() { return 0; }
-};
+        static constexpr bool tinyness_before = false;
+
+        static constexpr absl::int128(min)()
+        {
+            return absl::Int128Min();
+        }
+        static constexpr absl::int128 lowest()
+        {
+            return absl::Int128Min();
+        }
+        static constexpr absl::int128(max)()
+        {
+            return absl::Int128Max();
+        }
+        static constexpr absl::int128 epsilon()
+        {
+            return 0;
+        }
+        static constexpr absl::int128 round_error()
+        {
+            return 0;
+        }
+        static constexpr absl::int128 infinity()
+        {
+            return 0;
+        }
+        static constexpr absl::int128 quiet_NaN()
+        {
+            return 0;
+        }
+        static constexpr absl::int128 signaling_NaN()
+        {
+            return 0;
+        }
+        static constexpr absl::int128 denorm_min()
+        {
+            return 0;
+        }
+    };
 }  // namespace std
 
 // --------------------------------------------------------------------------
 //                      Implementation details follow
 // --------------------------------------------------------------------------
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-constexpr uint128 MakeUint128(uint64_t high, uint64_t low) {
-  return uint128(high, low);
-}
-
-// Assignment from integer types.
-
-inline uint128& uint128::operator=(int v) { return *this = uint128(v); }
-
-inline uint128& uint128::operator=(unsigned int v) {
-  return *this = uint128(v);
-}
-
-inline uint128& uint128::operator=(long v) {  // NOLINT(runtime/int)
-  return *this = uint128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline uint128& uint128::operator=(unsigned long v) {
-  return *this = uint128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline uint128& uint128::operator=(long long v) {
-  return *this = uint128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline uint128& uint128::operator=(unsigned long long v) {
-  return *this = uint128(v);
-}
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    constexpr uint128 MakeUint128(uint64_t high, uint64_t low)
+    {
+        return uint128(high, low);
+    }
+
+    // Assignment from integer types.
+
+    inline uint128& uint128::operator=(int v)
+    {
+        return *this = uint128(v);
+    }
+
+    inline uint128& uint128::operator=(unsigned int v)
+    {
+        return *this = uint128(v);
+    }
+
+    inline uint128& uint128::operator=(long v)
+    {  // NOLINT(runtime/int)
+        return *this = uint128(v);
+    }
+
+    // NOLINTNEXTLINE(runtime/int)
+    inline uint128& uint128::operator=(unsigned long v)
+    {
+        return *this = uint128(v);
+    }
+
+    // NOLINTNEXTLINE(runtime/int)
+    inline uint128& uint128::operator=(long long v)
+    {
+        return *this = uint128(v);
+    }
+
+    // NOLINTNEXTLINE(runtime/int)
+    inline uint128& uint128::operator=(unsigned long long v)
+    {
+        return *this = uint128(v);
+    }
 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-inline uint128& uint128::operator=(__int128 v) {
-  return *this = uint128(v);
-}
-
-inline uint128& uint128::operator=(unsigned __int128 v) {
-  return *this = uint128(v);
-}
+    inline uint128& uint128::operator=(__int128 v)
+    {
+        return *this = uint128(v);
+    }
+
+    inline uint128& uint128::operator=(unsigned __int128 v)
+    {
+        return *this = uint128(v);
+    }
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
-inline uint128& uint128::operator=(int128 v) {
-  return *this = uint128(v);
-}
-
-// Arithmetic operators.
-
-constexpr uint128 operator<<(uint128 lhs, int amount);
-constexpr uint128 operator>>(uint128 lhs, int amount);
-constexpr uint128 operator+(uint128 lhs, uint128 rhs);
-constexpr uint128 operator-(uint128 lhs, uint128 rhs);
-uint128 operator*(uint128 lhs, uint128 rhs);
-uint128 operator/(uint128 lhs, uint128 rhs);
-uint128 operator%(uint128 lhs, uint128 rhs);
-
-inline uint128& uint128::operator<<=(int amount) {
-  *this = *this << amount;
-  return *this;
-}
-
-inline uint128& uint128::operator>>=(int amount) {
-  *this = *this >> amount;
-  return *this;
-}
-
-inline uint128& uint128::operator+=(uint128 other) {
-  *this = *this + other;
-  return *this;
-}
-
-inline uint128& uint128::operator-=(uint128 other) {
-  *this = *this - other;
-  return *this;
-}
-
-inline uint128& uint128::operator*=(uint128 other) {
-  *this = *this * other;
-  return *this;
-}
-
-inline uint128& uint128::operator/=(uint128 other) {
-  *this = *this / other;
-  return *this;
-}
-
-inline uint128& uint128::operator%=(uint128 other) {
-  *this = *this % other;
-  return *this;
-}
-
-constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
-
-constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
-
-// Constructors from integer types.
+    inline uint128& uint128::operator=(int128 v)
+    {
+        return *this = uint128(v);
+    }
+
+    // Arithmetic operators.
+
+    constexpr uint128 operator<<(uint128 lhs, int amount);
+    constexpr uint128 operator>>(uint128 lhs, int amount);
+    constexpr uint128 operator+(uint128 lhs, uint128 rhs);
+    constexpr uint128 operator-(uint128 lhs, uint128 rhs);
+    uint128 operator*(uint128 lhs, uint128 rhs);
+    uint128 operator/(uint128 lhs, uint128 rhs);
+    uint128 operator%(uint128 lhs, uint128 rhs);
+
+    inline uint128& uint128::operator<<=(int amount)
+    {
+        *this = *this << amount;
+        return *this;
+    }
+
+    inline uint128& uint128::operator>>=(int amount)
+    {
+        *this = *this >> amount;
+        return *this;
+    }
+
+    inline uint128& uint128::operator+=(uint128 other)
+    {
+        *this = *this + other;
+        return *this;
+    }
+
+    inline uint128& uint128::operator-=(uint128 other)
+    {
+        *this = *this - other;
+        return *this;
+    }
+
+    inline uint128& uint128::operator*=(uint128 other)
+    {
+        *this = *this * other;
+        return *this;
+    }
+
+    inline uint128& uint128::operator/=(uint128 other)
+    {
+        *this = *this / other;
+        return *this;
+    }
+
+    inline uint128& uint128::operator%=(uint128 other)
+    {
+        *this = *this % other;
+        return *this;
+    }
+
+    constexpr uint64_t Uint128Low64(uint128 v)
+    {
+        return v.lo_;
+    }
+
+    constexpr uint64_t Uint128High64(uint128 v)
+    {
+        return v.hi_;
+    }
+
+    // Constructors from integer types.
 
 #if defined(ABSL_IS_LITTLE_ENDIAN)
 
-constexpr uint128::uint128(uint64_t high, uint64_t low)
-    : lo_{low}, hi_{high} {}
-
-constexpr uint128::uint128(int v)
-    : lo_{static_cast<uint64_t>(v)},
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
-constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
-    : lo_{static_cast<uint64_t>(v)},
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
-constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
-    : lo_{static_cast<uint64_t>(v)},
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
-
-constexpr uint128::uint128(unsigned int v) : lo_{v}, hi_{0} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::uint128(unsigned long long v) : lo_{v}, hi_{0} {}
+    constexpr uint128::uint128(uint64_t high, uint64_t low) :
+        lo_{low},
+        hi_{high}
+    {
+    }
+
+    constexpr uint128::uint128(int v) :
+        lo_{static_cast<uint64_t>(v)},
+        hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0}
+    {
+    }
+    constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
+        :
+        lo_{static_cast<uint64_t>(v)},
+        hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0}
+    {
+    }
+    constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
+        :
+        lo_{static_cast<uint64_t>(v)},
+        hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0}
+    {
+    }
+
+    constexpr uint128::uint128(unsigned int v) :
+        lo_{v},
+        hi_{0}
+    {
+    }
+    // NOLINTNEXTLINE(runtime/int)
+    constexpr uint128::uint128(unsigned long v) :
+        lo_{v},
+        hi_{0}
+    {
+    }
+    // NOLINTNEXTLINE(runtime/int)
+    constexpr uint128::uint128(unsigned long long v) :
+        lo_{v},
+        hi_{0}
+    {
+    }
 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-constexpr uint128::uint128(__int128 v)
-    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
-      hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)} {}
-constexpr uint128::uint128(unsigned __int128 v)
-    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
-      hi_{static_cast<uint64_t>(v >> 64)} {}
+    constexpr uint128::uint128(__int128 v) :
+        lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
+        hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)}
+    {
+    }
+    constexpr uint128::uint128(unsigned __int128 v) :
+        lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
+        hi_{static_cast<uint64_t>(v >> 64)}
+    {
+    }
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
-constexpr uint128::uint128(int128 v)
-    : lo_{Int128Low64(v)}, hi_{static_cast<uint64_t>(Int128High64(v))} {}
+    constexpr uint128::uint128(int128 v) :
+        lo_{Int128Low64(v)},
+        hi_{static_cast<uint64_t>(Int128High64(v))}
+    {
+    }
 
 #elif defined(ABSL_IS_BIG_ENDIAN)
 
-constexpr uint128::uint128(uint64_t high, uint64_t low)
-    : hi_{high}, lo_{low} {}
-
-constexpr uint128::uint128(int v)
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
-      lo_{static_cast<uint64_t>(v)} {}
-constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
-      lo_{static_cast<uint64_t>(v)} {}
-constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
-      lo_{static_cast<uint64_t>(v)} {}
-
-constexpr uint128::uint128(unsigned int v) : hi_{0}, lo_{v} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::uint128(unsigned long v) : hi_{0}, lo_{v} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::uint128(unsigned long long v) : hi_{0}, lo_{v} {}
+    constexpr uint128::uint128(uint64_t high, uint64_t low) :
+        hi_{high},
+        lo_{low}
+    {
+    }
+
+    constexpr uint128::uint128(int v) :
+        hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+        lo_{static_cast<uint64_t>(v)}
+    {
+    }
+    constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
+        :
+        hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+        lo_{static_cast<uint64_t>(v)}
+    {
+    }
+    constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
+        :
+        hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+        lo_{static_cast<uint64_t>(v)}
+    {
+    }
+
+    constexpr uint128::uint128(unsigned int v) :
+        hi_{0},
+        lo_{v}
+    {
+    }
+    // NOLINTNEXTLINE(runtime/int)
+    constexpr uint128::uint128(unsigned long v) :
+        hi_{0},
+        lo_{v}
+    {
+    }
+    // NOLINTNEXTLINE(runtime/int)
+    constexpr uint128::uint128(unsigned long long v) :
+        hi_{0},
+        lo_{v}
+    {
+    }
 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-constexpr uint128::uint128(__int128 v)
-    : hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)},
-      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
-constexpr uint128::uint128(unsigned __int128 v)
-    : hi_{static_cast<uint64_t>(v >> 64)},
-      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
+    constexpr uint128::uint128(__int128 v) :
+        hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)},
+        lo_{static_cast<uint64_t>(v & ~uint64_t{0})}
+    {
+    }
+    constexpr uint128::uint128(unsigned __int128 v) :
+        hi_{static_cast<uint64_t>(v >> 64)},
+        lo_{static_cast<uint64_t>(v & ~uint64_t{0})}
+    {
+    }
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
-constexpr uint128::uint128(int128 v)
-    : hi_{static_cast<uint64_t>(Int128High64(v))}, lo_{Int128Low64(v)} {}
+    constexpr uint128::uint128(int128 v) :
+        hi_{static_cast<uint64_t>(Int128High64(v))},
+        lo_{Int128Low64(v)}
+    {
+    }
 
 #else  // byte order
 #error "Unsupported byte order: must be little-endian or big-endian."
 #endif  // byte order
 
-// Conversion operators to integer types.
-
-constexpr uint128::operator bool() const { return lo_ || hi_; }
-
-constexpr uint128::operator char() const { return static_cast<char>(lo_); }
-
-constexpr uint128::operator signed char() const {
-  return static_cast<signed char>(lo_);
-}
-
-constexpr uint128::operator unsigned char() const {
-  return static_cast<unsigned char>(lo_);
-}
-
-constexpr uint128::operator char16_t() const {
-  return static_cast<char16_t>(lo_);
-}
-
-constexpr uint128::operator char32_t() const {
-  return static_cast<char32_t>(lo_);
-}
-
-constexpr uint128::operator ABSL_INTERNAL_WCHAR_T() const {
-  return static_cast<ABSL_INTERNAL_WCHAR_T>(lo_);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::operator short() const { return static_cast<short>(lo_); }
-
-constexpr uint128::operator unsigned short() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned short>(lo_);            // NOLINT(runtime/int)
-}
-
-constexpr uint128::operator int() const { return static_cast<int>(lo_); }
-
-constexpr uint128::operator unsigned int() const {
-  return static_cast<unsigned int>(lo_);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::operator long() const { return static_cast<long>(lo_); }
-
-constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
-}
-
-constexpr uint128::operator long long() const {  // NOLINT(runtime/int)
-  return static_cast<long long>(lo_);            // NOLINT(runtime/int)
-}
-
-constexpr uint128::operator unsigned long long() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned long long>(lo_);            // NOLINT(runtime/int)
-}
+    // Conversion operators to integer types.
+
+    constexpr uint128::operator bool() const
+    {
+        return lo_ || hi_;
+    }
+
+    constexpr uint128::operator char() const
+    {
+        return static_cast<char>(lo_);
+    }
+
+    constexpr uint128::operator signed char() const
+    {
+        return static_cast<signed char>(lo_);
+    }
+
+    constexpr uint128::operator unsigned char() const
+    {
+        return static_cast<unsigned char>(lo_);
+    }
+
+    constexpr uint128::operator char16_t() const
+    {
+        return static_cast<char16_t>(lo_);
+    }
+
+    constexpr uint128::operator char32_t() const
+    {
+        return static_cast<char32_t>(lo_);
+    }
+
+    constexpr uint128::operator ABSL_INTERNAL_WCHAR_T() const
+    {
+        return static_cast<ABSL_INTERNAL_WCHAR_T>(lo_);
+    }
+
+    // NOLINTNEXTLINE(runtime/int)
+    constexpr uint128::operator short() const
+    {
+        return static_cast<short>(lo_);
+    }
+
+    constexpr uint128::operator unsigned short() const
+    {                                             // NOLINT(runtime/int)
+        return static_cast<unsigned short>(lo_);  // NOLINT(runtime/int)
+    }
+
+    constexpr uint128::operator int() const
+    {
+        return static_cast<int>(lo_);
+    }
+
+    constexpr uint128::operator unsigned int() const
+    {
+        return static_cast<unsigned int>(lo_);
+    }
+
+    // NOLINTNEXTLINE(runtime/int)
+    constexpr uint128::operator long() const
+    {
+        return static_cast<long>(lo_);
+    }
+
+    constexpr uint128::operator unsigned long() const
+    {                                            // NOLINT(runtime/int)
+        return static_cast<unsigned long>(lo_);  // NOLINT(runtime/int)
+    }
+
+    constexpr uint128::operator long long() const
+    {                                        // NOLINT(runtime/int)
+        return static_cast<long long>(lo_);  // NOLINT(runtime/int)
+    }
+
+    constexpr uint128::operator unsigned long long() const
+    {                                                 // NOLINT(runtime/int)
+        return static_cast<unsigned long long>(lo_);  // NOLINT(runtime/int)
+    }
 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-constexpr uint128::operator __int128() const {
-  return (static_cast<__int128>(hi_) << 64) + lo_;
-}
-
-constexpr uint128::operator unsigned __int128() const {
-  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
-}
+    constexpr uint128::operator __int128() const
+    {
+        return (static_cast<__int128>(hi_) << 64) + lo_;
+    }
+
+    constexpr uint128::operator unsigned __int128() const
+    {
+        return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
+    }
 #endif  // ABSL_HAVE_INTRINSIC_INT128
 
-// Conversion operators to floating point types.
+    // Conversion operators to floating point types.
 
-inline uint128::operator float() const {
-  return static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64);
-}
+    inline uint128::operator float() const
+    {
+        return static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64);
+    }
 
-inline uint128::operator double() const {
-  return static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64);
-}
+    inline uint128::operator double() const
+    {
+        return static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64);
+    }
 
-inline uint128::operator long double() const {
-  return static_cast<long double>(lo_) +
-         std::ldexp(static_cast<long double>(hi_), 64);
-}
+    inline uint128::operator long double() const
+    {
+        return static_cast<long double>(lo_) +
+               std::ldexp(static_cast<long double>(hi_), 64);
+    }
 
-// Comparison operators.
+    // Comparison operators.
 
-constexpr bool operator==(uint128 lhs, uint128 rhs) {
+    constexpr bool operator==(uint128 lhs, uint128 rhs)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) ==
-         static_cast<unsigned __int128>(rhs);
+        return static_cast<unsigned __int128>(lhs) ==
+               static_cast<unsigned __int128>(rhs);
 #else
-  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
-          Uint128High64(lhs) == Uint128High64(rhs));
+        return (Uint128Low64(lhs) == Uint128Low64(rhs) && Uint128High64(lhs) == Uint128High64(rhs));
 #endif
-}
+    }
 
-constexpr bool operator!=(uint128 lhs, uint128 rhs) { return !(lhs == rhs); }
+    constexpr bool operator!=(uint128 lhs, uint128 rhs)
+    {
+        return !(lhs == rhs);
+    }
 
-constexpr bool operator<(uint128 lhs, uint128 rhs) {
+    constexpr bool operator<(uint128 lhs, uint128 rhs)
+    {
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) <
-         static_cast<unsigned __int128>(rhs);
+        return static_cast<unsigned __int128>(lhs) <
+               static_cast<unsigned __int128>(rhs);
 #else
-  return (Uint128High64(lhs) == Uint128High64(rhs))
-             ? (Uint128Low64(lhs) < Uint128Low64(rhs))
-             : (Uint128High64(lhs) < Uint128High64(rhs));
+        return (Uint128High64(lhs) == Uint128High64(rhs)) ? (Uint128Low64(lhs) < Uint128Low64(rhs)) : (Uint128High64(lhs) < Uint128High64(rhs));
 #endif
-}
+    }
 
-constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
+    constexpr bool operator>(uint128 lhs, uint128 rhs)
+    {
+        return rhs < lhs;
+    }
 
-constexpr bool operator<=(uint128 lhs, uint128 rhs) { return !(rhs < lhs); }
+    constexpr bool operator<=(uint128 lhs, uint128 rhs)
+    {
+        return !(rhs < lhs);
+    }
 
-constexpr bool operator>=(uint128 lhs, uint128 rhs) { return !(lhs < rhs); }
+    constexpr bool operator>=(uint128 lhs, uint128 rhs)
+    {
+        return !(lhs < rhs);
+    }
 
-// Unary operators.
+    // Unary operators.
 
-constexpr inline uint128 operator+(uint128 val) {
-  return val;
-}
+    constexpr inline uint128 operator+(uint128 val)
+    {
+        return val;
+    }
 
-constexpr inline int128 operator+(int128 val) {
-  return val;
-}
+    constexpr inline int128 operator+(int128 val)
+    {
+        return val;
+    }
 
-constexpr uint128 operator-(uint128 val) {
+    constexpr uint128 operator-(uint128 val)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return -static_cast<unsigned __int128>(val);
+        return -static_cast<unsigned __int128>(val);
 #else
-  return MakeUint128(
-      ~Uint128High64(val) + static_cast<unsigned long>(Uint128Low64(val) == 0),
-      ~Uint128Low64(val) + 1);
+        return MakeUint128(
+            ~Uint128High64(val) + static_cast<unsigned long>(Uint128Low64(val) == 0),
+            ~Uint128Low64(val) + 1
+        );
 #endif
-}
+    }
 
-constexpr inline bool operator!(uint128 val) {
+    constexpr inline bool operator!(uint128 val)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return !static_cast<unsigned __int128>(val);
+        return !static_cast<unsigned __int128>(val);
 #else
-  return !Uint128High64(val) && !Uint128Low64(val);
+        return !Uint128High64(val) && !Uint128Low64(val);
 #endif
-}
+    }
 
-// Logical operators.
+    // Logical operators.
 
-constexpr inline uint128 operator~(uint128 val) {
+    constexpr inline uint128 operator~(uint128 val)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return ~static_cast<unsigned __int128>(val);
+        return ~static_cast<unsigned __int128>(val);
 #else
-  return MakeUint128(~Uint128High64(val), ~Uint128Low64(val));
+        return MakeUint128(~Uint128High64(val), ~Uint128Low64(val));
 #endif
-}
+    }
 
-constexpr inline uint128 operator|(uint128 lhs, uint128 rhs) {
+    constexpr inline uint128 operator|(uint128 lhs, uint128 rhs)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) |
-         static_cast<unsigned __int128>(rhs);
+        return static_cast<unsigned __int128>(lhs) |
+               static_cast<unsigned __int128>(rhs);
 #else
-  return MakeUint128(Uint128High64(lhs) | Uint128High64(rhs),
-                     Uint128Low64(lhs) | Uint128Low64(rhs));
+        return MakeUint128(Uint128High64(lhs) | Uint128High64(rhs), Uint128Low64(lhs) | Uint128Low64(rhs));
 #endif
-}
+    }
 
-constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
+    constexpr inline uint128 operator&(uint128 lhs, uint128 rhs)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) &
-         static_cast<unsigned __int128>(rhs);
+        return static_cast<unsigned __int128>(lhs) &
+               static_cast<unsigned __int128>(rhs);
 #else
-  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
-                     Uint128Low64(lhs) & Uint128Low64(rhs));
+        return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs), Uint128Low64(lhs) & Uint128Low64(rhs));
 #endif
-}
+    }
 
-constexpr inline uint128 operator^(uint128 lhs, uint128 rhs) {
+    constexpr inline uint128 operator^(uint128 lhs, uint128 rhs)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) ^
-         static_cast<unsigned __int128>(rhs);
+        return static_cast<unsigned __int128>(lhs) ^
+               static_cast<unsigned __int128>(rhs);
 #else
-  return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
-                     Uint128Low64(lhs) ^ Uint128Low64(rhs));
+        return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs), Uint128Low64(lhs) ^ Uint128Low64(rhs));
 #endif
-}
-
-inline uint128& uint128::operator|=(uint128 other) {
-  *this = *this | other;
-  return *this;
-}
-
-inline uint128& uint128::operator&=(uint128 other) {
-  *this = *this & other;
-  return *this;
-}
-
-inline uint128& uint128::operator^=(uint128 other) {
-  *this = *this ^ other;
-  return *this;
-}
-
-// Arithmetic operators.
-
-constexpr uint128 operator<<(uint128 lhs, int amount) {
+    }
+
+    inline uint128& uint128::operator|=(uint128 other)
+    {
+        *this = *this | other;
+        return *this;
+    }
+
+    inline uint128& uint128::operator&=(uint128 other)
+    {
+        *this = *this & other;
+        return *this;
+    }
+
+    inline uint128& uint128::operator^=(uint128 other)
+    {
+        *this = *this ^ other;
+        return *this;
+    }
+
+    // Arithmetic operators.
+
+    constexpr uint128 operator<<(uint128 lhs, int amount)
+    {
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) << amount;
+        return static_cast<unsigned __int128>(lhs) << amount;
 #else
-  // uint64_t shifts of >= 64 are undefined, so we will need some
-  // special-casing.
-  return amount >= 64 ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
-         : amount == 0 ? lhs
-                       : MakeUint128((Uint128High64(lhs) << amount) |
-                                         (Uint128Low64(lhs) >> (64 - amount)),
-                                     Uint128Low64(lhs) << amount);
+        // uint64_t shifts of >= 64 are undefined, so we will need some
+        // special-casing.
+        return amount >= 64 ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0) : amount == 0 ? lhs :
+                                                                                                 MakeUint128((Uint128High64(lhs) << amount) | (Uint128Low64(lhs) >> (64 - amount)), Uint128Low64(lhs) << amount);
 #endif
-}
+    }
 
-constexpr uint128 operator>>(uint128 lhs, int amount) {
+    constexpr uint128 operator>>(uint128 lhs, int amount)
+    {
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) >> amount;
+        return static_cast<unsigned __int128>(lhs) >> amount;
 #else
-  // uint64_t shifts of >= 64 are undefined, so we will need some
-  // special-casing.
-  return amount >= 64 ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
-         : amount == 0 ? lhs
-                       : MakeUint128(Uint128High64(lhs) >> amount,
-                                     (Uint128Low64(lhs) >> amount) |
-                                         (Uint128High64(lhs) << (64 - amount)));
+        // uint64_t shifts of >= 64 are undefined, so we will need some
+        // special-casing.
+        return amount >= 64 ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64)) : amount == 0 ? lhs :
+                                                                                                  MakeUint128(Uint128High64(lhs) >> amount, (Uint128Low64(lhs) >> amount) | (Uint128High64(lhs) << (64 - amount)));
 #endif
-}
+    }
 
 #if !defined(ABSL_HAVE_INTRINSIC_INT128)
-namespace int128_internal {
-constexpr uint128 AddResult(uint128 result, uint128 lhs) {
-  // check for carry
-  return (Uint128Low64(result) < Uint128Low64(lhs))
-             ? MakeUint128(Uint128High64(result) + 1, Uint128Low64(result))
-             : result;
-}
-}  // namespace int128_internal
+    namespace int128_internal
+    {
+        constexpr uint128 AddResult(uint128 result, uint128 lhs)
+        {
+            // check for carry
+            return (Uint128Low64(result) < Uint128Low64(lhs)) ? MakeUint128(Uint128High64(result) + 1, Uint128Low64(result)) : result;
+        }
+    }  // namespace int128_internal
 #endif
 
-constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
+    constexpr uint128 operator+(uint128 lhs, uint128 rhs)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) +
-         static_cast<unsigned __int128>(rhs);
+        return static_cast<unsigned __int128>(lhs) +
+               static_cast<unsigned __int128>(rhs);
 #else
-  return int128_internal::AddResult(
-      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
-                  Uint128Low64(lhs) + Uint128Low64(rhs)),
-      lhs);
+        return int128_internal::AddResult(
+            MakeUint128(Uint128High64(lhs) + Uint128High64(rhs), Uint128Low64(lhs) + Uint128Low64(rhs)),
+            lhs
+        );
 #endif
-}
+    }
 
 #if !defined(ABSL_HAVE_INTRINSIC_INT128)
-namespace int128_internal {
-constexpr uint128 SubstructResult(uint128 result, uint128 lhs, uint128 rhs) {
-  // check for carry
-  return (Uint128Low64(lhs) < Uint128Low64(rhs))
-             ? MakeUint128(Uint128High64(result) - 1, Uint128Low64(result))
-             : result;
-}
-}  // namespace int128_internal
+    namespace int128_internal
+    {
+        constexpr uint128 SubstructResult(uint128 result, uint128 lhs, uint128 rhs)
+        {
+            // check for carry
+            return (Uint128Low64(lhs) < Uint128Low64(rhs)) ? MakeUint128(Uint128High64(result) - 1, Uint128Low64(result)) : result;
+        }
+    }  // namespace int128_internal
 #endif
 
-constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
+    constexpr uint128 operator-(uint128 lhs, uint128 rhs)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) -
-         static_cast<unsigned __int128>(rhs);
+        return static_cast<unsigned __int128>(lhs) -
+               static_cast<unsigned __int128>(rhs);
 #else
-  return int128_internal::SubstructResult(
-      MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
-                  Uint128Low64(lhs) - Uint128Low64(rhs)),
-      lhs, rhs);
+        return int128_internal::SubstructResult(
+            MakeUint128(Uint128High64(lhs) - Uint128High64(rhs), Uint128Low64(lhs) - Uint128Low64(rhs)),
+            lhs,
+            rhs
+        );
 #endif
-}
+    }
 
-inline uint128 operator*(uint128 lhs, uint128 rhs) {
+    inline uint128 operator*(uint128 lhs, uint128 rhs)
+    {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
-  // can be used for uint128 storage.
-  return static_cast<unsigned __int128>(lhs) *
-         static_cast<unsigned __int128>(rhs);
+        // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
+        // can be used for uint128 storage.
+        return static_cast<unsigned __int128>(lhs) *
+               static_cast<unsigned __int128>(rhs);
 #elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
-  uint64_t carry;
-  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
-  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
-                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
-                     low);
+        uint64_t carry;
+        uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
+        return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) + Uint128High64(lhs) * Uint128Low64(rhs) + carry, low);
 #else   // ABSL_HAVE_INTRINSIC128
-  uint64_t a32 = Uint128Low64(lhs) >> 32;
-  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
-  uint64_t b32 = Uint128Low64(rhs) >> 32;
-  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
-  uint128 result =
-      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
-                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
-                  a00 * b00);
-  result += uint128(a32 * b00) << 32;
-  result += uint128(a00 * b32) << 32;
-  return result;
+        uint64_t a32 = Uint128Low64(lhs) >> 32;
+        uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
+        uint64_t b32 = Uint128Low64(rhs) >> 32;
+        uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
+        uint128 result =
+            MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) + Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32, a00 * b00);
+        result += uint128(a32 * b00) << 32;
+        result += uint128(a00 * b32) << 32;
+        return result;
 #endif  // ABSL_HAVE_INTRINSIC128
-}
+    }
 
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-inline uint128 operator/(uint128 lhs, uint128 rhs) {
-  return static_cast<unsigned __int128>(lhs) /
-         static_cast<unsigned __int128>(rhs);
-}
-
-inline uint128 operator%(uint128 lhs, uint128 rhs) {
-  return static_cast<unsigned __int128>(lhs) %
-         static_cast<unsigned __int128>(rhs);
-}
+    inline uint128 operator/(uint128 lhs, uint128 rhs)
+    {
+        return static_cast<unsigned __int128>(lhs) /
+               static_cast<unsigned __int128>(rhs);
+    }
+
+    inline uint128 operator%(uint128 lhs, uint128 rhs)
+    {
+        return static_cast<unsigned __int128>(lhs) %
+               static_cast<unsigned __int128>(rhs);
+    }
 #endif
 
-// Increment/decrement operators.
-
-inline uint128 uint128::operator++(int) {
-  uint128 tmp(*this);
-  *this += 1;
-  return tmp;
-}
-
-inline uint128 uint128::operator--(int) {
-  uint128 tmp(*this);
-  *this -= 1;
-  return tmp;
-}
-
-inline uint128& uint128::operator++() {
-  *this += 1;
-  return *this;
-}
-
-inline uint128& uint128::operator--() {
-  *this -= 1;
-  return *this;
-}
-
-constexpr int128 MakeInt128(int64_t high, uint64_t low) {
-  return int128(high, low);
-}
-
-// Assignment from integer types.
-inline int128& int128::operator=(int v) {
-  return *this = int128(v);
-}
-
-inline int128& int128::operator=(unsigned int v) {
-  return *this = int128(v);
-}
-
-inline int128& int128::operator=(long v) {  // NOLINT(runtime/int)
-  return *this = int128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline int128& int128::operator=(unsigned long v) {
-  return *this = int128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline int128& int128::operator=(long long v) {
-  return *this = int128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline int128& int128::operator=(unsigned long long v) {
-  return *this = int128(v);
-}
-
-// Arithmetic operators.
-constexpr int128 operator-(int128 v);
-constexpr int128 operator+(int128 lhs, int128 rhs);
-constexpr int128 operator-(int128 lhs, int128 rhs);
-int128 operator*(int128 lhs, int128 rhs);
-int128 operator/(int128 lhs, int128 rhs);
-int128 operator%(int128 lhs, int128 rhs);
-constexpr int128 operator|(int128 lhs, int128 rhs);
-constexpr int128 operator&(int128 lhs, int128 rhs);
-constexpr int128 operator^(int128 lhs, int128 rhs);
-constexpr int128 operator<<(int128 lhs, int amount);
-constexpr int128 operator>>(int128 lhs, int amount);
-
-inline int128& int128::operator+=(int128 other) {
-  *this = *this + other;
-  return *this;
-}
-
-inline int128& int128::operator-=(int128 other) {
-  *this = *this - other;
-  return *this;
-}
-
-inline int128& int128::operator*=(int128 other) {
-  *this = *this * other;
-  return *this;
-}
-
-inline int128& int128::operator/=(int128 other) {
-  *this = *this / other;
-  return *this;
-}
-
-inline int128& int128::operator%=(int128 other) {
-  *this = *this % other;
-  return *this;
-}
-
-inline int128& int128::operator|=(int128 other) {
-  *this = *this | other;
-  return *this;
-}
-
-inline int128& int128::operator&=(int128 other) {
-  *this = *this & other;
-  return *this;
-}
-
-inline int128& int128::operator^=(int128 other) {
-  *this = *this ^ other;
-  return *this;
-}
-
-inline int128& int128::operator<<=(int amount) {
-  *this = *this << amount;
-  return *this;
-}
-
-inline int128& int128::operator>>=(int amount) {
-  *this = *this >> amount;
-  return *this;
-}
-
-// Forward declaration for comparison operators.
-constexpr bool operator!=(int128 lhs, int128 rhs);
-
-namespace int128_internal {
-
-// Casts from unsigned to signed while preserving the underlying binary
-// representation.
-constexpr int64_t BitCastToSigned(uint64_t v) {
-  // Casting an unsigned integer to a signed integer of the same
-  // width is implementation defined behavior if the source value would not fit
-  // in the destination type. We step around it with a roundtrip bitwise not
-  // operation to make sure this function remains constexpr. Clang, GCC, and
-  // MSVC optimize this to a no-op on x86-64.
-  return v & (uint64_t{1} << 63) ? ~static_cast<int64_t>(~v)
-                                 : static_cast<int64_t>(v);
-}
-
-}  // namespace int128_internal
+    // Increment/decrement operators.
+
+    inline uint128 uint128::operator++(int)
+    {
+        uint128 tmp(*this);
+        *this += 1;
+        return tmp;
+    }
+
+    inline uint128 uint128::operator--(int)
+    {
+        uint128 tmp(*this);
+        *this -= 1;
+        return tmp;
+    }
+
+    inline uint128& uint128::operator++()
+    {
+        *this += 1;
+        return *this;
+    }
+
+    inline uint128& uint128::operator--()
+    {
+        *this -= 1;
+        return *this;
+    }
+
+    constexpr int128 MakeInt128(int64_t high, uint64_t low)
+    {
+        return int128(high, low);
+    }
+
+    // Assignment from integer types.
+    inline int128& int128::operator=(int v)
+    {
+        return *this = int128(v);
+    }
+
+    inline int128& int128::operator=(unsigned int v)
+    {
+        return *this = int128(v);
+    }
+
+    inline int128& int128::operator=(long v)
+    {  // NOLINT(runtime/int)
+        return *this = int128(v);
+    }
+
+    // NOLINTNEXTLINE(runtime/int)
+    inline int128& int128::operator=(unsigned long v)
+    {
+        return *this = int128(v);
+    }
+
+    // NOLINTNEXTLINE(runtime/int)
+    inline int128& int128::operator=(long long v)
+    {
+        return *this = int128(v);
+    }
+
+    // NOLINTNEXTLINE(runtime/int)
+    inline int128& int128::operator=(unsigned long long v)
+    {
+        return *this = int128(v);
+    }
+
+    // Arithmetic operators.
+    constexpr int128 operator-(int128 v);
+    constexpr int128 operator+(int128 lhs, int128 rhs);
+    constexpr int128 operator-(int128 lhs, int128 rhs);
+    int128 operator*(int128 lhs, int128 rhs);
+    int128 operator/(int128 lhs, int128 rhs);
+    int128 operator%(int128 lhs, int128 rhs);
+    constexpr int128 operator|(int128 lhs, int128 rhs);
+    constexpr int128 operator&(int128 lhs, int128 rhs);
+    constexpr int128 operator^(int128 lhs, int128 rhs);
+    constexpr int128 operator<<(int128 lhs, int amount);
+    constexpr int128 operator>>(int128 lhs, int amount);
+
+    inline int128& int128::operator+=(int128 other)
+    {
+        *this = *this + other;
+        return *this;
+    }
+
+    inline int128& int128::operator-=(int128 other)
+    {
+        *this = *this - other;
+        return *this;
+    }
+
+    inline int128& int128::operator*=(int128 other)
+    {
+        *this = *this * other;
+        return *this;
+    }
+
+    inline int128& int128::operator/=(int128 other)
+    {
+        *this = *this / other;
+        return *this;
+    }
+
+    inline int128& int128::operator%=(int128 other)
+    {
+        *this = *this % other;
+        return *this;
+    }
+
+    inline int128& int128::operator|=(int128 other)
+    {
+        *this = *this | other;
+        return *this;
+    }
+
+    inline int128& int128::operator&=(int128 other)
+    {
+        *this = *this & other;
+        return *this;
+    }
+
+    inline int128& int128::operator^=(int128 other)
+    {
+        *this = *this ^ other;
+        return *this;
+    }
+
+    inline int128& int128::operator<<=(int amount)
+    {
+        *this = *this << amount;
+        return *this;
+    }
+
+    inline int128& int128::operator>>=(int amount)
+    {
+        *this = *this >> amount;
+        return *this;
+    }
+
+    // Forward declaration for comparison operators.
+    constexpr bool operator!=(int128 lhs, int128 rhs);
+
+    namespace int128_internal
+    {
+
+        // Casts from unsigned to signed while preserving the underlying binary
+        // representation.
+        constexpr int64_t BitCastToSigned(uint64_t v)
+        {
+            // Casting an unsigned integer to a signed integer of the same
+            // width is implementation defined behavior if the source value would not fit
+            // in the destination type. We step around it with a roundtrip bitwise not
+            // operation to make sure this function remains constexpr. Clang, GCC, and
+            // MSVC optimize this to a no-op on x86-64.
+            return v & (uint64_t{1} << 63) ? ~static_cast<int64_t>(~v) : static_cast<int64_t>(v);
+        }
+
+    }  // namespace int128_internal
 
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
 #include "absl/numeric/int128_have_intrinsic.inc"  // IWYU pragma: export
-#else  // ABSL_HAVE_INTRINSIC_INT128
-#include "absl/numeric/int128_no_intrinsic.inc"  // IWYU pragma: export
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#else                                              // ABSL_HAVE_INTRINSIC_INT128
+#include "absl/numeric/int128_no_intrinsic.inc"    // IWYU pragma: export
+#endif                                             // ABSL_HAVE_INTRINSIC_INT128
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #undef ABSL_INTERNAL_WCHAR_T
diff --git a/CAPI/cpp/grpc/include/absl/numeric/internal/bits.h b/CAPI/cpp/grpc/include/absl/numeric/internal/bits.h
index bfef06b..15a43ce 100644
--- a/CAPI/cpp/grpc/include/absl/numeric/internal/bits.h
+++ b/CAPI/cpp/grpc/include/absl/numeric/internal/bits.h
@@ -62,297 +62,324 @@
 #define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 0
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace numeric_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace numeric_internal
+    {
 
-constexpr bool IsPowerOf2(unsigned int x) noexcept {
-  return x != 0 && (x & (x - 1)) == 0;
-}
+        constexpr bool IsPowerOf2(unsigned int x) noexcept
+        {
+            return x != 0 && (x & (x - 1)) == 0;
+        }
 
-template <class T>
-ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
-    T x, int s) noexcept {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
+        template<class T>
+        ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
+            T x, int s
+        ) noexcept
+        {
+            static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+            static_assert(IsPowerOf2(std::numeric_limits<T>::digits), "T must have a power-of-2 size");
 
-  return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1)));
-}
+            return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) |
+                   static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1)));
+        }
 
-template <class T>
-ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
-    T x, int s) noexcept {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
+        template<class T>
+        ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
+            T x, int s
+        ) noexcept
+        {
+            static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+            static_assert(IsPowerOf2(std::numeric_limits<T>::digits), "T must have a power-of-2 size");
 
-  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
-}
+            return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
+                   static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
+        }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
-Popcount32(uint32_t x) noexcept {
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+            Popcount32(uint32_t x) noexcept
+        {
 #if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcount)
-  static_assert(sizeof(unsigned int) == sizeof(x),
-                "__builtin_popcount does not take 32-bit arg");
-  return __builtin_popcount(x);
+            static_assert(sizeof(unsigned int) == sizeof(x), "__builtin_popcount does not take 32-bit arg");
+            return __builtin_popcount(x);
 #else
-  x -= ((x >> 1) & 0x55555555);
-  x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
-  return static_cast<int>((((x + (x >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24);
+            x -= ((x >> 1) & 0x55555555);
+            x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
+            return static_cast<int>((((x + (x >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24);
 #endif
-}
+        }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
-Popcount64(uint64_t x) noexcept {
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+            Popcount64(uint64_t x) noexcept
+        {
 #if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
-  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_popcount does not take 64-bit arg");
-  return __builtin_popcountll(x);
+            static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
+                          "__builtin_popcount does not take 64-bit arg");
+            return __builtin_popcountll(x);
 #else
-  x -= (x >> 1) & 0x5555555555555555ULL;
-  x = ((x >> 2) & 0x3333333333333333ULL) + (x & 0x3333333333333333ULL);
-  return static_cast<int>(
-      (((x + (x >> 4)) & 0xF0F0F0F0F0F0F0FULL) * 0x101010101010101ULL) >> 56);
+            x -= (x >> 1) & 0x5555555555555555ULL;
+            x = ((x >> 2) & 0x3333333333333333ULL) + (x & 0x3333333333333333ULL);
+            return static_cast<int>(
+                (((x + (x >> 4)) & 0xF0F0F0F0F0F0F0FULL) * 0x101010101010101ULL) >> 56
+            );
 #endif
-}
+        }
 
-template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
-Popcount(T x) noexcept {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
-  static_assert(sizeof(x) <= sizeof(uint64_t), "T is too large");
-  return sizeof(x) <= sizeof(uint32_t) ? Popcount32(x) : Popcount64(x);
-}
+        template<class T>
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+            Popcount(T x) noexcept
+        {
+            static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+            static_assert(IsPowerOf2(std::numeric_limits<T>::digits), "T must have a power-of-2 size");
+            static_assert(sizeof(x) <= sizeof(uint64_t), "T is too large");
+            return sizeof(x) <= sizeof(uint32_t) ? Popcount32(x) : Popcount64(x);
+        }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
-CountLeadingZeroes32(uint32_t x) {
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+            CountLeadingZeroes32(uint32_t x)
+        {
 #if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz)
-  // Use __builtin_clz, which uses the following instructions:
-  //  x86: bsr, lzcnt
-  //  ARM64: clz
-  //  PPC: cntlzd
+            // Use __builtin_clz, which uses the following instructions:
+            //  x86: bsr, lzcnt
+            //  ARM64: clz
+            //  PPC: cntlzd
 
-  static_assert(sizeof(unsigned int) == sizeof(x),
-                "__builtin_clz does not take 32-bit arg");
-  // Handle 0 as a special case because __builtin_clz(0) is undefined.
-  return x == 0 ? 32 : __builtin_clz(x);
+            static_assert(sizeof(unsigned int) == sizeof(x), "__builtin_clz does not take 32-bit arg");
+            // Handle 0 as a special case because __builtin_clz(0) is undefined.
+            return x == 0 ? 32 : __builtin_clz(x);
 #elif defined(_MSC_VER) && !defined(__clang__)
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  if (_BitScanReverse(&result, x)) {
-    return 31 - result;
-  }
-  return 32;
+            unsigned long result = 0;  // NOLINT(runtime/int)
+            if (_BitScanReverse(&result, x))
+            {
+                return 31 - result;
+            }
+            return 32;
 #else
-  int zeroes = 28;
-  if (x >> 16) {
-    zeroes -= 16;
-    x >>= 16;
-  }
-  if (x >> 8) {
-    zeroes -= 8;
-    x >>= 8;
-  }
-  if (x >> 4) {
-    zeroes -= 4;
-    x >>= 4;
-  }
-  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
+            int zeroes = 28;
+            if (x >> 16)
+            {
+                zeroes -= 16;
+                x >>= 16;
+            }
+            if (x >> 8)
+            {
+                zeroes -= 8;
+                x >>= 8;
+            }
+            if (x >> 4)
+            {
+                zeroes -= 4;
+                x >>= 4;
+            }
+            return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
 #endif
-}
+        }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
-CountLeadingZeroes16(uint16_t x) {
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+            CountLeadingZeroes16(uint16_t x)
+        {
 #if ABSL_HAVE_BUILTIN(__builtin_clzs)
-  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_clzs does not take 16-bit arg");
-  return x == 0 ? 16 : __builtin_clzs(x);
+            static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
+                          "__builtin_clzs does not take 16-bit arg");
+            return x == 0 ? 16 : __builtin_clzs(x);
 #else
-  return CountLeadingZeroes32(x) - 16;
+            return CountLeadingZeroes32(x) - 16;
 #endif
-}
+        }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
-CountLeadingZeroes64(uint64_t x) {
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+            CountLeadingZeroes64(uint64_t x)
+        {
 #if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
-  // Use __builtin_clzll, which uses the following instructions:
-  //  x86: bsr, lzcnt
-  //  ARM64: clz
-  //  PPC: cntlzd
-  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_clzll does not take 64-bit arg");
+            // Use __builtin_clzll, which uses the following instructions:
+            //  x86: bsr, lzcnt
+            //  ARM64: clz
+            //  PPC: cntlzd
+            static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
+                          "__builtin_clzll does not take 64-bit arg");
 
-  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
-  return x == 0 ? 64 : __builtin_clzll(x);
+            // Handle 0 as a special case because __builtin_clzll(0) is undefined.
+            return x == 0 ? 64 : __builtin_clzll(x);
 #elif defined(_MSC_VER) && !defined(__clang__) && \
     (defined(_M_X64) || defined(_M_ARM64))
-  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  if (_BitScanReverse64(&result, x)) {
-    return 63 - result;
-  }
-  return 64;
+            // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
+            unsigned long result = 0;  // NOLINT(runtime/int)
+            if (_BitScanReverse64(&result, x))
+            {
+                return 63 - result;
+            }
+            return 64;
 #elif defined(_MSC_VER) && !defined(__clang__)
-  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  if ((x >> 32) &&
-      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
-    return 31 - result;
-  }
-  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
-    return 63 - result;
-  }
-  return 64;
+            // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
+            unsigned long result = 0;  // NOLINT(runtime/int)
+            if ((x >> 32) &&
+                _BitScanReverse(&result, static_cast<unsigned long>(x >> 32)))
+            {
+                return 31 - result;
+            }
+            if (_BitScanReverse(&result, static_cast<unsigned long>(x)))
+            {
+                return 63 - result;
+            }
+            return 64;
 #else
-  int zeroes = 60;
-  if (x >> 32) {
-    zeroes -= 32;
-    x >>= 32;
-  }
-  if (x >> 16) {
-    zeroes -= 16;
-    x >>= 16;
-  }
-  if (x >> 8) {
-    zeroes -= 8;
-    x >>= 8;
-  }
-  if (x >> 4) {
-    zeroes -= 4;
-    x >>= 4;
-  }
-  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
+            int zeroes = 60;
+            if (x >> 32)
+            {
+                zeroes -= 32;
+                x >>= 32;
+            }
+            if (x >> 16)
+            {
+                zeroes -= 16;
+                x >>= 16;
+            }
+            if (x >> 8)
+            {
+                zeroes -= 8;
+                x >>= 8;
+            }
+            if (x >> 4)
+            {
+                zeroes -= 4;
+                x >>= 4;
+            }
+            return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
 #endif
-}
+        }
 
-template <typename T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
-CountLeadingZeroes(T x) {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
-  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
-  return sizeof(T) <= sizeof(uint16_t)
-             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
-                   (std::numeric_limits<uint16_t>::digits -
-                    std::numeric_limits<T>::digits)
-             : (sizeof(T) <= sizeof(uint32_t)
-                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
-                          (std::numeric_limits<uint32_t>::digits -
-                           std::numeric_limits<T>::digits)
-                    : CountLeadingZeroes64(x));
-}
+        template<typename T>
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+            CountLeadingZeroes(T x)
+        {
+            static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+            static_assert(IsPowerOf2(std::numeric_limits<T>::digits), "T must have a power-of-2 size");
+            static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
+            return sizeof(T) <= sizeof(uint16_t) ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
+                                                       (std::numeric_limits<uint16_t>::digits -
+                                                        std::numeric_limits<T>::digits) :
+                                                   (sizeof(T) <= sizeof(uint32_t) ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
+                                                                                        (std::numeric_limits<uint32_t>::digits -
+                                                                                         std::numeric_limits<T>::digits) :
+                                                                                    CountLeadingZeroes64(x));
+        }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
-CountTrailingZeroesNonzero32(uint32_t x) {
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+            CountTrailingZeroesNonzero32(uint32_t x)
+        {
 #if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
-  static_assert(sizeof(unsigned int) == sizeof(x),
-                "__builtin_ctz does not take 32-bit arg");
-  return __builtin_ctz(x);
+            static_assert(sizeof(unsigned int) == sizeof(x), "__builtin_ctz does not take 32-bit arg");
+            return __builtin_ctz(x);
 #elif defined(_MSC_VER) && !defined(__clang__)
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  _BitScanForward(&result, x);
-  return result;
+            unsigned long result = 0;  // NOLINT(runtime/int)
+            _BitScanForward(&result, x);
+            return result;
 #else
-  int c = 31;
-  x &= ~x + 1;
-  if (x & 0x0000FFFF) c -= 16;
-  if (x & 0x00FF00FF) c -= 8;
-  if (x & 0x0F0F0F0F) c -= 4;
-  if (x & 0x33333333) c -= 2;
-  if (x & 0x55555555) c -= 1;
-  return c;
+            int c = 31;
+            x &= ~x + 1;
+            if (x & 0x0000FFFF)
+                c -= 16;
+            if (x & 0x00FF00FF)
+                c -= 8;
+            if (x & 0x0F0F0F0F)
+                c -= 4;
+            if (x & 0x33333333)
+                c -= 2;
+            if (x & 0x55555555)
+                c -= 1;
+            return c;
 #endif
-}
+        }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
-CountTrailingZeroesNonzero64(uint64_t x) {
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+            CountTrailingZeroesNonzero64(uint64_t x)
+        {
 #if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
-  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_ctzll does not take 64-bit arg");
-  return __builtin_ctzll(x);
+            static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
+                          "__builtin_ctzll does not take 64-bit arg");
+            return __builtin_ctzll(x);
 #elif defined(_MSC_VER) && !defined(__clang__) && \
     (defined(_M_X64) || defined(_M_ARM64))
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  _BitScanForward64(&result, x);
-  return result;
+            unsigned long result = 0;  // NOLINT(runtime/int)
+            _BitScanForward64(&result, x);
+            return result;
 #elif defined(_MSC_VER) && !defined(__clang__)
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  if (static_cast<uint32_t>(x) == 0) {
-    _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
-    return result + 32;
-  }
-  _BitScanForward(&result, static_cast<unsigned long>(x));
-  return result;
+            unsigned long result = 0;  // NOLINT(runtime/int)
+            if (static_cast<uint32_t>(x) == 0)
+            {
+                _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
+                return result + 32;
+            }
+            _BitScanForward(&result, static_cast<unsigned long>(x));
+            return result;
 #else
-  int c = 63;
-  x &= ~x + 1;
-  if (x & 0x00000000FFFFFFFF) c -= 32;
-  if (x & 0x0000FFFF0000FFFF) c -= 16;
-  if (x & 0x00FF00FF00FF00FF) c -= 8;
-  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4;
-  if (x & 0x3333333333333333) c -= 2;
-  if (x & 0x5555555555555555) c -= 1;
-  return c;
+            int c = 63;
+            x &= ~x + 1;
+            if (x & 0x00000000FFFFFFFF)
+                c -= 32;
+            if (x & 0x0000FFFF0000FFFF)
+                c -= 16;
+            if (x & 0x00FF00FF00FF00FF)
+                c -= 8;
+            if (x & 0x0F0F0F0F0F0F0F0F)
+                c -= 4;
+            if (x & 0x3333333333333333)
+                c -= 2;
+            if (x & 0x5555555555555555)
+                c -= 1;
+            return c;
 #endif
-}
+        }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
-CountTrailingZeroesNonzero16(uint16_t x) {
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+            CountTrailingZeroesNonzero16(uint16_t x)
+        {
 #if ABSL_HAVE_BUILTIN(__builtin_ctzs)
-  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_ctzs does not take 16-bit arg");
-  return __builtin_ctzs(x);
+            static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
+                          "__builtin_ctzs does not take 16-bit arg");
+            return __builtin_ctzs(x);
 #else
-  return CountTrailingZeroesNonzero32(x);
+            return CountTrailingZeroesNonzero32(x);
 #endif
-}
+        }
 
-template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
-CountTrailingZeroes(T x) noexcept {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
-  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
-  return x == 0 ? std::numeric_limits<T>::digits
-                : (sizeof(T) <= sizeof(uint16_t)
-                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
-                       : (sizeof(T) <= sizeof(uint32_t)
-                              ? CountTrailingZeroesNonzero32(
-                                    static_cast<uint32_t>(x))
-                              : CountTrailingZeroesNonzero64(x)));
-}
+        template<class T>
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+            CountTrailingZeroes(T x) noexcept
+        {
+            static_assert(std::is_unsigned<T>::value, "T must be unsigned");
+            static_assert(IsPowerOf2(std::numeric_limits<T>::digits), "T must have a power-of-2 size");
+            static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
+            return x == 0 ? std::numeric_limits<T>::digits : (sizeof(T) <= sizeof(uint16_t) ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x)) : (sizeof(T) <= sizeof(uint32_t) ? CountTrailingZeroesNonzero32(static_cast<uint32_t>(x)) : CountTrailingZeroesNonzero64(x)));
+        }
 
-// If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
-// want to force it to wraparound so that bit_ceil of an invalid value are not
-// core constant expressions.
-template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    BitCeilPromotionHelper(T x, T promotion) {
-  return (T{1} << (x + promotion)) >> promotion;
-}
+        // If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
+        // want to force it to wraparound so that bit_ceil of an invalid value are not
+        // core constant expressions.
+        template<class T>
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
+            typename std::enable_if<std::is_unsigned<T>::value, T>::type
+            BitCeilPromotionHelper(T x, T promotion)
+        {
+            return (T{1} << (x + promotion)) >> promotion;
+        }
 
-template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    BitCeilNonPowerOf2(T x) {
-  // If T is narrower than unsigned, it undergoes promotion to unsigned when we
-  // shift.  We calculate the number of bits added by the wider type.
-  return BitCeilPromotionHelper(
-      static_cast<T>(std::numeric_limits<T>::digits - CountLeadingZeroes(x)),
-      T{sizeof(T) >= sizeof(unsigned) ? 0
-                                      : std::numeric_limits<unsigned>::digits -
-                                            std::numeric_limits<T>::digits});
-}
+        template<class T>
+        ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
+            typename std::enable_if<std::is_unsigned<T>::value, T>::type
+            BitCeilNonPowerOf2(T x)
+        {
+            // If T is narrower than unsigned, it undergoes promotion to unsigned when we
+            // shift.  We calculate the number of bits added by the wider type.
+            return BitCeilPromotionHelper(
+                static_cast<T>(std::numeric_limits<T>::digits - CountLeadingZeroes(x)),
+                T{sizeof(T) >= sizeof(unsigned) ? 0 : std::numeric_limits<unsigned>::digits - std::numeric_limits<T>::digits}
+            );
+        }
 
-}  // namespace numeric_internal
-ABSL_NAMESPACE_END
+    }  // namespace numeric_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_NUMERIC_INTERNAL_BITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/numeric/internal/representation.h b/CAPI/cpp/grpc/include/absl/numeric/internal/representation.h
index 82d332f..22a17a7 100644
--- a/CAPI/cpp/grpc/include/absl/numeric/internal/representation.h
+++ b/CAPI/cpp/grpc/include/absl/numeric/internal/representation.h
@@ -19,37 +19,40 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace numeric_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace numeric_internal
+    {
 
-// Returns true iff long double is represented as a pair of doubles added
-// together.
-inline constexpr bool IsDoubleDouble() {
-  // A double-double value always has exactly twice the precision of a double
-  // value--one double carries the high digits and one double carries the low
-  // digits. This property is not shared with any other common floating-point
-  // representation, so this test won't trigger false positives. For reference,
-  // this table gives the number of bits of precision of each common
-  // floating-point representation:
-  //
-  //                type     precision
-  //         IEEE single          24 b
-  //         IEEE double          53
-  //     x86 long double          64
-  //       double-double         106
-  //      IEEE quadruple         113
-  //
-  // Note in particular that a quadruple-precision float has greater precision
-  // than a double-double float despite taking up the same amount of memory; the
-  // quad has more of its bits allocated to the mantissa than the double-double
-  // has.
-  return std::numeric_limits<long double>::digits ==
-         2 * std::numeric_limits<double>::digits;
-}
+        // Returns true iff long double is represented as a pair of doubles added
+        // together.
+        inline constexpr bool IsDoubleDouble()
+        {
+            // A double-double value always has exactly twice the precision of a double
+            // value--one double carries the high digits and one double carries the low
+            // digits. This property is not shared with any other common floating-point
+            // representation, so this test won't trigger false positives. For reference,
+            // this table gives the number of bits of precision of each common
+            // floating-point representation:
+            //
+            //                type     precision
+            //         IEEE single          24 b
+            //         IEEE double          53
+            //     x86 long double          64
+            //       double-double         106
+            //      IEEE quadruple         113
+            //
+            // Note in particular that a quadruple-precision float has greater precision
+            // than a double-double float despite taking up the same amount of memory; the
+            // quad has more of its bits allocated to the mantissa than the double-double
+            // has.
+            return std::numeric_limits<long double>::digits ==
+                   2 * std::numeric_limits<double>::digits;
+        }
 
-}  // namespace numeric_internal
-ABSL_NAMESPACE_END
+    }  // namespace numeric_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
diff --git a/CAPI/cpp/grpc/include/absl/profiling/internal/exponential_biased.h b/CAPI/cpp/grpc/include/absl/profiling/internal/exponential_biased.h
index d31f778..a9eb04c 100644
--- a/CAPI/cpp/grpc/include/absl/profiling/internal/exponential_biased.h
+++ b/CAPI/cpp/grpc/include/absl/profiling/internal/exponential_biased.h
@@ -20,111 +20,115 @@
 #include "absl/base/config.h"
 #include "absl/base/macros.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace profiling_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace profiling_internal
+    {
 
-// ExponentialBiased provides a small and fast random number generator for a
-// rounded exponential distribution. This generator manages very little state,
-// and imposes no synchronization overhead. This makes it useful in specialized
-// scenarios requiring minimum overhead, such as stride based periodic sampling.
-//
-// ExponentialBiased provides two closely related functions, GetSkipCount() and
-// GetStride(), both returning a rounded integer defining a number of events
-// required before some event with a given mean probability occurs.
-//
-// The distribution is useful to generate a random wait time or some periodic
-// event with a given mean probability. For example, if an action is supposed to
-// happen on average once every 'N' events, then we can get a random 'stride'
-// counting down how long before the event to happen. For example, if we'd want
-// to sample one in every 1000 'Frobber' calls, our code could look like this:
-//
-//   Frobber::Frobber() {
-//     stride_ = exponential_biased_.GetStride(1000);
-//   }
-//
-//   void Frobber::Frob(int arg) {
-//     if (--stride == 0) {
-//       SampleFrob(arg);
-//       stride_ = exponential_biased_.GetStride(1000);
-//     }
-//     ...
-//   }
-//
-// The rounding of the return value creates a bias, especially for smaller means
-// where the distribution of the fraction is not evenly distributed. We correct
-// this bias by tracking the fraction we rounded up or down on each iteration,
-// effectively tracking the distance between the cumulative value, and the
-// rounded cumulative value. For example, given a mean of 2:
-//
-//   raw = 1.63076, cumulative = 1.63076, rounded = 2, bias = -0.36923
-//   raw = 0.14624, cumulative = 1.77701, rounded = 2, bias =  0.14624
-//   raw = 4.93194, cumulative = 6.70895, rounded = 7, bias = -0.06805
-//   raw = 0.24206, cumulative = 6.95101, rounded = 7, bias =  0.24206
-//   etc...
-//
-// Adjusting with rounding bias is relatively trivial:
-//
-//    double value = bias_ + exponential_distribution(mean)();
-//    double rounded_value = std::rint(value);
-//    bias_ = value - rounded_value;
-//    return rounded_value;
-//
-// This class is thread-compatible.
-class ExponentialBiased {
- public:
-  // The number of bits set by NextRandom.
-  static constexpr int kPrngNumBits = 48;
+        // ExponentialBiased provides a small and fast random number generator for a
+        // rounded exponential distribution. This generator manages very little state,
+        // and imposes no synchronization overhead. This makes it useful in specialized
+        // scenarios requiring minimum overhead, such as stride based periodic sampling.
+        //
+        // ExponentialBiased provides two closely related functions, GetSkipCount() and
+        // GetStride(), both returning a rounded integer defining a number of events
+        // required before some event with a given mean probability occurs.
+        //
+        // The distribution is useful to generate a random wait time or some periodic
+        // event with a given mean probability. For example, if an action is supposed to
+        // happen on average once every 'N' events, then we can get a random 'stride'
+        // counting down how long before the event to happen. For example, if we'd want
+        // to sample one in every 1000 'Frobber' calls, our code could look like this:
+        //
+        //   Frobber::Frobber() {
+        //     stride_ = exponential_biased_.GetStride(1000);
+        //   }
+        //
+        //   void Frobber::Frob(int arg) {
+        //     if (--stride == 0) {
+        //       SampleFrob(arg);
+        //       stride_ = exponential_biased_.GetStride(1000);
+        //     }
+        //     ...
+        //   }
+        //
+        // The rounding of the return value creates a bias, especially for smaller means
+        // where the distribution of the fraction is not evenly distributed. We correct
+        // this bias by tracking the fraction we rounded up or down on each iteration,
+        // effectively tracking the distance between the cumulative value, and the
+        // rounded cumulative value. For example, given a mean of 2:
+        //
+        //   raw = 1.63076, cumulative = 1.63076, rounded = 2, bias = -0.36923
+        //   raw = 0.14624, cumulative = 1.77701, rounded = 2, bias =  0.14624
+        //   raw = 4.93194, cumulative = 6.70895, rounded = 7, bias = -0.06805
+        //   raw = 0.24206, cumulative = 6.95101, rounded = 7, bias =  0.24206
+        //   etc...
+        //
+        // Adjusting with rounding bias is relatively trivial:
+        //
+        //    double value = bias_ + exponential_distribution(mean)();
+        //    double rounded_value = std::rint(value);
+        //    bias_ = value - rounded_value;
+        //    return rounded_value;
+        //
+        // This class is thread-compatible.
+        class ExponentialBiased
+        {
+        public:
+            // The number of bits set by NextRandom.
+            static constexpr int kPrngNumBits = 48;
 
-  // `GetSkipCount()` returns the number of events to skip before some chosen
-  // event happens. For example, randomly tossing a coin, we will on average
-  // throw heads once before we get tails. We can simulate random coin tosses
-  // using GetSkipCount() as:
-  //
-  //   ExponentialBiased eb;
-  //   for (...) {
-  //     int number_of_heads_before_tail = eb.GetSkipCount(1);
-  //     for (int flips = 0; flips < number_of_heads_before_tail; ++flips) {
-  //       printf("head...");
-  //     }
-  //     printf("tail\n");
-  //   }
-  //
-  int64_t GetSkipCount(int64_t mean);
+            // `GetSkipCount()` returns the number of events to skip before some chosen
+            // event happens. For example, randomly tossing a coin, we will on average
+            // throw heads once before we get tails. We can simulate random coin tosses
+            // using GetSkipCount() as:
+            //
+            //   ExponentialBiased eb;
+            //   for (...) {
+            //     int number_of_heads_before_tail = eb.GetSkipCount(1);
+            //     for (int flips = 0; flips < number_of_heads_before_tail; ++flips) {
+            //       printf("head...");
+            //     }
+            //     printf("tail\n");
+            //   }
+            //
+            int64_t GetSkipCount(int64_t mean);
 
-  // GetStride() returns the number of events required for a specific event to
-  // happen. See the class comments for a usage example. `GetStride()` is
-  // equivalent to `GetSkipCount(mean - 1) + 1`. When to use `GetStride()` or
-  // `GetSkipCount()` depends mostly on what best fits the use case.
-  int64_t GetStride(int64_t mean);
+            // GetStride() returns the number of events required for a specific event to
+            // happen. See the class comments for a usage example. `GetStride()` is
+            // equivalent to `GetSkipCount(mean - 1) + 1`. When to use `GetStride()` or
+            // `GetSkipCount()` depends mostly on what best fits the use case.
+            int64_t GetStride(int64_t mean);
 
-  // Computes a random number in the range [0, 1<<(kPrngNumBits+1) - 1]
-  //
-  // This is public to enable testing.
-  static uint64_t NextRandom(uint64_t rnd);
+            // Computes a random number in the range [0, 1<<(kPrngNumBits+1) - 1]
+            //
+            // This is public to enable testing.
+            static uint64_t NextRandom(uint64_t rnd);
 
- private:
-  void Initialize();
+        private:
+            void Initialize();
 
-  uint64_t rng_{0};
-  double bias_{0};
-  bool initialized_{false};
-};
+            uint64_t rng_{0};
+            double bias_{0};
+            bool initialized_{false};
+        };
 
-// Returns the next prng value.
-// pRNG is: aX+b mod c with a = 0x5DEECE66D, b =  0xB, c = 1<<48
-// This is the lrand64 generator.
-inline uint64_t ExponentialBiased::NextRandom(uint64_t rnd) {
-  const uint64_t prng_mult = uint64_t{0x5DEECE66D};
-  const uint64_t prng_add = 0xB;
-  const uint64_t prng_mod_power = 48;
-  const uint64_t prng_mod_mask =
-      ~((~static_cast<uint64_t>(0)) << prng_mod_power);
-  return (prng_mult * rnd + prng_add) & prng_mod_mask;
-}
+        // Returns the next prng value.
+        // pRNG is: aX+b mod c with a = 0x5DEECE66D, b =  0xB, c = 1<<48
+        // This is the lrand64 generator.
+        inline uint64_t ExponentialBiased::NextRandom(uint64_t rnd)
+        {
+            const uint64_t prng_mult = uint64_t{0x5DEECE66D};
+            const uint64_t prng_add = 0xB;
+            const uint64_t prng_mod_power = 48;
+            const uint64_t prng_mod_mask =
+                ~((~static_cast<uint64_t>(0)) << prng_mod_power);
+            return (prng_mult * rnd + prng_add) & prng_mod_mask;
+        }
 
-}  // namespace profiling_internal
-ABSL_NAMESPACE_END
+    }  // namespace profiling_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
diff --git a/CAPI/cpp/grpc/include/absl/profiling/internal/periodic_sampler.h b/CAPI/cpp/grpc/include/absl/profiling/internal/periodic_sampler.h
index 54f0af4..22638da 100644
--- a/CAPI/cpp/grpc/include/absl/profiling/internal/periodic_sampler.h
+++ b/CAPI/cpp/grpc/include/absl/profiling/internal/periodic_sampler.h
@@ -22,190 +22,198 @@
 #include "absl/base/optimization.h"
 #include "absl/profiling/internal/exponential_biased.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace profiling_internal {
-
-// PeriodicSamplerBase provides the basic period sampler implementation.
-//
-// This is the base class for the templated PeriodicSampler class, which holds
-// a global std::atomic value identified by a user defined tag, such that
-// each specific PeriodSampler implementation holds its own global period.
-//
-// PeriodicSamplerBase is thread-compatible except where stated otherwise.
-class PeriodicSamplerBase {
- public:
-  // PeriodicSamplerBase is trivial / copyable / movable / destructible.
-  PeriodicSamplerBase() = default;
-  PeriodicSamplerBase(PeriodicSamplerBase&&) = default;
-  PeriodicSamplerBase(const PeriodicSamplerBase&) = default;
-
-  // Returns true roughly once every `period` calls. This is established by a
-  // randomly picked `stride` that is counted down on each call to `Sample`.
-  // This stride is picked such that the probability of `Sample()` returning
-  // true is 1 in `period`.
-  inline bool Sample() noexcept;
-
-  // The below methods are intended for optimized use cases where the
-  // size of the inlined fast path code is highly important. Applications
-  // should use the `Sample()` method unless they have proof that their
-  // specific use case requires the optimizations offered by these methods.
-  //
-  // An example of such a use case is SwissTable sampling. All sampling checks
-  // are in inlined SwissTable methods, and the number of call sites is huge.
-  // In this case, the inlined code size added to each translation unit calling
-  // SwissTable methods is non-trivial.
-  //
-  // The `SubtleMaybeSample()` function spuriously returns true even if the
-  // function should not be sampled, applications MUST match each call to
-  // 'SubtleMaybeSample()' returning true with a `SubtleConfirmSample()` call,
-  // and use the result of the latter as the sampling decision.
-  // In other words: the code should logically be equivalent to:
-  //
-  //    if (SubtleMaybeSample() && SubtleConfirmSample()) {
-  //      // Sample this call
-  //    }
-  //
-  // In the 'inline-size' optimized case, the `SubtleConfirmSample()` call can
-  // be placed out of line, for example, the typical use case looks as follows:
-  //
-  //   // --- frobber.h -----------
-  //   void FrobberSampled();
-  //
-  //   inline void FrobberImpl() {
-  //     // ...
-  //   }
-  //
-  //   inline void Frobber() {
-  //     if (ABSL_PREDICT_FALSE(sampler.SubtleMaybeSample())) {
-  //       FrobberSampled();
-  //     } else {
-  //       FrobberImpl();
-  //     }
-  //   }
-  //
-  //   // --- frobber.cc -----------
-  //   void FrobberSampled() {
-  //     if (!sampler.SubtleConfirmSample())) {
-  //       // Spurious false positive
-  //       FrobberImpl();
-  //       return;
-  //     }
-  //
-  //     // Sampled execution
-  //     // ...
-  //   }
-  inline bool SubtleMaybeSample() noexcept;
-  bool SubtleConfirmSample() noexcept;
-
- protected:
-  // We explicitly don't use a virtual destructor as this class is never
-  // virtually destroyed, and it keeps the class trivial, which avoids TLS
-  // prologue and epilogue code for our TLS instances.
-  ~PeriodicSamplerBase() = default;
-
-  // Returns the next stride for our sampler.
-  // This function is virtual for testing purposes only.
-  virtual int64_t GetExponentialBiased(int period) noexcept;
-
- private:
-  // Returns the current period of this sampler. Thread-safe.
-  virtual int period() const noexcept = 0;
-
-  // Keep and decrement stride_ as an unsigned integer, but compare the value
-  // to zero casted as a signed int. clang and msvc do not create optimum code
-  // if we use signed for the combined decrement and sign comparison.
-  //
-  // Below 3 alternative options, all compiles generate the best code
-  // using the unsigned increment <---> signed int comparison option.
-  //
-  // Option 1:
-  //   int64_t stride_;
-  //   if (ABSL_PREDICT_TRUE(++stride_ < 0)) { ... }
-  //
-  //   GCC   x64 (OK) : https://gcc.godbolt.org/z/R5MzzA
-  //   GCC   ppc (OK) : https://gcc.godbolt.org/z/z7NZAt
-  //   Clang x64 (BAD): https://gcc.godbolt.org/z/t4gPsd
-  //   ICC   x64 (OK) : https://gcc.godbolt.org/z/rE6s8W
-  //   MSVC  x64 (OK) : https://gcc.godbolt.org/z/ARMXqS
-  //
-  // Option 2:
-  //   int64_t stride_ = 0;
-  //   if (ABSL_PREDICT_TRUE(--stride_ >= 0)) { ... }
-  //
-  //   GCC   x64 (OK) : https://gcc.godbolt.org/z/jSQxYK
-  //   GCC   ppc (OK) : https://gcc.godbolt.org/z/VJdYaA
-  //   Clang x64 (BAD): https://gcc.godbolt.org/z/Xm4NjX
-  //   ICC   x64 (OK) : https://gcc.godbolt.org/z/4snaFd
-  //   MSVC  x64 (BAD): https://gcc.godbolt.org/z/BgnEKE
-  //
-  // Option 3:
-  //   uint64_t stride_;
-  //   if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) { ... }
-  //
-  //   GCC   x64 (OK) : https://gcc.godbolt.org/z/bFbfPy
-  //   GCC   ppc (OK) : https://gcc.godbolt.org/z/S9KkUE
-  //   Clang x64 (OK) : https://gcc.godbolt.org/z/UYzRb4
-  //   ICC   x64 (OK) : https://gcc.godbolt.org/z/ptTNfD
-  //   MSVC  x64 (OK) : https://gcc.godbolt.org/z/76j4-5
-  uint64_t stride_ = 0;
-  absl::profiling_internal::ExponentialBiased rng_;
-};
-
-inline bool PeriodicSamplerBase::SubtleMaybeSample() noexcept {
-  // See comments on `stride_` for the unsigned increment / signed compare.
-  if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) {
-    return false;
-  }
-  return true;
-}
-
-inline bool PeriodicSamplerBase::Sample() noexcept {
-  return ABSL_PREDICT_FALSE(SubtleMaybeSample()) ? SubtleConfirmSample()
-                                                 : false;
-}
-
-// PeriodicSampler is a concreted periodic sampler implementation.
-// The user provided Tag identifies the implementation, and is required to
-// isolate the global state of this instance from other instances.
-//
-// Typical use case:
-//
-//   struct HashTablezTag {};
-//   thread_local PeriodicSampler sampler;
-//
-//   void HashTableSamplingLogic(...) {
-//     if (sampler.Sample()) {
-//       HashTableSlowSamplePath(...);
-//     }
-//   }
-//
-template <typename Tag, int default_period = 0>
-class PeriodicSampler final : public PeriodicSamplerBase {
- public:
-  ~PeriodicSampler() = default;
-
-  int period() const noexcept final {
-    return period_.load(std::memory_order_relaxed);
-  }
-
-  // Sets the global period for this sampler. Thread-safe.
-  // Setting a period of 0 disables the sampler, i.e., every call to Sample()
-  // will return false. Setting a period of 1 puts the sampler in 'always on'
-  // mode, i.e., every call to Sample() returns true.
-  static void SetGlobalPeriod(int period) {
-    period_.store(period, std::memory_order_relaxed);
-  }
-
- private:
-  static std::atomic<int> period_;
-};
-
-template <typename Tag, int default_period>
-std::atomic<int> PeriodicSampler<Tag, default_period>::period_(default_period);
-
-}  // namespace profiling_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace profiling_internal
+    {
+
+        // PeriodicSamplerBase provides the basic period sampler implementation.
+        //
+        // This is the base class for the templated PeriodicSampler class, which holds
+        // a global std::atomic value identified by a user defined tag, such that
+        // each specific PeriodSampler implementation holds its own global period.
+        //
+        // PeriodicSamplerBase is thread-compatible except where stated otherwise.
+        class PeriodicSamplerBase
+        {
+        public:
+            // PeriodicSamplerBase is trivial / copyable / movable / destructible.
+            PeriodicSamplerBase() = default;
+            PeriodicSamplerBase(PeriodicSamplerBase&&) = default;
+            PeriodicSamplerBase(const PeriodicSamplerBase&) = default;
+
+            // Returns true roughly once every `period` calls. This is established by a
+            // randomly picked `stride` that is counted down on each call to `Sample`.
+            // This stride is picked such that the probability of `Sample()` returning
+            // true is 1 in `period`.
+            inline bool Sample() noexcept;
+
+            // The below methods are intended for optimized use cases where the
+            // size of the inlined fast path code is highly important. Applications
+            // should use the `Sample()` method unless they have proof that their
+            // specific use case requires the optimizations offered by these methods.
+            //
+            // An example of such a use case is SwissTable sampling. All sampling checks
+            // are in inlined SwissTable methods, and the number of call sites is huge.
+            // In this case, the inlined code size added to each translation unit calling
+            // SwissTable methods is non-trivial.
+            //
+            // The `SubtleMaybeSample()` function spuriously returns true even if the
+            // function should not be sampled, applications MUST match each call to
+            // 'SubtleMaybeSample()' returning true with a `SubtleConfirmSample()` call,
+            // and use the result of the latter as the sampling decision.
+            // In other words: the code should logically be equivalent to:
+            //
+            //    if (SubtleMaybeSample() && SubtleConfirmSample()) {
+            //      // Sample this call
+            //    }
+            //
+            // In the 'inline-size' optimized case, the `SubtleConfirmSample()` call can
+            // be placed out of line, for example, the typical use case looks as follows:
+            //
+            //   // --- frobber.h -----------
+            //   void FrobberSampled();
+            //
+            //   inline void FrobberImpl() {
+            //     // ...
+            //   }
+            //
+            //   inline void Frobber() {
+            //     if (ABSL_PREDICT_FALSE(sampler.SubtleMaybeSample())) {
+            //       FrobberSampled();
+            //     } else {
+            //       FrobberImpl();
+            //     }
+            //   }
+            //
+            //   // --- frobber.cc -----------
+            //   void FrobberSampled() {
+            //     if (!sampler.SubtleConfirmSample())) {
+            //       // Spurious false positive
+            //       FrobberImpl();
+            //       return;
+            //     }
+            //
+            //     // Sampled execution
+            //     // ...
+            //   }
+            inline bool SubtleMaybeSample() noexcept;
+            bool SubtleConfirmSample() noexcept;
+
+        protected:
+            // We explicitly don't use a virtual destructor as this class is never
+            // virtually destroyed, and it keeps the class trivial, which avoids TLS
+            // prologue and epilogue code for our TLS instances.
+            ~PeriodicSamplerBase() = default;
+
+            // Returns the next stride for our sampler.
+            // This function is virtual for testing purposes only.
+            virtual int64_t GetExponentialBiased(int period) noexcept;
+
+        private:
+            // Returns the current period of this sampler. Thread-safe.
+            virtual int period() const noexcept = 0;
+
+            // Keep and decrement stride_ as an unsigned integer, but compare the value
+            // to zero casted as a signed int. clang and msvc do not create optimum code
+            // if we use signed for the combined decrement and sign comparison.
+            //
+            // Below 3 alternative options, all compiles generate the best code
+            // using the unsigned increment <---> signed int comparison option.
+            //
+            // Option 1:
+            //   int64_t stride_;
+            //   if (ABSL_PREDICT_TRUE(++stride_ < 0)) { ... }
+            //
+            //   GCC   x64 (OK) : https://gcc.godbolt.org/z/R5MzzA
+            //   GCC   ppc (OK) : https://gcc.godbolt.org/z/z7NZAt
+            //   Clang x64 (BAD): https://gcc.godbolt.org/z/t4gPsd
+            //   ICC   x64 (OK) : https://gcc.godbolt.org/z/rE6s8W
+            //   MSVC  x64 (OK) : https://gcc.godbolt.org/z/ARMXqS
+            //
+            // Option 2:
+            //   int64_t stride_ = 0;
+            //   if (ABSL_PREDICT_TRUE(--stride_ >= 0)) { ... }
+            //
+            //   GCC   x64 (OK) : https://gcc.godbolt.org/z/jSQxYK
+            //   GCC   ppc (OK) : https://gcc.godbolt.org/z/VJdYaA
+            //   Clang x64 (BAD): https://gcc.godbolt.org/z/Xm4NjX
+            //   ICC   x64 (OK) : https://gcc.godbolt.org/z/4snaFd
+            //   MSVC  x64 (BAD): https://gcc.godbolt.org/z/BgnEKE
+            //
+            // Option 3:
+            //   uint64_t stride_;
+            //   if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) { ... }
+            //
+            //   GCC   x64 (OK) : https://gcc.godbolt.org/z/bFbfPy
+            //   GCC   ppc (OK) : https://gcc.godbolt.org/z/S9KkUE
+            //   Clang x64 (OK) : https://gcc.godbolt.org/z/UYzRb4
+            //   ICC   x64 (OK) : https://gcc.godbolt.org/z/ptTNfD
+            //   MSVC  x64 (OK) : https://gcc.godbolt.org/z/76j4-5
+            uint64_t stride_ = 0;
+            absl::profiling_internal::ExponentialBiased rng_;
+        };
+
+        inline bool PeriodicSamplerBase::SubtleMaybeSample() noexcept
+        {
+            // See comments on `stride_` for the unsigned increment / signed compare.
+            if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0))
+            {
+                return false;
+            }
+            return true;
+        }
+
+        inline bool PeriodicSamplerBase::Sample() noexcept
+        {
+            return ABSL_PREDICT_FALSE(SubtleMaybeSample()) ? SubtleConfirmSample() : false;
+        }
+
+        // PeriodicSampler is a concreted periodic sampler implementation.
+        // The user provided Tag identifies the implementation, and is required to
+        // isolate the global state of this instance from other instances.
+        //
+        // Typical use case:
+        //
+        //   struct HashTablezTag {};
+        //   thread_local PeriodicSampler sampler;
+        //
+        //   void HashTableSamplingLogic(...) {
+        //     if (sampler.Sample()) {
+        //       HashTableSlowSamplePath(...);
+        //     }
+        //   }
+        //
+        template<typename Tag, int default_period = 0>
+        class PeriodicSampler final : public PeriodicSamplerBase
+        {
+        public:
+            ~PeriodicSampler() = default;
+
+            int period() const noexcept final
+            {
+                return period_.load(std::memory_order_relaxed);
+            }
+
+            // Sets the global period for this sampler. Thread-safe.
+            // Setting a period of 0 disables the sampler, i.e., every call to Sample()
+            // will return false. Setting a period of 1 puts the sampler in 'always on'
+            // mode, i.e., every call to Sample() returns true.
+            static void SetGlobalPeriod(int period)
+            {
+                period_.store(period, std::memory_order_relaxed);
+            }
+
+        private:
+            static std::atomic<int> period_;
+        };
+
+        template<typename Tag, int default_period>
+        std::atomic<int> PeriodicSampler<Tag, default_period>::period_(default_period);
+
+    }  // namespace profiling_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
diff --git a/CAPI/cpp/grpc/include/absl/profiling/internal/sample_recorder.h b/CAPI/cpp/grpc/include/absl/profiling/internal/sample_recorder.h
index 5f65983..2c32f84 100644
--- a/CAPI/cpp/grpc/include/absl/profiling/internal/sample_recorder.h
+++ b/CAPI/cpp/grpc/include/absl/profiling/internal/sample_recorder.h
@@ -33,213 +33,238 @@
 #include "absl/synchronization/mutex.h"
 #include "absl/time/time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace profiling_internal {
-
-// Sample<T> that has members required for linking samples in the linked list of
-// samples maintained by the SampleRecorder.  Type T defines the sampled data.
-template <typename T>
-struct Sample {
-  // Guards the ability to restore the sample to a pristine state.  This
-  // prevents races with sampling and resurrecting an object.
-  absl::Mutex init_mu;
-  T* next = nullptr;
-  T* dead ABSL_GUARDED_BY(init_mu) = nullptr;
-  int64_t weight;  // How many sampling events were required to sample this one.
-};
-
-// Holds samples and their associated stack traces with a soft limit of
-// `SetHashtablezMaxSamples()`.
-//
-// Thread safe.
-template <typename T>
-class SampleRecorder {
- public:
-  SampleRecorder();
-  ~SampleRecorder();
-
-  // Registers for sampling.  Returns an opaque registration info.
-  template <typename... Targs>
-  T* Register(Targs&&... args);
-
-  // Unregisters the sample.
-  void Unregister(T* sample);
-
-  // The dispose callback will be called on all samples the moment they are
-  // being unregistered. Only affects samples that are unregistered after the
-  // callback has been set.
-  // Returns the previous callback.
-  using DisposeCallback = void (*)(const T&);
-  DisposeCallback SetDisposeCallback(DisposeCallback f);
-
-  // Iterates over all the registered `StackInfo`s.  Returning the number of
-  // samples that have been dropped.
-  int64_t Iterate(const std::function<void(const T& stack)>& f);
-
-  int32_t GetMaxSamples() const;
-  void SetMaxSamples(int32_t max);
-
- private:
-  void PushNew(T* sample);
-  void PushDead(T* sample);
-  template <typename... Targs>
-  T* PopDead(Targs... args);
-
-  std::atomic<size_t> dropped_samples_;
-  std::atomic<size_t> size_estimate_;
-  std::atomic<int32_t> max_samples_{1 << 20};
-
-  // Intrusive lock free linked lists for tracking samples.
-  //
-  // `all_` records all samples (they are never removed from this list) and is
-  // terminated with a `nullptr`.
-  //
-  // `graveyard_.dead` is a circular linked list.  When it is empty,
-  // `graveyard_.dead == &graveyard`.  The list is circular so that
-  // every item on it (even the last) has a non-null dead pointer.  This allows
-  // `Iterate` to determine if a given sample is live or dead using only
-  // information on the sample itself.
-  //
-  // For example, nodes [A, B, C, D, E] with [A, C, E] alive and [B, D] dead
-  // looks like this (G is the Graveyard):
-  //
-  //           +---+    +---+    +---+    +---+    +---+
-  //    all -->| A |--->| B |--->| C |--->| D |--->| E |
-  //           |   |    |   |    |   |    |   |    |   |
-  //   +---+   |   | +->|   |-+  |   | +->|   |-+  |   |
-  //   | G |   +---+ |  +---+ |  +---+ |  +---+ |  +---+
-  //   |   |         |        |        |        |
-  //   |   | --------+        +--------+        |
-  //   +---+                                    |
-  //     ^                                      |
-  //     +--------------------------------------+
-  //
-  std::atomic<T*> all_;
-  T graveyard_;
-
-  std::atomic<DisposeCallback> dispose_;
-};
-
-template <typename T>
-typename SampleRecorder<T>::DisposeCallback
-SampleRecorder<T>::SetDisposeCallback(DisposeCallback f) {
-  return dispose_.exchange(f, std::memory_order_relaxed);
-}
-
-template <typename T>
-SampleRecorder<T>::SampleRecorder()
-    : dropped_samples_(0), size_estimate_(0), all_(nullptr), dispose_(nullptr) {
-  absl::MutexLock l(&graveyard_.init_mu);
-  graveyard_.dead = &graveyard_;
-}
-
-template <typename T>
-SampleRecorder<T>::~SampleRecorder() {
-  T* s = all_.load(std::memory_order_acquire);
-  while (s != nullptr) {
-    T* next = s->next;
-    delete s;
-    s = next;
-  }
-}
-
-template <typename T>
-void SampleRecorder<T>::PushNew(T* sample) {
-  sample->next = all_.load(std::memory_order_relaxed);
-  while (!all_.compare_exchange_weak(sample->next, sample,
-                                     std::memory_order_release,
-                                     std::memory_order_relaxed)) {
-  }
-}
-
-template <typename T>
-void SampleRecorder<T>::PushDead(T* sample) {
-  if (auto* dispose = dispose_.load(std::memory_order_relaxed)) {
-    dispose(*sample);
-  }
-
-  absl::MutexLock graveyard_lock(&graveyard_.init_mu);
-  absl::MutexLock sample_lock(&sample->init_mu);
-  sample->dead = graveyard_.dead;
-  graveyard_.dead = sample;
-}
-
-template <typename T>
-template <typename... Targs>
-T* SampleRecorder<T>::PopDead(Targs... args) {
-  absl::MutexLock graveyard_lock(&graveyard_.init_mu);
-
-  // The list is circular, so eventually it collapses down to
-  //   graveyard_.dead == &graveyard_
-  // when it is empty.
-  T* sample = graveyard_.dead;
-  if (sample == &graveyard_) return nullptr;
-
-  absl::MutexLock sample_lock(&sample->init_mu);
-  graveyard_.dead = sample->dead;
-  sample->dead = nullptr;
-  sample->PrepareForSampling(std::forward<Targs>(args)...);
-  return sample;
-}
-
-template <typename T>
-template <typename... Targs>
-T* SampleRecorder<T>::Register(Targs&&... args) {
-  int64_t size = size_estimate_.fetch_add(1, std::memory_order_relaxed);
-  if (size > max_samples_.load(std::memory_order_relaxed)) {
-    size_estimate_.fetch_sub(1, std::memory_order_relaxed);
-    dropped_samples_.fetch_add(1, std::memory_order_relaxed);
-    return nullptr;
-  }
-
-  T* sample = PopDead(args...);
-  if (sample == nullptr) {
-    // Resurrection failed.  Hire a new warlock.
-    sample = new T();
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace profiling_internal
     {
-      absl::MutexLock sample_lock(&sample->init_mu);
-      sample->PrepareForSampling(std::forward<Targs>(args)...);
-    }
-    PushNew(sample);
-  }
-
-  return sample;
-}
-
-template <typename T>
-void SampleRecorder<T>::Unregister(T* sample) {
-  PushDead(sample);
-  size_estimate_.fetch_sub(1, std::memory_order_relaxed);
-}
-
-template <typename T>
-int64_t SampleRecorder<T>::Iterate(
-    const std::function<void(const T& stack)>& f) {
-  T* s = all_.load(std::memory_order_acquire);
-  while (s != nullptr) {
-    absl::MutexLock l(&s->init_mu);
-    if (s->dead == nullptr) {
-      f(*s);
-    }
-    s = s->next;
-  }
-
-  return dropped_samples_.load(std::memory_order_relaxed);
-}
-
-template <typename T>
-void SampleRecorder<T>::SetMaxSamples(int32_t max) {
-  max_samples_.store(max, std::memory_order_release);
-}
-
-template <typename T>
-int32_t SampleRecorder<T>::GetMaxSamples() const {
-  return max_samples_.load(std::memory_order_acquire);
-}
-
-}  // namespace profiling_internal
-ABSL_NAMESPACE_END
+
+        // Sample<T> that has members required for linking samples in the linked list of
+        // samples maintained by the SampleRecorder.  Type T defines the sampled data.
+        template<typename T>
+        struct Sample
+        {
+            // Guards the ability to restore the sample to a pristine state.  This
+            // prevents races with sampling and resurrecting an object.
+            absl::Mutex init_mu;
+            T* next = nullptr;
+            T* dead ABSL_GUARDED_BY(init_mu) = nullptr;
+            int64_t weight;  // How many sampling events were required to sample this one.
+        };
+
+        // Holds samples and their associated stack traces with a soft limit of
+        // `SetHashtablezMaxSamples()`.
+        //
+        // Thread safe.
+        template<typename T>
+        class SampleRecorder
+        {
+        public:
+            SampleRecorder();
+            ~SampleRecorder();
+
+            // Registers for sampling.  Returns an opaque registration info.
+            template<typename... Targs>
+            T* Register(Targs&&... args);
+
+            // Unregisters the sample.
+            void Unregister(T* sample);
+
+            // The dispose callback will be called on all samples the moment they are
+            // being unregistered. Only affects samples that are unregistered after the
+            // callback has been set.
+            // Returns the previous callback.
+            using DisposeCallback = void (*)(const T&);
+            DisposeCallback SetDisposeCallback(DisposeCallback f);
+
+            // Iterates over all the registered `StackInfo`s.  Returning the number of
+            // samples that have been dropped.
+            int64_t Iterate(const std::function<void(const T& stack)>& f);
+
+            int32_t GetMaxSamples() const;
+            void SetMaxSamples(int32_t max);
+
+        private:
+            void PushNew(T* sample);
+            void PushDead(T* sample);
+            template<typename... Targs>
+            T* PopDead(Targs... args);
+
+            std::atomic<size_t> dropped_samples_;
+            std::atomic<size_t> size_estimate_;
+            std::atomic<int32_t> max_samples_{1 << 20};
+
+            // Intrusive lock free linked lists for tracking samples.
+            //
+            // `all_` records all samples (they are never removed from this list) and is
+            // terminated with a `nullptr`.
+            //
+            // `graveyard_.dead` is a circular linked list.  When it is empty,
+            // `graveyard_.dead == &graveyard`.  The list is circular so that
+            // every item on it (even the last) has a non-null dead pointer.  This allows
+            // `Iterate` to determine if a given sample is live or dead using only
+            // information on the sample itself.
+            //
+            // For example, nodes [A, B, C, D, E] with [A, C, E] alive and [B, D] dead
+            // looks like this (G is the Graveyard):
+            //
+            //           +---+    +---+    +---+    +---+    +---+
+            //    all -->| A |--->| B |--->| C |--->| D |--->| E |
+            //           |   |    |   |    |   |    |   |    |   |
+            //   +---+   |   | +->|   |-+  |   | +->|   |-+  |   |
+            //   | G |   +---+ |  +---+ |  +---+ |  +---+ |  +---+
+            //   |   |         |        |        |        |
+            //   |   | --------+        +--------+        |
+            //   +---+                                    |
+            //     ^                                      |
+            //     +--------------------------------------+
+            //
+            std::atomic<T*> all_;
+            T graveyard_;
+
+            std::atomic<DisposeCallback> dispose_;
+        };
+
+        template<typename T>
+        typename SampleRecorder<T>::DisposeCallback
+            SampleRecorder<T>::SetDisposeCallback(DisposeCallback f)
+        {
+            return dispose_.exchange(f, std::memory_order_relaxed);
+        }
+
+        template<typename T>
+        SampleRecorder<T>::SampleRecorder() :
+            dropped_samples_(0),
+            size_estimate_(0),
+            all_(nullptr),
+            dispose_(nullptr)
+        {
+            absl::MutexLock l(&graveyard_.init_mu);
+            graveyard_.dead = &graveyard_;
+        }
+
+        template<typename T>
+        SampleRecorder<T>::~SampleRecorder()
+        {
+            T* s = all_.load(std::memory_order_acquire);
+            while (s != nullptr)
+            {
+                T* next = s->next;
+                delete s;
+                s = next;
+            }
+        }
+
+        template<typename T>
+        void SampleRecorder<T>::PushNew(T* sample)
+        {
+            sample->next = all_.load(std::memory_order_relaxed);
+            while (!all_.compare_exchange_weak(sample->next, sample, std::memory_order_release, std::memory_order_relaxed))
+            {
+            }
+        }
+
+        template<typename T>
+        void SampleRecorder<T>::PushDead(T* sample)
+        {
+            if (auto* dispose = dispose_.load(std::memory_order_relaxed))
+            {
+                dispose(*sample);
+            }
+
+            absl::MutexLock graveyard_lock(&graveyard_.init_mu);
+            absl::MutexLock sample_lock(&sample->init_mu);
+            sample->dead = graveyard_.dead;
+            graveyard_.dead = sample;
+        }
+
+        template<typename T>
+        template<typename... Targs>
+        T* SampleRecorder<T>::PopDead(Targs... args)
+        {
+            absl::MutexLock graveyard_lock(&graveyard_.init_mu);
+
+            // The list is circular, so eventually it collapses down to
+            //   graveyard_.dead == &graveyard_
+            // when it is empty.
+            T* sample = graveyard_.dead;
+            if (sample == &graveyard_)
+                return nullptr;
+
+            absl::MutexLock sample_lock(&sample->init_mu);
+            graveyard_.dead = sample->dead;
+            sample->dead = nullptr;
+            sample->PrepareForSampling(std::forward<Targs>(args)...);
+            return sample;
+        }
+
+        template<typename T>
+        template<typename... Targs>
+        T* SampleRecorder<T>::Register(Targs&&... args)
+        {
+            int64_t size = size_estimate_.fetch_add(1, std::memory_order_relaxed);
+            if (size > max_samples_.load(std::memory_order_relaxed))
+            {
+                size_estimate_.fetch_sub(1, std::memory_order_relaxed);
+                dropped_samples_.fetch_add(1, std::memory_order_relaxed);
+                return nullptr;
+            }
+
+            T* sample = PopDead(args...);
+            if (sample == nullptr)
+            {
+                // Resurrection failed.  Hire a new warlock.
+                sample = new T();
+                {
+                    absl::MutexLock sample_lock(&sample->init_mu);
+                    sample->PrepareForSampling(std::forward<Targs>(args)...);
+                }
+                PushNew(sample);
+            }
+
+            return sample;
+        }
+
+        template<typename T>
+        void SampleRecorder<T>::Unregister(T* sample)
+        {
+            PushDead(sample);
+            size_estimate_.fetch_sub(1, std::memory_order_relaxed);
+        }
+
+        template<typename T>
+        int64_t SampleRecorder<T>::Iterate(
+            const std::function<void(const T& stack)>& f
+        )
+        {
+            T* s = all_.load(std::memory_order_acquire);
+            while (s != nullptr)
+            {
+                absl::MutexLock l(&s->init_mu);
+                if (s->dead == nullptr)
+                {
+                    f(*s);
+                }
+                s = s->next;
+            }
+
+            return dropped_samples_.load(std::memory_order_relaxed);
+        }
+
+        template<typename T>
+        void SampleRecorder<T>::SetMaxSamples(int32_t max)
+        {
+            max_samples_.store(max, std::memory_order_release);
+        }
+
+        template<typename T>
+        int32_t SampleRecorder<T>::GetMaxSamples() const
+        {
+            return max_samples_.load(std::memory_order_acquire);
+        }
+
+    }  // namespace profiling_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/bernoulli_distribution.h b/CAPI/cpp/grpc/include/absl/random/bernoulli_distribution.h
index d81b6ae..3b85278 100644
--- a/CAPI/cpp/grpc/include/absl/random/bernoulli_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/bernoulli_distribution.h
@@ -23,178 +23,224 @@
 #include "absl/random/internal/fast_uniform_bits.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::bernoulli_distribution is a drop in replacement for
-// std::bernoulli_distribution. It guarantees that (given a perfect
-// UniformRandomBitGenerator) the acceptance probability is *exactly* equal to
-// the given double.
-//
-// The implementation assumes that double is IEEE754
-class bernoulli_distribution {
- public:
-  using result_type = bool;
-
-  class param_type {
-   public:
-    using distribution_type = bernoulli_distribution;
-
-    explicit param_type(double p = 0.5) : prob_(p) {
-      assert(p >= 0.0 && p <= 1.0);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::bernoulli_distribution is a drop in replacement for
+    // std::bernoulli_distribution. It guarantees that (given a perfect
+    // UniformRandomBitGenerator) the acceptance probability is *exactly* equal to
+    // the given double.
+    //
+    // The implementation assumes that double is IEEE754
+    class bernoulli_distribution
+    {
+    public:
+        using result_type = bool;
+
+        class param_type
+        {
+        public:
+            using distribution_type = bernoulli_distribution;
+
+            explicit param_type(double p = 0.5) :
+                prob_(p)
+            {
+                assert(p >= 0.0 && p <= 1.0);
+            }
+
+            double p() const
+            {
+                return prob_;
+            }
+
+            friend bool operator==(const param_type& p1, const param_type& p2)
+            {
+                return p1.p() == p2.p();
+            }
+            friend bool operator!=(const param_type& p1, const param_type& p2)
+            {
+                return p1.p() != p2.p();
+            }
+
+        private:
+            double prob_;
+        };
+
+        bernoulli_distribution() :
+            bernoulli_distribution(0.5)
+        {
+        }
+
+        explicit bernoulli_distribution(double p) :
+            param_(p)
+        {
+        }
+
+        explicit bernoulli_distribution(param_type p) :
+            param_(p)
+        {
+        }
+
+        // no-op
+        void reset()
+        {
+        }
+
+        template<typename URBG>
+        bool operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            return Generate(param_.p(), g);
+        }
+
+        template<typename URBG>
+        bool operator()(URBG& g,  // NOLINT(runtime/references)
+                        const param_type& param)
+        {
+            return Generate(param.p(), g);
+        }
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& param)
+        {
+            param_ = param;
+        }
+
+        double p() const
+        {
+            return param_.p();
+        }
+
+        result_type(min)() const
+        {
+            return false;
+        }
+        result_type(max)() const
+        {
+            return true;
+        }
+
+        friend bool operator==(const bernoulli_distribution& d1, const bernoulli_distribution& d2)
+        {
+            return d1.param_ == d2.param_;
+        }
+
+        friend bool operator!=(const bernoulli_distribution& d1, const bernoulli_distribution& d2)
+        {
+            return d1.param_ != d2.param_;
+        }
+
+    private:
+        static constexpr uint64_t kP32 = static_cast<uint64_t>(1) << 32;
+
+        template<typename URBG>
+        static bool Generate(double p, URBG& g);  // NOLINT(runtime/references)
+
+        param_type param_;
+    };
+
+    template<typename CharT, typename Traits>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const bernoulli_distribution& x
+    )
+    {
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os.precision(random_internal::stream_precision_helper<double>::kPrecision);
+        os << x.p();
+        return os;
     }
 
-    double p() const { return prob_; }
-
-    friend bool operator==(const param_type& p1, const param_type& p2) {
-      return p1.p() == p2.p();
+    template<typename CharT, typename Traits>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        bernoulli_distribution& x
+    )
+    {  // NOLINT(runtime/references)
+        auto saver = random_internal::make_istream_state_saver(is);
+        auto p = random_internal::read_floating_point<double>(is);
+        if (!is.fail())
+        {
+            x.param(bernoulli_distribution::param_type(p));
+        }
+        return is;
     }
-    friend bool operator!=(const param_type& p1, const param_type& p2) {
-      return p1.p() != p2.p();
+
+    template<typename URBG>
+    bool bernoulli_distribution::Generate(double p, URBG& g)
+    {  // NOLINT(runtime/references)
+        random_internal::FastUniformBits<uint32_t> fast_u32;
+
+        while (true)
+        {
+            // There are two aspects of the definition of `c` below that are worth
+            // commenting on.  First, because `p` is in the range [0, 1], `c` is in the
+            // range [0, 2^32] which does not fit in a uint32_t and therefore requires
+            // 64 bits.
+            //
+            // Second, `c` is constructed by first casting explicitly to a signed
+            // integer and then casting explicitly to an unsigned integer of the same
+            // size.  This is done because the hardware conversion instructions produce
+            // signed integers from double; if taken as a uint64_t the conversion would
+            // be wrong for doubles greater than 2^63 (not relevant in this use-case).
+            // If converted directly to an unsigned integer, the compiler would end up
+            // emitting code to handle such large values that are not relevant due to
+            // the known bounds on `c`.  To avoid these extra instructions this
+            // implementation converts first to the signed type and then convert to
+            // unsigned (which is a no-op).
+            const uint64_t c = static_cast<uint64_t>(static_cast<int64_t>(p * kP32));
+            const uint32_t v = fast_u32(g);
+            // FAST PATH: this path fails with probability 1/2^32.  Note that simply
+            // returning v <= c would approximate P very well (up to an absolute error
+            // of 1/2^32); the slow path (taken in that range of possible error, in the
+            // case of equality) eliminates the remaining error.
+            if (ABSL_PREDICT_TRUE(v != c))
+                return v < c;
+
+            // It is guaranteed that `q` is strictly less than 1, because if `q` were
+            // greater than or equal to 1, the same would be true for `p`. Certainly `p`
+            // cannot be greater than 1, and if `p == 1`, then the fast path would
+            // necessary have been taken already.
+            const double q = static_cast<double>(c) / kP32;
+
+            // The probability of acceptance on the fast path is `q` and so the
+            // probability of acceptance here should be `p - q`.
+            //
+            // Note that `q` is obtained from `p` via some shifts and conversions, the
+            // upshot of which is that `q` is simply `p` with some of the
+            // least-significant bits of its mantissa set to zero. This means that the
+            // difference `p - q` will not have any rounding errors. To see why, pretend
+            // that double has 10 bits of resolution and q is obtained from `p` in such
+            // a way that the 4 least-significant bits of its mantissa are set to zero.
+            // For example:
+            //   p   = 1.1100111011 * 2^-1
+            //   q   = 1.1100110000 * 2^-1
+            // p - q = 1.011        * 2^-8
+            // The difference `p - q` has exactly the nonzero mantissa bits that were
+            // "lost" in `q` producing a number which is certainly representable in a
+            // double.
+            const double left = p - q;
+
+            // By construction, the probability of being on this slow path is 1/2^32, so
+            // P(accept in slow path) = P(accept| in slow path) * P(slow path),
+            // which means the probability of acceptance here is `1 / (left * kP32)`:
+            const double here = left * kP32;
+
+            // The simplest way to compute the result of this trial is to repeat the
+            // whole algorithm with the new probability. This terminates because even
+            // given  arbitrarily unfriendly "random" bits, each iteration either
+            // multiplies a tiny probability by 2^32 (if c == 0) or strips off some
+            // number of nonzero mantissa bits. That process is bounded.
+            if (here == 0)
+                return false;
+            p = here;
+        }
     }
 
-   private:
-    double prob_;
-  };
-
-  bernoulli_distribution() : bernoulli_distribution(0.5) {}
-
-  explicit bernoulli_distribution(double p) : param_(p) {}
-
-  explicit bernoulli_distribution(param_type p) : param_(p) {}
-
-  // no-op
-  void reset() {}
-
-  template <typename URBG>
-  bool operator()(URBG& g) {  // NOLINT(runtime/references)
-    return Generate(param_.p(), g);
-  }
-
-  template <typename URBG>
-  bool operator()(URBG& g,  // NOLINT(runtime/references)
-                  const param_type& param) {
-    return Generate(param.p(), g);
-  }
-
-  param_type param() const { return param_; }
-  void param(const param_type& param) { param_ = param; }
-
-  double p() const { return param_.p(); }
-
-  result_type(min)() const { return false; }
-  result_type(max)() const { return true; }
-
-  friend bool operator==(const bernoulli_distribution& d1,
-                         const bernoulli_distribution& d2) {
-    return d1.param_ == d2.param_;
-  }
-
-  friend bool operator!=(const bernoulli_distribution& d1,
-                         const bernoulli_distribution& d2) {
-    return d1.param_ != d2.param_;
-  }
-
- private:
-  static constexpr uint64_t kP32 = static_cast<uint64_t>(1) << 32;
-
-  template <typename URBG>
-  static bool Generate(double p, URBG& g);  // NOLINT(runtime/references)
-
-  param_type param_;
-};
-
-template <typename CharT, typename Traits>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const bernoulli_distribution& x) {
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os.precision(random_internal::stream_precision_helper<double>::kPrecision);
-  os << x.p();
-  return os;
-}
-
-template <typename CharT, typename Traits>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-    bernoulli_distribution& x) {            // NOLINT(runtime/references)
-  auto saver = random_internal::make_istream_state_saver(is);
-  auto p = random_internal::read_floating_point<double>(is);
-  if (!is.fail()) {
-    x.param(bernoulli_distribution::param_type(p));
-  }
-  return is;
-}
-
-template <typename URBG>
-bool bernoulli_distribution::Generate(double p,
-                                      URBG& g) {  // NOLINT(runtime/references)
-  random_internal::FastUniformBits<uint32_t> fast_u32;
-
-  while (true) {
-    // There are two aspects of the definition of `c` below that are worth
-    // commenting on.  First, because `p` is in the range [0, 1], `c` is in the
-    // range [0, 2^32] which does not fit in a uint32_t and therefore requires
-    // 64 bits.
-    //
-    // Second, `c` is constructed by first casting explicitly to a signed
-    // integer and then casting explicitly to an unsigned integer of the same
-    // size.  This is done because the hardware conversion instructions produce
-    // signed integers from double; if taken as a uint64_t the conversion would
-    // be wrong for doubles greater than 2^63 (not relevant in this use-case).
-    // If converted directly to an unsigned integer, the compiler would end up
-    // emitting code to handle such large values that are not relevant due to
-    // the known bounds on `c`.  To avoid these extra instructions this
-    // implementation converts first to the signed type and then convert to
-    // unsigned (which is a no-op).
-    const uint64_t c = static_cast<uint64_t>(static_cast<int64_t>(p * kP32));
-    const uint32_t v = fast_u32(g);
-    // FAST PATH: this path fails with probability 1/2^32.  Note that simply
-    // returning v <= c would approximate P very well (up to an absolute error
-    // of 1/2^32); the slow path (taken in that range of possible error, in the
-    // case of equality) eliminates the remaining error.
-    if (ABSL_PREDICT_TRUE(v != c)) return v < c;
-
-    // It is guaranteed that `q` is strictly less than 1, because if `q` were
-    // greater than or equal to 1, the same would be true for `p`. Certainly `p`
-    // cannot be greater than 1, and if `p == 1`, then the fast path would
-    // necessary have been taken already.
-    const double q = static_cast<double>(c) / kP32;
-
-    // The probability of acceptance on the fast path is `q` and so the
-    // probability of acceptance here should be `p - q`.
-    //
-    // Note that `q` is obtained from `p` via some shifts and conversions, the
-    // upshot of which is that `q` is simply `p` with some of the
-    // least-significant bits of its mantissa set to zero. This means that the
-    // difference `p - q` will not have any rounding errors. To see why, pretend
-    // that double has 10 bits of resolution and q is obtained from `p` in such
-    // a way that the 4 least-significant bits of its mantissa are set to zero.
-    // For example:
-    //   p   = 1.1100111011 * 2^-1
-    //   q   = 1.1100110000 * 2^-1
-    // p - q = 1.011        * 2^-8
-    // The difference `p - q` has exactly the nonzero mantissa bits that were
-    // "lost" in `q` producing a number which is certainly representable in a
-    // double.
-    const double left = p - q;
-
-    // By construction, the probability of being on this slow path is 1/2^32, so
-    // P(accept in slow path) = P(accept| in slow path) * P(slow path),
-    // which means the probability of acceptance here is `1 / (left * kP32)`:
-    const double here = left * kP32;
-
-    // The simplest way to compute the result of this trial is to repeat the
-    // whole algorithm with the new probability. This terminates because even
-    // given  arbitrarily unfriendly "random" bits, each iteration either
-    // multiplies a tiny probability by 2^32 (if c == 0) or strips off some
-    // number of nonzero mantissa bits. That process is bounded.
-    if (here == 0) return false;
-    p = here;
-  }
-}
-
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_BERNOULLI_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/beta_distribution.h b/CAPI/cpp/grpc/include/absl/random/beta_distribution.h
index c154066..534b44d 100644
--- a/CAPI/cpp/grpc/include/absl/random/beta_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/beta_distribution.h
@@ -28,400 +28,484 @@
 #include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::beta_distribution:
-// Generate a floating-point variate conforming to a Beta distribution:
-//   pdf(x) \propto x^(alpha-1) * (1-x)^(beta-1),
-// where the params alpha and beta are both strictly positive real values.
-//
-// The support is the open interval (0, 1), but the return value might be equal
-// to 0 or 1, due to numerical errors when alpha and beta are very different.
-//
-// Usage note: One usage is that alpha and beta are counts of number of
-// successes and failures. When the total number of trials are large, consider
-// approximating a beta distribution with a Gaussian distribution with the same
-// mean and variance. One could use the skewness, which depends only on the
-// smaller of alpha and beta when the number of trials are sufficiently large,
-// to quantify how far a beta distribution is from the normal distribution.
-template <typename RealType = double>
-class beta_distribution {
- public:
-  using result_type = RealType;
-
-  class param_type {
-   public:
-    using distribution_type = beta_distribution;
-
-    explicit param_type(result_type alpha, result_type beta)
-        : alpha_(alpha), beta_(beta) {
-      assert(alpha >= 0);
-      assert(beta >= 0);
-      assert(alpha <= (std::numeric_limits<result_type>::max)());
-      assert(beta <= (std::numeric_limits<result_type>::max)());
-      if (alpha == 0 || beta == 0) {
-        method_ = DEGENERATE_SMALL;
-        x_ = (alpha >= beta) ? 1 : 0;
-        return;
-      }
-      // a_ = min(beta, alpha), b_ = max(beta, alpha).
-      if (beta < alpha) {
-        inverted_ = true;
-        a_ = beta;
-        b_ = alpha;
-      } else {
-        inverted_ = false;
-        a_ = alpha;
-        b_ = beta;
-      }
-      if (a_ <= 1 && b_ >= ThresholdForLargeA()) {
-        method_ = DEGENERATE_SMALL;
-        x_ = inverted_ ? result_type(1) : result_type(0);
-        return;
-      }
-      // For threshold values, see also:
-      // Evaluation of Beta Generation Algorithms, Ying-Chao Hung, et. al.
-      // February, 2009.
-      if ((b_ < 1.0 && a_ + b_ <= 1.2) || a_ <= ThresholdForSmallA()) {
-        // Choose Joehnk over Cheng when it's faster or when Cheng encounters
-        // numerical issues.
-        method_ = JOEHNK;
-        a_ = result_type(1) / alpha_;
-        b_ = result_type(1) / beta_;
-        if (std::isinf(a_) || std::isinf(b_)) {
-          method_ = DEGENERATE_SMALL;
-          x_ = inverted_ ? result_type(1) : result_type(0);
-        }
-        return;
-      }
-      if (a_ >= ThresholdForLargeA()) {
-        method_ = DEGENERATE_LARGE;
-        // Note: on PPC for long double, evaluating
-        // `std::numeric_limits::max() / ThresholdForLargeA` results in NaN.
-        result_type r = a_ / b_;
-        x_ = (inverted_ ? result_type(1) : r) / (1 + r);
-        return;
-      }
-      x_ = a_ + b_;
-      log_x_ = std::log(x_);
-      if (a_ <= 1) {
-        method_ = CHENG_BA;
-        y_ = result_type(1) / a_;
-        gamma_ = a_ + a_;
-        return;
-      }
-      method_ = CHENG_BB;
-      result_type r = (a_ - 1) / (b_ - 1);
-      y_ = std::sqrt((1 + r) / (b_ * r * 2 - r + 1));
-      gamma_ = a_ + result_type(1) / y_;
-    }
-
-    result_type alpha() const { return alpha_; }
-    result_type beta() const { return beta_; }
-
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.alpha_ == b.alpha_ && a.beta_ == b.beta_;
-    }
-
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
-    }
-
-   private:
-    friend class beta_distribution;
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::beta_distribution:
+    // Generate a floating-point variate conforming to a Beta distribution:
+    //   pdf(x) \propto x^(alpha-1) * (1-x)^(beta-1),
+    // where the params alpha and beta are both strictly positive real values.
+    //
+    // The support is the open interval (0, 1), but the return value might be equal
+    // to 0 or 1, due to numerical errors when alpha and beta are very different.
+    //
+    // Usage note: One usage is that alpha and beta are counts of number of
+    // successes and failures. When the total number of trials are large, consider
+    // approximating a beta distribution with a Gaussian distribution with the same
+    // mean and variance. One could use the skewness, which depends only on the
+    // smaller of alpha and beta when the number of trials are sufficiently large,
+    // to quantify how far a beta distribution is from the normal distribution.
+    template<typename RealType = double>
+    class beta_distribution
+    {
+    public:
+        using result_type = RealType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = beta_distribution;
+
+            explicit param_type(result_type alpha, result_type beta) :
+                alpha_(alpha),
+                beta_(beta)
+            {
+                assert(alpha >= 0);
+                assert(beta >= 0);
+                assert(alpha <= (std::numeric_limits<result_type>::max)());
+                assert(beta <= (std::numeric_limits<result_type>::max)());
+                if (alpha == 0 || beta == 0)
+                {
+                    method_ = DEGENERATE_SMALL;
+                    x_ = (alpha >= beta) ? 1 : 0;
+                    return;
+                }
+                // a_ = min(beta, alpha), b_ = max(beta, alpha).
+                if (beta < alpha)
+                {
+                    inverted_ = true;
+                    a_ = beta;
+                    b_ = alpha;
+                }
+                else
+                {
+                    inverted_ = false;
+                    a_ = alpha;
+                    b_ = beta;
+                }
+                if (a_ <= 1 && b_ >= ThresholdForLargeA())
+                {
+                    method_ = DEGENERATE_SMALL;
+                    x_ = inverted_ ? result_type(1) : result_type(0);
+                    return;
+                }
+                // For threshold values, see also:
+                // Evaluation of Beta Generation Algorithms, Ying-Chao Hung, et. al.
+                // February, 2009.
+                if ((b_ < 1.0 && a_ + b_ <= 1.2) || a_ <= ThresholdForSmallA())
+                {
+                    // Choose Joehnk over Cheng when it's faster or when Cheng encounters
+                    // numerical issues.
+                    method_ = JOEHNK;
+                    a_ = result_type(1) / alpha_;
+                    b_ = result_type(1) / beta_;
+                    if (std::isinf(a_) || std::isinf(b_))
+                    {
+                        method_ = DEGENERATE_SMALL;
+                        x_ = inverted_ ? result_type(1) : result_type(0);
+                    }
+                    return;
+                }
+                if (a_ >= ThresholdForLargeA())
+                {
+                    method_ = DEGENERATE_LARGE;
+                    // Note: on PPC for long double, evaluating
+                    // `std::numeric_limits::max() / ThresholdForLargeA` results in NaN.
+                    result_type r = a_ / b_;
+                    x_ = (inverted_ ? result_type(1) : r) / (1 + r);
+                    return;
+                }
+                x_ = a_ + b_;
+                log_x_ = std::log(x_);
+                if (a_ <= 1)
+                {
+                    method_ = CHENG_BA;
+                    y_ = result_type(1) / a_;
+                    gamma_ = a_ + a_;
+                    return;
+                }
+                method_ = CHENG_BB;
+                result_type r = (a_ - 1) / (b_ - 1);
+                y_ = std::sqrt((1 + r) / (b_ * r * 2 - r + 1));
+                gamma_ = a_ + result_type(1) / y_;
+            }
+
+            result_type alpha() const
+            {
+                return alpha_;
+            }
+            result_type beta() const
+            {
+                return beta_;
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.alpha_ == b.alpha_ && a.beta_ == b.beta_;
+            }
+
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            friend class beta_distribution;
 
 #ifdef _MSC_VER
-    // MSVC does not have constexpr implementations for std::log and std::exp
-    // so they are computed at runtime.
+            // MSVC does not have constexpr implementations for std::log and std::exp
+            // so they are computed at runtime.
 #define ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR
 #else
 #define ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR constexpr
 #endif
 
-    // The threshold for whether std::exp(1/a) is finite.
-    // Note that this value is quite large, and a smaller a_ is NOT abnormal.
-    static ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR result_type
-    ThresholdForSmallA() {
-      return result_type(1) /
-             std::log((std::numeric_limits<result_type>::max)());
-    }
-
-    // The threshold for whether a * std::log(a) is finite.
-    static ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR result_type
-    ThresholdForLargeA() {
-      return std::exp(
-          std::log((std::numeric_limits<result_type>::max)()) -
-          std::log(std::log((std::numeric_limits<result_type>::max)())) -
-          ThresholdPadding());
-    }
+            // The threshold for whether std::exp(1/a) is finite.
+            // Note that this value is quite large, and a smaller a_ is NOT abnormal.
+            static ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR result_type
+                ThresholdForSmallA()
+            {
+                return result_type(1) /
+                       std::log((std::numeric_limits<result_type>::max)());
+            }
+
+            // The threshold for whether a * std::log(a) is finite.
+            static ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR result_type
+                ThresholdForLargeA()
+            {
+                return std::exp(
+                    std::log((std::numeric_limits<result_type>::max)()) -
+                    std::log(std::log((std::numeric_limits<result_type>::max)())) -
+                    ThresholdPadding()
+                );
+            }
 
 #undef ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR
 
-    // Pad the threshold for large A for long double on PPC. This is done via a
-    // template specialization below.
-    static constexpr result_type ThresholdPadding() { return 0; }
+            // Pad the threshold for large A for long double on PPC. This is done via a
+            // template specialization below.
+            static constexpr result_type ThresholdPadding()
+            {
+                return 0;
+            }
+
+            enum Method
+            {
+                JOEHNK,    // Uses algorithm Joehnk
+                CHENG_BA,  // Uses algorithm BA in Cheng
+                CHENG_BB,  // Uses algorithm BB in Cheng
+
+                // Note: See also:
+                //   Hung et al. Evaluation of beta generation algorithms. Communications
+                //   in Statistics-Simulation and Computation 38.4 (2009): 750-770.
+                // especially:
+                //   Zechner, Heinz, and Ernst Stadlober. Generating beta variates via
+                //   patchwork rejection. Computing 50.1 (1993): 1-18.
+
+                DEGENERATE_SMALL,  // a_ is abnormally small.
+                DEGENERATE_LARGE,  // a_ is abnormally large.
+            };
+
+            result_type alpha_;
+            result_type beta_;
+
+            result_type a_;      // the smaller of {alpha, beta}, or 1.0/alpha_ in JOEHNK
+            result_type b_;      // the larger of {alpha, beta}, or 1.0/beta_ in JOEHNK
+            result_type x_;      // alpha + beta, or the result in degenerate cases
+            result_type log_x_;  // log(x_)
+            result_type y_;      // "beta" in Cheng
+            result_type gamma_;  // "gamma" in Cheng
+
+            Method method_;
+
+            // Placing this last for optimal alignment.
+            // Whether alpha_ != a_, i.e. true iff alpha_ > beta_.
+            bool inverted_;
+
+            static_assert(std::is_floating_point<RealType>::value, "Class-template absl::beta_distribution<> must be "
+                                                                   "parameterized using a floating-point type.");
+        };
+
+        beta_distribution() :
+            beta_distribution(1)
+        {
+        }
 
-    enum Method {
-      JOEHNK,    // Uses algorithm Joehnk
-      CHENG_BA,  // Uses algorithm BA in Cheng
-      CHENG_BB,  // Uses algorithm BB in Cheng
+        explicit beta_distribution(result_type alpha, result_type beta = 1) :
+            param_(alpha, beta)
+        {
+        }
 
-      // Note: See also:
-      //   Hung et al. Evaluation of beta generation algorithms. Communications
-      //   in Statistics-Simulation and Computation 38.4 (2009): 750-770.
-      // especially:
-      //   Zechner, Heinz, and Ernst Stadlober. Generating beta variates via
-      //   patchwork rejection. Computing 50.1 (1993): 1-18.
+        explicit beta_distribution(const param_type& p) :
+            param_(p)
+        {
+        }
 
-      DEGENERATE_SMALL,  // a_ is abnormally small.
-      DEGENERATE_LARGE,  // a_ is abnormally large.
-    };
+        void reset()
+        {
+        }
 
-    result_type alpha_;
-    result_type beta_;
-
-    result_type a_;  // the smaller of {alpha, beta}, or 1.0/alpha_ in JOEHNK
-    result_type b_;  // the larger of {alpha, beta}, or 1.0/beta_ in JOEHNK
-    result_type x_;  // alpha + beta, or the result in degenerate cases
-    result_type log_x_;  // log(x_)
-    result_type y_;      // "beta" in Cheng
-    result_type gamma_;  // "gamma" in Cheng
-
-    Method method_;
-
-    // Placing this last for optimal alignment.
-    // Whether alpha_ != a_, i.e. true iff alpha_ > beta_.
-    bool inverted_;
-
-    static_assert(std::is_floating_point<RealType>::value,
-                  "Class-template absl::beta_distribution<> must be "
-                  "parameterized using a floating-point type.");
-  };
-
-  beta_distribution() : beta_distribution(1) {}
-
-  explicit beta_distribution(result_type alpha, result_type beta = 1)
-      : param_(alpha, beta) {}
-
-  explicit beta_distribution(const param_type& p) : param_(p) {}
-
-  void reset() {}
-
-  // Generating functions
-  template <typename URBG>
-  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
-    return (*this)(g, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  param_type param() const { return param_; }
-  void param(const param_type& p) { param_ = p; }
-
-  result_type(min)() const { return 0; }
-  result_type(max)() const { return 1; }
-
-  result_type alpha() const { return param_.alpha(); }
-  result_type beta() const { return param_.beta(); }
-
-  friend bool operator==(const beta_distribution& a,
-                         const beta_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const beta_distribution& a,
-                         const beta_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  template <typename URBG>
-  result_type AlgorithmJoehnk(URBG& g,  // NOLINT(runtime/references)
-                              const param_type& p);
-
-  template <typename URBG>
-  result_type AlgorithmCheng(URBG& g,  // NOLINT(runtime/references)
-                             const param_type& p);
-
-  template <typename URBG>
-  result_type DegenerateCase(URBG& g,  // NOLINT(runtime/references)
-                             const param_type& p) {
-    if (p.method_ == param_type::DEGENERATE_SMALL && p.alpha_ == p.beta_) {
-      // Returns 0 or 1 with equal probability.
-      random_internal::FastUniformBits<uint8_t> fast_u8;
-      return static_cast<result_type>((fast_u8(g) & 0x10) !=
-                                      0);  // pick any single bit.
-    }
-    return p.x_;
-  }
+        // Generating functions
+        template<typename URBG>
+        result_type operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            return (*this)(g, param_);
+        }
 
-  param_type param_;
-  random_internal::FastUniformBits<uint64_t> fast_u64_;
-};
+        template<typename URBG>
+        result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                               const param_type& p);
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& p)
+        {
+            param_ = p;
+        }
+
+        result_type(min)() const
+        {
+            return 0;
+        }
+        result_type(max)() const
+        {
+            return 1;
+        }
+
+        result_type alpha() const
+        {
+            return param_.alpha();
+        }
+        result_type beta() const
+        {
+            return param_.beta();
+        }
+
+        friend bool operator==(const beta_distribution& a, const beta_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const beta_distribution& a, const beta_distribution& b)
+        {
+            return a.param_ != b.param_;
+        }
+
+    private:
+        template<typename URBG>
+        result_type AlgorithmJoehnk(URBG& g,  // NOLINT(runtime/references)
+                                    const param_type& p);
+
+        template<typename URBG>
+        result_type AlgorithmCheng(URBG& g,  // NOLINT(runtime/references)
+                                   const param_type& p);
+
+        template<typename URBG>
+        result_type DegenerateCase(URBG& g,  // NOLINT(runtime/references)
+                                   const param_type& p)
+        {
+            if (p.method_ == param_type::DEGENERATE_SMALL && p.alpha_ == p.beta_)
+            {
+                // Returns 0 or 1 with equal probability.
+                random_internal::FastUniformBits<uint8_t> fast_u8;
+                return static_cast<result_type>((fast_u8(g) & 0x10) != 0);  // pick any single bit.
+            }
+            return p.x_;
+        }
+
+        param_type param_;
+        random_internal::FastUniformBits<uint64_t> fast_u64_;
+    };
 
 #if defined(__powerpc64__) || defined(__PPC64__) || defined(__powerpc__) || \
     defined(__ppc__) || defined(__PPC__)
-// PPC needs a more stringent boundary for long double.
-template <>
-constexpr long double
-beta_distribution<long double>::param_type::ThresholdPadding() {
-  return 10;
-}
+    // PPC needs a more stringent boundary for long double.
+    template<>
+    constexpr long double
+        beta_distribution<long double>::param_type::ThresholdPadding()
+    {
+        return 10;
+    }
 #endif
 
-template <typename RealType>
-template <typename URBG>
-typename beta_distribution<RealType>::result_type
-beta_distribution<RealType>::AlgorithmJoehnk(
-    URBG& g,  // NOLINT(runtime/references)
-    const param_type& p) {
-  using random_internal::GeneratePositiveTag;
-  using random_internal::GenerateRealFromBits;
-  using real_type =
-      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
-
-  // Based on Joehnk, M. D. Erzeugung von betaverteilten und gammaverteilten
-  // Zufallszahlen. Metrika 8.1 (1964): 5-15.
-  // This method is described in Knuth, Vol 2 (Third Edition), pp 134.
-
-  result_type u, v, x, y, z;
-  for (;;) {
-    u = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
-        fast_u64_(g));
-    v = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
-        fast_u64_(g));
-
-    // Direct method. std::pow is slow for float, so rely on the optimizer to
-    // remove the std::pow() path for that case.
-    if (!std::is_same<float, result_type>::value) {
-      x = std::pow(u, p.a_);
-      y = std::pow(v, p.b_);
-      z = x + y;
-      if (z > 1) {
-        // Reject if and only if `x + y > 1.0`
-        continue;
-      }
-      if (z > 0) {
-        // When both alpha and beta are small, x and y are both close to 0, so
-        // divide by (x+y) directly may result in nan.
-        return x / z;
-      }
+    template<typename RealType>
+    template<typename URBG>
+    typename beta_distribution<RealType>::result_type
+        beta_distribution<RealType>::AlgorithmJoehnk(
+            URBG& g,  // NOLINT(runtime/references)
+            const param_type& p
+        )
+    {
+        using random_internal::GeneratePositiveTag;
+        using random_internal::GenerateRealFromBits;
+        using real_type =
+            absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+        // Based on Joehnk, M. D. Erzeugung von betaverteilten und gammaverteilten
+        // Zufallszahlen. Metrika 8.1 (1964): 5-15.
+        // This method is described in Knuth, Vol 2 (Third Edition), pp 134.
+
+        result_type u, v, x, y, z;
+        for (;;)
+        {
+            u = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+                fast_u64_(g)
+            );
+            v = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+                fast_u64_(g)
+            );
+
+            // Direct method. std::pow is slow for float, so rely on the optimizer to
+            // remove the std::pow() path for that case.
+            if (!std::is_same<float, result_type>::value)
+            {
+                x = std::pow(u, p.a_);
+                y = std::pow(v, p.b_);
+                z = x + y;
+                if (z > 1)
+                {
+                    // Reject if and only if `x + y > 1.0`
+                    continue;
+                }
+                if (z > 0)
+                {
+                    // When both alpha and beta are small, x and y are both close to 0, so
+                    // divide by (x+y) directly may result in nan.
+                    return x / z;
+                }
+            }
+
+            // Log transform.
+            // x = log( pow(u, p.a_) ), y = log( pow(v, p.b_) )
+            // since u, v <= 1.0,  x, y < 0.
+            x = std::log(u) * p.a_;
+            y = std::log(v) * p.b_;
+            if (!std::isfinite(x) || !std::isfinite(y))
+            {
+                continue;
+            }
+            // z = log( pow(u, a) + pow(v, b) )
+            z = x > y ? (x + std::log(1 + std::exp(y - x))) : (y + std::log(1 + std::exp(x - y)));
+            // Reject iff log(x+y) > 0.
+            if (z > 0)
+            {
+                continue;
+            }
+            return std::exp(x - z);
+        }
     }
 
-    // Log transform.
-    // x = log( pow(u, p.a_) ), y = log( pow(v, p.b_) )
-    // since u, v <= 1.0,  x, y < 0.
-    x = std::log(u) * p.a_;
-    y = std::log(v) * p.b_;
-    if (!std::isfinite(x) || !std::isfinite(y)) {
-      continue;
-    }
-    // z = log( pow(u, a) + pow(v, b) )
-    z = x > y ? (x + std::log(1 + std::exp(y - x)))
-              : (y + std::log(1 + std::exp(x - y)));
-    // Reject iff log(x+y) > 0.
-    if (z > 0) {
-      continue;
+    template<typename RealType>
+    template<typename URBG>
+    typename beta_distribution<RealType>::result_type
+        beta_distribution<RealType>::AlgorithmCheng(
+            URBG& g,  // NOLINT(runtime/references)
+            const param_type& p
+        )
+    {
+        using random_internal::GeneratePositiveTag;
+        using random_internal::GenerateRealFromBits;
+        using real_type =
+            absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+        // Based on Cheng, Russell CH. Generating beta variates with nonintegral
+        // shape parameters. Communications of the ACM 21.4 (1978): 317-322.
+        // (https://dl.acm.org/citation.cfm?id=359482).
+        static constexpr result_type kLogFour =
+            result_type(1.3862943611198906188344642429163531361);  // log(4)
+        static constexpr result_type kS =
+            result_type(2.6094379124341003746007593332261876);  // 1+log(5)
+
+        const bool use_algorithm_ba = (p.method_ == param_type::CHENG_BA);
+        result_type u1, u2, v, w, z, r, s, t, bw_inv, lhs;
+        for (;;)
+        {
+            u1 = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+                fast_u64_(g)
+            );
+            u2 = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
+                fast_u64_(g)
+            );
+            v = p.y_ * std::log(u1 / (1 - u1));
+            w = p.a_ * std::exp(v);
+            bw_inv = result_type(1) / (p.b_ + w);
+            r = p.gamma_ * v - kLogFour;
+            s = p.a_ + r - w;
+            z = u1 * u1 * u2;
+            if (!use_algorithm_ba && s + kS >= 5 * z)
+            {
+                break;
+            }
+            t = std::log(z);
+            if (!use_algorithm_ba && s >= t)
+            {
+                break;
+            }
+            lhs = p.x_ * (p.log_x_ + std::log(bw_inv)) + r;
+            if (lhs >= t)
+            {
+                break;
+            }
+        }
+        return p.inverted_ ? (1 - w * bw_inv) : w * bw_inv;
     }
-    return std::exp(x - z);
-  }
-}
-
-template <typename RealType>
-template <typename URBG>
-typename beta_distribution<RealType>::result_type
-beta_distribution<RealType>::AlgorithmCheng(
-    URBG& g,  // NOLINT(runtime/references)
-    const param_type& p) {
-  using random_internal::GeneratePositiveTag;
-  using random_internal::GenerateRealFromBits;
-  using real_type =
-      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
-
-  // Based on Cheng, Russell CH. Generating beta variates with nonintegral
-  // shape parameters. Communications of the ACM 21.4 (1978): 317-322.
-  // (https://dl.acm.org/citation.cfm?id=359482).
-  static constexpr result_type kLogFour =
-      result_type(1.3862943611198906188344642429163531361);  // log(4)
-  static constexpr result_type kS =
-      result_type(2.6094379124341003746007593332261876);  // 1+log(5)
-
-  const bool use_algorithm_ba = (p.method_ == param_type::CHENG_BA);
-  result_type u1, u2, v, w, z, r, s, t, bw_inv, lhs;
-  for (;;) {
-    u1 = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
-        fast_u64_(g));
-    u2 = GenerateRealFromBits<real_type, GeneratePositiveTag, false>(
-        fast_u64_(g));
-    v = p.y_ * std::log(u1 / (1 - u1));
-    w = p.a_ * std::exp(v);
-    bw_inv = result_type(1) / (p.b_ + w);
-    r = p.gamma_ * v - kLogFour;
-    s = p.a_ + r - w;
-    z = u1 * u1 * u2;
-    if (!use_algorithm_ba && s + kS >= 5 * z) {
-      break;
+
+    template<typename RealType>
+    template<typename URBG>
+    typename beta_distribution<RealType>::result_type
+        beta_distribution<RealType>::operator()(URBG& g,  // NOLINT(runtime/references)
+                                                const param_type& p)
+    {
+        switch (p.method_)
+        {
+            case param_type::JOEHNK:
+                return AlgorithmJoehnk(g, p);
+            case param_type::CHENG_BA:
+                ABSL_FALLTHROUGH_INTENDED;
+            case param_type::CHENG_BB:
+                return AlgorithmCheng(g, p);
+            default:
+                return DegenerateCase(g, p);
+        }
     }
-    t = std::log(z);
-    if (!use_algorithm_ba && s >= t) {
-      break;
+
+    template<typename CharT, typename Traits, typename RealType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const beta_distribution<RealType>& x
+    )
+    {
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
+        os << x.alpha() << os.fill() << x.beta();
+        return os;
     }
-    lhs = p.x_ * (p.log_x_ + std::log(bw_inv)) + r;
-    if (lhs >= t) {
-      break;
+
+    template<typename CharT, typename Traits, typename RealType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        beta_distribution<RealType>& x
+    )
+    {  // NOLINT(runtime/references)
+        using result_type = typename beta_distribution<RealType>::result_type;
+        using param_type = typename beta_distribution<RealType>::param_type;
+        result_type alpha, beta;
+
+        auto saver = random_internal::make_istream_state_saver(is);
+        alpha = random_internal::read_floating_point<result_type>(is);
+        if (is.fail())
+            return is;
+        beta = random_internal::read_floating_point<result_type>(is);
+        if (!is.fail())
+        {
+            x.param(param_type(alpha, beta));
+        }
+        return is;
     }
-  }
-  return p.inverted_ ? (1 - w * bw_inv) : w * bw_inv;
-}
-
-template <typename RealType>
-template <typename URBG>
-typename beta_distribution<RealType>::result_type
-beta_distribution<RealType>::operator()(URBG& g,  // NOLINT(runtime/references)
-                                        const param_type& p) {
-  switch (p.method_) {
-    case param_type::JOEHNK:
-      return AlgorithmJoehnk(g, p);
-    case param_type::CHENG_BA:
-      ABSL_FALLTHROUGH_INTENDED;
-    case param_type::CHENG_BB:
-      return AlgorithmCheng(g, p);
-    default:
-      return DegenerateCase(g, p);
-  }
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const beta_distribution<RealType>& x) {
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
-  os << x.alpha() << os.fill() << x.beta();
-  return os;
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-    beta_distribution<RealType>& x) {       // NOLINT(runtime/references)
-  using result_type = typename beta_distribution<RealType>::result_type;
-  using param_type = typename beta_distribution<RealType>::param_type;
-  result_type alpha, beta;
-
-  auto saver = random_internal::make_istream_state_saver(is);
-  alpha = random_internal::read_floating_point<result_type>(is);
-  if (is.fail()) return is;
-  beta = random_internal::read_floating_point<result_type>(is);
-  if (!is.fail()) {
-    x.param(param_type(alpha, beta));
-  }
-  return is;
-}
-
-ABSL_NAMESPACE_END
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_BETA_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/bit_gen_ref.h b/CAPI/cpp/grpc/include/absl/random/bit_gen_ref.h
index e475221..263669a 100644
--- a/CAPI/cpp/grpc/include/absl/random/bit_gen_ref.h
+++ b/CAPI/cpp/grpc/include/absl/random/bit_gen_ref.h
@@ -34,152 +34,167 @@
 #include "absl/random/internal/distribution_caller.h"
 #include "absl/random/internal/fast_uniform_bits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-template <typename URBG, typename = void, typename = void, typename = void>
-struct is_urbg : std::false_type {};
-
-template <typename URBG>
-struct is_urbg<
-    URBG,
-    absl::enable_if_t<std::is_same<
-        typename URBG::result_type,
-        typename std::decay<decltype((URBG::min)())>::type>::value>,
-    absl::enable_if_t<std::is_same<
-        typename URBG::result_type,
-        typename std::decay<decltype((URBG::max)())>::type>::value>,
-    absl::enable_if_t<std::is_same<
-        typename URBG::result_type,
-        typename std::decay<decltype(std::declval<URBG>()())>::type>::value>>
-    : std::true_type {};
-
-template <typename>
-struct DistributionCaller;
-class MockHelpers;
-
-}  // namespace random_internal
-
-// -----------------------------------------------------------------------------
-// absl::BitGenRef
-// -----------------------------------------------------------------------------
-//
-// `absl::BitGenRef` is a type-erasing class that provides a generator-agnostic
-// non-owning "reference" interface for use in place of any specific uniform
-// random bit generator (URBG). This class may be used for both Abseil
-// (e.g. `absl::BitGen`, `absl::InsecureBitGen`) and Standard library (e.g
-// `std::mt19937`, `std::minstd_rand`) bit generators.
-//
-// Like other reference classes, `absl::BitGenRef` does not own the
-// underlying bit generator, and the underlying instance must outlive the
-// `absl::BitGenRef`.
-//
-// `absl::BitGenRef` is particularly useful when used with an
-// `absl::MockingBitGen` to test specific paths in functions which use random
-// values.
-//
-// Example:
-//    void TakesBitGenRef(absl::BitGenRef gen) {
-//      int x = absl::Uniform<int>(gen, 0, 1000);
-//    }
-//
-class BitGenRef {
-  // SFINAE to detect whether the URBG type includes a member matching
-  // bool InvokeMock(base_internal::FastTypeIdType, void*, void*).
-  //
-  // These live inside BitGenRef so that they have friend access
-  // to MockingBitGen. (see similar methods in DistributionCaller).
-  template <template <class...> class Trait, class AlwaysVoid, class... Args>
-  struct detector : std::false_type {};
-  template <template <class...> class Trait, class... Args>
-  struct detector<Trait, absl::void_t<Trait<Args...>>, Args...>
-      : std::true_type {};
-
-  template <class T>
-  using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
-      std::declval<base_internal::FastTypeIdType>(), std::declval<void*>(),
-      std::declval<void*>()));
-
-  template <typename T>
-  using HasInvokeMock = typename detector<invoke_mock_t, void, T>::type;
-
- public:
-  BitGenRef(const BitGenRef&) = default;
-  BitGenRef(BitGenRef&&) = default;
-  BitGenRef& operator=(const BitGenRef&) = default;
-  BitGenRef& operator=(BitGenRef&&) = default;
-
-  template <typename URBG, typename absl::enable_if_t<
-                               (!std::is_same<URBG, BitGenRef>::value &&
-                                random_internal::is_urbg<URBG>::value &&
-                                !HasInvokeMock<URBG>::value)>* = nullptr>
-  BitGenRef(URBG& gen)  // NOLINT
-      : t_erased_gen_ptr_(reinterpret_cast<uintptr_t>(&gen)),
-        mock_call_(NotAMock),
-        generate_impl_fn_(ImplFn<URBG>) {}
-
-  template <typename URBG,
-            typename absl::enable_if_t<(!std::is_same<URBG, BitGenRef>::value &&
-                                        random_internal::is_urbg<URBG>::value &&
-                                        HasInvokeMock<URBG>::value)>* = nullptr>
-  BitGenRef(URBG& gen)  // NOLINT
-      : t_erased_gen_ptr_(reinterpret_cast<uintptr_t>(&gen)),
-        mock_call_(&MockCall<URBG>),
-        generate_impl_fn_(ImplFn<URBG>) {}
-
-  using result_type = uint64_t;
-
-  static constexpr result_type(min)() {
-    return (std::numeric_limits<result_type>::min)();
-  }
-
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
-
-  result_type operator()() { return generate_impl_fn_(t_erased_gen_ptr_); }
-
- private:
-  using impl_fn = result_type (*)(uintptr_t);
-  using mock_call_fn = bool (*)(uintptr_t, base_internal::FastTypeIdType, void*,
-                                void*);
-
-  template <typename URBG>
-  static result_type ImplFn(uintptr_t ptr) {
-    // Ensure that the return values from operator() fill the entire
-    // range promised by result_type, min() and max().
-    absl::random_internal::FastUniformBits<result_type> fast_uniform_bits;
-    return fast_uniform_bits(*reinterpret_cast<URBG*>(ptr));
-  }
-
-  // Get a type-erased InvokeMock pointer.
-  template <typename URBG>
-  static bool MockCall(uintptr_t gen_ptr, base_internal::FastTypeIdType type,
-                       void* result, void* arg_tuple) {
-    return reinterpret_cast<URBG*>(gen_ptr)->InvokeMock(type, result,
-                                                        arg_tuple);
-  }
-  static bool NotAMock(uintptr_t, base_internal::FastTypeIdType, void*, void*) {
-    return false;
-  }
-
-  inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple,
-                         void* result) {
-    if (mock_call_ == NotAMock) return false;  // avoids an indirect call.
-    return mock_call_(t_erased_gen_ptr_, type, args_tuple, result);
-  }
-
-  uintptr_t t_erased_gen_ptr_;
-  mock_call_fn mock_call_;
-  impl_fn generate_impl_fn_;
-
-  template <typename>
-  friend struct ::absl::random_internal::DistributionCaller;  // for InvokeMock
-  friend class ::absl::random_internal::MockHelpers;          // for InvokeMock
-};
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        template<typename URBG, typename = void, typename = void, typename = void>
+        struct is_urbg : std::false_type
+        {
+        };
+
+        template<typename URBG>
+        struct is_urbg<
+            URBG,
+            absl::enable_if_t<std::is_same<
+                typename URBG::result_type,
+                typename std::decay<decltype((URBG::min)())>::type>::value>,
+            absl::enable_if_t<std::is_same<
+                typename URBG::result_type,
+                typename std::decay<decltype((URBG::max)())>::type>::value>,
+            absl::enable_if_t<std::is_same<
+                typename URBG::result_type,
+                typename std::decay<decltype(std::declval<URBG>()())>::type>::value>> : std::true_type
+        {
+        };
+
+        template<typename>
+        struct DistributionCaller;
+        class MockHelpers;
+
+    }  // namespace random_internal
+
+    // -----------------------------------------------------------------------------
+    // absl::BitGenRef
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::BitGenRef` is a type-erasing class that provides a generator-agnostic
+    // non-owning "reference" interface for use in place of any specific uniform
+    // random bit generator (URBG). This class may be used for both Abseil
+    // (e.g. `absl::BitGen`, `absl::InsecureBitGen`) and Standard library (e.g
+    // `std::mt19937`, `std::minstd_rand`) bit generators.
+    //
+    // Like other reference classes, `absl::BitGenRef` does not own the
+    // underlying bit generator, and the underlying instance must outlive the
+    // `absl::BitGenRef`.
+    //
+    // `absl::BitGenRef` is particularly useful when used with an
+    // `absl::MockingBitGen` to test specific paths in functions which use random
+    // values.
+    //
+    // Example:
+    //    void TakesBitGenRef(absl::BitGenRef gen) {
+    //      int x = absl::Uniform<int>(gen, 0, 1000);
+    //    }
+    //
+    class BitGenRef
+    {
+        // SFINAE to detect whether the URBG type includes a member matching
+        // bool InvokeMock(base_internal::FastTypeIdType, void*, void*).
+        //
+        // These live inside BitGenRef so that they have friend access
+        // to MockingBitGen. (see similar methods in DistributionCaller).
+        template<template<class...> class Trait, class AlwaysVoid, class... Args>
+        struct detector : std::false_type
+        {
+        };
+        template<template<class...> class Trait, class... Args>
+        struct detector<Trait, absl::void_t<Trait<Args...>>, Args...> : std::true_type
+        {
+        };
+
+        template<class T>
+        using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
+            std::declval<base_internal::FastTypeIdType>(), std::declval<void*>(), std::declval<void*>()
+        ));
+
+        template<typename T>
+        using HasInvokeMock = typename detector<invoke_mock_t, void, T>::type;
+
+    public:
+        BitGenRef(const BitGenRef&) = default;
+        BitGenRef(BitGenRef&&) = default;
+        BitGenRef& operator=(const BitGenRef&) = default;
+        BitGenRef& operator=(BitGenRef&&) = default;
+
+        template<typename URBG, typename absl::enable_if_t<(!std::is_same<URBG, BitGenRef>::value && random_internal::is_urbg<URBG>::value && !HasInvokeMock<URBG>::value)>* = nullptr>
+        BitGenRef(URBG& gen)  // NOLINT
+            :
+            t_erased_gen_ptr_(reinterpret_cast<uintptr_t>(&gen)),
+            mock_call_(NotAMock),
+            generate_impl_fn_(ImplFn<URBG>)
+        {
+        }
+
+        template<typename URBG, typename absl::enable_if_t<(!std::is_same<URBG, BitGenRef>::value && random_internal::is_urbg<URBG>::value && HasInvokeMock<URBG>::value)>* = nullptr>
+        BitGenRef(URBG& gen)  // NOLINT
+            :
+            t_erased_gen_ptr_(reinterpret_cast<uintptr_t>(&gen)),
+            mock_call_(&MockCall<URBG>),
+            generate_impl_fn_(ImplFn<URBG>)
+        {
+        }
+
+        using result_type = uint64_t;
+
+        static constexpr result_type(min)()
+        {
+            return (std::numeric_limits<result_type>::min)();
+        }
+
+        static constexpr result_type(max)()
+        {
+            return (std::numeric_limits<result_type>::max)();
+        }
+
+        result_type operator()()
+        {
+            return generate_impl_fn_(t_erased_gen_ptr_);
+        }
+
+    private:
+        using impl_fn = result_type (*)(uintptr_t);
+        using mock_call_fn = bool (*)(uintptr_t, base_internal::FastTypeIdType, void*, void*);
+
+        template<typename URBG>
+        static result_type ImplFn(uintptr_t ptr)
+        {
+            // Ensure that the return values from operator() fill the entire
+            // range promised by result_type, min() and max().
+            absl::random_internal::FastUniformBits<result_type> fast_uniform_bits;
+            return fast_uniform_bits(*reinterpret_cast<URBG*>(ptr));
+        }
+
+        // Get a type-erased InvokeMock pointer.
+        template<typename URBG>
+        static bool MockCall(uintptr_t gen_ptr, base_internal::FastTypeIdType type, void* result, void* arg_tuple)
+        {
+            return reinterpret_cast<URBG*>(gen_ptr)->InvokeMock(type, result, arg_tuple);
+        }
+        static bool NotAMock(uintptr_t, base_internal::FastTypeIdType, void*, void*)
+        {
+            return false;
+        }
+
+        inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple, void* result)
+        {
+            if (mock_call_ == NotAMock)
+                return false;  // avoids an indirect call.
+            return mock_call_(t_erased_gen_ptr_, type, args_tuple, result);
+        }
+
+        uintptr_t t_erased_gen_ptr_;
+        mock_call_fn mock_call_;
+        impl_fn generate_impl_fn_;
+
+        template<typename>
+        friend struct ::absl::random_internal::DistributionCaller;  // for InvokeMock
+        friend class ::absl::random_internal::MockHelpers;          // for InvokeMock
+    };
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_BIT_GEN_REF_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/discrete_distribution.h b/CAPI/cpp/grpc/include/absl/random/discrete_distribution.h
index 171aa11..d3dd727 100644
--- a/CAPI/cpp/grpc/include/absl/random/discrete_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/discrete_distribution.h
@@ -28,220 +28,280 @@
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/uniform_int_distribution.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::discrete_distribution
+    //
+    // A discrete distribution produces random integers i, where 0 <= i < n
+    // distributed according to the discrete probability function:
+    //
+    //     P(i|p0,...,pn−1)=pi
+    //
+    // This class is an implementation of discrete_distribution (see
+    // [rand.dist.samp.discrete]).
+    //
+    // The algorithm used is Walker's Aliasing algorithm, described in Knuth, Vol 2.
+    // absl::discrete_distribution takes O(N) time to precompute the probabilities
+    // (where N is the number of possible outcomes in the distribution) at
+    // construction, and then takes O(1) time for each variate generation.  Many
+    // other implementations also take O(N) time to construct an ordered sequence of
+    // partial sums, plus O(log N) time per variate to binary search.
+    //
+    template<typename IntType = int>
+    class discrete_distribution
+    {
+    public:
+        using result_type = IntType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = discrete_distribution;
+
+            param_type()
+            {
+                init();
+            }
+
+            template<typename InputIterator>
+            explicit param_type(InputIterator begin, InputIterator end) :
+                p_(begin, end)
+            {
+                init();
+            }
+
+            explicit param_type(std::initializer_list<double> weights) :
+                p_(weights)
+            {
+                init();
+            }
+
+            template<class UnaryOperation>
+            explicit param_type(size_t nw, double xmin, double xmax, UnaryOperation fw)
+            {
+                if (nw > 0)
+                {
+                    p_.reserve(nw);
+                    double delta = (xmax - xmin) / static_cast<double>(nw);
+                    assert(delta > 0);
+                    double t = delta * 0.5;
+                    for (size_t i = 0; i < nw; ++i)
+                    {
+                        p_.push_back(fw(xmin + i * delta + t));
+                    }
+                }
+                init();
+            }
+
+            const std::vector<double>& probabilities() const
+            {
+                return p_;
+            }
+            size_t n() const
+            {
+                return p_.size() - 1;
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.probabilities() == b.probabilities();
+            }
+
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            friend class discrete_distribution;
+
+            void init();
+
+            std::vector<double> p_;                     // normalized probabilities
+            std::vector<std::pair<double, size_t>> q_;  // (acceptance, alternate) pairs
+
+            static_assert(std::is_integral<result_type>::value, "Class-template absl::discrete_distribution<> must be "
+                                                                "parameterized using an integral type.");
+        };
+
+        discrete_distribution() :
+            param_()
+        {
+        }
 
-// absl::discrete_distribution
-//
-// A discrete distribution produces random integers i, where 0 <= i < n
-// distributed according to the discrete probability function:
-//
-//     P(i|p0,...,pn−1)=pi
-//
-// This class is an implementation of discrete_distribution (see
-// [rand.dist.samp.discrete]).
-//
-// The algorithm used is Walker's Aliasing algorithm, described in Knuth, Vol 2.
-// absl::discrete_distribution takes O(N) time to precompute the probabilities
-// (where N is the number of possible outcomes in the distribution) at
-// construction, and then takes O(1) time for each variate generation.  Many
-// other implementations also take O(N) time to construct an ordered sequence of
-// partial sums, plus O(log N) time per variate to binary search.
-//
-template <typename IntType = int>
-class discrete_distribution {
- public:
-  using result_type = IntType;
+        explicit discrete_distribution(const param_type& p) :
+            param_(p)
+        {
+        }
 
-  class param_type {
-   public:
-    using distribution_type = discrete_distribution;
+        template<typename InputIterator>
+        explicit discrete_distribution(InputIterator begin, InputIterator end) :
+            param_(begin, end)
+        {
+        }
 
-    param_type() { init(); }
+        explicit discrete_distribution(std::initializer_list<double> weights) :
+            param_(weights)
+        {
+        }
 
-    template <typename InputIterator>
-    explicit param_type(InputIterator begin, InputIterator end)
-        : p_(begin, end) {
-      init();
-    }
+        template<class UnaryOperation>
+        explicit discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw) :
+            param_(nw, xmin, xmax, std::move(fw))
+        {
+        }
 
-    explicit param_type(std::initializer_list<double> weights) : p_(weights) {
-      init();
-    }
+        void reset()
+        {
+        }
 
-    template <class UnaryOperation>
-    explicit param_type(size_t nw, double xmin, double xmax,
-                        UnaryOperation fw) {
-      if (nw > 0) {
-        p_.reserve(nw);
-        double delta = (xmax - xmin) / static_cast<double>(nw);
-        assert(delta > 0);
-        double t = delta * 0.5;
-        for (size_t i = 0; i < nw; ++i) {
-          p_.push_back(fw(xmin + i * delta + t));
-        }
-      }
-      init();
-    }
+        // generating functions
+        template<typename URBG>
+        result_type operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            return (*this)(g, param_);
+        }
 
-    const std::vector<double>& probabilities() const { return p_; }
-    size_t n() const { return p_.size() - 1; }
+        template<typename URBG>
+        result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                               const param_type& p);
 
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.probabilities() == b.probabilities();
+        const param_type& param() const
+        {
+            return param_;
+        }
+        void param(const param_type& p)
+        {
+            param_ = p;
+        }
+
+        result_type(min)() const
+        {
+            return 0;
+        }
+        result_type(max)() const
+        {
+            return static_cast<result_type>(param_.n());
+        }  // inclusive
+
+        // NOTE [rand.dist.sample.discrete] returns a std::vector<double> not a
+        // const std::vector<double>&.
+        const std::vector<double>& probabilities() const
+        {
+            return param_.probabilities();
+        }
+
+        friend bool operator==(const discrete_distribution& a, const discrete_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const discrete_distribution& a, const discrete_distribution& b)
+        {
+            return a.param_ != b.param_;
+        }
+
+    private:
+        param_type param_;
+    };
+
+    // --------------------------------------------------------------------------
+    // Implementation details only below
+    // --------------------------------------------------------------------------
+
+    namespace random_internal
+    {
+
+        // Using the vector `*probabilities`, whose values are the weights or
+        // probabilities of an element being selected, constructs the proportional
+        // probabilities used by the discrete distribution.  `*probabilities` will be
+        // scaled, if necessary, so that its entries sum to a value sufficiently close
+        // to 1.0.
+        std::vector<std::pair<double, size_t>> InitDiscreteDistribution(
+            std::vector<double>* probabilities
+        );
+
+    }  // namespace random_internal
+
+    template<typename IntType>
+    void discrete_distribution<IntType>::param_type::init()
+    {
+        if (p_.empty())
+        {
+            p_.push_back(1.0);
+            q_.emplace_back(1.0, 0);
+        }
+        else
+        {
+            assert(n() <= (std::numeric_limits<IntType>::max)());
+            q_ = random_internal::InitDiscreteDistribution(&p_);
+        }
     }
 
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
+    template<typename IntType>
+    template<typename URBG>
+    typename discrete_distribution<IntType>::result_type
+        discrete_distribution<IntType>::operator()(
+            URBG& g,  // NOLINT(runtime/references)
+            const param_type& p
+        )
+    {
+        const auto idx = absl::uniform_int_distribution<result_type>(0, p.n())(g);
+        const auto& q = p.q_[idx];
+        const bool selected = absl::bernoulli_distribution(q.first)(g);
+        return selected ? idx : static_cast<result_type>(q.second);
     }
 
-   private:
-    friend class discrete_distribution;
-
-    void init();
-
-    std::vector<double> p_;                     // normalized probabilities
-    std::vector<std::pair<double, size_t>> q_;  // (acceptance, alternate) pairs
-
-    static_assert(std::is_integral<result_type>::value,
-                  "Class-template absl::discrete_distribution<> must be "
-                  "parameterized using an integral type.");
-  };
-
-  discrete_distribution() : param_() {}
-
-  explicit discrete_distribution(const param_type& p) : param_(p) {}
-
-  template <typename InputIterator>
-  explicit discrete_distribution(InputIterator begin, InputIterator end)
-      : param_(begin, end) {}
-
-  explicit discrete_distribution(std::initializer_list<double> weights)
-      : param_(weights) {}
-
-  template <class UnaryOperation>
-  explicit discrete_distribution(size_t nw, double xmin, double xmax,
-                                 UnaryOperation fw)
-      : param_(nw, xmin, xmax, std::move(fw)) {}
-
-  void reset() {}
-
-  // generating functions
-  template <typename URBG>
-  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
-    return (*this)(g, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  const param_type& param() const { return param_; }
-  void param(const param_type& p) { param_ = p; }
-
-  result_type(min)() const { return 0; }
-  result_type(max)() const {
-    return static_cast<result_type>(param_.n());
-  }  // inclusive
-
-  // NOTE [rand.dist.sample.discrete] returns a std::vector<double> not a
-  // const std::vector<double>&.
-  const std::vector<double>& probabilities() const {
-    return param_.probabilities();
-  }
-
-  friend bool operator==(const discrete_distribution& a,
-                         const discrete_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const discrete_distribution& a,
-                         const discrete_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  param_type param_;
-};
-
-// --------------------------------------------------------------------------
-// Implementation details only below
-// --------------------------------------------------------------------------
-
-namespace random_internal {
-
-// Using the vector `*probabilities`, whose values are the weights or
-// probabilities of an element being selected, constructs the proportional
-// probabilities used by the discrete distribution.  `*probabilities` will be
-// scaled, if necessary, so that its entries sum to a value sufficiently close
-// to 1.0.
-std::vector<std::pair<double, size_t>> InitDiscreteDistribution(
-    std::vector<double>* probabilities);
-
-}  // namespace random_internal
-
-template <typename IntType>
-void discrete_distribution<IntType>::param_type::init() {
-  if (p_.empty()) {
-    p_.push_back(1.0);
-    q_.emplace_back(1.0, 0);
-  } else {
-    assert(n() <= (std::numeric_limits<IntType>::max)());
-    q_ = random_internal::InitDiscreteDistribution(&p_);
-  }
-}
-
-template <typename IntType>
-template <typename URBG>
-typename discrete_distribution<IntType>::result_type
-discrete_distribution<IntType>::operator()(
-    URBG& g,  // NOLINT(runtime/references)
-    const param_type& p) {
-  const auto idx = absl::uniform_int_distribution<result_type>(0, p.n())(g);
-  const auto& q = p.q_[idx];
-  const bool selected = absl::bernoulli_distribution(q.first)(g);
-  return selected ? idx : static_cast<result_type>(q.second);
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const discrete_distribution<IntType>& x) {
-  auto saver = random_internal::make_ostream_state_saver(os);
-  const auto& probabilities = x.param().probabilities();
-  os << probabilities.size();
-
-  os.precision(random_internal::stream_precision_helper<double>::kPrecision);
-  for (const auto& p : probabilities) {
-    os << os.fill() << p;
-  }
-  return os;
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-    discrete_distribution<IntType>& x) {    // NOLINT(runtime/references)
-  using param_type = typename discrete_distribution<IntType>::param_type;
-  auto saver = random_internal::make_istream_state_saver(is);
-
-  size_t n;
-  std::vector<double> p;
-
-  is >> n;
-  if (is.fail()) return is;
-  if (n > 0) {
-    p.reserve(n);
-    for (IntType i = 0; i < n && !is.fail(); ++i) {
-      auto tmp = random_internal::read_floating_point<double>(is);
-      if (is.fail()) return is;
-      p.push_back(tmp);
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const discrete_distribution<IntType>& x
+    )
+    {
+        auto saver = random_internal::make_ostream_state_saver(os);
+        const auto& probabilities = x.param().probabilities();
+        os << probabilities.size();
+
+        os.precision(random_internal::stream_precision_helper<double>::kPrecision);
+        for (const auto& p : probabilities)
+        {
+            os << os.fill() << p;
+        }
+        return os;
+    }
+
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        discrete_distribution<IntType>& x
+    )
+    {  // NOLINT(runtime/references)
+        using param_type = typename discrete_distribution<IntType>::param_type;
+        auto saver = random_internal::make_istream_state_saver(is);
+
+        size_t n;
+        std::vector<double> p;
+
+        is >> n;
+        if (is.fail())
+            return is;
+        if (n > 0)
+        {
+            p.reserve(n);
+            for (IntType i = 0; i < n && !is.fail(); ++i)
+            {
+                auto tmp = random_internal::read_floating_point<double>(is);
+                if (is.fail())
+                    return is;
+                p.push_back(tmp);
+            }
+        }
+        x.param(param_type(p.begin(), p.end()));
+        return is;
     }
-  }
-  x.param(param_type(p.begin(), p.end()));
-  return is;
-}
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_DISCRETE_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/distributions.h b/CAPI/cpp/grpc/include/absl/random/distributions.h
index 37fc3aa..44161db 100644
--- a/CAPI/cpp/grpc/include/absl/random/distributions.h
+++ b/CAPI/cpp/grpc/include/absl/random/distributions.h
@@ -58,395 +58,415 @@
 #include "absl/random/exponential_distribution.h"
 #include "absl/random/gaussian_distribution.h"
 #include "absl/random/internal/distribution_caller.h"  // IWYU pragma: export
-#include "absl/random/internal/uniform_helper.h"  // IWYU pragma: export
+#include "absl/random/internal/uniform_helper.h"       // IWYU pragma: export
 #include "absl/random/log_uniform_int_distribution.h"
 #include "absl/random/poisson_distribution.h"
 #include "absl/random/uniform_int_distribution.h"
 #include "absl/random/uniform_real_distribution.h"
 #include "absl/random/zipf_distribution.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedClosedTag, IntervalClosedClosed,
-                               {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedClosedTag, IntervalClosed, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedOpenTag, IntervalClosedOpen, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenOpenTag, IntervalOpenOpen, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenOpenTag, IntervalOpen, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenClosedTag, IntervalOpenClosed, {});
-
-// -----------------------------------------------------------------------------
-// absl::Uniform<T>(tag, bitgen, lo, hi)
-// -----------------------------------------------------------------------------
-//
-// `absl::Uniform()` produces random values of type `T` uniformly distributed in
-// a defined interval {lo, hi}. The interval `tag` defines the type of interval
-// which should be one of the following possible values:
-//
-//   * `absl::IntervalOpenOpen`
-//   * `absl::IntervalOpenClosed`
-//   * `absl::IntervalClosedOpen`
-//   * `absl::IntervalClosedClosed`
-//
-// where "open" refers to an exclusive value (excluded) from the output, while
-// "closed" refers to an inclusive value (included) from the output.
-//
-// In the absence of an explicit return type `T`, `absl::Uniform()` will deduce
-// the return type based on the provided endpoint arguments {A lo, B hi}.
-// Given these endpoints, one of {A, B} will be chosen as the return type, if
-// a type can be implicitly converted into the other in a lossless way. The
-// lack of any such implicit conversion between {A, B} will produce a
-// compile-time error
-//
-// See https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
-//
-// Example:
-//
-//   absl::BitGen bitgen;
-//
-//   // Produce a random float value between 0.0 and 1.0, inclusive
-//   auto x = absl::Uniform(absl::IntervalClosedClosed, bitgen, 0.0f, 1.0f);
-//
-//   // The most common interval of `absl::IntervalClosedOpen` is available by
-//   // default:
-//
-//   auto x = absl::Uniform(bitgen, 0.0f, 1.0f);
-//
-//   // Return-types are typically inferred from the arguments, however callers
-//   // can optionally provide an explicit return-type to the template.
-//
-//   auto x = absl::Uniform<float>(bitgen, 0, 1);
-//
-template <typename R = void, typename TagType, typename URBG>
-typename absl::enable_if_t<!std::is_same<R, void>::value, R>  //
-Uniform(TagType tag,
-        URBG&& urbg,  // NOLINT(runtime/references)
-        R lo, R hi) {
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = random_internal::UniformDistributionWrapper<R>;
-
-  auto a = random_internal::uniform_lower_bound(tag, lo, hi);
-  auto b = random_internal::uniform_upper_bound(tag, lo, hi);
-  if (!random_internal::is_uniform_range_valid(a, b)) return lo;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, tag, lo, hi);
-}
-
-// absl::Uniform<T>(bitgen, lo, hi)
-//
-// Overload of `Uniform()` using the default closed-open interval of [lo, hi),
-// and returning values of type `T`
-template <typename R = void, typename URBG>
-typename absl::enable_if_t<!std::is_same<R, void>::value, R>  //
-Uniform(URBG&& urbg,  // NOLINT(runtime/references)
-        R lo, R hi) {
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = random_internal::UniformDistributionWrapper<R>;
-  constexpr auto tag = absl::IntervalClosedOpen;
-
-  auto a = random_internal::uniform_lower_bound(tag, lo, hi);
-  auto b = random_internal::uniform_upper_bound(tag, lo, hi);
-  if (!random_internal::is_uniform_range_valid(a, b)) return lo;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, lo, hi);
-}
-
-// absl::Uniform(tag, bitgen, lo, hi)
-//
-// Overload of `Uniform()` using different (but compatible) lo, hi types. Note
-// that a compile-error will result if the return type cannot be deduced
-// correctly from the passed types.
-template <typename R = void, typename TagType, typename URBG, typename A,
-          typename B>
-typename absl::enable_if_t<std::is_same<R, void>::value,
-                           random_internal::uniform_inferred_return_t<A, B>>
-Uniform(TagType tag,
-        URBG&& urbg,  // NOLINT(runtime/references)
-        A lo, B hi) {
-  using gen_t = absl::decay_t<URBG>;
-  using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
-  using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
-
-  auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
-  auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
-  if (!random_internal::is_uniform_range_valid(a, b)) return lo;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, tag, static_cast<return_t>(lo),
-                                static_cast<return_t>(hi));
-}
-
-// absl::Uniform(bitgen, lo, hi)
-//
-// Overload of `Uniform()` using different (but compatible) lo, hi types and the
-// default closed-open interval of [lo, hi). Note that a compile-error will
-// result if the return type cannot be deduced correctly from the passed types.
-template <typename R = void, typename URBG, typename A, typename B>
-typename absl::enable_if_t<std::is_same<R, void>::value,
-                           random_internal::uniform_inferred_return_t<A, B>>
-Uniform(URBG&& urbg,  // NOLINT(runtime/references)
-        A lo, B hi) {
-  using gen_t = absl::decay_t<URBG>;
-  using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
-  using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
-
-  constexpr auto tag = absl::IntervalClosedOpen;
-  auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
-  auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
-  if (!random_internal::is_uniform_range_valid(a, b)) return lo;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, static_cast<return_t>(lo),
-                                static_cast<return_t>(hi));
-}
-
-// absl::Uniform<unsigned T>(bitgen)
-//
-// Overload of Uniform() using the minimum and maximum values of a given type
-// `T` (which must be unsigned), returning a value of type `unsigned T`
-template <typename R, typename URBG>
-typename absl::enable_if_t<!std::is_signed<R>::value, R>  //
-Uniform(URBG&& urbg) {  // NOLINT(runtime/references)
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = random_internal::UniformDistributionWrapper<R>;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg);
-}
-
-// -----------------------------------------------------------------------------
-// absl::Bernoulli(bitgen, p)
-// -----------------------------------------------------------------------------
-//
-// `absl::Bernoulli` produces a random boolean value, with probability `p`
-// (where 0.0 <= p <= 1.0) equaling `true`.
-//
-// Prefer `absl::Bernoulli` to produce boolean values over other alternatives
-// such as comparing an `absl::Uniform()` value to a specific output.
-//
-// See https://en.wikipedia.org/wiki/Bernoulli_distribution
-//
-// Example:
-//
-//   absl::BitGen bitgen;
-//   ...
-//   if (absl::Bernoulli(bitgen, 1.0/3721.0)) {
-//     std::cout << "Asteroid field navigation successful.";
-//   }
-//
-template <typename URBG>
-bool Bernoulli(URBG&& urbg,  // NOLINT(runtime/references)
-               double p) {
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = absl::bernoulli_distribution;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, p);
-}
-
-// -----------------------------------------------------------------------------
-// absl::Beta<T>(bitgen, alpha, beta)
-// -----------------------------------------------------------------------------
-//
-// `absl::Beta` produces a floating point number distributed in the closed
-// interval [0,1] and parameterized by two values `alpha` and `beta` as per a
-// Beta distribution. `T` must be a floating point type, but may be inferred
-// from the types of `alpha` and `beta`.
-//
-// See https://en.wikipedia.org/wiki/Beta_distribution.
-//
-// Example:
-//
-//   absl::BitGen bitgen;
-//   ...
-//   double sample = absl::Beta(bitgen, 3.0, 2.0);
-//
-template <typename RealType, typename URBG>
-RealType Beta(URBG&& urbg,  // NOLINT(runtime/references)
-              RealType alpha, RealType beta) {
-  static_assert(
-      std::is_floating_point<RealType>::value,
-      "Template-argument 'RealType' must be a floating-point type, in "
-      "absl::Beta<RealType, URBG>(...)");
-
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = typename absl::beta_distribution<RealType>;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, alpha, beta);
-}
-
-// -----------------------------------------------------------------------------
-// absl::Exponential<T>(bitgen, lambda = 1)
-// -----------------------------------------------------------------------------
-//
-// `absl::Exponential` produces a floating point number representing the
-// distance (time) between two consecutive events in a point process of events
-// occurring continuously and independently at a constant average rate. `T` must
-// be a floating point type, but may be inferred from the type of `lambda`.
-//
-// See https://en.wikipedia.org/wiki/Exponential_distribution.
-//
-// Example:
-//
-//   absl::BitGen bitgen;
-//   ...
-//   double call_length = absl::Exponential(bitgen, 7.0);
-//
-template <typename RealType, typename URBG>
-RealType Exponential(URBG&& urbg,  // NOLINT(runtime/references)
-                     RealType lambda = 1) {
-  static_assert(
-      std::is_floating_point<RealType>::value,
-      "Template-argument 'RealType' must be a floating-point type, in "
-      "absl::Exponential<RealType, URBG>(...)");
-
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = typename absl::exponential_distribution<RealType>;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, lambda);
-}
-
-// -----------------------------------------------------------------------------
-// absl::Gaussian<T>(bitgen, mean = 0, stddev = 1)
-// -----------------------------------------------------------------------------
-//
-// `absl::Gaussian` produces a floating point number selected from the Gaussian
-// (ie. "Normal") distribution. `T` must be a floating point type, but may be
-// inferred from the types of `mean` and `stddev`.
-//
-// See https://en.wikipedia.org/wiki/Normal_distribution
-//
-// Example:
-//
-//   absl::BitGen bitgen;
-//   ...
-//   double giraffe_height = absl::Gaussian(bitgen, 16.3, 3.3);
-//
-template <typename RealType, typename URBG>
-RealType Gaussian(URBG&& urbg,  // NOLINT(runtime/references)
-                  RealType mean = 0, RealType stddev = 1) {
-  static_assert(
-      std::is_floating_point<RealType>::value,
-      "Template-argument 'RealType' must be a floating-point type, in "
-      "absl::Gaussian<RealType, URBG>(...)");
-
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = typename absl::gaussian_distribution<RealType>;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, mean, stddev);
-}
-
-// -----------------------------------------------------------------------------
-// absl::LogUniform<T>(bitgen, lo, hi, base = 2)
-// -----------------------------------------------------------------------------
-//
-// `absl::LogUniform` produces random values distributed where the log to a
-// given base of all values is uniform in a closed interval [lo, hi]. `T` must
-// be an integral type, but may be inferred from the types of `lo` and `hi`.
-//
-// I.e., `LogUniform(0, n, b)` is uniformly distributed across buckets
-// [0], [1, b-1], [b, b^2-1] .. [b^(k-1), (b^k)-1] .. [b^floor(log(n, b)), n]
-// and is uniformly distributed within each bucket.
-//
-// The resulting probability density is inversely related to bucket size, though
-// values in the final bucket may be more likely than previous values. (In the
-// extreme case where n = b^i the final value will be tied with zero as the most
-// probable result.
-//
-// If `lo` is nonzero then this distribution is shifted to the desired interval,
-// so LogUniform(lo, hi, b) is equivalent to LogUniform(0, hi-lo, b)+lo.
-//
-// See http://ecolego.facilia.se/ecolego/show/Log-Uniform%20Distribution
-//
-// Example:
-//
-//   absl::BitGen bitgen;
-//   ...
-//   int v = absl::LogUniform(bitgen, 0, 1000);
-//
-template <typename IntType, typename URBG>
-IntType LogUniform(URBG&& urbg,  // NOLINT(runtime/references)
-                   IntType lo, IntType hi, IntType base = 2) {
-  static_assert(random_internal::IsIntegral<IntType>::value,
-                "Template-argument 'IntType' must be an integral type, in "
-                "absl::LogUniform<IntType, URBG>(...)");
-
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = typename absl::log_uniform_int_distribution<IntType>;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, lo, hi, base);
-}
-
-// -----------------------------------------------------------------------------
-// absl::Poisson<T>(bitgen, mean = 1)
-// -----------------------------------------------------------------------------
-//
-// `absl::Poisson` produces discrete probabilities for a given number of events
-// occurring within a fixed interval within the closed interval [0, max]. `T`
-// must be an integral type.
-//
-// See https://en.wikipedia.org/wiki/Poisson_distribution
-//
-// Example:
-//
-//   absl::BitGen bitgen;
-//   ...
-//   int requests_per_minute = absl::Poisson<int>(bitgen, 3.2);
-//
-template <typename IntType, typename URBG>
-IntType Poisson(URBG&& urbg,  // NOLINT(runtime/references)
-                double mean = 1.0) {
-  static_assert(random_internal::IsIntegral<IntType>::value,
-                "Template-argument 'IntType' must be an integral type, in "
-                "absl::Poisson<IntType, URBG>(...)");
-
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = typename absl::poisson_distribution<IntType>;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, mean);
-}
-
-// -----------------------------------------------------------------------------
-// absl::Zipf<T>(bitgen, hi = max, q = 2, v = 1)
-// -----------------------------------------------------------------------------
-//
-// `absl::Zipf` produces discrete probabilities commonly used for modelling of
-// rare events over the closed interval [0, hi]. The parameters `v` and `q`
-// determine the skew of the distribution. `T`  must be an integral type, but
-// may be inferred from the type of `hi`.
-//
-// See http://mathworld.wolfram.com/ZipfDistribution.html
-//
-// Example:
-//
-//   absl::BitGen bitgen;
-//   ...
-//   int term_rank = absl::Zipf<int>(bitgen);
-//
-template <typename IntType, typename URBG>
-IntType Zipf(URBG&& urbg,  // NOLINT(runtime/references)
-             IntType hi = (std::numeric_limits<IntType>::max)(), double q = 2.0,
-             double v = 1.0) {
-  static_assert(random_internal::IsIntegral<IntType>::value,
-                "Template-argument 'IntType' must be an integral type, in "
-                "absl::Zipf<IntType, URBG>(...)");
-
-  using gen_t = absl::decay_t<URBG>;
-  using distribution_t = typename absl::zipf_distribution<IntType>;
-
-  return random_internal::DistributionCaller<gen_t>::template Call<
-      distribution_t>(&urbg, hi, q, v);
-}
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedClosedTag, IntervalClosedClosed, {});
+    ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedClosedTag, IntervalClosed, {});
+    ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalClosedOpenTag, IntervalClosedOpen, {});
+    ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenOpenTag, IntervalOpenOpen, {});
+    ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenOpenTag, IntervalOpen, {});
+    ABSL_INTERNAL_INLINE_CONSTEXPR(IntervalOpenClosedTag, IntervalOpenClosed, {});
+
+    // -----------------------------------------------------------------------------
+    // absl::Uniform<T>(tag, bitgen, lo, hi)
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::Uniform()` produces random values of type `T` uniformly distributed in
+    // a defined interval {lo, hi}. The interval `tag` defines the type of interval
+    // which should be one of the following possible values:
+    //
+    //   * `absl::IntervalOpenOpen`
+    //   * `absl::IntervalOpenClosed`
+    //   * `absl::IntervalClosedOpen`
+    //   * `absl::IntervalClosedClosed`
+    //
+    // where "open" refers to an exclusive value (excluded) from the output, while
+    // "closed" refers to an inclusive value (included) from the output.
+    //
+    // In the absence of an explicit return type `T`, `absl::Uniform()` will deduce
+    // the return type based on the provided endpoint arguments {A lo, B hi}.
+    // Given these endpoints, one of {A, B} will be chosen as the return type, if
+    // a type can be implicitly converted into the other in a lossless way. The
+    // lack of any such implicit conversion between {A, B} will produce a
+    // compile-time error
+    //
+    // See https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+    //
+    // Example:
+    //
+    //   absl::BitGen bitgen;
+    //
+    //   // Produce a random float value between 0.0 and 1.0, inclusive
+    //   auto x = absl::Uniform(absl::IntervalClosedClosed, bitgen, 0.0f, 1.0f);
+    //
+    //   // The most common interval of `absl::IntervalClosedOpen` is available by
+    //   // default:
+    //
+    //   auto x = absl::Uniform(bitgen, 0.0f, 1.0f);
+    //
+    //   // Return-types are typically inferred from the arguments, however callers
+    //   // can optionally provide an explicit return-type to the template.
+    //
+    //   auto x = absl::Uniform<float>(bitgen, 0, 1);
+    //
+    template<typename R = void, typename TagType, typename URBG>
+    typename absl::enable_if_t<!std::is_same<R, void>::value, R>  //
+        Uniform(TagType tag,
+                URBG&& urbg,  // NOLINT(runtime/references)
+                R lo,
+                R hi)
+    {
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = random_internal::UniformDistributionWrapper<R>;
+
+        auto a = random_internal::uniform_lower_bound(tag, lo, hi);
+        auto b = random_internal::uniform_upper_bound(tag, lo, hi);
+        if (!random_internal::is_uniform_range_valid(a, b))
+            return lo;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, tag, lo, hi);
+    }
+
+    // absl::Uniform<T>(bitgen, lo, hi)
+    //
+    // Overload of `Uniform()` using the default closed-open interval of [lo, hi),
+    // and returning values of type `T`
+    template<typename R = void, typename URBG>
+    typename absl::enable_if_t<!std::is_same<R, void>::value, R>  //
+        Uniform(URBG&& urbg,                                      // NOLINT(runtime/references)
+                R lo,
+                R hi)
+    {
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = random_internal::UniformDistributionWrapper<R>;
+        constexpr auto tag = absl::IntervalClosedOpen;
+
+        auto a = random_internal::uniform_lower_bound(tag, lo, hi);
+        auto b = random_internal::uniform_upper_bound(tag, lo, hi);
+        if (!random_internal::is_uniform_range_valid(a, b))
+            return lo;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, lo, hi);
+    }
+
+    // absl::Uniform(tag, bitgen, lo, hi)
+    //
+    // Overload of `Uniform()` using different (but compatible) lo, hi types. Note
+    // that a compile-error will result if the return type cannot be deduced
+    // correctly from the passed types.
+    template<typename R = void, typename TagType, typename URBG, typename A, typename B>
+    typename absl::enable_if_t<std::is_same<R, void>::value, random_internal::uniform_inferred_return_t<A, B>>
+        Uniform(TagType tag,
+                URBG&& urbg,  // NOLINT(runtime/references)
+                A lo,
+                B hi)
+    {
+        using gen_t = absl::decay_t<URBG>;
+        using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
+        using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
+
+        auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
+        auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
+        if (!random_internal::is_uniform_range_valid(a, b))
+            return lo;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, tag, static_cast<return_t>(lo), static_cast<return_t>(hi));
+    }
+
+    // absl::Uniform(bitgen, lo, hi)
+    //
+    // Overload of `Uniform()` using different (but compatible) lo, hi types and the
+    // default closed-open interval of [lo, hi). Note that a compile-error will
+    // result if the return type cannot be deduced correctly from the passed types.
+    template<typename R = void, typename URBG, typename A, typename B>
+    typename absl::enable_if_t<std::is_same<R, void>::value, random_internal::uniform_inferred_return_t<A, B>>
+        Uniform(URBG&& urbg,  // NOLINT(runtime/references)
+                A lo,
+                B hi)
+    {
+        using gen_t = absl::decay_t<URBG>;
+        using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
+        using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
+
+        constexpr auto tag = absl::IntervalClosedOpen;
+        auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
+        auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
+        if (!random_internal::is_uniform_range_valid(a, b))
+            return lo;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, static_cast<return_t>(lo), static_cast<return_t>(hi));
+    }
+
+    // absl::Uniform<unsigned T>(bitgen)
+    //
+    // Overload of Uniform() using the minimum and maximum values of a given type
+    // `T` (which must be unsigned), returning a value of type `unsigned T`
+    template<typename R, typename URBG>
+    typename absl::enable_if_t<!std::is_signed<R>::value, R>  //
+        Uniform(URBG&& urbg)
+    {  // NOLINT(runtime/references)
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = random_internal::UniformDistributionWrapper<R>;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg);
+    }
+
+    // -----------------------------------------------------------------------------
+    // absl::Bernoulli(bitgen, p)
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::Bernoulli` produces a random boolean value, with probability `p`
+    // (where 0.0 <= p <= 1.0) equaling `true`.
+    //
+    // Prefer `absl::Bernoulli` to produce boolean values over other alternatives
+    // such as comparing an `absl::Uniform()` value to a specific output.
+    //
+    // See https://en.wikipedia.org/wiki/Bernoulli_distribution
+    //
+    // Example:
+    //
+    //   absl::BitGen bitgen;
+    //   ...
+    //   if (absl::Bernoulli(bitgen, 1.0/3721.0)) {
+    //     std::cout << "Asteroid field navigation successful.";
+    //   }
+    //
+    template<typename URBG>
+    bool Bernoulli(URBG&& urbg,  // NOLINT(runtime/references)
+                   double p)
+    {
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = absl::bernoulli_distribution;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, p);
+    }
+
+    // -----------------------------------------------------------------------------
+    // absl::Beta<T>(bitgen, alpha, beta)
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::Beta` produces a floating point number distributed in the closed
+    // interval [0,1] and parameterized by two values `alpha` and `beta` as per a
+    // Beta distribution. `T` must be a floating point type, but may be inferred
+    // from the types of `alpha` and `beta`.
+    //
+    // See https://en.wikipedia.org/wiki/Beta_distribution.
+    //
+    // Example:
+    //
+    //   absl::BitGen bitgen;
+    //   ...
+    //   double sample = absl::Beta(bitgen, 3.0, 2.0);
+    //
+    template<typename RealType, typename URBG>
+    RealType Beta(URBG&& urbg,  // NOLINT(runtime/references)
+                  RealType alpha,
+                  RealType beta)
+    {
+        static_assert(
+            std::is_floating_point<RealType>::value,
+            "Template-argument 'RealType' must be a floating-point type, in "
+            "absl::Beta<RealType, URBG>(...)"
+        );
+
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = typename absl::beta_distribution<RealType>;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, alpha, beta);
+    }
+
+    // -----------------------------------------------------------------------------
+    // absl::Exponential<T>(bitgen, lambda = 1)
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::Exponential` produces a floating point number representing the
+    // distance (time) between two consecutive events in a point process of events
+    // occurring continuously and independently at a constant average rate. `T` must
+    // be a floating point type, but may be inferred from the type of `lambda`.
+    //
+    // See https://en.wikipedia.org/wiki/Exponential_distribution.
+    //
+    // Example:
+    //
+    //   absl::BitGen bitgen;
+    //   ...
+    //   double call_length = absl::Exponential(bitgen, 7.0);
+    //
+    template<typename RealType, typename URBG>
+    RealType Exponential(URBG&& urbg,  // NOLINT(runtime/references)
+                         RealType lambda = 1)
+    {
+        static_assert(
+            std::is_floating_point<RealType>::value,
+            "Template-argument 'RealType' must be a floating-point type, in "
+            "absl::Exponential<RealType, URBG>(...)"
+        );
+
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = typename absl::exponential_distribution<RealType>;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, lambda);
+    }
+
+    // -----------------------------------------------------------------------------
+    // absl::Gaussian<T>(bitgen, mean = 0, stddev = 1)
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::Gaussian` produces a floating point number selected from the Gaussian
+    // (ie. "Normal") distribution. `T` must be a floating point type, but may be
+    // inferred from the types of `mean` and `stddev`.
+    //
+    // See https://en.wikipedia.org/wiki/Normal_distribution
+    //
+    // Example:
+    //
+    //   absl::BitGen bitgen;
+    //   ...
+    //   double giraffe_height = absl::Gaussian(bitgen, 16.3, 3.3);
+    //
+    template<typename RealType, typename URBG>
+    RealType Gaussian(URBG&& urbg,  // NOLINT(runtime/references)
+                      RealType mean = 0,
+                      RealType stddev = 1)
+    {
+        static_assert(
+            std::is_floating_point<RealType>::value,
+            "Template-argument 'RealType' must be a floating-point type, in "
+            "absl::Gaussian<RealType, URBG>(...)"
+        );
+
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = typename absl::gaussian_distribution<RealType>;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, mean, stddev);
+    }
+
+    // -----------------------------------------------------------------------------
+    // absl::LogUniform<T>(bitgen, lo, hi, base = 2)
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::LogUniform` produces random values distributed where the log to a
+    // given base of all values is uniform in a closed interval [lo, hi]. `T` must
+    // be an integral type, but may be inferred from the types of `lo` and `hi`.
+    //
+    // I.e., `LogUniform(0, n, b)` is uniformly distributed across buckets
+    // [0], [1, b-1], [b, b^2-1] .. [b^(k-1), (b^k)-1] .. [b^floor(log(n, b)), n]
+    // and is uniformly distributed within each bucket.
+    //
+    // The resulting probability density is inversely related to bucket size, though
+    // values in the final bucket may be more likely than previous values. (In the
+    // extreme case where n = b^i the final value will be tied with zero as the most
+    // probable result.
+    //
+    // If `lo` is nonzero then this distribution is shifted to the desired interval,
+    // so LogUniform(lo, hi, b) is equivalent to LogUniform(0, hi-lo, b)+lo.
+    //
+    // See http://ecolego.facilia.se/ecolego/show/Log-Uniform%20Distribution
+    //
+    // Example:
+    //
+    //   absl::BitGen bitgen;
+    //   ...
+    //   int v = absl::LogUniform(bitgen, 0, 1000);
+    //
+    template<typename IntType, typename URBG>
+    IntType LogUniform(URBG&& urbg,  // NOLINT(runtime/references)
+                       IntType lo,
+                       IntType hi,
+                       IntType base = 2)
+    {
+        static_assert(random_internal::IsIntegral<IntType>::value, "Template-argument 'IntType' must be an integral type, in "
+                                                                   "absl::LogUniform<IntType, URBG>(...)");
+
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = typename absl::log_uniform_int_distribution<IntType>;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, lo, hi, base);
+    }
+
+    // -----------------------------------------------------------------------------
+    // absl::Poisson<T>(bitgen, mean = 1)
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::Poisson` produces discrete probabilities for a given number of events
+    // occurring within a fixed interval within the closed interval [0, max]. `T`
+    // must be an integral type.
+    //
+    // See https://en.wikipedia.org/wiki/Poisson_distribution
+    //
+    // Example:
+    //
+    //   absl::BitGen bitgen;
+    //   ...
+    //   int requests_per_minute = absl::Poisson<int>(bitgen, 3.2);
+    //
+    template<typename IntType, typename URBG>
+    IntType Poisson(URBG&& urbg,  // NOLINT(runtime/references)
+                    double mean = 1.0)
+    {
+        static_assert(random_internal::IsIntegral<IntType>::value, "Template-argument 'IntType' must be an integral type, in "
+                                                                   "absl::Poisson<IntType, URBG>(...)");
+
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = typename absl::poisson_distribution<IntType>;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, mean);
+    }
+
+    // -----------------------------------------------------------------------------
+    // absl::Zipf<T>(bitgen, hi = max, q = 2, v = 1)
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::Zipf` produces discrete probabilities commonly used for modelling of
+    // rare events over the closed interval [0, hi]. The parameters `v` and `q`
+    // determine the skew of the distribution. `T`  must be an integral type, but
+    // may be inferred from the type of `hi`.
+    //
+    // See http://mathworld.wolfram.com/ZipfDistribution.html
+    //
+    // Example:
+    //
+    //   absl::BitGen bitgen;
+    //   ...
+    //   int term_rank = absl::Zipf<int>(bitgen);
+    //
+    template<typename IntType, typename URBG>
+    IntType Zipf(URBG&& urbg,  // NOLINT(runtime/references)
+                 IntType hi = (std::numeric_limits<IntType>::max)(),
+                 double q = 2.0,
+                 double v = 1.0)
+    {
+        static_assert(random_internal::IsIntegral<IntType>::value, "Template-argument 'IntType' must be an integral type, in "
+                                                                   "absl::Zipf<IntType, URBG>(...)");
+
+        using gen_t = absl::decay_t<URBG>;
+        using distribution_t = typename absl::zipf_distribution<IntType>;
+
+        return random_internal::DistributionCaller<gen_t>::template Call<
+            distribution_t>(&urbg, hi, q, v);
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_DISTRIBUTIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/exponential_distribution.h b/CAPI/cpp/grpc/include/absl/random/exponential_distribution.h
index b5caf8a..4ae88fb 100644
--- a/CAPI/cpp/grpc/include/absl/random/exponential_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/exponential_distribution.h
@@ -26,140 +26,183 @@
 #include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::exponential_distribution:
-// Generates a number conforming to an exponential distribution and is
-// equivalent to the standard [rand.dist.pois.exp] distribution.
-template <typename RealType = double>
-class exponential_distribution {
- public:
-  using result_type = RealType;
-
-  class param_type {
-   public:
-    using distribution_type = exponential_distribution;
-
-    explicit param_type(result_type lambda = 1) : lambda_(lambda) {
-      assert(lambda > 0);
-      neg_inv_lambda_ = -result_type(1) / lambda_;
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::exponential_distribution:
+    // Generates a number conforming to an exponential distribution and is
+    // equivalent to the standard [rand.dist.pois.exp] distribution.
+    template<typename RealType = double>
+    class exponential_distribution
+    {
+    public:
+        using result_type = RealType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = exponential_distribution;
+
+            explicit param_type(result_type lambda = 1) :
+                lambda_(lambda)
+            {
+                assert(lambda > 0);
+                neg_inv_lambda_ = -result_type(1) / lambda_;
+            }
+
+            result_type lambda() const
+            {
+                return lambda_;
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.lambda_ == b.lambda_;
+            }
+
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            friend class exponential_distribution;
+
+            result_type lambda_;
+            result_type neg_inv_lambda_;
+
+            static_assert(
+                std::is_floating_point<RealType>::value,
+                "Class-template absl::exponential_distribution<> must be parameterized "
+                "using a floating-point type."
+            );
+        };
+
+        exponential_distribution() :
+            exponential_distribution(1)
+        {
+        }
+
+        explicit exponential_distribution(result_type lambda) :
+            param_(lambda)
+        {
+        }
+
+        explicit exponential_distribution(const param_type& p) :
+            param_(p)
+        {
+        }
+
+        void reset()
+        {
+        }
+
+        // Generating functions
+        template<typename URBG>
+        result_type operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            return (*this)(g, param_);
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                               const param_type& p);
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& p)
+        {
+            param_ = p;
+        }
+
+        result_type(min)() const
+        {
+            return 0;
+        }
+        result_type(max)() const
+        {
+            return std::numeric_limits<result_type>::infinity();
+        }
+
+        result_type lambda() const
+        {
+            return param_.lambda();
+        }
+
+        friend bool operator==(const exponential_distribution& a, const exponential_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const exponential_distribution& a, const exponential_distribution& b)
+        {
+            return a.param_ != b.param_;
+        }
+
+    private:
+        param_type param_;
+        random_internal::FastUniformBits<uint64_t> fast_u64_;
+    };
+
+    // --------------------------------------------------------------------------
+    // Implementation details follow
+    // --------------------------------------------------------------------------
+
+    template<typename RealType>
+    template<typename URBG>
+    typename exponential_distribution<RealType>::result_type
+        exponential_distribution<RealType>::operator()(
+            URBG& g,  // NOLINT(runtime/references)
+            const param_type& p
+        )
+    {
+        using random_internal::GenerateNegativeTag;
+        using random_internal::GenerateRealFromBits;
+        using real_type =
+            absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+        const result_type u = GenerateRealFromBits<real_type, GenerateNegativeTag,
+                                                   false>(fast_u64_(g));  // U(-1, 0)
+
+        // log1p(-x) is mathematically equivalent to log(1 - x) but has more
+        // accuracy for x near zero.
+        return p.neg_inv_lambda_ * std::log1p(u);
     }
 
-    result_type lambda() const { return lambda_; }
-
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.lambda_ == b.lambda_;
+    template<typename CharT, typename Traits, typename RealType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const exponential_distribution<RealType>& x
+    )
+    {
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
+        os << x.lambda();
+        return os;
     }
 
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
+    template<typename CharT, typename Traits, typename RealType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        exponential_distribution<RealType>& x
+    )
+    {  // NOLINT(runtime/references)
+        using result_type = typename exponential_distribution<RealType>::result_type;
+        using param_type = typename exponential_distribution<RealType>::param_type;
+        result_type lambda;
+
+        auto saver = random_internal::make_istream_state_saver(is);
+        lambda = random_internal::read_floating_point<result_type>(is);
+        if (!is.fail())
+        {
+            x.param(param_type(lambda));
+        }
+        return is;
     }
 
-   private:
-    friend class exponential_distribution;
-
-    result_type lambda_;
-    result_type neg_inv_lambda_;
-
-    static_assert(
-        std::is_floating_point<RealType>::value,
-        "Class-template absl::exponential_distribution<> must be parameterized "
-        "using a floating-point type.");
-  };
-
-  exponential_distribution() : exponential_distribution(1) {}
-
-  explicit exponential_distribution(result_type lambda) : param_(lambda) {}
-
-  explicit exponential_distribution(const param_type& p) : param_(p) {}
-
-  void reset() {}
-
-  // Generating functions
-  template <typename URBG>
-  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
-    return (*this)(g, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  param_type param() const { return param_; }
-  void param(const param_type& p) { param_ = p; }
-
-  result_type(min)() const { return 0; }
-  result_type(max)() const {
-    return std::numeric_limits<result_type>::infinity();
-  }
-
-  result_type lambda() const { return param_.lambda(); }
-
-  friend bool operator==(const exponential_distribution& a,
-                         const exponential_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const exponential_distribution& a,
-                         const exponential_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  param_type param_;
-  random_internal::FastUniformBits<uint64_t> fast_u64_;
-};
-
-// --------------------------------------------------------------------------
-// Implementation details follow
-// --------------------------------------------------------------------------
-
-template <typename RealType>
-template <typename URBG>
-typename exponential_distribution<RealType>::result_type
-exponential_distribution<RealType>::operator()(
-    URBG& g,  // NOLINT(runtime/references)
-    const param_type& p) {
-  using random_internal::GenerateNegativeTag;
-  using random_internal::GenerateRealFromBits;
-  using real_type =
-      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
-
-  const result_type u = GenerateRealFromBits<real_type, GenerateNegativeTag,
-                                             false>(fast_u64_(g));  // U(-1, 0)
-
-  // log1p(-x) is mathematically equivalent to log(1 - x) but has more
-  // accuracy for x near zero.
-  return p.neg_inv_lambda_ * std::log1p(u);
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const exponential_distribution<RealType>& x) {
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
-  os << x.lambda();
-  return os;
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,    // NOLINT(runtime/references)
-    exponential_distribution<RealType>& x) {  // NOLINT(runtime/references)
-  using result_type = typename exponential_distribution<RealType>::result_type;
-  using param_type = typename exponential_distribution<RealType>::param_type;
-  result_type lambda;
-
-  auto saver = random_internal::make_istream_state_saver(is);
-  lambda = random_internal::read_floating_point<result_type>(is);
-  if (!is.fail()) {
-    x.param(param_type(lambda));
-  }
-  return is;
-}
-
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/gaussian_distribution.h b/CAPI/cpp/grpc/include/absl/random/gaussian_distribution.h
index 4b07a5c..43aecc1 100644
--- a/CAPI/cpp/grpc/include/absl/random/gaussian_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/gaussian_distribution.h
@@ -33,243 +33,307 @@
 #include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// absl::gaussian_distribution_base implements the underlying ziggurat algorithm
-// using the ziggurat tables generated by the gaussian_distribution_gentables
-// binary.
-//
-// The specific algorithm has some of the improvements suggested by the
-// 2005 paper, "An Improved Ziggurat Method to Generate Normal Random Samples",
-// Jurgen A Doornik.  (https://www.doornik.com/research/ziggurat.pdf)
-class ABSL_DLL gaussian_distribution_base {
- public:
-  template <typename URBG>
-  inline double zignor(URBG& g);  // NOLINT(runtime/references)
-
- private:
-  friend class TableGenerator;
-
-  template <typename URBG>
-  inline double zignor_fallback(URBG& g,  // NOLINT(runtime/references)
-                                bool neg);
-
-  // Constants used for the gaussian distribution.
-  static constexpr double kR = 3.442619855899;  // Start of the tail.
-  static constexpr double kRInv = 0.29047645161474317;  // ~= (1.0 / kR) .
-  static constexpr double kV = 9.91256303526217e-3;
-  static constexpr uint64_t kMask = 0x07f;
-
-  // The ziggurat tables store the pdf(f) and inverse-pdf(x) for equal-area
-  // points on one-half of the normal distribution, where the pdf function,
-  // pdf = e ^ (-1/2 *x^2), assumes that the mean = 0 & stddev = 1.
-  //
-  // These tables are just over 2kb in size; larger tables might improve the
-  // distributions, but also lead to more cache pollution.
-  //
-  // x = {3.71308, 3.44261, 3.22308, ..., 0}
-  // f = {0.00101, 0.00266, 0.00554, ..., 1}
-  struct Tables {
-    double x[kMask + 2];
-    double f[kMask + 2];
-  };
-  static const Tables zg_;
-  random_internal::FastUniformBits<uint64_t> fast_u64_;
-};
-
-}  // namespace random_internal
-
-// absl::gaussian_distribution:
-// Generates a number conforming to a Gaussian distribution.
-template <typename RealType = double>
-class gaussian_distribution : random_internal::gaussian_distribution_base {
- public:
-  using result_type = RealType;
-
-  class param_type {
-   public:
-    using distribution_type = gaussian_distribution;
-
-    explicit param_type(result_type mean = 0, result_type stddev = 1)
-        : mean_(mean), stddev_(stddev) {}
-
-    // Returns the mean distribution parameter.  The mean specifies the location
-    // of the peak.  The default value is 0.0.
-    result_type mean() const { return mean_; }
-
-    // Returns the deviation distribution parameter.  The default value is 1.0.
-    result_type stddev() const { return stddev_; }
-
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.mean_ == b.mean_ && a.stddev_ == b.stddev_;
-    }
-
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // absl::gaussian_distribution_base implements the underlying ziggurat algorithm
+        // using the ziggurat tables generated by the gaussian_distribution_gentables
+        // binary.
+        //
+        // The specific algorithm has some of the improvements suggested by the
+        // 2005 paper, "An Improved Ziggurat Method to Generate Normal Random Samples",
+        // Jurgen A Doornik.  (https://www.doornik.com/research/ziggurat.pdf)
+        class ABSL_DLL gaussian_distribution_base
+        {
+        public:
+            template<typename URBG>
+            inline double zignor(URBG& g);  // NOLINT(runtime/references)
+
+        private:
+            friend class TableGenerator;
+
+            template<typename URBG>
+            inline double zignor_fallback(URBG& g,  // NOLINT(runtime/references)
+                                          bool neg);
+
+            // Constants used for the gaussian distribution.
+            static constexpr double kR = 3.442619855899;          // Start of the tail.
+            static constexpr double kRInv = 0.29047645161474317;  // ~= (1.0 / kR) .
+            static constexpr double kV = 9.91256303526217e-3;
+            static constexpr uint64_t kMask = 0x07f;
+
+            // The ziggurat tables store the pdf(f) and inverse-pdf(x) for equal-area
+            // points on one-half of the normal distribution, where the pdf function,
+            // pdf = e ^ (-1/2 *x^2), assumes that the mean = 0 & stddev = 1.
+            //
+            // These tables are just over 2kb in size; larger tables might improve the
+            // distributions, but also lead to more cache pollution.
+            //
+            // x = {3.71308, 3.44261, 3.22308, ..., 0}
+            // f = {0.00101, 0.00266, 0.00554, ..., 1}
+            struct Tables
+            {
+                double x[kMask + 2];
+                double f[kMask + 2];
+            };
+            static const Tables zg_;
+            random_internal::FastUniformBits<uint64_t> fast_u64_;
+        };
+
+    }  // namespace random_internal
+
+    // absl::gaussian_distribution:
+    // Generates a number conforming to a Gaussian distribution.
+    template<typename RealType = double>
+    class gaussian_distribution : random_internal::gaussian_distribution_base
+    {
+    public:
+        using result_type = RealType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = gaussian_distribution;
+
+            explicit param_type(result_type mean = 0, result_type stddev = 1) :
+                mean_(mean),
+                stddev_(stddev)
+            {
+            }
+
+            // Returns the mean distribution parameter.  The mean specifies the location
+            // of the peak.  The default value is 0.0.
+            result_type mean() const
+            {
+                return mean_;
+            }
+
+            // Returns the deviation distribution parameter.  The default value is 1.0.
+            result_type stddev() const
+            {
+                return stddev_;
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.mean_ == b.mean_ && a.stddev_ == b.stddev_;
+            }
+
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            result_type mean_;
+            result_type stddev_;
+
+            static_assert(
+                std::is_floating_point<RealType>::value,
+                "Class-template absl::gaussian_distribution<> must be parameterized "
+                "using a floating-point type."
+            );
+        };
+
+        gaussian_distribution() :
+            gaussian_distribution(0)
+        {
+        }
+
+        explicit gaussian_distribution(result_type mean, result_type stddev = 1) :
+            param_(mean, stddev)
+        {
+        }
+
+        explicit gaussian_distribution(const param_type& p) :
+            param_(p)
+        {
+        }
+
+        void reset()
+        {
+        }
+
+        // Generating functions
+        template<typename URBG>
+        result_type operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            return (*this)(g, param_);
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                               const param_type& p);
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& p)
+        {
+            param_ = p;
+        }
+
+        result_type(min)() const
+        {
+            return -std::numeric_limits<result_type>::infinity();
+        }
+        result_type(max)() const
+        {
+            return std::numeric_limits<result_type>::infinity();
+        }
+
+        result_type mean() const
+        {
+            return param_.mean();
+        }
+        result_type stddev() const
+        {
+            return param_.stddev();
+        }
+
+        friend bool operator==(const gaussian_distribution& a, const gaussian_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const gaussian_distribution& a, const gaussian_distribution& b)
+        {
+            return a.param_ != b.param_;
+        }
+
+    private:
+        param_type param_;
+    };
+
+    // --------------------------------------------------------------------------
+    // Implementation details only below
+    // --------------------------------------------------------------------------
+
+    template<typename RealType>
+    template<typename URBG>
+    typename gaussian_distribution<RealType>::result_type
+        gaussian_distribution<RealType>::operator()(
+            URBG& g,  // NOLINT(runtime/references)
+            const param_type& p
+        )
+    {
+        return p.mean() + p.stddev() * static_cast<result_type>(zignor(g));
     }
 
-   private:
-    result_type mean_;
-    result_type stddev_;
-
-    static_assert(
-        std::is_floating_point<RealType>::value,
-        "Class-template absl::gaussian_distribution<> must be parameterized "
-        "using a floating-point type.");
-  };
-
-  gaussian_distribution() : gaussian_distribution(0) {}
-
-  explicit gaussian_distribution(result_type mean, result_type stddev = 1)
-      : param_(mean, stddev) {}
-
-  explicit gaussian_distribution(const param_type& p) : param_(p) {}
-
-  void reset() {}
-
-  // Generating functions
-  template <typename URBG>
-  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
-    return (*this)(g, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  param_type param() const { return param_; }
-  void param(const param_type& p) { param_ = p; }
-
-  result_type(min)() const {
-    return -std::numeric_limits<result_type>::infinity();
-  }
-  result_type(max)() const {
-    return std::numeric_limits<result_type>::infinity();
-  }
-
-  result_type mean() const { return param_.mean(); }
-  result_type stddev() const { return param_.stddev(); }
-
-  friend bool operator==(const gaussian_distribution& a,
-                         const gaussian_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const gaussian_distribution& a,
-                         const gaussian_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  param_type param_;
-};
-
-// --------------------------------------------------------------------------
-// Implementation details only below
-// --------------------------------------------------------------------------
-
-template <typename RealType>
-template <typename URBG>
-typename gaussian_distribution<RealType>::result_type
-gaussian_distribution<RealType>::operator()(
-    URBG& g,  // NOLINT(runtime/references)
-    const param_type& p) {
-  return p.mean() + p.stddev() * static_cast<result_type>(zignor(g));
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const gaussian_distribution<RealType>& x) {
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
-  os << x.mean() << os.fill() << x.stddev();
-  return os;
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-    gaussian_distribution<RealType>& x) {   // NOLINT(runtime/references)
-  using result_type = typename gaussian_distribution<RealType>::result_type;
-  using param_type = typename gaussian_distribution<RealType>::param_type;
-
-  auto saver = random_internal::make_istream_state_saver(is);
-  auto mean = random_internal::read_floating_point<result_type>(is);
-  if (is.fail()) return is;
-  auto stddev = random_internal::read_floating_point<result_type>(is);
-  if (!is.fail()) {
-    x.param(param_type(mean, stddev));
-  }
-  return is;
-}
-
-namespace random_internal {
-
-template <typename URBG>
-inline double gaussian_distribution_base::zignor_fallback(URBG& g, bool neg) {
-  using random_internal::GeneratePositiveTag;
-  using random_internal::GenerateRealFromBits;
-
-  // This fallback path happens approximately 0.05% of the time.
-  double x, y;
-  do {
-    // kRInv = 1/r, U(0, 1)
-    x = kRInv *
-        std::log(GenerateRealFromBits<double, GeneratePositiveTag, false>(
-            fast_u64_(g)));
-    y = -std::log(
-        GenerateRealFromBits<double, GeneratePositiveTag, false>(fast_u64_(g)));
-  } while ((y + y) < (x * x));
-  return neg ? (x - kR) : (kR - x);
-}
-
-template <typename URBG>
-inline double gaussian_distribution_base::zignor(
-    URBG& g) {  // NOLINT(runtime/references)
-  using random_internal::GeneratePositiveTag;
-  using random_internal::GenerateRealFromBits;
-  using random_internal::GenerateSignedTag;
-
-  while (true) {
-    // We use a single uint64_t to generate both a double and a strip.
-    // These bits are unused when the generated double is > 1/2^5.
-    // This may introduce some bias from the duplicated low bits of small
-    // values (those smaller than 1/2^5, which all end up on the left tail).
-    uint64_t bits = fast_u64_(g);
-    int i = static_cast<int>(bits & kMask);  // pick a random strip
-    double j = GenerateRealFromBits<double, GenerateSignedTag, false>(
-        bits);  // U(-1, 1)
-    const double x = j * zg_.x[i];
-
-    // Retangular box. Handles >97% of all cases.
-    // For any given box, this handles between 75% and 99% of values.
-    // Equivalent to U(01) < (x[i+1] / x[i]), and when i == 0, ~93.5%
-    if (std::abs(x) < zg_.x[i + 1]) {
-      return x;
+    template<typename CharT, typename Traits, typename RealType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const gaussian_distribution<RealType>& x
+    )
+    {
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
+        os << x.mean() << os.fill() << x.stddev();
+        return os;
     }
 
-    // i == 0: Base box. Sample using a ratio of uniforms.
-    if (i == 0) {
-      // This path happens about 0.05% of the time.
-      return zignor_fallback(g, j < 0);
+    template<typename CharT, typename Traits, typename RealType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        gaussian_distribution<RealType>& x
+    )
+    {  // NOLINT(runtime/references)
+        using result_type = typename gaussian_distribution<RealType>::result_type;
+        using param_type = typename gaussian_distribution<RealType>::param_type;
+
+        auto saver = random_internal::make_istream_state_saver(is);
+        auto mean = random_internal::read_floating_point<result_type>(is);
+        if (is.fail())
+            return is;
+        auto stddev = random_internal::read_floating_point<result_type>(is);
+        if (!is.fail())
+        {
+            x.param(param_type(mean, stddev));
+        }
+        return is;
     }
 
-    // i > 0: Wedge samples using precomputed values.
-    double v = GenerateRealFromBits<double, GeneratePositiveTag, false>(
-        fast_u64_(g));  // U(0, 1)
-    if ((zg_.f[i + 1] + v * (zg_.f[i] - zg_.f[i + 1])) <
-        std::exp(-0.5 * x * x)) {
-      return x;
-    }
-
-    // The wedge was missed; reject the value and try again.
-  }
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    namespace random_internal
+    {
+
+        template<typename URBG>
+        inline double gaussian_distribution_base::zignor_fallback(URBG& g, bool neg)
+        {
+            using random_internal::GeneratePositiveTag;
+            using random_internal::GenerateRealFromBits;
+
+            // This fallback path happens approximately 0.05% of the time.
+            double x, y;
+            do
+            {
+                // kRInv = 1/r, U(0, 1)
+                x = kRInv *
+                    std::log(GenerateRealFromBits<double, GeneratePositiveTag, false>(
+                        fast_u64_(g)
+                    ));
+                y = -std::log(
+                    GenerateRealFromBits<double, GeneratePositiveTag, false>(fast_u64_(g))
+                );
+            } while ((y + y) < (x * x));
+            return neg ? (x - kR) : (kR - x);
+        }
+
+        template<typename URBG>
+        inline double gaussian_distribution_base::zignor(
+            URBG& g
+        )
+        {  // NOLINT(runtime/references)
+            using random_internal::GeneratePositiveTag;
+            using random_internal::GenerateRealFromBits;
+            using random_internal::GenerateSignedTag;
+
+            while (true)
+            {
+                // We use a single uint64_t to generate both a double and a strip.
+                // These bits are unused when the generated double is > 1/2^5.
+                // This may introduce some bias from the duplicated low bits of small
+                // values (those smaller than 1/2^5, which all end up on the left tail).
+                uint64_t bits = fast_u64_(g);
+                int i = static_cast<int>(bits & kMask);  // pick a random strip
+                double j = GenerateRealFromBits<double, GenerateSignedTag, false>(
+                    bits
+                );  // U(-1, 1)
+                const double x = j * zg_.x[i];
+
+                // Retangular box. Handles >97% of all cases.
+                // For any given box, this handles between 75% and 99% of values.
+                // Equivalent to U(01) < (x[i+1] / x[i]), and when i == 0, ~93.5%
+                if (std::abs(x) < zg_.x[i + 1])
+                {
+                    return x;
+                }
+
+                // i == 0: Base box. Sample using a ratio of uniforms.
+                if (i == 0)
+                {
+                    // This path happens about 0.05% of the time.
+                    return zignor_fallback(g, j < 0);
+                }
+
+                // i > 0: Wedge samples using precomputed values.
+                double v = GenerateRealFromBits<double, GeneratePositiveTag, false>(
+                    fast_u64_(g)
+                );  // U(0, 1)
+                if ((zg_.f[i + 1] + v * (zg_.f[i] - zg_.f[i + 1])) <
+                    std::exp(-0.5 * x * x))
+                {
+                    return x;
+                }
+
+                // The wedge was missed; reject the value and try again.
+            }
+        }
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_GAUSSIAN_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/chi_square.h b/CAPI/cpp/grpc/include/absl/random/internal/chi_square.h
index 07f4fbe..3a58175 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/chi_square.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/chi_square.h
@@ -28,62 +28,70 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-constexpr const char kChiSquared[] = "chi-squared";
+        constexpr const char kChiSquared[] = "chi-squared";
 
-// Returns the measured chi square value, using a single expected value.  This
-// assumes that the values in [begin, end) are uniformly distributed.
-template <typename Iterator>
-double ChiSquareWithExpected(Iterator begin, Iterator end, double expected) {
-  // Compute the sum and the number of buckets.
-  assert(expected >= 10);  // require at least 10 samples per bucket.
-  double chi_square = 0;
-  for (auto it = begin; it != end; it++) {
-    double d = static_cast<double>(*it) - expected;
-    chi_square += d * d;
-  }
-  chi_square = chi_square / expected;
-  return chi_square;
-}
+        // Returns the measured chi square value, using a single expected value.  This
+        // assumes that the values in [begin, end) are uniformly distributed.
+        template<typename Iterator>
+        double ChiSquareWithExpected(Iterator begin, Iterator end, double expected)
+        {
+            // Compute the sum and the number of buckets.
+            assert(expected >= 10);  // require at least 10 samples per bucket.
+            double chi_square = 0;
+            for (auto it = begin; it != end; it++)
+            {
+                double d = static_cast<double>(*it) - expected;
+                chi_square += d * d;
+            }
+            chi_square = chi_square / expected;
+            return chi_square;
+        }
 
-// Returns the measured chi square value, taking the actual value of each bucket
-// from the first set of iterators, and the expected value of each bucket from
-// the second set of iterators.
-template <typename Iterator, typename Expected>
-double ChiSquare(Iterator it, Iterator end, Expected eit, Expected eend) {
-  double chi_square = 0;
-  for (; it != end && eit != eend; ++it, ++eit) {
-    if (*it > 0) {
-      assert(*eit > 0);
-    }
-    double e = static_cast<double>(*eit);
-    double d = static_cast<double>(*it - *eit);
-    if (d != 0) {
-      assert(e > 0);
-      chi_square += (d * d) / e;
-    }
-  }
-  assert(it == end && eit == eend);
-  return chi_square;
-}
+        // Returns the measured chi square value, taking the actual value of each bucket
+        // from the first set of iterators, and the expected value of each bucket from
+        // the second set of iterators.
+        template<typename Iterator, typename Expected>
+        double ChiSquare(Iterator it, Iterator end, Expected eit, Expected eend)
+        {
+            double chi_square = 0;
+            for (; it != end && eit != eend; ++it, ++eit)
+            {
+                if (*it > 0)
+                {
+                    assert(*eit > 0);
+                }
+                double e = static_cast<double>(*eit);
+                double d = static_cast<double>(*it - *eit);
+                if (d != 0)
+                {
+                    assert(e > 0);
+                    chi_square += (d * d) / e;
+                }
+            }
+            assert(it == end && eit == eend);
+            return chi_square;
+        }
 
-// ======================================================================
-// The following methods can be used for an arbitrary significance level.
-//
+        // ======================================================================
+        // The following methods can be used for an arbitrary significance level.
+        //
 
-// Calculates critical chi-square values to produce the given p-value using a
-// bisection search for a value within epsilon, relying on the monotonicity of
-// ChiSquarePValue().
-double ChiSquareValue(int dof, double p);
+        // Calculates critical chi-square values to produce the given p-value using a
+        // bisection search for a value within epsilon, relying on the monotonicity of
+        // ChiSquarePValue().
+        double ChiSquareValue(int dof, double p);
 
-// Calculates the p-value (probability) of a given chi-square value.
-double ChiSquarePValue(double chi_square, int dof);
+        // Calculates the p-value (probability) of a given chi-square value.
+        double ChiSquarePValue(double chi_square, int dof);
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_CHI_SQUARE_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/distribution_caller.h b/CAPI/cpp/grpc/include/absl/random/internal/distribution_caller.h
index 0f162a4..c5ed558 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/distribution_caller.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/distribution_caller.h
@@ -24,72 +24,79 @@
 #include "absl/base/internal/fast_type_id.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-// DistributionCaller provides an opportunity to overload the general
-// mechanism for calling a distribution, allowing for mock-RNG classes
-// to intercept such calls.
-template <typename URBG>
-struct DistributionCaller {
-  static_assert(!std::is_pointer<URBG>::value,
-                "You must pass a reference, not a pointer.");
-  // SFINAE to detect whether the URBG type includes a member matching
-  // bool InvokeMock(base_internal::FastTypeIdType, void*, void*).
-  //
-  // These live inside BitGenRef so that they have friend access
-  // to MockingBitGen. (see similar methods in DistributionCaller).
-  template <template <class...> class Trait, class AlwaysVoid, class... Args>
-  struct detector : std::false_type {};
-  template <template <class...> class Trait, class... Args>
-  struct detector<Trait, absl::void_t<Trait<Args...>>, Args...>
-      : std::true_type {};
+        // DistributionCaller provides an opportunity to overload the general
+        // mechanism for calling a distribution, allowing for mock-RNG classes
+        // to intercept such calls.
+        template<typename URBG>
+        struct DistributionCaller
+        {
+            static_assert(!std::is_pointer<URBG>::value, "You must pass a reference, not a pointer.");
+            // SFINAE to detect whether the URBG type includes a member matching
+            // bool InvokeMock(base_internal::FastTypeIdType, void*, void*).
+            //
+            // These live inside BitGenRef so that they have friend access
+            // to MockingBitGen. (see similar methods in DistributionCaller).
+            template<template<class...> class Trait, class AlwaysVoid, class... Args>
+            struct detector : std::false_type
+            {
+            };
+            template<template<class...> class Trait, class... Args>
+            struct detector<Trait, absl::void_t<Trait<Args...>>, Args...> : std::true_type
+            {
+            };
 
-  template <class T>
-  using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
-      std::declval<::absl::base_internal::FastTypeIdType>(),
-      std::declval<void*>(), std::declval<void*>()));
+            template<class T>
+            using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
+                std::declval<::absl::base_internal::FastTypeIdType>(),
+                std::declval<void*>(),
+                std::declval<void*>()
+            ));
 
-  using HasInvokeMock = typename detector<invoke_mock_t, void, URBG>::type;
+            using HasInvokeMock = typename detector<invoke_mock_t, void, URBG>::type;
 
-  // Default implementation of distribution caller.
-  template <typename DistrT, typename... Args>
-  static typename DistrT::result_type Impl(std::false_type, URBG* urbg,
-                                           Args&&... args) {
-    DistrT dist(std::forward<Args>(args)...);
-    return dist(*urbg);
-  }
+            // Default implementation of distribution caller.
+            template<typename DistrT, typename... Args>
+            static typename DistrT::result_type Impl(std::false_type, URBG* urbg, Args&&... args)
+            {
+                DistrT dist(std::forward<Args>(args)...);
+                return dist(*urbg);
+            }
 
-  // Mock implementation of distribution caller.
-  // The underlying KeyT must match the KeyT constructed by MockOverloadSet.
-  template <typename DistrT, typename... Args>
-  static typename DistrT::result_type Impl(std::true_type, URBG* urbg,
-                                           Args&&... args) {
-    using ResultT = typename DistrT::result_type;
-    using ArgTupleT = std::tuple<absl::decay_t<Args>...>;
-    using KeyT = ResultT(DistrT, ArgTupleT);
+            // Mock implementation of distribution caller.
+            // The underlying KeyT must match the KeyT constructed by MockOverloadSet.
+            template<typename DistrT, typename... Args>
+            static typename DistrT::result_type Impl(std::true_type, URBG* urbg, Args&&... args)
+            {
+                using ResultT = typename DistrT::result_type;
+                using ArgTupleT = std::tuple<absl::decay_t<Args>...>;
+                using KeyT = ResultT(DistrT, ArgTupleT);
 
-    ArgTupleT arg_tuple(std::forward<Args>(args)...);
-    ResultT result;
-    if (!urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple,
-                          &result)) {
-      auto dist = absl::make_from_tuple<DistrT>(arg_tuple);
-      result = dist(*urbg);
-    }
-    return result;
-  }
+                ArgTupleT arg_tuple(std::forward<Args>(args)...);
+                ResultT result;
+                if (!urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple, &result))
+                {
+                    auto dist = absl::make_from_tuple<DistrT>(arg_tuple);
+                    result = dist(*urbg);
+                }
+                return result;
+            }
 
-  // Default implementation of distribution caller.
-  template <typename DistrT, typename... Args>
-  static typename DistrT::result_type Call(URBG* urbg, Args&&... args) {
-    return Impl<DistrT, Args...>(HasInvokeMock{}, urbg,
-                                 std::forward<Args>(args)...);
-  }
-};
+            // Default implementation of distribution caller.
+            template<typename DistrT, typename... Args>
+            static typename DistrT::result_type Call(URBG* urbg, Args&&... args)
+            {
+                return Impl<DistrT, Args...>(HasInvokeMock{}, urbg, std::forward<Args>(args)...);
+            }
+        };
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_DISTRIBUTION_CALLER_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/distribution_test_util.h b/CAPI/cpp/grpc/include/absl/random/internal/distribution_test_util.h
index 6d94cf6..619e324 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/distribution_test_util.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/distribution_test_util.h
@@ -25,89 +25,93 @@
 // NOTE: The functions in this file are test only, and are should not be used in
 // non-test code.
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// http://webspace.ship.edu/pgmarr/Geo441/Lectures/Lec%205%20-%20Normality%20Testing.pdf
-
-// Compute the 1st to 4th standard moments:
-// mean, variance, skewness, and kurtosis.
-// http://www.itl.nist.gov/div898/handbook/eda/section3/eda35b.htm
-struct DistributionMoments {
-  size_t n = 0;
-  double mean = 0.0;
-  double variance = 0.0;
-  double skewness = 0.0;
-  double kurtosis = 0.0;
-};
-DistributionMoments ComputeDistributionMoments(
-    absl::Span<const double> data_points);
-
-std::ostream& operator<<(std::ostream& os, const DistributionMoments& moments);
-
-// Computes the Z-score for a set of data with the given distribution moments
-// compared against `expected_mean`.
-double ZScore(double expected_mean, const DistributionMoments& moments);
-
-// Returns the probability of success required for a single trial to ensure that
-// after `num_trials` trials, the probability of at least one failure is no more
-// than `p_fail`.
-double RequiredSuccessProbability(double p_fail, int num_trials);
-
-// Computes the maximum distance from the mean tolerable, for Z-Tests that are
-// expected to pass with `acceptance_probability`. Will terminate if the
-// resulting tolerance is zero (due to passing in 0.0 for
-// `acceptance_probability` or rounding errors).
-//
-// For example,
-// MaxErrorTolerance(0.001) = 0.0
-// MaxErrorTolerance(0.5) = ~0.47
-// MaxErrorTolerance(1.0) = inf
-double MaxErrorTolerance(double acceptance_probability);
-
-// Approximation to inverse of the Error Function in double precision.
-// (http://people.maths.ox.ac.uk/gilesm/files/gems_erfinv.pdf)
-double erfinv(double x);
-
-// Beta(p, q) = Gamma(p) * Gamma(q) / Gamma(p+q)
-double beta(double p, double q);
-
-// The inverse of the normal survival function.
-double InverseNormalSurvival(double x);
-
-// Returns whether actual is "near" expected, based on the bound.
-bool Near(absl::string_view msg, double actual, double expected, double bound);
-
-// Implements the incomplete regularized beta function, AS63, BETAIN.
-//    https://www.jstor.org/stable/2346797
-//
-// BetaIncomplete(x, p, q), where
-//   `x` is the value of the upper limit
-//   `p` is beta parameter p, `q` is beta parameter q.
-//
-// NOTE: This is a test-only function which is only accurate to within, at most,
-// 1e-13 of the actual value.
-//
-double BetaIncomplete(double x, double p, double q);
-
-// Implements the inverse of the incomplete regularized beta function, AS109,
-// XINBTA.
-//   https://www.jstor.org/stable/2346798
-//   https://www.jstor.org/stable/2346887
-//
-// BetaIncompleteInv(p, q, beta, alhpa)
-//   `p` is beta parameter p, `q` is beta parameter q.
-//   `alpha` is the value of the lower tail area.
-//
-// NOTE: This is a test-only function and, when successful, is only accurate to
-// within ~1e-6 of the actual value; there are some cases where it diverges from
-// the actual value by much more than that.  The function uses Newton's method,
-// and thus the runtime is highly variable.
-double BetaIncompleteInv(double p, double q, double alpha);
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // http://webspace.ship.edu/pgmarr/Geo441/Lectures/Lec%205%20-%20Normality%20Testing.pdf
+
+        // Compute the 1st to 4th standard moments:
+        // mean, variance, skewness, and kurtosis.
+        // http://www.itl.nist.gov/div898/handbook/eda/section3/eda35b.htm
+        struct DistributionMoments
+        {
+            size_t n = 0;
+            double mean = 0.0;
+            double variance = 0.0;
+            double skewness = 0.0;
+            double kurtosis = 0.0;
+        };
+        DistributionMoments ComputeDistributionMoments(
+            absl::Span<const double> data_points
+        );
+
+        std::ostream& operator<<(std::ostream& os, const DistributionMoments& moments);
+
+        // Computes the Z-score for a set of data with the given distribution moments
+        // compared against `expected_mean`.
+        double ZScore(double expected_mean, const DistributionMoments& moments);
+
+        // Returns the probability of success required for a single trial to ensure that
+        // after `num_trials` trials, the probability of at least one failure is no more
+        // than `p_fail`.
+        double RequiredSuccessProbability(double p_fail, int num_trials);
+
+        // Computes the maximum distance from the mean tolerable, for Z-Tests that are
+        // expected to pass with `acceptance_probability`. Will terminate if the
+        // resulting tolerance is zero (due to passing in 0.0 for
+        // `acceptance_probability` or rounding errors).
+        //
+        // For example,
+        // MaxErrorTolerance(0.001) = 0.0
+        // MaxErrorTolerance(0.5) = ~0.47
+        // MaxErrorTolerance(1.0) = inf
+        double MaxErrorTolerance(double acceptance_probability);
+
+        // Approximation to inverse of the Error Function in double precision.
+        // (http://people.maths.ox.ac.uk/gilesm/files/gems_erfinv.pdf)
+        double erfinv(double x);
+
+        // Beta(p, q) = Gamma(p) * Gamma(q) / Gamma(p+q)
+        double beta(double p, double q);
+
+        // The inverse of the normal survival function.
+        double InverseNormalSurvival(double x);
+
+        // Returns whether actual is "near" expected, based on the bound.
+        bool Near(absl::string_view msg, double actual, double expected, double bound);
+
+        // Implements the incomplete regularized beta function, AS63, BETAIN.
+        //    https://www.jstor.org/stable/2346797
+        //
+        // BetaIncomplete(x, p, q), where
+        //   `x` is the value of the upper limit
+        //   `p` is beta parameter p, `q` is beta parameter q.
+        //
+        // NOTE: This is a test-only function which is only accurate to within, at most,
+        // 1e-13 of the actual value.
+        //
+        double BetaIncomplete(double x, double p, double q);
+
+        // Implements the inverse of the incomplete regularized beta function, AS109,
+        // XINBTA.
+        //   https://www.jstor.org/stable/2346798
+        //   https://www.jstor.org/stable/2346887
+        //
+        // BetaIncompleteInv(p, q, beta, alhpa)
+        //   `p` is beta parameter p, `q` is beta parameter q.
+        //   `alpha` is the value of the lower tail area.
+        //
+        // NOTE: This is a test-only function and, when successful, is only accurate to
+        // within ~1e-6 of the actual value; there are some cases where it diverges from
+        // the actual value by much more than that.  The function uses Newton's method,
+        // and thus the runtime is highly variable.
+        double BetaIncompleteInv(double p, double q, double alpha);
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_DISTRIBUTION_TEST_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/explicit_seed_seq.h b/CAPI/cpp/grpc/include/absl/random/internal/explicit_seed_seq.h
index 25f7915..5ba7c4d 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/explicit_seed_seq.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/explicit_seed_seq.h
@@ -25,68 +25,85 @@
 #include "absl/base/config.h"
 #include "absl/base/internal/endian.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-// This class conforms to the C++ Standard "Seed Sequence" concept
-// [rand.req.seedseq].
-//
-// An "ExplicitSeedSeq" is meant to provide a conformant interface for
-// forwarding pre-computed seed material to the constructor of a class
-// conforming to the "Uniform Random Bit Generator" concept. This class makes no
-// attempt to mutate the state provided by its constructor, and returns it
-// directly via ExplicitSeedSeq::generate().
-//
-// If this class is asked to generate more seed material than was provided to
-// the constructor, then the remaining bytes will be filled with deterministic,
-// nonrandom data.
-class ExplicitSeedSeq {
- public:
-  using result_type = uint32_t;
+        // This class conforms to the C++ Standard "Seed Sequence" concept
+        // [rand.req.seedseq].
+        //
+        // An "ExplicitSeedSeq" is meant to provide a conformant interface for
+        // forwarding pre-computed seed material to the constructor of a class
+        // conforming to the "Uniform Random Bit Generator" concept. This class makes no
+        // attempt to mutate the state provided by its constructor, and returns it
+        // directly via ExplicitSeedSeq::generate().
+        //
+        // If this class is asked to generate more seed material than was provided to
+        // the constructor, then the remaining bytes will be filled with deterministic,
+        // nonrandom data.
+        class ExplicitSeedSeq
+        {
+        public:
+            using result_type = uint32_t;
 
-  ExplicitSeedSeq() : state_() {}
+            ExplicitSeedSeq() :
+                state_()
+            {
+            }
 
-  // Copy and move both allowed.
-  ExplicitSeedSeq(const ExplicitSeedSeq& other) = default;
-  ExplicitSeedSeq& operator=(const ExplicitSeedSeq& other) = default;
-  ExplicitSeedSeq(ExplicitSeedSeq&& other) = default;
-  ExplicitSeedSeq& operator=(ExplicitSeedSeq&& other) = default;
+            // Copy and move both allowed.
+            ExplicitSeedSeq(const ExplicitSeedSeq& other) = default;
+            ExplicitSeedSeq& operator=(const ExplicitSeedSeq& other) = default;
+            ExplicitSeedSeq(ExplicitSeedSeq&& other) = default;
+            ExplicitSeedSeq& operator=(ExplicitSeedSeq&& other) = default;
 
-  template <typename Iterator>
-  ExplicitSeedSeq(Iterator begin, Iterator end) {
-    for (auto it = begin; it != end; it++) {
-      state_.push_back(*it & 0xffffffff);
-    }
-  }
+            template<typename Iterator>
+            ExplicitSeedSeq(Iterator begin, Iterator end)
+            {
+                for (auto it = begin; it != end; it++)
+                {
+                    state_.push_back(*it & 0xffffffff);
+                }
+            }
 
-  template <typename T>
-  ExplicitSeedSeq(std::initializer_list<T> il)
-      : ExplicitSeedSeq(il.begin(), il.end()) {}
+            template<typename T>
+            ExplicitSeedSeq(std::initializer_list<T> il) :
+                ExplicitSeedSeq(il.begin(), il.end())
+            {
+            }
 
-  size_t size() const { return state_.size(); }
+            size_t size() const
+            {
+                return state_.size();
+            }
 
-  template <typename OutIterator>
-  void param(OutIterator out) const {
-    std::copy(std::begin(state_), std::end(state_), out);
-  }
+            template<typename OutIterator>
+            void param(OutIterator out) const
+            {
+                std::copy(std::begin(state_), std::end(state_), out);
+            }
 
-  template <typename OutIterator>
-  void generate(OutIterator begin, OutIterator end) {
-    for (size_t index = 0; begin != end; begin++) {
-      *begin = state_.empty() ? 0 : state_[index++];
-      if (index >= state_.size()) {
-        index = 0;
-      }
-    }
-  }
+            template<typename OutIterator>
+            void generate(OutIterator begin, OutIterator end)
+            {
+                for (size_t index = 0; begin != end; begin++)
+                {
+                    *begin = state_.empty() ? 0 : state_[index++];
+                    if (index >= state_.size())
+                    {
+                        index = 0;
+                    }
+                }
+            }
 
- protected:
-  std::vector<uint32_t> state_;
-};
+        protected:
+            std::vector<uint32_t> state_;
+        };
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_EXPLICIT_SEED_SEQ_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/fast_uniform_bits.h b/CAPI/cpp/grpc/include/absl/random/internal/fast_uniform_bits.h
index f3a5c00..bb2dbe3 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/fast_uniform_bits.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/fast_uniform_bits.h
@@ -24,246 +24,259 @@
 #include "absl/meta/type_traits.h"
 #include "absl/random/internal/traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-// Returns true if the input value is zero or a power of two. Useful for
-// determining if the range of output values in a URBG
-template <typename UIntType>
-constexpr bool IsPowerOfTwoOrZero(UIntType n) {
-  return (n == 0) || ((n & (n - 1)) == 0);
-}
-
-// Computes the length of the range of values producible by the URBG, or returns
-// zero if that would encompass the entire range of representable values in
-// URBG::result_type.
-template <typename URBG>
-constexpr typename URBG::result_type RangeSize() {
-  using result_type = typename URBG::result_type;
-  static_assert((URBG::max)() != (URBG::min)(), "URBG range cannot be 0.");
-  return ((URBG::max)() == (std::numeric_limits<result_type>::max)() &&
-          (URBG::min)() == std::numeric_limits<result_type>::lowest())
-             ? result_type{0}
-             : ((URBG::max)() - (URBG::min)() + result_type{1});
-}
-
-// Computes the floor of the log. (i.e., std::floor(std::log2(N));
-template <typename UIntType>
-constexpr UIntType IntegerLog2(UIntType n) {
-  return (n <= 1) ? 0 : 1 + IntegerLog2(n >> 1);
-}
-
-// Returns the number of bits of randomness returned through
-// `PowerOfTwoVariate(urbg)`.
-template <typename URBG>
-constexpr size_t NumBits() {
-  return RangeSize<URBG>() == 0
-             ? std::numeric_limits<typename URBG::result_type>::digits
-             : IntegerLog2(RangeSize<URBG>());
-}
-
-// Given a shift value `n`, constructs a mask with exactly the low `n` bits set.
-// If `n == 0`, all bits are set.
-template <typename UIntType>
-constexpr UIntType MaskFromShift(size_t n) {
-  return ((n % std::numeric_limits<UIntType>::digits) == 0)
-             ? ~UIntType{0}
-             : (UIntType{1} << n) - UIntType{1};
-}
-
-// Tags used to dispatch FastUniformBits::generate to the simple or more complex
-// entropy extraction algorithm.
-struct SimplifiedLoopTag {};
-struct RejectionLoopTag {};
-
-// FastUniformBits implements a fast path to acquire uniform independent bits
-// from a type which conforms to the [rand.req.urbg] concept.
-// Parameterized by:
-//  `UIntType`: the result (output) type
-//
-// The std::independent_bits_engine [rand.adapt.ibits] adaptor can be
-// instantiated from an existing generator through a copy or a move. It does
-// not, however, facilitate the production of pseudorandom bits from an un-owned
-// generator that will outlive the std::independent_bits_engine instance.
-template <typename UIntType = uint64_t>
-class FastUniformBits {
- public:
-  using result_type = UIntType;
-
-  static constexpr result_type(min)() { return 0; }
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g);  // NOLINT(runtime/references)
-
- private:
-  static_assert(IsUnsigned<UIntType>::value,
-                "Class-template FastUniformBits<> must be parameterized using "
-                "an unsigned type.");
-
-  // Generate() generates a random value, dispatched on whether
-  // the underlying URBG must use rejection sampling to generate a value,
-  // or whether a simplified loop will suffice.
-  template <typename URBG>
-  result_type Generate(URBG& g,  // NOLINT(runtime/references)
-                       SimplifiedLoopTag);
-
-  template <typename URBG>
-  result_type Generate(URBG& g,  // NOLINT(runtime/references)
-                       RejectionLoopTag);
-};
-
-template <typename UIntType>
-template <typename URBG>
-typename FastUniformBits<UIntType>::result_type
-FastUniformBits<UIntType>::operator()(URBG& g) {  // NOLINT(runtime/references)
-  // kRangeMask is the mask used when sampling variates from the URBG when the
-  // width of the URBG range is not a power of 2.
-  // Y = (2 ^ kRange) - 1
-  static_assert((URBG::max)() > (URBG::min)(),
-                "URBG::max and URBG::min may not be equal.");
-
-  using tag = absl::conditional_t<IsPowerOfTwoOrZero(RangeSize<URBG>()),
-                                  SimplifiedLoopTag, RejectionLoopTag>;
-  return Generate(g, tag{});
-}
-
-template <typename UIntType>
-template <typename URBG>
-typename FastUniformBits<UIntType>::result_type
-FastUniformBits<UIntType>::Generate(URBG& g,  // NOLINT(runtime/references)
-                                    SimplifiedLoopTag) {
-  // The simplified version of FastUniformBits works only on URBGs that have
-  // a range that is a power of 2. In this case we simply loop and shift without
-  // attempting to balance the bits across calls.
-  static_assert(IsPowerOfTwoOrZero(RangeSize<URBG>()),
-                "incorrect Generate tag for URBG instance");
-
-  static constexpr size_t kResultBits =
-      std::numeric_limits<result_type>::digits;
-  static constexpr size_t kUrbgBits = NumBits<URBG>();
-  static constexpr size_t kIters =
-      (kResultBits / kUrbgBits) + (kResultBits % kUrbgBits != 0);
-  static constexpr size_t kShift = (kIters == 1) ? 0 : kUrbgBits;
-  static constexpr auto kMin = (URBG::min)();
-
-  result_type r = static_cast<result_type>(g() - kMin);
-  for (size_t n = 1; n < kIters; ++n) {
-    r = (r << kShift) + static_cast<result_type>(g() - kMin);
-  }
-  return r;
-}
-
-template <typename UIntType>
-template <typename URBG>
-typename FastUniformBits<UIntType>::result_type
-FastUniformBits<UIntType>::Generate(URBG& g,  // NOLINT(runtime/references)
-                                    RejectionLoopTag) {
-  static_assert(!IsPowerOfTwoOrZero(RangeSize<URBG>()),
-                "incorrect Generate tag for URBG instance");
-  using urbg_result_type = typename URBG::result_type;
-
-  // See [rand.adapt.ibits] for more details on the constants calculated below.
-  //
-  // It is preferable to use roughly the same number of bits from each generator
-  // call, however this is only possible when the number of bits provided by the
-  // URBG is a divisor of the number of bits in `result_type`. In all other
-  // cases, the number of bits used cannot always be the same, but it can be
-  // guaranteed to be off by at most 1. Thus we run two loops, one with a
-  // smaller bit-width size (`kSmallWidth`) and one with a larger width size
-  // (satisfying `kLargeWidth == kSmallWidth + 1`). The loops are run
-  // `kSmallIters` and `kLargeIters` times respectively such
-  // that
-  //
-  //    `kResultBits == kSmallIters * kSmallBits
-  //                    + kLargeIters * kLargeBits`
-  //
-  // where `kResultBits` is the total number of bits in `result_type`.
-  //
-  static constexpr size_t kResultBits =
-      std::numeric_limits<result_type>::digits;                      // w
-  static constexpr urbg_result_type kUrbgRange = RangeSize<URBG>();  // R
-  static constexpr size_t kUrbgBits = NumBits<URBG>();               // m
-
-  // compute the initial estimate of the bits used.
-  // [rand.adapt.ibits] 2 (c)
-  static constexpr size_t kA =  // ceil(w/m)
-      (kResultBits / kUrbgBits) + ((kResultBits % kUrbgBits) != 0);  // n'
-
-  static constexpr size_t kABits = kResultBits / kA;  // w0'
-  static constexpr urbg_result_type kARejection =
-      ((kUrbgRange >> kABits) << kABits);  // y0'
-
-  // refine the selection to reduce the rejection frequency.
-  static constexpr size_t kTotalIters =
-      ((kUrbgRange - kARejection) <= (kARejection / kA)) ? kA : (kA + 1);  // n
-
-  // [rand.adapt.ibits] 2 (b)
-  static constexpr size_t kSmallIters =
-      kTotalIters - (kResultBits % kTotalIters);                   // n0
-  static constexpr size_t kSmallBits = kResultBits / kTotalIters;  // w0
-  static constexpr urbg_result_type kSmallRejection =
-      ((kUrbgRange >> kSmallBits) << kSmallBits);  // y0
-
-  static constexpr size_t kLargeBits = kSmallBits + 1;  // w0+1
-  static constexpr urbg_result_type kLargeRejection =
-      ((kUrbgRange >> kLargeBits) << kLargeBits);  // y1
-
-  //
-  // Because `kLargeBits == kSmallBits + 1`, it follows that
-  //
-  //     `kResultBits == kSmallIters * kSmallBits + kLargeIters`
-  //
-  // and therefore
-  //
-  //     `kLargeIters == kTotalWidth % kSmallWidth`
-  //
-  // Intuitively, each iteration with the large width accounts for one unit
-  // of the remainder when `kTotalWidth` is divided by `kSmallWidth`. As
-  // mentioned above, if the URBG width is a divisor of `kTotalWidth`, then
-  // there would be no need for any large iterations (i.e., one loop would
-  // suffice), and indeed, in this case, `kLargeIters` would be zero.
-  static_assert(kResultBits == kSmallIters * kSmallBits +
-                                   (kTotalIters - kSmallIters) * kLargeBits,
-                "Error in looping constant calculations.");
-
-  // The small shift is essentially small bits, but due to the potential
-  // of generating a smaller result_type from a larger urbg type, the actual
-  // shift might be 0.
-  static constexpr size_t kSmallShift = kSmallBits % kResultBits;
-  static constexpr auto kSmallMask =
-      MaskFromShift<urbg_result_type>(kSmallShift);
-  static constexpr size_t kLargeShift = kLargeBits % kResultBits;
-  static constexpr auto kLargeMask =
-      MaskFromShift<urbg_result_type>(kLargeShift);
-
-  static constexpr auto kMin = (URBG::min)();
-
-  result_type s = 0;
-  for (size_t n = 0; n < kSmallIters; ++n) {
-    urbg_result_type v;
-    do {
-      v = g() - kMin;
-    } while (v >= kSmallRejection);
-
-    s = (s << kSmallShift) + static_cast<result_type>(v & kSmallMask);
-  }
-
-  for (size_t n = kSmallIters; n < kTotalIters; ++n) {
-    urbg_result_type v;
-    do {
-      v = g() - kMin;
-    } while (v >= kLargeRejection);
-
-    s = (s << kLargeShift) + static_cast<result_type>(v & kLargeMask);
-  }
-  return s;
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+        // Returns true if the input value is zero or a power of two. Useful for
+        // determining if the range of output values in a URBG
+        template<typename UIntType>
+        constexpr bool IsPowerOfTwoOrZero(UIntType n)
+        {
+            return (n == 0) || ((n & (n - 1)) == 0);
+        }
+
+        // Computes the length of the range of values producible by the URBG, or returns
+        // zero if that would encompass the entire range of representable values in
+        // URBG::result_type.
+        template<typename URBG>
+        constexpr typename URBG::result_type RangeSize()
+        {
+            using result_type = typename URBG::result_type;
+            static_assert((URBG::max)() != (URBG::min)(), "URBG range cannot be 0.");
+            return ((URBG::max)() == (std::numeric_limits<result_type>::max)() &&
+                    (URBG::min)() == std::numeric_limits<result_type>::lowest()) ?
+                       result_type{0} :
+                       ((URBG::max)() - (URBG::min)() + result_type{1});
+        }
+
+        // Computes the floor of the log. (i.e., std::floor(std::log2(N));
+        template<typename UIntType>
+        constexpr UIntType IntegerLog2(UIntType n)
+        {
+            return (n <= 1) ? 0 : 1 + IntegerLog2(n >> 1);
+        }
+
+        // Returns the number of bits of randomness returned through
+        // `PowerOfTwoVariate(urbg)`.
+        template<typename URBG>
+        constexpr size_t NumBits()
+        {
+            return RangeSize<URBG>() == 0 ? std::numeric_limits<typename URBG::result_type>::digits : IntegerLog2(RangeSize<URBG>());
+        }
+
+        // Given a shift value `n`, constructs a mask with exactly the low `n` bits set.
+        // If `n == 0`, all bits are set.
+        template<typename UIntType>
+        constexpr UIntType MaskFromShift(size_t n)
+        {
+            return ((n % std::numeric_limits<UIntType>::digits) == 0) ? ~UIntType{0} : (UIntType{1} << n) - UIntType{1};
+        }
+
+        // Tags used to dispatch FastUniformBits::generate to the simple or more complex
+        // entropy extraction algorithm.
+        struct SimplifiedLoopTag
+        {
+        };
+        struct RejectionLoopTag
+        {
+        };
+
+        // FastUniformBits implements a fast path to acquire uniform independent bits
+        // from a type which conforms to the [rand.req.urbg] concept.
+        // Parameterized by:
+        //  `UIntType`: the result (output) type
+        //
+        // The std::independent_bits_engine [rand.adapt.ibits] adaptor can be
+        // instantiated from an existing generator through a copy or a move. It does
+        // not, however, facilitate the production of pseudorandom bits from an un-owned
+        // generator that will outlive the std::independent_bits_engine instance.
+        template<typename UIntType = uint64_t>
+        class FastUniformBits
+        {
+        public:
+            using result_type = UIntType;
+
+            static constexpr result_type(min)()
+            {
+                return 0;
+            }
+            static constexpr result_type(max)()
+            {
+                return (std::numeric_limits<result_type>::max)();
+            }
+
+            template<typename URBG>
+            result_type operator()(URBG& g);  // NOLINT(runtime/references)
+
+        private:
+            static_assert(IsUnsigned<UIntType>::value, "Class-template FastUniformBits<> must be parameterized using "
+                                                       "an unsigned type.");
+
+            // Generate() generates a random value, dispatched on whether
+            // the underlying URBG must use rejection sampling to generate a value,
+            // or whether a simplified loop will suffice.
+            template<typename URBG>
+            result_type Generate(URBG& g,  // NOLINT(runtime/references)
+                                 SimplifiedLoopTag);
+
+            template<typename URBG>
+            result_type Generate(URBG& g,  // NOLINT(runtime/references)
+                                 RejectionLoopTag);
+        };
+
+        template<typename UIntType>
+        template<typename URBG>
+        typename FastUniformBits<UIntType>::result_type
+            FastUniformBits<UIntType>::operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            // kRangeMask is the mask used when sampling variates from the URBG when the
+            // width of the URBG range is not a power of 2.
+            // Y = (2 ^ kRange) - 1
+            static_assert((URBG::max)() > (URBG::min)(), "URBG::max and URBG::min may not be equal.");
+
+            using tag = absl::conditional_t<IsPowerOfTwoOrZero(RangeSize<URBG>()), SimplifiedLoopTag, RejectionLoopTag>;
+            return Generate(g, tag{});
+        }
+
+        template<typename UIntType>
+        template<typename URBG>
+        typename FastUniformBits<UIntType>::result_type
+            FastUniformBits<UIntType>::Generate(URBG& g,  // NOLINT(runtime/references)
+                                                SimplifiedLoopTag)
+        {
+            // The simplified version of FastUniformBits works only on URBGs that have
+            // a range that is a power of 2. In this case we simply loop and shift without
+            // attempting to balance the bits across calls.
+            static_assert(IsPowerOfTwoOrZero(RangeSize<URBG>()), "incorrect Generate tag for URBG instance");
+
+            static constexpr size_t kResultBits =
+                std::numeric_limits<result_type>::digits;
+            static constexpr size_t kUrbgBits = NumBits<URBG>();
+            static constexpr size_t kIters =
+                (kResultBits / kUrbgBits) + (kResultBits % kUrbgBits != 0);
+            static constexpr size_t kShift = (kIters == 1) ? 0 : kUrbgBits;
+            static constexpr auto kMin = (URBG::min)();
+
+            result_type r = static_cast<result_type>(g() - kMin);
+            for (size_t n = 1; n < kIters; ++n)
+            {
+                r = (r << kShift) + static_cast<result_type>(g() - kMin);
+            }
+            return r;
+        }
+
+        template<typename UIntType>
+        template<typename URBG>
+        typename FastUniformBits<UIntType>::result_type
+            FastUniformBits<UIntType>::Generate(URBG& g,  // NOLINT(runtime/references)
+                                                RejectionLoopTag)
+        {
+            static_assert(!IsPowerOfTwoOrZero(RangeSize<URBG>()), "incorrect Generate tag for URBG instance");
+            using urbg_result_type = typename URBG::result_type;
+
+            // See [rand.adapt.ibits] for more details on the constants calculated below.
+            //
+            // It is preferable to use roughly the same number of bits from each generator
+            // call, however this is only possible when the number of bits provided by the
+            // URBG is a divisor of the number of bits in `result_type`. In all other
+            // cases, the number of bits used cannot always be the same, but it can be
+            // guaranteed to be off by at most 1. Thus we run two loops, one with a
+            // smaller bit-width size (`kSmallWidth`) and one with a larger width size
+            // (satisfying `kLargeWidth == kSmallWidth + 1`). The loops are run
+            // `kSmallIters` and `kLargeIters` times respectively such
+            // that
+            //
+            //    `kResultBits == kSmallIters * kSmallBits
+            //                    + kLargeIters * kLargeBits`
+            //
+            // where `kResultBits` is the total number of bits in `result_type`.
+            //
+            static constexpr size_t kResultBits =
+                std::numeric_limits<result_type>::digits;                      // w
+            static constexpr urbg_result_type kUrbgRange = RangeSize<URBG>();  // R
+            static constexpr size_t kUrbgBits = NumBits<URBG>();               // m
+
+            // compute the initial estimate of the bits used.
+            // [rand.adapt.ibits] 2 (c)
+            static constexpr size_t kA =                                       // ceil(w/m)
+                (kResultBits / kUrbgBits) + ((kResultBits % kUrbgBits) != 0);  // n'
+
+            static constexpr size_t kABits = kResultBits / kA;  // w0'
+            static constexpr urbg_result_type kARejection =
+                ((kUrbgRange >> kABits) << kABits);  // y0'
+
+            // refine the selection to reduce the rejection frequency.
+            static constexpr size_t kTotalIters =
+                ((kUrbgRange - kARejection) <= (kARejection / kA)) ? kA : (kA + 1);  // n
+
+            // [rand.adapt.ibits] 2 (b)
+            static constexpr size_t kSmallIters =
+                kTotalIters - (kResultBits % kTotalIters);                   // n0
+            static constexpr size_t kSmallBits = kResultBits / kTotalIters;  // w0
+            static constexpr urbg_result_type kSmallRejection =
+                ((kUrbgRange >> kSmallBits) << kSmallBits);  // y0
+
+            static constexpr size_t kLargeBits = kSmallBits + 1;  // w0+1
+            static constexpr urbg_result_type kLargeRejection =
+                ((kUrbgRange >> kLargeBits) << kLargeBits);  // y1
+
+            //
+            // Because `kLargeBits == kSmallBits + 1`, it follows that
+            //
+            //     `kResultBits == kSmallIters * kSmallBits + kLargeIters`
+            //
+            // and therefore
+            //
+            //     `kLargeIters == kTotalWidth % kSmallWidth`
+            //
+            // Intuitively, each iteration with the large width accounts for one unit
+            // of the remainder when `kTotalWidth` is divided by `kSmallWidth`. As
+            // mentioned above, if the URBG width is a divisor of `kTotalWidth`, then
+            // there would be no need for any large iterations (i.e., one loop would
+            // suffice), and indeed, in this case, `kLargeIters` would be zero.
+            static_assert(kResultBits == kSmallIters * kSmallBits + (kTotalIters - kSmallIters) * kLargeBits, "Error in looping constant calculations.");
+
+            // The small shift is essentially small bits, but due to the potential
+            // of generating a smaller result_type from a larger urbg type, the actual
+            // shift might be 0.
+            static constexpr size_t kSmallShift = kSmallBits % kResultBits;
+            static constexpr auto kSmallMask =
+                MaskFromShift<urbg_result_type>(kSmallShift);
+            static constexpr size_t kLargeShift = kLargeBits % kResultBits;
+            static constexpr auto kLargeMask =
+                MaskFromShift<urbg_result_type>(kLargeShift);
+
+            static constexpr auto kMin = (URBG::min)();
+
+            result_type s = 0;
+            for (size_t n = 0; n < kSmallIters; ++n)
+            {
+                urbg_result_type v;
+                do
+                {
+                    v = g() - kMin;
+                } while (v >= kSmallRejection);
+
+                s = (s << kSmallShift) + static_cast<result_type>(v & kSmallMask);
+            }
+
+            for (size_t n = kSmallIters; n < kTotalIters; ++n)
+            {
+                urbg_result_type v;
+                do
+                {
+                    v = g() - kMin;
+                } while (v >= kLargeRejection);
+
+                s = (s << kLargeShift) + static_cast<result_type>(v & kLargeMask);
+            }
+            return s;
+        }
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_FAST_UNIFORM_BITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/fastmath.h b/CAPI/cpp/grpc/include/absl/random/internal/fastmath.h
index 963b769..a14ad44 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/fastmath.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/fastmath.h
@@ -24,34 +24,39 @@
 
 #include "absl/numeric/bits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// Compute log2(n) using integer operations.
-// While std::log2 is more accurate than std::log(n) / std::log(2), for
-// very large numbers--those close to std::numeric_limits<uint64_t>::max() - 2,
-// for instance--std::log2 rounds up rather than down, which introduces
-// definite skew in the results.
-inline int IntLog2Floor(uint64_t n) {
-  return (n <= 1) ? 0 : (63 - countl_zero(n));
-}
-inline int IntLog2Ceil(uint64_t n) {
-  return (n <= 1) ? 0 : (64 - countl_zero(n - 1));
-}
-
-inline double StirlingLogFactorial(double n) {
-  assert(n >= 1);
-  // Using Stirling's approximation.
-  constexpr double kLog2PI = 1.83787706640934548356;
-  const double logn = std::log(n);
-  const double ninv = 1.0 / static_cast<double>(n);
-  return n * logn - n + 0.5 * (kLog2PI + logn) + (1.0 / 12.0) * ninv -
-         (1.0 / 360.0) * ninv * ninv * ninv;
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // Compute log2(n) using integer operations.
+        // While std::log2 is more accurate than std::log(n) / std::log(2), for
+        // very large numbers--those close to std::numeric_limits<uint64_t>::max() - 2,
+        // for instance--std::log2 rounds up rather than down, which introduces
+        // definite skew in the results.
+        inline int IntLog2Floor(uint64_t n)
+        {
+            return (n <= 1) ? 0 : (63 - countl_zero(n));
+        }
+        inline int IntLog2Ceil(uint64_t n)
+        {
+            return (n <= 1) ? 0 : (64 - countl_zero(n - 1));
+        }
+
+        inline double StirlingLogFactorial(double n)
+        {
+            assert(n >= 1);
+            // Using Stirling's approximation.
+            constexpr double kLog2PI = 1.83787706640934548356;
+            const double logn = std::log(n);
+            const double ninv = 1.0 / static_cast<double>(n);
+            return n * logn - n + 0.5 * (kLog2PI + logn) + (1.0 / 12.0) * ninv -
+                   (1.0 / 360.0) * ninv * ninv * ninv;
+        }
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_FASTMATH_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/generate_real.h b/CAPI/cpp/grpc/include/absl/random/internal/generate_real.h
index b569450..9f89c14 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/generate_real.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/generate_real.h
@@ -28,117 +28,122 @@
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// Tristate tag types controlling the output of GenerateRealFromBits.
-struct GeneratePositiveTag {};
-struct GenerateNegativeTag {};
-struct GenerateSignedTag {};
-
-// GenerateRealFromBits generates a single real value from a single 64-bit
-// `bits` with template fields controlling the output.
-//
-// The `SignedTag` parameter controls whether positive, negative,
-// or either signed/unsigned may be returned.
-//   When SignedTag == GeneratePositiveTag, range is U(0, 1)
-//   When SignedTag == GenerateNegativeTag, range is U(-1, 0)
-//   When SignedTag == GenerateSignedTag, range is U(-1, 1)
-//
-// When the `IncludeZero` parameter is true, the function may return 0 for some
-// inputs, otherwise it never returns 0.
-//
-// When a value in U(0,1) is required, use:
-//   GenerateRealFromBits<double, PositiveValueT, true>;
-//
-// When a value in U(-1,1) is required, use:
-//   GenerateRealFromBits<double, SignedValueT, false>;
-//
-//   This generates more distinct values than the mathematical equivalent
-//   `U(0, 1) * 2.0 - 1.0`.
-//
-// Scaling the result by powers of 2 (and avoiding a multiply) is also possible:
-//   GenerateRealFromBits<double>(..., -1);  => U(0, 0.5)
-//   GenerateRealFromBits<double>(..., 1);   => U(0, 2)
-//
-template <typename RealType,  // Real type, either float or double.
-          typename SignedTag = GeneratePositiveTag,  // Whether a positive,
-                                                     // negative, or signed
-                                                     // value is generated.
-          bool IncludeZero = true>
-inline RealType GenerateRealFromBits(uint64_t bits, int exp_bias = 0) {
-  using real_type = RealType;
-  using uint_type = absl::conditional_t<std::is_same<real_type, float>::value,
-                                        uint32_t, uint64_t>;
-
-  static_assert(
-      (std::is_same<double, real_type>::value ||
-       std::is_same<float, real_type>::value),
-      "GenerateRealFromBits must be parameterized by either float or double.");
-
-  static_assert(sizeof(uint_type) == sizeof(real_type),
-                "Mismatched unsinged and real types.");
-
-  static_assert((std::numeric_limits<real_type>::is_iec559 &&
-                 std::numeric_limits<real_type>::radix == 2),
-                "RealType representation is not IEEE 754 binary.");
-
-  static_assert((std::is_same<SignedTag, GeneratePositiveTag>::value ||
-                 std::is_same<SignedTag, GenerateNegativeTag>::value ||
-                 std::is_same<SignedTag, GenerateSignedTag>::value),
-                "");
-
-  static constexpr int kExp = std::numeric_limits<real_type>::digits - 1;
-  static constexpr uint_type kMask = (static_cast<uint_type>(1) << kExp) - 1u;
-  static constexpr int kUintBits = sizeof(uint_type) * 8;
-
-  int exp = exp_bias + int{std::numeric_limits<real_type>::max_exponent - 2};
-
-  // Determine the sign bit.
-  // Depending on the SignedTag, this may use the left-most bit
-  // or it may be a constant value.
-  uint_type sign = std::is_same<SignedTag, GenerateNegativeTag>::value
-                       ? (static_cast<uint_type>(1) << (kUintBits - 1))
-                       : 0;
-  if (std::is_same<SignedTag, GenerateSignedTag>::value) {
-    if (std::is_same<uint_type, uint64_t>::value) {
-      sign = bits & uint64_t{0x8000000000000000};
-    }
-    if (std::is_same<uint_type, uint32_t>::value) {
-      const uint64_t tmp = bits & uint64_t{0x8000000000000000};
-      sign = static_cast<uint32_t>(tmp >> 32);
-    }
-    // adjust the bits and the exponent to account for removing
-    // the leading bit.
-    bits = bits & uint64_t{0x7FFFFFFFFFFFFFFF};
-    exp++;
-  }
-  if (IncludeZero) {
-    if (bits == 0u) return 0;
-  }
-
-  // Number of leading zeros is mapped to the exponent: 2^-clz
-  // bits is 0..01xxxxxx. After shifting, we're left with 1xxx...0..0
-  int clz = countl_zero(bits);
-  bits <<= (IncludeZero ? clz : (clz & 63));  // remove 0-bits.
-  exp -= clz;                                 // set the exponent.
-  bits >>= (63 - kExp);
-
-  // Construct the 32-bit or 64-bit IEEE 754 floating-point value from
-  // the individual fields: sign, exp, mantissa(bits).
-  uint_type val = sign | (static_cast<uint_type>(exp) << kExp) |
-                  (static_cast<uint_type>(bits) & kMask);
-
-  // bit_cast to the output-type
-  real_type result;
-  memcpy(static_cast<void*>(&result), static_cast<const void*>(&val),
-         sizeof(result));
-  return result;
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // Tristate tag types controlling the output of GenerateRealFromBits.
+        struct GeneratePositiveTag
+        {
+        };
+        struct GenerateNegativeTag
+        {
+        };
+        struct GenerateSignedTag
+        {
+        };
+
+        // GenerateRealFromBits generates a single real value from a single 64-bit
+        // `bits` with template fields controlling the output.
+        //
+        // The `SignedTag` parameter controls whether positive, negative,
+        // or either signed/unsigned may be returned.
+        //   When SignedTag == GeneratePositiveTag, range is U(0, 1)
+        //   When SignedTag == GenerateNegativeTag, range is U(-1, 0)
+        //   When SignedTag == GenerateSignedTag, range is U(-1, 1)
+        //
+        // When the `IncludeZero` parameter is true, the function may return 0 for some
+        // inputs, otherwise it never returns 0.
+        //
+        // When a value in U(0,1) is required, use:
+        //   GenerateRealFromBits<double, PositiveValueT, true>;
+        //
+        // When a value in U(-1,1) is required, use:
+        //   GenerateRealFromBits<double, SignedValueT, false>;
+        //
+        //   This generates more distinct values than the mathematical equivalent
+        //   `U(0, 1) * 2.0 - 1.0`.
+        //
+        // Scaling the result by powers of 2 (and avoiding a multiply) is also possible:
+        //   GenerateRealFromBits<double>(..., -1);  => U(0, 0.5)
+        //   GenerateRealFromBits<double>(..., 1);   => U(0, 2)
+        //
+        template<typename RealType,                         // Real type, either float or double.
+                 typename SignedTag = GeneratePositiveTag,  // Whether a positive,
+                                                            // negative, or signed
+                                                            // value is generated.
+                 bool IncludeZero = true>
+        inline RealType GenerateRealFromBits(uint64_t bits, int exp_bias = 0)
+        {
+            using real_type = RealType;
+            using uint_type = absl::conditional_t<std::is_same<real_type, float>::value, uint32_t, uint64_t>;
+
+            static_assert(
+                (std::is_same<double, real_type>::value ||
+                 std::is_same<float, real_type>::value),
+                "GenerateRealFromBits must be parameterized by either float or double."
+            );
+
+            static_assert(sizeof(uint_type) == sizeof(real_type), "Mismatched unsinged and real types.");
+
+            static_assert((std::numeric_limits<real_type>::is_iec559 && std::numeric_limits<real_type>::radix == 2), "RealType representation is not IEEE 754 binary.");
+
+            static_assert((std::is_same<SignedTag, GeneratePositiveTag>::value || std::is_same<SignedTag, GenerateNegativeTag>::value || std::is_same<SignedTag, GenerateSignedTag>::value), "");
+
+            static constexpr int kExp = std::numeric_limits<real_type>::digits - 1;
+            static constexpr uint_type kMask = (static_cast<uint_type>(1) << kExp) - 1u;
+            static constexpr int kUintBits = sizeof(uint_type) * 8;
+
+            int exp = exp_bias + int{std::numeric_limits<real_type>::max_exponent - 2};
+
+            // Determine the sign bit.
+            // Depending on the SignedTag, this may use the left-most bit
+            // or it may be a constant value.
+            uint_type sign = std::is_same<SignedTag, GenerateNegativeTag>::value ? (static_cast<uint_type>(1) << (kUintBits - 1)) : 0;
+            if (std::is_same<SignedTag, GenerateSignedTag>::value)
+            {
+                if (std::is_same<uint_type, uint64_t>::value)
+                {
+                    sign = bits & uint64_t{0x8000000000000000};
+                }
+                if (std::is_same<uint_type, uint32_t>::value)
+                {
+                    const uint64_t tmp = bits & uint64_t{0x8000000000000000};
+                    sign = static_cast<uint32_t>(tmp >> 32);
+                }
+                // adjust the bits and the exponent to account for removing
+                // the leading bit.
+                bits = bits & uint64_t{0x7FFFFFFFFFFFFFFF};
+                exp++;
+            }
+            if (IncludeZero)
+            {
+                if (bits == 0u)
+                    return 0;
+            }
+
+            // Number of leading zeros is mapped to the exponent: 2^-clz
+            // bits is 0..01xxxxxx. After shifting, we're left with 1xxx...0..0
+            int clz = countl_zero(bits);
+            bits <<= (IncludeZero ? clz : (clz & 63));  // remove 0-bits.
+            exp -= clz;                                 // set the exponent.
+            bits >>= (63 - kExp);
+
+            // Construct the 32-bit or 64-bit IEEE 754 floating-point value from
+            // the individual fields: sign, exp, mantissa(bits).
+            uint_type val = sign | (static_cast<uint_type>(exp) << kExp) |
+                            (static_cast<uint_type>(bits) & kMask);
+
+            // bit_cast to the output-type
+            real_type result;
+            memcpy(static_cast<void*>(&result), static_cast<const void*>(&val), sizeof(result));
+            return result;
+        }
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/iostream_state_saver.h b/CAPI/cpp/grpc/include/absl/random/internal/iostream_state_saver.h
index e6e242e..06e1472 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/iostream_state_saver.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/iostream_state_saver.h
@@ -23,54 +23,65 @@
 #include "absl/meta/type_traits.h"
 #include "absl/numeric/int128.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// The null_state_saver does nothing.
-template <typename T>
-class null_state_saver {
- public:
-  using stream_type = T;
-  using flags_type = std::ios_base::fmtflags;
-
-  null_state_saver(T&, flags_type) {}
-  ~null_state_saver() {}
-};
-
-// ostream_state_saver is a RAII object to save and restore the common
-// basic_ostream flags used when implementing `operator <<()` on any of
-// the absl random distributions.
-template <typename OStream>
-class ostream_state_saver {
- public:
-  using ostream_type = OStream;
-  using flags_type = std::ios_base::fmtflags;
-  using fill_type = typename ostream_type::char_type;
-  using precision_type = std::streamsize;
-
-  ostream_state_saver(ostream_type& os,  // NOLINT(runtime/references)
-                      flags_type flags, fill_type fill)
-      : os_(os),
-        flags_(os.flags(flags)),
-        fill_(os.fill(fill)),
-        precision_(os.precision()) {
-    // Save state in initialized variables.
-  }
-
-  ~ostream_state_saver() {
-    // Restore saved state.
-    os_.precision(precision_);
-    os_.fill(fill_);
-    os_.flags(flags_);
-  }
-
- private:
-  ostream_type& os_;
-  const flags_type flags_;
-  const fill_type fill_;
-  const precision_type precision_;
-};
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // The null_state_saver does nothing.
+        template<typename T>
+        class null_state_saver
+        {
+        public:
+            using stream_type = T;
+            using flags_type = std::ios_base::fmtflags;
+
+            null_state_saver(T&, flags_type)
+            {
+            }
+            ~null_state_saver()
+            {
+            }
+        };
+
+        // ostream_state_saver is a RAII object to save and restore the common
+        // basic_ostream flags used when implementing `operator <<()` on any of
+        // the absl random distributions.
+        template<typename OStream>
+        class ostream_state_saver
+        {
+        public:
+            using ostream_type = OStream;
+            using flags_type = std::ios_base::fmtflags;
+            using fill_type = typename ostream_type::char_type;
+            using precision_type = std::streamsize;
+
+            ostream_state_saver(ostream_type& os,  // NOLINT(runtime/references)
+                                flags_type flags,
+                                fill_type fill) :
+                os_(os),
+                flags_(os.flags(flags)),
+                fill_(os.fill(fill)),
+                precision_(os.precision())
+            {
+                // Save state in initialized variables.
+            }
+
+            ~ostream_state_saver()
+            {
+                // Restore saved state.
+                os_.precision(precision_);
+                os_.fill(fill_);
+                os_.flags(flags_);
+            }
+
+        private:
+            ostream_type& os_;
+            const flags_type flags_;
+            const fill_type fill_;
+            const precision_type precision_;
+        };
 
 #if defined(__NDK_MAJOR__) && __NDK_MAJOR__ < 16
 #define ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT 1
@@ -78,168 +89,192 @@ class ostream_state_saver {
 #define ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT 0
 #endif
 
-template <typename CharT, typename Traits>
-ostream_state_saver<std::basic_ostream<CharT, Traits>> make_ostream_state_saver(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    std::ios_base::fmtflags flags = std::ios_base::dec | std::ios_base::left |
+        template<typename CharT, typename Traits>
+        ostream_state_saver<std::basic_ostream<CharT, Traits>> make_ostream_state_saver(
+            std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+            std::ios_base::fmtflags flags = std::ios_base::dec | std::ios_base::left |
 #if ABSL_RANDOM_INTERNAL_IOSTREAM_HEXFLOAT
-                                    std::ios_base::fixed |
+                                            std::ios_base::fixed |
 #endif
-                                    std::ios_base::scientific) {
-  using result_type = ostream_state_saver<std::basic_ostream<CharT, Traits>>;
-  return result_type(os, flags, os.widen(' '));
-}
-
-template <typename T>
-typename absl::enable_if_t<!std::is_base_of<std::ios_base, T>::value,
-                           null_state_saver<T>>
-make_ostream_state_saver(T& is,  // NOLINT(runtime/references)
-                         std::ios_base::fmtflags flags = std::ios_base::dec) {
-  std::cerr << "null_state_saver";
-  using result_type = null_state_saver<T>;
-  return result_type(is, flags);
-}
-
-// stream_precision_helper<type>::kPrecision returns the base 10 precision
-// required to stream and reconstruct a real type exact binary value through
-// a binary->decimal->binary transition.
-template <typename T>
-struct stream_precision_helper {
-  // max_digits10 may be 0 on MSVC; if so, use digits10 + 3.
-  static constexpr int kPrecision =
-      (std::numeric_limits<T>::max_digits10 > std::numeric_limits<T>::digits10)
-          ? std::numeric_limits<T>::max_digits10
-          : (std::numeric_limits<T>::digits10 + 3);
-};
-
-template <>
-struct stream_precision_helper<float> {
-  static constexpr int kPrecision = 9;
-};
-template <>
-struct stream_precision_helper<double> {
-  static constexpr int kPrecision = 17;
-};
-template <>
-struct stream_precision_helper<long double> {
-  static constexpr int kPrecision = 36;  // assuming fp128
-};
-
-// istream_state_saver is a RAII object to save and restore the common
-// std::basic_istream<> flags used when implementing `operator >>()` on any of
-// the absl random distributions.
-template <typename IStream>
-class istream_state_saver {
- public:
-  using istream_type = IStream;
-  using flags_type = std::ios_base::fmtflags;
-
-  istream_state_saver(istream_type& is,  // NOLINT(runtime/references)
-                      flags_type flags)
-      : is_(is), flags_(is.flags(flags)) {}
-
-  ~istream_state_saver() { is_.flags(flags_); }
-
- private:
-  istream_type& is_;
-  flags_type flags_;
-};
-
-template <typename CharT, typename Traits>
-istream_state_saver<std::basic_istream<CharT, Traits>> make_istream_state_saver(
-    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-    std::ios_base::fmtflags flags = std::ios_base::dec |
-                                    std::ios_base::scientific |
-                                    std::ios_base::skipws) {
-  using result_type = istream_state_saver<std::basic_istream<CharT, Traits>>;
-  return result_type(is, flags);
-}
-
-template <typename T>
-typename absl::enable_if_t<!std::is_base_of<std::ios_base, T>::value,
-                           null_state_saver<T>>
-make_istream_state_saver(T& is,  // NOLINT(runtime/references)
-                         std::ios_base::fmtflags flags = std::ios_base::dec) {
-  using result_type = null_state_saver<T>;
-  return result_type(is, flags);
-}
-
-// stream_format_type<T> is a helper struct to convert types which
-// basic_iostream cannot output as decimal numbers into types which
-// basic_iostream can output as decimal numbers. Specifically:
-// * signed/unsigned char-width types are converted to int.
-// * TODO(lar): __int128 => uint128, except there is no operator << yet.
-//
-template <typename T>
-struct stream_format_type
-    : public std::conditional<(sizeof(T) == sizeof(char)), int, T> {};
-
-// stream_u128_helper allows us to write out either absl::uint128 or
-// __uint128_t types in the same way, which enables their use as internal
-// state of PRNG engines.
-template <typename T>
-struct stream_u128_helper;
-
-template <>
-struct stream_u128_helper<absl::uint128> {
-  template <typename IStream>
-  inline absl::uint128 read(IStream& in) {
-    uint64_t h = 0;
-    uint64_t l = 0;
-    in >> h >> l;
-    return absl::MakeUint128(h, l);
-  }
-
-  template <typename OStream>
-  inline void write(absl::uint128 val, OStream& out) {
-    uint64_t h = absl::Uint128High64(val);
-    uint64_t l = absl::Uint128Low64(val);
-    out << h << out.fill() << l;
-  }
-};
+                                            std::ios_base::scientific
+        )
+        {
+            using result_type = ostream_state_saver<std::basic_ostream<CharT, Traits>>;
+            return result_type(os, flags, os.widen(' '));
+        }
+
+        template<typename T>
+        typename absl::enable_if_t<!std::is_base_of<std::ios_base, T>::value,
+                                   null_state_saver<T>>
+            make_ostream_state_saver(T& is,  // NOLINT(runtime/references)
+                                     std::ios_base::fmtflags flags = std::ios_base::dec)
+        {
+            std::cerr << "null_state_saver";
+            using result_type = null_state_saver<T>;
+            return result_type(is, flags);
+        }
+
+        // stream_precision_helper<type>::kPrecision returns the base 10 precision
+        // required to stream and reconstruct a real type exact binary value through
+        // a binary->decimal->binary transition.
+        template<typename T>
+        struct stream_precision_helper
+        {
+            // max_digits10 may be 0 on MSVC; if so, use digits10 + 3.
+            static constexpr int kPrecision =
+                (std::numeric_limits<T>::max_digits10 > std::numeric_limits<T>::digits10) ? std::numeric_limits<T>::max_digits10 : (std::numeric_limits<T>::digits10 + 3);
+        };
+
+        template<>
+        struct stream_precision_helper<float>
+        {
+            static constexpr int kPrecision = 9;
+        };
+        template<>
+        struct stream_precision_helper<double>
+        {
+            static constexpr int kPrecision = 17;
+        };
+        template<>
+        struct stream_precision_helper<long double>
+        {
+            static constexpr int kPrecision = 36;  // assuming fp128
+        };
+
+        // istream_state_saver is a RAII object to save and restore the common
+        // std::basic_istream<> flags used when implementing `operator >>()` on any of
+        // the absl random distributions.
+        template<typename IStream>
+        class istream_state_saver
+        {
+        public:
+            using istream_type = IStream;
+            using flags_type = std::ios_base::fmtflags;
+
+            istream_state_saver(istream_type& is,  // NOLINT(runtime/references)
+                                flags_type flags) :
+                is_(is),
+                flags_(is.flags(flags))
+            {
+            }
+
+            ~istream_state_saver()
+            {
+                is_.flags(flags_);
+            }
+
+        private:
+            istream_type& is_;
+            flags_type flags_;
+        };
+
+        template<typename CharT, typename Traits>
+        istream_state_saver<std::basic_istream<CharT, Traits>> make_istream_state_saver(
+            std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+            std::ios_base::fmtflags flags = std::ios_base::dec |
+                                            std::ios_base::scientific |
+                                            std::ios_base::skipws
+        )
+        {
+            using result_type = istream_state_saver<std::basic_istream<CharT, Traits>>;
+            return result_type(is, flags);
+        }
+
+        template<typename T>
+        typename absl::enable_if_t<!std::is_base_of<std::ios_base, T>::value,
+                                   null_state_saver<T>>
+            make_istream_state_saver(T& is,  // NOLINT(runtime/references)
+                                     std::ios_base::fmtflags flags = std::ios_base::dec)
+        {
+            using result_type = null_state_saver<T>;
+            return result_type(is, flags);
+        }
+
+        // stream_format_type<T> is a helper struct to convert types which
+        // basic_iostream cannot output as decimal numbers into types which
+        // basic_iostream can output as decimal numbers. Specifically:
+        // * signed/unsigned char-width types are converted to int.
+        // * TODO(lar): __int128 => uint128, except there is no operator << yet.
+        //
+        template<typename T>
+        struct stream_format_type : public std::conditional<(sizeof(T) == sizeof(char)), int, T>
+        {
+        };
+
+        // stream_u128_helper allows us to write out either absl::uint128 or
+        // __uint128_t types in the same way, which enables their use as internal
+        // state of PRNG engines.
+        template<typename T>
+        struct stream_u128_helper;
+
+        template<>
+        struct stream_u128_helper<absl::uint128>
+        {
+            template<typename IStream>
+            inline absl::uint128 read(IStream& in)
+            {
+                uint64_t h = 0;
+                uint64_t l = 0;
+                in >> h >> l;
+                return absl::MakeUint128(h, l);
+            }
+
+            template<typename OStream>
+            inline void write(absl::uint128 val, OStream& out)
+            {
+                uint64_t h = absl::Uint128High64(val);
+                uint64_t l = absl::Uint128Low64(val);
+                out << h << out.fill() << l;
+            }
+        };
 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-template <>
-struct stream_u128_helper<__uint128_t> {
-  template <typename IStream>
-  inline __uint128_t read(IStream& in) {
-    uint64_t h = 0;
-    uint64_t l = 0;
-    in >> h >> l;
-    return (static_cast<__uint128_t>(h) << 64) | l;
-  }
-
-  template <typename OStream>
-  inline void write(__uint128_t val, OStream& out) {
-    uint64_t h = static_cast<uint64_t>(val >> 64u);
-    uint64_t l = static_cast<uint64_t>(val);
-    out << h << out.fill() << l;
-  }
-};
+        template<>
+        struct stream_u128_helper<__uint128_t>
+        {
+            template<typename IStream>
+            inline __uint128_t read(IStream& in)
+            {
+                uint64_t h = 0;
+                uint64_t l = 0;
+                in >> h >> l;
+                return (static_cast<__uint128_t>(h) << 64) | l;
+            }
+
+            template<typename OStream>
+            inline void write(__uint128_t val, OStream& out)
+            {
+                uint64_t h = static_cast<uint64_t>(val >> 64u);
+                uint64_t l = static_cast<uint64_t>(val);
+                out << h << out.fill() << l;
+            }
+        };
 #endif
 
-template <typename FloatType, typename IStream>
-inline FloatType read_floating_point(IStream& is) {
-  static_assert(std::is_floating_point<FloatType>::value, "");
-  FloatType dest;
-  is >> dest;
-  // Parsing a double value may report a subnormal value as an error
-  // despite being able to represent it.
-  // See https://stackoverflow.com/q/52410931/3286653
-  // It may also report an underflow when parsing DOUBLE_MIN as an
-  // ERANGE error, as the parsed value may be smaller than DOUBLE_MIN
-  // and rounded up.
-  // See: https://stackoverflow.com/q/42005462
-  if (is.fail() &&
-      (std::fabs(dest) == (std::numeric_limits<FloatType>::min)() ||
-       std::fpclassify(dest) == FP_SUBNORMAL)) {
-    is.clear(is.rdstate() & (~std::ios_base::failbit));
-  }
-  return dest;
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+        template<typename FloatType, typename IStream>
+        inline FloatType read_floating_point(IStream& is)
+        {
+            static_assert(std::is_floating_point<FloatType>::value, "");
+            FloatType dest;
+            is >> dest;
+            // Parsing a double value may report a subnormal value as an error
+            // despite being able to represent it.
+            // See https://stackoverflow.com/q/52410931/3286653
+            // It may also report an underflow when parsing DOUBLE_MIN as an
+            // ERANGE error, as the parsed value may be smaller than DOUBLE_MIN
+            // and rounded up.
+            // See: https://stackoverflow.com/q/42005462
+            if (is.fail() &&
+                (std::fabs(dest) == (std::numeric_limits<FloatType>::min)() ||
+                 std::fpclassify(dest) == FP_SUBNORMAL))
+            {
+                is.clear(is.rdstate() & (~std::ios_base::failbit));
+            }
+            return dest;
+        }
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_IOSTREAM_STATE_SAVER_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/mock_helpers.h b/CAPI/cpp/grpc/include/absl/random/internal/mock_helpers.h
index 882b051..c8181dd 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/mock_helpers.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/mock_helpers.h
@@ -23,113 +23,120 @@
 #include "absl/base/internal/fast_type_id.h"
 #include "absl/types/optional.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-// MockHelpers works in conjunction with MockOverloadSet, MockingBitGen, and
-// BitGenRef to enable the mocking capability for absl distribution functions.
-//
-// MockingBitGen registers mocks based on the typeid of a mock signature, KeyT,
-// which is used to generate a unique id.
-//
-// KeyT is a signature of the form:
-//   result_type(discriminator_type, std::tuple<args...>)
-// The mocked function signature will be composed from KeyT as:
-//   result_type(args...)
-//
-class MockHelpers {
-  using IdType = ::absl::base_internal::FastTypeIdType;
+        // MockHelpers works in conjunction with MockOverloadSet, MockingBitGen, and
+        // BitGenRef to enable the mocking capability for absl distribution functions.
+        //
+        // MockingBitGen registers mocks based on the typeid of a mock signature, KeyT,
+        // which is used to generate a unique id.
+        //
+        // KeyT is a signature of the form:
+        //   result_type(discriminator_type, std::tuple<args...>)
+        // The mocked function signature will be composed from KeyT as:
+        //   result_type(args...)
+        //
+        class MockHelpers
+        {
+            using IdType = ::absl::base_internal::FastTypeIdType;
 
-  // Given a key signature type used to index the mock, extract the components.
-  // KeyT is expected to have the form:
-  //   result_type(discriminator_type, arg_tuple_type)
-  template <typename KeyT>
-  struct KeySignature;
+            // Given a key signature type used to index the mock, extract the components.
+            // KeyT is expected to have the form:
+            //   result_type(discriminator_type, arg_tuple_type)
+            template<typename KeyT>
+            struct KeySignature;
 
-  template <typename ResultT, typename DiscriminatorT, typename ArgTupleT>
-  struct KeySignature<ResultT(DiscriminatorT, ArgTupleT)> {
-    using result_type = ResultT;
-    using discriminator_type = DiscriminatorT;
-    using arg_tuple_type = ArgTupleT;
-  };
+            template<typename ResultT, typename DiscriminatorT, typename ArgTupleT>
+            struct KeySignature<ResultT(DiscriminatorT, ArgTupleT)>
+            {
+                using result_type = ResultT;
+                using discriminator_type = DiscriminatorT;
+                using arg_tuple_type = ArgTupleT;
+            };
 
-  // Detector for InvokeMock.
-  template <class T>
-  using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
-      std::declval<IdType>(), std::declval<void*>(), std::declval<void*>()));
+            // Detector for InvokeMock.
+            template<class T>
+            using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
+                std::declval<IdType>(), std::declval<void*>(), std::declval<void*>()
+            ));
 
-  // Empty implementation of InvokeMock.
-  template <typename KeyT, typename ReturnT, typename ArgTupleT, typename URBG,
-            typename... Args>
-  static absl::optional<ReturnT> InvokeMockImpl(char, URBG*, Args&&...) {
-    return absl::nullopt;
-  }
+            // Empty implementation of InvokeMock.
+            template<typename KeyT, typename ReturnT, typename ArgTupleT, typename URBG, typename... Args>
+            static absl::optional<ReturnT> InvokeMockImpl(char, URBG*, Args&&...)
+            {
+                return absl::nullopt;
+            }
 
-  // Non-empty implementation of InvokeMock.
-  template <typename KeyT, typename ReturnT, typename ArgTupleT, typename URBG,
-            typename = invoke_mock_t<URBG>, typename... Args>
-  static absl::optional<ReturnT> InvokeMockImpl(int, URBG* urbg,
-                                                Args&&... args) {
-    ArgTupleT arg_tuple(std::forward<Args>(args)...);
-    ReturnT result;
-    if (urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple,
-                         &result)) {
-      return result;
-    }
-    return absl::nullopt;
-  }
+            // Non-empty implementation of InvokeMock.
+            template<typename KeyT, typename ReturnT, typename ArgTupleT, typename URBG, typename = invoke_mock_t<URBG>, typename... Args>
+            static absl::optional<ReturnT> InvokeMockImpl(int, URBG* urbg, Args&&... args)
+            {
+                ArgTupleT arg_tuple(std::forward<Args>(args)...);
+                ReturnT result;
+                if (urbg->InvokeMock(::absl::base_internal::FastTypeId<KeyT>(), &arg_tuple, &result))
+                {
+                    return result;
+                }
+                return absl::nullopt;
+            }
 
- public:
-  // InvokeMock is private; this provides access for some specialized use cases.
-  template <typename URBG>
-  static inline bool PrivateInvokeMock(URBG* urbg, IdType type,
-                                       void* args_tuple, void* result) {
-    return urbg->InvokeMock(type, args_tuple, result);
-  }
+        public:
+            // InvokeMock is private; this provides access for some specialized use cases.
+            template<typename URBG>
+            static inline bool PrivateInvokeMock(URBG* urbg, IdType type, void* args_tuple, void* result)
+            {
+                return urbg->InvokeMock(type, args_tuple, result);
+            }
 
-  // Invoke a mock for the KeyT (may or may not be a signature).
-  //
-  // KeyT is used to generate a typeid-based lookup key for the mock.
-  // KeyT is a signature of the form:
-  //   result_type(discriminator_type, std::tuple<args...>)
-  // The mocked function signature will be composed from KeyT as:
-  //   result_type(args...)
-  //
-  // An instance of arg_tuple_type must be constructable from Args..., since
-  // the underlying mechanism requires a pointer to an argument tuple.
-  template <typename KeyT, typename URBG, typename... Args>
-  static auto MaybeInvokeMock(URBG* urbg, Args&&... args)
-      -> absl::optional<typename KeySignature<KeyT>::result_type> {
-    // Use function overloading to dispatch to the implemenation since
-    // more modern patterns (e.g. require + constexpr) are not supported in all
-    // compiler configurations.
-    return InvokeMockImpl<KeyT, typename KeySignature<KeyT>::result_type,
-                          typename KeySignature<KeyT>::arg_tuple_type, URBG>(
-        0, urbg, std::forward<Args>(args)...);
-  }
+            // Invoke a mock for the KeyT (may or may not be a signature).
+            //
+            // KeyT is used to generate a typeid-based lookup key for the mock.
+            // KeyT is a signature of the form:
+            //   result_type(discriminator_type, std::tuple<args...>)
+            // The mocked function signature will be composed from KeyT as:
+            //   result_type(args...)
+            //
+            // An instance of arg_tuple_type must be constructable from Args..., since
+            // the underlying mechanism requires a pointer to an argument tuple.
+            template<typename KeyT, typename URBG, typename... Args>
+            static auto MaybeInvokeMock(URBG* urbg, Args&&... args)
+                -> absl::optional<typename KeySignature<KeyT>::result_type>
+            {
+                // Use function overloading to dispatch to the implemenation since
+                // more modern patterns (e.g. require + constexpr) are not supported in all
+                // compiler configurations.
+                return InvokeMockImpl<KeyT, typename KeySignature<KeyT>::result_type, typename KeySignature<KeyT>::arg_tuple_type, URBG>(
+                    0, urbg, std::forward<Args>(args)...
+                );
+            }
 
-  // Acquire a mock for the KeyT (may or may not be a signature).
-  //
-  // KeyT is used to generate a typeid-based lookup for the mock.
-  // KeyT is a signature of the form:
-  //   result_type(discriminator_type, std::tuple<args...>)
-  // The mocked function signature will be composed from KeyT as:
-  //   result_type(args...)
-  template <typename KeyT, typename MockURBG>
-  static auto MockFor(MockURBG& m)
-      -> decltype(m.template RegisterMock<
-                  typename KeySignature<KeyT>::result_type,
-                  typename KeySignature<KeyT>::arg_tuple_type>(
-          m, std::declval<IdType>())) {
-    return m.template RegisterMock<typename KeySignature<KeyT>::result_type,
-                                   typename KeySignature<KeyT>::arg_tuple_type>(
-        m, ::absl::base_internal::FastTypeId<KeyT>());
-  }
-};
+            // Acquire a mock for the KeyT (may or may not be a signature).
+            //
+            // KeyT is used to generate a typeid-based lookup for the mock.
+            // KeyT is a signature of the form:
+            //   result_type(discriminator_type, std::tuple<args...>)
+            // The mocked function signature will be composed from KeyT as:
+            //   result_type(args...)
+            template<typename KeyT, typename MockURBG>
+            static auto MockFor(MockURBG& m)
+                -> decltype(m.template RegisterMock<
+                            typename KeySignature<KeyT>::result_type,
+                            typename KeySignature<KeyT>::arg_tuple_type>(
+                    m, std::declval<IdType>()
+                ))
+            {
+                return m.template RegisterMock<typename KeySignature<KeyT>::result_type, typename KeySignature<KeyT>::arg_tuple_type>(
+                    m, ::absl::base_internal::FastTypeId<KeyT>()
+                );
+            }
+        };
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_MOCK_HELPERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/mock_overload_set.h b/CAPI/cpp/grpc/include/absl/random/internal/mock_overload_set.h
index 0d9c6c1..578f65c 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/mock_overload_set.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/mock_overload_set.h
@@ -22,79 +22,79 @@
 #include "absl/random/internal/mock_helpers.h"
 #include "absl/random/mocking_bit_gen.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-template <typename DistrT, typename Fn>
-struct MockSingleOverload;
+        template<typename DistrT, typename Fn>
+        struct MockSingleOverload;
 
-// MockSingleOverload
-//
-// MockSingleOverload hooks in to gMock's `ON_CALL` and `EXPECT_CALL` macros.
-// EXPECT_CALL(mock_single_overload, Call(...))` will expand to a call to
-// `mock_single_overload.gmock_Call(...)`. Because expectations are stored on
-// the MockingBitGen (an argument passed inside `Call(...)`), this forwards to
-// arguments to MockingBitGen::Register.
-//
-// The underlying KeyT must match the KeyT constructed by DistributionCaller.
-template <typename DistrT, typename Ret, typename... Args>
-struct MockSingleOverload<DistrT, Ret(MockingBitGen&, Args...)> {
-  static_assert(std::is_same<typename DistrT::result_type, Ret>::value,
-                "Overload signature must have return type matching the "
-                "distribution result_type.");
-  using KeyT = Ret(DistrT, std::tuple<Args...>);
+        // MockSingleOverload
+        //
+        // MockSingleOverload hooks in to gMock's `ON_CALL` and `EXPECT_CALL` macros.
+        // EXPECT_CALL(mock_single_overload, Call(...))` will expand to a call to
+        // `mock_single_overload.gmock_Call(...)`. Because expectations are stored on
+        // the MockingBitGen (an argument passed inside `Call(...)`), this forwards to
+        // arguments to MockingBitGen::Register.
+        //
+        // The underlying KeyT must match the KeyT constructed by DistributionCaller.
+        template<typename DistrT, typename Ret, typename... Args>
+        struct MockSingleOverload<DistrT, Ret(MockingBitGen&, Args...)>
+        {
+            static_assert(std::is_same<typename DistrT::result_type, Ret>::value, "Overload signature must have return type matching the "
+                                                                                  "distribution result_type.");
+            using KeyT = Ret(DistrT, std::tuple<Args...>);
 
-  template <typename MockURBG>
-  auto gmock_Call(MockURBG& gen, const ::testing::Matcher<Args>&... matchers)
-      -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...)) {
-    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
-                  "Mocking requires an absl::MockingBitGen");
-    return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...);
-  }
-};
+            template<typename MockURBG>
+            auto gmock_Call(MockURBG& gen, const ::testing::Matcher<Args>&... matchers)
+                -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...))
+            {
+                static_assert(std::is_base_of<MockingBitGen, MockURBG>::value, "Mocking requires an absl::MockingBitGen");
+                return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...);
+            }
+        };
 
-template <typename DistrT, typename Ret, typename Arg, typename... Args>
-struct MockSingleOverload<DistrT, Ret(Arg, MockingBitGen&, Args...)> {
-  static_assert(std::is_same<typename DistrT::result_type, Ret>::value,
-                "Overload signature must have return type matching the "
-                "distribution result_type.");
-  using KeyT = Ret(DistrT, std::tuple<Arg, Args...>);
+        template<typename DistrT, typename Ret, typename Arg, typename... Args>
+        struct MockSingleOverload<DistrT, Ret(Arg, MockingBitGen&, Args...)>
+        {
+            static_assert(std::is_same<typename DistrT::result_type, Ret>::value, "Overload signature must have return type matching the "
+                                                                                  "distribution result_type.");
+            using KeyT = Ret(DistrT, std::tuple<Arg, Args...>);
 
-  template <typename MockURBG>
-  auto gmock_Call(const ::testing::Matcher<Arg>& matcher, MockURBG& gen,
-                  const ::testing::Matcher<Args>&... matchers)
-      -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher,
-                                                             matchers...)) {
-    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
-                  "Mocking requires an absl::MockingBitGen");
-    return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, matchers...);
-  }
-};
+            template<typename MockURBG>
+            auto gmock_Call(const ::testing::Matcher<Arg>& matcher, MockURBG& gen, const ::testing::Matcher<Args>&... matchers)
+                -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, matchers...))
+            {
+                static_assert(std::is_base_of<MockingBitGen, MockURBG>::value, "Mocking requires an absl::MockingBitGen");
+                return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, matchers...);
+            }
+        };
 
-// MockOverloadSet
-//
-// MockOverloadSet takes a distribution and a collection of signatures and
-// performs overload resolution amongst all the overloads. This makes
-// `EXPECT_CALL(mock_overload_set, Call(...))` expand and do overload resolution
-// correctly.
-template <typename DistrT, typename... Signatures>
-struct MockOverloadSet;
+        // MockOverloadSet
+        //
+        // MockOverloadSet takes a distribution and a collection of signatures and
+        // performs overload resolution amongst all the overloads. This makes
+        // `EXPECT_CALL(mock_overload_set, Call(...))` expand and do overload resolution
+        // correctly.
+        template<typename DistrT, typename... Signatures>
+        struct MockOverloadSet;
 
-template <typename DistrT, typename Sig>
-struct MockOverloadSet<DistrT, Sig> : public MockSingleOverload<DistrT, Sig> {
-  using MockSingleOverload<DistrT, Sig>::gmock_Call;
-};
+        template<typename DistrT, typename Sig>
+        struct MockOverloadSet<DistrT, Sig> : public MockSingleOverload<DistrT, Sig>
+        {
+            using MockSingleOverload<DistrT, Sig>::gmock_Call;
+        };
 
-template <typename DistrT, typename FirstSig, typename... Rest>
-struct MockOverloadSet<DistrT, FirstSig, Rest...>
-    : public MockSingleOverload<DistrT, FirstSig>,
-      public MockOverloadSet<DistrT, Rest...> {
-  using MockSingleOverload<DistrT, FirstSig>::gmock_Call;
-  using MockOverloadSet<DistrT, Rest...>::gmock_Call;
-};
+        template<typename DistrT, typename FirstSig, typename... Rest>
+        struct MockOverloadSet<DistrT, FirstSig, Rest...> : public MockSingleOverload<DistrT, FirstSig>, public MockOverloadSet<DistrT, Rest...>
+        {
+            using MockSingleOverload<DistrT, FirstSig>::gmock_Call;
+            using MockOverloadSet<DistrT, Rest...>::gmock_Call;
+        };
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // ABSL_RANDOM_INTERNAL_MOCK_OVERLOAD_SET_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/nanobenchmark.h b/CAPI/cpp/grpc/include/absl/random/internal/nanobenchmark.h
index a5097ba..44ab090 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/nanobenchmark.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/nanobenchmark.h
@@ -52,121 +52,120 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal_nanobenchmark {
-
-// Input influencing the function being measured (e.g. number of bytes to copy).
-using FuncInput = size_t;
-
-// "Proof of work" returned by Func to ensure the compiler does not elide it.
-using FuncOutput = uint64_t;
-
-// Function to measure: either 1) a captureless lambda or function with two
-// arguments or 2) a lambda with capture, in which case the first argument
-// is reserved for use by MeasureClosure.
-using Func = FuncOutput (*)(const void*, FuncInput);
-
-// Internal parameters that determine precision/resolution/measuring time.
-struct Params {
-  // For measuring timer overhead/resolution. Used in a nested loop =>
-  // quadratic time, acceptable because we know timer overhead is "low".
-  // constexpr because this is used to define array bounds.
-  static constexpr size_t kTimerSamples = 256;
-
-  // Best-case precision, expressed as a divisor of the timer resolution.
-  // Larger => more calls to Func and higher precision.
-  size_t precision_divisor = 1024;
-
-  // Ratio between full and subset input distribution sizes. Cannot be less
-  // than 2; larger values increase measurement time but more faithfully
-  // model the given input distribution.
-  size_t subset_ratio = 2;
-
-  // Together with the estimated Func duration, determines how many times to
-  // call Func before checking the sample variability. Larger values increase
-  // measurement time, memory/cache use and precision.
-  double seconds_per_eval = 4E-3;
-
-  // The minimum number of samples before estimating the central tendency.
-  size_t min_samples_per_eval = 7;
-
-  // The mode is better than median for estimating the central tendency of
-  // skewed/fat-tailed distributions, but it requires sufficient samples
-  // relative to the width of half-ranges.
-  size_t min_mode_samples = 64;
-
-  // Maximum permissible variability (= median absolute deviation / center).
-  double target_rel_mad = 0.002;
-
-  // Abort after this many evals without reaching target_rel_mad. This
-  // prevents infinite loops.
-  size_t max_evals = 9;
-
-  // Retry the measure loop up to this many times.
-  size_t max_measure_retries = 2;
-
-  // Whether to print additional statistics to stdout.
-  bool verbose = true;
-};
-
-// Measurement result for each unique input.
-struct Result {
-  FuncInput input;
-
-  // Robust estimate (mode or median) of duration.
-  float ticks;
-
-  // Measure of variability (median absolute deviation relative to "ticks").
-  float variability;
-};
-
-// Ensures the thread is running on the specified cpu, and no others.
-// Reduces noise due to desynchronized socket RDTSC and context switches.
-// If "cpu" is negative, pin to the currently running core.
-void PinThreadToCPU(const int cpu = -1);
-
-// Returns tick rate, useful for converting measurements to seconds. Invariant
-// means the tick counter frequency is independent of CPU throttling or sleep.
-// This call may be expensive, callers should cache the result.
-double InvariantTicksPerSecond();
-
-// Precisely measures the number of ticks elapsed when calling "func" with the
-// given inputs, shuffled to ensure realistic branch prediction hit rates.
-//
-// "func" returns a 'proof of work' to ensure its computations are not elided.
-// "arg" is passed to Func, or reserved for internal use by MeasureClosure.
-// "inputs" is an array of "num_inputs" (not necessarily unique) arguments to
-//   "func". The values should be chosen to maximize coverage of "func". This
-//   represents a distribution, so a value's frequency should reflect its
-//   probability in the real application. Order does not matter; for example, a
-//   uniform distribution over [0, 4) could be represented as {3,0,2,1}.
-// Returns how many Result were written to "results": one per unique input, or
-//   zero if the measurement failed (an error message goes to stderr).
-size_t Measure(const Func func, const void* arg, const FuncInput* inputs,
-               const size_t num_inputs, Result* results,
-               const Params& p = Params());
-
-// Calls operator() of the given closure (lambda function).
-template <class Closure>
-static FuncOutput CallClosure(const void* f, const FuncInput input) {
-  return (*reinterpret_cast<const Closure*>(f))(input);
-}
-
-// Same as Measure, except "closure" is typically a lambda function of
-// FuncInput -> FuncOutput with a capture list.
-template <class Closure>
-static inline size_t MeasureClosure(const Closure& closure,
-                                    const FuncInput* inputs,
-                                    const size_t num_inputs, Result* results,
-                                    const Params& p = Params()) {
-  return Measure(reinterpret_cast<Func>(&CallClosure<Closure>),
-                 reinterpret_cast<const void*>(&closure), inputs, num_inputs,
-                 results, p);
-}
-
-}  // namespace random_internal_nanobenchmark
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal_nanobenchmark
+    {
+
+        // Input influencing the function being measured (e.g. number of bytes to copy).
+        using FuncInput = size_t;
+
+        // "Proof of work" returned by Func to ensure the compiler does not elide it.
+        using FuncOutput = uint64_t;
+
+        // Function to measure: either 1) a captureless lambda or function with two
+        // arguments or 2) a lambda with capture, in which case the first argument
+        // is reserved for use by MeasureClosure.
+        using Func = FuncOutput (*)(const void*, FuncInput);
+
+        // Internal parameters that determine precision/resolution/measuring time.
+        struct Params
+        {
+            // For measuring timer overhead/resolution. Used in a nested loop =>
+            // quadratic time, acceptable because we know timer overhead is "low".
+            // constexpr because this is used to define array bounds.
+            static constexpr size_t kTimerSamples = 256;
+
+            // Best-case precision, expressed as a divisor of the timer resolution.
+            // Larger => more calls to Func and higher precision.
+            size_t precision_divisor = 1024;
+
+            // Ratio between full and subset input distribution sizes. Cannot be less
+            // than 2; larger values increase measurement time but more faithfully
+            // model the given input distribution.
+            size_t subset_ratio = 2;
+
+            // Together with the estimated Func duration, determines how many times to
+            // call Func before checking the sample variability. Larger values increase
+            // measurement time, memory/cache use and precision.
+            double seconds_per_eval = 4E-3;
+
+            // The minimum number of samples before estimating the central tendency.
+            size_t min_samples_per_eval = 7;
+
+            // The mode is better than median for estimating the central tendency of
+            // skewed/fat-tailed distributions, but it requires sufficient samples
+            // relative to the width of half-ranges.
+            size_t min_mode_samples = 64;
+
+            // Maximum permissible variability (= median absolute deviation / center).
+            double target_rel_mad = 0.002;
+
+            // Abort after this many evals without reaching target_rel_mad. This
+            // prevents infinite loops.
+            size_t max_evals = 9;
+
+            // Retry the measure loop up to this many times.
+            size_t max_measure_retries = 2;
+
+            // Whether to print additional statistics to stdout.
+            bool verbose = true;
+        };
+
+        // Measurement result for each unique input.
+        struct Result
+        {
+            FuncInput input;
+
+            // Robust estimate (mode or median) of duration.
+            float ticks;
+
+            // Measure of variability (median absolute deviation relative to "ticks").
+            float variability;
+        };
+
+        // Ensures the thread is running on the specified cpu, and no others.
+        // Reduces noise due to desynchronized socket RDTSC and context switches.
+        // If "cpu" is negative, pin to the currently running core.
+        void PinThreadToCPU(const int cpu = -1);
+
+        // Returns tick rate, useful for converting measurements to seconds. Invariant
+        // means the tick counter frequency is independent of CPU throttling or sleep.
+        // This call may be expensive, callers should cache the result.
+        double InvariantTicksPerSecond();
+
+        // Precisely measures the number of ticks elapsed when calling "func" with the
+        // given inputs, shuffled to ensure realistic branch prediction hit rates.
+        //
+        // "func" returns a 'proof of work' to ensure its computations are not elided.
+        // "arg" is passed to Func, or reserved for internal use by MeasureClosure.
+        // "inputs" is an array of "num_inputs" (not necessarily unique) arguments to
+        //   "func". The values should be chosen to maximize coverage of "func". This
+        //   represents a distribution, so a value's frequency should reflect its
+        //   probability in the real application. Order does not matter; for example, a
+        //   uniform distribution over [0, 4) could be represented as {3,0,2,1}.
+        // Returns how many Result were written to "results": one per unique input, or
+        //   zero if the measurement failed (an error message goes to stderr).
+        size_t Measure(const Func func, const void* arg, const FuncInput* inputs, const size_t num_inputs, Result* results, const Params& p = Params());
+
+        // Calls operator() of the given closure (lambda function).
+        template<class Closure>
+        static FuncOutput CallClosure(const void* f, const FuncInput input)
+        {
+            return (*reinterpret_cast<const Closure*>(f))(input);
+        }
+
+        // Same as Measure, except "closure" is typically a lambda function of
+        // FuncInput -> FuncOutput with a capture list.
+        template<class Closure>
+        static inline size_t MeasureClosure(const Closure& closure, const FuncInput* inputs, const size_t num_inputs, Result* results, const Params& p = Params())
+        {
+            return Measure(reinterpret_cast<Func>(&CallClosure<Closure>), reinterpret_cast<const void*>(&closure), inputs, num_inputs, results, p);
+        }
+
+    }  // namespace random_internal_nanobenchmark
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_NANOBENCHMARK_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/nonsecure_base.h b/CAPI/cpp/grpc/include/absl/random/internal/nonsecure_base.h
index c7d7fa4..77aa9d2 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/nonsecure_base.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/nonsecure_base.h
@@ -30,132 +30,167 @@
 #include "absl/random/internal/seed_material.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// RandenPoolSeedSeq is a custom seed sequence type where generate() fills the
-// provided buffer via the RandenPool entropy source.
-class RandenPoolSeedSeq {
- private:
-  struct ContiguousTag {};
-  struct BufferTag {};
-
-  // Generate random unsigned values directly into the buffer.
-  template <typename Contiguous>
-  void generate_impl(ContiguousTag, Contiguous begin, Contiguous end) {
-    const size_t n = std::distance(begin, end);
-    auto* a = &(*begin);
-    RandenPool<uint8_t>::Fill(
-        absl::MakeSpan(reinterpret_cast<uint8_t*>(a), sizeof(*a) * n));
-  }
-
-  // Construct a buffer of size n and fill it with values, then copy
-  // those values into the seed iterators.
-  template <typename RandomAccessIterator>
-  void generate_impl(BufferTag, RandomAccessIterator begin,
-                     RandomAccessIterator end) {
-    const size_t n = std::distance(begin, end);
-    absl::InlinedVector<uint32_t, 8> data(n, 0);
-    RandenPool<uint32_t>::Fill(absl::MakeSpan(data.begin(), data.end()));
-    std::copy(std::begin(data), std::end(data), begin);
-  }
-
- public:
-  using result_type = uint32_t;
-
-  size_t size() { return 0; }
-
-  template <typename OutIterator>
-  void param(OutIterator) const {}
-
-  template <typename RandomAccessIterator>
-  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
-    // RandomAccessIterator must be assignable from uint32_t
-    if (begin != end) {
-      using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
-      // ContiguousTag indicates the common case of a known contiguous buffer,
-      // which allows directly filling the buffer. In C++20,
-      // std::contiguous_iterator_tag provides a mechanism for testing this
-      // capability, however until Abseil's support requirements allow us to
-      // assume C++20, limit checks to a few common cases.
-      using TagType = absl::conditional_t<
-          (std::is_pointer<RandomAccessIterator>::value ||
-           std::is_same<RandomAccessIterator,
-                        typename std::vector<U>::iterator>::value),
-          ContiguousTag, BufferTag>;
-
-      generate_impl(TagType{}, begin, end);
-    }
-  }
-};
-
-// Each instance of NonsecureURBGBase<URBG> will be seeded by variates produced
-// by a thread-unique URBG-instance.
-template <typename URBG, typename Seeder = RandenPoolSeedSeq>
-class NonsecureURBGBase {
- public:
-  using result_type = typename URBG::result_type;
-
-  // Default constructor
-  NonsecureURBGBase() : urbg_(ConstructURBG()) {}
-
-  // Copy disallowed, move allowed.
-  NonsecureURBGBase(const NonsecureURBGBase&) = delete;
-  NonsecureURBGBase& operator=(const NonsecureURBGBase&) = delete;
-  NonsecureURBGBase(NonsecureURBGBase&&) = default;
-  NonsecureURBGBase& operator=(NonsecureURBGBase&&) = default;
-
-  // Constructor using a seed
-  template <class SSeq, typename = typename absl::enable_if_t<
-                            !std::is_same<SSeq, NonsecureURBGBase>::value>>
-  explicit NonsecureURBGBase(SSeq&& seq)
-      : urbg_(ConstructURBG(std::forward<SSeq>(seq))) {}
-
-  // Note: on MSVC, min() or max() can be interpreted as MIN() or MAX(), so we
-  // enclose min() or max() in parens as (min)() and (max)().
-  // Additionally, clang-format requires no space before this construction.
-
-  // NonsecureURBGBase::min()
-  static constexpr result_type(min)() { return (URBG::min)(); }
-
-  // NonsecureURBGBase::max()
-  static constexpr result_type(max)() { return (URBG::max)(); }
-
-  // NonsecureURBGBase::operator()()
-  result_type operator()() { return urbg_(); }
-
-  // NonsecureURBGBase::discard()
-  void discard(unsigned long long values) {  // NOLINT(runtime/int)
-    urbg_.discard(values);
-  }
-
-  bool operator==(const NonsecureURBGBase& other) const {
-    return urbg_ == other.urbg_;
-  }
-
-  bool operator!=(const NonsecureURBGBase& other) const {
-    return !(urbg_ == other.urbg_);
-  }
-
- private:
-  static URBG ConstructURBG() {
-    Seeder seeder;
-    return URBG(seeder);
-  }
-
-  template <typename SSeq>
-  static URBG ConstructURBG(SSeq&& seq) {  // NOLINT(runtime/references)
-    auto salted_seq =
-        random_internal::MakeSaltedSeedSeq(std::forward<SSeq>(seq));
-    return URBG(salted_seq);
-  }
-
-  URBG urbg_;
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // RandenPoolSeedSeq is a custom seed sequence type where generate() fills the
+        // provided buffer via the RandenPool entropy source.
+        class RandenPoolSeedSeq
+        {
+        private:
+            struct ContiguousTag
+            {
+            };
+            struct BufferTag
+            {
+            };
+
+            // Generate random unsigned values directly into the buffer.
+            template<typename Contiguous>
+            void generate_impl(ContiguousTag, Contiguous begin, Contiguous end)
+            {
+                const size_t n = std::distance(begin, end);
+                auto* a = &(*begin);
+                RandenPool<uint8_t>::Fill(
+                    absl::MakeSpan(reinterpret_cast<uint8_t*>(a), sizeof(*a) * n)
+                );
+            }
+
+            // Construct a buffer of size n and fill it with values, then copy
+            // those values into the seed iterators.
+            template<typename RandomAccessIterator>
+            void generate_impl(BufferTag, RandomAccessIterator begin, RandomAccessIterator end)
+            {
+                const size_t n = std::distance(begin, end);
+                absl::InlinedVector<uint32_t, 8> data(n, 0);
+                RandenPool<uint32_t>::Fill(absl::MakeSpan(data.begin(), data.end()));
+                std::copy(std::begin(data), std::end(data), begin);
+            }
+
+        public:
+            using result_type = uint32_t;
+
+            size_t size()
+            {
+                return 0;
+            }
+
+            template<typename OutIterator>
+            void param(OutIterator) const
+            {
+            }
+
+            template<typename RandomAccessIterator>
+            void generate(RandomAccessIterator begin, RandomAccessIterator end)
+            {
+                // RandomAccessIterator must be assignable from uint32_t
+                if (begin != end)
+                {
+                    using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
+                    // ContiguousTag indicates the common case of a known contiguous buffer,
+                    // which allows directly filling the buffer. In C++20,
+                    // std::contiguous_iterator_tag provides a mechanism for testing this
+                    // capability, however until Abseil's support requirements allow us to
+                    // assume C++20, limit checks to a few common cases.
+                    using TagType = absl::conditional_t<
+                        (std::is_pointer<RandomAccessIterator>::value ||
+                         std::is_same<RandomAccessIterator, typename std::vector<U>::iterator>::value),
+                        ContiguousTag,
+                        BufferTag>;
+
+                    generate_impl(TagType{}, begin, end);
+                }
+            }
+        };
+
+        // Each instance of NonsecureURBGBase<URBG> will be seeded by variates produced
+        // by a thread-unique URBG-instance.
+        template<typename URBG, typename Seeder = RandenPoolSeedSeq>
+        class NonsecureURBGBase
+        {
+        public:
+            using result_type = typename URBG::result_type;
+
+            // Default constructor
+            NonsecureURBGBase() :
+                urbg_(ConstructURBG())
+            {
+            }
+
+            // Copy disallowed, move allowed.
+            NonsecureURBGBase(const NonsecureURBGBase&) = delete;
+            NonsecureURBGBase& operator=(const NonsecureURBGBase&) = delete;
+            NonsecureURBGBase(NonsecureURBGBase&&) = default;
+            NonsecureURBGBase& operator=(NonsecureURBGBase&&) = default;
+
+            // Constructor using a seed
+            template<class SSeq, typename = typename absl::enable_if_t<!std::is_same<SSeq, NonsecureURBGBase>::value>>
+            explicit NonsecureURBGBase(SSeq&& seq) :
+                urbg_(ConstructURBG(std::forward<SSeq>(seq)))
+            {
+            }
+
+            // Note: on MSVC, min() or max() can be interpreted as MIN() or MAX(), so we
+            // enclose min() or max() in parens as (min)() and (max)().
+            // Additionally, clang-format requires no space before this construction.
+
+            // NonsecureURBGBase::min()
+            static constexpr result_type(min)()
+            {
+                return (URBG::min)();
+            }
+
+            // NonsecureURBGBase::max()
+            static constexpr result_type(max)()
+            {
+                return (URBG::max)();
+            }
+
+            // NonsecureURBGBase::operator()()
+            result_type operator()()
+            {
+                return urbg_();
+            }
+
+            // NonsecureURBGBase::discard()
+            void discard(unsigned long long values)
+            {  // NOLINT(runtime/int)
+                urbg_.discard(values);
+            }
+
+            bool operator==(const NonsecureURBGBase& other) const
+            {
+                return urbg_ == other.urbg_;
+            }
+
+            bool operator!=(const NonsecureURBGBase& other) const
+            {
+                return !(urbg_ == other.urbg_);
+            }
+
+        private:
+            static URBG ConstructURBG()
+            {
+                Seeder seeder;
+                return URBG(seeder);
+            }
+
+            template<typename SSeq>
+            static URBG ConstructURBG(SSeq&& seq)
+            {  // NOLINT(runtime/references)
+                auto salted_seq =
+                    random_internal::MakeSaltedSeedSeq(std::forward<SSeq>(seq));
+                return URBG(salted_seq);
+            }
+
+            URBG urbg_;
+        };
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_NONSECURE_BASE_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/pcg_engine.h b/CAPI/cpp/grpc/include/absl/random/internal/pcg_engine.h
index 4ab44c9..99f8f5e 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/pcg_engine.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/pcg_engine.h
@@ -24,285 +24,328 @@
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// pcg_engine is a simplified implementation of Melissa O'Neil's PCG engine in
-// C++.  PCG combines a linear congruential generator (LCG) with output state
-// mixing functions to generate each random variate.  pcg_engine supports only a
-// single sequence (oneseq), and does not support streams.
-//
-// pcg_engine is parameterized by two types:
-//   Params, which provides the multiplier and increment values;
-//   Mix, which mixes the state into the result.
-//
-template <typename Params, typename Mix>
-class pcg_engine {
-  static_assert(std::is_same<typename Params::state_type,
-                             typename Mix::state_type>::value,
-                "Class-template absl::pcg_engine must be parameterized by "
-                "Params and Mix with identical state_type");
-
-  static_assert(std::is_unsigned<typename Mix::result_type>::value,
-                "Class-template absl::pcg_engine must be parameterized by "
-                "an unsigned Mix::result_type");
-
-  using params_type = Params;
-  using mix_type = Mix;
-  using state_type = typename Mix::state_type;
-
- public:
-  // C++11 URBG interface:
-  using result_type = typename Mix::result_type;
-
-  static constexpr result_type(min)() {
-    return (std::numeric_limits<result_type>::min)();
-  }
-
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
-
-  explicit pcg_engine(uint64_t seed_value = 0) { seed(seed_value); }
-
-  template <class SeedSequence,
-            typename = typename absl::enable_if_t<
-                !std::is_same<SeedSequence, pcg_engine>::value>>
-  explicit pcg_engine(SeedSequence&& seq) {
-    seed(seq);
-  }
-
-  pcg_engine(const pcg_engine&) = default;
-  pcg_engine& operator=(const pcg_engine&) = default;
-  pcg_engine(pcg_engine&&) = default;
-  pcg_engine& operator=(pcg_engine&&) = default;
-
-  result_type operator()() {
-    // Advance the LCG state, always using the new value to generate the output.
-    state_ = lcg(state_);
-    return Mix{}(state_);
-  }
-
-  void seed(uint64_t seed_value = 0) {
-    state_type tmp = seed_value;
-    state_ = lcg(tmp + Params::increment());
-  }
-
-  template <class SeedSequence>
-  typename absl::enable_if_t<
-      !std::is_convertible<SeedSequence, uint64_t>::value, void>
-  seed(SeedSequence&& seq) {
-    reseed(seq);
-  }
-
-  void discard(uint64_t count) { state_ = advance(state_, count); }
-
-  bool operator==(const pcg_engine& other) const {
-    return state_ == other.state_;
-  }
-
-  bool operator!=(const pcg_engine& other) const { return !(*this == other); }
-
-  template <class CharT, class Traits>
-  friend typename absl::enable_if_t<(sizeof(state_type) == 16),
-                                    std::basic_ostream<CharT, Traits>&>
-  operator<<(
-      std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-      const pcg_engine& engine) {
-    auto saver = random_internal::make_ostream_state_saver(os);
-    random_internal::stream_u128_helper<state_type> helper;
-    helper.write(pcg_engine::params_type::multiplier(), os);
-    os << os.fill();
-    helper.write(pcg_engine::params_type::increment(), os);
-    os << os.fill();
-    helper.write(engine.state_, os);
-    return os;
-  }
-
-  template <class CharT, class Traits>
-  friend typename absl::enable_if_t<(sizeof(state_type) <= 8),
-                                    std::basic_ostream<CharT, Traits>&>
-  operator<<(
-      std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-      const pcg_engine& engine) {
-    auto saver = random_internal::make_ostream_state_saver(os);
-    os << pcg_engine::params_type::multiplier() << os.fill();
-    os << pcg_engine::params_type::increment() << os.fill();
-    os << engine.state_;
-    return os;
-  }
-
-  template <class CharT, class Traits>
-  friend typename absl::enable_if_t<(sizeof(state_type) == 16),
-                                    std::basic_istream<CharT, Traits>&>
-  operator>>(
-      std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-      pcg_engine& engine) {                   // NOLINT(runtime/references)
-    random_internal::stream_u128_helper<state_type> helper;
-    auto mult = helper.read(is);
-    auto inc = helper.read(is);
-    auto tmp = helper.read(is);
-    if (mult != pcg_engine::params_type::multiplier() ||
-        inc != pcg_engine::params_type::increment()) {
-      // signal failure by setting the failbit.
-      is.setstate(is.rdstate() | std::ios_base::failbit);
-    }
-    if (!is.fail()) {
-      engine.state_ = tmp;
-    }
-    return is;
-  }
-
-  template <class CharT, class Traits>
-  friend typename absl::enable_if_t<(sizeof(state_type) <= 8),
-                                    std::basic_istream<CharT, Traits>&>
-  operator>>(
-      std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-      pcg_engine& engine) {                   // NOLINT(runtime/references)
-    state_type mult{}, inc{}, tmp{};
-    is >> mult >> inc >> tmp;
-    if (mult != pcg_engine::params_type::multiplier() ||
-        inc != pcg_engine::params_type::increment()) {
-      // signal failure by setting the failbit.
-      is.setstate(is.rdstate() | std::ios_base::failbit);
-    }
-    if (!is.fail()) {
-      engine.state_ = tmp;
-    }
-    return is;
-  }
-
- private:
-  state_type state_;
-
-  // Returns the linear-congruential generator next state.
-  static inline constexpr state_type lcg(state_type s) {
-    return s * Params::multiplier() + Params::increment();
-  }
-
-  // Returns the linear-congruential arbitrary seek state.
-  inline state_type advance(state_type s, uint64_t n) const {
-    state_type mult = Params::multiplier();
-    state_type inc = Params::increment();
-    state_type m = 1;
-    state_type i = 0;
-    while (n > 0) {
-      if (n & 1) {
-        m *= mult;
-        i = i * mult + inc;
-      }
-      inc = (mult + 1) * inc;
-      mult *= mult;
-      n >>= 1;
-    }
-    return m * s + i;
-  }
-
-  template <class SeedSequence>
-  void reseed(SeedSequence& seq) {
-    using sequence_result_type = typename SeedSequence::result_type;
-    constexpr size_t kBufferSize =
-        sizeof(state_type) / sizeof(sequence_result_type);
-    sequence_result_type buffer[kBufferSize];
-    seq.generate(std::begin(buffer), std::end(buffer));
-    // Convert the seed output to a single state value.
-    state_type tmp = buffer[0];
-    for (size_t i = 1; i < kBufferSize; i++) {
-      tmp <<= (sizeof(sequence_result_type) * 8);
-      tmp |= buffer[i];
-    }
-    state_ = lcg(tmp + params_type::increment());
-  }
-};
-
-// Parameterized implementation of the PCG 128-bit oneseq state.
-// This provides state_type, multiplier, and increment for pcg_engine.
-template <uint64_t kMultA, uint64_t kMultB, uint64_t kIncA, uint64_t kIncB>
-class pcg128_params {
- public:
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // pcg_engine is a simplified implementation of Melissa O'Neil's PCG engine in
+        // C++.  PCG combines a linear congruential generator (LCG) with output state
+        // mixing functions to generate each random variate.  pcg_engine supports only a
+        // single sequence (oneseq), and does not support streams.
+        //
+        // pcg_engine is parameterized by two types:
+        //   Params, which provides the multiplier and increment values;
+        //   Mix, which mixes the state into the result.
+        //
+        template<typename Params, typename Mix>
+        class pcg_engine
+        {
+            static_assert(std::is_same<typename Params::state_type, typename Mix::state_type>::value, "Class-template absl::pcg_engine must be parameterized by "
+                                                                                                      "Params and Mix with identical state_type");
+
+            static_assert(std::is_unsigned<typename Mix::result_type>::value, "Class-template absl::pcg_engine must be parameterized by "
+                                                                              "an unsigned Mix::result_type");
+
+            using params_type = Params;
+            using mix_type = Mix;
+            using state_type = typename Mix::state_type;
+
+        public:
+            // C++11 URBG interface:
+            using result_type = typename Mix::result_type;
+
+            static constexpr result_type(min)()
+            {
+                return (std::numeric_limits<result_type>::min)();
+            }
+
+            static constexpr result_type(max)()
+            {
+                return (std::numeric_limits<result_type>::max)();
+            }
+
+            explicit pcg_engine(uint64_t seed_value = 0)
+            {
+                seed(seed_value);
+            }
+
+            template<class SeedSequence, typename = typename absl::enable_if_t<!std::is_same<SeedSequence, pcg_engine>::value>>
+            explicit pcg_engine(SeedSequence&& seq)
+            {
+                seed(seq);
+            }
+
+            pcg_engine(const pcg_engine&) = default;
+            pcg_engine& operator=(const pcg_engine&) = default;
+            pcg_engine(pcg_engine&&) = default;
+            pcg_engine& operator=(pcg_engine&&) = default;
+
+            result_type operator()()
+            {
+                // Advance the LCG state, always using the new value to generate the output.
+                state_ = lcg(state_);
+                return Mix{}(state_);
+            }
+
+            void seed(uint64_t seed_value = 0)
+            {
+                state_type tmp = seed_value;
+                state_ = lcg(tmp + Params::increment());
+            }
+
+            template<class SeedSequence>
+            typename absl::enable_if_t<
+                !std::is_convertible<SeedSequence, uint64_t>::value,
+                void>
+                seed(SeedSequence&& seq)
+            {
+                reseed(seq);
+            }
+
+            void discard(uint64_t count)
+            {
+                state_ = advance(state_, count);
+            }
+
+            bool operator==(const pcg_engine& other) const
+            {
+                return state_ == other.state_;
+            }
+
+            bool operator!=(const pcg_engine& other) const
+            {
+                return !(*this == other);
+            }
+
+            template<class CharT, class Traits>
+            friend typename absl::enable_if_t<(sizeof(state_type) == 16), std::basic_ostream<CharT, Traits>&>
+                operator<<(
+                    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+                    const pcg_engine& engine
+                )
+            {
+                auto saver = random_internal::make_ostream_state_saver(os);
+                random_internal::stream_u128_helper<state_type> helper;
+                helper.write(pcg_engine::params_type::multiplier(), os);
+                os << os.fill();
+                helper.write(pcg_engine::params_type::increment(), os);
+                os << os.fill();
+                helper.write(engine.state_, os);
+                return os;
+            }
+
+            template<class CharT, class Traits>
+            friend typename absl::enable_if_t<(sizeof(state_type) <= 8), std::basic_ostream<CharT, Traits>&>
+                operator<<(
+                    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+                    const pcg_engine& engine
+                )
+            {
+                auto saver = random_internal::make_ostream_state_saver(os);
+                os << pcg_engine::params_type::multiplier() << os.fill();
+                os << pcg_engine::params_type::increment() << os.fill();
+                os << engine.state_;
+                return os;
+            }
+
+            template<class CharT, class Traits>
+            friend typename absl::enable_if_t<(sizeof(state_type) == 16), std::basic_istream<CharT, Traits>&>
+                operator>>(
+                    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+                    pcg_engine& engine
+                )
+            {  // NOLINT(runtime/references)
+                random_internal::stream_u128_helper<state_type> helper;
+                auto mult = helper.read(is);
+                auto inc = helper.read(is);
+                auto tmp = helper.read(is);
+                if (mult != pcg_engine::params_type::multiplier() ||
+                    inc != pcg_engine::params_type::increment())
+                {
+                    // signal failure by setting the failbit.
+                    is.setstate(is.rdstate() | std::ios_base::failbit);
+                }
+                if (!is.fail())
+                {
+                    engine.state_ = tmp;
+                }
+                return is;
+            }
+
+            template<class CharT, class Traits>
+            friend typename absl::enable_if_t<(sizeof(state_type) <= 8), std::basic_istream<CharT, Traits>&>
+                operator>>(
+                    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+                    pcg_engine& engine
+                )
+            {  // NOLINT(runtime/references)
+                state_type mult{}, inc{}, tmp{};
+                is >> mult >> inc >> tmp;
+                if (mult != pcg_engine::params_type::multiplier() ||
+                    inc != pcg_engine::params_type::increment())
+                {
+                    // signal failure by setting the failbit.
+                    is.setstate(is.rdstate() | std::ios_base::failbit);
+                }
+                if (!is.fail())
+                {
+                    engine.state_ = tmp;
+                }
+                return is;
+            }
+
+        private:
+            state_type state_;
+
+            // Returns the linear-congruential generator next state.
+            static inline constexpr state_type lcg(state_type s)
+            {
+                return s * Params::multiplier() + Params::increment();
+            }
+
+            // Returns the linear-congruential arbitrary seek state.
+            inline state_type advance(state_type s, uint64_t n) const
+            {
+                state_type mult = Params::multiplier();
+                state_type inc = Params::increment();
+                state_type m = 1;
+                state_type i = 0;
+                while (n > 0)
+                {
+                    if (n & 1)
+                    {
+                        m *= mult;
+                        i = i * mult + inc;
+                    }
+                    inc = (mult + 1) * inc;
+                    mult *= mult;
+                    n >>= 1;
+                }
+                return m * s + i;
+            }
+
+            template<class SeedSequence>
+            void reseed(SeedSequence& seq)
+            {
+                using sequence_result_type = typename SeedSequence::result_type;
+                constexpr size_t kBufferSize =
+                    sizeof(state_type) / sizeof(sequence_result_type);
+                sequence_result_type buffer[kBufferSize];
+                seq.generate(std::begin(buffer), std::end(buffer));
+                // Convert the seed output to a single state value.
+                state_type tmp = buffer[0];
+                for (size_t i = 1; i < kBufferSize; i++)
+                {
+                    tmp <<= (sizeof(sequence_result_type) * 8);
+                    tmp |= buffer[i];
+                }
+                state_ = lcg(tmp + params_type::increment());
+            }
+        };
+
+        // Parameterized implementation of the PCG 128-bit oneseq state.
+        // This provides state_type, multiplier, and increment for pcg_engine.
+        template<uint64_t kMultA, uint64_t kMultB, uint64_t kIncA, uint64_t kIncB>
+        class pcg128_params
+        {
+        public:
 #if ABSL_HAVE_INTRINSIC_INT128
-  using state_type = __uint128_t;
-  static inline constexpr state_type make_u128(uint64_t a, uint64_t b) {
-    return (static_cast<__uint128_t>(a) << 64) | b;
-  }
+            using state_type = __uint128_t;
+            static inline constexpr state_type make_u128(uint64_t a, uint64_t b)
+            {
+                return (static_cast<__uint128_t>(a) << 64) | b;
+            }
 #else
-  using state_type = absl::uint128;
-  static inline constexpr state_type make_u128(uint64_t a, uint64_t b) {
-    return absl::MakeUint128(a, b);
-  }
+            using state_type = absl::uint128;
+            static inline constexpr state_type make_u128(uint64_t a, uint64_t b)
+            {
+                return absl::MakeUint128(a, b);
+            }
 #endif
 
-  static inline constexpr state_type multiplier() {
-    return make_u128(kMultA, kMultB);
-  }
-  static inline constexpr state_type increment() {
-    return make_u128(kIncA, kIncB);
-  }
-};
-
-// Implementation of the PCG xsl_rr_128_64 128-bit mixing function, which
-// accepts an input of state_type and mixes it into an output of result_type.
-struct pcg_xsl_rr_128_64 {
+            static inline constexpr state_type multiplier()
+            {
+                return make_u128(kMultA, kMultB);
+            }
+            static inline constexpr state_type increment()
+            {
+                return make_u128(kIncA, kIncB);
+            }
+        };
+
+        // Implementation of the PCG xsl_rr_128_64 128-bit mixing function, which
+        // accepts an input of state_type and mixes it into an output of result_type.
+        struct pcg_xsl_rr_128_64
+        {
 #if ABSL_HAVE_INTRINSIC_INT128
-  using state_type = __uint128_t;
+            using state_type = __uint128_t;
 #else
-  using state_type = absl::uint128;
+            using state_type = absl::uint128;
 #endif
-  using result_type = uint64_t;
+            using result_type = uint64_t;
 
-  inline uint64_t operator()(state_type state) {
-    // This is equivalent to the xsl_rr_128_64 mixing function.
+            inline uint64_t operator()(state_type state)
+            {
+                // This is equivalent to the xsl_rr_128_64 mixing function.
 #if ABSL_HAVE_INTRINSIC_INT128
-    uint64_t rotate = static_cast<uint64_t>(state >> 122u);
-    state ^= state >> 64;
-    uint64_t s = static_cast<uint64_t>(state);
+                uint64_t rotate = static_cast<uint64_t>(state >> 122u);
+                state ^= state >> 64;
+                uint64_t s = static_cast<uint64_t>(state);
 #else
-    uint64_t h = Uint128High64(state);
-    uint64_t rotate = h >> 58u;
-    uint64_t s = Uint128Low64(state) ^ h;
+                uint64_t h = Uint128High64(state);
+                uint64_t rotate = h >> 58u;
+                uint64_t s = Uint128Low64(state) ^ h;
 #endif
-    return rotr(s, static_cast<int>(rotate));
-  }
-};
-
-// Parameterized implementation of the PCG 64-bit oneseq state.
-// This provides state_type, multiplier, and increment for pcg_engine.
-template <uint64_t kMult, uint64_t kInc>
-class pcg64_params {
- public:
-  using state_type = uint64_t;
-  static inline constexpr state_type multiplier() { return kMult; }
-  static inline constexpr state_type increment() { return kInc; }
-};
-
-// Implementation of the PCG xsh_rr_64_32 64-bit mixing function, which accepts
-// an input of state_type and mixes it into an output of result_type.
-struct pcg_xsh_rr_64_32 {
-  using state_type = uint64_t;
-  using result_type = uint32_t;
-  inline uint32_t operator()(uint64_t state) {
-    return rotr(static_cast<uint32_t>(((state >> 18) ^ state) >> 27),
-                state >> 59);
-  }
-};
-
-// Stable pcg_engine implementations:
-// This is a 64-bit generator using 128-bits of state.
-// The output sequence is equivalent to Melissa O'Neil's pcg64_oneseq.
-using pcg64_2018_engine = pcg_engine<
-    random_internal::pcg128_params<0x2360ed051fc65da4ull, 0x4385df649fccf645ull,
-                                   0x5851f42d4c957f2d, 0x14057b7ef767814f>,
-    random_internal::pcg_xsl_rr_128_64>;
-
-// This is a 32-bit generator using 64-bits of state.
-// This is equivalent to Melissa O'Neil's pcg32_oneseq.
-using pcg32_2018_engine = pcg_engine<
-    random_internal::pcg64_params<0x5851f42d4c957f2dull, 0x14057b7ef767814full>,
-    random_internal::pcg_xsh_rr_64_32>;
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+                return rotr(s, static_cast<int>(rotate));
+            }
+        };
+
+        // Parameterized implementation of the PCG 64-bit oneseq state.
+        // This provides state_type, multiplier, and increment for pcg_engine.
+        template<uint64_t kMult, uint64_t kInc>
+        class pcg64_params
+        {
+        public:
+            using state_type = uint64_t;
+            static inline constexpr state_type multiplier()
+            {
+                return kMult;
+            }
+            static inline constexpr state_type increment()
+            {
+                return kInc;
+            }
+        };
+
+        // Implementation of the PCG xsh_rr_64_32 64-bit mixing function, which accepts
+        // an input of state_type and mixes it into an output of result_type.
+        struct pcg_xsh_rr_64_32
+        {
+            using state_type = uint64_t;
+            using result_type = uint32_t;
+            inline uint32_t operator()(uint64_t state)
+            {
+                return rotr(static_cast<uint32_t>(((state >> 18) ^ state) >> 27), state >> 59);
+            }
+        };
+
+        // Stable pcg_engine implementations:
+        // This is a 64-bit generator using 128-bits of state.
+        // The output sequence is equivalent to Melissa O'Neil's pcg64_oneseq.
+        using pcg64_2018_engine = pcg_engine<
+            random_internal::pcg128_params<0x2360ed051fc65da4ull, 0x4385df649fccf645ull, 0x5851f42d4c957f2d, 0x14057b7ef767814f>,
+            random_internal::pcg_xsl_rr_128_64>;
+
+        // This is a 32-bit generator using 64-bits of state.
+        // This is equivalent to Melissa O'Neil's pcg32_oneseq.
+        using pcg32_2018_engine = pcg_engine<
+            random_internal::pcg64_params<0x5851f42d4c957f2dull, 0x14057b7ef767814full>,
+            random_internal::pcg_xsh_rr_64_32>;
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_PCG_ENGINE_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/pool_urbg.h b/CAPI/cpp/grpc/include/absl/random/internal/pool_urbg.h
index 0572192..64e557e 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/pool_urbg.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/pool_urbg.h
@@ -21,111 +21,128 @@
 #include "absl/random/internal/traits.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// RandenPool is a thread-safe random number generator [random.req.urbg] that
-// uses an underlying pool of Randen generators to generate values.  Each thread
-// has affinity to one instance of the underlying pool generators.  Concurrent
-// access is guarded by a spin-lock.
-template <typename T>
-class RandenPool {
- public:
-  using result_type = T;
-  static_assert(std::is_unsigned<result_type>::value,
-                "RandenPool template argument must be a built-in unsigned "
-                "integer type");
-
-  static constexpr result_type(min)() {
-    return (std::numeric_limits<result_type>::min)();
-  }
-
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
-
-  RandenPool() {}
-
-  // Returns a single value.
-  inline result_type operator()() { return Generate(); }
-
-  // Fill data with random values.
-  static void Fill(absl::Span<result_type> data);
-
- protected:
-  // Generate returns a single value.
-  static result_type Generate();
-};
-
-extern template class RandenPool<uint8_t>;
-extern template class RandenPool<uint16_t>;
-extern template class RandenPool<uint32_t>;
-extern template class RandenPool<uint64_t>;
-
-// PoolURBG uses an underlying pool of random generators to implement a
-// thread-compatible [random.req.urbg] interface with an internal cache of
-// values.
-template <typename T, size_t kBufferSize>
-class PoolURBG {
-  // Inheritance to access the protected static members of RandenPool.
-  using unsigned_type = typename make_unsigned_bits<T>::type;
-  using PoolType = RandenPool<unsigned_type>;
-  using SpanType = absl::Span<unsigned_type>;
-
-  static constexpr size_t kInitialBuffer = kBufferSize + 1;
-  static constexpr size_t kHalfBuffer = kBufferSize / 2;
-
- public:
-  using result_type = T;
-
-  static_assert(std::is_unsigned<result_type>::value,
-                "PoolURBG must be parameterized by an unsigned integer type");
-
-  static_assert(kBufferSize > 1,
-                "PoolURBG must be parameterized by a buffer-size > 1");
-
-  static_assert(kBufferSize <= 256,
-                "PoolURBG must be parameterized by a buffer-size <= 256");
-
-  static constexpr result_type(min)() {
-    return (std::numeric_limits<result_type>::min)();
-  }
-
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
-
-  PoolURBG() : next_(kInitialBuffer) {}
-
-  // copy-constructor does not copy cache.
-  PoolURBG(const PoolURBG&) : next_(kInitialBuffer) {}
-  const PoolURBG& operator=(const PoolURBG&) {
-    next_ = kInitialBuffer;
-    return *this;
-  }
-
-  // move-constructor does move cache.
-  PoolURBG(PoolURBG&&) = default;
-  PoolURBG& operator=(PoolURBG&&) = default;
-
-  inline result_type operator()() {
-    if (next_ >= kBufferSize) {
-      next_ = (kBufferSize > 2 && next_ > kBufferSize) ? kHalfBuffer : 0;
-      PoolType::Fill(SpanType(reinterpret_cast<unsigned_type*>(state_ + next_),
-                              kBufferSize - next_));
-    }
-    return state_[next_++];
-  }
-
- private:
-  // Buffer size.
-  size_t next_;  // index within state_
-  result_type state_[kBufferSize];
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // RandenPool is a thread-safe random number generator [random.req.urbg] that
+        // uses an underlying pool of Randen generators to generate values.  Each thread
+        // has affinity to one instance of the underlying pool generators.  Concurrent
+        // access is guarded by a spin-lock.
+        template<typename T>
+        class RandenPool
+        {
+        public:
+            using result_type = T;
+            static_assert(std::is_unsigned<result_type>::value, "RandenPool template argument must be a built-in unsigned "
+                                                                "integer type");
+
+            static constexpr result_type(min)()
+            {
+                return (std::numeric_limits<result_type>::min)();
+            }
+
+            static constexpr result_type(max)()
+            {
+                return (std::numeric_limits<result_type>::max)();
+            }
+
+            RandenPool()
+            {
+            }
+
+            // Returns a single value.
+            inline result_type operator()()
+            {
+                return Generate();
+            }
+
+            // Fill data with random values.
+            static void Fill(absl::Span<result_type> data);
+
+        protected:
+            // Generate returns a single value.
+            static result_type Generate();
+        };
+
+        extern template class RandenPool<uint8_t>;
+        extern template class RandenPool<uint16_t>;
+        extern template class RandenPool<uint32_t>;
+        extern template class RandenPool<uint64_t>;
+
+        // PoolURBG uses an underlying pool of random generators to implement a
+        // thread-compatible [random.req.urbg] interface with an internal cache of
+        // values.
+        template<typename T, size_t kBufferSize>
+        class PoolURBG
+        {
+            // Inheritance to access the protected static members of RandenPool.
+            using unsigned_type = typename make_unsigned_bits<T>::type;
+            using PoolType = RandenPool<unsigned_type>;
+            using SpanType = absl::Span<unsigned_type>;
+
+            static constexpr size_t kInitialBuffer = kBufferSize + 1;
+            static constexpr size_t kHalfBuffer = kBufferSize / 2;
+
+        public:
+            using result_type = T;
+
+            static_assert(std::is_unsigned<result_type>::value, "PoolURBG must be parameterized by an unsigned integer type");
+
+            static_assert(kBufferSize > 1, "PoolURBG must be parameterized by a buffer-size > 1");
+
+            static_assert(kBufferSize <= 256, "PoolURBG must be parameterized by a buffer-size <= 256");
+
+            static constexpr result_type(min)()
+            {
+                return (std::numeric_limits<result_type>::min)();
+            }
+
+            static constexpr result_type(max)()
+            {
+                return (std::numeric_limits<result_type>::max)();
+            }
+
+            PoolURBG() :
+                next_(kInitialBuffer)
+            {
+            }
+
+            // copy-constructor does not copy cache.
+            PoolURBG(const PoolURBG&) :
+                next_(kInitialBuffer)
+            {
+            }
+            const PoolURBG& operator=(const PoolURBG&)
+            {
+                next_ = kInitialBuffer;
+                return *this;
+            }
+
+            // move-constructor does move cache.
+            PoolURBG(PoolURBG&&) = default;
+            PoolURBG& operator=(PoolURBG&&) = default;
+
+            inline result_type operator()()
+            {
+                if (next_ >= kBufferSize)
+                {
+                    next_ = (kBufferSize > 2 && next_ > kBufferSize) ? kHalfBuffer : 0;
+                    PoolType::Fill(SpanType(reinterpret_cast<unsigned_type*>(state_ + next_), kBufferSize - next_));
+                }
+                return state_[next_++];
+            }
+
+        private:
+            // Buffer size.
+            size_t next_;  // index within state_
+            result_type state_[kBufferSize];
+        };
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_POOL_URBG_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen.h b/CAPI/cpp/grpc/include/absl/random/internal/randen.h
index 9ff4a7a..01e4d42 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/randen.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen.h
@@ -22,75 +22,86 @@
 #include "absl/random/internal/randen_slow.h"
 #include "absl/random/internal/randen_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
-// 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
-// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
-//
-// Randen implements the basic state manipulation methods.
-class Randen {
- public:
-  static constexpr size_t kStateBytes = RandenTraits::kStateBytes;
-  static constexpr size_t kCapacityBytes = RandenTraits::kCapacityBytes;
-  static constexpr size_t kSeedBytes = RandenTraits::kSeedBytes;
+        // RANDen = RANDom generator or beetroots in Swiss High German.
+        // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
+        // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
+        //
+        // Randen implements the basic state manipulation methods.
+        class Randen
+        {
+        public:
+            static constexpr size_t kStateBytes = RandenTraits::kStateBytes;
+            static constexpr size_t kCapacityBytes = RandenTraits::kCapacityBytes;
+            static constexpr size_t kSeedBytes = RandenTraits::kSeedBytes;
 
-  ~Randen() = default;
+            ~Randen() = default;
 
-  Randen();
+            Randen();
 
-  // Generate updates the randen sponge. The outer portion of the sponge
-  // (kCapacityBytes .. kStateBytes) may be consumed as PRNG state.
-  // REQUIRES: state points to kStateBytes of state.
-  inline void Generate(void* state) const {
+            // Generate updates the randen sponge. The outer portion of the sponge
+            // (kCapacityBytes .. kStateBytes) may be consumed as PRNG state.
+            // REQUIRES: state points to kStateBytes of state.
+            inline void Generate(void* state) const
+            {
 #if ABSL_RANDOM_INTERNAL_AES_DISPATCH
-    // HW AES Dispatch.
-    if (has_crypto_) {
-      RandenHwAes::Generate(keys_, state);
-    } else {
-      RandenSlow::Generate(keys_, state);
-    }
+                // HW AES Dispatch.
+                if (has_crypto_)
+                {
+                    RandenHwAes::Generate(keys_, state);
+                }
+                else
+                {
+                    RandenSlow::Generate(keys_, state);
+                }
 #elif ABSL_HAVE_ACCELERATED_AES
-    // HW AES is enabled.
-    RandenHwAes::Generate(keys_, state);
+                // HW AES is enabled.
+                RandenHwAes::Generate(keys_, state);
 #else
-    // HW AES is disabled.
-    RandenSlow::Generate(keys_, state);
+                // HW AES is disabled.
+                RandenSlow::Generate(keys_, state);
 #endif
-  }
+            }
 
-  // Absorb incorporates additional seed material into the randen sponge.  After
-  // absorb returns, Generate must be called before the state may be consumed.
-  // REQUIRES: seed points to kSeedBytes of seed.
-  // REQUIRES: state points to kStateBytes of state.
-  inline void Absorb(const void* seed, void* state) const {
+            // Absorb incorporates additional seed material into the randen sponge.  After
+            // absorb returns, Generate must be called before the state may be consumed.
+            // REQUIRES: seed points to kSeedBytes of seed.
+            // REQUIRES: state points to kStateBytes of state.
+            inline void Absorb(const void* seed, void* state) const
+            {
 #if ABSL_RANDOM_INTERNAL_AES_DISPATCH
-    // HW AES Dispatch.
-    if (has_crypto_) {
-      RandenHwAes::Absorb(seed, state);
-    } else {
-      RandenSlow::Absorb(seed, state);
-    }
+                // HW AES Dispatch.
+                if (has_crypto_)
+                {
+                    RandenHwAes::Absorb(seed, state);
+                }
+                else
+                {
+                    RandenSlow::Absorb(seed, state);
+                }
 #elif ABSL_HAVE_ACCELERATED_AES
-    // HW AES is enabled.
-    RandenHwAes::Absorb(seed, state);
+                // HW AES is enabled.
+                RandenHwAes::Absorb(seed, state);
 #else
-    // HW AES is disabled.
-    RandenSlow::Absorb(seed, state);
+                // HW AES is disabled.
+                RandenSlow::Absorb(seed, state);
 #endif
-  }
+            }
 
- private:
-  const void* keys_;
+        private:
+            const void* keys_;
 #if ABSL_RANDOM_INTERNAL_AES_DISPATCH
-  bool has_crypto_;
+            bool has_crypto_;
 #endif
-};
+        };
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_RANDEN_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_detect.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_detect.h
index f283f43..a6a2f93 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/randen_detect.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_detect.h
@@ -17,17 +17,19 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-// Returns whether the current CPU supports RandenHwAes implementation.
-// This typically involves supporting cryptographic extensions on whichever
-// platform is currently running.
-bool CPUSupportsRandenHwAes();
+        // Returns whether the current CPU supports RandenHwAes implementation.
+        // This typically involves supporting cryptographic extensions on whichever
+        // platform is currently running.
+        bool CPUSupportsRandenHwAes();
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_RANDEN_DETECT_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_engine.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_engine.h
index b470866..66871ae 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/randen_engine.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_engine.h
@@ -28,237 +28,271 @@
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/internal/randen.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-// Deterministic pseudorandom byte generator with backtracking resistance
-// (leaking the state does not compromise prior outputs). Based on Reverie
-// (see "A Robust and Sponge-Like PRNG with Improved Efficiency") instantiated
-// with an improved Simpira-like permutation.
-// Returns values of type "T" (must be a built-in unsigned integer type).
-//
-// RANDen = RANDom generator or beetroots in Swiss High German.
-// 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
-// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
-template <typename T>
-class alignas(8) randen_engine {
- public:
-  // C++11 URBG interface:
-  using result_type = T;
-  static_assert(std::is_unsigned<result_type>::value,
-                "randen_engine template argument must be a built-in unsigned "
-                "integer type");
+        // Deterministic pseudorandom byte generator with backtracking resistance
+        // (leaking the state does not compromise prior outputs). Based on Reverie
+        // (see "A Robust and Sponge-Like PRNG with Improved Efficiency") instantiated
+        // with an improved Simpira-like permutation.
+        // Returns values of type "T" (must be a built-in unsigned integer type).
+        //
+        // RANDen = RANDom generator or beetroots in Swiss High German.
+        // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
+        // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
+        template<typename T>
+        class alignas(8) randen_engine
+        {
+        public:
+            // C++11 URBG interface:
+            using result_type = T;
+            static_assert(std::is_unsigned<result_type>::value, "randen_engine template argument must be a built-in unsigned "
+                                                                "integer type");
 
-  static constexpr result_type(min)() {
-    return (std::numeric_limits<result_type>::min)();
-  }
+            static constexpr result_type(min)()
+            {
+                return (std::numeric_limits<result_type>::min)();
+            }
 
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
+            static constexpr result_type(max)()
+            {
+                return (std::numeric_limits<result_type>::max)();
+            }
 
-  randen_engine() : randen_engine(0) {}
-  explicit randen_engine(result_type seed_value) { seed(seed_value); }
+            randen_engine() :
+                randen_engine(0)
+            {
+            }
+            explicit randen_engine(result_type seed_value)
+            {
+                seed(seed_value);
+            }
 
-  template <class SeedSequence,
-            typename = typename absl::enable_if_t<
-                !std::is_same<SeedSequence, randen_engine>::value>>
-  explicit randen_engine(SeedSequence&& seq) {
-    seed(seq);
-  }
+            template<class SeedSequence, typename = typename absl::enable_if_t<!std::is_same<SeedSequence, randen_engine>::value>>
+            explicit randen_engine(SeedSequence&& seq)
+            {
+                seed(seq);
+            }
 
-  // alignment requirements dictate custom copy and move constructors.
-  randen_engine(const randen_engine& other)
-      : next_(other.next_), impl_(other.impl_) {
-    std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type));
-  }
-  randen_engine& operator=(const randen_engine& other) {
-    next_ = other.next_;
-    impl_ = other.impl_;
-    std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type));
-    return *this;
-  }
+            // alignment requirements dictate custom copy and move constructors.
+            randen_engine(const randen_engine& other) :
+                next_(other.next_),
+                impl_(other.impl_)
+            {
+                std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type));
+            }
+            randen_engine& operator=(const randen_engine& other)
+            {
+                next_ = other.next_;
+                impl_ = other.impl_;
+                std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type));
+                return *this;
+            }
 
-  // Returns random bits from the buffer in units of result_type.
-  result_type operator()() {
-    // Refill the buffer if needed (unlikely).
-    auto* begin = state();
-    if (next_ >= kStateSizeT) {
-      next_ = kCapacityT;
-      impl_.Generate(begin);
-    }
-    return little_endian::ToHost(begin[next_++]);
-  }
+            // Returns random bits from the buffer in units of result_type.
+            result_type operator()()
+            {
+                // Refill the buffer if needed (unlikely).
+                auto* begin = state();
+                if (next_ >= kStateSizeT)
+                {
+                    next_ = kCapacityT;
+                    impl_.Generate(begin);
+                }
+                return little_endian::ToHost(begin[next_++]);
+            }
 
-  template <class SeedSequence>
-  typename absl::enable_if_t<
-      !std::is_convertible<SeedSequence, result_type>::value>
-  seed(SeedSequence&& seq) {
-    // Zeroes the state.
-    seed();
-    reseed(seq);
-  }
+            template<class SeedSequence>
+            typename absl::enable_if_t<
+                !std::is_convertible<SeedSequence, result_type>::value>
+                seed(SeedSequence&& seq)
+            {
+                // Zeroes the state.
+                seed();
+                reseed(seq);
+            }
 
-  void seed(result_type seed_value = 0) {
-    next_ = kStateSizeT;
-    // Zeroes the inner state and fills the outer state with seed_value to
-    // mimic the behaviour of reseed
-    auto* begin = state();
-    std::fill(begin, begin + kCapacityT, 0);
-    std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value);
-  }
+            void seed(result_type seed_value = 0)
+            {
+                next_ = kStateSizeT;
+                // Zeroes the inner state and fills the outer state with seed_value to
+                // mimic the behaviour of reseed
+                auto* begin = state();
+                std::fill(begin, begin + kCapacityT, 0);
+                std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value);
+            }
 
-  // Inserts entropy into (part of) the state. Calling this periodically with
-  // sufficient entropy ensures prediction resistance (attackers cannot predict
-  // future outputs even if state is compromised).
-  template <class SeedSequence>
-  void reseed(SeedSequence& seq) {
-    using sequence_result_type = typename SeedSequence::result_type;
-    static_assert(sizeof(sequence_result_type) == 4,
-                  "SeedSequence::result_type must be 32-bit");
-    constexpr size_t kBufferSize =
-        Randen::kSeedBytes / sizeof(sequence_result_type);
-    alignas(16) sequence_result_type buffer[kBufferSize];
+            // Inserts entropy into (part of) the state. Calling this periodically with
+            // sufficient entropy ensures prediction resistance (attackers cannot predict
+            // future outputs even if state is compromised).
+            template<class SeedSequence>
+            void reseed(SeedSequence& seq)
+            {
+                using sequence_result_type = typename SeedSequence::result_type;
+                static_assert(sizeof(sequence_result_type) == 4, "SeedSequence::result_type must be 32-bit");
+                constexpr size_t kBufferSize =
+                    Randen::kSeedBytes / sizeof(sequence_result_type);
+                alignas(16) sequence_result_type buffer[kBufferSize];
 
-    // Randen::Absorb XORs the seed into state, which is then mixed by a call
-    // to Randen::Generate. Seeding with only the provided entropy is preferred
-    // to using an arbitrary generate() call, so use [rand.req.seed_seq]
-    // size as a proxy for the number of entropy units that can be generated
-    // without relying on seed sequence mixing...
-    const size_t entropy_size = seq.size();
-    if (entropy_size < kBufferSize) {
-      // ... and only request that many values, or 256-bits, when unspecified.
-      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
-      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
-      seq.generate(buffer, buffer + requested_entropy);
+                // Randen::Absorb XORs the seed into state, which is then mixed by a call
+                // to Randen::Generate. Seeding with only the provided entropy is preferred
+                // to using an arbitrary generate() call, so use [rand.req.seed_seq]
+                // size as a proxy for the number of entropy units that can be generated
+                // without relying on seed sequence mixing...
+                const size_t entropy_size = seq.size();
+                if (entropy_size < kBufferSize)
+                {
+                    // ... and only request that many values, or 256-bits, when unspecified.
+                    const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
+                    std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
+                    seq.generate(buffer, buffer + requested_entropy);
 #ifdef ABSL_IS_BIG_ENDIAN
-      // Randen expects the seed buffer to be in Little Endian; reverse it on
-      // Big Endian platforms.
-      for (sequence_result_type& e : buffer) {
-        e = absl::little_endian::FromHost(e);
-      }
+                    // Randen expects the seed buffer to be in Little Endian; reverse it on
+                    // Big Endian platforms.
+                    for (sequence_result_type& e : buffer)
+                    {
+                        e = absl::little_endian::FromHost(e);
+                    }
 #endif
-      // The Randen paper suggests preferentially initializing even-numbered
-      // 128-bit vectors of the randen state (there are 16 such vectors).
-      // The seed data is merged into the state offset by 128-bits, which
-      // implies prefering seed bytes [16..31, ..., 208..223]. Since the
-      // buffer is 32-bit values, we swap the corresponding buffer positions in
-      // 128-bit chunks.
-      size_t dst = kBufferSize;
-      while (dst > 7) {
-        // leave the odd bucket as-is.
-        dst -= 4;
-        size_t src = dst >> 1;
-        // swap 128-bits into the even bucket
-        std::swap(buffer[--dst], buffer[--src]);
-        std::swap(buffer[--dst], buffer[--src]);
-        std::swap(buffer[--dst], buffer[--src]);
-        std::swap(buffer[--dst], buffer[--src]);
-      }
-    } else {
-      seq.generate(buffer, buffer + kBufferSize);
-    }
-    impl_.Absorb(buffer, state());
+                    // The Randen paper suggests preferentially initializing even-numbered
+                    // 128-bit vectors of the randen state (there are 16 such vectors).
+                    // The seed data is merged into the state offset by 128-bits, which
+                    // implies prefering seed bytes [16..31, ..., 208..223]. Since the
+                    // buffer is 32-bit values, we swap the corresponding buffer positions in
+                    // 128-bit chunks.
+                    size_t dst = kBufferSize;
+                    while (dst > 7)
+                    {
+                        // leave the odd bucket as-is.
+                        dst -= 4;
+                        size_t src = dst >> 1;
+                        // swap 128-bits into the even bucket
+                        std::swap(buffer[--dst], buffer[--src]);
+                        std::swap(buffer[--dst], buffer[--src]);
+                        std::swap(buffer[--dst], buffer[--src]);
+                        std::swap(buffer[--dst], buffer[--src]);
+                    }
+                }
+                else
+                {
+                    seq.generate(buffer, buffer + kBufferSize);
+                }
+                impl_.Absorb(buffer, state());
 
-    // Generate will be called when operator() is called
-    next_ = kStateSizeT;
-  }
+                // Generate will be called when operator() is called
+                next_ = kStateSizeT;
+            }
 
-  void discard(uint64_t count) {
-    uint64_t step = std::min<uint64_t>(kStateSizeT - next_, count);
-    count -= step;
+            void discard(uint64_t count)
+            {
+                uint64_t step = std::min<uint64_t>(kStateSizeT - next_, count);
+                count -= step;
 
-    constexpr uint64_t kRateT = kStateSizeT - kCapacityT;
-    auto* begin = state();
-    while (count > 0) {
-      next_ = kCapacityT;
-      impl_.Generate(*reinterpret_cast<result_type(*)[kStateSizeT]>(begin));
-      step = std::min<uint64_t>(kRateT, count);
-      count -= step;
-    }
-    next_ += step;
-  }
+                constexpr uint64_t kRateT = kStateSizeT - kCapacityT;
+                auto* begin = state();
+                while (count > 0)
+                {
+                    next_ = kCapacityT;
+                    impl_.Generate(*reinterpret_cast<result_type(*)[kStateSizeT]>(begin));
+                    step = std::min<uint64_t>(kRateT, count);
+                    count -= step;
+                }
+                next_ += step;
+            }
 
-  bool operator==(const randen_engine& other) const {
-    const auto* begin = state();
-    return next_ == other.next_ &&
-           std::equal(begin, begin + kStateSizeT, other.state());
-  }
+            bool operator==(const randen_engine& other) const
+            {
+                const auto* begin = state();
+                return next_ == other.next_ &&
+                       std::equal(begin, begin + kStateSizeT, other.state());
+            }
 
-  bool operator!=(const randen_engine& other) const {
-    return !(*this == other);
-  }
+            bool operator!=(const randen_engine& other) const
+            {
+                return !(*this == other);
+            }
 
-  template <class CharT, class Traits>
-  friend std::basic_ostream<CharT, Traits>& operator<<(
-      std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-      const randen_engine<T>& engine) {       // NOLINT(runtime/references)
-    using numeric_type =
-        typename random_internal::stream_format_type<result_type>::type;
-    auto saver = random_internal::make_ostream_state_saver(os);
-    auto* it = engine.state();
-    for (auto* end = it + kStateSizeT; it < end; ++it) {
-      // In the case that `elem` is `uint8_t`, it must be cast to something
-      // larger so that it prints as an integer rather than a character. For
-      // simplicity, apply the cast all circumstances.
-      os << static_cast<numeric_type>(little_endian::FromHost(*it))
-         << os.fill();
-    }
-    os << engine.next_;
-    return os;
-  }
+            template<class CharT, class Traits>
+            friend std::basic_ostream<CharT, Traits>& operator<<(
+                std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+                const randen_engine<T>& engine
+            )
+            {  // NOLINT(runtime/references)
+                using numeric_type =
+                    typename random_internal::stream_format_type<result_type>::type;
+                auto saver = random_internal::make_ostream_state_saver(os);
+                auto* it = engine.state();
+                for (auto* end = it + kStateSizeT; it < end; ++it)
+                {
+                    // In the case that `elem` is `uint8_t`, it must be cast to something
+                    // larger so that it prints as an integer rather than a character. For
+                    // simplicity, apply the cast all circumstances.
+                    os << static_cast<numeric_type>(little_endian::FromHost(*it))
+                       << os.fill();
+                }
+                os << engine.next_;
+                return os;
+            }
 
-  template <class CharT, class Traits>
-  friend std::basic_istream<CharT, Traits>& operator>>(
-      std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-      randen_engine<T>& engine) {             // NOLINT(runtime/references)
-    using numeric_type =
-        typename random_internal::stream_format_type<result_type>::type;
-    result_type state[kStateSizeT];
-    size_t next;
-    for (auto& elem : state) {
-      // It is not possible to read uint8_t from wide streams, so it is
-      // necessary to read a wider type and then cast it to uint8_t.
-      numeric_type value;
-      is >> value;
-      elem = little_endian::ToHost(static_cast<result_type>(value));
-    }
-    is >> next;
-    if (is.fail()) {
-      return is;
-    }
-    std::memcpy(engine.state(), state, sizeof(state));
-    engine.next_ = next;
-    return is;
-  }
+            template<class CharT, class Traits>
+            friend std::basic_istream<CharT, Traits>& operator>>(
+                std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+                randen_engine<T>& engine
+            )
+            {  // NOLINT(runtime/references)
+                using numeric_type =
+                    typename random_internal::stream_format_type<result_type>::type;
+                result_type state[kStateSizeT];
+                size_t next;
+                for (auto& elem : state)
+                {
+                    // It is not possible to read uint8_t from wide streams, so it is
+                    // necessary to read a wider type and then cast it to uint8_t.
+                    numeric_type value;
+                    is >> value;
+                    elem = little_endian::ToHost(static_cast<result_type>(value));
+                }
+                is >> next;
+                if (is.fail())
+                {
+                    return is;
+                }
+                std::memcpy(engine.state(), state, sizeof(state));
+                engine.next_ = next;
+                return is;
+            }
 
- private:
-  static constexpr size_t kStateSizeT =
-      Randen::kStateBytes / sizeof(result_type);
-  static constexpr size_t kCapacityT =
-      Randen::kCapacityBytes / sizeof(result_type);
+        private:
+            static constexpr size_t kStateSizeT =
+                Randen::kStateBytes / sizeof(result_type);
+            static constexpr size_t kCapacityT =
+                Randen::kCapacityBytes / sizeof(result_type);
 
-  // Returns the state array pointer, which is aligned to 16 bytes.
-  // The first kCapacityT are the `inner' sponge; the remainder are available.
-  result_type* state() {
-    return reinterpret_cast<result_type*>(
-        (reinterpret_cast<uintptr_t>(&raw_state_) & 0xf) ? (raw_state_ + 8)
-                                                         : raw_state_);
-  }
-  const result_type* state() const {
-    return const_cast<randen_engine*>(this)->state();
-  }
+            // Returns the state array pointer, which is aligned to 16 bytes.
+            // The first kCapacityT are the `inner' sponge; the remainder are available.
+            result_type* state()
+            {
+                return reinterpret_cast<result_type*>(
+                    (reinterpret_cast<uintptr_t>(&raw_state_) & 0xf) ? (raw_state_ + 8) : raw_state_
+                );
+            }
+            const result_type* state() const
+            {
+                return const_cast<randen_engine*>(this)->state();
+            }
 
-  // raw state array, manually aligned in state(). This overallocates
-  // by 8 bytes since C++ does not guarantee extended heap alignment.
-  alignas(8) char raw_state_[Randen::kStateBytes + 8];
-  size_t next_;  // index within state()
-  Randen impl_;
-};
+            // raw state array, manually aligned in state(). This overallocates
+            // by 8 bytes since C++ does not guarantee extended heap alignment.
+            alignas(8) char raw_state_[Randen::kStateBytes + 8];
+            size_t next_;  // index within state()
+            Randen impl_;
+        };
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_RANDEN_ENGINE_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_hwaes.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_hwaes.h
index 71a7f69..6d0e1ae 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/randen_hwaes.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_hwaes.h
@@ -22,29 +22,32 @@
 // with different flags from other targets, using different levels of
 // optimization, potentially introducing ODR violations.
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// RANDen = RANDom generator or beetroots in Swiss High German.
-// 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
-// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
-//
-// RandenHwAes implements the basic state manipulation methods.
-class RandenHwAes {
- public:
-  static void Generate(const void* keys, void* state_void);
-  static void Absorb(const void* seed_void, void* state_void);
-  static const void* GetKeys();
-};
-
-// HasRandenHwAesImplementation returns true when there is an accelerated
-// implementation, and false otherwise.  If there is no implementation,
-// then attempting to use it will abort the program.
-bool HasRandenHwAesImplementation();
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // RANDen = RANDom generator or beetroots in Swiss High German.
+        // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
+        // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
+        //
+        // RandenHwAes implements the basic state manipulation methods.
+        class RandenHwAes
+        {
+        public:
+            static void Generate(const void* keys, void* state_void);
+            static void Absorb(const void* seed_void, void* state_void);
+            static const void* GetKeys();
+        };
+
+        // HasRandenHwAesImplementation returns true when there is an accelerated
+        // implementation, and false otherwise.  If there is no implementation,
+        // then attempting to use it will abort the program.
+        bool HasRandenHwAesImplementation();
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_RANDEN_HWAES_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_slow.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_slow.h
index 532c3a8..25c3133 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/randen_slow.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_slow.h
@@ -19,22 +19,25 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
-// RandenSlow implements the basic state manipulation methods for
-// architectures lacking AES hardware acceleration intrinsics.
-class RandenSlow {
- public:
-  static void Generate(const void* keys, void* state_void);
-  static void Absorb(const void* seed_void, void* state_void);
-  static const void* GetKeys();
-};
+        // RANDen = RANDom generator or beetroots in Swiss High German.
+        // RandenSlow implements the basic state manipulation methods for
+        // architectures lacking AES hardware acceleration intrinsics.
+        class RandenSlow
+        {
+        public:
+            static void Generate(const void* keys, void* state_void);
+            static void Absorb(const void* seed_void, void* state_void);
+            static const void* GetKeys();
+        };
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_RANDEN_SLOW_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/randen_traits.h b/CAPI/cpp/grpc/include/absl/random/internal/randen_traits.h
index 120022c..5217b88 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/randen_traits.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/randen_traits.h
@@ -24,65 +24,68 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
-// 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
-// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
-//
-// High-level summary:
-// 1) Reverie (see "A Robust and Sponge-Like PRNG with Improved Efficiency") is
-//    a sponge-like random generator that requires a cryptographic permutation.
-//    It improves upon "Provably Robust Sponge-Based PRNGs and KDFs" by
-//    achieving backtracking resistance with only one Permute() per buffer.
-//
-// 2) "Simpira v2: A Family of Efficient Permutations Using the AES Round
-//    Function" constructs up to 1024-bit permutations using an improved
-//    Generalized Feistel network with 2-round AES-128 functions. This Feistel
-//    block shuffle achieves diffusion faster and is less vulnerable to
-//    sliced-biclique attacks than the Type-2 cyclic shuffle.
-//
-// 3) "Improving the Generalized Feistel" and "New criterion for diffusion
-//    property" extends the same kind of improved Feistel block shuffle to 16
-//    branches, which enables a 2048-bit permutation.
-//
-// Combine these three ideas and also change Simpira's subround keys from
-// structured/low-entropy counters to digits of Pi (or other random source).
+        // RANDen = RANDom generator or beetroots in Swiss High German.
+        // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
+        // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
+        //
+        // High-level summary:
+        // 1) Reverie (see "A Robust and Sponge-Like PRNG with Improved Efficiency") is
+        //    a sponge-like random generator that requires a cryptographic permutation.
+        //    It improves upon "Provably Robust Sponge-Based PRNGs and KDFs" by
+        //    achieving backtracking resistance with only one Permute() per buffer.
+        //
+        // 2) "Simpira v2: A Family of Efficient Permutations Using the AES Round
+        //    Function" constructs up to 1024-bit permutations using an improved
+        //    Generalized Feistel network with 2-round AES-128 functions. This Feistel
+        //    block shuffle achieves diffusion faster and is less vulnerable to
+        //    sliced-biclique attacks than the Type-2 cyclic shuffle.
+        //
+        // 3) "Improving the Generalized Feistel" and "New criterion for diffusion
+        //    property" extends the same kind of improved Feistel block shuffle to 16
+        //    branches, which enables a 2048-bit permutation.
+        //
+        // Combine these three ideas and also change Simpira's subround keys from
+        // structured/low-entropy counters to digits of Pi (or other random source).
 
-// RandenTraits contains the basic algorithm traits, such as the size of the
-// state, seed, sponge, etc.
-struct RandenTraits {
-  // Size of the entire sponge / state for the randen PRNG.
-  static constexpr size_t kStateBytes = 256;  // 2048-bit
+        // RandenTraits contains the basic algorithm traits, such as the size of the
+        // state, seed, sponge, etc.
+        struct RandenTraits
+        {
+            // Size of the entire sponge / state for the randen PRNG.
+            static constexpr size_t kStateBytes = 256;  // 2048-bit
 
-  // Size of the 'inner' (inaccessible) part of the sponge. Larger values would
-  // require more frequent calls to RandenGenerate.
-  static constexpr size_t kCapacityBytes = 16;  // 128-bit
+            // Size of the 'inner' (inaccessible) part of the sponge. Larger values would
+            // require more frequent calls to RandenGenerate.
+            static constexpr size_t kCapacityBytes = 16;  // 128-bit
 
-  // Size of the default seed consumed by the sponge.
-  static constexpr size_t kSeedBytes = kStateBytes - kCapacityBytes;
+            // Size of the default seed consumed by the sponge.
+            static constexpr size_t kSeedBytes = kStateBytes - kCapacityBytes;
 
-  // Assuming 128-bit blocks, the number of blocks in the state.
-  // Largest size for which security proofs are known.
-  static constexpr size_t kFeistelBlocks = 16;
+            // Assuming 128-bit blocks, the number of blocks in the state.
+            // Largest size for which security proofs are known.
+            static constexpr size_t kFeistelBlocks = 16;
 
-  // Ensures SPRP security and two full subblock diffusions.
-  // Must be > 4 * log2(kFeistelBlocks).
-  static constexpr size_t kFeistelRounds = 16 + 1;
+            // Ensures SPRP security and two full subblock diffusions.
+            // Must be > 4 * log2(kFeistelBlocks).
+            static constexpr size_t kFeistelRounds = 16 + 1;
 
-  // Size of the key. A 128-bit key block is used for every-other
-  // feistel block (Type-2 generalized Feistel network) in each round.
-  static constexpr size_t kKeyBytes = 16 * kFeistelRounds * kFeistelBlocks / 2;
-};
+            // Size of the key. A 128-bit key block is used for every-other
+            // feistel block (Type-2 generalized Feistel network) in each round.
+            static constexpr size_t kKeyBytes = 16 * kFeistelRounds * kFeistelBlocks / 2;
+        };
 
-// Randen key arrays. In randen_round_keys.cc
-extern const unsigned char kRandenRoundKeys[RandenTraits::kKeyBytes];
-extern const unsigned char kRandenRoundKeysBE[RandenTraits::kKeyBytes];
+        // Randen key arrays. In randen_round_keys.cc
+        extern const unsigned char kRandenRoundKeys[RandenTraits::kKeyBytes];
+        extern const unsigned char kRandenRoundKeysBE[RandenTraits::kKeyBytes];
 
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_RANDEN_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/salted_seed_seq.h b/CAPI/cpp/grpc/include/absl/random/internal/salted_seed_seq.h
index 0629186..29467d5 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/salted_seed_seq.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/salted_seed_seq.h
@@ -30,136 +30,163 @@
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// This class conforms to the C++ Standard "Seed Sequence" concept
-// [rand.req.seedseq].
-//
-// A `SaltedSeedSeq` is meant to wrap an existing seed sequence and modify
-// generated sequence by mixing with extra entropy. This entropy may be
-// build-dependent or process-dependent. The implementation may change to be
-// have either or both kinds of entropy. If salt is not available sequence is
-// not modified.
-template <typename SSeq>
-class SaltedSeedSeq {
- public:
-  using inner_sequence_type = SSeq;
-  using result_type = typename SSeq::result_type;
-
-  SaltedSeedSeq() : seq_(absl::make_unique<SSeq>()) {}
-
-  template <typename Iterator>
-  SaltedSeedSeq(Iterator begin, Iterator end)
-      : seq_(absl::make_unique<SSeq>(begin, end)) {}
-
-  template <typename T>
-  SaltedSeedSeq(std::initializer_list<T> il)
-      : SaltedSeedSeq(il.begin(), il.end()) {}
-
-  SaltedSeedSeq(const SaltedSeedSeq&) = delete;
-  SaltedSeedSeq& operator=(const SaltedSeedSeq&) = delete;
-
-  SaltedSeedSeq(SaltedSeedSeq&&) = default;
-  SaltedSeedSeq& operator=(SaltedSeedSeq&&) = default;
-
-  template <typename RandomAccessIterator>
-  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
-    using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
-
-    // The common case is that generate is called with ContiguousIterators
-    // to uint arrays. Such contiguous memory regions may be optimized,
-    // which we detect here.
-    using TagType = absl::conditional_t<
-        (std::is_same<U, uint32_t>::value &&
-         (std::is_pointer<RandomAccessIterator>::value ||
-          std::is_same<RandomAccessIterator,
-                       typename std::vector<U>::iterator>::value)),
-        ContiguousAndUint32Tag, DefaultTag>;
-    if (begin != end) {
-      generate_impl(TagType{}, begin, end, std::distance(begin, end));
-    }
-  }
-
-  template <typename OutIterator>
-  void param(OutIterator out) const {
-    seq_->param(out);
-  }
-
-  size_t size() const { return seq_->size(); }
-
- private:
-  struct ContiguousAndUint32Tag {};
-  struct DefaultTag {};
-
-  // Generate which requires the iterators are contiguous pointers to uint32_t.
-  // Fills the initial seed buffer the underlying SSeq::generate() call,
-  // then mixes in the salt material.
-  template <typename Contiguous>
-  void generate_impl(ContiguousAndUint32Tag, Contiguous begin, Contiguous end,
-                     size_t n) {
-    seq_->generate(begin, end);
-    const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
-    auto span = absl::Span<uint32_t>(&*begin, n);
-    MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), span);
-  }
-
-  // The uncommon case for generate is that it is called with iterators over
-  // some other buffer type which is assignable from a 32-bit value. In this
-  // case we allocate a temporary 32-bit buffer and then copy-assign back
-  // to the initial inputs.
-  template <typename RandomAccessIterator>
-  void generate_impl(DefaultTag, RandomAccessIterator begin,
-                     RandomAccessIterator, size_t n) {
-    // Allocates a seed buffer of `n` elements, generates the seed, then
-    // copies the result into the `out` iterator.
-    absl::InlinedVector<uint32_t, 8> data(n, 0);
-    generate_impl(ContiguousAndUint32Tag{}, data.begin(), data.end(), n);
-    std::copy(data.begin(), data.end(), begin);
-  }
-
-  // Because [rand.req.seedseq] is not required to be copy-constructible,
-  // copy-assignable nor movable, we wrap it with unique pointer to be able
-  // to move SaltedSeedSeq.
-  std::unique_ptr<SSeq> seq_;
-};
-
-// is_salted_seed_seq indicates whether the type is a SaltedSeedSeq.
-template <typename T, typename = void>
-struct is_salted_seed_seq : public std::false_type {};
-
-template <typename T>
-struct is_salted_seed_seq<
-    T, typename std::enable_if<std::is_same<
-           T, SaltedSeedSeq<typename T::inner_sequence_type>>::value>::type>
-    : public std::true_type {};
-
-// MakeSaltedSeedSeq returns a salted variant of the seed sequence.
-// When provided with an existing SaltedSeedSeq, returns the input parameter,
-// otherwise constructs a new SaltedSeedSeq which embodies the original
-// non-salted seed parameters.
-template <
-    typename SSeq,  //
-    typename EnableIf = absl::enable_if_t<is_salted_seed_seq<SSeq>::value>>
-SSeq MakeSaltedSeedSeq(SSeq&& seq) {
-  return SSeq(std::forward<SSeq>(seq));
-}
-
-template <
-    typename SSeq,  //
-    typename EnableIf = absl::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
-SaltedSeedSeq<typename std::decay<SSeq>::type> MakeSaltedSeedSeq(SSeq&& seq) {
-  using sseq_type = typename std::decay<SSeq>::type;
-  using result_type = typename sseq_type::result_type;
-
-  absl::InlinedVector<result_type, 8> data;
-  seq.param(std::back_inserter(data));
-  return SaltedSeedSeq<sseq_type>(data.begin(), data.end());
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // This class conforms to the C++ Standard "Seed Sequence" concept
+        // [rand.req.seedseq].
+        //
+        // A `SaltedSeedSeq` is meant to wrap an existing seed sequence and modify
+        // generated sequence by mixing with extra entropy. This entropy may be
+        // build-dependent or process-dependent. The implementation may change to be
+        // have either or both kinds of entropy. If salt is not available sequence is
+        // not modified.
+        template<typename SSeq>
+        class SaltedSeedSeq
+        {
+        public:
+            using inner_sequence_type = SSeq;
+            using result_type = typename SSeq::result_type;
+
+            SaltedSeedSeq() :
+                seq_(absl::make_unique<SSeq>())
+            {
+            }
+
+            template<typename Iterator>
+            SaltedSeedSeq(Iterator begin, Iterator end) :
+                seq_(absl::make_unique<SSeq>(begin, end))
+            {
+            }
+
+            template<typename T>
+            SaltedSeedSeq(std::initializer_list<T> il) :
+                SaltedSeedSeq(il.begin(), il.end())
+            {
+            }
+
+            SaltedSeedSeq(const SaltedSeedSeq&) = delete;
+            SaltedSeedSeq& operator=(const SaltedSeedSeq&) = delete;
+
+            SaltedSeedSeq(SaltedSeedSeq&&) = default;
+            SaltedSeedSeq& operator=(SaltedSeedSeq&&) = default;
+
+            template<typename RandomAccessIterator>
+            void generate(RandomAccessIterator begin, RandomAccessIterator end)
+            {
+                using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
+
+                // The common case is that generate is called with ContiguousIterators
+                // to uint arrays. Such contiguous memory regions may be optimized,
+                // which we detect here.
+                using TagType = absl::conditional_t<
+                    (std::is_same<U, uint32_t>::value &&
+                     (std::is_pointer<RandomAccessIterator>::value ||
+                      std::is_same<RandomAccessIterator, typename std::vector<U>::iterator>::value)),
+                    ContiguousAndUint32Tag,
+                    DefaultTag>;
+                if (begin != end)
+                {
+                    generate_impl(TagType{}, begin, end, std::distance(begin, end));
+                }
+            }
+
+            template<typename OutIterator>
+            void param(OutIterator out) const
+            {
+                seq_->param(out);
+            }
+
+            size_t size() const
+            {
+                return seq_->size();
+            }
+
+        private:
+            struct ContiguousAndUint32Tag
+            {
+            };
+            struct DefaultTag
+            {
+            };
+
+            // Generate which requires the iterators are contiguous pointers to uint32_t.
+            // Fills the initial seed buffer the underlying SSeq::generate() call,
+            // then mixes in the salt material.
+            template<typename Contiguous>
+            void generate_impl(ContiguousAndUint32Tag, Contiguous begin, Contiguous end, size_t n)
+            {
+                seq_->generate(begin, end);
+                const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
+                auto span = absl::Span<uint32_t>(&*begin, n);
+                MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), span);
+            }
+
+            // The uncommon case for generate is that it is called with iterators over
+            // some other buffer type which is assignable from a 32-bit value. In this
+            // case we allocate a temporary 32-bit buffer and then copy-assign back
+            // to the initial inputs.
+            template<typename RandomAccessIterator>
+            void generate_impl(DefaultTag, RandomAccessIterator begin, RandomAccessIterator, size_t n)
+            {
+                // Allocates a seed buffer of `n` elements, generates the seed, then
+                // copies the result into the `out` iterator.
+                absl::InlinedVector<uint32_t, 8> data(n, 0);
+                generate_impl(ContiguousAndUint32Tag{}, data.begin(), data.end(), n);
+                std::copy(data.begin(), data.end(), begin);
+            }
+
+            // Because [rand.req.seedseq] is not required to be copy-constructible,
+            // copy-assignable nor movable, we wrap it with unique pointer to be able
+            // to move SaltedSeedSeq.
+            std::unique_ptr<SSeq> seq_;
+        };
+
+        // is_salted_seed_seq indicates whether the type is a SaltedSeedSeq.
+        template<typename T, typename = void>
+        struct is_salted_seed_seq : public std::false_type
+        {
+        };
+
+        template<typename T>
+        struct is_salted_seed_seq<
+            T,
+            typename std::enable_if<std::is_same<
+                T,
+                SaltedSeedSeq<typename T::inner_sequence_type>>::value>::type> : public std::true_type
+        {
+        };
+
+        // MakeSaltedSeedSeq returns a salted variant of the seed sequence.
+        // When provided with an existing SaltedSeedSeq, returns the input parameter,
+        // otherwise constructs a new SaltedSeedSeq which embodies the original
+        // non-salted seed parameters.
+        template<
+            typename SSeq,  //
+            typename EnableIf = absl::enable_if_t<is_salted_seed_seq<SSeq>::value>>
+        SSeq MakeSaltedSeedSeq(SSeq&& seq)
+        {
+            return SSeq(std::forward<SSeq>(seq));
+        }
+
+        template<
+            typename SSeq,  //
+            typename EnableIf = absl::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
+        SaltedSeedSeq<typename std::decay<SSeq>::type> MakeSaltedSeedSeq(SSeq&& seq)
+        {
+            using sseq_type = typename std::decay<SSeq>::type;
+            using result_type = typename sseq_type::result_type;
+
+            absl::InlinedVector<result_type, 8> data;
+            seq.param(std::back_inserter(data));
+            return SaltedSeedSeq<sseq_type>(data.begin(), data.end());
+        }
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/seed_material.h b/CAPI/cpp/grpc/include/absl/random/internal/seed_material.h
index 4be10e9..a1a3996 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/seed_material.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/seed_material.h
@@ -26,79 +26,84 @@
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// Returns the number of 32-bit blocks needed to contain the given number of
-// bits.
-constexpr size_t SeedBitsToBlocks(size_t seed_size) {
-  return (seed_size + 31) / 32;
-}
-
-// Amount of entropy (measured in bits) used to instantiate a Seed Sequence,
-// with which to create a URBG.
-constexpr size_t kEntropyBitsNeeded = 256;
-
-// Amount of entropy (measured in 32-bit blocks) used to instantiate a Seed
-// Sequence, with which to create a URBG.
-constexpr size_t kEntropyBlocksNeeded =
-    random_internal::SeedBitsToBlocks(kEntropyBitsNeeded);
-
-static_assert(kEntropyBlocksNeeded > 0,
-              "Entropy used to seed URBGs must be nonzero.");
-
-// Attempts to fill a span of uint32_t-values using an OS-provided source of
-// true entropy (eg. /dev/urandom) into an array of uint32_t blocks of data. The
-// resulting array may be used to initialize an instance of a class conforming
-// to the C++ Standard "Seed Sequence" concept [rand.req.seedseq].
-//
-// If values.data() == nullptr, the behavior is undefined.
-ABSL_MUST_USE_RESULT
-bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values);
-
-// Attempts to fill a span of uint32_t-values using variates generated by an
-// existing instance of a class conforming to the C++ Standard "Uniform Random
-// Bit Generator" concept [rand.req.urng]. The resulting data may be used to
-// initialize an instance of a class conforming to the C++ Standard
-// "Seed Sequence" concept [rand.req.seedseq].
-//
-// If urbg == nullptr or values.data() == nullptr, the behavior is undefined.
-template <typename URBG>
-ABSL_MUST_USE_RESULT bool ReadSeedMaterialFromURBG(
-    URBG* urbg, absl::Span<uint32_t> values) {
-  random_internal::FastUniformBits<uint32_t> distr;
-
-  assert(urbg != nullptr && values.data() != nullptr);
-  if (urbg == nullptr || values.data() == nullptr) {
-    return false;
-  }
-
-  for (uint32_t& seed_value : values) {
-    seed_value = distr(*urbg);
-  }
-  return true;
-}
-
-// Mixes given sequence of values with into given sequence of seed material.
-// Time complexity of this function is O(sequence.size() *
-// seed_material.size()).
-//
-// Algorithm is based on code available at
-// https://gist.github.com/imneme/540829265469e673d045
-// by Melissa O'Neill.
-void MixIntoSeedMaterial(absl::Span<const uint32_t> sequence,
-                         absl::Span<uint32_t> seed_material);
-
-// Returns salt value.
-//
-// Salt is obtained only once and stored in static variable.
-//
-// May return empty value if optaining the salt was not possible.
-absl::optional<uint32_t> GetSaltMaterial();
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // Returns the number of 32-bit blocks needed to contain the given number of
+        // bits.
+        constexpr size_t SeedBitsToBlocks(size_t seed_size)
+        {
+            return (seed_size + 31) / 32;
+        }
+
+        // Amount of entropy (measured in bits) used to instantiate a Seed Sequence,
+        // with which to create a URBG.
+        constexpr size_t kEntropyBitsNeeded = 256;
+
+        // Amount of entropy (measured in 32-bit blocks) used to instantiate a Seed
+        // Sequence, with which to create a URBG.
+        constexpr size_t kEntropyBlocksNeeded =
+            random_internal::SeedBitsToBlocks(kEntropyBitsNeeded);
+
+        static_assert(kEntropyBlocksNeeded > 0, "Entropy used to seed URBGs must be nonzero.");
+
+        // Attempts to fill a span of uint32_t-values using an OS-provided source of
+        // true entropy (eg. /dev/urandom) into an array of uint32_t blocks of data. The
+        // resulting array may be used to initialize an instance of a class conforming
+        // to the C++ Standard "Seed Sequence" concept [rand.req.seedseq].
+        //
+        // If values.data() == nullptr, the behavior is undefined.
+        ABSL_MUST_USE_RESULT
+        bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values);
+
+        // Attempts to fill a span of uint32_t-values using variates generated by an
+        // existing instance of a class conforming to the C++ Standard "Uniform Random
+        // Bit Generator" concept [rand.req.urng]. The resulting data may be used to
+        // initialize an instance of a class conforming to the C++ Standard
+        // "Seed Sequence" concept [rand.req.seedseq].
+        //
+        // If urbg == nullptr or values.data() == nullptr, the behavior is undefined.
+        template<typename URBG>
+        ABSL_MUST_USE_RESULT bool ReadSeedMaterialFromURBG(
+            URBG* urbg, absl::Span<uint32_t> values
+        )
+        {
+            random_internal::FastUniformBits<uint32_t> distr;
+
+            assert(urbg != nullptr && values.data() != nullptr);
+            if (urbg == nullptr || values.data() == nullptr)
+            {
+                return false;
+            }
+
+            for (uint32_t& seed_value : values)
+            {
+                seed_value = distr(*urbg);
+            }
+            return true;
+        }
+
+        // Mixes given sequence of values with into given sequence of seed material.
+        // Time complexity of this function is O(sequence.size() *
+        // seed_material.size()).
+        //
+        // Algorithm is based on code available at
+        // https://gist.github.com/imneme/540829265469e673d045
+        // by Melissa O'Neill.
+        void MixIntoSeedMaterial(absl::Span<const uint32_t> sequence, absl::Span<uint32_t> seed_material);
+
+        // Returns salt value.
+        //
+        // Salt is obtained only once and stored in static variable.
+        //
+        // May return empty value if optaining the salt was not possible.
+        absl::optional<uint32_t> GetSaltMaterial();
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_SEED_MATERIAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/sequence_urbg.h b/CAPI/cpp/grpc/include/absl/random/internal/sequence_urbg.h
index bc96a12..6e8ffea 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/sequence_urbg.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/sequence_urbg.h
@@ -23,38 +23,56 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// `sequence_urbg` is a simple random number generator which meets the
-// requirements of [rand.req.urbg], and is solely for testing absl
-// distributions.
-class sequence_urbg {
- public:
-  using result_type = uint64_t;
-
-  static constexpr result_type(min)() {
-    return (std::numeric_limits<result_type>::min)();
-  }
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
-
-  sequence_urbg(std::initializer_list<result_type> data) : i_(0), data_(data) {}
-  void reset() { i_ = 0; }
-
-  result_type operator()() { return data_[i_++ % data_.size()]; }
-
-  size_t invocations() const { return i_; }
-
- private:
-  size_t i_;
-  std::vector<result_type> data_;
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // `sequence_urbg` is a simple random number generator which meets the
+        // requirements of [rand.req.urbg], and is solely for testing absl
+        // distributions.
+        class sequence_urbg
+        {
+        public:
+            using result_type = uint64_t;
+
+            static constexpr result_type(min)()
+            {
+                return (std::numeric_limits<result_type>::min)();
+            }
+            static constexpr result_type(max)()
+            {
+                return (std::numeric_limits<result_type>::max)();
+            }
+
+            sequence_urbg(std::initializer_list<result_type> data) :
+                i_(0),
+                data_(data)
+            {
+            }
+            void reset()
+            {
+                i_ = 0;
+            }
+
+            result_type operator()()
+            {
+                return data_[i_++ % data_.size()];
+            }
+
+            size_t invocations() const
+            {
+                return i_;
+            }
+
+        private:
+            size_t i_;
+            std::vector<result_type> data_;
+        };
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_SEQUENCE_URBG_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/traits.h b/CAPI/cpp/grpc/include/absl/random/internal/traits.h
index f874a0f..cdcf473 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/traits.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/traits.h
@@ -23,127 +23,159 @@
 #include "absl/numeric/bits.h"
 #include "absl/numeric/int128.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// random_internal::is_widening_convertible<A, B>
-//
-// Returns whether a type A is widening-convertible to a type B.
-//
-// A is widening-convertible to B means:
-//   A a = <any number>;
-//   B b = a;
-//   A c = b;
-//   EXPECT_EQ(a, c);
-template <typename A, typename B>
-class is_widening_convertible {
-  // As long as there are enough bits in the exact part of a number:
-  // - unsigned can fit in float, signed, unsigned
-  // - signed can fit in float, signed
-  // - float can fit in float
-  // So we define rank to be:
-  // - rank(float) -> 2
-  // - rank(signed) -> 1
-  // - rank(unsigned) -> 0
-  template <class T>
-  static constexpr int rank() {
-    return !std::numeric_limits<T>::is_integer +
-           std::numeric_limits<T>::is_signed;
-  }
-
- public:
-  // If an arithmetic-type B can represent at least as many digits as a type A,
-  // and B belongs to a rank no lower than A, then A can be safely represented
-  // by B through a widening-conversion.
-  static constexpr bool value =
-      std::numeric_limits<A>::digits <= std::numeric_limits<B>::digits &&
-      rank<A>() <= rank<B>();
-};
-
-template <typename T>
-struct IsIntegral : std::is_integral<T> {};
-template <>
-struct IsIntegral<absl::int128> : std::true_type {};
-template <>
-struct IsIntegral<absl::uint128> : std::true_type {};
-
-template <typename T>
-struct MakeUnsigned : std::make_unsigned<T> {};
-template <>
-struct MakeUnsigned<absl::int128> {
-  using type = absl::uint128;
-};
-template <>
-struct MakeUnsigned<absl::uint128> {
-  using type = absl::uint128;
-};
-
-template <typename T>
-struct IsUnsigned : std::is_unsigned<T> {};
-template <>
-struct IsUnsigned<absl::int128> : std::false_type {};
-template <>
-struct IsUnsigned<absl::uint128> : std::true_type {};
-
-// unsigned_bits<N>::type returns the unsigned int type with the indicated
-// number of bits.
-template <size_t N>
-struct unsigned_bits;
-
-template <>
-struct unsigned_bits<8> {
-  using type = uint8_t;
-};
-template <>
-struct unsigned_bits<16> {
-  using type = uint16_t;
-};
-template <>
-struct unsigned_bits<32> {
-  using type = uint32_t;
-};
-template <>
-struct unsigned_bits<64> {
-  using type = uint64_t;
-};
-
-template <>
-struct unsigned_bits<128> {
-  using type = absl::uint128;
-};
-
-// 256-bit wrapper for wide multiplications.
-struct U256 {
-  uint128 hi;
-  uint128 lo;
-};
-template <>
-struct unsigned_bits<256> {
-  using type = U256;
-};
-
-template <typename IntType>
-struct make_unsigned_bits {
-  using type = typename unsigned_bits<
-      std::numeric_limits<typename MakeUnsigned<IntType>::type>::digits>::type;
-};
-
-template <typename T>
-int BitWidth(T v) {
-  // Workaround for bit_width not supporting int128.
-  // Don't hardcode `64` to make sure this code does not trigger compiler
-  // warnings in smaller types.
-  constexpr int half_bits = sizeof(T) * 8 / 2;
-  if (sizeof(T) == 16 && (v >> half_bits) != 0) {
-    return bit_width(static_cast<uint64_t>(v >> half_bits)) + half_bits;
-  } else {
-    return bit_width(static_cast<uint64_t>(v));
-  }
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // random_internal::is_widening_convertible<A, B>
+        //
+        // Returns whether a type A is widening-convertible to a type B.
+        //
+        // A is widening-convertible to B means:
+        //   A a = <any number>;
+        //   B b = a;
+        //   A c = b;
+        //   EXPECT_EQ(a, c);
+        template<typename A, typename B>
+        class is_widening_convertible
+        {
+            // As long as there are enough bits in the exact part of a number:
+            // - unsigned can fit in float, signed, unsigned
+            // - signed can fit in float, signed
+            // - float can fit in float
+            // So we define rank to be:
+            // - rank(float) -> 2
+            // - rank(signed) -> 1
+            // - rank(unsigned) -> 0
+            template<class T>
+            static constexpr int rank()
+            {
+                return !std::numeric_limits<T>::is_integer +
+                       std::numeric_limits<T>::is_signed;
+            }
+
+        public:
+            // If an arithmetic-type B can represent at least as many digits as a type A,
+            // and B belongs to a rank no lower than A, then A can be safely represented
+            // by B through a widening-conversion.
+            static constexpr bool value =
+                std::numeric_limits<A>::digits <= std::numeric_limits<B>::digits &&
+                rank<A>() <= rank<B>();
+        };
+
+        template<typename T>
+        struct IsIntegral : std::is_integral<T>
+        {
+        };
+        template<>
+        struct IsIntegral<absl::int128> : std::true_type
+        {
+        };
+        template<>
+        struct IsIntegral<absl::uint128> : std::true_type
+        {
+        };
+
+        template<typename T>
+        struct MakeUnsigned : std::make_unsigned<T>
+        {
+        };
+        template<>
+        struct MakeUnsigned<absl::int128>
+        {
+            using type = absl::uint128;
+        };
+        template<>
+        struct MakeUnsigned<absl::uint128>
+        {
+            using type = absl::uint128;
+        };
+
+        template<typename T>
+        struct IsUnsigned : std::is_unsigned<T>
+        {
+        };
+        template<>
+        struct IsUnsigned<absl::int128> : std::false_type
+        {
+        };
+        template<>
+        struct IsUnsigned<absl::uint128> : std::true_type
+        {
+        };
+
+        // unsigned_bits<N>::type returns the unsigned int type with the indicated
+        // number of bits.
+        template<size_t N>
+        struct unsigned_bits;
+
+        template<>
+        struct unsigned_bits<8>
+        {
+            using type = uint8_t;
+        };
+        template<>
+        struct unsigned_bits<16>
+        {
+            using type = uint16_t;
+        };
+        template<>
+        struct unsigned_bits<32>
+        {
+            using type = uint32_t;
+        };
+        template<>
+        struct unsigned_bits<64>
+        {
+            using type = uint64_t;
+        };
+
+        template<>
+        struct unsigned_bits<128>
+        {
+            using type = absl::uint128;
+        };
+
+        // 256-bit wrapper for wide multiplications.
+        struct U256
+        {
+            uint128 hi;
+            uint128 lo;
+        };
+        template<>
+        struct unsigned_bits<256>
+        {
+            using type = U256;
+        };
+
+        template<typename IntType>
+        struct make_unsigned_bits
+        {
+            using type = typename unsigned_bits<
+                std::numeric_limits<typename MakeUnsigned<IntType>::type>::digits>::type;
+        };
+
+        template<typename T>
+        int BitWidth(T v)
+        {
+            // Workaround for bit_width not supporting int128.
+            // Don't hardcode `64` to make sure this code does not trigger compiler
+            // warnings in smaller types.
+            constexpr int half_bits = sizeof(T) * 8 / 2;
+            if (sizeof(T) == 16 && (v >> half_bits) != 0)
+            {
+                return bit_width(static_cast<uint64_t>(v >> half_bits)) + half_bits;
+            }
+            else
+            {
+                return bit_width(static_cast<uint64_t>(v));
+            }
+        }
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/uniform_helper.h b/CAPI/cpp/grpc/include/absl/random/internal/uniform_helper.h
index e68b82e..0626b33 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/uniform_helper.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/uniform_helper.h
@@ -23,222 +23,238 @@
 #include "absl/meta/type_traits.h"
 #include "absl/random/internal/traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename IntType>
-class uniform_int_distribution;
-
-template <typename RealType>
-class uniform_real_distribution;
-
-// Interval tag types which specify whether the interval is open or closed
-// on either boundary.
-
-namespace random_internal {
-template <typename T>
-struct TagTypeCompare {};
-
-template <typename T>
-constexpr bool operator==(TagTypeCompare<T>, TagTypeCompare<T>) {
-  // Tags are mono-states. They always compare equal.
-  return true;
-}
-template <typename T>
-constexpr bool operator!=(TagTypeCompare<T>, TagTypeCompare<T>) {
-  return false;
-}
-
-}  // namespace random_internal
-
-struct IntervalClosedClosedTag
-    : public random_internal::TagTypeCompare<IntervalClosedClosedTag> {};
-struct IntervalClosedOpenTag
-    : public random_internal::TagTypeCompare<IntervalClosedOpenTag> {};
-struct IntervalOpenClosedTag
-    : public random_internal::TagTypeCompare<IntervalOpenClosedTag> {};
-struct IntervalOpenOpenTag
-    : public random_internal::TagTypeCompare<IntervalOpenOpenTag> {};
-
-namespace random_internal {
-
-// In the absence of an explicitly provided return-type, the template
-// "uniform_inferred_return_t<A, B>" is used to derive a suitable type, based on
-// the data-types of the endpoint-arguments {A lo, B hi}.
-//
-// Given endpoints {A lo, B hi}, one of {A, B} will be chosen as the
-// return-type, if one type can be implicitly converted into the other, in a
-// lossless way. The template "is_widening_convertible" implements the
-// compile-time logic for deciding if such a conversion is possible.
-//
-// If no such conversion between {A, B} exists, then the overload for
-// absl::Uniform() will be discarded, and the call will be ill-formed.
-// Return-type for absl::Uniform() when the return-type is inferred.
-template <typename A, typename B>
-using uniform_inferred_return_t =
-    absl::enable_if_t<absl::disjunction<is_widening_convertible<A, B>,
-                                        is_widening_convertible<B, A>>::value,
-                      typename std::conditional<
-                          is_widening_convertible<A, B>::value, B, A>::type>;
-
-// The functions
-//    uniform_lower_bound(tag, a, b)
-// and
-//    uniform_upper_bound(tag, a, b)
-// are used as implementation-details for absl::Uniform().
-//
-// Conceptually,
-//    [a, b] == [uniform_lower_bound(IntervalClosedClosed, a, b),
-//               uniform_upper_bound(IntervalClosedClosed, a, b)]
-//    (a, b) == [uniform_lower_bound(IntervalOpenOpen, a, b),
-//               uniform_upper_bound(IntervalOpenOpen, a, b)]
-//    [a, b) == [uniform_lower_bound(IntervalClosedOpen, a, b),
-//               uniform_upper_bound(IntervalClosedOpen, a, b)]
-//    (a, b] == [uniform_lower_bound(IntervalOpenClosed, a, b),
-//               uniform_upper_bound(IntervalOpenClosed, a, b)]
-//
-template <typename IntType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
-        IsIntegral<IntType>,
-        absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
-                          std::is_same<Tag, IntervalOpenOpenTag>>>::value,
-    IntType>
-uniform_lower_bound(Tag, IntType a, IntType) {
-  return a < (std::numeric_limits<IntType>::max)() ? (a + 1) : a;
-}
-
-template <typename FloatType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
-        std::is_floating_point<FloatType>,
-        absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
-                          std::is_same<Tag, IntervalOpenOpenTag>>>::value,
-    FloatType>
-uniform_lower_bound(Tag, FloatType a, FloatType b) {
-  return std::nextafter(a, b);
-}
-
-template <typename NumType, typename Tag>
-typename absl::enable_if_t<
-    absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
-                      std::is_same<Tag, IntervalClosedOpenTag>>::value,
-    NumType>
-uniform_lower_bound(Tag, NumType a, NumType) {
-  return a;
-}
-
-template <typename IntType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
-        IsIntegral<IntType>,
-        absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
-                          std::is_same<Tag, IntervalOpenOpenTag>>>::value,
-    IntType>
-uniform_upper_bound(Tag, IntType, IntType b) {
-  return b > (std::numeric_limits<IntType>::min)() ? (b - 1) : b;
-}
-
-template <typename FloatType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
-        std::is_floating_point<FloatType>,
-        absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
-                          std::is_same<Tag, IntervalOpenOpenTag>>>::value,
-    FloatType>
-uniform_upper_bound(Tag, FloatType, FloatType b) {
-  return b;
-}
-
-template <typename IntType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
-        IsIntegral<IntType>,
-        absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
-                          std::is_same<Tag, IntervalOpenClosedTag>>>::value,
-    IntType>
-uniform_upper_bound(Tag, IntType, IntType b) {
-  return b;
-}
-
-template <typename FloatType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
-        std::is_floating_point<FloatType>,
-        absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
-                          std::is_same<Tag, IntervalOpenClosedTag>>>::value,
-    FloatType>
-uniform_upper_bound(Tag, FloatType, FloatType b) {
-  return std::nextafter(b, (std::numeric_limits<FloatType>::max)());
-}
-
-// Returns whether the bounds are valid for the underlying distribution.
-// Inputs must have already been resolved via uniform_*_bound calls.
-//
-// The c++ standard constraints in [rand.dist.uni.int] are listed as:
-//    requires: lo <= hi.
-//
-// In the uniform_int_distrubtion, {lo, hi} are closed, closed. Thus:
-// [0, 0] is legal.
-// [0, 0) is not legal, but [0, 1) is, which translates to [0, 0].
-// (0, 1) is not legal, but (0, 2) is, which translates to [1, 1].
-// (0, 0] is not legal, but (0, 1] is, which translates to [1, 1].
-//
-// The c++ standard constraints in [rand.dist.uni.real] are listed as:
-//    requires: lo <= hi.
-//    requires: (hi - lo) <= numeric_limits<T>::max()
-//
-// In the uniform_real_distribution, {lo, hi} are closed, open, Thus:
-// [0, 0] is legal, which is [0, 0+epsilon).
-// [0, 0) is legal.
-// (0, 0) is not legal, but (0-epsilon, 0+epsilon) is.
-// (0, 0] is not legal, but (0, 0+epsilon] is.
-//
-template <typename FloatType>
-absl::enable_if_t<std::is_floating_point<FloatType>::value, bool>
-is_uniform_range_valid(FloatType a, FloatType b) {
-  return a <= b && std::isfinite(b - a);
-}
-
-template <typename IntType>
-absl::enable_if_t<IsIntegral<IntType>::value, bool>
-is_uniform_range_valid(IntType a, IntType b) {
-  return a <= b;
-}
-
-// UniformDistribution selects either absl::uniform_int_distribution
-// or absl::uniform_real_distribution depending on the NumType parameter.
-template <typename NumType>
-using UniformDistribution =
-    typename std::conditional<IsIntegral<NumType>::value,
-                              absl::uniform_int_distribution<NumType>,
-                              absl::uniform_real_distribution<NumType>>::type;
-
-// UniformDistributionWrapper is used as the underlying distribution type
-// by the absl::Uniform template function. It selects the proper Abseil
-// uniform distribution and provides constructor overloads that match the
-// expected parameter order as well as adjusting distribtuion bounds based
-// on the tag.
-template <typename NumType>
-struct UniformDistributionWrapper : public UniformDistribution<NumType> {
-  template <typename TagType>
-  explicit UniformDistributionWrapper(TagType, NumType lo, NumType hi)
-      : UniformDistribution<NumType>(
-            uniform_lower_bound<NumType>(TagType{}, lo, hi),
-            uniform_upper_bound<NumType>(TagType{}, lo, hi)) {}
-
-  explicit UniformDistributionWrapper(NumType lo, NumType hi)
-      : UniformDistribution<NumType>(
-            uniform_lower_bound<NumType>(IntervalClosedOpenTag(), lo, hi),
-            uniform_upper_bound<NumType>(IntervalClosedOpenTag(), lo, hi)) {}
-
-  explicit UniformDistributionWrapper()
-      : UniformDistribution<NumType>(std::numeric_limits<NumType>::lowest(),
-                                     (std::numeric_limits<NumType>::max)()) {}
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    template<typename IntType>
+    class uniform_int_distribution;
+
+    template<typename RealType>
+    class uniform_real_distribution;
+
+    // Interval tag types which specify whether the interval is open or closed
+    // on either boundary.
+
+    namespace random_internal
+    {
+        template<typename T>
+        struct TagTypeCompare
+        {
+        };
+
+        template<typename T>
+        constexpr bool operator==(TagTypeCompare<T>, TagTypeCompare<T>)
+        {
+            // Tags are mono-states. They always compare equal.
+            return true;
+        }
+        template<typename T>
+        constexpr bool operator!=(TagTypeCompare<T>, TagTypeCompare<T>)
+        {
+            return false;
+        }
+
+    }  // namespace random_internal
+
+    struct IntervalClosedClosedTag : public random_internal::TagTypeCompare<IntervalClosedClosedTag>
+    {
+    };
+    struct IntervalClosedOpenTag : public random_internal::TagTypeCompare<IntervalClosedOpenTag>
+    {
+    };
+    struct IntervalOpenClosedTag : public random_internal::TagTypeCompare<IntervalOpenClosedTag>
+    {
+    };
+    struct IntervalOpenOpenTag : public random_internal::TagTypeCompare<IntervalOpenOpenTag>
+    {
+    };
+
+    namespace random_internal
+    {
+
+        // In the absence of an explicitly provided return-type, the template
+        // "uniform_inferred_return_t<A, B>" is used to derive a suitable type, based on
+        // the data-types of the endpoint-arguments {A lo, B hi}.
+        //
+        // Given endpoints {A lo, B hi}, one of {A, B} will be chosen as the
+        // return-type, if one type can be implicitly converted into the other, in a
+        // lossless way. The template "is_widening_convertible" implements the
+        // compile-time logic for deciding if such a conversion is possible.
+        //
+        // If no such conversion between {A, B} exists, then the overload for
+        // absl::Uniform() will be discarded, and the call will be ill-formed.
+        // Return-type for absl::Uniform() when the return-type is inferred.
+        template<typename A, typename B>
+        using uniform_inferred_return_t =
+            absl::enable_if_t<absl::disjunction<is_widening_convertible<A, B>, is_widening_convertible<B, A>>::value, typename std::conditional<is_widening_convertible<A, B>::value, B, A>::type>;
+
+        // The functions
+        //    uniform_lower_bound(tag, a, b)
+        // and
+        //    uniform_upper_bound(tag, a, b)
+        // are used as implementation-details for absl::Uniform().
+        //
+        // Conceptually,
+        //    [a, b] == [uniform_lower_bound(IntervalClosedClosed, a, b),
+        //               uniform_upper_bound(IntervalClosedClosed, a, b)]
+        //    (a, b) == [uniform_lower_bound(IntervalOpenOpen, a, b),
+        //               uniform_upper_bound(IntervalOpenOpen, a, b)]
+        //    [a, b) == [uniform_lower_bound(IntervalClosedOpen, a, b),
+        //               uniform_upper_bound(IntervalClosedOpen, a, b)]
+        //    (a, b] == [uniform_lower_bound(IntervalOpenClosed, a, b),
+        //               uniform_upper_bound(IntervalOpenClosed, a, b)]
+        //
+        template<typename IntType, typename Tag>
+        typename absl::enable_if_t<
+            absl::conjunction<
+                IsIntegral<IntType>,
+                absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>, std::is_same<Tag, IntervalOpenOpenTag>>>::value,
+            IntType>
+            uniform_lower_bound(Tag, IntType a, IntType)
+        {
+            return a < (std::numeric_limits<IntType>::max)() ? (a + 1) : a;
+        }
+
+        template<typename FloatType, typename Tag>
+        typename absl::enable_if_t<
+            absl::conjunction<
+                std::is_floating_point<FloatType>,
+                absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>, std::is_same<Tag, IntervalOpenOpenTag>>>::value,
+            FloatType>
+            uniform_lower_bound(Tag, FloatType a, FloatType b)
+        {
+            return std::nextafter(a, b);
+        }
+
+        template<typename NumType, typename Tag>
+        typename absl::enable_if_t<
+            absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>, std::is_same<Tag, IntervalClosedOpenTag>>::value,
+            NumType>
+            uniform_lower_bound(Tag, NumType a, NumType)
+        {
+            return a;
+        }
+
+        template<typename IntType, typename Tag>
+        typename absl::enable_if_t<
+            absl::conjunction<
+                IsIntegral<IntType>,
+                absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>, std::is_same<Tag, IntervalOpenOpenTag>>>::value,
+            IntType>
+            uniform_upper_bound(Tag, IntType, IntType b)
+        {
+            return b > (std::numeric_limits<IntType>::min)() ? (b - 1) : b;
+        }
+
+        template<typename FloatType, typename Tag>
+        typename absl::enable_if_t<
+            absl::conjunction<
+                std::is_floating_point<FloatType>,
+                absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>, std::is_same<Tag, IntervalOpenOpenTag>>>::value,
+            FloatType>
+            uniform_upper_bound(Tag, FloatType, FloatType b)
+        {
+            return b;
+        }
+
+        template<typename IntType, typename Tag>
+        typename absl::enable_if_t<
+            absl::conjunction<
+                IsIntegral<IntType>,
+                absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>, std::is_same<Tag, IntervalOpenClosedTag>>>::value,
+            IntType>
+            uniform_upper_bound(Tag, IntType, IntType b)
+        {
+            return b;
+        }
+
+        template<typename FloatType, typename Tag>
+        typename absl::enable_if_t<
+            absl::conjunction<
+                std::is_floating_point<FloatType>,
+                absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>, std::is_same<Tag, IntervalOpenClosedTag>>>::value,
+            FloatType>
+            uniform_upper_bound(Tag, FloatType, FloatType b)
+        {
+            return std::nextafter(b, (std::numeric_limits<FloatType>::max)());
+        }
+
+        // Returns whether the bounds are valid for the underlying distribution.
+        // Inputs must have already been resolved via uniform_*_bound calls.
+        //
+        // The c++ standard constraints in [rand.dist.uni.int] are listed as:
+        //    requires: lo <= hi.
+        //
+        // In the uniform_int_distrubtion, {lo, hi} are closed, closed. Thus:
+        // [0, 0] is legal.
+        // [0, 0) is not legal, but [0, 1) is, which translates to [0, 0].
+        // (0, 1) is not legal, but (0, 2) is, which translates to [1, 1].
+        // (0, 0] is not legal, but (0, 1] is, which translates to [1, 1].
+        //
+        // The c++ standard constraints in [rand.dist.uni.real] are listed as:
+        //    requires: lo <= hi.
+        //    requires: (hi - lo) <= numeric_limits<T>::max()
+        //
+        // In the uniform_real_distribution, {lo, hi} are closed, open, Thus:
+        // [0, 0] is legal, which is [0, 0+epsilon).
+        // [0, 0) is legal.
+        // (0, 0) is not legal, but (0-epsilon, 0+epsilon) is.
+        // (0, 0] is not legal, but (0, 0+epsilon] is.
+        //
+        template<typename FloatType>
+        absl::enable_if_t<std::is_floating_point<FloatType>::value, bool>
+            is_uniform_range_valid(FloatType a, FloatType b)
+        {
+            return a <= b && std::isfinite(b - a);
+        }
+
+        template<typename IntType>
+        absl::enable_if_t<IsIntegral<IntType>::value, bool>
+            is_uniform_range_valid(IntType a, IntType b)
+        {
+            return a <= b;
+        }
+
+        // UniformDistribution selects either absl::uniform_int_distribution
+        // or absl::uniform_real_distribution depending on the NumType parameter.
+        template<typename NumType>
+        using UniformDistribution =
+            typename std::conditional<IsIntegral<NumType>::value, absl::uniform_int_distribution<NumType>, absl::uniform_real_distribution<NumType>>::type;
+
+        // UniformDistributionWrapper is used as the underlying distribution type
+        // by the absl::Uniform template function. It selects the proper Abseil
+        // uniform distribution and provides constructor overloads that match the
+        // expected parameter order as well as adjusting distribtuion bounds based
+        // on the tag.
+        template<typename NumType>
+        struct UniformDistributionWrapper : public UniformDistribution<NumType>
+        {
+            template<typename TagType>
+            explicit UniformDistributionWrapper(TagType, NumType lo, NumType hi) :
+                UniformDistribution<NumType>(
+                    uniform_lower_bound<NumType>(TagType{}, lo, hi),
+                    uniform_upper_bound<NumType>(TagType{}, lo, hi)
+                )
+            {
+            }
+
+            explicit UniformDistributionWrapper(NumType lo, NumType hi) :
+                UniformDistribution<NumType>(
+                    uniform_lower_bound<NumType>(IntervalClosedOpenTag(), lo, hi),
+                    uniform_upper_bound<NumType>(IntervalClosedOpenTag(), lo, hi)
+                )
+            {
+            }
+
+            explicit UniformDistributionWrapper() :
+                UniformDistribution<NumType>(std::numeric_limits<NumType>::lowest(), (std::numeric_limits<NumType>::max)())
+            {
+            }
+        };
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_UNIFORM_HELPER_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/internal/wide_multiply.h b/CAPI/cpp/grpc/include/absl/random/internal/wide_multiply.h
index 891e363..21a09c5 100644
--- a/CAPI/cpp/grpc/include/absl/random/internal/wide_multiply.h
+++ b/CAPI/cpp/grpc/include/absl/random/internal/wide_multiply.h
@@ -30,67 +30,79 @@
 #include "absl/numeric/int128.h"
 #include "absl/random/internal/traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// wide_multiply<T> multiplies two N-bit values to a 2N-bit result.
-template <typename UIntType>
-struct wide_multiply {
-  static constexpr size_t kN = std::numeric_limits<UIntType>::digits;
-  using input_type = UIntType;
-  using result_type = typename random_internal::unsigned_bits<kN * 2>::type;
-
-  static result_type multiply(input_type a, input_type b) {
-    return static_cast<result_type>(a) * b;
-  }
-
-  static input_type hi(result_type r) {
-    return static_cast<input_type>(r >> kN);
-  }
-  static input_type lo(result_type r) { return static_cast<input_type>(r); }
-
-  static_assert(std::is_unsigned<UIntType>::value,
-                "Class-template wide_multiply<> argument must be unsigned.");
-};
-
-// MultiplyU128ToU256 multiplies two 128-bit values to a 256-bit value.
-inline U256 MultiplyU128ToU256(uint128 a, uint128 b) {
-  const uint128 a00 = static_cast<uint64_t>(a);
-  const uint128 a64 = a >> 64;
-  const uint128 b00 = static_cast<uint64_t>(b);
-  const uint128 b64 = b >> 64;
-
-  const uint128 c00 = a00 * b00;
-  const uint128 c64a = a00 * b64;
-  const uint128 c64b = a64 * b00;
-  const uint128 c128 = a64 * b64;
-
-  const uint64_t carry =
-      static_cast<uint64_t>(((c00 >> 64) + static_cast<uint64_t>(c64a) +
-                             static_cast<uint64_t>(c64b)) >>
-                            64);
-
-  return {c128 + (c64a >> 64) + (c64b >> 64) + carry,
-          c00 + (c64a << 64) + (c64b << 64)};
-}
-
-
-template <>
-struct wide_multiply<uint128> {
-  using input_type = uint128;
-  using result_type = U256;
-
-  static result_type multiply(input_type a, input_type b) {
-    return MultiplyU128ToU256(a, b);
-  }
-
-  static input_type hi(result_type r) { return r.hi; }
-  static input_type lo(result_type r) { return r.lo; }
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace random_internal
+    {
+
+        // wide_multiply<T> multiplies two N-bit values to a 2N-bit result.
+        template<typename UIntType>
+        struct wide_multiply
+        {
+            static constexpr size_t kN = std::numeric_limits<UIntType>::digits;
+            using input_type = UIntType;
+            using result_type = typename random_internal::unsigned_bits<kN * 2>::type;
+
+            static result_type multiply(input_type a, input_type b)
+            {
+                return static_cast<result_type>(a) * b;
+            }
+
+            static input_type hi(result_type r)
+            {
+                return static_cast<input_type>(r >> kN);
+            }
+            static input_type lo(result_type r)
+            {
+                return static_cast<input_type>(r);
+            }
+
+            static_assert(std::is_unsigned<UIntType>::value, "Class-template wide_multiply<> argument must be unsigned.");
+        };
+
+        // MultiplyU128ToU256 multiplies two 128-bit values to a 256-bit value.
+        inline U256 MultiplyU128ToU256(uint128 a, uint128 b)
+        {
+            const uint128 a00 = static_cast<uint64_t>(a);
+            const uint128 a64 = a >> 64;
+            const uint128 b00 = static_cast<uint64_t>(b);
+            const uint128 b64 = b >> 64;
+
+            const uint128 c00 = a00 * b00;
+            const uint128 c64a = a00 * b64;
+            const uint128 c64b = a64 * b00;
+            const uint128 c128 = a64 * b64;
+
+            const uint64_t carry =
+                static_cast<uint64_t>(((c00 >> 64) + static_cast<uint64_t>(c64a) + static_cast<uint64_t>(c64b)) >> 64);
+
+            return {c128 + (c64a >> 64) + (c64b >> 64) + carry, c00 + (c64a << 64) + (c64b << 64)};
+        }
+
+        template<>
+        struct wide_multiply<uint128>
+        {
+            using input_type = uint128;
+            using result_type = U256;
+
+            static result_type multiply(input_type a, input_type b)
+            {
+                return MultiplyU128ToU256(a, b);
+            }
+
+            static input_type hi(result_type r)
+            {
+                return r.hi;
+            }
+            static input_type lo(result_type r)
+            {
+                return r.lo;
+            }
+        };
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_INTERNAL_WIDE_MULTIPLY_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/log_uniform_int_distribution.h b/CAPI/cpp/grpc/include/absl/random/log_uniform_int_distribution.h
index 4afff8f..ab11684 100644
--- a/CAPI/cpp/grpc/include/absl/random/log_uniform_int_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/log_uniform_int_distribution.h
@@ -30,227 +30,281 @@
 #include "absl/random/internal/traits.h"
 #include "absl/random/uniform_int_distribution.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// log_uniform_int_distribution:
-//
-// Returns a random variate R in range [min, max] such that
-// floor(log(R-min, base)) is uniformly distributed.
-// We ensure uniformity by discretization using the
-// boundary sets [0, 1, base, base * base, ... min(base*n, max)]
-//
-template <typename IntType = int>
-class log_uniform_int_distribution {
- private:
-  using unsigned_type =
-      typename random_internal::make_unsigned_bits<IntType>::type;
-
- public:
-  using result_type = IntType;
-
-  class param_type {
-   public:
-    using distribution_type = log_uniform_int_distribution;
-
-    explicit param_type(
-        result_type min = 0,
-        result_type max = (std::numeric_limits<result_type>::max)(),
-        result_type base = 2)
-        : min_(min),
-          max_(max),
-          base_(base),
-          range_(static_cast<unsigned_type>(max_) -
-                 static_cast<unsigned_type>(min_)),
-          log_range_(0) {
-      assert(max_ >= min_);
-      assert(base_ > 1);
-
-      if (base_ == 2) {
-        // Determine where the first set bit is on range(), giving a log2(range)
-        // value which can be used to construct bounds.
-        log_range_ = (std::min)(random_internal::BitWidth(range()),
-                                std::numeric_limits<unsigned_type>::digits);
-      } else {
-        // NOTE: Computing the logN(x) introduces error from 2 sources:
-        // 1. Conversion of int to double loses precision for values >=
-        // 2^53, which may cause some log() computations to operate on
-        // different values.
-        // 2. The error introduced by the division will cause the result
-        // to differ from the expected value.
-        //
-        // Thus a result which should equal K may equal K +/- epsilon,
-        // which can eliminate some values depending on where the bounds fall.
-        const double inv_log_base = 1.0 / std::log(static_cast<double>(base_));
-        const double log_range = std::log(static_cast<double>(range()) + 0.5);
-        log_range_ = static_cast<int>(std::ceil(inv_log_base * log_range));
-      }
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // log_uniform_int_distribution:
+    //
+    // Returns a random variate R in range [min, max] such that
+    // floor(log(R-min, base)) is uniformly distributed.
+    // We ensure uniformity by discretization using the
+    // boundary sets [0, 1, base, base * base, ... min(base*n, max)]
+    //
+    template<typename IntType = int>
+    class log_uniform_int_distribution
+    {
+    private:
+        using unsigned_type =
+            typename random_internal::make_unsigned_bits<IntType>::type;
+
+    public:
+        using result_type = IntType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = log_uniform_int_distribution;
+
+            explicit param_type(
+                result_type min = 0,
+                result_type max = (std::numeric_limits<result_type>::max)(),
+                result_type base = 2
+            ) :
+                min_(min),
+                max_(max),
+                base_(base),
+                range_(static_cast<unsigned_type>(max_) - static_cast<unsigned_type>(min_)),
+                log_range_(0)
+            {
+                assert(max_ >= min_);
+                assert(base_ > 1);
+
+                if (base_ == 2)
+                {
+                    // Determine where the first set bit is on range(), giving a log2(range)
+                    // value which can be used to construct bounds.
+                    log_range_ = (std::min)(random_internal::BitWidth(range()), std::numeric_limits<unsigned_type>::digits);
+                }
+                else
+                {
+                    // NOTE: Computing the logN(x) introduces error from 2 sources:
+                    // 1. Conversion of int to double loses precision for values >=
+                    // 2^53, which may cause some log() computations to operate on
+                    // different values.
+                    // 2. The error introduced by the division will cause the result
+                    // to differ from the expected value.
+                    //
+                    // Thus a result which should equal K may equal K +/- epsilon,
+                    // which can eliminate some values depending on where the bounds fall.
+                    const double inv_log_base = 1.0 / std::log(static_cast<double>(base_));
+                    const double log_range = std::log(static_cast<double>(range()) + 0.5);
+                    log_range_ = static_cast<int>(std::ceil(inv_log_base * log_range));
+                }
+            }
+
+            result_type(min)() const
+            {
+                return min_;
+            }
+            result_type(max)() const
+            {
+                return max_;
+            }
+            result_type base() const
+            {
+                return base_;
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.min_ == b.min_ && a.max_ == b.max_ && a.base_ == b.base_;
+            }
+
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            friend class log_uniform_int_distribution;
+
+            int log_range() const
+            {
+                return log_range_;
+            }
+            unsigned_type range() const
+            {
+                return range_;
+            }
+
+            result_type min_;
+            result_type max_;
+            result_type base_;
+            unsigned_type range_;  // max - min
+            int log_range_;        // ceil(logN(range_))
+
+            static_assert(random_internal::IsIntegral<IntType>::value, "Class-template absl::log_uniform_int_distribution<> must be "
+                                                                       "parameterized using an integral type.");
+        };
+
+        log_uniform_int_distribution() :
+            log_uniform_int_distribution(0)
+        {
+        }
+
+        explicit log_uniform_int_distribution(
+            result_type min,
+            result_type max = (std::numeric_limits<result_type>::max)(),
+            result_type base = 2
+        ) :
+            param_(min, max, base)
+        {
+        }
+
+        explicit log_uniform_int_distribution(const param_type& p) :
+            param_(p)
+        {
+        }
+
+        void reset()
+        {
+        }
+
+        // generating functions
+        template<typename URBG>
+        result_type operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            return (*this)(g, param_);
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                               const param_type& p)
+        {
+            return static_cast<result_type>((p.min)() + Generate(g, p));
+        }
+
+        result_type(min)() const
+        {
+            return (param_.min)();
+        }
+        result_type(max)() const
+        {
+            return (param_.max)();
+        }
+        result_type base() const
+        {
+            return param_.base();
+        }
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& p)
+        {
+            param_ = p;
+        }
+
+        friend bool operator==(const log_uniform_int_distribution& a, const log_uniform_int_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const log_uniform_int_distribution& a, const log_uniform_int_distribution& b)
+        {
+            return a.param_ != b.param_;
+        }
+
+    private:
+        // Returns a log-uniform variate in the range [0, p.range()]. The caller
+        // should add min() to shift the result to the correct range.
+        template<typename URNG>
+        unsigned_type Generate(URNG& g,  // NOLINT(runtime/references)
+                               const param_type& p);
+
+        param_type param_;
+    };
+
+    template<typename IntType>
+    template<typename URBG>
+    typename log_uniform_int_distribution<IntType>::unsigned_type
+        log_uniform_int_distribution<IntType>::Generate(
+            URBG& g,  // NOLINT(runtime/references)
+            const param_type& p
+        )
+    {
+        // sample e over [0, log_range]. Map the results of e to this:
+        // 0 => 0
+        // 1 => [1, b-1]
+        // 2 => [b, (b^2)-1]
+        // n => [b^(n-1)..(b^n)-1]
+        const int e = absl::uniform_int_distribution<int>(0, p.log_range())(g);
+        if (e == 0)
+        {
+            return 0;
+        }
+        const int d = e - 1;
+
+        unsigned_type base_e, top_e;
+        if (p.base() == 2)
+        {
+            base_e = static_cast<unsigned_type>(1) << d;
+
+            top_e = (e >= std::numeric_limits<unsigned_type>::digits) ? (std::numeric_limits<unsigned_type>::max)() : (static_cast<unsigned_type>(1) << e) - 1;
+        }
+        else
+        {
+            const double r = std::pow(static_cast<double>(p.base()), d);
+            const double s = (r * static_cast<double>(p.base())) - 1.0;
+
+            base_e =
+                (r > static_cast<double>((std::numeric_limits<unsigned_type>::max)())) ? (std::numeric_limits<unsigned_type>::max)() : static_cast<unsigned_type>(r);
+
+            top_e =
+                (s > static_cast<double>((std::numeric_limits<unsigned_type>::max)())) ? (std::numeric_limits<unsigned_type>::max)() : static_cast<unsigned_type>(s);
+        }
+
+        const unsigned_type lo = (base_e >= p.range()) ? p.range() : base_e;
+        const unsigned_type hi = (top_e >= p.range()) ? p.range() : top_e;
+
+        // choose uniformly over [lo, hi]
+        return absl::uniform_int_distribution<result_type>(
+            static_cast<result_type>(lo), static_cast<result_type>(hi)
+        )(g);
     }
 
-    result_type(min)() const { return min_; }
-    result_type(max)() const { return max_; }
-    result_type base() const { return base_; }
-
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.min_ == b.min_ && a.max_ == b.max_ && a.base_ == b.base_;
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const log_uniform_int_distribution<IntType>& x
+    )
+    {
+        using stream_type =
+            typename random_internal::stream_format_type<IntType>::type;
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os << static_cast<stream_type>((x.min)()) << os.fill()
+           << static_cast<stream_type>((x.max)()) << os.fill()
+           << static_cast<stream_type>(x.base());
+        return os;
     }
 
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        log_uniform_int_distribution<IntType>& x
+    )
+    {  // NOLINT(runtime/references)
+        using param_type = typename log_uniform_int_distribution<IntType>::param_type;
+        using result_type =
+            typename log_uniform_int_distribution<IntType>::result_type;
+        using stream_type =
+            typename random_internal::stream_format_type<IntType>::type;
+
+        stream_type min;
+        stream_type max;
+        stream_type base;
+
+        auto saver = random_internal::make_istream_state_saver(is);
+        is >> min >> max >> base;
+        if (!is.fail())
+        {
+            x.param(param_type(static_cast<result_type>(min), static_cast<result_type>(max), static_cast<result_type>(base)));
+        }
+        return is;
     }
 
-   private:
-    friend class log_uniform_int_distribution;
-
-    int log_range() const { return log_range_; }
-    unsigned_type range() const { return range_; }
-
-    result_type min_;
-    result_type max_;
-    result_type base_;
-    unsigned_type range_;  // max - min
-    int log_range_;        // ceil(logN(range_))
-
-    static_assert(random_internal::IsIntegral<IntType>::value,
-                  "Class-template absl::log_uniform_int_distribution<> must be "
-                  "parameterized using an integral type.");
-  };
-
-  log_uniform_int_distribution() : log_uniform_int_distribution(0) {}
-
-  explicit log_uniform_int_distribution(
-      result_type min,
-      result_type max = (std::numeric_limits<result_type>::max)(),
-      result_type base = 2)
-      : param_(min, max, base) {}
-
-  explicit log_uniform_int_distribution(const param_type& p) : param_(p) {}
-
-  void reset() {}
-
-  // generating functions
-  template <typename URBG>
-  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
-    return (*this)(g, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g,  // NOLINT(runtime/references)
-                         const param_type& p) {
-    return static_cast<result_type>((p.min)() + Generate(g, p));
-  }
-
-  result_type(min)() const { return (param_.min)(); }
-  result_type(max)() const { return (param_.max)(); }
-  result_type base() const { return param_.base(); }
-
-  param_type param() const { return param_; }
-  void param(const param_type& p) { param_ = p; }
-
-  friend bool operator==(const log_uniform_int_distribution& a,
-                         const log_uniform_int_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const log_uniform_int_distribution& a,
-                         const log_uniform_int_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  // Returns a log-uniform variate in the range [0, p.range()]. The caller
-  // should add min() to shift the result to the correct range.
-  template <typename URNG>
-  unsigned_type Generate(URNG& g,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  param_type param_;
-};
-
-template <typename IntType>
-template <typename URBG>
-typename log_uniform_int_distribution<IntType>::unsigned_type
-log_uniform_int_distribution<IntType>::Generate(
-    URBG& g,  // NOLINT(runtime/references)
-    const param_type& p) {
-  // sample e over [0, log_range]. Map the results of e to this:
-  // 0 => 0
-  // 1 => [1, b-1]
-  // 2 => [b, (b^2)-1]
-  // n => [b^(n-1)..(b^n)-1]
-  const int e = absl::uniform_int_distribution<int>(0, p.log_range())(g);
-  if (e == 0) {
-    return 0;
-  }
-  const int d = e - 1;
-
-  unsigned_type base_e, top_e;
-  if (p.base() == 2) {
-    base_e = static_cast<unsigned_type>(1) << d;
-
-    top_e = (e >= std::numeric_limits<unsigned_type>::digits)
-                ? (std::numeric_limits<unsigned_type>::max)()
-                : (static_cast<unsigned_type>(1) << e) - 1;
-  } else {
-    const double r = std::pow(static_cast<double>(p.base()), d);
-    const double s = (r * static_cast<double>(p.base())) - 1.0;
-
-    base_e =
-        (r > static_cast<double>((std::numeric_limits<unsigned_type>::max)()))
-            ? (std::numeric_limits<unsigned_type>::max)()
-            : static_cast<unsigned_type>(r);
-
-    top_e =
-        (s > static_cast<double>((std::numeric_limits<unsigned_type>::max)()))
-            ? (std::numeric_limits<unsigned_type>::max)()
-            : static_cast<unsigned_type>(s);
-  }
-
-  const unsigned_type lo = (base_e >= p.range()) ? p.range() : base_e;
-  const unsigned_type hi = (top_e >= p.range()) ? p.range() : top_e;
-
-  // choose uniformly over [lo, hi]
-  return absl::uniform_int_distribution<result_type>(
-      static_cast<result_type>(lo), static_cast<result_type>(hi))(g);
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const log_uniform_int_distribution<IntType>& x) {
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os << static_cast<stream_type>((x.min)()) << os.fill()
-     << static_cast<stream_type>((x.max)()) << os.fill()
-     << static_cast<stream_type>(x.base());
-  return os;
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,       // NOLINT(runtime/references)
-    log_uniform_int_distribution<IntType>& x) {  // NOLINT(runtime/references)
-  using param_type = typename log_uniform_int_distribution<IntType>::param_type;
-  using result_type =
-      typename log_uniform_int_distribution<IntType>::result_type;
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-
-  stream_type min;
-  stream_type max;
-  stream_type base;
-
-  auto saver = random_internal::make_istream_state_saver(is);
-  is >> min >> max >> base;
-  if (!is.fail()) {
-    x.param(param_type(static_cast<result_type>(min),
-                       static_cast<result_type>(max),
-                       static_cast<result_type>(base)));
-  }
-  return is;
-}
-
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_LOG_UNIFORM_INT_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/mock_distributions.h b/CAPI/cpp/grpc/include/absl/random/mock_distributions.h
index 764ab37..337c84b 100644
--- a/CAPI/cpp/grpc/include/absl/random/mock_distributions.h
+++ b/CAPI/cpp/grpc/include/absl/random/mock_distributions.h
@@ -57,210 +57,203 @@
 #include "absl/random/internal/mock_overload_set.h"
 #include "absl/random/mocking_bit_gen.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// -----------------------------------------------------------------------------
-// absl::MockUniform
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Uniform.
-//
-// `absl::MockUniform` is a class template used in conjunction with Googletest's
-// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
-// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
-// same way one would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockUniform<uint32_t>(), Call(mock))
-//     .WillOnce(Return(123456));
-//  auto x = absl::Uniform<uint32_t>(mock);
-//  assert(x == 123456)
-//
-template <typename R>
-using MockUniform = random_internal::MockOverloadSet<
-    random_internal::UniformDistributionWrapper<R>,
-    R(IntervalClosedOpenTag, MockingBitGen&, R, R),
-    R(IntervalClosedClosedTag, MockingBitGen&, R, R),
-    R(IntervalOpenOpenTag, MockingBitGen&, R, R),
-    R(IntervalOpenClosedTag, MockingBitGen&, R, R), R(MockingBitGen&, R, R),
-    R(MockingBitGen&)>;
+    // -----------------------------------------------------------------------------
+    // absl::MockUniform
+    // -----------------------------------------------------------------------------
+    //
+    // Matches calls to absl::Uniform.
+    //
+    // `absl::MockUniform` is a class template used in conjunction with Googletest's
+    // `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
+    // instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
+    // same way one would define mocks on a Googletest `MockFunction()`.
+    //
+    // Example:
+    //
+    //  absl::MockingBitGen mock;
+    //  EXPECT_CALL(absl::MockUniform<uint32_t>(), Call(mock))
+    //     .WillOnce(Return(123456));
+    //  auto x = absl::Uniform<uint32_t>(mock);
+    //  assert(x == 123456)
+    //
+    template<typename R>
+    using MockUniform = random_internal::MockOverloadSet<
+        random_internal::UniformDistributionWrapper<R>,
+        R(IntervalClosedOpenTag, MockingBitGen&, R, R),
+        R(IntervalClosedClosedTag, MockingBitGen&, R, R),
+        R(IntervalOpenOpenTag, MockingBitGen&, R, R),
+        R(IntervalOpenClosedTag, MockingBitGen&, R, R),
+        R(MockingBitGen&, R, R),
+        R(MockingBitGen&)>;
 
-// -----------------------------------------------------------------------------
-// absl::MockBernoulli
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Bernoulli.
-//
-// `absl::MockBernoulli` is a class used in conjunction with Googletest's
-// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
-// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
-// same way one would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockBernoulli(), Call(mock, testing::_))
-//     .WillOnce(Return(false));
-//  assert(absl::Bernoulli(mock, 0.5) == false);
-//
-using MockBernoulli =
-    random_internal::MockOverloadSet<absl::bernoulli_distribution,
-                                     bool(MockingBitGen&, double)>;
+    // -----------------------------------------------------------------------------
+    // absl::MockBernoulli
+    // -----------------------------------------------------------------------------
+    //
+    // Matches calls to absl::Bernoulli.
+    //
+    // `absl::MockBernoulli` is a class used in conjunction with Googletest's
+    // `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
+    // instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
+    // same way one would define mocks on a Googletest `MockFunction()`.
+    //
+    // Example:
+    //
+    //  absl::MockingBitGen mock;
+    //  EXPECT_CALL(absl::MockBernoulli(), Call(mock, testing::_))
+    //     .WillOnce(Return(false));
+    //  assert(absl::Bernoulli(mock, 0.5) == false);
+    //
+    using MockBernoulli =
+        random_internal::MockOverloadSet<absl::bernoulli_distribution, bool(MockingBitGen&, double)>;
 
-// -----------------------------------------------------------------------------
-// absl::MockBeta
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Beta.
-//
-// `absl::MockBeta` is a class used in conjunction with Googletest's `ON_CALL()`
-// and `EXPECT_CALL()` macros. To use it, default-construct an instance of it
-// inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the same way one
-// would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockBeta(), Call(mock, 3.0, 2.0))
-//     .WillOnce(Return(0.567));
-//  auto x = absl::Beta<double>(mock, 3.0, 2.0);
-//  assert(x == 0.567);
-//
-template <typename RealType>
-using MockBeta =
-    random_internal::MockOverloadSet<absl::beta_distribution<RealType>,
-                                     RealType(MockingBitGen&, RealType,
-                                              RealType)>;
+    // -----------------------------------------------------------------------------
+    // absl::MockBeta
+    // -----------------------------------------------------------------------------
+    //
+    // Matches calls to absl::Beta.
+    //
+    // `absl::MockBeta` is a class used in conjunction with Googletest's `ON_CALL()`
+    // and `EXPECT_CALL()` macros. To use it, default-construct an instance of it
+    // inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the same way one
+    // would define mocks on a Googletest `MockFunction()`.
+    //
+    // Example:
+    //
+    //  absl::MockingBitGen mock;
+    //  EXPECT_CALL(absl::MockBeta(), Call(mock, 3.0, 2.0))
+    //     .WillOnce(Return(0.567));
+    //  auto x = absl::Beta<double>(mock, 3.0, 2.0);
+    //  assert(x == 0.567);
+    //
+    template<typename RealType>
+    using MockBeta =
+        random_internal::MockOverloadSet<absl::beta_distribution<RealType>, RealType(MockingBitGen&, RealType, RealType)>;
 
-// -----------------------------------------------------------------------------
-// absl::MockExponential
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Exponential.
-//
-// `absl::MockExponential` is a class template used in conjunction with
-// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
-// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
-// and use `Call(...)` the same way one would define mocks on a
-// Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockExponential<double>(), Call(mock, 0.5))
-//     .WillOnce(Return(12.3456789));
-//  auto x = absl::Exponential<double>(mock, 0.5);
-//  assert(x == 12.3456789)
-//
-template <typename RealType>
-using MockExponential =
-    random_internal::MockOverloadSet<absl::exponential_distribution<RealType>,
-                                     RealType(MockingBitGen&, RealType)>;
+    // -----------------------------------------------------------------------------
+    // absl::MockExponential
+    // -----------------------------------------------------------------------------
+    //
+    // Matches calls to absl::Exponential.
+    //
+    // `absl::MockExponential` is a class template used in conjunction with
+    // Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
+    // default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
+    // and use `Call(...)` the same way one would define mocks on a
+    // Googletest `MockFunction()`.
+    //
+    // Example:
+    //
+    //  absl::MockingBitGen mock;
+    //  EXPECT_CALL(absl::MockExponential<double>(), Call(mock, 0.5))
+    //     .WillOnce(Return(12.3456789));
+    //  auto x = absl::Exponential<double>(mock, 0.5);
+    //  assert(x == 12.3456789)
+    //
+    template<typename RealType>
+    using MockExponential =
+        random_internal::MockOverloadSet<absl::exponential_distribution<RealType>, RealType(MockingBitGen&, RealType)>;
 
-// -----------------------------------------------------------------------------
-// absl::MockGaussian
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Gaussian.
-//
-// `absl::MockGaussian` is a class template used in conjunction with
-// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
-// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
-// and use `Call(...)` the same way one would define mocks on a
-// Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockGaussian<double>(), Call(mock, 16.3, 3.3))
-//     .WillOnce(Return(12.3456789));
-//  auto x = absl::Gaussian<double>(mock, 16.3, 3.3);
-//  assert(x == 12.3456789)
-//
-template <typename RealType>
-using MockGaussian =
-    random_internal::MockOverloadSet<absl::gaussian_distribution<RealType>,
-                                     RealType(MockingBitGen&, RealType,
-                                              RealType)>;
+    // -----------------------------------------------------------------------------
+    // absl::MockGaussian
+    // -----------------------------------------------------------------------------
+    //
+    // Matches calls to absl::Gaussian.
+    //
+    // `absl::MockGaussian` is a class template used in conjunction with
+    // Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
+    // default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
+    // and use `Call(...)` the same way one would define mocks on a
+    // Googletest `MockFunction()`.
+    //
+    // Example:
+    //
+    //  absl::MockingBitGen mock;
+    //  EXPECT_CALL(absl::MockGaussian<double>(), Call(mock, 16.3, 3.3))
+    //     .WillOnce(Return(12.3456789));
+    //  auto x = absl::Gaussian<double>(mock, 16.3, 3.3);
+    //  assert(x == 12.3456789)
+    //
+    template<typename RealType>
+    using MockGaussian =
+        random_internal::MockOverloadSet<absl::gaussian_distribution<RealType>, RealType(MockingBitGen&, RealType, RealType)>;
 
-// -----------------------------------------------------------------------------
-// absl::MockLogUniform
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::LogUniform.
-//
-// `absl::MockLogUniform` is a class template used in conjunction with
-// Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
-// default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
-// and use `Call(...)` the same way one would define mocks on a
-// Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockLogUniform<int>(), Call(mock, 10, 10000, 10))
-//     .WillOnce(Return(1221));
-//  auto x = absl::LogUniform<int>(mock, 10, 10000, 10);
-//  assert(x == 1221)
-//
-template <typename IntType>
-using MockLogUniform = random_internal::MockOverloadSet<
-    absl::log_uniform_int_distribution<IntType>,
-    IntType(MockingBitGen&, IntType, IntType, IntType)>;
+    // -----------------------------------------------------------------------------
+    // absl::MockLogUniform
+    // -----------------------------------------------------------------------------
+    //
+    // Matches calls to absl::LogUniform.
+    //
+    // `absl::MockLogUniform` is a class template used in conjunction with
+    // Googletest's `ON_CALL()` and `EXPECT_CALL()` macros. To use it,
+    // default-construct an instance of it inside `ON_CALL()` or `EXPECT_CALL()`,
+    // and use `Call(...)` the same way one would define mocks on a
+    // Googletest `MockFunction()`.
+    //
+    // Example:
+    //
+    //  absl::MockingBitGen mock;
+    //  EXPECT_CALL(absl::MockLogUniform<int>(), Call(mock, 10, 10000, 10))
+    //     .WillOnce(Return(1221));
+    //  auto x = absl::LogUniform<int>(mock, 10, 10000, 10);
+    //  assert(x == 1221)
+    //
+    template<typename IntType>
+    using MockLogUniform = random_internal::MockOverloadSet<
+        absl::log_uniform_int_distribution<IntType>,
+        IntType(MockingBitGen&, IntType, IntType, IntType)>;
 
-// -----------------------------------------------------------------------------
-// absl::MockPoisson
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Poisson.
-//
-// `absl::MockPoisson` is a class template used in conjunction with Googletest's
-// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
-// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
-// same way one would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockPoisson<int>(), Call(mock, 2.0))
-//     .WillOnce(Return(1221));
-//  auto x = absl::Poisson<int>(mock, 2.0);
-//  assert(x == 1221)
-//
-template <typename IntType>
-using MockPoisson =
-    random_internal::MockOverloadSet<absl::poisson_distribution<IntType>,
-                                     IntType(MockingBitGen&, double)>;
+    // -----------------------------------------------------------------------------
+    // absl::MockPoisson
+    // -----------------------------------------------------------------------------
+    //
+    // Matches calls to absl::Poisson.
+    //
+    // `absl::MockPoisson` is a class template used in conjunction with Googletest's
+    // `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
+    // instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
+    // same way one would define mocks on a Googletest `MockFunction()`.
+    //
+    // Example:
+    //
+    //  absl::MockingBitGen mock;
+    //  EXPECT_CALL(absl::MockPoisson<int>(), Call(mock, 2.0))
+    //     .WillOnce(Return(1221));
+    //  auto x = absl::Poisson<int>(mock, 2.0);
+    //  assert(x == 1221)
+    //
+    template<typename IntType>
+    using MockPoisson =
+        random_internal::MockOverloadSet<absl::poisson_distribution<IntType>, IntType(MockingBitGen&, double)>;
 
-// -----------------------------------------------------------------------------
-// absl::MockZipf
-// -----------------------------------------------------------------------------
-//
-// Matches calls to absl::Zipf.
-//
-// `absl::MockZipf` is a class template used in conjunction with Googletest's
-// `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
-// instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
-// same way one would define mocks on a Googletest `MockFunction()`.
-//
-// Example:
-//
-//  absl::MockingBitGen mock;
-//  EXPECT_CALL(absl::MockZipf<int>(), Call(mock, 1000000, 2.0, 1.0))
-//     .WillOnce(Return(1221));
-//  auto x = absl::Zipf<int>(mock, 1000000, 2.0, 1.0);
-//  assert(x == 1221)
-//
-template <typename IntType>
-using MockZipf =
-    random_internal::MockOverloadSet<absl::zipf_distribution<IntType>,
-                                     IntType(MockingBitGen&, IntType, double,
-                                             double)>;
+    // -----------------------------------------------------------------------------
+    // absl::MockZipf
+    // -----------------------------------------------------------------------------
+    //
+    // Matches calls to absl::Zipf.
+    //
+    // `absl::MockZipf` is a class template used in conjunction with Googletest's
+    // `ON_CALL()` and `EXPECT_CALL()` macros. To use it, default-construct an
+    // instance of it inside `ON_CALL()` or `EXPECT_CALL()`, and use `Call(...)` the
+    // same way one would define mocks on a Googletest `MockFunction()`.
+    //
+    // Example:
+    //
+    //  absl::MockingBitGen mock;
+    //  EXPECT_CALL(absl::MockZipf<int>(), Call(mock, 1000000, 2.0, 1.0))
+    //     .WillOnce(Return(1221));
+    //  auto x = absl::Zipf<int>(mock, 1000000, 2.0, 1.0);
+    //  assert(x == 1221)
+    //
+    template<typename IntType>
+    using MockZipf =
+        random_internal::MockOverloadSet<absl::zipf_distribution<IntType>, IntType(MockingBitGen&, IntType, double, double)>;
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_MOCK_DISTRIBUTIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/mocking_bit_gen.h b/CAPI/cpp/grpc/include/absl/random/mocking_bit_gen.h
index 89fa5a4..ce3513a 100644
--- a/CAPI/cpp/grpc/include/absl/random/mocking_bit_gen.h
+++ b/CAPI/cpp/grpc/include/absl/random/mocking_bit_gen.h
@@ -49,192 +49,207 @@
 #include "absl/types/variant.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace random_internal {
-template <typename>
-struct DistributionCaller;
-class MockHelpers;
-
-}  // namespace random_internal
-class BitGenRef;
-
-// MockingBitGen
-//
-// `absl::MockingBitGen` is a mock Uniform Random Bit Generator (URBG) class
-// which can act in place of an `absl::BitGen` URBG within tests using the
-// Googletest testing framework.
-//
-// Usage:
-//
-// Use an `absl::MockingBitGen` along with a mock distribution object (within
-// mock_distributions.h) inside Googletest constructs such as ON_CALL(),
-// EXPECT_TRUE(), etc. to produce deterministic results conforming to the
-// distribution's API contract.
-//
-// Example:
-//
-//  // Mock a call to an `absl::Bernoulli` distribution using Googletest
-//   absl::MockingBitGen bitgen;
-//
-//   ON_CALL(absl::MockBernoulli(), Call(bitgen, 0.5))
-//       .WillByDefault(testing::Return(true));
-//   EXPECT_TRUE(absl::Bernoulli(bitgen, 0.5));
-//
-//  // Mock a call to an `absl::Uniform` distribution within Googletest
-//  absl::MockingBitGen bitgen;
-//
-//   ON_CALL(absl::MockUniform<int>(), Call(bitgen, testing::_, testing::_))
-//       .WillByDefault([] (int low, int high) {
-//           return low + (high - low) / 2;
-//       });
-//
-//   EXPECT_EQ(absl::Uniform<int>(gen, 0, 10), 5);
-//   EXPECT_EQ(absl::Uniform<int>(gen, 30, 40), 35);
-//
-// At this time, only mock distributions supplied within the Abseil random
-// library are officially supported.
-//
-// EXPECT_CALL and ON_CALL need to be made within the same DLL component as
-// the call to absl::Uniform and related methods, otherwise mocking will fail
-// since the  underlying implementation creates a type-specific pointer which
-// will be distinct across different DLL boundaries.
-//
-class MockingBitGen {
- public:
-  MockingBitGen() = default;
-  ~MockingBitGen() = default;
-
-  // URBG interface
-  using result_type = absl::BitGen::result_type;
-
-  static constexpr result_type(min)() { return (absl::BitGen::min)(); }
-  static constexpr result_type(max)() { return (absl::BitGen::max)(); }
-  result_type operator()() { return gen_(); }
-
- private:
-  // GetMockFnType returns the testing::MockFunction for a result and tuple.
-  // This method only exists for type deduction and is otherwise unimplemented.
-  template <typename ResultT, typename... Args>
-  static auto GetMockFnType(ResultT, std::tuple<Args...>)
-      -> ::testing::MockFunction<ResultT(Args...)>;
-
-  // MockFnCaller is a helper method for use with absl::apply to
-  // apply an ArgTupleT to a compatible MockFunction.
-  // NOTE: MockFnCaller is essentially equivalent to the lambda:
-  // [fn](auto... args) { return fn->Call(std::move(args)...)}
-  // however that fails to build on some supported platforms.
-  template <typename MockFnType, typename ResultT, typename Tuple>
-  struct MockFnCaller;
-
-  // specialization for std::tuple.
-  template <typename MockFnType, typename ResultT, typename... Args>
-  struct MockFnCaller<MockFnType, ResultT, std::tuple<Args...>> {
-    MockFnType* fn;
-    inline ResultT operator()(Args... args) {
-      return fn->Call(std::move(args)...);
-    }
-  };
-
-  // FunctionHolder owns a particular ::testing::MockFunction associated with
-  // a mocked type signature, and implement the type-erased Apply call, which
-  // applies type-erased arguments to the mock.
-  class FunctionHolder {
-   public:
-    virtual ~FunctionHolder() = default;
-
-    // Call is a dispatch function which converts the
-    // generic type-erased parameters into a specific mock invocation call.
-    virtual void Apply(/*ArgTupleT*/ void* args_tuple,
-                       /*ResultT*/ void* result) = 0;
-  };
-
-  template <typename MockFnType, typename ResultT, typename ArgTupleT>
-  class FunctionHolderImpl final : public FunctionHolder {
-   public:
-    void Apply(void* args_tuple, void* result) override {
-      // Requires tuple_args to point to a ArgTupleT, which is a
-      // std::tuple<Args...> used to invoke the mock function. Requires result
-      // to point to a ResultT, which is the result of the call.
-      *static_cast<ResultT*>(result) =
-          absl::apply(MockFnCaller<MockFnType, ResultT, ArgTupleT>{&mock_fn_},
-                      *static_cast<ArgTupleT*>(args_tuple));
-    }
-
-    MockFnType mock_fn_;
-  };
-
-  // MockingBitGen::RegisterMock
-  //
-  // RegisterMock<ResultT, ArgTupleT>(FastTypeIdType) is the main extension
-  // point for extending the MockingBitGen framework. It provides a mechanism to
-  // install a mock expectation for a function like ResultT(Args...) keyed by
-  // type_idex onto the MockingBitGen context. The key is that the type_index
-  // used to register must match the type index used to call the mock.
-  //
-  // The returned MockFunction<...> type can be used to setup additional
-  // distribution parameters of the expectation.
-  template <typename ResultT, typename ArgTupleT, typename SelfT>
-  auto RegisterMock(SelfT&, base_internal::FastTypeIdType type)
-      -> decltype(GetMockFnType(std::declval<ResultT>(),
-                                std::declval<ArgTupleT>()))& {
-    using MockFnType = decltype(GetMockFnType(std::declval<ResultT>(),
-                                              std::declval<ArgTupleT>()));
-
-    using WrappedFnType = absl::conditional_t<
-        std::is_same<SelfT, ::testing::NiceMock<absl::MockingBitGen>>::value,
-        ::testing::NiceMock<MockFnType>,
-        absl::conditional_t<
-            std::is_same<SelfT,
-                         ::testing::NaggyMock<absl::MockingBitGen>>::value,
-            ::testing::NaggyMock<MockFnType>,
-            absl::conditional_t<
-                std::is_same<SelfT,
-                             ::testing::StrictMock<absl::MockingBitGen>>::value,
-                ::testing::StrictMock<MockFnType>, MockFnType>>>;
-
-    using ImplT = FunctionHolderImpl<WrappedFnType, ResultT, ArgTupleT>;
-    auto& mock = mocks_[type];
-    if (!mock) {
-      mock = absl::make_unique<ImplT>();
-    }
-    return static_cast<ImplT*>(mock.get())->mock_fn_;
-  }
-
-  // MockingBitGen::InvokeMock
-  //
-  // InvokeMock(FastTypeIdType, args, result) is the entrypoint for invoking
-  // mocks registered on MockingBitGen.
-  //
-  // When no mocks are registered on the provided FastTypeIdType, returns false.
-  // Otherwise attempts to invoke the mock function ResultT(Args...) that
-  // was previously registered via the type_index.
-  // Requires tuple_args to point to a ArgTupleT, which is a std::tuple<Args...>
-  // used to invoke the mock function.
-  // Requires result to point to a ResultT, which is the result of the call.
-  inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple,
-                         void* result) {
-    // Trigger a mock, if there exists one that matches `param`.
-    auto it = mocks_.find(type);
-    if (it == mocks_.end()) return false;
-    it->second->Apply(args_tuple, result);
-    return true;
-  }
-
-  absl::flat_hash_map<base_internal::FastTypeIdType,
-                      std::unique_ptr<FunctionHolder>>
-      mocks_;
-  absl::BitGen gen_;
-
-  template <typename>
-  friend struct ::absl::random_internal::DistributionCaller;  // for InvokeMock
-  friend class ::absl::BitGenRef;                             // for InvokeMock
-  friend class ::absl::random_internal::MockHelpers;  // for RegisterMock,
-                                                      // InvokeMock
-};
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    namespace random_internal
+    {
+        template<typename>
+        struct DistributionCaller;
+        class MockHelpers;
+
+    }  // namespace random_internal
+    class BitGenRef;
+
+    // MockingBitGen
+    //
+    // `absl::MockingBitGen` is a mock Uniform Random Bit Generator (URBG) class
+    // which can act in place of an `absl::BitGen` URBG within tests using the
+    // Googletest testing framework.
+    //
+    // Usage:
+    //
+    // Use an `absl::MockingBitGen` along with a mock distribution object (within
+    // mock_distributions.h) inside Googletest constructs such as ON_CALL(),
+    // EXPECT_TRUE(), etc. to produce deterministic results conforming to the
+    // distribution's API contract.
+    //
+    // Example:
+    //
+    //  // Mock a call to an `absl::Bernoulli` distribution using Googletest
+    //   absl::MockingBitGen bitgen;
+    //
+    //   ON_CALL(absl::MockBernoulli(), Call(bitgen, 0.5))
+    //       .WillByDefault(testing::Return(true));
+    //   EXPECT_TRUE(absl::Bernoulli(bitgen, 0.5));
+    //
+    //  // Mock a call to an `absl::Uniform` distribution within Googletest
+    //  absl::MockingBitGen bitgen;
+    //
+    //   ON_CALL(absl::MockUniform<int>(), Call(bitgen, testing::_, testing::_))
+    //       .WillByDefault([] (int low, int high) {
+    //           return low + (high - low) / 2;
+    //       });
+    //
+    //   EXPECT_EQ(absl::Uniform<int>(gen, 0, 10), 5);
+    //   EXPECT_EQ(absl::Uniform<int>(gen, 30, 40), 35);
+    //
+    // At this time, only mock distributions supplied within the Abseil random
+    // library are officially supported.
+    //
+    // EXPECT_CALL and ON_CALL need to be made within the same DLL component as
+    // the call to absl::Uniform and related methods, otherwise mocking will fail
+    // since the  underlying implementation creates a type-specific pointer which
+    // will be distinct across different DLL boundaries.
+    //
+    class MockingBitGen
+    {
+    public:
+        MockingBitGen() = default;
+        ~MockingBitGen() = default;
+
+        // URBG interface
+        using result_type = absl::BitGen::result_type;
+
+        static constexpr result_type(min)()
+        {
+            return (absl::BitGen::min)();
+        }
+        static constexpr result_type(max)()
+        {
+            return (absl::BitGen::max)();
+        }
+        result_type operator()()
+        {
+            return gen_();
+        }
+
+    private:
+        // GetMockFnType returns the testing::MockFunction for a result and tuple.
+        // This method only exists for type deduction and is otherwise unimplemented.
+        template<typename ResultT, typename... Args>
+        static auto GetMockFnType(ResultT, std::tuple<Args...>)
+            -> ::testing::MockFunction<ResultT(Args...)>;
+
+        // MockFnCaller is a helper method for use with absl::apply to
+        // apply an ArgTupleT to a compatible MockFunction.
+        // NOTE: MockFnCaller is essentially equivalent to the lambda:
+        // [fn](auto... args) { return fn->Call(std::move(args)...)}
+        // however that fails to build on some supported platforms.
+        template<typename MockFnType, typename ResultT, typename Tuple>
+        struct MockFnCaller;
+
+        // specialization for std::tuple.
+        template<typename MockFnType, typename ResultT, typename... Args>
+        struct MockFnCaller<MockFnType, ResultT, std::tuple<Args...>>
+        {
+            MockFnType* fn;
+            inline ResultT operator()(Args... args)
+            {
+                return fn->Call(std::move(args)...);
+            }
+        };
+
+        // FunctionHolder owns a particular ::testing::MockFunction associated with
+        // a mocked type signature, and implement the type-erased Apply call, which
+        // applies type-erased arguments to the mock.
+        class FunctionHolder
+        {
+        public:
+            virtual ~FunctionHolder() = default;
+
+            // Call is a dispatch function which converts the
+            // generic type-erased parameters into a specific mock invocation call.
+            virtual void Apply(/*ArgTupleT*/ void* args_tuple,
+                               /*ResultT*/ void* result) = 0;
+        };
+
+        template<typename MockFnType, typename ResultT, typename ArgTupleT>
+        class FunctionHolderImpl final : public FunctionHolder
+        {
+        public:
+            void Apply(void* args_tuple, void* result) override
+            {
+                // Requires tuple_args to point to a ArgTupleT, which is a
+                // std::tuple<Args...> used to invoke the mock function. Requires result
+                // to point to a ResultT, which is the result of the call.
+                *static_cast<ResultT*>(result) =
+                    absl::apply(MockFnCaller<MockFnType, ResultT, ArgTupleT>{&mock_fn_}, *static_cast<ArgTupleT*>(args_tuple));
+            }
+
+            MockFnType mock_fn_;
+        };
+
+        // MockingBitGen::RegisterMock
+        //
+        // RegisterMock<ResultT, ArgTupleT>(FastTypeIdType) is the main extension
+        // point for extending the MockingBitGen framework. It provides a mechanism to
+        // install a mock expectation for a function like ResultT(Args...) keyed by
+        // type_idex onto the MockingBitGen context. The key is that the type_index
+        // used to register must match the type index used to call the mock.
+        //
+        // The returned MockFunction<...> type can be used to setup additional
+        // distribution parameters of the expectation.
+        template<typename ResultT, typename ArgTupleT, typename SelfT>
+        auto RegisterMock(SelfT&, base_internal::FastTypeIdType type)
+            -> decltype(GetMockFnType(std::declval<ResultT>(), std::declval<ArgTupleT>()))&
+        {
+            using MockFnType = decltype(GetMockFnType(std::declval<ResultT>(), std::declval<ArgTupleT>()));
+
+            using WrappedFnType = absl::conditional_t<
+                std::is_same<SelfT, ::testing::NiceMock<absl::MockingBitGen>>::value,
+                ::testing::NiceMock<MockFnType>,
+                absl::conditional_t<
+                    std::is_same<SelfT, ::testing::NaggyMock<absl::MockingBitGen>>::value,
+                    ::testing::NaggyMock<MockFnType>,
+                    absl::conditional_t<
+                        std::is_same<SelfT, ::testing::StrictMock<absl::MockingBitGen>>::value,
+                        ::testing::StrictMock<MockFnType>,
+                        MockFnType>>>;
+
+            using ImplT = FunctionHolderImpl<WrappedFnType, ResultT, ArgTupleT>;
+            auto& mock = mocks_[type];
+            if (!mock)
+            {
+                mock = absl::make_unique<ImplT>();
+            }
+            return static_cast<ImplT*>(mock.get())->mock_fn_;
+        }
+
+        // MockingBitGen::InvokeMock
+        //
+        // InvokeMock(FastTypeIdType, args, result) is the entrypoint for invoking
+        // mocks registered on MockingBitGen.
+        //
+        // When no mocks are registered on the provided FastTypeIdType, returns false.
+        // Otherwise attempts to invoke the mock function ResultT(Args...) that
+        // was previously registered via the type_index.
+        // Requires tuple_args to point to a ArgTupleT, which is a std::tuple<Args...>
+        // used to invoke the mock function.
+        // Requires result to point to a ResultT, which is the result of the call.
+        inline bool InvokeMock(base_internal::FastTypeIdType type, void* args_tuple, void* result)
+        {
+            // Trigger a mock, if there exists one that matches `param`.
+            auto it = mocks_.find(type);
+            if (it == mocks_.end())
+                return false;
+            it->second->Apply(args_tuple, result);
+            return true;
+        }
+
+        absl::flat_hash_map<base_internal::FastTypeIdType, std::unique_ptr<FunctionHolder>>
+            mocks_;
+        absl::BitGen gen_;
+
+        template<typename>
+        friend struct ::absl::random_internal::DistributionCaller;  // for InvokeMock
+        friend class ::absl::BitGenRef;                             // for InvokeMock
+        friend class ::absl::random_internal::MockHelpers;          // for RegisterMock,
+                                                                    // InvokeMock
+    };
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_MOCKING_BIT_GEN_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/poisson_distribution.h b/CAPI/cpp/grpc/include/absl/random/poisson_distribution.h
index f457308..05657c6 100644
--- a/CAPI/cpp/grpc/include/absl/random/poisson_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/poisson_distribution.h
@@ -28,234 +28,288 @@
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/internal/traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// absl::poisson_distribution:
-// Generates discrete variates conforming to a Poisson distribution.
-//   p(n) = (mean^n / n!) exp(-mean)
-//
-// Depending on the parameter, the distribution selects one of the following
-// algorithms:
-// * The standard algorithm, attributed to Knuth, extended using a split method
-// for larger values
-// * The "Ratio of Uniforms as a convenient method for sampling from classical
-// discrete distributions", Stadlober, 1989.
-// http://www.sciencedirect.com/science/article/pii/0377042790903495
-//
-// NOTE: param_type.mean() is a double, which permits values larger than
-// poisson_distribution<IntType>::max(), however this should be avoided and
-// the distribution results are limited to the max() value.
-//
-// The goals of this implementation are to provide good performance while still
-// beig thread-safe: This limits the implementation to not using lgamma provided
-// by <math.h>.
-//
-template <typename IntType = int>
-class poisson_distribution {
- public:
-  using result_type = IntType;
-
-  class param_type {
-   public:
-    using distribution_type = poisson_distribution;
-    explicit param_type(double mean = 1.0);
-
-    double mean() const { return mean_; }
-
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.mean_ == b.mean_;
-    }
-
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
-    }
-
-   private:
-    friend class poisson_distribution;
-
-    double mean_;
-    double emu_;  // e ^ -mean_
-    double lmu_;  // ln(mean_)
-    double s_;
-    double log_k_;
-    int split_;
-
-    static_assert(random_internal::IsIntegral<IntType>::value,
-                  "Class-template absl::poisson_distribution<> must be "
-                  "parameterized using an integral type.");
-  };
-
-  poisson_distribution() : poisson_distribution(1.0) {}
-
-  explicit poisson_distribution(double mean) : param_(mean) {}
-
-  explicit poisson_distribution(const param_type& p) : param_(p) {}
-
-  void reset() {}
-
-  // generating functions
-  template <typename URBG>
-  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
-    return (*this)(g, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  param_type param() const { return param_; }
-  void param(const param_type& p) { param_ = p; }
-
-  result_type(min)() const { return 0; }
-  result_type(max)() const { return (std::numeric_limits<result_type>::max)(); }
-
-  double mean() const { return param_.mean(); }
-
-  friend bool operator==(const poisson_distribution& a,
-                         const poisson_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const poisson_distribution& a,
-                         const poisson_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  param_type param_;
-  random_internal::FastUniformBits<uint64_t> fast_u64_;
-};
-
-// -----------------------------------------------------------------------------
-// Implementation details follow
-// -----------------------------------------------------------------------------
-
-template <typename IntType>
-poisson_distribution<IntType>::param_type::param_type(double mean)
-    : mean_(mean), split_(0) {
-  assert(mean >= 0);
-  assert(mean <=
-         static_cast<double>((std::numeric_limits<result_type>::max)()));
-  // As a defensive measure, avoid large values of the mean.  The rejection
-  // algorithm used does not support very large values well.  It my be worth
-  // changing algorithms to better deal with these cases.
-  assert(mean <= 1e10);
-  if (mean_ < 10) {
-    // For small lambda, use the knuth method.
-    split_ = 1;
-    emu_ = std::exp(-mean_);
-  } else if (mean_ <= 50) {
-    // Use split-knuth method.
-    split_ = 1 + static_cast<int>(mean_ / 10.0);
-    emu_ = std::exp(-mean_ / static_cast<double>(split_));
-  } else {
-    // Use ratio of uniforms method.
-    constexpr double k2E = 0.7357588823428846;
-    constexpr double kSA = 0.4494580810294493;
-
-    lmu_ = std::log(mean_);
-    double a = mean_ + 0.5;
-    s_ = kSA + std::sqrt(k2E * a);
-    const double mode = std::ceil(mean_) - 1;
-    log_k_ = lmu_ * mode - absl::random_internal::StirlingLogFactorial(mode);
-  }
-}
-
-template <typename IntType>
-template <typename URBG>
-typename poisson_distribution<IntType>::result_type
-poisson_distribution<IntType>::operator()(
-    URBG& g,  // NOLINT(runtime/references)
-    const param_type& p) {
-  using random_internal::GeneratePositiveTag;
-  using random_internal::GenerateRealFromBits;
-  using random_internal::GenerateSignedTag;
-
-  if (p.split_ != 0) {
-    // Use Knuth's algorithm with range splitting to avoid floating-point
-    // errors. Knuth's algorithm is: Ui is a sequence of uniform variates on
-    // (0,1); return the number of variates required for product(Ui) <
-    // exp(-lambda).
+    // absl::poisson_distribution:
+    // Generates discrete variates conforming to a Poisson distribution.
+    //   p(n) = (mean^n / n!) exp(-mean)
+    //
+    // Depending on the parameter, the distribution selects one of the following
+    // algorithms:
+    // * The standard algorithm, attributed to Knuth, extended using a split method
+    // for larger values
+    // * The "Ratio of Uniforms as a convenient method for sampling from classical
+    // discrete distributions", Stadlober, 1989.
+    // http://www.sciencedirect.com/science/article/pii/0377042790903495
+    //
+    // NOTE: param_type.mean() is a double, which permits values larger than
+    // poisson_distribution<IntType>::max(), however this should be avoided and
+    // the distribution results are limited to the max() value.
     //
-    // The expected number of variates required for Knuth's method can be
-    // computed as follows:
-    // The expected value of U is 0.5, so solving for 0.5^n < exp(-lambda) gives
-    // the expected number of uniform variates
-    // required for a given lambda, which is:
-    //  lambda = [2, 5,  9, 10, 11, 12, 13, 14, 15, 16, 17]
-    //  n      = [3, 8, 13, 15, 16, 18, 19, 21, 22, 24, 25]
+    // The goals of this implementation are to provide good performance while still
+    // beig thread-safe: This limits the implementation to not using lgamma provided
+    // by <math.h>.
     //
-    result_type n = 0;
-    for (int split = p.split_; split > 0; --split) {
-      double r = 1.0;
-      do {
-        r *= GenerateRealFromBits<double, GeneratePositiveTag, true>(
-            fast_u64_(g));  // U(-1, 0)
-        ++n;
-      } while (r > p.emu_);
-      --n;
+    template<typename IntType = int>
+    class poisson_distribution
+    {
+    public:
+        using result_type = IntType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = poisson_distribution;
+            explicit param_type(double mean = 1.0);
+
+            double mean() const
+            {
+                return mean_;
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.mean_ == b.mean_;
+            }
+
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            friend class poisson_distribution;
+
+            double mean_;
+            double emu_;  // e ^ -mean_
+            double lmu_;  // ln(mean_)
+            double s_;
+            double log_k_;
+            int split_;
+
+            static_assert(random_internal::IsIntegral<IntType>::value, "Class-template absl::poisson_distribution<> must be "
+                                                                       "parameterized using an integral type.");
+        };
+
+        poisson_distribution() :
+            poisson_distribution(1.0)
+        {
+        }
+
+        explicit poisson_distribution(double mean) :
+            param_(mean)
+        {
+        }
+
+        explicit poisson_distribution(const param_type& p) :
+            param_(p)
+        {
+        }
+
+        void reset()
+        {
+        }
+
+        // generating functions
+        template<typename URBG>
+        result_type operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            return (*this)(g, param_);
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                               const param_type& p);
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& p)
+        {
+            param_ = p;
+        }
+
+        result_type(min)() const
+        {
+            return 0;
+        }
+        result_type(max)() const
+        {
+            return (std::numeric_limits<result_type>::max)();
+        }
+
+        double mean() const
+        {
+            return param_.mean();
+        }
+
+        friend bool operator==(const poisson_distribution& a, const poisson_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const poisson_distribution& a, const poisson_distribution& b)
+        {
+            return a.param_ != b.param_;
+        }
+
+    private:
+        param_type param_;
+        random_internal::FastUniformBits<uint64_t> fast_u64_;
+    };
+
+    // -----------------------------------------------------------------------------
+    // Implementation details follow
+    // -----------------------------------------------------------------------------
+
+    template<typename IntType>
+    poisson_distribution<IntType>::param_type::param_type(double mean) :
+        mean_(mean),
+        split_(0)
+    {
+        assert(mean >= 0);
+        assert(mean <= static_cast<double>((std::numeric_limits<result_type>::max)()));
+        // As a defensive measure, avoid large values of the mean.  The rejection
+        // algorithm used does not support very large values well.  It my be worth
+        // changing algorithms to better deal with these cases.
+        assert(mean <= 1e10);
+        if (mean_ < 10)
+        {
+            // For small lambda, use the knuth method.
+            split_ = 1;
+            emu_ = std::exp(-mean_);
+        }
+        else if (mean_ <= 50)
+        {
+            // Use split-knuth method.
+            split_ = 1 + static_cast<int>(mean_ / 10.0);
+            emu_ = std::exp(-mean_ / static_cast<double>(split_));
+        }
+        else
+        {
+            // Use ratio of uniforms method.
+            constexpr double k2E = 0.7357588823428846;
+            constexpr double kSA = 0.4494580810294493;
+
+            lmu_ = std::log(mean_);
+            double a = mean_ + 0.5;
+            s_ = kSA + std::sqrt(k2E * a);
+            const double mode = std::ceil(mean_) - 1;
+            log_k_ = lmu_ * mode - absl::random_internal::StirlingLogFactorial(mode);
+        }
     }
-    return n;
-  }
-
-  // Use ratio of uniforms method.
-  //
-  // Let u ~ Uniform(0, 1), v ~ Uniform(-1, 1),
-  //     a = lambda + 1/2,
-  //     s = 1.5 - sqrt(3/e) + sqrt(2(lambda + 1/2)/e),
-  //     x = s * v/u + a.
-  // P(floor(x) = k | u^2 < f(floor(x))/k), where
-  // f(m) = lambda^m exp(-lambda)/ m!, for 0 <= m, and f(m) = 0 otherwise,
-  // and k = max(f).
-  const double a = p.mean_ + 0.5;
-  for (;;) {
-    const double u = GenerateRealFromBits<double, GeneratePositiveTag, false>(
-        fast_u64_(g));  // U(0, 1)
-    const double v = GenerateRealFromBits<double, GenerateSignedTag, false>(
-        fast_u64_(g));  // U(-1, 1)
-
-    const double x = std::floor(p.s_ * v / u + a);
-    if (x < 0) continue;  // f(negative) = 0
-    const double rhs = x * p.lmu_;
-    // clang-format off
+
+    template<typename IntType>
+    template<typename URBG>
+    typename poisson_distribution<IntType>::result_type
+        poisson_distribution<IntType>::operator()(
+            URBG& g,  // NOLINT(runtime/references)
+            const param_type& p
+        )
+    {
+        using random_internal::GeneratePositiveTag;
+        using random_internal::GenerateRealFromBits;
+        using random_internal::GenerateSignedTag;
+
+        if (p.split_ != 0)
+        {
+            // Use Knuth's algorithm with range splitting to avoid floating-point
+            // errors. Knuth's algorithm is: Ui is a sequence of uniform variates on
+            // (0,1); return the number of variates required for product(Ui) <
+            // exp(-lambda).
+            //
+            // The expected number of variates required for Knuth's method can be
+            // computed as follows:
+            // The expected value of U is 0.5, so solving for 0.5^n < exp(-lambda) gives
+            // the expected number of uniform variates
+            // required for a given lambda, which is:
+            //  lambda = [2, 5,  9, 10, 11, 12, 13, 14, 15, 16, 17]
+            //  n      = [3, 8, 13, 15, 16, 18, 19, 21, 22, 24, 25]
+            //
+            result_type n = 0;
+            for (int split = p.split_; split > 0; --split)
+            {
+                double r = 1.0;
+                do
+                {
+                    r *= GenerateRealFromBits<double, GeneratePositiveTag, true>(
+                        fast_u64_(g)
+                    );  // U(-1, 0)
+                    ++n;
+                } while (r > p.emu_);
+                --n;
+            }
+            return n;
+        }
+
+        // Use ratio of uniforms method.
+        //
+        // Let u ~ Uniform(0, 1), v ~ Uniform(-1, 1),
+        //     a = lambda + 1/2,
+        //     s = 1.5 - sqrt(3/e) + sqrt(2(lambda + 1/2)/e),
+        //     x = s * v/u + a.
+        // P(floor(x) = k | u^2 < f(floor(x))/k), where
+        // f(m) = lambda^m exp(-lambda)/ m!, for 0 <= m, and f(m) = 0 otherwise,
+        // and k = max(f).
+        const double a = p.mean_ + 0.5;
+        for (;;)
+        {
+            const double u = GenerateRealFromBits<double, GeneratePositiveTag, false>(
+                fast_u64_(g)
+            );  // U(0, 1)
+            const double v = GenerateRealFromBits<double, GenerateSignedTag, false>(
+                fast_u64_(g)
+            );  // U(-1, 1)
+
+            const double x = std::floor(p.s_ * v / u + a);
+            if (x < 0)
+                continue;  // f(negative) = 0
+            const double rhs = x * p.lmu_;
+            // clang-format off
     double s = (x <= 1.0) ? 0.0
              : (x == 2.0) ? 0.693147180559945
              : absl::random_internal::StirlingLogFactorial(x);
-    // clang-format on
-    const double lhs = 2.0 * std::log(u) + p.log_k_ + s;
-    if (lhs < rhs) {
-      return x > static_cast<double>((max)())
-                 ? (max)()
-                 : static_cast<result_type>(x);  // f(x)/k >= u^2
+            // clang-format on
+            const double lhs = 2.0 * std::log(u) + p.log_k_ + s;
+            if (lhs < rhs)
+            {
+                return x > static_cast<double>((max)()) ? (max)() : static_cast<result_type>(x);  // f(x)/k >= u^2
+            }
+        }
     }
-  }
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const poisson_distribution<IntType>& x) {
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os.precision(random_internal::stream_precision_helper<double>::kPrecision);
-  os << x.mean();
-  return os;
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-    poisson_distribution<IntType>& x) {     // NOLINT(runtime/references)
-  using param_type = typename poisson_distribution<IntType>::param_type;
-
-  auto saver = random_internal::make_istream_state_saver(is);
-  double mean = random_internal::read_floating_point<double>(is);
-  if (!is.fail()) {
-    x.param(param_type(mean));
-  }
-  return is;
-}
-
-ABSL_NAMESPACE_END
+
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const poisson_distribution<IntType>& x
+    )
+    {
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os.precision(random_internal::stream_precision_helper<double>::kPrecision);
+        os << x.mean();
+        return os;
+    }
+
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        poisson_distribution<IntType>& x
+    )
+    {  // NOLINT(runtime/references)
+        using param_type = typename poisson_distribution<IntType>::param_type;
+
+        auto saver = random_internal::make_istream_state_saver(is);
+        double mean = random_internal::read_floating_point<double>(is);
+        if (!is.fail())
+        {
+            x.param(param_type(mean));
+        }
+        return is;
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_POISSON_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/random.h b/CAPI/cpp/grpc/include/absl/random/random.h
index 71b6309..d7c8378 100644
--- a/CAPI/cpp/grpc/include/absl/random/random.h
+++ b/CAPI/cpp/grpc/include/absl/random/random.h
@@ -33,157 +33,158 @@
 
 #include <random>
 
-#include "absl/random/distributions.h"  // IWYU pragma: export
+#include "absl/random/distributions.h"            // IWYU pragma: export
 #include "absl/random/internal/nonsecure_base.h"  // IWYU pragma: export
-#include "absl/random/internal/pcg_engine.h"  // IWYU pragma: export
+#include "absl/random/internal/pcg_engine.h"      // IWYU pragma: export
 #include "absl/random/internal/pool_urbg.h"
 #include "absl/random/internal/randen_engine.h"
 #include "absl/random/seed_sequences.h"  // IWYU pragma: export
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// absl::BitGen
-// -----------------------------------------------------------------------------
-//
-// `absl::BitGen` is a general-purpose random bit generator for generating
-// random values for use within the Abseil random library. Typically, you use a
-// bit generator in combination with a distribution to provide random values.
-//
-// Example:
-//
-//   // Create an absl::BitGen. There is no need to seed this bit generator.
-//   absl::BitGen gen;
-//
-//   // Generate an integer value in the closed interval [1,6]
-//   int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
-//
-// `absl::BitGen` is seeded by default with non-deterministic data to produce
-// different sequences of random values across different instances, including
-// different binary invocations. This behavior is different than the standard
-// library bit generators, which use golden values as their seeds. Default
-// construction intentionally provides no stability guarantees, to avoid
-// accidental dependence on such a property.
-//
-// `absl::BitGen` may be constructed with an optional seed sequence type,
-// conforming to [rand.req.seed_seq], which will be mixed with additional
-// non-deterministic data.
-//
-// Example:
-//
-//  // Create an absl::BitGen using an std::seed_seq seed sequence
-//  std::seed_seq seq{1,2,3};
-//  absl::BitGen gen_with_seed(seq);
-//
-//  // Generate an integer value in the closed interval [1,6]
-//  int die_roll2 = absl::uniform_int_distribution<int>(1, 6)(gen_with_seed);
-//
-// `absl::BitGen` meets the requirements of the Uniform Random Bit Generator
-// (URBG) concept as per the C++17 standard [rand.req.urng] though differs
-// slightly with [rand.req.eng]. Like its standard library equivalents (e.g.
-// `std::mersenne_twister_engine`) `absl::BitGen` is not cryptographically
-// secure.
-//
-// Constructing two `absl::BitGen`s with the same seed sequence in the same
-// binary will produce the same sequence of variates within the same binary, but
-// need not do so across multiple binary invocations.
-//
-// This type has been optimized to perform better than Mersenne Twister
-// (https://en.wikipedia.org/wiki/Mersenne_Twister) and many other complex URBG
-// types on modern x86, ARM, and PPC architectures.
-//
-// This type is thread-compatible, but not thread-safe.
-
-// ---------------------------------------------------------------------------
-// absl::BitGen member functions
-// ---------------------------------------------------------------------------
-
-// absl::BitGen::operator()()
-//
-// Calls the BitGen, returning a generated value.
-
-// absl::BitGen::min()
-//
-// Returns the smallest possible value from this bit generator.
-
-// absl::BitGen::max()
-//
-// Returns the largest possible value from this bit generator.
-
-// absl::BitGen::discard(num)
-//
-// Advances the internal state of this bit generator by `num` times, and
-// discards the intermediate results.
-// ---------------------------------------------------------------------------
-
-using BitGen = random_internal::NonsecureURBGBase<
-    random_internal::randen_engine<uint64_t>>;
-
-// -----------------------------------------------------------------------------
-// absl::InsecureBitGen
-// -----------------------------------------------------------------------------
-//
-// `absl::InsecureBitGen` is an efficient random bit generator for generating
-// random values, recommended only for performance-sensitive use cases where
-// `absl::BitGen` is not satisfactory when compute-bounded by bit generation
-// costs.
-//
-// Example:
-//
-//   // Create an absl::InsecureBitGen
-//   absl::InsecureBitGen gen;
-//   for (size_t i = 0; i < 1000000; i++) {
-//
-//     // Generate a bunch of random values from some complex distribution
-//     auto my_rnd = some_distribution(gen, 1, 1000);
-//   }
-//
-// Like `absl::BitGen`, `absl::InsecureBitGen` is seeded by default with
-// non-deterministic data to produce different sequences of random values across
-// different instances, including different binary invocations. (This behavior
-// is different than the standard library bit generators, which use golden
-// values as their seeds.)
-//
-// `absl::InsecureBitGen` may be constructed with an optional seed sequence
-// type, conforming to [rand.req.seed_seq], which will be mixed with additional
-// non-deterministic data. (See std_seed_seq.h for more information.)
-//
-// `absl::InsecureBitGen` meets the requirements of the Uniform Random Bit
-// Generator (URBG) concept as per the C++17 standard [rand.req.urng] though
-// its implementation differs slightly with [rand.req.eng]. Like its standard
-// library equivalents (e.g. `std::mersenne_twister_engine`)
-// `absl::InsecureBitGen` is not cryptographically secure.
-//
-// Prefer `absl::BitGen` over `absl::InsecureBitGen` as the general type is
-// often fast enough for the vast majority of applications.
-
-using InsecureBitGen =
-    random_internal::NonsecureURBGBase<random_internal::pcg64_2018_engine>;
-
-// ---------------------------------------------------------------------------
-// absl::InsecureBitGen member functions
-// ---------------------------------------------------------------------------
-
-// absl::InsecureBitGen::operator()()
-//
-// Calls the InsecureBitGen, returning a generated value.
-
-// absl::InsecureBitGen::min()
-//
-// Returns the smallest possible value from this bit generator.
-
-// absl::InsecureBitGen::max()
-//
-// Returns the largest possible value from this bit generator.
-
-// absl::InsecureBitGen::discard(num)
-//
-// Advances the internal state of this bit generator by `num` times, and
-// discards the intermediate results.
-// ---------------------------------------------------------------------------
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // -----------------------------------------------------------------------------
+    // absl::BitGen
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::BitGen` is a general-purpose random bit generator for generating
+    // random values for use within the Abseil random library. Typically, you use a
+    // bit generator in combination with a distribution to provide random values.
+    //
+    // Example:
+    //
+    //   // Create an absl::BitGen. There is no need to seed this bit generator.
+    //   absl::BitGen gen;
+    //
+    //   // Generate an integer value in the closed interval [1,6]
+    //   int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
+    //
+    // `absl::BitGen` is seeded by default with non-deterministic data to produce
+    // different sequences of random values across different instances, including
+    // different binary invocations. This behavior is different than the standard
+    // library bit generators, which use golden values as their seeds. Default
+    // construction intentionally provides no stability guarantees, to avoid
+    // accidental dependence on such a property.
+    //
+    // `absl::BitGen` may be constructed with an optional seed sequence type,
+    // conforming to [rand.req.seed_seq], which will be mixed with additional
+    // non-deterministic data.
+    //
+    // Example:
+    //
+    //  // Create an absl::BitGen using an std::seed_seq seed sequence
+    //  std::seed_seq seq{1,2,3};
+    //  absl::BitGen gen_with_seed(seq);
+    //
+    //  // Generate an integer value in the closed interval [1,6]
+    //  int die_roll2 = absl::uniform_int_distribution<int>(1, 6)(gen_with_seed);
+    //
+    // `absl::BitGen` meets the requirements of the Uniform Random Bit Generator
+    // (URBG) concept as per the C++17 standard [rand.req.urng] though differs
+    // slightly with [rand.req.eng]. Like its standard library equivalents (e.g.
+    // `std::mersenne_twister_engine`) `absl::BitGen` is not cryptographically
+    // secure.
+    //
+    // Constructing two `absl::BitGen`s with the same seed sequence in the same
+    // binary will produce the same sequence of variates within the same binary, but
+    // need not do so across multiple binary invocations.
+    //
+    // This type has been optimized to perform better than Mersenne Twister
+    // (https://en.wikipedia.org/wiki/Mersenne_Twister) and many other complex URBG
+    // types on modern x86, ARM, and PPC architectures.
+    //
+    // This type is thread-compatible, but not thread-safe.
+
+    // ---------------------------------------------------------------------------
+    // absl::BitGen member functions
+    // ---------------------------------------------------------------------------
+
+    // absl::BitGen::operator()()
+    //
+    // Calls the BitGen, returning a generated value.
+
+    // absl::BitGen::min()
+    //
+    // Returns the smallest possible value from this bit generator.
+
+    // absl::BitGen::max()
+    //
+    // Returns the largest possible value from this bit generator.
+
+    // absl::BitGen::discard(num)
+    //
+    // Advances the internal state of this bit generator by `num` times, and
+    // discards the intermediate results.
+    // ---------------------------------------------------------------------------
+
+    using BitGen = random_internal::NonsecureURBGBase<
+        random_internal::randen_engine<uint64_t>>;
+
+    // -----------------------------------------------------------------------------
+    // absl::InsecureBitGen
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::InsecureBitGen` is an efficient random bit generator for generating
+    // random values, recommended only for performance-sensitive use cases where
+    // `absl::BitGen` is not satisfactory when compute-bounded by bit generation
+    // costs.
+    //
+    // Example:
+    //
+    //   // Create an absl::InsecureBitGen
+    //   absl::InsecureBitGen gen;
+    //   for (size_t i = 0; i < 1000000; i++) {
+    //
+    //     // Generate a bunch of random values from some complex distribution
+    //     auto my_rnd = some_distribution(gen, 1, 1000);
+    //   }
+    //
+    // Like `absl::BitGen`, `absl::InsecureBitGen` is seeded by default with
+    // non-deterministic data to produce different sequences of random values across
+    // different instances, including different binary invocations. (This behavior
+    // is different than the standard library bit generators, which use golden
+    // values as their seeds.)
+    //
+    // `absl::InsecureBitGen` may be constructed with an optional seed sequence
+    // type, conforming to [rand.req.seed_seq], which will be mixed with additional
+    // non-deterministic data. (See std_seed_seq.h for more information.)
+    //
+    // `absl::InsecureBitGen` meets the requirements of the Uniform Random Bit
+    // Generator (URBG) concept as per the C++17 standard [rand.req.urng] though
+    // its implementation differs slightly with [rand.req.eng]. Like its standard
+    // library equivalents (e.g. `std::mersenne_twister_engine`)
+    // `absl::InsecureBitGen` is not cryptographically secure.
+    //
+    // Prefer `absl::BitGen` over `absl::InsecureBitGen` as the general type is
+    // often fast enough for the vast majority of applications.
+
+    using InsecureBitGen =
+        random_internal::NonsecureURBGBase<random_internal::pcg64_2018_engine>;
+
+    // ---------------------------------------------------------------------------
+    // absl::InsecureBitGen member functions
+    // ---------------------------------------------------------------------------
+
+    // absl::InsecureBitGen::operator()()
+    //
+    // Calls the InsecureBitGen, returning a generated value.
+
+    // absl::InsecureBitGen::min()
+    //
+    // Returns the smallest possible value from this bit generator.
+
+    // absl::InsecureBitGen::max()
+    //
+    // Returns the largest possible value from this bit generator.
+
+    // absl::InsecureBitGen::discard(num)
+    //
+    // Advances the internal state of this bit generator by `num` times, and
+    // discards the intermediate results.
+    // ---------------------------------------------------------------------------
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_RANDOM_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/seed_gen_exception.h b/CAPI/cpp/grpc/include/absl/random/seed_gen_exception.h
index 5353900..4c40da6 100644
--- a/CAPI/cpp/grpc/include/absl/random/seed_gen_exception.h
+++ b/CAPI/cpp/grpc/include/absl/random/seed_gen_exception.h
@@ -30,26 +30,29 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-//------------------------------------------------------------------------------
-// SeedGenException
-//------------------------------------------------------------------------------
-class SeedGenException : public std::exception {
- public:
-  SeedGenException() = default;
-  ~SeedGenException() override;
-  const char* what() const noexcept override;
-};
-
-namespace random_internal {
-
-// throw delegator
-[[noreturn]] void ThrowSeedGenException();
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    //------------------------------------------------------------------------------
+    // SeedGenException
+    //------------------------------------------------------------------------------
+    class SeedGenException : public std::exception
+    {
+    public:
+        SeedGenException() = default;
+        ~SeedGenException() override;
+        const char* what() const noexcept override;
+    };
+
+    namespace random_internal
+    {
+
+        // throw delegator
+        [[noreturn]] void ThrowSeedGenException();
+
+    }  // namespace random_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_SEED_GEN_EXCEPTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/seed_sequences.h b/CAPI/cpp/grpc/include/absl/random/seed_sequences.h
index c3af4b0..ef694bf 100644
--- a/CAPI/cpp/grpc/include/absl/random/seed_sequences.h
+++ b/CAPI/cpp/grpc/include/absl/random/seed_sequences.h
@@ -34,78 +34,82 @@
 #include "absl/random/seed_gen_exception.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// -----------------------------------------------------------------------------
-// absl::SeedSeq
-// -----------------------------------------------------------------------------
-//
-// `absl::SeedSeq` constructs a seed sequence according to [rand.req.seedseq]
-// for use within bit generators. `absl::SeedSeq`, unlike `std::seed_seq`
-// additionally salts the generated seeds with extra implementation-defined
-// entropy. For that reason, you can use `absl::SeedSeq` in combination with
-// standard library bit generators (e.g. `std::mt19937`) to introduce
-// non-determinism in your seeds.
-//
-// Example:
-//
-//   absl::SeedSeq my_seed_seq({a, b, c});
-//   std::mt19937 my_bitgen(my_seed_seq);
-//
-using SeedSeq = random_internal::SaltedSeedSeq<std::seed_seq>;
+    // -----------------------------------------------------------------------------
+    // absl::SeedSeq
+    // -----------------------------------------------------------------------------
+    //
+    // `absl::SeedSeq` constructs a seed sequence according to [rand.req.seedseq]
+    // for use within bit generators. `absl::SeedSeq`, unlike `std::seed_seq`
+    // additionally salts the generated seeds with extra implementation-defined
+    // entropy. For that reason, you can use `absl::SeedSeq` in combination with
+    // standard library bit generators (e.g. `std::mt19937`) to introduce
+    // non-determinism in your seeds.
+    //
+    // Example:
+    //
+    //   absl::SeedSeq my_seed_seq({a, b, c});
+    //   std::mt19937 my_bitgen(my_seed_seq);
+    //
+    using SeedSeq = random_internal::SaltedSeedSeq<std::seed_seq>;
 
-// -----------------------------------------------------------------------------
-// absl::CreateSeedSeqFrom(bitgen*)
-// -----------------------------------------------------------------------------
-//
-// Constructs a seed sequence conforming to [rand.req.seedseq] using variates
-// produced by a provided bit generator.
-//
-// You should generally avoid direct construction of seed sequences, but
-// use-cases for reuse of a seed sequence to construct identical bit generators
-// may be helpful (eg. replaying a simulation whose state is derived from bit
-// generator values).
-//
-// If bitgen == nullptr, then behavior is undefined.
-//
-// Example:
-//
-//   absl::BitGen my_bitgen;
-//   auto seed_seq = absl::CreateSeedSeqFrom(&my_bitgen);
-//   absl::BitGen new_engine(seed_seq); // derived from my_bitgen, but not
-//                                      // correlated.
-//
-template <typename URBG>
-SeedSeq CreateSeedSeqFrom(URBG* urbg) {
-  SeedSeq::result_type
-      seed_material[random_internal::kEntropyBlocksNeeded];
+    // -----------------------------------------------------------------------------
+    // absl::CreateSeedSeqFrom(bitgen*)
+    // -----------------------------------------------------------------------------
+    //
+    // Constructs a seed sequence conforming to [rand.req.seedseq] using variates
+    // produced by a provided bit generator.
+    //
+    // You should generally avoid direct construction of seed sequences, but
+    // use-cases for reuse of a seed sequence to construct identical bit generators
+    // may be helpful (eg. replaying a simulation whose state is derived from bit
+    // generator values).
+    //
+    // If bitgen == nullptr, then behavior is undefined.
+    //
+    // Example:
+    //
+    //   absl::BitGen my_bitgen;
+    //   auto seed_seq = absl::CreateSeedSeqFrom(&my_bitgen);
+    //   absl::BitGen new_engine(seed_seq); // derived from my_bitgen, but not
+    //                                      // correlated.
+    //
+    template<typename URBG>
+    SeedSeq CreateSeedSeqFrom(URBG* urbg)
+    {
+        SeedSeq::result_type
+            seed_material[random_internal::kEntropyBlocksNeeded];
 
-  if (!random_internal::ReadSeedMaterialFromURBG(
-          urbg, absl::MakeSpan(seed_material))) {
-    random_internal::ThrowSeedGenException();
-  }
-  return SeedSeq(std::begin(seed_material), std::end(seed_material));
-}
+        if (!random_internal::ReadSeedMaterialFromURBG(
+                urbg, absl::MakeSpan(seed_material)
+            ))
+        {
+            random_internal::ThrowSeedGenException();
+        }
+        return SeedSeq(std::begin(seed_material), std::end(seed_material));
+    }
 
-// -----------------------------------------------------------------------------
-// absl::MakeSeedSeq()
-// -----------------------------------------------------------------------------
-//
-// Constructs an `absl::SeedSeq` salting the generated values using
-// implementation-defined entropy. The returned sequence can be used to create
-// equivalent bit generators correlated using this sequence.
-//
-// Example:
-//
-//   auto my_seed_seq = absl::MakeSeedSeq();
-//   std::mt19937 rng1(my_seed_seq);
-//   std::mt19937 rng2(my_seed_seq);
-//   EXPECT_EQ(rng1(), rng2());
-//
-SeedSeq MakeSeedSeq();
+    // -----------------------------------------------------------------------------
+    // absl::MakeSeedSeq()
+    // -----------------------------------------------------------------------------
+    //
+    // Constructs an `absl::SeedSeq` salting the generated values using
+    // implementation-defined entropy. The returned sequence can be used to create
+    // equivalent bit generators correlated using this sequence.
+    //
+    // Example:
+    //
+    //   auto my_seed_seq = absl::MakeSeedSeq();
+    //   std::mt19937 rng1(my_seed_seq);
+    //   std::mt19937 rng2(my_seed_seq);
+    //   EXPECT_EQ(rng1(), rng2());
+    //
+    SeedSeq MakeSeedSeq();
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_SEED_SEQUENCES_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/uniform_int_distribution.h b/CAPI/cpp/grpc/include/absl/random/uniform_int_distribution.h
index fae8025..25aa8e6 100644
--- a/CAPI/cpp/grpc/include/absl/random/uniform_int_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/uniform_int_distribution.h
@@ -39,237 +39,292 @@
 #include "absl/random/internal/traits.h"
 #include "absl/random/internal/wide_multiply.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::uniform_int_distribution<T>
-//
-// This distribution produces random integer values uniformly distributed in the
-// closed (inclusive) interval [a, b].
-//
-// Example:
-//
-//   absl::BitGen gen;
-//
-//   // Use the distribution to produce a value between 1 and 6, inclusive.
-//   int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
-//
-template <typename IntType = int>
-class uniform_int_distribution {
- private:
-  using unsigned_type =
-      typename random_internal::make_unsigned_bits<IntType>::type;
-
- public:
-  using result_type = IntType;
-
-  class param_type {
-   public:
-    using distribution_type = uniform_int_distribution;
-
-    explicit param_type(
-        result_type lo = 0,
-        result_type hi = (std::numeric_limits<result_type>::max)())
-        : lo_(lo),
-          range_(static_cast<unsigned_type>(hi) -
-                 static_cast<unsigned_type>(lo)) {
-      // [rand.dist.uni.int] precondition 2
-      assert(lo <= hi);
-    }
-
-    result_type a() const { return lo_; }
-    result_type b() const {
-      return static_cast<result_type>(static_cast<unsigned_type>(lo_) + range_);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::uniform_int_distribution<T>
+    //
+    // This distribution produces random integer values uniformly distributed in the
+    // closed (inclusive) interval [a, b].
+    //
+    // Example:
+    //
+    //   absl::BitGen gen;
+    //
+    //   // Use the distribution to produce a value between 1 and 6, inclusive.
+    //   int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
+    //
+    template<typename IntType = int>
+    class uniform_int_distribution
+    {
+    private:
+        using unsigned_type =
+            typename random_internal::make_unsigned_bits<IntType>::type;
+
+    public:
+        using result_type = IntType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = uniform_int_distribution;
+
+            explicit param_type(
+                result_type lo = 0,
+                result_type hi = (std::numeric_limits<result_type>::max)()
+            ) :
+                lo_(lo),
+                range_(static_cast<unsigned_type>(hi) - static_cast<unsigned_type>(lo))
+            {
+                // [rand.dist.uni.int] precondition 2
+                assert(lo <= hi);
+            }
+
+            result_type a() const
+            {
+                return lo_;
+            }
+            result_type b() const
+            {
+                return static_cast<result_type>(static_cast<unsigned_type>(lo_) + range_);
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.lo_ == b.lo_ && a.range_ == b.range_;
+            }
+
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            friend class uniform_int_distribution;
+            unsigned_type range() const
+            {
+                return range_;
+            }
+
+            result_type lo_;
+            unsigned_type range_;
+
+            static_assert(random_internal::IsIntegral<result_type>::value, "Class-template absl::uniform_int_distribution<> must be "
+                                                                           "parameterized using an integral type.");
+        };  // param_type
+
+        uniform_int_distribution() :
+            uniform_int_distribution(0)
+        {
+        }
+
+        explicit uniform_int_distribution(
+            result_type lo,
+            result_type hi = (std::numeric_limits<result_type>::max)()
+        ) :
+            param_(lo, hi)
+        {
+        }
+
+        explicit uniform_int_distribution(const param_type& param) :
+            param_(param)
+        {
+        }
+
+        // uniform_int_distribution<T>::reset()
+        //
+        // Resets the uniform int distribution. Note that this function has no effect
+        // because the distribution already produces independent values.
+        void reset()
+        {
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& gen)
+        {  // NOLINT(runtime/references)
+            return (*this)(gen, param());
+        }
+
+        template<typename URBG>
+        result_type operator()(
+            URBG& gen, const param_type& param
+        )
+        {  // NOLINT(runtime/references)
+            return static_cast<result_type>(param.a() + Generate(gen, param.range()));
+        }
+
+        result_type a() const
+        {
+            return param_.a();
+        }
+        result_type b() const
+        {
+            return param_.b();
+        }
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& params)
+        {
+            param_ = params;
+        }
+
+        result_type(min)() const
+        {
+            return a();
+        }
+        result_type(max)() const
+        {
+            return b();
+        }
+
+        friend bool operator==(const uniform_int_distribution& a, const uniform_int_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const uniform_int_distribution& a, const uniform_int_distribution& b)
+        {
+            return !(a == b);
+        }
+
+    private:
+        // Generates a value in the *closed* interval [0, R]
+        template<typename URBG>
+        unsigned_type Generate(URBG& g,  // NOLINT(runtime/references)
+                               unsigned_type R);
+        param_type param_;
+    };
+
+    // -----------------------------------------------------------------------------
+    // Implementation details follow
+    // -----------------------------------------------------------------------------
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,
+        const uniform_int_distribution<IntType>& x
+    )
+    {
+        using stream_type =
+            typename random_internal::stream_format_type<IntType>::type;
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os << static_cast<stream_type>(x.a()) << os.fill()
+           << static_cast<stream_type>(x.b());
+        return os;
     }
 
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.lo_ == b.lo_ && a.range_ == b.range_;
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,
+        uniform_int_distribution<IntType>& x
+    )
+    {
+        using param_type = typename uniform_int_distribution<IntType>::param_type;
+        using result_type = typename uniform_int_distribution<IntType>::result_type;
+        using stream_type =
+            typename random_internal::stream_format_type<IntType>::type;
+
+        stream_type a;
+        stream_type b;
+
+        auto saver = random_internal::make_istream_state_saver(is);
+        is >> a >> b;
+        if (!is.fail())
+        {
+            x.param(
+                param_type(static_cast<result_type>(a), static_cast<result_type>(b))
+            );
+        }
+        return is;
     }
 
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
+    template<typename IntType>
+    template<typename URBG>
+    typename random_internal::make_unsigned_bits<IntType>::type
+        uniform_int_distribution<IntType>::Generate(
+            URBG& g,  // NOLINT(runtime/references)
+            typename random_internal::make_unsigned_bits<IntType>::type R
+        )
+    {
+        random_internal::FastUniformBits<unsigned_type> fast_bits;
+        unsigned_type bits = fast_bits(g);
+        const unsigned_type Lim = R + 1;
+        if ((R & Lim) == 0)
+        {
+            // If the interval's length is a power of two range, just take the low bits.
+            return bits & R;
+        }
+
+        // Generates a uniform variate on [0, Lim) using fixed-point multiplication.
+        // The above fast-path guarantees that Lim is representable in unsigned_type.
+        //
+        // Algorithm adapted from
+        // http://lemire.me/blog/2016/06/30/fast-random-shuffling/, with added
+        // explanation.
+        //
+        // The algorithm creates a uniform variate `bits` in the interval [0, 2^N),
+        // and treats it as the fractional part of a fixed-point real value in [0, 1),
+        // multiplied by 2^N.  For example, 0.25 would be represented as 2^(N - 2),
+        // because 2^N * 0.25 == 2^(N - 2).
+        //
+        // Next, `bits` and `Lim` are multiplied with a wide-multiply to bring the
+        // value into the range [0, Lim).  The integral part (the high word of the
+        // multiplication result) is then very nearly the desired result.  However,
+        // this is not quite accurate; viewing the multiplication result as one
+        // double-width integer, the resulting values for the sample are mapped as
+        // follows:
+        //
+        // If the result lies in this interval:       Return this value:
+        //        [0, 2^N)                                    0
+        //        [2^N, 2 * 2^N)                              1
+        //        ...                                         ...
+        //        [K * 2^N, (K + 1) * 2^N)                    K
+        //        ...                                         ...
+        //        [(Lim - 1) * 2^N, Lim * 2^N)                Lim - 1
+        //
+        // While all of these intervals have the same size, the result of `bits * Lim`
+        // must be a multiple of `Lim`, and not all of these intervals contain the
+        // same number of multiples of `Lim`.  In particular, some contain
+        // `F = floor(2^N / Lim)` and some contain `F + 1 = ceil(2^N / Lim)`.  This
+        // difference produces a small nonuniformity, which is corrected by applying
+        // rejection sampling to one of the values in the "larger intervals" (i.e.,
+        // the intervals containing `F + 1` multiples of `Lim`.
+        //
+        // An interval contains `F + 1` multiples of `Lim` if and only if its smallest
+        // value modulo 2^N is less than `2^N % Lim`.  The unique value satisfying
+        // this property is used as the one for rejection.  That is, a value of
+        // `bits * Lim` is rejected if `(bit * Lim) % 2^N < (2^N % Lim)`.
+
+        using helper = random_internal::wide_multiply<unsigned_type>;
+        auto product = helper::multiply(bits, Lim);
+
+        // Two optimizations here:
+        // * Rejection occurs with some probability less than 1/2, and for reasonable
+        //   ranges considerably less (in particular, less than 1/(F+1)), so
+        //   ABSL_PREDICT_FALSE is apt.
+        // * `Lim` is an overestimate of `threshold`, and doesn't require a divide.
+        if (ABSL_PREDICT_FALSE(helper::lo(product) < Lim))
+        {
+            // This quantity is exactly equal to `2^N % Lim`, but does not require high
+            // precision calculations: `2^N % Lim` is congruent to `(2^N - Lim) % Lim`.
+            // Ideally this could be expressed simply as `-X` rather than `2^N - X`, but
+            // for types smaller than int, this calculation is incorrect due to integer
+            // promotion rules.
+            const unsigned_type threshold =
+                ((std::numeric_limits<unsigned_type>::max)() - Lim + 1) % Lim;
+            while (helper::lo(product) < threshold)
+            {
+                bits = fast_bits(g);
+                product = helper::multiply(bits, Lim);
+            }
+        }
+
+        return helper::hi(product);
     }
 
-   private:
-    friend class uniform_int_distribution;
-    unsigned_type range() const { return range_; }
-
-    result_type lo_;
-    unsigned_type range_;
-
-    static_assert(random_internal::IsIntegral<result_type>::value,
-                  "Class-template absl::uniform_int_distribution<> must be "
-                  "parameterized using an integral type.");
-  };  // param_type
-
-  uniform_int_distribution() : uniform_int_distribution(0) {}
-
-  explicit uniform_int_distribution(
-      result_type lo,
-      result_type hi = (std::numeric_limits<result_type>::max)())
-      : param_(lo, hi) {}
-
-  explicit uniform_int_distribution(const param_type& param) : param_(param) {}
-
-  // uniform_int_distribution<T>::reset()
-  //
-  // Resets the uniform int distribution. Note that this function has no effect
-  // because the distribution already produces independent values.
-  void reset() {}
-
-  template <typename URBG>
-  result_type operator()(URBG& gen) {  // NOLINT(runtime/references)
-    return (*this)(gen, param());
-  }
-
-  template <typename URBG>
-  result_type operator()(
-      URBG& gen, const param_type& param) {  // NOLINT(runtime/references)
-    return static_cast<result_type>(param.a() + Generate(gen, param.range()));
-  }
-
-  result_type a() const { return param_.a(); }
-  result_type b() const { return param_.b(); }
-
-  param_type param() const { return param_; }
-  void param(const param_type& params) { param_ = params; }
-
-  result_type(min)() const { return a(); }
-  result_type(max)() const { return b(); }
-
-  friend bool operator==(const uniform_int_distribution& a,
-                         const uniform_int_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const uniform_int_distribution& a,
-                         const uniform_int_distribution& b) {
-    return !(a == b);
-  }
-
- private:
-  // Generates a value in the *closed* interval [0, R]
-  template <typename URBG>
-  unsigned_type Generate(URBG& g,  // NOLINT(runtime/references)
-                         unsigned_type R);
-  param_type param_;
-};
-
-// -----------------------------------------------------------------------------
-// Implementation details follow
-// -----------------------------------------------------------------------------
-template <typename CharT, typename Traits, typename IntType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,
-    const uniform_int_distribution<IntType>& x) {
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os << static_cast<stream_type>(x.a()) << os.fill()
-     << static_cast<stream_type>(x.b());
-  return os;
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,
-    uniform_int_distribution<IntType>& x) {
-  using param_type = typename uniform_int_distribution<IntType>::param_type;
-  using result_type = typename uniform_int_distribution<IntType>::result_type;
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-
-  stream_type a;
-  stream_type b;
-
-  auto saver = random_internal::make_istream_state_saver(is);
-  is >> a >> b;
-  if (!is.fail()) {
-    x.param(
-        param_type(static_cast<result_type>(a), static_cast<result_type>(b)));
-  }
-  return is;
-}
-
-template <typename IntType>
-template <typename URBG>
-typename random_internal::make_unsigned_bits<IntType>::type
-uniform_int_distribution<IntType>::Generate(
-    URBG& g,  // NOLINT(runtime/references)
-    typename random_internal::make_unsigned_bits<IntType>::type R) {
-  random_internal::FastUniformBits<unsigned_type> fast_bits;
-  unsigned_type bits = fast_bits(g);
-  const unsigned_type Lim = R + 1;
-  if ((R & Lim) == 0) {
-    // If the interval's length is a power of two range, just take the low bits.
-    return bits & R;
-  }
-
-  // Generates a uniform variate on [0, Lim) using fixed-point multiplication.
-  // The above fast-path guarantees that Lim is representable in unsigned_type.
-  //
-  // Algorithm adapted from
-  // http://lemire.me/blog/2016/06/30/fast-random-shuffling/, with added
-  // explanation.
-  //
-  // The algorithm creates a uniform variate `bits` in the interval [0, 2^N),
-  // and treats it as the fractional part of a fixed-point real value in [0, 1),
-  // multiplied by 2^N.  For example, 0.25 would be represented as 2^(N - 2),
-  // because 2^N * 0.25 == 2^(N - 2).
-  //
-  // Next, `bits` and `Lim` are multiplied with a wide-multiply to bring the
-  // value into the range [0, Lim).  The integral part (the high word of the
-  // multiplication result) is then very nearly the desired result.  However,
-  // this is not quite accurate; viewing the multiplication result as one
-  // double-width integer, the resulting values for the sample are mapped as
-  // follows:
-  //
-  // If the result lies in this interval:       Return this value:
-  //        [0, 2^N)                                    0
-  //        [2^N, 2 * 2^N)                              1
-  //        ...                                         ...
-  //        [K * 2^N, (K + 1) * 2^N)                    K
-  //        ...                                         ...
-  //        [(Lim - 1) * 2^N, Lim * 2^N)                Lim - 1
-  //
-  // While all of these intervals have the same size, the result of `bits * Lim`
-  // must be a multiple of `Lim`, and not all of these intervals contain the
-  // same number of multiples of `Lim`.  In particular, some contain
-  // `F = floor(2^N / Lim)` and some contain `F + 1 = ceil(2^N / Lim)`.  This
-  // difference produces a small nonuniformity, which is corrected by applying
-  // rejection sampling to one of the values in the "larger intervals" (i.e.,
-  // the intervals containing `F + 1` multiples of `Lim`.
-  //
-  // An interval contains `F + 1` multiples of `Lim` if and only if its smallest
-  // value modulo 2^N is less than `2^N % Lim`.  The unique value satisfying
-  // this property is used as the one for rejection.  That is, a value of
-  // `bits * Lim` is rejected if `(bit * Lim) % 2^N < (2^N % Lim)`.
-
-  using helper = random_internal::wide_multiply<unsigned_type>;
-  auto product = helper::multiply(bits, Lim);
-
-  // Two optimizations here:
-  // * Rejection occurs with some probability less than 1/2, and for reasonable
-  //   ranges considerably less (in particular, less than 1/(F+1)), so
-  //   ABSL_PREDICT_FALSE is apt.
-  // * `Lim` is an overestimate of `threshold`, and doesn't require a divide.
-  if (ABSL_PREDICT_FALSE(helper::lo(product) < Lim)) {
-    // This quantity is exactly equal to `2^N % Lim`, but does not require high
-    // precision calculations: `2^N % Lim` is congruent to `(2^N - Lim) % Lim`.
-    // Ideally this could be expressed simply as `-X` rather than `2^N - X`, but
-    // for types smaller than int, this calculation is incorrect due to integer
-    // promotion rules.
-    const unsigned_type threshold =
-        ((std::numeric_limits<unsigned_type>::max)() - Lim + 1) % Lim;
-    while (helper::lo(product) < threshold) {
-      bits = fast_bits(g);
-      product = helper::multiply(bits, Lim);
-    }
-  }
-
-  return helper::hi(product);
-}
-
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/uniform_real_distribution.h b/CAPI/cpp/grpc/include/absl/random/uniform_real_distribution.h
index 1968334..8bc215b 100644
--- a/CAPI/cpp/grpc/include/absl/random/uniform_real_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/uniform_real_distribution.h
@@ -44,159 +44,212 @@
 #include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::uniform_real_distribution<T>
-//
-// This distribution produces random floating-point values uniformly distributed
-// over the half-open interval [a, b).
-//
-// Example:
-//
-//   absl::BitGen gen;
-//
-//   // Use the distribution to produce a value between 0.0 (inclusive)
-//   // and 1.0 (exclusive).
-//   double value = absl::uniform_real_distribution<double>(0, 1)(gen);
-//
-template <typename RealType = double>
-class uniform_real_distribution {
- public:
-  using result_type = RealType;
-
-  class param_type {
-   public:
-    using distribution_type = uniform_real_distribution;
-
-    explicit param_type(result_type lo = 0, result_type hi = 1)
-        : lo_(lo), hi_(hi), range_(hi - lo) {
-      // [rand.dist.uni.real] preconditions 2 & 3
-      assert(lo <= hi);
-
-      // NOTE: For integral types, we can promote the range to an unsigned type,
-      // which gives full width of the range. However for real (fp) types, this
-      // is not possible, so value generation cannot use the full range of the
-      // real type.
-      assert(range_ <= (std::numeric_limits<result_type>::max)());
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::uniform_real_distribution<T>
+    //
+    // This distribution produces random floating-point values uniformly distributed
+    // over the half-open interval [a, b).
+    //
+    // Example:
+    //
+    //   absl::BitGen gen;
+    //
+    //   // Use the distribution to produce a value between 0.0 (inclusive)
+    //   // and 1.0 (exclusive).
+    //   double value = absl::uniform_real_distribution<double>(0, 1)(gen);
+    //
+    template<typename RealType = double>
+    class uniform_real_distribution
+    {
+    public:
+        using result_type = RealType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = uniform_real_distribution;
+
+            explicit param_type(result_type lo = 0, result_type hi = 1) :
+                lo_(lo),
+                hi_(hi),
+                range_(hi - lo)
+            {
+                // [rand.dist.uni.real] preconditions 2 & 3
+                assert(lo <= hi);
+
+                // NOTE: For integral types, we can promote the range to an unsigned type,
+                // which gives full width of the range. However for real (fp) types, this
+                // is not possible, so value generation cannot use the full range of the
+                // real type.
+                assert(range_ <= (std::numeric_limits<result_type>::max)());
+            }
+
+            result_type a() const
+            {
+                return lo_;
+            }
+            result_type b() const
+            {
+                return hi_;
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.lo_ == b.lo_ && a.hi_ == b.hi_;
+            }
+
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            friend class uniform_real_distribution;
+            result_type lo_, hi_, range_;
+
+            static_assert(std::is_floating_point<RealType>::value, "Class-template absl::uniform_real_distribution<> must be "
+                                                                   "parameterized using a floating-point type.");
+        };
+
+        uniform_real_distribution() :
+            uniform_real_distribution(0)
+        {
+        }
+
+        explicit uniform_real_distribution(result_type lo, result_type hi = 1) :
+            param_(lo, hi)
+        {
+        }
+
+        explicit uniform_real_distribution(const param_type& param) :
+            param_(param)
+        {
+        }
+
+        // uniform_real_distribution<T>::reset()
+        //
+        // Resets the uniform real distribution. Note that this function has no effect
+        // because the distribution already produces independent values.
+        void reset()
+        {
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& gen)
+        {  // NOLINT(runtime/references)
+            return operator()(gen, param_);
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& gen,  // NOLINT(runtime/references)
+                               const param_type& p);
+
+        result_type a() const
+        {
+            return param_.a();
+        }
+        result_type b() const
+        {
+            return param_.b();
+        }
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& params)
+        {
+            param_ = params;
+        }
+
+        result_type(min)() const
+        {
+            return a();
+        }
+        result_type(max)() const
+        {
+            return b();
+        }
+
+        friend bool operator==(const uniform_real_distribution& a, const uniform_real_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const uniform_real_distribution& a, const uniform_real_distribution& b)
+        {
+            return a.param_ != b.param_;
+        }
+
+    private:
+        param_type param_;
+        random_internal::FastUniformBits<uint64_t> fast_u64_;
+    };
+
+    // -----------------------------------------------------------------------------
+    // Implementation details follow
+    // -----------------------------------------------------------------------------
+    template<typename RealType>
+    template<typename URBG>
+    typename uniform_real_distribution<RealType>::result_type
+        uniform_real_distribution<RealType>::operator()(
+            URBG& gen, const param_type& p
+        )
+    {  // NOLINT(runtime/references)
+        using random_internal::GeneratePositiveTag;
+        using random_internal::GenerateRealFromBits;
+        using real_type =
+            absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+
+        while (true)
+        {
+            const result_type sample =
+                GenerateRealFromBits<real_type, GeneratePositiveTag, true>(
+                    fast_u64_(gen)
+                );
+            const result_type res = p.a() + (sample * p.range_);
+            if (res < p.b() || p.range_ <= 0 || !std::isfinite(p.range_))
+            {
+                return res;
+            }
+            // else sample rejected, try again.
+        }
     }
 
-    result_type a() const { return lo_; }
-    result_type b() const { return hi_; }
-
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.lo_ == b.lo_ && a.hi_ == b.hi_;
-    }
-
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
+    template<typename CharT, typename Traits, typename RealType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const uniform_real_distribution<RealType>& x
+    )
+    {
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
+        os << x.a() << os.fill() << x.b();
+        return os;
     }
 
-   private:
-    friend class uniform_real_distribution;
-    result_type lo_, hi_, range_;
-
-    static_assert(std::is_floating_point<RealType>::value,
-                  "Class-template absl::uniform_real_distribution<> must be "
-                  "parameterized using a floating-point type.");
-  };
-
-  uniform_real_distribution() : uniform_real_distribution(0) {}
-
-  explicit uniform_real_distribution(result_type lo, result_type hi = 1)
-      : param_(lo, hi) {}
-
-  explicit uniform_real_distribution(const param_type& param) : param_(param) {}
-
-  // uniform_real_distribution<T>::reset()
-  //
-  // Resets the uniform real distribution. Note that this function has no effect
-  // because the distribution already produces independent values.
-  void reset() {}
-
-  template <typename URBG>
-  result_type operator()(URBG& gen) {  // NOLINT(runtime/references)
-    return operator()(gen, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& gen,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  result_type a() const { return param_.a(); }
-  result_type b() const { return param_.b(); }
-
-  param_type param() const { return param_; }
-  void param(const param_type& params) { param_ = params; }
-
-  result_type(min)() const { return a(); }
-  result_type(max)() const { return b(); }
-
-  friend bool operator==(const uniform_real_distribution& a,
-                         const uniform_real_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const uniform_real_distribution& a,
-                         const uniform_real_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  param_type param_;
-  random_internal::FastUniformBits<uint64_t> fast_u64_;
-};
-
-// -----------------------------------------------------------------------------
-// Implementation details follow
-// -----------------------------------------------------------------------------
-template <typename RealType>
-template <typename URBG>
-typename uniform_real_distribution<RealType>::result_type
-uniform_real_distribution<RealType>::operator()(
-    URBG& gen, const param_type& p) {  // NOLINT(runtime/references)
-  using random_internal::GeneratePositiveTag;
-  using random_internal::GenerateRealFromBits;
-  using real_type =
-      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
-
-  while (true) {
-    const result_type sample =
-        GenerateRealFromBits<real_type, GeneratePositiveTag, true>(
-            fast_u64_(gen));
-    const result_type res = p.a() + (sample * p.range_);
-    if (res < p.b() || p.range_ <= 0 || !std::isfinite(p.range_)) {
-      return res;
+    template<typename CharT, typename Traits, typename RealType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        uniform_real_distribution<RealType>& x
+    )
+    {  // NOLINT(runtime/references)
+        using param_type = typename uniform_real_distribution<RealType>::param_type;
+        using result_type = typename uniform_real_distribution<RealType>::result_type;
+        auto saver = random_internal::make_istream_state_saver(is);
+        auto a = random_internal::read_floating_point<result_type>(is);
+        if (is.fail())
+            return is;
+        auto b = random_internal::read_floating_point<result_type>(is);
+        if (!is.fail())
+        {
+            x.param(param_type(a, b));
+        }
+        return is;
     }
-    // else sample rejected, try again.
-  }
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const uniform_real_distribution<RealType>& x) {
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
-  os << x.a() << os.fill() << x.b();
-  return os;
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,     // NOLINT(runtime/references)
-    uniform_real_distribution<RealType>& x) {  // NOLINT(runtime/references)
-  using param_type = typename uniform_real_distribution<RealType>::param_type;
-  using result_type = typename uniform_real_distribution<RealType>::result_type;
-  auto saver = random_internal::make_istream_state_saver(is);
-  auto a = random_internal::read_floating_point<result_type>(is);
-  if (is.fail()) return is;
-  auto b = random_internal::read_floating_point<result_type>(is);
-  if (!is.fail()) {
-    x.param(param_type(a, b));
-  }
-  return is;
-}
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_UNIFORM_REAL_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/random/zipf_distribution.h b/CAPI/cpp/grpc/include/absl/random/zipf_distribution.h
index 03497b1..37c1c09 100644
--- a/CAPI/cpp/grpc/include/absl/random/zipf_distribution.h
+++ b/CAPI/cpp/grpc/include/absl/random/zipf_distribution.h
@@ -26,247 +26,312 @@
 #include "absl/random/internal/traits.h"
 #include "absl/random/uniform_real_distribution.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::zipf_distribution produces random integer-values in the range [0, k],
+    // distributed according to the unnormalized discrete probability function:
+    //
+    //  P(x) = (v + x) ^ -q
+    //
+    // The parameter `v` must be greater than 0 and the parameter `q` must be
+    // greater than 1. If either of these parameters take invalid values then the
+    // behavior is undefined.
+    //
+    // IntType is the result_type generated by the generator. It must be of integral
+    // type; a static_assert ensures this is the case.
+    //
+    // The implementation is based on W.Hormann, G.Derflinger:
+    //
+    // "Rejection-Inversion to Generate Variates from Monotone Discrete
+    // Distributions"
+    //
+    // http://eeyore.wu-wien.ac.at/papers/96-04-04.wh-der.ps.gz
+    //
+    template<typename IntType = int>
+    class zipf_distribution
+    {
+    public:
+        using result_type = IntType;
+
+        class param_type
+        {
+        public:
+            using distribution_type = zipf_distribution;
+
+            // Preconditions: k > 0, v > 0, q > 1
+            // The precondidtions are validated when NDEBUG is not defined via
+            // a pair of assert() directives.
+            // If NDEBUG is defined and either or both of these parameters take invalid
+            // values, the behavior of the class is undefined.
+            explicit param_type(result_type k = (std::numeric_limits<IntType>::max)(), double q = 2.0, double v = 1.0);
+
+            result_type k() const
+            {
+                return k_;
+            }
+            double q() const
+            {
+                return q_;
+            }
+            double v() const
+            {
+                return v_;
+            }
+
+            friend bool operator==(const param_type& a, const param_type& b)
+            {
+                return a.k_ == b.k_ && a.q_ == b.q_ && a.v_ == b.v_;
+            }
+            friend bool operator!=(const param_type& a, const param_type& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            friend class zipf_distribution;
+            inline double h(double x) const;
+            inline double hinv(double x) const;
+            inline double compute_s() const;
+            inline double pow_negative_q(double x) const;
+
+            // Parameters here are exactly the same as the parameters of Algorithm ZRI
+            // in the paper.
+            IntType k_;
+            double q_;
+            double v_;
+
+            double one_minus_q_;  // 1-q
+            double s_;
+            double one_minus_q_inv_;  // 1 / 1-q
+            double hxm_;              // h(k + 0.5)
+            double hx0_minus_hxm_;    // h(x0) - h(k + 0.5)
+
+            static_assert(random_internal::IsIntegral<IntType>::value, "Class-template absl::zipf_distribution<> must be "
+                                                                       "parameterized using an integral type.");
+        };
+
+        zipf_distribution() :
+            zipf_distribution((std::numeric_limits<IntType>::max)())
+        {
+        }
+
+        explicit zipf_distribution(result_type k, double q = 2.0, double v = 1.0) :
+            param_(k, q, v)
+        {
+        }
+
+        explicit zipf_distribution(const param_type& p) :
+            param_(p)
+        {
+        }
+
+        void reset()
+        {
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& g)
+        {  // NOLINT(runtime/references)
+            return (*this)(g, param_);
+        }
+
+        template<typename URBG>
+        result_type operator()(URBG& g,  // NOLINT(runtime/references)
+                               const param_type& p);
+
+        result_type k() const
+        {
+            return param_.k();
+        }
+        double q() const
+        {
+            return param_.q();
+        }
+        double v() const
+        {
+            return param_.v();
+        }
+
+        param_type param() const
+        {
+            return param_;
+        }
+        void param(const param_type& p)
+        {
+            param_ = p;
+        }
+
+        result_type(min)() const
+        {
+            return 0;
+        }
+        result_type(max)() const
+        {
+            return k();
+        }
+
+        friend bool operator==(const zipf_distribution& a, const zipf_distribution& b)
+        {
+            return a.param_ == b.param_;
+        }
+        friend bool operator!=(const zipf_distribution& a, const zipf_distribution& b)
+        {
+            return a.param_ != b.param_;
+        }
+
+    private:
+        param_type param_;
+    };
+
+    // --------------------------------------------------------------------------
+    // Implementation details follow
+    // --------------------------------------------------------------------------
+
+    template<typename IntType>
+    zipf_distribution<IntType>::param_type::param_type(
+        typename zipf_distribution<IntType>::result_type k, double q, double v
+    ) :
+        k_(k),
+        q_(q),
+        v_(v),
+        one_minus_q_(1 - q)
+    {
+        assert(q > 1);
+        assert(v > 0);
+        assert(k > 0);
+        one_minus_q_inv_ = 1 / one_minus_q_;
+
+        // Setup for the ZRI algorithm (pg 17 of the paper).
+        // Compute: h(i max) => h(k + 0.5)
+        constexpr double kMax = 18446744073709549568.0;
+        double kd = static_cast<double>(k);
+        // TODO(absl-team): Determine if this check is needed, and if so, add a test
+        // that fails for k > kMax
+        if (kd > kMax)
+        {
+            // Ensure that our maximum value is capped to a value which will
+            // round-trip back through double.
+            kd = kMax;
+        }
+        hxm_ = h(kd + 0.5);
+
+        // Compute: h(0)
+        const bool use_precomputed = (v == 1.0 && q == 2.0);
+        const double h0x5 = use_precomputed ? (-1.0 / 1.5)  // exp(-log(1.5))
+                                              :
+                                              h(0.5);
+        const double elogv_q = (v_ == 1.0) ? 1 : pow_negative_q(v_);
+
+        // h(0) = h(0.5) - exp(log(v) * -q)
+        hx0_minus_hxm_ = (h0x5 - elogv_q) - hxm_;
+
+        // And s
+        s_ = use_precomputed ? 0.46153846153846123 : compute_s();
+    }
 
-// absl::zipf_distribution produces random integer-values in the range [0, k],
-// distributed according to the unnormalized discrete probability function:
-//
-//  P(x) = (v + x) ^ -q
-//
-// The parameter `v` must be greater than 0 and the parameter `q` must be
-// greater than 1. If either of these parameters take invalid values then the
-// behavior is undefined.
-//
-// IntType is the result_type generated by the generator. It must be of integral
-// type; a static_assert ensures this is the case.
-//
-// The implementation is based on W.Hormann, G.Derflinger:
-//
-// "Rejection-Inversion to Generate Variates from Monotone Discrete
-// Distributions"
-//
-// http://eeyore.wu-wien.ac.at/papers/96-04-04.wh-der.ps.gz
-//
-template <typename IntType = int>
-class zipf_distribution {
- public:
-  using result_type = IntType;
-
-  class param_type {
-   public:
-    using distribution_type = zipf_distribution;
-
-    // Preconditions: k > 0, v > 0, q > 1
-    // The precondidtions are validated when NDEBUG is not defined via
-    // a pair of assert() directives.
-    // If NDEBUG is defined and either or both of these parameters take invalid
-    // values, the behavior of the class is undefined.
-    explicit param_type(result_type k = (std::numeric_limits<IntType>::max)(),
-                        double q = 2.0, double v = 1.0);
-
-    result_type k() const { return k_; }
-    double q() const { return q_; }
-    double v() const { return v_; }
-
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.k_ == b.k_ && a.q_ == b.q_ && a.v_ == b.v_;
+    template<typename IntType>
+    double zipf_distribution<IntType>::param_type::h(double x) const
+    {
+        // std::exp(one_minus_q_ * std::log(v_ + x)) * one_minus_q_inv_;
+        x += v_;
+        return (one_minus_q_ == -1.0) ? (-1.0 / x)  // -exp(-log(x))
+                                        :
+                                        (std::exp(std::log(x) * one_minus_q_) * one_minus_q_inv_);
+    }
+
+    template<typename IntType>
+    double zipf_distribution<IntType>::param_type::hinv(double x) const
+    {
+        // std::exp(one_minus_q_inv_ * std::log(one_minus_q_ * x)) - v_;
+        return -v_ + ((one_minus_q_ == -1.0) ? (-1.0 / x)  // exp(-log(-x))
+                                               :
+                                               std::exp(one_minus_q_inv_ * std::log(one_minus_q_ * x)));
     }
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
+
+    template<typename IntType>
+    double zipf_distribution<IntType>::param_type::compute_s() const
+    {
+        // 1 - hinv(h(1.5) - std::exp(std::log(v_ + 1) * -q_));
+        return 1.0 - hinv(h(1.5) - pow_negative_q(v_ + 1.0));
+    }
+
+    template<typename IntType>
+    double zipf_distribution<IntType>::param_type::pow_negative_q(double x) const
+    {
+        // std::exp(std::log(x) * -q_);
+        return q_ == 2.0 ? (1.0 / (x * x)) : std::exp(std::log(x) * -q_);
+    }
+
+    template<typename IntType>
+    template<typename URBG>
+    typename zipf_distribution<IntType>::result_type
+        zipf_distribution<IntType>::operator()(
+            URBG& g, const param_type& p
+        )
+    {  // NOLINT(runtime/references)
+        absl::uniform_real_distribution<double> uniform_double;
+        double k;
+        for (;;)
+        {
+            const double v = uniform_double(g);
+            const double u = p.hxm_ + v * p.hx0_minus_hxm_;
+            const double x = p.hinv(u);
+            k = rint(x);  // std::floor(x + 0.5);
+            if (k > static_cast<double>(p.k()))
+                continue;  // reject k > max_k
+            if (k - x <= p.s_)
+                break;
+            const double h = p.h(k + 0.5);
+            const double r = p.pow_negative_q(p.v_ + k);
+            if (u >= h - r)
+                break;
+        }
+        IntType ki = static_cast<IntType>(k);
+        assert(ki <= p.k_);
+        return ki;
+    }
+
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_ostream<CharT, Traits>& operator<<(
+        std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
+        const zipf_distribution<IntType>& x
+    )
+    {
+        using stream_type =
+            typename random_internal::stream_format_type<IntType>::type;
+        auto saver = random_internal::make_ostream_state_saver(os);
+        os.precision(random_internal::stream_precision_helper<double>::kPrecision);
+        os << static_cast<stream_type>(x.k()) << os.fill() << x.q() << os.fill()
+           << x.v();
+        return os;
+    }
+
+    template<typename CharT, typename Traits, typename IntType>
+    std::basic_istream<CharT, Traits>& operator>>(
+        std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+        zipf_distribution<IntType>& x
+    )
+    {  // NOLINT(runtime/references)
+        using result_type = typename zipf_distribution<IntType>::result_type;
+        using param_type = typename zipf_distribution<IntType>::param_type;
+        using stream_type =
+            typename random_internal::stream_format_type<IntType>::type;
+        stream_type k;
+        double q;
+        double v;
+
+        auto saver = random_internal::make_istream_state_saver(is);
+        is >> k >> q >> v;
+        if (!is.fail())
+        {
+            x.param(param_type(static_cast<result_type>(k), q, v));
+        }
+        return is;
     }
 
-   private:
-    friend class zipf_distribution;
-    inline double h(double x) const;
-    inline double hinv(double x) const;
-    inline double compute_s() const;
-    inline double pow_negative_q(double x) const;
-
-    // Parameters here are exactly the same as the parameters of Algorithm ZRI
-    // in the paper.
-    IntType k_;
-    double q_;
-    double v_;
-
-    double one_minus_q_;  // 1-q
-    double s_;
-    double one_minus_q_inv_;  // 1 / 1-q
-    double hxm_;              // h(k + 0.5)
-    double hx0_minus_hxm_;    // h(x0) - h(k + 0.5)
-
-    static_assert(random_internal::IsIntegral<IntType>::value,
-                  "Class-template absl::zipf_distribution<> must be "
-                  "parameterized using an integral type.");
-  };
-
-  zipf_distribution()
-      : zipf_distribution((std::numeric_limits<IntType>::max)()) {}
-
-  explicit zipf_distribution(result_type k, double q = 2.0, double v = 1.0)
-      : param_(k, q, v) {}
-
-  explicit zipf_distribution(const param_type& p) : param_(p) {}
-
-  void reset() {}
-
-  template <typename URBG>
-  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
-    return (*this)(g, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  result_type k() const { return param_.k(); }
-  double q() const { return param_.q(); }
-  double v() const { return param_.v(); }
-
-  param_type param() const { return param_; }
-  void param(const param_type& p) { param_ = p; }
-
-  result_type(min)() const { return 0; }
-  result_type(max)() const { return k(); }
-
-  friend bool operator==(const zipf_distribution& a,
-                         const zipf_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const zipf_distribution& a,
-                         const zipf_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  param_type param_;
-};
-
-// --------------------------------------------------------------------------
-// Implementation details follow
-// --------------------------------------------------------------------------
-
-template <typename IntType>
-zipf_distribution<IntType>::param_type::param_type(
-    typename zipf_distribution<IntType>::result_type k, double q, double v)
-    : k_(k), q_(q), v_(v), one_minus_q_(1 - q) {
-  assert(q > 1);
-  assert(v > 0);
-  assert(k > 0);
-  one_minus_q_inv_ = 1 / one_minus_q_;
-
-  // Setup for the ZRI algorithm (pg 17 of the paper).
-  // Compute: h(i max) => h(k + 0.5)
-  constexpr double kMax = 18446744073709549568.0;
-  double kd = static_cast<double>(k);
-  // TODO(absl-team): Determine if this check is needed, and if so, add a test
-  // that fails for k > kMax
-  if (kd > kMax) {
-    // Ensure that our maximum value is capped to a value which will
-    // round-trip back through double.
-    kd = kMax;
-  }
-  hxm_ = h(kd + 0.5);
-
-  // Compute: h(0)
-  const bool use_precomputed = (v == 1.0 && q == 2.0);
-  const double h0x5 = use_precomputed ? (-1.0 / 1.5)  // exp(-log(1.5))
-                                      : h(0.5);
-  const double elogv_q = (v_ == 1.0) ? 1 : pow_negative_q(v_);
-
-  // h(0) = h(0.5) - exp(log(v) * -q)
-  hx0_minus_hxm_ = (h0x5 - elogv_q) - hxm_;
-
-  // And s
-  s_ = use_precomputed ? 0.46153846153846123 : compute_s();
-}
-
-template <typename IntType>
-double zipf_distribution<IntType>::param_type::h(double x) const {
-  // std::exp(one_minus_q_ * std::log(v_ + x)) * one_minus_q_inv_;
-  x += v_;
-  return (one_minus_q_ == -1.0)
-             ? (-1.0 / x)  // -exp(-log(x))
-             : (std::exp(std::log(x) * one_minus_q_) * one_minus_q_inv_);
-}
-
-template <typename IntType>
-double zipf_distribution<IntType>::param_type::hinv(double x) const {
-  // std::exp(one_minus_q_inv_ * std::log(one_minus_q_ * x)) - v_;
-  return -v_ + ((one_minus_q_ == -1.0)
-                    ? (-1.0 / x)  // exp(-log(-x))
-                    : std::exp(one_minus_q_inv_ * std::log(one_minus_q_ * x)));
-}
-
-template <typename IntType>
-double zipf_distribution<IntType>::param_type::compute_s() const {
-  // 1 - hinv(h(1.5) - std::exp(std::log(v_ + 1) * -q_));
-  return 1.0 - hinv(h(1.5) - pow_negative_q(v_ + 1.0));
-}
-
-template <typename IntType>
-double zipf_distribution<IntType>::param_type::pow_negative_q(double x) const {
-  // std::exp(std::log(x) * -q_);
-  return q_ == 2.0 ? (1.0 / (x * x)) : std::exp(std::log(x) * -q_);
-}
-
-template <typename IntType>
-template <typename URBG>
-typename zipf_distribution<IntType>::result_type
-zipf_distribution<IntType>::operator()(
-    URBG& g, const param_type& p) {  // NOLINT(runtime/references)
-  absl::uniform_real_distribution<double> uniform_double;
-  double k;
-  for (;;) {
-    const double v = uniform_double(g);
-    const double u = p.hxm_ + v * p.hx0_minus_hxm_;
-    const double x = p.hinv(u);
-    k = rint(x);              // std::floor(x + 0.5);
-    if (k > static_cast<double>(p.k())) continue;  // reject k > max_k
-    if (k - x <= p.s_) break;
-    const double h = p.h(k + 0.5);
-    const double r = p.pow_negative_q(p.v_ + k);
-    if (u >= h - r) break;
-  }
-  IntType ki = static_cast<IntType>(k);
-  assert(ki <= p.k_);
-  return ki;
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const zipf_distribution<IntType>& x) {
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os.precision(random_internal::stream_precision_helper<double>::kPrecision);
-  os << static_cast<stream_type>(x.k()) << os.fill() << x.q() << os.fill()
-     << x.v();
-  return os;
-}
-
-template <typename CharT, typename Traits, typename IntType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
-    zipf_distribution<IntType>& x) {        // NOLINT(runtime/references)
-  using result_type = typename zipf_distribution<IntType>::result_type;
-  using param_type = typename zipf_distribution<IntType>::param_type;
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-  stream_type k;
-  double q;
-  double v;
-
-  auto saver = random_internal::make_istream_state_saver(is);
-  is >> k >> q >> v;
-  if (!is.fail()) {
-    x.param(param_type(static_cast<result_type>(k), q, v));
-  }
-  return is;
-}
-
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_RANDOM_ZIPF_DISTRIBUTION_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/internal/status_internal.h b/CAPI/cpp/grpc/include/absl/status/internal/status_internal.h
index 19a4a7a..1db8887 100644
--- a/CAPI/cpp/grpc/include/absl/status/internal/status_internal.h
+++ b/CAPI/cpp/grpc/include/absl/status/internal/status_internal.h
@@ -23,64 +23,69 @@
 
 #ifndef SWIG
 // Disabled for SWIG as it doesn't parse attributes correctly.
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 // Returned Status objects may not be ignored. Codesearch doesn't handle ifdefs
 // as part of a class definitions (b/6995610), so we use a forward declaration.
 //
 // TODO(b/176172494): ABSL_MUST_USE_RESULT should expand to the more strict
 // [[nodiscard]]. For now, just use [[nodiscard]] directly when it is available.
 #if ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
-class [[nodiscard]] Status;
+    class [[nodiscard]] Status;
 #else
-class ABSL_MUST_USE_RESULT Status;
+    class ABSL_MUST_USE_RESULT Status;
 #endif
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // !SWIG
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-enum class StatusCode : int;
+    enum class StatusCode : int;
 
-namespace status_internal {
+    namespace status_internal
+    {
 
-// Container for status payloads.
-struct Payload {
-  std::string type_url;
-  absl::Cord payload;
-};
+        // Container for status payloads.
+        struct Payload
+        {
+            std::string type_url;
+            absl::Cord payload;
+        };
 
-using Payloads = absl::InlinedVector<Payload, 1>;
+        using Payloads = absl::InlinedVector<Payload, 1>;
 
-// Reference-counted representation of Status data.
-struct StatusRep {
-  StatusRep(absl::StatusCode code_arg, absl::string_view message_arg,
-            std::unique_ptr<status_internal::Payloads> payloads_arg)
-      : ref(int32_t{1}),
-        code(code_arg),
-        message(message_arg),
-        payloads(std::move(payloads_arg)) {}
+        // Reference-counted representation of Status data.
+        struct StatusRep
+        {
+            StatusRep(absl::StatusCode code_arg, absl::string_view message_arg, std::unique_ptr<status_internal::Payloads> payloads_arg) :
+                ref(int32_t{1}),
+                code(code_arg),
+                message(message_arg),
+                payloads(std::move(payloads_arg))
+            {
+            }
 
-  std::atomic<int32_t> ref;
-  absl::StatusCode code;
-  std::string message;
-  std::unique_ptr<status_internal::Payloads> payloads;
-};
+            std::atomic<int32_t> ref;
+            absl::StatusCode code;
+            std::string message;
+            std::unique_ptr<status_internal::Payloads> payloads;
+        };
 
-absl::StatusCode MapToLocalCode(int value);
+        absl::StatusCode MapToLocalCode(int value);
 
-// Returns a pointer to a newly-allocated string with the given `prefix`,
-// suitable for output as an error message in assertion/`CHECK()` failures.
-//
-// This is an internal implementation detail for Abseil logging.
-std::string* MakeCheckFailString(const absl::Status* status,
-                                 const char* prefix);
+        // Returns a pointer to a newly-allocated string with the given `prefix`,
+        // suitable for output as an error message in assertion/`CHECK()` failures.
+        //
+        // This is an internal implementation detail for Abseil logging.
+        std::string* MakeCheckFailString(const absl::Status* status, const char* prefix);
 
-}  // namespace status_internal
+    }  // namespace status_internal
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/internal/statusor_internal.h b/CAPI/cpp/grpc/include/absl/status/internal/statusor_internal.h
index eaac2c0..37a36ba 100644
--- a/CAPI/cpp/grpc/include/absl/status/internal/statusor_internal.h
+++ b/CAPI/cpp/grpc/include/absl/status/internal/statusor_internal.h
@@ -22,375 +22,415 @@
 #include "absl/status/status.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
-
-namespace internal_statusor {
-
-// Detects whether `U` has conversion operator to `StatusOr<T>`, i.e. `operator
-// StatusOr<T>()`.
-template <typename T, typename U, typename = void>
-struct HasConversionOperatorToStatusOr : std::false_type {};
-
-template <typename T, typename U>
-void test(char (*)[sizeof(std::declval<U>().operator absl::StatusOr<T>())]);
-
-template <typename T, typename U>
-struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))>
-    : std::true_type {};
-
-// Detects whether `T` is constructible or convertible from `StatusOr<U>`.
-template <typename T, typename U>
-using IsConstructibleOrConvertibleFromStatusOr =
-    absl::disjunction<std::is_constructible<T, StatusOr<U>&>,
-                      std::is_constructible<T, const StatusOr<U>&>,
-                      std::is_constructible<T, StatusOr<U>&&>,
-                      std::is_constructible<T, const StatusOr<U>&&>,
-                      std::is_convertible<StatusOr<U>&, T>,
-                      std::is_convertible<const StatusOr<U>&, T>,
-                      std::is_convertible<StatusOr<U>&&, T>,
-                      std::is_convertible<const StatusOr<U>&&, T>>;
-
-// Detects whether `T` is constructible or convertible or assignable from
-// `StatusOr<U>`.
-template <typename T, typename U>
-using IsConstructibleOrConvertibleOrAssignableFromStatusOr =
-    absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>,
-                      std::is_assignable<T&, StatusOr<U>&>,
-                      std::is_assignable<T&, const StatusOr<U>&>,
-                      std::is_assignable<T&, StatusOr<U>&&>,
-                      std::is_assignable<T&, const StatusOr<U>&&>>;
-
-// Detects whether direct initializing `StatusOr<T>` from `U` is ambiguous, i.e.
-// when `U` is `StatusOr<V>` and `T` is constructible or convertible from `V`.
-template <typename T, typename U>
-struct IsDirectInitializationAmbiguous
-    : public absl::conditional_t<
-          std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>,
-                       U>::value,
-          std::false_type,
-          IsDirectInitializationAmbiguous<
-              T, absl::remove_cv_t<absl::remove_reference_t<U>>>> {};
-
-template <typename T, typename V>
-struct IsDirectInitializationAmbiguous<T, absl::StatusOr<V>>
-    : public IsConstructibleOrConvertibleFromStatusOr<T, V> {};
-
-// Checks against the constraints of the direction initialization, i.e. when
-// `StatusOr<T>::StatusOr(U&&)` should participate in overload resolution.
-template <typename T, typename U>
-using IsDirectInitializationValid = absl::disjunction<
-    // Short circuits if T is basically U.
-    std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>,
-    absl::negation<absl::disjunction<
-        std::is_same<absl::StatusOr<T>,
-                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
-        std::is_same<absl::Status,
-                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
-        std::is_same<absl::in_place_t,
-                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
-        IsDirectInitializationAmbiguous<T, U>>>>;
-
-// This trait detects whether `StatusOr<T>::operator=(U&&)` is ambiguous, which
-// is equivalent to whether all the following conditions are met:
-// 1. `U` is `StatusOr<V>`.
-// 2. `T` is constructible and assignable from `V`.
-// 3. `T` is constructible and assignable from `U` (i.e. `StatusOr<V>`).
-// For example, the following code is considered ambiguous:
-// (`T` is `bool`, `U` is `StatusOr<bool>`, `V` is `bool`)
-//   StatusOr<bool> s1 = true;  // s1.ok() && s1.ValueOrDie() == true
-//   StatusOr<bool> s2 = false;  // s2.ok() && s2.ValueOrDie() == false
-//   s1 = s2;  // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`?
-template <typename T, typename U>
-struct IsForwardingAssignmentAmbiguous
-    : public absl::conditional_t<
-          std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>,
-                       U>::value,
-          std::false_type,
-          IsForwardingAssignmentAmbiguous<
-              T, absl::remove_cv_t<absl::remove_reference_t<U>>>> {};
-
-template <typename T, typename U>
-struct IsForwardingAssignmentAmbiguous<T, absl::StatusOr<U>>
-    : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U> {};
-
-// Checks against the constraints of the forwarding assignment, i.e. whether
-// `StatusOr<T>::operator(U&&)` should participate in overload resolution.
-template <typename T, typename U>
-using IsForwardingAssignmentValid = absl::disjunction<
-    // Short circuits if T is basically U.
-    std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>,
-    absl::negation<absl::disjunction<
-        std::is_same<absl::StatusOr<T>,
-                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
-        std::is_same<absl::Status,
-                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
-        std::is_same<absl::in_place_t,
-                     absl::remove_cv_t<absl::remove_reference_t<U>>>,
-        IsForwardingAssignmentAmbiguous<T, U>>>>;
-
-class Helper {
- public:
-  // Move type-agnostic error handling to the .cc.
-  static void HandleInvalidStatusCtorArg(Status*);
-  ABSL_ATTRIBUTE_NORETURN static void Crash(const absl::Status& status);
-};
-
-// Construct an instance of T in `p` through placement new, passing Args... to
-// the constructor.
-// This abstraction is here mostly for the gcc performance fix.
-template <typename T, typename... Args>
-ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* p, Args&&... args) {
-  new (p) T(std::forward<Args>(args)...);
-}
-
-// Helper base class to hold the data and all operations.
-// We move all this to a base class to allow mixing with the appropriate
-// TraitsBase specialization.
-template <typename T>
-class StatusOrData {
-  template <typename U>
-  friend class StatusOrData;
-
- public:
-  StatusOrData() = delete;
-
-  StatusOrData(const StatusOrData& other) {
-    if (other.ok()) {
-      MakeValue(other.data_);
-      MakeStatus();
-    } else {
-      MakeStatus(other.status_);
-    }
-  }
-
-  StatusOrData(StatusOrData&& other) noexcept {
-    if (other.ok()) {
-      MakeValue(std::move(other.data_));
-      MakeStatus();
-    } else {
-      MakeStatus(std::move(other.status_));
-    }
-  }
-
-  template <typename U>
-  explicit StatusOrData(const StatusOrData<U>& other) {
-    if (other.ok()) {
-      MakeValue(other.data_);
-      MakeStatus();
-    } else {
-      MakeStatus(other.status_);
-    }
-  }
-
-  template <typename U>
-  explicit StatusOrData(StatusOrData<U>&& other) {
-    if (other.ok()) {
-      MakeValue(std::move(other.data_));
-      MakeStatus();
-    } else {
-      MakeStatus(std::move(other.status_));
-    }
-  }
-
-  template <typename... Args>
-  explicit StatusOrData(absl::in_place_t, Args&&... args)
-      : data_(std::forward<Args>(args)...) {
-    MakeStatus();
-  }
-
-  explicit StatusOrData(const T& value) : data_(value) {
-    MakeStatus();
-  }
-  explicit StatusOrData(T&& value) : data_(std::move(value)) {
-    MakeStatus();
-  }
-
-  template <typename U,
-            absl::enable_if_t<std::is_constructible<absl::Status, U&&>::value,
-                              int> = 0>
-  explicit StatusOrData(U&& v) : status_(std::forward<U>(v)) {
-    EnsureNotOk();
-  }
-
-  StatusOrData& operator=(const StatusOrData& other) {
-    if (this == &other) return *this;
-    if (other.ok())
-      Assign(other.data_);
-    else
-      AssignStatus(other.status_);
-    return *this;
-  }
-
-  StatusOrData& operator=(StatusOrData&& other) {
-    if (this == &other) return *this;
-    if (other.ok())
-      Assign(std::move(other.data_));
-    else
-      AssignStatus(std::move(other.status_));
-    return *this;
-  }
-
-  ~StatusOrData() {
-    if (ok()) {
-      status_.~Status();
-      data_.~T();
-    } else {
-      status_.~Status();
-    }
-  }
-
-  template <typename U>
-  void Assign(U&& value) {
-    if (ok()) {
-      data_ = std::forward<U>(value);
-    } else {
-      MakeValue(std::forward<U>(value));
-      status_ = OkStatus();
-    }
-  }
-
-  template <typename U>
-  void AssignStatus(U&& v) {
-    Clear();
-    status_ = static_cast<absl::Status>(std::forward<U>(v));
-    EnsureNotOk();
-  }
-
-  bool ok() const { return status_.ok(); }
-
- protected:
-  // status_ will always be active after the constructor.
-  // We make it a union to be able to initialize exactly how we need without
-  // waste.
-  // Eg. in the copy constructor we use the default constructor of Status in
-  // the ok() path to avoid an extra Ref call.
-  union {
-    Status status_;
-  };
-
-  // data_ is active iff status_.ok()==true
-  struct Dummy {};
-  union {
-    // When T is const, we need some non-const object we can cast to void* for
-    // the placement new. dummy_ is that object.
-    Dummy dummy_;
-    T data_;
-  };
-
-  void Clear() {
-    if (ok()) data_.~T();
-  }
-
-  void EnsureOk() const {
-    if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_);
-  }
-
-  void EnsureNotOk() {
-    if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_);
-  }
-
-  // Construct the value (ie. data_) through placement new with the passed
-  // argument.
-  template <typename... Arg>
-  void MakeValue(Arg&&... arg) {
-    internal_statusor::PlacementNew<T>(&dummy_, std::forward<Arg>(arg)...);
-  }
-
-  // Construct the status (ie. status_) through placement new with the passed
-  // argument.
-  template <typename... Args>
-  void MakeStatus(Args&&... args) {
-    internal_statusor::PlacementNew<Status>(&status_,
-                                            std::forward<Args>(args)...);
-  }
-};
-
-// Helper base classes to allow implicitly deleted constructors and assignment
-// operators in `StatusOr`. For example, `CopyCtorBase` will explicitly delete
-// the copy constructor when T is not copy constructible and `StatusOr` will
-// inherit that behavior implicitly.
-template <typename T, bool = std::is_copy_constructible<T>::value>
-struct CopyCtorBase {
-  CopyCtorBase() = default;
-  CopyCtorBase(const CopyCtorBase&) = default;
-  CopyCtorBase(CopyCtorBase&&) = default;
-  CopyCtorBase& operator=(const CopyCtorBase&) = default;
-  CopyCtorBase& operator=(CopyCtorBase&&) = default;
-};
-
-template <typename T>
-struct CopyCtorBase<T, false> {
-  CopyCtorBase() = default;
-  CopyCtorBase(const CopyCtorBase&) = delete;
-  CopyCtorBase(CopyCtorBase&&) = default;
-  CopyCtorBase& operator=(const CopyCtorBase&) = default;
-  CopyCtorBase& operator=(CopyCtorBase&&) = default;
-};
-
-template <typename T, bool = std::is_move_constructible<T>::value>
-struct MoveCtorBase {
-  MoveCtorBase() = default;
-  MoveCtorBase(const MoveCtorBase&) = default;
-  MoveCtorBase(MoveCtorBase&&) = default;
-  MoveCtorBase& operator=(const MoveCtorBase&) = default;
-  MoveCtorBase& operator=(MoveCtorBase&&) = default;
-};
-
-template <typename T>
-struct MoveCtorBase<T, false> {
-  MoveCtorBase() = default;
-  MoveCtorBase(const MoveCtorBase&) = default;
-  MoveCtorBase(MoveCtorBase&&) = delete;
-  MoveCtorBase& operator=(const MoveCtorBase&) = default;
-  MoveCtorBase& operator=(MoveCtorBase&&) = default;
-};
-
-template <typename T, bool = std::is_copy_constructible<T>::value&&
-                          std::is_copy_assignable<T>::value>
-struct CopyAssignBase {
-  CopyAssignBase() = default;
-  CopyAssignBase(const CopyAssignBase&) = default;
-  CopyAssignBase(CopyAssignBase&&) = default;
-  CopyAssignBase& operator=(const CopyAssignBase&) = default;
-  CopyAssignBase& operator=(CopyAssignBase&&) = default;
-};
-
-template <typename T>
-struct CopyAssignBase<T, false> {
-  CopyAssignBase() = default;
-  CopyAssignBase(const CopyAssignBase&) = default;
-  CopyAssignBase(CopyAssignBase&&) = default;
-  CopyAssignBase& operator=(const CopyAssignBase&) = delete;
-  CopyAssignBase& operator=(CopyAssignBase&&) = default;
-};
-
-template <typename T, bool = std::is_move_constructible<T>::value&&
-                          std::is_move_assignable<T>::value>
-struct MoveAssignBase {
-  MoveAssignBase() = default;
-  MoveAssignBase(const MoveAssignBase&) = default;
-  MoveAssignBase(MoveAssignBase&&) = default;
-  MoveAssignBase& operator=(const MoveAssignBase&) = default;
-  MoveAssignBase& operator=(MoveAssignBase&&) = default;
-};
-
-template <typename T>
-struct MoveAssignBase<T, false> {
-  MoveAssignBase() = default;
-  MoveAssignBase(const MoveAssignBase&) = default;
-  MoveAssignBase(MoveAssignBase&&) = default;
-  MoveAssignBase& operator=(const MoveAssignBase&) = default;
-  MoveAssignBase& operator=(MoveAssignBase&&) = delete;
-};
-
-ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(absl::Status status);
-
-}  // namespace internal_statusor
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    template<typename T>
+    class ABSL_MUST_USE_RESULT StatusOr;
+
+    namespace internal_statusor
+    {
+
+        // Detects whether `U` has conversion operator to `StatusOr<T>`, i.e. `operator
+        // StatusOr<T>()`.
+        template<typename T, typename U, typename = void>
+        struct HasConversionOperatorToStatusOr : std::false_type
+        {
+        };
+
+        template<typename T, typename U>
+        void test(char (*)[sizeof(std::declval<U>().operator absl::StatusOr<T>())]);
+
+        template<typename T, typename U>
+        struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))> : std::true_type
+        {
+        };
+
+        // Detects whether `T` is constructible or convertible from `StatusOr<U>`.
+        template<typename T, typename U>
+        using IsConstructibleOrConvertibleFromStatusOr =
+            absl::disjunction<std::is_constructible<T, StatusOr<U>&>, std::is_constructible<T, const StatusOr<U>&>, std::is_constructible<T, StatusOr<U>&&>, std::is_constructible<T, const StatusOr<U>&&>, std::is_convertible<StatusOr<U>&, T>, std::is_convertible<const StatusOr<U>&, T>, std::is_convertible<StatusOr<U>&&, T>, std::is_convertible<const StatusOr<U>&&, T>>;
+
+        // Detects whether `T` is constructible or convertible or assignable from
+        // `StatusOr<U>`.
+        template<typename T, typename U>
+        using IsConstructibleOrConvertibleOrAssignableFromStatusOr =
+            absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>, std::is_assignable<T&, StatusOr<U>&>, std::is_assignable<T&, const StatusOr<U>&>, std::is_assignable<T&, StatusOr<U>&&>, std::is_assignable<T&, const StatusOr<U>&&>>;
+
+        // Detects whether direct initializing `StatusOr<T>` from `U` is ambiguous, i.e.
+        // when `U` is `StatusOr<V>` and `T` is constructible or convertible from `V`.
+        template<typename T, typename U>
+        struct IsDirectInitializationAmbiguous : public absl::conditional_t<std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, U>::value, std::false_type, IsDirectInitializationAmbiguous<T, absl::remove_cv_t<absl::remove_reference_t<U>>>>
+        {
+        };
+
+        template<typename T, typename V>
+        struct IsDirectInitializationAmbiguous<T, absl::StatusOr<V>> : public IsConstructibleOrConvertibleFromStatusOr<T, V>
+        {
+        };
+
+        // Checks against the constraints of the direction initialization, i.e. when
+        // `StatusOr<T>::StatusOr(U&&)` should participate in overload resolution.
+        template<typename T, typename U>
+        using IsDirectInitializationValid = absl::disjunction<
+            // Short circuits if T is basically U.
+            std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+            absl::negation<absl::disjunction<
+                std::is_same<absl::StatusOr<T>, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+                std::is_same<absl::Status, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+                std::is_same<absl::in_place_t, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+                IsDirectInitializationAmbiguous<T, U>>>>;
+
+        // This trait detects whether `StatusOr<T>::operator=(U&&)` is ambiguous, which
+        // is equivalent to whether all the following conditions are met:
+        // 1. `U` is `StatusOr<V>`.
+        // 2. `T` is constructible and assignable from `V`.
+        // 3. `T` is constructible and assignable from `U` (i.e. `StatusOr<V>`).
+        // For example, the following code is considered ambiguous:
+        // (`T` is `bool`, `U` is `StatusOr<bool>`, `V` is `bool`)
+        //   StatusOr<bool> s1 = true;  // s1.ok() && s1.ValueOrDie() == true
+        //   StatusOr<bool> s2 = false;  // s2.ok() && s2.ValueOrDie() == false
+        //   s1 = s2;  // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`?
+        template<typename T, typename U>
+        struct IsForwardingAssignmentAmbiguous : public absl::conditional_t<std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, U>::value, std::false_type, IsForwardingAssignmentAmbiguous<T, absl::remove_cv_t<absl::remove_reference_t<U>>>>
+        {
+        };
+
+        template<typename T, typename U>
+        struct IsForwardingAssignmentAmbiguous<T, absl::StatusOr<U>> : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U>
+        {
+        };
+
+        // Checks against the constraints of the forwarding assignment, i.e. whether
+        // `StatusOr<T>::operator(U&&)` should participate in overload resolution.
+        template<typename T, typename U>
+        using IsForwardingAssignmentValid = absl::disjunction<
+            // Short circuits if T is basically U.
+            std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+            absl::negation<absl::disjunction<
+                std::is_same<absl::StatusOr<T>, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+                std::is_same<absl::Status, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+                std::is_same<absl::in_place_t, absl::remove_cv_t<absl::remove_reference_t<U>>>,
+                IsForwardingAssignmentAmbiguous<T, U>>>>;
+
+        class Helper
+        {
+        public:
+            // Move type-agnostic error handling to the .cc.
+            static void HandleInvalidStatusCtorArg(Status*);
+            ABSL_ATTRIBUTE_NORETURN static void Crash(const absl::Status& status);
+        };
+
+        // Construct an instance of T in `p` through placement new, passing Args... to
+        // the constructor.
+        // This abstraction is here mostly for the gcc performance fix.
+        template<typename T, typename... Args>
+        ABSL_ATTRIBUTE_NONNULL(1)
+        void PlacementNew(void* p, Args&&... args)
+        {
+            new (p) T(std::forward<Args>(args)...);
+        }
+
+        // Helper base class to hold the data and all operations.
+        // We move all this to a base class to allow mixing with the appropriate
+        // TraitsBase specialization.
+        template<typename T>
+        class StatusOrData
+        {
+            template<typename U>
+            friend class StatusOrData;
+
+        public:
+            StatusOrData() = delete;
+
+            StatusOrData(const StatusOrData& other)
+            {
+                if (other.ok())
+                {
+                    MakeValue(other.data_);
+                    MakeStatus();
+                }
+                else
+                {
+                    MakeStatus(other.status_);
+                }
+            }
+
+            StatusOrData(StatusOrData&& other) noexcept
+            {
+                if (other.ok())
+                {
+                    MakeValue(std::move(other.data_));
+                    MakeStatus();
+                }
+                else
+                {
+                    MakeStatus(std::move(other.status_));
+                }
+            }
+
+            template<typename U>
+            explicit StatusOrData(const StatusOrData<U>& other)
+            {
+                if (other.ok())
+                {
+                    MakeValue(other.data_);
+                    MakeStatus();
+                }
+                else
+                {
+                    MakeStatus(other.status_);
+                }
+            }
+
+            template<typename U>
+            explicit StatusOrData(StatusOrData<U>&& other)
+            {
+                if (other.ok())
+                {
+                    MakeValue(std::move(other.data_));
+                    MakeStatus();
+                }
+                else
+                {
+                    MakeStatus(std::move(other.status_));
+                }
+            }
+
+            template<typename... Args>
+            explicit StatusOrData(absl::in_place_t, Args&&... args) :
+                data_(std::forward<Args>(args)...)
+            {
+                MakeStatus();
+            }
+
+            explicit StatusOrData(const T& value) :
+                data_(value)
+            {
+                MakeStatus();
+            }
+            explicit StatusOrData(T&& value) :
+                data_(std::move(value))
+            {
+                MakeStatus();
+            }
+
+            template<typename U, absl::enable_if_t<std::is_constructible<absl::Status, U&&>::value, int> = 0>
+            explicit StatusOrData(U&& v) :
+                status_(std::forward<U>(v))
+            {
+                EnsureNotOk();
+            }
+
+            StatusOrData& operator=(const StatusOrData& other)
+            {
+                if (this == &other)
+                    return *this;
+                if (other.ok())
+                    Assign(other.data_);
+                else
+                    AssignStatus(other.status_);
+                return *this;
+            }
+
+            StatusOrData& operator=(StatusOrData&& other)
+            {
+                if (this == &other)
+                    return *this;
+                if (other.ok())
+                    Assign(std::move(other.data_));
+                else
+                    AssignStatus(std::move(other.status_));
+                return *this;
+            }
+
+            ~StatusOrData()
+            {
+                if (ok())
+                {
+                    status_.~Status();
+                    data_.~T();
+                }
+                else
+                {
+                    status_.~Status();
+                }
+            }
+
+            template<typename U>
+            void Assign(U&& value)
+            {
+                if (ok())
+                {
+                    data_ = std::forward<U>(value);
+                }
+                else
+                {
+                    MakeValue(std::forward<U>(value));
+                    status_ = OkStatus();
+                }
+            }
+
+            template<typename U>
+            void AssignStatus(U&& v)
+            {
+                Clear();
+                status_ = static_cast<absl::Status>(std::forward<U>(v));
+                EnsureNotOk();
+            }
+
+            bool ok() const
+            {
+                return status_.ok();
+            }
+
+        protected:
+            // status_ will always be active after the constructor.
+            // We make it a union to be able to initialize exactly how we need without
+            // waste.
+            // Eg. in the copy constructor we use the default constructor of Status in
+            // the ok() path to avoid an extra Ref call.
+            union
+            {
+                Status status_;
+            };
+
+            // data_ is active iff status_.ok()==true
+            struct Dummy
+            {
+            };
+            union
+            {
+                // When T is const, we need some non-const object we can cast to void* for
+                // the placement new. dummy_ is that object.
+                Dummy dummy_;
+                T data_;
+            };
+
+            void Clear()
+            {
+                if (ok())
+                    data_.~T();
+            }
+
+            void EnsureOk() const
+            {
+                if (ABSL_PREDICT_FALSE(!ok()))
+                    Helper::Crash(status_);
+            }
+
+            void EnsureNotOk()
+            {
+                if (ABSL_PREDICT_FALSE(ok()))
+                    Helper::HandleInvalidStatusCtorArg(&status_);
+            }
+
+            // Construct the value (ie. data_) through placement new with the passed
+            // argument.
+            template<typename... Arg>
+            void MakeValue(Arg&&... arg)
+            {
+                internal_statusor::PlacementNew<T>(&dummy_, std::forward<Arg>(arg)...);
+            }
+
+            // Construct the status (ie. status_) through placement new with the passed
+            // argument.
+            template<typename... Args>
+            void MakeStatus(Args&&... args)
+            {
+                internal_statusor::PlacementNew<Status>(&status_, std::forward<Args>(args)...);
+            }
+        };
+
+        // Helper base classes to allow implicitly deleted constructors and assignment
+        // operators in `StatusOr`. For example, `CopyCtorBase` will explicitly delete
+        // the copy constructor when T is not copy constructible and `StatusOr` will
+        // inherit that behavior implicitly.
+        template<typename T, bool = std::is_copy_constructible<T>::value>
+        struct CopyCtorBase
+        {
+            CopyCtorBase() = default;
+            CopyCtorBase(const CopyCtorBase&) = default;
+            CopyCtorBase(CopyCtorBase&&) = default;
+            CopyCtorBase& operator=(const CopyCtorBase&) = default;
+            CopyCtorBase& operator=(CopyCtorBase&&) = default;
+        };
+
+        template<typename T>
+        struct CopyCtorBase<T, false>
+        {
+            CopyCtorBase() = default;
+            CopyCtorBase(const CopyCtorBase&) = delete;
+            CopyCtorBase(CopyCtorBase&&) = default;
+            CopyCtorBase& operator=(const CopyCtorBase&) = default;
+            CopyCtorBase& operator=(CopyCtorBase&&) = default;
+        };
+
+        template<typename T, bool = std::is_move_constructible<T>::value>
+        struct MoveCtorBase
+        {
+            MoveCtorBase() = default;
+            MoveCtorBase(const MoveCtorBase&) = default;
+            MoveCtorBase(MoveCtorBase&&) = default;
+            MoveCtorBase& operator=(const MoveCtorBase&) = default;
+            MoveCtorBase& operator=(MoveCtorBase&&) = default;
+        };
+
+        template<typename T>
+        struct MoveCtorBase<T, false>
+        {
+            MoveCtorBase() = default;
+            MoveCtorBase(const MoveCtorBase&) = default;
+            MoveCtorBase(MoveCtorBase&&) = delete;
+            MoveCtorBase& operator=(const MoveCtorBase&) = default;
+            MoveCtorBase& operator=(MoveCtorBase&&) = default;
+        };
+
+        template<typename T, bool = std::is_copy_constructible<T>::value&& std::is_copy_assignable<T>::value>
+        struct CopyAssignBase
+        {
+            CopyAssignBase() = default;
+            CopyAssignBase(const CopyAssignBase&) = default;
+            CopyAssignBase(CopyAssignBase&&) = default;
+            CopyAssignBase& operator=(const CopyAssignBase&) = default;
+            CopyAssignBase& operator=(CopyAssignBase&&) = default;
+        };
+
+        template<typename T>
+        struct CopyAssignBase<T, false>
+        {
+            CopyAssignBase() = default;
+            CopyAssignBase(const CopyAssignBase&) = default;
+            CopyAssignBase(CopyAssignBase&&) = default;
+            CopyAssignBase& operator=(const CopyAssignBase&) = delete;
+            CopyAssignBase& operator=(CopyAssignBase&&) = default;
+        };
+
+        template<typename T, bool = std::is_move_constructible<T>::value&& std::is_move_assignable<T>::value>
+        struct MoveAssignBase
+        {
+            MoveAssignBase() = default;
+            MoveAssignBase(const MoveAssignBase&) = default;
+            MoveAssignBase(MoveAssignBase&&) = default;
+            MoveAssignBase& operator=(const MoveAssignBase&) = default;
+            MoveAssignBase& operator=(MoveAssignBase&&) = default;
+        };
+
+        template<typename T>
+        struct MoveAssignBase<T, false>
+        {
+            MoveAssignBase() = default;
+            MoveAssignBase(const MoveAssignBase&) = default;
+            MoveAssignBase(MoveAssignBase&&) = default;
+            MoveAssignBase& operator=(const MoveAssignBase&) = default;
+            MoveAssignBase& operator=(MoveAssignBase&&) = delete;
+        };
+
+        ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(absl::Status status);
+
+    }  // namespace internal_statusor
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/status.h b/CAPI/cpp/grpc/include/absl/status/status.h
index 9292b83..6598a95 100644
--- a/CAPI/cpp/grpc/include/absl/status/status.h
+++ b/CAPI/cpp/grpc/include/absl/status/status.h
@@ -61,832 +61,884 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::StatusCode
-//
-// An `absl::StatusCode` is an enumerated type indicating either no error ("OK")
-// or an error condition. In most cases, an `absl::Status` indicates a
-// recoverable error, and the purpose of signalling an error is to indicate what
-// action to take in response to that error. These error codes map to the proto
-// RPC error codes indicated in https://cloud.google.com/apis/design/errors.
-//
-// The errors listed below are the canonical errors associated with
-// `absl::Status` and are used throughout the codebase. As a result, these
-// error codes are somewhat generic.
-//
-// In general, try to return the most specific error that applies if more than
-// one error may pertain. For example, prefer `kOutOfRange` over
-// `kFailedPrecondition` if both codes apply. Similarly prefer `kNotFound` or
-// `kAlreadyExists` over `kFailedPrecondition`.
-//
-// Because these errors may cross RPC boundaries, these codes are tied to the
-// `google.rpc.Code` definitions within
-// https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
-// The string value of these RPC codes is denoted within each enum below.
-//
-// If your error handling code requires more context, you can attach payloads
-// to your status. See `absl::Status::SetPayload()` and
-// `absl::Status::GetPayload()` below.
-enum class StatusCode : int {
-  // StatusCode::kOk
-  //
-  // kOK (gRPC code "OK") does not indicate an error; this value is returned on
-  // success. It is typical to check for this value before proceeding on any
-  // given call across an API or RPC boundary. To check this value, use the
-  // `absl::Status::ok()` member function rather than inspecting the raw code.
-  kOk = 0,
-
-  // StatusCode::kCancelled
-  //
-  // kCancelled (gRPC code "CANCELLED") indicates the operation was cancelled,
-  // typically by the caller.
-  kCancelled = 1,
-
-  // StatusCode::kUnknown
-  //
-  // kUnknown (gRPC code "UNKNOWN") indicates an unknown error occurred. In
-  // general, more specific errors should be raised, if possible. Errors raised
-  // by APIs that do not return enough error information may be converted to
-  // this error.
-  kUnknown = 2,
-
-  // StatusCode::kInvalidArgument
-  //
-  // kInvalidArgument (gRPC code "INVALID_ARGUMENT") indicates the caller
-  // specified an invalid argument, such as a malformed filename. Note that use
-  // of such errors should be narrowly limited to indicate the invalid nature of
-  // the arguments themselves. Errors with validly formed arguments that may
-  // cause errors with the state of the receiving system should be denoted with
-  // `kFailedPrecondition` instead.
-  kInvalidArgument = 3,
-
-  // StatusCode::kDeadlineExceeded
-  //
-  // kDeadlineExceeded (gRPC code "DEADLINE_EXCEEDED") indicates a deadline
-  // expired before the operation could complete. For operations that may change
-  // state within a system, this error may be returned even if the operation has
-  // completed successfully. For example, a successful response from a server
-  // could have been delayed long enough for the deadline to expire.
-  kDeadlineExceeded = 4,
-
-  // StatusCode::kNotFound
-  //
-  // kNotFound (gRPC code "NOT_FOUND") indicates some requested entity (such as
-  // a file or directory) was not found.
-  //
-  // `kNotFound` is useful if a request should be denied for an entire class of
-  // users, such as during a gradual feature rollout or undocumented allow list.
-  // If a request should be denied for specific sets of users, such as through
-  // user-based access control, use `kPermissionDenied` instead.
-  kNotFound = 5,
-
-  // StatusCode::kAlreadyExists
-  //
-  // kAlreadyExists (gRPC code "ALREADY_EXISTS") indicates that the entity a
-  // caller attempted to create (such as a file or directory) is already
-  // present.
-  kAlreadyExists = 6,
-
-  // StatusCode::kPermissionDenied
-  //
-  // kPermissionDenied (gRPC code "PERMISSION_DENIED") indicates that the caller
-  // does not have permission to execute the specified operation. Note that this
-  // error is different than an error due to an *un*authenticated user. This
-  // error code does not imply the request is valid or the requested entity
-  // exists or satisfies any other pre-conditions.
-  //
-  // `kPermissionDenied` must not be used for rejections caused by exhausting
-  // some resource. Instead, use `kResourceExhausted` for those errors.
-  // `kPermissionDenied` must not be used if the caller cannot be identified.
-  // Instead, use `kUnauthenticated` for those errors.
-  kPermissionDenied = 7,
-
-  // StatusCode::kResourceExhausted
-  //
-  // kResourceExhausted (gRPC code "RESOURCE_EXHAUSTED") indicates some resource
-  // has been exhausted, perhaps a per-user quota, or perhaps the entire file
-  // system is out of space.
-  kResourceExhausted = 8,
-
-  // StatusCode::kFailedPrecondition
-  //
-  // kFailedPrecondition (gRPC code "FAILED_PRECONDITION") indicates that the
-  // operation was rejected because the system is not in a state required for
-  // the operation's execution. For example, a directory to be deleted may be
-  // non-empty, an "rmdir" operation is applied to a non-directory, etc.
-  //
-  // Some guidelines that may help a service implementer in deciding between
-  // `kFailedPrecondition`, `kAborted`, and `kUnavailable`:
-  //
-  //  (a) Use `kUnavailable` if the client can retry just the failing call.
-  //  (b) Use `kAborted` if the client should retry at a higher transaction
-  //      level (such as when a client-specified test-and-set fails, indicating
-  //      the client should restart a read-modify-write sequence).
-  //  (c) Use `kFailedPrecondition` if the client should not retry until
-  //      the system state has been explicitly fixed. For example, if a "rmdir"
-  //      fails because the directory is non-empty, `kFailedPrecondition`
-  //      should be returned since the client should not retry unless
-  //      the files are deleted from the directory.
-  kFailedPrecondition = 9,
-
-  // StatusCode::kAborted
-  //
-  // kAborted (gRPC code "ABORTED") indicates the operation was aborted,
-  // typically due to a concurrency issue such as a sequencer check failure or a
-  // failed transaction.
-  //
-  // See the guidelines above for deciding between `kFailedPrecondition`,
-  // `kAborted`, and `kUnavailable`.
-  kAborted = 10,
-
-  // StatusCode::kOutOfRange
-  //
-  // kOutOfRange (gRPC code "OUT_OF_RANGE") indicates the operation was
-  // attempted past the valid range, such as seeking or reading past an
-  // end-of-file.
-  //
-  // Unlike `kInvalidArgument`, this error indicates a problem that may
-  // be fixed if the system state changes. For example, a 32-bit file
-  // system will generate `kInvalidArgument` if asked to read at an
-  // offset that is not in the range [0,2^32-1], but it will generate
-  // `kOutOfRange` if asked to read from an offset past the current
-  // file size.
-  //
-  // There is a fair bit of overlap between `kFailedPrecondition` and
-  // `kOutOfRange`.  We recommend using `kOutOfRange` (the more specific
-  // error) when it applies so that callers who are iterating through
-  // a space can easily look for an `kOutOfRange` error to detect when
-  // they are done.
-  kOutOfRange = 11,
-
-  // StatusCode::kUnimplemented
-  //
-  // kUnimplemented (gRPC code "UNIMPLEMENTED") indicates the operation is not
-  // implemented or supported in this service. In this case, the operation
-  // should not be re-attempted.
-  kUnimplemented = 12,
-
-  // StatusCode::kInternal
-  //
-  // kInternal (gRPC code "INTERNAL") indicates an internal error has occurred
-  // and some invariants expected by the underlying system have not been
-  // satisfied. This error code is reserved for serious errors.
-  kInternal = 13,
-
-  // StatusCode::kUnavailable
-  //
-  // kUnavailable (gRPC code "UNAVAILABLE") indicates the service is currently
-  // unavailable and that this is most likely a transient condition. An error
-  // such as this can be corrected by retrying with a backoff scheme. Note that
-  // it is not always safe to retry non-idempotent operations.
-  //
-  // See the guidelines above for deciding between `kFailedPrecondition`,
-  // `kAborted`, and `kUnavailable`.
-  kUnavailable = 14,
-
-  // StatusCode::kDataLoss
-  //
-  // kDataLoss (gRPC code "DATA_LOSS") indicates that unrecoverable data loss or
-  // corruption has occurred. As this error is serious, proper alerting should
-  // be attached to errors such as this.
-  kDataLoss = 15,
-
-  // StatusCode::kUnauthenticated
-  //
-  // kUnauthenticated (gRPC code "UNAUTHENTICATED") indicates that the request
-  // does not have valid authentication credentials for the operation. Correct
-  // the authentication and try again.
-  kUnauthenticated = 16,
-
-  // StatusCode::DoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_
-  //
-  // NOTE: this error code entry should not be used and you should not rely on
-  // its value, which may change.
-  //
-  // The purpose of this enumerated value is to force people who handle status
-  // codes with `switch()` statements to *not* simply enumerate all possible
-  // values, but instead provide a "default:" case. Providing such a default
-  // case ensures that code will compile when new codes are added.
-  kDoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ = 20
-};
-
-// StatusCodeToString()
-//
-// Returns the name for the status code, or "" if it is an unknown value.
-std::string StatusCodeToString(StatusCode code);
-
-// operator<<
-//
-// Streams StatusCodeToString(code) to `os`.
-std::ostream& operator<<(std::ostream& os, StatusCode code);
-
-// absl::StatusToStringMode
-//
-// An `absl::StatusToStringMode` is an enumerated type indicating how
-// `absl::Status::ToString()` should construct the output string for a non-ok
-// status.
-enum class StatusToStringMode : int {
-  // ToString will not contain any extra data (such as payloads). It will only
-  // contain the error code and message, if any.
-  kWithNoExtraData = 0,
-  // ToString will contain the payloads.
-  kWithPayload = 1 << 0,
-  // ToString will include all the extra data this Status has.
-  kWithEverything = ~kWithNoExtraData,
-  // Default mode used by ToString. Its exact value might change in the future.
-  kDefault = kWithPayload,
-};
-
-// absl::StatusToStringMode is specified as a bitmask type, which means the
-// following operations must be provided:
-inline constexpr StatusToStringMode operator&(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) &
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator|(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) |
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator^(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) ^
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator~(StatusToStringMode arg) {
-  return static_cast<StatusToStringMode>(~static_cast<int>(arg));
-}
-inline StatusToStringMode& operator&=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs & rhs;
-  return lhs;
-}
-inline StatusToStringMode& operator|=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs | rhs;
-  return lhs;
-}
-inline StatusToStringMode& operator^=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs ^ rhs;
-  return lhs;
-}
-
-// absl::Status
-//
-// The `absl::Status` class is generally used to gracefully handle errors
-// across API boundaries (and in particular across RPC boundaries). Some of
-// these errors may be recoverable, but others may not. Most
-// functions which can produce a recoverable error should be designed to return
-// either an `absl::Status` (or the similar `absl::StatusOr<T>`, which holds
-// either an object of type `T` or an error).
-//
-// API developers should construct their functions to return `absl::OkStatus()`
-// upon success, or an `absl::StatusCode` upon another type of error (e.g
-// an `absl::StatusCode::kInvalidArgument` error). The API provides convenience
-// functions to construct each status code.
-//
-// Example:
-//
-// absl::Status myFunction(absl::string_view fname, ...) {
-//   ...
-//   // encounter error
-//   if (error condition) {
-//     // Construct an absl::StatusCode::kInvalidArgument error
-//     return absl::InvalidArgumentError("bad mode");
-//   }
-//   // else, return OK
-//   return absl::OkStatus();
-// }
-//
-// Users handling status error codes should prefer checking for an OK status
-// using the `ok()` member function. Handling multiple error codes may justify
-// use of switch statement, but only check for error codes you know how to
-// handle; do not try to exhaustively match against all canonical error codes.
-// Errors that cannot be handled should be logged and/or propagated for higher
-// levels to deal with. If you do use a switch statement, make sure that you
-// also provide a `default:` switch case, so that code does not break as other
-// canonical codes are added to the API.
-//
-// Example:
-//
-//   absl::Status result = DoSomething();
-//   if (!result.ok()) {
-//     LOG(ERROR) << result;
-//   }
-//
-//   // Provide a default if switching on multiple error codes
-//   switch (result.code()) {
-//     // The user hasn't authenticated. Ask them to reauth
-//     case absl::StatusCode::kUnauthenticated:
-//       DoReAuth();
-//       break;
-//     // The user does not have permission. Log an error.
-//     case absl::StatusCode::kPermissionDenied:
-//       LOG(ERROR) << result;
-//       break;
-//     // Propagate the error otherwise.
-//     default:
-//       return true;
-//   }
-//
-// An `absl::Status` can optionally include a payload with more information
-// about the error. Typically, this payload serves one of several purposes:
-//
-//   * It may provide more fine-grained semantic information about the error to
-//     facilitate actionable remedies.
-//   * It may provide human-readable contexual information that is more
-//     appropriate to display to an end user.
-//
-// Example:
-//
-//   absl::Status result = DoSomething();
-//   // Inform user to retry after 30 seconds
-//   // See more error details in googleapis/google/rpc/error_details.proto
-//   if (absl::IsResourceExhausted(result)) {
-//     google::rpc::RetryInfo info;
-//     info.retry_delay().seconds() = 30;
-//     // Payloads require a unique key (a URL to ensure no collisions with
-//     // other payloads), and an `absl::Cord` to hold the encoded data.
-//     absl::string_view url = "type.googleapis.com/google.rpc.RetryInfo";
-//     result.SetPayload(url, info.SerializeAsCord());
-//     return result;
-//   }
-//
-// For documentation see https://abseil.io/docs/cpp/guides/status.
-//
-// Returned Status objects may not be ignored. status_internal.h has a forward
-// declaration of the form
-// class ABSL_MUST_USE_RESULT Status;
-class Status final {
- public:
-  // Constructors
-
-  // This default constructor creates an OK status with no message or payload.
-  // Avoid this constructor and prefer explicit construction of an OK status
-  // with `absl::OkStatus()`.
-  Status();
-
-  // Creates a status in the canonical error space with the specified
-  // `absl::StatusCode` and error message.  If `code == absl::StatusCode::kOk`,  // NOLINT
-  // `msg` is ignored and an object identical to an OK status is constructed.
-  //
-  // The `msg` string must be in UTF-8. The implementation may complain (e.g.,  // NOLINT
-  // by printing a warning) if it is not.
-  Status(absl::StatusCode code, absl::string_view msg);
-
-  Status(const Status&);
-  Status& operator=(const Status& x);
-
-  // Move operators
-
-  // The moved-from state is valid but unspecified.
-  Status(Status&&) noexcept;
-  Status& operator=(Status&&);
-
-  ~Status();
-
-  // Status::Update()
-  //
-  // Updates the existing status with `new_status` provided that `this->ok()`.
-  // If the existing status already contains a non-OK error, this update has no
-  // effect and preserves the current data. Note that this behavior may change
-  // in the future to augment a current non-ok status with additional
-  // information about `new_status`.
-  //
-  // `Update()` provides a convenient way of keeping track of the first error
-  // encountered.
-  //
-  // Example:
-  //   // Instead of "if (overall_status.ok()) overall_status = new_status"
-  //   overall_status.Update(new_status);
-  //
-  void Update(const Status& new_status);
-  void Update(Status&& new_status);
-
-  // Status::ok()
-  //
-  // Returns `true` if `this->code()` == `absl::StatusCode::kOk`,
-  // indicating the absence of an error.
-  // Prefer checking for an OK status using this member function.
-  ABSL_MUST_USE_RESULT bool ok() const;
-
-  // Status::code()
-  //
-  // Returns the canonical error code of type `absl::StatusCode` of this status.
-  absl::StatusCode code() const;
-
-  // Status::raw_code()
-  //
-  // Returns a raw (canonical) error code corresponding to the enum value of
-  // `google.rpc.Code` definitions within
-  // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto.
-  // These values could be out of the range of canonical `absl::StatusCode`
-  // enum values.
-  //
-  // NOTE: This function should only be called when converting to an associated
-  // wire format. Use `Status::code()` for error handling.
-  int raw_code() const;
-
-  // Status::message()
-  //
-  // Returns the error message associated with this error code, if available.
-  // Note that this message rarely describes the error code.  It is not unusual
-  // for the error message to be the empty string. As a result, prefer
-  // `operator<<` or `Status::ToString()` for debug logging.
-  absl::string_view message() const;
-
-  friend bool operator==(const Status&, const Status&);
-  friend bool operator!=(const Status&, const Status&);
-
-  // Status::ToString()
-  //
-  // Returns a string based on the `mode`. By default, it returns combination of
-  // the error code name, the message and any associated payload messages. This
-  // string is designed simply to be human readable and its exact format should
-  // not be load bearing. Do not depend on the exact format of the result of
-  // `ToString()` which is subject to change.
-  //
-  // The printed code name and the message are generally substrings of the
-  // result, and the payloads to be printed use the status payload printer
-  // mechanism (which is internal).
-  std::string ToString(
-      StatusToStringMode mode = StatusToStringMode::kDefault) const;
-
-  // Status::IgnoreError()
-  //
-  // Ignores any errors. This method does nothing except potentially suppress
-  // complaints from any tools that are checking that errors are not dropped on
-  // the floor.
-  void IgnoreError() const;
-
-  // swap()
-  //
-  // Swap the contents of one status with another.
-  friend void swap(Status& a, Status& b);
-
-  //----------------------------------------------------------------------------
-  // Payload Management APIs
-  //----------------------------------------------------------------------------
-
-  // A payload may be attached to a status to provide additional context to an
-  // error that may not be satisfied by an existing `absl::StatusCode`.
-  // Typically, this payload serves one of several purposes:
-  //
-  //   * It may provide more fine-grained semantic information about the error
-  //     to facilitate actionable remedies.
-  //   * It may provide human-readable contexual information that is more
-  //     appropriate to display to an end user.
-  //
-  // A payload consists of a [key,value] pair, where the key is a string
-  // referring to a unique "type URL" and the value is an object of type
-  // `absl::Cord` to hold the contextual data.
-  //
-  // The "type URL" should be unique and follow the format of a URL
-  // (https://en.wikipedia.org/wiki/URL) and, ideally, provide some
-  // documentation or schema on how to interpret its associated data. For
-  // example, the default type URL for a protobuf message type is
-  // "type.googleapis.com/packagename.messagename". Other custom wire formats
-  // should define the format of type URL in a similar practice so as to
-  // minimize the chance of conflict between type URLs.
-  // Users should ensure that the type URL can be mapped to a concrete
-  // C++ type if they want to deserialize the payload and read it effectively.
-  //
-  // To attach a payload to a status object, call `Status::SetPayload()`,
-  // passing it the type URL and an `absl::Cord` of associated data. Similarly,
-  // to extract the payload from a status, call `Status::GetPayload()`. You
-  // may attach multiple payloads (with differing type URLs) to any given
-  // status object, provided that the status is currently exhibiting an error
-  // code (i.e. is not OK).
-
-  // Status::GetPayload()
-  //
-  // Gets the payload of a status given its unique `type_url` key, if present.
-  absl::optional<absl::Cord> GetPayload(absl::string_view type_url) const;
-
-  // Status::SetPayload()
-  //
-  // Sets the payload for a non-ok status using a `type_url` key, overwriting
-  // any existing payload for that `type_url`.
-  //
-  // NOTE: This function does nothing if the Status is ok.
-  void SetPayload(absl::string_view type_url, absl::Cord payload);
-
-  // Status::ErasePayload()
-  //
-  // Erases the payload corresponding to the `type_url` key.  Returns `true` if
-  // the payload was present.
-  bool ErasePayload(absl::string_view type_url);
-
-  // Status::ForEachPayload()
-  //
-  // Iterates over the stored payloads and calls the
-  // `visitor(type_key, payload)` callable for each one.
-  //
-  // NOTE: The order of calls to `visitor()` is not specified and may change at
-  // any time.
-  //
-  // NOTE: Any mutation on the same 'absl::Status' object during visitation is
-  // forbidden and could result in undefined behavior.
-  void ForEachPayload(
-      absl::FunctionRef<void(absl::string_view, const absl::Cord&)> visitor)
-      const;
-
- private:
-  friend Status CancelledError();
-
-  // Creates a status in the canonical error space with the specified
-  // code, and an empty error message.
-  explicit Status(absl::StatusCode code);
-
-  static void UnrefNonInlined(uintptr_t rep);
-  static void Ref(uintptr_t rep);
-  static void Unref(uintptr_t rep);
-
-  // REQUIRES: !ok()
-  // Ensures rep_ is not shared with any other Status.
-  void PrepareToModify();
-
-  const status_internal::Payloads* GetPayloads() const;
-  status_internal::Payloads* GetPayloads();
-
-  static bool EqualsSlow(const absl::Status& a, const absl::Status& b);
-
-  // MSVC 14.0 limitation requires the const.
-  static constexpr const char kMovedFromString[] =
-      "Status accessed after move.";
-
-  static const std::string* EmptyString();
-  static const std::string* MovedFromString();
-
-  // Returns whether rep contains an inlined representation.
-  // See rep_ for details.
-  static bool IsInlined(uintptr_t rep);
-
-  // Indicates whether this Status was the rhs of a move operation. See rep_
-  // for details.
-  static bool IsMovedFrom(uintptr_t rep);
-  static uintptr_t MovedFromRep();
-
-  // Convert between error::Code and the inlined uintptr_t representation used
-  // by rep_. See rep_ for details.
-  static uintptr_t CodeToInlinedRep(absl::StatusCode code);
-  static absl::StatusCode InlinedRepToCode(uintptr_t rep);
-
-  // Converts between StatusRep* and the external uintptr_t representation used
-  // by rep_. See rep_ for details.
-  static uintptr_t PointerToRep(status_internal::StatusRep* r);
-  static status_internal::StatusRep* RepToPointer(uintptr_t r);
-
-  std::string ToStringSlow(StatusToStringMode mode) const;
-
-  // Status supports two different representations.
-  //  - When the low bit is off it is an inlined representation.
-  //    It uses the canonical error space, no message or payload.
-  //    The error code is (rep_ >> 2).
-  //    The (rep_ & 2) bit is the "moved from" indicator, used in IsMovedFrom().
-  //  - When the low bit is on it is an external representation.
-  //    In this case all the data comes from a heap allocated Rep object.
-  //    (rep_ - 1) is a status_internal::StatusRep* pointer to that structure.
-  uintptr_t rep_;
-};
-
-// OkStatus()
-//
-// Returns an OK status, equivalent to a default constructed instance. Prefer
-// usage of `absl::OkStatus()` when constructing such an OK status.
-Status OkStatus();
-
-// operator<<()
-//
-// Prints a human-readable representation of `x` to `os`.
-std::ostream& operator<<(std::ostream& os, const Status& x);
-
-// IsAborted()
-// IsAlreadyExists()
-// IsCancelled()
-// IsDataLoss()
-// IsDeadlineExceeded()
-// IsFailedPrecondition()
-// IsInternal()
-// IsInvalidArgument()
-// IsNotFound()
-// IsOutOfRange()
-// IsPermissionDenied()
-// IsResourceExhausted()
-// IsUnauthenticated()
-// IsUnavailable()
-// IsUnimplemented()
-// IsUnknown()
-//
-// These convenience functions return `true` if a given status matches the
-// `absl::StatusCode` error code of its associated function.
-ABSL_MUST_USE_RESULT bool IsAborted(const Status& status);
-ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status);
-ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status);
-ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status);
-ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status);
-ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status);
-ABSL_MUST_USE_RESULT bool IsInternal(const Status& status);
-ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status);
-ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status);
-ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status);
-ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status);
-ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status);
-
-// AbortedError()
-// AlreadyExistsError()
-// CancelledError()
-// DataLossError()
-// DeadlineExceededError()
-// FailedPreconditionError()
-// InternalError()
-// InvalidArgumentError()
-// NotFoundError()
-// OutOfRangeError()
-// PermissionDeniedError()
-// ResourceExhaustedError()
-// UnauthenticatedError()
-// UnavailableError()
-// UnimplementedError()
-// UnknownError()
-//
-// These convenience functions create an `absl::Status` object with an error
-// code as indicated by the associated function name, using the error message
-// passed in `message`.
-Status AbortedError(absl::string_view message);
-Status AlreadyExistsError(absl::string_view message);
-Status CancelledError(absl::string_view message);
-Status DataLossError(absl::string_view message);
-Status DeadlineExceededError(absl::string_view message);
-Status FailedPreconditionError(absl::string_view message);
-Status InternalError(absl::string_view message);
-Status InvalidArgumentError(absl::string_view message);
-Status NotFoundError(absl::string_view message);
-Status OutOfRangeError(absl::string_view message);
-Status PermissionDeniedError(absl::string_view message);
-Status ResourceExhaustedError(absl::string_view message);
-Status UnauthenticatedError(absl::string_view message);
-Status UnavailableError(absl::string_view message);
-Status UnimplementedError(absl::string_view message);
-Status UnknownError(absl::string_view message);
-
-// ErrnoToStatusCode()
-//
-// Returns the StatusCode for `error_number`, which should be an `errno` value.
-// See https://en.cppreference.com/w/cpp/error/errno_macros and similar
-// references.
-absl::StatusCode ErrnoToStatusCode(int error_number);
-
-// ErrnoToStatus()
-//
-// Convenience function that creates a `absl::Status` using an `error_number`,
-// which should be an `errno` value.
-Status ErrnoToStatus(int error_number, absl::string_view message);
-
-//------------------------------------------------------------------------------
-// Implementation details follow
-//------------------------------------------------------------------------------
-
-inline Status::Status() : rep_(CodeToInlinedRep(absl::StatusCode::kOk)) {}
-
-inline Status::Status(absl::StatusCode code) : rep_(CodeToInlinedRep(code)) {}
-
-inline Status::Status(const Status& x) : rep_(x.rep_) { Ref(rep_); }
-
-inline Status& Status::operator=(const Status& x) {
-  uintptr_t old_rep = rep_;
-  if (x.rep_ != old_rep) {
-    Ref(x.rep_);
-    rep_ = x.rep_;
-    Unref(old_rep);
-  }
-  return *this;
-}
-
-inline Status::Status(Status&& x) noexcept : rep_(x.rep_) {
-  x.rep_ = MovedFromRep();
-}
-
-inline Status& Status::operator=(Status&& x) {
-  uintptr_t old_rep = rep_;
-  if (x.rep_ != old_rep) {
-    rep_ = x.rep_;
-    x.rep_ = MovedFromRep();
-    Unref(old_rep);
-  }
-  return *this;
-}
-
-inline void Status::Update(const Status& new_status) {
-  if (ok()) {
-    *this = new_status;
-  }
-}
-
-inline void Status::Update(Status&& new_status) {
-  if (ok()) {
-    *this = std::move(new_status);
-  }
-}
-
-inline Status::~Status() { Unref(rep_); }
-
-inline bool Status::ok() const {
-  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
-}
-
-inline absl::string_view Status::message() const {
-  return !IsInlined(rep_)
-             ? RepToPointer(rep_)->message
-             : (IsMovedFrom(rep_) ? absl::string_view(kMovedFromString)
-                                  : absl::string_view());
-}
-
-inline bool operator==(const Status& lhs, const Status& rhs) {
-  return lhs.rep_ == rhs.rep_ || Status::EqualsSlow(lhs, rhs);
-}
-
-inline bool operator!=(const Status& lhs, const Status& rhs) {
-  return !(lhs == rhs);
-}
-
-inline std::string Status::ToString(StatusToStringMode mode) const {
-  return ok() ? "OK" : ToStringSlow(mode);
-}
-
-inline void Status::IgnoreError() const {
-  // no-op
-}
-
-inline void swap(absl::Status& a, absl::Status& b) {
-  using std::swap;
-  swap(a.rep_, b.rep_);
-}
-
-inline const status_internal::Payloads* Status::GetPayloads() const {
-  return IsInlined(rep_) ? nullptr : RepToPointer(rep_)->payloads.get();
-}
-
-inline status_internal::Payloads* Status::GetPayloads() {
-  return IsInlined(rep_) ? nullptr : RepToPointer(rep_)->payloads.get();
-}
-
-inline bool Status::IsInlined(uintptr_t rep) { return (rep & 1) == 0; }
-
-inline bool Status::IsMovedFrom(uintptr_t rep) {
-  return IsInlined(rep) && (rep & 2) != 0;
-}
-
-inline uintptr_t Status::MovedFromRep() {
-  return CodeToInlinedRep(absl::StatusCode::kInternal) | 2;
-}
-
-inline uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
-  return static_cast<uintptr_t>(code) << 2;
-}
-
-inline absl::StatusCode Status::InlinedRepToCode(uintptr_t rep) {
-  assert(IsInlined(rep));
-  return static_cast<absl::StatusCode>(rep >> 2);
-}
-
-inline status_internal::StatusRep* Status::RepToPointer(uintptr_t rep) {
-  assert(!IsInlined(rep));
-  return reinterpret_cast<status_internal::StatusRep*>(rep - 1);
-}
-
-inline uintptr_t Status::PointerToRep(status_internal::StatusRep* rep) {
-  return reinterpret_cast<uintptr_t>(rep) + 1;
-}
-
-inline void Status::Ref(uintptr_t rep) {
-  if (!IsInlined(rep)) {
-    RepToPointer(rep)->ref.fetch_add(1, std::memory_order_relaxed);
-  }
-}
-
-inline void Status::Unref(uintptr_t rep) {
-  if (!IsInlined(rep)) {
-    UnrefNonInlined(rep);
-  }
-}
-
-inline Status OkStatus() { return Status(); }
-
-// Creates a `Status` object with the `absl::StatusCode::kCancelled` error code
-// and an empty message. It is provided only for efficiency, given that
-// message-less kCancelled errors are common in the infrastructure.
-inline Status CancelledError() { return Status(absl::StatusCode::kCancelled); }
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::StatusCode
+    //
+    // An `absl::StatusCode` is an enumerated type indicating either no error ("OK")
+    // or an error condition. In most cases, an `absl::Status` indicates a
+    // recoverable error, and the purpose of signalling an error is to indicate what
+    // action to take in response to that error. These error codes map to the proto
+    // RPC error codes indicated in https://cloud.google.com/apis/design/errors.
+    //
+    // The errors listed below are the canonical errors associated with
+    // `absl::Status` and are used throughout the codebase. As a result, these
+    // error codes are somewhat generic.
+    //
+    // In general, try to return the most specific error that applies if more than
+    // one error may pertain. For example, prefer `kOutOfRange` over
+    // `kFailedPrecondition` if both codes apply. Similarly prefer `kNotFound` or
+    // `kAlreadyExists` over `kFailedPrecondition`.
+    //
+    // Because these errors may cross RPC boundaries, these codes are tied to the
+    // `google.rpc.Code` definitions within
+    // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
+    // The string value of these RPC codes is denoted within each enum below.
+    //
+    // If your error handling code requires more context, you can attach payloads
+    // to your status. See `absl::Status::SetPayload()` and
+    // `absl::Status::GetPayload()` below.
+    enum class StatusCode : int
+    {
+        // StatusCode::kOk
+        //
+        // kOK (gRPC code "OK") does not indicate an error; this value is returned on
+        // success. It is typical to check for this value before proceeding on any
+        // given call across an API or RPC boundary. To check this value, use the
+        // `absl::Status::ok()` member function rather than inspecting the raw code.
+        kOk = 0,
+
+        // StatusCode::kCancelled
+        //
+        // kCancelled (gRPC code "CANCELLED") indicates the operation was cancelled,
+        // typically by the caller.
+        kCancelled = 1,
+
+        // StatusCode::kUnknown
+        //
+        // kUnknown (gRPC code "UNKNOWN") indicates an unknown error occurred. In
+        // general, more specific errors should be raised, if possible. Errors raised
+        // by APIs that do not return enough error information may be converted to
+        // this error.
+        kUnknown = 2,
+
+        // StatusCode::kInvalidArgument
+        //
+        // kInvalidArgument (gRPC code "INVALID_ARGUMENT") indicates the caller
+        // specified an invalid argument, such as a malformed filename. Note that use
+        // of such errors should be narrowly limited to indicate the invalid nature of
+        // the arguments themselves. Errors with validly formed arguments that may
+        // cause errors with the state of the receiving system should be denoted with
+        // `kFailedPrecondition` instead.
+        kInvalidArgument = 3,
+
+        // StatusCode::kDeadlineExceeded
+        //
+        // kDeadlineExceeded (gRPC code "DEADLINE_EXCEEDED") indicates a deadline
+        // expired before the operation could complete. For operations that may change
+        // state within a system, this error may be returned even if the operation has
+        // completed successfully. For example, a successful response from a server
+        // could have been delayed long enough for the deadline to expire.
+        kDeadlineExceeded = 4,
+
+        // StatusCode::kNotFound
+        //
+        // kNotFound (gRPC code "NOT_FOUND") indicates some requested entity (such as
+        // a file or directory) was not found.
+        //
+        // `kNotFound` is useful if a request should be denied for an entire class of
+        // users, such as during a gradual feature rollout or undocumented allow list.
+        // If a request should be denied for specific sets of users, such as through
+        // user-based access control, use `kPermissionDenied` instead.
+        kNotFound = 5,
+
+        // StatusCode::kAlreadyExists
+        //
+        // kAlreadyExists (gRPC code "ALREADY_EXISTS") indicates that the entity a
+        // caller attempted to create (such as a file or directory) is already
+        // present.
+        kAlreadyExists = 6,
+
+        // StatusCode::kPermissionDenied
+        //
+        // kPermissionDenied (gRPC code "PERMISSION_DENIED") indicates that the caller
+        // does not have permission to execute the specified operation. Note that this
+        // error is different than an error due to an *un*authenticated user. This
+        // error code does not imply the request is valid or the requested entity
+        // exists or satisfies any other pre-conditions.
+        //
+        // `kPermissionDenied` must not be used for rejections caused by exhausting
+        // some resource. Instead, use `kResourceExhausted` for those errors.
+        // `kPermissionDenied` must not be used if the caller cannot be identified.
+        // Instead, use `kUnauthenticated` for those errors.
+        kPermissionDenied = 7,
+
+        // StatusCode::kResourceExhausted
+        //
+        // kResourceExhausted (gRPC code "RESOURCE_EXHAUSTED") indicates some resource
+        // has been exhausted, perhaps a per-user quota, or perhaps the entire file
+        // system is out of space.
+        kResourceExhausted = 8,
+
+        // StatusCode::kFailedPrecondition
+        //
+        // kFailedPrecondition (gRPC code "FAILED_PRECONDITION") indicates that the
+        // operation was rejected because the system is not in a state required for
+        // the operation's execution. For example, a directory to be deleted may be
+        // non-empty, an "rmdir" operation is applied to a non-directory, etc.
+        //
+        // Some guidelines that may help a service implementer in deciding between
+        // `kFailedPrecondition`, `kAborted`, and `kUnavailable`:
+        //
+        //  (a) Use `kUnavailable` if the client can retry just the failing call.
+        //  (b) Use `kAborted` if the client should retry at a higher transaction
+        //      level (such as when a client-specified test-and-set fails, indicating
+        //      the client should restart a read-modify-write sequence).
+        //  (c) Use `kFailedPrecondition` if the client should not retry until
+        //      the system state has been explicitly fixed. For example, if a "rmdir"
+        //      fails because the directory is non-empty, `kFailedPrecondition`
+        //      should be returned since the client should not retry unless
+        //      the files are deleted from the directory.
+        kFailedPrecondition = 9,
+
+        // StatusCode::kAborted
+        //
+        // kAborted (gRPC code "ABORTED") indicates the operation was aborted,
+        // typically due to a concurrency issue such as a sequencer check failure or a
+        // failed transaction.
+        //
+        // See the guidelines above for deciding between `kFailedPrecondition`,
+        // `kAborted`, and `kUnavailable`.
+        kAborted = 10,
+
+        // StatusCode::kOutOfRange
+        //
+        // kOutOfRange (gRPC code "OUT_OF_RANGE") indicates the operation was
+        // attempted past the valid range, such as seeking or reading past an
+        // end-of-file.
+        //
+        // Unlike `kInvalidArgument`, this error indicates a problem that may
+        // be fixed if the system state changes. For example, a 32-bit file
+        // system will generate `kInvalidArgument` if asked to read at an
+        // offset that is not in the range [0,2^32-1], but it will generate
+        // `kOutOfRange` if asked to read from an offset past the current
+        // file size.
+        //
+        // There is a fair bit of overlap between `kFailedPrecondition` and
+        // `kOutOfRange`.  We recommend using `kOutOfRange` (the more specific
+        // error) when it applies so that callers who are iterating through
+        // a space can easily look for an `kOutOfRange` error to detect when
+        // they are done.
+        kOutOfRange = 11,
+
+        // StatusCode::kUnimplemented
+        //
+        // kUnimplemented (gRPC code "UNIMPLEMENTED") indicates the operation is not
+        // implemented or supported in this service. In this case, the operation
+        // should not be re-attempted.
+        kUnimplemented = 12,
+
+        // StatusCode::kInternal
+        //
+        // kInternal (gRPC code "INTERNAL") indicates an internal error has occurred
+        // and some invariants expected by the underlying system have not been
+        // satisfied. This error code is reserved for serious errors.
+        kInternal = 13,
+
+        // StatusCode::kUnavailable
+        //
+        // kUnavailable (gRPC code "UNAVAILABLE") indicates the service is currently
+        // unavailable and that this is most likely a transient condition. An error
+        // such as this can be corrected by retrying with a backoff scheme. Note that
+        // it is not always safe to retry non-idempotent operations.
+        //
+        // See the guidelines above for deciding between `kFailedPrecondition`,
+        // `kAborted`, and `kUnavailable`.
+        kUnavailable = 14,
+
+        // StatusCode::kDataLoss
+        //
+        // kDataLoss (gRPC code "DATA_LOSS") indicates that unrecoverable data loss or
+        // corruption has occurred. As this error is serious, proper alerting should
+        // be attached to errors such as this.
+        kDataLoss = 15,
+
+        // StatusCode::kUnauthenticated
+        //
+        // kUnauthenticated (gRPC code "UNAUTHENTICATED") indicates that the request
+        // does not have valid authentication credentials for the operation. Correct
+        // the authentication and try again.
+        kUnauthenticated = 16,
+
+        // StatusCode::DoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_
+        //
+        // NOTE: this error code entry should not be used and you should not rely on
+        // its value, which may change.
+        //
+        // The purpose of this enumerated value is to force people who handle status
+        // codes with `switch()` statements to *not* simply enumerate all possible
+        // values, but instead provide a "default:" case. Providing such a default
+        // case ensures that code will compile when new codes are added.
+        kDoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ = 20
+    };
+
+    // StatusCodeToString()
+    //
+    // Returns the name for the status code, or "" if it is an unknown value.
+    std::string StatusCodeToString(StatusCode code);
+
+    // operator<<
+    //
+    // Streams StatusCodeToString(code) to `os`.
+    std::ostream& operator<<(std::ostream& os, StatusCode code);
+
+    // absl::StatusToStringMode
+    //
+    // An `absl::StatusToStringMode` is an enumerated type indicating how
+    // `absl::Status::ToString()` should construct the output string for a non-ok
+    // status.
+    enum class StatusToStringMode : int
+    {
+        // ToString will not contain any extra data (such as payloads). It will only
+        // contain the error code and message, if any.
+        kWithNoExtraData = 0,
+        // ToString will contain the payloads.
+        kWithPayload = 1 << 0,
+        // ToString will include all the extra data this Status has.
+        kWithEverything = ~kWithNoExtraData,
+        // Default mode used by ToString. Its exact value might change in the future.
+        kDefault = kWithPayload,
+    };
+
+    // absl::StatusToStringMode is specified as a bitmask type, which means the
+    // following operations must be provided:
+    inline constexpr StatusToStringMode operator&(StatusToStringMode lhs, StatusToStringMode rhs)
+    {
+        return static_cast<StatusToStringMode>(static_cast<int>(lhs) & static_cast<int>(rhs));
+    }
+    inline constexpr StatusToStringMode operator|(StatusToStringMode lhs, StatusToStringMode rhs)
+    {
+        return static_cast<StatusToStringMode>(static_cast<int>(lhs) | static_cast<int>(rhs));
+    }
+    inline constexpr StatusToStringMode operator^(StatusToStringMode lhs, StatusToStringMode rhs)
+    {
+        return static_cast<StatusToStringMode>(static_cast<int>(lhs) ^ static_cast<int>(rhs));
+    }
+    inline constexpr StatusToStringMode operator~(StatusToStringMode arg)
+    {
+        return static_cast<StatusToStringMode>(~static_cast<int>(arg));
+    }
+    inline StatusToStringMode& operator&=(StatusToStringMode& lhs, StatusToStringMode rhs)
+    {
+        lhs = lhs & rhs;
+        return lhs;
+    }
+    inline StatusToStringMode& operator|=(StatusToStringMode& lhs, StatusToStringMode rhs)
+    {
+        lhs = lhs | rhs;
+        return lhs;
+    }
+    inline StatusToStringMode& operator^=(StatusToStringMode& lhs, StatusToStringMode rhs)
+    {
+        lhs = lhs ^ rhs;
+        return lhs;
+    }
+
+    // absl::Status
+    //
+    // The `absl::Status` class is generally used to gracefully handle errors
+    // across API boundaries (and in particular across RPC boundaries). Some of
+    // these errors may be recoverable, but others may not. Most
+    // functions which can produce a recoverable error should be designed to return
+    // either an `absl::Status` (or the similar `absl::StatusOr<T>`, which holds
+    // either an object of type `T` or an error).
+    //
+    // API developers should construct their functions to return `absl::OkStatus()`
+    // upon success, or an `absl::StatusCode` upon another type of error (e.g
+    // an `absl::StatusCode::kInvalidArgument` error). The API provides convenience
+    // functions to construct each status code.
+    //
+    // Example:
+    //
+    // absl::Status myFunction(absl::string_view fname, ...) {
+    //   ...
+    //   // encounter error
+    //   if (error condition) {
+    //     // Construct an absl::StatusCode::kInvalidArgument error
+    //     return absl::InvalidArgumentError("bad mode");
+    //   }
+    //   // else, return OK
+    //   return absl::OkStatus();
+    // }
+    //
+    // Users handling status error codes should prefer checking for an OK status
+    // using the `ok()` member function. Handling multiple error codes may justify
+    // use of switch statement, but only check for error codes you know how to
+    // handle; do not try to exhaustively match against all canonical error codes.
+    // Errors that cannot be handled should be logged and/or propagated for higher
+    // levels to deal with. If you do use a switch statement, make sure that you
+    // also provide a `default:` switch case, so that code does not break as other
+    // canonical codes are added to the API.
+    //
+    // Example:
+    //
+    //   absl::Status result = DoSomething();
+    //   if (!result.ok()) {
+    //     LOG(ERROR) << result;
+    //   }
+    //
+    //   // Provide a default if switching on multiple error codes
+    //   switch (result.code()) {
+    //     // The user hasn't authenticated. Ask them to reauth
+    //     case absl::StatusCode::kUnauthenticated:
+    //       DoReAuth();
+    //       break;
+    //     // The user does not have permission. Log an error.
+    //     case absl::StatusCode::kPermissionDenied:
+    //       LOG(ERROR) << result;
+    //       break;
+    //     // Propagate the error otherwise.
+    //     default:
+    //       return true;
+    //   }
+    //
+    // An `absl::Status` can optionally include a payload with more information
+    // about the error. Typically, this payload serves one of several purposes:
+    //
+    //   * It may provide more fine-grained semantic information about the error to
+    //     facilitate actionable remedies.
+    //   * It may provide human-readable contexual information that is more
+    //     appropriate to display to an end user.
+    //
+    // Example:
+    //
+    //   absl::Status result = DoSomething();
+    //   // Inform user to retry after 30 seconds
+    //   // See more error details in googleapis/google/rpc/error_details.proto
+    //   if (absl::IsResourceExhausted(result)) {
+    //     google::rpc::RetryInfo info;
+    //     info.retry_delay().seconds() = 30;
+    //     // Payloads require a unique key (a URL to ensure no collisions with
+    //     // other payloads), and an `absl::Cord` to hold the encoded data.
+    //     absl::string_view url = "type.googleapis.com/google.rpc.RetryInfo";
+    //     result.SetPayload(url, info.SerializeAsCord());
+    //     return result;
+    //   }
+    //
+    // For documentation see https://abseil.io/docs/cpp/guides/status.
+    //
+    // Returned Status objects may not be ignored. status_internal.h has a forward
+    // declaration of the form
+    // class ABSL_MUST_USE_RESULT Status;
+    class Status final
+    {
+    public:
+        // Constructors
+
+        // This default constructor creates an OK status with no message or payload.
+        // Avoid this constructor and prefer explicit construction of an OK status
+        // with `absl::OkStatus()`.
+        Status();
+
+        // Creates a status in the canonical error space with the specified
+        // `absl::StatusCode` and error message.  If `code == absl::StatusCode::kOk`,  // NOLINT
+        // `msg` is ignored and an object identical to an OK status is constructed.
+        //
+        // The `msg` string must be in UTF-8. The implementation may complain (e.g.,  // NOLINT
+        // by printing a warning) if it is not.
+        Status(absl::StatusCode code, absl::string_view msg);
+
+        Status(const Status&);
+        Status& operator=(const Status& x);
+
+        // Move operators
+
+        // The moved-from state is valid but unspecified.
+        Status(Status&&) noexcept;
+        Status& operator=(Status&&);
+
+        ~Status();
+
+        // Status::Update()
+        //
+        // Updates the existing status with `new_status` provided that `this->ok()`.
+        // If the existing status already contains a non-OK error, this update has no
+        // effect and preserves the current data. Note that this behavior may change
+        // in the future to augment a current non-ok status with additional
+        // information about `new_status`.
+        //
+        // `Update()` provides a convenient way of keeping track of the first error
+        // encountered.
+        //
+        // Example:
+        //   // Instead of "if (overall_status.ok()) overall_status = new_status"
+        //   overall_status.Update(new_status);
+        //
+        void Update(const Status& new_status);
+        void Update(Status&& new_status);
+
+        // Status::ok()
+        //
+        // Returns `true` if `this->code()` == `absl::StatusCode::kOk`,
+        // indicating the absence of an error.
+        // Prefer checking for an OK status using this member function.
+        ABSL_MUST_USE_RESULT bool ok() const;
+
+        // Status::code()
+        //
+        // Returns the canonical error code of type `absl::StatusCode` of this status.
+        absl::StatusCode code() const;
+
+        // Status::raw_code()
+        //
+        // Returns a raw (canonical) error code corresponding to the enum value of
+        // `google.rpc.Code` definitions within
+        // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto.
+        // These values could be out of the range of canonical `absl::StatusCode`
+        // enum values.
+        //
+        // NOTE: This function should only be called when converting to an associated
+        // wire format. Use `Status::code()` for error handling.
+        int raw_code() const;
+
+        // Status::message()
+        //
+        // Returns the error message associated with this error code, if available.
+        // Note that this message rarely describes the error code.  It is not unusual
+        // for the error message to be the empty string. As a result, prefer
+        // `operator<<` or `Status::ToString()` for debug logging.
+        absl::string_view message() const;
+
+        friend bool operator==(const Status&, const Status&);
+        friend bool operator!=(const Status&, const Status&);
+
+        // Status::ToString()
+        //
+        // Returns a string based on the `mode`. By default, it returns combination of
+        // the error code name, the message and any associated payload messages. This
+        // string is designed simply to be human readable and its exact format should
+        // not be load bearing. Do not depend on the exact format of the result of
+        // `ToString()` which is subject to change.
+        //
+        // The printed code name and the message are generally substrings of the
+        // result, and the payloads to be printed use the status payload printer
+        // mechanism (which is internal).
+        std::string ToString(
+            StatusToStringMode mode = StatusToStringMode::kDefault
+        ) const;
+
+        // Status::IgnoreError()
+        //
+        // Ignores any errors. This method does nothing except potentially suppress
+        // complaints from any tools that are checking that errors are not dropped on
+        // the floor.
+        void IgnoreError() const;
+
+        // swap()
+        //
+        // Swap the contents of one status with another.
+        friend void swap(Status& a, Status& b);
+
+        //----------------------------------------------------------------------------
+        // Payload Management APIs
+        //----------------------------------------------------------------------------
+
+        // A payload may be attached to a status to provide additional context to an
+        // error that may not be satisfied by an existing `absl::StatusCode`.
+        // Typically, this payload serves one of several purposes:
+        //
+        //   * It may provide more fine-grained semantic information about the error
+        //     to facilitate actionable remedies.
+        //   * It may provide human-readable contexual information that is more
+        //     appropriate to display to an end user.
+        //
+        // A payload consists of a [key,value] pair, where the key is a string
+        // referring to a unique "type URL" and the value is an object of type
+        // `absl::Cord` to hold the contextual data.
+        //
+        // The "type URL" should be unique and follow the format of a URL
+        // (https://en.wikipedia.org/wiki/URL) and, ideally, provide some
+        // documentation or schema on how to interpret its associated data. For
+        // example, the default type URL for a protobuf message type is
+        // "type.googleapis.com/packagename.messagename". Other custom wire formats
+        // should define the format of type URL in a similar practice so as to
+        // minimize the chance of conflict between type URLs.
+        // Users should ensure that the type URL can be mapped to a concrete
+        // C++ type if they want to deserialize the payload and read it effectively.
+        //
+        // To attach a payload to a status object, call `Status::SetPayload()`,
+        // passing it the type URL and an `absl::Cord` of associated data. Similarly,
+        // to extract the payload from a status, call `Status::GetPayload()`. You
+        // may attach multiple payloads (with differing type URLs) to any given
+        // status object, provided that the status is currently exhibiting an error
+        // code (i.e. is not OK).
+
+        // Status::GetPayload()
+        //
+        // Gets the payload of a status given its unique `type_url` key, if present.
+        absl::optional<absl::Cord> GetPayload(absl::string_view type_url) const;
+
+        // Status::SetPayload()
+        //
+        // Sets the payload for a non-ok status using a `type_url` key, overwriting
+        // any existing payload for that `type_url`.
+        //
+        // NOTE: This function does nothing if the Status is ok.
+        void SetPayload(absl::string_view type_url, absl::Cord payload);
+
+        // Status::ErasePayload()
+        //
+        // Erases the payload corresponding to the `type_url` key.  Returns `true` if
+        // the payload was present.
+        bool ErasePayload(absl::string_view type_url);
+
+        // Status::ForEachPayload()
+        //
+        // Iterates over the stored payloads and calls the
+        // `visitor(type_key, payload)` callable for each one.
+        //
+        // NOTE: The order of calls to `visitor()` is not specified and may change at
+        // any time.
+        //
+        // NOTE: Any mutation on the same 'absl::Status' object during visitation is
+        // forbidden and could result in undefined behavior.
+        void ForEachPayload(
+            absl::FunctionRef<void(absl::string_view, const absl::Cord&)> visitor
+        )
+            const;
+
+    private:
+        friend Status CancelledError();
+
+        // Creates a status in the canonical error space with the specified
+        // code, and an empty error message.
+        explicit Status(absl::StatusCode code);
+
+        static void UnrefNonInlined(uintptr_t rep);
+        static void Ref(uintptr_t rep);
+        static void Unref(uintptr_t rep);
+
+        // REQUIRES: !ok()
+        // Ensures rep_ is not shared with any other Status.
+        void PrepareToModify();
+
+        const status_internal::Payloads* GetPayloads() const;
+        status_internal::Payloads* GetPayloads();
+
+        static bool EqualsSlow(const absl::Status& a, const absl::Status& b);
+
+        // MSVC 14.0 limitation requires the const.
+        static constexpr const char kMovedFromString[] =
+            "Status accessed after move.";
+
+        static const std::string* EmptyString();
+        static const std::string* MovedFromString();
+
+        // Returns whether rep contains an inlined representation.
+        // See rep_ for details.
+        static bool IsInlined(uintptr_t rep);
+
+        // Indicates whether this Status was the rhs of a move operation. See rep_
+        // for details.
+        static bool IsMovedFrom(uintptr_t rep);
+        static uintptr_t MovedFromRep();
+
+        // Convert between error::Code and the inlined uintptr_t representation used
+        // by rep_. See rep_ for details.
+        static uintptr_t CodeToInlinedRep(absl::StatusCode code);
+        static absl::StatusCode InlinedRepToCode(uintptr_t rep);
+
+        // Converts between StatusRep* and the external uintptr_t representation used
+        // by rep_. See rep_ for details.
+        static uintptr_t PointerToRep(status_internal::StatusRep* r);
+        static status_internal::StatusRep* RepToPointer(uintptr_t r);
+
+        std::string ToStringSlow(StatusToStringMode mode) const;
+
+        // Status supports two different representations.
+        //  - When the low bit is off it is an inlined representation.
+        //    It uses the canonical error space, no message or payload.
+        //    The error code is (rep_ >> 2).
+        //    The (rep_ & 2) bit is the "moved from" indicator, used in IsMovedFrom().
+        //  - When the low bit is on it is an external representation.
+        //    In this case all the data comes from a heap allocated Rep object.
+        //    (rep_ - 1) is a status_internal::StatusRep* pointer to that structure.
+        uintptr_t rep_;
+    };
+
+    // OkStatus()
+    //
+    // Returns an OK status, equivalent to a default constructed instance. Prefer
+    // usage of `absl::OkStatus()` when constructing such an OK status.
+    Status OkStatus();
+
+    // operator<<()
+    //
+    // Prints a human-readable representation of `x` to `os`.
+    std::ostream& operator<<(std::ostream& os, const Status& x);
+
+    // IsAborted()
+    // IsAlreadyExists()
+    // IsCancelled()
+    // IsDataLoss()
+    // IsDeadlineExceeded()
+    // IsFailedPrecondition()
+    // IsInternal()
+    // IsInvalidArgument()
+    // IsNotFound()
+    // IsOutOfRange()
+    // IsPermissionDenied()
+    // IsResourceExhausted()
+    // IsUnauthenticated()
+    // IsUnavailable()
+    // IsUnimplemented()
+    // IsUnknown()
+    //
+    // These convenience functions return `true` if a given status matches the
+    // `absl::StatusCode` error code of its associated function.
+    ABSL_MUST_USE_RESULT bool IsAborted(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsInternal(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status);
+    ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status);
+
+    // AbortedError()
+    // AlreadyExistsError()
+    // CancelledError()
+    // DataLossError()
+    // DeadlineExceededError()
+    // FailedPreconditionError()
+    // InternalError()
+    // InvalidArgumentError()
+    // NotFoundError()
+    // OutOfRangeError()
+    // PermissionDeniedError()
+    // ResourceExhaustedError()
+    // UnauthenticatedError()
+    // UnavailableError()
+    // UnimplementedError()
+    // UnknownError()
+    //
+    // These convenience functions create an `absl::Status` object with an error
+    // code as indicated by the associated function name, using the error message
+    // passed in `message`.
+    Status AbortedError(absl::string_view message);
+    Status AlreadyExistsError(absl::string_view message);
+    Status CancelledError(absl::string_view message);
+    Status DataLossError(absl::string_view message);
+    Status DeadlineExceededError(absl::string_view message);
+    Status FailedPreconditionError(absl::string_view message);
+    Status InternalError(absl::string_view message);
+    Status InvalidArgumentError(absl::string_view message);
+    Status NotFoundError(absl::string_view message);
+    Status OutOfRangeError(absl::string_view message);
+    Status PermissionDeniedError(absl::string_view message);
+    Status ResourceExhaustedError(absl::string_view message);
+    Status UnauthenticatedError(absl::string_view message);
+    Status UnavailableError(absl::string_view message);
+    Status UnimplementedError(absl::string_view message);
+    Status UnknownError(absl::string_view message);
+
+    // ErrnoToStatusCode()
+    //
+    // Returns the StatusCode for `error_number`, which should be an `errno` value.
+    // See https://en.cppreference.com/w/cpp/error/errno_macros and similar
+    // references.
+    absl::StatusCode ErrnoToStatusCode(int error_number);
+
+    // ErrnoToStatus()
+    //
+    // Convenience function that creates a `absl::Status` using an `error_number`,
+    // which should be an `errno` value.
+    Status ErrnoToStatus(int error_number, absl::string_view message);
+
+    //------------------------------------------------------------------------------
+    // Implementation details follow
+    //------------------------------------------------------------------------------
+
+    inline Status::Status() :
+        rep_(CodeToInlinedRep(absl::StatusCode::kOk))
+    {
+    }
+
+    inline Status::Status(absl::StatusCode code) :
+        rep_(CodeToInlinedRep(code))
+    {
+    }
+
+    inline Status::Status(const Status& x) :
+        rep_(x.rep_)
+    {
+        Ref(rep_);
+    }
+
+    inline Status& Status::operator=(const Status& x)
+    {
+        uintptr_t old_rep = rep_;
+        if (x.rep_ != old_rep)
+        {
+            Ref(x.rep_);
+            rep_ = x.rep_;
+            Unref(old_rep);
+        }
+        return *this;
+    }
+
+    inline Status::Status(Status&& x) noexcept :
+        rep_(x.rep_)
+    {
+        x.rep_ = MovedFromRep();
+    }
+
+    inline Status& Status::operator=(Status&& x)
+    {
+        uintptr_t old_rep = rep_;
+        if (x.rep_ != old_rep)
+        {
+            rep_ = x.rep_;
+            x.rep_ = MovedFromRep();
+            Unref(old_rep);
+        }
+        return *this;
+    }
+
+    inline void Status::Update(const Status& new_status)
+    {
+        if (ok())
+        {
+            *this = new_status;
+        }
+    }
+
+    inline void Status::Update(Status&& new_status)
+    {
+        if (ok())
+        {
+            *this = std::move(new_status);
+        }
+    }
+
+    inline Status::~Status()
+    {
+        Unref(rep_);
+    }
+
+    inline bool Status::ok() const
+    {
+        return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
+    }
+
+    inline absl::string_view Status::message() const
+    {
+        return !IsInlined(rep_) ? RepToPointer(rep_)->message : (IsMovedFrom(rep_) ? absl::string_view(kMovedFromString) : absl::string_view());
+    }
+
+    inline bool operator==(const Status& lhs, const Status& rhs)
+    {
+        return lhs.rep_ == rhs.rep_ || Status::EqualsSlow(lhs, rhs);
+    }
+
+    inline bool operator!=(const Status& lhs, const Status& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+    inline std::string Status::ToString(StatusToStringMode mode) const
+    {
+        return ok() ? "OK" : ToStringSlow(mode);
+    }
+
+    inline void Status::IgnoreError() const
+    {
+        // no-op
+    }
+
+    inline void swap(absl::Status& a, absl::Status& b)
+    {
+        using std::swap;
+        swap(a.rep_, b.rep_);
+    }
+
+    inline const status_internal::Payloads* Status::GetPayloads() const
+    {
+        return IsInlined(rep_) ? nullptr : RepToPointer(rep_)->payloads.get();
+    }
+
+    inline status_internal::Payloads* Status::GetPayloads()
+    {
+        return IsInlined(rep_) ? nullptr : RepToPointer(rep_)->payloads.get();
+    }
+
+    inline bool Status::IsInlined(uintptr_t rep)
+    {
+        return (rep & 1) == 0;
+    }
+
+    inline bool Status::IsMovedFrom(uintptr_t rep)
+    {
+        return IsInlined(rep) && (rep & 2) != 0;
+    }
+
+    inline uintptr_t Status::MovedFromRep()
+    {
+        return CodeToInlinedRep(absl::StatusCode::kInternal) | 2;
+    }
+
+    inline uintptr_t Status::CodeToInlinedRep(absl::StatusCode code)
+    {
+        return static_cast<uintptr_t>(code) << 2;
+    }
+
+    inline absl::StatusCode Status::InlinedRepToCode(uintptr_t rep)
+    {
+        assert(IsInlined(rep));
+        return static_cast<absl::StatusCode>(rep >> 2);
+    }
+
+    inline status_internal::StatusRep* Status::RepToPointer(uintptr_t rep)
+    {
+        assert(!IsInlined(rep));
+        return reinterpret_cast<status_internal::StatusRep*>(rep - 1);
+    }
+
+    inline uintptr_t Status::PointerToRep(status_internal::StatusRep* rep)
+    {
+        return reinterpret_cast<uintptr_t>(rep) + 1;
+    }
+
+    inline void Status::Ref(uintptr_t rep)
+    {
+        if (!IsInlined(rep))
+        {
+            RepToPointer(rep)->ref.fetch_add(1, std::memory_order_relaxed);
+        }
+    }
+
+    inline void Status::Unref(uintptr_t rep)
+    {
+        if (!IsInlined(rep))
+        {
+            UnrefNonInlined(rep);
+        }
+    }
+
+    inline Status OkStatus()
+    {
+        return Status();
+    }
+
+    // Creates a `Status` object with the `absl::StatusCode::kCancelled` error code
+    // and an empty message. It is provided only for efficiency, given that
+    // message-less kCancelled errors are common in the infrastructure.
+    inline Status CancelledError()
+    {
+        return Status(absl::StatusCode::kCancelled);
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STATUS_STATUS_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/status_payload_printer.h b/CAPI/cpp/grpc/include/absl/status/status_payload_printer.h
index 5e0937f..2187ee0 100644
--- a/CAPI/cpp/grpc/include/absl/status/status_payload_printer.h
+++ b/CAPI/cpp/grpc/include/absl/status/status_payload_printer.h
@@ -20,32 +20,33 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace status_internal {
-
-// By default, `Status::ToString` and `operator<<(Status)` print a payload by
-// dumping the type URL and the raw bytes. To help debugging, we provide an
-// extension point, which is a global printer function that can be set by users
-// to specify how to print payloads. The function takes the type URL and the
-// payload as input, and should return a valid human-readable string on success
-// or `absl::nullopt` on failure (in which case it falls back to the default
-// approach of printing the raw bytes).
-// NOTE: This is an internal API and the design is subject to change in the
-// future in a non-backward-compatible way. Since it's only meant for debugging
-// purpose, you should not rely on it in any critical logic.
-using StatusPayloadPrinter = absl::optional<std::string> (*)(absl::string_view,
-                                                             const absl::Cord&);
-
-// Sets the global payload printer. Only one printer should be set per process.
-// If multiple printers are set, it's undefined which one will be used.
-void SetStatusPayloadPrinter(StatusPayloadPrinter);
-
-// Returns the global payload printer if previously set, otherwise `nullptr`.
-StatusPayloadPrinter GetStatusPayloadPrinter();
-
-}  // namespace status_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace status_internal
+    {
+
+        // By default, `Status::ToString` and `operator<<(Status)` print a payload by
+        // dumping the type URL and the raw bytes. To help debugging, we provide an
+        // extension point, which is a global printer function that can be set by users
+        // to specify how to print payloads. The function takes the type URL and the
+        // payload as input, and should return a valid human-readable string on success
+        // or `absl::nullopt` on failure (in which case it falls back to the default
+        // approach of printing the raw bytes).
+        // NOTE: This is an internal API and the design is subject to change in the
+        // future in a non-backward-compatible way. Since it's only meant for debugging
+        // purpose, you should not rely on it in any critical logic.
+        using StatusPayloadPrinter = absl::optional<std::string> (*)(absl::string_view, const absl::Cord&);
+
+        // Sets the global payload printer. Only one printer should be set per process.
+        // If multiple printers are set, it's undefined which one will be used.
+        void SetStatusPayloadPrinter(StatusPayloadPrinter);
+
+        // Returns the global payload printer if previously set, otherwise `nullptr`.
+        StatusPayloadPrinter GetStatusPayloadPrinter();
+
+    }  // namespace status_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
diff --git a/CAPI/cpp/grpc/include/absl/status/statusor.h b/CAPI/cpp/grpc/include/absl/status/statusor.h
index a76e720..194e1fe 100644
--- a/CAPI/cpp/grpc/include/absl/status/statusor.h
+++ b/CAPI/cpp/grpc/include/absl/status/statusor.h
@@ -51,726 +51,814 @@
 #include "absl/types/variant.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// BadStatusOrAccess
-//
-// This class defines the type of object to throw (if exceptions are enabled),
-// when accessing the value of an `absl::StatusOr<T>` object that does not
-// contain a value. This behavior is analogous to that of
-// `std::bad_optional_access` in the case of accessing an invalid
-// `std::optional` value.
-//
-// Example:
-//
-// try {
-//   absl::StatusOr<int> v = FetchInt();
-//   DoWork(v.value());  // Accessing value() when not "OK" may throw
-// } catch (absl::BadStatusOrAccess& ex) {
-//   LOG(ERROR) << ex.status();
-// }
-class BadStatusOrAccess : public std::exception {
- public:
-  explicit BadStatusOrAccess(absl::Status status);
-  ~BadStatusOrAccess() override = default;
-
-  BadStatusOrAccess(const BadStatusOrAccess& other);
-  BadStatusOrAccess& operator=(const BadStatusOrAccess& other);
-  BadStatusOrAccess(BadStatusOrAccess&& other);
-  BadStatusOrAccess& operator=(BadStatusOrAccess&& other);
-
-  // BadStatusOrAccess::what()
-  //
-  // Returns the associated explanatory string of the `absl::StatusOr<T>`
-  // object's error code. This function contains information about the failing
-  // status, but its exact formatting may change and should not be depended on.
-  //
-  // The pointer of this string is guaranteed to be valid until any non-const
-  // function is invoked on the exception object.
-  const char* what() const noexcept override;
-
-  // BadStatusOrAccess::status()
-  //
-  // Returns the associated `absl::Status` of the `absl::StatusOr<T>` object's
-  // error.
-  const absl::Status& status() const;
-
- private:
-  void InitWhat() const;
-
-  absl::Status status_;
-  mutable absl::once_flag init_what_;
-  mutable std::string what_;
-};
-
-// Returned StatusOr objects may not be ignored.
-template <typename T>
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // BadStatusOrAccess
+    //
+    // This class defines the type of object to throw (if exceptions are enabled),
+    // when accessing the value of an `absl::StatusOr<T>` object that does not
+    // contain a value. This behavior is analogous to that of
+    // `std::bad_optional_access` in the case of accessing an invalid
+    // `std::optional` value.
+    //
+    // Example:
+    //
+    // try {
+    //   absl::StatusOr<int> v = FetchInt();
+    //   DoWork(v.value());  // Accessing value() when not "OK" may throw
+    // } catch (absl::BadStatusOrAccess& ex) {
+    //   LOG(ERROR) << ex.status();
+    // }
+    class BadStatusOrAccess : public std::exception
+    {
+    public:
+        explicit BadStatusOrAccess(absl::Status status);
+        ~BadStatusOrAccess() override = default;
+
+        BadStatusOrAccess(const BadStatusOrAccess& other);
+        BadStatusOrAccess& operator=(const BadStatusOrAccess& other);
+        BadStatusOrAccess(BadStatusOrAccess&& other);
+        BadStatusOrAccess& operator=(BadStatusOrAccess&& other);
+
+        // BadStatusOrAccess::what()
+        //
+        // Returns the associated explanatory string of the `absl::StatusOr<T>`
+        // object's error code. This function contains information about the failing
+        // status, but its exact formatting may change and should not be depended on.
+        //
+        // The pointer of this string is guaranteed to be valid until any non-const
+        // function is invoked on the exception object.
+        const char* what() const noexcept override;
+
+        // BadStatusOrAccess::status()
+        //
+        // Returns the associated `absl::Status` of the `absl::StatusOr<T>` object's
+        // error.
+        const absl::Status& status() const;
+
+    private:
+        void InitWhat() const;
+
+        absl::Status status_;
+        mutable absl::once_flag init_what_;
+        mutable std::string what_;
+    };
+
+    // Returned StatusOr objects may not be ignored.
+    template<typename T>
 #if ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
-// TODO(b/176172494): ABSL_MUST_USE_RESULT should expand to the more strict
-// [[nodiscard]]. For now, just use [[nodiscard]] directly when it is available.
-class [[nodiscard]] StatusOr;
+    // TODO(b/176172494): ABSL_MUST_USE_RESULT should expand to the more strict
+    // [[nodiscard]]. For now, just use [[nodiscard]] directly when it is available.
+    class [[nodiscard]] StatusOr;
 #else
-class ABSL_MUST_USE_RESULT StatusOr;
+    class ABSL_MUST_USE_RESULT StatusOr;
 #endif  // ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
 
-// absl::StatusOr<T>
-//
-// The `absl::StatusOr<T>` class template is a union of an `absl::Status` object
-// and an object of type `T`. The `absl::StatusOr<T>` models an object that is
-// either a usable object, or an error (of type `absl::Status`) explaining why
-// such an object is not present. An `absl::StatusOr<T>` is typically the return
-// value of a function which may fail.
-//
-// An `absl::StatusOr<T>` can never hold an "OK" status (an
-// `absl::StatusCode::kOk` value); instead, the presence of an object of type
-// `T` indicates success. Instead of checking for a `kOk` value, use the
-// `absl::StatusOr<T>::ok()` member function. (It is for this reason, and code
-// readability, that using the `ok()` function is preferred for `absl::Status`
-// as well.)
-//
-// Example:
-//
-//   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-//   if (result.ok()) {
-//     result->DoSomethingCool();
-//   } else {
-//     LOG(ERROR) << result.status();
-//   }
-//
-// Accessing the object held by an `absl::StatusOr<T>` should be performed via
-// `operator*` or `operator->`, after a call to `ok()` confirms that the
-// `absl::StatusOr<T>` holds an object of type `T`:
-//
-// Example:
-//
-//   absl::StatusOr<int> i = GetCount();
-//   if (i.ok()) {
-//     updated_total += *i
-//   }
-//
-// NOTE: using `absl::StatusOr<T>::value()` when no valid value is present will
-// throw an exception if exceptions are enabled or terminate the process when
-// exceptions are not enabled.
-//
-// Example:
-//
-//   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-//   const Foo& foo = result.value();    // Crash/exception if no value present
-//   foo.DoSomethingCool();
-//
-// A `absl::StatusOr<T*>` can be constructed from a null pointer like any other
-// pointer value, and the result will be that `ok()` returns `true` and
-// `value()` returns `nullptr`. Checking the value of pointer in an
-// `absl::StatusOr<T*>` generally requires a bit more care, to ensure both that
-// a value is present and that value is not null:
-//
-//  StatusOr<std::unique_ptr<Foo>> result = FooFactory::MakeNewFoo(arg);
-//  if (!result.ok()) {
-//    LOG(ERROR) << result.status();
-//  } else if (*result == nullptr) {
-//    LOG(ERROR) << "Unexpected null pointer";
-//  } else {
-//    (*result)->DoSomethingCool();
-//  }
-//
-// Example factory implementation returning StatusOr<T>:
-//
-//  StatusOr<Foo> FooFactory::MakeFoo(int arg) {
-//    if (arg <= 0) {
-//      return absl::Status(absl::StatusCode::kInvalidArgument,
-//                          "Arg must be positive");
-//    }
-//    return Foo(arg);
-//  }
-template <typename T>
-class StatusOr : private internal_statusor::StatusOrData<T>,
-                 private internal_statusor::CopyCtorBase<T>,
-                 private internal_statusor::MoveCtorBase<T>,
-                 private internal_statusor::CopyAssignBase<T>,
-                 private internal_statusor::MoveAssignBase<T> {
-  template <typename U>
-  friend class StatusOr;
-
-  typedef internal_statusor::StatusOrData<T> Base;
-
- public:
-  // StatusOr<T>::value_type
-  //
-  // This instance data provides a generic `value_type` member for use within
-  // generic programming. This usage is analogous to that of
-  // `optional::value_type` in the case of `std::optional`.
-  typedef T value_type;
-
-  // Constructors
-
-  // Constructs a new `absl::StatusOr` with an `absl::StatusCode::kUnknown`
-  // status. This constructor is marked 'explicit' to prevent usages in return
-  // values such as 'return {};', under the misconception that
-  // `absl::StatusOr<std::vector<int>>` will be initialized with an empty
-  // vector, instead of an `absl::StatusCode::kUnknown` error code.
-  explicit StatusOr();
-
-  // `StatusOr<T>` is copy constructible if `T` is copy constructible.
-  StatusOr(const StatusOr&) = default;
-  // `StatusOr<T>` is copy assignable if `T` is copy constructible and copy
-  // assignable.
-  StatusOr& operator=(const StatusOr&) = default;
-
-  // `StatusOr<T>` is move constructible if `T` is move constructible.
-  StatusOr(StatusOr&&) = default;
-  // `StatusOr<T>` is moveAssignable if `T` is move constructible and move
-  // assignable.
-  StatusOr& operator=(StatusOr&&) = default;
-
-  // Converting Constructors
-
-  // Constructs a new `absl::StatusOr<T>` from an `absl::StatusOr<U>`, when `T`
-  // is constructible from `U`. To avoid ambiguity, these constructors are
-  // disabled if `T` is also constructible from `StatusOr<U>.`. This constructor
-  // is explicit if and only if the corresponding construction of `T` from `U`
-  // is explicit. (This constructor inherits its explicitness from the
-  // underlying constructor.)
-  template <
-      typename U,
-      absl::enable_if_t<
-          absl::conjunction<
-              absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              std::is_convertible<const U&, T>,
-              absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  StatusOr(const StatusOr<U>& other)  // NOLINT
-      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
-  template <
-      typename U,
-      absl::enable_if_t<
-          absl::conjunction<
-              absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              absl::negation<std::is_convertible<const U&, T>>,
-              absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  explicit StatusOr(const StatusOr<U>& other)
-      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
-
-  template <
-      typename U,
-      absl::enable_if_t<
-          absl::conjunction<
-              absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              std::is_convertible<U&&, T>,
-              absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  StatusOr(StatusOr<U>&& other)  // NOLINT
-      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
-  template <
-      typename U,
-      absl::enable_if_t<
-          absl::conjunction<
-              absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              absl::negation<std::is_convertible<U&&, T>>,
-              absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  explicit StatusOr(StatusOr<U>&& other)
-      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
-
-  // Converting Assignment Operators
-
-  // Creates an `absl::StatusOr<T>` through assignment from an
-  // `absl::StatusOr<U>` when:
-  //
-  //   * Both `absl::StatusOr<T>` and `absl::StatusOr<U>` are OK by assigning
-  //     `U` to `T` directly.
-  //   * `absl::StatusOr<T>` is OK and `absl::StatusOr<U>` contains an error
-  //      code by destroying `absl::StatusOr<T>`'s value and assigning from
-  //      `absl::StatusOr<U>'
-  //   * `absl::StatusOr<T>` contains an error code and `absl::StatusOr<U>` is
-  //      OK by directly initializing `T` from `U`.
-  //   * Both `absl::StatusOr<T>` and `absl::StatusOr<U>` contain an error
-  //     code by assigning the `Status` in `absl::StatusOr<U>` to
-  //     `absl::StatusOr<T>`
-  //
-  // These overloads only apply if `absl::StatusOr<T>` is constructible and
-  // assignable from `absl::StatusOr<U>` and `StatusOr<T>` cannot be directly
-  // assigned from `StatusOr<U>`.
-  template <
-      typename U,
-      absl::enable_if_t<
-          absl::conjunction<
-              absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              std::is_assignable<T, const U&>,
-              absl::negation<
-                  internal_statusor::
-                      IsConstructibleOrConvertibleOrAssignableFromStatusOr<
-                          T, U>>>::value,
-          int> = 0>
-  StatusOr& operator=(const StatusOr<U>& other) {
-    this->Assign(other);
-    return *this;
-  }
-  template <
-      typename U,
-      absl::enable_if_t<
-          absl::conjunction<
-              absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              std::is_assignable<T, U&&>,
-              absl::negation<
-                  internal_statusor::
-                      IsConstructibleOrConvertibleOrAssignableFromStatusOr<
-                          T, U>>>::value,
-          int> = 0>
-  StatusOr& operator=(StatusOr<U>&& other) {
-    this->Assign(std::move(other));
-    return *this;
-  }
-
-  // Constructs a new `absl::StatusOr<T>` with a non-ok status. After calling
-  // this constructor, `this->ok()` will be `false` and calls to `value()` will
-  // crash, or produce an exception if exceptions are enabled.
-  //
-  // The constructor also takes any type `U` that is convertible to
-  // `absl::Status`. This constructor is explicit if an only if `U` is not of
-  // type `absl::Status` and the conversion from `U` to `Status` is explicit.
-  //
-  // REQUIRES: !Status(std::forward<U>(v)).ok(). This requirement is DCHECKed.
-  // In optimized builds, passing absl::OkStatus() here will have the effect
-  // of passing absl::StatusCode::kInternal as a fallback.
-  template <
-      typename U = absl::Status,
-      absl::enable_if_t<
-          absl::conjunction<
-              std::is_convertible<U&&, absl::Status>,
-              std::is_constructible<absl::Status, U&&>,
-              absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
-              absl::negation<std::is_same<absl::decay_t<U>, T>>,
-              absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
-              absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  StatusOr(U&& v) : Base(std::forward<U>(v)) {}
-
-  template <
-      typename U = absl::Status,
-      absl::enable_if_t<
-          absl::conjunction<
-              absl::negation<std::is_convertible<U&&, absl::Status>>,
-              std::is_constructible<absl::Status, U&&>,
-              absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
-              absl::negation<std::is_same<absl::decay_t<U>, T>>,
-              absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
-              absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  explicit StatusOr(U&& v) : Base(std::forward<U>(v)) {}
-
-  template <
-      typename U = absl::Status,
-      absl::enable_if_t<
-          absl::conjunction<
-              std::is_convertible<U&&, absl::Status>,
-              std::is_constructible<absl::Status, U&&>,
-              absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
-              absl::negation<std::is_same<absl::decay_t<U>, T>>,
-              absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
-              absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  StatusOr& operator=(U&& v) {
-    this->AssignStatus(std::forward<U>(v));
-    return *this;
-  }
-
-  // Perfect-forwarding value assignment operator.
-
-  // If `*this` contains a `T` value before the call, the contained value is
-  // assigned from `std::forward<U>(v)`; Otherwise, it is directly-initialized
-  // from `std::forward<U>(v)`.
-  // This function does not participate in overload unless:
-  // 1. `std::is_constructible_v<T, U>` is true,
-  // 2. `std::is_assignable_v<T&, U>` is true.
-  // 3. `std::is_same_v<StatusOr<T>, std::remove_cvref_t<U>>` is false.
-  // 4. Assigning `U` to `T` is not ambiguous:
-  //  If `U` is `StatusOr<V>` and `T` is constructible and assignable from
-  //  both `StatusOr<V>` and `V`, the assignment is considered bug-prone and
-  //  ambiguous thus will fail to compile. For example:
-  //    StatusOr<bool> s1 = true;  // s1.ok() && *s1 == true
-  //    StatusOr<bool> s2 = false;  // s2.ok() && *s2 == false
-  //    s1 = s2;  // ambiguous, `s1 = *s2` or `s1 = bool(s2)`?
-  template <
-      typename U = T,
-      typename = typename std::enable_if<absl::conjunction<
-          std::is_constructible<T, U&&>, std::is_assignable<T&, U&&>,
-          absl::disjunction<
-              std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, T>,
-              absl::conjunction<
-                  absl::negation<std::is_convertible<U&&, absl::Status>>,
-                  absl::negation<internal_statusor::
-                                     HasConversionOperatorToStatusOr<T, U&&>>>>,
-          internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>::type>
-  StatusOr& operator=(U&& v) {
-    this->Assign(std::forward<U>(v));
-    return *this;
-  }
-
-  // Constructs the inner value `T` in-place using the provided args, using the
-  // `T(args...)` constructor.
-  template <typename... Args>
-  explicit StatusOr(absl::in_place_t, Args&&... args);
-  template <typename U, typename... Args>
-  explicit StatusOr(absl::in_place_t, std::initializer_list<U> ilist,
-                    Args&&... args);
-
-  // Constructs the inner value `T` in-place using the provided args, using the
-  // `T(U)` (direct-initialization) constructor. This constructor is only valid
-  // if `T` can be constructed from a `U`. Can accept move or copy constructors.
-  //
-  // This constructor is explicit if `U` is not convertible to `T`. To avoid
-  // ambiguity, this constructor is disabled if `U` is a `StatusOr<J>`, where
-  // `J` is convertible to `T`.
-  template <
-      typename U = T,
-      absl::enable_if_t<
-          absl::conjunction<
-              internal_statusor::IsDirectInitializationValid<T, U&&>,
-              std::is_constructible<T, U&&>, std::is_convertible<U&&, T>,
-              absl::disjunction<
-                  std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>,
-                               T>,
-                  absl::conjunction<
-                      absl::negation<std::is_convertible<U&&, absl::Status>>,
-                      absl::negation<
-                          internal_statusor::HasConversionOperatorToStatusOr<
-                              T, U&&>>>>>::value,
-          int> = 0>
-  StatusOr(U&& u)  // NOLINT
-      : StatusOr(absl::in_place, std::forward<U>(u)) {}
-
-  template <
-      typename U = T,
-      absl::enable_if_t<
-          absl::conjunction<
-              internal_statusor::IsDirectInitializationValid<T, U&&>,
-              absl::disjunction<
-                  std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>,
-                               T>,
-                  absl::conjunction<
-                      absl::negation<std::is_constructible<absl::Status, U&&>>,
-                      absl::negation<
-                          internal_statusor::HasConversionOperatorToStatusOr<
-                              T, U&&>>>>,
-              std::is_constructible<T, U&&>,
-              absl::negation<std::is_convertible<U&&, T>>>::value,
-          int> = 0>
-  explicit StatusOr(U&& u)  // NOLINT
-      : StatusOr(absl::in_place, std::forward<U>(u)) {}
-
-  // StatusOr<T>::ok()
-  //
-  // Returns whether or not this `absl::StatusOr<T>` holds a `T` value. This
-  // member function is analogous to `absl::Status::ok()` and should be used
-  // similarly to check the status of return values.
-  //
-  // Example:
-  //
-  // StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-  // if (result.ok()) {
-  //    // Handle result
-  // else {
-  //    // Handle error
-  // }
-  ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); }
-
-  // StatusOr<T>::status()
-  //
-  // Returns a reference to the current `absl::Status` contained within the
-  // `absl::StatusOr<T>`. If `absl::StatusOr<T>` contains a `T`, then this
-  // function returns `absl::OkStatus()`.
-  const Status& status() const&;
-  Status status() &&;
-
-  // StatusOr<T>::value()
-  //
-  // Returns a reference to the held value if `this->ok()`. Otherwise, throws
-  // `absl::BadStatusOrAccess` if exceptions are enabled, or is guaranteed to
-  // terminate the process if exceptions are disabled.
-  //
-  // If you have already checked the status using `this->ok()`, you probably
-  // want to use `operator*()` or `operator->()` to access the value instead of
-  // `value`.
-  //
-  // Note: for value types that are cheap to copy, prefer simple code:
-  //
-  //   T value = statusor.value();
-  //
-  // Otherwise, if the value type is expensive to copy, but can be left
-  // in the StatusOr, simply assign to a reference:
-  //
-  //   T& value = statusor.value();  // or `const T&`
-  //
-  // Otherwise, if the value type supports an efficient move, it can be
-  // used as follows:
-  //
-  //   T value = std::move(statusor).value();
-  //
-  // The `std::move` on statusor instead of on the whole expression enables
-  // warnings about possible uses of the statusor object after the move.
-  const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  const T&& value() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>:: operator*()
-  //
-  // Returns a reference to the current value.
-  //
-  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
-  //
-  // Use `this->ok()` to verify that there is a current value within the
-  // `absl::StatusOr<T>`. Alternatively, see the `value()` member function for a
-  // similar API that guarantees crashing or throwing an exception if there is
-  // no current value.
-  const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>::operator->()
-  //
-  // Returns a pointer to the current value.
-  //
-  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
-  //
-  // Use `this->ok()` to verify that there is a current value.
-  const T* operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T* operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>::value_or()
-  //
-  // Returns the current value if `this->ok() == true`. Otherwise constructs a
-  // value using the provided `default_value`.
-  //
-  // Unlike `value`, this function returns by value, copying the current value
-  // if necessary. If the value type supports an efficient move, it can be used
-  // as follows:
-  //
-  //   T value = std::move(statusor).value_or(def);
-  //
-  // Unlike with `value`, calling `std::move()` on the result of `value_or` will
-  // still trigger a copy.
-  template <typename U>
-  T value_or(U&& default_value) const&;
-  template <typename U>
-  T value_or(U&& default_value) &&;
-
-  // StatusOr<T>::IgnoreError()
-  //
-  // Ignores any errors. This method does nothing except potentially suppress
-  // complaints from any tools that are checking that errors are not dropped on
-  // the floor.
-  void IgnoreError() const;
-
-  // StatusOr<T>::emplace()
-  //
-  // Reconstructs the inner value T in-place using the provided args, using the
-  // T(args...) constructor. Returns reference to the reconstructed `T`.
-  template <typename... Args>
-  T& emplace(Args&&... args) {
-    if (ok()) {
-      this->Clear();
-      this->MakeValue(std::forward<Args>(args)...);
-    } else {
-      this->MakeValue(std::forward<Args>(args)...);
-      this->status_ = absl::OkStatus();
+    // absl::StatusOr<T>
+    //
+    // The `absl::StatusOr<T>` class template is a union of an `absl::Status` object
+    // and an object of type `T`. The `absl::StatusOr<T>` models an object that is
+    // either a usable object, or an error (of type `absl::Status`) explaining why
+    // such an object is not present. An `absl::StatusOr<T>` is typically the return
+    // value of a function which may fail.
+    //
+    // An `absl::StatusOr<T>` can never hold an "OK" status (an
+    // `absl::StatusCode::kOk` value); instead, the presence of an object of type
+    // `T` indicates success. Instead of checking for a `kOk` value, use the
+    // `absl::StatusOr<T>::ok()` member function. (It is for this reason, and code
+    // readability, that using the `ok()` function is preferred for `absl::Status`
+    // as well.)
+    //
+    // Example:
+    //
+    //   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
+    //   if (result.ok()) {
+    //     result->DoSomethingCool();
+    //   } else {
+    //     LOG(ERROR) << result.status();
+    //   }
+    //
+    // Accessing the object held by an `absl::StatusOr<T>` should be performed via
+    // `operator*` or `operator->`, after a call to `ok()` confirms that the
+    // `absl::StatusOr<T>` holds an object of type `T`:
+    //
+    // Example:
+    //
+    //   absl::StatusOr<int> i = GetCount();
+    //   if (i.ok()) {
+    //     updated_total += *i
+    //   }
+    //
+    // NOTE: using `absl::StatusOr<T>::value()` when no valid value is present will
+    // throw an exception if exceptions are enabled or terminate the process when
+    // exceptions are not enabled.
+    //
+    // Example:
+    //
+    //   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
+    //   const Foo& foo = result.value();    // Crash/exception if no value present
+    //   foo.DoSomethingCool();
+    //
+    // A `absl::StatusOr<T*>` can be constructed from a null pointer like any other
+    // pointer value, and the result will be that `ok()` returns `true` and
+    // `value()` returns `nullptr`. Checking the value of pointer in an
+    // `absl::StatusOr<T*>` generally requires a bit more care, to ensure both that
+    // a value is present and that value is not null:
+    //
+    //  StatusOr<std::unique_ptr<Foo>> result = FooFactory::MakeNewFoo(arg);
+    //  if (!result.ok()) {
+    //    LOG(ERROR) << result.status();
+    //  } else if (*result == nullptr) {
+    //    LOG(ERROR) << "Unexpected null pointer";
+    //  } else {
+    //    (*result)->DoSomethingCool();
+    //  }
+    //
+    // Example factory implementation returning StatusOr<T>:
+    //
+    //  StatusOr<Foo> FooFactory::MakeFoo(int arg) {
+    //    if (arg <= 0) {
+    //      return absl::Status(absl::StatusCode::kInvalidArgument,
+    //                          "Arg must be positive");
+    //    }
+    //    return Foo(arg);
+    //  }
+    template<typename T>
+    class StatusOr : private internal_statusor::StatusOrData<T>, private internal_statusor::CopyCtorBase<T>, private internal_statusor::MoveCtorBase<T>, private internal_statusor::CopyAssignBase<T>, private internal_statusor::MoveAssignBase<T>
+    {
+        template<typename U>
+        friend class StatusOr;
+
+        typedef internal_statusor::StatusOrData<T> Base;
+
+    public:
+        // StatusOr<T>::value_type
+        //
+        // This instance data provides a generic `value_type` member for use within
+        // generic programming. This usage is analogous to that of
+        // `optional::value_type` in the case of `std::optional`.
+        typedef T value_type;
+
+        // Constructors
+
+        // Constructs a new `absl::StatusOr` with an `absl::StatusCode::kUnknown`
+        // status. This constructor is marked 'explicit' to prevent usages in return
+        // values such as 'return {};', under the misconception that
+        // `absl::StatusOr<std::vector<int>>` will be initialized with an empty
+        // vector, instead of an `absl::StatusCode::kUnknown` error code.
+        explicit StatusOr();
+
+        // `StatusOr<T>` is copy constructible if `T` is copy constructible.
+        StatusOr(const StatusOr&) = default;
+        // `StatusOr<T>` is copy assignable if `T` is copy constructible and copy
+        // assignable.
+        StatusOr& operator=(const StatusOr&) = default;
+
+        // `StatusOr<T>` is move constructible if `T` is move constructible.
+        StatusOr(StatusOr&&) = default;
+        // `StatusOr<T>` is moveAssignable if `T` is move constructible and move
+        // assignable.
+        StatusOr& operator=(StatusOr&&) = default;
+
+        // Converting Constructors
+
+        // Constructs a new `absl::StatusOr<T>` from an `absl::StatusOr<U>`, when `T`
+        // is constructible from `U`. To avoid ambiguity, these constructors are
+        // disabled if `T` is also constructible from `StatusOr<U>.`. This constructor
+        // is explicit if and only if the corresponding construction of `T` from `U`
+        // is explicit. (This constructor inherits its explicitness from the
+        // underlying constructor.)
+        template<
+            typename U,
+            absl::enable_if_t<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U>>,
+                    std::is_constructible<T, const U&>,
+                    std::is_convertible<const U&, T>,
+                    absl::negation<
+                        internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
+                            T,
+                            U>>>::value,
+                int> = 0>
+        StatusOr(const StatusOr<U>& other)  // NOLINT
+            :
+            Base(static_cast<const typename StatusOr<U>::Base&>(other))
+        {
+        }
+        template<
+            typename U,
+            absl::enable_if_t<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U>>,
+                    std::is_constructible<T, const U&>,
+                    absl::negation<std::is_convertible<const U&, T>>,
+                    absl::negation<
+                        internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
+                            T,
+                            U>>>::value,
+                int> = 0>
+        explicit StatusOr(const StatusOr<U>& other) :
+            Base(static_cast<const typename StatusOr<U>::Base&>(other))
+        {
+        }
+
+        template<
+            typename U,
+            absl::enable_if_t<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U>>,
+                    std::is_constructible<T, U&&>,
+                    std::is_convertible<U&&, T>,
+                    absl::negation<
+                        internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
+                            T,
+                            U>>>::value,
+                int> = 0>
+        StatusOr(StatusOr<U>&& other)  // NOLINT
+            :
+            Base(static_cast<typename StatusOr<U>::Base&&>(other))
+        {
+        }
+        template<
+            typename U,
+            absl::enable_if_t<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U>>,
+                    std::is_constructible<T, U&&>,
+                    absl::negation<std::is_convertible<U&&, T>>,
+                    absl::negation<
+                        internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
+                            T,
+                            U>>>::value,
+                int> = 0>
+        explicit StatusOr(StatusOr<U>&& other) :
+            Base(static_cast<typename StatusOr<U>::Base&&>(other))
+        {
+        }
+
+        // Converting Assignment Operators
+
+        // Creates an `absl::StatusOr<T>` through assignment from an
+        // `absl::StatusOr<U>` when:
+        //
+        //   * Both `absl::StatusOr<T>` and `absl::StatusOr<U>` are OK by assigning
+        //     `U` to `T` directly.
+        //   * `absl::StatusOr<T>` is OK and `absl::StatusOr<U>` contains an error
+        //      code by destroying `absl::StatusOr<T>`'s value and assigning from
+        //      `absl::StatusOr<U>'
+        //   * `absl::StatusOr<T>` contains an error code and `absl::StatusOr<U>` is
+        //      OK by directly initializing `T` from `U`.
+        //   * Both `absl::StatusOr<T>` and `absl::StatusOr<U>` contain an error
+        //     code by assigning the `Status` in `absl::StatusOr<U>` to
+        //     `absl::StatusOr<T>`
+        //
+        // These overloads only apply if `absl::StatusOr<T>` is constructible and
+        // assignable from `absl::StatusOr<U>` and `StatusOr<T>` cannot be directly
+        // assigned from `StatusOr<U>`.
+        template<
+            typename U,
+            absl::enable_if_t<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U>>,
+                    std::is_constructible<T, const U&>,
+                    std::is_assignable<T, const U&>,
+                    absl::negation<
+                        internal_statusor::
+                            IsConstructibleOrConvertibleOrAssignableFromStatusOr<
+                                T,
+                                U>>>::value,
+                int> = 0>
+        StatusOr& operator=(const StatusOr<U>& other)
+        {
+            this->Assign(other);
+            return *this;
+        }
+        template<
+            typename U,
+            absl::enable_if_t<
+                absl::conjunction<
+                    absl::negation<std::is_same<T, U>>,
+                    std::is_constructible<T, U&&>,
+                    std::is_assignable<T, U&&>,
+                    absl::negation<
+                        internal_statusor::
+                            IsConstructibleOrConvertibleOrAssignableFromStatusOr<
+                                T,
+                                U>>>::value,
+                int> = 0>
+        StatusOr& operator=(StatusOr<U>&& other)
+        {
+            this->Assign(std::move(other));
+            return *this;
+        }
+
+        // Constructs a new `absl::StatusOr<T>` with a non-ok status. After calling
+        // this constructor, `this->ok()` will be `false` and calls to `value()` will
+        // crash, or produce an exception if exceptions are enabled.
+        //
+        // The constructor also takes any type `U` that is convertible to
+        // `absl::Status`. This constructor is explicit if an only if `U` is not of
+        // type `absl::Status` and the conversion from `U` to `Status` is explicit.
+        //
+        // REQUIRES: !Status(std::forward<U>(v)).ok(). This requirement is DCHECKed.
+        // In optimized builds, passing absl::OkStatus() here will have the effect
+        // of passing absl::StatusCode::kInternal as a fallback.
+        template<
+            typename U = absl::Status,
+            absl::enable_if_t<
+                absl::conjunction<
+                    std::is_convertible<U&&, absl::Status>,
+                    std::is_constructible<absl::Status, U&&>,
+                    absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
+                    absl::negation<std::is_same<absl::decay_t<U>, T>>,
+                    absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
+                    absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
+                        T,
+                        U&&>>>::value,
+                int> = 0>
+        StatusOr(U&& v) :
+            Base(std::forward<U>(v))
+        {
+        }
+
+        template<
+            typename U = absl::Status,
+            absl::enable_if_t<
+                absl::conjunction<
+                    absl::negation<std::is_convertible<U&&, absl::Status>>,
+                    std::is_constructible<absl::Status, U&&>,
+                    absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
+                    absl::negation<std::is_same<absl::decay_t<U>, T>>,
+                    absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
+                    absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
+                        T,
+                        U&&>>>::value,
+                int> = 0>
+        explicit StatusOr(U&& v) :
+            Base(std::forward<U>(v))
+        {
+        }
+
+        template<
+            typename U = absl::Status,
+            absl::enable_if_t<
+                absl::conjunction<
+                    std::is_convertible<U&&, absl::Status>,
+                    std::is_constructible<absl::Status, U&&>,
+                    absl::negation<std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>,
+                    absl::negation<std::is_same<absl::decay_t<U>, T>>,
+                    absl::negation<std::is_same<absl::decay_t<U>, absl::in_place_t>>,
+                    absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
+                        T,
+                        U&&>>>::value,
+                int> = 0>
+        StatusOr& operator=(U&& v)
+        {
+            this->AssignStatus(std::forward<U>(v));
+            return *this;
+        }
+
+        // Perfect-forwarding value assignment operator.
+
+        // If `*this` contains a `T` value before the call, the contained value is
+        // assigned from `std::forward<U>(v)`; Otherwise, it is directly-initialized
+        // from `std::forward<U>(v)`.
+        // This function does not participate in overload unless:
+        // 1. `std::is_constructible_v<T, U>` is true,
+        // 2. `std::is_assignable_v<T&, U>` is true.
+        // 3. `std::is_same_v<StatusOr<T>, std::remove_cvref_t<U>>` is false.
+        // 4. Assigning `U` to `T` is not ambiguous:
+        //  If `U` is `StatusOr<V>` and `T` is constructible and assignable from
+        //  both `StatusOr<V>` and `V`, the assignment is considered bug-prone and
+        //  ambiguous thus will fail to compile. For example:
+        //    StatusOr<bool> s1 = true;  // s1.ok() && *s1 == true
+        //    StatusOr<bool> s2 = false;  // s2.ok() && *s2 == false
+        //    s1 = s2;  // ambiguous, `s1 = *s2` or `s1 = bool(s2)`?
+        template<
+            typename U = T,
+            typename = typename std::enable_if<absl::conjunction<
+                std::is_constructible<T, U&&>,
+                std::is_assignable<T&, U&&>,
+                absl::disjunction<
+                    std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, T>,
+                    absl::conjunction<
+                        absl::negation<std::is_convertible<U&&, absl::Status>>,
+                        absl::negation<internal_statusor::
+                                           HasConversionOperatorToStatusOr<T, U&&>>>>,
+                internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>::type>
+        StatusOr& operator=(U&& v)
+        {
+            this->Assign(std::forward<U>(v));
+            return *this;
+        }
+
+        // Constructs the inner value `T` in-place using the provided args, using the
+        // `T(args...)` constructor.
+        template<typename... Args>
+        explicit StatusOr(absl::in_place_t, Args&&... args);
+        template<typename U, typename... Args>
+        explicit StatusOr(absl::in_place_t, std::initializer_list<U> ilist, Args&&... args);
+
+        // Constructs the inner value `T` in-place using the provided args, using the
+        // `T(U)` (direct-initialization) constructor. This constructor is only valid
+        // if `T` can be constructed from a `U`. Can accept move or copy constructors.
+        //
+        // This constructor is explicit if `U` is not convertible to `T`. To avoid
+        // ambiguity, this constructor is disabled if `U` is a `StatusOr<J>`, where
+        // `J` is convertible to `T`.
+        template<
+            typename U = T,
+            absl::enable_if_t<
+                absl::conjunction<
+                    internal_statusor::IsDirectInitializationValid<T, U&&>,
+                    std::is_constructible<T, U&&>,
+                    std::is_convertible<U&&, T>,
+                    absl::disjunction<
+                        std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, T>,
+                        absl::conjunction<
+                            absl::negation<std::is_convertible<U&&, absl::Status>>,
+                            absl::negation<
+                                internal_statusor::HasConversionOperatorToStatusOr<
+                                    T,
+                                    U&&>>>>>::value,
+                int> = 0>
+        StatusOr(U&& u)  // NOLINT
+            :
+            StatusOr(absl::in_place, std::forward<U>(u))
+        {
+        }
+
+        template<
+            typename U = T,
+            absl::enable_if_t<
+                absl::conjunction<
+                    internal_statusor::IsDirectInitializationValid<T, U&&>,
+                    absl::disjunction<
+                        std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, T>,
+                        absl::conjunction<
+                            absl::negation<std::is_constructible<absl::Status, U&&>>,
+                            absl::negation<
+                                internal_statusor::HasConversionOperatorToStatusOr<
+                                    T,
+                                    U&&>>>>,
+                    std::is_constructible<T, U&&>,
+                    absl::negation<std::is_convertible<U&&, T>>>::value,
+                int> = 0>
+        explicit StatusOr(U&& u)  // NOLINT
+            :
+            StatusOr(absl::in_place, std::forward<U>(u))
+        {
+        }
+
+        // StatusOr<T>::ok()
+        //
+        // Returns whether or not this `absl::StatusOr<T>` holds a `T` value. This
+        // member function is analogous to `absl::Status::ok()` and should be used
+        // similarly to check the status of return values.
+        //
+        // Example:
+        //
+        // StatusOr<Foo> result = DoBigCalculationThatCouldFail();
+        // if (result.ok()) {
+        //    // Handle result
+        // else {
+        //    // Handle error
+        // }
+        ABSL_MUST_USE_RESULT bool ok() const
+        {
+            return this->status_.ok();
+        }
+
+        // StatusOr<T>::status()
+        //
+        // Returns a reference to the current `absl::Status` contained within the
+        // `absl::StatusOr<T>`. If `absl::StatusOr<T>` contains a `T`, then this
+        // function returns `absl::OkStatus()`.
+        const Status& status() const&;
+        Status status() &&;
+
+        // StatusOr<T>::value()
+        //
+        // Returns a reference to the held value if `this->ok()`. Otherwise, throws
+        // `absl::BadStatusOrAccess` if exceptions are enabled, or is guaranteed to
+        // terminate the process if exceptions are disabled.
+        //
+        // If you have already checked the status using `this->ok()`, you probably
+        // want to use `operator*()` or `operator->()` to access the value instead of
+        // `value`.
+        //
+        // Note: for value types that are cheap to copy, prefer simple code:
+        //
+        //   T value = statusor.value();
+        //
+        // Otherwise, if the value type is expensive to copy, but can be left
+        // in the StatusOr, simply assign to a reference:
+        //
+        //   T& value = statusor.value();  // or `const T&`
+        //
+        // Otherwise, if the value type supports an efficient move, it can be
+        // used as follows:
+        //
+        //   T value = std::move(statusor).value();
+        //
+        // The `std::move` on statusor instead of on the whole expression enables
+        // warnings about possible uses of the statusor object after the move.
+        const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
+        T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
+        const T&& value() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
+        T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+        // StatusOr<T>:: operator*()
+        //
+        // Returns a reference to the current value.
+        //
+        // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
+        //
+        // Use `this->ok()` to verify that there is a current value within the
+        // `absl::StatusOr<T>`. Alternatively, see the `value()` member function for a
+        // similar API that guarantees crashing or throwing an exception if there is
+        // no current value.
+        const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
+        T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
+        const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
+        T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+        // StatusOr<T>::operator->()
+        //
+        // Returns a pointer to the current value.
+        //
+        // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
+        //
+        // Use `this->ok()` to verify that there is a current value.
+        const T* operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
+        T* operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND;
+
+        // StatusOr<T>::value_or()
+        //
+        // Returns the current value if `this->ok() == true`. Otherwise constructs a
+        // value using the provided `default_value`.
+        //
+        // Unlike `value`, this function returns by value, copying the current value
+        // if necessary. If the value type supports an efficient move, it can be used
+        // as follows:
+        //
+        //   T value = std::move(statusor).value_or(def);
+        //
+        // Unlike with `value`, calling `std::move()` on the result of `value_or` will
+        // still trigger a copy.
+        template<typename U>
+        T value_or(U&& default_value) const&;
+        template<typename U>
+        T value_or(U&& default_value) &&;
+
+        // StatusOr<T>::IgnoreError()
+        //
+        // Ignores any errors. This method does nothing except potentially suppress
+        // complaints from any tools that are checking that errors are not dropped on
+        // the floor.
+        void IgnoreError() const;
+
+        // StatusOr<T>::emplace()
+        //
+        // Reconstructs the inner value T in-place using the provided args, using the
+        // T(args...) constructor. Returns reference to the reconstructed `T`.
+        template<typename... Args>
+        T& emplace(Args&&... args)
+        {
+            if (ok())
+            {
+                this->Clear();
+                this->MakeValue(std::forward<Args>(args)...);
+            }
+            else
+            {
+                this->MakeValue(std::forward<Args>(args)...);
+                this->status_ = absl::OkStatus();
+            }
+            return this->data_;
+        }
+
+        template<
+            typename U,
+            typename... Args,
+            absl::enable_if_t<
+                std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
+                int> = 0>
+        T& emplace(std::initializer_list<U> ilist, Args&&... args)
+        {
+            if (ok())
+            {
+                this->Clear();
+                this->MakeValue(ilist, std::forward<Args>(args)...);
+            }
+            else
+            {
+                this->MakeValue(ilist, std::forward<Args>(args)...);
+                this->status_ = absl::OkStatus();
+            }
+            return this->data_;
+        }
+
+    private:
+        using internal_statusor::StatusOrData<T>::Assign;
+        template<typename U>
+        void Assign(const absl::StatusOr<U>& other);
+        template<typename U>
+        void Assign(absl::StatusOr<U>&& other);
+    };
+
+    // operator==()
+    //
+    // This operator checks the equality of two `absl::StatusOr<T>` objects.
+    template<typename T>
+    bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs)
+    {
+        if (lhs.ok() && rhs.ok())
+            return *lhs == *rhs;
+        return lhs.status() == rhs.status();
     }
-    return this->data_;
-  }
-
-  template <
-      typename U, typename... Args,
-      absl::enable_if_t<
-          std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
-          int> = 0>
-  T& emplace(std::initializer_list<U> ilist, Args&&... args) {
-    if (ok()) {
-      this->Clear();
-      this->MakeValue(ilist, std::forward<Args>(args)...);
-    } else {
-      this->MakeValue(ilist, std::forward<Args>(args)...);
-      this->status_ = absl::OkStatus();
+
+    // operator!=()
+    //
+    // This operator checks the inequality of two `absl::StatusOr<T>` objects.
+    template<typename T>
+    bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs)
+    {
+        return !(lhs == rhs);
     }
-    return this->data_;
-  }
-
- private:
-  using internal_statusor::StatusOrData<T>::Assign;
-  template <typename U>
-  void Assign(const absl::StatusOr<U>& other);
-  template <typename U>
-  void Assign(absl::StatusOr<U>&& other);
-};
-
-// operator==()
-//
-// This operator checks the equality of two `absl::StatusOr<T>` objects.
-template <typename T>
-bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
-  if (lhs.ok() && rhs.ok()) return *lhs == *rhs;
-  return lhs.status() == rhs.status();
-}
-
-// operator!=()
-//
-// This operator checks the inequality of two `absl::StatusOr<T>` objects.
-template <typename T>
-bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
-  return !(lhs == rhs);
-}
-
-//------------------------------------------------------------------------------
-// Implementation details for StatusOr<T>
-//------------------------------------------------------------------------------
-
-// TODO(sbenza): avoid the string here completely.
-template <typename T>
-StatusOr<T>::StatusOr() : Base(Status(absl::StatusCode::kUnknown, "")) {}
-
-template <typename T>
-template <typename U>
-inline void StatusOr<T>::Assign(const StatusOr<U>& other) {
-  if (other.ok()) {
-    this->Assign(*other);
-  } else {
-    this->AssignStatus(other.status());
-  }
-}
-
-template <typename T>
-template <typename U>
-inline void StatusOr<T>::Assign(StatusOr<U>&& other) {
-  if (other.ok()) {
-    this->Assign(*std::move(other));
-  } else {
-    this->AssignStatus(std::move(other).status());
-  }
-}
-template <typename T>
-template <typename... Args>
-StatusOr<T>::StatusOr(absl::in_place_t, Args&&... args)
-    : Base(absl::in_place, std::forward<Args>(args)...) {}
-
-template <typename T>
-template <typename U, typename... Args>
-StatusOr<T>::StatusOr(absl::in_place_t, std::initializer_list<U> ilist,
-                      Args&&... args)
-    : Base(absl::in_place, ilist, std::forward<Args>(args)...) {}
-
-template <typename T>
-const Status& StatusOr<T>::status() const& {
-  return this->status_;
-}
-template <typename T>
-Status StatusOr<T>::status() && {
-  return ok() ? OkStatus() : std::move(this->status_);
-}
-
-template <typename T>
-const T& StatusOr<T>::value() const& {
-  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
-  return this->data_;
-}
-
-template <typename T>
-T& StatusOr<T>::value() & {
-  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
-  return this->data_;
-}
-
-template <typename T>
-const T&& StatusOr<T>::value() const&& {
-  if (!this->ok()) {
-    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
-  }
-  return std::move(this->data_);
-}
-
-template <typename T>
-T&& StatusOr<T>::value() && {
-  if (!this->ok()) {
-    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
-  }
-  return std::move(this->data_);
-}
-
-template <typename T>
-const T& StatusOr<T>::operator*() const& {
-  this->EnsureOk();
-  return this->data_;
-}
-
-template <typename T>
-T& StatusOr<T>::operator*() & {
-  this->EnsureOk();
-  return this->data_;
-}
-
-template <typename T>
-const T&& StatusOr<T>::operator*() const&& {
-  this->EnsureOk();
-  return std::move(this->data_);
-}
-
-template <typename T>
-T&& StatusOr<T>::operator*() && {
-  this->EnsureOk();
-  return std::move(this->data_);
-}
-
-template <typename T>
-const T* StatusOr<T>::operator->() const {
-  this->EnsureOk();
-  return &this->data_;
-}
-
-template <typename T>
-T* StatusOr<T>::operator->() {
-  this->EnsureOk();
-  return &this->data_;
-}
-
-template <typename T>
-template <typename U>
-T StatusOr<T>::value_or(U&& default_value) const& {
-  if (ok()) {
-    return this->data_;
-  }
-  return std::forward<U>(default_value);
-}
-
-template <typename T>
-template <typename U>
-T StatusOr<T>::value_or(U&& default_value) && {
-  if (ok()) {
-    return std::move(this->data_);
-  }
-  return std::forward<U>(default_value);
-}
-
-template <typename T>
-void StatusOr<T>::IgnoreError() const {
-  // no-op
-}
-
-ABSL_NAMESPACE_END
+
+    //------------------------------------------------------------------------------
+    // Implementation details for StatusOr<T>
+    //------------------------------------------------------------------------------
+
+    // TODO(sbenza): avoid the string here completely.
+    template<typename T>
+    StatusOr<T>::StatusOr() :
+        Base(Status(absl::StatusCode::kUnknown, ""))
+    {
+    }
+
+    template<typename T>
+    template<typename U>
+    inline void StatusOr<T>::Assign(const StatusOr<U>& other)
+    {
+        if (other.ok())
+        {
+            this->Assign(*other);
+        }
+        else
+        {
+            this->AssignStatus(other.status());
+        }
+    }
+
+    template<typename T>
+    template<typename U>
+    inline void StatusOr<T>::Assign(StatusOr<U>&& other)
+    {
+        if (other.ok())
+        {
+            this->Assign(*std::move(other));
+        }
+        else
+        {
+            this->AssignStatus(std::move(other).status());
+        }
+    }
+    template<typename T>
+    template<typename... Args>
+    StatusOr<T>::StatusOr(absl::in_place_t, Args&&... args) :
+        Base(absl::in_place, std::forward<Args>(args)...)
+    {
+    }
+
+    template<typename T>
+    template<typename U, typename... Args>
+    StatusOr<T>::StatusOr(absl::in_place_t, std::initializer_list<U> ilist, Args&&... args) :
+        Base(absl::in_place, ilist, std::forward<Args>(args)...)
+    {
+    }
+
+    template<typename T>
+    const Status& StatusOr<T>::status() const&
+    {
+        return this->status_;
+    }
+    template<typename T>
+    Status StatusOr<T>::status() &&
+    {
+        return ok() ? OkStatus() : std::move(this->status_);
+    }
+
+    template<typename T>
+    const T& StatusOr<T>::value() const&
+    {
+        if (!this->ok())
+            internal_statusor::ThrowBadStatusOrAccess(this->status_);
+        return this->data_;
+    }
+
+    template<typename T>
+    T& StatusOr<T>::value() &
+    {
+        if (!this->ok())
+            internal_statusor::ThrowBadStatusOrAccess(this->status_);
+        return this->data_;
+    }
+
+    template<typename T>
+    const T&& StatusOr<T>::value() const&&
+    {
+        if (!this->ok())
+        {
+            internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
+        }
+        return std::move(this->data_);
+    }
+
+    template<typename T>
+    T&& StatusOr<T>::value() &&
+    {
+        if (!this->ok())
+        {
+            internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
+        }
+        return std::move(this->data_);
+    }
+
+    template<typename T>
+    const T& StatusOr<T>::operator*() const&
+    {
+        this->EnsureOk();
+        return this->data_;
+    }
+
+    template<typename T>
+    T& StatusOr<T>::operator*() &
+    {
+        this->EnsureOk();
+        return this->data_;
+    }
+
+    template<typename T>
+    const T&& StatusOr<T>::operator*() const&&
+    {
+        this->EnsureOk();
+        return std::move(this->data_);
+    }
+
+    template<typename T>
+    T&& StatusOr<T>::operator*() &&
+    {
+        this->EnsureOk();
+        return std::move(this->data_);
+    }
+
+    template<typename T>
+    const T* StatusOr<T>::operator->() const
+    {
+        this->EnsureOk();
+        return &this->data_;
+    }
+
+    template<typename T>
+    T* StatusOr<T>::operator->()
+    {
+        this->EnsureOk();
+        return &this->data_;
+    }
+
+    template<typename T>
+    template<typename U>
+    T StatusOr<T>::value_or(U&& default_value) const&
+    {
+        if (ok())
+        {
+            return this->data_;
+        }
+        return std::forward<U>(default_value);
+    }
+
+    template<typename T>
+    template<typename U>
+    T StatusOr<T>::value_or(U&& default_value) &&
+    {
+        if (ok())
+        {
+            return std::move(this->data_);
+        }
+        return std::forward<U>(default_value);
+    }
+
+    template<typename T>
+    void StatusOr<T>::IgnoreError() const
+    {
+        // no-op
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STATUS_STATUSOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/ascii.h b/CAPI/cpp/grpc/include/absl/strings/ascii.h
index 42eadae..62edb21 100644
--- a/CAPI/cpp/grpc/include/absl/strings/ascii.h
+++ b/CAPI/cpp/grpc/include/absl/strings/ascii.h
@@ -59,184 +59,224 @@
 #include "absl/base/config.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace ascii_internal {
-
-// Declaration for an array of bitfields holding character information.
-ABSL_DLL extern const unsigned char kPropertyBits[256];
-
-// Declaration for the array of characters to upper-case characters.
-ABSL_DLL extern const char kToUpper[256];
-
-// Declaration for the array of characters to lower-case characters.
-ABSL_DLL extern const char kToLower[256];
-
-}  // namespace ascii_internal
-
-// ascii_isalpha()
-//
-// Determines whether the given character is an alphabetic character.
-inline bool ascii_isalpha(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x01) != 0;
-}
-
-// ascii_isalnum()
-//
-// Determines whether the given character is an alphanumeric character.
-inline bool ascii_isalnum(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x04) != 0;
-}
-
-// ascii_isspace()
-//
-// Determines whether the given character is a whitespace character (space,
-// tab, vertical tab, formfeed, linefeed, or carriage return).
-inline bool ascii_isspace(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
-}
-
-// ascii_ispunct()
-//
-// Determines whether the given character is a punctuation character.
-inline bool ascii_ispunct(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x10) != 0;
-}
-
-// ascii_isblank()
-//
-// Determines whether the given character is a blank character (tab or space).
-inline bool ascii_isblank(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x20) != 0;
-}
-
-// ascii_iscntrl()
-//
-// Determines whether the given character is a control character.
-inline bool ascii_iscntrl(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x40) != 0;
-}
-
-// ascii_isxdigit()
-//
-// Determines whether the given character can be represented as a hexadecimal
-// digit character (i.e. {0-9} or {A-F}).
-inline bool ascii_isxdigit(unsigned char c) {
-  return (ascii_internal::kPropertyBits[c] & 0x80) != 0;
-}
-
-// ascii_isdigit()
-//
-// Determines whether the given character can be represented as a decimal
-// digit character (i.e. {0-9}).
-inline bool ascii_isdigit(unsigned char c) { return c >= '0' && c <= '9'; }
-
-// ascii_isprint()
-//
-// Determines whether the given character is printable, including spaces.
-inline bool ascii_isprint(unsigned char c) { return c >= 32 && c < 127; }
-
-// ascii_isgraph()
-//
-// Determines whether the given character has a graphical representation.
-inline bool ascii_isgraph(unsigned char c) { return c > 32 && c < 127; }
-
-// ascii_isupper()
-//
-// Determines whether the given character is uppercase.
-inline bool ascii_isupper(unsigned char c) { return c >= 'A' && c <= 'Z'; }
-
-// ascii_islower()
-//
-// Determines whether the given character is lowercase.
-inline bool ascii_islower(unsigned char c) { return c >= 'a' && c <= 'z'; }
-
-// ascii_isascii()
-//
-// Determines whether the given character is ASCII.
-inline bool ascii_isascii(unsigned char c) { return c < 128; }
-
-// ascii_tolower()
-//
-// Returns an ASCII character, converting to lowercase if uppercase is
-// passed. Note that character values > 127 are simply returned.
-inline char ascii_tolower(unsigned char c) {
-  return ascii_internal::kToLower[c];
-}
-
-// Converts the characters in `s` to lowercase, changing the contents of `s`.
-void AsciiStrToLower(std::string* s);
-
-// Creates a lowercase string from a given absl::string_view.
-ABSL_MUST_USE_RESULT inline std::string AsciiStrToLower(absl::string_view s) {
-  std::string result(s);
-  absl::AsciiStrToLower(&result);
-  return result;
-}
-
-// ascii_toupper()
-//
-// Returns the ASCII character, converting to upper-case if lower-case is
-// passed. Note that characters values > 127 are simply returned.
-inline char ascii_toupper(unsigned char c) {
-  return ascii_internal::kToUpper[c];
-}
-
-// Converts the characters in `s` to uppercase, changing the contents of `s`.
-void AsciiStrToUpper(std::string* s);
-
-// Creates an uppercase string from a given absl::string_view.
-ABSL_MUST_USE_RESULT inline std::string AsciiStrToUpper(absl::string_view s) {
-  std::string result(s);
-  absl::AsciiStrToUpper(&result);
-  return result;
-}
-
-// Returns absl::string_view with whitespace stripped from the beginning of the
-// given string_view.
-ABSL_MUST_USE_RESULT inline absl::string_view StripLeadingAsciiWhitespace(
-    absl::string_view str) {
-  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
-  return str.substr(static_cast<size_t>(it - str.begin()));
-}
-
-// Strips in place whitespace from the beginning of the given string.
-inline void StripLeadingAsciiWhitespace(std::string* str) {
-  auto it = std::find_if_not(str->begin(), str->end(), absl::ascii_isspace);
-  str->erase(str->begin(), it);
-}
-
-// Returns absl::string_view with whitespace stripped from the end of the given
-// string_view.
-ABSL_MUST_USE_RESULT inline absl::string_view StripTrailingAsciiWhitespace(
-    absl::string_view str) {
-  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
-  return str.substr(0, static_cast<size_t>(str.rend() - it));
-}
-
-// Strips in place whitespace from the end of the given string
-inline void StripTrailingAsciiWhitespace(std::string* str) {
-  auto it = std::find_if_not(str->rbegin(), str->rend(), absl::ascii_isspace);
-  str->erase(static_cast<size_t>(str->rend() - it));
-}
-
-// Returns absl::string_view with whitespace stripped from both ends of the
-// given string_view.
-ABSL_MUST_USE_RESULT inline absl::string_view StripAsciiWhitespace(
-    absl::string_view str) {
-  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
-}
-
-// Strips in place whitespace from both ends of the given string
-inline void StripAsciiWhitespace(std::string* str) {
-  StripTrailingAsciiWhitespace(str);
-  StripLeadingAsciiWhitespace(str);
-}
-
-// Removes leading, trailing, and consecutive internal whitespace.
-void RemoveExtraAsciiWhitespace(std::string*);
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace ascii_internal
+    {
+
+        // Declaration for an array of bitfields holding character information.
+        ABSL_DLL extern const unsigned char kPropertyBits[256];
+
+        // Declaration for the array of characters to upper-case characters.
+        ABSL_DLL extern const char kToUpper[256];
+
+        // Declaration for the array of characters to lower-case characters.
+        ABSL_DLL extern const char kToLower[256];
+
+    }  // namespace ascii_internal
+
+    // ascii_isalpha()
+    //
+    // Determines whether the given character is an alphabetic character.
+    inline bool ascii_isalpha(unsigned char c)
+    {
+        return (ascii_internal::kPropertyBits[c] & 0x01) != 0;
+    }
+
+    // ascii_isalnum()
+    //
+    // Determines whether the given character is an alphanumeric character.
+    inline bool ascii_isalnum(unsigned char c)
+    {
+        return (ascii_internal::kPropertyBits[c] & 0x04) != 0;
+    }
+
+    // ascii_isspace()
+    //
+    // Determines whether the given character is a whitespace character (space,
+    // tab, vertical tab, formfeed, linefeed, or carriage return).
+    inline bool ascii_isspace(unsigned char c)
+    {
+        return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
+    }
+
+    // ascii_ispunct()
+    //
+    // Determines whether the given character is a punctuation character.
+    inline bool ascii_ispunct(unsigned char c)
+    {
+        return (ascii_internal::kPropertyBits[c] & 0x10) != 0;
+    }
+
+    // ascii_isblank()
+    //
+    // Determines whether the given character is a blank character (tab or space).
+    inline bool ascii_isblank(unsigned char c)
+    {
+        return (ascii_internal::kPropertyBits[c] & 0x20) != 0;
+    }
+
+    // ascii_iscntrl()
+    //
+    // Determines whether the given character is a control character.
+    inline bool ascii_iscntrl(unsigned char c)
+    {
+        return (ascii_internal::kPropertyBits[c] & 0x40) != 0;
+    }
+
+    // ascii_isxdigit()
+    //
+    // Determines whether the given character can be represented as a hexadecimal
+    // digit character (i.e. {0-9} or {A-F}).
+    inline bool ascii_isxdigit(unsigned char c)
+    {
+        return (ascii_internal::kPropertyBits[c] & 0x80) != 0;
+    }
+
+    // ascii_isdigit()
+    //
+    // Determines whether the given character can be represented as a decimal
+    // digit character (i.e. {0-9}).
+    inline bool ascii_isdigit(unsigned char c)
+    {
+        return c >= '0' && c <= '9';
+    }
+
+    // ascii_isprint()
+    //
+    // Determines whether the given character is printable, including spaces.
+    inline bool ascii_isprint(unsigned char c)
+    {
+        return c >= 32 && c < 127;
+    }
+
+    // ascii_isgraph()
+    //
+    // Determines whether the given character has a graphical representation.
+    inline bool ascii_isgraph(unsigned char c)
+    {
+        return c > 32 && c < 127;
+    }
+
+    // ascii_isupper()
+    //
+    // Determines whether the given character is uppercase.
+    inline bool ascii_isupper(unsigned char c)
+    {
+        return c >= 'A' && c <= 'Z';
+    }
+
+    // ascii_islower()
+    //
+    // Determines whether the given character is lowercase.
+    inline bool ascii_islower(unsigned char c)
+    {
+        return c >= 'a' && c <= 'z';
+    }
+
+    // ascii_isascii()
+    //
+    // Determines whether the given character is ASCII.
+    inline bool ascii_isascii(unsigned char c)
+    {
+        return c < 128;
+    }
+
+    // ascii_tolower()
+    //
+    // Returns an ASCII character, converting to lowercase if uppercase is
+    // passed. Note that character values > 127 are simply returned.
+    inline char ascii_tolower(unsigned char c)
+    {
+        return ascii_internal::kToLower[c];
+    }
+
+    // Converts the characters in `s` to lowercase, changing the contents of `s`.
+    void AsciiStrToLower(std::string* s);
+
+    // Creates a lowercase string from a given absl::string_view.
+    ABSL_MUST_USE_RESULT inline std::string AsciiStrToLower(absl::string_view s)
+    {
+        std::string result(s);
+        absl::AsciiStrToLower(&result);
+        return result;
+    }
+
+    // ascii_toupper()
+    //
+    // Returns the ASCII character, converting to upper-case if lower-case is
+    // passed. Note that characters values > 127 are simply returned.
+    inline char ascii_toupper(unsigned char c)
+    {
+        return ascii_internal::kToUpper[c];
+    }
+
+    // Converts the characters in `s` to uppercase, changing the contents of `s`.
+    void AsciiStrToUpper(std::string* s);
+
+    // Creates an uppercase string from a given absl::string_view.
+    ABSL_MUST_USE_RESULT inline std::string AsciiStrToUpper(absl::string_view s)
+    {
+        std::string result(s);
+        absl::AsciiStrToUpper(&result);
+        return result;
+    }
+
+    // Returns absl::string_view with whitespace stripped from the beginning of the
+    // given string_view.
+    ABSL_MUST_USE_RESULT inline absl::string_view StripLeadingAsciiWhitespace(
+        absl::string_view str
+    )
+    {
+        auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
+        return str.substr(static_cast<size_t>(it - str.begin()));
+    }
+
+    // Strips in place whitespace from the beginning of the given string.
+    inline void StripLeadingAsciiWhitespace(std::string* str)
+    {
+        auto it = std::find_if_not(str->begin(), str->end(), absl::ascii_isspace);
+        str->erase(str->begin(), it);
+    }
+
+    // Returns absl::string_view with whitespace stripped from the end of the given
+    // string_view.
+    ABSL_MUST_USE_RESULT inline absl::string_view StripTrailingAsciiWhitespace(
+        absl::string_view str
+    )
+    {
+        auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
+        return str.substr(0, static_cast<size_t>(str.rend() - it));
+    }
+
+    // Strips in place whitespace from the end of the given string
+    inline void StripTrailingAsciiWhitespace(std::string* str)
+    {
+        auto it = std::find_if_not(str->rbegin(), str->rend(), absl::ascii_isspace);
+        str->erase(static_cast<size_t>(str->rend() - it));
+    }
+
+    // Returns absl::string_view with whitespace stripped from both ends of the
+    // given string_view.
+    ABSL_MUST_USE_RESULT inline absl::string_view StripAsciiWhitespace(
+        absl::string_view str
+    )
+    {
+        return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
+    }
+
+    // Strips in place whitespace from both ends of the given string
+    inline void StripAsciiWhitespace(std::string* str)
+    {
+        StripTrailingAsciiWhitespace(str);
+        StripLeadingAsciiWhitespace(str);
+    }
+
+    // Removes leading, trailing, and consecutive internal whitespace.
+    void RemoveExtraAsciiWhitespace(std::string*);
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_ASCII_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/charconv.h b/CAPI/cpp/grpc/include/absl/strings/charconv.h
index 7c50981..37b6ff8 100644
--- a/CAPI/cpp/grpc/include/absl/strings/charconv.h
+++ b/CAPI/cpp/grpc/include/absl/strings/charconv.h
@@ -19,102 +19,109 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// Workalike compatibilty version of std::chars_format from C++17.
-//
-// This is an bitfield enumerator which can be passed to absl::from_chars to
-// configure the string-to-float conversion.
-enum class chars_format {
-  scientific = 1,
-  fixed = 2,
-  hex = 4,
-  general = fixed | scientific,
-};
+    // Workalike compatibilty version of std::chars_format from C++17.
+    //
+    // This is an bitfield enumerator which can be passed to absl::from_chars to
+    // configure the string-to-float conversion.
+    enum class chars_format
+    {
+        scientific = 1,
+        fixed = 2,
+        hex = 4,
+        general = fixed | scientific,
+    };
 
-// The return result of a string-to-number conversion.
-//
-// `ec` will be set to `invalid_argument` if a well-formed number was not found
-// at the start of the input range, `result_out_of_range` if a well-formed
-// number was found, but it was out of the representable range of the requested
-// type, or to std::errc() otherwise.
-//
-// If a well-formed number was found, `ptr` is set to one past the sequence of
-// characters that were successfully parsed.  If none was found, `ptr` is set
-// to the `first` argument to from_chars.
-struct from_chars_result {
-  const char* ptr;
-  std::errc ec;
-};
+    // The return result of a string-to-number conversion.
+    //
+    // `ec` will be set to `invalid_argument` if a well-formed number was not found
+    // at the start of the input range, `result_out_of_range` if a well-formed
+    // number was found, but it was out of the representable range of the requested
+    // type, or to std::errc() otherwise.
+    //
+    // If a well-formed number was found, `ptr` is set to one past the sequence of
+    // characters that were successfully parsed.  If none was found, `ptr` is set
+    // to the `first` argument to from_chars.
+    struct from_chars_result
+    {
+        const char* ptr;
+        std::errc ec;
+    };
 
-// Workalike compatibilty version of std::from_chars from C++17.  Currently
-// this only supports the `double` and `float` types.
-//
-// This interface incorporates the proposed resolutions for library issues
-// DR 3080 and DR 3081.  If these are adopted with different wording,
-// Abseil's behavior will change to match the standard.  (The behavior most
-// likely to change is for DR 3081, which says what `value` will be set to in
-// the case of overflow and underflow.  Code that wants to avoid possible
-// breaking changes in this area should not depend on `value` when the returned
-// from_chars_result indicates a range error.)
-//
-// Searches the range [first, last) for the longest matching pattern beginning
-// at `first` that represents a floating point number.  If one is found, store
-// the result in `value`.
-//
-// The matching pattern format is almost the same as that of strtod(), except
-// that (1) C locale is not respected, (2) an initial '+' character in the
-// input range will never be matched, and (3) leading whitespaces are not
-// ignored.
-//
-// If `fmt` is set, it must be one of the enumerator values of the chars_format.
-// (This is despite the fact that chars_format is a bitmask type.)  If set to
-// `scientific`, a matching number must contain an exponent.  If set to `fixed`,
-// then an exponent will never match.  (For example, the string "1e5" will be
-// parsed as "1".)  If set to `hex`, then a hexadecimal float is parsed in the
-// format that strtod() accepts, except that a "0x" prefix is NOT matched.
-// (In particular, in `hex` mode, the input "0xff" results in the largest
-// matching pattern "0".)
-absl::from_chars_result from_chars(const char* first, const char* last,
-                                   double& value,  // NOLINT
-                                   chars_format fmt = chars_format::general);
+    // Workalike compatibilty version of std::from_chars from C++17.  Currently
+    // this only supports the `double` and `float` types.
+    //
+    // This interface incorporates the proposed resolutions for library issues
+    // DR 3080 and DR 3081.  If these are adopted with different wording,
+    // Abseil's behavior will change to match the standard.  (The behavior most
+    // likely to change is for DR 3081, which says what `value` will be set to in
+    // the case of overflow and underflow.  Code that wants to avoid possible
+    // breaking changes in this area should not depend on `value` when the returned
+    // from_chars_result indicates a range error.)
+    //
+    // Searches the range [first, last) for the longest matching pattern beginning
+    // at `first` that represents a floating point number.  If one is found, store
+    // the result in `value`.
+    //
+    // The matching pattern format is almost the same as that of strtod(), except
+    // that (1) C locale is not respected, (2) an initial '+' character in the
+    // input range will never be matched, and (3) leading whitespaces are not
+    // ignored.
+    //
+    // If `fmt` is set, it must be one of the enumerator values of the chars_format.
+    // (This is despite the fact that chars_format is a bitmask type.)  If set to
+    // `scientific`, a matching number must contain an exponent.  If set to `fixed`,
+    // then an exponent will never match.  (For example, the string "1e5" will be
+    // parsed as "1".)  If set to `hex`, then a hexadecimal float is parsed in the
+    // format that strtod() accepts, except that a "0x" prefix is NOT matched.
+    // (In particular, in `hex` mode, the input "0xff" results in the largest
+    // matching pattern "0".)
+    absl::from_chars_result from_chars(const char* first, const char* last,
+                                       double& value,  // NOLINT
+                                       chars_format fmt = chars_format::general);
 
-absl::from_chars_result from_chars(const char* first, const char* last,
-                                   float& value,  // NOLINT
-                                   chars_format fmt = chars_format::general);
+    absl::from_chars_result from_chars(const char* first, const char* last,
+                                       float& value,  // NOLINT
+                                       chars_format fmt = chars_format::general);
 
-// std::chars_format is specified as a bitmask type, which means the following
-// operations must be provided:
-inline constexpr chars_format operator&(chars_format lhs, chars_format rhs) {
-  return static_cast<chars_format>(static_cast<int>(lhs) &
-                                   static_cast<int>(rhs));
-}
-inline constexpr chars_format operator|(chars_format lhs, chars_format rhs) {
-  return static_cast<chars_format>(static_cast<int>(lhs) |
-                                   static_cast<int>(rhs));
-}
-inline constexpr chars_format operator^(chars_format lhs, chars_format rhs) {
-  return static_cast<chars_format>(static_cast<int>(lhs) ^
-                                   static_cast<int>(rhs));
-}
-inline constexpr chars_format operator~(chars_format arg) {
-  return static_cast<chars_format>(~static_cast<int>(arg));
-}
-inline chars_format& operator&=(chars_format& lhs, chars_format rhs) {
-  lhs = lhs & rhs;
-  return lhs;
-}
-inline chars_format& operator|=(chars_format& lhs, chars_format rhs) {
-  lhs = lhs | rhs;
-  return lhs;
-}
-inline chars_format& operator^=(chars_format& lhs, chars_format rhs) {
-  lhs = lhs ^ rhs;
-  return lhs;
-}
+    // std::chars_format is specified as a bitmask type, which means the following
+    // operations must be provided:
+    inline constexpr chars_format operator&(chars_format lhs, chars_format rhs)
+    {
+        return static_cast<chars_format>(static_cast<int>(lhs) & static_cast<int>(rhs));
+    }
+    inline constexpr chars_format operator|(chars_format lhs, chars_format rhs)
+    {
+        return static_cast<chars_format>(static_cast<int>(lhs) | static_cast<int>(rhs));
+    }
+    inline constexpr chars_format operator^(chars_format lhs, chars_format rhs)
+    {
+        return static_cast<chars_format>(static_cast<int>(lhs) ^ static_cast<int>(rhs));
+    }
+    inline constexpr chars_format operator~(chars_format arg)
+    {
+        return static_cast<chars_format>(~static_cast<int>(arg));
+    }
+    inline chars_format& operator&=(chars_format& lhs, chars_format rhs)
+    {
+        lhs = lhs & rhs;
+        return lhs;
+    }
+    inline chars_format& operator|=(chars_format& lhs, chars_format rhs)
+    {
+        lhs = lhs | rhs;
+        return lhs;
+    }
+    inline chars_format& operator^=(chars_format& lhs, chars_format rhs)
+    {
+        lhs = lhs ^ rhs;
+        return lhs;
+    }
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CHARCONV_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cord.h b/CAPI/cpp/grpc/include/absl/strings/cord.h
index 18d6ab8..9f3893a 100644
--- a/CAPI/cpp/grpc/include/absl/strings/cord.h
+++ b/CAPI/cpp/grpc/include/absl/strings/cord.h
@@ -97,1546 +97,1813 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-class Cord;
-class CordTestPeer;
-template <typename Releaser>
-Cord MakeCordFromExternal(absl::string_view, Releaser&&);
-void CopyCordToString(const Cord& src, std::string* dst);
-
-// Cord memory accounting modes
-enum class CordMemoryAccounting {
-  // Counts the *approximate* number of bytes held in full or in part by this
-  // Cord (which may not remain the same between invocations). Cords that share
-  // memory could each be "charged" independently for the same shared memory.
-  kTotal,
-
-  // Counts the *approximate* number of bytes held in full or in part by this
-  // Cord weighted by the sharing ratio of that data. For example, if some data
-  // edge is shared by 4 different Cords, then each cord is attributed 1/4th of
-  // the total memory usage as a 'fair share' of the total memory usage.
-  kFairShare,
-};
-
-// Cord
-//
-// A Cord is a sequence of characters, designed to be more efficient than a
-// `std::string` in certain circumstances: namely, large string data that needs
-// to change over its lifetime or shared, especially when such data is shared
-// across API boundaries.
-//
-// A Cord stores its character data in a structure that allows efficient prepend
-// and append operations. This makes a Cord useful for large string data sent
-// over in a wire format that may need to be prepended or appended at some point
-// during the data exchange (e.g. HTTP, protocol buffers). For example, a
-// Cord is useful for storing an HTTP request, and prepending an HTTP header to
-// such a request.
-//
-// Cords should not be used for storing general string data, however. They
-// require overhead to construct and are slower than strings for random access.
-//
-// The Cord API provides the following common API operations:
-//
-// * Create or assign Cords out of existing string data, memory, or other Cords
-// * Append and prepend data to an existing Cord
-// * Create new Sub-Cords from existing Cord data
-// * Swap Cord data and compare Cord equality
-// * Write out Cord data by constructing a `std::string`
-//
-// Additionally, the API provides iterator utilities to iterate through Cord
-// data via chunks or character bytes.
-//
-class Cord {
- private:
-  template <typename T>
-  using EnableIfString =
-      absl::enable_if_t<std::is_same<T, std::string>::value, int>;
-
- public:
-  // Cord::Cord() Constructors.
-
-  // Creates an empty Cord.
-  constexpr Cord() noexcept;
-
-  // Creates a Cord from an existing Cord. Cord is copyable and efficiently
-  // movable. The moved-from state is valid but unspecified.
-  Cord(const Cord& src);
-  Cord(Cord&& src) noexcept;
-  Cord& operator=(const Cord& x);
-  Cord& operator=(Cord&& x) noexcept;
-
-  // Creates a Cord from a `src` string. This constructor is marked explicit to
-  // prevent implicit Cord constructions from arguments convertible to an
-  // `absl::string_view`.
-  explicit Cord(absl::string_view src);
-  Cord& operator=(absl::string_view src);
-
-  // Creates a Cord from a `std::string&&` rvalue. These constructors are
-  // templated to avoid ambiguities for types that are convertible to both
-  // `absl::string_view` and `std::string`, such as `const char*`.
-  template <typename T, EnableIfString<T> = 0>
-  explicit Cord(T&& src);
-  template <typename T, EnableIfString<T> = 0>
-  Cord& operator=(T&& src);
-
-  // Cord::~Cord()
-  //
-  // Destructs the Cord.
-  ~Cord() {
-    if (contents_.is_tree()) DestroyCordSlow();
-  }
-
-  // MakeCordFromExternal()
-  //
-  // Creates a Cord that takes ownership of external string memory. The
-  // contents of `data` are not copied to the Cord; instead, the external
-  // memory is added to the Cord and reference-counted. This data may not be
-  // changed for the life of the Cord, though it may be prepended or appended
-  // to.
-  //
-  // `MakeCordFromExternal()` takes a callable "releaser" that is invoked when
-  // the reference count for `data` reaches zero. As noted above, this data must
-  // remain live until the releaser is invoked. The callable releaser also must:
-  //
-  //   * be move constructible
-  //   * support `void operator()(absl::string_view) const` or `void operator()`
-  //
-  // Example:
-  //
-  // Cord MakeCord(BlockPool* pool) {
-  //   Block* block = pool->NewBlock();
-  //   FillBlock(block);
-  //   return absl::MakeCordFromExternal(
-  //       block->ToStringView(),
-  //       [pool, block](absl::string_view v) {
-  //         pool->FreeBlock(block, v);
-  //       });
-  // }
-  //
-  // WARNING: Because a Cord can be reference-counted, it's likely a bug if your
-  // releaser doesn't do anything. For example, consider the following:
-  //
-  // void Foo(const char* buffer, int len) {
-  //   auto c = absl::MakeCordFromExternal(absl::string_view(buffer, len),
-  //                                       [](absl::string_view) {});
-  //
-  //   // BUG: If Bar() copies its cord for any reason, including keeping a
-  //   // substring of it, the lifetime of buffer might be extended beyond
-  //   // when Foo() returns.
-  //   Bar(c);
-  // }
-  template <typename Releaser>
-  friend Cord MakeCordFromExternal(absl::string_view data, Releaser&& releaser);
-
-  // Cord::Clear()
-  //
-  // Releases the Cord data. Any nodes that share data with other Cords, if
-  // applicable, will have their reference counts reduced by 1.
-  ABSL_ATTRIBUTE_REINITIALIZES void Clear();
-
-  // Cord::Append()
-  //
-  // Appends data to the Cord, which may come from another Cord or other string
-  // data.
-  void Append(const Cord& src);
-  void Append(Cord&& src);
-  void Append(absl::string_view src);
-  template <typename T, EnableIfString<T> = 0>
-  void Append(T&& src);
-
-  // Appends `buffer` to this cord, unless `buffer` has a zero length in which
-  // case this method has no effect on this cord instance.
-  // This method is guaranteed to consume `buffer`.
-  void Append(CordBuffer buffer);
-
-  // Returns a CordBuffer, re-using potential existing capacity in this cord.
-  //
-  // Cord instances may have additional unused capacity in the last (or first)
-  // nodes of the underlying tree to facilitate amortized growth. This method
-  // allows applications to explicitly use this spare capacity if available,
-  // or create a new CordBuffer instance otherwise.
-  // If this cord has a final non-shared node with at least `min_capacity`
-  // available, then this method will return that buffer including its data
-  // contents. I.e.; the returned buffer will have a non-zero length, and
-  // a capacity of at least `buffer.length + min_capacity`. Otherwise, this
-  // method will return `CordBuffer::CreateWithDefaultLimit(capacity)`.
-  //
-  // Below an example of using GetAppendBuffer. Notice that in this example we
-  // use `GetAppendBuffer()` only on the first iteration. As we know nothing
-  // about any initial extra capacity in `cord`, we may be able to use the extra
-  // capacity. But as we add new buffers with fully utilized contents after that
-  // we avoid calling `GetAppendBuffer()` on subsequent iterations: while this
-  // works fine, it results in an unnecessary inspection of cord contents:
-  //
-  //   void AppendRandomDataToCord(absl::Cord &cord, size_t n) {
-  //     bool first = true;
-  //     while (n > 0) {
-  //       CordBuffer buffer = first ? cord.GetAppendBuffer(n)
-  //                                 : CordBuffer::CreateWithDefaultLimit(n);
-  //       absl::Span<char> data = buffer.available_up_to(n);
-  //       FillRandomValues(data.data(), data.size());
-  //       buffer.IncreaseLengthBy(data.size());
-  //       cord.Append(std::move(buffer));
-  //       n -= data.size();
-  //       first = false;
-  //     }
-  //   }
-  CordBuffer GetAppendBuffer(size_t capacity, size_t min_capacity = 16);
-
-  // Cord::Prepend()
-  //
-  // Prepends data to the Cord, which may come from another Cord or other string
-  // data.
-  void Prepend(const Cord& src);
-  void Prepend(absl::string_view src);
-  template <typename T, EnableIfString<T> = 0>
-  void Prepend(T&& src);
-
-  // Prepends `buffer` to this cord, unless `buffer` has a zero length in which
-  // case this method has no effect on this cord instance.
-  // This method is guaranteed to consume `buffer`.
-  void Prepend(CordBuffer buffer);
-
-  // Cord::RemovePrefix()
-  //
-  // Removes the first `n` bytes of a Cord.
-  void RemovePrefix(size_t n);
-  void RemoveSuffix(size_t n);
-
-  // Cord::Subcord()
-  //
-  // Returns a new Cord representing the subrange [pos, pos + new_size) of
-  // *this. If pos >= size(), the result is empty(). If
-  // (pos + new_size) >= size(), the result is the subrange [pos, size()).
-  Cord Subcord(size_t pos, size_t new_size) const;
-
-  // Cord::swap()
-  //
-  // Swaps the contents of the Cord with `other`.
-  void swap(Cord& other) noexcept;
-
-  // swap()
-  //
-  // Swaps the contents of two Cords.
-  friend void swap(Cord& x, Cord& y) noexcept { x.swap(y); }
-
-  // Cord::size()
-  //
-  // Returns the size of the Cord.
-  size_t size() const;
-
-  // Cord::empty()
-  //
-  // Determines whether the given Cord is empty, returning `true` is so.
-  bool empty() const;
-
-  // Cord::EstimatedMemoryUsage()
-  //
-  // Returns the *approximate* number of bytes held by this cord.
-  // See CordMemoryAccounting for more information on the accounting method.
-  size_t EstimatedMemoryUsage(CordMemoryAccounting accounting_method =
-                                  CordMemoryAccounting::kTotal) const;
-
-  // Cord::Compare()
-  //
-  // Compares 'this' Cord with rhs. This function and its relatives treat Cords
-  // as sequences of unsigned bytes. The comparison is a straightforward
-  // lexicographic comparison. `Cord::Compare()` returns values as follows:
-  //
-  //   -1  'this' Cord is smaller
-  //    0  two Cords are equal
-  //    1  'this' Cord is larger
-  int Compare(absl::string_view rhs) const;
-  int Compare(const Cord& rhs) const;
-
-  // Cord::StartsWith()
-  //
-  // Determines whether the Cord starts with the passed string data `rhs`.
-  bool StartsWith(const Cord& rhs) const;
-  bool StartsWith(absl::string_view rhs) const;
-
-  // Cord::EndsWith()
-  //
-  // Determines whether the Cord ends with the passed string data `rhs`.
-  bool EndsWith(absl::string_view rhs) const;
-  bool EndsWith(const Cord& rhs) const;
-
-  // Cord::operator std::string()
-  //
-  // Converts a Cord into a `std::string()`. This operator is marked explicit to
-  // prevent unintended Cord usage in functions that take a string.
-  explicit operator std::string() const;
-
-  // CopyCordToString()
-  //
-  // Copies the contents of a `src` Cord into a `*dst` string.
-  //
-  // This function optimizes the case of reusing the destination string since it
-  // can reuse previously allocated capacity. However, this function does not
-  // guarantee that pointers previously returned by `dst->data()` remain valid
-  // even if `*dst` had enough capacity to hold `src`. If `*dst` is a new
-  // object, prefer to simply use the conversion operator to `std::string`.
-  friend void CopyCordToString(const Cord& src, std::string* dst);
-
-  class CharIterator;
-
-  //----------------------------------------------------------------------------
-  // Cord::ChunkIterator
-  //----------------------------------------------------------------------------
-  //
-  // A `Cord::ChunkIterator` allows iteration over the constituent chunks of its
-  // Cord. Such iteration allows you to perform non-const operations on the data
-  // of a Cord without modifying it.
-  //
-  // Generally, you do not instantiate a `Cord::ChunkIterator` directly;
-  // instead, you create one implicitly through use of the `Cord::Chunks()`
-  // member function.
-  //
-  // The `Cord::ChunkIterator` has the following properties:
-  //
-  //   * The iterator is invalidated after any non-const operation on the
-  //     Cord object over which it iterates.
-  //   * The `string_view` returned by dereferencing a valid, non-`end()`
-  //     iterator is guaranteed to be non-empty.
-  //   * Two `ChunkIterator` objects can be compared equal if and only if they
-  //     remain valid and iterate over the same Cord.
-  //   * The iterator in this case is a proxy iterator; the `string_view`
-  //     returned by the iterator does not live inside the Cord, and its
-  //     lifetime is limited to the lifetime of the iterator itself. To help
-  //     prevent lifetime issues, `ChunkIterator::reference` is not a true
-  //     reference type and is equivalent to `value_type`.
-  //   * The iterator keeps state that can grow for Cords that contain many
-  //     nodes and are imbalanced due to sharing. Prefer to pass this type by
-  //     const reference instead of by value.
-  class ChunkIterator {
-   public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = absl::string_view;
-    using difference_type = ptrdiff_t;
-    using pointer = const value_type*;
-    using reference = value_type;
-
-    ChunkIterator() = default;
-
-    ChunkIterator& operator++();
-    ChunkIterator operator++(int);
-    bool operator==(const ChunkIterator& other) const;
-    bool operator!=(const ChunkIterator& other) const;
-    reference operator*() const;
-    pointer operator->() const;
-
-    friend class Cord;
-    friend class CharIterator;
-
-   private:
-    using CordRep = absl::cord_internal::CordRep;
-    using CordRepBtree = absl::cord_internal::CordRepBtree;
-    using CordRepBtreeReader = absl::cord_internal::CordRepBtreeReader;
-
-    // Constructs a `begin()` iterator from `tree`. `tree` must not be null.
-    explicit ChunkIterator(cord_internal::CordRep* tree);
-
-    // Constructs a `begin()` iterator from `cord`.
-    explicit ChunkIterator(const Cord* cord);
-
-    // Initializes this instance from a tree. Invoked by constructors.
-    void InitTree(cord_internal::CordRep* tree);
-
-    // Removes `n` bytes from `current_chunk_`. Expects `n` to be smaller than
-    // `current_chunk_.size()`.
-    void RemoveChunkPrefix(size_t n);
-    Cord AdvanceAndReadBytes(size_t n);
-    void AdvanceBytes(size_t n);
-
-    // Btree specific operator++
-    ChunkIterator& AdvanceBtree();
-    void AdvanceBytesBtree(size_t n);
-
-    // A view into bytes of the current `CordRep`. It may only be a view to a
-    // suffix of bytes if this is being used by `CharIterator`.
-    absl::string_view current_chunk_;
-    // The current leaf, or `nullptr` if the iterator points to short data.
-    // If the current chunk is a substring node, current_leaf_ points to the
-    // underlying flat or external node.
-    absl::cord_internal::CordRep* current_leaf_ = nullptr;
-    // The number of bytes left in the `Cord` over which we are iterating.
-    size_t bytes_remaining_ = 0;
-
-    // Cord reader for cord btrees. Empty if not traversing a btree.
-    CordRepBtreeReader btree_reader_;
-  };
-
-  // Cord::chunk_begin()
-  //
-  // Returns an iterator to the first chunk of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `ChunkIterator` where range-based for-loops are not useful.
-  //
-  // Example:
-  //
-  //   absl::Cord::ChunkIterator FindAsChunk(const absl::Cord& c,
-  //                                         absl::string_view s) {
-  //     return std::find(c.chunk_begin(), c.chunk_end(), s);
-  //   }
-  ChunkIterator chunk_begin() const;
-
-  // Cord::chunk_end()
-  //
-  // Returns an iterator one increment past the last chunk of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `ChunkIterator` where range-based for-loops may not be available.
-  ChunkIterator chunk_end() const;
-
-  //----------------------------------------------------------------------------
-  // Cord::ChunkRange
-  //----------------------------------------------------------------------------
-  //
-  // `ChunkRange` is a helper class for iterating over the chunks of the `Cord`,
-  // producing an iterator which can be used within a range-based for loop.
-  // Construction of a `ChunkRange` will return an iterator pointing to the
-  // first chunk of the Cord. Generally, do not construct a `ChunkRange`
-  // directly; instead, prefer to use the `Cord::Chunks()` method.
-  //
-  // Implementation note: `ChunkRange` is simply a convenience wrapper over
-  // `Cord::chunk_begin()` and `Cord::chunk_end()`.
-  class ChunkRange {
-   public:
-    // Fulfill minimum c++ container requirements [container.requirements]
-    // These (partial) container type definitions allow ChunkRange to be used
-    // in various utilities expecting a subset of [container.requirements].
-    // For example, the below enables using `::testing::ElementsAre(...)`
-    using value_type = absl::string_view;
-    using reference = value_type&;
-    using const_reference = const value_type&;
-    using iterator = ChunkIterator;
-    using const_iterator = ChunkIterator;
-
-    explicit ChunkRange(const Cord* cord) : cord_(cord) {}
-
-    ChunkIterator begin() const;
-    ChunkIterator end() const;
-
-   private:
-    const Cord* cord_;
-  };
-
-  // Cord::Chunks()
-  //
-  // Returns a `Cord::ChunkRange` for iterating over the chunks of a `Cord` with
-  // a range-based for-loop. For most iteration tasks on a Cord, use
-  // `Cord::Chunks()` to retrieve this iterator.
-  //
-  // Example:
-  //
-  //   void ProcessChunks(const Cord& cord) {
-  //     for (absl::string_view chunk : cord.Chunks()) { ... }
-  //   }
-  //
-  // Note that the ordinary caveats of temporary lifetime extension apply:
-  //
-  //   void Process() {
-  //     for (absl::string_view chunk : CordFactory().Chunks()) {
-  //       // The temporary Cord returned by CordFactory has been destroyed!
-  //     }
-  //   }
-  ChunkRange Chunks() const;
-
-  //----------------------------------------------------------------------------
-  // Cord::CharIterator
-  //----------------------------------------------------------------------------
-  //
-  // A `Cord::CharIterator` allows iteration over the constituent characters of
-  // a `Cord`.
-  //
-  // Generally, you do not instantiate a `Cord::CharIterator` directly; instead,
-  // you create one implicitly through use of the `Cord::Chars()` member
-  // function.
-  //
-  // A `Cord::CharIterator` has the following properties:
-  //
-  //   * The iterator is invalidated after any non-const operation on the
-  //     Cord object over which it iterates.
-  //   * Two `CharIterator` objects can be compared equal if and only if they
-  //     remain valid and iterate over the same Cord.
-  //   * The iterator keeps state that can grow for Cords that contain many
-  //     nodes and are imbalanced due to sharing. Prefer to pass this type by
-  //     const reference instead of by value.
-  //   * This type cannot act as a forward iterator because a `Cord` can reuse
-  //     sections of memory. This fact violates the requirement for forward
-  //     iterators to compare equal if dereferencing them returns the same
-  //     object.
-  class CharIterator {
-   public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = char;
-    using difference_type = ptrdiff_t;
-    using pointer = const char*;
-    using reference = const char&;
-
-    CharIterator() = default;
-
-    CharIterator& operator++();
-    CharIterator operator++(int);
-    bool operator==(const CharIterator& other) const;
-    bool operator!=(const CharIterator& other) const;
-    reference operator*() const;
-    pointer operator->() const;
-
-    friend Cord;
-
-   private:
-    explicit CharIterator(const Cord* cord) : chunk_iterator_(cord) {}
-
-    ChunkIterator chunk_iterator_;
-  };
-
-  // Cord::AdvanceAndRead()
-  //
-  // Advances the `Cord::CharIterator` by `n_bytes` and returns the bytes
-  // advanced as a separate `Cord`. `n_bytes` must be less than or equal to the
-  // number of bytes within the Cord; otherwise, behavior is undefined. It is
-  // valid to pass `char_end()` and `0`.
-  static Cord AdvanceAndRead(CharIterator* it, size_t n_bytes);
-
-  // Cord::Advance()
-  //
-  // Advances the `Cord::CharIterator` by `n_bytes`. `n_bytes` must be less than
-  // or equal to the number of bytes remaining within the Cord; otherwise,
-  // behavior is undefined. It is valid to pass `char_end()` and `0`.
-  static void Advance(CharIterator* it, size_t n_bytes);
-
-  // Cord::ChunkRemaining()
-  //
-  // Returns the longest contiguous view starting at the iterator's position.
-  //
-  // `it` must be dereferenceable.
-  static absl::string_view ChunkRemaining(const CharIterator& it);
-
-  // Cord::char_begin()
-  //
-  // Returns an iterator to the first character of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chars()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `CharIterator` where range-based for-loops may not be available.
-  CharIterator char_begin() const;
-
-  // Cord::char_end()
-  //
-  // Returns an iterator to one past the last character of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chars()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `CharIterator` where range-based for-loops are not useful.
-  CharIterator char_end() const;
-
-  // Cord::CharRange
-  //
-  // `CharRange` is a helper class for iterating over the characters of a
-  // producing an iterator which can be used within a range-based for loop.
-  // Construction of a `CharRange` will return an iterator pointing to the first
-  // character of the Cord. Generally, do not construct a `CharRange` directly;
-  // instead, prefer to use the `Cord::Chars()` method shown below.
-  //
-  // Implementation note: `CharRange` is simply a convenience wrapper over
-  // `Cord::char_begin()` and `Cord::char_end()`.
-  class CharRange {
-   public:
-    // Fulfill minimum c++ container requirements [container.requirements]
-    // Theses (partial) container type definitions allow CharRange to be used
-    // in various utilities expecting a subset of [container.requirements].
-    // For example, the below enables using `::testing::ElementsAre(...)`
-    using value_type = char;
-    using reference = value_type&;
-    using const_reference = const value_type&;
-    using iterator = CharIterator;
-    using const_iterator = CharIterator;
-
-    explicit CharRange(const Cord* cord) : cord_(cord) {}
-
-    CharIterator begin() const;
-    CharIterator end() const;
-
-   private:
-    const Cord* cord_;
-  };
-
-  // Cord::Chars()
-  //
-  // Returns a `Cord::CharRange` for iterating over the characters of a `Cord`
-  // with a range-based for-loop. For most character-based iteration tasks on a
-  // Cord, use `Cord::Chars()` to retrieve this iterator.
-  //
-  // Example:
-  //
-  //   void ProcessCord(const Cord& cord) {
-  //     for (char c : cord.Chars()) { ... }
-  //   }
-  //
-  // Note that the ordinary caveats of temporary lifetime extension apply:
-  //
-  //   void Process() {
-  //     for (char c : CordFactory().Chars()) {
-  //       // The temporary Cord returned by CordFactory has been destroyed!
-  //     }
-  //   }
-  CharRange Chars() const;
-
-  // Cord::operator[]
-  //
-  // Gets the "i"th character of the Cord and returns it, provided that
-  // 0 <= i < Cord.size().
-  //
-  // NOTE: This routine is reasonably efficient. It is roughly
-  // logarithmic based on the number of chunks that make up the cord. Still,
-  // if you need to iterate over the contents of a cord, you should
-  // use a CharIterator/ChunkIterator rather than call operator[] or Get()
-  // repeatedly in a loop.
-  char operator[](size_t i) const;
-
-  // Cord::TryFlat()
-  //
-  // If this cord's representation is a single flat array, returns a
-  // string_view referencing that array.  Otherwise returns nullopt.
-  absl::optional<absl::string_view> TryFlat() const;
-
-  // Cord::Flatten()
-  //
-  // Flattens the cord into a single array and returns a view of the data.
-  //
-  // If the cord was already flat, the contents are not modified.
-  absl::string_view Flatten();
-
-  // Supports absl::Cord as a sink object for absl::Format().
-  friend void AbslFormatFlush(absl::Cord* cord, absl::string_view part) {
-    cord->Append(part);
-  }
-
-  // Cord::SetExpectedChecksum()
-  //
-  // Stores a checksum value with this non-empty cord instance, for later
-  // retrieval.
-  //
-  // The expected checksum is a number stored out-of-band, alongside the data.
-  // It is preserved across copies and assignments, but any mutations to a cord
-  // will cause it to lose its expected checksum.
-  //
-  // The expected checksum is not part of a Cord's value, and does not affect
-  // operations such as equality or hashing.
-  //
-  // This field is intended to store a CRC32C checksum for later validation, to
-  // help support end-to-end checksum workflows.  However, the Cord API itself
-  // does no CRC validation, and assigns no meaning to this number.
-  //
-  // This call has no effect if this cord is empty.
-  void SetExpectedChecksum(uint32_t crc);
-
-  // Returns this cord's expected checksum, if it has one.  Otherwise, returns
-  // nullopt.
-  absl::optional<uint32_t> ExpectedChecksum() const;
-
-  template <typename H>
-  friend H AbslHashValue(H hash_state, const absl::Cord& c) {
-    absl::optional<absl::string_view> maybe_flat = c.TryFlat();
-    if (maybe_flat.has_value()) {
-      return H::combine(std::move(hash_state), *maybe_flat);
-    }
-    return c.HashFragmented(std::move(hash_state));
-  }
-
-  // Create a Cord with the contents of StringConstant<T>::value.
-  // No allocations will be done and no data will be copied.
-  // This is an INTERNAL API and subject to change or removal. This API can only
-  // be used by spelling absl::strings_internal::MakeStringConstant, which is
-  // also an internal API.
-  template <typename T>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr Cord(strings_internal::StringConstant<T>);
-
- private:
-  using CordRep = absl::cord_internal::CordRep;
-  using CordRepFlat = absl::cord_internal::CordRepFlat;
-  using CordzInfo = cord_internal::CordzInfo;
-  using CordzUpdateScope = cord_internal::CordzUpdateScope;
-  using CordzUpdateTracker = cord_internal::CordzUpdateTracker;
-  using InlineData = cord_internal::InlineData;
-  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
-
-  // Creates a cord instance with `method` representing the originating
-  // public API call causing the cord to be created.
-  explicit Cord(absl::string_view src, MethodIdentifier method);
-
-  friend class CordTestPeer;
-  friend bool operator==(const Cord& lhs, const Cord& rhs);
-  friend bool operator==(const Cord& lhs, absl::string_view rhs);
-
-  friend const CordzInfo* GetCordzInfoForTesting(const Cord& cord);
-
-  // Calls the provided function once for each cord chunk, in order.  Unlike
-  // Chunks(), this API will not allocate memory.
-  void ForEachChunk(absl::FunctionRef<void(absl::string_view)>) const;
-
-  // Allocates new contiguous storage for the contents of the cord. This is
-  // called by Flatten() when the cord was not already flat.
-  absl::string_view FlattenSlowPath();
-
-  // Actual cord contents are hidden inside the following simple
-  // class so that we can isolate the bulk of cord.cc from changes
-  // to the representation.
-  //
-  // InlineRep holds either a tree pointer, or an array of kMaxInline bytes.
-  class InlineRep {
-   public:
-    static constexpr unsigned char kMaxInline = cord_internal::kMaxInline;
-    static_assert(kMaxInline >= sizeof(absl::cord_internal::CordRep*), "");
-
-    constexpr InlineRep() : data_() {}
-    explicit InlineRep(InlineData::DefaultInitType init) : data_(init) {}
-    InlineRep(const InlineRep& src);
-    InlineRep(InlineRep&& src);
-    InlineRep& operator=(const InlineRep& src);
-    InlineRep& operator=(InlineRep&& src) noexcept;
-
-    explicit constexpr InlineRep(cord_internal::InlineData data);
-
-    void Swap(InlineRep* rhs);
-    bool empty() const;
-    size_t size() const;
-    const char* data() const;  // Returns nullptr if holding pointer
-    void set_data(const char* data, size_t n);  // Discards pointer, if any
-    char* set_data(size_t n);                   // Write data to the result
-    // Returns nullptr if holding bytes
-    absl::cord_internal::CordRep* tree() const;
-    absl::cord_internal::CordRep* as_tree() const;
-    const char* as_chars() const;
-    // Returns non-null iff was holding a pointer
-    absl::cord_internal::CordRep* clear();
-    // Converts to pointer if necessary.
-    void reduce_size(size_t n);    // REQUIRES: holding data
-    void remove_prefix(size_t n);  // REQUIRES: holding data
-    void AppendArray(absl::string_view src, MethodIdentifier method);
-    absl::string_view FindFlatStartPiece() const;
-
-    // Creates a CordRepFlat instance from the current inlined data with `extra'
-    // bytes of desired additional capacity.
-    CordRepFlat* MakeFlatWithExtraCapacity(size_t extra);
-
-    // Sets the tree value for this instance. `rep` must not be null.
-    // Requires the current instance to hold a tree, and a lock to be held on
-    // any CordzInfo referenced by this instance. The latter is enforced through
-    // the CordzUpdateScope argument. If the current instance is sampled, then
-    // the CordzInfo instance is updated to reference the new `rep` value.
-    void SetTree(CordRep* rep, const CordzUpdateScope& scope);
-
-    // Identical to SetTree(), except that `rep` is allowed to be null, in
-    // which case the current instance is reset to an empty value.
-    void SetTreeOrEmpty(CordRep* rep, const CordzUpdateScope& scope);
-
-    // Sets the tree value for this instance, and randomly samples this cord.
-    // This function disregards existing contents in `data_`, and should be
-    // called when a Cord is 'promoted' from an 'uninitialized' or 'inlined'
-    // value to a non-inlined (tree / ring) value.
-    void EmplaceTree(CordRep* rep, MethodIdentifier method);
-
-    // Identical to EmplaceTree, except that it copies the parent stack from
-    // the provided `parent` data if the parent is sampled.
-    void EmplaceTree(CordRep* rep, const InlineData& parent,
-                     MethodIdentifier method);
-
-    // Commits the change of a newly created, or updated `rep` root value into
-    // this cord. `old_rep` indicates the old (inlined or tree) value of the
-    // cord, and determines if the commit invokes SetTree() or EmplaceTree().
-    void CommitTree(const CordRep* old_rep, CordRep* rep,
-                    const CordzUpdateScope& scope, MethodIdentifier method);
-
-    void AppendTreeToInlined(CordRep* tree, MethodIdentifier method);
-    void AppendTreeToTree(CordRep* tree, MethodIdentifier method);
-    void AppendTree(CordRep* tree, MethodIdentifier method);
-    void PrependTreeToInlined(CordRep* tree, MethodIdentifier method);
-    void PrependTreeToTree(CordRep* tree, MethodIdentifier method);
-    void PrependTree(CordRep* tree, MethodIdentifier method);
-
-    template <bool has_length>
-    void GetAppendRegion(char** region, size_t* size, size_t length);
-
-    bool IsSame(const InlineRep& other) const {
-      return memcmp(&data_, &other.data_, sizeof(data_)) == 0;
-    }
-    int BitwiseCompare(const InlineRep& other) const {
-      uint64_t x, y;
-      // Use memcpy to avoid aliasing issues.
-      memcpy(&x, &data_, sizeof(x));
-      memcpy(&y, &other.data_, sizeof(y));
-      if (x == y) {
-        memcpy(&x, reinterpret_cast<const char*>(&data_) + 8, sizeof(x));
-        memcpy(&y, reinterpret_cast<const char*>(&other.data_) + 8, sizeof(y));
-        if (x == y) return 0;
-      }
-      return absl::big_endian::FromHost64(x) < absl::big_endian::FromHost64(y)
-                 ? -1
-                 : 1;
-    }
-    void CopyTo(std::string* dst) const {
-      // memcpy is much faster when operating on a known size. On most supported
-      // platforms, the small string optimization is large enough that resizing
-      // to 15 bytes does not cause a memory allocation.
-      absl::strings_internal::STLStringResizeUninitialized(dst,
-                                                           sizeof(data_) - 1);
-      memcpy(&(*dst)[0], &data_, sizeof(data_) - 1);
-      // erase is faster than resize because the logic for memory allocation is
-      // not needed.
-      dst->erase(inline_size());
-    }
-
-    // Copies the inline contents into `dst`. Assumes the cord is not empty.
-    void CopyToArray(char* dst) const;
-
-    bool is_tree() const { return data_.is_tree(); }
-
-    // Returns true if the Cord is being profiled by cordz.
-    bool is_profiled() const { return data_.is_tree() && data_.is_profiled(); }
-
-    // Returns the available inlined capacity, or 0 if is_tree() == true.
-    size_t remaining_inline_capacity() const {
-      return data_.is_tree() ? 0 : kMaxInline - data_.inline_size();
-    }
-
-    // Returns the profiled CordzInfo, or nullptr if not sampled.
-    absl::cord_internal::CordzInfo* cordz_info() const {
-      return data_.cordz_info();
-    }
-
-    // Sets the profiled CordzInfo. `cordz_info` must not be null.
-    void set_cordz_info(cord_internal::CordzInfo* cordz_info) {
-      assert(cordz_info != nullptr);
-      data_.set_cordz_info(cordz_info);
-    }
-
-    // Resets the current cordz_info to null / empty.
-    void clear_cordz_info() { data_.clear_cordz_info(); }
-
-   private:
-    friend class Cord;
-
-    void AssignSlow(const InlineRep& src);
-    // Unrefs the tree and stops profiling.
-    void UnrefTree();
-
-    void ResetToEmpty() { data_ = {}; }
-
-    void set_inline_size(size_t size) { data_.set_inline_size(size); }
-    size_t inline_size() const { return data_.inline_size(); }
-
-    cord_internal::InlineData data_;
-  };
-  InlineRep contents_;
-
-  // Helper for GetFlat() and TryFlat().
-  static bool GetFlatAux(absl::cord_internal::CordRep* rep,
-                         absl::string_view* fragment);
-
-  // Helper for ForEachChunk().
-  static void ForEachChunkAux(
-      absl::cord_internal::CordRep* rep,
-      absl::FunctionRef<void(absl::string_view)> callback);
-
-  // The destructor for non-empty Cords.
-  void DestroyCordSlow();
-
-  // Out-of-line implementation of slower parts of logic.
-  void CopyToArraySlowPath(char* dst) const;
-  int CompareSlowPath(absl::string_view rhs, size_t compared_size,
-                      size_t size_to_compare) const;
-  int CompareSlowPath(const Cord& rhs, size_t compared_size,
-                      size_t size_to_compare) const;
-  bool EqualsImpl(absl::string_view rhs, size_t size_to_compare) const;
-  bool EqualsImpl(const Cord& rhs, size_t size_to_compare) const;
-  int CompareImpl(const Cord& rhs) const;
-
-  template <typename ResultType, typename RHS>
-  friend ResultType GenericCompare(const Cord& lhs, const RHS& rhs,
-                                   size_t size_to_compare);
-  static absl::string_view GetFirstChunk(const Cord& c);
-  static absl::string_view GetFirstChunk(absl::string_view sv);
-
-  // Returns a new reference to contents_.tree(), or steals an existing
-  // reference if called on an rvalue.
-  absl::cord_internal::CordRep* TakeRep() const&;
-  absl::cord_internal::CordRep* TakeRep() &&;
-
-  // Helper for Append().
-  template <typename C>
-  void AppendImpl(C&& src);
-
-  // Appends / Prepends `src` to this instance, using precise sizing.
-  // This method does explicitly not attempt to use any spare capacity
-  // in any pending last added private owned flat.
-  // Requires `src` to be <= kMaxFlatLength.
-  void AppendPrecise(absl::string_view src, MethodIdentifier method);
-  void PrependPrecise(absl::string_view src, MethodIdentifier method);
-
-  CordBuffer GetAppendBufferSlowPath(size_t capacity, size_t min_capacity);
-
-  // Prepends the provided data to this instance. `method` contains the public
-  // API method for this action which is tracked for Cordz sampling purposes.
-  void PrependArray(absl::string_view src, MethodIdentifier method);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    class Cord;
+    class CordTestPeer;
+    template<typename Releaser>
+    Cord MakeCordFromExternal(absl::string_view, Releaser&&);
+    void CopyCordToString(const Cord& src, std::string* dst);
+
+    // Cord memory accounting modes
+    enum class CordMemoryAccounting
+    {
+        // Counts the *approximate* number of bytes held in full or in part by this
+        // Cord (which may not remain the same between invocations). Cords that share
+        // memory could each be "charged" independently for the same shared memory.
+        kTotal,
+
+        // Counts the *approximate* number of bytes held in full or in part by this
+        // Cord weighted by the sharing ratio of that data. For example, if some data
+        // edge is shared by 4 different Cords, then each cord is attributed 1/4th of
+        // the total memory usage as a 'fair share' of the total memory usage.
+        kFairShare,
+    };
+
+    // Cord
+    //
+    // A Cord is a sequence of characters, designed to be more efficient than a
+    // `std::string` in certain circumstances: namely, large string data that needs
+    // to change over its lifetime or shared, especially when such data is shared
+    // across API boundaries.
+    //
+    // A Cord stores its character data in a structure that allows efficient prepend
+    // and append operations. This makes a Cord useful for large string data sent
+    // over in a wire format that may need to be prepended or appended at some point
+    // during the data exchange (e.g. HTTP, protocol buffers). For example, a
+    // Cord is useful for storing an HTTP request, and prepending an HTTP header to
+    // such a request.
+    //
+    // Cords should not be used for storing general string data, however. They
+    // require overhead to construct and are slower than strings for random access.
+    //
+    // The Cord API provides the following common API operations:
+    //
+    // * Create or assign Cords out of existing string data, memory, or other Cords
+    // * Append and prepend data to an existing Cord
+    // * Create new Sub-Cords from existing Cord data
+    // * Swap Cord data and compare Cord equality
+    // * Write out Cord data by constructing a `std::string`
+    //
+    // Additionally, the API provides iterator utilities to iterate through Cord
+    // data via chunks or character bytes.
+    //
+    class Cord
+    {
+    private:
+        template<typename T>
+        using EnableIfString =
+            absl::enable_if_t<std::is_same<T, std::string>::value, int>;
+
+    public:
+        // Cord::Cord() Constructors.
+
+        // Creates an empty Cord.
+        constexpr Cord() noexcept;
+
+        // Creates a Cord from an existing Cord. Cord is copyable and efficiently
+        // movable. The moved-from state is valid but unspecified.
+        Cord(const Cord& src);
+        Cord(Cord&& src) noexcept;
+        Cord& operator=(const Cord& x);
+        Cord& operator=(Cord&& x) noexcept;
+
+        // Creates a Cord from a `src` string. This constructor is marked explicit to
+        // prevent implicit Cord constructions from arguments convertible to an
+        // `absl::string_view`.
+        explicit Cord(absl::string_view src);
+        Cord& operator=(absl::string_view src);
+
+        // Creates a Cord from a `std::string&&` rvalue. These constructors are
+        // templated to avoid ambiguities for types that are convertible to both
+        // `absl::string_view` and `std::string`, such as `const char*`.
+        template<typename T, EnableIfString<T> = 0>
+        explicit Cord(T&& src);
+        template<typename T, EnableIfString<T> = 0>
+        Cord& operator=(T&& src);
+
+        // Cord::~Cord()
+        //
+        // Destructs the Cord.
+        ~Cord()
+        {
+            if (contents_.is_tree())
+                DestroyCordSlow();
+        }
+
+        // MakeCordFromExternal()
+        //
+        // Creates a Cord that takes ownership of external string memory. The
+        // contents of `data` are not copied to the Cord; instead, the external
+        // memory is added to the Cord and reference-counted. This data may not be
+        // changed for the life of the Cord, though it may be prepended or appended
+        // to.
+        //
+        // `MakeCordFromExternal()` takes a callable "releaser" that is invoked when
+        // the reference count for `data` reaches zero. As noted above, this data must
+        // remain live until the releaser is invoked. The callable releaser also must:
+        //
+        //   * be move constructible
+        //   * support `void operator()(absl::string_view) const` or `void operator()`
+        //
+        // Example:
+        //
+        // Cord MakeCord(BlockPool* pool) {
+        //   Block* block = pool->NewBlock();
+        //   FillBlock(block);
+        //   return absl::MakeCordFromExternal(
+        //       block->ToStringView(),
+        //       [pool, block](absl::string_view v) {
+        //         pool->FreeBlock(block, v);
+        //       });
+        // }
+        //
+        // WARNING: Because a Cord can be reference-counted, it's likely a bug if your
+        // releaser doesn't do anything. For example, consider the following:
+        //
+        // void Foo(const char* buffer, int len) {
+        //   auto c = absl::MakeCordFromExternal(absl::string_view(buffer, len),
+        //                                       [](absl::string_view) {});
+        //
+        //   // BUG: If Bar() copies its cord for any reason, including keeping a
+        //   // substring of it, the lifetime of buffer might be extended beyond
+        //   // when Foo() returns.
+        //   Bar(c);
+        // }
+        template<typename Releaser>
+        friend Cord MakeCordFromExternal(absl::string_view data, Releaser&& releaser);
+
+        // Cord::Clear()
+        //
+        // Releases the Cord data. Any nodes that share data with other Cords, if
+        // applicable, will have their reference counts reduced by 1.
+        ABSL_ATTRIBUTE_REINITIALIZES void Clear();
+
+        // Cord::Append()
+        //
+        // Appends data to the Cord, which may come from another Cord or other string
+        // data.
+        void Append(const Cord& src);
+        void Append(Cord&& src);
+        void Append(absl::string_view src);
+        template<typename T, EnableIfString<T> = 0>
+        void Append(T&& src);
+
+        // Appends `buffer` to this cord, unless `buffer` has a zero length in which
+        // case this method has no effect on this cord instance.
+        // This method is guaranteed to consume `buffer`.
+        void Append(CordBuffer buffer);
+
+        // Returns a CordBuffer, re-using potential existing capacity in this cord.
+        //
+        // Cord instances may have additional unused capacity in the last (or first)
+        // nodes of the underlying tree to facilitate amortized growth. This method
+        // allows applications to explicitly use this spare capacity if available,
+        // or create a new CordBuffer instance otherwise.
+        // If this cord has a final non-shared node with at least `min_capacity`
+        // available, then this method will return that buffer including its data
+        // contents. I.e.; the returned buffer will have a non-zero length, and
+        // a capacity of at least `buffer.length + min_capacity`. Otherwise, this
+        // method will return `CordBuffer::CreateWithDefaultLimit(capacity)`.
+        //
+        // Below an example of using GetAppendBuffer. Notice that in this example we
+        // use `GetAppendBuffer()` only on the first iteration. As we know nothing
+        // about any initial extra capacity in `cord`, we may be able to use the extra
+        // capacity. But as we add new buffers with fully utilized contents after that
+        // we avoid calling `GetAppendBuffer()` on subsequent iterations: while this
+        // works fine, it results in an unnecessary inspection of cord contents:
+        //
+        //   void AppendRandomDataToCord(absl::Cord &cord, size_t n) {
+        //     bool first = true;
+        //     while (n > 0) {
+        //       CordBuffer buffer = first ? cord.GetAppendBuffer(n)
+        //                                 : CordBuffer::CreateWithDefaultLimit(n);
+        //       absl::Span<char> data = buffer.available_up_to(n);
+        //       FillRandomValues(data.data(), data.size());
+        //       buffer.IncreaseLengthBy(data.size());
+        //       cord.Append(std::move(buffer));
+        //       n -= data.size();
+        //       first = false;
+        //     }
+        //   }
+        CordBuffer GetAppendBuffer(size_t capacity, size_t min_capacity = 16);
+
+        // Cord::Prepend()
+        //
+        // Prepends data to the Cord, which may come from another Cord or other string
+        // data.
+        void Prepend(const Cord& src);
+        void Prepend(absl::string_view src);
+        template<typename T, EnableIfString<T> = 0>
+        void Prepend(T&& src);
+
+        // Prepends `buffer` to this cord, unless `buffer` has a zero length in which
+        // case this method has no effect on this cord instance.
+        // This method is guaranteed to consume `buffer`.
+        void Prepend(CordBuffer buffer);
+
+        // Cord::RemovePrefix()
+        //
+        // Removes the first `n` bytes of a Cord.
+        void RemovePrefix(size_t n);
+        void RemoveSuffix(size_t n);
+
+        // Cord::Subcord()
+        //
+        // Returns a new Cord representing the subrange [pos, pos + new_size) of
+        // *this. If pos >= size(), the result is empty(). If
+        // (pos + new_size) >= size(), the result is the subrange [pos, size()).
+        Cord Subcord(size_t pos, size_t new_size) const;
+
+        // Cord::swap()
+        //
+        // Swaps the contents of the Cord with `other`.
+        void swap(Cord& other) noexcept;
+
+        // swap()
+        //
+        // Swaps the contents of two Cords.
+        friend void swap(Cord& x, Cord& y) noexcept
+        {
+            x.swap(y);
+        }
+
+        // Cord::size()
+        //
+        // Returns the size of the Cord.
+        size_t size() const;
+
+        // Cord::empty()
+        //
+        // Determines whether the given Cord is empty, returning `true` is so.
+        bool empty() const;
+
+        // Cord::EstimatedMemoryUsage()
+        //
+        // Returns the *approximate* number of bytes held by this cord.
+        // See CordMemoryAccounting for more information on the accounting method.
+        size_t EstimatedMemoryUsage(CordMemoryAccounting accounting_method = CordMemoryAccounting::kTotal) const;
+
+        // Cord::Compare()
+        //
+        // Compares 'this' Cord with rhs. This function and its relatives treat Cords
+        // as sequences of unsigned bytes. The comparison is a straightforward
+        // lexicographic comparison. `Cord::Compare()` returns values as follows:
+        //
+        //   -1  'this' Cord is smaller
+        //    0  two Cords are equal
+        //    1  'this' Cord is larger
+        int Compare(absl::string_view rhs) const;
+        int Compare(const Cord& rhs) const;
+
+        // Cord::StartsWith()
+        //
+        // Determines whether the Cord starts with the passed string data `rhs`.
+        bool StartsWith(const Cord& rhs) const;
+        bool StartsWith(absl::string_view rhs) const;
+
+        // Cord::EndsWith()
+        //
+        // Determines whether the Cord ends with the passed string data `rhs`.
+        bool EndsWith(absl::string_view rhs) const;
+        bool EndsWith(const Cord& rhs) const;
+
+        // Cord::operator std::string()
+        //
+        // Converts a Cord into a `std::string()`. This operator is marked explicit to
+        // prevent unintended Cord usage in functions that take a string.
+        explicit operator std::string() const;
+
+        // CopyCordToString()
+        //
+        // Copies the contents of a `src` Cord into a `*dst` string.
+        //
+        // This function optimizes the case of reusing the destination string since it
+        // can reuse previously allocated capacity. However, this function does not
+        // guarantee that pointers previously returned by `dst->data()` remain valid
+        // even if `*dst` had enough capacity to hold `src`. If `*dst` is a new
+        // object, prefer to simply use the conversion operator to `std::string`.
+        friend void CopyCordToString(const Cord& src, std::string* dst);
+
+        class CharIterator;
+
+        //----------------------------------------------------------------------------
+        // Cord::ChunkIterator
+        //----------------------------------------------------------------------------
+        //
+        // A `Cord::ChunkIterator` allows iteration over the constituent chunks of its
+        // Cord. Such iteration allows you to perform non-const operations on the data
+        // of a Cord without modifying it.
+        //
+        // Generally, you do not instantiate a `Cord::ChunkIterator` directly;
+        // instead, you create one implicitly through use of the `Cord::Chunks()`
+        // member function.
+        //
+        // The `Cord::ChunkIterator` has the following properties:
+        //
+        //   * The iterator is invalidated after any non-const operation on the
+        //     Cord object over which it iterates.
+        //   * The `string_view` returned by dereferencing a valid, non-`end()`
+        //     iterator is guaranteed to be non-empty.
+        //   * Two `ChunkIterator` objects can be compared equal if and only if they
+        //     remain valid and iterate over the same Cord.
+        //   * The iterator in this case is a proxy iterator; the `string_view`
+        //     returned by the iterator does not live inside the Cord, and its
+        //     lifetime is limited to the lifetime of the iterator itself. To help
+        //     prevent lifetime issues, `ChunkIterator::reference` is not a true
+        //     reference type and is equivalent to `value_type`.
+        //   * The iterator keeps state that can grow for Cords that contain many
+        //     nodes and are imbalanced due to sharing. Prefer to pass this type by
+        //     const reference instead of by value.
+        class ChunkIterator
+        {
+        public:
+            using iterator_category = std::input_iterator_tag;
+            using value_type = absl::string_view;
+            using difference_type = ptrdiff_t;
+            using pointer = const value_type*;
+            using reference = value_type;
+
+            ChunkIterator() = default;
+
+            ChunkIterator& operator++();
+            ChunkIterator operator++(int);
+            bool operator==(const ChunkIterator& other) const;
+            bool operator!=(const ChunkIterator& other) const;
+            reference operator*() const;
+            pointer operator->() const;
+
+            friend class Cord;
+            friend class CharIterator;
+
+        private:
+            using CordRep = absl::cord_internal::CordRep;
+            using CordRepBtree = absl::cord_internal::CordRepBtree;
+            using CordRepBtreeReader = absl::cord_internal::CordRepBtreeReader;
+
+            // Constructs a `begin()` iterator from `tree`. `tree` must not be null.
+            explicit ChunkIterator(cord_internal::CordRep* tree);
+
+            // Constructs a `begin()` iterator from `cord`.
+            explicit ChunkIterator(const Cord* cord);
+
+            // Initializes this instance from a tree. Invoked by constructors.
+            void InitTree(cord_internal::CordRep* tree);
+
+            // Removes `n` bytes from `current_chunk_`. Expects `n` to be smaller than
+            // `current_chunk_.size()`.
+            void RemoveChunkPrefix(size_t n);
+            Cord AdvanceAndReadBytes(size_t n);
+            void AdvanceBytes(size_t n);
+
+            // Btree specific operator++
+            ChunkIterator& AdvanceBtree();
+            void AdvanceBytesBtree(size_t n);
+
+            // A view into bytes of the current `CordRep`. It may only be a view to a
+            // suffix of bytes if this is being used by `CharIterator`.
+            absl::string_view current_chunk_;
+            // The current leaf, or `nullptr` if the iterator points to short data.
+            // If the current chunk is a substring node, current_leaf_ points to the
+            // underlying flat or external node.
+            absl::cord_internal::CordRep* current_leaf_ = nullptr;
+            // The number of bytes left in the `Cord` over which we are iterating.
+            size_t bytes_remaining_ = 0;
+
+            // Cord reader for cord btrees. Empty if not traversing a btree.
+            CordRepBtreeReader btree_reader_;
+        };
+
+        // Cord::chunk_begin()
+        //
+        // Returns an iterator to the first chunk of the `Cord`.
+        //
+        // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
+        // iterating over the chunks of a Cord. This method may be useful for getting
+        // a `ChunkIterator` where range-based for-loops are not useful.
+        //
+        // Example:
+        //
+        //   absl::Cord::ChunkIterator FindAsChunk(const absl::Cord& c,
+        //                                         absl::string_view s) {
+        //     return std::find(c.chunk_begin(), c.chunk_end(), s);
+        //   }
+        ChunkIterator chunk_begin() const;
+
+        // Cord::chunk_end()
+        //
+        // Returns an iterator one increment past the last chunk of the `Cord`.
+        //
+        // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
+        // iterating over the chunks of a Cord. This method may be useful for getting
+        // a `ChunkIterator` where range-based for-loops may not be available.
+        ChunkIterator chunk_end() const;
+
+        //----------------------------------------------------------------------------
+        // Cord::ChunkRange
+        //----------------------------------------------------------------------------
+        //
+        // `ChunkRange` is a helper class for iterating over the chunks of the `Cord`,
+        // producing an iterator which can be used within a range-based for loop.
+        // Construction of a `ChunkRange` will return an iterator pointing to the
+        // first chunk of the Cord. Generally, do not construct a `ChunkRange`
+        // directly; instead, prefer to use the `Cord::Chunks()` method.
+        //
+        // Implementation note: `ChunkRange` is simply a convenience wrapper over
+        // `Cord::chunk_begin()` and `Cord::chunk_end()`.
+        class ChunkRange
+        {
+        public:
+            // Fulfill minimum c++ container requirements [container.requirements]
+            // These (partial) container type definitions allow ChunkRange to be used
+            // in various utilities expecting a subset of [container.requirements].
+            // For example, the below enables using `::testing::ElementsAre(...)`
+            using value_type = absl::string_view;
+            using reference = value_type&;
+            using const_reference = const value_type&;
+            using iterator = ChunkIterator;
+            using const_iterator = ChunkIterator;
+
+            explicit ChunkRange(const Cord* cord) :
+                cord_(cord)
+            {
+            }
+
+            ChunkIterator begin() const;
+            ChunkIterator end() const;
+
+        private:
+            const Cord* cord_;
+        };
+
+        // Cord::Chunks()
+        //
+        // Returns a `Cord::ChunkRange` for iterating over the chunks of a `Cord` with
+        // a range-based for-loop. For most iteration tasks on a Cord, use
+        // `Cord::Chunks()` to retrieve this iterator.
+        //
+        // Example:
+        //
+        //   void ProcessChunks(const Cord& cord) {
+        //     for (absl::string_view chunk : cord.Chunks()) { ... }
+        //   }
+        //
+        // Note that the ordinary caveats of temporary lifetime extension apply:
+        //
+        //   void Process() {
+        //     for (absl::string_view chunk : CordFactory().Chunks()) {
+        //       // The temporary Cord returned by CordFactory has been destroyed!
+        //     }
+        //   }
+        ChunkRange Chunks() const;
+
+        //----------------------------------------------------------------------------
+        // Cord::CharIterator
+        //----------------------------------------------------------------------------
+        //
+        // A `Cord::CharIterator` allows iteration over the constituent characters of
+        // a `Cord`.
+        //
+        // Generally, you do not instantiate a `Cord::CharIterator` directly; instead,
+        // you create one implicitly through use of the `Cord::Chars()` member
+        // function.
+        //
+        // A `Cord::CharIterator` has the following properties:
+        //
+        //   * The iterator is invalidated after any non-const operation on the
+        //     Cord object over which it iterates.
+        //   * Two `CharIterator` objects can be compared equal if and only if they
+        //     remain valid and iterate over the same Cord.
+        //   * The iterator keeps state that can grow for Cords that contain many
+        //     nodes and are imbalanced due to sharing. Prefer to pass this type by
+        //     const reference instead of by value.
+        //   * This type cannot act as a forward iterator because a `Cord` can reuse
+        //     sections of memory. This fact violates the requirement for forward
+        //     iterators to compare equal if dereferencing them returns the same
+        //     object.
+        class CharIterator
+        {
+        public:
+            using iterator_category = std::input_iterator_tag;
+            using value_type = char;
+            using difference_type = ptrdiff_t;
+            using pointer = const char*;
+            using reference = const char&;
+
+            CharIterator() = default;
+
+            CharIterator& operator++();
+            CharIterator operator++(int);
+            bool operator==(const CharIterator& other) const;
+            bool operator!=(const CharIterator& other) const;
+            reference operator*() const;
+            pointer operator->() const;
+
+            friend Cord;
+
+        private:
+            explicit CharIterator(const Cord* cord) :
+                chunk_iterator_(cord)
+            {
+            }
+
+            ChunkIterator chunk_iterator_;
+        };
+
+        // Cord::AdvanceAndRead()
+        //
+        // Advances the `Cord::CharIterator` by `n_bytes` and returns the bytes
+        // advanced as a separate `Cord`. `n_bytes` must be less than or equal to the
+        // number of bytes within the Cord; otherwise, behavior is undefined. It is
+        // valid to pass `char_end()` and `0`.
+        static Cord AdvanceAndRead(CharIterator* it, size_t n_bytes);
+
+        // Cord::Advance()
+        //
+        // Advances the `Cord::CharIterator` by `n_bytes`. `n_bytes` must be less than
+        // or equal to the number of bytes remaining within the Cord; otherwise,
+        // behavior is undefined. It is valid to pass `char_end()` and `0`.
+        static void Advance(CharIterator* it, size_t n_bytes);
+
+        // Cord::ChunkRemaining()
+        //
+        // Returns the longest contiguous view starting at the iterator's position.
+        //
+        // `it` must be dereferenceable.
+        static absl::string_view ChunkRemaining(const CharIterator& it);
+
+        // Cord::char_begin()
+        //
+        // Returns an iterator to the first character of the `Cord`.
+        //
+        // Generally, prefer using `Cord::Chars()` within a range-based for loop for
+        // iterating over the chunks of a Cord. This method may be useful for getting
+        // a `CharIterator` where range-based for-loops may not be available.
+        CharIterator char_begin() const;
+
+        // Cord::char_end()
+        //
+        // Returns an iterator to one past the last character of the `Cord`.
+        //
+        // Generally, prefer using `Cord::Chars()` within a range-based for loop for
+        // iterating over the chunks of a Cord. This method may be useful for getting
+        // a `CharIterator` where range-based for-loops are not useful.
+        CharIterator char_end() const;
+
+        // Cord::CharRange
+        //
+        // `CharRange` is a helper class for iterating over the characters of a
+        // producing an iterator which can be used within a range-based for loop.
+        // Construction of a `CharRange` will return an iterator pointing to the first
+        // character of the Cord. Generally, do not construct a `CharRange` directly;
+        // instead, prefer to use the `Cord::Chars()` method shown below.
+        //
+        // Implementation note: `CharRange` is simply a convenience wrapper over
+        // `Cord::char_begin()` and `Cord::char_end()`.
+        class CharRange
+        {
+        public:
+            // Fulfill minimum c++ container requirements [container.requirements]
+            // Theses (partial) container type definitions allow CharRange to be used
+            // in various utilities expecting a subset of [container.requirements].
+            // For example, the below enables using `::testing::ElementsAre(...)`
+            using value_type = char;
+            using reference = value_type&;
+            using const_reference = const value_type&;
+            using iterator = CharIterator;
+            using const_iterator = CharIterator;
+
+            explicit CharRange(const Cord* cord) :
+                cord_(cord)
+            {
+            }
+
+            CharIterator begin() const;
+            CharIterator end() const;
+
+        private:
+            const Cord* cord_;
+        };
+
+        // Cord::Chars()
+        //
+        // Returns a `Cord::CharRange` for iterating over the characters of a `Cord`
+        // with a range-based for-loop. For most character-based iteration tasks on a
+        // Cord, use `Cord::Chars()` to retrieve this iterator.
+        //
+        // Example:
+        //
+        //   void ProcessCord(const Cord& cord) {
+        //     for (char c : cord.Chars()) { ... }
+        //   }
+        //
+        // Note that the ordinary caveats of temporary lifetime extension apply:
+        //
+        //   void Process() {
+        //     for (char c : CordFactory().Chars()) {
+        //       // The temporary Cord returned by CordFactory has been destroyed!
+        //     }
+        //   }
+        CharRange Chars() const;
+
+        // Cord::operator[]
+        //
+        // Gets the "i"th character of the Cord and returns it, provided that
+        // 0 <= i < Cord.size().
+        //
+        // NOTE: This routine is reasonably efficient. It is roughly
+        // logarithmic based on the number of chunks that make up the cord. Still,
+        // if you need to iterate over the contents of a cord, you should
+        // use a CharIterator/ChunkIterator rather than call operator[] or Get()
+        // repeatedly in a loop.
+        char operator[](size_t i) const;
+
+        // Cord::TryFlat()
+        //
+        // If this cord's representation is a single flat array, returns a
+        // string_view referencing that array.  Otherwise returns nullopt.
+        absl::optional<absl::string_view> TryFlat() const;
+
+        // Cord::Flatten()
+        //
+        // Flattens the cord into a single array and returns a view of the data.
+        //
+        // If the cord was already flat, the contents are not modified.
+        absl::string_view Flatten();
+
+        // Supports absl::Cord as a sink object for absl::Format().
+        friend void AbslFormatFlush(absl::Cord* cord, absl::string_view part)
+        {
+            cord->Append(part);
+        }
+
+        // Cord::SetExpectedChecksum()
+        //
+        // Stores a checksum value with this non-empty cord instance, for later
+        // retrieval.
+        //
+        // The expected checksum is a number stored out-of-band, alongside the data.
+        // It is preserved across copies and assignments, but any mutations to a cord
+        // will cause it to lose its expected checksum.
+        //
+        // The expected checksum is not part of a Cord's value, and does not affect
+        // operations such as equality or hashing.
+        //
+        // This field is intended to store a CRC32C checksum for later validation, to
+        // help support end-to-end checksum workflows.  However, the Cord API itself
+        // does no CRC validation, and assigns no meaning to this number.
+        //
+        // This call has no effect if this cord is empty.
+        void SetExpectedChecksum(uint32_t crc);
+
+        // Returns this cord's expected checksum, if it has one.  Otherwise, returns
+        // nullopt.
+        absl::optional<uint32_t> ExpectedChecksum() const;
+
+        template<typename H>
+        friend H AbslHashValue(H hash_state, const absl::Cord& c)
+        {
+            absl::optional<absl::string_view> maybe_flat = c.TryFlat();
+            if (maybe_flat.has_value())
+            {
+                return H::combine(std::move(hash_state), *maybe_flat);
+            }
+            return c.HashFragmented(std::move(hash_state));
+        }
+
+        // Create a Cord with the contents of StringConstant<T>::value.
+        // No allocations will be done and no data will be copied.
+        // This is an INTERNAL API and subject to change or removal. This API can only
+        // be used by spelling absl::strings_internal::MakeStringConstant, which is
+        // also an internal API.
+        template<typename T>
+        // NOLINTNEXTLINE(google-explicit-constructor)
+        constexpr Cord(strings_internal::StringConstant<T>);
+
+    private:
+        using CordRep = absl::cord_internal::CordRep;
+        using CordRepFlat = absl::cord_internal::CordRepFlat;
+        using CordzInfo = cord_internal::CordzInfo;
+        using CordzUpdateScope = cord_internal::CordzUpdateScope;
+        using CordzUpdateTracker = cord_internal::CordzUpdateTracker;
+        using InlineData = cord_internal::InlineData;
+        using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
+
+        // Creates a cord instance with `method` representing the originating
+        // public API call causing the cord to be created.
+        explicit Cord(absl::string_view src, MethodIdentifier method);
+
+        friend class CordTestPeer;
+        friend bool operator==(const Cord& lhs, const Cord& rhs);
+        friend bool operator==(const Cord& lhs, absl::string_view rhs);
+
+        friend const CordzInfo* GetCordzInfoForTesting(const Cord& cord);
+
+        // Calls the provided function once for each cord chunk, in order.  Unlike
+        // Chunks(), this API will not allocate memory.
+        void ForEachChunk(absl::FunctionRef<void(absl::string_view)>) const;
+
+        // Allocates new contiguous storage for the contents of the cord. This is
+        // called by Flatten() when the cord was not already flat.
+        absl::string_view FlattenSlowPath();
+
+        // Actual cord contents are hidden inside the following simple
+        // class so that we can isolate the bulk of cord.cc from changes
+        // to the representation.
+        //
+        // InlineRep holds either a tree pointer, or an array of kMaxInline bytes.
+        class InlineRep
+        {
+        public:
+            static constexpr unsigned char kMaxInline = cord_internal::kMaxInline;
+            static_assert(kMaxInline >= sizeof(absl::cord_internal::CordRep*), "");
+
+            constexpr InlineRep() :
+                data_()
+            {
+            }
+            explicit InlineRep(InlineData::DefaultInitType init) :
+                data_(init)
+            {
+            }
+            InlineRep(const InlineRep& src);
+            InlineRep(InlineRep&& src);
+            InlineRep& operator=(const InlineRep& src);
+            InlineRep& operator=(InlineRep&& src) noexcept;
+
+            explicit constexpr InlineRep(cord_internal::InlineData data);
+
+            void Swap(InlineRep* rhs);
+            bool empty() const;
+            size_t size() const;
+            const char* data() const;                   // Returns nullptr if holding pointer
+            void set_data(const char* data, size_t n);  // Discards pointer, if any
+            char* set_data(size_t n);                   // Write data to the result
+            // Returns nullptr if holding bytes
+            absl::cord_internal::CordRep* tree() const;
+            absl::cord_internal::CordRep* as_tree() const;
+            const char* as_chars() const;
+            // Returns non-null iff was holding a pointer
+            absl::cord_internal::CordRep* clear();
+            // Converts to pointer if necessary.
+            void reduce_size(size_t n);    // REQUIRES: holding data
+            void remove_prefix(size_t n);  // REQUIRES: holding data
+            void AppendArray(absl::string_view src, MethodIdentifier method);
+            absl::string_view FindFlatStartPiece() const;
+
+            // Creates a CordRepFlat instance from the current inlined data with `extra'
+            // bytes of desired additional capacity.
+            CordRepFlat* MakeFlatWithExtraCapacity(size_t extra);
+
+            // Sets the tree value for this instance. `rep` must not be null.
+            // Requires the current instance to hold a tree, and a lock to be held on
+            // any CordzInfo referenced by this instance. The latter is enforced through
+            // the CordzUpdateScope argument. If the current instance is sampled, then
+            // the CordzInfo instance is updated to reference the new `rep` value.
+            void SetTree(CordRep* rep, const CordzUpdateScope& scope);
+
+            // Identical to SetTree(), except that `rep` is allowed to be null, in
+            // which case the current instance is reset to an empty value.
+            void SetTreeOrEmpty(CordRep* rep, const CordzUpdateScope& scope);
+
+            // Sets the tree value for this instance, and randomly samples this cord.
+            // This function disregards existing contents in `data_`, and should be
+            // called when a Cord is 'promoted' from an 'uninitialized' or 'inlined'
+            // value to a non-inlined (tree / ring) value.
+            void EmplaceTree(CordRep* rep, MethodIdentifier method);
+
+            // Identical to EmplaceTree, except that it copies the parent stack from
+            // the provided `parent` data if the parent is sampled.
+            void EmplaceTree(CordRep* rep, const InlineData& parent, MethodIdentifier method);
+
+            // Commits the change of a newly created, or updated `rep` root value into
+            // this cord. `old_rep` indicates the old (inlined or tree) value of the
+            // cord, and determines if the commit invokes SetTree() or EmplaceTree().
+            void CommitTree(const CordRep* old_rep, CordRep* rep, const CordzUpdateScope& scope, MethodIdentifier method);
+
+            void AppendTreeToInlined(CordRep* tree, MethodIdentifier method);
+            void AppendTreeToTree(CordRep* tree, MethodIdentifier method);
+            void AppendTree(CordRep* tree, MethodIdentifier method);
+            void PrependTreeToInlined(CordRep* tree, MethodIdentifier method);
+            void PrependTreeToTree(CordRep* tree, MethodIdentifier method);
+            void PrependTree(CordRep* tree, MethodIdentifier method);
+
+            template<bool has_length>
+            void GetAppendRegion(char** region, size_t* size, size_t length);
+
+            bool IsSame(const InlineRep& other) const
+            {
+                return memcmp(&data_, &other.data_, sizeof(data_)) == 0;
+            }
+            int BitwiseCompare(const InlineRep& other) const
+            {
+                uint64_t x, y;
+                // Use memcpy to avoid aliasing issues.
+                memcpy(&x, &data_, sizeof(x));
+                memcpy(&y, &other.data_, sizeof(y));
+                if (x == y)
+                {
+                    memcpy(&x, reinterpret_cast<const char*>(&data_) + 8, sizeof(x));
+                    memcpy(&y, reinterpret_cast<const char*>(&other.data_) + 8, sizeof(y));
+                    if (x == y)
+                        return 0;
+                }
+                return absl::big_endian::FromHost64(x) < absl::big_endian::FromHost64(y) ? -1 : 1;
+            }
+            void CopyTo(std::string* dst) const
+            {
+                // memcpy is much faster when operating on a known size. On most supported
+                // platforms, the small string optimization is large enough that resizing
+                // to 15 bytes does not cause a memory allocation.
+                absl::strings_internal::STLStringResizeUninitialized(dst, sizeof(data_) - 1);
+                memcpy(&(*dst)[0], &data_, sizeof(data_) - 1);
+                // erase is faster than resize because the logic for memory allocation is
+                // not needed.
+                dst->erase(inline_size());
+            }
+
+            // Copies the inline contents into `dst`. Assumes the cord is not empty.
+            void CopyToArray(char* dst) const;
+
+            bool is_tree() const
+            {
+                return data_.is_tree();
+            }
+
+            // Returns true if the Cord is being profiled by cordz.
+            bool is_profiled() const
+            {
+                return data_.is_tree() && data_.is_profiled();
+            }
+
+            // Returns the available inlined capacity, or 0 if is_tree() == true.
+            size_t remaining_inline_capacity() const
+            {
+                return data_.is_tree() ? 0 : kMaxInline - data_.inline_size();
+            }
+
+            // Returns the profiled CordzInfo, or nullptr if not sampled.
+            absl::cord_internal::CordzInfo* cordz_info() const
+            {
+                return data_.cordz_info();
+            }
+
+            // Sets the profiled CordzInfo. `cordz_info` must not be null.
+            void set_cordz_info(cord_internal::CordzInfo* cordz_info)
+            {
+                assert(cordz_info != nullptr);
+                data_.set_cordz_info(cordz_info);
+            }
+
+            // Resets the current cordz_info to null / empty.
+            void clear_cordz_info()
+            {
+                data_.clear_cordz_info();
+            }
+
+        private:
+            friend class Cord;
+
+            void AssignSlow(const InlineRep& src);
+            // Unrefs the tree and stops profiling.
+            void UnrefTree();
+
+            void ResetToEmpty()
+            {
+                data_ = {};
+            }
+
+            void set_inline_size(size_t size)
+            {
+                data_.set_inline_size(size);
+            }
+            size_t inline_size() const
+            {
+                return data_.inline_size();
+            }
+
+            cord_internal::InlineData data_;
+        };
+        InlineRep contents_;
+
+        // Helper for GetFlat() and TryFlat().
+        static bool GetFlatAux(absl::cord_internal::CordRep* rep, absl::string_view* fragment);
+
+        // Helper for ForEachChunk().
+        static void ForEachChunkAux(
+            absl::cord_internal::CordRep* rep,
+            absl::FunctionRef<void(absl::string_view)> callback
+        );
+
+        // The destructor for non-empty Cords.
+        void DestroyCordSlow();
+
+        // Out-of-line implementation of slower parts of logic.
+        void CopyToArraySlowPath(char* dst) const;
+        int CompareSlowPath(absl::string_view rhs, size_t compared_size, size_t size_to_compare) const;
+        int CompareSlowPath(const Cord& rhs, size_t compared_size, size_t size_to_compare) const;
+        bool EqualsImpl(absl::string_view rhs, size_t size_to_compare) const;
+        bool EqualsImpl(const Cord& rhs, size_t size_to_compare) const;
+        int CompareImpl(const Cord& rhs) const;
+
+        template<typename ResultType, typename RHS>
+        friend ResultType GenericCompare(const Cord& lhs, const RHS& rhs, size_t size_to_compare);
+        static absl::string_view GetFirstChunk(const Cord& c);
+        static absl::string_view GetFirstChunk(absl::string_view sv);
+
+        // Returns a new reference to contents_.tree(), or steals an existing
+        // reference if called on an rvalue.
+        absl::cord_internal::CordRep* TakeRep() const&;
+        absl::cord_internal::CordRep* TakeRep() &&;
+
+        // Helper for Append().
+        template<typename C>
+        void AppendImpl(C&& src);
+
+        // Appends / Prepends `src` to this instance, using precise sizing.
+        // This method does explicitly not attempt to use any spare capacity
+        // in any pending last added private owned flat.
+        // Requires `src` to be <= kMaxFlatLength.
+        void AppendPrecise(absl::string_view src, MethodIdentifier method);
+        void PrependPrecise(absl::string_view src, MethodIdentifier method);
+
+        CordBuffer GetAppendBufferSlowPath(size_t capacity, size_t min_capacity);
+
+        // Prepends the provided data to this instance. `method` contains the public
+        // API method for this action which is tracked for Cordz sampling purposes.
+        void PrependArray(absl::string_view src, MethodIdentifier method);
+
+        // Assigns the value in 'src' to this instance, 'stealing' its contents.
+        // Requires src.length() > kMaxBytesToCopy.
+        Cord& AssignLargeString(std::string&& src);
+
+        // Helper for AbslHashValue().
+        template<typename H>
+        H HashFragmented(H hash_state) const
+        {
+            typename H::AbslInternalPiecewiseCombiner combiner;
+            ForEachChunk([&combiner, &hash_state](absl::string_view chunk)
+                         { hash_state = combiner.add_buffer(std::move(hash_state), chunk.data(), chunk.size()); });
+            return H::combine(combiner.finalize(std::move(hash_state)), size());
+        }
+    };
+
+    ABSL_NAMESPACE_END
+}  // namespace absl
 
-  // Assigns the value in 'src' to this instance, 'stealing' its contents.
-  // Requires src.length() > kMaxBytesToCopy.
-  Cord& AssignLargeString(std::string&& src);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // allow a Cord to be logged
+    extern std::ostream& operator<<(std::ostream& out, const Cord& cord);
+
+    // ------------------------------------------------------------------
+    // Internal details follow.  Clients should ignore.
+
+    namespace cord_internal
+    {
+
+        // Fast implementation of memmove for up to 15 bytes. This implementation is
+        // safe for overlapping regions. If nullify_tail is true, the destination is
+        // padded with '\0' up to 16 bytes.
+        template<bool nullify_tail = false>
+        inline void SmallMemmove(char* dst, const char* src, size_t n)
+        {
+            if (n >= 8)
+            {
+                assert(n <= 16);
+                uint64_t buf1;
+                uint64_t buf2;
+                memcpy(&buf1, src, 8);
+                memcpy(&buf2, src + n - 8, 8);
+                if (nullify_tail)
+                {
+                    memset(dst + 8, 0, 8);
+                }
+                memcpy(dst, &buf1, 8);
+                memcpy(dst + n - 8, &buf2, 8);
+            }
+            else if (n >= 4)
+            {
+                uint32_t buf1;
+                uint32_t buf2;
+                memcpy(&buf1, src, 4);
+                memcpy(&buf2, src + n - 4, 4);
+                if (nullify_tail)
+                {
+                    memset(dst + 4, 0, 4);
+                    memset(dst + 8, 0, 8);
+                }
+                memcpy(dst, &buf1, 4);
+                memcpy(dst + n - 4, &buf2, 4);
+            }
+            else
+            {
+                if (n != 0)
+                {
+                    dst[0] = src[0];
+                    dst[n / 2] = src[n / 2];
+                    dst[n - 1] = src[n - 1];
+                }
+                if (nullify_tail)
+                {
+                    memset(dst + 8, 0, 8);
+                    memset(dst + n, 0, 8);
+                }
+            }
+        }
+
+        // Does non-template-specific `CordRepExternal` initialization.
+        // Requires `data` to be non-empty.
+        void InitializeCordRepExternal(absl::string_view data, CordRepExternal* rep);
+
+        // Creates a new `CordRep` that owns `data` and `releaser` and returns a pointer
+        // to it. Requires `data` to be non-empty.
+        template<typename Releaser>
+        // NOLINTNEXTLINE - suppress clang-tidy raw pointer return.
+        CordRep* NewExternalRep(absl::string_view data, Releaser&& releaser)
+        {
+            assert(!data.empty());
+            using ReleaserType = absl::decay_t<Releaser>;
+            CordRepExternal* rep = new CordRepExternalImpl<ReleaserType>(
+                std::forward<Releaser>(releaser), 0
+            );
+            InitializeCordRepExternal(data, rep);
+            return rep;
+        }
+
+        // Overload for function reference types that dispatches using a function
+        // pointer because there are no `alignof()` or `sizeof()` a function reference.
+        // NOLINTNEXTLINE - suppress clang-tidy raw pointer return.
+        inline CordRep* NewExternalRep(absl::string_view data, void (&releaser)(absl::string_view))
+        {
+            return NewExternalRep(data, &releaser);
+        }
+
+    }  // namespace cord_internal
+
+    template<typename Releaser>
+    Cord MakeCordFromExternal(absl::string_view data, Releaser&& releaser)
+    {
+        Cord cord;
+        if (ABSL_PREDICT_TRUE(!data.empty()))
+        {
+            cord.contents_.EmplaceTree(::absl::cord_internal::NewExternalRep(data, std::forward<Releaser>(releaser)), Cord::MethodIdentifier::kMakeCordFromExternal);
+        }
+        else
+        {
+            using ReleaserType = absl::decay_t<Releaser>;
+            cord_internal::InvokeReleaser(
+                cord_internal::Rank0{}, ReleaserType(std::forward<Releaser>(releaser)), data
+            );
+        }
+        return cord;
+    }
 
-  // Helper for AbslHashValue().
-  template <typename H>
-  H HashFragmented(H hash_state) const {
-    typename H::AbslInternalPiecewiseCombiner combiner;
-    ForEachChunk([&combiner, &hash_state](absl::string_view chunk) {
-      hash_state = combiner.add_buffer(std::move(hash_state), chunk.data(),
-                                       chunk.size());
-    });
-    return H::combine(combiner.finalize(std::move(hash_state)), size());
-  }
-};
-
-ABSL_NAMESPACE_END
-}  // namespace absl
+    constexpr Cord::InlineRep::InlineRep(cord_internal::InlineData data) :
+        data_(data)
+    {
+    }
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// allow a Cord to be logged
-extern std::ostream& operator<<(std::ostream& out, const Cord& cord);
-
-// ------------------------------------------------------------------
-// Internal details follow.  Clients should ignore.
-
-namespace cord_internal {
-
-// Fast implementation of memmove for up to 15 bytes. This implementation is
-// safe for overlapping regions. If nullify_tail is true, the destination is
-// padded with '\0' up to 16 bytes.
-template <bool nullify_tail = false>
-inline void SmallMemmove(char* dst, const char* src, size_t n) {
-  if (n >= 8) {
-    assert(n <= 16);
-    uint64_t buf1;
-    uint64_t buf2;
-    memcpy(&buf1, src, 8);
-    memcpy(&buf2, src + n - 8, 8);
-    if (nullify_tail) {
-      memset(dst + 8, 0, 8);
-    }
-    memcpy(dst, &buf1, 8);
-    memcpy(dst + n - 8, &buf2, 8);
-  } else if (n >= 4) {
-    uint32_t buf1;
-    uint32_t buf2;
-    memcpy(&buf1, src, 4);
-    memcpy(&buf2, src + n - 4, 4);
-    if (nullify_tail) {
-      memset(dst + 4, 0, 4);
-      memset(dst + 8, 0, 8);
-    }
-    memcpy(dst, &buf1, 4);
-    memcpy(dst + n - 4, &buf2, 4);
-  } else {
-    if (n != 0) {
-      dst[0] = src[0];
-      dst[n / 2] = src[n / 2];
-      dst[n - 1] = src[n - 1];
-    }
-    if (nullify_tail) {
-      memset(dst + 8, 0, 8);
-      memset(dst + n, 0, 8);
-    }
-  }
-}
-
-// Does non-template-specific `CordRepExternal` initialization.
-// Requires `data` to be non-empty.
-void InitializeCordRepExternal(absl::string_view data, CordRepExternal* rep);
-
-// Creates a new `CordRep` that owns `data` and `releaser` and returns a pointer
-// to it. Requires `data` to be non-empty.
-template <typename Releaser>
-// NOLINTNEXTLINE - suppress clang-tidy raw pointer return.
-CordRep* NewExternalRep(absl::string_view data, Releaser&& releaser) {
-  assert(!data.empty());
-  using ReleaserType = absl::decay_t<Releaser>;
-  CordRepExternal* rep = new CordRepExternalImpl<ReleaserType>(
-      std::forward<Releaser>(releaser), 0);
-  InitializeCordRepExternal(data, rep);
-  return rep;
-}
-
-// Overload for function reference types that dispatches using a function
-// pointer because there are no `alignof()` or `sizeof()` a function reference.
-// NOLINTNEXTLINE - suppress clang-tidy raw pointer return.
-inline CordRep* NewExternalRep(absl::string_view data,
-                               void (&releaser)(absl::string_view)) {
-  return NewExternalRep(data, &releaser);
-}
-
-}  // namespace cord_internal
-
-template <typename Releaser>
-Cord MakeCordFromExternal(absl::string_view data, Releaser&& releaser) {
-  Cord cord;
-  if (ABSL_PREDICT_TRUE(!data.empty())) {
-    cord.contents_.EmplaceTree(::absl::cord_internal::NewExternalRep(
-                                   data, std::forward<Releaser>(releaser)),
-                               Cord::MethodIdentifier::kMakeCordFromExternal);
-  } else {
-    using ReleaserType = absl::decay_t<Releaser>;
-    cord_internal::InvokeReleaser(
-        cord_internal::Rank0{}, ReleaserType(std::forward<Releaser>(releaser)),
-        data);
-  }
-  return cord;
-}
-
-constexpr Cord::InlineRep::InlineRep(cord_internal::InlineData data)
-    : data_(data) {}
-
-inline Cord::InlineRep::InlineRep(const Cord::InlineRep& src)
-    : data_(InlineData::kDefaultInit) {
-  if (CordRep* tree = src.tree()) {
-    EmplaceTree(CordRep::Ref(tree), src.data_,
-                CordzUpdateTracker::kConstructorCord);
-  } else {
-    data_ = src.data_;
-  }
-}
-
-inline Cord::InlineRep::InlineRep(Cord::InlineRep&& src) : data_(src.data_) {
-  src.ResetToEmpty();
-}
-
-inline Cord::InlineRep& Cord::InlineRep::operator=(const Cord::InlineRep& src) {
-  if (this == &src) {
-    return *this;
-  }
-  if (!is_tree() && !src.is_tree()) {
-    data_ = src.data_;
-    return *this;
-  }
-  AssignSlow(src);
-  return *this;
-}
-
-inline Cord::InlineRep& Cord::InlineRep::operator=(
-    Cord::InlineRep&& src) noexcept {
-  if (is_tree()) {
-    UnrefTree();
-  }
-  data_ = src.data_;
-  src.ResetToEmpty();
-  return *this;
-}
-
-inline void Cord::InlineRep::Swap(Cord::InlineRep* rhs) {
-  if (rhs == this) {
-    return;
-  }
-  std::swap(data_, rhs->data_);
-}
-
-inline const char* Cord::InlineRep::data() const {
-  return is_tree() ? nullptr : data_.as_chars();
-}
-
-inline const char* Cord::InlineRep::as_chars() const {
-  assert(!data_.is_tree());
-  return data_.as_chars();
-}
-
-inline absl::cord_internal::CordRep* Cord::InlineRep::as_tree() const {
-  assert(data_.is_tree());
-  return data_.as_tree();
-}
-
-inline absl::cord_internal::CordRep* Cord::InlineRep::tree() const {
-  if (is_tree()) {
-    return as_tree();
-  } else {
-    return nullptr;
-  }
-}
-
-inline bool Cord::InlineRep::empty() const { return data_.is_empty(); }
-
-inline size_t Cord::InlineRep::size() const {
-  return is_tree() ? as_tree()->length : inline_size();
-}
-
-inline cord_internal::CordRepFlat* Cord::InlineRep::MakeFlatWithExtraCapacity(
-    size_t extra) {
-  static_assert(cord_internal::kMinFlatLength >= sizeof(data_), "");
-  size_t len = data_.inline_size();
-  auto* result = CordRepFlat::New(len + extra);
-  result->length = len;
-  memcpy(result->Data(), data_.as_chars(), sizeof(data_));
-  return result;
-}
-
-inline void Cord::InlineRep::EmplaceTree(CordRep* rep,
-                                         MethodIdentifier method) {
-  assert(rep);
-  data_.make_tree(rep);
-  CordzInfo::MaybeTrackCord(data_, method);
-}
-
-inline void Cord::InlineRep::EmplaceTree(CordRep* rep, const InlineData& parent,
-                                         MethodIdentifier method) {
-  data_.make_tree(rep);
-  CordzInfo::MaybeTrackCord(data_, parent, method);
-}
-
-inline void Cord::InlineRep::SetTree(CordRep* rep,
-                                     const CordzUpdateScope& scope) {
-  assert(rep);
-  assert(data_.is_tree());
-  data_.set_tree(rep);
-  scope.SetCordRep(rep);
-}
-
-inline void Cord::InlineRep::SetTreeOrEmpty(CordRep* rep,
-                                            const CordzUpdateScope& scope) {
-  assert(data_.is_tree());
-  if (rep) {
-    data_.set_tree(rep);
-  } else {
-    data_ = {};
-  }
-  scope.SetCordRep(rep);
-}
-
-inline void Cord::InlineRep::CommitTree(const CordRep* old_rep, CordRep* rep,
-                                        const CordzUpdateScope& scope,
-                                        MethodIdentifier method) {
-  if (old_rep) {
-    SetTree(rep, scope);
-  } else {
-    EmplaceTree(rep, method);
-  }
-}
-
-inline absl::cord_internal::CordRep* Cord::InlineRep::clear() {
-  if (is_tree()) {
-    CordzInfo::MaybeUntrackCord(cordz_info());
-  }
-  absl::cord_internal::CordRep* result = tree();
-  ResetToEmpty();
-  return result;
-}
-
-inline void Cord::InlineRep::CopyToArray(char* dst) const {
-  assert(!is_tree());
-  size_t n = inline_size();
-  assert(n != 0);
-  cord_internal::SmallMemmove(dst, data_.as_chars(), n);
-}
-
-constexpr inline Cord::Cord() noexcept {}
-
-inline Cord::Cord(absl::string_view src)
-    : Cord(src, CordzUpdateTracker::kConstructorString) {}
-
-template <typename T>
-constexpr Cord::Cord(strings_internal::StringConstant<T>)
-    : contents_(strings_internal::StringConstant<T>::value.size() <=
-                        cord_internal::kMaxInline
-                    ? cord_internal::InlineData(
-                          strings_internal::StringConstant<T>::value)
-                    : cord_internal::InlineData(
-                          &cord_internal::ConstInitExternalStorage<
-                              strings_internal::StringConstant<T>>::value)) {}
-
-inline Cord& Cord::operator=(const Cord& x) {
-  contents_ = x.contents_;
-  return *this;
-}
-
-template <typename T, Cord::EnableIfString<T>>
-Cord& Cord::operator=(T&& src) {
-  if (src.size() <= cord_internal::kMaxBytesToCopy) {
-    return operator=(absl::string_view(src));
-  } else {
-    return AssignLargeString(std::forward<T>(src));
-  }
-}
-
-inline Cord::Cord(const Cord& src) : contents_(src.contents_) {}
-
-inline Cord::Cord(Cord&& src) noexcept : contents_(std::move(src.contents_)) {}
-
-inline void Cord::swap(Cord& other) noexcept {
-  contents_.Swap(&other.contents_);
-}
-
-inline Cord& Cord::operator=(Cord&& x) noexcept {
-  contents_ = std::move(x.contents_);
-  return *this;
-}
-
-extern template Cord::Cord(std::string&& src);
-
-inline size_t Cord::size() const {
-  // Length is 1st field in str.rep_
-  return contents_.size();
-}
-
-inline bool Cord::empty() const { return contents_.empty(); }
-
-inline size_t Cord::EstimatedMemoryUsage(
-    CordMemoryAccounting accounting_method) const {
-  size_t result = sizeof(Cord);
-  if (const absl::cord_internal::CordRep* rep = contents_.tree()) {
-    if (accounting_method == CordMemoryAccounting::kFairShare) {
-      result += cord_internal::GetEstimatedFairShareMemoryUsage(rep);
-    } else {
-      result += cord_internal::GetEstimatedMemoryUsage(rep);
-    }
-  }
-  return result;
-}
-
-inline absl::optional<absl::string_view> Cord::TryFlat() const {
-  absl::cord_internal::CordRep* rep = contents_.tree();
-  if (rep == nullptr) {
-    return absl::string_view(contents_.data(), contents_.size());
-  }
-  absl::string_view fragment;
-  if (GetFlatAux(rep, &fragment)) {
-    return fragment;
-  }
-  return absl::nullopt;
-}
-
-inline absl::string_view Cord::Flatten() {
-  absl::cord_internal::CordRep* rep = contents_.tree();
-  if (rep == nullptr) {
-    return absl::string_view(contents_.data(), contents_.size());
-  } else {
-    absl::string_view already_flat_contents;
-    if (GetFlatAux(rep, &already_flat_contents)) {
-      return already_flat_contents;
-    }
-  }
-  return FlattenSlowPath();
-}
-
-inline void Cord::Append(absl::string_view src) {
-  contents_.AppendArray(src, CordzUpdateTracker::kAppendString);
-}
-
-inline void Cord::Prepend(absl::string_view src) {
-  PrependArray(src, CordzUpdateTracker::kPrependString);
-}
-
-inline void Cord::Append(CordBuffer buffer) {
-  if (ABSL_PREDICT_FALSE(buffer.length() == 0)) return;
-  absl::string_view short_value;
-  if (CordRep* rep = buffer.ConsumeValue(short_value)) {
-    contents_.AppendTree(rep, CordzUpdateTracker::kAppendCordBuffer);
-  } else {
-    AppendPrecise(short_value, CordzUpdateTracker::kAppendCordBuffer);
-  }
-}
-
-inline void Cord::Prepend(CordBuffer buffer) {
-  if (ABSL_PREDICT_FALSE(buffer.length() == 0)) return;
-  absl::string_view short_value;
-  if (CordRep* rep = buffer.ConsumeValue(short_value)) {
-    contents_.PrependTree(rep, CordzUpdateTracker::kPrependCordBuffer);
-  } else {
-    PrependPrecise(short_value, CordzUpdateTracker::kPrependCordBuffer);
-  }
-}
-
-inline CordBuffer Cord::GetAppendBuffer(size_t capacity, size_t min_capacity) {
-  if (empty()) return CordBuffer::CreateWithDefaultLimit(capacity);
-  return GetAppendBufferSlowPath(capacity, min_capacity);
-}
-
-extern template void Cord::Append(std::string&& src);
-extern template void Cord::Prepend(std::string&& src);
-
-inline int Cord::Compare(const Cord& rhs) const {
-  if (!contents_.is_tree() && !rhs.contents_.is_tree()) {
-    return contents_.BitwiseCompare(rhs.contents_);
-  }
-
-  return CompareImpl(rhs);
-}
-
-// Does 'this' cord start/end with rhs
-inline bool Cord::StartsWith(const Cord& rhs) const {
-  if (contents_.IsSame(rhs.contents_)) return true;
-  size_t rhs_size = rhs.size();
-  if (size() < rhs_size) return false;
-  return EqualsImpl(rhs, rhs_size);
-}
-
-inline bool Cord::StartsWith(absl::string_view rhs) const {
-  size_t rhs_size = rhs.size();
-  if (size() < rhs_size) return false;
-  return EqualsImpl(rhs, rhs_size);
-}
-
-inline void Cord::ChunkIterator::InitTree(cord_internal::CordRep* tree) {
-  tree = cord_internal::SkipCrcNode(tree);
-  if (tree->tag == cord_internal::BTREE) {
-    current_chunk_ = btree_reader_.Init(tree->btree());
-  } else {
-    current_leaf_ = tree;
-    current_chunk_ = cord_internal::EdgeData(tree);
-  }
-}
-
-inline Cord::ChunkIterator::ChunkIterator(cord_internal::CordRep* tree) {
-  bytes_remaining_ = tree->length;
-  InitTree(tree);
-}
-
-inline Cord::ChunkIterator::ChunkIterator(const Cord* cord) {
-  if (CordRep* tree = cord->contents_.tree()) {
-    bytes_remaining_ = tree->length;
-    InitTree(tree);
-  } else {
-    bytes_remaining_ = cord->contents_.inline_size();
-    current_chunk_ = {cord->contents_.data(), bytes_remaining_};
-  }
-}
-
-inline Cord::ChunkIterator& Cord::ChunkIterator::AdvanceBtree() {
-  current_chunk_ = btree_reader_.Next();
-  return *this;
-}
-
-inline void Cord::ChunkIterator::AdvanceBytesBtree(size_t n) {
-  assert(n >= current_chunk_.size());
-  bytes_remaining_ -= n;
-  if (bytes_remaining_) {
-    if (n == current_chunk_.size()) {
-      current_chunk_ = btree_reader_.Next();
-    } else {
-      size_t offset = btree_reader_.length() - bytes_remaining_;
-      current_chunk_ = btree_reader_.Seek(offset);
-    }
-  } else {
-    current_chunk_ = {};
-  }
-}
-
-inline Cord::ChunkIterator& Cord::ChunkIterator::operator++() {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ > 0 &&
-                        "Attempted to iterate past `end()`");
-  assert(bytes_remaining_ >= current_chunk_.size());
-  bytes_remaining_ -= current_chunk_.size();
-  if (bytes_remaining_ > 0) {
-    if (btree_reader_) {
-      return AdvanceBtree();
-    } else {
-      assert(!current_chunk_.empty());  // Called on invalid iterator.
-    }
-    current_chunk_ = {};
-  }
-  return *this;
-}
-
-inline Cord::ChunkIterator Cord::ChunkIterator::operator++(int) {
-  ChunkIterator tmp(*this);
-  operator++();
-  return tmp;
-}
-
-inline bool Cord::ChunkIterator::operator==(const ChunkIterator& other) const {
-  return bytes_remaining_ == other.bytes_remaining_;
-}
-
-inline bool Cord::ChunkIterator::operator!=(const ChunkIterator& other) const {
-  return !(*this == other);
-}
-
-inline Cord::ChunkIterator::reference Cord::ChunkIterator::operator*() const {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
-  return current_chunk_;
-}
-
-inline Cord::ChunkIterator::pointer Cord::ChunkIterator::operator->() const {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
-  return &current_chunk_;
-}
-
-inline void Cord::ChunkIterator::RemoveChunkPrefix(size_t n) {
-  assert(n < current_chunk_.size());
-  current_chunk_.remove_prefix(n);
-  bytes_remaining_ -= n;
-}
-
-inline void Cord::ChunkIterator::AdvanceBytes(size_t n) {
-  assert(bytes_remaining_ >= n);
-  if (ABSL_PREDICT_TRUE(n < current_chunk_.size())) {
-    RemoveChunkPrefix(n);
-  } else if (n != 0) {
-    if (btree_reader_) {
-      AdvanceBytesBtree(n);
-    } else {
-      bytes_remaining_ = 0;
-    }
-  }
-}
-
-inline Cord::ChunkIterator Cord::chunk_begin() const {
-  return ChunkIterator(this);
-}
-
-inline Cord::ChunkIterator Cord::chunk_end() const { return ChunkIterator(); }
-
-inline Cord::ChunkIterator Cord::ChunkRange::begin() const {
-  return cord_->chunk_begin();
-}
-
-inline Cord::ChunkIterator Cord::ChunkRange::end() const {
-  return cord_->chunk_end();
-}
-
-inline Cord::ChunkRange Cord::Chunks() const { return ChunkRange(this); }
-
-inline Cord::CharIterator& Cord::CharIterator::operator++() {
-  if (ABSL_PREDICT_TRUE(chunk_iterator_->size() > 1)) {
-    chunk_iterator_.RemoveChunkPrefix(1);
-  } else {
-    ++chunk_iterator_;
-  }
-  return *this;
-}
-
-inline Cord::CharIterator Cord::CharIterator::operator++(int) {
-  CharIterator tmp(*this);
-  operator++();
-  return tmp;
-}
-
-inline bool Cord::CharIterator::operator==(const CharIterator& other) const {
-  return chunk_iterator_ == other.chunk_iterator_;
-}
-
-inline bool Cord::CharIterator::operator!=(const CharIterator& other) const {
-  return !(*this == other);
-}
-
-inline Cord::CharIterator::reference Cord::CharIterator::operator*() const {
-  return *chunk_iterator_->data();
-}
-
-inline Cord::CharIterator::pointer Cord::CharIterator::operator->() const {
-  return chunk_iterator_->data();
-}
-
-inline Cord Cord::AdvanceAndRead(CharIterator* it, size_t n_bytes) {
-  assert(it != nullptr);
-  return it->chunk_iterator_.AdvanceAndReadBytes(n_bytes);
-}
-
-inline void Cord::Advance(CharIterator* it, size_t n_bytes) {
-  assert(it != nullptr);
-  it->chunk_iterator_.AdvanceBytes(n_bytes);
-}
-
-inline absl::string_view Cord::ChunkRemaining(const CharIterator& it) {
-  return *it.chunk_iterator_;
-}
-
-inline Cord::CharIterator Cord::char_begin() const {
-  return CharIterator(this);
-}
-
-inline Cord::CharIterator Cord::char_end() const { return CharIterator(); }
-
-inline Cord::CharIterator Cord::CharRange::begin() const {
-  return cord_->char_begin();
-}
-
-inline Cord::CharIterator Cord::CharRange::end() const {
-  return cord_->char_end();
-}
-
-inline Cord::CharRange Cord::Chars() const { return CharRange(this); }
-
-inline void Cord::ForEachChunk(
-    absl::FunctionRef<void(absl::string_view)> callback) const {
-  absl::cord_internal::CordRep* rep = contents_.tree();
-  if (rep == nullptr) {
-    callback(absl::string_view(contents_.data(), contents_.size()));
-  } else {
-    return ForEachChunkAux(rep, callback);
-  }
-}
-
-// Nonmember Cord-to-Cord relational operators.
-inline bool operator==(const Cord& lhs, const Cord& rhs) {
-  if (lhs.contents_.IsSame(rhs.contents_)) return true;
-  size_t rhs_size = rhs.size();
-  if (lhs.size() != rhs_size) return false;
-  return lhs.EqualsImpl(rhs, rhs_size);
-}
-
-inline bool operator!=(const Cord& x, const Cord& y) { return !(x == y); }
-inline bool operator<(const Cord& x, const Cord& y) { return x.Compare(y) < 0; }
-inline bool operator>(const Cord& x, const Cord& y) { return x.Compare(y) > 0; }
-inline bool operator<=(const Cord& x, const Cord& y) {
-  return x.Compare(y) <= 0;
-}
-inline bool operator>=(const Cord& x, const Cord& y) {
-  return x.Compare(y) >= 0;
-}
-
-// Nonmember Cord-to-absl::string_view relational operators.
-//
-// Due to implicit conversions, these also enable comparisons of Cord with
-// with std::string, ::string, and const char*.
-inline bool operator==(const Cord& lhs, absl::string_view rhs) {
-  size_t lhs_size = lhs.size();
-  size_t rhs_size = rhs.size();
-  if (lhs_size != rhs_size) return false;
-  return lhs.EqualsImpl(rhs, rhs_size);
-}
-
-inline bool operator==(absl::string_view x, const Cord& y) { return y == x; }
-inline bool operator!=(const Cord& x, absl::string_view y) { return !(x == y); }
-inline bool operator!=(absl::string_view x, const Cord& y) { return !(x == y); }
-inline bool operator<(const Cord& x, absl::string_view y) {
-  return x.Compare(y) < 0;
-}
-inline bool operator<(absl::string_view x, const Cord& y) {
-  return y.Compare(x) > 0;
-}
-inline bool operator>(const Cord& x, absl::string_view y) { return y < x; }
-inline bool operator>(absl::string_view x, const Cord& y) { return y < x; }
-inline bool operator<=(const Cord& x, absl::string_view y) { return !(y < x); }
-inline bool operator<=(absl::string_view x, const Cord& y) { return !(y < x); }
-inline bool operator>=(const Cord& x, absl::string_view y) { return !(x < y); }
-inline bool operator>=(absl::string_view x, const Cord& y) { return !(x < y); }
-
-// Some internals exposed to test code.
-namespace strings_internal {
-class CordTestAccess {
- public:
-  static size_t FlatOverhead();
-  static size_t MaxFlatLength();
-  static size_t SizeofCordRepExternal();
-  static size_t SizeofCordRepSubstring();
-  static size_t FlatTagToLength(uint8_t tag);
-  static uint8_t LengthToTag(size_t s);
-};
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+    inline Cord::InlineRep::InlineRep(const Cord::InlineRep& src) :
+        data_(InlineData::kDefaultInit)
+    {
+        if (CordRep* tree = src.tree())
+        {
+            EmplaceTree(CordRep::Ref(tree), src.data_, CordzUpdateTracker::kConstructorCord);
+        }
+        else
+        {
+            data_ = src.data_;
+        }
+    }
+
+    inline Cord::InlineRep::InlineRep(Cord::InlineRep&& src) :
+        data_(src.data_)
+    {
+        src.ResetToEmpty();
+    }
+
+    inline Cord::InlineRep& Cord::InlineRep::operator=(const Cord::InlineRep& src)
+    {
+        if (this == &src)
+        {
+            return *this;
+        }
+        if (!is_tree() && !src.is_tree())
+        {
+            data_ = src.data_;
+            return *this;
+        }
+        AssignSlow(src);
+        return *this;
+    }
+
+    inline Cord::InlineRep& Cord::InlineRep::operator=(
+        Cord::InlineRep&& src
+    ) noexcept
+    {
+        if (is_tree())
+        {
+            UnrefTree();
+        }
+        data_ = src.data_;
+        src.ResetToEmpty();
+        return *this;
+    }
+
+    inline void Cord::InlineRep::Swap(Cord::InlineRep* rhs)
+    {
+        if (rhs == this)
+        {
+            return;
+        }
+        std::swap(data_, rhs->data_);
+    }
+
+    inline const char* Cord::InlineRep::data() const
+    {
+        return is_tree() ? nullptr : data_.as_chars();
+    }
+
+    inline const char* Cord::InlineRep::as_chars() const
+    {
+        assert(!data_.is_tree());
+        return data_.as_chars();
+    }
+
+    inline absl::cord_internal::CordRep* Cord::InlineRep::as_tree() const
+    {
+        assert(data_.is_tree());
+        return data_.as_tree();
+    }
+
+    inline absl::cord_internal::CordRep* Cord::InlineRep::tree() const
+    {
+        if (is_tree())
+        {
+            return as_tree();
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+
+    inline bool Cord::InlineRep::empty() const
+    {
+        return data_.is_empty();
+    }
+
+    inline size_t Cord::InlineRep::size() const
+    {
+        return is_tree() ? as_tree()->length : inline_size();
+    }
+
+    inline cord_internal::CordRepFlat* Cord::InlineRep::MakeFlatWithExtraCapacity(
+        size_t extra
+    )
+    {
+        static_assert(cord_internal::kMinFlatLength >= sizeof(data_), "");
+        size_t len = data_.inline_size();
+        auto* result = CordRepFlat::New(len + extra);
+        result->length = len;
+        memcpy(result->Data(), data_.as_chars(), sizeof(data_));
+        return result;
+    }
+
+    inline void Cord::InlineRep::EmplaceTree(CordRep* rep, MethodIdentifier method)
+    {
+        assert(rep);
+        data_.make_tree(rep);
+        CordzInfo::MaybeTrackCord(data_, method);
+    }
+
+    inline void Cord::InlineRep::EmplaceTree(CordRep* rep, const InlineData& parent, MethodIdentifier method)
+    {
+        data_.make_tree(rep);
+        CordzInfo::MaybeTrackCord(data_, parent, method);
+    }
+
+    inline void Cord::InlineRep::SetTree(CordRep* rep, const CordzUpdateScope& scope)
+    {
+        assert(rep);
+        assert(data_.is_tree());
+        data_.set_tree(rep);
+        scope.SetCordRep(rep);
+    }
+
+    inline void Cord::InlineRep::SetTreeOrEmpty(CordRep* rep, const CordzUpdateScope& scope)
+    {
+        assert(data_.is_tree());
+        if (rep)
+        {
+            data_.set_tree(rep);
+        }
+        else
+        {
+            data_ = {};
+        }
+        scope.SetCordRep(rep);
+    }
+
+    inline void Cord::InlineRep::CommitTree(const CordRep* old_rep, CordRep* rep, const CordzUpdateScope& scope, MethodIdentifier method)
+    {
+        if (old_rep)
+        {
+            SetTree(rep, scope);
+        }
+        else
+        {
+            EmplaceTree(rep, method);
+        }
+    }
+
+    inline absl::cord_internal::CordRep* Cord::InlineRep::clear()
+    {
+        if (is_tree())
+        {
+            CordzInfo::MaybeUntrackCord(cordz_info());
+        }
+        absl::cord_internal::CordRep* result = tree();
+        ResetToEmpty();
+        return result;
+    }
+
+    inline void Cord::InlineRep::CopyToArray(char* dst) const
+    {
+        assert(!is_tree());
+        size_t n = inline_size();
+        assert(n != 0);
+        cord_internal::SmallMemmove(dst, data_.as_chars(), n);
+    }
+
+    constexpr inline Cord::Cord() noexcept
+    {
+    }
+
+    inline Cord::Cord(absl::string_view src) :
+        Cord(src, CordzUpdateTracker::kConstructorString)
+    {
+    }
+
+    template<typename T>
+    constexpr Cord::Cord(strings_internal::StringConstant<T>) :
+        contents_(strings_internal::StringConstant<T>::value.size() <= cord_internal::kMaxInline ? cord_internal::InlineData(strings_internal::StringConstant<T>::value) : cord_internal::InlineData(&cord_internal::ConstInitExternalStorage<strings_internal::StringConstant<T>>::value))
+    {
+    }
+
+    inline Cord& Cord::operator=(const Cord& x)
+    {
+        contents_ = x.contents_;
+        return *this;
+    }
+
+    template<typename T, Cord::EnableIfString<T>>
+    Cord& Cord::operator=(T&& src)
+    {
+        if (src.size() <= cord_internal::kMaxBytesToCopy)
+        {
+            return operator=(absl::string_view(src));
+        }
+        else
+        {
+            return AssignLargeString(std::forward<T>(src));
+        }
+    }
+
+    inline Cord::Cord(const Cord& src) :
+        contents_(src.contents_)
+    {
+    }
+
+    inline Cord::Cord(Cord&& src) noexcept :
+        contents_(std::move(src.contents_))
+    {
+    }
+
+    inline void Cord::swap(Cord& other) noexcept
+    {
+        contents_.Swap(&other.contents_);
+    }
+
+    inline Cord& Cord::operator=(Cord&& x) noexcept
+    {
+        contents_ = std::move(x.contents_);
+        return *this;
+    }
+
+    extern template Cord::Cord(std::string&& src);
+
+    inline size_t Cord::size() const
+    {
+        // Length is 1st field in str.rep_
+        return contents_.size();
+    }
+
+    inline bool Cord::empty() const
+    {
+        return contents_.empty();
+    }
+
+    inline size_t Cord::EstimatedMemoryUsage(
+        CordMemoryAccounting accounting_method
+    ) const
+    {
+        size_t result = sizeof(Cord);
+        if (const absl::cord_internal::CordRep* rep = contents_.tree())
+        {
+            if (accounting_method == CordMemoryAccounting::kFairShare)
+            {
+                result += cord_internal::GetEstimatedFairShareMemoryUsage(rep);
+            }
+            else
+            {
+                result += cord_internal::GetEstimatedMemoryUsage(rep);
+            }
+        }
+        return result;
+    }
+
+    inline absl::optional<absl::string_view> Cord::TryFlat() const
+    {
+        absl::cord_internal::CordRep* rep = contents_.tree();
+        if (rep == nullptr)
+        {
+            return absl::string_view(contents_.data(), contents_.size());
+        }
+        absl::string_view fragment;
+        if (GetFlatAux(rep, &fragment))
+        {
+            return fragment;
+        }
+        return absl::nullopt;
+    }
+
+    inline absl::string_view Cord::Flatten()
+    {
+        absl::cord_internal::CordRep* rep = contents_.tree();
+        if (rep == nullptr)
+        {
+            return absl::string_view(contents_.data(), contents_.size());
+        }
+        else
+        {
+            absl::string_view already_flat_contents;
+            if (GetFlatAux(rep, &already_flat_contents))
+            {
+                return already_flat_contents;
+            }
+        }
+        return FlattenSlowPath();
+    }
+
+    inline void Cord::Append(absl::string_view src)
+    {
+        contents_.AppendArray(src, CordzUpdateTracker::kAppendString);
+    }
+
+    inline void Cord::Prepend(absl::string_view src)
+    {
+        PrependArray(src, CordzUpdateTracker::kPrependString);
+    }
+
+    inline void Cord::Append(CordBuffer buffer)
+    {
+        if (ABSL_PREDICT_FALSE(buffer.length() == 0))
+            return;
+        absl::string_view short_value;
+        if (CordRep* rep = buffer.ConsumeValue(short_value))
+        {
+            contents_.AppendTree(rep, CordzUpdateTracker::kAppendCordBuffer);
+        }
+        else
+        {
+            AppendPrecise(short_value, CordzUpdateTracker::kAppendCordBuffer);
+        }
+    }
+
+    inline void Cord::Prepend(CordBuffer buffer)
+    {
+        if (ABSL_PREDICT_FALSE(buffer.length() == 0))
+            return;
+        absl::string_view short_value;
+        if (CordRep* rep = buffer.ConsumeValue(short_value))
+        {
+            contents_.PrependTree(rep, CordzUpdateTracker::kPrependCordBuffer);
+        }
+        else
+        {
+            PrependPrecise(short_value, CordzUpdateTracker::kPrependCordBuffer);
+        }
+    }
+
+    inline CordBuffer Cord::GetAppendBuffer(size_t capacity, size_t min_capacity)
+    {
+        if (empty())
+            return CordBuffer::CreateWithDefaultLimit(capacity);
+        return GetAppendBufferSlowPath(capacity, min_capacity);
+    }
+
+    extern template void Cord::Append(std::string&& src);
+    extern template void Cord::Prepend(std::string&& src);
+
+    inline int Cord::Compare(const Cord& rhs) const
+    {
+        if (!contents_.is_tree() && !rhs.contents_.is_tree())
+        {
+            return contents_.BitwiseCompare(rhs.contents_);
+        }
+
+        return CompareImpl(rhs);
+    }
+
+    // Does 'this' cord start/end with rhs
+    inline bool Cord::StartsWith(const Cord& rhs) const
+    {
+        if (contents_.IsSame(rhs.contents_))
+            return true;
+        size_t rhs_size = rhs.size();
+        if (size() < rhs_size)
+            return false;
+        return EqualsImpl(rhs, rhs_size);
+    }
+
+    inline bool Cord::StartsWith(absl::string_view rhs) const
+    {
+        size_t rhs_size = rhs.size();
+        if (size() < rhs_size)
+            return false;
+        return EqualsImpl(rhs, rhs_size);
+    }
+
+    inline void Cord::ChunkIterator::InitTree(cord_internal::CordRep* tree)
+    {
+        tree = cord_internal::SkipCrcNode(tree);
+        if (tree->tag == cord_internal::BTREE)
+        {
+            current_chunk_ = btree_reader_.Init(tree->btree());
+        }
+        else
+        {
+            current_leaf_ = tree;
+            current_chunk_ = cord_internal::EdgeData(tree);
+        }
+    }
+
+    inline Cord::ChunkIterator::ChunkIterator(cord_internal::CordRep* tree)
+    {
+        bytes_remaining_ = tree->length;
+        InitTree(tree);
+    }
+
+    inline Cord::ChunkIterator::ChunkIterator(const Cord* cord)
+    {
+        if (CordRep* tree = cord->contents_.tree())
+        {
+            bytes_remaining_ = tree->length;
+            InitTree(tree);
+        }
+        else
+        {
+            bytes_remaining_ = cord->contents_.inline_size();
+            current_chunk_ = {cord->contents_.data(), bytes_remaining_};
+        }
+    }
+
+    inline Cord::ChunkIterator& Cord::ChunkIterator::AdvanceBtree()
+    {
+        current_chunk_ = btree_reader_.Next();
+        return *this;
+    }
+
+    inline void Cord::ChunkIterator::AdvanceBytesBtree(size_t n)
+    {
+        assert(n >= current_chunk_.size());
+        bytes_remaining_ -= n;
+        if (bytes_remaining_)
+        {
+            if (n == current_chunk_.size())
+            {
+                current_chunk_ = btree_reader_.Next();
+            }
+            else
+            {
+                size_t offset = btree_reader_.length() - bytes_remaining_;
+                current_chunk_ = btree_reader_.Seek(offset);
+            }
+        }
+        else
+        {
+            current_chunk_ = {};
+        }
+    }
+
+    inline Cord::ChunkIterator& Cord::ChunkIterator::operator++()
+    {
+        ABSL_HARDENING_ASSERT(bytes_remaining_ > 0 && "Attempted to iterate past `end()`");
+        assert(bytes_remaining_ >= current_chunk_.size());
+        bytes_remaining_ -= current_chunk_.size();
+        if (bytes_remaining_ > 0)
+        {
+            if (btree_reader_)
+            {
+                return AdvanceBtree();
+            }
+            else
+            {
+                assert(!current_chunk_.empty());  // Called on invalid iterator.
+            }
+            current_chunk_ = {};
+        }
+        return *this;
+    }
+
+    inline Cord::ChunkIterator Cord::ChunkIterator::operator++(int)
+    {
+        ChunkIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
+
+    inline bool Cord::ChunkIterator::operator==(const ChunkIterator& other) const
+    {
+        return bytes_remaining_ == other.bytes_remaining_;
+    }
+
+    inline bool Cord::ChunkIterator::operator!=(const ChunkIterator& other) const
+    {
+        return !(*this == other);
+    }
+
+    inline Cord::ChunkIterator::reference Cord::ChunkIterator::operator*() const
+    {
+        ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
+        return current_chunk_;
+    }
+
+    inline Cord::ChunkIterator::pointer Cord::ChunkIterator::operator->() const
+    {
+        ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
+        return &current_chunk_;
+    }
+
+    inline void Cord::ChunkIterator::RemoveChunkPrefix(size_t n)
+    {
+        assert(n < current_chunk_.size());
+        current_chunk_.remove_prefix(n);
+        bytes_remaining_ -= n;
+    }
+
+    inline void Cord::ChunkIterator::AdvanceBytes(size_t n)
+    {
+        assert(bytes_remaining_ >= n);
+        if (ABSL_PREDICT_TRUE(n < current_chunk_.size()))
+        {
+            RemoveChunkPrefix(n);
+        }
+        else if (n != 0)
+        {
+            if (btree_reader_)
+            {
+                AdvanceBytesBtree(n);
+            }
+            else
+            {
+                bytes_remaining_ = 0;
+            }
+        }
+    }
+
+    inline Cord::ChunkIterator Cord::chunk_begin() const
+    {
+        return ChunkIterator(this);
+    }
+
+    inline Cord::ChunkIterator Cord::chunk_end() const
+    {
+        return ChunkIterator();
+    }
+
+    inline Cord::ChunkIterator Cord::ChunkRange::begin() const
+    {
+        return cord_->chunk_begin();
+    }
+
+    inline Cord::ChunkIterator Cord::ChunkRange::end() const
+    {
+        return cord_->chunk_end();
+    }
+
+    inline Cord::ChunkRange Cord::Chunks() const
+    {
+        return ChunkRange(this);
+    }
+
+    inline Cord::CharIterator& Cord::CharIterator::operator++()
+    {
+        if (ABSL_PREDICT_TRUE(chunk_iterator_->size() > 1))
+        {
+            chunk_iterator_.RemoveChunkPrefix(1);
+        }
+        else
+        {
+            ++chunk_iterator_;
+        }
+        return *this;
+    }
+
+    inline Cord::CharIterator Cord::CharIterator::operator++(int)
+    {
+        CharIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
+
+    inline bool Cord::CharIterator::operator==(const CharIterator& other) const
+    {
+        return chunk_iterator_ == other.chunk_iterator_;
+    }
+
+    inline bool Cord::CharIterator::operator!=(const CharIterator& other) const
+    {
+        return !(*this == other);
+    }
+
+    inline Cord::CharIterator::reference Cord::CharIterator::operator*() const
+    {
+        return *chunk_iterator_->data();
+    }
+
+    inline Cord::CharIterator::pointer Cord::CharIterator::operator->() const
+    {
+        return chunk_iterator_->data();
+    }
+
+    inline Cord Cord::AdvanceAndRead(CharIterator* it, size_t n_bytes)
+    {
+        assert(it != nullptr);
+        return it->chunk_iterator_.AdvanceAndReadBytes(n_bytes);
+    }
+
+    inline void Cord::Advance(CharIterator* it, size_t n_bytes)
+    {
+        assert(it != nullptr);
+        it->chunk_iterator_.AdvanceBytes(n_bytes);
+    }
+
+    inline absl::string_view Cord::ChunkRemaining(const CharIterator& it)
+    {
+        return *it.chunk_iterator_;
+    }
+
+    inline Cord::CharIterator Cord::char_begin() const
+    {
+        return CharIterator(this);
+    }
+
+    inline Cord::CharIterator Cord::char_end() const
+    {
+        return CharIterator();
+    }
+
+    inline Cord::CharIterator Cord::CharRange::begin() const
+    {
+        return cord_->char_begin();
+    }
+
+    inline Cord::CharIterator Cord::CharRange::end() const
+    {
+        return cord_->char_end();
+    }
+
+    inline Cord::CharRange Cord::Chars() const
+    {
+        return CharRange(this);
+    }
+
+    inline void Cord::ForEachChunk(
+        absl::FunctionRef<void(absl::string_view)> callback
+    ) const
+    {
+        absl::cord_internal::CordRep* rep = contents_.tree();
+        if (rep == nullptr)
+        {
+            callback(absl::string_view(contents_.data(), contents_.size()));
+        }
+        else
+        {
+            return ForEachChunkAux(rep, callback);
+        }
+    }
+
+    // Nonmember Cord-to-Cord relational operators.
+    inline bool operator==(const Cord& lhs, const Cord& rhs)
+    {
+        if (lhs.contents_.IsSame(rhs.contents_))
+            return true;
+        size_t rhs_size = rhs.size();
+        if (lhs.size() != rhs_size)
+            return false;
+        return lhs.EqualsImpl(rhs, rhs_size);
+    }
+
+    inline bool operator!=(const Cord& x, const Cord& y)
+    {
+        return !(x == y);
+    }
+    inline bool operator<(const Cord& x, const Cord& y)
+    {
+        return x.Compare(y) < 0;
+    }
+    inline bool operator>(const Cord& x, const Cord& y)
+    {
+        return x.Compare(y) > 0;
+    }
+    inline bool operator<=(const Cord& x, const Cord& y)
+    {
+        return x.Compare(y) <= 0;
+    }
+    inline bool operator>=(const Cord& x, const Cord& y)
+    {
+        return x.Compare(y) >= 0;
+    }
+
+    // Nonmember Cord-to-absl::string_view relational operators.
+    //
+    // Due to implicit conversions, these also enable comparisons of Cord with
+    // with std::string, ::string, and const char*.
+    inline bool operator==(const Cord& lhs, absl::string_view rhs)
+    {
+        size_t lhs_size = lhs.size();
+        size_t rhs_size = rhs.size();
+        if (lhs_size != rhs_size)
+            return false;
+        return lhs.EqualsImpl(rhs, rhs_size);
+    }
+
+    inline bool operator==(absl::string_view x, const Cord& y)
+    {
+        return y == x;
+    }
+    inline bool operator!=(const Cord& x, absl::string_view y)
+    {
+        return !(x == y);
+    }
+    inline bool operator!=(absl::string_view x, const Cord& y)
+    {
+        return !(x == y);
+    }
+    inline bool operator<(const Cord& x, absl::string_view y)
+    {
+        return x.Compare(y) < 0;
+    }
+    inline bool operator<(absl::string_view x, const Cord& y)
+    {
+        return y.Compare(x) > 0;
+    }
+    inline bool operator>(const Cord& x, absl::string_view y)
+    {
+        return y < x;
+    }
+    inline bool operator>(absl::string_view x, const Cord& y)
+    {
+        return y < x;
+    }
+    inline bool operator<=(const Cord& x, absl::string_view y)
+    {
+        return !(y < x);
+    }
+    inline bool operator<=(absl::string_view x, const Cord& y)
+    {
+        return !(y < x);
+    }
+    inline bool operator>=(const Cord& x, absl::string_view y)
+    {
+        return !(x < y);
+    }
+    inline bool operator>=(absl::string_view x, const Cord& y)
+    {
+        return !(x < y);
+    }
+
+    // Some internals exposed to test code.
+    namespace strings_internal
+    {
+        class CordTestAccess
+        {
+        public:
+            static size_t FlatOverhead();
+            static size_t MaxFlatLength();
+            static size_t SizeofCordRepExternal();
+            static size_t SizeofCordRepSubstring();
+            static size_t FlatTagToLength(uint8_t tag);
+            static uint8_t LengthToTag(size_t s);
+        };
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CORD_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cord_analysis.h b/CAPI/cpp/grpc/include/absl/strings/cord_analysis.h
index 7041ad1..49b4a55 100644
--- a/CAPI/cpp/grpc/include/absl/strings/cord_analysis.h
+++ b/CAPI/cpp/grpc/include/absl/strings/cord_analysis.h
@@ -21,24 +21,25 @@
 #include "absl/base/config.h"
 #include "absl/strings/internal/cord_internal.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Returns the *approximate* number of bytes held in full or in part by this
-// Cord (which may not remain the same between invocations). Cords that share
-// memory could each be "charged" independently for the same shared memory.
-size_t GetEstimatedMemoryUsage(const CordRep* rep);
-
-// Returns the *approximate* number of bytes held in full or in part by this
-// CordRep weighted by the sharing ratio of that data. For example, if some data
-// edge is shared by 4 different Cords, then each cord is attribute 1/4th of
-// the total memory usage as a 'fair share' of the total memory usage.
-size_t GetEstimatedFairShareMemoryUsage(const CordRep* rep);
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // Returns the *approximate* number of bytes held in full or in part by this
+        // Cord (which may not remain the same between invocations). Cords that share
+        // memory could each be "charged" independently for the same shared memory.
+        size_t GetEstimatedMemoryUsage(const CordRep* rep);
+
+        // Returns the *approximate* number of bytes held in full or in part by this
+        // CordRep weighted by the sharing ratio of that data. For example, if some data
+        // edge is shared by 4 different Cords, then each cord is attribute 1/4th of
+        // the total memory usage as a 'fair share' of the total memory usage.
+        size_t GetEstimatedFairShareMemoryUsage(const CordRep* rep);
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
-
 #endif  // ABSL_STRINGS_CORD_ANALYSIS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cord_buffer.h b/CAPI/cpp/grpc/include/absl/strings/cord_buffer.h
index 56a6ce6..ec18548 100644
--- a/CAPI/cpp/grpc/include/absl/strings/cord_buffer.h
+++ b/CAPI/cpp/grpc/include/absl/strings/cord_buffer.h
@@ -38,535 +38,607 @@
 #include "absl/strings/internal/cord_rep_flat.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class Cord;
+    class CordBufferTestPeer;
+
+    // CordBuffer
+    //
+    // CordBuffer manages memory buffers for purposes such as zero-copy APIs as well
+    // as applications building cords with large data requiring granular control
+    // over the allocation and size of cord data. For example, a function creating
+    // a cord of random data could use a CordBuffer as follows:
+    //
+    //   absl::Cord CreateRandomCord(size_t length) {
+    //     absl::Cord cord;
+    //     while (length > 0) {
+    //       CordBuffer buffer = CordBuffer::CreateWithDefaultLimit(length);
+    //       absl::Span<char> data = buffer.available_up_to(length);
+    //       FillRandomValues(data.data(), data.size());
+    //       buffer.IncreaseLengthBy(data.size());
+    //       cord.Append(std::move(buffer));
+    //       length -= data.size();
+    //     }
+    //     return cord;
+    //   }
+    //
+    // CordBuffer instances are by default limited to a capacity of `kDefaultLimit`
+    // bytes. `kDefaultLimit` is currently just under 4KiB, but this default may
+    // change in the future and/or for specific architectures. The default limit is
+    // aimed to provide a good trade-off between performance and memory overhead.
+    // Smaller buffers typically incur more compute cost while larger buffers are
+    // more CPU efficient but create significant memory overhead because of such
+    // allocations being less granular. Using larger buffers may also increase the
+    // risk of memory fragmentation.
+    //
+    // Applications create a buffer using one of the `CreateWithDefaultLimit()` or
+    // `CreateWithCustomLimit()` methods. The returned instance will have a non-zero
+    // capacity and a zero length. Applications use the `data()` method to set the
+    // contents of the managed memory, and once done filling the buffer, use the
+    // `IncreaseLengthBy()` or 'SetLength()' method to specify the length of the
+    // initialized data before adding the buffer to a Cord.
+    //
+    // The `CreateWithCustomLimit()` method is intended for applications needing
+    // larger buffers than the default memory limit, allowing the allocation of up
+    // to a capacity of `kCustomLimit` bytes minus some minimum internal overhead.
+    // The usage of `CreateWithCustomLimit()` should be limited to only those use
+    // cases where the distribution of the input is relatively well known, and/or
+    // where the trade-off between the efficiency gains outweigh the risk of memory
+    // fragmentation. See the documentation for `CreateWithCustomLimit()` for more
+    // information on using larger custom limits.
+    //
+    // The capacity of a `CordBuffer` returned by one of the `Create` methods may
+    // be larger than the requested capacity due to rounding, alignment and
+    // granularity of the memory allocator. Applications should use the `capacity`
+    // method to obtain the effective capacity of the returned instance as
+    // demonstrated in the provided example above.
+    //
+    // CordBuffer is a move-only class. All references into the managed memory are
+    // invalidated when an instance is moved into either another CordBuffer instance
+    // or a Cord. Writing to a location obtained by a previous call to `data()`
+    // after an instance was moved will lead to undefined behavior.
+    //
+    // A `moved from` CordBuffer instance will have a valid, but empty state.
+    // CordBuffer is thread compatible.
+    class CordBuffer
+    {
+    public:
+        // kDefaultLimit
+        //
+        // Default capacity limits of allocated CordBuffers.
+        // See the class comments for more information on allocation limits.
+        static constexpr size_t kDefaultLimit = cord_internal::kMaxFlatLength;
+
+        // kCustomLimit
+        //
+        // Maximum size for CreateWithCustomLimit() allocated buffers.
+        // Note that the effective capacity may be slightly less
+        // because of internal overhead of internal cord buffers.
+        static constexpr size_t kCustomLimit = 64U << 10;
+
+        // Constructors, Destructors and Assignment Operators
+
+        // Creates an empty CordBuffer.
+        CordBuffer() = default;
+
+        // Destroys this CordBuffer instance and, if not empty, releases any memory
+        // managed by this instance, invalidating previously returned references.
+        ~CordBuffer();
+
+        // CordBuffer is move-only
+        CordBuffer(CordBuffer&& rhs) noexcept;
+        CordBuffer& operator=(CordBuffer&&) noexcept;
+        CordBuffer(const CordBuffer&) = delete;
+        CordBuffer& operator=(const CordBuffer&) = delete;
+
+        // CordBuffer::MaximumPayload()
+        //
+        // Returns the guaranteed maximum payload for a CordBuffer returned by the
+        // `CreateWithDefaultLimit()` method. While small, each internal buffer inside
+        // a Cord incurs an overhead to manage the length, type and reference count
+        // for the buffer managed inside the cord tree. Applications can use this
+        // method to get approximate number of buffers required for a given byte
+        // size, etc.
+        //
+        // For example:
+        //   const size_t payload = absl::CordBuffer::MaximumPayload();
+        //   const size_t buffer_count = (total_size + payload - 1) / payload;
+        //   buffers.reserve(buffer_count);
+        static constexpr size_t MaximumPayload();
+
+        // Overload to the above `MaximumPayload()` except that it returns the
+        // maximum payload for a CordBuffer returned by the `CreateWithCustomLimit()`
+        // method given the provided `block_size`.
+        static constexpr size_t MaximumPayload(size_t block_size);
+
+        // CordBuffer::CreateWithDefaultLimit()
+        //
+        // Creates a CordBuffer instance of the desired `capacity`, capped at the
+        // default limit `kDefaultLimit`. The returned buffer has a guaranteed
+        // capacity of at least `min(kDefaultLimit, capacity)`. See the class comments
+        // for more information on buffer capacities and intended usage.
+        static CordBuffer CreateWithDefaultLimit(size_t capacity);
+
+        // CordBuffer::CreateWithCustomLimit()
+        //
+        // Creates a CordBuffer instance of the desired `capacity` rounded to an
+        // appropriate power of 2 size less than, or equal to `block_size`.
+        // Requires `block_size` to be a power of 2.
+        //
+        // If `capacity` is less than or equal to `kDefaultLimit`, then this method
+        // behaves identical to `CreateWithDefaultLimit`, which means that the caller
+        // is guaranteed to get a buffer of at least the requested capacity.
+        //
+        // If `capacity` is greater than or equal to `block_size`, then this method
+        // returns a buffer with an `allocated size` of `block_size` bytes. Otherwise,
+        // this methods returns a buffer with a suitable smaller power of 2 block size
+        // to satisfy the request. The actual size depends on a number of factors, and
+        // is typically (but not necessarily) the highest or second highest power of 2
+        // value less than or equal to `capacity`.
+        //
+        // The 'allocated size' includes a small amount of overhead required for
+        // internal state, which is currently 13 bytes on 64-bit platforms. For
+        // example: a buffer created with `block_size` and `capacity' set to 8KiB
+        // will have an allocated size of 8KiB, and an effective internal `capacity`
+        // of 8KiB - 13 = 8179 bytes.
+        //
+        // To demonstrate this in practice, let's assume we want to read data from
+        // somewhat larger files using approximately 64KiB buffers:
+        //
+        //   absl::Cord ReadFromFile(int fd, size_t n) {
+        //     absl::Cord cord;
+        //     while (n > 0) {
+        //       CordBuffer buffer = CordBuffer::CreateWithCustomLimit(64 << 10, n);
+        //       absl::Span<char> data = buffer.available_up_to(n);
+        //       ReadFileDataOrDie(fd, data.data(), data.size());
+        //       buffer.IncreaseLengthBy(data.size());
+        //       cord.Append(std::move(buffer));
+        //       n -= data.size();
+        //     }
+        //     return cord;
+        //   }
+        //
+        // If we'd use this function to read a file of 659KiB, we may get the
+        // following pattern of allocated cord buffer sizes:
+        //
+        //   CreateWithCustomLimit(64KiB, 674816) --> ~64KiB (65523)
+        //   CreateWithCustomLimit(64KiB, 674816) --> ~64KiB (65523)
+        //   ...
+        //   CreateWithCustomLimit(64KiB,  19586) --> ~16KiB (16371)
+        //   CreateWithCustomLimit(64KiB,   3215) -->   3215 (at least 3215)
+        //
+        // The reason the method returns a 16K buffer instead of a roughly 19K buffer
+        // is to reduce memory overhead and fragmentation risks. Using carefully
+        // chosen power of 2 values reduces the entropy of allocated memory sizes.
+        //
+        // Additionally, let's assume we'd use the above function on files that are
+        // generally smaller than 64K. If we'd use 'precise' sized buffers for such
+        // files, than we'd get a very wide distribution of allocated memory sizes
+        // rounded to 4K page sizes, and we'd end up with a lot of unused capacity.
+        //
+        // In general, application should only use custom sizes if the data they are
+        // consuming or storing is expected to be many times the chosen block size,
+        // and be based on objective data and performance metrics. For example, a
+        // compress function may work faster and consume less CPU when using larger
+        // buffers. Such an application should pick a size offering a reasonable
+        // trade-off between expected data size, compute savings with larger buffers,
+        // and the cost or fragmentation effect of larger buffers.
+        // Applications must pick a reasonable spot on that curve, and make sure their
+        // data meets their expectations in size distributions such as "mostly large".
+        static CordBuffer CreateWithCustomLimit(size_t block_size, size_t capacity);
+
+        // CordBuffer::available()
+        //
+        // Returns the span delineating the available capacity in this buffer
+        // which is defined as `{ data() + length(), capacity() - length() }`.
+        absl::Span<char> available();
+
+        // CordBuffer::available_up_to()
+        //
+        // Returns the span delineating the available capacity in this buffer limited
+        // to `size` bytes. This is equivalent to `available().subspan(0, size)`.
+        absl::Span<char> available_up_to(size_t size);
+
+        // CordBuffer::data()
+        //
+        // Returns a non-null reference to the data managed by this instance.
+        // Applications are allowed to write up to `capacity` bytes of instance data.
+        // CordBuffer data is uninitialized by default. Reading data from an instance
+        // that has not yet been initialized will lead to undefined behavior.
+        char* data();
+        const char* data() const;
+
+        // CordBuffer::length()
+        //
+        // Returns the length of this instance. The default length of a CordBuffer is
+        // 0, indicating an 'empty' CordBuffer. Applications must specify the length
+        // of the data in a CordBuffer before adding it to a Cord.
+        size_t length() const;
+
+        // CordBuffer::capacity()
+        //
+        // Returns the capacity of this instance. All instances have a non-zero
+        // capacity: default and `moved from` instances have a small internal buffer.
+        size_t capacity() const;
+
+        // CordBuffer::IncreaseLengthBy()
+        //
+        // Increases the length of this buffer by the specified 'n' bytes.
+        // Applications must make sure all data in this buffer up to the new length
+        // has been initialized before adding a CordBuffer to a Cord: failure to do so
+        // will lead to undefined behavior.  Requires `length() + n <= capacity()`.
+        // Typically, applications will use 'available_up_to()` to get a span of the
+        // desired capacity, and use `span.size()` to increase the length as in:
+        //   absl::Span<char> span = buffer.available_up_to(desired);
+        //   buffer.IncreaseLengthBy(span.size());
+        //   memcpy(span.data(), src, span.size());
+        //   etc...
+        void IncreaseLengthBy(size_t n);
+
+        // CordBuffer::SetLength()
+        //
+        // Sets the data length of this instance. Applications must make sure all data
+        // of the specified length has been initialized before adding a CordBuffer to
+        // a Cord: failure to do so will lead to undefined behavior.
+        // Setting the length to a small value or zero does not release any memory
+        // held by this CordBuffer instance. Requires `length <= capacity()`.
+        // Applications should preferably use the `IncreaseLengthBy()` method above
+        // in combination with the 'available()` or `available_up_to()` methods.
+        void SetLength(size_t length);
+
+    private:
+        // Make sure we don't accidentally over promise.
+        static_assert(kCustomLimit <= cord_internal::kMaxLargeFlatSize, "");
+
+        // Assume the cost of an 'uprounded' allocation to CeilPow2(size) versus
+        // the cost of allocating at least 1 extra flat <= 4KB:
+        // - Flat overhead = 13 bytes
+        // - Btree amortized cost / node =~ 13 bytes
+        // - 64 byte granularity of tcmalloc at 4K =~ 32 byte average
+        // CPU cost and efficiency requires we should at least 'save' something by
+        // splitting, as a poor man's measure, we say the slop needs to be
+        // at least double the cost offset to make it worth splitting: ~128 bytes.
+        static constexpr size_t kMaxPageSlop = 128;
+
+        // Overhead for allocation a flat.
+        static constexpr size_t kOverhead = cord_internal::kFlatOverhead;
+
+        using CordRepFlat = cord_internal::CordRepFlat;
+
+        // `Rep` is the internal data representation of a CordBuffer. The internal
+        // representation has an internal small size optimization similar to
+        // std::string (SSO).
+        struct Rep
+        {
+            // Inline SSO size of a CordBuffer
+            static constexpr size_t kInlineCapacity = sizeof(intptr_t) * 2 - 1;
+
+            // Creates a default instance with kInlineCapacity.
+            Rep() :
+                short_rep{}
+            {
+            }
+
+            // Creates an instance managing an allocated non zero CordRep.
+            explicit Rep(cord_internal::CordRepFlat* rep) :
+                long_rep{rep}
+            {
+                assert(rep != nullptr);
+            }
+
+            // Returns true if this instance manages the SSO internal buffer.
+            bool is_short() const
+            {
+                constexpr size_t offset = offsetof(Short, raw_size);
+                return (reinterpret_cast<const char*>(this)[offset] & 1) != 0;
+            }
+
+            // Returns the available area of the internal SSO data
+            absl::Span<char> short_available()
+            {
+                assert(is_short());
+                const size_t length = (short_rep.raw_size >> 1);
+                return absl::Span<char>(short_rep.data + length, kInlineCapacity - length);
+            }
+
+            // Returns the available area of the internal SSO data
+            absl::Span<char> long_available()
+            {
+                assert(!is_short());
+                const size_t length = long_rep.rep->length;
+                return absl::Span<char>(long_rep.rep->Data() + length, long_rep.rep->Capacity() - length);
+            }
+
+            // Returns the length of the internal SSO data.
+            size_t short_length() const
+            {
+                assert(is_short());
+                return short_rep.raw_size >> 1;
+            }
+
+            // Sets the length of the internal SSO data.
+            // Disregards any previously set CordRep instance.
+            void set_short_length(size_t length)
+            {
+                short_rep.raw_size = static_cast<char>((length << 1) + 1);
+            }
+
+            // Adds `n` to the current short length.
+            void add_short_length(size_t n)
+            {
+                assert(is_short());
+                short_rep.raw_size += static_cast<char>(n << 1);
+            }
+
+            // Returns reference to the internal SSO data buffer.
+            char* data()
+            {
+                assert(is_short());
+                return short_rep.data;
+            }
+            const char* data() const
+            {
+                assert(is_short());
+                return short_rep.data;
+            }
+
+            // Returns a pointer the external CordRep managed by this instance.
+            cord_internal::CordRepFlat* rep() const
+            {
+                assert(!is_short());
+                return long_rep.rep;
+            }
+
+            // The internal representation takes advantage of the fact that allocated
+            // memory is always on an even address, and uses the least significant bit
+            // of the first or last byte (depending on endianness) as the inline size
+            // indicator overlapping with the least significant byte of the CordRep*.
+#if defined(ABSL_IS_BIG_ENDIAN)
+            struct Long
+            {
+                explicit Long(cord_internal::CordRepFlat* rep_arg) :
+                    rep(rep_arg)
+                {
+                }
+                void* padding;
+                cord_internal::CordRepFlat* rep;
+            };
+            struct Short
+            {
+                char data[sizeof(Long) - 1];
+                char raw_size = 1;
+            };
+#else
+            struct Long
+            {
+                explicit Long(cord_internal::CordRepFlat* rep_arg) :
+                    rep(rep_arg)
+                {
+                }
+                cord_internal::CordRepFlat* rep;
+                void* padding;
+            };
+            struct Short
+            {
+                char raw_size = 1;
+                char data[sizeof(Long) - 1];
+            };
+#endif
 
-class Cord;
-class CordBufferTestPeer;
+            union
+            {
+                Long long_rep;
+                Short short_rep;
+            };
+        };
+
+        // Power2 functions
+        static bool IsPow2(size_t size)
+        {
+            return absl::has_single_bit(size);
+        }
+        static size_t Log2Floor(size_t size)
+        {
+            return absl::bit_width(size) - 1;
+        }
+        static size_t Log2Ceil(size_t size)
+        {
+            return absl::bit_width(size - 1);
+        }
+
+        // Implementation of `CreateWithCustomLimit()`.
+        // This implementation allows for future memory allocation hints to
+        // be passed down into the CordRepFlat allocation function.
+        template<typename... AllocationHints>
+        static CordBuffer CreateWithCustomLimitImpl(size_t block_size, size_t capacity, AllocationHints... hints);
+
+        // Consumes the value contained in this instance and resets the instance.
+        // This method returns a non-null Cordrep* if the current instances manages a
+        // CordRep*, and resets the instance to an empty SSO instance. If the current
+        // instance is an SSO instance, then this method returns nullptr and sets
+        // `short_value` to the inlined data value. In either case, the current
+        // instance length is reset to zero.
+        // This method is intended to be used by Cord internal functions only.
+        cord_internal::CordRep* ConsumeValue(absl::string_view& short_value)
+        {
+            cord_internal::CordRep* rep = nullptr;
+            if (rep_.is_short())
+            {
+                short_value = absl::string_view(rep_.data(), rep_.short_length());
+            }
+            else
+            {
+                rep = rep_.rep();
+            }
+            rep_.set_short_length(0);
+            return rep;
+        }
+
+        // Internal constructor.
+        explicit CordBuffer(cord_internal::CordRepFlat* rep) :
+            rep_(rep)
+        {
+            assert(rep != nullptr);
+        }
+
+        Rep rep_;
+
+        friend class Cord;
+        friend class CordBufferTestPeer;
+    };
 
-// CordBuffer
-//
-// CordBuffer manages memory buffers for purposes such as zero-copy APIs as well
-// as applications building cords with large data requiring granular control
-// over the allocation and size of cord data. For example, a function creating
-// a cord of random data could use a CordBuffer as follows:
-//
-//   absl::Cord CreateRandomCord(size_t length) {
-//     absl::Cord cord;
-//     while (length > 0) {
-//       CordBuffer buffer = CordBuffer::CreateWithDefaultLimit(length);
-//       absl::Span<char> data = buffer.available_up_to(length);
-//       FillRandomValues(data.data(), data.size());
-//       buffer.IncreaseLengthBy(data.size());
-//       cord.Append(std::move(buffer));
-//       length -= data.size();
-//     }
-//     return cord;
-//   }
-//
-// CordBuffer instances are by default limited to a capacity of `kDefaultLimit`
-// bytes. `kDefaultLimit` is currently just under 4KiB, but this default may
-// change in the future and/or for specific architectures. The default limit is
-// aimed to provide a good trade-off between performance and memory overhead.
-// Smaller buffers typically incur more compute cost while larger buffers are
-// more CPU efficient but create significant memory overhead because of such
-// allocations being less granular. Using larger buffers may also increase the
-// risk of memory fragmentation.
-//
-// Applications create a buffer using one of the `CreateWithDefaultLimit()` or
-// `CreateWithCustomLimit()` methods. The returned instance will have a non-zero
-// capacity and a zero length. Applications use the `data()` method to set the
-// contents of the managed memory, and once done filling the buffer, use the
-// `IncreaseLengthBy()` or 'SetLength()' method to specify the length of the
-// initialized data before adding the buffer to a Cord.
-//
-// The `CreateWithCustomLimit()` method is intended for applications needing
-// larger buffers than the default memory limit, allowing the allocation of up
-// to a capacity of `kCustomLimit` bytes minus some minimum internal overhead.
-// The usage of `CreateWithCustomLimit()` should be limited to only those use
-// cases where the distribution of the input is relatively well known, and/or
-// where the trade-off between the efficiency gains outweigh the risk of memory
-// fragmentation. See the documentation for `CreateWithCustomLimit()` for more
-// information on using larger custom limits.
-//
-// The capacity of a `CordBuffer` returned by one of the `Create` methods may
-// be larger than the requested capacity due to rounding, alignment and
-// granularity of the memory allocator. Applications should use the `capacity`
-// method to obtain the effective capacity of the returned instance as
-// demonstrated in the provided example above.
-//
-// CordBuffer is a move-only class. All references into the managed memory are
-// invalidated when an instance is moved into either another CordBuffer instance
-// or a Cord. Writing to a location obtained by a previous call to `data()`
-// after an instance was moved will lead to undefined behavior.
-//
-// A `moved from` CordBuffer instance will have a valid, but empty state.
-// CordBuffer is thread compatible.
-class CordBuffer {
- public:
-  // kDefaultLimit
-  //
-  // Default capacity limits of allocated CordBuffers.
-  // See the class comments for more information on allocation limits.
-  static constexpr size_t kDefaultLimit = cord_internal::kMaxFlatLength;
-
-  // kCustomLimit
-  //
-  // Maximum size for CreateWithCustomLimit() allocated buffers.
-  // Note that the effective capacity may be slightly less
-  // because of internal overhead of internal cord buffers.
-  static constexpr size_t kCustomLimit = 64U << 10;
-
-  // Constructors, Destructors and Assignment Operators
-
-  // Creates an empty CordBuffer.
-  CordBuffer() = default;
-
-  // Destroys this CordBuffer instance and, if not empty, releases any memory
-  // managed by this instance, invalidating previously returned references.
-  ~CordBuffer();
-
-  // CordBuffer is move-only
-  CordBuffer(CordBuffer&& rhs) noexcept;
-  CordBuffer& operator=(CordBuffer&&) noexcept;
-  CordBuffer(const CordBuffer&) = delete;
-  CordBuffer& operator=(const CordBuffer&) = delete;
-
-  // CordBuffer::MaximumPayload()
-  //
-  // Returns the guaranteed maximum payload for a CordBuffer returned by the
-  // `CreateWithDefaultLimit()` method. While small, each internal buffer inside
-  // a Cord incurs an overhead to manage the length, type and reference count
-  // for the buffer managed inside the cord tree. Applications can use this
-  // method to get approximate number of buffers required for a given byte
-  // size, etc.
-  //
-  // For example:
-  //   const size_t payload = absl::CordBuffer::MaximumPayload();
-  //   const size_t buffer_count = (total_size + payload - 1) / payload;
-  //   buffers.reserve(buffer_count);
-  static constexpr size_t MaximumPayload();
-
-  // Overload to the above `MaximumPayload()` except that it returns the
-  // maximum payload for a CordBuffer returned by the `CreateWithCustomLimit()`
-  // method given the provided `block_size`.
-  static constexpr size_t MaximumPayload(size_t block_size);
-
-  // CordBuffer::CreateWithDefaultLimit()
-  //
-  // Creates a CordBuffer instance of the desired `capacity`, capped at the
-  // default limit `kDefaultLimit`. The returned buffer has a guaranteed
-  // capacity of at least `min(kDefaultLimit, capacity)`. See the class comments
-  // for more information on buffer capacities and intended usage.
-  static CordBuffer CreateWithDefaultLimit(size_t capacity);
-
-
-  // CordBuffer::CreateWithCustomLimit()
-  //
-  // Creates a CordBuffer instance of the desired `capacity` rounded to an
-  // appropriate power of 2 size less than, or equal to `block_size`.
-  // Requires `block_size` to be a power of 2.
-  //
-  // If `capacity` is less than or equal to `kDefaultLimit`, then this method
-  // behaves identical to `CreateWithDefaultLimit`, which means that the caller
-  // is guaranteed to get a buffer of at least the requested capacity.
-  //
-  // If `capacity` is greater than or equal to `block_size`, then this method
-  // returns a buffer with an `allocated size` of `block_size` bytes. Otherwise,
-  // this methods returns a buffer with a suitable smaller power of 2 block size
-  // to satisfy the request. The actual size depends on a number of factors, and
-  // is typically (but not necessarily) the highest or second highest power of 2
-  // value less than or equal to `capacity`.
-  //
-  // The 'allocated size' includes a small amount of overhead required for
-  // internal state, which is currently 13 bytes on 64-bit platforms. For
-  // example: a buffer created with `block_size` and `capacity' set to 8KiB
-  // will have an allocated size of 8KiB, and an effective internal `capacity`
-  // of 8KiB - 13 = 8179 bytes.
-  //
-  // To demonstrate this in practice, let's assume we want to read data from
-  // somewhat larger files using approximately 64KiB buffers:
-  //
-  //   absl::Cord ReadFromFile(int fd, size_t n) {
-  //     absl::Cord cord;
-  //     while (n > 0) {
-  //       CordBuffer buffer = CordBuffer::CreateWithCustomLimit(64 << 10, n);
-  //       absl::Span<char> data = buffer.available_up_to(n);
-  //       ReadFileDataOrDie(fd, data.data(), data.size());
-  //       buffer.IncreaseLengthBy(data.size());
-  //       cord.Append(std::move(buffer));
-  //       n -= data.size();
-  //     }
-  //     return cord;
-  //   }
-  //
-  // If we'd use this function to read a file of 659KiB, we may get the
-  // following pattern of allocated cord buffer sizes:
-  //
-  //   CreateWithCustomLimit(64KiB, 674816) --> ~64KiB (65523)
-  //   CreateWithCustomLimit(64KiB, 674816) --> ~64KiB (65523)
-  //   ...
-  //   CreateWithCustomLimit(64KiB,  19586) --> ~16KiB (16371)
-  //   CreateWithCustomLimit(64KiB,   3215) -->   3215 (at least 3215)
-  //
-  // The reason the method returns a 16K buffer instead of a roughly 19K buffer
-  // is to reduce memory overhead and fragmentation risks. Using carefully
-  // chosen power of 2 values reduces the entropy of allocated memory sizes.
-  //
-  // Additionally, let's assume we'd use the above function on files that are
-  // generally smaller than 64K. If we'd use 'precise' sized buffers for such
-  // files, than we'd get a very wide distribution of allocated memory sizes
-  // rounded to 4K page sizes, and we'd end up with a lot of unused capacity.
-  //
-  // In general, application should only use custom sizes if the data they are
-  // consuming or storing is expected to be many times the chosen block size,
-  // and be based on objective data and performance metrics. For example, a
-  // compress function may work faster and consume less CPU when using larger
-  // buffers. Such an application should pick a size offering a reasonable
-  // trade-off between expected data size, compute savings with larger buffers,
-  // and the cost or fragmentation effect of larger buffers.
-  // Applications must pick a reasonable spot on that curve, and make sure their
-  // data meets their expectations in size distributions such as "mostly large".
-  static CordBuffer CreateWithCustomLimit(size_t block_size, size_t capacity);
-
-  // CordBuffer::available()
-  //
-  // Returns the span delineating the available capacity in this buffer
-  // which is defined as `{ data() + length(), capacity() - length() }`.
-  absl::Span<char> available();
-
-  // CordBuffer::available_up_to()
-  //
-  // Returns the span delineating the available capacity in this buffer limited
-  // to `size` bytes. This is equivalent to `available().subspan(0, size)`.
-  absl::Span<char> available_up_to(size_t size);
-
-  // CordBuffer::data()
-  //
-  // Returns a non-null reference to the data managed by this instance.
-  // Applications are allowed to write up to `capacity` bytes of instance data.
-  // CordBuffer data is uninitialized by default. Reading data from an instance
-  // that has not yet been initialized will lead to undefined behavior.
-  char* data();
-  const char* data() const;
-
-  // CordBuffer::length()
-  //
-  // Returns the length of this instance. The default length of a CordBuffer is
-  // 0, indicating an 'empty' CordBuffer. Applications must specify the length
-  // of the data in a CordBuffer before adding it to a Cord.
-  size_t length() const;
-
-  // CordBuffer::capacity()
-  //
-  // Returns the capacity of this instance. All instances have a non-zero
-  // capacity: default and `moved from` instances have a small internal buffer.
-  size_t capacity() const;
-
-  // CordBuffer::IncreaseLengthBy()
-  //
-  // Increases the length of this buffer by the specified 'n' bytes.
-  // Applications must make sure all data in this buffer up to the new length
-  // has been initialized before adding a CordBuffer to a Cord: failure to do so
-  // will lead to undefined behavior.  Requires `length() + n <= capacity()`.
-  // Typically, applications will use 'available_up_to()` to get a span of the
-  // desired capacity, and use `span.size()` to increase the length as in:
-  //   absl::Span<char> span = buffer.available_up_to(desired);
-  //   buffer.IncreaseLengthBy(span.size());
-  //   memcpy(span.data(), src, span.size());
-  //   etc...
-  void IncreaseLengthBy(size_t n);
-
-  // CordBuffer::SetLength()
-  //
-  // Sets the data length of this instance. Applications must make sure all data
-  // of the specified length has been initialized before adding a CordBuffer to
-  // a Cord: failure to do so will lead to undefined behavior.
-  // Setting the length to a small value or zero does not release any memory
-  // held by this CordBuffer instance. Requires `length <= capacity()`.
-  // Applications should preferably use the `IncreaseLengthBy()` method above
-  // in combination with the 'available()` or `available_up_to()` methods.
-  void SetLength(size_t length);
-
- private:
-  // Make sure we don't accidentally over promise.
-  static_assert(kCustomLimit <= cord_internal::kMaxLargeFlatSize, "");
-
-  // Assume the cost of an 'uprounded' allocation to CeilPow2(size) versus
-  // the cost of allocating at least 1 extra flat <= 4KB:
-  // - Flat overhead = 13 bytes
-  // - Btree amortized cost / node =~ 13 bytes
-  // - 64 byte granularity of tcmalloc at 4K =~ 32 byte average
-  // CPU cost and efficiency requires we should at least 'save' something by
-  // splitting, as a poor man's measure, we say the slop needs to be
-  // at least double the cost offset to make it worth splitting: ~128 bytes.
-  static constexpr size_t kMaxPageSlop = 128;
-
-  // Overhead for allocation a flat.
-  static constexpr size_t kOverhead = cord_internal::kFlatOverhead;
-
-  using CordRepFlat = cord_internal::CordRepFlat;
-
-  // `Rep` is the internal data representation of a CordBuffer. The internal
-  // representation has an internal small size optimization similar to
-  // std::string (SSO).
-  struct Rep {
-    // Inline SSO size of a CordBuffer
-    static constexpr size_t kInlineCapacity = sizeof(intptr_t) * 2 - 1;
-
-    // Creates a default instance with kInlineCapacity.
-    Rep() : short_rep{} {}
-
-    // Creates an instance managing an allocated non zero CordRep.
-    explicit Rep(cord_internal::CordRepFlat* rep) : long_rep{rep} {
-      assert(rep != nullptr);
+    inline constexpr size_t CordBuffer::MaximumPayload()
+    {
+        return cord_internal::kMaxFlatLength;
     }
 
-    // Returns true if this instance manages the SSO internal buffer.
-    bool is_short() const {
-      constexpr size_t offset = offsetof(Short, raw_size);
-      return (reinterpret_cast<const char*>(this)[offset] & 1) != 0;
+    inline constexpr size_t CordBuffer::MaximumPayload(size_t block_size)
+    {
+        // TODO(absl-team): Use std::min when C++11 support is dropped.
+        return (kCustomLimit < block_size ? kCustomLimit : block_size) -
+               cord_internal::kFlatOverhead;
     }
 
-    // Returns the available area of the internal SSO data
-    absl::Span<char> short_available() {
-      assert(is_short());
-      const size_t length = (short_rep.raw_size >> 1);
-      return absl::Span<char>(short_rep.data + length,
-                              kInlineCapacity - length);
+    inline CordBuffer CordBuffer::CreateWithDefaultLimit(size_t capacity)
+    {
+        if (capacity > Rep::kInlineCapacity)
+        {
+            auto* rep = cord_internal::CordRepFlat::New(capacity);
+            rep->length = 0;
+            return CordBuffer(rep);
+        }
+        return CordBuffer();
     }
 
-    // Returns the available area of the internal SSO data
-    absl::Span<char> long_available() {
-      assert(!is_short());
-      const size_t length = long_rep.rep->length;
-      return absl::Span<char>(long_rep.rep->Data() + length,
-                              long_rep.rep->Capacity() - length);
+    template<typename... AllocationHints>
+    inline CordBuffer CordBuffer::CreateWithCustomLimitImpl(
+        size_t block_size, size_t capacity, AllocationHints... hints
+    )
+    {
+        assert(IsPow2(block_size));
+        capacity = (std::min)(capacity, kCustomLimit);
+        block_size = (std::min)(block_size, kCustomLimit);
+        if (capacity + kOverhead >= block_size)
+        {
+            capacity = block_size;
+        }
+        else if (capacity <= kDefaultLimit)
+        {
+            capacity = capacity + kOverhead;
+        }
+        else if (!IsPow2(capacity))
+        {
+            // Check if rounded up to next power 2 is a good enough fit
+            // with limited waste making it an acceptable direct fit.
+            const size_t rounded_up = size_t{1} << Log2Ceil(capacity);
+            const size_t slop = rounded_up - capacity;
+            if (slop >= kOverhead && slop <= kMaxPageSlop + kOverhead)
+            {
+                capacity = rounded_up;
+            }
+            else
+            {
+                // Round down to highest power of 2 <= capacity.
+                // Consider a more aggressive step down if that may reduce the
+                // risk of fragmentation where 'people are holding it wrong'.
+                const size_t rounded_down = size_t{1} << Log2Floor(capacity);
+                capacity = rounded_down;
+            }
+        }
+        const size_t length = capacity - kOverhead;
+        auto* rep = CordRepFlat::New(CordRepFlat::Large(), length, hints...);
+        rep->length = 0;
+        return CordBuffer(rep);
     }
 
-    // Returns the length of the internal SSO data.
-    size_t short_length() const {
-      assert(is_short());
-      return short_rep.raw_size >> 1;
+    inline CordBuffer CordBuffer::CreateWithCustomLimit(size_t block_size, size_t capacity)
+    {
+        return CreateWithCustomLimitImpl(block_size, capacity);
     }
 
-    // Sets the length of the internal SSO data.
-    // Disregards any previously set CordRep instance.
-    void set_short_length(size_t length) {
-      short_rep.raw_size = static_cast<char>((length << 1) + 1);
+    inline CordBuffer::~CordBuffer()
+    {
+        if (!rep_.is_short())
+        {
+            cord_internal::CordRepFlat::Delete(rep_.rep());
+        }
     }
 
-    // Adds `n` to the current short length.
-    void add_short_length(size_t n) {
-      assert(is_short());
-      short_rep.raw_size += static_cast<char>(n << 1);
+    inline CordBuffer::CordBuffer(CordBuffer&& rhs) noexcept :
+        rep_(rhs.rep_)
+    {
+        rhs.rep_.set_short_length(0);
     }
 
-    // Returns reference to the internal SSO data buffer.
-    char* data() {
-      assert(is_short());
-      return short_rep.data;
+    inline CordBuffer& CordBuffer::operator=(CordBuffer&& rhs) noexcept
+    {
+        if (!rep_.is_short())
+            cord_internal::CordRepFlat::Delete(rep_.rep());
+        rep_ = rhs.rep_;
+        rhs.rep_.set_short_length(0);
+        return *this;
     }
-    const char* data() const {
-      assert(is_short());
-      return short_rep.data;
+
+    inline absl::Span<char> CordBuffer::available()
+    {
+        return rep_.is_short() ? rep_.short_available() : rep_.long_available();
     }
 
-    // Returns a pointer the external CordRep managed by this instance.
-    cord_internal::CordRepFlat* rep() const {
-      assert(!is_short());
-      return long_rep.rep;
+    inline absl::Span<char> CordBuffer::available_up_to(size_t size)
+    {
+        return available().subspan(0, size);
     }
 
-    // The internal representation takes advantage of the fact that allocated
-    // memory is always on an even address, and uses the least significant bit
-    // of the first or last byte (depending on endianness) as the inline size
-    // indicator overlapping with the least significant byte of the CordRep*.
-#if defined(ABSL_IS_BIG_ENDIAN)
-    struct Long {
-      explicit Long(cord_internal::CordRepFlat* rep_arg) : rep(rep_arg) {}
-      void* padding;
-      cord_internal::CordRepFlat* rep;
-    };
-    struct Short {
-      char data[sizeof(Long) - 1];
-      char raw_size = 1;
-    };
-#else
-    struct Long {
-      explicit Long(cord_internal::CordRepFlat* rep_arg) : rep(rep_arg) {}
-      cord_internal::CordRepFlat* rep;
-      void* padding;
-    };
-    struct Short {
-      char raw_size = 1;
-      char data[sizeof(Long) - 1];
-    };
-#endif
+    inline char* CordBuffer::data()
+    {
+        return rep_.is_short() ? rep_.data() : rep_.rep()->Data();
+    }
 
-    union {
-      Long long_rep;
-      Short short_rep;
-    };
-  };
-
-  // Power2 functions
-  static bool IsPow2(size_t size) { return absl::has_single_bit(size); }
-  static size_t Log2Floor(size_t size) { return absl::bit_width(size) - 1; }
-  static size_t Log2Ceil(size_t size) { return absl::bit_width(size - 1); }
-
-  // Implementation of `CreateWithCustomLimit()`.
-  // This implementation allows for future memory allocation hints to
-  // be passed down into the CordRepFlat allocation function.
-  template <typename... AllocationHints>
-  static CordBuffer CreateWithCustomLimitImpl(size_t block_size,
-                                              size_t capacity,
-                                              AllocationHints... hints);
-
-  // Consumes the value contained in this instance and resets the instance.
-  // This method returns a non-null Cordrep* if the current instances manages a
-  // CordRep*, and resets the instance to an empty SSO instance. If the current
-  // instance is an SSO instance, then this method returns nullptr and sets
-  // `short_value` to the inlined data value. In either case, the current
-  // instance length is reset to zero.
-  // This method is intended to be used by Cord internal functions only.
-  cord_internal::CordRep* ConsumeValue(absl::string_view& short_value) {
-    cord_internal::CordRep* rep = nullptr;
-    if (rep_.is_short()) {
-      short_value = absl::string_view(rep_.data(), rep_.short_length());
-    } else {
-      rep = rep_.rep();
+    inline const char* CordBuffer::data() const
+    {
+        return rep_.is_short() ? rep_.data() : rep_.rep()->Data();
     }
-    rep_.set_short_length(0);
-    return rep;
-  }
-
-  // Internal constructor.
-  explicit CordBuffer(cord_internal::CordRepFlat* rep) : rep_(rep) {
-    assert(rep != nullptr);
-  }
-
-  Rep rep_;
-
-  friend class Cord;
-  friend class CordBufferTestPeer;
-};
-
-inline constexpr size_t CordBuffer::MaximumPayload() {
-  return cord_internal::kMaxFlatLength;
-}
-
-inline constexpr size_t CordBuffer::MaximumPayload(size_t block_size) {
-  // TODO(absl-team): Use std::min when C++11 support is dropped.
-  return (kCustomLimit < block_size ? kCustomLimit : block_size) -
-         cord_internal::kFlatOverhead;
-}
-
-inline CordBuffer CordBuffer::CreateWithDefaultLimit(size_t capacity) {
-  if (capacity > Rep::kInlineCapacity) {
-    auto* rep = cord_internal::CordRepFlat::New(capacity);
-    rep->length = 0;
-    return CordBuffer(rep);
-  }
-  return CordBuffer();
-}
-
-template <typename... AllocationHints>
-inline CordBuffer CordBuffer::CreateWithCustomLimitImpl(
-    size_t block_size, size_t capacity, AllocationHints... hints) {
-  assert(IsPow2(block_size));
-  capacity = (std::min)(capacity, kCustomLimit);
-  block_size = (std::min)(block_size, kCustomLimit);
-  if (capacity + kOverhead >= block_size) {
-    capacity = block_size;
-  } else if (capacity <= kDefaultLimit) {
-    capacity = capacity + kOverhead;
-  } else if (!IsPow2(capacity)) {
-    // Check if rounded up to next power 2 is a good enough fit
-    // with limited waste making it an acceptable direct fit.
-    const size_t rounded_up = size_t{1} << Log2Ceil(capacity);
-    const size_t slop = rounded_up - capacity;
-    if (slop >= kOverhead && slop <= kMaxPageSlop + kOverhead) {
-      capacity = rounded_up;
-    } else {
-      // Round down to highest power of 2 <= capacity.
-      // Consider a more aggressive step down if that may reduce the
-      // risk of fragmentation where 'people are holding it wrong'.
-      const size_t rounded_down = size_t{1} << Log2Floor(capacity);
-      capacity = rounded_down;
+
+    inline size_t CordBuffer::capacity() const
+    {
+        return rep_.is_short() ? Rep::kInlineCapacity : rep_.rep()->Capacity();
     }
-  }
-  const size_t length = capacity - kOverhead;
-  auto* rep = CordRepFlat::New(CordRepFlat::Large(), length, hints...);
-  rep->length = 0;
-  return CordBuffer(rep);
-}
-
-inline CordBuffer CordBuffer::CreateWithCustomLimit(size_t block_size,
-                                                    size_t capacity) {
-  return CreateWithCustomLimitImpl(block_size, capacity);
-}
-
-inline CordBuffer::~CordBuffer() {
-  if (!rep_.is_short()) {
-    cord_internal::CordRepFlat::Delete(rep_.rep());
-  }
-}
-
-inline CordBuffer::CordBuffer(CordBuffer&& rhs) noexcept : rep_(rhs.rep_) {
-  rhs.rep_.set_short_length(0);
-}
-
-inline CordBuffer& CordBuffer::operator=(CordBuffer&& rhs) noexcept {
-  if (!rep_.is_short()) cord_internal::CordRepFlat::Delete(rep_.rep());
-  rep_ = rhs.rep_;
-  rhs.rep_.set_short_length(0);
-  return *this;
-}
-
-inline absl::Span<char> CordBuffer::available() {
-  return rep_.is_short() ? rep_.short_available() : rep_.long_available();
-}
-
-inline absl::Span<char> CordBuffer::available_up_to(size_t size) {
-  return available().subspan(0, size);
-}
-
-inline char* CordBuffer::data() {
-  return rep_.is_short() ? rep_.data() : rep_.rep()->Data();
-}
-
-inline const char* CordBuffer::data() const {
-  return rep_.is_short() ? rep_.data() : rep_.rep()->Data();
-}
-
-inline size_t CordBuffer::capacity() const {
-  return rep_.is_short() ? Rep::kInlineCapacity : rep_.rep()->Capacity();
-}
-
-inline size_t CordBuffer::length() const {
-  return rep_.is_short() ? rep_.short_length() : rep_.rep()->length;
-}
-
-inline void CordBuffer::SetLength(size_t length) {
-  ABSL_HARDENING_ASSERT(length <= capacity());
-  if (rep_.is_short()) {
-    rep_.set_short_length(length);
-  } else {
-    rep_.rep()->length = length;
-  }
-}
-
-inline void CordBuffer::IncreaseLengthBy(size_t n) {
-  ABSL_HARDENING_ASSERT(n <= capacity() && length() + n <= capacity());
-  if (rep_.is_short()) {
-    rep_.add_short_length(n);
-  } else {
-    rep_.rep()->length += n;
-  }
-}
-
-ABSL_NAMESPACE_END
+
+    inline size_t CordBuffer::length() const
+    {
+        return rep_.is_short() ? rep_.short_length() : rep_.rep()->length;
+    }
+
+    inline void CordBuffer::SetLength(size_t length)
+    {
+        ABSL_HARDENING_ASSERT(length <= capacity());
+        if (rep_.is_short())
+        {
+            rep_.set_short_length(length);
+        }
+        else
+        {
+            rep_.rep()->length = length;
+        }
+    }
+
+    inline void CordBuffer::IncreaseLengthBy(size_t n)
+    {
+        ABSL_HARDENING_ASSERT(n <= capacity() && length() + n <= capacity());
+        if (rep_.is_short())
+        {
+            rep_.add_short_length(n);
+        }
+        else
+        {
+            rep_.rep()->length += n;
+        }
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CORD_BUFFER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cord_test_helpers.h b/CAPI/cpp/grpc/include/absl/strings/cord_test_helpers.h
index 31a1dc8..f84f0ea 100644
--- a/CAPI/cpp/grpc/include/absl/strings/cord_test_helpers.h
+++ b/CAPI/cpp/grpc/include/absl/strings/cord_test_helpers.h
@@ -26,97 +26,110 @@
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Cord sizes relevant for testing
-enum class TestCordSize {
-  // An empty value
-  kEmpty = 0,
-
-  // An inlined string value
-  kInlined = cord_internal::kMaxInline / 2 + 1,
-
-  // 'Well known' SSO lengths (excluding terminating zero).
-  // libstdcxx has a maximum SSO of 15, libc++ has a maximum SSO of 22.
-  kStringSso1 = 15,
-  kStringSso2 = 22,
-
-  // A string value which is too large to fit in inlined data, but small enough
-  // such that Cord prefers copying the value if possible, i.e.: not stealing
-  // std::string inputs, or referencing existing CordReps on Append, etc.
-  kSmall = cord_internal::kMaxBytesToCopy / 2 + 1,
-
-  // A string value large enough that Cord prefers to reference or steal from
-  // existing inputs rather than copying contents of the input.
-  kMedium = cord_internal::kMaxFlatLength / 2 + 1,
-
-  // A string value large enough to cause it to be stored in mutliple flats.
-  kLarge = cord_internal::kMaxFlatLength * 4
-};
-
-// To string helper
-inline absl::string_view ToString(TestCordSize size) {
-  switch (size) {
-    case TestCordSize::kEmpty:
-      return "Empty";
-    case TestCordSize::kInlined:
-      return "Inlined";
-    case TestCordSize::kSmall:
-      return "Small";
-    case TestCordSize::kStringSso1:
-      return "StringSso1";
-    case TestCordSize::kStringSso2:
-      return "StringSso2";
-    case TestCordSize::kMedium:
-      return "Medium";
-    case TestCordSize::kLarge:
-      return "Large";
-  }
-  return "???";
-}
-
-// Returns the length matching the specified size
-inline size_t Length(TestCordSize size) { return static_cast<size_t>(size); }
-
-// Stream output helper
-inline std::ostream& operator<<(std::ostream& stream, TestCordSize size) {
-  return stream << ToString(size);
-}
-
-// Creates a multi-segment Cord from an iterable container of strings.  The
-// resulting Cord is guaranteed to have one segment for every string in the
-// container.  This allows code to be unit tested with multi-segment Cord
-// inputs.
-//
-// Example:
-//
-//   absl::Cord c = absl::MakeFragmentedCord({"A ", "fragmented ", "Cord"});
-//   EXPECT_FALSE(c.GetFlat(&unused));
-//
-// The mechanism by which this Cord is created is an implementation detail.  Any
-// implementation that produces a multi-segment Cord may produce a flat Cord in
-// the future as new optimizations are added to the Cord class.
-// MakeFragmentedCord will, however, always be updated to return a multi-segment
-// Cord.
-template <typename Container>
-Cord MakeFragmentedCord(const Container& c) {
-  Cord result;
-  for (const auto& s : c) {
-    auto* external = new std::string(s);
-    Cord tmp = absl::MakeCordFromExternal(
-        *external, [external](absl::string_view) { delete external; });
-    tmp.Prepend(result);
-    result = tmp;
-  }
-  return result;
-}
-
-inline Cord MakeFragmentedCord(std::initializer_list<absl::string_view> list) {
-  return MakeFragmentedCord<std::initializer_list<absl::string_view>>(list);
-}
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // Cord sizes relevant for testing
+    enum class TestCordSize
+    {
+        // An empty value
+        kEmpty = 0,
+
+        // An inlined string value
+        kInlined = cord_internal::kMaxInline / 2 + 1,
+
+        // 'Well known' SSO lengths (excluding terminating zero).
+        // libstdcxx has a maximum SSO of 15, libc++ has a maximum SSO of 22.
+        kStringSso1 = 15,
+        kStringSso2 = 22,
+
+        // A string value which is too large to fit in inlined data, but small enough
+        // such that Cord prefers copying the value if possible, i.e.: not stealing
+        // std::string inputs, or referencing existing CordReps on Append, etc.
+        kSmall = cord_internal::kMaxBytesToCopy / 2 + 1,
+
+        // A string value large enough that Cord prefers to reference or steal from
+        // existing inputs rather than copying contents of the input.
+        kMedium = cord_internal::kMaxFlatLength / 2 + 1,
+
+        // A string value large enough to cause it to be stored in mutliple flats.
+        kLarge = cord_internal::kMaxFlatLength * 4
+    };
+
+    // To string helper
+    inline absl::string_view ToString(TestCordSize size)
+    {
+        switch (size)
+        {
+            case TestCordSize::kEmpty:
+                return "Empty";
+            case TestCordSize::kInlined:
+                return "Inlined";
+            case TestCordSize::kSmall:
+                return "Small";
+            case TestCordSize::kStringSso1:
+                return "StringSso1";
+            case TestCordSize::kStringSso2:
+                return "StringSso2";
+            case TestCordSize::kMedium:
+                return "Medium";
+            case TestCordSize::kLarge:
+                return "Large";
+        }
+        return "???";
+    }
+
+    // Returns the length matching the specified size
+    inline size_t Length(TestCordSize size)
+    {
+        return static_cast<size_t>(size);
+    }
+
+    // Stream output helper
+    inline std::ostream& operator<<(std::ostream& stream, TestCordSize size)
+    {
+        return stream << ToString(size);
+    }
+
+    // Creates a multi-segment Cord from an iterable container of strings.  The
+    // resulting Cord is guaranteed to have one segment for every string in the
+    // container.  This allows code to be unit tested with multi-segment Cord
+    // inputs.
+    //
+    // Example:
+    //
+    //   absl::Cord c = absl::MakeFragmentedCord({"A ", "fragmented ", "Cord"});
+    //   EXPECT_FALSE(c.GetFlat(&unused));
+    //
+    // The mechanism by which this Cord is created is an implementation detail.  Any
+    // implementation that produces a multi-segment Cord may produce a flat Cord in
+    // the future as new optimizations are added to the Cord class.
+    // MakeFragmentedCord will, however, always be updated to return a multi-segment
+    // Cord.
+    template<typename Container>
+    Cord MakeFragmentedCord(const Container& c)
+    {
+        Cord result;
+        for (const auto& s : c)
+        {
+            auto* external = new std::string(s);
+            Cord tmp = absl::MakeCordFromExternal(
+                *external, [external](absl::string_view)
+                { delete external; }
+            );
+            tmp.Prepend(result);
+            result = tmp;
+        }
+        return result;
+    }
+
+    inline Cord MakeFragmentedCord(std::initializer_list<absl::string_view> list)
+    {
+        return MakeFragmentedCord<std::initializer_list<absl::string_view>>(list);
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CORD_TEST_HELPERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/cordz_test_helpers.h b/CAPI/cpp/grpc/include/absl/strings/cordz_test_helpers.h
index e410eec..e0163c6 100644
--- a/CAPI/cpp/grpc/include/absl/strings/cordz_test_helpers.h
+++ b/CAPI/cpp/grpc/include/absl/strings/cordz_test_helpers.h
@@ -29,123 +29,146 @@
 #include "absl/strings/internal/cordz_update_tracker.h"
 #include "absl/strings/str_cat.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Returns the CordzInfo for the cord, or nullptr if the cord is not sampled.
-inline const cord_internal::CordzInfo* GetCordzInfoForTesting(
-    const Cord& cord) {
-  if (!cord.contents_.is_tree()) return nullptr;
-  return cord.contents_.cordz_info();
-}
-
-// Returns true if the provided cordz_info is in the list of sampled cords.
-inline bool CordzInfoIsListed(const cord_internal::CordzInfo* cordz_info,
-                              cord_internal::CordzSampleToken token = {}) {
-  for (const cord_internal::CordzInfo& info : token) {
-    if (cordz_info == &info) return true;
-  }
-  return false;
-}
-
-// Matcher on Cord that verifies all of:
-// - the cord is sampled
-// - the CordzInfo of the cord is listed / discoverable.
-// - the reported CordzStatistics match the cord's actual properties
-// - the cord has an (initial) UpdateTracker count of 1 for `method`
-MATCHER_P(HasValidCordzInfoOf, method, "CordzInfo matches cord") {
-  const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
-  if (cord_info == nullptr) {
-    *result_listener << "cord is not sampled";
-    return false;
-  }
-  if (!CordzInfoIsListed(cord_info)) {
-    *result_listener << "cord is sampled, but not listed";
-    return false;
-  }
-  cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
-  if (stat.size != arg.size()) {
-    *result_listener << "cordz size " << stat.size
-                     << " does not match cord size " << arg.size();
-    return false;
-  }
-  if (stat.update_tracker.Value(method) != 1) {
-    *result_listener << "Expected method count 1 for " << method << ", found "
-                     << stat.update_tracker.Value(method);
-    return false;
-  }
-  return true;
-}
-
-// Matcher on Cord that verifies that the cord is sampled and that the CordzInfo
-// update tracker has 'method' with a call count of 'n'
-MATCHER_P2(CordzMethodCountEq, method, n,
-           absl::StrCat("CordzInfo method count equals ", n)) {
-  const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
-  if (cord_info == nullptr) {
-    *result_listener << "cord is not sampled";
-    return false;
-  }
-  cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
-  if (stat.update_tracker.Value(method) != n) {
-    *result_listener << "Expected method count " << n << " for " << method
-                     << ", found " << stat.update_tracker.Value(method);
-    return false;
-  }
-  return true;
-}
-
-// Cordz will only update with a new rate once the previously scheduled event
-// has fired. When we disable Cordz, a long delay takes place where we won't
-// consider profiling new Cords. CordzSampleIntervalHelper will burn through
-// that interval and allow for testing that assumes that the average sampling
-// interval is a particular value.
-class CordzSamplingIntervalHelper {
- public:
-  explicit CordzSamplingIntervalHelper(int32_t interval)
-      : orig_mean_interval_(absl::cord_internal::get_cordz_mean_interval()) {
-    absl::cord_internal::set_cordz_mean_interval(interval);
-    absl::cord_internal::cordz_set_next_sample_for_testing(interval);
-  }
-
-  ~CordzSamplingIntervalHelper() {
-    absl::cord_internal::set_cordz_mean_interval(orig_mean_interval_);
-    absl::cord_internal::cordz_set_next_sample_for_testing(orig_mean_interval_);
-  }
-
- private:
-  int32_t orig_mean_interval_;
-};
-
-// Wrapper struct managing a small CordRep `rep`
-struct TestCordRep {
-  cord_internal::CordRepFlat* rep;
-
-  TestCordRep() {
-    rep = cord_internal::CordRepFlat::New(100);
-    rep->length = 100;
-    memset(rep->Data(), 1, 100);
-  }
-  ~TestCordRep() { cord_internal::CordRep::Unref(rep); }
-};
-
-// Wrapper struct managing a small CordRep `rep`, and
-// an InlineData `data` initialized with that CordRep.
-struct TestCordData {
-  TestCordRep rep;
-  cord_internal::InlineData data{rep.rep};
-};
-
-// Creates a Cord that is not sampled
-template <typename... Args>
-Cord UnsampledCord(Args... args) {
-  CordzSamplingIntervalHelper never(9999);
-  Cord cord(std::forward<Args>(args)...);
-  ABSL_ASSERT(GetCordzInfoForTesting(cord) == nullptr);
-  return cord;
-}
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // Returns the CordzInfo for the cord, or nullptr if the cord is not sampled.
+    inline const cord_internal::CordzInfo* GetCordzInfoForTesting(
+        const Cord& cord
+    )
+    {
+        if (!cord.contents_.is_tree())
+            return nullptr;
+        return cord.contents_.cordz_info();
+    }
+
+    // Returns true if the provided cordz_info is in the list of sampled cords.
+    inline bool CordzInfoIsListed(const cord_internal::CordzInfo* cordz_info, cord_internal::CordzSampleToken token = {})
+    {
+        for (const cord_internal::CordzInfo& info : token)
+        {
+            if (cordz_info == &info)
+                return true;
+        }
+        return false;
+    }
+
+    // Matcher on Cord that verifies all of:
+    // - the cord is sampled
+    // - the CordzInfo of the cord is listed / discoverable.
+    // - the reported CordzStatistics match the cord's actual properties
+    // - the cord has an (initial) UpdateTracker count of 1 for `method`
+    MATCHER_P(HasValidCordzInfoOf, method, "CordzInfo matches cord")
+    {
+        const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
+        if (cord_info == nullptr)
+        {
+            *result_listener << "cord is not sampled";
+            return false;
+        }
+        if (!CordzInfoIsListed(cord_info))
+        {
+            *result_listener << "cord is sampled, but not listed";
+            return false;
+        }
+        cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
+        if (stat.size != arg.size())
+        {
+            *result_listener << "cordz size " << stat.size
+                             << " does not match cord size " << arg.size();
+            return false;
+        }
+        if (stat.update_tracker.Value(method) != 1)
+        {
+            *result_listener << "Expected method count 1 for " << method << ", found "
+                             << stat.update_tracker.Value(method);
+            return false;
+        }
+        return true;
+    }
+
+    // Matcher on Cord that verifies that the cord is sampled and that the CordzInfo
+    // update tracker has 'method' with a call count of 'n'
+    MATCHER_P2(CordzMethodCountEq, method, n, absl::StrCat("CordzInfo method count equals ", n))
+    {
+        const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
+        if (cord_info == nullptr)
+        {
+            *result_listener << "cord is not sampled";
+            return false;
+        }
+        cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
+        if (stat.update_tracker.Value(method) != n)
+        {
+            *result_listener << "Expected method count " << n << " for " << method
+                             << ", found " << stat.update_tracker.Value(method);
+            return false;
+        }
+        return true;
+    }
+
+    // Cordz will only update with a new rate once the previously scheduled event
+    // has fired. When we disable Cordz, a long delay takes place where we won't
+    // consider profiling new Cords. CordzSampleIntervalHelper will burn through
+    // that interval and allow for testing that assumes that the average sampling
+    // interval is a particular value.
+    class CordzSamplingIntervalHelper
+    {
+    public:
+        explicit CordzSamplingIntervalHelper(int32_t interval) :
+            orig_mean_interval_(absl::cord_internal::get_cordz_mean_interval())
+        {
+            absl::cord_internal::set_cordz_mean_interval(interval);
+            absl::cord_internal::cordz_set_next_sample_for_testing(interval);
+        }
+
+        ~CordzSamplingIntervalHelper()
+        {
+            absl::cord_internal::set_cordz_mean_interval(orig_mean_interval_);
+            absl::cord_internal::cordz_set_next_sample_for_testing(orig_mean_interval_);
+        }
+
+    private:
+        int32_t orig_mean_interval_;
+    };
+
+    // Wrapper struct managing a small CordRep `rep`
+    struct TestCordRep
+    {
+        cord_internal::CordRepFlat* rep;
+
+        TestCordRep()
+        {
+            rep = cord_internal::CordRepFlat::New(100);
+            rep->length = 100;
+            memset(rep->Data(), 1, 100);
+        }
+        ~TestCordRep()
+        {
+            cord_internal::CordRep::Unref(rep);
+        }
+    };
+
+    // Wrapper struct managing a small CordRep `rep`, and
+    // an InlineData `data` initialized with that CordRep.
+    struct TestCordData
+    {
+        TestCordRep rep;
+        cord_internal::InlineData data{rep.rep};
+    };
+
+    // Creates a Cord that is not sampled
+    template<typename... Args>
+    Cord UnsampledCord(Args... args)
+    {
+        CordzSamplingIntervalHelper never(9999);
+        Cord cord(std::forward<Args>(args)...);
+        ABSL_ASSERT(GetCordzInfoForTesting(cord) == nullptr);
+        return cord;
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/escaping.h b/CAPI/cpp/grpc/include/absl/strings/escaping.h
index f5ca26c..e973b16 100644
--- a/CAPI/cpp/grpc/include/absl/strings/escaping.h
+++ b/CAPI/cpp/grpc/include/absl/strings/escaping.h
@@ -32,133 +32,135 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// CUnescape()
-//
-// Unescapes a `source` string and copies it into `dest`, rewriting C-style
-// escape sequences (https://en.cppreference.com/w/cpp/language/escape) into
-// their proper code point equivalents, returning `true` if successful.
-//
-// The following unescape sequences can be handled:
-//
-//   * ASCII escape sequences ('\n','\r','\\', etc.) to their ASCII equivalents
-//   * Octal escape sequences ('\nnn') to byte nnn. The unescaped value must
-//     resolve to a single byte or an error will occur. E.g. values greater than
-//     0xff will produce an error.
-//   * Hexadecimal escape sequences ('\xnn') to byte nn. While an arbitrary
-//     number of following digits are allowed, the unescaped value must resolve
-//     to a single byte or an error will occur. E.g. '\x0045' is equivalent to
-//     '\x45', but '\x1234' will produce an error.
-//   * Unicode escape sequences ('\unnnn' for exactly four hex digits or
-//     '\Unnnnnnnn' for exactly eight hex digits, which will be encoded in
-//     UTF-8. (E.g., `\u2019` unescapes to the three bytes 0xE2, 0x80, and
-//     0x99).
-//
-// If any errors are encountered, this function returns `false`, leaving the
-// `dest` output parameter in an unspecified state, and stores the first
-// encountered error in `error`. To disable error reporting, set `error` to
-// `nullptr` or use the overload with no error reporting below.
-//
-// Example:
-//
-//   std::string s = "foo\\rbar\\nbaz\\t";
-//   std::string unescaped_s;
-//   if (!absl::CUnescape(s, &unescaped_s) {
-//     ...
-//   }
-//   EXPECT_EQ(unescaped_s, "foo\rbar\nbaz\t");
-bool CUnescape(absl::string_view source, std::string* dest, std::string* error);
-
-// Overload of `CUnescape()` with no error reporting.
-inline bool CUnescape(absl::string_view source, std::string* dest) {
-  return CUnescape(source, dest, nullptr);
-}
-
-// CEscape()
-//
-// Escapes a 'src' string using C-style escapes sequences
-// (https://en.cppreference.com/w/cpp/language/escape), escaping other
-// non-printable/non-whitespace bytes as octal sequences (e.g. "\377").
-//
-// Example:
-//
-//   std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
-//   std::string escaped_s = absl::CEscape(s);
-//   EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\010\\t\\n\\013\\014\\r\\n");
-std::string CEscape(absl::string_view src);
-
-// CHexEscape()
-//
-// Escapes a 'src' string using C-style escape sequences, escaping
-// other non-printable/non-whitespace bytes as hexadecimal sequences (e.g.
-// "\xFF").
-//
-// Example:
-//
-//   std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
-//   std::string escaped_s = absl::CHexEscape(s);
-//   EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\x08\\t\\n\\x0b\\x0c\\r\\n");
-std::string CHexEscape(absl::string_view src);
-
-// Utf8SafeCEscape()
-//
-// Escapes a 'src' string using C-style escape sequences, escaping bytes as
-// octal sequences, and passing through UTF-8 characters without conversion.
-// I.e., when encountering any bytes with their high bit set, this function
-// will not escape those values, whether or not they are valid UTF-8.
-std::string Utf8SafeCEscape(absl::string_view src);
-
-// Utf8SafeCHexEscape()
-//
-// Escapes a 'src' string using C-style escape sequences, escaping bytes as
-// hexadecimal sequences, and passing through UTF-8 characters without
-// conversion.
-std::string Utf8SafeCHexEscape(absl::string_view src);
-
-// Base64Unescape()
-//
-// Converts a `src` string encoded in Base64 to its binary equivalent, writing
-// it to a `dest` buffer, returning `true` on success. If `src` contains invalid
-// characters, `dest` is cleared and returns `false`.
-bool Base64Unescape(absl::string_view src, std::string* dest);
-
-// WebSafeBase64Unescape()
-//
-// Converts a `src` string encoded in Base64 to its binary equivalent, writing
-// it to a `dest` buffer, but using '-' instead of '+', and '_' instead of '/'.
-// If `src` contains invalid characters, `dest` is cleared and returns `false`.
-bool WebSafeBase64Unescape(absl::string_view src, std::string* dest);
-
-// Base64Escape()
-//
-// Encodes a `src` string into a base64-encoded string, with padding characters.
-// This function conforms with RFC 4648 section 4 (base64).
-void Base64Escape(absl::string_view src, std::string* dest);
-std::string Base64Escape(absl::string_view src);
-
-// WebSafeBase64Escape()
-//
-// Encodes a `src` string into a base64-like string, using '-' instead of '+'
-// and '_' instead of '/', and without padding. This function conforms with RFC
-// 4648 section 5 (base64url).
-void WebSafeBase64Escape(absl::string_view src, std::string* dest);
-std::string WebSafeBase64Escape(absl::string_view src);
-
-// HexStringToBytes()
-//
-// Converts an ASCII hex string into bytes, returning binary data of length
-// `from.size()/2`.
-std::string HexStringToBytes(absl::string_view from);
-
-// BytesToHexString()
-//
-// Converts binary data into an ASCII text string, returning a string of size
-// `2*from.size()`.
-std::string BytesToHexString(absl::string_view from);
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // CUnescape()
+    //
+    // Unescapes a `source` string and copies it into `dest`, rewriting C-style
+    // escape sequences (https://en.cppreference.com/w/cpp/language/escape) into
+    // their proper code point equivalents, returning `true` if successful.
+    //
+    // The following unescape sequences can be handled:
+    //
+    //   * ASCII escape sequences ('\n','\r','\\', etc.) to their ASCII equivalents
+    //   * Octal escape sequences ('\nnn') to byte nnn. The unescaped value must
+    //     resolve to a single byte or an error will occur. E.g. values greater than
+    //     0xff will produce an error.
+    //   * Hexadecimal escape sequences ('\xnn') to byte nn. While an arbitrary
+    //     number of following digits are allowed, the unescaped value must resolve
+    //     to a single byte or an error will occur. E.g. '\x0045' is equivalent to
+    //     '\x45', but '\x1234' will produce an error.
+    //   * Unicode escape sequences ('\unnnn' for exactly four hex digits or
+    //     '\Unnnnnnnn' for exactly eight hex digits, which will be encoded in
+    //     UTF-8. (E.g., `\u2019` unescapes to the three bytes 0xE2, 0x80, and
+    //     0x99).
+    //
+    // If any errors are encountered, this function returns `false`, leaving the
+    // `dest` output parameter in an unspecified state, and stores the first
+    // encountered error in `error`. To disable error reporting, set `error` to
+    // `nullptr` or use the overload with no error reporting below.
+    //
+    // Example:
+    //
+    //   std::string s = "foo\\rbar\\nbaz\\t";
+    //   std::string unescaped_s;
+    //   if (!absl::CUnescape(s, &unescaped_s) {
+    //     ...
+    //   }
+    //   EXPECT_EQ(unescaped_s, "foo\rbar\nbaz\t");
+    bool CUnescape(absl::string_view source, std::string* dest, std::string* error);
+
+    // Overload of `CUnescape()` with no error reporting.
+    inline bool CUnescape(absl::string_view source, std::string* dest)
+    {
+        return CUnescape(source, dest, nullptr);
+    }
+
+    // CEscape()
+    //
+    // Escapes a 'src' string using C-style escapes sequences
+    // (https://en.cppreference.com/w/cpp/language/escape), escaping other
+    // non-printable/non-whitespace bytes as octal sequences (e.g. "\377").
+    //
+    // Example:
+    //
+    //   std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
+    //   std::string escaped_s = absl::CEscape(s);
+    //   EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\010\\t\\n\\013\\014\\r\\n");
+    std::string CEscape(absl::string_view src);
+
+    // CHexEscape()
+    //
+    // Escapes a 'src' string using C-style escape sequences, escaping
+    // other non-printable/non-whitespace bytes as hexadecimal sequences (e.g.
+    // "\xFF").
+    //
+    // Example:
+    //
+    //   std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
+    //   std::string escaped_s = absl::CHexEscape(s);
+    //   EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\x08\\t\\n\\x0b\\x0c\\r\\n");
+    std::string CHexEscape(absl::string_view src);
+
+    // Utf8SafeCEscape()
+    //
+    // Escapes a 'src' string using C-style escape sequences, escaping bytes as
+    // octal sequences, and passing through UTF-8 characters without conversion.
+    // I.e., when encountering any bytes with their high bit set, this function
+    // will not escape those values, whether or not they are valid UTF-8.
+    std::string Utf8SafeCEscape(absl::string_view src);
+
+    // Utf8SafeCHexEscape()
+    //
+    // Escapes a 'src' string using C-style escape sequences, escaping bytes as
+    // hexadecimal sequences, and passing through UTF-8 characters without
+    // conversion.
+    std::string Utf8SafeCHexEscape(absl::string_view src);
+
+    // Base64Unescape()
+    //
+    // Converts a `src` string encoded in Base64 to its binary equivalent, writing
+    // it to a `dest` buffer, returning `true` on success. If `src` contains invalid
+    // characters, `dest` is cleared and returns `false`.
+    bool Base64Unescape(absl::string_view src, std::string* dest);
+
+    // WebSafeBase64Unescape()
+    //
+    // Converts a `src` string encoded in Base64 to its binary equivalent, writing
+    // it to a `dest` buffer, but using '-' instead of '+', and '_' instead of '/'.
+    // If `src` contains invalid characters, `dest` is cleared and returns `false`.
+    bool WebSafeBase64Unescape(absl::string_view src, std::string* dest);
+
+    // Base64Escape()
+    //
+    // Encodes a `src` string into a base64-encoded string, with padding characters.
+    // This function conforms with RFC 4648 section 4 (base64).
+    void Base64Escape(absl::string_view src, std::string* dest);
+    std::string Base64Escape(absl::string_view src);
+
+    // WebSafeBase64Escape()
+    //
+    // Encodes a `src` string into a base64-like string, using '-' instead of '+'
+    // and '_' instead of '/', and without padding. This function conforms with RFC
+    // 4648 section 5 (base64url).
+    void WebSafeBase64Escape(absl::string_view src, std::string* dest);
+    std::string WebSafeBase64Escape(absl::string_view src);
+
+    // HexStringToBytes()
+    //
+    // Converts an ASCII hex string into bytes, returning binary data of length
+    // `from.size()/2`.
+    std::string HexStringToBytes(absl::string_view from);
+
+    // BytesToHexString()
+    //
+    // Converts binary data into an ASCII text string, returning a string of size
+    // `2*from.size()`.
+    std::string BytesToHexString(absl::string_view from);
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_ESCAPING_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/char_map.h b/CAPI/cpp/grpc/include/absl/strings/internal/char_map.h
index 61484de..eda86e2 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/char_map.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/char_map.h
@@ -27,130 +27,184 @@
 #include "absl/base/macros.h"
 #include "absl/base/port.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-class Charmap {
- public:
-  constexpr Charmap() : m_() {}
-
-  // Initializes with a given char*.  Note that NUL is not treated as
-  // a terminator, but rather a char to be flicked.
-  Charmap(const char* str, int len) : m_() {
-    while (len--) SetChar(*str++);
-  }
-
-  // Initializes with a given char*.  NUL is treated as a terminator
-  // and will not be in the charmap.
-  explicit Charmap(const char* str) : m_() {
-    while (*str) SetChar(*str++);
-  }
-
-  constexpr bool contains(unsigned char c) const {
-    return (m_[c / 64] >> (c % 64)) & 0x1;
-  }
-
-  // Returns true if and only if a character exists in both maps.
-  bool IntersectsWith(const Charmap& c) const {
-    for (size_t i = 0; i < ABSL_ARRAYSIZE(m_); ++i) {
-      if ((m_[i] & c.m_[i]) != 0) return true;
-    }
-    return false;
-  }
-
-  bool IsZero() const {
-    for (uint64_t c : m_) {
-      if (c != 0) return false;
-    }
-    return true;
-  }
-
-  // Containing only a single specified char.
-  static constexpr Charmap Char(char x) {
-    return Charmap(CharMaskForWord(x, 0), CharMaskForWord(x, 1),
-                   CharMaskForWord(x, 2), CharMaskForWord(x, 3));
-  }
-
-  // Containing all the chars in the C-string 's'.
-  // Note that this is expensively recursive because of the C++11 constexpr
-  // formulation. Use only in constexpr initializers.
-  static constexpr Charmap FromString(const char* s) {
-    return *s == 0 ? Charmap() : (Char(*s) | FromString(s + 1));
-  }
-
-  // Containing all the chars in the closed interval [lo,hi].
-  static constexpr Charmap Range(char lo, char hi) {
-    return Charmap(RangeForWord(lo, hi, 0), RangeForWord(lo, hi, 1),
-                   RangeForWord(lo, hi, 2), RangeForWord(lo, hi, 3));
-  }
-
-  friend constexpr Charmap operator&(const Charmap& a, const Charmap& b) {
-    return Charmap(a.m_[0] & b.m_[0], a.m_[1] & b.m_[1], a.m_[2] & b.m_[2],
-                   a.m_[3] & b.m_[3]);
-  }
-
-  friend constexpr Charmap operator|(const Charmap& a, const Charmap& b) {
-    return Charmap(a.m_[0] | b.m_[0], a.m_[1] | b.m_[1], a.m_[2] | b.m_[2],
-                   a.m_[3] | b.m_[3]);
-  }
-
-  friend constexpr Charmap operator~(const Charmap& a) {
-    return Charmap(~a.m_[0], ~a.m_[1], ~a.m_[2], ~a.m_[3]);
-  }
-
- private:
-  constexpr Charmap(uint64_t b0, uint64_t b1, uint64_t b2, uint64_t b3)
-      : m_{b0, b1, b2, b3} {}
-
-  static constexpr uint64_t RangeForWord(unsigned char lo, unsigned char hi,
-                                         uint64_t word) {
-    return OpenRangeFromZeroForWord(hi + 1, word) &
-           ~OpenRangeFromZeroForWord(lo, word);
-  }
-
-  // All the chars in the specified word of the range [0, upper).
-  static constexpr uint64_t OpenRangeFromZeroForWord(uint64_t upper,
-                                                     uint64_t word) {
-    return (upper <= 64 * word)
-               ? 0
-               : (upper >= 64 * (word + 1))
-                     ? ~static_cast<uint64_t>(0)
-                     : (~static_cast<uint64_t>(0) >> (64 - upper % 64));
-  }
-
-  static constexpr uint64_t CharMaskForWord(unsigned char x, uint64_t word) {
-    return (x / 64 == word) ? (static_cast<uint64_t>(1) << (x % 64)) : 0;
-  }
-
- private:
-  void SetChar(unsigned char c) {
-    m_[c / 64] |= static_cast<uint64_t>(1) << (c % 64);
-  }
-
-  uint64_t m_[4];
-};
-
-// Mirror the char-classifying predicates in <cctype>
-constexpr Charmap UpperCharmap() { return Charmap::Range('A', 'Z'); }
-constexpr Charmap LowerCharmap() { return Charmap::Range('a', 'z'); }
-constexpr Charmap DigitCharmap() { return Charmap::Range('0', '9'); }
-constexpr Charmap AlphaCharmap() { return LowerCharmap() | UpperCharmap(); }
-constexpr Charmap AlnumCharmap() { return DigitCharmap() | AlphaCharmap(); }
-constexpr Charmap XDigitCharmap() {
-  return DigitCharmap() | Charmap::Range('A', 'F') | Charmap::Range('a', 'f');
-}
-constexpr Charmap PrintCharmap() { return Charmap::Range(0x20, 0x7e); }
-constexpr Charmap SpaceCharmap() { return Charmap::FromString("\t\n\v\f\r "); }
-constexpr Charmap CntrlCharmap() {
-  return Charmap::Range(0, 0x7f) & ~PrintCharmap();
-}
-constexpr Charmap BlankCharmap() { return Charmap::FromString("\t "); }
-constexpr Charmap GraphCharmap() { return PrintCharmap() & ~SpaceCharmap(); }
-constexpr Charmap PunctCharmap() { return GraphCharmap() & ~AlnumCharmap(); }
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        class Charmap
+        {
+        public:
+            constexpr Charmap() :
+                m_()
+            {
+            }
+
+            // Initializes with a given char*.  Note that NUL is not treated as
+            // a terminator, but rather a char to be flicked.
+            Charmap(const char* str, int len) :
+                m_()
+            {
+                while (len--)
+                    SetChar(*str++);
+            }
+
+            // Initializes with a given char*.  NUL is treated as a terminator
+            // and will not be in the charmap.
+            explicit Charmap(const char* str) :
+                m_()
+            {
+                while (*str)
+                    SetChar(*str++);
+            }
+
+            constexpr bool contains(unsigned char c) const
+            {
+                return (m_[c / 64] >> (c % 64)) & 0x1;
+            }
+
+            // Returns true if and only if a character exists in both maps.
+            bool IntersectsWith(const Charmap& c) const
+            {
+                for (size_t i = 0; i < ABSL_ARRAYSIZE(m_); ++i)
+                {
+                    if ((m_[i] & c.m_[i]) != 0)
+                        return true;
+                }
+                return false;
+            }
+
+            bool IsZero() const
+            {
+                for (uint64_t c : m_)
+                {
+                    if (c != 0)
+                        return false;
+                }
+                return true;
+            }
+
+            // Containing only a single specified char.
+            static constexpr Charmap Char(char x)
+            {
+                return Charmap(CharMaskForWord(x, 0), CharMaskForWord(x, 1), CharMaskForWord(x, 2), CharMaskForWord(x, 3));
+            }
+
+            // Containing all the chars in the C-string 's'.
+            // Note that this is expensively recursive because of the C++11 constexpr
+            // formulation. Use only in constexpr initializers.
+            static constexpr Charmap FromString(const char* s)
+            {
+                return *s == 0 ? Charmap() : (Char(*s) | FromString(s + 1));
+            }
+
+            // Containing all the chars in the closed interval [lo,hi].
+            static constexpr Charmap Range(char lo, char hi)
+            {
+                return Charmap(RangeForWord(lo, hi, 0), RangeForWord(lo, hi, 1), RangeForWord(lo, hi, 2), RangeForWord(lo, hi, 3));
+            }
+
+            friend constexpr Charmap operator&(const Charmap& a, const Charmap& b)
+            {
+                return Charmap(a.m_[0] & b.m_[0], a.m_[1] & b.m_[1], a.m_[2] & b.m_[2], a.m_[3] & b.m_[3]);
+            }
+
+            friend constexpr Charmap operator|(const Charmap& a, const Charmap& b)
+            {
+                return Charmap(a.m_[0] | b.m_[0], a.m_[1] | b.m_[1], a.m_[2] | b.m_[2], a.m_[3] | b.m_[3]);
+            }
+
+            friend constexpr Charmap operator~(const Charmap& a)
+            {
+                return Charmap(~a.m_[0], ~a.m_[1], ~a.m_[2], ~a.m_[3]);
+            }
+
+        private:
+            constexpr Charmap(uint64_t b0, uint64_t b1, uint64_t b2, uint64_t b3) :
+                m_{b0, b1, b2, b3}
+            {
+            }
+
+            static constexpr uint64_t RangeForWord(unsigned char lo, unsigned char hi, uint64_t word)
+            {
+                return OpenRangeFromZeroForWord(hi + 1, word) &
+                       ~OpenRangeFromZeroForWord(lo, word);
+            }
+
+            // All the chars in the specified word of the range [0, upper).
+            static constexpr uint64_t OpenRangeFromZeroForWord(uint64_t upper, uint64_t word)
+            {
+                return (upper <= 64 * word) ? 0 : (upper >= 64 * (word + 1)) ? ~static_cast<uint64_t>(0) :
+                                                                               (~static_cast<uint64_t>(0) >> (64 - upper % 64));
+            }
+
+            static constexpr uint64_t CharMaskForWord(unsigned char x, uint64_t word)
+            {
+                return (x / 64 == word) ? (static_cast<uint64_t>(1) << (x % 64)) : 0;
+            }
+
+        private:
+            void SetChar(unsigned char c)
+            {
+                m_[c / 64] |= static_cast<uint64_t>(1) << (c % 64);
+            }
+
+            uint64_t m_[4];
+        };
+
+        // Mirror the char-classifying predicates in <cctype>
+        constexpr Charmap UpperCharmap()
+        {
+            return Charmap::Range('A', 'Z');
+        }
+        constexpr Charmap LowerCharmap()
+        {
+            return Charmap::Range('a', 'z');
+        }
+        constexpr Charmap DigitCharmap()
+        {
+            return Charmap::Range('0', '9');
+        }
+        constexpr Charmap AlphaCharmap()
+        {
+            return LowerCharmap() | UpperCharmap();
+        }
+        constexpr Charmap AlnumCharmap()
+        {
+            return DigitCharmap() | AlphaCharmap();
+        }
+        constexpr Charmap XDigitCharmap()
+        {
+            return DigitCharmap() | Charmap::Range('A', 'F') | Charmap::Range('a', 'f');
+        }
+        constexpr Charmap PrintCharmap()
+        {
+            return Charmap::Range(0x20, 0x7e);
+        }
+        constexpr Charmap SpaceCharmap()
+        {
+            return Charmap::FromString("\t\n\v\f\r ");
+        }
+        constexpr Charmap CntrlCharmap()
+        {
+            return Charmap::Range(0, 0x7f) & ~PrintCharmap();
+        }
+        constexpr Charmap BlankCharmap()
+        {
+            return Charmap::FromString("\t ");
+        }
+        constexpr Charmap GraphCharmap()
+        {
+            return PrintCharmap() & ~SpaceCharmap();
+        }
+        constexpr Charmap PunctCharmap()
+        {
+            return GraphCharmap() & ~AlnumCharmap();
+        }
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/charconv_bigint.h b/CAPI/cpp/grpc/include/absl/strings/internal/charconv_bigint.h
index 8f70297..45a27c1 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/charconv_bigint.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/charconv_bigint.h
@@ -25,399 +25,477 @@
 #include "absl/strings/internal/charconv_parse.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        // The largest power that 5 that can be raised to, and still fit in a uint32_t.
+        constexpr int kMaxSmallPowerOfFive = 13;
+        // The largest power that 10 that can be raised to, and still fit in a uint32_t.
+        constexpr int kMaxSmallPowerOfTen = 9;
+
+        ABSL_DLL extern const uint32_t
+            kFiveToNth[kMaxSmallPowerOfFive + 1];
+        ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
+
+        // Large, fixed-width unsigned integer.
+        //
+        // Exact rounding for decimal-to-binary floating point conversion requires very
+        // large integer math, but a design goal of absl::from_chars is to avoid
+        // allocating memory.  The integer precision needed for decimal-to-binary
+        // conversions is large but bounded, so a huge fixed-width integer class
+        // suffices.
+        //
+        // This is an intentionally limited big integer class.  Only needed operations
+        // are implemented.  All storage lives in an array data member, and all
+        // arithmetic is done in-place, to avoid requiring separate storage for operand
+        // and result.
+        //
+        // This is an internal class.  Some methods live in the .cc file, and are
+        // instantiated only for the values of max_words we need.
+        template<int max_words>
+        class BigUnsigned
+        {
+        public:
+            static_assert(max_words == 4 || max_words == 84, "unsupported max_words value");
+
+            BigUnsigned() :
+                size_(0),
+                words_{}
+            {
+            }
+            explicit constexpr BigUnsigned(uint64_t v) :
+                size_((v >> 32) ? 2 : v ? 1 :
+                                          0),
+                words_{static_cast<uint32_t>(v & 0xffffffffu), static_cast<uint32_t>(v >> 32)}
+            {
+            }
+
+            // Constructs a BigUnsigned from the given string_view containing a decimal
+            // value.  If the input string is not a decimal integer, constructs a 0
+            // instead.
+            explicit BigUnsigned(absl::string_view sv) :
+                size_(0),
+                words_{}
+            {
+                // Check for valid input, returning a 0 otherwise.  This is reasonable
+                // behavior only because this constructor is for unit tests.
+                if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() ||
+                    sv.empty())
+                {
+                    return;
+                }
+                int exponent_adjust =
+                    ReadDigits(sv.data(), sv.data() + sv.size(), Digits10() + 1);
+                if (exponent_adjust > 0)
+                {
+                    MultiplyByTenToTheNth(exponent_adjust);
+                }
+            }
+
+            // Loads the mantissa value of a previously-parsed float.
+            //
+            // Returns the associated decimal exponent.  The value of the parsed float is
+            // exactly *this * 10**exponent.
+            int ReadFloatMantissa(const ParsedFloat& fp, int significant_digits);
+
+            // Returns the number of decimal digits of precision this type provides.  All
+            // numbers with this many decimal digits or fewer are representable by this
+            // type.
+            //
+            // Analagous to std::numeric_limits<BigUnsigned>::digits10.
+            static constexpr int Digits10()
+            {
+                // 9975007/1035508 is very slightly less than log10(2**32).
+                return static_cast<uint64_t>(max_words) * 9975007 / 1035508;
+            }
+
+            // Shifts left by the given number of bits.
+            void ShiftLeft(int count)
+            {
+                if (count > 0)
+                {
+                    const int word_shift = count / 32;
+                    if (word_shift >= max_words)
+                    {
+                        SetToZero();
+                        return;
+                    }
+                    size_ = (std::min)(size_ + word_shift, max_words);
+                    count %= 32;
+                    if (count == 0)
+                    {
+                        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
+                    }
+                    else
+                    {
+                        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i)
+                        {
+                            words_[i] = (words_[i - word_shift] << count) |
+                                        (words_[i - word_shift - 1] >> (32 - count));
+                        }
+                        words_[word_shift] = words_[0] << count;
+                        // Grow size_ if necessary.
+                        if (size_ < max_words && words_[size_])
+                        {
+                            ++size_;
+                        }
+                    }
+                    std::fill(words_, words_ + word_shift, 0u);
+                }
+            }
+
+            // Multiplies by v in-place.
+            void MultiplyBy(uint32_t v)
+            {
+                if (size_ == 0 || v == 1)
+                {
+                    return;
+                }
+                if (v == 0)
+                {
+                    SetToZero();
+                    return;
+                }
+                const uint64_t factor = v;
+                uint64_t window = 0;
+                for (int i = 0; i < size_; ++i)
+                {
+                    window += factor * words_[i];
+                    words_[i] = window & 0xffffffff;
+                    window >>= 32;
+                }
+                // If carry bits remain and there's space for them, grow size_.
+                if (window && size_ < max_words)
+                {
+                    words_[size_] = window & 0xffffffff;
+                    ++size_;
+                }
+            }
+
+            void MultiplyBy(uint64_t v)
+            {
+                uint32_t words[2];
+                words[0] = static_cast<uint32_t>(v);
+                words[1] = static_cast<uint32_t>(v >> 32);
+                if (words[1] == 0)
+                {
+                    MultiplyBy(words[0]);
+                }
+                else
+                {
+                    MultiplyBy(2, words);
+                }
+            }
+
+            // Multiplies in place by 5 to the power of n.  n must be non-negative.
+            void MultiplyByFiveToTheNth(int n)
+            {
+                while (n >= kMaxSmallPowerOfFive)
+                {
+                    MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
+                    n -= kMaxSmallPowerOfFive;
+                }
+                if (n > 0)
+                {
+                    MultiplyBy(kFiveToNth[n]);
+                }
+            }
+
+            // Multiplies in place by 10 to the power of n.  n must be non-negative.
+            void MultiplyByTenToTheNth(int n)
+            {
+                if (n > kMaxSmallPowerOfTen)
+                {
+                    // For large n, raise to a power of 5, then shift left by the same amount.
+                    // (10**n == 5**n * 2**n.)  This requires fewer multiplications overall.
+                    MultiplyByFiveToTheNth(n);
+                    ShiftLeft(n);
+                }
+                else if (n > 0)
+                {
+                    // We can do this more quickly for very small N by using a single
+                    // multiplication.
+                    MultiplyBy(kTenToNth[n]);
+                }
+            }
+
+            // Returns the value of 5**n, for non-negative n.  This implementation uses
+            // a lookup table, and is faster then seeding a BigUnsigned with 1 and calling
+            // MultiplyByFiveToTheNth().
+            static BigUnsigned FiveToTheNth(int n);
+
+            // Multiplies by another BigUnsigned, in-place.
+            template<int M>
+            void MultiplyBy(const BigUnsigned<M>& other)
+            {
+                MultiplyBy(other.size(), other.words());
+            }
+
+            void SetToZero()
+            {
+                std::fill(words_, words_ + size_, 0u);
+                size_ = 0;
+            }
+
+            // Returns the value of the nth word of this BigUnsigned.  This is
+            // range-checked, and returns 0 on out-of-bounds accesses.
+            uint32_t GetWord(int index) const
+            {
+                if (index < 0 || index >= size_)
+                {
+                    return 0;
+                }
+                return words_[index];
+            }
+
+            // Returns this integer as a decimal string.  This is not used in the decimal-
+            // to-binary conversion; it is intended to aid in testing.
+            std::string ToString() const;
+
+            int size() const
+            {
+                return size_;
+            }
+            const uint32_t* words() const
+            {
+                return words_;
+            }
+
+        private:
+            // Reads the number between [begin, end), possibly containing a decimal point,
+            // into this BigUnsigned.
+            //
+            // Callers are required to ensure [begin, end) contains a valid number, with
+            // one or more decimal digits and at most one decimal point.  This routine
+            // will behave unpredictably if these preconditions are not met.
+            //
+            // Only the first `significant_digits` digits are read.  Digits beyond this
+            // limit are "sticky": If the final significant digit is 0 or 5, and if any
+            // dropped digit is nonzero, then that final significant digit is adjusted up
+            // to 1 or 6.  This adjustment allows for precise rounding.
+            //
+            // Returns `exponent_adjustment`, a power-of-ten exponent adjustment to
+            // account for the decimal point and for dropped significant digits.  After
+            // this function returns,
+            //   actual_value_of_parsed_string ~= *this * 10**exponent_adjustment.
+            int ReadDigits(const char* begin, const char* end, int significant_digits);
+
+            // Performs a step of big integer multiplication.  This computes the full
+            // (64-bit-wide) values that should be added at the given index (step), and
+            // adds to that location in-place.
+            //
+            // Because our math all occurs in place, we must multiply starting from the
+            // highest word working downward.  (This is a bit more expensive due to the
+            // extra carries involved.)
+            //
+            // This must be called in steps, for each word to be calculated, starting from
+            // the high end and working down to 0.  The first value of `step` should be
+            //   `std::min(original_size + other.size_ - 2, max_words - 1)`.
+            // The reason for this expression is that multiplying the i'th word from one
+            // multiplicand and the j'th word of another multiplicand creates a
+            // two-word-wide value to be stored at the (i+j)'th element.  The highest
+            // word indices we will access are `original_size - 1` from this object, and
+            // `other.size_ - 1` from our operand.  Therefore,
+            // `original_size + other.size_ - 2` is the first step we should calculate,
+            // but limited on an upper bound by max_words.
+
+            // Working from high-to-low ensures that we do not overwrite the portions of
+            // the initial value of *this which are still needed for later steps.
+            //
+            // Once called with step == 0, *this contains the result of the
+            // multiplication.
+            //
+            // `original_size` is the size_ of *this before the first call to
+            // MultiplyStep().  `other_words` and `other_size` are the contents of our
+            // operand.  `step` is the step to perform, as described above.
+            void MultiplyStep(int original_size, const uint32_t* other_words, int other_size, int step);
+
+            void MultiplyBy(int other_size, const uint32_t* other_words)
+            {
+                const int original_size = size_;
+                const int first_step =
+                    (std::min)(original_size + other_size - 2, max_words - 1);
+                for (int step = first_step; step >= 0; --step)
+                {
+                    MultiplyStep(original_size, other_words, other_size, step);
+                }
+            }
+
+            // Adds a 32-bit value to the index'th word, with carry.
+            void AddWithCarry(int index, uint32_t value)
+            {
+                if (value)
+                {
+                    while (index < max_words && value > 0)
+                    {
+                        words_[index] += value;
+                        // carry if we overflowed in this word:
+                        if (value > words_[index])
+                        {
+                            value = 1;
+                            ++index;
+                        }
+                        else
+                        {
+                            value = 0;
+                        }
+                    }
+                    size_ = (std::min)(max_words, (std::max)(index + 1, size_));
+                }
+            }
+
+            void AddWithCarry(int index, uint64_t value)
+            {
+                if (value && index < max_words)
+                {
+                    uint32_t high = value >> 32;
+                    uint32_t low = value & 0xffffffff;
+                    words_[index] += low;
+                    if (words_[index] < low)
+                    {
+                        ++high;
+                        if (high == 0)
+                        {
+                            // Carry from the low word caused our high word to overflow.
+                            // Short circuit here to do the right thing.
+                            AddWithCarry(index + 2, static_cast<uint32_t>(1));
+                            return;
+                        }
+                    }
+                    if (high > 0)
+                    {
+                        AddWithCarry(index + 1, high);
+                    }
+                    else
+                    {
+                        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
+                        // it when `high` is 0, do it ourselves here.
+                        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
+                    }
+                }
+            }
+
+            // Divide this in place by a constant divisor.  Returns the remainder of the
+            // division.
+            template<uint32_t divisor>
+            uint32_t DivMod()
+            {
+                uint64_t accumulator = 0;
+                for (int i = size_ - 1; i >= 0; --i)
+                {
+                    accumulator <<= 32;
+                    accumulator += words_[i];
+                    // accumulator / divisor will never overflow an int32_t in this loop
+                    words_[i] = static_cast<uint32_t>(accumulator / divisor);
+                    accumulator = accumulator % divisor;
+                }
+                while (size_ > 0 && words_[size_ - 1] == 0)
+                {
+                    --size_;
+                }
+                return static_cast<uint32_t>(accumulator);
+            }
+
+            // The number of elements in words_ that may carry significant values.
+            // All elements beyond this point are 0.
+            //
+            // When size_ is 0, this BigUnsigned stores the value 0.
+            // When size_ is nonzero, is *not* guaranteed that words_[size_ - 1] is
+            // nonzero.  This can occur due to overflow truncation.
+            // In particular, x.size_ != y.size_ does *not* imply x != y.
+            int size_;
+            uint32_t words_[max_words];
+        };
+
+        // Compares two big integer instances.
+        //
+        // Returns -1 if lhs < rhs, 0 if lhs == rhs, and 1 if lhs > rhs.
+        template<int N, int M>
+        int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs)
+        {
+            int limit = (std::max)(lhs.size(), rhs.size());
+            for (int i = limit - 1; i >= 0; --i)
+            {
+                const uint32_t lhs_word = lhs.GetWord(i);
+                const uint32_t rhs_word = rhs.GetWord(i);
+                if (lhs_word < rhs_word)
+                {
+                    return -1;
+                }
+                else if (lhs_word > rhs_word)
+                {
+                    return 1;
+                }
+            }
+            return 0;
+        }
 
-// The largest power that 5 that can be raised to, and still fit in a uint32_t.
-constexpr int kMaxSmallPowerOfFive = 13;
-// The largest power that 10 that can be raised to, and still fit in a uint32_t.
-constexpr int kMaxSmallPowerOfTen = 9;
+        template<int N, int M>
+        bool operator==(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs)
+        {
+            int limit = (std::max)(lhs.size(), rhs.size());
+            for (int i = 0; i < limit; ++i)
+            {
+                if (lhs.GetWord(i) != rhs.GetWord(i))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
 
-ABSL_DLL extern const uint32_t
-    kFiveToNth[kMaxSmallPowerOfFive + 1];
-ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
+        template<int N, int M>
+        bool operator!=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs)
+        {
+            return !(lhs == rhs);
+        }
 
-// Large, fixed-width unsigned integer.
-//
-// Exact rounding for decimal-to-binary floating point conversion requires very
-// large integer math, but a design goal of absl::from_chars is to avoid
-// allocating memory.  The integer precision needed for decimal-to-binary
-// conversions is large but bounded, so a huge fixed-width integer class
-// suffices.
-//
-// This is an intentionally limited big integer class.  Only needed operations
-// are implemented.  All storage lives in an array data member, and all
-// arithmetic is done in-place, to avoid requiring separate storage for operand
-// and result.
-//
-// This is an internal class.  Some methods live in the .cc file, and are
-// instantiated only for the values of max_words we need.
-template <int max_words>
-class BigUnsigned {
- public:
-  static_assert(max_words == 4 || max_words == 84,
-                "unsupported max_words value");
-
-  BigUnsigned() : size_(0), words_{} {}
-  explicit constexpr BigUnsigned(uint64_t v)
-      : size_((v >> 32) ? 2 : v ? 1 : 0),
-        words_{static_cast<uint32_t>(v & 0xffffffffu),
-               static_cast<uint32_t>(v >> 32)} {}
-
-  // Constructs a BigUnsigned from the given string_view containing a decimal
-  // value.  If the input string is not a decimal integer, constructs a 0
-  // instead.
-  explicit BigUnsigned(absl::string_view sv) : size_(0), words_{} {
-    // Check for valid input, returning a 0 otherwise.  This is reasonable
-    // behavior only because this constructor is for unit tests.
-    if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() ||
-        sv.empty()) {
-      return;
-    }
-    int exponent_adjust =
-        ReadDigits(sv.data(), sv.data() + sv.size(), Digits10() + 1);
-    if (exponent_adjust > 0) {
-      MultiplyByTenToTheNth(exponent_adjust);
-    }
-  }
-
-  // Loads the mantissa value of a previously-parsed float.
-  //
-  // Returns the associated decimal exponent.  The value of the parsed float is
-  // exactly *this * 10**exponent.
-  int ReadFloatMantissa(const ParsedFloat& fp, int significant_digits);
-
-  // Returns the number of decimal digits of precision this type provides.  All
-  // numbers with this many decimal digits or fewer are representable by this
-  // type.
-  //
-  // Analagous to std::numeric_limits<BigUnsigned>::digits10.
-  static constexpr int Digits10() {
-    // 9975007/1035508 is very slightly less than log10(2**32).
-    return static_cast<uint64_t>(max_words) * 9975007 / 1035508;
-  }
-
-  // Shifts left by the given number of bits.
-  void ShiftLeft(int count) {
-    if (count > 0) {
-      const int word_shift = count / 32;
-      if (word_shift >= max_words) {
-        SetToZero();
-        return;
-      }
-      size_ = (std::min)(size_ + word_shift, max_words);
-      count %= 32;
-      if (count == 0) {
-        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
-      } else {
-        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
-          words_[i] = (words_[i - word_shift] << count) |
-                      (words_[i - word_shift - 1] >> (32 - count));
+        template<int N, int M>
+        bool operator<(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs)
+        {
+            return Compare(lhs, rhs) == -1;
         }
-        words_[word_shift] = words_[0] << count;
-        // Grow size_ if necessary.
-        if (size_ < max_words && words_[size_]) {
-          ++size_;
+
+        template<int N, int M>
+        bool operator>(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs)
+        {
+            return rhs < lhs;
         }
-      }
-      std::fill(words_, words_ + word_shift, 0u);
-    }
-  }
-
-
-  // Multiplies by v in-place.
-  void MultiplyBy(uint32_t v) {
-    if (size_ == 0 || v == 1) {
-      return;
-    }
-    if (v == 0) {
-      SetToZero();
-      return;
-    }
-    const uint64_t factor = v;
-    uint64_t window = 0;
-    for (int i = 0; i < size_; ++i) {
-      window += factor * words_[i];
-      words_[i] = window & 0xffffffff;
-      window >>= 32;
-    }
-    // If carry bits remain and there's space for them, grow size_.
-    if (window && size_ < max_words) {
-      words_[size_] = window & 0xffffffff;
-      ++size_;
-    }
-  }
-
-  void MultiplyBy(uint64_t v) {
-    uint32_t words[2];
-    words[0] = static_cast<uint32_t>(v);
-    words[1] = static_cast<uint32_t>(v >> 32);
-    if (words[1] == 0) {
-      MultiplyBy(words[0]);
-    } else {
-      MultiplyBy(2, words);
-    }
-  }
-
-  // Multiplies in place by 5 to the power of n.  n must be non-negative.
-  void MultiplyByFiveToTheNth(int n) {
-    while (n >= kMaxSmallPowerOfFive) {
-      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
-      n -= kMaxSmallPowerOfFive;
-    }
-    if (n > 0) {
-      MultiplyBy(kFiveToNth[n]);
-    }
-  }
-
-  // Multiplies in place by 10 to the power of n.  n must be non-negative.
-  void MultiplyByTenToTheNth(int n) {
-    if (n > kMaxSmallPowerOfTen) {
-      // For large n, raise to a power of 5, then shift left by the same amount.
-      // (10**n == 5**n * 2**n.)  This requires fewer multiplications overall.
-      MultiplyByFiveToTheNth(n);
-      ShiftLeft(n);
-    } else if (n > 0) {
-      // We can do this more quickly for very small N by using a single
-      // multiplication.
-      MultiplyBy(kTenToNth[n]);
-    }
-  }
-
-  // Returns the value of 5**n, for non-negative n.  This implementation uses
-  // a lookup table, and is faster then seeding a BigUnsigned with 1 and calling
-  // MultiplyByFiveToTheNth().
-  static BigUnsigned FiveToTheNth(int n);
-
-  // Multiplies by another BigUnsigned, in-place.
-  template <int M>
-  void MultiplyBy(const BigUnsigned<M>& other) {
-    MultiplyBy(other.size(), other.words());
-  }
-
-  void SetToZero() {
-    std::fill(words_, words_ + size_, 0u);
-    size_ = 0;
-  }
-
-  // Returns the value of the nth word of this BigUnsigned.  This is
-  // range-checked, and returns 0 on out-of-bounds accesses.
-  uint32_t GetWord(int index) const {
-    if (index < 0 || index >= size_) {
-      return 0;
-    }
-    return words_[index];
-  }
-
-  // Returns this integer as a decimal string.  This is not used in the decimal-
-  // to-binary conversion; it is intended to aid in testing.
-  std::string ToString() const;
-
-  int size() const { return size_; }
-  const uint32_t* words() const { return words_; }
-
- private:
-  // Reads the number between [begin, end), possibly containing a decimal point,
-  // into this BigUnsigned.
-  //
-  // Callers are required to ensure [begin, end) contains a valid number, with
-  // one or more decimal digits and at most one decimal point.  This routine
-  // will behave unpredictably if these preconditions are not met.
-  //
-  // Only the first `significant_digits` digits are read.  Digits beyond this
-  // limit are "sticky": If the final significant digit is 0 or 5, and if any
-  // dropped digit is nonzero, then that final significant digit is adjusted up
-  // to 1 or 6.  This adjustment allows for precise rounding.
-  //
-  // Returns `exponent_adjustment`, a power-of-ten exponent adjustment to
-  // account for the decimal point and for dropped significant digits.  After
-  // this function returns,
-  //   actual_value_of_parsed_string ~= *this * 10**exponent_adjustment.
-  int ReadDigits(const char* begin, const char* end, int significant_digits);
-
-  // Performs a step of big integer multiplication.  This computes the full
-  // (64-bit-wide) values that should be added at the given index (step), and
-  // adds to that location in-place.
-  //
-  // Because our math all occurs in place, we must multiply starting from the
-  // highest word working downward.  (This is a bit more expensive due to the
-  // extra carries involved.)
-  //
-  // This must be called in steps, for each word to be calculated, starting from
-  // the high end and working down to 0.  The first value of `step` should be
-  //   `std::min(original_size + other.size_ - 2, max_words - 1)`.
-  // The reason for this expression is that multiplying the i'th word from one
-  // multiplicand and the j'th word of another multiplicand creates a
-  // two-word-wide value to be stored at the (i+j)'th element.  The highest
-  // word indices we will access are `original_size - 1` from this object, and
-  // `other.size_ - 1` from our operand.  Therefore,
-  // `original_size + other.size_ - 2` is the first step we should calculate,
-  // but limited on an upper bound by max_words.
-
-  // Working from high-to-low ensures that we do not overwrite the portions of
-  // the initial value of *this which are still needed for later steps.
-  //
-  // Once called with step == 0, *this contains the result of the
-  // multiplication.
-  //
-  // `original_size` is the size_ of *this before the first call to
-  // MultiplyStep().  `other_words` and `other_size` are the contents of our
-  // operand.  `step` is the step to perform, as described above.
-  void MultiplyStep(int original_size, const uint32_t* other_words,
-                    int other_size, int step);
-
-  void MultiplyBy(int other_size, const uint32_t* other_words) {
-    const int original_size = size_;
-    const int first_step =
-        (std::min)(original_size + other_size - 2, max_words - 1);
-    for (int step = first_step; step >= 0; --step) {
-      MultiplyStep(original_size, other_words, other_size, step);
-    }
-  }
-
-  // Adds a 32-bit value to the index'th word, with carry.
-  void AddWithCarry(int index, uint32_t value) {
-    if (value) {
-      while (index < max_words && value > 0) {
-        words_[index] += value;
-        // carry if we overflowed in this word:
-        if (value > words_[index]) {
-          value = 1;
-          ++index;
-        } else {
-          value = 0;
+        template<int N, int M>
+        bool operator<=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs)
+        {
+            return !(rhs < lhs);
         }
-      }
-      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
-    }
-  }
-
-  void AddWithCarry(int index, uint64_t value) {
-    if (value && index < max_words) {
-      uint32_t high = value >> 32;
-      uint32_t low = value & 0xffffffff;
-      words_[index] += low;
-      if (words_[index] < low) {
-        ++high;
-        if (high == 0) {
-          // Carry from the low word caused our high word to overflow.
-          // Short circuit here to do the right thing.
-          AddWithCarry(index + 2, static_cast<uint32_t>(1));
-          return;
+        template<int N, int M>
+        bool operator>=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs)
+        {
+            return !(lhs < rhs);
+        }
+
+        // Output operator for BigUnsigned, for testing purposes only.
+        template<int N>
+        std::ostream& operator<<(std::ostream& os, const BigUnsigned<N>& num)
+        {
+            return os << num.ToString();
         }
-      }
-      if (high > 0) {
-        AddWithCarry(index + 1, high);
-      } else {
-        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
-        // it when `high` is 0, do it ourselves here.
-        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
-      }
-    }
-  }
-
-  // Divide this in place by a constant divisor.  Returns the remainder of the
-  // division.
-  template <uint32_t divisor>
-  uint32_t DivMod() {
-    uint64_t accumulator = 0;
-    for (int i = size_ - 1; i >= 0; --i) {
-      accumulator <<= 32;
-      accumulator += words_[i];
-      // accumulator / divisor will never overflow an int32_t in this loop
-      words_[i] = static_cast<uint32_t>(accumulator / divisor);
-      accumulator = accumulator % divisor;
-    }
-    while (size_ > 0 && words_[size_ - 1] == 0) {
-      --size_;
-    }
-    return static_cast<uint32_t>(accumulator);
-  }
-
-  // The number of elements in words_ that may carry significant values.
-  // All elements beyond this point are 0.
-  //
-  // When size_ is 0, this BigUnsigned stores the value 0.
-  // When size_ is nonzero, is *not* guaranteed that words_[size_ - 1] is
-  // nonzero.  This can occur due to overflow truncation.
-  // In particular, x.size_ != y.size_ does *not* imply x != y.
-  int size_;
-  uint32_t words_[max_words];
-};
-
-// Compares two big integer instances.
-//
-// Returns -1 if lhs < rhs, 0 if lhs == rhs, and 1 if lhs > rhs.
-template <int N, int M>
-int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  int limit = (std::max)(lhs.size(), rhs.size());
-  for (int i = limit - 1; i >= 0; --i) {
-    const uint32_t lhs_word = lhs.GetWord(i);
-    const uint32_t rhs_word = rhs.GetWord(i);
-    if (lhs_word < rhs_word) {
-      return -1;
-    } else if (lhs_word > rhs_word) {
-      return 1;
-    }
-  }
-  return 0;
-}
-
-template <int N, int M>
-bool operator==(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  int limit = (std::max)(lhs.size(), rhs.size());
-  for (int i = 0; i < limit; ++i) {
-    if (lhs.GetWord(i) != rhs.GetWord(i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-template <int N, int M>
-bool operator!=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return !(lhs == rhs);
-}
-
-template <int N, int M>
-bool operator<(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return Compare(lhs, rhs) == -1;
-}
-
-template <int N, int M>
-bool operator>(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return rhs < lhs;
-}
-template <int N, int M>
-bool operator<=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return !(rhs < lhs);
-}
-template <int N, int M>
-bool operator>=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
-  return !(lhs < rhs);
-}
-
-// Output operator for BigUnsigned, for testing purposes only.
-template <int N>
-std::ostream& operator<<(std::ostream& os, const BigUnsigned<N>& num) {
-  return os << num.ToString();
-}
-
-// Explicit instantiation declarations for the sizes of BigUnsigned that we
-// are using.
-//
-// For now, the choices of 4 and 84 are arbitrary; 4 is a small value that is
-// still bigger than an int128, and 84 is a large value we will want to use
-// in the from_chars implementation.
-//
-// Comments justifying the use of 84 belong in the from_chars implementation,
-// and will be added in a follow-up CL.
-extern template class BigUnsigned<4>;
-extern template class BigUnsigned<84>;
 
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+        // Explicit instantiation declarations for the sizes of BigUnsigned that we
+        // are using.
+        //
+        // For now, the choices of 4 and 84 are arbitrary; 4 is a small value that is
+        // still bigger than an int128, and 84 is a large value we will want to use
+        // in the from_chars implementation.
+        //
+        // Comments justifying the use of 84 belong in the from_chars implementation,
+        // and will be added in a follow-up CL.
+        extern template class BigUnsigned<4>;
+        extern template class BigUnsigned<84>;
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/charconv_parse.h b/CAPI/cpp/grpc/include/absl/strings/internal/charconv_parse.h
index 505998b..3452359 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/charconv_parse.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/charconv_parse.h
@@ -20,80 +20,85 @@
 #include "absl/base/config.h"
 #include "absl/strings/charconv.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
 
-// Enum indicating whether a parsed float is a number or special value.
-enum class FloatType { kNumber, kInfinity, kNan };
+        // Enum indicating whether a parsed float is a number or special value.
+        enum class FloatType
+        {
+            kNumber,
+            kInfinity,
+            kNan
+        };
 
-// The decomposed parts of a parsed `float` or `double`.
-struct ParsedFloat {
-  // Representation of the parsed mantissa, with the decimal point adjusted to
-  // make it an integer.
-  //
-  // During decimal scanning, this contains 19 significant digits worth of
-  // mantissa value.  If digits beyond this point are found, they
-  // are truncated, and if any of these dropped digits are nonzero, then
-  // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
-  // subrange_end).
-  //
-  // During hexadecimal scanning, this contains 15 significant hex digits worth
-  // of mantissa value.  Digits beyond this point are sticky -- they are
-  // truncated, but if any dropped digits are nonzero, the low bit of mantissa
-  // will be set.  (This allows for precise rounding, and avoids the need
-  // to store the full mantissa in [subrange_begin, subrange_end).)
-  uint64_t mantissa = 0;
+        // The decomposed parts of a parsed `float` or `double`.
+        struct ParsedFloat
+        {
+            // Representation of the parsed mantissa, with the decimal point adjusted to
+            // make it an integer.
+            //
+            // During decimal scanning, this contains 19 significant digits worth of
+            // mantissa value.  If digits beyond this point are found, they
+            // are truncated, and if any of these dropped digits are nonzero, then
+            // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
+            // subrange_end).
+            //
+            // During hexadecimal scanning, this contains 15 significant hex digits worth
+            // of mantissa value.  Digits beyond this point are sticky -- they are
+            // truncated, but if any dropped digits are nonzero, the low bit of mantissa
+            // will be set.  (This allows for precise rounding, and avoids the need
+            // to store the full mantissa in [subrange_begin, subrange_end).)
+            uint64_t mantissa = 0;
 
-  // Floating point expontent.  This reflects any decimal point adjustments and
-  // any truncated digits from the mantissa.  The absolute value of the parsed
-  // number is represented by mantissa * (base ** exponent), where base==10 for
-  // decimal floats, and base==2 for hexadecimal floats.
-  int exponent = 0;
+            // Floating point expontent.  This reflects any decimal point adjustments and
+            // any truncated digits from the mantissa.  The absolute value of the parsed
+            // number is represented by mantissa * (base ** exponent), where base==10 for
+            // decimal floats, and base==2 for hexadecimal floats.
+            int exponent = 0;
 
-  // The literal exponent value scanned from the input, or 0 if none was
-  // present.  This does not reflect any adjustments applied to mantissa.
-  int literal_exponent = 0;
+            // The literal exponent value scanned from the input, or 0 if none was
+            // present.  This does not reflect any adjustments applied to mantissa.
+            int literal_exponent = 0;
 
-  // The type of number scanned.
-  FloatType type = FloatType::kNumber;
+            // The type of number scanned.
+            FloatType type = FloatType::kNumber;
 
-  // When non-null, [subrange_begin, subrange_end) marks a range of characters
-  // that require further processing.  The meaning is dependent on float type.
-  // If type == kNumber and this is set, this is a "wide input": the input
-  // mantissa contained more than 19 digits.  The range contains the full
-  // mantissa.  It plus `literal_exponent` need to be examined to find the best
-  // floating point match.
-  // If type == kNan and this is set, the range marks the contents of a
-  // matched parenthesized character region after the NaN.
-  const char* subrange_begin = nullptr;
-  const char* subrange_end = nullptr;
+            // When non-null, [subrange_begin, subrange_end) marks a range of characters
+            // that require further processing.  The meaning is dependent on float type.
+            // If type == kNumber and this is set, this is a "wide input": the input
+            // mantissa contained more than 19 digits.  The range contains the full
+            // mantissa.  It plus `literal_exponent` need to be examined to find the best
+            // floating point match.
+            // If type == kNan and this is set, the range marks the contents of a
+            // matched parenthesized character region after the NaN.
+            const char* subrange_begin = nullptr;
+            const char* subrange_end = nullptr;
 
-  // One-past-the-end of the successfully parsed region, or nullptr if no
-  // matching pattern was found.
-  const char* end = nullptr;
-};
+            // One-past-the-end of the successfully parsed region, or nullptr if no
+            // matching pattern was found.
+            const char* end = nullptr;
+        };
 
-// Read the floating point number in the provided range, and populate
-// ParsedFloat accordingly.
-//
-// format_flags is a bitmask value specifying what patterns this API will match.
-// `scientific` and `fixed`  are honored per std::from_chars rules
-// ([utility.from.chars], C++17): if exactly one of these bits is set, then an
-// exponent is required, or dislallowed, respectively.
-//
-// Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is
-// *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat.
-template <int base>
-ParsedFloat ParseFloat(const char* begin, const char* end,
-                       absl::chars_format format_flags);
+        // Read the floating point number in the provided range, and populate
+        // ParsedFloat accordingly.
+        //
+        // format_flags is a bitmask value specifying what patterns this API will match.
+        // `scientific` and `fixed`  are honored per std::from_chars rules
+        // ([utility.from.chars], C++17): if exactly one of these bits is set, then an
+        // exponent is required, or dislallowed, respectively.
+        //
+        // Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is
+        // *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat.
+        template<int base>
+        ParsedFloat ParseFloat(const char* begin, const char* end, absl::chars_format format_flags);
 
-extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
-                                           absl::chars_format format_flags);
-extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
-                                           absl::chars_format format_flags);
+        extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end, absl::chars_format format_flags);
+        extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end, absl::chars_format format_flags);
 
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_data_edge.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_data_edge.h
index e18b33e..f16a883 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_data_edge.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_data_edge.h
@@ -23,41 +23,46 @@
 #include "absl/strings/internal/cord_rep_flat.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Returns true if the provided rep is a FLAT, EXTERNAL or a SUBSTRING node
-// holding a FLAT or EXTERNAL child rep. Requires `rep != nullptr`.
-inline bool IsDataEdge(const CordRep* edge) {
-  assert(edge != nullptr);
-
-  // The fast path is that `edge` is an EXTERNAL or FLAT node, making the below
-  // if a single, well predicted branch. We then repeat the FLAT or EXTERNAL
-  // check in the slow path of the SUBSTRING check to optimize for the hot path.
-  if (edge->tag == EXTERNAL || edge->tag >= FLAT) return true;
-  if (edge->tag == SUBSTRING) edge = edge->substring()->child;
-  return edge->tag == EXTERNAL || edge->tag >= FLAT;
-}
-
-// Returns the `absl::string_view` data reference for the provided data edge.
-// Requires 'IsDataEdge(edge) == true`.
-inline absl::string_view EdgeData(const CordRep* edge) {
-  assert(IsDataEdge(edge));
-
-  size_t offset = 0;
-  const size_t length = edge->length;
-  if (edge->IsSubstring()) {
-    offset = edge->substring()->start;
-    edge = edge->substring()->child;
-  }
-  return edge->tag >= FLAT
-             ? absl::string_view{edge->flat()->Data() + offset, length}
-             : absl::string_view{edge->external()->base + offset, length};
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // Returns true if the provided rep is a FLAT, EXTERNAL or a SUBSTRING node
+        // holding a FLAT or EXTERNAL child rep. Requires `rep != nullptr`.
+        inline bool IsDataEdge(const CordRep* edge)
+        {
+            assert(edge != nullptr);
+
+            // The fast path is that `edge` is an EXTERNAL or FLAT node, making the below
+            // if a single, well predicted branch. We then repeat the FLAT or EXTERNAL
+            // check in the slow path of the SUBSTRING check to optimize for the hot path.
+            if (edge->tag == EXTERNAL || edge->tag >= FLAT)
+                return true;
+            if (edge->tag == SUBSTRING)
+                edge = edge->substring()->child;
+            return edge->tag == EXTERNAL || edge->tag >= FLAT;
+        }
+
+        // Returns the `absl::string_view` data reference for the provided data edge.
+        // Requires 'IsDataEdge(edge) == true`.
+        inline absl::string_view EdgeData(const CordRep* edge)
+        {
+            assert(IsDataEdge(edge));
+
+            size_t offset = 0;
+            const size_t length = edge->length;
+            if (edge->IsSubstring())
+            {
+                offset = edge->substring()->start;
+                edge = edge->substring()->child;
+            }
+            return edge->tag >= FLAT ? absl::string_view{edge->flat()->Data() + offset, length} : absl::string_view{edge->external()->base + offset, length};
+        }
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_DATA_EDGE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_internal.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_internal.h
index b50fb79..f373152 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_internal.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_internal.h
@@ -30,626 +30,737 @@
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// The overhead of a vtable is too much for Cord, so we roll our own subclasses
-// using only a single byte to differentiate classes from each other - the "tag"
-// byte.  Define the subclasses first so we can provide downcasting helper
-// functions in the base class.
-struct CordRep;
-struct CordRepConcat;
-struct CordRepExternal;
-struct CordRepFlat;
-struct CordRepSubstring;
-struct CordRepCrc;
-class CordRepRing;
-class CordRepBtree;
-
-class CordzInfo;
-
-// Default feature enable states for cord ring buffers
-enum CordFeatureDefaults {
-  kCordEnableRingBufferDefault = false,
-  kCordShallowSubcordsDefault = false
-};
-
-extern std::atomic<bool> cord_ring_buffer_enabled;
-extern std::atomic<bool> shallow_subcords_enabled;
-
-// `cord_btree_exhaustive_validation` can be set to force exhaustive validation
-// in debug assertions, and code that calls `IsValid()` explicitly. By default,
-// assertions should be relatively cheap and AssertValid() can easily lead to
-// O(n^2) complexity as recursive / full tree validation is O(n).
-extern std::atomic<bool> cord_btree_exhaustive_validation;
-
-inline void enable_cord_ring_buffer(bool enable) {
-  cord_ring_buffer_enabled.store(enable, std::memory_order_relaxed);
-}
-
-inline void enable_shallow_subcords(bool enable) {
-  shallow_subcords_enabled.store(enable, std::memory_order_relaxed);
-}
-
-enum Constants {
-  // The inlined size to use with absl::InlinedVector.
-  //
-  // Note: The InlinedVectors in this file (and in cord.h) do not need to use
-  // the same value for their inlined size. The fact that they do is historical.
-  // It may be desirable for each to use a different inlined size optimized for
-  // that InlinedVector's usage.
-  //
-  // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for
-  // the inlined vector size (47 exists for backward compatibility).
-  kInlinedVectorSize = 47,
-
-  // Prefer copying blocks of at most this size, otherwise reference count.
-  kMaxBytesToCopy = 511
-};
-
-// Emits a fatal error "Unexpected node type: xyz" and aborts the program.
-ABSL_ATTRIBUTE_NORETURN void LogFatalNodeType(CordRep* rep);
-
-// Compact class for tracking the reference count and state flags for CordRep
-// instances.  Data is stored in an atomic int32_t for compactness and speed.
-class RefcountAndFlags {
- public:
-  constexpr RefcountAndFlags() : count_{kRefIncrement} {}
-  struct Immortal {};
-  explicit constexpr RefcountAndFlags(Immortal) : count_(kImmortalFlag) {}
-
-  // Increments the reference count. Imposes no memory ordering.
-  inline void Increment() {
-    count_.fetch_add(kRefIncrement, std::memory_order_relaxed);
-  }
-
-  // Asserts that the current refcount is greater than 0. If the refcount is
-  // greater than 1, decrements the reference count.
-  //
-  // Returns false if there are no references outstanding; true otherwise.
-  // Inserts barriers to ensure that state written before this method returns
-  // false will be visible to a thread that just observed this method returning
-  // false.  Always returns false when the immortal bit is set.
-  inline bool Decrement() {
-    int32_t refcount = count_.load(std::memory_order_acquire) & kRefcountMask;
-    assert(refcount > 0 || refcount & kImmortalFlag);
-    return refcount != kRefIncrement &&
-           (count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
-            kRefcountMask) != kRefIncrement;
-  }
-
-  // Same as Decrement but expect that refcount is greater than 1.
-  inline bool DecrementExpectHighRefcount() {
-    int32_t refcount =
-        count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
-        kRefcountMask;
-    assert(refcount > 0 || refcount & kImmortalFlag);
-    return refcount != kRefIncrement;
-  }
-
-  // Returns the current reference count using acquire semantics.
-  inline int32_t Get() const {
-    return count_.load(std::memory_order_acquire) >> kNumFlags;
-  }
-
-  // Returns whether the atomic integer is 1.
-  // If the reference count is used in the conventional way, a
-  // reference count of 1 implies that the current thread owns the
-  // reference and no other thread shares it.
-  // This call performs the test for a reference count of one, and
-  // performs the memory barrier needed for the owning thread
-  // to act on the object, knowing that it has exclusive access to the
-  // object.  Always returns false when the immortal bit is set.
-  inline bool IsOne() {
-    return (count_.load(std::memory_order_acquire) & kRefcountMask) ==
-           kRefIncrement;
-  }
-
-  bool IsImmortal() const {
-    return (count_.load(std::memory_order_relaxed) & kImmortalFlag) != 0;
-  }
-
- private:
-  // We reserve the bottom bits for flags.
-  // kImmortalBit indicates that this entity should never be collected; it is
-  // used for the StringConstant constructor to avoid collecting immutable
-  // constant cords.
-  // kReservedFlag is reserved for future use.
-  enum Flags {
-    kNumFlags = 2,
-
-    kImmortalFlag = 0x1,
-    kReservedFlag = 0x2,
-    kRefIncrement = (1 << kNumFlags),
-
-    // Bitmask to use when checking refcount by equality.  This masks out
-    // all flags except kImmortalFlag, which is part of the refcount for
-    // purposes of equality.  (A refcount of 0 or 1 does not count as 0 or 1
-    // if the immortal bit is set.)
-    kRefcountMask = ~kReservedFlag,
-  };
-
-  std::atomic<int32_t> count_;
-};
-
-// Various representations that we allow
-enum CordRepKind {
-  UNUSED_0 = 0,
-  SUBSTRING = 1,
-  CRC = 2,
-  BTREE = 3,
-  RING = 4,
-  EXTERNAL = 5,
-
-  // We have different tags for different sized flat arrays,
-  // starting with FLAT, and limited to MAX_FLAT_TAG. The below values map to an
-  // allocated range of 32 bytes to 256 KB. The current granularity is:
-  // - 8 byte granularity for flat sizes in [32 - 512]
-  // - 64 byte granularity for flat sizes in (512 - 8KiB]
-  // - 4KiB byte granularity for flat sizes in (8KiB, 256 KiB]
-  // If a new tag is needed in the future, then 'FLAT' and 'MAX_FLAT_TAG' should
-  // be adjusted as well as the Tag <---> Size mapping logic so that FLAT still
-  // represents the minimum flat allocation size. (32 bytes as of now).
-  FLAT = 6,
-  MAX_FLAT_TAG = 248
-};
-
-// There are various locations where we want to check if some rep is a 'plain'
-// data edge, i.e. an external or flat rep. By having FLAT == EXTERNAL + 1, we
-// can perform this check in a single branch as 'tag >= EXTERNAL'
-// Likewise, we have some locations where we check for 'ring or external/flat',
-// so likewise align RING to EXTERNAL.
-// Note that we can leave this optimization to the compiler. The compiler will
-// DTRT when it sees a condition like `tag == EXTERNAL || tag >= FLAT`.
-static_assert(RING == BTREE + 1, "BTREE and RING not consecutive");
-static_assert(EXTERNAL == RING + 1, "BTREE and EXTERNAL not consecutive");
-static_assert(FLAT == EXTERNAL + 1, "EXTERNAL and FLAT not consecutive");
-
-struct CordRep {
-  // Result from an `extract edge` operation. Contains the (possibly changed)
-  // tree node as well as the extracted edge, or {tree, nullptr} if no edge
-  // could be extracted.
-  // On success, the returned `tree` value is null if `extracted` was the only
-  // data edge inside the tree, a data edge if there were only two data edges in
-  // the tree, or the (possibly new / smaller) remaining tree with the extracted
-  // data edge removed.
-  struct ExtractResult {
-    CordRep* tree;
-    CordRep* extracted;
-  };
-
-  CordRep() = default;
-  constexpr CordRep(RefcountAndFlags::Immortal immortal, size_t l)
-      : length(l), refcount(immortal), tag(EXTERNAL), storage{} {}
-
-  // The following three fields have to be less than 32 bytes since
-  // that is the smallest supported flat node size.
-  size_t length;
-  RefcountAndFlags refcount;
-  // If tag < FLAT, it represents CordRepKind and indicates the type of node.
-  // Otherwise, the node type is CordRepFlat and the tag is the encoded size.
-  uint8_t tag;
-
-  // `storage` provides two main purposes:
-  // - the starting point for FlatCordRep.Data() [flexible-array-member]
-  // - 3 bytes of additional storage for use by derived classes.
-  // The latter is used by CordrepConcat and CordRepBtree. CordRepConcat stores
-  // a 'depth' value in storage[0], and the (future) CordRepBtree class stores
-  // `height`, `begin` and `end` in the 3 entries. Otherwise we would need to
-  // allocate room for these in the derived class, as not all compilers reuse
-  // padding space from the base class (clang and gcc do, MSVC does not, etc)
-  uint8_t storage[3];
-
-  // Returns true if this instance's tag matches the requested type.
-  constexpr bool IsRing() const { return tag == RING; }
-  constexpr bool IsSubstring() const { return tag == SUBSTRING; }
-  constexpr bool IsCrc() const { return tag == CRC; }
-  constexpr bool IsExternal() const { return tag == EXTERNAL; }
-  constexpr bool IsFlat() const { return tag >= FLAT; }
-  constexpr bool IsBtree() const { return tag == BTREE; }
-
-  inline CordRepRing* ring();
-  inline const CordRepRing* ring() const;
-  inline CordRepSubstring* substring();
-  inline const CordRepSubstring* substring() const;
-  inline CordRepCrc* crc();
-  inline const CordRepCrc* crc() const;
-  inline CordRepExternal* external();
-  inline const CordRepExternal* external() const;
-  inline CordRepFlat* flat();
-  inline const CordRepFlat* flat() const;
-  inline CordRepBtree* btree();
-  inline const CordRepBtree* btree() const;
-
-  // --------------------------------------------------------------------
-  // Memory management
-
-  // Destroys the provided `rep`.
-  static void Destroy(CordRep* rep);
-
-  // Increments the reference count of `rep`.
-  // Requires `rep` to be a non-null pointer value.
-  static inline CordRep* Ref(CordRep* rep);
-
-  // Decrements the reference count of `rep`. Destroys rep if count reaches
-  // zero. Requires `rep` to be a non-null pointer value.
-  static inline void Unref(CordRep* rep);
-};
-
-struct CordRepSubstring : public CordRep {
-  size_t start;  // Starting offset of substring in child
-  CordRep* child;
-
-  // Creates a substring on `child`, adopting a reference on `child`.
-  // Requires `child` to be either a flat or external node, and `pos` and `n` to
-  // form a non-empty partial sub range of `'child`, i.e.:
-  // `n > 0 && n < length && n + pos <= length`
-  static inline CordRepSubstring* Create(CordRep* child, size_t pos, size_t n);
-
-  // Creates a substring of `rep`. Does not adopt a reference on `rep`.
-  // Requires `IsDataEdge(rep) && n > 0 && pos + n <= rep->length`.
-  // If `n == rep->length` then this method returns `CordRep::Ref(rep)`
-  // If `rep` is a substring of a flat or external node, then this method will
-  // return a new substring of that flat or external node with `pos` adjusted
-  // with the original `start` position.
-  static inline CordRep* Substring(CordRep* rep, size_t pos, size_t n);
-};
-
-// Type for function pointer that will invoke the releaser function and also
-// delete the `CordRepExternalImpl` corresponding to the passed in
-// `CordRepExternal`.
-using ExternalReleaserInvoker = void (*)(CordRepExternal*);
-
-// External CordReps are allocated together with a type erased releaser. The
-// releaser is stored in the memory directly following the CordRepExternal.
-struct CordRepExternal : public CordRep {
-  CordRepExternal() = default;
-  explicit constexpr CordRepExternal(absl::string_view str)
-      : CordRep(RefcountAndFlags::Immortal{}, str.size()),
-        base(str.data()),
-        releaser_invoker(nullptr) {}
-
-  const char* base;
-  // Pointer to function that knows how to call and destroy the releaser.
-  ExternalReleaserInvoker releaser_invoker;
-
-  // Deletes (releases) the external rep.
-  // Requires rep != nullptr and rep->IsExternal()
-  static void Delete(CordRep* rep);
-};
-
-struct Rank1 {};
-struct Rank0 : Rank1 {};
-
-template <typename Releaser, typename = ::absl::base_internal::invoke_result_t<
-                                 Releaser, absl::string_view>>
-void InvokeReleaser(Rank0, Releaser&& releaser, absl::string_view data) {
-  ::absl::base_internal::invoke(std::forward<Releaser>(releaser), data);
-}
-
-template <typename Releaser,
-          typename = ::absl::base_internal::invoke_result_t<Releaser>>
-void InvokeReleaser(Rank1, Releaser&& releaser, absl::string_view) {
-  ::absl::base_internal::invoke(std::forward<Releaser>(releaser));
-}
-
-// We use CompressedTuple so that we can benefit from EBCO.
-template <typename Releaser>
-struct CordRepExternalImpl
-    : public CordRepExternal,
-      public ::absl::container_internal::CompressedTuple<Releaser> {
-  // The extra int arg is so that we can avoid interfering with copy/move
-  // constructors while still benefitting from perfect forwarding.
-  template <typename T>
-  CordRepExternalImpl(T&& releaser, int)
-      : CordRepExternalImpl::CompressedTuple(std::forward<T>(releaser)) {
-    this->releaser_invoker = &Release;
-  }
-
-  ~CordRepExternalImpl() {
-    InvokeReleaser(Rank0{}, std::move(this->template get<0>()),
-                   absl::string_view(base, length));
-  }
-
-  static void Release(CordRepExternal* rep) {
-    delete static_cast<CordRepExternalImpl*>(rep);
-  }
-};
-
-inline CordRepSubstring* CordRepSubstring::Create(CordRep* child, size_t pos,
-                                                  size_t n) {
-  assert(child != nullptr);
-  assert(n > 0);
-  assert(n < child->length);
-  assert(pos < child->length);
-  assert(n <= child->length - pos);
-
-  // TODO(b/217376272): Harden internal logic.
-  // Move to strategical places inside the Cord logic and make this an assert.
-  if (ABSL_PREDICT_FALSE(!(child->IsExternal() || child->IsFlat()))) {
-    LogFatalNodeType(child);
-  }
-
-  CordRepSubstring* rep = new CordRepSubstring();
-  rep->length = n;
-  rep->tag = SUBSTRING;
-  rep->start = pos;
-  rep->child = child;
-  return rep;
-}
-
-inline CordRep* CordRepSubstring::Substring(CordRep* rep, size_t pos,
-                                            size_t n) {
-  assert(rep != nullptr);
-  assert(n != 0);
-  assert(pos < rep->length);
-  assert(n <= rep->length - pos);
-  if (n == rep->length) return CordRep::Ref(rep);
-  if (rep->IsSubstring()) {
-    pos += rep->substring()->start;
-    rep = rep->substring()->child;
-  }
-  CordRepSubstring* substr = new CordRepSubstring();
-  substr->length = n;
-  substr->tag = SUBSTRING;
-  substr->start = pos;
-  substr->child = CordRep::Ref(rep);
-  return substr;
-}
-
-inline void CordRepExternal::Delete(CordRep* rep) {
-  assert(rep != nullptr && rep->IsExternal());
-  auto* rep_external = static_cast<CordRepExternal*>(rep);
-  assert(rep_external->releaser_invoker != nullptr);
-  rep_external->releaser_invoker(rep_external);
-}
-
-template <typename Str>
-struct ConstInitExternalStorage {
-  ABSL_CONST_INIT static CordRepExternal value;
-};
-
-template <typename Str>
-ABSL_CONST_INIT CordRepExternal
-    ConstInitExternalStorage<Str>::value(Str::value);
-
-enum {
-  kMaxInline = 15,
-};
-
-constexpr char GetOrNull(absl::string_view data, size_t pos) {
-  return pos < data.size() ? data[pos] : '\0';
-}
-
-// We store cordz_info as 64 bit pointer value in big endian format. This
-// guarantees that the least significant byte of cordz_info matches the last
-// byte of the inline data representation in as_chars_, which holds the inlined
-// size or the 'is_tree' bit.
-using cordz_info_t = int64_t;
-
-// Assert that the `cordz_info` pointer value perfectly overlaps the last half
-// of `as_chars_` and can hold a pointer value.
-static_assert(sizeof(cordz_info_t) * 2 == kMaxInline + 1, "");
-static_assert(sizeof(cordz_info_t) >= sizeof(intptr_t), "");
-
-// BigEndianByte() creates a big endian representation of 'value', i.e.: a big
-// endian value where the last byte in the host's representation holds 'value`,
-// with all other bytes being 0.
-static constexpr cordz_info_t BigEndianByte(unsigned char value) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // The overhead of a vtable is too much for Cord, so we roll our own subclasses
+        // using only a single byte to differentiate classes from each other - the "tag"
+        // byte.  Define the subclasses first so we can provide downcasting helper
+        // functions in the base class.
+        struct CordRep;
+        struct CordRepConcat;
+        struct CordRepExternal;
+        struct CordRepFlat;
+        struct CordRepSubstring;
+        struct CordRepCrc;
+        class CordRepRing;
+        class CordRepBtree;
+
+        class CordzInfo;
+
+        // Default feature enable states for cord ring buffers
+        enum CordFeatureDefaults
+        {
+            kCordEnableRingBufferDefault = false,
+            kCordShallowSubcordsDefault = false
+        };
+
+        extern std::atomic<bool> cord_ring_buffer_enabled;
+        extern std::atomic<bool> shallow_subcords_enabled;
+
+        // `cord_btree_exhaustive_validation` can be set to force exhaustive validation
+        // in debug assertions, and code that calls `IsValid()` explicitly. By default,
+        // assertions should be relatively cheap and AssertValid() can easily lead to
+        // O(n^2) complexity as recursive / full tree validation is O(n).
+        extern std::atomic<bool> cord_btree_exhaustive_validation;
+
+        inline void enable_cord_ring_buffer(bool enable)
+        {
+            cord_ring_buffer_enabled.store(enable, std::memory_order_relaxed);
+        }
+
+        inline void enable_shallow_subcords(bool enable)
+        {
+            shallow_subcords_enabled.store(enable, std::memory_order_relaxed);
+        }
+
+        enum Constants
+        {
+            // The inlined size to use with absl::InlinedVector.
+            //
+            // Note: The InlinedVectors in this file (and in cord.h) do not need to use
+            // the same value for their inlined size. The fact that they do is historical.
+            // It may be desirable for each to use a different inlined size optimized for
+            // that InlinedVector's usage.
+            //
+            // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for
+            // the inlined vector size (47 exists for backward compatibility).
+            kInlinedVectorSize = 47,
+
+            // Prefer copying blocks of at most this size, otherwise reference count.
+            kMaxBytesToCopy = 511
+        };
+
+        // Emits a fatal error "Unexpected node type: xyz" and aborts the program.
+        ABSL_ATTRIBUTE_NORETURN void LogFatalNodeType(CordRep* rep);
+
+        // Compact class for tracking the reference count and state flags for CordRep
+        // instances.  Data is stored in an atomic int32_t for compactness and speed.
+        class RefcountAndFlags
+        {
+        public:
+            constexpr RefcountAndFlags() :
+                count_{kRefIncrement}
+            {
+            }
+            struct Immortal
+            {
+            };
+            explicit constexpr RefcountAndFlags(Immortal) :
+                count_(kImmortalFlag)
+            {
+            }
+
+            // Increments the reference count. Imposes no memory ordering.
+            inline void Increment()
+            {
+                count_.fetch_add(kRefIncrement, std::memory_order_relaxed);
+            }
+
+            // Asserts that the current refcount is greater than 0. If the refcount is
+            // greater than 1, decrements the reference count.
+            //
+            // Returns false if there are no references outstanding; true otherwise.
+            // Inserts barriers to ensure that state written before this method returns
+            // false will be visible to a thread that just observed this method returning
+            // false.  Always returns false when the immortal bit is set.
+            inline bool Decrement()
+            {
+                int32_t refcount = count_.load(std::memory_order_acquire) & kRefcountMask;
+                assert(refcount > 0 || refcount & kImmortalFlag);
+                return refcount != kRefIncrement &&
+                       (count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
+                        kRefcountMask) != kRefIncrement;
+            }
+
+            // Same as Decrement but expect that refcount is greater than 1.
+            inline bool DecrementExpectHighRefcount()
+            {
+                int32_t refcount =
+                    count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
+                    kRefcountMask;
+                assert(refcount > 0 || refcount & kImmortalFlag);
+                return refcount != kRefIncrement;
+            }
+
+            // Returns the current reference count using acquire semantics.
+            inline int32_t Get() const
+            {
+                return count_.load(std::memory_order_acquire) >> kNumFlags;
+            }
+
+            // Returns whether the atomic integer is 1.
+            // If the reference count is used in the conventional way, a
+            // reference count of 1 implies that the current thread owns the
+            // reference and no other thread shares it.
+            // This call performs the test for a reference count of one, and
+            // performs the memory barrier needed for the owning thread
+            // to act on the object, knowing that it has exclusive access to the
+            // object.  Always returns false when the immortal bit is set.
+            inline bool IsOne()
+            {
+                return (count_.load(std::memory_order_acquire) & kRefcountMask) ==
+                       kRefIncrement;
+            }
+
+            bool IsImmortal() const
+            {
+                return (count_.load(std::memory_order_relaxed) & kImmortalFlag) != 0;
+            }
+
+        private:
+            // We reserve the bottom bits for flags.
+            // kImmortalBit indicates that this entity should never be collected; it is
+            // used for the StringConstant constructor to avoid collecting immutable
+            // constant cords.
+            // kReservedFlag is reserved for future use.
+            enum Flags
+            {
+                kNumFlags = 2,
+
+                kImmortalFlag = 0x1,
+                kReservedFlag = 0x2,
+                kRefIncrement = (1 << kNumFlags),
+
+                // Bitmask to use when checking refcount by equality.  This masks out
+                // all flags except kImmortalFlag, which is part of the refcount for
+                // purposes of equality.  (A refcount of 0 or 1 does not count as 0 or 1
+                // if the immortal bit is set.)
+                kRefcountMask = ~kReservedFlag,
+            };
+
+            std::atomic<int32_t> count_;
+        };
+
+        // Various representations that we allow
+        enum CordRepKind
+        {
+            UNUSED_0 = 0,
+            SUBSTRING = 1,
+            CRC = 2,
+            BTREE = 3,
+            RING = 4,
+            EXTERNAL = 5,
+
+            // We have different tags for different sized flat arrays,
+            // starting with FLAT, and limited to MAX_FLAT_TAG. The below values map to an
+            // allocated range of 32 bytes to 256 KB. The current granularity is:
+            // - 8 byte granularity for flat sizes in [32 - 512]
+            // - 64 byte granularity for flat sizes in (512 - 8KiB]
+            // - 4KiB byte granularity for flat sizes in (8KiB, 256 KiB]
+            // If a new tag is needed in the future, then 'FLAT' and 'MAX_FLAT_TAG' should
+            // be adjusted as well as the Tag <---> Size mapping logic so that FLAT still
+            // represents the minimum flat allocation size. (32 bytes as of now).
+            FLAT = 6,
+            MAX_FLAT_TAG = 248
+        };
+
+        // There are various locations where we want to check if some rep is a 'plain'
+        // data edge, i.e. an external or flat rep. By having FLAT == EXTERNAL + 1, we
+        // can perform this check in a single branch as 'tag >= EXTERNAL'
+        // Likewise, we have some locations where we check for 'ring or external/flat',
+        // so likewise align RING to EXTERNAL.
+        // Note that we can leave this optimization to the compiler. The compiler will
+        // DTRT when it sees a condition like `tag == EXTERNAL || tag >= FLAT`.
+        static_assert(RING == BTREE + 1, "BTREE and RING not consecutive");
+        static_assert(EXTERNAL == RING + 1, "BTREE and EXTERNAL not consecutive");
+        static_assert(FLAT == EXTERNAL + 1, "EXTERNAL and FLAT not consecutive");
+
+        struct CordRep
+        {
+            // Result from an `extract edge` operation. Contains the (possibly changed)
+            // tree node as well as the extracted edge, or {tree, nullptr} if no edge
+            // could be extracted.
+            // On success, the returned `tree` value is null if `extracted` was the only
+            // data edge inside the tree, a data edge if there were only two data edges in
+            // the tree, or the (possibly new / smaller) remaining tree with the extracted
+            // data edge removed.
+            struct ExtractResult
+            {
+                CordRep* tree;
+                CordRep* extracted;
+            };
+
+            CordRep() = default;
+            constexpr CordRep(RefcountAndFlags::Immortal immortal, size_t l) :
+                length(l),
+                refcount(immortal),
+                tag(EXTERNAL),
+                storage{}
+            {
+            }
+
+            // The following three fields have to be less than 32 bytes since
+            // that is the smallest supported flat node size.
+            size_t length;
+            RefcountAndFlags refcount;
+            // If tag < FLAT, it represents CordRepKind and indicates the type of node.
+            // Otherwise, the node type is CordRepFlat and the tag is the encoded size.
+            uint8_t tag;
+
+            // `storage` provides two main purposes:
+            // - the starting point for FlatCordRep.Data() [flexible-array-member]
+            // - 3 bytes of additional storage for use by derived classes.
+            // The latter is used by CordrepConcat and CordRepBtree. CordRepConcat stores
+            // a 'depth' value in storage[0], and the (future) CordRepBtree class stores
+            // `height`, `begin` and `end` in the 3 entries. Otherwise we would need to
+            // allocate room for these in the derived class, as not all compilers reuse
+            // padding space from the base class (clang and gcc do, MSVC does not, etc)
+            uint8_t storage[3];
+
+            // Returns true if this instance's tag matches the requested type.
+            constexpr bool IsRing() const
+            {
+                return tag == RING;
+            }
+            constexpr bool IsSubstring() const
+            {
+                return tag == SUBSTRING;
+            }
+            constexpr bool IsCrc() const
+            {
+                return tag == CRC;
+            }
+            constexpr bool IsExternal() const
+            {
+                return tag == EXTERNAL;
+            }
+            constexpr bool IsFlat() const
+            {
+                return tag >= FLAT;
+            }
+            constexpr bool IsBtree() const
+            {
+                return tag == BTREE;
+            }
+
+            inline CordRepRing* ring();
+            inline const CordRepRing* ring() const;
+            inline CordRepSubstring* substring();
+            inline const CordRepSubstring* substring() const;
+            inline CordRepCrc* crc();
+            inline const CordRepCrc* crc() const;
+            inline CordRepExternal* external();
+            inline const CordRepExternal* external() const;
+            inline CordRepFlat* flat();
+            inline const CordRepFlat* flat() const;
+            inline CordRepBtree* btree();
+            inline const CordRepBtree* btree() const;
+
+            // --------------------------------------------------------------------
+            // Memory management
+
+            // Destroys the provided `rep`.
+            static void Destroy(CordRep* rep);
+
+            // Increments the reference count of `rep`.
+            // Requires `rep` to be a non-null pointer value.
+            static inline CordRep* Ref(CordRep* rep);
+
+            // Decrements the reference count of `rep`. Destroys rep if count reaches
+            // zero. Requires `rep` to be a non-null pointer value.
+            static inline void Unref(CordRep* rep);
+        };
+
+        struct CordRepSubstring : public CordRep
+        {
+            size_t start;  // Starting offset of substring in child
+            CordRep* child;
+
+            // Creates a substring on `child`, adopting a reference on `child`.
+            // Requires `child` to be either a flat or external node, and `pos` and `n` to
+            // form a non-empty partial sub range of `'child`, i.e.:
+            // `n > 0 && n < length && n + pos <= length`
+            static inline CordRepSubstring* Create(CordRep* child, size_t pos, size_t n);
+
+            // Creates a substring of `rep`. Does not adopt a reference on `rep`.
+            // Requires `IsDataEdge(rep) && n > 0 && pos + n <= rep->length`.
+            // If `n == rep->length` then this method returns `CordRep::Ref(rep)`
+            // If `rep` is a substring of a flat or external node, then this method will
+            // return a new substring of that flat or external node with `pos` adjusted
+            // with the original `start` position.
+            static inline CordRep* Substring(CordRep* rep, size_t pos, size_t n);
+        };
+
+        // Type for function pointer that will invoke the releaser function and also
+        // delete the `CordRepExternalImpl` corresponding to the passed in
+        // `CordRepExternal`.
+        using ExternalReleaserInvoker = void (*)(CordRepExternal*);
+
+        // External CordReps are allocated together with a type erased releaser. The
+        // releaser is stored in the memory directly following the CordRepExternal.
+        struct CordRepExternal : public CordRep
+        {
+            CordRepExternal() = default;
+            explicit constexpr CordRepExternal(absl::string_view str) :
+                CordRep(RefcountAndFlags::Immortal{}, str.size()),
+                base(str.data()),
+                releaser_invoker(nullptr)
+            {
+            }
+
+            const char* base;
+            // Pointer to function that knows how to call and destroy the releaser.
+            ExternalReleaserInvoker releaser_invoker;
+
+            // Deletes (releases) the external rep.
+            // Requires rep != nullptr and rep->IsExternal()
+            static void Delete(CordRep* rep);
+        };
+
+        struct Rank1
+        {
+        };
+        struct Rank0 : Rank1
+        {
+        };
+
+        template<typename Releaser, typename = ::absl::base_internal::invoke_result_t<Releaser, absl::string_view>>
+        void InvokeReleaser(Rank0, Releaser&& releaser, absl::string_view data)
+        {
+            ::absl::base_internal::invoke(std::forward<Releaser>(releaser), data);
+        }
+
+        template<typename Releaser, typename = ::absl::base_internal::invoke_result_t<Releaser>>
+        void InvokeReleaser(Rank1, Releaser&& releaser, absl::string_view)
+        {
+            ::absl::base_internal::invoke(std::forward<Releaser>(releaser));
+        }
+
+        // We use CompressedTuple so that we can benefit from EBCO.
+        template<typename Releaser>
+        struct CordRepExternalImpl : public CordRepExternal, public ::absl::container_internal::CompressedTuple<Releaser>
+        {
+            // The extra int arg is so that we can avoid interfering with copy/move
+            // constructors while still benefitting from perfect forwarding.
+            template<typename T>
+            CordRepExternalImpl(T&& releaser, int) :
+                CordRepExternalImpl::CompressedTuple(std::forward<T>(releaser))
+            {
+                this->releaser_invoker = &Release;
+            }
+
+            ~CordRepExternalImpl()
+            {
+                InvokeReleaser(Rank0{}, std::move(this->template get<0>()), absl::string_view(base, length));
+            }
+
+            static void Release(CordRepExternal* rep)
+            {
+                delete static_cast<CordRepExternalImpl*>(rep);
+            }
+        };
+
+        inline CordRepSubstring* CordRepSubstring::Create(CordRep* child, size_t pos, size_t n)
+        {
+            assert(child != nullptr);
+            assert(n > 0);
+            assert(n < child->length);
+            assert(pos < child->length);
+            assert(n <= child->length - pos);
+
+            // TODO(b/217376272): Harden internal logic.
+            // Move to strategical places inside the Cord logic and make this an assert.
+            if (ABSL_PREDICT_FALSE(!(child->IsExternal() || child->IsFlat())))
+            {
+                LogFatalNodeType(child);
+            }
+
+            CordRepSubstring* rep = new CordRepSubstring();
+            rep->length = n;
+            rep->tag = SUBSTRING;
+            rep->start = pos;
+            rep->child = child;
+            return rep;
+        }
+
+        inline CordRep* CordRepSubstring::Substring(CordRep* rep, size_t pos, size_t n)
+        {
+            assert(rep != nullptr);
+            assert(n != 0);
+            assert(pos < rep->length);
+            assert(n <= rep->length - pos);
+            if (n == rep->length)
+                return CordRep::Ref(rep);
+            if (rep->IsSubstring())
+            {
+                pos += rep->substring()->start;
+                rep = rep->substring()->child;
+            }
+            CordRepSubstring* substr = new CordRepSubstring();
+            substr->length = n;
+            substr->tag = SUBSTRING;
+            substr->start = pos;
+            substr->child = CordRep::Ref(rep);
+            return substr;
+        }
+
+        inline void CordRepExternal::Delete(CordRep* rep)
+        {
+            assert(rep != nullptr && rep->IsExternal());
+            auto* rep_external = static_cast<CordRepExternal*>(rep);
+            assert(rep_external->releaser_invoker != nullptr);
+            rep_external->releaser_invoker(rep_external);
+        }
+
+        template<typename Str>
+        struct ConstInitExternalStorage
+        {
+            ABSL_CONST_INIT static CordRepExternal value;
+        };
+
+        template<typename Str>
+        ABSL_CONST_INIT CordRepExternal
+            ConstInitExternalStorage<Str>::value(Str::value);
+
+        enum
+        {
+            kMaxInline = 15,
+        };
+
+        constexpr char GetOrNull(absl::string_view data, size_t pos)
+        {
+            return pos < data.size() ? data[pos] : '\0';
+        }
+
+        // We store cordz_info as 64 bit pointer value in big endian format. This
+        // guarantees that the least significant byte of cordz_info matches the last
+        // byte of the inline data representation in as_chars_, which holds the inlined
+        // size or the 'is_tree' bit.
+        using cordz_info_t = int64_t;
+
+        // Assert that the `cordz_info` pointer value perfectly overlaps the last half
+        // of `as_chars_` and can hold a pointer value.
+        static_assert(sizeof(cordz_info_t) * 2 == kMaxInline + 1, "");
+        static_assert(sizeof(cordz_info_t) >= sizeof(intptr_t), "");
+
+        // BigEndianByte() creates a big endian representation of 'value', i.e.: a big
+        // endian value where the last byte in the host's representation holds 'value`,
+        // with all other bytes being 0.
+        static constexpr cordz_info_t BigEndianByte(unsigned char value)
+        {
 #if defined(ABSL_IS_BIG_ENDIAN)
-  return value;
+            return value;
 #else
-  return static_cast<cordz_info_t>(value) << ((sizeof(cordz_info_t) - 1) * 8);
+            return static_cast<cordz_info_t>(value) << ((sizeof(cordz_info_t) - 1) * 8);
 #endif
-}
-
-class InlineData {
- public:
-  // DefaultInitType forces the use of the default initialization constructor.
-  enum DefaultInitType { kDefaultInit };
-
-  // kNullCordzInfo holds the big endian representation of intptr_t(1)
-  // This is the 'null' / initial value of 'cordz_info'. The null value
-  // is specifically big endian 1 as with 64-bit pointers, the last
-  // byte of cordz_info overlaps with the last byte holding the tag.
-  static constexpr cordz_info_t kNullCordzInfo = BigEndianByte(1);
-
-  constexpr InlineData() : as_chars_{0} {}
-  explicit InlineData(DefaultInitType) {}
-  explicit constexpr InlineData(CordRep* rep) : as_tree_(rep) {}
-  explicit constexpr InlineData(absl::string_view chars)
-      : as_chars_{
-            GetOrNull(chars, 0),  GetOrNull(chars, 1),
-            GetOrNull(chars, 2),  GetOrNull(chars, 3),
-            GetOrNull(chars, 4),  GetOrNull(chars, 5),
-            GetOrNull(chars, 6),  GetOrNull(chars, 7),
-            GetOrNull(chars, 8),  GetOrNull(chars, 9),
-            GetOrNull(chars, 10), GetOrNull(chars, 11),
-            GetOrNull(chars, 12), GetOrNull(chars, 13),
-            GetOrNull(chars, 14), static_cast<char>((chars.size() << 1))} {}
-
-  // Returns true if the current instance is empty.
-  // The 'empty value' is an inlined data value of zero length.
-  bool is_empty() const { return tag() == 0; }
-
-  // Returns true if the current instance holds a tree value.
-  bool is_tree() const { return (tag() & 1) != 0; }
-
-  // Returns true if the current instance holds a cordz_info value.
-  // Requires the current instance to hold a tree value.
-  bool is_profiled() const {
-    assert(is_tree());
-    return as_tree_.cordz_info != kNullCordzInfo;
-  }
-
-  // Returns true if either of the provided instances hold a cordz_info value.
-  // This method is more efficient than the equivalent `data1.is_profiled() ||
-  // data2.is_profiled()`. Requires both arguments to hold a tree.
-  static bool is_either_profiled(const InlineData& data1,
-                                 const InlineData& data2) {
-    assert(data1.is_tree() && data2.is_tree());
-    return (data1.as_tree_.cordz_info | data2.as_tree_.cordz_info) !=
-           kNullCordzInfo;
-  }
-
-  // Returns the cordz_info sampling instance for this instance, or nullptr
-  // if the current instance is not sampled and does not have CordzInfo data.
-  // Requires the current instance to hold a tree value.
-  CordzInfo* cordz_info() const {
-    assert(is_tree());
-    intptr_t info = static_cast<intptr_t>(
-        absl::big_endian::ToHost64(static_cast<uint64_t>(as_tree_.cordz_info)));
-    assert(info & 1);
-    return reinterpret_cast<CordzInfo*>(info - 1);
-  }
-
-  // Sets the current cordz_info sampling instance for this instance, or nullptr
-  // if the current instance is not sampled and does not have CordzInfo data.
-  // Requires the current instance to hold a tree value.
-  void set_cordz_info(CordzInfo* cordz_info) {
-    assert(is_tree());
-    uintptr_t info = reinterpret_cast<uintptr_t>(cordz_info) | 1;
-    as_tree_.cordz_info =
-        static_cast<cordz_info_t>(absl::big_endian::FromHost64(info));
-  }
-
-  // Resets the current cordz_info to null / empty.
-  void clear_cordz_info() {
-    assert(is_tree());
-    as_tree_.cordz_info = kNullCordzInfo;
-  }
-
-  // Returns a read only pointer to the character data inside this instance.
-  // Requires the current instance to hold inline data.
-  const char* as_chars() const {
-    assert(!is_tree());
-    return as_chars_;
-  }
-
-  // Returns a mutable pointer to the character data inside this instance.
-  // Should be used for 'write only' operations setting an inlined value.
-  // Applications can set the value of inlined data either before or after
-  // setting the inlined size, i.e., both of the below are valid:
-  //
-  //   // Set inlined data and inline size
-  //   memcpy(data_.as_chars(), data, size);
-  //   data_.set_inline_size(size);
-  //
-  //   // Set inlined size and inline data
-  //   data_.set_inline_size(size);
-  //   memcpy(data_.as_chars(), data, size);
-  //
-  // It's an error to read from the returned pointer without a preceding write
-  // if the current instance does not hold inline data, i.e.: is_tree() == true.
-  char* as_chars() { return as_chars_; }
-
-  // Returns the tree value of this value.
-  // Requires the current instance to hold a tree value.
-  CordRep* as_tree() const {
-    assert(is_tree());
-    return as_tree_.rep;
-  }
-
-  // Initialize this instance to holding the tree value `rep`,
-  // initializing the cordz_info to null, i.e.: 'not profiled'.
-  void make_tree(CordRep* rep) {
-    as_tree_.rep = rep;
-    as_tree_.cordz_info = kNullCordzInfo;
-  }
-
-  // Set the tree value of this instance to 'rep`.
-  // Requires the current instance to already hold a tree value.
-  // Does not affect the value of cordz_info.
-  void set_tree(CordRep* rep) {
-    assert(is_tree());
-    as_tree_.rep = rep;
-  }
-
-  // Returns the size of the inlined character data inside this instance.
-  // Requires the current instance to hold inline data.
-  size_t inline_size() const {
-    assert(!is_tree());
-    return tag() >> 1;
-  }
-
-  // Sets the size of the inlined character data inside this instance.
-  // Requires `size` to be <= kMaxInline.
-  // See the documentation on 'as_chars()' for more information and examples.
-  void set_inline_size(size_t size) {
-    ABSL_ASSERT(size <= kMaxInline);
-    tag() = static_cast<char>(size << 1);
-  }
-
- private:
-  // See cordz_info_t for forced alignment and size of `cordz_info` details.
-  struct AsTree {
-    explicit constexpr AsTree(absl::cord_internal::CordRep* tree)
-        : rep(tree), cordz_info(kNullCordzInfo) {}
-    // This union uses up extra space so that whether rep is 32 or 64 bits,
-    // cordz_info will still start at the eighth byte, and the last
-    // byte of cordz_info will still be the last byte of InlineData.
-    union {
-      absl::cord_internal::CordRep* rep;
-      cordz_info_t unused_aligner;
-    };
-    cordz_info_t cordz_info;
-  };
-
-  char& tag() { return reinterpret_cast<char*>(this)[kMaxInline]; }
-  char tag() const { return reinterpret_cast<const char*>(this)[kMaxInline]; }
-
-  // If the data has length <= kMaxInline, we store it in `as_chars_`, and
-  // store the size in the last char of `as_chars_` shifted left + 1.
-  // Else we store it in a tree and store a pointer to that tree in
-  // `as_tree_.rep` and store a tag in `tagged_size`.
-  union {
-    char as_chars_[kMaxInline + 1];
-    AsTree as_tree_;
-  };
-};
-
-static_assert(sizeof(InlineData) == kMaxInline + 1, "");
-
-inline CordRepSubstring* CordRep::substring() {
-  assert(IsSubstring());
-  return static_cast<CordRepSubstring*>(this);
-}
-
-inline const CordRepSubstring* CordRep::substring() const {
-  assert(IsSubstring());
-  return static_cast<const CordRepSubstring*>(this);
-}
-
-inline CordRepExternal* CordRep::external() {
-  assert(IsExternal());
-  return static_cast<CordRepExternal*>(this);
-}
-
-inline const CordRepExternal* CordRep::external() const {
-  assert(IsExternal());
-  return static_cast<const CordRepExternal*>(this);
-}
-
-inline CordRep* CordRep::Ref(CordRep* rep) {
-  // ABSL_ASSUME is a workaround for
-  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105585
-  ABSL_ASSUME(rep != nullptr);
-  rep->refcount.Increment();
-  return rep;
-}
-
-inline void CordRep::Unref(CordRep* rep) {
-  assert(rep != nullptr);
-  // Expect refcount to be 0. Avoiding the cost of an atomic decrement should
-  // typically outweigh the cost of an extra branch checking for ref == 1.
-  if (ABSL_PREDICT_FALSE(!rep->refcount.DecrementExpectHighRefcount())) {
-    Destroy(rep);
-  }
-}
-
-}  // namespace cord_internal
-
-ABSL_NAMESPACE_END
+        }
+
+        class InlineData
+        {
+        public:
+            // DefaultInitType forces the use of the default initialization constructor.
+            enum DefaultInitType
+            {
+                kDefaultInit
+            };
+
+            // kNullCordzInfo holds the big endian representation of intptr_t(1)
+            // This is the 'null' / initial value of 'cordz_info'. The null value
+            // is specifically big endian 1 as with 64-bit pointers, the last
+            // byte of cordz_info overlaps with the last byte holding the tag.
+            static constexpr cordz_info_t kNullCordzInfo = BigEndianByte(1);
+
+            constexpr InlineData() :
+                as_chars_{0}
+            {
+            }
+            explicit InlineData(DefaultInitType)
+            {
+            }
+            explicit constexpr InlineData(CordRep* rep) :
+                as_tree_(rep)
+            {
+            }
+            explicit constexpr InlineData(absl::string_view chars) :
+                as_chars_{
+                    GetOrNull(chars, 0), GetOrNull(chars, 1), GetOrNull(chars, 2), GetOrNull(chars, 3), GetOrNull(chars, 4), GetOrNull(chars, 5), GetOrNull(chars, 6), GetOrNull(chars, 7), GetOrNull(chars, 8), GetOrNull(chars, 9), GetOrNull(chars, 10), GetOrNull(chars, 11), GetOrNull(chars, 12), GetOrNull(chars, 13), GetOrNull(chars, 14), static_cast<char>((chars.size() << 1))}
+            {
+            }
+
+            // Returns true if the current instance is empty.
+            // The 'empty value' is an inlined data value of zero length.
+            bool is_empty() const
+            {
+                return tag() == 0;
+            }
+
+            // Returns true if the current instance holds a tree value.
+            bool is_tree() const
+            {
+                return (tag() & 1) != 0;
+            }
+
+            // Returns true if the current instance holds a cordz_info value.
+            // Requires the current instance to hold a tree value.
+            bool is_profiled() const
+            {
+                assert(is_tree());
+                return as_tree_.cordz_info != kNullCordzInfo;
+            }
+
+            // Returns true if either of the provided instances hold a cordz_info value.
+            // This method is more efficient than the equivalent `data1.is_profiled() ||
+            // data2.is_profiled()`. Requires both arguments to hold a tree.
+            static bool is_either_profiled(const InlineData& data1, const InlineData& data2)
+            {
+                assert(data1.is_tree() && data2.is_tree());
+                return (data1.as_tree_.cordz_info | data2.as_tree_.cordz_info) !=
+                       kNullCordzInfo;
+            }
+
+            // Returns the cordz_info sampling instance for this instance, or nullptr
+            // if the current instance is not sampled and does not have CordzInfo data.
+            // Requires the current instance to hold a tree value.
+            CordzInfo* cordz_info() const
+            {
+                assert(is_tree());
+                intptr_t info = static_cast<intptr_t>(
+                    absl::big_endian::ToHost64(static_cast<uint64_t>(as_tree_.cordz_info))
+                );
+                assert(info & 1);
+                return reinterpret_cast<CordzInfo*>(info - 1);
+            }
+
+            // Sets the current cordz_info sampling instance for this instance, or nullptr
+            // if the current instance is not sampled and does not have CordzInfo data.
+            // Requires the current instance to hold a tree value.
+            void set_cordz_info(CordzInfo* cordz_info)
+            {
+                assert(is_tree());
+                uintptr_t info = reinterpret_cast<uintptr_t>(cordz_info) | 1;
+                as_tree_.cordz_info =
+                    static_cast<cordz_info_t>(absl::big_endian::FromHost64(info));
+            }
+
+            // Resets the current cordz_info to null / empty.
+            void clear_cordz_info()
+            {
+                assert(is_tree());
+                as_tree_.cordz_info = kNullCordzInfo;
+            }
+
+            // Returns a read only pointer to the character data inside this instance.
+            // Requires the current instance to hold inline data.
+            const char* as_chars() const
+            {
+                assert(!is_tree());
+                return as_chars_;
+            }
+
+            // Returns a mutable pointer to the character data inside this instance.
+            // Should be used for 'write only' operations setting an inlined value.
+            // Applications can set the value of inlined data either before or after
+            // setting the inlined size, i.e., both of the below are valid:
+            //
+            //   // Set inlined data and inline size
+            //   memcpy(data_.as_chars(), data, size);
+            //   data_.set_inline_size(size);
+            //
+            //   // Set inlined size and inline data
+            //   data_.set_inline_size(size);
+            //   memcpy(data_.as_chars(), data, size);
+            //
+            // It's an error to read from the returned pointer without a preceding write
+            // if the current instance does not hold inline data, i.e.: is_tree() == true.
+            char* as_chars()
+            {
+                return as_chars_;
+            }
+
+            // Returns the tree value of this value.
+            // Requires the current instance to hold a tree value.
+            CordRep* as_tree() const
+            {
+                assert(is_tree());
+                return as_tree_.rep;
+            }
+
+            // Initialize this instance to holding the tree value `rep`,
+            // initializing the cordz_info to null, i.e.: 'not profiled'.
+            void make_tree(CordRep* rep)
+            {
+                as_tree_.rep = rep;
+                as_tree_.cordz_info = kNullCordzInfo;
+            }
+
+            // Set the tree value of this instance to 'rep`.
+            // Requires the current instance to already hold a tree value.
+            // Does not affect the value of cordz_info.
+            void set_tree(CordRep* rep)
+            {
+                assert(is_tree());
+                as_tree_.rep = rep;
+            }
+
+            // Returns the size of the inlined character data inside this instance.
+            // Requires the current instance to hold inline data.
+            size_t inline_size() const
+            {
+                assert(!is_tree());
+                return tag() >> 1;
+            }
+
+            // Sets the size of the inlined character data inside this instance.
+            // Requires `size` to be <= kMaxInline.
+            // See the documentation on 'as_chars()' for more information and examples.
+            void set_inline_size(size_t size)
+            {
+                ABSL_ASSERT(size <= kMaxInline);
+                tag() = static_cast<char>(size << 1);
+            }
+
+        private:
+            // See cordz_info_t for forced alignment and size of `cordz_info` details.
+            struct AsTree
+            {
+                explicit constexpr AsTree(absl::cord_internal::CordRep* tree) :
+                    rep(tree),
+                    cordz_info(kNullCordzInfo)
+                {
+                }
+                // This union uses up extra space so that whether rep is 32 or 64 bits,
+                // cordz_info will still start at the eighth byte, and the last
+                // byte of cordz_info will still be the last byte of InlineData.
+                union
+                {
+                    absl::cord_internal::CordRep* rep;
+                    cordz_info_t unused_aligner;
+                };
+                cordz_info_t cordz_info;
+            };
+
+            char& tag()
+            {
+                return reinterpret_cast<char*>(this)[kMaxInline];
+            }
+            char tag() const
+            {
+                return reinterpret_cast<const char*>(this)[kMaxInline];
+            }
+
+            // If the data has length <= kMaxInline, we store it in `as_chars_`, and
+            // store the size in the last char of `as_chars_` shifted left + 1.
+            // Else we store it in a tree and store a pointer to that tree in
+            // `as_tree_.rep` and store a tag in `tagged_size`.
+            union
+            {
+                char as_chars_[kMaxInline + 1];
+                AsTree as_tree_;
+            };
+        };
+
+        static_assert(sizeof(InlineData) == kMaxInline + 1, "");
+
+        inline CordRepSubstring* CordRep::substring()
+        {
+            assert(IsSubstring());
+            return static_cast<CordRepSubstring*>(this);
+        }
+
+        inline const CordRepSubstring* CordRep::substring() const
+        {
+            assert(IsSubstring());
+            return static_cast<const CordRepSubstring*>(this);
+        }
+
+        inline CordRepExternal* CordRep::external()
+        {
+            assert(IsExternal());
+            return static_cast<CordRepExternal*>(this);
+        }
+
+        inline const CordRepExternal* CordRep::external() const
+        {
+            assert(IsExternal());
+            return static_cast<const CordRepExternal*>(this);
+        }
+
+        inline CordRep* CordRep::Ref(CordRep* rep)
+        {
+            // ABSL_ASSUME is a workaround for
+            // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105585
+            ABSL_ASSUME(rep != nullptr);
+            rep->refcount.Increment();
+            return rep;
+        }
+
+        inline void CordRep::Unref(CordRep* rep)
+        {
+            assert(rep != nullptr);
+            // Expect refcount to be 0. Avoiding the cost of an atomic decrement should
+            // typically outweigh the cost of an extra branch checking for ref == 1.
+            if (ABSL_PREDICT_FALSE(!rep->refcount.DecrementExpectHighRefcount()))
+            {
+                Destroy(rep);
+            }
+        }
+
+    }  // namespace cord_internal
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree.h
index 2cbc09e..887b5ab 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree.h
@@ -28,897 +28,994 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-class CordRepBtreeNavigator;
-
-// CordRepBtree is as the name implies a btree implementation of a Cordrep tree.
-// Data is stored at the leaf level only, non leaf nodes contain down pointers
-// only. Allowed types of data edges are FLAT, EXTERNAL and SUBSTRINGs of FLAT
-// or EXTERNAL nodes. The implementation allows for data to be added to either
-// end of the tree only, it does not provide any 'insert' logic. This has the
-// benefit that we can expect good fill ratios: all nodes except the outer
-// 'legs' will have 100% fill ratios for trees built using Append/Prepend
-// methods. Merged trees will typically have a fill ratio well above 50% as in a
-// similar fashion, one side of the merged tree will typically have a 100% fill
-// ratio, and the 'open' end will average 50%. All operations are O(log(n)) or
-// better, and the tree never needs balancing.
-//
-// All methods accepting a CordRep* or CordRepBtree* adopt a reference on that
-// input unless explicitly stated otherwise. All functions returning a CordRep*
-// or CordRepBtree* instance transfer a reference back to the caller.
-// Simplified, callers both 'donate' and 'consume' a reference count on each
-// call, simplifying the API. An example of building a tree:
-//
-//   CordRepBtree* tree = CordRepBtree::Create(MakeFlat("Hello"));
-//   tree = CordRepBtree::Append(tree, MakeFlat("world"));
-//
-// In the above example, all inputs are consumed, making each call affecting
-// `tree` reference count neutral. The returned `tree` value can be different
-// from the input if the input is shared with other threads, or if the tree
-// grows in height, but callers typically never have to concern themselves with
-// that and trust that all methods DTRT at all times.
-class CordRepBtree : public CordRep {
- public:
-  // EdgeType identifies `front` and `back` enum values.
-  // Various implementations in CordRepBtree such as `Add` and `Edge` are
-  // generic and templated on operating on either of the boundary edges.
-  // For more information on the possible edges contained in a CordRepBtree
-  // instance see the documentation for `edges_`.
-  enum class EdgeType { kFront, kBack };
-
-  // Convenience constants into `EdgeType`
-  static constexpr EdgeType kFront = EdgeType::kFront;
-  static constexpr EdgeType kBack = EdgeType::kBack;
-
-  // Maximum number of edges: based on experiments and performance data, we can
-  // pick suitable values resulting in optimum cacheline aligned values. The
-  // preferred values are based on 64-bit systems where we aim to align this
-  // class onto 64 bytes, i.e.:  6 = 64 bytes, 14 = 128 bytes, etc.
-  // TODO(b/192061034): experiment with alternative sizes.
-  static constexpr size_t kMaxCapacity = 6;
-
-  // Reasonable maximum height of the btree. We can expect a fill ratio of at
-  // least 50%: trees are always expanded at the front or back. Concatenating
-  // trees will then typically fold at the top most node, where the lower nodes
-  // are at least at capacity on one side of joined inputs. At a lower fill
-  // rate of 4 edges per node, we have capacity for ~16 million leaf nodes.
-  // We will fail / abort if an application ever exceeds this height, which
-  // should be extremely rare (near impossible) and be an indication of an
-  // application error: we do not assume it reasonable for any application to
-  // operate correctly with such monster trees.
-  // Another compelling reason for the number `12` is that any contextual stack
-  // required for navigation or insertion requires 12 words and 12 bytes, which
-  // fits inside 2 cache lines with some room to spare, and is reasonable as a
-  // local stack variable compared to Cord's current near 400 bytes stack use.
-  // The maximum `height` value of a node is then `kMaxDepth - 1` as node height
-  // values start with a value of 0 for leaf nodes.
-  static constexpr int kMaxDepth = 12;
-  static constexpr int kMaxHeight = kMaxDepth - 1;
-
-  // `Action` defines the action for unwinding changes done at the btree's leaf
-  // level that need to be propagated up to the parent node(s). Each operation
-  // on a node has an effect / action defined as follows:
-  // - kSelf
-  //   The operation (add / update, etc) was performed directly on the node as
-  //   the node is private to the current thread (i.e.: not shared directly or
-  //   indirectly through a refcount > 1). Changes can be propagated directly to
-  //   all parent nodes as all parent nodes are also then private to the current
-  //   thread.
-  // - kCopied
-  //   The operation (add / update, etc) was performed on a copy of the original
-  //   node, as the node is (potentially) directly or indirectly shared with
-  //   other threads. Changes need to be propagated into the parent nodes where
-  //   the old down pointer must be unreffed and replaced with this new copy.
-  //   Such changes to parent nodes may themselves require a copy if the parent
-  //   node is also shared. A kCopied action can propagate all the way to the
-  //   top node where we then must unref the `tree` input provided by the
-  //   caller, and return the new copy.
-  // - kPopped
-  //   The operation (typically add) could not be satisfied due to insufficient
-  //   capacity in the targeted node, and a new 'leg' was created that needs to
-  //   be added into the parent node. For example, adding a FLAT inside a leaf
-  //   node that is at capacity will create a new leaf node containing that
-  //   FLAT, that needs to be 'popped' up the btree. Such 'pop' actions can
-  //   cascade up the tree if parent nodes are also at capacity. A 'Popped'
-  //   action propagating all the way to the top of the tree will result in
-  //   the tree becoming one level higher than the current tree through a final
-  //   `CordRepBtree::New(tree, popped)` call, resulting in a new top node
-  //   referencing the old tree and the new (fully popped upwards) 'leg'.
-  enum Action { kSelf, kCopied, kPopped };
-
-  // Result of an operation on a node. See the `Action` enum for details.
-  struct OpResult {
-    CordRepBtree* tree;
-    Action action;
-  };
-
-  // Return value of the CopyPrefix and CopySuffix methods which can
-  // return a node or data edge at any height inside the tree.
-  // A height of 0 defines the lowest (leaf) node, a height of -1 identifies
-  // `edge` as being a plain data node: EXTERNAL / FLAT or SUBSTRING thereof.
-  struct CopyResult {
-    CordRep* edge;
-    int height;
-  };
-
-  // Logical position inside a node:
-  // - index: index of the edge.
-  // - n: size or offset value depending on context.
-  struct Position {
-    size_t index;
-    size_t n;
-  };
-
-  // Creates a btree from the given input. Adopts a ref of `rep`.
-  // If the input `rep` is itself a btree, i.e., `IsBtree()`, then this
-  // function immediately returns `rep->btree()`. If the input is a valid data
-  // edge (see IsDataEdge()), then a new leaf node is returned containing `rep`
-  // as the sole data edge. Else, the input is assumed to be a (legacy) concat
-  // tree, and the input is consumed and transformed into a btree().
-  static CordRepBtree* Create(CordRep* rep);
-
-  // Destroys the provided tree. Should only be called by cord internal API's,
-  // typically after a ref_count.Decrement() on the last reference count.
-  static void Destroy(CordRepBtree* tree);
-
-  // Destruction
-  static void Delete(CordRepBtree* tree) { delete tree; }
-
-  // Use CordRep::Unref() as we overload for absl::Span<CordRep* const>.
-  using CordRep::Unref;
-
-  // Unrefs all edges in `edges` which are assumed to be 'likely one'.
-  static void Unref(absl::Span<CordRep* const> edges);
-
-  // Appends / Prepends an existing CordRep instance to this tree.
-  // The below methods accept three types of input:
-  // 1) `rep` is a data node (See `IsDataNode` for valid data edges).
-  // `rep` is appended or prepended to this tree 'as is'.
-  // 2) `rep` is a BTREE.
-  // `rep` is merged into `tree` respecting the Append/Prepend order.
-  // 3) `rep` is some other (legacy) type.
-  // `rep` is converted in place and added to `tree`
-  // Requires `tree` and `rep` to be not null.
-  static CordRepBtree* Append(CordRepBtree* tree, CordRep* rep);
-  static CordRepBtree* Prepend(CordRepBtree* tree, CordRep* rep);
-
-  // Append/Prepend the data in `data` to this tree.
-  // The `extra` parameter defines how much extra capacity should be allocated
-  // for any additional FLAT being allocated. This is an optimization hint from
-  // the caller. For example, a caller may need to add 2 string_views of data
-  // "abc" and "defghi" which are not consecutive. The caller can in this case
-  // invoke `AddData(tree, "abc", 6)`, and any newly added flat is allocated
-  // where possible with at least 6 bytes of extra capacity beyond `length`.
-  // This helps avoiding data getting fragmented over multiple flats.
-  // There is no limit on the size of `data`. If `data` can not be stored inside
-  // a single flat, then the function will iteratively add flats until all data
-  // has been consumed and appended or prepended to the tree.
-  static CordRepBtree* Append(CordRepBtree* tree, string_view data,
-                              size_t extra = 0);
-  static CordRepBtree* Prepend(CordRepBtree* tree, string_view data,
-                               size_t extra = 0);
-
-  // Returns a new tree, containing `n` bytes of data from this instance
-  // starting at offset `offset`. Where possible, the returned tree shares
-  // (re-uses) data edges and nodes with this instance to minimize the
-  // combined memory footprint of both trees.
-  // Requires `offset + n <= length`. Returns `nullptr` if `n` is zero.
-  CordRep* SubTree(size_t offset, size_t n);
-
-  // Removes `n` trailing bytes from `tree`, and returns the resulting tree
-  // or data edge. Returns `tree` if n is zero, and nullptr if n == length.
-  // This function is logically identical to:
-  //   result = tree->SubTree(0, tree->length - n);
-  //   Unref(tree);
-  //   return result;
-  // However, the actual implementation will as much as possible perform 'in
-  // place' modifications on the tree on all nodes and edges that are mutable.
-  // For example, in a fully privately owned tree with the last edge being a
-  // flat of length 12, RemoveSuffix(1) will simply set the length of that data
-  // edge to 11, and reduce the length of all nodes on the edge path by 1.
-  static CordRep* RemoveSuffix(CordRepBtree* tree, size_t n);
-
-  // Returns the character at the given offset.
-  char GetCharacter(size_t offset) const;
-
-  // Returns true if this node holds a single data edge, and if so, sets
-  // `fragment` to reference the contained data. `fragment` is an optional
-  // output parameter and allowed to be null.
-  bool IsFlat(absl::string_view* fragment) const;
-
-  // Returns true if the data of `n` bytes starting at offset `offset`
-  // is contained in a single data edge, and if so, sets fragment to reference
-  // the contained data. `fragment` is an optional output parameter and allowed
-  // to be null.
-  bool IsFlat(size_t offset, size_t n, absl::string_view* fragment) const;
-
-  // Returns a span (mutable range of bytes) of up to `size` bytes into the
-  // last FLAT data edge inside this tree under the following conditions:
-  // - none of the nodes down into the FLAT node are shared.
-  // - the last data edge in this tree is a non-shared FLAT.
-  // - the referenced FLAT has additional capacity available.
-  // If all these conditions are met, a non-empty span is returned, and the
-  // length of the flat node and involved tree nodes have been increased by
-  // `span.length()`. The caller is responsible for immediately assigning values
-  // to all uninitialized data reference by the returned span.
-  // Requires `this->refcount.IsOne()`: this function forces the caller to do
-  // this fast path check on the top level node, as this is the most commonly
-  // shared node of a cord tree.
-  Span<char> GetAppendBuffer(size_t size);
-
-  // Extracts the right-most data edge from this tree iff:
-  // - the tree and all internal edges to the right-most node are not shared.
-  // - the right-most node is a FLAT node and not shared.
-  // - the right-most node has at least the desired extra capacity.
-  //
-  // Returns {tree, nullptr} if any of the above conditions are not met.
-  // This method effectively removes data from the tree. The intent of this
-  // method is to allow applications appending small string data to use
-  // pre-existing capacity, and add the modified rep back to the tree.
-  //
-  // Simplified such code would look similar to this:
-  //   void MyTreeBuilder::Append(string_view data) {
-  //     ExtractResult result = CordRepBtree::ExtractAppendBuffer(tree_, 1);
-  //     if (CordRep* rep = result.extracted) {
-  //       size_t available = rep->Capacity() - rep->length;
-  //       size_t n = std::min(data.size(), n);
-  //       memcpy(rep->Data(), data.data(), n);
-  //       rep->length += n;
-  //       data.remove_prefix(n);
-  //       if (!result.tree->IsBtree()) {
-  //         tree_ = CordRepBtree::Create(result.tree);
-  //       }
-  //       tree_ = CordRepBtree::Append(tree_, rep);
-  //     }
-  //     ...
-  //     // Remaining edge in `result.tree`.
-  //   }
-  static ExtractResult ExtractAppendBuffer(CordRepBtree* tree,
-                                           size_t extra_capacity = 1);
-
-  // Returns the `height` of the tree. The height of a tree is limited to
-  // kMaxHeight. `height` is implemented as an `int` as in some places we
-  // use negative (-1) values for 'data edges'.
-  int height() const { return static_cast<int>(storage[0]); }
-
-  // Properties: begin, back, end, front/back boundary indexes.
-  size_t begin() const { return static_cast<size_t>(storage[1]); }
-  size_t back() const { return static_cast<size_t>(storage[2]) - 1; }
-  size_t end() const { return static_cast<size_t>(storage[2]); }
-  size_t index(EdgeType edge) const {
-    return edge == kFront ? begin() : back();
-  }
-
-  // Properties: size and capacity.
-  // `capacity` contains the current capacity of this instance, where
-  // `kMaxCapacity` contains the maximum capacity of a btree node.
-  // For now, `capacity` and `kMaxCapacity` return the same value, but this may
-  // change in the future if we see benefit in dynamically sizing 'small' nodes
-  // to 'large' nodes for large data trees.
-  size_t size() const { return end() - begin(); }
-  size_t capacity() const { return kMaxCapacity; }
-
-  // Edge access
-  inline CordRep* Edge(size_t index) const;
-  inline CordRep* Edge(EdgeType edge_type) const;
-  inline absl::Span<CordRep* const> Edges() const;
-  inline absl::Span<CordRep* const> Edges(size_t begin, size_t end) const;
-
-  // Returns reference to the data edge at `index`.
-  // Requires this instance to be a leaf node, and `index` to be valid index.
-  inline absl::string_view Data(size_t index) const;
-
-  // Diagnostics: returns true if `tree` is valid and internally consistent.
-  // If `shallow` is false, then the provided top level node and all child nodes
-  // below it are recursively checked. If `shallow` is true, only the provided
-  // node in `tree` and the cumulative length, type and height of the direct
-  // child nodes of `tree` are checked. The value of `shallow` is ignored if the
-  // internal `cord_btree_exhaustive_validation` diagnostics variable is true,
-  // in which case the performed validations works as if `shallow` were false.
-  // This function is intended for debugging and testing purposes only.
-  static bool IsValid(const CordRepBtree* tree, bool shallow = false);
-
-  // Diagnostics: asserts that the provided tree is valid.
-  // `AssertValid()` performs a shallow validation by default. `shallow` can be
-  // set to false in which case an exhaustive validation is performed. This
-  // function is implemented in terms of calling `IsValid()` and asserting the
-  // return value to be true. See `IsValid()` for more information.
-  // This function is intended for debugging and testing purposes only.
-  static CordRepBtree* AssertValid(CordRepBtree* tree, bool shallow = true);
-  static const CordRepBtree* AssertValid(const CordRepBtree* tree,
-                                         bool shallow = true);
-
-  // Diagnostics: dump the contents of this tree to `stream`.
-  // This function is intended for debugging and testing purposes only.
-  static void Dump(const CordRep* rep, std::ostream& stream);
-  static void Dump(const CordRep* rep, absl::string_view label,
-                   std::ostream& stream);
-  static void Dump(const CordRep* rep, absl::string_view label,
-                   bool include_contents, std::ostream& stream);
-
-  // Adds the edge `edge` to this node if possible. `owned` indicates if the
-  // current node is potentially shared or not with other threads. Returns:
-  // - {kSelf, <this>}
-  //   The edge was directly added to this node.
-  // - {kCopied, <node>}
-  //   The edge was added to a copy of this node.
-  // - {kPopped, New(edge, height())}
-  //   A new leg with the edge was created as this node has no extra capacity.
-  template <EdgeType edge_type>
-  inline OpResult AddEdge(bool owned, CordRep* edge, size_t delta);
-
-  // Replaces the front or back edge with the provided new edge. Returns:
-  // - {kSelf, <this>}
-  //   The edge was directly set in this node. The old edge is unreffed.
-  // - {kCopied, <node>}
-  //   A copy of this node was created with the new edge value.
-  // In both cases, the function adopts a reference on `edge`.
-  template <EdgeType edge_type>
-  OpResult SetEdge(bool owned, CordRep* edge, size_t delta);
-
-  // Creates a new empty node at the specified height.
-  static CordRepBtree* New(int height = 0);
-
-  // Creates a new node containing `rep`, with the height being computed
-  // automatically based on the type of `rep`.
-  static CordRepBtree* New(CordRep* rep);
-
-  // Creates a new node containing both `front` and `back` at height
-  // `front.height() + 1`. Requires `back.height() == front.height()`.
-  static CordRepBtree* New(CordRepBtree* front, CordRepBtree* back);
-
-  // Creates a fully balanced tree from the provided tree by rebuilding a new
-  // tree from all data edges in the input. This function is automatically
-  // invoked internally when the tree exceeds the maximum height.
-  static CordRepBtree* Rebuild(CordRepBtree* tree);
-
- private:
-  CordRepBtree() = default;
-  ~CordRepBtree() = default;
-
-  // Initializes the main properties `tag`, `begin`, `end`, `height`.
-  inline void InitInstance(int height, size_t begin = 0, size_t end = 0);
-
-  // Direct property access begin / end
-  void set_begin(size_t begin) { storage[1] = static_cast<uint8_t>(begin); }
-  void set_end(size_t end) { storage[2] = static_cast<uint8_t>(end); }
-
-  // Decreases the value of `begin` by `n`, and returns the new value. Notice
-  // how this returns the new value unlike atomic::fetch_add which returns the
-  // old value. This is because this is used to prepend edges at 'begin - 1'.
-  size_t sub_fetch_begin(size_t n) {
-    storage[1] -= static_cast<uint8_t>(n);
-    return storage[1];
-  }
-
-  // Increases the value of `end` by `n`, and returns the previous value. This
-  // function is typically used to append edges at 'end'.
-  size_t fetch_add_end(size_t n) {
-    const uint8_t current = storage[2];
-    storage[2] = static_cast<uint8_t>(current + n);
-    return current;
-  }
-
-  // Returns the index of the last edge starting on, or before `offset`, with
-  // `n` containing the relative offset of `offset` inside that edge.
-  // Requires `offset` < length.
-  Position IndexOf(size_t offset) const;
-
-  // Returns the index of the last edge starting before `offset`, with `n`
-  // containing the relative offset of `offset` inside that edge.
-  // This function is useful to find the edges for some span of bytes ending at
-  // `offset` (i.e., `n` bytes). For example:
-  //
-  //   Position pos = IndexBefore(n)
-  //   edges = Edges(begin(), pos.index)     // All full edges (may be empty)
-  //   last = Sub(Edge(pos.index), 0, pos.n) // Last partial edge (may be empty)
-  //
-  // Requires 0 < `offset` <= length.
-  Position IndexBefore(size_t offset) const;
-
-  // Returns the index of the edge ending at (or on) length `length`, and the
-  // number of bytes inside that edge up to `length`. For example, if we have a
-  // Node with 2 edges, one of 10 and one of 20 long, then IndexOfLength(27)
-  // will return {1, 17}, and IndexOfLength(10) will return {0, 10}.
-  Position IndexOfLength(size_t n) const;
-
-  // Identical to the above function except starting from the position `front`.
-  // This function is equivalent to `IndexBefore(front.n + offset)`, with
-  // the difference that this function is optimized to start at `front.index`.
-  Position IndexBefore(Position front, size_t offset) const;
-
-  // Returns the index of the edge directly beyond the edge containing offset
-  // `offset`, with `n` containing the distance of that edge from `offset`.
-  // This function is useful for iteratively finding suffix nodes and remaining
-  // partial bytes in left-most suffix nodes as for example in CopySuffix.
-  // Requires `offset` < length.
-  Position IndexBeyond(size_t offset) const;
-
-  // Creates a new leaf node containing as much data as possible from `data`.
-  // The data is added either forwards or reversed depending on `edge_type`.
-  // Callers must check the length of the returned node to determine if all data
-  // was copied or not.
-  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
-  template <EdgeType edge_type>
-  static CordRepBtree* NewLeaf(absl::string_view data, size_t extra);
-
-  // Creates a raw copy of this Btree node, copying all properties, but
-  // without adding any references to existing edges.
-  CordRepBtree* CopyRaw() const;
-
-  // Creates a full copy of this Btree node, adding a reference on all edges.
-  CordRepBtree* Copy() const;
-
-  // Creates a partial copy of this Btree node, copying all edges up to `end`,
-  // adding a reference on each copied edge, and sets the length of the newly
-  // created copy to `new_length`.
-  CordRepBtree* CopyBeginTo(size_t end, size_t new_length) const;
-
-  // Returns a tree containing the edges [tree->begin(), end) and length
-  // of `new_length`. This method consumes a reference on the provided
-  // tree, and logically performs the following operation:
-  //   result = tree->CopyBeginTo(end, new_length);
-  //   CordRep::Unref(tree);
-  //   return result;
-  static CordRepBtree* ConsumeBeginTo(CordRepBtree* tree, size_t end,
-                                      size_t new_length);
-
-  // Creates a partial copy of this Btree node, copying all edges starting at
-  // `begin`, adding a reference on each copied edge, and sets the length of
-  // the newly created copy to `new_length`.
-  CordRepBtree* CopyToEndFrom(size_t begin, size_t new_length) const;
-
-  // Extracts and returns the front edge from the provided tree.
-  // This method consumes a reference on the provided tree, and logically
-  // performs the following operation:
-  //   edge = CordRep::Ref(tree->Edge(kFront));
-  //   CordRep::Unref(tree);
-  //   return edge;
-  static CordRep* ExtractFront(CordRepBtree* tree);
-
-  // Returns a tree containing the result of appending `right` to `left`.
-  static CordRepBtree* MergeTrees(CordRepBtree* left, CordRepBtree* right);
-
-  // Fallback functions for `Create()`, `Append()` and `Prepend()` which
-  // deal with legacy / non conforming input, i.e.: CONCAT trees.
-  static CordRepBtree* CreateSlow(CordRep* rep);
-  static CordRepBtree* AppendSlow(CordRepBtree*, CordRep* rep);
-  static CordRepBtree* PrependSlow(CordRepBtree*, CordRep* rep);
-
-  // Recursively rebuilds `tree` into `stack`. If 'consume` is set to true, the
-  // function will consume a reference on `tree`. `stack` is a null terminated
-  // array containing the new tree's state, with the current leaf node at
-  // stack[0], and parent nodes above that, or null for 'top of tree'.
-  static void Rebuild(CordRepBtree** stack, CordRepBtree* tree, bool consume);
-
-  // Aligns existing edges to start at index 0, to allow for a new edge to be
-  // added to the back of the current edges.
-  inline void AlignBegin();
-
-  // Aligns existing edges to end at `capacity`, to allow for a new edge to be
-  // added in front of the current edges.
-  inline void AlignEnd();
-
-  // Adds the provided edge to this node.
-  // Requires this node to have capacity for the edge. Realigns / moves
-  // existing edges as needed to prepend or append the new edge.
-  template <EdgeType edge_type>
-  inline void Add(CordRep* rep);
-
-  // Adds the provided edges to this node.
-  // Requires this node to have capacity for the edges. Realigns / moves
-  // existing edges as needed to prepend or append the new edges.
-  template <EdgeType edge_type>
-  inline void Add(absl::Span<CordRep* const>);
-
-  // Adds data from `data` to this node until either all data has been consumed,
-  // or there is no more capacity for additional flat nodes inside this node.
-  // Requires the current node to be a leaf node, data to be non empty, and the
-  // current node to have capacity for at least one more data edge.
-  // Returns any remaining data from `data` that was not added, which is
-  // depending on the edge type (front / back) either the remaining prefix of
-  // suffix of the input.
-  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
-  template <EdgeType edge_type>
-  absl::string_view AddData(absl::string_view data, size_t extra);
-
-  // Replace the front or back edge with the provided value.
-  // Adopts a reference on `edge` and unrefs the old edge.
-  template <EdgeType edge_type>
-  inline void SetEdge(CordRep* edge);
-
-  // Returns a partial copy of the current tree containing the first `n` bytes
-  // of data. `CopyResult` contains both the resulting edge and its height. The
-  // resulting tree may be less high than the current tree, or even be a single
-  // matching data edge if `allow_folding` is set to true.
-  // For example, if `n == 1`, then the result will be the single data edge, and
-  // height will be set to -1 (one below the owning leaf node). If n == 0, this
-  // function returns null. Requires `n <= length`
-  CopyResult CopyPrefix(size_t n, bool allow_folding = true);
-
-  // Returns a partial copy of the current tree containing all data starting
-  // after `offset`. `CopyResult` contains both the resulting edge and its
-  // height. The resulting tree may be less high than the current tree, or even
-  // be a single matching data edge. For example, if `n == length - 1`, then the
-  // result will be a single data edge, and height will be set to -1 (one below
-  // the owning leaf node).
-  // Requires `offset < length`
-  CopyResult CopySuffix(size_t offset);
-
-  // Returns a OpResult value of {this, kSelf} or {Copy(), kCopied}
-  // depending on the value of `owned`.
-  inline OpResult ToOpResult(bool owned);
-
-  // Adds `rep` to the specified tree, returning the modified tree.
-  template <EdgeType edge_type>
-  static CordRepBtree* AddCordRep(CordRepBtree* tree, CordRep* rep);
-
-  // Adds `data` to the specified tree, returning the modified tree.
-  // See the `Append/Prepend` function for the meaning and purpose of `extra`.
-  template <EdgeType edge_type>
-  static CordRepBtree* AddData(CordRepBtree* tree, absl::string_view data,
-                               size_t extra = 0);
-
-  // Merges `src` into `dst` with `src` being added either before (kFront) or
-  // after (kBack) `dst`. Requires the height of `dst` to be greater than or
-  // equal to the height of `src`.
-  template <EdgeType edge_type>
-  static CordRepBtree* Merge(CordRepBtree* dst, CordRepBtree* src);
-
-  // Fallback version of GetAppendBuffer for large trees: GetAppendBuffer()
-  // implements an inlined version for trees of limited height (3 levels),
-  // GetAppendBufferSlow implements the logic for large trees.
-  Span<char> GetAppendBufferSlow(size_t size);
-
-  // `edges_` contains all edges starting from this instance.
-  // These are explicitly `child` edges only, a cord btree (or any cord tree in
-  // that respect) does not store `parent` pointers anywhere: multiple trees /
-  // parents can reference the same shared child edge. The type of these edges
-  // depends on the height of the node. `Leaf nodes` (height == 0) contain `data
-  // edges` (external or flat nodes, or sub-strings thereof). All other nodes
-  // (height > 0) contain pointers to BTREE nodes with a height of `height - 1`.
-  CordRep* edges_[kMaxCapacity];
-
-  friend class CordRepBtreeTestPeer;
-  friend class CordRepBtreeNavigator;
-};
-
-inline CordRepBtree* CordRep::btree() {
-  assert(IsBtree());
-  return static_cast<CordRepBtree*>(this);
-}
-
-inline const CordRepBtree* CordRep::btree() const {
-  assert(IsBtree());
-  return static_cast<const CordRepBtree*>(this);
-}
-
-inline void CordRepBtree::InitInstance(int height, size_t begin, size_t end) {
-  tag = BTREE;
-  storage[0] = static_cast<uint8_t>(height);
-  storage[1] = static_cast<uint8_t>(begin);
-  storage[2] = static_cast<uint8_t>(end);
-}
-
-inline CordRep* CordRepBtree::Edge(size_t index) const {
-  assert(index >= begin());
-  assert(index < end());
-  return edges_[index];
-}
-
-inline CordRep* CordRepBtree::Edge(EdgeType edge_type) const {
-  return edges_[edge_type == kFront ? begin() : back()];
-}
-
-inline absl::Span<CordRep* const> CordRepBtree::Edges() const {
-  return {edges_ + begin(), size()};
-}
-
-inline absl::Span<CordRep* const> CordRepBtree::Edges(size_t begin,
-                                                      size_t end) const {
-  assert(begin <= end);
-  assert(begin >= this->begin());
-  assert(end <= this->end());
-  return {edges_ + begin, static_cast<size_t>(end - begin)};
-}
-
-inline absl::string_view CordRepBtree::Data(size_t index) const {
-  assert(height() == 0);
-  return EdgeData(Edge(index));
-}
-
-inline CordRepBtree* CordRepBtree::New(int height) {
-  CordRepBtree* tree = new CordRepBtree;
-  tree->length = 0;
-  tree->InitInstance(height);
-  return tree;
-}
-
-inline CordRepBtree* CordRepBtree::New(CordRep* rep) {
-  CordRepBtree* tree = new CordRepBtree;
-  int height = rep->IsBtree() ? rep->btree()->height() + 1 : 0;
-  tree->length = rep->length;
-  tree->InitInstance(height, /*begin=*/0, /*end=*/1);
-  tree->edges_[0] = rep;
-  return tree;
-}
-
-inline CordRepBtree* CordRepBtree::New(CordRepBtree* front,
-                                       CordRepBtree* back) {
-  assert(front->height() == back->height());
-  CordRepBtree* tree = new CordRepBtree;
-  tree->length = front->length + back->length;
-  tree->InitInstance(front->height() + 1, /*begin=*/0, /*end=*/2);
-  tree->edges_[0] = front;
-  tree->edges_[1] = back;
-  return tree;
-}
-
-inline void CordRepBtree::Unref(absl::Span<CordRep* const> edges) {
-  for (CordRep* edge : edges) {
-    if (ABSL_PREDICT_FALSE(!edge->refcount.Decrement())) {
-      CordRep::Destroy(edge);
-    }
-  }
-}
-
-inline CordRepBtree* CordRepBtree::CopyRaw() const {
-  auto* tree = static_cast<CordRepBtree*>(::operator new(sizeof(CordRepBtree)));
-  memcpy(static_cast<void*>(tree), this, sizeof(CordRepBtree));
-  new (&tree->refcount) RefcountAndFlags;
-  return tree;
-}
-
-inline CordRepBtree* CordRepBtree::Copy() const {
-  CordRepBtree* tree = CopyRaw();
-  for (CordRep* rep : Edges()) CordRep::Ref(rep);
-  return tree;
-}
-
-inline CordRepBtree* CordRepBtree::CopyToEndFrom(size_t begin,
-                                                 size_t new_length) const {
-  assert(begin >= this->begin());
-  assert(begin <= this->end());
-  CordRepBtree* tree = CopyRaw();
-  tree->length = new_length;
-  tree->set_begin(begin);
-  for (CordRep* edge : tree->Edges()) CordRep::Ref(edge);
-  return tree;
-}
-
-inline CordRepBtree* CordRepBtree::CopyBeginTo(size_t end,
-                                               size_t new_length) const {
-  assert(end <= capacity());
-  assert(end >= this->begin());
-  CordRepBtree* tree = CopyRaw();
-  tree->length = new_length;
-  tree->set_end(end);
-  for (CordRep* edge : tree->Edges()) CordRep::Ref(edge);
-  return tree;
-}
-
-inline void CordRepBtree::AlignBegin() {
-  // The below code itself does not need to be fast as typically we have
-  // mono-directional append/prepend calls, and `begin` / `end` are typically
-  // adjusted no more than once. But we want to avoid potential register clobber
-  // effects, making the compiler emit register save/store/spills, and minimize
-  // the size of code.
-  const size_t delta = begin();
-  if (ABSL_PREDICT_FALSE(delta != 0)) {
-    const size_t new_end = end() - delta;
-    set_begin(0);
-    set_end(new_end);
-    // TODO(mvels): we can write this using 2 loads / 2 stores depending on
-    // total size for the kMaxCapacity = 6 case. I.e., we can branch (switch) on
-    // size, and then do overlapping load/store of up to 4 pointers (inlined as
-    // XMM, YMM or ZMM load/store) and up to 2 pointers (XMM / YMM), which is a)
-    // compact and b) not clobbering any registers.
-    ABSL_ASSUME(new_end <= kMaxCapacity);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        class CordRepBtreeNavigator;
+
+        // CordRepBtree is as the name implies a btree implementation of a Cordrep tree.
+        // Data is stored at the leaf level only, non leaf nodes contain down pointers
+        // only. Allowed types of data edges are FLAT, EXTERNAL and SUBSTRINGs of FLAT
+        // or EXTERNAL nodes. The implementation allows for data to be added to either
+        // end of the tree only, it does not provide any 'insert' logic. This has the
+        // benefit that we can expect good fill ratios: all nodes except the outer
+        // 'legs' will have 100% fill ratios for trees built using Append/Prepend
+        // methods. Merged trees will typically have a fill ratio well above 50% as in a
+        // similar fashion, one side of the merged tree will typically have a 100% fill
+        // ratio, and the 'open' end will average 50%. All operations are O(log(n)) or
+        // better, and the tree never needs balancing.
+        //
+        // All methods accepting a CordRep* or CordRepBtree* adopt a reference on that
+        // input unless explicitly stated otherwise. All functions returning a CordRep*
+        // or CordRepBtree* instance transfer a reference back to the caller.
+        // Simplified, callers both 'donate' and 'consume' a reference count on each
+        // call, simplifying the API. An example of building a tree:
+        //
+        //   CordRepBtree* tree = CordRepBtree::Create(MakeFlat("Hello"));
+        //   tree = CordRepBtree::Append(tree, MakeFlat("world"));
+        //
+        // In the above example, all inputs are consumed, making each call affecting
+        // `tree` reference count neutral. The returned `tree` value can be different
+        // from the input if the input is shared with other threads, or if the tree
+        // grows in height, but callers typically never have to concern themselves with
+        // that and trust that all methods DTRT at all times.
+        class CordRepBtree : public CordRep
+        {
+        public:
+            // EdgeType identifies `front` and `back` enum values.
+            // Various implementations in CordRepBtree such as `Add` and `Edge` are
+            // generic and templated on operating on either of the boundary edges.
+            // For more information on the possible edges contained in a CordRepBtree
+            // instance see the documentation for `edges_`.
+            enum class EdgeType
+            {
+                kFront,
+                kBack
+            };
+
+            // Convenience constants into `EdgeType`
+            static constexpr EdgeType kFront = EdgeType::kFront;
+            static constexpr EdgeType kBack = EdgeType::kBack;
+
+            // Maximum number of edges: based on experiments and performance data, we can
+            // pick suitable values resulting in optimum cacheline aligned values. The
+            // preferred values are based on 64-bit systems where we aim to align this
+            // class onto 64 bytes, i.e.:  6 = 64 bytes, 14 = 128 bytes, etc.
+            // TODO(b/192061034): experiment with alternative sizes.
+            static constexpr size_t kMaxCapacity = 6;
+
+            // Reasonable maximum height of the btree. We can expect a fill ratio of at
+            // least 50%: trees are always expanded at the front or back. Concatenating
+            // trees will then typically fold at the top most node, where the lower nodes
+            // are at least at capacity on one side of joined inputs. At a lower fill
+            // rate of 4 edges per node, we have capacity for ~16 million leaf nodes.
+            // We will fail / abort if an application ever exceeds this height, which
+            // should be extremely rare (near impossible) and be an indication of an
+            // application error: we do not assume it reasonable for any application to
+            // operate correctly with such monster trees.
+            // Another compelling reason for the number `12` is that any contextual stack
+            // required for navigation or insertion requires 12 words and 12 bytes, which
+            // fits inside 2 cache lines with some room to spare, and is reasonable as a
+            // local stack variable compared to Cord's current near 400 bytes stack use.
+            // The maximum `height` value of a node is then `kMaxDepth - 1` as node height
+            // values start with a value of 0 for leaf nodes.
+            static constexpr int kMaxDepth = 12;
+            static constexpr int kMaxHeight = kMaxDepth - 1;
+
+            // `Action` defines the action for unwinding changes done at the btree's leaf
+            // level that need to be propagated up to the parent node(s). Each operation
+            // on a node has an effect / action defined as follows:
+            // - kSelf
+            //   The operation (add / update, etc) was performed directly on the node as
+            //   the node is private to the current thread (i.e.: not shared directly or
+            //   indirectly through a refcount > 1). Changes can be propagated directly to
+            //   all parent nodes as all parent nodes are also then private to the current
+            //   thread.
+            // - kCopied
+            //   The operation (add / update, etc) was performed on a copy of the original
+            //   node, as the node is (potentially) directly or indirectly shared with
+            //   other threads. Changes need to be propagated into the parent nodes where
+            //   the old down pointer must be unreffed and replaced with this new copy.
+            //   Such changes to parent nodes may themselves require a copy if the parent
+            //   node is also shared. A kCopied action can propagate all the way to the
+            //   top node where we then must unref the `tree` input provided by the
+            //   caller, and return the new copy.
+            // - kPopped
+            //   The operation (typically add) could not be satisfied due to insufficient
+            //   capacity in the targeted node, and a new 'leg' was created that needs to
+            //   be added into the parent node. For example, adding a FLAT inside a leaf
+            //   node that is at capacity will create a new leaf node containing that
+            //   FLAT, that needs to be 'popped' up the btree. Such 'pop' actions can
+            //   cascade up the tree if parent nodes are also at capacity. A 'Popped'
+            //   action propagating all the way to the top of the tree will result in
+            //   the tree becoming one level higher than the current tree through a final
+            //   `CordRepBtree::New(tree, popped)` call, resulting in a new top node
+            //   referencing the old tree and the new (fully popped upwards) 'leg'.
+            enum Action
+            {
+                kSelf,
+                kCopied,
+                kPopped
+            };
+
+            // Result of an operation on a node. See the `Action` enum for details.
+            struct OpResult
+            {
+                CordRepBtree* tree;
+                Action action;
+            };
+
+            // Return value of the CopyPrefix and CopySuffix methods which can
+            // return a node or data edge at any height inside the tree.
+            // A height of 0 defines the lowest (leaf) node, a height of -1 identifies
+            // `edge` as being a plain data node: EXTERNAL / FLAT or SUBSTRING thereof.
+            struct CopyResult
+            {
+                CordRep* edge;
+                int height;
+            };
+
+            // Logical position inside a node:
+            // - index: index of the edge.
+            // - n: size or offset value depending on context.
+            struct Position
+            {
+                size_t index;
+                size_t n;
+            };
+
+            // Creates a btree from the given input. Adopts a ref of `rep`.
+            // If the input `rep` is itself a btree, i.e., `IsBtree()`, then this
+            // function immediately returns `rep->btree()`. If the input is a valid data
+            // edge (see IsDataEdge()), then a new leaf node is returned containing `rep`
+            // as the sole data edge. Else, the input is assumed to be a (legacy) concat
+            // tree, and the input is consumed and transformed into a btree().
+            static CordRepBtree* Create(CordRep* rep);
+
+            // Destroys the provided tree. Should only be called by cord internal API's,
+            // typically after a ref_count.Decrement() on the last reference count.
+            static void Destroy(CordRepBtree* tree);
+
+            // Destruction
+            static void Delete(CordRepBtree* tree)
+            {
+                delete tree;
+            }
+
+            // Use CordRep::Unref() as we overload for absl::Span<CordRep* const>.
+            using CordRep::Unref;
+
+            // Unrefs all edges in `edges` which are assumed to be 'likely one'.
+            static void Unref(absl::Span<CordRep* const> edges);
+
+            // Appends / Prepends an existing CordRep instance to this tree.
+            // The below methods accept three types of input:
+            // 1) `rep` is a data node (See `IsDataNode` for valid data edges).
+            // `rep` is appended or prepended to this tree 'as is'.
+            // 2) `rep` is a BTREE.
+            // `rep` is merged into `tree` respecting the Append/Prepend order.
+            // 3) `rep` is some other (legacy) type.
+            // `rep` is converted in place and added to `tree`
+            // Requires `tree` and `rep` to be not null.
+            static CordRepBtree* Append(CordRepBtree* tree, CordRep* rep);
+            static CordRepBtree* Prepend(CordRepBtree* tree, CordRep* rep);
+
+            // Append/Prepend the data in `data` to this tree.
+            // The `extra` parameter defines how much extra capacity should be allocated
+            // for any additional FLAT being allocated. This is an optimization hint from
+            // the caller. For example, a caller may need to add 2 string_views of data
+            // "abc" and "defghi" which are not consecutive. The caller can in this case
+            // invoke `AddData(tree, "abc", 6)`, and any newly added flat is allocated
+            // where possible with at least 6 bytes of extra capacity beyond `length`.
+            // This helps avoiding data getting fragmented over multiple flats.
+            // There is no limit on the size of `data`. If `data` can not be stored inside
+            // a single flat, then the function will iteratively add flats until all data
+            // has been consumed and appended or prepended to the tree.
+            static CordRepBtree* Append(CordRepBtree* tree, string_view data, size_t extra = 0);
+            static CordRepBtree* Prepend(CordRepBtree* tree, string_view data, size_t extra = 0);
+
+            // Returns a new tree, containing `n` bytes of data from this instance
+            // starting at offset `offset`. Where possible, the returned tree shares
+            // (re-uses) data edges and nodes with this instance to minimize the
+            // combined memory footprint of both trees.
+            // Requires `offset + n <= length`. Returns `nullptr` if `n` is zero.
+            CordRep* SubTree(size_t offset, size_t n);
+
+            // Removes `n` trailing bytes from `tree`, and returns the resulting tree
+            // or data edge. Returns `tree` if n is zero, and nullptr if n == length.
+            // This function is logically identical to:
+            //   result = tree->SubTree(0, tree->length - n);
+            //   Unref(tree);
+            //   return result;
+            // However, the actual implementation will as much as possible perform 'in
+            // place' modifications on the tree on all nodes and edges that are mutable.
+            // For example, in a fully privately owned tree with the last edge being a
+            // flat of length 12, RemoveSuffix(1) will simply set the length of that data
+            // edge to 11, and reduce the length of all nodes on the edge path by 1.
+            static CordRep* RemoveSuffix(CordRepBtree* tree, size_t n);
+
+            // Returns the character at the given offset.
+            char GetCharacter(size_t offset) const;
+
+            // Returns true if this node holds a single data edge, and if so, sets
+            // `fragment` to reference the contained data. `fragment` is an optional
+            // output parameter and allowed to be null.
+            bool IsFlat(absl::string_view* fragment) const;
+
+            // Returns true if the data of `n` bytes starting at offset `offset`
+            // is contained in a single data edge, and if so, sets fragment to reference
+            // the contained data. `fragment` is an optional output parameter and allowed
+            // to be null.
+            bool IsFlat(size_t offset, size_t n, absl::string_view* fragment) const;
+
+            // Returns a span (mutable range of bytes) of up to `size` bytes into the
+            // last FLAT data edge inside this tree under the following conditions:
+            // - none of the nodes down into the FLAT node are shared.
+            // - the last data edge in this tree is a non-shared FLAT.
+            // - the referenced FLAT has additional capacity available.
+            // If all these conditions are met, a non-empty span is returned, and the
+            // length of the flat node and involved tree nodes have been increased by
+            // `span.length()`. The caller is responsible for immediately assigning values
+            // to all uninitialized data reference by the returned span.
+            // Requires `this->refcount.IsOne()`: this function forces the caller to do
+            // this fast path check on the top level node, as this is the most commonly
+            // shared node of a cord tree.
+            Span<char> GetAppendBuffer(size_t size);
+
+            // Extracts the right-most data edge from this tree iff:
+            // - the tree and all internal edges to the right-most node are not shared.
+            // - the right-most node is a FLAT node and not shared.
+            // - the right-most node has at least the desired extra capacity.
+            //
+            // Returns {tree, nullptr} if any of the above conditions are not met.
+            // This method effectively removes data from the tree. The intent of this
+            // method is to allow applications appending small string data to use
+            // pre-existing capacity, and add the modified rep back to the tree.
+            //
+            // Simplified such code would look similar to this:
+            //   void MyTreeBuilder::Append(string_view data) {
+            //     ExtractResult result = CordRepBtree::ExtractAppendBuffer(tree_, 1);
+            //     if (CordRep* rep = result.extracted) {
+            //       size_t available = rep->Capacity() - rep->length;
+            //       size_t n = std::min(data.size(), n);
+            //       memcpy(rep->Data(), data.data(), n);
+            //       rep->length += n;
+            //       data.remove_prefix(n);
+            //       if (!result.tree->IsBtree()) {
+            //         tree_ = CordRepBtree::Create(result.tree);
+            //       }
+            //       tree_ = CordRepBtree::Append(tree_, rep);
+            //     }
+            //     ...
+            //     // Remaining edge in `result.tree`.
+            //   }
+            static ExtractResult ExtractAppendBuffer(CordRepBtree* tree, size_t extra_capacity = 1);
+
+            // Returns the `height` of the tree. The height of a tree is limited to
+            // kMaxHeight. `height` is implemented as an `int` as in some places we
+            // use negative (-1) values for 'data edges'.
+            int height() const
+            {
+                return static_cast<int>(storage[0]);
+            }
+
+            // Properties: begin, back, end, front/back boundary indexes.
+            size_t begin() const
+            {
+                return static_cast<size_t>(storage[1]);
+            }
+            size_t back() const
+            {
+                return static_cast<size_t>(storage[2]) - 1;
+            }
+            size_t end() const
+            {
+                return static_cast<size_t>(storage[2]);
+            }
+            size_t index(EdgeType edge) const
+            {
+                return edge == kFront ? begin() : back();
+            }
+
+            // Properties: size and capacity.
+            // `capacity` contains the current capacity of this instance, where
+            // `kMaxCapacity` contains the maximum capacity of a btree node.
+            // For now, `capacity` and `kMaxCapacity` return the same value, but this may
+            // change in the future if we see benefit in dynamically sizing 'small' nodes
+            // to 'large' nodes for large data trees.
+            size_t size() const
+            {
+                return end() - begin();
+            }
+            size_t capacity() const
+            {
+                return kMaxCapacity;
+            }
+
+            // Edge access
+            inline CordRep* Edge(size_t index) const;
+            inline CordRep* Edge(EdgeType edge_type) const;
+            inline absl::Span<CordRep* const> Edges() const;
+            inline absl::Span<CordRep* const> Edges(size_t begin, size_t end) const;
+
+            // Returns reference to the data edge at `index`.
+            // Requires this instance to be a leaf node, and `index` to be valid index.
+            inline absl::string_view Data(size_t index) const;
+
+            // Diagnostics: returns true if `tree` is valid and internally consistent.
+            // If `shallow` is false, then the provided top level node and all child nodes
+            // below it are recursively checked. If `shallow` is true, only the provided
+            // node in `tree` and the cumulative length, type and height of the direct
+            // child nodes of `tree` are checked. The value of `shallow` is ignored if the
+            // internal `cord_btree_exhaustive_validation` diagnostics variable is true,
+            // in which case the performed validations works as if `shallow` were false.
+            // This function is intended for debugging and testing purposes only.
+            static bool IsValid(const CordRepBtree* tree, bool shallow = false);
+
+            // Diagnostics: asserts that the provided tree is valid.
+            // `AssertValid()` performs a shallow validation by default. `shallow` can be
+            // set to false in which case an exhaustive validation is performed. This
+            // function is implemented in terms of calling `IsValid()` and asserting the
+            // return value to be true. See `IsValid()` for more information.
+            // This function is intended for debugging and testing purposes only.
+            static CordRepBtree* AssertValid(CordRepBtree* tree, bool shallow = true);
+            static const CordRepBtree* AssertValid(const CordRepBtree* tree, bool shallow = true);
+
+            // Diagnostics: dump the contents of this tree to `stream`.
+            // This function is intended for debugging and testing purposes only.
+            static void Dump(const CordRep* rep, std::ostream& stream);
+            static void Dump(const CordRep* rep, absl::string_view label, std::ostream& stream);
+            static void Dump(const CordRep* rep, absl::string_view label, bool include_contents, std::ostream& stream);
+
+            // Adds the edge `edge` to this node if possible. `owned` indicates if the
+            // current node is potentially shared or not with other threads. Returns:
+            // - {kSelf, <this>}
+            //   The edge was directly added to this node.
+            // - {kCopied, <node>}
+            //   The edge was added to a copy of this node.
+            // - {kPopped, New(edge, height())}
+            //   A new leg with the edge was created as this node has no extra capacity.
+            template<EdgeType edge_type>
+            inline OpResult AddEdge(bool owned, CordRep* edge, size_t delta);
+
+            // Replaces the front or back edge with the provided new edge. Returns:
+            // - {kSelf, <this>}
+            //   The edge was directly set in this node. The old edge is unreffed.
+            // - {kCopied, <node>}
+            //   A copy of this node was created with the new edge value.
+            // In both cases, the function adopts a reference on `edge`.
+            template<EdgeType edge_type>
+            OpResult SetEdge(bool owned, CordRep* edge, size_t delta);
+
+            // Creates a new empty node at the specified height.
+            static CordRepBtree* New(int height = 0);
+
+            // Creates a new node containing `rep`, with the height being computed
+            // automatically based on the type of `rep`.
+            static CordRepBtree* New(CordRep* rep);
+
+            // Creates a new node containing both `front` and `back` at height
+            // `front.height() + 1`. Requires `back.height() == front.height()`.
+            static CordRepBtree* New(CordRepBtree* front, CordRepBtree* back);
+
+            // Creates a fully balanced tree from the provided tree by rebuilding a new
+            // tree from all data edges in the input. This function is automatically
+            // invoked internally when the tree exceeds the maximum height.
+            static CordRepBtree* Rebuild(CordRepBtree* tree);
+
+        private:
+            CordRepBtree() = default;
+            ~CordRepBtree() = default;
+
+            // Initializes the main properties `tag`, `begin`, `end`, `height`.
+            inline void InitInstance(int height, size_t begin = 0, size_t end = 0);
+
+            // Direct property access begin / end
+            void set_begin(size_t begin)
+            {
+                storage[1] = static_cast<uint8_t>(begin);
+            }
+            void set_end(size_t end)
+            {
+                storage[2] = static_cast<uint8_t>(end);
+            }
+
+            // Decreases the value of `begin` by `n`, and returns the new value. Notice
+            // how this returns the new value unlike atomic::fetch_add which returns the
+            // old value. This is because this is used to prepend edges at 'begin - 1'.
+            size_t sub_fetch_begin(size_t n)
+            {
+                storage[1] -= static_cast<uint8_t>(n);
+                return storage[1];
+            }
+
+            // Increases the value of `end` by `n`, and returns the previous value. This
+            // function is typically used to append edges at 'end'.
+            size_t fetch_add_end(size_t n)
+            {
+                const uint8_t current = storage[2];
+                storage[2] = static_cast<uint8_t>(current + n);
+                return current;
+            }
+
+            // Returns the index of the last edge starting on, or before `offset`, with
+            // `n` containing the relative offset of `offset` inside that edge.
+            // Requires `offset` < length.
+            Position IndexOf(size_t offset) const;
+
+            // Returns the index of the last edge starting before `offset`, with `n`
+            // containing the relative offset of `offset` inside that edge.
+            // This function is useful to find the edges for some span of bytes ending at
+            // `offset` (i.e., `n` bytes). For example:
+            //
+            //   Position pos = IndexBefore(n)
+            //   edges = Edges(begin(), pos.index)     // All full edges (may be empty)
+            //   last = Sub(Edge(pos.index), 0, pos.n) // Last partial edge (may be empty)
+            //
+            // Requires 0 < `offset` <= length.
+            Position IndexBefore(size_t offset) const;
+
+            // Returns the index of the edge ending at (or on) length `length`, and the
+            // number of bytes inside that edge up to `length`. For example, if we have a
+            // Node with 2 edges, one of 10 and one of 20 long, then IndexOfLength(27)
+            // will return {1, 17}, and IndexOfLength(10) will return {0, 10}.
+            Position IndexOfLength(size_t n) const;
+
+            // Identical to the above function except starting from the position `front`.
+            // This function is equivalent to `IndexBefore(front.n + offset)`, with
+            // the difference that this function is optimized to start at `front.index`.
+            Position IndexBefore(Position front, size_t offset) const;
+
+            // Returns the index of the edge directly beyond the edge containing offset
+            // `offset`, with `n` containing the distance of that edge from `offset`.
+            // This function is useful for iteratively finding suffix nodes and remaining
+            // partial bytes in left-most suffix nodes as for example in CopySuffix.
+            // Requires `offset` < length.
+            Position IndexBeyond(size_t offset) const;
+
+            // Creates a new leaf node containing as much data as possible from `data`.
+            // The data is added either forwards or reversed depending on `edge_type`.
+            // Callers must check the length of the returned node to determine if all data
+            // was copied or not.
+            // See the `Append/Prepend` function for the meaning and purpose of `extra`.
+            template<EdgeType edge_type>
+            static CordRepBtree* NewLeaf(absl::string_view data, size_t extra);
+
+            // Creates a raw copy of this Btree node, copying all properties, but
+            // without adding any references to existing edges.
+            CordRepBtree* CopyRaw() const;
+
+            // Creates a full copy of this Btree node, adding a reference on all edges.
+            CordRepBtree* Copy() const;
+
+            // Creates a partial copy of this Btree node, copying all edges up to `end`,
+            // adding a reference on each copied edge, and sets the length of the newly
+            // created copy to `new_length`.
+            CordRepBtree* CopyBeginTo(size_t end, size_t new_length) const;
+
+            // Returns a tree containing the edges [tree->begin(), end) and length
+            // of `new_length`. This method consumes a reference on the provided
+            // tree, and logically performs the following operation:
+            //   result = tree->CopyBeginTo(end, new_length);
+            //   CordRep::Unref(tree);
+            //   return result;
+            static CordRepBtree* ConsumeBeginTo(CordRepBtree* tree, size_t end, size_t new_length);
+
+            // Creates a partial copy of this Btree node, copying all edges starting at
+            // `begin`, adding a reference on each copied edge, and sets the length of
+            // the newly created copy to `new_length`.
+            CordRepBtree* CopyToEndFrom(size_t begin, size_t new_length) const;
+
+            // Extracts and returns the front edge from the provided tree.
+            // This method consumes a reference on the provided tree, and logically
+            // performs the following operation:
+            //   edge = CordRep::Ref(tree->Edge(kFront));
+            //   CordRep::Unref(tree);
+            //   return edge;
+            static CordRep* ExtractFront(CordRepBtree* tree);
+
+            // Returns a tree containing the result of appending `right` to `left`.
+            static CordRepBtree* MergeTrees(CordRepBtree* left, CordRepBtree* right);
+
+            // Fallback functions for `Create()`, `Append()` and `Prepend()` which
+            // deal with legacy / non conforming input, i.e.: CONCAT trees.
+            static CordRepBtree* CreateSlow(CordRep* rep);
+            static CordRepBtree* AppendSlow(CordRepBtree*, CordRep* rep);
+            static CordRepBtree* PrependSlow(CordRepBtree*, CordRep* rep);
+
+            // Recursively rebuilds `tree` into `stack`. If 'consume` is set to true, the
+            // function will consume a reference on `tree`. `stack` is a null terminated
+            // array containing the new tree's state, with the current leaf node at
+            // stack[0], and parent nodes above that, or null for 'top of tree'.
+            static void Rebuild(CordRepBtree** stack, CordRepBtree* tree, bool consume);
+
+            // Aligns existing edges to start at index 0, to allow for a new edge to be
+            // added to the back of the current edges.
+            inline void AlignBegin();
+
+            // Aligns existing edges to end at `capacity`, to allow for a new edge to be
+            // added in front of the current edges.
+            inline void AlignEnd();
+
+            // Adds the provided edge to this node.
+            // Requires this node to have capacity for the edge. Realigns / moves
+            // existing edges as needed to prepend or append the new edge.
+            template<EdgeType edge_type>
+            inline void Add(CordRep* rep);
+
+            // Adds the provided edges to this node.
+            // Requires this node to have capacity for the edges. Realigns / moves
+            // existing edges as needed to prepend or append the new edges.
+            template<EdgeType edge_type>
+            inline void Add(absl::Span<CordRep* const>);
+
+            // Adds data from `data` to this node until either all data has been consumed,
+            // or there is no more capacity for additional flat nodes inside this node.
+            // Requires the current node to be a leaf node, data to be non empty, and the
+            // current node to have capacity for at least one more data edge.
+            // Returns any remaining data from `data` that was not added, which is
+            // depending on the edge type (front / back) either the remaining prefix of
+            // suffix of the input.
+            // See the `Append/Prepend` function for the meaning and purpose of `extra`.
+            template<EdgeType edge_type>
+            absl::string_view AddData(absl::string_view data, size_t extra);
+
+            // Replace the front or back edge with the provided value.
+            // Adopts a reference on `edge` and unrefs the old edge.
+            template<EdgeType edge_type>
+            inline void SetEdge(CordRep* edge);
+
+            // Returns a partial copy of the current tree containing the first `n` bytes
+            // of data. `CopyResult` contains both the resulting edge and its height. The
+            // resulting tree may be less high than the current tree, or even be a single
+            // matching data edge if `allow_folding` is set to true.
+            // For example, if `n == 1`, then the result will be the single data edge, and
+            // height will be set to -1 (one below the owning leaf node). If n == 0, this
+            // function returns null. Requires `n <= length`
+            CopyResult CopyPrefix(size_t n, bool allow_folding = true);
+
+            // Returns a partial copy of the current tree containing all data starting
+            // after `offset`. `CopyResult` contains both the resulting edge and its
+            // height. The resulting tree may be less high than the current tree, or even
+            // be a single matching data edge. For example, if `n == length - 1`, then the
+            // result will be a single data edge, and height will be set to -1 (one below
+            // the owning leaf node).
+            // Requires `offset < length`
+            CopyResult CopySuffix(size_t offset);
+
+            // Returns a OpResult value of {this, kSelf} or {Copy(), kCopied}
+            // depending on the value of `owned`.
+            inline OpResult ToOpResult(bool owned);
+
+            // Adds `rep` to the specified tree, returning the modified tree.
+            template<EdgeType edge_type>
+            static CordRepBtree* AddCordRep(CordRepBtree* tree, CordRep* rep);
+
+            // Adds `data` to the specified tree, returning the modified tree.
+            // See the `Append/Prepend` function for the meaning and purpose of `extra`.
+            template<EdgeType edge_type>
+            static CordRepBtree* AddData(CordRepBtree* tree, absl::string_view data, size_t extra = 0);
+
+            // Merges `src` into `dst` with `src` being added either before (kFront) or
+            // after (kBack) `dst`. Requires the height of `dst` to be greater than or
+            // equal to the height of `src`.
+            template<EdgeType edge_type>
+            static CordRepBtree* Merge(CordRepBtree* dst, CordRepBtree* src);
+
+            // Fallback version of GetAppendBuffer for large trees: GetAppendBuffer()
+            // implements an inlined version for trees of limited height (3 levels),
+            // GetAppendBufferSlow implements the logic for large trees.
+            Span<char> GetAppendBufferSlow(size_t size);
+
+            // `edges_` contains all edges starting from this instance.
+            // These are explicitly `child` edges only, a cord btree (or any cord tree in
+            // that respect) does not store `parent` pointers anywhere: multiple trees /
+            // parents can reference the same shared child edge. The type of these edges
+            // depends on the height of the node. `Leaf nodes` (height == 0) contain `data
+            // edges` (external or flat nodes, or sub-strings thereof). All other nodes
+            // (height > 0) contain pointers to BTREE nodes with a height of `height - 1`.
+            CordRep* edges_[kMaxCapacity];
+
+            friend class CordRepBtreeTestPeer;
+            friend class CordRepBtreeNavigator;
+        };
+
+        inline CordRepBtree* CordRep::btree()
+        {
+            assert(IsBtree());
+            return static_cast<CordRepBtree*>(this);
+        }
+
+        inline const CordRepBtree* CordRep::btree() const
+        {
+            assert(IsBtree());
+            return static_cast<const CordRepBtree*>(this);
+        }
+
+        inline void CordRepBtree::InitInstance(int height, size_t begin, size_t end)
+        {
+            tag = BTREE;
+            storage[0] = static_cast<uint8_t>(height);
+            storage[1] = static_cast<uint8_t>(begin);
+            storage[2] = static_cast<uint8_t>(end);
+        }
+
+        inline CordRep* CordRepBtree::Edge(size_t index) const
+        {
+            assert(index >= begin());
+            assert(index < end());
+            return edges_[index];
+        }
+
+        inline CordRep* CordRepBtree::Edge(EdgeType edge_type) const
+        {
+            return edges_[edge_type == kFront ? begin() : back()];
+        }
+
+        inline absl::Span<CordRep* const> CordRepBtree::Edges() const
+        {
+            return {edges_ + begin(), size()};
+        }
+
+        inline absl::Span<CordRep* const> CordRepBtree::Edges(size_t begin, size_t end) const
+        {
+            assert(begin <= end);
+            assert(begin >= this->begin());
+            assert(end <= this->end());
+            return {edges_ + begin, static_cast<size_t>(end - begin)};
+        }
+
+        inline absl::string_view CordRepBtree::Data(size_t index) const
+        {
+            assert(height() == 0);
+            return EdgeData(Edge(index));
+        }
+
+        inline CordRepBtree* CordRepBtree::New(int height)
+        {
+            CordRepBtree* tree = new CordRepBtree;
+            tree->length = 0;
+            tree->InitInstance(height);
+            return tree;
+        }
+
+        inline CordRepBtree* CordRepBtree::New(CordRep* rep)
+        {
+            CordRepBtree* tree = new CordRepBtree;
+            int height = rep->IsBtree() ? rep->btree()->height() + 1 : 0;
+            tree->length = rep->length;
+            tree->InitInstance(height, /*begin=*/0, /*end=*/1);
+            tree->edges_[0] = rep;
+            return tree;
+        }
+
+        inline CordRepBtree* CordRepBtree::New(CordRepBtree* front, CordRepBtree* back)
+        {
+            assert(front->height() == back->height());
+            CordRepBtree* tree = new CordRepBtree;
+            tree->length = front->length + back->length;
+            tree->InitInstance(front->height() + 1, /*begin=*/0, /*end=*/2);
+            tree->edges_[0] = front;
+            tree->edges_[1] = back;
+            return tree;
+        }
+
+        inline void CordRepBtree::Unref(absl::Span<CordRep* const> edges)
+        {
+            for (CordRep* edge : edges)
+            {
+                if (ABSL_PREDICT_FALSE(!edge->refcount.Decrement()))
+                {
+                    CordRep::Destroy(edge);
+                }
+            }
+        }
+
+        inline CordRepBtree* CordRepBtree::CopyRaw() const
+        {
+            auto* tree = static_cast<CordRepBtree*>(::operator new(sizeof(CordRepBtree)));
+            memcpy(static_cast<void*>(tree), this, sizeof(CordRepBtree));
+            new (&tree->refcount) RefcountAndFlags;
+            return tree;
+        }
+
+        inline CordRepBtree* CordRepBtree::Copy() const
+        {
+            CordRepBtree* tree = CopyRaw();
+            for (CordRep* rep : Edges())
+                CordRep::Ref(rep);
+            return tree;
+        }
+
+        inline CordRepBtree* CordRepBtree::CopyToEndFrom(size_t begin, size_t new_length) const
+        {
+            assert(begin >= this->begin());
+            assert(begin <= this->end());
+            CordRepBtree* tree = CopyRaw();
+            tree->length = new_length;
+            tree->set_begin(begin);
+            for (CordRep* edge : tree->Edges())
+                CordRep::Ref(edge);
+            return tree;
+        }
+
+        inline CordRepBtree* CordRepBtree::CopyBeginTo(size_t end, size_t new_length) const
+        {
+            assert(end <= capacity());
+            assert(end >= this->begin());
+            CordRepBtree* tree = CopyRaw();
+            tree->length = new_length;
+            tree->set_end(end);
+            for (CordRep* edge : tree->Edges())
+                CordRep::Ref(edge);
+            return tree;
+        }
+
+        inline void CordRepBtree::AlignBegin()
+        {
+            // The below code itself does not need to be fast as typically we have
+            // mono-directional append/prepend calls, and `begin` / `end` are typically
+            // adjusted no more than once. But we want to avoid potential register clobber
+            // effects, making the compiler emit register save/store/spills, and minimize
+            // the size of code.
+            const size_t delta = begin();
+            if (ABSL_PREDICT_FALSE(delta != 0))
+            {
+                const size_t new_end = end() - delta;
+                set_begin(0);
+                set_end(new_end);
+                // TODO(mvels): we can write this using 2 loads / 2 stores depending on
+                // total size for the kMaxCapacity = 6 case. I.e., we can branch (switch) on
+                // size, and then do overlapping load/store of up to 4 pointers (inlined as
+                // XMM, YMM or ZMM load/store) and up to 2 pointers (XMM / YMM), which is a)
+                // compact and b) not clobbering any registers.
+                ABSL_ASSUME(new_end <= kMaxCapacity);
 #ifdef __clang__
 #pragma unroll 1
 #endif
-    for (size_t i = 0; i < new_end; ++i) {
-      edges_[i] = edges_[i + delta];
-    }
-  }
-}
-
-inline void CordRepBtree::AlignEnd() {
-  // See comments in `AlignBegin` for motivation on the hand-rolled for loops.
-  const size_t delta = capacity() - end();
-  if (delta != 0) {
-    const size_t new_begin = begin() + delta;
-    const size_t new_end = end() + delta;
-    set_begin(new_begin);
-    set_end(new_end);
-    ABSL_ASSUME(new_end <= kMaxCapacity);
+                for (size_t i = 0; i < new_end; ++i)
+                {
+                    edges_[i] = edges_[i + delta];
+                }
+            }
+        }
+
+        inline void CordRepBtree::AlignEnd()
+        {
+            // See comments in `AlignBegin` for motivation on the hand-rolled for loops.
+            const size_t delta = capacity() - end();
+            if (delta != 0)
+            {
+                const size_t new_begin = begin() + delta;
+                const size_t new_end = end() + delta;
+                set_begin(new_begin);
+                set_end(new_end);
+                ABSL_ASSUME(new_end <= kMaxCapacity);
 #ifdef __clang__
 #pragma unroll 1
 #endif
-    for (size_t i = new_end - 1; i >= new_begin; --i) {
-      edges_[i] = edges_[i - delta];
-    }
-  }
-}
-
-template <>
-inline void CordRepBtree::Add<CordRepBtree::kBack>(CordRep* rep) {
-  AlignBegin();
-  edges_[fetch_add_end(1)] = rep;
-}
-
-template <>
-inline void CordRepBtree::Add<CordRepBtree::kBack>(
-    absl::Span<CordRep* const> edges) {
-  AlignBegin();
-  size_t new_end = end();
-  for (CordRep* edge : edges) edges_[new_end++] = edge;
-  set_end(new_end);
-}
-
-template <>
-inline void CordRepBtree::Add<CordRepBtree::kFront>(CordRep* rep) {
-  AlignEnd();
-  edges_[sub_fetch_begin(1)] = rep;
-}
-
-template <>
-inline void CordRepBtree::Add<CordRepBtree::kFront>(
-    absl::Span<CordRep* const> edges) {
-  AlignEnd();
-  size_t new_begin = begin() - edges.size();
-  set_begin(new_begin);
-  for (CordRep* edge : edges) edges_[new_begin++] = edge;
-}
-
-template <CordRepBtree::EdgeType edge_type>
-inline void CordRepBtree::SetEdge(CordRep* edge) {
-  const int idx = edge_type == kFront ? begin() : back();
-  CordRep::Unref(edges_[idx]);
-  edges_[idx] = edge;
-}
-
-inline CordRepBtree::OpResult CordRepBtree::ToOpResult(bool owned) {
-  return owned ? OpResult{this, kSelf} : OpResult{Copy(), kCopied};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexOf(size_t offset) const {
-  assert(offset < length);
-  size_t index = begin();
-  while (offset >= edges_[index]->length) offset -= edges_[index++]->length;
-  return {index, offset};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexBefore(size_t offset) const {
-  assert(offset > 0);
-  assert(offset <= length);
-  size_t index = begin();
-  while (offset > edges_[index]->length) offset -= edges_[index++]->length;
-  return {index, offset};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexBefore(Position front,
-                                                        size_t offset) const {
-  size_t index = front.index;
-  offset = offset + front.n;
-  while (offset > edges_[index]->length) offset -= edges_[index++]->length;
-  return {index, offset};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexOfLength(size_t n) const {
-  assert(n <= length);
-  size_t index = back();
-  size_t strip = length - n;
-  while (strip >= edges_[index]->length) strip -= edges_[index--]->length;
-  return {index, edges_[index]->length - strip};
-}
-
-inline CordRepBtree::Position CordRepBtree::IndexBeyond(
-    const size_t offset) const {
-  // We need to find the edge which `starting offset` is beyond (>=)`offset`.
-  // For this we can't use the `offset -= length` logic of IndexOf. Instead, we
-  // track the offset of the `current edge` in `off`, which we increase as we
-  // iterate over the edges until we find the matching edge.
-  size_t off = 0;
-  size_t index = begin();
-  while (offset > off) off += edges_[index++]->length;
-  return {index, off - offset};
-}
-
-inline CordRepBtree* CordRepBtree::Create(CordRep* rep) {
-  if (IsDataEdge(rep)) return New(rep);
-  return CreateSlow(rep);
-}
-
-inline Span<char> CordRepBtree::GetAppendBuffer(size_t size) {
-  assert(refcount.IsOne());
-  CordRepBtree* tree = this;
-  const int height = this->height();
-  CordRepBtree* n1 = tree;
-  CordRepBtree* n2 = tree;
-  CordRepBtree* n3 = tree;
-  switch (height) {
-    case 3:
-      tree = tree->Edge(kBack)->btree();
-      if (!tree->refcount.IsOne()) return {};
-      n2 = tree;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 2:
-      tree = tree->Edge(kBack)->btree();
-      if (!tree->refcount.IsOne()) return {};
-      n1 = tree;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 1:
-      tree = tree->Edge(kBack)->btree();
-      if (!tree->refcount.IsOne()) return {};
-      ABSL_FALLTHROUGH_INTENDED;
-    case 0:
-      CordRep* edge = tree->Edge(kBack);
-      if (!edge->refcount.IsOne()) return {};
-      if (edge->tag < FLAT) return {};
-      size_t avail = edge->flat()->Capacity() - edge->length;
-      if (avail == 0) return {};
-      size_t delta = (std::min)(size, avail);
-      Span<char> span = {edge->flat()->Data() + edge->length, delta};
-      edge->length += delta;
-      switch (height) {
-        case 3:
-          n3->length += delta;
-          ABSL_FALLTHROUGH_INTENDED;
-        case 2:
-          n2->length += delta;
-          ABSL_FALLTHROUGH_INTENDED;
-        case 1:
-          n1->length += delta;
-          ABSL_FALLTHROUGH_INTENDED;
-        case 0:
-          tree->length += delta;
-          return span;
-      }
-      break;
-  }
-  return GetAppendBufferSlow(size);
-}
-
-extern template CordRepBtree* CordRepBtree::AddCordRep<CordRepBtree::kBack>(
-    CordRepBtree* tree, CordRep* rep);
-
-extern template CordRepBtree* CordRepBtree::AddCordRep<CordRepBtree::kFront>(
-    CordRepBtree* tree, CordRep* rep);
-
-inline CordRepBtree* CordRepBtree::Append(CordRepBtree* tree, CordRep* rep) {
-  if (ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
-    return CordRepBtree::AddCordRep<kBack>(tree, rep);
-  }
-  return AppendSlow(tree, rep);
-}
-
-inline CordRepBtree* CordRepBtree::Prepend(CordRepBtree* tree, CordRep* rep) {
-  if (ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
-    return CordRepBtree::AddCordRep<kFront>(tree, rep);
-  }
-  return PrependSlow(tree, rep);
-}
+                for (size_t i = new_end - 1; i >= new_begin; --i)
+                {
+                    edges_[i] = edges_[i - delta];
+                }
+            }
+        }
+
+        template<>
+        inline void CordRepBtree::Add<CordRepBtree::kBack>(CordRep* rep)
+        {
+            AlignBegin();
+            edges_[fetch_add_end(1)] = rep;
+        }
+
+        template<>
+        inline void CordRepBtree::Add<CordRepBtree::kBack>(
+            absl::Span<CordRep* const> edges
+        )
+        {
+            AlignBegin();
+            size_t new_end = end();
+            for (CordRep* edge : edges)
+                edges_[new_end++] = edge;
+            set_end(new_end);
+        }
+
+        template<>
+        inline void CordRepBtree::Add<CordRepBtree::kFront>(CordRep* rep)
+        {
+            AlignEnd();
+            edges_[sub_fetch_begin(1)] = rep;
+        }
+
+        template<>
+        inline void CordRepBtree::Add<CordRepBtree::kFront>(
+            absl::Span<CordRep* const> edges
+        )
+        {
+            AlignEnd();
+            size_t new_begin = begin() - edges.size();
+            set_begin(new_begin);
+            for (CordRep* edge : edges)
+                edges_[new_begin++] = edge;
+        }
+
+        template<CordRepBtree::EdgeType edge_type>
+        inline void CordRepBtree::SetEdge(CordRep* edge)
+        {
+            const int idx = edge_type == kFront ? begin() : back();
+            CordRep::Unref(edges_[idx]);
+            edges_[idx] = edge;
+        }
+
+        inline CordRepBtree::OpResult CordRepBtree::ToOpResult(bool owned)
+        {
+            return owned ? OpResult{this, kSelf} : OpResult{Copy(), kCopied};
+        }
+
+        inline CordRepBtree::Position CordRepBtree::IndexOf(size_t offset) const
+        {
+            assert(offset < length);
+            size_t index = begin();
+            while (offset >= edges_[index]->length)
+                offset -= edges_[index++]->length;
+            return {index, offset};
+        }
+
+        inline CordRepBtree::Position CordRepBtree::IndexBefore(size_t offset) const
+        {
+            assert(offset > 0);
+            assert(offset <= length);
+            size_t index = begin();
+            while (offset > edges_[index]->length)
+                offset -= edges_[index++]->length;
+            return {index, offset};
+        }
+
+        inline CordRepBtree::Position CordRepBtree::IndexBefore(Position front, size_t offset) const
+        {
+            size_t index = front.index;
+            offset = offset + front.n;
+            while (offset > edges_[index]->length)
+                offset -= edges_[index++]->length;
+            return {index, offset};
+        }
+
+        inline CordRepBtree::Position CordRepBtree::IndexOfLength(size_t n) const
+        {
+            assert(n <= length);
+            size_t index = back();
+            size_t strip = length - n;
+            while (strip >= edges_[index]->length)
+                strip -= edges_[index--]->length;
+            return {index, edges_[index]->length - strip};
+        }
+
+        inline CordRepBtree::Position CordRepBtree::IndexBeyond(
+            const size_t offset
+        ) const
+        {
+            // We need to find the edge which `starting offset` is beyond (>=)`offset`.
+            // For this we can't use the `offset -= length` logic of IndexOf. Instead, we
+            // track the offset of the `current edge` in `off`, which we increase as we
+            // iterate over the edges until we find the matching edge.
+            size_t off = 0;
+            size_t index = begin();
+            while (offset > off)
+                off += edges_[index++]->length;
+            return {index, off - offset};
+        }
+
+        inline CordRepBtree* CordRepBtree::Create(CordRep* rep)
+        {
+            if (IsDataEdge(rep))
+                return New(rep);
+            return CreateSlow(rep);
+        }
+
+        inline Span<char> CordRepBtree::GetAppendBuffer(size_t size)
+        {
+            assert(refcount.IsOne());
+            CordRepBtree* tree = this;
+            const int height = this->height();
+            CordRepBtree* n1 = tree;
+            CordRepBtree* n2 = tree;
+            CordRepBtree* n3 = tree;
+            switch (height)
+            {
+                case 3:
+                    tree = tree->Edge(kBack)->btree();
+                    if (!tree->refcount.IsOne())
+                        return {};
+                    n2 = tree;
+                    ABSL_FALLTHROUGH_INTENDED;
+                case 2:
+                    tree = tree->Edge(kBack)->btree();
+                    if (!tree->refcount.IsOne())
+                        return {};
+                    n1 = tree;
+                    ABSL_FALLTHROUGH_INTENDED;
+                case 1:
+                    tree = tree->Edge(kBack)->btree();
+                    if (!tree->refcount.IsOne())
+                        return {};
+                    ABSL_FALLTHROUGH_INTENDED;
+                case 0:
+                    CordRep* edge = tree->Edge(kBack);
+                    if (!edge->refcount.IsOne())
+                        return {};
+                    if (edge->tag < FLAT)
+                        return {};
+                    size_t avail = edge->flat()->Capacity() - edge->length;
+                    if (avail == 0)
+                        return {};
+                    size_t delta = (std::min)(size, avail);
+                    Span<char> span = {edge->flat()->Data() + edge->length, delta};
+                    edge->length += delta;
+                    switch (height)
+                    {
+                        case 3:
+                            n3->length += delta;
+                            ABSL_FALLTHROUGH_INTENDED;
+                        case 2:
+                            n2->length += delta;
+                            ABSL_FALLTHROUGH_INTENDED;
+                        case 1:
+                            n1->length += delta;
+                            ABSL_FALLTHROUGH_INTENDED;
+                        case 0:
+                            tree->length += delta;
+                            return span;
+                    }
+                    break;
+            }
+            return GetAppendBufferSlow(size);
+        }
+
+        extern template CordRepBtree* CordRepBtree::AddCordRep<CordRepBtree::kBack>(
+            CordRepBtree* tree, CordRep* rep
+        );
+
+        extern template CordRepBtree* CordRepBtree::AddCordRep<CordRepBtree::kFront>(
+            CordRepBtree* tree, CordRep* rep
+        );
+
+        inline CordRepBtree* CordRepBtree::Append(CordRepBtree* tree, CordRep* rep)
+        {
+            if (ABSL_PREDICT_TRUE(IsDataEdge(rep)))
+            {
+                return CordRepBtree::AddCordRep<kBack>(tree, rep);
+            }
+            return AppendSlow(tree, rep);
+        }
+
+        inline CordRepBtree* CordRepBtree::Prepend(CordRepBtree* tree, CordRep* rep)
+        {
+            if (ABSL_PREDICT_TRUE(IsDataEdge(rep)))
+            {
+                return CordRepBtree::AddCordRep<kFront>(tree, rep);
+            }
+            return PrependSlow(tree, rep);
+        }
 
 #ifdef NDEBUG
 
-inline CordRepBtree* CordRepBtree::AssertValid(CordRepBtree* tree,
-                                               bool /* shallow */) {
-  return tree;
-}
+        inline CordRepBtree* CordRepBtree::AssertValid(CordRepBtree* tree, bool /* shallow */)
+        {
+            return tree;
+        }
 
-inline const CordRepBtree* CordRepBtree::AssertValid(const CordRepBtree* tree,
-                                                     bool /* shallow */) {
-  return tree;
-}
+        inline const CordRepBtree* CordRepBtree::AssertValid(const CordRepBtree* tree, bool /* shallow */)
+        {
+            return tree;
+        }
 
 #endif
 
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_navigator.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_navigator.h
index 3d581c8..1a5a5de 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_navigator.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_navigator.h
@@ -21,247 +21,281 @@
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cord_rep_btree.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordRepBtreeNavigator is a bi-directional navigator allowing callers to
-// navigate all the (leaf) data edges in a CordRepBtree instance.
-//
-// A CordRepBtreeNavigator instance is by default empty. Callers initialize a
-// navigator instance by calling one of `InitFirst()`, `InitLast()` or
-// `InitOffset()`, which establishes a current position. Callers can then
-// navigate using the `Next`, `Previous`, `Skip` and `Seek` methods.
-//
-// The navigator instance does not take or adopt a reference on the provided
-// `tree` on any of the initialization calls. Callers are responsible for
-// guaranteeing the lifecycle of the provided tree. A navigator instance can
-// be reset to the empty state by calling `Reset`.
-//
-// A navigator only keeps positional state on the 'current data edge', it does
-// explicitly not keep any 'offset' state. The class does accept and return
-// offsets in the `Read()`, `Skip()` and 'Seek()` methods as these would
-// otherwise put a big burden on callers. Callers are expected to maintain
-// (returned) offset info if they require such granular state.
-class CordRepBtreeNavigator {
- public:
-  // The logical position as returned by the Seek() and Skip() functions.
-  // Returns the current leaf edge for the desired seek or skip position and
-  // the offset of that position inside that edge.
-  struct Position {
-    CordRep* edge;
-    size_t offset;
-  };
-
-  // The read result as returned by the Read() function.
-  // `tree` contains the resulting tree which is identical to the result
-  // of calling CordRepBtree::SubTree(...) on the tree being navigated.
-  // `n` contains the number of bytes used from the last navigated to
-  // edge of the tree.
-  struct ReadResult {
-    CordRep* tree;
-    size_t n;
-  };
-
-  // Returns true if this instance is not empty.
-  explicit operator bool() const;
-
-  // Returns the tree for this instance or nullptr if empty.
-  CordRepBtree* btree() const;
-
-  // Returns the data edge of the current position.
-  // Requires this instance to not be empty.
-  CordRep* Current() const;
-
-  // Resets this navigator to `tree`, returning the first data edge in the tree.
-  CordRep* InitFirst(CordRepBtree* tree);
-
-  // Resets this navigator to `tree`, returning the last data edge in the tree.
-  CordRep* InitLast(CordRepBtree* tree);
-
-  // Resets this navigator to `tree` returning the data edge at position
-  // `offset` and the relative offset of `offset` into that data edge.
-  // Returns `Position.edge = nullptr` if the provided offset is greater
-  // than or equal to the length of the tree, in which case the state of
-  // the navigator instance remains unchanged.
-  Position InitOffset(CordRepBtree* tree, size_t offset);
-
-  // Navigates to the next data edge.
-  // Returns the next data edge or nullptr if there is no next data edge, in
-  // which case the current position remains unchanged.
-  CordRep* Next();
-
-  // Navigates to the previous data edge.
-  // Returns the previous data edge or nullptr if there is no previous data
-  // edge, in which case the current position remains unchanged.
-  CordRep* Previous();
-
-  // Navigates to the data edge at position `offset`. Returns the navigated to
-  // data edge in `Position.edge` and the relative offset of `offset` into that
-  // data edge in `Position.offset`. Returns `Position.edge = nullptr` if the
-  // provide offset is greater than or equal to the tree's length.
-  Position Seek(size_t offset);
-
-  // Reads `n` bytes of data starting at offset `edge_offset` of the current
-  // data edge, and returns the result in `ReadResult.tree`. `ReadResult.n`
-  // contains the 'bytes used` from the last / current data edge in the tree.
-  // This allows users that mix regular navigation (using string views) and
-  // 'read into cord' navigation to keep track of the current state, and which
-  // bytes have been consumed from a navigator.
-  // This function returns `ReadResult.tree = nullptr` if the requested length
-  // exceeds the length of the tree starting at the current data edge.
-  ReadResult Read(size_t edge_offset, size_t n);
-
-  // Skips `n` bytes forward from the current data edge, returning the navigated
-  // to data edge in `Position.edge` and `Position.offset` containing the offset
-  // inside that data edge. Note that the state of the navigator is left
-  // unchanged if `n` is smaller than the length of the current data edge.
-  Position Skip(size_t n);
-
-  // Resets this instance to the default / empty state.
-  void Reset();
-
- private:
-  // Slow path for Next() if Next() reached the end of a leaf node. Backtracks
-  // up the stack until it finds a node that has a 'next' position available,
-  // and then does a 'front dive' towards the next leaf node.
-  CordRep* NextUp();
-
-  // Slow path for Previous() if Previous() reached the beginning of a leaf
-  // node. Backtracks up the stack until it finds a node that has a 'previous'
-  // position available, and then does a 'back dive' towards the previous leaf
-  // node.
-  CordRep* PreviousUp();
-
-  // Generic implementation of InitFirst() and InitLast().
-  template <CordRepBtree::EdgeType edge_type>
-  CordRep* Init(CordRepBtree* tree);
-
-  // `height_` contains the height of the current tree, or -1 if empty.
-  int height_ = -1;
-
-  // `index_` and `node_` contain the navigation state as the 'path' to the
-  // current data edge which is at `node_[0]->Edge(index_[0])`. The contents
-  // of these are undefined until the instance is initialized (`height_ >= 0`).
-  uint8_t index_[CordRepBtree::kMaxDepth];
-  CordRepBtree* node_[CordRepBtree::kMaxDepth];
-};
-
-// Returns true if this instance is not empty.
-inline CordRepBtreeNavigator::operator bool() const { return height_ >= 0; }
-
-inline CordRepBtree* CordRepBtreeNavigator::btree() const {
-  return height_ >= 0 ? node_[height_] : nullptr;
-}
-
-inline CordRep* CordRepBtreeNavigator::Current() const {
-  assert(height_ >= 0);
-  return node_[0]->Edge(index_[0]);
-}
-
-inline void CordRepBtreeNavigator::Reset() { height_ = -1; }
-
-inline CordRep* CordRepBtreeNavigator::InitFirst(CordRepBtree* tree) {
-  return Init<CordRepBtree::kFront>(tree);
-}
-
-inline CordRep* CordRepBtreeNavigator::InitLast(CordRepBtree* tree) {
-  return Init<CordRepBtree::kBack>(tree);
-}
-
-template <CordRepBtree::EdgeType edge_type>
-inline CordRep* CordRepBtreeNavigator::Init(CordRepBtree* tree) {
-  assert(tree != nullptr);
-  assert(tree->size() > 0);
-  assert(tree->height() <= CordRepBtree::kMaxHeight);
-  int height = height_ = tree->height();
-  size_t index = tree->index(edge_type);
-  node_[height] = tree;
-  index_[height] = static_cast<uint8_t>(index);
-  while (--height >= 0) {
-    tree = tree->Edge(index)->btree();
-    node_[height] = tree;
-    index = tree->index(edge_type);
-    index_[height] = static_cast<uint8_t>(index);
-  }
-  return node_[0]->Edge(index);
-}
-
-inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::Seek(
-    size_t offset) {
-  assert(btree() != nullptr);
-  int height = height_;
-  CordRepBtree* edge = node_[height];
-  if (ABSL_PREDICT_FALSE(offset >= edge->length)) return {nullptr, 0};
-  CordRepBtree::Position index = edge->IndexOf(offset);
-  index_[height] = static_cast<uint8_t>(index.index);
-  while (--height >= 0) {
-    edge = edge->Edge(index.index)->btree();
-    node_[height] = edge;
-    index = edge->IndexOf(index.n);
-    index_[height] = static_cast<uint8_t>(index.index);
-  }
-  return {edge->Edge(index.index), index.n};
-}
-
-inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::InitOffset(
-    CordRepBtree* tree, size_t offset) {
-  assert(tree != nullptr);
-  assert(tree->height() <= CordRepBtree::kMaxHeight);
-  if (ABSL_PREDICT_FALSE(offset >= tree->length)) return {nullptr, 0};
-  height_ = tree->height();
-  node_[height_] = tree;
-  return Seek(offset);
-}
-
-inline CordRep* CordRepBtreeNavigator::Next() {
-  CordRepBtree* edge = node_[0];
-  return index_[0] == edge->back() ? NextUp() : edge->Edge(++index_[0]);
-}
-
-inline CordRep* CordRepBtreeNavigator::Previous() {
-  CordRepBtree* edge = node_[0];
-  return index_[0] == edge->begin() ? PreviousUp() : edge->Edge(--index_[0]);
-}
-
-inline CordRep* CordRepBtreeNavigator::NextUp() {
-  assert(index_[0] == node_[0]->back());
-  CordRepBtree* edge;
-  size_t index;
-  int height = 0;
-  do {
-    if (++height > height_) return nullptr;
-    edge = node_[height];
-    index = index_[height] + 1;
-  } while (index == edge->end());
-  index_[height] = static_cast<uint8_t>(index);
-  do {
-    node_[--height] = edge = edge->Edge(index)->btree();
-    index_[height] = static_cast<uint8_t>(index = edge->begin());
-  } while (height > 0);
-  return edge->Edge(index);
-}
-
-inline CordRep* CordRepBtreeNavigator::PreviousUp() {
-  assert(index_[0] == node_[0]->begin());
-  CordRepBtree* edge;
-  size_t index;
-  int height = 0;
-  do {
-    if (++height > height_) return nullptr;
-    edge = node_[height];
-    index = index_[height];
-  } while (index == edge->begin());
-  index_[height] = static_cast<uint8_t>(--index);
-  do {
-    node_[--height] = edge = edge->Edge(index)->btree();
-    index_[height] = static_cast<uint8_t>(index = edge->back());
-  } while (height > 0);
-  return edge->Edge(index);
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // CordRepBtreeNavigator is a bi-directional navigator allowing callers to
+        // navigate all the (leaf) data edges in a CordRepBtree instance.
+        //
+        // A CordRepBtreeNavigator instance is by default empty. Callers initialize a
+        // navigator instance by calling one of `InitFirst()`, `InitLast()` or
+        // `InitOffset()`, which establishes a current position. Callers can then
+        // navigate using the `Next`, `Previous`, `Skip` and `Seek` methods.
+        //
+        // The navigator instance does not take or adopt a reference on the provided
+        // `tree` on any of the initialization calls. Callers are responsible for
+        // guaranteeing the lifecycle of the provided tree. A navigator instance can
+        // be reset to the empty state by calling `Reset`.
+        //
+        // A navigator only keeps positional state on the 'current data edge', it does
+        // explicitly not keep any 'offset' state. The class does accept and return
+        // offsets in the `Read()`, `Skip()` and 'Seek()` methods as these would
+        // otherwise put a big burden on callers. Callers are expected to maintain
+        // (returned) offset info if they require such granular state.
+        class CordRepBtreeNavigator
+        {
+        public:
+            // The logical position as returned by the Seek() and Skip() functions.
+            // Returns the current leaf edge for the desired seek or skip position and
+            // the offset of that position inside that edge.
+            struct Position
+            {
+                CordRep* edge;
+                size_t offset;
+            };
+
+            // The read result as returned by the Read() function.
+            // `tree` contains the resulting tree which is identical to the result
+            // of calling CordRepBtree::SubTree(...) on the tree being navigated.
+            // `n` contains the number of bytes used from the last navigated to
+            // edge of the tree.
+            struct ReadResult
+            {
+                CordRep* tree;
+                size_t n;
+            };
+
+            // Returns true if this instance is not empty.
+            explicit operator bool() const;
+
+            // Returns the tree for this instance or nullptr if empty.
+            CordRepBtree* btree() const;
+
+            // Returns the data edge of the current position.
+            // Requires this instance to not be empty.
+            CordRep* Current() const;
+
+            // Resets this navigator to `tree`, returning the first data edge in the tree.
+            CordRep* InitFirst(CordRepBtree* tree);
+
+            // Resets this navigator to `tree`, returning the last data edge in the tree.
+            CordRep* InitLast(CordRepBtree* tree);
+
+            // Resets this navigator to `tree` returning the data edge at position
+            // `offset` and the relative offset of `offset` into that data edge.
+            // Returns `Position.edge = nullptr` if the provided offset is greater
+            // than or equal to the length of the tree, in which case the state of
+            // the navigator instance remains unchanged.
+            Position InitOffset(CordRepBtree* tree, size_t offset);
+
+            // Navigates to the next data edge.
+            // Returns the next data edge or nullptr if there is no next data edge, in
+            // which case the current position remains unchanged.
+            CordRep* Next();
+
+            // Navigates to the previous data edge.
+            // Returns the previous data edge or nullptr if there is no previous data
+            // edge, in which case the current position remains unchanged.
+            CordRep* Previous();
+
+            // Navigates to the data edge at position `offset`. Returns the navigated to
+            // data edge in `Position.edge` and the relative offset of `offset` into that
+            // data edge in `Position.offset`. Returns `Position.edge = nullptr` if the
+            // provide offset is greater than or equal to the tree's length.
+            Position Seek(size_t offset);
+
+            // Reads `n` bytes of data starting at offset `edge_offset` of the current
+            // data edge, and returns the result in `ReadResult.tree`. `ReadResult.n`
+            // contains the 'bytes used` from the last / current data edge in the tree.
+            // This allows users that mix regular navigation (using string views) and
+            // 'read into cord' navigation to keep track of the current state, and which
+            // bytes have been consumed from a navigator.
+            // This function returns `ReadResult.tree = nullptr` if the requested length
+            // exceeds the length of the tree starting at the current data edge.
+            ReadResult Read(size_t edge_offset, size_t n);
+
+            // Skips `n` bytes forward from the current data edge, returning the navigated
+            // to data edge in `Position.edge` and `Position.offset` containing the offset
+            // inside that data edge. Note that the state of the navigator is left
+            // unchanged if `n` is smaller than the length of the current data edge.
+            Position Skip(size_t n);
+
+            // Resets this instance to the default / empty state.
+            void Reset();
+
+        private:
+            // Slow path for Next() if Next() reached the end of a leaf node. Backtracks
+            // up the stack until it finds a node that has a 'next' position available,
+            // and then does a 'front dive' towards the next leaf node.
+            CordRep* NextUp();
+
+            // Slow path for Previous() if Previous() reached the beginning of a leaf
+            // node. Backtracks up the stack until it finds a node that has a 'previous'
+            // position available, and then does a 'back dive' towards the previous leaf
+            // node.
+            CordRep* PreviousUp();
+
+            // Generic implementation of InitFirst() and InitLast().
+            template<CordRepBtree::EdgeType edge_type>
+            CordRep* Init(CordRepBtree* tree);
+
+            // `height_` contains the height of the current tree, or -1 if empty.
+            int height_ = -1;
+
+            // `index_` and `node_` contain the navigation state as the 'path' to the
+            // current data edge which is at `node_[0]->Edge(index_[0])`. The contents
+            // of these are undefined until the instance is initialized (`height_ >= 0`).
+            uint8_t index_[CordRepBtree::kMaxDepth];
+            CordRepBtree* node_[CordRepBtree::kMaxDepth];
+        };
+
+        // Returns true if this instance is not empty.
+        inline CordRepBtreeNavigator::operator bool() const
+        {
+            return height_ >= 0;
+        }
+
+        inline CordRepBtree* CordRepBtreeNavigator::btree() const
+        {
+            return height_ >= 0 ? node_[height_] : nullptr;
+        }
+
+        inline CordRep* CordRepBtreeNavigator::Current() const
+        {
+            assert(height_ >= 0);
+            return node_[0]->Edge(index_[0]);
+        }
+
+        inline void CordRepBtreeNavigator::Reset()
+        {
+            height_ = -1;
+        }
+
+        inline CordRep* CordRepBtreeNavigator::InitFirst(CordRepBtree* tree)
+        {
+            return Init<CordRepBtree::kFront>(tree);
+        }
+
+        inline CordRep* CordRepBtreeNavigator::InitLast(CordRepBtree* tree)
+        {
+            return Init<CordRepBtree::kBack>(tree);
+        }
+
+        template<CordRepBtree::EdgeType edge_type>
+        inline CordRep* CordRepBtreeNavigator::Init(CordRepBtree* tree)
+        {
+            assert(tree != nullptr);
+            assert(tree->size() > 0);
+            assert(tree->height() <= CordRepBtree::kMaxHeight);
+            int height = height_ = tree->height();
+            size_t index = tree->index(edge_type);
+            node_[height] = tree;
+            index_[height] = static_cast<uint8_t>(index);
+            while (--height >= 0)
+            {
+                tree = tree->Edge(index)->btree();
+                node_[height] = tree;
+                index = tree->index(edge_type);
+                index_[height] = static_cast<uint8_t>(index);
+            }
+            return node_[0]->Edge(index);
+        }
+
+        inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::Seek(
+            size_t offset
+        )
+        {
+            assert(btree() != nullptr);
+            int height = height_;
+            CordRepBtree* edge = node_[height];
+            if (ABSL_PREDICT_FALSE(offset >= edge->length))
+                return {nullptr, 0};
+            CordRepBtree::Position index = edge->IndexOf(offset);
+            index_[height] = static_cast<uint8_t>(index.index);
+            while (--height >= 0)
+            {
+                edge = edge->Edge(index.index)->btree();
+                node_[height] = edge;
+                index = edge->IndexOf(index.n);
+                index_[height] = static_cast<uint8_t>(index.index);
+            }
+            return {edge->Edge(index.index), index.n};
+        }
+
+        inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::InitOffset(
+            CordRepBtree* tree, size_t offset
+        )
+        {
+            assert(tree != nullptr);
+            assert(tree->height() <= CordRepBtree::kMaxHeight);
+            if (ABSL_PREDICT_FALSE(offset >= tree->length))
+                return {nullptr, 0};
+            height_ = tree->height();
+            node_[height_] = tree;
+            return Seek(offset);
+        }
+
+        inline CordRep* CordRepBtreeNavigator::Next()
+        {
+            CordRepBtree* edge = node_[0];
+            return index_[0] == edge->back() ? NextUp() : edge->Edge(++index_[0]);
+        }
+
+        inline CordRep* CordRepBtreeNavigator::Previous()
+        {
+            CordRepBtree* edge = node_[0];
+            return index_[0] == edge->begin() ? PreviousUp() : edge->Edge(--index_[0]);
+        }
+
+        inline CordRep* CordRepBtreeNavigator::NextUp()
+        {
+            assert(index_[0] == node_[0]->back());
+            CordRepBtree* edge;
+            size_t index;
+            int height = 0;
+            do
+            {
+                if (++height > height_)
+                    return nullptr;
+                edge = node_[height];
+                index = index_[height] + 1;
+            } while (index == edge->end());
+            index_[height] = static_cast<uint8_t>(index);
+            do
+            {
+                node_[--height] = edge = edge->Edge(index)->btree();
+                index_[height] = static_cast<uint8_t>(index = edge->begin());
+            } while (height > 0);
+            return edge->Edge(index);
+        }
+
+        inline CordRep* CordRepBtreeNavigator::PreviousUp()
+        {
+            assert(index_[0] == node_[0]->begin());
+            CordRepBtree* edge;
+            size_t index;
+            int height = 0;
+            do
+            {
+                if (++height > height_)
+                    return nullptr;
+                edge = node_[height];
+                index = index_[height];
+            } while (index == edge->begin());
+            index_[height] = static_cast<uint8_t>(--index);
+            do
+            {
+                node_[--height] = edge = edge->Edge(index)->btree();
+                index_[height] = static_cast<uint8_t>(index = edge->back());
+            } while (height > 0);
+            return edge->Edge(index);
+        }
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_reader.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_reader.h
index 8db8f8d..78e9637 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_reader.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_btree_reader.h
@@ -24,189 +24,215 @@
 #include "absl/strings/internal/cord_rep_btree_navigator.h"
 #include "absl/strings/internal/cord_rep_flat.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordRepBtreeReader implements logic to iterate over cord btrees.
-// References to the underlying data are returned as absl::string_view values.
-// The most typical use case is a forward only iteration over tree data.
-// The class also provides `Skip()`, `Seek()` and `Read()` methods similar to
-// CordRepBtreeNavigator that allow more advanced navigation.
-//
-// Example: iterate over all data inside a cord btree:
-//
-//   CordRepBtreeReader reader;
-//   for (string_view sv = reader.Init(tree); !sv.Empty(); sv = sv.Next()) {
-//     DoSomethingWithDataIn(sv);
-//   }
-//
-// All navigation methods always return the next 'chunk' of data. The class
-// assumes that all data is directly 'consumed' by the caller. For example:
-// invoking `Skip()` will skip the desired number of bytes, and directly
-// read and return the next chunk of data directly after the skipped bytes.
-//
-// Example: iterate over all data inside a btree skipping the first 100 bytes:
-//
-//   CordRepBtreeReader reader;
-//   absl::string_view sv = reader.Init(tree);
-//   if (sv.length() > 100) {
-//     sv.RemovePrefix(100);
-//   } else {
-//     sv = reader.Skip(100 - sv.length());
-//   }
-//   while (!sv.empty()) {
-//     DoSomethingWithDataIn(sv);
-//     absl::string_view sv = reader.Next();
-//   }
-//
-// It is important to notice that `remaining` is based on the end position of
-// the last data edge returned to the caller, not the cumulative data returned
-// to the caller which can be less in cases of skipping or seeking over data.
-//
-// For example, consider a cord btree with five data edges: "abc", "def", "ghi",
-// "jkl" and "mno":
-//
-//   absl::string_view sv;
-//   CordRepBtreeReader reader;
-//
-//   sv = reader.Init(tree); // sv = "abc", remaining = 12
-//   sv = reader.Skip(4);    // sv = "hi",  remaining = 6
-//   sv = reader.Skip(2);    // sv = "l",   remaining = 3
-//   sv = reader.Next();     // sv = "mno", remaining = 0
-//   sv = reader.Seek(1);    // sv = "bc", remaining = 12
-//
-class CordRepBtreeReader {
- public:
-  using ReadResult = CordRepBtreeNavigator::ReadResult;
-  using Position = CordRepBtreeNavigator::Position;
-
-  // Returns true if this instance is not empty.
-  explicit operator bool() const { return navigator_.btree() != nullptr; }
-
-  // Returns the tree referenced by this instance or nullptr if empty.
-  CordRepBtree* btree() const { return navigator_.btree(); }
-
-  // Returns the current data edge inside the referenced btree.
-  // Requires that the current instance is not empty.
-  CordRep* node() const { return navigator_.Current(); }
-
-  // Returns the length of the referenced tree.
-  // Requires that the current instance is not empty.
-  size_t length() const;
-
-  // Returns the number of remaining bytes available for iteration, which is the
-  // number of bytes directly following the end of the last chunk returned.
-  // This value will be zero if we iterated over the last edge in the bound
-  // tree, in which case any call to Next() or Skip() will return an empty
-  // string_view reflecting the EOF state.
-  // Note that a call to `Seek()` resets `remaining` to a value based on the
-  // end position of the chunk returned by that call.
-  size_t remaining() const { return remaining_; }
-
-  // Resets this instance to an empty value.
-  void Reset() { navigator_.Reset(); }
-
-  // Initializes this instance with `tree`. `tree` must not be null.
-  // Returns a reference to the first data edge of the provided tree.
-  absl::string_view Init(CordRepBtree* tree);
-
-  // Navigates to and returns the next data edge of the referenced tree.
-  // Returns an empty string_view if an attempt is made to read beyond the end
-  // of the tree, i.e.: if `remaining()` is zero indicating an EOF condition.
-  // Requires that the current instance is not empty.
-  absl::string_view Next();
-
-  // Skips the provided amount of bytes and returns a reference to the data
-  // directly following the skipped bytes.
-  absl::string_view Skip(size_t skip);
-
-  // Reads `n` bytes into `tree`.
-  // If `chunk_size` is zero, starts reading at the next data edge. If
-  // `chunk_size` is non zero, the read starts at the last `chunk_size` bytes of
-  // the last returned data edge. Effectively, this means that the read starts
-  // at offset `consumed() - chunk_size`.
-  // Requires that `chunk_size` is less than or equal to the length of the
-  // last returned data edge. The purpose of `chunk_size` is to simplify code
-  // partially consuming a returned chunk and wanting to include the remaining
-  // bytes in the Read call. For example, the below code will read 1000 bytes of
-  // data into a cord tree if the first chunk starts with "big:":
-  //
-  //   CordRepBtreeReader reader;
-  //   absl::string_view sv = reader.Init(tree);
-  //   if (absl::StartsWith(sv, "big:")) {
-  //     CordRepBtree tree;
-  //     sv = reader.Read(1000, sv.size() - 4 /* "big:" */, &tree);
-  //   }
-  //
-  // This method will return an empty string view if all remaining data was
-  // read. If `n` exceeded the amount of remaining data this function will
-  // return an empty string view and `tree` will be set to nullptr.
-  // In both cases, `consumed` will be set to `length`.
-  absl::string_view Read(size_t n, size_t chunk_size, CordRep*& tree);
-
-  // Navigates to the chunk at offset `offset`.
-  // Returns a reference into the navigated to chunk, adjusted for the relative
-  // position of `offset` into that chunk. For example, calling `Seek(13)` on a
-  // cord tree containing 2 chunks of 10 and 20 bytes respectively will return
-  // a string view into the second chunk starting at offset 3 with a size of 17.
-  // Returns an empty string view if `offset` is equal to or greater than the
-  // length of the referenced tree.
-  absl::string_view Seek(size_t offset);
-
- private:
-  size_t remaining_ = 0;
-  CordRepBtreeNavigator navigator_;
-};
-
-inline size_t CordRepBtreeReader::length() const {
-  assert(btree() != nullptr);
-  return btree()->length;
-}
-
-inline absl::string_view CordRepBtreeReader::Init(CordRepBtree* tree) {
-  assert(tree != nullptr);
-  const CordRep* edge = navigator_.InitFirst(tree);
-  remaining_ = tree->length - edge->length;
-  return EdgeData(edge);
-}
-
-inline absl::string_view CordRepBtreeReader::Next() {
-  if (remaining_ == 0) return {};
-  const CordRep* edge = navigator_.Next();
-  assert(edge != nullptr);
-  remaining_ -= edge->length;
-  return EdgeData(edge);
-}
-
-inline absl::string_view CordRepBtreeReader::Skip(size_t skip) {
-  // As we are always positioned on the last 'consumed' edge, we
-  // need to skip the current edge as well as `skip`.
-  const size_t edge_length = navigator_.Current()->length;
-  CordRepBtreeNavigator::Position pos = navigator_.Skip(skip + edge_length);
-  if (ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
-    remaining_ = 0;
-    return {};
-  }
-  // The combined length of all edges skipped before `pos.edge` is `skip -
-  // pos.offset`, all of which are 'consumed', as well as the current edge.
-  remaining_ -= skip - pos.offset + pos.edge->length;
-  return EdgeData(pos.edge).substr(pos.offset);
-}
-
-inline absl::string_view CordRepBtreeReader::Seek(size_t offset) {
-  const CordRepBtreeNavigator::Position pos = navigator_.Seek(offset);
-  if (ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
-    remaining_ = 0;
-    return {};
-  }
-  absl::string_view chunk = EdgeData(pos.edge).substr(pos.offset);
-  remaining_ = length() - offset - chunk.length();
-  return chunk;
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // CordRepBtreeReader implements logic to iterate over cord btrees.
+        // References to the underlying data are returned as absl::string_view values.
+        // The most typical use case is a forward only iteration over tree data.
+        // The class also provides `Skip()`, `Seek()` and `Read()` methods similar to
+        // CordRepBtreeNavigator that allow more advanced navigation.
+        //
+        // Example: iterate over all data inside a cord btree:
+        //
+        //   CordRepBtreeReader reader;
+        //   for (string_view sv = reader.Init(tree); !sv.Empty(); sv = sv.Next()) {
+        //     DoSomethingWithDataIn(sv);
+        //   }
+        //
+        // All navigation methods always return the next 'chunk' of data. The class
+        // assumes that all data is directly 'consumed' by the caller. For example:
+        // invoking `Skip()` will skip the desired number of bytes, and directly
+        // read and return the next chunk of data directly after the skipped bytes.
+        //
+        // Example: iterate over all data inside a btree skipping the first 100 bytes:
+        //
+        //   CordRepBtreeReader reader;
+        //   absl::string_view sv = reader.Init(tree);
+        //   if (sv.length() > 100) {
+        //     sv.RemovePrefix(100);
+        //   } else {
+        //     sv = reader.Skip(100 - sv.length());
+        //   }
+        //   while (!sv.empty()) {
+        //     DoSomethingWithDataIn(sv);
+        //     absl::string_view sv = reader.Next();
+        //   }
+        //
+        // It is important to notice that `remaining` is based on the end position of
+        // the last data edge returned to the caller, not the cumulative data returned
+        // to the caller which can be less in cases of skipping or seeking over data.
+        //
+        // For example, consider a cord btree with five data edges: "abc", "def", "ghi",
+        // "jkl" and "mno":
+        //
+        //   absl::string_view sv;
+        //   CordRepBtreeReader reader;
+        //
+        //   sv = reader.Init(tree); // sv = "abc", remaining = 12
+        //   sv = reader.Skip(4);    // sv = "hi",  remaining = 6
+        //   sv = reader.Skip(2);    // sv = "l",   remaining = 3
+        //   sv = reader.Next();     // sv = "mno", remaining = 0
+        //   sv = reader.Seek(1);    // sv = "bc", remaining = 12
+        //
+        class CordRepBtreeReader
+        {
+        public:
+            using ReadResult = CordRepBtreeNavigator::ReadResult;
+            using Position = CordRepBtreeNavigator::Position;
+
+            // Returns true if this instance is not empty.
+            explicit operator bool() const
+            {
+                return navigator_.btree() != nullptr;
+            }
+
+            // Returns the tree referenced by this instance or nullptr if empty.
+            CordRepBtree* btree() const
+            {
+                return navigator_.btree();
+            }
+
+            // Returns the current data edge inside the referenced btree.
+            // Requires that the current instance is not empty.
+            CordRep* node() const
+            {
+                return navigator_.Current();
+            }
+
+            // Returns the length of the referenced tree.
+            // Requires that the current instance is not empty.
+            size_t length() const;
+
+            // Returns the number of remaining bytes available for iteration, which is the
+            // number of bytes directly following the end of the last chunk returned.
+            // This value will be zero if we iterated over the last edge in the bound
+            // tree, in which case any call to Next() or Skip() will return an empty
+            // string_view reflecting the EOF state.
+            // Note that a call to `Seek()` resets `remaining` to a value based on the
+            // end position of the chunk returned by that call.
+            size_t remaining() const
+            {
+                return remaining_;
+            }
+
+            // Resets this instance to an empty value.
+            void Reset()
+            {
+                navigator_.Reset();
+            }
+
+            // Initializes this instance with `tree`. `tree` must not be null.
+            // Returns a reference to the first data edge of the provided tree.
+            absl::string_view Init(CordRepBtree* tree);
+
+            // Navigates to and returns the next data edge of the referenced tree.
+            // Returns an empty string_view if an attempt is made to read beyond the end
+            // of the tree, i.e.: if `remaining()` is zero indicating an EOF condition.
+            // Requires that the current instance is not empty.
+            absl::string_view Next();
+
+            // Skips the provided amount of bytes and returns a reference to the data
+            // directly following the skipped bytes.
+            absl::string_view Skip(size_t skip);
+
+            // Reads `n` bytes into `tree`.
+            // If `chunk_size` is zero, starts reading at the next data edge. If
+            // `chunk_size` is non zero, the read starts at the last `chunk_size` bytes of
+            // the last returned data edge. Effectively, this means that the read starts
+            // at offset `consumed() - chunk_size`.
+            // Requires that `chunk_size` is less than or equal to the length of the
+            // last returned data edge. The purpose of `chunk_size` is to simplify code
+            // partially consuming a returned chunk and wanting to include the remaining
+            // bytes in the Read call. For example, the below code will read 1000 bytes of
+            // data into a cord tree if the first chunk starts with "big:":
+            //
+            //   CordRepBtreeReader reader;
+            //   absl::string_view sv = reader.Init(tree);
+            //   if (absl::StartsWith(sv, "big:")) {
+            //     CordRepBtree tree;
+            //     sv = reader.Read(1000, sv.size() - 4 /* "big:" */, &tree);
+            //   }
+            //
+            // This method will return an empty string view if all remaining data was
+            // read. If `n` exceeded the amount of remaining data this function will
+            // return an empty string view and `tree` will be set to nullptr.
+            // In both cases, `consumed` will be set to `length`.
+            absl::string_view Read(size_t n, size_t chunk_size, CordRep*& tree);
+
+            // Navigates to the chunk at offset `offset`.
+            // Returns a reference into the navigated to chunk, adjusted for the relative
+            // position of `offset` into that chunk. For example, calling `Seek(13)` on a
+            // cord tree containing 2 chunks of 10 and 20 bytes respectively will return
+            // a string view into the second chunk starting at offset 3 with a size of 17.
+            // Returns an empty string view if `offset` is equal to or greater than the
+            // length of the referenced tree.
+            absl::string_view Seek(size_t offset);
+
+        private:
+            size_t remaining_ = 0;
+            CordRepBtreeNavigator navigator_;
+        };
+
+        inline size_t CordRepBtreeReader::length() const
+        {
+            assert(btree() != nullptr);
+            return btree()->length;
+        }
+
+        inline absl::string_view CordRepBtreeReader::Init(CordRepBtree* tree)
+        {
+            assert(tree != nullptr);
+            const CordRep* edge = navigator_.InitFirst(tree);
+            remaining_ = tree->length - edge->length;
+            return EdgeData(edge);
+        }
+
+        inline absl::string_view CordRepBtreeReader::Next()
+        {
+            if (remaining_ == 0)
+                return {};
+            const CordRep* edge = navigator_.Next();
+            assert(edge != nullptr);
+            remaining_ -= edge->length;
+            return EdgeData(edge);
+        }
+
+        inline absl::string_view CordRepBtreeReader::Skip(size_t skip)
+        {
+            // As we are always positioned on the last 'consumed' edge, we
+            // need to skip the current edge as well as `skip`.
+            const size_t edge_length = navigator_.Current()->length;
+            CordRepBtreeNavigator::Position pos = navigator_.Skip(skip + edge_length);
+            if (ABSL_PREDICT_FALSE(pos.edge == nullptr))
+            {
+                remaining_ = 0;
+                return {};
+            }
+            // The combined length of all edges skipped before `pos.edge` is `skip -
+            // pos.offset`, all of which are 'consumed', as well as the current edge.
+            remaining_ -= skip - pos.offset + pos.edge->length;
+            return EdgeData(pos.edge).substr(pos.offset);
+        }
+
+        inline absl::string_view CordRepBtreeReader::Seek(size_t offset)
+        {
+            const CordRepBtreeNavigator::Position pos = navigator_.Seek(offset);
+            if (ABSL_PREDICT_FALSE(pos.edge == nullptr))
+            {
+                remaining_ = 0;
+                return {};
+            }
+            absl::string_view chunk = EdgeData(pos.edge).substr(pos.offset);
+            remaining_ = length() - offset - chunk.length();
+            return chunk;
+        }
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_consume.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_consume.h
index d46fca2..0474aea 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_consume.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_consume.h
@@ -20,31 +20,33 @@
 #include "absl/functional/function_ref.h"
 #include "absl/strings/internal/cord_internal.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Functor for the Consume() and ReverseConsume() functions:
-//   void ConsumeFunc(CordRep* rep, size_t offset, size_t length);
-// See the Consume() and ReverseConsume() function comments for documentation.
-using ConsumeFn = FunctionRef<void(CordRep*, size_t, size_t)>;
-
-// Consume() and ReverseConsume() consume CONCAT based trees and invoke the
-// provided functor with the contained nodes in the proper forward or reverse
-// order, which is used to convert CONCAT trees into other tree or cord data.
-// All CONCAT and SUBSTRING nodes are processed internally. The 'offset`
-// parameter of the functor is non-zero for any nodes below SUBSTRING nodes.
-// It's up to the caller to form these back into SUBSTRING nodes or otherwise
-// store offset / prefix information. These functions are intended to be used
-// only for migration / transitional code where due to factors such as ODR
-// violations, we can not 100% guarantee that all code respects 'new format'
-// settings and flags, so we need to be able to parse old data on the fly until
-// all old code is deprecated / no longer the default format.
-void Consume(CordRep* rep, ConsumeFn consume_fn);
-void ReverseConsume(CordRep* rep, ConsumeFn consume_fn);
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // Functor for the Consume() and ReverseConsume() functions:
+        //   void ConsumeFunc(CordRep* rep, size_t offset, size_t length);
+        // See the Consume() and ReverseConsume() function comments for documentation.
+        using ConsumeFn = FunctionRef<void(CordRep*, size_t, size_t)>;
+
+        // Consume() and ReverseConsume() consume CONCAT based trees and invoke the
+        // provided functor with the contained nodes in the proper forward or reverse
+        // order, which is used to convert CONCAT trees into other tree or cord data.
+        // All CONCAT and SUBSTRING nodes are processed internally. The 'offset`
+        // parameter of the functor is non-zero for any nodes below SUBSTRING nodes.
+        // It's up to the caller to form these back into SUBSTRING nodes or otherwise
+        // store offset / prefix information. These functions are intended to be used
+        // only for migration / transitional code where due to factors such as ODR
+        // violations, we can not 100% guarantee that all code respects 'new format'
+        // settings and flags, so we need to be able to parse old data on the fly until
+        // all old code is deprecated / no longer the default format.
+        void Consume(CordRep* rep, ConsumeFn consume_fn);
+        void ReverseConsume(CordRep* rep, ConsumeFn consume_fn);
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_crc.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_crc.h
index 5294b0d..0cec25b 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_crc.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_crc.h
@@ -22,81 +22,99 @@
 #include "absl/base/optimization.h"
 #include "absl/strings/internal/cord_internal.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
 
-// CordRepCrc is a CordRep node intended only to appear at the top level of a
-// cord tree.  It associates an "expected CRC" with the contained data, to allow
-// for easy passage of checksum data in Cord data flows.
-//
-// From Cord's perspective, the crc value has no semantics; any validation of
-// the contained checksum is the user's responsibility.
-struct CordRepCrc : public CordRep {
-  CordRep* child;
-  uint32_t crc;
+        // CordRepCrc is a CordRep node intended only to appear at the top level of a
+        // cord tree.  It associates an "expected CRC" with the contained data, to allow
+        // for easy passage of checksum data in Cord data flows.
+        //
+        // From Cord's perspective, the crc value has no semantics; any validation of
+        // the contained checksum is the user's responsibility.
+        struct CordRepCrc : public CordRep
+        {
+            CordRep* child;
+            uint32_t crc;
 
-  // Consumes `child` and returns a CordRepCrc prefixed tree containing `child`.
-  // If the specified `child` is itself a CordRepCrc node, then this method
-  // either replaces the existing node, or directly updates the crc value in it
-  // depending on the node being shared or not, i.e.: refcount.IsOne().
-  // `child` must not be null. Never returns null.
-  static CordRepCrc* New(CordRep* child, uint32_t crc);
+            // Consumes `child` and returns a CordRepCrc prefixed tree containing `child`.
+            // If the specified `child` is itself a CordRepCrc node, then this method
+            // either replaces the existing node, or directly updates the crc value in it
+            // depending on the node being shared or not, i.e.: refcount.IsOne().
+            // `child` must not be null. Never returns null.
+            static CordRepCrc* New(CordRep* child, uint32_t crc);
 
-  // Destroys (deletes) the provided node. `node` must not be null.
-  static void Destroy(CordRepCrc* node);
-};
+            // Destroys (deletes) the provided node. `node` must not be null.
+            static void Destroy(CordRepCrc* node);
+        };
 
-// Consumes `rep` and returns a CordRep* with any outer CordRepCrc wrapper
-// removed.  This is usually a no-op (returning `rep`), but this will remove and
-// unref an outer CordRepCrc node.
-inline CordRep* RemoveCrcNode(CordRep* rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    CordRep* child = rep->crc()->child;
-    if (rep->refcount.IsOne()) {
-      delete rep->crc();
-    } else {
-      CordRep::Ref(child);
-      CordRep::Unref(rep);
-    }
-    return child;
-  }
-  return rep;
-}
+        // Consumes `rep` and returns a CordRep* with any outer CordRepCrc wrapper
+        // removed.  This is usually a no-op (returning `rep`), but this will remove and
+        // unref an outer CordRepCrc node.
+        inline CordRep* RemoveCrcNode(CordRep* rep)
+        {
+            assert(rep != nullptr);
+            if (ABSL_PREDICT_FALSE(rep->IsCrc()))
+            {
+                CordRep* child = rep->crc()->child;
+                if (rep->refcount.IsOne())
+                {
+                    delete rep->crc();
+                }
+                else
+                {
+                    CordRep::Ref(child);
+                    CordRep::Unref(rep);
+                }
+                return child;
+            }
+            return rep;
+        }
 
-// Returns `rep` if it is not a CordRepCrc node, or its child if it is.
-// Does not consume or create a reference on `rep` or the returned value.
-inline CordRep* SkipCrcNode(CordRep* rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    return rep->crc()->child;
-  } else {
-    return rep;
-  }
-}
+        // Returns `rep` if it is not a CordRepCrc node, or its child if it is.
+        // Does not consume or create a reference on `rep` or the returned value.
+        inline CordRep* SkipCrcNode(CordRep* rep)
+        {
+            assert(rep != nullptr);
+            if (ABSL_PREDICT_FALSE(rep->IsCrc()))
+            {
+                return rep->crc()->child;
+            }
+            else
+            {
+                return rep;
+            }
+        }
 
-inline const CordRep* SkipCrcNode(const CordRep* rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    return rep->crc()->child;
-  } else {
-    return rep;
-  }
-}
+        inline const CordRep* SkipCrcNode(const CordRep* rep)
+        {
+            assert(rep != nullptr);
+            if (ABSL_PREDICT_FALSE(rep->IsCrc()))
+            {
+                return rep->crc()->child;
+            }
+            else
+            {
+                return rep;
+            }
+        }
 
-inline CordRepCrc* CordRep::crc() {
-  assert(IsCrc());
-  return static_cast<CordRepCrc*>(this);
-}
+        inline CordRepCrc* CordRep::crc()
+        {
+            assert(IsCrc());
+            return static_cast<CordRepCrc*>(this);
+        }
 
-inline const CordRepCrc* CordRep::crc() const {
-  assert(IsCrc());
-  return static_cast<const CordRepCrc*>(this);
-}
+        inline const CordRepCrc* CordRep::crc() const
+        {
+            assert(IsCrc());
+            return static_cast<const CordRepCrc*>(this);
+        }
 
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_flat.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_flat.h
index e3e27fc..8a6e92c 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_flat.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_flat.h
@@ -24,164 +24,191 @@
 #include "absl/base/macros.h"
 #include "absl/strings/internal/cord_internal.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Note: all constants below are never ODR used and internal to cord, we define
-// these as static constexpr to avoid 'in struct' definition and usage clutter.
-
-// Largest and smallest flat node lengths we are willing to allocate
-// Flat allocation size is stored in tag, which currently can encode sizes up
-// to 4K, encoded as multiple of either 8 or 32 bytes.
-// If we allow for larger sizes, we need to change this to 8/64, 16/128, etc.
-// kMinFlatSize is bounded by tag needing to be at least FLAT * 8 bytes, and
-// ideally a 'nice' size aligning with allocation and cacheline sizes like 32.
-// kMaxFlatSize is bounded by the size resulting in a computed tag no greater
-// than MAX_FLAT_TAG. MAX_FLAT_TAG provides for additional 'high' tag values.
-static constexpr size_t kFlatOverhead = offsetof(CordRep, storage);
-static constexpr size_t kMinFlatSize = 32;
-static constexpr size_t kMaxFlatSize = 4096;
-static constexpr size_t kMaxFlatLength = kMaxFlatSize - kFlatOverhead;
-static constexpr size_t kMinFlatLength = kMinFlatSize - kFlatOverhead;
-static constexpr size_t kMaxLargeFlatSize = 256 * 1024;
-static constexpr size_t kMaxLargeFlatLength = kMaxLargeFlatSize - kFlatOverhead;
-
-// kTagBase should make the Size <--> Tag computation resilient
-// against changes to the value of FLAT when we add a new tag..
-static constexpr uint8_t kTagBase = FLAT - 4;
-
-// Converts the provided rounded size to the corresponding tag
-constexpr uint8_t AllocatedSizeToTagUnchecked(size_t size) {
-  return static_cast<uint8_t>(size <= 512 ? kTagBase + size / 8
-                              : size <= 8192
-                                  ? kTagBase + 512 / 8 + size / 64 - 512 / 64
-                                  : kTagBase + 512 / 8 + ((8192 - 512) / 64) +
-                                        size / 4096 - 8192 / 4096);
-}
-
-// Converts the provided tag to the corresponding allocated size
-constexpr size_t TagToAllocatedSize(uint8_t tag) {
-  return (tag <= kTagBase + 512 / 8) ? tag * 8 - kTagBase * 8
-         : (tag <= kTagBase + (512 / 8) + ((8192 - 512) / 64))
-             ? 512 + tag * 64 - kTagBase * 64 - 512 / 8 * 64
-             : 8192 + tag * 4096 - kTagBase * 4096 -
-                   ((512 / 8) + ((8192 - 512) / 64)) * 4096;
-}
-
-static_assert(AllocatedSizeToTagUnchecked(kMinFlatSize) == FLAT, "");
-static_assert(AllocatedSizeToTagUnchecked(kMaxLargeFlatSize) == MAX_FLAT_TAG,
-              "");
-
-// RoundUp logically performs `((n + m - 1) / m) * m` to round up to the nearest
-// multiple of `m`, optimized for the invariant that `m` is a power of 2.
-constexpr size_t RoundUp(size_t n, size_t m) {
-  return (n + m - 1) & (0 - m);
-}
-
-// Returns the size to the nearest equal or larger value that can be
-// expressed exactly as a tag value.
-inline size_t RoundUpForTag(size_t size) {
-  return RoundUp(size, (size <= 512) ? 8 : (size <= 8192 ? 64 : 4096));
-}
-
-// Converts the allocated size to a tag, rounding down if the size
-// does not exactly match a 'tag expressible' size value. The result is
-// undefined if the size exceeds the maximum size that can be encoded in
-// a tag, i.e., if size is larger than TagToAllocatedSize(<max tag>).
-inline uint8_t AllocatedSizeToTag(size_t size) {
-  const uint8_t tag = AllocatedSizeToTagUnchecked(size);
-  assert(tag <= MAX_FLAT_TAG);
-  return tag;
-}
-
-// Converts the provided tag to the corresponding available data length
-constexpr size_t TagToLength(uint8_t tag) {
-  return TagToAllocatedSize(tag) - kFlatOverhead;
-}
-
-// Enforce that kMaxFlatSize maps to a well-known exact tag value.
-static_assert(TagToAllocatedSize(MAX_FLAT_TAG) == kMaxLargeFlatSize,
-              "Bad tag logic");
-
-struct CordRepFlat : public CordRep {
-  // Tag for explicit 'large flat' allocation
-  struct Large {};
-
-  // Creates a new flat node.
-  template <size_t max_flat_size, typename... Args>
-  static CordRepFlat* NewImpl(size_t len, Args... args ABSL_ATTRIBUTE_UNUSED) {
-    if (len <= kMinFlatLength) {
-      len = kMinFlatLength;
-    } else if (len > max_flat_size - kFlatOverhead) {
-      len = max_flat_size - kFlatOverhead;
-    }
-
-    // Round size up so it matches a size we can exactly express in a tag.
-    const size_t size = RoundUpForTag(len + kFlatOverhead);
-    void* const raw_rep = ::operator new(size);
-    CordRepFlat* rep = new (raw_rep) CordRepFlat();
-    rep->tag = AllocatedSizeToTag(size);
-    return rep;
-  }
-
-  static CordRepFlat* New(size_t len) { return NewImpl<kMaxFlatSize>(len); }
-
-  static CordRepFlat* New(Large, size_t len) {
-    return NewImpl<kMaxLargeFlatSize>(len);
-  }
-
-  // Deletes a CordRepFlat instance created previously through a call to New().
-  // Flat CordReps are allocated and constructed with raw ::operator new and
-  // placement new, and must be destructed and deallocated accordingly.
-  static void Delete(CordRep*rep) {
-    assert(rep->tag >= FLAT && rep->tag <= MAX_FLAT_TAG);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // Note: all constants below are never ODR used and internal to cord, we define
+        // these as static constexpr to avoid 'in struct' definition and usage clutter.
+
+        // Largest and smallest flat node lengths we are willing to allocate
+        // Flat allocation size is stored in tag, which currently can encode sizes up
+        // to 4K, encoded as multiple of either 8 or 32 bytes.
+        // If we allow for larger sizes, we need to change this to 8/64, 16/128, etc.
+        // kMinFlatSize is bounded by tag needing to be at least FLAT * 8 bytes, and
+        // ideally a 'nice' size aligning with allocation and cacheline sizes like 32.
+        // kMaxFlatSize is bounded by the size resulting in a computed tag no greater
+        // than MAX_FLAT_TAG. MAX_FLAT_TAG provides for additional 'high' tag values.
+        static constexpr size_t kFlatOverhead = offsetof(CordRep, storage);
+        static constexpr size_t kMinFlatSize = 32;
+        static constexpr size_t kMaxFlatSize = 4096;
+        static constexpr size_t kMaxFlatLength = kMaxFlatSize - kFlatOverhead;
+        static constexpr size_t kMinFlatLength = kMinFlatSize - kFlatOverhead;
+        static constexpr size_t kMaxLargeFlatSize = 256 * 1024;
+        static constexpr size_t kMaxLargeFlatLength = kMaxLargeFlatSize - kFlatOverhead;
+
+        // kTagBase should make the Size <--> Tag computation resilient
+        // against changes to the value of FLAT when we add a new tag..
+        static constexpr uint8_t kTagBase = FLAT - 4;
+
+        // Converts the provided rounded size to the corresponding tag
+        constexpr uint8_t AllocatedSizeToTagUnchecked(size_t size)
+        {
+            return static_cast<uint8_t>(size <= 512 ? kTagBase + size / 8 : size <= 8192 ? kTagBase + 512 / 8 + size / 64 - 512 / 64 :
+                                                                                           kTagBase + 512 / 8 + ((8192 - 512) / 64) + size / 4096 - 8192 / 4096);
+        }
+
+        // Converts the provided tag to the corresponding allocated size
+        constexpr size_t TagToAllocatedSize(uint8_t tag)
+        {
+            return (tag <= kTagBase + 512 / 8) ? tag * 8 - kTagBase * 8 : (tag <= kTagBase + (512 / 8) + ((8192 - 512) / 64)) ? 512 + tag * 64 - kTagBase * 64 - 512 / 8 * 64 :
+                                                                                                                                8192 + tag * 4096 - kTagBase * 4096 - ((512 / 8) + ((8192 - 512) / 64)) * 4096;
+        }
+
+        static_assert(AllocatedSizeToTagUnchecked(kMinFlatSize) == FLAT, "");
+        static_assert(AllocatedSizeToTagUnchecked(kMaxLargeFlatSize) == MAX_FLAT_TAG, "");
+
+        // RoundUp logically performs `((n + m - 1) / m) * m` to round up to the nearest
+        // multiple of `m`, optimized for the invariant that `m` is a power of 2.
+        constexpr size_t RoundUp(size_t n, size_t m)
+        {
+            return (n + m - 1) & (0 - m);
+        }
+
+        // Returns the size to the nearest equal or larger value that can be
+        // expressed exactly as a tag value.
+        inline size_t RoundUpForTag(size_t size)
+        {
+            return RoundUp(size, (size <= 512) ? 8 : (size <= 8192 ? 64 : 4096));
+        }
+
+        // Converts the allocated size to a tag, rounding down if the size
+        // does not exactly match a 'tag expressible' size value. The result is
+        // undefined if the size exceeds the maximum size that can be encoded in
+        // a tag, i.e., if size is larger than TagToAllocatedSize(<max tag>).
+        inline uint8_t AllocatedSizeToTag(size_t size)
+        {
+            const uint8_t tag = AllocatedSizeToTagUnchecked(size);
+            assert(tag <= MAX_FLAT_TAG);
+            return tag;
+        }
+
+        // Converts the provided tag to the corresponding available data length
+        constexpr size_t TagToLength(uint8_t tag)
+        {
+            return TagToAllocatedSize(tag) - kFlatOverhead;
+        }
+
+        // Enforce that kMaxFlatSize maps to a well-known exact tag value.
+        static_assert(TagToAllocatedSize(MAX_FLAT_TAG) == kMaxLargeFlatSize, "Bad tag logic");
+
+        struct CordRepFlat : public CordRep
+        {
+            // Tag for explicit 'large flat' allocation
+            struct Large
+            {
+            };
+
+            // Creates a new flat node.
+            template<size_t max_flat_size, typename... Args>
+            static CordRepFlat* NewImpl(size_t len, Args... args ABSL_ATTRIBUTE_UNUSED)
+            {
+                if (len <= kMinFlatLength)
+                {
+                    len = kMinFlatLength;
+                }
+                else if (len > max_flat_size - kFlatOverhead)
+                {
+                    len = max_flat_size - kFlatOverhead;
+                }
+
+                // Round size up so it matches a size we can exactly express in a tag.
+                const size_t size = RoundUpForTag(len + kFlatOverhead);
+                void* const raw_rep = ::operator new(size);
+                CordRepFlat* rep = new (raw_rep) CordRepFlat();
+                rep->tag = AllocatedSizeToTag(size);
+                return rep;
+            }
+
+            static CordRepFlat* New(size_t len)
+            {
+                return NewImpl<kMaxFlatSize>(len);
+            }
+
+            static CordRepFlat* New(Large, size_t len)
+            {
+                return NewImpl<kMaxLargeFlatSize>(len);
+            }
+
+            // Deletes a CordRepFlat instance created previously through a call to New().
+            // Flat CordReps are allocated and constructed with raw ::operator new and
+            // placement new, and must be destructed and deallocated accordingly.
+            static void Delete(CordRep* rep)
+            {
+                assert(rep->tag >= FLAT && rep->tag <= MAX_FLAT_TAG);
 
 #if defined(__cpp_sized_deallocation)
-    size_t size = TagToAllocatedSize(rep->tag);
-    rep->~CordRep();
-    ::operator delete(rep, size);
+                size_t size = TagToAllocatedSize(rep->tag);
+                rep->~CordRep();
+                ::operator delete(rep, size);
 #else
-    rep->~CordRep();
-    ::operator delete(rep);
+                rep->~CordRep();
+                ::operator delete(rep);
 #endif
-  }
-
-  // Create a CordRepFlat containing `data`, with an optional additional
-  // extra capacity of up to `extra` bytes. Requires that `data.size()`
-  // is less than kMaxFlatLength.
-  static CordRepFlat* Create(absl::string_view data, size_t extra = 0) {
-    assert(data.size() <= kMaxFlatLength);
-    CordRepFlat* flat = New(data.size() + (std::min)(extra, kMaxFlatLength));
-    memcpy(flat->Data(), data.data(), data.size());
-    flat->length = data.size();
-    return flat;
-  }
-
-  // Returns a pointer to the data inside this flat rep.
-  char* Data() { return reinterpret_cast<char*>(storage); }
-  const char* Data() const { return reinterpret_cast<const char*>(storage); }
-
-  // Returns the maximum capacity (payload size) of this instance.
-  size_t Capacity() const { return TagToLength(tag); }
-
-  // Returns the allocated size (payload + overhead) of this instance.
-  size_t AllocatedSize() const { return TagToAllocatedSize(tag); }
-};
-
-// Now that CordRepFlat is defined, we can define CordRep's helper casts:
-inline CordRepFlat* CordRep::flat() {
-  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
-  return reinterpret_cast<CordRepFlat*>(this);
-}
-
-inline const CordRepFlat* CordRep::flat() const {
-  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
-  return reinterpret_cast<const CordRepFlat*>(this);
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+            }
+
+            // Create a CordRepFlat containing `data`, with an optional additional
+            // extra capacity of up to `extra` bytes. Requires that `data.size()`
+            // is less than kMaxFlatLength.
+            static CordRepFlat* Create(absl::string_view data, size_t extra = 0)
+            {
+                assert(data.size() <= kMaxFlatLength);
+                CordRepFlat* flat = New(data.size() + (std::min)(extra, kMaxFlatLength));
+                memcpy(flat->Data(), data.data(), data.size());
+                flat->length = data.size();
+                return flat;
+            }
+
+            // Returns a pointer to the data inside this flat rep.
+            char* Data()
+            {
+                return reinterpret_cast<char*>(storage);
+            }
+            const char* Data() const
+            {
+                return reinterpret_cast<const char*>(storage);
+            }
+
+            // Returns the maximum capacity (payload size) of this instance.
+            size_t Capacity() const
+            {
+                return TagToLength(tag);
+            }
+
+            // Returns the allocated size (payload + overhead) of this instance.
+            size_t AllocatedSize() const
+            {
+                return TagToAllocatedSize(tag);
+            }
+        };
+
+        // Now that CordRepFlat is defined, we can define CordRep's helper casts:
+        inline CordRepFlat* CordRep::flat()
+        {
+            assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
+            return reinterpret_cast<CordRepFlat*>(this);
+        }
+
+        inline const CordRepFlat* CordRep::flat() const
+        {
+            assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
+            return reinterpret_cast<const CordRepFlat*>(this);
+        }
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring.h
index 2000e21..a4efe88 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring.h
@@ -26,582 +26,632 @@
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cord_rep_flat.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// All operations modifying a ring buffer are implemented as static methods
-// requiring a CordRepRing instance with a reference adopted by the method.
-//
-// The methods return the modified ring buffer, which may be equal to the input
-// if the input was not shared, and having large enough capacity to accommodate
-// any newly added node(s). Otherwise, a copy of the input rep with the new
-// node(s) added is returned.
-//
-// Any modification on non shared ring buffers with enough capacity will then
-// require minimum atomic operations. Caller should where possible provide
-// reasonable `extra` hints for both anticipated extra `flat` byte space, as
-// well as anticipated extra nodes required for complex operations.
-//
-// Example of code creating a ring buffer, adding some data to it,
-// and discarding the buffer when done:
-//
-//   void FunWithRings() {
-//     // Create ring with 3 flats
-//     CordRep* flat = CreateFlat("Hello");
-//     CordRepRing* ring = CordRepRing::Create(flat, 2);
-//     ring = CordRepRing::Append(ring, CreateFlat(" "));
-//     ring = CordRepRing::Append(ring, CreateFlat("world"));
-//     DoSomethingWithRing(ring);
-//     CordRep::Unref(ring);
-//   }
-//
-// Example of code Copying an existing ring buffer and modifying it:
-//
-//   void MoreFunWithRings(CordRepRing* src) {
-//     CordRepRing* ring = CordRep::Ref(src)->ring();
-//     ring = CordRepRing::Append(ring, CreateFlat("Hello"));
-//     ring = CordRepRing::Append(ring, CreateFlat(" "));
-//     ring = CordRepRing::Append(ring, CreateFlat("world"));
-//     DoSomethingWithRing(ring);
-//     CordRep::Unref(ring);
-//   }
-//
-class CordRepRing : public CordRep {
- public:
-  // `pos_type` represents a 'logical position'. A CordRepRing instance has a
-  // `begin_pos` (default 0), and each node inside the buffer will have an
-  // `end_pos` which is the `end_pos` of the previous node (or `begin_pos`) plus
-  // this node's length. The purpose is to allow for a binary search on this
-  // position, while allowing O(1) prepend and append operations.
-  using pos_type = size_t;
-
-  // `index_type` is the type for the `head`, `tail` and `capacity` indexes.
-  // Ring buffers are limited to having no more than four billion entries.
-  using index_type = uint32_t;
-
-  // `offset_type` is the type for the data offset inside a child rep's data.
-  using offset_type = uint32_t;
-
-  // Position holds the node index and relative offset into the node for
-  // some physical offset in the contained data as returned by the Find()
-  // and FindTail() methods.
-  struct Position {
-    index_type index;
-    size_t offset;
-  };
-
-  // The maximum # of child nodes that can be hosted inside a CordRepRing.
-  static constexpr size_t kMaxCapacity = (std::numeric_limits<uint32_t>::max)();
-
-  // CordRepring can not be default constructed, moved, copied or assigned.
-  CordRepRing() = delete;
-  CordRepRing(const CordRepRing&) = delete;
-  CordRepRing& operator=(const CordRepRing&) = delete;
-
-  // Returns true if this instance is valid, false if some or all of the
-  // invariants are broken. Intended for debug purposes only.
-  // `output` receives an explanation of the broken invariants.
-  bool IsValid(std::ostream& output) const;
-
-  // Returns the size in bytes for a CordRepRing with `capacity' entries.
-  static constexpr size_t AllocSize(size_t capacity);
-
-  // Returns the distance in bytes from `pos` to `end_pos`.
-  static constexpr size_t Distance(pos_type pos, pos_type end_pos);
-
-  // Creates a new ring buffer from the provided `rep`. Adopts a reference
-  // on `rep`. The returned ring buffer has a capacity of at least `extra + 1`
-  static CordRepRing* Create(CordRep* child, size_t extra = 0);
-
-  // `head`, `tail` and `capacity` indexes defining the ring buffer boundaries.
-  index_type head() const { return head_; }
-  index_type tail() const { return tail_; }
-  index_type capacity() const { return capacity_; }
-
-  // Returns the number of entries in this instance.
-  index_type entries() const { return entries(head_, tail_); }
-
-  // Returns the logical begin position of this instance.
-  pos_type begin_pos() const { return begin_pos_; }
-
-  // Returns the number of entries for a given head-tail range.
-  // Requires `head` and `tail` values to be less than `capacity()`.
-  index_type entries(index_type head, index_type tail) const {
-    assert(head < capacity_ && tail < capacity_);
-    return tail - head + ((tail > head) ? 0 : capacity_);
-  }
-
-  // Returns the logical end position of entry `index`.
-  pos_type const& entry_end_pos(index_type index) const {
-    assert(IsValidIndex(index));
-    return Layout::Partial().Pointer<0>(data_)[index];
-  }
-
-  // Returns the child pointer of entry `index`.
-  CordRep* const& entry_child(index_type index) const {
-    assert(IsValidIndex(index));
-    return Layout::Partial(capacity()).Pointer<1>(data_)[index];
-  }
-
-  // Returns the data offset of entry `index`
-  offset_type const& entry_data_offset(index_type index) const {
-    assert(IsValidIndex(index));
-    return Layout::Partial(capacity(), capacity()).Pointer<2>(data_)[index];
-  }
-
-  // Appends the provided child node to the `rep` instance.
-  // Adopts a reference from `rep` and `child` which may not be null.
-  // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node
-  // containing a FLAT or EXTERNAL node, then flat or external the node is added
-  // 'as is', with an offset added for the SUBSTRING case.
-  // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING or
-  // CONCAT tree, then all child nodes not excluded by any start offset or
-  // length values are added recursively.
-  static CordRepRing* Append(CordRepRing* rep, CordRep* child);
-
-  // Appends the provided string data to the `rep` instance.
-  // This function will attempt to utilize any remaining capacity in the last
-  // node of the input if that node is not shared (directly or indirectly), and
-  // of type FLAT. Remaining data will be added as one or more FLAT nodes.
-  // Any last node added to the ring buffer will be allocated with up to
-  // `extra` bytes of capacity for (anticipated) subsequent append actions.
-  static CordRepRing* Append(CordRepRing* rep, string_view data,
-                             size_t extra = 0);
-
-  // Prepends the provided child node to the `rep` instance.
-  // Adopts a reference from `rep` and `child` which may not be null.
-  // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node
-  // containing a FLAT or EXTERNAL node, then flat or external the node is
-  // prepended 'as is', with an optional offset added for the SUBSTRING case.
-  // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING
-  // or CONCAT tree, then all child nodes not excluded by any start offset or
-  // length values are added recursively.
-  static CordRepRing* Prepend(CordRepRing* rep, CordRep* child);
-
-  // Prepends the provided string data to the `rep` instance.
-  // This function will attempt to utilize any remaining capacity in the first
-  // node of the input if that node is not shared (directly or indirectly), and
-  // of type FLAT. Remaining data will be added as one or more FLAT nodes.
-  // Any first node prepnded to the ring buffer will be allocated with up to
-  // `extra` bytes of capacity for (anticipated) subsequent prepend actions.
-  static CordRepRing* Prepend(CordRepRing* rep, string_view data,
-                              size_t extra = 0);
-
-  // Returns a span referencing potentially unused capacity in the last node.
-  // The returned span may be empty if no such capacity is available, or if the
-  // current instance is shared. Else, a span of size `n <= size` is returned.
-  // If non empty, the ring buffer is adjusted to the new length, with the newly
-  // added capacity left uninitialized. Callers should assign a value to the
-  // entire span before any other operations on this instance.
-  Span<char> GetAppendBuffer(size_t size);
-
-  // Returns a span referencing potentially unused capacity in the first node.
-  // This function is identical to GetAppendBuffer except that it returns a span
-  // referencing up to `size` capacity directly before the existing data.
-  Span<char> GetPrependBuffer(size_t size);
-
-  // Returns a cord ring buffer containing `len` bytes of data starting at
-  // `offset`. If the input is not shared, this function will remove all head
-  // and tail child nodes outside of the requested range, and adjust the new
-  // head and tail nodes as required. If the input is shared, this function
-  // returns a new instance sharing some or all of the nodes from the input.
-  static CordRepRing* SubRing(CordRepRing* r, size_t offset, size_t len,
-                              size_t extra = 0);
-
-  // Returns a cord ring buffer with the first `len` bytes removed.
-  // If the input is not shared, this function will remove all head child nodes
-  // fully inside the first `length` bytes, and adjust the new head as required.
-  // If the input is shared, this function returns a new instance sharing some
-  // or all of the nodes from the input.
-  static CordRepRing* RemoveSuffix(CordRepRing* r, size_t len,
-                                   size_t extra = 0);
-
-  // Returns a cord ring buffer with the last `len` bytes removed.
-  // If the input is not shared, this function will remove all head child nodes
-  // fully inside the first `length` bytes, and adjust the new head as required.
-  // If the input is shared, this function returns a new instance sharing some
-  // or all of the nodes from the input.
-  static CordRepRing* RemovePrefix(CordRepRing* r, size_t len,
-                                   size_t extra = 0);
-
-  // Returns the character at `offset`. Requires that `offset < length`.
-  char GetCharacter(size_t offset) const;
-
-  // Returns true if this instance manages a single contiguous buffer, in which
-  // case the (optional) output parameter `fragment` is set. Otherwise, the
-  // function returns false, and `fragment` is left unchanged.
-  bool IsFlat(absl::string_view* fragment) const;
-
-  // Returns true if the data starting at `offset` with length `len` is
-  // managed by this instance inside a single contiguous buffer, in which case
-  // the (optional) output parameter `fragment` is set to the contiguous memory
-  // starting at offset `offset` with length `length`. Otherwise, the function
-  // returns false, and `fragment` is left unchanged.
-  bool IsFlat(size_t offset, size_t len, absl::string_view* fragment) const;
-
-  // Testing only: set capacity to requested capacity.
-  void SetCapacityForTesting(size_t capacity);
-
-  // Returns the CordRep data pointer for the provided CordRep.
-  // Requires that the provided `rep` is either a FLAT or EXTERNAL CordRep.
-  static const char* GetLeafData(const CordRep* rep);
-
-  // Returns the CordRep data pointer for the provided CordRep.
-  // Requires that `rep` is either a FLAT, EXTERNAL, or SUBSTRING CordRep.
-  static const char* GetRepData(const CordRep* rep);
-
-  // Advances the provided position, wrapping around capacity as needed.
-  // Requires `index` < capacity()
-  inline index_type advance(index_type index) const;
-
-  // Advances the provided position by 'n`, wrapping around capacity as needed.
-  // Requires `index` < capacity() and `n` <= capacity.
-  inline index_type advance(index_type index, index_type n) const;
-
-  // Retreats the provided position, wrapping around 0 as needed.
-  // Requires `index` < capacity()
-  inline index_type retreat(index_type index) const;
-
-  // Retreats the provided position by 'n', wrapping around 0 as needed.
-  // Requires `index` < capacity()
-  inline index_type retreat(index_type index, index_type n) const;
-
-  // Returns the logical begin position of entry `index`
-  pos_type const& entry_begin_pos(index_type index) const {
-    return (index == head_) ? begin_pos_ : entry_end_pos(retreat(index));
-  }
-
-  // Returns the physical start offset of entry `index`
-  size_t entry_start_offset(index_type index) const {
-    return Distance(begin_pos_, entry_begin_pos(index));
-  }
-
-  // Returns the physical end offset of entry `index`
-  size_t entry_end_offset(index_type index) const {
-    return Distance(begin_pos_, entry_end_pos(index));
-  }
-
-  // Returns the data length for entry `index`
-  size_t entry_length(index_type index) const {
-    return Distance(entry_begin_pos(index), entry_end_pos(index));
-  }
-
-  // Returns the data for entry `index`
-  absl::string_view entry_data(index_type index) const;
-
-  // Returns the position for `offset` as {index, prefix}. `index` holds the
-  // index of the entry at the specified offset and `prefix` holds the relative
-  // offset inside that entry.
-  // Requires `offset` < length.
-  //
-  // For example we can implement GetCharacter(offset) as:
-  //   char GetCharacter(size_t offset) {
-  //     Position pos = this->Find(offset);
-  //     return this->entry_data(pos.pos)[pos.offset];
-  //   }
-  inline Position Find(size_t offset) const;
-
-  // Find starting at `head`
-  inline Position Find(index_type head, size_t offset) const;
-
-  // Returns the tail position for `offset` as {tail index, suffix}.
-  // `tail index` holds holds the index of the entry holding the offset directly
-  // before 'offset` advanced by one. 'suffix` holds the relative offset from
-  // that relative offset in the entry to the end of the entry.
-  // For example, FindTail(length) will return {tail(), 0}, FindTail(length - 5)
-  // will return {retreat(tail), 5)} provided the preceding entry contains at
-  // least 5 bytes of data.
-  // Requires offset >= 1 && offset <= length.
-  //
-  // This function is very useful in functions that need to clip the end of some
-  // ring buffer such as 'RemovePrefix'.
-  // For example, we could implement RemovePrefix for non shared instances as:
-  //   void RemoveSuffix(size_t n) {
-  //     Position pos = FindTail(length - n);
-  //     UnrefEntries(pos.pos, this->tail_);
-  //     this->tail_ = pos.pos;
-  //     entry(retreat(pos.pos)).end_pos -= pos.offset;
-  //   }
-  inline Position FindTail(size_t offset) const;
-
-  // Find tail starting at `head`
-  inline Position FindTail(index_type head, size_t offset) const;
-
-  // Invokes f(index_type index) for each entry inside the range [head, tail>
-  template <typename F>
-  void ForEach(index_type head, index_type tail, F&& f) const {
-    index_type n1 = (tail > head) ? tail : capacity_;
-    for (index_type i = head; i < n1; ++i) f(i);
-    if (tail <= head) {
-      for (index_type i = 0; i < tail; ++i) f(i);
-    }
-  }
-
-  // Invokes f(index_type index) for each entry inside this instance.
-  template <typename F>
-  void ForEach(F&& f) const {
-    ForEach(head_, tail_, std::forward<F>(f));
-  }
-
-  // Dump this instance's data tp stream `s` in human readable format, excluding
-  // the actual data content itself. Intended for debug purposes only.
-  friend std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
-
- private:
-  enum class AddMode { kAppend, kPrepend };
-
-  using Layout = container_internal::Layout<pos_type, CordRep*, offset_type>;
-
-  class Filler;
-  class Transaction;
-  class CreateTransaction;
-
-  static constexpr size_t kLayoutAlignment = Layout::Partial().Alignment();
-
-  // Creates a new CordRepRing.
-  explicit CordRepRing(index_type capacity) : capacity_(capacity) {}
-
-  // Returns true if `index` is a valid index into this instance.
-  bool IsValidIndex(index_type index) const;
-
-  // Debug use only: validates the provided CordRepRing invariants.
-  // Verification of all CordRepRing methods can be enabled by defining
-  // EXTRA_CORD_RING_VALIDATION, i.e.: `--copts=-DEXTRA_CORD_RING_VALIDATION`
-  // Verification is VERY expensive, so only do it for debugging purposes.
-  static CordRepRing* Validate(CordRepRing* rep, const char* file = nullptr,
-                               int line = 0);
-
-  // Allocates a CordRepRing large enough to hold `capacity + extra' entries.
-  // The returned capacity may be larger if the allocated memory allows for it.
-  // The maximum capacity of a CordRepRing is capped at kMaxCapacity.
-  // Throws `std::length_error` if `capacity + extra' exceeds kMaxCapacity.
-  static CordRepRing* New(size_t capacity, size_t extra);
-
-  // Deallocates (but does not destroy) the provided ring buffer.
-  static void Delete(CordRepRing* rep);
-
-  // Destroys the provided ring buffer, decrementing the reference count of all
-  // contained child CordReps. The provided 1\`rep` should have a ref count of
-  // one (pre decrement destroy call observing `refcount.IsOne()`) or zero
-  // (post decrement destroy call observing `!refcount.Decrement()`).
-  static void Destroy(CordRepRing* rep);
-
-  // Returns a mutable reference to the logical end position array.
-  pos_type* entry_end_pos() {
-    return Layout::Partial().Pointer<0>(data_);
-  }
-
-  // Returns a mutable reference to the child pointer array.
-  CordRep** entry_child() {
-    return Layout::Partial(capacity()).Pointer<1>(data_);
-  }
-
-  // Returns a mutable reference to the data offset array.
-  offset_type* entry_data_offset() {
-    return Layout::Partial(capacity(), capacity()).Pointer<2>(data_);
-  }
-
-  // Find implementations for the non fast path 0 / length cases.
-  Position FindSlow(index_type head, size_t offset) const;
-  Position FindTailSlow(index_type head, size_t offset) const;
-
-  // Finds the index of the first node that is inside a reasonable distance
-  // of the node at `offset` from which we can continue with a linear search.
-  template <bool wrap>
-  index_type FindBinary(index_type head, index_type tail, size_t offset) const;
-
-  // Fills the current (initialized) instance from the provided source, copying
-  // entries [head, tail). Adds a reference to copied entries if `ref` is true.
-  template <bool ref>
-  void Fill(const CordRepRing* src, index_type head, index_type tail);
-
-  // Create a copy of 'rep', copying all entries [head, tail), allocating room
-  // for `extra` entries. Adds a reference on all copied entries.
-  static CordRepRing* Copy(CordRepRing* rep, index_type head, index_type tail,
-                           size_t extra = 0);
-
-  // Returns a Mutable CordRepRing reference from `rep` with room for at least
-  // `extra` additional nodes. Adopts a reference count from `rep`.
-  // This function will return `rep` if, and only if:
-  // - rep.entries + extra <= rep.capacity
-  // - rep.refcount == 1
-  // Otherwise, this function will create a new copy of `rep` with additional
-  // capacity to satisfy `extra` extra nodes, and unref the old `rep` instance.
-  //
-  // If a new CordRepRing can not be allocated, or the new capacity would exceed
-  // the maxmimum capacity, then the input is consumed only, and an exception is
-  // thrown.
-  static CordRepRing* Mutable(CordRepRing* rep, size_t extra);
-
-  // Slow path for Append(CordRepRing* rep, CordRep* child). This function is
-  // exercised if the provided `child` in Append() is not a leaf node, i.e., a
-  // ring buffer or old (concat) cord tree.
-  static CordRepRing* AppendSlow(CordRepRing* rep, CordRep* child);
-
-  // Appends the provided leaf node. Requires `child` to be FLAT or EXTERNAL.
-  static CordRepRing* AppendLeaf(CordRepRing* rep, CordRep* child,
-                                 size_t offset, size_t length);
-
-  // Prepends the provided leaf node. Requires `child` to be FLAT or EXTERNAL.
-  static CordRepRing* PrependLeaf(CordRepRing* rep, CordRep* child,
-                                  size_t offset, size_t length);
-
-  // Slow path for Prepend(CordRepRing* rep, CordRep* child). This function is
-  // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a
-  // ring buffer or old (concat) cord tree.
-  static CordRepRing* PrependSlow(CordRepRing* rep, CordRep* child);
-
-  // Slow path for Create(CordRep* child, size_t extra). This function is
-  // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a
-  // ring buffer or old (concat) cord tree.
-  static CordRepRing* CreateSlow(CordRep* child, size_t extra);
-
-  // Creates a new ring buffer from the provided `child` leaf node. Requires
-  // `child` to be FLAT or EXTERNAL. on `rep`.
-  // The returned ring buffer has a capacity of at least `1 + extra`
-  static CordRepRing* CreateFromLeaf(CordRep* child, size_t offset,
-                                     size_t length, size_t extra);
-
-  // Appends or prepends (depending on AddMode) the ring buffer in `ring' to
-  // `rep` starting at `offset` with length `len`.
-  template <AddMode mode>
-  static CordRepRing* AddRing(CordRepRing* rep, CordRepRing* ring,
-                              size_t offset, size_t len);
-
-  // Increases the data offset for entry `index` by `n`.
-  void AddDataOffset(index_type index, size_t n);
-
-  // Descreases the length for entry `index` by `n`.
-  void SubLength(index_type index, size_t n);
-
-  index_type head_;
-  index_type tail_;
-  index_type capacity_;
-  pos_type begin_pos_;
-
-  alignas(kLayoutAlignment) char data_[kLayoutAlignment];
-
-  friend struct CordRep;
-};
-
-constexpr size_t CordRepRing::AllocSize(size_t capacity) {
-  return sizeof(CordRepRing) - sizeof(data_) +
-         Layout(capacity, capacity, capacity).AllocSize();
-}
-
-inline constexpr size_t CordRepRing::Distance(pos_type pos, pos_type end_pos) {
-  return (end_pos - pos);
-}
-
-inline const char* CordRepRing::GetLeafData(const CordRep* rep) {
-  return rep->tag != EXTERNAL ? rep->flat()->Data() : rep->external()->base;
-}
-
-inline const char* CordRepRing::GetRepData(const CordRep* rep) {
-  if (rep->tag >= FLAT) return rep->flat()->Data();
-  if (rep->tag == EXTERNAL) return rep->external()->base;
-  return GetLeafData(rep->substring()->child) + rep->substring()->start;
-}
-
-inline CordRepRing::index_type CordRepRing::advance(index_type index) const {
-  assert(index < capacity_);
-  return ++index == capacity_ ? 0 : index;
-}
-
-inline CordRepRing::index_type CordRepRing::advance(index_type index,
-                                                    index_type n) const {
-  assert(index < capacity_ && n <= capacity_);
-  return (index += n) >= capacity_ ? index - capacity_ : index;
-}
-
-inline CordRepRing::index_type CordRepRing::retreat(index_type index) const {
-  assert(index < capacity_);
-  return (index > 0 ? index : capacity_) - 1;
-}
-
-inline CordRepRing::index_type CordRepRing::retreat(index_type index,
-                                                    index_type n) const {
-  assert(index < capacity_ && n <= capacity_);
-  return index >= n ? index - n : capacity_ - n + index;
-}
-
-inline absl::string_view CordRepRing::entry_data(index_type index) const {
-  size_t data_offset = entry_data_offset(index);
-  return {GetRepData(entry_child(index)) + data_offset, entry_length(index)};
-}
-
-inline bool CordRepRing::IsValidIndex(index_type index) const {
-  if (index >= capacity_) return false;
-  return (tail_ > head_) ? (index >= head_ && index < tail_)
-                         : (index >= head_ || index < tail_);
-}
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // All operations modifying a ring buffer are implemented as static methods
+        // requiring a CordRepRing instance with a reference adopted by the method.
+        //
+        // The methods return the modified ring buffer, which may be equal to the input
+        // if the input was not shared, and having large enough capacity to accommodate
+        // any newly added node(s). Otherwise, a copy of the input rep with the new
+        // node(s) added is returned.
+        //
+        // Any modification on non shared ring buffers with enough capacity will then
+        // require minimum atomic operations. Caller should where possible provide
+        // reasonable `extra` hints for both anticipated extra `flat` byte space, as
+        // well as anticipated extra nodes required for complex operations.
+        //
+        // Example of code creating a ring buffer, adding some data to it,
+        // and discarding the buffer when done:
+        //
+        //   void FunWithRings() {
+        //     // Create ring with 3 flats
+        //     CordRep* flat = CreateFlat("Hello");
+        //     CordRepRing* ring = CordRepRing::Create(flat, 2);
+        //     ring = CordRepRing::Append(ring, CreateFlat(" "));
+        //     ring = CordRepRing::Append(ring, CreateFlat("world"));
+        //     DoSomethingWithRing(ring);
+        //     CordRep::Unref(ring);
+        //   }
+        //
+        // Example of code Copying an existing ring buffer and modifying it:
+        //
+        //   void MoreFunWithRings(CordRepRing* src) {
+        //     CordRepRing* ring = CordRep::Ref(src)->ring();
+        //     ring = CordRepRing::Append(ring, CreateFlat("Hello"));
+        //     ring = CordRepRing::Append(ring, CreateFlat(" "));
+        //     ring = CordRepRing::Append(ring, CreateFlat("world"));
+        //     DoSomethingWithRing(ring);
+        //     CordRep::Unref(ring);
+        //   }
+        //
+        class CordRepRing : public CordRep
+        {
+        public:
+            // `pos_type` represents a 'logical position'. A CordRepRing instance has a
+            // `begin_pos` (default 0), and each node inside the buffer will have an
+            // `end_pos` which is the `end_pos` of the previous node (or `begin_pos`) plus
+            // this node's length. The purpose is to allow for a binary search on this
+            // position, while allowing O(1) prepend and append operations.
+            using pos_type = size_t;
+
+            // `index_type` is the type for the `head`, `tail` and `capacity` indexes.
+            // Ring buffers are limited to having no more than four billion entries.
+            using index_type = uint32_t;
+
+            // `offset_type` is the type for the data offset inside a child rep's data.
+            using offset_type = uint32_t;
+
+            // Position holds the node index and relative offset into the node for
+            // some physical offset in the contained data as returned by the Find()
+            // and FindTail() methods.
+            struct Position
+            {
+                index_type index;
+                size_t offset;
+            };
+
+            // The maximum # of child nodes that can be hosted inside a CordRepRing.
+            static constexpr size_t kMaxCapacity = (std::numeric_limits<uint32_t>::max)();
+
+            // CordRepring can not be default constructed, moved, copied or assigned.
+            CordRepRing() = delete;
+            CordRepRing(const CordRepRing&) = delete;
+            CordRepRing& operator=(const CordRepRing&) = delete;
+
+            // Returns true if this instance is valid, false if some or all of the
+            // invariants are broken. Intended for debug purposes only.
+            // `output` receives an explanation of the broken invariants.
+            bool IsValid(std::ostream& output) const;
+
+            // Returns the size in bytes for a CordRepRing with `capacity' entries.
+            static constexpr size_t AllocSize(size_t capacity);
+
+            // Returns the distance in bytes from `pos` to `end_pos`.
+            static constexpr size_t Distance(pos_type pos, pos_type end_pos);
+
+            // Creates a new ring buffer from the provided `rep`. Adopts a reference
+            // on `rep`. The returned ring buffer has a capacity of at least `extra + 1`
+            static CordRepRing* Create(CordRep* child, size_t extra = 0);
+
+            // `head`, `tail` and `capacity` indexes defining the ring buffer boundaries.
+            index_type head() const
+            {
+                return head_;
+            }
+            index_type tail() const
+            {
+                return tail_;
+            }
+            index_type capacity() const
+            {
+                return capacity_;
+            }
+
+            // Returns the number of entries in this instance.
+            index_type entries() const
+            {
+                return entries(head_, tail_);
+            }
+
+            // Returns the logical begin position of this instance.
+            pos_type begin_pos() const
+            {
+                return begin_pos_;
+            }
+
+            // Returns the number of entries for a given head-tail range.
+            // Requires `head` and `tail` values to be less than `capacity()`.
+            index_type entries(index_type head, index_type tail) const
+            {
+                assert(head < capacity_ && tail < capacity_);
+                return tail - head + ((tail > head) ? 0 : capacity_);
+            }
+
+            // Returns the logical end position of entry `index`.
+            pos_type const& entry_end_pos(index_type index) const
+            {
+                assert(IsValidIndex(index));
+                return Layout::Partial().Pointer<0>(data_)[index];
+            }
+
+            // Returns the child pointer of entry `index`.
+            CordRep* const& entry_child(index_type index) const
+            {
+                assert(IsValidIndex(index));
+                return Layout::Partial(capacity()).Pointer<1>(data_)[index];
+            }
+
+            // Returns the data offset of entry `index`
+            offset_type const& entry_data_offset(index_type index) const
+            {
+                assert(IsValidIndex(index));
+                return Layout::Partial(capacity(), capacity()).Pointer<2>(data_)[index];
+            }
+
+            // Appends the provided child node to the `rep` instance.
+            // Adopts a reference from `rep` and `child` which may not be null.
+            // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node
+            // containing a FLAT or EXTERNAL node, then flat or external the node is added
+            // 'as is', with an offset added for the SUBSTRING case.
+            // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING or
+            // CONCAT tree, then all child nodes not excluded by any start offset or
+            // length values are added recursively.
+            static CordRepRing* Append(CordRepRing* rep, CordRep* child);
+
+            // Appends the provided string data to the `rep` instance.
+            // This function will attempt to utilize any remaining capacity in the last
+            // node of the input if that node is not shared (directly or indirectly), and
+            // of type FLAT. Remaining data will be added as one or more FLAT nodes.
+            // Any last node added to the ring buffer will be allocated with up to
+            // `extra` bytes of capacity for (anticipated) subsequent append actions.
+            static CordRepRing* Append(CordRepRing* rep, string_view data, size_t extra = 0);
+
+            // Prepends the provided child node to the `rep` instance.
+            // Adopts a reference from `rep` and `child` which may not be null.
+            // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node
+            // containing a FLAT or EXTERNAL node, then flat or external the node is
+            // prepended 'as is', with an optional offset added for the SUBSTRING case.
+            // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING
+            // or CONCAT tree, then all child nodes not excluded by any start offset or
+            // length values are added recursively.
+            static CordRepRing* Prepend(CordRepRing* rep, CordRep* child);
+
+            // Prepends the provided string data to the `rep` instance.
+            // This function will attempt to utilize any remaining capacity in the first
+            // node of the input if that node is not shared (directly or indirectly), and
+            // of type FLAT. Remaining data will be added as one or more FLAT nodes.
+            // Any first node prepnded to the ring buffer will be allocated with up to
+            // `extra` bytes of capacity for (anticipated) subsequent prepend actions.
+            static CordRepRing* Prepend(CordRepRing* rep, string_view data, size_t extra = 0);
+
+            // Returns a span referencing potentially unused capacity in the last node.
+            // The returned span may be empty if no such capacity is available, or if the
+            // current instance is shared. Else, a span of size `n <= size` is returned.
+            // If non empty, the ring buffer is adjusted to the new length, with the newly
+            // added capacity left uninitialized. Callers should assign a value to the
+            // entire span before any other operations on this instance.
+            Span<char> GetAppendBuffer(size_t size);
+
+            // Returns a span referencing potentially unused capacity in the first node.
+            // This function is identical to GetAppendBuffer except that it returns a span
+            // referencing up to `size` capacity directly before the existing data.
+            Span<char> GetPrependBuffer(size_t size);
+
+            // Returns a cord ring buffer containing `len` bytes of data starting at
+            // `offset`. If the input is not shared, this function will remove all head
+            // and tail child nodes outside of the requested range, and adjust the new
+            // head and tail nodes as required. If the input is shared, this function
+            // returns a new instance sharing some or all of the nodes from the input.
+            static CordRepRing* SubRing(CordRepRing* r, size_t offset, size_t len, size_t extra = 0);
+
+            // Returns a cord ring buffer with the first `len` bytes removed.
+            // If the input is not shared, this function will remove all head child nodes
+            // fully inside the first `length` bytes, and adjust the new head as required.
+            // If the input is shared, this function returns a new instance sharing some
+            // or all of the nodes from the input.
+            static CordRepRing* RemoveSuffix(CordRepRing* r, size_t len, size_t extra = 0);
+
+            // Returns a cord ring buffer with the last `len` bytes removed.
+            // If the input is not shared, this function will remove all head child nodes
+            // fully inside the first `length` bytes, and adjust the new head as required.
+            // If the input is shared, this function returns a new instance sharing some
+            // or all of the nodes from the input.
+            static CordRepRing* RemovePrefix(CordRepRing* r, size_t len, size_t extra = 0);
+
+            // Returns the character at `offset`. Requires that `offset < length`.
+            char GetCharacter(size_t offset) const;
+
+            // Returns true if this instance manages a single contiguous buffer, in which
+            // case the (optional) output parameter `fragment` is set. Otherwise, the
+            // function returns false, and `fragment` is left unchanged.
+            bool IsFlat(absl::string_view* fragment) const;
+
+            // Returns true if the data starting at `offset` with length `len` is
+            // managed by this instance inside a single contiguous buffer, in which case
+            // the (optional) output parameter `fragment` is set to the contiguous memory
+            // starting at offset `offset` with length `length`. Otherwise, the function
+            // returns false, and `fragment` is left unchanged.
+            bool IsFlat(size_t offset, size_t len, absl::string_view* fragment) const;
+
+            // Testing only: set capacity to requested capacity.
+            void SetCapacityForTesting(size_t capacity);
+
+            // Returns the CordRep data pointer for the provided CordRep.
+            // Requires that the provided `rep` is either a FLAT or EXTERNAL CordRep.
+            static const char* GetLeafData(const CordRep* rep);
+
+            // Returns the CordRep data pointer for the provided CordRep.
+            // Requires that `rep` is either a FLAT, EXTERNAL, or SUBSTRING CordRep.
+            static const char* GetRepData(const CordRep* rep);
+
+            // Advances the provided position, wrapping around capacity as needed.
+            // Requires `index` < capacity()
+            inline index_type advance(index_type index) const;
+
+            // Advances the provided position by 'n`, wrapping around capacity as needed.
+            // Requires `index` < capacity() and `n` <= capacity.
+            inline index_type advance(index_type index, index_type n) const;
+
+            // Retreats the provided position, wrapping around 0 as needed.
+            // Requires `index` < capacity()
+            inline index_type retreat(index_type index) const;
+
+            // Retreats the provided position by 'n', wrapping around 0 as needed.
+            // Requires `index` < capacity()
+            inline index_type retreat(index_type index, index_type n) const;
+
+            // Returns the logical begin position of entry `index`
+            pos_type const& entry_begin_pos(index_type index) const
+            {
+                return (index == head_) ? begin_pos_ : entry_end_pos(retreat(index));
+            }
+
+            // Returns the physical start offset of entry `index`
+            size_t entry_start_offset(index_type index) const
+            {
+                return Distance(begin_pos_, entry_begin_pos(index));
+            }
+
+            // Returns the physical end offset of entry `index`
+            size_t entry_end_offset(index_type index) const
+            {
+                return Distance(begin_pos_, entry_end_pos(index));
+            }
+
+            // Returns the data length for entry `index`
+            size_t entry_length(index_type index) const
+            {
+                return Distance(entry_begin_pos(index), entry_end_pos(index));
+            }
+
+            // Returns the data for entry `index`
+            absl::string_view entry_data(index_type index) const;
+
+            // Returns the position for `offset` as {index, prefix}. `index` holds the
+            // index of the entry at the specified offset and `prefix` holds the relative
+            // offset inside that entry.
+            // Requires `offset` < length.
+            //
+            // For example we can implement GetCharacter(offset) as:
+            //   char GetCharacter(size_t offset) {
+            //     Position pos = this->Find(offset);
+            //     return this->entry_data(pos.pos)[pos.offset];
+            //   }
+            inline Position Find(size_t offset) const;
+
+            // Find starting at `head`
+            inline Position Find(index_type head, size_t offset) const;
+
+            // Returns the tail position for `offset` as {tail index, suffix}.
+            // `tail index` holds holds the index of the entry holding the offset directly
+            // before 'offset` advanced by one. 'suffix` holds the relative offset from
+            // that relative offset in the entry to the end of the entry.
+            // For example, FindTail(length) will return {tail(), 0}, FindTail(length - 5)
+            // will return {retreat(tail), 5)} provided the preceding entry contains at
+            // least 5 bytes of data.
+            // Requires offset >= 1 && offset <= length.
+            //
+            // This function is very useful in functions that need to clip the end of some
+            // ring buffer such as 'RemovePrefix'.
+            // For example, we could implement RemovePrefix for non shared instances as:
+            //   void RemoveSuffix(size_t n) {
+            //     Position pos = FindTail(length - n);
+            //     UnrefEntries(pos.pos, this->tail_);
+            //     this->tail_ = pos.pos;
+            //     entry(retreat(pos.pos)).end_pos -= pos.offset;
+            //   }
+            inline Position FindTail(size_t offset) const;
+
+            // Find tail starting at `head`
+            inline Position FindTail(index_type head, size_t offset) const;
+
+            // Invokes f(index_type index) for each entry inside the range [head, tail>
+            template<typename F>
+            void ForEach(index_type head, index_type tail, F&& f) const
+            {
+                index_type n1 = (tail > head) ? tail : capacity_;
+                for (index_type i = head; i < n1; ++i)
+                    f(i);
+                if (tail <= head)
+                {
+                    for (index_type i = 0; i < tail; ++i)
+                        f(i);
+                }
+            }
+
+            // Invokes f(index_type index) for each entry inside this instance.
+            template<typename F>
+            void ForEach(F&& f) const
+            {
+                ForEach(head_, tail_, std::forward<F>(f));
+            }
+
+            // Dump this instance's data tp stream `s` in human readable format, excluding
+            // the actual data content itself. Intended for debug purposes only.
+            friend std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
+
+        private:
+            enum class AddMode
+            {
+                kAppend,
+                kPrepend
+            };
+
+            using Layout = container_internal::Layout<pos_type, CordRep*, offset_type>;
+
+            class Filler;
+            class Transaction;
+            class CreateTransaction;
+
+            static constexpr size_t kLayoutAlignment = Layout::Partial().Alignment();
+
+            // Creates a new CordRepRing.
+            explicit CordRepRing(index_type capacity) :
+                capacity_(capacity)
+            {
+            }
+
+            // Returns true if `index` is a valid index into this instance.
+            bool IsValidIndex(index_type index) const;
+
+            // Debug use only: validates the provided CordRepRing invariants.
+            // Verification of all CordRepRing methods can be enabled by defining
+            // EXTRA_CORD_RING_VALIDATION, i.e.: `--copts=-DEXTRA_CORD_RING_VALIDATION`
+            // Verification is VERY expensive, so only do it for debugging purposes.
+            static CordRepRing* Validate(CordRepRing* rep, const char* file = nullptr, int line = 0);
+
+            // Allocates a CordRepRing large enough to hold `capacity + extra' entries.
+            // The returned capacity may be larger if the allocated memory allows for it.
+            // The maximum capacity of a CordRepRing is capped at kMaxCapacity.
+            // Throws `std::length_error` if `capacity + extra' exceeds kMaxCapacity.
+            static CordRepRing* New(size_t capacity, size_t extra);
+
+            // Deallocates (but does not destroy) the provided ring buffer.
+            static void Delete(CordRepRing* rep);
+
+            // Destroys the provided ring buffer, decrementing the reference count of all
+            // contained child CordReps. The provided 1\`rep` should have a ref count of
+            // one (pre decrement destroy call observing `refcount.IsOne()`) or zero
+            // (post decrement destroy call observing `!refcount.Decrement()`).
+            static void Destroy(CordRepRing* rep);
+
+            // Returns a mutable reference to the logical end position array.
+            pos_type* entry_end_pos()
+            {
+                return Layout::Partial().Pointer<0>(data_);
+            }
+
+            // Returns a mutable reference to the child pointer array.
+            CordRep** entry_child()
+            {
+                return Layout::Partial(capacity()).Pointer<1>(data_);
+            }
+
+            // Returns a mutable reference to the data offset array.
+            offset_type* entry_data_offset()
+            {
+                return Layout::Partial(capacity(), capacity()).Pointer<2>(data_);
+            }
+
+            // Find implementations for the non fast path 0 / length cases.
+            Position FindSlow(index_type head, size_t offset) const;
+            Position FindTailSlow(index_type head, size_t offset) const;
+
+            // Finds the index of the first node that is inside a reasonable distance
+            // of the node at `offset` from which we can continue with a linear search.
+            template<bool wrap>
+            index_type FindBinary(index_type head, index_type tail, size_t offset) const;
+
+            // Fills the current (initialized) instance from the provided source, copying
+            // entries [head, tail). Adds a reference to copied entries if `ref` is true.
+            template<bool ref>
+            void Fill(const CordRepRing* src, index_type head, index_type tail);
+
+            // Create a copy of 'rep', copying all entries [head, tail), allocating room
+            // for `extra` entries. Adds a reference on all copied entries.
+            static CordRepRing* Copy(CordRepRing* rep, index_type head, index_type tail, size_t extra = 0);
+
+            // Returns a Mutable CordRepRing reference from `rep` with room for at least
+            // `extra` additional nodes. Adopts a reference count from `rep`.
+            // This function will return `rep` if, and only if:
+            // - rep.entries + extra <= rep.capacity
+            // - rep.refcount == 1
+            // Otherwise, this function will create a new copy of `rep` with additional
+            // capacity to satisfy `extra` extra nodes, and unref the old `rep` instance.
+            //
+            // If a new CordRepRing can not be allocated, or the new capacity would exceed
+            // the maxmimum capacity, then the input is consumed only, and an exception is
+            // thrown.
+            static CordRepRing* Mutable(CordRepRing* rep, size_t extra);
+
+            // Slow path for Append(CordRepRing* rep, CordRep* child). This function is
+            // exercised if the provided `child` in Append() is not a leaf node, i.e., a
+            // ring buffer or old (concat) cord tree.
+            static CordRepRing* AppendSlow(CordRepRing* rep, CordRep* child);
+
+            // Appends the provided leaf node. Requires `child` to be FLAT or EXTERNAL.
+            static CordRepRing* AppendLeaf(CordRepRing* rep, CordRep* child, size_t offset, size_t length);
+
+            // Prepends the provided leaf node. Requires `child` to be FLAT or EXTERNAL.
+            static CordRepRing* PrependLeaf(CordRepRing* rep, CordRep* child, size_t offset, size_t length);
+
+            // Slow path for Prepend(CordRepRing* rep, CordRep* child). This function is
+            // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a
+            // ring buffer or old (concat) cord tree.
+            static CordRepRing* PrependSlow(CordRepRing* rep, CordRep* child);
+
+            // Slow path for Create(CordRep* child, size_t extra). This function is
+            // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a
+            // ring buffer or old (concat) cord tree.
+            static CordRepRing* CreateSlow(CordRep* child, size_t extra);
+
+            // Creates a new ring buffer from the provided `child` leaf node. Requires
+            // `child` to be FLAT or EXTERNAL. on `rep`.
+            // The returned ring buffer has a capacity of at least `1 + extra`
+            static CordRepRing* CreateFromLeaf(CordRep* child, size_t offset, size_t length, size_t extra);
+
+            // Appends or prepends (depending on AddMode) the ring buffer in `ring' to
+            // `rep` starting at `offset` with length `len`.
+            template<AddMode mode>
+            static CordRepRing* AddRing(CordRepRing* rep, CordRepRing* ring, size_t offset, size_t len);
+
+            // Increases the data offset for entry `index` by `n`.
+            void AddDataOffset(index_type index, size_t n);
+
+            // Descreases the length for entry `index` by `n`.
+            void SubLength(index_type index, size_t n);
+
+            index_type head_;
+            index_type tail_;
+            index_type capacity_;
+            pos_type begin_pos_;
+
+            alignas(kLayoutAlignment) char data_[kLayoutAlignment];
+
+            friend struct CordRep;
+        };
+
+        constexpr size_t CordRepRing::AllocSize(size_t capacity)
+        {
+            return sizeof(CordRepRing) - sizeof(data_) +
+                   Layout(capacity, capacity, capacity).AllocSize();
+        }
+
+        inline constexpr size_t CordRepRing::Distance(pos_type pos, pos_type end_pos)
+        {
+            return (end_pos - pos);
+        }
+
+        inline const char* CordRepRing::GetLeafData(const CordRep* rep)
+        {
+            return rep->tag != EXTERNAL ? rep->flat()->Data() : rep->external()->base;
+        }
+
+        inline const char* CordRepRing::GetRepData(const CordRep* rep)
+        {
+            if (rep->tag >= FLAT)
+                return rep->flat()->Data();
+            if (rep->tag == EXTERNAL)
+                return rep->external()->base;
+            return GetLeafData(rep->substring()->child) + rep->substring()->start;
+        }
+
+        inline CordRepRing::index_type CordRepRing::advance(index_type index) const
+        {
+            assert(index < capacity_);
+            return ++index == capacity_ ? 0 : index;
+        }
+
+        inline CordRepRing::index_type CordRepRing::advance(index_type index, index_type n) const
+        {
+            assert(index < capacity_ && n <= capacity_);
+            return (index += n) >= capacity_ ? index - capacity_ : index;
+        }
+
+        inline CordRepRing::index_type CordRepRing::retreat(index_type index) const
+        {
+            assert(index < capacity_);
+            return (index > 0 ? index : capacity_) - 1;
+        }
+
+        inline CordRepRing::index_type CordRepRing::retreat(index_type index, index_type n) const
+        {
+            assert(index < capacity_ && n <= capacity_);
+            return index >= n ? index - n : capacity_ - n + index;
+        }
+
+        inline absl::string_view CordRepRing::entry_data(index_type index) const
+        {
+            size_t data_offset = entry_data_offset(index);
+            return {GetRepData(entry_child(index)) + data_offset, entry_length(index)};
+        }
+
+        inline bool CordRepRing::IsValidIndex(index_type index) const
+        {
+            if (index >= capacity_)
+                return false;
+            return (tail_ > head_) ? (index >= head_ && index < tail_) : (index >= head_ || index < tail_);
+        }
 
 #ifndef EXTRA_CORD_RING_VALIDATION
-inline CordRepRing* CordRepRing::Validate(CordRepRing* rep,
-                                          const char* /*file*/, int /*line*/) {
-  return rep;
-}
+        inline CordRepRing* CordRepRing::Validate(CordRepRing* rep, const char* /*file*/, int /*line*/)
+        {
+            return rep;
+        }
 #endif
 
-inline CordRepRing::Position CordRepRing::Find(size_t offset) const {
-  assert(offset < length);
-  return (offset == 0) ? Position{head_, 0} : FindSlow(head_, offset);
-}
-
-inline CordRepRing::Position CordRepRing::Find(index_type head,
-                                               size_t offset) const {
-  assert(offset < length);
-  assert(IsValidIndex(head) && offset >= entry_start_offset(head));
-  return (offset == 0) ? Position{head_, 0} : FindSlow(head, offset);
-}
-
-inline CordRepRing::Position CordRepRing::FindTail(size_t offset) const {
-  assert(offset > 0 && offset <= length);
-  return (offset == length) ? Position{tail_, 0} : FindTailSlow(head_, offset);
-}
-
-inline CordRepRing::Position CordRepRing::FindTail(index_type head,
-                                                   size_t offset) const {
-  assert(offset > 0 && offset <= length);
-  assert(IsValidIndex(head) && offset >= entry_start_offset(head) + 1);
-  return (offset == length) ? Position{tail_, 0} : FindTailSlow(head, offset);
-}
-
-// Now that CordRepRing is defined, we can define CordRep's helper casts:
-inline CordRepRing* CordRep::ring() {
-  assert(IsRing());
-  return static_cast<CordRepRing*>(this);
-}
-
-inline const CordRepRing* CordRep::ring() const {
-  assert(IsRing());
-  return static_cast<const CordRepRing*>(this);
-}
-
-inline bool CordRepRing::IsFlat(absl::string_view* fragment) const {
-  if (entries() == 1) {
-    if (fragment) *fragment = entry_data(head());
-    return true;
-  }
-  return false;
-}
-
-inline bool CordRepRing::IsFlat(size_t offset, size_t len,
-                                absl::string_view* fragment) const {
-  const Position pos = Find(offset);
-  const absl::string_view data = entry_data(pos.index);
-  if (data.length() >= len && data.length() - len >= pos.offset) {
-    if (fragment) *fragment = data.substr(pos.offset, len);
-    return true;
-  }
-  return false;
-}
-
-std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+        inline CordRepRing::Position CordRepRing::Find(size_t offset) const
+        {
+            assert(offset < length);
+            return (offset == 0) ? Position{head_, 0} : FindSlow(head_, offset);
+        }
+
+        inline CordRepRing::Position CordRepRing::Find(index_type head, size_t offset) const
+        {
+            assert(offset < length);
+            assert(IsValidIndex(head) && offset >= entry_start_offset(head));
+            return (offset == 0) ? Position{head_, 0} : FindSlow(head, offset);
+        }
+
+        inline CordRepRing::Position CordRepRing::FindTail(size_t offset) const
+        {
+            assert(offset > 0 && offset <= length);
+            return (offset == length) ? Position{tail_, 0} : FindTailSlow(head_, offset);
+        }
+
+        inline CordRepRing::Position CordRepRing::FindTail(index_type head, size_t offset) const
+        {
+            assert(offset > 0 && offset <= length);
+            assert(IsValidIndex(head) && offset >= entry_start_offset(head) + 1);
+            return (offset == length) ? Position{tail_, 0} : FindTailSlow(head, offset);
+        }
+
+        // Now that CordRepRing is defined, we can define CordRep's helper casts:
+        inline CordRepRing* CordRep::ring()
+        {
+            assert(IsRing());
+            return static_cast<CordRepRing*>(this);
+        }
+
+        inline const CordRepRing* CordRep::ring() const
+        {
+            assert(IsRing());
+            return static_cast<const CordRepRing*>(this);
+        }
+
+        inline bool CordRepRing::IsFlat(absl::string_view* fragment) const
+        {
+            if (entries() == 1)
+            {
+                if (fragment)
+                    *fragment = entry_data(head());
+                return true;
+            }
+            return false;
+        }
+
+        inline bool CordRepRing::IsFlat(size_t offset, size_t len, absl::string_view* fragment) const
+        {
+            const Position pos = Find(offset);
+            const absl::string_view data = entry_data(pos.index);
+            if (data.length() >= len && data.length() - len >= pos.offset)
+            {
+                if (fragment)
+                    *fragment = data.substr(pos.offset, len);
+                return true;
+            }
+            return false;
+        }
+
+        std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring_reader.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring_reader.h
index 7ceeaa0..45e9af4 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring_reader.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_ring_reader.h
@@ -23,96 +23,120 @@
 #include "absl/strings/internal/cord_rep_ring.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordRepRingReader provides basic navigation over CordRepRing data.
-class CordRepRingReader {
- public:
-  // Returns true if this instance is not empty.
-  explicit operator bool() const { return ring_ != nullptr; }
-
-  // Returns the ring buffer reference for this instance, or nullptr if empty.
-  CordRepRing* ring() const { return ring_; }
-
-  // Returns the current node index inside the ring buffer for this instance.
-  // The returned value is undefined if this instance is empty.
-  CordRepRing::index_type index() const { return index_; }
-
-  // Returns the current node inside the ring buffer for this instance.
-  // The returned value is undefined if this instance is empty.
-  CordRep* node() const { return ring_->entry_child(index_); }
-
-  // Returns the length of the referenced ring buffer.
-  // Requires the current instance to be non empty.
-  size_t length() const {
-    assert(ring_);
-    return ring_->length;
-  }
-
-  // Returns the end offset of the last navigated-to chunk, which represents the
-  // total bytes 'consumed' relative to the start of the ring. The returned
-  // value is never zero. For example, initializing a reader with a ring buffer
-  // with a first chunk of 19 bytes will return consumed() = 19.
-  // Requires the current instance to be non empty.
-  size_t consumed() const {
-    assert(ring_);
-    return ring_->entry_end_offset(index_);
-  }
-
-  // Returns the number of bytes remaining beyond the last navigated-to chunk.
-  // Requires the current instance to be non empty.
-  size_t remaining() const {
-    assert(ring_);
-    return length() - consumed();
-  }
-
-  // Resets this instance to an empty value
-  void Reset() { ring_ = nullptr; }
-
-  // Resets this instance to the start of `ring`. `ring` must not be null.
-  // Returns a reference into the first chunk of the provided ring.
-  absl::string_view Reset(CordRepRing* ring) {
-    assert(ring);
-    ring_ = ring;
-    index_ = ring_->head();
-    return ring_->entry_data(index_);
-  }
-
-  // Navigates to the next chunk inside the reference ring buffer.
-  // Returns a reference into the navigated-to chunk.
-  // Requires remaining() to be non zero.
-  absl::string_view Next() {
-    assert(remaining());
-    index_ = ring_->advance(index_);
-    return ring_->entry_data(index_);
-  }
-
-  // Navigates to the chunk at offset `offset`.
-  // Returns a reference into the navigated-to chunk, adjusted for the relative
-  // position of `offset` into that chunk. For example, calling Seek(13) on a
-  // ring buffer containing 2 chunks of 10 and 20 bytes respectively will return
-  // a string view into the second chunk starting at offset 3 with a size of 17.
-  // Requires `offset` to be less than `length()`
-  absl::string_view Seek(size_t offset) {
-    assert(offset < length());
-    size_t current = ring_->entry_end_offset(index_);
-    CordRepRing::index_type hint = (offset >= current) ? index_ : ring_->head();
-    const CordRepRing::Position head = ring_->Find(hint, offset);
-    index_ = head.index;
-    auto data = ring_->entry_data(head.index);
-    data.remove_prefix(head.offset);
-    return data;
-  }
-
- private:
-  CordRepRing* ring_ = nullptr;
-  CordRepRing::index_type index_;
-};
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // CordRepRingReader provides basic navigation over CordRepRing data.
+        class CordRepRingReader
+        {
+        public:
+            // Returns true if this instance is not empty.
+            explicit operator bool() const
+            {
+                return ring_ != nullptr;
+            }
+
+            // Returns the ring buffer reference for this instance, or nullptr if empty.
+            CordRepRing* ring() const
+            {
+                return ring_;
+            }
+
+            // Returns the current node index inside the ring buffer for this instance.
+            // The returned value is undefined if this instance is empty.
+            CordRepRing::index_type index() const
+            {
+                return index_;
+            }
+
+            // Returns the current node inside the ring buffer for this instance.
+            // The returned value is undefined if this instance is empty.
+            CordRep* node() const
+            {
+                return ring_->entry_child(index_);
+            }
+
+            // Returns the length of the referenced ring buffer.
+            // Requires the current instance to be non empty.
+            size_t length() const
+            {
+                assert(ring_);
+                return ring_->length;
+            }
+
+            // Returns the end offset of the last navigated-to chunk, which represents the
+            // total bytes 'consumed' relative to the start of the ring. The returned
+            // value is never zero. For example, initializing a reader with a ring buffer
+            // with a first chunk of 19 bytes will return consumed() = 19.
+            // Requires the current instance to be non empty.
+            size_t consumed() const
+            {
+                assert(ring_);
+                return ring_->entry_end_offset(index_);
+            }
+
+            // Returns the number of bytes remaining beyond the last navigated-to chunk.
+            // Requires the current instance to be non empty.
+            size_t remaining() const
+            {
+                assert(ring_);
+                return length() - consumed();
+            }
+
+            // Resets this instance to an empty value
+            void Reset()
+            {
+                ring_ = nullptr;
+            }
+
+            // Resets this instance to the start of `ring`. `ring` must not be null.
+            // Returns a reference into the first chunk of the provided ring.
+            absl::string_view Reset(CordRepRing* ring)
+            {
+                assert(ring);
+                ring_ = ring;
+                index_ = ring_->head();
+                return ring_->entry_data(index_);
+            }
+
+            // Navigates to the next chunk inside the reference ring buffer.
+            // Returns a reference into the navigated-to chunk.
+            // Requires remaining() to be non zero.
+            absl::string_view Next()
+            {
+                assert(remaining());
+                index_ = ring_->advance(index_);
+                return ring_->entry_data(index_);
+            }
+
+            // Navigates to the chunk at offset `offset`.
+            // Returns a reference into the navigated-to chunk, adjusted for the relative
+            // position of `offset` into that chunk. For example, calling Seek(13) on a
+            // ring buffer containing 2 chunks of 10 and 20 bytes respectively will return
+            // a string view into the second chunk starting at offset 3 with a size of 17.
+            // Requires `offset` to be less than `length()`
+            absl::string_view Seek(size_t offset)
+            {
+                assert(offset < length());
+                size_t current = ring_->entry_end_offset(index_);
+                CordRepRing::index_type hint = (offset >= current) ? index_ : ring_->head();
+                const CordRepRing::Position head = ring_->Find(hint, offset);
+                index_ = head.index;
+                auto data = ring_->entry_data(head.index);
+                data.remove_prefix(head.offset);
+                return data;
+            }
+
+        private:
+            CordRepRing* ring_ = nullptr;
+            CordRepRing::index_type index_;
+        };
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_test_util.h b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_test_util.h
index 18a0a19..98af8bd 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_test_util.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cord_rep_test_util.h
@@ -28,178 +28,223 @@
 #include "absl/strings/internal/cord_rep_flat.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cordrep_testing {
-
-inline cord_internal::CordRepSubstring* MakeSubstring(
-    size_t start, size_t len, cord_internal::CordRep* rep) {
-  auto* sub = new cord_internal::CordRepSubstring;
-  sub->tag = cord_internal::SUBSTRING;
-  sub->start = start;
-  sub->length = len <= 0 ? rep->length - start + len : len;
-  sub->child = rep;
-  return sub;
-}
-
-inline cord_internal::CordRepFlat* MakeFlat(absl::string_view value) {
-  assert(value.length() <= cord_internal::kMaxFlatLength);
-  auto* flat = cord_internal::CordRepFlat::New(value.length());
-  flat->length = value.length();
-  memcpy(flat->Data(), value.data(), value.length());
-  return flat;
-}
-
-// Creates an external node for testing
-inline cord_internal::CordRepExternal* MakeExternal(absl::string_view s) {
-  struct Rep : public cord_internal::CordRepExternal {
-    std::string s;
-    explicit Rep(absl::string_view sv) : s(sv) {
-      this->tag = cord_internal::EXTERNAL;
-      this->base = s.data();
-      this->length = s.length();
-      this->releaser_invoker = [](cord_internal::CordRepExternal* self) {
-        delete static_cast<Rep*>(self);
-      };
-    }
-  };
-  return new Rep(s);
-}
-
-inline std::string CreateRandomString(size_t n) {
-  absl::string_view data =
-      "abcdefghijklmnopqrstuvwxyz"
-      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-      "0123456789~!@#$%^&*()_+=-<>?:\"{}[]|";
-  std::minstd_rand rnd;
-  std::uniform_int_distribution<size_t> dist(0, data.size() - 1);
-  std::string s(n, ' ');
-  for (size_t i = 0; i < n; ++i) {
-    s[i] = data[dist(rnd)];
-  }
-  return s;
-}
-
-// Creates an array of flats from the provided string, chopping
-// the provided string up into flats of size `chunk_size` characters
-// resulting in roughly `data.size() / chunk_size` total flats.
-inline std::vector<cord_internal::CordRep*> CreateFlatsFromString(
-    absl::string_view data, size_t chunk_size) {
-  assert(chunk_size > 0);
-  std::vector<cord_internal::CordRep*> flats;
-  for (absl::string_view s = data; !s.empty(); s.remove_prefix(chunk_size)) {
-    flats.push_back(MakeFlat(s.substr(0, chunk_size)));
-  }
-  return flats;
-}
-
-inline cord_internal::CordRepBtree* CordRepBtreeFromFlats(
-    absl::Span<cord_internal::CordRep* const> flats) {
-  assert(!flats.empty());
-  auto* node = cord_internal::CordRepBtree::Create(flats[0]);
-  for (size_t i = 1; i < flats.size(); ++i) {
-    node = cord_internal::CordRepBtree::Append(node, flats[i]);
-  }
-  return node;
-}
-
-template <typename Fn>
-inline void CordVisitReps(cord_internal::CordRep* rep, Fn&& fn) {
-  fn(rep);
-  while (rep->tag == cord_internal::SUBSTRING) {
-    rep = rep->substring()->child;
-    fn(rep);
-  }
-  if (rep->tag == cord_internal::BTREE) {
-    for (cord_internal::CordRep* edge : rep->btree()->Edges()) {
-      CordVisitReps(edge, fn);
-    }
-  }
-}
-
-template <typename Predicate>
-inline std::vector<cord_internal::CordRep*> CordCollectRepsIf(
-    Predicate&& predicate, cord_internal::CordRep* rep) {
-  std::vector<cord_internal::CordRep*> reps;
-  CordVisitReps(rep, [&reps, &predicate](cord_internal::CordRep* rep) {
-    if (predicate(rep)) reps.push_back(rep);
-  });
-  return reps;
-}
-
-inline std::vector<cord_internal::CordRep*> CordCollectReps(
-    cord_internal::CordRep* rep) {
-  std::vector<cord_internal::CordRep*> reps;
-  auto fn = [&reps](cord_internal::CordRep* rep) { reps.push_back(rep); };
-  CordVisitReps(rep, fn);
-  return reps;
-}
-
-inline void CordToString(cord_internal::CordRep* rep, std::string& s) {
-  size_t offset = 0;
-  size_t length = rep->length;
-  while (rep->tag == cord_internal::SUBSTRING) {
-    offset += rep->substring()->start;
-    rep = rep->substring()->child;
-  }
-  if (rep->tag == cord_internal::BTREE) {
-    for (cord_internal::CordRep* edge : rep->btree()->Edges()) {
-      CordToString(edge, s);
-    }
-  } else if (rep->tag >= cord_internal::FLAT) {
-    s.append(rep->flat()->Data() + offset, length);
-  } else if (rep->tag == cord_internal::EXTERNAL) {
-    s.append(rep->external()->base + offset, length);
-  } else {
-    ABSL_RAW_LOG(FATAL, "Unsupported tag %d", rep->tag);
-  }
-}
-
-inline std::string CordToString(cord_internal::CordRep* rep) {
-  std::string s;
-  s.reserve(rep->length);
-  CordToString(rep, s);
-  return s;
-}
-
-// RAII Helper class to automatically unref reps on destruction.
-class AutoUnref {
- public:
-  ~AutoUnref() {
-    for (CordRep* rep : unrefs_) CordRep::Unref(rep);
-  }
-
-  // Adds `rep` to the list of reps to be unreffed at destruction.
-  template <typename CordRepType>
-  CordRepType* Add(CordRepType* rep) {
-    unrefs_.push_back(rep);
-    return rep;
-  }
-
-  // Increments the reference count of `rep` by one, and adds it to
-  // the list of reps to be unreffed at destruction.
-  template <typename CordRepType>
-  CordRepType* Ref(CordRepType* rep) {
-    unrefs_.push_back(CordRep::Ref(rep));
-    return rep;
-  }
-
-  // Increments the reference count of `rep` by one if `condition` is true,
-  // and adds it to the list of reps to be unreffed at destruction.
-  template <typename CordRepType>
-  CordRepType* RefIf(bool condition, CordRepType* rep) {
-    if (condition) unrefs_.push_back(CordRep::Ref(rep));
-    return rep;
-  }
-
- private:
-  using CordRep = absl::cord_internal::CordRep;
-
-  std::vector<CordRep*> unrefs_;
-};
-
-}  // namespace cordrep_testing
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cordrep_testing
+    {
+
+        inline cord_internal::CordRepSubstring* MakeSubstring(
+            size_t start, size_t len, cord_internal::CordRep* rep
+        )
+        {
+            auto* sub = new cord_internal::CordRepSubstring;
+            sub->tag = cord_internal::SUBSTRING;
+            sub->start = start;
+            sub->length = len <= 0 ? rep->length - start + len : len;
+            sub->child = rep;
+            return sub;
+        }
+
+        inline cord_internal::CordRepFlat* MakeFlat(absl::string_view value)
+        {
+            assert(value.length() <= cord_internal::kMaxFlatLength);
+            auto* flat = cord_internal::CordRepFlat::New(value.length());
+            flat->length = value.length();
+            memcpy(flat->Data(), value.data(), value.length());
+            return flat;
+        }
+
+        // Creates an external node for testing
+        inline cord_internal::CordRepExternal* MakeExternal(absl::string_view s)
+        {
+            struct Rep : public cord_internal::CordRepExternal
+            {
+                std::string s;
+                explicit Rep(absl::string_view sv) :
+                    s(sv)
+                {
+                    this->tag = cord_internal::EXTERNAL;
+                    this->base = s.data();
+                    this->length = s.length();
+                    this->releaser_invoker = [](cord_internal::CordRepExternal* self)
+                    {
+                        delete static_cast<Rep*>(self);
+                    };
+                }
+            };
+            return new Rep(s);
+        }
+
+        inline std::string CreateRandomString(size_t n)
+        {
+            absl::string_view data =
+                "abcdefghijklmnopqrstuvwxyz"
+                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                "0123456789~!@#$%^&*()_+=-<>?:\"{}[]|";
+            std::minstd_rand rnd;
+            std::uniform_int_distribution<size_t> dist(0, data.size() - 1);
+            std::string s(n, ' ');
+            for (size_t i = 0; i < n; ++i)
+            {
+                s[i] = data[dist(rnd)];
+            }
+            return s;
+        }
+
+        // Creates an array of flats from the provided string, chopping
+        // the provided string up into flats of size `chunk_size` characters
+        // resulting in roughly `data.size() / chunk_size` total flats.
+        inline std::vector<cord_internal::CordRep*> CreateFlatsFromString(
+            absl::string_view data, size_t chunk_size
+        )
+        {
+            assert(chunk_size > 0);
+            std::vector<cord_internal::CordRep*> flats;
+            for (absl::string_view s = data; !s.empty(); s.remove_prefix(chunk_size))
+            {
+                flats.push_back(MakeFlat(s.substr(0, chunk_size)));
+            }
+            return flats;
+        }
+
+        inline cord_internal::CordRepBtree* CordRepBtreeFromFlats(
+            absl::Span<cord_internal::CordRep* const> flats
+        )
+        {
+            assert(!flats.empty());
+            auto* node = cord_internal::CordRepBtree::Create(flats[0]);
+            for (size_t i = 1; i < flats.size(); ++i)
+            {
+                node = cord_internal::CordRepBtree::Append(node, flats[i]);
+            }
+            return node;
+        }
+
+        template<typename Fn>
+        inline void CordVisitReps(cord_internal::CordRep* rep, Fn&& fn)
+        {
+            fn(rep);
+            while (rep->tag == cord_internal::SUBSTRING)
+            {
+                rep = rep->substring()->child;
+                fn(rep);
+            }
+            if (rep->tag == cord_internal::BTREE)
+            {
+                for (cord_internal::CordRep* edge : rep->btree()->Edges())
+                {
+                    CordVisitReps(edge, fn);
+                }
+            }
+        }
+
+        template<typename Predicate>
+        inline std::vector<cord_internal::CordRep*> CordCollectRepsIf(
+            Predicate&& predicate, cord_internal::CordRep* rep
+        )
+        {
+            std::vector<cord_internal::CordRep*> reps;
+            CordVisitReps(rep, [&reps, &predicate](cord_internal::CordRep* rep)
+                          {
+    if (predicate(rep)) reps.push_back(rep); });
+            return reps;
+        }
+
+        inline std::vector<cord_internal::CordRep*> CordCollectReps(
+            cord_internal::CordRep* rep
+        )
+        {
+            std::vector<cord_internal::CordRep*> reps;
+            auto fn = [&reps](cord_internal::CordRep* rep)
+            { reps.push_back(rep); };
+            CordVisitReps(rep, fn);
+            return reps;
+        }
+
+        inline void CordToString(cord_internal::CordRep* rep, std::string& s)
+        {
+            size_t offset = 0;
+            size_t length = rep->length;
+            while (rep->tag == cord_internal::SUBSTRING)
+            {
+                offset += rep->substring()->start;
+                rep = rep->substring()->child;
+            }
+            if (rep->tag == cord_internal::BTREE)
+            {
+                for (cord_internal::CordRep* edge : rep->btree()->Edges())
+                {
+                    CordToString(edge, s);
+                }
+            }
+            else if (rep->tag >= cord_internal::FLAT)
+            {
+                s.append(rep->flat()->Data() + offset, length);
+            }
+            else if (rep->tag == cord_internal::EXTERNAL)
+            {
+                s.append(rep->external()->base + offset, length);
+            }
+            else
+            {
+                ABSL_RAW_LOG(FATAL, "Unsupported tag %d", rep->tag);
+            }
+        }
+
+        inline std::string CordToString(cord_internal::CordRep* rep)
+        {
+            std::string s;
+            s.reserve(rep->length);
+            CordToString(rep, s);
+            return s;
+        }
+
+        // RAII Helper class to automatically unref reps on destruction.
+        class AutoUnref
+        {
+        public:
+            ~AutoUnref()
+            {
+                for (CordRep* rep : unrefs_)
+                    CordRep::Unref(rep);
+            }
+
+            // Adds `rep` to the list of reps to be unreffed at destruction.
+            template<typename CordRepType>
+            CordRepType* Add(CordRepType* rep)
+            {
+                unrefs_.push_back(rep);
+                return rep;
+            }
+
+            // Increments the reference count of `rep` by one, and adds it to
+            // the list of reps to be unreffed at destruction.
+            template<typename CordRepType>
+            CordRepType* Ref(CordRepType* rep)
+            {
+                unrefs_.push_back(CordRep::Ref(rep));
+                return rep;
+            }
+
+            // Increments the reference count of `rep` by one if `condition` is true,
+            // and adds it to the list of reps to be unreffed at destruction.
+            template<typename CordRepType>
+            CordRepType* RefIf(bool condition, CordRepType* rep)
+            {
+                if (condition)
+                    unrefs_.push_back(CordRep::Ref(rep));
+                return rep;
+            }
+
+        private:
+            using CordRep = absl::cord_internal::CordRep;
+
+            std::vector<CordRep*> unrefs_;
+        };
+
+    }  // namespace cordrep_testing
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_functions.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_functions.h
index c9ba145..f2eff82 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_functions.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_functions.h
@@ -21,16 +21,18 @@
 #include "absl/base/config.h"
 #include "absl/base/optimization.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
 
-// Returns the current sample rate. This represents the average interval
-// between samples.
-int32_t get_cordz_mean_interval();
+        // Returns the current sample rate. This represents the average interval
+        // between samples.
+        int32_t get_cordz_mean_interval();
 
-// Sets the sample rate with the average interval between samples.
-void set_cordz_mean_interval(int32_t mean_interval);
+        // Sets the sample rate with the average interval between samples.
+        void set_cordz_mean_interval(int32_t mean_interval);
 
 // Enable cordz unless any of the following applies:
 // - no thread local support
@@ -41,7 +43,7 @@ void set_cordz_mean_interval(int32_t mean_interval);
 // Hashtablez is turned off completely in opensource builds.
 // MSVC's static atomics are dynamically initialized in debug mode, which breaks
 // sampling.
-#if defined(ABSL_HAVE_THREAD_LOCAL) && !defined(_MSC_VER)  && \
+#if defined(ABSL_HAVE_THREAD_LOCAL) && !defined(_MSC_VER) &&  \
     !defined(ABSL_BUILD_DLL) && !defined(ABSL_CONSUME_DLL) && \
     !defined(__ANDROID__) && !defined(__APPLE__)
 #define ABSL_INTERNAL_CORDZ_ENABLED 1
@@ -49,37 +51,44 @@ void set_cordz_mean_interval(int32_t mean_interval);
 
 #ifdef ABSL_INTERNAL_CORDZ_ENABLED
 
-// cordz_next_sample is the number of events until the next sample event. If
-// the value is 1 or less, the code will check on the next event if cordz is
-// enabled, and if so, will sample the Cord. cordz is only enabled when we can
-// use thread locals.
-ABSL_CONST_INIT extern thread_local int64_t cordz_next_sample;
-
-// Determines if the next sample should be profiled. If it is, the value pointed
-// at by next_sample will be set with the interval until the next sample.
-bool cordz_should_profile_slow();
-
-// Returns true if the next cord should be sampled.
-inline bool cordz_should_profile() {
-  if (ABSL_PREDICT_TRUE(cordz_next_sample > 1)) {
-    cordz_next_sample--;
-    return false;
-  }
-  return cordz_should_profile_slow();
-}
-
-// Sets the interval until the next sample (for testing only)
-void cordz_set_next_sample_for_testing(int64_t next_sample);
+        // cordz_next_sample is the number of events until the next sample event. If
+        // the value is 1 or less, the code will check on the next event if cordz is
+        // enabled, and if so, will sample the Cord. cordz is only enabled when we can
+        // use thread locals.
+        ABSL_CONST_INIT extern thread_local int64_t cordz_next_sample;
+
+        // Determines if the next sample should be profiled. If it is, the value pointed
+        // at by next_sample will be set with the interval until the next sample.
+        bool cordz_should_profile_slow();
+
+        // Returns true if the next cord should be sampled.
+        inline bool cordz_should_profile()
+        {
+            if (ABSL_PREDICT_TRUE(cordz_next_sample > 1))
+            {
+                cordz_next_sample--;
+                return false;
+            }
+            return cordz_should_profile_slow();
+        }
+
+        // Sets the interval until the next sample (for testing only)
+        void cordz_set_next_sample_for_testing(int64_t next_sample);
 
 #else  // ABSL_INTERNAL_CORDZ_ENABLED
 
-inline bool cordz_should_profile() { return false; }
-inline void cordz_set_next_sample_for_testing(int64_t) {}
+        inline bool cordz_should_profile()
+        {
+            return false;
+        }
+        inline void cordz_set_next_sample_for_testing(int64_t)
+        {
+        }
 
 #endif  // ABSL_INTERNAL_CORDZ_ENABLED
 
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CORDZ_FUNCTIONS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_handle.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_handle.h
index 5df53c7..063ff78 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_handle.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_handle.h
@@ -23,109 +23,126 @@
 #include "absl/base/internal/spinlock.h"
 #include "absl/synchronization/mutex.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// This base class allows multiple types of object (CordzInfo and
-// CordzSampleToken) to exist simultaneously on the delete queue (pointed to by
-// global_dq_tail and traversed using dq_prev_ and dq_next_). The
-// delete queue guarantees that once a profiler creates a CordzSampleToken and
-// has gained visibility into a CordzInfo object, that CordzInfo object will not
-// be deleted prematurely. This allows the profiler to inspect all CordzInfo
-// objects that are alive without needing to hold a global lock.
-class CordzHandle {
- public:
-  CordzHandle() : CordzHandle(false) {}
-
-  bool is_snapshot() const { return is_snapshot_; }
-
-  // Returns true if this instance is safe to be deleted because it is either a
-  // snapshot, which is always safe to delete, or not included in the global
-  // delete queue and thus not included in any snapshot.
-  // Callers are responsible for making sure this instance can not be newly
-  // discovered by other threads. For example, CordzInfo instances first de-list
-  // themselves from the global CordzInfo list before determining if they are
-  // safe to be deleted directly.
-  // If SafeToDelete returns false, callers MUST use the Delete() method to
-  // safely queue CordzHandle instances for deletion.
-  bool SafeToDelete() const;
-
-  // Deletes the provided instance, or puts it on the delete queue to be deleted
-  // once there are no more sample tokens (snapshot) instances potentially
-  // referencing the instance. `handle` should not be null.
-  static void Delete(CordzHandle* handle);
-
-  // Returns the current entries in the delete queue in LIFO order.
-  static std::vector<const CordzHandle*> DiagnosticsGetDeleteQueue();
-
-  // Returns true if the provided handle is nullptr or guarded by this handle.
-  // Since the CordzSnapshot token is itself a CordzHandle, this method will
-  // allow tests to check if that token is keeping an arbitrary CordzHandle
-  // alive.
-  bool DiagnosticsHandleIsSafeToInspect(const CordzHandle* handle) const;
-
-  // Returns the current entries in the delete queue, in LIFO order, that are
-  // protected by this. CordzHandle objects are only placed on the delete queue
-  // after CordzHandle::Delete is called with them as an argument. Only
-  // CordzHandle objects that are not also CordzSnapshot objects will be
-  // included in the return vector. For each of the handles in the return
-  // vector, the earliest that their memory can be freed is when this
-  // CordzSnapshot object is deleted.
-  std::vector<const CordzHandle*> DiagnosticsGetSafeToInspectDeletedHandles();
-
- protected:
-  explicit CordzHandle(bool is_snapshot);
-  virtual ~CordzHandle();
-
- private:
-  // Global queue data. CordzHandle stores a pointer to the global queue
-  // instance to harden against ODR violations.
-  struct Queue {
-    constexpr explicit Queue(absl::ConstInitType)
-        : mutex(absl::kConstInit,
-                absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL) {}
-
-    absl::base_internal::SpinLock mutex;
-    std::atomic<CordzHandle*> dq_tail ABSL_GUARDED_BY(mutex){nullptr};
-
-    // Returns true if this delete queue is empty. This method does not acquire
-    // the lock, but does a 'load acquire' observation on the delete queue tail.
-    // It is used inside Delete() to check for the presence of a delete queue
-    // without holding the lock. The assumption is that the caller is in the
-    // state of 'being deleted', and can not be newly discovered by a concurrent
-    // 'being constructed' snapshot instance. Practically, this means that any
-    // such discovery (`find`, 'first' or 'next', etc) must have proper 'happens
-    // before / after' semantics and atomic fences.
-    bool IsEmpty() const ABSL_NO_THREAD_SAFETY_ANALYSIS {
-      return dq_tail.load(std::memory_order_acquire) == nullptr;
-    }
-  };
-
-  void ODRCheck() const {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // This base class allows multiple types of object (CordzInfo and
+        // CordzSampleToken) to exist simultaneously on the delete queue (pointed to by
+        // global_dq_tail and traversed using dq_prev_ and dq_next_). The
+        // delete queue guarantees that once a profiler creates a CordzSampleToken and
+        // has gained visibility into a CordzInfo object, that CordzInfo object will not
+        // be deleted prematurely. This allows the profiler to inspect all CordzInfo
+        // objects that are alive without needing to hold a global lock.
+        class CordzHandle
+        {
+        public:
+            CordzHandle() :
+                CordzHandle(false)
+            {
+            }
+
+            bool is_snapshot() const
+            {
+                return is_snapshot_;
+            }
+
+            // Returns true if this instance is safe to be deleted because it is either a
+            // snapshot, which is always safe to delete, or not included in the global
+            // delete queue and thus not included in any snapshot.
+            // Callers are responsible for making sure this instance can not be newly
+            // discovered by other threads. For example, CordzInfo instances first de-list
+            // themselves from the global CordzInfo list before determining if they are
+            // safe to be deleted directly.
+            // If SafeToDelete returns false, callers MUST use the Delete() method to
+            // safely queue CordzHandle instances for deletion.
+            bool SafeToDelete() const;
+
+            // Deletes the provided instance, or puts it on the delete queue to be deleted
+            // once there are no more sample tokens (snapshot) instances potentially
+            // referencing the instance. `handle` should not be null.
+            static void Delete(CordzHandle* handle);
+
+            // Returns the current entries in the delete queue in LIFO order.
+            static std::vector<const CordzHandle*> DiagnosticsGetDeleteQueue();
+
+            // Returns true if the provided handle is nullptr or guarded by this handle.
+            // Since the CordzSnapshot token is itself a CordzHandle, this method will
+            // allow tests to check if that token is keeping an arbitrary CordzHandle
+            // alive.
+            bool DiagnosticsHandleIsSafeToInspect(const CordzHandle* handle) const;
+
+            // Returns the current entries in the delete queue, in LIFO order, that are
+            // protected by this. CordzHandle objects are only placed on the delete queue
+            // after CordzHandle::Delete is called with them as an argument. Only
+            // CordzHandle objects that are not also CordzSnapshot objects will be
+            // included in the return vector. For each of the handles in the return
+            // vector, the earliest that their memory can be freed is when this
+            // CordzSnapshot object is deleted.
+            std::vector<const CordzHandle*> DiagnosticsGetSafeToInspectDeletedHandles();
+
+        protected:
+            explicit CordzHandle(bool is_snapshot);
+            virtual ~CordzHandle();
+
+        private:
+            // Global queue data. CordzHandle stores a pointer to the global queue
+            // instance to harden against ODR violations.
+            struct Queue
+            {
+                constexpr explicit Queue(absl::ConstInitType) :
+                    mutex(absl::kConstInit, absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL)
+                {
+                }
+
+                absl::base_internal::SpinLock mutex;
+                std::atomic<CordzHandle*> dq_tail ABSL_GUARDED_BY(mutex){nullptr};
+
+                // Returns true if this delete queue is empty. This method does not acquire
+                // the lock, but does a 'load acquire' observation on the delete queue tail.
+                // It is used inside Delete() to check for the presence of a delete queue
+                // without holding the lock. The assumption is that the caller is in the
+                // state of 'being deleted', and can not be newly discovered by a concurrent
+                // 'being constructed' snapshot instance. Practically, this means that any
+                // such discovery (`find`, 'first' or 'next', etc) must have proper 'happens
+                // before / after' semantics and atomic fences.
+                bool IsEmpty() const ABSL_NO_THREAD_SAFETY_ANALYSIS
+                {
+                    return dq_tail.load(std::memory_order_acquire) == nullptr;
+                }
+            };
+
+            void ODRCheck() const
+            {
 #ifndef NDEBUG
-    ABSL_RAW_CHECK(queue_ == &global_queue_, "ODR violation in Cord");
+                ABSL_RAW_CHECK(queue_ == &global_queue_, "ODR violation in Cord");
 #endif
-  }
-
-  ABSL_CONST_INIT static Queue global_queue_;
-  Queue* const queue_ = &global_queue_;
-  const bool is_snapshot_;
-
-  // dq_prev_ and dq_next_ require the global queue mutex to be held.
-  // Unfortunately we can't use thread annotations such that the thread safety
-  // analysis understands that queue_ and global_queue_ are one and the same.
-  CordzHandle* dq_prev_  = nullptr;
-  CordzHandle* dq_next_ = nullptr;
-};
-
-class CordzSnapshot : public CordzHandle {
- public:
-  CordzSnapshot() : CordzHandle(true) {}
-};
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+            }
+
+            ABSL_CONST_INIT static Queue global_queue_;
+            Queue* const queue_ = &global_queue_;
+            const bool is_snapshot_;
+
+            // dq_prev_ and dq_next_ require the global queue mutex to be held.
+            // Unfortunately we can't use thread annotations such that the thread safety
+            // analysis understands that queue_ and global_queue_ are one and the same.
+            CordzHandle* dq_prev_ = nullptr;
+            CordzHandle* dq_next_ = nullptr;
+        };
+
+        class CordzSnapshot : public CordzHandle
+        {
+        public:
+            CordzSnapshot() :
+                CordzHandle(true)
+            {
+            }
+        };
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CORDZ_HANDLE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_info.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_info.h
index 026d5b9..6589de3 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_info.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_info.h
@@ -31,268 +31,287 @@
 #include "absl/synchronization/mutex.h"
 #include "absl/types/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordzInfo tracks a profiled Cord. Each of these objects can be in two places.
-// If a Cord is alive, the CordzInfo will be in the global_cordz_infos map, and
-// can also be retrieved via the linked list starting with
-// global_cordz_infos_head and continued via the cordz_info_next() method. When
-// a Cord has reached the end of its lifespan, the CordzInfo object will be
-// migrated out of the global_cordz_infos list and the global_cordz_infos_map,
-// and will either be deleted or appended to the global_delete_queue. If it is
-// placed on the global_delete_queue, the CordzInfo object will be cleaned in
-// the destructor of a CordzSampleToken object.
-class ABSL_LOCKABLE CordzInfo : public CordzHandle {
- public:
-  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
-
-  // TrackCord creates a CordzInfo instance which tracks important metrics of
-  // a sampled cord, and stores the created CordzInfo instance into `cord'. All
-  // CordzInfo instances are placed in a global list which is used to discover
-  // and snapshot all actively tracked cords. Callers are responsible for
-  // calling UntrackCord() before the tracked Cord instance is deleted, or to
-  // stop tracking the sampled Cord. Callers are also responsible for guarding
-  // changes to the 'tree' value of a Cord (InlineData.tree) through the Lock()
-  // and Unlock() calls. Any change resulting in a new tree value for the cord
-  // requires a call to SetCordRep() before the old tree has been unreffed
-  // and/or deleted. `method` identifies the Cord public API method initiating
-  // the cord to be sampled.
-  // Requires `cord` to hold a tree, and `cord.cordz_info()` to be null.
-  static void TrackCord(InlineData& cord, MethodIdentifier method);
-
-  // Identical to TrackCord(), except that this function fills the
-  // `parent_stack` and `parent_method` properties of the returned CordzInfo
-  // instance from the provided `src` instance if `src` is sampled.
-  // This function should be used for sampling 'copy constructed' and 'copy
-  // assigned' cords. This function allows 'cord` to be already sampled, in
-  // which case the CordzInfo will be newly created from `src`.
-  static void TrackCord(InlineData& cord, const InlineData& src,
-                        MethodIdentifier method);
-
-  // Maybe sample the cord identified by 'cord' for method 'method'.
-  // Uses `cordz_should_profile` to randomly pick cords to be sampled, and if
-  // so, invokes `TrackCord` to start sampling `cord`.
-  static void MaybeTrackCord(InlineData& cord, MethodIdentifier method);
-
-  // Maybe sample the cord identified by 'cord' for method 'method'.
-  // `src` identifies a 'parent' cord which is assigned to `cord`, typically the
-  // input cord for a copy constructor, or an assign method such as `operator=`
-  // `cord` will be sampled if (and only if) `src` is sampled.
-  // If `cord` is currently being sampled and `src` is not being sampled, then
-  // this function will stop sampling the cord and reset the cord's cordz_info.
-  //
-  // Previously this function defined that `cord` will be sampled if either
-  // `src` is sampled, or if `cord` is randomly picked for sampling. However,
-  // this can cause issues, as there may be paths where some cord is assigned an
-  // indirect copy of it's own value. As such a 'string of copies' would then
-  // remain sampled (`src.is_profiled`), then assigning such a cord back to
-  // 'itself' creates a cycle where the cord will converge to 'always sampled`.
-  //
-  // For example:
-  //
-  //   Cord x;
-  //   for (...) {
-  //     // Copy ctor --> y.is_profiled := x.is_profiled | random(...)
-  //     Cord y = x;
-  //     ...
-  //     // Assign x = y --> x.is_profiled = y.is_profiled | random(...)
-  //     //              ==> x.is_profiled |= random(...)
-  //     //              ==> x converges to 'always profiled'
-  //     x = y;
-  //   }
-  static void MaybeTrackCord(InlineData& cord, const InlineData& src,
-                             MethodIdentifier method);
-
-  // Stops tracking changes for a sampled cord, and deletes the provided info.
-  // This function must be called before the sampled cord instance is deleted,
-  // and before the root cordrep of the sampled cord is unreffed.
-  // This function may extend the lifetime of the cordrep in cases where the
-  // CordInfo instance is being held by a concurrent collection thread.
-  void Untrack();
-
-  // Invokes UntrackCord() on `info` if `info` is not null.
-  static void MaybeUntrackCord(CordzInfo* info);
-
-  CordzInfo() = delete;
-  CordzInfo(const CordzInfo&) = delete;
-  CordzInfo& operator=(const CordzInfo&) = delete;
-
-  // Retrieves the oldest existing CordzInfo.
-  static CordzInfo* Head(const CordzSnapshot& snapshot)
-      ABSL_NO_THREAD_SAFETY_ANALYSIS;
-
-  // Retrieves the next oldest existing CordzInfo older than 'this' instance.
-  CordzInfo* Next(const CordzSnapshot& snapshot) const
-      ABSL_NO_THREAD_SAFETY_ANALYSIS;
-
-  // Locks this instance for the update identified by `method`.
-  // Increases the count for `method` in `update_tracker`.
-  void Lock(MethodIdentifier method) ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_);
-
-  // Unlocks this instance. If the contained `rep` has been set to null
-  // indicating the Cord has been cleared or is otherwise no longer sampled,
-  // then this method will delete this CordzInfo instance.
-  void Unlock() ABSL_UNLOCK_FUNCTION(mutex_);
-
-  // Asserts that this CordzInfo instance is locked.
-  void AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_);
-
-  // Updates the `rep` property of this instance. This methods is invoked by
-  // Cord logic each time the root node of a sampled Cord changes, and before
-  // the old root reference count is deleted. This guarantees that collection
-  // code can always safely take a reference on the tracked cord.
-  // Requires a lock to be held through the `Lock()` method.
-  // TODO(b/117940323): annotate with ABSL_EXCLUSIVE_LOCKS_REQUIRED once all
-  // Cord code is in a state where this can be proven true by the compiler.
-  void SetCordRep(CordRep* rep);
-
-  // Returns the current `rep` property of this instance with a reference
-  // added, or null if this instance represents a cord that has since been
-  // deleted or untracked.
-  CordRep* RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_);
-
-  // Returns the current value of `rep_` for testing purposes only.
-  CordRep* GetCordRepForTesting() const ABSL_NO_THREAD_SAFETY_ANALYSIS {
-    return rep_;
-  }
-
-  // Sets the current value of `rep_` for testing purposes only.
-  void SetCordRepForTesting(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-    rep_ = rep;
-  }
-
-  // Returns the stack trace for where the cord was first sampled. Cords are
-  // potentially sampled when they promote from an inlined cord to a tree or
-  // ring representation, which is not necessarily the location where the cord
-  // was first created. Some cords are created as inlined cords, and only as
-  // data is added do they become a non-inlined cord. However, typically the
-  // location represents reasonably well where the cord is 'created'.
-  absl::Span<void* const> GetStack() const;
-
-  // Returns the stack trace for a sampled cord's 'parent stack trace'. This
-  // value may be set if the cord is sampled (promoted) after being created
-  // from, or being assigned the value of an existing (sampled) cord.
-  absl::Span<void* const> GetParentStack() const;
-
-  // Retrieves the CordzStatistics associated with this Cord. The statistics
-  // are only updated when a Cord goes through a mutation, such as an Append
-  // or RemovePrefix.
-  CordzStatistics GetCordzStatistics() const;
-
- private:
-  using SpinLock = absl::base_internal::SpinLock;
-  using SpinLockHolder = ::absl::base_internal::SpinLockHolder;
-
-  // Global cordz info list. CordzInfo stores a pointer to the global list
-  // instance to harden against ODR violations.
-  struct List {
-    constexpr explicit List(absl::ConstInitType)
-        : mutex(absl::kConstInit,
-                absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL) {}
-
-    SpinLock mutex;
-    std::atomic<CordzInfo*> head ABSL_GUARDED_BY(mutex){nullptr};
-  };
-
-  static constexpr int kMaxStackDepth = 64;
-
-  explicit CordzInfo(CordRep* rep, const CordzInfo* src,
-                     MethodIdentifier method);
-  ~CordzInfo() override;
-
-  // Sets `rep_` without holding a lock.
-  void UnsafeSetCordRep(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS;
-
-  void Track();
-
-  // Returns the parent method from `src`, which is either `parent_method_` or
-  // `method_` depending on `parent_method_` being kUnknown.
-  // Returns kUnknown if `src` is null.
-  static MethodIdentifier GetParentMethod(const CordzInfo* src);
-
-  // Fills the provided stack from `src`, copying either `parent_stack_` or
-  // `stack_` depending on `parent_stack_` being empty, returning the size of
-  // the parent stack.
-  // Returns 0 if `src` is null.
-  static int FillParentStack(const CordzInfo* src, void** stack);
-
-  void ODRCheck() const {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // CordzInfo tracks a profiled Cord. Each of these objects can be in two places.
+        // If a Cord is alive, the CordzInfo will be in the global_cordz_infos map, and
+        // can also be retrieved via the linked list starting with
+        // global_cordz_infos_head and continued via the cordz_info_next() method. When
+        // a Cord has reached the end of its lifespan, the CordzInfo object will be
+        // migrated out of the global_cordz_infos list and the global_cordz_infos_map,
+        // and will either be deleted or appended to the global_delete_queue. If it is
+        // placed on the global_delete_queue, the CordzInfo object will be cleaned in
+        // the destructor of a CordzSampleToken object.
+        class ABSL_LOCKABLE CordzInfo : public CordzHandle
+        {
+        public:
+            using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
+
+            // TrackCord creates a CordzInfo instance which tracks important metrics of
+            // a sampled cord, and stores the created CordzInfo instance into `cord'. All
+            // CordzInfo instances are placed in a global list which is used to discover
+            // and snapshot all actively tracked cords. Callers are responsible for
+            // calling UntrackCord() before the tracked Cord instance is deleted, or to
+            // stop tracking the sampled Cord. Callers are also responsible for guarding
+            // changes to the 'tree' value of a Cord (InlineData.tree) through the Lock()
+            // and Unlock() calls. Any change resulting in a new tree value for the cord
+            // requires a call to SetCordRep() before the old tree has been unreffed
+            // and/or deleted. `method` identifies the Cord public API method initiating
+            // the cord to be sampled.
+            // Requires `cord` to hold a tree, and `cord.cordz_info()` to be null.
+            static void TrackCord(InlineData& cord, MethodIdentifier method);
+
+            // Identical to TrackCord(), except that this function fills the
+            // `parent_stack` and `parent_method` properties of the returned CordzInfo
+            // instance from the provided `src` instance if `src` is sampled.
+            // This function should be used for sampling 'copy constructed' and 'copy
+            // assigned' cords. This function allows 'cord` to be already sampled, in
+            // which case the CordzInfo will be newly created from `src`.
+            static void TrackCord(InlineData& cord, const InlineData& src, MethodIdentifier method);
+
+            // Maybe sample the cord identified by 'cord' for method 'method'.
+            // Uses `cordz_should_profile` to randomly pick cords to be sampled, and if
+            // so, invokes `TrackCord` to start sampling `cord`.
+            static void MaybeTrackCord(InlineData& cord, MethodIdentifier method);
+
+            // Maybe sample the cord identified by 'cord' for method 'method'.
+            // `src` identifies a 'parent' cord which is assigned to `cord`, typically the
+            // input cord for a copy constructor, or an assign method such as `operator=`
+            // `cord` will be sampled if (and only if) `src` is sampled.
+            // If `cord` is currently being sampled and `src` is not being sampled, then
+            // this function will stop sampling the cord and reset the cord's cordz_info.
+            //
+            // Previously this function defined that `cord` will be sampled if either
+            // `src` is sampled, or if `cord` is randomly picked for sampling. However,
+            // this can cause issues, as there may be paths where some cord is assigned an
+            // indirect copy of it's own value. As such a 'string of copies' would then
+            // remain sampled (`src.is_profiled`), then assigning such a cord back to
+            // 'itself' creates a cycle where the cord will converge to 'always sampled`.
+            //
+            // For example:
+            //
+            //   Cord x;
+            //   for (...) {
+            //     // Copy ctor --> y.is_profiled := x.is_profiled | random(...)
+            //     Cord y = x;
+            //     ...
+            //     // Assign x = y --> x.is_profiled = y.is_profiled | random(...)
+            //     //              ==> x.is_profiled |= random(...)
+            //     //              ==> x converges to 'always profiled'
+            //     x = y;
+            //   }
+            static void MaybeTrackCord(InlineData& cord, const InlineData& src, MethodIdentifier method);
+
+            // Stops tracking changes for a sampled cord, and deletes the provided info.
+            // This function must be called before the sampled cord instance is deleted,
+            // and before the root cordrep of the sampled cord is unreffed.
+            // This function may extend the lifetime of the cordrep in cases where the
+            // CordInfo instance is being held by a concurrent collection thread.
+            void Untrack();
+
+            // Invokes UntrackCord() on `info` if `info` is not null.
+            static void MaybeUntrackCord(CordzInfo* info);
+
+            CordzInfo() = delete;
+            CordzInfo(const CordzInfo&) = delete;
+            CordzInfo& operator=(const CordzInfo&) = delete;
+
+            // Retrieves the oldest existing CordzInfo.
+            static CordzInfo* Head(const CordzSnapshot& snapshot)
+                ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+            // Retrieves the next oldest existing CordzInfo older than 'this' instance.
+            CordzInfo* Next(const CordzSnapshot& snapshot) const
+                ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+            // Locks this instance for the update identified by `method`.
+            // Increases the count for `method` in `update_tracker`.
+            void Lock(MethodIdentifier method) ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_);
+
+            // Unlocks this instance. If the contained `rep` has been set to null
+            // indicating the Cord has been cleared or is otherwise no longer sampled,
+            // then this method will delete this CordzInfo instance.
+            void Unlock() ABSL_UNLOCK_FUNCTION(mutex_);
+
+            // Asserts that this CordzInfo instance is locked.
+            void AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_);
+
+            // Updates the `rep` property of this instance. This methods is invoked by
+            // Cord logic each time the root node of a sampled Cord changes, and before
+            // the old root reference count is deleted. This guarantees that collection
+            // code can always safely take a reference on the tracked cord.
+            // Requires a lock to be held through the `Lock()` method.
+            // TODO(b/117940323): annotate with ABSL_EXCLUSIVE_LOCKS_REQUIRED once all
+            // Cord code is in a state where this can be proven true by the compiler.
+            void SetCordRep(CordRep* rep);
+
+            // Returns the current `rep` property of this instance with a reference
+            // added, or null if this instance represents a cord that has since been
+            // deleted or untracked.
+            CordRep* RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_);
+
+            // Returns the current value of `rep_` for testing purposes only.
+            CordRep* GetCordRepForTesting() const ABSL_NO_THREAD_SAFETY_ANALYSIS
+            {
+                return rep_;
+            }
+
+            // Sets the current value of `rep_` for testing purposes only.
+            void SetCordRepForTesting(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS
+            {
+                rep_ = rep;
+            }
+
+            // Returns the stack trace for where the cord was first sampled. Cords are
+            // potentially sampled when they promote from an inlined cord to a tree or
+            // ring representation, which is not necessarily the location where the cord
+            // was first created. Some cords are created as inlined cords, and only as
+            // data is added do they become a non-inlined cord. However, typically the
+            // location represents reasonably well where the cord is 'created'.
+            absl::Span<void* const> GetStack() const;
+
+            // Returns the stack trace for a sampled cord's 'parent stack trace'. This
+            // value may be set if the cord is sampled (promoted) after being created
+            // from, or being assigned the value of an existing (sampled) cord.
+            absl::Span<void* const> GetParentStack() const;
+
+            // Retrieves the CordzStatistics associated with this Cord. The statistics
+            // are only updated when a Cord goes through a mutation, such as an Append
+            // or RemovePrefix.
+            CordzStatistics GetCordzStatistics() const;
+
+        private:
+            using SpinLock = absl::base_internal::SpinLock;
+            using SpinLockHolder = ::absl::base_internal::SpinLockHolder;
+
+            // Global cordz info list. CordzInfo stores a pointer to the global list
+            // instance to harden against ODR violations.
+            struct List
+            {
+                constexpr explicit List(absl::ConstInitType) :
+                    mutex(absl::kConstInit, absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL)
+                {
+                }
+
+                SpinLock mutex;
+                std::atomic<CordzInfo*> head ABSL_GUARDED_BY(mutex){nullptr};
+            };
+
+            static constexpr int kMaxStackDepth = 64;
+
+            explicit CordzInfo(CordRep* rep, const CordzInfo* src, MethodIdentifier method);
+            ~CordzInfo() override;
+
+            // Sets `rep_` without holding a lock.
+            void UnsafeSetCordRep(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+            void Track();
+
+            // Returns the parent method from `src`, which is either `parent_method_` or
+            // `method_` depending on `parent_method_` being kUnknown.
+            // Returns kUnknown if `src` is null.
+            static MethodIdentifier GetParentMethod(const CordzInfo* src);
+
+            // Fills the provided stack from `src`, copying either `parent_stack_` or
+            // `stack_` depending on `parent_stack_` being empty, returning the size of
+            // the parent stack.
+            // Returns 0 if `src` is null.
+            static int FillParentStack(const CordzInfo* src, void** stack);
+
+            void ODRCheck() const
+            {
 #ifndef NDEBUG
-    ABSL_RAW_CHECK(list_ == &global_list_, "ODR violation in Cord");
+                ABSL_RAW_CHECK(list_ == &global_list_, "ODR violation in Cord");
 #endif
-  }
-
-  // Non-inlined implementation of `MaybeTrackCord`, which is executed if
-  // either `src` is sampled or `cord` is sampled, and either untracks or
-  // tracks `cord` as documented per `MaybeTrackCord`.
-  static void MaybeTrackCordImpl(InlineData& cord, const InlineData& src,
-                                 MethodIdentifier method);
-
-  ABSL_CONST_INIT static List global_list_;
-  List* const list_ = &global_list_;
-
-  // ci_prev_ and ci_next_ require the global list mutex to be held.
-  // Unfortunately we can't use thread annotations such that the thread safety
-  // analysis understands that list_ and global_list_ are one and the same.
-  std::atomic<CordzInfo*> ci_prev_{nullptr};
-  std::atomic<CordzInfo*> ci_next_{nullptr};
-
-  mutable absl::Mutex mutex_;
-  CordRep* rep_ ABSL_GUARDED_BY(mutex_);
-
-  void* stack_[kMaxStackDepth];
-  void* parent_stack_[kMaxStackDepth];
-  const int stack_depth_;
-  const int parent_stack_depth_;
-  const MethodIdentifier method_;
-  const MethodIdentifier parent_method_;
-  CordzUpdateTracker update_tracker_;
-  const absl::Time create_time_;
-};
-
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
-    InlineData& cord, MethodIdentifier method) {
-  if (ABSL_PREDICT_FALSE(cordz_should_profile())) {
-    TrackCord(cord, method);
-  }
-}
-
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
-    InlineData& cord, const InlineData& src, MethodIdentifier method) {
-  if (ABSL_PREDICT_FALSE(InlineData::is_either_profiled(cord, src))) {
-    MaybeTrackCordImpl(cord, src, method);
-  }
-}
-
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeUntrackCord(
-    CordzInfo* info) {
-  if (ABSL_PREDICT_FALSE(info)) {
-    info->Untrack();
-  }
-}
-
-inline void CordzInfo::AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_) {
+            }
+
+            // Non-inlined implementation of `MaybeTrackCord`, which is executed if
+            // either `src` is sampled or `cord` is sampled, and either untracks or
+            // tracks `cord` as documented per `MaybeTrackCord`.
+            static void MaybeTrackCordImpl(InlineData& cord, const InlineData& src, MethodIdentifier method);
+
+            ABSL_CONST_INIT static List global_list_;
+            List* const list_ = &global_list_;
+
+            // ci_prev_ and ci_next_ require the global list mutex to be held.
+            // Unfortunately we can't use thread annotations such that the thread safety
+            // analysis understands that list_ and global_list_ are one and the same.
+            std::atomic<CordzInfo*> ci_prev_{nullptr};
+            std::atomic<CordzInfo*> ci_next_{nullptr};
+
+            mutable absl::Mutex mutex_;
+            CordRep* rep_ ABSL_GUARDED_BY(mutex_);
+
+            void* stack_[kMaxStackDepth];
+            void* parent_stack_[kMaxStackDepth];
+            const int stack_depth_;
+            const int parent_stack_depth_;
+            const MethodIdentifier method_;
+            const MethodIdentifier parent_method_;
+            CordzUpdateTracker update_tracker_;
+            const absl::Time create_time_;
+        };
+
+        inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
+            InlineData& cord, MethodIdentifier method
+        )
+        {
+            if (ABSL_PREDICT_FALSE(cordz_should_profile()))
+            {
+                TrackCord(cord, method);
+            }
+        }
+
+        inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
+            InlineData& cord, const InlineData& src, MethodIdentifier method
+        )
+        {
+            if (ABSL_PREDICT_FALSE(InlineData::is_either_profiled(cord, src)))
+            {
+                MaybeTrackCordImpl(cord, src, method);
+            }
+        }
+
+        inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeUntrackCord(
+            CordzInfo* info
+        )
+        {
+            if (ABSL_PREDICT_FALSE(info))
+            {
+                info->Untrack();
+            }
+        }
+
+        inline void CordzInfo::AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_)
+        {
 #ifndef NDEBUG
-  mutex_.AssertHeld();
+            mutex_.AssertHeld();
 #endif
-}
-
-inline void CordzInfo::SetCordRep(CordRep* rep) {
-  AssertHeld();
-  rep_ = rep;
-}
-
-inline void CordzInfo::UnsafeSetCordRep(CordRep* rep) { rep_ = rep; }
-
-inline CordRep* CordzInfo::RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_) {
-  MutexLock lock(&mutex_);
-  return rep_ ? CordRep::Ref(rep_) : nullptr;
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+        }
+
+        inline void CordzInfo::SetCordRep(CordRep* rep)
+        {
+            AssertHeld();
+            rep_ = rep;
+        }
+
+        inline void CordzInfo::UnsafeSetCordRep(CordRep* rep)
+        {
+            rep_ = rep;
+        }
+
+        inline CordRep* CordzInfo::RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_)
+        {
+            MutexLock lock(&mutex_);
+            return rep_ ? CordRep::Ref(rep_) : nullptr;
+        }
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CORDZ_INFO_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_sample_token.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_sample_token.h
index 28a1d70..3d8865a 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_sample_token.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_sample_token.h
@@ -19,79 +19,89 @@
 #ifndef ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
 #define ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
 
-// The existence of a CordzSampleToken guarantees that a reader can traverse the
-// global_cordz_infos_head linked-list without needing to hold a mutex. When a
-// CordzSampleToken exists, all CordzInfo objects that would be destroyed are
-// instead appended to a deletion queue. When the CordzSampleToken is destroyed,
-// it will also clean up any of these CordzInfo objects.
-//
-// E.g., ST are CordzSampleToken objects and CH are CordzHandle objects.
-//   ST1 <- CH1 <- CH2 <- ST2 <- CH3 <- global_delete_queue_tail
-//
-// This list tracks that CH1 and CH2 were created after ST1, so the thread
-// holding ST1 might have a referece to CH1, CH2, ST2, and CH3. However, ST2 was
-// created later, so the thread holding the ST2 token cannot have a reference to
-// ST1, CH1, or CH2. If ST1 is cleaned up first, that thread will delete ST1,
-// CH1, and CH2. If instead ST2 is cleaned up first, that thread will only
-// delete ST2.
-//
-// If ST1 is cleaned up first, the new list will be:
-//   ST2 <- CH3 <- global_delete_queue_tail
-//
-// If ST2 is cleaned up first, the new list will be:
-//   ST1 <- CH1 <- CH2 <- CH3 <- global_delete_queue_tail
-//
-// All new CordzHandle objects are appended to the list, so if a new thread
-// comes along before either ST1 or ST2 are cleaned up, the new list will be:
-//   ST1 <- CH1 <- CH2 <- ST2 <- CH3 <- ST3 <- global_delete_queue_tail
-//
-// A thread must hold the global_delete_queue_mu mutex whenever it's altering
-// this list.
-//
-// It is safe for thread that holds a CordzSampleToken to read
-// global_cordz_infos at any time since the objects it is able to retrieve will
-// not be deleted while the CordzSampleToken exists.
-class CordzSampleToken : public CordzSnapshot {
- public:
-  class Iterator {
-   public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = const CordzInfo&;
-    using difference_type = ptrdiff_t;
-    using pointer = const CordzInfo*;
-    using reference = value_type;
+        // The existence of a CordzSampleToken guarantees that a reader can traverse the
+        // global_cordz_infos_head linked-list without needing to hold a mutex. When a
+        // CordzSampleToken exists, all CordzInfo objects that would be destroyed are
+        // instead appended to a deletion queue. When the CordzSampleToken is destroyed,
+        // it will also clean up any of these CordzInfo objects.
+        //
+        // E.g., ST are CordzSampleToken objects and CH are CordzHandle objects.
+        //   ST1 <- CH1 <- CH2 <- ST2 <- CH3 <- global_delete_queue_tail
+        //
+        // This list tracks that CH1 and CH2 were created after ST1, so the thread
+        // holding ST1 might have a referece to CH1, CH2, ST2, and CH3. However, ST2 was
+        // created later, so the thread holding the ST2 token cannot have a reference to
+        // ST1, CH1, or CH2. If ST1 is cleaned up first, that thread will delete ST1,
+        // CH1, and CH2. If instead ST2 is cleaned up first, that thread will only
+        // delete ST2.
+        //
+        // If ST1 is cleaned up first, the new list will be:
+        //   ST2 <- CH3 <- global_delete_queue_tail
+        //
+        // If ST2 is cleaned up first, the new list will be:
+        //   ST1 <- CH1 <- CH2 <- CH3 <- global_delete_queue_tail
+        //
+        // All new CordzHandle objects are appended to the list, so if a new thread
+        // comes along before either ST1 or ST2 are cleaned up, the new list will be:
+        //   ST1 <- CH1 <- CH2 <- ST2 <- CH3 <- ST3 <- global_delete_queue_tail
+        //
+        // A thread must hold the global_delete_queue_mu mutex whenever it's altering
+        // this list.
+        //
+        // It is safe for thread that holds a CordzSampleToken to read
+        // global_cordz_infos at any time since the objects it is able to retrieve will
+        // not be deleted while the CordzSampleToken exists.
+        class CordzSampleToken : public CordzSnapshot
+        {
+        public:
+            class Iterator
+            {
+            public:
+                using iterator_category = std::input_iterator_tag;
+                using value_type = const CordzInfo&;
+                using difference_type = ptrdiff_t;
+                using pointer = const CordzInfo*;
+                using reference = value_type;
 
-    Iterator() = default;
+                Iterator() = default;
 
-    Iterator& operator++();
-    Iterator operator++(int);
-    friend bool operator==(const Iterator& lhs, const Iterator& rhs);
-    friend bool operator!=(const Iterator& lhs, const Iterator& rhs);
-    reference operator*() const;
-    pointer operator->() const;
+                Iterator& operator++();
+                Iterator operator++(int);
+                friend bool operator==(const Iterator& lhs, const Iterator& rhs);
+                friend bool operator!=(const Iterator& lhs, const Iterator& rhs);
+                reference operator*() const;
+                pointer operator->() const;
 
-   private:
-    friend class CordzSampleToken;
-    explicit Iterator(const CordzSampleToken* token);
+            private:
+                friend class CordzSampleToken;
+                explicit Iterator(const CordzSampleToken* token);
 
-    const CordzSampleToken* token_ = nullptr;
-    pointer current_ = nullptr;
-  };
+                const CordzSampleToken* token_ = nullptr;
+                pointer current_ = nullptr;
+            };
 
-  CordzSampleToken() = default;
-  CordzSampleToken(const CordzSampleToken&) = delete;
-  CordzSampleToken& operator=(const CordzSampleToken&) = delete;
+            CordzSampleToken() = default;
+            CordzSampleToken(const CordzSampleToken&) = delete;
+            CordzSampleToken& operator=(const CordzSampleToken&) = delete;
 
-  Iterator begin() { return Iterator(this); }
-  Iterator end() { return Iterator(); }
-};
+            Iterator begin()
+            {
+                return Iterator(this);
+            }
+            Iterator end()
+            {
+                return Iterator();
+            }
+        };
 
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_statistics.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_statistics.h
index 5707190..d0ad0da 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_statistics.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_statistics.h
@@ -20,69 +20,73 @@
 #include "absl/base/config.h"
 #include "absl/strings/internal/cordz_update_tracker.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordzStatistics captures some meta information about a Cord's shape.
-struct CordzStatistics {
-  using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
-
-  // Node counts information
-  struct NodeCounts {
-    size_t flat = 0;       // #flats
-    size_t flat_64 = 0;    // #flats up to 64 bytes
-    size_t flat_128 = 0;   // #flats up to 128 bytes
-    size_t flat_256 = 0;   // #flats up to 256 bytes
-    size_t flat_512 = 0;   // #flats up to 512 bytes
-    size_t flat_1k = 0;    // #flats up to 1K bytes
-    size_t external = 0;   // #external reps
-    size_t substring = 0;  // #substring reps
-    size_t concat = 0;     // #concat reps
-    size_t ring = 0;       // #ring buffer reps
-    size_t btree = 0;      // #btree reps
-    size_t crc = 0;        // #crc reps
-  };
-
-  // The size of the cord in bytes. This matches the result of Cord::size().
-  int64_t size = 0;
-
-  // The estimated memory used by the sampled cord. This value matches the
-  // value as reported by Cord::EstimatedMemoryUsage().
-  // A value of 0 implies the property has not been recorded.
-  int64_t estimated_memory_usage = 0;
-
-  // The effective memory used by the sampled cord, inversely weighted by the
-  // effective indegree of each allocated node. This is a representation of the
-  // fair share of memory usage that should be attributed to the sampled cord.
-  // This value is more useful for cases where one or more nodes are referenced
-  // by multiple Cord instances, and for cases where a Cord includes the same
-  // node multiple times (either directly or indirectly).
-  // A value of 0 implies the property has not been recorded.
-  int64_t estimated_fair_share_memory_usage = 0;
-
-  // The total number of nodes referenced by this cord.
-  // For ring buffer Cords, this includes the 'ring buffer' node.
-  // For btree Cords, this includes all 'CordRepBtree' tree nodes as well as all
-  // the substring, flat and external nodes referenced by the tree.
-  // A value of 0 implies the property has not been recorded.
-  int64_t node_count = 0;
-
-  // Detailed node counts per type
-  NodeCounts node_counts;
-
-  // The cord method responsible for sampling the cord.
-  MethodIdentifier method = MethodIdentifier::kUnknown;
-
-  // The cord method responsible for sampling the parent cord if applicable.
-  MethodIdentifier parent_method = MethodIdentifier::kUnknown;
-
-  // Update tracker tracking invocation count per cord method.
-  CordzUpdateTracker update_tracker;
-};
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // CordzStatistics captures some meta information about a Cord's shape.
+        struct CordzStatistics
+        {
+            using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
+
+            // Node counts information
+            struct NodeCounts
+            {
+                size_t flat = 0;       // #flats
+                size_t flat_64 = 0;    // #flats up to 64 bytes
+                size_t flat_128 = 0;   // #flats up to 128 bytes
+                size_t flat_256 = 0;   // #flats up to 256 bytes
+                size_t flat_512 = 0;   // #flats up to 512 bytes
+                size_t flat_1k = 0;    // #flats up to 1K bytes
+                size_t external = 0;   // #external reps
+                size_t substring = 0;  // #substring reps
+                size_t concat = 0;     // #concat reps
+                size_t ring = 0;       // #ring buffer reps
+                size_t btree = 0;      // #btree reps
+                size_t crc = 0;        // #crc reps
+            };
+
+            // The size of the cord in bytes. This matches the result of Cord::size().
+            int64_t size = 0;
+
+            // The estimated memory used by the sampled cord. This value matches the
+            // value as reported by Cord::EstimatedMemoryUsage().
+            // A value of 0 implies the property has not been recorded.
+            int64_t estimated_memory_usage = 0;
+
+            // The effective memory used by the sampled cord, inversely weighted by the
+            // effective indegree of each allocated node. This is a representation of the
+            // fair share of memory usage that should be attributed to the sampled cord.
+            // This value is more useful for cases where one or more nodes are referenced
+            // by multiple Cord instances, and for cases where a Cord includes the same
+            // node multiple times (either directly or indirectly).
+            // A value of 0 implies the property has not been recorded.
+            int64_t estimated_fair_share_memory_usage = 0;
+
+            // The total number of nodes referenced by this cord.
+            // For ring buffer Cords, this includes the 'ring buffer' node.
+            // For btree Cords, this includes all 'CordRepBtree' tree nodes as well as all
+            // the substring, flat and external nodes referenced by the tree.
+            // A value of 0 implies the property has not been recorded.
+            int64_t node_count = 0;
+
+            // Detailed node counts per type
+            NodeCounts node_counts;
+
+            // The cord method responsible for sampling the cord.
+            MethodIdentifier method = MethodIdentifier::kUnknown;
+
+            // The cord method responsible for sampling the parent cord if applicable.
+            MethodIdentifier parent_method = MethodIdentifier::kUnknown;
+
+            // Update tracker tracking invocation count per cord method.
+            CordzUpdateTracker update_tracker;
+        };
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_scope.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_scope.h
index 57ba75d..3fa306a 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_scope.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_scope.h
@@ -22,50 +22,62 @@
 #include "absl/strings/internal/cordz_info.h"
 #include "absl/strings/internal/cordz_update_tracker.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
 
-// CordzUpdateScope scopes an update to the provided CordzInfo.
-// The class invokes `info->Lock(method)` and `info->Unlock()` to guard
-// cordrep updates. This class does nothing if `info` is null.
-// See also the 'Lock`, `Unlock` and `SetCordRep` methods in `CordzInfo`.
-class ABSL_SCOPED_LOCKABLE CordzUpdateScope {
- public:
-  CordzUpdateScope(CordzInfo* info, CordzUpdateTracker::MethodIdentifier method)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(info)
-      : info_(info) {
-    if (ABSL_PREDICT_FALSE(info_)) {
-      info->Lock(method);
-    }
-  }
+        // CordzUpdateScope scopes an update to the provided CordzInfo.
+        // The class invokes `info->Lock(method)` and `info->Unlock()` to guard
+        // cordrep updates. This class does nothing if `info` is null.
+        // See also the 'Lock`, `Unlock` and `SetCordRep` methods in `CordzInfo`.
+        class ABSL_SCOPED_LOCKABLE CordzUpdateScope
+        {
+        public:
+            CordzUpdateScope(CordzInfo* info, CordzUpdateTracker::MethodIdentifier method)
+                ABSL_EXCLUSIVE_LOCK_FUNCTION(info) :
+                info_(info)
+            {
+                if (ABSL_PREDICT_FALSE(info_))
+                {
+                    info->Lock(method);
+                }
+            }
 
-  // CordzUpdateScope can not be copied or assigned to.
-  CordzUpdateScope(CordzUpdateScope&& rhs) = delete;
-  CordzUpdateScope(const CordzUpdateScope&) = delete;
-  CordzUpdateScope& operator=(CordzUpdateScope&& rhs) = delete;
-  CordzUpdateScope& operator=(const CordzUpdateScope&) = delete;
+            // CordzUpdateScope can not be copied or assigned to.
+            CordzUpdateScope(CordzUpdateScope&& rhs) = delete;
+            CordzUpdateScope(const CordzUpdateScope&) = delete;
+            CordzUpdateScope& operator=(CordzUpdateScope&& rhs) = delete;
+            CordzUpdateScope& operator=(const CordzUpdateScope&) = delete;
 
-  ~CordzUpdateScope() ABSL_UNLOCK_FUNCTION() {
-    if (ABSL_PREDICT_FALSE(info_)) {
-      info_->Unlock();
-    }
-  }
+            ~CordzUpdateScope() ABSL_UNLOCK_FUNCTION()
+            {
+                if (ABSL_PREDICT_FALSE(info_))
+                {
+                    info_->Unlock();
+                }
+            }
 
-  void SetCordRep(CordRep* rep) const {
-    if (ABSL_PREDICT_FALSE(info_)) {
-      info_->SetCordRep(rep);
-    }
-  }
+            void SetCordRep(CordRep* rep) const
+            {
+                if (ABSL_PREDICT_FALSE(info_))
+                {
+                    info_->SetCordRep(rep);
+                }
+            }
 
-  CordzInfo* info() const { return info_; }
+            CordzInfo* info() const
+            {
+                return info_;
+            }
 
- private:
-  CordzInfo* info_;
-};
+        private:
+            CordzInfo* info_;
+        };
 
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_tracker.h b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_tracker.h
index c517066..453220e 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_tracker.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/cordz_update_tracker.h
@@ -20,104 +20,123 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordzUpdateTracker tracks counters for Cord update methods.
-//
-// The purpose of CordzUpdateTracker is to track the number of calls to methods
-// updating Cord data for sampled cords. The class internally uses 'lossy'
-// atomic operations: Cord is thread-compatible, so there is no need to
-// synchronize updates. However, Cordz collection threads may call 'Value()' at
-// any point, so the class needs to provide thread safe access.
-//
-// This class is thread-safe. But as per above comments, all non-const methods
-// should be used single-threaded only: updates are thread-safe but lossy.
-class CordzUpdateTracker {
- public:
-  // Tracked update methods.
-  enum MethodIdentifier {
-    kUnknown,
-    kAppendCord,
-    kAppendCordBuffer,
-    kAppendExternalMemory,
-    kAppendString,
-    kAssignCord,
-    kAssignString,
-    kClear,
-    kConstructorCord,
-    kConstructorString,
-    kCordReader,
-    kFlatten,
-    kGetAppendBuffer,
-    kGetAppendRegion,
-    kMakeCordFromExternal,
-    kMoveAppendCord,
-    kMoveAssignCord,
-    kMovePrependCord,
-    kPrependCord,
-    kPrependCordBuffer,
-    kPrependString,
-    kRemovePrefix,
-    kRemoveSuffix,
-    kSetExpectedChecksum,
-    kSubCord,
-
-    // kNumMethods defines the number of entries: must be the last entry.
-    kNumMethods,
-  };
-
-  // Constructs a new instance. All counters are zero-initialized.
-  constexpr CordzUpdateTracker() noexcept : values_{} {}
-
-  // Copy constructs a new instance.
-  CordzUpdateTracker(const CordzUpdateTracker& rhs) noexcept { *this = rhs; }
-
-  // Assigns the provided value to this instance.
-  CordzUpdateTracker& operator=(const CordzUpdateTracker& rhs) noexcept {
-    for (int i = 0; i < kNumMethods; ++i) {
-      values_[i].store(rhs.values_[i].load(std::memory_order_relaxed),
-                       std::memory_order_relaxed);
-    }
-    return *this;
-  }
-
-  // Returns the value for the specified method.
-  int64_t Value(MethodIdentifier method) const {
-    return values_[method].load(std::memory_order_relaxed);
-  }
-
-  // Increases the value for the specified method by `n`
-  void LossyAdd(MethodIdentifier method, int64_t n = 1) {
-    auto& value = values_[method];
-    value.store(value.load(std::memory_order_relaxed) + n,
-                std::memory_order_relaxed);
-  }
-
-  // Adds all the values from `src` to this instance
-  void LossyAdd(const CordzUpdateTracker& src) {
-    for (int i = 0; i < kNumMethods; ++i) {
-      MethodIdentifier method = static_cast<MethodIdentifier>(i);
-      if (int64_t value = src.Value(method)) {
-        LossyAdd(method, value);
-      }
-    }
-  }
-
- private:
-  // Until C++20 std::atomic is not constexpr default-constructible, so we need
-  // a wrapper for this class to be constexpr constructible.
-  class Counter : public std::atomic<int64_t> {
-   public:
-    constexpr Counter() noexcept : std::atomic<int64_t>(0) {}
-  };
-
-  Counter values_[kNumMethods];
-};
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace cord_internal
+    {
+
+        // CordzUpdateTracker tracks counters for Cord update methods.
+        //
+        // The purpose of CordzUpdateTracker is to track the number of calls to methods
+        // updating Cord data for sampled cords. The class internally uses 'lossy'
+        // atomic operations: Cord is thread-compatible, so there is no need to
+        // synchronize updates. However, Cordz collection threads may call 'Value()' at
+        // any point, so the class needs to provide thread safe access.
+        //
+        // This class is thread-safe. But as per above comments, all non-const methods
+        // should be used single-threaded only: updates are thread-safe but lossy.
+        class CordzUpdateTracker
+        {
+        public:
+            // Tracked update methods.
+            enum MethodIdentifier
+            {
+                kUnknown,
+                kAppendCord,
+                kAppendCordBuffer,
+                kAppendExternalMemory,
+                kAppendString,
+                kAssignCord,
+                kAssignString,
+                kClear,
+                kConstructorCord,
+                kConstructorString,
+                kCordReader,
+                kFlatten,
+                kGetAppendBuffer,
+                kGetAppendRegion,
+                kMakeCordFromExternal,
+                kMoveAppendCord,
+                kMoveAssignCord,
+                kMovePrependCord,
+                kPrependCord,
+                kPrependCordBuffer,
+                kPrependString,
+                kRemovePrefix,
+                kRemoveSuffix,
+                kSetExpectedChecksum,
+                kSubCord,
+
+                // kNumMethods defines the number of entries: must be the last entry.
+                kNumMethods,
+            };
+
+            // Constructs a new instance. All counters are zero-initialized.
+            constexpr CordzUpdateTracker() noexcept :
+                values_{}
+            {
+            }
+
+            // Copy constructs a new instance.
+            CordzUpdateTracker(const CordzUpdateTracker& rhs) noexcept
+            {
+                *this = rhs;
+            }
+
+            // Assigns the provided value to this instance.
+            CordzUpdateTracker& operator=(const CordzUpdateTracker& rhs) noexcept
+            {
+                for (int i = 0; i < kNumMethods; ++i)
+                {
+                    values_[i].store(rhs.values_[i].load(std::memory_order_relaxed), std::memory_order_relaxed);
+                }
+                return *this;
+            }
+
+            // Returns the value for the specified method.
+            int64_t Value(MethodIdentifier method) const
+            {
+                return values_[method].load(std::memory_order_relaxed);
+            }
+
+            // Increases the value for the specified method by `n`
+            void LossyAdd(MethodIdentifier method, int64_t n = 1)
+            {
+                auto& value = values_[method];
+                value.store(value.load(std::memory_order_relaxed) + n, std::memory_order_relaxed);
+            }
+
+            // Adds all the values from `src` to this instance
+            void LossyAdd(const CordzUpdateTracker& src)
+            {
+                for (int i = 0; i < kNumMethods; ++i)
+                {
+                    MethodIdentifier method = static_cast<MethodIdentifier>(i);
+                    if (int64_t value = src.Value(method))
+                    {
+                        LossyAdd(method, value);
+                    }
+                }
+            }
+
+        private:
+            // Until C++20 std::atomic is not constexpr default-constructible, so we need
+            // a wrapper for this class to be constexpr constructible.
+            class Counter : public std::atomic<int64_t>
+            {
+            public:
+                constexpr Counter() noexcept :
+                    std::atomic<int64_t>(0)
+                {
+                }
+            };
+
+            Counter values_[kNumMethods];
+        };
+
+    }  // namespace cord_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/escaping.h b/CAPI/cpp/grpc/include/absl/strings/internal/escaping.h
index 6a9ce60..414a725 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/escaping.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/escaping.h
@@ -19,40 +19,42 @@
 
 #include "absl/strings/internal/resize_uninitialized.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-ABSL_CONST_INIT extern const char kBase64Chars[];
-
-// Calculates how long a string will be when it is base64 encoded given its
-// length and whether or not the result should be padded.
-size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding);
-
-// Base64-encodes `src` using the alphabet provided in `base64` and writes the
-// result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars
-// until its length is a multiple of 3. Returns the length of `dest`.
-size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
-                            size_t szdest, const char* base64, bool do_padding);
-
-// Base64-encodes `src` using the alphabet provided in `base64` and writes the
-// result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars
-// until its length is a multiple of 3.
-template <typename String>
-void Base64EscapeInternal(const unsigned char* src, size_t szsrc, String* dest,
-                          bool do_padding, const char* base64_chars) {
-  const size_t calc_escaped_size =
-      CalculateBase64EscapedLenInternal(szsrc, do_padding);
-  STLStringResizeUninitialized(dest, calc_escaped_size);
-
-  const size_t escaped_len = Base64EscapeInternal(
-      src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding);
-  assert(calc_escaped_size == escaped_len);
-  dest->erase(escaped_len);
-}
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        ABSL_CONST_INIT extern const char kBase64Chars[];
+
+        // Calculates how long a string will be when it is base64 encoded given its
+        // length and whether or not the result should be padded.
+        size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding);
+
+        // Base64-encodes `src` using the alphabet provided in `base64` and writes the
+        // result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars
+        // until its length is a multiple of 3. Returns the length of `dest`.
+        size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest, size_t szdest, const char* base64, bool do_padding);
+
+        // Base64-encodes `src` using the alphabet provided in `base64` and writes the
+        // result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars
+        // until its length is a multiple of 3.
+        template<typename String>
+        void Base64EscapeInternal(const unsigned char* src, size_t szsrc, String* dest, bool do_padding, const char* base64_chars)
+        {
+            const size_t calc_escaped_size =
+                CalculateBase64EscapedLenInternal(szsrc, do_padding);
+            STLStringResizeUninitialized(dest, calc_escaped_size);
+
+            const size_t escaped_len = Base64EscapeInternal(
+                src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding
+            );
+            assert(calc_escaped_size == escaped_len);
+            dest->erase(escaped_len);
+        }
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_ESCAPING_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/escaping_test_common.h b/CAPI/cpp/grpc/include/absl/strings/internal/escaping_test_common.h
index 7b18017..48be259 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/escaping_test_common.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/escaping_test_common.h
@@ -21,113 +21,120 @@
 #include <array>
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-struct base64_testcase {
-  absl::string_view plaintext;
-  absl::string_view cyphertext;
-};
-
-inline const std::array<base64_testcase, 5>& base64_strings() {
-  static const std::array<base64_testcase, 5> testcase{{
-      // Some google quotes
-      // Cyphertext created with "uuencode (GNU sharutils) 4.6.3"
-      // (Note that we're testing the websafe encoding, though, so if
-      // you add messages, be sure to run "tr -- '+/' '-_'" on the output)
-      { "I was always good at math and science, and I never realized "
-        "that was unusual or somehow undesirable. So one of the things "
-        "I care a lot about is helping to remove that stigma, "
-        "to show girls that you can be feminine, you can like the things "
-        "that girls like, but you can also be really good at technology. "
-        "You can be really good at building things."
-        " - Marissa Meyer, Newsweek, 2010-12-22" "\n",
-
-        "SSB3YXMgYWx3YXlzIGdvb2QgYXQgbWF0aCBhbmQgc2NpZW5jZSwgYW5kIEkg"
-        "bmV2ZXIgcmVhbGl6ZWQgdGhhdCB3YXMgdW51c3VhbCBvciBzb21laG93IHVu"
-        "ZGVzaXJhYmxlLiBTbyBvbmUgb2YgdGhlIHRoaW5ncyBJIGNhcmUgYSBsb3Qg"
-        "YWJvdXQgaXMgaGVscGluZyB0byByZW1vdmUgdGhhdCBzdGlnbWEsIHRvIHNo"
-        "b3cgZ2lybHMgdGhhdCB5b3UgY2FuIGJlIGZlbWluaW5lLCB5b3UgY2FuIGxp"
-        "a2UgdGhlIHRoaW5ncyB0aGF0IGdpcmxzIGxpa2UsIGJ1dCB5b3UgY2FuIGFs"
-        "c28gYmUgcmVhbGx5IGdvb2QgYXQgdGVjaG5vbG9neS4gWW91IGNhbiBiZSBy"
-        "ZWFsbHkgZ29vZCBhdCBidWlsZGluZyB0aGluZ3MuIC0gTWFyaXNzYSBNZXll"
-        "ciwgTmV3c3dlZWssIDIwMTAtMTItMjIK" },
-
-      { "Typical first year for a new cluster: "
-        "~0.5 overheating "
-        "~1 PDU failure "
-        "~1 rack-move "
-        "~1 network rewiring "
-        "~20 rack failures "
-        "~5 racks go wonky "
-        "~8 network maintenances "
-        "~12 router reloads "
-        "~3 router failures "
-        "~dozens of minor 30-second blips for dns "
-        "~1000 individual machine failures "
-        "~thousands of hard drive failures "
-        "slow disks, bad memory, misconfigured machines, flaky machines, etc."
-        " - Jeff Dean, The Joys of Real Hardware" "\n",
-
-        "VHlwaWNhbCBmaXJzdCB5ZWFyIGZvciBhIG5ldyBjbHVzdGVyOiB-MC41IG92"
-        "ZXJoZWF0aW5nIH4xIFBEVSBmYWlsdXJlIH4xIHJhY2stbW92ZSB-MSBuZXR3"
-        "b3JrIHJld2lyaW5nIH4yMCByYWNrIGZhaWx1cmVzIH41IHJhY2tzIGdvIHdv"
-        "bmt5IH44IG5ldHdvcmsgbWFpbnRlbmFuY2VzIH4xMiByb3V0ZXIgcmVsb2Fk"
-        "cyB-MyByb3V0ZXIgZmFpbHVyZXMgfmRvemVucyBvZiBtaW5vciAzMC1zZWNv"
-        "bmQgYmxpcHMgZm9yIGRucyB-MTAwMCBpbmRpdmlkdWFsIG1hY2hpbmUgZmFp"
-        "bHVyZXMgfnRob3VzYW5kcyBvZiBoYXJkIGRyaXZlIGZhaWx1cmVzIHNsb3cg"
-        "ZGlza3MsIGJhZCBtZW1vcnksIG1pc2NvbmZpZ3VyZWQgbWFjaGluZXMsIGZs"
-        "YWt5IG1hY2hpbmVzLCBldGMuIC0gSmVmZiBEZWFuLCBUaGUgSm95cyBvZiBS"
-        "ZWFsIEhhcmR3YXJlCg" },
-
-      { "I'm the head of the webspam team at Google.  "
-        "That means that if you type your name into Google and get porn back, "
-        "it's my fault. Unless you're a porn star, in which case porn is a "
-        "completely reasonable response."
-        " - Matt Cutts, Google Plus" "\n",
-
-        "SSdtIHRoZSBoZWFkIG9mIHRoZSB3ZWJzcGFtIHRlYW0gYXQgR29vZ2xlLiAg"
-        "VGhhdCBtZWFucyB0aGF0IGlmIHlvdSB0eXBlIHlvdXIgbmFtZSBpbnRvIEdv"
-        "b2dsZSBhbmQgZ2V0IHBvcm4gYmFjaywgaXQncyBteSBmYXVsdC4gVW5sZXNz"
-        "IHlvdSdyZSBhIHBvcm4gc3RhciwgaW4gd2hpY2ggY2FzZSBwb3JuIGlzIGEg"
-        "Y29tcGxldGVseSByZWFzb25hYmxlIHJlc3BvbnNlLiAtIE1hdHQgQ3V0dHMs"
-        "IEdvb2dsZSBQbHVzCg" },
-
-      { "It will still be a long time before machines approach human "
-        "intelligence. "
-        "But luckily, machines don't actually have to be intelligent; "
-        "they just have to fake it. Access to a wealth of information, "
-        "combined with a rudimentary decision-making capacity, "
-        "can often be almost as useful. Of course, the results are better yet "
-        "when coupled with intelligence. A reference librarian with access to "
-        "a good search engine is a formidable tool."
-        " - Craig Silverstein, Siemens Pictures of the Future, Spring 2004"
-        "\n",
-
-        "SXQgd2lsbCBzdGlsbCBiZSBhIGxvbmcgdGltZSBiZWZvcmUgbWFjaGluZXMg"
-        "YXBwcm9hY2ggaHVtYW4gaW50ZWxsaWdlbmNlLiBCdXQgbHVja2lseSwgbWFj"
-        "aGluZXMgZG9uJ3QgYWN0dWFsbHkgaGF2ZSB0byBiZSBpbnRlbGxpZ2VudDsg"
-        "dGhleSBqdXN0IGhhdmUgdG8gZmFrZSBpdC4gQWNjZXNzIHRvIGEgd2VhbHRo"
-        "IG9mIGluZm9ybWF0aW9uLCBjb21iaW5lZCB3aXRoIGEgcnVkaW1lbnRhcnkg"
-        "ZGVjaXNpb24tbWFraW5nIGNhcGFjaXR5LCBjYW4gb2Z0ZW4gYmUgYWxtb3N0"
-        "IGFzIHVzZWZ1bC4gT2YgY291cnNlLCB0aGUgcmVzdWx0cyBhcmUgYmV0dGVy"
-        "IHlldCB3aGVuIGNvdXBsZWQgd2l0aCBpbnRlbGxpZ2VuY2UuIEEgcmVmZXJl"
-        "bmNlIGxpYnJhcmlhbiB3aXRoIGFjY2VzcyB0byBhIGdvb2Qgc2VhcmNoIGVu"
-        "Z2luZSBpcyBhIGZvcm1pZGFibGUgdG9vbC4gLSBDcmFpZyBTaWx2ZXJzdGVp"
-        "biwgU2llbWVucyBQaWN0dXJlcyBvZiB0aGUgRnV0dXJlLCBTcHJpbmcgMjAw"
-        "NAo" },
-
-      // Degenerate edge case
-      { "",
-        "" },
-  }};
-
-  return testcase;
-}
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        struct base64_testcase
+        {
+            absl::string_view plaintext;
+            absl::string_view cyphertext;
+        };
+
+        inline const std::array<base64_testcase, 5>& base64_strings()
+        {
+            static const std::array<base64_testcase, 5> testcase{{
+                // Some google quotes
+                // Cyphertext created with "uuencode (GNU sharutils) 4.6.3"
+                // (Note that we're testing the websafe encoding, though, so if
+                // you add messages, be sure to run "tr -- '+/' '-_'" on the output)
+                {"I was always good at math and science, and I never realized "
+                 "that was unusual or somehow undesirable. So one of the things "
+                 "I care a lot about is helping to remove that stigma, "
+                 "to show girls that you can be feminine, you can like the things "
+                 "that girls like, but you can also be really good at technology. "
+                 "You can be really good at building things."
+                 " - Marissa Meyer, Newsweek, 2010-12-22"
+                 "\n",
+
+                 "SSB3YXMgYWx3YXlzIGdvb2QgYXQgbWF0aCBhbmQgc2NpZW5jZSwgYW5kIEkg"
+                 "bmV2ZXIgcmVhbGl6ZWQgdGhhdCB3YXMgdW51c3VhbCBvciBzb21laG93IHVu"
+                 "ZGVzaXJhYmxlLiBTbyBvbmUgb2YgdGhlIHRoaW5ncyBJIGNhcmUgYSBsb3Qg"
+                 "YWJvdXQgaXMgaGVscGluZyB0byByZW1vdmUgdGhhdCBzdGlnbWEsIHRvIHNo"
+                 "b3cgZ2lybHMgdGhhdCB5b3UgY2FuIGJlIGZlbWluaW5lLCB5b3UgY2FuIGxp"
+                 "a2UgdGhlIHRoaW5ncyB0aGF0IGdpcmxzIGxpa2UsIGJ1dCB5b3UgY2FuIGFs"
+                 "c28gYmUgcmVhbGx5IGdvb2QgYXQgdGVjaG5vbG9neS4gWW91IGNhbiBiZSBy"
+                 "ZWFsbHkgZ29vZCBhdCBidWlsZGluZyB0aGluZ3MuIC0gTWFyaXNzYSBNZXll"
+                 "ciwgTmV3c3dlZWssIDIwMTAtMTItMjIK"},
+
+                {"Typical first year for a new cluster: "
+                 "~0.5 overheating "
+                 "~1 PDU failure "
+                 "~1 rack-move "
+                 "~1 network rewiring "
+                 "~20 rack failures "
+                 "~5 racks go wonky "
+                 "~8 network maintenances "
+                 "~12 router reloads "
+                 "~3 router failures "
+                 "~dozens of minor 30-second blips for dns "
+                 "~1000 individual machine failures "
+                 "~thousands of hard drive failures "
+                 "slow disks, bad memory, misconfigured machines, flaky machines, etc."
+                 " - Jeff Dean, The Joys of Real Hardware"
+                 "\n",
+
+                 "VHlwaWNhbCBmaXJzdCB5ZWFyIGZvciBhIG5ldyBjbHVzdGVyOiB-MC41IG92"
+                 "ZXJoZWF0aW5nIH4xIFBEVSBmYWlsdXJlIH4xIHJhY2stbW92ZSB-MSBuZXR3"
+                 "b3JrIHJld2lyaW5nIH4yMCByYWNrIGZhaWx1cmVzIH41IHJhY2tzIGdvIHdv"
+                 "bmt5IH44IG5ldHdvcmsgbWFpbnRlbmFuY2VzIH4xMiByb3V0ZXIgcmVsb2Fk"
+                 "cyB-MyByb3V0ZXIgZmFpbHVyZXMgfmRvemVucyBvZiBtaW5vciAzMC1zZWNv"
+                 "bmQgYmxpcHMgZm9yIGRucyB-MTAwMCBpbmRpdmlkdWFsIG1hY2hpbmUgZmFp"
+                 "bHVyZXMgfnRob3VzYW5kcyBvZiBoYXJkIGRyaXZlIGZhaWx1cmVzIHNsb3cg"
+                 "ZGlza3MsIGJhZCBtZW1vcnksIG1pc2NvbmZpZ3VyZWQgbWFjaGluZXMsIGZs"
+                 "YWt5IG1hY2hpbmVzLCBldGMuIC0gSmVmZiBEZWFuLCBUaGUgSm95cyBvZiBS"
+                 "ZWFsIEhhcmR3YXJlCg"},
+
+                {"I'm the head of the webspam team at Google.  "
+                 "That means that if you type your name into Google and get porn back, "
+                 "it's my fault. Unless you're a porn star, in which case porn is a "
+                 "completely reasonable response."
+                 " - Matt Cutts, Google Plus"
+                 "\n",
+
+                 "SSdtIHRoZSBoZWFkIG9mIHRoZSB3ZWJzcGFtIHRlYW0gYXQgR29vZ2xlLiAg"
+                 "VGhhdCBtZWFucyB0aGF0IGlmIHlvdSB0eXBlIHlvdXIgbmFtZSBpbnRvIEdv"
+                 "b2dsZSBhbmQgZ2V0IHBvcm4gYmFjaywgaXQncyBteSBmYXVsdC4gVW5sZXNz"
+                 "IHlvdSdyZSBhIHBvcm4gc3RhciwgaW4gd2hpY2ggY2FzZSBwb3JuIGlzIGEg"
+                 "Y29tcGxldGVseSByZWFzb25hYmxlIHJlc3BvbnNlLiAtIE1hdHQgQ3V0dHMs"
+                 "IEdvb2dsZSBQbHVzCg"},
+
+                {"It will still be a long time before machines approach human "
+                 "intelligence. "
+                 "But luckily, machines don't actually have to be intelligent; "
+                 "they just have to fake it. Access to a wealth of information, "
+                 "combined with a rudimentary decision-making capacity, "
+                 "can often be almost as useful. Of course, the results are better yet "
+                 "when coupled with intelligence. A reference librarian with access to "
+                 "a good search engine is a formidable tool."
+                 " - Craig Silverstein, Siemens Pictures of the Future, Spring 2004"
+                 "\n",
+
+                 "SXQgd2lsbCBzdGlsbCBiZSBhIGxvbmcgdGltZSBiZWZvcmUgbWFjaGluZXMg"
+                 "YXBwcm9hY2ggaHVtYW4gaW50ZWxsaWdlbmNlLiBCdXQgbHVja2lseSwgbWFj"
+                 "aGluZXMgZG9uJ3QgYWN0dWFsbHkgaGF2ZSB0byBiZSBpbnRlbGxpZ2VudDsg"
+                 "dGhleSBqdXN0IGhhdmUgdG8gZmFrZSBpdC4gQWNjZXNzIHRvIGEgd2VhbHRo"
+                 "IG9mIGluZm9ybWF0aW9uLCBjb21iaW5lZCB3aXRoIGEgcnVkaW1lbnRhcnkg"
+                 "ZGVjaXNpb24tbWFraW5nIGNhcGFjaXR5LCBjYW4gb2Z0ZW4gYmUgYWxtb3N0"
+                 "IGFzIHVzZWZ1bC4gT2YgY291cnNlLCB0aGUgcmVzdWx0cyBhcmUgYmV0dGVy"
+                 "IHlldCB3aGVuIGNvdXBsZWQgd2l0aCBpbnRlbGxpZ2VuY2UuIEEgcmVmZXJl"
+                 "bmNlIGxpYnJhcmlhbiB3aXRoIGFjY2VzcyB0byBhIGdvb2Qgc2VhcmNoIGVu"
+                 "Z2luZSBpcyBhIGZvcm1pZGFibGUgdG9vbC4gLSBDcmFpZyBTaWx2ZXJzdGVp"
+                 "biwgU2llbWVucyBQaWN0dXJlcyBvZiB0aGUgRnV0dXJlLCBTcHJpbmcgMjAw"
+                 "NAo"},
+
+                // Degenerate edge case
+                {"",
+                 ""},
+            }};
+
+            return testcase;
+        }
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/memutil.h b/CAPI/cpp/grpc/include/absl/strings/internal/memutil.h
index 9ad0535..bad0f8d 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/memutil.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/memutil.h
@@ -65,84 +65,87 @@
 #include <cstddef>
 #include <cstring>
 
-#include "absl/base/port.h"  // disable some warnings on Windows
+#include "absl/base/port.h"      // disable some warnings on Windows
 #include "absl/strings/ascii.h"  // for absl::ascii_tolower
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-inline char* memcat(char* dest, size_t destlen, const char* src,
-                    size_t srclen) {
-  return reinterpret_cast<char*>(memcpy(dest + destlen, src, srclen));
-}
-
-int memcasecmp(const char* s1, const char* s2, size_t len);
-char* memdup(const char* s, size_t slen);
-char* memrchr(const char* s, int c, size_t slen);
-size_t memspn(const char* s, size_t slen, const char* accept);
-size_t memcspn(const char* s, size_t slen, const char* reject);
-char* mempbrk(const char* s, size_t slen, const char* accept);
-
-// This is for internal use only.  Don't call this directly
-template <bool case_sensitive>
-const char* int_memmatch(const char* haystack, size_t haylen,
-                         const char* needle, size_t neelen) {
-  if (0 == neelen) {
-    return haystack;  // even if haylen is 0
-  }
-  const char* hayend = haystack + haylen;
-  const char* needlestart = needle;
-  const char* needleend = needlestart + neelen;
-
-  for (; haystack < hayend; ++haystack) {
-    char hay = case_sensitive
-                   ? *haystack
-                   : absl::ascii_tolower(static_cast<unsigned char>(*haystack));
-    char nee = case_sensitive
-                   ? *needle
-                   : absl::ascii_tolower(static_cast<unsigned char>(*needle));
-    if (hay == nee) {
-      if (++needle == needleend) {
-        return haystack + 1 - neelen;
-      }
-    } else if (needle != needlestart) {
-      // must back up haystack in case a prefix matched (find "aab" in "aaab")
-      haystack -= needle - needlestart;  // for loop will advance one more
-      needle = needlestart;
-    }
-  }
-  return nullptr;
-}
-
-// These are the guys you can call directly
-inline const char* memstr(const char* phaystack, size_t haylen,
-                          const char* pneedle) {
-  return int_memmatch<true>(phaystack, haylen, pneedle, strlen(pneedle));
-}
-
-inline const char* memcasestr(const char* phaystack, size_t haylen,
-                              const char* pneedle) {
-  return int_memmatch<false>(phaystack, haylen, pneedle, strlen(pneedle));
-}
-
-inline const char* memmem(const char* phaystack, size_t haylen,
-                          const char* pneedle, size_t needlelen) {
-  return int_memmatch<true>(phaystack, haylen, pneedle, needlelen);
-}
-
-inline const char* memcasemem(const char* phaystack, size_t haylen,
-                              const char* pneedle, size_t needlelen) {
-  return int_memmatch<false>(phaystack, haylen, pneedle, needlelen);
-}
-
-// This is significantly faster for case-sensitive matches with very
-// few possible matches.  See unit test for benchmarks.
-const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
-                     size_t neelen);
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        inline char* memcat(char* dest, size_t destlen, const char* src, size_t srclen)
+        {
+            return reinterpret_cast<char*>(memcpy(dest + destlen, src, srclen));
+        }
+
+        int memcasecmp(const char* s1, const char* s2, size_t len);
+        char* memdup(const char* s, size_t slen);
+        char* memrchr(const char* s, int c, size_t slen);
+        size_t memspn(const char* s, size_t slen, const char* accept);
+        size_t memcspn(const char* s, size_t slen, const char* reject);
+        char* mempbrk(const char* s, size_t slen, const char* accept);
+
+        // This is for internal use only.  Don't call this directly
+        template<bool case_sensitive>
+        const char* int_memmatch(const char* haystack, size_t haylen, const char* needle, size_t neelen)
+        {
+            if (0 == neelen)
+            {
+                return haystack;  // even if haylen is 0
+            }
+            const char* hayend = haystack + haylen;
+            const char* needlestart = needle;
+            const char* needleend = needlestart + neelen;
+
+            for (; haystack < hayend; ++haystack)
+            {
+                char hay = case_sensitive ? *haystack : absl::ascii_tolower(static_cast<unsigned char>(*haystack));
+                char nee = case_sensitive ? *needle : absl::ascii_tolower(static_cast<unsigned char>(*needle));
+                if (hay == nee)
+                {
+                    if (++needle == needleend)
+                    {
+                        return haystack + 1 - neelen;
+                    }
+                }
+                else if (needle != needlestart)
+                {
+                    // must back up haystack in case a prefix matched (find "aab" in "aaab")
+                    haystack -= needle - needlestart;  // for loop will advance one more
+                    needle = needlestart;
+                }
+            }
+            return nullptr;
+        }
+
+        // These are the guys you can call directly
+        inline const char* memstr(const char* phaystack, size_t haylen, const char* pneedle)
+        {
+            return int_memmatch<true>(phaystack, haylen, pneedle, strlen(pneedle));
+        }
+
+        inline const char* memcasestr(const char* phaystack, size_t haylen, const char* pneedle)
+        {
+            return int_memmatch<false>(phaystack, haylen, pneedle, strlen(pneedle));
+        }
+
+        inline const char* memmem(const char* phaystack, size_t haylen, const char* pneedle, size_t needlelen)
+        {
+            return int_memmatch<true>(phaystack, haylen, pneedle, needlelen);
+        }
+
+        inline const char* memcasemem(const char* phaystack, size_t haylen, const char* pneedle, size_t needlelen)
+        {
+            return int_memmatch<false>(phaystack, haylen, pneedle, needlelen);
+        }
+
+        // This is significantly faster for case-sensitive matches with very
+        // few possible matches.  See unit test for benchmarks.
+        const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle, size_t neelen);
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_MEMUTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/numbers_test_common.h b/CAPI/cpp/grpc/include/absl/strings/internal/numbers_test_common.h
index eaa88a8..94b48fe 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/numbers_test_common.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/numbers_test_common.h
@@ -25,160 +25,165 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-template <typename IntType>
-inline bool Itoa(IntType value, int base, std::string* destination) {
-  destination->clear();
-  if (base <= 1 || base > 36) {
-    return false;
-  }
-
-  if (value == 0) {
-    destination->push_back('0');
-    return true;
-  }
-
-  bool negative = value < 0;
-  while (value != 0) {
-    const IntType next_value = value / base;
-    // Can't use std::abs here because of problems when IntType is unsigned.
-    int remainder =
-        static_cast<int>(value > next_value * base ? value - next_value * base
-                                                   : next_value * base - value);
-    char c = remainder < 10 ? '0' + remainder : 'A' + remainder - 10;
-    destination->insert(0, 1, c);
-    value = next_value;
-  }
-
-  if (negative) {
-    destination->insert(0, 1, '-');
-  }
-  return true;
-}
-
-struct uint32_test_case {
-  const char* str;
-  bool expect_ok;
-  int base;  // base to pass to the conversion function
-  uint32_t expected;
-};
-
-inline const std::array<uint32_test_case, 27>& strtouint32_test_cases() {
-  static const std::array<uint32_test_case, 27> test_cases{{
-      {"0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
-      {"0x34234324", true, 16, 0x34234324},
-      {"34234324", true, 16, 0x34234324},
-      {"0", true, 16, 0},
-      {" \t\n 0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
-      {" \f\v 46", true, 10, 46},  // must accept weird whitespace
-      {" \t\n 72717222", true, 8, 072717222},
-      {" \t\n 072717222", true, 8, 072717222},
-      {" \t\n 072717228", false, 8, 07271722},
-      {"0", true, 0, 0},
-
-      // Base-10 version.
-      {"34234324", true, 0, 34234324},
-      {"4294967295", true, 0, (std::numeric_limits<uint32_t>::max)()},
-      {"34234324 \n\t", true, 10, 34234324},
-
-      // Unusual base
-      {"0", true, 3, 0},
-      {"2", true, 3, 2},
-      {"11", true, 3, 4},
-
-      // Invalid uints.
-      {"", false, 0, 0},
-      {"  ", false, 0, 0},
-      {"abc", false, 0, 0},  // would be valid hex, but prefix is missing
-      {"34234324a", false, 0, 34234324},
-      {"34234.3", false, 0, 34234},
-      {"-1", false, 0, 0},
-      {"   -123", false, 0, 0},
-      {" \t\n -123", false, 0, 0},
-
-      // Out of bounds.
-      {"4294967296", false, 0, (std::numeric_limits<uint32_t>::max)()},
-      {"0x100000000", false, 0, (std::numeric_limits<uint32_t>::max)()},
-      {nullptr, false, 0, 0},
-  }};
-  return test_cases;
-}
-
-struct uint64_test_case {
-  const char* str;
-  bool expect_ok;
-  int base;
-  uint64_t expected;
-};
-
-inline const std::array<uint64_test_case, 34>& strtouint64_test_cases() {
-  static const std::array<uint64_test_case, 34> test_cases{{
-      {"0x3423432448783446", true, 16, int64_t{0x3423432448783446}},
-      {"3423432448783446", true, 16, int64_t{0x3423432448783446}},
-
-      {"0", true, 16, 0},
-      {"000", true, 0, 0},
-      {"0", true, 0, 0},
-      {" \t\n 0xffffffffffffffff", true, 16,
-       (std::numeric_limits<uint64_t>::max)()},
-
-      {"012345670123456701234", true, 8, int64_t{012345670123456701234}},
-      {"12345670123456701234", true, 8, int64_t{012345670123456701234}},
-
-      {"12845670123456701234", false, 8, 0},
-
-      // Base-10 version.
-      {"34234324487834466", true, 0, int64_t{34234324487834466}},
-
-      {" \t\n 18446744073709551615", true, 0,
-       (std::numeric_limits<uint64_t>::max)()},
-
-      {"34234324487834466 \n\t ", true, 0, int64_t{34234324487834466}},
-
-      {" \f\v 46", true, 10, 46},  // must accept weird whitespace
-
-      // Unusual base
-      {"0", true, 3, 0},
-      {"2", true, 3, 2},
-      {"11", true, 3, 4},
-
-      {"0", true, 0, 0},
-
-      // Invalid uints.
-      {"", false, 0, 0},
-      {"  ", false, 0, 0},
-      {"abc", false, 0, 0},
-      {"34234324487834466a", false, 0, 0},
-      {"34234487834466.3", false, 0, 0},
-      {"-1", false, 0, 0},
-      {"   -123", false, 0, 0},
-      {" \t\n -123", false, 0, 0},
-
-      // Out of bounds.
-      {"18446744073709551616", false, 10, 0},
-      {"18446744073709551616", false, 0, 0},
-      {"0x10000000000000000", false, 16,
-       (std::numeric_limits<uint64_t>::max)()},
-      {"0X10000000000000000", false, 16,
-       (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x.
-      {"0x10000000000000000", false, 0, (std::numeric_limits<uint64_t>::max)()},
-      {"0X10000000000000000", false, 0,
-       (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x.
-
-      {"0x1234", true, 16, 0x1234},
-
-      // Base-10 string version.
-      {"1234", true, 0, 1234},
-      {nullptr, false, 0, 0},
-  }};
-  return test_cases;
-}
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        template<typename IntType>
+        inline bool Itoa(IntType value, int base, std::string* destination)
+        {
+            destination->clear();
+            if (base <= 1 || base > 36)
+            {
+                return false;
+            }
+
+            if (value == 0)
+            {
+                destination->push_back('0');
+                return true;
+            }
+
+            bool negative = value < 0;
+            while (value != 0)
+            {
+                const IntType next_value = value / base;
+                // Can't use std::abs here because of problems when IntType is unsigned.
+                int remainder =
+                    static_cast<int>(value > next_value * base ? value - next_value * base : next_value * base - value);
+                char c = remainder < 10 ? '0' + remainder : 'A' + remainder - 10;
+                destination->insert(0, 1, c);
+                value = next_value;
+            }
+
+            if (negative)
+            {
+                destination->insert(0, 1, '-');
+            }
+            return true;
+        }
+
+        struct uint32_test_case
+        {
+            const char* str;
+            bool expect_ok;
+            int base;  // base to pass to the conversion function
+            uint32_t expected;
+        };
+
+        inline const std::array<uint32_test_case, 27>& strtouint32_test_cases()
+        {
+            static const std::array<uint32_test_case, 27> test_cases{{
+                {"0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
+                {"0x34234324", true, 16, 0x34234324},
+                {"34234324", true, 16, 0x34234324},
+                {"0", true, 16, 0},
+                {" \t\n 0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
+                {" \f\v 46", true, 10, 46},  // must accept weird whitespace
+                {" \t\n 72717222", true, 8, 072717222},
+                {" \t\n 072717222", true, 8, 072717222},
+                {" \t\n 072717228", false, 8, 07271722},
+                {"0", true, 0, 0},
+
+                // Base-10 version.
+                {"34234324", true, 0, 34234324},
+                {"4294967295", true, 0, (std::numeric_limits<uint32_t>::max)()},
+                {"34234324 \n\t", true, 10, 34234324},
+
+                // Unusual base
+                {"0", true, 3, 0},
+                {"2", true, 3, 2},
+                {"11", true, 3, 4},
+
+                // Invalid uints.
+                {"", false, 0, 0},
+                {"  ", false, 0, 0},
+                {"abc", false, 0, 0},  // would be valid hex, but prefix is missing
+                {"34234324a", false, 0, 34234324},
+                {"34234.3", false, 0, 34234},
+                {"-1", false, 0, 0},
+                {"   -123", false, 0, 0},
+                {" \t\n -123", false, 0, 0},
+
+                // Out of bounds.
+                {"4294967296", false, 0, (std::numeric_limits<uint32_t>::max)()},
+                {"0x100000000", false, 0, (std::numeric_limits<uint32_t>::max)()},
+                {nullptr, false, 0, 0},
+            }};
+            return test_cases;
+        }
+
+        struct uint64_test_case
+        {
+            const char* str;
+            bool expect_ok;
+            int base;
+            uint64_t expected;
+        };
+
+        inline const std::array<uint64_test_case, 34>& strtouint64_test_cases()
+        {
+            static const std::array<uint64_test_case, 34> test_cases{{
+                {"0x3423432448783446", true, 16, int64_t{0x3423432448783446}},
+                {"3423432448783446", true, 16, int64_t{0x3423432448783446}},
+
+                {"0", true, 16, 0},
+                {"000", true, 0, 0},
+                {"0", true, 0, 0},
+                {" \t\n 0xffffffffffffffff", true, 16, (std::numeric_limits<uint64_t>::max)()},
+
+                {"012345670123456701234", true, 8, int64_t{012345670123456701234}},
+                {"12345670123456701234", true, 8, int64_t{012345670123456701234}},
+
+                {"12845670123456701234", false, 8, 0},
+
+                // Base-10 version.
+                {"34234324487834466", true, 0, int64_t{34234324487834466}},
+
+                {" \t\n 18446744073709551615", true, 0, (std::numeric_limits<uint64_t>::max)()},
+
+                {"34234324487834466 \n\t ", true, 0, int64_t{34234324487834466}},
+
+                {" \f\v 46", true, 10, 46},  // must accept weird whitespace
+
+                // Unusual base
+                {"0", true, 3, 0},
+                {"2", true, 3, 2},
+                {"11", true, 3, 4},
+
+                {"0", true, 0, 0},
+
+                // Invalid uints.
+                {"", false, 0, 0},
+                {"  ", false, 0, 0},
+                {"abc", false, 0, 0},
+                {"34234324487834466a", false, 0, 0},
+                {"34234487834466.3", false, 0, 0},
+                {"-1", false, 0, 0},
+                {"   -123", false, 0, 0},
+                {" \t\n -123", false, 0, 0},
+
+                // Out of bounds.
+                {"18446744073709551616", false, 10, 0},
+                {"18446744073709551616", false, 0, 0},
+                {"0x10000000000000000", false, 16, (std::numeric_limits<uint64_t>::max)()},
+                {"0X10000000000000000", false, 16, (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x.
+                {"0x10000000000000000", false, 0, (std::numeric_limits<uint64_t>::max)()},
+                {"0X10000000000000000", false, 0, (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x.
+
+                {"0x1234", true, 16, 0x1234},
+
+                // Base-10 string version.
+                {"1234", true, 0, 1234},
+                {nullptr, false, 0, 0},
+            }};
+            return test_cases;
+        }
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/ostringstream.h b/CAPI/cpp/grpc/include/absl/strings/internal/ostringstream.h
index d25d604..7ff080c 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/ostringstream.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/ostringstream.h
@@ -22,68 +22,84 @@
 
 #include "absl/base/port.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
 
-// The same as std::ostringstream but appends to a user-specified std::string,
-// and is faster. It is ~70% faster to create, ~50% faster to write to, and
-// completely free to extract the result std::string.
-//
-//   std::string s;
-//   OStringStream strm(&s);
-//   strm << 42 << ' ' << 3.14;  // appends to `s`
-//
-// The stream object doesn't have to be named. Starting from C++11 operator<<
-// works with rvalues of std::ostream.
-//
-//   std::string s;
-//   OStringStream(&s) << 42 << ' ' << 3.14;  // appends to `s`
-//
-// OStringStream is faster to create than std::ostringstream but it's still
-// relatively slow. Avoid creating multiple streams where a single stream will
-// do.
-//
-// Creates unnecessary instances of OStringStream: slow.
-//
-//   std::string s;
-//   OStringStream(&s) << 42;
-//   OStringStream(&s) << ' ';
-//   OStringStream(&s) << 3.14;
-//
-// Creates a single instance of OStringStream and reuses it: fast.
-//
-//   std::string s;
-//   OStringStream strm(&s);
-//   strm << 42;
-//   strm << ' ';
-//   strm << 3.14;
-//
-// Note: flush() has no effect. No reason to call it.
-class OStringStream : private std::basic_streambuf<char>, public std::ostream {
- public:
-  // The argument can be null, in which case you'll need to call str(p) with a
-  // non-null argument before you can write to the stream.
-  //
-  // The destructor of OStringStream doesn't use the std::string. It's OK to
-  // destroy the std::string before the stream.
-  explicit OStringStream(std::string* s) : std::ostream(this), s_(s) {}
+        // The same as std::ostringstream but appends to a user-specified std::string,
+        // and is faster. It is ~70% faster to create, ~50% faster to write to, and
+        // completely free to extract the result std::string.
+        //
+        //   std::string s;
+        //   OStringStream strm(&s);
+        //   strm << 42 << ' ' << 3.14;  // appends to `s`
+        //
+        // The stream object doesn't have to be named. Starting from C++11 operator<<
+        // works with rvalues of std::ostream.
+        //
+        //   std::string s;
+        //   OStringStream(&s) << 42 << ' ' << 3.14;  // appends to `s`
+        //
+        // OStringStream is faster to create than std::ostringstream but it's still
+        // relatively slow. Avoid creating multiple streams where a single stream will
+        // do.
+        //
+        // Creates unnecessary instances of OStringStream: slow.
+        //
+        //   std::string s;
+        //   OStringStream(&s) << 42;
+        //   OStringStream(&s) << ' ';
+        //   OStringStream(&s) << 3.14;
+        //
+        // Creates a single instance of OStringStream and reuses it: fast.
+        //
+        //   std::string s;
+        //   OStringStream strm(&s);
+        //   strm << 42;
+        //   strm << ' ';
+        //   strm << 3.14;
+        //
+        // Note: flush() has no effect. No reason to call it.
+        class OStringStream : private std::basic_streambuf<char>, public std::ostream
+        {
+        public:
+            // The argument can be null, in which case you'll need to call str(p) with a
+            // non-null argument before you can write to the stream.
+            //
+            // The destructor of OStringStream doesn't use the std::string. It's OK to
+            // destroy the std::string before the stream.
+            explicit OStringStream(std::string* s) :
+                std::ostream(this),
+                s_(s)
+            {
+            }
 
-  std::string* str() { return s_; }
-  const std::string* str() const { return s_; }
-  void str(std::string* s) { s_ = s; }
+            std::string* str()
+            {
+                return s_;
+            }
+            const std::string* str() const
+            {
+                return s_;
+            }
+            void str(std::string* s)
+            {
+                s_ = s;
+            }
 
- private:
-  using Buf = std::basic_streambuf<char>;
+        private:
+            using Buf = std::basic_streambuf<char>;
 
-  Buf::int_type overflow(int c) override;
-  std::streamsize xsputn(const char* s, std::streamsize n) override;
+            Buf::int_type overflow(int c) override;
+            std::streamsize xsputn(const char* s, std::streamsize n) override;
 
-  std::string* s_;
-};
+            std::string* s_;
+        };
 
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/pow10_helper.h b/CAPI/cpp/grpc/include/absl/strings/internal/pow10_helper.h
index c37c2c3..345c460 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/pow10_helper.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/pow10_helper.h
@@ -24,17 +24,19 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
 
-// Computes the precise value of 10^exp. (I.e. the nearest representable
-// double to the exact value, rounding to nearest-even in the (single) case of
-// being exactly halfway between.)
-double Pow10(int exp);
+        // Computes the precise value of 10^exp. (I.e. the nearest representable
+        // double to the exact value, rounding to nearest-even in the (single) case of
+        // being exactly halfway between.)
+        double Pow10(int exp);
 
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/resize_uninitialized.h b/CAPI/cpp/grpc/include/absl/strings/internal/resize_uninitialized.h
index 49859dc..642b50a 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/resize_uninitialized.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/resize_uninitialized.h
@@ -25,95 +25,117 @@
 #include "absl/base/port.h"
 #include "absl/meta/type_traits.h"  //  for void_t
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
 
-// In this type trait, we look for a __resize_default_init member function, and
-// we use it if available, otherwise, we use resize. We provide HasMember to
-// indicate whether __resize_default_init is present.
-template <typename string_type, typename = void>
-struct ResizeUninitializedTraits {
-  using HasMember = std::false_type;
-  static void Resize(string_type* s, size_t new_size) { s->resize(new_size); }
-};
+        // In this type trait, we look for a __resize_default_init member function, and
+        // we use it if available, otherwise, we use resize. We provide HasMember to
+        // indicate whether __resize_default_init is present.
+        template<typename string_type, typename = void>
+        struct ResizeUninitializedTraits
+        {
+            using HasMember = std::false_type;
+            static void Resize(string_type* s, size_t new_size)
+            {
+                s->resize(new_size);
+            }
+        };
 
-// __resize_default_init is provided by libc++ >= 8.0
-template <typename string_type>
-struct ResizeUninitializedTraits<
-    string_type, absl::void_t<decltype(std::declval<string_type&>()
-                                           .__resize_default_init(237))> > {
-  using HasMember = std::true_type;
-  static void Resize(string_type* s, size_t new_size) {
-    s->__resize_default_init(new_size);
-  }
-};
+        // __resize_default_init is provided by libc++ >= 8.0
+        template<typename string_type>
+        struct ResizeUninitializedTraits<
+            string_type,
+            absl::void_t<decltype(std::declval<string_type&>()
+                                      .__resize_default_init(237))>>
+        {
+            using HasMember = std::true_type;
+            static void Resize(string_type* s, size_t new_size)
+            {
+                s->__resize_default_init(new_size);
+            }
+        };
 
-// Returns true if the std::string implementation supports a resize where
-// the new characters added to the std::string are left untouched.
-//
-// (A better name might be "STLStringSupportsUninitializedResize", alluding to
-// the previous function.)
-template <typename string_type>
-inline constexpr bool STLStringSupportsNontrashingResize(string_type*) {
-  return ResizeUninitializedTraits<string_type>::HasMember::value;
-}
+        // Returns true if the std::string implementation supports a resize where
+        // the new characters added to the std::string are left untouched.
+        //
+        // (A better name might be "STLStringSupportsUninitializedResize", alluding to
+        // the previous function.)
+        template<typename string_type>
+        inline constexpr bool STLStringSupportsNontrashingResize(string_type*)
+        {
+            return ResizeUninitializedTraits<string_type>::HasMember::value;
+        }
 
-// Like str->resize(new_size), except any new characters added to "*str" as a
-// result of resizing may be left uninitialized, rather than being filled with
-// '0' bytes. Typically used when code is then going to overwrite the backing
-// store of the std::string with known data.
-template <typename string_type, typename = void>
-inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
-  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
-}
+        // Like str->resize(new_size), except any new characters added to "*str" as a
+        // result of resizing may be left uninitialized, rather than being filled with
+        // '0' bytes. Typically used when code is then going to overwrite the backing
+        // store of the std::string with known data.
+        template<typename string_type, typename = void>
+        inline void STLStringResizeUninitialized(string_type* s, size_t new_size)
+        {
+            ResizeUninitializedTraits<string_type>::Resize(s, new_size);
+        }
 
-// Used to ensure exponential growth so that the amortized complexity of
-// increasing the string size by a small amount is O(1), in contrast to
-// O(str->size()) in the case of precise growth.
-template <typename string_type>
-void STLStringReserveAmortized(string_type* s, size_t new_size) {
-  const size_t cap = s->capacity();
-  if (new_size > cap) {
-    // Make sure to always grow by at least a factor of 2x.
-    s->reserve((std::max)(new_size, 2 * cap));
-  }
-}
+        // Used to ensure exponential growth so that the amortized complexity of
+        // increasing the string size by a small amount is O(1), in contrast to
+        // O(str->size()) in the case of precise growth.
+        template<typename string_type>
+        void STLStringReserveAmortized(string_type* s, size_t new_size)
+        {
+            const size_t cap = s->capacity();
+            if (new_size > cap)
+            {
+                // Make sure to always grow by at least a factor of 2x.
+                s->reserve((std::max)(new_size, 2 * cap));
+            }
+        }
 
-// In this type trait, we look for an __append_default_init member function, and
-// we use it if available, otherwise, we use append.
-template <typename string_type, typename = void>
-struct AppendUninitializedTraits {
-  static void Append(string_type* s, size_t n) {
-    s->append(n, typename string_type::value_type());
-  }
-};
+        // In this type trait, we look for an __append_default_init member function, and
+        // we use it if available, otherwise, we use append.
+        template<typename string_type, typename = void>
+        struct AppendUninitializedTraits
+        {
+            static void Append(string_type* s, size_t n)
+            {
+                s->append(n, typename string_type::value_type());
+            }
+        };
 
-template <typename string_type>
-struct AppendUninitializedTraits<
-    string_type, absl::void_t<decltype(std::declval<string_type&>()
-                                           .__append_default_init(237))> > {
-  static void Append(string_type* s, size_t n) {
-    s->__append_default_init(n);
-  }
-};
+        template<typename string_type>
+        struct AppendUninitializedTraits<
+            string_type,
+            absl::void_t<decltype(std::declval<string_type&>()
+                                      .__append_default_init(237))>>
+        {
+            static void Append(string_type* s, size_t n)
+            {
+                s->__append_default_init(n);
+            }
+        };
 
-// Like STLStringResizeUninitialized(str, new_size), except guaranteed to use
-// exponential growth so that the amortized complexity of increasing the string
-// size by a small amount is O(1), in contrast to O(str->size()) in the case of
-// precise growth.
-template <typename string_type>
-void STLStringResizeUninitializedAmortized(string_type* s, size_t new_size) {
-  const size_t size = s->size();
-  if (new_size > size) {
-    AppendUninitializedTraits<string_type>::Append(s, new_size - size);
-  } else {
-    s->erase(new_size);
-  }
-}
+        // Like STLStringResizeUninitialized(str, new_size), except guaranteed to use
+        // exponential growth so that the amortized complexity of increasing the string
+        // size by a small amount is O(1), in contrast to O(str->size()) in the case of
+        // precise growth.
+        template<typename string_type>
+        void STLStringResizeUninitializedAmortized(string_type* s, size_t new_size)
+        {
+            const size_t size = s->size();
+            if (new_size > size)
+            {
+                AppendUninitializedTraits<string_type>::Append(s, new_size - size);
+            }
+            else
+            {
+                s->erase(new_size);
+            }
+        }
 
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/stl_type_traits.h b/CAPI/cpp/grpc/include/absl/strings/internal/stl_type_traits.h
index 6035ca4..b7dd9aa 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/stl_type_traits.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/stl_type_traits.h
@@ -39,210 +39,201 @@
 
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-template <typename C, template <typename...> class T>
-struct IsSpecializationImpl : std::false_type {};
-template <template <typename...> class T, typename... Args>
-struct IsSpecializationImpl<T<Args...>, T> : std::true_type {};
-template <typename C, template <typename...> class T>
-using IsSpecialization = IsSpecializationImpl<absl::decay_t<C>, T>;
-
-template <typename C>
-struct IsArrayImpl : std::false_type {};
-template <template <typename, size_t> class A, typename T, size_t N>
-struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>> {};
-template <typename C>
-using IsArray = IsArrayImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsBitsetImpl : std::false_type {};
-template <template <size_t> class B, size_t N>
-struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>> {};
-template <typename C>
-using IsBitset = IsBitsetImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsSTLContainer
-    : absl::disjunction<
-          IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>,
-          IsSpecialization<C, std::forward_list>,
-          IsSpecialization<C, std::list>, IsSpecialization<C, std::map>,
-          IsSpecialization<C, std::multimap>, IsSpecialization<C, std::set>,
-          IsSpecialization<C, std::multiset>,
-          IsSpecialization<C, std::unordered_map>,
-          IsSpecialization<C, std::unordered_multimap>,
-          IsSpecialization<C, std::unordered_set>,
-          IsSpecialization<C, std::unordered_multiset>,
-          IsSpecialization<C, std::vector>> {};
-
-template <typename C, template <typename...> class T, typename = void>
-struct IsBaseOfSpecializationImpl : std::false_type {};
-// IsBaseOfSpecializationImpl needs multiple partial specializations to SFINAE
-// on the existence of container dependent types and plug them into the STL
-// template.
-template <typename C, template <typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
-    : std::is_base_of<C,
-                      T<typename C::value_type, typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::key_compare,
-                 typename C::allocator_type>>
-    : std::is_base_of<C, T<typename C::key_type, typename C::key_compare,
-                           typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::key_compare, typename C::allocator_type>>
-    : std::is_base_of<C,
-                      T<typename C::key_type, typename C::mapped_type,
-                        typename C::key_compare, typename C::allocator_type>> {
-};
-template <typename C, template <typename, typename, typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::hasher,
-                 typename C::key_equal, typename C::allocator_type>>
-    : std::is_base_of<C, T<typename C::key_type, typename C::hasher,
-                           typename C::key_equal, typename C::allocator_type>> {
-};
-template <typename C,
-          template <typename, typename, typename, typename, typename> class T>
-struct IsBaseOfSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::hasher, typename C::key_equal,
-                 typename C::allocator_type>>
-    : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type,
-                           typename C::hasher, typename C::key_equal,
-                           typename C::allocator_type>> {};
-template <typename C, template <typename...> class T>
-using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<absl::decay_t<C>, T>;
-
-template <typename C>
-struct IsBaseOfArrayImpl : std::false_type {};
-template <template <typename, size_t> class A, typename T, size_t N>
-struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>> {
-};
-template <typename C>
-using IsBaseOfArray = IsBaseOfArrayImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsBaseOfBitsetImpl : std::false_type {};
-template <template <size_t> class B, size_t N>
-struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>> {};
-template <typename C>
-using IsBaseOfBitset = IsBaseOfBitsetImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsBaseOfSTLContainer
-    : absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>,
-                        IsBaseOfSpecialization<C, std::deque>,
-                        IsBaseOfSpecialization<C, std::forward_list>,
-                        IsBaseOfSpecialization<C, std::list>,
-                        IsBaseOfSpecialization<C, std::map>,
-                        IsBaseOfSpecialization<C, std::multimap>,
-                        IsBaseOfSpecialization<C, std::set>,
-                        IsBaseOfSpecialization<C, std::multiset>,
-                        IsBaseOfSpecialization<C, std::unordered_map>,
-                        IsBaseOfSpecialization<C, std::unordered_multimap>,
-                        IsBaseOfSpecialization<C, std::unordered_set>,
-                        IsBaseOfSpecialization<C, std::unordered_multiset>,
-                        IsBaseOfSpecialization<C, std::vector>> {};
-
-template <typename C, template <typename...> class T, typename = void>
-struct IsConvertibleToSpecializationImpl : std::false_type {};
-// IsConvertibleToSpecializationImpl needs multiple partial specializations to
-// SFINAE on the existence of container dependent types and plug them into the
-// STL template.
-template <typename C, template <typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
-    : std::is_convertible<
-          C, T<typename C::value_type, typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::key_compare,
-                 typename C::allocator_type>>
-    : std::is_convertible<C, T<typename C::key_type, typename C::key_compare,
-                               typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::key_compare, typename C::allocator_type>>
-    : std::is_convertible<
-          C, T<typename C::key_type, typename C::mapped_type,
-               typename C::key_compare, typename C::allocator_type>> {};
-template <typename C, template <typename, typename, typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::hasher,
-                 typename C::key_equal, typename C::allocator_type>>
-    : std::is_convertible<
-          C, T<typename C::key_type, typename C::hasher, typename C::key_equal,
-               typename C::allocator_type>> {};
-template <typename C,
-          template <typename, typename, typename, typename, typename> class T>
-struct IsConvertibleToSpecializationImpl<
-    C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::hasher, typename C::key_equal,
-                 typename C::allocator_type>>
-    : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type,
-                               typename C::hasher, typename C::key_equal,
-                               typename C::allocator_type>> {};
-template <typename C, template <typename...> class T>
-using IsConvertibleToSpecialization =
-    IsConvertibleToSpecializationImpl<absl::decay_t<C>, T>;
-
-template <typename C>
-struct IsConvertibleToArrayImpl : std::false_type {};
-template <template <typename, size_t> class A, typename T, size_t N>
-struct IsConvertibleToArrayImpl<A<T, N>>
-    : std::is_convertible<A<T, N>, std::array<T, N>> {};
-template <typename C>
-using IsConvertibleToArray = IsConvertibleToArrayImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsConvertibleToBitsetImpl : std::false_type {};
-template <template <size_t> class B, size_t N>
-struct IsConvertibleToBitsetImpl<B<N>>
-    : std::is_convertible<B<N>, std::bitset<N>> {};
-template <typename C>
-using IsConvertibleToBitset = IsConvertibleToBitsetImpl<absl::decay_t<C>>;
-
-template <typename C>
-struct IsConvertibleToSTLContainer
-    : absl::disjunction<
-          IsConvertibleToArray<C>, IsConvertibleToBitset<C>,
-          IsConvertibleToSpecialization<C, std::deque>,
-          IsConvertibleToSpecialization<C, std::forward_list>,
-          IsConvertibleToSpecialization<C, std::list>,
-          IsConvertibleToSpecialization<C, std::map>,
-          IsConvertibleToSpecialization<C, std::multimap>,
-          IsConvertibleToSpecialization<C, std::set>,
-          IsConvertibleToSpecialization<C, std::multiset>,
-          IsConvertibleToSpecialization<C, std::unordered_map>,
-          IsConvertibleToSpecialization<C, std::unordered_multimap>,
-          IsConvertibleToSpecialization<C, std::unordered_set>,
-          IsConvertibleToSpecialization<C, std::unordered_multiset>,
-          IsConvertibleToSpecialization<C, std::vector>> {};
-
-template <typename C>
-struct IsStrictlyBaseOfAndConvertibleToSTLContainer
-    : absl::conjunction<absl::negation<IsSTLContainer<C>>,
-                        IsBaseOfSTLContainer<C>,
-                        IsConvertibleToSTLContainer<C>> {};
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        template<typename C, template<typename...> class T>
+        struct IsSpecializationImpl : std::false_type
+        {
+        };
+        template<template<typename...> class T, typename... Args>
+        struct IsSpecializationImpl<T<Args...>, T> : std::true_type
+        {
+        };
+        template<typename C, template<typename...> class T>
+        using IsSpecialization = IsSpecializationImpl<absl::decay_t<C>, T>;
+
+        template<typename C>
+        struct IsArrayImpl : std::false_type
+        {
+        };
+        template<template<typename, size_t> class A, typename T, size_t N>
+        struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>>
+        {
+        };
+        template<typename C>
+        using IsArray = IsArrayImpl<absl::decay_t<C>>;
+
+        template<typename C>
+        struct IsBitsetImpl : std::false_type
+        {
+        };
+        template<template<size_t> class B, size_t N>
+        struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>>
+        {
+        };
+        template<typename C>
+        using IsBitset = IsBitsetImpl<absl::decay_t<C>>;
+
+        template<typename C>
+        struct IsSTLContainer : absl::disjunction<IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>, IsSpecialization<C, std::forward_list>, IsSpecialization<C, std::list>, IsSpecialization<C, std::map>, IsSpecialization<C, std::multimap>, IsSpecialization<C, std::set>, IsSpecialization<C, std::multiset>, IsSpecialization<C, std::unordered_map>, IsSpecialization<C, std::unordered_multimap>, IsSpecialization<C, std::unordered_set>, IsSpecialization<C, std::unordered_multiset>, IsSpecialization<C, std::vector>>
+        {
+        };
+
+        template<typename C, template<typename...> class T, typename = void>
+        struct IsBaseOfSpecializationImpl : std::false_type
+        {
+        };
+        // IsBaseOfSpecializationImpl needs multiple partial specializations to SFINAE
+        // on the existence of container dependent types and plug them into the STL
+        // template.
+        template<typename C, template<typename, typename> class T>
+        struct IsBaseOfSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::value_type, typename C::allocator_type>> : std::is_base_of<C, T<typename C::value_type, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename, typename, typename> class T>
+        struct IsBaseOfSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::key_type, typename C::key_compare, typename C::allocator_type>> : std::is_base_of<C, T<typename C::key_type, typename C::key_compare, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename, typename, typename, typename> class T>
+        struct IsBaseOfSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::key_type, typename C::mapped_type, typename C::key_compare, typename C::allocator_type>> : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type, typename C::key_compare, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename, typename, typename, typename> class T>
+        struct IsBaseOfSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> : std::is_base_of<C, T<typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename, typename, typename, typename, typename> class T>
+        struct IsBaseOfSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename...> class T>
+        using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<absl::decay_t<C>, T>;
+
+        template<typename C>
+        struct IsBaseOfArrayImpl : std::false_type
+        {
+        };
+        template<template<typename, size_t> class A, typename T, size_t N>
+        struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>>
+        {
+        };
+        template<typename C>
+        using IsBaseOfArray = IsBaseOfArrayImpl<absl::decay_t<C>>;
+
+        template<typename C>
+        struct IsBaseOfBitsetImpl : std::false_type
+        {
+        };
+        template<template<size_t> class B, size_t N>
+        struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>>
+        {
+        };
+        template<typename C>
+        using IsBaseOfBitset = IsBaseOfBitsetImpl<absl::decay_t<C>>;
+
+        template<typename C>
+        struct IsBaseOfSTLContainer : absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>, IsBaseOfSpecialization<C, std::deque>, IsBaseOfSpecialization<C, std::forward_list>, IsBaseOfSpecialization<C, std::list>, IsBaseOfSpecialization<C, std::map>, IsBaseOfSpecialization<C, std::multimap>, IsBaseOfSpecialization<C, std::set>, IsBaseOfSpecialization<C, std::multiset>, IsBaseOfSpecialization<C, std::unordered_map>, IsBaseOfSpecialization<C, std::unordered_multimap>, IsBaseOfSpecialization<C, std::unordered_set>, IsBaseOfSpecialization<C, std::unordered_multiset>, IsBaseOfSpecialization<C, std::vector>>
+        {
+        };
+
+        template<typename C, template<typename...> class T, typename = void>
+        struct IsConvertibleToSpecializationImpl : std::false_type
+        {
+        };
+        // IsConvertibleToSpecializationImpl needs multiple partial specializations to
+        // SFINAE on the existence of container dependent types and plug them into the
+        // STL template.
+        template<typename C, template<typename, typename> class T>
+        struct IsConvertibleToSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::value_type, typename C::allocator_type>> : std::is_convertible<C, T<typename C::value_type, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename, typename, typename> class T>
+        struct IsConvertibleToSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::key_type, typename C::key_compare, typename C::allocator_type>> : std::is_convertible<C, T<typename C::key_type, typename C::key_compare, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename, typename, typename, typename> class T>
+        struct IsConvertibleToSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::key_type, typename C::mapped_type, typename C::key_compare, typename C::allocator_type>> : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type, typename C::key_compare, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename, typename, typename, typename> class T>
+        struct IsConvertibleToSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> : std::is_convertible<C, T<typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename, typename, typename, typename, typename> class T>
+        struct IsConvertibleToSpecializationImpl<
+            C,
+            T,
+            absl::void_t<typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>> : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type>>
+        {
+        };
+        template<typename C, template<typename...> class T>
+        using IsConvertibleToSpecialization =
+            IsConvertibleToSpecializationImpl<absl::decay_t<C>, T>;
+
+        template<typename C>
+        struct IsConvertibleToArrayImpl : std::false_type
+        {
+        };
+        template<template<typename, size_t> class A, typename T, size_t N>
+        struct IsConvertibleToArrayImpl<A<T, N>> : std::is_convertible<A<T, N>, std::array<T, N>>
+        {
+        };
+        template<typename C>
+        using IsConvertibleToArray = IsConvertibleToArrayImpl<absl::decay_t<C>>;
+
+        template<typename C>
+        struct IsConvertibleToBitsetImpl : std::false_type
+        {
+        };
+        template<template<size_t> class B, size_t N>
+        struct IsConvertibleToBitsetImpl<B<N>> : std::is_convertible<B<N>, std::bitset<N>>
+        {
+        };
+        template<typename C>
+        using IsConvertibleToBitset = IsConvertibleToBitsetImpl<absl::decay_t<C>>;
+
+        template<typename C>
+        struct IsConvertibleToSTLContainer : absl::disjunction<IsConvertibleToArray<C>, IsConvertibleToBitset<C>, IsConvertibleToSpecialization<C, std::deque>, IsConvertibleToSpecialization<C, std::forward_list>, IsConvertibleToSpecialization<C, std::list>, IsConvertibleToSpecialization<C, std::map>, IsConvertibleToSpecialization<C, std::multimap>, IsConvertibleToSpecialization<C, std::set>, IsConvertibleToSpecialization<C, std::multiset>, IsConvertibleToSpecialization<C, std::unordered_map>, IsConvertibleToSpecialization<C, std::unordered_multimap>, IsConvertibleToSpecialization<C, std::unordered_set>, IsConvertibleToSpecialization<C, std::unordered_multiset>, IsConvertibleToSpecialization<C, std::vector>>
+        {
+        };
+
+        template<typename C>
+        struct IsStrictlyBaseOfAndConvertibleToSTLContainer : absl::conjunction<absl::negation<IsSTLContainer<C>>, IsBaseOfSTLContainer<C>, IsConvertibleToSTLContainer<C>>
+        {
+        };
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/arg.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/arg.h
index b9dda90..8d02587 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/arg.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/arg.h
@@ -32,495 +32,512 @@
 #include "absl/strings/internal/str_format/extension.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class Cord;
-class FormatCountCapture;
-class FormatSink;
-
-template <absl::FormatConversionCharSet C>
-struct FormatConvertResult;
-class FormatConversionSpec;
-
-namespace str_format_internal {
-
-template <typename T, typename = void>
-struct HasUserDefinedConvert : std::false_type {};
-
-template <typename T>
-struct HasUserDefinedConvert<T, void_t<decltype(AbslFormatConvert(
-                                    std::declval<const T&>(),
-                                    std::declval<const FormatConversionSpec&>(),
-                                    std::declval<FormatSink*>()))>>
-    : std::true_type {};
-
-void AbslFormatConvert();  // Stops the lexical name lookup
-template <typename T>
-auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv,
-                       FormatSinkImpl* sink)
-    -> decltype(AbslFormatConvert(v,
-                                  std::declval<const FormatConversionSpec&>(),
-                                  std::declval<FormatSink*>())) {
-  using FormatConversionSpecT =
-      absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatConversionSpec>;
-  using FormatSinkT =
-      absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
-  auto fcs = conv.Wrap<FormatConversionSpecT>();
-  auto fs = sink->Wrap<FormatSinkT>();
-  return AbslFormatConvert(v, fcs, &fs);
-}
-
-template <typename T>
-class StreamedWrapper;
-
-// If 'v' can be converted (in the printf sense) according to 'conv',
-// then convert it, appending to `sink` and return `true`.
-// Otherwise fail and return `false`.
-
-// AbslFormatConvert(v, conv, sink) is intended to be found by ADL on 'v'
-// as an extension mechanism. These FormatConvertImpl functions are the default
-// implementations.
-// The ADL search is augmented via the 'Sink*' parameter, which also
-// serves as a disambiguator to reject possible unintended 'AbslFormatConvert'
-// functions in the namespaces associated with 'v'.
-
-// Raw pointers.
-struct VoidPtr {
-  VoidPtr() = default;
-  template <typename T,
-            decltype(reinterpret_cast<uintptr_t>(std::declval<T*>())) = 0>
-  VoidPtr(T* ptr)  // NOLINT
-      : value(ptr ? reinterpret_cast<uintptr_t>(ptr) : 0) {}
-  uintptr_t value;
-};
-
-template <FormatConversionCharSet C>
-struct ArgConvertResult {
-  bool value;
-};
-
-template <FormatConversionCharSet C>
-constexpr FormatConversionCharSet ExtractCharSet(FormatConvertResult<C>) {
-  return C;
-}
-
-template <FormatConversionCharSet C>
-constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
-  return C;
-}
-
-using StringConvertResult =
-    ArgConvertResult<FormatConversionCharSetInternal::s>;
-ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
-    VoidPtr v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
-
-// Strings.
-StringConvertResult FormatConvertImpl(const std::string& v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl* sink);
-StringConvertResult FormatConvertImpl(string_view v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl* sink);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class Cord;
+    class FormatCountCapture;
+    class FormatSink;
+
+    template<absl::FormatConversionCharSet C>
+    struct FormatConvertResult;
+    class FormatConversionSpec;
+
+    namespace str_format_internal
+    {
+
+        template<typename T, typename = void>
+        struct HasUserDefinedConvert : std::false_type
+        {
+        };
+
+        template<typename T>
+        struct HasUserDefinedConvert<T, void_t<decltype(AbslFormatConvert(std::declval<const T&>(), std::declval<const FormatConversionSpec&>(), std::declval<FormatSink*>()))>> : std::true_type
+        {
+        };
+
+        void AbslFormatConvert();  // Stops the lexical name lookup
+        template<typename T>
+        auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv, FormatSinkImpl* sink)
+            -> decltype(AbslFormatConvert(v, std::declval<const FormatConversionSpec&>(), std::declval<FormatSink*>()))
+        {
+            using FormatConversionSpecT =
+                absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatConversionSpec>;
+            using FormatSinkT =
+                absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
+            auto fcs = conv.Wrap<FormatConversionSpecT>();
+            auto fs = sink->Wrap<FormatSinkT>();
+            return AbslFormatConvert(v, fcs, &fs);
+        }
+
+        template<typename T>
+        class StreamedWrapper;
+
+        // If 'v' can be converted (in the printf sense) according to 'conv',
+        // then convert it, appending to `sink` and return `true`.
+        // Otherwise fail and return `false`.
+
+        // AbslFormatConvert(v, conv, sink) is intended to be found by ADL on 'v'
+        // as an extension mechanism. These FormatConvertImpl functions are the default
+        // implementations.
+        // The ADL search is augmented via the 'Sink*' parameter, which also
+        // serves as a disambiguator to reject possible unintended 'AbslFormatConvert'
+        // functions in the namespaces associated with 'v'.
+
+        // Raw pointers.
+        struct VoidPtr
+        {
+            VoidPtr() = default;
+            template<typename T,
+                     decltype(reinterpret_cast<uintptr_t>(std::declval<T*>())) = 0>
+            VoidPtr(T* ptr)  // NOLINT
+                :
+                value(ptr ? reinterpret_cast<uintptr_t>(ptr) : 0)
+            {
+            }
+            uintptr_t value;
+        };
+
+        template<FormatConversionCharSet C>
+        struct ArgConvertResult
+        {
+            bool value;
+        };
+
+        template<FormatConversionCharSet C>
+        constexpr FormatConversionCharSet ExtractCharSet(FormatConvertResult<C>)
+        {
+            return C;
+        }
+
+        template<FormatConversionCharSet C>
+        constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>)
+        {
+            return C;
+        }
+
+        using StringConvertResult =
+            ArgConvertResult<FormatConversionCharSetInternal::s>;
+        ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
+            VoidPtr v, FormatConversionSpecImpl conv, FormatSinkImpl* sink
+        );
+
+        // Strings.
+        StringConvertResult FormatConvertImpl(const std::string& v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        StringConvertResult FormatConvertImpl(string_view v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
 #if defined(ABSL_HAVE_STD_STRING_VIEW) && !defined(ABSL_USES_STD_STRING_VIEW)
-inline StringConvertResult FormatConvertImpl(std::string_view v,
-                                             FormatConversionSpecImpl conv,
-                                             FormatSinkImpl* sink) {
-  return FormatConvertImpl(absl::string_view(v.data(), v.size()), conv, sink);
-}
+        inline StringConvertResult FormatConvertImpl(std::string_view v, FormatConversionSpecImpl conv, FormatSinkImpl* sink)
+        {
+            return FormatConvertImpl(absl::string_view(v.data(), v.size()), conv, sink);
+        }
 #endif  // ABSL_HAVE_STD_STRING_VIEW && !ABSL_USES_STD_STRING_VIEW
 
-ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>
-FormatConvertImpl(const char* v, const FormatConversionSpecImpl conv,
-                  FormatSinkImpl* sink);
-
-template <class AbslCord, typename std::enable_if<std::is_same<
-                              AbslCord, absl::Cord>::value>::type* = nullptr>
-StringConvertResult FormatConvertImpl(const AbslCord& value,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl* sink) {
-  bool is_left = conv.has_left_flag();
-  size_t space_remaining = 0;
-
-  int width = conv.width();
-  if (width >= 0) space_remaining = static_cast<size_t>(width);
-
-  size_t to_write = value.size();
-
-  int precision = conv.precision();
-  if (precision >= 0)
-    to_write = (std::min)(to_write, static_cast<size_t>(precision));
-
-  space_remaining = Excess(to_write, space_remaining);
-
-  if (space_remaining > 0 && !is_left) sink->Append(space_remaining, ' ');
-
-  for (string_view piece : value.Chunks()) {
-    if (piece.size() > to_write) {
-      piece.remove_suffix(piece.size() - to_write);
-      to_write = 0;
-    } else {
-      to_write -= piece.size();
-    }
-    sink->Append(piece);
-    if (to_write == 0) {
-      break;
-    }
-  }
-
-  if (space_remaining > 0 && is_left) sink->Append(space_remaining, ' ');
-  return {true};
-}
-
-using IntegralConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::c,
-    FormatConversionCharSetInternal::kNumeric,
-    FormatConversionCharSetInternal::kStar)>;
-using FloatingConvertResult =
-    ArgConvertResult<FormatConversionCharSetInternal::kFloating>;
-
-// Floats.
-FloatingConvertResult FormatConvertImpl(float v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-FloatingConvertResult FormatConvertImpl(double v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-FloatingConvertResult FormatConvertImpl(long double v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-
-// Chars.
-IntegralConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(signed char v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(unsigned char v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-
-// Ints.
-IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(int v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(unsigned v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(long v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(int128 v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(uint128 v,
-                                        FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink);
-template <typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0>
-IntegralConvertResult FormatConvertImpl(T v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink) {
-  return FormatConvertImpl(static_cast<int>(v), conv, sink);
-}
-
-// We provide this function to help the checker, but it is never defined.
-// FormatArgImpl will use the underlying Convert functions instead.
-template <typename T>
-typename std::enable_if<std::is_enum<T>::value &&
-                            !HasUserDefinedConvert<T>::value,
-                        IntegralConvertResult>::type
-FormatConvertImpl(T v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
-
-template <typename T>
-StringConvertResult FormatConvertImpl(const StreamedWrapper<T>& v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl* out) {
-  std::ostringstream oss;
-  oss << v.v_;
-  if (!oss) return {false};
-  return str_format_internal::FormatConvertImpl(oss.str(), conv, out);
-}
-
-// Use templates and dependent types to delay evaluation of the function
-// until after FormatCountCapture is fully defined.
-struct FormatCountCaptureHelper {
-  template <class T = int>
-  static ArgConvertResult<FormatConversionCharSetInternal::n> ConvertHelper(
-      const FormatCountCapture& v, FormatConversionSpecImpl conv,
-      FormatSinkImpl* sink) {
-    const absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
-
-    if (conv.conversion_char() !=
-        str_format_internal::FormatConversionCharInternal::n) {
-      return {false};
-    }
-    *v2.p_ = static_cast<int>(sink->size());
-    return {true};
-  }
-};
-
-template <class T = int>
-ArgConvertResult<FormatConversionCharSetInternal::n> FormatConvertImpl(
-    const FormatCountCapture& v, FormatConversionSpecImpl conv,
-    FormatSinkImpl* sink) {
-  return FormatCountCaptureHelper::ConvertHelper(v, conv, sink);
-}
-
-// Helper friend struct to hide implementation details from the public API of
-// FormatArgImpl.
-struct FormatArgImplFriend {
-  template <typename Arg>
-  static bool ToInt(Arg arg, int* out) {
-    // A value initialized FormatConversionSpecImpl has a `none` conv, which
-    // tells the dispatcher to run the `int` conversion.
-    return arg.dispatcher_(arg.data_, {}, out);
-  }
-
-  template <typename Arg>
-  static bool Convert(Arg arg, FormatConversionSpecImpl conv,
-                      FormatSinkImpl* out) {
-    return arg.dispatcher_(arg.data_, conv, out);
-  }
-
-  template <typename Arg>
-  static typename Arg::Dispatcher GetVTablePtrForTest(Arg arg) {
-    return arg.dispatcher_;
-  }
-};
-
-template <typename Arg>
-constexpr FormatConversionCharSet ArgumentToConv() {
-  return absl::str_format_internal::ExtractCharSet(
-      decltype(str_format_internal::FormatConvertImpl(
-          std::declval<const Arg&>(),
-          std::declval<const FormatConversionSpecImpl&>(),
-          std::declval<FormatSinkImpl*>())){});
-}
-
-// A type-erased handle to a format argument.
-class FormatArgImpl {
- private:
-  enum { kInlinedSpace = 8 };
-
-  using VoidPtr = str_format_internal::VoidPtr;
-
-  union Data {
-    const void* ptr;
-    const volatile void* volatile_ptr;
-    char buf[kInlinedSpace];
-  };
-
-  using Dispatcher = bool (*)(Data, FormatConversionSpecImpl, void* out);
-
-  template <typename T>
-  struct store_by_value
-      : std::integral_constant<bool, (sizeof(T) <= kInlinedSpace) &&
-                                         (std::is_integral<T>::value ||
-                                          std::is_floating_point<T>::value ||
-                                          std::is_pointer<T>::value ||
-                                          std::is_same<VoidPtr, T>::value)> {};
-
-  enum StoragePolicy { ByPointer, ByVolatilePointer, ByValue };
-  template <typename T>
-  struct storage_policy
-      : std::integral_constant<StoragePolicy,
-                               (std::is_volatile<T>::value
-                                    ? ByVolatilePointer
-                                    : (store_by_value<T>::value ? ByValue
-                                                                : ByPointer))> {
-  };
-
-  // To reduce the number of vtables we will decay values before hand.
-  // Anything with a user-defined Convert will get its own vtable.
-  // For everything else:
-  //   - Decay char* and char arrays into `const char*`
-  //   - Decay any other pointer to `const void*`
-  //   - Decay all enums to their underlying type.
-  //   - Decay function pointers to void*.
-  template <typename T, typename = void>
-  struct DecayType {
-    static constexpr bool kHasUserDefined =
-        str_format_internal::HasUserDefinedConvert<T>::value;
-    using type = typename std::conditional<
-        !kHasUserDefined && std::is_convertible<T, const char*>::value,
-        const char*,
-        typename std::conditional<!kHasUserDefined &&
-                                      std::is_convertible<T, VoidPtr>::value,
-                                  VoidPtr, const T&>::type>::type;
-  };
-  template <typename T>
-  struct DecayType<T,
-                   typename std::enable_if<
-                       !str_format_internal::HasUserDefinedConvert<T>::value &&
-                       std::is_enum<T>::value>::type> {
-    using type = typename std::underlying_type<T>::type;
-  };
-
- public:
-  template <typename T>
-  explicit FormatArgImpl(const T& value) {
-    using D = typename DecayType<T>::type;
-    static_assert(
-        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
-        "Decayed types must be stored by value");
-    Init(static_cast<D>(value));
-  }
-
- private:
-  friend struct str_format_internal::FormatArgImplFriend;
-  template <typename T, StoragePolicy = storage_policy<T>::value>
-  struct Manager;
-
-  template <typename T>
-  struct Manager<T, ByPointer> {
-    static Data SetValue(const T& value) {
-      Data data;
-      data.ptr = std::addressof(value);
-      return data;
-    }
-
-    static const T& Value(Data arg) { return *static_cast<const T*>(arg.ptr); }
-  };
-
-  template <typename T>
-  struct Manager<T, ByVolatilePointer> {
-    static Data SetValue(const T& value) {
-      Data data;
-      data.volatile_ptr = &value;
-      return data;
-    }
-
-    static const T& Value(Data arg) {
-      return *static_cast<const T*>(arg.volatile_ptr);
-    }
-  };
-
-  template <typename T>
-  struct Manager<T, ByValue> {
-    static Data SetValue(const T& value) {
-      Data data;
-      memcpy(data.buf, &value, sizeof(value));
-      return data;
-    }
-
-    static T Value(Data arg) {
-      T value;
-      memcpy(&value, arg.buf, sizeof(T));
-      return value;
-    }
-  };
-
-  template <typename T>
-  void Init(const T& value) {
-    data_ = Manager<T>::SetValue(value);
-    dispatcher_ = &Dispatch<T>;
-  }
-
-  template <typename T>
-  static int ToIntVal(const T& val) {
-    using CommonType = typename std::conditional<std::is_signed<T>::value,
-                                                 int64_t, uint64_t>::type;
-    if (static_cast<CommonType>(val) >
-        static_cast<CommonType>((std::numeric_limits<int>::max)())) {
-      return (std::numeric_limits<int>::max)();
-    } else if (std::is_signed<T>::value &&
-               static_cast<CommonType>(val) <
-                   static_cast<CommonType>((std::numeric_limits<int>::min)())) {
-      return (std::numeric_limits<int>::min)();
-    }
-    return static_cast<int>(val);
-  }
-
-  template <typename T>
-  static bool ToInt(Data arg, int* out, std::true_type /* is_integral */,
-                    std::false_type) {
-    *out = ToIntVal(Manager<T>::Value(arg));
-    return true;
-  }
-
-  template <typename T>
-  static bool ToInt(Data arg, int* out, std::false_type,
-                    std::true_type /* is_enum */) {
-    *out = ToIntVal(static_cast<typename std::underlying_type<T>::type>(
-        Manager<T>::Value(arg)));
-    return true;
-  }
-
-  template <typename T>
-  static bool ToInt(Data, int*, std::false_type, std::false_type) {
-    return false;
-  }
-
-  template <typename T>
-  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
-    // A `none` conv indicates that we want the `int` conversion.
-    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
-                           FormatConversionCharInternal::kNone)) {
-      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
-                      std::is_enum<T>());
-    }
-    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
-                                     spec.conversion_char()))) {
-      return false;
-    }
-    return str_format_internal::FormatConvertImpl(
-               Manager<T>::Value(arg), spec,
-               static_cast<FormatSinkImpl*>(out))
-        .value;
-  }
-
-  Data data_;
-  Dispatcher dispatcher_;
-};
-
-#define ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E)                     \
-  E template bool FormatArgImpl::Dispatch<T>(Data, FormatConversionSpecImpl, \
-                                             void*)
-
-#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr,     \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(bool, __VA_ARGS__);               \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(char, __VA_ARGS__);               \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(signed char, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned char, __VA_ARGS__);      \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(short, __VA_ARGS__); /* NOLINT */ \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned short,      /* NOLINT */ \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int, __VA_ARGS__);                \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned int, __VA_ARGS__);       \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long, __VA_ARGS__); /* NOLINT */  \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long,      /* NOLINT */  \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long long, /* NOLINT */           \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */  \
-                                             __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__);             \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__);            \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__);              \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__);             \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char*, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(std::string, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__)
-
-ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
-
-
-}  // namespace str_format_internal
-ABSL_NAMESPACE_END
+        ArgConvertResult<FormatConversionCharSetUnion(
+            FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p
+        )>
+            FormatConvertImpl(const char* v, const FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+
+        template<class AbslCord, typename std::enable_if<std::is_same<AbslCord, absl::Cord>::value>::type* = nullptr>
+        StringConvertResult FormatConvertImpl(const AbslCord& value, FormatConversionSpecImpl conv, FormatSinkImpl* sink)
+        {
+            bool is_left = conv.has_left_flag();
+            size_t space_remaining = 0;
+
+            int width = conv.width();
+            if (width >= 0)
+                space_remaining = static_cast<size_t>(width);
+
+            size_t to_write = value.size();
+
+            int precision = conv.precision();
+            if (precision >= 0)
+                to_write = (std::min)(to_write, static_cast<size_t>(precision));
+
+            space_remaining = Excess(to_write, space_remaining);
+
+            if (space_remaining > 0 && !is_left)
+                sink->Append(space_remaining, ' ');
+
+            for (string_view piece : value.Chunks())
+            {
+                if (piece.size() > to_write)
+                {
+                    piece.remove_suffix(piece.size() - to_write);
+                    to_write = 0;
+                }
+                else
+                {
+                    to_write -= piece.size();
+                }
+                sink->Append(piece);
+                if (to_write == 0)
+                {
+                    break;
+                }
+            }
+
+            if (space_remaining > 0 && is_left)
+                sink->Append(space_remaining, ' ');
+            return {true};
+        }
+
+        using IntegralConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
+            FormatConversionCharSetInternal::c,
+            FormatConversionCharSetInternal::kNumeric,
+            FormatConversionCharSetInternal::kStar
+        )>;
+        using FloatingConvertResult =
+            ArgConvertResult<FormatConversionCharSetInternal::kFloating>;
+
+        // Floats.
+        FloatingConvertResult FormatConvertImpl(float v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        FloatingConvertResult FormatConvertImpl(double v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        FloatingConvertResult FormatConvertImpl(long double v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+
+        // Chars.
+        IntegralConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(signed char v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(unsigned char v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+
+        // Ints.
+        IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
+                                                FormatConversionSpecImpl conv,
+                                                FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT
+                                                FormatConversionSpecImpl conv,
+                                                FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(int v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(unsigned v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(long v,  // NOLINT
+                                                FormatConversionSpecImpl conv,
+                                                FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT
+                                                FormatConversionSpecImpl conv,
+                                                FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT
+                                                FormatConversionSpecImpl conv,
+                                                FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT
+                                                FormatConversionSpecImpl conv,
+                                                FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(int128 v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        IntegralConvertResult FormatConvertImpl(uint128 v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+        template<typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0>
+        IntegralConvertResult FormatConvertImpl(T v, FormatConversionSpecImpl conv, FormatSinkImpl* sink)
+        {
+            return FormatConvertImpl(static_cast<int>(v), conv, sink);
+        }
+
+        // We provide this function to help the checker, but it is never defined.
+        // FormatArgImpl will use the underlying Convert functions instead.
+        template<typename T>
+        typename std::enable_if<std::is_enum<T>::value && !HasUserDefinedConvert<T>::value, IntegralConvertResult>::type
+            FormatConvertImpl(T v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+
+        template<typename T>
+        StringConvertResult FormatConvertImpl(const StreamedWrapper<T>& v, FormatConversionSpecImpl conv, FormatSinkImpl* out)
+        {
+            std::ostringstream oss;
+            oss << v.v_;
+            if (!oss)
+                return {false};
+            return str_format_internal::FormatConvertImpl(oss.str(), conv, out);
+        }
+
+        // Use templates and dependent types to delay evaluation of the function
+        // until after FormatCountCapture is fully defined.
+        struct FormatCountCaptureHelper
+        {
+            template<class T = int>
+            static ArgConvertResult<FormatConversionCharSetInternal::n> ConvertHelper(
+                const FormatCountCapture& v, FormatConversionSpecImpl conv, FormatSinkImpl* sink
+            )
+            {
+                const absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
+
+                if (conv.conversion_char() !=
+                    str_format_internal::FormatConversionCharInternal::n)
+                {
+                    return {false};
+                }
+                *v2.p_ = static_cast<int>(sink->size());
+                return {true};
+            }
+        };
+
+        template<class T = int>
+        ArgConvertResult<FormatConversionCharSetInternal::n> FormatConvertImpl(
+            const FormatCountCapture& v, FormatConversionSpecImpl conv, FormatSinkImpl* sink
+        )
+        {
+            return FormatCountCaptureHelper::ConvertHelper(v, conv, sink);
+        }
+
+        // Helper friend struct to hide implementation details from the public API of
+        // FormatArgImpl.
+        struct FormatArgImplFriend
+        {
+            template<typename Arg>
+            static bool ToInt(Arg arg, int* out)
+            {
+                // A value initialized FormatConversionSpecImpl has a `none` conv, which
+                // tells the dispatcher to run the `int` conversion.
+                return arg.dispatcher_(arg.data_, {}, out);
+            }
+
+            template<typename Arg>
+            static bool Convert(Arg arg, FormatConversionSpecImpl conv, FormatSinkImpl* out)
+            {
+                return arg.dispatcher_(arg.data_, conv, out);
+            }
+
+            template<typename Arg>
+            static typename Arg::Dispatcher GetVTablePtrForTest(Arg arg)
+            {
+                return arg.dispatcher_;
+            }
+        };
+
+        template<typename Arg>
+        constexpr FormatConversionCharSet ArgumentToConv()
+        {
+            return absl::str_format_internal::ExtractCharSet(
+                decltype(str_format_internal::FormatConvertImpl(
+                    std::declval<const Arg&>(),
+                    std::declval<const FormatConversionSpecImpl&>(),
+                    std::declval<FormatSinkImpl*>()
+                )){}
+            );
+        }
+
+        // A type-erased handle to a format argument.
+        class FormatArgImpl
+        {
+        private:
+            enum
+            {
+                kInlinedSpace = 8
+            };
+
+            using VoidPtr = str_format_internal::VoidPtr;
+
+            union Data
+            {
+                const void* ptr;
+                const volatile void* volatile_ptr;
+                char buf[kInlinedSpace];
+            };
+
+            using Dispatcher = bool (*)(Data, FormatConversionSpecImpl, void* out);
+
+            template<typename T>
+            struct store_by_value : std::integral_constant<bool, (sizeof(T) <= kInlinedSpace) && (std::is_integral<T>::value || std::is_floating_point<T>::value || std::is_pointer<T>::value || std::is_same<VoidPtr, T>::value)>
+            {
+            };
+
+            enum StoragePolicy
+            {
+                ByPointer,
+                ByVolatilePointer,
+                ByValue
+            };
+            template<typename T>
+            struct storage_policy : std::integral_constant<StoragePolicy, (std::is_volatile<T>::value ? ByVolatilePointer : (store_by_value<T>::value ? ByValue : ByPointer))>
+            {
+            };
+
+            // To reduce the number of vtables we will decay values before hand.
+            // Anything with a user-defined Convert will get its own vtable.
+            // For everything else:
+            //   - Decay char* and char arrays into `const char*`
+            //   - Decay any other pointer to `const void*`
+            //   - Decay all enums to their underlying type.
+            //   - Decay function pointers to void*.
+            template<typename T, typename = void>
+            struct DecayType
+            {
+                static constexpr bool kHasUserDefined =
+                    str_format_internal::HasUserDefinedConvert<T>::value;
+                using type = typename std::conditional<
+                    !kHasUserDefined && std::is_convertible<T, const char*>::value,
+                    const char*,
+                    typename std::conditional<!kHasUserDefined && std::is_convertible<T, VoidPtr>::value, VoidPtr, const T&>::type>::type;
+            };
+            template<typename T>
+            struct DecayType<T, typename std::enable_if<!str_format_internal::HasUserDefinedConvert<T>::value && std::is_enum<T>::value>::type>
+            {
+                using type = typename std::underlying_type<T>::type;
+            };
+
+        public:
+            template<typename T>
+            explicit FormatArgImpl(const T& value)
+            {
+                using D = typename DecayType<T>::type;
+                static_assert(
+                    std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
+                    "Decayed types must be stored by value"
+                );
+                Init(static_cast<D>(value));
+            }
+
+        private:
+            friend struct str_format_internal::FormatArgImplFriend;
+            template<typename T, StoragePolicy = storage_policy<T>::value>
+            struct Manager;
+
+            template<typename T>
+            struct Manager<T, ByPointer>
+            {
+                static Data SetValue(const T& value)
+                {
+                    Data data;
+                    data.ptr = std::addressof(value);
+                    return data;
+                }
+
+                static const T& Value(Data arg)
+                {
+                    return *static_cast<const T*>(arg.ptr);
+                }
+            };
+
+            template<typename T>
+            struct Manager<T, ByVolatilePointer>
+            {
+                static Data SetValue(const T& value)
+                {
+                    Data data;
+                    data.volatile_ptr = &value;
+                    return data;
+                }
+
+                static const T& Value(Data arg)
+                {
+                    return *static_cast<const T*>(arg.volatile_ptr);
+                }
+            };
+
+            template<typename T>
+            struct Manager<T, ByValue>
+            {
+                static Data SetValue(const T& value)
+                {
+                    Data data;
+                    memcpy(data.buf, &value, sizeof(value));
+                    return data;
+                }
+
+                static T Value(Data arg)
+                {
+                    T value;
+                    memcpy(&value, arg.buf, sizeof(T));
+                    return value;
+                }
+            };
+
+            template<typename T>
+            void Init(const T& value)
+            {
+                data_ = Manager<T>::SetValue(value);
+                dispatcher_ = &Dispatch<T>;
+            }
+
+            template<typename T>
+            static int ToIntVal(const T& val)
+            {
+                using CommonType = typename std::conditional<std::is_signed<T>::value, int64_t, uint64_t>::type;
+                if (static_cast<CommonType>(val) >
+                    static_cast<CommonType>((std::numeric_limits<int>::max)()))
+                {
+                    return (std::numeric_limits<int>::max)();
+                }
+                else if (std::is_signed<T>::value && static_cast<CommonType>(val) < static_cast<CommonType>((std::numeric_limits<int>::min)()))
+                {
+                    return (std::numeric_limits<int>::min)();
+                }
+                return static_cast<int>(val);
+            }
+
+            template<typename T>
+            static bool ToInt(Data arg, int* out, std::true_type /* is_integral */, std::false_type)
+            {
+                *out = ToIntVal(Manager<T>::Value(arg));
+                return true;
+            }
+
+            template<typename T>
+            static bool ToInt(Data arg, int* out, std::false_type, std::true_type /* is_enum */)
+            {
+                *out = ToIntVal(static_cast<typename std::underlying_type<T>::type>(
+                    Manager<T>::Value(arg)
+                ));
+                return true;
+            }
+
+            template<typename T>
+            static bool ToInt(Data, int*, std::false_type, std::false_type)
+            {
+                return false;
+            }
+
+            template<typename T>
+            static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out)
+            {
+                // A `none` conv indicates that we want the `int` conversion.
+                if (ABSL_PREDICT_FALSE(spec.conversion_char() == FormatConversionCharInternal::kNone))
+                {
+                    return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(), std::is_enum<T>());
+                }
+                if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(), spec.conversion_char())))
+                {
+                    return false;
+                }
+                return str_format_internal::FormatConvertImpl(
+                           Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out)
+                )
+                    .value;
+            }
+
+            Data data_;
+            Dispatcher dispatcher_;
+        };
+
+#define ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E) \
+    E template bool FormatArgImpl::Dispatch<T>(Data, FormatConversionSpecImpl, void*)
+
+#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                               \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr, __VA_ARGS__); \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(bool, __VA_ARGS__);                         \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(char, __VA_ARGS__);                         \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(signed char, __VA_ARGS__);                  \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned char, __VA_ARGS__);                \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(short, __VA_ARGS__); /* NOLINT */           \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned short,      /* NOLINT */           \
+                                               __VA_ARGS__);                               \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int, __VA_ARGS__);                          \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned int, __VA_ARGS__);                 \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long, __VA_ARGS__); /* NOLINT */            \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long,      /* NOLINT */            \
+                                               __VA_ARGS__);                               \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long long, /* NOLINT */                     \
+                                               __VA_ARGS__);                               \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */            \
+                                               __VA_ARGS__);                               \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__);                       \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__);                      \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__);                        \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__);                       \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__);                  \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char*, __VA_ARGS__);                  \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(std::string, __VA_ARGS__);                  \
+    ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__)
+
+        ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
+
+    }  // namespace str_format_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/bind.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/bind.h
index 80f2965..5f56cb9 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/bind.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/bind.h
@@ -27,222 +27,264 @@
 #include "absl/types/span.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class UntypedFormatSpec;
-
-namespace str_format_internal {
-
-class BoundConversion : public FormatConversionSpecImpl {
- public:
-  const FormatArgImpl* arg() const { return arg_; }
-  void set_arg(const FormatArgImpl* a) { arg_ = a; }
-
- private:
-  const FormatArgImpl* arg_;
-};
-
-// This is the type-erased class that the implementation uses.
-class UntypedFormatSpecImpl {
- public:
-  UntypedFormatSpecImpl() = delete;
-
-  explicit UntypedFormatSpecImpl(string_view s)
-      : data_(s.data()), size_(s.size()) {}
-  explicit UntypedFormatSpecImpl(
-      const str_format_internal::ParsedFormatBase* pc)
-      : data_(pc), size_(~size_t{}) {}
-
-  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
-
-  string_view str() const {
-    assert(!has_parsed_conversion());
-    return string_view(static_cast<const char*>(data_), size_);
-  }
-  const str_format_internal::ParsedFormatBase* parsed_conversion() const {
-    assert(has_parsed_conversion());
-    return static_cast<const str_format_internal::ParsedFormatBase*>(data_);
-  }
-
-  template <typename T>
-  static const UntypedFormatSpecImpl& Extract(const T& s) {
-    return s.spec_;
-  }
-
- private:
-  const void* data_;
-  size_t size_;
-};
-
-template <typename T, FormatConversionCharSet...>
-struct MakeDependent {
-  using type = T;
-};
-
-// Implicitly convertible from `const char*`, `string_view`, and the
-// `ExtendedParsedFormat` type. This abstraction allows all format functions to
-// operate on any without providing too many overloads.
-template <FormatConversionCharSet... Args>
-class FormatSpecTemplate
-    : public MakeDependent<UntypedFormatSpec, Args...>::type {
-  using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type;
-
-  template <bool res>
-  struct ErrorMaker {
-    constexpr bool operator()(int) const { return res; }
-  };
-
-  template <int i, int j>
-  static constexpr bool CheckArity(ErrorMaker<true> SpecifierCount = {},
-                                   ErrorMaker<i == j> ParametersPassed = {}) {
-    static_assert(SpecifierCount(i) == ParametersPassed(j),
-                  "Number of arguments passed must match the number of "
-                  "conversion specifiers.");
-    return true;
-  }
-
-  template <FormatConversionCharSet specified, FormatConversionCharSet passed,
-            int arg>
-  static constexpr bool CheckMatch(
-      ErrorMaker<Contains(specified, passed)> MismatchedArgumentNumber = {}) {
-    static_assert(MismatchedArgumentNumber(arg),
-                  "Passed argument must match specified format.");
-    return true;
-  }
-
-  template <FormatConversionCharSet... C, size_t... I>
-  static bool CheckMatches(absl::index_sequence<I...>) {
-    bool res[] = {true, CheckMatch<Args, C, I + 1>()...};
-    (void)res;
-    return true;
-  }
-
- public:
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class UntypedFormatSpec;
+
+    namespace str_format_internal
+    {
+
+        class BoundConversion : public FormatConversionSpecImpl
+        {
+        public:
+            const FormatArgImpl* arg() const
+            {
+                return arg_;
+            }
+            void set_arg(const FormatArgImpl* a)
+            {
+                arg_ = a;
+            }
+
+        private:
+            const FormatArgImpl* arg_;
+        };
+
+        // This is the type-erased class that the implementation uses.
+        class UntypedFormatSpecImpl
+        {
+        public:
+            UntypedFormatSpecImpl() = delete;
+
+            explicit UntypedFormatSpecImpl(string_view s) :
+                data_(s.data()),
+                size_(s.size())
+            {
+            }
+            explicit UntypedFormatSpecImpl(
+                const str_format_internal::ParsedFormatBase* pc
+            ) :
+                data_(pc),
+                size_(~size_t{})
+            {
+            }
+
+            bool has_parsed_conversion() const
+            {
+                return size_ == ~size_t{};
+            }
+
+            string_view str() const
+            {
+                assert(!has_parsed_conversion());
+                return string_view(static_cast<const char*>(data_), size_);
+            }
+            const str_format_internal::ParsedFormatBase* parsed_conversion() const
+            {
+                assert(has_parsed_conversion());
+                return static_cast<const str_format_internal::ParsedFormatBase*>(data_);
+            }
+
+            template<typename T>
+            static const UntypedFormatSpecImpl& Extract(const T& s)
+            {
+                return s.spec_;
+            }
+
+        private:
+            const void* data_;
+            size_t size_;
+        };
+
+        template<typename T, FormatConversionCharSet...>
+        struct MakeDependent
+        {
+            using type = T;
+        };
+
+        // Implicitly convertible from `const char*`, `string_view`, and the
+        // `ExtendedParsedFormat` type. This abstraction allows all format functions to
+        // operate on any without providing too many overloads.
+        template<FormatConversionCharSet... Args>
+        class FormatSpecTemplate : public MakeDependent<UntypedFormatSpec, Args...>::type
+        {
+            using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type;
+
+            template<bool res>
+            struct ErrorMaker
+            {
+                constexpr bool operator()(int) const
+                {
+                    return res;
+                }
+            };
+
+            template<int i, int j>
+            static constexpr bool CheckArity(ErrorMaker<true> SpecifierCount = {}, ErrorMaker<i == j> ParametersPassed = {})
+            {
+                static_assert(SpecifierCount(i) == ParametersPassed(j), "Number of arguments passed must match the number of "
+                                                                        "conversion specifiers.");
+                return true;
+            }
+
+            template<FormatConversionCharSet specified, FormatConversionCharSet passed, int arg>
+            static constexpr bool CheckMatch(
+                ErrorMaker<Contains(specified, passed)> MismatchedArgumentNumber = {}
+            )
+            {
+                static_assert(MismatchedArgumentNumber(arg), "Passed argument must match specified format.");
+                return true;
+            }
+
+            template<FormatConversionCharSet... C, size_t... I>
+            static bool CheckMatches(absl::index_sequence<I...>)
+            {
+                bool res[] = {true, CheckMatch<Args, C, I + 1>()...};
+                (void)res;
+                return true;
+            }
+
+        public:
 #ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
-  // Honeypot overload for when the string is not constexpr.
-  // We use the 'unavailable' attribute to give a better compiler error than
-  // just 'method is deleted'.
-  FormatSpecTemplate(...)  // NOLINT
-      __attribute__((unavailable("Format string is not constexpr.")));
-
-  // Honeypot overload for when the format is constexpr and invalid.
-  // We use the 'unavailable' attribute to give a better compiler error than
-  // just 'method is deleted'.
-  // To avoid checking the format twice, we just check that the format is
-  // constexpr. If it is valid, then the overload below will kick in.
-  // We add the template here to make this overload have lower priority.
-  template <typename = void>
-  FormatSpecTemplate(const char* s)  // NOLINT
-      __attribute__((
-          enable_if(str_format_internal::EnsureConstexpr(s), "constexpr trap"),
-          unavailable(
-              "Format specified does not match the arguments passed.")));
-
-  template <typename T = void>
-  FormatSpecTemplate(string_view s)  // NOLINT
-      __attribute__((enable_if(str_format_internal::EnsureConstexpr(s),
-                               "constexpr trap")))
-      : Base("to avoid noise in the compiler error") {
-    static_assert(sizeof(T*) == 0,
-                  "Format specified does not match the arguments passed.");
-  }
-
-  // Good format overload.
-  FormatSpecTemplate(const char* s)  // NOLINT
-      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
-      : Base(s) {}
-
-  FormatSpecTemplate(string_view s)  // NOLINT
-      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
-      : Base(s) {}
+            // Honeypot overload for when the string is not constexpr.
+            // We use the 'unavailable' attribute to give a better compiler error than
+            // just 'method is deleted'.
+            FormatSpecTemplate(...)  // NOLINT
+                __attribute__((unavailable("Format string is not constexpr.")));
+
+            // Honeypot overload for when the format is constexpr and invalid.
+            // We use the 'unavailable' attribute to give a better compiler error than
+            // just 'method is deleted'.
+            // To avoid checking the format twice, we just check that the format is
+            // constexpr. If it is valid, then the overload below will kick in.
+            // We add the template here to make this overload have lower priority.
+            template<typename = void>
+            FormatSpecTemplate(const char* s)  // NOLINT
+                __attribute__((
+                    enable_if(str_format_internal::EnsureConstexpr(s), "constexpr trap"),
+                    unavailable(
+                        "Format specified does not match the arguments passed."
+                    )
+                ));
+
+            template<typename T = void>
+            FormatSpecTemplate(string_view s)  // NOLINT
+                __attribute__((enable_if(str_format_internal::EnsureConstexpr(s), "constexpr trap"))) :
+                Base("to avoid noise in the compiler error")
+            {
+                static_assert(sizeof(T*) == 0, "Format specified does not match the arguments passed.");
+            }
+
+            // Good format overload.
+            FormatSpecTemplate(const char* s)  // NOLINT
+                __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap"))) :
+                Base(s)
+            {
+            }
+
+            FormatSpecTemplate(string_view s)  // NOLINT
+                __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap"))) :
+                Base(s)
+            {
+            }
 
 #else  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
-  FormatSpecTemplate(const char* s) : Base(s) {}  // NOLINT
-  FormatSpecTemplate(string_view s) : Base(s) {}  // NOLINT
+            FormatSpecTemplate(const char* s) :
+                Base(s)
+            {
+            }  // NOLINT
+            FormatSpecTemplate(string_view s) :
+                Base(s)
+            {
+            }  // NOLINT
 
 #endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
-  template <FormatConversionCharSet... C>
-  FormatSpecTemplate(const ExtendedParsedFormat<C...>& pc)  // NOLINT
-      : Base(&pc) {
-    CheckArity<sizeof...(C), sizeof...(Args)>();
-    CheckMatches<C...>(absl::make_index_sequence<sizeof...(C)>{});
-  }
-};
-
-class Streamable {
- public:
-  Streamable(const UntypedFormatSpecImpl& format,
-             absl::Span<const FormatArgImpl> args)
-      : format_(format) {
-    if (args.size() <= ABSL_ARRAYSIZE(few_args_)) {
-      for (size_t i = 0; i < args.size(); ++i) {
-        few_args_[i] = args[i];
-      }
-      args_ = absl::MakeSpan(few_args_, args.size());
-    } else {
-      many_args_.assign(args.begin(), args.end());
-      args_ = many_args_;
-    }
-  }
-
-  std::ostream& Print(std::ostream& os) const;
-
-  friend std::ostream& operator<<(std::ostream& os, const Streamable& l) {
-    return l.Print(os);
-  }
-
- private:
-  const UntypedFormatSpecImpl& format_;
-  absl::Span<const FormatArgImpl> args_;
-  // if args_.size() is 4 or less:
-  FormatArgImpl few_args_[4] = {FormatArgImpl(0), FormatArgImpl(0),
-                                FormatArgImpl(0), FormatArgImpl(0)};
-  // if args_.size() is more than 4:
-  std::vector<FormatArgImpl> many_args_;
-};
-
-// for testing
-std::string Summarize(UntypedFormatSpecImpl format,
-                      absl::Span<const FormatArgImpl> args);
-bool BindWithPack(const UnboundConversion* props,
-                  absl::Span<const FormatArgImpl> pack, BoundConversion* bound);
-
-bool FormatUntyped(FormatRawSinkImpl raw_sink,
-                   UntypedFormatSpecImpl format,
-                   absl::Span<const FormatArgImpl> args);
-
-std::string& AppendPack(std::string* out, UntypedFormatSpecImpl format,
-                        absl::Span<const FormatArgImpl> args);
-
-std::string FormatPack(const UntypedFormatSpecImpl format,
-                       absl::Span<const FormatArgImpl> args);
-
-int FprintF(std::FILE* output, UntypedFormatSpecImpl format,
-            absl::Span<const FormatArgImpl> args);
-int SnprintF(char* output, size_t size, UntypedFormatSpecImpl format,
-             absl::Span<const FormatArgImpl> args);
-
-// Returned by Streamed(v). Converts via '%s' to the std::string created
-// by std::ostream << v.
-template <typename T>
-class StreamedWrapper {
- public:
-  explicit StreamedWrapper(const T& v) : v_(v) { }
-
- private:
-  template <typename S>
-  friend ArgConvertResult<FormatConversionCharSetInternal::s> FormatConvertImpl(
-      const StreamedWrapper<S>& v, FormatConversionSpecImpl conv,
-      FormatSinkImpl* out);
-  const T& v_;
-};
-
-}  // namespace str_format_internal
-ABSL_NAMESPACE_END
+            template<FormatConversionCharSet... C>
+            FormatSpecTemplate(const ExtendedParsedFormat<C...>& pc)  // NOLINT
+                :
+                Base(&pc)
+            {
+                CheckArity<sizeof...(C), sizeof...(Args)>();
+                CheckMatches<C...>(absl::make_index_sequence<sizeof...(C)>{});
+            }
+        };
+
+        class Streamable
+        {
+        public:
+            Streamable(const UntypedFormatSpecImpl& format, absl::Span<const FormatArgImpl> args) :
+                format_(format)
+            {
+                if (args.size() <= ABSL_ARRAYSIZE(few_args_))
+                {
+                    for (size_t i = 0; i < args.size(); ++i)
+                    {
+                        few_args_[i] = args[i];
+                    }
+                    args_ = absl::MakeSpan(few_args_, args.size());
+                }
+                else
+                {
+                    many_args_.assign(args.begin(), args.end());
+                    args_ = many_args_;
+                }
+            }
+
+            std::ostream& Print(std::ostream& os) const;
+
+            friend std::ostream& operator<<(std::ostream& os, const Streamable& l)
+            {
+                return l.Print(os);
+            }
+
+        private:
+            const UntypedFormatSpecImpl& format_;
+            absl::Span<const FormatArgImpl> args_;
+            // if args_.size() is 4 or less:
+            FormatArgImpl few_args_[4] = {FormatArgImpl(0), FormatArgImpl(0), FormatArgImpl(0), FormatArgImpl(0)};
+            // if args_.size() is more than 4:
+            std::vector<FormatArgImpl> many_args_;
+        };
+
+        // for testing
+        std::string Summarize(UntypedFormatSpecImpl format, absl::Span<const FormatArgImpl> args);
+        bool BindWithPack(const UnboundConversion* props, absl::Span<const FormatArgImpl> pack, BoundConversion* bound);
+
+        bool FormatUntyped(FormatRawSinkImpl raw_sink, UntypedFormatSpecImpl format, absl::Span<const FormatArgImpl> args);
+
+        std::string& AppendPack(std::string* out, UntypedFormatSpecImpl format, absl::Span<const FormatArgImpl> args);
+
+        std::string FormatPack(const UntypedFormatSpecImpl format, absl::Span<const FormatArgImpl> args);
+
+        int FprintF(std::FILE* output, UntypedFormatSpecImpl format, absl::Span<const FormatArgImpl> args);
+        int SnprintF(char* output, size_t size, UntypedFormatSpecImpl format, absl::Span<const FormatArgImpl> args);
+
+        // Returned by Streamed(v). Converts via '%s' to the std::string created
+        // by std::ostream << v.
+        template<typename T>
+        class StreamedWrapper
+        {
+        public:
+            explicit StreamedWrapper(const T& v) :
+                v_(v)
+            {
+            }
+
+        private:
+            template<typename S>
+            friend ArgConvertResult<FormatConversionCharSetInternal::s> FormatConvertImpl(
+                const StreamedWrapper<S>& v, FormatConversionSpecImpl conv, FormatSinkImpl* out
+            );
+            const T& v_;
+        };
+
+    }  // namespace str_format_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/checker.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/checker.h
index 4fd19d1..7551780 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/checker.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/checker.h
@@ -32,307 +32,332 @@
         // !defined(__INTELLISENSE__)
 #endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
-
-constexpr bool AllOf() { return true; }
-
-template <typename... T>
-constexpr bool AllOf(bool b, T... t) {
-  return b && AllOf(t...);
-}
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace str_format_internal
+    {
+
+        constexpr bool AllOf()
+        {
+            return true;
+        }
+
+        template<typename... T>
+        constexpr bool AllOf(bool b, T... t)
+        {
+            return b && AllOf(t...);
+        }
 
 #ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
-constexpr bool ContainsChar(const char* chars, char c) {
-  return *chars == c || (*chars && ContainsChar(chars + 1, c));
-}
-
-// A constexpr compatible list of Convs.
-struct ConvList {
-  const FormatConversionCharSet* array;
-  int count;
-
-  // We do the bound check here to avoid having to do it on the callers.
-  // Returning an empty FormatConversionCharSet has the same effect as
-  // short circuiting because it will never match any conversion.
-  constexpr FormatConversionCharSet operator[](int i) const {
-    return i < count ? array[i] : FormatConversionCharSet{};
-  }
-
-  constexpr ConvList without_front() const {
-    return count != 0 ? ConvList{array + 1, count - 1} : *this;
-  }
-};
-
-template <size_t count>
-struct ConvListT {
-  // Make sure the array has size > 0.
-  FormatConversionCharSet list[count ? count : 1];
-};
-
-constexpr char GetChar(string_view str, size_t index) {
-  return index < str.size() ? str[index] : char{};
-}
-
-constexpr string_view ConsumeFront(string_view str, size_t len = 1) {
-  return len <= str.size() ? string_view(str.data() + len, str.size() - len)
-                           : string_view();
-}
-
-constexpr string_view ConsumeAnyOf(string_view format, const char* chars) {
-  return ContainsChar(chars, GetChar(format, 0))
-             ? ConsumeAnyOf(ConsumeFront(format), chars)
-             : format;
-}
-
-constexpr bool IsDigit(char c) { return c >= '0' && c <= '9'; }
-
-// Helper class for the ParseDigits function.
-// It encapsulates the two return values we need there.
-struct Integer {
-  string_view format;
-  int value;
-
-  // If the next character is a '$', consume it.
-  // Otherwise, make `this` an invalid positional argument.
-  constexpr Integer ConsumePositionalDollar() const {
-    return GetChar(format, 0) == '$' ? Integer{ConsumeFront(format), value}
-                                     : Integer{format, 0};
-  }
-};
-
-constexpr Integer ParseDigits(string_view format, int value = 0) {
-  return IsDigit(GetChar(format, 0))
-             ? ParseDigits(ConsumeFront(format),
-                           10 * value + GetChar(format, 0) - '0')
-             : Integer{format, value};
-}
-
-// Parse digits for a positional argument.
-// The parsing also consumes the '$'.
-constexpr Integer ParsePositional(string_view format) {
-  return ParseDigits(format).ConsumePositionalDollar();
-}
-
-// Parses a single conversion specifier.
-// See ConvParser::Run() for post conditions.
-class ConvParser {
-  constexpr ConvParser SetFormat(string_view format) const {
-    return ConvParser(format, args_, error_, arg_position_, is_positional_);
-  }
-
-  constexpr ConvParser SetArgs(ConvList args) const {
-    return ConvParser(format_, args, error_, arg_position_, is_positional_);
-  }
-
-  constexpr ConvParser SetError(bool error) const {
-    return ConvParser(format_, args_, error_ || error, arg_position_,
-                      is_positional_);
-  }
-
-  constexpr ConvParser SetArgPosition(int arg_position) const {
-    return ConvParser(format_, args_, error_, arg_position, is_positional_);
-  }
-
-  // Consumes the next arg and verifies that it matches `conv`.
-  // `error_` is set if there is no next arg or if it doesn't match `conv`.
-  constexpr ConvParser ConsumeNextArg(char conv) const {
-    return SetArgs(args_.without_front()).SetError(!Contains(args_[0], conv));
-  }
-
-  // Verify that positional argument `i.value` matches `conv`.
-  // `error_` is set if `i.value` is not a valid argument or if it doesn't
-  // match.
-  constexpr ConvParser VerifyPositional(Integer i, char conv) const {
-    return SetFormat(i.format).SetError(!Contains(args_[i.value - 1], conv));
-  }
-
-  // Parse the position of the arg and store it in `arg_position_`.
-  constexpr ConvParser ParseArgPosition(Integer arg) const {
-    return SetFormat(arg.format).SetArgPosition(arg.value);
-  }
-
-  // Consume the flags.
-  constexpr ConvParser ParseFlags() const {
-    return SetFormat(ConsumeAnyOf(format_, "-+ #0"));
-  }
-
-  // Consume the width.
-  // If it is '*', we verify that it matches `args_`. `error_` is set if it
-  // doesn't match.
-  constexpr ConvParser ParseWidth() const {
-    return IsDigit(GetChar(format_, 0))
-               ? SetFormat(ParseDigits(format_).format)
-               : GetChar(format_, 0) == '*'
-                     ? is_positional_
-                           ? VerifyPositional(
-                                 ParsePositional(ConsumeFront(format_)), '*')
-                           : SetFormat(ConsumeFront(format_))
-                                 .ConsumeNextArg('*')
-                     : *this;
-  }
-
-  // Consume the precision.
-  // If it is '*', we verify that it matches `args_`. `error_` is set if it
-  // doesn't match.
-  constexpr ConvParser ParsePrecision() const {
-    return GetChar(format_, 0) != '.'
-               ? *this
-               : GetChar(format_, 1) == '*'
-                     ? is_positional_
-                           ? VerifyPositional(
-                                 ParsePositional(ConsumeFront(format_, 2)), '*')
-                           : SetFormat(ConsumeFront(format_, 2))
-                                 .ConsumeNextArg('*')
-                     : SetFormat(ParseDigits(ConsumeFront(format_)).format);
-  }
-
-  // Consume the length characters.
-  constexpr ConvParser ParseLength() const {
-    return SetFormat(ConsumeAnyOf(format_, "lLhjztq"));
-  }
-
-  // Consume the conversion character and verify that it matches `args_`.
-  // `error_` is set if it doesn't match.
-  constexpr ConvParser ParseConversion() const {
-    return is_positional_
-               ? VerifyPositional({ConsumeFront(format_), arg_position_},
-                                  GetChar(format_, 0))
-               : ConsumeNextArg(GetChar(format_, 0))
-                     .SetFormat(ConsumeFront(format_));
-  }
-
-  constexpr ConvParser(string_view format, ConvList args, bool error,
-                       int arg_position, bool is_positional)
-      : format_(format),
-        args_(args),
-        error_(error),
-        arg_position_(arg_position),
-        is_positional_(is_positional) {}
-
- public:
-  constexpr ConvParser(string_view format, ConvList args, bool is_positional)
-      : format_(format),
-        args_(args),
-        error_(false),
-        arg_position_(0),
-        is_positional_(is_positional) {}
-
-  // Consume the whole conversion specifier.
-  // `format()` will be set to the character after the conversion character.
-  // `error()` will be set if any of the arguments do not match.
-  constexpr ConvParser Run() const {
-    return (is_positional_ ? ParseArgPosition(ParsePositional(format_)) : *this)
-        .ParseFlags()
-        .ParseWidth()
-        .ParsePrecision()
-        .ParseLength()
-        .ParseConversion();
-  }
-
-  constexpr string_view format() const { return format_; }
-  constexpr ConvList args() const { return args_; }
-  constexpr bool error() const { return error_; }
-  constexpr bool is_positional() const { return is_positional_; }
-
- private:
-  string_view format_;
-  // Current list of arguments. If we are not in positional mode we will consume
-  // from the front.
-  ConvList args_;
-  bool error_;
-  // Holds the argument position of the conversion character, if we are in
-  // positional mode. Otherwise, it is unspecified.
-  int arg_position_;
-  // Whether we are in positional mode.
-  // It changes the behavior of '*' and where to find the converted argument.
-  bool is_positional_;
-};
-
-// Parses a whole format expression.
-// See FormatParser::Run().
-class FormatParser {
-  static constexpr bool FoundPercent(string_view format) {
-    return format.empty() ||
-           (GetChar(format, 0) == '%' && GetChar(format, 1) != '%');
-  }
-
-  // We use an inner function to increase the recursion limit.
-  // The inner function consumes up to `limit` characters on every run.
-  // This increases the limit from 512 to ~512*limit.
-  static constexpr string_view ConsumeNonPercentInner(string_view format,
-                                                      int limit = 20) {
-    return FoundPercent(format) || !limit
-               ? format
-               : ConsumeNonPercentInner(
-                     ConsumeFront(format, GetChar(format, 0) == '%' &&
-                                                  GetChar(format, 1) == '%'
-                                              ? 2
-                                              : 1),
-                     limit - 1);
-  }
-
-  // Consume characters until the next conversion spec %.
-  // It skips %%.
-  static constexpr string_view ConsumeNonPercent(string_view format) {
-    return FoundPercent(format)
-               ? format
-               : ConsumeNonPercent(ConsumeNonPercentInner(format));
-  }
-
-  static constexpr bool IsPositional(string_view format) {
-    return IsDigit(GetChar(format, 0)) ? IsPositional(ConsumeFront(format))
-                                       : GetChar(format, 0) == '$';
-  }
-
-  constexpr bool RunImpl(bool is_positional) const {
-    // In non-positional mode we require all arguments to be consumed.
-    // In positional mode just reaching the end of the format without errors is
-    // enough.
-    return (format_.empty() && (is_positional || args_.count == 0)) ||
-           (!format_.empty() &&
-            ValidateArg(
-                ConvParser(ConsumeFront(format_), args_, is_positional).Run()));
-  }
-
-  constexpr bool ValidateArg(ConvParser conv) const {
-    return !conv.error() && FormatParser(conv.format(), conv.args())
-                                .RunImpl(conv.is_positional());
-  }
-
- public:
-  constexpr FormatParser(string_view format, ConvList args)
-      : format_(ConsumeNonPercent(format)), args_(args) {}
-
-  // Runs the parser for `format` and `args`.
-  // It verifies that the format is valid and that all conversion specifiers
-  // match the arguments passed.
-  // In non-positional mode it also verfies that all arguments are consumed.
-  constexpr bool Run() const {
-    return RunImpl(!format_.empty() && IsPositional(ConsumeFront(format_)));
-  }
-
- private:
-  string_view format_;
-  // Current list of arguments.
-  // If we are not in positional mode we will consume from the front and will
-  // have to be empty in the end.
-  ConvList args_;
-};
-
-template <FormatConversionCharSet... C>
-constexpr bool ValidFormatImpl(string_view format) {
-  return FormatParser(format,
-                      {ConvListT<sizeof...(C)>{{C...}}.list, sizeof...(C)})
-      .Run();
-}
+        constexpr bool ContainsChar(const char* chars, char c)
+        {
+            return *chars == c || (*chars && ContainsChar(chars + 1, c));
+        }
+
+        // A constexpr compatible list of Convs.
+        struct ConvList
+        {
+            const FormatConversionCharSet* array;
+            int count;
+
+            // We do the bound check here to avoid having to do it on the callers.
+            // Returning an empty FormatConversionCharSet has the same effect as
+            // short circuiting because it will never match any conversion.
+            constexpr FormatConversionCharSet operator[](int i) const
+            {
+                return i < count ? array[i] : FormatConversionCharSet{};
+            }
+
+            constexpr ConvList without_front() const
+            {
+                return count != 0 ? ConvList{array + 1, count - 1} : *this;
+            }
+        };
+
+        template<size_t count>
+        struct ConvListT
+        {
+            // Make sure the array has size > 0.
+            FormatConversionCharSet list[count ? count : 1];
+        };
+
+        constexpr char GetChar(string_view str, size_t index)
+        {
+            return index < str.size() ? str[index] : char{};
+        }
+
+        constexpr string_view ConsumeFront(string_view str, size_t len = 1)
+        {
+            return len <= str.size() ? string_view(str.data() + len, str.size() - len) : string_view();
+        }
+
+        constexpr string_view ConsumeAnyOf(string_view format, const char* chars)
+        {
+            return ContainsChar(chars, GetChar(format, 0)) ? ConsumeAnyOf(ConsumeFront(format), chars) : format;
+        }
+
+        constexpr bool IsDigit(char c)
+        {
+            return c >= '0' && c <= '9';
+        }
+
+        // Helper class for the ParseDigits function.
+        // It encapsulates the two return values we need there.
+        struct Integer
+        {
+            string_view format;
+            int value;
+
+            // If the next character is a '$', consume it.
+            // Otherwise, make `this` an invalid positional argument.
+            constexpr Integer ConsumePositionalDollar() const
+            {
+                return GetChar(format, 0) == '$' ? Integer{ConsumeFront(format), value} : Integer{format, 0};
+            }
+        };
+
+        constexpr Integer ParseDigits(string_view format, int value = 0)
+        {
+            return IsDigit(GetChar(format, 0)) ? ParseDigits(ConsumeFront(format), 10 * value + GetChar(format, 0) - '0') : Integer{format, value};
+        }
+
+        // Parse digits for a positional argument.
+        // The parsing also consumes the '$'.
+        constexpr Integer ParsePositional(string_view format)
+        {
+            return ParseDigits(format).ConsumePositionalDollar();
+        }
+
+        // Parses a single conversion specifier.
+        // See ConvParser::Run() for post conditions.
+        class ConvParser
+        {
+            constexpr ConvParser SetFormat(string_view format) const
+            {
+                return ConvParser(format, args_, error_, arg_position_, is_positional_);
+            }
+
+            constexpr ConvParser SetArgs(ConvList args) const
+            {
+                return ConvParser(format_, args, error_, arg_position_, is_positional_);
+            }
+
+            constexpr ConvParser SetError(bool error) const
+            {
+                return ConvParser(format_, args_, error_ || error, arg_position_, is_positional_);
+            }
+
+            constexpr ConvParser SetArgPosition(int arg_position) const
+            {
+                return ConvParser(format_, args_, error_, arg_position, is_positional_);
+            }
+
+            // Consumes the next arg and verifies that it matches `conv`.
+            // `error_` is set if there is no next arg or if it doesn't match `conv`.
+            constexpr ConvParser ConsumeNextArg(char conv) const
+            {
+                return SetArgs(args_.without_front()).SetError(!Contains(args_[0], conv));
+            }
+
+            // Verify that positional argument `i.value` matches `conv`.
+            // `error_` is set if `i.value` is not a valid argument or if it doesn't
+            // match.
+            constexpr ConvParser VerifyPositional(Integer i, char conv) const
+            {
+                return SetFormat(i.format).SetError(!Contains(args_[i.value - 1], conv));
+            }
+
+            // Parse the position of the arg and store it in `arg_position_`.
+            constexpr ConvParser ParseArgPosition(Integer arg) const
+            {
+                return SetFormat(arg.format).SetArgPosition(arg.value);
+            }
+
+            // Consume the flags.
+            constexpr ConvParser ParseFlags() const
+            {
+                return SetFormat(ConsumeAnyOf(format_, "-+ #0"));
+            }
+
+            // Consume the width.
+            // If it is '*', we verify that it matches `args_`. `error_` is set if it
+            // doesn't match.
+            constexpr ConvParser ParseWidth() const
+            {
+                return IsDigit(GetChar(format_, 0)) ? SetFormat(ParseDigits(format_).format) : GetChar(format_, 0) == '*' ? is_positional_ ? VerifyPositional(ParsePositional(ConsumeFront(format_)), '*') : SetFormat(ConsumeFront(format_)).ConsumeNextArg('*') :
+                                                                                                                            *this;
+            }
+
+            // Consume the precision.
+            // If it is '*', we verify that it matches `args_`. `error_` is set if it
+            // doesn't match.
+            constexpr ConvParser ParsePrecision() const
+            {
+                return GetChar(format_, 0) != '.' ? *this : GetChar(format_, 1) == '*' ? is_positional_ ? VerifyPositional(ParsePositional(ConsumeFront(format_, 2)), '*') : SetFormat(ConsumeFront(format_, 2)).ConsumeNextArg('*') :
+                                                                                         SetFormat(ParseDigits(ConsumeFront(format_)).format);
+            }
+
+            // Consume the length characters.
+            constexpr ConvParser ParseLength() const
+            {
+                return SetFormat(ConsumeAnyOf(format_, "lLhjztq"));
+            }
+
+            // Consume the conversion character and verify that it matches `args_`.
+            // `error_` is set if it doesn't match.
+            constexpr ConvParser ParseConversion() const
+            {
+                return is_positional_ ? VerifyPositional({ConsumeFront(format_), arg_position_}, GetChar(format_, 0)) : ConsumeNextArg(GetChar(format_, 0)).SetFormat(ConsumeFront(format_));
+            }
+
+            constexpr ConvParser(string_view format, ConvList args, bool error, int arg_position, bool is_positional) :
+                format_(format),
+                args_(args),
+                error_(error),
+                arg_position_(arg_position),
+                is_positional_(is_positional)
+            {
+            }
+
+        public:
+            constexpr ConvParser(string_view format, ConvList args, bool is_positional) :
+                format_(format),
+                args_(args),
+                error_(false),
+                arg_position_(0),
+                is_positional_(is_positional)
+            {
+            }
+
+            // Consume the whole conversion specifier.
+            // `format()` will be set to the character after the conversion character.
+            // `error()` will be set if any of the arguments do not match.
+            constexpr ConvParser Run() const
+            {
+                return (is_positional_ ? ParseArgPosition(ParsePositional(format_)) : *this)
+                    .ParseFlags()
+                    .ParseWidth()
+                    .ParsePrecision()
+                    .ParseLength()
+                    .ParseConversion();
+            }
+
+            constexpr string_view format() const
+            {
+                return format_;
+            }
+            constexpr ConvList args() const
+            {
+                return args_;
+            }
+            constexpr bool error() const
+            {
+                return error_;
+            }
+            constexpr bool is_positional() const
+            {
+                return is_positional_;
+            }
+
+        private:
+            string_view format_;
+            // Current list of arguments. If we are not in positional mode we will consume
+            // from the front.
+            ConvList args_;
+            bool error_;
+            // Holds the argument position of the conversion character, if we are in
+            // positional mode. Otherwise, it is unspecified.
+            int arg_position_;
+            // Whether we are in positional mode.
+            // It changes the behavior of '*' and where to find the converted argument.
+            bool is_positional_;
+        };
+
+        // Parses a whole format expression.
+        // See FormatParser::Run().
+        class FormatParser
+        {
+            static constexpr bool FoundPercent(string_view format)
+            {
+                return format.empty() ||
+                       (GetChar(format, 0) == '%' && GetChar(format, 1) != '%');
+            }
+
+            // We use an inner function to increase the recursion limit.
+            // The inner function consumes up to `limit` characters on every run.
+            // This increases the limit from 512 to ~512*limit.
+            static constexpr string_view ConsumeNonPercentInner(string_view format, int limit = 20)
+            {
+                return FoundPercent(format) || !limit ? format : ConsumeNonPercentInner(ConsumeFront(format, GetChar(format, 0) == '%' && GetChar(format, 1) == '%' ? 2 : 1), limit - 1);
+            }
+
+            // Consume characters until the next conversion spec %.
+            // It skips %%.
+            static constexpr string_view ConsumeNonPercent(string_view format)
+            {
+                return FoundPercent(format) ? format : ConsumeNonPercent(ConsumeNonPercentInner(format));
+            }
+
+            static constexpr bool IsPositional(string_view format)
+            {
+                return IsDigit(GetChar(format, 0)) ? IsPositional(ConsumeFront(format)) : GetChar(format, 0) == '$';
+            }
+
+            constexpr bool RunImpl(bool is_positional) const
+            {
+                // In non-positional mode we require all arguments to be consumed.
+                // In positional mode just reaching the end of the format without errors is
+                // enough.
+                return (format_.empty() && (is_positional || args_.count == 0)) ||
+                       (!format_.empty() &&
+                        ValidateArg(
+                            ConvParser(ConsumeFront(format_), args_, is_positional).Run()
+                        ));
+            }
+
+            constexpr bool ValidateArg(ConvParser conv) const
+            {
+                return !conv.error() && FormatParser(conv.format(), conv.args())
+                                            .RunImpl(conv.is_positional());
+            }
+
+        public:
+            constexpr FormatParser(string_view format, ConvList args) :
+                format_(ConsumeNonPercent(format)),
+                args_(args)
+            {
+            }
+
+            // Runs the parser for `format` and `args`.
+            // It verifies that the format is valid and that all conversion specifiers
+            // match the arguments passed.
+            // In non-positional mode it also verfies that all arguments are consumed.
+            constexpr bool Run() const
+            {
+                return RunImpl(!format_.empty() && IsPositional(ConsumeFront(format_)));
+            }
+
+        private:
+            string_view format_;
+            // Current list of arguments.
+            // If we are not in positional mode we will consume from the front and will
+            // have to be empty in the end.
+            ConvList args_;
+        };
+
+        template<FormatConversionCharSet... C>
+        constexpr bool ValidFormatImpl(string_view format)
+        {
+            return FormatParser(format, {ConvListT<sizeof...(C)>{{C...}}.list, sizeof...(C)})
+                .Run();
+        }
 
 #endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
-}  // namespace str_format_internal
-ABSL_NAMESPACE_END
+    }  // namespace str_format_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/extension.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/extension.h
index 55e8ac8..57486c6 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/extension.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/extension.h
@@ -29,134 +29,171 @@
 #include "absl/strings/internal/str_format/output.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-enum class FormatConversionChar : uint8_t;
-enum class FormatConversionCharSet : uint64_t;
-
-namespace str_format_internal {
-
-class FormatRawSinkImpl {
- public:
-  // Implicitly convert from any type that provides the hook function as
-  // described above.
-  template <typename T, decltype(str_format_internal::InvokeFlush(
-                            std::declval<T*>(), string_view()))* = nullptr>
-  FormatRawSinkImpl(T* raw)  // NOLINT
-      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
-
-  void Write(string_view s) { write_(sink_, s); }
-
-  template <typename T>
-  static FormatRawSinkImpl Extract(T s) {
-    return s.sink_;
-  }
-
- private:
-  template <typename T>
-  static void Flush(void* r, string_view s) {
-    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
-  }
-
-  void* sink_;
-  void (*write_)(void*, string_view);
-};
-
-// An abstraction to which conversions write their string data.
-class FormatSinkImpl {
- public:
-  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
-
-  ~FormatSinkImpl() { Flush(); }
-
-  void Flush() {
-    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
-    pos_ = buf_;
-  }
-
-  void Append(size_t n, char c) {
-    if (n == 0) return;
-    size_ += n;
-    auto raw_append = [&](size_t count) {
-      memset(pos_, c, count);
-      pos_ += count;
-    };
-    while (n > Avail()) {
-      n -= Avail();
-      if (Avail() > 0) {
-        raw_append(Avail());
-      }
-      Flush();
-    }
-    raw_append(n);
-  }
-
-  void Append(string_view v) {
-    size_t n = v.size();
-    if (n == 0) return;
-    size_ += n;
-    if (n >= Avail()) {
-      Flush();
-      raw_.Write(v);
-      return;
-    }
-    memcpy(pos_, v.data(), n);
-    pos_ += n;
-  }
-
-  size_t size() const { return size_; }
-
-  // Put 'v' to 'sink' with specified width, precision, and left flag.
-  bool PutPaddedString(string_view v, int width, int precision, bool left);
-
-  template <typename T>
-  T Wrap() {
-    return T(this);
-  }
-
-  template <typename T>
-  static FormatSinkImpl* Extract(T* s) {
-    return s->sink_;
-  }
-
- private:
-  size_t Avail() const {
-    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
-  }
-
-  FormatRawSinkImpl raw_;
-  size_t size_ = 0;
-  char* pos_ = buf_;
-  char buf_[1024];
-};
-
-enum class Flags : uint8_t {
-  kBasic = 0,
-  kLeft = 1 << 0,
-  kShowPos = 1 << 1,
-  kSignCol = 1 << 2,
-  kAlt = 1 << 3,
-  kZero = 1 << 4,
-  // This is not a real flag. It just exists to turn off kBasic when no other
-  // flags are set. This is for when width/precision are specified.
-  kNonBasic = 1 << 5,
-};
-
-constexpr Flags operator|(Flags a, Flags b) {
-  return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
-}
-
-constexpr bool FlagsContains(Flags haystack, Flags needle) {
-  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
-         static_cast<uint8_t>(needle);
-}
-
-std::string FlagsToString(Flags v);
-
-inline std::ostream& operator<<(std::ostream& os, Flags v) {
-  return os << FlagsToString(v);
-}
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    enum class FormatConversionChar : uint8_t;
+    enum class FormatConversionCharSet : uint64_t;
+
+    namespace str_format_internal
+    {
+
+        class FormatRawSinkImpl
+        {
+        public:
+            // Implicitly convert from any type that provides the hook function as
+            // described above.
+            template<typename T, decltype(str_format_internal::InvokeFlush(std::declval<T*>(), string_view()))* = nullptr>
+            FormatRawSinkImpl(T* raw)  // NOLINT
+                :
+                sink_(raw),
+                write_(&FormatRawSinkImpl::Flush<T>)
+            {
+            }
+
+            void Write(string_view s)
+            {
+                write_(sink_, s);
+            }
+
+            template<typename T>
+            static FormatRawSinkImpl Extract(T s)
+            {
+                return s.sink_;
+            }
+
+        private:
+            template<typename T>
+            static void Flush(void* r, string_view s)
+            {
+                str_format_internal::InvokeFlush(static_cast<T*>(r), s);
+            }
+
+            void* sink_;
+            void (*write_)(void*, string_view);
+        };
+
+        // An abstraction to which conversions write their string data.
+        class FormatSinkImpl
+        {
+        public:
+            explicit FormatSinkImpl(FormatRawSinkImpl raw) :
+                raw_(raw)
+            {
+            }
+
+            ~FormatSinkImpl()
+            {
+                Flush();
+            }
+
+            void Flush()
+            {
+                raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
+                pos_ = buf_;
+            }
+
+            void Append(size_t n, char c)
+            {
+                if (n == 0)
+                    return;
+                size_ += n;
+                auto raw_append = [&](size_t count)
+                {
+                    memset(pos_, c, count);
+                    pos_ += count;
+                };
+                while (n > Avail())
+                {
+                    n -= Avail();
+                    if (Avail() > 0)
+                    {
+                        raw_append(Avail());
+                    }
+                    Flush();
+                }
+                raw_append(n);
+            }
+
+            void Append(string_view v)
+            {
+                size_t n = v.size();
+                if (n == 0)
+                    return;
+                size_ += n;
+                if (n >= Avail())
+                {
+                    Flush();
+                    raw_.Write(v);
+                    return;
+                }
+                memcpy(pos_, v.data(), n);
+                pos_ += n;
+            }
+
+            size_t size() const
+            {
+                return size_;
+            }
+
+            // Put 'v' to 'sink' with specified width, precision, and left flag.
+            bool PutPaddedString(string_view v, int width, int precision, bool left);
+
+            template<typename T>
+            T Wrap()
+            {
+                return T(this);
+            }
+
+            template<typename T>
+            static FormatSinkImpl* Extract(T* s)
+            {
+                return s->sink_;
+            }
+
+        private:
+            size_t Avail() const
+            {
+                return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
+            }
+
+            FormatRawSinkImpl raw_;
+            size_t size_ = 0;
+            char* pos_ = buf_;
+            char buf_[1024];
+        };
+
+        enum class Flags : uint8_t
+        {
+            kBasic = 0,
+            kLeft = 1 << 0,
+            kShowPos = 1 << 1,
+            kSignCol = 1 << 2,
+            kAlt = 1 << 3,
+            kZero = 1 << 4,
+            // This is not a real flag. It just exists to turn off kBasic when no other
+            // flags are set. This is for when width/precision are specified.
+            kNonBasic = 1 << 5,
+        };
+
+        constexpr Flags operator|(Flags a, Flags b)
+        {
+            return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
+        }
+
+        constexpr bool FlagsContains(Flags haystack, Flags needle)
+        {
+            return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
+                   static_cast<uint8_t>(needle);
+        }
+
+        std::string FlagsToString(Flags v);
+
+        inline std::ostream& operator<<(std::ostream& os, Flags v)
+        {
+            return os << FlagsToString(v);
+        }
 
 // clang-format off
 #define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
@@ -170,23 +207,24 @@ inline std::ostream& operator<<(std::ostream& os, Flags v) {
   X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
   /* misc */ \
   X_VAL(n) X_SEP X_VAL(p)
-// clang-format on
-
-// This type should not be referenced, it exists only to provide labels
-// internally that match the values declared in FormatConversionChar in
-// str_format.h. This is meant to allow internal libraries to use the same
-// declared interface type as the public interface
-// (absl::StrFormatConversionChar) while keeping the definition in a public
-// header.
-// Internal libraries should use the form
-// `FormatConversionCharInternal::c`, `FormatConversionCharInternal::kNone` for
-// comparisons.  Use in switch statements is not recommended due to a bug in how
-// gcc 4.9 -Wswitch handles declared but undefined enums.
-struct FormatConversionCharInternal {
-  FormatConversionCharInternal() = delete;
-
- private:
-  // clang-format off
+        // clang-format on
+
+        // This type should not be referenced, it exists only to provide labels
+        // internally that match the values declared in FormatConversionChar in
+        // str_format.h. This is meant to allow internal libraries to use the same
+        // declared interface type as the public interface
+        // (absl::StrFormatConversionChar) while keeping the definition in a public
+        // header.
+        // Internal libraries should use the form
+        // `FormatConversionCharInternal::c`, `FormatConversionCharInternal::kNone` for
+        // comparisons.  Use in switch statements is not recommended due to a bug in how
+        // gcc 4.9 -Wswitch handles declared but undefined enums.
+        struct FormatConversionCharInternal
+        {
+            FormatConversionCharInternal() = delete;
+
+        private:
+            // clang-format off
   enum class Enum : uint8_t {
     c, s,                    // text
     d, i, o, u, x, X,        // int
@@ -194,255 +232,316 @@ struct FormatConversionCharInternal {
     n, p,                    // misc
     kNone
   };
-  // clang-format on
- public:
-#define ABSL_INTERNAL_X_VAL(id)              \
-  static constexpr FormatConversionChar id = \
-      static_cast<FormatConversionChar>(Enum::id);
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
-#undef ABSL_INTERNAL_X_VAL
-  static constexpr FormatConversionChar kNone =
-      static_cast<FormatConversionChar>(Enum::kNone);
-};
-// clang-format on
+            // clang-format on
 
-inline FormatConversionChar FormatConversionCharFromChar(char c) {
-  switch (c) {
+        public:
+#define ABSL_INTERNAL_X_VAL(id)                \
+    static constexpr FormatConversionChar id = \
+        static_cast<FormatConversionChar>(Enum::id);
+            ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
+#undef ABSL_INTERNAL_X_VAL
+            static constexpr FormatConversionChar kNone =
+                static_cast<FormatConversionChar>(Enum::kNone);
+        };
+        // clang-format on
+
+        inline FormatConversionChar FormatConversionCharFromChar(char c)
+        {
+            switch (c)
+            {
 #define ABSL_INTERNAL_X_VAL(id) \
-  case #id[0]:                  \
-    return FormatConversionCharInternal::id;
-    ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
+    case #id[0]:                \
+        return FormatConversionCharInternal::id;
+                ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
 #undef ABSL_INTERNAL_X_VAL
-  }
-  return FormatConversionCharInternal::kNone;
-}
-
-inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::X ||
-      c == FormatConversionCharInternal::F ||
-      c == FormatConversionCharInternal::E ||
-      c == FormatConversionCharInternal::G ||
-      c == FormatConversionCharInternal::A) {
-    return true;
-  } else {
-    return false;
-  }
-}
-
-inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::a ||
-      c == FormatConversionCharInternal::e ||
-      c == FormatConversionCharInternal::f ||
-      c == FormatConversionCharInternal::g ||
-      c == FormatConversionCharInternal::A ||
-      c == FormatConversionCharInternal::E ||
-      c == FormatConversionCharInternal::F ||
-      c == FormatConversionCharInternal::G) {
-    return true;
-  } else {
-    return false;
-  }
-}
-
-inline char FormatConversionCharToChar(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::kNone) {
-    return '\0';
-
-#define ABSL_INTERNAL_X_VAL(e)                       \
-  } else if (c == FormatConversionCharInternal::e) { \
-    return #e[0];
+            }
+            return FormatConversionCharInternal::kNone;
+        }
+
+        inline bool FormatConversionCharIsUpper(FormatConversionChar c)
+        {
+            if (c == FormatConversionCharInternal::X ||
+                c == FormatConversionCharInternal::F ||
+                c == FormatConversionCharInternal::E ||
+                c == FormatConversionCharInternal::G ||
+                c == FormatConversionCharInternal::A)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        inline bool FormatConversionCharIsFloat(FormatConversionChar c)
+        {
+            if (c == FormatConversionCharInternal::a ||
+                c == FormatConversionCharInternal::e ||
+                c == FormatConversionCharInternal::f ||
+                c == FormatConversionCharInternal::g ||
+                c == FormatConversionCharInternal::A ||
+                c == FormatConversionCharInternal::E ||
+                c == FormatConversionCharInternal::F ||
+                c == FormatConversionCharInternal::G)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        inline char FormatConversionCharToChar(FormatConversionChar c)
+        {
+            if (c == FormatConversionCharInternal::kNone)
+            {
+                return '\0';
+
+#define ABSL_INTERNAL_X_VAL(e)                     \
+    }                                              \
+    else if (c == FormatConversionCharInternal::e) \
+    {                                              \
+        return #e[0];
 #define ABSL_INTERNAL_X_SEP
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
-                                         ABSL_INTERNAL_X_SEP)
-  } else {
-    return '\0';
-  }
+                ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, ABSL_INTERNAL_X_SEP)
+            }
+            else
+            {
+                return '\0';
+            }
 
 #undef ABSL_INTERNAL_X_VAL
 #undef ABSL_INTERNAL_X_SEP
-}
-
-// The associated char.
-inline std::ostream& operator<<(std::ostream& os, FormatConversionChar v) {
-  char c = FormatConversionCharToChar(v);
-  if (!c) c = '?';
-  return os << c;
-}
-
-struct FormatConversionSpecImplFriend;
-
-class FormatConversionSpecImpl {
- public:
-  // Width and precison are not specified, no flags are set.
-  bool is_basic() const { return flags_ == Flags::kBasic; }
-  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
-  bool has_show_pos_flag() const {
-    return FlagsContains(flags_, Flags::kShowPos);
-  }
-  bool has_sign_col_flag() const {
-    return FlagsContains(flags_, Flags::kSignCol);
-  }
-  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
-  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
-
-  FormatConversionChar conversion_char() const {
-    // Keep this field first in the struct . It generates better code when
-    // accessing it when ConversionSpec is passed by value in registers.
-    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
-    return conv_;
-  }
-
-  // Returns the specified width. If width is unspecfied, it returns a negative
-  // value.
-  int width() const { return width_; }
-  // Returns the specified precision. If precision is unspecfied, it returns a
-  // negative value.
-  int precision() const { return precision_; }
-
-  template <typename T>
-  T Wrap() {
-    return T(*this);
-  }
-
- private:
-  friend struct str_format_internal::FormatConversionSpecImplFriend;
-  FormatConversionChar conv_ = FormatConversionCharInternal::kNone;
-  Flags flags_;
-  int width_;
-  int precision_;
-};
-
-struct FormatConversionSpecImplFriend final {
-  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
-    conv->flags_ = f;
-  }
-  static void SetConversionChar(FormatConversionChar c,
-                                FormatConversionSpecImpl* conv) {
-    conv->conv_ = c;
-  }
-  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
-    conv->width_ = w;
-  }
-  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
-    conv->precision_ = p;
-  }
-  static std::string FlagsToString(const FormatConversionSpecImpl& spec) {
-    return str_format_internal::FlagsToString(spec.flags_);
-  }
-};
-
-// Type safe OR operator.
-// We need this for two reasons:
-//  1. operator| on enums makes them decay to integers and the result is an
-//     integer. We need the result to stay as an enum.
-//  2. We use "enum class" which would not work even if we accepted the decay.
-constexpr FormatConversionCharSet FormatConversionCharSetUnion(
-    FormatConversionCharSet a) {
-  return a;
-}
-
-template <typename... CharSet>
-constexpr FormatConversionCharSet FormatConversionCharSetUnion(
-    FormatConversionCharSet a, CharSet... rest) {
-  return static_cast<FormatConversionCharSet>(
-      static_cast<uint64_t>(a) |
-      static_cast<uint64_t>(FormatConversionCharSetUnion(rest...)));
-}
-
-constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
-  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
-}
-
-constexpr uint64_t FormatConversionCharToConvInt(char conv) {
-  return
-#define ABSL_INTERNAL_CHAR_SET_CASE(c)                                 \
-  conv == #c[0]                                                        \
-      ? FormatConversionCharToConvInt(FormatConversionCharInternal::c) \
-      :
-      ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
+        }
+
+        // The associated char.
+        inline std::ostream& operator<<(std::ostream& os, FormatConversionChar v)
+        {
+            char c = FormatConversionCharToChar(v);
+            if (!c)
+                c = '?';
+            return os << c;
+        }
+
+        struct FormatConversionSpecImplFriend;
+
+        class FormatConversionSpecImpl
+        {
+        public:
+            // Width and precison are not specified, no flags are set.
+            bool is_basic() const
+            {
+                return flags_ == Flags::kBasic;
+            }
+            bool has_left_flag() const
+            {
+                return FlagsContains(flags_, Flags::kLeft);
+            }
+            bool has_show_pos_flag() const
+            {
+                return FlagsContains(flags_, Flags::kShowPos);
+            }
+            bool has_sign_col_flag() const
+            {
+                return FlagsContains(flags_, Flags::kSignCol);
+            }
+            bool has_alt_flag() const
+            {
+                return FlagsContains(flags_, Flags::kAlt);
+            }
+            bool has_zero_flag() const
+            {
+                return FlagsContains(flags_, Flags::kZero);
+            }
+
+            FormatConversionChar conversion_char() const
+            {
+                // Keep this field first in the struct . It generates better code when
+                // accessing it when ConversionSpec is passed by value in registers.
+                static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
+                return conv_;
+            }
+
+            // Returns the specified width. If width is unspecfied, it returns a negative
+            // value.
+            int width() const
+            {
+                return width_;
+            }
+            // Returns the specified precision. If precision is unspecfied, it returns a
+            // negative value.
+            int precision() const
+            {
+                return precision_;
+            }
+
+            template<typename T>
+            T Wrap()
+            {
+                return T(*this);
+            }
+
+        private:
+            friend struct str_format_internal::FormatConversionSpecImplFriend;
+            FormatConversionChar conv_ = FormatConversionCharInternal::kNone;
+            Flags flags_;
+            int width_;
+            int precision_;
+        };
+
+        struct FormatConversionSpecImplFriend final
+        {
+            static void SetFlags(Flags f, FormatConversionSpecImpl* conv)
+            {
+                conv->flags_ = f;
+            }
+            static void SetConversionChar(FormatConversionChar c, FormatConversionSpecImpl* conv)
+            {
+                conv->conv_ = c;
+            }
+            static void SetWidth(int w, FormatConversionSpecImpl* conv)
+            {
+                conv->width_ = w;
+            }
+            static void SetPrecision(int p, FormatConversionSpecImpl* conv)
+            {
+                conv->precision_ = p;
+            }
+            static std::string FlagsToString(const FormatConversionSpecImpl& spec)
+            {
+                return str_format_internal::FlagsToString(spec.flags_);
+            }
+        };
+
+        // Type safe OR operator.
+        // We need this for two reasons:
+        //  1. operator| on enums makes them decay to integers and the result is an
+        //     integer. We need the result to stay as an enum.
+        //  2. We use "enum class" which would not work even if we accepted the decay.
+        constexpr FormatConversionCharSet FormatConversionCharSetUnion(
+            FormatConversionCharSet a
+        )
+        {
+            return a;
+        }
+
+        template<typename... CharSet>
+        constexpr FormatConversionCharSet FormatConversionCharSetUnion(
+            FormatConversionCharSet a, CharSet... rest
+        )
+        {
+            return static_cast<FormatConversionCharSet>(
+                static_cast<uint64_t>(a) |
+                static_cast<uint64_t>(FormatConversionCharSetUnion(rest...))
+            );
+        }
+
+        constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c)
+        {
+            return uint64_t{1} << (1 + static_cast<uint8_t>(c));
+        }
+
+        constexpr uint64_t FormatConversionCharToConvInt(char conv)
+        {
+            return
+#define ABSL_INTERNAL_CHAR_SET_CASE(c) \
+    conv == #c[0] ? FormatConversionCharToConvInt(FormatConversionCharInternal::c):
+                ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
 #undef ABSL_INTERNAL_CHAR_SET_CASE
-                  conv == '*'
-          ? 1
-          : 0;
-}
-
-constexpr FormatConversionCharSet FormatConversionCharToConvValue(char conv) {
-  return static_cast<FormatConversionCharSet>(
-      FormatConversionCharToConvInt(conv));
-}
-
-struct FormatConversionCharSetInternal {
-#define ABSL_INTERNAL_CHAR_SET_CASE(c)         \
-  static constexpr FormatConversionCharSet c = \
-      FormatConversionCharToConvValue(#c[0]);
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
+                            conv == '*' ?
+                    1 :
+                    0;
+        }
+
+        constexpr FormatConversionCharSet FormatConversionCharToConvValue(char conv)
+        {
+            return static_cast<FormatConversionCharSet>(
+                FormatConversionCharToConvInt(conv)
+            );
+        }
+
+        struct FormatConversionCharSetInternal
+        {
+#define ABSL_INTERNAL_CHAR_SET_CASE(c)           \
+    static constexpr FormatConversionCharSet c = \
+        FormatConversionCharToConvValue(#c[0]);
+            ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
 #undef ABSL_INTERNAL_CHAR_SET_CASE
 
-  // Used for width/precision '*' specification.
-  static constexpr FormatConversionCharSet kStar =
-      FormatConversionCharToConvValue('*');
-
-  static constexpr FormatConversionCharSet kIntegral =
-      FormatConversionCharSetUnion(d, i, u, o, x, X);
-  static constexpr FormatConversionCharSet kFloating =
-      FormatConversionCharSetUnion(a, e, f, g, A, E, F, G);
-  static constexpr FormatConversionCharSet kNumeric =
-      FormatConversionCharSetUnion(kIntegral, kFloating);
-  static constexpr FormatConversionCharSet kPointer = p;
-};
-
-// Type safe OR operator.
-// We need this for two reasons:
-//  1. operator| on enums makes them decay to integers and the result is an
-//     integer. We need the result to stay as an enum.
-//  2. We use "enum class" which would not work even if we accepted the decay.
-constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
-                                            FormatConversionCharSet b) {
-  return FormatConversionCharSetUnion(a, b);
-}
-
-// Overloaded conversion functions to support absl::ParsedFormat.
-// Get a conversion with a single character in it.
-constexpr FormatConversionCharSet ToFormatConversionCharSet(char c) {
-  return static_cast<FormatConversionCharSet>(
-      FormatConversionCharToConvValue(c));
-}
-
-// Get a conversion with a single character in it.
-constexpr FormatConversionCharSet ToFormatConversionCharSet(
-    FormatConversionCharSet c) {
-  return c;
-}
-
-template <typename T>
-void ToFormatConversionCharSet(T) = delete;
-
-// Checks whether `c` exists in `set`.
-constexpr bool Contains(FormatConversionCharSet set, char c) {
-  return (static_cast<uint64_t>(set) &
-          static_cast<uint64_t>(FormatConversionCharToConvValue(c))) != 0;
-}
-
-// Checks whether all the characters in `c` are contained in `set`
-constexpr bool Contains(FormatConversionCharSet set,
-                        FormatConversionCharSet c) {
-  return (static_cast<uint64_t>(set) & static_cast<uint64_t>(c)) ==
-         static_cast<uint64_t>(c);
-}
-
-// Checks whether all the characters in `c` are contained in `set`
-constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
-  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
-}
-
-// Return capacity - used, clipped to a minimum of 0.
-inline size_t Excess(size_t used, size_t capacity) {
-  return used < capacity ? capacity - used : 0;
-}
-
-}  // namespace str_format_internal
-
-ABSL_NAMESPACE_END
+            // Used for width/precision '*' specification.
+            static constexpr FormatConversionCharSet kStar =
+                FormatConversionCharToConvValue('*');
+
+            static constexpr FormatConversionCharSet kIntegral =
+                FormatConversionCharSetUnion(d, i, u, o, x, X);
+            static constexpr FormatConversionCharSet kFloating =
+                FormatConversionCharSetUnion(a, e, f, g, A, E, F, G);
+            static constexpr FormatConversionCharSet kNumeric =
+                FormatConversionCharSetUnion(kIntegral, kFloating);
+            static constexpr FormatConversionCharSet kPointer = p;
+        };
+
+        // Type safe OR operator.
+        // We need this for two reasons:
+        //  1. operator| on enums makes them decay to integers and the result is an
+        //     integer. We need the result to stay as an enum.
+        //  2. We use "enum class" which would not work even if we accepted the decay.
+        constexpr FormatConversionCharSet operator|(FormatConversionCharSet a, FormatConversionCharSet b)
+        {
+            return FormatConversionCharSetUnion(a, b);
+        }
+
+        // Overloaded conversion functions to support absl::ParsedFormat.
+        // Get a conversion with a single character in it.
+        constexpr FormatConversionCharSet ToFormatConversionCharSet(char c)
+        {
+            return static_cast<FormatConversionCharSet>(
+                FormatConversionCharToConvValue(c)
+            );
+        }
+
+        // Get a conversion with a single character in it.
+        constexpr FormatConversionCharSet ToFormatConversionCharSet(
+            FormatConversionCharSet c
+        )
+        {
+            return c;
+        }
+
+        template<typename T>
+        void ToFormatConversionCharSet(T) = delete;
+
+        // Checks whether `c` exists in `set`.
+        constexpr bool Contains(FormatConversionCharSet set, char c)
+        {
+            return (static_cast<uint64_t>(set) &
+                    static_cast<uint64_t>(FormatConversionCharToConvValue(c))) != 0;
+        }
+
+        // Checks whether all the characters in `c` are contained in `set`
+        constexpr bool Contains(FormatConversionCharSet set, FormatConversionCharSet c)
+        {
+            return (static_cast<uint64_t>(set) & static_cast<uint64_t>(c)) ==
+                   static_cast<uint64_t>(c);
+        }
+
+        // Checks whether all the characters in `c` are contained in `set`
+        constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c)
+        {
+            return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
+        }
+
+        // Return capacity - used, clipped to a minimum of 0.
+        inline size_t Excess(size_t used, size_t capacity)
+        {
+            return used < capacity ? capacity - used : 0;
+        }
+
+    }  // namespace str_format_internal
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/float_conversion.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/float_conversion.h
index 71100e7..61bc504 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/float_conversion.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/float_conversion.h
@@ -17,21 +17,20 @@
 
 #include "absl/strings/internal/str_format/extension.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace str_format_internal
+    {
 
-bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink);
+        bool ConvertFloatImpl(float v, const FormatConversionSpecImpl& conv, FormatSinkImpl* sink);
 
-bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink);
+        bool ConvertFloatImpl(double v, const FormatConversionSpecImpl& conv, FormatSinkImpl* sink);
 
-bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink);
+        bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl& conv, FormatSinkImpl* sink);
 
-}  // namespace str_format_internal
-ABSL_NAMESPACE_END
+    }  // namespace str_format_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/output.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/output.h
index 15e751a..1a06319 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/output.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/output.h
@@ -29,69 +29,94 @@
 #include "absl/base/port.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
-
-// RawSink implementation that writes into a char* buffer.
-// It will not overflow the buffer, but will keep the total count of chars
-// that would have been written.
-class BufferRawSink {
- public:
-  BufferRawSink(char* buffer, size_t size) : buffer_(buffer), size_(size) {}
-
-  size_t total_written() const { return total_written_; }
-  void Write(string_view v);
-
- private:
-  char* buffer_;
-  size_t size_;
-  size_t total_written_ = 0;
-};
-
-// RawSink implementation that writes into a FILE*.
-// It keeps track of the total number of bytes written and any error encountered
-// during the writes.
-class FILERawSink {
- public:
-  explicit FILERawSink(std::FILE* output) : output_(output) {}
-
-  void Write(string_view v);
-
-  size_t count() const { return count_; }
-  int error() const { return error_; }
-
- private:
-  std::FILE* output_;
-  int error_ = 0;
-  size_t count_ = 0;
-};
-
-// Provide RawSink integration with common types from the STL.
-inline void AbslFormatFlush(std::string* out, string_view s) {
-  out->append(s.data(), s.size());
-}
-inline void AbslFormatFlush(std::ostream* out, string_view s) {
-  out->write(s.data(), static_cast<std::streamsize>(s.size()));
-}
-
-inline void AbslFormatFlush(FILERawSink* sink, string_view v) {
-  sink->Write(v);
-}
-
-inline void AbslFormatFlush(BufferRawSink* sink, string_view v) {
-  sink->Write(v);
-}
-
-// This is a SFINAE to get a better compiler error message when the type
-// is not supported.
-template <typename T>
-auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
-  AbslFormatFlush(out, s);
-}
-
-}  // namespace str_format_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace str_format_internal
+    {
+
+        // RawSink implementation that writes into a char* buffer.
+        // It will not overflow the buffer, but will keep the total count of chars
+        // that would have been written.
+        class BufferRawSink
+        {
+        public:
+            BufferRawSink(char* buffer, size_t size) :
+                buffer_(buffer),
+                size_(size)
+            {
+            }
+
+            size_t total_written() const
+            {
+                return total_written_;
+            }
+            void Write(string_view v);
+
+        private:
+            char* buffer_;
+            size_t size_;
+            size_t total_written_ = 0;
+        };
+
+        // RawSink implementation that writes into a FILE*.
+        // It keeps track of the total number of bytes written and any error encountered
+        // during the writes.
+        class FILERawSink
+        {
+        public:
+            explicit FILERawSink(std::FILE* output) :
+                output_(output)
+            {
+            }
+
+            void Write(string_view v);
+
+            size_t count() const
+            {
+                return count_;
+            }
+            int error() const
+            {
+                return error_;
+            }
+
+        private:
+            std::FILE* output_;
+            int error_ = 0;
+            size_t count_ = 0;
+        };
+
+        // Provide RawSink integration with common types from the STL.
+        inline void AbslFormatFlush(std::string* out, string_view s)
+        {
+            out->append(s.data(), s.size());
+        }
+        inline void AbslFormatFlush(std::ostream* out, string_view s)
+        {
+            out->write(s.data(), static_cast<std::streamsize>(s.size()));
+        }
+
+        inline void AbslFormatFlush(FILERawSink* sink, string_view v)
+        {
+            sink->Write(v);
+        }
+
+        inline void AbslFormatFlush(BufferRawSink* sink, string_view v)
+        {
+            sink->Write(v);
+        }
+
+        // This is a SFINAE to get a better compiler error message when the type
+        // is not supported.
+        template<typename T>
+        auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s))
+        {
+            AbslFormatFlush(out, s);
+        }
+
+    }  // namespace str_format_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/parser.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/parser.h
index 32b91d0..bf5e725 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_format/parser.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_format/parser.h
@@ -31,329 +31,430 @@
 #include "absl/strings/internal/str_format/checker.h"
 #include "absl/strings/internal/str_format/extension.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace str_format_internal {
-
-enum class LengthMod : std::uint8_t { h, hh, l, ll, L, j, z, t, q, none };
-
-std::string LengthModToString(LengthMod v);
-
-// The analyzed properties of a single specified conversion.
-struct UnboundConversion {
-  UnboundConversion() {}
-
-  class InputValue {
-   public:
-    void set_value(int value) {
-      assert(value >= 0);
-      value_ = value;
-    }
-    int value() const { return value_; }
-
-    // Marks the value as "from arg". aka the '*' format.
-    // Requires `value >= 1`.
-    // When set, is_from_arg() return true and get_from_arg() returns the
-    // original value.
-    // `value()`'s return value is unspecfied in this state.
-    void set_from_arg(int value) {
-      assert(value > 0);
-      value_ = -value - 1;
-    }
-    bool is_from_arg() const { return value_ < -1; }
-    int get_from_arg() const {
-      assert(is_from_arg());
-      return -value_ - 1;
-    }
-
-   private:
-    int value_ = -1;
-  };
-
-  // No need to initialize. It will always be set in the parser.
-  int arg_position;
-
-  InputValue width;
-  InputValue precision;
-
-  Flags flags = Flags::kBasic;
-  LengthMod length_mod = LengthMod::none;
-  FormatConversionChar conv = FormatConversionCharInternal::kNone;
-};
-
-// Consume conversion spec prefix (not including '%') of [p, end) if valid.
-// Examples of valid specs would be e.g.: "s", "d", "-12.6f".
-// If valid, it returns the first character following the conversion spec,
-// and the spec part is broken down and returned in 'conv'.
-// If invalid, returns nullptr.
-const char* ConsumeUnboundConversion(const char* p, const char* end,
-                                     UnboundConversion* conv, int* next_arg);
-
-// Helper tag class for the table below.
-// It allows fast `char -> ConversionChar/LengthMod/Flags` checking and
-// conversions.
-class ConvTag {
- public:
-  constexpr ConvTag(FormatConversionChar conversion_char)  // NOLINT
-      : tag_(static_cast<uint8_t>(conversion_char)) {}
-  constexpr ConvTag(LengthMod length_mod)  // NOLINT
-      : tag_(0x80 | static_cast<uint8_t>(length_mod)) {}
-  constexpr ConvTag(Flags flags)  // NOLINT
-      : tag_(0xc0 | static_cast<uint8_t>(flags)) {}
-  constexpr ConvTag() : tag_(0xFF) {}
-
-  bool is_conv() const { return (tag_ & 0x80) == 0; }
-  bool is_length() const { return (tag_ & 0xC0) == 0x80; }
-  bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
-
-  FormatConversionChar as_conv() const {
-    assert(is_conv());
-    assert(!is_length());
-    assert(!is_flags());
-    return static_cast<FormatConversionChar>(tag_);
-  }
-  LengthMod as_length() const {
-    assert(!is_conv());
-    assert(is_length());
-    assert(!is_flags());
-    return static_cast<LengthMod>(tag_ & 0x3F);
-  }
-  Flags as_flags() const {
-    assert(!is_conv());
-    assert(!is_length());
-    assert(is_flags());
-    return static_cast<Flags>(tag_ & 0x1F);
-  }
-
- private:
-  uint8_t tag_;
-};
-
-extern const ConvTag kTags[256];
-// Keep a single table for all the conversion chars and length modifiers.
-inline ConvTag GetTagForChar(char c) {
-  return kTags[static_cast<unsigned char>(c)];
-}
-
-// Parse the format string provided in 'src' and pass the identified items into
-// 'consumer'.
-// Text runs will be passed by calling
-//   Consumer::Append(string_view);
-// ConversionItems will be passed by calling
-//   Consumer::ConvertOne(UnboundConversion, string_view);
-// In the case of ConvertOne, the string_view that is passed is the
-// portion of the format string corresponding to the conversion, not including
-// the leading %. On success, it returns true. On failure, it stops and returns
-// false.
-template <typename Consumer>
-bool ParseFormatString(string_view src, Consumer consumer) {
-  int next_arg = 0;
-  const char* p = src.data();
-  const char* const end = p + src.size();
-  while (p != end) {
-    const char* percent =
-        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
-    if (!percent) {
-      // We found the last substring.
-      return consumer.Append(string_view(p, end - p));
-    }
-    // We found a percent, so push the text run then process the percent.
-    if (ABSL_PREDICT_FALSE(!consumer.Append(string_view(p, percent - p)))) {
-      return false;
-    }
-    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
-
-    auto tag = GetTagForChar(percent[1]);
-    if (tag.is_conv()) {
-      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
-        // This indicates an error in the format string.
-        // The only way to get `next_arg < 0` here is to have a positional
-        // argument first which sets next_arg to -1 and then a non-positional
-        // argument.
-        return false;
-      }
-      p = percent + 2;
-
-      // Keep this case separate from the one below.
-      // ConvertOne is more efficient when the compiler can see that the `basic`
-      // flag is set.
-      UnboundConversion conv;
-      conv.conv = tag.as_conv();
-      conv.arg_position = ++next_arg;
-      if (ABSL_PREDICT_FALSE(
-              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
-        return false;
-      }
-    } else if (percent[1] != '%') {
-      UnboundConversion conv;
-      p = ConsumeUnboundConversion(percent + 1, end, &conv, &next_arg);
-      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
-      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
-          conv, string_view(percent + 1, p - (percent + 1))))) {
-        return false;
-      }
-    } else {
-      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
-      p = percent + 2;
-      continue;
-    }
-  }
-  return true;
-}
-
-// Always returns true, or fails to compile in a constexpr context if s does not
-// point to a constexpr char array.
-constexpr bool EnsureConstexpr(string_view s) {
-  return s.empty() || s[0] == s[0];
-}
-
-class ParsedFormatBase {
- public:
-  explicit ParsedFormatBase(
-      string_view format, bool allow_ignored,
-      std::initializer_list<FormatConversionCharSet> convs);
-
-  ParsedFormatBase(const ParsedFormatBase& other) { *this = other; }
-
-  ParsedFormatBase(ParsedFormatBase&& other) { *this = std::move(other); }
-
-  ParsedFormatBase& operator=(const ParsedFormatBase& other) {
-    if (this == &other) return *this;
-    has_error_ = other.has_error_;
-    items_ = other.items_;
-    size_t text_size = items_.empty() ? 0 : items_.back().text_end;
-    data_.reset(new char[text_size]);
-    memcpy(data_.get(), other.data_.get(), text_size);
-    return *this;
-  }
-
-  ParsedFormatBase& operator=(ParsedFormatBase&& other) {
-    if (this == &other) return *this;
-    has_error_ = other.has_error_;
-    data_ = std::move(other.data_);
-    items_ = std::move(other.items_);
-    // Reset the vector to make sure the invariants hold.
-    other.items_.clear();
-    return *this;
-  }
-
-  template <typename Consumer>
-  bool ProcessFormat(Consumer consumer) const {
-    const char* const base = data_.get();
-    string_view text(base, 0);
-    for (const auto& item : items_) {
-      const char* const end = text.data() + text.size();
-      text =
-          string_view(end, static_cast<size_t>((base + item.text_end) - end));
-      if (item.is_conversion) {
-        if (!consumer.ConvertOne(item.conv, text)) return false;
-      } else {
-        if (!consumer.Append(text)) return false;
-      }
-    }
-    return !has_error_;
-  }
-
-  bool has_error() const { return has_error_; }
-
- private:
-  // Returns whether the conversions match and if !allow_ignored it verifies
-  // that all conversions are used by the format.
-  bool MatchesConversions(
-      bool allow_ignored,
-      std::initializer_list<FormatConversionCharSet> convs) const;
-
-  struct ParsedFormatConsumer;
-
-  struct ConversionItem {
-    bool is_conversion;
-    // Points to the past-the-end location of this element in the data_ array.
-    size_t text_end;
-    UnboundConversion conv;
-  };
-
-  bool has_error_;
-  std::unique_ptr<char[]> data_;
-  std::vector<ConversionItem> items_;
-};
-
-
-// A value type representing a preparsed format.  These can be created, copied
-// around, and reused to speed up formatting loops.
-// The user must specify through the template arguments the conversion
-// characters used in the format. This will be checked at compile time.
-//
-// This class uses Conv enum values to specify each argument.
-// This allows for more flexibility as you can specify multiple possible
-// conversion characters for each argument.
-// ParsedFormat<char...> is a simplified alias for when the user only
-// needs to specify a single conversion character for each argument.
-//
-// Example:
-//   // Extended format supports multiple characters per argument:
-//   using MyFormat = ExtendedParsedFormat<Conv::d | Conv::x>;
-//   MyFormat GetFormat(bool use_hex) {
-//     if (use_hex) return MyFormat("foo %x bar");
-//     return MyFormat("foo %d bar");
-//   }
-//   // 'format' can be used with any value that supports 'd' and 'x',
-//   // like `int`.
-//   auto format = GetFormat(use_hex);
-//   value = StringF(format, i);
-//
-// This class also supports runtime format checking with the ::New() and
-// ::NewAllowIgnored() factory functions.
-// This is the only API that allows the user to pass a runtime specified format
-// string. These factory functions will return NULL if the format does not match
-// the conversions requested by the user.
-template <FormatConversionCharSet... C>
-class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
- public:
-  explicit ExtendedParsedFormat(string_view format)
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace str_format_internal
+    {
+
+        enum class LengthMod : std::uint8_t
+        {
+            h,
+            hh,
+            l,
+            ll,
+            L,
+            j,
+            z,
+            t,
+            q,
+            none
+        };
+
+        std::string LengthModToString(LengthMod v);
+
+        // The analyzed properties of a single specified conversion.
+        struct UnboundConversion
+        {
+            UnboundConversion()
+            {
+            }
+
+            class InputValue
+            {
+            public:
+                void set_value(int value)
+                {
+                    assert(value >= 0);
+                    value_ = value;
+                }
+                int value() const
+                {
+                    return value_;
+                }
+
+                // Marks the value as "from arg". aka the '*' format.
+                // Requires `value >= 1`.
+                // When set, is_from_arg() return true and get_from_arg() returns the
+                // original value.
+                // `value()`'s return value is unspecfied in this state.
+                void set_from_arg(int value)
+                {
+                    assert(value > 0);
+                    value_ = -value - 1;
+                }
+                bool is_from_arg() const
+                {
+                    return value_ < -1;
+                }
+                int get_from_arg() const
+                {
+                    assert(is_from_arg());
+                    return -value_ - 1;
+                }
+
+            private:
+                int value_ = -1;
+            };
+
+            // No need to initialize. It will always be set in the parser.
+            int arg_position;
+
+            InputValue width;
+            InputValue precision;
+
+            Flags flags = Flags::kBasic;
+            LengthMod length_mod = LengthMod::none;
+            FormatConversionChar conv = FormatConversionCharInternal::kNone;
+        };
+
+        // Consume conversion spec prefix (not including '%') of [p, end) if valid.
+        // Examples of valid specs would be e.g.: "s", "d", "-12.6f".
+        // If valid, it returns the first character following the conversion spec,
+        // and the spec part is broken down and returned in 'conv'.
+        // If invalid, returns nullptr.
+        const char* ConsumeUnboundConversion(const char* p, const char* end, UnboundConversion* conv, int* next_arg);
+
+        // Helper tag class for the table below.
+        // It allows fast `char -> ConversionChar/LengthMod/Flags` checking and
+        // conversions.
+        class ConvTag
+        {
+        public:
+            constexpr ConvTag(FormatConversionChar conversion_char)  // NOLINT
+                :
+                tag_(static_cast<uint8_t>(conversion_char))
+            {
+            }
+            constexpr ConvTag(LengthMod length_mod)  // NOLINT
+                :
+                tag_(0x80 | static_cast<uint8_t>(length_mod))
+            {
+            }
+            constexpr ConvTag(Flags flags)  // NOLINT
+                :
+                tag_(0xc0 | static_cast<uint8_t>(flags))
+            {
+            }
+            constexpr ConvTag() :
+                tag_(0xFF)
+            {
+            }
+
+            bool is_conv() const
+            {
+                return (tag_ & 0x80) == 0;
+            }
+            bool is_length() const
+            {
+                return (tag_ & 0xC0) == 0x80;
+            }
+            bool is_flags() const
+            {
+                return (tag_ & 0xE0) == 0xC0;
+            }
+
+            FormatConversionChar as_conv() const
+            {
+                assert(is_conv());
+                assert(!is_length());
+                assert(!is_flags());
+                return static_cast<FormatConversionChar>(tag_);
+            }
+            LengthMod as_length() const
+            {
+                assert(!is_conv());
+                assert(is_length());
+                assert(!is_flags());
+                return static_cast<LengthMod>(tag_ & 0x3F);
+            }
+            Flags as_flags() const
+            {
+                assert(!is_conv());
+                assert(!is_length());
+                assert(is_flags());
+                return static_cast<Flags>(tag_ & 0x1F);
+            }
+
+        private:
+            uint8_t tag_;
+        };
+
+        extern const ConvTag kTags[256];
+        // Keep a single table for all the conversion chars and length modifiers.
+        inline ConvTag GetTagForChar(char c)
+        {
+            return kTags[static_cast<unsigned char>(c)];
+        }
+
+        // Parse the format string provided in 'src' and pass the identified items into
+        // 'consumer'.
+        // Text runs will be passed by calling
+        //   Consumer::Append(string_view);
+        // ConversionItems will be passed by calling
+        //   Consumer::ConvertOne(UnboundConversion, string_view);
+        // In the case of ConvertOne, the string_view that is passed is the
+        // portion of the format string corresponding to the conversion, not including
+        // the leading %. On success, it returns true. On failure, it stops and returns
+        // false.
+        template<typename Consumer>
+        bool ParseFormatString(string_view src, Consumer consumer)
+        {
+            int next_arg = 0;
+            const char* p = src.data();
+            const char* const end = p + src.size();
+            while (p != end)
+            {
+                const char* percent =
+                    static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
+                if (!percent)
+                {
+                    // We found the last substring.
+                    return consumer.Append(string_view(p, end - p));
+                }
+                // We found a percent, so push the text run then process the percent.
+                if (ABSL_PREDICT_FALSE(!consumer.Append(string_view(p, percent - p))))
+                {
+                    return false;
+                }
+                if (ABSL_PREDICT_FALSE(percent + 1 >= end))
+                    return false;
+
+                auto tag = GetTagForChar(percent[1]);
+                if (tag.is_conv())
+                {
+                    if (ABSL_PREDICT_FALSE(next_arg < 0))
+                    {
+                        // This indicates an error in the format string.
+                        // The only way to get `next_arg < 0` here is to have a positional
+                        // argument first which sets next_arg to -1 and then a non-positional
+                        // argument.
+                        return false;
+                    }
+                    p = percent + 2;
+
+                    // Keep this case separate from the one below.
+                    // ConvertOne is more efficient when the compiler can see that the `basic`
+                    // flag is set.
+                    UnboundConversion conv;
+                    conv.conv = tag.as_conv();
+                    conv.arg_position = ++next_arg;
+                    if (ABSL_PREDICT_FALSE(
+                            !consumer.ConvertOne(conv, string_view(percent + 1, 1))
+                        ))
+                    {
+                        return false;
+                    }
+                }
+                else if (percent[1] != '%')
+                {
+                    UnboundConversion conv;
+                    p = ConsumeUnboundConversion(percent + 1, end, &conv, &next_arg);
+                    if (ABSL_PREDICT_FALSE(p == nullptr))
+                        return false;
+                    if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
+                            conv, string_view(percent + 1, p - (percent + 1))
+                        )))
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    if (ABSL_PREDICT_FALSE(!consumer.Append("%")))
+                        return false;
+                    p = percent + 2;
+                    continue;
+                }
+            }
+            return true;
+        }
+
+        // Always returns true, or fails to compile in a constexpr context if s does not
+        // point to a constexpr char array.
+        constexpr bool EnsureConstexpr(string_view s)
+        {
+            return s.empty() || s[0] == s[0];
+        }
+
+        class ParsedFormatBase
+        {
+        public:
+            explicit ParsedFormatBase(
+                string_view format, bool allow_ignored, std::initializer_list<FormatConversionCharSet> convs
+            );
+
+            ParsedFormatBase(const ParsedFormatBase& other)
+            {
+                *this = other;
+            }
+
+            ParsedFormatBase(ParsedFormatBase&& other)
+            {
+                *this = std::move(other);
+            }
+
+            ParsedFormatBase& operator=(const ParsedFormatBase& other)
+            {
+                if (this == &other)
+                    return *this;
+                has_error_ = other.has_error_;
+                items_ = other.items_;
+                size_t text_size = items_.empty() ? 0 : items_.back().text_end;
+                data_.reset(new char[text_size]);
+                memcpy(data_.get(), other.data_.get(), text_size);
+                return *this;
+            }
+
+            ParsedFormatBase& operator=(ParsedFormatBase&& other)
+            {
+                if (this == &other)
+                    return *this;
+                has_error_ = other.has_error_;
+                data_ = std::move(other.data_);
+                items_ = std::move(other.items_);
+                // Reset the vector to make sure the invariants hold.
+                other.items_.clear();
+                return *this;
+            }
+
+            template<typename Consumer>
+            bool ProcessFormat(Consumer consumer) const
+            {
+                const char* const base = data_.get();
+                string_view text(base, 0);
+                for (const auto& item : items_)
+                {
+                    const char* const end = text.data() + text.size();
+                    text =
+                        string_view(end, static_cast<size_t>((base + item.text_end) - end));
+                    if (item.is_conversion)
+                    {
+                        if (!consumer.ConvertOne(item.conv, text))
+                            return false;
+                    }
+                    else
+                    {
+                        if (!consumer.Append(text))
+                            return false;
+                    }
+                }
+                return !has_error_;
+            }
+
+            bool has_error() const
+            {
+                return has_error_;
+            }
+
+        private:
+            // Returns whether the conversions match and if !allow_ignored it verifies
+            // that all conversions are used by the format.
+            bool MatchesConversions(
+                bool allow_ignored,
+                std::initializer_list<FormatConversionCharSet> convs
+            ) const;
+
+            struct ParsedFormatConsumer;
+
+            struct ConversionItem
+            {
+                bool is_conversion;
+                // Points to the past-the-end location of this element in the data_ array.
+                size_t text_end;
+                UnboundConversion conv;
+            };
+
+            bool has_error_;
+            std::unique_ptr<char[]> data_;
+            std::vector<ConversionItem> items_;
+        };
+
+        // A value type representing a preparsed format.  These can be created, copied
+        // around, and reused to speed up formatting loops.
+        // The user must specify through the template arguments the conversion
+        // characters used in the format. This will be checked at compile time.
+        //
+        // This class uses Conv enum values to specify each argument.
+        // This allows for more flexibility as you can specify multiple possible
+        // conversion characters for each argument.
+        // ParsedFormat<char...> is a simplified alias for when the user only
+        // needs to specify a single conversion character for each argument.
+        //
+        // Example:
+        //   // Extended format supports multiple characters per argument:
+        //   using MyFormat = ExtendedParsedFormat<Conv::d | Conv::x>;
+        //   MyFormat GetFormat(bool use_hex) {
+        //     if (use_hex) return MyFormat("foo %x bar");
+        //     return MyFormat("foo %d bar");
+        //   }
+        //   // 'format' can be used with any value that supports 'd' and 'x',
+        //   // like `int`.
+        //   auto format = GetFormat(use_hex);
+        //   value = StringF(format, i);
+        //
+        // This class also supports runtime format checking with the ::New() and
+        // ::NewAllowIgnored() factory functions.
+        // This is the only API that allows the user to pass a runtime specified format
+        // string. These factory functions will return NULL if the format does not match
+        // the conversions requested by the user.
+        template<FormatConversionCharSet... C>
+        class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase
+        {
+        public:
+            explicit ExtendedParsedFormat(string_view format)
 #ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-      __attribute__((
-          enable_if(str_format_internal::EnsureConstexpr(format),
-                    "Format string is not constexpr."),
-          enable_if(str_format_internal::ValidFormatImpl<C...>(format),
-                    "Format specified does not match the template arguments.")))
+                __attribute__((
+                    enable_if(str_format_internal::EnsureConstexpr(format), "Format string is not constexpr."),
+                    enable_if(str_format_internal::ValidFormatImpl<C...>(format), "Format specified does not match the template arguments.")
+                ))
 #endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-      : ExtendedParsedFormat(format, false) {
-  }
-
-  // ExtendedParsedFormat factory function.
-  // The user still has to specify the conversion characters, but they will not
-  // be checked at compile time. Instead, it will be checked at runtime.
-  // This delays the checking to runtime, but allows the user to pass
-  // dynamically sourced formats.
-  // It returns NULL if the format does not match the conversion characters.
-  // The user is responsible for checking the return value before using it.
-  //
-  // The 'New' variant will check that all the specified arguments are being
-  // consumed by the format and return NULL if any argument is being ignored.
-  // The 'NewAllowIgnored' variant will not verify this and will allow formats
-  // that ignore arguments.
-  static std::unique_ptr<ExtendedParsedFormat> New(string_view format) {
-    return New(format, false);
-  }
-  static std::unique_ptr<ExtendedParsedFormat> NewAllowIgnored(
-      string_view format) {
-    return New(format, true);
-  }
-
- private:
-  static std::unique_ptr<ExtendedParsedFormat> New(string_view format,
-                                                   bool allow_ignored) {
-    std::unique_ptr<ExtendedParsedFormat> conv(
-        new ExtendedParsedFormat(format, allow_ignored));
-    if (conv->has_error()) return nullptr;
-    return conv;
-  }
-
-  ExtendedParsedFormat(string_view s, bool allow_ignored)
-      : ParsedFormatBase(s, allow_ignored, {C...}) {}
-};
-}  // namespace str_format_internal
-ABSL_NAMESPACE_END
+                :
+                ExtendedParsedFormat(format, false)
+            {
+            }
+
+            // ExtendedParsedFormat factory function.
+            // The user still has to specify the conversion characters, but they will not
+            // be checked at compile time. Instead, it will be checked at runtime.
+            // This delays the checking to runtime, but allows the user to pass
+            // dynamically sourced formats.
+            // It returns NULL if the format does not match the conversion characters.
+            // The user is responsible for checking the return value before using it.
+            //
+            // The 'New' variant will check that all the specified arguments are being
+            // consumed by the format and return NULL if any argument is being ignored.
+            // The 'NewAllowIgnored' variant will not verify this and will allow formats
+            // that ignore arguments.
+            static std::unique_ptr<ExtendedParsedFormat> New(string_view format)
+            {
+                return New(format, false);
+            }
+            static std::unique_ptr<ExtendedParsedFormat> NewAllowIgnored(
+                string_view format
+            )
+            {
+                return New(format, true);
+            }
+
+        private:
+            static std::unique_ptr<ExtendedParsedFormat> New(string_view format, bool allow_ignored)
+            {
+                std::unique_ptr<ExtendedParsedFormat> conv(
+                    new ExtendedParsedFormat(format, allow_ignored)
+                );
+                if (conv->has_error())
+                    return nullptr;
+                return conv;
+            }
+
+            ExtendedParsedFormat(string_view s, bool allow_ignored) :
+                ParsedFormatBase(s, allow_ignored, {C...})
+            {
+            }
+        };
+    }  // namespace str_format_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_join_internal.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_join_internal.h
index d97d503..f4ed31b 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_join_internal.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_join_internal.h
@@ -42,276 +42,318 @@
 #include "absl/strings/internal/resize_uninitialized.h"
 #include "absl/strings/str_cat.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-//
-// Formatter objects
-//
-// The following are implementation classes for standard Formatter objects. The
-// factory functions that users will call to create and use these formatters are
-// defined and documented in strings/join.h.
-//
-
-// The default formatter. Converts alpha-numeric types to strings.
-struct AlphaNumFormatterImpl {
-  // This template is needed in order to support passing in a dereferenced
-  // vector<bool>::iterator
-  template <typename T>
-  void operator()(std::string* out, const T& t) const {
-    StrAppend(out, AlphaNum(t));
-  }
-
-  void operator()(std::string* out, const AlphaNum& t) const {
-    StrAppend(out, t);
-  }
-};
-
-// A type that's used to overload the JoinAlgorithm() function (defined below)
-// for ranges that do not require additional formatting (e.g., a range of
-// strings).
-
-struct NoFormatter : public AlphaNumFormatterImpl {};
-
-// Formats types to strings using the << operator.
-class StreamFormatterImpl {
- public:
-  // The method isn't const because it mutates state. Making it const will
-  // render StreamFormatterImpl thread-hostile.
-  template <typename T>
-  void operator()(std::string* out, const T& t) {
-    // The stream is created lazily to avoid paying the relatively high cost
-    // of its construction when joining an empty range.
-    if (strm_) {
-      strm_->clear();  // clear the bad, fail and eof bits in case they were set
-      strm_->str(out);
-    } else {
-      strm_.reset(new strings_internal::OStringStream(out));
-    }
-    *strm_ << t;
-  }
-
- private:
-  std::unique_ptr<strings_internal::OStringStream> strm_;
-};
-
-// Formats a std::pair<>. The 'first' member is formatted using f1_ and the
-// 'second' member is formatted using f2_. sep_ is the separator.
-template <typename F1, typename F2>
-class PairFormatterImpl {
- public:
-  PairFormatterImpl(F1 f1, absl::string_view sep, F2 f2)
-      : f1_(std::move(f1)), sep_(sep), f2_(std::move(f2)) {}
-
-  template <typename T>
-  void operator()(std::string* out, const T& p) {
-    f1_(out, p.first);
-    out->append(sep_);
-    f2_(out, p.second);
-  }
-
-  template <typename T>
-  void operator()(std::string* out, const T& p) const {
-    f1_(out, p.first);
-    out->append(sep_);
-    f2_(out, p.second);
-  }
-
- private:
-  F1 f1_;
-  std::string sep_;
-  F2 f2_;
-};
-
-// Wraps another formatter and dereferences the argument to operator() then
-// passes the dereferenced argument to the wrapped formatter. This can be
-// useful, for example, to join a std::vector<int*>.
-template <typename Formatter>
-class DereferenceFormatterImpl {
- public:
-  DereferenceFormatterImpl() : f_() {}
-  explicit DereferenceFormatterImpl(Formatter&& f)
-      : f_(std::forward<Formatter>(f)) {}
-
-  template <typename T>
-  void operator()(std::string* out, const T& t) {
-    f_(out, *t);
-  }
-
-  template <typename T>
-  void operator()(std::string* out, const T& t) const {
-    f_(out, *t);
-  }
-
- private:
-  Formatter f_;
-};
-
-// DefaultFormatter<T> is a traits class that selects a default Formatter to use
-// for the given type T. The ::Type member names the Formatter to use. This is
-// used by the strings::Join() functions that do NOT take a Formatter argument,
-// in which case a default Formatter must be chosen.
-//
-// AlphaNumFormatterImpl is the default in the base template, followed by
-// specializations for other types.
-template <typename ValueType>
-struct DefaultFormatter {
-  typedef AlphaNumFormatterImpl Type;
-};
-template <>
-struct DefaultFormatter<const char*> {
-  typedef AlphaNumFormatterImpl Type;
-};
-template <>
-struct DefaultFormatter<char*> {
-  typedef AlphaNumFormatterImpl Type;
-};
-template <>
-struct DefaultFormatter<std::string> {
-  typedef NoFormatter Type;
-};
-template <>
-struct DefaultFormatter<absl::string_view> {
-  typedef NoFormatter Type;
-};
-template <typename ValueType>
-struct DefaultFormatter<ValueType*> {
-  typedef DereferenceFormatterImpl<typename DefaultFormatter<ValueType>::Type>
-      Type;
-};
-
-template <typename ValueType>
-struct DefaultFormatter<std::unique_ptr<ValueType>>
-    : public DefaultFormatter<ValueType*> {};
-
-//
-// JoinAlgorithm() functions
-//
-
-// The main joining algorithm. This simply joins the elements in the given
-// iterator range, each separated by the given separator, into an output string,
-// and formats each element using the provided Formatter object.
-template <typename Iterator, typename Formatter>
-std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
-                          Formatter&& f) {
-  std::string result;
-  absl::string_view sep("");
-  for (Iterator it = start; it != end; ++it) {
-    result.append(sep.data(), sep.size());
-    f(&result, *it);
-    sep = s;
-  }
-  return result;
-}
-
-// A joining algorithm that's optimized for a forward iterator range of
-// string-like objects that do not need any additional formatting. This is to
-// optimize the common case of joining, say, a std::vector<string> or a
-// std::vector<absl::string_view>.
-//
-// This is an overload of the previous JoinAlgorithm() function. Here the
-// Formatter argument is of type NoFormatter. Since NoFormatter is an internal
-// type, this overload is only invoked when strings::Join() is called with a
-// range of string-like objects (e.g., std::string, absl::string_view), and an
-// explicit Formatter argument was NOT specified.
-//
-// The optimization is that the needed space will be reserved in the output
-// string to avoid the need to resize while appending. To do this, the iterator
-// range will be traversed twice: once to calculate the total needed size, and
-// then again to copy the elements and delimiters to the output string.
-template <typename Iterator,
-          typename = typename std::enable_if<std::is_convertible<
-              typename std::iterator_traits<Iterator>::iterator_category,
-              std::forward_iterator_tag>::value>::type>
-std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
-                          NoFormatter) {
-  std::string result;
-  if (start != end) {
-    // Sums size
-    auto&& start_value = *start;
-    size_t result_size = start_value.size();
-    for (Iterator it = start; ++it != end;) {
-      result_size += s.size();
-      result_size += (*it).size();
-    }
-
-    if (result_size > 0) {
-      STLStringResizeUninitialized(&result, result_size);
-
-      // Joins strings
-      char* result_buf = &*result.begin();
-
-      memcpy(result_buf, start_value.data(), start_value.size());
-      result_buf += start_value.size();
-      for (Iterator it = start; ++it != end;) {
-        memcpy(result_buf, s.data(), s.size());
-        result_buf += s.size();
-        auto&& value = *it;
-        memcpy(result_buf, value.data(), value.size());
-        result_buf += value.size();
-      }
-    }
-  }
-
-  return result;
-}
-
-// JoinTupleLoop implements a loop over the elements of a std::tuple, which
-// are heterogeneous. The primary template matches the tuple interior case. It
-// continues the iteration after appending a separator (for nonzero indices)
-// and formatting an element of the tuple. The specialization for the I=N case
-// matches the end-of-tuple, and terminates the iteration.
-template <size_t I, size_t N>
-struct JoinTupleLoop {
-  template <typename Tup, typename Formatter>
-  void operator()(std::string* out, const Tup& tup, absl::string_view sep,
-                  Formatter&& fmt) {
-    if (I > 0) out->append(sep.data(), sep.size());
-    fmt(out, std::get<I>(tup));
-    JoinTupleLoop<I + 1, N>()(out, tup, sep, fmt);
-  }
-};
-template <size_t N>
-struct JoinTupleLoop<N, N> {
-  template <typename Tup, typename Formatter>
-  void operator()(std::string*, const Tup&, absl::string_view, Formatter&&) {}
-};
-
-template <typename... T, typename Formatter>
-std::string JoinAlgorithm(const std::tuple<T...>& tup, absl::string_view sep,
-                          Formatter&& fmt) {
-  std::string result;
-  JoinTupleLoop<0, sizeof...(T)>()(&result, tup, sep, fmt);
-  return result;
-}
-
-template <typename Iterator>
-std::string JoinRange(Iterator first, Iterator last,
-                      absl::string_view separator) {
-  // No formatter was explicitly given, so a default must be chosen.
-  typedef typename std::iterator_traits<Iterator>::value_type ValueType;
-  typedef typename DefaultFormatter<ValueType>::Type Formatter;
-  return JoinAlgorithm(first, last, separator, Formatter());
-}
-
-template <typename Range, typename Formatter>
-std::string JoinRange(const Range& range, absl::string_view separator,
-                      Formatter&& fmt) {
-  using std::begin;
-  using std::end;
-  return JoinAlgorithm(begin(range), end(range), separator, fmt);
-}
-
-template <typename Range>
-std::string JoinRange(const Range& range, absl::string_view separator) {
-  using std::begin;
-  using std::end;
-  return JoinRange(begin(range), end(range), separator);
-}
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        //
+        // Formatter objects
+        //
+        // The following are implementation classes for standard Formatter objects. The
+        // factory functions that users will call to create and use these formatters are
+        // defined and documented in strings/join.h.
+        //
+
+        // The default formatter. Converts alpha-numeric types to strings.
+        struct AlphaNumFormatterImpl
+        {
+            // This template is needed in order to support passing in a dereferenced
+            // vector<bool>::iterator
+            template<typename T>
+            void operator()(std::string* out, const T& t) const
+            {
+                StrAppend(out, AlphaNum(t));
+            }
+
+            void operator()(std::string* out, const AlphaNum& t) const
+            {
+                StrAppend(out, t);
+            }
+        };
+
+        // A type that's used to overload the JoinAlgorithm() function (defined below)
+        // for ranges that do not require additional formatting (e.g., a range of
+        // strings).
+
+        struct NoFormatter : public AlphaNumFormatterImpl
+        {
+        };
+
+        // Formats types to strings using the << operator.
+        class StreamFormatterImpl
+        {
+        public:
+            // The method isn't const because it mutates state. Making it const will
+            // render StreamFormatterImpl thread-hostile.
+            template<typename T>
+            void operator()(std::string* out, const T& t)
+            {
+                // The stream is created lazily to avoid paying the relatively high cost
+                // of its construction when joining an empty range.
+                if (strm_)
+                {
+                    strm_->clear();  // clear the bad, fail and eof bits in case they were set
+                    strm_->str(out);
+                }
+                else
+                {
+                    strm_.reset(new strings_internal::OStringStream(out));
+                }
+                *strm_ << t;
+            }
+
+        private:
+            std::unique_ptr<strings_internal::OStringStream> strm_;
+        };
+
+        // Formats a std::pair<>. The 'first' member is formatted using f1_ and the
+        // 'second' member is formatted using f2_. sep_ is the separator.
+        template<typename F1, typename F2>
+        class PairFormatterImpl
+        {
+        public:
+            PairFormatterImpl(F1 f1, absl::string_view sep, F2 f2) :
+                f1_(std::move(f1)),
+                sep_(sep),
+                f2_(std::move(f2))
+            {
+            }
+
+            template<typename T>
+            void operator()(std::string* out, const T& p)
+            {
+                f1_(out, p.first);
+                out->append(sep_);
+                f2_(out, p.second);
+            }
+
+            template<typename T>
+            void operator()(std::string* out, const T& p) const
+            {
+                f1_(out, p.first);
+                out->append(sep_);
+                f2_(out, p.second);
+            }
+
+        private:
+            F1 f1_;
+            std::string sep_;
+            F2 f2_;
+        };
+
+        // Wraps another formatter and dereferences the argument to operator() then
+        // passes the dereferenced argument to the wrapped formatter. This can be
+        // useful, for example, to join a std::vector<int*>.
+        template<typename Formatter>
+        class DereferenceFormatterImpl
+        {
+        public:
+            DereferenceFormatterImpl() :
+                f_()
+            {
+            }
+            explicit DereferenceFormatterImpl(Formatter&& f) :
+                f_(std::forward<Formatter>(f))
+            {
+            }
+
+            template<typename T>
+            void operator()(std::string* out, const T& t)
+            {
+                f_(out, *t);
+            }
+
+            template<typename T>
+            void operator()(std::string* out, const T& t) const
+            {
+                f_(out, *t);
+            }
+
+        private:
+            Formatter f_;
+        };
+
+        // DefaultFormatter<T> is a traits class that selects a default Formatter to use
+        // for the given type T. The ::Type member names the Formatter to use. This is
+        // used by the strings::Join() functions that do NOT take a Formatter argument,
+        // in which case a default Formatter must be chosen.
+        //
+        // AlphaNumFormatterImpl is the default in the base template, followed by
+        // specializations for other types.
+        template<typename ValueType>
+        struct DefaultFormatter
+        {
+            typedef AlphaNumFormatterImpl Type;
+        };
+        template<>
+        struct DefaultFormatter<const char*>
+        {
+            typedef AlphaNumFormatterImpl Type;
+        };
+        template<>
+        struct DefaultFormatter<char*>
+        {
+            typedef AlphaNumFormatterImpl Type;
+        };
+        template<>
+        struct DefaultFormatter<std::string>
+        {
+            typedef NoFormatter Type;
+        };
+        template<>
+        struct DefaultFormatter<absl::string_view>
+        {
+            typedef NoFormatter Type;
+        };
+        template<typename ValueType>
+        struct DefaultFormatter<ValueType*>
+        {
+            typedef DereferenceFormatterImpl<typename DefaultFormatter<ValueType>::Type>
+                Type;
+        };
+
+        template<typename ValueType>
+        struct DefaultFormatter<std::unique_ptr<ValueType>> : public DefaultFormatter<ValueType*>
+        {
+        };
+
+        //
+        // JoinAlgorithm() functions
+        //
+
+        // The main joining algorithm. This simply joins the elements in the given
+        // iterator range, each separated by the given separator, into an output string,
+        // and formats each element using the provided Formatter object.
+        template<typename Iterator, typename Formatter>
+        std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s, Formatter&& f)
+        {
+            std::string result;
+            absl::string_view sep("");
+            for (Iterator it = start; it != end; ++it)
+            {
+                result.append(sep.data(), sep.size());
+                f(&result, *it);
+                sep = s;
+            }
+            return result;
+        }
+
+        // A joining algorithm that's optimized for a forward iterator range of
+        // string-like objects that do not need any additional formatting. This is to
+        // optimize the common case of joining, say, a std::vector<string> or a
+        // std::vector<absl::string_view>.
+        //
+        // This is an overload of the previous JoinAlgorithm() function. Here the
+        // Formatter argument is of type NoFormatter. Since NoFormatter is an internal
+        // type, this overload is only invoked when strings::Join() is called with a
+        // range of string-like objects (e.g., std::string, absl::string_view), and an
+        // explicit Formatter argument was NOT specified.
+        //
+        // The optimization is that the needed space will be reserved in the output
+        // string to avoid the need to resize while appending. To do this, the iterator
+        // range will be traversed twice: once to calculate the total needed size, and
+        // then again to copy the elements and delimiters to the output string.
+        template<typename Iterator, typename = typename std::enable_if<std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value>::type>
+        std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s, NoFormatter)
+        {
+            std::string result;
+            if (start != end)
+            {
+                // Sums size
+                auto&& start_value = *start;
+                size_t result_size = start_value.size();
+                for (Iterator it = start; ++it != end;)
+                {
+                    result_size += s.size();
+                    result_size += (*it).size();
+                }
+
+                if (result_size > 0)
+                {
+                    STLStringResizeUninitialized(&result, result_size);
+
+                    // Joins strings
+                    char* result_buf = &*result.begin();
+
+                    memcpy(result_buf, start_value.data(), start_value.size());
+                    result_buf += start_value.size();
+                    for (Iterator it = start; ++it != end;)
+                    {
+                        memcpy(result_buf, s.data(), s.size());
+                        result_buf += s.size();
+                        auto&& value = *it;
+                        memcpy(result_buf, value.data(), value.size());
+                        result_buf += value.size();
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        // JoinTupleLoop implements a loop over the elements of a std::tuple, which
+        // are heterogeneous. The primary template matches the tuple interior case. It
+        // continues the iteration after appending a separator (for nonzero indices)
+        // and formatting an element of the tuple. The specialization for the I=N case
+        // matches the end-of-tuple, and terminates the iteration.
+        template<size_t I, size_t N>
+        struct JoinTupleLoop
+        {
+            template<typename Tup, typename Formatter>
+            void operator()(std::string* out, const Tup& tup, absl::string_view sep, Formatter&& fmt)
+            {
+                if (I > 0)
+                    out->append(sep.data(), sep.size());
+                fmt(out, std::get<I>(tup));
+                JoinTupleLoop<I + 1, N>()(out, tup, sep, fmt);
+            }
+        };
+        template<size_t N>
+        struct JoinTupleLoop<N, N>
+        {
+            template<typename Tup, typename Formatter>
+            void operator()(std::string*, const Tup&, absl::string_view, Formatter&&)
+            {
+            }
+        };
+
+        template<typename... T, typename Formatter>
+        std::string JoinAlgorithm(const std::tuple<T...>& tup, absl::string_view sep, Formatter&& fmt)
+        {
+            std::string result;
+            JoinTupleLoop<0, sizeof...(T)>()(&result, tup, sep, fmt);
+            return result;
+        }
+
+        template<typename Iterator>
+        std::string JoinRange(Iterator first, Iterator last, absl::string_view separator)
+        {
+            // No formatter was explicitly given, so a default must be chosen.
+            typedef typename std::iterator_traits<Iterator>::value_type ValueType;
+            typedef typename DefaultFormatter<ValueType>::Type Formatter;
+            return JoinAlgorithm(first, last, separator, Formatter());
+        }
+
+        template<typename Range, typename Formatter>
+        std::string JoinRange(const Range& range, absl::string_view separator, Formatter&& fmt)
+        {
+            using std::begin;
+            using std::end;
+            return JoinAlgorithm(begin(range), end(range), separator, fmt);
+        }
+
+        template<typename Range>
+        std::string JoinRange(const Range& range, absl::string_view separator)
+        {
+            using std::begin;
+            using std::end;
+            return JoinRange(begin(range), end(range), separator);
+        }
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/str_split_internal.h b/CAPI/cpp/grpc/include/absl/strings/internal/str_split_internal.h
index e766421..e7c8423 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/str_split_internal.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/str_split_internal.h
@@ -46,385 +46,485 @@
 #include "absl/strings/internal/stl_type_traits.h"
 #endif  // _GLIBCXX_DEBUG
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// This class is implicitly constructible from everything that absl::string_view
-// is implicitly constructible from, except for rvalue strings.  This means it
-// can be used as a function parameter in places where passing a temporary
-// string might cause memory lifetime issues.
-class ConvertibleToStringView {
- public:
-  ConvertibleToStringView(const char* s)  // NOLINT(runtime/explicit)
-      : value_(s) {}
-  ConvertibleToStringView(char* s) : value_(s) {}  // NOLINT(runtime/explicit)
-  ConvertibleToStringView(absl::string_view s)     // NOLINT(runtime/explicit)
-      : value_(s) {}
-  ConvertibleToStringView(const std::string& s)  // NOLINT(runtime/explicit)
-      : value_(s) {}
-
-  // Disable conversion from rvalue strings.
-  ConvertibleToStringView(std::string&& s) = delete;
-  ConvertibleToStringView(const std::string&& s) = delete;
-
-  absl::string_view value() const { return value_; }
-
- private:
-  absl::string_view value_;
-};
-
-// An iterator that enumerates the parts of a string from a Splitter. The text
-// to be split, the Delimiter, and the Predicate are all taken from the given
-// Splitter object. Iterators may only be compared if they refer to the same
-// Splitter instance.
-//
-// This class is NOT part of the public splitting API.
-template <typename Splitter>
-class SplitIterator {
- public:
-  using iterator_category = std::input_iterator_tag;
-  using value_type = absl::string_view;
-  using difference_type = ptrdiff_t;
-  using pointer = const value_type*;
-  using reference = const value_type&;
-
-  enum State { kInitState, kLastState, kEndState };
-  SplitIterator(State state, const Splitter* splitter)
-      : pos_(0),
-        state_(state),
-        splitter_(splitter),
-        delimiter_(splitter->delimiter()),
-        predicate_(splitter->predicate()) {
-    // Hack to maintain backward compatibility. This one block makes it so an
-    // empty absl::string_view whose .data() happens to be nullptr behaves
-    // *differently* from an otherwise empty absl::string_view whose .data() is
-    // not nullptr. This is an undesirable difference in general, but this
-    // behavior is maintained to avoid breaking existing code that happens to
-    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
-    // difference in behavior is as follows:
-    //   Split(absl::string_view(""), '-');  // {""}
-    //   Split(absl::string_view(), '-');    // {}
-    if (splitter_->text().data() == nullptr) {
-      state_ = kEndState;
-      pos_ = splitter_->text().size();
-      return;
-    }
-
-    if (state_ == kEndState) {
-      pos_ = splitter_->text().size();
-    } else {
-      ++(*this);
-    }
-  }
-
-  bool at_end() const { return state_ == kEndState; }
-
-  reference operator*() const { return curr_; }
-  pointer operator->() const { return &curr_; }
-
-  SplitIterator& operator++() {
-    do {
-      if (state_ == kLastState) {
-        state_ = kEndState;
-        return *this;
-      }
-      const absl::string_view text = splitter_->text();
-      const absl::string_view d = delimiter_.Find(text, pos_);
-      if (d.data() == text.data() + text.size()) state_ = kLastState;
-      curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
-      pos_ += curr_.size() + d.size();
-    } while (!predicate_(curr_));
-    return *this;
-  }
-
-  SplitIterator operator++(int) {
-    SplitIterator old(*this);
-    ++(*this);
-    return old;
-  }
-
-  friend bool operator==(const SplitIterator& a, const SplitIterator& b) {
-    return a.state_ == b.state_ && a.pos_ == b.pos_;
-  }
-
-  friend bool operator!=(const SplitIterator& a, const SplitIterator& b) {
-    return !(a == b);
-  }
-
- private:
-  size_t pos_;
-  State state_;
-  absl::string_view curr_;
-  const Splitter* splitter_;
-  typename Splitter::DelimiterType delimiter_;
-  typename Splitter::PredicateType predicate_;
-};
-
-// HasMappedType<T>::value is true iff there exists a type T::mapped_type.
-template <typename T, typename = void>
-struct HasMappedType : std::false_type {};
-template <typename T>
-struct HasMappedType<T, absl::void_t<typename T::mapped_type>>
-    : std::true_type {};
-
-// HasValueType<T>::value is true iff there exists a type T::value_type.
-template <typename T, typename = void>
-struct HasValueType : std::false_type {};
-template <typename T>
-struct HasValueType<T, absl::void_t<typename T::value_type>> : std::true_type {
-};
-
-// HasConstIterator<T>::value is true iff there exists a type T::const_iterator.
-template <typename T, typename = void>
-struct HasConstIterator : std::false_type {};
-template <typename T>
-struct HasConstIterator<T, absl::void_t<typename T::const_iterator>>
-    : std::true_type {};
-
-// HasEmplace<T>::value is true iff there exists a method T::emplace().
-template <typename T, typename = void>
-struct HasEmplace : std::false_type {};
-template <typename T>
-struct HasEmplace<T, absl::void_t<decltype(std::declval<T>().emplace())>>
-    : std::true_type {};
-
-// IsInitializerList<T>::value is true iff T is an std::initializer_list. More
-// details below in Splitter<> where this is used.
-std::false_type IsInitializerListDispatch(...);  // default: No
-template <typename T>
-std::true_type IsInitializerListDispatch(std::initializer_list<T>*);
-template <typename T>
-struct IsInitializerList
-    : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr))) {};
-
-// A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition
-// is true for type 'C'.
-//
-// Restricts conversion to container-like types (by testing for the presence of
-// a const_iterator member type) and also to disable conversion to an
-// std::initializer_list (which also has a const_iterator). Otherwise, code
-// compiled in C++11 will get an error due to ambiguous conversion paths (in
-// C++11 std::vector<T>::operator= is overloaded to take either a std::vector<T>
-// or an std::initializer_list<T>).
-
-template <typename C, bool has_value_type, bool has_mapped_type>
-struct SplitterIsConvertibleToImpl : std::false_type {};
-
-template <typename C>
-struct SplitterIsConvertibleToImpl<C, true, false>
-    : std::is_constructible<typename C::value_type, absl::string_view> {};
-
-template <typename C>
-struct SplitterIsConvertibleToImpl<C, true, true>
-    : absl::conjunction<
-          std::is_constructible<typename C::key_type, absl::string_view>,
-          std::is_constructible<typename C::mapped_type, absl::string_view>> {};
-
-template <typename C>
-struct SplitterIsConvertibleTo
-    : SplitterIsConvertibleToImpl<
-          C,
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
+
+        // This class is implicitly constructible from everything that absl::string_view
+        // is implicitly constructible from, except for rvalue strings.  This means it
+        // can be used as a function parameter in places where passing a temporary
+        // string might cause memory lifetime issues.
+        class ConvertibleToStringView
+        {
+        public:
+            ConvertibleToStringView(const char* s)  // NOLINT(runtime/explicit)
+                :
+                value_(s)
+            {
+            }
+            ConvertibleToStringView(char* s) :
+                value_(s)
+            {
+            }                                             // NOLINT(runtime/explicit)
+            ConvertibleToStringView(absl::string_view s)  // NOLINT(runtime/explicit)
+                :
+                value_(s)
+            {
+            }
+            ConvertibleToStringView(const std::string& s)  // NOLINT(runtime/explicit)
+                :
+                value_(s)
+            {
+            }
+
+            // Disable conversion from rvalue strings.
+            ConvertibleToStringView(std::string&& s) = delete;
+            ConvertibleToStringView(const std::string&& s) = delete;
+
+            absl::string_view value() const
+            {
+                return value_;
+            }
+
+        private:
+            absl::string_view value_;
+        };
+
+        // An iterator that enumerates the parts of a string from a Splitter. The text
+        // to be split, the Delimiter, and the Predicate are all taken from the given
+        // Splitter object. Iterators may only be compared if they refer to the same
+        // Splitter instance.
+        //
+        // This class is NOT part of the public splitting API.
+        template<typename Splitter>
+        class SplitIterator
+        {
+        public:
+            using iterator_category = std::input_iterator_tag;
+            using value_type = absl::string_view;
+            using difference_type = ptrdiff_t;
+            using pointer = const value_type*;
+            using reference = const value_type&;
+
+            enum State
+            {
+                kInitState,
+                kLastState,
+                kEndState
+            };
+            SplitIterator(State state, const Splitter* splitter) :
+                pos_(0),
+                state_(state),
+                splitter_(splitter),
+                delimiter_(splitter->delimiter()),
+                predicate_(splitter->predicate())
+            {
+                // Hack to maintain backward compatibility. This one block makes it so an
+                // empty absl::string_view whose .data() happens to be nullptr behaves
+                // *differently* from an otherwise empty absl::string_view whose .data() is
+                // not nullptr. This is an undesirable difference in general, but this
+                // behavior is maintained to avoid breaking existing code that happens to
+                // depend on this old behavior/bug. Perhaps it will be fixed one day. The
+                // difference in behavior is as follows:
+                //   Split(absl::string_view(""), '-');  // {""}
+                //   Split(absl::string_view(), '-');    // {}
+                if (splitter_->text().data() == nullptr)
+                {
+                    state_ = kEndState;
+                    pos_ = splitter_->text().size();
+                    return;
+                }
+
+                if (state_ == kEndState)
+                {
+                    pos_ = splitter_->text().size();
+                }
+                else
+                {
+                    ++(*this);
+                }
+            }
+
+            bool at_end() const
+            {
+                return state_ == kEndState;
+            }
+
+            reference operator*() const
+            {
+                return curr_;
+            }
+            pointer operator->() const
+            {
+                return &curr_;
+            }
+
+            SplitIterator& operator++()
+            {
+                do
+                {
+                    if (state_ == kLastState)
+                    {
+                        state_ = kEndState;
+                        return *this;
+                    }
+                    const absl::string_view text = splitter_->text();
+                    const absl::string_view d = delimiter_.Find(text, pos_);
+                    if (d.data() == text.data() + text.size())
+                        state_ = kLastState;
+                    curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
+                    pos_ += curr_.size() + d.size();
+                } while (!predicate_(curr_));
+                return *this;
+            }
+
+            SplitIterator operator++(int)
+            {
+                SplitIterator old(*this);
+                ++(*this);
+                return old;
+            }
+
+            friend bool operator==(const SplitIterator& a, const SplitIterator& b)
+            {
+                return a.state_ == b.state_ && a.pos_ == b.pos_;
+            }
+
+            friend bool operator!=(const SplitIterator& a, const SplitIterator& b)
+            {
+                return !(a == b);
+            }
+
+        private:
+            size_t pos_;
+            State state_;
+            absl::string_view curr_;
+            const Splitter* splitter_;
+            typename Splitter::DelimiterType delimiter_;
+            typename Splitter::PredicateType predicate_;
+        };
+
+        // HasMappedType<T>::value is true iff there exists a type T::mapped_type.
+        template<typename T, typename = void>
+        struct HasMappedType : std::false_type
+        {
+        };
+        template<typename T>
+        struct HasMappedType<T, absl::void_t<typename T::mapped_type>> : std::true_type
+        {
+        };
+
+        // HasValueType<T>::value is true iff there exists a type T::value_type.
+        template<typename T, typename = void>
+        struct HasValueType : std::false_type
+        {
+        };
+        template<typename T>
+        struct HasValueType<T, absl::void_t<typename T::value_type>> : std::true_type
+        {
+        };
+
+        // HasConstIterator<T>::value is true iff there exists a type T::const_iterator.
+        template<typename T, typename = void>
+        struct HasConstIterator : std::false_type
+        {
+        };
+        template<typename T>
+        struct HasConstIterator<T, absl::void_t<typename T::const_iterator>> : std::true_type
+        {
+        };
+
+        // HasEmplace<T>::value is true iff there exists a method T::emplace().
+        template<typename T, typename = void>
+        struct HasEmplace : std::false_type
+        {
+        };
+        template<typename T>
+        struct HasEmplace<T, absl::void_t<decltype(std::declval<T>().emplace())>> : std::true_type
+        {
+        };
+
+        // IsInitializerList<T>::value is true iff T is an std::initializer_list. More
+        // details below in Splitter<> where this is used.
+        std::false_type IsInitializerListDispatch(...);  // default: No
+        template<typename T>
+        std::true_type IsInitializerListDispatch(std::initializer_list<T>*);
+        template<typename T>
+        struct IsInitializerList : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr)))
+        {
+        };
+
+        // A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition
+        // is true for type 'C'.
+        //
+        // Restricts conversion to container-like types (by testing for the presence of
+        // a const_iterator member type) and also to disable conversion to an
+        // std::initializer_list (which also has a const_iterator). Otherwise, code
+        // compiled in C++11 will get an error due to ambiguous conversion paths (in
+        // C++11 std::vector<T>::operator= is overloaded to take either a std::vector<T>
+        // or an std::initializer_list<T>).
+
+        template<typename C, bool has_value_type, bool has_mapped_type>
+        struct SplitterIsConvertibleToImpl : std::false_type
+        {
+        };
+
+        template<typename C>
+        struct SplitterIsConvertibleToImpl<C, true, false> : std::is_constructible<typename C::value_type, absl::string_view>
+        {
+        };
+
+        template<typename C>
+        struct SplitterIsConvertibleToImpl<C, true, true> : absl::conjunction<std::is_constructible<typename C::key_type, absl::string_view>, std::is_constructible<typename C::mapped_type, absl::string_view>>
+        {
+        };
+
+        template<typename C>
+        struct SplitterIsConvertibleTo : SplitterIsConvertibleToImpl<C,
 #ifdef _GLIBCXX_DEBUG
-          !IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value &&
+                                                                     !IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value &&
 #endif  // _GLIBCXX_DEBUG
-              !IsInitializerList<
-                  typename std::remove_reference<C>::type>::value &&
-              HasValueType<C>::value && HasConstIterator<C>::value,
-          HasMappedType<C>::value> {
-};
-
-// This class implements the range that is returned by absl::StrSplit(). This
-// class has templated conversion operators that allow it to be implicitly
-// converted to a variety of types that the caller may have specified on the
-// left-hand side of an assignment.
-//
-// The main interface for interacting with this class is through its implicit
-// conversion operators. However, this class may also be used like a container
-// in that it has .begin() and .end() member functions. It may also be used
-// within a range-for loop.
-//
-// Output containers can be collections of any type that is constructible from
-// an absl::string_view.
-//
-// An Predicate functor may be supplied. This predicate will be used to filter
-// the split strings: only strings for which the predicate returns true will be
-// kept. A Predicate object is any unary functor that takes an absl::string_view
-// and returns bool.
-//
-// The StringType parameter can be either string_view or string, depending on
-// whether the Splitter refers to a string stored elsewhere, or if the string
-// resides inside the Splitter itself.
-template <typename Delimiter, typename Predicate, typename StringType>
-class Splitter {
- public:
-  using DelimiterType = Delimiter;
-  using PredicateType = Predicate;
-  using const_iterator = strings_internal::SplitIterator<Splitter>;
-  using value_type = typename std::iterator_traits<const_iterator>::value_type;
-
-  Splitter(StringType input_text, Delimiter d, Predicate p)
-      : text_(std::move(input_text)),
-        delimiter_(std::move(d)),
-        predicate_(std::move(p)) {}
-
-  absl::string_view text() const { return text_; }
-  const Delimiter& delimiter() const { return delimiter_; }
-  const Predicate& predicate() const { return predicate_; }
-
-  // Range functions that iterate the split substrings as absl::string_view
-  // objects. These methods enable a Splitter to be used in a range-based for
-  // loop.
-  const_iterator begin() const { return {const_iterator::kInitState, this}; }
-  const_iterator end() const { return {const_iterator::kEndState, this}; }
-
-  // An implicit conversion operator that is restricted to only those containers
-  // that the splitter is convertible to.
-  template <typename Container,
-            typename = typename std::enable_if<
-                SplitterIsConvertibleTo<Container>::value>::type>
-  operator Container() const {  // NOLINT(runtime/explicit)
-    return ConvertToContainer<Container, typename Container::value_type,
-                              HasMappedType<Container>::value>()(*this);
-  }
-
-  // Returns a pair with its .first and .second members set to the first two
-  // strings returned by the begin() iterator. Either/both of .first and .second
-  // will be constructed with empty strings if the iterator doesn't have a
-  // corresponding value.
-  template <typename First, typename Second>
-  operator std::pair<First, Second>() const {  // NOLINT(runtime/explicit)
-    absl::string_view first, second;
-    auto it = begin();
-    if (it != end()) {
-      first = *it;
-      if (++it != end()) {
-        second = *it;
-      }
-    }
-    return {First(first), Second(second)};
-  }
-
- private:
-  // ConvertToContainer is a functor converting a Splitter to the requested
-  // Container of ValueType. It is specialized below to optimize splitting to
-  // certain combinations of Container and ValueType.
-  //
-  // This base template handles the generic case of storing the split results in
-  // the requested non-map-like container and converting the split substrings to
-  // the requested type.
-  template <typename Container, typename ValueType, bool is_map = false>
-  struct ConvertToContainer {
-    Container operator()(const Splitter& splitter) const {
-      Container c;
-      auto it = std::inserter(c, c.end());
-      for (const auto& sp : splitter) {
-        *it++ = ValueType(sp);
-      }
-      return c;
-    }
-  };
-
-  // Partial specialization for a std::vector<absl::string_view>.
-  //
-  // Optimized for the common case of splitting to a
-  // std::vector<absl::string_view>. In this case we first split the results to
-  // a small array of absl::string_view on the stack, to reduce reallocations.
-  template <typename A>
-  struct ConvertToContainer<std::vector<absl::string_view, A>,
-                            absl::string_view, false> {
-    std::vector<absl::string_view, A> operator()(
-        const Splitter& splitter) const {
-      struct raw_view {
-        const char* data;
-        size_t size;
-        operator absl::string_view() const {  // NOLINT(runtime/explicit)
-          return {data, size};
-        }
-      };
-      std::vector<absl::string_view, A> v;
-      std::array<raw_view, 16> ar;
-      for (auto it = splitter.begin(); !it.at_end();) {
-        size_t index = 0;
-        do {
-          ar[index].data = it->data();
-          ar[index].size = it->size();
-          ++it;
-        } while (++index != ar.size() && !it.at_end());
-        v.insert(v.end(), ar.begin(), ar.begin() + index);
-      }
-      return v;
-    }
-  };
-
-  // Partial specialization for a std::vector<std::string>.
-  //
-  // Optimized for the common case of splitting to a std::vector<std::string>.
-  // In this case we first split the results to a std::vector<absl::string_view>
-  // so the returned std::vector<std::string> can have space reserved to avoid
-  // std::string moves.
-  template <typename A>
-  struct ConvertToContainer<std::vector<std::string, A>, std::string, false> {
-    std::vector<std::string, A> operator()(const Splitter& splitter) const {
-      const std::vector<absl::string_view> v = splitter;
-      return std::vector<std::string, A>(v.begin(), v.end());
-    }
-  };
-
-  // Partial specialization for containers of pairs (e.g., maps).
-  //
-  // The algorithm is to insert a new pair into the map for each even-numbered
-  // item, with the even-numbered item as the key with a default-constructed
-  // value. Each odd-numbered item will then be assigned to the last pair's
-  // value.
-  template <typename Container, typename First, typename Second>
-  struct ConvertToContainer<Container, std::pair<const First, Second>, true> {
-    using iterator = typename Container::iterator;
-
-    Container operator()(const Splitter& splitter) const {
-      Container m;
-      iterator it;
-      bool insert = true;
-      for (const absl::string_view sv : splitter) {
-        if (insert) {
-          it = InsertOrEmplace(&m, sv);
-        } else {
-          it->second = Second(sv);
-        }
-        insert = !insert;
-      }
-      return m;
-    }
-
-    // Inserts the key and an empty value into the map, returning an iterator to
-    // the inserted item. We use emplace() if available, otherwise insert().
-    template <typename M>
-    static absl::enable_if_t<HasEmplace<M>::value, iterator> InsertOrEmplace(
-        M* m, absl::string_view key) {
-      // Use piecewise_construct to support old versions of gcc in which pair
-      // constructor can't otherwise construct string from string_view.
-      return ToIter(m->emplace(std::piecewise_construct, std::make_tuple(key),
-                               std::tuple<>()));
-    }
-    template <typename M>
-    static absl::enable_if_t<!HasEmplace<M>::value, iterator> InsertOrEmplace(
-        M* m, absl::string_view key) {
-      return ToIter(m->insert(std::make_pair(First(key), Second(""))));
-    }
-
-    static iterator ToIter(std::pair<iterator, bool> pair) {
-      return pair.first;
-    }
-    static iterator ToIter(iterator iter) { return iter; }
-  };
-
-  StringType text_;
-  Delimiter delimiter_;
-  Predicate predicate_;
-};
-
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+                                                                         !IsInitializerList<typename std::remove_reference<C>::type>::value && HasValueType<C>::value && HasConstIterator<C>::value,
+                                                                     HasMappedType<C>::value>
+        {
+        };
+
+        // This class implements the range that is returned by absl::StrSplit(). This
+        // class has templated conversion operators that allow it to be implicitly
+        // converted to a variety of types that the caller may have specified on the
+        // left-hand side of an assignment.
+        //
+        // The main interface for interacting with this class is through its implicit
+        // conversion operators. However, this class may also be used like a container
+        // in that it has .begin() and .end() member functions. It may also be used
+        // within a range-for loop.
+        //
+        // Output containers can be collections of any type that is constructible from
+        // an absl::string_view.
+        //
+        // An Predicate functor may be supplied. This predicate will be used to filter
+        // the split strings: only strings for which the predicate returns true will be
+        // kept. A Predicate object is any unary functor that takes an absl::string_view
+        // and returns bool.
+        //
+        // The StringType parameter can be either string_view or string, depending on
+        // whether the Splitter refers to a string stored elsewhere, or if the string
+        // resides inside the Splitter itself.
+        template<typename Delimiter, typename Predicate, typename StringType>
+        class Splitter
+        {
+        public:
+            using DelimiterType = Delimiter;
+            using PredicateType = Predicate;
+            using const_iterator = strings_internal::SplitIterator<Splitter>;
+            using value_type = typename std::iterator_traits<const_iterator>::value_type;
+
+            Splitter(StringType input_text, Delimiter d, Predicate p) :
+                text_(std::move(input_text)),
+                delimiter_(std::move(d)),
+                predicate_(std::move(p))
+            {
+            }
+
+            absl::string_view text() const
+            {
+                return text_;
+            }
+            const Delimiter& delimiter() const
+            {
+                return delimiter_;
+            }
+            const Predicate& predicate() const
+            {
+                return predicate_;
+            }
+
+            // Range functions that iterate the split substrings as absl::string_view
+            // objects. These methods enable a Splitter to be used in a range-based for
+            // loop.
+            const_iterator begin() const
+            {
+                return {const_iterator::kInitState, this};
+            }
+            const_iterator end() const
+            {
+                return {const_iterator::kEndState, this};
+            }
+
+            // An implicit conversion operator that is restricted to only those containers
+            // that the splitter is convertible to.
+            template<typename Container, typename = typename std::enable_if<SplitterIsConvertibleTo<Container>::value>::type>
+            operator Container() const
+            {  // NOLINT(runtime/explicit)
+                return ConvertToContainer<Container, typename Container::value_type, HasMappedType<Container>::value>()(*this);
+            }
+
+            // Returns a pair with its .first and .second members set to the first two
+            // strings returned by the begin() iterator. Either/both of .first and .second
+            // will be constructed with empty strings if the iterator doesn't have a
+            // corresponding value.
+            template<typename First, typename Second>
+            operator std::pair<First, Second>() const
+            {  // NOLINT(runtime/explicit)
+                absl::string_view first, second;
+                auto it = begin();
+                if (it != end())
+                {
+                    first = *it;
+                    if (++it != end())
+                    {
+                        second = *it;
+                    }
+                }
+                return {First(first), Second(second)};
+            }
+
+        private:
+            // ConvertToContainer is a functor converting a Splitter to the requested
+            // Container of ValueType. It is specialized below to optimize splitting to
+            // certain combinations of Container and ValueType.
+            //
+            // This base template handles the generic case of storing the split results in
+            // the requested non-map-like container and converting the split substrings to
+            // the requested type.
+            template<typename Container, typename ValueType, bool is_map = false>
+            struct ConvertToContainer
+            {
+                Container operator()(const Splitter& splitter) const
+                {
+                    Container c;
+                    auto it = std::inserter(c, c.end());
+                    for (const auto& sp : splitter)
+                    {
+                        *it++ = ValueType(sp);
+                    }
+                    return c;
+                }
+            };
+
+            // Partial specialization for a std::vector<absl::string_view>.
+            //
+            // Optimized for the common case of splitting to a
+            // std::vector<absl::string_view>. In this case we first split the results to
+            // a small array of absl::string_view on the stack, to reduce reallocations.
+            template<typename A>
+            struct ConvertToContainer<std::vector<absl::string_view, A>, absl::string_view, false>
+            {
+                std::vector<absl::string_view, A> operator()(
+                    const Splitter& splitter
+                ) const
+                {
+                    struct raw_view
+                    {
+                        const char* data;
+                        size_t size;
+                        operator absl::string_view() const
+                        {  // NOLINT(runtime/explicit)
+                            return {data, size};
+                        }
+                    };
+                    std::vector<absl::string_view, A> v;
+                    std::array<raw_view, 16> ar;
+                    for (auto it = splitter.begin(); !it.at_end();)
+                    {
+                        size_t index = 0;
+                        do
+                        {
+                            ar[index].data = it->data();
+                            ar[index].size = it->size();
+                            ++it;
+                        } while (++index != ar.size() && !it.at_end());
+                        v.insert(v.end(), ar.begin(), ar.begin() + index);
+                    }
+                    return v;
+                }
+            };
+
+            // Partial specialization for a std::vector<std::string>.
+            //
+            // Optimized for the common case of splitting to a std::vector<std::string>.
+            // In this case we first split the results to a std::vector<absl::string_view>
+            // so the returned std::vector<std::string> can have space reserved to avoid
+            // std::string moves.
+            template<typename A>
+            struct ConvertToContainer<std::vector<std::string, A>, std::string, false>
+            {
+                std::vector<std::string, A> operator()(const Splitter& splitter) const
+                {
+                    const std::vector<absl::string_view> v = splitter;
+                    return std::vector<std::string, A>(v.begin(), v.end());
+                }
+            };
+
+            // Partial specialization for containers of pairs (e.g., maps).
+            //
+            // The algorithm is to insert a new pair into the map for each even-numbered
+            // item, with the even-numbered item as the key with a default-constructed
+            // value. Each odd-numbered item will then be assigned to the last pair's
+            // value.
+            template<typename Container, typename First, typename Second>
+            struct ConvertToContainer<Container, std::pair<const First, Second>, true>
+            {
+                using iterator = typename Container::iterator;
+
+                Container operator()(const Splitter& splitter) const
+                {
+                    Container m;
+                    iterator it;
+                    bool insert = true;
+                    for (const absl::string_view sv : splitter)
+                    {
+                        if (insert)
+                        {
+                            it = InsertOrEmplace(&m, sv);
+                        }
+                        else
+                        {
+                            it->second = Second(sv);
+                        }
+                        insert = !insert;
+                    }
+                    return m;
+                }
+
+                // Inserts the key and an empty value into the map, returning an iterator to
+                // the inserted item. We use emplace() if available, otherwise insert().
+                template<typename M>
+                static absl::enable_if_t<HasEmplace<M>::value, iterator> InsertOrEmplace(
+                    M* m, absl::string_view key
+                )
+                {
+                    // Use piecewise_construct to support old versions of gcc in which pair
+                    // constructor can't otherwise construct string from string_view.
+                    return ToIter(m->emplace(std::piecewise_construct, std::make_tuple(key), std::tuple<>()));
+                }
+                template<typename M>
+                static absl::enable_if_t<!HasEmplace<M>::value, iterator> InsertOrEmplace(
+                    M* m, absl::string_view key
+                )
+                {
+                    return ToIter(m->insert(std::make_pair(First(key), Second(""))));
+                }
+
+                static iterator ToIter(std::pair<iterator, bool> pair)
+                {
+                    return pair.first;
+                }
+                static iterator ToIter(iterator iter)
+                {
+                    return iter;
+                }
+            };
+
+            StringType text_;
+            Delimiter delimiter_;
+            Predicate predicate_;
+        };
+
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/string_constant.h b/CAPI/cpp/grpc/include/absl/strings/internal/string_constant.h
index f68b17d..3a51970 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/string_constant.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/string_constant.h
@@ -18,55 +18,62 @@
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
 
-// StringConstant<T> represents a compile time string constant.
-// It can be accessed via its `absl::string_view value` static member.
-// It is guaranteed that the `string_view` returned has constant `.data()`,
-// constant `.size()` and constant `value[i]` for all `0 <= i < .size()`
-//
-// The `T` is an opaque type. It is guaranteed that different string constants
-// will have different values of `T`. This allows users to associate the string
-// constant with other static state at compile time.
-//
-// Instances should be made using the `MakeStringConstant()` factory function
-// below.
-template <typename T>
-struct StringConstant {
- private:
-  static constexpr bool TryConstexprEval(absl::string_view view) {
-    return view.empty() || 2 * view[0] != 1;
-  }
+        // StringConstant<T> represents a compile time string constant.
+        // It can be accessed via its `absl::string_view value` static member.
+        // It is guaranteed that the `string_view` returned has constant `.data()`,
+        // constant `.size()` and constant `value[i]` for all `0 <= i < .size()`
+        //
+        // The `T` is an opaque type. It is guaranteed that different string constants
+        // will have different values of `T`. This allows users to associate the string
+        // constant with other static state at compile time.
+        //
+        // Instances should be made using the `MakeStringConstant()` factory function
+        // below.
+        template<typename T>
+        struct StringConstant
+        {
+        private:
+            static constexpr bool TryConstexprEval(absl::string_view view)
+            {
+                return view.empty() || 2 * view[0] != 1;
+            }
 
- public:
-  static constexpr absl::string_view value = T{}();
-  constexpr absl::string_view operator()() const { return value; }
+        public:
+            static constexpr absl::string_view value = T{}();
+            constexpr absl::string_view operator()() const
+            {
+                return value;
+            }
 
-  // Check to be sure `view` points to constant data.
-  // Otherwise, it can't be constant evaluated.
-  static_assert(TryConstexprEval(value),
-                "The input string_view must point to constant data.");
-};
+            // Check to be sure `view` points to constant data.
+            // Otherwise, it can't be constant evaluated.
+            static_assert(TryConstexprEval(value), "The input string_view must point to constant data.");
+        };
 
 #ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-template <typename T>
-constexpr absl::string_view StringConstant<T>::value;
+        template<typename T>
+        constexpr absl::string_view StringConstant<T>::value;
 #endif
 
-// Factory function for `StringConstant` instances.
-// It supports callables that have a constexpr default constructor and a
-// constexpr operator().
-// It must return an `absl::string_view` or `const char*` pointing to constant
-// data. This is validated at compile time.
-template <typename T>
-constexpr StringConstant<T> MakeStringConstant(T) {
-  return {};
-}
+        // Factory function for `StringConstant` instances.
+        // It supports callables that have a constexpr default constructor and a
+        // constexpr operator().
+        // It must return an `absl::string_view` or `const char*` pointing to constant
+        // data. This is validated at compile time.
+        template<typename T>
+        constexpr StringConstant<T> MakeStringConstant(T)
+        {
+            return {};
+        }
 
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/internal/utf8.h b/CAPI/cpp/grpc/include/absl/strings/internal/utf8.h
index 32fb109..394a4c8 100644
--- a/CAPI/cpp/grpc/include/absl/strings/internal/utf8.h
+++ b/CAPI/cpp/grpc/include/absl/strings/internal/utf8.h
@@ -22,29 +22,34 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace strings_internal
+    {
 
-// For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
-// out the UTF-8 encoding into buffer, and returns the number of chars
-// it wrote.
-//
-// As described in https://tools.ietf.org/html/rfc3629#section-3 , the encodings
-// are:
-//    00 -     7F : 0xxxxxxx
-//    80 -    7FF : 110xxxxx 10xxxxxx
-//   800 -   FFFF : 1110xxxx 10xxxxxx 10xxxxxx
-// 10000 - 10FFFF : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-//
-// Values greater than 0x10FFFF are not supported and may or may not write
-// characters into buffer, however never will more than kMaxEncodedUTF8Size
-// bytes be written, regardless of the value of utf8_char.
-enum { kMaxEncodedUTF8Size = 4 };
-size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
+        // For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
+        // out the UTF-8 encoding into buffer, and returns the number of chars
+        // it wrote.
+        //
+        // As described in https://tools.ietf.org/html/rfc3629#section-3 , the encodings
+        // are:
+        //    00 -     7F : 0xxxxxxx
+        //    80 -    7FF : 110xxxxx 10xxxxxx
+        //   800 -   FFFF : 1110xxxx 10xxxxxx 10xxxxxx
+        // 10000 - 10FFFF : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+        //
+        // Values greater than 0x10FFFF are not supported and may or may not write
+        // characters into buffer, however never will more than kMaxEncodedUTF8Size
+        // bytes be written, regardless of the value of utf8_char.
+        enum
+        {
+            kMaxEncodedUTF8Size = 4
+        };
+        size_t EncodeUTF8Char(char* buffer, char32_t utf8_char);
 
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
+    }  // namespace strings_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_INTERNAL_UTF8_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/match.h b/CAPI/cpp/grpc/include/absl/strings/match.h
index 038cbb3..dce135d 100644
--- a/CAPI/cpp/grpc/include/absl/strings/match.h
+++ b/CAPI/cpp/grpc/include/absl/strings/match.h
@@ -37,64 +37,62 @@
 
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// StrContains()
-//
-// Returns whether a given string `haystack` contains the substring `needle`.
-inline bool StrContains(absl::string_view haystack,
-                        absl::string_view needle) noexcept {
-  return haystack.find(needle, 0) != haystack.npos;
-}
+    // StrContains()
+    //
+    // Returns whether a given string `haystack` contains the substring `needle`.
+    inline bool StrContains(absl::string_view haystack, absl::string_view needle) noexcept
+    {
+        return haystack.find(needle, 0) != haystack.npos;
+    }
 
-inline bool StrContains(absl::string_view haystack, char needle) noexcept {
-  return haystack.find(needle) != haystack.npos;
-}
+    inline bool StrContains(absl::string_view haystack, char needle) noexcept
+    {
+        return haystack.find(needle) != haystack.npos;
+    }
 
-// StartsWith()
-//
-// Returns whether a given string `text` begins with `prefix`.
-inline bool StartsWith(absl::string_view text,
-                       absl::string_view prefix) noexcept {
-  return prefix.empty() ||
-         (text.size() >= prefix.size() &&
-          memcmp(text.data(), prefix.data(), prefix.size()) == 0);
-}
+    // StartsWith()
+    //
+    // Returns whether a given string `text` begins with `prefix`.
+    inline bool StartsWith(absl::string_view text, absl::string_view prefix) noexcept
+    {
+        return prefix.empty() ||
+               (text.size() >= prefix.size() &&
+                memcmp(text.data(), prefix.data(), prefix.size()) == 0);
+    }
 
-// EndsWith()
-//
-// Returns whether a given string `text` ends with `suffix`.
-inline bool EndsWith(absl::string_view text,
-                     absl::string_view suffix) noexcept {
-  return suffix.empty() ||
-         (text.size() >= suffix.size() &&
-          memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
-                 suffix.size()) == 0);
-}
+    // EndsWith()
+    //
+    // Returns whether a given string `text` ends with `suffix`.
+    inline bool EndsWith(absl::string_view text, absl::string_view suffix) noexcept
+    {
+        return suffix.empty() ||
+               (text.size() >= suffix.size() &&
+                memcmp(text.data() + (text.size() - suffix.size()), suffix.data(), suffix.size()) == 0);
+    }
 
-// EqualsIgnoreCase()
-//
-// Returns whether given ASCII strings `piece1` and `piece2` are equal, ignoring
-// case in the comparison.
-bool EqualsIgnoreCase(absl::string_view piece1,
-                      absl::string_view piece2) noexcept;
+    // EqualsIgnoreCase()
+    //
+    // Returns whether given ASCII strings `piece1` and `piece2` are equal, ignoring
+    // case in the comparison.
+    bool EqualsIgnoreCase(absl::string_view piece1, absl::string_view piece2) noexcept;
 
-// StartsWithIgnoreCase()
-//
-// Returns whether a given ASCII string `text` starts with `prefix`,
-// ignoring case in the comparison.
-bool StartsWithIgnoreCase(absl::string_view text,
-                          absl::string_view prefix) noexcept;
+    // StartsWithIgnoreCase()
+    //
+    // Returns whether a given ASCII string `text` starts with `prefix`,
+    // ignoring case in the comparison.
+    bool StartsWithIgnoreCase(absl::string_view text, absl::string_view prefix) noexcept;
 
-// EndsWithIgnoreCase()
-//
-// Returns whether a given ASCII string `text` ends with `suffix`, ignoring
-// case in the comparison.
-bool EndsWithIgnoreCase(absl::string_view text,
-                        absl::string_view suffix) noexcept;
+    // EndsWithIgnoreCase()
+    //
+    // Returns whether a given ASCII string `text` ends with `suffix`, ignoring
+    // case in the comparison.
+    bool EndsWithIgnoreCase(absl::string_view text, absl::string_view suffix) noexcept;
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_MATCH_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/numbers.h b/CAPI/cpp/grpc/include/absl/strings/numbers.h
index 86c84ed..e065405 100644
--- a/CAPI/cpp/grpc/include/absl/strings/numbers.h
+++ b/CAPI/cpp/grpc/include/absl/strings/numbers.h
@@ -47,257 +47,276 @@
 #include "absl/numeric/int128.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// SimpleAtoi()
-//
-// Converts the given string (optionally followed or preceded by ASCII
-// whitespace) into an integer value, returning `true` if successful. The string
-// must reflect a base-10 integer whose value falls within the range of the
-// integer type (optionally preceded by a `+` or `-`). If any errors are
-// encountered, this function returns `false`, leaving `out` in an unspecified
-// state.
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out);
-
-// SimpleAtof()
-//
-// Converts the given string (optionally followed or preceded by ASCII
-// whitespace) into a float, which may be rounded on overflow or underflow,
-// returning `true` if successful.
-// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
-// allowed formats for `str`, except SimpleAtof() is locale-independent and will
-// always use the "C" locale. If any errors are encountered, this function
-// returns `false`, leaving `out` in an unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str, float* out);
-
-// SimpleAtod()
-//
-// Converts the given string (optionally followed or preceded by ASCII
-// whitespace) into a double, which may be rounded on overflow or underflow,
-// returning `true` if successful.
-// See https://en.cppreference.com/w/c/string/byte/strtof for details about the
-// allowed formats for `str`, except SimpleAtod is locale-independent and will
-// always use the "C" locale. If any errors are encountered, this function
-// returns `false`, leaving `out` in an unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str, double* out);
-
-// SimpleAtob()
-//
-// Converts the given string into a boolean, returning `true` if successful.
-// The following case-insensitive strings are interpreted as boolean `true`:
-// "true", "t", "yes", "y", "1". The following case-insensitive strings
-// are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any
-// errors are encountered, this function returns `false`, leaving `out` in an
-// unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str, bool* out);
-
-// SimpleHexAtoi()
-//
-// Converts a hexadecimal string (optionally followed or preceded by ASCII
-// whitespace) to an integer, returning `true` if successful. Only valid base-16
-// hexadecimal integers whose value falls within the range of the integer type
-// (optionally preceded by a `+` or `-`) can be converted. A valid hexadecimal
-// value may include both upper and lowercase character symbols, and may
-// optionally include a leading "0x" (or "0X") number prefix, which is ignored
-// by this function. If any errors are encountered, this function returns
-// `false`, leaving `out` in an unspecified state.
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str, int_type* out);
-
-// Overloads of SimpleHexAtoi() for 128 bit integers.
-ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
-                                               absl::int128* out);
-ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
-                                               absl::uint128* out);
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // SimpleAtoi()
+    //
+    // Converts the given string (optionally followed or preceded by ASCII
+    // whitespace) into an integer value, returning `true` if successful. The string
+    // must reflect a base-10 integer whose value falls within the range of the
+    // integer type (optionally preceded by a `+` or `-`). If any errors are
+    // encountered, this function returns `false`, leaving `out` in an unspecified
+    // state.
+    template<typename int_type>
+    ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out);
+
+    // SimpleAtof()
+    //
+    // Converts the given string (optionally followed or preceded by ASCII
+    // whitespace) into a float, which may be rounded on overflow or underflow,
+    // returning `true` if successful.
+    // See https://en.cppreference.com/w/c/string/byte/strtof for details about the
+    // allowed formats for `str`, except SimpleAtof() is locale-independent and will
+    // always use the "C" locale. If any errors are encountered, this function
+    // returns `false`, leaving `out` in an unspecified state.
+    ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str, float* out);
+
+    // SimpleAtod()
+    //
+    // Converts the given string (optionally followed or preceded by ASCII
+    // whitespace) into a double, which may be rounded on overflow or underflow,
+    // returning `true` if successful.
+    // See https://en.cppreference.com/w/c/string/byte/strtof for details about the
+    // allowed formats for `str`, except SimpleAtod is locale-independent and will
+    // always use the "C" locale. If any errors are encountered, this function
+    // returns `false`, leaving `out` in an unspecified state.
+    ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str, double* out);
+
+    // SimpleAtob()
+    //
+    // Converts the given string into a boolean, returning `true` if successful.
+    // The following case-insensitive strings are interpreted as boolean `true`:
+    // "true", "t", "yes", "y", "1". The following case-insensitive strings
+    // are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any
+    // errors are encountered, this function returns `false`, leaving `out` in an
+    // unspecified state.
+    ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str, bool* out);
+
+    // SimpleHexAtoi()
+    //
+    // Converts a hexadecimal string (optionally followed or preceded by ASCII
+    // whitespace) to an integer, returning `true` if successful. Only valid base-16
+    // hexadecimal integers whose value falls within the range of the integer type
+    // (optionally preceded by a `+` or `-`) can be converted. A valid hexadecimal
+    // value may include both upper and lowercase character symbols, and may
+    // optionally include a leading "0x" (or "0X") number prefix, which is ignored
+    // by this function. If any errors are encountered, this function returns
+    // `false`, leaving `out` in an unspecified state.
+    template<typename int_type>
+    ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str, int_type* out);
+
+    // Overloads of SimpleHexAtoi() for 128 bit integers.
+    ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str, absl::int128* out);
+    ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str, absl::uint128* out);
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // End of public API.  Implementation details follow.
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace numbers_internal {
-
-// Digit conversion.
-ABSL_DLL extern const char kHexChar[17];  // 0123456789abcdef
-ABSL_DLL extern const char
-    kHexTable[513];  // 000102030405060708090a0b0c0d0e0f1011...
-ABSL_DLL extern const char
-    two_ASCII_digits[100][2];  // 00, 01, 02, 03...
-
-// Writes a two-character representation of 'i' to 'buf'. 'i' must be in the
-// range 0 <= i < 100, and buf must have space for two characters. Example:
-//   char buf[2];
-//   PutTwoDigits(42, buf);
-//   // buf[0] == '4'
-//   // buf[1] == '2'
-inline void PutTwoDigits(size_t i, char* buf) {
-  assert(i < 100);
-  memcpy(buf, two_ASCII_digits[i], 2);
-}
-
-// safe_strto?() functions for implementing SimpleAtoi()
-
-bool safe_strto32_base(absl::string_view text, int32_t* value, int base);
-bool safe_strto64_base(absl::string_view text, int64_t* value, int base);
-bool safe_strto128_base(absl::string_view text, absl::int128* value,
-                         int base);
-bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base);
-bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base);
-bool safe_strtou128_base(absl::string_view text, absl::uint128* value,
-                         int base);
-
-static const int kFastToBufferSize = 32;
-static const int kSixDigitsToBufferSize = 16;
-
-// Helper function for fast formatting of floating-point values.
-// The result is the same as printf's "%g", a.k.a. "%.6g"; that is, six
-// significant digits are returned, trailing zeros are removed, and numbers
-// outside the range 0.0001-999999 are output using scientific notation
-// (1.23456e+06). This routine is heavily optimized.
-// Required buffer size is `kSixDigitsToBufferSize`.
-size_t SixDigitsToBuffer(double d, char* buffer);
-
-// These functions are intended for speed. All functions take an output buffer
-// as an argument and return a pointer to the last byte they wrote, which is the
-// terminating '\0'. At most `kFastToBufferSize` bytes are written.
-char* FastIntToBuffer(int32_t, char*);
-char* FastIntToBuffer(uint32_t, char*);
-char* FastIntToBuffer(int64_t, char*);
-char* FastIntToBuffer(uint64_t, char*);
-
-// For enums and integer types that are not an exact match for the types above,
-// use templates to call the appropriate one of the four overloads above.
-template <typename int_type>
-char* FastIntToBuffer(int_type i, char* buffer) {
-  static_assert(sizeof(i) <= 64 / 8,
-                "FastIntToBuffer works only with 64-bit-or-less integers.");
-  // TODO(jorg): This signed-ness check is used because it works correctly
-  // with enums, and it also serves to check that int_type is not a pointer.
-  // If one day something like std::is_signed<enum E> works, switch to it.
-  // These conditions are constexpr bools to suppress MSVC warning C4127.
-  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
-  constexpr bool kUse64Bit = sizeof(i) > 32 / 8;
-  if (kIsSigned) {
-    if (kUse64Bit) {
-      return FastIntToBuffer(static_cast<int64_t>(i), buffer);
-    } else {
-      return FastIntToBuffer(static_cast<int32_t>(i), buffer);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace numbers_internal
+    {
+
+        // Digit conversion.
+        ABSL_DLL extern const char kHexChar[17];  // 0123456789abcdef
+        ABSL_DLL extern const char
+            kHexTable[513];  // 000102030405060708090a0b0c0d0e0f1011...
+        ABSL_DLL extern const char
+            two_ASCII_digits[100][2];  // 00, 01, 02, 03...
+
+        // Writes a two-character representation of 'i' to 'buf'. 'i' must be in the
+        // range 0 <= i < 100, and buf must have space for two characters. Example:
+        //   char buf[2];
+        //   PutTwoDigits(42, buf);
+        //   // buf[0] == '4'
+        //   // buf[1] == '2'
+        inline void PutTwoDigits(size_t i, char* buf)
+        {
+            assert(i < 100);
+            memcpy(buf, two_ASCII_digits[i], 2);
+        }
+
+        // safe_strto?() functions for implementing SimpleAtoi()
+
+        bool safe_strto32_base(absl::string_view text, int32_t* value, int base);
+        bool safe_strto64_base(absl::string_view text, int64_t* value, int base);
+        bool safe_strto128_base(absl::string_view text, absl::int128* value, int base);
+        bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base);
+        bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base);
+        bool safe_strtou128_base(absl::string_view text, absl::uint128* value, int base);
+
+        static const int kFastToBufferSize = 32;
+        static const int kSixDigitsToBufferSize = 16;
+
+        // Helper function for fast formatting of floating-point values.
+        // The result is the same as printf's "%g", a.k.a. "%.6g"; that is, six
+        // significant digits are returned, trailing zeros are removed, and numbers
+        // outside the range 0.0001-999999 are output using scientific notation
+        // (1.23456e+06). This routine is heavily optimized.
+        // Required buffer size is `kSixDigitsToBufferSize`.
+        size_t SixDigitsToBuffer(double d, char* buffer);
+
+        // These functions are intended for speed. All functions take an output buffer
+        // as an argument and return a pointer to the last byte they wrote, which is the
+        // terminating '\0'. At most `kFastToBufferSize` bytes are written.
+        char* FastIntToBuffer(int32_t, char*);
+        char* FastIntToBuffer(uint32_t, char*);
+        char* FastIntToBuffer(int64_t, char*);
+        char* FastIntToBuffer(uint64_t, char*);
+
+        // For enums and integer types that are not an exact match for the types above,
+        // use templates to call the appropriate one of the four overloads above.
+        template<typename int_type>
+        char* FastIntToBuffer(int_type i, char* buffer)
+        {
+            static_assert(sizeof(i) <= 64 / 8, "FastIntToBuffer works only with 64-bit-or-less integers.");
+            // TODO(jorg): This signed-ness check is used because it works correctly
+            // with enums, and it also serves to check that int_type is not a pointer.
+            // If one day something like std::is_signed<enum E> works, switch to it.
+            // These conditions are constexpr bools to suppress MSVC warning C4127.
+            constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
+            constexpr bool kUse64Bit = sizeof(i) > 32 / 8;
+            if (kIsSigned)
+            {
+                if (kUse64Bit)
+                {
+                    return FastIntToBuffer(static_cast<int64_t>(i), buffer);
+                }
+                else
+                {
+                    return FastIntToBuffer(static_cast<int32_t>(i), buffer);
+                }
+            }
+            else
+            {
+                if (kUse64Bit)
+                {
+                    return FastIntToBuffer(static_cast<uint64_t>(i), buffer);
+                }
+                else
+                {
+                    return FastIntToBuffer(static_cast<uint32_t>(i), buffer);
+                }
+            }
+        }
+
+        // Implementation of SimpleAtoi, generalized to support arbitrary base (used
+        // with base different from 10 elsewhere in Abseil implementation).
+        template<typename int_type>
+        ABSL_MUST_USE_RESULT bool safe_strtoi_base(absl::string_view s, int_type* out, int base)
+        {
+            static_assert(sizeof(*out) == 4 || sizeof(*out) == 8, "SimpleAtoi works only with 32-bit or 64-bit integers.");
+            static_assert(!std::is_floating_point<int_type>::value, "Use SimpleAtof or SimpleAtod instead.");
+            bool parsed;
+            // TODO(jorg): This signed-ness check is used because it works correctly
+            // with enums, and it also serves to check that int_type is not a pointer.
+            // If one day something like std::is_signed<enum E> works, switch to it.
+            // These conditions are constexpr bools to suppress MSVC warning C4127.
+            constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
+            constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
+            if (kIsSigned)
+            {
+                if (kUse64Bit)
+                {
+                    int64_t val;
+                    parsed = numbers_internal::safe_strto64_base(s, &val, base);
+                    *out = static_cast<int_type>(val);
+                }
+                else
+                {
+                    int32_t val;
+                    parsed = numbers_internal::safe_strto32_base(s, &val, base);
+                    *out = static_cast<int_type>(val);
+                }
+            }
+            else
+            {
+                if (kUse64Bit)
+                {
+                    uint64_t val;
+                    parsed = numbers_internal::safe_strtou64_base(s, &val, base);
+                    *out = static_cast<int_type>(val);
+                }
+                else
+                {
+                    uint32_t val;
+                    parsed = numbers_internal::safe_strtou32_base(s, &val, base);
+                    *out = static_cast<int_type>(val);
+                }
+            }
+            return parsed;
+        }
+
+        // FastHexToBufferZeroPad16()
+        //
+        // Outputs `val` into `out` as if by `snprintf(out, 17, "%016x", val)` but
+        // without the terminating null character. Thus `out` must be of length >= 16.
+        // Returns the number of non-pad digits of the output (it can never be zero
+        // since 0 has one digit).
+        inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out)
+        {
+#ifdef ABSL_INTERNAL_HAVE_SSSE3
+            uint64_t be = absl::big_endian::FromHost64(val);
+            const auto kNibbleMask = _mm_set1_epi8(0xf);
+            const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
+            auto v = _mm_loadl_epi64(reinterpret_cast<__m128i*>(&be));  // load lo dword
+            auto v4 = _mm_srli_epi64(v, 4);                             // shift 4 right
+            auto il = _mm_unpacklo_epi8(v4, v);                         // interleave bytes
+            auto m = _mm_and_si128(il, kNibbleMask);                    // mask out nibbles
+            auto hexchars = _mm_shuffle_epi8(kHexDigits, m);            // hex chars
+            _mm_storeu_si128(reinterpret_cast<__m128i*>(out), hexchars);
+#else
+            for (int i = 0; i < 8; ++i)
+            {
+                auto byte = (val >> (56 - 8 * i)) & 0xFF;
+                auto* hex = &absl::numbers_internal::kHexTable[byte * 2];
+                std::memcpy(out + 2 * i, hex, 2);
+            }
+#endif
+            // | 0x1 so that even 0 has 1 digit.
+            return 16 - static_cast<size_t>(countl_zero(val | 0x1) / 4);
+        }
+
+    }  // namespace numbers_internal
+
+    template<typename int_type>
+    ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out)
+    {
+        return numbers_internal::safe_strtoi_base(str, out, 10);
     }
-  } else {
-    if (kUse64Bit) {
-      return FastIntToBuffer(static_cast<uint64_t>(i), buffer);
-    } else {
-      return FastIntToBuffer(static_cast<uint32_t>(i), buffer);
+
+    ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str, absl::int128* out)
+    {
+        return numbers_internal::safe_strto128_base(str, out, 10);
     }
-  }
-}
-
-// Implementation of SimpleAtoi, generalized to support arbitrary base (used
-// with base different from 10 elsewhere in Abseil implementation).
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool safe_strtoi_base(absl::string_view s, int_type* out,
-                                           int base) {
-  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
-                "SimpleAtoi works only with 32-bit or 64-bit integers.");
-  static_assert(!std::is_floating_point<int_type>::value,
-                "Use SimpleAtof or SimpleAtod instead.");
-  bool parsed;
-  // TODO(jorg): This signed-ness check is used because it works correctly
-  // with enums, and it also serves to check that int_type is not a pointer.
-  // If one day something like std::is_signed<enum E> works, switch to it.
-  // These conditions are constexpr bools to suppress MSVC warning C4127.
-  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
-  constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
-  if (kIsSigned) {
-    if (kUse64Bit) {
-      int64_t val;
-      parsed = numbers_internal::safe_strto64_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    } else {
-      int32_t val;
-      parsed = numbers_internal::safe_strto32_base(s, &val, base);
-      *out = static_cast<int_type>(val);
+
+    ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str, absl::uint128* out)
+    {
+        return numbers_internal::safe_strtou128_base(str, out, 10);
     }
-  } else {
-    if (kUse64Bit) {
-      uint64_t val;
-      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
-      *out = static_cast<int_type>(val);
-    } else {
-      uint32_t val;
-      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
-      *out = static_cast<int_type>(val);
+
+    template<typename int_type>
+    ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str, int_type* out)
+    {
+        return numbers_internal::safe_strtoi_base(str, out, 16);
     }
-  }
-  return parsed;
-}
 
-// FastHexToBufferZeroPad16()
-//
-// Outputs `val` into `out` as if by `snprintf(out, 17, "%016x", val)` but
-// without the terminating null character. Thus `out` must be of length >= 16.
-// Returns the number of non-pad digits of the output (it can never be zero
-// since 0 has one digit).
-inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) {
-#ifdef ABSL_INTERNAL_HAVE_SSSE3
-  uint64_t be = absl::big_endian::FromHost64(val);
-  const auto kNibbleMask = _mm_set1_epi8(0xf);
-  const auto kHexDigits = _mm_setr_epi8('0', '1', '2', '3', '4', '5', '6', '7',
-                                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
-  auto v = _mm_loadl_epi64(reinterpret_cast<__m128i*>(&be));  // load lo dword
-  auto v4 = _mm_srli_epi64(v, 4);                            // shift 4 right
-  auto il = _mm_unpacklo_epi8(v4, v);                        // interleave bytes
-  auto m = _mm_and_si128(il, kNibbleMask);                   // mask out nibbles
-  auto hexchars = _mm_shuffle_epi8(kHexDigits, m);           // hex chars
-  _mm_storeu_si128(reinterpret_cast<__m128i*>(out), hexchars);
-#else
-  for (int i = 0; i < 8; ++i) {
-    auto byte = (val >> (56 - 8 * i)) & 0xFF;
-    auto* hex = &absl::numbers_internal::kHexTable[byte * 2];
-    std::memcpy(out + 2 * i, hex, 2);
-  }
-#endif
-  // | 0x1 so that even 0 has 1 digit.
-  return 16 - static_cast<size_t>(countl_zero(val | 0x1) / 4);
-}
-
-}  // namespace numbers_internal
-
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out) {
-  return numbers_internal::safe_strtoi_base(str, out, 10);
-}
-
-ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
-                                            absl::int128* out) {
-  return numbers_internal::safe_strto128_base(str, out, 10);
-}
-
-ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
-                                            absl::uint128* out) {
-  return numbers_internal::safe_strtou128_base(str, out, 10);
-}
-
-template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleHexAtoi(absl::string_view str, int_type* out) {
-  return numbers_internal::safe_strtoi_base(str, out, 16);
-}
-
-ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
-                                               absl::int128* out) {
-  return numbers_internal::safe_strto128_base(str, out, 16);
-}
-
-ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str,
-                                               absl::uint128* out) {
-  return numbers_internal::safe_strtou128_base(str, out, 16);
-}
-
-ABSL_NAMESPACE_END
+    ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str, absl::int128* out)
+    {
+        return numbers_internal::safe_strto128_base(str, out, 16);
+    }
+
+    ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(absl::string_view str, absl::uint128* out)
+    {
+        return numbers_internal::safe_strtou128_base(str, out, 16);
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_NUMBERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_cat.h b/CAPI/cpp/grpc/include/absl/strings/str_cat.h
index a94bc5d..3a5fea4 100644
--- a/CAPI/cpp/grpc/include/absl/strings/str_cat.h
+++ b/CAPI/cpp/grpc/include/absl/strings/str_cat.h
@@ -63,353 +63,404 @@
 #include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace strings_internal {
-// AlphaNumBuffer allows a way to pass a string to StrCat without having to do
-// memory allocation.  It is simply a pair of a fixed-size character array, and
-// a size.  Please don't use outside of absl, yet.
-template <size_t max_size>
-struct AlphaNumBuffer {
-  std::array<char, max_size> data;
-  size_t size;
-};
-
-}  // namespace strings_internal
-
-// Enum that specifies the number of significant digits to return in a `Hex` or
-// `Dec` conversion and fill character to use. A `kZeroPad2` value, for example,
-// would produce hexadecimal strings such as "0a","0f" and a 'kSpacePad5' value
-// would produce hexadecimal strings such as "    a","    f".
-enum PadSpec : uint8_t {
-  kNoPad = 1,
-  kZeroPad2,
-  kZeroPad3,
-  kZeroPad4,
-  kZeroPad5,
-  kZeroPad6,
-  kZeroPad7,
-  kZeroPad8,
-  kZeroPad9,
-  kZeroPad10,
-  kZeroPad11,
-  kZeroPad12,
-  kZeroPad13,
-  kZeroPad14,
-  kZeroPad15,
-  kZeroPad16,
-  kZeroPad17,
-  kZeroPad18,
-  kZeroPad19,
-  kZeroPad20,
-
-  kSpacePad2 = kZeroPad2 + 64,
-  kSpacePad3,
-  kSpacePad4,
-  kSpacePad5,
-  kSpacePad6,
-  kSpacePad7,
-  kSpacePad8,
-  kSpacePad9,
-  kSpacePad10,
-  kSpacePad11,
-  kSpacePad12,
-  kSpacePad13,
-  kSpacePad14,
-  kSpacePad15,
-  kSpacePad16,
-  kSpacePad17,
-  kSpacePad18,
-  kSpacePad19,
-  kSpacePad20,
-};
-
-// -----------------------------------------------------------------------------
-// Hex
-// -----------------------------------------------------------------------------
-//
-// `Hex` stores a set of hexadecimal string conversion parameters for use
-// within `AlphaNum` string conversions.
-struct Hex {
-  uint64_t value;
-  uint8_t width;
-  char fill;
-
-  template <typename Int>
-  explicit Hex(
-      Int v, PadSpec spec = absl::kNoPad,
-      typename std::enable_if<sizeof(Int) == 1 &&
-                              !std::is_pointer<Int>::value>::type* = nullptr)
-      : Hex(spec, static_cast<uint8_t>(v)) {}
-  template <typename Int>
-  explicit Hex(
-      Int v, PadSpec spec = absl::kNoPad,
-      typename std::enable_if<sizeof(Int) == 2 &&
-                              !std::is_pointer<Int>::value>::type* = nullptr)
-      : Hex(spec, static_cast<uint16_t>(v)) {}
-  template <typename Int>
-  explicit Hex(
-      Int v, PadSpec spec = absl::kNoPad,
-      typename std::enable_if<sizeof(Int) == 4 &&
-                              !std::is_pointer<Int>::value>::type* = nullptr)
-      : Hex(spec, static_cast<uint32_t>(v)) {}
-  template <typename Int>
-  explicit Hex(
-      Int v, PadSpec spec = absl::kNoPad,
-      typename std::enable_if<sizeof(Int) == 8 &&
-                              !std::is_pointer<Int>::value>::type* = nullptr)
-      : Hex(spec, static_cast<uint64_t>(v)) {}
-  template <typename Pointee>
-  explicit Hex(Pointee* v, PadSpec spec = absl::kNoPad)
-      : Hex(spec, reinterpret_cast<uintptr_t>(v)) {}
-
- private:
-  Hex(PadSpec spec, uint64_t v)
-      : value(v),
-        width(spec == absl::kNoPad
-                  ? 1
-                  : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2
-                                             : spec - absl::kZeroPad2 + 2),
-        fill(spec >= absl::kSpacePad2 ? ' ' : '0') {}
-};
-
-// -----------------------------------------------------------------------------
-// Dec
-// -----------------------------------------------------------------------------
-//
-// `Dec` stores a set of decimal string conversion parameters for use
-// within `AlphaNum` string conversions.  Dec is slower than the default
-// integer conversion, so use it only if you need padding.
-struct Dec {
-  uint64_t value;
-  uint8_t width;
-  char fill;
-  bool neg;
-
-  template <typename Int>
-  explicit Dec(Int v, PadSpec spec = absl::kNoPad,
-               typename std::enable_if<(sizeof(Int) <= 8)>::type* = nullptr)
-      : value(v >= 0 ? static_cast<uint64_t>(v)
-                     : uint64_t{0} - static_cast<uint64_t>(v)),
-        width(spec == absl::kNoPad
-                  ? 1
-                  : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2
-                                             : spec - absl::kZeroPad2 + 2),
-        fill(spec >= absl::kSpacePad2 ? ' ' : '0'),
-        neg(v < 0) {}
-};
-
-// -----------------------------------------------------------------------------
-// AlphaNum
-// -----------------------------------------------------------------------------
-//
-// The `AlphaNum` class acts as the main parameter type for `StrCat()` and
-// `StrAppend()`, providing efficient conversion of numeric, boolean, and
-// hexadecimal values (through the `Hex` type) into strings.
-
-class AlphaNum {
- public:
-  // No bool ctor -- bools convert to an integral type.
-  // A bool ctor would also convert incoming pointers (bletch).
-
-  AlphaNum(int x)  // NOLINT(runtime/explicit)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(unsigned int x)  // NOLINT(runtime/explicit)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(long x)  // NOLINT(*)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(unsigned long x)  // NOLINT(*)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(long long x)  // NOLINT(*)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-  AlphaNum(unsigned long long x)  // NOLINT(*)
-      : piece_(digits_, static_cast<size_t>(
-                            numbers_internal::FastIntToBuffer(x, digits_) -
-                            &digits_[0])) {}
-
-  AlphaNum(float f)  // NOLINT(runtime/explicit)
-      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
-  AlphaNum(double f)  // NOLINT(runtime/explicit)
-      : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
-
-  AlphaNum(Hex hex);  // NOLINT(runtime/explicit)
-  AlphaNum(Dec dec);  // NOLINT(runtime/explicit)
-
-  template <size_t size>
-  AlphaNum(  // NOLINT(runtime/explicit)
-      const strings_internal::AlphaNumBuffer<size>& buf)
-      : piece_(&buf.data[0], buf.size) {}
-
-  AlphaNum(const char* c_str)                     // NOLINT(runtime/explicit)
-      : piece_(NullSafeStringView(c_str)) {}      // NOLINT(runtime/explicit)
-  AlphaNum(absl::string_view pc) : piece_(pc) {}  // NOLINT(runtime/explicit)
-
-  template <typename Allocator>
-  AlphaNum(  // NOLINT(runtime/explicit)
-      const std::basic_string<char, std::char_traits<char>, Allocator>& str)
-      : piece_(str) {}
-
-  // Use string literals ":" instead of character literals ':'.
-  AlphaNum(char c) = delete;  // NOLINT(runtime/explicit)
-
-  AlphaNum(const AlphaNum&) = delete;
-  AlphaNum& operator=(const AlphaNum&) = delete;
-
-  absl::string_view::size_type size() const { return piece_.size(); }
-  const char* data() const { return piece_.data(); }
-  absl::string_view Piece() const { return piece_; }
-
-  // Normal enums are already handled by the integer formatters.
-  // This overload matches only scoped enums.
-  template <typename T,
-            typename = typename std::enable_if<
-                std::is_enum<T>{} && !std::is_convertible<T, int>{}>::type>
-  AlphaNum(T e)  // NOLINT(runtime/explicit)
-      : AlphaNum(static_cast<typename std::underlying_type<T>::type>(e)) {}
-
-  // vector<bool>::reference and const_reference require special help to
-  // convert to `AlphaNum` because it requires two user defined conversions.
-  template <
-      typename T,
-      typename std::enable_if<
-          std::is_class<T>::value &&
-          (std::is_same<T, std::vector<bool>::reference>::value ||
-           std::is_same<T, std::vector<bool>::const_reference>::value)>::type* =
-          nullptr>
-  AlphaNum(T e) : AlphaNum(static_cast<bool>(e)) {}  // NOLINT(runtime/explicit)
-
- private:
-  absl::string_view piece_;
-  char digits_[numbers_internal::kFastToBufferSize];
-};
-
-// -----------------------------------------------------------------------------
-// StrCat()
-// -----------------------------------------------------------------------------
-//
-// Merges given strings or numbers, using no delimiter(s), returning the merged
-// result as a string.
-//
-// `StrCat()` is designed to be the fastest possible way to construct a string
-// out of a mix of raw C strings, string_views, strings, bool values,
-// and numeric values.
-//
-// Don't use `StrCat()` for user-visible strings. The localization process
-// works poorly on strings built up out of fragments.
-//
-// For clarity and performance, don't use `StrCat()` when appending to a
-// string. Use `StrAppend()` instead. In particular, avoid using any of these
-// (anti-)patterns:
-//
-//   str.append(StrCat(...))
-//   str += StrCat(...)
-//   str = StrCat(str, ...)
-//
-// The last case is the worst, with a potential to change a loop
-// from a linear time operation with O(1) dynamic allocations into a
-// quadratic time operation with O(n) dynamic allocations.
-//
-// See `StrAppend()` below for more information.
-
-namespace strings_internal {
-
-// Do not call directly - this is not part of the public API.
-std::string CatPieces(std::initializer_list<absl::string_view> pieces);
-void AppendPieces(std::string* dest,
-                  std::initializer_list<absl::string_view> pieces);
-
-}  // namespace strings_internal
-
-ABSL_MUST_USE_RESULT inline std::string StrCat() { return std::string(); }
-
-ABSL_MUST_USE_RESULT inline std::string StrCat(const AlphaNum& a) {
-  return std::string(a.data(), a.size());
-}
-
-ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b);
-ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                        const AlphaNum& c);
-ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                        const AlphaNum& c, const AlphaNum& d);
-
-// Support 5 or more arguments
-template <typename... AV>
-ABSL_MUST_USE_RESULT inline std::string StrCat(
-    const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d,
-    const AlphaNum& e, const AV&... args) {
-  return strings_internal::CatPieces(
-      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
-       static_cast<const AlphaNum&>(args).Piece()...});
-}
-
-// -----------------------------------------------------------------------------
-// StrAppend()
-// -----------------------------------------------------------------------------
-//
-// Appends a string or set of strings to an existing string, in a similar
-// fashion to `StrCat()`.
-//
-// WARNING: `StrAppend(&str, a, b, c, ...)` requires that none of the
-// a, b, c, parameters be a reference into str. For speed, `StrAppend()` does
-// not try to check each of its input arguments to be sure that they are not
-// a subset of the string being appended to. That is, while this will work:
-//
-//   std::string s = "foo";
-//   s += s;
-//
-// This output is undefined:
-//
-//   std::string s = "foo";
-//   StrAppend(&s, s);
-//
-// This output is undefined as well, since `absl::string_view` does not own its
-// data:
-//
-//   std::string s = "foobar";
-//   absl::string_view p = s;
-//   StrAppend(&s, p);
-
-inline void StrAppend(std::string*) {}
-void StrAppend(std::string* dest, const AlphaNum& a);
-void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b);
-void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
-               const AlphaNum& c);
-void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
-               const AlphaNum& c, const AlphaNum& d);
-
-// Support 5 or more arguments
-template <typename... AV>
-inline void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
-                      const AlphaNum& c, const AlphaNum& d, const AlphaNum& e,
-                      const AV&... args) {
-  strings_internal::AppendPieces(
-      dest, {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
-             static_cast<const AlphaNum&>(args).Piece()...});
-}
-
-// Helper function for the future StrCat default floating-point format, %.6g
-// This is fast.
-inline strings_internal::AlphaNumBuffer<
-    numbers_internal::kSixDigitsToBufferSize>
-SixDigits(double d) {
-  strings_internal::AlphaNumBuffer<numbers_internal::kSixDigitsToBufferSize>
-      result;
-  result.size = numbers_internal::SixDigitsToBuffer(d, &result.data[0]);
-  return result;
-}
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    namespace strings_internal
+    {
+        // AlphaNumBuffer allows a way to pass a string to StrCat without having to do
+        // memory allocation.  It is simply a pair of a fixed-size character array, and
+        // a size.  Please don't use outside of absl, yet.
+        template<size_t max_size>
+        struct AlphaNumBuffer
+        {
+            std::array<char, max_size> data;
+            size_t size;
+        };
+
+    }  // namespace strings_internal
+
+    // Enum that specifies the number of significant digits to return in a `Hex` or
+    // `Dec` conversion and fill character to use. A `kZeroPad2` value, for example,
+    // would produce hexadecimal strings such as "0a","0f" and a 'kSpacePad5' value
+    // would produce hexadecimal strings such as "    a","    f".
+    enum PadSpec : uint8_t
+    {
+        kNoPad = 1,
+        kZeroPad2,
+        kZeroPad3,
+        kZeroPad4,
+        kZeroPad5,
+        kZeroPad6,
+        kZeroPad7,
+        kZeroPad8,
+        kZeroPad9,
+        kZeroPad10,
+        kZeroPad11,
+        kZeroPad12,
+        kZeroPad13,
+        kZeroPad14,
+        kZeroPad15,
+        kZeroPad16,
+        kZeroPad17,
+        kZeroPad18,
+        kZeroPad19,
+        kZeroPad20,
+
+        kSpacePad2 = kZeroPad2 + 64,
+        kSpacePad3,
+        kSpacePad4,
+        kSpacePad5,
+        kSpacePad6,
+        kSpacePad7,
+        kSpacePad8,
+        kSpacePad9,
+        kSpacePad10,
+        kSpacePad11,
+        kSpacePad12,
+        kSpacePad13,
+        kSpacePad14,
+        kSpacePad15,
+        kSpacePad16,
+        kSpacePad17,
+        kSpacePad18,
+        kSpacePad19,
+        kSpacePad20,
+    };
+
+    // -----------------------------------------------------------------------------
+    // Hex
+    // -----------------------------------------------------------------------------
+    //
+    // `Hex` stores a set of hexadecimal string conversion parameters for use
+    // within `AlphaNum` string conversions.
+    struct Hex
+    {
+        uint64_t value;
+        uint8_t width;
+        char fill;
+
+        template<typename Int>
+        explicit Hex(
+            Int v, PadSpec spec = absl::kNoPad, typename std::enable_if<sizeof(Int) == 1 && !std::is_pointer<Int>::value>::type* = nullptr
+        ) :
+            Hex(spec, static_cast<uint8_t>(v))
+        {
+        }
+        template<typename Int>
+        explicit Hex(
+            Int v, PadSpec spec = absl::kNoPad, typename std::enable_if<sizeof(Int) == 2 && !std::is_pointer<Int>::value>::type* = nullptr
+        ) :
+            Hex(spec, static_cast<uint16_t>(v))
+        {
+        }
+        template<typename Int>
+        explicit Hex(
+            Int v, PadSpec spec = absl::kNoPad, typename std::enable_if<sizeof(Int) == 4 && !std::is_pointer<Int>::value>::type* = nullptr
+        ) :
+            Hex(spec, static_cast<uint32_t>(v))
+        {
+        }
+        template<typename Int>
+        explicit Hex(
+            Int v, PadSpec spec = absl::kNoPad, typename std::enable_if<sizeof(Int) == 8 && !std::is_pointer<Int>::value>::type* = nullptr
+        ) :
+            Hex(spec, static_cast<uint64_t>(v))
+        {
+        }
+        template<typename Pointee>
+        explicit Hex(Pointee* v, PadSpec spec = absl::kNoPad) :
+            Hex(spec, reinterpret_cast<uintptr_t>(v))
+        {
+        }
+
+    private:
+        Hex(PadSpec spec, uint64_t v) :
+            value(v),
+            width(spec == absl::kNoPad ? 1 : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2 :
+                                                                        spec - absl::kZeroPad2 + 2),
+            fill(spec >= absl::kSpacePad2 ? ' ' : '0')
+        {
+        }
+    };
+
+    // -----------------------------------------------------------------------------
+    // Dec
+    // -----------------------------------------------------------------------------
+    //
+    // `Dec` stores a set of decimal string conversion parameters for use
+    // within `AlphaNum` string conversions.  Dec is slower than the default
+    // integer conversion, so use it only if you need padding.
+    struct Dec
+    {
+        uint64_t value;
+        uint8_t width;
+        char fill;
+        bool neg;
+
+        template<typename Int>
+        explicit Dec(Int v, PadSpec spec = absl::kNoPad, typename std::enable_if<(sizeof(Int) <= 8)>::type* = nullptr) :
+            value(v >= 0 ? static_cast<uint64_t>(v) : uint64_t{0} - static_cast<uint64_t>(v)),
+            width(spec == absl::kNoPad ? 1 : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2 :
+                                                                        spec - absl::kZeroPad2 + 2),
+            fill(spec >= absl::kSpacePad2 ? ' ' : '0'),
+            neg(v < 0)
+        {
+        }
+    };
+
+    // -----------------------------------------------------------------------------
+    // AlphaNum
+    // -----------------------------------------------------------------------------
+    //
+    // The `AlphaNum` class acts as the main parameter type for `StrCat()` and
+    // `StrAppend()`, providing efficient conversion of numeric, boolean, and
+    // hexadecimal values (through the `Hex` type) into strings.
+
+    class AlphaNum
+    {
+    public:
+        // No bool ctor -- bools convert to an integral type.
+        // A bool ctor would also convert incoming pointers (bletch).
+
+        AlphaNum(int x)  // NOLINT(runtime/explicit)
+            :
+            piece_(digits_, static_cast<size_t>(numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]))
+        {
+        }
+        AlphaNum(unsigned int x)  // NOLINT(runtime/explicit)
+            :
+            piece_(digits_, static_cast<size_t>(numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]))
+        {
+        }
+        AlphaNum(long x)  // NOLINT(*)
+            :
+            piece_(digits_, static_cast<size_t>(numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]))
+        {
+        }
+        AlphaNum(unsigned long x)  // NOLINT(*)
+            :
+            piece_(digits_, static_cast<size_t>(numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]))
+        {
+        }
+        AlphaNum(long long x)  // NOLINT(*)
+            :
+            piece_(digits_, static_cast<size_t>(numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]))
+        {
+        }
+        AlphaNum(unsigned long long x)  // NOLINT(*)
+            :
+            piece_(digits_, static_cast<size_t>(numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]))
+        {
+        }
+
+        AlphaNum(float f)  // NOLINT(runtime/explicit)
+            :
+            piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_))
+        {
+        }
+        AlphaNum(double f)  // NOLINT(runtime/explicit)
+            :
+            piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_))
+        {
+        }
+
+        AlphaNum(Hex hex);  // NOLINT(runtime/explicit)
+        AlphaNum(Dec dec);  // NOLINT(runtime/explicit)
+
+        template<size_t size>
+        AlphaNum(  // NOLINT(runtime/explicit)
+            const strings_internal::AlphaNumBuffer<size>& buf
+        ) :
+            piece_(&buf.data[0], buf.size)
+        {
+        }
+
+        AlphaNum(const char* c_str)  // NOLINT(runtime/explicit)
+            :
+            piece_(NullSafeStringView(c_str))
+        {
+        }  // NOLINT(runtime/explicit)
+        AlphaNum(absl::string_view pc) :
+            piece_(pc)
+        {
+        }  // NOLINT(runtime/explicit)
+
+        template<typename Allocator>
+        AlphaNum(  // NOLINT(runtime/explicit)
+            const std::basic_string<char, std::char_traits<char>, Allocator>& str
+        ) :
+            piece_(str)
+        {
+        }
+
+        // Use string literals ":" instead of character literals ':'.
+        AlphaNum(char c) = delete;  // NOLINT(runtime/explicit)
+
+        AlphaNum(const AlphaNum&) = delete;
+        AlphaNum& operator=(const AlphaNum&) = delete;
+
+        absl::string_view::size_type size() const
+        {
+            return piece_.size();
+        }
+        const char* data() const
+        {
+            return piece_.data();
+        }
+        absl::string_view Piece() const
+        {
+            return piece_;
+        }
+
+        // Normal enums are already handled by the integer formatters.
+        // This overload matches only scoped enums.
+        template<typename T, typename = typename std::enable_if<std::is_enum<T>{} && !std::is_convertible<T, int>{}>::type>
+        AlphaNum(T e)  // NOLINT(runtime/explicit)
+            :
+            AlphaNum(static_cast<typename std::underlying_type<T>::type>(e))
+        {
+        }
+
+        // vector<bool>::reference and const_reference require special help to
+        // convert to `AlphaNum` because it requires two user defined conversions.
+        template<
+            typename T,
+            typename std::enable_if<
+                std::is_class<T>::value &&
+                (std::is_same<T, std::vector<bool>::reference>::value ||
+                 std::is_same<T, std::vector<bool>::const_reference>::value)>::type* =
+                nullptr>
+        AlphaNum(T e) :
+            AlphaNum(static_cast<bool>(e))
+        {
+        }  // NOLINT(runtime/explicit)
+
+    private:
+        absl::string_view piece_;
+        char digits_[numbers_internal::kFastToBufferSize];
+    };
+
+    // -----------------------------------------------------------------------------
+    // StrCat()
+    // -----------------------------------------------------------------------------
+    //
+    // Merges given strings or numbers, using no delimiter(s), returning the merged
+    // result as a string.
+    //
+    // `StrCat()` is designed to be the fastest possible way to construct a string
+    // out of a mix of raw C strings, string_views, strings, bool values,
+    // and numeric values.
+    //
+    // Don't use `StrCat()` for user-visible strings. The localization process
+    // works poorly on strings built up out of fragments.
+    //
+    // For clarity and performance, don't use `StrCat()` when appending to a
+    // string. Use `StrAppend()` instead. In particular, avoid using any of these
+    // (anti-)patterns:
+    //
+    //   str.append(StrCat(...))
+    //   str += StrCat(...)
+    //   str = StrCat(str, ...)
+    //
+    // The last case is the worst, with a potential to change a loop
+    // from a linear time operation with O(1) dynamic allocations into a
+    // quadratic time operation with O(n) dynamic allocations.
+    //
+    // See `StrAppend()` below for more information.
+
+    namespace strings_internal
+    {
+
+        // Do not call directly - this is not part of the public API.
+        std::string CatPieces(std::initializer_list<absl::string_view> pieces);
+        void AppendPieces(std::string* dest, std::initializer_list<absl::string_view> pieces);
+
+    }  // namespace strings_internal
+
+    ABSL_MUST_USE_RESULT inline std::string StrCat()
+    {
+        return std::string();
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string StrCat(const AlphaNum& a)
+    {
+        return std::string(a.data(), a.size());
+    }
+
+    ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b);
+    ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c);
+    ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d);
+
+    // Support 5 or more arguments
+    template<typename... AV>
+    ABSL_MUST_USE_RESULT inline std::string StrCat(
+        const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e, const AV&... args
+    )
+    {
+        return strings_internal::CatPieces(
+            {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(), static_cast<const AlphaNum&>(args).Piece()...}
+        );
+    }
+
+    // -----------------------------------------------------------------------------
+    // StrAppend()
+    // -----------------------------------------------------------------------------
+    //
+    // Appends a string or set of strings to an existing string, in a similar
+    // fashion to `StrCat()`.
+    //
+    // WARNING: `StrAppend(&str, a, b, c, ...)` requires that none of the
+    // a, b, c, parameters be a reference into str. For speed, `StrAppend()` does
+    // not try to check each of its input arguments to be sure that they are not
+    // a subset of the string being appended to. That is, while this will work:
+    //
+    //   std::string s = "foo";
+    //   s += s;
+    //
+    // This output is undefined:
+    //
+    //   std::string s = "foo";
+    //   StrAppend(&s, s);
+    //
+    // This output is undefined as well, since `absl::string_view` does not own its
+    // data:
+    //
+    //   std::string s = "foobar";
+    //   absl::string_view p = s;
+    //   StrAppend(&s, p);
+
+    inline void StrAppend(std::string*)
+    {
+    }
+    void StrAppend(std::string* dest, const AlphaNum& a);
+    void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b);
+    void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c);
+    void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d);
+
+    // Support 5 or more arguments
+    template<typename... AV>
+    inline void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e, const AV&... args)
+    {
+        strings_internal::AppendPieces(
+            dest, {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(), static_cast<const AlphaNum&>(args).Piece()...}
+        );
+    }
+
+    // Helper function for the future StrCat default floating-point format, %.6g
+    // This is fast.
+    inline strings_internal::AlphaNumBuffer<
+        numbers_internal::kSixDigitsToBufferSize>
+        SixDigits(double d)
+    {
+        strings_internal::AlphaNumBuffer<numbers_internal::kSixDigitsToBufferSize>
+            result;
+        result.size = numbers_internal::SixDigitsToBuffer(d, &result.data[0]);
+        return result;
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_STR_CAT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_format.h b/CAPI/cpp/grpc/include/absl/strings/str_format.h
index 4b05c70..bfee27a 100644
--- a/CAPI/cpp/grpc/include/absl/strings/str_format.h
+++ b/CAPI/cpp/grpc/include/absl/strings/str_format.h
@@ -73,561 +73,586 @@
 #include <cstdio>
 #include <string>
 
-#include "absl/strings/internal/str_format/arg.h"  // IWYU pragma: export
-#include "absl/strings/internal/str_format/bind.h"  // IWYU pragma: export
-#include "absl/strings/internal/str_format/checker.h"  // IWYU pragma: export
+#include "absl/strings/internal/str_format/arg.h"        // IWYU pragma: export
+#include "absl/strings/internal/str_format/bind.h"       // IWYU pragma: export
+#include "absl/strings/internal/str_format/checker.h"    // IWYU pragma: export
 #include "absl/strings/internal/str_format/extension.h"  // IWYU pragma: export
-#include "absl/strings/internal/str_format/parser.h"  // IWYU pragma: export
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// UntypedFormatSpec
-//
-// A type-erased class that can be used directly within untyped API entry
-// points. An `UntypedFormatSpec` is specifically used as an argument to
-// `FormatUntyped()`.
-//
-// Example:
-//
-//   absl::UntypedFormatSpec format("%d");
-//   std::string out;
-//   CHECK(absl::FormatUntyped(&out, format, {absl::FormatArg(1)}));
-class UntypedFormatSpec {
- public:
-  UntypedFormatSpec() = delete;
-  UntypedFormatSpec(const UntypedFormatSpec&) = delete;
-  UntypedFormatSpec& operator=(const UntypedFormatSpec&) = delete;
-
-  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
-
- protected:
-  explicit UntypedFormatSpec(const str_format_internal::ParsedFormatBase* pc)
-      : spec_(pc) {}
-
- private:
-  friend str_format_internal::UntypedFormatSpecImpl;
-  str_format_internal::UntypedFormatSpecImpl spec_;
-};
-
-// FormatStreamed()
-//
-// Takes a streamable argument and returns an object that can print it
-// with '%s'. Allows printing of types that have an `operator<<` but no
-// intrinsic type support within `StrFormat()` itself.
-//
-// Example:
-//
-//   absl::StrFormat("%s", absl::FormatStreamed(obj));
-template <typename T>
-str_format_internal::StreamedWrapper<T> FormatStreamed(const T& v) {
-  return str_format_internal::StreamedWrapper<T>(v);
-}
-
-// FormatCountCapture
-//
-// This class provides a way to safely wrap `StrFormat()` captures of `%n`
-// conversions, which denote the number of characters written by a formatting
-// operation to this point, into an integer value.
-//
-// This wrapper is designed to allow safe usage of `%n` within `StrFormat(); in
-// the `printf()` family of functions, `%n` is not safe to use, as the `int *`
-// buffer can be used to capture arbitrary data.
-//
-// Example:
-//
-//   int n = 0;
-//   std::string s = absl::StrFormat("%s%d%n", "hello", 123,
-//                       absl::FormatCountCapture(&n));
-//   EXPECT_EQ(8, n);
-class FormatCountCapture {
- public:
-  explicit FormatCountCapture(int* p) : p_(p) {}
-
- private:
-  // FormatCountCaptureHelper is used to define FormatConvertImpl() for this
-  // class.
-  friend struct str_format_internal::FormatCountCaptureHelper;
-  // Unused() is here because of the false positive from -Wunused-private-field
-  // p_ is used in the templated function of the friend FormatCountCaptureHelper
-  // class.
-  int* Unused() { return p_; }
-  int* p_;
-};
-
-// FormatSpec
-//
-// The `FormatSpec` type defines the makeup of a format string within the
-// `str_format` library. It is a variadic class template that is evaluated at
-// compile-time, according to the format string and arguments that are passed to
-// it.
-//
-// You should not need to manipulate this type directly. You should only name it
-// if you are writing wrapper functions which accept format arguments that will
-// be provided unmodified to functions in this library. Such a wrapper function
-// might be a class method that provides format arguments and/or internally uses
-// the result of formatting.
-//
-// For a `FormatSpec` to be valid at compile-time, it must be provided as
-// either:
-//
-// * A `constexpr` literal or `absl::string_view`, which is how it most often
-//   used.
-// * A `ParsedFormat` instantiation, which ensures the format string is
-//   valid before use. (See below.)
-//
-// Example:
-//
-//   // Provided as a string literal.
-//   absl::StrFormat("Welcome to %s, Number %d!", "The Village", 6);
-//
-//   // Provided as a constexpr absl::string_view.
-//   constexpr absl::string_view formatString = "Welcome to %s, Number %d!";
-//   absl::StrFormat(formatString, "The Village", 6);
-//
-//   // Provided as a pre-compiled ParsedFormat object.
-//   // Note that this example is useful only for illustration purposes.
-//   absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
-//   absl::StrFormat(formatString, "TheVillage", 6);
-//
-// A format string generally follows the POSIX syntax as used within the POSIX
-// `printf` specification.
-//
-// (See http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html.)
-//
-// In specific, the `FormatSpec` supports the following type specifiers:
-//   * `c` for characters
-//   * `s` for strings
-//   * `d` or `i` for integers
-//   * `o` for unsigned integer conversions into octal
-//   * `x` or `X` for unsigned integer conversions into hex
-//   * `u` for unsigned integers
-//   * `f` or `F` for floating point values into decimal notation
-//   * `e` or `E` for floating point values into exponential notation
-//   * `a` or `A` for floating point values into hex exponential notation
-//   * `g` or `G` for floating point values into decimal or exponential
-//     notation based on their precision
-//   * `p` for pointer address values
-//   * `n` for the special case of writing out the number of characters
-//     written to this point. The resulting value must be captured within an
-//     `absl::FormatCountCapture` type.
-//
-// Implementation-defined behavior:
-//   * A null pointer provided to "%s" or "%p" is output as "(nil)".
-//   * A non-null pointer provided to "%p" is output in hex as if by %#x or
-//     %#lx.
-//
-// NOTE: `o`, `x\X` and `u` will convert signed values to their unsigned
-// counterpart before formatting.
-//
-// Examples:
-//     "%c", 'a'                -> "a"
-//     "%c", 32                 -> " "
-//     "%s", "C"                -> "C"
-//     "%s", std::string("C++") -> "C++"
-//     "%d", -10                -> "-10"
-//     "%o", 10                 -> "12"
-//     "%x", 16                 -> "10"
-//     "%f", 123456789          -> "123456789.000000"
-//     "%e", .01                -> "1.00000e-2"
-//     "%a", -3.0               -> "-0x1.8p+1"
-//     "%g", .01                -> "1e-2"
-//     "%p", (void*)&value      -> "0x7ffdeb6ad2a4"
-//
-//     int n = 0;
-//     std::string s = absl::StrFormat(
-//         "%s%d%n", "hello", 123, absl::FormatCountCapture(&n));
-//     EXPECT_EQ(8, n);
-//
-// The `FormatSpec` intrinsically supports all of these fundamental C++ types:
-//
-// *   Characters: `char`, `signed char`, `unsigned char`
-// *   Integers: `int`, `short`, `unsigned short`, `unsigned`, `long`,
-//         `unsigned long`, `long long`, `unsigned long long`
-// *   Floating-point: `float`, `double`, `long double`
-//
-// However, in the `str_format` library, a format conversion specifies a broader
-// C++ conceptual category instead of an exact type. For example, `%s` binds to
-// any string-like argument, so `std::string`, `absl::string_view`, and
-// `const char*` are all accepted. Likewise, `%d` accepts any integer-like
-// argument, etc.
-
-template <typename... Args>
-using FormatSpec = str_format_internal::FormatSpecTemplate<
-    str_format_internal::ArgumentToConv<Args>()...>;
-
-// ParsedFormat
-//
-// A `ParsedFormat` is a class template representing a preparsed `FormatSpec`,
-// with template arguments specifying the conversion characters used within the
-// format string. Such characters must be valid format type specifiers, and
-// these type specifiers are checked at compile-time.
-//
-// Instances of `ParsedFormat` can be created, copied, and reused to speed up
-// formatting loops. A `ParsedFormat` may either be constructed statically, or
-// dynamically through its `New()` factory function, which only constructs a
-// runtime object if the format is valid at that time.
-//
-// Example:
-//
-//   // Verified at compile time.
-//   absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
-//   absl::StrFormat(formatString, "TheVillage", 6);
-//
-//   // Verified at runtime.
-//   auto format_runtime = absl::ParsedFormat<'d'>::New(format_string);
-//   if (format_runtime) {
-//     value = absl::StrFormat(*format_runtime, i);
-//   } else {
-//     ... error case ...
-//   }
+#include "absl/strings/internal/str_format/parser.h"     // IWYU pragma: export
+
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // UntypedFormatSpec
+    //
+    // A type-erased class that can be used directly within untyped API entry
+    // points. An `UntypedFormatSpec` is specifically used as an argument to
+    // `FormatUntyped()`.
+    //
+    // Example:
+    //
+    //   absl::UntypedFormatSpec format("%d");
+    //   std::string out;
+    //   CHECK(absl::FormatUntyped(&out, format, {absl::FormatArg(1)}));
+    class UntypedFormatSpec
+    {
+    public:
+        UntypedFormatSpec() = delete;
+        UntypedFormatSpec(const UntypedFormatSpec&) = delete;
+        UntypedFormatSpec& operator=(const UntypedFormatSpec&) = delete;
+
+        explicit UntypedFormatSpec(string_view s) :
+            spec_(s)
+        {
+        }
+
+    protected:
+        explicit UntypedFormatSpec(const str_format_internal::ParsedFormatBase* pc) :
+            spec_(pc)
+        {
+        }
+
+    private:
+        friend str_format_internal::UntypedFormatSpecImpl;
+        str_format_internal::UntypedFormatSpecImpl spec_;
+    };
+
+    // FormatStreamed()
+    //
+    // Takes a streamable argument and returns an object that can print it
+    // with '%s'. Allows printing of types that have an `operator<<` but no
+    // intrinsic type support within `StrFormat()` itself.
+    //
+    // Example:
+    //
+    //   absl::StrFormat("%s", absl::FormatStreamed(obj));
+    template<typename T>
+    str_format_internal::StreamedWrapper<T> FormatStreamed(const T& v)
+    {
+        return str_format_internal::StreamedWrapper<T>(v);
+    }
+
+    // FormatCountCapture
+    //
+    // This class provides a way to safely wrap `StrFormat()` captures of `%n`
+    // conversions, which denote the number of characters written by a formatting
+    // operation to this point, into an integer value.
+    //
+    // This wrapper is designed to allow safe usage of `%n` within `StrFormat(); in
+    // the `printf()` family of functions, `%n` is not safe to use, as the `int *`
+    // buffer can be used to capture arbitrary data.
+    //
+    // Example:
+    //
+    //   int n = 0;
+    //   std::string s = absl::StrFormat("%s%d%n", "hello", 123,
+    //                       absl::FormatCountCapture(&n));
+    //   EXPECT_EQ(8, n);
+    class FormatCountCapture
+    {
+    public:
+        explicit FormatCountCapture(int* p) :
+            p_(p)
+        {
+        }
+
+    private:
+        // FormatCountCaptureHelper is used to define FormatConvertImpl() for this
+        // class.
+        friend struct str_format_internal::FormatCountCaptureHelper;
+        // Unused() is here because of the false positive from -Wunused-private-field
+        // p_ is used in the templated function of the friend FormatCountCaptureHelper
+        // class.
+        int* Unused()
+        {
+            return p_;
+        }
+        int* p_;
+    };
+
+    // FormatSpec
+    //
+    // The `FormatSpec` type defines the makeup of a format string within the
+    // `str_format` library. It is a variadic class template that is evaluated at
+    // compile-time, according to the format string and arguments that are passed to
+    // it.
+    //
+    // You should not need to manipulate this type directly. You should only name it
+    // if you are writing wrapper functions which accept format arguments that will
+    // be provided unmodified to functions in this library. Such a wrapper function
+    // might be a class method that provides format arguments and/or internally uses
+    // the result of formatting.
+    //
+    // For a `FormatSpec` to be valid at compile-time, it must be provided as
+    // either:
+    //
+    // * A `constexpr` literal or `absl::string_view`, which is how it most often
+    //   used.
+    // * A `ParsedFormat` instantiation, which ensures the format string is
+    //   valid before use. (See below.)
+    //
+    // Example:
+    //
+    //   // Provided as a string literal.
+    //   absl::StrFormat("Welcome to %s, Number %d!", "The Village", 6);
+    //
+    //   // Provided as a constexpr absl::string_view.
+    //   constexpr absl::string_view formatString = "Welcome to %s, Number %d!";
+    //   absl::StrFormat(formatString, "The Village", 6);
+    //
+    //   // Provided as a pre-compiled ParsedFormat object.
+    //   // Note that this example is useful only for illustration purposes.
+    //   absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
+    //   absl::StrFormat(formatString, "TheVillage", 6);
+    //
+    // A format string generally follows the POSIX syntax as used within the POSIX
+    // `printf` specification.
+    //
+    // (See http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html.)
+    //
+    // In specific, the `FormatSpec` supports the following type specifiers:
+    //   * `c` for characters
+    //   * `s` for strings
+    //   * `d` or `i` for integers
+    //   * `o` for unsigned integer conversions into octal
+    //   * `x` or `X` for unsigned integer conversions into hex
+    //   * `u` for unsigned integers
+    //   * `f` or `F` for floating point values into decimal notation
+    //   * `e` or `E` for floating point values into exponential notation
+    //   * `a` or `A` for floating point values into hex exponential notation
+    //   * `g` or `G` for floating point values into decimal or exponential
+    //     notation based on their precision
+    //   * `p` for pointer address values
+    //   * `n` for the special case of writing out the number of characters
+    //     written to this point. The resulting value must be captured within an
+    //     `absl::FormatCountCapture` type.
+    //
+    // Implementation-defined behavior:
+    //   * A null pointer provided to "%s" or "%p" is output as "(nil)".
+    //   * A non-null pointer provided to "%p" is output in hex as if by %#x or
+    //     %#lx.
+    //
+    // NOTE: `o`, `x\X` and `u` will convert signed values to their unsigned
+    // counterpart before formatting.
+    //
+    // Examples:
+    //     "%c", 'a'                -> "a"
+    //     "%c", 32                 -> " "
+    //     "%s", "C"                -> "C"
+    //     "%s", std::string("C++") -> "C++"
+    //     "%d", -10                -> "-10"
+    //     "%o", 10                 -> "12"
+    //     "%x", 16                 -> "10"
+    //     "%f", 123456789          -> "123456789.000000"
+    //     "%e", .01                -> "1.00000e-2"
+    //     "%a", -3.0               -> "-0x1.8p+1"
+    //     "%g", .01                -> "1e-2"
+    //     "%p", (void*)&value      -> "0x7ffdeb6ad2a4"
+    //
+    //     int n = 0;
+    //     std::string s = absl::StrFormat(
+    //         "%s%d%n", "hello", 123, absl::FormatCountCapture(&n));
+    //     EXPECT_EQ(8, n);
+    //
+    // The `FormatSpec` intrinsically supports all of these fundamental C++ types:
+    //
+    // *   Characters: `char`, `signed char`, `unsigned char`
+    // *   Integers: `int`, `short`, `unsigned short`, `unsigned`, `long`,
+    //         `unsigned long`, `long long`, `unsigned long long`
+    // *   Floating-point: `float`, `double`, `long double`
+    //
+    // However, in the `str_format` library, a format conversion specifies a broader
+    // C++ conceptual category instead of an exact type. For example, `%s` binds to
+    // any string-like argument, so `std::string`, `absl::string_view`, and
+    // `const char*` are all accepted. Likewise, `%d` accepts any integer-like
+    // argument, etc.
+
+    template<typename... Args>
+    using FormatSpec = str_format_internal::FormatSpecTemplate<
+        str_format_internal::ArgumentToConv<Args>()...>;
+
+    // ParsedFormat
+    //
+    // A `ParsedFormat` is a class template representing a preparsed `FormatSpec`,
+    // with template arguments specifying the conversion characters used within the
+    // format string. Such characters must be valid format type specifiers, and
+    // these type specifiers are checked at compile-time.
+    //
+    // Instances of `ParsedFormat` can be created, copied, and reused to speed up
+    // formatting loops. A `ParsedFormat` may either be constructed statically, or
+    // dynamically through its `New()` factory function, which only constructs a
+    // runtime object if the format is valid at that time.
+    //
+    // Example:
+    //
+    //   // Verified at compile time.
+    //   absl::ParsedFormat<'s', 'd'> formatString("Welcome to %s, Number %d!");
+    //   absl::StrFormat(formatString, "TheVillage", 6);
+    //
+    //   // Verified at runtime.
+    //   auto format_runtime = absl::ParsedFormat<'d'>::New(format_string);
+    //   if (format_runtime) {
+    //     value = absl::StrFormat(*format_runtime, i);
+    //   } else {
+    //     ... error case ...
+    //   }
 
 #if defined(__cpp_nontype_template_parameter_auto)
-// If C++17 is available, an 'extended' format is also allowed that can specify
-// multiple conversion characters per format argument, using a combination of
-// `absl::FormatConversionCharSet` enum values (logically a set union)
-//  via the `|` operator. (Single character-based arguments are still accepted,
-// but cannot be combined). Some common conversions also have predefined enum
-// values, such as `absl::FormatConversionCharSet::kIntegral`.
-//
-// Example:
-//   // Extended format supports multiple conversion characters per argument,
-//   // specified via a combination of `FormatConversionCharSet` enums.
-//   using MyFormat = absl::ParsedFormat<absl::FormatConversionCharSet::d |
-//                                       absl::FormatConversionCharSet::x>;
-//   MyFormat GetFormat(bool use_hex) {
-//     if (use_hex) return MyFormat("foo %x bar");
-//     return MyFormat("foo %d bar");
-//   }
-//   // `format` can be used with any value that supports 'd' and 'x',
-//   // like `int`.
-//   auto format = GetFormat(use_hex);
-//   value = StringF(format, i);
-template <auto... Conv>
-using ParsedFormat = absl::str_format_internal::ExtendedParsedFormat<
-    absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
+    // If C++17 is available, an 'extended' format is also allowed that can specify
+    // multiple conversion characters per format argument, using a combination of
+    // `absl::FormatConversionCharSet` enum values (logically a set union)
+    //  via the `|` operator. (Single character-based arguments are still accepted,
+    // but cannot be combined). Some common conversions also have predefined enum
+    // values, such as `absl::FormatConversionCharSet::kIntegral`.
+    //
+    // Example:
+    //   // Extended format supports multiple conversion characters per argument,
+    //   // specified via a combination of `FormatConversionCharSet` enums.
+    //   using MyFormat = absl::ParsedFormat<absl::FormatConversionCharSet::d |
+    //                                       absl::FormatConversionCharSet::x>;
+    //   MyFormat GetFormat(bool use_hex) {
+    //     if (use_hex) return MyFormat("foo %x bar");
+    //     return MyFormat("foo %d bar");
+    //   }
+    //   // `format` can be used with any value that supports 'd' and 'x',
+    //   // like `int`.
+    //   auto format = GetFormat(use_hex);
+    //   value = StringF(format, i);
+    template<auto... Conv>
+    using ParsedFormat = absl::str_format_internal::ExtendedParsedFormat<
+        absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
 #else
-template <char... Conv>
-using ParsedFormat = str_format_internal::ExtendedParsedFormat<
-    absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
+    template<char... Conv>
+    using ParsedFormat = str_format_internal::ExtendedParsedFormat<
+        absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
 #endif  // defined(__cpp_nontype_template_parameter_auto)
 
-// StrFormat()
-//
-// Returns a `string` given a `printf()`-style format string and zero or more
-// additional arguments. Use it as you would `sprintf()`. `StrFormat()` is the
-// primary formatting function within the `str_format` library, and should be
-// used in most cases where you need type-safe conversion of types into
-// formatted strings.
-//
-// The format string generally consists of ordinary character data along with
-// one or more format conversion specifiers (denoted by the `%` character).
-// Ordinary character data is returned unchanged into the result string, while
-// each conversion specification performs a type substitution from
-// `StrFormat()`'s other arguments. See the comments for `FormatSpec` for full
-// information on the makeup of this format string.
-//
-// Example:
-//
-//   std::string s = absl::StrFormat(
-//       "Welcome to %s, Number %d!", "The Village", 6);
-//   EXPECT_EQ("Welcome to The Village, Number 6!", s);
-//
-// Returns an empty string in case of error.
-template <typename... Args>
-ABSL_MUST_USE_RESULT std::string StrFormat(const FormatSpec<Args...>& format,
-                                           const Args&... args) {
-  return str_format_internal::FormatPack(
-      str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// StrAppendFormat()
-//
-// Appends to a `dst` string given a format string, and zero or more additional
-// arguments, returning `*dst` as a convenience for chaining purposes. Appends
-// nothing in case of error (but possibly alters its capacity).
-//
-// Example:
-//
-//   std::string orig("For example PI is approximately ");
-//   std::cout << StrAppendFormat(&orig, "%12.6f", 3.14);
-template <typename... Args>
-std::string& StrAppendFormat(std::string* dst,
-                             const FormatSpec<Args...>& format,
-                             const Args&... args) {
-  return str_format_internal::AppendPack(
-      dst, str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// StreamFormat()
-//
-// Writes to an output stream given a format string and zero or more arguments,
-// generally in a manner that is more efficient than streaming the result of
-// `absl:: StrFormat()`. The returned object must be streamed before the full
-// expression ends.
-//
-// Example:
-//
-//   std::cout << StreamFormat("%12.6f", 3.14);
-template <typename... Args>
-ABSL_MUST_USE_RESULT str_format_internal::Streamable StreamFormat(
-    const FormatSpec<Args...>& format, const Args&... args) {
-  return str_format_internal::Streamable(
-      str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// PrintF()
-//
-// Writes to stdout given a format string and zero or more arguments. This
-// function is functionally equivalent to `std::printf()` (and type-safe);
-// prefer `absl::PrintF()` over `std::printf()`.
-//
-// Example:
-//
-//   std::string_view s = "Ulaanbaatar";
-//   absl::PrintF("The capital of Mongolia is %s", s);
-//
-//   Outputs: "The capital of Mongolia is Ulaanbaatar"
-//
-template <typename... Args>
-int PrintF(const FormatSpec<Args...>& format, const Args&... args) {
-  return str_format_internal::FprintF(
-      stdout, str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// FPrintF()
-//
-// Writes to a file given a format string and zero or more arguments. This
-// function is functionally equivalent to `std::fprintf()` (and type-safe);
-// prefer `absl::FPrintF()` over `std::fprintf()`.
-//
-// Example:
-//
-//   std::string_view s = "Ulaanbaatar";
-//   absl::FPrintF(stdout, "The capital of Mongolia is %s", s);
-//
-//   Outputs: "The capital of Mongolia is Ulaanbaatar"
-//
-template <typename... Args>
-int FPrintF(std::FILE* output, const FormatSpec<Args...>& format,
-            const Args&... args) {
-  return str_format_internal::FprintF(
-      output, str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// SNPrintF()
-//
-// Writes to a sized buffer given a format string and zero or more arguments.
-// This function is functionally equivalent to `std::snprintf()` (and
-// type-safe); prefer `absl::SNPrintF()` over `std::snprintf()`.
-//
-// In particular, a successful call to `absl::SNPrintF()` writes at most `size`
-// bytes of the formatted output to `output`, including a NUL-terminator, and
-// returns the number of bytes that would have been written if truncation did
-// not occur. In the event of an error, a negative value is returned and `errno`
-// is set.
-//
-// Example:
-//
-//   std::string_view s = "Ulaanbaatar";
-//   char output[128];
-//   absl::SNPrintF(output, sizeof(output),
-//                  "The capital of Mongolia is %s", s);
-//
-//   Post-condition: output == "The capital of Mongolia is Ulaanbaatar"
-//
-template <typename... Args>
-int SNPrintF(char* output, std::size_t size, const FormatSpec<Args...>& format,
-             const Args&... args) {
-  return str_format_internal::SnprintF(
-      output, size, str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// -----------------------------------------------------------------------------
-// Custom Output Formatting Functions
-// -----------------------------------------------------------------------------
-
-// FormatRawSink
-//
-// FormatRawSink is a type erased wrapper around arbitrary sink objects
-// specifically used as an argument to `Format()`.
-//
-// All the object has to do define an overload of `AbslFormatFlush()` for the
-// sink, usually by adding a ADL-based free function in the same namespace as
-// the sink:
-//
-//   void AbslFormatFlush(MySink* dest, absl::string_view part);
-//
-// where `dest` is the pointer passed to `absl::Format()`. The function should
-// append `part` to `dest`.
-//
-// FormatRawSink does not own the passed sink object. The passed object must
-// outlive the FormatRawSink.
-class FormatRawSink {
- public:
-  // Implicitly convert from any type that provides the hook function as
-  // described above.
-  template <typename T,
-            typename = typename std::enable_if<std::is_constructible<
-                str_format_internal::FormatRawSinkImpl, T*>::value>::type>
-  FormatRawSink(T* raw)  // NOLINT
-      : sink_(raw) {}
-
- private:
-  friend str_format_internal::FormatRawSinkImpl;
-  str_format_internal::FormatRawSinkImpl sink_;
-};
-
-// Format()
-//
-// Writes a formatted string to an arbitrary sink object (implementing the
-// `absl::FormatRawSink` interface), using a format string and zero or more
-// additional arguments.
-//
-// By default, `std::string`, `std::ostream`, and `absl::Cord` are supported as
-// destination objects. If a `std::string` is used the formatted string is
-// appended to it.
-//
-// `absl::Format()` is a generic version of `absl::StrAppendFormat()`, for
-// custom sinks. The format string, like format strings for `StrFormat()`, is
-// checked at compile-time.
-//
-// On failure, this function returns `false` and the state of the sink is
-// unspecified.
-template <typename... Args>
-bool Format(FormatRawSink raw_sink, const FormatSpec<Args...>& format,
-            const Args&... args) {
-  return str_format_internal::FormatUntyped(
-      str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
-      str_format_internal::UntypedFormatSpecImpl::Extract(format),
-      {str_format_internal::FormatArgImpl(args)...});
-}
-
-// FormatArg
-//
-// A type-erased handle to a format argument specifically used as an argument to
-// `FormatUntyped()`. You may construct `FormatArg` by passing
-// reference-to-const of any printable type. `FormatArg` is both copyable and
-// assignable. The source data must outlive the `FormatArg` instance. See
-// example below.
-//
-using FormatArg = str_format_internal::FormatArgImpl;
-
-// FormatUntyped()
-//
-// Writes a formatted string to an arbitrary sink object (implementing the
-// `absl::FormatRawSink` interface), using an `UntypedFormatSpec` and zero or
-// more additional arguments.
-//
-// This function acts as the most generic formatting function in the
-// `str_format` library. The caller provides a raw sink, an unchecked format
-// string, and (usually) a runtime specified list of arguments; no compile-time
-// checking of formatting is performed within this function. As a result, a
-// caller should check the return value to verify that no error occurred.
-// On failure, this function returns `false` and the state of the sink is
-// unspecified.
-//
-// The arguments are provided in an `absl::Span<const absl::FormatArg>`.
-// Each `absl::FormatArg` object binds to a single argument and keeps a
-// reference to it. The values used to create the `FormatArg` objects must
-// outlive this function call.
-//
-// Example:
-//
-//   std::optional<std::string> FormatDynamic(
-//       const std::string& in_format,
-//       const vector<std::string>& in_args) {
-//     std::string out;
-//     std::vector<absl::FormatArg> args;
-//     for (const auto& v : in_args) {
-//       // It is important that 'v' is a reference to the objects in in_args.
-//       // The values we pass to FormatArg must outlive the call to
-//       // FormatUntyped.
-//       args.emplace_back(v);
-//     }
-//     absl::UntypedFormatSpec format(in_format);
-//     if (!absl::FormatUntyped(&out, format, args)) {
-//       return std::nullopt;
-//     }
-//     return std::move(out);
-//   }
-//
-ABSL_MUST_USE_RESULT inline bool FormatUntyped(
-    FormatRawSink raw_sink, const UntypedFormatSpec& format,
-    absl::Span<const FormatArg> args) {
-  return str_format_internal::FormatUntyped(
-      str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
-      str_format_internal::UntypedFormatSpecImpl::Extract(format), args);
-}
-
-//------------------------------------------------------------------------------
-// StrFormat Extensions
-//------------------------------------------------------------------------------
-//
-// AbslFormatConvert()
-//
-// The StrFormat library provides a customization API for formatting
-// user-defined types using absl::StrFormat(). The API relies on detecting an
-// overload in the user-defined type's namespace of a free (non-member)
-// `AbslFormatConvert()` function, usually as a friend definition with the
-// following signature:
-//
-// absl::FormatConvertResult<...> AbslFormatConvert(
-//     const X& value,
-//     const absl::FormatConversionSpec& spec,
-//     absl::FormatSink *sink);
-//
-// An `AbslFormatConvert()` overload for a type should only be declared in the
-// same file and namespace as said type.
-//
-// The abstractions within this definition include:
-//
-// * An `absl::FormatConversionSpec` to specify the fields to pull from a
-//   user-defined type's format string
-// * An `absl::FormatSink` to hold the converted string data during the
-//   conversion process.
-// * An `absl::FormatConvertResult` to hold the status of the returned
-//   formatting operation
-//
-// The return type encodes all the conversion characters that your
-// AbslFormatConvert() routine accepts.  The return value should be {true}.
-// A return value of {false} will result in `StrFormat()` returning
-// an empty string.  This result will be propagated to the result of
-// `FormatUntyped`.
-//
-// Example:
-//
-// struct Point {
-//   // To add formatting support to `Point`, we simply need to add a free
-//   // (non-member) function `AbslFormatConvert()`.  This method interprets
-//   // `spec` to print in the request format. The allowed conversion characters
-//   // can be restricted via the type of the result, in this example
-//   // string and integral formatting are allowed (but not, for instance
-//   // floating point characters like "%f").  You can add such a free function
-//   // using a friend declaration within the body of the class:
-//   friend absl::FormatConvertResult<absl::FormatConversionCharSet::kString |
-//                                    absl::FormatConversionCharSet::kIntegral>
-//   AbslFormatConvert(const Point& p, const absl::FormatConversionSpec& spec,
-//                     absl::FormatSink* s) {
-//     if (spec.conversion_char() == absl::FormatConversionChar::s) {
-//       s->Append(absl::StrCat("x=", p.x, " y=", p.y));
-//     } else {
-//       s->Append(absl::StrCat(p.x, ",", p.y));
-//     }
-//     return {true};
-//   }
-//
-//   int x;
-//   int y;
-// };
-
-// clang-format off
+    // StrFormat()
+    //
+    // Returns a `string` given a `printf()`-style format string and zero or more
+    // additional arguments. Use it as you would `sprintf()`. `StrFormat()` is the
+    // primary formatting function within the `str_format` library, and should be
+    // used in most cases where you need type-safe conversion of types into
+    // formatted strings.
+    //
+    // The format string generally consists of ordinary character data along with
+    // one or more format conversion specifiers (denoted by the `%` character).
+    // Ordinary character data is returned unchanged into the result string, while
+    // each conversion specification performs a type substitution from
+    // `StrFormat()`'s other arguments. See the comments for `FormatSpec` for full
+    // information on the makeup of this format string.
+    //
+    // Example:
+    //
+    //   std::string s = absl::StrFormat(
+    //       "Welcome to %s, Number %d!", "The Village", 6);
+    //   EXPECT_EQ("Welcome to The Village, Number 6!", s);
+    //
+    // Returns an empty string in case of error.
+    template<typename... Args>
+    ABSL_MUST_USE_RESULT std::string StrFormat(const FormatSpec<Args...>& format, const Args&... args)
+    {
+        return str_format_internal::FormatPack(
+            str_format_internal::UntypedFormatSpecImpl::Extract(format),
+            {str_format_internal::FormatArgImpl(args)...}
+        );
+    }
+
+    // StrAppendFormat()
+    //
+    // Appends to a `dst` string given a format string, and zero or more additional
+    // arguments, returning `*dst` as a convenience for chaining purposes. Appends
+    // nothing in case of error (but possibly alters its capacity).
+    //
+    // Example:
+    //
+    //   std::string orig("For example PI is approximately ");
+    //   std::cout << StrAppendFormat(&orig, "%12.6f", 3.14);
+    template<typename... Args>
+    std::string& StrAppendFormat(std::string* dst, const FormatSpec<Args...>& format, const Args&... args)
+    {
+        return str_format_internal::AppendPack(
+            dst, str_format_internal::UntypedFormatSpecImpl::Extract(format), {str_format_internal::FormatArgImpl(args)...}
+        );
+    }
+
+    // StreamFormat()
+    //
+    // Writes to an output stream given a format string and zero or more arguments,
+    // generally in a manner that is more efficient than streaming the result of
+    // `absl:: StrFormat()`. The returned object must be streamed before the full
+    // expression ends.
+    //
+    // Example:
+    //
+    //   std::cout << StreamFormat("%12.6f", 3.14);
+    template<typename... Args>
+    ABSL_MUST_USE_RESULT str_format_internal::Streamable StreamFormat(
+        const FormatSpec<Args...>& format, const Args&... args
+    )
+    {
+        return str_format_internal::Streamable(
+            str_format_internal::UntypedFormatSpecImpl::Extract(format),
+            {str_format_internal::FormatArgImpl(args)...}
+        );
+    }
+
+    // PrintF()
+    //
+    // Writes to stdout given a format string and zero or more arguments. This
+    // function is functionally equivalent to `std::printf()` (and type-safe);
+    // prefer `absl::PrintF()` over `std::printf()`.
+    //
+    // Example:
+    //
+    //   std::string_view s = "Ulaanbaatar";
+    //   absl::PrintF("The capital of Mongolia is %s", s);
+    //
+    //   Outputs: "The capital of Mongolia is Ulaanbaatar"
+    //
+    template<typename... Args>
+    int PrintF(const FormatSpec<Args...>& format, const Args&... args)
+    {
+        return str_format_internal::FprintF(
+            stdout, str_format_internal::UntypedFormatSpecImpl::Extract(format), {str_format_internal::FormatArgImpl(args)...}
+        );
+    }
+
+    // FPrintF()
+    //
+    // Writes to a file given a format string and zero or more arguments. This
+    // function is functionally equivalent to `std::fprintf()` (and type-safe);
+    // prefer `absl::FPrintF()` over `std::fprintf()`.
+    //
+    // Example:
+    //
+    //   std::string_view s = "Ulaanbaatar";
+    //   absl::FPrintF(stdout, "The capital of Mongolia is %s", s);
+    //
+    //   Outputs: "The capital of Mongolia is Ulaanbaatar"
+    //
+    template<typename... Args>
+    int FPrintF(std::FILE* output, const FormatSpec<Args...>& format, const Args&... args)
+    {
+        return str_format_internal::FprintF(
+            output, str_format_internal::UntypedFormatSpecImpl::Extract(format), {str_format_internal::FormatArgImpl(args)...}
+        );
+    }
+
+    // SNPrintF()
+    //
+    // Writes to a sized buffer given a format string and zero or more arguments.
+    // This function is functionally equivalent to `std::snprintf()` (and
+    // type-safe); prefer `absl::SNPrintF()` over `std::snprintf()`.
+    //
+    // In particular, a successful call to `absl::SNPrintF()` writes at most `size`
+    // bytes of the formatted output to `output`, including a NUL-terminator, and
+    // returns the number of bytes that would have been written if truncation did
+    // not occur. In the event of an error, a negative value is returned and `errno`
+    // is set.
+    //
+    // Example:
+    //
+    //   std::string_view s = "Ulaanbaatar";
+    //   char output[128];
+    //   absl::SNPrintF(output, sizeof(output),
+    //                  "The capital of Mongolia is %s", s);
+    //
+    //   Post-condition: output == "The capital of Mongolia is Ulaanbaatar"
+    //
+    template<typename... Args>
+    int SNPrintF(char* output, std::size_t size, const FormatSpec<Args...>& format, const Args&... args)
+    {
+        return str_format_internal::SnprintF(
+            output, size, str_format_internal::UntypedFormatSpecImpl::Extract(format), {str_format_internal::FormatArgImpl(args)...}
+        );
+    }
+
+    // -----------------------------------------------------------------------------
+    // Custom Output Formatting Functions
+    // -----------------------------------------------------------------------------
+
+    // FormatRawSink
+    //
+    // FormatRawSink is a type erased wrapper around arbitrary sink objects
+    // specifically used as an argument to `Format()`.
+    //
+    // All the object has to do define an overload of `AbslFormatFlush()` for the
+    // sink, usually by adding a ADL-based free function in the same namespace as
+    // the sink:
+    //
+    //   void AbslFormatFlush(MySink* dest, absl::string_view part);
+    //
+    // where `dest` is the pointer passed to `absl::Format()`. The function should
+    // append `part` to `dest`.
+    //
+    // FormatRawSink does not own the passed sink object. The passed object must
+    // outlive the FormatRawSink.
+    class FormatRawSink
+    {
+    public:
+        // Implicitly convert from any type that provides the hook function as
+        // described above.
+        template<typename T, typename = typename std::enable_if<std::is_constructible<str_format_internal::FormatRawSinkImpl, T*>::value>::type>
+        FormatRawSink(T* raw)  // NOLINT
+            :
+            sink_(raw)
+        {
+        }
+
+    private:
+        friend str_format_internal::FormatRawSinkImpl;
+        str_format_internal::FormatRawSinkImpl sink_;
+    };
+
+    // Format()
+    //
+    // Writes a formatted string to an arbitrary sink object (implementing the
+    // `absl::FormatRawSink` interface), using a format string and zero or more
+    // additional arguments.
+    //
+    // By default, `std::string`, `std::ostream`, and `absl::Cord` are supported as
+    // destination objects. If a `std::string` is used the formatted string is
+    // appended to it.
+    //
+    // `absl::Format()` is a generic version of `absl::StrAppendFormat()`, for
+    // custom sinks. The format string, like format strings for `StrFormat()`, is
+    // checked at compile-time.
+    //
+    // On failure, this function returns `false` and the state of the sink is
+    // unspecified.
+    template<typename... Args>
+    bool Format(FormatRawSink raw_sink, const FormatSpec<Args...>& format, const Args&... args)
+    {
+        return str_format_internal::FormatUntyped(
+            str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
+            str_format_internal::UntypedFormatSpecImpl::Extract(format),
+            {str_format_internal::FormatArgImpl(args)...}
+        );
+    }
+
+    // FormatArg
+    //
+    // A type-erased handle to a format argument specifically used as an argument to
+    // `FormatUntyped()`. You may construct `FormatArg` by passing
+    // reference-to-const of any printable type. `FormatArg` is both copyable and
+    // assignable. The source data must outlive the `FormatArg` instance. See
+    // example below.
+    //
+    using FormatArg = str_format_internal::FormatArgImpl;
+
+    // FormatUntyped()
+    //
+    // Writes a formatted string to an arbitrary sink object (implementing the
+    // `absl::FormatRawSink` interface), using an `UntypedFormatSpec` and zero or
+    // more additional arguments.
+    //
+    // This function acts as the most generic formatting function in the
+    // `str_format` library. The caller provides a raw sink, an unchecked format
+    // string, and (usually) a runtime specified list of arguments; no compile-time
+    // checking of formatting is performed within this function. As a result, a
+    // caller should check the return value to verify that no error occurred.
+    // On failure, this function returns `false` and the state of the sink is
+    // unspecified.
+    //
+    // The arguments are provided in an `absl::Span<const absl::FormatArg>`.
+    // Each `absl::FormatArg` object binds to a single argument and keeps a
+    // reference to it. The values used to create the `FormatArg` objects must
+    // outlive this function call.
+    //
+    // Example:
+    //
+    //   std::optional<std::string> FormatDynamic(
+    //       const std::string& in_format,
+    //       const vector<std::string>& in_args) {
+    //     std::string out;
+    //     std::vector<absl::FormatArg> args;
+    //     for (const auto& v : in_args) {
+    //       // It is important that 'v' is a reference to the objects in in_args.
+    //       // The values we pass to FormatArg must outlive the call to
+    //       // FormatUntyped.
+    //       args.emplace_back(v);
+    //     }
+    //     absl::UntypedFormatSpec format(in_format);
+    //     if (!absl::FormatUntyped(&out, format, args)) {
+    //       return std::nullopt;
+    //     }
+    //     return std::move(out);
+    //   }
+    //
+    ABSL_MUST_USE_RESULT inline bool FormatUntyped(
+        FormatRawSink raw_sink, const UntypedFormatSpec& format, absl::Span<const FormatArg> args
+    )
+    {
+        return str_format_internal::FormatUntyped(
+            str_format_internal::FormatRawSinkImpl::Extract(raw_sink),
+            str_format_internal::UntypedFormatSpecImpl::Extract(format),
+            args
+        );
+    }
+
+    //------------------------------------------------------------------------------
+    // StrFormat Extensions
+    //------------------------------------------------------------------------------
+    //
+    // AbslFormatConvert()
+    //
+    // The StrFormat library provides a customization API for formatting
+    // user-defined types using absl::StrFormat(). The API relies on detecting an
+    // overload in the user-defined type's namespace of a free (non-member)
+    // `AbslFormatConvert()` function, usually as a friend definition with the
+    // following signature:
+    //
+    // absl::FormatConvertResult<...> AbslFormatConvert(
+    //     const X& value,
+    //     const absl::FormatConversionSpec& spec,
+    //     absl::FormatSink *sink);
+    //
+    // An `AbslFormatConvert()` overload for a type should only be declared in the
+    // same file and namespace as said type.
+    //
+    // The abstractions within this definition include:
+    //
+    // * An `absl::FormatConversionSpec` to specify the fields to pull from a
+    //   user-defined type's format string
+    // * An `absl::FormatSink` to hold the converted string data during the
+    //   conversion process.
+    // * An `absl::FormatConvertResult` to hold the status of the returned
+    //   formatting operation
+    //
+    // The return type encodes all the conversion characters that your
+    // AbslFormatConvert() routine accepts.  The return value should be {true}.
+    // A return value of {false} will result in `StrFormat()` returning
+    // an empty string.  This result will be propagated to the result of
+    // `FormatUntyped`.
+    //
+    // Example:
+    //
+    // struct Point {
+    //   // To add formatting support to `Point`, we simply need to add a free
+    //   // (non-member) function `AbslFormatConvert()`.  This method interprets
+    //   // `spec` to print in the request format. The allowed conversion characters
+    //   // can be restricted via the type of the result, in this example
+    //   // string and integral formatting are allowed (but not, for instance
+    //   // floating point characters like "%f").  You can add such a free function
+    //   // using a friend declaration within the body of the class:
+    //   friend absl::FormatConvertResult<absl::FormatConversionCharSet::kString |
+    //                                    absl::FormatConversionCharSet::kIntegral>
+    //   AbslFormatConvert(const Point& p, const absl::FormatConversionSpec& spec,
+    //                     absl::FormatSink* s) {
+    //     if (spec.conversion_char() == absl::FormatConversionChar::s) {
+    //       s->Append(absl::StrCat("x=", p.x, " y=", p.y));
+    //     } else {
+    //       s->Append(absl::StrCat(p.x, ",", p.y));
+    //     }
+    //     return {true};
+    //   }
+    //
+    //   int x;
+    //   int y;
+    // };
+
+    // clang-format off
 
 // FormatConversionChar
 //
@@ -639,174 +664,216 @@ enum class FormatConversionChar : uint8_t {
   f, F, e, E, g, G, a, A,  // float
   n, p                     // misc
 };
-// clang-format on
-
-// FormatConversionSpec
-//
-// Specifies modifications to the conversion of the format string, through use
-// of one or more format flags in the source format string.
-class FormatConversionSpec {
- public:
-  // FormatConversionSpec::is_basic()
-  //
-  // Indicates that width and precision are not specified, and no additional
-  // flags are set for this conversion character in the format string.
-  bool is_basic() const { return impl_.is_basic(); }
-
-  // FormatConversionSpec::has_left_flag()
-  //
-  // Indicates whether the result should be left justified for this conversion
-  // character in the format string. This flag is set through use of a '-'
-  // character in the format string. E.g. "%-s"
-  bool has_left_flag() const { return impl_.has_left_flag(); }
-
-  // FormatConversionSpec::has_show_pos_flag()
-  //
-  // Indicates whether a sign column is prepended to the result for this
-  // conversion character in the format string, even if the result is positive.
-  // This flag is set through use of a '+' character in the format string.
-  // E.g. "%+d"
-  bool has_show_pos_flag() const { return impl_.has_show_pos_flag(); }
-
-  // FormatConversionSpec::has_sign_col_flag()
-  //
-  // Indicates whether a mandatory sign column is added to the result for this
-  // conversion character. This flag is set through use of a space character
-  // (' ') in the format string. E.g. "% i"
-  bool has_sign_col_flag() const { return impl_.has_sign_col_flag(); }
-
-  // FormatConversionSpec::has_alt_flag()
-  //
-  // Indicates whether an "alternate" format is applied to the result for this
-  // conversion character. Alternative forms depend on the type of conversion
-  // character, and unallowed alternatives are undefined. This flag is set
-  // through use of a '#' character in the format string. E.g. "%#h"
-  bool has_alt_flag() const { return impl_.has_alt_flag(); }
-
-  // FormatConversionSpec::has_zero_flag()
-  //
-  // Indicates whether zeroes should be prepended to the result for this
-  // conversion character instead of spaces. This flag is set through use of the
-  // '0' character in the format string. E.g. "%0f"
-  bool has_zero_flag() const { return impl_.has_zero_flag(); }
-
-  // FormatConversionSpec::conversion_char()
-  //
-  // Returns the underlying conversion character.
-  FormatConversionChar conversion_char() const {
-    return impl_.conversion_char();
-  }
-
-  // FormatConversionSpec::width()
-  //
-  // Returns the specified width (indicated through use of a non-zero integer
-  // value or '*' character) of the conversion character. If width is
-  // unspecified, it returns a negative value.
-  int width() const { return impl_.width(); }
-
-  // FormatConversionSpec::precision()
-  //
-  // Returns the specified precision (through use of the '.' character followed
-  // by a non-zero integer value or '*' character) of the conversion character.
-  // If precision is unspecified, it returns a negative value.
-  int precision() const { return impl_.precision(); }
-
- private:
-  explicit FormatConversionSpec(
-      str_format_internal::FormatConversionSpecImpl impl)
-      : impl_(impl) {}
-
-  friend str_format_internal::FormatConversionSpecImpl;
-
-  absl::str_format_internal::FormatConversionSpecImpl impl_;
-};
-
-// Type safe OR operator for FormatConversionCharSet to allow accepting multiple
-// conversion chars in custom format converters.
-constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
-                                            FormatConversionCharSet b) {
-  return static_cast<FormatConversionCharSet>(static_cast<uint64_t>(a) |
-                                              static_cast<uint64_t>(b));
-}
-
-// FormatConversionCharSet
-//
-// Specifies the _accepted_ conversion types as a template parameter to
-// FormatConvertResult for custom implementations of `AbslFormatConvert`.
-// Note the helper predefined alias definitions (kIntegral, etc.) below.
-enum class FormatConversionCharSet : uint64_t {
-  // text
-  c = str_format_internal::FormatConversionCharToConvInt('c'),
-  s = str_format_internal::FormatConversionCharToConvInt('s'),
-  // integer
-  d = str_format_internal::FormatConversionCharToConvInt('d'),
-  i = str_format_internal::FormatConversionCharToConvInt('i'),
-  o = str_format_internal::FormatConversionCharToConvInt('o'),
-  u = str_format_internal::FormatConversionCharToConvInt('u'),
-  x = str_format_internal::FormatConversionCharToConvInt('x'),
-  X = str_format_internal::FormatConversionCharToConvInt('X'),
-  // Float
-  f = str_format_internal::FormatConversionCharToConvInt('f'),
-  F = str_format_internal::FormatConversionCharToConvInt('F'),
-  e = str_format_internal::FormatConversionCharToConvInt('e'),
-  E = str_format_internal::FormatConversionCharToConvInt('E'),
-  g = str_format_internal::FormatConversionCharToConvInt('g'),
-  G = str_format_internal::FormatConversionCharToConvInt('G'),
-  a = str_format_internal::FormatConversionCharToConvInt('a'),
-  A = str_format_internal::FormatConversionCharToConvInt('A'),
-  // misc
-  n = str_format_internal::FormatConversionCharToConvInt('n'),
-  p = str_format_internal::FormatConversionCharToConvInt('p'),
-
-  // Used for width/precision '*' specification.
-  kStar = static_cast<uint64_t>(
-      absl::str_format_internal::FormatConversionCharSetInternal::kStar),
-  // Some predefined values:
-  kIntegral = d | i | u | o | x | X,
-  kFloating = a | e | f | g | A | E | F | G,
-  kNumeric = kIntegral | kFloating,
-  kString = s,
-  kPointer = p,
-};
-
-// FormatSink
-//
-// An abstraction to which conversions write their string data.
-//
-class FormatSink {
- public:
-  // Appends `count` copies of `ch`.
-  void Append(size_t count, char ch) { sink_->Append(count, ch); }
-
-  void Append(string_view v) { sink_->Append(v); }
-
-  // Appends the first `precision` bytes of `v`. If this is less than
-  // `width`, spaces will be appended first (if `left` is false), or
-  // after (if `left` is true) to ensure the total amount appended is
-  // at least `width`.
-  bool PutPaddedString(string_view v, int width, int precision, bool left) {
-    return sink_->PutPaddedString(v, width, precision, left);
-  }
-
- private:
-  friend str_format_internal::FormatSinkImpl;
-  explicit FormatSink(str_format_internal::FormatSinkImpl* s) : sink_(s) {}
-  str_format_internal::FormatSinkImpl* sink_;
-};
-
-// FormatConvertResult
-//
-// Indicates whether a call to AbslFormatConvert() was successful.
-// This return type informs the StrFormat extension framework (through
-// ADL but using the return type) of what conversion characters are supported.
-// It is strongly discouraged to return {false}, as this will result in an
-// empty string in StrFormat.
-template <FormatConversionCharSet C>
-struct FormatConvertResult {
-  bool value;
-};
-
-ABSL_NAMESPACE_END
+    // clang-format on
+
+    // FormatConversionSpec
+    //
+    // Specifies modifications to the conversion of the format string, through use
+    // of one or more format flags in the source format string.
+    class FormatConversionSpec
+    {
+    public:
+        // FormatConversionSpec::is_basic()
+        //
+        // Indicates that width and precision are not specified, and no additional
+        // flags are set for this conversion character in the format string.
+        bool is_basic() const
+        {
+            return impl_.is_basic();
+        }
+
+        // FormatConversionSpec::has_left_flag()
+        //
+        // Indicates whether the result should be left justified for this conversion
+        // character in the format string. This flag is set through use of a '-'
+        // character in the format string. E.g. "%-s"
+        bool has_left_flag() const
+        {
+            return impl_.has_left_flag();
+        }
+
+        // FormatConversionSpec::has_show_pos_flag()
+        //
+        // Indicates whether a sign column is prepended to the result for this
+        // conversion character in the format string, even if the result is positive.
+        // This flag is set through use of a '+' character in the format string.
+        // E.g. "%+d"
+        bool has_show_pos_flag() const
+        {
+            return impl_.has_show_pos_flag();
+        }
+
+        // FormatConversionSpec::has_sign_col_flag()
+        //
+        // Indicates whether a mandatory sign column is added to the result for this
+        // conversion character. This flag is set through use of a space character
+        // (' ') in the format string. E.g. "% i"
+        bool has_sign_col_flag() const
+        {
+            return impl_.has_sign_col_flag();
+        }
+
+        // FormatConversionSpec::has_alt_flag()
+        //
+        // Indicates whether an "alternate" format is applied to the result for this
+        // conversion character. Alternative forms depend on the type of conversion
+        // character, and unallowed alternatives are undefined. This flag is set
+        // through use of a '#' character in the format string. E.g. "%#h"
+        bool has_alt_flag() const
+        {
+            return impl_.has_alt_flag();
+        }
+
+        // FormatConversionSpec::has_zero_flag()
+        //
+        // Indicates whether zeroes should be prepended to the result for this
+        // conversion character instead of spaces. This flag is set through use of the
+        // '0' character in the format string. E.g. "%0f"
+        bool has_zero_flag() const
+        {
+            return impl_.has_zero_flag();
+        }
+
+        // FormatConversionSpec::conversion_char()
+        //
+        // Returns the underlying conversion character.
+        FormatConversionChar conversion_char() const
+        {
+            return impl_.conversion_char();
+        }
+
+        // FormatConversionSpec::width()
+        //
+        // Returns the specified width (indicated through use of a non-zero integer
+        // value or '*' character) of the conversion character. If width is
+        // unspecified, it returns a negative value.
+        int width() const
+        {
+            return impl_.width();
+        }
+
+        // FormatConversionSpec::precision()
+        //
+        // Returns the specified precision (through use of the '.' character followed
+        // by a non-zero integer value or '*' character) of the conversion character.
+        // If precision is unspecified, it returns a negative value.
+        int precision() const
+        {
+            return impl_.precision();
+        }
+
+    private:
+        explicit FormatConversionSpec(
+            str_format_internal::FormatConversionSpecImpl impl
+        ) :
+            impl_(impl)
+        {
+        }
+
+        friend str_format_internal::FormatConversionSpecImpl;
+
+        absl::str_format_internal::FormatConversionSpecImpl impl_;
+    };
+
+    // Type safe OR operator for FormatConversionCharSet to allow accepting multiple
+    // conversion chars in custom format converters.
+    constexpr FormatConversionCharSet operator|(FormatConversionCharSet a, FormatConversionCharSet b)
+    {
+        return static_cast<FormatConversionCharSet>(static_cast<uint64_t>(a) | static_cast<uint64_t>(b));
+    }
+
+    // FormatConversionCharSet
+    //
+    // Specifies the _accepted_ conversion types as a template parameter to
+    // FormatConvertResult for custom implementations of `AbslFormatConvert`.
+    // Note the helper predefined alias definitions (kIntegral, etc.) below.
+    enum class FormatConversionCharSet : uint64_t
+    {
+        // text
+        c = str_format_internal::FormatConversionCharToConvInt('c'),
+        s = str_format_internal::FormatConversionCharToConvInt('s'),
+        // integer
+        d = str_format_internal::FormatConversionCharToConvInt('d'),
+        i = str_format_internal::FormatConversionCharToConvInt('i'),
+        o = str_format_internal::FormatConversionCharToConvInt('o'),
+        u = str_format_internal::FormatConversionCharToConvInt('u'),
+        x = str_format_internal::FormatConversionCharToConvInt('x'),
+        X = str_format_internal::FormatConversionCharToConvInt('X'),
+        // Float
+        f = str_format_internal::FormatConversionCharToConvInt('f'),
+        F = str_format_internal::FormatConversionCharToConvInt('F'),
+        e = str_format_internal::FormatConversionCharToConvInt('e'),
+        E = str_format_internal::FormatConversionCharToConvInt('E'),
+        g = str_format_internal::FormatConversionCharToConvInt('g'),
+        G = str_format_internal::FormatConversionCharToConvInt('G'),
+        a = str_format_internal::FormatConversionCharToConvInt('a'),
+        A = str_format_internal::FormatConversionCharToConvInt('A'),
+        // misc
+        n = str_format_internal::FormatConversionCharToConvInt('n'),
+        p = str_format_internal::FormatConversionCharToConvInt('p'),
+
+        // Used for width/precision '*' specification.
+        kStar = static_cast<uint64_t>(
+            absl::str_format_internal::FormatConversionCharSetInternal::kStar
+        ),
+        // Some predefined values:
+        kIntegral = d | i | u | o | x | X,
+        kFloating = a | e | f | g | A | E | F | G,
+        kNumeric = kIntegral | kFloating,
+        kString = s,
+        kPointer = p,
+    };
+
+    // FormatSink
+    //
+    // An abstraction to which conversions write their string data.
+    //
+    class FormatSink
+    {
+    public:
+        // Appends `count` copies of `ch`.
+        void Append(size_t count, char ch)
+        {
+            sink_->Append(count, ch);
+        }
+
+        void Append(string_view v)
+        {
+            sink_->Append(v);
+        }
+
+        // Appends the first `precision` bytes of `v`. If this is less than
+        // `width`, spaces will be appended first (if `left` is false), or
+        // after (if `left` is true) to ensure the total amount appended is
+        // at least `width`.
+        bool PutPaddedString(string_view v, int width, int precision, bool left)
+        {
+            return sink_->PutPaddedString(v, width, precision, left);
+        }
+
+    private:
+        friend str_format_internal::FormatSinkImpl;
+        explicit FormatSink(str_format_internal::FormatSinkImpl* s) :
+            sink_(s)
+        {
+        }
+        str_format_internal::FormatSinkImpl* sink_;
+    };
+
+    // FormatConvertResult
+    //
+    // Indicates whether a call to AbslFormatConvert() was successful.
+    // This return type informs the StrFormat extension framework (through
+    // ADL but using the return type) of what conversion characters are supported.
+    // It is strongly discouraged to return {false}, as this will result in an
+    // empty string in StrFormat.
+    template<FormatConversionCharSet C>
+    struct FormatConvertResult
+    {
+        bool value;
+    };
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_STR_FORMAT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_join.h b/CAPI/cpp/grpc/include/absl/strings/str_join.h
index ee5ae7e..12dcf05 100644
--- a/CAPI/cpp/grpc/include/absl/strings/str_join.h
+++ b/CAPI/cpp/grpc/include/absl/strings/str_join.h
@@ -59,229 +59,241 @@
 #include "absl/strings/internal/str_join_internal.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// -----------------------------------------------------------------------------
-// Concept: Formatter
-// -----------------------------------------------------------------------------
-//
-// A Formatter is a function object that is responsible for formatting its
-// argument as a string and appending it to a given output std::string.
-// Formatters may be implemented as function objects, lambdas, or normal
-// functions. You may provide your own Formatter to enable `absl::StrJoin()` to
-// work with arbitrary types.
-//
-// The following is an example of a custom Formatter that uses
-// `absl::FormatDuration` to join a list of `absl::Duration`s.
-//
-//   std::vector<absl::Duration> v = {absl::Seconds(1), absl::Milliseconds(10)};
-//   std::string s =
-//       absl::StrJoin(v, ", ", [](std::string* out, absl::Duration dur) {
-//         absl::StrAppend(out, absl::FormatDuration(dur));
-//       });
-//   EXPECT_EQ("1s, 10ms", s);
-//
-// The following standard formatters are provided within this file:
-//
-// - `AlphaNumFormatter()` (the default)
-// - `StreamFormatter()`
-// - `PairFormatter()`
-// - `DereferenceFormatter()`
+    // -----------------------------------------------------------------------------
+    // Concept: Formatter
+    // -----------------------------------------------------------------------------
+    //
+    // A Formatter is a function object that is responsible for formatting its
+    // argument as a string and appending it to a given output std::string.
+    // Formatters may be implemented as function objects, lambdas, or normal
+    // functions. You may provide your own Formatter to enable `absl::StrJoin()` to
+    // work with arbitrary types.
+    //
+    // The following is an example of a custom Formatter that uses
+    // `absl::FormatDuration` to join a list of `absl::Duration`s.
+    //
+    //   std::vector<absl::Duration> v = {absl::Seconds(1), absl::Milliseconds(10)};
+    //   std::string s =
+    //       absl::StrJoin(v, ", ", [](std::string* out, absl::Duration dur) {
+    //         absl::StrAppend(out, absl::FormatDuration(dur));
+    //       });
+    //   EXPECT_EQ("1s, 10ms", s);
+    //
+    // The following standard formatters are provided within this file:
+    //
+    // - `AlphaNumFormatter()` (the default)
+    // - `StreamFormatter()`
+    // - `PairFormatter()`
+    // - `DereferenceFormatter()`
 
-// AlphaNumFormatter()
-//
-// Default formatter used if none is specified. Uses `absl::AlphaNum` to convert
-// numeric arguments to strings.
-inline strings_internal::AlphaNumFormatterImpl AlphaNumFormatter() {
-  return strings_internal::AlphaNumFormatterImpl();
-}
+    // AlphaNumFormatter()
+    //
+    // Default formatter used if none is specified. Uses `absl::AlphaNum` to convert
+    // numeric arguments to strings.
+    inline strings_internal::AlphaNumFormatterImpl AlphaNumFormatter()
+    {
+        return strings_internal::AlphaNumFormatterImpl();
+    }
 
-// StreamFormatter()
-//
-// Formats its argument using the << operator.
-inline strings_internal::StreamFormatterImpl StreamFormatter() {
-  return strings_internal::StreamFormatterImpl();
-}
+    // StreamFormatter()
+    //
+    // Formats its argument using the << operator.
+    inline strings_internal::StreamFormatterImpl StreamFormatter()
+    {
+        return strings_internal::StreamFormatterImpl();
+    }
 
-// Function Template: PairFormatter(Formatter, absl::string_view, Formatter)
-//
-// Formats a `std::pair` by putting a given separator between the pair's
-// `.first` and `.second` members. This formatter allows you to specify
-// custom Formatters for both the first and second member of each pair.
-template <typename FirstFormatter, typename SecondFormatter>
-inline strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>
-PairFormatter(FirstFormatter f1, absl::string_view sep, SecondFormatter f2) {
-  return strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>(
-      std::move(f1), sep, std::move(f2));
-}
+    // Function Template: PairFormatter(Formatter, absl::string_view, Formatter)
+    //
+    // Formats a `std::pair` by putting a given separator between the pair's
+    // `.first` and `.second` members. This formatter allows you to specify
+    // custom Formatters for both the first and second member of each pair.
+    template<typename FirstFormatter, typename SecondFormatter>
+    inline strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>
+        PairFormatter(FirstFormatter f1, absl::string_view sep, SecondFormatter f2)
+    {
+        return strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>(
+            std::move(f1), sep, std::move(f2)
+        );
+    }
 
-// Function overload of PairFormatter() for using a default
-// `AlphaNumFormatter()` for each Formatter in the pair.
-inline strings_internal::PairFormatterImpl<
-    strings_internal::AlphaNumFormatterImpl,
-    strings_internal::AlphaNumFormatterImpl>
-PairFormatter(absl::string_view sep) {
-  return PairFormatter(AlphaNumFormatter(), sep, AlphaNumFormatter());
-}
+    // Function overload of PairFormatter() for using a default
+    // `AlphaNumFormatter()` for each Formatter in the pair.
+    inline strings_internal::PairFormatterImpl<
+        strings_internal::AlphaNumFormatterImpl,
+        strings_internal::AlphaNumFormatterImpl>
+        PairFormatter(absl::string_view sep)
+    {
+        return PairFormatter(AlphaNumFormatter(), sep, AlphaNumFormatter());
+    }
 
-// Function Template: DereferenceFormatter(Formatter)
-//
-// Formats its argument by dereferencing it and then applying the given
-// formatter. This formatter is useful for formatting a container of
-// pointer-to-T. This pattern often shows up when joining repeated fields in
-// protocol buffers.
-template <typename Formatter>
-strings_internal::DereferenceFormatterImpl<Formatter> DereferenceFormatter(
-    Formatter&& f) {
-  return strings_internal::DereferenceFormatterImpl<Formatter>(
-      std::forward<Formatter>(f));
-}
+    // Function Template: DereferenceFormatter(Formatter)
+    //
+    // Formats its argument by dereferencing it and then applying the given
+    // formatter. This formatter is useful for formatting a container of
+    // pointer-to-T. This pattern often shows up when joining repeated fields in
+    // protocol buffers.
+    template<typename Formatter>
+    strings_internal::DereferenceFormatterImpl<Formatter> DereferenceFormatter(
+        Formatter&& f
+    )
+    {
+        return strings_internal::DereferenceFormatterImpl<Formatter>(
+            std::forward<Formatter>(f)
+        );
+    }
 
-// Function overload of `DereferenceFormatter()` for using a default
-// `AlphaNumFormatter()`.
-inline strings_internal::DereferenceFormatterImpl<
-    strings_internal::AlphaNumFormatterImpl>
-DereferenceFormatter() {
-  return strings_internal::DereferenceFormatterImpl<
-      strings_internal::AlphaNumFormatterImpl>(AlphaNumFormatter());
-}
+    // Function overload of `DereferenceFormatter()` for using a default
+    // `AlphaNumFormatter()`.
+    inline strings_internal::DereferenceFormatterImpl<
+        strings_internal::AlphaNumFormatterImpl>
+        DereferenceFormatter()
+    {
+        return strings_internal::DereferenceFormatterImpl<
+            strings_internal::AlphaNumFormatterImpl>(AlphaNumFormatter());
+    }
 
-// -----------------------------------------------------------------------------
-// StrJoin()
-// -----------------------------------------------------------------------------
-//
-// Joins a range of elements and returns the result as a std::string.
-// `absl::StrJoin()` takes a range, a separator string to use between the
-// elements joined, and an optional Formatter responsible for converting each
-// argument in the range to a string.
-//
-// If omitted, the default `AlphaNumFormatter()` is called on the elements to be
-// joined.
-//
-// Example 1:
-//   // Joins a collection of strings. This pattern also works with a collection
-//   // of `absl::string_view` or even `const char*`.
-//   std::vector<std::string> v = {"foo", "bar", "baz"};
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ("foo-bar-baz", s);
-//
-// Example 2:
-//   // Joins the values in the given `std::initializer_list<>` specified using
-//   // brace initialization. This pattern also works with an initializer_list
-//   // of ints or `absl::string_view` -- any `AlphaNum`-compatible type.
-//   std::string s = absl::StrJoin({"foo", "bar", "baz"}, "-");
-//   EXPECT_EQ("foo-bar-baz", s);
-//
-// Example 3:
-//   // Joins a collection of ints. This pattern also works with floats,
-//   // doubles, int64s -- any `StrCat()`-compatible type.
-//   std::vector<int> v = {1, 2, 3, -4};
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ("1-2-3--4", s);
-//
-// Example 4:
-//   // Joins a collection of pointer-to-int. By default, pointers are
-//   // dereferenced and the pointee is formatted using the default format for
-//   // that type; such dereferencing occurs for all levels of indirection, so
-//   // this pattern works just as well for `std::vector<int**>` as for
-//   // `std::vector<int*>`.
-//   int x = 1, y = 2, z = 3;
-//   std::vector<int*> v = {&x, &y, &z};
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ("1-2-3", s);
-//
-// Example 5:
-//   // Dereferencing of `std::unique_ptr<>` is also supported:
-//   std::vector<std::unique_ptr<int>> v
-//   v.emplace_back(new int(1));
-//   v.emplace_back(new int(2));
-//   v.emplace_back(new int(3));
-//   std::string s = absl::StrJoin(v, "-");
-//   EXPECT_EQ("1-2-3", s);
-//
-// Example 6:
-//   // Joins a `std::map`, with each key-value pair separated by an equals
-//   // sign. This pattern would also work with, say, a
-//   // `std::vector<std::pair<>>`.
-//   std::map<std::string, int> m = {
-//       std::make_pair("a", 1),
-//       std::make_pair("b", 2),
-//       std::make_pair("c", 3)};
-//   std::string s = absl::StrJoin(m, ",", absl::PairFormatter("="));
-//   EXPECT_EQ("a=1,b=2,c=3", s);
-//
-// Example 7:
-//   // These examples show how `absl::StrJoin()` handles a few common edge
-//   // cases:
-//   std::vector<std::string> v_empty;
-//   EXPECT_EQ("", absl::StrJoin(v_empty, "-"));
-//
-//   std::vector<std::string> v_one_item = {"foo"};
-//   EXPECT_EQ("foo", absl::StrJoin(v_one_item, "-"));
-//
-//   std::vector<std::string> v_empty_string = {""};
-//   EXPECT_EQ("", absl::StrJoin(v_empty_string, "-"));
-//
-//   std::vector<std::string> v_one_item_empty_string = {"a", ""};
-//   EXPECT_EQ("a-", absl::StrJoin(v_one_item_empty_string, "-"));
-//
-//   std::vector<std::string> v_two_empty_string = {"", ""};
-//   EXPECT_EQ("-", absl::StrJoin(v_two_empty_string, "-"));
-//
-// Example 8:
-//   // Joins a `std::tuple<T...>` of heterogeneous types, converting each to
-//   // a std::string using the `absl::AlphaNum` class.
-//   std::string s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-");
-//   EXPECT_EQ("123-abc-0.456", s);
+    // -----------------------------------------------------------------------------
+    // StrJoin()
+    // -----------------------------------------------------------------------------
+    //
+    // Joins a range of elements and returns the result as a std::string.
+    // `absl::StrJoin()` takes a range, a separator string to use between the
+    // elements joined, and an optional Formatter responsible for converting each
+    // argument in the range to a string.
+    //
+    // If omitted, the default `AlphaNumFormatter()` is called on the elements to be
+    // joined.
+    //
+    // Example 1:
+    //   // Joins a collection of strings. This pattern also works with a collection
+    //   // of `absl::string_view` or even `const char*`.
+    //   std::vector<std::string> v = {"foo", "bar", "baz"};
+    //   std::string s = absl::StrJoin(v, "-");
+    //   EXPECT_EQ("foo-bar-baz", s);
+    //
+    // Example 2:
+    //   // Joins the values in the given `std::initializer_list<>` specified using
+    //   // brace initialization. This pattern also works with an initializer_list
+    //   // of ints or `absl::string_view` -- any `AlphaNum`-compatible type.
+    //   std::string s = absl::StrJoin({"foo", "bar", "baz"}, "-");
+    //   EXPECT_EQ("foo-bar-baz", s);
+    //
+    // Example 3:
+    //   // Joins a collection of ints. This pattern also works with floats,
+    //   // doubles, int64s -- any `StrCat()`-compatible type.
+    //   std::vector<int> v = {1, 2, 3, -4};
+    //   std::string s = absl::StrJoin(v, "-");
+    //   EXPECT_EQ("1-2-3--4", s);
+    //
+    // Example 4:
+    //   // Joins a collection of pointer-to-int. By default, pointers are
+    //   // dereferenced and the pointee is formatted using the default format for
+    //   // that type; such dereferencing occurs for all levels of indirection, so
+    //   // this pattern works just as well for `std::vector<int**>` as for
+    //   // `std::vector<int*>`.
+    //   int x = 1, y = 2, z = 3;
+    //   std::vector<int*> v = {&x, &y, &z};
+    //   std::string s = absl::StrJoin(v, "-");
+    //   EXPECT_EQ("1-2-3", s);
+    //
+    // Example 5:
+    //   // Dereferencing of `std::unique_ptr<>` is also supported:
+    //   std::vector<std::unique_ptr<int>> v
+    //   v.emplace_back(new int(1));
+    //   v.emplace_back(new int(2));
+    //   v.emplace_back(new int(3));
+    //   std::string s = absl::StrJoin(v, "-");
+    //   EXPECT_EQ("1-2-3", s);
+    //
+    // Example 6:
+    //   // Joins a `std::map`, with each key-value pair separated by an equals
+    //   // sign. This pattern would also work with, say, a
+    //   // `std::vector<std::pair<>>`.
+    //   std::map<std::string, int> m = {
+    //       std::make_pair("a", 1),
+    //       std::make_pair("b", 2),
+    //       std::make_pair("c", 3)};
+    //   std::string s = absl::StrJoin(m, ",", absl::PairFormatter("="));
+    //   EXPECT_EQ("a=1,b=2,c=3", s);
+    //
+    // Example 7:
+    //   // These examples show how `absl::StrJoin()` handles a few common edge
+    //   // cases:
+    //   std::vector<std::string> v_empty;
+    //   EXPECT_EQ("", absl::StrJoin(v_empty, "-"));
+    //
+    //   std::vector<std::string> v_one_item = {"foo"};
+    //   EXPECT_EQ("foo", absl::StrJoin(v_one_item, "-"));
+    //
+    //   std::vector<std::string> v_empty_string = {""};
+    //   EXPECT_EQ("", absl::StrJoin(v_empty_string, "-"));
+    //
+    //   std::vector<std::string> v_one_item_empty_string = {"a", ""};
+    //   EXPECT_EQ("a-", absl::StrJoin(v_one_item_empty_string, "-"));
+    //
+    //   std::vector<std::string> v_two_empty_string = {"", ""};
+    //   EXPECT_EQ("-", absl::StrJoin(v_two_empty_string, "-"));
+    //
+    // Example 8:
+    //   // Joins a `std::tuple<T...>` of heterogeneous types, converting each to
+    //   // a std::string using the `absl::AlphaNum` class.
+    //   std::string s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-");
+    //   EXPECT_EQ("123-abc-0.456", s);
 
-template <typename Iterator, typename Formatter>
-std::string StrJoin(Iterator start, Iterator end, absl::string_view sep,
-                    Formatter&& fmt) {
-  return strings_internal::JoinAlgorithm(start, end, sep, fmt);
-}
+    template<typename Iterator, typename Formatter>
+    std::string StrJoin(Iterator start, Iterator end, absl::string_view sep, Formatter&& fmt)
+    {
+        return strings_internal::JoinAlgorithm(start, end, sep, fmt);
+    }
 
-template <typename Range, typename Formatter>
-std::string StrJoin(const Range& range, absl::string_view separator,
-                    Formatter&& fmt) {
-  return strings_internal::JoinRange(range, separator, fmt);
-}
+    template<typename Range, typename Formatter>
+    std::string StrJoin(const Range& range, absl::string_view separator, Formatter&& fmt)
+    {
+        return strings_internal::JoinRange(range, separator, fmt);
+    }
 
-template <typename T, typename Formatter>
-std::string StrJoin(std::initializer_list<T> il, absl::string_view separator,
-                    Formatter&& fmt) {
-  return strings_internal::JoinRange(il, separator, fmt);
-}
+    template<typename T, typename Formatter>
+    std::string StrJoin(std::initializer_list<T> il, absl::string_view separator, Formatter&& fmt)
+    {
+        return strings_internal::JoinRange(il, separator, fmt);
+    }
 
-template <typename... T, typename Formatter>
-std::string StrJoin(const std::tuple<T...>& value, absl::string_view separator,
-                    Formatter&& fmt) {
-  return strings_internal::JoinAlgorithm(value, separator, fmt);
-}
+    template<typename... T, typename Formatter>
+    std::string StrJoin(const std::tuple<T...>& value, absl::string_view separator, Formatter&& fmt)
+    {
+        return strings_internal::JoinAlgorithm(value, separator, fmt);
+    }
 
-template <typename Iterator>
-std::string StrJoin(Iterator start, Iterator end, absl::string_view separator) {
-  return strings_internal::JoinRange(start, end, separator);
-}
+    template<typename Iterator>
+    std::string StrJoin(Iterator start, Iterator end, absl::string_view separator)
+    {
+        return strings_internal::JoinRange(start, end, separator);
+    }
 
-template <typename Range>
-std::string StrJoin(const Range& range, absl::string_view separator) {
-  return strings_internal::JoinRange(range, separator);
-}
+    template<typename Range>
+    std::string StrJoin(const Range& range, absl::string_view separator)
+    {
+        return strings_internal::JoinRange(range, separator);
+    }
 
-template <typename T>
-std::string StrJoin(std::initializer_list<T> il,
-                    absl::string_view separator) {
-  return strings_internal::JoinRange(il, separator);
-}
+    template<typename T>
+    std::string StrJoin(std::initializer_list<T> il, absl::string_view separator)
+    {
+        return strings_internal::JoinRange(il, separator);
+    }
 
-template <typename... T>
-std::string StrJoin(const std::tuple<T...>& value,
-                    absl::string_view separator) {
-  return strings_internal::JoinAlgorithm(value, separator, AlphaNumFormatter());
-}
+    template<typename... T>
+    std::string StrJoin(const std::tuple<T...>& value, absl::string_view separator)
+    {
+        return strings_internal::JoinAlgorithm(value, separator, AlphaNumFormatter());
+    }
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_STR_JOIN_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_replace.h b/CAPI/cpp/grpc/include/absl/strings/str_replace.h
index 273c707..a550908 100644
--- a/CAPI/cpp/grpc/include/absl/strings/str_replace.h
+++ b/CAPI/cpp/grpc/include/absl/strings/str_replace.h
@@ -45,175 +45,190 @@
 #include "absl/base/attributes.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // StrReplaceAll()
+    //
+    // Replaces character sequences within a given string with replacements provided
+    // within an initializer list of key/value pairs. Candidate replacements are
+    // considered in order as they occur within the string, with earlier matches
+    // taking precedence, and longer matches taking precedence for candidates
+    // starting at the same position in the string. Once a substitution is made, the
+    // replaced text is not considered for any further substitutions.
+    //
+    // Example:
+    //
+    //   std::string s = absl::StrReplaceAll(
+    //       "$who bought $count #Noun. Thanks $who!",
+    //       {{"$count", absl::StrCat(5)},
+    //        {"$who", "Bob"},
+    //        {"#Noun", "Apples"}});
+    //   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+    ABSL_MUST_USE_RESULT std::string StrReplaceAll(
+        absl::string_view s,
+        std::initializer_list<std::pair<absl::string_view, absl::string_view>>
+            replacements
+    );
+
+    // Overload of `StrReplaceAll()` to accept a container of key/value replacement
+    // pairs (typically either an associative map or a `std::vector` of `std::pair`
+    // elements). A vector of pairs is generally more efficient.
+    //
+    // Examples:
+    //
+    //   std::map<const absl::string_view, const absl::string_view> replacements;
+    //   replacements["$who"] = "Bob";
+    //   replacements["$count"] = "5";
+    //   replacements["#Noun"] = "Apples";
+    //   std::string s = absl::StrReplaceAll(
+    //       "$who bought $count #Noun. Thanks $who!",
+    //       replacements);
+    //   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+    //
+    //   // A std::vector of std::pair elements can be more efficient.
+    //   std::vector<std::pair<const absl::string_view, std::string>> replacements;
+    //   replacements.push_back({"&", "&amp;"});
+    //   replacements.push_back({"<", "&lt;"});
+    //   replacements.push_back({">", "&gt;"});
+    //   std::string s = absl::StrReplaceAll("if (ptr < &foo)",
+    //                                  replacements);
+    //   EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
+    template<typename StrToStrMapping>
+    std::string StrReplaceAll(absl::string_view s, const StrToStrMapping& replacements);
+
+    // Overload of `StrReplaceAll()` to replace character sequences within a given
+    // output string *in place* with replacements provided within an initializer
+    // list of key/value pairs, returning the number of substitutions that occurred.
+    //
+    // Example:
+    //
+    //   std::string s = std::string("$who bought $count #Noun. Thanks $who!");
+    //   int count;
+    //   count = absl::StrReplaceAll({{"$count", absl::StrCat(5)},
+    //                               {"$who", "Bob"},
+    //                               {"#Noun", "Apples"}}, &s);
+    //  EXPECT_EQ(count, 4);
+    //  EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+    int StrReplaceAll(
+        std::initializer_list<std::pair<absl::string_view, absl::string_view>>
+            replacements,
+        std::string* target
+    );
+
+    // Overload of `StrReplaceAll()` to replace patterns within a given output
+    // string *in place* with replacements provided within a container of key/value
+    // pairs.
+    //
+    // Example:
+    //
+    //   std::string s = std::string("if (ptr < &foo)");
+    //   int count = absl::StrReplaceAll({{"&", "&amp;"},
+    //                                    {"<", "&lt;"},
+    //                                    {">", "&gt;"}}, &s);
+    //  EXPECT_EQ(count, 2);
+    //  EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
+    template<typename StrToStrMapping>
+    int StrReplaceAll(const StrToStrMapping& replacements, std::string* target);
+
+    // Implementation details only, past this point.
+    namespace strings_internal
+    {
+
+        struct ViableSubstitution
+        {
+            absl::string_view old;
+            absl::string_view replacement;
+            size_t offset;
+
+            ViableSubstitution(absl::string_view old_str, absl::string_view replacement_str, size_t offset_val) :
+                old(old_str),
+                replacement(replacement_str),
+                offset(offset_val)
+            {
+            }
+
+            // One substitution occurs "before" another (takes priority) if either
+            // it has the lowest offset, or it has the same offset but a larger size.
+            bool OccursBefore(const ViableSubstitution& y) const
+            {
+                if (offset != y.offset)
+                    return offset < y.offset;
+                return old.size() > y.old.size();
+            }
+        };
+
+        // Build a vector of ViableSubstitutions based on the given list of
+        // replacements. subs can be implemented as a priority_queue. However, it turns
+        // out that most callers have small enough a list of substitutions that the
+        // overhead of such a queue isn't worth it.
+        template<typename StrToStrMapping>
+        std::vector<ViableSubstitution> FindSubstitutions(
+            absl::string_view s, const StrToStrMapping& replacements
+        )
+        {
+            std::vector<ViableSubstitution> subs;
+            subs.reserve(replacements.size());
+
+            for (const auto& rep : replacements)
+            {
+                using std::get;
+                absl::string_view old(get<0>(rep));
+
+                size_t pos = s.find(old);
+                if (pos == s.npos)
+                    continue;
+
+                // Ignore attempts to replace "". This condition is almost never true,
+                // but above condition is frequently true. That's why we test for this
+                // now and not before.
+                if (old.empty())
+                    continue;
+
+                subs.emplace_back(old, get<1>(rep), pos);
+
+                // Insertion sort to ensure the last ViableSubstitution comes before
+                // all the others.
+                size_t index = subs.size();
+                while (--index && subs[index - 1].OccursBefore(subs[index]))
+                {
+                    std::swap(subs[index], subs[index - 1]);
+                }
+            }
+            return subs;
+        }
+
+        int ApplySubstitutions(absl::string_view s, std::vector<ViableSubstitution>* subs_ptr, std::string* result_ptr);
+
+    }  // namespace strings_internal
+
+    template<typename StrToStrMapping>
+    std::string StrReplaceAll(absl::string_view s, const StrToStrMapping& replacements)
+    {
+        auto subs = strings_internal::FindSubstitutions(s, replacements);
+        std::string result;
+        result.reserve(s.size());
+        strings_internal::ApplySubstitutions(s, &subs, &result);
+        return result;
+    }
 
-// StrReplaceAll()
-//
-// Replaces character sequences within a given string with replacements provided
-// within an initializer list of key/value pairs. Candidate replacements are
-// considered in order as they occur within the string, with earlier matches
-// taking precedence, and longer matches taking precedence for candidates
-// starting at the same position in the string. Once a substitution is made, the
-// replaced text is not considered for any further substitutions.
-//
-// Example:
-//
-//   std::string s = absl::StrReplaceAll(
-//       "$who bought $count #Noun. Thanks $who!",
-//       {{"$count", absl::StrCat(5)},
-//        {"$who", "Bob"},
-//        {"#Noun", "Apples"}});
-//   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-ABSL_MUST_USE_RESULT std::string StrReplaceAll(
-    absl::string_view s,
-    std::initializer_list<std::pair<absl::string_view, absl::string_view>>
-        replacements);
-
-// Overload of `StrReplaceAll()` to accept a container of key/value replacement
-// pairs (typically either an associative map or a `std::vector` of `std::pair`
-// elements). A vector of pairs is generally more efficient.
-//
-// Examples:
-//
-//   std::map<const absl::string_view, const absl::string_view> replacements;
-//   replacements["$who"] = "Bob";
-//   replacements["$count"] = "5";
-//   replacements["#Noun"] = "Apples";
-//   std::string s = absl::StrReplaceAll(
-//       "$who bought $count #Noun. Thanks $who!",
-//       replacements);
-//   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-//
-//   // A std::vector of std::pair elements can be more efficient.
-//   std::vector<std::pair<const absl::string_view, std::string>> replacements;
-//   replacements.push_back({"&", "&amp;"});
-//   replacements.push_back({"<", "&lt;"});
-//   replacements.push_back({">", "&gt;"});
-//   std::string s = absl::StrReplaceAll("if (ptr < &foo)",
-//                                  replacements);
-//   EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
-template <typename StrToStrMapping>
-std::string StrReplaceAll(absl::string_view s,
-                          const StrToStrMapping& replacements);
-
-// Overload of `StrReplaceAll()` to replace character sequences within a given
-// output string *in place* with replacements provided within an initializer
-// list of key/value pairs, returning the number of substitutions that occurred.
-//
-// Example:
-//
-//   std::string s = std::string("$who bought $count #Noun. Thanks $who!");
-//   int count;
-//   count = absl::StrReplaceAll({{"$count", absl::StrCat(5)},
-//                               {"$who", "Bob"},
-//                               {"#Noun", "Apples"}}, &s);
-//  EXPECT_EQ(count, 4);
-//  EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-int StrReplaceAll(
-    std::initializer_list<std::pair<absl::string_view, absl::string_view>>
-        replacements,
-    std::string* target);
-
-// Overload of `StrReplaceAll()` to replace patterns within a given output
-// string *in place* with replacements provided within a container of key/value
-// pairs.
-//
-// Example:
-//
-//   std::string s = std::string("if (ptr < &foo)");
-//   int count = absl::StrReplaceAll({{"&", "&amp;"},
-//                                    {"<", "&lt;"},
-//                                    {">", "&gt;"}}, &s);
-//  EXPECT_EQ(count, 2);
-//  EXPECT_EQ("if (ptr &lt; &amp;foo)", s);
-template <typename StrToStrMapping>
-int StrReplaceAll(const StrToStrMapping& replacements, std::string* target);
-
-// Implementation details only, past this point.
-namespace strings_internal {
-
-struct ViableSubstitution {
-  absl::string_view old;
-  absl::string_view replacement;
-  size_t offset;
-
-  ViableSubstitution(absl::string_view old_str,
-                     absl::string_view replacement_str, size_t offset_val)
-      : old(old_str), replacement(replacement_str), offset(offset_val) {}
-
-  // One substitution occurs "before" another (takes priority) if either
-  // it has the lowest offset, or it has the same offset but a larger size.
-  bool OccursBefore(const ViableSubstitution& y) const {
-    if (offset != y.offset) return offset < y.offset;
-    return old.size() > y.old.size();
-  }
-};
-
-// Build a vector of ViableSubstitutions based on the given list of
-// replacements. subs can be implemented as a priority_queue. However, it turns
-// out that most callers have small enough a list of substitutions that the
-// overhead of such a queue isn't worth it.
-template <typename StrToStrMapping>
-std::vector<ViableSubstitution> FindSubstitutions(
-    absl::string_view s, const StrToStrMapping& replacements) {
-  std::vector<ViableSubstitution> subs;
-  subs.reserve(replacements.size());
-
-  for (const auto& rep : replacements) {
-    using std::get;
-    absl::string_view old(get<0>(rep));
-
-    size_t pos = s.find(old);
-    if (pos == s.npos) continue;
-
-    // Ignore attempts to replace "". This condition is almost never true,
-    // but above condition is frequently true. That's why we test for this
-    // now and not before.
-    if (old.empty()) continue;
-
-    subs.emplace_back(old, get<1>(rep), pos);
-
-    // Insertion sort to ensure the last ViableSubstitution comes before
-    // all the others.
-    size_t index = subs.size();
-    while (--index && subs[index - 1].OccursBefore(subs[index])) {
-      std::swap(subs[index], subs[index - 1]);
+    template<typename StrToStrMapping>
+    int StrReplaceAll(const StrToStrMapping& replacements, std::string* target)
+    {
+        auto subs = strings_internal::FindSubstitutions(*target, replacements);
+        if (subs.empty())
+            return 0;
+
+        std::string result;
+        result.reserve(target->size());
+        int substitutions =
+            strings_internal::ApplySubstitutions(*target, &subs, &result);
+        target->swap(result);
+        return substitutions;
     }
-  }
-  return subs;
-}
-
-int ApplySubstitutions(absl::string_view s,
-                       std::vector<ViableSubstitution>* subs_ptr,
-                       std::string* result_ptr);
-
-}  // namespace strings_internal
-
-template <typename StrToStrMapping>
-std::string StrReplaceAll(absl::string_view s,
-                          const StrToStrMapping& replacements) {
-  auto subs = strings_internal::FindSubstitutions(s, replacements);
-  std::string result;
-  result.reserve(s.size());
-  strings_internal::ApplySubstitutions(s, &subs, &result);
-  return result;
-}
-
-template <typename StrToStrMapping>
-int StrReplaceAll(const StrToStrMapping& replacements, std::string* target) {
-  auto subs = strings_internal::FindSubstitutions(*target, replacements);
-  if (subs.empty()) return 0;
-
-  std::string result;
-  result.reserve(target->size());
-  int substitutions =
-      strings_internal::ApplySubstitutions(*target, &subs, &result);
-  target->swap(result);
-  return substitutions;
-}
-
-ABSL_NAMESPACE_END
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_STR_REPLACE_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/str_split.h b/CAPI/cpp/grpc/include/absl/strings/str_split.h
index 7bbb68a..0bf7621 100644
--- a/CAPI/cpp/grpc/include/absl/strings/str_split.h
+++ b/CAPI/cpp/grpc/include/absl/strings/str_split.h
@@ -49,499 +49,538 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-//------------------------------------------------------------------------------
-// Delimiters
-//------------------------------------------------------------------------------
-//
-// `StrSplit()` uses delimiters to define the boundaries between elements in the
-// provided input. Several `Delimiter` types are defined below. If a string
-// (`const char*`, `std::string`, or `absl::string_view`) is passed in place of
-// an explicit `Delimiter` object, `StrSplit()` treats it the same way as if it
-// were passed a `ByString` delimiter.
-//
-// A `Delimiter` is an object with a `Find()` function that knows how to find
-// the first occurrence of itself in a given `absl::string_view`.
-//
-// The following `Delimiter` types are available for use within `StrSplit()`:
-//
-//   - `ByString` (default for string arguments)
-//   - `ByChar` (default for a char argument)
-//   - `ByAnyChar`
-//   - `ByLength`
-//   - `MaxSplits`
-//
-// A Delimiter's `Find()` member function will be passed an input `text` that is
-// to be split and a position (`pos`) to begin searching for the next delimiter
-// in `text`. The returned absl::string_view should refer to the next occurrence
-// (after `pos`) of the represented delimiter; this returned absl::string_view
-// represents the next location where the input `text` should be broken.
-//
-// The returned absl::string_view may be zero-length if the Delimiter does not
-// represent a part of the string (e.g., a fixed-length delimiter). If no
-// delimiter is found in the input `text`, a zero-length absl::string_view
-// referring to `text.end()` should be returned (e.g.,
-// `text.substr(text.size())`). It is important that the returned
-// absl::string_view always be within the bounds of the input `text` given as an
-// argument--it must not refer to a string that is physically located outside of
-// the given string.
-//
-// The following example is a simple Delimiter object that is created with a
-// single char and will look for that char in the text passed to the `Find()`
-// function:
-//
-//   struct SimpleDelimiter {
-//     const char c_;
-//     explicit SimpleDelimiter(char c) : c_(c) {}
-//     absl::string_view Find(absl::string_view text, size_t pos) {
-//       auto found = text.find(c_, pos);
-//       if (found == absl::string_view::npos)
-//         return text.substr(text.size());
-//
-//       return text.substr(found, 1);
-//     }
-//   };
-
-// ByString
-//
-// A sub-string delimiter. If `StrSplit()` is passed a string in place of a
-// `Delimiter` object, the string will be implicitly converted into a
-// `ByString` delimiter.
-//
-// Example:
-//
-//   // Because a string literal is converted to an `absl::ByString`,
-//   // the following two splits are equivalent.
-//
-//   std::vector<std::string> v1 = absl::StrSplit("a, b, c", ", ");
-//
-//   using absl::ByString;
-//   std::vector<std::string> v2 = absl::StrSplit("a, b, c",
-//                                                ByString(", "));
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-class ByString {
- public:
-  explicit ByString(absl::string_view sp);
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-
- private:
-  const std::string delimiter_;
-};
-
-// ByChar
-//
-// A single character delimiter. `ByChar` is functionally equivalent to a
-// 1-char string within a `ByString` delimiter, but slightly more efficient.
-//
-// Example:
-//
-//   // Because a char literal is converted to a absl::ByChar,
-//   // the following two splits are equivalent.
-//   std::vector<std::string> v1 = absl::StrSplit("a,b,c", ',');
-//   using absl::ByChar;
-//   std::vector<std::string> v2 = absl::StrSplit("a,b,c", ByChar(','));
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-//
-// `ByChar` is also the default delimiter if a single character is given
-// as the delimiter to `StrSplit()`. For example, the following calls are
-// equivalent:
-//
-//   std::vector<std::string> v = absl::StrSplit("a-b", '-');
-//
-//   using absl::ByChar;
-//   std::vector<std::string> v = absl::StrSplit("a-b", ByChar('-'));
-//
-class ByChar {
- public:
-  explicit ByChar(char c) : c_(c) {}
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-
- private:
-  char c_;
-};
-
-// ByAnyChar
-//
-// A delimiter that will match any of the given byte-sized characters within
-// its provided string.
-//
-// Note: this delimiter works with single-byte string data, but does not work
-// with variable-width encodings, such as UTF-8.
-//
-// Example:
-//
-//   using absl::ByAnyChar;
-//   std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-//
-// If `ByAnyChar` is given the empty string, it behaves exactly like
-// `ByString` and matches each individual character in the input string.
-//
-class ByAnyChar {
- public:
-  explicit ByAnyChar(absl::string_view sp);
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-
- private:
-  const std::string delimiters_;
-};
-
-// ByLength
-//
-// A delimiter for splitting into equal-length strings. The length argument to
-// the constructor must be greater than 0.
-//
-// Note: this delimiter works with single-byte string data, but does not work
-// with variable-width encodings, such as UTF-8.
-//
-// Example:
-//
-//   using absl::ByLength;
-//   std::vector<std::string> v = absl::StrSplit("123456789", ByLength(3));
-
-//   // v[0] == "123", v[1] == "456", v[2] == "789"
-//
-// Note that the string does not have to be a multiple of the fixed split
-// length. In such a case, the last substring will be shorter.
-//
-//   using absl::ByLength;
-//   std::vector<std::string> v = absl::StrSplit("12345", ByLength(2));
-//
-//   // v[0] == "12", v[1] == "34", v[2] == "5"
-class ByLength {
- public:
-  explicit ByLength(ptrdiff_t length);
-  absl::string_view Find(absl::string_view text, size_t pos) const;
-
- private:
-  const ptrdiff_t length_;
-};
-
-namespace strings_internal {
-
-// A traits-like metafunction for selecting the default Delimiter object type
-// for a particular Delimiter type. The base case simply exposes type Delimiter
-// itself as the delimiter's Type. However, there are specializations for
-// string-like objects that map them to the ByString delimiter object.
-// This allows functions like absl::StrSplit() and absl::MaxSplits() to accept
-// string-like objects (e.g., ',') as delimiter arguments but they will be
-// treated as if a ByString delimiter was given.
-template <typename Delimiter>
-struct SelectDelimiter {
-  using type = Delimiter;
-};
-
-template <>
-struct SelectDelimiter<char> {
-  using type = ByChar;
-};
-template <>
-struct SelectDelimiter<char*> {
-  using type = ByString;
-};
-template <>
-struct SelectDelimiter<const char*> {
-  using type = ByString;
-};
-template <>
-struct SelectDelimiter<absl::string_view> {
-  using type = ByString;
-};
-template <>
-struct SelectDelimiter<std::string> {
-  using type = ByString;
-};
-
-// Wraps another delimiter and sets a max number of matches for that delimiter.
-template <typename Delimiter>
-class MaxSplitsImpl {
- public:
-  MaxSplitsImpl(Delimiter delimiter, int limit)
-      : delimiter_(delimiter), limit_(limit), count_(0) {}
-  absl::string_view Find(absl::string_view text, size_t pos) {
-    if (count_++ == limit_) {
-      return absl::string_view(text.data() + text.size(),
-                               0);  // No more matches.
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    //------------------------------------------------------------------------------
+    // Delimiters
+    //------------------------------------------------------------------------------
+    //
+    // `StrSplit()` uses delimiters to define the boundaries between elements in the
+    // provided input. Several `Delimiter` types are defined below. If a string
+    // (`const char*`, `std::string`, or `absl::string_view`) is passed in place of
+    // an explicit `Delimiter` object, `StrSplit()` treats it the same way as if it
+    // were passed a `ByString` delimiter.
+    //
+    // A `Delimiter` is an object with a `Find()` function that knows how to find
+    // the first occurrence of itself in a given `absl::string_view`.
+    //
+    // The following `Delimiter` types are available for use within `StrSplit()`:
+    //
+    //   - `ByString` (default for string arguments)
+    //   - `ByChar` (default for a char argument)
+    //   - `ByAnyChar`
+    //   - `ByLength`
+    //   - `MaxSplits`
+    //
+    // A Delimiter's `Find()` member function will be passed an input `text` that is
+    // to be split and a position (`pos`) to begin searching for the next delimiter
+    // in `text`. The returned absl::string_view should refer to the next occurrence
+    // (after `pos`) of the represented delimiter; this returned absl::string_view
+    // represents the next location where the input `text` should be broken.
+    //
+    // The returned absl::string_view may be zero-length if the Delimiter does not
+    // represent a part of the string (e.g., a fixed-length delimiter). If no
+    // delimiter is found in the input `text`, a zero-length absl::string_view
+    // referring to `text.end()` should be returned (e.g.,
+    // `text.substr(text.size())`). It is important that the returned
+    // absl::string_view always be within the bounds of the input `text` given as an
+    // argument--it must not refer to a string that is physically located outside of
+    // the given string.
+    //
+    // The following example is a simple Delimiter object that is created with a
+    // single char and will look for that char in the text passed to the `Find()`
+    // function:
+    //
+    //   struct SimpleDelimiter {
+    //     const char c_;
+    //     explicit SimpleDelimiter(char c) : c_(c) {}
+    //     absl::string_view Find(absl::string_view text, size_t pos) {
+    //       auto found = text.find(c_, pos);
+    //       if (found == absl::string_view::npos)
+    //         return text.substr(text.size());
+    //
+    //       return text.substr(found, 1);
+    //     }
+    //   };
+
+    // ByString
+    //
+    // A sub-string delimiter. If `StrSplit()` is passed a string in place of a
+    // `Delimiter` object, the string will be implicitly converted into a
+    // `ByString` delimiter.
+    //
+    // Example:
+    //
+    //   // Because a string literal is converted to an `absl::ByString`,
+    //   // the following two splits are equivalent.
+    //
+    //   std::vector<std::string> v1 = absl::StrSplit("a, b, c", ", ");
+    //
+    //   using absl::ByString;
+    //   std::vector<std::string> v2 = absl::StrSplit("a, b, c",
+    //                                                ByString(", "));
+    //   // v[0] == "a", v[1] == "b", v[2] == "c"
+    class ByString
+    {
+    public:
+        explicit ByString(absl::string_view sp);
+        absl::string_view Find(absl::string_view text, size_t pos) const;
+
+    private:
+        const std::string delimiter_;
+    };
+
+    // ByChar
+    //
+    // A single character delimiter. `ByChar` is functionally equivalent to a
+    // 1-char string within a `ByString` delimiter, but slightly more efficient.
+    //
+    // Example:
+    //
+    //   // Because a char literal is converted to a absl::ByChar,
+    //   // the following two splits are equivalent.
+    //   std::vector<std::string> v1 = absl::StrSplit("a,b,c", ',');
+    //   using absl::ByChar;
+    //   std::vector<std::string> v2 = absl::StrSplit("a,b,c", ByChar(','));
+    //   // v[0] == "a", v[1] == "b", v[2] == "c"
+    //
+    // `ByChar` is also the default delimiter if a single character is given
+    // as the delimiter to `StrSplit()`. For example, the following calls are
+    // equivalent:
+    //
+    //   std::vector<std::string> v = absl::StrSplit("a-b", '-');
+    //
+    //   using absl::ByChar;
+    //   std::vector<std::string> v = absl::StrSplit("a-b", ByChar('-'));
+    //
+    class ByChar
+    {
+    public:
+        explicit ByChar(char c) :
+            c_(c)
+        {
+        }
+        absl::string_view Find(absl::string_view text, size_t pos) const;
+
+    private:
+        char c_;
+    };
+
+    // ByAnyChar
+    //
+    // A delimiter that will match any of the given byte-sized characters within
+    // its provided string.
+    //
+    // Note: this delimiter works with single-byte string data, but does not work
+    // with variable-width encodings, such as UTF-8.
+    //
+    // Example:
+    //
+    //   using absl::ByAnyChar;
+    //   std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
+    //   // v[0] == "a", v[1] == "b", v[2] == "c"
+    //
+    // If `ByAnyChar` is given the empty string, it behaves exactly like
+    // `ByString` and matches each individual character in the input string.
+    //
+    class ByAnyChar
+    {
+    public:
+        explicit ByAnyChar(absl::string_view sp);
+        absl::string_view Find(absl::string_view text, size_t pos) const;
+
+    private:
+        const std::string delimiters_;
+    };
+
+    // ByLength
+    //
+    // A delimiter for splitting into equal-length strings. The length argument to
+    // the constructor must be greater than 0.
+    //
+    // Note: this delimiter works with single-byte string data, but does not work
+    // with variable-width encodings, such as UTF-8.
+    //
+    // Example:
+    //
+    //   using absl::ByLength;
+    //   std::vector<std::string> v = absl::StrSplit("123456789", ByLength(3));
+
+    //   // v[0] == "123", v[1] == "456", v[2] == "789"
+    //
+    // Note that the string does not have to be a multiple of the fixed split
+    // length. In such a case, the last substring will be shorter.
+    //
+    //   using absl::ByLength;
+    //   std::vector<std::string> v = absl::StrSplit("12345", ByLength(2));
+    //
+    //   // v[0] == "12", v[1] == "34", v[2] == "5"
+    class ByLength
+    {
+    public:
+        explicit ByLength(ptrdiff_t length);
+        absl::string_view Find(absl::string_view text, size_t pos) const;
+
+    private:
+        const ptrdiff_t length_;
+    };
+
+    namespace strings_internal
+    {
+
+        // A traits-like metafunction for selecting the default Delimiter object type
+        // for a particular Delimiter type. The base case simply exposes type Delimiter
+        // itself as the delimiter's Type. However, there are specializations for
+        // string-like objects that map them to the ByString delimiter object.
+        // This allows functions like absl::StrSplit() and absl::MaxSplits() to accept
+        // string-like objects (e.g., ',') as delimiter arguments but they will be
+        // treated as if a ByString delimiter was given.
+        template<typename Delimiter>
+        struct SelectDelimiter
+        {
+            using type = Delimiter;
+        };
+
+        template<>
+        struct SelectDelimiter<char>
+        {
+            using type = ByChar;
+        };
+        template<>
+        struct SelectDelimiter<char*>
+        {
+            using type = ByString;
+        };
+        template<>
+        struct SelectDelimiter<const char*>
+        {
+            using type = ByString;
+        };
+        template<>
+        struct SelectDelimiter<absl::string_view>
+        {
+            using type = ByString;
+        };
+        template<>
+        struct SelectDelimiter<std::string>
+        {
+            using type = ByString;
+        };
+
+        // Wraps another delimiter and sets a max number of matches for that delimiter.
+        template<typename Delimiter>
+        class MaxSplitsImpl
+        {
+        public:
+            MaxSplitsImpl(Delimiter delimiter, int limit) :
+                delimiter_(delimiter),
+                limit_(limit),
+                count_(0)
+            {
+            }
+            absl::string_view Find(absl::string_view text, size_t pos)
+            {
+                if (count_++ == limit_)
+                {
+                    return absl::string_view(text.data() + text.size(),
+                                             0);  // No more matches.
+                }
+                return delimiter_.Find(text, pos);
+            }
+
+        private:
+            Delimiter delimiter_;
+            const int limit_;
+            int count_;
+        };
+
+    }  // namespace strings_internal
+
+    // MaxSplits()
+    //
+    // A delimiter that limits the number of matches which can occur to the passed
+    // `limit`. The last element in the returned collection will contain all
+    // remaining unsplit pieces, which may contain instances of the delimiter.
+    // The collection will contain at most `limit` + 1 elements.
+    // Example:
+    //
+    //   using absl::MaxSplits;
+    //   std::vector<std::string> v = absl::StrSplit("a,b,c", MaxSplits(',', 1));
+    //
+    //   // v[0] == "a", v[1] == "b,c"
+    template<typename Delimiter>
+    inline strings_internal::MaxSplitsImpl<
+        typename strings_internal::SelectDelimiter<Delimiter>::type>
+        MaxSplits(Delimiter delimiter, int limit)
+    {
+        typedef
+            typename strings_internal::SelectDelimiter<Delimiter>::type DelimiterType;
+        return strings_internal::MaxSplitsImpl<DelimiterType>(
+            DelimiterType(delimiter), limit
+        );
     }
-    return delimiter_.Find(text, pos);
-  }
 
- private:
-  Delimiter delimiter_;
-  const int limit_;
-  int count_;
-};
+    //------------------------------------------------------------------------------
+    // Predicates
+    //------------------------------------------------------------------------------
+    //
+    // Predicates filter the results of a `StrSplit()` by determining whether or not
+    // a resultant element is included in the result set. A predicate may be passed
+    // as an optional third argument to the `StrSplit()` function.
+    //
+    // Predicates are unary functions (or functors) that take a single
+    // `absl::string_view` argument and return a bool indicating whether the
+    // argument should be included (`true`) or excluded (`false`).
+    //
+    // Predicates are useful when filtering out empty substrings. By default, empty
+    // substrings may be returned by `StrSplit()`, which is similar to the way split
+    // functions work in other programming languages.
+
+    // AllowEmpty()
+    //
+    // Always returns `true`, indicating that all strings--including empty
+    // strings--should be included in the split output. This predicate is not
+    // strictly needed because this is the default behavior of `StrSplit()`;
+    // however, it might be useful at some call sites to make the intent explicit.
+    //
+    // Example:
+    //
+    //  std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', AllowEmpty());
+    //
+    //  // v[0] == " a ", v[1] == " ", v[2] == "", v[3] = "b", v[4] == ""
+    struct AllowEmpty
+    {
+        bool operator()(absl::string_view) const
+        {
+            return true;
+        }
+    };
+
+    // SkipEmpty()
+    //
+    // Returns `false` if the given `absl::string_view` is empty, indicating that
+    // `StrSplit()` should omit the empty string.
+    //
+    // Example:
+    //
+    //   std::vector<std::string> v = absl::StrSplit(",a,,b,", ',', SkipEmpty());
+    //
+    //   // v[0] == "a", v[1] == "b"
+    //
+    // Note: `SkipEmpty()` does not consider a string containing only whitespace
+    // to be empty. To skip such whitespace as well, use the `SkipWhitespace()`
+    // predicate.
+    struct SkipEmpty
+    {
+        bool operator()(absl::string_view sp) const
+        {
+            return !sp.empty();
+        }
+    };
+
+    // SkipWhitespace()
+    //
+    // Returns `false` if the given `absl::string_view` is empty *or* contains only
+    // whitespace, indicating that `StrSplit()` should omit the string.
+    //
+    // Example:
+    //
+    //   std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
+    //                                               ',', SkipWhitespace());
+    //   // v[0] == " a ", v[1] == "b"
+    //
+    //   // SkipEmpty() would return whitespace elements
+    //   std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', SkipEmpty());
+    //   // v[0] == " a ", v[1] == " ", v[2] == "b"
+    struct SkipWhitespace
+    {
+        bool operator()(absl::string_view sp) const
+        {
+            sp = absl::StripAsciiWhitespace(sp);
+            return !sp.empty();
+        }
+    };
+
+    template<typename T>
+    using EnableSplitIfString =
+        typename std::enable_if<std::is_same<T, std::string>::value || std::is_same<T, const std::string>::value, int>::type;
+
+    //------------------------------------------------------------------------------
+    //                                  StrSplit()
+    //------------------------------------------------------------------------------
+
+    // StrSplit()
+    //
+    // Splits a given string based on the provided `Delimiter` object, returning the
+    // elements within the type specified by the caller. Optionally, you may pass a
+    // `Predicate` to `StrSplit()` indicating whether to include or exclude the
+    // resulting element within the final result set. (See the overviews for
+    // Delimiters and Predicates above.)
+    //
+    // Example:
+    //
+    //   std::vector<std::string> v = absl::StrSplit("a,b,c,d", ',');
+    //   // v[0] == "a", v[1] == "b", v[2] == "c", v[3] == "d"
+    //
+    // You can also provide an explicit `Delimiter` object:
+    //
+    // Example:
+    //
+    //   using absl::ByAnyChar;
+    //   std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
+    //   // v[0] == "a", v[1] == "b", v[2] == "c"
+    //
+    // See above for more information on delimiters.
+    //
+    // By default, empty strings are included in the result set. You can optionally
+    // include a third `Predicate` argument to apply a test for whether the
+    // resultant element should be included in the result set:
+    //
+    // Example:
+    //
+    //   std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
+    //                                               ',', SkipWhitespace());
+    //   // v[0] == " a ", v[1] == "b"
+    //
+    // See above for more information on predicates.
+    //
+    //------------------------------------------------------------------------------
+    // StrSplit() Return Types
+    //------------------------------------------------------------------------------
+    //
+    // The `StrSplit()` function adapts the returned collection to the collection
+    // specified by the caller (e.g. `std::vector` above). The returned collections
+    // may contain `std::string`, `absl::string_view` (in which case the original
+    // string being split must ensure that it outlives the collection), or any
+    // object that can be explicitly created from an `absl::string_view`. This
+    // behavior works for:
+    //
+    // 1) All standard STL containers including `std::vector`, `std::list`,
+    //    `std::deque`, `std::set`,`std::multiset`, 'std::map`, and `std::multimap`
+    // 2) `std::pair` (which is not actually a container). See below.
+    //
+    // Example:
+    //
+    //   // The results are returned as `absl::string_view` objects. Note that we
+    //   // have to ensure that the input string outlives any results.
+    //   std::vector<absl::string_view> v = absl::StrSplit("a,b,c", ',');
+    //
+    //   // Stores results in a std::set<std::string>, which also performs
+    //   // de-duplication and orders the elements in ascending order.
+    //   std::set<std::string> a = absl::StrSplit("b,a,c,a,b", ',');
+    //   // v[0] == "a", v[1] == "b", v[2] = "c"
+    //
+    //   // `StrSplit()` can be used within a range-based for loop, in which case
+    //   // each element will be of type `absl::string_view`.
+    //   std::vector<std::string> v;
+    //   for (const auto sv : absl::StrSplit("a,b,c", ',')) {
+    //     if (sv != "b") v.emplace_back(sv);
+    //   }
+    //   // v[0] == "a", v[1] == "c"
+    //
+    //   // Stores results in a map. The map implementation assumes that the input
+    //   // is provided as a series of key/value pairs. For example, the 0th element
+    //   // resulting from the split will be stored as a key to the 1st element. If
+    //   // an odd number of elements are resolved, the last element is paired with
+    //   // a default-constructed value (e.g., empty string).
+    //   std::map<std::string, std::string> m = absl::StrSplit("a,b,c", ',');
+    //   // m["a"] == "b", m["c"] == ""     // last component value equals ""
+    //
+    // Splitting to `std::pair` is an interesting case because it can hold only two
+    // elements and is not a collection type. When splitting to a `std::pair` the
+    // first two split strings become the `std::pair` `.first` and `.second`
+    // members, respectively. The remaining split substrings are discarded. If there
+    // are less than two split substrings, the empty string is used for the
+    // corresponding `std::pair` member.
+    //
+    // Example:
+    //
+    //   // Stores first two split strings as the members in a std::pair.
+    //   std::pair<std::string, std::string> p = absl::StrSplit("a,b,c", ',');
+    //   // p.first == "a", p.second == "b"       // "c" is omitted.
+    //
+    // The `StrSplit()` function can be used multiple times to perform more
+    // complicated splitting logic, such as intelligently parsing key-value pairs.
+    //
+    // Example:
+    //
+    //   // The input string "a=b=c,d=e,f=,g" becomes
+    //   // { "a" => "b=c", "d" => "e", "f" => "", "g" => "" }
+    //   std::map<std::string, std::string> m;
+    //   for (absl::string_view sp : absl::StrSplit("a=b=c,d=e,f=,g", ',')) {
+    //     m.insert(absl::StrSplit(sp, absl::MaxSplits('=', 1)));
+    //   }
+    //   EXPECT_EQ("b=c", m.find("a")->second);
+    //   EXPECT_EQ("e", m.find("d")->second);
+    //   EXPECT_EQ("", m.find("f")->second);
+    //   EXPECT_EQ("", m.find("g")->second);
+    //
+    // WARNING: Due to a legacy bug that is maintained for backward compatibility,
+    // splitting the following empty string_views produces different results:
+    //
+    //   absl::StrSplit(absl::string_view(""), '-');  // {""}
+    //   absl::StrSplit(absl::string_view(), '-');    // {}, but should be {""}
+    //
+    // Try not to depend on this distinction because the bug may one day be fixed.
+    template<typename Delimiter>
+    strings_internal::Splitter<
+        typename strings_internal::SelectDelimiter<Delimiter>::type,
+        AllowEmpty,
+        absl::string_view>
+        StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d)
+    {
+        using DelimiterType =
+            typename strings_internal::SelectDelimiter<Delimiter>::type;
+        return strings_internal::Splitter<DelimiterType, AllowEmpty, absl::string_view>(
+            text.value(), DelimiterType(d), AllowEmpty()
+        );
+    }
 
-}  // namespace strings_internal
+    template<typename Delimiter, typename StringType, EnableSplitIfString<StringType> = 0>
+    strings_internal::Splitter<
+        typename strings_internal::SelectDelimiter<Delimiter>::type,
+        AllowEmpty,
+        std::string>
+        StrSplit(StringType&& text, Delimiter d)
+    {
+        using DelimiterType =
+            typename strings_internal::SelectDelimiter<Delimiter>::type;
+        return strings_internal::Splitter<DelimiterType, AllowEmpty, std::string>(
+            std::move(text), DelimiterType(d), AllowEmpty()
+        );
+    }
 
-// MaxSplits()
-//
-// A delimiter that limits the number of matches which can occur to the passed
-// `limit`. The last element in the returned collection will contain all
-// remaining unsplit pieces, which may contain instances of the delimiter.
-// The collection will contain at most `limit` + 1 elements.
-// Example:
-//
-//   using absl::MaxSplits;
-//   std::vector<std::string> v = absl::StrSplit("a,b,c", MaxSplits(',', 1));
-//
-//   // v[0] == "a", v[1] == "b,c"
-template <typename Delimiter>
-inline strings_internal::MaxSplitsImpl<
-    typename strings_internal::SelectDelimiter<Delimiter>::type>
-MaxSplits(Delimiter delimiter, int limit) {
-  typedef
-      typename strings_internal::SelectDelimiter<Delimiter>::type DelimiterType;
-  return strings_internal::MaxSplitsImpl<DelimiterType>(
-      DelimiterType(delimiter), limit);
-}
-
-//------------------------------------------------------------------------------
-// Predicates
-//------------------------------------------------------------------------------
-//
-// Predicates filter the results of a `StrSplit()` by determining whether or not
-// a resultant element is included in the result set. A predicate may be passed
-// as an optional third argument to the `StrSplit()` function.
-//
-// Predicates are unary functions (or functors) that take a single
-// `absl::string_view` argument and return a bool indicating whether the
-// argument should be included (`true`) or excluded (`false`).
-//
-// Predicates are useful when filtering out empty substrings. By default, empty
-// substrings may be returned by `StrSplit()`, which is similar to the way split
-// functions work in other programming languages.
+    template<typename Delimiter, typename Predicate>
+    strings_internal::Splitter<
+        typename strings_internal::SelectDelimiter<Delimiter>::type,
+        Predicate,
+        absl::string_view>
+        StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d, Predicate p)
+    {
+        using DelimiterType =
+            typename strings_internal::SelectDelimiter<Delimiter>::type;
+        return strings_internal::Splitter<DelimiterType, Predicate, absl::string_view>(
+            text.value(), DelimiterType(d), std::move(p)
+        );
+    }
 
-// AllowEmpty()
-//
-// Always returns `true`, indicating that all strings--including empty
-// strings--should be included in the split output. This predicate is not
-// strictly needed because this is the default behavior of `StrSplit()`;
-// however, it might be useful at some call sites to make the intent explicit.
-//
-// Example:
-//
-//  std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', AllowEmpty());
-//
-//  // v[0] == " a ", v[1] == " ", v[2] == "", v[3] = "b", v[4] == ""
-struct AllowEmpty {
-  bool operator()(absl::string_view) const { return true; }
-};
+    template<typename Delimiter, typename Predicate, typename StringType, EnableSplitIfString<StringType> = 0>
+    strings_internal::Splitter<
+        typename strings_internal::SelectDelimiter<Delimiter>::type,
+        Predicate,
+        std::string>
+        StrSplit(StringType&& text, Delimiter d, Predicate p)
+    {
+        using DelimiterType =
+            typename strings_internal::SelectDelimiter<Delimiter>::type;
+        return strings_internal::Splitter<DelimiterType, Predicate, std::string>(
+            std::move(text), DelimiterType(d), std::move(p)
+        );
+    }
 
-// SkipEmpty()
-//
-// Returns `false` if the given `absl::string_view` is empty, indicating that
-// `StrSplit()` should omit the empty string.
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit(",a,,b,", ',', SkipEmpty());
-//
-//   // v[0] == "a", v[1] == "b"
-//
-// Note: `SkipEmpty()` does not consider a string containing only whitespace
-// to be empty. To skip such whitespace as well, use the `SkipWhitespace()`
-// predicate.
-struct SkipEmpty {
-  bool operator()(absl::string_view sp) const { return !sp.empty(); }
-};
-
-// SkipWhitespace()
-//
-// Returns `false` if the given `absl::string_view` is empty *or* contains only
-// whitespace, indicating that `StrSplit()` should omit the string.
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
-//                                               ',', SkipWhitespace());
-//   // v[0] == " a ", v[1] == "b"
-//
-//   // SkipEmpty() would return whitespace elements
-//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', SkipEmpty());
-//   // v[0] == " a ", v[1] == " ", v[2] == "b"
-struct SkipWhitespace {
-  bool operator()(absl::string_view sp) const {
-    sp = absl::StripAsciiWhitespace(sp);
-    return !sp.empty();
-  }
-};
-
-template <typename T>
-using EnableSplitIfString =
-    typename std::enable_if<std::is_same<T, std::string>::value ||
-                            std::is_same<T, const std::string>::value,
-                            int>::type;
-
-//------------------------------------------------------------------------------
-//                                  StrSplit()
-//------------------------------------------------------------------------------
-
-// StrSplit()
-//
-// Splits a given string based on the provided `Delimiter` object, returning the
-// elements within the type specified by the caller. Optionally, you may pass a
-// `Predicate` to `StrSplit()` indicating whether to include or exclude the
-// resulting element within the final result set. (See the overviews for
-// Delimiters and Predicates above.)
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit("a,b,c,d", ',');
-//   // v[0] == "a", v[1] == "b", v[2] == "c", v[3] == "d"
-//
-// You can also provide an explicit `Delimiter` object:
-//
-// Example:
-//
-//   using absl::ByAnyChar;
-//   std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
-//   // v[0] == "a", v[1] == "b", v[2] == "c"
-//
-// See above for more information on delimiters.
-//
-// By default, empty strings are included in the result set. You can optionally
-// include a third `Predicate` argument to apply a test for whether the
-// resultant element should be included in the result set:
-//
-// Example:
-//
-//   std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
-//                                               ',', SkipWhitespace());
-//   // v[0] == " a ", v[1] == "b"
-//
-// See above for more information on predicates.
-//
-//------------------------------------------------------------------------------
-// StrSplit() Return Types
-//------------------------------------------------------------------------------
-//
-// The `StrSplit()` function adapts the returned collection to the collection
-// specified by the caller (e.g. `std::vector` above). The returned collections
-// may contain `std::string`, `absl::string_view` (in which case the original
-// string being split must ensure that it outlives the collection), or any
-// object that can be explicitly created from an `absl::string_view`. This
-// behavior works for:
-//
-// 1) All standard STL containers including `std::vector`, `std::list`,
-//    `std::deque`, `std::set`,`std::multiset`, 'std::map`, and `std::multimap`
-// 2) `std::pair` (which is not actually a container). See below.
-//
-// Example:
-//
-//   // The results are returned as `absl::string_view` objects. Note that we
-//   // have to ensure that the input string outlives any results.
-//   std::vector<absl::string_view> v = absl::StrSplit("a,b,c", ',');
-//
-//   // Stores results in a std::set<std::string>, which also performs
-//   // de-duplication and orders the elements in ascending order.
-//   std::set<std::string> a = absl::StrSplit("b,a,c,a,b", ',');
-//   // v[0] == "a", v[1] == "b", v[2] = "c"
-//
-//   // `StrSplit()` can be used within a range-based for loop, in which case
-//   // each element will be of type `absl::string_view`.
-//   std::vector<std::string> v;
-//   for (const auto sv : absl::StrSplit("a,b,c", ',')) {
-//     if (sv != "b") v.emplace_back(sv);
-//   }
-//   // v[0] == "a", v[1] == "c"
-//
-//   // Stores results in a map. The map implementation assumes that the input
-//   // is provided as a series of key/value pairs. For example, the 0th element
-//   // resulting from the split will be stored as a key to the 1st element. If
-//   // an odd number of elements are resolved, the last element is paired with
-//   // a default-constructed value (e.g., empty string).
-//   std::map<std::string, std::string> m = absl::StrSplit("a,b,c", ',');
-//   // m["a"] == "b", m["c"] == ""     // last component value equals ""
-//
-// Splitting to `std::pair` is an interesting case because it can hold only two
-// elements and is not a collection type. When splitting to a `std::pair` the
-// first two split strings become the `std::pair` `.first` and `.second`
-// members, respectively. The remaining split substrings are discarded. If there
-// are less than two split substrings, the empty string is used for the
-// corresponding `std::pair` member.
-//
-// Example:
-//
-//   // Stores first two split strings as the members in a std::pair.
-//   std::pair<std::string, std::string> p = absl::StrSplit("a,b,c", ',');
-//   // p.first == "a", p.second == "b"       // "c" is omitted.
-//
-// The `StrSplit()` function can be used multiple times to perform more
-// complicated splitting logic, such as intelligently parsing key-value pairs.
-//
-// Example:
-//
-//   // The input string "a=b=c,d=e,f=,g" becomes
-//   // { "a" => "b=c", "d" => "e", "f" => "", "g" => "" }
-//   std::map<std::string, std::string> m;
-//   for (absl::string_view sp : absl::StrSplit("a=b=c,d=e,f=,g", ',')) {
-//     m.insert(absl::StrSplit(sp, absl::MaxSplits('=', 1)));
-//   }
-//   EXPECT_EQ("b=c", m.find("a")->second);
-//   EXPECT_EQ("e", m.find("d")->second);
-//   EXPECT_EQ("", m.find("f")->second);
-//   EXPECT_EQ("", m.find("g")->second);
-//
-// WARNING: Due to a legacy bug that is maintained for backward compatibility,
-// splitting the following empty string_views produces different results:
-//
-//   absl::StrSplit(absl::string_view(""), '-');  // {""}
-//   absl::StrSplit(absl::string_view(), '-');    // {}, but should be {""}
-//
-// Try not to depend on this distinction because the bug may one day be fixed.
-template <typename Delimiter>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty,
-    absl::string_view>
-StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, AllowEmpty,
-                                    absl::string_view>(
-      text.value(), DelimiterType(d), AllowEmpty());
-}
-
-template <typename Delimiter, typename StringType,
-          EnableSplitIfString<StringType> = 0>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty,
-    std::string>
-StrSplit(StringType&& text, Delimiter d) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, AllowEmpty, std::string>(
-      std::move(text), DelimiterType(d), AllowEmpty());
-}
-
-template <typename Delimiter, typename Predicate>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
-    absl::string_view>
-StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d,
-         Predicate p) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, Predicate,
-                                    absl::string_view>(
-      text.value(), DelimiterType(d), std::move(p));
-}
-
-template <typename Delimiter, typename Predicate, typename StringType,
-          EnableSplitIfString<StringType> = 0>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
-    std::string>
-StrSplit(StringType&& text, Delimiter d, Predicate p) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, Predicate, std::string>(
-      std::move(text), DelimiterType(d), std::move(p));
-}
-
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_STR_SPLIT_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/string_view.h b/CAPI/cpp/grpc/include/absl/strings/string_view.h
index e3239f5..8e3f372 100644
--- a/CAPI/cpp/grpc/include/absl/strings/string_view.h
+++ b/CAPI/cpp/grpc/include/absl/strings/string_view.h
@@ -47,10 +47,11 @@
 
 #include <string_view>  // IWYU pragma: export
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using string_view = std::string_view;
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    using string_view = std::string_view;
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_STRING_VIEW
@@ -69,613 +70,702 @@ ABSL_NAMESPACE_END
 #define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::string_view
-//
-// A `string_view` provides a lightweight view into the string data provided by
-// a `std::string`, double-quoted string literal, character array, or even
-// another `string_view`. A `string_view` does *not* own the string to which it
-// points, and that data cannot be modified through the view.
-//
-// You can use `string_view` as a function or method parameter anywhere a
-// parameter can receive a double-quoted string literal, `const char*`,
-// `std::string`, or another `absl::string_view` argument with no need to copy
-// the string data. Systematic use of `string_view` within function arguments
-// reduces data copies and `strlen()` calls.
-//
-// Because of its small size, prefer passing `string_view` by value:
-//
-//   void MyFunction(absl::string_view arg);
-//
-// If circumstances require, you may also pass one by const reference:
-//
-//   void MyFunction(const absl::string_view& arg);  // not preferred
-//
-// Passing by value generates slightly smaller code for many architectures.
-//
-// In either case, the source data of the `string_view` must outlive the
-// `string_view` itself.
-//
-// A `string_view` is also suitable for local variables if you know that the
-// lifetime of the underlying object is longer than the lifetime of your
-// `string_view` variable. However, beware of binding a `string_view` to a
-// temporary value:
-//
-//   // BAD use of string_view: lifetime problem
-//   absl::string_view sv = obj.ReturnAString();
-//
-//   // GOOD use of string_view: str outlives sv
-//   std::string str = obj.ReturnAString();
-//   absl::string_view sv = str;
-//
-// Due to lifetime issues, a `string_view` is sometimes a poor choice for a
-// return value and usually a poor choice for a data member. If you do use a
-// `string_view` this way, it is your responsibility to ensure that the object
-// pointed to by the `string_view` outlives the `string_view`.
-//
-// A `string_view` may represent a whole string or just part of a string. For
-// example, when splitting a string, `std::vector<absl::string_view>` is a
-// natural data type for the output.
-//
-// For another example, a Cord is a non-contiguous, potentially very
-// long string-like object.  The Cord class has an interface that iteratively
-// provides string_view objects that point to the successive pieces of a Cord
-// object.
-//
-// When constructed from a source which is NUL-terminated, the `string_view`
-// itself will not include the NUL-terminator unless a specific size (including
-// the NUL) is passed to the constructor. As a result, common idioms that work
-// on NUL-terminated strings do not work on `string_view` objects. If you write
-// code that scans a `string_view`, you must check its length rather than test
-// for nul, for example. Note, however, that nuls may still be embedded within
-// a `string_view` explicitly.
-//
-// You may create a null `string_view` in two ways:
-//
-//   absl::string_view sv;
-//   absl::string_view sv(nullptr, 0);
-//
-// For the above, `sv.data() == nullptr`, `sv.length() == 0`, and
-// `sv.empty() == true`. Also, if you create a `string_view` with a non-null
-// pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to
-// signal an undefined value that is different from other `string_view` values
-// in a similar fashion to how `const char* p1 = nullptr;` is different from
-// `const char* p2 = "";`. However, in practice, it is not recommended to rely
-// on this behavior.
-//
-// Be careful not to confuse a null `string_view` with an empty one. A null
-// `string_view` is an empty `string_view`, but some empty `string_view`s are
-// not null. Prefer checking for emptiness over checking for null.
-//
-// There are many ways to create an empty string_view:
-//
-//   const char* nullcp = nullptr;
-//   // string_view.size() will return 0 in all cases.
-//   absl::string_view();
-//   absl::string_view(nullcp, 0);
-//   absl::string_view("");
-//   absl::string_view("", 0);
-//   absl::string_view("abcdef", 0);
-//   absl::string_view("abcdef" + 6, 0);
-//
-// All empty `string_view` objects whether null or not, are equal:
-//
-//   absl::string_view() == absl::string_view("", 0)
-//   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
-class string_view {
- public:
-  using traits_type = std::char_traits<char>;
-  using value_type = char;
-  using pointer = char*;
-  using const_pointer = const char*;
-  using reference = char&;
-  using const_reference = const char&;
-  using const_iterator = const char*;
-  using iterator = const_iterator;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using reverse_iterator = const_reverse_iterator;
-  using size_type = size_t;
-  using difference_type = std::ptrdiff_t;
-
-  static constexpr size_type npos = static_cast<size_type>(-1);
-
-  // Null `string_view` constructor
-  constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
-
-  // Implicit constructors
-
-  template <typename Allocator>
-  string_view(  // NOLINT(runtime/explicit)
-      const std::basic_string<char, std::char_traits<char>, Allocator>& str
-          ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
-      // This is implemented in terms of `string_view(p, n)` so `str.size()`
-      // doesn't need to be reevaluated after `ptr_` is set.
-      // The length check is also skipped since it is unnecessary and causes
-      // code bloat.
-      : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
-
-  // Implicit constructor of a `string_view` from NUL-terminated `str`. When
-  // accepting possibly null strings, use `absl::NullSafeStringView(str)`
-  // instead (see below).
-  // The length check is skipped since it is unnecessary and causes code bloat.
-  constexpr string_view(const char* str)  // NOLINT(runtime/explicit)
-      : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
-
-  // Implicit constructor of a `string_view` from a `const char*` and length.
-  constexpr string_view(const char* data, size_type len)
-      : ptr_(data), length_(CheckLengthInternal(len)) {}
-
-  // NOTE: Harmlessly omitted to work around gdb bug.
-  //   constexpr string_view(const string_view&) noexcept = default;
-  //   string_view& operator=(const string_view&) noexcept = default;
-
-  // Iterators
-
-  // string_view::begin()
-  //
-  // Returns an iterator pointing to the first character at the beginning of the
-  // `string_view`, or `end()` if the `string_view` is empty.
-  constexpr const_iterator begin() const noexcept { return ptr_; }
-
-  // string_view::end()
-  //
-  // Returns an iterator pointing just beyond the last character at the end of
-  // the `string_view`. This iterator acts as a placeholder; attempting to
-  // access it results in undefined behavior.
-  constexpr const_iterator end() const noexcept { return ptr_ + length_; }
-
-  // string_view::cbegin()
-  //
-  // Returns a const iterator pointing to the first character at the beginning
-  // of the `string_view`, or `end()` if the `string_view` is empty.
-  constexpr const_iterator cbegin() const noexcept { return begin(); }
-
-  // string_view::cend()
-  //
-  // Returns a const iterator pointing just beyond the last character at the end
-  // of the `string_view`. This pointer acts as a placeholder; attempting to
-  // access its element results in undefined behavior.
-  constexpr const_iterator cend() const noexcept { return end(); }
-
-  // string_view::rbegin()
-  //
-  // Returns a reverse iterator pointing to the last character at the end of the
-  // `string_view`, or `rend()` if the `string_view` is empty.
-  const_reverse_iterator rbegin() const noexcept {
-    return const_reverse_iterator(end());
-  }
-
-  // string_view::rend()
-  //
-  // Returns a reverse iterator pointing just before the first character at the
-  // beginning of the `string_view`. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
-  const_reverse_iterator rend() const noexcept {
-    return const_reverse_iterator(begin());
-  }
-
-  // string_view::crbegin()
-  //
-  // Returns a const reverse iterator pointing to the last character at the end
-  // of the `string_view`, or `crend()` if the `string_view` is empty.
-  const_reverse_iterator crbegin() const noexcept { return rbegin(); }
-
-  // string_view::crend()
-  //
-  // Returns a const reverse iterator pointing just before the first character
-  // at the beginning of the `string_view`. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
-  const_reverse_iterator crend() const noexcept { return rend(); }
-
-  // Capacity Utilities
-
-  // string_view::size()
-  //
-  // Returns the number of characters in the `string_view`.
-  constexpr size_type size() const noexcept { return length_; }
-
-  // string_view::length()
-  //
-  // Returns the number of characters in the `string_view`. Alias for `size()`.
-  constexpr size_type length() const noexcept { return size(); }
-
-  // string_view::max_size()
-  //
-  // Returns the maximum number of characters the `string_view` can hold.
-  constexpr size_type max_size() const noexcept { return kMaxSize; }
-
-  // string_view::empty()
-  //
-  // Checks if the `string_view` is empty (refers to no characters).
-  constexpr bool empty() const noexcept { return length_ == 0; }
-
-  // string_view::operator[]
-  //
-  // Returns the ith element of the `string_view` using the array operator.
-  // Note that this operator does not perform any bounds checking.
-  constexpr const_reference operator[](size_type i) const {
-    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
-  }
-
-  // string_view::at()
-  //
-  // Returns the ith element of the `string_view`. Bounds checking is performed,
-  // and an exception of type `std::out_of_range` will be thrown on invalid
-  // access.
-  constexpr const_reference at(size_type i) const {
-    return ABSL_PREDICT_TRUE(i < size())
-               ? ptr_[i]
-               : ((void)base_internal::ThrowStdOutOfRange(
-                      "absl::string_view::at"),
-                  ptr_[i]);
-  }
-
-  // string_view::front()
-  //
-  // Returns the first element of a `string_view`.
-  constexpr const_reference front() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
-  }
-
-  // string_view::back()
-  //
-  // Returns the last element of a `string_view`.
-  constexpr const_reference back() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
-  }
-
-  // string_view::data()
-  //
-  // Returns a pointer to the underlying character array (which is of course
-  // stored elsewhere). Note that `string_view::data()` may contain embedded nul
-  // characters, but the returned buffer may or may not be NUL-terminated;
-  // therefore, do not pass `data()` to a routine that expects a NUL-terminated
-  // string.
-  constexpr const_pointer data() const noexcept { return ptr_; }
-
-  // Modifiers
-
-  // string_view::remove_prefix()
-  //
-  // Removes the first `n` characters from the `string_view`. Note that the
-  // underlying string is not changed, only the view.
-  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_prefix(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= length_);
-    ptr_ += n;
-    length_ -= n;
-  }
-
-  // string_view::remove_suffix()
-  //
-  // Removes the last `n` characters from the `string_view`. Note that the
-  // underlying string is not changed, only the view.
-  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_suffix(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= length_);
-    length_ -= n;
-  }
-
-  // string_view::swap()
-  //
-  // Swaps this `string_view` with another `string_view`.
-  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void swap(string_view& s) noexcept {
-    auto t = *this;
-    *this = s;
-    s = t;
-  }
-
-  // Explicit conversion operators
-
-  // Converts to `std::basic_string`.
-  template <typename A>
-  explicit operator std::basic_string<char, traits_type, A>() const {
-    if (!data()) return {};
-    return std::basic_string<char, traits_type, A>(data(), size());
-  }
-
-  // string_view::copy()
-  //
-  // Copies the contents of the `string_view` at offset `pos` and length `n`
-  // into `buf`.
-  size_type copy(char* buf, size_type n, size_type pos = 0) const {
-    if (ABSL_PREDICT_FALSE(pos > length_)) {
-      base_internal::ThrowStdOutOfRange("absl::string_view::copy");
-    }
-    size_type rlen = (std::min)(length_ - pos, n);
-    if (rlen > 0) {
-      const char* start = ptr_ + pos;
-      traits_type::copy(buf, start, rlen);
-    }
-    return rlen;
-  }
-
-  // string_view::substr()
-  //
-  // Returns a "substring" of the `string_view` (at offset `pos` and length
-  // `n`) as another string_view. This function throws `std::out_of_bounds` if
-  // `pos > size`.
-  // Use absl::ClippedSubstr if you need a truncating substr operation.
-  constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
-    return ABSL_PREDICT_FALSE(pos > length_)
-               ? (base_internal::ThrowStdOutOfRange(
-                      "absl::string_view::substr"),
-                  string_view())
-               : string_view(ptr_ + pos, Min(n, length_ - pos));
-  }
-
-  // string_view::compare()
-  //
-  // Performs a lexicographical comparison between this `string_view` and
-  // another `string_view` `x`, returning a negative value if `*this` is less
-  // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this`
-  // is greater than `x`.
-  constexpr int compare(string_view x) const noexcept {
-    return CompareImpl(length_, x.length_,
-                       Min(length_, x.length_) == 0
-                           ? 0
-                           : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
-                                 ptr_, x.ptr_, Min(length_, x.length_)));
-  }
-
-  // Overload of `string_view::compare()` for comparing a substring of the
-  // 'string_view` and another `absl::string_view`.
-  constexpr int compare(size_type pos1, size_type count1, string_view v) const {
-    return substr(pos1, count1).compare(v);
-  }
-
-  // Overload of `string_view::compare()` for comparing a substring of the
-  // `string_view` and a substring of another `absl::string_view`.
-  constexpr int compare(size_type pos1, size_type count1, string_view v,
-                        size_type pos2, size_type count2) const {
-    return substr(pos1, count1).compare(v.substr(pos2, count2));
-  }
-
-  // Overload of `string_view::compare()` for comparing a `string_view` and a
-  // a different C-style string `s`.
-  constexpr int compare(const char* s) const { return compare(string_view(s)); }
-
-  // Overload of `string_view::compare()` for comparing a substring of the
-  // `string_view` and a different string C-style string `s`.
-  constexpr int compare(size_type pos1, size_type count1, const char* s) const {
-    return substr(pos1, count1).compare(string_view(s));
-  }
-
-  // Overload of `string_view::compare()` for comparing a substring of the
-  // `string_view` and a substring of a different C-style string `s`.
-  constexpr int compare(size_type pos1, size_type count1, const char* s,
-                        size_type count2) const {
-    return substr(pos1, count1).compare(string_view(s, count2));
-  }
-
-  // Find Utilities
-
-  // string_view::find()
-  //
-  // Finds the first occurrence of the substring `s` within the `string_view`,
-  // returning the position of the first character's match, or `npos` if no
-  // match was found.
-  size_type find(string_view s, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find()` for finding the given character `c`
-  // within the `string_view`.
-  size_type find(char c, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find()` for finding a substring of a different
-  // C-style string `s` within the `string_view`.
-  size_type find(const char* s, size_type pos, size_type count) const {
-    return find(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find()` for finding a different C-style string
-  // `s` within the `string_view`.
-  size_type find(const char* s, size_type pos = 0) const {
-    return find(string_view(s), pos);
-  }
-
-  // string_view::rfind()
-  //
-  // Finds the last occurrence of a substring `s` within the `string_view`,
-  // returning the position of the first character's match, or `npos` if no
-  // match was found.
-  size_type rfind(string_view s, size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::rfind()` for finding the last given character `c`
-  // within the `string_view`.
-  size_type rfind(char c, size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::rfind()` for finding a substring of a different
-  // C-style string `s` within the `string_view`.
-  size_type rfind(const char* s, size_type pos, size_type count) const {
-    return rfind(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::rfind()` for finding a different C-style string
-  // `s` within the `string_view`.
-  size_type rfind(const char* s, size_type pos = npos) const {
-    return rfind(string_view(s), pos);
-  }
-
-  // string_view::find_first_of()
-  //
-  // Finds the first occurrence of any of the characters in `s` within the
-  // `string_view`, returning the start position of the match, or `npos` if no
-  // match was found.
-  size_type find_first_of(string_view s, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find_first_of()` for finding a character `c`
-  // within the `string_view`.
-  size_type find_first_of(char c, size_type pos = 0) const noexcept {
-    return find(c, pos);
-  }
-
-  // Overload of `string_view::find_first_of()` for finding a substring of a
-  // different C-style string `s` within the `string_view`.
-  size_type find_first_of(const char* s, size_type pos,
-                                    size_type count) const {
-    return find_first_of(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find_first_of()` for finding a different C-style
-  // string `s` within the `string_view`.
-  size_type find_first_of(const char* s, size_type pos = 0) const {
-    return find_first_of(string_view(s), pos);
-  }
-
-  // string_view::find_last_of()
-  //
-  // Finds the last occurrence of any of the characters in `s` within the
-  // `string_view`, returning the start position of the match, or `npos` if no
-  // match was found.
-  size_type find_last_of(string_view s, size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::find_last_of()` for finding a character `c`
-  // within the `string_view`.
-  size_type find_last_of(char c, size_type pos = npos) const noexcept {
-    return rfind(c, pos);
-  }
-
-  // Overload of `string_view::find_last_of()` for finding a substring of a
-  // different C-style string `s` within the `string_view`.
-  size_type find_last_of(const char* s, size_type pos, size_type count) const {
-    return find_last_of(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find_last_of()` for finding a different C-style
-  // string `s` within the `string_view`.
-  size_type find_last_of(const char* s, size_type pos = npos) const {
-    return find_last_of(string_view(s), pos);
-  }
-
-  // string_view::find_first_not_of()
-  //
-  // Finds the first occurrence of any of the characters not in `s` within the
-  // `string_view`, returning the start position of the first non-match, or
-  // `npos` if no non-match was found.
-  size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find_first_not_of()` for finding a character
-  // that is not `c` within the `string_view`.
-  size_type find_first_not_of(char c, size_type pos = 0) const noexcept;
-
-  // Overload of `string_view::find_first_not_of()` for finding a substring of a
-  // different C-style string `s` within the `string_view`.
-  size_type find_first_not_of(const char* s, size_type pos,
-                              size_type count) const {
-    return find_first_not_of(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find_first_not_of()` for finding a different
-  // C-style string `s` within the `string_view`.
-  size_type find_first_not_of(const char* s, size_type pos = 0) const {
-    return find_first_not_of(string_view(s), pos);
-  }
-
-  // string_view::find_last_not_of()
-  //
-  // Finds the last occurrence of any of the characters not in `s` within the
-  // `string_view`, returning the start position of the last non-match, or
-  // `npos` if no non-match was found.
-  size_type find_last_not_of(string_view s,
-                             size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::find_last_not_of()` for finding a character
-  // that is not `c` within the `string_view`.
-  size_type find_last_not_of(char c, size_type pos = npos) const noexcept;
-
-  // Overload of `string_view::find_last_not_of()` for finding a substring of a
-  // different C-style string `s` within the `string_view`.
-  size_type find_last_not_of(const char* s, size_type pos,
-                             size_type count) const {
-    return find_last_not_of(string_view(s, count), pos);
-  }
-
-  // Overload of `string_view::find_last_not_of()` for finding a different
-  // C-style string `s` within the `string_view`.
-  size_type find_last_not_of(const char* s, size_type pos = npos) const {
-    return find_last_not_of(string_view(s), pos);
-  }
-
- private:
-  // The constructor from std::string delegates to this constructor.
-  // See the comment on that constructor for the rationale.
-  struct SkipCheckLengthTag {};
-  string_view(const char* data, size_type len, SkipCheckLengthTag) noexcept
-      : ptr_(data), length_(len) {}
-
-  static constexpr size_type kMaxSize =
-      (std::numeric_limits<difference_type>::max)();
-
-  static constexpr size_type CheckLengthInternal(size_type len) {
-    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
-  }
-
-  static constexpr size_type StrlenInternal(const char* str) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // absl::string_view
+    //
+    // A `string_view` provides a lightweight view into the string data provided by
+    // a `std::string`, double-quoted string literal, character array, or even
+    // another `string_view`. A `string_view` does *not* own the string to which it
+    // points, and that data cannot be modified through the view.
+    //
+    // You can use `string_view` as a function or method parameter anywhere a
+    // parameter can receive a double-quoted string literal, `const char*`,
+    // `std::string`, or another `absl::string_view` argument with no need to copy
+    // the string data. Systematic use of `string_view` within function arguments
+    // reduces data copies and `strlen()` calls.
+    //
+    // Because of its small size, prefer passing `string_view` by value:
+    //
+    //   void MyFunction(absl::string_view arg);
+    //
+    // If circumstances require, you may also pass one by const reference:
+    //
+    //   void MyFunction(const absl::string_view& arg);  // not preferred
+    //
+    // Passing by value generates slightly smaller code for many architectures.
+    //
+    // In either case, the source data of the `string_view` must outlive the
+    // `string_view` itself.
+    //
+    // A `string_view` is also suitable for local variables if you know that the
+    // lifetime of the underlying object is longer than the lifetime of your
+    // `string_view` variable. However, beware of binding a `string_view` to a
+    // temporary value:
+    //
+    //   // BAD use of string_view: lifetime problem
+    //   absl::string_view sv = obj.ReturnAString();
+    //
+    //   // GOOD use of string_view: str outlives sv
+    //   std::string str = obj.ReturnAString();
+    //   absl::string_view sv = str;
+    //
+    // Due to lifetime issues, a `string_view` is sometimes a poor choice for a
+    // return value and usually a poor choice for a data member. If you do use a
+    // `string_view` this way, it is your responsibility to ensure that the object
+    // pointed to by the `string_view` outlives the `string_view`.
+    //
+    // A `string_view` may represent a whole string or just part of a string. For
+    // example, when splitting a string, `std::vector<absl::string_view>` is a
+    // natural data type for the output.
+    //
+    // For another example, a Cord is a non-contiguous, potentially very
+    // long string-like object.  The Cord class has an interface that iteratively
+    // provides string_view objects that point to the successive pieces of a Cord
+    // object.
+    //
+    // When constructed from a source which is NUL-terminated, the `string_view`
+    // itself will not include the NUL-terminator unless a specific size (including
+    // the NUL) is passed to the constructor. As a result, common idioms that work
+    // on NUL-terminated strings do not work on `string_view` objects. If you write
+    // code that scans a `string_view`, you must check its length rather than test
+    // for nul, for example. Note, however, that nuls may still be embedded within
+    // a `string_view` explicitly.
+    //
+    // You may create a null `string_view` in two ways:
+    //
+    //   absl::string_view sv;
+    //   absl::string_view sv(nullptr, 0);
+    //
+    // For the above, `sv.data() == nullptr`, `sv.length() == 0`, and
+    // `sv.empty() == true`. Also, if you create a `string_view` with a non-null
+    // pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to
+    // signal an undefined value that is different from other `string_view` values
+    // in a similar fashion to how `const char* p1 = nullptr;` is different from
+    // `const char* p2 = "";`. However, in practice, it is not recommended to rely
+    // on this behavior.
+    //
+    // Be careful not to confuse a null `string_view` with an empty one. A null
+    // `string_view` is an empty `string_view`, but some empty `string_view`s are
+    // not null. Prefer checking for emptiness over checking for null.
+    //
+    // There are many ways to create an empty string_view:
+    //
+    //   const char* nullcp = nullptr;
+    //   // string_view.size() will return 0 in all cases.
+    //   absl::string_view();
+    //   absl::string_view(nullcp, 0);
+    //   absl::string_view("");
+    //   absl::string_view("", 0);
+    //   absl::string_view("abcdef", 0);
+    //   absl::string_view("abcdef" + 6, 0);
+    //
+    // All empty `string_view` objects whether null or not, are equal:
+    //
+    //   absl::string_view() == absl::string_view("", 0)
+    //   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
+    class string_view
+    {
+    public:
+        using traits_type = std::char_traits<char>;
+        using value_type = char;
+        using pointer = char*;
+        using const_pointer = const char*;
+        using reference = char&;
+        using const_reference = const char&;
+        using const_iterator = const char*;
+        using iterator = const_iterator;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        using reverse_iterator = const_reverse_iterator;
+        using size_type = size_t;
+        using difference_type = std::ptrdiff_t;
+
+        static constexpr size_type npos = static_cast<size_type>(-1);
+
+        // Null `string_view` constructor
+        constexpr string_view() noexcept :
+            ptr_(nullptr),
+            length_(0)
+        {
+        }
+
+        // Implicit constructors
+
+        template<typename Allocator>
+        string_view(  // NOLINT(runtime/explicit)
+            const std::basic_string<char, std::char_traits<char>, Allocator>& str
+                ABSL_ATTRIBUTE_LIFETIME_BOUND
+        ) noexcept
+            // This is implemented in terms of `string_view(p, n)` so `str.size()`
+            // doesn't need to be reevaluated after `ptr_` is set.
+            // The length check is also skipped since it is unnecessary and causes
+            // code bloat.
+            :
+            string_view(str.data(), str.size(), SkipCheckLengthTag{})
+        {
+        }
+
+        // Implicit constructor of a `string_view` from NUL-terminated `str`. When
+        // accepting possibly null strings, use `absl::NullSafeStringView(str)`
+        // instead (see below).
+        // The length check is skipped since it is unnecessary and causes code bloat.
+        constexpr string_view(const char* str)  // NOLINT(runtime/explicit)
+            :
+            ptr_(str),
+            length_(str ? StrlenInternal(str) : 0)
+        {
+        }
+
+        // Implicit constructor of a `string_view` from a `const char*` and length.
+        constexpr string_view(const char* data, size_type len) :
+            ptr_(data),
+            length_(CheckLengthInternal(len))
+        {
+        }
+
+        // NOTE: Harmlessly omitted to work around gdb bug.
+        //   constexpr string_view(const string_view&) noexcept = default;
+        //   string_view& operator=(const string_view&) noexcept = default;
+
+        // Iterators
+
+        // string_view::begin()
+        //
+        // Returns an iterator pointing to the first character at the beginning of the
+        // `string_view`, or `end()` if the `string_view` is empty.
+        constexpr const_iterator begin() const noexcept
+        {
+            return ptr_;
+        }
+
+        // string_view::end()
+        //
+        // Returns an iterator pointing just beyond the last character at the end of
+        // the `string_view`. This iterator acts as a placeholder; attempting to
+        // access it results in undefined behavior.
+        constexpr const_iterator end() const noexcept
+        {
+            return ptr_ + length_;
+        }
+
+        // string_view::cbegin()
+        //
+        // Returns a const iterator pointing to the first character at the beginning
+        // of the `string_view`, or `end()` if the `string_view` is empty.
+        constexpr const_iterator cbegin() const noexcept
+        {
+            return begin();
+        }
+
+        // string_view::cend()
+        //
+        // Returns a const iterator pointing just beyond the last character at the end
+        // of the `string_view`. This pointer acts as a placeholder; attempting to
+        // access its element results in undefined behavior.
+        constexpr const_iterator cend() const noexcept
+        {
+            return end();
+        }
+
+        // string_view::rbegin()
+        //
+        // Returns a reverse iterator pointing to the last character at the end of the
+        // `string_view`, or `rend()` if the `string_view` is empty.
+        const_reverse_iterator rbegin() const noexcept
+        {
+            return const_reverse_iterator(end());
+        }
+
+        // string_view::rend()
+        //
+        // Returns a reverse iterator pointing just before the first character at the
+        // beginning of the `string_view`. This pointer acts as a placeholder;
+        // attempting to access its element results in undefined behavior.
+        const_reverse_iterator rend() const noexcept
+        {
+            return const_reverse_iterator(begin());
+        }
+
+        // string_view::crbegin()
+        //
+        // Returns a const reverse iterator pointing to the last character at the end
+        // of the `string_view`, or `crend()` if the `string_view` is empty.
+        const_reverse_iterator crbegin() const noexcept
+        {
+            return rbegin();
+        }
+
+        // string_view::crend()
+        //
+        // Returns a const reverse iterator pointing just before the first character
+        // at the beginning of the `string_view`. This pointer acts as a placeholder;
+        // attempting to access its element results in undefined behavior.
+        const_reverse_iterator crend() const noexcept
+        {
+            return rend();
+        }
+
+        // Capacity Utilities
+
+        // string_view::size()
+        //
+        // Returns the number of characters in the `string_view`.
+        constexpr size_type size() const noexcept
+        {
+            return length_;
+        }
+
+        // string_view::length()
+        //
+        // Returns the number of characters in the `string_view`. Alias for `size()`.
+        constexpr size_type length() const noexcept
+        {
+            return size();
+        }
+
+        // string_view::max_size()
+        //
+        // Returns the maximum number of characters the `string_view` can hold.
+        constexpr size_type max_size() const noexcept
+        {
+            return kMaxSize;
+        }
+
+        // string_view::empty()
+        //
+        // Checks if the `string_view` is empty (refers to no characters).
+        constexpr bool empty() const noexcept
+        {
+            return length_ == 0;
+        }
+
+        // string_view::operator[]
+        //
+        // Returns the ith element of the `string_view` using the array operator.
+        // Note that this operator does not perform any bounds checking.
+        constexpr const_reference operator[](size_type i) const
+        {
+            return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
+        }
+
+        // string_view::at()
+        //
+        // Returns the ith element of the `string_view`. Bounds checking is performed,
+        // and an exception of type `std::out_of_range` will be thrown on invalid
+        // access.
+        constexpr const_reference at(size_type i) const
+        {
+            return ABSL_PREDICT_TRUE(i < size()) ? ptr_[i] : ((void)base_internal::ThrowStdOutOfRange("absl::string_view::at"), ptr_[i]);
+        }
+
+        // string_view::front()
+        //
+        // Returns the first element of a `string_view`.
+        constexpr const_reference front() const
+        {
+            return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
+        }
+
+        // string_view::back()
+        //
+        // Returns the last element of a `string_view`.
+        constexpr const_reference back() const
+        {
+            return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
+        }
+
+        // string_view::data()
+        //
+        // Returns a pointer to the underlying character array (which is of course
+        // stored elsewhere). Note that `string_view::data()` may contain embedded nul
+        // characters, but the returned buffer may or may not be NUL-terminated;
+        // therefore, do not pass `data()` to a routine that expects a NUL-terminated
+        // string.
+        constexpr const_pointer data() const noexcept
+        {
+            return ptr_;
+        }
+
+        // Modifiers
+
+        // string_view::remove_prefix()
+        //
+        // Removes the first `n` characters from the `string_view`. Note that the
+        // underlying string is not changed, only the view.
+        ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_prefix(size_type n)
+        {
+            ABSL_HARDENING_ASSERT(n <= length_);
+            ptr_ += n;
+            length_ -= n;
+        }
+
+        // string_view::remove_suffix()
+        //
+        // Removes the last `n` characters from the `string_view`. Note that the
+        // underlying string is not changed, only the view.
+        ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_suffix(size_type n)
+        {
+            ABSL_HARDENING_ASSERT(n <= length_);
+            length_ -= n;
+        }
+
+        // string_view::swap()
+        //
+        // Swaps this `string_view` with another `string_view`.
+        ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void swap(string_view& s) noexcept
+        {
+            auto t = *this;
+            *this = s;
+            s = t;
+        }
+
+        // Explicit conversion operators
+
+        // Converts to `std::basic_string`.
+        template<typename A>
+        explicit operator std::basic_string<char, traits_type, A>() const
+        {
+            if (!data())
+                return {};
+            return std::basic_string<char, traits_type, A>(data(), size());
+        }
+
+        // string_view::copy()
+        //
+        // Copies the contents of the `string_view` at offset `pos` and length `n`
+        // into `buf`.
+        size_type copy(char* buf, size_type n, size_type pos = 0) const
+        {
+            if (ABSL_PREDICT_FALSE(pos > length_))
+            {
+                base_internal::ThrowStdOutOfRange("absl::string_view::copy");
+            }
+            size_type rlen = (std::min)(length_ - pos, n);
+            if (rlen > 0)
+            {
+                const char* start = ptr_ + pos;
+                traits_type::copy(buf, start, rlen);
+            }
+            return rlen;
+        }
+
+        // string_view::substr()
+        //
+        // Returns a "substring" of the `string_view` (at offset `pos` and length
+        // `n`) as another string_view. This function throws `std::out_of_bounds` if
+        // `pos > size`.
+        // Use absl::ClippedSubstr if you need a truncating substr operation.
+        constexpr string_view substr(size_type pos = 0, size_type n = npos) const
+        {
+            return ABSL_PREDICT_FALSE(pos > length_) ? (base_internal::ThrowStdOutOfRange(
+                                                            "absl::string_view::substr"
+                                                        ),
+                                                        string_view()) :
+                                                       string_view(ptr_ + pos, Min(n, length_ - pos));
+        }
+
+        // string_view::compare()
+        //
+        // Performs a lexicographical comparison between this `string_view` and
+        // another `string_view` `x`, returning a negative value if `*this` is less
+        // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this`
+        // is greater than `x`.
+        constexpr int compare(string_view x) const noexcept
+        {
+            return CompareImpl(length_, x.length_, Min(length_, x.length_) == 0 ? 0 : ABSL_INTERNAL_STRING_VIEW_MEMCMP(ptr_, x.ptr_, Min(length_, x.length_)));
+        }
+
+        // Overload of `string_view::compare()` for comparing a substring of the
+        // 'string_view` and another `absl::string_view`.
+        constexpr int compare(size_type pos1, size_type count1, string_view v) const
+        {
+            return substr(pos1, count1).compare(v);
+        }
+
+        // Overload of `string_view::compare()` for comparing a substring of the
+        // `string_view` and a substring of another `absl::string_view`.
+        constexpr int compare(size_type pos1, size_type count1, string_view v, size_type pos2, size_type count2) const
+        {
+            return substr(pos1, count1).compare(v.substr(pos2, count2));
+        }
+
+        // Overload of `string_view::compare()` for comparing a `string_view` and a
+        // a different C-style string `s`.
+        constexpr int compare(const char* s) const
+        {
+            return compare(string_view(s));
+        }
+
+        // Overload of `string_view::compare()` for comparing a substring of the
+        // `string_view` and a different string C-style string `s`.
+        constexpr int compare(size_type pos1, size_type count1, const char* s) const
+        {
+            return substr(pos1, count1).compare(string_view(s));
+        }
+
+        // Overload of `string_view::compare()` for comparing a substring of the
+        // `string_view` and a substring of a different C-style string `s`.
+        constexpr int compare(size_type pos1, size_type count1, const char* s, size_type count2) const
+        {
+            return substr(pos1, count1).compare(string_view(s, count2));
+        }
+
+        // Find Utilities
+
+        // string_view::find()
+        //
+        // Finds the first occurrence of the substring `s` within the `string_view`,
+        // returning the position of the first character's match, or `npos` if no
+        // match was found.
+        size_type find(string_view s, size_type pos = 0) const noexcept;
+
+        // Overload of `string_view::find()` for finding the given character `c`
+        // within the `string_view`.
+        size_type find(char c, size_type pos = 0) const noexcept;
+
+        // Overload of `string_view::find()` for finding a substring of a different
+        // C-style string `s` within the `string_view`.
+        size_type find(const char* s, size_type pos, size_type count) const
+        {
+            return find(string_view(s, count), pos);
+        }
+
+        // Overload of `string_view::find()` for finding a different C-style string
+        // `s` within the `string_view`.
+        size_type find(const char* s, size_type pos = 0) const
+        {
+            return find(string_view(s), pos);
+        }
+
+        // string_view::rfind()
+        //
+        // Finds the last occurrence of a substring `s` within the `string_view`,
+        // returning the position of the first character's match, or `npos` if no
+        // match was found.
+        size_type rfind(string_view s, size_type pos = npos) const noexcept;
+
+        // Overload of `string_view::rfind()` for finding the last given character `c`
+        // within the `string_view`.
+        size_type rfind(char c, size_type pos = npos) const noexcept;
+
+        // Overload of `string_view::rfind()` for finding a substring of a different
+        // C-style string `s` within the `string_view`.
+        size_type rfind(const char* s, size_type pos, size_type count) const
+        {
+            return rfind(string_view(s, count), pos);
+        }
+
+        // Overload of `string_view::rfind()` for finding a different C-style string
+        // `s` within the `string_view`.
+        size_type rfind(const char* s, size_type pos = npos) const
+        {
+            return rfind(string_view(s), pos);
+        }
+
+        // string_view::find_first_of()
+        //
+        // Finds the first occurrence of any of the characters in `s` within the
+        // `string_view`, returning the start position of the match, or `npos` if no
+        // match was found.
+        size_type find_first_of(string_view s, size_type pos = 0) const noexcept;
+
+        // Overload of `string_view::find_first_of()` for finding a character `c`
+        // within the `string_view`.
+        size_type find_first_of(char c, size_type pos = 0) const noexcept
+        {
+            return find(c, pos);
+        }
+
+        // Overload of `string_view::find_first_of()` for finding a substring of a
+        // different C-style string `s` within the `string_view`.
+        size_type find_first_of(const char* s, size_type pos, size_type count) const
+        {
+            return find_first_of(string_view(s, count), pos);
+        }
+
+        // Overload of `string_view::find_first_of()` for finding a different C-style
+        // string `s` within the `string_view`.
+        size_type find_first_of(const char* s, size_type pos = 0) const
+        {
+            return find_first_of(string_view(s), pos);
+        }
+
+        // string_view::find_last_of()
+        //
+        // Finds the last occurrence of any of the characters in `s` within the
+        // `string_view`, returning the start position of the match, or `npos` if no
+        // match was found.
+        size_type find_last_of(string_view s, size_type pos = npos) const noexcept;
+
+        // Overload of `string_view::find_last_of()` for finding a character `c`
+        // within the `string_view`.
+        size_type find_last_of(char c, size_type pos = npos) const noexcept
+        {
+            return rfind(c, pos);
+        }
+
+        // Overload of `string_view::find_last_of()` for finding a substring of a
+        // different C-style string `s` within the `string_view`.
+        size_type find_last_of(const char* s, size_type pos, size_type count) const
+        {
+            return find_last_of(string_view(s, count), pos);
+        }
+
+        // Overload of `string_view::find_last_of()` for finding a different C-style
+        // string `s` within the `string_view`.
+        size_type find_last_of(const char* s, size_type pos = npos) const
+        {
+            return find_last_of(string_view(s), pos);
+        }
+
+        // string_view::find_first_not_of()
+        //
+        // Finds the first occurrence of any of the characters not in `s` within the
+        // `string_view`, returning the start position of the first non-match, or
+        // `npos` if no non-match was found.
+        size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;
+
+        // Overload of `string_view::find_first_not_of()` for finding a character
+        // that is not `c` within the `string_view`.
+        size_type find_first_not_of(char c, size_type pos = 0) const noexcept;
+
+        // Overload of `string_view::find_first_not_of()` for finding a substring of a
+        // different C-style string `s` within the `string_view`.
+        size_type find_first_not_of(const char* s, size_type pos, size_type count) const
+        {
+            return find_first_not_of(string_view(s, count), pos);
+        }
+
+        // Overload of `string_view::find_first_not_of()` for finding a different
+        // C-style string `s` within the `string_view`.
+        size_type find_first_not_of(const char* s, size_type pos = 0) const
+        {
+            return find_first_not_of(string_view(s), pos);
+        }
+
+        // string_view::find_last_not_of()
+        //
+        // Finds the last occurrence of any of the characters not in `s` within the
+        // `string_view`, returning the start position of the last non-match, or
+        // `npos` if no non-match was found.
+        size_type find_last_not_of(string_view s, size_type pos = npos) const noexcept;
+
+        // Overload of `string_view::find_last_not_of()` for finding a character
+        // that is not `c` within the `string_view`.
+        size_type find_last_not_of(char c, size_type pos = npos) const noexcept;
+
+        // Overload of `string_view::find_last_not_of()` for finding a substring of a
+        // different C-style string `s` within the `string_view`.
+        size_type find_last_not_of(const char* s, size_type pos, size_type count) const
+        {
+            return find_last_not_of(string_view(s, count), pos);
+        }
+
+        // Overload of `string_view::find_last_not_of()` for finding a different
+        // C-style string `s` within the `string_view`.
+        size_type find_last_not_of(const char* s, size_type pos = npos) const
+        {
+            return find_last_not_of(string_view(s), pos);
+        }
+
+    private:
+        // The constructor from std::string delegates to this constructor.
+        // See the comment on that constructor for the rationale.
+        struct SkipCheckLengthTag
+        {
+        };
+        string_view(const char* data, size_type len, SkipCheckLengthTag) noexcept
+            :
+            ptr_(data),
+            length_(len)
+        {
+        }
+
+        static constexpr size_type kMaxSize =
+            (std::numeric_limits<difference_type>::max)();
+
+        static constexpr size_type CheckLengthInternal(size_type len)
+        {
+            return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
+        }
+
+        static constexpr size_type StrlenInternal(const char* str)
+        {
 #if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__)
-    // MSVC 2017+ can evaluate this at compile-time.
-    const char* begin = str;
-    while (*str != '\0') ++str;
-    return str - begin;
+            // MSVC 2017+ can evaluate this at compile-time.
+            const char* begin = str;
+            while (*str != '\0')
+                ++str;
+            return str - begin;
 #elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
     (defined(__GNUC__) && !defined(__clang__))
-    // GCC has __builtin_strlen according to
-    // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
-    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
-    // __builtin_strlen is constexpr.
-    return __builtin_strlen(str);
+            // GCC has __builtin_strlen according to
+            // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
+            // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
+            // __builtin_strlen is constexpr.
+            return __builtin_strlen(str);
 #else
-    return str ? strlen(str) : 0;
+            return str ? strlen(str) : 0;
 #endif
-  }
-
-  static constexpr size_t Min(size_type length_a, size_type length_b) {
-    return length_a < length_b ? length_a : length_b;
-  }
-
-  static constexpr int CompareImpl(size_type length_a, size_type length_b,
-                                   int compare_result) {
-    return compare_result == 0 ? static_cast<int>(length_a > length_b) -
-                                     static_cast<int>(length_a < length_b)
-                               : (compare_result < 0 ? -1 : 1);
-  }
-
-  const char* ptr_;
-  size_type length_;
-};
-
-// This large function is defined inline so that in a fairly common case where
-// one of the arguments is a literal, the compiler can elide a lot of the
-// following comparisons.
-constexpr bool operator==(string_view x, string_view y) noexcept {
-  return x.size() == y.size() &&
-         (x.empty() ||
-          ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
-}
-
-constexpr bool operator!=(string_view x, string_view y) noexcept {
-  return !(x == y);
-}
-
-constexpr bool operator<(string_view x, string_view y) noexcept {
-  return x.compare(y) < 0;
-}
-
-constexpr bool operator>(string_view x, string_view y) noexcept {
-  return y < x;
-}
-
-constexpr bool operator<=(string_view x, string_view y) noexcept {
-  return !(y < x);
-}
-
-constexpr bool operator>=(string_view x, string_view y) noexcept {
-  return !(x < y);
-}
-
-// IO Insertion Operator
-std::ostream& operator<<(std::ostream& o, string_view piece);
-
-ABSL_NAMESPACE_END
+        }
+
+        static constexpr size_t Min(size_type length_a, size_type length_b)
+        {
+            return length_a < length_b ? length_a : length_b;
+        }
+
+        static constexpr int CompareImpl(size_type length_a, size_type length_b, int compare_result)
+        {
+            return compare_result == 0 ? static_cast<int>(length_a > length_b) -
+                                             static_cast<int>(length_a < length_b) :
+                                         (compare_result < 0 ? -1 : 1);
+        }
+
+        const char* ptr_;
+        size_type length_;
+    };
+
+    // This large function is defined inline so that in a fairly common case where
+    // one of the arguments is a literal, the compiler can elide a lot of the
+    // following comparisons.
+    constexpr bool operator==(string_view x, string_view y) noexcept
+    {
+        return x.size() == y.size() &&
+               (x.empty() ||
+                ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
+    }
+
+    constexpr bool operator!=(string_view x, string_view y) noexcept
+    {
+        return !(x == y);
+    }
+
+    constexpr bool operator<(string_view x, string_view y) noexcept
+    {
+        return x.compare(y) < 0;
+    }
+
+    constexpr bool operator>(string_view x, string_view y) noexcept
+    {
+        return y < x;
+    }
+
+    constexpr bool operator<=(string_view x, string_view y) noexcept
+    {
+        return !(y < x);
+    }
+
+    constexpr bool operator>=(string_view x, string_view y) noexcept
+    {
+        return !(x < y);
+    }
+
+    // IO Insertion Operator
+    std::ostream& operator<<(std::ostream& o, string_view piece);
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #undef ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
@@ -683,29 +773,31 @@ ABSL_NAMESPACE_END
 
 #endif  // ABSL_USES_STD_STRING_VIEW
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // ClippedSubstr()
+    //
+    // Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
+    // Provided because std::string_view::substr throws if `pos > size()`
+    inline string_view ClippedSubstr(string_view s, size_t pos, size_t n = string_view::npos)
+    {
+        pos = (std::min)(pos, static_cast<size_t>(s.size()));
+        return s.substr(pos, n);
+    }
 
-// ClippedSubstr()
-//
-// Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
-// Provided because std::string_view::substr throws if `pos > size()`
-inline string_view ClippedSubstr(string_view s, size_t pos,
-                                 size_t n = string_view::npos) {
-  pos = (std::min)(pos, static_cast<size_t>(s.size()));
-  return s.substr(pos, n);
-}
-
-// NullSafeStringView()
-//
-// Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
-// This function should be used where an `absl::string_view` can be created from
-// a possibly-null pointer.
-constexpr string_view NullSafeStringView(const char* p) {
-  return p ? string_view(p) : string_view();
-}
-
-ABSL_NAMESPACE_END
+    // NullSafeStringView()
+    //
+    // Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
+    // This function should be used where an `absl::string_view` can be created from
+    // a possibly-null pointer.
+    constexpr string_view NullSafeStringView(const char* p)
+    {
+        return p ? string_view(p) : string_view();
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_STRING_VIEW_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/strip.h b/CAPI/cpp/grpc/include/absl/strings/strip.h
index 341e66f..a643aef 100644
--- a/CAPI/cpp/grpc/include/absl/strings/strip.h
+++ b/CAPI/cpp/grpc/include/absl/strings/strip.h
@@ -29,65 +29,76 @@
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// ConsumePrefix()
-//
-// Strips the `expected` prefix, if found, from the start of `str`.
-// If the operation succeeded, `true` is returned.  If not, `false`
-// is returned and `str` is not modified.
-//
-// Example:
-//
-//   absl::string_view input("abc");
-//   EXPECT_TRUE(absl::ConsumePrefix(&input, "a"));
-//   EXPECT_EQ(input, "bc");
-inline bool ConsumePrefix(absl::string_view* str, absl::string_view expected) {
-  if (!absl::StartsWith(*str, expected)) return false;
-  str->remove_prefix(expected.size());
-  return true;
-}
-// ConsumeSuffix()
-//
-// Strips the `expected` suffix, if found, from the end of `str`.
-// If the operation succeeded, `true` is returned.  If not, `false`
-// is returned and `str` is not modified.
-//
-// Example:
-//
-//   absl::string_view input("abcdef");
-//   EXPECT_TRUE(absl::ConsumeSuffix(&input, "def"));
-//   EXPECT_EQ(input, "abc");
-inline bool ConsumeSuffix(absl::string_view* str, absl::string_view expected) {
-  if (!absl::EndsWith(*str, expected)) return false;
-  str->remove_suffix(expected.size());
-  return true;
-}
+    // ConsumePrefix()
+    //
+    // Strips the `expected` prefix, if found, from the start of `str`.
+    // If the operation succeeded, `true` is returned.  If not, `false`
+    // is returned and `str` is not modified.
+    //
+    // Example:
+    //
+    //   absl::string_view input("abc");
+    //   EXPECT_TRUE(absl::ConsumePrefix(&input, "a"));
+    //   EXPECT_EQ(input, "bc");
+    inline bool ConsumePrefix(absl::string_view* str, absl::string_view expected)
+    {
+        if (!absl::StartsWith(*str, expected))
+            return false;
+        str->remove_prefix(expected.size());
+        return true;
+    }
+    // ConsumeSuffix()
+    //
+    // Strips the `expected` suffix, if found, from the end of `str`.
+    // If the operation succeeded, `true` is returned.  If not, `false`
+    // is returned and `str` is not modified.
+    //
+    // Example:
+    //
+    //   absl::string_view input("abcdef");
+    //   EXPECT_TRUE(absl::ConsumeSuffix(&input, "def"));
+    //   EXPECT_EQ(input, "abc");
+    inline bool ConsumeSuffix(absl::string_view* str, absl::string_view expected)
+    {
+        if (!absl::EndsWith(*str, expected))
+            return false;
+        str->remove_suffix(expected.size());
+        return true;
+    }
 
-// StripPrefix()
-//
-// Returns a view into the input string `str` with the given `prefix` removed,
-// but leaving the original string intact. If the prefix does not match at the
-// start of the string, returns the original string instead.
-ABSL_MUST_USE_RESULT inline absl::string_view StripPrefix(
-    absl::string_view str, absl::string_view prefix) {
-  if (absl::StartsWith(str, prefix)) str.remove_prefix(prefix.size());
-  return str;
-}
+    // StripPrefix()
+    //
+    // Returns a view into the input string `str` with the given `prefix` removed,
+    // but leaving the original string intact. If the prefix does not match at the
+    // start of the string, returns the original string instead.
+    ABSL_MUST_USE_RESULT inline absl::string_view StripPrefix(
+        absl::string_view str, absl::string_view prefix
+    )
+    {
+        if (absl::StartsWith(str, prefix))
+            str.remove_prefix(prefix.size());
+        return str;
+    }
 
-// StripSuffix()
-//
-// Returns a view into the input string `str` with the given `suffix` removed,
-// but leaving the original string intact. If the suffix does not match at the
-// end of the string, returns the original string instead.
-ABSL_MUST_USE_RESULT inline absl::string_view StripSuffix(
-    absl::string_view str, absl::string_view suffix) {
-  if (absl::EndsWith(str, suffix)) str.remove_suffix(suffix.size());
-  return str;
-}
+    // StripSuffix()
+    //
+    // Returns a view into the input string `str` with the given `suffix` removed,
+    // but leaving the original string intact. If the suffix does not match at the
+    // end of the string, returns the original string instead.
+    ABSL_MUST_USE_RESULT inline absl::string_view StripSuffix(
+        absl::string_view str, absl::string_view suffix
+    )
+    {
+        if (absl::EndsWith(str, suffix))
+            str.remove_suffix(suffix.size());
+        return str;
+    }
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_STRIP_H_
diff --git a/CAPI/cpp/grpc/include/absl/strings/substitute.h b/CAPI/cpp/grpc/include/absl/strings/substitute.h
index 6d2b08a..d182c08 100644
--- a/CAPI/cpp/grpc/include/absl/strings/substitute.h
+++ b/CAPI/cpp/grpc/include/absl/strings/substitute.h
@@ -85,645 +85,580 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace substitute_internal {
-
-// Arg
-//
-// This class provides an argument type for `absl::Substitute()` and
-// `absl::SubstituteAndAppend()`. `Arg` handles implicit conversion of various
-// types to a string. (`Arg` is very similar to the `AlphaNum` class in
-// `StrCat()`.)
-//
-// This class has implicit constructors.
-class Arg {
- public:
-  // Overloads for string-y things
-  //
-  // Explicitly overload `const char*` so the compiler doesn't cast to `bool`.
-  Arg(const char* value)  // NOLINT(runtime/explicit)
-      : piece_(absl::NullSafeStringView(value)) {}
-  template <typename Allocator>
-  Arg(  // NOLINT
-      const std::basic_string<char, std::char_traits<char>, Allocator>&
-          value) noexcept
-      : piece_(value) {}
-  Arg(absl::string_view value)  // NOLINT(runtime/explicit)
-      : piece_(value) {}
-
-  // Overloads for primitives
-  //
-  // No overloads are available for signed and unsigned char because if people
-  // are explicitly declaring their chars as signed or unsigned then they are
-  // probably using them as 8-bit integers and would probably prefer an integer
-  // representation. However, we can't really know, so we make the caller decide
-  // what to do.
-  Arg(char value)  // NOLINT(runtime/explicit)
-      : piece_(scratch_, 1) {
-    scratch_[0] = value;
-  }
-  Arg(short value)  // NOLINT(*)
-      : piece_(scratch_,
-               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
-  Arg(unsigned short value)  // NOLINT(*)
-      : piece_(scratch_,
-               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
-  Arg(int value)  // NOLINT(runtime/explicit)
-      : piece_(scratch_,
-               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
-  Arg(unsigned int value)  // NOLINT(runtime/explicit)
-      : piece_(scratch_,
-               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
-  Arg(long value)  // NOLINT(*)
-      : piece_(scratch_,
-               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
-  Arg(unsigned long value)  // NOLINT(*)
-      : piece_(scratch_,
-               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
-  Arg(long long value)  // NOLINT(*)
-      : piece_(scratch_,
-               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
-  Arg(unsigned long long value)  // NOLINT(*)
-      : piece_(scratch_,
-               numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
-  Arg(float value)  // NOLINT(runtime/explicit)
-      : piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
-  }
-  Arg(double value)  // NOLINT(runtime/explicit)
-      : piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
-  }
-  Arg(bool value)  // NOLINT(runtime/explicit)
-      : piece_(value ? "true" : "false") {}
-
-  Arg(Hex hex);  // NOLINT(runtime/explicit)
-  Arg(Dec dec);  // NOLINT(runtime/explicit)
-
-  // vector<bool>::reference and const_reference require special help to convert
-  // to `Arg` because it requires two user defined conversions.
-  template <typename T,
-            absl::enable_if_t<
-                std::is_class<T>::value &&
-                (std::is_same<T, std::vector<bool>::reference>::value ||
-                 std::is_same<T, std::vector<bool>::const_reference>::value)>* =
-                nullptr>
-  Arg(T value)  // NOLINT(google-explicit-constructor)
-      : Arg(static_cast<bool>(value)) {}
-
-  // `void*` values, with the exception of `char*`, are printed as
-  // "0x<hex value>". However, in the case of `nullptr`, "NULL" is printed.
-  Arg(const void* value);  // NOLINT(runtime/explicit)
-
-  // Normal enums are already handled by the integer formatters.
-  // This overload matches only scoped enums.
-  template <typename T,
-            typename = typename std::enable_if<
-                std::is_enum<T>{} && !std::is_convertible<T, int>{}>::type>
-  Arg(T value)  // NOLINT(google-explicit-constructor)
-      : Arg(static_cast<typename std::underlying_type<T>::type>(value)) {}
-
-  Arg(const Arg&) = delete;
-  Arg& operator=(const Arg&) = delete;
-
-  absl::string_view piece() const { return piece_; }
-
- private:
-  absl::string_view piece_;
-  char scratch_[numbers_internal::kFastToBufferSize];
-};
-
-// Internal helper function. Don't call this from outside this implementation.
-// This interface may change without notice.
-void SubstituteAndAppendArray(std::string* output, absl::string_view format,
-                              const absl::string_view* args_array,
-                              size_t num_args);
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace substitute_internal
+    {
+
+        // Arg
+        //
+        // This class provides an argument type for `absl::Substitute()` and
+        // `absl::SubstituteAndAppend()`. `Arg` handles implicit conversion of various
+        // types to a string. (`Arg` is very similar to the `AlphaNum` class in
+        // `StrCat()`.)
+        //
+        // This class has implicit constructors.
+        class Arg
+        {
+        public:
+            // Overloads for string-y things
+            //
+            // Explicitly overload `const char*` so the compiler doesn't cast to `bool`.
+            Arg(const char* value)  // NOLINT(runtime/explicit)
+                :
+                piece_(absl::NullSafeStringView(value))
+            {
+            }
+            template<typename Allocator>
+            Arg(  // NOLINT
+                const std::basic_string<char, std::char_traits<char>, Allocator>&
+                    value
+            ) noexcept
+                :
+                piece_(value)
+            {
+            }
+            Arg(absl::string_view value)  // NOLINT(runtime/explicit)
+                :
+                piece_(value)
+            {
+            }
+
+            // Overloads for primitives
+            //
+            // No overloads are available for signed and unsigned char because if people
+            // are explicitly declaring their chars as signed or unsigned then they are
+            // probably using them as 8-bit integers and would probably prefer an integer
+            // representation. However, we can't really know, so we make the caller decide
+            // what to do.
+            Arg(char value)  // NOLINT(runtime/explicit)
+                :
+                piece_(scratch_, 1)
+            {
+                scratch_[0] = value;
+            }
+            Arg(short value)  // NOLINT(*)
+                :
+                piece_(scratch_, numbers_internal::FastIntToBuffer(value, scratch_) - scratch_)
+            {
+            }
+            Arg(unsigned short value)  // NOLINT(*)
+                :
+                piece_(scratch_, numbers_internal::FastIntToBuffer(value, scratch_) - scratch_)
+            {
+            }
+            Arg(int value)  // NOLINT(runtime/explicit)
+                :
+                piece_(scratch_, numbers_internal::FastIntToBuffer(value, scratch_) - scratch_)
+            {
+            }
+            Arg(unsigned int value)  // NOLINT(runtime/explicit)
+                :
+                piece_(scratch_, numbers_internal::FastIntToBuffer(value, scratch_) - scratch_)
+            {
+            }
+            Arg(long value)  // NOLINT(*)
+                :
+                piece_(scratch_, numbers_internal::FastIntToBuffer(value, scratch_) - scratch_)
+            {
+            }
+            Arg(unsigned long value)  // NOLINT(*)
+                :
+                piece_(scratch_, numbers_internal::FastIntToBuffer(value, scratch_) - scratch_)
+            {
+            }
+            Arg(long long value)  // NOLINT(*)
+                :
+                piece_(scratch_, numbers_internal::FastIntToBuffer(value, scratch_) - scratch_)
+            {
+            }
+            Arg(unsigned long long value)  // NOLINT(*)
+                :
+                piece_(scratch_, numbers_internal::FastIntToBuffer(value, scratch_) - scratch_)
+            {
+            }
+            Arg(float value)  // NOLINT(runtime/explicit)
+                :
+                piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_))
+            {
+            }
+            Arg(double value)  // NOLINT(runtime/explicit)
+                :
+                piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_))
+            {
+            }
+            Arg(bool value)  // NOLINT(runtime/explicit)
+                :
+                piece_(value ? "true" : "false")
+            {
+            }
+
+            Arg(Hex hex);  // NOLINT(runtime/explicit)
+            Arg(Dec dec);  // NOLINT(runtime/explicit)
+
+            // vector<bool>::reference and const_reference require special help to convert
+            // to `Arg` because it requires two user defined conversions.
+            template<typename T, absl::enable_if_t<std::is_class<T>::value && (std::is_same<T, std::vector<bool>::reference>::value || std::is_same<T, std::vector<bool>::const_reference>::value)>* = nullptr>
+            Arg(T value)  // NOLINT(google-explicit-constructor)
+                :
+                Arg(static_cast<bool>(value))
+            {
+            }
+
+            // `void*` values, with the exception of `char*`, are printed as
+            // "0x<hex value>". However, in the case of `nullptr`, "NULL" is printed.
+            Arg(const void* value);  // NOLINT(runtime/explicit)
+
+            // Normal enums are already handled by the integer formatters.
+            // This overload matches only scoped enums.
+            template<typename T, typename = typename std::enable_if<std::is_enum<T>{} && !std::is_convertible<T, int>{}>::type>
+            Arg(T value)  // NOLINT(google-explicit-constructor)
+                :
+                Arg(static_cast<typename std::underlying_type<T>::type>(value))
+            {
+            }
+
+            Arg(const Arg&) = delete;
+            Arg& operator=(const Arg&) = delete;
+
+            absl::string_view piece() const
+            {
+                return piece_;
+            }
+
+        private:
+            absl::string_view piece_;
+            char scratch_[numbers_internal::kFastToBufferSize];
+        };
+
+        // Internal helper function. Don't call this from outside this implementation.
+        // This interface may change without notice.
+        void SubstituteAndAppendArray(std::string* output, absl::string_view format, const absl::string_view* args_array, size_t num_args);
 
 #if defined(ABSL_BAD_CALL_IF)
-constexpr int CalculateOneBit(const char* format) {
-  // Returns:
-  // * 2^N for '$N' when N is in [0-9]
-  // * 0 for correct '$' escaping: '$$'.
-  // * -1 otherwise.
-  return (*format < '0' || *format > '9') ? (*format == '$' ? 0 : -1)
-                                          : (1 << (*format - '0'));
-}
-
-constexpr const char* SkipNumber(const char* format) {
-  return !*format ? format : (format + 1);
-}
-
-constexpr int PlaceholderBitmask(const char* format) {
-  return !*format
-             ? 0
-             : *format != '$' ? PlaceholderBitmask(format + 1)
-                              : (CalculateOneBit(format + 1) |
-                                 PlaceholderBitmask(SkipNumber(format + 1)));
-}
+        constexpr int CalculateOneBit(const char* format)
+        {
+            // Returns:
+            // * 2^N for '$N' when N is in [0-9]
+            // * 0 for correct '$' escaping: '$$'.
+            // * -1 otherwise.
+            return (*format < '0' || *format > '9') ? (*format == '$' ? 0 : -1) : (1 << (*format - '0'));
+        }
+
+        constexpr const char* SkipNumber(const char* format)
+        {
+            return !*format ? format : (format + 1);
+        }
+
+        constexpr int PlaceholderBitmask(const char* format)
+        {
+            return !*format ? 0 : *format != '$' ? PlaceholderBitmask(format + 1) :
+                                                   (CalculateOneBit(format + 1) | PlaceholderBitmask(SkipNumber(format + 1)));
+        }
 #endif  // ABSL_BAD_CALL_IF
 
-}  // namespace substitute_internal
-
-//
-// PUBLIC API
-//
-
-// SubstituteAndAppend()
-//
-// Substitutes variables into a given format string and appends to a given
-// output string. See file comments above for usage.
-//
-// The declarations of `SubstituteAndAppend()` below consist of overloads
-// for passing 0 to 10 arguments, respectively.
-//
-// NOTE: A zero-argument `SubstituteAndAppend()` may be used within variadic
-// templates to allow a variable number of arguments.
-//
-// Example:
-//  template <typename... Args>
-//  void VarMsg(std::string* boilerplate, absl::string_view format,
-//      const Args&... args) {
-//    absl::SubstituteAndAppend(boilerplate, format, args...);
-//  }
-//
-inline void SubstituteAndAppend(std::string* output, absl::string_view format) {
-  substitute_internal::SubstituteAndAppendArray(output, format, nullptr, 0);
-}
-
-inline void SubstituteAndAppend(std::string* output, absl::string_view format,
-                                const substitute_internal::Arg& a0) {
-  const absl::string_view args[] = {a0.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(std::string* output, absl::string_view format,
-                                const substitute_internal::Arg& a0,
-                                const substitute_internal::Arg& a1) {
-  const absl::string_view args[] = {a0.piece(), a1.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(std::string* output, absl::string_view format,
-                                const substitute_internal::Arg& a0,
-                                const substitute_internal::Arg& a1,
-                                const substitute_internal::Arg& a2) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(std::string* output, absl::string_view format,
-                                const substitute_internal::Arg& a0,
-                                const substitute_internal::Arg& a1,
-                                const substitute_internal::Arg& a2,
-                                const substitute_internal::Arg& a3) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(std::string* output, absl::string_view format,
-                                const substitute_internal::Arg& a0,
-                                const substitute_internal::Arg& a1,
-                                const substitute_internal::Arg& a2,
-                                const substitute_internal::Arg& a3,
-                                const substitute_internal::Arg& a4) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(std::string* output, absl::string_view format,
-                                const substitute_internal::Arg& a0,
-                                const substitute_internal::Arg& a1,
-                                const substitute_internal::Arg& a2,
-                                const substitute_internal::Arg& a3,
-                                const substitute_internal::Arg& a4,
-                                const substitute_internal::Arg& a5) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece(), a5.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(std::string* output, absl::string_view format,
-                                const substitute_internal::Arg& a0,
-                                const substitute_internal::Arg& a1,
-                                const substitute_internal::Arg& a2,
-                                const substitute_internal::Arg& a3,
-                                const substitute_internal::Arg& a4,
-                                const substitute_internal::Arg& a5,
-                                const substitute_internal::Arg& a6) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece(), a5.piece(),
-                                    a6.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(
-    std::string* output, absl::string_view format,
-    const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
-    const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
-    const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
-    const substitute_internal::Arg& a6, const substitute_internal::Arg& a7) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece(), a5.piece(),
-                                    a6.piece(), a7.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(
-    std::string* output, absl::string_view format,
-    const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
-    const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
-    const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
-    const substitute_internal::Arg& a6, const substitute_internal::Arg& a7,
-    const substitute_internal::Arg& a8) {
-  const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
-                                    a3.piece(), a4.piece(), a5.piece(),
-                                    a6.piece(), a7.piece(), a8.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
-
-inline void SubstituteAndAppend(
-    std::string* output, absl::string_view format,
-    const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
-    const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
-    const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
-    const substitute_internal::Arg& a6, const substitute_internal::Arg& a7,
-    const substitute_internal::Arg& a8, const substitute_internal::Arg& a9) {
-  const absl::string_view args[] = {
-      a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(),
-      a5.piece(), a6.piece(), a7.piece(), a8.piece(), a9.piece()};
-  substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
-}
+    }  // namespace substitute_internal
+
+    //
+    // PUBLIC API
+    //
+
+    // SubstituteAndAppend()
+    //
+    // Substitutes variables into a given format string and appends to a given
+    // output string. See file comments above for usage.
+    //
+    // The declarations of `SubstituteAndAppend()` below consist of overloads
+    // for passing 0 to 10 arguments, respectively.
+    //
+    // NOTE: A zero-argument `SubstituteAndAppend()` may be used within variadic
+    // templates to allow a variable number of arguments.
+    //
+    // Example:
+    //  template <typename... Args>
+    //  void VarMsg(std::string* boilerplate, absl::string_view format,
+    //      const Args&... args) {
+    //    absl::SubstituteAndAppend(boilerplate, format, args...);
+    //  }
+    //
+    inline void SubstituteAndAppend(std::string* output, absl::string_view format)
+    {
+        substitute_internal::SubstituteAndAppendArray(output, format, nullptr, 0);
+    }
+
+    inline void SubstituteAndAppend(std::string* output, absl::string_view format, const substitute_internal::Arg& a0)
+    {
+        const absl::string_view args[] = {a0.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1)
+    {
+        const absl::string_view args[] = {a0.piece(), a1.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2)
+    {
+        const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3)
+    {
+        const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4)
+    {
+        const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5)
+    {
+        const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6)
+    {
+        const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece(), a6.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(
+        std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7
+    )
+    {
+        const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece(), a6.piece(), a7.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(
+        std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8
+    )
+    {
+        const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece(), a6.piece(), a7.piece(), a8.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
+
+    inline void SubstituteAndAppend(
+        std::string* output, absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8, const substitute_internal::Arg& a9
+    )
+    {
+        const absl::string_view args[] = {
+            a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(), a5.piece(), a6.piece(), a7.piece(), a8.piece(), a9.piece()};
+        substitute_internal::SubstituteAndAppendArray(output, format, args, ABSL_ARRAYSIZE(args));
+    }
 
 #if defined(ABSL_BAD_CALL_IF)
-// This body of functions catches cases where the number of placeholders
-// doesn't match the number of data arguments.
-void SubstituteAndAppend(std::string* output, const char* format)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 0,
-        "There were no substitution arguments "
-        "but this format string either has a $[0-9] in it or contains "
-        "an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(std::string* output, const char* format,
-                         const substitute_internal::Arg& a0)
-    ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1,
-                     "There was 1 substitution argument given, but "
-                     "this format string is missing its $0, contains "
-                     "one of $1-$9, or contains an unescaped $ character (use "
-                     "$$ instead)");
-
-void SubstituteAndAppend(std::string* output, const char* format,
-                         const substitute_internal::Arg& a0,
-                         const substitute_internal::Arg& a1)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 3,
-        "There were 2 substitution arguments given, but this format string is "
-        "missing its $0/$1, contains one of $2-$9, or contains an "
-        "unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(std::string* output, const char* format,
-                         const substitute_internal::Arg& a0,
-                         const substitute_internal::Arg& a1,
-                         const substitute_internal::Arg& a2)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 7,
-        "There were 3 substitution arguments given, but "
-        "this format string is missing its $0/$1/$2, contains one of "
-        "$3-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(std::string* output, const char* format,
-                         const substitute_internal::Arg& a0,
-                         const substitute_internal::Arg& a1,
-                         const substitute_internal::Arg& a2,
-                         const substitute_internal::Arg& a3)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 15,
-        "There were 4 substitution arguments given, but "
-        "this format string is missing its $0-$3, contains one of "
-        "$4-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(std::string* output, const char* format,
-                         const substitute_internal::Arg& a0,
-                         const substitute_internal::Arg& a1,
-                         const substitute_internal::Arg& a2,
-                         const substitute_internal::Arg& a3,
-                         const substitute_internal::Arg& a4)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 31,
-        "There were 5 substitution arguments given, but "
-        "this format string is missing its $0-$4, contains one of "
-        "$5-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(std::string* output, const char* format,
-                         const substitute_internal::Arg& a0,
-                         const substitute_internal::Arg& a1,
-                         const substitute_internal::Arg& a2,
-                         const substitute_internal::Arg& a3,
-                         const substitute_internal::Arg& a4,
-                         const substitute_internal::Arg& a5)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 63,
-        "There were 6 substitution arguments given, but "
-        "this format string is missing its $0-$5, contains one of "
-        "$6-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    std::string* output, const char* format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 127,
-        "There were 7 substitution arguments given, but "
-        "this format string is missing its $0-$6, contains one of "
-        "$7-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    std::string* output, const char* format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
-    const substitute_internal::Arg& a7)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 255,
-        "There were 8 substitution arguments given, but "
-        "this format string is missing its $0-$7, contains one of "
-        "$8-$9, or contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    std::string* output, const char* format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
-    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 511,
-        "There were 9 substitution arguments given, but "
-        "this format string is missing its $0-$8, contains a $9, or "
-        "contains an unescaped $ character (use $$ instead)");
-
-void SubstituteAndAppend(
-    std::string* output, const char* format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
-    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
-    const substitute_internal::Arg& a9)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 1023,
-        "There were 10 substitution arguments given, but this "
-        "format string either doesn't contain all of $0 through $9 or "
-        "contains an unescaped $ character (use $$ instead)");
+    // This body of functions catches cases where the number of placeholders
+    // doesn't match the number of data arguments.
+    void SubstituteAndAppend(std::string* output, const char* format)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 0,
+            "There were no substitution arguments "
+            "but this format string either has a $[0-9] in it or contains "
+            "an unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(std::string* output, const char* format, const substitute_internal::Arg& a0)
+        ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1, "There was 1 substitution argument given, but "
+                                                                               "this format string is missing its $0, contains "
+                                                                               "one of $1-$9, or contains an unescaped $ character (use "
+                                                                               "$$ instead)");
+
+    void SubstituteAndAppend(std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 3,
+            "There were 2 substitution arguments given, but this format string is "
+            "missing its $0/$1, contains one of $2-$9, or contains an "
+            "unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 7,
+            "There were 3 substitution arguments given, but "
+            "this format string is missing its $0/$1/$2, contains one of "
+            "$3-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 15,
+            "There were 4 substitution arguments given, but "
+            "this format string is missing its $0-$3, contains one of "
+            "$4-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 31,
+            "There were 5 substitution arguments given, but "
+            "this format string is missing its $0-$4, contains one of "
+            "$5-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 63,
+            "There were 6 substitution arguments given, but "
+            "this format string is missing its $0-$5, contains one of "
+            "$6-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(
+        std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6
+    )
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 127,
+            "There were 7 substitution arguments given, but "
+            "this format string is missing its $0-$6, contains one of "
+            "$7-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(
+        std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7
+    )
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 255,
+            "There were 8 substitution arguments given, but "
+            "this format string is missing its $0-$7, contains one of "
+            "$8-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(
+        std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8
+    )
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 511,
+            "There were 9 substitution arguments given, but "
+            "this format string is missing its $0-$8, contains a $9, or "
+            "contains an unescaped $ character (use $$ instead)"
+        );
+
+    void SubstituteAndAppend(
+        std::string* output, const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8, const substitute_internal::Arg& a9
+    )
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 1023,
+            "There were 10 substitution arguments given, but this "
+            "format string either doesn't contain all of $0 through $9 or "
+            "contains an unescaped $ character (use $$ instead)"
+        );
 #endif  // ABSL_BAD_CALL_IF
 
-// Substitute()
-//
-// Substitutes variables into a given format string. See file comments above
-// for usage.
-//
-// The declarations of `Substitute()` below consist of overloads for passing 0
-// to 10 arguments, respectively.
-//
-// NOTE: A zero-argument `Substitute()` may be used within variadic templates to
-// allow a variable number of arguments.
-//
-// Example:
-//  template <typename... Args>
-//  void VarMsg(absl::string_view format, const Args&... args) {
-//    std::string s = absl::Substitute(format, args...);
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(absl::string_view format) {
-  std::string result;
-  SubstituteAndAppend(&result, format);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
-    const substitute_internal::Arg& a7) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
-    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8);
-  return result;
-}
-
-ABSL_MUST_USE_RESULT inline std::string Substitute(
-    absl::string_view format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
-    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
-    const substitute_internal::Arg& a9) {
-  std::string result;
-  SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
-  return result;
-}
+    // Substitute()
+    //
+    // Substitutes variables into a given format string. See file comments above
+    // for usage.
+    //
+    // The declarations of `Substitute()` below consist of overloads for passing 0
+    // to 10 arguments, respectively.
+    //
+    // NOTE: A zero-argument `Substitute()` may be used within variadic templates to
+    // allow a variable number of arguments.
+    //
+    // Example:
+    //  template <typename... Args>
+    //  void VarMsg(absl::string_view format, const Args&... args) {
+    //    std::string s = absl::Substitute(format, args...);
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(absl::string_view format)
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1, a2);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1, a2, a3);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8);
+        return result;
+    }
+
+    ABSL_MUST_USE_RESULT inline std::string Substitute(
+        absl::string_view format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8, const substitute_internal::Arg& a9
+    )
+    {
+        std::string result;
+        SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        return result;
+    }
 
 #if defined(ABSL_BAD_CALL_IF)
-// This body of functions catches cases where the number of placeholders
-// doesn't match the number of data arguments.
-std::string Substitute(const char* format)
-    ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0,
-                     "There were no substitution arguments "
-                     "but this format string either has a $[0-9] in it or "
-                     "contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(const char* format, const substitute_internal::Arg& a0)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 1,
-        "There was 1 substitution argument given, but "
-        "this format string is missing its $0, contains one of $1-$9, "
-        "or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(const char* format, const substitute_internal::Arg& a0,
-                       const substitute_internal::Arg& a1)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 3,
-        "There were 2 substitution arguments given, but "
-        "this format string is missing its $0/$1, contains one of "
-        "$2-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(const char* format, const substitute_internal::Arg& a0,
-                       const substitute_internal::Arg& a1,
-                       const substitute_internal::Arg& a2)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 7,
-        "There were 3 substitution arguments given, but "
-        "this format string is missing its $0/$1/$2, contains one of "
-        "$3-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(const char* format, const substitute_internal::Arg& a0,
-                       const substitute_internal::Arg& a1,
-                       const substitute_internal::Arg& a2,
-                       const substitute_internal::Arg& a3)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 15,
-        "There were 4 substitution arguments given, but "
-        "this format string is missing its $0-$3, contains one of "
-        "$4-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(const char* format, const substitute_internal::Arg& a0,
-                       const substitute_internal::Arg& a1,
-                       const substitute_internal::Arg& a2,
-                       const substitute_internal::Arg& a3,
-                       const substitute_internal::Arg& a4)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 31,
-        "There were 5 substitution arguments given, but "
-        "this format string is missing its $0-$4, contains one of "
-        "$5-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(const char* format, const substitute_internal::Arg& a0,
-                       const substitute_internal::Arg& a1,
-                       const substitute_internal::Arg& a2,
-                       const substitute_internal::Arg& a3,
-                       const substitute_internal::Arg& a4,
-                       const substitute_internal::Arg& a5)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 63,
-        "There were 6 substitution arguments given, but "
-        "this format string is missing its $0-$5, contains one of "
-        "$6-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(const char* format, const substitute_internal::Arg& a0,
-                       const substitute_internal::Arg& a1,
-                       const substitute_internal::Arg& a2,
-                       const substitute_internal::Arg& a3,
-                       const substitute_internal::Arg& a4,
-                       const substitute_internal::Arg& a5,
-                       const substitute_internal::Arg& a6)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 127,
-        "There were 7 substitution arguments given, but "
-        "this format string is missing its $0-$6, contains one of "
-        "$7-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(const char* format, const substitute_internal::Arg& a0,
-                       const substitute_internal::Arg& a1,
-                       const substitute_internal::Arg& a2,
-                       const substitute_internal::Arg& a3,
-                       const substitute_internal::Arg& a4,
-                       const substitute_internal::Arg& a5,
-                       const substitute_internal::Arg& a6,
-                       const substitute_internal::Arg& a7)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 255,
-        "There were 8 substitution arguments given, but "
-        "this format string is missing its $0-$7, contains one of "
-        "$8-$9, or contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(
-    const char* format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
-    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 511,
-        "There were 9 substitution arguments given, but "
-        "this format string is missing its $0-$8, contains a $9, or "
-        "contains an unescaped $ character (use $$ instead)");
-
-std::string Substitute(
-    const char* format, const substitute_internal::Arg& a0,
-    const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
-    const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
-    const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
-    const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
-    const substitute_internal::Arg& a9)
-    ABSL_BAD_CALL_IF(
-        substitute_internal::PlaceholderBitmask(format) != 1023,
-        "There were 10 substitution arguments given, but this "
-        "format string either doesn't contain all of $0 through $9 or "
-        "contains an unescaped $ character (use $$ instead)");
+    // This body of functions catches cases where the number of placeholders
+    // doesn't match the number of data arguments.
+    std::string Substitute(const char* format)
+        ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0, "There were no substitution arguments "
+                                                                               "but this format string either has a $[0-9] in it or "
+                                                                               "contains an unescaped $ character (use $$ instead)");
+
+    std::string Substitute(const char* format, const substitute_internal::Arg& a0)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 1,
+            "There was 1 substitution argument given, but "
+            "this format string is missing its $0, contains one of $1-$9, "
+            "or contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 3,
+            "There were 2 substitution arguments given, but "
+            "this format string is missing its $0/$1, contains one of "
+            "$2-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 7,
+            "There were 3 substitution arguments given, but "
+            "this format string is missing its $0/$1/$2, contains one of "
+            "$3-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 15,
+            "There were 4 substitution arguments given, but "
+            "this format string is missing its $0-$3, contains one of "
+            "$4-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 31,
+            "There were 5 substitution arguments given, but "
+            "this format string is missing its $0-$4, contains one of "
+            "$5-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 63,
+            "There were 6 substitution arguments given, but "
+            "this format string is missing its $0-$5, contains one of "
+            "$6-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 127,
+            "There were 7 substitution arguments given, but "
+            "this format string is missing its $0-$6, contains one of "
+            "$7-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7)
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 255,
+            "There were 8 substitution arguments given, but "
+            "this format string is missing its $0-$7, contains one of "
+            "$8-$9, or contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(
+        const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8
+    )
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 511,
+            "There were 9 substitution arguments given, but "
+            "this format string is missing its $0-$8, contains a $9, or "
+            "contains an unescaped $ character (use $$ instead)"
+        );
+
+    std::string Substitute(
+        const char* format, const substitute_internal::Arg& a0, const substitute_internal::Arg& a1, const substitute_internal::Arg& a2, const substitute_internal::Arg& a3, const substitute_internal::Arg& a4, const substitute_internal::Arg& a5, const substitute_internal::Arg& a6, const substitute_internal::Arg& a7, const substitute_internal::Arg& a8, const substitute_internal::Arg& a9
+    )
+        ABSL_BAD_CALL_IF(
+            substitute_internal::PlaceholderBitmask(format) != 1023,
+            "There were 10 substitution arguments given, but this "
+            "format string either doesn't contain all of $0 through $9 or "
+            "contains an unescaped $ character (use $$ instead)"
+        );
 #endif  // ABSL_BAD_CALL_IF
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_STRINGS_SUBSTITUTE_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/barrier.h b/CAPI/cpp/grpc/include/absl/synchronization/barrier.h
index d8e7544..b04d6e5 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/barrier.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/barrier.h
@@ -22,58 +22,63 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/synchronization/mutex.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// Barrier
-//
-// This class creates a barrier which blocks threads until a prespecified
-// threshold of threads (`num_threads`) utilizes the barrier. A thread utilizes
-// the `Barrier` by calling `Block()` on the barrier, which will block that
-// thread; no call to `Block()` will return until `num_threads` threads have
-// called it.
-//
-// Exactly one call to `Block()` will return `true`, which is then responsible
-// for destroying the barrier; because stack allocation will cause the barrier
-// to be deleted when it is out of scope, barriers should not be stack
-// allocated.
-//
-// Example:
-//
-//   // Main thread creates a `Barrier`:
-//   barrier = new Barrier(num_threads);
-//
-//   // Each participating thread could then call:
-//   if (barrier->Block()) delete barrier;  // Exactly one call to `Block()`
-//                                          // returns `true`; that call
-//                                          // deletes the barrier.
-class Barrier {
- public:
-  // `num_threads` is the number of threads that will participate in the barrier
-  explicit Barrier(int num_threads)
-      : num_to_block_(num_threads), num_to_exit_(num_threads) {}
+    // Barrier
+    //
+    // This class creates a barrier which blocks threads until a prespecified
+    // threshold of threads (`num_threads`) utilizes the barrier. A thread utilizes
+    // the `Barrier` by calling `Block()` on the barrier, which will block that
+    // thread; no call to `Block()` will return until `num_threads` threads have
+    // called it.
+    //
+    // Exactly one call to `Block()` will return `true`, which is then responsible
+    // for destroying the barrier; because stack allocation will cause the barrier
+    // to be deleted when it is out of scope, barriers should not be stack
+    // allocated.
+    //
+    // Example:
+    //
+    //   // Main thread creates a `Barrier`:
+    //   barrier = new Barrier(num_threads);
+    //
+    //   // Each participating thread could then call:
+    //   if (barrier->Block()) delete barrier;  // Exactly one call to `Block()`
+    //                                          // returns `true`; that call
+    //                                          // deletes the barrier.
+    class Barrier
+    {
+    public:
+        // `num_threads` is the number of threads that will participate in the barrier
+        explicit Barrier(int num_threads) :
+            num_to_block_(num_threads),
+            num_to_exit_(num_threads)
+        {
+        }
 
-  Barrier(const Barrier&) = delete;
-  Barrier& operator=(const Barrier&) = delete;
+        Barrier(const Barrier&) = delete;
+        Barrier& operator=(const Barrier&) = delete;
 
-  // Barrier::Block()
-  //
-  // Blocks the current thread, and returns only when the `num_threads`
-  // threshold of threads utilizing this barrier has been reached. `Block()`
-  // returns `true` for precisely one caller, which may then destroy the
-  // barrier.
-  //
-  // Memory ordering: For any threads X and Y, any action taken by X
-  // before X calls `Block()` will be visible to Y after Y returns from
-  // `Block()`.
-  bool Block();
+        // Barrier::Block()
+        //
+        // Blocks the current thread, and returns only when the `num_threads`
+        // threshold of threads utilizing this barrier has been reached. `Block()`
+        // returns `true` for precisely one caller, which may then destroy the
+        // barrier.
+        //
+        // Memory ordering: For any threads X and Y, any action taken by X
+        // before X calls `Block()` will be visible to Y after Y returns from
+        // `Block()`.
+        bool Block();
 
- private:
-  Mutex lock_;
-  int num_to_block_ ABSL_GUARDED_BY(lock_);
-  int num_to_exit_ ABSL_GUARDED_BY(lock_);
-};
+    private:
+        Mutex lock_;
+        int num_to_block_ ABSL_GUARDED_BY(lock_);
+        int num_to_exit_ ABSL_GUARDED_BY(lock_);
+    };
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // ABSL_SYNCHRONIZATION_BARRIER_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/blocking_counter.h b/CAPI/cpp/grpc/include/absl/synchronization/blocking_counter.h
index 1908fdb..cd50359 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/blocking_counter.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/blocking_counter.h
@@ -25,77 +25,79 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/synchronization/mutex.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// BlockingCounter
-//
-// This class allows a thread to block for a pre-specified number of actions.
-// `BlockingCounter` maintains a single non-negative abstract integer "count"
-// with an initial value `initial_count`. A thread can then call `Wait()` on
-// this blocking counter to block until the specified number of events occur;
-// worker threads then call 'DecrementCount()` on the counter upon completion of
-// their work. Once the counter's internal "count" reaches zero, the blocked
-// thread unblocks.
-//
-// A `BlockingCounter` requires the following:
-//     - its `initial_count` is non-negative.
-//     - the number of calls to `DecrementCount()` on it is at most
-//       `initial_count`.
-//     - `Wait()` is called at most once on it.
-//
-// Given the above requirements, a `BlockingCounter` provides the following
-// guarantees:
-//     - Once its internal "count" reaches zero, no legal action on the object
-//       can further change the value of "count".
-//     - When `Wait()` returns, it is legal to destroy the `BlockingCounter`.
-//     - When `Wait()` returns, the number of calls to `DecrementCount()` on
-//       this blocking counter exactly equals `initial_count`.
-//
-// Example:
-//     BlockingCounter bcount(N);         // there are N items of work
-//     ... Allow worker threads to start.
-//     ... On completing each work item, workers do:
-//     ... bcount.DecrementCount();      // an item of work has been completed
-//
-//     bcount.Wait();                    // wait for all work to be complete
-//
-class BlockingCounter {
- public:
-  explicit BlockingCounter(int initial_count);
+    // BlockingCounter
+    //
+    // This class allows a thread to block for a pre-specified number of actions.
+    // `BlockingCounter` maintains a single non-negative abstract integer "count"
+    // with an initial value `initial_count`. A thread can then call `Wait()` on
+    // this blocking counter to block until the specified number of events occur;
+    // worker threads then call 'DecrementCount()` on the counter upon completion of
+    // their work. Once the counter's internal "count" reaches zero, the blocked
+    // thread unblocks.
+    //
+    // A `BlockingCounter` requires the following:
+    //     - its `initial_count` is non-negative.
+    //     - the number of calls to `DecrementCount()` on it is at most
+    //       `initial_count`.
+    //     - `Wait()` is called at most once on it.
+    //
+    // Given the above requirements, a `BlockingCounter` provides the following
+    // guarantees:
+    //     - Once its internal "count" reaches zero, no legal action on the object
+    //       can further change the value of "count".
+    //     - When `Wait()` returns, it is legal to destroy the `BlockingCounter`.
+    //     - When `Wait()` returns, the number of calls to `DecrementCount()` on
+    //       this blocking counter exactly equals `initial_count`.
+    //
+    // Example:
+    //     BlockingCounter bcount(N);         // there are N items of work
+    //     ... Allow worker threads to start.
+    //     ... On completing each work item, workers do:
+    //     ... bcount.DecrementCount();      // an item of work has been completed
+    //
+    //     bcount.Wait();                    // wait for all work to be complete
+    //
+    class BlockingCounter
+    {
+    public:
+        explicit BlockingCounter(int initial_count);
 
-  BlockingCounter(const BlockingCounter&) = delete;
-  BlockingCounter& operator=(const BlockingCounter&) = delete;
+        BlockingCounter(const BlockingCounter&) = delete;
+        BlockingCounter& operator=(const BlockingCounter&) = delete;
 
-  // BlockingCounter::DecrementCount()
-  //
-  // Decrements the counter's "count" by one, and return "count == 0". This
-  // function requires that "count != 0" when it is called.
-  //
-  // Memory ordering: For any threads X and Y, any action taken by X
-  // before it calls `DecrementCount()` is visible to thread Y after
-  // Y's call to `DecrementCount()`, provided Y's call returns `true`.
-  bool DecrementCount();
+        // BlockingCounter::DecrementCount()
+        //
+        // Decrements the counter's "count" by one, and return "count == 0". This
+        // function requires that "count != 0" when it is called.
+        //
+        // Memory ordering: For any threads X and Y, any action taken by X
+        // before it calls `DecrementCount()` is visible to thread Y after
+        // Y's call to `DecrementCount()`, provided Y's call returns `true`.
+        bool DecrementCount();
 
-  // BlockingCounter::Wait()
-  //
-  // Blocks until the counter reaches zero. This function may be called at most
-  // once. On return, `DecrementCount()` will have been called "initial_count"
-  // times and the blocking counter may be destroyed.
-  //
-  // Memory ordering: For any threads X and Y, any action taken by X
-  // before X calls `DecrementCount()` is visible to Y after Y returns
-  // from `Wait()`.
-  void Wait();
+        // BlockingCounter::Wait()
+        //
+        // Blocks until the counter reaches zero. This function may be called at most
+        // once. On return, `DecrementCount()` will have been called "initial_count"
+        // times and the blocking counter may be destroyed.
+        //
+        // Memory ordering: For any threads X and Y, any action taken by X
+        // before X calls `DecrementCount()` is visible to Y after Y returns
+        // from `Wait()`.
+        void Wait();
 
- private:
-  Mutex lock_;
-  std::atomic<int> count_;
-  int num_waiting_ ABSL_GUARDED_BY(lock_);
-  bool done_ ABSL_GUARDED_BY(lock_);
-};
+    private:
+        Mutex lock_;
+        std::atomic<int> count_;
+        int num_waiting_ ABSL_GUARDED_BY(lock_);
+        bool done_ ABSL_GUARDED_BY(lock_);
+    };
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/create_thread_identity.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/create_thread_identity.h
index 4cfde09..369c3ab 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/internal/create_thread_identity.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/create_thread_identity.h
@@ -28,29 +28,33 @@
 #include "absl/base/internal/thread_identity.h"
 #include "absl/base/port.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace synchronization_internal {
-
-// Allocates and attaches a ThreadIdentity object for the calling thread.
-// For private use only.
-base_internal::ThreadIdentity* CreateThreadIdentity();
-
-// Returns the ThreadIdentity object representing the calling thread; guaranteed
-// to be unique for its lifetime.  The returned object will remain valid for the
-// program's lifetime; although it may be re-assigned to a subsequent thread.
-// If one does not exist for the calling thread, allocate it now.
-inline base_internal::ThreadIdentity* GetOrCreateCurrentThreadIdentity() {
-  base_internal::ThreadIdentity* identity =
-      base_internal::CurrentThreadIdentityIfPresent();
-  if (ABSL_PREDICT_FALSE(identity == nullptr)) {
-    return CreateThreadIdentity();
-  }
-  return identity;
-}
-
-}  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace synchronization_internal
+    {
+
+        // Allocates and attaches a ThreadIdentity object for the calling thread.
+        // For private use only.
+        base_internal::ThreadIdentity* CreateThreadIdentity();
+
+        // Returns the ThreadIdentity object representing the calling thread; guaranteed
+        // to be unique for its lifetime.  The returned object will remain valid for the
+        // program's lifetime; although it may be re-assigned to a subsequent thread.
+        // If one does not exist for the calling thread, allocate it now.
+        inline base_internal::ThreadIdentity* GetOrCreateCurrentThreadIdentity()
+        {
+            base_internal::ThreadIdentity* identity =
+                base_internal::CurrentThreadIdentityIfPresent();
+            if (ABSL_PREDICT_FALSE(identity == nullptr))
+            {
+                return CreateThreadIdentity();
+            }
+            return identity;
+        }
+
+    }  // namespace synchronization_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/futex.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/futex.h
index 06fbd6d..f5c6700 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/internal/futex.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/futex.h
@@ -51,9 +51,11 @@
 
 #ifdef ABSL_INTERNAL_HAVE_FUTEX
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace synchronization_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace synchronization_internal
+    {
 
 // Some Android headers are missing these definitions even though they
 // support these futex operations.
@@ -83,70 +85,74 @@ namespace synchronization_internal {
 #define SYS_futex SYS_futex_time64
 #endif
 
-class FutexImpl {
- public:
-  static int WaitUntil(std::atomic<int32_t> *v, int32_t val,
-                       KernelTimeout t) {
-    int err = 0;
-    if (t.has_timeout()) {
-      // https://locklessinc.com/articles/futex_cheat_sheet/
-      // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET uses absolute time.
-      struct timespec abs_timeout = t.MakeAbsTimespec();
-      // Atomically check that the futex value is still 0, and if it
-      // is, sleep until abs_timeout or until woken by FUTEX_WAKE.
-      err = syscall(
-          SYS_futex, reinterpret_cast<int32_t *>(v),
-          FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME, val,
-          &abs_timeout, nullptr, FUTEX_BITSET_MATCH_ANY);
-    } else {
-      // Atomically check that the futex value is still 0, and if it
-      // is, sleep until woken by FUTEX_WAKE.
-      err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
-                    FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, nullptr);
-    }
-    if (ABSL_PREDICT_FALSE(err != 0)) {
-      err = -errno;
-    }
-    return err;
-  }
-
-  static int WaitBitsetAbsoluteTimeout(std::atomic<int32_t> *v, int32_t val,
-                                       int32_t bits,
-                                       const struct timespec *abstime) {
-    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
-                      FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG, val, abstime,
-                      nullptr, bits);
-    if (ABSL_PREDICT_FALSE(err != 0)) {
-      err = -errno;
-    }
-    return err;
-  }
-
-  static int Wake(std::atomic<int32_t> *v, int32_t count) {
-    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
-                      FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count);
-    if (ABSL_PREDICT_FALSE(err < 0)) {
-      err = -errno;
-    }
-    return err;
-  }
-
-  // FUTEX_WAKE_BITSET
-  static int WakeBitset(std::atomic<int32_t> *v, int32_t count, int32_t bits) {
-    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
-                      FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, count, nullptr,
-                      nullptr, bits);
-    if (ABSL_PREDICT_FALSE(err < 0)) {
-      err = -errno;
-    }
-    return err;
-  }
-};
-
-class Futex : public FutexImpl {};
-
-}  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+        class FutexImpl
+        {
+        public:
+            static int WaitUntil(std::atomic<int32_t>* v, int32_t val, KernelTimeout t)
+            {
+                int err = 0;
+                if (t.has_timeout())
+                {
+                    // https://locklessinc.com/articles/futex_cheat_sheet/
+                    // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET uses absolute time.
+                    struct timespec abs_timeout = t.MakeAbsTimespec();
+                    // Atomically check that the futex value is still 0, and if it
+                    // is, sleep until abs_timeout or until woken by FUTEX_WAKE.
+                    err = syscall(
+                        SYS_futex, reinterpret_cast<int32_t*>(v), FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME, val, &abs_timeout, nullptr, FUTEX_BITSET_MATCH_ANY
+                    );
+                }
+                else
+                {
+                    // Atomically check that the futex value is still 0, and if it
+                    // is, sleep until woken by FUTEX_WAKE.
+                    err = syscall(SYS_futex, reinterpret_cast<int32_t*>(v), FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, nullptr);
+                }
+                if (ABSL_PREDICT_FALSE(err != 0))
+                {
+                    err = -errno;
+                }
+                return err;
+            }
+
+            static int WaitBitsetAbsoluteTimeout(std::atomic<int32_t>* v, int32_t val, int32_t bits, const struct timespec* abstime)
+            {
+                int err = syscall(SYS_futex, reinterpret_cast<int32_t*>(v), FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG, val, abstime, nullptr, bits);
+                if (ABSL_PREDICT_FALSE(err != 0))
+                {
+                    err = -errno;
+                }
+                return err;
+            }
+
+            static int Wake(std::atomic<int32_t>* v, int32_t count)
+            {
+                int err = syscall(SYS_futex, reinterpret_cast<int32_t*>(v), FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count);
+                if (ABSL_PREDICT_FALSE(err < 0))
+                {
+                    err = -errno;
+                }
+                return err;
+            }
+
+            // FUTEX_WAKE_BITSET
+            static int WakeBitset(std::atomic<int32_t>* v, int32_t count, int32_t bits)
+            {
+                int err = syscall(SYS_futex, reinterpret_cast<int32_t*>(v), FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, count, nullptr, nullptr, bits);
+                if (ABSL_PREDICT_FALSE(err < 0))
+                {
+                    err = -errno;
+                }
+                return err;
+            }
+        };
+
+        class Futex : public FutexImpl
+        {
+        };
+
+    }  // namespace synchronization_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_INTERNAL_HAVE_FUTEX
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/graphcycles.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/graphcycles.h
index ceba33e..58ededf 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/internal/graphcycles.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/graphcycles.h
@@ -42,100 +42,110 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace synchronization_internal {
-
-// Opaque identifier for a graph node.
-struct GraphId {
-  uint64_t handle;
-
-  bool operator==(const GraphId& x) const { return handle == x.handle; }
-  bool operator!=(const GraphId& x) const { return handle != x.handle; }
-};
-
-// Return an invalid graph id that will never be assigned by GraphCycles.
-inline GraphId InvalidGraphId() {
-  return GraphId{0};
-}
-
-class GraphCycles {
- public:
-  GraphCycles();
-  ~GraphCycles();
-
-  // Return the id to use for ptr, assigning one if necessary.
-  // Subsequent calls with the same ptr value will return the same id
-  // until Remove().
-  GraphId GetId(void* ptr);
-
-  // Remove "ptr" from the graph.  Its corresponding node and all
-  // edges to and from it are removed.
-  void RemoveNode(void* ptr);
-
-  // Return the pointer associated with id, or nullptr if id is not
-  // currently in the graph.
-  void* Ptr(GraphId id);
-
-  // Attempt to insert an edge from source_node to dest_node.  If the
-  // edge would introduce a cycle, return false without making any
-  // changes. Otherwise add the edge and return true.
-  bool InsertEdge(GraphId source_node, GraphId dest_node);
-
-  // Remove any edge that exists from source_node to dest_node.
-  void RemoveEdge(GraphId source_node, GraphId dest_node);
-
-  // Return whether node exists in the graph.
-  bool HasNode(GraphId node);
-
-  // Return whether there is an edge directly from source_node to dest_node.
-  bool HasEdge(GraphId source_node, GraphId dest_node) const;
-
-  // Return whether dest_node is reachable from source_node
-  // by following edges.
-  bool IsReachable(GraphId source_node, GraphId dest_node) const;
-
-  // Find a path from "source" to "dest".  If such a path exists,
-  // place the nodes on the path in the array path[], and return
-  // the number of nodes on the path.  If the path is longer than
-  // max_path_len nodes, only the first max_path_len nodes are placed
-  // in path[].  The client should compare the return value with
-  // max_path_len" to see when this occurs.  If no path exists, return
-  // 0.  Any valid path stored in path[] will start with "source" and
-  // end with "dest".  There is no guarantee that the path is the
-  // shortest, but no node will appear twice in the path, except the
-  // source and destination node if they are identical; therefore, the
-  // return value is at most one greater than the number of nodes in
-  // the graph.
-  int FindPath(GraphId source, GraphId dest, int max_path_len,
-               GraphId path[]) const;
-
-  // Update the stack trace recorded for id with the current stack
-  // trace if the last time it was updated had a smaller priority
-  // than the priority passed on this call.
-  //
-  // *get_stack_trace is called to get the stack trace.
-  void UpdateStackTrace(GraphId id, int priority,
-                        int (*get_stack_trace)(void**, int));
-
-  // Set *ptr to the beginning of the array that holds the recorded
-  // stack trace for id and return the depth of the stack trace.
-  int GetStackTrace(GraphId id, void*** ptr);
-
-  // Check internal invariants. Crashes on failure, returns true on success.
-  // Expensive: should only be called from graphcycles_test.cc.
-  bool CheckInvariants() const;
-
-  // ----------------------------------------------------
-  struct Rep;
- private:
-  Rep *rep_;      // opaque representation
-  GraphCycles(const GraphCycles&) = delete;
-  GraphCycles& operator=(const GraphCycles&) = delete;
-};
-
-}  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace synchronization_internal
+    {
+
+        // Opaque identifier for a graph node.
+        struct GraphId
+        {
+            uint64_t handle;
+
+            bool operator==(const GraphId& x) const
+            {
+                return handle == x.handle;
+            }
+            bool operator!=(const GraphId& x) const
+            {
+                return handle != x.handle;
+            }
+        };
+
+        // Return an invalid graph id that will never be assigned by GraphCycles.
+        inline GraphId InvalidGraphId()
+        {
+            return GraphId{0};
+        }
+
+        class GraphCycles
+        {
+        public:
+            GraphCycles();
+            ~GraphCycles();
+
+            // Return the id to use for ptr, assigning one if necessary.
+            // Subsequent calls with the same ptr value will return the same id
+            // until Remove().
+            GraphId GetId(void* ptr);
+
+            // Remove "ptr" from the graph.  Its corresponding node and all
+            // edges to and from it are removed.
+            void RemoveNode(void* ptr);
+
+            // Return the pointer associated with id, or nullptr if id is not
+            // currently in the graph.
+            void* Ptr(GraphId id);
+
+            // Attempt to insert an edge from source_node to dest_node.  If the
+            // edge would introduce a cycle, return false without making any
+            // changes. Otherwise add the edge and return true.
+            bool InsertEdge(GraphId source_node, GraphId dest_node);
+
+            // Remove any edge that exists from source_node to dest_node.
+            void RemoveEdge(GraphId source_node, GraphId dest_node);
+
+            // Return whether node exists in the graph.
+            bool HasNode(GraphId node);
+
+            // Return whether there is an edge directly from source_node to dest_node.
+            bool HasEdge(GraphId source_node, GraphId dest_node) const;
+
+            // Return whether dest_node is reachable from source_node
+            // by following edges.
+            bool IsReachable(GraphId source_node, GraphId dest_node) const;
+
+            // Find a path from "source" to "dest".  If such a path exists,
+            // place the nodes on the path in the array path[], and return
+            // the number of nodes on the path.  If the path is longer than
+            // max_path_len nodes, only the first max_path_len nodes are placed
+            // in path[].  The client should compare the return value with
+            // max_path_len" to see when this occurs.  If no path exists, return
+            // 0.  Any valid path stored in path[] will start with "source" and
+            // end with "dest".  There is no guarantee that the path is the
+            // shortest, but no node will appear twice in the path, except the
+            // source and destination node if they are identical; therefore, the
+            // return value is at most one greater than the number of nodes in
+            // the graph.
+            int FindPath(GraphId source, GraphId dest, int max_path_len, GraphId path[]) const;
+
+            // Update the stack trace recorded for id with the current stack
+            // trace if the last time it was updated had a smaller priority
+            // than the priority passed on this call.
+            //
+            // *get_stack_trace is called to get the stack trace.
+            void UpdateStackTrace(GraphId id, int priority, int (*get_stack_trace)(void**, int));
+
+            // Set *ptr to the beginning of the array that holds the recorded
+            // stack trace for id and return the depth of the stack trace.
+            int GetStackTrace(GraphId id, void*** ptr);
+
+            // Check internal invariants. Crashes on failure, returns true on success.
+            // Expensive: should only be called from graphcycles_test.cc.
+            bool CheckInvariants() const;
+
+            // ----------------------------------------------------
+            struct Rep;
+
+        private:
+            Rep* rep_;  // opaque representation
+            GraphCycles(const GraphCycles&) = delete;
+            GraphCycles& operator=(const GraphCycles&) = delete;
+        };
+
+    }  // namespace synchronization_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h
index bbd4d2d..eedec10 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h
@@ -34,123 +34,149 @@
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace synchronization_internal {
-
-class Futex;
-class Waiter;
-
-class KernelTimeout {
- public:
-  // A timeout that should expire at <t>.  Any value, in the full
-  // InfinitePast() to InfiniteFuture() range, is valid here and will be
-  // respected.
-  explicit KernelTimeout(absl::Time t) : ns_(MakeNs(t)) {}
-  // No timeout.
-  KernelTimeout() : ns_(0) {}
-
-  // A more explicit factory for those who prefer it.  Equivalent to {}.
-  static KernelTimeout Never() { return {}; }
-
-  // We explicitly do not support other custom formats: timespec, int64_t nanos.
-  // Unify on this and absl::Time, please.
-
-  bool has_timeout() const { return ns_ != 0; }
-
-  // Convert to parameter for sem_timedwait/futex/similar.  Only for approved
-  // users.  Do not call if !has_timeout.
-  struct timespec MakeAbsTimespec();
-
- private:
-  // internal rep, not user visible: ns after unix epoch.
-  // zero = no timeout.
-  // Negative we treat as an unlikely (and certainly expired!) but valid
-  // timeout.
-  int64_t ns_;
-
-  static int64_t MakeNs(absl::Time t) {
-    // optimization--InfiniteFuture is common "no timeout" value
-    // and cheaper to compare than convert.
-    if (t == absl::InfiniteFuture()) return 0;
-    int64_t x = ToUnixNanos(t);
-
-    // A timeout that lands exactly on the epoch (x=0) needs to be respected,
-    // so we alter it unnoticably to 1.  Negative timeouts are in
-    // theory supported, but handled poorly by the kernel (long
-    // delays) so push them forward too; since all such times have
-    // already passed, it's indistinguishable.
-    if (x <= 0) x = 1;
-    // A time larger than what can be represented to the kernel is treated
-    // as no timeout.
-    if (x == (std::numeric_limits<int64_t>::max)()) x = 0;
-    return x;
-  }
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace synchronization_internal
+    {
+
+        class Futex;
+        class Waiter;
+
+        class KernelTimeout
+        {
+        public:
+            // A timeout that should expire at <t>.  Any value, in the full
+            // InfinitePast() to InfiniteFuture() range, is valid here and will be
+            // respected.
+            explicit KernelTimeout(absl::Time t) :
+                ns_(MakeNs(t))
+            {
+            }
+            // No timeout.
+            KernelTimeout() :
+                ns_(0)
+            {
+            }
+
+            // A more explicit factory for those who prefer it.  Equivalent to {}.
+            static KernelTimeout Never()
+            {
+                return {};
+            }
+
+            // We explicitly do not support other custom formats: timespec, int64_t nanos.
+            // Unify on this and absl::Time, please.
+
+            bool has_timeout() const
+            {
+                return ns_ != 0;
+            }
+
+            // Convert to parameter for sem_timedwait/futex/similar.  Only for approved
+            // users.  Do not call if !has_timeout.
+            struct timespec MakeAbsTimespec();
+
+        private:
+            // internal rep, not user visible: ns after unix epoch.
+            // zero = no timeout.
+            // Negative we treat as an unlikely (and certainly expired!) but valid
+            // timeout.
+            int64_t ns_;
+
+            static int64_t MakeNs(absl::Time t)
+            {
+                // optimization--InfiniteFuture is common "no timeout" value
+                // and cheaper to compare than convert.
+                if (t == absl::InfiniteFuture())
+                    return 0;
+                int64_t x = ToUnixNanos(t);
+
+                // A timeout that lands exactly on the epoch (x=0) needs to be respected,
+                // so we alter it unnoticably to 1.  Negative timeouts are in
+                // theory supported, but handled poorly by the kernel (long
+                // delays) so push them forward too; since all such times have
+                // already passed, it's indistinguishable.
+                if (x <= 0)
+                    x = 1;
+                // A time larger than what can be represented to the kernel is treated
+                // as no timeout.
+                if (x == (std::numeric_limits<int64_t>::max)())
+                    x = 0;
+                return x;
+            }
 
 #ifdef _WIN32
-  // Converts to milliseconds from now, or INFINITE when
-  // !has_timeout(). For use by SleepConditionVariableSRW on
-  // Windows. Callers should recognize that the return value is a
-  // relative duration (it should be recomputed by calling this method
-  // in the case of a spurious wakeup).
-  // This header file may be included transitively by public header files,
-  // so we define our own DWORD and INFINITE instead of getting them from
-  // <intsafe.h> and <WinBase.h>.
-  typedef unsigned long DWord;  // NOLINT
-  DWord InMillisecondsFromNow() const {
-    constexpr DWord kInfinite = (std::numeric_limits<DWord>::max)();
-    if (!has_timeout()) {
-      return kInfinite;
-    }
-    // The use of absl::Now() to convert from absolute time to
-    // relative time means that absl::Now() cannot use anything that
-    // depends on KernelTimeout (for example, Mutex) on Windows.
-    int64_t now = ToUnixNanos(absl::Now());
-    if (ns_ >= now) {
-      // Round up so that Now() + ms_from_now >= ns_.
-      constexpr uint64_t max_nanos =
-          (std::numeric_limits<int64_t>::max)() - 999999u;
-      uint64_t ms_from_now =
-          (std::min<uint64_t>(max_nanos, ns_ - now) + 999999u) / 1000000u;
-      if (ms_from_now > kInfinite) {
-        return kInfinite;
-      }
-      return static_cast<DWord>(ms_from_now);
-    }
-    return 0;
-  }
+            // Converts to milliseconds from now, or INFINITE when
+            // !has_timeout(). For use by SleepConditionVariableSRW on
+            // Windows. Callers should recognize that the return value is a
+            // relative duration (it should be recomputed by calling this method
+            // in the case of a spurious wakeup).
+            // This header file may be included transitively by public header files,
+            // so we define our own DWORD and INFINITE instead of getting them from
+            // <intsafe.h> and <WinBase.h>.
+            typedef unsigned long DWord;  // NOLINT
+            DWord InMillisecondsFromNow() const
+            {
+                constexpr DWord kInfinite = (std::numeric_limits<DWord>::max)();
+                if (!has_timeout())
+                {
+                    return kInfinite;
+                }
+                // The use of absl::Now() to convert from absolute time to
+                // relative time means that absl::Now() cannot use anything that
+                // depends on KernelTimeout (for example, Mutex) on Windows.
+                int64_t now = ToUnixNanos(absl::Now());
+                if (ns_ >= now)
+                {
+                    // Round up so that Now() + ms_from_now >= ns_.
+                    constexpr uint64_t max_nanos =
+                        (std::numeric_limits<int64_t>::max)() - 999999u;
+                    uint64_t ms_from_now =
+                        (std::min<uint64_t>(max_nanos, ns_ - now) + 999999u) / 1000000u;
+                    if (ms_from_now > kInfinite)
+                    {
+                        return kInfinite;
+                    }
+                    return static_cast<DWord>(ms_from_now);
+                }
+                return 0;
+            }
 #endif
 
-  friend class Futex;
-  friend class Waiter;
-};
-
-inline struct timespec KernelTimeout::MakeAbsTimespec() {
-  int64_t n = ns_;
-  static const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
-  if (n == 0) {
-    ABSL_RAW_LOG(
-        ERROR, "Tried to create a timespec from a non-timeout; never do this.");
-    // But we'll try to continue sanely.  no-timeout ~= saturated timeout.
-    n = (std::numeric_limits<int64_t>::max)();
-  }
-
-  // Kernel APIs validate timespecs as being at or after the epoch,
-  // despite the kernel time type being signed.  However, no one can
-  // tell the difference between a timeout at or before the epoch (since
-  // all such timeouts have expired!)
-  if (n < 0) n = 0;
-
-  struct timespec abstime;
-  int64_t seconds = (std::min)(n / kNanosPerSecond,
-                               int64_t{(std::numeric_limits<time_t>::max)()});
-  abstime.tv_sec = static_cast<time_t>(seconds);
-  abstime.tv_nsec = static_cast<decltype(abstime.tv_nsec)>(n % kNanosPerSecond);
-  return abstime;
-}
-
-}  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+            friend class Futex;
+            friend class Waiter;
+        };
+
+        inline struct timespec KernelTimeout::MakeAbsTimespec()
+        {
+            int64_t n = ns_;
+            static const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
+            if (n == 0)
+            {
+                ABSL_RAW_LOG(
+                    ERROR, "Tried to create a timespec from a non-timeout; never do this."
+                );
+                // But we'll try to continue sanely.  no-timeout ~= saturated timeout.
+                n = (std::numeric_limits<int64_t>::max)();
+            }
+
+            // Kernel APIs validate timespecs as being at or after the epoch,
+            // despite the kernel time type being signed.  However, no one can
+            // tell the difference between a timeout at or before the epoch (since
+            // all such timeouts have expired!)
+            if (n < 0)
+                n = 0;
+
+            struct timespec abstime;
+            int64_t seconds = (std::min)(n / kNanosPerSecond, int64_t{(std::numeric_limits<time_t>::max)()});
+            abstime.tv_sec = static_cast<time_t>(seconds);
+            abstime.tv_nsec = static_cast<decltype(abstime.tv_nsec)>(n % kNanosPerSecond);
+            return abstime;
+        }
+
+    }  // namespace synchronization_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/per_thread_sem.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/per_thread_sem.h
index 90a8880..8e3f2ad 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/internal/per_thread_sem.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/per_thread_sem.h
@@ -31,57 +31,60 @@
 #include "absl/synchronization/internal/create_thread_identity.h"
 #include "absl/synchronization/internal/kernel_timeout.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class Mutex;
-
-namespace synchronization_internal {
-
-class PerThreadSem {
- public:
-  PerThreadSem() = delete;
-  PerThreadSem(const PerThreadSem&) = delete;
-  PerThreadSem& operator=(const PerThreadSem&) = delete;
-
-  // Routine invoked periodically (once a second) by a background thread.
-  // Has no effect on user-visible state.
-  static void Tick(base_internal::ThreadIdentity* identity);
-
-  // ---------------------------------------------------------------------------
-  // Routines used by autosizing threadpools to detect when threads are
-  // blocked.  Each thread has a counter pointer, initially zero.  If non-zero,
-  // the implementation atomically increments the counter when it blocks on a
-  // semaphore, a decrements it again when it wakes.  This allows a threadpool
-  // to keep track of how many of its threads are blocked.
-  // SetThreadBlockedCounter() should be used only by threadpool
-  // implementations.  GetThreadBlockedCounter() should be used by modules that
-  // block threads; if the pointer returned is non-zero, the location should be
-  // incremented before the thread blocks, and decremented after it wakes.
-  static void SetThreadBlockedCounter(std::atomic<int> *counter);
-  static std::atomic<int> *GetThreadBlockedCounter();
-
- private:
-  // Create the PerThreadSem associated with "identity".  Initializes count=0.
-  // REQUIRES: May only be called by ThreadIdentity.
-  static void Init(base_internal::ThreadIdentity* identity);
-
-  // Increments "identity"'s count.
-  static inline void Post(base_internal::ThreadIdentity* identity);
-
-  // Waits until either our count > 0 or t has expired.
-  // If count > 0, decrements count and returns true.  Otherwise returns false.
-  // !t.has_timeout() => Wait(t) will return true.
-  static inline bool Wait(KernelTimeout t);
-
-  // Permitted callers.
-  friend class PerThreadSemTest;
-  friend class absl::Mutex;
-  friend void OneTimeInitThreadIdentity(absl::base_internal::ThreadIdentity*);
-};
-
-}  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class Mutex;
+
+    namespace synchronization_internal
+    {
+
+        class PerThreadSem
+        {
+        public:
+            PerThreadSem() = delete;
+            PerThreadSem(const PerThreadSem&) = delete;
+            PerThreadSem& operator=(const PerThreadSem&) = delete;
+
+            // Routine invoked periodically (once a second) by a background thread.
+            // Has no effect on user-visible state.
+            static void Tick(base_internal::ThreadIdentity* identity);
+
+            // ---------------------------------------------------------------------------
+            // Routines used by autosizing threadpools to detect when threads are
+            // blocked.  Each thread has a counter pointer, initially zero.  If non-zero,
+            // the implementation atomically increments the counter when it blocks on a
+            // semaphore, a decrements it again when it wakes.  This allows a threadpool
+            // to keep track of how many of its threads are blocked.
+            // SetThreadBlockedCounter() should be used only by threadpool
+            // implementations.  GetThreadBlockedCounter() should be used by modules that
+            // block threads; if the pointer returned is non-zero, the location should be
+            // incremented before the thread blocks, and decremented after it wakes.
+            static void SetThreadBlockedCounter(std::atomic<int>* counter);
+            static std::atomic<int>* GetThreadBlockedCounter();
+
+        private:
+            // Create the PerThreadSem associated with "identity".  Initializes count=0.
+            // REQUIRES: May only be called by ThreadIdentity.
+            static void Init(base_internal::ThreadIdentity* identity);
+
+            // Increments "identity"'s count.
+            static inline void Post(base_internal::ThreadIdentity* identity);
+
+            // Waits until either our count > 0 or t has expired.
+            // If count > 0, decrements count and returns true.  Otherwise returns false.
+            // !t.has_timeout() => Wait(t) will return true.
+            static inline bool Wait(KernelTimeout t);
+
+            // Permitted callers.
+            friend class PerThreadSemTest;
+            friend class absl::Mutex;
+            friend void OneTimeInitThreadIdentity(absl::base_internal::ThreadIdentity*);
+        };
+
+    }  // namespace synchronization_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // In some build configurations we pass --detect-odr-violations to the
@@ -90,21 +93,29 @@ ABSL_NAMESPACE_END
 // --detect-odr-violations ignores symbols not mangled with C++ names.
 // By changing our extension points to be extern "C", we dodge this
 // check.
-extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
-    absl::base_internal::ThreadIdentity* identity);
-bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
-    absl::synchronization_internal::KernelTimeout t);
+extern "C"
+{
+    void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
+        absl::base_internal::ThreadIdentity* identity
+    );
+    bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
+        absl::synchronization_internal::KernelTimeout t
+    );
 }  // extern "C"
 
 void absl::synchronization_internal::PerThreadSem::Post(
-    absl::base_internal::ThreadIdentity* identity) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity);
+    absl::base_internal::ThreadIdentity* identity
+)
+{
+    ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)
+    (identity);
 }
 
 bool absl::synchronization_internal::PerThreadSem::Wait(
-    absl::synchronization_internal::KernelTimeout t) {
-  return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t);
+    absl::synchronization_internal::KernelTimeout t
+)
+{
+    return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t);
 }
 
 #endif  // ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/thread_pool.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/thread_pool.h
index 0cb96da..f973d13 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/internal/thread_pool.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/thread_pool.h
@@ -25,69 +25,82 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/synchronization/mutex.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace synchronization_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace synchronization_internal
+    {
 
-// A simple ThreadPool implementation for tests.
-class ThreadPool {
- public:
-  explicit ThreadPool(int num_threads) {
-    for (int i = 0; i < num_threads; ++i) {
-      threads_.push_back(std::thread(&ThreadPool::WorkLoop, this));
-    }
-  }
+        // A simple ThreadPool implementation for tests.
+        class ThreadPool
+        {
+        public:
+            explicit ThreadPool(int num_threads)
+            {
+                for (int i = 0; i < num_threads; ++i)
+                {
+                    threads_.push_back(std::thread(&ThreadPool::WorkLoop, this));
+                }
+            }
 
-  ThreadPool(const ThreadPool &) = delete;
-  ThreadPool &operator=(const ThreadPool &) = delete;
+            ThreadPool(const ThreadPool&) = delete;
+            ThreadPool& operator=(const ThreadPool&) = delete;
 
-  ~ThreadPool() {
-    {
-      absl::MutexLock l(&mu_);
-      for (size_t i = 0; i < threads_.size(); i++) {
-        queue_.push(nullptr);  // Shutdown signal.
-      }
-    }
-    for (auto &t : threads_) {
-      t.join();
-    }
-  }
+            ~ThreadPool()
+            {
+                {
+                    absl::MutexLock l(&mu_);
+                    for (size_t i = 0; i < threads_.size(); i++)
+                    {
+                        queue_.push(nullptr);  // Shutdown signal.
+                    }
+                }
+                for (auto& t : threads_)
+                {
+                    t.join();
+                }
+            }
 
-  // Schedule a function to be run on a ThreadPool thread immediately.
-  void Schedule(std::function<void()> func) {
-    assert(func != nullptr);
-    absl::MutexLock l(&mu_);
-    queue_.push(std::move(func));
-  }
+            // Schedule a function to be run on a ThreadPool thread immediately.
+            void Schedule(std::function<void()> func)
+            {
+                assert(func != nullptr);
+                absl::MutexLock l(&mu_);
+                queue_.push(std::move(func));
+            }
 
- private:
-  bool WorkAvailable() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    return !queue_.empty();
-  }
+        private:
+            bool WorkAvailable() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_)
+            {
+                return !queue_.empty();
+            }
 
-  void WorkLoop() {
-    while (true) {
-      std::function<void()> func;
-      {
-        absl::MutexLock l(&mu_);
-        mu_.Await(absl::Condition(this, &ThreadPool::WorkAvailable));
-        func = std::move(queue_.front());
-        queue_.pop();
-      }
-      if (func == nullptr) {  // Shutdown signal.
-        break;
-      }
-      func();
-    }
-  }
+            void WorkLoop()
+            {
+                while (true)
+                {
+                    std::function<void()> func;
+                    {
+                        absl::MutexLock l(&mu_);
+                        mu_.Await(absl::Condition(this, &ThreadPool::WorkAvailable));
+                        func = std::move(queue_.front());
+                        queue_.pop();
+                    }
+                    if (func == nullptr)
+                    {  // Shutdown signal.
+                        break;
+                    }
+                    func();
+                }
+            }
 
-  absl::Mutex mu_;
-  std::queue<std::function<void()>> queue_ ABSL_GUARDED_BY(mu_);
-  std::vector<std::thread> threads_;
-};
+            absl::Mutex mu_;
+            std::queue<std::function<void()>> queue_ ABSL_GUARDED_BY(mu_);
+            std::vector<std::thread> threads_;
+        };
 
-}  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+    }  // namespace synchronization_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/internal/waiter.h b/CAPI/cpp/grpc/include/absl/synchronization/internal/waiter.h
index b8adfeb..c58a026 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/internal/waiter.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/internal/waiter.h
@@ -57,105 +57,110 @@
 #define ABSL_WAITER_MODE ABSL_WAITER_MODE_CONDVAR
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace synchronization_internal {
-
-// Waiter is an OS-specific semaphore.
-class Waiter {
- public:
-  // Prepare any data to track waits.
-  Waiter();
-
-  // Not copyable or movable
-  Waiter(const Waiter&) = delete;
-  Waiter& operator=(const Waiter&) = delete;
-
-  // Blocks the calling thread until a matching call to `Post()` or
-  // `t` has passed. Returns `true` if woken (`Post()` called),
-  // `false` on timeout.
-  bool Wait(KernelTimeout t);
-
-  // Restart the caller of `Wait()` as with a normal semaphore.
-  void Post();
-
-  // If anyone is waiting, wake them up temporarily and cause them to
-  // call `MaybeBecomeIdle()`. They will then return to waiting for a
-  // `Post()` or timeout.
-  void Poke();
-
-  // Returns the Waiter associated with the identity.
-  static Waiter* GetWaiter(base_internal::ThreadIdentity* identity) {
-    static_assert(
-        sizeof(Waiter) <= sizeof(base_internal::ThreadIdentity::WaiterState),
-        "Insufficient space for Waiter");
-    return reinterpret_cast<Waiter*>(identity->waiter_state.data);
-  }
-
-  // How many periods to remain idle before releasing resources
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace synchronization_internal
+    {
+
+        // Waiter is an OS-specific semaphore.
+        class Waiter
+        {
+        public:
+            // Prepare any data to track waits.
+            Waiter();
+
+            // Not copyable or movable
+            Waiter(const Waiter&) = delete;
+            Waiter& operator=(const Waiter&) = delete;
+
+            // Blocks the calling thread until a matching call to `Post()` or
+            // `t` has passed. Returns `true` if woken (`Post()` called),
+            // `false` on timeout.
+            bool Wait(KernelTimeout t);
+
+            // Restart the caller of `Wait()` as with a normal semaphore.
+            void Post();
+
+            // If anyone is waiting, wake them up temporarily and cause them to
+            // call `MaybeBecomeIdle()`. They will then return to waiting for a
+            // `Post()` or timeout.
+            void Poke();
+
+            // Returns the Waiter associated with the identity.
+            static Waiter* GetWaiter(base_internal::ThreadIdentity* identity)
+            {
+                static_assert(
+                    sizeof(Waiter) <= sizeof(base_internal::ThreadIdentity::WaiterState),
+                    "Insufficient space for Waiter"
+                );
+                return reinterpret_cast<Waiter*>(identity->waiter_state.data);
+            }
+
+            // How many periods to remain idle before releasing resources
 #ifndef ABSL_HAVE_THREAD_SANITIZER
-  static constexpr int kIdlePeriods = 60;
+            static constexpr int kIdlePeriods = 60;
 #else
-  // Memory consumption under ThreadSanitizer is a serious concern,
-  // so we release resources sooner. The value of 1 leads to 1 to 2 second
-  // delay before marking a thread as idle.
-  static const int kIdlePeriods = 1;
+            // Memory consumption under ThreadSanitizer is a serious concern,
+            // so we release resources sooner. The value of 1 leads to 1 to 2 second
+            // delay before marking a thread as idle.
+            static const int kIdlePeriods = 1;
 #endif
 
- private:
-  // The destructor must not be called since Mutex/CondVar
-  // can use PerThreadSem/Waiter after the thread exits.
-  // Waiter objects are embedded in ThreadIdentity objects,
-  // which are reused via a freelist and are never destroyed.
-  ~Waiter() = delete;
+        private:
+            // The destructor must not be called since Mutex/CondVar
+            // can use PerThreadSem/Waiter after the thread exits.
+            // Waiter objects are embedded in ThreadIdentity objects,
+            // which are reused via a freelist and are never destroyed.
+            ~Waiter() = delete;
 
 #if ABSL_WAITER_MODE == ABSL_WAITER_MODE_FUTEX
-  // Futexes are defined by specification to be 32-bits.
-  // Thus std::atomic<int32_t> must be just an int32_t with lockfree methods.
-  std::atomic<int32_t> futex_;
-  static_assert(sizeof(int32_t) == sizeof(futex_), "Wrong size for futex");
+            // Futexes are defined by specification to be 32-bits.
+            // Thus std::atomic<int32_t> must be just an int32_t with lockfree methods.
+            std::atomic<int32_t> futex_;
+            static_assert(sizeof(int32_t) == sizeof(futex_), "Wrong size for futex");
 
 #elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_CONDVAR
-  // REQUIRES: mu_ must be held.
-  void InternalCondVarPoke();
+            // REQUIRES: mu_ must be held.
+            void InternalCondVarPoke();
 
-  pthread_mutex_t mu_;
-  pthread_cond_t cv_;
-  int waiter_count_;
-  int wakeup_count_;  // Unclaimed wakeups.
+            pthread_mutex_t mu_;
+            pthread_cond_t cv_;
+            int waiter_count_;
+            int wakeup_count_;  // Unclaimed wakeups.
 
 #elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_SEM
-  sem_t sem_;
-  // This seems superfluous, but for Poke() we need to cause spurious
-  // wakeups on the semaphore. Hence we can't actually use the
-  // semaphore's count.
-  std::atomic<int> wakeups_;
+            sem_t sem_;
+            // This seems superfluous, but for Poke() we need to cause spurious
+            // wakeups on the semaphore. Hence we can't actually use the
+            // semaphore's count.
+            std::atomic<int> wakeups_;
 
 #elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_WIN32
-  // WinHelper - Used to define utilities for accessing the lock and
-  // condition variable storage once the types are complete.
-  class WinHelper;
-
-  // REQUIRES: WinHelper::GetLock(this) must be held.
-  void InternalCondVarPoke();
-
-  // We can't include Windows.h in our headers, so we use aligned character
-  // buffers to define the storage of SRWLOCK and CONDITION_VARIABLE.
-  // SRW locks and condition variables do not need to be explicitly destroyed.
-  // https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-initializesrwlock
-  // https://stackoverflow.com/questions/28975958/why-does-windows-have-no-deleteconditionvariable-function-to-go-together-with
-  alignas(void*) unsigned char mu_storage_[sizeof(void*)];
-  alignas(void*) unsigned char cv_storage_[sizeof(void*)];
-  int waiter_count_;
-  int wakeup_count_;
+            // WinHelper - Used to define utilities for accessing the lock and
+            // condition variable storage once the types are complete.
+            class WinHelper;
+
+            // REQUIRES: WinHelper::GetLock(this) must be held.
+            void InternalCondVarPoke();
+
+            // We can't include Windows.h in our headers, so we use aligned character
+            // buffers to define the storage of SRWLOCK and CONDITION_VARIABLE.
+            // SRW locks and condition variables do not need to be explicitly destroyed.
+            // https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-initializesrwlock
+            // https://stackoverflow.com/questions/28975958/why-does-windows-have-no-deleteconditionvariable-function-to-go-together-with
+            alignas(void*) unsigned char mu_storage_[sizeof(void*)];
+            alignas(void*) unsigned char cv_storage_[sizeof(void*)];
+            int waiter_count_;
+            int wakeup_count_;
 
 #else
-  #error Unknown ABSL_WAITER_MODE
+#error Unknown ABSL_WAITER_MODE
 #endif
-};
+        };
 
-}  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+    }  // namespace synchronization_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/mutex.h b/CAPI/cpp/grpc/include/absl/synchronization/mutex.h
index b69b708..446cdce 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/mutex.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/mutex.h
@@ -73,1008 +73,1069 @@
 #include "absl/synchronization/internal/per_thread_sem.h"
 #include "absl/time/time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class Condition;
-struct SynchWaitParams;
-
-// -----------------------------------------------------------------------------
-// Mutex
-// -----------------------------------------------------------------------------
-//
-// A `Mutex` is a non-reentrant (aka non-recursive) Mutually Exclusive lock
-// on some resource, typically a variable or data structure with associated
-// invariants. Proper usage of mutexes prevents concurrent access by different
-// threads to the same resource.
-//
-// A `Mutex` has two basic operations: `Mutex::Lock()` and `Mutex::Unlock()`.
-// The `Lock()` operation *acquires* a `Mutex` (in a state known as an
-// *exclusive* -- or write -- lock), while the `Unlock()` operation *releases* a
-// Mutex. During the span of time between the Lock() and Unlock() operations,
-// a mutex is said to be *held*. By design all mutexes support exclusive/write
-// locks, as this is the most common way to use a mutex.
-//
-// The `Mutex` state machine for basic lock/unlock operations is quite simple:
-//
-// |                | Lock()     | Unlock() |
-// |----------------+------------+----------|
-// | Free           | Exclusive  | invalid  |
-// | Exclusive      | blocks     | Free     |
-//
-// Attempts to `Unlock()` must originate from the thread that performed the
-// corresponding `Lock()` operation.
-//
-// An "invalid" operation is disallowed by the API. The `Mutex` implementation
-// is allowed to do anything on an invalid call, including but not limited to
-// crashing with a useful error message, silently succeeding, or corrupting
-// data structures. In debug mode, the implementation attempts to crash with a
-// useful error message.
-//
-// `Mutex` is not guaranteed to be "fair" in prioritizing waiting threads; it
-// is, however, approximately fair over long periods, and starvation-free for
-// threads at the same priority.
-//
-// The lock/unlock primitives are now annotated with lock annotations
-// defined in (base/thread_annotations.h). When writing multi-threaded code,
-// you should use lock annotations whenever possible to document your lock
-// synchronization policy. Besides acting as documentation, these annotations
-// also help compilers or static analysis tools to identify and warn about
-// issues that could potentially result in race conditions and deadlocks.
-//
-// For more information about the lock annotations, please see
-// [Thread Safety Analysis](http://clang.llvm.org/docs/ThreadSafetyAnalysis.html)
-// in the Clang documentation.
-//
-// See also `MutexLock`, below, for scoped `Mutex` acquisition.
-
-class ABSL_LOCKABLE Mutex {
- public:
-  // Creates a `Mutex` that is not held by anyone. This constructor is
-  // typically used for Mutexes allocated on the heap or the stack.
-  //
-  // To create `Mutex` instances with static storage duration
-  // (e.g. a namespace-scoped or global variable), see
-  // `Mutex::Mutex(absl::kConstInit)` below instead.
-  Mutex();
-
-  // Creates a mutex with static storage duration.  A global variable
-  // constructed this way avoids the lifetime issues that can occur on program
-  // startup and shutdown.  (See absl/base/const_init.h.)
-  //
-  // For Mutexes allocated on the heap and stack, instead use the default
-  // constructor, which can interact more fully with the thread sanitizer.
-  //
-  // Example usage:
-  //   namespace foo {
-  //   ABSL_CONST_INIT absl::Mutex mu(absl::kConstInit);
-  //   }
-  explicit constexpr Mutex(absl::ConstInitType);
-
-  ~Mutex();
-
-  // Mutex::Lock()
-  //
-  // Blocks the calling thread, if necessary, until this `Mutex` is free, and
-  // then acquires it exclusively. (This lock is also known as a "write lock.")
-  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION();
-
-  // Mutex::Unlock()
-  //
-  // Releases this `Mutex` and returns it from the exclusive/write state to the
-  // free state. Calling thread must hold the `Mutex` exclusively.
-  void Unlock() ABSL_UNLOCK_FUNCTION();
-
-  // Mutex::TryLock()
-  //
-  // If the mutex can be acquired without blocking, does so exclusively and
-  // returns `true`. Otherwise, returns `false`. Returns `true` with high
-  // probability if the `Mutex` was free.
-  bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true);
-
-  // Mutex::AssertHeld()
-  //
-  // Require that the mutex be held exclusively (write mode) by this thread.
-  //
-  // If the mutex is not currently held by this thread, this function may report
-  // an error (typically by crashing with a diagnostic) or it may do nothing.
-  // This function is intended only as a tool to assist debugging; it doesn't
-  // guarantee correctness.
-  void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK();
-
-  // ---------------------------------------------------------------------------
-  // Reader-Writer Locking
-  // ---------------------------------------------------------------------------
-
-  // A Mutex can also be used as a starvation-free reader-writer lock.
-  // Neither read-locks nor write-locks are reentrant/recursive to avoid
-  // potential client programming errors.
-  //
-  // The Mutex API provides `Writer*()` aliases for the existing `Lock()`,
-  // `Unlock()` and `TryLock()` methods for use within applications mixing
-  // reader/writer locks. Using `Reader*()` and `Writer*()` operations in this
-  // manner can make locking behavior clearer when mixing read and write modes.
-  //
-  // Introducing reader locks necessarily complicates the `Mutex` state
-  // machine somewhat. The table below illustrates the allowed state transitions
-  // of a mutex in such cases. Note that ReaderLock() may block even if the lock
-  // is held in shared mode; this occurs when another thread is blocked on a
-  // call to WriterLock().
-  //
-  // ---------------------------------------------------------------------------
-  //     Operation: WriterLock() Unlock()  ReaderLock()           ReaderUnlock()
-  // ---------------------------------------------------------------------------
-  // State
-  // ---------------------------------------------------------------------------
-  // Free           Exclusive    invalid   Shared(1)              invalid
-  // Shared(1)      blocks       invalid   Shared(2) or blocks    Free
-  // Shared(n) n>1  blocks       invalid   Shared(n+1) or blocks  Shared(n-1)
-  // Exclusive      blocks       Free      blocks                 invalid
-  // ---------------------------------------------------------------------------
-  //
-  // In comments below, "shared" refers to a state of Shared(n) for any n > 0.
-
-  // Mutex::ReaderLock()
-  //
-  // Blocks the calling thread, if necessary, until this `Mutex` is either free,
-  // or in shared mode, and then acquires a share of it. Note that
-  // `ReaderLock()` will block if some other thread has an exclusive/writer lock
-  // on the mutex.
-
-  void ReaderLock() ABSL_SHARED_LOCK_FUNCTION();
-
-  // Mutex::ReaderUnlock()
-  //
-  // Releases a read share of this `Mutex`. `ReaderUnlock` may return a mutex to
-  // the free state if this thread holds the last reader lock on the mutex. Note
-  // that you cannot call `ReaderUnlock()` on a mutex held in write mode.
-  void ReaderUnlock() ABSL_UNLOCK_FUNCTION();
-
-  // Mutex::ReaderTryLock()
-  //
-  // If the mutex can be acquired without blocking, acquires this mutex for
-  // shared access and returns `true`. Otherwise, returns `false`. Returns
-  // `true` with high probability if the `Mutex` was free or shared.
-  bool ReaderTryLock() ABSL_SHARED_TRYLOCK_FUNCTION(true);
-
-  // Mutex::AssertReaderHeld()
-  //
-  // Require that the mutex be held at least in shared mode (read mode) by this
-  // thread.
-  //
-  // If the mutex is not currently held by this thread, this function may report
-  // an error (typically by crashing with a diagnostic) or it may do nothing.
-  // This function is intended only as a tool to assist debugging; it doesn't
-  // guarantee correctness.
-  void AssertReaderHeld() const ABSL_ASSERT_SHARED_LOCK();
-
-  // Mutex::WriterLock()
-  // Mutex::WriterUnlock()
-  // Mutex::WriterTryLock()
-  //
-  // Aliases for `Mutex::Lock()`, `Mutex::Unlock()`, and `Mutex::TryLock()`.
-  //
-  // These methods may be used (along with the complementary `Reader*()`
-  // methods) to distingish simple exclusive `Mutex` usage (`Lock()`,
-  // etc.) from reader/writer lock usage.
-  void WriterLock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { this->Lock(); }
-
-  void WriterUnlock() ABSL_UNLOCK_FUNCTION() { this->Unlock(); }
-
-  bool WriterTryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
-    return this->TryLock();
-  }
-
-  // ---------------------------------------------------------------------------
-  // Conditional Critical Regions
-  // ---------------------------------------------------------------------------
-
-  // Conditional usage of a `Mutex` can occur using two distinct paradigms:
-  //
-  //   * Use of `Mutex` member functions with `Condition` objects.
-  //   * Use of the separate `CondVar` abstraction.
-  //
-  // In general, prefer use of `Condition` and the `Mutex` member functions
-  // listed below over `CondVar`. When there are multiple threads waiting on
-  // distinctly different conditions, however, a battery of `CondVar`s may be
-  // more efficient. This section discusses use of `Condition` objects.
-  //
-  // `Mutex` contains member functions for performing lock operations only under
-  // certain conditions, of class `Condition`. For correctness, the `Condition`
-  // must return a boolean that is a pure function, only of state protected by
-  // the `Mutex`. The condition must be invariant w.r.t. environmental state
-  // such as thread, cpu id, or time, and must be `noexcept`. The condition will
-  // always be invoked with the mutex held in at least read mode, so you should
-  // not block it for long periods or sleep it on a timer.
-  //
-  // Since a condition must not depend directly on the current time, use
-  // `*WithTimeout()` member function variants to make your condition
-  // effectively true after a given duration, or `*WithDeadline()` variants to
-  // make your condition effectively true after a given time.
-  //
-  // The condition function should have no side-effects aside from debug
-  // logging; as a special exception, the function may acquire other mutexes
-  // provided it releases all those that it acquires.  (This exception was
-  // required to allow logging.)
-
-  // Mutex::Await()
-  //
-  // Unlocks this `Mutex` and blocks until simultaneously both `cond` is `true`
-  // and this `Mutex` can be reacquired, then reacquires this `Mutex` in the
-  // same mode in which it was previously held. If the condition is initially
-  // `true`, `Await()` *may* skip the release/re-acquire step.
-  //
-  // `Await()` requires that this thread holds this `Mutex` in some mode.
-  void Await(const Condition &cond);
-
-  // Mutex::LockWhen()
-  // Mutex::ReaderLockWhen()
-  // Mutex::WriterLockWhen()
-  //
-  // Blocks until simultaneously both `cond` is `true` and this `Mutex` can
-  // be acquired, then atomically acquires this `Mutex`. `LockWhen()` is
-  // logically equivalent to `*Lock(); Await();` though they may have different
-  // performance characteristics.
-  void LockWhen(const Condition &cond) ABSL_EXCLUSIVE_LOCK_FUNCTION();
-
-  void ReaderLockWhen(const Condition &cond) ABSL_SHARED_LOCK_FUNCTION();
-
-  void WriterLockWhen(const Condition &cond) ABSL_EXCLUSIVE_LOCK_FUNCTION() {
-    this->LockWhen(cond);
-  }
-
-  // ---------------------------------------------------------------------------
-  // Mutex Variants with Timeouts/Deadlines
-  // ---------------------------------------------------------------------------
-
-  // Mutex::AwaitWithTimeout()
-  // Mutex::AwaitWithDeadline()
-  //
-  // Unlocks this `Mutex` and blocks until simultaneously:
-  //   - either `cond` is true or the {timeout has expired, deadline has passed}
-  //     and
-  //   - this `Mutex` can be reacquired,
-  // then reacquire this `Mutex` in the same mode in which it was previously
-  // held, returning `true` iff `cond` is `true` on return.
-  //
-  // If the condition is initially `true`, the implementation *may* skip the
-  // release/re-acquire step and return immediately.
-  //
-  // Deadlines in the past are equivalent to an immediate deadline.
-  // Negative timeouts are equivalent to a zero timeout.
-  //
-  // This method requires that this thread holds this `Mutex` in some mode.
-  bool AwaitWithTimeout(const Condition &cond, absl::Duration timeout);
-
-  bool AwaitWithDeadline(const Condition &cond, absl::Time deadline);
-
-  // Mutex::LockWhenWithTimeout()
-  // Mutex::ReaderLockWhenWithTimeout()
-  // Mutex::WriterLockWhenWithTimeout()
-  //
-  // Blocks until simultaneously both:
-  //   - either `cond` is `true` or the timeout has expired, and
-  //   - this `Mutex` can be acquired,
-  // then atomically acquires this `Mutex`, returning `true` iff `cond` is
-  // `true` on return.
-  //
-  // Negative timeouts are equivalent to a zero timeout.
-  bool LockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION();
-  bool ReaderLockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
-      ABSL_SHARED_LOCK_FUNCTION();
-  bool WriterLockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION() {
-    return this->LockWhenWithTimeout(cond, timeout);
-  }
-
-  // Mutex::LockWhenWithDeadline()
-  // Mutex::ReaderLockWhenWithDeadline()
-  // Mutex::WriterLockWhenWithDeadline()
-  //
-  // Blocks until simultaneously both:
-  //   - either `cond` is `true` or the deadline has been passed, and
-  //   - this `Mutex` can be acquired,
-  // then atomically acquires this Mutex, returning `true` iff `cond` is `true`
-  // on return.
-  //
-  // Deadlines in the past are equivalent to an immediate deadline.
-  bool LockWhenWithDeadline(const Condition &cond, absl::Time deadline)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION();
-  bool ReaderLockWhenWithDeadline(const Condition &cond, absl::Time deadline)
-      ABSL_SHARED_LOCK_FUNCTION();
-  bool WriterLockWhenWithDeadline(const Condition &cond, absl::Time deadline)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION() {
-    return this->LockWhenWithDeadline(cond, deadline);
-  }
-
-  // ---------------------------------------------------------------------------
-  // Debug Support: Invariant Checking, Deadlock Detection, Logging.
-  // ---------------------------------------------------------------------------
-
-  // Mutex::EnableInvariantDebugging()
-  //
-  // If `invariant`!=null and if invariant debugging has been enabled globally,
-  // cause `(*invariant)(arg)` to be called at moments when the invariant for
-  // this `Mutex` should hold (for example: just after acquire, just before
-  // release).
-  //
-  // The routine `invariant` should have no side-effects since it is not
-  // guaranteed how many times it will be called; it should check the invariant
-  // and crash if it does not hold. Enabling global invariant debugging may
-  // substantially reduce `Mutex` performance; it should be set only for
-  // non-production runs.  Optimization options may also disable invariant
-  // checks.
-  void EnableInvariantDebugging(void (*invariant)(void *), void *arg);
-
-  // Mutex::EnableDebugLog()
-  //
-  // Cause all subsequent uses of this `Mutex` to be logged via
-  // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if no previous
-  // call to `EnableInvariantDebugging()` or `EnableDebugLog()` has been made.
-  //
-  // Note: This method substantially reduces `Mutex` performance.
-  void EnableDebugLog(const char *name);
-
-  // Deadlock detection
-
-  // Mutex::ForgetDeadlockInfo()
-  //
-  // Forget any deadlock-detection information previously gathered
-  // about this `Mutex`. Call this method in debug mode when the lock ordering
-  // of a `Mutex` changes.
-  void ForgetDeadlockInfo();
-
-  // Mutex::AssertNotHeld()
-  //
-  // Return immediately if this thread does not hold this `Mutex` in any
-  // mode; otherwise, may report an error (typically by crashing with a
-  // diagnostic), or may return immediately.
-  //
-  // Currently this check is performed only if all of:
-  //    - in debug mode
-  //    - SetMutexDeadlockDetectionMode() has been set to kReport or kAbort
-  //    - number of locks concurrently held by this thread is not large.
-  // are true.
-  void AssertNotHeld() const;
-
-  // Special cases.
-
-  // A `MuHow` is a constant that indicates how a lock should be acquired.
-  // Internal implementation detail.  Clients should ignore.
-  typedef const struct MuHowS *MuHow;
-
-  // Mutex::InternalAttemptToUseMutexInFatalSignalHandler()
-  //
-  // Causes the `Mutex` implementation to prepare itself for re-entry caused by
-  // future use of `Mutex` within a fatal signal handler. This method is
-  // intended for use only for last-ditch attempts to log crash information.
-  // It does not guarantee that attempts to use Mutexes within the handler will
-  // not deadlock; it merely makes other faults less likely.
-  //
-  // WARNING:  This routine must be invoked from a signal handler, and the
-  // signal handler must either loop forever or terminate the process.
-  // Attempts to return from (or `longjmp` out of) the signal handler once this
-  // call has been made may cause arbitrary program behaviour including
-  // crashes and deadlocks.
-  static void InternalAttemptToUseMutexInFatalSignalHandler();
-
- private:
-  std::atomic<intptr_t> mu_;  // The Mutex state.
-
-  // Post()/Wait() versus associated PerThreadSem; in class for required
-  // friendship with PerThreadSem.
-  static void IncrementSynchSem(Mutex *mu, base_internal::PerThreadSynch *w);
-  static bool DecrementSynchSem(Mutex *mu, base_internal::PerThreadSynch *w,
-                                synchronization_internal::KernelTimeout t);
-
-  // slow path acquire
-  void LockSlowLoop(SynchWaitParams *waitp, int flags);
-  // wrappers around LockSlowLoop()
-  bool LockSlowWithDeadline(MuHow how, const Condition *cond,
-                            synchronization_internal::KernelTimeout t,
-                            int flags);
-  void LockSlow(MuHow how, const Condition *cond,
-                int flags) ABSL_ATTRIBUTE_COLD;
-  // slow path release
-  void UnlockSlow(SynchWaitParams *waitp) ABSL_ATTRIBUTE_COLD;
-  // Common code between Await() and AwaitWithTimeout/Deadline()
-  bool AwaitCommon(const Condition &cond,
-                   synchronization_internal::KernelTimeout t);
-  // Attempt to remove thread s from queue.
-  void TryRemove(base_internal::PerThreadSynch *s);
-  // Block a thread on mutex.
-  void Block(base_internal::PerThreadSynch *s);
-  // Wake a thread; return successor.
-  base_internal::PerThreadSynch *Wakeup(base_internal::PerThreadSynch *w);
-
-  friend class CondVar;   // for access to Trans()/Fer().
-  void Trans(MuHow how);  // used for CondVar->Mutex transfer
-  void Fer(
-      base_internal::PerThreadSynch *w);  // used for CondVar->Mutex transfer
-
-  // Catch the error of writing Mutex when intending MutexLock.
-  Mutex(const volatile Mutex * /*ignored*/) {}  // NOLINT(runtime/explicit)
-
-  Mutex(const Mutex&) = delete;
-  Mutex& operator=(const Mutex&) = delete;
-};
-
-// -----------------------------------------------------------------------------
-// Mutex RAII Wrappers
-// -----------------------------------------------------------------------------
-
-// MutexLock
-//
-// `MutexLock` is a helper class, which acquires and releases a `Mutex` via
-// RAII.
-//
-// Example:
-//
-// Class Foo {
-//  public:
-//   Foo::Bar* Baz() {
-//     MutexLock lock(&mu_);
-//     ...
-//     return bar;
-//   }
-//
-// private:
-//   Mutex mu_;
-// };
-class ABSL_SCOPED_LOCKABLE MutexLock {
- public:
-  // Constructors
-
-  // Calls `mu->Lock()` and returns when that call returns. That is, `*mu` is
-  // guaranteed to be locked when this object is constructed. Requires that
-  // `mu` be dereferenceable.
-  explicit MutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
-    this->mu_->Lock();
-  }
-
-  // Like above, but calls `mu->LockWhen(cond)` instead. That is, in addition to
-  // the above, the condition given by `cond` is also guaranteed to hold when
-  // this object is constructed.
-  explicit MutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    this->mu_->LockWhen(cond);
-  }
-
-  MutexLock(const MutexLock &) = delete;  // NOLINT(runtime/mutex)
-  MutexLock(MutexLock&&) = delete;  // NOLINT(runtime/mutex)
-  MutexLock& operator=(const MutexLock&) = delete;
-  MutexLock& operator=(MutexLock&&) = delete;
-
-  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->Unlock(); }
-
- private:
-  Mutex *const mu_;
-};
-
-// ReaderMutexLock
-//
-// The `ReaderMutexLock` is a helper class, like `MutexLock`, which acquires and
-// releases a shared lock on a `Mutex` via RAII.
-class ABSL_SCOPED_LOCKABLE ReaderMutexLock {
- public:
-  explicit ReaderMutexLock(Mutex *mu) ABSL_SHARED_LOCK_FUNCTION(mu) : mu_(mu) {
-    mu->ReaderLock();
-  }
-
-  explicit ReaderMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_SHARED_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    mu->ReaderLockWhen(cond);
-  }
-
-  ReaderMutexLock(const ReaderMutexLock&) = delete;
-  ReaderMutexLock(ReaderMutexLock&&) = delete;
-  ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
-  ReaderMutexLock& operator=(ReaderMutexLock&&) = delete;
-
-  ~ReaderMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->ReaderUnlock(); }
-
- private:
-  Mutex *const mu_;
-};
-
-// WriterMutexLock
-//
-// The `WriterMutexLock` is a helper class, like `MutexLock`, which acquires and
-// releases a write (exclusive) lock on a `Mutex` via RAII.
-class ABSL_SCOPED_LOCKABLE WriterMutexLock {
- public:
-  explicit WriterMutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    mu->WriterLock();
-  }
-
-  explicit WriterMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    mu->WriterLockWhen(cond);
-  }
-
-  WriterMutexLock(const WriterMutexLock&) = delete;
-  WriterMutexLock(WriterMutexLock&&) = delete;
-  WriterMutexLock& operator=(const WriterMutexLock&) = delete;
-  WriterMutexLock& operator=(WriterMutexLock&&) = delete;
-
-  ~WriterMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->WriterUnlock(); }
-
- private:
-  Mutex *const mu_;
-};
-
-// -----------------------------------------------------------------------------
-// Condition
-// -----------------------------------------------------------------------------
-//
-// As noted above, `Mutex` contains a number of member functions which take a
-// `Condition` as an argument; clients can wait for conditions to become `true`
-// before attempting to acquire the mutex. These sections are known as
-// "condition critical" sections. To use a `Condition`, you simply need to
-// construct it, and use within an appropriate `Mutex` member function;
-// everything else in the `Condition` class is an implementation detail.
-//
-// A `Condition` is specified as a function pointer which returns a boolean.
-// `Condition` functions should be pure functions -- their results should depend
-// only on passed arguments, should not consult any external state (such as
-// clocks), and should have no side-effects, aside from debug logging. Any
-// objects that the function may access should be limited to those which are
-// constant while the mutex is blocked on the condition (e.g. a stack variable),
-// or objects of state protected explicitly by the mutex.
-//
-// No matter which construction is used for `Condition`, the underlying
-// function pointer / functor / callable must not throw any
-// exceptions. Correctness of `Mutex` / `Condition` is not guaranteed in
-// the face of a throwing `Condition`. (When Abseil is allowed to depend
-// on C++17, these function pointers will be explicitly marked
-// `noexcept`; until then this requirement cannot be enforced in the
-// type system.)
-//
-// Note: to use a `Condition`, you need only construct it and pass it to a
-// suitable `Mutex' member function, such as `Mutex::Await()`, or to the
-// constructor of one of the scope guard classes.
-//
-// Example using LockWhen/Unlock:
-//
-//   // assume count_ is not internal reference count
-//   int count_ ABSL_GUARDED_BY(mu_);
-//   Condition count_is_zero(+[](int *count) { return *count == 0; }, &count_);
-//
-//   mu_.LockWhen(count_is_zero);
-//   // ...
-//   mu_.Unlock();
-//
-// Example using a scope guard:
-//
-//   {
-//     MutexLock lock(&mu_, count_is_zero);
-//     // ...
-//   }
-//
-// When multiple threads are waiting on exactly the same condition, make sure
-// that they are constructed with the same parameters (same pointer to function
-// + arg, or same pointer to object + method), so that the mutex implementation
-// can avoid redundantly evaluating the same condition for each thread.
-class Condition {
- public:
-  // A Condition that returns the result of "(*func)(arg)"
-  Condition(bool (*func)(void *), void *arg);
-
-  // Templated version for people who are averse to casts.
-  //
-  // To use a lambda, prepend it with unary plus, which converts the lambda
-  // into a function pointer:
-  //     Condition(+[](T* t) { return ...; }, arg).
-  //
-  // Note: lambdas in this case must contain no bound variables.
-  //
-  // See class comment for performance advice.
-  template<typename T>
-  Condition(bool (*func)(T *), T *arg);
-
-  // Templated version for invoking a method that returns a `bool`.
-  //
-  // `Condition(object, &Class::Method)` constructs a `Condition` that evaluates
-  // `object->Method()`.
-  //
-  // Implementation Note: `absl::internal::identity` is used to allow methods to
-  // come from base classes. A simpler signature like
-  // `Condition(T*, bool (T::*)())` does not suffice.
-  template<typename T>
-  Condition(T *object, bool (absl::internal::identity<T>::type::* method)());
-
-  // Same as above, for const members
-  template<typename T>
-  Condition(const T *object,
-            bool (absl::internal::identity<T>::type::* method)() const);
-
-  // A Condition that returns the value of `*cond`
-  explicit Condition(const bool *cond);
-
-  // Templated version for invoking a functor that returns a `bool`.
-  // This approach accepts pointers to non-mutable lambdas, `std::function`,
-  // the result of` std::bind` and user-defined functors that define
-  // `bool F::operator()() const`.
-  //
-  // Example:
-  //
-  //   auto reached = [this, current]() {
-  //     mu_.AssertReaderHeld();                // For annotalysis.
-  //     return processed_ >= current;
-  //   };
-  //   mu_.Await(Condition(&reached));
-  //
-  // NOTE: never use "mu_.AssertHeld()" instead of "mu_.AssertReaderHeld()" in
-  // the lambda as it may be called when the mutex is being unlocked from a
-  // scope holding only a reader lock, which will make the assertion not
-  // fulfilled and crash the binary.
-
-  // See class comment for performance advice. In particular, if there
-  // might be more than one waiter for the same condition, make sure
-  // that all waiters construct the condition with the same pointers.
-
-  // Implementation note: The second template parameter ensures that this
-  // constructor doesn't participate in overload resolution if T doesn't have
-  // `bool operator() const`.
-  template <typename T, typename E = decltype(
-      static_cast<bool (T::*)() const>(&T::operator()))>
-  explicit Condition(const T *obj)
-      : Condition(obj, static_cast<bool (T::*)() const>(&T::operator())) {}
-
-  // A Condition that always returns `true`.
-  static const Condition kTrue;
-
-  // Evaluates the condition.
-  bool Eval() const;
-
-  // Returns `true` if the two conditions are guaranteed to return the same
-  // value if evaluated at the same time, `false` if the evaluation *may* return
-  // different results.
-  //
-  // Two `Condition` values are guaranteed equal if both their `func` and `arg`
-  // components are the same. A null pointer is equivalent to a `true`
-  // condition.
-  static bool GuaranteedEqual(const Condition *a, const Condition *b);
-
- private:
-  typedef bool (*InternalFunctionType)(void * arg);
-  typedef bool (Condition::*InternalMethodType)();
-  typedef bool (*InternalMethodCallerType)(void * arg,
-                                           InternalMethodType internal_method);
-
-  bool (*eval_)(const Condition*);  // Actual evaluator
-  InternalFunctionType function_;   // function taking pointer returning bool
-  InternalMethodType method_;       // method returning bool
-  void *arg_;                       // arg of function_ or object of method_
-
-  Condition();        // null constructor used only to create kTrue
-
-  // Various functions eval_ can point to:
-  static bool CallVoidPtrFunction(const Condition*);
-  template <typename T> static bool CastAndCallFunction(const Condition* c);
-  template <typename T> static bool CastAndCallMethod(const Condition* c);
-};
-
-// -----------------------------------------------------------------------------
-// CondVar
-// -----------------------------------------------------------------------------
-//
-// A condition variable, reflecting state evaluated separately outside of the
-// `Mutex` object, which can be signaled to wake callers.
-// This class is not normally needed; use `Mutex` member functions such as
-// `Mutex::Await()` and intrinsic `Condition` abstractions. In rare cases
-// with many threads and many conditions, `CondVar` may be faster.
-//
-// The implementation may deliver signals to any condition variable at
-// any time, even when no call to `Signal()` or `SignalAll()` is made; as a
-// result, upon being awoken, you must check the logical condition you have
-// been waiting upon.
-//
-// Examples:
-//
-// Usage for a thread waiting for some condition C protected by mutex mu:
-//       mu.Lock();
-//       while (!C) { cv->Wait(&mu); }        // releases and reacquires mu
-//       //  C holds; process data
-//       mu.Unlock();
-//
-// Usage to wake T is:
-//       mu.Lock();
-//       // process data, possibly establishing C
-//       if (C) { cv->Signal(); }
-//       mu.Unlock();
-//
-// If C may be useful to more than one waiter, use `SignalAll()` instead of
-// `Signal()`.
-//
-// With this implementation it is efficient to use `Signal()/SignalAll()` inside
-// the locked region; this usage can make reasoning about your program easier.
-//
-class CondVar {
- public:
-  // A `CondVar` allocated on the heap or on the stack can use the this
-  // constructor.
-  CondVar();
-  ~CondVar();
-
-  // CondVar::Wait()
-  //
-  // Atomically releases a `Mutex` and blocks on this condition variable.
-  // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
-  // spurious wakeup), then reacquires the `Mutex` and returns.
-  //
-  // Requires and ensures that the current thread holds the `Mutex`.
-  void Wait(Mutex *mu);
-
-  // CondVar::WaitWithTimeout()
-  //
-  // Atomically releases a `Mutex` and blocks on this condition variable.
-  // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
-  // spurious wakeup), or until the timeout has expired, then reacquires
-  // the `Mutex` and returns.
-  //
-  // Returns true if the timeout has expired without this `CondVar`
-  // being signalled in any manner. If both the timeout has expired
-  // and this `CondVar` has been signalled, the implementation is free
-  // to return `true` or `false`.
-  //
-  // Requires and ensures that the current thread holds the `Mutex`.
-  bool WaitWithTimeout(Mutex *mu, absl::Duration timeout);
-
-  // CondVar::WaitWithDeadline()
-  //
-  // Atomically releases a `Mutex` and blocks on this condition variable.
-  // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
-  // spurious wakeup), or until the deadline has passed, then reacquires
-  // the `Mutex` and returns.
-  //
-  // Deadlines in the past are equivalent to an immediate deadline.
-  //
-  // Returns true if the deadline has passed without this `CondVar`
-  // being signalled in any manner. If both the deadline has passed
-  // and this `CondVar` has been signalled, the implementation is free
-  // to return `true` or `false`.
-  //
-  // Requires and ensures that the current thread holds the `Mutex`.
-  bool WaitWithDeadline(Mutex *mu, absl::Time deadline);
-
-  // CondVar::Signal()
-  //
-  // Signal this `CondVar`; wake at least one waiter if one exists.
-  void Signal();
-
-  // CondVar::SignalAll()
-  //
-  // Signal this `CondVar`; wake all waiters.
-  void SignalAll();
-
-  // CondVar::EnableDebugLog()
-  //
-  // Causes all subsequent uses of this `CondVar` to be logged via
-  // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if `name != 0`.
-  // Note: this method substantially reduces `CondVar` performance.
-  void EnableDebugLog(const char *name);
-
- private:
-  bool WaitCommon(Mutex *mutex, synchronization_internal::KernelTimeout t);
-  void Remove(base_internal::PerThreadSynch *s);
-  void Wakeup(base_internal::PerThreadSynch *w);
-  std::atomic<intptr_t> cv_;  // Condition variable state.
-  CondVar(const CondVar&) = delete;
-  CondVar& operator=(const CondVar&) = delete;
-};
-
-
-// Variants of MutexLock.
-//
-// If you find yourself using one of these, consider instead using
-// Mutex::Unlock() and/or if-statements for clarity.
-
-// MutexLockMaybe
-//
-// MutexLockMaybe is like MutexLock, but is a no-op when mu is null.
-class ABSL_SCOPED_LOCKABLE MutexLockMaybe {
- public:
-  explicit MutexLockMaybe(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    if (this->mu_ != nullptr) {
-      this->mu_->Lock();
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class Condition;
+    struct SynchWaitParams;
+
+    // -----------------------------------------------------------------------------
+    // Mutex
+    // -----------------------------------------------------------------------------
+    //
+    // A `Mutex` is a non-reentrant (aka non-recursive) Mutually Exclusive lock
+    // on some resource, typically a variable or data structure with associated
+    // invariants. Proper usage of mutexes prevents concurrent access by different
+    // threads to the same resource.
+    //
+    // A `Mutex` has two basic operations: `Mutex::Lock()` and `Mutex::Unlock()`.
+    // The `Lock()` operation *acquires* a `Mutex` (in a state known as an
+    // *exclusive* -- or write -- lock), while the `Unlock()` operation *releases* a
+    // Mutex. During the span of time between the Lock() and Unlock() operations,
+    // a mutex is said to be *held*. By design all mutexes support exclusive/write
+    // locks, as this is the most common way to use a mutex.
+    //
+    // The `Mutex` state machine for basic lock/unlock operations is quite simple:
+    //
+    // |                | Lock()     | Unlock() |
+    // |----------------+------------+----------|
+    // | Free           | Exclusive  | invalid  |
+    // | Exclusive      | blocks     | Free     |
+    //
+    // Attempts to `Unlock()` must originate from the thread that performed the
+    // corresponding `Lock()` operation.
+    //
+    // An "invalid" operation is disallowed by the API. The `Mutex` implementation
+    // is allowed to do anything on an invalid call, including but not limited to
+    // crashing with a useful error message, silently succeeding, or corrupting
+    // data structures. In debug mode, the implementation attempts to crash with a
+    // useful error message.
+    //
+    // `Mutex` is not guaranteed to be "fair" in prioritizing waiting threads; it
+    // is, however, approximately fair over long periods, and starvation-free for
+    // threads at the same priority.
+    //
+    // The lock/unlock primitives are now annotated with lock annotations
+    // defined in (base/thread_annotations.h). When writing multi-threaded code,
+    // you should use lock annotations whenever possible to document your lock
+    // synchronization policy. Besides acting as documentation, these annotations
+    // also help compilers or static analysis tools to identify and warn about
+    // issues that could potentially result in race conditions and deadlocks.
+    //
+    // For more information about the lock annotations, please see
+    // [Thread Safety Analysis](http://clang.llvm.org/docs/ThreadSafetyAnalysis.html)
+    // in the Clang documentation.
+    //
+    // See also `MutexLock`, below, for scoped `Mutex` acquisition.
+
+    class ABSL_LOCKABLE Mutex
+    {
+    public:
+        // Creates a `Mutex` that is not held by anyone. This constructor is
+        // typically used for Mutexes allocated on the heap or the stack.
+        //
+        // To create `Mutex` instances with static storage duration
+        // (e.g. a namespace-scoped or global variable), see
+        // `Mutex::Mutex(absl::kConstInit)` below instead.
+        Mutex();
+
+        // Creates a mutex with static storage duration.  A global variable
+        // constructed this way avoids the lifetime issues that can occur on program
+        // startup and shutdown.  (See absl/base/const_init.h.)
+        //
+        // For Mutexes allocated on the heap and stack, instead use the default
+        // constructor, which can interact more fully with the thread sanitizer.
+        //
+        // Example usage:
+        //   namespace foo {
+        //   ABSL_CONST_INIT absl::Mutex mu(absl::kConstInit);
+        //   }
+        explicit constexpr Mutex(absl::ConstInitType);
+
+        ~Mutex();
+
+        // Mutex::Lock()
+        //
+        // Blocks the calling thread, if necessary, until this `Mutex` is free, and
+        // then acquires it exclusively. (This lock is also known as a "write lock.")
+        void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION();
+
+        // Mutex::Unlock()
+        //
+        // Releases this `Mutex` and returns it from the exclusive/write state to the
+        // free state. Calling thread must hold the `Mutex` exclusively.
+        void Unlock() ABSL_UNLOCK_FUNCTION();
+
+        // Mutex::TryLock()
+        //
+        // If the mutex can be acquired without blocking, does so exclusively and
+        // returns `true`. Otherwise, returns `false`. Returns `true` with high
+        // probability if the `Mutex` was free.
+        bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true);
+
+        // Mutex::AssertHeld()
+        //
+        // Require that the mutex be held exclusively (write mode) by this thread.
+        //
+        // If the mutex is not currently held by this thread, this function may report
+        // an error (typically by crashing with a diagnostic) or it may do nothing.
+        // This function is intended only as a tool to assist debugging; it doesn't
+        // guarantee correctness.
+        void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK();
+
+        // ---------------------------------------------------------------------------
+        // Reader-Writer Locking
+        // ---------------------------------------------------------------------------
+
+        // A Mutex can also be used as a starvation-free reader-writer lock.
+        // Neither read-locks nor write-locks are reentrant/recursive to avoid
+        // potential client programming errors.
+        //
+        // The Mutex API provides `Writer*()` aliases for the existing `Lock()`,
+        // `Unlock()` and `TryLock()` methods for use within applications mixing
+        // reader/writer locks. Using `Reader*()` and `Writer*()` operations in this
+        // manner can make locking behavior clearer when mixing read and write modes.
+        //
+        // Introducing reader locks necessarily complicates the `Mutex` state
+        // machine somewhat. The table below illustrates the allowed state transitions
+        // of a mutex in such cases. Note that ReaderLock() may block even if the lock
+        // is held in shared mode; this occurs when another thread is blocked on a
+        // call to WriterLock().
+        //
+        // ---------------------------------------------------------------------------
+        //     Operation: WriterLock() Unlock()  ReaderLock()           ReaderUnlock()
+        // ---------------------------------------------------------------------------
+        // State
+        // ---------------------------------------------------------------------------
+        // Free           Exclusive    invalid   Shared(1)              invalid
+        // Shared(1)      blocks       invalid   Shared(2) or blocks    Free
+        // Shared(n) n>1  blocks       invalid   Shared(n+1) or blocks  Shared(n-1)
+        // Exclusive      blocks       Free      blocks                 invalid
+        // ---------------------------------------------------------------------------
+        //
+        // In comments below, "shared" refers to a state of Shared(n) for any n > 0.
+
+        // Mutex::ReaderLock()
+        //
+        // Blocks the calling thread, if necessary, until this `Mutex` is either free,
+        // or in shared mode, and then acquires a share of it. Note that
+        // `ReaderLock()` will block if some other thread has an exclusive/writer lock
+        // on the mutex.
+
+        void ReaderLock() ABSL_SHARED_LOCK_FUNCTION();
+
+        // Mutex::ReaderUnlock()
+        //
+        // Releases a read share of this `Mutex`. `ReaderUnlock` may return a mutex to
+        // the free state if this thread holds the last reader lock on the mutex. Note
+        // that you cannot call `ReaderUnlock()` on a mutex held in write mode.
+        void ReaderUnlock() ABSL_UNLOCK_FUNCTION();
+
+        // Mutex::ReaderTryLock()
+        //
+        // If the mutex can be acquired without blocking, acquires this mutex for
+        // shared access and returns `true`. Otherwise, returns `false`. Returns
+        // `true` with high probability if the `Mutex` was free or shared.
+        bool ReaderTryLock() ABSL_SHARED_TRYLOCK_FUNCTION(true);
+
+        // Mutex::AssertReaderHeld()
+        //
+        // Require that the mutex be held at least in shared mode (read mode) by this
+        // thread.
+        //
+        // If the mutex is not currently held by this thread, this function may report
+        // an error (typically by crashing with a diagnostic) or it may do nothing.
+        // This function is intended only as a tool to assist debugging; it doesn't
+        // guarantee correctness.
+        void AssertReaderHeld() const ABSL_ASSERT_SHARED_LOCK();
+
+        // Mutex::WriterLock()
+        // Mutex::WriterUnlock()
+        // Mutex::WriterTryLock()
+        //
+        // Aliases for `Mutex::Lock()`, `Mutex::Unlock()`, and `Mutex::TryLock()`.
+        //
+        // These methods may be used (along with the complementary `Reader*()`
+        // methods) to distingish simple exclusive `Mutex` usage (`Lock()`,
+        // etc.) from reader/writer lock usage.
+        void WriterLock() ABSL_EXCLUSIVE_LOCK_FUNCTION()
+        {
+            this->Lock();
+        }
+
+        void WriterUnlock() ABSL_UNLOCK_FUNCTION()
+        {
+            this->Unlock();
+        }
+
+        bool WriterTryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true)
+        {
+            return this->TryLock();
+        }
+
+        // ---------------------------------------------------------------------------
+        // Conditional Critical Regions
+        // ---------------------------------------------------------------------------
+
+        // Conditional usage of a `Mutex` can occur using two distinct paradigms:
+        //
+        //   * Use of `Mutex` member functions with `Condition` objects.
+        //   * Use of the separate `CondVar` abstraction.
+        //
+        // In general, prefer use of `Condition` and the `Mutex` member functions
+        // listed below over `CondVar`. When there are multiple threads waiting on
+        // distinctly different conditions, however, a battery of `CondVar`s may be
+        // more efficient. This section discusses use of `Condition` objects.
+        //
+        // `Mutex` contains member functions for performing lock operations only under
+        // certain conditions, of class `Condition`. For correctness, the `Condition`
+        // must return a boolean that is a pure function, only of state protected by
+        // the `Mutex`. The condition must be invariant w.r.t. environmental state
+        // such as thread, cpu id, or time, and must be `noexcept`. The condition will
+        // always be invoked with the mutex held in at least read mode, so you should
+        // not block it for long periods or sleep it on a timer.
+        //
+        // Since a condition must not depend directly on the current time, use
+        // `*WithTimeout()` member function variants to make your condition
+        // effectively true after a given duration, or `*WithDeadline()` variants to
+        // make your condition effectively true after a given time.
+        //
+        // The condition function should have no side-effects aside from debug
+        // logging; as a special exception, the function may acquire other mutexes
+        // provided it releases all those that it acquires.  (This exception was
+        // required to allow logging.)
+
+        // Mutex::Await()
+        //
+        // Unlocks this `Mutex` and blocks until simultaneously both `cond` is `true`
+        // and this `Mutex` can be reacquired, then reacquires this `Mutex` in the
+        // same mode in which it was previously held. If the condition is initially
+        // `true`, `Await()` *may* skip the release/re-acquire step.
+        //
+        // `Await()` requires that this thread holds this `Mutex` in some mode.
+        void Await(const Condition& cond);
+
+        // Mutex::LockWhen()
+        // Mutex::ReaderLockWhen()
+        // Mutex::WriterLockWhen()
+        //
+        // Blocks until simultaneously both `cond` is `true` and this `Mutex` can
+        // be acquired, then atomically acquires this `Mutex`. `LockWhen()` is
+        // logically equivalent to `*Lock(); Await();` though they may have different
+        // performance characteristics.
+        void LockWhen(const Condition& cond) ABSL_EXCLUSIVE_LOCK_FUNCTION();
+
+        void ReaderLockWhen(const Condition& cond) ABSL_SHARED_LOCK_FUNCTION();
+
+        void WriterLockWhen(const Condition& cond) ABSL_EXCLUSIVE_LOCK_FUNCTION()
+        {
+            this->LockWhen(cond);
+        }
+
+        // ---------------------------------------------------------------------------
+        // Mutex Variants with Timeouts/Deadlines
+        // ---------------------------------------------------------------------------
+
+        // Mutex::AwaitWithTimeout()
+        // Mutex::AwaitWithDeadline()
+        //
+        // Unlocks this `Mutex` and blocks until simultaneously:
+        //   - either `cond` is true or the {timeout has expired, deadline has passed}
+        //     and
+        //   - this `Mutex` can be reacquired,
+        // then reacquire this `Mutex` in the same mode in which it was previously
+        // held, returning `true` iff `cond` is `true` on return.
+        //
+        // If the condition is initially `true`, the implementation *may* skip the
+        // release/re-acquire step and return immediately.
+        //
+        // Deadlines in the past are equivalent to an immediate deadline.
+        // Negative timeouts are equivalent to a zero timeout.
+        //
+        // This method requires that this thread holds this `Mutex` in some mode.
+        bool AwaitWithTimeout(const Condition& cond, absl::Duration timeout);
+
+        bool AwaitWithDeadline(const Condition& cond, absl::Time deadline);
+
+        // Mutex::LockWhenWithTimeout()
+        // Mutex::ReaderLockWhenWithTimeout()
+        // Mutex::WriterLockWhenWithTimeout()
+        //
+        // Blocks until simultaneously both:
+        //   - either `cond` is `true` or the timeout has expired, and
+        //   - this `Mutex` can be acquired,
+        // then atomically acquires this `Mutex`, returning `true` iff `cond` is
+        // `true` on return.
+        //
+        // Negative timeouts are equivalent to a zero timeout.
+        bool LockWhenWithTimeout(const Condition& cond, absl::Duration timeout)
+            ABSL_EXCLUSIVE_LOCK_FUNCTION();
+        bool ReaderLockWhenWithTimeout(const Condition& cond, absl::Duration timeout)
+            ABSL_SHARED_LOCK_FUNCTION();
+        bool WriterLockWhenWithTimeout(const Condition& cond, absl::Duration timeout)
+            ABSL_EXCLUSIVE_LOCK_FUNCTION()
+        {
+            return this->LockWhenWithTimeout(cond, timeout);
+        }
+
+        // Mutex::LockWhenWithDeadline()
+        // Mutex::ReaderLockWhenWithDeadline()
+        // Mutex::WriterLockWhenWithDeadline()
+        //
+        // Blocks until simultaneously both:
+        //   - either `cond` is `true` or the deadline has been passed, and
+        //   - this `Mutex` can be acquired,
+        // then atomically acquires this Mutex, returning `true` iff `cond` is `true`
+        // on return.
+        //
+        // Deadlines in the past are equivalent to an immediate deadline.
+        bool LockWhenWithDeadline(const Condition& cond, absl::Time deadline)
+            ABSL_EXCLUSIVE_LOCK_FUNCTION();
+        bool ReaderLockWhenWithDeadline(const Condition& cond, absl::Time deadline)
+            ABSL_SHARED_LOCK_FUNCTION();
+        bool WriterLockWhenWithDeadline(const Condition& cond, absl::Time deadline)
+            ABSL_EXCLUSIVE_LOCK_FUNCTION()
+        {
+            return this->LockWhenWithDeadline(cond, deadline);
+        }
+
+        // ---------------------------------------------------------------------------
+        // Debug Support: Invariant Checking, Deadlock Detection, Logging.
+        // ---------------------------------------------------------------------------
+
+        // Mutex::EnableInvariantDebugging()
+        //
+        // If `invariant`!=null and if invariant debugging has been enabled globally,
+        // cause `(*invariant)(arg)` to be called at moments when the invariant for
+        // this `Mutex` should hold (for example: just after acquire, just before
+        // release).
+        //
+        // The routine `invariant` should have no side-effects since it is not
+        // guaranteed how many times it will be called; it should check the invariant
+        // and crash if it does not hold. Enabling global invariant debugging may
+        // substantially reduce `Mutex` performance; it should be set only for
+        // non-production runs.  Optimization options may also disable invariant
+        // checks.
+        void EnableInvariantDebugging(void (*invariant)(void*), void* arg);
+
+        // Mutex::EnableDebugLog()
+        //
+        // Cause all subsequent uses of this `Mutex` to be logged via
+        // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if no previous
+        // call to `EnableInvariantDebugging()` or `EnableDebugLog()` has been made.
+        //
+        // Note: This method substantially reduces `Mutex` performance.
+        void EnableDebugLog(const char* name);
+
+        // Deadlock detection
+
+        // Mutex::ForgetDeadlockInfo()
+        //
+        // Forget any deadlock-detection information previously gathered
+        // about this `Mutex`. Call this method in debug mode when the lock ordering
+        // of a `Mutex` changes.
+        void ForgetDeadlockInfo();
+
+        // Mutex::AssertNotHeld()
+        //
+        // Return immediately if this thread does not hold this `Mutex` in any
+        // mode; otherwise, may report an error (typically by crashing with a
+        // diagnostic), or may return immediately.
+        //
+        // Currently this check is performed only if all of:
+        //    - in debug mode
+        //    - SetMutexDeadlockDetectionMode() has been set to kReport or kAbort
+        //    - number of locks concurrently held by this thread is not large.
+        // are true.
+        void AssertNotHeld() const;
+
+        // Special cases.
+
+        // A `MuHow` is a constant that indicates how a lock should be acquired.
+        // Internal implementation detail.  Clients should ignore.
+        typedef const struct MuHowS* MuHow;
+
+        // Mutex::InternalAttemptToUseMutexInFatalSignalHandler()
+        //
+        // Causes the `Mutex` implementation to prepare itself for re-entry caused by
+        // future use of `Mutex` within a fatal signal handler. This method is
+        // intended for use only for last-ditch attempts to log crash information.
+        // It does not guarantee that attempts to use Mutexes within the handler will
+        // not deadlock; it merely makes other faults less likely.
+        //
+        // WARNING:  This routine must be invoked from a signal handler, and the
+        // signal handler must either loop forever or terminate the process.
+        // Attempts to return from (or `longjmp` out of) the signal handler once this
+        // call has been made may cause arbitrary program behaviour including
+        // crashes and deadlocks.
+        static void InternalAttemptToUseMutexInFatalSignalHandler();
+
+    private:
+        std::atomic<intptr_t> mu_;  // The Mutex state.
+
+        // Post()/Wait() versus associated PerThreadSem; in class for required
+        // friendship with PerThreadSem.
+        static void IncrementSynchSem(Mutex* mu, base_internal::PerThreadSynch* w);
+        static bool DecrementSynchSem(Mutex* mu, base_internal::PerThreadSynch* w, synchronization_internal::KernelTimeout t);
+
+        // slow path acquire
+        void LockSlowLoop(SynchWaitParams* waitp, int flags);
+        // wrappers around LockSlowLoop()
+        bool LockSlowWithDeadline(MuHow how, const Condition* cond, synchronization_internal::KernelTimeout t, int flags);
+        void LockSlow(MuHow how, const Condition* cond, int flags) ABSL_ATTRIBUTE_COLD;
+        // slow path release
+        void UnlockSlow(SynchWaitParams* waitp) ABSL_ATTRIBUTE_COLD;
+        // Common code between Await() and AwaitWithTimeout/Deadline()
+        bool AwaitCommon(const Condition& cond, synchronization_internal::KernelTimeout t);
+        // Attempt to remove thread s from queue.
+        void TryRemove(base_internal::PerThreadSynch* s);
+        // Block a thread on mutex.
+        void Block(base_internal::PerThreadSynch* s);
+        // Wake a thread; return successor.
+        base_internal::PerThreadSynch* Wakeup(base_internal::PerThreadSynch* w);
+
+        friend class CondVar;   // for access to Trans()/Fer().
+        void Trans(MuHow how);  // used for CondVar->Mutex transfer
+        void Fer(
+            base_internal::PerThreadSynch* w
+        );  // used for CondVar->Mutex transfer
+
+        // Catch the error of writing Mutex when intending MutexLock.
+        Mutex(const volatile Mutex* /*ignored*/)
+        {
+        }  // NOLINT(runtime/explicit)
+
+        Mutex(const Mutex&) = delete;
+        Mutex& operator=(const Mutex&) = delete;
+    };
+
+    // -----------------------------------------------------------------------------
+    // Mutex RAII Wrappers
+    // -----------------------------------------------------------------------------
+
+    // MutexLock
+    //
+    // `MutexLock` is a helper class, which acquires and releases a `Mutex` via
+    // RAII.
+    //
+    // Example:
+    //
+    // Class Foo {
+    //  public:
+    //   Foo::Bar* Baz() {
+    //     MutexLock lock(&mu_);
+    //     ...
+    //     return bar;
+    //   }
+    //
+    // private:
+    //   Mutex mu_;
+    // };
+    class ABSL_SCOPED_LOCKABLE MutexLock
+    {
+    public:
+        // Constructors
+
+        // Calls `mu->Lock()` and returns when that call returns. That is, `*mu` is
+        // guaranteed to be locked when this object is constructed. Requires that
+        // `mu` be dereferenceable.
+        explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            this->mu_->Lock();
+        }
+
+        // Like above, but calls `mu->LockWhen(cond)` instead. That is, in addition to
+        // the above, the condition given by `cond` is also guaranteed to hold when
+        // this object is constructed.
+        explicit MutexLock(Mutex* mu, const Condition& cond)
+            ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            this->mu_->LockWhen(cond);
+        }
+
+        MutexLock(const MutexLock&) = delete;  // NOLINT(runtime/mutex)
+        MutexLock(MutexLock&&) = delete;       // NOLINT(runtime/mutex)
+        MutexLock& operator=(const MutexLock&) = delete;
+        MutexLock& operator=(MutexLock&&) = delete;
+
+        ~MutexLock() ABSL_UNLOCK_FUNCTION()
+        {
+            this->mu_->Unlock();
+        }
+
+    private:
+        Mutex* const mu_;
+    };
+
+    // ReaderMutexLock
+    //
+    // The `ReaderMutexLock` is a helper class, like `MutexLock`, which acquires and
+    // releases a shared lock on a `Mutex` via RAII.
+    class ABSL_SCOPED_LOCKABLE ReaderMutexLock
+    {
+    public:
+        explicit ReaderMutexLock(Mutex* mu) ABSL_SHARED_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            mu->ReaderLock();
+        }
+
+        explicit ReaderMutexLock(Mutex* mu, const Condition& cond)
+            ABSL_SHARED_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            mu->ReaderLockWhen(cond);
+        }
+
+        ReaderMutexLock(const ReaderMutexLock&) = delete;
+        ReaderMutexLock(ReaderMutexLock&&) = delete;
+        ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
+        ReaderMutexLock& operator=(ReaderMutexLock&&) = delete;
+
+        ~ReaderMutexLock() ABSL_UNLOCK_FUNCTION()
+        {
+            this->mu_->ReaderUnlock();
+        }
+
+    private:
+        Mutex* const mu_;
+    };
+
+    // WriterMutexLock
+    //
+    // The `WriterMutexLock` is a helper class, like `MutexLock`, which acquires and
+    // releases a write (exclusive) lock on a `Mutex` via RAII.
+    class ABSL_SCOPED_LOCKABLE WriterMutexLock
+    {
+    public:
+        explicit WriterMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            mu->WriterLock();
+        }
+
+        explicit WriterMutexLock(Mutex* mu, const Condition& cond)
+            ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            mu->WriterLockWhen(cond);
+        }
+
+        WriterMutexLock(const WriterMutexLock&) = delete;
+        WriterMutexLock(WriterMutexLock&&) = delete;
+        WriterMutexLock& operator=(const WriterMutexLock&) = delete;
+        WriterMutexLock& operator=(WriterMutexLock&&) = delete;
+
+        ~WriterMutexLock() ABSL_UNLOCK_FUNCTION()
+        {
+            this->mu_->WriterUnlock();
+        }
+
+    private:
+        Mutex* const mu_;
+    };
+
+    // -----------------------------------------------------------------------------
+    // Condition
+    // -----------------------------------------------------------------------------
+    //
+    // As noted above, `Mutex` contains a number of member functions which take a
+    // `Condition` as an argument; clients can wait for conditions to become `true`
+    // before attempting to acquire the mutex. These sections are known as
+    // "condition critical" sections. To use a `Condition`, you simply need to
+    // construct it, and use within an appropriate `Mutex` member function;
+    // everything else in the `Condition` class is an implementation detail.
+    //
+    // A `Condition` is specified as a function pointer which returns a boolean.
+    // `Condition` functions should be pure functions -- their results should depend
+    // only on passed arguments, should not consult any external state (such as
+    // clocks), and should have no side-effects, aside from debug logging. Any
+    // objects that the function may access should be limited to those which are
+    // constant while the mutex is blocked on the condition (e.g. a stack variable),
+    // or objects of state protected explicitly by the mutex.
+    //
+    // No matter which construction is used for `Condition`, the underlying
+    // function pointer / functor / callable must not throw any
+    // exceptions. Correctness of `Mutex` / `Condition` is not guaranteed in
+    // the face of a throwing `Condition`. (When Abseil is allowed to depend
+    // on C++17, these function pointers will be explicitly marked
+    // `noexcept`; until then this requirement cannot be enforced in the
+    // type system.)
+    //
+    // Note: to use a `Condition`, you need only construct it and pass it to a
+    // suitable `Mutex' member function, such as `Mutex::Await()`, or to the
+    // constructor of one of the scope guard classes.
+    //
+    // Example using LockWhen/Unlock:
+    //
+    //   // assume count_ is not internal reference count
+    //   int count_ ABSL_GUARDED_BY(mu_);
+    //   Condition count_is_zero(+[](int *count) { return *count == 0; }, &count_);
+    //
+    //   mu_.LockWhen(count_is_zero);
+    //   // ...
+    //   mu_.Unlock();
+    //
+    // Example using a scope guard:
+    //
+    //   {
+    //     MutexLock lock(&mu_, count_is_zero);
+    //     // ...
+    //   }
+    //
+    // When multiple threads are waiting on exactly the same condition, make sure
+    // that they are constructed with the same parameters (same pointer to function
+    // + arg, or same pointer to object + method), so that the mutex implementation
+    // can avoid redundantly evaluating the same condition for each thread.
+    class Condition
+    {
+    public:
+        // A Condition that returns the result of "(*func)(arg)"
+        Condition(bool (*func)(void*), void* arg);
+
+        // Templated version for people who are averse to casts.
+        //
+        // To use a lambda, prepend it with unary plus, which converts the lambda
+        // into a function pointer:
+        //     Condition(+[](T* t) { return ...; }, arg).
+        //
+        // Note: lambdas in this case must contain no bound variables.
+        //
+        // See class comment for performance advice.
+        template<typename T>
+        Condition(bool (*func)(T*), T* arg);
+
+        // Templated version for invoking a method that returns a `bool`.
+        //
+        // `Condition(object, &Class::Method)` constructs a `Condition` that evaluates
+        // `object->Method()`.
+        //
+        // Implementation Note: `absl::internal::identity` is used to allow methods to
+        // come from base classes. A simpler signature like
+        // `Condition(T*, bool (T::*)())` does not suffice.
+        template<typename T>
+        Condition(T* object, bool (absl::internal::identity<T>::type::*method)());
+
+        // Same as above, for const members
+        template<typename T>
+        Condition(const T* object, bool (absl::internal::identity<T>::type::*method)() const);
+
+        // A Condition that returns the value of `*cond`
+        explicit Condition(const bool* cond);
+
+        // Templated version for invoking a functor that returns a `bool`.
+        // This approach accepts pointers to non-mutable lambdas, `std::function`,
+        // the result of` std::bind` and user-defined functors that define
+        // `bool F::operator()() const`.
+        //
+        // Example:
+        //
+        //   auto reached = [this, current]() {
+        //     mu_.AssertReaderHeld();                // For annotalysis.
+        //     return processed_ >= current;
+        //   };
+        //   mu_.Await(Condition(&reached));
+        //
+        // NOTE: never use "mu_.AssertHeld()" instead of "mu_.AssertReaderHeld()" in
+        // the lambda as it may be called when the mutex is being unlocked from a
+        // scope holding only a reader lock, which will make the assertion not
+        // fulfilled and crash the binary.
+
+        // See class comment for performance advice. In particular, if there
+        // might be more than one waiter for the same condition, make sure
+        // that all waiters construct the condition with the same pointers.
+
+        // Implementation note: The second template parameter ensures that this
+        // constructor doesn't participate in overload resolution if T doesn't have
+        // `bool operator() const`.
+        template<typename T, typename E = decltype(static_cast<bool (T::*)() const>(&T::operator()))>
+        explicit Condition(const T* obj) :
+            Condition(obj, static_cast<bool (T::*)() const>(&T::operator()))
+        {
+        }
+
+        // A Condition that always returns `true`.
+        static const Condition kTrue;
+
+        // Evaluates the condition.
+        bool Eval() const;
+
+        // Returns `true` if the two conditions are guaranteed to return the same
+        // value if evaluated at the same time, `false` if the evaluation *may* return
+        // different results.
+        //
+        // Two `Condition` values are guaranteed equal if both their `func` and `arg`
+        // components are the same. A null pointer is equivalent to a `true`
+        // condition.
+        static bool GuaranteedEqual(const Condition* a, const Condition* b);
+
+    private:
+        typedef bool (*InternalFunctionType)(void* arg);
+        typedef bool (Condition::*InternalMethodType)();
+        typedef bool (*InternalMethodCallerType)(void* arg, InternalMethodType internal_method);
+
+        bool (*eval_)(const Condition*);  // Actual evaluator
+        InternalFunctionType function_;   // function taking pointer returning bool
+        InternalMethodType method_;       // method returning bool
+        void* arg_;                       // arg of function_ or object of method_
+
+        Condition();  // null constructor used only to create kTrue
+
+        // Various functions eval_ can point to:
+        static bool CallVoidPtrFunction(const Condition*);
+        template<typename T>
+        static bool CastAndCallFunction(const Condition* c);
+        template<typename T>
+        static bool CastAndCallMethod(const Condition* c);
+    };
+
+    // -----------------------------------------------------------------------------
+    // CondVar
+    // -----------------------------------------------------------------------------
+    //
+    // A condition variable, reflecting state evaluated separately outside of the
+    // `Mutex` object, which can be signaled to wake callers.
+    // This class is not normally needed; use `Mutex` member functions such as
+    // `Mutex::Await()` and intrinsic `Condition` abstractions. In rare cases
+    // with many threads and many conditions, `CondVar` may be faster.
+    //
+    // The implementation may deliver signals to any condition variable at
+    // any time, even when no call to `Signal()` or `SignalAll()` is made; as a
+    // result, upon being awoken, you must check the logical condition you have
+    // been waiting upon.
+    //
+    // Examples:
+    //
+    // Usage for a thread waiting for some condition C protected by mutex mu:
+    //       mu.Lock();
+    //       while (!C) { cv->Wait(&mu); }        // releases and reacquires mu
+    //       //  C holds; process data
+    //       mu.Unlock();
+    //
+    // Usage to wake T is:
+    //       mu.Lock();
+    //       // process data, possibly establishing C
+    //       if (C) { cv->Signal(); }
+    //       mu.Unlock();
+    //
+    // If C may be useful to more than one waiter, use `SignalAll()` instead of
+    // `Signal()`.
+    //
+    // With this implementation it is efficient to use `Signal()/SignalAll()` inside
+    // the locked region; this usage can make reasoning about your program easier.
+    //
+    class CondVar
+    {
+    public:
+        // A `CondVar` allocated on the heap or on the stack can use the this
+        // constructor.
+        CondVar();
+        ~CondVar();
+
+        // CondVar::Wait()
+        //
+        // Atomically releases a `Mutex` and blocks on this condition variable.
+        // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+        // spurious wakeup), then reacquires the `Mutex` and returns.
+        //
+        // Requires and ensures that the current thread holds the `Mutex`.
+        void Wait(Mutex* mu);
+
+        // CondVar::WaitWithTimeout()
+        //
+        // Atomically releases a `Mutex` and blocks on this condition variable.
+        // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+        // spurious wakeup), or until the timeout has expired, then reacquires
+        // the `Mutex` and returns.
+        //
+        // Returns true if the timeout has expired without this `CondVar`
+        // being signalled in any manner. If both the timeout has expired
+        // and this `CondVar` has been signalled, the implementation is free
+        // to return `true` or `false`.
+        //
+        // Requires and ensures that the current thread holds the `Mutex`.
+        bool WaitWithTimeout(Mutex* mu, absl::Duration timeout);
+
+        // CondVar::WaitWithDeadline()
+        //
+        // Atomically releases a `Mutex` and blocks on this condition variable.
+        // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+        // spurious wakeup), or until the deadline has passed, then reacquires
+        // the `Mutex` and returns.
+        //
+        // Deadlines in the past are equivalent to an immediate deadline.
+        //
+        // Returns true if the deadline has passed without this `CondVar`
+        // being signalled in any manner. If both the deadline has passed
+        // and this `CondVar` has been signalled, the implementation is free
+        // to return `true` or `false`.
+        //
+        // Requires and ensures that the current thread holds the `Mutex`.
+        bool WaitWithDeadline(Mutex* mu, absl::Time deadline);
+
+        // CondVar::Signal()
+        //
+        // Signal this `CondVar`; wake at least one waiter if one exists.
+        void Signal();
+
+        // CondVar::SignalAll()
+        //
+        // Signal this `CondVar`; wake all waiters.
+        void SignalAll();
+
+        // CondVar::EnableDebugLog()
+        //
+        // Causes all subsequent uses of this `CondVar` to be logged via
+        // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if `name != 0`.
+        // Note: this method substantially reduces `CondVar` performance.
+        void EnableDebugLog(const char* name);
+
+    private:
+        bool WaitCommon(Mutex* mutex, synchronization_internal::KernelTimeout t);
+        void Remove(base_internal::PerThreadSynch* s);
+        void Wakeup(base_internal::PerThreadSynch* w);
+        std::atomic<intptr_t> cv_;  // Condition variable state.
+        CondVar(const CondVar&) = delete;
+        CondVar& operator=(const CondVar&) = delete;
+    };
+
+    // Variants of MutexLock.
+    //
+    // If you find yourself using one of these, consider instead using
+    // Mutex::Unlock() and/or if-statements for clarity.
+
+    // MutexLockMaybe
+    //
+    // MutexLockMaybe is like MutexLock, but is a no-op when mu is null.
+    class ABSL_SCOPED_LOCKABLE MutexLockMaybe
+    {
+    public:
+        explicit MutexLockMaybe(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            if (this->mu_ != nullptr)
+            {
+                this->mu_->Lock();
+            }
+        }
+
+        explicit MutexLockMaybe(Mutex* mu, const Condition& cond)
+            ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            if (this->mu_ != nullptr)
+            {
+                this->mu_->LockWhen(cond);
+            }
+        }
+
+        ~MutexLockMaybe() ABSL_UNLOCK_FUNCTION()
+        {
+            if (this->mu_ != nullptr)
+            {
+                this->mu_->Unlock();
+            }
+        }
+
+    private:
+        Mutex* const mu_;
+        MutexLockMaybe(const MutexLockMaybe&) = delete;
+        MutexLockMaybe(MutexLockMaybe&&) = delete;
+        MutexLockMaybe& operator=(const MutexLockMaybe&) = delete;
+        MutexLockMaybe& operator=(MutexLockMaybe&&) = delete;
+    };
+
+    // ReleasableMutexLock
+    //
+    // ReleasableMutexLock is like MutexLock, but permits `Release()` of its
+    // mutex before destruction. `Release()` may be called at most once.
+    class ABSL_SCOPED_LOCKABLE ReleasableMutexLock
+    {
+    public:
+        explicit ReleasableMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            this->mu_->Lock();
+        }
+
+        explicit ReleasableMutexLock(Mutex* mu, const Condition& cond)
+            ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+            mu_(mu)
+        {
+            this->mu_->LockWhen(cond);
+        }
+
+        ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION()
+        {
+            if (this->mu_ != nullptr)
+            {
+                this->mu_->Unlock();
+            }
+        }
+
+        void Release() ABSL_UNLOCK_FUNCTION();
+
+    private:
+        Mutex* mu_;
+        ReleasableMutexLock(const ReleasableMutexLock&) = delete;
+        ReleasableMutexLock(ReleasableMutexLock&&) = delete;
+        ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
+        ReleasableMutexLock& operator=(ReleasableMutexLock&&) = delete;
+    };
+
+    inline Mutex::Mutex() :
+        mu_(0)
+    {
+        ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
     }
-  }
 
-  explicit MutexLockMaybe(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    if (this->mu_ != nullptr) {
-      this->mu_->LockWhen(cond);
+    inline constexpr Mutex::Mutex(absl::ConstInitType) :
+        mu_(0)
+    {
     }
-  }
 
-  ~MutexLockMaybe() ABSL_UNLOCK_FUNCTION() {
-    if (this->mu_ != nullptr) { this->mu_->Unlock(); }
-  }
+    inline CondVar::CondVar() :
+        cv_(0)
+    {
+    }
 
- private:
-  Mutex *const mu_;
-  MutexLockMaybe(const MutexLockMaybe&) = delete;
-  MutexLockMaybe(MutexLockMaybe&&) = delete;
-  MutexLockMaybe& operator=(const MutexLockMaybe&) = delete;
-  MutexLockMaybe& operator=(MutexLockMaybe&&) = delete;
-};
+    // static
+    template<typename T>
+    bool Condition::CastAndCallMethod(const Condition* c)
+    {
+        typedef bool (T::*MemberType)();
+        MemberType rm = reinterpret_cast<MemberType>(c->method_);
+        T* x = static_cast<T*>(c->arg_);
+        return (x->*rm)();
+    }
 
-// ReleasableMutexLock
-//
-// ReleasableMutexLock is like MutexLock, but permits `Release()` of its
-// mutex before destruction. `Release()` may be called at most once.
-class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
- public:
-  explicit ReleasableMutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    this->mu_->Lock();
-  }
-
-  explicit ReleasableMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    this->mu_->LockWhen(cond);
-  }
-
-  ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
-    if (this->mu_ != nullptr) { this->mu_->Unlock(); }
-  }
-
-  void Release() ABSL_UNLOCK_FUNCTION();
-
- private:
-  Mutex *mu_;
-  ReleasableMutexLock(const ReleasableMutexLock&) = delete;
-  ReleasableMutexLock(ReleasableMutexLock&&) = delete;
-  ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
-  ReleasableMutexLock& operator=(ReleasableMutexLock&&) = delete;
-};
-
-inline Mutex::Mutex() : mu_(0) {
-  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
-}
-
-inline constexpr Mutex::Mutex(absl::ConstInitType) : mu_(0) {}
-
-inline CondVar::CondVar() : cv_(0) {}
-
-// static
-template <typename T>
-bool Condition::CastAndCallMethod(const Condition *c) {
-  typedef bool (T::*MemberType)();
-  MemberType rm = reinterpret_cast<MemberType>(c->method_);
-  T *x = static_cast<T *>(c->arg_);
-  return (x->*rm)();
-}
-
-// static
-template <typename T>
-bool Condition::CastAndCallFunction(const Condition *c) {
-  typedef bool (*FuncType)(T *);
-  FuncType fn = reinterpret_cast<FuncType>(c->function_);
-  T *x = static_cast<T *>(c->arg_);
-  return (*fn)(x);
-}
-
-template <typename T>
-inline Condition::Condition(bool (*func)(T *), T *arg)
-    : eval_(&CastAndCallFunction<T>),
-      function_(reinterpret_cast<InternalFunctionType>(func)),
-      method_(nullptr),
-      arg_(const_cast<void *>(static_cast<const void *>(arg))) {}
-
-template <typename T>
-inline Condition::Condition(T *object,
-                            bool (absl::internal::identity<T>::type::*method)())
-    : eval_(&CastAndCallMethod<T>),
-      function_(nullptr),
-      method_(reinterpret_cast<InternalMethodType>(method)),
-      arg_(object) {}
-
-template <typename T>
-inline Condition::Condition(const T *object,
-                            bool (absl::internal::identity<T>::type::*method)()
-                                const)
-    : eval_(&CastAndCallMethod<T>),
-      function_(nullptr),
-      method_(reinterpret_cast<InternalMethodType>(method)),
-      arg_(reinterpret_cast<void *>(const_cast<T *>(object))) {}
-
-// Register a hook for profiling support.
-//
-// The function pointer registered here will be called whenever a mutex is
-// contended.  The callback is given the cycles for which waiting happened (as
-// measured by //absl/base/internal/cycleclock.h, and which may not
-// be real "cycle" counts.)
-//
-// Calls to this function do not race or block, but there is no ordering
-// guaranteed between calls to this function and call to the provided hook.
-// In particular, the previously registered hook may still be called for some
-// time after this function returns.
-void RegisterMutexProfiler(void (*fn)(int64_t wait_cycles));
+    // static
+    template<typename T>
+    bool Condition::CastAndCallFunction(const Condition* c)
+    {
+        typedef bool (*FuncType)(T*);
+        FuncType fn = reinterpret_cast<FuncType>(c->function_);
+        T* x = static_cast<T*>(c->arg_);
+        return (*fn)(x);
+    }
 
-// Register a hook for Mutex tracing.
-//
-// The function pointer registered here will be called whenever a mutex is
-// contended.  The callback is given an opaque handle to the contended mutex,
-// an event name, and the number of wait cycles (as measured by
-// //absl/base/internal/cycleclock.h, and which may not be real
-// "cycle" counts.)
-//
-// The only event name currently sent is "slow release".
-//
-// This has the same memory ordering concerns as RegisterMutexProfiler() above.
-void RegisterMutexTracer(void (*fn)(const char *msg, const void *obj,
-                                    int64_t wait_cycles));
+    template<typename T>
+    inline Condition::Condition(bool (*func)(T*), T* arg) :
+        eval_(&CastAndCallFunction<T>),
+        function_(reinterpret_cast<InternalFunctionType>(func)),
+        method_(nullptr),
+        arg_(const_cast<void*>(static_cast<const void*>(arg)))
+    {
+    }
 
-// TODO(gfalcon): Combine RegisterMutexProfiler() and RegisterMutexTracer()
-// into a single interface, since they are only ever called in pairs.
+    template<typename T>
+    inline Condition::Condition(T* object, bool (absl::internal::identity<T>::type::*method)()) :
+        eval_(&CastAndCallMethod<T>),
+        function_(nullptr),
+        method_(reinterpret_cast<InternalMethodType>(method)),
+        arg_(object)
+    {
+    }
 
-// Register a hook for CondVar tracing.
-//
-// The function pointer registered here will be called here on various CondVar
-// events.  The callback is given an opaque handle to the CondVar object and
-// a string identifying the event.  This is thread-safe, but only a single
-// tracer can be registered.
-//
-// Events that can be sent are "Wait", "Unwait", "Signal wakeup", and
-// "SignalAll wakeup".
-//
-// This has the same memory ordering concerns as RegisterMutexProfiler() above.
-void RegisterCondVarTracer(void (*fn)(const char *msg, const void *cv));
+    template<typename T>
+    inline Condition::Condition(const T* object, bool (absl::internal::identity<T>::type::*method)() const) :
+        eval_(&CastAndCallMethod<T>),
+        function_(nullptr),
+        method_(reinterpret_cast<InternalMethodType>(method)),
+        arg_(reinterpret_cast<void*>(const_cast<T*>(object)))
+    {
+    }
 
-// Register a hook for symbolizing stack traces in deadlock detector reports.
-//
-// 'pc' is the program counter being symbolized, 'out' is the buffer to write
-// into, and 'out_size' is the size of the buffer.  This function can return
-// false if symbolizing failed, or true if a NUL-terminated symbol was written
-// to 'out.'
-//
-// This has the same memory ordering concerns as RegisterMutexProfiler() above.
-//
-// DEPRECATED: The default symbolizer function is absl::Symbolize() and the
-// ability to register a different hook for symbolizing stack traces will be
-// removed on or after 2023-05-01.
-ABSL_DEPRECATED("absl::RegisterSymbolizer() is deprecated and will be removed "
-                "on or after 2023-05-01")
-void RegisterSymbolizer(bool (*fn)(const void *pc, char *out, int out_size));
-
-// EnableMutexInvariantDebugging()
-//
-// Enable or disable global support for Mutex invariant debugging.  If enabled,
-// then invariant predicates can be registered per-Mutex for debug checking.
-// See Mutex::EnableInvariantDebugging().
-void EnableMutexInvariantDebugging(bool enabled);
-
-// When in debug mode, and when the feature has been enabled globally, the
-// implementation will keep track of lock ordering and complain (or optionally
-// crash) if a cycle is detected in the acquired-before graph.
-
-// Possible modes of operation for the deadlock detector in debug mode.
-enum class OnDeadlockCycle {
-  kIgnore,  // Neither report on nor attempt to track cycles in lock ordering
-  kReport,  // Report lock cycles to stderr when detected
-  kAbort,  // Report lock cycles to stderr when detected, then abort
-};
-
-// SetMutexDeadlockDetectionMode()
-//
-// Enable or disable global support for detection of potential deadlocks
-// due to Mutex lock ordering inversions.  When set to 'kIgnore', tracking of
-// lock ordering is disabled.  Otherwise, in debug builds, a lock ordering graph
-// will be maintained internally, and detected cycles will be reported in
-// the manner chosen here.
-void SetMutexDeadlockDetectionMode(OnDeadlockCycle mode);
-
-ABSL_NAMESPACE_END
+    // Register a hook for profiling support.
+    //
+    // The function pointer registered here will be called whenever a mutex is
+    // contended.  The callback is given the cycles for which waiting happened (as
+    // measured by //absl/base/internal/cycleclock.h, and which may not
+    // be real "cycle" counts.)
+    //
+    // Calls to this function do not race or block, but there is no ordering
+    // guaranteed between calls to this function and call to the provided hook.
+    // In particular, the previously registered hook may still be called for some
+    // time after this function returns.
+    void RegisterMutexProfiler(void (*fn)(int64_t wait_cycles));
+
+    // Register a hook for Mutex tracing.
+    //
+    // The function pointer registered here will be called whenever a mutex is
+    // contended.  The callback is given an opaque handle to the contended mutex,
+    // an event name, and the number of wait cycles (as measured by
+    // //absl/base/internal/cycleclock.h, and which may not be real
+    // "cycle" counts.)
+    //
+    // The only event name currently sent is "slow release".
+    //
+    // This has the same memory ordering concerns as RegisterMutexProfiler() above.
+    void RegisterMutexTracer(void (*fn)(const char* msg, const void* obj, int64_t wait_cycles));
+
+    // TODO(gfalcon): Combine RegisterMutexProfiler() and RegisterMutexTracer()
+    // into a single interface, since they are only ever called in pairs.
+
+    // Register a hook for CondVar tracing.
+    //
+    // The function pointer registered here will be called here on various CondVar
+    // events.  The callback is given an opaque handle to the CondVar object and
+    // a string identifying the event.  This is thread-safe, but only a single
+    // tracer can be registered.
+    //
+    // Events that can be sent are "Wait", "Unwait", "Signal wakeup", and
+    // "SignalAll wakeup".
+    //
+    // This has the same memory ordering concerns as RegisterMutexProfiler() above.
+    void RegisterCondVarTracer(void (*fn)(const char* msg, const void* cv));
+
+    // Register a hook for symbolizing stack traces in deadlock detector reports.
+    //
+    // 'pc' is the program counter being symbolized, 'out' is the buffer to write
+    // into, and 'out_size' is the size of the buffer.  This function can return
+    // false if symbolizing failed, or true if a NUL-terminated symbol was written
+    // to 'out.'
+    //
+    // This has the same memory ordering concerns as RegisterMutexProfiler() above.
+    //
+    // DEPRECATED: The default symbolizer function is absl::Symbolize() and the
+    // ability to register a different hook for symbolizing stack traces will be
+    // removed on or after 2023-05-01.
+    ABSL_DEPRECATED("absl::RegisterSymbolizer() is deprecated and will be removed "
+                    "on or after 2023-05-01")
+    void RegisterSymbolizer(bool (*fn)(const void* pc, char* out, int out_size));
+
+    // EnableMutexInvariantDebugging()
+    //
+    // Enable or disable global support for Mutex invariant debugging.  If enabled,
+    // then invariant predicates can be registered per-Mutex for debug checking.
+    // See Mutex::EnableInvariantDebugging().
+    void EnableMutexInvariantDebugging(bool enabled);
+
+    // When in debug mode, and when the feature has been enabled globally, the
+    // implementation will keep track of lock ordering and complain (or optionally
+    // crash) if a cycle is detected in the acquired-before graph.
+
+    // Possible modes of operation for the deadlock detector in debug mode.
+    enum class OnDeadlockCycle
+    {
+        kIgnore,  // Neither report on nor attempt to track cycles in lock ordering
+        kReport,  // Report lock cycles to stderr when detected
+        kAbort,   // Report lock cycles to stderr when detected, then abort
+    };
+
+    // SetMutexDeadlockDetectionMode()
+    //
+    // Enable or disable global support for detection of potential deadlocks
+    // due to Mutex lock ordering inversions.  When set to 'kIgnore', tracking of
+    // lock ordering is disabled.  Otherwise, in debug builds, a lock ordering graph
+    // will be maintained internally, and detected cycles will be reported in
+    // the manner chosen here.
+    void SetMutexDeadlockDetectionMode(OnDeadlockCycle mode);
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // In some build configurations we pass --detect-odr-violations to the
@@ -1083,8 +1144,9 @@ ABSL_NAMESPACE_END
 // --detect-odr-violations ignores symbols not mangled with C++ names.
 // By changing our extension points to be extern "C", we dodge this
 // check.
-extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
+extern "C"
+{
+    void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
 }  // extern "C"
 
 #endif  // ABSL_SYNCHRONIZATION_MUTEX_H_
diff --git a/CAPI/cpp/grpc/include/absl/synchronization/notification.h b/CAPI/cpp/grpc/include/absl/synchronization/notification.h
index 4bec268..ca4f49a 100644
--- a/CAPI/cpp/grpc/include/absl/synchronization/notification.h
+++ b/CAPI/cpp/grpc/include/absl/synchronization/notification.h
@@ -57,68 +57,79 @@
 #include "absl/synchronization/mutex.h"
 #include "absl/time/time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// -----------------------------------------------------------------------------
-// Notification
-// -----------------------------------------------------------------------------
-class Notification {
- public:
-  // Initializes the "notified" state to unnotified.
-  Notification() : notified_yet_(false) {}
-  explicit Notification(bool prenotify) : notified_yet_(prenotify) {}
-  Notification(const Notification&) = delete;
-  Notification& operator=(const Notification&) = delete;
-  ~Notification();
+    // -----------------------------------------------------------------------------
+    // Notification
+    // -----------------------------------------------------------------------------
+    class Notification
+    {
+    public:
+        // Initializes the "notified" state to unnotified.
+        Notification() :
+            notified_yet_(false)
+        {
+        }
+        explicit Notification(bool prenotify) :
+            notified_yet_(prenotify)
+        {
+        }
+        Notification(const Notification&) = delete;
+        Notification& operator=(const Notification&) = delete;
+        ~Notification();
 
-  // Notification::HasBeenNotified()
-  //
-  // Returns the value of the notification's internal "notified" state.
-  ABSL_MUST_USE_RESULT bool HasBeenNotified() const {
-    return HasBeenNotifiedInternal(&this->notified_yet_);
-  }
+        // Notification::HasBeenNotified()
+        //
+        // Returns the value of the notification's internal "notified" state.
+        ABSL_MUST_USE_RESULT bool HasBeenNotified() const
+        {
+            return HasBeenNotifiedInternal(&this->notified_yet_);
+        }
 
-  // Notification::WaitForNotification()
-  //
-  // Blocks the calling thread until the notification's "notified" state is
-  // `true`. Note that if `Notify()` has been previously called on this
-  // notification, this function will immediately return.
-  void WaitForNotification() const;
+        // Notification::WaitForNotification()
+        //
+        // Blocks the calling thread until the notification's "notified" state is
+        // `true`. Note that if `Notify()` has been previously called on this
+        // notification, this function will immediately return.
+        void WaitForNotification() const;
 
-  // Notification::WaitForNotificationWithTimeout()
-  //
-  // Blocks until either the notification's "notified" state is `true` (which
-  // may occur immediately) or the timeout has elapsed, returning the value of
-  // its "notified" state in either case.
-  bool WaitForNotificationWithTimeout(absl::Duration timeout) const;
+        // Notification::WaitForNotificationWithTimeout()
+        //
+        // Blocks until either the notification's "notified" state is `true` (which
+        // may occur immediately) or the timeout has elapsed, returning the value of
+        // its "notified" state in either case.
+        bool WaitForNotificationWithTimeout(absl::Duration timeout) const;
 
-  // Notification::WaitForNotificationWithDeadline()
-  //
-  // Blocks until either the notification's "notified" state is `true` (which
-  // may occur immediately) or the deadline has expired, returning the value of
-  // its "notified" state in either case.
-  bool WaitForNotificationWithDeadline(absl::Time deadline) const;
+        // Notification::WaitForNotificationWithDeadline()
+        //
+        // Blocks until either the notification's "notified" state is `true` (which
+        // may occur immediately) or the deadline has expired, returning the value of
+        // its "notified" state in either case.
+        bool WaitForNotificationWithDeadline(absl::Time deadline) const;
 
-  // Notification::Notify()
-  //
-  // Sets the "notified" state of this notification to `true` and wakes waiting
-  // threads. Note: do not call `Notify()` multiple times on the same
-  // `Notification`; calling `Notify()` more than once on the same notification
-  // results in undefined behavior.
-  void Notify();
+        // Notification::Notify()
+        //
+        // Sets the "notified" state of this notification to `true` and wakes waiting
+        // threads. Note: do not call `Notify()` multiple times on the same
+        // `Notification`; calling `Notify()` more than once on the same notification
+        // results in undefined behavior.
+        void Notify();
 
- private:
-  static inline bool HasBeenNotifiedInternal(
-      const std::atomic<bool>* notified_yet) {
-    return notified_yet->load(std::memory_order_acquire);
-  }
+    private:
+        static inline bool HasBeenNotifiedInternal(
+            const std::atomic<bool>* notified_yet
+        )
+        {
+            return notified_yet->load(std::memory_order_acquire);
+        }
 
-  mutable Mutex mutex_;
-  std::atomic<bool> notified_yet_;  // written under mutex_
-};
+        mutable Mutex mutex_;
+        std::atomic<bool> notified_yet_;  // written under mutex_
+    };
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_SYNCHRONIZATION_NOTIFICATION_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/civil_time.h b/CAPI/cpp/grpc/include/absl/time/civil_time.h
index bb46004..2ec25d9 100644
--- a/CAPI/cpp/grpc/include/absl/time/civil_time.h
+++ b/CAPI/cpp/grpc/include/absl/time/civil_time.h
@@ -75,464 +75,483 @@
 #include "absl/strings/string_view.h"
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-namespace time_internal {
-struct second_tag : cctz::detail::second_tag {};
-struct minute_tag : second_tag, cctz::detail::minute_tag {};
-struct hour_tag : minute_tag, cctz::detail::hour_tag {};
-struct day_tag : hour_tag, cctz::detail::day_tag {};
-struct month_tag : day_tag, cctz::detail::month_tag {};
-struct year_tag : month_tag, cctz::detail::year_tag {};
-}  // namespace time_internal
+    namespace time_internal
+    {
+        struct second_tag : cctz::detail::second_tag
+        {
+        };
+        struct minute_tag : second_tag, cctz::detail::minute_tag
+        {
+        };
+        struct hour_tag : minute_tag, cctz::detail::hour_tag
+        {
+        };
+        struct day_tag : hour_tag, cctz::detail::day_tag
+        {
+        };
+        struct month_tag : day_tag, cctz::detail::month_tag
+        {
+        };
+        struct year_tag : month_tag, cctz::detail::year_tag
+        {
+        };
+    }  // namespace time_internal
 
-// -----------------------------------------------------------------------------
-// CivilSecond, CivilMinute, CivilHour, CivilDay, CivilMonth, CivilYear
-// -----------------------------------------------------------------------------
-//
-// Each of these civil-time types is a simple value type with the same
-// interface for construction and the same six accessors for each of the civil
-// time fields (year, month, day, hour, minute, and second, aka YMDHMS). These
-// classes differ only in their alignment, which is indicated by the type name
-// and specifies the field on which arithmetic operates.
-//
-// CONSTRUCTION
-//
-// Each of the civil-time types can be constructed in two ways: by directly
-// passing to the constructor up to six integers representing the YMDHMS fields,
-// or by copying the YMDHMS fields from a differently aligned civil-time type.
-// Omitted fields are assigned their minimum valid value. Hours, minutes, and
-// seconds will be set to 0, month and day will be set to 1. Since there is no
-// minimum year, the default is 1970.
-//
-// Examples:
-//
-//   absl::CivilDay default_value;               // 1970-01-01 00:00:00
-//
-//   absl::CivilDay a(2015, 2, 3);               // 2015-02-03 00:00:00
-//   absl::CivilDay b(2015, 2, 3, 4, 5, 6);      // 2015-02-03 00:00:00
-//   absl::CivilDay c(2015);                     // 2015-01-01 00:00:00
-//
-//   absl::CivilSecond ss(2015, 2, 3, 4, 5, 6);  // 2015-02-03 04:05:06
-//   absl::CivilMinute mm(ss);                   // 2015-02-03 04:05:00
-//   absl::CivilHour hh(mm);                     // 2015-02-03 04:00:00
-//   absl::CivilDay d(hh);                       // 2015-02-03 00:00:00
-//   absl::CivilMonth m(d);                      // 2015-02-01 00:00:00
-//   absl::CivilYear y(m);                       // 2015-01-01 00:00:00
-//
-//   m = absl::CivilMonth(y);                    // 2015-01-01 00:00:00
-//   d = absl::CivilDay(m);                      // 2015-01-01 00:00:00
-//   hh = absl::CivilHour(d);                    // 2015-01-01 00:00:00
-//   mm = absl::CivilMinute(hh);                 // 2015-01-01 00:00:00
-//   ss = absl::CivilSecond(mm);                 // 2015-01-01 00:00:00
-//
-// Each civil-time class is aligned to the civil-time field indicated in the
-// class's name after normalization. Alignment is performed by setting all the
-// inferior fields to their minimum valid value (as described above). The
-// following are examples of how each of the six types would align the fields
-// representing November 22, 2015 at 12:34:56 in the afternoon. (Note: the
-// string format used here is not important; it's just a shorthand way of
-// showing the six YMDHMS fields.)
-//
-//   absl::CivilSecond   : 2015-11-22 12:34:56
-//   absl::CivilMinute   : 2015-11-22 12:34:00
-//   absl::CivilHour     : 2015-11-22 12:00:00
-//   absl::CivilDay      : 2015-11-22 00:00:00
-//   absl::CivilMonth    : 2015-11-01 00:00:00
-//   absl::CivilYear     : 2015-01-01 00:00:00
-//
-// Each civil-time type performs arithmetic on the field to which it is
-// aligned. This means that adding 1 to an absl::CivilDay increments the day
-// field (normalizing as necessary), and subtracting 7 from an absl::CivilMonth
-// operates on the month field (normalizing as necessary). All arithmetic
-// produces a valid civil time. Difference requires two similarly aligned
-// civil-time objects and returns the scalar answer in units of the objects'
-// alignment. For example, the difference between two absl::CivilHour objects
-// will give an answer in units of civil hours.
-//
-// ALIGNMENT CONVERSION
-//
-// The alignment of a civil-time object cannot change, but the object may be
-// used to construct a new object with a different alignment. This is referred
-// to as "realigning". When realigning to a type with the same or more
-// precision (e.g., absl::CivilDay -> absl::CivilSecond), the conversion may be
-// performed implicitly since no information is lost. However, if information
-// could be discarded (e.g., CivilSecond -> CivilDay), the conversion must
-// be explicit at the call site.
-//
-// Examples:
-//
-//   void UseDay(absl::CivilDay day);
-//
-//   absl::CivilSecond cs;
-//   UseDay(cs);                  // Won't compile because data may be discarded
-//   UseDay(absl::CivilDay(cs));  // OK: explicit conversion
-//
-//   absl::CivilDay cd;
-//   UseDay(cd);                  // OK: no conversion needed
-//
-//   absl::CivilMonth cm;
-//   UseDay(cm);                  // OK: implicit conversion to absl::CivilDay
-//
-// NORMALIZATION
-//
-// Normalization takes invalid values and adjusts them to produce valid values.
-// Within the civil-time library, integer arguments passed to the Civil*
-// constructors may be out-of-range, in which case they are normalized by
-// carrying overflow into a field of courser granularity to produce valid
-// civil-time objects. This normalization enables natural arithmetic on
-// constructor arguments without worrying about the field's range.
-//
-// Examples:
-//
-//   // Out-of-range; normalized to 2016-11-01
-//   absl::CivilDay d(2016, 10, 32);
-//   // Out-of-range, negative: normalized to 2016-10-30T23
-//   absl::CivilHour h1(2016, 10, 31, -1);
-//   // Normalization is cumulative: normalized to 2016-10-30T23
-//   absl::CivilHour h2(2016, 10, 32, -25);
-//
-// Note: If normalization is undesired, you can signal an error by comparing
-// the constructor arguments to the normalized values returned by the YMDHMS
-// properties.
-//
-// COMPARISON
-//
-// Comparison between civil-time objects considers all six YMDHMS fields,
-// regardless of the type's alignment. Comparison between differently aligned
-// civil-time types is allowed.
-//
-// Examples:
-//
-//   absl::CivilDay feb_3(2015, 2, 3);  // 2015-02-03 00:00:00
-//   absl::CivilDay mar_4(2015, 3, 4);  // 2015-03-04 00:00:00
-//   // feb_3 < mar_4
-//   // absl::CivilYear(feb_3) == absl::CivilYear(mar_4)
-//
-//   absl::CivilSecond feb_3_noon(2015, 2, 3, 12, 0, 0);  // 2015-02-03 12:00:00
-//   // feb_3 < feb_3_noon
-//   // feb_3 == absl::CivilDay(feb_3_noon)
-//
-//   // Iterates all the days of February 2015.
-//   for (absl::CivilDay d(2015, 2, 1); d < absl::CivilMonth(2015, 3); ++d) {
-//     // ...
-//   }
-//
-// ARITHMETIC
-//
-// Civil-time types support natural arithmetic operators such as addition,
-// subtraction, and difference. Arithmetic operates on the civil-time field
-// indicated in the type's name. Difference operators require arguments with
-// the same alignment and return the answer in units of the alignment.
-//
-// Example:
-//
-//   absl::CivilDay a(2015, 2, 3);
-//   ++a;                              // 2015-02-04 00:00:00
-//   --a;                              // 2015-02-03 00:00:00
-//   absl::CivilDay b = a + 1;         // 2015-02-04 00:00:00
-//   absl::CivilDay c = 1 + b;         // 2015-02-05 00:00:00
-//   int n = c - a;                    // n = 2 (civil days)
-//   int m = c - absl::CivilMonth(c);  // Won't compile: different types.
-//
-// ACCESSORS
-//
-// Each civil-time type has accessors for all six of the civil-time fields:
-// year, month, day, hour, minute, and second.
-//
-// civil_year_t year()
-// int          month()
-// int          day()
-// int          hour()
-// int          minute()
-// int          second()
-//
-// Recall that fields inferior to the type's alignment will be set to their
-// minimum valid value.
-//
-// Example:
-//
-//   absl::CivilDay d(2015, 6, 28);
-//   // d.year() == 2015
-//   // d.month() == 6
-//   // d.day() == 28
-//   // d.hour() == 0
-//   // d.minute() == 0
-//   // d.second() == 0
-//
-// CASE STUDY: Adding a month to January 31.
-//
-// One of the classic questions that arises when considering a civil time
-// library (or a date library or a date/time library) is this:
-//   "What is the result of adding a month to January 31?"
-// This is an interesting question because it is unclear what is meant by a
-// "month", and several different answers are possible, depending on context:
-//
-//   1. March 3 (or 2 if a leap year), if "add a month" means to add a month to
-//      the current month, and adjust the date to overflow the extra days into
-//      March. In this case the result of "February 31" would be normalized as
-//      within the civil-time library.
-//   2. February 28 (or 29 if a leap year), if "add a month" means to add a
-//      month, and adjust the date while holding the resulting month constant.
-//      In this case, the result of "February 31" would be truncated to the last
-//      day in February.
-//   3. An error. The caller may get some error, an exception, an invalid date
-//      object, or perhaps return `false`. This may make sense because there is
-//      no single unambiguously correct answer to the question.
-//
-// Practically speaking, any answer that is not what the programmer intended
-// is the wrong answer.
-//
-// The Abseil time library avoids this problem by making it impossible to
-// ask ambiguous questions. All civil-time objects are aligned to a particular
-// civil-field boundary (such as aligned to a year, month, day, hour, minute,
-// or second), and arithmetic operates on the field to which the object is
-// aligned. This means that in order to "add a month" the object must first be
-// aligned to a month boundary, which is equivalent to the first day of that
-// month.
-//
-// Of course, there are ways to compute an answer the question at hand using
-// this Abseil time library, but they require the programmer to be explicit
-// about the answer they expect. To illustrate, let's see how to compute all
-// three of the above possible answers to the question of "Jan 31 plus 1
-// month":
-//
-// Example:
-//
-//   const absl::CivilDay d(2015, 1, 31);
-//
-//   // Answer 1:
-//   // Add 1 to the month field in the constructor, and rely on normalization.
-//   const auto normalized = absl::CivilDay(d.year(), d.month() + 1, d.day());
-//   // normalized == 2015-03-03 (aka Feb 31)
-//
-//   // Answer 2:
-//   // Add 1 to month field, capping to the end of next month.
-//   const auto next_month = absl::CivilMonth(d) + 1;
-//   const auto last_day_of_next_month = absl::CivilDay(next_month + 1) - 1;
-//   const auto capped = std::min(normalized, last_day_of_next_month);
-//   // capped == 2015-02-28
-//
-//   // Answer 3:
-//   // Signal an error if the normalized answer is not in next month.
-//   if (absl::CivilMonth(normalized) != next_month) {
-//     // error, month overflow
-//   }
-//
-using CivilSecond =
-    time_internal::cctz::detail::civil_time<time_internal::second_tag>;
-using CivilMinute =
-    time_internal::cctz::detail::civil_time<time_internal::minute_tag>;
-using CivilHour =
-    time_internal::cctz::detail::civil_time<time_internal::hour_tag>;
-using CivilDay =
-    time_internal::cctz::detail::civil_time<time_internal::day_tag>;
-using CivilMonth =
-    time_internal::cctz::detail::civil_time<time_internal::month_tag>;
-using CivilYear =
-    time_internal::cctz::detail::civil_time<time_internal::year_tag>;
+    // -----------------------------------------------------------------------------
+    // CivilSecond, CivilMinute, CivilHour, CivilDay, CivilMonth, CivilYear
+    // -----------------------------------------------------------------------------
+    //
+    // Each of these civil-time types is a simple value type with the same
+    // interface for construction and the same six accessors for each of the civil
+    // time fields (year, month, day, hour, minute, and second, aka YMDHMS). These
+    // classes differ only in their alignment, which is indicated by the type name
+    // and specifies the field on which arithmetic operates.
+    //
+    // CONSTRUCTION
+    //
+    // Each of the civil-time types can be constructed in two ways: by directly
+    // passing to the constructor up to six integers representing the YMDHMS fields,
+    // or by copying the YMDHMS fields from a differently aligned civil-time type.
+    // Omitted fields are assigned their minimum valid value. Hours, minutes, and
+    // seconds will be set to 0, month and day will be set to 1. Since there is no
+    // minimum year, the default is 1970.
+    //
+    // Examples:
+    //
+    //   absl::CivilDay default_value;               // 1970-01-01 00:00:00
+    //
+    //   absl::CivilDay a(2015, 2, 3);               // 2015-02-03 00:00:00
+    //   absl::CivilDay b(2015, 2, 3, 4, 5, 6);      // 2015-02-03 00:00:00
+    //   absl::CivilDay c(2015);                     // 2015-01-01 00:00:00
+    //
+    //   absl::CivilSecond ss(2015, 2, 3, 4, 5, 6);  // 2015-02-03 04:05:06
+    //   absl::CivilMinute mm(ss);                   // 2015-02-03 04:05:00
+    //   absl::CivilHour hh(mm);                     // 2015-02-03 04:00:00
+    //   absl::CivilDay d(hh);                       // 2015-02-03 00:00:00
+    //   absl::CivilMonth m(d);                      // 2015-02-01 00:00:00
+    //   absl::CivilYear y(m);                       // 2015-01-01 00:00:00
+    //
+    //   m = absl::CivilMonth(y);                    // 2015-01-01 00:00:00
+    //   d = absl::CivilDay(m);                      // 2015-01-01 00:00:00
+    //   hh = absl::CivilHour(d);                    // 2015-01-01 00:00:00
+    //   mm = absl::CivilMinute(hh);                 // 2015-01-01 00:00:00
+    //   ss = absl::CivilSecond(mm);                 // 2015-01-01 00:00:00
+    //
+    // Each civil-time class is aligned to the civil-time field indicated in the
+    // class's name after normalization. Alignment is performed by setting all the
+    // inferior fields to their minimum valid value (as described above). The
+    // following are examples of how each of the six types would align the fields
+    // representing November 22, 2015 at 12:34:56 in the afternoon. (Note: the
+    // string format used here is not important; it's just a shorthand way of
+    // showing the six YMDHMS fields.)
+    //
+    //   absl::CivilSecond   : 2015-11-22 12:34:56
+    //   absl::CivilMinute   : 2015-11-22 12:34:00
+    //   absl::CivilHour     : 2015-11-22 12:00:00
+    //   absl::CivilDay      : 2015-11-22 00:00:00
+    //   absl::CivilMonth    : 2015-11-01 00:00:00
+    //   absl::CivilYear     : 2015-01-01 00:00:00
+    //
+    // Each civil-time type performs arithmetic on the field to which it is
+    // aligned. This means that adding 1 to an absl::CivilDay increments the day
+    // field (normalizing as necessary), and subtracting 7 from an absl::CivilMonth
+    // operates on the month field (normalizing as necessary). All arithmetic
+    // produces a valid civil time. Difference requires two similarly aligned
+    // civil-time objects and returns the scalar answer in units of the objects'
+    // alignment. For example, the difference between two absl::CivilHour objects
+    // will give an answer in units of civil hours.
+    //
+    // ALIGNMENT CONVERSION
+    //
+    // The alignment of a civil-time object cannot change, but the object may be
+    // used to construct a new object with a different alignment. This is referred
+    // to as "realigning". When realigning to a type with the same or more
+    // precision (e.g., absl::CivilDay -> absl::CivilSecond), the conversion may be
+    // performed implicitly since no information is lost. However, if information
+    // could be discarded (e.g., CivilSecond -> CivilDay), the conversion must
+    // be explicit at the call site.
+    //
+    // Examples:
+    //
+    //   void UseDay(absl::CivilDay day);
+    //
+    //   absl::CivilSecond cs;
+    //   UseDay(cs);                  // Won't compile because data may be discarded
+    //   UseDay(absl::CivilDay(cs));  // OK: explicit conversion
+    //
+    //   absl::CivilDay cd;
+    //   UseDay(cd);                  // OK: no conversion needed
+    //
+    //   absl::CivilMonth cm;
+    //   UseDay(cm);                  // OK: implicit conversion to absl::CivilDay
+    //
+    // NORMALIZATION
+    //
+    // Normalization takes invalid values and adjusts them to produce valid values.
+    // Within the civil-time library, integer arguments passed to the Civil*
+    // constructors may be out-of-range, in which case they are normalized by
+    // carrying overflow into a field of courser granularity to produce valid
+    // civil-time objects. This normalization enables natural arithmetic on
+    // constructor arguments without worrying about the field's range.
+    //
+    // Examples:
+    //
+    //   // Out-of-range; normalized to 2016-11-01
+    //   absl::CivilDay d(2016, 10, 32);
+    //   // Out-of-range, negative: normalized to 2016-10-30T23
+    //   absl::CivilHour h1(2016, 10, 31, -1);
+    //   // Normalization is cumulative: normalized to 2016-10-30T23
+    //   absl::CivilHour h2(2016, 10, 32, -25);
+    //
+    // Note: If normalization is undesired, you can signal an error by comparing
+    // the constructor arguments to the normalized values returned by the YMDHMS
+    // properties.
+    //
+    // COMPARISON
+    //
+    // Comparison between civil-time objects considers all six YMDHMS fields,
+    // regardless of the type's alignment. Comparison between differently aligned
+    // civil-time types is allowed.
+    //
+    // Examples:
+    //
+    //   absl::CivilDay feb_3(2015, 2, 3);  // 2015-02-03 00:00:00
+    //   absl::CivilDay mar_4(2015, 3, 4);  // 2015-03-04 00:00:00
+    //   // feb_3 < mar_4
+    //   // absl::CivilYear(feb_3) == absl::CivilYear(mar_4)
+    //
+    //   absl::CivilSecond feb_3_noon(2015, 2, 3, 12, 0, 0);  // 2015-02-03 12:00:00
+    //   // feb_3 < feb_3_noon
+    //   // feb_3 == absl::CivilDay(feb_3_noon)
+    //
+    //   // Iterates all the days of February 2015.
+    //   for (absl::CivilDay d(2015, 2, 1); d < absl::CivilMonth(2015, 3); ++d) {
+    //     // ...
+    //   }
+    //
+    // ARITHMETIC
+    //
+    // Civil-time types support natural arithmetic operators such as addition,
+    // subtraction, and difference. Arithmetic operates on the civil-time field
+    // indicated in the type's name. Difference operators require arguments with
+    // the same alignment and return the answer in units of the alignment.
+    //
+    // Example:
+    //
+    //   absl::CivilDay a(2015, 2, 3);
+    //   ++a;                              // 2015-02-04 00:00:00
+    //   --a;                              // 2015-02-03 00:00:00
+    //   absl::CivilDay b = a + 1;         // 2015-02-04 00:00:00
+    //   absl::CivilDay c = 1 + b;         // 2015-02-05 00:00:00
+    //   int n = c - a;                    // n = 2 (civil days)
+    //   int m = c - absl::CivilMonth(c);  // Won't compile: different types.
+    //
+    // ACCESSORS
+    //
+    // Each civil-time type has accessors for all six of the civil-time fields:
+    // year, month, day, hour, minute, and second.
+    //
+    // civil_year_t year()
+    // int          month()
+    // int          day()
+    // int          hour()
+    // int          minute()
+    // int          second()
+    //
+    // Recall that fields inferior to the type's alignment will be set to their
+    // minimum valid value.
+    //
+    // Example:
+    //
+    //   absl::CivilDay d(2015, 6, 28);
+    //   // d.year() == 2015
+    //   // d.month() == 6
+    //   // d.day() == 28
+    //   // d.hour() == 0
+    //   // d.minute() == 0
+    //   // d.second() == 0
+    //
+    // CASE STUDY: Adding a month to January 31.
+    //
+    // One of the classic questions that arises when considering a civil time
+    // library (or a date library or a date/time library) is this:
+    //   "What is the result of adding a month to January 31?"
+    // This is an interesting question because it is unclear what is meant by a
+    // "month", and several different answers are possible, depending on context:
+    //
+    //   1. March 3 (or 2 if a leap year), if "add a month" means to add a month to
+    //      the current month, and adjust the date to overflow the extra days into
+    //      March. In this case the result of "February 31" would be normalized as
+    //      within the civil-time library.
+    //   2. February 28 (or 29 if a leap year), if "add a month" means to add a
+    //      month, and adjust the date while holding the resulting month constant.
+    //      In this case, the result of "February 31" would be truncated to the last
+    //      day in February.
+    //   3. An error. The caller may get some error, an exception, an invalid date
+    //      object, or perhaps return `false`. This may make sense because there is
+    //      no single unambiguously correct answer to the question.
+    //
+    // Practically speaking, any answer that is not what the programmer intended
+    // is the wrong answer.
+    //
+    // The Abseil time library avoids this problem by making it impossible to
+    // ask ambiguous questions. All civil-time objects are aligned to a particular
+    // civil-field boundary (such as aligned to a year, month, day, hour, minute,
+    // or second), and arithmetic operates on the field to which the object is
+    // aligned. This means that in order to "add a month" the object must first be
+    // aligned to a month boundary, which is equivalent to the first day of that
+    // month.
+    //
+    // Of course, there are ways to compute an answer the question at hand using
+    // this Abseil time library, but they require the programmer to be explicit
+    // about the answer they expect. To illustrate, let's see how to compute all
+    // three of the above possible answers to the question of "Jan 31 plus 1
+    // month":
+    //
+    // Example:
+    //
+    //   const absl::CivilDay d(2015, 1, 31);
+    //
+    //   // Answer 1:
+    //   // Add 1 to the month field in the constructor, and rely on normalization.
+    //   const auto normalized = absl::CivilDay(d.year(), d.month() + 1, d.day());
+    //   // normalized == 2015-03-03 (aka Feb 31)
+    //
+    //   // Answer 2:
+    //   // Add 1 to month field, capping to the end of next month.
+    //   const auto next_month = absl::CivilMonth(d) + 1;
+    //   const auto last_day_of_next_month = absl::CivilDay(next_month + 1) - 1;
+    //   const auto capped = std::min(normalized, last_day_of_next_month);
+    //   // capped == 2015-02-28
+    //
+    //   // Answer 3:
+    //   // Signal an error if the normalized answer is not in next month.
+    //   if (absl::CivilMonth(normalized) != next_month) {
+    //     // error, month overflow
+    //   }
+    //
+    using CivilSecond =
+        time_internal::cctz::detail::civil_time<time_internal::second_tag>;
+    using CivilMinute =
+        time_internal::cctz::detail::civil_time<time_internal::minute_tag>;
+    using CivilHour =
+        time_internal::cctz::detail::civil_time<time_internal::hour_tag>;
+    using CivilDay =
+        time_internal::cctz::detail::civil_time<time_internal::day_tag>;
+    using CivilMonth =
+        time_internal::cctz::detail::civil_time<time_internal::month_tag>;
+    using CivilYear =
+        time_internal::cctz::detail::civil_time<time_internal::year_tag>;
 
-// civil_year_t
-//
-// Type alias of a civil-time year value. This type is guaranteed to (at least)
-// support any year value supported by `time_t`.
-//
-// Example:
-//
-//   absl::CivilSecond cs = ...;
-//   absl::civil_year_t y = cs.year();
-//   cs = absl::CivilSecond(y, 1, 1, 0, 0, 0);  // CivilSecond(CivilYear(cs))
-//
-using civil_year_t = time_internal::cctz::year_t;
+    // civil_year_t
+    //
+    // Type alias of a civil-time year value. This type is guaranteed to (at least)
+    // support any year value supported by `time_t`.
+    //
+    // Example:
+    //
+    //   absl::CivilSecond cs = ...;
+    //   absl::civil_year_t y = cs.year();
+    //   cs = absl::CivilSecond(y, 1, 1, 0, 0, 0);  // CivilSecond(CivilYear(cs))
+    //
+    using civil_year_t = time_internal::cctz::year_t;
 
-// civil_diff_t
-//
-// Type alias of the difference between two civil-time values.
-// This type is used to indicate arguments that are not
-// normalized (such as parameters to the civil-time constructors), the results
-// of civil-time subtraction, or the operand to civil-time addition.
-//
-// Example:
-//
-//   absl::civil_diff_t n_sec = cs1 - cs2;             // cs1 == cs2 + n_sec;
-//
-using civil_diff_t = time_internal::cctz::diff_t;
+    // civil_diff_t
+    //
+    // Type alias of the difference between two civil-time values.
+    // This type is used to indicate arguments that are not
+    // normalized (such as parameters to the civil-time constructors), the results
+    // of civil-time subtraction, or the operand to civil-time addition.
+    //
+    // Example:
+    //
+    //   absl::civil_diff_t n_sec = cs1 - cs2;             // cs1 == cs2 + n_sec;
+    //
+    using civil_diff_t = time_internal::cctz::diff_t;
 
-// Weekday::monday, Weekday::tuesday, Weekday::wednesday, Weekday::thursday,
-// Weekday::friday, Weekday::saturday, Weekday::sunday
-//
-// The Weekday enum class represents the civil-time concept of a "weekday" with
-// members for all days of the week.
-//
-//   absl::Weekday wd = absl::Weekday::thursday;
-//
-using Weekday = time_internal::cctz::weekday;
+    // Weekday::monday, Weekday::tuesday, Weekday::wednesday, Weekday::thursday,
+    // Weekday::friday, Weekday::saturday, Weekday::sunday
+    //
+    // The Weekday enum class represents the civil-time concept of a "weekday" with
+    // members for all days of the week.
+    //
+    //   absl::Weekday wd = absl::Weekday::thursday;
+    //
+    using Weekday = time_internal::cctz::weekday;
 
-// GetWeekday()
-//
-// Returns the absl::Weekday for the given (realigned) civil-time value.
-//
-// Example:
-//
-//   absl::CivilDay a(2015, 8, 13);
-//   absl::Weekday wd = absl::GetWeekday(a);  // wd == absl::Weekday::thursday
-//
-inline Weekday GetWeekday(CivilSecond cs) {
-  return time_internal::cctz::get_weekday(cs);
-}
+    // GetWeekday()
+    //
+    // Returns the absl::Weekday for the given (realigned) civil-time value.
+    //
+    // Example:
+    //
+    //   absl::CivilDay a(2015, 8, 13);
+    //   absl::Weekday wd = absl::GetWeekday(a);  // wd == absl::Weekday::thursday
+    //
+    inline Weekday GetWeekday(CivilSecond cs)
+    {
+        return time_internal::cctz::get_weekday(cs);
+    }
 
-// NextWeekday()
-// PrevWeekday()
-//
-// Returns the absl::CivilDay that strictly follows or precedes a given
-// absl::CivilDay, and that falls on the given absl::Weekday.
-//
-// Example, given the following month:
-//
-//       August 2015
-//   Su Mo Tu We Th Fr Sa
-//                      1
-//    2  3  4  5  6  7  8
-//    9 10 11 12 13 14 15
-//   16 17 18 19 20 21 22
-//   23 24 25 26 27 28 29
-//   30 31
-//
-//   absl::CivilDay a(2015, 8, 13);
-//   // absl::GetWeekday(a) == absl::Weekday::thursday
-//   absl::CivilDay b = absl::NextWeekday(a, absl::Weekday::thursday);
-//   // b = 2015-08-20
-//   absl::CivilDay c = absl::PrevWeekday(a, absl::Weekday::thursday);
-//   // c = 2015-08-06
-//
-//   absl::CivilDay d = ...
-//   // Gets the following Thursday if d is not already Thursday
-//   absl::CivilDay thurs1 = absl::NextWeekday(d - 1, absl::Weekday::thursday);
-//   // Gets the previous Thursday if d is not already Thursday
-//   absl::CivilDay thurs2 = absl::PrevWeekday(d + 1, absl::Weekday::thursday);
-//
-inline CivilDay NextWeekday(CivilDay cd, Weekday wd) {
-  return CivilDay(time_internal::cctz::next_weekday(cd, wd));
-}
-inline CivilDay PrevWeekday(CivilDay cd, Weekday wd) {
-  return CivilDay(time_internal::cctz::prev_weekday(cd, wd));
-}
+    // NextWeekday()
+    // PrevWeekday()
+    //
+    // Returns the absl::CivilDay that strictly follows or precedes a given
+    // absl::CivilDay, and that falls on the given absl::Weekday.
+    //
+    // Example, given the following month:
+    //
+    //       August 2015
+    //   Su Mo Tu We Th Fr Sa
+    //                      1
+    //    2  3  4  5  6  7  8
+    //    9 10 11 12 13 14 15
+    //   16 17 18 19 20 21 22
+    //   23 24 25 26 27 28 29
+    //   30 31
+    //
+    //   absl::CivilDay a(2015, 8, 13);
+    //   // absl::GetWeekday(a) == absl::Weekday::thursday
+    //   absl::CivilDay b = absl::NextWeekday(a, absl::Weekday::thursday);
+    //   // b = 2015-08-20
+    //   absl::CivilDay c = absl::PrevWeekday(a, absl::Weekday::thursday);
+    //   // c = 2015-08-06
+    //
+    //   absl::CivilDay d = ...
+    //   // Gets the following Thursday if d is not already Thursday
+    //   absl::CivilDay thurs1 = absl::NextWeekday(d - 1, absl::Weekday::thursday);
+    //   // Gets the previous Thursday if d is not already Thursday
+    //   absl::CivilDay thurs2 = absl::PrevWeekday(d + 1, absl::Weekday::thursday);
+    //
+    inline CivilDay NextWeekday(CivilDay cd, Weekday wd)
+    {
+        return CivilDay(time_internal::cctz::next_weekday(cd, wd));
+    }
+    inline CivilDay PrevWeekday(CivilDay cd, Weekday wd)
+    {
+        return CivilDay(time_internal::cctz::prev_weekday(cd, wd));
+    }
 
-// GetYearDay()
-//
-// Returns the day-of-year for the given (realigned) civil-time value.
-//
-// Example:
-//
-//   absl::CivilDay a(2015, 1, 1);
-//   int yd_jan_1 = absl::GetYearDay(a);   // yd_jan_1 = 1
-//   absl::CivilDay b(2015, 12, 31);
-//   int yd_dec_31 = absl::GetYearDay(b);  // yd_dec_31 = 365
-//
-inline int GetYearDay(CivilSecond cs) {
-  return time_internal::cctz::get_yearday(cs);
-}
+    // GetYearDay()
+    //
+    // Returns the day-of-year for the given (realigned) civil-time value.
+    //
+    // Example:
+    //
+    //   absl::CivilDay a(2015, 1, 1);
+    //   int yd_jan_1 = absl::GetYearDay(a);   // yd_jan_1 = 1
+    //   absl::CivilDay b(2015, 12, 31);
+    //   int yd_dec_31 = absl::GetYearDay(b);  // yd_dec_31 = 365
+    //
+    inline int GetYearDay(CivilSecond cs)
+    {
+        return time_internal::cctz::get_yearday(cs);
+    }
 
-// FormatCivilTime()
-//
-// Formats the given civil-time value into a string value of the following
-// format:
-//
-//  Type        | Format
-//  ---------------------------------
-//  CivilSecond | YYYY-MM-DDTHH:MM:SS
-//  CivilMinute | YYYY-MM-DDTHH:MM
-//  CivilHour   | YYYY-MM-DDTHH
-//  CivilDay    | YYYY-MM-DD
-//  CivilMonth  | YYYY-MM
-//  CivilYear   | YYYY
-//
-// Example:
-//
-//   absl::CivilDay d = absl::CivilDay(1969, 7, 20);
-//   std::string day_string = absl::FormatCivilTime(d);  // "1969-07-20"
-//
-std::string FormatCivilTime(CivilSecond c);
-std::string FormatCivilTime(CivilMinute c);
-std::string FormatCivilTime(CivilHour c);
-std::string FormatCivilTime(CivilDay c);
-std::string FormatCivilTime(CivilMonth c);
-std::string FormatCivilTime(CivilYear c);
+    // FormatCivilTime()
+    //
+    // Formats the given civil-time value into a string value of the following
+    // format:
+    //
+    //  Type        | Format
+    //  ---------------------------------
+    //  CivilSecond | YYYY-MM-DDTHH:MM:SS
+    //  CivilMinute | YYYY-MM-DDTHH:MM
+    //  CivilHour   | YYYY-MM-DDTHH
+    //  CivilDay    | YYYY-MM-DD
+    //  CivilMonth  | YYYY-MM
+    //  CivilYear   | YYYY
+    //
+    // Example:
+    //
+    //   absl::CivilDay d = absl::CivilDay(1969, 7, 20);
+    //   std::string day_string = absl::FormatCivilTime(d);  // "1969-07-20"
+    //
+    std::string FormatCivilTime(CivilSecond c);
+    std::string FormatCivilTime(CivilMinute c);
+    std::string FormatCivilTime(CivilHour c);
+    std::string FormatCivilTime(CivilDay c);
+    std::string FormatCivilTime(CivilMonth c);
+    std::string FormatCivilTime(CivilYear c);
 
-// absl::ParseCivilTime()
-//
-// Parses a civil-time value from the specified `absl::string_view` into the
-// passed output parameter. Returns `true` upon successful parsing.
-//
-// The expected form of the input string is as follows:
-//
-//  Type        | Format
-//  ---------------------------------
-//  CivilSecond | YYYY-MM-DDTHH:MM:SS
-//  CivilMinute | YYYY-MM-DDTHH:MM
-//  CivilHour   | YYYY-MM-DDTHH
-//  CivilDay    | YYYY-MM-DD
-//  CivilMonth  | YYYY-MM
-//  CivilYear   | YYYY
-//
-// Example:
-//
-//   absl::CivilDay d;
-//   bool ok = absl::ParseCivilTime("2018-01-02", &d); // OK
-//
-// Note that parsing will fail if the string's format does not match the
-// expected type exactly. `ParseLenientCivilTime()` below is more lenient.
-//
-bool ParseCivilTime(absl::string_view s, CivilSecond* c);
-bool ParseCivilTime(absl::string_view s, CivilMinute* c);
-bool ParseCivilTime(absl::string_view s, CivilHour* c);
-bool ParseCivilTime(absl::string_view s, CivilDay* c);
-bool ParseCivilTime(absl::string_view s, CivilMonth* c);
-bool ParseCivilTime(absl::string_view s, CivilYear* c);
+    // absl::ParseCivilTime()
+    //
+    // Parses a civil-time value from the specified `absl::string_view` into the
+    // passed output parameter. Returns `true` upon successful parsing.
+    //
+    // The expected form of the input string is as follows:
+    //
+    //  Type        | Format
+    //  ---------------------------------
+    //  CivilSecond | YYYY-MM-DDTHH:MM:SS
+    //  CivilMinute | YYYY-MM-DDTHH:MM
+    //  CivilHour   | YYYY-MM-DDTHH
+    //  CivilDay    | YYYY-MM-DD
+    //  CivilMonth  | YYYY-MM
+    //  CivilYear   | YYYY
+    //
+    // Example:
+    //
+    //   absl::CivilDay d;
+    //   bool ok = absl::ParseCivilTime("2018-01-02", &d); // OK
+    //
+    // Note that parsing will fail if the string's format does not match the
+    // expected type exactly. `ParseLenientCivilTime()` below is more lenient.
+    //
+    bool ParseCivilTime(absl::string_view s, CivilSecond* c);
+    bool ParseCivilTime(absl::string_view s, CivilMinute* c);
+    bool ParseCivilTime(absl::string_view s, CivilHour* c);
+    bool ParseCivilTime(absl::string_view s, CivilDay* c);
+    bool ParseCivilTime(absl::string_view s, CivilMonth* c);
+    bool ParseCivilTime(absl::string_view s, CivilYear* c);
 
-// ParseLenientCivilTime()
-//
-// Parses any of the formats accepted by `absl::ParseCivilTime()`, but is more
-// lenient if the format of the string does not exactly match the associated
-// type.
-//
-// Example:
-//
-//   absl::CivilDay d;
-//   bool ok = absl::ParseLenientCivilTime("1969-07-20", &d); // OK
-//   ok = absl::ParseLenientCivilTime("1969-07-20T10", &d);   // OK: T10 floored
-//   ok = absl::ParseLenientCivilTime("1969-07", &d);   // OK: day defaults to 1
-//
-bool ParseLenientCivilTime(absl::string_view s, CivilSecond* c);
-bool ParseLenientCivilTime(absl::string_view s, CivilMinute* c);
-bool ParseLenientCivilTime(absl::string_view s, CivilHour* c);
-bool ParseLenientCivilTime(absl::string_view s, CivilDay* c);
-bool ParseLenientCivilTime(absl::string_view s, CivilMonth* c);
-bool ParseLenientCivilTime(absl::string_view s, CivilYear* c);
+    // ParseLenientCivilTime()
+    //
+    // Parses any of the formats accepted by `absl::ParseCivilTime()`, but is more
+    // lenient if the format of the string does not exactly match the associated
+    // type.
+    //
+    // Example:
+    //
+    //   absl::CivilDay d;
+    //   bool ok = absl::ParseLenientCivilTime("1969-07-20", &d); // OK
+    //   ok = absl::ParseLenientCivilTime("1969-07-20T10", &d);   // OK: T10 floored
+    //   ok = absl::ParseLenientCivilTime("1969-07", &d);   // OK: day defaults to 1
+    //
+    bool ParseLenientCivilTime(absl::string_view s, CivilSecond* c);
+    bool ParseLenientCivilTime(absl::string_view s, CivilMinute* c);
+    bool ParseLenientCivilTime(absl::string_view s, CivilHour* c);
+    bool ParseLenientCivilTime(absl::string_view s, CivilDay* c);
+    bool ParseLenientCivilTime(absl::string_view s, CivilMonth* c);
+    bool ParseLenientCivilTime(absl::string_view s, CivilYear* c);
 
-namespace time_internal {  // For functions found via ADL on civil-time tags.
+    namespace time_internal
+    {  // For functions found via ADL on civil-time tags.
 
-// Streaming Operators
-//
-// Each civil-time type may be sent to an output stream using operator<<().
-// The result matches the string produced by `FormatCivilTime()`.
-//
-// Example:
-//
-//   absl::CivilDay d = absl::CivilDay(1969, 7, 20);
-//   std::cout << "Date is: " << d << "\n";
-//
-std::ostream& operator<<(std::ostream& os, CivilYear y);
-std::ostream& operator<<(std::ostream& os, CivilMonth m);
-std::ostream& operator<<(std::ostream& os, CivilDay d);
-std::ostream& operator<<(std::ostream& os, CivilHour h);
-std::ostream& operator<<(std::ostream& os, CivilMinute m);
-std::ostream& operator<<(std::ostream& os, CivilSecond s);
+        // Streaming Operators
+        //
+        // Each civil-time type may be sent to an output stream using operator<<().
+        // The result matches the string produced by `FormatCivilTime()`.
+        //
+        // Example:
+        //
+        //   absl::CivilDay d = absl::CivilDay(1969, 7, 20);
+        //   std::cout << "Date is: " << d << "\n";
+        //
+        std::ostream& operator<<(std::ostream& os, CivilYear y);
+        std::ostream& operator<<(std::ostream& os, CivilMonth m);
+        std::ostream& operator<<(std::ostream& os, CivilDay d);
+        std::ostream& operator<<(std::ostream& os, CivilHour h);
+        std::ostream& operator<<(std::ostream& os, CivilMinute m);
+        std::ostream& operator<<(std::ostream& os, CivilSecond s);
 
-}  // namespace time_internal
+    }  // namespace time_internal
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_CIVIL_TIME_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/clock.h b/CAPI/cpp/grpc/include/absl/time/clock.h
index 5fe244d..459d113 100644
--- a/CAPI/cpp/grpc/include/absl/time/clock.h
+++ b/CAPI/cpp/grpc/include/absl/time/clock.h
@@ -25,32 +25,33 @@
 #include "absl/base/macros.h"
 #include "absl/time/time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// Now()
-//
-// Returns the current time, expressed as an `absl::Time` absolute time value.
-absl::Time Now();
+    // Now()
+    //
+    // Returns the current time, expressed as an `absl::Time` absolute time value.
+    absl::Time Now();
 
-// GetCurrentTimeNanos()
-//
-// Returns the current time, expressed as a count of nanoseconds since the Unix
-// Epoch (https://en.wikipedia.org/wiki/Unix_time). Prefer `absl::Now()` instead
-// for all but the most performance-sensitive cases (i.e. when you are calling
-// this function hundreds of thousands of times per second).
-int64_t GetCurrentTimeNanos();
+    // GetCurrentTimeNanos()
+    //
+    // Returns the current time, expressed as a count of nanoseconds since the Unix
+    // Epoch (https://en.wikipedia.org/wiki/Unix_time). Prefer `absl::Now()` instead
+    // for all but the most performance-sensitive cases (i.e. when you are calling
+    // this function hundreds of thousands of times per second).
+    int64_t GetCurrentTimeNanos();
 
-// SleepFor()
-//
-// Sleeps for the specified duration, expressed as an `absl::Duration`.
-//
-// Notes:
-// * Signal interruptions will not reduce the sleep duration.
-// * Returns immediately when passed a nonpositive duration.
-void SleepFor(absl::Duration duration);
+    // SleepFor()
+    //
+    // Sleeps for the specified duration, expressed as an `absl::Duration`.
+    //
+    // Notes:
+    // * Signal interruptions will not reduce the sleep duration.
+    // * Returns immediately when passed a nonpositive duration.
+    void SleepFor(absl::Duration duration);
 
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 // -----------------------------------------------------------------------------
@@ -63,12 +64,15 @@ ABSL_NAMESPACE_END
 // --detect-odr-violations ignores symbols not mangled with C++ names.
 // By changing our extension points to be extern "C", we dodge this
 // check.
-extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(absl::Duration duration);
+extern "C"
+{
+    void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(absl::Duration duration);
 }  // extern "C"
 
-inline void absl::SleepFor(absl::Duration duration) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration);
+inline void absl::SleepFor(absl::Duration duration)
+{
+    ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)
+    (duration);
 }
 
 #endif  // ABSL_TIME_CLOCK_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time.h
index d47ff86..8d6aa9f 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time.h
@@ -18,315 +18,318 @@
 #include "absl/base/config.h"
 #include "absl/time/internal/cctz/include/cctz/civil_time_detail.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
 
-// The term "civil time" refers to the legally recognized human-scale time
-// that is represented by the six fields YYYY-MM-DD hh:mm:ss. Modern-day civil
-// time follows the Gregorian Calendar and is a time-zone-independent concept.
-// A "date" is perhaps the most common example of a civil time (represented in
-// this library as cctz::civil_day). This library provides six classes and a
-// handful of functions that help with rounding, iterating, and arithmetic on
-// civil times while avoiding complications like daylight-saving time (DST).
-//
-// The following six classes form the core of this civil-time library:
-//
-//   * civil_second
-//   * civil_minute
-//   * civil_hour
-//   * civil_day
-//   * civil_month
-//   * civil_year
-//
-// Each class is a simple value type with the same interface for construction
-// and the same six accessors for each of the civil fields (year, month, day,
-// hour, minute, and second, aka YMDHMS). These classes differ only in their
-// alignment, which is indicated by the type name and specifies the field on
-// which arithmetic operates.
-//
-// Each class can be constructed by passing up to six optional integer
-// arguments representing the YMDHMS fields (in that order) to the
-// constructor. Omitted fields are assigned their minimum valid value. Hours,
-// minutes, and seconds will be set to 0, month and day will be set to 1, and
-// since there is no minimum valid year, it will be set to 1970. So, a
-// default-constructed civil-time object will have YMDHMS fields representing
-// "1970-01-01 00:00:00". Fields that are out-of-range are normalized (e.g.,
-// October 32 -> November 1) so that all civil-time objects represent valid
-// values.
-//
-// Each civil-time class is aligned to the civil-time field indicated in the
-// class's name after normalization. Alignment is performed by setting all the
-// inferior fields to their minimum valid value (as described above). The
-// following are examples of how each of the six types would align the fields
-// representing November 22, 2015 at 12:34:56 in the afternoon. (Note: the
-// string format used here is not important; it's just a shorthand way of
-// showing the six YMDHMS fields.)
-//
-//   civil_second  2015-11-22 12:34:56
-//   civil_minute  2015-11-22 12:34:00
-//   civil_hour    2015-11-22 12:00:00
-//   civil_day     2015-11-22 00:00:00
-//   civil_month   2015-11-01 00:00:00
-//   civil_year    2015-01-01 00:00:00
-//
-// Each civil-time type performs arithmetic on the field to which it is
-// aligned. This means that adding 1 to a civil_day increments the day field
-// (normalizing as necessary), and subtracting 7 from a civil_month operates
-// on the month field (normalizing as necessary). All arithmetic produces a
-// valid civil time. Difference requires two similarly aligned civil-time
-// objects and returns the scalar answer in units of the objects' alignment.
-// For example, the difference between two civil_hour objects will give an
-// answer in units of civil hours.
-//
-// In addition to the six civil-time types just described, there are
-// a handful of helper functions and algorithms for performing common
-// calculations. These are described below.
-//
-// Note: In C++14 and later, this library is usable in a constexpr context.
-//
-// CONSTRUCTION:
-//
-// Each of the civil-time types can be constructed in two ways: by directly
-// passing to the constructor up to six (optional) integers representing the
-// YMDHMS fields, or by copying the YMDHMS fields from a differently aligned
-// civil-time type.
-//
-//   civil_day default_value;  // 1970-01-01 00:00:00
-//
-//   civil_day a(2015, 2, 3);           // 2015-02-03 00:00:00
-//   civil_day b(2015, 2, 3, 4, 5, 6);  // 2015-02-03 00:00:00
-//   civil_day c(2015);                 // 2015-01-01 00:00:00
-//
-//   civil_second ss(2015, 2, 3, 4, 5, 6);  // 2015-02-03 04:05:06
-//   civil_minute mm(ss);                   // 2015-02-03 04:05:00
-//   civil_hour hh(mm);                     // 2015-02-03 04:00:00
-//   civil_day d(hh);                       // 2015-02-03 00:00:00
-//   civil_month m(d);                      // 2015-02-01 00:00:00
-//   civil_year y(m);                       // 2015-01-01 00:00:00
-//
-//   m = civil_month(y);     // 2015-01-01 00:00:00
-//   d = civil_day(m);       // 2015-01-01 00:00:00
-//   hh = civil_hour(d);     // 2015-01-01 00:00:00
-//   mm = civil_minute(hh);  // 2015-01-01 00:00:00
-//   ss = civil_second(mm);  // 2015-01-01 00:00:00
-//
-// ALIGNMENT CONVERSION:
-//
-// The alignment of a civil-time object cannot change, but the object may be
-// used to construct a new object with a different alignment. This is referred
-// to as "realigning". When realigning to a type with the same or more
-// precision (e.g., civil_day -> civil_second), the conversion may be
-// performed implicitly since no information is lost. However, if information
-// could be discarded (e.g., civil_second -> civil_day), the conversion must
-// be explicit at the call site.
-//
-//   void fun(const civil_day& day);
-//
-//   civil_second cs;
-//   fun(cs);  // Won't compile because data may be discarded
-//   fun(civil_day(cs));  // OK: explicit conversion
-//
-//   civil_day cd;
-//   fun(cd);  // OK: no conversion needed
-//
-//   civil_month cm;
-//   fun(cm);  // OK: implicit conversion to civil_day
-//
-// NORMALIZATION:
-//
-// Integer arguments passed to the constructor may be out-of-range, in which
-// case they are normalized to produce a valid civil-time object. This enables
-// natural arithmetic on constructor arguments without worrying about the
-// field's range. Normalization guarantees that there are no invalid
-// civil-time objects.
-//
-//   civil_day d(2016, 10, 32);  // Out-of-range day; normalized to 2016-11-01
-//
-// Note: If normalization is undesired, you can signal an error by comparing
-// the constructor arguments to the normalized values returned by the YMDHMS
-// properties.
-//
-// PROPERTIES:
-//
-// All civil-time types have accessors for all six of the civil-time fields:
-// year, month, day, hour, minute, and second. Recall that fields inferior to
-// the type's alignment will be set to their minimum valid value.
-//
-//   civil_day d(2015, 6, 28);
-//   // d.year() == 2015
-//   // d.month() == 6
-//   // d.day() == 28
-//   // d.hour() == 0
-//   // d.minute() == 0
-//   // d.second() == 0
-//
-// COMPARISON:
-//
-// Comparison always considers all six YMDHMS fields, regardless of the type's
-// alignment. Comparison between differently aligned civil-time types is
-// allowed.
-//
-//   civil_day feb_3(2015, 2, 3);  // 2015-02-03 00:00:00
-//   civil_day mar_4(2015, 3, 4);  // 2015-03-04 00:00:00
-//   // feb_3 < mar_4
-//   // civil_year(feb_3) == civil_year(mar_4)
-//
-//   civil_second feb_3_noon(2015, 2, 3, 12, 0, 0);  // 2015-02-03 12:00:00
-//   // feb_3 < feb_3_noon
-//   // feb_3 == civil_day(feb_3_noon)
-//
-//   // Iterates all the days of February 2015.
-//   for (civil_day d(2015, 2, 1); d < civil_month(2015, 3); ++d) {
-//     // ...
-//   }
-//
-// STREAMING:
-//
-// Each civil-time type may be sent to an output stream using operator<<().
-// The output format follows the pattern "YYYY-MM-DDThh:mm:ss" where fields
-// inferior to the type's alignment are omitted.
-//
-//   civil_second cs(2015, 2, 3, 4, 5, 6);
-//   std::cout << cs << "\n";  // Outputs: 2015-02-03T04:05:06
-//
-//   civil_day cd(cs);
-//   std::cout << cd << "\n";  // Outputs: 2015-02-03
-//
-//   civil_year cy(cs);
-//   std::cout << cy << "\n";  // Outputs: 2015
-//
-// ARITHMETIC:
-//
-// Civil-time types support natural arithmetic operators such as addition,
-// subtraction, and difference. Arithmetic operates on the civil-time field
-// indicated in the type's name. Difference requires arguments with the same
-// alignment and returns the answer in units of the alignment.
-//
-//   civil_day a(2015, 2, 3);
-//   ++a;                         // 2015-02-04 00:00:00
-//   --a;                         // 2015-02-03 00:00:00
-//   civil_day b = a + 1;         // 2015-02-04 00:00:00
-//   civil_day c = 1 + b;         // 2015-02-05 00:00:00
-//   int n = c - a;               // n = 2 (civil days)
-//   int m = c - civil_month(c);  // Won't compile: different types.
-//
-// EXAMPLE: Adding a month to January 31.
-//
-// One of the classic questions that arises when considering a civil-time
-// library (or a date library or a date/time library) is this: "What happens
-// when you add a month to January 31?" This is an interesting question
-// because there could be a number of possible answers:
-//
-//   1. March 3 (or 2 if a leap year). This may make sense if the operation
-//      wants the equivalent of February 31.
-//   2. February 28 (or 29 if a leap year). This may make sense if the operation
-//      wants the last day of January to go to the last day of February.
-//   3. Error. The caller may get some error, an exception, an invalid date
-//      object, or maybe false is returned. This may make sense because there is
-//      no single unambiguously correct answer to the question.
-//
-// Practically speaking, any answer that is not what the programmer intended
-// is the wrong answer.
-//
-// This civil-time library avoids the problem by making it impossible to ask
-// ambiguous questions. All civil-time objects are aligned to a particular
-// civil-field boundary (such as aligned to a year, month, day, hour, minute,
-// or second), and arithmetic operates on the field to which the object is
-// aligned. This means that in order to "add a month" the object must first be
-// aligned to a month boundary, which is equivalent to the first day of that
-// month.
-//
-// Of course, there are ways to compute an answer the question at hand using
-// this civil-time library, but they require the programmer to be explicit
-// about the answer they expect. To illustrate, let's see how to compute all
-// three of the above possible answers to the question of "Jan 31 plus 1
-// month":
-//
-//   const civil_day d(2015, 1, 31);
-//
-//   // Answer 1:
-//   // Add 1 to the month field in the constructor, and rely on normalization.
-//   const auto ans_normalized = civil_day(d.year(), d.month() + 1, d.day());
-//   // ans_normalized == 2015-03-03 (aka Feb 31)
-//
-//   // Answer 2:
-//   // Add 1 to month field, capping to the end of next month.
-//   const auto next_month = civil_month(d) + 1;
-//   const auto last_day_of_next_month = civil_day(next_month + 1) - 1;
-//   const auto ans_capped = std::min(ans_normalized, last_day_of_next_month);
-//   // ans_capped == 2015-02-28
-//
-//   // Answer 3:
-//   // Signal an error if the normalized answer is not in next month.
-//   if (civil_month(ans_normalized) != next_month) {
-//     // error, month overflow
-//   }
-//
-using civil_year = detail::civil_year;
-using civil_month = detail::civil_month;
-using civil_day = detail::civil_day;
-using civil_hour = detail::civil_hour;
-using civil_minute = detail::civil_minute;
-using civil_second = detail::civil_second;
+            // The term "civil time" refers to the legally recognized human-scale time
+            // that is represented by the six fields YYYY-MM-DD hh:mm:ss. Modern-day civil
+            // time follows the Gregorian Calendar and is a time-zone-independent concept.
+            // A "date" is perhaps the most common example of a civil time (represented in
+            // this library as cctz::civil_day). This library provides six classes and a
+            // handful of functions that help with rounding, iterating, and arithmetic on
+            // civil times while avoiding complications like daylight-saving time (DST).
+            //
+            // The following six classes form the core of this civil-time library:
+            //
+            //   * civil_second
+            //   * civil_minute
+            //   * civil_hour
+            //   * civil_day
+            //   * civil_month
+            //   * civil_year
+            //
+            // Each class is a simple value type with the same interface for construction
+            // and the same six accessors for each of the civil fields (year, month, day,
+            // hour, minute, and second, aka YMDHMS). These classes differ only in their
+            // alignment, which is indicated by the type name and specifies the field on
+            // which arithmetic operates.
+            //
+            // Each class can be constructed by passing up to six optional integer
+            // arguments representing the YMDHMS fields (in that order) to the
+            // constructor. Omitted fields are assigned their minimum valid value. Hours,
+            // minutes, and seconds will be set to 0, month and day will be set to 1, and
+            // since there is no minimum valid year, it will be set to 1970. So, a
+            // default-constructed civil-time object will have YMDHMS fields representing
+            // "1970-01-01 00:00:00". Fields that are out-of-range are normalized (e.g.,
+            // October 32 -> November 1) so that all civil-time objects represent valid
+            // values.
+            //
+            // Each civil-time class is aligned to the civil-time field indicated in the
+            // class's name after normalization. Alignment is performed by setting all the
+            // inferior fields to their minimum valid value (as described above). The
+            // following are examples of how each of the six types would align the fields
+            // representing November 22, 2015 at 12:34:56 in the afternoon. (Note: the
+            // string format used here is not important; it's just a shorthand way of
+            // showing the six YMDHMS fields.)
+            //
+            //   civil_second  2015-11-22 12:34:56
+            //   civil_minute  2015-11-22 12:34:00
+            //   civil_hour    2015-11-22 12:00:00
+            //   civil_day     2015-11-22 00:00:00
+            //   civil_month   2015-11-01 00:00:00
+            //   civil_year    2015-01-01 00:00:00
+            //
+            // Each civil-time type performs arithmetic on the field to which it is
+            // aligned. This means that adding 1 to a civil_day increments the day field
+            // (normalizing as necessary), and subtracting 7 from a civil_month operates
+            // on the month field (normalizing as necessary). All arithmetic produces a
+            // valid civil time. Difference requires two similarly aligned civil-time
+            // objects and returns the scalar answer in units of the objects' alignment.
+            // For example, the difference between two civil_hour objects will give an
+            // answer in units of civil hours.
+            //
+            // In addition to the six civil-time types just described, there are
+            // a handful of helper functions and algorithms for performing common
+            // calculations. These are described below.
+            //
+            // Note: In C++14 and later, this library is usable in a constexpr context.
+            //
+            // CONSTRUCTION:
+            //
+            // Each of the civil-time types can be constructed in two ways: by directly
+            // passing to the constructor up to six (optional) integers representing the
+            // YMDHMS fields, or by copying the YMDHMS fields from a differently aligned
+            // civil-time type.
+            //
+            //   civil_day default_value;  // 1970-01-01 00:00:00
+            //
+            //   civil_day a(2015, 2, 3);           // 2015-02-03 00:00:00
+            //   civil_day b(2015, 2, 3, 4, 5, 6);  // 2015-02-03 00:00:00
+            //   civil_day c(2015);                 // 2015-01-01 00:00:00
+            //
+            //   civil_second ss(2015, 2, 3, 4, 5, 6);  // 2015-02-03 04:05:06
+            //   civil_minute mm(ss);                   // 2015-02-03 04:05:00
+            //   civil_hour hh(mm);                     // 2015-02-03 04:00:00
+            //   civil_day d(hh);                       // 2015-02-03 00:00:00
+            //   civil_month m(d);                      // 2015-02-01 00:00:00
+            //   civil_year y(m);                       // 2015-01-01 00:00:00
+            //
+            //   m = civil_month(y);     // 2015-01-01 00:00:00
+            //   d = civil_day(m);       // 2015-01-01 00:00:00
+            //   hh = civil_hour(d);     // 2015-01-01 00:00:00
+            //   mm = civil_minute(hh);  // 2015-01-01 00:00:00
+            //   ss = civil_second(mm);  // 2015-01-01 00:00:00
+            //
+            // ALIGNMENT CONVERSION:
+            //
+            // The alignment of a civil-time object cannot change, but the object may be
+            // used to construct a new object with a different alignment. This is referred
+            // to as "realigning". When realigning to a type with the same or more
+            // precision (e.g., civil_day -> civil_second), the conversion may be
+            // performed implicitly since no information is lost. However, if information
+            // could be discarded (e.g., civil_second -> civil_day), the conversion must
+            // be explicit at the call site.
+            //
+            //   void fun(const civil_day& day);
+            //
+            //   civil_second cs;
+            //   fun(cs);  // Won't compile because data may be discarded
+            //   fun(civil_day(cs));  // OK: explicit conversion
+            //
+            //   civil_day cd;
+            //   fun(cd);  // OK: no conversion needed
+            //
+            //   civil_month cm;
+            //   fun(cm);  // OK: implicit conversion to civil_day
+            //
+            // NORMALIZATION:
+            //
+            // Integer arguments passed to the constructor may be out-of-range, in which
+            // case they are normalized to produce a valid civil-time object. This enables
+            // natural arithmetic on constructor arguments without worrying about the
+            // field's range. Normalization guarantees that there are no invalid
+            // civil-time objects.
+            //
+            //   civil_day d(2016, 10, 32);  // Out-of-range day; normalized to 2016-11-01
+            //
+            // Note: If normalization is undesired, you can signal an error by comparing
+            // the constructor arguments to the normalized values returned by the YMDHMS
+            // properties.
+            //
+            // PROPERTIES:
+            //
+            // All civil-time types have accessors for all six of the civil-time fields:
+            // year, month, day, hour, minute, and second. Recall that fields inferior to
+            // the type's alignment will be set to their minimum valid value.
+            //
+            //   civil_day d(2015, 6, 28);
+            //   // d.year() == 2015
+            //   // d.month() == 6
+            //   // d.day() == 28
+            //   // d.hour() == 0
+            //   // d.minute() == 0
+            //   // d.second() == 0
+            //
+            // COMPARISON:
+            //
+            // Comparison always considers all six YMDHMS fields, regardless of the type's
+            // alignment. Comparison between differently aligned civil-time types is
+            // allowed.
+            //
+            //   civil_day feb_3(2015, 2, 3);  // 2015-02-03 00:00:00
+            //   civil_day mar_4(2015, 3, 4);  // 2015-03-04 00:00:00
+            //   // feb_3 < mar_4
+            //   // civil_year(feb_3) == civil_year(mar_4)
+            //
+            //   civil_second feb_3_noon(2015, 2, 3, 12, 0, 0);  // 2015-02-03 12:00:00
+            //   // feb_3 < feb_3_noon
+            //   // feb_3 == civil_day(feb_3_noon)
+            //
+            //   // Iterates all the days of February 2015.
+            //   for (civil_day d(2015, 2, 1); d < civil_month(2015, 3); ++d) {
+            //     // ...
+            //   }
+            //
+            // STREAMING:
+            //
+            // Each civil-time type may be sent to an output stream using operator<<().
+            // The output format follows the pattern "YYYY-MM-DDThh:mm:ss" where fields
+            // inferior to the type's alignment are omitted.
+            //
+            //   civil_second cs(2015, 2, 3, 4, 5, 6);
+            //   std::cout << cs << "\n";  // Outputs: 2015-02-03T04:05:06
+            //
+            //   civil_day cd(cs);
+            //   std::cout << cd << "\n";  // Outputs: 2015-02-03
+            //
+            //   civil_year cy(cs);
+            //   std::cout << cy << "\n";  // Outputs: 2015
+            //
+            // ARITHMETIC:
+            //
+            // Civil-time types support natural arithmetic operators such as addition,
+            // subtraction, and difference. Arithmetic operates on the civil-time field
+            // indicated in the type's name. Difference requires arguments with the same
+            // alignment and returns the answer in units of the alignment.
+            //
+            //   civil_day a(2015, 2, 3);
+            //   ++a;                         // 2015-02-04 00:00:00
+            //   --a;                         // 2015-02-03 00:00:00
+            //   civil_day b = a + 1;         // 2015-02-04 00:00:00
+            //   civil_day c = 1 + b;         // 2015-02-05 00:00:00
+            //   int n = c - a;               // n = 2 (civil days)
+            //   int m = c - civil_month(c);  // Won't compile: different types.
+            //
+            // EXAMPLE: Adding a month to January 31.
+            //
+            // One of the classic questions that arises when considering a civil-time
+            // library (or a date library or a date/time library) is this: "What happens
+            // when you add a month to January 31?" This is an interesting question
+            // because there could be a number of possible answers:
+            //
+            //   1. March 3 (or 2 if a leap year). This may make sense if the operation
+            //      wants the equivalent of February 31.
+            //   2. February 28 (or 29 if a leap year). This may make sense if the operation
+            //      wants the last day of January to go to the last day of February.
+            //   3. Error. The caller may get some error, an exception, an invalid date
+            //      object, or maybe false is returned. This may make sense because there is
+            //      no single unambiguously correct answer to the question.
+            //
+            // Practically speaking, any answer that is not what the programmer intended
+            // is the wrong answer.
+            //
+            // This civil-time library avoids the problem by making it impossible to ask
+            // ambiguous questions. All civil-time objects are aligned to a particular
+            // civil-field boundary (such as aligned to a year, month, day, hour, minute,
+            // or second), and arithmetic operates on the field to which the object is
+            // aligned. This means that in order to "add a month" the object must first be
+            // aligned to a month boundary, which is equivalent to the first day of that
+            // month.
+            //
+            // Of course, there are ways to compute an answer the question at hand using
+            // this civil-time library, but they require the programmer to be explicit
+            // about the answer they expect. To illustrate, let's see how to compute all
+            // three of the above possible answers to the question of "Jan 31 plus 1
+            // month":
+            //
+            //   const civil_day d(2015, 1, 31);
+            //
+            //   // Answer 1:
+            //   // Add 1 to the month field in the constructor, and rely on normalization.
+            //   const auto ans_normalized = civil_day(d.year(), d.month() + 1, d.day());
+            //   // ans_normalized == 2015-03-03 (aka Feb 31)
+            //
+            //   // Answer 2:
+            //   // Add 1 to month field, capping to the end of next month.
+            //   const auto next_month = civil_month(d) + 1;
+            //   const auto last_day_of_next_month = civil_day(next_month + 1) - 1;
+            //   const auto ans_capped = std::min(ans_normalized, last_day_of_next_month);
+            //   // ans_capped == 2015-02-28
+            //
+            //   // Answer 3:
+            //   // Signal an error if the normalized answer is not in next month.
+            //   if (civil_month(ans_normalized) != next_month) {
+            //     // error, month overflow
+            //   }
+            //
+            using civil_year = detail::civil_year;
+            using civil_month = detail::civil_month;
+            using civil_day = detail::civil_day;
+            using civil_hour = detail::civil_hour;
+            using civil_minute = detail::civil_minute;
+            using civil_second = detail::civil_second;
 
-// An enum class with members monday, tuesday, wednesday, thursday, friday,
-// saturday, and sunday. These enum values may be sent to an output stream
-// using operator<<(). The result is the full weekday name in English with a
-// leading capital letter.
-//
-//   weekday wd = weekday::thursday;
-//   std::cout << wd << "\n";  // Outputs: Thursday
-//
-using detail::weekday;
+            // An enum class with members monday, tuesday, wednesday, thursday, friday,
+            // saturday, and sunday. These enum values may be sent to an output stream
+            // using operator<<(). The result is the full weekday name in English with a
+            // leading capital letter.
+            //
+            //   weekday wd = weekday::thursday;
+            //   std::cout << wd << "\n";  // Outputs: Thursday
+            //
+            using detail::weekday;
 
-// Returns the weekday for the given civil-time value.
-//
-//   civil_day a(2015, 8, 13);
-//   weekday wd = get_weekday(a);  // wd == weekday::thursday
-//
-using detail::get_weekday;
+            // Returns the weekday for the given civil-time value.
+            //
+            //   civil_day a(2015, 8, 13);
+            //   weekday wd = get_weekday(a);  // wd == weekday::thursday
+            //
+            using detail::get_weekday;
 
-// Returns the civil_day that strictly follows or precedes the given
-// civil_day, and that falls on the given weekday.
-//
-// For example, given:
-//
-//     August 2015
-// Su Mo Tu We Th Fr Sa
-//                    1
-//  2  3  4  5  6  7  8
-//  9 10 11 12 13 14 15
-// 16 17 18 19 20 21 22
-// 23 24 25 26 27 28 29
-// 30 31
-//
-//   civil_day a(2015, 8, 13);  // get_weekday(a) == weekday::thursday
-//   civil_day b = next_weekday(a, weekday::thursday);  // b = 2015-08-20
-//   civil_day c = prev_weekday(a, weekday::thursday);  // c = 2015-08-06
-//
-//   civil_day d = ...
-//   // Gets the following Thursday if d is not already Thursday
-//   civil_day thurs1 = next_weekday(d - 1, weekday::thursday);
-//   // Gets the previous Thursday if d is not already Thursday
-//   civil_day thurs2 = prev_weekday(d + 1, weekday::thursday);
-//
-using detail::next_weekday;
-using detail::prev_weekday;
+            // Returns the civil_day that strictly follows or precedes the given
+            // civil_day, and that falls on the given weekday.
+            //
+            // For example, given:
+            //
+            //     August 2015
+            // Su Mo Tu We Th Fr Sa
+            //                    1
+            //  2  3  4  5  6  7  8
+            //  9 10 11 12 13 14 15
+            // 16 17 18 19 20 21 22
+            // 23 24 25 26 27 28 29
+            // 30 31
+            //
+            //   civil_day a(2015, 8, 13);  // get_weekday(a) == weekday::thursday
+            //   civil_day b = next_weekday(a, weekday::thursday);  // b = 2015-08-20
+            //   civil_day c = prev_weekday(a, weekday::thursday);  // c = 2015-08-06
+            //
+            //   civil_day d = ...
+            //   // Gets the following Thursday if d is not already Thursday
+            //   civil_day thurs1 = next_weekday(d - 1, weekday::thursday);
+            //   // Gets the previous Thursday if d is not already Thursday
+            //   civil_day thurs2 = prev_weekday(d + 1, weekday::thursday);
+            //
+            using detail::next_weekday;
+            using detail::prev_weekday;
 
-// Returns the day-of-year for the given civil-time value.
-//
-//   civil_day a(2015, 1, 1);
-//   int yd_jan_1 = get_yearday(a);   // yd_jan_1 = 1
-//   civil_day b(2015, 12, 31);
-//   int yd_dec_31 = get_yearday(b);  // yd_dec_31 = 365
-//
-using detail::get_yearday;
+            // Returns the day-of-year for the given civil-time value.
+            //
+            //   civil_day a(2015, 1, 1);
+            //   int yd_jan_1 = get_yearday(a);   // yd_jan_1 = 1
+            //   civil_day b(2015, 12, 31);
+            //   int yd_dec_31 = get_yearday(b);  // yd_dec_31 = 365
+            //
+            using detail::get_yearday;
 
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+        }  // namespace cctz
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time_detail.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time_detail.h
index a5b084e..d696b42 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time_detail.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/civil_time_detail.h
@@ -33,596 +33,796 @@
 #define CONSTEXPR_M
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-// Support years that at least span the range of 64-bit time_t values.
-using year_t = std::int_fast64_t;
-
-// Type alias that indicates an argument is not normalized (e.g., the
-// constructor parameters and operands/results of addition/subtraction).
-using diff_t = std::int_fast64_t;
-
-namespace detail {
-
-// Type aliases that indicate normalized argument values.
-using month_t = std::int_fast8_t;   // [1:12]
-using day_t = std::int_fast8_t;     // [1:31]
-using hour_t = std::int_fast8_t;    // [0:23]
-using minute_t = std::int_fast8_t;  // [0:59]
-using second_t = std::int_fast8_t;  // [0:59]
-
-// Normalized civil-time fields: Y-M-D HH:MM:SS.
-struct fields {
-  CONSTEXPR_M fields(year_t year, month_t month, day_t day, hour_t hour,
-                     minute_t minute, second_t second)
-      : y(year), m(month), d(day), hh(hour), mm(minute), ss(second) {}
-  std::int_least64_t y;
-  std::int_least8_t m;
-  std::int_least8_t d;
-  std::int_least8_t hh;
-  std::int_least8_t mm;
-  std::int_least8_t ss;
-};
-
-struct second_tag {};
-struct minute_tag : second_tag {};
-struct hour_tag : minute_tag {};
-struct day_tag : hour_tag {};
-struct month_tag : day_tag {};
-struct year_tag : month_tag {};
-
-////////////////////////////////////////////////////////////////////////
-
-// Field normalization (without avoidable overflow).
-
-namespace impl {
-
-CONSTEXPR_F bool is_leap_year(year_t y) noexcept {
-  return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
-}
-CONSTEXPR_F int year_index(year_t y, month_t m) noexcept {
-  const int yi = static_cast<int>((y + (m > 2)) % 400);
-  return yi < 0 ? yi + 400 : yi;
-}
-CONSTEXPR_F int days_per_century(int yi) noexcept {
-  return 36524 + (yi == 0 || yi > 300);
-}
-CONSTEXPR_F int days_per_4years(int yi) noexcept {
-  return 1460 + (yi == 0 || yi > 300 || (yi - 1) % 100 < 96);
-}
-CONSTEXPR_F int days_per_year(year_t y, month_t m) noexcept {
-  return is_leap_year(y + (m > 2)) ? 366 : 365;
-}
-CONSTEXPR_F int days_per_month(year_t y, month_t m) noexcept {
-  CONSTEXPR_D int k_days_per_month[1 + 12] = {
-      -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // non leap year
-  };
-  return k_days_per_month[m] + (m == 2 && is_leap_year(y));
-}
-
-CONSTEXPR_F fields n_day(year_t y, month_t m, diff_t d, diff_t cd, hour_t hh,
-                         minute_t mm, second_t ss) noexcept {
-  year_t ey = y % 400;
-  const year_t oey = ey;
-  ey += (cd / 146097) * 400;
-  cd %= 146097;
-  if (cd < 0) {
-    ey -= 400;
-    cd += 146097;
-  }
-  ey += (d / 146097) * 400;
-  d = d % 146097 + cd;
-  if (d > 0) {
-    if (d > 146097) {
-      ey += 400;
-      d -= 146097;
-    }
-  } else {
-    if (d > -365) {
-      // We often hit the previous year when stepping a civil time backwards,
-      // so special case it to avoid counting up by 100/4/1-year chunks.
-      ey -= 1;
-      d += days_per_year(ey, m);
-    } else {
-      ey -= 400;
-      d += 146097;
-    }
-  }
-  if (d > 365) {
-    int yi = year_index(ey, m);  // Index into Gregorian 400 year cycle.
-    for (;;) {
-      int n = days_per_century(yi);
-      if (d <= n) break;
-      d -= n;
-      ey += 100;
-      yi += 100;
-      if (yi >= 400) yi -= 400;
-    }
-    for (;;) {
-      int n = days_per_4years(yi);
-      if (d <= n) break;
-      d -= n;
-      ey += 4;
-      yi += 4;
-      if (yi >= 400) yi -= 400;
-    }
-    for (;;) {
-      int n = days_per_year(ey, m);
-      if (d <= n) break;
-      d -= n;
-      ++ey;
-    }
-  }
-  if (d > 28) {
-    for (;;) {
-      int n = days_per_month(ey, m);
-      if (d <= n) break;
-      d -= n;
-      if (++m > 12) {
-        ++ey;
-        m = 1;
-      }
-    }
-  }
-  return fields(y + (ey - oey), m, static_cast<day_t>(d), hh, mm, ss);
-}
-CONSTEXPR_F fields n_mon(year_t y, diff_t m, diff_t d, diff_t cd, hour_t hh,
-                         minute_t mm, second_t ss) noexcept {
-  if (m != 12) {
-    y += m / 12;
-    m %= 12;
-    if (m <= 0) {
-      y -= 1;
-      m += 12;
-    }
-  }
-  return n_day(y, static_cast<month_t>(m), d, cd, hh, mm, ss);
-}
-CONSTEXPR_F fields n_hour(year_t y, diff_t m, diff_t d, diff_t cd, diff_t hh,
-                          minute_t mm, second_t ss) noexcept {
-  cd += hh / 24;
-  hh %= 24;
-  if (hh < 0) {
-    cd -= 1;
-    hh += 24;
-  }
-  return n_mon(y, m, d, cd, static_cast<hour_t>(hh), mm, ss);
-}
-CONSTEXPR_F fields n_min(year_t y, diff_t m, diff_t d, diff_t hh, diff_t ch,
-                         diff_t mm, second_t ss) noexcept {
-  ch += mm / 60;
-  mm %= 60;
-  if (mm < 0) {
-    ch -= 1;
-    mm += 60;
-  }
-  return n_hour(y, m, d, hh / 24 + ch / 24, hh % 24 + ch % 24,
-                static_cast<minute_t>(mm), ss);
-}
-CONSTEXPR_F fields n_sec(year_t y, diff_t m, diff_t d, diff_t hh, diff_t mm,
-                         diff_t ss) noexcept {
-  // Optimization for when (non-constexpr) fields are already normalized.
-  if (0 <= ss && ss < 60) {
-    const second_t nss = static_cast<second_t>(ss);
-    if (0 <= mm && mm < 60) {
-      const minute_t nmm = static_cast<minute_t>(mm);
-      if (0 <= hh && hh < 24) {
-        const hour_t nhh = static_cast<hour_t>(hh);
-        if (1 <= d && d <= 28 && 1 <= m && m <= 12) {
-          const day_t nd = static_cast<day_t>(d);
-          const month_t nm = static_cast<month_t>(m);
-          return fields(y, nm, nd, nhh, nmm, nss);
-        }
-        return n_mon(y, m, d, 0, nhh, nmm, nss);
-      }
-      return n_hour(y, m, d, hh / 24, hh % 24, nmm, nss);
-    }
-    return n_min(y, m, d, hh, mm / 60, mm % 60, nss);
-  }
-  diff_t cm = ss / 60;
-  ss %= 60;
-  if (ss < 0) {
-    cm -= 1;
-    ss += 60;
-  }
-  return n_min(y, m, d, hh, mm / 60 + cm / 60, mm % 60 + cm % 60,
-               static_cast<second_t>(ss));
-}
-
-}  // namespace impl
-
-////////////////////////////////////////////////////////////////////////
-
-// Increments the indicated (normalized) field by "n".
-CONSTEXPR_F fields step(second_tag, fields f, diff_t n) noexcept {
-  return impl::n_sec(f.y, f.m, f.d, f.hh, f.mm + n / 60, f.ss + n % 60);
-}
-CONSTEXPR_F fields step(minute_tag, fields f, diff_t n) noexcept {
-  return impl::n_min(f.y, f.m, f.d, f.hh + n / 60, 0, f.mm + n % 60, f.ss);
-}
-CONSTEXPR_F fields step(hour_tag, fields f, diff_t n) noexcept {
-  return impl::n_hour(f.y, f.m, f.d + n / 24, 0, f.hh + n % 24, f.mm, f.ss);
-}
-CONSTEXPR_F fields step(day_tag, fields f, diff_t n) noexcept {
-  return impl::n_day(f.y, f.m, f.d, n, f.hh, f.mm, f.ss);
-}
-CONSTEXPR_F fields step(month_tag, fields f, diff_t n) noexcept {
-  return impl::n_mon(f.y + n / 12, f.m + n % 12, f.d, 0, f.hh, f.mm, f.ss);
-}
-CONSTEXPR_F fields step(year_tag, fields f, diff_t n) noexcept {
-  return fields(f.y + n, f.m, f.d, f.hh, f.mm, f.ss);
-}
-
-////////////////////////////////////////////////////////////////////////
-
-namespace impl {
-
-// Returns (v * f + a) but avoiding intermediate overflow when possible.
-CONSTEXPR_F diff_t scale_add(diff_t v, diff_t f, diff_t a) noexcept {
-  return (v < 0) ? ((v + 1) * f + a) - f : ((v - 1) * f + a) + f;
-}
-
-// Map a (normalized) Y/M/D to the number of days before/after 1970-01-01.
-// Probably overflows for years outside [-292277022656:292277026595].
-CONSTEXPR_F diff_t ymd_ord(year_t y, month_t m, day_t d) noexcept {
-  const diff_t eyear = (m <= 2) ? y - 1 : y;
-  const diff_t era = (eyear >= 0 ? eyear : eyear - 399) / 400;
-  const diff_t yoe = eyear - era * 400;
-  const diff_t doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
-  const diff_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
-  return era * 146097 + doe - 719468;
-}
-
-// Returns the difference in days between two normalized Y-M-D tuples.
-// ymd_ord() will encounter integer overflow given extreme year values,
-// yet the difference between two such extreme values may actually be
-// small, so we take a little care to avoid overflow when possible by
-// exploiting the 146097-day cycle.
-CONSTEXPR_F diff_t day_difference(year_t y1, month_t m1, day_t d1, year_t y2,
-                                  month_t m2, day_t d2) noexcept {
-  const diff_t a_c4_off = y1 % 400;
-  const diff_t b_c4_off = y2 % 400;
-  diff_t c4_diff = (y1 - a_c4_off) - (y2 - b_c4_off);
-  diff_t delta = ymd_ord(a_c4_off, m1, d1) - ymd_ord(b_c4_off, m2, d2);
-  if (c4_diff > 0 && delta < 0) {
-    delta += 2 * 146097;
-    c4_diff -= 2 * 400;
-  } else if (c4_diff < 0 && delta > 0) {
-    delta -= 2 * 146097;
-    c4_diff += 2 * 400;
-  }
-  return (c4_diff / 400 * 146097) + delta;
-}
-
-}  // namespace impl
-
-// Returns the difference between fields structs using the indicated unit.
-CONSTEXPR_F diff_t difference(year_tag, fields f1, fields f2) noexcept {
-  return f1.y - f2.y;
-}
-CONSTEXPR_F diff_t difference(month_tag, fields f1, fields f2) noexcept {
-  return impl::scale_add(difference(year_tag{}, f1, f2), 12, (f1.m - f2.m));
-}
-CONSTEXPR_F diff_t difference(day_tag, fields f1, fields f2) noexcept {
-  return impl::day_difference(f1.y, f1.m, f1.d, f2.y, f2.m, f2.d);
-}
-CONSTEXPR_F diff_t difference(hour_tag, fields f1, fields f2) noexcept {
-  return impl::scale_add(difference(day_tag{}, f1, f2), 24, (f1.hh - f2.hh));
-}
-CONSTEXPR_F diff_t difference(minute_tag, fields f1, fields f2) noexcept {
-  return impl::scale_add(difference(hour_tag{}, f1, f2), 60, (f1.mm - f2.mm));
-}
-CONSTEXPR_F diff_t difference(second_tag, fields f1, fields f2) noexcept {
-  return impl::scale_add(difference(minute_tag{}, f1, f2), 60, f1.ss - f2.ss);
-}
-
-////////////////////////////////////////////////////////////////////////
-
-// Aligns the (normalized) fields struct to the indicated field.
-CONSTEXPR_F fields align(second_tag, fields f) noexcept { return f; }
-CONSTEXPR_F fields align(minute_tag, fields f) noexcept {
-  return fields{f.y, f.m, f.d, f.hh, f.mm, 0};
-}
-CONSTEXPR_F fields align(hour_tag, fields f) noexcept {
-  return fields{f.y, f.m, f.d, f.hh, 0, 0};
-}
-CONSTEXPR_F fields align(day_tag, fields f) noexcept {
-  return fields{f.y, f.m, f.d, 0, 0, 0};
-}
-CONSTEXPR_F fields align(month_tag, fields f) noexcept {
-  return fields{f.y, f.m, 1, 0, 0, 0};
-}
-CONSTEXPR_F fields align(year_tag, fields f) noexcept {
-  return fields{f.y, 1, 1, 0, 0, 0};
-}
-
-////////////////////////////////////////////////////////////////////////
-
-namespace impl {
-
-template <typename H>
-H AbslHashValueImpl(second_tag, H h, fields f) {
-  return H::combine(std::move(h), f.y, f.m, f.d, f.hh, f.mm, f.ss);
-}
-template <typename H>
-H AbslHashValueImpl(minute_tag, H h, fields f) {
-  return H::combine(std::move(h), f.y, f.m, f.d, f.hh, f.mm);
-}
-template <typename H>
-H AbslHashValueImpl(hour_tag, H h, fields f) {
-  return H::combine(std::move(h), f.y, f.m, f.d, f.hh);
-}
-template <typename H>
-H AbslHashValueImpl(day_tag, H h, fields f) {
-  return H::combine(std::move(h), f.y, f.m, f.d);
-}
-template <typename H>
-H AbslHashValueImpl(month_tag, H h, fields f) {
-  return H::combine(std::move(h), f.y, f.m);
-}
-template <typename H>
-H AbslHashValueImpl(year_tag, H h, fields f) {
-  return H::combine(std::move(h), f.y);
-}
-
-}  // namespace impl
-
-////////////////////////////////////////////////////////////////////////
-
-template <typename T>
-class civil_time {
- public:
-  explicit CONSTEXPR_M civil_time(year_t y, diff_t m = 1, diff_t d = 1,
-                                  diff_t hh = 0, diff_t mm = 0,
-                                  diff_t ss = 0) noexcept
-      : civil_time(impl::n_sec(y, m, d, hh, mm, ss)) {}
-
-  CONSTEXPR_M civil_time() noexcept : f_{1970, 1, 1, 0, 0, 0} {}
-  civil_time(const civil_time&) = default;
-  civil_time& operator=(const civil_time&) = default;
-
-  // Conversion between civil times of different alignment. Conversion to
-  // a more precise alignment is allowed implicitly (e.g., day -> hour),
-  // but conversion where information is discarded must be explicit
-  // (e.g., second -> minute).
-  template <typename U, typename S>
-  using preserves_data =
-      typename std::enable_if<std::is_base_of<U, S>::value>::type;
-  template <typename U>
-  CONSTEXPR_M civil_time(const civil_time<U>& ct,
-                         preserves_data<T, U>* = nullptr) noexcept
-      : civil_time(ct.f_) {}
-  template <typename U>
-  explicit CONSTEXPR_M civil_time(const civil_time<U>& ct,
-                                  preserves_data<U, T>* = nullptr) noexcept
-      : civil_time(ct.f_) {}
-
-  // Factories for the maximum/minimum representable civil_time.
-  static CONSTEXPR_F civil_time(max)() {
-    const auto max_year = (std::numeric_limits<std::int_least64_t>::max)();
-    return civil_time(max_year, 12, 31, 23, 59, 59);
-  }
-  static CONSTEXPR_F civil_time(min)() {
-    const auto min_year = (std::numeric_limits<std::int_least64_t>::min)();
-    return civil_time(min_year, 1, 1, 0, 0, 0);
-  }
-
-  // Field accessors.  Note: All but year() return an int.
-  CONSTEXPR_M year_t year() const noexcept { return f_.y; }
-  CONSTEXPR_M int month() const noexcept { return f_.m; }
-  CONSTEXPR_M int day() const noexcept { return f_.d; }
-  CONSTEXPR_M int hour() const noexcept { return f_.hh; }
-  CONSTEXPR_M int minute() const noexcept { return f_.mm; }
-  CONSTEXPR_M int second() const noexcept { return f_.ss; }
-
-  // Assigning arithmetic.
-  CONSTEXPR_M civil_time& operator+=(diff_t n) noexcept {
-    return *this = *this + n;
-  }
-  CONSTEXPR_M civil_time& operator-=(diff_t n) noexcept {
-    return *this = *this - n;
-  }
-  CONSTEXPR_M civil_time& operator++() noexcept { return *this += 1; }
-  CONSTEXPR_M civil_time operator++(int) noexcept {
-    const civil_time a = *this;
-    ++*this;
-    return a;
-  }
-  CONSTEXPR_M civil_time& operator--() noexcept { return *this -= 1; }
-  CONSTEXPR_M civil_time operator--(int) noexcept {
-    const civil_time a = *this;
-    --*this;
-    return a;
-  }
-
-  // Binary arithmetic operators.
-  friend CONSTEXPR_F civil_time operator+(civil_time a, diff_t n) noexcept {
-    return civil_time(step(T{}, a.f_, n));
-  }
-  friend CONSTEXPR_F civil_time operator+(diff_t n, civil_time a) noexcept {
-    return a + n;
-  }
-  friend CONSTEXPR_F civil_time operator-(civil_time a, diff_t n) noexcept {
-    return n != (std::numeric_limits<diff_t>::min)()
-               ? civil_time(step(T{}, a.f_, -n))
-               : civil_time(step(T{}, step(T{}, a.f_, -(n + 1)), 1));
-  }
-  friend CONSTEXPR_F diff_t operator-(civil_time lhs, civil_time rhs) noexcept {
-    return difference(T{}, lhs.f_, rhs.f_);
-  }
-
-  template <typename H>
-  friend H AbslHashValue(H h, civil_time a) {
-    return impl::AbslHashValueImpl(T{}, std::move(h), a.f_);
-  }
-
- private:
-  // All instantiations of this template are allowed to call the following
-  // private constructor and access the private fields member.
-  template <typename U>
-  friend class civil_time;
-
-  // The designated constructor that all others eventually call.
-  explicit CONSTEXPR_M civil_time(fields f) noexcept : f_(align(T{}, f)) {}
-
-  fields f_;
-};
-
-// Disallows difference between differently aligned types.
-// auto n = civil_day(...) - civil_hour(...);  // would be confusing.
-template <typename T, typename U>
-CONSTEXPR_F diff_t operator-(civil_time<T>, civil_time<U>) = delete;
-
-using civil_year = civil_time<year_tag>;
-using civil_month = civil_time<month_tag>;
-using civil_day = civil_time<day_tag>;
-using civil_hour = civil_time<hour_tag>;
-using civil_minute = civil_time<minute_tag>;
-using civil_second = civil_time<second_tag>;
-
-////////////////////////////////////////////////////////////////////////
-
-// Relational operators that work with differently aligned objects.
-// Always compares all six fields.
-template <typename T1, typename T2>
-CONSTEXPR_F bool operator<(const civil_time<T1>& lhs,
-                           const civil_time<T2>& rhs) noexcept {
-  return (
-      lhs.year() < rhs.year() ||
-      (lhs.year() == rhs.year() &&
-       (lhs.month() < rhs.month() ||
-        (lhs.month() == rhs.month() &&
-         (lhs.day() < rhs.day() || (lhs.day() == rhs.day() &&
-                                    (lhs.hour() < rhs.hour() ||
-                                     (lhs.hour() == rhs.hour() &&
-                                      (lhs.minute() < rhs.minute() ||
-                                       (lhs.minute() == rhs.minute() &&
-                                        (lhs.second() < rhs.second())))))))))));
-}
-template <typename T1, typename T2>
-CONSTEXPR_F bool operator<=(const civil_time<T1>& lhs,
-                            const civil_time<T2>& rhs) noexcept {
-  return !(rhs < lhs);
-}
-template <typename T1, typename T2>
-CONSTEXPR_F bool operator>=(const civil_time<T1>& lhs,
-                            const civil_time<T2>& rhs) noexcept {
-  return !(lhs < rhs);
-}
-template <typename T1, typename T2>
-CONSTEXPR_F bool operator>(const civil_time<T1>& lhs,
-                           const civil_time<T2>& rhs) noexcept {
-  return rhs < lhs;
-}
-template <typename T1, typename T2>
-CONSTEXPR_F bool operator==(const civil_time<T1>& lhs,
-                            const civil_time<T2>& rhs) noexcept {
-  return lhs.year() == rhs.year() && lhs.month() == rhs.month() &&
-         lhs.day() == rhs.day() && lhs.hour() == rhs.hour() &&
-         lhs.minute() == rhs.minute() && lhs.second() == rhs.second();
-}
-template <typename T1, typename T2>
-CONSTEXPR_F bool operator!=(const civil_time<T1>& lhs,
-                            const civil_time<T2>& rhs) noexcept {
-  return !(lhs == rhs);
-}
-
-////////////////////////////////////////////////////////////////////////
-
-enum class weekday {
-  monday,
-  tuesday,
-  wednesday,
-  thursday,
-  friday,
-  saturday,
-  sunday,
-};
-
-CONSTEXPR_F weekday get_weekday(const civil_second& cs) noexcept {
-  CONSTEXPR_D weekday k_weekday_by_mon_off[13] = {
-      weekday::monday,    weekday::tuesday,  weekday::wednesday,
-      weekday::thursday,  weekday::friday,   weekday::saturday,
-      weekday::sunday,    weekday::monday,   weekday::tuesday,
-      weekday::wednesday, weekday::thursday, weekday::friday,
-      weekday::saturday,
-  };
-  CONSTEXPR_D int k_weekday_offsets[1 + 12] = {
-      -1, 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4,
-  };
-  year_t wd = 2400 + (cs.year() % 400) - (cs.month() < 3);
-  wd += wd / 4 - wd / 100 + wd / 400;
-  wd += k_weekday_offsets[cs.month()] + cs.day();
-  return k_weekday_by_mon_off[wd % 7 + 6];
-}
-
-////////////////////////////////////////////////////////////////////////
-
-CONSTEXPR_F civil_day next_weekday(civil_day cd, weekday wd) noexcept {
-  CONSTEXPR_D weekday k_weekdays_forw[14] = {
-      weekday::monday,    weekday::tuesday,  weekday::wednesday,
-      weekday::thursday,  weekday::friday,   weekday::saturday,
-      weekday::sunday,    weekday::monday,   weekday::tuesday,
-      weekday::wednesday, weekday::thursday, weekday::friday,
-      weekday::saturday,  weekday::sunday,
-  };
-  weekday base = get_weekday(cd);
-  for (int i = 0;; ++i) {
-    if (base == k_weekdays_forw[i]) {
-      for (int j = i + 1;; ++j) {
-        if (wd == k_weekdays_forw[j]) {
-          return cd + (j - i);
-        }
-      }
-    }
-  }
-}
-
-CONSTEXPR_F civil_day prev_weekday(civil_day cd, weekday wd) noexcept {
-  CONSTEXPR_D weekday k_weekdays_back[14] = {
-      weekday::sunday,   weekday::saturday,  weekday::friday,
-      weekday::thursday, weekday::wednesday, weekday::tuesday,
-      weekday::monday,   weekday::sunday,    weekday::saturday,
-      weekday::friday,   weekday::thursday,  weekday::wednesday,
-      weekday::tuesday,  weekday::monday,
-  };
-  weekday base = get_weekday(cd);
-  for (int i = 0;; ++i) {
-    if (base == k_weekdays_back[i]) {
-      for (int j = i + 1;; ++j) {
-        if (wd == k_weekdays_back[j]) {
-          return cd - (j - i);
-        }
-      }
-    }
-  }
-}
-
-CONSTEXPR_F int get_yearday(const civil_second& cs) noexcept {
-  CONSTEXPR_D int k_month_offsets[1 + 12] = {
-      -1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
-  };
-  const int feb29 = (cs.month() > 2 && impl::is_leap_year(cs.year()));
-  return k_month_offsets[cs.month()] + feb29 + cs.day();
-}
-
-////////////////////////////////////////////////////////////////////////
-
-std::ostream& operator<<(std::ostream& os, const civil_year& y);
-std::ostream& operator<<(std::ostream& os, const civil_month& m);
-std::ostream& operator<<(std::ostream& os, const civil_day& d);
-std::ostream& operator<<(std::ostream& os, const civil_hour& h);
-std::ostream& operator<<(std::ostream& os, const civil_minute& m);
-std::ostream& operator<<(std::ostream& os, const civil_second& s);
-std::ostream& operator<<(std::ostream& os, weekday wd);
-
-}  // namespace detail
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
+
+            // Support years that at least span the range of 64-bit time_t values.
+            using year_t = std::int_fast64_t;
+
+            // Type alias that indicates an argument is not normalized (e.g., the
+            // constructor parameters and operands/results of addition/subtraction).
+            using diff_t = std::int_fast64_t;
+
+            namespace detail
+            {
+
+                // Type aliases that indicate normalized argument values.
+                using month_t = std::int_fast8_t;   // [1:12]
+                using day_t = std::int_fast8_t;     // [1:31]
+                using hour_t = std::int_fast8_t;    // [0:23]
+                using minute_t = std::int_fast8_t;  // [0:59]
+                using second_t = std::int_fast8_t;  // [0:59]
+
+                // Normalized civil-time fields: Y-M-D HH:MM:SS.
+                struct fields
+                {
+                    CONSTEXPR_M fields(year_t year, month_t month, day_t day, hour_t hour, minute_t minute, second_t second) :
+                        y(year),
+                        m(month),
+                        d(day),
+                        hh(hour),
+                        mm(minute),
+                        ss(second)
+                    {
+                    }
+                    std::int_least64_t y;
+                    std::int_least8_t m;
+                    std::int_least8_t d;
+                    std::int_least8_t hh;
+                    std::int_least8_t mm;
+                    std::int_least8_t ss;
+                };
+
+                struct second_tag
+                {
+                };
+                struct minute_tag : second_tag
+                {
+                };
+                struct hour_tag : minute_tag
+                {
+                };
+                struct day_tag : hour_tag
+                {
+                };
+                struct month_tag : day_tag
+                {
+                };
+                struct year_tag : month_tag
+                {
+                };
+
+                ////////////////////////////////////////////////////////////////////////
+
+                // Field normalization (without avoidable overflow).
+
+                namespace impl
+                {
+
+                    CONSTEXPR_F bool is_leap_year(year_t y) noexcept
+                    {
+                        return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
+                    }
+                    CONSTEXPR_F int year_index(year_t y, month_t m) noexcept
+                    {
+                        const int yi = static_cast<int>((y + (m > 2)) % 400);
+                        return yi < 0 ? yi + 400 : yi;
+                    }
+                    CONSTEXPR_F int days_per_century(int yi) noexcept
+                    {
+                        return 36524 + (yi == 0 || yi > 300);
+                    }
+                    CONSTEXPR_F int days_per_4years(int yi) noexcept
+                    {
+                        return 1460 + (yi == 0 || yi > 300 || (yi - 1) % 100 < 96);
+                    }
+                    CONSTEXPR_F int days_per_year(year_t y, month_t m) noexcept
+                    {
+                        return is_leap_year(y + (m > 2)) ? 366 : 365;
+                    }
+                    CONSTEXPR_F int days_per_month(year_t y, month_t m) noexcept
+                    {
+                        CONSTEXPR_D int k_days_per_month[1 + 12] = {
+                            -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // non leap year
+                        };
+                        return k_days_per_month[m] + (m == 2 && is_leap_year(y));
+                    }
+
+                    CONSTEXPR_F fields n_day(year_t y, month_t m, diff_t d, diff_t cd, hour_t hh, minute_t mm, second_t ss) noexcept
+                    {
+                        year_t ey = y % 400;
+                        const year_t oey = ey;
+                        ey += (cd / 146097) * 400;
+                        cd %= 146097;
+                        if (cd < 0)
+                        {
+                            ey -= 400;
+                            cd += 146097;
+                        }
+                        ey += (d / 146097) * 400;
+                        d = d % 146097 + cd;
+                        if (d > 0)
+                        {
+                            if (d > 146097)
+                            {
+                                ey += 400;
+                                d -= 146097;
+                            }
+                        }
+                        else
+                        {
+                            if (d > -365)
+                            {
+                                // We often hit the previous year when stepping a civil time backwards,
+                                // so special case it to avoid counting up by 100/4/1-year chunks.
+                                ey -= 1;
+                                d += days_per_year(ey, m);
+                            }
+                            else
+                            {
+                                ey -= 400;
+                                d += 146097;
+                            }
+                        }
+                        if (d > 365)
+                        {
+                            int yi = year_index(ey, m);  // Index into Gregorian 400 year cycle.
+                            for (;;)
+                            {
+                                int n = days_per_century(yi);
+                                if (d <= n)
+                                    break;
+                                d -= n;
+                                ey += 100;
+                                yi += 100;
+                                if (yi >= 400)
+                                    yi -= 400;
+                            }
+                            for (;;)
+                            {
+                                int n = days_per_4years(yi);
+                                if (d <= n)
+                                    break;
+                                d -= n;
+                                ey += 4;
+                                yi += 4;
+                                if (yi >= 400)
+                                    yi -= 400;
+                            }
+                            for (;;)
+                            {
+                                int n = days_per_year(ey, m);
+                                if (d <= n)
+                                    break;
+                                d -= n;
+                                ++ey;
+                            }
+                        }
+                        if (d > 28)
+                        {
+                            for (;;)
+                            {
+                                int n = days_per_month(ey, m);
+                                if (d <= n)
+                                    break;
+                                d -= n;
+                                if (++m > 12)
+                                {
+                                    ++ey;
+                                    m = 1;
+                                }
+                            }
+                        }
+                        return fields(y + (ey - oey), m, static_cast<day_t>(d), hh, mm, ss);
+                    }
+                    CONSTEXPR_F fields n_mon(year_t y, diff_t m, diff_t d, diff_t cd, hour_t hh, minute_t mm, second_t ss) noexcept
+                    {
+                        if (m != 12)
+                        {
+                            y += m / 12;
+                            m %= 12;
+                            if (m <= 0)
+                            {
+                                y -= 1;
+                                m += 12;
+                            }
+                        }
+                        return n_day(y, static_cast<month_t>(m), d, cd, hh, mm, ss);
+                    }
+                    CONSTEXPR_F fields n_hour(year_t y, diff_t m, diff_t d, diff_t cd, diff_t hh, minute_t mm, second_t ss) noexcept
+                    {
+                        cd += hh / 24;
+                        hh %= 24;
+                        if (hh < 0)
+                        {
+                            cd -= 1;
+                            hh += 24;
+                        }
+                        return n_mon(y, m, d, cd, static_cast<hour_t>(hh), mm, ss);
+                    }
+                    CONSTEXPR_F fields n_min(year_t y, diff_t m, diff_t d, diff_t hh, diff_t ch, diff_t mm, second_t ss) noexcept
+                    {
+                        ch += mm / 60;
+                        mm %= 60;
+                        if (mm < 0)
+                        {
+                            ch -= 1;
+                            mm += 60;
+                        }
+                        return n_hour(y, m, d, hh / 24 + ch / 24, hh % 24 + ch % 24, static_cast<minute_t>(mm), ss);
+                    }
+                    CONSTEXPR_F fields n_sec(year_t y, diff_t m, diff_t d, diff_t hh, diff_t mm, diff_t ss) noexcept
+                    {
+                        // Optimization for when (non-constexpr) fields are already normalized.
+                        if (0 <= ss && ss < 60)
+                        {
+                            const second_t nss = static_cast<second_t>(ss);
+                            if (0 <= mm && mm < 60)
+                            {
+                                const minute_t nmm = static_cast<minute_t>(mm);
+                                if (0 <= hh && hh < 24)
+                                {
+                                    const hour_t nhh = static_cast<hour_t>(hh);
+                                    if (1 <= d && d <= 28 && 1 <= m && m <= 12)
+                                    {
+                                        const day_t nd = static_cast<day_t>(d);
+                                        const month_t nm = static_cast<month_t>(m);
+                                        return fields(y, nm, nd, nhh, nmm, nss);
+                                    }
+                                    return n_mon(y, m, d, 0, nhh, nmm, nss);
+                                }
+                                return n_hour(y, m, d, hh / 24, hh % 24, nmm, nss);
+                            }
+                            return n_min(y, m, d, hh, mm / 60, mm % 60, nss);
+                        }
+                        diff_t cm = ss / 60;
+                        ss %= 60;
+                        if (ss < 0)
+                        {
+                            cm -= 1;
+                            ss += 60;
+                        }
+                        return n_min(y, m, d, hh, mm / 60 + cm / 60, mm % 60 + cm % 60, static_cast<second_t>(ss));
+                    }
+
+                }  // namespace impl
+
+                ////////////////////////////////////////////////////////////////////////
+
+                // Increments the indicated (normalized) field by "n".
+                CONSTEXPR_F fields step(second_tag, fields f, diff_t n) noexcept
+                {
+                    return impl::n_sec(f.y, f.m, f.d, f.hh, f.mm + n / 60, f.ss + n % 60);
+                }
+                CONSTEXPR_F fields step(minute_tag, fields f, diff_t n) noexcept
+                {
+                    return impl::n_min(f.y, f.m, f.d, f.hh + n / 60, 0, f.mm + n % 60, f.ss);
+                }
+                CONSTEXPR_F fields step(hour_tag, fields f, diff_t n) noexcept
+                {
+                    return impl::n_hour(f.y, f.m, f.d + n / 24, 0, f.hh + n % 24, f.mm, f.ss);
+                }
+                CONSTEXPR_F fields step(day_tag, fields f, diff_t n) noexcept
+                {
+                    return impl::n_day(f.y, f.m, f.d, n, f.hh, f.mm, f.ss);
+                }
+                CONSTEXPR_F fields step(month_tag, fields f, diff_t n) noexcept
+                {
+                    return impl::n_mon(f.y + n / 12, f.m + n % 12, f.d, 0, f.hh, f.mm, f.ss);
+                }
+                CONSTEXPR_F fields step(year_tag, fields f, diff_t n) noexcept
+                {
+                    return fields(f.y + n, f.m, f.d, f.hh, f.mm, f.ss);
+                }
+
+                ////////////////////////////////////////////////////////////////////////
+
+                namespace impl
+                {
+
+                    // Returns (v * f + a) but avoiding intermediate overflow when possible.
+                    CONSTEXPR_F diff_t scale_add(diff_t v, diff_t f, diff_t a) noexcept
+                    {
+                        return (v < 0) ? ((v + 1) * f + a) - f : ((v - 1) * f + a) + f;
+                    }
+
+                    // Map a (normalized) Y/M/D to the number of days before/after 1970-01-01.
+                    // Probably overflows for years outside [-292277022656:292277026595].
+                    CONSTEXPR_F diff_t ymd_ord(year_t y, month_t m, day_t d) noexcept
+                    {
+                        const diff_t eyear = (m <= 2) ? y - 1 : y;
+                        const diff_t era = (eyear >= 0 ? eyear : eyear - 399) / 400;
+                        const diff_t yoe = eyear - era * 400;
+                        const diff_t doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
+                        const diff_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+                        return era * 146097 + doe - 719468;
+                    }
+
+                    // Returns the difference in days between two normalized Y-M-D tuples.
+                    // ymd_ord() will encounter integer overflow given extreme year values,
+                    // yet the difference between two such extreme values may actually be
+                    // small, so we take a little care to avoid overflow when possible by
+                    // exploiting the 146097-day cycle.
+                    CONSTEXPR_F diff_t day_difference(year_t y1, month_t m1, day_t d1, year_t y2, month_t m2, day_t d2) noexcept
+                    {
+                        const diff_t a_c4_off = y1 % 400;
+                        const diff_t b_c4_off = y2 % 400;
+                        diff_t c4_diff = (y1 - a_c4_off) - (y2 - b_c4_off);
+                        diff_t delta = ymd_ord(a_c4_off, m1, d1) - ymd_ord(b_c4_off, m2, d2);
+                        if (c4_diff > 0 && delta < 0)
+                        {
+                            delta += 2 * 146097;
+                            c4_diff -= 2 * 400;
+                        }
+                        else if (c4_diff < 0 && delta > 0)
+                        {
+                            delta -= 2 * 146097;
+                            c4_diff += 2 * 400;
+                        }
+                        return (c4_diff / 400 * 146097) + delta;
+                    }
+
+                }  // namespace impl
+
+                // Returns the difference between fields structs using the indicated unit.
+                CONSTEXPR_F diff_t difference(year_tag, fields f1, fields f2) noexcept
+                {
+                    return f1.y - f2.y;
+                }
+                CONSTEXPR_F diff_t difference(month_tag, fields f1, fields f2) noexcept
+                {
+                    return impl::scale_add(difference(year_tag{}, f1, f2), 12, (f1.m - f2.m));
+                }
+                CONSTEXPR_F diff_t difference(day_tag, fields f1, fields f2) noexcept
+                {
+                    return impl::day_difference(f1.y, f1.m, f1.d, f2.y, f2.m, f2.d);
+                }
+                CONSTEXPR_F diff_t difference(hour_tag, fields f1, fields f2) noexcept
+                {
+                    return impl::scale_add(difference(day_tag{}, f1, f2), 24, (f1.hh - f2.hh));
+                }
+                CONSTEXPR_F diff_t difference(minute_tag, fields f1, fields f2) noexcept
+                {
+                    return impl::scale_add(difference(hour_tag{}, f1, f2), 60, (f1.mm - f2.mm));
+                }
+                CONSTEXPR_F diff_t difference(second_tag, fields f1, fields f2) noexcept
+                {
+                    return impl::scale_add(difference(minute_tag{}, f1, f2), 60, f1.ss - f2.ss);
+                }
+
+                ////////////////////////////////////////////////////////////////////////
+
+                // Aligns the (normalized) fields struct to the indicated field.
+                CONSTEXPR_F fields align(second_tag, fields f) noexcept
+                {
+                    return f;
+                }
+                CONSTEXPR_F fields align(minute_tag, fields f) noexcept
+                {
+                    return fields{f.y, f.m, f.d, f.hh, f.mm, 0};
+                }
+                CONSTEXPR_F fields align(hour_tag, fields f) noexcept
+                {
+                    return fields{f.y, f.m, f.d, f.hh, 0, 0};
+                }
+                CONSTEXPR_F fields align(day_tag, fields f) noexcept
+                {
+                    return fields{f.y, f.m, f.d, 0, 0, 0};
+                }
+                CONSTEXPR_F fields align(month_tag, fields f) noexcept
+                {
+                    return fields{f.y, f.m, 1, 0, 0, 0};
+                }
+                CONSTEXPR_F fields align(year_tag, fields f) noexcept
+                {
+                    return fields{f.y, 1, 1, 0, 0, 0};
+                }
+
+                ////////////////////////////////////////////////////////////////////////
+
+                namespace impl
+                {
+
+                    template<typename H>
+                    H AbslHashValueImpl(second_tag, H h, fields f)
+                    {
+                        return H::combine(std::move(h), f.y, f.m, f.d, f.hh, f.mm, f.ss);
+                    }
+                    template<typename H>
+                    H AbslHashValueImpl(minute_tag, H h, fields f)
+                    {
+                        return H::combine(std::move(h), f.y, f.m, f.d, f.hh, f.mm);
+                    }
+                    template<typename H>
+                    H AbslHashValueImpl(hour_tag, H h, fields f)
+                    {
+                        return H::combine(std::move(h), f.y, f.m, f.d, f.hh);
+                    }
+                    template<typename H>
+                    H AbslHashValueImpl(day_tag, H h, fields f)
+                    {
+                        return H::combine(std::move(h), f.y, f.m, f.d);
+                    }
+                    template<typename H>
+                    H AbslHashValueImpl(month_tag, H h, fields f)
+                    {
+                        return H::combine(std::move(h), f.y, f.m);
+                    }
+                    template<typename H>
+                    H AbslHashValueImpl(year_tag, H h, fields f)
+                    {
+                        return H::combine(std::move(h), f.y);
+                    }
+
+                }  // namespace impl
+
+                ////////////////////////////////////////////////////////////////////////
+
+                template<typename T>
+                class civil_time
+                {
+                public:
+                    explicit CONSTEXPR_M civil_time(year_t y, diff_t m = 1, diff_t d = 1, diff_t hh = 0, diff_t mm = 0, diff_t ss = 0) noexcept
+                        :
+                        civil_time(impl::n_sec(y, m, d, hh, mm, ss))
+                    {
+                    }
+
+                    CONSTEXPR_M civil_time() noexcept :
+                        f_{1970, 1, 1, 0, 0, 0}
+                    {
+                    }
+                    civil_time(const civil_time&) = default;
+                    civil_time& operator=(const civil_time&) = default;
+
+                    // Conversion between civil times of different alignment. Conversion to
+                    // a more precise alignment is allowed implicitly (e.g., day -> hour),
+                    // but conversion where information is discarded must be explicit
+                    // (e.g., second -> minute).
+                    template<typename U, typename S>
+                    using preserves_data =
+                        typename std::enable_if<std::is_base_of<U, S>::value>::type;
+                    template<typename U>
+                    CONSTEXPR_M civil_time(const civil_time<U>& ct, preserves_data<T, U>* = nullptr) noexcept
+                        :
+                        civil_time(ct.f_)
+                    {
+                    }
+                    template<typename U>
+                    explicit CONSTEXPR_M civil_time(const civil_time<U>& ct, preserves_data<U, T>* = nullptr) noexcept
+                        :
+                        civil_time(ct.f_)
+                    {
+                    }
+
+                    // Factories for the maximum/minimum representable civil_time.
+                    static CONSTEXPR_F civil_time(max)()
+                    {
+                        const auto max_year = (std::numeric_limits<std::int_least64_t>::max)();
+                        return civil_time(max_year, 12, 31, 23, 59, 59);
+                    }
+                    static CONSTEXPR_F civil_time(min)()
+                    {
+                        const auto min_year = (std::numeric_limits<std::int_least64_t>::min)();
+                        return civil_time(min_year, 1, 1, 0, 0, 0);
+                    }
+
+                    // Field accessors.  Note: All but year() return an int.
+                    CONSTEXPR_M year_t year() const noexcept
+                    {
+                        return f_.y;
+                    }
+                    CONSTEXPR_M int month() const noexcept
+                    {
+                        return f_.m;
+                    }
+                    CONSTEXPR_M int day() const noexcept
+                    {
+                        return f_.d;
+                    }
+                    CONSTEXPR_M int hour() const noexcept
+                    {
+                        return f_.hh;
+                    }
+                    CONSTEXPR_M int minute() const noexcept
+                    {
+                        return f_.mm;
+                    }
+                    CONSTEXPR_M int second() const noexcept
+                    {
+                        return f_.ss;
+                    }
+
+                    // Assigning arithmetic.
+                    CONSTEXPR_M civil_time& operator+=(diff_t n) noexcept
+                    {
+                        return *this = *this + n;
+                    }
+                    CONSTEXPR_M civil_time& operator-=(diff_t n) noexcept
+                    {
+                        return *this = *this - n;
+                    }
+                    CONSTEXPR_M civil_time& operator++() noexcept
+                    {
+                        return *this += 1;
+                    }
+                    CONSTEXPR_M civil_time operator++(int) noexcept
+                    {
+                        const civil_time a = *this;
+                        ++*this;
+                        return a;
+                    }
+                    CONSTEXPR_M civil_time& operator--() noexcept
+                    {
+                        return *this -= 1;
+                    }
+                    CONSTEXPR_M civil_time operator--(int) noexcept
+                    {
+                        const civil_time a = *this;
+                        --*this;
+                        return a;
+                    }
+
+                    // Binary arithmetic operators.
+                    friend CONSTEXPR_F civil_time operator+(civil_time a, diff_t n) noexcept
+                    {
+                        return civil_time(step(T{}, a.f_, n));
+                    }
+                    friend CONSTEXPR_F civil_time operator+(diff_t n, civil_time a) noexcept
+                    {
+                        return a + n;
+                    }
+                    friend CONSTEXPR_F civil_time operator-(civil_time a, diff_t n) noexcept
+                    {
+                        return n != (std::numeric_limits<diff_t>::min)() ? civil_time(step(T{}, a.f_, -n)) : civil_time(step(T{}, step(T{}, a.f_, -(n + 1)), 1));
+                    }
+                    friend CONSTEXPR_F diff_t operator-(civil_time lhs, civil_time rhs) noexcept
+                    {
+                        return difference(T{}, lhs.f_, rhs.f_);
+                    }
+
+                    template<typename H>
+                    friend H AbslHashValue(H h, civil_time a)
+                    {
+                        return impl::AbslHashValueImpl(T{}, std::move(h), a.f_);
+                    }
+
+                private:
+                    // All instantiations of this template are allowed to call the following
+                    // private constructor and access the private fields member.
+                    template<typename U>
+                    friend class civil_time;
+
+                    // The designated constructor that all others eventually call.
+                    explicit CONSTEXPR_M civil_time(fields f) noexcept :
+                        f_(align(T{}, f))
+                    {
+                    }
+
+                    fields f_;
+                };
+
+                // Disallows difference between differently aligned types.
+                // auto n = civil_day(...) - civil_hour(...);  // would be confusing.
+                template<typename T, typename U>
+                CONSTEXPR_F diff_t operator-(civil_time<T>, civil_time<U>) = delete;
+
+                using civil_year = civil_time<year_tag>;
+                using civil_month = civil_time<month_tag>;
+                using civil_day = civil_time<day_tag>;
+                using civil_hour = civil_time<hour_tag>;
+                using civil_minute = civil_time<minute_tag>;
+                using civil_second = civil_time<second_tag>;
+
+                ////////////////////////////////////////////////////////////////////////
+
+                // Relational operators that work with differently aligned objects.
+                // Always compares all six fields.
+                template<typename T1, typename T2>
+                CONSTEXPR_F bool operator<(const civil_time<T1>& lhs, const civil_time<T2>& rhs) noexcept
+                {
+                    return (
+                        lhs.year() < rhs.year() ||
+                        (lhs.year() == rhs.year() &&
+                         (lhs.month() < rhs.month() ||
+                          (lhs.month() == rhs.month() &&
+                           (lhs.day() < rhs.day() || (lhs.day() == rhs.day() &&
+                                                      (lhs.hour() < rhs.hour() ||
+                                                       (lhs.hour() == rhs.hour() &&
+                                                        (lhs.minute() < rhs.minute() ||
+                                                         (lhs.minute() == rhs.minute() &&
+                                                          (lhs.second() < rhs.second()))))))))))
+                    );
+                }
+                template<typename T1, typename T2>
+                CONSTEXPR_F bool operator<=(const civil_time<T1>& lhs, const civil_time<T2>& rhs) noexcept
+                {
+                    return !(rhs < lhs);
+                }
+                template<typename T1, typename T2>
+                CONSTEXPR_F bool operator>=(const civil_time<T1>& lhs, const civil_time<T2>& rhs) noexcept
+                {
+                    return !(lhs < rhs);
+                }
+                template<typename T1, typename T2>
+                CONSTEXPR_F bool operator>(const civil_time<T1>& lhs, const civil_time<T2>& rhs) noexcept
+                {
+                    return rhs < lhs;
+                }
+                template<typename T1, typename T2>
+                CONSTEXPR_F bool operator==(const civil_time<T1>& lhs, const civil_time<T2>& rhs) noexcept
+                {
+                    return lhs.year() == rhs.year() && lhs.month() == rhs.month() &&
+                           lhs.day() == rhs.day() && lhs.hour() == rhs.hour() &&
+                           lhs.minute() == rhs.minute() && lhs.second() == rhs.second();
+                }
+                template<typename T1, typename T2>
+                CONSTEXPR_F bool operator!=(const civil_time<T1>& lhs, const civil_time<T2>& rhs) noexcept
+                {
+                    return !(lhs == rhs);
+                }
+
+                ////////////////////////////////////////////////////////////////////////
+
+                enum class weekday
+                {
+                    monday,
+                    tuesday,
+                    wednesday,
+                    thursday,
+                    friday,
+                    saturday,
+                    sunday,
+                };
+
+                CONSTEXPR_F weekday get_weekday(const civil_second& cs) noexcept
+                {
+                    CONSTEXPR_D weekday k_weekday_by_mon_off[13] = {
+                        weekday::monday,
+                        weekday::tuesday,
+                        weekday::wednesday,
+                        weekday::thursday,
+                        weekday::friday,
+                        weekday::saturday,
+                        weekday::sunday,
+                        weekday::monday,
+                        weekday::tuesday,
+                        weekday::wednesday,
+                        weekday::thursday,
+                        weekday::friday,
+                        weekday::saturday,
+                    };
+                    CONSTEXPR_D int k_weekday_offsets[1 + 12] = {
+                        -1,
+                        0,
+                        3,
+                        2,
+                        5,
+                        0,
+                        3,
+                        5,
+                        1,
+                        4,
+                        6,
+                        2,
+                        4,
+                    };
+                    year_t wd = 2400 + (cs.year() % 400) - (cs.month() < 3);
+                    wd += wd / 4 - wd / 100 + wd / 400;
+                    wd += k_weekday_offsets[cs.month()] + cs.day();
+                    return k_weekday_by_mon_off[wd % 7 + 6];
+                }
+
+                ////////////////////////////////////////////////////////////////////////
+
+                CONSTEXPR_F civil_day next_weekday(civil_day cd, weekday wd) noexcept
+                {
+                    CONSTEXPR_D weekday k_weekdays_forw[14] = {
+                        weekday::monday,
+                        weekday::tuesday,
+                        weekday::wednesday,
+                        weekday::thursday,
+                        weekday::friday,
+                        weekday::saturday,
+                        weekday::sunday,
+                        weekday::monday,
+                        weekday::tuesday,
+                        weekday::wednesday,
+                        weekday::thursday,
+                        weekday::friday,
+                        weekday::saturday,
+                        weekday::sunday,
+                    };
+                    weekday base = get_weekday(cd);
+                    for (int i = 0;; ++i)
+                    {
+                        if (base == k_weekdays_forw[i])
+                        {
+                            for (int j = i + 1;; ++j)
+                            {
+                                if (wd == k_weekdays_forw[j])
+                                {
+                                    return cd + (j - i);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                CONSTEXPR_F civil_day prev_weekday(civil_day cd, weekday wd) noexcept
+                {
+                    CONSTEXPR_D weekday k_weekdays_back[14] = {
+                        weekday::sunday,
+                        weekday::saturday,
+                        weekday::friday,
+                        weekday::thursday,
+                        weekday::wednesday,
+                        weekday::tuesday,
+                        weekday::monday,
+                        weekday::sunday,
+                        weekday::saturday,
+                        weekday::friday,
+                        weekday::thursday,
+                        weekday::wednesday,
+                        weekday::tuesday,
+                        weekday::monday,
+                    };
+                    weekday base = get_weekday(cd);
+                    for (int i = 0;; ++i)
+                    {
+                        if (base == k_weekdays_back[i])
+                        {
+                            for (int j = i + 1;; ++j)
+                            {
+                                if (wd == k_weekdays_back[j])
+                                {
+                                    return cd - (j - i);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                CONSTEXPR_F int get_yearday(const civil_second& cs) noexcept
+                {
+                    CONSTEXPR_D int k_month_offsets[1 + 12] = {
+                        -1,
+                        0,
+                        31,
+                        59,
+                        90,
+                        120,
+                        151,
+                        181,
+                        212,
+                        243,
+                        273,
+                        304,
+                        334,
+                    };
+                    const int feb29 = (cs.month() > 2 && impl::is_leap_year(cs.year()));
+                    return k_month_offsets[cs.month()] + feb29 + cs.day();
+                }
+
+                ////////////////////////////////////////////////////////////////////////
+
+                std::ostream& operator<<(std::ostream& os, const civil_year& y);
+                std::ostream& operator<<(std::ostream& os, const civil_month& m);
+                std::ostream& operator<<(std::ostream& os, const civil_day& d);
+                std::ostream& operator<<(std::ostream& os, const civil_hour& h);
+                std::ostream& operator<<(std::ostream& os, const civil_minute& m);
+                std::ostream& operator<<(std::ostream& os, const civil_second& s);
+                std::ostream& operator<<(std::ostream& os, weekday wd);
+
+            }  // namespace detail
+        }      // namespace cctz
+    }          // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #undef CONSTEXPR_M
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/time_zone.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/time_zone.h
index 6e382dc..aa58b3f 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/time_zone.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/time_zone.h
@@ -29,431 +29,468 @@
 #include "absl/base/config.h"
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-// Convenience aliases. Not intended as public API points.
-template <typename D>
-using time_point = std::chrono::time_point<std::chrono::system_clock, D>;
-using seconds = std::chrono::duration<std::int_fast64_t>;
-using sys_seconds = seconds;  // Deprecated.  Use cctz::seconds instead.
-
-namespace detail {
-template <typename D>
-std::pair<time_point<seconds>, D> split_seconds(const time_point<D>& tp);
-std::pair<time_point<seconds>, seconds> split_seconds(
-    const time_point<seconds>& tp);
-}  // namespace detail
-
-// cctz::time_zone is an opaque, small, value-type class representing a
-// geo-political region within which particular rules are used for mapping
-// between absolute and civil times. Time zones are named using the TZ
-// identifiers from the IANA Time Zone Database, such as "America/Los_Angeles"
-// or "Australia/Sydney". Time zones are created from factory functions such
-// as load_time_zone(). Note: strings like "PST" and "EDT" are not valid TZ
-// identifiers.
-//
-// Example:
-//   cctz::time_zone utc = cctz::utc_time_zone();
-//   cctz::time_zone pst = cctz::fixed_time_zone(std::chrono::hours(-8));
-//   cctz::time_zone loc = cctz::local_time_zone();
-//   cctz::time_zone lax;
-//   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
-//
-// See also:
-// - http://www.iana.org/time-zones
-// - https://en.wikipedia.org/wiki/Zoneinfo
-class time_zone {
- public:
-  time_zone() : time_zone(nullptr) {}  // Equivalent to UTC
-  time_zone(const time_zone&) = default;
-  time_zone& operator=(const time_zone&) = default;
-
-  std::string name() const;
-
-  // An absolute_lookup represents the civil time (cctz::civil_second) within
-  // this time_zone at the given absolute time (time_point). There are
-  // additionally a few other fields that may be useful when working with
-  // older APIs, such as std::tm.
-  //
-  // Example:
-  //   const cctz::time_zone tz = ...
-  //   const auto tp = std::chrono::system_clock::now();
-  //   const cctz::time_zone::absolute_lookup al = tz.lookup(tp);
-  struct absolute_lookup {
-    civil_second cs;
-    // Note: The following fields exist for backward compatibility with older
-    // APIs. Accessing these fields directly is a sign of imprudent logic in
-    // the calling code. Modern time-related code should only access this data
-    // indirectly by way of cctz::format().
-    int offset;        // civil seconds east of UTC
-    bool is_dst;       // is offset non-standard?
-    const char* abbr;  // time-zone abbreviation (e.g., "PST")
-  };
-  absolute_lookup lookup(const time_point<seconds>& tp) const;
-  template <typename D>
-  absolute_lookup lookup(const time_point<D>& tp) const {
-    return lookup(detail::split_seconds(tp).first);
-  }
-
-  // A civil_lookup represents the absolute time(s) (time_point) that
-  // correspond to the given civil time (cctz::civil_second) within this
-  // time_zone. Usually the given civil time represents a unique instant
-  // in time, in which case the conversion is unambiguous. However,
-  // within this time zone, the given civil time may be skipped (e.g.,
-  // during a positive UTC offset shift), or repeated (e.g., during a
-  // negative UTC offset shift). To account for these possibilities,
-  // civil_lookup is richer than just a single time_point.
-  //
-  // In all cases the civil_lookup::kind enum will indicate the nature
-  // of the given civil-time argument, and the pre, trans, and post
-  // members will give the absolute time answers using the pre-transition
-  // offset, the transition point itself, and the post-transition offset,
-  // respectively (all three times are equal if kind == UNIQUE). If any
-  // of these three absolute times is outside the representable range of a
-  // time_point<seconds> the field is set to its maximum/minimum value.
-  //
-  // Example:
-  //   cctz::time_zone lax;
-  //   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
-  //
-  //   // A unique civil time.
-  //   auto jan01 = lax.lookup(cctz::civil_second(2011, 1, 1, 0, 0, 0));
-  //   // jan01.kind == cctz::time_zone::civil_lookup::UNIQUE
-  //   // jan01.pre    is 2011/01/01 00:00:00 -0800
-  //   // jan01.trans  is 2011/01/01 00:00:00 -0800
-  //   // jan01.post   is 2011/01/01 00:00:00 -0800
-  //
-  //   // A Spring DST transition, when there is a gap in civil time.
-  //   auto mar13 = lax.lookup(cctz::civil_second(2011, 3, 13, 2, 15, 0));
-  //   // mar13.kind == cctz::time_zone::civil_lookup::SKIPPED
-  //   // mar13.pre   is 2011/03/13 03:15:00 -0700
-  //   // mar13.trans is 2011/03/13 03:00:00 -0700
-  //   // mar13.post  is 2011/03/13 01:15:00 -0800
-  //
-  //   // A Fall DST transition, when civil times are repeated.
-  //   auto nov06 = lax.lookup(cctz::civil_second(2011, 11, 6, 1, 15, 0));
-  //   // nov06.kind == cctz::time_zone::civil_lookup::REPEATED
-  //   // nov06.pre   is 2011/11/06 01:15:00 -0700
-  //   // nov06.trans is 2011/11/06 01:00:00 -0800
-  //   // nov06.post  is 2011/11/06 01:15:00 -0800
-  struct civil_lookup {
-    enum civil_kind {
-      UNIQUE,    // the civil time was singular (pre == trans == post)
-      SKIPPED,   // the civil time did not exist (pre >= trans > post)
-      REPEATED,  // the civil time was ambiguous (pre < trans <= post)
-    } kind;
-    time_point<seconds> pre;    // uses the pre-transition offset
-    time_point<seconds> trans;  // instant of civil-offset change
-    time_point<seconds> post;   // uses the post-transition offset
-  };
-  civil_lookup lookup(const civil_second& cs) const;
-
-  // Finds the time of the next/previous offset change in this time zone.
-  //
-  // By definition, next_transition(tp, &trans) returns false when tp has
-  // its maximum value, and prev_transition(tp, &trans) returns false
-  // when tp has its minimum value. If the zone has no transitions, the
-  // result will also be false no matter what the argument.
-  //
-  // Otherwise, when tp has its minimum value, next_transition(tp, &trans)
-  // returns true and sets trans to the first recorded transition. Chains
-  // of calls to next_transition()/prev_transition() will eventually return
-  // false, but it is unspecified exactly when next_transition(tp, &trans)
-  // jumps to false, or what time is set by prev_transition(tp, &trans) for
-  // a very distant tp.
-  //
-  // Note: Enumeration of time-zone transitions is for informational purposes
-  // only. Modern time-related code should not care about when offset changes
-  // occur.
-  //
-  // Example:
-  //   cctz::time_zone nyc;
-  //   if (!cctz::load_time_zone("America/New_York", &nyc)) { ... }
-  //   const auto now = std::chrono::system_clock::now();
-  //   auto tp = cctz::time_point<cctz::seconds>::min();
-  //   cctz::time_zone::civil_transition trans;
-  //   while (tp <= now && nyc.next_transition(tp, &trans)) {
-  //     // transition: trans.from -> trans.to
-  //     tp = nyc.lookup(trans.to).trans;
-  //   }
-  struct civil_transition {
-    civil_second from;  // the civil time we jump from
-    civil_second to;    // the civil time we jump to
-  };
-  bool next_transition(const time_point<seconds>& tp,
-                       civil_transition* trans) const;
-  template <typename D>
-  bool next_transition(const time_point<D>& tp, civil_transition* trans) const {
-    return next_transition(detail::split_seconds(tp).first, trans);
-  }
-  bool prev_transition(const time_point<seconds>& tp,
-                       civil_transition* trans) const;
-  template <typename D>
-  bool prev_transition(const time_point<D>& tp, civil_transition* trans) const {
-    return prev_transition(detail::split_seconds(tp).first, trans);
-  }
-
-  // version() and description() provide additional information about the
-  // time zone. The content of each of the returned strings is unspecified,
-  // however, when the IANA Time Zone Database is the underlying data source
-  // the version() string will be in the familar form (e.g, "2018e") or
-  // empty when unavailable.
-  //
-  // Note: These functions are for informational or testing purposes only.
-  std::string version() const;  // empty when unknown
-  std::string description() const;
-
-  // Relational operators.
-  friend bool operator==(time_zone lhs, time_zone rhs) {
-    return &lhs.effective_impl() == &rhs.effective_impl();
-  }
-  friend bool operator!=(time_zone lhs, time_zone rhs) { return !(lhs == rhs); }
-
-  template <typename H>
-  friend H AbslHashValue(H h, time_zone tz) {
-    return H::combine(std::move(h), &tz.effective_impl());
-  }
-
-  class Impl;
-
- private:
-  explicit time_zone(const Impl* impl) : impl_(impl) {}
-  const Impl& effective_impl() const;  // handles implicit UTC
-  const Impl* impl_;
-};
-
-// Loads the named time zone. May perform I/O on the initial load.
-// If the name is invalid, or some other kind of error occurs, returns
-// false and "*tz" is set to the UTC time zone.
-bool load_time_zone(const std::string& name, time_zone* tz);
-
-// Returns a time_zone representing UTC. Cannot fail.
-time_zone utc_time_zone();
-
-// Returns a time zone that is a fixed offset (seconds east) from UTC.
-// Note: If the absolute value of the offset is greater than 24 hours
-// you'll get UTC (i.e., zero offset) instead.
-time_zone fixed_time_zone(const seconds& offset);
-
-// Returns a time zone representing the local time zone. Falls back to UTC.
-// Note: local_time_zone.name() may only be something like "localtime".
-time_zone local_time_zone();
-
-// Returns the civil time (cctz::civil_second) within the given time zone at
-// the given absolute time (time_point). Since the additional fields provided
-// by the time_zone::absolute_lookup struct should rarely be needed in modern
-// code, this convert() function is simpler and should be preferred.
-template <typename D>
-inline civil_second convert(const time_point<D>& tp, const time_zone& tz) {
-  return tz.lookup(tp).cs;
-}
-
-// Returns the absolute time (time_point) that corresponds to the given civil
-// time within the given time zone. If the civil time is not unique (i.e., if
-// it was either repeated or non-existent), then the returned time_point is
-// the best estimate that preserves relative order. That is, this function
-// guarantees that if cs1 < cs2, then convert(cs1, tz) <= convert(cs2, tz).
-inline time_point<seconds> convert(const civil_second& cs,
-                                   const time_zone& tz) {
-  const time_zone::civil_lookup cl = tz.lookup(cs);
-  if (cl.kind == time_zone::civil_lookup::SKIPPED) return cl.trans;
-  return cl.pre;
-}
-
-namespace detail {
-using femtoseconds = std::chrono::duration<std::int_fast64_t, std::femto>;
-std::string format(const std::string&, const time_point<seconds>&,
-                   const femtoseconds&, const time_zone&);
-bool parse(const std::string&, const std::string&, const time_zone&,
-           time_point<seconds>*, femtoseconds*, std::string* err = nullptr);
-template <typename Rep, std::intmax_t Denom>
-bool join_seconds(
-    const time_point<seconds>& sec, const femtoseconds& fs,
-    time_point<std::chrono::duration<Rep, std::ratio<1, Denom>>>* tpp);
-template <typename Rep, std::intmax_t Num>
-bool join_seconds(
-    const time_point<seconds>& sec, const femtoseconds& fs,
-    time_point<std::chrono::duration<Rep, std::ratio<Num, 1>>>* tpp);
-template <typename Rep>
-bool join_seconds(
-    const time_point<seconds>& sec, const femtoseconds& fs,
-    time_point<std::chrono::duration<Rep, std::ratio<1, 1>>>* tpp);
-bool join_seconds(const time_point<seconds>& sec, const femtoseconds&,
-                  time_point<seconds>* tpp);
-}  // namespace detail
-
-// Formats the given time_point in the given cctz::time_zone according to
-// the provided format string. Uses strftime()-like formatting options,
-// with the following extensions:
-//
-//   - %Ez  - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
-//   - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
-//   - %E#S - Seconds with # digits of fractional precision
-//   - %E*S - Seconds with full fractional precision (a literal '*')
-//   - %E#f - Fractional seconds with # digits of precision
-//   - %E*f - Fractional seconds with full precision (a literal '*')
-//   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
-//   - %ET  - The RFC3339 "date-time" separator "T"
-//
-// Note that %E0S behaves like %S, and %E0f produces no characters. In
-// contrast %E*f always produces at least one digit, which may be '0'.
-//
-// Note that %Y produces as many characters as it takes to fully render the
-// year. A year outside of [-999:9999] when formatted with %E4Y will produce
-// more than four characters, just like %Y.
-//
-// Tip: Format strings should include the UTC offset (e.g., %z, %Ez, or %E*z)
-// so that the resulting string uniquely identifies an absolute time.
-//
-// Example:
-//   cctz::time_zone lax;
-//   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
-//   auto tp = cctz::convert(cctz::civil_second(2013, 1, 2, 3, 4, 5), lax);
-//   std::string f = cctz::format("%H:%M:%S", tp, lax);  // "03:04:05"
-//   f = cctz::format("%H:%M:%E3S", tp, lax);            // "03:04:05.000"
-template <typename D>
-inline std::string format(const std::string& fmt, const time_point<D>& tp,
-                          const time_zone& tz) {
-  const auto p = detail::split_seconds(tp);
-  const auto n = std::chrono::duration_cast<detail::femtoseconds>(p.second);
-  return detail::format(fmt, p.first, n, tz);
-}
-
-// Parses an input string according to the provided format string and
-// returns the corresponding time_point. Uses strftime()-like formatting
-// options, with the same extensions as cctz::format(), but with the
-// exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez
-// and %E*z also accept the same inputs, which (along with %z) includes
-// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
-//
-// %Y consumes as many numeric characters as it can, so the matching data
-// should always be terminated with a non-numeric. %E4Y always consumes
-// exactly four characters, including any sign.
-//
-// Unspecified fields are taken from the default date and time of ...
-//
-//   "1970-01-01 00:00:00.0 +0000"
-//
-// For example, parsing a string of "15:45" (%H:%M) will return a time_point
-// that represents "1970-01-01 15:45:00.0 +0000".
-//
-// Note that parse() returns time instants, so it makes most sense to parse
-// fully-specified date/time strings that include a UTC offset (%z, %Ez, or
-// %E*z).
-//
-// Note also that parse() only heeds the fields year, month, day, hour,
-// minute, (fractional) second, and UTC offset. Other fields, like weekday (%a
-// or %A), while parsed for syntactic validity, are ignored in the conversion.
-//
-// Date and time fields that are out-of-range will be treated as errors rather
-// than normalizing them like cctz::civil_second() would do. For example, it
-// is an error to parse the date "Oct 32, 2013" because 32 is out of range.
-//
-// A second of ":60" is normalized to ":00" of the following minute with
-// fractional seconds discarded. The following table shows how the given
-// seconds and subseconds will be parsed:
-//
-//   "59.x" -> 59.x  // exact
-//   "60.x" -> 00.0  // normalized
-//   "00.x" -> 00.x  // exact
-//
-// Errors are indicated by returning false.
-//
-// Example:
-//   const cctz::time_zone tz = ...
-//   std::chrono::system_clock::time_point tp;
-//   if (cctz::parse("%Y-%m-%d", "2015-10-09", tz, &tp)) {
-//     ...
-//   }
-template <typename D>
-inline bool parse(const std::string& fmt, const std::string& input,
-                  const time_zone& tz, time_point<D>* tpp) {
-  time_point<seconds> sec;
-  detail::femtoseconds fs;
-  return detail::parse(fmt, input, tz, &sec, &fs) &&
-         detail::join_seconds(sec, fs, tpp);
-}
-
-namespace detail {
-
-// Split a time_point<D> into a time_point<seconds> and a D subseconds.
-// Undefined behavior if time_point<seconds> is not of sufficient range.
-// Note that this means it is UB to call cctz::time_zone::lookup(tp) or
-// cctz::format(fmt, tp, tz) with a time_point that is outside the range
-// of a 64-bit std::time_t.
-template <typename D>
-std::pair<time_point<seconds>, D> split_seconds(const time_point<D>& tp) {
-  auto sec = std::chrono::time_point_cast<seconds>(tp);
-  auto sub = tp - sec;
-  if (sub.count() < 0) {
-    sec -= seconds(1);
-    sub += seconds(1);
-  }
-  return {sec, std::chrono::duration_cast<D>(sub)};
-}
-
-inline std::pair<time_point<seconds>, seconds> split_seconds(
-    const time_point<seconds>& tp) {
-  return {tp, seconds::zero()};
-}
-
-// Join a time_point<seconds> and femto subseconds into a time_point<D>.
-// Floors to the resolution of time_point<D>. Returns false if time_point<D>
-// is not of sufficient range.
-template <typename Rep, std::intmax_t Denom>
-bool join_seconds(
-    const time_point<seconds>& sec, const femtoseconds& fs,
-    time_point<std::chrono::duration<Rep, std::ratio<1, Denom>>>* tpp) {
-  using D = std::chrono::duration<Rep, std::ratio<1, Denom>>;
-  // TODO(#199): Return false if result unrepresentable as a time_point<D>.
-  *tpp = std::chrono::time_point_cast<D>(sec);
-  *tpp += std::chrono::duration_cast<D>(fs);
-  return true;
-}
-
-template <typename Rep, std::intmax_t Num>
-bool join_seconds(
-    const time_point<seconds>& sec, const femtoseconds&,
-    time_point<std::chrono::duration<Rep, std::ratio<Num, 1>>>* tpp) {
-  using D = std::chrono::duration<Rep, std::ratio<Num, 1>>;
-  auto count = sec.time_since_epoch().count();
-  if (count >= 0 || count % Num == 0) {
-    count /= Num;
-  } else {
-    count /= Num;
-    count -= 1;
-  }
-  if (count > (std::numeric_limits<Rep>::max)()) return false;
-  if (count < (std::numeric_limits<Rep>::min)()) return false;
-  *tpp = time_point<D>() + D{static_cast<Rep>(count)};
-  return true;
-}
-
-template <typename Rep>
-bool join_seconds(
-    const time_point<seconds>& sec, const femtoseconds&,
-    time_point<std::chrono::duration<Rep, std::ratio<1, 1>>>* tpp) {
-  using D = std::chrono::duration<Rep, std::ratio<1, 1>>;
-  auto count = sec.time_since_epoch().count();
-  if (count > (std::numeric_limits<Rep>::max)()) return false;
-  if (count < (std::numeric_limits<Rep>::min)()) return false;
-  *tpp = time_point<D>() + D{static_cast<Rep>(count)};
-  return true;
-}
-
-inline bool join_seconds(const time_point<seconds>& sec, const femtoseconds&,
-                         time_point<seconds>* tpp) {
-  *tpp = sec;
-  return true;
-}
-
-}  // namespace detail
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
+
+            // Convenience aliases. Not intended as public API points.
+            template<typename D>
+            using time_point = std::chrono::time_point<std::chrono::system_clock, D>;
+            using seconds = std::chrono::duration<std::int_fast64_t>;
+            using sys_seconds = seconds;  // Deprecated.  Use cctz::seconds instead.
+
+            namespace detail
+            {
+                template<typename D>
+                std::pair<time_point<seconds>, D> split_seconds(const time_point<D>& tp);
+                std::pair<time_point<seconds>, seconds> split_seconds(
+                    const time_point<seconds>& tp
+                );
+            }  // namespace detail
+
+            // cctz::time_zone is an opaque, small, value-type class representing a
+            // geo-political region within which particular rules are used for mapping
+            // between absolute and civil times. Time zones are named using the TZ
+            // identifiers from the IANA Time Zone Database, such as "America/Los_Angeles"
+            // or "Australia/Sydney". Time zones are created from factory functions such
+            // as load_time_zone(). Note: strings like "PST" and "EDT" are not valid TZ
+            // identifiers.
+            //
+            // Example:
+            //   cctz::time_zone utc = cctz::utc_time_zone();
+            //   cctz::time_zone pst = cctz::fixed_time_zone(std::chrono::hours(-8));
+            //   cctz::time_zone loc = cctz::local_time_zone();
+            //   cctz::time_zone lax;
+            //   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+            //
+            // See also:
+            // - http://www.iana.org/time-zones
+            // - https://en.wikipedia.org/wiki/Zoneinfo
+            class time_zone
+            {
+            public:
+                time_zone() :
+                    time_zone(nullptr)
+                {
+                }  // Equivalent to UTC
+                time_zone(const time_zone&) = default;
+                time_zone& operator=(const time_zone&) = default;
+
+                std::string name() const;
+
+                // An absolute_lookup represents the civil time (cctz::civil_second) within
+                // this time_zone at the given absolute time (time_point). There are
+                // additionally a few other fields that may be useful when working with
+                // older APIs, such as std::tm.
+                //
+                // Example:
+                //   const cctz::time_zone tz = ...
+                //   const auto tp = std::chrono::system_clock::now();
+                //   const cctz::time_zone::absolute_lookup al = tz.lookup(tp);
+                struct absolute_lookup
+                {
+                    civil_second cs;
+                    // Note: The following fields exist for backward compatibility with older
+                    // APIs. Accessing these fields directly is a sign of imprudent logic in
+                    // the calling code. Modern time-related code should only access this data
+                    // indirectly by way of cctz::format().
+                    int offset;        // civil seconds east of UTC
+                    bool is_dst;       // is offset non-standard?
+                    const char* abbr;  // time-zone abbreviation (e.g., "PST")
+                };
+                absolute_lookup lookup(const time_point<seconds>& tp) const;
+                template<typename D>
+                absolute_lookup lookup(const time_point<D>& tp) const
+                {
+                    return lookup(detail::split_seconds(tp).first);
+                }
+
+                // A civil_lookup represents the absolute time(s) (time_point) that
+                // correspond to the given civil time (cctz::civil_second) within this
+                // time_zone. Usually the given civil time represents a unique instant
+                // in time, in which case the conversion is unambiguous. However,
+                // within this time zone, the given civil time may be skipped (e.g.,
+                // during a positive UTC offset shift), or repeated (e.g., during a
+                // negative UTC offset shift). To account for these possibilities,
+                // civil_lookup is richer than just a single time_point.
+                //
+                // In all cases the civil_lookup::kind enum will indicate the nature
+                // of the given civil-time argument, and the pre, trans, and post
+                // members will give the absolute time answers using the pre-transition
+                // offset, the transition point itself, and the post-transition offset,
+                // respectively (all three times are equal if kind == UNIQUE). If any
+                // of these three absolute times is outside the representable range of a
+                // time_point<seconds> the field is set to its maximum/minimum value.
+                //
+                // Example:
+                //   cctz::time_zone lax;
+                //   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+                //
+                //   // A unique civil time.
+                //   auto jan01 = lax.lookup(cctz::civil_second(2011, 1, 1, 0, 0, 0));
+                //   // jan01.kind == cctz::time_zone::civil_lookup::UNIQUE
+                //   // jan01.pre    is 2011/01/01 00:00:00 -0800
+                //   // jan01.trans  is 2011/01/01 00:00:00 -0800
+                //   // jan01.post   is 2011/01/01 00:00:00 -0800
+                //
+                //   // A Spring DST transition, when there is a gap in civil time.
+                //   auto mar13 = lax.lookup(cctz::civil_second(2011, 3, 13, 2, 15, 0));
+                //   // mar13.kind == cctz::time_zone::civil_lookup::SKIPPED
+                //   // mar13.pre   is 2011/03/13 03:15:00 -0700
+                //   // mar13.trans is 2011/03/13 03:00:00 -0700
+                //   // mar13.post  is 2011/03/13 01:15:00 -0800
+                //
+                //   // A Fall DST transition, when civil times are repeated.
+                //   auto nov06 = lax.lookup(cctz::civil_second(2011, 11, 6, 1, 15, 0));
+                //   // nov06.kind == cctz::time_zone::civil_lookup::REPEATED
+                //   // nov06.pre   is 2011/11/06 01:15:00 -0700
+                //   // nov06.trans is 2011/11/06 01:00:00 -0800
+                //   // nov06.post  is 2011/11/06 01:15:00 -0800
+                struct civil_lookup
+                {
+                    enum civil_kind
+                    {
+                        UNIQUE,    // the civil time was singular (pre == trans == post)
+                        SKIPPED,   // the civil time did not exist (pre >= trans > post)
+                        REPEATED,  // the civil time was ambiguous (pre < trans <= post)
+                    } kind;
+                    time_point<seconds> pre;    // uses the pre-transition offset
+                    time_point<seconds> trans;  // instant of civil-offset change
+                    time_point<seconds> post;   // uses the post-transition offset
+                };
+                civil_lookup lookup(const civil_second& cs) const;
+
+                // Finds the time of the next/previous offset change in this time zone.
+                //
+                // By definition, next_transition(tp, &trans) returns false when tp has
+                // its maximum value, and prev_transition(tp, &trans) returns false
+                // when tp has its minimum value. If the zone has no transitions, the
+                // result will also be false no matter what the argument.
+                //
+                // Otherwise, when tp has its minimum value, next_transition(tp, &trans)
+                // returns true and sets trans to the first recorded transition. Chains
+                // of calls to next_transition()/prev_transition() will eventually return
+                // false, but it is unspecified exactly when next_transition(tp, &trans)
+                // jumps to false, or what time is set by prev_transition(tp, &trans) for
+                // a very distant tp.
+                //
+                // Note: Enumeration of time-zone transitions is for informational purposes
+                // only. Modern time-related code should not care about when offset changes
+                // occur.
+                //
+                // Example:
+                //   cctz::time_zone nyc;
+                //   if (!cctz::load_time_zone("America/New_York", &nyc)) { ... }
+                //   const auto now = std::chrono::system_clock::now();
+                //   auto tp = cctz::time_point<cctz::seconds>::min();
+                //   cctz::time_zone::civil_transition trans;
+                //   while (tp <= now && nyc.next_transition(tp, &trans)) {
+                //     // transition: trans.from -> trans.to
+                //     tp = nyc.lookup(trans.to).trans;
+                //   }
+                struct civil_transition
+                {
+                    civil_second from;  // the civil time we jump from
+                    civil_second to;    // the civil time we jump to
+                };
+                bool next_transition(const time_point<seconds>& tp, civil_transition* trans) const;
+                template<typename D>
+                bool next_transition(const time_point<D>& tp, civil_transition* trans) const
+                {
+                    return next_transition(detail::split_seconds(tp).first, trans);
+                }
+                bool prev_transition(const time_point<seconds>& tp, civil_transition* trans) const;
+                template<typename D>
+                bool prev_transition(const time_point<D>& tp, civil_transition* trans) const
+                {
+                    return prev_transition(detail::split_seconds(tp).first, trans);
+                }
+
+                // version() and description() provide additional information about the
+                // time zone. The content of each of the returned strings is unspecified,
+                // however, when the IANA Time Zone Database is the underlying data source
+                // the version() string will be in the familar form (e.g, "2018e") or
+                // empty when unavailable.
+                //
+                // Note: These functions are for informational or testing purposes only.
+                std::string version() const;  // empty when unknown
+                std::string description() const;
+
+                // Relational operators.
+                friend bool operator==(time_zone lhs, time_zone rhs)
+                {
+                    return &lhs.effective_impl() == &rhs.effective_impl();
+                }
+                friend bool operator!=(time_zone lhs, time_zone rhs)
+                {
+                    return !(lhs == rhs);
+                }
+
+                template<typename H>
+                friend H AbslHashValue(H h, time_zone tz)
+                {
+                    return H::combine(std::move(h), &tz.effective_impl());
+                }
+
+                class Impl;
+
+            private:
+                explicit time_zone(const Impl* impl) :
+                    impl_(impl)
+                {
+                }
+                const Impl& effective_impl() const;  // handles implicit UTC
+                const Impl* impl_;
+            };
+
+            // Loads the named time zone. May perform I/O on the initial load.
+            // If the name is invalid, or some other kind of error occurs, returns
+            // false and "*tz" is set to the UTC time zone.
+            bool load_time_zone(const std::string& name, time_zone* tz);
+
+            // Returns a time_zone representing UTC. Cannot fail.
+            time_zone utc_time_zone();
+
+            // Returns a time zone that is a fixed offset (seconds east) from UTC.
+            // Note: If the absolute value of the offset is greater than 24 hours
+            // you'll get UTC (i.e., zero offset) instead.
+            time_zone fixed_time_zone(const seconds& offset);
+
+            // Returns a time zone representing the local time zone. Falls back to UTC.
+            // Note: local_time_zone.name() may only be something like "localtime".
+            time_zone local_time_zone();
+
+            // Returns the civil time (cctz::civil_second) within the given time zone at
+            // the given absolute time (time_point). Since the additional fields provided
+            // by the time_zone::absolute_lookup struct should rarely be needed in modern
+            // code, this convert() function is simpler and should be preferred.
+            template<typename D>
+            inline civil_second convert(const time_point<D>& tp, const time_zone& tz)
+            {
+                return tz.lookup(tp).cs;
+            }
+
+            // Returns the absolute time (time_point) that corresponds to the given civil
+            // time within the given time zone. If the civil time is not unique (i.e., if
+            // it was either repeated or non-existent), then the returned time_point is
+            // the best estimate that preserves relative order. That is, this function
+            // guarantees that if cs1 < cs2, then convert(cs1, tz) <= convert(cs2, tz).
+            inline time_point<seconds> convert(const civil_second& cs, const time_zone& tz)
+            {
+                const time_zone::civil_lookup cl = tz.lookup(cs);
+                if (cl.kind == time_zone::civil_lookup::SKIPPED)
+                    return cl.trans;
+                return cl.pre;
+            }
+
+            namespace detail
+            {
+                using femtoseconds = std::chrono::duration<std::int_fast64_t, std::femto>;
+                std::string format(const std::string&, const time_point<seconds>&, const femtoseconds&, const time_zone&);
+                bool parse(const std::string&, const std::string&, const time_zone&, time_point<seconds>*, femtoseconds*, std::string* err = nullptr);
+                template<typename Rep, std::intmax_t Denom>
+                bool join_seconds(
+                    const time_point<seconds>& sec, const femtoseconds& fs, time_point<std::chrono::duration<Rep, std::ratio<1, Denom>>>* tpp
+                );
+                template<typename Rep, std::intmax_t Num>
+                bool join_seconds(
+                    const time_point<seconds>& sec, const femtoseconds& fs, time_point<std::chrono::duration<Rep, std::ratio<Num, 1>>>* tpp
+                );
+                template<typename Rep>
+                bool join_seconds(
+                    const time_point<seconds>& sec, const femtoseconds& fs, time_point<std::chrono::duration<Rep, std::ratio<1, 1>>>* tpp
+                );
+                bool join_seconds(const time_point<seconds>& sec, const femtoseconds&, time_point<seconds>* tpp);
+            }  // namespace detail
+
+            // Formats the given time_point in the given cctz::time_zone according to
+            // the provided format string. Uses strftime()-like formatting options,
+            // with the following extensions:
+            //
+            //   - %Ez  - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
+            //   - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
+            //   - %E#S - Seconds with # digits of fractional precision
+            //   - %E*S - Seconds with full fractional precision (a literal '*')
+            //   - %E#f - Fractional seconds with # digits of precision
+            //   - %E*f - Fractional seconds with full precision (a literal '*')
+            //   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
+            //   - %ET  - The RFC3339 "date-time" separator "T"
+            //
+            // Note that %E0S behaves like %S, and %E0f produces no characters. In
+            // contrast %E*f always produces at least one digit, which may be '0'.
+            //
+            // Note that %Y produces as many characters as it takes to fully render the
+            // year. A year outside of [-999:9999] when formatted with %E4Y will produce
+            // more than four characters, just like %Y.
+            //
+            // Tip: Format strings should include the UTC offset (e.g., %z, %Ez, or %E*z)
+            // so that the resulting string uniquely identifies an absolute time.
+            //
+            // Example:
+            //   cctz::time_zone lax;
+            //   if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+            //   auto tp = cctz::convert(cctz::civil_second(2013, 1, 2, 3, 4, 5), lax);
+            //   std::string f = cctz::format("%H:%M:%S", tp, lax);  // "03:04:05"
+            //   f = cctz::format("%H:%M:%E3S", tp, lax);            // "03:04:05.000"
+            template<typename D>
+            inline std::string format(const std::string& fmt, const time_point<D>& tp, const time_zone& tz)
+            {
+                const auto p = detail::split_seconds(tp);
+                const auto n = std::chrono::duration_cast<detail::femtoseconds>(p.second);
+                return detail::format(fmt, p.first, n, tz);
+            }
+
+            // Parses an input string according to the provided format string and
+            // returns the corresponding time_point. Uses strftime()-like formatting
+            // options, with the same extensions as cctz::format(), but with the
+            // exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez
+            // and %E*z also accept the same inputs, which (along with %z) includes
+            // 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
+            //
+            // %Y consumes as many numeric characters as it can, so the matching data
+            // should always be terminated with a non-numeric. %E4Y always consumes
+            // exactly four characters, including any sign.
+            //
+            // Unspecified fields are taken from the default date and time of ...
+            //
+            //   "1970-01-01 00:00:00.0 +0000"
+            //
+            // For example, parsing a string of "15:45" (%H:%M) will return a time_point
+            // that represents "1970-01-01 15:45:00.0 +0000".
+            //
+            // Note that parse() returns time instants, so it makes most sense to parse
+            // fully-specified date/time strings that include a UTC offset (%z, %Ez, or
+            // %E*z).
+            //
+            // Note also that parse() only heeds the fields year, month, day, hour,
+            // minute, (fractional) second, and UTC offset. Other fields, like weekday (%a
+            // or %A), while parsed for syntactic validity, are ignored in the conversion.
+            //
+            // Date and time fields that are out-of-range will be treated as errors rather
+            // than normalizing them like cctz::civil_second() would do. For example, it
+            // is an error to parse the date "Oct 32, 2013" because 32 is out of range.
+            //
+            // A second of ":60" is normalized to ":00" of the following minute with
+            // fractional seconds discarded. The following table shows how the given
+            // seconds and subseconds will be parsed:
+            //
+            //   "59.x" -> 59.x  // exact
+            //   "60.x" -> 00.0  // normalized
+            //   "00.x" -> 00.x  // exact
+            //
+            // Errors are indicated by returning false.
+            //
+            // Example:
+            //   const cctz::time_zone tz = ...
+            //   std::chrono::system_clock::time_point tp;
+            //   if (cctz::parse("%Y-%m-%d", "2015-10-09", tz, &tp)) {
+            //     ...
+            //   }
+            template<typename D>
+            inline bool parse(const std::string& fmt, const std::string& input, const time_zone& tz, time_point<D>* tpp)
+            {
+                time_point<seconds> sec;
+                detail::femtoseconds fs;
+                return detail::parse(fmt, input, tz, &sec, &fs) &&
+                       detail::join_seconds(sec, fs, tpp);
+            }
+
+            namespace detail
+            {
+
+                // Split a time_point<D> into a time_point<seconds> and a D subseconds.
+                // Undefined behavior if time_point<seconds> is not of sufficient range.
+                // Note that this means it is UB to call cctz::time_zone::lookup(tp) or
+                // cctz::format(fmt, tp, tz) with a time_point that is outside the range
+                // of a 64-bit std::time_t.
+                template<typename D>
+                std::pair<time_point<seconds>, D> split_seconds(const time_point<D>& tp)
+                {
+                    auto sec = std::chrono::time_point_cast<seconds>(tp);
+                    auto sub = tp - sec;
+                    if (sub.count() < 0)
+                    {
+                        sec -= seconds(1);
+                        sub += seconds(1);
+                    }
+                    return {sec, std::chrono::duration_cast<D>(sub)};
+                }
+
+                inline std::pair<time_point<seconds>, seconds> split_seconds(
+                    const time_point<seconds>& tp
+                )
+                {
+                    return {tp, seconds::zero()};
+                }
+
+                // Join a time_point<seconds> and femto subseconds into a time_point<D>.
+                // Floors to the resolution of time_point<D>. Returns false if time_point<D>
+                // is not of sufficient range.
+                template<typename Rep, std::intmax_t Denom>
+                bool join_seconds(
+                    const time_point<seconds>& sec, const femtoseconds& fs, time_point<std::chrono::duration<Rep, std::ratio<1, Denom>>>* tpp
+                )
+                {
+                    using D = std::chrono::duration<Rep, std::ratio<1, Denom>>;
+                    // TODO(#199): Return false if result unrepresentable as a time_point<D>.
+                    *tpp = std::chrono::time_point_cast<D>(sec);
+                    *tpp += std::chrono::duration_cast<D>(fs);
+                    return true;
+                }
+
+                template<typename Rep, std::intmax_t Num>
+                bool join_seconds(
+                    const time_point<seconds>& sec, const femtoseconds&, time_point<std::chrono::duration<Rep, std::ratio<Num, 1>>>* tpp
+                )
+                {
+                    using D = std::chrono::duration<Rep, std::ratio<Num, 1>>;
+                    auto count = sec.time_since_epoch().count();
+                    if (count >= 0 || count % Num == 0)
+                    {
+                        count /= Num;
+                    }
+                    else
+                    {
+                        count /= Num;
+                        count -= 1;
+                    }
+                    if (count > (std::numeric_limits<Rep>::max)())
+                        return false;
+                    if (count < (std::numeric_limits<Rep>::min)())
+                        return false;
+                    *tpp = time_point<D>() + D{static_cast<Rep>(count)};
+                    return true;
+                }
+
+                template<typename Rep>
+                bool join_seconds(
+                    const time_point<seconds>& sec, const femtoseconds&, time_point<std::chrono::duration<Rep, std::ratio<1, 1>>>* tpp
+                )
+                {
+                    using D = std::chrono::duration<Rep, std::ratio<1, 1>>;
+                    auto count = sec.time_since_epoch().count();
+                    if (count > (std::numeric_limits<Rep>::max)())
+                        return false;
+                    if (count < (std::numeric_limits<Rep>::min)())
+                        return false;
+                    *tpp = time_point<D>() + D{static_cast<Rep>(count)};
+                    return true;
+                }
+
+                inline bool join_seconds(const time_point<seconds>& sec, const femtoseconds&, time_point<seconds>* tpp)
+                {
+                    *tpp = sec;
+                    return true;
+                }
+
+            }  // namespace detail
+        }      // namespace cctz
+    }          // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/zone_info_source.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/zone_info_source.h
index 012eb4e..ab5cbc6 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/zone_info_source.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/include/cctz/zone_info_source.h
@@ -22,81 +22,89 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
 
-// A stdio-like interface for providing zoneinfo data for a particular zone.
-class ZoneInfoSource {
- public:
-  virtual ~ZoneInfoSource();
+            // A stdio-like interface for providing zoneinfo data for a particular zone.
+            class ZoneInfoSource
+            {
+            public:
+                virtual ~ZoneInfoSource();
 
-  virtual std::size_t Read(void* ptr, std::size_t size) = 0;  // like fread()
-  virtual int Skip(std::size_t offset) = 0;                   // like fseek()
+                virtual std::size_t Read(void* ptr, std::size_t size) = 0;  // like fread()
+                virtual int Skip(std::size_t offset) = 0;                   // like fseek()
 
-  // Until the zoneinfo data supports versioning information, we provide
-  // a way for a ZoneInfoSource to indicate it out-of-band.  The default
-  // implementation returns an empty string.
-  virtual std::string Version() const;
-};
+                // Until the zoneinfo data supports versioning information, we provide
+                // a way for a ZoneInfoSource to indicate it out-of-band.  The default
+                // implementation returns an empty string.
+                virtual std::string Version() const;
+            };
 
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+        }  // namespace cctz
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz_extension {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz_extension
+        {
 
-// A function-pointer type for a factory that returns a ZoneInfoSource
-// given the name of a time zone and a fallback factory.  Returns null
-// when the data for the named zone cannot be found.
-using ZoneInfoSourceFactory =
-    std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource> (*)(
-        const std::string&,
-        const std::function<std::unique_ptr<
-            absl::time_internal::cctz::ZoneInfoSource>(const std::string&)>&);
+            // A function-pointer type for a factory that returns a ZoneInfoSource
+            // given the name of a time zone and a fallback factory.  Returns null
+            // when the data for the named zone cannot be found.
+            using ZoneInfoSourceFactory =
+                std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource> (*)(
+                    const std::string&,
+                    const std::function<std::unique_ptr<
+                        absl::time_internal::cctz::ZoneInfoSource>(const std::string&)>&
+                );
 
-// The user can control the mapping of zone names to zoneinfo data by
-// providing a definition for cctz_extension::zone_info_source_factory.
-// For example, given functions my_factory() and my_other_factory() that
-// can return a ZoneInfoSource for a named zone, we could inject them into
-// cctz::load_time_zone() with:
-//
-//   namespace cctz_extension {
-//   namespace {
-//   std::unique_ptr<cctz::ZoneInfoSource> CustomFactory(
-//       const std::string& name,
-//       const std::function<std::unique_ptr<cctz::ZoneInfoSource>(
-//           const std::string& name)>& fallback_factory) {
-//     if (auto zip = my_factory(name)) return zip;
-//     if (auto zip = fallback_factory(name)) return zip;
-//     if (auto zip = my_other_factory(name)) return zip;
-//     return nullptr;
-//   }
-//   }  // namespace
-//   ZoneInfoSourceFactory zone_info_source_factory = CustomFactory;
-//   }  // namespace cctz_extension
-//
-// This might be used, say, to use zoneinfo data embedded in the program,
-// or read from a (possibly compressed) file archive, or both.
-//
-// cctz_extension::zone_info_source_factory() will be called:
-//   (1) from the same thread as the cctz::load_time_zone() call,
-//   (2) only once for any zone name, and
-//   (3) serially (i.e., no concurrent execution).
-//
-// The fallback factory obtains zoneinfo data by reading files in ${TZDIR},
-// and it is used automatically when no zone_info_source_factory definition
-// is linked into the program.
-extern ZoneInfoSourceFactory zone_info_source_factory;
+            // The user can control the mapping of zone names to zoneinfo data by
+            // providing a definition for cctz_extension::zone_info_source_factory.
+            // For example, given functions my_factory() and my_other_factory() that
+            // can return a ZoneInfoSource for a named zone, we could inject them into
+            // cctz::load_time_zone() with:
+            //
+            //   namespace cctz_extension {
+            //   namespace {
+            //   std::unique_ptr<cctz::ZoneInfoSource> CustomFactory(
+            //       const std::string& name,
+            //       const std::function<std::unique_ptr<cctz::ZoneInfoSource>(
+            //           const std::string& name)>& fallback_factory) {
+            //     if (auto zip = my_factory(name)) return zip;
+            //     if (auto zip = fallback_factory(name)) return zip;
+            //     if (auto zip = my_other_factory(name)) return zip;
+            //     return nullptr;
+            //   }
+            //   }  // namespace
+            //   ZoneInfoSourceFactory zone_info_source_factory = CustomFactory;
+            //   }  // namespace cctz_extension
+            //
+            // This might be used, say, to use zoneinfo data embedded in the program,
+            // or read from a (possibly compressed) file archive, or both.
+            //
+            // cctz_extension::zone_info_source_factory() will be called:
+            //   (1) from the same thread as the cctz::load_time_zone() call,
+            //   (2) only once for any zone name, and
+            //   (3) serially (i.e., no concurrent execution).
+            //
+            // The fallback factory obtains zoneinfo data by reading files in ${TZDIR},
+            // and it is used automatically when no zone_info_source_factory definition
+            // is linked into the program.
+            extern ZoneInfoSourceFactory zone_info_source_factory;
 
-}  // namespace cctz_extension
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+        }  // namespace cctz_extension
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_fixed.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_fixed.h
index e74a0bb..5aaa52e 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_fixed.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_fixed.h
@@ -20,33 +20,36 @@
 #include "absl/base/config.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
 
-// Helper functions for dealing with the names and abbreviations
-// of time zones that are a fixed offset (seconds east) from UTC.
-// FixedOffsetFromName() extracts the offset from a valid fixed-offset
-// name, while FixedOffsetToName() and FixedOffsetToAbbr() generate
-// the canonical zone name and abbreviation respectively for the given
-// offset.
-//
-// A fixed-offset name looks like "Fixed/UTC<+-><hours>:<mins>:<secs>".
-// Its abbreviation is of the form "UTC(<+->H?H(MM(SS)?)?)?" where the
-// optional pieces are omitted when their values are zero.  (Note that
-// the sign is the opposite of that used in a POSIX TZ specification.)
-//
-// Note: FixedOffsetFromName() fails on syntax errors or when the parsed
-// offset exceeds 24 hours.  FixedOffsetToName() and FixedOffsetToAbbr()
-// both produce "UTC" when the argument offset exceeds 24 hours.
-bool FixedOffsetFromName(const std::string& name, seconds* offset);
-std::string FixedOffsetToName(const seconds& offset);
-std::string FixedOffsetToAbbr(const seconds& offset);
+            // Helper functions for dealing with the names and abbreviations
+            // of time zones that are a fixed offset (seconds east) from UTC.
+            // FixedOffsetFromName() extracts the offset from a valid fixed-offset
+            // name, while FixedOffsetToName() and FixedOffsetToAbbr() generate
+            // the canonical zone name and abbreviation respectively for the given
+            // offset.
+            //
+            // A fixed-offset name looks like "Fixed/UTC<+-><hours>:<mins>:<secs>".
+            // Its abbreviation is of the form "UTC(<+->H?H(MM(SS)?)?)?" where the
+            // optional pieces are omitted when their values are zero.  (Note that
+            // the sign is the opposite of that used in a POSIX TZ specification.)
+            //
+            // Note: FixedOffsetFromName() fails on syntax errors or when the parsed
+            // offset exceeds 24 hours.  FixedOffsetToName() and FixedOffsetToAbbr()
+            // both produce "UTC" when the argument offset exceeds 24 hours.
+            bool FixedOffsetFromName(const std::string& name, seconds* offset);
+            std::string FixedOffsetToName(const seconds& offset);
+            std::string FixedOffsetToAbbr(const seconds& offset);
 
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+        }  // namespace cctz
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_if.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_if.h
index 7d3e42d..9baf232 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_if.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_if.h
@@ -24,54 +24,63 @@
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
 
-// A simple interface used to hide time-zone complexities from time_zone::Impl.
-// Subclasses implement the functions for civil-time conversions in the zone.
-class TimeZoneIf {
- public:
-  // A factory function for TimeZoneIf implementations.
-  static std::unique_ptr<TimeZoneIf> Load(const std::string& name);
+            // A simple interface used to hide time-zone complexities from time_zone::Impl.
+            // Subclasses implement the functions for civil-time conversions in the zone.
+            class TimeZoneIf
+            {
+            public:
+                // A factory function for TimeZoneIf implementations.
+                static std::unique_ptr<TimeZoneIf> Load(const std::string& name);
 
-  virtual ~TimeZoneIf();
+                virtual ~TimeZoneIf();
 
-  virtual time_zone::absolute_lookup BreakTime(
-      const time_point<seconds>& tp) const = 0;
-  virtual time_zone::civil_lookup MakeTime(const civil_second& cs) const = 0;
+                virtual time_zone::absolute_lookup BreakTime(
+                    const time_point<seconds>& tp
+                ) const = 0;
+                virtual time_zone::civil_lookup MakeTime(const civil_second& cs) const = 0;
 
-  virtual bool NextTransition(const time_point<seconds>& tp,
-                              time_zone::civil_transition* trans) const = 0;
-  virtual bool PrevTransition(const time_point<seconds>& tp,
-                              time_zone::civil_transition* trans) const = 0;
+                virtual bool NextTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const = 0;
+                virtual bool PrevTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const = 0;
 
-  virtual std::string Version() const = 0;
-  virtual std::string Description() const = 0;
+                virtual std::string Version() const = 0;
+                virtual std::string Description() const = 0;
 
- protected:
-  TimeZoneIf() {}
-};
+            protected:
+                TimeZoneIf()
+                {
+                }
+            };
 
-// Convert between time_point<seconds> and a count of seconds since the
-// Unix epoch.  We assume that the std::chrono::system_clock and the
-// Unix clock are second aligned, and that the results are representable.
-// (That is, that they share an epoch, which is required since C++20.)
-inline std::int_fast64_t ToUnixSeconds(const time_point<seconds>& tp) {
-  return (tp - std::chrono::time_point_cast<seconds>(
-                   std::chrono::system_clock::from_time_t(0)))
-      .count();
-}
-inline time_point<seconds> FromUnixSeconds(std::int_fast64_t t) {
-  return std::chrono::time_point_cast<seconds>(
-             std::chrono::system_clock::from_time_t(0)) +
-         seconds(t);
-}
+            // Convert between time_point<seconds> and a count of seconds since the
+            // Unix epoch.  We assume that the std::chrono::system_clock and the
+            // Unix clock are second aligned, and that the results are representable.
+            // (That is, that they share an epoch, which is required since C++20.)
+            inline std::int_fast64_t ToUnixSeconds(const time_point<seconds>& tp)
+            {
+                return (tp - std::chrono::time_point_cast<seconds>(
+                                 std::chrono::system_clock::from_time_t(0)
+                             ))
+                    .count();
+            }
+            inline time_point<seconds> FromUnixSeconds(std::int_fast64_t t)
+            {
+                return std::chrono::time_point_cast<seconds>(
+                           std::chrono::system_clock::from_time_t(0)
+                       ) +
+                       seconds(t);
+            }
 
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+        }  // namespace cctz
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_impl.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_impl.h
index 7d747ba..3c800d1 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_impl.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_impl.h
@@ -24,70 +24,83 @@
 #include "time_zone_if.h"
 #include "time_zone_info.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-// time_zone::Impl is the internal object referenced by a cctz::time_zone.
-class time_zone::Impl {
- public:
-  // The UTC time zone. Also used for other time zones that fail to load.
-  static time_zone UTC();
-
-  // Load a named time zone. Returns false if the name is invalid, or if
-  // some other kind of error occurs. Note that loading "UTC" never fails.
-  static bool LoadTimeZone(const std::string& name, time_zone* tz);
-
-  // Clears the map of cached time zones.  Primarily for use in benchmarks
-  // that gauge the performance of loading/parsing the time-zone data.
-  static void ClearTimeZoneMapTestOnly();
-
-  // The primary key is the time-zone ID (e.g., "America/New_York").
-  const std::string& Name() const {
-    // TODO: It would nice if the zoneinfo data included the zone name.
-    return name_;
-  }
-
-  // Breaks a time_point down to civil-time components in this time zone.
-  time_zone::absolute_lookup BreakTime(const time_point<seconds>& tp) const {
-    return zone_->BreakTime(tp);
-  }
-
-  // Converts the civil-time components in this time zone into a time_point.
-  // That is, the opposite of BreakTime(). The requested civil time may be
-  // ambiguous or illegal due to a change of UTC offset.
-  time_zone::civil_lookup MakeTime(const civil_second& cs) const {
-    return zone_->MakeTime(cs);
-  }
-
-  // Finds the time of the next/previous offset change in this time zone.
-  bool NextTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const {
-    return zone_->NextTransition(tp, trans);
-  }
-  bool PrevTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const {
-    return zone_->PrevTransition(tp, trans);
-  }
-
-  // Returns an implementation-defined version string for this time zone.
-  std::string Version() const { return zone_->Version(); }
-
-  // Returns an implementation-defined description of this time zone.
-  std::string Description() const { return zone_->Description(); }
-
- private:
-  explicit Impl(const std::string& name);
-  static const Impl* UTCImpl();
-
-  const std::string name_;
-  std::unique_ptr<TimeZoneIf> zone_;
-};
-
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
+
+            // time_zone::Impl is the internal object referenced by a cctz::time_zone.
+            class time_zone::Impl
+            {
+            public:
+                // The UTC time zone. Also used for other time zones that fail to load.
+                static time_zone UTC();
+
+                // Load a named time zone. Returns false if the name is invalid, or if
+                // some other kind of error occurs. Note that loading "UTC" never fails.
+                static bool LoadTimeZone(const std::string& name, time_zone* tz);
+
+                // Clears the map of cached time zones.  Primarily for use in benchmarks
+                // that gauge the performance of loading/parsing the time-zone data.
+                static void ClearTimeZoneMapTestOnly();
+
+                // The primary key is the time-zone ID (e.g., "America/New_York").
+                const std::string& Name() const
+                {
+                    // TODO: It would nice if the zoneinfo data included the zone name.
+                    return name_;
+                }
+
+                // Breaks a time_point down to civil-time components in this time zone.
+                time_zone::absolute_lookup BreakTime(const time_point<seconds>& tp) const
+                {
+                    return zone_->BreakTime(tp);
+                }
+
+                // Converts the civil-time components in this time zone into a time_point.
+                // That is, the opposite of BreakTime(). The requested civil time may be
+                // ambiguous or illegal due to a change of UTC offset.
+                time_zone::civil_lookup MakeTime(const civil_second& cs) const
+                {
+                    return zone_->MakeTime(cs);
+                }
+
+                // Finds the time of the next/previous offset change in this time zone.
+                bool NextTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const
+                {
+                    return zone_->NextTransition(tp, trans);
+                }
+                bool PrevTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const
+                {
+                    return zone_->PrevTransition(tp, trans);
+                }
+
+                // Returns an implementation-defined version string for this time zone.
+                std::string Version() const
+                {
+                    return zone_->Version();
+                }
+
+                // Returns an implementation-defined description of this time zone.
+                std::string Description() const
+                {
+                    return zone_->Description();
+                }
+
+            private:
+                explicit Impl(const std::string& name);
+                static const Impl* UTCImpl();
+
+                const std::string name_;
+                std::unique_ptr<TimeZoneIf> zone_;
+            };
+
+        }  // namespace cctz
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_info.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_info.h
index 2467ff5..e2dae04 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_info.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_info.h
@@ -28,110 +28,115 @@
 #include "time_zone_if.h"
 #include "tzfile.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-// A transition to a new UTC offset.
-struct Transition {
-  std::int_least64_t unix_time;   // the instant of this transition
-  std::uint_least8_t type_index;  // index of the transition type
-  civil_second civil_sec;         // local civil time of transition
-  civil_second prev_civil_sec;    // local civil time one second earlier
-
-  struct ByUnixTime {
-    inline bool operator()(const Transition& lhs, const Transition& rhs) const {
-      return lhs.unix_time < rhs.unix_time;
-    }
-  };
-  struct ByCivilTime {
-    inline bool operator()(const Transition& lhs, const Transition& rhs) const {
-      return lhs.civil_sec < rhs.civil_sec;
-    }
-  };
-};
-
-// The characteristics of a particular transition.
-struct TransitionType {
-  std::int_least32_t utc_offset;  // the new prevailing UTC offset
-  civil_second civil_max;         // max convertible civil time for offset
-  civil_second civil_min;         // min convertible civil time for offset
-  bool is_dst;                    // did we move into daylight-saving time
-  std::uint_least8_t abbr_index;  // index of the new abbreviation
-};
-
-// A time zone backed by the IANA Time Zone Database (zoneinfo).
-class TimeZoneInfo : public TimeZoneIf {
- public:
-  TimeZoneInfo() = default;
-  TimeZoneInfo(const TimeZoneInfo&) = delete;
-  TimeZoneInfo& operator=(const TimeZoneInfo&) = delete;
-
-  // Loads the zoneinfo for the given name, returning true if successful.
-  bool Load(const std::string& name);
-
-  // TimeZoneIf implementations.
-  time_zone::absolute_lookup BreakTime(
-      const time_point<seconds>& tp) const override;
-  time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
-  bool NextTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const override;
-  bool PrevTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const override;
-  std::string Version() const override;
-  std::string Description() const override;
-
- private:
-  struct Header {            // counts of:
-    std::size_t timecnt;     // transition times
-    std::size_t typecnt;     // transition types
-    std::size_t charcnt;     // zone abbreviation characters
-    std::size_t leapcnt;     // leap seconds (we expect none)
-    std::size_t ttisstdcnt;  // UTC/local indicators (unused)
-    std::size_t ttisutcnt;   // standard/wall indicators (unused)
-
-    bool Build(const tzhead& tzh);
-    std::size_t DataLength(std::size_t time_len) const;
-  };
-
-  bool GetTransitionType(std::int_fast32_t utc_offset, bool is_dst,
-                         const std::string& abbr, std::uint_least8_t* index);
-  bool EquivTransitions(std::uint_fast8_t tt1_index,
-                        std::uint_fast8_t tt2_index) const;
-  bool ExtendTransitions();
-
-  bool ResetToBuiltinUTC(const seconds& offset);
-  bool Load(ZoneInfoSource* zip);
-
-  // Helpers for BreakTime() and MakeTime().
-  time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
-                                       const TransitionType& tt) const;
-  time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
-                                       const Transition& tr) const;
-  time_zone::civil_lookup TimeLocal(const civil_second& cs,
-                                    year_t c4_shift) const;
-
-  std::vector<Transition> transitions_;  // ordered by unix_time and civil_sec
-  std::vector<TransitionType> transition_types_;  // distinct transition types
-  std::uint_fast8_t default_transition_type_;     // for before first transition
-  std::string abbreviations_;  // all the NUL-terminated abbreviations
-
-  std::string version_;      // the tzdata version if available
-  std::string future_spec_;  // for after the last zic transition
-  bool extended_;            // future_spec_ was used to generate transitions
-  year_t last_year_;         // the final year of the generated transitions
-
-  // We remember the transitions found during the last BreakTime() and
-  // MakeTime() calls. If the next request is for the same transition we
-  // will avoid re-searching.
-  mutable std::atomic<std::size_t> local_time_hint_ = {};  // BreakTime() hint
-  mutable std::atomic<std::size_t> time_local_hint_ = {};  // MakeTime() hint
-};
-
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
+
+            // A transition to a new UTC offset.
+            struct Transition
+            {
+                std::int_least64_t unix_time;   // the instant of this transition
+                std::uint_least8_t type_index;  // index of the transition type
+                civil_second civil_sec;         // local civil time of transition
+                civil_second prev_civil_sec;    // local civil time one second earlier
+
+                struct ByUnixTime
+                {
+                    inline bool operator()(const Transition& lhs, const Transition& rhs) const
+                    {
+                        return lhs.unix_time < rhs.unix_time;
+                    }
+                };
+                struct ByCivilTime
+                {
+                    inline bool operator()(const Transition& lhs, const Transition& rhs) const
+                    {
+                        return lhs.civil_sec < rhs.civil_sec;
+                    }
+                };
+            };
+
+            // The characteristics of a particular transition.
+            struct TransitionType
+            {
+                std::int_least32_t utc_offset;  // the new prevailing UTC offset
+                civil_second civil_max;         // max convertible civil time for offset
+                civil_second civil_min;         // min convertible civil time for offset
+                bool is_dst;                    // did we move into daylight-saving time
+                std::uint_least8_t abbr_index;  // index of the new abbreviation
+            };
+
+            // A time zone backed by the IANA Time Zone Database (zoneinfo).
+            class TimeZoneInfo : public TimeZoneIf
+            {
+            public:
+                TimeZoneInfo() = default;
+                TimeZoneInfo(const TimeZoneInfo&) = delete;
+                TimeZoneInfo& operator=(const TimeZoneInfo&) = delete;
+
+                // Loads the zoneinfo for the given name, returning true if successful.
+                bool Load(const std::string& name);
+
+                // TimeZoneIf implementations.
+                time_zone::absolute_lookup BreakTime(
+                    const time_point<seconds>& tp
+                ) const override;
+                time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
+                bool NextTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const override;
+                bool PrevTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const override;
+                std::string Version() const override;
+                std::string Description() const override;
+
+            private:
+                struct Header
+                {                            // counts of:
+                    std::size_t timecnt;     // transition times
+                    std::size_t typecnt;     // transition types
+                    std::size_t charcnt;     // zone abbreviation characters
+                    std::size_t leapcnt;     // leap seconds (we expect none)
+                    std::size_t ttisstdcnt;  // UTC/local indicators (unused)
+                    std::size_t ttisutcnt;   // standard/wall indicators (unused)
+
+                    bool Build(const tzhead& tzh);
+                    std::size_t DataLength(std::size_t time_len) const;
+                };
+
+                bool GetTransitionType(std::int_fast32_t utc_offset, bool is_dst, const std::string& abbr, std::uint_least8_t* index);
+                bool EquivTransitions(std::uint_fast8_t tt1_index, std::uint_fast8_t tt2_index) const;
+                bool ExtendTransitions();
+
+                bool ResetToBuiltinUTC(const seconds& offset);
+                bool Load(ZoneInfoSource* zip);
+
+                // Helpers for BreakTime() and MakeTime().
+                time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time, const TransitionType& tt) const;
+                time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time, const Transition& tr) const;
+                time_zone::civil_lookup TimeLocal(const civil_second& cs, year_t c4_shift) const;
+
+                std::vector<Transition> transitions_;           // ordered by unix_time and civil_sec
+                std::vector<TransitionType> transition_types_;  // distinct transition types
+                std::uint_fast8_t default_transition_type_;     // for before first transition
+                std::string abbreviations_;                     // all the NUL-terminated abbreviations
+
+                std::string version_;      // the tzdata version if available
+                std::string future_spec_;  // for after the last zic transition
+                bool extended_;            // future_spec_ was used to generate transitions
+                year_t last_year_;         // the final year of the generated transitions
+
+                // We remember the transitions found during the last BreakTime() and
+                // MakeTime() calls. If the next request is for the same transition we
+                // will avoid re-searching.
+                mutable std::atomic<std::size_t> local_time_hint_ = {};  // BreakTime() hint
+                mutable std::atomic<std::size_t> time_local_hint_ = {};  // MakeTime() hint
+            };
+
+        }  // namespace cctz
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_libc.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_libc.h
index 1da9039..9781180 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_libc.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_libc.h
@@ -20,36 +20,39 @@
 #include "absl/base/config.h"
 #include "time_zone_if.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-// A time zone backed by gmtime_r(3), localtime_r(3), and mktime(3),
-// and which therefore only supports UTC and the local time zone.
-// TODO: Add support for fixed offsets from UTC.
-class TimeZoneLibC : public TimeZoneIf {
- public:
-  explicit TimeZoneLibC(const std::string& name);
-
-  // TimeZoneIf implementations.
-  time_zone::absolute_lookup BreakTime(
-      const time_point<seconds>& tp) const override;
-  time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
-  bool NextTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const override;
-  bool PrevTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const override;
-  std::string Version() const override;
-  std::string Description() const override;
-
- private:
-  const bool local_;  // localtime or UTC
-};
-
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
+
+            // A time zone backed by gmtime_r(3), localtime_r(3), and mktime(3),
+            // and which therefore only supports UTC and the local time zone.
+            // TODO: Add support for fixed offsets from UTC.
+            class TimeZoneLibC : public TimeZoneIf
+            {
+            public:
+                explicit TimeZoneLibC(const std::string& name);
+
+                // TimeZoneIf implementations.
+                time_zone::absolute_lookup BreakTime(
+                    const time_point<seconds>& tp
+                ) const override;
+                time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
+                bool NextTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const override;
+                bool PrevTransition(const time_point<seconds>& tp, time_zone::civil_transition* trans) const override;
+                std::string Version() const override;
+                std::string Description() const override;
+
+            private:
+                const bool local_;  // localtime or UTC
+            };
+
+        }  // namespace cctz
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_posix.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_posix.h
index 0cf2905..5a1f25e 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_posix.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/time_zone_posix.h
@@ -57,76 +57,92 @@
 
 #include "absl/base/config.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-// The date/time of the transition. The date is specified as either:
-// (J) the Nth day of the year (1 <= N <= 365), excluding leap days, or
-// (N) the Nth day of the year (0 <= N <= 365), including leap days, or
-// (M) the Nth weekday of a month (e.g., the 2nd Sunday in March).
-// The time, specified as a day offset, identifies the particular moment
-// of the transition, and may be negative or >= 24h, and in which case
-// it would take us to another day, and perhaps week, or even month.
-struct PosixTransition {
-  enum DateFormat { J, N, M };
-
-  struct Date {
-    struct NonLeapDay {
-      std::int_fast16_t day;  // day of non-leap year [1:365]
-    };
-    struct Day {
-      std::int_fast16_t day;  // day of year [0:365]
-    };
-    struct MonthWeekWeekday {
-      std::int_fast8_t month;    // month of year [1:12]
-      std::int_fast8_t week;     // week of month [1:5] (5==last)
-      std::int_fast8_t weekday;  // 0==Sun, ..., 6=Sat
-    };
-
-    DateFormat fmt;
-
-    union {
-      NonLeapDay j;
-      Day n;
-      MonthWeekWeekday m;
-    };
-  };
-
-  struct Time {
-    std::int_fast32_t offset;  // seconds before/after 00:00:00
-  };
-
-  Date date;
-  Time time;
-};
-
-// The entirety of a POSIX-string specified time-zone rule. The standard
-// abbreviation and offset are always given. If the time zone includes
-// daylight saving, then the daylight abbrevation is non-empty and the
-// remaining fields are also valid. Note that the start/end transitions
-// are not ordered---in the southern hemisphere the transition to end
-// daylight time occurs first in any particular year.
-struct PosixTimeZone {
-  std::string std_abbr;
-  std::int_fast32_t std_offset;
-
-  std::string dst_abbr;
-  std::int_fast32_t dst_offset;
-  PosixTransition dst_start;
-  PosixTransition dst_end;
-};
-
-// Breaks down a POSIX time-zone specification into its constituent pieces,
-// filling in any missing values (DST offset, or start/end transition times)
-// with the standard-defined defaults. Returns false if the specification
-// could not be parsed (although some fields of *res may have been altered).
-bool ParsePosixSpec(const std::string& spec, PosixTimeZone* res);
-
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
+        namespace cctz
+        {
+
+            // The date/time of the transition. The date is specified as either:
+            // (J) the Nth day of the year (1 <= N <= 365), excluding leap days, or
+            // (N) the Nth day of the year (0 <= N <= 365), including leap days, or
+            // (M) the Nth weekday of a month (e.g., the 2nd Sunday in March).
+            // The time, specified as a day offset, identifies the particular moment
+            // of the transition, and may be negative or >= 24h, and in which case
+            // it would take us to another day, and perhaps week, or even month.
+            struct PosixTransition
+            {
+                enum DateFormat
+                {
+                    J,
+                    N,
+                    M
+                };
+
+                struct Date
+                {
+                    struct NonLeapDay
+                    {
+                        std::int_fast16_t day;  // day of non-leap year [1:365]
+                    };
+                    struct Day
+                    {
+                        std::int_fast16_t day;  // day of year [0:365]
+                    };
+                    struct MonthWeekWeekday
+                    {
+                        std::int_fast8_t month;    // month of year [1:12]
+                        std::int_fast8_t week;     // week of month [1:5] (5==last)
+                        std::int_fast8_t weekday;  // 0==Sun, ..., 6=Sat
+                    };
+
+                    DateFormat fmt;
+
+                    union
+                    {
+                        NonLeapDay j;
+                        Day n;
+                        MonthWeekWeekday m;
+                    };
+                };
+
+                struct Time
+                {
+                    std::int_fast32_t offset;  // seconds before/after 00:00:00
+                };
+
+                Date date;
+                Time time;
+            };
+
+            // The entirety of a POSIX-string specified time-zone rule. The standard
+            // abbreviation and offset are always given. If the time zone includes
+            // daylight saving, then the daylight abbrevation is non-empty and the
+            // remaining fields are also valid. Note that the start/end transitions
+            // are not ordered---in the southern hemisphere the transition to end
+            // daylight time occurs first in any particular year.
+            struct PosixTimeZone
+            {
+                std::string std_abbr;
+                std::int_fast32_t std_offset;
+
+                std::string dst_abbr;
+                std::int_fast32_t dst_offset;
+                PosixTransition dst_start;
+                PosixTransition dst_end;
+            };
+
+            // Breaks down a POSIX time-zone specification into its constituent pieces,
+            // filling in any missing values (DST offset, or start/end transition times)
+            // with the standard-defined defaults. Returns false if the specification
+            // could not be parsed (although some fields of *res may have been altered).
+            bool ParsePosixSpec(const std::string& spec, PosixTimeZone* res);
+
+        }  // namespace cctz
+    }      // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/tzfile.h b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/tzfile.h
index 31e8598..7390260 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/tzfile.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/cctz/src/tzfile.h
@@ -41,16 +41,17 @@
 
 #define TZ_MAGIC "TZif"
 
-struct tzhead {
-  char tzh_magic[4];      /* TZ_MAGIC */
-  char tzh_version[1];    /* '\0' or '2'-'4' as of 2021 */
-  char tzh_reserved[15];  /* reserved; must be zero */
-  char tzh_ttisutcnt[4];  /* coded number of trans. time flags */
-  char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */
-  char tzh_leapcnt[4];    /* coded number of leap seconds */
-  char tzh_timecnt[4];    /* coded number of transition times */
-  char tzh_typecnt[4];    /* coded number of local time types */
-  char tzh_charcnt[4];    /* coded number of abbr. chars */
+struct tzhead
+{
+    char tzh_magic[4];      /* TZ_MAGIC */
+    char tzh_version[1];    /* '\0' or '2'-'4' as of 2021 */
+    char tzh_reserved[15];  /* reserved; must be zero */
+    char tzh_ttisutcnt[4];  /* coded number of trans. time flags */
+    char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */
+    char tzh_leapcnt[4];    /* coded number of leap seconds */
+    char tzh_timecnt[4];    /* coded number of transition times */
+    char tzh_typecnt[4];    /* coded number of local time types */
+    char tzh_charcnt[4];    /* coded number of abbr. chars */
 };
 
 /*
diff --git a/CAPI/cpp/grpc/include/absl/time/internal/test_util.h b/CAPI/cpp/grpc/include/absl/time/internal/test_util.h
index 5c4bf1f..69891af 100644
--- a/CAPI/cpp/grpc/include/absl/time/internal/test_util.h
+++ b/CAPI/cpp/grpc/include/absl/time/internal/test_util.h
@@ -19,15 +19,17 @@
 
 #include "absl/time/time.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace time_internal
+    {
 
-// Loads the named timezone, but dies on any failure.
-absl::TimeZone LoadTimeZone(const std::string& name);
+        // Loads the named timezone, but dies on any failure.
+        absl::TimeZone LoadTimeZone(const std::string& name);
 
-}  // namespace time_internal
-ABSL_NAMESPACE_END
+    }  // namespace time_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_INTERNAL_TEST_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/absl/time/time.h b/CAPI/cpp/grpc/include/absl/time/time.h
index bd01867..b2277b5 100644
--- a/CAPI/cpp/grpc/include/absl/time/time.h
+++ b/CAPI/cpp/grpc/include/absl/time/time.h
@@ -88,1533 +88,1722 @@ struct timeval;
 #include "absl/time/civil_time.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class Duration;  // Defined below
-class Time;      // Defined below
-class TimeZone;  // Defined below
-
-namespace time_internal {
-int64_t IDivDuration(bool satq, Duration num, Duration den, Duration* rem);
-constexpr Time FromUnixDuration(Duration d);
-constexpr Duration ToUnixDuration(Time t);
-constexpr int64_t GetRepHi(Duration d);
-constexpr uint32_t GetRepLo(Duration d);
-constexpr Duration MakeDuration(int64_t hi, uint32_t lo);
-constexpr Duration MakeDuration(int64_t hi, int64_t lo);
-inline Duration MakePosDoubleDuration(double n);
-constexpr int64_t kTicksPerNanosecond = 4;
-constexpr int64_t kTicksPerSecond = 1000 * 1000 * 1000 * kTicksPerNanosecond;
-template <std::intmax_t N>
-constexpr Duration FromInt64(int64_t v, std::ratio<1, N>);
-constexpr Duration FromInt64(int64_t v, std::ratio<60>);
-constexpr Duration FromInt64(int64_t v, std::ratio<3600>);
-template <typename T>
-using EnableIfIntegral = typename std::enable_if<
-    std::is_integral<T>::value || std::is_enum<T>::value, int>::type;
-template <typename T>
-using EnableIfFloat =
-    typename std::enable_if<std::is_floating_point<T>::value, int>::type;
-}  // namespace time_internal
-
-// Duration
-//
-// The `absl::Duration` class represents a signed, fixed-length amount of time.
-// A `Duration` is generated using a unit-specific factory function, or is
-// the result of subtracting one `absl::Time` from another. Durations behave
-// like unit-safe integers and they support all the natural integer-like
-// arithmetic operations. Arithmetic overflows and saturates at +/- infinity.
-// `Duration` should be passed by value rather than const reference.
-//
-// Factory functions `Nanoseconds()`, `Microseconds()`, `Milliseconds()`,
-// `Seconds()`, `Minutes()`, `Hours()` and `InfiniteDuration()` allow for
-// creation of constexpr `Duration` values
-//
-// Examples:
-//
-//   constexpr absl::Duration ten_ns = absl::Nanoseconds(10);
-//   constexpr absl::Duration min = absl::Minutes(1);
-//   constexpr absl::Duration hour = absl::Hours(1);
-//   absl::Duration dur = 60 * min;  // dur == hour
-//   absl::Duration half_sec = absl::Milliseconds(500);
-//   absl::Duration quarter_sec = 0.25 * absl::Seconds(1);
-//
-// `Duration` values can be easily converted to an integral number of units
-// using the division operator.
-//
-// Example:
-//
-//   constexpr absl::Duration dur = absl::Milliseconds(1500);
-//   int64_t ns = dur / absl::Nanoseconds(1);   // ns == 1500000000
-//   int64_t ms = dur / absl::Milliseconds(1);  // ms == 1500
-//   int64_t sec = dur / absl::Seconds(1);    // sec == 1 (subseconds truncated)
-//   int64_t min = dur / absl::Minutes(1);    // min == 0
-//
-// See the `IDivDuration()` and `FDivDuration()` functions below for details on
-// how to access the fractional parts of the quotient.
-//
-// Alternatively, conversions can be performed using helpers such as
-// `ToInt64Microseconds()` and `ToDoubleSeconds()`.
-class Duration {
- public:
-  // Value semantics.
-  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
-
-  // Copyable.
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class Duration;  // Defined below
+    class Time;      // Defined below
+    class TimeZone;  // Defined below
+
+    namespace time_internal
+    {
+        int64_t IDivDuration(bool satq, Duration num, Duration den, Duration* rem);
+        constexpr Time FromUnixDuration(Duration d);
+        constexpr Duration ToUnixDuration(Time t);
+        constexpr int64_t GetRepHi(Duration d);
+        constexpr uint32_t GetRepLo(Duration d);
+        constexpr Duration MakeDuration(int64_t hi, uint32_t lo);
+        constexpr Duration MakeDuration(int64_t hi, int64_t lo);
+        inline Duration MakePosDoubleDuration(double n);
+        constexpr int64_t kTicksPerNanosecond = 4;
+        constexpr int64_t kTicksPerSecond = 1000 * 1000 * 1000 * kTicksPerNanosecond;
+        template<std::intmax_t N>
+        constexpr Duration FromInt64(int64_t v, std::ratio<1, N>);
+        constexpr Duration FromInt64(int64_t v, std::ratio<60>);
+        constexpr Duration FromInt64(int64_t v, std::ratio<3600>);
+        template<typename T>
+        using EnableIfIntegral = typename std::enable_if<
+            std::is_integral<T>::value || std::is_enum<T>::value,
+            int>::type;
+        template<typename T>
+        using EnableIfFloat =
+            typename std::enable_if<std::is_floating_point<T>::value, int>::type;
+    }  // namespace time_internal
+
+    // Duration
+    //
+    // The `absl::Duration` class represents a signed, fixed-length amount of time.
+    // A `Duration` is generated using a unit-specific factory function, or is
+    // the result of subtracting one `absl::Time` from another. Durations behave
+    // like unit-safe integers and they support all the natural integer-like
+    // arithmetic operations. Arithmetic overflows and saturates at +/- infinity.
+    // `Duration` should be passed by value rather than const reference.
+    //
+    // Factory functions `Nanoseconds()`, `Microseconds()`, `Milliseconds()`,
+    // `Seconds()`, `Minutes()`, `Hours()` and `InfiniteDuration()` allow for
+    // creation of constexpr `Duration` values
+    //
+    // Examples:
+    //
+    //   constexpr absl::Duration ten_ns = absl::Nanoseconds(10);
+    //   constexpr absl::Duration min = absl::Minutes(1);
+    //   constexpr absl::Duration hour = absl::Hours(1);
+    //   absl::Duration dur = 60 * min;  // dur == hour
+    //   absl::Duration half_sec = absl::Milliseconds(500);
+    //   absl::Duration quarter_sec = 0.25 * absl::Seconds(1);
+    //
+    // `Duration` values can be easily converted to an integral number of units
+    // using the division operator.
+    //
+    // Example:
+    //
+    //   constexpr absl::Duration dur = absl::Milliseconds(1500);
+    //   int64_t ns = dur / absl::Nanoseconds(1);   // ns == 1500000000
+    //   int64_t ms = dur / absl::Milliseconds(1);  // ms == 1500
+    //   int64_t sec = dur / absl::Seconds(1);    // sec == 1 (subseconds truncated)
+    //   int64_t min = dur / absl::Minutes(1);    // min == 0
+    //
+    // See the `IDivDuration()` and `FDivDuration()` functions below for details on
+    // how to access the fractional parts of the quotient.
+    //
+    // Alternatively, conversions can be performed using helpers such as
+    // `ToInt64Microseconds()` and `ToDoubleSeconds()`.
+    class Duration
+    {
+    public:
+        // Value semantics.
+        constexpr Duration() :
+            rep_hi_(0),
+            rep_lo_(0)
+        {
+        }  // zero-length duration
+
+        // Copyable.
 #if !defined(__clang__) && defined(_MSC_VER) && _MSC_VER < 1930
-  // Explicitly defining the constexpr copy constructor avoids an MSVC bug.
-  constexpr Duration(const Duration& d)
-      : rep_hi_(d.rep_hi_), rep_lo_(d.rep_lo_) {}
+        // Explicitly defining the constexpr copy constructor avoids an MSVC bug.
+        constexpr Duration(const Duration& d) :
+            rep_hi_(d.rep_hi_),
+            rep_lo_(d.rep_lo_)
+        {
+        }
 #else
-  constexpr Duration(const Duration& d) = default;
+        constexpr Duration(const Duration& d) = default;
 #endif
-  Duration& operator=(const Duration& d) = default;
-
-  // Compound assignment operators.
-  Duration& operator+=(Duration d);
-  Duration& operator-=(Duration d);
-  Duration& operator*=(int64_t r);
-  Duration& operator*=(double r);
-  Duration& operator/=(int64_t r);
-  Duration& operator/=(double r);
-  Duration& operator%=(Duration rhs);
-
-  // Overloads that forward to either the int64_t or double overloads above.
-  // Integer operands must be representable as int64_t.
-  template <typename T, time_internal::EnableIfIntegral<T> = 0>
-  Duration& operator*=(T r) {
-    int64_t x = r;
-    return *this *= x;
-  }
-
-  template <typename T, time_internal::EnableIfIntegral<T> = 0>
-  Duration& operator/=(T r) {
-    int64_t x = r;
-    return *this /= x;
-  }
-
-  template <typename T, time_internal::EnableIfFloat<T> = 0>
-  Duration& operator*=(T r) {
-    double x = r;
-    return *this *= x;
-  }
-
-  template <typename T, time_internal::EnableIfFloat<T> = 0>
-  Duration& operator/=(T r) {
-    double x = r;
-    return *this /= x;
-  }
-
-  template <typename H>
-  friend H AbslHashValue(H h, Duration d) {
-    return H::combine(std::move(h), d.rep_hi_, d.rep_lo_);
-  }
-
- private:
-  friend constexpr int64_t time_internal::GetRepHi(Duration d);
-  friend constexpr uint32_t time_internal::GetRepLo(Duration d);
-  friend constexpr Duration time_internal::MakeDuration(int64_t hi,
-                                                        uint32_t lo);
-  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
-  int64_t rep_hi_;
-  uint32_t rep_lo_;
-};
-
-// Relational Operators
-constexpr bool operator<(Duration lhs, Duration rhs);
-constexpr bool operator>(Duration lhs, Duration rhs) { return rhs < lhs; }
-constexpr bool operator>=(Duration lhs, Duration rhs) { return !(lhs < rhs); }
-constexpr bool operator<=(Duration lhs, Duration rhs) { return !(rhs < lhs); }
-constexpr bool operator==(Duration lhs, Duration rhs);
-constexpr bool operator!=(Duration lhs, Duration rhs) { return !(lhs == rhs); }
-
-// Additive Operators
-constexpr Duration operator-(Duration d);
-inline Duration operator+(Duration lhs, Duration rhs) { return lhs += rhs; }
-inline Duration operator-(Duration lhs, Duration rhs) { return lhs -= rhs; }
-
-// Multiplicative Operators
-// Integer operands must be representable as int64_t.
-template <typename T>
-Duration operator*(Duration lhs, T rhs) {
-  return lhs *= rhs;
-}
-template <typename T>
-Duration operator*(T lhs, Duration rhs) {
-  return rhs *= lhs;
-}
-template <typename T>
-Duration operator/(Duration lhs, T rhs) {
-  return lhs /= rhs;
-}
-inline int64_t operator/(Duration lhs, Duration rhs) {
-  return time_internal::IDivDuration(true, lhs, rhs,
-                                     &lhs);  // trunc towards zero
-}
-inline Duration operator%(Duration lhs, Duration rhs) { return lhs %= rhs; }
-
-// IDivDuration()
-//
-// Divides a numerator `Duration` by a denominator `Duration`, returning the
-// quotient and remainder. The remainder always has the same sign as the
-// numerator. The returned quotient and remainder respect the identity:
-//
-//   numerator = denominator * quotient + remainder
-//
-// Returned quotients are capped to the range of `int64_t`, with the difference
-// spilling into the remainder to uphold the above identity. This means that the
-// remainder returned could differ from the remainder returned by
-// `Duration::operator%` for huge quotients.
-//
-// See also the notes on `InfiniteDuration()` below regarding the behavior of
-// division involving zero and infinite durations.
-//
-// Example:
-//
-//   constexpr absl::Duration a =
-//       absl::Seconds(std::numeric_limits<int64_t>::max());  // big
-//   constexpr absl::Duration b = absl::Nanoseconds(1);       // small
-//
-//   absl::Duration rem = a % b;
-//   // rem == absl::ZeroDuration()
-//
-//   // Here, q would overflow int64_t, so rem accounts for the difference.
-//   int64_t q = absl::IDivDuration(a, b, &rem);
-//   // q == std::numeric_limits<int64_t>::max(), rem == a - b * q
-inline int64_t IDivDuration(Duration num, Duration den, Duration* rem) {
-  return time_internal::IDivDuration(true, num, den,
-                                     rem);  // trunc towards zero
-}
-
-// FDivDuration()
-//
-// Divides a `Duration` numerator into a fractional number of units of a
-// `Duration` denominator.
-//
-// See also the notes on `InfiniteDuration()` below regarding the behavior of
-// division involving zero and infinite durations.
-//
-// Example:
-//
-//   double d = absl::FDivDuration(absl::Milliseconds(1500), absl::Seconds(1));
-//   // d == 1.5
-double FDivDuration(Duration num, Duration den);
+        Duration& operator=(const Duration& d) = default;
+
+        // Compound assignment operators.
+        Duration& operator+=(Duration d);
+        Duration& operator-=(Duration d);
+        Duration& operator*=(int64_t r);
+        Duration& operator*=(double r);
+        Duration& operator/=(int64_t r);
+        Duration& operator/=(double r);
+        Duration& operator%=(Duration rhs);
+
+        // Overloads that forward to either the int64_t or double overloads above.
+        // Integer operands must be representable as int64_t.
+        template<typename T, time_internal::EnableIfIntegral<T> = 0>
+        Duration& operator*=(T r)
+        {
+            int64_t x = r;
+            return *this *= x;
+        }
+
+        template<typename T, time_internal::EnableIfIntegral<T> = 0>
+        Duration& operator/=(T r)
+        {
+            int64_t x = r;
+            return *this /= x;
+        }
+
+        template<typename T, time_internal::EnableIfFloat<T> = 0>
+        Duration& operator*=(T r)
+        {
+            double x = r;
+            return *this *= x;
+        }
+
+        template<typename T, time_internal::EnableIfFloat<T> = 0>
+        Duration& operator/=(T r)
+        {
+            double x = r;
+            return *this /= x;
+        }
+
+        template<typename H>
+        friend H AbslHashValue(H h, Duration d)
+        {
+            return H::combine(std::move(h), d.rep_hi_, d.rep_lo_);
+        }
+
+    private:
+        friend constexpr int64_t time_internal::GetRepHi(Duration d);
+        friend constexpr uint32_t time_internal::GetRepLo(Duration d);
+        friend constexpr Duration time_internal::MakeDuration(int64_t hi, uint32_t lo);
+        constexpr Duration(int64_t hi, uint32_t lo) :
+            rep_hi_(hi),
+            rep_lo_(lo)
+        {
+        }
+        int64_t rep_hi_;
+        uint32_t rep_lo_;
+    };
+
+    // Relational Operators
+    constexpr bool operator<(Duration lhs, Duration rhs);
+    constexpr bool operator>(Duration lhs, Duration rhs)
+    {
+        return rhs < lhs;
+    }
+    constexpr bool operator>=(Duration lhs, Duration rhs)
+    {
+        return !(lhs < rhs);
+    }
+    constexpr bool operator<=(Duration lhs, Duration rhs)
+    {
+        return !(rhs < lhs);
+    }
+    constexpr bool operator==(Duration lhs, Duration rhs);
+    constexpr bool operator!=(Duration lhs, Duration rhs)
+    {
+        return !(lhs == rhs);
+    }
 
-// ZeroDuration()
-//
-// Returns a zero-length duration. This function behaves just like the default
-// constructor, but the name helps make the semantics clear at call sites.
-constexpr Duration ZeroDuration() { return Duration(); }
+    // Additive Operators
+    constexpr Duration operator-(Duration d);
+    inline Duration operator+(Duration lhs, Duration rhs)
+    {
+        return lhs += rhs;
+    }
+    inline Duration operator-(Duration lhs, Duration rhs)
+    {
+        return lhs -= rhs;
+    }
 
-// AbsDuration()
-//
-// Returns the absolute value of a duration.
-inline Duration AbsDuration(Duration d) {
-  return (d < ZeroDuration()) ? -d : d;
-}
+    // Multiplicative Operators
+    // Integer operands must be representable as int64_t.
+    template<typename T>
+    Duration operator*(Duration lhs, T rhs)
+    {
+        return lhs *= rhs;
+    }
+    template<typename T>
+    Duration operator*(T lhs, Duration rhs)
+    {
+        return rhs *= lhs;
+    }
+    template<typename T>
+    Duration operator/(Duration lhs, T rhs)
+    {
+        return lhs /= rhs;
+    }
+    inline int64_t operator/(Duration lhs, Duration rhs)
+    {
+        return time_internal::IDivDuration(true, lhs, rhs,
+                                           &lhs);  // trunc towards zero
+    }
+    inline Duration operator%(Duration lhs, Duration rhs)
+    {
+        return lhs %= rhs;
+    }
 
-// Trunc()
-//
-// Truncates a duration (toward zero) to a multiple of a non-zero unit.
-//
-// Example:
-//
-//   absl::Duration d = absl::Nanoseconds(123456789);
-//   absl::Duration a = absl::Trunc(d, absl::Microseconds(1));  // 123456us
-Duration Trunc(Duration d, Duration unit);
+    // IDivDuration()
+    //
+    // Divides a numerator `Duration` by a denominator `Duration`, returning the
+    // quotient and remainder. The remainder always has the same sign as the
+    // numerator. The returned quotient and remainder respect the identity:
+    //
+    //   numerator = denominator * quotient + remainder
+    //
+    // Returned quotients are capped to the range of `int64_t`, with the difference
+    // spilling into the remainder to uphold the above identity. This means that the
+    // remainder returned could differ from the remainder returned by
+    // `Duration::operator%` for huge quotients.
+    //
+    // See also the notes on `InfiniteDuration()` below regarding the behavior of
+    // division involving zero and infinite durations.
+    //
+    // Example:
+    //
+    //   constexpr absl::Duration a =
+    //       absl::Seconds(std::numeric_limits<int64_t>::max());  // big
+    //   constexpr absl::Duration b = absl::Nanoseconds(1);       // small
+    //
+    //   absl::Duration rem = a % b;
+    //   // rem == absl::ZeroDuration()
+    //
+    //   // Here, q would overflow int64_t, so rem accounts for the difference.
+    //   int64_t q = absl::IDivDuration(a, b, &rem);
+    //   // q == std::numeric_limits<int64_t>::max(), rem == a - b * q
+    inline int64_t IDivDuration(Duration num, Duration den, Duration* rem)
+    {
+        return time_internal::IDivDuration(true, num, den,
+                                           rem);  // trunc towards zero
+    }
 
-// Floor()
-//
-// Floors a duration using the passed duration unit to its largest value not
-// greater than the duration.
-//
-// Example:
-//
-//   absl::Duration d = absl::Nanoseconds(123456789);
-//   absl::Duration b = absl::Floor(d, absl::Microseconds(1));  // 123456us
-Duration Floor(Duration d, Duration unit);
+    // FDivDuration()
+    //
+    // Divides a `Duration` numerator into a fractional number of units of a
+    // `Duration` denominator.
+    //
+    // See also the notes on `InfiniteDuration()` below regarding the behavior of
+    // division involving zero and infinite durations.
+    //
+    // Example:
+    //
+    //   double d = absl::FDivDuration(absl::Milliseconds(1500), absl::Seconds(1));
+    //   // d == 1.5
+    double FDivDuration(Duration num, Duration den);
+
+    // ZeroDuration()
+    //
+    // Returns a zero-length duration. This function behaves just like the default
+    // constructor, but the name helps make the semantics clear at call sites.
+    constexpr Duration ZeroDuration()
+    {
+        return Duration();
+    }
 
-// Ceil()
-//
-// Returns the ceiling of a duration using the passed duration unit to its
-// smallest value not less than the duration.
-//
-// Example:
-//
-//   absl::Duration d = absl::Nanoseconds(123456789);
-//   absl::Duration c = absl::Ceil(d, absl::Microseconds(1));   // 123457us
-Duration Ceil(Duration d, Duration unit);
+    // AbsDuration()
+    //
+    // Returns the absolute value of a duration.
+    inline Duration AbsDuration(Duration d)
+    {
+        return (d < ZeroDuration()) ? -d : d;
+    }
 
-// InfiniteDuration()
-//
-// Returns an infinite `Duration`.  To get a `Duration` representing negative
-// infinity, use `-InfiniteDuration()`.
-//
-// Duration arithmetic overflows to +/- infinity and saturates. In general,
-// arithmetic with `Duration` infinities is similar to IEEE 754 infinities
-// except where IEEE 754 NaN would be involved, in which case +/-
-// `InfiniteDuration()` is used in place of a "nan" Duration.
-//
-// Examples:
-//
-//   constexpr absl::Duration inf = absl::InfiniteDuration();
-//   const absl::Duration d = ... any finite duration ...
-//
-//   inf == inf + inf
-//   inf == inf + d
-//   inf == inf - inf
-//   -inf == d - inf
-//
-//   inf == d * 1e100
-//   inf == inf / 2
-//   0 == d / inf
-//   INT64_MAX == inf / d
-//
-//   d < inf
-//   -inf < d
-//
-//   // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
-//   inf == d / 0
-//   INT64_MAX == d / absl::ZeroDuration()
-//
-// The examples involving the `/` operator above also apply to `IDivDuration()`
-// and `FDivDuration()`.
-constexpr Duration InfiniteDuration();
-
-// Nanoseconds()
-// Microseconds()
-// Milliseconds()
-// Seconds()
-// Minutes()
-// Hours()
-//
-// Factory functions for constructing `Duration` values from an integral number
-// of the unit indicated by the factory function's name. The number must be
-// representable as int64_t.
-//
-// NOTE: no "Days()" factory function exists because "a day" is ambiguous.
-// Civil days are not always 24 hours long, and a 24-hour duration often does
-// not correspond with a civil day. If a 24-hour duration is needed, use
-// `absl::Hours(24)`. If you actually want a civil day, use absl::CivilDay
-// from civil_time.h.
-//
-// Example:
-//
-//   absl::Duration a = absl::Seconds(60);
-//   absl::Duration b = absl::Minutes(1);  // b == a
-template <typename T, time_internal::EnableIfIntegral<T> = 0>
-constexpr Duration Nanoseconds(T n) {
-  return time_internal::FromInt64(n, std::nano{});
-}
-template <typename T, time_internal::EnableIfIntegral<T> = 0>
-constexpr Duration Microseconds(T n) {
-  return time_internal::FromInt64(n, std::micro{});
-}
-template <typename T, time_internal::EnableIfIntegral<T> = 0>
-constexpr Duration Milliseconds(T n) {
-  return time_internal::FromInt64(n, std::milli{});
-}
-template <typename T, time_internal::EnableIfIntegral<T> = 0>
-constexpr Duration Seconds(T n) {
-  return time_internal::FromInt64(n, std::ratio<1>{});
-}
-template <typename T, time_internal::EnableIfIntegral<T> = 0>
-constexpr Duration Minutes(T n) {
-  return time_internal::FromInt64(n, std::ratio<60>{});
-}
-template <typename T, time_internal::EnableIfIntegral<T> = 0>
-constexpr Duration Hours(T n) {
-  return time_internal::FromInt64(n, std::ratio<3600>{});
-}
-
-// Factory overloads for constructing `Duration` values from a floating-point
-// number of the unit indicated by the factory function's name. These functions
-// exist for convenience, but they are not as efficient as the integral
-// factories, which should be preferred.
-//
-// Example:
-//
-//   auto a = absl::Seconds(1.5);        // OK
-//   auto b = absl::Milliseconds(1500);  // BETTER
-template <typename T, time_internal::EnableIfFloat<T> = 0>
-Duration Nanoseconds(T n) {
-  return n * Nanoseconds(1);
-}
-template <typename T, time_internal::EnableIfFloat<T> = 0>
-Duration Microseconds(T n) {
-  return n * Microseconds(1);
-}
-template <typename T, time_internal::EnableIfFloat<T> = 0>
-Duration Milliseconds(T n) {
-  return n * Milliseconds(1);
-}
-template <typename T, time_internal::EnableIfFloat<T> = 0>
-Duration Seconds(T n) {
-  if (n >= 0) {  // Note: `NaN >= 0` is false.
-    if (n >= static_cast<T>((std::numeric_limits<int64_t>::max)())) {
-      return InfiniteDuration();
-    }
-    return time_internal::MakePosDoubleDuration(n);
-  } else {
-    if (std::isnan(n))
-      return std::signbit(n) ? -InfiniteDuration() : InfiniteDuration();
-    if (n <= (std::numeric_limits<int64_t>::min)()) return -InfiniteDuration();
-    return -time_internal::MakePosDoubleDuration(-n);
-  }
-}
-template <typename T, time_internal::EnableIfFloat<T> = 0>
-Duration Minutes(T n) {
-  return n * Minutes(1);
-}
-template <typename T, time_internal::EnableIfFloat<T> = 0>
-Duration Hours(T n) {
-  return n * Hours(1);
-}
-
-// ToInt64Nanoseconds()
-// ToInt64Microseconds()
-// ToInt64Milliseconds()
-// ToInt64Seconds()
-// ToInt64Minutes()
-// ToInt64Hours()
-//
-// Helper functions that convert a Duration to an integral count of the
-// indicated unit. These return the same results as the `IDivDuration()`
-// function, though they usually do so more efficiently; see the
-// documentation of `IDivDuration()` for details about overflow, etc.
-//
-// Example:
-//
-//   absl::Duration d = absl::Milliseconds(1500);
-//   int64_t isec = absl::ToInt64Seconds(d);  // isec == 1
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Seconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Minutes(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
-
-// ToDoubleNanoSeconds()
-// ToDoubleMicroseconds()
-// ToDoubleMilliseconds()
-// ToDoubleSeconds()
-// ToDoubleMinutes()
-// ToDoubleHours()
-//
-// Helper functions that convert a Duration to a floating point count of the
-// indicated unit. These functions are shorthand for the `FDivDuration()`
-// function above; see its documentation for details about overflow, etc.
-//
-// Example:
-//
-//   absl::Duration d = absl::Milliseconds(1500);
-//   double dsec = absl::ToDoubleSeconds(d);  // dsec == 1.5
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleSeconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMinutes(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d);
-
-// FromChrono()
-//
-// Converts any of the pre-defined std::chrono durations to an absl::Duration.
-//
-// Example:
-//
-//   std::chrono::milliseconds ms(123);
-//   absl::Duration d = absl::FromChrono(ms);
-constexpr Duration FromChrono(const std::chrono::nanoseconds& d);
-constexpr Duration FromChrono(const std::chrono::microseconds& d);
-constexpr Duration FromChrono(const std::chrono::milliseconds& d);
-constexpr Duration FromChrono(const std::chrono::seconds& d);
-constexpr Duration FromChrono(const std::chrono::minutes& d);
-constexpr Duration FromChrono(const std::chrono::hours& d);
-
-// ToChronoNanoseconds()
-// ToChronoMicroseconds()
-// ToChronoMilliseconds()
-// ToChronoSeconds()
-// ToChronoMinutes()
-// ToChronoHours()
-//
-// Converts an absl::Duration to any of the pre-defined std::chrono durations.
-// If overflow would occur, the returned value will saturate at the min/max
-// chrono duration value instead.
-//
-// Example:
-//
-//   absl::Duration d = absl::Microseconds(123);
-//   auto x = absl::ToChronoMicroseconds(d);
-//   auto y = absl::ToChronoNanoseconds(d);  // x == y
-//   auto z = absl::ToChronoSeconds(absl::InfiniteDuration());
-//   // z == std::chrono::seconds::max()
-std::chrono::nanoseconds ToChronoNanoseconds(Duration d);
-std::chrono::microseconds ToChronoMicroseconds(Duration d);
-std::chrono::milliseconds ToChronoMilliseconds(Duration d);
-std::chrono::seconds ToChronoSeconds(Duration d);
-std::chrono::minutes ToChronoMinutes(Duration d);
-std::chrono::hours ToChronoHours(Duration d);
-
-// FormatDuration()
-//
-// Returns a string representing the duration in the form "72h3m0.5s".
-// Returns "inf" or "-inf" for +/- `InfiniteDuration()`.
-std::string FormatDuration(Duration d);
+    // Trunc()
+    //
+    // Truncates a duration (toward zero) to a multiple of a non-zero unit.
+    //
+    // Example:
+    //
+    //   absl::Duration d = absl::Nanoseconds(123456789);
+    //   absl::Duration a = absl::Trunc(d, absl::Microseconds(1));  // 123456us
+    Duration Trunc(Duration d, Duration unit);
+
+    // Floor()
+    //
+    // Floors a duration using the passed duration unit to its largest value not
+    // greater than the duration.
+    //
+    // Example:
+    //
+    //   absl::Duration d = absl::Nanoseconds(123456789);
+    //   absl::Duration b = absl::Floor(d, absl::Microseconds(1));  // 123456us
+    Duration Floor(Duration d, Duration unit);
+
+    // Ceil()
+    //
+    // Returns the ceiling of a duration using the passed duration unit to its
+    // smallest value not less than the duration.
+    //
+    // Example:
+    //
+    //   absl::Duration d = absl::Nanoseconds(123456789);
+    //   absl::Duration c = absl::Ceil(d, absl::Microseconds(1));   // 123457us
+    Duration Ceil(Duration d, Duration unit);
+
+    // InfiniteDuration()
+    //
+    // Returns an infinite `Duration`.  To get a `Duration` representing negative
+    // infinity, use `-InfiniteDuration()`.
+    //
+    // Duration arithmetic overflows to +/- infinity and saturates. In general,
+    // arithmetic with `Duration` infinities is similar to IEEE 754 infinities
+    // except where IEEE 754 NaN would be involved, in which case +/-
+    // `InfiniteDuration()` is used in place of a "nan" Duration.
+    //
+    // Examples:
+    //
+    //   constexpr absl::Duration inf = absl::InfiniteDuration();
+    //   const absl::Duration d = ... any finite duration ...
+    //
+    //   inf == inf + inf
+    //   inf == inf + d
+    //   inf == inf - inf
+    //   -inf == d - inf
+    //
+    //   inf == d * 1e100
+    //   inf == inf / 2
+    //   0 == d / inf
+    //   INT64_MAX == inf / d
+    //
+    //   d < inf
+    //   -inf < d
+    //
+    //   // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
+    //   inf == d / 0
+    //   INT64_MAX == d / absl::ZeroDuration()
+    //
+    // The examples involving the `/` operator above also apply to `IDivDuration()`
+    // and `FDivDuration()`.
+    constexpr Duration InfiniteDuration();
+
+    // Nanoseconds()
+    // Microseconds()
+    // Milliseconds()
+    // Seconds()
+    // Minutes()
+    // Hours()
+    //
+    // Factory functions for constructing `Duration` values from an integral number
+    // of the unit indicated by the factory function's name. The number must be
+    // representable as int64_t.
+    //
+    // NOTE: no "Days()" factory function exists because "a day" is ambiguous.
+    // Civil days are not always 24 hours long, and a 24-hour duration often does
+    // not correspond with a civil day. If a 24-hour duration is needed, use
+    // `absl::Hours(24)`. If you actually want a civil day, use absl::CivilDay
+    // from civil_time.h.
+    //
+    // Example:
+    //
+    //   absl::Duration a = absl::Seconds(60);
+    //   absl::Duration b = absl::Minutes(1);  // b == a
+    template<typename T, time_internal::EnableIfIntegral<T> = 0>
+    constexpr Duration Nanoseconds(T n)
+    {
+        return time_internal::FromInt64(n, std::nano{});
+    }
+    template<typename T, time_internal::EnableIfIntegral<T> = 0>
+    constexpr Duration Microseconds(T n)
+    {
+        return time_internal::FromInt64(n, std::micro{});
+    }
+    template<typename T, time_internal::EnableIfIntegral<T> = 0>
+    constexpr Duration Milliseconds(T n)
+    {
+        return time_internal::FromInt64(n, std::milli{});
+    }
+    template<typename T, time_internal::EnableIfIntegral<T> = 0>
+    constexpr Duration Seconds(T n)
+    {
+        return time_internal::FromInt64(n, std::ratio<1>{});
+    }
+    template<typename T, time_internal::EnableIfIntegral<T> = 0>
+    constexpr Duration Minutes(T n)
+    {
+        return time_internal::FromInt64(n, std::ratio<60>{});
+    }
+    template<typename T, time_internal::EnableIfIntegral<T> = 0>
+    constexpr Duration Hours(T n)
+    {
+        return time_internal::FromInt64(n, std::ratio<3600>{});
+    }
 
-// Output stream operator.
-inline std::ostream& operator<<(std::ostream& os, Duration d) {
-  return os << FormatDuration(d);
-}
+    // Factory overloads for constructing `Duration` values from a floating-point
+    // number of the unit indicated by the factory function's name. These functions
+    // exist for convenience, but they are not as efficient as the integral
+    // factories, which should be preferred.
+    //
+    // Example:
+    //
+    //   auto a = absl::Seconds(1.5);        // OK
+    //   auto b = absl::Milliseconds(1500);  // BETTER
+    template<typename T, time_internal::EnableIfFloat<T> = 0>
+    Duration Nanoseconds(T n)
+    {
+        return n * Nanoseconds(1);
+    }
+    template<typename T, time_internal::EnableIfFloat<T> = 0>
+    Duration Microseconds(T n)
+    {
+        return n * Microseconds(1);
+    }
+    template<typename T, time_internal::EnableIfFloat<T> = 0>
+    Duration Milliseconds(T n)
+    {
+        return n * Milliseconds(1);
+    }
+    template<typename T, time_internal::EnableIfFloat<T> = 0>
+    Duration Seconds(T n)
+    {
+        if (n >= 0)
+        {  // Note: `NaN >= 0` is false.
+            if (n >= static_cast<T>((std::numeric_limits<int64_t>::max)()))
+            {
+                return InfiniteDuration();
+            }
+            return time_internal::MakePosDoubleDuration(n);
+        }
+        else
+        {
+            if (std::isnan(n))
+                return std::signbit(n) ? -InfiniteDuration() : InfiniteDuration();
+            if (n <= (std::numeric_limits<int64_t>::min)())
+                return -InfiniteDuration();
+            return -time_internal::MakePosDoubleDuration(-n);
+        }
+    }
+    template<typename T, time_internal::EnableIfFloat<T> = 0>
+    Duration Minutes(T n)
+    {
+        return n * Minutes(1);
+    }
+    template<typename T, time_internal::EnableIfFloat<T> = 0>
+    Duration Hours(T n)
+    {
+        return n * Hours(1);
+    }
 
-// ParseDuration()
-//
-// Parses a duration string consisting of a possibly signed sequence of
-// decimal numbers, each with an optional fractional part and a unit
-// suffix.  The valid suffixes are "ns", "us" "ms", "s", "m", and "h".
-// Simple examples include "300ms", "-1.5h", and "2h45m".  Parses "0" as
-// `ZeroDuration()`. Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
-bool ParseDuration(absl::string_view dur_string, Duration* d);
-
-// AbslParseFlag()
-//
-// Parses a command-line flag string representation `text` into a Duration
-// value. Duration flags must be specified in a format that is valid input for
-// `absl::ParseDuration()`.
-bool AbslParseFlag(absl::string_view text, Duration* dst, std::string* error);
+    // ToInt64Nanoseconds()
+    // ToInt64Microseconds()
+    // ToInt64Milliseconds()
+    // ToInt64Seconds()
+    // ToInt64Minutes()
+    // ToInt64Hours()
+    //
+    // Helper functions that convert a Duration to an integral count of the
+    // indicated unit. These return the same results as the `IDivDuration()`
+    // function, though they usually do so more efficiently; see the
+    // documentation of `IDivDuration()` for details about overflow, etc.
+    //
+    // Example:
+    //
+    //   absl::Duration d = absl::Milliseconds(1500);
+    //   int64_t isec = absl::ToInt64Seconds(d);  // isec == 1
+    ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Seconds(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Minutes(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
+
+    // ToDoubleNanoSeconds()
+    // ToDoubleMicroseconds()
+    // ToDoubleMilliseconds()
+    // ToDoubleSeconds()
+    // ToDoubleMinutes()
+    // ToDoubleHours()
+    //
+    // Helper functions that convert a Duration to a floating point count of the
+    // indicated unit. These functions are shorthand for the `FDivDuration()`
+    // function above; see its documentation for details about overflow, etc.
+    //
+    // Example:
+    //
+    //   absl::Duration d = absl::Milliseconds(1500);
+    //   double dsec = absl::ToDoubleSeconds(d);  // dsec == 1.5
+    ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleSeconds(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMinutes(Duration d);
+    ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d);
+
+    // FromChrono()
+    //
+    // Converts any of the pre-defined std::chrono durations to an absl::Duration.
+    //
+    // Example:
+    //
+    //   std::chrono::milliseconds ms(123);
+    //   absl::Duration d = absl::FromChrono(ms);
+    constexpr Duration FromChrono(const std::chrono::nanoseconds& d);
+    constexpr Duration FromChrono(const std::chrono::microseconds& d);
+    constexpr Duration FromChrono(const std::chrono::milliseconds& d);
+    constexpr Duration FromChrono(const std::chrono::seconds& d);
+    constexpr Duration FromChrono(const std::chrono::minutes& d);
+    constexpr Duration FromChrono(const std::chrono::hours& d);
+
+    // ToChronoNanoseconds()
+    // ToChronoMicroseconds()
+    // ToChronoMilliseconds()
+    // ToChronoSeconds()
+    // ToChronoMinutes()
+    // ToChronoHours()
+    //
+    // Converts an absl::Duration to any of the pre-defined std::chrono durations.
+    // If overflow would occur, the returned value will saturate at the min/max
+    // chrono duration value instead.
+    //
+    // Example:
+    //
+    //   absl::Duration d = absl::Microseconds(123);
+    //   auto x = absl::ToChronoMicroseconds(d);
+    //   auto y = absl::ToChronoNanoseconds(d);  // x == y
+    //   auto z = absl::ToChronoSeconds(absl::InfiniteDuration());
+    //   // z == std::chrono::seconds::max()
+    std::chrono::nanoseconds ToChronoNanoseconds(Duration d);
+    std::chrono::microseconds ToChronoMicroseconds(Duration d);
+    std::chrono::milliseconds ToChronoMilliseconds(Duration d);
+    std::chrono::seconds ToChronoSeconds(Duration d);
+    std::chrono::minutes ToChronoMinutes(Duration d);
+    std::chrono::hours ToChronoHours(Duration d);
+
+    // FormatDuration()
+    //
+    // Returns a string representing the duration in the form "72h3m0.5s".
+    // Returns "inf" or "-inf" for +/- `InfiniteDuration()`.
+    std::string FormatDuration(Duration d);
+
+    // Output stream operator.
+    inline std::ostream& operator<<(std::ostream& os, Duration d)
+    {
+        return os << FormatDuration(d);
+    }
 
+    // ParseDuration()
+    //
+    // Parses a duration string consisting of a possibly signed sequence of
+    // decimal numbers, each with an optional fractional part and a unit
+    // suffix.  The valid suffixes are "ns", "us" "ms", "s", "m", and "h".
+    // Simple examples include "300ms", "-1.5h", and "2h45m".  Parses "0" as
+    // `ZeroDuration()`. Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
+    bool ParseDuration(absl::string_view dur_string, Duration* d);
+
+    // AbslParseFlag()
+    //
+    // Parses a command-line flag string representation `text` into a Duration
+    // value. Duration flags must be specified in a format that is valid input for
+    // `absl::ParseDuration()`.
+    bool AbslParseFlag(absl::string_view text, Duration* dst, std::string* error);
+
+    // AbslUnparseFlag()
+    //
+    // Unparses a Duration value into a command-line string representation using
+    // the format specified by `absl::ParseDuration()`.
+    std::string AbslUnparseFlag(Duration d);
+
+    ABSL_DEPRECATED("Use AbslParseFlag() instead.")
+    bool ParseFlag(const std::string& text, Duration* dst, std::string* error);
+    ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
+    std::string UnparseFlag(Duration d);
+
+    // Time
+    //
+    // An `absl::Time` represents a specific instant in time. Arithmetic operators
+    // are provided for naturally expressing time calculations. Instances are
+    // created using `absl::Now()` and the `absl::From*()` factory functions that
+    // accept the gamut of other time representations. Formatting and parsing
+    // functions are provided for conversion to and from strings.  `absl::Time`
+    // should be passed by value rather than const reference.
+    //
+    // `absl::Time` assumes there are 60 seconds in a minute, which means the
+    // underlying time scales must be "smeared" to eliminate leap seconds.
+    // See https://developers.google.com/time/smear.
+    //
+    // Even though `absl::Time` supports a wide range of timestamps, exercise
+    // caution when using values in the distant past. `absl::Time` uses the
+    // Proleptic Gregorian calendar, which extends the Gregorian calendar backward
+    // to dates before its introduction in 1582.
+    // See https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar
+    // for more information. Use the ICU calendar classes to convert a date in
+    // some other calendar (http://userguide.icu-project.org/datetime/calendar).
+    //
+    // Similarly, standardized time zones are a reasonably recent innovation, with
+    // the Greenwich prime meridian being established in 1884. The TZ database
+    // itself does not profess accurate offsets for timestamps prior to 1970. The
+    // breakdown of future timestamps is subject to the whim of regional
+    // governments.
+    //
+    // The `absl::Time` class represents an instant in time as a count of clock
+    // ticks of some granularity (resolution) from some starting point (epoch).
+    //
+    // `absl::Time` uses a resolution that is high enough to avoid loss in
+    // precision, and a range that is wide enough to avoid overflow, when
+    // converting between tick counts in most Google time scales (i.e., resolution
+    // of at least one nanosecond, and range +/-100 billion years).  Conversions
+    // between the time scales are performed by truncating (towards negative
+    // infinity) to the nearest representable point.
+    //
+    // Examples:
+    //
+    //   absl::Time t1 = ...;
+    //   absl::Time t2 = t1 + absl::Minutes(2);
+    //   absl::Duration d = t2 - t1;  // == absl::Minutes(2)
+    //
+    class Time
+    {
+    public:
+        // Value semantics.
+
+        // Returns the Unix epoch.  However, those reading your code may not know
+        // or expect the Unix epoch as the default value, so make your code more
+        // readable by explicitly initializing all instances before use.
+        //
+        // Example:
+        //   absl::Time t = absl::UnixEpoch();
+        //   absl::Time t = absl::Now();
+        //   absl::Time t = absl::TimeFromTimeval(tv);
+        //   absl::Time t = absl::InfinitePast();
+        constexpr Time() = default;
+
+        // Copyable.
+        constexpr Time(const Time& t) = default;
+        Time& operator=(const Time& t) = default;
+
+        // Assignment operators.
+        Time& operator+=(Duration d)
+        {
+            rep_ += d;
+            return *this;
+        }
+        Time& operator-=(Duration d)
+        {
+            rep_ -= d;
+            return *this;
+        }
+
+        // Time::Breakdown
+        //
+        // The calendar and wall-clock (aka "civil time") components of an
+        // `absl::Time` in a certain `absl::TimeZone`. This struct is not
+        // intended to represent an instant in time. So, rather than passing
+        // a `Time::Breakdown` to a function, pass an `absl::Time` and an
+        // `absl::TimeZone`.
+        //
+        // Deprecated. Use `absl::TimeZone::CivilInfo`.
+        struct
+            Breakdown
+        {
+            int64_t year;        // year (e.g., 2013)
+            int month;           // month of year [1:12]
+            int day;             // day of month [1:31]
+            int hour;            // hour of day [0:23]
+            int minute;          // minute of hour [0:59]
+            int second;          // second of minute [0:59]
+            Duration subsecond;  // [Seconds(0):Seconds(1)) if finite
+            int weekday;         // 1==Mon, ..., 7=Sun
+            int yearday;         // day of year [1:366]
+
+            // Note: The following fields exist for backward compatibility
+            // with older APIs.  Accessing these fields directly is a sign of
+            // imprudent logic in the calling code.  Modern time-related code
+            // should only access this data indirectly by way of FormatTime().
+            // These fields are undefined for InfiniteFuture() and InfinitePast().
+            int offset;             // seconds east of UTC
+            bool is_dst;            // is offset non-standard?
+            const char* zone_abbr;  // time-zone abbreviation (e.g., "PST")
+        };
+
+        // Time::In()
+        //
+        // Returns the breakdown of this instant in the given TimeZone.
+        //
+        // Deprecated. Use `absl::TimeZone::At(Time)`.
+        Breakdown In(TimeZone tz) const;
+
+        template<typename H>
+        friend H AbslHashValue(H h, Time t)
+        {
+            return H::combine(std::move(h), t.rep_);
+        }
+
+    private:
+        friend constexpr Time time_internal::FromUnixDuration(Duration d);
+        friend constexpr Duration time_internal::ToUnixDuration(Time t);
+        friend constexpr bool operator<(Time lhs, Time rhs);
+        friend constexpr bool operator==(Time lhs, Time rhs);
+        friend Duration operator-(Time lhs, Time rhs);
+        friend constexpr Time UniversalEpoch();
+        friend constexpr Time InfiniteFuture();
+        friend constexpr Time InfinitePast();
+        constexpr explicit Time(Duration rep) :
+            rep_(rep)
+        {
+        }
+        Duration rep_;
+    };
+
+    // Relational Operators
+    constexpr bool operator<(Time lhs, Time rhs)
+    {
+        return lhs.rep_ < rhs.rep_;
+    }
+    constexpr bool operator>(Time lhs, Time rhs)
+    {
+        return rhs < lhs;
+    }
+    constexpr bool operator>=(Time lhs, Time rhs)
+    {
+        return !(lhs < rhs);
+    }
+    constexpr bool operator<=(Time lhs, Time rhs)
+    {
+        return !(rhs < lhs);
+    }
+    constexpr bool operator==(Time lhs, Time rhs)
+    {
+        return lhs.rep_ == rhs.rep_;
+    }
+    constexpr bool operator!=(Time lhs, Time rhs)
+    {
+        return !(lhs == rhs);
+    }
 
-// AbslUnparseFlag()
-//
-// Unparses a Duration value into a command-line string representation using
-// the format specified by `absl::ParseDuration()`.
-std::string AbslUnparseFlag(Duration d);
+    // Additive Operators
+    inline Time operator+(Time lhs, Duration rhs)
+    {
+        return lhs += rhs;
+    }
+    inline Time operator+(Duration lhs, Time rhs)
+    {
+        return rhs += lhs;
+    }
+    inline Time operator-(Time lhs, Duration rhs)
+    {
+        return lhs -= rhs;
+    }
+    inline Duration operator-(Time lhs, Time rhs)
+    {
+        return lhs.rep_ - rhs.rep_;
+    }
 
-ABSL_DEPRECATED("Use AbslParseFlag() instead.")
-bool ParseFlag(const std::string& text, Duration* dst, std::string* error);
-ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
-std::string UnparseFlag(Duration d);
+    // UnixEpoch()
+    //
+    // Returns the `absl::Time` representing "1970-01-01 00:00:00.0 +0000".
+    constexpr Time UnixEpoch()
+    {
+        return Time();
+    }
 
-// Time
-//
-// An `absl::Time` represents a specific instant in time. Arithmetic operators
-// are provided for naturally expressing time calculations. Instances are
-// created using `absl::Now()` and the `absl::From*()` factory functions that
-// accept the gamut of other time representations. Formatting and parsing
-// functions are provided for conversion to and from strings.  `absl::Time`
-// should be passed by value rather than const reference.
-//
-// `absl::Time` assumes there are 60 seconds in a minute, which means the
-// underlying time scales must be "smeared" to eliminate leap seconds.
-// See https://developers.google.com/time/smear.
-//
-// Even though `absl::Time` supports a wide range of timestamps, exercise
-// caution when using values in the distant past. `absl::Time` uses the
-// Proleptic Gregorian calendar, which extends the Gregorian calendar backward
-// to dates before its introduction in 1582.
-// See https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar
-// for more information. Use the ICU calendar classes to convert a date in
-// some other calendar (http://userguide.icu-project.org/datetime/calendar).
-//
-// Similarly, standardized time zones are a reasonably recent innovation, with
-// the Greenwich prime meridian being established in 1884. The TZ database
-// itself does not profess accurate offsets for timestamps prior to 1970. The
-// breakdown of future timestamps is subject to the whim of regional
-// governments.
-//
-// The `absl::Time` class represents an instant in time as a count of clock
-// ticks of some granularity (resolution) from some starting point (epoch).
-//
-// `absl::Time` uses a resolution that is high enough to avoid loss in
-// precision, and a range that is wide enough to avoid overflow, when
-// converting between tick counts in most Google time scales (i.e., resolution
-// of at least one nanosecond, and range +/-100 billion years).  Conversions
-// between the time scales are performed by truncating (towards negative
-// infinity) to the nearest representable point.
-//
-// Examples:
-//
-//   absl::Time t1 = ...;
-//   absl::Time t2 = t1 + absl::Minutes(2);
-//   absl::Duration d = t2 - t1;  // == absl::Minutes(2)
-//
-class Time {
- public:
-  // Value semantics.
-
-  // Returns the Unix epoch.  However, those reading your code may not know
-  // or expect the Unix epoch as the default value, so make your code more
-  // readable by explicitly initializing all instances before use.
-  //
-  // Example:
-  //   absl::Time t = absl::UnixEpoch();
-  //   absl::Time t = absl::Now();
-  //   absl::Time t = absl::TimeFromTimeval(tv);
-  //   absl::Time t = absl::InfinitePast();
-  constexpr Time() = default;
-
-  // Copyable.
-  constexpr Time(const Time& t) = default;
-  Time& operator=(const Time& t) = default;
-
-  // Assignment operators.
-  Time& operator+=(Duration d) {
-    rep_ += d;
-    return *this;
-  }
-  Time& operator-=(Duration d) {
-    rep_ -= d;
-    return *this;
-  }
-
-  // Time::Breakdown
-  //
-  // The calendar and wall-clock (aka "civil time") components of an
-  // `absl::Time` in a certain `absl::TimeZone`. This struct is not
-  // intended to represent an instant in time. So, rather than passing
-  // a `Time::Breakdown` to a function, pass an `absl::Time` and an
-  // `absl::TimeZone`.
-  //
-  // Deprecated. Use `absl::TimeZone::CivilInfo`.
-  struct
-      Breakdown {
-    int64_t year;        // year (e.g., 2013)
-    int month;           // month of year [1:12]
-    int day;             // day of month [1:31]
-    int hour;            // hour of day [0:23]
-    int minute;          // minute of hour [0:59]
-    int second;          // second of minute [0:59]
-    Duration subsecond;  // [Seconds(0):Seconds(1)) if finite
-    int weekday;         // 1==Mon, ..., 7=Sun
-    int yearday;         // day of year [1:366]
-
-    // Note: The following fields exist for backward compatibility
-    // with older APIs.  Accessing these fields directly is a sign of
-    // imprudent logic in the calling code.  Modern time-related code
-    // should only access this data indirectly by way of FormatTime().
-    // These fields are undefined for InfiniteFuture() and InfinitePast().
-    int offset;             // seconds east of UTC
-    bool is_dst;            // is offset non-standard?
-    const char* zone_abbr;  // time-zone abbreviation (e.g., "PST")
-  };
-
-  // Time::In()
-  //
-  // Returns the breakdown of this instant in the given TimeZone.
-  //
-  // Deprecated. Use `absl::TimeZone::At(Time)`.
-  Breakdown In(TimeZone tz) const;
-
-  template <typename H>
-  friend H AbslHashValue(H h, Time t) {
-    return H::combine(std::move(h), t.rep_);
-  }
-
- private:
-  friend constexpr Time time_internal::FromUnixDuration(Duration d);
-  friend constexpr Duration time_internal::ToUnixDuration(Time t);
-  friend constexpr bool operator<(Time lhs, Time rhs);
-  friend constexpr bool operator==(Time lhs, Time rhs);
-  friend Duration operator-(Time lhs, Time rhs);
-  friend constexpr Time UniversalEpoch();
-  friend constexpr Time InfiniteFuture();
-  friend constexpr Time InfinitePast();
-  constexpr explicit Time(Duration rep) : rep_(rep) {}
-  Duration rep_;
-};
-
-// Relational Operators
-constexpr bool operator<(Time lhs, Time rhs) { return lhs.rep_ < rhs.rep_; }
-constexpr bool operator>(Time lhs, Time rhs) { return rhs < lhs; }
-constexpr bool operator>=(Time lhs, Time rhs) { return !(lhs < rhs); }
-constexpr bool operator<=(Time lhs, Time rhs) { return !(rhs < lhs); }
-constexpr bool operator==(Time lhs, Time rhs) { return lhs.rep_ == rhs.rep_; }
-constexpr bool operator!=(Time lhs, Time rhs) { return !(lhs == rhs); }
-
-// Additive Operators
-inline Time operator+(Time lhs, Duration rhs) { return lhs += rhs; }
-inline Time operator+(Duration lhs, Time rhs) { return rhs += lhs; }
-inline Time operator-(Time lhs, Duration rhs) { return lhs -= rhs; }
-inline Duration operator-(Time lhs, Time rhs) { return lhs.rep_ - rhs.rep_; }
-
-// UnixEpoch()
-//
-// Returns the `absl::Time` representing "1970-01-01 00:00:00.0 +0000".
-constexpr Time UnixEpoch() { return Time(); }
+    // UniversalEpoch()
+    //
+    // Returns the `absl::Time` representing "0001-01-01 00:00:00.0 +0000", the
+    // epoch of the ICU Universal Time Scale.
+    constexpr Time UniversalEpoch()
+    {
+        // 719162 is the number of days from 0001-01-01 to 1970-01-01,
+        // assuming the Gregorian calendar.
+        return Time(
+            time_internal::MakeDuration(-24 * 719162 * int64_t{3600}, uint32_t{0})
+        );
+    }
 
-// UniversalEpoch()
-//
-// Returns the `absl::Time` representing "0001-01-01 00:00:00.0 +0000", the
-// epoch of the ICU Universal Time Scale.
-constexpr Time UniversalEpoch() {
-  // 719162 is the number of days from 0001-01-01 to 1970-01-01,
-  // assuming the Gregorian calendar.
-  return Time(
-      time_internal::MakeDuration(-24 * 719162 * int64_t{3600}, uint32_t{0}));
-}
-
-// InfiniteFuture()
-//
-// Returns an `absl::Time` that is infinitely far in the future.
-constexpr Time InfiniteFuture() {
-  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
-                                          ~uint32_t{0}));
-}
+    // InfiniteFuture()
+    //
+    // Returns an `absl::Time` that is infinitely far in the future.
+    constexpr Time InfiniteFuture()
+    {
+        return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(), ~uint32_t{0}));
+    }
 
-// InfinitePast()
-//
-// Returns an `absl::Time` that is infinitely far in the past.
-constexpr Time InfinitePast() {
-  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::min)(),
-                                          ~uint32_t{0}));
-}
-
-// FromUnixNanos()
-// FromUnixMicros()
-// FromUnixMillis()
-// FromUnixSeconds()
-// FromTimeT()
-// FromUDate()
-// FromUniversal()
-//
-// Creates an `absl::Time` from a variety of other representations.
-constexpr Time FromUnixNanos(int64_t ns);
-constexpr Time FromUnixMicros(int64_t us);
-constexpr Time FromUnixMillis(int64_t ms);
-constexpr Time FromUnixSeconds(int64_t s);
-constexpr Time FromTimeT(time_t t);
-Time FromUDate(double udate);
-Time FromUniversal(int64_t universal);
-
-// ToUnixNanos()
-// ToUnixMicros()
-// ToUnixMillis()
-// ToUnixSeconds()
-// ToTimeT()
-// ToUDate()
-// ToUniversal()
-//
-// Converts an `absl::Time` to a variety of other representations.  Note that
-// these operations round down toward negative infinity where necessary to
-// adjust to the resolution of the result type.  Beware of possible time_t
-// over/underflow in ToTime{T,val,spec}() on 32-bit platforms.
-int64_t ToUnixNanos(Time t);
-int64_t ToUnixMicros(Time t);
-int64_t ToUnixMillis(Time t);
-int64_t ToUnixSeconds(Time t);
-time_t ToTimeT(Time t);
-double ToUDate(Time t);
-int64_t ToUniversal(Time t);
-
-// DurationFromTimespec()
-// DurationFromTimeval()
-// ToTimespec()
-// ToTimeval()
-// TimeFromTimespec()
-// TimeFromTimeval()
-// ToTimespec()
-// ToTimeval()
-//
-// Some APIs use a timespec or a timeval as a Duration (e.g., nanosleep(2)
-// and select(2)), while others use them as a Time (e.g. clock_gettime(2)
-// and gettimeofday(2)), so conversion functions are provided for both cases.
-// The "to timespec/val" direction is easily handled via overloading, but
-// for "from timespec/val" the desired type is part of the function name.
-Duration DurationFromTimespec(timespec ts);
-Duration DurationFromTimeval(timeval tv);
-timespec ToTimespec(Duration d);
-timeval ToTimeval(Duration d);
-Time TimeFromTimespec(timespec ts);
-Time TimeFromTimeval(timeval tv);
-timespec ToTimespec(Time t);
-timeval ToTimeval(Time t);
-
-// FromChrono()
-//
-// Converts a std::chrono::system_clock::time_point to an absl::Time.
-//
-// Example:
-//
-//   auto tp = std::chrono::system_clock::from_time_t(123);
-//   absl::Time t = absl::FromChrono(tp);
-//   // t == absl::FromTimeT(123)
-Time FromChrono(const std::chrono::system_clock::time_point& tp);
+    // InfinitePast()
+    //
+    // Returns an `absl::Time` that is infinitely far in the past.
+    constexpr Time InfinitePast()
+    {
+        return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::min)(), ~uint32_t{0}));
+    }
 
-// ToChronoTime()
-//
-// Converts an absl::Time to a std::chrono::system_clock::time_point. If
-// overflow would occur, the returned value will saturate at the min/max time
-// point value instead.
-//
-// Example:
-//
-//   absl::Time t = absl::FromTimeT(123);
-//   auto tp = absl::ToChronoTime(t);
-//   // tp == std::chrono::system_clock::from_time_t(123);
-std::chrono::system_clock::time_point ToChronoTime(Time);
+    // FromUnixNanos()
+    // FromUnixMicros()
+    // FromUnixMillis()
+    // FromUnixSeconds()
+    // FromTimeT()
+    // FromUDate()
+    // FromUniversal()
+    //
+    // Creates an `absl::Time` from a variety of other representations.
+    constexpr Time FromUnixNanos(int64_t ns);
+    constexpr Time FromUnixMicros(int64_t us);
+    constexpr Time FromUnixMillis(int64_t ms);
+    constexpr Time FromUnixSeconds(int64_t s);
+    constexpr Time FromTimeT(time_t t);
+    Time FromUDate(double udate);
+    Time FromUniversal(int64_t universal);
+
+    // ToUnixNanos()
+    // ToUnixMicros()
+    // ToUnixMillis()
+    // ToUnixSeconds()
+    // ToTimeT()
+    // ToUDate()
+    // ToUniversal()
+    //
+    // Converts an `absl::Time` to a variety of other representations.  Note that
+    // these operations round down toward negative infinity where necessary to
+    // adjust to the resolution of the result type.  Beware of possible time_t
+    // over/underflow in ToTime{T,val,spec}() on 32-bit platforms.
+    int64_t ToUnixNanos(Time t);
+    int64_t ToUnixMicros(Time t);
+    int64_t ToUnixMillis(Time t);
+    int64_t ToUnixSeconds(Time t);
+    time_t ToTimeT(Time t);
+    double ToUDate(Time t);
+    int64_t ToUniversal(Time t);
+
+    // DurationFromTimespec()
+    // DurationFromTimeval()
+    // ToTimespec()
+    // ToTimeval()
+    // TimeFromTimespec()
+    // TimeFromTimeval()
+    // ToTimespec()
+    // ToTimeval()
+    //
+    // Some APIs use a timespec or a timeval as a Duration (e.g., nanosleep(2)
+    // and select(2)), while others use them as a Time (e.g. clock_gettime(2)
+    // and gettimeofday(2)), so conversion functions are provided for both cases.
+    // The "to timespec/val" direction is easily handled via overloading, but
+    // for "from timespec/val" the desired type is part of the function name.
+    Duration DurationFromTimespec(timespec ts);
+    Duration DurationFromTimeval(timeval tv);
+    timespec ToTimespec(Duration d);
+    timeval ToTimeval(Duration d);
+    Time TimeFromTimespec(timespec ts);
+    Time TimeFromTimeval(timeval tv);
+    timespec ToTimespec(Time t);
+    timeval ToTimeval(Time t);
+
+    // FromChrono()
+    //
+    // Converts a std::chrono::system_clock::time_point to an absl::Time.
+    //
+    // Example:
+    //
+    //   auto tp = std::chrono::system_clock::from_time_t(123);
+    //   absl::Time t = absl::FromChrono(tp);
+    //   // t == absl::FromTimeT(123)
+    Time FromChrono(const std::chrono::system_clock::time_point& tp);
+
+    // ToChronoTime()
+    //
+    // Converts an absl::Time to a std::chrono::system_clock::time_point. If
+    // overflow would occur, the returned value will saturate at the min/max time
+    // point value instead.
+    //
+    // Example:
+    //
+    //   absl::Time t = absl::FromTimeT(123);
+    //   auto tp = absl::ToChronoTime(t);
+    //   // tp == std::chrono::system_clock::from_time_t(123);
+    std::chrono::system_clock::time_point ToChronoTime(Time);
+
+    // AbslParseFlag()
+    //
+    // Parses the command-line flag string representation `text` into a Time value.
+    // Time flags must be specified in a format that matches absl::RFC3339_full.
+    //
+    // For example:
+    //
+    //   --start_time=2016-01-02T03:04:05.678+08:00
+    //
+    // Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required.
+    //
+    // Additionally, if you'd like to specify a time as a count of
+    // seconds/milliseconds/etc from the Unix epoch, use an absl::Duration flag
+    // and add that duration to absl::UnixEpoch() to get an absl::Time.
+    bool AbslParseFlag(absl::string_view text, Time* t, std::string* error);
+
+    // AbslUnparseFlag()
+    //
+    // Unparses a Time value into a command-line string representation using
+    // the format specified by `absl::ParseTime()`.
+    std::string AbslUnparseFlag(Time t);
+
+    ABSL_DEPRECATED("Use AbslParseFlag() instead.")
+    bool ParseFlag(const std::string& text, Time* t, std::string* error);
+    ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
+    std::string UnparseFlag(Time t);
+
+    // TimeZone
+    //
+    // The `absl::TimeZone` is an opaque, small, value-type class representing a
+    // geo-political region within which particular rules are used for converting
+    // between absolute and civil times (see https://git.io/v59Ly). `absl::TimeZone`
+    // values are named using the TZ identifiers from the IANA Time Zone Database,
+    // such as "America/Los_Angeles" or "Australia/Sydney". `absl::TimeZone` values
+    // are created from factory functions such as `absl::LoadTimeZone()`. Note:
+    // strings like "PST" and "EDT" are not valid TZ identifiers. Prefer to pass by
+    // value rather than const reference.
+    //
+    // For more on the fundamental concepts of time zones, absolute times, and civil
+    // times, see https://github.com/google/cctz#fundamental-concepts
+    //
+    // Examples:
+    //
+    //   absl::TimeZone utc = absl::UTCTimeZone();
+    //   absl::TimeZone pst = absl::FixedTimeZone(-8 * 60 * 60);
+    //   absl::TimeZone loc = absl::LocalTimeZone();
+    //   absl::TimeZone lax;
+    //   if (!absl::LoadTimeZone("America/Los_Angeles", &lax)) {
+    //     // handle error case
+    //   }
+    //
+    // See also:
+    // - https://github.com/google/cctz
+    // - https://www.iana.org/time-zones
+    // - https://en.wikipedia.org/wiki/Zoneinfo
+    class TimeZone
+    {
+    public:
+        explicit TimeZone(time_internal::cctz::time_zone tz) :
+            cz_(tz)
+        {
+        }
+        TimeZone() = default;  // UTC, but prefer UTCTimeZone() to be explicit.
+
+        // Copyable.
+        TimeZone(const TimeZone&) = default;
+        TimeZone& operator=(const TimeZone&) = default;
+
+        explicit operator time_internal::cctz::time_zone() const
+        {
+            return cz_;
+        }
+
+        std::string name() const
+        {
+            return cz_.name();
+        }
+
+        // TimeZone::CivilInfo
+        //
+        // Information about the civil time corresponding to an absolute time.
+        // This struct is not intended to represent an instant in time. So, rather
+        // than passing a `TimeZone::CivilInfo` to a function, pass an `absl::Time`
+        // and an `absl::TimeZone`.
+        struct CivilInfo
+        {
+            CivilSecond cs;
+            Duration subsecond;
+
+            // Note: The following fields exist for backward compatibility
+            // with older APIs.  Accessing these fields directly is a sign of
+            // imprudent logic in the calling code.  Modern time-related code
+            // should only access this data indirectly by way of FormatTime().
+            // These fields are undefined for InfiniteFuture() and InfinitePast().
+            int offset;             // seconds east of UTC
+            bool is_dst;            // is offset non-standard?
+            const char* zone_abbr;  // time-zone abbreviation (e.g., "PST")
+        };
+
+        // TimeZone::At(Time)
+        //
+        // Returns the civil time for this TimeZone at a certain `absl::Time`.
+        // If the input time is infinite, the output civil second will be set to
+        // CivilSecond::max() or min(), and the subsecond will be infinite.
+        //
+        // Example:
+        //
+        //   const auto epoch = lax.At(absl::UnixEpoch());
+        //   // epoch.cs == 1969-12-31 16:00:00
+        //   // epoch.subsecond == absl::ZeroDuration()
+        //   // epoch.offset == -28800
+        //   // epoch.is_dst == false
+        //   // epoch.abbr == "PST"
+        CivilInfo At(Time t) const;
+
+        // TimeZone::TimeInfo
+        //
+        // Information about the absolute times corresponding to a civil time.
+        // (Subseconds must be handled separately.)
+        //
+        // It is possible for a caller to pass a civil-time value that does
+        // not represent an actual or unique instant in time (due to a shift
+        // in UTC offset in the TimeZone, which results in a discontinuity in
+        // the civil-time components). For example, a daylight-saving-time
+        // transition skips or repeats civil times---in the United States,
+        // March 13, 2011 02:15 never occurred, while November 6, 2011 01:15
+        // occurred twice---so requests for such times are not well-defined.
+        // To account for these possibilities, `absl::TimeZone::TimeInfo` is
+        // richer than just a single `absl::Time`.
+        struct TimeInfo
+        {
+            enum CivilKind
+            {
+                UNIQUE,    // the civil time was singular (pre == trans == post)
+                SKIPPED,   // the civil time did not exist (pre >= trans > post)
+                REPEATED,  // the civil time was ambiguous (pre < trans <= post)
+            } kind;
+            Time pre;    // time calculated using the pre-transition offset
+            Time trans;  // when the civil-time discontinuity occurred
+            Time post;   // time calculated using the post-transition offset
+        };
+
+        // TimeZone::At(CivilSecond)
+        //
+        // Returns an `absl::TimeInfo` containing the absolute time(s) for this
+        // TimeZone at an `absl::CivilSecond`. When the civil time is skipped or
+        // repeated, returns times calculated using the pre-transition and post-
+        // transition UTC offsets, plus the transition time itself.
+        //
+        // Examples:
+        //
+        //   // A unique civil time
+        //   const auto jan01 = lax.At(absl::CivilSecond(2011, 1, 1, 0, 0, 0));
+        //   // jan01.kind == TimeZone::TimeInfo::UNIQUE
+        //   // jan01.pre    is 2011-01-01 00:00:00 -0800
+        //   // jan01.trans  is 2011-01-01 00:00:00 -0800
+        //   // jan01.post   is 2011-01-01 00:00:00 -0800
+        //
+        //   // A Spring DST transition, when there is a gap in civil time
+        //   const auto mar13 = lax.At(absl::CivilSecond(2011, 3, 13, 2, 15, 0));
+        //   // mar13.kind == TimeZone::TimeInfo::SKIPPED
+        //   // mar13.pre   is 2011-03-13 03:15:00 -0700
+        //   // mar13.trans is 2011-03-13 03:00:00 -0700
+        //   // mar13.post  is 2011-03-13 01:15:00 -0800
+        //
+        //   // A Fall DST transition, when civil times are repeated
+        //   const auto nov06 = lax.At(absl::CivilSecond(2011, 11, 6, 1, 15, 0));
+        //   // nov06.kind == TimeZone::TimeInfo::REPEATED
+        //   // nov06.pre   is 2011-11-06 01:15:00 -0700
+        //   // nov06.trans is 2011-11-06 01:00:00 -0800
+        //   // nov06.post  is 2011-11-06 01:15:00 -0800
+        TimeInfo At(CivilSecond ct) const;
+
+        // TimeZone::NextTransition()
+        // TimeZone::PrevTransition()
+        //
+        // Finds the time of the next/previous offset change in this time zone.
+        //
+        // By definition, `NextTransition(t, &trans)` returns false when `t` is
+        // `InfiniteFuture()`, and `PrevTransition(t, &trans)` returns false
+        // when `t` is `InfinitePast()`. If the zone has no transitions, the
+        // result will also be false no matter what the argument.
+        //
+        // Otherwise, when `t` is `InfinitePast()`, `NextTransition(t, &trans)`
+        // returns true and sets `trans` to the first recorded transition. Chains
+        // of calls to `NextTransition()/PrevTransition()` will eventually return
+        // false, but it is unspecified exactly when `NextTransition(t, &trans)`
+        // jumps to false, or what time is set by `PrevTransition(t, &trans)` for
+        // a very distant `t`.
+        //
+        // Note: Enumeration of time-zone transitions is for informational purposes
+        // only. Modern time-related code should not care about when offset changes
+        // occur.
+        //
+        // Example:
+        //   absl::TimeZone nyc;
+        //   if (!absl::LoadTimeZone("America/New_York", &nyc)) { ... }
+        //   const auto now = absl::Now();
+        //   auto t = absl::InfinitePast();
+        //   absl::TimeZone::CivilTransition trans;
+        //   while (t <= now && nyc.NextTransition(t, &trans)) {
+        //     // transition: trans.from -> trans.to
+        //     t = nyc.At(trans.to).trans;
+        //   }
+        struct CivilTransition
+        {
+            CivilSecond from;  // the civil time we jump from
+            CivilSecond to;    // the civil time we jump to
+        };
+        bool NextTransition(Time t, CivilTransition* trans) const;
+        bool PrevTransition(Time t, CivilTransition* trans) const;
+
+        template<typename H>
+        friend H AbslHashValue(H h, TimeZone tz)
+        {
+            return H::combine(std::move(h), tz.cz_);
+        }
+
+    private:
+        friend bool operator==(TimeZone a, TimeZone b)
+        {
+            return a.cz_ == b.cz_;
+        }
+        friend bool operator!=(TimeZone a, TimeZone b)
+        {
+            return a.cz_ != b.cz_;
+        }
+        friend std::ostream& operator<<(std::ostream& os, TimeZone tz)
+        {
+            return os << tz.name();
+        }
+
+        time_internal::cctz::time_zone cz_;
+    };
+
+    // LoadTimeZone()
+    //
+    // Loads the named zone. May perform I/O on the initial load of the named
+    // zone. If the name is invalid, or some other kind of error occurs, returns
+    // `false` and `*tz` is set to the UTC time zone.
+    inline bool LoadTimeZone(absl::string_view name, TimeZone* tz)
+    {
+        if (name == "localtime")
+        {
+            *tz = TimeZone(time_internal::cctz::local_time_zone());
+            return true;
+        }
+        time_internal::cctz::time_zone cz;
+        const bool b = time_internal::cctz::load_time_zone(std::string(name), &cz);
+        *tz = TimeZone(cz);
+        return b;
+    }
 
-// AbslParseFlag()
-//
-// Parses the command-line flag string representation `text` into a Time value.
-// Time flags must be specified in a format that matches absl::RFC3339_full.
-//
-// For example:
-//
-//   --start_time=2016-01-02T03:04:05.678+08:00
-//
-// Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required.
-//
-// Additionally, if you'd like to specify a time as a count of
-// seconds/milliseconds/etc from the Unix epoch, use an absl::Duration flag
-// and add that duration to absl::UnixEpoch() to get an absl::Time.
-bool AbslParseFlag(absl::string_view text, Time* t, std::string* error);
+    // FixedTimeZone()
+    //
+    // Returns a TimeZone that is a fixed offset (seconds east) from UTC.
+    // Note: If the absolute value of the offset is greater than 24 hours
+    // you'll get UTC (i.e., no offset) instead.
+    inline TimeZone FixedTimeZone(int seconds)
+    {
+        return TimeZone(
+            time_internal::cctz::fixed_time_zone(std::chrono::seconds(seconds))
+        );
+    }
 
-// AbslUnparseFlag()
-//
-// Unparses a Time value into a command-line string representation using
-// the format specified by `absl::ParseTime()`.
-std::string AbslUnparseFlag(Time t);
+    // UTCTimeZone()
+    //
+    // Convenience method returning the UTC time zone.
+    inline TimeZone UTCTimeZone()
+    {
+        return TimeZone(time_internal::cctz::utc_time_zone());
+    }
 
-ABSL_DEPRECATED("Use AbslParseFlag() instead.")
-bool ParseFlag(const std::string& text, Time* t, std::string* error);
-ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
-std::string UnparseFlag(Time t);
+    // LocalTimeZone()
+    //
+    // Convenience method returning the local time zone, or UTC if there is
+    // no configured local zone.  Warning: Be wary of using LocalTimeZone(),
+    // and particularly so in a server process, as the zone configured for the
+    // local machine should be irrelevant.  Prefer an explicit zone name.
+    inline TimeZone LocalTimeZone()
+    {
+        return TimeZone(time_internal::cctz::local_time_zone());
+    }
 
-// TimeZone
-//
-// The `absl::TimeZone` is an opaque, small, value-type class representing a
-// geo-political region within which particular rules are used for converting
-// between absolute and civil times (see https://git.io/v59Ly). `absl::TimeZone`
-// values are named using the TZ identifiers from the IANA Time Zone Database,
-// such as "America/Los_Angeles" or "Australia/Sydney". `absl::TimeZone` values
-// are created from factory functions such as `absl::LoadTimeZone()`. Note:
-// strings like "PST" and "EDT" are not valid TZ identifiers. Prefer to pass by
-// value rather than const reference.
-//
-// For more on the fundamental concepts of time zones, absolute times, and civil
-// times, see https://github.com/google/cctz#fundamental-concepts
-//
-// Examples:
-//
-//   absl::TimeZone utc = absl::UTCTimeZone();
-//   absl::TimeZone pst = absl::FixedTimeZone(-8 * 60 * 60);
-//   absl::TimeZone loc = absl::LocalTimeZone();
-//   absl::TimeZone lax;
-//   if (!absl::LoadTimeZone("America/Los_Angeles", &lax)) {
-//     // handle error case
-//   }
-//
-// See also:
-// - https://github.com/google/cctz
-// - https://www.iana.org/time-zones
-// - https://en.wikipedia.org/wiki/Zoneinfo
-class TimeZone {
- public:
-  explicit TimeZone(time_internal::cctz::time_zone tz) : cz_(tz) {}
-  TimeZone() = default;  // UTC, but prefer UTCTimeZone() to be explicit.
-
-  // Copyable.
-  TimeZone(const TimeZone&) = default;
-  TimeZone& operator=(const TimeZone&) = default;
-
-  explicit operator time_internal::cctz::time_zone() const { return cz_; }
-
-  std::string name() const { return cz_.name(); }
-
-  // TimeZone::CivilInfo
-  //
-  // Information about the civil time corresponding to an absolute time.
-  // This struct is not intended to represent an instant in time. So, rather
-  // than passing a `TimeZone::CivilInfo` to a function, pass an `absl::Time`
-  // and an `absl::TimeZone`.
-  struct CivilInfo {
-    CivilSecond cs;
-    Duration subsecond;
-
-    // Note: The following fields exist for backward compatibility
-    // with older APIs.  Accessing these fields directly is a sign of
-    // imprudent logic in the calling code.  Modern time-related code
-    // should only access this data indirectly by way of FormatTime().
-    // These fields are undefined for InfiniteFuture() and InfinitePast().
-    int offset;             // seconds east of UTC
-    bool is_dst;            // is offset non-standard?
-    const char* zone_abbr;  // time-zone abbreviation (e.g., "PST")
-  };
-
-  // TimeZone::At(Time)
-  //
-  // Returns the civil time for this TimeZone at a certain `absl::Time`.
-  // If the input time is infinite, the output civil second will be set to
-  // CivilSecond::max() or min(), and the subsecond will be infinite.
-  //
-  // Example:
-  //
-  //   const auto epoch = lax.At(absl::UnixEpoch());
-  //   // epoch.cs == 1969-12-31 16:00:00
-  //   // epoch.subsecond == absl::ZeroDuration()
-  //   // epoch.offset == -28800
-  //   // epoch.is_dst == false
-  //   // epoch.abbr == "PST"
-  CivilInfo At(Time t) const;
-
-  // TimeZone::TimeInfo
-  //
-  // Information about the absolute times corresponding to a civil time.
-  // (Subseconds must be handled separately.)
-  //
-  // It is possible for a caller to pass a civil-time value that does
-  // not represent an actual or unique instant in time (due to a shift
-  // in UTC offset in the TimeZone, which results in a discontinuity in
-  // the civil-time components). For example, a daylight-saving-time
-  // transition skips or repeats civil times---in the United States,
-  // March 13, 2011 02:15 never occurred, while November 6, 2011 01:15
-  // occurred twice---so requests for such times are not well-defined.
-  // To account for these possibilities, `absl::TimeZone::TimeInfo` is
-  // richer than just a single `absl::Time`.
-  struct TimeInfo {
-    enum CivilKind {
-      UNIQUE,    // the civil time was singular (pre == trans == post)
-      SKIPPED,   // the civil time did not exist (pre >= trans > post)
-      REPEATED,  // the civil time was ambiguous (pre < trans <= post)
-    } kind;
-    Time pre;    // time calculated using the pre-transition offset
-    Time trans;  // when the civil-time discontinuity occurred
-    Time post;   // time calculated using the post-transition offset
-  };
-
-  // TimeZone::At(CivilSecond)
-  //
-  // Returns an `absl::TimeInfo` containing the absolute time(s) for this
-  // TimeZone at an `absl::CivilSecond`. When the civil time is skipped or
-  // repeated, returns times calculated using the pre-transition and post-
-  // transition UTC offsets, plus the transition time itself.
-  //
-  // Examples:
-  //
-  //   // A unique civil time
-  //   const auto jan01 = lax.At(absl::CivilSecond(2011, 1, 1, 0, 0, 0));
-  //   // jan01.kind == TimeZone::TimeInfo::UNIQUE
-  //   // jan01.pre    is 2011-01-01 00:00:00 -0800
-  //   // jan01.trans  is 2011-01-01 00:00:00 -0800
-  //   // jan01.post   is 2011-01-01 00:00:00 -0800
-  //
-  //   // A Spring DST transition, when there is a gap in civil time
-  //   const auto mar13 = lax.At(absl::CivilSecond(2011, 3, 13, 2, 15, 0));
-  //   // mar13.kind == TimeZone::TimeInfo::SKIPPED
-  //   // mar13.pre   is 2011-03-13 03:15:00 -0700
-  //   // mar13.trans is 2011-03-13 03:00:00 -0700
-  //   // mar13.post  is 2011-03-13 01:15:00 -0800
-  //
-  //   // A Fall DST transition, when civil times are repeated
-  //   const auto nov06 = lax.At(absl::CivilSecond(2011, 11, 6, 1, 15, 0));
-  //   // nov06.kind == TimeZone::TimeInfo::REPEATED
-  //   // nov06.pre   is 2011-11-06 01:15:00 -0700
-  //   // nov06.trans is 2011-11-06 01:00:00 -0800
-  //   // nov06.post  is 2011-11-06 01:15:00 -0800
-  TimeInfo At(CivilSecond ct) const;
-
-  // TimeZone::NextTransition()
-  // TimeZone::PrevTransition()
-  //
-  // Finds the time of the next/previous offset change in this time zone.
-  //
-  // By definition, `NextTransition(t, &trans)` returns false when `t` is
-  // `InfiniteFuture()`, and `PrevTransition(t, &trans)` returns false
-  // when `t` is `InfinitePast()`. If the zone has no transitions, the
-  // result will also be false no matter what the argument.
-  //
-  // Otherwise, when `t` is `InfinitePast()`, `NextTransition(t, &trans)`
-  // returns true and sets `trans` to the first recorded transition. Chains
-  // of calls to `NextTransition()/PrevTransition()` will eventually return
-  // false, but it is unspecified exactly when `NextTransition(t, &trans)`
-  // jumps to false, or what time is set by `PrevTransition(t, &trans)` for
-  // a very distant `t`.
-  //
-  // Note: Enumeration of time-zone transitions is for informational purposes
-  // only. Modern time-related code should not care about when offset changes
-  // occur.
-  //
-  // Example:
-  //   absl::TimeZone nyc;
-  //   if (!absl::LoadTimeZone("America/New_York", &nyc)) { ... }
-  //   const auto now = absl::Now();
-  //   auto t = absl::InfinitePast();
-  //   absl::TimeZone::CivilTransition trans;
-  //   while (t <= now && nyc.NextTransition(t, &trans)) {
-  //     // transition: trans.from -> trans.to
-  //     t = nyc.At(trans.to).trans;
-  //   }
-  struct CivilTransition {
-    CivilSecond from;  // the civil time we jump from
-    CivilSecond to;    // the civil time we jump to
-  };
-  bool NextTransition(Time t, CivilTransition* trans) const;
-  bool PrevTransition(Time t, CivilTransition* trans) const;
-
-  template <typename H>
-  friend H AbslHashValue(H h, TimeZone tz) {
-    return H::combine(std::move(h), tz.cz_);
-  }
-
- private:
-  friend bool operator==(TimeZone a, TimeZone b) { return a.cz_ == b.cz_; }
-  friend bool operator!=(TimeZone a, TimeZone b) { return a.cz_ != b.cz_; }
-  friend std::ostream& operator<<(std::ostream& os, TimeZone tz) {
-    return os << tz.name();
-  }
-
-  time_internal::cctz::time_zone cz_;
-};
-
-// LoadTimeZone()
-//
-// Loads the named zone. May perform I/O on the initial load of the named
-// zone. If the name is invalid, or some other kind of error occurs, returns
-// `false` and `*tz` is set to the UTC time zone.
-inline bool LoadTimeZone(absl::string_view name, TimeZone* tz) {
-  if (name == "localtime") {
-    *tz = TimeZone(time_internal::cctz::local_time_zone());
-    return true;
-  }
-  time_internal::cctz::time_zone cz;
-  const bool b = time_internal::cctz::load_time_zone(std::string(name), &cz);
-  *tz = TimeZone(cz);
-  return b;
-}
-
-// FixedTimeZone()
-//
-// Returns a TimeZone that is a fixed offset (seconds east) from UTC.
-// Note: If the absolute value of the offset is greater than 24 hours
-// you'll get UTC (i.e., no offset) instead.
-inline TimeZone FixedTimeZone(int seconds) {
-  return TimeZone(
-      time_internal::cctz::fixed_time_zone(std::chrono::seconds(seconds)));
-}
-
-// UTCTimeZone()
-//
-// Convenience method returning the UTC time zone.
-inline TimeZone UTCTimeZone() {
-  return TimeZone(time_internal::cctz::utc_time_zone());
-}
+    // ToCivilSecond()
+    // ToCivilMinute()
+    // ToCivilHour()
+    // ToCivilDay()
+    // ToCivilMonth()
+    // ToCivilYear()
+    //
+    // Helpers for TimeZone::At(Time) to return particularly aligned civil times.
+    //
+    // Example:
+    //
+    //   absl::Time t = ...;
+    //   absl::TimeZone tz = ...;
+    //   const auto cd = absl::ToCivilDay(t, tz);
+    inline CivilSecond ToCivilSecond(Time t, TimeZone tz)
+    {
+        return tz.At(t).cs;  // already a CivilSecond
+    }
+    inline CivilMinute ToCivilMinute(Time t, TimeZone tz)
+    {
+        return CivilMinute(tz.At(t).cs);
+    }
+    inline CivilHour ToCivilHour(Time t, TimeZone tz)
+    {
+        return CivilHour(tz.At(t).cs);
+    }
+    inline CivilDay ToCivilDay(Time t, TimeZone tz)
+    {
+        return CivilDay(tz.At(t).cs);
+    }
+    inline CivilMonth ToCivilMonth(Time t, TimeZone tz)
+    {
+        return CivilMonth(tz.At(t).cs);
+    }
+    inline CivilYear ToCivilYear(Time t, TimeZone tz)
+    {
+        return CivilYear(tz.At(t).cs);
+    }
 
-// LocalTimeZone()
-//
-// Convenience method returning the local time zone, or UTC if there is
-// no configured local zone.  Warning: Be wary of using LocalTimeZone(),
-// and particularly so in a server process, as the zone configured for the
-// local machine should be irrelevant.  Prefer an explicit zone name.
-inline TimeZone LocalTimeZone() {
-  return TimeZone(time_internal::cctz::local_time_zone());
-}
-
-// ToCivilSecond()
-// ToCivilMinute()
-// ToCivilHour()
-// ToCivilDay()
-// ToCivilMonth()
-// ToCivilYear()
-//
-// Helpers for TimeZone::At(Time) to return particularly aligned civil times.
-//
-// Example:
-//
-//   absl::Time t = ...;
-//   absl::TimeZone tz = ...;
-//   const auto cd = absl::ToCivilDay(t, tz);
-inline CivilSecond ToCivilSecond(Time t, TimeZone tz) {
-  return tz.At(t).cs;  // already a CivilSecond
-}
-inline CivilMinute ToCivilMinute(Time t, TimeZone tz) {
-  return CivilMinute(tz.At(t).cs);
-}
-inline CivilHour ToCivilHour(Time t, TimeZone tz) {
-  return CivilHour(tz.At(t).cs);
-}
-inline CivilDay ToCivilDay(Time t, TimeZone tz) {
-  return CivilDay(tz.At(t).cs);
-}
-inline CivilMonth ToCivilMonth(Time t, TimeZone tz) {
-  return CivilMonth(tz.At(t).cs);
-}
-inline CivilYear ToCivilYear(Time t, TimeZone tz) {
-  return CivilYear(tz.At(t).cs);
-}
-
-// FromCivil()
-//
-// Helper for TimeZone::At(CivilSecond) that provides "order-preserving
-// semantics." If the civil time maps to a unique time, that time is
-// returned. If the civil time is repeated in the given time zone, the
-// time using the pre-transition offset is returned. Otherwise, the
-// civil time is skipped in the given time zone, and the transition time
-// is returned. This means that for any two civil times, ct1 and ct2,
-// (ct1 < ct2) => (FromCivil(ct1) <= FromCivil(ct2)), the equal case
-// being when two non-existent civil times map to the same transition time.
-//
-// Note: Accepts civil times of any alignment.
-inline Time FromCivil(CivilSecond ct, TimeZone tz) {
-  const auto ti = tz.At(ct);
-  if (ti.kind == TimeZone::TimeInfo::SKIPPED) return ti.trans;
-  return ti.pre;
-}
-
-// TimeConversion
-//
-// An `absl::TimeConversion` represents the conversion of year, month, day,
-// hour, minute, and second values (i.e., a civil time), in a particular
-// `absl::TimeZone`, to a time instant (an absolute time), as returned by
-// `absl::ConvertDateTime()`. Legacy version of `absl::TimeZone::TimeInfo`.
-//
-// Deprecated. Use `absl::TimeZone::TimeInfo`.
-struct
-    TimeConversion {
-  Time pre;    // time calculated using the pre-transition offset
-  Time trans;  // when the civil-time discontinuity occurred
-  Time post;   // time calculated using the post-transition offset
-
-  enum Kind {
-    UNIQUE,    // the civil time was singular (pre == trans == post)
-    SKIPPED,   // the civil time did not exist
-    REPEATED,  // the civil time was ambiguous
-  };
-  Kind kind;
-
-  bool normalized;  // input values were outside their valid ranges
-};
-
-// ConvertDateTime()
-//
-// Legacy version of `absl::TimeZone::At(absl::CivilSecond)` that takes
-// the civil time as six, separate values (YMDHMS).
-//
-// The input month, day, hour, minute, and second values can be outside
-// of their valid ranges, in which case they will be "normalized" during
-// the conversion.
-//
-// Example:
-//
-//   // "October 32" normalizes to "November 1".
-//   absl::TimeConversion tc =
-//       absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, lax);
-//   // tc.kind == TimeConversion::UNIQUE && tc.normalized == true
-//   // absl::ToCivilDay(tc.pre, tz).month() == 11
-//   // absl::ToCivilDay(tc.pre, tz).day() == 1
-//
-// Deprecated. Use `absl::TimeZone::At(CivilSecond)`.
-TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour,
-                               int min, int sec, TimeZone tz);
+    // FromCivil()
+    //
+    // Helper for TimeZone::At(CivilSecond) that provides "order-preserving
+    // semantics." If the civil time maps to a unique time, that time is
+    // returned. If the civil time is repeated in the given time zone, the
+    // time using the pre-transition offset is returned. Otherwise, the
+    // civil time is skipped in the given time zone, and the transition time
+    // is returned. This means that for any two civil times, ct1 and ct2,
+    // (ct1 < ct2) => (FromCivil(ct1) <= FromCivil(ct2)), the equal case
+    // being when two non-existent civil times map to the same transition time.
+    //
+    // Note: Accepts civil times of any alignment.
+    inline Time FromCivil(CivilSecond ct, TimeZone tz)
+    {
+        const auto ti = tz.At(ct);
+        if (ti.kind == TimeZone::TimeInfo::SKIPPED)
+            return ti.trans;
+        return ti.pre;
+    }
 
-// FromDateTime()
-//
-// A convenience wrapper for `absl::ConvertDateTime()` that simply returns
-// the "pre" `absl::Time`.  That is, the unique result, or the instant that
-// is correct using the pre-transition offset (as if the transition never
-// happened).
-//
-// Example:
-//
-//   absl::Time t = absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax);
-//   // t = 2017-09-26 09:30:00 -0700
-//
-// Deprecated. Use `absl::FromCivil(CivilSecond, TimeZone)`. Note that the
-// behavior of `FromCivil()` differs from `FromDateTime()` for skipped civil
-// times. If you care about that see `absl::TimeZone::At(absl::CivilSecond)`.
-inline Time FromDateTime(int64_t year, int mon, int day, int hour,
-                         int min, int sec, TimeZone tz) {
-  return ConvertDateTime(year, mon, day, hour, min, sec, tz).pre;
-}
-
-// FromTM()
-//
-// Converts the `tm_year`, `tm_mon`, `tm_mday`, `tm_hour`, `tm_min`, and
-// `tm_sec` fields to an `absl::Time` using the given time zone. See ctime(3)
-// for a description of the expected values of the tm fields. If the civil time
-// is unique (see `absl::TimeZone::At(absl::CivilSecond)` above), the matching
-// time instant is returned.  Otherwise, the `tm_isdst` field is consulted to
-// choose between the possible results.  For a repeated civil time, `tm_isdst !=
-// 0` returns the matching DST instant, while `tm_isdst == 0` returns the
-// matching non-DST instant.  For a skipped civil time there is no matching
-// instant, so `tm_isdst != 0` returns the DST instant, and `tm_isdst == 0`
-// returns the non-DST instant, that would have matched if the transition never
-// happened.
-Time FromTM(const struct tm& tm, TimeZone tz);
-
-// ToTM()
-//
-// Converts the given `absl::Time` to a struct tm using the given time zone.
-// See ctime(3) for a description of the values of the tm fields.
-struct tm ToTM(Time t, TimeZone tz);
+    // TimeConversion
+    //
+    // An `absl::TimeConversion` represents the conversion of year, month, day,
+    // hour, minute, and second values (i.e., a civil time), in a particular
+    // `absl::TimeZone`, to a time instant (an absolute time), as returned by
+    // `absl::ConvertDateTime()`. Legacy version of `absl::TimeZone::TimeInfo`.
+    //
+    // Deprecated. Use `absl::TimeZone::TimeInfo`.
+    struct
+        TimeConversion
+    {
+        Time pre;    // time calculated using the pre-transition offset
+        Time trans;  // when the civil-time discontinuity occurred
+        Time post;   // time calculated using the post-transition offset
+
+        enum Kind
+        {
+            UNIQUE,    // the civil time was singular (pre == trans == post)
+            SKIPPED,   // the civil time did not exist
+            REPEATED,  // the civil time was ambiguous
+        };
+        Kind kind;
+
+        bool normalized;  // input values were outside their valid ranges
+    };
+
+    // ConvertDateTime()
+    //
+    // Legacy version of `absl::TimeZone::At(absl::CivilSecond)` that takes
+    // the civil time as six, separate values (YMDHMS).
+    //
+    // The input month, day, hour, minute, and second values can be outside
+    // of their valid ranges, in which case they will be "normalized" during
+    // the conversion.
+    //
+    // Example:
+    //
+    //   // "October 32" normalizes to "November 1".
+    //   absl::TimeConversion tc =
+    //       absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, lax);
+    //   // tc.kind == TimeConversion::UNIQUE && tc.normalized == true
+    //   // absl::ToCivilDay(tc.pre, tz).month() == 11
+    //   // absl::ToCivilDay(tc.pre, tz).day() == 1
+    //
+    // Deprecated. Use `absl::TimeZone::At(CivilSecond)`.
+    TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz);
+
+    // FromDateTime()
+    //
+    // A convenience wrapper for `absl::ConvertDateTime()` that simply returns
+    // the "pre" `absl::Time`.  That is, the unique result, or the instant that
+    // is correct using the pre-transition offset (as if the transition never
+    // happened).
+    //
+    // Example:
+    //
+    //   absl::Time t = absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax);
+    //   // t = 2017-09-26 09:30:00 -0700
+    //
+    // Deprecated. Use `absl::FromCivil(CivilSecond, TimeZone)`. Note that the
+    // behavior of `FromCivil()` differs from `FromDateTime()` for skipped civil
+    // times. If you care about that see `absl::TimeZone::At(absl::CivilSecond)`.
+    inline Time FromDateTime(int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz)
+    {
+        return ConvertDateTime(year, mon, day, hour, min, sec, tz).pre;
+    }
 
-// RFC3339_full
-// RFC3339_sec
-//
-// FormatTime()/ParseTime() format specifiers for RFC3339 date/time strings,
-// with trailing zeros trimmed or with fractional seconds omitted altogether.
-//
-// Note that RFC3339_sec[] matches an ISO 8601 extended format for date and
-// time with UTC offset.  Also note the use of "%Y": RFC3339 mandates that
-// years have exactly four digits, but we allow them to take their natural
-// width.
-ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez
-ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez
-
-// RFC1123_full
-// RFC1123_no_wday
-//
-// FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
-ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z
-ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
+    // FromTM()
+    //
+    // Converts the `tm_year`, `tm_mon`, `tm_mday`, `tm_hour`, `tm_min`, and
+    // `tm_sec` fields to an `absl::Time` using the given time zone. See ctime(3)
+    // for a description of the expected values of the tm fields. If the civil time
+    // is unique (see `absl::TimeZone::At(absl::CivilSecond)` above), the matching
+    // time instant is returned.  Otherwise, the `tm_isdst` field is consulted to
+    // choose between the possible results.  For a repeated civil time, `tm_isdst !=
+    // 0` returns the matching DST instant, while `tm_isdst == 0` returns the
+    // matching non-DST instant.  For a skipped civil time there is no matching
+    // instant, so `tm_isdst != 0` returns the DST instant, and `tm_isdst == 0`
+    // returns the non-DST instant, that would have matched if the transition never
+    // happened.
+    Time FromTM(const struct tm& tm, TimeZone tz);
+
+    // ToTM()
+    //
+    // Converts the given `absl::Time` to a struct tm using the given time zone.
+    // See ctime(3) for a description of the values of the tm fields.
+    struct tm ToTM(Time t, TimeZone tz);
+
+    // RFC3339_full
+    // RFC3339_sec
+    //
+    // FormatTime()/ParseTime() format specifiers for RFC3339 date/time strings,
+    // with trailing zeros trimmed or with fractional seconds omitted altogether.
+    //
+    // Note that RFC3339_sec[] matches an ISO 8601 extended format for date and
+    // time with UTC offset.  Also note the use of "%Y": RFC3339 mandates that
+    // years have exactly four digits, but we allow them to take their natural
+    // width.
+    ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez
+    ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez
+
+    // RFC1123_full
+    // RFC1123_no_wday
+    //
+    // FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
+    ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z
+    ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
+
+    // FormatTime()
+    //
+    // Formats the given `absl::Time` in the `absl::TimeZone` according to the
+    // provided format string. Uses strftime()-like formatting options, with
+    // the following extensions:
+    //
+    //   - %Ez  - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
+    //   - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
+    //   - %E#S - Seconds with # digits of fractional precision
+    //   - %E*S - Seconds with full fractional precision (a literal '*')
+    //   - %E#f - Fractional seconds with # digits of precision
+    //   - %E*f - Fractional seconds with full precision (a literal '*')
+    //   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
+    //   - %ET  - The RFC3339 "date-time" separator "T"
+    //
+    // Note that %E0S behaves like %S, and %E0f produces no characters.  In
+    // contrast %E*f always produces at least one digit, which may be '0'.
+    //
+    // Note that %Y produces as many characters as it takes to fully render the
+    // year.  A year outside of [-999:9999] when formatted with %E4Y will produce
+    // more than four characters, just like %Y.
+    //
+    // We recommend that format strings include the UTC offset (%z, %Ez, or %E*z)
+    // so that the result uniquely identifies a time instant.
+    //
+    // Example:
+    //
+    //   absl::CivilSecond cs(2013, 1, 2, 3, 4, 5);
+    //   absl::Time t = absl::FromCivil(cs, lax);
+    //   std::string f = absl::FormatTime("%H:%M:%S", t, lax);  // "03:04:05"
+    //   f = absl::FormatTime("%H:%M:%E3S", t, lax);  // "03:04:05.000"
+    //
+    // Note: If the given `absl::Time` is `absl::InfiniteFuture()`, the returned
+    // string will be exactly "infinite-future". If the given `absl::Time` is
+    // `absl::InfinitePast()`, the returned string will be exactly "infinite-past".
+    // In both cases the given format string and `absl::TimeZone` are ignored.
+    //
+    std::string FormatTime(absl::string_view format, Time t, TimeZone tz);
+
+    // Convenience functions that format the given time using the RFC3339_full
+    // format.  The first overload uses the provided TimeZone, while the second
+    // uses LocalTimeZone().
+    std::string FormatTime(Time t, TimeZone tz);
+    std::string FormatTime(Time t);
+
+    // Output stream operator.
+    inline std::ostream& operator<<(std::ostream& os, Time t)
+    {
+        return os << FormatTime(t);
+    }
 
-// FormatTime()
-//
-// Formats the given `absl::Time` in the `absl::TimeZone` according to the
-// provided format string. Uses strftime()-like formatting options, with
-// the following extensions:
-//
-//   - %Ez  - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
-//   - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
-//   - %E#S - Seconds with # digits of fractional precision
-//   - %E*S - Seconds with full fractional precision (a literal '*')
-//   - %E#f - Fractional seconds with # digits of precision
-//   - %E*f - Fractional seconds with full precision (a literal '*')
-//   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
-//   - %ET  - The RFC3339 "date-time" separator "T"
-//
-// Note that %E0S behaves like %S, and %E0f produces no characters.  In
-// contrast %E*f always produces at least one digit, which may be '0'.
-//
-// Note that %Y produces as many characters as it takes to fully render the
-// year.  A year outside of [-999:9999] when formatted with %E4Y will produce
-// more than four characters, just like %Y.
-//
-// We recommend that format strings include the UTC offset (%z, %Ez, or %E*z)
-// so that the result uniquely identifies a time instant.
-//
-// Example:
-//
-//   absl::CivilSecond cs(2013, 1, 2, 3, 4, 5);
-//   absl::Time t = absl::FromCivil(cs, lax);
-//   std::string f = absl::FormatTime("%H:%M:%S", t, lax);  // "03:04:05"
-//   f = absl::FormatTime("%H:%M:%E3S", t, lax);  // "03:04:05.000"
-//
-// Note: If the given `absl::Time` is `absl::InfiniteFuture()`, the returned
-// string will be exactly "infinite-future". If the given `absl::Time` is
-// `absl::InfinitePast()`, the returned string will be exactly "infinite-past".
-// In both cases the given format string and `absl::TimeZone` are ignored.
-//
-std::string FormatTime(absl::string_view format, Time t, TimeZone tz);
+    // ParseTime()
+    //
+    // Parses an input string according to the provided format string and
+    // returns the corresponding `absl::Time`. Uses strftime()-like formatting
+    // options, with the same extensions as FormatTime(), but with the
+    // exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f.  %Ez
+    // and %E*z also accept the same inputs, which (along with %z) includes
+    // 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
+    //
+    // %Y consumes as many numeric characters as it can, so the matching data
+    // should always be terminated with a non-numeric.  %E4Y always consumes
+    // exactly four characters, including any sign.
+    //
+    // Unspecified fields are taken from the default date and time of ...
+    //
+    //   "1970-01-01 00:00:00.0 +0000"
+    //
+    // For example, parsing a string of "15:45" (%H:%M) will return an absl::Time
+    // that represents "1970-01-01 15:45:00.0 +0000".
+    //
+    // Note that since ParseTime() returns time instants, it makes the most sense
+    // to parse fully-specified date/time strings that include a UTC offset (%z,
+    // %Ez, or %E*z).
+    //
+    // Note also that `absl::ParseTime()` only heeds the fields year, month, day,
+    // hour, minute, (fractional) second, and UTC offset.  Other fields, like
+    // weekday (%a or %A), while parsed for syntactic validity, are ignored
+    // in the conversion.
+    //
+    // Date and time fields that are out-of-range will be treated as errors
+    // rather than normalizing them like `absl::CivilSecond` does.  For example,
+    // it is an error to parse the date "Oct 32, 2013" because 32 is out of range.
+    //
+    // A leap second of ":60" is normalized to ":00" of the following minute
+    // with fractional seconds discarded.  The following table shows how the
+    // given seconds and subseconds will be parsed:
+    //
+    //   "59.x" -> 59.x  // exact
+    //   "60.x" -> 00.0  // normalized
+    //   "00.x" -> 00.x  // exact
+    //
+    // Errors are indicated by returning false and assigning an error message
+    // to the "err" out param if it is non-null.
+    //
+    // Note: If the input string is exactly "infinite-future", the returned
+    // `absl::Time` will be `absl::InfiniteFuture()` and `true` will be returned.
+    // If the input string is "infinite-past", the returned `absl::Time` will be
+    // `absl::InfinitePast()` and `true` will be returned.
+    //
+    bool ParseTime(absl::string_view format, absl::string_view input, Time* time, std::string* err);
+
+    // Like ParseTime() above, but if the format string does not contain a UTC
+    // offset specification (%z/%Ez/%E*z) then the input is interpreted in the
+    // given TimeZone.  This means that the input, by itself, does not identify a
+    // unique instant.  Being time-zone dependent, it also admits the possibility
+    // of ambiguity or non-existence, in which case the "pre" time (as defined
+    // by TimeZone::TimeInfo) is returned.  For these reasons we recommend that
+    // all date/time strings include a UTC offset so they're context independent.
+    bool ParseTime(absl::string_view format, absl::string_view input, TimeZone tz, Time* time, std::string* err);
+
+    // ============================================================================
+    // Implementation Details Follow
+    // ============================================================================
+
+    namespace time_internal
+    {
+
+        // Creates a Duration with a given representation.
+        // REQUIRES: hi,lo is a valid representation of a Duration as specified
+        // in time/duration.cc.
+        constexpr Duration MakeDuration(int64_t hi, uint32_t lo = 0)
+        {
+            return Duration(hi, lo);
+        }
+
+        constexpr Duration MakeDuration(int64_t hi, int64_t lo)
+        {
+            return MakeDuration(hi, static_cast<uint32_t>(lo));
+        }
+
+        // Make a Duration value from a floating-point number, as long as that number
+        // is in the range [ 0 .. numeric_limits<int64_t>::max ), that is, as long as
+        // it's positive and can be converted to int64_t without risk of UB.
+        inline Duration MakePosDoubleDuration(double n)
+        {
+            const int64_t int_secs = static_cast<int64_t>(n);
+            const uint32_t ticks = static_cast<uint32_t>(
+                std::round((n - static_cast<double>(int_secs)) * kTicksPerSecond)
+            );
+            return ticks < kTicksPerSecond ? MakeDuration(int_secs, ticks) : MakeDuration(int_secs + 1, ticks - kTicksPerSecond);
+        }
+
+        // Creates a normalized Duration from an almost-normalized (sec,ticks)
+        // pair. sec may be positive or negative.  ticks must be in the range
+        // -kTicksPerSecond < *ticks < kTicksPerSecond.  If ticks is negative it
+        // will be normalized to a positive value in the resulting Duration.
+        constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks)
+        {
+            return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond) : MakeDuration(sec, ticks);
+        }
+
+        // Provide access to the Duration representation.
+        constexpr int64_t GetRepHi(Duration d)
+        {
+            return d.rep_hi_;
+        }
+        constexpr uint32_t GetRepLo(Duration d)
+        {
+            return d.rep_lo_;
+        }
+
+        // Returns true iff d is positive or negative infinity.
+        constexpr bool IsInfiniteDuration(Duration d)
+        {
+            return GetRepLo(d) == ~uint32_t{0};
+        }
+
+        // Returns an infinite Duration with the opposite sign.
+        // REQUIRES: IsInfiniteDuration(d)
+        constexpr Duration OppositeInfinity(Duration d)
+        {
+            return GetRepHi(d) < 0 ? MakeDuration((std::numeric_limits<int64_t>::max)(), ~uint32_t{0}) : MakeDuration((std::numeric_limits<int64_t>::min)(), ~uint32_t{0});
+        }
+
+        // Returns (-n)-1 (equivalently -(n+1)) without avoidable overflow.
+        constexpr int64_t NegateAndSubtractOne(int64_t n)
+        {
+            // Note: Good compilers will optimize this expression to ~n when using
+            // a two's-complement representation (which is required for int64_t).
+            return (n < 0) ? -(n + 1) : (-n) - 1;
+        }
+
+        // Map between a Time and a Duration since the Unix epoch.  Note that these
+        // functions depend on the above mentioned choice of the Unix epoch for the
+        // Time representation (and both need to be Time friends).  Without this
+        // knowledge, we would need to add-in/subtract-out UnixEpoch() respectively.
+        constexpr Time FromUnixDuration(Duration d)
+        {
+            return Time(d);
+        }
+        constexpr Duration ToUnixDuration(Time t)
+        {
+            return t.rep_;
+        }
+
+        template<std::intmax_t N>
+        constexpr Duration FromInt64(int64_t v, std::ratio<1, N>)
+        {
+            static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
+            // Subsecond ratios cannot overflow.
+            return MakeNormalizedDuration(
+                v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N
+            );
+        }
+        constexpr Duration FromInt64(int64_t v, std::ratio<60>)
+        {
+            return (v <= (std::numeric_limits<int64_t>::max)() / 60 &&
+                    v >= (std::numeric_limits<int64_t>::min)() / 60) ?
+                       MakeDuration(v * 60) :
+                   v > 0 ? InfiniteDuration() :
+                           -InfiniteDuration();
+        }
+        constexpr Duration FromInt64(int64_t v, std::ratio<3600>)
+        {
+            return (v <= (std::numeric_limits<int64_t>::max)() / 3600 &&
+                    v >= (std::numeric_limits<int64_t>::min)() / 3600) ?
+                       MakeDuration(v * 3600) :
+                   v > 0 ? InfiniteDuration() :
+                           -InfiniteDuration();
+        }
+
+        // IsValidRep64<T>(0) is true if the expression `int64_t{std::declval<T>()}` is
+        // valid. That is, if a T can be assigned to an int64_t without narrowing.
+        template<typename T>
+        constexpr auto IsValidRep64(int) -> decltype(int64_t{std::declval<T>()} == 0)
+        {
+            return true;
+        }
+        template<typename T>
+        constexpr auto IsValidRep64(char) -> bool
+        {
+            return false;
+        }
+
+        // Converts a std::chrono::duration to an absl::Duration.
+        template<typename Rep, typename Period>
+        constexpr Duration FromChrono(const std::chrono::duration<Rep, Period>& d)
+        {
+            static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
+            return FromInt64(int64_t{d.count()}, Period{});
+        }
+
+        template<typename Ratio>
+        int64_t ToInt64(Duration d, Ratio)
+        {
+            // Note: This may be used on MSVC, which may have a system_clock period of
+            // std::ratio<1, 10 * 1000 * 1000>
+            return ToInt64Seconds(d * Ratio::den / Ratio::num);
+        }
+        // Fastpath implementations for the 6 common duration units.
+        inline int64_t ToInt64(Duration d, std::nano)
+        {
+            return ToInt64Nanoseconds(d);
+        }
+        inline int64_t ToInt64(Duration d, std::micro)
+        {
+            return ToInt64Microseconds(d);
+        }
+        inline int64_t ToInt64(Duration d, std::milli)
+        {
+            return ToInt64Milliseconds(d);
+        }
+        inline int64_t ToInt64(Duration d, std::ratio<1>)
+        {
+            return ToInt64Seconds(d);
+        }
+        inline int64_t ToInt64(Duration d, std::ratio<60>)
+        {
+            return ToInt64Minutes(d);
+        }
+        inline int64_t ToInt64(Duration d, std::ratio<3600>)
+        {
+            return ToInt64Hours(d);
+        }
+
+        // Converts an absl::Duration to a chrono duration of type T.
+        template<typename T>
+        T ToChronoDuration(Duration d)
+        {
+            using Rep = typename T::rep;
+            using Period = typename T::period;
+            static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
+            if (time_internal::IsInfiniteDuration(d))
+                return d < ZeroDuration() ? (T::min)() : (T::max)();
+            const auto v = ToInt64(d, Period{});
+            if (v > (std::numeric_limits<Rep>::max)())
+                return (T::max)();
+            if (v < (std::numeric_limits<Rep>::min)())
+                return (T::min)();
+            return T{v};
+        }
+
+    }  // namespace time_internal
+
+    constexpr bool operator<(Duration lhs, Duration rhs)
+    {
+        return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs) ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs) : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)() ? time_internal::GetRepLo(lhs) + 1 < time_internal::GetRepLo(rhs) + 1 :
+                                                                                                                                                                                                                    time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
+    }
 
-// Convenience functions that format the given time using the RFC3339_full
-// format.  The first overload uses the provided TimeZone, while the second
-// uses LocalTimeZone().
-std::string FormatTime(Time t, TimeZone tz);
-std::string FormatTime(Time t);
+    constexpr bool operator==(Duration lhs, Duration rhs)
+    {
+        return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
+               time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
+    }
 
-// Output stream operator.
-inline std::ostream& operator<<(std::ostream& os, Time t) {
-  return os << FormatTime(t);
-}
+    constexpr Duration operator-(Duration d)
+    {
+        // This is a little interesting because of the special cases.
+        //
+        // If rep_lo_ is zero, we have it easy; it's safe to negate rep_hi_, we're
+        // dealing with an integral number of seconds, and the only special case is
+        // the maximum negative finite duration, which can't be negated.
+        //
+        // Infinities stay infinite, and just change direction.
+        //
+        // Finally we're in the case where rep_lo_ is non-zero, and we can borrow
+        // a second's worth of ticks and avoid overflow (as negating int64_t-min + 1
+        // is safe).
+        return time_internal::GetRepLo(d) == 0      ? time_internal::GetRepHi(d) ==
+                                                         (std::numeric_limits<int64_t>::min)() ?
+                                                      InfiniteDuration() :
+                                                      time_internal::MakeDuration(-time_internal::GetRepHi(d)) :
+               time_internal::IsInfiniteDuration(d) ? time_internal::OppositeInfinity(d) :
+                                                      time_internal::MakeDuration(
+                                                          time_internal::NegateAndSubtractOne(
+                                                              time_internal::GetRepHi(d)
+                                                          ),
+                                                          time_internal::kTicksPerSecond -
+                                                              time_internal::GetRepLo(d)
+                                                      );
+    }
 
-// ParseTime()
-//
-// Parses an input string according to the provided format string and
-// returns the corresponding `absl::Time`. Uses strftime()-like formatting
-// options, with the same extensions as FormatTime(), but with the
-// exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f.  %Ez
-// and %E*z also accept the same inputs, which (along with %z) includes
-// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
-//
-// %Y consumes as many numeric characters as it can, so the matching data
-// should always be terminated with a non-numeric.  %E4Y always consumes
-// exactly four characters, including any sign.
-//
-// Unspecified fields are taken from the default date and time of ...
-//
-//   "1970-01-01 00:00:00.0 +0000"
-//
-// For example, parsing a string of "15:45" (%H:%M) will return an absl::Time
-// that represents "1970-01-01 15:45:00.0 +0000".
-//
-// Note that since ParseTime() returns time instants, it makes the most sense
-// to parse fully-specified date/time strings that include a UTC offset (%z,
-// %Ez, or %E*z).
-//
-// Note also that `absl::ParseTime()` only heeds the fields year, month, day,
-// hour, minute, (fractional) second, and UTC offset.  Other fields, like
-// weekday (%a or %A), while parsed for syntactic validity, are ignored
-// in the conversion.
-//
-// Date and time fields that are out-of-range will be treated as errors
-// rather than normalizing them like `absl::CivilSecond` does.  For example,
-// it is an error to parse the date "Oct 32, 2013" because 32 is out of range.
-//
-// A leap second of ":60" is normalized to ":00" of the following minute
-// with fractional seconds discarded.  The following table shows how the
-// given seconds and subseconds will be parsed:
-//
-//   "59.x" -> 59.x  // exact
-//   "60.x" -> 00.0  // normalized
-//   "00.x" -> 00.x  // exact
-//
-// Errors are indicated by returning false and assigning an error message
-// to the "err" out param if it is non-null.
-//
-// Note: If the input string is exactly "infinite-future", the returned
-// `absl::Time` will be `absl::InfiniteFuture()` and `true` will be returned.
-// If the input string is "infinite-past", the returned `absl::Time` will be
-// `absl::InfinitePast()` and `true` will be returned.
-//
-bool ParseTime(absl::string_view format, absl::string_view input, Time* time,
-               std::string* err);
-
-// Like ParseTime() above, but if the format string does not contain a UTC
-// offset specification (%z/%Ez/%E*z) then the input is interpreted in the
-// given TimeZone.  This means that the input, by itself, does not identify a
-// unique instant.  Being time-zone dependent, it also admits the possibility
-// of ambiguity or non-existence, in which case the "pre" time (as defined
-// by TimeZone::TimeInfo) is returned.  For these reasons we recommend that
-// all date/time strings include a UTC offset so they're context independent.
-bool ParseTime(absl::string_view format, absl::string_view input, TimeZone tz,
-               Time* time, std::string* err);
-
-// ============================================================================
-// Implementation Details Follow
-// ============================================================================
-
-namespace time_internal {
-
-// Creates a Duration with a given representation.
-// REQUIRES: hi,lo is a valid representation of a Duration as specified
-// in time/duration.cc.
-constexpr Duration MakeDuration(int64_t hi, uint32_t lo = 0) {
-  return Duration(hi, lo);
-}
-
-constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
-  return MakeDuration(hi, static_cast<uint32_t>(lo));
-}
-
-// Make a Duration value from a floating-point number, as long as that number
-// is in the range [ 0 .. numeric_limits<int64_t>::max ), that is, as long as
-// it's positive and can be converted to int64_t without risk of UB.
-inline Duration MakePosDoubleDuration(double n) {
-  const int64_t int_secs = static_cast<int64_t>(n);
-  const uint32_t ticks = static_cast<uint32_t>(
-      std::round((n - static_cast<double>(int_secs)) * kTicksPerSecond));
-  return ticks < kTicksPerSecond
-             ? MakeDuration(int_secs, ticks)
-             : MakeDuration(int_secs + 1, ticks - kTicksPerSecond);
-}
-
-// Creates a normalized Duration from an almost-normalized (sec,ticks)
-// pair. sec may be positive or negative.  ticks must be in the range
-// -kTicksPerSecond < *ticks < kTicksPerSecond.  If ticks is negative it
-// will be normalized to a positive value in the resulting Duration.
-constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks) {
-  return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
-                     : MakeDuration(sec, ticks);
-}
-
-// Provide access to the Duration representation.
-constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; }
-constexpr uint32_t GetRepLo(Duration d) { return d.rep_lo_; }
-
-// Returns true iff d is positive or negative infinity.
-constexpr bool IsInfiniteDuration(Duration d) {
-  return GetRepLo(d) == ~uint32_t{0};
-}
-
-// Returns an infinite Duration with the opposite sign.
-// REQUIRES: IsInfiniteDuration(d)
-constexpr Duration OppositeInfinity(Duration d) {
-  return GetRepHi(d) < 0
-             ? MakeDuration((std::numeric_limits<int64_t>::max)(), ~uint32_t{0})
-             : MakeDuration((std::numeric_limits<int64_t>::min)(),
-                            ~uint32_t{0});
-}
-
-// Returns (-n)-1 (equivalently -(n+1)) without avoidable overflow.
-constexpr int64_t NegateAndSubtractOne(int64_t n) {
-  // Note: Good compilers will optimize this expression to ~n when using
-  // a two's-complement representation (which is required for int64_t).
-  return (n < 0) ? -(n + 1) : (-n) - 1;
-}
-
-// Map between a Time and a Duration since the Unix epoch.  Note that these
-// functions depend on the above mentioned choice of the Unix epoch for the
-// Time representation (and both need to be Time friends).  Without this
-// knowledge, we would need to add-in/subtract-out UnixEpoch() respectively.
-constexpr Time FromUnixDuration(Duration d) { return Time(d); }
-constexpr Duration ToUnixDuration(Time t) { return t.rep_; }
-
-template <std::intmax_t N>
-constexpr Duration FromInt64(int64_t v, std::ratio<1, N>) {
-  static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
-  // Subsecond ratios cannot overflow.
-  return MakeNormalizedDuration(
-      v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
-}
-constexpr Duration FromInt64(int64_t v, std::ratio<60>) {
-  return (v <= (std::numeric_limits<int64_t>::max)() / 60 &&
-          v >= (std::numeric_limits<int64_t>::min)() / 60)
-             ? MakeDuration(v * 60)
-             : v > 0 ? InfiniteDuration() : -InfiniteDuration();
-}
-constexpr Duration FromInt64(int64_t v, std::ratio<3600>) {
-  return (v <= (std::numeric_limits<int64_t>::max)() / 3600 &&
-          v >= (std::numeric_limits<int64_t>::min)() / 3600)
-             ? MakeDuration(v * 3600)
-             : v > 0 ? InfiniteDuration() : -InfiniteDuration();
-}
-
-// IsValidRep64<T>(0) is true if the expression `int64_t{std::declval<T>()}` is
-// valid. That is, if a T can be assigned to an int64_t without narrowing.
-template <typename T>
-constexpr auto IsValidRep64(int) -> decltype(int64_t{std::declval<T>()} == 0) {
-  return true;
-}
-template <typename T>
-constexpr auto IsValidRep64(char) -> bool {
-  return false;
-}
-
-// Converts a std::chrono::duration to an absl::Duration.
-template <typename Rep, typename Period>
-constexpr Duration FromChrono(const std::chrono::duration<Rep, Period>& d) {
-  static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
-  return FromInt64(int64_t{d.count()}, Period{});
-}
-
-template <typename Ratio>
-int64_t ToInt64(Duration d, Ratio) {
-  // Note: This may be used on MSVC, which may have a system_clock period of
-  // std::ratio<1, 10 * 1000 * 1000>
-  return ToInt64Seconds(d * Ratio::den / Ratio::num);
-}
-// Fastpath implementations for the 6 common duration units.
-inline int64_t ToInt64(Duration d, std::nano) {
-  return ToInt64Nanoseconds(d);
-}
-inline int64_t ToInt64(Duration d, std::micro) {
-  return ToInt64Microseconds(d);
-}
-inline int64_t ToInt64(Duration d, std::milli) {
-  return ToInt64Milliseconds(d);
-}
-inline int64_t ToInt64(Duration d, std::ratio<1>) {
-  return ToInt64Seconds(d);
-}
-inline int64_t ToInt64(Duration d, std::ratio<60>) {
-  return ToInt64Minutes(d);
-}
-inline int64_t ToInt64(Duration d, std::ratio<3600>) {
-  return ToInt64Hours(d);
-}
-
-// Converts an absl::Duration to a chrono duration of type T.
-template <typename T>
-T ToChronoDuration(Duration d) {
-  using Rep = typename T::rep;
-  using Period = typename T::period;
-  static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
-  if (time_internal::IsInfiniteDuration(d))
-    return d < ZeroDuration() ? (T::min)() : (T::max)();
-  const auto v = ToInt64(d, Period{});
-  if (v > (std::numeric_limits<Rep>::max)()) return (T::max)();
-  if (v < (std::numeric_limits<Rep>::min)()) return (T::min)();
-  return T{v};
-}
-
-}  // namespace time_internal
-
-constexpr bool operator<(Duration lhs, Duration rhs) {
-  return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
-             ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
-         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
-             ? time_internal::GetRepLo(lhs) + 1 <
-                   time_internal::GetRepLo(rhs) + 1
-             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
-}
-
-constexpr bool operator==(Duration lhs, Duration rhs) {
-  return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
-         time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
-}
-
-constexpr Duration operator-(Duration d) {
-  // This is a little interesting because of the special cases.
-  //
-  // If rep_lo_ is zero, we have it easy; it's safe to negate rep_hi_, we're
-  // dealing with an integral number of seconds, and the only special case is
-  // the maximum negative finite duration, which can't be negated.
-  //
-  // Infinities stay infinite, and just change direction.
-  //
-  // Finally we're in the case where rep_lo_ is non-zero, and we can borrow
-  // a second's worth of ticks and avoid overflow (as negating int64_t-min + 1
-  // is safe).
-  return time_internal::GetRepLo(d) == 0
-             ? time_internal::GetRepHi(d) ==
-                       (std::numeric_limits<int64_t>::min)()
-                   ? InfiniteDuration()
-                   : time_internal::MakeDuration(-time_internal::GetRepHi(d))
-             : time_internal::IsInfiniteDuration(d)
-                   ? time_internal::OppositeInfinity(d)
-                   : time_internal::MakeDuration(
-                         time_internal::NegateAndSubtractOne(
-                             time_internal::GetRepHi(d)),
-                         time_internal::kTicksPerSecond -
-                             time_internal::GetRepLo(d));
-}
-
-constexpr Duration InfiniteDuration() {
-  return time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
-                                     ~uint32_t{0});
-}
-
-constexpr Duration FromChrono(const std::chrono::nanoseconds& d) {
-  return time_internal::FromChrono(d);
-}
-constexpr Duration FromChrono(const std::chrono::microseconds& d) {
-  return time_internal::FromChrono(d);
-}
-constexpr Duration FromChrono(const std::chrono::milliseconds& d) {
-  return time_internal::FromChrono(d);
-}
-constexpr Duration FromChrono(const std::chrono::seconds& d) {
-  return time_internal::FromChrono(d);
-}
-constexpr Duration FromChrono(const std::chrono::minutes& d) {
-  return time_internal::FromChrono(d);
-}
-constexpr Duration FromChrono(const std::chrono::hours& d) {
-  return time_internal::FromChrono(d);
-}
-
-constexpr Time FromUnixNanos(int64_t ns) {
-  return time_internal::FromUnixDuration(Nanoseconds(ns));
-}
-
-constexpr Time FromUnixMicros(int64_t us) {
-  return time_internal::FromUnixDuration(Microseconds(us));
-}
-
-constexpr Time FromUnixMillis(int64_t ms) {
-  return time_internal::FromUnixDuration(Milliseconds(ms));
-}
-
-constexpr Time FromUnixSeconds(int64_t s) {
-  return time_internal::FromUnixDuration(Seconds(s));
-}
-
-constexpr Time FromTimeT(time_t t) {
-  return time_internal::FromUnixDuration(Seconds(t));
-}
-
-ABSL_NAMESPACE_END
+    constexpr Duration InfiniteDuration()
+    {
+        return time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(), ~uint32_t{0});
+    }
+
+    constexpr Duration FromChrono(const std::chrono::nanoseconds& d)
+    {
+        return time_internal::FromChrono(d);
+    }
+    constexpr Duration FromChrono(const std::chrono::microseconds& d)
+    {
+        return time_internal::FromChrono(d);
+    }
+    constexpr Duration FromChrono(const std::chrono::milliseconds& d)
+    {
+        return time_internal::FromChrono(d);
+    }
+    constexpr Duration FromChrono(const std::chrono::seconds& d)
+    {
+        return time_internal::FromChrono(d);
+    }
+    constexpr Duration FromChrono(const std::chrono::minutes& d)
+    {
+        return time_internal::FromChrono(d);
+    }
+    constexpr Duration FromChrono(const std::chrono::hours& d)
+    {
+        return time_internal::FromChrono(d);
+    }
+
+    constexpr Time FromUnixNanos(int64_t ns)
+    {
+        return time_internal::FromUnixDuration(Nanoseconds(ns));
+    }
+
+    constexpr Time FromUnixMicros(int64_t us)
+    {
+        return time_internal::FromUnixDuration(Microseconds(us));
+    }
+
+    constexpr Time FromUnixMillis(int64_t ms)
+    {
+        return time_internal::FromUnixDuration(Milliseconds(ms));
+    }
+
+    constexpr Time FromUnixSeconds(int64_t s)
+    {
+        return time_internal::FromUnixDuration(Seconds(s));
+    }
+
+    constexpr Time FromTimeT(time_t t)
+    {
+        return time_internal::FromUnixDuration(Seconds(t));
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TIME_TIME_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/any.h b/CAPI/cpp/grpc/include/absl/types/any.h
index 204da26..195738b 100644
--- a/CAPI/cpp/grpc/include/absl/types/any.h
+++ b/CAPI/cpp/grpc/include/absl/types/any.h
@@ -60,13 +60,14 @@
 
 #include <any>  // IWYU pragma: export
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::any;
-using std::any_cast;
-using std::bad_any_cast;
-using std::make_any;
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    using std::any;
+    using std::any_cast;
+    using std::bad_any_cast;
+    using std::make_any;
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_ANY
@@ -84,432 +85,484 @@ ABSL_NAMESPACE_END
 #include "absl/meta/type_traits.h"
 #include "absl/types/bad_any_cast.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    class any;
+
+    // swap()
+    //
+    // Swaps two `absl::any` values. Equivalent to `x.swap(y) where `x` and `y` are
+    // `absl::any` types.
+    void swap(any& x, any& y) noexcept;
+
+    // make_any()
+    //
+    // Constructs an `absl::any` of type `T` with the given arguments.
+    template<typename T, typename... Args>
+    any make_any(Args&&... args);
+
+    // Overload of `absl::make_any()` for constructing an `absl::any` type from an
+    // initializer list.
+    template<typename T, typename U, typename... Args>
+    any make_any(std::initializer_list<U> il, Args&&... args);
+
+    // any_cast()
+    //
+    // Statically casts the value of a `const absl::any` type to the given type.
+    // This function will throw `absl::bad_any_cast` if the stored value type of the
+    // `absl::any` does not match the cast.
+    //
+    // `any_cast()` can also be used to get a reference to the internal storage iff
+    // a reference type is passed as its `ValueType`:
+    //
+    // Example:
+    //
+    //   absl::any my_any = std::vector<int>();
+    //   absl::any_cast<std::vector<int>&>(my_any).push_back(42);
+    template<typename ValueType>
+    ValueType any_cast(const any& operand);
+
+    // Overload of `any_cast()` to statically cast the value of a non-const
+    // `absl::any` type to the given type. This function will throw
+    // `absl::bad_any_cast` if the stored value type of the `absl::any` does not
+    // match the cast.
+    template<typename ValueType>
+    ValueType any_cast(any& operand);  // NOLINT(runtime/references)
+
+    // Overload of `any_cast()` to statically cast the rvalue of an `absl::any`
+    // type. This function will throw `absl::bad_any_cast` if the stored value type
+    // of the `absl::any` does not match the cast.
+    template<typename ValueType>
+    ValueType any_cast(any&& operand);
+
+    // Overload of `any_cast()` to statically cast the value of a const pointer
+    // `absl::any` type to the given pointer type, or `nullptr` if the stored value
+    // type of the `absl::any` does not match the cast.
+    template<typename ValueType>
+    const ValueType* any_cast(const any* operand) noexcept;
+
+    // Overload of `any_cast()` to statically cast the value of a pointer
+    // `absl::any` type to the given pointer type, or `nullptr` if the stored value
+    // type of the `absl::any` does not match the cast.
+    template<typename ValueType>
+    ValueType* any_cast(any* operand) noexcept;
+
+    // -----------------------------------------------------------------------------
+    // absl::any
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::any` object provides the facility to either store an instance of a
+    // type, known as the "contained object", or no value. An `absl::any` is used to
+    // store values of types that are unknown at compile time. The `absl::any`
+    // object, when containing a value, must contain a value type; storing a
+    // reference type is neither desired nor supported.
+    //
+    // An `absl::any` can only store a type that is copy-constructible; move-only
+    // types are not allowed within an `any` object.
+    //
+    // Example:
+    //
+    //   auto a = absl::any(65);                 // Literal, copyable
+    //   auto b = absl::any(std::vector<int>()); // Default-initialized, copyable
+    //   std::unique_ptr<Foo> my_foo;
+    //   auto c = absl::any(std::move(my_foo));  // Error, not copy-constructible
+    //
+    // Note that `absl::any` makes use of decayed types (`absl::decay_t` in this
+    // context) to remove const-volatile qualifiers (known as "cv qualifiers"),
+    // decay functions to function pointers, etc. We essentially "decay" a given
+    // type into its essential type.
+    //
+    // `absl::any` makes use of decayed types when determining the basic type `T` of
+    // the value to store in the any's contained object. In the documentation below,
+    // we explicitly denote this by using the phrase "a decayed type of `T`".
+    //
+    // Example:
+    //
+    //   const int a = 4;
+    //   absl::any foo(a);  // Decay ensures we store an "int", not a "const int&".
+    //
+    //   void my_function() {}
+    //   absl::any bar(my_function);  // Decay ensures we store a function pointer.
+    //
+    // `absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction
+    // and is designed to be a drop-in replacement for code compliant with C++17.
+    class any
+    {
+    private:
+        template<typename T>
+        struct IsInPlaceType;
+
+    public:
+        // Constructors
+
+        // Constructs an empty `absl::any` object (`any::has_value()` will return
+        // `false`).
+        constexpr any() noexcept;
+
+        // Copy constructs an `absl::any` object with a "contained object" of the
+        // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
+        // `false`.
+        any(const any& other) :
+            obj_(other.has_value() ? other.obj_->Clone() : std::unique_ptr<ObjInterface>())
+        {
+        }
+
+        // Move constructs an `absl::any` object with a "contained object" of the
+        // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
+        // `false`).
+        any(any&& other) noexcept = default;
+
+        // Constructs an `absl::any` object with a "contained object" of the decayed
+        // type of `T`, which is initialized via `std::forward<T>(value)`.
+        //
+        // This constructor will not participate in overload resolution if the
+        // decayed type of `T` is not copy-constructible.
+        template<
+            typename T,
+            typename VT = absl::decay_t<T>,
+            absl::enable_if_t<!absl::disjunction<
+                std::is_same<any, VT>,
+                IsInPlaceType<VT>,
+                absl::negation<std::is_copy_constructible<VT>>>::value>* = nullptr>
+        any(T&& value) :
+            obj_(new Obj<VT>(in_place, std::forward<T>(value)))
+        {
+        }
+
+        // Constructs an `absl::any` object with a "contained object" of the decayed
+        // type of `T`, which is initialized via `std::forward<T>(value)`.
+        template<typename T, typename... Args, typename VT = absl::decay_t<T>, absl::enable_if_t<absl::conjunction<std::is_copy_constructible<VT>, std::is_constructible<VT, Args...>>::value>* = nullptr>
+        explicit any(in_place_type_t<T> /*tag*/, Args&&... args) :
+            obj_(new Obj<VT>(in_place, std::forward<Args>(args)...))
+        {
+        }
+
+        // Constructs an `absl::any` object with a "contained object" of the passed
+        // type `VT` as a decayed type of `T`. `VT` is initialized as if
+        // direct-non-list-initializing an object of type `VT` with the arguments
+        // `initializer_list, std::forward<Args>(args)...`.
+        template<
+            typename T,
+            typename U,
+            typename... Args,
+            typename VT = absl::decay_t<T>,
+            absl::enable_if_t<
+                absl::conjunction<std::is_copy_constructible<VT>, std::is_constructible<VT, std::initializer_list<U>&, Args...>>::value>* = nullptr>
+        explicit any(in_place_type_t<T> /*tag*/, std::initializer_list<U> ilist, Args&&... args) :
+            obj_(new Obj<VT>(in_place, ilist, std::forward<Args>(args)...))
+        {
+        }
+
+        // Assignment operators
+
+        // Copy assigns an `absl::any` object with a "contained object" of the
+        // passed type.
+        any& operator=(const any& rhs)
+        {
+            any(rhs).swap(*this);
+            return *this;
+        }
+
+        // Move assigns an `absl::any` object with a "contained object" of the
+        // passed type. `rhs` is left in a valid but otherwise unspecified state.
+        any& operator=(any&& rhs) noexcept
+        {
+            any(std::move(rhs)).swap(*this);
+            return *this;
+        }
+
+        // Assigns an `absl::any` object with a "contained object" of the passed type.
+        template<typename T, typename VT = absl::decay_t<T>, absl::enable_if_t<absl::conjunction<absl::negation<std::is_same<VT, any>>, std::is_copy_constructible<VT>>::value>* = nullptr>
+        any& operator=(T&& rhs)
+        {
+            any tmp(in_place_type_t<VT>(), std::forward<T>(rhs));
+            tmp.swap(*this);
+            return *this;
+        }
+
+        // Modifiers
+
+        // any::emplace()
+        //
+        // Emplaces a value within an `absl::any` object by calling `any::reset()`,
+        // initializing the contained value as if direct-non-list-initializing an
+        // object of type `VT` with the arguments `std::forward<Args>(args)...`, and
+        // returning a reference to the new contained value.
+        //
+        // Note: If an exception is thrown during the call to `VT`'s constructor,
+        // `*this` does not contain a value, and any previously contained value has
+        // been destroyed.
+        template<
+            typename T,
+            typename... Args,
+            typename VT = absl::decay_t<T>,
+            absl::enable_if_t<std::is_copy_constructible<VT>::value && std::is_constructible<VT, Args...>::value>* = nullptr>
+        VT& emplace(Args&&... args)
+        {
+            reset();  // NOTE: reset() is required here even in the world of exceptions.
+            Obj<VT>* const object_ptr =
+                new Obj<VT>(in_place, std::forward<Args>(args)...);
+            obj_ = std::unique_ptr<ObjInterface>(object_ptr);
+            return object_ptr->value;
+        }
+
+        // Overload of `any::emplace()` to emplace a value within an `absl::any`
+        // object by calling `any::reset()`, initializing the contained value as if
+        // direct-non-list-initializing an object of type `VT` with the arguments
+        // `initializer_list, std::forward<Args>(args)...`, and returning a reference
+        // to the new contained value.
+        //
+        // Note: If an exception is thrown during the call to `VT`'s constructor,
+        // `*this` does not contain a value, and any previously contained value has
+        // been destroyed. The function shall not participate in overload resolution
+        // unless `is_copy_constructible_v<VT>` is `true` and
+        // `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`.
+        template<
+            typename T,
+            typename U,
+            typename... Args,
+            typename VT = absl::decay_t<T>,
+            absl::enable_if_t<std::is_copy_constructible<VT>::value && std::is_constructible<VT, std::initializer_list<U>&, Args...>::value>* = nullptr>
+        VT& emplace(std::initializer_list<U> ilist, Args&&... args)
+        {
+            reset();  // NOTE: reset() is required here even in the world of exceptions.
+            Obj<VT>* const object_ptr =
+                new Obj<VT>(in_place, ilist, std::forward<Args>(args)...);
+            obj_ = std::unique_ptr<ObjInterface>(object_ptr);
+            return object_ptr->value;
+        }
+
+        // any::reset()
+        //
+        // Resets the state of the `absl::any` object, destroying the contained object
+        // if present.
+        void reset() noexcept
+        {
+            obj_ = nullptr;
+        }
+
+        // any::swap()
+        //
+        // Swaps the passed value and the value of this `absl::any` object.
+        void swap(any& other) noexcept
+        {
+            obj_.swap(other.obj_);
+        }
+
+        // Observers
+
+        // any::has_value()
+        //
+        // Returns `true` if the `any` object has a contained value, otherwise
+        // returns `false`.
+        bool has_value() const noexcept
+        {
+            return obj_ != nullptr;
+        }
 
-class any;
+#ifdef ABSL_INTERNAL_HAS_RTTI
+        // Returns: typeid(T) if *this has a contained object of type T, otherwise
+        // typeid(void).
+        const std::type_info& type() const noexcept
+        {
+            if (has_value())
+            {
+                return obj_->Type();
+            }
+
+            return typeid(void);
+        }
+#endif  // ABSL_INTERNAL_HAS_RTTI
 
-// swap()
-//
-// Swaps two `absl::any` values. Equivalent to `x.swap(y) where `x` and `y` are
-// `absl::any` types.
-void swap(any& x, any& y) noexcept;
+    private:
+        // Tagged type-erased abstraction for holding a cloneable object.
+        class ObjInterface
+        {
+        public:
+            virtual ~ObjInterface() = default;
+            virtual std::unique_ptr<ObjInterface> Clone() const = 0;
+            virtual const void* ObjTypeId() const noexcept = 0;
+#ifdef ABSL_INTERNAL_HAS_RTTI
+            virtual const std::type_info& Type() const noexcept = 0;
+#endif  // ABSL_INTERNAL_HAS_RTTI
+        };
+
+        // Hold a value of some queryable type, with an ability to Clone it.
+        template<typename T>
+        class Obj : public ObjInterface
+        {
+        public:
+            template<typename... Args>
+            explicit Obj(in_place_t /*tag*/, Args&&... args) :
+                value(std::forward<Args>(args)...)
+            {
+            }
+
+            std::unique_ptr<ObjInterface> Clone() const final
+            {
+                return std::unique_ptr<ObjInterface>(new Obj(in_place, value));
+            }
+
+            const void* ObjTypeId() const noexcept final
+            {
+                return IdForType<T>();
+            }
 
-// make_any()
-//
-// Constructs an `absl::any` of type `T` with the given arguments.
-template <typename T, typename... Args>
-any make_any(Args&&... args);
+#ifdef ABSL_INTERNAL_HAS_RTTI
+            const std::type_info& Type() const noexcept final
+            {
+                return typeid(T);
+            }
+#endif  // ABSL_INTERNAL_HAS_RTTI
 
-// Overload of `absl::make_any()` for constructing an `absl::any` type from an
-// initializer list.
-template <typename T, typename U, typename... Args>
-any make_any(std::initializer_list<U> il, Args&&... args);
+            T value;
+        };
 
-// any_cast()
-//
-// Statically casts the value of a `const absl::any` type to the given type.
-// This function will throw `absl::bad_any_cast` if the stored value type of the
-// `absl::any` does not match the cast.
-//
-// `any_cast()` can also be used to get a reference to the internal storage iff
-// a reference type is passed as its `ValueType`:
-//
-// Example:
-//
-//   absl::any my_any = std::vector<int>();
-//   absl::any_cast<std::vector<int>&>(my_any).push_back(42);
-template <typename ValueType>
-ValueType any_cast(const any& operand);
-
-// Overload of `any_cast()` to statically cast the value of a non-const
-// `absl::any` type to the given type. This function will throw
-// `absl::bad_any_cast` if the stored value type of the `absl::any` does not
-// match the cast.
-template <typename ValueType>
-ValueType any_cast(any& operand);  // NOLINT(runtime/references)
-
-// Overload of `any_cast()` to statically cast the rvalue of an `absl::any`
-// type. This function will throw `absl::bad_any_cast` if the stored value type
-// of the `absl::any` does not match the cast.
-template <typename ValueType>
-ValueType any_cast(any&& operand);
-
-// Overload of `any_cast()` to statically cast the value of a const pointer
-// `absl::any` type to the given pointer type, or `nullptr` if the stored value
-// type of the `absl::any` does not match the cast.
-template <typename ValueType>
-const ValueType* any_cast(const any* operand) noexcept;
-
-// Overload of `any_cast()` to statically cast the value of a pointer
-// `absl::any` type to the given pointer type, or `nullptr` if the stored value
-// type of the `absl::any` does not match the cast.
-template <typename ValueType>
-ValueType* any_cast(any* operand) noexcept;
+        std::unique_ptr<ObjInterface> CloneObj() const
+        {
+            if (!obj_)
+                return nullptr;
+            return obj_->Clone();
+        }
 
-// -----------------------------------------------------------------------------
-// absl::any
-// -----------------------------------------------------------------------------
-//
-// An `absl::any` object provides the facility to either store an instance of a
-// type, known as the "contained object", or no value. An `absl::any` is used to
-// store values of types that are unknown at compile time. The `absl::any`
-// object, when containing a value, must contain a value type; storing a
-// reference type is neither desired nor supported.
-//
-// An `absl::any` can only store a type that is copy-constructible; move-only
-// types are not allowed within an `any` object.
-//
-// Example:
-//
-//   auto a = absl::any(65);                 // Literal, copyable
-//   auto b = absl::any(std::vector<int>()); // Default-initialized, copyable
-//   std::unique_ptr<Foo> my_foo;
-//   auto c = absl::any(std::move(my_foo));  // Error, not copy-constructible
-//
-// Note that `absl::any` makes use of decayed types (`absl::decay_t` in this
-// context) to remove const-volatile qualifiers (known as "cv qualifiers"),
-// decay functions to function pointers, etc. We essentially "decay" a given
-// type into its essential type.
-//
-// `absl::any` makes use of decayed types when determining the basic type `T` of
-// the value to store in the any's contained object. In the documentation below,
-// we explicitly denote this by using the phrase "a decayed type of `T`".
-//
-// Example:
-//
-//   const int a = 4;
-//   absl::any foo(a);  // Decay ensures we store an "int", not a "const int&".
-//
-//   void my_function() {}
-//   absl::any bar(my_function);  // Decay ensures we store a function pointer.
-//
-// `absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction
-// and is designed to be a drop-in replacement for code compliant with C++17.
-class any {
- private:
-  template <typename T>
-  struct IsInPlaceType;
-
- public:
-  // Constructors
-
-  // Constructs an empty `absl::any` object (`any::has_value()` will return
-  // `false`).
-  constexpr any() noexcept;
-
-  // Copy constructs an `absl::any` object with a "contained object" of the
-  // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
-  // `false`.
-  any(const any& other)
-      : obj_(other.has_value() ? other.obj_->Clone()
-                               : std::unique_ptr<ObjInterface>()) {}
-
-  // Move constructs an `absl::any` object with a "contained object" of the
-  // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
-  // `false`).
-  any(any&& other) noexcept = default;
-
-  // Constructs an `absl::any` object with a "contained object" of the decayed
-  // type of `T`, which is initialized via `std::forward<T>(value)`.
-  //
-  // This constructor will not participate in overload resolution if the
-  // decayed type of `T` is not copy-constructible.
-  template <
-      typename T, typename VT = absl::decay_t<T>,
-      absl::enable_if_t<!absl::disjunction<
-          std::is_same<any, VT>, IsInPlaceType<VT>,
-          absl::negation<std::is_copy_constructible<VT> > >::value>* = nullptr>
-  any(T&& value) : obj_(new Obj<VT>(in_place, std::forward<T>(value))) {}
-
-  // Constructs an `absl::any` object with a "contained object" of the decayed
-  // type of `T`, which is initialized via `std::forward<T>(value)`.
-  template <typename T, typename... Args, typename VT = absl::decay_t<T>,
-            absl::enable_if_t<absl::conjunction<
-                std::is_copy_constructible<VT>,
-                std::is_constructible<VT, Args...>>::value>* = nullptr>
-  explicit any(in_place_type_t<T> /*tag*/, Args&&... args)
-      : obj_(new Obj<VT>(in_place, std::forward<Args>(args)...)) {}
-
-  // Constructs an `absl::any` object with a "contained object" of the passed
-  // type `VT` as a decayed type of `T`. `VT` is initialized as if
-  // direct-non-list-initializing an object of type `VT` with the arguments
-  // `initializer_list, std::forward<Args>(args)...`.
-  template <
-      typename T, typename U, typename... Args, typename VT = absl::decay_t<T>,
-      absl::enable_if_t<
-          absl::conjunction<std::is_copy_constructible<VT>,
-                            std::is_constructible<VT, std::initializer_list<U>&,
-                                                  Args...>>::value>* = nullptr>
-  explicit any(in_place_type_t<T> /*tag*/, std::initializer_list<U> ilist,
-               Args&&... args)
-      : obj_(new Obj<VT>(in_place, ilist, std::forward<Args>(args)...)) {}
-
-  // Assignment operators
-
-  // Copy assigns an `absl::any` object with a "contained object" of the
-  // passed type.
-  any& operator=(const any& rhs) {
-    any(rhs).swap(*this);
-    return *this;
-  }
-
-  // Move assigns an `absl::any` object with a "contained object" of the
-  // passed type. `rhs` is left in a valid but otherwise unspecified state.
-  any& operator=(any&& rhs) noexcept {
-    any(std::move(rhs)).swap(*this);
-    return *this;
-  }
-
-  // Assigns an `absl::any` object with a "contained object" of the passed type.
-  template <typename T, typename VT = absl::decay_t<T>,
-            absl::enable_if_t<absl::conjunction<
-                absl::negation<std::is_same<VT, any>>,
-                std::is_copy_constructible<VT>>::value>* = nullptr>
-  any& operator=(T&& rhs) {
-    any tmp(in_place_type_t<VT>(), std::forward<T>(rhs));
-    tmp.swap(*this);
-    return *this;
-  }
-
-  // Modifiers
-
-  // any::emplace()
-  //
-  // Emplaces a value within an `absl::any` object by calling `any::reset()`,
-  // initializing the contained value as if direct-non-list-initializing an
-  // object of type `VT` with the arguments `std::forward<Args>(args)...`, and
-  // returning a reference to the new contained value.
-  //
-  // Note: If an exception is thrown during the call to `VT`'s constructor,
-  // `*this` does not contain a value, and any previously contained value has
-  // been destroyed.
-  template <
-      typename T, typename... Args, typename VT = absl::decay_t<T>,
-      absl::enable_if_t<std::is_copy_constructible<VT>::value &&
-                        std::is_constructible<VT, Args...>::value>* = nullptr>
-  VT& emplace(Args&&... args) {
-    reset();  // NOTE: reset() is required here even in the world of exceptions.
-    Obj<VT>* const object_ptr =
-        new Obj<VT>(in_place, std::forward<Args>(args)...);
-    obj_ = std::unique_ptr<ObjInterface>(object_ptr);
-    return object_ptr->value;
-  }
-
-  // Overload of `any::emplace()` to emplace a value within an `absl::any`
-  // object by calling `any::reset()`, initializing the contained value as if
-  // direct-non-list-initializing an object of type `VT` with the arguments
-  // `initializer_list, std::forward<Args>(args)...`, and returning a reference
-  // to the new contained value.
-  //
-  // Note: If an exception is thrown during the call to `VT`'s constructor,
-  // `*this` does not contain a value, and any previously contained value has
-  // been destroyed. The function shall not participate in overload resolution
-  // unless `is_copy_constructible_v<VT>` is `true` and
-  // `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`.
-  template <
-      typename T, typename U, typename... Args, typename VT = absl::decay_t<T>,
-      absl::enable_if_t<std::is_copy_constructible<VT>::value &&
-                        std::is_constructible<VT, std::initializer_list<U>&,
-                                              Args...>::value>* = nullptr>
-  VT& emplace(std::initializer_list<U> ilist, Args&&... args) {
-    reset();  // NOTE: reset() is required here even in the world of exceptions.
-    Obj<VT>* const object_ptr =
-        new Obj<VT>(in_place, ilist, std::forward<Args>(args)...);
-    obj_ = std::unique_ptr<ObjInterface>(object_ptr);
-    return object_ptr->value;
-  }
-
-  // any::reset()
-  //
-  // Resets the state of the `absl::any` object, destroying the contained object
-  // if present.
-  void reset() noexcept { obj_ = nullptr; }
-
-  // any::swap()
-  //
-  // Swaps the passed value and the value of this `absl::any` object.
-  void swap(any& other) noexcept { obj_.swap(other.obj_); }
-
-  // Observers
-
-  // any::has_value()
-  //
-  // Returns `true` if the `any` object has a contained value, otherwise
-  // returns `false`.
-  bool has_value() const noexcept { return obj_ != nullptr; }
+        template<typename T>
+        constexpr static const void* IdForType()
+        {
+            // Note: This type dance is to make the behavior consistent with typeid.
+            using NormalizedType =
+                typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
-#ifdef ABSL_INTERNAL_HAS_RTTI
-  // Returns: typeid(T) if *this has a contained object of type T, otherwise
-  // typeid(void).
-  const std::type_info& type() const noexcept {
-    if (has_value()) {
-      return obj_->Type();
-    }
+            return base_internal::FastTypeId<NormalizedType>();
+        }
 
-    return typeid(void);
-  }
-#endif  // ABSL_INTERNAL_HAS_RTTI
+        const void* GetObjTypeId() const
+        {
+            return obj_ ? obj_->ObjTypeId() : base_internal::FastTypeId<void>();
+        }
 
- private:
-  // Tagged type-erased abstraction for holding a cloneable object.
-  class ObjInterface {
-   public:
-    virtual ~ObjInterface() = default;
-    virtual std::unique_ptr<ObjInterface> Clone() const = 0;
-    virtual const void* ObjTypeId() const noexcept = 0;
-#ifdef ABSL_INTERNAL_HAS_RTTI
-    virtual const std::type_info& Type() const noexcept = 0;
-#endif  // ABSL_INTERNAL_HAS_RTTI
-  };
-
-  // Hold a value of some queryable type, with an ability to Clone it.
-  template <typename T>
-  class Obj : public ObjInterface {
-   public:
-    template <typename... Args>
-    explicit Obj(in_place_t /*tag*/, Args&&... args)
-        : value(std::forward<Args>(args)...) {}
-
-    std::unique_ptr<ObjInterface> Clone() const final {
-      return std::unique_ptr<ObjInterface>(new Obj(in_place, value));
-    }
+        // `absl::any` nonmember functions //
 
-    const void* ObjTypeId() const noexcept final { return IdForType<T>(); }
+        // Description at the declaration site (top of file).
+        template<typename ValueType>
+        friend ValueType any_cast(const any& operand);
 
-#ifdef ABSL_INTERNAL_HAS_RTTI
-    const std::type_info& Type() const noexcept final { return typeid(T); }
-#endif  // ABSL_INTERNAL_HAS_RTTI
+        // Description at the declaration site (top of file).
+        template<typename ValueType>
+        friend ValueType any_cast(any& operand);  // NOLINT(runtime/references)
 
-    T value;
-  };
+        // Description at the declaration site (top of file).
+        template<typename T>
+        friend const T* any_cast(const any* operand) noexcept;
 
-  std::unique_ptr<ObjInterface> CloneObj() const {
-    if (!obj_) return nullptr;
-    return obj_->Clone();
-  }
+        // Description at the declaration site (top of file).
+        template<typename T>
+        friend T* any_cast(any* operand) noexcept;
 
-  template <typename T>
-  constexpr static const void* IdForType() {
-    // Note: This type dance is to make the behavior consistent with typeid.
-    using NormalizedType =
-        typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+        std::unique_ptr<ObjInterface> obj_;
+    };
 
-    return base_internal::FastTypeId<NormalizedType>();
-  }
+    // -----------------------------------------------------------------------------
+    // Implementation Details
+    // -----------------------------------------------------------------------------
 
-  const void* GetObjTypeId() const {
-    return obj_ ? obj_->ObjTypeId() : base_internal::FastTypeId<void>();
-  }
+    constexpr any::any() noexcept = default;
 
-  // `absl::any` nonmember functions //
+    template<typename T>
+    struct any::IsInPlaceType : std::false_type
+    {
+    };
 
-  // Description at the declaration site (top of file).
-  template <typename ValueType>
-  friend ValueType any_cast(const any& operand);
+    template<typename T>
+    struct any::IsInPlaceType<in_place_type_t<T>> : std::true_type
+    {
+    };
 
-  // Description at the declaration site (top of file).
-  template <typename ValueType>
-  friend ValueType any_cast(any& operand);  // NOLINT(runtime/references)
+    inline void swap(any& x, any& y) noexcept
+    {
+        x.swap(y);
+    }
 
-  // Description at the declaration site (top of file).
-  template <typename T>
-  friend const T* any_cast(const any* operand) noexcept;
+    // Description at the declaration site (top of file).
+    template<typename T, typename... Args>
+    any make_any(Args&&... args)
+    {
+        return any(in_place_type_t<T>(), std::forward<Args>(args)...);
+    }
 
-  // Description at the declaration site (top of file).
-  template <typename T>
-  friend T* any_cast(any* operand) noexcept;
+    // Description at the declaration site (top of file).
+    template<typename T, typename U, typename... Args>
+    any make_any(std::initializer_list<U> il, Args&&... args)
+    {
+        return any(in_place_type_t<T>(), il, std::forward<Args>(args)...);
+    }
 
-  std::unique_ptr<ObjInterface> obj_;
-};
+    // Description at the declaration site (top of file).
+    template<typename ValueType>
+    ValueType any_cast(const any& operand)
+    {
+        using U = typename std::remove_cv<
+            typename std::remove_reference<ValueType>::type>::type;
+        static_assert(std::is_constructible<ValueType, const U&>::value, "Invalid ValueType");
+        auto* const result = (any_cast<U>)(&operand);
+        if (result == nullptr)
+        {
+            any_internal::ThrowBadAnyCast();
+        }
+        return static_cast<ValueType>(*result);
+    }
 
-// -----------------------------------------------------------------------------
-// Implementation Details
-// -----------------------------------------------------------------------------
+    // Description at the declaration site (top of file).
+    template<typename ValueType>
+    ValueType any_cast(any& operand)
+    {  // NOLINT(runtime/references)
+        using U = typename std::remove_cv<
+            typename std::remove_reference<ValueType>::type>::type;
+        static_assert(std::is_constructible<ValueType, U&>::value, "Invalid ValueType");
+        auto* result = (any_cast<U>)(&operand);
+        if (result == nullptr)
+        {
+            any_internal::ThrowBadAnyCast();
+        }
+        return static_cast<ValueType>(*result);
+    }
+
+    // Description at the declaration site (top of file).
+    template<typename ValueType>
+    ValueType any_cast(any&& operand)
+    {
+        using U = typename std::remove_cv<
+            typename std::remove_reference<ValueType>::type>::type;
+        static_assert(std::is_constructible<ValueType, U>::value, "Invalid ValueType");
+        return static_cast<ValueType>(std::move((any_cast<U&>)(operand)));
+    }
+
+    // Description at the declaration site (top of file).
+    template<typename T>
+    const T* any_cast(const any* operand) noexcept
+    {
+        using U =
+            typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+        return operand && operand->GetObjTypeId() == any::IdForType<U>() ? std::addressof(
+                                                                               static_cast<const any::Obj<U>*>(operand->obj_.get())->value
+                                                                           ) :
+                                                                           nullptr;
+    }
+
+    // Description at the declaration site (top of file).
+    template<typename T>
+    T* any_cast(any* operand) noexcept
+    {
+        using U =
+            typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+        return operand && operand->GetObjTypeId() == any::IdForType<U>() ? std::addressof(
+                                                                               static_cast<any::Obj<U>*>(operand->obj_.get())->value
+                                                                           ) :
+                                                                           nullptr;
+    }
 
-constexpr any::any() noexcept = default;
-
-template <typename T>
-struct any::IsInPlaceType : std::false_type {};
-
-template <typename T>
-struct any::IsInPlaceType<in_place_type_t<T>> : std::true_type {};
-
-inline void swap(any& x, any& y) noexcept { x.swap(y); }
-
-// Description at the declaration site (top of file).
-template <typename T, typename... Args>
-any make_any(Args&&... args) {
-  return any(in_place_type_t<T>(), std::forward<Args>(args)...);
-}
-
-// Description at the declaration site (top of file).
-template <typename T, typename U, typename... Args>
-any make_any(std::initializer_list<U> il, Args&&... args) {
-  return any(in_place_type_t<T>(), il, std::forward<Args>(args)...);
-}
-
-// Description at the declaration site (top of file).
-template <typename ValueType>
-ValueType any_cast(const any& operand) {
-  using U = typename std::remove_cv<
-      typename std::remove_reference<ValueType>::type>::type;
-  static_assert(std::is_constructible<ValueType, const U&>::value,
-                "Invalid ValueType");
-  auto* const result = (any_cast<U>)(&operand);
-  if (result == nullptr) {
-    any_internal::ThrowBadAnyCast();
-  }
-  return static_cast<ValueType>(*result);
-}
-
-// Description at the declaration site (top of file).
-template <typename ValueType>
-ValueType any_cast(any& operand) {  // NOLINT(runtime/references)
-  using U = typename std::remove_cv<
-      typename std::remove_reference<ValueType>::type>::type;
-  static_assert(std::is_constructible<ValueType, U&>::value,
-                "Invalid ValueType");
-  auto* result = (any_cast<U>)(&operand);
-  if (result == nullptr) {
-    any_internal::ThrowBadAnyCast();
-  }
-  return static_cast<ValueType>(*result);
-}
-
-// Description at the declaration site (top of file).
-template <typename ValueType>
-ValueType any_cast(any&& operand) {
-  using U = typename std::remove_cv<
-      typename std::remove_reference<ValueType>::type>::type;
-  static_assert(std::is_constructible<ValueType, U>::value,
-                "Invalid ValueType");
-  return static_cast<ValueType>(std::move((any_cast<U&>)(operand)));
-}
-
-// Description at the declaration site (top of file).
-template <typename T>
-const T* any_cast(const any* operand) noexcept {
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-  return operand && operand->GetObjTypeId() == any::IdForType<U>()
-             ? std::addressof(
-                   static_cast<const any::Obj<U>*>(operand->obj_.get())->value)
-             : nullptr;
-}
-
-// Description at the declaration site (top of file).
-template <typename T>
-T* any_cast(any* operand) noexcept {
-  using U =
-      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-  return operand && operand->GetObjTypeId() == any::IdForType<U>()
-             ? std::addressof(
-                   static_cast<any::Obj<U>*>(operand->obj_.get())->value)
-             : nullptr;
-}
-
-ABSL_NAMESPACE_END
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_USES_STD_ANY
diff --git a/CAPI/cpp/grpc/include/absl/types/bad_any_cast.h b/CAPI/cpp/grpc/include/absl/types/bad_any_cast.h
index 114cef8..5aba45b 100644
--- a/CAPI/cpp/grpc/include/absl/types/bad_any_cast.h
+++ b/CAPI/cpp/grpc/include/absl/types/bad_any_cast.h
@@ -29,45 +29,49 @@
 
 #include <any>
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_any_cast;
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    using std::bad_any_cast;
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_ANY
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// -----------------------------------------------------------------------------
-// bad_any_cast
-// -----------------------------------------------------------------------------
-//
-// An `absl::bad_any_cast` type is an exception type that is thrown when
-// failing to successfully cast the return value of an `absl::any` object.
-//
-// Example:
-//
-//   auto a = absl::any(65);
-//   absl::any_cast<int>(a);         // 65
-//   try {
-//     absl::any_cast<char>(a);
-//   } catch(const absl::bad_any_cast& e) {
-//     std::cout << "Bad any cast: " << e.what() << '\n';
-//   }
-class bad_any_cast : public std::bad_cast {
- public:
-  ~bad_any_cast() override;
-  const char* what() const noexcept override;
-};
+    // -----------------------------------------------------------------------------
+    // bad_any_cast
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::bad_any_cast` type is an exception type that is thrown when
+    // failing to successfully cast the return value of an `absl::any` object.
+    //
+    // Example:
+    //
+    //   auto a = absl::any(65);
+    //   absl::any_cast<int>(a);         // 65
+    //   try {
+    //     absl::any_cast<char>(a);
+    //   } catch(const absl::bad_any_cast& e) {
+    //     std::cout << "Bad any cast: " << e.what() << '\n';
+    //   }
+    class bad_any_cast : public std::bad_cast
+    {
+    public:
+        ~bad_any_cast() override;
+        const char* what() const noexcept override;
+    };
 
-namespace any_internal {
+    namespace any_internal
+    {
 
-[[noreturn]] void ThrowBadAnyCast();
+        [[noreturn]] void ThrowBadAnyCast();
 
-}  // namespace any_internal
-ABSL_NAMESPACE_END
+    }  // namespace any_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_USES_STD_ANY
diff --git a/CAPI/cpp/grpc/include/absl/types/bad_optional_access.h b/CAPI/cpp/grpc/include/absl/types/bad_optional_access.h
index 049e72a..e841eed 100644
--- a/CAPI/cpp/grpc/include/absl/types/bad_optional_access.h
+++ b/CAPI/cpp/grpc/include/absl/types/bad_optional_access.h
@@ -29,48 +29,52 @@
 
 #include <optional>
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_optional_access;
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    using std::bad_optional_access;
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_OPTIONAL
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// -----------------------------------------------------------------------------
-// bad_optional_access
-// -----------------------------------------------------------------------------
-//
-// An `absl::bad_optional_access` type is an exception type that is thrown when
-// attempting to access an `absl::optional` object that does not contain a
-// value.
-//
-// Example:
-//
-//   absl::optional<int> o;
-//
-//   try {
-//     int n = o.value();
-//   } catch(const absl::bad_optional_access& e) {
-//     std::cout << "Bad optional access: " << e.what() << '\n';
-//   }
-class bad_optional_access : public std::exception {
- public:
-  bad_optional_access() = default;
-  ~bad_optional_access() override;
-  const char* what() const noexcept override;
-};
+    // -----------------------------------------------------------------------------
+    // bad_optional_access
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::bad_optional_access` type is an exception type that is thrown when
+    // attempting to access an `absl::optional` object that does not contain a
+    // value.
+    //
+    // Example:
+    //
+    //   absl::optional<int> o;
+    //
+    //   try {
+    //     int n = o.value();
+    //   } catch(const absl::bad_optional_access& e) {
+    //     std::cout << "Bad optional access: " << e.what() << '\n';
+    //   }
+    class bad_optional_access : public std::exception
+    {
+    public:
+        bad_optional_access() = default;
+        ~bad_optional_access() override;
+        const char* what() const noexcept override;
+    };
 
-namespace optional_internal {
+    namespace optional_internal
+    {
 
-// throw delegator
-[[noreturn]] ABSL_DLL void throw_bad_optional_access();
+        // throw delegator
+        [[noreturn]] ABSL_DLL void throw_bad_optional_access();
 
-}  // namespace optional_internal
-ABSL_NAMESPACE_END
+    }  // namespace optional_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_USES_STD_OPTIONAL
diff --git a/CAPI/cpp/grpc/include/absl/types/bad_variant_access.h b/CAPI/cpp/grpc/include/absl/types/bad_variant_access.h
index 8ab215e..12c7ebf 100644
--- a/CAPI/cpp/grpc/include/absl/types/bad_variant_access.h
+++ b/CAPI/cpp/grpc/include/absl/types/bad_variant_access.h
@@ -29,52 +29,56 @@
 
 #include <variant>
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_variant_access;
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    using std::bad_variant_access;
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_VARIANT
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
 
-// -----------------------------------------------------------------------------
-// bad_variant_access
-// -----------------------------------------------------------------------------
-//
-// An `absl::bad_variant_access` type is an exception type that is thrown in
-// the following cases:
-//
-//   * Calling `absl::get(absl::variant) with an index or type that does not
-//     match the currently selected alternative type
-//   * Calling `absl::visit on an `absl::variant` that is in the
-//     `variant::valueless_by_exception` state.
-//
-// Example:
-//
-//   absl::variant<int, std::string> v;
-//   v = 1;
-//   try {
-//     absl::get<std::string>(v);
-//   } catch(const absl::bad_variant_access& e) {
-//     std::cout << "Bad variant access: " << e.what() << '\n';
-//   }
-class bad_variant_access : public std::exception {
- public:
-  bad_variant_access() noexcept = default;
-  ~bad_variant_access() override;
-  const char* what() const noexcept override;
-};
+    // -----------------------------------------------------------------------------
+    // bad_variant_access
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::bad_variant_access` type is an exception type that is thrown in
+    // the following cases:
+    //
+    //   * Calling `absl::get(absl::variant) with an index or type that does not
+    //     match the currently selected alternative type
+    //   * Calling `absl::visit on an `absl::variant` that is in the
+    //     `variant::valueless_by_exception` state.
+    //
+    // Example:
+    //
+    //   absl::variant<int, std::string> v;
+    //   v = 1;
+    //   try {
+    //     absl::get<std::string>(v);
+    //   } catch(const absl::bad_variant_access& e) {
+    //     std::cout << "Bad variant access: " << e.what() << '\n';
+    //   }
+    class bad_variant_access : public std::exception
+    {
+    public:
+        bad_variant_access() noexcept = default;
+        ~bad_variant_access() override;
+        const char* what() const noexcept override;
+    };
 
-namespace variant_internal {
+    namespace variant_internal
+    {
 
-[[noreturn]] ABSL_DLL void ThrowBadVariantAccess();
-[[noreturn]] ABSL_DLL void Rethrow();
+        [[noreturn]] ABSL_DLL void ThrowBadVariantAccess();
+        [[noreturn]] ABSL_DLL void Rethrow();
 
-}  // namespace variant_internal
-ABSL_NAMESPACE_END
+    }  // namespace variant_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_USES_STD_VARIANT
diff --git a/CAPI/cpp/grpc/include/absl/types/compare.h b/CAPI/cpp/grpc/include/absl/types/compare.h
index 19b076e..9e227fc 100644
--- a/CAPI/cpp/grpc/include/absl/types/compare.h
+++ b/CAPI/cpp/grpc/include/absl/types/compare.h
@@ -38,47 +38,61 @@
 #include "absl/base/attributes.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace compare_internal {
-
-using value_type = int8_t;
-
-template <typename T>
-struct Fail {
-  static_assert(sizeof(T) < 0, "Only literal `0` is allowed.");
-};
-
-// We need the NullPtrT template to avoid triggering the modernize-use-nullptr
-// ClangTidy warning in user code.
-template <typename NullPtrT = std::nullptr_t>
-struct OnlyLiteralZero {
-  constexpr OnlyLiteralZero(NullPtrT) noexcept {}  // NOLINT
-
-  // Fails compilation when `nullptr` or integral type arguments other than
-  // `int` are passed. This constructor doesn't accept `int` because literal `0`
-  // has type `int`. Literal `0` arguments will be implicitly converted to
-  // `std::nullptr_t` and accepted by the above constructor, while other `int`
-  // arguments will fail to be converted and cause compilation failure.
-  template <
-      typename T,
-      typename = typename std::enable_if<
-          std::is_same<T, std::nullptr_t>::value ||
-          (std::is_integral<T>::value && !std::is_same<T, int>::value)>::type,
-      typename = typename Fail<T>::type>
-  OnlyLiteralZero(T);  // NOLINT
-};
-
-enum class eq : value_type {
-  equal = 0,
-  equivalent = equal,
-  nonequal = 1,
-  nonequivalent = nonequal,
-};
-
-enum class ord : value_type { less = -1, greater = 1 };
-
-enum class ncmp : value_type { unordered = -127 };
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace compare_internal
+    {
+
+        using value_type = int8_t;
+
+        template<typename T>
+        struct Fail
+        {
+            static_assert(sizeof(T) < 0, "Only literal `0` is allowed.");
+        };
+
+        // We need the NullPtrT template to avoid triggering the modernize-use-nullptr
+        // ClangTidy warning in user code.
+        template<typename NullPtrT = std::nullptr_t>
+        struct OnlyLiteralZero
+        {
+            constexpr OnlyLiteralZero(NullPtrT) noexcept
+            {
+            }  // NOLINT
+
+            // Fails compilation when `nullptr` or integral type arguments other than
+            // `int` are passed. This constructor doesn't accept `int` because literal `0`
+            // has type `int`. Literal `0` arguments will be implicitly converted to
+            // `std::nullptr_t` and accepted by the above constructor, while other `int`
+            // arguments will fail to be converted and cause compilation failure.
+            template<
+                typename T,
+                typename = typename std::enable_if<
+                    std::is_same<T, std::nullptr_t>::value ||
+                    (std::is_integral<T>::value && !std::is_same<T, int>::value)>::type,
+                typename = typename Fail<T>::type>
+            OnlyLiteralZero(T);  // NOLINT
+        };
+
+        enum class eq : value_type
+        {
+            equal = 0,
+            equivalent = equal,
+            nonequal = 1,
+            nonequivalent = nonequal,
+        };
+
+        enum class ord : value_type
+        {
+            less = -1,
+            greater = 1
+        };
+
+        enum class ncmp : value_type
+        {
+            unordered = -127
+        };
 
 // Define macros to allow for creation or emulation of C++17 inline variables
 // based on whether the feature is supported. Note: we can't use
@@ -90,511 +104,578 @@ enum class ncmp : value_type { unordered = -127 };
 #define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) static_assert(true, "")
 
 #define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) \
-  static const type name
+    static const type name
 
 #define ABSL_COMPARE_INLINE_INIT(type, name, init) \
-  inline constexpr type type::name(init)
+    inline constexpr type type::name(init)
 
 #else  // __cpp_inline_variables
 
 #define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) \
-  ABSL_CONST_INIT static const T name
+    ABSL_CONST_INIT static const T name
 
 // A no-op expansion that can be followed by a semicolon at class level.
 #define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) static_assert(true, "")
 
 #define ABSL_COMPARE_INLINE_INIT(type, name, init) \
-  template <typename T>                            \
-  const T compare_internal::type##_base<T>::name(init)
+    template<typename T>                           \
+    const T compare_internal::type##_base<T>::name(init)
 
 #endif  // __cpp_inline_variables
 
-// These template base classes allow for defining the values of the constants
-// in the header file (for performance) without using inline variables (which
-// aren't available in C++11).
-template <typename T>
-struct weak_equality_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
-};
-
-template <typename T>
-struct strong_equality_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequal);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
-};
-
-template <typename T>
-struct partial_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(unordered);
-};
-
-template <typename T>
-struct weak_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
-};
-
-template <typename T>
-struct strong_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
-};
-
-}  // namespace compare_internal
-
-class weak_equality
-    : public compare_internal::weak_equality_base<weak_equality> {
-  explicit constexpr weak_equality(compare_internal::eq v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  friend struct compare_internal::weak_equality_base<weak_equality>;
-
- public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, nonequivalent);
-
-  // Comparisons
-  friend constexpr bool operator==(
-      weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ == 0;
-  }
-  friend constexpr bool operator!=(
-      weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ != 0;
-  }
-  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
-                                   weak_equality v) noexcept {
-    return 0 == v.value_;
-  }
-  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
-                                   weak_equality v) noexcept {
-    return 0 != v.value_;
-  }
-  friend constexpr bool operator==(weak_equality v1,
-                                   weak_equality v2) noexcept {
-    return v1.value_ == v2.value_;
-  }
-  friend constexpr bool operator!=(weak_equality v1,
-                                   weak_equality v2) noexcept {
-    return v1.value_ != v2.value_;
-  }
-
- private:
-  compare_internal::value_type value_;
-};
-ABSL_COMPARE_INLINE_INIT(weak_equality, equivalent,
-                         compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(weak_equality, nonequivalent,
-                         compare_internal::eq::nonequivalent);
-
-class strong_equality
-    : public compare_internal::strong_equality_base<strong_equality> {
-  explicit constexpr strong_equality(compare_internal::eq v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  friend struct compare_internal::strong_equality_base<strong_equality>;
-
- public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equal);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequal);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequivalent);
-
-  // Conversion
-  constexpr operator weak_equality() const noexcept {  // NOLINT
-    return value_ == 0 ? weak_equality::equivalent
-                       : weak_equality::nonequivalent;
-  }
-  // Comparisons
-  friend constexpr bool operator==(
-      strong_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ == 0;
-  }
-  friend constexpr bool operator!=(
-      strong_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ != 0;
-  }
-  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
-                                   strong_equality v) noexcept {
-    return 0 == v.value_;
-  }
-  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
-                                   strong_equality v) noexcept {
-    return 0 != v.value_;
-  }
-  friend constexpr bool operator==(strong_equality v1,
-                                   strong_equality v2) noexcept {
-    return v1.value_ == v2.value_;
-  }
-  friend constexpr bool operator!=(strong_equality v1,
-                                   strong_equality v2) noexcept {
-    return v1.value_ != v2.value_;
-  }
-
- private:
-  compare_internal::value_type value_;
-};
-ABSL_COMPARE_INLINE_INIT(strong_equality, equal, compare_internal::eq::equal);
-ABSL_COMPARE_INLINE_INIT(strong_equality, nonequal,
-                         compare_internal::eq::nonequal);
-ABSL_COMPARE_INLINE_INIT(strong_equality, equivalent,
-                         compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(strong_equality, nonequivalent,
-                         compare_internal::eq::nonequivalent);
-
-class partial_ordering
-    : public compare_internal::partial_ordering_base<partial_ordering> {
-  explicit constexpr partial_ordering(compare_internal::eq v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  explicit constexpr partial_ordering(compare_internal::ord v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  explicit constexpr partial_ordering(compare_internal::ncmp v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  friend struct compare_internal::partial_ordering_base<partial_ordering>;
-
-  constexpr bool is_ordered() const noexcept {
-    return value_ !=
-           compare_internal::value_type(compare_internal::ncmp::unordered);
-  }
-
- public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered);
-
-  // Conversion
-  constexpr operator weak_equality() const noexcept {  // NOLINT
-    return value_ == 0 ? weak_equality::equivalent
-                       : weak_equality::nonequivalent;
-  }
-  // Comparisons
-  friend constexpr bool operator==(
-      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.is_ordered() && v.value_ == 0;
-  }
-  friend constexpr bool operator!=(
-      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return !v.is_ordered() || v.value_ != 0;
-  }
-  friend constexpr bool operator<(
-      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.is_ordered() && v.value_ < 0;
-  }
-  friend constexpr bool operator<=(
-      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.is_ordered() && v.value_ <= 0;
-  }
-  friend constexpr bool operator>(
-      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.is_ordered() && v.value_ > 0;
-  }
-  friend constexpr bool operator>=(
-      partial_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.is_ordered() && v.value_ >= 0;
-  }
-  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
-                                   partial_ordering v) noexcept {
-    return v.is_ordered() && 0 == v.value_;
-  }
-  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
-                                   partial_ordering v) noexcept {
-    return !v.is_ordered() || 0 != v.value_;
-  }
-  friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
-                                  partial_ordering v) noexcept {
-    return v.is_ordered() && 0 < v.value_;
-  }
-  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
-                                   partial_ordering v) noexcept {
-    return v.is_ordered() && 0 <= v.value_;
-  }
-  friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
-                                  partial_ordering v) noexcept {
-    return v.is_ordered() && 0 > v.value_;
-  }
-  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
-                                   partial_ordering v) noexcept {
-    return v.is_ordered() && 0 >= v.value_;
-  }
-  friend constexpr bool operator==(partial_ordering v1,
-                                   partial_ordering v2) noexcept {
-    return v1.value_ == v2.value_;
-  }
-  friend constexpr bool operator!=(partial_ordering v1,
-                                   partial_ordering v2) noexcept {
-    return v1.value_ != v2.value_;
-  }
-
- private:
-  compare_internal::value_type value_;
-};
-ABSL_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, equivalent,
-                         compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, greater,
-                         compare_internal::ord::greater);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, unordered,
-                         compare_internal::ncmp::unordered);
-
-class weak_ordering
-    : public compare_internal::weak_ordering_base<weak_ordering> {
-  explicit constexpr weak_ordering(compare_internal::eq v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  explicit constexpr weak_ordering(compare_internal::ord v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  friend struct compare_internal::weak_ordering_base<weak_ordering>;
-
- public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater);
-
-  // Conversions
-  constexpr operator weak_equality() const noexcept {  // NOLINT
-    return value_ == 0 ? weak_equality::equivalent
-                       : weak_equality::nonequivalent;
-  }
-  constexpr operator partial_ordering() const noexcept {  // NOLINT
-    return value_ == 0 ? partial_ordering::equivalent
-                       : (value_ < 0 ? partial_ordering::less
-                                     : partial_ordering::greater);
-  }
-  // Comparisons
-  friend constexpr bool operator==(
-      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ == 0;
-  }
-  friend constexpr bool operator!=(
-      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ != 0;
-  }
-  friend constexpr bool operator<(
-      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ < 0;
-  }
-  friend constexpr bool operator<=(
-      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ <= 0;
-  }
-  friend constexpr bool operator>(
-      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ > 0;
-  }
-  friend constexpr bool operator>=(
-      weak_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ >= 0;
-  }
-  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
-                                   weak_ordering v) noexcept {
-    return 0 == v.value_;
-  }
-  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
-                                   weak_ordering v) noexcept {
-    return 0 != v.value_;
-  }
-  friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
-                                  weak_ordering v) noexcept {
-    return 0 < v.value_;
-  }
-  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
-                                   weak_ordering v) noexcept {
-    return 0 <= v.value_;
-  }
-  friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
-                                  weak_ordering v) noexcept {
-    return 0 > v.value_;
-  }
-  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
-                                   weak_ordering v) noexcept {
-    return 0 >= v.value_;
-  }
-  friend constexpr bool operator==(weak_ordering v1,
-                                   weak_ordering v2) noexcept {
-    return v1.value_ == v2.value_;
-  }
-  friend constexpr bool operator!=(weak_ordering v1,
-                                   weak_ordering v2) noexcept {
-    return v1.value_ != v2.value_;
-  }
-
- private:
-  compare_internal::value_type value_;
-};
-ABSL_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(weak_ordering, equivalent,
-                         compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(weak_ordering, greater,
-                         compare_internal::ord::greater);
-
-class strong_ordering
-    : public compare_internal::strong_ordering_base<strong_ordering> {
-  explicit constexpr strong_ordering(compare_internal::eq v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  explicit constexpr strong_ordering(compare_internal::ord v) noexcept
-      : value_(static_cast<compare_internal::value_type>(v)) {}
-  friend struct compare_internal::strong_ordering_base<strong_ordering>;
-
- public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater);
-
-  // Conversions
-  constexpr operator weak_equality() const noexcept {  // NOLINT
-    return value_ == 0 ? weak_equality::equivalent
-                       : weak_equality::nonequivalent;
-  }
-  constexpr operator strong_equality() const noexcept {  // NOLINT
-    return value_ == 0 ? strong_equality::equal : strong_equality::nonequal;
-  }
-  constexpr operator partial_ordering() const noexcept {  // NOLINT
-    return value_ == 0 ? partial_ordering::equivalent
-                       : (value_ < 0 ? partial_ordering::less
-                                     : partial_ordering::greater);
-  }
-  constexpr operator weak_ordering() const noexcept {  // NOLINT
-    return value_ == 0
-               ? weak_ordering::equivalent
-               : (value_ < 0 ? weak_ordering::less : weak_ordering::greater);
-  }
-  // Comparisons
-  friend constexpr bool operator==(
-      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ == 0;
-  }
-  friend constexpr bool operator!=(
-      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ != 0;
-  }
-  friend constexpr bool operator<(
-      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ < 0;
-  }
-  friend constexpr bool operator<=(
-      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ <= 0;
-  }
-  friend constexpr bool operator>(
-      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ > 0;
-  }
-  friend constexpr bool operator>=(
-      strong_ordering v, compare_internal::OnlyLiteralZero<>) noexcept {
-    return v.value_ >= 0;
-  }
-  friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>,
-                                   strong_ordering v) noexcept {
-    return 0 == v.value_;
-  }
-  friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>,
-                                   strong_ordering v) noexcept {
-    return 0 != v.value_;
-  }
-  friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>,
-                                  strong_ordering v) noexcept {
-    return 0 < v.value_;
-  }
-  friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>,
-                                   strong_ordering v) noexcept {
-    return 0 <= v.value_;
-  }
-  friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>,
-                                  strong_ordering v) noexcept {
-    return 0 > v.value_;
-  }
-  friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>,
-                                   strong_ordering v) noexcept {
-    return 0 >= v.value_;
-  }
-  friend constexpr bool operator==(strong_ordering v1,
-                                   strong_ordering v2) noexcept {
-    return v1.value_ == v2.value_;
-  }
-  friend constexpr bool operator!=(strong_ordering v1,
-                                   strong_ordering v2) noexcept {
-    return v1.value_ != v2.value_;
-  }
-
- private:
-  compare_internal::value_type value_;
-};
-ABSL_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, equivalent,
-                         compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, greater,
-                         compare_internal::ord::greater);
+        // These template base classes allow for defining the values of the constants
+        // in the header file (for performance) without using inline variables (which
+        // aren't available in C++11).
+        template<typename T>
+        struct weak_equality_base
+        {
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
+        };
+
+        template<typename T>
+        struct strong_equality_base
+        {
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequal);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
+        };
+
+        template<typename T>
+        struct partial_ordering_base
+        {
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(unordered);
+        };
+
+        template<typename T>
+        struct weak_ordering_base
+        {
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+        };
+
+        template<typename T>
+        struct strong_ordering_base
+        {
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+            ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+        };
+
+    }  // namespace compare_internal
+
+    class weak_equality : public compare_internal::weak_equality_base<weak_equality>
+    {
+        explicit constexpr weak_equality(compare_internal::eq v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        friend struct compare_internal::weak_equality_base<weak_equality>;
+
+    public:
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, equivalent);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, nonequivalent);
+
+        // Comparisons
+        friend constexpr bool operator==(
+            weak_equality v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            weak_equality v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>, weak_equality v) noexcept
+        {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>, weak_equality v) noexcept
+        {
+            return 0 != v.value_;
+        }
+        friend constexpr bool operator==(weak_equality v1, weak_equality v2) noexcept
+        {
+            return v1.value_ == v2.value_;
+        }
+        friend constexpr bool operator!=(weak_equality v1, weak_equality v2) noexcept
+        {
+            return v1.value_ != v2.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    ABSL_COMPARE_INLINE_INIT(weak_equality, equivalent, compare_internal::eq::equivalent);
+    ABSL_COMPARE_INLINE_INIT(weak_equality, nonequivalent, compare_internal::eq::nonequivalent);
+
+    class strong_equality : public compare_internal::strong_equality_base<strong_equality>
+    {
+        explicit constexpr strong_equality(compare_internal::eq v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        friend struct compare_internal::strong_equality_base<strong_equality>;
+
+    public:
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equal);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequal);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equivalent);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequivalent);
+
+        // Conversion
+        constexpr operator weak_equality() const noexcept
+        {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent : weak_equality::nonequivalent;
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            strong_equality v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            strong_equality v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>, strong_equality v) noexcept
+        {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>, strong_equality v) noexcept
+        {
+            return 0 != v.value_;
+        }
+        friend constexpr bool operator==(strong_equality v1, strong_equality v2) noexcept
+        {
+            return v1.value_ == v2.value_;
+        }
+        friend constexpr bool operator!=(strong_equality v1, strong_equality v2) noexcept
+        {
+            return v1.value_ != v2.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    ABSL_COMPARE_INLINE_INIT(strong_equality, equal, compare_internal::eq::equal);
+    ABSL_COMPARE_INLINE_INIT(strong_equality, nonequal, compare_internal::eq::nonequal);
+    ABSL_COMPARE_INLINE_INIT(strong_equality, equivalent, compare_internal::eq::equivalent);
+    ABSL_COMPARE_INLINE_INIT(strong_equality, nonequivalent, compare_internal::eq::nonequivalent);
+
+    class partial_ordering : public compare_internal::partial_ordering_base<partial_ordering>
+    {
+        explicit constexpr partial_ordering(compare_internal::eq v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        explicit constexpr partial_ordering(compare_internal::ord v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        explicit constexpr partial_ordering(compare_internal::ncmp v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        friend struct compare_internal::partial_ordering_base<partial_ordering>;
+
+        constexpr bool is_ordered() const noexcept
+        {
+            return value_ !=
+                   compare_internal::value_type(compare_internal::ncmp::unordered);
+        }
+
+    public:
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered);
+
+        // Conversion
+        constexpr operator weak_equality() const noexcept
+        {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent : weak_equality::nonequivalent;
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.is_ordered() && v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return !v.is_ordered() || v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.is_ordered() && v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.is_ordered() && v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.is_ordered() && v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            partial_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.is_ordered() && v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>, partial_ordering v) noexcept
+        {
+            return v.is_ordered() && 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>, partial_ordering v) noexcept
+        {
+            return !v.is_ordered() || 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>, partial_ordering v) noexcept
+        {
+            return v.is_ordered() && 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>, partial_ordering v) noexcept
+        {
+            return v.is_ordered() && 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>, partial_ordering v) noexcept
+        {
+            return v.is_ordered() && 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>, partial_ordering v) noexcept
+        {
+            return v.is_ordered() && 0 >= v.value_;
+        }
+        friend constexpr bool operator==(partial_ordering v1, partial_ordering v2) noexcept
+        {
+            return v1.value_ == v2.value_;
+        }
+        friend constexpr bool operator!=(partial_ordering v1, partial_ordering v2) noexcept
+        {
+            return v1.value_ != v2.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    ABSL_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
+    ABSL_COMPARE_INLINE_INIT(partial_ordering, equivalent, compare_internal::eq::equivalent);
+    ABSL_COMPARE_INLINE_INIT(partial_ordering, greater, compare_internal::ord::greater);
+    ABSL_COMPARE_INLINE_INIT(partial_ordering, unordered, compare_internal::ncmp::unordered);
+
+    class weak_ordering : public compare_internal::weak_ordering_base<weak_ordering>
+    {
+        explicit constexpr weak_ordering(compare_internal::eq v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        explicit constexpr weak_ordering(compare_internal::ord v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        friend struct compare_internal::weak_ordering_base<weak_ordering>;
+
+    public:
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater);
+
+        // Conversions
+        constexpr operator weak_equality() const noexcept
+        {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent : weak_equality::nonequivalent;
+        }
+        constexpr operator partial_ordering() const noexcept
+        {  // NOLINT
+            return value_ == 0 ? partial_ordering::equivalent : (value_ < 0 ? partial_ordering::less : partial_ordering::greater);
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            weak_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>, weak_ordering v) noexcept
+        {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>, weak_ordering v) noexcept
+        {
+            return 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>, weak_ordering v) noexcept
+        {
+            return 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>, weak_ordering v) noexcept
+        {
+            return 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>, weak_ordering v) noexcept
+        {
+            return 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>, weak_ordering v) noexcept
+        {
+            return 0 >= v.value_;
+        }
+        friend constexpr bool operator==(weak_ordering v1, weak_ordering v2) noexcept
+        {
+            return v1.value_ == v2.value_;
+        }
+        friend constexpr bool operator!=(weak_ordering v1, weak_ordering v2) noexcept
+        {
+            return v1.value_ != v2.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    ABSL_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
+    ABSL_COMPARE_INLINE_INIT(weak_ordering, equivalent, compare_internal::eq::equivalent);
+    ABSL_COMPARE_INLINE_INIT(weak_ordering, greater, compare_internal::ord::greater);
+
+    class strong_ordering : public compare_internal::strong_ordering_base<strong_ordering>
+    {
+        explicit constexpr strong_ordering(compare_internal::eq v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        explicit constexpr strong_ordering(compare_internal::ord v) noexcept
+            :
+            value_(static_cast<compare_internal::value_type>(v))
+        {
+        }
+        friend struct compare_internal::strong_ordering_base<strong_ordering>;
+
+    public:
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent);
+        ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater);
+
+        // Conversions
+        constexpr operator weak_equality() const noexcept
+        {  // NOLINT
+            return value_ == 0 ? weak_equality::equivalent : weak_equality::nonequivalent;
+        }
+        constexpr operator strong_equality() const noexcept
+        {  // NOLINT
+            return value_ == 0 ? strong_equality::equal : strong_equality::nonequal;
+        }
+        constexpr operator partial_ordering() const noexcept
+        {  // NOLINT
+            return value_ == 0 ? partial_ordering::equivalent : (value_ < 0 ? partial_ordering::less : partial_ordering::greater);
+        }
+        constexpr operator weak_ordering() const noexcept
+        {  // NOLINT
+            return value_ == 0 ? weak_ordering::equivalent : (value_ < 0 ? weak_ordering::less : weak_ordering::greater);
+        }
+        // Comparisons
+        friend constexpr bool operator==(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ == 0;
+        }
+        friend constexpr bool operator!=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ != 0;
+        }
+        friend constexpr bool operator<(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ < 0;
+        }
+        friend constexpr bool operator<=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ <= 0;
+        }
+        friend constexpr bool operator>(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ > 0;
+        }
+        friend constexpr bool operator>=(
+            strong_ordering v, compare_internal::OnlyLiteralZero<>
+        ) noexcept
+        {
+            return v.value_ >= 0;
+        }
+        friend constexpr bool operator==(compare_internal::OnlyLiteralZero<>, strong_ordering v) noexcept
+        {
+            return 0 == v.value_;
+        }
+        friend constexpr bool operator!=(compare_internal::OnlyLiteralZero<>, strong_ordering v) noexcept
+        {
+            return 0 != v.value_;
+        }
+        friend constexpr bool operator<(compare_internal::OnlyLiteralZero<>, strong_ordering v) noexcept
+        {
+            return 0 < v.value_;
+        }
+        friend constexpr bool operator<=(compare_internal::OnlyLiteralZero<>, strong_ordering v) noexcept
+        {
+            return 0 <= v.value_;
+        }
+        friend constexpr bool operator>(compare_internal::OnlyLiteralZero<>, strong_ordering v) noexcept
+        {
+            return 0 > v.value_;
+        }
+        friend constexpr bool operator>=(compare_internal::OnlyLiteralZero<>, strong_ordering v) noexcept
+        {
+            return 0 >= v.value_;
+        }
+        friend constexpr bool operator==(strong_ordering v1, strong_ordering v2) noexcept
+        {
+            return v1.value_ == v2.value_;
+        }
+        friend constexpr bool operator!=(strong_ordering v1, strong_ordering v2) noexcept
+        {
+            return v1.value_ != v2.value_;
+        }
+
+    private:
+        compare_internal::value_type value_;
+    };
+    ABSL_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
+    ABSL_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
+    ABSL_COMPARE_INLINE_INIT(strong_ordering, equivalent, compare_internal::eq::equivalent);
+    ABSL_COMPARE_INLINE_INIT(strong_ordering, greater, compare_internal::ord::greater);
 
 #undef ABSL_COMPARE_INLINE_BASECLASS_DECL
 #undef ABSL_COMPARE_INLINE_SUBCLASS_DECL
 #undef ABSL_COMPARE_INLINE_INIT
 
-namespace compare_internal {
-// We also provide these comparator adapter functions for internal absl use.
-
-// Helper functions to do a boolean comparison of two keys given a boolean
-// or three-way comparator.
-// SFINAE prevents implicit conversions to bool (such as from int).
-template <typename Bool,
-          absl::enable_if_t<std::is_same<bool, Bool>::value, int> = 0>
-constexpr bool compare_result_as_less_than(const Bool r) { return r; }
-constexpr bool compare_result_as_less_than(const absl::weak_ordering r) {
-  return r < 0;
-}
-
-template <typename Compare, typename K, typename LK>
-constexpr bool do_less_than_comparison(const Compare &compare, const K &x,
-                                       const LK &y) {
-  return compare_result_as_less_than(compare(x, y));
-}
-
-// Helper functions to do a three-way comparison of two keys given a boolean or
-// three-way comparator.
-// SFINAE prevents implicit conversions to int (such as from bool).
-template <typename Int,
-          absl::enable_if_t<std::is_same<int, Int>::value, int> = 0>
-constexpr absl::weak_ordering compare_result_as_ordering(const Int c) {
-  return c < 0 ? absl::weak_ordering::less
-               : c == 0 ? absl::weak_ordering::equivalent
-                        : absl::weak_ordering::greater;
-}
-constexpr absl::weak_ordering compare_result_as_ordering(
-    const absl::weak_ordering c) {
-  return c;
-}
-
-template <
-    typename Compare, typename K, typename LK,
-    absl::enable_if_t<!std::is_same<bool, absl::result_of_t<Compare(
-                                              const K &, const LK &)>>::value,
-                      int> = 0>
-constexpr absl::weak_ordering do_three_way_comparison(const Compare &compare,
-                                                      const K &x, const LK &y) {
-  return compare_result_as_ordering(compare(x, y));
-}
-template <
-    typename Compare, typename K, typename LK,
-    absl::enable_if_t<std::is_same<bool, absl::result_of_t<Compare(
-                                             const K &, const LK &)>>::value,
-                      int> = 0>
-constexpr absl::weak_ordering do_three_way_comparison(const Compare &compare,
-                                                      const K &x, const LK &y) {
-  return compare(x, y) ? absl::weak_ordering::less
-                       : compare(y, x) ? absl::weak_ordering::greater
-                                       : absl::weak_ordering::equivalent;
-}
-
-}  // namespace compare_internal
-ABSL_NAMESPACE_END
+    namespace compare_internal
+    {
+        // We also provide these comparator adapter functions for internal absl use.
+
+        // Helper functions to do a boolean comparison of two keys given a boolean
+        // or three-way comparator.
+        // SFINAE prevents implicit conversions to bool (such as from int).
+        template<typename Bool, absl::enable_if_t<std::is_same<bool, Bool>::value, int> = 0>
+        constexpr bool compare_result_as_less_than(const Bool r)
+        {
+            return r;
+        }
+        constexpr bool compare_result_as_less_than(const absl::weak_ordering r)
+        {
+            return r < 0;
+        }
+
+        template<typename Compare, typename K, typename LK>
+        constexpr bool do_less_than_comparison(const Compare& compare, const K& x, const LK& y)
+        {
+            return compare_result_as_less_than(compare(x, y));
+        }
+
+        // Helper functions to do a three-way comparison of two keys given a boolean or
+        // three-way comparator.
+        // SFINAE prevents implicit conversions to int (such as from bool).
+        template<typename Int, absl::enable_if_t<std::is_same<int, Int>::value, int> = 0>
+        constexpr absl::weak_ordering compare_result_as_ordering(const Int c)
+        {
+            return c < 0 ? absl::weak_ordering::less : c == 0 ? absl::weak_ordering::equivalent :
+                                                                absl::weak_ordering::greater;
+        }
+        constexpr absl::weak_ordering compare_result_as_ordering(
+            const absl::weak_ordering c
+        )
+        {
+            return c;
+        }
+
+        template<
+            typename Compare,
+            typename K,
+            typename LK,
+            absl::enable_if_t<!std::is_same<bool, absl::result_of_t<Compare(const K&, const LK&)>>::value, int> = 0>
+        constexpr absl::weak_ordering do_three_way_comparison(const Compare& compare, const K& x, const LK& y)
+        {
+            return compare_result_as_ordering(compare(x, y));
+        }
+        template<
+            typename Compare,
+            typename K,
+            typename LK,
+            absl::enable_if_t<std::is_same<bool, absl::result_of_t<Compare(const K&, const LK&)>>::value, int> = 0>
+        constexpr absl::weak_ordering do_three_way_comparison(const Compare& compare, const K& x, const LK& y)
+        {
+            return compare(x, y) ? absl::weak_ordering::less : compare(y, x) ? absl::weak_ordering::greater :
+                                                                               absl::weak_ordering::equivalent;
+        }
+
+    }  // namespace compare_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TYPES_COMPARE_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_aliases.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_aliases.h
index 0cc6884..e246cbe 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/conformance_aliases.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_aliases.h
@@ -25,421 +25,462 @@
 #include "absl/types/internal/conformance_archetype.h"
 #include "absl/types/internal/conformance_profile.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace types_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace types_internal
+    {
 
 // Creates both a Profile and a corresponding Archetype with root name "name".
-#define ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(name, ...)                \
-  struct name##Profile : __VA_ARGS__ {};                                    \
-                                                                            \
-  using name##Archetype = ::absl::types_internal::Archetype<name##Profile>; \
-                                                                            \
-  template <class AbslInternalProfileTag>                                   \
-  using name##Archetype##_ = ::absl::types_internal::Archetype<             \
-      ::absl::types_internal::StrongProfileTypedef<name##Profile,           \
-                                                   AbslInternalProfileTag>>
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasTrivialDefaultConstructor,
-    ConformanceProfile<default_constructible::trivial>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowDefaultConstructor,
-    ConformanceProfile<default_constructible::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasDefaultConstructor, ConformanceProfile<default_constructible::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasTrivialMoveConstructor, ConformanceProfile<default_constructible::maybe,
-                                                  move_constructible::trivial>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowMoveConstructor, ConformanceProfile<default_constructible::maybe,
-                                                  move_constructible::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasMoveConstructor,
-    ConformanceProfile<default_constructible::maybe, move_constructible::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasTrivialCopyConstructor,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::trivial>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowCopyConstructor,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasCopyConstructor,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasTrivialMoveAssign,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::trivial>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowMoveAssign,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasMoveAssign,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasTrivialCopyAssign,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::trivial>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowCopyAssign,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasCopyAssign,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasTrivialDestructor,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::trivial>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowDestructor,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasDestructor,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowEquality,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::maybe,
-                       equality_comparable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasEquality,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::maybe,
-                       equality_comparable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowInequality,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::maybe,
-                       equality_comparable::maybe,
-                       inequality_comparable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasInequality,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::maybe,
-                       equality_comparable::maybe, inequality_comparable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowLessThan,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::maybe,
-                       equality_comparable::maybe, inequality_comparable::maybe,
-                       less_than_comparable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasLessThan,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::maybe,
-                       equality_comparable::maybe, inequality_comparable::maybe,
-                       less_than_comparable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowLessEqual,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::maybe,
-                       equality_comparable::maybe, inequality_comparable::maybe,
-                       less_than_comparable::maybe,
-                       less_equal_comparable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasLessEqual,
-    ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
-                       copy_constructible::maybe, move_assignable::maybe,
-                       copy_assignable::maybe, destructible::maybe,
-                       equality_comparable::maybe, inequality_comparable::maybe,
-                       less_than_comparable::maybe,
-                       less_equal_comparable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowGreaterEqual,
-    ConformanceProfile<
-        default_constructible::maybe, move_constructible::maybe,
-        copy_constructible::maybe, move_assignable::maybe,
-        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
-        inequality_comparable::maybe, less_than_comparable::maybe,
-        less_equal_comparable::maybe, greater_equal_comparable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasGreaterEqual,
-    ConformanceProfile<
-        default_constructible::maybe, move_constructible::maybe,
-        copy_constructible::maybe, move_assignable::maybe,
-        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
-        inequality_comparable::maybe, less_than_comparable::maybe,
-        less_equal_comparable::maybe, greater_equal_comparable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowGreaterThan,
-    ConformanceProfile<
-        default_constructible::maybe, move_constructible::maybe,
-        copy_constructible::maybe, move_assignable::maybe,
-        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
-        inequality_comparable::maybe, less_than_comparable::maybe,
-        less_equal_comparable::maybe, greater_equal_comparable::maybe,
-        greater_than_comparable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasGreaterThan,
-    ConformanceProfile<
-        default_constructible::maybe, move_constructible::maybe,
-        copy_constructible::maybe, move_assignable::maybe,
-        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
-        inequality_comparable::maybe, less_than_comparable::maybe,
-        less_equal_comparable::maybe, greater_equal_comparable::maybe,
-        greater_than_comparable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasNothrowSwap,
-    ConformanceProfile<
-        default_constructible::maybe, move_constructible::maybe,
-        copy_constructible::maybe, move_assignable::maybe,
-        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
-        inequality_comparable::maybe, less_than_comparable::maybe,
-        less_equal_comparable::maybe, greater_equal_comparable::maybe,
-        greater_than_comparable::maybe, swappable::nothrow>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasSwap,
-    ConformanceProfile<
-        default_constructible::maybe, move_constructible::maybe,
-        copy_constructible::maybe, move_assignable::maybe,
-        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
-        inequality_comparable::maybe, less_than_comparable::maybe,
-        less_equal_comparable::maybe, greater_equal_comparable::maybe,
-        greater_than_comparable::maybe, swappable::yes>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HasStdHashSpecialization,
-    ConformanceProfile<
-        default_constructible::maybe, move_constructible::maybe,
-        copy_constructible::maybe, move_assignable::maybe,
-        copy_assignable::maybe, destructible::maybe, equality_comparable::maybe,
-        inequality_comparable::maybe, less_than_comparable::maybe,
-        less_equal_comparable::maybe, greater_equal_comparable::maybe,
-        greater_than_comparable::maybe, swappable::maybe, hashable::yes>);
-
-////////////////////////////////////////////////////////////////////////////////
-////     The remaining aliases are combinations of the previous aliases.    ////
-////////////////////////////////////////////////////////////////////////////////
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    Equatable, CombineProfiles<HasEqualityProfile, HasInequalityProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    Comparable,
-    CombineProfiles<EquatableProfile, HasLessThanProfile, HasLessEqualProfile,
-                    HasGreaterEqualProfile, HasGreaterThanProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    NothrowEquatable,
-    CombineProfiles<HasNothrowEqualityProfile, HasNothrowInequalityProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    NothrowComparable,
-    CombineProfiles<NothrowEquatableProfile, HasNothrowLessThanProfile,
-                    HasNothrowLessEqualProfile, HasNothrowGreaterEqualProfile,
-                    HasNothrowGreaterThanProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    Value,
-    CombineProfiles<HasNothrowMoveConstructorProfile, HasCopyConstructorProfile,
-                    HasNothrowMoveAssignProfile, HasCopyAssignProfile,
-                    HasNothrowDestructorProfile, HasNothrowSwapProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    EquatableValue, CombineProfiles<EquatableProfile, ValueProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    ComparableValue, CombineProfiles<ComparableProfile, ValueProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    DefaultConstructibleValue,
-    CombineProfiles<HasDefaultConstructorProfile, ValueProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    NothrowMoveConstructible, CombineProfiles<HasNothrowMoveConstructorProfile,
-                                              HasNothrowDestructorProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    EquatableNothrowMoveConstructible,
-    CombineProfiles<EquatableProfile, NothrowMoveConstructibleProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    ComparableNothrowMoveConstructible,
-    CombineProfiles<ComparableProfile, NothrowMoveConstructibleProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    DefaultConstructibleNothrowMoveConstructible,
-    CombineProfiles<HasDefaultConstructorProfile,
-                    NothrowMoveConstructibleProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    CopyConstructible,
-    CombineProfiles<HasNothrowMoveConstructorProfile, HasCopyConstructorProfile,
-                    HasNothrowDestructorProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    EquatableCopyConstructible,
-    CombineProfiles<EquatableProfile, CopyConstructibleProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    ComparableCopyConstructible,
-    CombineProfiles<ComparableProfile, CopyConstructibleProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    DefaultConstructibleCopyConstructible,
-    CombineProfiles<HasDefaultConstructorProfile, CopyConstructibleProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    NothrowMovable,
-    CombineProfiles<HasNothrowMoveConstructorProfile,
-                    HasNothrowMoveAssignProfile, HasNothrowDestructorProfile,
-                    HasNothrowSwapProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    EquatableNothrowMovable,
-    CombineProfiles<EquatableProfile, NothrowMovableProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    ComparableNothrowMovable,
-    CombineProfiles<ComparableProfile, NothrowMovableProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    DefaultConstructibleNothrowMovable,
-    CombineProfiles<HasDefaultConstructorProfile, NothrowMovableProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    TrivialSpecialMemberFunctions,
-    CombineProfiles<HasTrivialDefaultConstructorProfile,
-                    HasTrivialMoveConstructorProfile,
-                    HasTrivialCopyConstructorProfile,
-                    HasTrivialMoveAssignProfile, HasTrivialCopyAssignProfile,
-                    HasTrivialDestructorProfile, HasNothrowSwapProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    TriviallyComplete,
-    CombineProfiles<TrivialSpecialMemberFunctionsProfile, ComparableProfile,
-                    HasStdHashSpecializationProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HashableNothrowMoveConstructible,
-    CombineProfiles<HasStdHashSpecializationProfile,
-                    NothrowMoveConstructibleProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HashableCopyConstructible,
-    CombineProfiles<HasStdHashSpecializationProfile, CopyConstructibleProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HashableNothrowMovable,
-    CombineProfiles<HasStdHashSpecializationProfile, NothrowMovableProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    HashableValue,
-    CombineProfiles<HasStdHashSpecializationProfile, ValueProfile>);
-
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
-    ComparableHashableValue,
-    CombineProfiles<HashableValueProfile, ComparableProfile>);
-
-// The "preferred" profiles that we support in Abseil.
-template <template <class...> class Receiver>
-using ExpandBasicProfiles =
-    Receiver<NothrowMoveConstructibleProfile, CopyConstructibleProfile,
-             NothrowMovableProfile, ValueProfile>;
-
-// The basic profiles except that they are also all Equatable.
-template <template <class...> class Receiver>
-using ExpandBasicEquatableProfiles =
-    Receiver<EquatableNothrowMoveConstructibleProfile,
-             EquatableCopyConstructibleProfile, EquatableNothrowMovableProfile,
-             EquatableValueProfile>;
-
-// The basic profiles except that they are also all Comparable.
-template <template <class...> class Receiver>
-using ExpandBasicComparableProfiles =
-    Receiver<ComparableNothrowMoveConstructibleProfile,
-             ComparableCopyConstructibleProfile,
-             ComparableNothrowMovableProfile, ComparableValueProfile>;
-
-// The basic profiles except that they are also all Hashable.
-template <template <class...> class Receiver>
-using ExpandBasicHashableProfiles =
-    Receiver<HashableNothrowMoveConstructibleProfile,
-             HashableCopyConstructibleProfile, HashableNothrowMovableProfile,
-             HashableValueProfile>;
-
-// The basic profiles except that they are also all DefaultConstructible.
-template <template <class...> class Receiver>
-using ExpandBasicDefaultConstructibleProfiles =
-    Receiver<DefaultConstructibleNothrowMoveConstructibleProfile,
-             DefaultConstructibleCopyConstructibleProfile,
-             DefaultConstructibleNothrowMovableProfile,
-             DefaultConstructibleValueProfile>;
-
-// The type profiles that we support in Abseil (all of the previous lists).
-template <template <class...> class Receiver>
-using ExpandSupportedProfiles = Receiver<
-    NothrowMoveConstructibleProfile, CopyConstructibleProfile,
-    NothrowMovableProfile, ValueProfile,
-    EquatableNothrowMoveConstructibleProfile, EquatableCopyConstructibleProfile,
-    EquatableNothrowMovableProfile, EquatableValueProfile,
-    ComparableNothrowMoveConstructibleProfile,
-    ComparableCopyConstructibleProfile, ComparableNothrowMovableProfile,
-    ComparableValueProfile, DefaultConstructibleNothrowMoveConstructibleProfile,
-    DefaultConstructibleCopyConstructibleProfile,
-    DefaultConstructibleNothrowMovableProfile, DefaultConstructibleValueProfile,
-    HashableNothrowMoveConstructibleProfile, HashableCopyConstructibleProfile,
-    HashableNothrowMovableProfile, HashableValueProfile>;
-
-// TODO(calabrese) Include types that have throwing move constructors, since in
-// practice we still need to support them because of standard library types with
-// (potentially) non-noexcept moves.
-
-}  // namespace types_internal
-ABSL_NAMESPACE_END
+#define ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(name, ...)                  \
+    struct name##Profile : __VA_ARGS__                                        \
+    {                                                                         \
+    };                                                                        \
+                                                                              \
+    using name##Archetype = ::absl::types_internal::Archetype<name##Profile>; \
+                                                                              \
+    template<class AbslInternalProfileTag>                                    \
+    using name##Archetype##_ = ::absl::types_internal::Archetype<             \
+        ::absl::types_internal::StrongProfileTypedef<name##Profile, AbslInternalProfileTag>>
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasTrivialDefaultConstructor,
+            ConformanceProfile<default_constructible::trivial>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowDefaultConstructor,
+            ConformanceProfile<default_constructible::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasDefaultConstructor, ConformanceProfile<default_constructible::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasTrivialMoveConstructor, ConformanceProfile<default_constructible::maybe, move_constructible::trivial>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowMoveConstructor, ConformanceProfile<default_constructible::maybe, move_constructible::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasMoveConstructor,
+            ConformanceProfile<default_constructible::maybe, move_constructible::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasTrivialCopyConstructor,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::trivial>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowCopyConstructor,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasCopyConstructor,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasTrivialMoveAssign,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::trivial>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowMoveAssign,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasMoveAssign,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasTrivialCopyAssign,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::trivial>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowCopyAssign,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasCopyAssign,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasTrivialDestructor,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::trivial>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowDestructor,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasDestructor,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowEquality,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::maybe, equality_comparable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasEquality,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::maybe, equality_comparable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowInequality,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::maybe, equality_comparable::maybe, inequality_comparable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasInequality,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::maybe, equality_comparable::maybe, inequality_comparable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowLessThan,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::maybe, equality_comparable::maybe, inequality_comparable::maybe, less_than_comparable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasLessThan,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::maybe, equality_comparable::maybe, inequality_comparable::maybe, less_than_comparable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowLessEqual,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::maybe, equality_comparable::maybe, inequality_comparable::maybe, less_than_comparable::maybe, less_equal_comparable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasLessEqual,
+            ConformanceProfile<default_constructible::maybe, move_constructible::maybe, copy_constructible::maybe, move_assignable::maybe, copy_assignable::maybe, destructible::maybe, equality_comparable::maybe, inequality_comparable::maybe, less_than_comparable::maybe, less_equal_comparable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowGreaterEqual,
+            ConformanceProfile<
+                default_constructible::maybe,
+                move_constructible::maybe,
+                copy_constructible::maybe,
+                move_assignable::maybe,
+                copy_assignable::maybe,
+                destructible::maybe,
+                equality_comparable::maybe,
+                inequality_comparable::maybe,
+                less_than_comparable::maybe,
+                less_equal_comparable::maybe,
+                greater_equal_comparable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasGreaterEqual,
+            ConformanceProfile<
+                default_constructible::maybe,
+                move_constructible::maybe,
+                copy_constructible::maybe,
+                move_assignable::maybe,
+                copy_assignable::maybe,
+                destructible::maybe,
+                equality_comparable::maybe,
+                inequality_comparable::maybe,
+                less_than_comparable::maybe,
+                less_equal_comparable::maybe,
+                greater_equal_comparable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowGreaterThan,
+            ConformanceProfile<
+                default_constructible::maybe,
+                move_constructible::maybe,
+                copy_constructible::maybe,
+                move_assignable::maybe,
+                copy_assignable::maybe,
+                destructible::maybe,
+                equality_comparable::maybe,
+                inequality_comparable::maybe,
+                less_than_comparable::maybe,
+                less_equal_comparable::maybe,
+                greater_equal_comparable::maybe,
+                greater_than_comparable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasGreaterThan,
+            ConformanceProfile<
+                default_constructible::maybe,
+                move_constructible::maybe,
+                copy_constructible::maybe,
+                move_assignable::maybe,
+                copy_assignable::maybe,
+                destructible::maybe,
+                equality_comparable::maybe,
+                inequality_comparable::maybe,
+                less_than_comparable::maybe,
+                less_equal_comparable::maybe,
+                greater_equal_comparable::maybe,
+                greater_than_comparable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasNothrowSwap,
+            ConformanceProfile<
+                default_constructible::maybe,
+                move_constructible::maybe,
+                copy_constructible::maybe,
+                move_assignable::maybe,
+                copy_assignable::maybe,
+                destructible::maybe,
+                equality_comparable::maybe,
+                inequality_comparable::maybe,
+                less_than_comparable::maybe,
+                less_equal_comparable::maybe,
+                greater_equal_comparable::maybe,
+                greater_than_comparable::maybe,
+                swappable::nothrow>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasSwap,
+            ConformanceProfile<
+                default_constructible::maybe,
+                move_constructible::maybe,
+                copy_constructible::maybe,
+                move_assignable::maybe,
+                copy_assignable::maybe,
+                destructible::maybe,
+                equality_comparable::maybe,
+                inequality_comparable::maybe,
+                less_than_comparable::maybe,
+                less_equal_comparable::maybe,
+                greater_equal_comparable::maybe,
+                greater_than_comparable::maybe,
+                swappable::yes>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HasStdHashSpecialization,
+            ConformanceProfile<
+                default_constructible::maybe,
+                move_constructible::maybe,
+                copy_constructible::maybe,
+                move_assignable::maybe,
+                copy_assignable::maybe,
+                destructible::maybe,
+                equality_comparable::maybe,
+                inequality_comparable::maybe,
+                less_than_comparable::maybe,
+                less_equal_comparable::maybe,
+                greater_equal_comparable::maybe,
+                greater_than_comparable::maybe,
+                swappable::maybe,
+                hashable::yes>
+        );
+
+        ////////////////////////////////////////////////////////////////////////////////
+        ////     The remaining aliases are combinations of the previous aliases.    ////
+        ////////////////////////////////////////////////////////////////////////////////
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            Equatable, CombineProfiles<HasEqualityProfile, HasInequalityProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            Comparable,
+            CombineProfiles<EquatableProfile, HasLessThanProfile, HasLessEqualProfile, HasGreaterEqualProfile, HasGreaterThanProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            NothrowEquatable,
+            CombineProfiles<HasNothrowEqualityProfile, HasNothrowInequalityProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            NothrowComparable,
+            CombineProfiles<NothrowEquatableProfile, HasNothrowLessThanProfile, HasNothrowLessEqualProfile, HasNothrowGreaterEqualProfile, HasNothrowGreaterThanProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            Value,
+            CombineProfiles<HasNothrowMoveConstructorProfile, HasCopyConstructorProfile, HasNothrowMoveAssignProfile, HasCopyAssignProfile, HasNothrowDestructorProfile, HasNothrowSwapProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            EquatableValue, CombineProfiles<EquatableProfile, ValueProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            ComparableValue, CombineProfiles<ComparableProfile, ValueProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            DefaultConstructibleValue,
+            CombineProfiles<HasDefaultConstructorProfile, ValueProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            NothrowMoveConstructible, CombineProfiles<HasNothrowMoveConstructorProfile, HasNothrowDestructorProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            EquatableNothrowMoveConstructible,
+            CombineProfiles<EquatableProfile, NothrowMoveConstructibleProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            ComparableNothrowMoveConstructible,
+            CombineProfiles<ComparableProfile, NothrowMoveConstructibleProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            DefaultConstructibleNothrowMoveConstructible,
+            CombineProfiles<HasDefaultConstructorProfile, NothrowMoveConstructibleProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            CopyConstructible,
+            CombineProfiles<HasNothrowMoveConstructorProfile, HasCopyConstructorProfile, HasNothrowDestructorProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            EquatableCopyConstructible,
+            CombineProfiles<EquatableProfile, CopyConstructibleProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            ComparableCopyConstructible,
+            CombineProfiles<ComparableProfile, CopyConstructibleProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            DefaultConstructibleCopyConstructible,
+            CombineProfiles<HasDefaultConstructorProfile, CopyConstructibleProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            NothrowMovable,
+            CombineProfiles<HasNothrowMoveConstructorProfile, HasNothrowMoveAssignProfile, HasNothrowDestructorProfile, HasNothrowSwapProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            EquatableNothrowMovable,
+            CombineProfiles<EquatableProfile, NothrowMovableProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            ComparableNothrowMovable,
+            CombineProfiles<ComparableProfile, NothrowMovableProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            DefaultConstructibleNothrowMovable,
+            CombineProfiles<HasDefaultConstructorProfile, NothrowMovableProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            TrivialSpecialMemberFunctions,
+            CombineProfiles<HasTrivialDefaultConstructorProfile, HasTrivialMoveConstructorProfile, HasTrivialCopyConstructorProfile, HasTrivialMoveAssignProfile, HasTrivialCopyAssignProfile, HasTrivialDestructorProfile, HasNothrowSwapProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            TriviallyComplete,
+            CombineProfiles<TrivialSpecialMemberFunctionsProfile, ComparableProfile, HasStdHashSpecializationProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HashableNothrowMoveConstructible,
+            CombineProfiles<HasStdHashSpecializationProfile, NothrowMoveConstructibleProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HashableCopyConstructible,
+            CombineProfiles<HasStdHashSpecializationProfile, CopyConstructibleProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HashableNothrowMovable,
+            CombineProfiles<HasStdHashSpecializationProfile, NothrowMovableProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            HashableValue,
+            CombineProfiles<HasStdHashSpecializationProfile, ValueProfile>
+        );
+
+        ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+            ComparableHashableValue,
+            CombineProfiles<HashableValueProfile, ComparableProfile>
+        );
+
+        // The "preferred" profiles that we support in Abseil.
+        template<template<class...> class Receiver>
+        using ExpandBasicProfiles =
+            Receiver<NothrowMoveConstructibleProfile, CopyConstructibleProfile, NothrowMovableProfile, ValueProfile>;
+
+        // The basic profiles except that they are also all Equatable.
+        template<template<class...> class Receiver>
+        using ExpandBasicEquatableProfiles =
+            Receiver<EquatableNothrowMoveConstructibleProfile, EquatableCopyConstructibleProfile, EquatableNothrowMovableProfile, EquatableValueProfile>;
+
+        // The basic profiles except that they are also all Comparable.
+        template<template<class...> class Receiver>
+        using ExpandBasicComparableProfiles =
+            Receiver<ComparableNothrowMoveConstructibleProfile, ComparableCopyConstructibleProfile, ComparableNothrowMovableProfile, ComparableValueProfile>;
+
+        // The basic profiles except that they are also all Hashable.
+        template<template<class...> class Receiver>
+        using ExpandBasicHashableProfiles =
+            Receiver<HashableNothrowMoveConstructibleProfile, HashableCopyConstructibleProfile, HashableNothrowMovableProfile, HashableValueProfile>;
+
+        // The basic profiles except that they are also all DefaultConstructible.
+        template<template<class...> class Receiver>
+        using ExpandBasicDefaultConstructibleProfiles =
+            Receiver<DefaultConstructibleNothrowMoveConstructibleProfile, DefaultConstructibleCopyConstructibleProfile, DefaultConstructibleNothrowMovableProfile, DefaultConstructibleValueProfile>;
+
+        // The type profiles that we support in Abseil (all of the previous lists).
+        template<template<class...> class Receiver>
+        using ExpandSupportedProfiles = Receiver<
+            NothrowMoveConstructibleProfile,
+            CopyConstructibleProfile,
+            NothrowMovableProfile,
+            ValueProfile,
+            EquatableNothrowMoveConstructibleProfile,
+            EquatableCopyConstructibleProfile,
+            EquatableNothrowMovableProfile,
+            EquatableValueProfile,
+            ComparableNothrowMoveConstructibleProfile,
+            ComparableCopyConstructibleProfile,
+            ComparableNothrowMovableProfile,
+            ComparableValueProfile,
+            DefaultConstructibleNothrowMoveConstructibleProfile,
+            DefaultConstructibleCopyConstructibleProfile,
+            DefaultConstructibleNothrowMovableProfile,
+            DefaultConstructibleValueProfile,
+            HashableNothrowMoveConstructibleProfile,
+            HashableCopyConstructibleProfile,
+            HashableNothrowMovableProfile,
+            HashableValueProfile>;
+
+        // TODO(calabrese) Include types that have throwing move constructors, since in
+        // practice we still need to support them because of standard library types with
+        // (potentially) non-noexcept moves.
+
+    }  // namespace types_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #undef ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_archetype.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_archetype.h
index 2349e0f..45b77c0 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/conformance_archetype.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_archetype.h
@@ -42,936 +42,831 @@
 #include "absl/meta/type_traits.h"
 #include "absl/types/internal/conformance_profile.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace types_internal {
-
-// A minimum-conforming implementation of a type with properties specified in
-// `Prof`, where `Prof` is a valid Conformance Profile.
-template <class Prof, class /*Enabler*/ = void>
-class Archetype;
-
-// Given an Archetype, obtain the properties of the profile associated with that
-// archetype.
-template <class Archetype>
-struct PropertiesOfArchetype;
-
-template <class Prof>
-struct PropertiesOfArchetype<Archetype<Prof>> {
-  using type = PropertiesOfT<Prof>;
-};
-
-template <class Archetype>
-using PropertiesOfArchetypeT = typename PropertiesOfArchetype<Archetype>::type;
-
-// A metafunction to determine if a type is an `Archetype`.
-template <class T>
-struct IsArchetype : std::false_type {};
-
-template <class Prof>
-struct IsArchetype<Archetype<Prof>> : std::true_type {};
-
-// A constructor tag type used when creating an Archetype with internal state.
-struct MakeArchetypeState {};
-
-// Data stored within an archetype that is copied/compared/hashed when the
-// corresponding operations are used.
-using ArchetypeState = std::size_t;
-
-////////////////////////////////////////////////////////////////////////////////
-//   This section of the file defines a chain of base classes for Archetype,  //
-//   where each base defines a specific special member function with the      //
-//   appropriate properties (deleted, noexcept(false), noexcept, or trivial). //
-////////////////////////////////////////////////////////////////////////////////
-
-// The bottom-most base, which contains the state and the default constructor.
-template <default_constructible DefaultConstructibleValue>
-struct ArchetypeStateBase {
-  static_assert(DefaultConstructibleValue == default_constructible::yes ||
-                    DefaultConstructibleValue == default_constructible::nothrow,
-                "");
-
-  ArchetypeStateBase() noexcept(
-      DefaultConstructibleValue ==
-      default_constructible::
-          nothrow) /*Vacuous archetype_state initialization*/ {}
-  explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
-      : archetype_state(state) {}
-
-  ArchetypeState archetype_state;
-};
-
-template <>
-struct ArchetypeStateBase<default_constructible::maybe> {
-  explicit ArchetypeStateBase() = delete;
-  explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
-      : archetype_state(state) {}
-
-  ArchetypeState archetype_state;
-};
-
-template <>
-struct ArchetypeStateBase<default_constructible::trivial> {
-  ArchetypeStateBase() = default;
-  explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
-      : archetype_state(state) {}
-
-  ArchetypeState archetype_state;
-};
-
-// The move-constructor base
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue>
-struct ArchetypeMoveConstructor
-    : ArchetypeStateBase<DefaultConstructibleValue> {
-  static_assert(MoveConstructibleValue == move_constructible::yes ||
-                    MoveConstructibleValue == move_constructible::nothrow,
-                "");
-
-  explicit ArchetypeMoveConstructor(MakeArchetypeState,
-                                    ArchetypeState state) noexcept
-      : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(),
-                                                      state) {}
-
-  ArchetypeMoveConstructor() = default;
-  ArchetypeMoveConstructor(ArchetypeMoveConstructor&& other) noexcept(
-      MoveConstructibleValue == move_constructible::nothrow)
-      : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(),
-                                                      other.archetype_state) {}
-  ArchetypeMoveConstructor(const ArchetypeMoveConstructor&) = default;
-  ArchetypeMoveConstructor& operator=(ArchetypeMoveConstructor&&) = default;
-  ArchetypeMoveConstructor& operator=(const ArchetypeMoveConstructor&) =
-      default;
-};
-
-template <default_constructible DefaultConstructibleValue>
-struct ArchetypeMoveConstructor<DefaultConstructibleValue,
-                                move_constructible::trivial>
-    : ArchetypeStateBase<DefaultConstructibleValue> {
-  explicit ArchetypeMoveConstructor(MakeArchetypeState,
-                                    ArchetypeState state) noexcept
-      : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(),
-                                                      state) {}
-
-  ArchetypeMoveConstructor() = default;
-};
-
-// The copy-constructor base
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue>
-struct ArchetypeCopyConstructor
-    : ArchetypeMoveConstructor<DefaultConstructibleValue,
-                               MoveConstructibleValue> {
-  static_assert(CopyConstructibleValue == copy_constructible::yes ||
-                    CopyConstructibleValue == copy_constructible::nothrow,
-                "");
-  explicit ArchetypeCopyConstructor(MakeArchetypeState,
-                                    ArchetypeState state) noexcept
-      : ArchetypeMoveConstructor<DefaultConstructibleValue,
-                                 MoveConstructibleValue>(MakeArchetypeState(),
-                                                         state) {}
-
-  ArchetypeCopyConstructor() = default;
-  ArchetypeCopyConstructor(ArchetypeCopyConstructor&&) = default;
-  ArchetypeCopyConstructor(const ArchetypeCopyConstructor& other) noexcept(
-      CopyConstructibleValue == copy_constructible::nothrow)
-      : ArchetypeMoveConstructor<DefaultConstructibleValue,
-                                 MoveConstructibleValue>(
-            MakeArchetypeState(), other.archetype_state) {}
-  ArchetypeCopyConstructor& operator=(ArchetypeCopyConstructor&&) = default;
-  ArchetypeCopyConstructor& operator=(const ArchetypeCopyConstructor&) =
-      default;
-};
-
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue>
-struct ArchetypeCopyConstructor<DefaultConstructibleValue,
-                                MoveConstructibleValue,
-                                copy_constructible::maybe>
-    : ArchetypeMoveConstructor<DefaultConstructibleValue,
-                               MoveConstructibleValue> {
-  explicit ArchetypeCopyConstructor(MakeArchetypeState,
-                                    ArchetypeState state) noexcept
-      : ArchetypeMoveConstructor<DefaultConstructibleValue,
-                                 MoveConstructibleValue>(MakeArchetypeState(),
-                                                         state) {}
-
-  ArchetypeCopyConstructor() = default;
-  ArchetypeCopyConstructor(ArchetypeCopyConstructor&&) = default;
-  ArchetypeCopyConstructor(const ArchetypeCopyConstructor&) = delete;
-  ArchetypeCopyConstructor& operator=(ArchetypeCopyConstructor&&) = default;
-  ArchetypeCopyConstructor& operator=(const ArchetypeCopyConstructor&) =
-      default;
-};
-
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue>
-struct ArchetypeCopyConstructor<DefaultConstructibleValue,
-                                MoveConstructibleValue,
-                                copy_constructible::trivial>
-    : ArchetypeMoveConstructor<DefaultConstructibleValue,
-                               MoveConstructibleValue> {
-  explicit ArchetypeCopyConstructor(MakeArchetypeState,
-                                    ArchetypeState state) noexcept
-      : ArchetypeMoveConstructor<DefaultConstructibleValue,
-                                 MoveConstructibleValue>(MakeArchetypeState(),
-                                                         state) {}
-
-  ArchetypeCopyConstructor() = default;
-};
-
-// The move-assign base
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue,
-          move_assignable MoveAssignableValue>
-struct ArchetypeMoveAssign
-    : ArchetypeCopyConstructor<DefaultConstructibleValue,
-                               MoveConstructibleValue, CopyConstructibleValue> {
-  static_assert(MoveAssignableValue == move_assignable::yes ||
-                    MoveAssignableValue == move_assignable::nothrow,
-                "");
-  explicit ArchetypeMoveAssign(MakeArchetypeState,
-                               ArchetypeState state) noexcept
-      : ArchetypeCopyConstructor<DefaultConstructibleValue,
-                                 MoveConstructibleValue,
-                                 CopyConstructibleValue>(MakeArchetypeState(),
-                                                         state) {}
-
-  ArchetypeMoveAssign() = default;
-  ArchetypeMoveAssign(ArchetypeMoveAssign&&) = default;
-  ArchetypeMoveAssign(const ArchetypeMoveAssign&) = default;
-  ArchetypeMoveAssign& operator=(ArchetypeMoveAssign&& other) noexcept(
-      MoveAssignableValue == move_assignable::nothrow) {
-    this->archetype_state = other.archetype_state;
-    return *this;
-  }
-
-  ArchetypeMoveAssign& operator=(const ArchetypeMoveAssign&) = default;
-};
-
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue>
-struct ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                           CopyConstructibleValue, move_assignable::trivial>
-    : ArchetypeCopyConstructor<DefaultConstructibleValue,
-                               MoveConstructibleValue, CopyConstructibleValue> {
-  explicit ArchetypeMoveAssign(MakeArchetypeState,
-                               ArchetypeState state) noexcept
-      : ArchetypeCopyConstructor<DefaultConstructibleValue,
-                                 MoveConstructibleValue,
-                                 CopyConstructibleValue>(MakeArchetypeState(),
-                                                         state) {}
-
-  ArchetypeMoveAssign() = default;
-};
-
-// The copy-assign base
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue,
-          move_assignable MoveAssignableValue,
-          copy_assignable CopyAssignableValue>
-struct ArchetypeCopyAssign
-    : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                          CopyConstructibleValue, MoveAssignableValue> {
-  static_assert(CopyAssignableValue == copy_assignable::yes ||
-                    CopyAssignableValue == copy_assignable::nothrow,
-                "");
-  explicit ArchetypeCopyAssign(MakeArchetypeState,
-                               ArchetypeState state) noexcept
-      : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                            CopyConstructibleValue, MoveAssignableValue>(
-            MakeArchetypeState(), state) {}
-
-  ArchetypeCopyAssign() = default;
-  ArchetypeCopyAssign(ArchetypeCopyAssign&&) = default;
-  ArchetypeCopyAssign(const ArchetypeCopyAssign&) = default;
-  ArchetypeCopyAssign& operator=(ArchetypeCopyAssign&&) = default;
-
-  ArchetypeCopyAssign& operator=(const ArchetypeCopyAssign& other) noexcept(
-      CopyAssignableValue == copy_assignable::nothrow) {
-    this->archetype_state = other.archetype_state;
-    return *this;
-  }
-};
-
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue,
-          move_assignable MoveAssignableValue>
-struct ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                           CopyConstructibleValue, MoveAssignableValue,
-                           copy_assignable::maybe>
-    : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                          CopyConstructibleValue, MoveAssignableValue> {
-  explicit ArchetypeCopyAssign(MakeArchetypeState,
-                               ArchetypeState state) noexcept
-      : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                            CopyConstructibleValue, MoveAssignableValue>(
-            MakeArchetypeState(), state) {}
-
-  ArchetypeCopyAssign() = default;
-  ArchetypeCopyAssign(ArchetypeCopyAssign&&) = default;
-  ArchetypeCopyAssign(const ArchetypeCopyAssign&) = default;
-  ArchetypeCopyAssign& operator=(ArchetypeCopyAssign&&) = default;
-  ArchetypeCopyAssign& operator=(const ArchetypeCopyAssign&) = delete;
-};
-
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue,
-          move_assignable MoveAssignableValue>
-struct ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                           CopyConstructibleValue, MoveAssignableValue,
-                           copy_assignable::trivial>
-    : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                          CopyConstructibleValue, MoveAssignableValue> {
-  explicit ArchetypeCopyAssign(MakeArchetypeState,
-                               ArchetypeState state) noexcept
-      : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                            CopyConstructibleValue, MoveAssignableValue>(
-            MakeArchetypeState(), state) {}
-
-  ArchetypeCopyAssign() = default;
-};
-
-// The destructor base
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue,
-          move_assignable MoveAssignableValue,
-          copy_assignable CopyAssignableValue, destructible DestructibleValue>
-struct ArchetypeDestructor
-    : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                          CopyConstructibleValue, MoveAssignableValue,
-                          CopyAssignableValue> {
-  static_assert(DestructibleValue == destructible::yes ||
-                    DestructibleValue == destructible::nothrow,
-                "");
-
-  explicit ArchetypeDestructor(MakeArchetypeState,
-                               ArchetypeState state) noexcept
-      : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                            CopyConstructibleValue, MoveAssignableValue,
-                            CopyAssignableValue>(MakeArchetypeState(), state) {}
-
-  ArchetypeDestructor() = default;
-  ArchetypeDestructor(ArchetypeDestructor&&) = default;
-  ArchetypeDestructor(const ArchetypeDestructor&) = default;
-  ArchetypeDestructor& operator=(ArchetypeDestructor&&) = default;
-  ArchetypeDestructor& operator=(const ArchetypeDestructor&) = default;
-  ~ArchetypeDestructor() noexcept(DestructibleValue == destructible::nothrow) {}
-};
-
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue,
-          move_assignable MoveAssignableValue,
-          copy_assignable CopyAssignableValue>
-struct ArchetypeDestructor<DefaultConstructibleValue, MoveConstructibleValue,
-                           CopyConstructibleValue, MoveAssignableValue,
-                           CopyAssignableValue, destructible::trivial>
-    : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                          CopyConstructibleValue, MoveAssignableValue,
-                          CopyAssignableValue> {
-  explicit ArchetypeDestructor(MakeArchetypeState,
-                               ArchetypeState state) noexcept
-      : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue,
-                            CopyConstructibleValue, MoveAssignableValue,
-                            CopyAssignableValue>(MakeArchetypeState(), state) {}
-
-  ArchetypeDestructor() = default;
-};
-
-// An alias to the top of the chain of bases for special-member functions.
-// NOTE: move_constructible::maybe, move_assignable::maybe, and
-// destructible::maybe are handled in the top-level type by way of SFINAE.
-// Because of this, we never instantiate the base classes with
-// move_constructible::maybe, move_assignable::maybe, or destructible::maybe so
-// that we minimize the number of different possible type-template
-// instantiations.
-template <default_constructible DefaultConstructibleValue,
-          move_constructible MoveConstructibleValue,
-          copy_constructible CopyConstructibleValue,
-          move_assignable MoveAssignableValue,
-          copy_assignable CopyAssignableValue, destructible DestructibleValue>
-using ArchetypeSpecialMembersBase = ArchetypeDestructor<
-    DefaultConstructibleValue,
-    MoveConstructibleValue != move_constructible::maybe
-        ? MoveConstructibleValue
-        : move_constructible::nothrow,
-    CopyConstructibleValue,
-    MoveAssignableValue != move_assignable::maybe ? MoveAssignableValue
-                                                  : move_assignable::nothrow,
-    CopyAssignableValue,
-    DestructibleValue != destructible::maybe ? DestructibleValue
-                                             : destructible::nothrow>;
-
-// A function that is used to create an archetype with some associated state.
-template <class Arch>
-Arch MakeArchetype(ArchetypeState state) noexcept {
-  static_assert(IsArchetype<Arch>::value,
-                "The explicit template argument to MakeArchetype is required "
-                "to be an Archetype.");
-  return Arch(MakeArchetypeState(), state);
-}
-
-// This is used to conditionally delete "copy" and "move" constructors in a way
-// that is consistent with what the ConformanceProfile requires and that also
-// strictly enforces the arguments to the copy/move to not come from implicit
-// conversions when dealing with the Archetype.
-template <class Prof, class T>
-constexpr bool ShouldDeleteConstructor() {
-  return !((PropertiesOfT<Prof>::move_constructible_support !=
-                move_constructible::maybe &&
-            std::is_same<T, Archetype<Prof>>::value) ||
-           (PropertiesOfT<Prof>::copy_constructible_support !=
-                copy_constructible::maybe &&
-            (std::is_same<T, const Archetype<Prof>&>::value ||
-             std::is_same<T, Archetype<Prof>&>::value ||
-             std::is_same<T, const Archetype<Prof>>::value)));
-}
-
-// This is used to conditionally delete "copy" and "move" assigns in a way
-// that is consistent with what the ConformanceProfile requires and that also
-// strictly enforces the arguments to the copy/move to not come from implicit
-// conversions when dealing with the Archetype.
-template <class Prof, class T>
-constexpr bool ShouldDeleteAssign() {
-  return !(
-      (PropertiesOfT<Prof>::move_assignable_support != move_assignable::maybe &&
-       std::is_same<T, Archetype<Prof>>::value) ||
-      (PropertiesOfT<Prof>::copy_assignable_support != copy_assignable::maybe &&
-       (std::is_same<T, const Archetype<Prof>&>::value ||
-        std::is_same<T, Archetype<Prof>&>::value ||
-        std::is_same<T, const Archetype<Prof>>::value)));
-}
-
-// TODO(calabrese) Inherit from a chain of secondary bases to pull in the
-// associated functions of other concepts.
-template <class Prof, class Enabler>
-class Archetype : ArchetypeSpecialMembersBase<
-                      PropertiesOfT<Prof>::default_constructible_support,
-                      PropertiesOfT<Prof>::move_constructible_support,
-                      PropertiesOfT<Prof>::copy_constructible_support,
-                      PropertiesOfT<Prof>::move_assignable_support,
-                      PropertiesOfT<Prof>::copy_assignable_support,
-                      PropertiesOfT<Prof>::destructible_support> {
-  static_assert(std::is_same<Enabler, void>::value,
-                "An explicit type must not be passed as the second template "
-                "argument to 'Archetype`.");
-
-  // The cases mentioned in these static_asserts are expected to be handled in
-  // the partial template specializations of Archetype that follow this
-  // definition.
-  static_assert(PropertiesOfT<Prof>::destructible_support !=
-                    destructible::maybe,
-                "");
-  static_assert(PropertiesOfT<Prof>::move_constructible_support !=
-                        move_constructible::maybe ||
-                    PropertiesOfT<Prof>::copy_constructible_support ==
-                        copy_constructible::maybe,
-                "");
-  static_assert(PropertiesOfT<Prof>::move_assignable_support !=
-                        move_assignable::maybe ||
-                    PropertiesOfT<Prof>::copy_assignable_support ==
-                        copy_assignable::maybe,
-                "");
-
- public:
-  Archetype() = default;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
-  Archetype(T&&) = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
-  Archetype& operator=(T&&) = delete;
-
-  using ArchetypeSpecialMembersBase<
-      PropertiesOfT<Prof>::default_constructible_support,
-      PropertiesOfT<Prof>::move_constructible_support,
-      PropertiesOfT<Prof>::copy_constructible_support,
-      PropertiesOfT<Prof>::move_assignable_support,
-      PropertiesOfT<Prof>::copy_assignable_support,
-      PropertiesOfT<Prof>::destructible_support>::archetype_state;
-
- private:
-  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
-      : ArchetypeSpecialMembersBase<
-            PropertiesOfT<Prof>::default_constructible_support,
-            PropertiesOfT<Prof>::move_constructible_support,
-            PropertiesOfT<Prof>::copy_constructible_support,
-            PropertiesOfT<Prof>::move_assignable_support,
-            PropertiesOfT<Prof>::copy_assignable_support,
-            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
-                                                       state) {}
-
-  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
-};
-
-template <class Prof>
-class Archetype<Prof, typename std::enable_if<
-                          PropertiesOfT<Prof>::move_constructible_support !=
-                              move_constructible::maybe &&
-                          PropertiesOfT<Prof>::move_assignable_support ==
-                              move_assignable::maybe &&
-                          PropertiesOfT<Prof>::destructible_support !=
-                              destructible::maybe>::type>
-    : ArchetypeSpecialMembersBase<
-          PropertiesOfT<Prof>::default_constructible_support,
-          PropertiesOfT<Prof>::move_constructible_support,
-          PropertiesOfT<Prof>::copy_constructible_support,
-          PropertiesOfT<Prof>::move_assignable_support,
-          PropertiesOfT<Prof>::copy_assignable_support,
-          PropertiesOfT<Prof>::destructible_support> {
- public:
-  Archetype() = default;
-  Archetype(Archetype&&) = default;
-  Archetype(const Archetype&) = default;
-  Archetype& operator=(Archetype&&) = delete;
-  Archetype& operator=(const Archetype&) = default;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
-  Archetype(T&&) = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
-  Archetype& operator=(T&&) = delete;
-
-  using ArchetypeSpecialMembersBase<
-      PropertiesOfT<Prof>::default_constructible_support,
-      PropertiesOfT<Prof>::move_constructible_support,
-      PropertiesOfT<Prof>::copy_constructible_support,
-      PropertiesOfT<Prof>::move_assignable_support,
-      PropertiesOfT<Prof>::copy_assignable_support,
-      PropertiesOfT<Prof>::destructible_support>::archetype_state;
-
- private:
-  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
-      : ArchetypeSpecialMembersBase<
-            PropertiesOfT<Prof>::default_constructible_support,
-            PropertiesOfT<Prof>::move_constructible_support,
-            PropertiesOfT<Prof>::copy_constructible_support,
-            PropertiesOfT<Prof>::move_assignable_support,
-            PropertiesOfT<Prof>::copy_assignable_support,
-            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
-                                                       state) {}
-
-  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
-};
-
-template <class Prof>
-class Archetype<Prof, typename std::enable_if<
-                          PropertiesOfT<Prof>::move_constructible_support ==
-                              move_constructible::maybe &&
-                          PropertiesOfT<Prof>::move_assignable_support ==
-                              move_assignable::maybe &&
-                          PropertiesOfT<Prof>::destructible_support !=
-                              destructible::maybe>::type>
-    : ArchetypeSpecialMembersBase<
-          PropertiesOfT<Prof>::default_constructible_support,
-          PropertiesOfT<Prof>::move_constructible_support,
-          PropertiesOfT<Prof>::copy_constructible_support,
-          PropertiesOfT<Prof>::move_assignable_support,
-          PropertiesOfT<Prof>::copy_assignable_support,
-          PropertiesOfT<Prof>::destructible_support> {
- public:
-  Archetype() = default;
-  Archetype(Archetype&&) = delete;
-  Archetype(const Archetype&) = default;
-  Archetype& operator=(Archetype&&) = delete;
-  Archetype& operator=(const Archetype&) = default;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
-  Archetype(T&&) = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
-  Archetype& operator=(T&&) = delete;
-
-  using ArchetypeSpecialMembersBase<
-      PropertiesOfT<Prof>::default_constructible_support,
-      PropertiesOfT<Prof>::move_constructible_support,
-      PropertiesOfT<Prof>::copy_constructible_support,
-      PropertiesOfT<Prof>::move_assignable_support,
-      PropertiesOfT<Prof>::copy_assignable_support,
-      PropertiesOfT<Prof>::destructible_support>::archetype_state;
-
- private:
-  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
-      : ArchetypeSpecialMembersBase<
-            PropertiesOfT<Prof>::default_constructible_support,
-            PropertiesOfT<Prof>::move_constructible_support,
-            PropertiesOfT<Prof>::copy_constructible_support,
-            PropertiesOfT<Prof>::move_assignable_support,
-            PropertiesOfT<Prof>::copy_assignable_support,
-            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
-                                                       state) {}
-
-  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
-};
-
-template <class Prof>
-class Archetype<Prof, typename std::enable_if<
-                          PropertiesOfT<Prof>::move_constructible_support ==
-                              move_constructible::maybe &&
-                          PropertiesOfT<Prof>::move_assignable_support !=
-                              move_assignable::maybe &&
-                          PropertiesOfT<Prof>::destructible_support !=
-                              destructible::maybe>::type>
-    : ArchetypeSpecialMembersBase<
-          PropertiesOfT<Prof>::default_constructible_support,
-          PropertiesOfT<Prof>::move_constructible_support,
-          PropertiesOfT<Prof>::copy_constructible_support,
-          PropertiesOfT<Prof>::move_assignable_support,
-          PropertiesOfT<Prof>::copy_assignable_support,
-          PropertiesOfT<Prof>::destructible_support> {
- public:
-  Archetype() = default;
-  Archetype(Archetype&&) = delete;
-  Archetype(const Archetype&) = default;
-  Archetype& operator=(Archetype&&) = default;
-  Archetype& operator=(const Archetype&) = default;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
-  Archetype(T&&) = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
-  Archetype& operator=(T&&) = delete;
-
-  using ArchetypeSpecialMembersBase<
-      PropertiesOfT<Prof>::default_constructible_support,
-      PropertiesOfT<Prof>::move_constructible_support,
-      PropertiesOfT<Prof>::copy_constructible_support,
-      PropertiesOfT<Prof>::move_assignable_support,
-      PropertiesOfT<Prof>::copy_assignable_support,
-      PropertiesOfT<Prof>::destructible_support>::archetype_state;
-
- private:
-  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
-      : ArchetypeSpecialMembersBase<
-            PropertiesOfT<Prof>::default_constructible_support,
-            PropertiesOfT<Prof>::move_constructible_support,
-            PropertiesOfT<Prof>::copy_constructible_support,
-            PropertiesOfT<Prof>::move_assignable_support,
-            PropertiesOfT<Prof>::copy_assignable_support,
-            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
-                                                       state) {}
-
-  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
-};
-
-template <class Prof>
-class Archetype<Prof, typename std::enable_if<
-                          PropertiesOfT<Prof>::move_constructible_support !=
-                              move_constructible::maybe &&
-                          PropertiesOfT<Prof>::move_assignable_support ==
-                              move_assignable::maybe &&
-                          PropertiesOfT<Prof>::destructible_support ==
-                              destructible::maybe>::type>
-    : ArchetypeSpecialMembersBase<
-          PropertiesOfT<Prof>::default_constructible_support,
-          PropertiesOfT<Prof>::move_constructible_support,
-          PropertiesOfT<Prof>::copy_constructible_support,
-          PropertiesOfT<Prof>::move_assignable_support,
-          PropertiesOfT<Prof>::copy_assignable_support,
-          PropertiesOfT<Prof>::destructible_support> {
- public:
-  Archetype() = default;
-  Archetype(Archetype&&) = default;
-  Archetype(const Archetype&) = default;
-  Archetype& operator=(Archetype&&) = delete;
-  Archetype& operator=(const Archetype&) = default;
-  ~Archetype() = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
-  Archetype(T&&) = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
-  Archetype& operator=(T&&) = delete;
-
-  using ArchetypeSpecialMembersBase<
-      PropertiesOfT<Prof>::default_constructible_support,
-      PropertiesOfT<Prof>::move_constructible_support,
-      PropertiesOfT<Prof>::copy_constructible_support,
-      PropertiesOfT<Prof>::move_assignable_support,
-      PropertiesOfT<Prof>::copy_assignable_support,
-      PropertiesOfT<Prof>::destructible_support>::archetype_state;
-
- private:
-  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
-      : ArchetypeSpecialMembersBase<
-            PropertiesOfT<Prof>::default_constructible_support,
-            PropertiesOfT<Prof>::move_constructible_support,
-            PropertiesOfT<Prof>::copy_constructible_support,
-            PropertiesOfT<Prof>::move_assignable_support,
-            PropertiesOfT<Prof>::copy_assignable_support,
-            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
-                                                       state) {}
-
-  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
-};
-
-template <class Prof>
-class Archetype<Prof, typename std::enable_if<
-                          PropertiesOfT<Prof>::move_constructible_support ==
-                              move_constructible::maybe &&
-                          PropertiesOfT<Prof>::move_assignable_support ==
-                              move_assignable::maybe &&
-                          PropertiesOfT<Prof>::destructible_support ==
-                              destructible::maybe>::type>
-    : ArchetypeSpecialMembersBase<
-          PropertiesOfT<Prof>::default_constructible_support,
-          PropertiesOfT<Prof>::move_constructible_support,
-          PropertiesOfT<Prof>::copy_constructible_support,
-          PropertiesOfT<Prof>::move_assignable_support,
-          PropertiesOfT<Prof>::copy_assignable_support,
-          PropertiesOfT<Prof>::destructible_support> {
- public:
-  Archetype() = default;
-  Archetype(Archetype&&) = delete;
-  Archetype(const Archetype&) = default;
-  Archetype& operator=(Archetype&&) = delete;
-  Archetype& operator=(const Archetype&) = default;
-  ~Archetype() = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
-  Archetype(T&&) = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
-  Archetype& operator=(T&&) = delete;
-
-  using ArchetypeSpecialMembersBase<
-      PropertiesOfT<Prof>::default_constructible_support,
-      PropertiesOfT<Prof>::move_constructible_support,
-      PropertiesOfT<Prof>::copy_constructible_support,
-      PropertiesOfT<Prof>::move_assignable_support,
-      PropertiesOfT<Prof>::copy_assignable_support,
-      PropertiesOfT<Prof>::destructible_support>::archetype_state;
-
- private:
-  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
-      : ArchetypeSpecialMembersBase<
-            PropertiesOfT<Prof>::default_constructible_support,
-            PropertiesOfT<Prof>::move_constructible_support,
-            PropertiesOfT<Prof>::copy_constructible_support,
-            PropertiesOfT<Prof>::move_assignable_support,
-            PropertiesOfT<Prof>::copy_assignable_support,
-            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
-                                                       state) {}
-
-  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
-};
-
-template <class Prof>
-class Archetype<Prof, typename std::enable_if<
-                          PropertiesOfT<Prof>::move_constructible_support ==
-                              move_constructible::maybe &&
-                          PropertiesOfT<Prof>::move_assignable_support !=
-                              move_assignable::maybe &&
-                          PropertiesOfT<Prof>::destructible_support ==
-                              destructible::maybe>::type>
-    : ArchetypeSpecialMembersBase<
-          PropertiesOfT<Prof>::default_constructible_support,
-          PropertiesOfT<Prof>::move_constructible_support,
-          PropertiesOfT<Prof>::copy_constructible_support,
-          PropertiesOfT<Prof>::move_assignable_support,
-          PropertiesOfT<Prof>::copy_assignable_support,
-          PropertiesOfT<Prof>::destructible_support> {
- public:
-  Archetype() = default;
-  Archetype(Archetype&&) = delete;
-  Archetype(const Archetype&) = default;
-  Archetype& operator=(Archetype&&) = default;
-  Archetype& operator=(const Archetype&) = default;
-  ~Archetype() = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
-  Archetype(T&&) = delete;
-
-  // Disallow moves when requested, and disallow implicit conversions.
-  template <class T, typename std::enable_if<
-                         ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
-  Archetype& operator=(T&&) = delete;
-
-  using ArchetypeSpecialMembersBase<
-      PropertiesOfT<Prof>::default_constructible_support,
-      PropertiesOfT<Prof>::move_constructible_support,
-      PropertiesOfT<Prof>::copy_constructible_support,
-      PropertiesOfT<Prof>::move_assignable_support,
-      PropertiesOfT<Prof>::copy_assignable_support,
-      PropertiesOfT<Prof>::destructible_support>::archetype_state;
-
- private:
-  explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
-      : ArchetypeSpecialMembersBase<
-            PropertiesOfT<Prof>::default_constructible_support,
-            PropertiesOfT<Prof>::move_constructible_support,
-            PropertiesOfT<Prof>::copy_constructible_support,
-            PropertiesOfT<Prof>::move_assignable_support,
-            PropertiesOfT<Prof>::copy_assignable_support,
-            PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(),
-                                                       state) {}
-
-  friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
-};
-
-// Explicitly deleted swap for Archetype if the profile does not require swap.
-// It is important to delete it rather than simply leave it out so that the
-// "using std::swap;" idiom will result in this deleted overload being picked.
-template <class Prof,
-          absl::enable_if_t<!PropertiesOfT<Prof>::is_swappable, int> = 0>
-void swap(Archetype<Prof>&, Archetype<Prof>&) = delete;  // NOLINT
-
-// A conditionally-noexcept swap implementation for Archetype when the profile
-// supports swap.
-template <class Prof,
-          absl::enable_if_t<PropertiesOfT<Prof>::is_swappable, int> = 0>
-void swap(Archetype<Prof>& lhs, Archetype<Prof>& rhs)  // NOLINT
-    noexcept(PropertiesOfT<Prof>::swappable_support != swappable::yes) {
-  std::swap(lhs.archetype_state, rhs.archetype_state);
-}
-
-// A convertible-to-bool type that is used as the return type of comparison
-// operators since the standard doesn't always require exactly bool.
-struct NothrowBool {
-  explicit NothrowBool() = delete;
-  ~NothrowBool() = default;
-
-  // TODO(calabrese) Delete the copy constructor in C++17 mode since guaranteed
-  // elision makes it not required when returning from a function.
-  // NothrowBool(NothrowBool const&) = delete;
-
-  NothrowBool& operator=(NothrowBool const&) = delete;
-
-  explicit operator bool() const noexcept { return value; }
-
-  static NothrowBool make(bool const value) noexcept {
-    return NothrowBool(value);
-  }
-
- private:
-  explicit NothrowBool(bool const value) noexcept : value(value) {}
-
-  bool value;
-};
-
-// A convertible-to-bool type that is used as the return type of comparison
-// operators since the standard doesn't always require exactly bool.
-// Note: ExceptionalBool has a conversion operator that is not noexcept, so
-// that even when a comparison operator is noexcept, that operation may still
-// potentially throw when converted to bool.
-struct ExceptionalBool {
-  explicit ExceptionalBool() = delete;
-  ~ExceptionalBool() = default;
-
-  // TODO(calabrese) Delete the copy constructor in C++17 mode since guaranteed
-  // elision makes it not required when returning from a function.
-  // ExceptionalBool(ExceptionalBool const&) = delete;
-
-  ExceptionalBool& operator=(ExceptionalBool const&) = delete;
-
-  explicit operator bool() const { return value; }  // NOLINT
-
-  static ExceptionalBool make(bool const value) noexcept {
-    return ExceptionalBool(value);
-  }
-
- private:
-  explicit ExceptionalBool(bool const value) noexcept : value(value) {}
-
-  bool value;
-};
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace types_internal
+    {
+
+        // A minimum-conforming implementation of a type with properties specified in
+        // `Prof`, where `Prof` is a valid Conformance Profile.
+        template<class Prof, class /*Enabler*/ = void>
+        class Archetype;
+
+        // Given an Archetype, obtain the properties of the profile associated with that
+        // archetype.
+        template<class Archetype>
+        struct PropertiesOfArchetype;
+
+        template<class Prof>
+        struct PropertiesOfArchetype<Archetype<Prof>>
+        {
+            using type = PropertiesOfT<Prof>;
+        };
+
+        template<class Archetype>
+        using PropertiesOfArchetypeT = typename PropertiesOfArchetype<Archetype>::type;
+
+        // A metafunction to determine if a type is an `Archetype`.
+        template<class T>
+        struct IsArchetype : std::false_type
+        {
+        };
+
+        template<class Prof>
+        struct IsArchetype<Archetype<Prof>> : std::true_type
+        {
+        };
+
+        // A constructor tag type used when creating an Archetype with internal state.
+        struct MakeArchetypeState
+        {
+        };
+
+        // Data stored within an archetype that is copied/compared/hashed when the
+        // corresponding operations are used.
+        using ArchetypeState = std::size_t;
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //   This section of the file defines a chain of base classes for Archetype,  //
+        //   where each base defines a specific special member function with the      //
+        //   appropriate properties (deleted, noexcept(false), noexcept, or trivial). //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // The bottom-most base, which contains the state and the default constructor.
+        template<default_constructible DefaultConstructibleValue>
+        struct ArchetypeStateBase
+        {
+            static_assert(DefaultConstructibleValue == default_constructible::yes || DefaultConstructibleValue == default_constructible::nothrow, "");
+
+            ArchetypeStateBase() noexcept(
+                DefaultConstructibleValue ==
+                default_constructible::
+                    nothrow
+            ) /*Vacuous archetype_state initialization*/
+            {
+            }
+            explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                archetype_state(state)
+            {
+            }
+
+            ArchetypeState archetype_state;
+        };
+
+        template<>
+        struct ArchetypeStateBase<default_constructible::maybe>
+        {
+            explicit ArchetypeStateBase() = delete;
+            explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                archetype_state(state)
+            {
+            }
+
+            ArchetypeState archetype_state;
+        };
+
+        template<>
+        struct ArchetypeStateBase<default_constructible::trivial>
+        {
+            ArchetypeStateBase() = default;
+            explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                archetype_state(state)
+            {
+            }
+
+            ArchetypeState archetype_state;
+        };
+
+        // The move-constructor base
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue>
+        struct ArchetypeMoveConstructor : ArchetypeStateBase<DefaultConstructibleValue>
+        {
+            static_assert(MoveConstructibleValue == move_constructible::yes || MoveConstructibleValue == move_constructible::nothrow, "");
+
+            explicit ArchetypeMoveConstructor(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeMoveConstructor() = default;
+            ArchetypeMoveConstructor(ArchetypeMoveConstructor&& other) noexcept(
+                MoveConstructibleValue == move_constructible::nothrow
+            ) :
+                ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(), other.archetype_state)
+            {
+            }
+            ArchetypeMoveConstructor(const ArchetypeMoveConstructor&) = default;
+            ArchetypeMoveConstructor& operator=(ArchetypeMoveConstructor&&) = default;
+            ArchetypeMoveConstructor& operator=(const ArchetypeMoveConstructor&) =
+                default;
+        };
+
+        template<default_constructible DefaultConstructibleValue>
+        struct ArchetypeMoveConstructor<DefaultConstructibleValue, move_constructible::trivial> : ArchetypeStateBase<DefaultConstructibleValue>
+        {
+            explicit ArchetypeMoveConstructor(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeMoveConstructor() = default;
+        };
+
+        // The copy-constructor base
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue>
+        struct ArchetypeCopyConstructor : ArchetypeMoveConstructor<DefaultConstructibleValue, MoveConstructibleValue>
+        {
+            static_assert(CopyConstructibleValue == copy_constructible::yes || CopyConstructibleValue == copy_constructible::nothrow, "");
+            explicit ArchetypeCopyConstructor(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeMoveConstructor<DefaultConstructibleValue, MoveConstructibleValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeCopyConstructor() = default;
+            ArchetypeCopyConstructor(ArchetypeCopyConstructor&&) = default;
+            ArchetypeCopyConstructor(const ArchetypeCopyConstructor& other) noexcept(
+                CopyConstructibleValue == copy_constructible::nothrow
+            ) :
+                ArchetypeMoveConstructor<DefaultConstructibleValue, MoveConstructibleValue>(
+                    MakeArchetypeState(), other.archetype_state
+                )
+            {
+            }
+            ArchetypeCopyConstructor& operator=(ArchetypeCopyConstructor&&) = default;
+            ArchetypeCopyConstructor& operator=(const ArchetypeCopyConstructor&) =
+                default;
+        };
+
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue>
+        struct ArchetypeCopyConstructor<DefaultConstructibleValue, MoveConstructibleValue, copy_constructible::maybe> : ArchetypeMoveConstructor<DefaultConstructibleValue, MoveConstructibleValue>
+        {
+            explicit ArchetypeCopyConstructor(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeMoveConstructor<DefaultConstructibleValue, MoveConstructibleValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeCopyConstructor() = default;
+            ArchetypeCopyConstructor(ArchetypeCopyConstructor&&) = default;
+            ArchetypeCopyConstructor(const ArchetypeCopyConstructor&) = delete;
+            ArchetypeCopyConstructor& operator=(ArchetypeCopyConstructor&&) = default;
+            ArchetypeCopyConstructor& operator=(const ArchetypeCopyConstructor&) =
+                default;
+        };
+
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue>
+        struct ArchetypeCopyConstructor<DefaultConstructibleValue, MoveConstructibleValue, copy_constructible::trivial> : ArchetypeMoveConstructor<DefaultConstructibleValue, MoveConstructibleValue>
+        {
+            explicit ArchetypeCopyConstructor(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeMoveConstructor<DefaultConstructibleValue, MoveConstructibleValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeCopyConstructor() = default;
+        };
+
+        // The move-assign base
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue, move_assignable MoveAssignableValue>
+        struct ArchetypeMoveAssign : ArchetypeCopyConstructor<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue>
+        {
+            static_assert(MoveAssignableValue == move_assignable::yes || MoveAssignableValue == move_assignable::nothrow, "");
+            explicit ArchetypeMoveAssign(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeCopyConstructor<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeMoveAssign() = default;
+            ArchetypeMoveAssign(ArchetypeMoveAssign&&) = default;
+            ArchetypeMoveAssign(const ArchetypeMoveAssign&) = default;
+            ArchetypeMoveAssign& operator=(ArchetypeMoveAssign&& other) noexcept(
+                MoveAssignableValue == move_assignable::nothrow
+            )
+            {
+                this->archetype_state = other.archetype_state;
+                return *this;
+            }
+
+            ArchetypeMoveAssign& operator=(const ArchetypeMoveAssign&) = default;
+        };
+
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue>
+        struct ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, move_assignable::trivial> : ArchetypeCopyConstructor<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue>
+        {
+            explicit ArchetypeMoveAssign(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeCopyConstructor<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeMoveAssign() = default;
+        };
+
+        // The copy-assign base
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue, move_assignable MoveAssignableValue, copy_assignable CopyAssignableValue>
+        struct ArchetypeCopyAssign : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue>
+        {
+            static_assert(CopyAssignableValue == copy_assignable::yes || CopyAssignableValue == copy_assignable::nothrow, "");
+            explicit ArchetypeCopyAssign(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue>(
+                    MakeArchetypeState(), state
+                )
+            {
+            }
+
+            ArchetypeCopyAssign() = default;
+            ArchetypeCopyAssign(ArchetypeCopyAssign&&) = default;
+            ArchetypeCopyAssign(const ArchetypeCopyAssign&) = default;
+            ArchetypeCopyAssign& operator=(ArchetypeCopyAssign&&) = default;
+
+            ArchetypeCopyAssign& operator=(const ArchetypeCopyAssign& other) noexcept(
+                CopyAssignableValue == copy_assignable::nothrow
+            )
+            {
+                this->archetype_state = other.archetype_state;
+                return *this;
+            }
+        };
+
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue, move_assignable MoveAssignableValue>
+        struct ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue, copy_assignable::maybe> : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue>
+        {
+            explicit ArchetypeCopyAssign(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue>(
+                    MakeArchetypeState(), state
+                )
+            {
+            }
+
+            ArchetypeCopyAssign() = default;
+            ArchetypeCopyAssign(ArchetypeCopyAssign&&) = default;
+            ArchetypeCopyAssign(const ArchetypeCopyAssign&) = default;
+            ArchetypeCopyAssign& operator=(ArchetypeCopyAssign&&) = default;
+            ArchetypeCopyAssign& operator=(const ArchetypeCopyAssign&) = delete;
+        };
+
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue, move_assignable MoveAssignableValue>
+        struct ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue, copy_assignable::trivial> : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue>
+        {
+            explicit ArchetypeCopyAssign(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue>(
+                    MakeArchetypeState(), state
+                )
+            {
+            }
+
+            ArchetypeCopyAssign() = default;
+        };
+
+        // The destructor base
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue, move_assignable MoveAssignableValue, copy_assignable CopyAssignableValue, destructible DestructibleValue>
+        struct ArchetypeDestructor : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue, CopyAssignableValue>
+        {
+            static_assert(DestructibleValue == destructible::yes || DestructibleValue == destructible::nothrow, "");
+
+            explicit ArchetypeDestructor(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue, CopyAssignableValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeDestructor() = default;
+            ArchetypeDestructor(ArchetypeDestructor&&) = default;
+            ArchetypeDestructor(const ArchetypeDestructor&) = default;
+            ArchetypeDestructor& operator=(ArchetypeDestructor&&) = default;
+            ArchetypeDestructor& operator=(const ArchetypeDestructor&) = default;
+            ~ArchetypeDestructor() noexcept(DestructibleValue == destructible::nothrow)
+            {
+            }
+        };
+
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue, move_assignable MoveAssignableValue, copy_assignable CopyAssignableValue>
+        struct ArchetypeDestructor<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue, CopyAssignableValue, destructible::trivial> : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue, CopyAssignableValue>
+        {
+            explicit ArchetypeDestructor(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, CopyConstructibleValue, MoveAssignableValue, CopyAssignableValue>(MakeArchetypeState(), state)
+            {
+            }
+
+            ArchetypeDestructor() = default;
+        };
+
+        // An alias to the top of the chain of bases for special-member functions.
+        // NOTE: move_constructible::maybe, move_assignable::maybe, and
+        // destructible::maybe are handled in the top-level type by way of SFINAE.
+        // Because of this, we never instantiate the base classes with
+        // move_constructible::maybe, move_assignable::maybe, or destructible::maybe so
+        // that we minimize the number of different possible type-template
+        // instantiations.
+        template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue, move_assignable MoveAssignableValue, copy_assignable CopyAssignableValue, destructible DestructibleValue>
+        using ArchetypeSpecialMembersBase = ArchetypeDestructor<
+            DefaultConstructibleValue,
+            MoveConstructibleValue != move_constructible::maybe ? MoveConstructibleValue : move_constructible::nothrow,
+            CopyConstructibleValue,
+            MoveAssignableValue != move_assignable::maybe ? MoveAssignableValue : move_assignable::nothrow,
+            CopyAssignableValue,
+            DestructibleValue != destructible::maybe ? DestructibleValue : destructible::nothrow>;
+
+        // A function that is used to create an archetype with some associated state.
+        template<class Arch>
+        Arch MakeArchetype(ArchetypeState state) noexcept
+        {
+            static_assert(IsArchetype<Arch>::value, "The explicit template argument to MakeArchetype is required "
+                                                    "to be an Archetype.");
+            return Arch(MakeArchetypeState(), state);
+        }
+
+        // This is used to conditionally delete "copy" and "move" constructors in a way
+        // that is consistent with what the ConformanceProfile requires and that also
+        // strictly enforces the arguments to the copy/move to not come from implicit
+        // conversions when dealing with the Archetype.
+        template<class Prof, class T>
+        constexpr bool ShouldDeleteConstructor()
+        {
+            return !((PropertiesOfT<Prof>::move_constructible_support != move_constructible::maybe && std::is_same<T, Archetype<Prof>>::value) || (PropertiesOfT<Prof>::copy_constructible_support != copy_constructible::maybe && (std::is_same<T, const Archetype<Prof>&>::value || std::is_same<T, Archetype<Prof>&>::value || std::is_same<T, const Archetype<Prof>>::value)));
+        }
+
+        // This is used to conditionally delete "copy" and "move" assigns in a way
+        // that is consistent with what the ConformanceProfile requires and that also
+        // strictly enforces the arguments to the copy/move to not come from implicit
+        // conversions when dealing with the Archetype.
+        template<class Prof, class T>
+        constexpr bool ShouldDeleteAssign()
+        {
+            return !(
+                (PropertiesOfT<Prof>::move_assignable_support != move_assignable::maybe &&
+                 std::is_same<T, Archetype<Prof>>::value) ||
+                (PropertiesOfT<Prof>::copy_assignable_support != copy_assignable::maybe &&
+                 (std::is_same<T, const Archetype<Prof>&>::value ||
+                  std::is_same<T, Archetype<Prof>&>::value ||
+                  std::is_same<T, const Archetype<Prof>>::value))
+            );
+        }
+
+        // TODO(calabrese) Inherit from a chain of secondary bases to pull in the
+        // associated functions of other concepts.
+        template<class Prof, class Enabler>
+        class Archetype : ArchetypeSpecialMembersBase<PropertiesOfT<Prof>::default_constructible_support, PropertiesOfT<Prof>::move_constructible_support, PropertiesOfT<Prof>::copy_constructible_support, PropertiesOfT<Prof>::move_assignable_support, PropertiesOfT<Prof>::copy_assignable_support, PropertiesOfT<Prof>::destructible_support>
+        {
+            static_assert(std::is_same<Enabler, void>::value, "An explicit type must not be passed as the second template "
+                                                              "argument to 'Archetype`.");
+
+            // The cases mentioned in these static_asserts are expected to be handled in
+            // the partial template specializations of Archetype that follow this
+            // definition.
+            static_assert(PropertiesOfT<Prof>::destructible_support != destructible::maybe, "");
+            static_assert(PropertiesOfT<Prof>::move_constructible_support != move_constructible::maybe || PropertiesOfT<Prof>::copy_constructible_support == copy_constructible::maybe, "");
+            static_assert(PropertiesOfT<Prof>::move_assignable_support != move_assignable::maybe || PropertiesOfT<Prof>::copy_assignable_support == copy_assignable::maybe, "");
+
+        public:
+            Archetype() = default;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+            Archetype(T&&) = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+            Archetype& operator=(T&&) = delete;
+
+            using ArchetypeSpecialMembersBase<
+                PropertiesOfT<Prof>::default_constructible_support,
+                PropertiesOfT<Prof>::move_constructible_support,
+                PropertiesOfT<Prof>::copy_constructible_support,
+                PropertiesOfT<Prof>::move_assignable_support,
+                PropertiesOfT<Prof>::copy_assignable_support,
+                PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+        private:
+            explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeSpecialMembersBase<
+                    PropertiesOfT<Prof>::default_constructible_support,
+                    PropertiesOfT<Prof>::move_constructible_support,
+                    PropertiesOfT<Prof>::copy_constructible_support,
+                    PropertiesOfT<Prof>::move_assignable_support,
+                    PropertiesOfT<Prof>::copy_assignable_support,
+                    PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), state)
+            {
+            }
+
+            friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+        };
+
+        template<class Prof>
+        class Archetype<Prof, typename std::enable_if<PropertiesOfT<Prof>::move_constructible_support != move_constructible::maybe && PropertiesOfT<Prof>::move_assignable_support == move_assignable::maybe && PropertiesOfT<Prof>::destructible_support != destructible::maybe>::type> : ArchetypeSpecialMembersBase<PropertiesOfT<Prof>::default_constructible_support, PropertiesOfT<Prof>::move_constructible_support, PropertiesOfT<Prof>::copy_constructible_support, PropertiesOfT<Prof>::move_assignable_support, PropertiesOfT<Prof>::copy_assignable_support, PropertiesOfT<Prof>::destructible_support>
+        {
+        public:
+            Archetype() = default;
+            Archetype(Archetype&&) = default;
+            Archetype(const Archetype&) = default;
+            Archetype& operator=(Archetype&&) = delete;
+            Archetype& operator=(const Archetype&) = default;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+            Archetype(T&&) = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+            Archetype& operator=(T&&) = delete;
+
+            using ArchetypeSpecialMembersBase<
+                PropertiesOfT<Prof>::default_constructible_support,
+                PropertiesOfT<Prof>::move_constructible_support,
+                PropertiesOfT<Prof>::copy_constructible_support,
+                PropertiesOfT<Prof>::move_assignable_support,
+                PropertiesOfT<Prof>::copy_assignable_support,
+                PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+        private:
+            explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeSpecialMembersBase<
+                    PropertiesOfT<Prof>::default_constructible_support,
+                    PropertiesOfT<Prof>::move_constructible_support,
+                    PropertiesOfT<Prof>::copy_constructible_support,
+                    PropertiesOfT<Prof>::move_assignable_support,
+                    PropertiesOfT<Prof>::copy_assignable_support,
+                    PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), state)
+            {
+            }
+
+            friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+        };
+
+        template<class Prof>
+        class Archetype<Prof, typename std::enable_if<PropertiesOfT<Prof>::move_constructible_support == move_constructible::maybe && PropertiesOfT<Prof>::move_assignable_support == move_assignable::maybe && PropertiesOfT<Prof>::destructible_support != destructible::maybe>::type> : ArchetypeSpecialMembersBase<PropertiesOfT<Prof>::default_constructible_support, PropertiesOfT<Prof>::move_constructible_support, PropertiesOfT<Prof>::copy_constructible_support, PropertiesOfT<Prof>::move_assignable_support, PropertiesOfT<Prof>::copy_assignable_support, PropertiesOfT<Prof>::destructible_support>
+        {
+        public:
+            Archetype() = default;
+            Archetype(Archetype&&) = delete;
+            Archetype(const Archetype&) = default;
+            Archetype& operator=(Archetype&&) = delete;
+            Archetype& operator=(const Archetype&) = default;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+            Archetype(T&&) = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+            Archetype& operator=(T&&) = delete;
+
+            using ArchetypeSpecialMembersBase<
+                PropertiesOfT<Prof>::default_constructible_support,
+                PropertiesOfT<Prof>::move_constructible_support,
+                PropertiesOfT<Prof>::copy_constructible_support,
+                PropertiesOfT<Prof>::move_assignable_support,
+                PropertiesOfT<Prof>::copy_assignable_support,
+                PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+        private:
+            explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeSpecialMembersBase<
+                    PropertiesOfT<Prof>::default_constructible_support,
+                    PropertiesOfT<Prof>::move_constructible_support,
+                    PropertiesOfT<Prof>::copy_constructible_support,
+                    PropertiesOfT<Prof>::move_assignable_support,
+                    PropertiesOfT<Prof>::copy_assignable_support,
+                    PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), state)
+            {
+            }
+
+            friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+        };
+
+        template<class Prof>
+        class Archetype<Prof, typename std::enable_if<PropertiesOfT<Prof>::move_constructible_support == move_constructible::maybe && PropertiesOfT<Prof>::move_assignable_support != move_assignable::maybe && PropertiesOfT<Prof>::destructible_support != destructible::maybe>::type> : ArchetypeSpecialMembersBase<PropertiesOfT<Prof>::default_constructible_support, PropertiesOfT<Prof>::move_constructible_support, PropertiesOfT<Prof>::copy_constructible_support, PropertiesOfT<Prof>::move_assignable_support, PropertiesOfT<Prof>::copy_assignable_support, PropertiesOfT<Prof>::destructible_support>
+        {
+        public:
+            Archetype() = default;
+            Archetype(Archetype&&) = delete;
+            Archetype(const Archetype&) = default;
+            Archetype& operator=(Archetype&&) = default;
+            Archetype& operator=(const Archetype&) = default;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+            Archetype(T&&) = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+            Archetype& operator=(T&&) = delete;
+
+            using ArchetypeSpecialMembersBase<
+                PropertiesOfT<Prof>::default_constructible_support,
+                PropertiesOfT<Prof>::move_constructible_support,
+                PropertiesOfT<Prof>::copy_constructible_support,
+                PropertiesOfT<Prof>::move_assignable_support,
+                PropertiesOfT<Prof>::copy_assignable_support,
+                PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+        private:
+            explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeSpecialMembersBase<
+                    PropertiesOfT<Prof>::default_constructible_support,
+                    PropertiesOfT<Prof>::move_constructible_support,
+                    PropertiesOfT<Prof>::copy_constructible_support,
+                    PropertiesOfT<Prof>::move_assignable_support,
+                    PropertiesOfT<Prof>::copy_assignable_support,
+                    PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), state)
+            {
+            }
+
+            friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+        };
+
+        template<class Prof>
+        class Archetype<Prof, typename std::enable_if<PropertiesOfT<Prof>::move_constructible_support != move_constructible::maybe && PropertiesOfT<Prof>::move_assignable_support == move_assignable::maybe && PropertiesOfT<Prof>::destructible_support == destructible::maybe>::type> : ArchetypeSpecialMembersBase<PropertiesOfT<Prof>::default_constructible_support, PropertiesOfT<Prof>::move_constructible_support, PropertiesOfT<Prof>::copy_constructible_support, PropertiesOfT<Prof>::move_assignable_support, PropertiesOfT<Prof>::copy_assignable_support, PropertiesOfT<Prof>::destructible_support>
+        {
+        public:
+            Archetype() = default;
+            Archetype(Archetype&&) = default;
+            Archetype(const Archetype&) = default;
+            Archetype& operator=(Archetype&&) = delete;
+            Archetype& operator=(const Archetype&) = default;
+            ~Archetype() = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+            Archetype(T&&) = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+            Archetype& operator=(T&&) = delete;
+
+            using ArchetypeSpecialMembersBase<
+                PropertiesOfT<Prof>::default_constructible_support,
+                PropertiesOfT<Prof>::move_constructible_support,
+                PropertiesOfT<Prof>::copy_constructible_support,
+                PropertiesOfT<Prof>::move_assignable_support,
+                PropertiesOfT<Prof>::copy_assignable_support,
+                PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+        private:
+            explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeSpecialMembersBase<
+                    PropertiesOfT<Prof>::default_constructible_support,
+                    PropertiesOfT<Prof>::move_constructible_support,
+                    PropertiesOfT<Prof>::copy_constructible_support,
+                    PropertiesOfT<Prof>::move_assignable_support,
+                    PropertiesOfT<Prof>::copy_assignable_support,
+                    PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), state)
+            {
+            }
+
+            friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+        };
+
+        template<class Prof>
+        class Archetype<Prof, typename std::enable_if<PropertiesOfT<Prof>::move_constructible_support == move_constructible::maybe && PropertiesOfT<Prof>::move_assignable_support == move_assignable::maybe && PropertiesOfT<Prof>::destructible_support == destructible::maybe>::type> : ArchetypeSpecialMembersBase<PropertiesOfT<Prof>::default_constructible_support, PropertiesOfT<Prof>::move_constructible_support, PropertiesOfT<Prof>::copy_constructible_support, PropertiesOfT<Prof>::move_assignable_support, PropertiesOfT<Prof>::copy_assignable_support, PropertiesOfT<Prof>::destructible_support>
+        {
+        public:
+            Archetype() = default;
+            Archetype(Archetype&&) = delete;
+            Archetype(const Archetype&) = default;
+            Archetype& operator=(Archetype&&) = delete;
+            Archetype& operator=(const Archetype&) = default;
+            ~Archetype() = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+            Archetype(T&&) = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+            Archetype& operator=(T&&) = delete;
+
+            using ArchetypeSpecialMembersBase<
+                PropertiesOfT<Prof>::default_constructible_support,
+                PropertiesOfT<Prof>::move_constructible_support,
+                PropertiesOfT<Prof>::copy_constructible_support,
+                PropertiesOfT<Prof>::move_assignable_support,
+                PropertiesOfT<Prof>::copy_assignable_support,
+                PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+        private:
+            explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeSpecialMembersBase<
+                    PropertiesOfT<Prof>::default_constructible_support,
+                    PropertiesOfT<Prof>::move_constructible_support,
+                    PropertiesOfT<Prof>::copy_constructible_support,
+                    PropertiesOfT<Prof>::move_assignable_support,
+                    PropertiesOfT<Prof>::copy_assignable_support,
+                    PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), state)
+            {
+            }
+
+            friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+        };
+
+        template<class Prof>
+        class Archetype<Prof, typename std::enable_if<PropertiesOfT<Prof>::move_constructible_support == move_constructible::maybe && PropertiesOfT<Prof>::move_assignable_support != move_assignable::maybe && PropertiesOfT<Prof>::destructible_support == destructible::maybe>::type> : ArchetypeSpecialMembersBase<PropertiesOfT<Prof>::default_constructible_support, PropertiesOfT<Prof>::move_constructible_support, PropertiesOfT<Prof>::copy_constructible_support, PropertiesOfT<Prof>::move_assignable_support, PropertiesOfT<Prof>::copy_assignable_support, PropertiesOfT<Prof>::destructible_support>
+        {
+        public:
+            Archetype() = default;
+            Archetype(Archetype&&) = delete;
+            Archetype(const Archetype&) = default;
+            Archetype& operator=(Archetype&&) = default;
+            Archetype& operator=(const Archetype&) = default;
+            ~Archetype() = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteConstructor<Prof, T>()>::type* = nullptr>
+            Archetype(T&&) = delete;
+
+            // Disallow moves when requested, and disallow implicit conversions.
+            template<class T, typename std::enable_if<ShouldDeleteAssign<Prof, T>()>::type* = nullptr>
+            Archetype& operator=(T&&) = delete;
+
+            using ArchetypeSpecialMembersBase<
+                PropertiesOfT<Prof>::default_constructible_support,
+                PropertiesOfT<Prof>::move_constructible_support,
+                PropertiesOfT<Prof>::copy_constructible_support,
+                PropertiesOfT<Prof>::move_assignable_support,
+                PropertiesOfT<Prof>::copy_assignable_support,
+                PropertiesOfT<Prof>::destructible_support>::archetype_state;
+
+        private:
+            explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept
+                :
+                ArchetypeSpecialMembersBase<
+                    PropertiesOfT<Prof>::default_constructible_support,
+                    PropertiesOfT<Prof>::move_constructible_support,
+                    PropertiesOfT<Prof>::copy_constructible_support,
+                    PropertiesOfT<Prof>::move_assignable_support,
+                    PropertiesOfT<Prof>::copy_assignable_support,
+                    PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), state)
+            {
+            }
+
+            friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept;
+        };
+
+        // Explicitly deleted swap for Archetype if the profile does not require swap.
+        // It is important to delete it rather than simply leave it out so that the
+        // "using std::swap;" idiom will result in this deleted overload being picked.
+        template<class Prof, absl::enable_if_t<!PropertiesOfT<Prof>::is_swappable, int> = 0>
+        void swap(Archetype<Prof>&, Archetype<Prof>&) = delete;  // NOLINT
+
+        // A conditionally-noexcept swap implementation for Archetype when the profile
+        // supports swap.
+        template<class Prof, absl::enable_if_t<PropertiesOfT<Prof>::is_swappable, int> = 0>
+        void swap(Archetype<Prof>& lhs, Archetype<Prof>& rhs)  // NOLINT
+            noexcept(PropertiesOfT<Prof>::swappable_support != swappable::yes)
+        {
+            std::swap(lhs.archetype_state, rhs.archetype_state);
+        }
+
+        // A convertible-to-bool type that is used as the return type of comparison
+        // operators since the standard doesn't always require exactly bool.
+        struct NothrowBool
+        {
+            explicit NothrowBool() = delete;
+            ~NothrowBool() = default;
+
+            // TODO(calabrese) Delete the copy constructor in C++17 mode since guaranteed
+            // elision makes it not required when returning from a function.
+            // NothrowBool(NothrowBool const&) = delete;
+
+            NothrowBool& operator=(NothrowBool const&) = delete;
+
+            explicit operator bool() const noexcept
+            {
+                return value;
+            }
+
+            static NothrowBool make(bool const value) noexcept
+            {
+                return NothrowBool(value);
+            }
+
+        private:
+            explicit NothrowBool(bool const value) noexcept :
+                value(value)
+            {
+            }
+
+            bool value;
+        };
+
+        // A convertible-to-bool type that is used as the return type of comparison
+        // operators since the standard doesn't always require exactly bool.
+        // Note: ExceptionalBool has a conversion operator that is not noexcept, so
+        // that even when a comparison operator is noexcept, that operation may still
+        // potentially throw when converted to bool.
+        struct ExceptionalBool
+        {
+            explicit ExceptionalBool() = delete;
+            ~ExceptionalBool() = default;
+
+            // TODO(calabrese) Delete the copy constructor in C++17 mode since guaranteed
+            // elision makes it not required when returning from a function.
+            // ExceptionalBool(ExceptionalBool const&) = delete;
+
+            ExceptionalBool& operator=(ExceptionalBool const&) = delete;
+
+            explicit operator bool() const
+            {
+                return value;
+            }  // NOLINT
+
+            static ExceptionalBool make(bool const value) noexcept
+            {
+                return ExceptionalBool(value);
+            }
+
+        private:
+            explicit ExceptionalBool(bool const value) noexcept :
+                value(value)
+            {
+            }
+
+            bool value;
+        };
 
 // The following macro is only used as a helper in this file to stamp out
 // comparison operator definitions. It is undefined after usage.
 //
 // NOTE: Non-nothrow operators throw via their result's conversion to bool even
 // though the operation itself is noexcept.
-#define ABSL_TYPES_INTERNAL_OP(enum_name, op)                                \
-  template <class Prof>                                                      \
-  absl::enable_if_t<!PropertiesOfT<Prof>::is_##enum_name, bool> operator op( \
-      const Archetype<Prof>&, const Archetype<Prof>&) = delete;              \
-                                                                             \
-  template <class Prof>                                                      \
-  typename absl::enable_if_t<                                                \
-      PropertiesOfT<Prof>::is_##enum_name,                                   \
-      std::conditional<PropertiesOfT<Prof>::enum_name##_support ==           \
-                           enum_name::nothrow,                               \
-                       NothrowBool, ExceptionalBool>>::type                  \
-  operator op(const Archetype<Prof>& lhs,                                    \
-              const Archetype<Prof>& rhs) noexcept {                         \
-    return absl::conditional_t<                                              \
-        PropertiesOfT<Prof>::enum_name##_support == enum_name::nothrow,      \
-        NothrowBool, ExceptionalBool>::make(lhs.archetype_state op           \
-                                                rhs.archetype_state);        \
-  }
-
-ABSL_TYPES_INTERNAL_OP(equality_comparable, ==);
-ABSL_TYPES_INTERNAL_OP(inequality_comparable, !=);
-ABSL_TYPES_INTERNAL_OP(less_than_comparable, <);
-ABSL_TYPES_INTERNAL_OP(less_equal_comparable, <=);
-ABSL_TYPES_INTERNAL_OP(greater_equal_comparable, >=);
-ABSL_TYPES_INTERNAL_OP(greater_than_comparable, >);
+#define ABSL_TYPES_INTERNAL_OP(enum_name, op)                                                                                 \
+    template<class Prof>                                                                                                      \
+    absl::enable_if_t<!PropertiesOfT<Prof>::is_##enum_name, bool> operator op(                                                \
+        const Archetype<Prof>&, const Archetype<Prof>&                                                                        \
+    ) = delete;                                                                                                               \
+                                                                                                                              \
+    template<class Prof>                                                                                                      \
+    typename absl::enable_if_t<                                                                                               \
+        PropertiesOfT<Prof>::is_##enum_name,                                                                                  \
+        std::conditional<PropertiesOfT<Prof>::enum_name##_support == enum_name::nothrow, NothrowBool, ExceptionalBool>>::type \
+        operator op(const Archetype<Prof>& lhs, const Archetype<Prof>& rhs) noexcept                                          \
+    {                                                                                                                         \
+        return absl::conditional_t<                                                                                           \
+            PropertiesOfT<Prof>::enum_name##_support == enum_name::nothrow,                                                   \
+            NothrowBool,                                                                                                      \
+            ExceptionalBool>::make(lhs.archetype_state op                                                                     \
+                                       rhs.archetype_state);                                                                  \
+    }
+
+        ABSL_TYPES_INTERNAL_OP(equality_comparable, ==);
+        ABSL_TYPES_INTERNAL_OP(inequality_comparable, !=);
+        ABSL_TYPES_INTERNAL_OP(less_than_comparable, <);
+        ABSL_TYPES_INTERNAL_OP(less_equal_comparable, <=);
+        ABSL_TYPES_INTERNAL_OP(greater_equal_comparable, >=);
+        ABSL_TYPES_INTERNAL_OP(greater_than_comparable, >);
 
 #undef ABSL_TYPES_INTERNAL_OP
 
-// Base class for std::hash specializations when an Archetype doesn't support
-// hashing.
-struct PoisonedHash {
-  PoisonedHash() = delete;
-  PoisonedHash(const PoisonedHash&) = delete;
-  PoisonedHash& operator=(const PoisonedHash&) = delete;
-};
-
-// Base class for std::hash specializations when an Archetype supports hashing.
-template <class Prof>
-struct EnabledHash {
-  using argument_type = Archetype<Prof>;
-  using result_type = std::size_t;
-  result_type operator()(const argument_type& arg) const {
-    return std::hash<ArchetypeState>()(arg.archetype_state);
-  }
-};
-
-}  // namespace types_internal
-ABSL_NAMESPACE_END
+        // Base class for std::hash specializations when an Archetype doesn't support
+        // hashing.
+        struct PoisonedHash
+        {
+            PoisonedHash() = delete;
+            PoisonedHash(const PoisonedHash&) = delete;
+            PoisonedHash& operator=(const PoisonedHash&) = delete;
+        };
+
+        // Base class for std::hash specializations when an Archetype supports hashing.
+        template<class Prof>
+        struct EnabledHash
+        {
+            using argument_type = Archetype<Prof>;
+            using result_type = std::size_t;
+            result_type operator()(const argument_type& arg) const
+            {
+                return std::hash<ArchetypeState>()(arg.archetype_state);
+            }
+        };
+
+    }  // namespace types_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
-namespace std {
+namespace std
+{
 
-template <class Prof>  // NOLINT
-struct hash<::absl::types_internal::Archetype<Prof>>
-    : conditional<::absl::types_internal::PropertiesOfT<Prof>::is_hashable,
-                  ::absl::types_internal::EnabledHash<Prof>,
-                  ::absl::types_internal::PoisonedHash>::type {};
+    template<class Prof>  // NOLINT
+    struct hash<::absl::types_internal::Archetype<Prof>> : conditional<::absl::types_internal::PropertiesOfT<Prof>::is_hashable, ::absl::types_internal::EnabledHash<Prof>, ::absl::types_internal::PoisonedHash>::type
+    {
+    };
 
 }  // namespace std
 
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_profile.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_profile.h
index 37b017d..932f498 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/conformance_profile.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_profile.h
@@ -52,397 +52,442 @@
 
 // TODO(calabrese) Add support for extending profiles.
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace types_internal {
-
-// Converts an enum to its underlying integral value.
-template <typename Enum>
-constexpr absl::underlying_type_t<Enum> UnderlyingValue(Enum value) {
-  return static_cast<absl::underlying_type_t<Enum>>(value);
-}
-
-// A tag type used in place of a matcher when checking that an assertion result
-// does not actually contain any errors.
-struct NoError {};
-
-// -----------------------------------------------------------------------------
-// ConformanceErrors
-// -----------------------------------------------------------------------------
-class ConformanceErrors {
- public:
-  // Setup the error reporting mechanism by seeding it with the name of the type
-  // that is being tested.
-  explicit ConformanceErrors(std::string type_name)
-      : assertion_result_(false), type_name_(std::move(type_name)) {
-    assertion_result_ << "\n\n"
-                         "Assuming the following type alias:\n"
-                         "\n"
-                         "  using _T = "
-                      << type_name_ << ";\n\n";
-    outputDivider();
-  }
-
-  // Adds the test name to the list of successfully run tests iff it was not
-  // previously reported as failing. This behavior is useful for tests that
-  // have multiple parts, where failures and successes are reported individually
-  // with the same test name.
-  void addTestSuccess(absl::string_view test_name) {
-    auto normalized_test_name = absl::AsciiStrToLower(test_name);
-
-    // If the test is already reported as failing, do not add it to the list of
-    // successes.
-    if (test_failures_.find(normalized_test_name) == test_failures_.end()) {
-      test_successes_.insert(std::move(normalized_test_name));
-    }
-  }
-
-  // Streams a single error description into the internal buffer (a visual
-  // divider is automatically inserted after the error so that multiple errors
-  // are visibly distinct).
-  //
-  // This function increases the error count by 1.
-  //
-  // TODO(calabrese) Determine desired behavior when if this function throws.
-  template <class... P>
-  void addTestFailure(absl::string_view test_name, const P&... args) {
-    // Output a message related to the test failure.
-    assertion_result_ << "\n\n"
-                         "Failed test: "
-                      << test_name << "\n\n";
-    addTestFailureImpl(args...);
-    assertion_result_ << "\n\n";
-    outputDivider();
-
-    auto normalized_test_name = absl::AsciiStrToLower(test_name);
-
-    // If previous parts of this test succeeded, remove it from that set.
-    test_successes_.erase(normalized_test_name);
-
-    // Add the test name to the list of failed tests.
-    test_failures_.insert(std::move(normalized_test_name));
-
-    has_error_ = true;
-  }
-
-  // Convert this object into a testing::AssertionResult instance such that it
-  // can be used with gtest.
-  ::testing::AssertionResult assertionResult() const {
-    return has_error_ ? assertion_result_ : ::testing::AssertionSuccess();
-  }
-
-  // Convert this object into a testing::AssertionResult instance such that it
-  // can be used with gtest. This overload expects errors, using the specified
-  // matcher.
-  ::testing::AssertionResult expectFailedTests(
-      const std::set<std::string>& test_names) const {
-    // Since we are expecting nonconformance, output an error message when the
-    // type actually conformed to the specified profile.
-    if (!has_error_) {
-      return ::testing::AssertionFailure()
-             << "Unexpected conformance of type:\n"
-                "    "
-             << type_name_ << "\n\n";
-    }
-
-    // Get a list of all expected failures that did not actually fail
-    // (or that were not run).
-    std::vector<std::string> nonfailing_tests;
-    absl::c_set_difference(test_names, test_failures_,
-                           std::back_inserter(nonfailing_tests));
-
-    // Get a list of all "expected failures" that were never actually run.
-    std::vector<std::string> unrun_tests;
-    absl::c_set_difference(nonfailing_tests, test_successes_,
-                           std::back_inserter(unrun_tests));
-
-    // Report when the user specified tests that were not run.
-    if (!unrun_tests.empty()) {
-      const bool tests_were_run =
-          !(test_failures_.empty() && test_successes_.empty());
-
-      // Prepare an assertion result used in the case that tests pass that were
-      // expected to fail.
-      ::testing::AssertionResult result = ::testing::AssertionFailure();
-      result << "When testing type:\n    " << type_name_
-             << "\n\nThe following tests were expected to fail but were not "
-                "run";
-
-      if (tests_were_run) result << " (was the test name spelled correctly?)";
-
-      result << ":\n\n";
-
-      // List all of the tests that unexpectedly passed.
-      for (const auto& test_name : unrun_tests) {
-        result << "    " << test_name << "\n";
-      }
-
-      if (!tests_were_run) result << "\nNo tests were run.";
-
-      if (!test_failures_.empty()) {
-        // List test failures
-        result << "\nThe tests that were run and failed are:\n\n";
-        for (const auto& test_name : test_failures_) {
-          result << "    " << test_name << "\n";
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace types_internal
+    {
+
+        // Converts an enum to its underlying integral value.
+        template<typename Enum>
+        constexpr absl::underlying_type_t<Enum> UnderlyingValue(Enum value)
+        {
+            return static_cast<absl::underlying_type_t<Enum>>(value);
         }
-      }
 
-      if (!test_successes_.empty()) {
-        // List test successes
-        result << "\nThe tests that were run and succeeded are:\n\n";
-        for (const auto& test_name : test_successes_) {
-          result << "    " << test_name << "\n";
+        // A tag type used in place of a matcher when checking that an assertion result
+        // does not actually contain any errors.
+        struct NoError
+        {
+        };
+
+        // -----------------------------------------------------------------------------
+        // ConformanceErrors
+        // -----------------------------------------------------------------------------
+        class ConformanceErrors
+        {
+        public:
+            // Setup the error reporting mechanism by seeding it with the name of the type
+            // that is being tested.
+            explicit ConformanceErrors(std::string type_name) :
+                assertion_result_(false),
+                type_name_(std::move(type_name))
+            {
+                assertion_result_ << "\n\n"
+                                     "Assuming the following type alias:\n"
+                                     "\n"
+                                     "  using _T = "
+                                  << type_name_ << ";\n\n";
+                outputDivider();
+            }
+
+            // Adds the test name to the list of successfully run tests iff it was not
+            // previously reported as failing. This behavior is useful for tests that
+            // have multiple parts, where failures and successes are reported individually
+            // with the same test name.
+            void addTestSuccess(absl::string_view test_name)
+            {
+                auto normalized_test_name = absl::AsciiStrToLower(test_name);
+
+                // If the test is already reported as failing, do not add it to the list of
+                // successes.
+                if (test_failures_.find(normalized_test_name) == test_failures_.end())
+                {
+                    test_successes_.insert(std::move(normalized_test_name));
+                }
+            }
+
+            // Streams a single error description into the internal buffer (a visual
+            // divider is automatically inserted after the error so that multiple errors
+            // are visibly distinct).
+            //
+            // This function increases the error count by 1.
+            //
+            // TODO(calabrese) Determine desired behavior when if this function throws.
+            template<class... P>
+            void addTestFailure(absl::string_view test_name, const P&... args)
+            {
+                // Output a message related to the test failure.
+                assertion_result_ << "\n\n"
+                                     "Failed test: "
+                                  << test_name << "\n\n";
+                addTestFailureImpl(args...);
+                assertion_result_ << "\n\n";
+                outputDivider();
+
+                auto normalized_test_name = absl::AsciiStrToLower(test_name);
+
+                // If previous parts of this test succeeded, remove it from that set.
+                test_successes_.erase(normalized_test_name);
+
+                // Add the test name to the list of failed tests.
+                test_failures_.insert(std::move(normalized_test_name));
+
+                has_error_ = true;
+            }
+
+            // Convert this object into a testing::AssertionResult instance such that it
+            // can be used with gtest.
+            ::testing::AssertionResult assertionResult() const
+            {
+                return has_error_ ? assertion_result_ : ::testing::AssertionSuccess();
+            }
+
+            // Convert this object into a testing::AssertionResult instance such that it
+            // can be used with gtest. This overload expects errors, using the specified
+            // matcher.
+            ::testing::AssertionResult expectFailedTests(
+                const std::set<std::string>& test_names
+            ) const
+            {
+                // Since we are expecting nonconformance, output an error message when the
+                // type actually conformed to the specified profile.
+                if (!has_error_)
+                {
+                    return ::testing::AssertionFailure()
+                           << "Unexpected conformance of type:\n"
+                              "    "
+                           << type_name_ << "\n\n";
+                }
+
+                // Get a list of all expected failures that did not actually fail
+                // (or that were not run).
+                std::vector<std::string> nonfailing_tests;
+                absl::c_set_difference(test_names, test_failures_, std::back_inserter(nonfailing_tests));
+
+                // Get a list of all "expected failures" that were never actually run.
+                std::vector<std::string> unrun_tests;
+                absl::c_set_difference(nonfailing_tests, test_successes_, std::back_inserter(unrun_tests));
+
+                // Report when the user specified tests that were not run.
+                if (!unrun_tests.empty())
+                {
+                    const bool tests_were_run =
+                        !(test_failures_.empty() && test_successes_.empty());
+
+                    // Prepare an assertion result used in the case that tests pass that were
+                    // expected to fail.
+                    ::testing::AssertionResult result = ::testing::AssertionFailure();
+                    result << "When testing type:\n    " << type_name_
+                           << "\n\nThe following tests were expected to fail but were not "
+                              "run";
+
+                    if (tests_were_run)
+                        result << " (was the test name spelled correctly?)";
+
+                    result << ":\n\n";
+
+                    // List all of the tests that unexpectedly passed.
+                    for (const auto& test_name : unrun_tests)
+                    {
+                        result << "    " << test_name << "\n";
+                    }
+
+                    if (!tests_were_run)
+                        result << "\nNo tests were run.";
+
+                    if (!test_failures_.empty())
+                    {
+                        // List test failures
+                        result << "\nThe tests that were run and failed are:\n\n";
+                        for (const auto& test_name : test_failures_)
+                        {
+                            result << "    " << test_name << "\n";
+                        }
+                    }
+
+                    if (!test_successes_.empty())
+                    {
+                        // List test successes
+                        result << "\nThe tests that were run and succeeded are:\n\n";
+                        for (const auto& test_name : test_successes_)
+                        {
+                            result << "    " << test_name << "\n";
+                        }
+                    }
+
+                    return result;
+                }
+
+                // If some tests passed when they were expected to fail, alert the caller.
+                if (nonfailing_tests.empty())
+                    return ::testing::AssertionSuccess();
+
+                // Prepare an assertion result used in the case that tests pass that were
+                // expected to fail.
+                ::testing::AssertionResult unexpected_successes =
+                    ::testing::AssertionFailure();
+                unexpected_successes << "When testing type:\n    " << type_name_
+                                     << "\n\nThe following tests passed when they were "
+                                        "expected to fail:\n\n";
+
+                // List all of the tests that unexpectedly passed.
+                for (const auto& test_name : nonfailing_tests)
+                {
+                    unexpected_successes << "    " << test_name << "\n";
+                }
+
+                return unexpected_successes;
+            }
+
+        private:
+            void outputDivider()
+            {
+                assertion_result_ << "========================================";
+            }
+
+            void addTestFailureImpl()
+            {
+            }
+
+            template<class H, class... T>
+            void addTestFailureImpl(const H& head, const T&... tail)
+            {
+                assertion_result_ << head;
+                addTestFailureImpl(tail...);
+            }
+
+            ::testing::AssertionResult assertion_result_;
+            std::set<std::string> test_failures_;
+            std::set<std::string> test_successes_;
+            std::string type_name_;
+            bool has_error_ = false;
+        };
+
+        template<class T, class /*Enabler*/ = void>
+        struct PropertiesOfImpl
+        {
+        };
+
+        template<class T>
+        struct PropertiesOfImpl<T, absl::void_t<typename T::properties>>
+        {
+            using type = typename T::properties;
+        };
+
+        template<class T>
+        struct PropertiesOfImpl<T, absl::void_t<typename T::profile_alias_of>>
+        {
+            using type = typename PropertiesOfImpl<typename T::profile_alias_of>::type;
+        };
+
+        template<class T>
+        struct PropertiesOf : PropertiesOfImpl<T>
+        {
+        };
+
+        template<class T>
+        using PropertiesOfT = typename PropertiesOf<T>::type;
+
+        // NOTE: These enums use this naming convention to be consistent with the
+        // standard trait names, which is useful since it allows us to match up each
+        // enum name with a corresponding trait name in macro definitions.
+
+        // An enum that describes the various expectations on an operations existence.
+        enum class function_support
+        {
+            maybe,
+            yes,
+            nothrow,
+            trivial
+        };
+
+        constexpr const char* PessimisticPropertyDescription(function_support v)
+        {
+            return v == function_support::maybe ? "no" : v == function_support::yes ? "yes, potentially throwing" :
+                                                     v == function_support::nothrow ? "yes, nothrow" :
+                                                                                      "yes, trivial";
         }
-      }
-
-      return result;
-    }
-
-    // If some tests passed when they were expected to fail, alert the caller.
-    if (nonfailing_tests.empty()) return ::testing::AssertionSuccess();
 
-    // Prepare an assertion result used in the case that tests pass that were
-    // expected to fail.
-    ::testing::AssertionResult unexpected_successes =
-        ::testing::AssertionFailure();
-    unexpected_successes << "When testing type:\n    " << type_name_
-                         << "\n\nThe following tests passed when they were "
-                            "expected to fail:\n\n";
-
-    // List all of the tests that unexpectedly passed.
-    for (const auto& test_name : nonfailing_tests) {
-      unexpected_successes << "    " << test_name << "\n";
-    }
+        // Return a string that describes the kind of property support that was
+        // expected.
+        inline std::string ExpectedFunctionKindList(function_support min, function_support max)
+        {
+            if (min == max)
+            {
+                std::string result =
+                    absl::StrCat("Expected:\n  ", PessimisticPropertyDescription(static_cast<function_support>(UnderlyingValue(min))), "\n");
+                return result;
+            }
+
+            std::string result = "Expected one of:\n";
+            for (auto curr_support = UnderlyingValue(min);
+                 curr_support <= UnderlyingValue(max);
+                 ++curr_support)
+            {
+                absl::StrAppend(&result, "  ", PessimisticPropertyDescription(static_cast<function_support>(curr_support)), "\n");
+            }
+
+            return result;
+        }
 
-    return unexpected_successes;
-  }
-
- private:
-  void outputDivider() {
-    assertion_result_ << "========================================";
-  }
-
-  void addTestFailureImpl() {}
-
-  template <class H, class... T>
-  void addTestFailureImpl(const H& head, const T&... tail) {
-    assertion_result_ << head;
-    addTestFailureImpl(tail...);
-  }
-
-  ::testing::AssertionResult assertion_result_;
-  std::set<std::string> test_failures_;
-  std::set<std::string> test_successes_;
-  std::string type_name_;
-  bool has_error_ = false;
-};
-
-template <class T, class /*Enabler*/ = void>
-struct PropertiesOfImpl {};
-
-template <class T>
-struct PropertiesOfImpl<T, absl::void_t<typename T::properties>> {
-  using type = typename T::properties;
-};
-
-template <class T>
-struct PropertiesOfImpl<T, absl::void_t<typename T::profile_alias_of>> {
-  using type = typename PropertiesOfImpl<typename T::profile_alias_of>::type;
-};
-
-template <class T>
-struct PropertiesOf : PropertiesOfImpl<T> {};
-
-template <class T>
-using PropertiesOfT = typename PropertiesOf<T>::type;
-
-// NOTE: These enums use this naming convention to be consistent with the
-// standard trait names, which is useful since it allows us to match up each
-// enum name with a corresponding trait name in macro definitions.
-
-// An enum that describes the various expectations on an operations existence.
-enum class function_support { maybe, yes, nothrow, trivial };
-
-constexpr const char* PessimisticPropertyDescription(function_support v) {
-  return v == function_support::maybe
-             ? "no"
-             : v == function_support::yes
-                   ? "yes, potentially throwing"
-                   : v == function_support::nothrow ? "yes, nothrow"
-                                                    : "yes, trivial";
-}
-
-// Return a string that describes the kind of property support that was
-// expected.
-inline std::string ExpectedFunctionKindList(function_support min,
-                                            function_support max) {
-  if (min == max) {
-    std::string result =
-        absl::StrCat("Expected:\n  ",
-                     PessimisticPropertyDescription(
-                         static_cast<function_support>(UnderlyingValue(min))),
-                     "\n");
-    return result;
-  }
-
-  std::string result = "Expected one of:\n";
-  for (auto curr_support = UnderlyingValue(min);
-       curr_support <= UnderlyingValue(max); ++curr_support) {
-    absl::StrAppend(&result, "  ",
-                    PessimisticPropertyDescription(
-                        static_cast<function_support>(curr_support)),
-                    "\n");
-  }
-
-  return result;
-}
-
-template <class Enum>
-void ExpectModelOfImpl(ConformanceErrors* errors, Enum min_support,
-                       Enum max_support, Enum kind) {
-  const auto kind_value = UnderlyingValue(kind);
-  const auto min_support_value = UnderlyingValue(min_support);
-  const auto max_support_value = UnderlyingValue(max_support);
-
-  if (!(kind_value >= min_support_value && kind_value <= max_support_value)) {
-    errors->addTestFailure(
-        PropertyName(kind), "**Failed property expectation**\n\n",
-        ExpectedFunctionKindList(
-            static_cast<function_support>(min_support_value),
-            static_cast<function_support>(max_support_value)),
-        '\n', "Actual:\n  ",
-        PessimisticPropertyDescription(
-            static_cast<function_support>(kind_value)));
-  } else {
-    errors->addTestSuccess(PropertyName(kind));
-  }
-}
+        template<class Enum>
+        void ExpectModelOfImpl(ConformanceErrors* errors, Enum min_support, Enum max_support, Enum kind)
+        {
+            const auto kind_value = UnderlyingValue(kind);
+            const auto min_support_value = UnderlyingValue(min_support);
+            const auto max_support_value = UnderlyingValue(max_support);
+
+            if (!(kind_value >= min_support_value && kind_value <= max_support_value))
+            {
+                errors->addTestFailure(
+                    PropertyName(kind), "**Failed property expectation**\n\n", ExpectedFunctionKindList(static_cast<function_support>(min_support_value), static_cast<function_support>(max_support_value)), '\n', "Actual:\n  ", PessimisticPropertyDescription(static_cast<function_support>(kind_value))
+                );
+            }
+            else
+            {
+                errors->addTestSuccess(PropertyName(kind));
+            }
+        }
 
 #define ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM(description, name) \
-  enum class name { maybe, yes, nothrow, trivial };                   \
+    enum class name                                                   \
+    {                                                                 \
+        maybe,                                                        \
+        yes,                                                          \
+        nothrow,                                                      \
+        trivial                                                       \
+    };                                                                \
                                                                       \
-  constexpr const char* PropertyName(name v) { return description; }  \
-  static_assert(true, "")  // Force a semicolon when using this macro.
-
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for default construction",
-                                           default_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move construction",
-                                           move_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy construction",
-                                           copy_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move assignment",
-                                           move_assignable);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy assignment",
-                                           copy_assignable);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for destruction",
-                                           destructible);
+    constexpr const char* PropertyName(name v)                        \
+    {                                                                 \
+        return description;                                           \
+    }                                                                 \
+    static_assert(true, "")  // Force a semicolon when using this macro.
+
+        ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for default construction", default_constructible);
+        ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move construction", move_constructible);
+        ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy construction", copy_constructible);
+        ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move assignment", move_assignable);
+        ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy assignment", copy_assignable);
+        ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for destruction", destructible);
 
 #undef ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM
 
-#define ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM(description, name)     \
-  enum class name { maybe, yes, nothrow };                           \
-                                                                     \
-  constexpr const char* PropertyName(name v) { return description; } \
-  static_assert(true, "")  // Force a semicolon when using this macro.
-
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for ==", equality_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for !=", inequality_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <", less_than_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <=", less_equal_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >=",
-                                      greater_equal_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >", greater_than_comparable);
-
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for swap", swappable);
+#define ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM(description, name) \
+    enum class name                                              \
+    {                                                            \
+        maybe,                                                   \
+        yes,                                                     \
+        nothrow                                                  \
+    };                                                           \
+                                                                 \
+    constexpr const char* PropertyName(name v)                   \
+    {                                                            \
+        return description;                                      \
+    }                                                            \
+    static_assert(true, "")  // Force a semicolon when using this macro.
+
+        ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for ==", equality_comparable);
+        ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for !=", inequality_comparable);
+        ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <", less_than_comparable);
+        ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <=", less_equal_comparable);
+        ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >=", greater_equal_comparable);
+        ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >", greater_than_comparable);
+
+        ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for swap", swappable);
 
 #undef ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM
 
-enum class hashable { maybe, yes };
+        enum class hashable
+        {
+            maybe,
+            yes
+        };
 
-constexpr const char* PropertyName(hashable v) {
-  return "support for std::hash";
-}
-
-template <class T>
-using AlwaysFalse = std::false_type;
+        constexpr const char* PropertyName(hashable v)
+        {
+            return "support for std::hash";
+        }
 
-#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(name, property)   \
-  template <class T>                                                        \
-  constexpr property property##_support_of() {                              \
-    return std::is_##property<T>::value                                     \
-               ? std::is_nothrow_##property<T>::value                       \
-                     ? absl::is_trivially_##property<T>::value              \
-                           ? property::trivial                              \
-                           : property::nothrow                              \
-                     : property::yes                                        \
-               : property::maybe;                                           \
-  }                                                                         \
-                                                                            \
-  template <class T, class MinProf, class MaxProf>                          \
-  void ExpectModelOf##name(ConformanceErrors* errors) {                     \
-    (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support, \
-                        PropertiesOfT<MaxProf>::property##_support,         \
-                        property##_support_of<T>());                        \
-  }
+        template<class T>
+        using AlwaysFalse = std::false_type;
+
+#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(name, property)                                                                                                                               \
+    template<class T>                                                                                                                                                                                   \
+    constexpr property property##_support_of()                                                                                                                                                          \
+    {                                                                                                                                                                                                   \
+        return std::is_##property<T>::value ? std::is_nothrow_##property<T>::value ? absl::is_trivially_##property<T>::value ? property::trivial : property::nothrow : property::yes : property::maybe; \
+    }                                                                                                                                                                                                   \
+                                                                                                                                                                                                        \
+    template<class T, class MinProf, class MaxProf>                                                                                                                                                     \
+    void ExpectModelOf##name(ConformanceErrors* errors)                                                                                                                                                 \
+    {                                                                                                                                                                                                   \
+        (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support, PropertiesOfT<MaxProf>::property##_support, property##_support_of<T>());                                                \
+    }
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(DefaultConstructible,
-                                                  default_constructible);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(DefaultConstructible, default_constructible);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveConstructible,
-                                                  move_constructible);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveConstructible, move_constructible);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyConstructible,
-                                                  copy_constructible);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyConstructible, copy_constructible);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveAssignable,
-                                                  move_assignable);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveAssignable, move_assignable);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyAssignable,
-                                                  copy_assignable);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyAssignable, copy_assignable);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(Destructible, destructible);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(Destructible, destructible);
 
 #undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER
 
-void BoolFunction(bool) noexcept;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction for checking if an operation exists through SFINAE.
-//
-// `T` is the type to test and Op is an alias containing the expression to test.
-template <class T, template <class...> class Op, class = void>
-struct IsOpableImpl : std::false_type {};
-
-template <class T, template <class...> class Op>
-struct IsOpableImpl<T, Op, absl::void_t<Op<T>>> : std::true_type {};
-
-template <template <class...> class Op>
-struct IsOpable {
-  template <class T>
-  using apply = typename IsOpableImpl<T, Op>::type;
-};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction for checking if an operation exists and is also noexcept
-// through SFINAE and the noexcept operator.
-///
-// `T` is the type to test and Op is an alias containing the expression to test.
-template <class T, template <class...> class Op, class = void>
-struct IsNothrowOpableImpl : std::false_type {};
-
-template <class T, template <class...> class Op>
-struct IsNothrowOpableImpl<T, Op, absl::enable_if_t<Op<T>::value>>
-    : std::true_type {};
-
-template <template <class...> class Op>
-struct IsNothrowOpable {
-  template <class T>
-  using apply = typename IsNothrowOpableImpl<T, Op>::type;
-};
+        void BoolFunction(bool) noexcept;
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction for checking if an operation exists through SFINAE.
+        //
+        // `T` is the type to test and Op is an alias containing the expression to test.
+        template<class T, template<class...> class Op, class = void>
+        struct IsOpableImpl : std::false_type
+        {
+        };
+
+        template<class T, template<class...> class Op>
+        struct IsOpableImpl<T, Op, absl::void_t<Op<T>>> : std::true_type
+        {
+        };
+
+        template<template<class...> class Op>
+        struct IsOpable
+        {
+            template<class T>
+            using apply = typename IsOpableImpl<T, Op>::type;
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction for checking if an operation exists and is also noexcept
+        // through SFINAE and the noexcept operator.
+        ///
+        // `T` is the type to test and Op is an alias containing the expression to test.
+        template<class T, template<class...> class Op, class = void>
+        struct IsNothrowOpableImpl : std::false_type
+        {
+        };
+
+        template<class T, template<class...> class Op>
+        struct IsNothrowOpableImpl<T, Op, absl::enable_if_t<Op<T>::value>> : std::true_type
+        {
+        };
+
+        template<template<class...> class Op>
+        struct IsNothrowOpable
+        {
+            template<class T>
+            using apply = typename IsNothrowOpableImpl<T, Op>::type;
+        };
 //
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -452,482 +497,505 @@ struct IsNothrowOpable {
 // support a specific comparison operation has and a function for reporting an
 // error if a given type's support for that operation does not meet the expected
 // requirements.
-#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(name, property, op)      \
-  template <class T,                                                           \
-            class Result = std::integral_constant<                             \
-                bool, noexcept((BoolFunction)(std::declval<const T&>() op      \
-                                                  std::declval<const T&>()))>> \
-  using name = Result;                                                         \
-                                                                               \
-  template <class T>                                                           \
-  constexpr property property##_support_of() {                                 \
-    return IsOpable<name>::apply<T>::value                                     \
-               ? IsNothrowOpable<name>::apply<T>::value ? property::nothrow    \
-                                                        : property::yes        \
-               : property::maybe;                                              \
-  }                                                                            \
-                                                                               \
-  template <class T, class MinProf, class MaxProf>                             \
-  void ExpectModelOf##name(ConformanceErrors* errors) {                        \
-    (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support,    \
-                        PropertiesOfT<MaxProf>::property##_support,            \
-                        property##_support_of<T>());                           \
-  }
-//
-////////////////////////////////////////////////////////////////////////////////
+#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(name, property, op)                                                                                \
+    template<class T, class Result = std::integral_constant<bool, noexcept((BoolFunction)(std::declval<const T&>() op std::declval<const T&>()))>>       \
+    using name = Result;                                                                                                                                 \
+                                                                                                                                                         \
+    template<class T>                                                                                                                                    \
+    constexpr property property##_support_of()                                                                                                           \
+    {                                                                                                                                                    \
+        return IsOpable<name>::apply<T>::value ? IsNothrowOpable<name>::apply<T>::value ? property::nothrow : property::yes : property::maybe;           \
+    }                                                                                                                                                    \
+                                                                                                                                                         \
+    template<class T, class MinProf, class MaxProf>                                                                                                      \
+    void ExpectModelOf##name(ConformanceErrors* errors)                                                                                                  \
+    {                                                                                                                                                    \
+        (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support, PropertiesOfT<MaxProf>::property##_support, property##_support_of<T>()); \
+    }
+        //
+        ////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// Generate the necessary support-checking and error reporting functions for
-// each of the comparison operators.
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(EqualityComparable,
-                                              equality_comparable, ==);
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // Generate the necessary support-checking and error reporting functions for
+        // each of the comparison operators.
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(EqualityComparable, equality_comparable, ==);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(InequalityComparable,
-                                              inequality_comparable, !=);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(InequalityComparable, inequality_comparable, !=);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessThanComparable,
-                                              less_than_comparable, <);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessThanComparable, less_than_comparable, <);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessEqualComparable,
-                                              less_equal_comparable, <=);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessEqualComparable, less_equal_comparable, <=);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterEqualComparable,
-                                              greater_equal_comparable, >=);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterEqualComparable, greater_equal_comparable, >=);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterThanComparable,
-                                              greater_than_comparable, >);
+        ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterThanComparable, greater_than_comparable, >);
 
 #undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// The necessary support-checking and error-reporting functions for swap.
-template <class T>
-constexpr swappable swappable_support_of() {
-  return type_traits_internal::IsSwappable<T>::value
-             ? type_traits_internal::IsNothrowSwappable<T>::value
-                   ? swappable::nothrow
-                   : swappable::yes
-             : swappable::maybe;
-}
-
-template <class T, class MinProf, class MaxProf>
-void ExpectModelOfSwappable(ConformanceErrors* errors) {
-  (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::swappable_support,
-                      PropertiesOfT<MaxProf>::swappable_support,
-                      swappable_support_of<T>());
-}
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// The necessary support-checking and error-reporting functions for std::hash.
-template <class T>
-constexpr hashable hashable_support_of() {
-  return type_traits_internal::IsHashable<T>::value ? hashable::yes
-                                                    : hashable::maybe;
-}
-
-template <class T, class MinProf, class MaxProf>
-void ExpectModelOfHashable(ConformanceErrors* errors) {
-  (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::hashable_support,
-                      PropertiesOfT<MaxProf>::hashable_support,
-                      hashable_support_of<T>());
-}
-//
-////////////////////////////////////////////////////////////////////////////////
-
-template <
-    default_constructible DefaultConstructibleValue =
-        default_constructible::maybe,
-    move_constructible MoveConstructibleValue = move_constructible::maybe,
-    copy_constructible CopyConstructibleValue = copy_constructible::maybe,
-    move_assignable MoveAssignableValue = move_assignable::maybe,
-    copy_assignable CopyAssignableValue = copy_assignable::maybe,
-    destructible DestructibleValue = destructible::maybe,
-    equality_comparable EqualityComparableValue = equality_comparable::maybe,
-    inequality_comparable InequalityComparableValue =
-        inequality_comparable::maybe,
-    less_than_comparable LessThanComparableValue = less_than_comparable::maybe,
-    less_equal_comparable LessEqualComparableValue =
-        less_equal_comparable::maybe,
-    greater_equal_comparable GreaterEqualComparableValue =
-        greater_equal_comparable::maybe,
-    greater_than_comparable GreaterThanComparableValue =
-        greater_than_comparable::maybe,
-    swappable SwappableValue = swappable::maybe,
-    hashable HashableValue = hashable::maybe>
-struct ConformanceProfile {
-  using properties = ConformanceProfile;
-
-  static constexpr default_constructible
-      default_constructible_support =  // NOLINT
-      DefaultConstructibleValue;
-
-  static constexpr move_constructible move_constructible_support =  // NOLINT
-      MoveConstructibleValue;
-
-  static constexpr copy_constructible copy_constructible_support =  // NOLINT
-      CopyConstructibleValue;
-
-  static constexpr move_assignable move_assignable_support =  // NOLINT
-      MoveAssignableValue;
-
-  static constexpr copy_assignable copy_assignable_support =  // NOLINT
-      CopyAssignableValue;
-
-  static constexpr destructible destructible_support =  // NOLINT
-      DestructibleValue;
-
-  static constexpr equality_comparable equality_comparable_support =  // NOLINT
-      EqualityComparableValue;
-
-  static constexpr inequality_comparable
-      inequality_comparable_support =  // NOLINT
-      InequalityComparableValue;
-
-  static constexpr less_than_comparable
-      less_than_comparable_support =  // NOLINT
-      LessThanComparableValue;
-
-  static constexpr less_equal_comparable
-      less_equal_comparable_support =  // NOLINT
-      LessEqualComparableValue;
-
-  static constexpr greater_equal_comparable
-      greater_equal_comparable_support =  // NOLINT
-      GreaterEqualComparableValue;
-
-  static constexpr greater_than_comparable
-      greater_than_comparable_support =  // NOLINT
-      GreaterThanComparableValue;
-
-  static constexpr swappable swappable_support = SwappableValue;  // NOLINT
-
-  static constexpr hashable hashable_support = HashableValue;  // NOLINT
-
-  static constexpr bool is_default_constructible =  // NOLINT
-      DefaultConstructibleValue != default_constructible::maybe;
-
-  static constexpr bool is_move_constructible =  // NOLINT
-      MoveConstructibleValue != move_constructible::maybe;
-
-  static constexpr bool is_copy_constructible =  // NOLINT
-      CopyConstructibleValue != copy_constructible::maybe;
-
-  static constexpr bool is_move_assignable =  // NOLINT
-      MoveAssignableValue != move_assignable::maybe;
-
-  static constexpr bool is_copy_assignable =  // NOLINT
-      CopyAssignableValue != copy_assignable::maybe;
-
-  static constexpr bool is_destructible =  // NOLINT
-      DestructibleValue != destructible::maybe;
-
-  static constexpr bool is_equality_comparable =  // NOLINT
-      EqualityComparableValue != equality_comparable::maybe;
-
-  static constexpr bool is_inequality_comparable =  // NOLINT
-      InequalityComparableValue != inequality_comparable::maybe;
-
-  static constexpr bool is_less_than_comparable =  // NOLINT
-      LessThanComparableValue != less_than_comparable::maybe;
-
-  static constexpr bool is_less_equal_comparable =  // NOLINT
-      LessEqualComparableValue != less_equal_comparable::maybe;
-
-  static constexpr bool is_greater_equal_comparable =  // NOLINT
-      GreaterEqualComparableValue != greater_equal_comparable::maybe;
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // The necessary support-checking and error-reporting functions for swap.
+        template<class T>
+        constexpr swappable swappable_support_of()
+        {
+            return type_traits_internal::IsSwappable<T>::value ? type_traits_internal::IsNothrowSwappable<T>::value ? swappable::nothrow : swappable::yes : swappable::maybe;
+        }
 
-  static constexpr bool is_greater_than_comparable =  // NOLINT
-      GreaterThanComparableValue != greater_than_comparable::maybe;
+        template<class T, class MinProf, class MaxProf>
+        void ExpectModelOfSwappable(ConformanceErrors* errors)
+        {
+            (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::swappable_support, PropertiesOfT<MaxProf>::swappable_support, swappable_support_of<T>());
+        }
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // The necessary support-checking and error-reporting functions for std::hash.
+        template<class T>
+        constexpr hashable hashable_support_of()
+        {
+            return type_traits_internal::IsHashable<T>::value ? hashable::yes : hashable::maybe;
+        }
 
-  static constexpr bool is_swappable =  // NOLINT
-      SwappableValue != swappable::maybe;
+        template<class T, class MinProf, class MaxProf>
+        void ExpectModelOfHashable(ConformanceErrors* errors)
+        {
+            (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::hashable_support, PropertiesOfT<MaxProf>::hashable_support, hashable_support_of<T>());
+        }
+        //
+        ////////////////////////////////////////////////////////////////////////////////
 
-  static constexpr bool is_hashable =  // NOLINT
-      HashableValue != hashable::maybe;
-};
+        template<
+            default_constructible DefaultConstructibleValue =
+                default_constructible::maybe,
+            move_constructible MoveConstructibleValue = move_constructible::maybe,
+            copy_constructible CopyConstructibleValue = copy_constructible::maybe,
+            move_assignable MoveAssignableValue = move_assignable::maybe,
+            copy_assignable CopyAssignableValue = copy_assignable::maybe,
+            destructible DestructibleValue = destructible::maybe,
+            equality_comparable EqualityComparableValue = equality_comparable::maybe,
+            inequality_comparable InequalityComparableValue =
+                inequality_comparable::maybe,
+            less_than_comparable LessThanComparableValue = less_than_comparable::maybe,
+            less_equal_comparable LessEqualComparableValue =
+                less_equal_comparable::maybe,
+            greater_equal_comparable GreaterEqualComparableValue =
+                greater_equal_comparable::maybe,
+            greater_than_comparable GreaterThanComparableValue =
+                greater_than_comparable::maybe,
+            swappable SwappableValue = swappable::maybe,
+            hashable HashableValue = hashable::maybe>
+        struct ConformanceProfile
+        {
+            using properties = ConformanceProfile;
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// Compliant SFINAE-friendliness is not always present on the standard library
-// implementations that we support. This helper-struct (and associated enum) is
-// used as a means to conditionally check the hashability support of a type.
-enum class CheckHashability { no, yes };
-
-template <class T, CheckHashability ShouldCheckHashability>
-struct conservative_hashable_support_of;
-
-template <class T>
-struct conservative_hashable_support_of<T, CheckHashability::no> {
-  static constexpr hashable Invoke() { return hashable::maybe; }
-};
-
-template <class T>
-struct conservative_hashable_support_of<T, CheckHashability::yes> {
-  static constexpr hashable Invoke() { return hashable_support_of<T>(); }
-};
-//
-////////////////////////////////////////////////////////////////////////////////
+            static constexpr default_constructible
+                default_constructible_support =  // NOLINT
+                DefaultConstructibleValue;
 
-// The ConformanceProfile that is expected based on introspection into the type
-// by way of trait checks.
-template <class T, CheckHashability ShouldCheckHashability>
-struct SyntacticConformanceProfileOf {
-  using properties = ConformanceProfile<
-      default_constructible_support_of<T>(), move_constructible_support_of<T>(),
-      copy_constructible_support_of<T>(), move_assignable_support_of<T>(),
-      copy_assignable_support_of<T>(), destructible_support_of<T>(),
-      equality_comparable_support_of<T>(),
-      inequality_comparable_support_of<T>(),
-      less_than_comparable_support_of<T>(),
-      less_equal_comparable_support_of<T>(),
-      greater_equal_comparable_support_of<T>(),
-      greater_than_comparable_support_of<T>(), swappable_support_of<T>(),
-      conservative_hashable_support_of<T, ShouldCheckHashability>::Invoke()>;
-};
-
-#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, name)     \
-  template <default_constructible DefaultConstructibleValue,                   \
-            move_constructible MoveConstructibleValue,                         \
-            copy_constructible CopyConstructibleValue,                         \
-            move_assignable MoveAssignableValue,                               \
-            copy_assignable CopyAssignableValue,                               \
-            destructible DestructibleValue,                                    \
-            equality_comparable EqualityComparableValue,                       \
-            inequality_comparable InequalityComparableValue,                   \
-            less_than_comparable LessThanComparableValue,                      \
-            less_equal_comparable LessEqualComparableValue,                    \
-            greater_equal_comparable GreaterEqualComparableValue,              \
-            greater_than_comparable GreaterThanComparableValue,                \
-            swappable SwappableValue, hashable HashableValue>                  \
-  constexpr type ConformanceProfile<                                           \
-      DefaultConstructibleValue, MoveConstructibleValue,                       \
-      CopyConstructibleValue, MoveAssignableValue, CopyAssignableValue,        \
-      DestructibleValue, EqualityComparableValue, InequalityComparableValue,   \
-      LessThanComparableValue, LessEqualComparableValue,                       \
-      GreaterEqualComparableValue, GreaterThanComparableValue, SwappableValue, \
-      HashableValue>::name
-
-#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(type)           \
-  ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type,            \
-                                                         type##_support); \
-  ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(bool, is_##type)
+            static constexpr move_constructible move_constructible_support =  // NOLINT
+                MoveConstructibleValue;
+
+            static constexpr copy_constructible copy_constructible_support =  // NOLINT
+                CopyConstructibleValue;
+
+            static constexpr move_assignable move_assignable_support =  // NOLINT
+                MoveAssignableValue;
+
+            static constexpr copy_assignable copy_assignable_support =  // NOLINT
+                CopyAssignableValue;
+
+            static constexpr destructible destructible_support =  // NOLINT
+                DestructibleValue;
+
+            static constexpr equality_comparable equality_comparable_support =  // NOLINT
+                EqualityComparableValue;
+
+            static constexpr inequality_comparable
+                inequality_comparable_support =  // NOLINT
+                InequalityComparableValue;
+
+            static constexpr less_than_comparable
+                less_than_comparable_support =  // NOLINT
+                LessThanComparableValue;
+
+            static constexpr less_equal_comparable
+                less_equal_comparable_support =  // NOLINT
+                LessEqualComparableValue;
+
+            static constexpr greater_equal_comparable
+                greater_equal_comparable_support =  // NOLINT
+                GreaterEqualComparableValue;
+
+            static constexpr greater_than_comparable
+                greater_than_comparable_support =  // NOLINT
+                GreaterThanComparableValue;
+
+            static constexpr swappable swappable_support = SwappableValue;  // NOLINT
+
+            static constexpr hashable hashable_support = HashableValue;  // NOLINT
+
+            static constexpr bool is_default_constructible =  // NOLINT
+                DefaultConstructibleValue != default_constructible::maybe;
+
+            static constexpr bool is_move_constructible =  // NOLINT
+                MoveConstructibleValue != move_constructible::maybe;
+
+            static constexpr bool is_copy_constructible =  // NOLINT
+                CopyConstructibleValue != copy_constructible::maybe;
+
+            static constexpr bool is_move_assignable =  // NOLINT
+                MoveAssignableValue != move_assignable::maybe;
+
+            static constexpr bool is_copy_assignable =  // NOLINT
+                CopyAssignableValue != copy_assignable::maybe;
+
+            static constexpr bool is_destructible =  // NOLINT
+                DestructibleValue != destructible::maybe;
+
+            static constexpr bool is_equality_comparable =  // NOLINT
+                EqualityComparableValue != equality_comparable::maybe;
+
+            static constexpr bool is_inequality_comparable =  // NOLINT
+                InequalityComparableValue != inequality_comparable::maybe;
+
+            static constexpr bool is_less_than_comparable =  // NOLINT
+                LessThanComparableValue != less_than_comparable::maybe;
+
+            static constexpr bool is_less_equal_comparable =  // NOLINT
+                LessEqualComparableValue != less_equal_comparable::maybe;
+
+            static constexpr bool is_greater_equal_comparable =  // NOLINT
+                GreaterEqualComparableValue != greater_equal_comparable::maybe;
+
+            static constexpr bool is_greater_than_comparable =  // NOLINT
+                GreaterThanComparableValue != greater_than_comparable::maybe;
+
+            static constexpr bool is_swappable =  // NOLINT
+                SwappableValue != swappable::maybe;
+
+            static constexpr bool is_hashable =  // NOLINT
+                HashableValue != hashable::maybe;
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // Compliant SFINAE-friendliness is not always present on the standard library
+        // implementations that we support. This helper-struct (and associated enum) is
+        // used as a means to conditionally check the hashability support of a type.
+        enum class CheckHashability
+        {
+            no,
+            yes
+        };
+
+        template<class T, CheckHashability ShouldCheckHashability>
+        struct conservative_hashable_support_of;
+
+        template<class T>
+        struct conservative_hashable_support_of<T, CheckHashability::no>
+        {
+            static constexpr hashable Invoke()
+            {
+                return hashable::maybe;
+            }
+        };
+
+        template<class T>
+        struct conservative_hashable_support_of<T, CheckHashability::yes>
+        {
+            static constexpr hashable Invoke()
+            {
+                return hashable_support_of<T>();
+            }
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // The ConformanceProfile that is expected based on introspection into the type
+        // by way of trait checks.
+        template<class T, CheckHashability ShouldCheckHashability>
+        struct SyntacticConformanceProfileOf
+        {
+            using properties = ConformanceProfile<
+                default_constructible_support_of<T>(),
+                move_constructible_support_of<T>(),
+                copy_constructible_support_of<T>(),
+                move_assignable_support_of<T>(),
+                copy_assignable_support_of<T>(),
+                destructible_support_of<T>(),
+                equality_comparable_support_of<T>(),
+                inequality_comparable_support_of<T>(),
+                less_than_comparable_support_of<T>(),
+                less_equal_comparable_support_of<T>(),
+                greater_equal_comparable_support_of<T>(),
+                greater_than_comparable_support_of<T>(),
+                swappable_support_of<T>(),
+                conservative_hashable_support_of<T, ShouldCheckHashability>::Invoke()>;
+        };
+
+#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, name)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+    template<default_constructible DefaultConstructibleValue, move_constructible MoveConstructibleValue, copy_constructible CopyConstructibleValue, move_assignable MoveAssignableValue, copy_assignable CopyAssignableValue, destructible DestructibleValue, equality_comparable EqualityComparableValue, inequality_comparable InequalityComparableValue, less_than_comparable LessThanComparableValue, less_equal_comparable LessEqualComparableValue, greater_equal_comparable GreaterEqualComparableValue, greater_than_comparable GreaterThanComparableValue, swappable SwappableValue, hashable HashableValue> \
+    constexpr type ConformanceProfile<                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                \
+        DefaultConstructibleValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+        MoveConstructibleValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+        CopyConstructibleValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \
+        MoveAssignableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+        CopyAssignableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \
+        DestructibleValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \
+        EqualityComparableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+        InequalityComparableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    \
+        LessThanComparableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \
+        LessEqualComparableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     \
+        GreaterEqualComparableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
+        GreaterThanComparableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   \
+        SwappableValue,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               \
+        HashableValue>::name
+
+#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(type)                   \
+    ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, type##_support); \
+    ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(bool, is_##type)
 
 #ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(default_constructible);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_constructible);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_constructible);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_assignable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_assignable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(destructible);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(equality_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(inequality_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_than_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_equal_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_equal_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_than_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(swappable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(hashable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(default_constructible);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_constructible);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_constructible);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_assignable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_assignable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(destructible);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(equality_comparable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(inequality_comparable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_than_comparable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_equal_comparable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_equal_comparable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_than_comparable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(swappable);
+        ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(hashable);
 #endif
 
 #undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF
 #undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL
 
-// Retrieve the enum with the minimum underlying value.
-// Note: std::min is not constexpr in C++11, which is why this is necessary.
-template <class H>
-constexpr H MinEnum(H head) {
-  return head;
-}
-
-template <class H, class N, class... T>
-constexpr H MinEnum(H head, N next, T... tail) {
-  return (UnderlyingValue)(head) < (UnderlyingValue)(next)
-             ? (MinEnum)(head, tail...)
-             : (MinEnum)(next, tail...);
-}
-
-template <class... Profs>
-struct MinimalProfiles {
-  static constexpr default_constructible
-      default_constructible_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::default_constructible_support...);
-
-  static constexpr move_constructible move_constructible_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::move_constructible_support...);
-
-  static constexpr copy_constructible copy_constructible_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
-
-  static constexpr move_assignable move_assignable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::move_assignable_support...);
-
-  static constexpr copy_assignable copy_assignable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
-
-  static constexpr destructible destructible_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::destructible_support...);
-
-  static constexpr equality_comparable equality_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
+        // Retrieve the enum with the minimum underlying value.
+        // Note: std::min is not constexpr in C++11, which is why this is necessary.
+        template<class H>
+        constexpr H MinEnum(H head)
+        {
+            return head;
+        }
 
-  static constexpr inequality_comparable
-      inequality_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
-
-  static constexpr less_than_comparable
-      less_than_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
-
-  static constexpr less_equal_comparable
-      less_equal_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
-
-  static constexpr greater_equal_comparable
-      greater_equal_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
-
-  static constexpr greater_than_comparable
-      greater_than_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
-
-  static constexpr swappable swappable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::swappable_support...);
-
-  static constexpr hashable hashable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::hashable_support...);
-
-  using properties = ConformanceProfile<
-      default_constructible_support, move_constructible_support,
-      copy_constructible_support, move_assignable_support,
-      copy_assignable_support, destructible_support,
-      equality_comparable_support, inequality_comparable_support,
-      less_than_comparable_support, less_equal_comparable_support,
-      greater_equal_comparable_support, greater_than_comparable_support,
-      swappable_support, hashable_support>;
-};
-
-// Retrieve the enum with the greatest underlying value.
-// Note: std::max is not constexpr in C++11, which is why this is necessary.
-template <class H>
-constexpr H MaxEnum(H head) {
-  return head;
-}
-
-template <class H, class N, class... T>
-constexpr H MaxEnum(H head, N next, T... tail) {
-  return (UnderlyingValue)(next) < (UnderlyingValue)(head)
-             ? (MaxEnum)(head, tail...)
-             : (MaxEnum)(next, tail...);
-}
-
-template <class... Profs>
-struct CombineProfilesImpl {
-  static constexpr default_constructible
-      default_constructible_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::default_constructible_support...);
-
-  static constexpr move_constructible move_constructible_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::move_constructible_support...);
-
-  static constexpr copy_constructible copy_constructible_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
-
-  static constexpr move_assignable move_assignable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::move_assignable_support...);
-
-  static constexpr copy_assignable copy_assignable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
-
-  static constexpr destructible destructible_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::destructible_support...);
-
-  static constexpr equality_comparable equality_comparable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
-
-  static constexpr inequality_comparable
-      inequality_comparable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
-
-  static constexpr less_than_comparable
-      less_than_comparable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
-
-  static constexpr less_equal_comparable
-      less_equal_comparable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
-
-  static constexpr greater_equal_comparable
-      greater_equal_comparable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
-
-  static constexpr greater_than_comparable
-      greater_than_comparable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
-
-  static constexpr swappable swappable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::swappable_support...);
-
-  static constexpr hashable hashable_support =  // NOLINT
-      (MaxEnum)(PropertiesOfT<Profs>::hashable_support...);
-
-  using properties = ConformanceProfile<
-      default_constructible_support, move_constructible_support,
-      copy_constructible_support, move_assignable_support,
-      copy_assignable_support, destructible_support,
-      equality_comparable_support, inequality_comparable_support,
-      less_than_comparable_support, less_equal_comparable_support,
-      greater_equal_comparable_support, greater_than_comparable_support,
-      swappable_support, hashable_support>;
-};
-
-// NOTE: We use this as opposed to a direct alias of CombineProfilesImpl so that
-// when named aliases of CombineProfiles are created (such as in
-// conformance_aliases.h), we only pay for the combination algorithm on the
-// profiles that are actually used.
-template <class... Profs>
-struct CombineProfiles {
-  using profile_alias_of = CombineProfilesImpl<Profs...>;
-};
-
-template <>
-struct CombineProfiles<> {
-  using properties = ConformanceProfile<>;
-};
-
-template <class Profile, class Tag>
-struct StrongProfileTypedef {
-  using properties = PropertiesOfT<Profile>;
-};
-
-template <class T, class /*Enabler*/ = void>
-struct IsProfileImpl : std::false_type {};
-
-template <class T>
-struct IsProfileImpl<T, absl::void_t<PropertiesOfT<T>>> : std::true_type {};
-
-template <class T>
-struct IsProfile : IsProfileImpl<T>::type {};
-
-// A tag that describes which set of properties we will check when the user
-// requires a strict match in conformance (as opposed to a loose match which
-// allows more-refined support of any given operation).
-//
-// Currently only the RegularityDomain exists and it includes all operations
-// that the conformance testing suite knows about. The intent is that if the
-// suite is expanded to support extension, such as for checking conformance of
-// concepts like Iterators or Containers, additional corresponding domains can
-// be created.
-struct RegularityDomain {};
-
-}  // namespace types_internal
-ABSL_NAMESPACE_END
+        template<class H, class N, class... T>
+        constexpr H MinEnum(H head, N next, T... tail)
+        {
+            return (UnderlyingValue)(head) < (UnderlyingValue)(next) ? (MinEnum)(head, tail...) : (MinEnum)(next, tail...);
+        }
+
+        template<class... Profs>
+        struct MinimalProfiles
+        {
+            static constexpr default_constructible
+                default_constructible_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::default_constructible_support...);
+
+            static constexpr move_constructible move_constructible_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::move_constructible_support...);
+
+            static constexpr copy_constructible copy_constructible_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
+
+            static constexpr move_assignable move_assignable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::move_assignable_support...);
+
+            static constexpr copy_assignable copy_assignable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
+
+            static constexpr destructible destructible_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::destructible_support...);
+
+            static constexpr equality_comparable equality_comparable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
+
+            static constexpr inequality_comparable
+                inequality_comparable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
+
+            static constexpr less_than_comparable
+                less_than_comparable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
+
+            static constexpr less_equal_comparable
+                less_equal_comparable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
+
+            static constexpr greater_equal_comparable
+                greater_equal_comparable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
+
+            static constexpr greater_than_comparable
+                greater_than_comparable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
+
+            static constexpr swappable swappable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::swappable_support...);
+
+            static constexpr hashable hashable_support =  // NOLINT
+                (MinEnum)(PropertiesOfT<Profs>::hashable_support...);
+
+            using properties = ConformanceProfile<
+                default_constructible_support,
+                move_constructible_support,
+                copy_constructible_support,
+                move_assignable_support,
+                copy_assignable_support,
+                destructible_support,
+                equality_comparable_support,
+                inequality_comparable_support,
+                less_than_comparable_support,
+                less_equal_comparable_support,
+                greater_equal_comparable_support,
+                greater_than_comparable_support,
+                swappable_support,
+                hashable_support>;
+        };
+
+        // Retrieve the enum with the greatest underlying value.
+        // Note: std::max is not constexpr in C++11, which is why this is necessary.
+        template<class H>
+        constexpr H MaxEnum(H head)
+        {
+            return head;
+        }
+
+        template<class H, class N, class... T>
+        constexpr H MaxEnum(H head, N next, T... tail)
+        {
+            return (UnderlyingValue)(next) < (UnderlyingValue)(head) ? (MaxEnum)(head, tail...) : (MaxEnum)(next, tail...);
+        }
+
+        template<class... Profs>
+        struct CombineProfilesImpl
+        {
+            static constexpr default_constructible
+                default_constructible_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::default_constructible_support...);
+
+            static constexpr move_constructible move_constructible_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::move_constructible_support...);
+
+            static constexpr copy_constructible copy_constructible_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
+
+            static constexpr move_assignable move_assignable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::move_assignable_support...);
+
+            static constexpr copy_assignable copy_assignable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
+
+            static constexpr destructible destructible_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::destructible_support...);
+
+            static constexpr equality_comparable equality_comparable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
+
+            static constexpr inequality_comparable
+                inequality_comparable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
+
+            static constexpr less_than_comparable
+                less_than_comparable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
+
+            static constexpr less_equal_comparable
+                less_equal_comparable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
+
+            static constexpr greater_equal_comparable
+                greater_equal_comparable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
+
+            static constexpr greater_than_comparable
+                greater_than_comparable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
+
+            static constexpr swappable swappable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::swappable_support...);
+
+            static constexpr hashable hashable_support =  // NOLINT
+                (MaxEnum)(PropertiesOfT<Profs>::hashable_support...);
+
+            using properties = ConformanceProfile<
+                default_constructible_support,
+                move_constructible_support,
+                copy_constructible_support,
+                move_assignable_support,
+                copy_assignable_support,
+                destructible_support,
+                equality_comparable_support,
+                inequality_comparable_support,
+                less_than_comparable_support,
+                less_equal_comparable_support,
+                greater_equal_comparable_support,
+                greater_than_comparable_support,
+                swappable_support,
+                hashable_support>;
+        };
+
+        // NOTE: We use this as opposed to a direct alias of CombineProfilesImpl so that
+        // when named aliases of CombineProfiles are created (such as in
+        // conformance_aliases.h), we only pay for the combination algorithm on the
+        // profiles that are actually used.
+        template<class... Profs>
+        struct CombineProfiles
+        {
+            using profile_alias_of = CombineProfilesImpl<Profs...>;
+        };
+
+        template<>
+        struct CombineProfiles<>
+        {
+            using properties = ConformanceProfile<>;
+        };
+
+        template<class Profile, class Tag>
+        struct StrongProfileTypedef
+        {
+            using properties = PropertiesOfT<Profile>;
+        };
+
+        template<class T, class /*Enabler*/ = void>
+        struct IsProfileImpl : std::false_type
+        {
+        };
+
+        template<class T>
+        struct IsProfileImpl<T, absl::void_t<PropertiesOfT<T>>> : std::true_type
+        {
+        };
+
+        template<class T>
+        struct IsProfile : IsProfileImpl<T>::type
+        {
+        };
+
+        // A tag that describes which set of properties we will check when the user
+        // requires a strict match in conformance (as opposed to a loose match which
+        // allows more-refined support of any given operation).
+        //
+        // Currently only the RegularityDomain exists and it includes all operations
+        // that the conformance testing suite knows about. The intent is that if the
+        // suite is expanded to support extension, such as for checking conformance of
+        // concepts like Iterators or Containers, additional corresponding domains can
+        // be created.
+        struct RegularityDomain
+        {
+        };
+
+    }  // namespace types_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing.h
index 487b0f7..14f1843 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing.h
@@ -49,1257 +49,1260 @@
 #include "absl/types/internal/transform_args.h"
 #include "absl/utility/utility.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace types_internal {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace types_internal
+    {
 
-// Returns true if the compiler incorrectly greedily instantiates constexpr
-// templates in any unevaluated context.
-constexpr bool constexpr_instantiation_when_unevaluated() {
+        // Returns true if the compiler incorrectly greedily instantiates constexpr
+        // templates in any unevaluated context.
+        constexpr bool constexpr_instantiation_when_unevaluated()
+        {
 #if defined(__apple_build_version__)  // TODO(calabrese) Make more specific
-  return true;
+            return true;
 #elif defined(__clang__)
-  return __clang_major__ < 4;
+            return __clang_major__ < 4;
 #elif defined(__GNUC__)
-  // TODO(calabrese) Figure out why gcc 7 fails (seems like a different bug)
-  return __GNUC__ < 5 || (__GNUC__ == 5 && __GNUC_MINOR__ < 2) || __GNUC__ >= 7;
+            // TODO(calabrese) Figure out why gcc 7 fails (seems like a different bug)
+            return __GNUC__ < 5 || (__GNUC__ == 5 && __GNUC_MINOR__ < 2) || __GNUC__ >= 7;
 #else
-  return false;
+            return false;
 #endif
-}
+        }
 
-// Returns true if the standard library being used incorrectly produces an error
-// when instantiating the definition of a poisoned std::hash specialization.
-constexpr bool poisoned_hash_fails_instantiation() {
+        // Returns true if the standard library being used incorrectly produces an error
+        // when instantiating the definition of a poisoned std::hash specialization.
+        constexpr bool poisoned_hash_fails_instantiation()
+        {
 #if defined(_MSC_VER) && !defined(_LIBCPP_VERSION)
-  return _MSC_VER < 1914;
+            return _MSC_VER < 1914;
 #else
-  return false;
+            return false;
 #endif
-}
-
-template <class Fun>
-struct GeneratorType {
-  decltype(std::declval<const Fun&>()()) operator()() const
-      noexcept(noexcept(std::declval<const Fun&>()())) {
-    return fun();
-  }
-
-  Fun fun;
-  const char* description;
-};
-
-// A "make" function for the GeneratorType template that deduces the function
-// object type.
-template <class Fun,
-          absl::enable_if_t<IsNullaryCallable<Fun>::value>** = nullptr>
-GeneratorType<Fun> Generator(Fun fun, const char* description) {
-  return GeneratorType<Fun>{absl::move(fun), description};
-}
-
-// A type that contains a set of nullary function objects that each return an
-// instance of the same type and value (though possibly different
-// representations, such as +0 and -0 or two vectors with the same elements but
-// with different capacities).
-template <class... Funs>
-struct EquivalenceClassType {
-  std::tuple<GeneratorType<Funs>...> generators;
-};
-
-// A "make" function for the EquivalenceClassType template that deduces the
-// function object types and is constrained such that a user can only pass in
-// function objects that all have the same return type.
-template <class... Funs, absl::enable_if_t<AreGeneratorsWithTheSameReturnType<
-                             Funs...>::value>** = nullptr>
-EquivalenceClassType<Funs...> EquivalenceClass(GeneratorType<Funs>... funs) {
-  return {std::make_tuple(absl::move(funs)...)};
-}
-
-// A type that contains an ordered series of EquivalenceClassTypes, from
-// smallest value to largest value.
-template <class... EqClasses>
-struct OrderedEquivalenceClasses {
-  std::tuple<EqClasses...> eq_classes;
-};
-
-// An object containing the parts of a given (name, initialization expression),
-// and is capable of generating a string that describes the given.
-struct GivenDeclaration {
-  std::string outputDeclaration(std::size_t width) const {
-    const std::size_t indent_size = 2;
-    std::string result = absl::StrCat("  ", name);
-
-    if (!expression.empty()) {
-      // Indent
-      result.resize(indent_size + width, ' ');
-      absl::StrAppend(&result, " = ", expression, ";\n");
-    } else {
-      absl::StrAppend(&result, ";\n");
+        }
+
+        template<class Fun>
+        struct GeneratorType
+        {
+            decltype(std::declval<const Fun&>()()) operator()() const
+                noexcept(noexcept(std::declval<const Fun&>()()))
+            {
+                return fun();
+            }
+
+            Fun fun;
+            const char* description;
+        };
+
+        // A "make" function for the GeneratorType template that deduces the function
+        // object type.
+        template<class Fun, absl::enable_if_t<IsNullaryCallable<Fun>::value>** = nullptr>
+        GeneratorType<Fun> Generator(Fun fun, const char* description)
+        {
+            return GeneratorType<Fun>{absl::move(fun), description};
+        }
+
+        // A type that contains a set of nullary function objects that each return an
+        // instance of the same type and value (though possibly different
+        // representations, such as +0 and -0 or two vectors with the same elements but
+        // with different capacities).
+        template<class... Funs>
+        struct EquivalenceClassType
+        {
+            std::tuple<GeneratorType<Funs>...> generators;
+        };
+
+        // A "make" function for the EquivalenceClassType template that deduces the
+        // function object types and is constrained such that a user can only pass in
+        // function objects that all have the same return type.
+        template<class... Funs, absl::enable_if_t<AreGeneratorsWithTheSameReturnType<Funs...>::value>** = nullptr>
+        EquivalenceClassType<Funs...> EquivalenceClass(GeneratorType<Funs>... funs)
+        {
+            return {std::make_tuple(absl::move(funs)...)};
+        }
+
+        // A type that contains an ordered series of EquivalenceClassTypes, from
+        // smallest value to largest value.
+        template<class... EqClasses>
+        struct OrderedEquivalenceClasses
+        {
+            std::tuple<EqClasses...> eq_classes;
+        };
+
+        // An object containing the parts of a given (name, initialization expression),
+        // and is capable of generating a string that describes the given.
+        struct GivenDeclaration
+        {
+            std::string outputDeclaration(std::size_t width) const
+            {
+                const std::size_t indent_size = 2;
+                std::string result = absl::StrCat("  ", name);
+
+                if (!expression.empty())
+                {
+                    // Indent
+                    result.resize(indent_size + width, ' ');
+                    absl::StrAppend(&result, " = ", expression, ";\n");
+                }
+                else
+                {
+                    absl::StrAppend(&result, ";\n");
+                }
+
+                return result;
+            }
+
+            std::string name;
+            std::string expression;
+        };
+
+        // Produce a string that contains all of the givens of an error report.
+        template<class... Decls>
+        std::string PrepareGivenContext(const Decls&... decls)
+        {
+            const std::size_t width = (std::max)({decls.name.size()...});
+            return absl::StrCat("Given:\n", decls.outputDeclaration(width)..., "\n");
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////
+        // Function objects that perform a check for each comparison operator         //
+        ////////////////////////////////////////////////////////////////////////////////
+
+#define ABSL_INTERNAL_EXPECT_OP(name, op)                                                                                                                                 \
+    struct Expect##name                                                                                                                                                   \
+    {                                                                                                                                                                     \
+        template<class T>                                                                                                                                                 \
+        void operator()(absl::string_view test_name, absl::string_view context, const T& lhs, const T& rhs, absl::string_view lhs_name, absl::string_view rhs_name) const \
+        {                                                                                                                                                                 \
+            if (!static_cast<bool>(lhs op rhs))                                                                                                                           \
+            {                                                                                                                                                             \
+                errors->addTestFailure(                                                                                                                                   \
+                    test_name, absl::StrCat(context, "**Unexpected comparison result**\n"                                                                                 \
+                                                     "\n"                                                                                                                 \
+                                                     "Expression:\n"                                                                                                      \
+                                                     "  ",                                                                                                                \
+                                            lhs_name,                                                                                                                     \
+                                            " " #op " ",                                                                                                                  \
+                                            rhs_name,                                                                                                                     \
+                                            "\n"                                                                                                                          \
+                                            "\n"                                                                                                                          \
+                                            "Expected: true\n"                                                                                                            \
+                                            "  Actual: false")                                                                                                            \
+                );                                                                                                                                                        \
+            }                                                                                                                                                             \
+            else                                                                                                                                                          \
+            {                                                                                                                                                             \
+                errors->addTestSuccess(test_name);                                                                                                                        \
+            }                                                                                                                                                             \
+        }                                                                                                                                                                 \
+                                                                                                                                                                          \
+        ConformanceErrors* errors;                                                                                                                                        \
+    };                                                                                                                                                                    \
+                                                                                                                                                                          \
+    struct ExpectNot##name                                                                                                                                                \
+    {                                                                                                                                                                     \
+        template<class T>                                                                                                                                                 \
+        void operator()(absl::string_view test_name, absl::string_view context, const T& lhs, const T& rhs, absl::string_view lhs_name, absl::string_view rhs_name) const \
+        {                                                                                                                                                                 \
+            if (lhs op rhs)                                                                                                                                               \
+            {                                                                                                                                                             \
+                errors->addTestFailure(                                                                                                                                   \
+                    test_name, absl::StrCat(context, "**Unexpected comparison result**\n"                                                                                 \
+                                                     "\n"                                                                                                                 \
+                                                     "Expression:\n"                                                                                                      \
+                                                     "  ",                                                                                                                \
+                                            lhs_name,                                                                                                                     \
+                                            " " #op " ",                                                                                                                  \
+                                            rhs_name,                                                                                                                     \
+                                            "\n"                                                                                                                          \
+                                            "\n"                                                                                                                          \
+                                            "Expected: false\n"                                                                                                           \
+                                            "  Actual: true")                                                                                                             \
+                );                                                                                                                                                        \
+            }                                                                                                                                                             \
+            else                                                                                                                                                          \
+            {                                                                                                                                                             \
+                errors->addTestSuccess(test_name);                                                                                                                        \
+            }                                                                                                                                                             \
+        }                                                                                                                                                                 \
+                                                                                                                                                                          \
+        ConformanceErrors* errors;                                                                                                                                        \
     }
 
-    return result;
-  }
-
-  std::string name;
-  std::string expression;
-};
-
-// Produce a string that contains all of the givens of an error report.
-template <class... Decls>
-std::string PrepareGivenContext(const Decls&... decls) {
-  const std::size_t width = (std::max)({decls.name.size()...});
-  return absl::StrCat("Given:\n", decls.outputDeclaration(width)..., "\n");
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Function objects that perform a check for each comparison operator         //
-////////////////////////////////////////////////////////////////////////////////
-
-#define ABSL_INTERNAL_EXPECT_OP(name, op)                                   \
-  struct Expect##name {                                                     \
-    template <class T>                                                      \
-    void operator()(absl::string_view test_name, absl::string_view context, \
-                    const T& lhs, const T& rhs, absl::string_view lhs_name, \
-                    absl::string_view rhs_name) const {                     \
-      if (!static_cast<bool>(lhs op rhs)) {                                 \
-        errors->addTestFailure(                                             \
-            test_name, absl::StrCat(context,                                \
-                                    "**Unexpected comparison result**\n"    \
-                                    "\n"                                    \
-                                    "Expression:\n"                         \
-                                    "  ",                                   \
-                                    lhs_name, " " #op " ", rhs_name,        \
-                                    "\n"                                    \
-                                    "\n"                                    \
-                                    "Expected: true\n"                      \
-                                    "  Actual: false"));                    \
-      } else {                                                              \
-        errors->addTestSuccess(test_name);                                  \
-      }                                                                     \
-    }                                                                       \
-                                                                            \
-    ConformanceErrors* errors;                                              \
-  };                                                                        \
-                                                                            \
-  struct ExpectNot##name {                                                  \
-    template <class T>                                                      \
-    void operator()(absl::string_view test_name, absl::string_view context, \
-                    const T& lhs, const T& rhs, absl::string_view lhs_name, \
-                    absl::string_view rhs_name) const {                     \
-      if (lhs op rhs) {                                                     \
-        errors->addTestFailure(                                             \
-            test_name, absl::StrCat(context,                                \
-                                    "**Unexpected comparison result**\n"    \
-                                    "\n"                                    \
-                                    "Expression:\n"                         \
-                                    "  ",                                   \
-                                    lhs_name, " " #op " ", rhs_name,        \
-                                    "\n"                                    \
-                                    "\n"                                    \
-                                    "Expected: false\n"                     \
-                                    "  Actual: true"));                     \
-      } else {                                                              \
-        errors->addTestSuccess(test_name);                                  \
-      }                                                                     \
-    }                                                                       \
-                                                                            \
-    ConformanceErrors* errors;                                              \
-  }
-
-ABSL_INTERNAL_EXPECT_OP(Eq, ==);
-ABSL_INTERNAL_EXPECT_OP(Ne, !=);
-ABSL_INTERNAL_EXPECT_OP(Lt, <);
-ABSL_INTERNAL_EXPECT_OP(Le, <=);
-ABSL_INTERNAL_EXPECT_OP(Ge, >=);
-ABSL_INTERNAL_EXPECT_OP(Gt, >);
+        ABSL_INTERNAL_EXPECT_OP(Eq, ==);
+        ABSL_INTERNAL_EXPECT_OP(Ne, !=);
+        ABSL_INTERNAL_EXPECT_OP(Lt, <);
+        ABSL_INTERNAL_EXPECT_OP(Le, <=);
+        ABSL_INTERNAL_EXPECT_OP(Ge, >=);
+        ABSL_INTERNAL_EXPECT_OP(Gt, >);
 
 #undef ABSL_INTERNAL_EXPECT_OP
 
-// A function object that verifies that two objects hash to the same value by
-// way of the std::hash specialization.
-struct ExpectSameHash {
-  template <class T>
-  void operator()(absl::string_view test_name, absl::string_view context,
-                  const T& lhs, const T& rhs, absl::string_view lhs_name,
-                  absl::string_view rhs_name) const {
-    if (std::hash<T>()(lhs) != std::hash<T>()(rhs)) {
-      errors->addTestFailure(
-          test_name, absl::StrCat(context,
-                                  "**Unexpected hash result**\n"
-                                  "\n"
-                                  "Expression:\n"
-                                  "  std::hash<T>()(",
-                                  lhs_name, ") == std::hash<T>()(", rhs_name,
-                                  ")\n"
-                                  "\n"
-                                  "Expected: true\n"
-                                  "  Actual: false"));
-    } else {
-      errors->addTestSuccess(test_name);
-    }
-  }
-
-  ConformanceErrors* errors;
-};
-
-// A function template that takes two objects and verifies that each comparison
-// operator behaves in a way that is consistent with equality. It has "OneWay"
-// in the name because the first argument will always be the left-hand operand
-// of the corresponding comparison operator and the second argument will
-// always be the right-hand operand. It will never switch that order.
-// At a higher level in the test suite, the one-way form is called once for each
-// of the two possible orders whenever lhs and rhs are not the same initializer.
-template <class T, class Prof>
-void ExpectOneWayEquality(ConformanceErrors* errors,
-                          absl::string_view test_name,
-                          absl::string_view context, const T& lhs, const T& rhs,
-                          absl::string_view lhs_name,
-                          absl::string_view rhs_name) {
-  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
-      ExpectEq{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
-      ExpectNotNe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
-      ExpectNotLt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
-      ExpectLe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
-      ExpectGe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
-      ExpectNotGt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_hashable>::Invoke(
-      ExpectSameHash{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-}
-
-// A function template that takes two objects and verifies that each comparison
-// operator behaves in a way that is consistent with equality. This function
-// differs from ExpectOneWayEquality in that this will do checks with argument
-// order reversed in addition to in-order.
-template <class T, class Prof>
-void ExpectEquality(ConformanceErrors* errors, absl::string_view test_name,
-                    absl::string_view context, const T& lhs, const T& rhs,
-                    absl::string_view lhs_name, absl::string_view rhs_name) {
-  (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, lhs, rhs,
-                                  lhs_name, rhs_name);
-  (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, rhs, lhs,
-                                  rhs_name, lhs_name);
-}
-
-// Given a generator, makes sure that a generated value and a moved-from
-// generated value are equal.
-template <class T, class Prof>
-struct ExpectMoveConstructOneGenerator {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T object = generator();
-    const T moved_object = absl::move(generator());  // Force no elision.
-
-    (ExpectEquality<T, Prof>)(errors, "Move construction",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T object",
-                                                   generator.description},
-                                  GivenDeclaration{"const _T moved_object",
-                                                   std::string("std::move(") +
-                                                       generator.description +
-                                                       ")"}),
-                              object, moved_object, "object", "moved_object");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Given a generator, makes sure that a generated value and a copied-from
-// generated value are equal.
-template <class T, class Prof>
-struct ExpectCopyConstructOneGenerator {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T object = generator();
-    const T copied_object = static_cast<const T&>(generator());
-
-    (ExpectEquality<T, Prof>)(errors, "Copy construction",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T object",
-                                                   generator.description},
-                                  GivenDeclaration{
-                                      "const _T copied_object",
-                                      std::string("static_cast<const _T&>(") +
-                                          generator.description + ")"}),
-                              object, copied_object, "object", "copied_object");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Default-construct and do nothing before destruction.
-//
-// This is useful in exercising the codepath of default construction followed by
-// destruction, but does not explicitly test anything. An example of where this
-// might fail is a default destructor that default-initializes a scalar and a
-// destructor reads the value of that member. Sanitizers can catch this as long
-// as our test attempts to execute such a case.
-template <class T>
-struct ExpectDefaultConstructWithDestruct {
-  void operator()() const {
-    // Scoped so that destructor gets called before reporting success.
-    {
-      T object;
-      static_cast<void>(object);
-    }
-
-    errors->addTestSuccess("Default construction");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check move-assign into a default-constructed object.
-template <class T, class Prof>
-struct ExpectDefaultConstructWithMoveAssign {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T source_of_truth = generator();
-    T object;
-    object = generator();
-
-    (ExpectEquality<T, Prof>)(errors, "Move assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T object",
-                                                   generator.description},
-                                  GivenDeclaration{"_T object", ""},
-                                  GivenDeclaration{"object",
-                                                   generator.description}),
-                              object, source_of_truth, "std::as_const(object)",
-                              "source_of_truth");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check copy-assign into a default-constructed object.
-template <class T, class Prof>
-struct ExpectDefaultConstructWithCopyAssign {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T source_of_truth = generator();
-    T object;
-    object = static_cast<const T&>(generator());
-
-    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T source_of_truth",
-                                                   generator.description},
-                                  GivenDeclaration{"_T object", ""},
-                                  GivenDeclaration{
-                                      "object",
-                                      std::string("static_cast<const _T&>(") +
-                                          generator.description + ")"}),
-                              object, source_of_truth, "std::as_const(object)",
-                              "source_of_truth");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform a self move-assign.
-template <class T, class Prof>
-struct ExpectSelfMoveAssign {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    T object = generator();
-    object = absl::move(object);
-
-    // NOTE: Self move-assign results in a valid-but-unspecified state.
-
-    (ExpectEquality<T, Prof>)(errors, "Move assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"_T object",
-                                                   generator.description},
-                                  GivenDeclaration{"object",
-                                                   "std::move(object)"}),
-                              object, object, "object", "object");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform a self copy-assign.
-template <class T, class Prof>
-struct ExpectSelfCopyAssign {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T source_of_truth = generator();
-    T object = generator();
-    const T& const_object = object;
-    object = const_object;
-
-    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T source_of_truth",
-                                                   generator.description},
-                                  GivenDeclaration{"_T object",
-                                                   generator.description},
-                                  GivenDeclaration{"object",
-                                                   "std::as_const(object)"}),
-                              const_object, source_of_truth,
-                              "std::as_const(object)", "source_of_truth");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform a self-swap.
-template <class T, class Prof>
-struct ExpectSelfSwap {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T source_of_truth = generator();
-    T object = generator();
-
-    type_traits_internal::Swap(object, object);
-
-    std::string preliminary_info = absl::StrCat(
-        PrepareGivenContext(
-            GivenDeclaration{"const _T source_of_truth", generator.description},
-            GivenDeclaration{"_T object", generator.description}),
-        "After performing a self-swap:\n"
-        "  using std::swap;\n"
-        "  swap(object, object);\n"
-        "\n");
-
-    (ExpectEquality<T, Prof>)(errors, "Swap", std::move(preliminary_info),
-                              object, source_of_truth, "std::as_const(object)",
-                              "source_of_truth");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform each of the single-generator checks when necessary operations are
-// supported.
-template <class T, class Prof>
-struct ExpectSelfComparison {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T object = generator();
-    (ExpectOneWayEquality<T, Prof>)(errors, "Comparison",
-                                    PrepareGivenContext(GivenDeclaration{
-                                        "const _T object",
-                                        generator.description}),
-                                    object, object, "object", "object");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform each of the single-generator checks when necessary operations are
-// supported.
-template <class T, class Prof>
-struct ExpectConsistency {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    If<PropertiesOfT<Prof>::is_move_constructible>::Invoke(
-        ExpectMoveConstructOneGenerator<T, Prof>{errors}, generator);
-
-    If<PropertiesOfT<Prof>::is_copy_constructible>::Invoke(
-        ExpectCopyConstructOneGenerator<T, Prof>{errors}, generator);
-
-    If<PropertiesOfT<Prof>::is_default_constructible &&
-       PropertiesOfT<Prof>::is_move_assignable>::
-        Invoke(ExpectDefaultConstructWithMoveAssign<T, Prof>{errors},
-               generator);
-
-    If<PropertiesOfT<Prof>::is_default_constructible &&
-       PropertiesOfT<Prof>::is_copy_assignable>::
-        Invoke(ExpectDefaultConstructWithCopyAssign<T, Prof>{errors},
-               generator);
-
-    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
-        ExpectSelfMoveAssign<T, Prof>{errors}, generator);
-
-    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
-        ExpectSelfCopyAssign<T, Prof>{errors}, generator);
-
-    If<PropertiesOfT<Prof>::is_swappable>::Invoke(
-        ExpectSelfSwap<T, Prof>{errors}, generator);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check move-assign with two different values.
-template <class T, class Prof>
-struct ExpectMoveAssign {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    const T source_of_truth1 = generator1();
-    T object = generator0();
-    object = generator1();
-
-    (ExpectEquality<T, Prof>)(errors, "Move assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T source_of_truth1",
-                                                   generator1.description},
-                                  GivenDeclaration{"_T object",
-                                                   generator0.description},
-                                  GivenDeclaration{"object",
-                                                   generator1.description}),
-                              object, source_of_truth1, "std::as_const(object)",
-                              "source_of_truth1");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check copy-assign with two different values.
-template <class T, class Prof>
-struct ExpectCopyAssign {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    const T source_of_truth1 = generator1();
-    T object = generator0();
-    object = static_cast<const T&>(generator1());
-
-    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T source_of_truth1",
-                                                   generator1.description},
-                                  GivenDeclaration{"_T object",
-                                                   generator0.description},
-                                  GivenDeclaration{
-                                      "object",
-                                      std::string("static_cast<const _T&>(") +
-                                          generator1.description + ")"}),
-                              object, source_of_truth1, "std::as_const(object)",
-                              "source_of_truth1");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check swap with two different values.
-template <class T, class Prof>
-struct ExpectSwap {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    const T source_of_truth0 = generator0();
-    const T source_of_truth1 = generator1();
-    T object0 = generator0();
-    T object1 = generator1();
-
-    type_traits_internal::Swap(object0, object1);
-
-    const std::string context =
-        PrepareGivenContext(
-            GivenDeclaration{"const _T source_of_truth0",
-                             generator0.description},
-            GivenDeclaration{"const _T source_of_truth1",
-                             generator1.description},
-            GivenDeclaration{"_T object0", generator0.description},
-            GivenDeclaration{"_T object1", generator1.description}) +
-        "After performing a swap:\n"
-        "  using std::swap;\n"
-        "  swap(object0, object1);\n"
-        "\n";
-
-    (ExpectEquality<T, Prof>)(errors, "Swap", context, object0,
-                              source_of_truth1, "std::as_const(object0)",
-                              "source_of_truth1");
-    (ExpectEquality<T, Prof>)(errors, "Swap", context, object1,
-                              source_of_truth0, "std::as_const(object1)",
-                              "source_of_truth0");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that `generator0` and `generator1` produce values that are equal.
-template <class T, class Prof>
-struct ExpectEquivalenceClassComparison {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    const T object0 = generator0();
-    const T object1 = generator1();
-
-    (ExpectEquality<T, Prof>)(errors, "Comparison",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T object0",
-                                                   generator0.description},
-                                  GivenDeclaration{"const _T object1",
-                                                   generator1.description}),
-                              object0, object1, "object0", "object1");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that all objects in the same equivalence-class have the same value.
-template <class T, class Prof>
-struct ExpectEquivalenceClassConsistency {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
-        ExpectMoveAssign<T, Prof>{errors}, generator0, generator1);
-
-    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
-        ExpectCopyAssign<T, Prof>{errors}, generator0, generator1);
-
-    If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors},
-                                                  generator0, generator1);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Given a "lesser" object and a "greater" object, perform every combination of
-// comparison operators supported for the type, expecting consistent results.
-template <class T, class Prof>
-void ExpectOrdered(ConformanceErrors* errors, absl::string_view context,
-                   const T& small, const T& big, absl::string_view small_name,
-                   absl::string_view big_name) {
-  const absl::string_view test_name = "Comparison";
-
-  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
-      ExpectNotEq{errors}, test_name, context, small, big, small_name,
-      big_name);
-  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
-      ExpectNotEq{errors}, test_name, context, big, small, big_name,
-      small_name);
-
-  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
-      ExpectNe{errors}, test_name, context, small, big, small_name, big_name);
-  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
-      ExpectNe{errors}, test_name, context, big, small, big_name, small_name);
-
-  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
-      ExpectLt{errors}, test_name, context, small, big, small_name, big_name);
-  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
-      ExpectNotLt{errors}, test_name, context, big, small, big_name,
-      small_name);
-
-  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
-      ExpectLe{errors}, test_name, context, small, big, small_name, big_name);
-  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
-      ExpectNotLe{errors}, test_name, context, big, small, big_name,
-      small_name);
-
-  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
-      ExpectNotGe{errors}, test_name, context, small, big, small_name,
-      big_name);
-  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
-      ExpectGe{errors}, test_name, context, big, small, big_name, small_name);
-
-  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
-      ExpectNotGt{errors}, test_name, context, small, big, small_name,
-      big_name);
-  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
-      ExpectGt{errors}, test_name, context, big, small, big_name, small_name);
-}
-
-// For every two elements of an equivalence class, makes sure that those two
-// elements compare equal, including checks with the same argument passed as
-// both operands.
-template <class T, class Prof>
-struct ExpectEquivalenceClassComparisons {
-  template <class... Funs>
-  void operator()(EquivalenceClassType<Funs...> eq_class) const {
-    (ForEachTupleElement)(ExpectSelfComparison<T, Prof>{errors},
-                          eq_class.generators);
-
-    (ForEveryTwo)(ExpectEquivalenceClassComparison<T, Prof>{errors},
-                  eq_class.generators);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// For every element of an equivalence class, makes sure that the element is
-// self-consistent (in other words, if any of move/copy/swap are defined,
-// perform those operations and make such that results and operands still
-// compare equal to known values whenever it is required for that operation.
-template <class T, class Prof>
-struct ExpectEquivalenceClass {
-  template <class... Funs>
-  void operator()(EquivalenceClassType<Funs...> eq_class) const {
-    (ForEachTupleElement)(ExpectConsistency<T, Prof>{errors},
-                          eq_class.generators);
-
-    (ForEveryTwo)(ExpectEquivalenceClassConsistency<T, Prof>{errors},
-                  eq_class.generators);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that the passed-in argument is a generator of a greater value than
-// the one produced by the "small_gen" datamember with respect to all of the
-// comparison operators that Prof requires, with both argument orders to test.
-template <class T, class Prof, class SmallGenerator>
-struct ExpectBiggerGeneratorThanComparisons {
-  template <class BigGenerator>
-  void operator()(BigGenerator big_gen) const {
-    const T small = small_gen();
-    const T big = big_gen();
-
-    (ExpectOrdered<T, Prof>)(errors,
-                             PrepareGivenContext(
-                                 GivenDeclaration{"const _T small",
-                                                  small_gen.description},
-                                 GivenDeclaration{"const _T big",
-                                                  big_gen.description}),
-                             small, big, "small", "big");
-  }
-
-  SmallGenerator small_gen;
-  ConformanceErrors* errors;
-};
-
-// Perform all of the move, copy, and swap checks on the value generated by
-// `small_gen` and the value generated by `big_gen`.
-template <class T, class Prof, class SmallGenerator>
-struct ExpectBiggerGeneratorThan {
-  template <class BigGenerator>
-  void operator()(BigGenerator big_gen) const {
-    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
-        ExpectMoveAssign<T, Prof>{errors}, small_gen, big_gen);
-    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
-        ExpectMoveAssign<T, Prof>{errors}, big_gen, small_gen);
-
-    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
-        ExpectCopyAssign<T, Prof>{errors}, small_gen, big_gen);
-    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
-        ExpectCopyAssign<T, Prof>{errors}, big_gen, small_gen);
-
-    If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors},
-                                                  small_gen, big_gen);
-  }
-
-  SmallGenerator small_gen;
-  ConformanceErrors* errors;
-};
-
-// Validate that the result of a generator is greater than the results of all
-// generators in an equivalence class with respect to comparisons.
-template <class T, class Prof, class SmallGenerator>
-struct ExpectBiggerGeneratorThanEqClassesComparisons {
-  template <class BigEqClass>
-  void operator()(BigEqClass big_eq_class) const {
-    (ForEachTupleElement)(
-        ExpectBiggerGeneratorThanComparisons<T, Prof, SmallGenerator>{small_gen,
-                                                                      errors},
-        big_eq_class.generators);
-  }
-
-  SmallGenerator small_gen;
-  ConformanceErrors* errors;
-};
-
-// Validate that the non-comparison binary operations required by Prof are
-// correct for the result of each generator of big_eq_class and a generator of
-// the logically smaller value returned by small_gen.
-template <class T, class Prof, class SmallGenerator>
-struct ExpectBiggerGeneratorThanEqClasses {
-  template <class BigEqClass>
-  void operator()(BigEqClass big_eq_class) const {
-    (ForEachTupleElement)(
-        ExpectBiggerGeneratorThan<T, Prof, SmallGenerator>{small_gen, errors},
-        big_eq_class.generators);
-  }
-
-  SmallGenerator small_gen;
-  ConformanceErrors* errors;
-};
-
-// Validate that each equivalence class that is passed is logically less than
-// the equivalence classes that comes later on in the argument list.
-template <class T, class Prof>
-struct ExpectOrderedEquivalenceClassesComparisons {
-  template <class... BigEqClasses>
-  struct Impl {
-    // Validate that the value produced by `small_gen` is less than all of the
-    // values generated by those of the logically larger equivalence classes.
-    template <class SmallGenerator>
-    void operator()(SmallGenerator small_gen) const {
-      (ForEachTupleElement)(ExpectBiggerGeneratorThanEqClassesComparisons<
-                                T, Prof, SmallGenerator>{small_gen, errors},
-                            big_eq_classes);
-    }
-
-    std::tuple<BigEqClasses...> big_eq_classes;
-    ConformanceErrors* errors;
-  };
-
-  // When given no equivalence classes, no validation is necessary.
-  void operator()() const {}
-
-  template <class SmallEqClass, class... BigEqClasses>
-  void operator()(SmallEqClass small_eq_class,
-                  BigEqClasses... big_eq_classes) const {
-    // For each generator in the first equivalence class, make sure that it is
-    // less than each of those in the logically greater equivalence classes.
-    (ForEachTupleElement)(
-        Impl<BigEqClasses...>{std::make_tuple(absl::move(big_eq_classes)...),
-                              errors},
-        small_eq_class.generators);
-
-    // Recurse so that all equivalence class combinations are checked.
-    (*this)(absl::move(big_eq_classes)...);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that the non-comparison binary operations required by Prof are
-// correct for the result of each generator of big_eq_classes and a generator of
-// the logically smaller value returned by small_gen.
-template <class T, class Prof>
-struct ExpectOrderedEquivalenceClasses {
-  template <class... BigEqClasses>
-  struct Impl {
-    template <class SmallGenerator>
-    void operator()(SmallGenerator small_gen) const {
-      (ForEachTupleElement)(
-          ExpectBiggerGeneratorThanEqClasses<T, Prof, SmallGenerator>{small_gen,
-                                                                      errors},
-          big_eq_classes);
-    }
-
-    std::tuple<BigEqClasses...> big_eq_classes;
-    ConformanceErrors* errors;
-  };
-
-  // Check that small_eq_class is logically consistent and also is logically
-  // less than all values in big_eq_classes.
-  template <class SmallEqClass, class... BigEqClasses>
-  void operator()(SmallEqClass small_eq_class,
-                  BigEqClasses... big_eq_classes) const {
-    (ForEachTupleElement)(
-        Impl<BigEqClasses...>{std::make_tuple(absl::move(big_eq_classes)...),
-                              errors},
-        small_eq_class.generators);
-
-    (*this)(absl::move(big_eq_classes)...);
-  }
-
-  // Terminating case of operator().
-  void operator()() const {}
-
-  ConformanceErrors* errors;
-};
-
-// Validate that a type meets the syntactic requirements of std::hash if the
-// range of profiles requires it.
-template <class T, class MinProf, class MaxProf>
-struct ExpectHashable {
-  void operator()() const {
-    ExpectModelOfHashable<T, MinProf, MaxProf>(errors);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that the type `T` meets all of the requirements associated with
-// `MinProf` and without going beyond the syntactic properties of `MaxProf`.
-template <class T, class MinProf, class MaxProf>
-struct ExpectModels {
-  void operator()(ConformanceErrors* errors) const {
-    ExpectModelOfDefaultConstructible<T, MinProf, MaxProf>(errors);
-    ExpectModelOfMoveConstructible<T, MinProf, MaxProf>(errors);
-    ExpectModelOfCopyConstructible<T, MinProf, MaxProf>(errors);
-    ExpectModelOfMoveAssignable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfCopyAssignable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfDestructible<T, MinProf, MaxProf>(errors);
-    ExpectModelOfEqualityComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfInequalityComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfLessThanComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfLessEqualComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfGreaterEqualComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfGreaterThanComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfSwappable<T, MinProf, MaxProf>(errors);
-
-    // Only check hashability on compilers that have a compliant default-hash.
-    If<!poisoned_hash_fails_instantiation()>::Invoke(
-        ExpectHashable<T, MinProf, MaxProf>{errors});
-  }
-};
-
-// A metafunction that yields a Profile matching the set of properties that are
-// safe to be checked (lack-of-hashability is only checked on standard library
-// implementations that are standards compliant in that they provide a std::hash
-// primary template that is SFINAE-friendly)
-template <class LogicalProf, class T>
-struct MinimalCheckableProfile {
-  using type =
-      MinimalProfiles<PropertiesOfT<LogicalProf>,
-                      PropertiesOfT<SyntacticConformanceProfileOf<
-                          T, !PropertiesOfT<LogicalProf>::is_hashable &&
-                                     poisoned_hash_fails_instantiation()
-                                 ? CheckHashability::no
-                                 : CheckHashability::yes>>>;
-};
-
-// An identity metafunction
-template <class T>
-struct Always {
-  using type = T;
-};
-
-// Validate the T meets all of the necessary requirements of LogicalProf, with
-// syntactic requirements defined by the profile range [MinProf, MaxProf].
-template <class T, class LogicalProf, class MinProf, class MaxProf,
-          class... EqClasses>
-ConformanceErrors ExpectRegularityImpl(
-    OrderedEquivalenceClasses<EqClasses...> vals) {
-  ConformanceErrors errors((NameOf<T>()));
-
-  If<!constexpr_instantiation_when_unevaluated()>::Invoke(
-      ExpectModels<T, MinProf, MaxProf>(), &errors);
-
-  using minimal_profile = typename absl::conditional_t<
-      constexpr_instantiation_when_unevaluated(), Always<LogicalProf>,
-      MinimalCheckableProfile<LogicalProf, T>>::type;
-
-  If<PropertiesOfT<minimal_profile>::is_default_constructible>::Invoke(
-      ExpectDefaultConstructWithDestruct<T>{&errors});
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Perform all comparison checks first, since later checks depend on their
-  // correctness.
-  //
-  // Check all of the comparisons for all values in the same equivalence
-  // class (equal with respect to comparison operators and hash the same).
-  (ForEachTupleElement)(
-      ExpectEquivalenceClassComparisons<T, minimal_profile>{&errors},
-      vals.eq_classes);
-
-  // Check all of the comparisons for each combination of values that are in
-  // different equivalence classes (not equal with respect to comparison
-  // operators).
-  absl::apply(
-      ExpectOrderedEquivalenceClassesComparisons<T, minimal_profile>{&errors},
-      vals.eq_classes);
-  //
-  //////////////////////////////////////////////////////////////////////////////
-
-  // Perform remaining checks, relying on comparisons.
-  // TODO(calabrese) short circuit if any comparisons above failed.
-  (ForEachTupleElement)(ExpectEquivalenceClass<T, minimal_profile>{&errors},
-                        vals.eq_classes);
-
-  absl::apply(ExpectOrderedEquivalenceClasses<T, minimal_profile>{&errors},
-              vals.eq_classes);
-
-  return errors;
-}
-
-// A type that represents a range of profiles that are acceptable to be matched.
-//
-// `MinProf` is the minimum set of syntactic requirements that must be met.
-//
-// `MaxProf` is the maximum set of syntactic requirements that must be met.
-// This maximum is particularly useful for certain "strictness" checking. Some
-// examples for when this is useful:
-//
-// * Making sure that a type is move-only (rather than simply movable)
-//
-// * Making sure that a member function is *not* noexcept in cases where it
-//   cannot be noexcept, such as if a dependent datamember has certain
-//   operations that are not noexcept.
-//
-// * Making sure that a type tightly matches a spec, such as the standard.
-//
-// `LogicalProf` is the Profile for which run-time testing is to take place.
-//
-// Note: The reason for `LogicalProf` is because it is often the case, when
-// dealing with templates, that a declaration of a given operation is specified,
-// but whose body would fail to instantiate. Examples include the
-// copy-constructor of a standard container when the element-type is move-only,
-// or the comparison operators of a standard container when the element-type
-// does not have the necessary comparison operations defined. The `LogicalProf`
-// parameter allows us to capture the intent of what should be tested at
-// run-time, even in the cases where syntactically it might otherwise appear as
-// though the type undergoing testing supports more than it actually does.
-template <class LogicalProf, class MinProf = LogicalProf,
-          class MaxProf = MinProf>
-struct ProfileRange {
-  using logical_profile = LogicalProf;
-  using min_profile = MinProf;
-  using max_profile = MaxProf;
-};
-
-// Similar to ProfileRange except that it creates a profile range that is
-// coupled with a Domain and is used when testing that a type matches exactly
-// the "minimum" requirements of LogicalProf.
-template <class StrictnessDomain, class LogicalProf,
-          class MinProf = LogicalProf, class MaxProf = MinProf>
-struct StrictProfileRange {
-  // We do not yet support extension.
-  static_assert(
-      std::is_same<StrictnessDomain, RegularityDomain>::value,
-      "Currently, the only valid StrictnessDomain is RegularityDomain.");
-  using strictness_domain = StrictnessDomain;
-  using logical_profile = LogicalProf;
-  using min_profile = MinProf;
-  using max_profile = MaxProf;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction that creates a StrictProfileRange from a Domain and either a
-// Profile or ProfileRange.
-template <class StrictnessDomain, class ProfOrRange>
-struct MakeStrictProfileRange;
-
-template <class StrictnessDomain, class LogicalProf>
-struct MakeStrictProfileRange {
-  using type = StrictProfileRange<StrictnessDomain, LogicalProf>;
-};
-
-template <class StrictnessDomain, class LogicalProf, class MinProf,
-          class MaxProf>
-struct MakeStrictProfileRange<StrictnessDomain,
-                              ProfileRange<LogicalProf, MinProf, MaxProf>> {
-  using type =
-      StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>;
-};
-
-template <class StrictnessDomain, class ProfOrRange>
-using MakeStrictProfileRangeT =
-    typename MakeStrictProfileRange<StrictnessDomain, ProfOrRange>::type;
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A profile in the RegularityDomain with the strongest possible requirements.
-using MostStrictProfile =
-    CombineProfiles<TriviallyCompleteProfile, NothrowComparableProfile>;
-
-// Forms a ProfileRange that treats the Profile as the bare minimum requirements
-// of a type.
-template <class LogicalProf, class MinProf = LogicalProf>
-using LooseProfileRange = StrictProfileRange<RegularityDomain, LogicalProf,
-                                             MinProf, MostStrictProfile>;
-
-template <class Prof>
-using MakeLooseProfileRangeT = Prof;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// The following classes implement the metafunction ProfileRangeOfT<T> that
-// takes either a Profile or ProfileRange and yields the ProfileRange to be
-// used during testing.
-//
-template <class T, class /*Enabler*/ = void>
-struct ProfileRangeOfImpl;
-
-template <class T>
-struct ProfileRangeOfImpl<T, absl::void_t<PropertiesOfT<T>>> {
-  using type = LooseProfileRange<T>;
-};
-
-template <class T>
-struct ProfileRangeOf : ProfileRangeOfImpl<T> {};
-
-template <class StrictnessDomain, class LogicalProf, class MinProf,
-          class MaxProf>
-struct ProfileRangeOf<
-    StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>> {
-  using type =
-      StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>;
-};
-
-template <class T>
-using ProfileRangeOfT = typename ProfileRangeOf<T>::type;
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// Extract the logical profile of a range (what will be runtime tested).
-template <class T>
-using LogicalProfileOfT = typename ProfileRangeOfT<T>::logical_profile;
-
-// Extract the minimal syntactic profile of a range (error if not at least).
-template <class T>
-using MinProfileOfT = typename ProfileRangeOfT<T>::min_profile;
-
-// Extract the maximum syntactic profile of a range (error if more than).
-template <class T>
-using MaxProfileOfT = typename ProfileRangeOfT<T>::max_profile;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-template <class T>
-struct IsProfileOrProfileRange : IsProfile<T>::type {};
-
-template <class StrictnessDomain, class LogicalProf, class MinProf,
-          class MaxProf>
-struct IsProfileOrProfileRange<
-    StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>>
-    : std::true_type {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// TODO(calabrese): Consider naming the functions in this class the same as
-// the macros (defined later on) so that auto-complete leads to the correct name
-// and so that a user cannot accidentally call a function rather than the macro
-// form.
-template <bool ExpectSuccess, class T, class... EqClasses>
-struct ExpectConformanceOf {
-  // Add a value to be tested. Subsequent calls to this function on the same
-  // object must specify logically "larger" values with respect to the
-  // comparison operators of the type, if any.
-  //
-  // NOTE: This function should not be called directly. A stateless lambda is
-  // implicitly formed and passed when using the INITIALIZER macro at the bottom
-  // of this file.
-  template <class Fun,
-            absl::enable_if_t<std::is_same<
-                ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
-                                           EquivalenceClassType<Fun>>
-  initializer(GeneratorType<Fun> fun) && {
-    return {
-        {std::tuple_cat(absl::move(ordered_vals.eq_classes),
-                        std::make_tuple((EquivalenceClass)(absl::move(fun))))},
-        std::move(expected_failed_tests)};
-  }
-
-  template <class... TestNames,
-            absl::enable_if_t<!ExpectSuccess && sizeof...(EqClasses) == 0 &&
-                              absl::conjunction<std::is_convertible<
-                                  TestNames, absl::string_view>...>::value>** =
-                nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
-  due_to(TestNames&&... test_names) && {
-    (InsertEach)(&expected_failed_tests,
-                 absl::AsciiStrToLower(absl::string_view(test_names))...);
-
-    return {absl::move(ordered_vals), std::move(expected_failed_tests)};
-  }
-
-  template <class... TestNames, int = 0,  // MSVC disambiguator
-            absl::enable_if_t<ExpectSuccess && sizeof...(EqClasses) == 0 &&
-                              absl::conjunction<std::is_convertible<
-                                  TestNames, absl::string_view>...>::value>** =
-                nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
-  due_to(TestNames&&... test_names) && {
-    // TODO(calabrese) Instead have DUE_TO only exist via a CRTP base.
-    // This would produce better errors messages than the static_assert.
-    static_assert(!ExpectSuccess,
-                  "DUE_TO cannot be called when conformance is expected -- did "
-                  "you mean to use ASSERT_NONCONFORMANCE_OF?");
-  }
-
-  // Add a value to be tested. Subsequent calls to this function on the same
-  // object must specify logically "larger" values with respect to the
-  // comparison operators of the type, if any.
-  //
-  // NOTE: This function should not be called directly. A stateful lambda is
-  // implicitly formed and passed when using the INITIALIZER macro at the bottom
-  // of this file.
-  template <class Fun,
-            absl::enable_if_t<std::is_same<
-                ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
-                                           EquivalenceClassType<Fun>>
-  dont_class_directly_stateful_initializer(GeneratorType<Fun> fun) && {
-    return {
-        {std::tuple_cat(absl::move(ordered_vals.eq_classes),
-                        std::make_tuple((EquivalenceClass)(absl::move(fun))))},
-        std::move(expected_failed_tests)};
-  }
-
-  // Add a set of value to be tested, where each value is equal with respect to
-  // the comparison operators and std::hash specialization, if defined.
-  template <
-      class... Funs,
-      absl::void_t<absl::enable_if_t<std::is_same<
-          ResultOfGeneratorT<GeneratorType<Funs>>, T>::value>...>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
-                                           EquivalenceClassType<Funs...>>
-  equivalence_class(GeneratorType<Funs>... funs) && {
-    return {{std::tuple_cat(
-                absl::move(ordered_vals.eq_classes),
-                std::make_tuple((EquivalenceClass)(absl::move(funs)...)))},
-            std::move(expected_failed_tests)};
-  }
-
-  // Execute the tests for the captured set of values, strictly matching a range
-  // of expected profiles in a given domain.
-  template <
-      class ProfRange,
-      absl::enable_if_t<IsProfileOrProfileRange<ProfRange>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_strict_profile(
-      ProfRange /*profile*/) {
-    ConformanceErrors test_result =
-        (ExpectRegularityImpl<
-            T, LogicalProfileOfT<ProfRange>, MinProfileOfT<ProfRange>,
-            MaxProfileOfT<ProfRange>>)(absl::move(ordered_vals));
-
-    return ExpectSuccess ? test_result.assertionResult()
-                         : test_result.expectFailedTests(expected_failed_tests);
-  }
-
-  // Execute the tests for the captured set of values, loosely matching a range
-  // of expected profiles (loose in that an interface is allowed to be more
-  // refined that a profile suggests, such as a type having a noexcept copy
-  // constructor when all that is required is that the copy constructor exists).
-  template <class Prof, absl::enable_if_t<IsProfile<Prof>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_loose_profile(
-      Prof /*profile*/) {
-    ConformanceErrors test_result =
-        (ExpectRegularityImpl<
-            T, Prof, Prof,
-            CombineProfiles<TriviallyCompleteProfile,
-                            NothrowComparableProfile>>)(absl::
-                                                            move(ordered_vals));
-
-    return ExpectSuccess ? test_result.assertionResult()
-                         : test_result.expectFailedTests(expected_failed_tests);
-  }
-
-  OrderedEquivalenceClasses<EqClasses...> ordered_vals;
-  std::set<std::string> expected_failed_tests;
-};
-
-template <class T>
-using ExpectConformanceOfType = ExpectConformanceOf</*ExpectSuccess=*/true, T>;
-
-template <class T>
-using ExpectNonconformanceOfType =
-    ExpectConformanceOf</*ExpectSuccess=*/false, T>;
-
-struct EquivalenceClassMaker {
-  // TODO(calabrese) Constrain to callable
-  template <class Fun>
-  static GeneratorType<Fun> initializer(GeneratorType<Fun> fun) {
-    return fun;
-  }
-};
+        // A function object that verifies that two objects hash to the same value by
+        // way of the std::hash specialization.
+        struct ExpectSameHash
+        {
+            template<class T>
+            void operator()(absl::string_view test_name, absl::string_view context, const T& lhs, const T& rhs, absl::string_view lhs_name, absl::string_view rhs_name) const
+            {
+                if (std::hash<T>()(lhs) != std::hash<T>()(rhs))
+                {
+                    errors->addTestFailure(
+                        test_name, absl::StrCat(context, "**Unexpected hash result**\n"
+                                                         "\n"
+                                                         "Expression:\n"
+                                                         "  std::hash<T>()(",
+                                                lhs_name,
+                                                ") == std::hash<T>()(",
+                                                rhs_name,
+                                                ")\n"
+                                                "\n"
+                                                "Expected: true\n"
+                                                "  Actual: false")
+                    );
+                }
+                else
+                {
+                    errors->addTestSuccess(test_name);
+                }
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // A function template that takes two objects and verifies that each comparison
+        // operator behaves in a way that is consistent with equality. It has "OneWay"
+        // in the name because the first argument will always be the left-hand operand
+        // of the corresponding comparison operator and the second argument will
+        // always be the right-hand operand. It will never switch that order.
+        // At a higher level in the test suite, the one-way form is called once for each
+        // of the two possible orders whenever lhs and rhs are not the same initializer.
+        template<class T, class Prof>
+        void ExpectOneWayEquality(ConformanceErrors* errors, absl::string_view test_name, absl::string_view context, const T& lhs, const T& rhs, absl::string_view lhs_name, absl::string_view rhs_name)
+        {
+            If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
+                ExpectEq{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name
+            );
+
+            If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
+                ExpectNotNe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name
+            );
+
+            If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
+                ExpectNotLt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name
+            );
+
+            If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
+                ExpectLe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name
+            );
+
+            If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
+                ExpectGe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name
+            );
+
+            If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
+                ExpectNotGt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name
+            );
+
+            If<PropertiesOfT<Prof>::is_hashable>::Invoke(
+                ExpectSameHash{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name
+            );
+        }
+
+        // A function template that takes two objects and verifies that each comparison
+        // operator behaves in a way that is consistent with equality. This function
+        // differs from ExpectOneWayEquality in that this will do checks with argument
+        // order reversed in addition to in-order.
+        template<class T, class Prof>
+        void ExpectEquality(ConformanceErrors* errors, absl::string_view test_name, absl::string_view context, const T& lhs, const T& rhs, absl::string_view lhs_name, absl::string_view rhs_name)
+        {
+            (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, lhs, rhs, lhs_name, rhs_name);
+            (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, rhs, lhs, rhs_name, lhs_name);
+        }
+
+        // Given a generator, makes sure that a generated value and a moved-from
+        // generated value are equal.
+        template<class T, class Prof>
+        struct ExpectMoveConstructOneGenerator
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                const T object = generator();
+                const T moved_object = absl::move(generator());  // Force no elision.
+
+                (ExpectEquality<T, Prof>)(errors, "Move construction", PrepareGivenContext(GivenDeclaration{"const _T object", generator.description}, GivenDeclaration{"const _T moved_object", std::string("std::move(") + generator.description + ")"}), object, moved_object, "object", "moved_object");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Given a generator, makes sure that a generated value and a copied-from
+        // generated value are equal.
+        template<class T, class Prof>
+        struct ExpectCopyConstructOneGenerator
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                const T object = generator();
+                const T copied_object = static_cast<const T&>(generator());
+
+                (ExpectEquality<T, Prof>)(errors, "Copy construction", PrepareGivenContext(GivenDeclaration{"const _T object", generator.description}, GivenDeclaration{"const _T copied_object", std::string("static_cast<const _T&>(") + generator.description + ")"}), object, copied_object, "object", "copied_object");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Default-construct and do nothing before destruction.
+        //
+        // This is useful in exercising the codepath of default construction followed by
+        // destruction, but does not explicitly test anything. An example of where this
+        // might fail is a default destructor that default-initializes a scalar and a
+        // destructor reads the value of that member. Sanitizers can catch this as long
+        // as our test attempts to execute such a case.
+        template<class T>
+        struct ExpectDefaultConstructWithDestruct
+        {
+            void operator()() const
+            {
+                // Scoped so that destructor gets called before reporting success.
+                {
+                    T object;
+                    static_cast<void>(object);
+                }
+
+                errors->addTestSuccess("Default construction");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Check move-assign into a default-constructed object.
+        template<class T, class Prof>
+        struct ExpectDefaultConstructWithMoveAssign
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                const T source_of_truth = generator();
+                T object;
+                object = generator();
+
+                (ExpectEquality<T, Prof>)(errors, "Move assignment", PrepareGivenContext(GivenDeclaration{"const _T object", generator.description}, GivenDeclaration{"_T object", ""}, GivenDeclaration{"object", generator.description}), object, source_of_truth, "std::as_const(object)", "source_of_truth");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Check copy-assign into a default-constructed object.
+        template<class T, class Prof>
+        struct ExpectDefaultConstructWithCopyAssign
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                const T source_of_truth = generator();
+                T object;
+                object = static_cast<const T&>(generator());
+
+                (ExpectEquality<T, Prof>)(errors, "Copy assignment", PrepareGivenContext(GivenDeclaration{"const _T source_of_truth", generator.description}, GivenDeclaration{"_T object", ""}, GivenDeclaration{"object", std::string("static_cast<const _T&>(") + generator.description + ")"}), object, source_of_truth, "std::as_const(object)", "source_of_truth");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Perform a self move-assign.
+        template<class T, class Prof>
+        struct ExpectSelfMoveAssign
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                T object = generator();
+                object = absl::move(object);
+
+                // NOTE: Self move-assign results in a valid-but-unspecified state.
+
+                (ExpectEquality<T, Prof>)(errors, "Move assignment", PrepareGivenContext(GivenDeclaration{"_T object", generator.description}, GivenDeclaration{"object", "std::move(object)"}), object, object, "object", "object");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Perform a self copy-assign.
+        template<class T, class Prof>
+        struct ExpectSelfCopyAssign
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                const T source_of_truth = generator();
+                T object = generator();
+                const T& const_object = object;
+                object = const_object;
+
+                (ExpectEquality<T, Prof>)(errors, "Copy assignment", PrepareGivenContext(GivenDeclaration{"const _T source_of_truth", generator.description}, GivenDeclaration{"_T object", generator.description}, GivenDeclaration{"object", "std::as_const(object)"}), const_object, source_of_truth, "std::as_const(object)", "source_of_truth");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Perform a self-swap.
+        template<class T, class Prof>
+        struct ExpectSelfSwap
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                const T source_of_truth = generator();
+                T object = generator();
+
+                type_traits_internal::Swap(object, object);
+
+                std::string preliminary_info = absl::StrCat(
+                    PrepareGivenContext(
+                        GivenDeclaration{"const _T source_of_truth", generator.description},
+                        GivenDeclaration{"_T object", generator.description}
+                    ),
+                    "After performing a self-swap:\n"
+                    "  using std::swap;\n"
+                    "  swap(object, object);\n"
+                    "\n"
+                );
+
+                (ExpectEquality<T, Prof>)(errors, "Swap", std::move(preliminary_info), object, source_of_truth, "std::as_const(object)", "source_of_truth");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Perform each of the single-generator checks when necessary operations are
+        // supported.
+        template<class T, class Prof>
+        struct ExpectSelfComparison
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                const T object = generator();
+                (ExpectOneWayEquality<T, Prof>)(errors, "Comparison", PrepareGivenContext(GivenDeclaration{"const _T object", generator.description}), object, object, "object", "object");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Perform each of the single-generator checks when necessary operations are
+        // supported.
+        template<class T, class Prof>
+        struct ExpectConsistency
+        {
+            template<class Fun>
+            void operator()(const Fun& generator) const
+            {
+                If<PropertiesOfT<Prof>::is_move_constructible>::Invoke(
+                    ExpectMoveConstructOneGenerator<T, Prof>{errors}, generator
+                );
+
+                If<PropertiesOfT<Prof>::is_copy_constructible>::Invoke(
+                    ExpectCopyConstructOneGenerator<T, Prof>{errors}, generator
+                );
+
+                If<PropertiesOfT<Prof>::is_default_constructible &&
+                   PropertiesOfT<Prof>::is_move_assignable>::
+                    Invoke(ExpectDefaultConstructWithMoveAssign<T, Prof>{errors}, generator);
+
+                If<PropertiesOfT<Prof>::is_default_constructible &&
+                   PropertiesOfT<Prof>::is_copy_assignable>::
+                    Invoke(ExpectDefaultConstructWithCopyAssign<T, Prof>{errors}, generator);
+
+                If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
+                    ExpectSelfMoveAssign<T, Prof>{errors}, generator
+                );
+
+                If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
+                    ExpectSelfCopyAssign<T, Prof>{errors}, generator
+                );
+
+                If<PropertiesOfT<Prof>::is_swappable>::Invoke(
+                    ExpectSelfSwap<T, Prof>{errors}, generator
+                );
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Check move-assign with two different values.
+        template<class T, class Prof>
+        struct ExpectMoveAssign
+        {
+            template<class Fun0, class Fun1>
+            void operator()(const Fun0& generator0, const Fun1& generator1) const
+            {
+                const T source_of_truth1 = generator1();
+                T object = generator0();
+                object = generator1();
+
+                (ExpectEquality<T, Prof>)(errors, "Move assignment", PrepareGivenContext(GivenDeclaration{"const _T source_of_truth1", generator1.description}, GivenDeclaration{"_T object", generator0.description}, GivenDeclaration{"object", generator1.description}), object, source_of_truth1, "std::as_const(object)", "source_of_truth1");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Check copy-assign with two different values.
+        template<class T, class Prof>
+        struct ExpectCopyAssign
+        {
+            template<class Fun0, class Fun1>
+            void operator()(const Fun0& generator0, const Fun1& generator1) const
+            {
+                const T source_of_truth1 = generator1();
+                T object = generator0();
+                object = static_cast<const T&>(generator1());
+
+                (ExpectEquality<T, Prof>)(errors, "Copy assignment", PrepareGivenContext(GivenDeclaration{"const _T source_of_truth1", generator1.description}, GivenDeclaration{"_T object", generator0.description}, GivenDeclaration{"object", std::string("static_cast<const _T&>(") + generator1.description + ")"}), object, source_of_truth1, "std::as_const(object)", "source_of_truth1");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Check swap with two different values.
+        template<class T, class Prof>
+        struct ExpectSwap
+        {
+            template<class Fun0, class Fun1>
+            void operator()(const Fun0& generator0, const Fun1& generator1) const
+            {
+                const T source_of_truth0 = generator0();
+                const T source_of_truth1 = generator1();
+                T object0 = generator0();
+                T object1 = generator1();
+
+                type_traits_internal::Swap(object0, object1);
+
+                const std::string context =
+                    PrepareGivenContext(
+                        GivenDeclaration{"const _T source_of_truth0", generator0.description},
+                        GivenDeclaration{"const _T source_of_truth1", generator1.description},
+                        GivenDeclaration{"_T object0", generator0.description},
+                        GivenDeclaration{"_T object1", generator1.description}
+                    ) +
+                    "After performing a swap:\n"
+                    "  using std::swap;\n"
+                    "  swap(object0, object1);\n"
+                    "\n";
+
+                (ExpectEquality<T, Prof>)(errors, "Swap", context, object0, source_of_truth1, "std::as_const(object0)", "source_of_truth1");
+                (ExpectEquality<T, Prof>)(errors, "Swap", context, object1, source_of_truth0, "std::as_const(object1)", "source_of_truth0");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Validate that `generator0` and `generator1` produce values that are equal.
+        template<class T, class Prof>
+        struct ExpectEquivalenceClassComparison
+        {
+            template<class Fun0, class Fun1>
+            void operator()(const Fun0& generator0, const Fun1& generator1) const
+            {
+                const T object0 = generator0();
+                const T object1 = generator1();
+
+                (ExpectEquality<T, Prof>)(errors, "Comparison", PrepareGivenContext(GivenDeclaration{"const _T object0", generator0.description}, GivenDeclaration{"const _T object1", generator1.description}), object0, object1, "object0", "object1");
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Validate that all objects in the same equivalence-class have the same value.
+        template<class T, class Prof>
+        struct ExpectEquivalenceClassConsistency
+        {
+            template<class Fun0, class Fun1>
+            void operator()(const Fun0& generator0, const Fun1& generator1) const
+            {
+                If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
+                    ExpectMoveAssign<T, Prof>{errors}, generator0, generator1
+                );
+
+                If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
+                    ExpectCopyAssign<T, Prof>{errors}, generator0, generator1
+                );
+
+                If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors}, generator0, generator1);
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Given a "lesser" object and a "greater" object, perform every combination of
+        // comparison operators supported for the type, expecting consistent results.
+        template<class T, class Prof>
+        void ExpectOrdered(ConformanceErrors* errors, absl::string_view context, const T& small, const T& big, absl::string_view small_name, absl::string_view big_name)
+        {
+            const absl::string_view test_name = "Comparison";
+
+            If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
+                ExpectNotEq{errors}, test_name, context, small, big, small_name, big_name
+            );
+            If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
+                ExpectNotEq{errors}, test_name, context, big, small, big_name, small_name
+            );
+
+            If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
+                ExpectNe{errors}, test_name, context, small, big, small_name, big_name
+            );
+            If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
+                ExpectNe{errors}, test_name, context, big, small, big_name, small_name
+            );
+
+            If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
+                ExpectLt{errors}, test_name, context, small, big, small_name, big_name
+            );
+            If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
+                ExpectNotLt{errors}, test_name, context, big, small, big_name, small_name
+            );
+
+            If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
+                ExpectLe{errors}, test_name, context, small, big, small_name, big_name
+            );
+            If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
+                ExpectNotLe{errors}, test_name, context, big, small, big_name, small_name
+            );
+
+            If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
+                ExpectNotGe{errors}, test_name, context, small, big, small_name, big_name
+            );
+            If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
+                ExpectGe{errors}, test_name, context, big, small, big_name, small_name
+            );
+
+            If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
+                ExpectNotGt{errors}, test_name, context, small, big, small_name, big_name
+            );
+            If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
+                ExpectGt{errors}, test_name, context, big, small, big_name, small_name
+            );
+        }
+
+        // For every two elements of an equivalence class, makes sure that those two
+        // elements compare equal, including checks with the same argument passed as
+        // both operands.
+        template<class T, class Prof>
+        struct ExpectEquivalenceClassComparisons
+        {
+            template<class... Funs>
+            void operator()(EquivalenceClassType<Funs...> eq_class) const
+            {
+                (ForEachTupleElement)(ExpectSelfComparison<T, Prof>{errors}, eq_class.generators);
+
+                (ForEveryTwo)(ExpectEquivalenceClassComparison<T, Prof>{errors}, eq_class.generators);
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // For every element of an equivalence class, makes sure that the element is
+        // self-consistent (in other words, if any of move/copy/swap are defined,
+        // perform those operations and make such that results and operands still
+        // compare equal to known values whenever it is required for that operation.
+        template<class T, class Prof>
+        struct ExpectEquivalenceClass
+        {
+            template<class... Funs>
+            void operator()(EquivalenceClassType<Funs...> eq_class) const
+            {
+                (ForEachTupleElement)(ExpectConsistency<T, Prof>{errors}, eq_class.generators);
+
+                (ForEveryTwo)(ExpectEquivalenceClassConsistency<T, Prof>{errors}, eq_class.generators);
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Validate that the passed-in argument is a generator of a greater value than
+        // the one produced by the "small_gen" datamember with respect to all of the
+        // comparison operators that Prof requires, with both argument orders to test.
+        template<class T, class Prof, class SmallGenerator>
+        struct ExpectBiggerGeneratorThanComparisons
+        {
+            template<class BigGenerator>
+            void operator()(BigGenerator big_gen) const
+            {
+                const T small = small_gen();
+                const T big = big_gen();
+
+                (ExpectOrdered<T, Prof>)(errors, PrepareGivenContext(GivenDeclaration{"const _T small", small_gen.description}, GivenDeclaration{"const _T big", big_gen.description}), small, big, "small", "big");
+            }
+
+            SmallGenerator small_gen;
+            ConformanceErrors* errors;
+        };
+
+        // Perform all of the move, copy, and swap checks on the value generated by
+        // `small_gen` and the value generated by `big_gen`.
+        template<class T, class Prof, class SmallGenerator>
+        struct ExpectBiggerGeneratorThan
+        {
+            template<class BigGenerator>
+            void operator()(BigGenerator big_gen) const
+            {
+                If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
+                    ExpectMoveAssign<T, Prof>{errors}, small_gen, big_gen
+                );
+                If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
+                    ExpectMoveAssign<T, Prof>{errors}, big_gen, small_gen
+                );
+
+                If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
+                    ExpectCopyAssign<T, Prof>{errors}, small_gen, big_gen
+                );
+                If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
+                    ExpectCopyAssign<T, Prof>{errors}, big_gen, small_gen
+                );
+
+                If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors}, small_gen, big_gen);
+            }
+
+            SmallGenerator small_gen;
+            ConformanceErrors* errors;
+        };
+
+        // Validate that the result of a generator is greater than the results of all
+        // generators in an equivalence class with respect to comparisons.
+        template<class T, class Prof, class SmallGenerator>
+        struct ExpectBiggerGeneratorThanEqClassesComparisons
+        {
+            template<class BigEqClass>
+            void operator()(BigEqClass big_eq_class) const
+            {
+                (ForEachTupleElement)(
+                    ExpectBiggerGeneratorThanComparisons<T, Prof, SmallGenerator>{small_gen, errors},
+                    big_eq_class.generators
+                );
+            }
+
+            SmallGenerator small_gen;
+            ConformanceErrors* errors;
+        };
+
+        // Validate that the non-comparison binary operations required by Prof are
+        // correct for the result of each generator of big_eq_class and a generator of
+        // the logically smaller value returned by small_gen.
+        template<class T, class Prof, class SmallGenerator>
+        struct ExpectBiggerGeneratorThanEqClasses
+        {
+            template<class BigEqClass>
+            void operator()(BigEqClass big_eq_class) const
+            {
+                (ForEachTupleElement)(
+                    ExpectBiggerGeneratorThan<T, Prof, SmallGenerator>{small_gen, errors},
+                    big_eq_class.generators
+                );
+            }
+
+            SmallGenerator small_gen;
+            ConformanceErrors* errors;
+        };
+
+        // Validate that each equivalence class that is passed is logically less than
+        // the equivalence classes that comes later on in the argument list.
+        template<class T, class Prof>
+        struct ExpectOrderedEquivalenceClassesComparisons
+        {
+            template<class... BigEqClasses>
+            struct Impl
+            {
+                // Validate that the value produced by `small_gen` is less than all of the
+                // values generated by those of the logically larger equivalence classes.
+                template<class SmallGenerator>
+                void operator()(SmallGenerator small_gen) const
+                {
+                    (ForEachTupleElement)(ExpectBiggerGeneratorThanEqClassesComparisons<T, Prof, SmallGenerator>{small_gen, errors}, big_eq_classes);
+                }
+
+                std::tuple<BigEqClasses...> big_eq_classes;
+                ConformanceErrors* errors;
+            };
+
+            // When given no equivalence classes, no validation is necessary.
+            void operator()() const
+            {
+            }
+
+            template<class SmallEqClass, class... BigEqClasses>
+            void operator()(SmallEqClass small_eq_class, BigEqClasses... big_eq_classes) const
+            {
+                // For each generator in the first equivalence class, make sure that it is
+                // less than each of those in the logically greater equivalence classes.
+                (ForEachTupleElement)(
+                    Impl<BigEqClasses...>{std::make_tuple(absl::move(big_eq_classes)...), errors},
+                    small_eq_class.generators
+                );
+
+                // Recurse so that all equivalence class combinations are checked.
+                (*this)(absl::move(big_eq_classes)...);
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Validate that the non-comparison binary operations required by Prof are
+        // correct for the result of each generator of big_eq_classes and a generator of
+        // the logically smaller value returned by small_gen.
+        template<class T, class Prof>
+        struct ExpectOrderedEquivalenceClasses
+        {
+            template<class... BigEqClasses>
+            struct Impl
+            {
+                template<class SmallGenerator>
+                void operator()(SmallGenerator small_gen) const
+                {
+                    (ForEachTupleElement)(
+                        ExpectBiggerGeneratorThanEqClasses<T, Prof, SmallGenerator>{small_gen, errors},
+                        big_eq_classes
+                    );
+                }
+
+                std::tuple<BigEqClasses...> big_eq_classes;
+                ConformanceErrors* errors;
+            };
+
+            // Check that small_eq_class is logically consistent and also is logically
+            // less than all values in big_eq_classes.
+            template<class SmallEqClass, class... BigEqClasses>
+            void operator()(SmallEqClass small_eq_class, BigEqClasses... big_eq_classes) const
+            {
+                (ForEachTupleElement)(
+                    Impl<BigEqClasses...>{std::make_tuple(absl::move(big_eq_classes)...), errors},
+                    small_eq_class.generators
+                );
+
+                (*this)(absl::move(big_eq_classes)...);
+            }
+
+            // Terminating case of operator().
+            void operator()() const
+            {
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Validate that a type meets the syntactic requirements of std::hash if the
+        // range of profiles requires it.
+        template<class T, class MinProf, class MaxProf>
+        struct ExpectHashable
+        {
+            void operator()() const
+            {
+                ExpectModelOfHashable<T, MinProf, MaxProf>(errors);
+            }
+
+            ConformanceErrors* errors;
+        };
+
+        // Validate that the type `T` meets all of the requirements associated with
+        // `MinProf` and without going beyond the syntactic properties of `MaxProf`.
+        template<class T, class MinProf, class MaxProf>
+        struct ExpectModels
+        {
+            void operator()(ConformanceErrors* errors) const
+            {
+                ExpectModelOfDefaultConstructible<T, MinProf, MaxProf>(errors);
+                ExpectModelOfMoveConstructible<T, MinProf, MaxProf>(errors);
+                ExpectModelOfCopyConstructible<T, MinProf, MaxProf>(errors);
+                ExpectModelOfMoveAssignable<T, MinProf, MaxProf>(errors);
+                ExpectModelOfCopyAssignable<T, MinProf, MaxProf>(errors);
+                ExpectModelOfDestructible<T, MinProf, MaxProf>(errors);
+                ExpectModelOfEqualityComparable<T, MinProf, MaxProf>(errors);
+                ExpectModelOfInequalityComparable<T, MinProf, MaxProf>(errors);
+                ExpectModelOfLessThanComparable<T, MinProf, MaxProf>(errors);
+                ExpectModelOfLessEqualComparable<T, MinProf, MaxProf>(errors);
+                ExpectModelOfGreaterEqualComparable<T, MinProf, MaxProf>(errors);
+                ExpectModelOfGreaterThanComparable<T, MinProf, MaxProf>(errors);
+                ExpectModelOfSwappable<T, MinProf, MaxProf>(errors);
+
+                // Only check hashability on compilers that have a compliant default-hash.
+                If<!poisoned_hash_fails_instantiation()>::Invoke(
+                    ExpectHashable<T, MinProf, MaxProf>{errors}
+                );
+            }
+        };
+
+        // A metafunction that yields a Profile matching the set of properties that are
+        // safe to be checked (lack-of-hashability is only checked on standard library
+        // implementations that are standards compliant in that they provide a std::hash
+        // primary template that is SFINAE-friendly)
+        template<class LogicalProf, class T>
+        struct MinimalCheckableProfile
+        {
+            using type =
+                MinimalProfiles<PropertiesOfT<LogicalProf>, PropertiesOfT<SyntacticConformanceProfileOf<T, !PropertiesOfT<LogicalProf>::is_hashable && poisoned_hash_fails_instantiation() ? CheckHashability::no : CheckHashability::yes>>>;
+        };
+
+        // An identity metafunction
+        template<class T>
+        struct Always
+        {
+            using type = T;
+        };
+
+        // Validate the T meets all of the necessary requirements of LogicalProf, with
+        // syntactic requirements defined by the profile range [MinProf, MaxProf].
+        template<class T, class LogicalProf, class MinProf, class MaxProf, class... EqClasses>
+        ConformanceErrors ExpectRegularityImpl(
+            OrderedEquivalenceClasses<EqClasses...> vals
+        )
+        {
+            ConformanceErrors errors((NameOf<T>()));
+
+            If<!constexpr_instantiation_when_unevaluated()>::Invoke(
+                ExpectModels<T, MinProf, MaxProf>(), &errors
+            );
+
+            using minimal_profile = typename absl::conditional_t<
+                constexpr_instantiation_when_unevaluated(),
+                Always<LogicalProf>,
+                MinimalCheckableProfile<LogicalProf, T>>::type;
+
+            If<PropertiesOfT<minimal_profile>::is_default_constructible>::Invoke(
+                ExpectDefaultConstructWithDestruct<T>{&errors}
+            );
+
+            //////////////////////////////////////////////////////////////////////////////
+            // Perform all comparison checks first, since later checks depend on their
+            // correctness.
+            //
+            // Check all of the comparisons for all values in the same equivalence
+            // class (equal with respect to comparison operators and hash the same).
+            (ForEachTupleElement)(
+                ExpectEquivalenceClassComparisons<T, minimal_profile>{&errors},
+                vals.eq_classes
+            );
+
+            // Check all of the comparisons for each combination of values that are in
+            // different equivalence classes (not equal with respect to comparison
+            // operators).
+            absl::apply(
+                ExpectOrderedEquivalenceClassesComparisons<T, minimal_profile>{&errors},
+                vals.eq_classes
+            );
+            //
+            //////////////////////////////////////////////////////////////////////////////
+
+            // Perform remaining checks, relying on comparisons.
+            // TODO(calabrese) short circuit if any comparisons above failed.
+            (ForEachTupleElement)(ExpectEquivalenceClass<T, minimal_profile>{&errors}, vals.eq_classes);
+
+            absl::apply(ExpectOrderedEquivalenceClasses<T, minimal_profile>{&errors}, vals.eq_classes);
+
+            return errors;
+        }
+
+        // A type that represents a range of profiles that are acceptable to be matched.
+        //
+        // `MinProf` is the minimum set of syntactic requirements that must be met.
+        //
+        // `MaxProf` is the maximum set of syntactic requirements that must be met.
+        // This maximum is particularly useful for certain "strictness" checking. Some
+        // examples for when this is useful:
+        //
+        // * Making sure that a type is move-only (rather than simply movable)
+        //
+        // * Making sure that a member function is *not* noexcept in cases where it
+        //   cannot be noexcept, such as if a dependent datamember has certain
+        //   operations that are not noexcept.
+        //
+        // * Making sure that a type tightly matches a spec, such as the standard.
+        //
+        // `LogicalProf` is the Profile for which run-time testing is to take place.
+        //
+        // Note: The reason for `LogicalProf` is because it is often the case, when
+        // dealing with templates, that a declaration of a given operation is specified,
+        // but whose body would fail to instantiate. Examples include the
+        // copy-constructor of a standard container when the element-type is move-only,
+        // or the comparison operators of a standard container when the element-type
+        // does not have the necessary comparison operations defined. The `LogicalProf`
+        // parameter allows us to capture the intent of what should be tested at
+        // run-time, even in the cases where syntactically it might otherwise appear as
+        // though the type undergoing testing supports more than it actually does.
+        template<class LogicalProf, class MinProf = LogicalProf, class MaxProf = MinProf>
+        struct ProfileRange
+        {
+            using logical_profile = LogicalProf;
+            using min_profile = MinProf;
+            using max_profile = MaxProf;
+        };
+
+        // Similar to ProfileRange except that it creates a profile range that is
+        // coupled with a Domain and is used when testing that a type matches exactly
+        // the "minimum" requirements of LogicalProf.
+        template<class StrictnessDomain, class LogicalProf, class MinProf = LogicalProf, class MaxProf = MinProf>
+        struct StrictProfileRange
+        {
+            // We do not yet support extension.
+            static_assert(
+                std::is_same<StrictnessDomain, RegularityDomain>::value,
+                "Currently, the only valid StrictnessDomain is RegularityDomain."
+            );
+            using strictness_domain = StrictnessDomain;
+            using logical_profile = LogicalProf;
+            using min_profile = MinProf;
+            using max_profile = MaxProf;
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction that creates a StrictProfileRange from a Domain and either a
+        // Profile or ProfileRange.
+        template<class StrictnessDomain, class ProfOrRange>
+        struct MakeStrictProfileRange;
+
+        template<class StrictnessDomain, class LogicalProf>
+        struct MakeStrictProfileRange
+        {
+            using type = StrictProfileRange<StrictnessDomain, LogicalProf>;
+        };
+
+        template<class StrictnessDomain, class LogicalProf, class MinProf, class MaxProf>
+        struct MakeStrictProfileRange<StrictnessDomain, ProfileRange<LogicalProf, MinProf, MaxProf>>
+        {
+            using type =
+                StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>;
+        };
+
+        template<class StrictnessDomain, class ProfOrRange>
+        using MakeStrictProfileRangeT =
+            typename MakeStrictProfileRange<StrictnessDomain, ProfOrRange>::type;
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // A profile in the RegularityDomain with the strongest possible requirements.
+        using MostStrictProfile =
+            CombineProfiles<TriviallyCompleteProfile, NothrowComparableProfile>;
+
+        // Forms a ProfileRange that treats the Profile as the bare minimum requirements
+        // of a type.
+        template<class LogicalProf, class MinProf = LogicalProf>
+        using LooseProfileRange = StrictProfileRange<RegularityDomain, LogicalProf, MinProf, MostStrictProfile>;
+
+        template<class Prof>
+        using MakeLooseProfileRangeT = Prof;
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // The following classes implement the metafunction ProfileRangeOfT<T> that
+        // takes either a Profile or ProfileRange and yields the ProfileRange to be
+        // used during testing.
+        //
+        template<class T, class /*Enabler*/ = void>
+        struct ProfileRangeOfImpl;
+
+        template<class T>
+        struct ProfileRangeOfImpl<T, absl::void_t<PropertiesOfT<T>>>
+        {
+            using type = LooseProfileRange<T>;
+        };
+
+        template<class T>
+        struct ProfileRangeOf : ProfileRangeOfImpl<T>
+        {
+        };
+
+        template<class StrictnessDomain, class LogicalProf, class MinProf, class MaxProf>
+        struct ProfileRangeOf<
+            StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>>
+        {
+            using type =
+                StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>;
+        };
+
+        template<class T>
+        using ProfileRangeOfT = typename ProfileRangeOf<T>::type;
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // Extract the logical profile of a range (what will be runtime tested).
+        template<class T>
+        using LogicalProfileOfT = typename ProfileRangeOfT<T>::logical_profile;
+
+        // Extract the minimal syntactic profile of a range (error if not at least).
+        template<class T>
+        using MinProfileOfT = typename ProfileRangeOfT<T>::min_profile;
+
+        // Extract the maximum syntactic profile of a range (error if more than).
+        template<class T>
+        using MaxProfileOfT = typename ProfileRangeOfT<T>::max_profile;
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        template<class T>
+        struct IsProfileOrProfileRange : IsProfile<T>::type
+        {
+        };
+
+        template<class StrictnessDomain, class LogicalProf, class MinProf, class MaxProf>
+        struct IsProfileOrProfileRange<
+            StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>> : std::true_type
+        {
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // TODO(calabrese): Consider naming the functions in this class the same as
+        // the macros (defined later on) so that auto-complete leads to the correct name
+        // and so that a user cannot accidentally call a function rather than the macro
+        // form.
+        template<bool ExpectSuccess, class T, class... EqClasses>
+        struct ExpectConformanceOf
+        {
+            // Add a value to be tested. Subsequent calls to this function on the same
+            // object must specify logically "larger" values with respect to the
+            // comparison operators of the type, if any.
+            //
+            // NOTE: This function should not be called directly. A stateless lambda is
+            // implicitly formed and passed when using the INITIALIZER macro at the bottom
+            // of this file.
+            template<class Fun, absl::enable_if_t<std::is_same<ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
+            ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses..., EquivalenceClassType<Fun>>
+                initializer(GeneratorType<Fun> fun) &&
+            {
+                return {
+                    {std::tuple_cat(absl::move(ordered_vals.eq_classes), std::make_tuple((EquivalenceClass)(absl::move(fun))))},
+                    std::move(expected_failed_tests)};
+            }
+
+            template<class... TestNames, absl::enable_if_t<!ExpectSuccess && sizeof...(EqClasses) == 0 && absl::conjunction<std::is_convertible<TestNames, absl::string_view>...>::value>** = nullptr>
+            ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
+                due_to(TestNames&&... test_names) &&
+            {
+                (InsertEach)(&expected_failed_tests, absl::AsciiStrToLower(absl::string_view(test_names))...);
+
+                return {absl::move(ordered_vals), std::move(expected_failed_tests)};
+            }
+
+            template<class... TestNames, int = 0,  // MSVC disambiguator
+                     absl::enable_if_t<ExpectSuccess && sizeof...(EqClasses) == 0 && absl::conjunction<std::is_convertible<TestNames, absl::string_view>...>::value>** = nullptr>
+            ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
+                due_to(TestNames&&... test_names) &&
+            {
+                // TODO(calabrese) Instead have DUE_TO only exist via a CRTP base.
+                // This would produce better errors messages than the static_assert.
+                static_assert(!ExpectSuccess, "DUE_TO cannot be called when conformance is expected -- did "
+                                              "you mean to use ASSERT_NONCONFORMANCE_OF?");
+            }
+
+            // Add a value to be tested. Subsequent calls to this function on the same
+            // object must specify logically "larger" values with respect to the
+            // comparison operators of the type, if any.
+            //
+            // NOTE: This function should not be called directly. A stateful lambda is
+            // implicitly formed and passed when using the INITIALIZER macro at the bottom
+            // of this file.
+            template<class Fun, absl::enable_if_t<std::is_same<ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
+            ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses..., EquivalenceClassType<Fun>>
+                dont_class_directly_stateful_initializer(GeneratorType<Fun> fun) &&
+            {
+                return {
+                    {std::tuple_cat(absl::move(ordered_vals.eq_classes), std::make_tuple((EquivalenceClass)(absl::move(fun))))},
+                    std::move(expected_failed_tests)};
+            }
+
+            // Add a set of value to be tested, where each value is equal with respect to
+            // the comparison operators and std::hash specialization, if defined.
+            template<
+                class... Funs,
+                absl::void_t<absl::enable_if_t<std::is_same<
+                    ResultOfGeneratorT<GeneratorType<Funs>>,
+                    T>::value>...>** = nullptr>
+            ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses..., EquivalenceClassType<Funs...>>
+                equivalence_class(GeneratorType<Funs>... funs) &&
+            {
+                return {{std::tuple_cat(absl::move(ordered_vals.eq_classes), std::make_tuple((EquivalenceClass)(absl::move(funs)...)))}, std::move(expected_failed_tests)};
+            }
+
+            // Execute the tests for the captured set of values, strictly matching a range
+            // of expected profiles in a given domain.
+            template<
+                class ProfRange,
+                absl::enable_if_t<IsProfileOrProfileRange<ProfRange>::value>** = nullptr>
+            ABSL_MUST_USE_RESULT ::testing::AssertionResult with_strict_profile(
+                ProfRange /*profile*/
+            )
+            {
+                ConformanceErrors test_result =
+                    (ExpectRegularityImpl<
+                        T,
+                        LogicalProfileOfT<ProfRange>,
+                        MinProfileOfT<ProfRange>,
+                        MaxProfileOfT<ProfRange>>)(absl::move(ordered_vals));
+
+                return ExpectSuccess ? test_result.assertionResult() : test_result.expectFailedTests(expected_failed_tests);
+            }
+
+            // Execute the tests for the captured set of values, loosely matching a range
+            // of expected profiles (loose in that an interface is allowed to be more
+            // refined that a profile suggests, such as a type having a noexcept copy
+            // constructor when all that is required is that the copy constructor exists).
+            template<class Prof, absl::enable_if_t<IsProfile<Prof>::value>** = nullptr>
+            ABSL_MUST_USE_RESULT ::testing::AssertionResult with_loose_profile(
+                Prof /*profile*/
+            )
+            {
+                ConformanceErrors test_result =
+                    (ExpectRegularityImpl<
+                        T,
+                        Prof,
+                        Prof,
+                        CombineProfiles<TriviallyCompleteProfile, NothrowComparableProfile>>)(absl::
+                                                                                                  move(ordered_vals));
+
+                return ExpectSuccess ? test_result.assertionResult() : test_result.expectFailedTests(expected_failed_tests);
+            }
+
+            OrderedEquivalenceClasses<EqClasses...> ordered_vals;
+            std::set<std::string> expected_failed_tests;
+        };
+
+        template<class T>
+        using ExpectConformanceOfType = ExpectConformanceOf</*ExpectSuccess=*/true, T>;
+
+        template<class T>
+        using ExpectNonconformanceOfType =
+            ExpectConformanceOf</*ExpectSuccess=*/false, T>;
+
+        struct EquivalenceClassMaker
+        {
+            // TODO(calabrese) Constrain to callable
+            template<class Fun>
+            static GeneratorType<Fun> initializer(GeneratorType<Fun> fun)
+            {
+                return fun;
+            }
+        };
 
 // A top-level macro that begins the builder pattern.
 //
 // The argument here takes the datatype to be tested.
-#define ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(...)                            \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
-  if ABSL_INTERNAL_LPAREN                                                   \
-  const ::testing::AssertionResult gtest_ar =                               \
-      ABSL_INTERNAL_LPAREN ::absl::types_internal::ExpectConformanceOfType< \
-          __VA_ARGS__>()
+#define ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(...)                              \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
+    if ABSL_INTERNAL_LPAREN                                                   \
+    const ::testing::AssertionResult gtest_ar =                               \
+        ABSL_INTERNAL_LPAREN ::absl::types_internal::ExpectConformanceOfType< \
+            __VA_ARGS__>()
 
 // Akin to ASSERT_CONFORMANCE_OF except that it expects failure and tries to
 // match text.
-#define ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(...)                            \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
-  if ABSL_INTERNAL_LPAREN                                                      \
-  const ::testing::AssertionResult gtest_ar =                                  \
-      ABSL_INTERNAL_LPAREN ::absl::types_internal::ExpectNonconformanceOfType< \
-          __VA_ARGS__>()
+#define ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(...)                              \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+    if ABSL_INTERNAL_LPAREN                                                      \
+    const ::testing::AssertionResult gtest_ar =                                  \
+        ABSL_INTERNAL_LPAREN ::absl::types_internal::ExpectNonconformanceOfType< \
+            __VA_ARGS__>()
 
 ////////////////////////////////////////////////////////////////////////////////
 // NOTE: The following macros look like they are recursive, but are not (macros
@@ -1317,18 +1320,20 @@ struct EquivalenceClassMaker {
 // Note: Internally, this takes an expression and turns it into the return value
 // of lambda that captures no data. The expression is stringized during
 // preprocessing so that it can be used in error reports.
-#define INITIALIZER(...)                         \
-  initializer(::absl::types_internal::Generator( \
-      [] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
+#define INITIALIZER(...)                                                 \
+    initializer(::absl::types_internal::Generator(                       \
+        [] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__) \
+    ))
 
 // Specify a value to be tested.
 //
 // Note: Internally, this takes an expression and turns it into the return value
 // of lambda that captures data by reference. The expression is stringized
 // during preprocessing so that it can be used in error reports.
-#define STATEFUL_INITIALIZER(...)                         \
-  stateful_initializer(::absl::types_internal::Generator( \
-      [&] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
+#define STATEFUL_INITIALIZER(...)                                         \
+    stateful_initializer(::absl::types_internal::Generator(               \
+        [&] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__) \
+    ))
 
 // Used in the builder-pattern.
 //
@@ -1336,9 +1341,10 @@ struct EquivalenceClassMaker {
 // forwards them along to be tested, grouping them such that the testing suite
 // knows that they are supposed to represent the same logical value (the values
 // compare the same, hash the same, etc.).
-#define EQUIVALENCE_CLASS(...)                    \
-  equivalence_class(ABSL_INTERNAL_TRANSFORM_ARGS( \
-      ABSL_INTERNAL_PREPEND_EQ_MAKER, __VA_ARGS__))
+#define EQUIVALENCE_CLASS(...)                      \
+    equivalence_class(ABSL_INTERNAL_TRANSFORM_ARGS( \
+        ABSL_INTERNAL_PREPEND_EQ_MAKER, __VA_ARGS__ \
+    ))
 
 // An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern.
 // It takes a Profile as its argument.
@@ -1350,11 +1356,12 @@ struct EquivalenceClassMaker {
 //
 // This is useful for testing that a type meets some minimum set of
 // requirements.
-#define WITH_LOOSE_PROFILE(...)                                      \
-  with_loose_profile(                                                \
-      ::absl::types_internal::MakeLooseProfileRangeT<__VA_ARGS__>()) \
-      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                     \
-  else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
+#define WITH_LOOSE_PROFILE(...)                                       \
+    with_loose_profile(                                               \
+        ::absl::types_internal::MakeLooseProfileRangeT<__VA_ARGS__>() \
+    )                                                                 \
+        ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                    \
+    else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
 
 // An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern.
 // It takes a Domain and a Profile as its arguments.
@@ -1368,19 +1375,20 @@ struct EquivalenceClassMaker {
 // commonly, to prevent a type from being "accidentally" copy-constructible in
 // a way that may produce incorrect results, simply because the user forget to
 // delete that operation.
-#define WITH_STRICT_PROFILE(...)                                      \
-  with_strict_profile(                                                \
-      ::absl::types_internal::MakeStrictProfileRangeT<__VA_ARGS__>()) \
-      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                      \
-  else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
+#define WITH_STRICT_PROFILE(...)                                       \
+    with_strict_profile(                                               \
+        ::absl::types_internal::MakeStrictProfileRangeT<__VA_ARGS__>() \
+    )                                                                  \
+        ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                     \
+    else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
 
 // Internal macro that is used in the internals of the EDSL when forming
 // equivalence classes.
 #define ABSL_INTERNAL_PREPEND_EQ_MAKER(arg) \
-  ::absl::types_internal::EquivalenceClassMaker().arg
+    ::absl::types_internal::EquivalenceClassMaker().arg
 
-}  // namespace types_internal
-ABSL_NAMESPACE_END
+    }  // namespace types_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing_helpers.h b/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing_helpers.h
index 00775f9..41c25ab 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing_helpers.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/conformance_testing_helpers.h
@@ -46,326 +46,369 @@
 #include <cstdlib>
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace types_internal {
-
-// Return a readable name for type T.
-template <class T>
-absl::string_view NameOfImpl() {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace types_internal
+    {
+
+        // Return a readable name for type T.
+        template<class T>
+        absl::string_view NameOfImpl()
+        {
 // TODO(calabrese) Investigate using debugging:internal_demangle as a fallback.
 #if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
-  int status = 0;
-  char* demangled_name = nullptr;
-
-  demangled_name =
-      abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
-
-  if (status == 0 && demangled_name != nullptr) {
-    return demangled_name;
-  } else {
-    return typeid(T).name();
-  }
+            int status = 0;
+            char* demangled_name = nullptr;
+
+            demangled_name =
+                abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
+
+            if (status == 0 && demangled_name != nullptr)
+            {
+                return demangled_name;
+            }
+            else
+            {
+                return typeid(T).name();
+            }
 #else
-  return typeid(T).name();
+            return typeid(T).name();
 #endif
-  // NOTE: We intentionally leak demangled_name so that it remains valid
-  // throughout the remainder of the program.
-}
-
-// Given a type, returns as nice of a type name as we can produce (demangled).
-//
-// Note: This currently strips cv-qualifiers and references, but that is okay
-// because we only use this internally with unqualified object types.
-template <class T>
-std::string NameOf() {
-  static const absl::string_view result = NameOfImpl<T>();
-  return std::string(result);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Metafunction to check if a type is callable with no explicit arguments
-template <class Fun, class /*Enabler*/ = void>
-struct IsNullaryCallableImpl : std::false_type {};
-
-template <class Fun>
-struct IsNullaryCallableImpl<
-    Fun, absl::void_t<decltype(std::declval<const Fun&>()())>>
-    : std::true_type {
-  using result_type = decltype(std::declval<const Fun&>()());
-
-  template <class ValueType>
-  using for_type = std::is_same<ValueType, result_type>;
-
-  using void_if_true = void;
-};
-
-template <class Fun>
-struct IsNullaryCallable : IsNullaryCallableImpl<Fun> {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A type that contains a function object that returns an instance of a type
-// that is undergoing conformance testing. This function is required to always
-// return the same value upon invocation.
-template <class Fun>
-struct GeneratorType;
-
-// A type that contains a tuple of GeneratorType<Fun> where each Fun has the
-// same return type. The result of each of the different generators should all
-// be equal values, though the underlying object representation may differ (such
-// as if one returns 0.0 and another return -0.0, or if one returns an empty
-// vector and another returns an empty vector with a different capacity.
-template <class... Funs>
-struct EquivalenceClassType;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction to check if a type is a specialization of EquivalenceClassType
-template <class T>
-struct IsEquivalenceClass : std::false_type {};
-
-template <>
-struct IsEquivalenceClass<EquivalenceClassType<>> : std::true_type {
-  using self = IsEquivalenceClass;
-
-  // A metafunction to check if this EquivalenceClassType is a valid
-  // EquivalenceClassType for a type `ValueType` that is undergoing testing
-  template <class ValueType>
-  using for_type = std::true_type;
-};
-
-template <class Head, class... Tail>
-struct IsEquivalenceClass<EquivalenceClassType<Head, Tail...>>
-    : std::true_type {
-  using self = IsEquivalenceClass;
-
-  // The type undergoing conformance testing that this EquivalenceClass
-  // corresponds to
-  using result_type = typename IsNullaryCallable<Head>::result_type;
-
-  // A metafunction to check if this EquivalenceClassType is a valid
-  // EquivalenceClassType for a type `ValueType` that is undergoing testing
-  template <class ValueType>
-  using for_type = std::is_same<ValueType, result_type>;
-};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A type that contains an ordered series of EquivalenceClassTypes, where the
-// the function object of each underlying GeneratorType has the same return type
-//
-// These equivalence classes are required to be in a logical ascending order
-// that is consistent with comparison operators that are defined for the return
-// type of each GeneratorType, if any.
-template <class... EqClasses>
-struct OrderedEquivalenceClasses;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction to determine the return type of the function object contained
-// in a GeneratorType specialization.
-template <class T>
-struct ResultOfGenerator {};
-
-template <class Fun>
-struct ResultOfGenerator<GeneratorType<Fun>> {
-  using type = decltype(std::declval<const Fun&>()());
-};
-
-template <class Fun>
-using ResultOfGeneratorT = typename ResultOfGenerator<GeneratorType<Fun>>::type;
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction that yields true iff each of Funs is a GeneratorType
-// specialization and they all contain functions with the same return type
-template <class /*Enabler*/, class... Funs>
-struct AreGeneratorsWithTheSameReturnTypeImpl : std::false_type {};
-
-template <>
-struct AreGeneratorsWithTheSameReturnTypeImpl<void> : std::true_type {};
-
-template <class Head, class... Tail>
-struct AreGeneratorsWithTheSameReturnTypeImpl<
-    typename std::enable_if<absl::conjunction<std::is_same<
-        ResultOfGeneratorT<Head>, ResultOfGeneratorT<Tail>>...>::value>::type,
-    Head, Tail...> : std::true_type {};
-
-template <class... Funs>
-struct AreGeneratorsWithTheSameReturnType
-    : AreGeneratorsWithTheSameReturnTypeImpl<void, Funs...>::type {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction that yields true iff each of Funs is an EquivalenceClassType
-// specialization and they all contain GeneratorType specializations that have
-// the same return type
-template <class... EqClasses>
-struct AreEquivalenceClassesOfTheSameType {
-  static_assert(sizeof...(EqClasses) != sizeof...(EqClasses), "");
-};
-
-template <>
-struct AreEquivalenceClassesOfTheSameType<> : std::true_type {
-  using self = AreEquivalenceClassesOfTheSameType;
-
-  // Metafunction to check that a type is the same as all of the equivalence
-  // classes, if any.
-  // Note: In this specialization there are no equivalence classes, so the
-  // value type is always compatible.
-  template <class /*ValueType*/>
-  using for_type = std::true_type;
-};
-
-template <class... Funs>
-struct AreEquivalenceClassesOfTheSameType<EquivalenceClassType<Funs...>>
-    : std::true_type {
-  using self = AreEquivalenceClassesOfTheSameType;
-
-  // Metafunction to check that a type is the same as all of the equivalence
-  // classes, if any.
-  template <class ValueType>
-  using for_type = typename IsEquivalenceClass<
-      EquivalenceClassType<Funs...>>::template for_type<ValueType>;
-};
-
-template <class... TailEqClasses>
-struct AreEquivalenceClassesOfTheSameType<
-    EquivalenceClassType<>, EquivalenceClassType<>, TailEqClasses...>
-    : AreEquivalenceClassesOfTheSameType<TailEqClasses...>::self {};
-
-template <class HeadNextFun, class... TailNextFuns, class... TailEqClasses>
-struct AreEquivalenceClassesOfTheSameType<
-    EquivalenceClassType<>, EquivalenceClassType<HeadNextFun, TailNextFuns...>,
-    TailEqClasses...>
-    : AreEquivalenceClassesOfTheSameType<
-          EquivalenceClassType<HeadNextFun, TailNextFuns...>,
-          TailEqClasses...>::self {};
-
-template <class HeadHeadFun, class... TailHeadFuns, class... TailEqClasses>
-struct AreEquivalenceClassesOfTheSameType<
-    EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, EquivalenceClassType<>,
-    TailEqClasses...>
-    : AreEquivalenceClassesOfTheSameType<
-          EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
-          TailEqClasses...>::self {};
-
-template <class HeadHeadFun, class... TailHeadFuns, class HeadNextFun,
-          class... TailNextFuns, class... TailEqClasses>
-struct AreEquivalenceClassesOfTheSameType<
-    EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
-    EquivalenceClassType<HeadNextFun, TailNextFuns...>, TailEqClasses...>
-    : absl::conditional_t<
-          IsNullaryCallable<HeadNextFun>::template for_type<
-              typename IsNullaryCallable<HeadHeadFun>::result_type>::value,
-          AreEquivalenceClassesOfTheSameType<
-              EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
-              TailEqClasses...>,
-          std::false_type> {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// Execute a function for each passed-in parameter.
-template <class Fun, class... Cases>
-void ForEachParameter(const Fun& fun, const Cases&... cases) {
-  const std::initializer_list<bool> results = {
-      (static_cast<void>(fun(cases)), true)...};
-
-  (void)results;
-}
-
-// Execute a function on each passed-in parameter (using a bound function).
-template <class Fun>
-struct ForEachParameterFun {
-  template <class... T>
-  void operator()(const T&... cases) const {
-    (ForEachParameter)(fun, cases...);
-  }
-
-  Fun fun;
-};
-
-// Execute a function on each element of a tuple.
-template <class Fun, class Tup>
-void ForEachTupleElement(const Fun& fun, const Tup& tup) {
-  absl::apply(ForEachParameterFun<Fun>{fun}, tup);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Execute a function for each combination of two elements of a tuple, including
-// combinations of an element with itself.
-template <class Fun, class... T>
-struct ForEveryTwoImpl {
-  template <class Lhs>
-  struct WithBoundLhs {
-    template <class Rhs>
-    void operator()(const Rhs& rhs) const {
-      fun(lhs, rhs);
-    }
-
-    Fun fun;
-    Lhs lhs;
-  };
-
-  template <class Lhs>
-  void operator()(const Lhs& lhs) const {
-    (ForEachTupleElement)(WithBoundLhs<Lhs>{fun, lhs}, args);
-  }
-
-  Fun fun;
-  std::tuple<T...> args;
-};
-
-template <class Fun, class... T>
-void ForEveryTwo(const Fun& fun, std::tuple<T...> args) {
-  (ForEachTupleElement)(ForEveryTwoImpl<Fun, T...>{fun, args}, args);
-}
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Insert all values into an associative container
-template<class Container>
-void InsertEach(Container* cont) {
-}
-
-template<class Container, class H, class... T>
-void InsertEach(Container* cont, H&& head, T&&... tail) {
-  cont->insert(head);
-  (InsertEach)(cont, tail...);
-}
-//
-////////////////////////////////////////////////////////////////////////////////
-// A template with a nested "Invoke" static-member-function that executes a
-// passed-in Callable when `Condition` is true, otherwise it ignores the
-// Callable. This is useful for executing a function object with a condition
-// that corresponds to whether or not the Callable can be safely instantiated.
-// It has some overlapping uses with C++17 `if constexpr`.
-template <bool Condition>
-struct If;
-
-template <>
-struct If</*Condition =*/false> {
-  template <class Fun, class... P>
-  static void Invoke(const Fun& /*fun*/, P&&... /*args*/) {}
-};
-
-template <>
-struct If</*Condition =*/true> {
-  template <class Fun, class... P>
-  static void Invoke(const Fun& fun, P&&... args) {
-    // TODO(calabrese) Use std::invoke equivalent instead of function-call.
-    fun(absl::forward<P>(args)...);
-  }
-};
+            // NOTE: We intentionally leak demangled_name so that it remains valid
+            // throughout the remainder of the program.
+        }
+
+        // Given a type, returns as nice of a type name as we can produce (demangled).
+        //
+        // Note: This currently strips cv-qualifiers and references, but that is okay
+        // because we only use this internally with unqualified object types.
+        template<class T>
+        std::string NameOf()
+        {
+            static const absl::string_view result = NameOfImpl<T>();
+            return std::string(result);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // Metafunction to check if a type is callable with no explicit arguments
+        template<class Fun, class /*Enabler*/ = void>
+        struct IsNullaryCallableImpl : std::false_type
+        {
+        };
+
+        template<class Fun>
+        struct IsNullaryCallableImpl<
+            Fun,
+            absl::void_t<decltype(std::declval<const Fun&>()())>> : std::true_type
+        {
+            using result_type = decltype(std::declval<const Fun&>()());
+
+            template<class ValueType>
+            using for_type = std::is_same<ValueType, result_type>;
+
+            using void_if_true = void;
+        };
+
+        template<class Fun>
+        struct IsNullaryCallable : IsNullaryCallableImpl<Fun>
+        {
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // A type that contains a function object that returns an instance of a type
+        // that is undergoing conformance testing. This function is required to always
+        // return the same value upon invocation.
+        template<class Fun>
+        struct GeneratorType;
+
+        // A type that contains a tuple of GeneratorType<Fun> where each Fun has the
+        // same return type. The result of each of the different generators should all
+        // be equal values, though the underlying object representation may differ (such
+        // as if one returns 0.0 and another return -0.0, or if one returns an empty
+        // vector and another returns an empty vector with a different capacity.
+        template<class... Funs>
+        struct EquivalenceClassType;
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction to check if a type is a specialization of EquivalenceClassType
+        template<class T>
+        struct IsEquivalenceClass : std::false_type
+        {
+        };
+
+        template<>
+        struct IsEquivalenceClass<EquivalenceClassType<>> : std::true_type
+        {
+            using self = IsEquivalenceClass;
+
+            // A metafunction to check if this EquivalenceClassType is a valid
+            // EquivalenceClassType for a type `ValueType` that is undergoing testing
+            template<class ValueType>
+            using for_type = std::true_type;
+        };
+
+        template<class Head, class... Tail>
+        struct IsEquivalenceClass<EquivalenceClassType<Head, Tail...>> : std::true_type
+        {
+            using self = IsEquivalenceClass;
+
+            // The type undergoing conformance testing that this EquivalenceClass
+            // corresponds to
+            using result_type = typename IsNullaryCallable<Head>::result_type;
+
+            // A metafunction to check if this EquivalenceClassType is a valid
+            // EquivalenceClassType for a type `ValueType` that is undergoing testing
+            template<class ValueType>
+            using for_type = std::is_same<ValueType, result_type>;
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // A type that contains an ordered series of EquivalenceClassTypes, where the
+        // the function object of each underlying GeneratorType has the same return type
+        //
+        // These equivalence classes are required to be in a logical ascending order
+        // that is consistent with comparison operators that are defined for the return
+        // type of each GeneratorType, if any.
+        template<class... EqClasses>
+        struct OrderedEquivalenceClasses;
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction to determine the return type of the function object contained
+        // in a GeneratorType specialization.
+        template<class T>
+        struct ResultOfGenerator
+        {
+        };
+
+        template<class Fun>
+        struct ResultOfGenerator<GeneratorType<Fun>>
+        {
+            using type = decltype(std::declval<const Fun&>()());
+        };
+
+        template<class Fun>
+        using ResultOfGeneratorT = typename ResultOfGenerator<GeneratorType<Fun>>::type;
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction that yields true iff each of Funs is a GeneratorType
+        // specialization and they all contain functions with the same return type
+        template<class /*Enabler*/, class... Funs>
+        struct AreGeneratorsWithTheSameReturnTypeImpl : std::false_type
+        {
+        };
+
+        template<>
+        struct AreGeneratorsWithTheSameReturnTypeImpl<void> : std::true_type
+        {
+        };
+
+        template<class Head, class... Tail>
+        struct AreGeneratorsWithTheSameReturnTypeImpl<
+            typename std::enable_if<absl::conjunction<std::is_same<
+                ResultOfGeneratorT<Head>,
+                ResultOfGeneratorT<Tail>>...>::value>::type,
+            Head,
+            Tail...> : std::true_type
+        {
+        };
+
+        template<class... Funs>
+        struct AreGeneratorsWithTheSameReturnType : AreGeneratorsWithTheSameReturnTypeImpl<void, Funs...>::type
+        {
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // A metafunction that yields true iff each of Funs is an EquivalenceClassType
+        // specialization and they all contain GeneratorType specializations that have
+        // the same return type
+        template<class... EqClasses>
+        struct AreEquivalenceClassesOfTheSameType
+        {
+            static_assert(sizeof...(EqClasses) != sizeof...(EqClasses), "");
+        };
+
+        template<>
+        struct AreEquivalenceClassesOfTheSameType<> : std::true_type
+        {
+            using self = AreEquivalenceClassesOfTheSameType;
+
+            // Metafunction to check that a type is the same as all of the equivalence
+            // classes, if any.
+            // Note: In this specialization there are no equivalence classes, so the
+            // value type is always compatible.
+            template<class /*ValueType*/>
+            using for_type = std::true_type;
+        };
+
+        template<class... Funs>
+        struct AreEquivalenceClassesOfTheSameType<EquivalenceClassType<Funs...>> : std::true_type
+        {
+            using self = AreEquivalenceClassesOfTheSameType;
+
+            // Metafunction to check that a type is the same as all of the equivalence
+            // classes, if any.
+            template<class ValueType>
+            using for_type = typename IsEquivalenceClass<
+                EquivalenceClassType<Funs...>>::template for_type<ValueType>;
+        };
+
+        template<class... TailEqClasses>
+        struct AreEquivalenceClassesOfTheSameType<
+            EquivalenceClassType<>,
+            EquivalenceClassType<>,
+            TailEqClasses...> : AreEquivalenceClassesOfTheSameType<TailEqClasses...>::self
+        {
+        };
+
+        template<class HeadNextFun, class... TailNextFuns, class... TailEqClasses>
+        struct AreEquivalenceClassesOfTheSameType<
+            EquivalenceClassType<>,
+            EquivalenceClassType<HeadNextFun, TailNextFuns...>,
+            TailEqClasses...> : AreEquivalenceClassesOfTheSameType<EquivalenceClassType<HeadNextFun, TailNextFuns...>, TailEqClasses...>::self
+        {
+        };
+
+        template<class HeadHeadFun, class... TailHeadFuns, class... TailEqClasses>
+        struct AreEquivalenceClassesOfTheSameType<
+            EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
+            EquivalenceClassType<>,
+            TailEqClasses...> : AreEquivalenceClassesOfTheSameType<EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, TailEqClasses...>::self
+        {
+        };
+
+        template<class HeadHeadFun, class... TailHeadFuns, class HeadNextFun, class... TailNextFuns, class... TailEqClasses>
+        struct AreEquivalenceClassesOfTheSameType<
+            EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
+            EquivalenceClassType<HeadNextFun, TailNextFuns...>,
+            TailEqClasses...> : absl::conditional_t<IsNullaryCallable<HeadNextFun>::template for_type<typename IsNullaryCallable<HeadHeadFun>::result_type>::value, AreEquivalenceClassesOfTheSameType<EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, TailEqClasses...>, std::false_type>
+        {
+        };
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        // Execute a function for each passed-in parameter.
+        template<class Fun, class... Cases>
+        void ForEachParameter(const Fun& fun, const Cases&... cases)
+        {
+            const std::initializer_list<bool> results = {
+                (static_cast<void>(fun(cases)), true)...};
+
+            (void)results;
+        }
+
+        // Execute a function on each passed-in parameter (using a bound function).
+        template<class Fun>
+        struct ForEachParameterFun
+        {
+            template<class... T>
+            void operator()(const T&... cases) const
+            {
+                (ForEachParameter)(fun, cases...);
+            }
+
+            Fun fun;
+        };
+
+        // Execute a function on each element of a tuple.
+        template<class Fun, class Tup>
+        void ForEachTupleElement(const Fun& fun, const Tup& tup)
+        {
+            absl::apply(ForEachParameterFun<Fun>{fun}, tup);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // Execute a function for each combination of two elements of a tuple, including
+        // combinations of an element with itself.
+        template<class Fun, class... T>
+        struct ForEveryTwoImpl
+        {
+            template<class Lhs>
+            struct WithBoundLhs
+            {
+                template<class Rhs>
+                void operator()(const Rhs& rhs) const
+                {
+                    fun(lhs, rhs);
+                }
+
+                Fun fun;
+                Lhs lhs;
+            };
+
+            template<class Lhs>
+            void operator()(const Lhs& lhs) const
+            {
+                (ForEachTupleElement)(WithBoundLhs<Lhs>{fun, lhs}, args);
+            }
+
+            Fun fun;
+            std::tuple<T...> args;
+        };
+
+        template<class Fun, class... T>
+        void ForEveryTwo(const Fun& fun, std::tuple<T...> args)
+        {
+            (ForEachTupleElement)(ForEveryTwoImpl<Fun, T...>{fun, args}, args);
+        }
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////////////
+        //
+        // Insert all values into an associative container
+        template<class Container>
+        void InsertEach(Container* cont)
+        {
+        }
+
+        template<class Container, class H, class... T>
+        void InsertEach(Container* cont, H&& head, T&&... tail)
+        {
+            cont->insert(head);
+            (InsertEach)(cont, tail...);
+        }
+        //
+        ////////////////////////////////////////////////////////////////////////////////
+        // A template with a nested "Invoke" static-member-function that executes a
+        // passed-in Callable when `Condition` is true, otherwise it ignores the
+        // Callable. This is useful for executing a function object with a condition
+        // that corresponds to whether or not the Callable can be safely instantiated.
+        // It has some overlapping uses with C++17 `if constexpr`.
+        template<bool Condition>
+        struct If;
+
+        template<>
+        struct If</*Condition =*/false>
+        {
+            template<class Fun, class... P>
+            static void Invoke(const Fun& /*fun*/, P&&... /*args*/)
+            {
+            }
+        };
+
+        template<>
+        struct If</*Condition =*/true>
+        {
+            template<class Fun, class... P>
+            static void Invoke(const Fun& fun, P&&... args)
+            {
+                // TODO(calabrese) Use std::invoke equivalent instead of function-call.
+                fun(absl::forward<P>(args)...);
+            }
+        };
 
 //
 // ABSL_INTERNAL_STRINGIZE(...)
@@ -384,8 +427,8 @@ struct If</*Condition =*/true> {
 #define ABSL_INTERNAL_STRINGIZE_IMPL(arg) ABSL_INTERNAL_STRINGIZE_IMPL2 arg
 #define ABSL_INTERNAL_STRINGIZE_IMPL2(...) #__VA_ARGS__
 
-}  // namespace types_internal
-ABSL_NAMESPACE_END
+    }  // namespace types_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/optional.h b/CAPI/cpp/grpc/include/absl/types/internal/optional.h
index 6ed0c66..2756af0 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/optional.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/optional.h
@@ -46,357 +46,416 @@
 #if __has_feature(cxx_inheriting_constructors)
 #define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
 #endif
-#elif (defined(__GNUC__) &&                                       \
-       (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 8)) || \
-    (__cpp_inheriting_constructors >= 200802) ||                  \
+#elif (defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 8)) || \
+    (__cpp_inheriting_constructors >= 200802) ||                                       \
     (defined(_MSC_VER) && _MSC_VER >= 1910)
 #define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Forward declaration
-template <typename T>
-class optional;
-
-namespace optional_internal {
-
-// This tag type is used as a constructor parameter type for `nullopt_t`.
-struct init_t {
-  explicit init_t() = default;
-};
-
-struct empty_struct {};
-
-// This class stores the data in optional<T>.
-// It is specialized based on whether T is trivially destructible.
-// This is the specialization for non trivially destructible type.
-template <typename T, bool unused = std::is_trivially_destructible<T>::value>
-class optional_data_dtor_base {
-  struct dummy_type {
-    static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
-    // Use an array to avoid GCC 6 placement-new warning.
-    empty_struct data[sizeof(T) / sizeof(empty_struct)];
-  };
-
- protected:
-  // Whether there is data or not.
-  bool engaged_;
-  // Data storage
-  union {
-    T data_;
-    dummy_type dummy_;
-  };
-
-  void destruct() noexcept {
-    if (engaged_) {
-      // `data_` must be initialized if `engaged_` is true.
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // Forward declaration
+    template<typename T>
+    class optional;
+
+    namespace optional_internal
+    {
+
+        // This tag type is used as a constructor parameter type for `nullopt_t`.
+        struct init_t
+        {
+            explicit init_t() = default;
+        };
+
+        struct empty_struct
+        {
+        };
+
+        // This class stores the data in optional<T>.
+        // It is specialized based on whether T is trivially destructible.
+        // This is the specialization for non trivially destructible type.
+        template<typename T, bool unused = std::is_trivially_destructible<T>::value>
+        class optional_data_dtor_base
+        {
+            struct dummy_type
+            {
+                static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+                // Use an array to avoid GCC 6 placement-new warning.
+                empty_struct data[sizeof(T) / sizeof(empty_struct)];
+            };
+
+        protected:
+            // Whether there is data or not.
+            bool engaged_;
+            // Data storage
+            union
+            {
+                T data_;
+                dummy_type dummy_;
+            };
+
+            void destruct() noexcept
+            {
+                if (engaged_)
+                {
+                    // `data_` must be initialized if `engaged_` is true.
 #if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
 #endif
-      data_.~T();
+                    data_.~T();
 #if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
 #pragma GCC diagnostic pop
 #endif
-      engaged_ = false;
-    }
-  }
-
-  // dummy_ must be initialized for constexpr constructor.
-  constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
-
-  template <typename... Args>
-  constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
-      : engaged_(true), data_(absl::forward<Args>(args)...) {}
-
-  ~optional_data_dtor_base() { destruct(); }
-};
-
-// Specialization for trivially destructible type.
-template <typename T>
-class optional_data_dtor_base<T, true> {
-  struct dummy_type {
-    static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
-    // Use array to avoid GCC 6 placement-new warning.
-    empty_struct data[sizeof(T) / sizeof(empty_struct)];
-  };
-
- protected:
-  // Whether there is data or not.
-  bool engaged_;
-  // Data storage
-  union {
-    T data_;
-    dummy_type dummy_;
-  };
-  void destruct() noexcept { engaged_ = false; }
-
-  // dummy_ must be initialized for constexpr constructor.
-  constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
-
-  template <typename... Args>
-  constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
-      : engaged_(true), data_(absl::forward<Args>(args)...) {}
-};
-
-template <typename T>
-class optional_data_base : public optional_data_dtor_base<T> {
- protected:
-  using base = optional_data_dtor_base<T>;
+                    engaged_ = false;
+                }
+            }
+
+            // dummy_ must be initialized for constexpr constructor.
+            constexpr optional_data_dtor_base() noexcept :
+                engaged_(false),
+                dummy_{{}}
+            {
+            }
+
+            template<typename... Args>
+            constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args) :
+                engaged_(true),
+                data_(absl::forward<Args>(args)...)
+            {
+            }
+
+            ~optional_data_dtor_base()
+            {
+                destruct();
+            }
+        };
+
+        // Specialization for trivially destructible type.
+        template<typename T>
+        class optional_data_dtor_base<T, true>
+        {
+            struct dummy_type
+            {
+                static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+                // Use array to avoid GCC 6 placement-new warning.
+                empty_struct data[sizeof(T) / sizeof(empty_struct)];
+            };
+
+        protected:
+            // Whether there is data or not.
+            bool engaged_;
+            // Data storage
+            union
+            {
+                T data_;
+                dummy_type dummy_;
+            };
+            void destruct() noexcept
+            {
+                engaged_ = false;
+            }
+
+            // dummy_ must be initialized for constexpr constructor.
+            constexpr optional_data_dtor_base() noexcept :
+                engaged_(false),
+                dummy_{{}}
+            {
+            }
+
+            template<typename... Args>
+            constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args) :
+                engaged_(true),
+                data_(absl::forward<Args>(args)...)
+            {
+            }
+        };
+
+        template<typename T>
+        class optional_data_base : public optional_data_dtor_base<T>
+        {
+        protected:
+            using base = optional_data_dtor_base<T>;
 #ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
-  using base::base;
+            using base::base;
 #else
-  optional_data_base() = default;
+            optional_data_base() = default;
 
-  template <typename... Args>
-  constexpr explicit optional_data_base(in_place_t t, Args&&... args)
-      : base(t, absl::forward<Args>(args)...) {}
+            template<typename... Args>
+            constexpr explicit optional_data_base(in_place_t t, Args&&... args) :
+                base(t, absl::forward<Args>(args)...)
+            {
+            }
 #endif
 
-  template <typename... Args>
-  void construct(Args&&... args) {
-    // Use dummy_'s address to work around casting cv-qualified T* to void*.
-    ::new (static_cast<void*>(&this->dummy_)) T(std::forward<Args>(args)...);
-    this->engaged_ = true;
-  }
-
-  template <typename U>
-  void assign(U&& u) {
-    if (this->engaged_) {
-      this->data_ = std::forward<U>(u);
-    } else {
-      construct(std::forward<U>(u));
-    }
-  }
-};
-
-// TODO(absl-team): Add another class using
-// std::is_trivially_move_constructible trait when available to match
-// http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that
-// have trivial move but nontrivial copy.
-// Also, we should be checking is_trivially_copyable here, which is not
-// supported now, so we use is_trivially_* traits instead.
-template <typename T,
-          bool unused = absl::is_trivially_copy_constructible<T>::value&&
-              absl::is_trivially_copy_assignable<typename std::remove_cv<
-                  T>::type>::value&& std::is_trivially_destructible<T>::value>
-class optional_data;
-
-// Trivially copyable types
-template <typename T>
-class optional_data<T, true> : public optional_data_base<T> {
- protected:
+            template<typename... Args>
+            void construct(Args&&... args)
+            {
+                // Use dummy_'s address to work around casting cv-qualified T* to void*.
+                ::new (static_cast<void*>(&this->dummy_)) T(std::forward<Args>(args)...);
+                this->engaged_ = true;
+            }
+
+            template<typename U>
+            void assign(U&& u)
+            {
+                if (this->engaged_)
+                {
+                    this->data_ = std::forward<U>(u);
+                }
+                else
+                {
+                    construct(std::forward<U>(u));
+                }
+            }
+        };
+
+        // TODO(absl-team): Add another class using
+        // std::is_trivially_move_constructible trait when available to match
+        // http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that
+        // have trivial move but nontrivial copy.
+        // Also, we should be checking is_trivially_copyable here, which is not
+        // supported now, so we use is_trivially_* traits instead.
+        template<typename T, bool unused = absl::is_trivially_copy_constructible<T>::value&& absl::is_trivially_copy_assignable<typename std::remove_cv<T>::type>::value&& std::is_trivially_destructible<T>::value>
+        class optional_data;
+
+        // Trivially copyable types
+        template<typename T>
+        class optional_data<T, true> : public optional_data_base<T>
+        {
+        protected:
 #ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
-  using optional_data_base<T>::optional_data_base;
+            using optional_data_base<T>::optional_data_base;
 #else
-  optional_data() = default;
+            optional_data() = default;
 
-  template <typename... Args>
-  constexpr explicit optional_data(in_place_t t, Args&&... args)
-      : optional_data_base<T>(t, absl::forward<Args>(args)...) {}
+            template<typename... Args>
+            constexpr explicit optional_data(in_place_t t, Args&&... args) :
+                optional_data_base<T>(t, absl::forward<Args>(args)...)
+            {
+            }
 #endif
-};
+        };
 
-template <typename T>
-class optional_data<T, false> : public optional_data_base<T> {
- protected:
+        template<typename T>
+        class optional_data<T, false> : public optional_data_base<T>
+        {
+        protected:
 #ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
-  using optional_data_base<T>::optional_data_base;
+            using optional_data_base<T>::optional_data_base;
 #else
-  template <typename... Args>
-  constexpr explicit optional_data(in_place_t t, Args&&... args)
-      : optional_data_base<T>(t, absl::forward<Args>(args)...) {}
+            template<typename... Args>
+            constexpr explicit optional_data(in_place_t t, Args&&... args) :
+                optional_data_base<T>(t, absl::forward<Args>(args)...)
+            {
+            }
 #endif
 
-  optional_data() = default;
-
-  optional_data(const optional_data& rhs) : optional_data_base<T>() {
-    if (rhs.engaged_) {
-      this->construct(rhs.data_);
-    }
-  }
-
-  optional_data(optional_data&& rhs) noexcept(
-      absl::default_allocator_is_nothrow::value ||
-      std::is_nothrow_move_constructible<T>::value)
-      : optional_data_base<T>() {
-    if (rhs.engaged_) {
-      this->construct(std::move(rhs.data_));
-    }
-  }
-
-  optional_data& operator=(const optional_data& rhs) {
-    if (rhs.engaged_) {
-      this->assign(rhs.data_);
-    } else {
-      this->destruct();
-    }
-    return *this;
-  }
-
-  optional_data& operator=(optional_data&& rhs) noexcept(
-      std::is_nothrow_move_assignable<T>::value&&
-          std::is_nothrow_move_constructible<T>::value) {
-    if (rhs.engaged_) {
-      this->assign(std::move(rhs.data_));
-    } else {
-      this->destruct();
-    }
-    return *this;
-  }
-};
-
-// Ordered by level of restriction, from low to high.
-// Copyable implies movable.
-enum class copy_traits { copyable = 0, movable = 1, non_movable = 2 };
-
-// Base class for enabling/disabling copy/move constructor.
-template <copy_traits>
-class optional_ctor_base;
-
-template <>
-class optional_ctor_base<copy_traits::copyable> {
- public:
-  constexpr optional_ctor_base() = default;
-  optional_ctor_base(const optional_ctor_base&) = default;
-  optional_ctor_base(optional_ctor_base&&) = default;
-  optional_ctor_base& operator=(const optional_ctor_base&) = default;
-  optional_ctor_base& operator=(optional_ctor_base&&) = default;
-};
-
-template <>
-class optional_ctor_base<copy_traits::movable> {
- public:
-  constexpr optional_ctor_base() = default;
-  optional_ctor_base(const optional_ctor_base&) = delete;
-  optional_ctor_base(optional_ctor_base&&) = default;
-  optional_ctor_base& operator=(const optional_ctor_base&) = default;
-  optional_ctor_base& operator=(optional_ctor_base&&) = default;
-};
-
-template <>
-class optional_ctor_base<copy_traits::non_movable> {
- public:
-  constexpr optional_ctor_base() = default;
-  optional_ctor_base(const optional_ctor_base&) = delete;
-  optional_ctor_base(optional_ctor_base&&) = delete;
-  optional_ctor_base& operator=(const optional_ctor_base&) = default;
-  optional_ctor_base& operator=(optional_ctor_base&&) = default;
-};
-
-// Base class for enabling/disabling copy/move assignment.
-template <copy_traits>
-class optional_assign_base;
-
-template <>
-class optional_assign_base<copy_traits::copyable> {
- public:
-  constexpr optional_assign_base() = default;
-  optional_assign_base(const optional_assign_base&) = default;
-  optional_assign_base(optional_assign_base&&) = default;
-  optional_assign_base& operator=(const optional_assign_base&) = default;
-  optional_assign_base& operator=(optional_assign_base&&) = default;
-};
-
-template <>
-class optional_assign_base<copy_traits::movable> {
- public:
-  constexpr optional_assign_base() = default;
-  optional_assign_base(const optional_assign_base&) = default;
-  optional_assign_base(optional_assign_base&&) = default;
-  optional_assign_base& operator=(const optional_assign_base&) = delete;
-  optional_assign_base& operator=(optional_assign_base&&) = default;
-};
-
-template <>
-class optional_assign_base<copy_traits::non_movable> {
- public:
-  constexpr optional_assign_base() = default;
-  optional_assign_base(const optional_assign_base&) = default;
-  optional_assign_base(optional_assign_base&&) = default;
-  optional_assign_base& operator=(const optional_assign_base&) = delete;
-  optional_assign_base& operator=(optional_assign_base&&) = delete;
-};
-
-template <typename T>
-struct ctor_copy_traits {
-  static constexpr copy_traits traits =
-      std::is_copy_constructible<T>::value
-          ? copy_traits::copyable
-          : std::is_move_constructible<T>::value ? copy_traits::movable
-                                                 : copy_traits::non_movable;
-};
-
-template <typename T>
-struct assign_copy_traits {
-  static constexpr copy_traits traits =
-      absl::is_copy_assignable<T>::value && std::is_copy_constructible<T>::value
-          ? copy_traits::copyable
-          : absl::is_move_assignable<T>::value &&
-                    std::is_move_constructible<T>::value
-                ? copy_traits::movable
-                : copy_traits::non_movable;
-};
-
-// Whether T is constructible or convertible from optional<U>.
-template <typename T, typename U>
-struct is_constructible_convertible_from_optional
-    : std::integral_constant<
-          bool, std::is_constructible<T, optional<U>&>::value ||
-                    std::is_constructible<T, optional<U>&&>::value ||
-                    std::is_constructible<T, const optional<U>&>::value ||
-                    std::is_constructible<T, const optional<U>&&>::value ||
-                    std::is_convertible<optional<U>&, T>::value ||
-                    std::is_convertible<optional<U>&&, T>::value ||
-                    std::is_convertible<const optional<U>&, T>::value ||
-                    std::is_convertible<const optional<U>&&, T>::value> {};
-
-// Whether T is constructible or convertible or assignable from optional<U>.
-template <typename T, typename U>
-struct is_constructible_convertible_assignable_from_optional
-    : std::integral_constant<
-          bool, is_constructible_convertible_from_optional<T, U>::value ||
-                    std::is_assignable<T&, optional<U>&>::value ||
-                    std::is_assignable<T&, optional<U>&&>::value ||
-                    std::is_assignable<T&, const optional<U>&>::value ||
-                    std::is_assignable<T&, const optional<U>&&>::value> {};
-
-// Helper function used by [optional.relops], [optional.comp_with_t],
-// for checking whether an expression is convertible to bool.
-bool convertible_to_bool(bool);
-
-// Base class for std::hash<absl::optional<T>>:
-// If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to
-// compute the hash; Otherwise, it is disabled.
-// Reference N4659 23.14.15 [unord.hash].
-template <typename T, typename = size_t>
-struct optional_hash_base {
-  optional_hash_base() = delete;
-  optional_hash_base(const optional_hash_base&) = delete;
-  optional_hash_base(optional_hash_base&&) = delete;
-  optional_hash_base& operator=(const optional_hash_base&) = delete;
-  optional_hash_base& operator=(optional_hash_base&&) = delete;
-};
-
-template <typename T>
-struct optional_hash_base<T, decltype(std::hash<absl::remove_const_t<T> >()(
-                                 std::declval<absl::remove_const_t<T> >()))> {
-  using argument_type = absl::optional<T>;
-  using result_type = size_t;
-  size_t operator()(const absl::optional<T>& opt) const {
-    absl::type_traits_internal::AssertHashEnabled<absl::remove_const_t<T>>();
-    if (opt) {
-      return std::hash<absl::remove_const_t<T> >()(*opt);
-    } else {
-      return static_cast<size_t>(0x297814aaad196e6dULL);
-    }
-  }
-};
-
-}  // namespace optional_internal
-ABSL_NAMESPACE_END
+            optional_data() = default;
+
+            optional_data(const optional_data& rhs) :
+                optional_data_base<T>()
+            {
+                if (rhs.engaged_)
+                {
+                    this->construct(rhs.data_);
+                }
+            }
+
+            optional_data(optional_data&& rhs) noexcept(
+                absl::default_allocator_is_nothrow::value ||
+                std::is_nothrow_move_constructible<T>::value
+            ) :
+                optional_data_base<T>()
+            {
+                if (rhs.engaged_)
+                {
+                    this->construct(std::move(rhs.data_));
+                }
+            }
+
+            optional_data& operator=(const optional_data& rhs)
+            {
+                if (rhs.engaged_)
+                {
+                    this->assign(rhs.data_);
+                }
+                else
+                {
+                    this->destruct();
+                }
+                return *this;
+            }
+
+            optional_data& operator=(optional_data&& rhs) noexcept(
+                std::is_nothrow_move_assignable<T>::value&&
+                    std::is_nothrow_move_constructible<T>::value
+            )
+            {
+                if (rhs.engaged_)
+                {
+                    this->assign(std::move(rhs.data_));
+                }
+                else
+                {
+                    this->destruct();
+                }
+                return *this;
+            }
+        };
+
+        // Ordered by level of restriction, from low to high.
+        // Copyable implies movable.
+        enum class copy_traits
+        {
+            copyable = 0,
+            movable = 1,
+            non_movable = 2
+        };
+
+        // Base class for enabling/disabling copy/move constructor.
+        template<copy_traits>
+        class optional_ctor_base;
+
+        template<>
+        class optional_ctor_base<copy_traits::copyable>
+        {
+        public:
+            constexpr optional_ctor_base() = default;
+            optional_ctor_base(const optional_ctor_base&) = default;
+            optional_ctor_base(optional_ctor_base&&) = default;
+            optional_ctor_base& operator=(const optional_ctor_base&) = default;
+            optional_ctor_base& operator=(optional_ctor_base&&) = default;
+        };
+
+        template<>
+        class optional_ctor_base<copy_traits::movable>
+        {
+        public:
+            constexpr optional_ctor_base() = default;
+            optional_ctor_base(const optional_ctor_base&) = delete;
+            optional_ctor_base(optional_ctor_base&&) = default;
+            optional_ctor_base& operator=(const optional_ctor_base&) = default;
+            optional_ctor_base& operator=(optional_ctor_base&&) = default;
+        };
+
+        template<>
+        class optional_ctor_base<copy_traits::non_movable>
+        {
+        public:
+            constexpr optional_ctor_base() = default;
+            optional_ctor_base(const optional_ctor_base&) = delete;
+            optional_ctor_base(optional_ctor_base&&) = delete;
+            optional_ctor_base& operator=(const optional_ctor_base&) = default;
+            optional_ctor_base& operator=(optional_ctor_base&&) = default;
+        };
+
+        // Base class for enabling/disabling copy/move assignment.
+        template<copy_traits>
+        class optional_assign_base;
+
+        template<>
+        class optional_assign_base<copy_traits::copyable>
+        {
+        public:
+            constexpr optional_assign_base() = default;
+            optional_assign_base(const optional_assign_base&) = default;
+            optional_assign_base(optional_assign_base&&) = default;
+            optional_assign_base& operator=(const optional_assign_base&) = default;
+            optional_assign_base& operator=(optional_assign_base&&) = default;
+        };
+
+        template<>
+        class optional_assign_base<copy_traits::movable>
+        {
+        public:
+            constexpr optional_assign_base() = default;
+            optional_assign_base(const optional_assign_base&) = default;
+            optional_assign_base(optional_assign_base&&) = default;
+            optional_assign_base& operator=(const optional_assign_base&) = delete;
+            optional_assign_base& operator=(optional_assign_base&&) = default;
+        };
+
+        template<>
+        class optional_assign_base<copy_traits::non_movable>
+        {
+        public:
+            constexpr optional_assign_base() = default;
+            optional_assign_base(const optional_assign_base&) = default;
+            optional_assign_base(optional_assign_base&&) = default;
+            optional_assign_base& operator=(const optional_assign_base&) = delete;
+            optional_assign_base& operator=(optional_assign_base&&) = delete;
+        };
+
+        template<typename T>
+        struct ctor_copy_traits
+        {
+            static constexpr copy_traits traits =
+                std::is_copy_constructible<T>::value ? copy_traits::copyable : std::is_move_constructible<T>::value ? copy_traits::movable :
+                                                                                                                      copy_traits::non_movable;
+        };
+
+        template<typename T>
+        struct assign_copy_traits
+        {
+            static constexpr copy_traits traits =
+                absl::is_copy_assignable<T>::value && std::is_copy_constructible<T>::value ? copy_traits::copyable : absl::is_move_assignable<T>::value && std::is_move_constructible<T>::value ? copy_traits::movable :
+                                                                                                                                                                                                  copy_traits::non_movable;
+        };
+
+        // Whether T is constructible or convertible from optional<U>.
+        template<typename T, typename U>
+        struct is_constructible_convertible_from_optional : std::integral_constant<bool, std::is_constructible<T, optional<U>&>::value || std::is_constructible<T, optional<U>&&>::value || std::is_constructible<T, const optional<U>&>::value || std::is_constructible<T, const optional<U>&&>::value || std::is_convertible<optional<U>&, T>::value || std::is_convertible<optional<U>&&, T>::value || std::is_convertible<const optional<U>&, T>::value || std::is_convertible<const optional<U>&&, T>::value>
+        {
+        };
+
+        // Whether T is constructible or convertible or assignable from optional<U>.
+        template<typename T, typename U>
+        struct is_constructible_convertible_assignable_from_optional : std::integral_constant<bool, is_constructible_convertible_from_optional<T, U>::value || std::is_assignable<T&, optional<U>&>::value || std::is_assignable<T&, optional<U>&&>::value || std::is_assignable<T&, const optional<U>&>::value || std::is_assignable<T&, const optional<U>&&>::value>
+        {
+        };
+
+        // Helper function used by [optional.relops], [optional.comp_with_t],
+        // for checking whether an expression is convertible to bool.
+        bool convertible_to_bool(bool);
+
+        // Base class for std::hash<absl::optional<T>>:
+        // If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to
+        // compute the hash; Otherwise, it is disabled.
+        // Reference N4659 23.14.15 [unord.hash].
+        template<typename T, typename = size_t>
+        struct optional_hash_base
+        {
+            optional_hash_base() = delete;
+            optional_hash_base(const optional_hash_base&) = delete;
+            optional_hash_base(optional_hash_base&&) = delete;
+            optional_hash_base& operator=(const optional_hash_base&) = delete;
+            optional_hash_base& operator=(optional_hash_base&&) = delete;
+        };
+
+        template<typename T>
+        struct optional_hash_base<T, decltype(std::hash<absl::remove_const_t<T>>()(std::declval<absl::remove_const_t<T>>()))>
+        {
+            using argument_type = absl::optional<T>;
+            using result_type = size_t;
+            size_t operator()(const absl::optional<T>& opt) const
+            {
+                absl::type_traits_internal::AssertHashEnabled<absl::remove_const_t<T>>();
+                if (opt)
+                {
+                    return std::hash<absl::remove_const_t<T>>()(*opt);
+                }
+                else
+                {
+                    return static_cast<size_t>(0x297814aaad196e6dULL);
+                }
+            }
+        };
+
+    }  // namespace optional_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #undef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/span.h b/CAPI/cpp/grpc/include/absl/types/internal/span.h
index 112612f..926a659 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/span.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/span.h
@@ -25,104 +25,118 @@
 #include "absl/base/internal/throw_delegate.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace span_internal {
-// A constexpr min function
-constexpr size_t Min(size_t a, size_t b) noexcept { return a < b ? a : b; }
-
-// Wrappers for access to container data pointers.
-template <typename C>
-constexpr auto GetDataImpl(C& c, char) noexcept  // NOLINT(runtime/references)
-    -> decltype(c.data()) {
-  return c.data();
-}
-
-// Before C++17, std::string::data returns a const char* in all cases.
-inline char* GetDataImpl(std::string& s,  // NOLINT(runtime/references)
-                         int) noexcept {
-  return &s[0];
-}
-
-template <typename C>
-constexpr auto GetData(C& c) noexcept  // NOLINT(runtime/references)
-    -> decltype(GetDataImpl(c, 0)) {
-  return GetDataImpl(c, 0);
-}
-
-// Detection idioms for size() and data().
-template <typename C>
-using HasSize =
-    std::is_integral<absl::decay_t<decltype(std::declval<C&>().size())>>;
-
-// We want to enable conversion from vector<T*> to Span<const T* const> but
-// disable conversion from vector<Derived> to Span<Base>. Here we use
-// the fact that U** is convertible to Q* const* if and only if Q is the same
-// type or a more cv-qualified version of U.  We also decay the result type of
-// data() to avoid problems with classes which have a member function data()
-// which returns a reference.
-template <typename T, typename C>
-using HasData =
-    std::is_convertible<absl::decay_t<decltype(GetData(std::declval<C&>()))>*,
-                        T* const*>;
-
-// Extracts value type from a Container
-template <typename C>
-struct ElementType {
-  using type = typename absl::remove_reference_t<C>::value_type;
-};
-
-template <typename T, size_t N>
-struct ElementType<T (&)[N]> {
-  using type = T;
-};
-
-template <typename C>
-using ElementT = typename ElementType<C>::type;
-
-template <typename T>
-using EnableIfMutable =
-    typename std::enable_if<!std::is_const<T>::value, int>::type;
-
-template <template <typename> class SpanT, typename T>
-bool EqualImpl(SpanT<T> a, SpanT<T> b) {
-  static_assert(std::is_const<T>::value, "");
-  return absl::equal(a.begin(), a.end(), b.begin(), b.end());
-}
-
-template <template <typename> class SpanT, typename T>
-bool LessThanImpl(SpanT<T> a, SpanT<T> b) {
-  // We can't use value_type since that is remove_cv_t<T>, so we go the long way
-  // around.
-  static_assert(std::is_const<T>::value, "");
-  return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
-}
-
-// The `IsConvertible` classes here are needed because of the
-// `std::is_convertible` bug in libcxx when compiled with GCC. This build
-// configuration is used by Android NDK toolchain. Reference link:
-// https://bugs.llvm.org/show_bug.cgi?id=27538.
-template <typename From, typename To>
-struct IsConvertibleHelper {
- private:
-  static std::true_type testval(To);
-  static std::false_type testval(...);
-
- public:
-  using type = decltype(testval(std::declval<From>()));
-};
-
-template <typename From, typename To>
-struct IsConvertible : IsConvertibleHelper<From, To>::type {};
-
-// TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the
-// older version of libcxx is not supported.
-template <typename From, typename To>
-using EnableIfConvertibleTo =
-    typename std::enable_if<IsConvertible<From, To>::value>::type;
-}  // namespace span_internal
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    namespace span_internal
+    {
+        // A constexpr min function
+        constexpr size_t Min(size_t a, size_t b) noexcept
+        {
+            return a < b ? a : b;
+        }
+
+        // Wrappers for access to container data pointers.
+        template<typename C>
+        constexpr auto GetDataImpl(C& c, char) noexcept  // NOLINT(runtime/references)
+            -> decltype(c.data())
+        {
+            return c.data();
+        }
+
+        // Before C++17, std::string::data returns a const char* in all cases.
+        inline char* GetDataImpl(std::string& s,  // NOLINT(runtime/references)
+                                 int) noexcept
+        {
+            return &s[0];
+        }
+
+        template<typename C>
+        constexpr auto GetData(C& c) noexcept  // NOLINT(runtime/references)
+            -> decltype(GetDataImpl(c, 0))
+        {
+            return GetDataImpl(c, 0);
+        }
+
+        // Detection idioms for size() and data().
+        template<typename C>
+        using HasSize =
+            std::is_integral<absl::decay_t<decltype(std::declval<C&>().size())>>;
+
+        // We want to enable conversion from vector<T*> to Span<const T* const> but
+        // disable conversion from vector<Derived> to Span<Base>. Here we use
+        // the fact that U** is convertible to Q* const* if and only if Q is the same
+        // type or a more cv-qualified version of U.  We also decay the result type of
+        // data() to avoid problems with classes which have a member function data()
+        // which returns a reference.
+        template<typename T, typename C>
+        using HasData =
+            std::is_convertible<absl::decay_t<decltype(GetData(std::declval<C&>()))>*, T* const*>;
+
+        // Extracts value type from a Container
+        template<typename C>
+        struct ElementType
+        {
+            using type = typename absl::remove_reference_t<C>::value_type;
+        };
+
+        template<typename T, size_t N>
+        struct ElementType<T (&)[N]>
+        {
+            using type = T;
+        };
+
+        template<typename C>
+        using ElementT = typename ElementType<C>::type;
+
+        template<typename T>
+        using EnableIfMutable =
+            typename std::enable_if<!std::is_const<T>::value, int>::type;
+
+        template<template<typename> class SpanT, typename T>
+        bool EqualImpl(SpanT<T> a, SpanT<T> b)
+        {
+            static_assert(std::is_const<T>::value, "");
+            return absl::equal(a.begin(), a.end(), b.begin(), b.end());
+        }
+
+        template<template<typename> class SpanT, typename T>
+        bool LessThanImpl(SpanT<T> a, SpanT<T> b)
+        {
+            // We can't use value_type since that is remove_cv_t<T>, so we go the long way
+            // around.
+            static_assert(std::is_const<T>::value, "");
+            return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+        }
+
+        // The `IsConvertible` classes here are needed because of the
+        // `std::is_convertible` bug in libcxx when compiled with GCC. This build
+        // configuration is used by Android NDK toolchain. Reference link:
+        // https://bugs.llvm.org/show_bug.cgi?id=27538.
+        template<typename From, typename To>
+        struct IsConvertibleHelper
+        {
+        private:
+            static std::true_type testval(To);
+            static std::false_type testval(...);
+
+        public:
+            using type = decltype(testval(std::declval<From>()));
+        };
+
+        template<typename From, typename To>
+        struct IsConvertible : IsConvertibleHelper<From, To>::type
+        {
+        };
+
+        // TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the
+        // older version of libcxx is not supported.
+        template<typename From, typename To>
+        using EnableIfConvertibleTo =
+            typename std::enable_if<IsConvertible<From, To>::value>::type;
+    }  // namespace span_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TYPES_INTERNAL_SPAN_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/transform_args.h b/CAPI/cpp/grpc/include/absl/types/internal/transform_args.h
index 4a0ab42..706bbdd 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/transform_args.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/transform_args.h
@@ -55,10 +55,9 @@
 //   MY_MACRO(a), MY_MACRO(b), MY_MACRO(c)
 //
 // TODO(calabrese) Handle no arguments as a special case.
-#define ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)             \
-  ABSL_INTERNAL_CAT(ABSL_INTERNAL_TRANSFORM_ARGS,        \
-                    ABSL_INTERNAL_NUM_ARGS(__VA_ARGS__)) \
-  (m, __VA_ARGS__)
+#define ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)                                             \
+    ABSL_INTERNAL_CAT(ABSL_INTERNAL_TRANSFORM_ARGS, ABSL_INTERNAL_NUM_ARGS(__VA_ARGS__)) \
+    (m, __VA_ARGS__)
 
 #define ABSL_INTERNAL_TRANSFORM_ARGS1(m, a0) m(a0)
 
@@ -67,180 +66,150 @@
 #define ABSL_INTERNAL_TRANSFORM_ARGS3(m, a0, a1, a2) m(a0), m(a1), m(a2)
 
 #define ABSL_INTERNAL_TRANSFORM_ARGS4(m, a0, a1, a2, a3) \
-  m(a0), m(a1), m(a2), m(a3)
+    m(a0), m(a1), m(a2), m(a3)
 
 #define ABSL_INTERNAL_TRANSFORM_ARGS5(m, a0, a1, a2, a3, a4) \
-  m(a0), m(a1), m(a2), m(a3), m(a4)
+    m(a0), m(a1), m(a2), m(a3), m(a4)
 
 #define ABSL_INTERNAL_TRANSFORM_ARGS6(m, a0, a1, a2, a3, a4, a5) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5)
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5)
 
 #define ABSL_INTERNAL_TRANSFORM_ARGS7(m, a0, a1, a2, a3, a4, a5, a6) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6)
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6)
 
 #define ABSL_INTERNAL_TRANSFORM_ARGS8(m, a0, a1, a2, a3, a4, a5, a6, a7) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7)
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7)
 
 #define ABSL_INTERNAL_TRANSFORM_ARGS9(m, a0, a1, a2, a3, a4, a5, a6, a7, a8) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS10(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9)                                    \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS11(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10)                               \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9), m(a10)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS12(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11)                          \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS13(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12)                     \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS14(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13)                \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS15(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14)           \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS16(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15)      \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS17(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS18(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17)                                   \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS19(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18)                              \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS20(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19)                         \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS21(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19, a20)                    \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS22(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19, a20, a21)               \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS23(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19, a20, a21, a22)          \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS24(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19, a20, a21, a22, a23)     \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS25(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
-                                       a9, a10, a11, a12, a13, a14, a15, a16,  \
-                                       a17, a18, a19, a20, a21, a22, a23, a24) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS26(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)                         \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS27(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)                    \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS28(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)               \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS29(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)          \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \
-      m(a28)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS30(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)     \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \
-      m(a28), m(a29)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS31(                                        \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,   \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \
-      m(a28), m(a29), m(a30)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS32(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
-                                       a9, a10, a11, a12, a13, a14, a15, a16,  \
-                                       a17, a18, a19, a20, a21, a22, a23, a24, \
-                                       a25, a26, a27, a28, a29, a30, a31)      \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \
-      m(a28), m(a29), m(a30), m(a31)
-
-#define ABSL_INTERNAL_NUM_ARGS_IMPL(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,    \
-                                    a10, a11, a12, a13, a14, a15, a16, a17,    \
-                                    a18, a19, a20, a21, a22, a23, a24, a25,    \
-                                    a26, a27, a28, a29, a30, a31, result, ...) \
-  result
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS10(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS11(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9), m(a10)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS12(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                   \
+        m(a10), m(a11)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS13(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                        \
+        m(a10), m(a11), m(a12)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS14(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                             \
+        m(a10), m(a11), m(a12), m(a13)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS15(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                  \
+        m(a10), m(a11), m(a12), m(a13), m(a14)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS16(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                       \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS17(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                            \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS18(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                 \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS19(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                      \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS20(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                           \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                     \
+        m(a19)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS21(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                          \
+        m(a19), m(a20)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS22(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                     \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                               \
+        m(a19), m(a20), m(a21)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS23(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                          \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                                    \
+        m(a19), m(a20), m(a21), m(a22)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS24(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                               \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                                         \
+        m(a19), m(a20), m(a21), m(a22), m(a23)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS25(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                                    \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                                              \
+        m(a19), m(a20), m(a21), m(a22), m(a23), m(a24)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS26(                                                                                       \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25 \
+)                                                                                                                             \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                     \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                               \
+        m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS27(                                                                                            \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26 \
+)                                                                                                                                  \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                          \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                    \
+        m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS28(                                                                                                 \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27 \
+)                                                                                                                                       \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                               \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                         \
+        m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS29(                                                                                                      \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28 \
+)                                                                                                                                            \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                    \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                              \
+        m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),                                                              \
+        m(a28)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS30(                                                                                                           \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29 \
+)                                                                                                                                                 \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                         \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                                   \
+        m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),                                                                   \
+        m(a28), m(a29)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS31(                                                                                                                \
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30 \
+)                                                                                                                                                      \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                              \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                                        \
+        m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),                                                                        \
+        m(a28), m(a29), m(a30)
+
+#define ABSL_INTERNAL_TRANSFORM_ARGS32(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) \
+    m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),                                                                                                                       \
+        m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),                                                                                                                 \
+        m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),                                                                                                                 \
+        m(a28), m(a29), m(a30), m(a31)
+
+#define ABSL_INTERNAL_NUM_ARGS_IMPL(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, result, ...) \
+    result
 
 #define ABSL_INTERNAL_FORCE_EXPANSION(...) __VA_ARGS__
 
-#define ABSL_INTERNAL_NUM_ARGS(...)                                            \
-  ABSL_INTERNAL_FORCE_EXPANSION(ABSL_INTERNAL_NUM_ARGS_IMPL(                   \
-      __VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, \
-      17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ))
+#define ABSL_INTERNAL_NUM_ARGS(...)                                                                                                         \
+    ABSL_INTERNAL_FORCE_EXPANSION(ABSL_INTERNAL_NUM_ARGS_IMPL(                                                                              \
+        __VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, \
+    ))
 
 #endif  // ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/internal/variant.h b/CAPI/cpp/grpc/include/absl/types/internal/variant.h
index 7c402ec..3ba8669 100644
--- a/CAPI/cpp/grpc/include/absl/types/internal/variant.h
+++ b/CAPI/cpp/grpc/include/absl/types/internal/variant.h
@@ -39,499 +39,544 @@
 
 #if !defined(ABSL_USES_STD_VARIANT)
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <class... Types>
-class variant;
-
-ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1));
-
-template <class T>
-struct variant_size;
-
-template <std::size_t I, class T>
-struct variant_alternative;
-
-namespace variant_internal {
-
-// NOTE: See specializations below for details.
-template <std::size_t I, class T>
-struct VariantAlternativeSfinae {};
-
-// Requires: I < variant_size_v<T>.
-//
-// Value: The Ith type of Types...
-template <std::size_t I, class T0, class... Tn>
-struct VariantAlternativeSfinae<I, variant<T0, Tn...>>
-    : VariantAlternativeSfinae<I - 1, variant<Tn...>> {};
-
-// Value: T0
-template <class T0, class... Ts>
-struct VariantAlternativeSfinae<0, variant<T0, Ts...>> {
-  using type = T0;
-};
-
-template <std::size_t I, class T>
-using VariantAlternativeSfinaeT = typename VariantAlternativeSfinae<I, T>::type;
-
-// NOTE: Requires T to be a reference type.
-template <class T, class U>
-struct GiveQualsTo;
-
-template <class T, class U>
-struct GiveQualsTo<T&, U> {
-  using type = U&;
-};
-
-template <class T, class U>
-struct GiveQualsTo<T&&, U> {
-  using type = U&&;
-};
-
-template <class T, class U>
-struct GiveQualsTo<const T&, U> {
-  using type = const U&;
-};
-
-template <class T, class U>
-struct GiveQualsTo<const T&&, U> {
-  using type = const U&&;
-};
-
-template <class T, class U>
-struct GiveQualsTo<volatile T&, U> {
-  using type = volatile U&;
-};
-
-template <class T, class U>
-struct GiveQualsTo<volatile T&&, U> {
-  using type = volatile U&&;
-};
-
-template <class T, class U>
-struct GiveQualsTo<volatile const T&, U> {
-  using type = volatile const U&;
-};
-
-template <class T, class U>
-struct GiveQualsTo<volatile const T&&, U> {
-  using type = volatile const U&&;
-};
-
-template <class T, class U>
-using GiveQualsToT = typename GiveQualsTo<T, U>::type;
-
-// Convenience alias, since size_t integral_constant is used a lot in this file.
-template <std::size_t I>
-using SizeT = std::integral_constant<std::size_t, I>;
-
-using NPos = SizeT<variant_npos>;
-
-template <class Variant, class T, class = void>
-struct IndexOfConstructedType {};
-
-template <std::size_t I, class Variant>
-struct VariantAccessResultImpl;
-
-template <std::size_t I, template <class...> class Variantemplate, class... T>
-struct VariantAccessResultImpl<I, Variantemplate<T...>&> {
-  using type = typename absl::variant_alternative<I, variant<T...>>::type&;
-};
-
-template <std::size_t I, template <class...> class Variantemplate, class... T>
-struct VariantAccessResultImpl<I, const Variantemplate<T...>&> {
-  using type =
-      const typename absl::variant_alternative<I, variant<T...>>::type&;
-};
-
-template <std::size_t I, template <class...> class Variantemplate, class... T>
-struct VariantAccessResultImpl<I, Variantemplate<T...>&&> {
-  using type = typename absl::variant_alternative<I, variant<T...>>::type&&;
-};
-
-template <std::size_t I, template <class...> class Variantemplate, class... T>
-struct VariantAccessResultImpl<I, const Variantemplate<T...>&&> {
-  using type =
-      const typename absl::variant_alternative<I, variant<T...>>::type&&;
-};
-
-template <std::size_t I, class Variant>
-using VariantAccessResult =
-    typename VariantAccessResultImpl<I, Variant&&>::type;
-
-// NOTE: This is used instead of std::array to reduce instantiation overhead.
-template <class T, std::size_t Size>
-struct SimpleArray {
-  static_assert(Size != 0, "");
-  T value[Size];
-};
-
-template <class T>
-struct AccessedType {
-  using type = T;
-};
-
-template <class T>
-using AccessedTypeT = typename AccessedType<T>::type;
-
-template <class T, std::size_t Size>
-struct AccessedType<SimpleArray<T, Size>> {
-  using type = AccessedTypeT<T>;
-};
-
-template <class T>
-constexpr T AccessSimpleArray(const T& value) {
-  return value;
-}
-
-template <class T, std::size_t Size, class... SizeT>
-constexpr AccessedTypeT<T> AccessSimpleArray(const SimpleArray<T, Size>& table,
-                                             std::size_t head_index,
-                                             SizeT... tail_indices) {
-  return AccessSimpleArray(table.value[head_index], tail_indices...);
-}
-
-// Note: Intentionally is an alias.
-template <class T>
-using AlwaysZero = SizeT<0>;
-
-template <class Op, class... Vs>
-struct VisitIndicesResultImpl {
-  using type = absl::result_of_t<Op(AlwaysZero<Vs>...)>;
-};
-
-template <class Op, class... Vs>
-using VisitIndicesResultT = typename VisitIndicesResultImpl<Op, Vs...>::type;
-
-template <class ReturnType, class FunctionObject, class EndIndices,
-          class BoundIndices>
-struct MakeVisitationMatrix;
-
-template <class ReturnType, class FunctionObject, std::size_t... Indices>
-constexpr ReturnType call_with_indices(FunctionObject&& function) {
-  static_assert(
-      std::is_same<ReturnType, decltype(std::declval<FunctionObject>()(
-                                   SizeT<Indices>()...))>::value,
-      "Not all visitation overloads have the same return type.");
-  return absl::forward<FunctionObject>(function)(SizeT<Indices>()...);
-}
-
-template <class ReturnType, class FunctionObject, std::size_t... BoundIndices>
-struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
-                            index_sequence<BoundIndices...>> {
-  using ResultType = ReturnType (*)(FunctionObject&&);
-  static constexpr ResultType Run() {
-    return &call_with_indices<ReturnType, FunctionObject,
-                              (BoundIndices - 1)...>;
-  }
-};
-
-template <typename Is, std::size_t J>
-struct AppendToIndexSequence;
-
-template <typename Is, std::size_t J>
-using AppendToIndexSequenceT = typename AppendToIndexSequence<Is, J>::type;
-
-template <std::size_t... Is, std::size_t J>
-struct AppendToIndexSequence<index_sequence<Is...>, J> {
-  using type = index_sequence<Is..., J>;
-};
-
-template <class ReturnType, class FunctionObject, class EndIndices,
-          class CurrIndices, class BoundIndices>
-struct MakeVisitationMatrixImpl;
-
-template <class ReturnType, class FunctionObject, class EndIndices,
-          std::size_t... CurrIndices, class BoundIndices>
-struct MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices,
-                                index_sequence<CurrIndices...>, BoundIndices> {
-  using ResultType = SimpleArray<
-      typename MakeVisitationMatrix<ReturnType, FunctionObject, EndIndices,
-                                    index_sequence<>>::ResultType,
-      sizeof...(CurrIndices)>;
-
-  static constexpr ResultType Run() {
-    return {{MakeVisitationMatrix<
-        ReturnType, FunctionObject, EndIndices,
-        AppendToIndexSequenceT<BoundIndices, CurrIndices>>::Run()...}};
-  }
-};
-
-template <class ReturnType, class FunctionObject, std::size_t HeadEndIndex,
-          std::size_t... TailEndIndices, std::size_t... BoundIndices>
-struct MakeVisitationMatrix<ReturnType, FunctionObject,
-                            index_sequence<HeadEndIndex, TailEndIndices...>,
-                            index_sequence<BoundIndices...>>
-    : MakeVisitationMatrixImpl<ReturnType, FunctionObject,
-                               index_sequence<TailEndIndices...>,
-                               absl::make_index_sequence<HeadEndIndex>,
-                               index_sequence<BoundIndices...>> {};
-
-struct UnreachableSwitchCase {
-  template <class Op>
-  [[noreturn]] static VisitIndicesResultT<Op, std::size_t> Run(
-      Op&& /*ignored*/) {
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    template<class... Types>
+    class variant;
+
+    ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1));
+
+    template<class T>
+    struct variant_size;
+
+    template<std::size_t I, class T>
+    struct variant_alternative;
+
+    namespace variant_internal
+    {
+
+        // NOTE: See specializations below for details.
+        template<std::size_t I, class T>
+        struct VariantAlternativeSfinae
+        {
+        };
+
+        // Requires: I < variant_size_v<T>.
+        //
+        // Value: The Ith type of Types...
+        template<std::size_t I, class T0, class... Tn>
+        struct VariantAlternativeSfinae<I, variant<T0, Tn...>> : VariantAlternativeSfinae<I - 1, variant<Tn...>>
+        {
+        };
+
+        // Value: T0
+        template<class T0, class... Ts>
+        struct VariantAlternativeSfinae<0, variant<T0, Ts...>>
+        {
+            using type = T0;
+        };
+
+        template<std::size_t I, class T>
+        using VariantAlternativeSfinaeT = typename VariantAlternativeSfinae<I, T>::type;
+
+        // NOTE: Requires T to be a reference type.
+        template<class T, class U>
+        struct GiveQualsTo;
+
+        template<class T, class U>
+        struct GiveQualsTo<T&, U>
+        {
+            using type = U&;
+        };
+
+        template<class T, class U>
+        struct GiveQualsTo<T&&, U>
+        {
+            using type = U&&;
+        };
+
+        template<class T, class U>
+        struct GiveQualsTo<const T&, U>
+        {
+            using type = const U&;
+        };
+
+        template<class T, class U>
+        struct GiveQualsTo<const T&&, U>
+        {
+            using type = const U&&;
+        };
+
+        template<class T, class U>
+        struct GiveQualsTo<volatile T&, U>
+        {
+            using type = volatile U&;
+        };
+
+        template<class T, class U>
+        struct GiveQualsTo<volatile T&&, U>
+        {
+            using type = volatile U&&;
+        };
+
+        template<class T, class U>
+        struct GiveQualsTo<volatile const T&, U>
+        {
+            using type = volatile const U&;
+        };
+
+        template<class T, class U>
+        struct GiveQualsTo<volatile const T&&, U>
+        {
+            using type = volatile const U&&;
+        };
+
+        template<class T, class U>
+        using GiveQualsToT = typename GiveQualsTo<T, U>::type;
+
+        // Convenience alias, since size_t integral_constant is used a lot in this file.
+        template<std::size_t I>
+        using SizeT = std::integral_constant<std::size_t, I>;
+
+        using NPos = SizeT<variant_npos>;
+
+        template<class Variant, class T, class = void>
+        struct IndexOfConstructedType
+        {
+        };
+
+        template<std::size_t I, class Variant>
+        struct VariantAccessResultImpl;
+
+        template<std::size_t I, template<class...> class Variantemplate, class... T>
+        struct VariantAccessResultImpl<I, Variantemplate<T...>&>
+        {
+            using type = typename absl::variant_alternative<I, variant<T...>>::type&;
+        };
+
+        template<std::size_t I, template<class...> class Variantemplate, class... T>
+        struct VariantAccessResultImpl<I, const Variantemplate<T...>&>
+        {
+            using type =
+                const typename absl::variant_alternative<I, variant<T...>>::type&;
+        };
+
+        template<std::size_t I, template<class...> class Variantemplate, class... T>
+        struct VariantAccessResultImpl<I, Variantemplate<T...>&&>
+        {
+            using type = typename absl::variant_alternative<I, variant<T...>>::type&&;
+        };
+
+        template<std::size_t I, template<class...> class Variantemplate, class... T>
+        struct VariantAccessResultImpl<I, const Variantemplate<T...>&&>
+        {
+            using type =
+                const typename absl::variant_alternative<I, variant<T...>>::type&&;
+        };
+
+        template<std::size_t I, class Variant>
+        using VariantAccessResult =
+            typename VariantAccessResultImpl<I, Variant&&>::type;
+
+        // NOTE: This is used instead of std::array to reduce instantiation overhead.
+        template<class T, std::size_t Size>
+        struct SimpleArray
+        {
+            static_assert(Size != 0, "");
+            T value[Size];
+        };
+
+        template<class T>
+        struct AccessedType
+        {
+            using type = T;
+        };
+
+        template<class T>
+        using AccessedTypeT = typename AccessedType<T>::type;
+
+        template<class T, std::size_t Size>
+        struct AccessedType<SimpleArray<T, Size>>
+        {
+            using type = AccessedTypeT<T>;
+        };
+
+        template<class T>
+        constexpr T AccessSimpleArray(const T& value)
+        {
+            return value;
+        }
+
+        template<class T, std::size_t Size, class... SizeT>
+        constexpr AccessedTypeT<T> AccessSimpleArray(const SimpleArray<T, Size>& table, std::size_t head_index, SizeT... tail_indices)
+        {
+            return AccessSimpleArray(table.value[head_index], tail_indices...);
+        }
+
+        // Note: Intentionally is an alias.
+        template<class T>
+        using AlwaysZero = SizeT<0>;
+
+        template<class Op, class... Vs>
+        struct VisitIndicesResultImpl
+        {
+            using type = absl::result_of_t<Op(AlwaysZero<Vs>...)>;
+        };
+
+        template<class Op, class... Vs>
+        using VisitIndicesResultT = typename VisitIndicesResultImpl<Op, Vs...>::type;
+
+        template<class ReturnType, class FunctionObject, class EndIndices, class BoundIndices>
+        struct MakeVisitationMatrix;
+
+        template<class ReturnType, class FunctionObject, std::size_t... Indices>
+        constexpr ReturnType call_with_indices(FunctionObject&& function)
+        {
+            static_assert(
+                std::is_same<ReturnType, decltype(std::declval<FunctionObject>()(SizeT<Indices>()...))>::value,
+                "Not all visitation overloads have the same return type."
+            );
+            return absl::forward<FunctionObject>(function)(SizeT<Indices>()...);
+        }
+
+        template<class ReturnType, class FunctionObject, std::size_t... BoundIndices>
+        struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>, index_sequence<BoundIndices...>>
+        {
+            using ResultType = ReturnType (*)(FunctionObject&&);
+            static constexpr ResultType Run()
+            {
+                return &call_with_indices<ReturnType, FunctionObject, (BoundIndices - 1)...>;
+            }
+        };
+
+        template<typename Is, std::size_t J>
+        struct AppendToIndexSequence;
+
+        template<typename Is, std::size_t J>
+        using AppendToIndexSequenceT = typename AppendToIndexSequence<Is, J>::type;
+
+        template<std::size_t... Is, std::size_t J>
+        struct AppendToIndexSequence<index_sequence<Is...>, J>
+        {
+            using type = index_sequence<Is..., J>;
+        };
+
+        template<class ReturnType, class FunctionObject, class EndIndices, class CurrIndices, class BoundIndices>
+        struct MakeVisitationMatrixImpl;
+
+        template<class ReturnType, class FunctionObject, class EndIndices, std::size_t... CurrIndices, class BoundIndices>
+        struct MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices, index_sequence<CurrIndices...>, BoundIndices>
+        {
+            using ResultType = SimpleArray<
+                typename MakeVisitationMatrix<ReturnType, FunctionObject, EndIndices, index_sequence<>>::ResultType,
+                sizeof...(CurrIndices)>;
+
+            static constexpr ResultType Run()
+            {
+                return {{MakeVisitationMatrix<
+                    ReturnType,
+                    FunctionObject,
+                    EndIndices,
+                    AppendToIndexSequenceT<BoundIndices, CurrIndices>>::Run()...}};
+            }
+        };
+
+        template<class ReturnType, class FunctionObject, std::size_t HeadEndIndex, std::size_t... TailEndIndices, std::size_t... BoundIndices>
+        struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<HeadEndIndex, TailEndIndices...>, index_sequence<BoundIndices...>> : MakeVisitationMatrixImpl<ReturnType, FunctionObject, index_sequence<TailEndIndices...>, absl::make_index_sequence<HeadEndIndex>, index_sequence<BoundIndices...>>
+        {
+        };
+
+        struct UnreachableSwitchCase
+        {
+            template<class Op>
+            [[noreturn]] static VisitIndicesResultT<Op, std::size_t> Run(
+                Op&& /*ignored*/
+            )
+            {
 #if ABSL_HAVE_BUILTIN(__builtin_unreachable) || \
     (defined(__GNUC__) && !defined(__clang__))
-    __builtin_unreachable();
+                __builtin_unreachable();
 #elif defined(_MSC_VER)
-    __assume(false);
+                __assume(false);
 #else
-    // Try to use assert of false being identified as an unreachable intrinsic.
-    // NOTE: We use assert directly to increase chances of exploiting an assume
-    //       intrinsic.
-    assert(false);  // NOLINT
+                // Try to use assert of false being identified as an unreachable intrinsic.
+                // NOTE: We use assert directly to increase chances of exploiting an assume
+                //       intrinsic.
+                assert(false);  // NOLINT
 
-    // Hack to silence potential no return warning -- cause an infinite loop.
-    return Run(absl::forward<Op>(op));
+                // Hack to silence potential no return warning -- cause an infinite loop.
+                return Run(absl::forward<Op>(op));
 #endif  // Checks for __builtin_unreachable
-  }
-};
-
-template <class Op, std::size_t I>
-struct ReachableSwitchCase {
-  static VisitIndicesResultT<Op, std::size_t> Run(Op&& op) {
-    return absl::base_internal::invoke(absl::forward<Op>(op), SizeT<I>());
-  }
-};
-
-// The number 33 is just a guess at a reasonable maximum to our switch. It is
-// not based on any analysis. The reason it is a power of 2 plus 1 instead of a
-// power of 2 is because the number was picked to correspond to a power of 2
-// amount of "normal" alternatives, plus one for the possibility of the user
-// providing "monostate" in addition to the more natural alternatives.
-ABSL_INTERNAL_INLINE_CONSTEXPR(std::size_t, MaxUnrolledVisitCases, 33);
-
-// Note: The default-definition is for unreachable cases.
-template <bool IsReachable>
-struct PickCaseImpl {
-  template <class Op, std::size_t I>
-  using Apply = UnreachableSwitchCase;
-};
-
-template <>
-struct PickCaseImpl</*IsReachable =*/true> {
-  template <class Op, std::size_t I>
-  using Apply = ReachableSwitchCase<Op, I>;
-};
-
-// Note: This form of dance with template aliases is to make sure that we
-//       instantiate a number of templates proportional to the number of variant
-//       alternatives rather than a number of templates proportional to our
-//       maximum unrolled amount of visitation cases (aliases are effectively
-//       "free" whereas other template instantiations are costly).
-template <class Op, std::size_t I, std::size_t EndIndex>
-using PickCase = typename PickCaseImpl<(I < EndIndex)>::template Apply<Op, I>;
-
-template <class ReturnType>
-[[noreturn]] ReturnType TypedThrowBadVariantAccess() {
-  absl::variant_internal::ThrowBadVariantAccess();
-}
-
-// Given N variant sizes, determine the number of cases there would need to be
-// in a single switch-statement that would cover every possibility in the
-// corresponding N-ary visit operation.
-template <std::size_t... NumAlternatives>
-struct NumCasesOfSwitch;
-
-template <std::size_t HeadNumAlternatives, std::size_t... TailNumAlternatives>
-struct NumCasesOfSwitch<HeadNumAlternatives, TailNumAlternatives...> {
-  static constexpr std::size_t value =
-      (HeadNumAlternatives + 1) *
-      NumCasesOfSwitch<TailNumAlternatives...>::value;
-};
-
-template <>
-struct NumCasesOfSwitch<> {
-  static constexpr std::size_t value = 1;
-};
-
-// A switch statement optimizes better than the table of function pointers.
-template <std::size_t EndIndex>
-struct VisitIndicesSwitch {
-  static_assert(EndIndex <= MaxUnrolledVisitCases,
-                "Maximum unrolled switch size exceeded.");
-
-  template <class Op>
-  static VisitIndicesResultT<Op, std::size_t> Run(Op&& op, std::size_t i) {
-    switch (i) {
-      case 0:
-        return PickCase<Op, 0, EndIndex>::Run(absl::forward<Op>(op));
-      case 1:
-        return PickCase<Op, 1, EndIndex>::Run(absl::forward<Op>(op));
-      case 2:
-        return PickCase<Op, 2, EndIndex>::Run(absl::forward<Op>(op));
-      case 3:
-        return PickCase<Op, 3, EndIndex>::Run(absl::forward<Op>(op));
-      case 4:
-        return PickCase<Op, 4, EndIndex>::Run(absl::forward<Op>(op));
-      case 5:
-        return PickCase<Op, 5, EndIndex>::Run(absl::forward<Op>(op));
-      case 6:
-        return PickCase<Op, 6, EndIndex>::Run(absl::forward<Op>(op));
-      case 7:
-        return PickCase<Op, 7, EndIndex>::Run(absl::forward<Op>(op));
-      case 8:
-        return PickCase<Op, 8, EndIndex>::Run(absl::forward<Op>(op));
-      case 9:
-        return PickCase<Op, 9, EndIndex>::Run(absl::forward<Op>(op));
-      case 10:
-        return PickCase<Op, 10, EndIndex>::Run(absl::forward<Op>(op));
-      case 11:
-        return PickCase<Op, 11, EndIndex>::Run(absl::forward<Op>(op));
-      case 12:
-        return PickCase<Op, 12, EndIndex>::Run(absl::forward<Op>(op));
-      case 13:
-        return PickCase<Op, 13, EndIndex>::Run(absl::forward<Op>(op));
-      case 14:
-        return PickCase<Op, 14, EndIndex>::Run(absl::forward<Op>(op));
-      case 15:
-        return PickCase<Op, 15, EndIndex>::Run(absl::forward<Op>(op));
-      case 16:
-        return PickCase<Op, 16, EndIndex>::Run(absl::forward<Op>(op));
-      case 17:
-        return PickCase<Op, 17, EndIndex>::Run(absl::forward<Op>(op));
-      case 18:
-        return PickCase<Op, 18, EndIndex>::Run(absl::forward<Op>(op));
-      case 19:
-        return PickCase<Op, 19, EndIndex>::Run(absl::forward<Op>(op));
-      case 20:
-        return PickCase<Op, 20, EndIndex>::Run(absl::forward<Op>(op));
-      case 21:
-        return PickCase<Op, 21, EndIndex>::Run(absl::forward<Op>(op));
-      case 22:
-        return PickCase<Op, 22, EndIndex>::Run(absl::forward<Op>(op));
-      case 23:
-        return PickCase<Op, 23, EndIndex>::Run(absl::forward<Op>(op));
-      case 24:
-        return PickCase<Op, 24, EndIndex>::Run(absl::forward<Op>(op));
-      case 25:
-        return PickCase<Op, 25, EndIndex>::Run(absl::forward<Op>(op));
-      case 26:
-        return PickCase<Op, 26, EndIndex>::Run(absl::forward<Op>(op));
-      case 27:
-        return PickCase<Op, 27, EndIndex>::Run(absl::forward<Op>(op));
-      case 28:
-        return PickCase<Op, 28, EndIndex>::Run(absl::forward<Op>(op));
-      case 29:
-        return PickCase<Op, 29, EndIndex>::Run(absl::forward<Op>(op));
-      case 30:
-        return PickCase<Op, 30, EndIndex>::Run(absl::forward<Op>(op));
-      case 31:
-        return PickCase<Op, 31, EndIndex>::Run(absl::forward<Op>(op));
-      case 32:
-        return PickCase<Op, 32, EndIndex>::Run(absl::forward<Op>(op));
-      default:
-        ABSL_ASSERT(i == variant_npos);
-        return absl::base_internal::invoke(absl::forward<Op>(op), NPos());
-    }
-  }
-};
-
-template <std::size_t... EndIndices>
-struct VisitIndicesFallback {
-  template <class Op, class... SizeT>
-  static VisitIndicesResultT<Op, SizeT...> Run(Op&& op, SizeT... indices) {
-    return AccessSimpleArray(
-        MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op,
-                             index_sequence<(EndIndices + 1)...>,
-                             index_sequence<>>::Run(),
-        (indices + 1)...)(absl::forward<Op>(op));
-  }
-};
-
-// Take an N-dimensional series of indices and convert them into a single index
-// without loss of information. The purpose of this is to be able to convert an
-// N-ary visit operation into a single switch statement.
-template <std::size_t...>
-struct FlattenIndices;
-
-template <std::size_t HeadSize, std::size_t... TailSize>
-struct FlattenIndices<HeadSize, TailSize...> {
-  template<class... SizeType>
-  static constexpr std::size_t Run(std::size_t head, SizeType... tail) {
-    return head + HeadSize * FlattenIndices<TailSize...>::Run(tail...);
-  }
-};
-
-template <>
-struct FlattenIndices<> {
-  static constexpr std::size_t Run() { return 0; }
-};
-
-// Take a single "flattened" index (flattened by FlattenIndices) and determine
-// the value of the index of one of the logically represented dimensions.
-template <std::size_t I, std::size_t IndexToGet, std::size_t HeadSize,
-          std::size_t... TailSize>
-struct UnflattenIndex {
-  static constexpr std::size_t value =
-      UnflattenIndex<I / HeadSize, IndexToGet - 1, TailSize...>::value;
-};
-
-template <std::size_t I, std::size_t HeadSize, std::size_t... TailSize>
-struct UnflattenIndex<I, 0, HeadSize, TailSize...> {
-  static constexpr std::size_t value = (I % HeadSize);
-};
-
-// The backend for converting an N-ary visit operation into a unary visit.
-template <class IndexSequence, std::size_t... EndIndices>
-struct VisitIndicesVariadicImpl;
-
-template <std::size_t... N, std::size_t... EndIndices>
-struct VisitIndicesVariadicImpl<absl::index_sequence<N...>, EndIndices...> {
-  // A type that can take an N-ary function object and converts it to a unary
-  // function object that takes a single, flattened index, and "unflattens" it
-  // into its individual dimensions when forwarding to the wrapped object.
-  template <class Op>
-  struct FlattenedOp {
-    template <std::size_t I>
-    VisitIndicesResultT<Op, decltype(EndIndices)...> operator()(
-        SizeT<I> /*index*/) && {
-      return base_internal::invoke(
-          absl::forward<Op>(op),
-          SizeT<UnflattenIndex<I, N, (EndIndices + 1)...>::value -
-                std::size_t{1}>()...);
-    }
-
-    Op&& op;
-  };
-
-  template <class Op, class... SizeType>
-  static VisitIndicesResultT<Op, decltype(EndIndices)...> Run(
-      Op&& op, SizeType... i) {
-    return VisitIndicesSwitch<NumCasesOfSwitch<EndIndices...>::value>::Run(
-        FlattenedOp<Op>{absl::forward<Op>(op)},
-        FlattenIndices<(EndIndices + std::size_t{1})...>::Run(
-            (i + std::size_t{1})...));
-  }
-};
-
-template <std::size_t... EndIndices>
-struct VisitIndicesVariadic
-    : VisitIndicesVariadicImpl<absl::make_index_sequence<sizeof...(EndIndices)>,
-                               EndIndices...> {};
-
-// This implementation will flatten N-ary visit operations into a single switch
-// statement when the number of cases would be less than our maximum specified
-// switch-statement size.
-// TODO(calabrese)
-//   Based on benchmarks, determine whether the function table approach actually
-//   does optimize better than a chain of switch statements and possibly update
-//   the implementation accordingly. Also consider increasing the maximum switch
-//   size.
-template <std::size_t... EndIndices>
-struct VisitIndices
-    : absl::conditional_t<(NumCasesOfSwitch<EndIndices...>::value <=
-                           MaxUnrolledVisitCases),
-                          VisitIndicesVariadic<EndIndices...>,
-                          VisitIndicesFallback<EndIndices...>> {};
-
-template <std::size_t EndIndex>
-struct VisitIndices<EndIndex>
-    : absl::conditional_t<(EndIndex <= MaxUnrolledVisitCases),
-                          VisitIndicesSwitch<EndIndex>,
-                          VisitIndicesFallback<EndIndex>> {};
+            }
+        };
+
+        template<class Op, std::size_t I>
+        struct ReachableSwitchCase
+        {
+            static VisitIndicesResultT<Op, std::size_t> Run(Op&& op)
+            {
+                return absl::base_internal::invoke(absl::forward<Op>(op), SizeT<I>());
+            }
+        };
+
+        // The number 33 is just a guess at a reasonable maximum to our switch. It is
+        // not based on any analysis. The reason it is a power of 2 plus 1 instead of a
+        // power of 2 is because the number was picked to correspond to a power of 2
+        // amount of "normal" alternatives, plus one for the possibility of the user
+        // providing "monostate" in addition to the more natural alternatives.
+        ABSL_INTERNAL_INLINE_CONSTEXPR(std::size_t, MaxUnrolledVisitCases, 33);
+
+        // Note: The default-definition is for unreachable cases.
+        template<bool IsReachable>
+        struct PickCaseImpl
+        {
+            template<class Op, std::size_t I>
+            using Apply = UnreachableSwitchCase;
+        };
+
+        template<>
+        struct PickCaseImpl</*IsReachable =*/true>
+        {
+            template<class Op, std::size_t I>
+            using Apply = ReachableSwitchCase<Op, I>;
+        };
+
+        // Note: This form of dance with template aliases is to make sure that we
+        //       instantiate a number of templates proportional to the number of variant
+        //       alternatives rather than a number of templates proportional to our
+        //       maximum unrolled amount of visitation cases (aliases are effectively
+        //       "free" whereas other template instantiations are costly).
+        template<class Op, std::size_t I, std::size_t EndIndex>
+        using PickCase = typename PickCaseImpl<(I < EndIndex)>::template Apply<Op, I>;
+
+        template<class ReturnType>
+        [[noreturn]] ReturnType TypedThrowBadVariantAccess()
+        {
+            absl::variant_internal::ThrowBadVariantAccess();
+        }
+
+        // Given N variant sizes, determine the number of cases there would need to be
+        // in a single switch-statement that would cover every possibility in the
+        // corresponding N-ary visit operation.
+        template<std::size_t... NumAlternatives>
+        struct NumCasesOfSwitch;
+
+        template<std::size_t HeadNumAlternatives, std::size_t... TailNumAlternatives>
+        struct NumCasesOfSwitch<HeadNumAlternatives, TailNumAlternatives...>
+        {
+            static constexpr std::size_t value =
+                (HeadNumAlternatives + 1) *
+                NumCasesOfSwitch<TailNumAlternatives...>::value;
+        };
+
+        template<>
+        struct NumCasesOfSwitch<>
+        {
+            static constexpr std::size_t value = 1;
+        };
+
+        // A switch statement optimizes better than the table of function pointers.
+        template<std::size_t EndIndex>
+        struct VisitIndicesSwitch
+        {
+            static_assert(EndIndex <= MaxUnrolledVisitCases, "Maximum unrolled switch size exceeded.");
+
+            template<class Op>
+            static VisitIndicesResultT<Op, std::size_t> Run(Op&& op, std::size_t i)
+            {
+                switch (i)
+                {
+                    case 0:
+                        return PickCase<Op, 0, EndIndex>::Run(absl::forward<Op>(op));
+                    case 1:
+                        return PickCase<Op, 1, EndIndex>::Run(absl::forward<Op>(op));
+                    case 2:
+                        return PickCase<Op, 2, EndIndex>::Run(absl::forward<Op>(op));
+                    case 3:
+                        return PickCase<Op, 3, EndIndex>::Run(absl::forward<Op>(op));
+                    case 4:
+                        return PickCase<Op, 4, EndIndex>::Run(absl::forward<Op>(op));
+                    case 5:
+                        return PickCase<Op, 5, EndIndex>::Run(absl::forward<Op>(op));
+                    case 6:
+                        return PickCase<Op, 6, EndIndex>::Run(absl::forward<Op>(op));
+                    case 7:
+                        return PickCase<Op, 7, EndIndex>::Run(absl::forward<Op>(op));
+                    case 8:
+                        return PickCase<Op, 8, EndIndex>::Run(absl::forward<Op>(op));
+                    case 9:
+                        return PickCase<Op, 9, EndIndex>::Run(absl::forward<Op>(op));
+                    case 10:
+                        return PickCase<Op, 10, EndIndex>::Run(absl::forward<Op>(op));
+                    case 11:
+                        return PickCase<Op, 11, EndIndex>::Run(absl::forward<Op>(op));
+                    case 12:
+                        return PickCase<Op, 12, EndIndex>::Run(absl::forward<Op>(op));
+                    case 13:
+                        return PickCase<Op, 13, EndIndex>::Run(absl::forward<Op>(op));
+                    case 14:
+                        return PickCase<Op, 14, EndIndex>::Run(absl::forward<Op>(op));
+                    case 15:
+                        return PickCase<Op, 15, EndIndex>::Run(absl::forward<Op>(op));
+                    case 16:
+                        return PickCase<Op, 16, EndIndex>::Run(absl::forward<Op>(op));
+                    case 17:
+                        return PickCase<Op, 17, EndIndex>::Run(absl::forward<Op>(op));
+                    case 18:
+                        return PickCase<Op, 18, EndIndex>::Run(absl::forward<Op>(op));
+                    case 19:
+                        return PickCase<Op, 19, EndIndex>::Run(absl::forward<Op>(op));
+                    case 20:
+                        return PickCase<Op, 20, EndIndex>::Run(absl::forward<Op>(op));
+                    case 21:
+                        return PickCase<Op, 21, EndIndex>::Run(absl::forward<Op>(op));
+                    case 22:
+                        return PickCase<Op, 22, EndIndex>::Run(absl::forward<Op>(op));
+                    case 23:
+                        return PickCase<Op, 23, EndIndex>::Run(absl::forward<Op>(op));
+                    case 24:
+                        return PickCase<Op, 24, EndIndex>::Run(absl::forward<Op>(op));
+                    case 25:
+                        return PickCase<Op, 25, EndIndex>::Run(absl::forward<Op>(op));
+                    case 26:
+                        return PickCase<Op, 26, EndIndex>::Run(absl::forward<Op>(op));
+                    case 27:
+                        return PickCase<Op, 27, EndIndex>::Run(absl::forward<Op>(op));
+                    case 28:
+                        return PickCase<Op, 28, EndIndex>::Run(absl::forward<Op>(op));
+                    case 29:
+                        return PickCase<Op, 29, EndIndex>::Run(absl::forward<Op>(op));
+                    case 30:
+                        return PickCase<Op, 30, EndIndex>::Run(absl::forward<Op>(op));
+                    case 31:
+                        return PickCase<Op, 31, EndIndex>::Run(absl::forward<Op>(op));
+                    case 32:
+                        return PickCase<Op, 32, EndIndex>::Run(absl::forward<Op>(op));
+                    default:
+                        ABSL_ASSERT(i == variant_npos);
+                        return absl::base_internal::invoke(absl::forward<Op>(op), NPos());
+                }
+            }
+        };
+
+        template<std::size_t... EndIndices>
+        struct VisitIndicesFallback
+        {
+            template<class Op, class... SizeT>
+            static VisitIndicesResultT<Op, SizeT...> Run(Op&& op, SizeT... indices)
+            {
+                return AccessSimpleArray(
+                    MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op, index_sequence<(EndIndices + 1)...>, index_sequence<>>::Run(),
+                    (indices + 1)...
+                )(absl::forward<Op>(op));
+            }
+        };
+
+        // Take an N-dimensional series of indices and convert them into a single index
+        // without loss of information. The purpose of this is to be able to convert an
+        // N-ary visit operation into a single switch statement.
+        template<std::size_t...>
+        struct FlattenIndices;
+
+        template<std::size_t HeadSize, std::size_t... TailSize>
+        struct FlattenIndices<HeadSize, TailSize...>
+        {
+            template<class... SizeType>
+            static constexpr std::size_t Run(std::size_t head, SizeType... tail)
+            {
+                return head + HeadSize * FlattenIndices<TailSize...>::Run(tail...);
+            }
+        };
+
+        template<>
+        struct FlattenIndices<>
+        {
+            static constexpr std::size_t Run()
+            {
+                return 0;
+            }
+        };
+
+        // Take a single "flattened" index (flattened by FlattenIndices) and determine
+        // the value of the index of one of the logically represented dimensions.
+        template<std::size_t I, std::size_t IndexToGet, std::size_t HeadSize, std::size_t... TailSize>
+        struct UnflattenIndex
+        {
+            static constexpr std::size_t value =
+                UnflattenIndex<I / HeadSize, IndexToGet - 1, TailSize...>::value;
+        };
+
+        template<std::size_t I, std::size_t HeadSize, std::size_t... TailSize>
+        struct UnflattenIndex<I, 0, HeadSize, TailSize...>
+        {
+            static constexpr std::size_t value = (I % HeadSize);
+        };
+
+        // The backend for converting an N-ary visit operation into a unary visit.
+        template<class IndexSequence, std::size_t... EndIndices>
+        struct VisitIndicesVariadicImpl;
+
+        template<std::size_t... N, std::size_t... EndIndices>
+        struct VisitIndicesVariadicImpl<absl::index_sequence<N...>, EndIndices...>
+        {
+            // A type that can take an N-ary function object and converts it to a unary
+            // function object that takes a single, flattened index, and "unflattens" it
+            // into its individual dimensions when forwarding to the wrapped object.
+            template<class Op>
+            struct FlattenedOp
+            {
+                template<std::size_t I>
+                VisitIndicesResultT<Op, decltype(EndIndices)...> operator()(
+                    SizeT<I> /*index*/
+                ) &&
+                {
+                    return base_internal::invoke(
+                        absl::forward<Op>(op),
+                        SizeT<UnflattenIndex<I, N, (EndIndices + 1)...>::value - std::size_t{1}>()...
+                    );
+                }
+
+                Op&& op;
+            };
+
+            template<class Op, class... SizeType>
+            static VisitIndicesResultT<Op, decltype(EndIndices)...> Run(
+                Op&& op, SizeType... i
+            )
+            {
+                return VisitIndicesSwitch<NumCasesOfSwitch<EndIndices...>::value>::Run(
+                    FlattenedOp<Op>{absl::forward<Op>(op)},
+                    FlattenIndices<(EndIndices + std::size_t{1})...>::Run(
+                        (i + std::size_t{1})...
+                    )
+                );
+            }
+        };
+
+        template<std::size_t... EndIndices>
+        struct VisitIndicesVariadic : VisitIndicesVariadicImpl<absl::make_index_sequence<sizeof...(EndIndices)>, EndIndices...>
+        {
+        };
+
+        // This implementation will flatten N-ary visit operations into a single switch
+        // statement when the number of cases would be less than our maximum specified
+        // switch-statement size.
+        // TODO(calabrese)
+        //   Based on benchmarks, determine whether the function table approach actually
+        //   does optimize better than a chain of switch statements and possibly update
+        //   the implementation accordingly. Also consider increasing the maximum switch
+        //   size.
+        template<std::size_t... EndIndices>
+        struct VisitIndices : absl::conditional_t<(NumCasesOfSwitch<EndIndices...>::value <= MaxUnrolledVisitCases), VisitIndicesVariadic<EndIndices...>, VisitIndicesFallback<EndIndices...>>
+        {
+        };
+
+        template<std::size_t EndIndex>
+        struct VisitIndices<EndIndex> : absl::conditional_t<(EndIndex <= MaxUnrolledVisitCases), VisitIndicesSwitch<EndIndex>, VisitIndicesFallback<EndIndex>>
+        {
+        };
 
 // Suppress bogus warning on MSVC: MSVC complains that the `reinterpret_cast`
 // below is returning the address of a temporary or local object.
@@ -540,430 +585,505 @@ struct VisitIndices<EndIndex>
 #pragma warning(disable : 4172)
 #endif  // _MSC_VER
 
-// TODO(calabrese) std::launder
-// TODO(calabrese) constexpr
-// NOTE: DO NOT REMOVE the `inline` keyword as it is necessary to work around a
-// MSVC bug. See https://github.com/abseil/abseil-cpp/issues/129 for details.
-template <class Self, std::size_t I>
-inline VariantAccessResult<I, Self> AccessUnion(Self&& self, SizeT<I> /*i*/) {
-  return reinterpret_cast<VariantAccessResult<I, Self>>(self);
-}
+        // TODO(calabrese) std::launder
+        // TODO(calabrese) constexpr
+        // NOTE: DO NOT REMOVE the `inline` keyword as it is necessary to work around a
+        // MSVC bug. See https://github.com/abseil/abseil-cpp/issues/129 for details.
+        template<class Self, std::size_t I>
+        inline VariantAccessResult<I, Self> AccessUnion(Self&& self, SizeT<I> /*i*/)
+        {
+            return reinterpret_cast<VariantAccessResult<I, Self>>(self);
+        }
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif  // _MSC_VER
 
-template <class T>
-void DeducedDestroy(T& self) {  // NOLINT
-  self.~T();
-}
-
-// NOTE: This type exists as a single entity for variant and its bases to
-// befriend. It contains helper functionality that manipulates the state of the
-// variant, such as the implementation of things like assignment and emplace
-// operations.
-struct VariantCoreAccess {
-  template <class VariantType>
-  static typename VariantType::Variant& Derived(VariantType& self) {  // NOLINT
-    return static_cast<typename VariantType::Variant&>(self);
-  }
-
-  template <class VariantType>
-  static const typename VariantType::Variant& Derived(
-      const VariantType& self) {  // NOLINT
-    return static_cast<const typename VariantType::Variant&>(self);
-  }
-
-  template <class VariantType>
-  static void Destroy(VariantType& self) {  // NOLINT
-    Derived(self).destroy();
-    self.index_ = absl::variant_npos;
-  }
-
-  template <class Variant>
-  static void SetIndex(Variant& self, std::size_t i) {  // NOLINT
-    self.index_ = i;
-  }
-
-  template <class Variant>
-  static void InitFrom(Variant& self, Variant&& other) {  // NOLINT
-    VisitIndices<absl::variant_size<Variant>::value>::Run(
-        InitFromVisitor<Variant, Variant&&>{&self,
-                                            std::forward<Variant>(other)},
-        other.index());
-    self.index_ = other.index();
-  }
-
-  // Access a variant alternative, assuming the index is correct.
-  template <std::size_t I, class Variant>
-  static VariantAccessResult<I, Variant> Access(Variant&& self) {
-    // This cast instead of invocation of AccessUnion with an rvalue is a
-    // workaround for msvc. Without this there is a runtime failure when dealing
-    // with rvalues.
-    // TODO(calabrese) Reduce test case and find a simpler workaround.
-    return static_cast<VariantAccessResult<I, Variant>>(
-        variant_internal::AccessUnion(self.state_, SizeT<I>()));
-  }
-
-  // Access a variant alternative, throwing if the index is incorrect.
-  template <std::size_t I, class Variant>
-  static VariantAccessResult<I, Variant> CheckedAccess(Variant&& self) {
-    if (ABSL_PREDICT_FALSE(self.index_ != I)) {
-      TypedThrowBadVariantAccess<VariantAccessResult<I, Variant>>();
-    }
-
-    return Access<I>(absl::forward<Variant>(self));
-  }
-
-  // The implementation of the move-assignment operation for a variant.
-  template <class VType>
-  struct MoveAssignVisitor {
-    using DerivedType = typename VType::Variant;
-    template <std::size_t NewIndex>
-    void operator()(SizeT<NewIndex> /*new_i*/) const {
-      if (left->index_ == NewIndex) {
-        Access<NewIndex>(*left) = std::move(Access<NewIndex>(*right));
-      } else {
-        Derived(*left).template emplace<NewIndex>(
-            std::move(Access<NewIndex>(*right)));
-      }
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
-      Destroy(*left);
-    }
-
-    VType* left;
-    VType* right;
-  };
-
-  template <class VType>
-  static MoveAssignVisitor<VType> MakeMoveAssignVisitor(VType* left,
-                                                        VType* other) {
-    return {left, other};
-  }
-
-  // The implementation of the assignment operation for a variant.
-  template <class VType>
-  struct CopyAssignVisitor {
-    using DerivedType = typename VType::Variant;
-    template <std::size_t NewIndex>
-    void operator()(SizeT<NewIndex> /*new_i*/) const {
-      using New =
-          typename absl::variant_alternative<NewIndex, DerivedType>::type;
-
-      if (left->index_ == NewIndex) {
-        Access<NewIndex>(*left) = Access<NewIndex>(*right);
-      } else if (std::is_nothrow_copy_constructible<New>::value ||
-                 !std::is_nothrow_move_constructible<New>::value) {
-        Derived(*left).template emplace<NewIndex>(Access<NewIndex>(*right));
-      } else {
-        Derived(*left) = DerivedType(Derived(*right));
-      }
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
-      Destroy(*left);
-    }
-
-    VType* left;
-    const VType* right;
-  };
-
-  template <class VType>
-  static CopyAssignVisitor<VType> MakeCopyAssignVisitor(VType* left,
-                                                        const VType& other) {
-    return {left, &other};
-  }
-
-  // The implementation of conversion-assignment operations for variant.
-  template <class Left, class QualifiedNew>
-  struct ConversionAssignVisitor {
-    using NewIndex =
-        variant_internal::IndexOfConstructedType<Left, QualifiedNew>;
-
-    void operator()(SizeT<NewIndex::value> /*old_i*/
-                    ) const {
-      Access<NewIndex::value>(*left) = absl::forward<QualifiedNew>(other);
-    }
-
-    template <std::size_t OldIndex>
-    void operator()(SizeT<OldIndex> /*old_i*/
-                    ) const {
-      using New =
-          typename absl::variant_alternative<NewIndex::value, Left>::type;
-      if (std::is_nothrow_constructible<New, QualifiedNew>::value ||
-          !std::is_nothrow_move_constructible<New>::value) {
-        left->template emplace<NewIndex::value>(
-            absl::forward<QualifiedNew>(other));
-      } else {
-        // the standard says "equivalent to
-        // operator=(variant(std::forward<T>(t)))", but we use `emplace` here
-        // because the variant's move assignment operator could be deleted.
-        left->template emplace<NewIndex::value>(
-            New(absl::forward<QualifiedNew>(other)));
-      }
-    }
-
-    Left* left;
-    QualifiedNew&& other;
-  };
-
-  template <class Left, class QualifiedNew>
-  static ConversionAssignVisitor<Left, QualifiedNew>
-  MakeConversionAssignVisitor(Left* left, QualifiedNew&& qual) {
-    return {left, absl::forward<QualifiedNew>(qual)};
-  }
-
-  // Backend for operations for `emplace()` which destructs `*self` then
-  // construct a new alternative with `Args...`.
-  template <std::size_t NewIndex, class Self, class... Args>
-  static typename absl::variant_alternative<NewIndex, Self>::type& Replace(
-      Self* self, Args&&... args) {
-    Destroy(*self);
-    using New = typename absl::variant_alternative<NewIndex, Self>::type;
-    New* const result = ::new (static_cast<void*>(&self->state_))
-        New(absl::forward<Args>(args)...);
-    self->index_ = NewIndex;
-    return *result;
-  }
-
-  template <class LeftVariant, class QualifiedRightVariant>
-  struct InitFromVisitor {
-    template <std::size_t NewIndex>
-    void operator()(SizeT<NewIndex> /*new_i*/) const {
-      using Alternative =
-          typename variant_alternative<NewIndex, LeftVariant>::type;
-      ::new (static_cast<void*>(&left->state_)) Alternative(
-          Access<NewIndex>(std::forward<QualifiedRightVariant>(right)));
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
-      // This space intentionally left blank.
-    }
-    LeftVariant* left;
-    QualifiedRightVariant&& right;
-  };
-};
-
-template <class Expected, class... T>
-struct IndexOfImpl;
-
-template <class Expected>
-struct IndexOfImpl<Expected> {
-  using IndexFromEnd = SizeT<0>;
-  using MatchedIndexFromEnd = IndexFromEnd;
-  using MultipleMatches = std::false_type;
-};
-
-template <class Expected, class Head, class... Tail>
-struct IndexOfImpl<Expected, Head, Tail...> : IndexOfImpl<Expected, Tail...> {
-  using IndexFromEnd =
-      SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
-};
-
-template <class Expected, class... Tail>
-struct IndexOfImpl<Expected, Expected, Tail...>
-    : IndexOfImpl<Expected, Tail...> {
-  using IndexFromEnd =
-      SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
-  using MatchedIndexFromEnd = IndexFromEnd;
-  using MultipleMatches = std::integral_constant<
-      bool, IndexOfImpl<Expected, Tail...>::MatchedIndexFromEnd::value != 0>;
-};
-
-template <class Expected, class... Types>
-struct IndexOfMeta {
-  using Results = IndexOfImpl<Expected, Types...>;
-  static_assert(!Results::MultipleMatches::value,
-                "Attempted to access a variant by specifying a type that "
-                "matches more than one alternative.");
-  static_assert(Results::MatchedIndexFromEnd::value != 0,
-                "Attempted to access a variant by specifying a type that does "
-                "not match any alternative.");
-  using type = SizeT<sizeof...(Types) - Results::MatchedIndexFromEnd::value>;
-};
-
-template <class Expected, class... Types>
-using IndexOf = typename IndexOfMeta<Expected, Types...>::type;
-
-template <class Variant, class T, std::size_t CurrIndex>
-struct UnambiguousIndexOfImpl;
-
-// Terminating case encountered once we've checked all of the alternatives
-template <class T, std::size_t CurrIndex>
-struct UnambiguousIndexOfImpl<variant<>, T, CurrIndex> : SizeT<CurrIndex> {};
-
-// Case where T is not Head
-template <class Head, class... Tail, class T, std::size_t CurrIndex>
-struct UnambiguousIndexOfImpl<variant<Head, Tail...>, T, CurrIndex>
-    : UnambiguousIndexOfImpl<variant<Tail...>, T, CurrIndex + 1>::type {};
-
-// Case where T is Head
-template <class Head, class... Tail, std::size_t CurrIndex>
-struct UnambiguousIndexOfImpl<variant<Head, Tail...>, Head, CurrIndex>
-    : SizeT<UnambiguousIndexOfImpl<variant<Tail...>, Head, 0>::value ==
-                    sizeof...(Tail)
-                ? CurrIndex
-                : CurrIndex + sizeof...(Tail) + 1> {};
-
-template <class Variant, class T>
-struct UnambiguousIndexOf;
-
-struct NoMatch {
-  struct type {};
-};
-
-template <class... Alts, class T>
-struct UnambiguousIndexOf<variant<Alts...>, T>
-    : std::conditional<UnambiguousIndexOfImpl<variant<Alts...>, T, 0>::value !=
-                           sizeof...(Alts),
-                       UnambiguousIndexOfImpl<variant<Alts...>, T, 0>,
-                       NoMatch>::type::type {};
-
-template <class T, std::size_t /*Dummy*/>
-using UnambiguousTypeOfImpl = T;
-
-template <class Variant, class T>
-using UnambiguousTypeOfT =
-    UnambiguousTypeOfImpl<T, UnambiguousIndexOf<Variant, T>::value>;
-
-template <class H, class... T>
-class VariantStateBase;
-
-// This is an implementation of the "imaginary function" that is described in
-// [variant.ctor]
-// It is used in order to determine which alternative to construct during
-// initialization from some type T.
-template <class Variant, std::size_t I = 0>
-struct ImaginaryFun;
-
-template <std::size_t I>
-struct ImaginaryFun<variant<>, I> {
-  static void Run() = delete;
-};
-
-template <class H, class... T, std::size_t I>
-struct ImaginaryFun<variant<H, T...>, I> : ImaginaryFun<variant<T...>, I + 1> {
-  using ImaginaryFun<variant<T...>, I + 1>::Run;
-
-  // NOTE: const& and && are used instead of by-value due to lack of guaranteed
-  // move elision of C++17. This may have other minor differences, but tests
-  // pass.
-  static SizeT<I> Run(const H&, SizeT<I>);
-  static SizeT<I> Run(H&&, SizeT<I>);
-};
-
-// The following metafunctions are used in constructor and assignment
-// constraints.
-template <class Self, class T>
-struct IsNeitherSelfNorInPlace : std::true_type {};
-
-template <class Self>
-struct IsNeitherSelfNorInPlace<Self, Self> : std::false_type {};
-
-template <class Self, class T>
-struct IsNeitherSelfNorInPlace<Self, in_place_type_t<T>> : std::false_type {};
-
-template <class Self, std::size_t I>
-struct IsNeitherSelfNorInPlace<Self, in_place_index_t<I>> : std::false_type {};
-
-template <class Variant, class T, class = void>
-struct ConversionIsPossibleImpl : std::false_type {};
-
-template <class Variant, class T>
-struct ConversionIsPossibleImpl<
-    Variant, T,
-    void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>>
-    : std::true_type {};
-
-template <class Variant, class T>
-struct ConversionIsPossible : ConversionIsPossibleImpl<Variant, T>::type {};
-
-template <class Variant, class T>
-struct IndexOfConstructedType<
-    Variant, T,
-    void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>>
-    : decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {})) {};
-
-template <std::size_t... Is>
-struct ContainsVariantNPos
-    : absl::negation<std::is_same<  // NOLINT
-          absl::integer_sequence<bool, 0 <= Is...>,
-          absl::integer_sequence<bool, Is != absl::variant_npos...>>> {};
-
-template <class Op, class... QualifiedVariants>
-using RawVisitResult =
-    absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
-
-// NOTE: The spec requires that all return-paths yield the same type and is not
-// SFINAE-friendly, so we can deduce the return type by examining the first
-// result. If it's not callable, then we get an error, but are compliant and
-// fast to compile.
-// TODO(calabrese) Possibly rewrite in a way that yields better compile errors
-// at the cost of longer compile-times.
-template <class Op, class... QualifiedVariants>
-struct VisitResultImpl {
-  using type =
-      absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
-};
-
-// Done in two steps intentionally so that we don't cause substitution to fail.
-template <class Op, class... QualifiedVariants>
-using VisitResult = typename VisitResultImpl<Op, QualifiedVariants...>::type;
-
-template <class Op, class... QualifiedVariants>
-struct PerformVisitation {
-  using ReturnType = VisitResult<Op, QualifiedVariants...>;
-
-  template <std::size_t... Is>
-  constexpr ReturnType operator()(SizeT<Is>... indices) const {
-    return Run(typename ContainsVariantNPos<Is...>::type{},
-               absl::index_sequence_for<QualifiedVariants...>(), indices...);
-  }
-
-  template <std::size_t... TupIs, std::size_t... Is>
-  constexpr ReturnType Run(std::false_type /*has_valueless*/,
-                           index_sequence<TupIs...>, SizeT<Is>...) const {
-    static_assert(
-        std::is_same<ReturnType,
-                     absl::result_of_t<Op(VariantAccessResult<
-                                          Is, QualifiedVariants>...)>>::value,
-        "All visitation overloads must have the same return type.");
-    return absl::base_internal::invoke(
-        absl::forward<Op>(op),
-        VariantCoreAccess::Access<Is>(
-            absl::forward<QualifiedVariants>(std::get<TupIs>(variant_tup)))...);
-  }
-
-  template <std::size_t... TupIs, std::size_t... Is>
-  [[noreturn]] ReturnType Run(std::true_type /*has_valueless*/,
-                              index_sequence<TupIs...>, SizeT<Is>...) const {
-    absl::variant_internal::ThrowBadVariantAccess();
-  }
-
-  // TODO(calabrese) Avoid using a tuple, which causes lots of instantiations
-  // Attempts using lambda variadic captures fail on current GCC.
-  std::tuple<QualifiedVariants&&...> variant_tup;
-  Op&& op;
-};
-
-template <class... T>
-union Union;
-
-// We want to allow for variant<> to be trivial. For that, we need the default
-// constructor to be trivial, which means we can't define it ourselves.
-// Instead, we use a non-default constructor that takes NoopConstructorTag
-// that doesn't affect the triviality of the types.
-struct NoopConstructorTag {};
-
-template <std::size_t I>
-struct EmplaceTag {};
-
-template <>
-union Union<> {
-  constexpr explicit Union(NoopConstructorTag) noexcept {}
-};
+        template<class T>
+        void DeducedDestroy(T& self)
+        {  // NOLINT
+            self.~T();
+        }
+
+        // NOTE: This type exists as a single entity for variant and its bases to
+        // befriend. It contains helper functionality that manipulates the state of the
+        // variant, such as the implementation of things like assignment and emplace
+        // operations.
+        struct VariantCoreAccess
+        {
+            template<class VariantType>
+            static typename VariantType::Variant& Derived(VariantType& self)
+            {  // NOLINT
+                return static_cast<typename VariantType::Variant&>(self);
+            }
+
+            template<class VariantType>
+            static const typename VariantType::Variant& Derived(
+                const VariantType& self
+            )
+            {  // NOLINT
+                return static_cast<const typename VariantType::Variant&>(self);
+            }
+
+            template<class VariantType>
+            static void Destroy(VariantType& self)
+            {  // NOLINT
+                Derived(self).destroy();
+                self.index_ = absl::variant_npos;
+            }
+
+            template<class Variant>
+            static void SetIndex(Variant& self, std::size_t i)
+            {  // NOLINT
+                self.index_ = i;
+            }
+
+            template<class Variant>
+            static void InitFrom(Variant& self, Variant&& other)
+            {  // NOLINT
+                VisitIndices<absl::variant_size<Variant>::value>::Run(
+                    InitFromVisitor<Variant, Variant&&>{&self, std::forward<Variant>(other)},
+                    other.index()
+                );
+                self.index_ = other.index();
+            }
+
+            // Access a variant alternative, assuming the index is correct.
+            template<std::size_t I, class Variant>
+            static VariantAccessResult<I, Variant> Access(Variant&& self)
+            {
+                // This cast instead of invocation of AccessUnion with an rvalue is a
+                // workaround for msvc. Without this there is a runtime failure when dealing
+                // with rvalues.
+                // TODO(calabrese) Reduce test case and find a simpler workaround.
+                return static_cast<VariantAccessResult<I, Variant>>(
+                    variant_internal::AccessUnion(self.state_, SizeT<I>())
+                );
+            }
+
+            // Access a variant alternative, throwing if the index is incorrect.
+            template<std::size_t I, class Variant>
+            static VariantAccessResult<I, Variant> CheckedAccess(Variant&& self)
+            {
+                if (ABSL_PREDICT_FALSE(self.index_ != I))
+                {
+                    TypedThrowBadVariantAccess<VariantAccessResult<I, Variant>>();
+                }
+
+                return Access<I>(absl::forward<Variant>(self));
+            }
+
+            // The implementation of the move-assignment operation for a variant.
+            template<class VType>
+            struct MoveAssignVisitor
+            {
+                using DerivedType = typename VType::Variant;
+                template<std::size_t NewIndex>
+                void operator()(SizeT<NewIndex> /*new_i*/) const
+                {
+                    if (left->index_ == NewIndex)
+                    {
+                        Access<NewIndex>(*left) = std::move(Access<NewIndex>(*right));
+                    }
+                    else
+                    {
+                        Derived(*left).template emplace<NewIndex>(
+                            std::move(Access<NewIndex>(*right))
+                        );
+                    }
+                }
+
+                void operator()(SizeT<absl::variant_npos> /*new_i*/) const
+                {
+                    Destroy(*left);
+                }
+
+                VType* left;
+                VType* right;
+            };
+
+            template<class VType>
+            static MoveAssignVisitor<VType> MakeMoveAssignVisitor(VType* left, VType* other)
+            {
+                return {left, other};
+            }
+
+            // The implementation of the assignment operation for a variant.
+            template<class VType>
+            struct CopyAssignVisitor
+            {
+                using DerivedType = typename VType::Variant;
+                template<std::size_t NewIndex>
+                void operator()(SizeT<NewIndex> /*new_i*/) const
+                {
+                    using New =
+                        typename absl::variant_alternative<NewIndex, DerivedType>::type;
+
+                    if (left->index_ == NewIndex)
+                    {
+                        Access<NewIndex>(*left) = Access<NewIndex>(*right);
+                    }
+                    else if (std::is_nothrow_copy_constructible<New>::value || !std::is_nothrow_move_constructible<New>::value)
+                    {
+                        Derived(*left).template emplace<NewIndex>(Access<NewIndex>(*right));
+                    }
+                    else
+                    {
+                        Derived(*left) = DerivedType(Derived(*right));
+                    }
+                }
+
+                void operator()(SizeT<absl::variant_npos> /*new_i*/) const
+                {
+                    Destroy(*left);
+                }
+
+                VType* left;
+                const VType* right;
+            };
+
+            template<class VType>
+            static CopyAssignVisitor<VType> MakeCopyAssignVisitor(VType* left, const VType& other)
+            {
+                return {left, &other};
+            }
+
+            // The implementation of conversion-assignment operations for variant.
+            template<class Left, class QualifiedNew>
+            struct ConversionAssignVisitor
+            {
+                using NewIndex =
+                    variant_internal::IndexOfConstructedType<Left, QualifiedNew>;
+
+                void operator()(SizeT<NewIndex::value> /*old_i*/
+                ) const
+                {
+                    Access<NewIndex::value>(*left) = absl::forward<QualifiedNew>(other);
+                }
+
+                template<std::size_t OldIndex>
+                void operator()(SizeT<OldIndex> /*old_i*/
+                ) const
+                {
+                    using New =
+                        typename absl::variant_alternative<NewIndex::value, Left>::type;
+                    if (std::is_nothrow_constructible<New, QualifiedNew>::value ||
+                        !std::is_nothrow_move_constructible<New>::value)
+                    {
+                        left->template emplace<NewIndex::value>(
+                            absl::forward<QualifiedNew>(other)
+                        );
+                    }
+                    else
+                    {
+                        // the standard says "equivalent to
+                        // operator=(variant(std::forward<T>(t)))", but we use `emplace` here
+                        // because the variant's move assignment operator could be deleted.
+                        left->template emplace<NewIndex::value>(
+                            New(absl::forward<QualifiedNew>(other))
+                        );
+                    }
+                }
+
+                Left* left;
+                QualifiedNew&& other;
+            };
+
+            template<class Left, class QualifiedNew>
+            static ConversionAssignVisitor<Left, QualifiedNew>
+                MakeConversionAssignVisitor(Left* left, QualifiedNew&& qual)
+            {
+                return {left, absl::forward<QualifiedNew>(qual)};
+            }
+
+            // Backend for operations for `emplace()` which destructs `*self` then
+            // construct a new alternative with `Args...`.
+            template<std::size_t NewIndex, class Self, class... Args>
+            static typename absl::variant_alternative<NewIndex, Self>::type& Replace(
+                Self* self, Args&&... args
+            )
+            {
+                Destroy(*self);
+                using New = typename absl::variant_alternative<NewIndex, Self>::type;
+                New* const result = ::new (static_cast<void*>(&self->state_))
+                    New(absl::forward<Args>(args)...);
+                self->index_ = NewIndex;
+                return *result;
+            }
+
+            template<class LeftVariant, class QualifiedRightVariant>
+            struct InitFromVisitor
+            {
+                template<std::size_t NewIndex>
+                void operator()(SizeT<NewIndex> /*new_i*/) const
+                {
+                    using Alternative =
+                        typename variant_alternative<NewIndex, LeftVariant>::type;
+                    ::new (static_cast<void*>(&left->state_)) Alternative(
+                        Access<NewIndex>(std::forward<QualifiedRightVariant>(right))
+                    );
+                }
+
+                void operator()(SizeT<absl::variant_npos> /*new_i*/) const
+                {
+                    // This space intentionally left blank.
+                }
+                LeftVariant* left;
+                QualifiedRightVariant&& right;
+            };
+        };
+
+        template<class Expected, class... T>
+        struct IndexOfImpl;
+
+        template<class Expected>
+        struct IndexOfImpl<Expected>
+        {
+            using IndexFromEnd = SizeT<0>;
+            using MatchedIndexFromEnd = IndexFromEnd;
+            using MultipleMatches = std::false_type;
+        };
+
+        template<class Expected, class Head, class... Tail>
+        struct IndexOfImpl<Expected, Head, Tail...> : IndexOfImpl<Expected, Tail...>
+        {
+            using IndexFromEnd =
+                SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
+        };
+
+        template<class Expected, class... Tail>
+        struct IndexOfImpl<Expected, Expected, Tail...> : IndexOfImpl<Expected, Tail...>
+        {
+            using IndexFromEnd =
+                SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
+            using MatchedIndexFromEnd = IndexFromEnd;
+            using MultipleMatches = std::integral_constant<
+                bool,
+                IndexOfImpl<Expected, Tail...>::MatchedIndexFromEnd::value != 0>;
+        };
+
+        template<class Expected, class... Types>
+        struct IndexOfMeta
+        {
+            using Results = IndexOfImpl<Expected, Types...>;
+            static_assert(!Results::MultipleMatches::value, "Attempted to access a variant by specifying a type that "
+                                                            "matches more than one alternative.");
+            static_assert(Results::MatchedIndexFromEnd::value != 0, "Attempted to access a variant by specifying a type that does "
+                                                                    "not match any alternative.");
+            using type = SizeT<sizeof...(Types) - Results::MatchedIndexFromEnd::value>;
+        };
+
+        template<class Expected, class... Types>
+        using IndexOf = typename IndexOfMeta<Expected, Types...>::type;
+
+        template<class Variant, class T, std::size_t CurrIndex>
+        struct UnambiguousIndexOfImpl;
+
+        // Terminating case encountered once we've checked all of the alternatives
+        template<class T, std::size_t CurrIndex>
+        struct UnambiguousIndexOfImpl<variant<>, T, CurrIndex> : SizeT<CurrIndex>
+        {
+        };
+
+        // Case where T is not Head
+        template<class Head, class... Tail, class T, std::size_t CurrIndex>
+        struct UnambiguousIndexOfImpl<variant<Head, Tail...>, T, CurrIndex> : UnambiguousIndexOfImpl<variant<Tail...>, T, CurrIndex + 1>::type
+        {
+        };
+
+        // Case where T is Head
+        template<class Head, class... Tail, std::size_t CurrIndex>
+        struct UnambiguousIndexOfImpl<variant<Head, Tail...>, Head, CurrIndex> : SizeT<UnambiguousIndexOfImpl<variant<Tail...>, Head, 0>::value == sizeof...(Tail) ? CurrIndex : CurrIndex + sizeof...(Tail) + 1>
+        {
+        };
+
+        template<class Variant, class T>
+        struct UnambiguousIndexOf;
+
+        struct NoMatch
+        {
+            struct type
+            {
+            };
+        };
+
+        template<class... Alts, class T>
+        struct UnambiguousIndexOf<variant<Alts...>, T> : std::conditional<UnambiguousIndexOfImpl<variant<Alts...>, T, 0>::value != sizeof...(Alts), UnambiguousIndexOfImpl<variant<Alts...>, T, 0>, NoMatch>::type::type
+        {
+        };
+
+        template<class T, std::size_t /*Dummy*/>
+        using UnambiguousTypeOfImpl = T;
+
+        template<class Variant, class T>
+        using UnambiguousTypeOfT =
+            UnambiguousTypeOfImpl<T, UnambiguousIndexOf<Variant, T>::value>;
+
+        template<class H, class... T>
+        class VariantStateBase;
+
+        // This is an implementation of the "imaginary function" that is described in
+        // [variant.ctor]
+        // It is used in order to determine which alternative to construct during
+        // initialization from some type T.
+        template<class Variant, std::size_t I = 0>
+        struct ImaginaryFun;
+
+        template<std::size_t I>
+        struct ImaginaryFun<variant<>, I>
+        {
+            static void Run() = delete;
+        };
+
+        template<class H, class... T, std::size_t I>
+        struct ImaginaryFun<variant<H, T...>, I> : ImaginaryFun<variant<T...>, I + 1>
+        {
+            using ImaginaryFun<variant<T...>, I + 1>::Run;
+
+            // NOTE: const& and && are used instead of by-value due to lack of guaranteed
+            // move elision of C++17. This may have other minor differences, but tests
+            // pass.
+            static SizeT<I> Run(const H&, SizeT<I>);
+            static SizeT<I> Run(H&&, SizeT<I>);
+        };
+
+        // The following metafunctions are used in constructor and assignment
+        // constraints.
+        template<class Self, class T>
+        struct IsNeitherSelfNorInPlace : std::true_type
+        {
+        };
+
+        template<class Self>
+        struct IsNeitherSelfNorInPlace<Self, Self> : std::false_type
+        {
+        };
+
+        template<class Self, class T>
+        struct IsNeitherSelfNorInPlace<Self, in_place_type_t<T>> : std::false_type
+        {
+        };
+
+        template<class Self, std::size_t I>
+        struct IsNeitherSelfNorInPlace<Self, in_place_index_t<I>> : std::false_type
+        {
+        };
+
+        template<class Variant, class T, class = void>
+        struct ConversionIsPossibleImpl : std::false_type
+        {
+        };
+
+        template<class Variant, class T>
+        struct ConversionIsPossibleImpl<
+            Variant,
+            T,
+            void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>> : std::true_type
+        {
+        };
+
+        template<class Variant, class T>
+        struct ConversionIsPossible : ConversionIsPossibleImpl<Variant, T>::type
+        {
+        };
+
+        template<class Variant, class T>
+        struct IndexOfConstructedType<
+            Variant,
+            T,
+            void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))>> : decltype(ImaginaryFun<Variant>::Run(std::declval<T>(), {}))
+        {
+        };
+
+        template<std::size_t... Is>
+        struct ContainsVariantNPos : absl::negation<std::is_same<  // NOLINT
+                                         absl::integer_sequence<bool, 0 <= Is...>,
+                                         absl::integer_sequence<bool, Is != absl::variant_npos...>>>
+        {
+        };
+
+        template<class Op, class... QualifiedVariants>
+        using RawVisitResult =
+            absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
+
+        // NOTE: The spec requires that all return-paths yield the same type and is not
+        // SFINAE-friendly, so we can deduce the return type by examining the first
+        // result. If it's not callable, then we get an error, but are compliant and
+        // fast to compile.
+        // TODO(calabrese) Possibly rewrite in a way that yields better compile errors
+        // at the cost of longer compile-times.
+        template<class Op, class... QualifiedVariants>
+        struct VisitResultImpl
+        {
+            using type =
+                absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
+        };
+
+        // Done in two steps intentionally so that we don't cause substitution to fail.
+        template<class Op, class... QualifiedVariants>
+        using VisitResult = typename VisitResultImpl<Op, QualifiedVariants...>::type;
+
+        template<class Op, class... QualifiedVariants>
+        struct PerformVisitation
+        {
+            using ReturnType = VisitResult<Op, QualifiedVariants...>;
+
+            template<std::size_t... Is>
+            constexpr ReturnType operator()(SizeT<Is>... indices) const
+            {
+                return Run(typename ContainsVariantNPos<Is...>::type{}, absl::index_sequence_for<QualifiedVariants...>(), indices...);
+            }
+
+            template<std::size_t... TupIs, std::size_t... Is>
+            constexpr ReturnType Run(std::false_type /*has_valueless*/, index_sequence<TupIs...>, SizeT<Is>...) const
+            {
+                static_assert(
+                    std::is_same<ReturnType, absl::result_of_t<Op(VariantAccessResult<Is, QualifiedVariants>...)>>::value,
+                    "All visitation overloads must have the same return type."
+                );
+                return absl::base_internal::invoke(
+                    absl::forward<Op>(op),
+                    VariantCoreAccess::Access<Is>(
+                        absl::forward<QualifiedVariants>(std::get<TupIs>(variant_tup))
+                    )...
+                );
+            }
+
+            template<std::size_t... TupIs, std::size_t... Is>
+            [[noreturn]] ReturnType Run(std::true_type /*has_valueless*/, index_sequence<TupIs...>, SizeT<Is>...) const
+            {
+                absl::variant_internal::ThrowBadVariantAccess();
+            }
+
+            // TODO(calabrese) Avoid using a tuple, which causes lots of instantiations
+            // Attempts using lambda variadic captures fail on current GCC.
+            std::tuple<QualifiedVariants&&...> variant_tup;
+            Op&& op;
+        };
+
+        template<class... T>
+        union Union;
+
+        // We want to allow for variant<> to be trivial. For that, we need the default
+        // constructor to be trivial, which means we can't define it ourselves.
+        // Instead, we use a non-default constructor that takes NoopConstructorTag
+        // that doesn't affect the triviality of the types.
+        struct NoopConstructorTag
+        {
+        };
+
+        template<std::size_t I>
+        struct EmplaceTag
+        {
+        };
+
+        template<>
+        union Union<>
+        {
+            constexpr explicit Union(NoopConstructorTag) noexcept
+            {
+            }
+        };
 
 // Suppress bogus warning on MSVC: MSVC complains that Union<T...> has a defined
 // deleted destructor from the `std::is_destructible` check below.
@@ -972,674 +1092,770 @@ union Union<> {
 #pragma warning(disable : 4624)
 #endif  // _MSC_VER
 
-template <class Head, class... Tail>
-union Union<Head, Tail...> {
-  using TailUnion = Union<Tail...>;
-
-  explicit constexpr Union(NoopConstructorTag /*tag*/) noexcept
-      : tail(NoopConstructorTag()) {}
-
-  template <class... P>
-  explicit constexpr Union(EmplaceTag<0>, P&&... args)
-      : head(absl::forward<P>(args)...) {}
-
-  template <std::size_t I, class... P>
-  explicit constexpr Union(EmplaceTag<I>, P&&... args)
-      : tail(EmplaceTag<I - 1>{}, absl::forward<P>(args)...) {}
-
-  Head head;
-  TailUnion tail;
-};
+        template<class Head, class... Tail>
+        union Union<Head, Tail...>
+        {
+            using TailUnion = Union<Tail...>;
+
+            explicit constexpr Union(NoopConstructorTag /*tag*/) noexcept
+                :
+                tail(NoopConstructorTag())
+            {
+            }
+
+            template<class... P>
+            explicit constexpr Union(EmplaceTag<0>, P&&... args) :
+                head(absl::forward<P>(args)...)
+            {
+            }
+
+            template<std::size_t I, class... P>
+            explicit constexpr Union(EmplaceTag<I>, P&&... args) :
+                tail(EmplaceTag<I - 1>{}, absl::forward<P>(args)...)
+            {
+            }
+
+            Head head;
+            TailUnion tail;
+        };
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif  // _MSC_VER
 
-// TODO(calabrese) Just contain a Union in this union (certain configs fail).
-template <class... T>
-union DestructibleUnionImpl;
-
-template <>
-union DestructibleUnionImpl<> {
-  constexpr explicit DestructibleUnionImpl(NoopConstructorTag) noexcept {}
-};
-
-template <class Head, class... Tail>
-union DestructibleUnionImpl<Head, Tail...> {
-  using TailUnion = DestructibleUnionImpl<Tail...>;
-
-  explicit constexpr DestructibleUnionImpl(NoopConstructorTag /*tag*/) noexcept
-      : tail(NoopConstructorTag()) {}
-
-  template <class... P>
-  explicit constexpr DestructibleUnionImpl(EmplaceTag<0>, P&&... args)
-      : head(absl::forward<P>(args)...) {}
-
-  template <std::size_t I, class... P>
-  explicit constexpr DestructibleUnionImpl(EmplaceTag<I>, P&&... args)
-      : tail(EmplaceTag<I - 1>{}, absl::forward<P>(args)...) {}
-
-  ~DestructibleUnionImpl() {}
-
-  Head head;
-  TailUnion tail;
-};
-
-// This union type is destructible even if one or more T are not trivially
-// destructible. In the case that all T are trivially destructible, then so is
-// this resultant type.
-template <class... T>
-using DestructibleUnion =
-    absl::conditional_t<std::is_destructible<Union<T...>>::value, Union<T...>,
-                        DestructibleUnionImpl<T...>>;
-
-// Deepest base, containing the actual union and the discriminator
-template <class H, class... T>
-class VariantStateBase {
- protected:
-  using Variant = variant<H, T...>;
-
-  template <class LazyH = H,
-            class ConstructibleH = absl::enable_if_t<
-                std::is_default_constructible<LazyH>::value, LazyH>>
-  constexpr VariantStateBase() noexcept(
-      std::is_nothrow_default_constructible<ConstructibleH>::value)
-      : state_(EmplaceTag<0>()), index_(0) {}
-
-  template <std::size_t I, class... P>
-  explicit constexpr VariantStateBase(EmplaceTag<I> tag, P&&... args)
-      : state_(tag, absl::forward<P>(args)...), index_(I) {}
-
-  explicit constexpr VariantStateBase(NoopConstructorTag)
-      : state_(NoopConstructorTag()), index_(variant_npos) {}
-
-  void destroy() {}  // Does nothing (shadowed in child if non-trivial)
-
-  DestructibleUnion<H, T...> state_;
-  std::size_t index_;
-};
-
-using absl::internal::identity;
-
-// OverloadSet::Overload() is a unary function which is overloaded to
-// take any of the element types of the variant, by reference-to-const.
-// The return type of the overload on T is identity<T>, so that you
-// can statically determine which overload was called.
-//
-// Overload() is not defined, so it can only be called in unevaluated
-// contexts.
-template <typename... Ts>
-struct OverloadSet;
-
-template <typename T, typename... Ts>
-struct OverloadSet<T, Ts...> : OverloadSet<Ts...> {
-  using Base = OverloadSet<Ts...>;
-  static identity<T> Overload(const T&);
-  using Base::Overload;
-};
-
-template <>
-struct OverloadSet<> {
-  // For any case not handled above.
-  static void Overload(...);
-};
-
-template <class T>
-using LessThanResult = decltype(std::declval<T>() < std::declval<T>());
-
-template <class T>
-using GreaterThanResult = decltype(std::declval<T>() > std::declval<T>());
-
-template <class T>
-using LessThanOrEqualResult = decltype(std::declval<T>() <= std::declval<T>());
-
-template <class T>
-using GreaterThanOrEqualResult =
-    decltype(std::declval<T>() >= std::declval<T>());
-
-template <class T>
-using EqualResult = decltype(std::declval<T>() == std::declval<T>());
-
-template <class T>
-using NotEqualResult = decltype(std::declval<T>() != std::declval<T>());
-
-using type_traits_internal::is_detected_convertible;
-
-template <class... T>
-using RequireAllHaveEqualT = absl::enable_if_t<
-    absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value,
-    bool>;
-
-template <class... T>
-using RequireAllHaveNotEqualT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, NotEqualResult, T>...>::value,
-                      bool>;
-
-template <class... T>
-using RequireAllHaveLessThanT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, LessThanResult, T>...>::value,
-                      bool>;
-
-template <class... T>
-using RequireAllHaveLessThanOrEqualT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, LessThanOrEqualResult, T>...>::value,
-                      bool>;
-
-template <class... T>
-using RequireAllHaveGreaterThanOrEqualT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, GreaterThanOrEqualResult, T>...>::value,
-                      bool>;
-
-template <class... T>
-using RequireAllHaveGreaterThanT =
-    absl::enable_if_t<absl::conjunction<is_detected_convertible<
-                          bool, GreaterThanResult, T>...>::value,
-                      bool>;
-
-// Helper template containing implementations details of variant that can't go
-// in the private section. For convenience, this takes the variant type as a
-// single template parameter.
-template <typename T>
-struct VariantHelper;
-
-template <typename... Ts>
-struct VariantHelper<variant<Ts...>> {
-  // Type metafunction which returns the element type selected if
-  // OverloadSet::Overload() is well-formed when called with argument type U.
-  template <typename U>
-  using BestMatch = decltype(
-      variant_internal::OverloadSet<Ts...>::Overload(std::declval<U>()));
-
-  // Type metafunction which returns true if OverloadSet::Overload() is
-  // well-formed when called with argument type U.
-  // CanAccept can't be just an alias because there is a MSVC bug on parameter
-  // pack expansion involving decltype.
-  template <typename U>
-  struct CanAccept :
-      std::integral_constant<bool, !std::is_void<BestMatch<U>>::value> {};
-
-  // Type metafunction which returns true if Other is an instantiation of
-  // variant, and variants's converting constructor from Other will be
-  // well-formed. We will use this to remove constructors that would be
-  // ill-formed from the overload set.
-  template <typename Other>
-  struct CanConvertFrom;
-
-  template <typename... Us>
-  struct CanConvertFrom<variant<Us...>>
-      : public absl::conjunction<CanAccept<Us>...> {};
-};
-
-// A type with nontrivial copy ctor and trivial move ctor.
-struct TrivialMoveOnly {
-  TrivialMoveOnly(TrivialMoveOnly&&) = default;
-};
-
-// Trait class to detect whether a type is trivially move constructible.
-// A union's defaulted copy/move constructor is deleted if any variant member's
-// copy/move constructor is nontrivial.
-template <typename T>
-struct IsTriviallyMoveConstructible:
-  std::is_move_constructible<Union<T, TrivialMoveOnly>> {};
-
-// To guarantee triviality of all special-member functions that can be trivial,
-// we use a chain of conditional bases for each one.
-// The order of inheritance of bases from child to base are logically:
-//
-// variant
-// VariantCopyAssignBase
-// VariantMoveAssignBase
-// VariantCopyBase
-// VariantMoveBase
-// VariantStateBaseDestructor
-// VariantStateBase
-//
-// Note that there is a separate branch at each base that is dependent on
-// whether or not that corresponding special-member-function can be trivial in
-// the resultant variant type.
-
-template <class... T>
-class VariantStateBaseDestructorNontrivial;
-
-template <class... T>
-class VariantMoveBaseNontrivial;
-
-template <class... T>
-class VariantCopyBaseNontrivial;
-
-template <class... T>
-class VariantMoveAssignBaseNontrivial;
-
-template <class... T>
-class VariantCopyAssignBaseNontrivial;
-
-// Base that is dependent on whether or not the destructor can be trivial.
-template <class... T>
-using VariantStateBaseDestructor =
-    absl::conditional_t<std::is_destructible<Union<T...>>::value,
-                        VariantStateBase<T...>,
-                        VariantStateBaseDestructorNontrivial<T...>>;
-
-// Base that is dependent on whether or not the move-constructor can be
-// implicitly generated by the compiler (trivial or deleted).
-// Previously we were using `std::is_move_constructible<Union<T...>>` to check
-// whether all Ts have trivial move constructor, but it ran into a GCC bug:
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84866
-// So we have to use a different approach (i.e. `HasTrivialMoveConstructor`) to
-// work around the bug.
-template <class... T>
-using VariantMoveBase = absl::conditional_t<
-    absl::disjunction<
-        absl::negation<absl::conjunction<std::is_move_constructible<T>...>>,
-        absl::conjunction<IsTriviallyMoveConstructible<T>...>>::value,
-    VariantStateBaseDestructor<T...>, VariantMoveBaseNontrivial<T...>>;
-
-// Base that is dependent on whether or not the copy-constructor can be trivial.
-template <class... T>
-using VariantCopyBase = absl::conditional_t<
-    absl::disjunction<
-        absl::negation<absl::conjunction<std::is_copy_constructible<T>...>>,
-        std::is_copy_constructible<Union<T...>>>::value,
-    VariantMoveBase<T...>, VariantCopyBaseNontrivial<T...>>;
-
-// Base that is dependent on whether or not the move-assign can be trivial.
-template <class... T>
-using VariantMoveAssignBase = absl::conditional_t<
-    absl::disjunction<
-        absl::conjunction<absl::is_move_assignable<Union<T...>>,
-                          std::is_move_constructible<Union<T...>>,
-                          std::is_destructible<Union<T...>>>,
-        absl::negation<absl::conjunction<std::is_move_constructible<T>...,
-                                         // Note: We're not qualifying this with
-                                         // absl:: because it doesn't compile
-                                         // under MSVC.
-                                         is_move_assignable<T>...>>>::value,
-    VariantCopyBase<T...>, VariantMoveAssignBaseNontrivial<T...>>;
-
-// Base that is dependent on whether or not the copy-assign can be trivial.
-template <class... T>
-using VariantCopyAssignBase = absl::conditional_t<
-    absl::disjunction<
-        absl::conjunction<absl::is_copy_assignable<Union<T...>>,
-                          std::is_copy_constructible<Union<T...>>,
-                          std::is_destructible<Union<T...>>>,
-        absl::negation<absl::conjunction<std::is_copy_constructible<T>...,
-                                         // Note: We're not qualifying this with
-                                         // absl:: because it doesn't compile
-                                         // under MSVC.
-                                         is_copy_assignable<T>...>>>::value,
-    VariantMoveAssignBase<T...>, VariantCopyAssignBaseNontrivial<T...>>;
-
-template <class... T>
-using VariantBase = VariantCopyAssignBase<T...>;
-
-template <class... T>
-class VariantStateBaseDestructorNontrivial : protected VariantStateBase<T...> {
- private:
-  using Base = VariantStateBase<T...>;
-
- protected:
-  using Base::Base;
-
-  VariantStateBaseDestructorNontrivial() = default;
-  VariantStateBaseDestructorNontrivial(VariantStateBaseDestructorNontrivial&&) =
-      default;
-  VariantStateBaseDestructorNontrivial(
-      const VariantStateBaseDestructorNontrivial&) = default;
-  VariantStateBaseDestructorNontrivial& operator=(
-      VariantStateBaseDestructorNontrivial&&) = default;
-  VariantStateBaseDestructorNontrivial& operator=(
-      const VariantStateBaseDestructorNontrivial&) = default;
-
-  struct Destroyer {
-    template <std::size_t I>
-    void operator()(SizeT<I> i) const {
-      using Alternative =
-          typename absl::variant_alternative<I, variant<T...>>::type;
-      variant_internal::AccessUnion(self->state_, i).~Alternative();
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*i*/) const {
-      // This space intentionally left blank
-    }
-
-    VariantStateBaseDestructorNontrivial* self;
-  };
-
-  void destroy() { VisitIndices<sizeof...(T)>::Run(Destroyer{this}, index_); }
-
-  ~VariantStateBaseDestructorNontrivial() { destroy(); }
-
- protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-template <class... T>
-class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...> {
- private:
-  using Base = VariantStateBaseDestructor<T...>;
-
- protected:
-  using Base::Base;
-
-  struct Construct {
-    template <std::size_t I>
-    void operator()(SizeT<I> i) const {
-      using Alternative =
-          typename absl::variant_alternative<I, variant<T...>>::type;
-      ::new (static_cast<void*>(&self->state_)) Alternative(
-          variant_internal::AccessUnion(absl::move(other->state_), i));
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*i*/) const {}
-
-    VariantMoveBaseNontrivial* self;
-    VariantMoveBaseNontrivial* other;
-  };
-
-  VariantMoveBaseNontrivial() = default;
-  VariantMoveBaseNontrivial(VariantMoveBaseNontrivial&& other) noexcept(
-      absl::conjunction<std::is_nothrow_move_constructible<T>...>::value)
-      : Base(NoopConstructorTag()) {
-    VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
-    index_ = other.index_;
-  }
-
-  VariantMoveBaseNontrivial(VariantMoveBaseNontrivial const&) = default;
-
-  VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial&&) = default;
-  VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial const&) =
-      default;
-
- protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-template <class... T>
-class VariantCopyBaseNontrivial : protected VariantMoveBase<T...> {
- private:
-  using Base = VariantMoveBase<T...>;
-
- protected:
-  using Base::Base;
-
-  VariantCopyBaseNontrivial() = default;
-  VariantCopyBaseNontrivial(VariantCopyBaseNontrivial&&) = default;
-
-  struct Construct {
-    template <std::size_t I>
-    void operator()(SizeT<I> i) const {
-      using Alternative =
-          typename absl::variant_alternative<I, variant<T...>>::type;
-      ::new (static_cast<void*>(&self->state_))
-          Alternative(variant_internal::AccessUnion(other->state_, i));
-    }
-
-    void operator()(SizeT<absl::variant_npos> /*i*/) const {}
-
-    VariantCopyBaseNontrivial* self;
-    const VariantCopyBaseNontrivial* other;
-  };
-
-  VariantCopyBaseNontrivial(VariantCopyBaseNontrivial const& other)
-      : Base(NoopConstructorTag()) {
-    VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
-    index_ = other.index_;
-  }
-
-  VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial&&) = default;
-  VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial const&) =
-      default;
-
- protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-template <class... T>
-class VariantMoveAssignBaseNontrivial : protected VariantCopyBase<T...> {
-  friend struct VariantCoreAccess;
-
- private:
-  using Base = VariantCopyBase<T...>;
-
- protected:
-  using Base::Base;
-
-  VariantMoveAssignBaseNontrivial() = default;
-  VariantMoveAssignBaseNontrivial(VariantMoveAssignBaseNontrivial&&) = default;
-  VariantMoveAssignBaseNontrivial(const VariantMoveAssignBaseNontrivial&) =
-      default;
-  VariantMoveAssignBaseNontrivial& operator=(
-      VariantMoveAssignBaseNontrivial const&) = default;
-
-    VariantMoveAssignBaseNontrivial&
-    operator=(VariantMoveAssignBaseNontrivial&& other) noexcept(
-        absl::conjunction<std::is_nothrow_move_constructible<T>...,
-                          std::is_nothrow_move_assignable<T>...>::value) {
-      VisitIndices<sizeof...(T)>::Run(
-          VariantCoreAccess::MakeMoveAssignVisitor(this, &other), other.index_);
-      return *this;
-    }
-
- protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-template <class... T>
-class VariantCopyAssignBaseNontrivial : protected VariantMoveAssignBase<T...> {
-  friend struct VariantCoreAccess;
-
- private:
-  using Base = VariantMoveAssignBase<T...>;
-
- protected:
-  using Base::Base;
-
-  VariantCopyAssignBaseNontrivial() = default;
-  VariantCopyAssignBaseNontrivial(VariantCopyAssignBaseNontrivial&&) = default;
-  VariantCopyAssignBaseNontrivial(const VariantCopyAssignBaseNontrivial&) =
-      default;
-  VariantCopyAssignBaseNontrivial& operator=(
-      VariantCopyAssignBaseNontrivial&&) = default;
-
-    VariantCopyAssignBaseNontrivial& operator=(
-        const VariantCopyAssignBaseNontrivial& other) {
-      VisitIndices<sizeof...(T)>::Run(
-          VariantCoreAccess::MakeCopyAssignVisitor(this, other), other.index_);
-      return *this;
-    }
-
- protected:
-  using Base::index_;
-  using Base::state_;
-};
-
-////////////////////////////////////////
-// Visitors for Comparison Operations //
-////////////////////////////////////////
-
-template <class... Types>
-struct EqualsOp {
-  const variant<Types...>* v;
-  const variant<Types...>* w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return true;
-  }
-
-  template <std::size_t I>
-  constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) == VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types>
-struct NotEqualsOp {
-  const variant<Types...>* v;
-  const variant<Types...>* w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return false;
-  }
-
-  template <std::size_t I>
-  constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) != VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types>
-struct LessThanOp {
-  const variant<Types...>* v;
-  const variant<Types...>* w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return false;
-  }
-
-  template <std::size_t I>
-  constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) < VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types>
-struct GreaterThanOp {
-  const variant<Types...>* v;
-  const variant<Types...>* w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return false;
-  }
-
-  template <std::size_t I>
-  constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) > VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types>
-struct LessThanOrEqualsOp {
-  const variant<Types...>* v;
-  const variant<Types...>* w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return true;
-  }
-
-  template <std::size_t I>
-  constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) <= VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-template <class... Types>
-struct GreaterThanOrEqualsOp {
-  const variant<Types...>* v;
-  const variant<Types...>* w;
-
-  constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
-    return true;
-  }
-
-  template <std::size_t I>
-  constexpr bool operator()(SizeT<I> /*v_i*/) const {
-    return VariantCoreAccess::Access<I>(*v) >= VariantCoreAccess::Access<I>(*w);
-  }
-};
-
-// Precondition: v.index() == w.index();
-template <class... Types>
-struct SwapSameIndex {
-  variant<Types...>* v;
-  variant<Types...>* w;
-  template <std::size_t I>
-  void operator()(SizeT<I>) const {
-    type_traits_internal::Swap(VariantCoreAccess::Access<I>(*v),
-                               VariantCoreAccess::Access<I>(*w));
-  }
-
-  void operator()(SizeT<variant_npos>) const {}
-};
-
-// TODO(calabrese) do this from a different namespace for proper adl usage
-template <class... Types>
-struct Swap {
-  variant<Types...>* v;
-  variant<Types...>* w;
-
-  void generic_swap() const {
-    variant<Types...> tmp(std::move(*w));
-    VariantCoreAccess::Destroy(*w);
-    VariantCoreAccess::InitFrom(*w, std::move(*v));
-    VariantCoreAccess::Destroy(*v);
-    VariantCoreAccess::InitFrom(*v, std::move(tmp));
-  }
-
-  void operator()(SizeT<absl::variant_npos> /*w_i*/) const {
-    if (!v->valueless_by_exception()) {
-      generic_swap();
-    }
-  }
-
-  template <std::size_t Wi>
-  void operator()(SizeT<Wi> /*w_i*/) {
-    if (v->index() == Wi) {
-      VisitIndices<sizeof...(Types)>::Run(SwapSameIndex<Types...>{v, w}, Wi);
-    } else {
-      generic_swap();
-    }
-  }
-};
-
-template <typename Variant, typename = void, typename... Ts>
-struct VariantHashBase {
-  VariantHashBase() = delete;
-  VariantHashBase(const VariantHashBase&) = delete;
-  VariantHashBase(VariantHashBase&&) = delete;
-  VariantHashBase& operator=(const VariantHashBase&) = delete;
-  VariantHashBase& operator=(VariantHashBase&&) = delete;
-};
-
-struct VariantHashVisitor {
-  template <typename T>
-  size_t operator()(const T& t) {
-    return std::hash<T>{}(t);
-  }
-};
-
-template <typename Variant, typename... Ts>
-struct VariantHashBase<Variant,
-                       absl::enable_if_t<absl::conjunction<
-                           type_traits_internal::IsHashable<Ts>...>::value>,
-                       Ts...> {
-  using argument_type = Variant;
-  using result_type = size_t;
-  size_t operator()(const Variant& var) const {
-    type_traits_internal::AssertHashEnabled<Ts...>();
-    if (var.valueless_by_exception()) {
-      return 239799884;
-    }
-    size_t result = VisitIndices<variant_size<Variant>::value>::Run(
-        PerformVisitation<VariantHashVisitor, const Variant&>{
-            std::forward_as_tuple(var), VariantHashVisitor{}},
-        var.index());
-    // Combine the index and the hash result in order to distinguish
-    // std::variant<int, int> holding the same value as different alternative.
-    return result ^ var.index();
-  }
-};
-
-}  // namespace variant_internal
-ABSL_NAMESPACE_END
+        // TODO(calabrese) Just contain a Union in this union (certain configs fail).
+        template<class... T>
+        union DestructibleUnionImpl;
+
+        template<>
+        union DestructibleUnionImpl<>
+        {
+            constexpr explicit DestructibleUnionImpl(NoopConstructorTag) noexcept
+            {
+            }
+        };
+
+        template<class Head, class... Tail>
+        union DestructibleUnionImpl<Head, Tail...>
+        {
+            using TailUnion = DestructibleUnionImpl<Tail...>;
+
+            explicit constexpr DestructibleUnionImpl(NoopConstructorTag /*tag*/) noexcept
+                :
+                tail(NoopConstructorTag())
+            {
+            }
+
+            template<class... P>
+            explicit constexpr DestructibleUnionImpl(EmplaceTag<0>, P&&... args) :
+                head(absl::forward<P>(args)...)
+            {
+            }
+
+            template<std::size_t I, class... P>
+            explicit constexpr DestructibleUnionImpl(EmplaceTag<I>, P&&... args) :
+                tail(EmplaceTag<I - 1>{}, absl::forward<P>(args)...)
+            {
+            }
+
+            ~DestructibleUnionImpl()
+            {
+            }
+
+            Head head;
+            TailUnion tail;
+        };
+
+        // This union type is destructible even if one or more T are not trivially
+        // destructible. In the case that all T are trivially destructible, then so is
+        // this resultant type.
+        template<class... T>
+        using DestructibleUnion =
+            absl::conditional_t<std::is_destructible<Union<T...>>::value, Union<T...>, DestructibleUnionImpl<T...>>;
+
+        // Deepest base, containing the actual union and the discriminator
+        template<class H, class... T>
+        class VariantStateBase
+        {
+        protected:
+            using Variant = variant<H, T...>;
+
+            template<class LazyH = H, class ConstructibleH = absl::enable_if_t<std::is_default_constructible<LazyH>::value, LazyH>>
+            constexpr VariantStateBase() noexcept(
+                std::is_nothrow_default_constructible<ConstructibleH>::value
+            ) :
+                state_(EmplaceTag<0>()),
+                index_(0)
+            {
+            }
+
+            template<std::size_t I, class... P>
+            explicit constexpr VariantStateBase(EmplaceTag<I> tag, P&&... args) :
+                state_(tag, absl::forward<P>(args)...),
+                index_(I)
+            {
+            }
+
+            explicit constexpr VariantStateBase(NoopConstructorTag) :
+                state_(NoopConstructorTag()),
+                index_(variant_npos)
+            {
+            }
+
+            void destroy()
+            {
+            }  // Does nothing (shadowed in child if non-trivial)
+
+            DestructibleUnion<H, T...> state_;
+            std::size_t index_;
+        };
+
+        using absl::internal::identity;
+
+        // OverloadSet::Overload() is a unary function which is overloaded to
+        // take any of the element types of the variant, by reference-to-const.
+        // The return type of the overload on T is identity<T>, so that you
+        // can statically determine which overload was called.
+        //
+        // Overload() is not defined, so it can only be called in unevaluated
+        // contexts.
+        template<typename... Ts>
+        struct OverloadSet;
+
+        template<typename T, typename... Ts>
+        struct OverloadSet<T, Ts...> : OverloadSet<Ts...>
+        {
+            using Base = OverloadSet<Ts...>;
+            static identity<T> Overload(const T&);
+            using Base::Overload;
+        };
+
+        template<>
+        struct OverloadSet<>
+        {
+            // For any case not handled above.
+            static void Overload(...);
+        };
+
+        template<class T>
+        using LessThanResult = decltype(std::declval<T>() < std::declval<T>());
+
+        template<class T>
+        using GreaterThanResult = decltype(std::declval<T>() > std::declval<T>());
+
+        template<class T>
+        using LessThanOrEqualResult = decltype(std::declval<T>() <= std::declval<T>());
+
+        template<class T>
+        using GreaterThanOrEqualResult =
+            decltype(std::declval<T>() >= std::declval<T>());
+
+        template<class T>
+        using EqualResult = decltype(std::declval<T>() == std::declval<T>());
+
+        template<class T>
+        using NotEqualResult = decltype(std::declval<T>() != std::declval<T>());
+
+        using type_traits_internal::is_detected_convertible;
+
+        template<class... T>
+        using RequireAllHaveEqualT = absl::enable_if_t<
+            absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value,
+            bool>;
+
+        template<class... T>
+        using RequireAllHaveNotEqualT =
+            absl::enable_if_t<absl::conjunction<is_detected_convertible<bool, NotEqualResult, T>...>::value, bool>;
+
+        template<class... T>
+        using RequireAllHaveLessThanT =
+            absl::enable_if_t<absl::conjunction<is_detected_convertible<bool, LessThanResult, T>...>::value, bool>;
+
+        template<class... T>
+        using RequireAllHaveLessThanOrEqualT =
+            absl::enable_if_t<absl::conjunction<is_detected_convertible<bool, LessThanOrEqualResult, T>...>::value, bool>;
+
+        template<class... T>
+        using RequireAllHaveGreaterThanOrEqualT =
+            absl::enable_if_t<absl::conjunction<is_detected_convertible<bool, GreaterThanOrEqualResult, T>...>::value, bool>;
+
+        template<class... T>
+        using RequireAllHaveGreaterThanT =
+            absl::enable_if_t<absl::conjunction<is_detected_convertible<bool, GreaterThanResult, T>...>::value, bool>;
+
+        // Helper template containing implementations details of variant that can't go
+        // in the private section. For convenience, this takes the variant type as a
+        // single template parameter.
+        template<typename T>
+        struct VariantHelper;
+
+        template<typename... Ts>
+        struct VariantHelper<variant<Ts...>>
+        {
+            // Type metafunction which returns the element type selected if
+            // OverloadSet::Overload() is well-formed when called with argument type U.
+            template<typename U>
+            using BestMatch = decltype(variant_internal::OverloadSet<Ts...>::Overload(std::declval<U>()));
+
+            // Type metafunction which returns true if OverloadSet::Overload() is
+            // well-formed when called with argument type U.
+            // CanAccept can't be just an alias because there is a MSVC bug on parameter
+            // pack expansion involving decltype.
+            template<typename U>
+            struct CanAccept :
+                std::integral_constant<bool, !std::is_void<BestMatch<U>>::value>
+            {
+            };
+
+            // Type metafunction which returns true if Other is an instantiation of
+            // variant, and variants's converting constructor from Other will be
+            // well-formed. We will use this to remove constructors that would be
+            // ill-formed from the overload set.
+            template<typename Other>
+            struct CanConvertFrom;
+
+            template<typename... Us>
+            struct CanConvertFrom<variant<Us...>> : public absl::conjunction<CanAccept<Us>...>
+            {
+            };
+        };
+
+        // A type with nontrivial copy ctor and trivial move ctor.
+        struct TrivialMoveOnly
+        {
+            TrivialMoveOnly(TrivialMoveOnly&&) = default;
+        };
+
+        // Trait class to detect whether a type is trivially move constructible.
+        // A union's defaulted copy/move constructor is deleted if any variant member's
+        // copy/move constructor is nontrivial.
+        template<typename T>
+        struct IsTriviallyMoveConstructible :
+            std::is_move_constructible<Union<T, TrivialMoveOnly>>
+        {
+        };
+
+        // To guarantee triviality of all special-member functions that can be trivial,
+        // we use a chain of conditional bases for each one.
+        // The order of inheritance of bases from child to base are logically:
+        //
+        // variant
+        // VariantCopyAssignBase
+        // VariantMoveAssignBase
+        // VariantCopyBase
+        // VariantMoveBase
+        // VariantStateBaseDestructor
+        // VariantStateBase
+        //
+        // Note that there is a separate branch at each base that is dependent on
+        // whether or not that corresponding special-member-function can be trivial in
+        // the resultant variant type.
+
+        template<class... T>
+        class VariantStateBaseDestructorNontrivial;
+
+        template<class... T>
+        class VariantMoveBaseNontrivial;
+
+        template<class... T>
+        class VariantCopyBaseNontrivial;
+
+        template<class... T>
+        class VariantMoveAssignBaseNontrivial;
+
+        template<class... T>
+        class VariantCopyAssignBaseNontrivial;
+
+        // Base that is dependent on whether or not the destructor can be trivial.
+        template<class... T>
+        using VariantStateBaseDestructor =
+            absl::conditional_t<std::is_destructible<Union<T...>>::value, VariantStateBase<T...>, VariantStateBaseDestructorNontrivial<T...>>;
+
+        // Base that is dependent on whether or not the move-constructor can be
+        // implicitly generated by the compiler (trivial or deleted).
+        // Previously we were using `std::is_move_constructible<Union<T...>>` to check
+        // whether all Ts have trivial move constructor, but it ran into a GCC bug:
+        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84866
+        // So we have to use a different approach (i.e. `HasTrivialMoveConstructor`) to
+        // work around the bug.
+        template<class... T>
+        using VariantMoveBase = absl::conditional_t<
+            absl::disjunction<
+                absl::negation<absl::conjunction<std::is_move_constructible<T>...>>,
+                absl::conjunction<IsTriviallyMoveConstructible<T>...>>::value,
+            VariantStateBaseDestructor<T...>,
+            VariantMoveBaseNontrivial<T...>>;
+
+        // Base that is dependent on whether or not the copy-constructor can be trivial.
+        template<class... T>
+        using VariantCopyBase = absl::conditional_t<
+            absl::disjunction<
+                absl::negation<absl::conjunction<std::is_copy_constructible<T>...>>,
+                std::is_copy_constructible<Union<T...>>>::value,
+            VariantMoveBase<T...>,
+            VariantCopyBaseNontrivial<T...>>;
+
+        // Base that is dependent on whether or not the move-assign can be trivial.
+        template<class... T>
+        using VariantMoveAssignBase = absl::conditional_t<
+            absl::disjunction<
+                absl::conjunction<absl::is_move_assignable<Union<T...>>, std::is_move_constructible<Union<T...>>, std::is_destructible<Union<T...>>>,
+                absl::negation<absl::conjunction<std::is_move_constructible<T>...,
+                                                 // Note: We're not qualifying this with
+                                                 // absl:: because it doesn't compile
+                                                 // under MSVC.
+                                                 is_move_assignable<T>...>>>::value,
+            VariantCopyBase<T...>,
+            VariantMoveAssignBaseNontrivial<T...>>;
+
+        // Base that is dependent on whether or not the copy-assign can be trivial.
+        template<class... T>
+        using VariantCopyAssignBase = absl::conditional_t<
+            absl::disjunction<
+                absl::conjunction<absl::is_copy_assignable<Union<T...>>, std::is_copy_constructible<Union<T...>>, std::is_destructible<Union<T...>>>,
+                absl::negation<absl::conjunction<std::is_copy_constructible<T>...,
+                                                 // Note: We're not qualifying this with
+                                                 // absl:: because it doesn't compile
+                                                 // under MSVC.
+                                                 is_copy_assignable<T>...>>>::value,
+            VariantMoveAssignBase<T...>,
+            VariantCopyAssignBaseNontrivial<T...>>;
+
+        template<class... T>
+        using VariantBase = VariantCopyAssignBase<T...>;
+
+        template<class... T>
+        class VariantStateBaseDestructorNontrivial : protected VariantStateBase<T...>
+        {
+        private:
+            using Base = VariantStateBase<T...>;
+
+        protected:
+            using Base::Base;
+
+            VariantStateBaseDestructorNontrivial() = default;
+            VariantStateBaseDestructorNontrivial(VariantStateBaseDestructorNontrivial&&) =
+                default;
+            VariantStateBaseDestructorNontrivial(
+                const VariantStateBaseDestructorNontrivial&
+            ) = default;
+            VariantStateBaseDestructorNontrivial& operator=(
+                VariantStateBaseDestructorNontrivial&&
+            ) = default;
+            VariantStateBaseDestructorNontrivial& operator=(
+                const VariantStateBaseDestructorNontrivial&
+            ) = default;
+
+            struct Destroyer
+            {
+                template<std::size_t I>
+                void operator()(SizeT<I> i) const
+                {
+                    using Alternative =
+                        typename absl::variant_alternative<I, variant<T...>>::type;
+                    variant_internal::AccessUnion(self->state_, i).~Alternative();
+                }
+
+                void operator()(SizeT<absl::variant_npos> /*i*/) const
+                {
+                    // This space intentionally left blank
+                }
+
+                VariantStateBaseDestructorNontrivial* self;
+            };
+
+            void destroy()
+            {
+                VisitIndices<sizeof...(T)>::Run(Destroyer{this}, index_);
+            }
+
+            ~VariantStateBaseDestructorNontrivial()
+            {
+                destroy();
+            }
+
+        protected:
+            using Base::index_;
+            using Base::state_;
+        };
+
+        template<class... T>
+        class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...>
+        {
+        private:
+            using Base = VariantStateBaseDestructor<T...>;
+
+        protected:
+            using Base::Base;
+
+            struct Construct
+            {
+                template<std::size_t I>
+                void operator()(SizeT<I> i) const
+                {
+                    using Alternative =
+                        typename absl::variant_alternative<I, variant<T...>>::type;
+                    ::new (static_cast<void*>(&self->state_)) Alternative(
+                        variant_internal::AccessUnion(absl::move(other->state_), i)
+                    );
+                }
+
+                void operator()(SizeT<absl::variant_npos> /*i*/) const
+                {
+                }
+
+                VariantMoveBaseNontrivial* self;
+                VariantMoveBaseNontrivial* other;
+            };
+
+            VariantMoveBaseNontrivial() = default;
+            VariantMoveBaseNontrivial(VariantMoveBaseNontrivial&& other) noexcept(
+                absl::conjunction<std::is_nothrow_move_constructible<T>...>::value
+            ) :
+                Base(NoopConstructorTag())
+            {
+                VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
+                index_ = other.index_;
+            }
+
+            VariantMoveBaseNontrivial(VariantMoveBaseNontrivial const&) = default;
+
+            VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial&&) = default;
+            VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial const&) =
+                default;
+
+        protected:
+            using Base::index_;
+            using Base::state_;
+        };
+
+        template<class... T>
+        class VariantCopyBaseNontrivial : protected VariantMoveBase<T...>
+        {
+        private:
+            using Base = VariantMoveBase<T...>;
+
+        protected:
+            using Base::Base;
+
+            VariantCopyBaseNontrivial() = default;
+            VariantCopyBaseNontrivial(VariantCopyBaseNontrivial&&) = default;
+
+            struct Construct
+            {
+                template<std::size_t I>
+                void operator()(SizeT<I> i) const
+                {
+                    using Alternative =
+                        typename absl::variant_alternative<I, variant<T...>>::type;
+                    ::new (static_cast<void*>(&self->state_))
+                        Alternative(variant_internal::AccessUnion(other->state_, i));
+                }
+
+                void operator()(SizeT<absl::variant_npos> /*i*/) const
+                {
+                }
+
+                VariantCopyBaseNontrivial* self;
+                const VariantCopyBaseNontrivial* other;
+            };
+
+            VariantCopyBaseNontrivial(VariantCopyBaseNontrivial const& other) :
+                Base(NoopConstructorTag())
+            {
+                VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
+                index_ = other.index_;
+            }
+
+            VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial&&) = default;
+            VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial const&) =
+                default;
+
+        protected:
+            using Base::index_;
+            using Base::state_;
+        };
+
+        template<class... T>
+        class VariantMoveAssignBaseNontrivial : protected VariantCopyBase<T...>
+        {
+            friend struct VariantCoreAccess;
+
+        private:
+            using Base = VariantCopyBase<T...>;
+
+        protected:
+            using Base::Base;
+
+            VariantMoveAssignBaseNontrivial() = default;
+            VariantMoveAssignBaseNontrivial(VariantMoveAssignBaseNontrivial&&) = default;
+            VariantMoveAssignBaseNontrivial(const VariantMoveAssignBaseNontrivial&) =
+                default;
+            VariantMoveAssignBaseNontrivial& operator=(
+                VariantMoveAssignBaseNontrivial const&
+            ) = default;
+
+            VariantMoveAssignBaseNontrivial&
+                operator=(VariantMoveAssignBaseNontrivial&& other) noexcept(
+                    absl::conjunction<std::is_nothrow_move_constructible<T>..., std::is_nothrow_move_assignable<T>...>::value
+                )
+            {
+                VisitIndices<sizeof...(T)>::Run(
+                    VariantCoreAccess::MakeMoveAssignVisitor(this, &other), other.index_
+                );
+                return *this;
+            }
+
+        protected:
+            using Base::index_;
+            using Base::state_;
+        };
+
+        template<class... T>
+        class VariantCopyAssignBaseNontrivial : protected VariantMoveAssignBase<T...>
+        {
+            friend struct VariantCoreAccess;
+
+        private:
+            using Base = VariantMoveAssignBase<T...>;
+
+        protected:
+            using Base::Base;
+
+            VariantCopyAssignBaseNontrivial() = default;
+            VariantCopyAssignBaseNontrivial(VariantCopyAssignBaseNontrivial&&) = default;
+            VariantCopyAssignBaseNontrivial(const VariantCopyAssignBaseNontrivial&) =
+                default;
+            VariantCopyAssignBaseNontrivial& operator=(
+                VariantCopyAssignBaseNontrivial&&
+            ) = default;
+
+            VariantCopyAssignBaseNontrivial& operator=(
+                const VariantCopyAssignBaseNontrivial& other
+            )
+            {
+                VisitIndices<sizeof...(T)>::Run(
+                    VariantCoreAccess::MakeCopyAssignVisitor(this, other), other.index_
+                );
+                return *this;
+            }
+
+        protected:
+            using Base::index_;
+            using Base::state_;
+        };
+
+        ////////////////////////////////////////
+        // Visitors for Comparison Operations //
+        ////////////////////////////////////////
+
+        template<class... Types>
+        struct EqualsOp
+        {
+            const variant<Types...>* v;
+            const variant<Types...>* w;
+
+            constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const
+            {
+                return true;
+            }
+
+            template<std::size_t I>
+            constexpr bool operator()(SizeT<I> /*v_i*/) const
+            {
+                return VariantCoreAccess::Access<I>(*v) == VariantCoreAccess::Access<I>(*w);
+            }
+        };
+
+        template<class... Types>
+        struct NotEqualsOp
+        {
+            const variant<Types...>* v;
+            const variant<Types...>* w;
+
+            constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const
+            {
+                return false;
+            }
+
+            template<std::size_t I>
+            constexpr bool operator()(SizeT<I> /*v_i*/) const
+            {
+                return VariantCoreAccess::Access<I>(*v) != VariantCoreAccess::Access<I>(*w);
+            }
+        };
+
+        template<class... Types>
+        struct LessThanOp
+        {
+            const variant<Types...>* v;
+            const variant<Types...>* w;
+
+            constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const
+            {
+                return false;
+            }
+
+            template<std::size_t I>
+            constexpr bool operator()(SizeT<I> /*v_i*/) const
+            {
+                return VariantCoreAccess::Access<I>(*v) < VariantCoreAccess::Access<I>(*w);
+            }
+        };
+
+        template<class... Types>
+        struct GreaterThanOp
+        {
+            const variant<Types...>* v;
+            const variant<Types...>* w;
+
+            constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const
+            {
+                return false;
+            }
+
+            template<std::size_t I>
+            constexpr bool operator()(SizeT<I> /*v_i*/) const
+            {
+                return VariantCoreAccess::Access<I>(*v) > VariantCoreAccess::Access<I>(*w);
+            }
+        };
+
+        template<class... Types>
+        struct LessThanOrEqualsOp
+        {
+            const variant<Types...>* v;
+            const variant<Types...>* w;
+
+            constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const
+            {
+                return true;
+            }
+
+            template<std::size_t I>
+            constexpr bool operator()(SizeT<I> /*v_i*/) const
+            {
+                return VariantCoreAccess::Access<I>(*v) <= VariantCoreAccess::Access<I>(*w);
+            }
+        };
+
+        template<class... Types>
+        struct GreaterThanOrEqualsOp
+        {
+            const variant<Types...>* v;
+            const variant<Types...>* w;
+
+            constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const
+            {
+                return true;
+            }
+
+            template<std::size_t I>
+            constexpr bool operator()(SizeT<I> /*v_i*/) const
+            {
+                return VariantCoreAccess::Access<I>(*v) >= VariantCoreAccess::Access<I>(*w);
+            }
+        };
+
+        // Precondition: v.index() == w.index();
+        template<class... Types>
+        struct SwapSameIndex
+        {
+            variant<Types...>* v;
+            variant<Types...>* w;
+            template<std::size_t I>
+            void operator()(SizeT<I>) const
+            {
+                type_traits_internal::Swap(VariantCoreAccess::Access<I>(*v), VariantCoreAccess::Access<I>(*w));
+            }
+
+            void operator()(SizeT<variant_npos>) const
+            {
+            }
+        };
+
+        // TODO(calabrese) do this from a different namespace for proper adl usage
+        template<class... Types>
+        struct Swap
+        {
+            variant<Types...>* v;
+            variant<Types...>* w;
+
+            void generic_swap() const
+            {
+                variant<Types...> tmp(std::move(*w));
+                VariantCoreAccess::Destroy(*w);
+                VariantCoreAccess::InitFrom(*w, std::move(*v));
+                VariantCoreAccess::Destroy(*v);
+                VariantCoreAccess::InitFrom(*v, std::move(tmp));
+            }
+
+            void operator()(SizeT<absl::variant_npos> /*w_i*/) const
+            {
+                if (!v->valueless_by_exception())
+                {
+                    generic_swap();
+                }
+            }
+
+            template<std::size_t Wi>
+            void operator()(SizeT<Wi> /*w_i*/)
+            {
+                if (v->index() == Wi)
+                {
+                    VisitIndices<sizeof...(Types)>::Run(SwapSameIndex<Types...>{v, w}, Wi);
+                }
+                else
+                {
+                    generic_swap();
+                }
+            }
+        };
+
+        template<typename Variant, typename = void, typename... Ts>
+        struct VariantHashBase
+        {
+            VariantHashBase() = delete;
+            VariantHashBase(const VariantHashBase&) = delete;
+            VariantHashBase(VariantHashBase&&) = delete;
+            VariantHashBase& operator=(const VariantHashBase&) = delete;
+            VariantHashBase& operator=(VariantHashBase&&) = delete;
+        };
+
+        struct VariantHashVisitor
+        {
+            template<typename T>
+            size_t operator()(const T& t)
+            {
+                return std::hash<T>{}(t);
+            }
+        };
+
+        template<typename Variant, typename... Ts>
+        struct VariantHashBase<Variant, absl::enable_if_t<absl::conjunction<type_traits_internal::IsHashable<Ts>...>::value>, Ts...>
+        {
+            using argument_type = Variant;
+            using result_type = size_t;
+            size_t operator()(const Variant& var) const
+            {
+                type_traits_internal::AssertHashEnabled<Ts...>();
+                if (var.valueless_by_exception())
+                {
+                    return 239799884;
+                }
+                size_t result = VisitIndices<variant_size<Variant>::value>::Run(
+                    PerformVisitation<VariantHashVisitor, const Variant&>{
+                        std::forward_as_tuple(var), VariantHashVisitor{}},
+                    var.index()
+                );
+                // Combine the index and the hash result in order to distinguish
+                // std::variant<int, int> holding the same value as different alternative.
+                return result ^ var.index();
+            }
+        };
+
+    }  // namespace variant_internal
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // !defined(ABSL_USES_STD_VARIANT)
diff --git a/CAPI/cpp/grpc/include/absl/types/optional.h b/CAPI/cpp/grpc/include/absl/types/optional.h
index 134b2af..1b7fd48 100644
--- a/CAPI/cpp/grpc/include/absl/types/optional.h
+++ b/CAPI/cpp/grpc/include/absl/types/optional.h
@@ -35,21 +35,22 @@
 #ifndef ABSL_TYPES_OPTIONAL_H_
 #define ABSL_TYPES_OPTIONAL_H_
 
-#include "absl/base/config.h"   // TODO(calabrese) IWYU removal?
+#include "absl/base/config.h"  // TODO(calabrese) IWYU removal?
 #include "absl/utility/utility.h"
 
 #ifdef ABSL_USES_STD_OPTIONAL
 
 #include <optional>  // IWYU pragma: export
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_optional_access;
-using std::optional;
-using std::make_optional;
-using std::nullopt_t;
-using std::nullopt;
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    using std::bad_optional_access;
+    using std::make_optional;
+    using std::nullopt;
+    using std::nullopt_t;
+    using std::optional;
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_OPTIONAL
@@ -66,399 +67,401 @@ ABSL_NAMESPACE_END
 #include "absl/types/bad_optional_access.h"
 #include "absl/types/internal/optional.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// nullopt_t
-//
-// Class type for `absl::nullopt` used to indicate an `absl::optional<T>` type
-// that does not contain a value.
-struct nullopt_t {
-  // It must not be default-constructible to avoid ambiguity for opt = {}.
-  explicit constexpr nullopt_t(optional_internal::init_t) noexcept {}
-};
-
-// nullopt
-//
-// A tag constant of type `absl::nullopt_t` used to indicate an empty
-// `absl::optional` in certain functions, such as construction or assignment.
-ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt,
-                               nullopt_t(optional_internal::init_t()));
-
-// -----------------------------------------------------------------------------
-// absl::optional
-// -----------------------------------------------------------------------------
-//
-// A value of type `absl::optional<T>` holds either a value of `T` or an
-// "empty" value.  When it holds a value of `T`, it stores it as a direct
-// sub-object, so `sizeof(optional<T>)` is approximately
-// `sizeof(T) + sizeof(bool)`.
-//
-// This implementation is based on the specification in the latest draft of the
-// C++17 `std::optional` specification as of May 2017, section 20.6.
-//
-// Differences between `absl::optional<T>` and `std::optional<T>` include:
-//
-//    * `constexpr` is not used for non-const member functions.
-//      (dependency on some differences between C++11 and C++14.)
-//    * `absl::nullopt` and `absl::in_place` are not declared `constexpr`. We
-//      need the inline variable support in C++17 for external linkage.
-//    * Throws `absl::bad_optional_access` instead of
-//      `std::bad_optional_access`.
-//    * `make_optional()` cannot be declared `constexpr` due to the absence of
-//      guaranteed copy elision.
-//    * The move constructor's `noexcept` specification is stronger, i.e. if the
-//      default allocator is non-throwing (via setting
-//      `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
-//      we assume
-//       a) move constructors should only throw due to allocation failure and
-//       b) if T's move constructor allocates, it uses the same allocation
-//          function as the default allocator.
-//
-template <typename T>
-class optional : private optional_internal::optional_data<T>,
-                 private optional_internal::optional_ctor_base<
-                     optional_internal::ctor_copy_traits<T>::traits>,
-                 private optional_internal::optional_assign_base<
-                     optional_internal::assign_copy_traits<T>::traits> {
-  using data_base = optional_internal::optional_data<T>;
-
- public:
-  typedef T value_type;
-
-  // Constructors
-
-  // Constructs an `optional` holding an empty value, NOT a default constructed
-  // `T`.
-  constexpr optional() noexcept {}
-
-  // Constructs an `optional` initialized with `nullopt` to hold an empty value.
-  constexpr optional(nullopt_t) noexcept {}  // NOLINT(runtime/explicit)
-
-  // Copy constructor, standard semantics
-  optional(const optional&) = default;
-
-  // Move constructor, standard semantics
-  optional(optional&&) = default;
-
-  // Constructs a non-empty `optional` direct-initialized value of type `T` from
-  // the arguments `std::forward<Args>(args)...`  within the `optional`.
-  // (The `in_place_t` is a tag used to indicate that the contained object
-  // should be constructed in-place.)
-  template <typename InPlaceT, typename... Args,
-            absl::enable_if_t<absl::conjunction<
-                std::is_same<InPlaceT, in_place_t>,
-                std::is_constructible<T, Args&&...> >::value>* = nullptr>
-  constexpr explicit optional(InPlaceT, Args&&... args)
-      : data_base(in_place_t(), absl::forward<Args>(args)...) {}
-
-  // Constructs a non-empty `optional` direct-initialized value of type `T` from
-  // the arguments of an initializer_list and `std::forward<Args>(args)...`.
-  // (The `in_place_t` is a tag used to indicate that the contained object
-  // should be constructed in-place.)
-  template <typename U, typename... Args,
-            typename = typename std::enable_if<std::is_constructible<
-                T, std::initializer_list<U>&, Args&&...>::value>::type>
-  constexpr explicit optional(in_place_t, std::initializer_list<U> il,
-                              Args&&... args)
-      : data_base(in_place_t(), il, absl::forward<Args>(args)...) {
-  }
-
-  // Value constructor (implicit)
-  template <
-      typename U = T,
-      typename std::enable_if<
-          absl::conjunction<absl::negation<std::is_same<
-                                in_place_t, typename std::decay<U>::type> >,
-                            absl::negation<std::is_same<
-                                optional<T>, typename std::decay<U>::type> >,
-                            std::is_convertible<U&&, T>,
-                            std::is_constructible<T, U&&> >::value,
-          bool>::type = false>
-  constexpr optional(U&& v) : data_base(in_place_t(), absl::forward<U>(v)) {}
-
-  // Value constructor (explicit)
-  template <
-      typename U = T,
-      typename std::enable_if<
-          absl::conjunction<absl::negation<std::is_same<
-                                in_place_t, typename std::decay<U>::type>>,
-                            absl::negation<std::is_same<
-                                optional<T>, typename std::decay<U>::type>>,
-                            absl::negation<std::is_convertible<U&&, T>>,
-                            std::is_constructible<T, U&&>>::value,
-          bool>::type = false>
-  explicit constexpr optional(U&& v)
-      : data_base(in_place_t(), absl::forward<U>(v)) {}
-
-  // Converting copy constructor (implicit)
-  template <typename U,
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // nullopt_t
+    //
+    // Class type for `absl::nullopt` used to indicate an `absl::optional<T>` type
+    // that does not contain a value.
+    struct nullopt_t
+    {
+        // It must not be default-constructible to avoid ambiguity for opt = {}.
+        explicit constexpr nullopt_t(optional_internal::init_t) noexcept
+        {
+        }
+    };
+
+    // nullopt
+    //
+    // A tag constant of type `absl::nullopt_t` used to indicate an empty
+    // `absl::optional` in certain functions, such as construction or assignment.
+    ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt, nullopt_t(optional_internal::init_t()));
+
+    // -----------------------------------------------------------------------------
+    // absl::optional
+    // -----------------------------------------------------------------------------
+    //
+    // A value of type `absl::optional<T>` holds either a value of `T` or an
+    // "empty" value.  When it holds a value of `T`, it stores it as a direct
+    // sub-object, so `sizeof(optional<T>)` is approximately
+    // `sizeof(T) + sizeof(bool)`.
+    //
+    // This implementation is based on the specification in the latest draft of the
+    // C++17 `std::optional` specification as of May 2017, section 20.6.
+    //
+    // Differences between `absl::optional<T>` and `std::optional<T>` include:
+    //
+    //    * `constexpr` is not used for non-const member functions.
+    //      (dependency on some differences between C++11 and C++14.)
+    //    * `absl::nullopt` and `absl::in_place` are not declared `constexpr`. We
+    //      need the inline variable support in C++17 for external linkage.
+    //    * Throws `absl::bad_optional_access` instead of
+    //      `std::bad_optional_access`.
+    //    * `make_optional()` cannot be declared `constexpr` due to the absence of
+    //      guaranteed copy elision.
+    //    * The move constructor's `noexcept` specification is stronger, i.e. if the
+    //      default allocator is non-throwing (via setting
+    //      `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
+    //      we assume
+    //       a) move constructors should only throw due to allocation failure and
+    //       b) if T's move constructor allocates, it uses the same allocation
+    //          function as the default allocator.
+    //
+    template<typename T>
+    class optional : private optional_internal::optional_data<T>, private optional_internal::optional_ctor_base<optional_internal::ctor_copy_traits<T>::traits>, private optional_internal::optional_assign_base<optional_internal::assign_copy_traits<T>::traits>
+    {
+        using data_base = optional_internal::optional_data<T>;
+
+    public:
+        typedef T value_type;
+
+        // Constructors
+
+        // Constructs an `optional` holding an empty value, NOT a default constructed
+        // `T`.
+        constexpr optional() noexcept
+        {
+        }
+
+        // Constructs an `optional` initialized with `nullopt` to hold an empty value.
+        constexpr optional(nullopt_t) noexcept
+        {
+        }  // NOLINT(runtime/explicit)
+
+        // Copy constructor, standard semantics
+        optional(const optional&) = default;
+
+        // Move constructor, standard semantics
+        optional(optional&&) = default;
+
+        // Constructs a non-empty `optional` direct-initialized value of type `T` from
+        // the arguments `std::forward<Args>(args)...`  within the `optional`.
+        // (The `in_place_t` is a tag used to indicate that the contained object
+        // should be constructed in-place.)
+        template<typename InPlaceT, typename... Args, absl::enable_if_t<absl::conjunction<std::is_same<InPlaceT, in_place_t>, std::is_constructible<T, Args&&...>>::value>* = nullptr>
+        constexpr explicit optional(InPlaceT, Args&&... args) :
+            data_base(in_place_t(), absl::forward<Args>(args)...)
+        {
+        }
+
+        // Constructs a non-empty `optional` direct-initialized value of type `T` from
+        // the arguments of an initializer_list and `std::forward<Args>(args)...`.
+        // (The `in_place_t` is a tag used to indicate that the contained object
+        // should be constructed in-place.)
+        template<typename U, typename... Args, typename = typename std::enable_if<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value>::type>
+        constexpr explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args) :
+            data_base(in_place_t(), il, absl::forward<Args>(args)...)
+        {
+        }
+
+        // Value constructor (implicit)
+        template<
+            typename U = T,
             typename std::enable_if<
-                absl::conjunction<
-                    absl::negation<std::is_same<T, U> >,
-                    std::is_constructible<T, const U&>,
-                    absl::negation<
-                        optional_internal::
-                            is_constructible_convertible_from_optional<T, U> >,
-                    std::is_convertible<const U&, T> >::value,
+                absl::conjunction<absl::negation<std::is_same<in_place_t, typename std::decay<U>::type>>, absl::negation<std::is_same<optional<T>, typename std::decay<U>::type>>, std::is_convertible<U&&, T>, std::is_constructible<T, U&&>>::value,
                 bool>::type = false>
-  optional(const optional<U>& rhs) {
-    if (rhs) {
-      this->construct(*rhs);
-    }
-  }
-
-  // Converting copy constructor (explicit)
-  template <typename U,
+        constexpr optional(U&& v) :
+            data_base(in_place_t(), absl::forward<U>(v))
+        {
+        }
+
+        // Value constructor (explicit)
+        template<
+            typename U = T,
             typename std::enable_if<
-                absl::conjunction<
-                    absl::negation<std::is_same<T, U>>,
-                    std::is_constructible<T, const U&>,
-                    absl::negation<
-                        optional_internal::
-                            is_constructible_convertible_from_optional<T, U>>,
-                    absl::negation<std::is_convertible<const U&, T>>>::value,
+                absl::conjunction<absl::negation<std::is_same<in_place_t, typename std::decay<U>::type>>, absl::negation<std::is_same<optional<T>, typename std::decay<U>::type>>, absl::negation<std::is_convertible<U&&, T>>, std::is_constructible<T, U&&>>::value,
                 bool>::type = false>
-  explicit optional(const optional<U>& rhs) {
-    if (rhs) {
-      this->construct(*rhs);
-    }
-  }
-
-  // Converting move constructor (implicit)
-  template <typename U,
+        explicit constexpr optional(U&& v) :
+            data_base(in_place_t(), absl::forward<U>(v))
+        {
+        }
+
+        // Converting copy constructor (implicit)
+        template<typename U, typename std::enable_if<absl::conjunction<absl::negation<std::is_same<T, U>>, std::is_constructible<T, const U&>, absl::negation<optional_internal::is_constructible_convertible_from_optional<T, U>>, std::is_convertible<const U&, T>>::value, bool>::type = false>
+        optional(const optional<U>& rhs)
+        {
+            if (rhs)
+            {
+                this->construct(*rhs);
+            }
+        }
+
+        // Converting copy constructor (explicit)
+        template<typename U, typename std::enable_if<absl::conjunction<absl::negation<std::is_same<T, U>>, std::is_constructible<T, const U&>, absl::negation<optional_internal::is_constructible_convertible_from_optional<T, U>>, absl::negation<std::is_convertible<const U&, T>>>::value, bool>::type = false>
+        explicit optional(const optional<U>& rhs)
+        {
+            if (rhs)
+            {
+                this->construct(*rhs);
+            }
+        }
+
+        // Converting move constructor (implicit)
+        template<typename U, typename std::enable_if<absl::conjunction<absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, absl::negation<optional_internal::is_constructible_convertible_from_optional<T, U>>, std::is_convertible<U&&, T>>::value, bool>::type = false>
+        optional(optional<U>&& rhs)
+        {
+            if (rhs)
+            {
+                this->construct(std::move(*rhs));
+            }
+        }
+
+        // Converting move constructor (explicit)
+        template<
+            typename U,
             typename std::enable_if<
                 absl::conjunction<
-                    absl::negation<std::is_same<T, U> >,
+                    absl::negation<std::is_same<T, U>>,
                     std::is_constructible<T, U&&>,
                     absl::negation<
-                        optional_internal::
-                            is_constructible_convertible_from_optional<T, U> >,
-                    std::is_convertible<U&&, T> >::value,
+                        optional_internal::is_constructible_convertible_from_optional<
+                            T,
+                            U>>,
+                    absl::negation<std::is_convertible<U&&, T>>>::value,
                 bool>::type = false>
-  optional(optional<U>&& rhs) {
-    if (rhs) {
-      this->construct(std::move(*rhs));
-    }
-  }
-
-  // Converting move constructor (explicit)
-  template <
-      typename U,
-      typename std::enable_if<
-          absl::conjunction<
-              absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              absl::negation<
-                  optional_internal::is_constructible_convertible_from_optional<
-                      T, U>>,
-              absl::negation<std::is_convertible<U&&, T>>>::value,
-          bool>::type = false>
-  explicit optional(optional<U>&& rhs) {
-    if (rhs) {
-      this->construct(std::move(*rhs));
-    }
-  }
-
-  // Destructor. Trivial if `T` is trivially destructible.
-  ~optional() = default;
-
-  // Assignment Operators
-
-  // Assignment from `nullopt`
-  //
-  // Example:
-  //
-  //   struct S { int value; };
-  //   optional<S> opt = absl::nullopt;  // Could also use opt = { };
-  optional& operator=(nullopt_t) noexcept {
-    this->destruct();
-    return *this;
-  }
-
-  // Copy assignment operator, standard semantics
-  optional& operator=(const optional& src) = default;
-
-  // Move assignment operator, standard semantics
-  optional& operator=(optional&& src) = default;
-
-  // Value assignment operators
-  template <typename U = T,
-            int&...,  // Workaround an internal compiler error in GCC 5 to 10.
-            typename = typename std::enable_if<absl::conjunction<
-                absl::negation<
-                    std::is_same<optional<T>, typename std::decay<U>::type> >,
-                absl::negation<absl::conjunction<
-                    std::is_scalar<T>,
-                    std::is_same<T, typename std::decay<U>::type> > >,
-                std::is_constructible<T, U>,
-                std::is_assignable<T&, U> >::value>::type>
-  optional& operator=(U&& v) {
-    this->assign(std::forward<U>(v));
-    return *this;
-  }
-
-  template <
-      typename U,
-      int&...,  // Workaround an internal compiler error in GCC 5 to 10.
-      typename = typename std::enable_if<absl::conjunction<
-          absl::negation<std::is_same<T, U> >,
-          std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>,
-          absl::negation<
-              optional_internal::
-                  is_constructible_convertible_assignable_from_optional<
-                      T, U> > >::value>::type>
-  optional& operator=(const optional<U>& rhs) {
-    if (rhs) {
-      this->assign(*rhs);
-    } else {
-      this->destruct();
-    }
-    return *this;
-  }
-
-  template <typename U,
+        explicit optional(optional<U>&& rhs)
+        {
+            if (rhs)
+            {
+                this->construct(std::move(*rhs));
+            }
+        }
+
+        // Destructor. Trivial if `T` is trivially destructible.
+        ~optional() = default;
+
+        // Assignment Operators
+
+        // Assignment from `nullopt`
+        //
+        // Example:
+        //
+        //   struct S { int value; };
+        //   optional<S> opt = absl::nullopt;  // Could also use opt = { };
+        optional& operator=(nullopt_t) noexcept
+        {
+            this->destruct();
+            return *this;
+        }
+
+        // Copy assignment operator, standard semantics
+        optional& operator=(const optional& src) = default;
+
+        // Move assignment operator, standard semantics
+        optional& operator=(optional&& src) = default;
+
+        // Value assignment operators
+        template<typename U = T,
+                 int&...,  // Workaround an internal compiler error in GCC 5 to 10.
+                 typename = typename std::enable_if<absl::conjunction<absl::negation<std::is_same<optional<T>, typename std::decay<U>::type>>, absl::negation<absl::conjunction<std::is_scalar<T>, std::is_same<T, typename std::decay<U>::type>>>, std::is_constructible<T, U>, std::is_assignable<T&, U>>::value>::type>
+        optional& operator=(U&& v)
+        {
+            this->assign(std::forward<U>(v));
+            return *this;
+        }
+
+        template<
+            typename U,
             int&...,  // Workaround an internal compiler error in GCC 5 to 10.
             typename = typename std::enable_if<absl::conjunction<
-                absl::negation<std::is_same<T, U> >,
-                std::is_constructible<T, U>, std::is_assignable<T&, U>,
+                absl::negation<std::is_same<T, U>>,
+                std::is_constructible<T, const U&>,
+                std::is_assignable<T&, const U&>,
                 absl::negation<
                     optional_internal::
                         is_constructible_convertible_assignable_from_optional<
-                            T, U> > >::value>::type>
-  optional& operator=(optional<U>&& rhs) {
-    if (rhs) {
-      this->assign(std::move(*rhs));
-    } else {
-      this->destruct();
-    }
-    return *this;
-  }
-
-  // Modifiers
-
-  // optional::reset()
-  //
-  // Destroys the inner `T` value of an `absl::optional` if one is present.
-  ABSL_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
-
-  // optional::emplace()
-  //
-  // (Re)constructs the underlying `T` in-place with the given forwarded
-  // arguments.
-  //
-  // Example:
-  //
-  //   optional<Foo> opt;
-  //   opt.emplace(arg1,arg2,arg3);  // Constructs Foo(arg1,arg2,arg3)
-  //
-  // If the optional is non-empty, and the `args` refer to subobjects of the
-  // current object, then behaviour is undefined, because the current object
-  // will be destructed before the new object is constructed with `args`.
-  template <typename... Args,
-            typename = typename std::enable_if<
-                std::is_constructible<T, Args&&...>::value>::type>
-  T& emplace(Args&&... args) {
-    this->destruct();
-    this->construct(std::forward<Args>(args)...);
-    return reference();
-  }
-
-  // Emplace reconstruction overload for an initializer list and the given
-  // forwarded arguments.
-  //
-  // Example:
-  //
-  //   struct Foo {
-  //     Foo(std::initializer_list<int>);
-  //   };
-  //
-  //   optional<Foo> opt;
-  //   opt.emplace({1,2,3});  // Constructs Foo({1,2,3})
-  template <typename U, typename... Args,
-            typename = typename std::enable_if<std::is_constructible<
-                T, std::initializer_list<U>&, Args&&...>::value>::type>
-  T& emplace(std::initializer_list<U> il, Args&&... args) {
-    this->destruct();
-    this->construct(il, std::forward<Args>(args)...);
-    return reference();
-  }
-
-  // Swaps
-
-  // Swap, standard semantics
-  void swap(optional& rhs) noexcept(
-      std::is_nothrow_move_constructible<T>::value&&
-          type_traits_internal::IsNothrowSwappable<T>::value) {
-    if (*this) {
-      if (rhs) {
-        type_traits_internal::Swap(**this, *rhs);
-      } else {
-        rhs.construct(std::move(**this));
-        this->destruct();
-      }
-    } else {
-      if (rhs) {
-        this->construct(std::move(*rhs));
-        rhs.destruct();
-      } else {
-        // No effect (swap(disengaged, disengaged)).
-      }
-    }
-  }
-
-  // Observers
-
-  // optional::operator->()
-  //
-  // Accesses the underlying `T` value's member `m` of an `optional`. If the
-  // `optional` is empty, behavior is undefined.
-  //
-  // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
-  const T* operator->() const {
-    ABSL_HARDENING_ASSERT(this->engaged_);
-    return std::addressof(this->data_);
-  }
-  T* operator->() {
-    ABSL_HARDENING_ASSERT(this->engaged_);
-    return std::addressof(this->data_);
-  }
-
-  // optional::operator*()
-  //
-  // Accesses the underlying `T` value of an `optional`. If the `optional` is
-  // empty, behavior is undefined.
-  constexpr const T& operator*() const& {
-    return ABSL_HARDENING_ASSERT(this->engaged_), reference();
-  }
-  T& operator*() & {
-    ABSL_HARDENING_ASSERT(this->engaged_);
-    return reference();
-  }
-  constexpr const T&& operator*() const && {
-    return ABSL_HARDENING_ASSERT(this->engaged_), absl::move(reference());
-  }
-  T&& operator*() && {
-    ABSL_HARDENING_ASSERT(this->engaged_);
-    return std::move(reference());
-  }
-
-  // optional::operator bool()
-  //
-  // Returns false if and only if the `optional` is empty.
-  //
-  //   if (opt) {
-  //     // do something with *opt or opt->;
-  //   } else {
-  //     // opt is empty.
-  //   }
-  //
-  constexpr explicit operator bool() const noexcept { return this->engaged_; }
-
-  // optional::has_value()
-  //
-  // Determines whether the `optional` contains a value. Returns `false` if and
-  // only if `*this` is empty.
-  constexpr bool has_value() const noexcept { return this->engaged_; }
+                            T,
+                            U>>>::value>::type>
+        optional& operator=(const optional<U>& rhs)
+        {
+            if (rhs)
+            {
+                this->assign(*rhs);
+            }
+            else
+            {
+                this->destruct();
+            }
+            return *this;
+        }
+
+        template<typename U,
+                 int&...,  // Workaround an internal compiler error in GCC 5 to 10.
+                 typename = typename std::enable_if<absl::conjunction<absl::negation<std::is_same<T, U>>, std::is_constructible<T, U>, std::is_assignable<T&, U>, absl::negation<optional_internal::is_constructible_convertible_assignable_from_optional<T, U>>>::value>::type>
+        optional& operator=(optional<U>&& rhs)
+        {
+            if (rhs)
+            {
+                this->assign(std::move(*rhs));
+            }
+            else
+            {
+                this->destruct();
+            }
+            return *this;
+        }
+
+        // Modifiers
+
+        // optional::reset()
+        //
+        // Destroys the inner `T` value of an `absl::optional` if one is present.
+        ABSL_ATTRIBUTE_REINITIALIZES void reset() noexcept
+        {
+            this->destruct();
+        }
+
+        // optional::emplace()
+        //
+        // (Re)constructs the underlying `T` in-place with the given forwarded
+        // arguments.
+        //
+        // Example:
+        //
+        //   optional<Foo> opt;
+        //   opt.emplace(arg1,arg2,arg3);  // Constructs Foo(arg1,arg2,arg3)
+        //
+        // If the optional is non-empty, and the `args` refer to subobjects of the
+        // current object, then behaviour is undefined, because the current object
+        // will be destructed before the new object is constructed with `args`.
+        template<typename... Args, typename = typename std::enable_if<std::is_constructible<T, Args&&...>::value>::type>
+        T& emplace(Args&&... args)
+        {
+            this->destruct();
+            this->construct(std::forward<Args>(args)...);
+            return reference();
+        }
+
+        // Emplace reconstruction overload for an initializer list and the given
+        // forwarded arguments.
+        //
+        // Example:
+        //
+        //   struct Foo {
+        //     Foo(std::initializer_list<int>);
+        //   };
+        //
+        //   optional<Foo> opt;
+        //   opt.emplace({1,2,3});  // Constructs Foo({1,2,3})
+        template<typename U, typename... Args, typename = typename std::enable_if<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value>::type>
+        T& emplace(std::initializer_list<U> il, Args&&... args)
+        {
+            this->destruct();
+            this->construct(il, std::forward<Args>(args)...);
+            return reference();
+        }
+
+        // Swaps
+
+        // Swap, standard semantics
+        void swap(optional& rhs) noexcept(
+            std::is_nothrow_move_constructible<T>::value&&
+                type_traits_internal::IsNothrowSwappable<T>::value
+        )
+        {
+            if (*this)
+            {
+                if (rhs)
+                {
+                    type_traits_internal::Swap(**this, *rhs);
+                }
+                else
+                {
+                    rhs.construct(std::move(**this));
+                    this->destruct();
+                }
+            }
+            else
+            {
+                if (rhs)
+                {
+                    this->construct(std::move(*rhs));
+                    rhs.destruct();
+                }
+                else
+                {
+                    // No effect (swap(disengaged, disengaged)).
+                }
+            }
+        }
+
+        // Observers
+
+        // optional::operator->()
+        //
+        // Accesses the underlying `T` value's member `m` of an `optional`. If the
+        // `optional` is empty, behavior is undefined.
+        //
+        // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
+        const T* operator->() const
+        {
+            ABSL_HARDENING_ASSERT(this->engaged_);
+            return std::addressof(this->data_);
+        }
+        T* operator->()
+        {
+            ABSL_HARDENING_ASSERT(this->engaged_);
+            return std::addressof(this->data_);
+        }
+
+        // optional::operator*()
+        //
+        // Accesses the underlying `T` value of an `optional`. If the `optional` is
+        // empty, behavior is undefined.
+        constexpr const T& operator*() const&
+        {
+            return ABSL_HARDENING_ASSERT(this->engaged_), reference();
+        }
+        T& operator*() &
+        {
+            ABSL_HARDENING_ASSERT(this->engaged_);
+            return reference();
+        }
+        constexpr const T&& operator*() const&&
+        {
+            return ABSL_HARDENING_ASSERT(this->engaged_), absl::move(reference());
+        }
+        T&& operator*() &&
+        {
+            ABSL_HARDENING_ASSERT(this->engaged_);
+            return std::move(reference());
+        }
+
+        // optional::operator bool()
+        //
+        // Returns false if and only if the `optional` is empty.
+        //
+        //   if (opt) {
+        //     // do something with *opt or opt->;
+        //   } else {
+        //     // opt is empty.
+        //   }
+        //
+        constexpr explicit operator bool() const noexcept
+        {
+            return this->engaged_;
+        }
+
+        // optional::has_value()
+        //
+        // Determines whether the `optional` contains a value. Returns `false` if and
+        // only if `*this` is empty.
+        constexpr bool has_value() const noexcept
+        {
+            return this->engaged_;
+        }
 
 // Suppress bogus warning on MSVC: MSVC complains call to reference() after
 // throw_bad_optional_access() is unreachable.
@@ -466,309 +469,340 @@ class optional : private optional_internal::optional_data<T>,
 #pragma warning(push)
 #pragma warning(disable : 4702)
 #endif  // _MSC_VER
-  // optional::value()
-  //
-  // Returns a reference to an `optional`s underlying value. The constness
-  // and lvalue/rvalue-ness of the `optional` is preserved to the view of
-  // the `T` sub-object. Throws `absl::bad_optional_access` when the `optional`
-  // is empty.
-  constexpr const T& value() const & {
-    return static_cast<bool>(*this)
-               ? reference()
-               : (optional_internal::throw_bad_optional_access(), reference());
-  }
-  T& value() & {
-    return static_cast<bool>(*this)
-               ? reference()
-               : (optional_internal::throw_bad_optional_access(), reference());
-  }
-  T&& value() && {  // NOLINT(build/c++11)
-    return std::move(
-        static_cast<bool>(*this)
-            ? reference()
-            : (optional_internal::throw_bad_optional_access(), reference()));
-  }
-  constexpr const T&& value() const && {  // NOLINT(build/c++11)
-    return absl::move(
-        static_cast<bool>(*this)
-            ? reference()
-            : (optional_internal::throw_bad_optional_access(), reference()));
-  }
+        // optional::value()
+        //
+        // Returns a reference to an `optional`s underlying value. The constness
+        // and lvalue/rvalue-ness of the `optional` is preserved to the view of
+        // the `T` sub-object. Throws `absl::bad_optional_access` when the `optional`
+        // is empty.
+        constexpr const T& value() const&
+        {
+            return static_cast<bool>(*this) ? reference() : (optional_internal::throw_bad_optional_access(), reference());
+        }
+        T& value() &
+        {
+            return static_cast<bool>(*this) ? reference() : (optional_internal::throw_bad_optional_access(), reference());
+        }
+        T&& value() &&
+        {  // NOLINT(build/c++11)
+            return std::move(
+                static_cast<bool>(*this) ? reference() : (optional_internal::throw_bad_optional_access(), reference())
+            );
+        }
+        constexpr const T&& value() const&&
+        {  // NOLINT(build/c++11)
+            return absl::move(
+                static_cast<bool>(*this) ? reference() : (optional_internal::throw_bad_optional_access(), reference())
+            );
+        }
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif  // _MSC_VER
 
-  // optional::value_or()
-  //
-  // Returns either the value of `T` or a passed default `v` if the `optional`
-  // is empty.
-  template <typename U>
-  constexpr T value_or(U&& v) const& {
-    static_assert(std::is_copy_constructible<value_type>::value,
-                  "optional<T>::value_or: T must be copy constructible");
-    static_assert(std::is_convertible<U&&, value_type>::value,
-                  "optional<T>::value_or: U must be convertible to T");
-    return static_cast<bool>(*this)
-               ? **this
-               : static_cast<T>(absl::forward<U>(v));
-  }
-  template <typename U>
-  T value_or(U&& v) && {  // NOLINT(build/c++11)
-    static_assert(std::is_move_constructible<value_type>::value,
-                  "optional<T>::value_or: T must be move constructible");
-    static_assert(std::is_convertible<U&&, value_type>::value,
-                  "optional<T>::value_or: U must be convertible to T");
-    return static_cast<bool>(*this) ? std::move(**this)
-                                    : static_cast<T>(std::forward<U>(v));
-  }
-
- private:
-  // Private accessors for internal storage viewed as reference to T.
-  constexpr const T& reference() const { return this->data_; }
-  T& reference() { return this->data_; }
-
-  // T constraint checks.  You can't have an optional of nullopt_t, in_place_t
-  // or a reference.
-  static_assert(
-      !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
-      "optional<nullopt_t> is not allowed.");
-  static_assert(
-      !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
-      "optional<in_place_t> is not allowed.");
-  static_assert(!std::is_reference<T>::value,
-                "optional<reference> is not allowed.");
-};
-
-// Non-member functions
-
-// swap()
-//
-// Performs a swap between two `absl::optional` objects, using standard
-// semantics.
-template <typename T, typename std::enable_if<
-                          std::is_move_constructible<T>::value &&
-                              type_traits_internal::IsSwappable<T>::value,
-                          bool>::type = false>
-void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) {
-  a.swap(b);
-}
-
-// make_optional()
-//
-// Creates a non-empty `optional<T>` where the type of `T` is deduced. An
-// `absl::optional` can also be explicitly instantiated with
-// `make_optional<T>(v)`.
-//
-// Note: `make_optional()` constructions may be declared `constexpr` for
-// trivially copyable types `T`. Non-trivial types require copy elision
-// support in C++17 for `make_optional` to support `constexpr` on such
-// non-trivial types.
-//
-// Example:
-//
-//   constexpr absl::optional<int> opt = absl::make_optional(1);
-//   static_assert(opt.value() == 1, "");
-template <typename T>
-constexpr optional<typename std::decay<T>::type> make_optional(T&& v) {
-  return optional<typename std::decay<T>::type>(absl::forward<T>(v));
-}
-
-template <typename T, typename... Args>
-constexpr optional<T> make_optional(Args&&... args) {
-  return optional<T>(in_place_t(), absl::forward<Args>(args)...);
-}
-
-template <typename T, typename U, typename... Args>
-constexpr optional<T> make_optional(std::initializer_list<U> il,
-                                    Args&&... args) {
-  return optional<T>(in_place_t(), il,
-                     absl::forward<Args>(args)...);
-}
-
-// Relational operators [optional.relops]
-
-// Empty optionals are considered equal to each other and less than non-empty
-// optionals. Supports relations between optional<T> and optional<U>, between
-// optional<T> and U, and between optional<T> and nullopt.
-//
-// Note: We're careful to support T having non-bool relationals.
-
-// Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
-// shall be convertible to bool.
-// The C++17 (N4606) "Returns:" statements are translated into
-// code in an obvious way here, and the original text retained as function docs.
-// Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
-// otherwise *x == *y.
-template <typename T, typename U>
-constexpr auto operator==(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x == *y)) {
-  return static_cast<bool>(x) != static_cast<bool>(y)
-             ? false
-             : static_cast<bool>(x) == false ? true
-                                             : static_cast<bool>(*x == *y);
-}
-
-// Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
-// otherwise *x != *y.
-template <typename T, typename U>
-constexpr auto operator!=(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x != *y)) {
-  return static_cast<bool>(x) != static_cast<bool>(y)
-             ? true
-             : static_cast<bool>(x) == false ? false
-                                             : static_cast<bool>(*x != *y);
-}
-// Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
-template <typename T, typename U>
-constexpr auto operator<(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x < *y)) {
-  return !y ? false : !x ? true : static_cast<bool>(*x < *y);
-}
-// Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
-template <typename T, typename U>
-constexpr auto operator>(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x > *y)) {
-  return !x ? false : !y ? true : static_cast<bool>(*x > *y);
-}
-// Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
-template <typename T, typename U>
-constexpr auto operator<=(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x <= *y)) {
-  return !x ? true : !y ? false : static_cast<bool>(*x <= *y);
-}
-// Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
-template <typename T, typename U>
-constexpr auto operator>=(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x >= *y)) {
-  return !y ? true : !x ? false : static_cast<bool>(*x >= *y);
-}
-
-// Comparison with nullopt [optional.nullops]
-// The C++17 (N4606) "Returns:" statements are used directly here.
-template <typename T>
-constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept {
-  return !x;
-}
-template <typename T>
-constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept {
-  return !x;
-}
-template <typename T>
-constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept {
-  return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept {
-  return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
-  return false;
-}
-template <typename T>
-constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept {
-  return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept {
-  return !x;
-}
-template <typename T>
-constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
-  return true;
-}
-template <typename T>
-constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept {
-  return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
-  return false;
-}
-template <typename T>
-constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
-  return true;
-}
-template <typename T>
-constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept {
-  return !x;
-}
-
-// Comparison with T [optional.comp_with_t]
-
-// Requires: The expression, e.g. "*x == v" shall be well-formed and its result
-// shall be convertible to bool.
-// The C++17 (N4606) "Equivalent to:" statements are used directly here.
-template <typename T, typename U>
-constexpr auto operator==(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x == v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x == v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator==(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v == *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v == *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator!=(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x != v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x != v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator!=(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v != *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v != *x) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x < v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x < v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v < *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v < *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator<=(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x <= v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x <= v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<=(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v <= *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v <= *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x > v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x > v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v > *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v > *x) : true;
-}
-template <typename T, typename U>
-constexpr auto operator>=(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x >= v)) {
-  return static_cast<bool>(x) ? static_cast<bool>(*x >= v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>=(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v >= *x)) {
-  return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
-}
-
-ABSL_NAMESPACE_END
+        // optional::value_or()
+        //
+        // Returns either the value of `T` or a passed default `v` if the `optional`
+        // is empty.
+        template<typename U>
+        constexpr T value_or(U&& v) const&
+        {
+            static_assert(std::is_copy_constructible<value_type>::value, "optional<T>::value_or: T must be copy constructible");
+            static_assert(std::is_convertible<U&&, value_type>::value, "optional<T>::value_or: U must be convertible to T");
+            return static_cast<bool>(*this) ? **this : static_cast<T>(absl::forward<U>(v));
+        }
+        template<typename U>
+        T value_or(U&& v) &&
+        {  // NOLINT(build/c++11)
+            static_assert(std::is_move_constructible<value_type>::value, "optional<T>::value_or: T must be move constructible");
+            static_assert(std::is_convertible<U&&, value_type>::value, "optional<T>::value_or: U must be convertible to T");
+            return static_cast<bool>(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
+        }
+
+    private:
+        // Private accessors for internal storage viewed as reference to T.
+        constexpr const T& reference() const
+        {
+            return this->data_;
+        }
+        T& reference()
+        {
+            return this->data_;
+        }
+
+        // T constraint checks.  You can't have an optional of nullopt_t, in_place_t
+        // or a reference.
+        static_assert(
+            !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
+            "optional<nullopt_t> is not allowed."
+        );
+        static_assert(
+            !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
+            "optional<in_place_t> is not allowed."
+        );
+        static_assert(!std::is_reference<T>::value, "optional<reference> is not allowed.");
+    };
+
+    // Non-member functions
+
+    // swap()
+    //
+    // Performs a swap between two `absl::optional` objects, using standard
+    // semantics.
+    template<typename T, typename std::enable_if<std::is_move_constructible<T>::value && type_traits_internal::IsSwappable<T>::value, bool>::type = false>
+    void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b)))
+    {
+        a.swap(b);
+    }
+
+    // make_optional()
+    //
+    // Creates a non-empty `optional<T>` where the type of `T` is deduced. An
+    // `absl::optional` can also be explicitly instantiated with
+    // `make_optional<T>(v)`.
+    //
+    // Note: `make_optional()` constructions may be declared `constexpr` for
+    // trivially copyable types `T`. Non-trivial types require copy elision
+    // support in C++17 for `make_optional` to support `constexpr` on such
+    // non-trivial types.
+    //
+    // Example:
+    //
+    //   constexpr absl::optional<int> opt = absl::make_optional(1);
+    //   static_assert(opt.value() == 1, "");
+    template<typename T>
+    constexpr optional<typename std::decay<T>::type> make_optional(T&& v)
+    {
+        return optional<typename std::decay<T>::type>(absl::forward<T>(v));
+    }
+
+    template<typename T, typename... Args>
+    constexpr optional<T> make_optional(Args&&... args)
+    {
+        return optional<T>(in_place_t(), absl::forward<Args>(args)...);
+    }
+
+    template<typename T, typename U, typename... Args>
+    constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args)
+    {
+        return optional<T>(in_place_t(), il, absl::forward<Args>(args)...);
+    }
+
+    // Relational operators [optional.relops]
+
+    // Empty optionals are considered equal to each other and less than non-empty
+    // optionals. Supports relations between optional<T> and optional<U>, between
+    // optional<T> and U, and between optional<T> and nullopt.
+    //
+    // Note: We're careful to support T having non-bool relationals.
+
+    // Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
+    // shall be convertible to bool.
+    // The C++17 (N4606) "Returns:" statements are translated into
+    // code in an obvious way here, and the original text retained as function docs.
+    // Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
+    // otherwise *x == *y.
+    template<typename T, typename U>
+    constexpr auto operator==(const optional<T>& x, const optional<U>& y)
+        -> decltype(optional_internal::convertible_to_bool(*x == *y))
+    {
+        return static_cast<bool>(x) != static_cast<bool>(y) ? false : static_cast<bool>(x) == false ? true :
+                                                                                                      static_cast<bool>(*x == *y);
+    }
+
+    // Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
+    // otherwise *x != *y.
+    template<typename T, typename U>
+    constexpr auto operator!=(const optional<T>& x, const optional<U>& y)
+        -> decltype(optional_internal::convertible_to_bool(*x != *y))
+    {
+        return static_cast<bool>(x) != static_cast<bool>(y) ? true : static_cast<bool>(x) == false ? false :
+                                                                                                     static_cast<bool>(*x != *y);
+    }
+    // Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
+    template<typename T, typename U>
+    constexpr auto operator<(const optional<T>& x, const optional<U>& y)
+        -> decltype(optional_internal::convertible_to_bool(*x < *y))
+    {
+        return !y ? false : !x ? true :
+                                 static_cast<bool>(*x < *y);
+    }
+    // Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
+    template<typename T, typename U>
+    constexpr auto operator>(const optional<T>& x, const optional<U>& y)
+        -> decltype(optional_internal::convertible_to_bool(*x > *y))
+    {
+        return !x ? false : !y ? true :
+                                 static_cast<bool>(*x > *y);
+    }
+    // Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
+    template<typename T, typename U>
+    constexpr auto operator<=(const optional<T>& x, const optional<U>& y)
+        -> decltype(optional_internal::convertible_to_bool(*x <= *y))
+    {
+        return !x ? true : !y ? false :
+                                static_cast<bool>(*x <= *y);
+    }
+    // Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
+    template<typename T, typename U>
+    constexpr auto operator>=(const optional<T>& x, const optional<U>& y)
+        -> decltype(optional_internal::convertible_to_bool(*x >= *y))
+    {
+        return !y ? true : !x ? false :
+                                static_cast<bool>(*x >= *y);
+    }
+
+    // Comparison with nullopt [optional.nullops]
+    // The C++17 (N4606) "Returns:" statements are used directly here.
+    template<typename T>
+    constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
+    {
+        return !x;
+    }
+    template<typename T>
+    constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
+    {
+        return !x;
+    }
+    template<typename T>
+    constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
+    {
+        return static_cast<bool>(x);
+    }
+    template<typename T>
+    constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
+    {
+        return static_cast<bool>(x);
+    }
+    template<typename T>
+    constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
+    {
+        return false;
+    }
+    template<typename T>
+    constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
+    {
+        return static_cast<bool>(x);
+    }
+    template<typename T>
+    constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
+    {
+        return !x;
+    }
+    template<typename T>
+    constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
+    {
+        return true;
+    }
+    template<typename T>
+    constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
+    {
+        return static_cast<bool>(x);
+    }
+    template<typename T>
+    constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
+    {
+        return false;
+    }
+    template<typename T>
+    constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
+    {
+        return true;
+    }
+    template<typename T>
+    constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
+    {
+        return !x;
+    }
+
+    // Comparison with T [optional.comp_with_t]
+
+    // Requires: The expression, e.g. "*x == v" shall be well-formed and its result
+    // shall be convertible to bool.
+    // The C++17 (N4606) "Equivalent to:" statements are used directly here.
+    template<typename T, typename U>
+    constexpr auto operator==(const optional<T>& x, const U& v)
+        -> decltype(optional_internal::convertible_to_bool(*x == v))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(*x == v) : false;
+    }
+    template<typename T, typename U>
+    constexpr auto operator==(const U& v, const optional<T>& x)
+        -> decltype(optional_internal::convertible_to_bool(v == *x))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(v == *x) : false;
+    }
+    template<typename T, typename U>
+    constexpr auto operator!=(const optional<T>& x, const U& v)
+        -> decltype(optional_internal::convertible_to_bool(*x != v))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(*x != v) : true;
+    }
+    template<typename T, typename U>
+    constexpr auto operator!=(const U& v, const optional<T>& x)
+        -> decltype(optional_internal::convertible_to_bool(v != *x))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(v != *x) : true;
+    }
+    template<typename T, typename U>
+    constexpr auto operator<(const optional<T>& x, const U& v)
+        -> decltype(optional_internal::convertible_to_bool(*x < v))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(*x < v) : true;
+    }
+    template<typename T, typename U>
+    constexpr auto operator<(const U& v, const optional<T>& x)
+        -> decltype(optional_internal::convertible_to_bool(v < *x))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(v < *x) : false;
+    }
+    template<typename T, typename U>
+    constexpr auto operator<=(const optional<T>& x, const U& v)
+        -> decltype(optional_internal::convertible_to_bool(*x <= v))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(*x <= v) : true;
+    }
+    template<typename T, typename U>
+    constexpr auto operator<=(const U& v, const optional<T>& x)
+        -> decltype(optional_internal::convertible_to_bool(v <= *x))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(v <= *x) : false;
+    }
+    template<typename T, typename U>
+    constexpr auto operator>(const optional<T>& x, const U& v)
+        -> decltype(optional_internal::convertible_to_bool(*x > v))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(*x > v) : false;
+    }
+    template<typename T, typename U>
+    constexpr auto operator>(const U& v, const optional<T>& x)
+        -> decltype(optional_internal::convertible_to_bool(v > *x))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(v > *x) : true;
+    }
+    template<typename T, typename U>
+    constexpr auto operator>=(const optional<T>& x, const U& v)
+        -> decltype(optional_internal::convertible_to_bool(*x >= v))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(*x >= v) : false;
+    }
+    template<typename T, typename U>
+    constexpr auto operator>=(const U& v, const optional<T>& x)
+        -> decltype(optional_internal::convertible_to_bool(v >= *x))
+    {
+        return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
-namespace std {
+namespace std
+{
 
-// std::hash specialization for absl::optional.
-template <typename T>
-struct hash<absl::optional<T> >
-    : absl::optional_internal::optional_hash_base<T> {};
+    // std::hash specialization for absl::optional.
+    template<typename T>
+    struct hash<absl::optional<T>> : absl::optional_internal::optional_hash_base<T>
+    {
+    };
 
 }  // namespace std
 
diff --git a/CAPI/cpp/grpc/include/absl/types/span.h b/CAPI/cpp/grpc/include/absl/types/span.h
index fdfbd77..1e09225 100644
--- a/CAPI/cpp/grpc/include/absl/types/span.h
+++ b/CAPI/cpp/grpc/include/absl/types/span.h
@@ -63,665 +63,772 @@
 #include "absl/base/internal/throw_delegate.h"
 #include "absl/base/macros.h"
 #include "absl/base/optimization.h"
-#include "absl/base/port.h"    // TODO(strel): remove this include
+#include "absl/base/port.h"  // TODO(strel): remove this include
 #include "absl/meta/type_traits.h"
 #include "absl/types/internal/span.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-//------------------------------------------------------------------------------
-// Span
-//------------------------------------------------------------------------------
-//
-// A `Span` is an "array reference" type for holding a reference of contiguous
-// array data; the `Span` object does not and cannot own such data itself. A
-// span provides an easy way to provide overloads for anything operating on
-// contiguous sequences without needing to manage pointers and array lengths
-// manually.
-
-// A span is conceptually a pointer (ptr) and a length (size) into an already
-// existing array of contiguous memory; the array it represents references the
-// elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span`
-// instead of raw pointers avoids many issues related to index out of bounds
-// errors.
-//
-// Spans may also be constructed from containers holding contiguous sequences.
-// Such containers must supply `data()` and `size() const` methods (e.g
-// `std::vector<T>`, `absl::InlinedVector<T, N>`). All implicit conversions to
-// `absl::Span` from such containers will create spans of type `const T`;
-// spans which can mutate their values (of type `T`) must use explicit
-// constructors.
-//
-// A `Span<T>` is somewhat analogous to an `absl::string_view`, but for an array
-// of elements of type `T`, and unlike an `absl::string_view`, a span can hold a
-// reference to mutable data. A user of `Span` must ensure that the data being
-// pointed to outlives the `Span` itself.
-//
-// You can construct a `Span<T>` in several ways:
-//
-//   * Explicitly from a reference to a container type
-//   * Explicitly from a pointer and size
-//   * Implicitly from a container type (but only for spans of type `const T`)
-//   * Using the `MakeSpan()` or `MakeConstSpan()` factory functions.
-//
-// Examples:
-//
-//   // Construct a Span explicitly from a container:
-//   std::vector<int> v = {1, 2, 3, 4, 5};
-//   auto span = absl::Span<const int>(v);
-//
-//   // Construct a Span explicitly from a C-style array:
-//   int a[5] =  {1, 2, 3, 4, 5};
-//   auto span = absl::Span<const int>(a);
-//
-//   // Construct a Span implicitly from a container
-//   void MyRoutine(absl::Span<const int> a) {
-//     ...
-//   }
-//   std::vector v = {1,2,3,4,5};
-//   MyRoutine(v)                     // convert to Span<const T>
-//
-// Note that `Span` objects, in addition to requiring that the memory they
-// point to remains alive, must also ensure that such memory does not get
-// reallocated. Therefore, to avoid undefined behavior, containers with
-// associated spans should not invoke operations that may reallocate memory
-// (such as resizing) or invalidate iterators into the container.
-//
-// One common use for a `Span` is when passing arguments to a routine that can
-// accept a variety of array types (e.g. a `std::vector`, `absl::InlinedVector`,
-// a C-style array, etc.). Instead of creating overloads for each case, you
-// can simply specify a `Span` as the argument to such a routine.
-//
-// Example:
-//
-//   void MyRoutine(absl::Span<const int> a) {
-//     ...
-//   }
-//
-//   std::vector v = {1,2,3,4,5};
-//   MyRoutine(v);
-//
-//   absl::InlinedVector<int, 4> my_inline_vector;
-//   MyRoutine(my_inline_vector);
-//
-//   // Explicit constructor from pointer,size
-//   int* my_array = new int[10];
-//   MyRoutine(absl::Span<const int>(my_array, 10));
-template <typename T>
-class Span {
- private:
-  // Used to determine whether a Span can be constructed from a container of
-  // type C.
-  template <typename C>
-  using EnableIfConvertibleFrom =
-      typename std::enable_if<span_internal::HasData<T, C>::value &&
-                              span_internal::HasSize<C>::value>::type;
-
-  // Used to SFINAE-enable a function when the slice elements are const.
-  template <typename U>
-  using EnableIfConstView =
-      typename std::enable_if<std::is_const<T>::value, U>::type;
-
-  // Used to SFINAE-enable a function when the slice elements are mutable.
-  template <typename U>
-  using EnableIfMutableView =
-      typename std::enable_if<!std::is_const<T>::value, U>::type;
-
- public:
-  using element_type = T;
-  using value_type = absl::remove_cv_t<T>;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using reference = T&;
-  using const_reference = const T&;
-  using iterator = pointer;
-  using const_iterator = const_pointer;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-
-  static const size_type npos = ~(size_type(0));
-
-  constexpr Span() noexcept : Span(nullptr, 0) {}
-  constexpr Span(pointer array, size_type length) noexcept
-      : ptr_(array), len_(length) {}
-
-  // Implicit conversion constructors
-  template <size_t N>
-  constexpr Span(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
-      : Span(a, N) {}
-
-  // Explicit reference constructor for a mutable `Span<T>` type. Can be
-  // replaced with MakeSpan() to infer the type parameter.
-  template <typename V, typename = EnableIfConvertibleFrom<V>,
-            typename = EnableIfMutableView<V>>
-  explicit Span(V& v) noexcept  // NOLINT(runtime/references)
-      : Span(span_internal::GetData(v), v.size()) {}
-
-  // Implicit reference constructor for a read-only `Span<const T>` type
-  template <typename V, typename = EnableIfConvertibleFrom<V>,
-            typename = EnableIfConstView<V>>
-  constexpr Span(const V& v) noexcept  // NOLINT(runtime/explicit)
-      : Span(span_internal::GetData(v), v.size()) {}
-
-  // Implicit constructor from an initializer list, making it possible to pass a
-  // brace-enclosed initializer list to a function expecting a `Span`. Such
-  // spans constructed from an initializer list must be of type `Span<const T>`.
-  //
-  //   void Process(absl::Span<const int> x);
-  //   Process({1, 2, 3});
-  //
-  // Note that as always the array referenced by the span must outlive the span.
-  // Since an initializer list constructor acts as if it is fed a temporary
-  // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this
-  // constructor only when the `std::initializer_list` itself outlives the span.
-  // In order to meet this requirement it's sufficient to ensure that neither
-  // the span nor a copy of it is used outside of the expression in which it's
-  // created:
-  //
-  //   // Assume that this function uses the array directly, not retaining any
-  //   // copy of the span or pointer to any of its elements.
-  //   void Process(absl::Span<const int> ints);
-  //
-  //   // Okay: the std::initializer_list<int> will reference a temporary array
-  //   // that isn't destroyed until after the call to Process returns.
-  //   Process({ 17, 19 });
-  //
-  //   // Not okay: the storage used by the std::initializer_list<int> is not
-  //   // allowed to be referenced after the first line.
-  //   absl::Span<const int> ints = { 17, 19 };
-  //   Process(ints);
-  //
-  //   // Not okay for the same reason as above: even when the elements of the
-  //   // initializer list expression are not temporaries the underlying array
-  //   // is, so the initializer list must still outlive the span.
-  //   const int foo = 17;
-  //   absl::Span<const int> ints = { foo };
-  //   Process(ints);
-  //
-  template <typename LazyT = T,
-            typename = EnableIfConstView<LazyT>>
-  Span(std::initializer_list<value_type> v
-           ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept  // NOLINT(runtime/explicit)
-      : Span(v.begin(), v.size()) {}
-
-  // Accessors
-
-  // Span::data()
-  //
-  // Returns a pointer to the span's underlying array of data (which is held
-  // outside the span).
-  constexpr pointer data() const noexcept { return ptr_; }
-
-  // Span::size()
-  //
-  // Returns the size of this span.
-  constexpr size_type size() const noexcept { return len_; }
-
-  // Span::length()
-  //
-  // Returns the length (size) of this span.
-  constexpr size_type length() const noexcept { return size(); }
-
-  // Span::empty()
-  //
-  // Returns a boolean indicating whether or not this span is considered empty.
-  constexpr bool empty() const noexcept { return size() == 0; }
-
-  // Span::operator[]
-  //
-  // Returns a reference to the i'th element of this span.
-  constexpr reference operator[](size_type i) const noexcept {
-    // MSVC 2015 accepts this as constexpr, but not ptr_[i]
-    return ABSL_HARDENING_ASSERT(i < size()), *(data() + i);
-  }
-
-  // Span::at()
-  //
-  // Returns a reference to the i'th element of this span.
-  constexpr reference at(size_type i) const {
-    return ABSL_PREDICT_TRUE(i < size())  //
-               ? *(data() + i)
-               : (base_internal::ThrowStdOutOfRange(
-                      "Span::at failed bounds check"),
-                  *(data() + i));
-  }
-
-  // Span::front()
-  //
-  // Returns a reference to the first element of this span. The span must not
-  // be empty.
-  constexpr reference front() const noexcept {
-    return ABSL_HARDENING_ASSERT(size() > 0), *data();
-  }
-
-  // Span::back()
-  //
-  // Returns a reference to the last element of this span. The span must not
-  // be empty.
-  constexpr reference back() const noexcept {
-    return ABSL_HARDENING_ASSERT(size() > 0), *(data() + size() - 1);
-  }
-
-  // Span::begin()
-  //
-  // Returns an iterator pointing to the first element of this span, or `end()`
-  // if the span is empty.
-  constexpr iterator begin() const noexcept { return data(); }
-
-  // Span::cbegin()
-  //
-  // Returns a const iterator pointing to the first element of this span, or
-  // `end()` if the span is empty.
-  constexpr const_iterator cbegin() const noexcept { return begin(); }
-
-  // Span::end()
-  //
-  // Returns an iterator pointing just beyond the last element at the
-  // end of this span. This iterator acts as a placeholder; attempting to
-  // access it results in undefined behavior.
-  constexpr iterator end() const noexcept { return data() + size(); }
-
-  // Span::cend()
-  //
-  // Returns a const iterator pointing just beyond the last element at the
-  // end of this span. This iterator acts as a placeholder; attempting to
-  // access it results in undefined behavior.
-  constexpr const_iterator cend() const noexcept { return end(); }
-
-  // Span::rbegin()
-  //
-  // Returns a reverse iterator pointing to the last element at the end of this
-  // span, or `rend()` if the span is empty.
-  constexpr reverse_iterator rbegin() const noexcept {
-    return reverse_iterator(end());
-  }
-
-  // Span::crbegin()
-  //
-  // Returns a const reverse iterator pointing to the last element at the end of
-  // this span, or `crend()` if the span is empty.
-  constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
-
-  // Span::rend()
-  //
-  // Returns a reverse iterator pointing just before the first element
-  // at the beginning of this span. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
-  constexpr reverse_iterator rend() const noexcept {
-    return reverse_iterator(begin());
-  }
-
-  // Span::crend()
-  //
-  // Returns a reverse const iterator pointing just before the first element
-  // at the beginning of this span. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
-  constexpr const_reverse_iterator crend() const noexcept { return rend(); }
-
-  // Span mutations
-
-  // Span::remove_prefix()
-  //
-  // Removes the first `n` elements from the span.
-  void remove_prefix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
-    ptr_ += n;
-    len_ -= n;
-  }
-
-  // Span::remove_suffix()
-  //
-  // Removes the last `n` elements from the span.
-  void remove_suffix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
-    len_ -= n;
-  }
-
-  // Span::subspan()
-  //
-  // Returns a `Span` starting at element `pos` and of length `len`. Both `pos`
-  // and `len` are of type `size_type` and thus non-negative. Parameter `pos`
-  // must be <= size(). Any `len` value that points past the end of the span
-  // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
-  // ensures the returned subspan continues until the end of the span.
-  //
-  // Examples:
-  //
-  //   std::vector<int> vec = {10, 11, 12, 13};
-  //   absl::MakeSpan(vec).subspan(1, 2);  // {11, 12}
-  //   absl::MakeSpan(vec).subspan(2, 8);  // {12, 13}
-  //   absl::MakeSpan(vec).subspan(1);     // {11, 12, 13}
-  //   absl::MakeSpan(vec).subspan(4);     // {}
-  //   absl::MakeSpan(vec).subspan(5);     // throws std::out_of_range
-  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
-    return (pos <= size())
-               ? Span(data() + pos, span_internal::Min(size() - pos, len))
-               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
-  }
-
-  // Span::first()
-  //
-  // Returns a `Span` containing first `len` elements. Parameter `len` is of
-  // type `size_type` and thus non-negative. `len` value must be <= size().
-  //
-  // Examples:
-  //
-  //   std::vector<int> vec = {10, 11, 12, 13};
-  //   absl::MakeSpan(vec).first(1);  // {10}
-  //   absl::MakeSpan(vec).first(3);  // {10, 11, 12}
-  //   absl::MakeSpan(vec).first(5);  // throws std::out_of_range
-  constexpr Span first(size_type len) const {
-    return (len <= size())
-               ? Span(data(), len)
-               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
-  }
-
-  // Span::last()
-  //
-  // Returns a `Span` containing last `len` elements. Parameter `len` is of
-  // type `size_type` and thus non-negative. `len` value must be <= size().
-  //
-  // Examples:
-  //
-  //   std::vector<int> vec = {10, 11, 12, 13};
-  //   absl::MakeSpan(vec).last(1);  // {13}
-  //   absl::MakeSpan(vec).last(3);  // {11, 12, 13}
-  //   absl::MakeSpan(vec).last(5);  // throws std::out_of_range
-  constexpr Span last(size_type len) const {
-    return (len <= size())
-               ? Span(size() - len + data(), len)
-               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
-  }
-
-  // Support for absl::Hash.
-  template <typename H>
-  friend H AbslHashValue(H h, Span v) {
-    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
-                      v.size());
-  }
-
- private:
-  pointer ptr_;
-  size_type len_;
-};
-
-template <typename T>
-const typename Span<T>::size_type Span<T>::npos;
-
-// Span relationals
-
-// Equality is compared element-by-element, while ordering is lexicographical.
-// We provide three overloads for each operator to cover any combination on the
-// left or right hand side of mutable Span<T>, read-only Span<const T>, and
-// convertible-to-read-only Span<T>.
-// TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering
-// template functions, 5 overloads per operator is needed as a workaround. We
-// should update them to 3 overloads per operator using non-deduced context like
-// string_view, i.e.
-// - (Span<T>, Span<T>)
-// - (Span<T>, non_deduced<Span<const T>>)
-// - (non_deduced<Span<const T>>, Span<T>)
-
-// operator==
-template <typename T>
-bool operator==(Span<T> a, Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-template <typename T>
-bool operator==(Span<const T> a, Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-template <typename T>
-bool operator==(Span<T> a, Span<const T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator==(const U& a, Span<T> b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator==(Span<T> a, const U& b) {
-  return span_internal::EqualImpl<Span, const T>(a, b);
-}
-
-// operator!=
-template <typename T>
-bool operator!=(Span<T> a, Span<T> b) {
-  return !(a == b);
-}
-template <typename T>
-bool operator!=(Span<const T> a, Span<T> b) {
-  return !(a == b);
-}
-template <typename T>
-bool operator!=(Span<T> a, Span<const T> b) {
-  return !(a == b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator!=(const U& a, Span<T> b) {
-  return !(a == b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator!=(Span<T> a, const U& b) {
-  return !(a == b);
-}
-
-// operator<
-template <typename T>
-bool operator<(Span<T> a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-template <typename T>
-bool operator<(Span<const T> a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-template <typename T>
-bool operator<(Span<T> a, Span<const T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator<(const U& a, Span<T> b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator<(Span<T> a, const U& b) {
-  return span_internal::LessThanImpl<Span, const T>(a, b);
-}
-
-// operator>
-template <typename T>
-bool operator>(Span<T> a, Span<T> b) {
-  return b < a;
-}
-template <typename T>
-bool operator>(Span<const T> a, Span<T> b) {
-  return b < a;
-}
-template <typename T>
-bool operator>(Span<T> a, Span<const T> b) {
-  return b < a;
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator>(const U& a, Span<T> b) {
-  return b < a;
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator>(Span<T> a, const U& b) {
-  return b < a;
-}
-
-// operator<=
-template <typename T>
-bool operator<=(Span<T> a, Span<T> b) {
-  return !(b < a);
-}
-template <typename T>
-bool operator<=(Span<const T> a, Span<T> b) {
-  return !(b < a);
-}
-template <typename T>
-bool operator<=(Span<T> a, Span<const T> b) {
-  return !(b < a);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator<=(const U& a, Span<T> b) {
-  return !(b < a);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator<=(Span<T> a, const U& b) {
-  return !(b < a);
-}
-
-// operator>=
-template <typename T>
-bool operator>=(Span<T> a, Span<T> b) {
-  return !(a < b);
-}
-template <typename T>
-bool operator>=(Span<const T> a, Span<T> b) {
-  return !(a < b);
-}
-template <typename T>
-bool operator>=(Span<T> a, Span<const T> b) {
-  return !(a < b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator>=(const U& a, Span<T> b) {
-  return !(a < b);
-}
-template <
-    typename T, typename U,
-    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
-bool operator>=(Span<T> a, const U& b) {
-  return !(a < b);
-}
-
-// MakeSpan()
-//
-// Constructs a mutable `Span<T>`, deducing `T` automatically from either a
-// container or pointer+size.
-//
-// Because a read-only `Span<const T>` is implicitly constructed from container
-// types regardless of whether the container itself is a const container,
-// constructing mutable spans of type `Span<T>` from containers requires
-// explicit constructors. The container-accepting version of `MakeSpan()`
-// deduces the type of `T` by the constness of the pointer received from the
-// container's `data()` member. Similarly, the pointer-accepting version returns
-// a `Span<const T>` if `T` is `const`, and a `Span<T>` otherwise.
-//
-// Examples:
-//
-//   void MyRoutine(absl::Span<MyComplicatedType> a) {
-//     ...
-//   };
-//   // my_vector is a container of non-const types
-//   std::vector<MyComplicatedType> my_vector;
-//
-//   // Constructing a Span implicitly attempts to create a Span of type
-//   // `Span<const T>`
-//   MyRoutine(my_vector);                // error, type mismatch
-//
-//   // Explicitly constructing the Span is verbose
-//   MyRoutine(absl::Span<MyComplicatedType>(my_vector));
-//
-//   // Use MakeSpan() to make an absl::Span<T>
-//   MyRoutine(absl::MakeSpan(my_vector));
-//
-//   // Construct a span from an array ptr+size
-//   absl::Span<T> my_span() {
-//     return absl::MakeSpan(&array[0], num_elements_);
-//   }
-//
-template <int&... ExplicitArgumentBarrier, typename T>
-constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept {
-  return Span<T>(ptr, size);
-}
-
-template <int&... ExplicitArgumentBarrier, typename T>
-Span<T> MakeSpan(T* begin, T* end) noexcept {
-  return ABSL_HARDENING_ASSERT(begin <= end),
-         Span<T>(begin, static_cast<size_t>(end - begin));
-}
-
-template <int&... ExplicitArgumentBarrier, typename C>
-constexpr auto MakeSpan(C& c) noexcept  // NOLINT(runtime/references)
-    -> decltype(absl::MakeSpan(span_internal::GetData(c), c.size())) {
-  return MakeSpan(span_internal::GetData(c), c.size());
-}
-
-template <int&... ExplicitArgumentBarrier, typename T, size_t N>
-constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
-  return Span<T>(array, N);
-}
-
-// MakeConstSpan()
-//
-// Constructs a `Span<const T>` as with `MakeSpan`, deducing `T` automatically,
-// but always returning a `Span<const T>`.
-//
-// Examples:
-//
-//   void ProcessInts(absl::Span<const int> some_ints);
-//
-//   // Call with a pointer and size.
-//   int array[3] = { 0, 0, 0 };
-//   ProcessInts(absl::MakeConstSpan(&array[0], 3));
-//
-//   // Call with a [begin, end) pair.
-//   ProcessInts(absl::MakeConstSpan(&array[0], &array[3]));
-//
-//   // Call directly with an array.
-//   ProcessInts(absl::MakeConstSpan(array));
-//
-//   // Call with a contiguous container.
-//   std::vector<int> some_ints = ...;
-//   ProcessInts(absl::MakeConstSpan(some_ints));
-//   ProcessInts(absl::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
-//
-template <int&... ExplicitArgumentBarrier, typename T>
-constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept {
-  return Span<const T>(ptr, size);
-}
-
-template <int&... ExplicitArgumentBarrier, typename T>
-Span<const T> MakeConstSpan(T* begin, T* end) noexcept {
-  return ABSL_HARDENING_ASSERT(begin <= end), Span<const T>(begin, end - begin);
-}
-
-template <int&... ExplicitArgumentBarrier, typename C>
-constexpr auto MakeConstSpan(const C& c) noexcept -> decltype(MakeSpan(c)) {
-  return MakeSpan(c);
-}
-
-template <int&... ExplicitArgumentBarrier, typename T, size_t N>
-constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
-  return Span<const T>(array, N);
-}
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    //------------------------------------------------------------------------------
+    // Span
+    //------------------------------------------------------------------------------
+    //
+    // A `Span` is an "array reference" type for holding a reference of contiguous
+    // array data; the `Span` object does not and cannot own such data itself. A
+    // span provides an easy way to provide overloads for anything operating on
+    // contiguous sequences without needing to manage pointers and array lengths
+    // manually.
+
+    // A span is conceptually a pointer (ptr) and a length (size) into an already
+    // existing array of contiguous memory; the array it represents references the
+    // elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span`
+    // instead of raw pointers avoids many issues related to index out of bounds
+    // errors.
+    //
+    // Spans may also be constructed from containers holding contiguous sequences.
+    // Such containers must supply `data()` and `size() const` methods (e.g
+    // `std::vector<T>`, `absl::InlinedVector<T, N>`). All implicit conversions to
+    // `absl::Span` from such containers will create spans of type `const T`;
+    // spans which can mutate their values (of type `T`) must use explicit
+    // constructors.
+    //
+    // A `Span<T>` is somewhat analogous to an `absl::string_view`, but for an array
+    // of elements of type `T`, and unlike an `absl::string_view`, a span can hold a
+    // reference to mutable data. A user of `Span` must ensure that the data being
+    // pointed to outlives the `Span` itself.
+    //
+    // You can construct a `Span<T>` in several ways:
+    //
+    //   * Explicitly from a reference to a container type
+    //   * Explicitly from a pointer and size
+    //   * Implicitly from a container type (but only for spans of type `const T`)
+    //   * Using the `MakeSpan()` or `MakeConstSpan()` factory functions.
+    //
+    // Examples:
+    //
+    //   // Construct a Span explicitly from a container:
+    //   std::vector<int> v = {1, 2, 3, 4, 5};
+    //   auto span = absl::Span<const int>(v);
+    //
+    //   // Construct a Span explicitly from a C-style array:
+    //   int a[5] =  {1, 2, 3, 4, 5};
+    //   auto span = absl::Span<const int>(a);
+    //
+    //   // Construct a Span implicitly from a container
+    //   void MyRoutine(absl::Span<const int> a) {
+    //     ...
+    //   }
+    //   std::vector v = {1,2,3,4,5};
+    //   MyRoutine(v)                     // convert to Span<const T>
+    //
+    // Note that `Span` objects, in addition to requiring that the memory they
+    // point to remains alive, must also ensure that such memory does not get
+    // reallocated. Therefore, to avoid undefined behavior, containers with
+    // associated spans should not invoke operations that may reallocate memory
+    // (such as resizing) or invalidate iterators into the container.
+    //
+    // One common use for a `Span` is when passing arguments to a routine that can
+    // accept a variety of array types (e.g. a `std::vector`, `absl::InlinedVector`,
+    // a C-style array, etc.). Instead of creating overloads for each case, you
+    // can simply specify a `Span` as the argument to such a routine.
+    //
+    // Example:
+    //
+    //   void MyRoutine(absl::Span<const int> a) {
+    //     ...
+    //   }
+    //
+    //   std::vector v = {1,2,3,4,5};
+    //   MyRoutine(v);
+    //
+    //   absl::InlinedVector<int, 4> my_inline_vector;
+    //   MyRoutine(my_inline_vector);
+    //
+    //   // Explicit constructor from pointer,size
+    //   int* my_array = new int[10];
+    //   MyRoutine(absl::Span<const int>(my_array, 10));
+    template<typename T>
+    class Span
+    {
+    private:
+        // Used to determine whether a Span can be constructed from a container of
+        // type C.
+        template<typename C>
+        using EnableIfConvertibleFrom =
+            typename std::enable_if<span_internal::HasData<T, C>::value && span_internal::HasSize<C>::value>::type;
+
+        // Used to SFINAE-enable a function when the slice elements are const.
+        template<typename U>
+        using EnableIfConstView =
+            typename std::enable_if<std::is_const<T>::value, U>::type;
+
+        // Used to SFINAE-enable a function when the slice elements are mutable.
+        template<typename U>
+        using EnableIfMutableView =
+            typename std::enable_if<!std::is_const<T>::value, U>::type;
+
+    public:
+        using element_type = T;
+        using value_type = absl::remove_cv_t<T>;
+        using pointer = T*;
+        using const_pointer = const T*;
+        using reference = T&;
+        using const_reference = const T&;
+        using iterator = pointer;
+        using const_iterator = const_pointer;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        using size_type = size_t;
+        using difference_type = ptrdiff_t;
+
+        static const size_type npos = ~(size_type(0));
+
+        constexpr Span() noexcept :
+            Span(nullptr, 0)
+        {
+        }
+        constexpr Span(pointer array, size_type length) noexcept
+            :
+            ptr_(array),
+            len_(length)
+        {
+        }
+
+        // Implicit conversion constructors
+        template<size_t N>
+        constexpr Span(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
+            :
+            Span(a, N)
+        {
+        }
+
+        // Explicit reference constructor for a mutable `Span<T>` type. Can be
+        // replaced with MakeSpan() to infer the type parameter.
+        template<typename V, typename = EnableIfConvertibleFrom<V>,
+                 typename = EnableIfMutableView<V>>
+        explicit Span(V& v) noexcept  // NOLINT(runtime/references)
+            :
+            Span(span_internal::GetData(v), v.size())
+        {
+        }
+
+        // Implicit reference constructor for a read-only `Span<const T>` type
+        template<typename V, typename = EnableIfConvertibleFrom<V>,
+                 typename = EnableIfConstView<V>>
+        constexpr Span(const V& v) noexcept  // NOLINT(runtime/explicit)
+            :
+            Span(span_internal::GetData(v), v.size())
+        {
+        }
+
+        // Implicit constructor from an initializer list, making it possible to pass a
+        // brace-enclosed initializer list to a function expecting a `Span`. Such
+        // spans constructed from an initializer list must be of type `Span<const T>`.
+        //
+        //   void Process(absl::Span<const int> x);
+        //   Process({1, 2, 3});
+        //
+        // Note that as always the array referenced by the span must outlive the span.
+        // Since an initializer list constructor acts as if it is fed a temporary
+        // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this
+        // constructor only when the `std::initializer_list` itself outlives the span.
+        // In order to meet this requirement it's sufficient to ensure that neither
+        // the span nor a copy of it is used outside of the expression in which it's
+        // created:
+        //
+        //   // Assume that this function uses the array directly, not retaining any
+        //   // copy of the span or pointer to any of its elements.
+        //   void Process(absl::Span<const int> ints);
+        //
+        //   // Okay: the std::initializer_list<int> will reference a temporary array
+        //   // that isn't destroyed until after the call to Process returns.
+        //   Process({ 17, 19 });
+        //
+        //   // Not okay: the storage used by the std::initializer_list<int> is not
+        //   // allowed to be referenced after the first line.
+        //   absl::Span<const int> ints = { 17, 19 };
+        //   Process(ints);
+        //
+        //   // Not okay for the same reason as above: even when the elements of the
+        //   // initializer list expression are not temporaries the underlying array
+        //   // is, so the initializer list must still outlive the span.
+        //   const int foo = 17;
+        //   absl::Span<const int> ints = { foo };
+        //   Process(ints);
+        //
+        template<typename LazyT = T,
+                 typename = EnableIfConstView<LazyT>>
+        Span(std::initializer_list<value_type> v
+                 ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept  // NOLINT(runtime/explicit)
+            :
+            Span(v.begin(), v.size())
+        {
+        }
+
+        // Accessors
+
+        // Span::data()
+        //
+        // Returns a pointer to the span's underlying array of data (which is held
+        // outside the span).
+        constexpr pointer data() const noexcept
+        {
+            return ptr_;
+        }
+
+        // Span::size()
+        //
+        // Returns the size of this span.
+        constexpr size_type size() const noexcept
+        {
+            return len_;
+        }
+
+        // Span::length()
+        //
+        // Returns the length (size) of this span.
+        constexpr size_type length() const noexcept
+        {
+            return size();
+        }
+
+        // Span::empty()
+        //
+        // Returns a boolean indicating whether or not this span is considered empty.
+        constexpr bool empty() const noexcept
+        {
+            return size() == 0;
+        }
+
+        // Span::operator[]
+        //
+        // Returns a reference to the i'th element of this span.
+        constexpr reference operator[](size_type i) const noexcept
+        {
+            // MSVC 2015 accepts this as constexpr, but not ptr_[i]
+            return ABSL_HARDENING_ASSERT(i < size()), *(data() + i);
+        }
+
+        // Span::at()
+        //
+        // Returns a reference to the i'th element of this span.
+        constexpr reference at(size_type i) const
+        {
+            return ABSL_PREDICT_TRUE(i < size())  //
+                       ?
+                       *(data() + i) :
+                       (base_internal::ThrowStdOutOfRange(
+                            "Span::at failed bounds check"
+                        ),
+                        *(data() + i));
+        }
+
+        // Span::front()
+        //
+        // Returns a reference to the first element of this span. The span must not
+        // be empty.
+        constexpr reference front() const noexcept
+        {
+            return ABSL_HARDENING_ASSERT(size() > 0), *data();
+        }
+
+        // Span::back()
+        //
+        // Returns a reference to the last element of this span. The span must not
+        // be empty.
+        constexpr reference back() const noexcept
+        {
+            return ABSL_HARDENING_ASSERT(size() > 0), *(data() + size() - 1);
+        }
+
+        // Span::begin()
+        //
+        // Returns an iterator pointing to the first element of this span, or `end()`
+        // if the span is empty.
+        constexpr iterator begin() const noexcept
+        {
+            return data();
+        }
+
+        // Span::cbegin()
+        //
+        // Returns a const iterator pointing to the first element of this span, or
+        // `end()` if the span is empty.
+        constexpr const_iterator cbegin() const noexcept
+        {
+            return begin();
+        }
+
+        // Span::end()
+        //
+        // Returns an iterator pointing just beyond the last element at the
+        // end of this span. This iterator acts as a placeholder; attempting to
+        // access it results in undefined behavior.
+        constexpr iterator end() const noexcept
+        {
+            return data() + size();
+        }
+
+        // Span::cend()
+        //
+        // Returns a const iterator pointing just beyond the last element at the
+        // end of this span. This iterator acts as a placeholder; attempting to
+        // access it results in undefined behavior.
+        constexpr const_iterator cend() const noexcept
+        {
+            return end();
+        }
+
+        // Span::rbegin()
+        //
+        // Returns a reverse iterator pointing to the last element at the end of this
+        // span, or `rend()` if the span is empty.
+        constexpr reverse_iterator rbegin() const noexcept
+        {
+            return reverse_iterator(end());
+        }
+
+        // Span::crbegin()
+        //
+        // Returns a const reverse iterator pointing to the last element at the end of
+        // this span, or `crend()` if the span is empty.
+        constexpr const_reverse_iterator crbegin() const noexcept
+        {
+            return rbegin();
+        }
+
+        // Span::rend()
+        //
+        // Returns a reverse iterator pointing just before the first element
+        // at the beginning of this span. This pointer acts as a placeholder;
+        // attempting to access its element results in undefined behavior.
+        constexpr reverse_iterator rend() const noexcept
+        {
+            return reverse_iterator(begin());
+        }
+
+        // Span::crend()
+        //
+        // Returns a reverse const iterator pointing just before the first element
+        // at the beginning of this span. This pointer acts as a placeholder;
+        // attempting to access its element results in undefined behavior.
+        constexpr const_reverse_iterator crend() const noexcept
+        {
+            return rend();
+        }
+
+        // Span mutations
+
+        // Span::remove_prefix()
+        //
+        // Removes the first `n` elements from the span.
+        void remove_prefix(size_type n) noexcept
+        {
+            ABSL_HARDENING_ASSERT(size() >= n);
+            ptr_ += n;
+            len_ -= n;
+        }
+
+        // Span::remove_suffix()
+        //
+        // Removes the last `n` elements from the span.
+        void remove_suffix(size_type n) noexcept
+        {
+            ABSL_HARDENING_ASSERT(size() >= n);
+            len_ -= n;
+        }
+
+        // Span::subspan()
+        //
+        // Returns a `Span` starting at element `pos` and of length `len`. Both `pos`
+        // and `len` are of type `size_type` and thus non-negative. Parameter `pos`
+        // must be <= size(). Any `len` value that points past the end of the span
+        // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
+        // ensures the returned subspan continues until the end of the span.
+        //
+        // Examples:
+        //
+        //   std::vector<int> vec = {10, 11, 12, 13};
+        //   absl::MakeSpan(vec).subspan(1, 2);  // {11, 12}
+        //   absl::MakeSpan(vec).subspan(2, 8);  // {12, 13}
+        //   absl::MakeSpan(vec).subspan(1);     // {11, 12, 13}
+        //   absl::MakeSpan(vec).subspan(4);     // {}
+        //   absl::MakeSpan(vec).subspan(5);     // throws std::out_of_range
+        constexpr Span subspan(size_type pos = 0, size_type len = npos) const
+        {
+            return (pos <= size()) ? Span(data() + pos, span_internal::Min(size() - pos, len)) : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
+        }
+
+        // Span::first()
+        //
+        // Returns a `Span` containing first `len` elements. Parameter `len` is of
+        // type `size_type` and thus non-negative. `len` value must be <= size().
+        //
+        // Examples:
+        //
+        //   std::vector<int> vec = {10, 11, 12, 13};
+        //   absl::MakeSpan(vec).first(1);  // {10}
+        //   absl::MakeSpan(vec).first(3);  // {10, 11, 12}
+        //   absl::MakeSpan(vec).first(5);  // throws std::out_of_range
+        constexpr Span first(size_type len) const
+        {
+            return (len <= size()) ? Span(data(), len) : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+        }
+
+        // Span::last()
+        //
+        // Returns a `Span` containing last `len` elements. Parameter `len` is of
+        // type `size_type` and thus non-negative. `len` value must be <= size().
+        //
+        // Examples:
+        //
+        //   std::vector<int> vec = {10, 11, 12, 13};
+        //   absl::MakeSpan(vec).last(1);  // {13}
+        //   absl::MakeSpan(vec).last(3);  // {11, 12, 13}
+        //   absl::MakeSpan(vec).last(5);  // throws std::out_of_range
+        constexpr Span last(size_type len) const
+        {
+            return (len <= size()) ? Span(size() - len + data(), len) : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+        }
+
+        // Support for absl::Hash.
+        template<typename H>
+        friend H AbslHashValue(H h, Span v)
+        {
+            return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()), v.size());
+        }
+
+    private:
+        pointer ptr_;
+        size_type len_;
+    };
+
+    template<typename T>
+    const typename Span<T>::size_type Span<T>::npos;
+
+    // Span relationals
+
+    // Equality is compared element-by-element, while ordering is lexicographical.
+    // We provide three overloads for each operator to cover any combination on the
+    // left or right hand side of mutable Span<T>, read-only Span<const T>, and
+    // convertible-to-read-only Span<T>.
+    // TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering
+    // template functions, 5 overloads per operator is needed as a workaround. We
+    // should update them to 3 overloads per operator using non-deduced context like
+    // string_view, i.e.
+    // - (Span<T>, Span<T>)
+    // - (Span<T>, non_deduced<Span<const T>>)
+    // - (non_deduced<Span<const T>>, Span<T>)
+
+    // operator==
+    template<typename T>
+    bool operator==(Span<T> a, Span<T> b)
+    {
+        return span_internal::EqualImpl<Span, const T>(a, b);
+    }
+    template<typename T>
+    bool operator==(Span<const T> a, Span<T> b)
+    {
+        return span_internal::EqualImpl<Span, const T>(a, b);
+    }
+    template<typename T>
+    bool operator==(Span<T> a, Span<const T> b)
+    {
+        return span_internal::EqualImpl<Span, const T>(a, b);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator==(const U& a, Span<T> b)
+    {
+        return span_internal::EqualImpl<Span, const T>(a, b);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator==(Span<T> a, const U& b)
+    {
+        return span_internal::EqualImpl<Span, const T>(a, b);
+    }
+
+    // operator!=
+    template<typename T>
+    bool operator!=(Span<T> a, Span<T> b)
+    {
+        return !(a == b);
+    }
+    template<typename T>
+    bool operator!=(Span<const T> a, Span<T> b)
+    {
+        return !(a == b);
+    }
+    template<typename T>
+    bool operator!=(Span<T> a, Span<const T> b)
+    {
+        return !(a == b);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator!=(const U& a, Span<T> b)
+    {
+        return !(a == b);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator!=(Span<T> a, const U& b)
+    {
+        return !(a == b);
+    }
+
+    // operator<
+    template<typename T>
+    bool operator<(Span<T> a, Span<T> b)
+    {
+        return span_internal::LessThanImpl<Span, const T>(a, b);
+    }
+    template<typename T>
+    bool operator<(Span<const T> a, Span<T> b)
+    {
+        return span_internal::LessThanImpl<Span, const T>(a, b);
+    }
+    template<typename T>
+    bool operator<(Span<T> a, Span<const T> b)
+    {
+        return span_internal::LessThanImpl<Span, const T>(a, b);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator<(const U& a, Span<T> b)
+    {
+        return span_internal::LessThanImpl<Span, const T>(a, b);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator<(Span<T> a, const U& b)
+    {
+        return span_internal::LessThanImpl<Span, const T>(a, b);
+    }
+
+    // operator>
+    template<typename T>
+    bool operator>(Span<T> a, Span<T> b)
+    {
+        return b < a;
+    }
+    template<typename T>
+    bool operator>(Span<const T> a, Span<T> b)
+    {
+        return b < a;
+    }
+    template<typename T>
+    bool operator>(Span<T> a, Span<const T> b)
+    {
+        return b < a;
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator>(const U& a, Span<T> b)
+    {
+        return b < a;
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator>(Span<T> a, const U& b)
+    {
+        return b < a;
+    }
+
+    // operator<=
+    template<typename T>
+    bool operator<=(Span<T> a, Span<T> b)
+    {
+        return !(b < a);
+    }
+    template<typename T>
+    bool operator<=(Span<const T> a, Span<T> b)
+    {
+        return !(b < a);
+    }
+    template<typename T>
+    bool operator<=(Span<T> a, Span<const T> b)
+    {
+        return !(b < a);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator<=(const U& a, Span<T> b)
+    {
+        return !(b < a);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator<=(Span<T> a, const U& b)
+    {
+        return !(b < a);
+    }
+
+    // operator>=
+    template<typename T>
+    bool operator>=(Span<T> a, Span<T> b)
+    {
+        return !(a < b);
+    }
+    template<typename T>
+    bool operator>=(Span<const T> a, Span<T> b)
+    {
+        return !(a < b);
+    }
+    template<typename T>
+    bool operator>=(Span<T> a, Span<const T> b)
+    {
+        return !(a < b);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator>=(const U& a, Span<T> b)
+    {
+        return !(a < b);
+    }
+    template<
+        typename T,
+        typename U,
+        typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
+    bool operator>=(Span<T> a, const U& b)
+    {
+        return !(a < b);
+    }
+
+    // MakeSpan()
+    //
+    // Constructs a mutable `Span<T>`, deducing `T` automatically from either a
+    // container or pointer+size.
+    //
+    // Because a read-only `Span<const T>` is implicitly constructed from container
+    // types regardless of whether the container itself is a const container,
+    // constructing mutable spans of type `Span<T>` from containers requires
+    // explicit constructors. The container-accepting version of `MakeSpan()`
+    // deduces the type of `T` by the constness of the pointer received from the
+    // container's `data()` member. Similarly, the pointer-accepting version returns
+    // a `Span<const T>` if `T` is `const`, and a `Span<T>` otherwise.
+    //
+    // Examples:
+    //
+    //   void MyRoutine(absl::Span<MyComplicatedType> a) {
+    //     ...
+    //   };
+    //   // my_vector is a container of non-const types
+    //   std::vector<MyComplicatedType> my_vector;
+    //
+    //   // Constructing a Span implicitly attempts to create a Span of type
+    //   // `Span<const T>`
+    //   MyRoutine(my_vector);                // error, type mismatch
+    //
+    //   // Explicitly constructing the Span is verbose
+    //   MyRoutine(absl::Span<MyComplicatedType>(my_vector));
+    //
+    //   // Use MakeSpan() to make an absl::Span<T>
+    //   MyRoutine(absl::MakeSpan(my_vector));
+    //
+    //   // Construct a span from an array ptr+size
+    //   absl::Span<T> my_span() {
+    //     return absl::MakeSpan(&array[0], num_elements_);
+    //   }
+    //
+    template<int&... ExplicitArgumentBarrier, typename T>
+    constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept
+    {
+        return Span<T>(ptr, size);
+    }
+
+    template<int&... ExplicitArgumentBarrier, typename T>
+    Span<T> MakeSpan(T* begin, T* end) noexcept
+    {
+        return ABSL_HARDENING_ASSERT(begin <= end),
+               Span<T>(begin, static_cast<size_t>(end - begin));
+    }
+
+    template<int&... ExplicitArgumentBarrier, typename C>
+    constexpr auto MakeSpan(C& c) noexcept  // NOLINT(runtime/references)
+        -> decltype(absl::MakeSpan(span_internal::GetData(c), c.size()))
+    {
+        return MakeSpan(span_internal::GetData(c), c.size());
+    }
+
+    template<int&... ExplicitArgumentBarrier, typename T, size_t N>
+    constexpr Span<T> MakeSpan(T (&array)[N]) noexcept
+    {
+        return Span<T>(array, N);
+    }
+
+    // MakeConstSpan()
+    //
+    // Constructs a `Span<const T>` as with `MakeSpan`, deducing `T` automatically,
+    // but always returning a `Span<const T>`.
+    //
+    // Examples:
+    //
+    //   void ProcessInts(absl::Span<const int> some_ints);
+    //
+    //   // Call with a pointer and size.
+    //   int array[3] = { 0, 0, 0 };
+    //   ProcessInts(absl::MakeConstSpan(&array[0], 3));
+    //
+    //   // Call with a [begin, end) pair.
+    //   ProcessInts(absl::MakeConstSpan(&array[0], &array[3]));
+    //
+    //   // Call directly with an array.
+    //   ProcessInts(absl::MakeConstSpan(array));
+    //
+    //   // Call with a contiguous container.
+    //   std::vector<int> some_ints = ...;
+    //   ProcessInts(absl::MakeConstSpan(some_ints));
+    //   ProcessInts(absl::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
+    //
+    template<int&... ExplicitArgumentBarrier, typename T>
+    constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept
+    {
+        return Span<const T>(ptr, size);
+    }
+
+    template<int&... ExplicitArgumentBarrier, typename T>
+    Span<const T> MakeConstSpan(T* begin, T* end) noexcept
+    {
+        return ABSL_HARDENING_ASSERT(begin <= end), Span<const T>(begin, end - begin);
+    }
+
+    template<int&... ExplicitArgumentBarrier, typename C>
+    constexpr auto MakeConstSpan(const C& c) noexcept -> decltype(MakeSpan(c))
+    {
+        return MakeSpan(c);
+    }
+
+    template<int&... ExplicitArgumentBarrier, typename T, size_t N>
+    constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept
+    {
+        return Span<const T>(array, N);
+    }
+    ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // ABSL_TYPES_SPAN_H_
diff --git a/CAPI/cpp/grpc/include/absl/types/variant.h b/CAPI/cpp/grpc/include/absl/types/variant.h
index ac93464..d5c1f81 100644
--- a/CAPI/cpp/grpc/include/absl/types/variant.h
+++ b/CAPI/cpp/grpc/include/absl/types/variant.h
@@ -49,21 +49,22 @@
 
 #include <variant>  // IWYU pragma: export
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-using std::bad_variant_access;
-using std::get;
-using std::get_if;
-using std::holds_alternative;
-using std::monostate;
-using std::variant;
-using std::variant_alternative;
-using std::variant_alternative_t;
-using std::variant_npos;
-using std::variant_size;
-using std::variant_size_v;
-using std::visit;
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    using std::bad_variant_access;
+    using std::get;
+    using std::get_if;
+    using std::holds_alternative;
+    using std::monostate;
+    using std::variant;
+    using std::variant_alternative;
+    using std::variant_alternative_t;
+    using std::variant_npos;
+    using std::variant_size;
+    using std::variant_size_v;
+    using std::visit;
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #else  // ABSL_USES_STD_VARIANT
@@ -78,789 +79,847 @@ ABSL_NAMESPACE_END
 #include "absl/meta/type_traits.h"
 #include "absl/types/internal/variant.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// absl::variant
-// -----------------------------------------------------------------------------
-//
-// An `absl::variant` type is a form of type-safe union. An `absl::variant` --
-// except in exceptional cases -- always holds a value of one of its alternative
-// types.
-//
-// Example:
-//
-//   // Construct a variant that holds either an integer or a std::string and
-//   // assign it to a std::string.
-//   absl::variant<int, std::string> v = std::string("abc");
-//
-//   // A default-constructed variant will hold a value-initialized value of
-//   // the first alternative type.
-//   auto a = absl::variant<int, std::string>();   // Holds an int of value '0'.
-//
-//   // variants are assignable.
-//
-//   // copy assignment
-//   auto v1 = absl::variant<int, std::string>("abc");
-//   auto v2 = absl::variant<int, std::string>(10);
-//   v2 = v1;  // copy assign
-//
-//   // move assignment
-//   auto v1 = absl::variant<int, std::string>("abc");
-//   v1 = absl::variant<int, std::string>(10);
-//
-//   // assignment through type conversion
-//   a = 128;         // variant contains int
-//   a = "128";       // variant contains std::string
-//
-// An `absl::variant` holding a value of one of its alternative types `T` holds
-// an allocation of `T` directly within the variant itself. An `absl::variant`
-// is not allowed to allocate additional storage, such as dynamic memory, to
-// allocate the contained value. The contained value shall be allocated in a
-// region of the variant storage suitably aligned for all alternative types.
-template <typename... Ts>
-class variant;
-
-// swap()
-//
-// Swaps two `absl::variant` values. This function is equivalent to `v.swap(w)`
-// where `v` and `w` are `absl::variant` types.
-//
-// Note that this function requires all alternative types to be both swappable
-// and move-constructible, because any two variants may refer to either the same
-// type (in which case, they will be swapped) or to two different types (in
-// which case the values will need to be moved).
-//
-template <
-    typename... Ts,
-    absl::enable_if_t<
-        absl::conjunction<std::is_move_constructible<Ts>...,
-                          type_traits_internal::IsSwappable<Ts>...>::value,
-        int> = 0>
-void swap(variant<Ts...>& v, variant<Ts...>& w) noexcept(noexcept(v.swap(w))) {
-  v.swap(w);
-}
-
-// variant_size
-//
-// Returns the number of alternative types available for a given `absl::variant`
-// type as a compile-time constant expression. As this is a class template, it
-// is not generally useful for accessing the number of alternative types of
-// any given `absl::variant` instance.
-//
-// Example:
-//
-//   auto a = absl::variant<int, std::string>;
-//   constexpr int num_types =
-//       absl::variant_size<absl::variant<int, std::string>>();
-//
-//   // You can also use the member constant `value`.
-//   constexpr int num_types =
-//       absl::variant_size<absl::variant<int, std::string>>::value;
-//
-//   // `absl::variant_size` is more valuable for use in generic code:
-//   template <typename Variant>
-//   constexpr bool IsVariantMultivalue() {
-//       return absl::variant_size<Variant>() > 1;
-//   }
-//
-// Note that the set of cv-qualified specializations of `variant_size` are
-// provided to ensure that those specializations compile (especially when passed
-// within template logic).
-template <class T>
-struct variant_size;
-
-template <class... Ts>
-struct variant_size<variant<Ts...>>
-    : std::integral_constant<std::size_t, sizeof...(Ts)> {};
-
-// Specialization of `variant_size` for const qualified variants.
-template <class T>
-struct variant_size<const T> : variant_size<T>::type {};
-
-// Specialization of `variant_size` for volatile qualified variants.
-template <class T>
-struct variant_size<volatile T> : variant_size<T>::type {};
-
-// Specialization of `variant_size` for const volatile qualified variants.
-template <class T>
-struct variant_size<const volatile T> : variant_size<T>::type {};
-
-// variant_alternative
-//
-// Returns the alternative type for a given `absl::variant` at the passed
-// index value as a compile-time constant expression. As this is a class
-// template resulting in a type, it is not useful for access of the run-time
-// value of any given `absl::variant` variable.
-//
-// Example:
-//
-//   // The type of the 0th alternative is "int".
-//   using alternative_type_0
-//     = absl::variant_alternative<0, absl::variant<int, std::string>>::type;
-//
-//   static_assert(std::is_same<alternative_type_0, int>::value, "");
-//
-//   // `absl::variant_alternative` is more valuable for use in generic code:
-//   template <typename Variant>
-//   constexpr bool IsFirstElementTrivial() {
-//       return std::is_trivial_v<variant_alternative<0, Variant>::type>;
-//   }
-//
-// Note that the set of cv-qualified specializations of `variant_alternative`
-// are provided to ensure that those specializations compile (especially when
-// passed within template logic).
-template <std::size_t I, class T>
-struct variant_alternative;
-
-template <std::size_t I, class... Types>
-struct variant_alternative<I, variant<Types...>> {
-  using type =
-      variant_internal::VariantAlternativeSfinaeT<I, variant<Types...>>;
-};
-
-// Specialization of `variant_alternative` for const qualified variants.
-template <std::size_t I, class T>
-struct variant_alternative<I, const T> {
-  using type = const typename variant_alternative<I, T>::type;
-};
-
-// Specialization of `variant_alternative` for volatile qualified variants.
-template <std::size_t I, class T>
-struct variant_alternative<I, volatile T> {
-  using type = volatile typename variant_alternative<I, T>::type;
-};
-
-// Specialization of `variant_alternative` for const volatile qualified
-// variants.
-template <std::size_t I, class T>
-struct variant_alternative<I, const volatile T> {
-  using type = const volatile typename variant_alternative<I, T>::type;
-};
-
-// Template type alias for variant_alternative<I, T>::type.
-//
-// Example:
-//
-//   using alternative_type_0
-//     = absl::variant_alternative_t<0, absl::variant<int, std::string>>;
-//   static_assert(std::is_same<alternative_type_0, int>::value, "");
-template <std::size_t I, class T>
-using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-// holds_alternative()
-//
-// Checks whether the given variant currently holds a given alternative type,
-// returning `true` if so.
-//
-// Example:
-//
-//   absl::variant<int, std::string> foo = 42;
-//   if (absl::holds_alternative<int>(foo)) {
-//       std::cout << "The variant holds an integer";
-//   }
-template <class T, class... Types>
-constexpr bool holds_alternative(const variant<Types...>& v) noexcept {
-  static_assert(
-      variant_internal::UnambiguousIndexOfImpl<variant<Types...>, T,
-                                               0>::value != sizeof...(Types),
-      "The type T must occur exactly once in Types...");
-  return v.index() ==
-         variant_internal::UnambiguousIndexOf<variant<Types...>, T>::value;
-}
-
-// get()
-//
-// Returns a reference to the value currently within a given variant, using
-// either a unique alternative type amongst the variant's set of alternative
-// types, or the variant's index value. Attempting to get a variant's value
-// using a type that is not unique within the variant's set of alternative types
-// is a compile-time error. If the index of the alternative being specified is
-// different from the index of the alternative that is currently stored, throws
-// `absl::bad_variant_access`.
-//
-// Example:
-//
-//   auto a = absl::variant<int, std::string>;
-//
-//   // Get the value by type (if unique).
-//   int i = absl::get<int>(a);
-//
-//   auto b = absl::variant<int, int>;
-//
-//   // Getting the value by a type that is not unique is ill-formed.
-//   int j = absl::get<int>(b);     // Compile Error!
-//
-//   // Getting value by index not ambiguous and allowed.
-//   int k = absl::get<1>(b);
-
-// Overload for getting a variant's lvalue by type.
-template <class T, class... Types>
-constexpr T& get(variant<Types...>& v) {  // NOLINT
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a variant's rvalue by type.
-// Note: `absl::move()` is required to allow use of constexpr in C++11.
-template <class T, class... Types>
-constexpr T&& get(variant<Types...>&& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(absl::move(v));
-}
-
-// Overload for getting a variant's const lvalue by type.
-template <class T, class... Types>
-constexpr const T& get(const variant<Types...>& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a variant's const rvalue by type.
-// Note: `absl::move()` is required to allow use of constexpr in C++11.
-template <class T, class... Types>
-constexpr const T&& get(const variant<Types...>&& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(absl::move(v));
-}
-
-// Overload for getting a variant's lvalue by index.
-template <std::size_t I, class... Types>
-constexpr variant_alternative_t<I, variant<Types...>>& get(
-    variant<Types...>& v) {  // NOLINT
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
-}
-
-// Overload for getting a variant's rvalue by index.
-// Note: `absl::move()` is required to allow use of constexpr in C++11.
-template <std::size_t I, class... Types>
-constexpr variant_alternative_t<I, variant<Types...>>&& get(
-    variant<Types...>&& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(absl::move(v));
-}
-
-// Overload for getting a variant's const lvalue by index.
-template <std::size_t I, class... Types>
-constexpr const variant_alternative_t<I, variant<Types...>>& get(
-    const variant<Types...>& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
-}
-
-// Overload for getting a variant's const rvalue by index.
-// Note: `absl::move()` is required to allow use of constexpr in C++11.
-template <std::size_t I, class... Types>
-constexpr const variant_alternative_t<I, variant<Types...>>&& get(
-    const variant<Types...>&& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(absl::move(v));
-}
-
-// get_if()
-//
-// Returns a pointer to the value currently stored within a given variant, if
-// present, using either a unique alternative type amongst the variant's set of
-// alternative types, or the variant's index value. If such a value does not
-// exist, returns `nullptr`.
-//
-// As with `get`, attempting to get a variant's value using a type that is not
-// unique within the variant's set of alternative types is a compile-time error.
-
-// Overload for getting a pointer to the value stored in the given variant by
-// index.
-template <std::size_t I, class... Types>
-constexpr absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>>
-get_if(variant<Types...>* v) noexcept {
-  return (v != nullptr && v->index() == I)
-             ? std::addressof(
-                   variant_internal::VariantCoreAccess::Access<I>(*v))
-             : nullptr;
-}
-
-// Overload for getting a pointer to the const value stored in the given
-// variant by index.
-template <std::size_t I, class... Types>
-constexpr absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
-get_if(const variant<Types...>* v) noexcept {
-  return (v != nullptr && v->index() == I)
-             ? std::addressof(
-                   variant_internal::VariantCoreAccess::Access<I>(*v))
-             : nullptr;
-}
-
-// Overload for getting a pointer to the value stored in the given variant by
-// type.
-template <class T, class... Types>
-constexpr absl::add_pointer_t<T> get_if(variant<Types...>* v) noexcept {
-  return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a pointer to the const value stored in the given variant
-// by type.
-template <class T, class... Types>
-constexpr absl::add_pointer_t<const T> get_if(
-    const variant<Types...>* v) noexcept {
-  return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// visit()
-//
-// Calls a provided functor on a given set of variants. `absl::visit()` is
-// commonly used to conditionally inspect the state of a given variant (or set
-// of variants).
-//
-// The functor must return the same type when called with any of the variants'
-// alternatives.
-//
-// Example:
-//
-//   // Define a visitor functor
-//   struct GetVariant {
-//       template<typename T>
-//       void operator()(const T& i) const {
-//         std::cout << "The variant's value is: " << i;
-//       }
-//   };
-//
-//   // Declare our variant, and call `absl::visit()` on it.
-//   // Note that `GetVariant()` returns void in either case.
-//   absl::variant<int, std::string> foo = std::string("foo");
-//   GetVariant visitor;
-//   absl::visit(visitor, foo);  // Prints `The variant's value is: foo'
-template <typename Visitor, typename... Variants>
-variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis,
-                                                          Variants&&... vars) {
-  return variant_internal::
-      VisitIndices<variant_size<absl::decay_t<Variants> >::value...>::Run(
-          variant_internal::PerformVisitation<Visitor, Variants...>{
-              std::forward_as_tuple(absl::forward<Variants>(vars)...),
-              absl::forward<Visitor>(vis)},
-          vars.index()...);
-}
-
-// monostate
-//
-// The monostate class serves as a first alternative type for a variant for
-// which the first variant type is otherwise not default-constructible.
-struct monostate {};
-
-// `absl::monostate` Relational Operators
-
-constexpr bool operator<(monostate, monostate) noexcept { return false; }
-constexpr bool operator>(monostate, monostate) noexcept { return false; }
-constexpr bool operator<=(monostate, monostate) noexcept { return true; }
-constexpr bool operator>=(monostate, monostate) noexcept { return true; }
-constexpr bool operator==(monostate, monostate) noexcept { return true; }
-constexpr bool operator!=(monostate, monostate) noexcept { return false; }
-
-
-//------------------------------------------------------------------------------
-// `absl::variant` Template Definition
-//------------------------------------------------------------------------------
-template <typename T0, typename... Tn>
-class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
-  static_assert(absl::conjunction<std::is_object<T0>,
-                                  std::is_object<Tn>...>::value,
-                "Attempted to instantiate a variant containing a non-object "
-                "type.");
-  // Intentionally not qualifying `negation` with `absl::` to work around a bug
-  // in MSVC 2015 with inline namespace and variadic template.
-  static_assert(absl::conjunction<negation<std::is_array<T0> >,
-                                  negation<std::is_array<Tn> >...>::value,
-                "Attempted to instantiate a variant containing an array type.");
-  static_assert(absl::conjunction<std::is_nothrow_destructible<T0>,
-                                  std::is_nothrow_destructible<Tn>...>::value,
-                "Attempted to instantiate a variant containing a non-nothrow "
-                "destructible type.");
-
-  friend struct variant_internal::VariantCoreAccess;
-
- private:
-  using Base = variant_internal::VariantBase<T0, Tn...>;
-
- public:
-  // Constructors
-
-  // Constructs a variant holding a default-initialized value of the first
-  // alternative type.
-  constexpr variant() /*noexcept(see 111above)*/ = default;
-
-  // Copy constructor, standard semantics
-  variant(const variant& other) = default;
-
-  // Move constructor, standard semantics
-  variant(variant&& other) /*noexcept(see above)*/ = default;
-
-  // Constructs a variant of an alternative type specified by overload
-  // resolution of the provided forwarding arguments through
-  // direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  //
-  // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
-  // has been voted passed the design phase in the C++ standard meeting in Mar
-  // 2018. It will be implemented and integrated into `absl::variant`.
-  template <
-      class T,
-      std::size_t I = std::enable_if<
-          variant_internal::IsNeitherSelfNorInPlace<variant,
-                                                    absl::decay_t<T>>::value,
-          variant_internal::IndexOfConstructedType<variant, T>>::type::value,
-      class Tj = absl::variant_alternative_t<I, variant>,
-      absl::enable_if_t<std::is_constructible<Tj, T>::value>* =
-          nullptr>
-  constexpr variant(T&& t) noexcept(std::is_nothrow_constructible<Tj, T>::value)
-      : Base(variant_internal::EmplaceTag<I>(), absl::forward<T>(t)) {}
-
-  // Constructs a variant of an alternative type from the arguments through
-  // direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  template <class T, class... Args,
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // -----------------------------------------------------------------------------
+    // absl::variant
+    // -----------------------------------------------------------------------------
+    //
+    // An `absl::variant` type is a form of type-safe union. An `absl::variant` --
+    // except in exceptional cases -- always holds a value of one of its alternative
+    // types.
+    //
+    // Example:
+    //
+    //   // Construct a variant that holds either an integer or a std::string and
+    //   // assign it to a std::string.
+    //   absl::variant<int, std::string> v = std::string("abc");
+    //
+    //   // A default-constructed variant will hold a value-initialized value of
+    //   // the first alternative type.
+    //   auto a = absl::variant<int, std::string>();   // Holds an int of value '0'.
+    //
+    //   // variants are assignable.
+    //
+    //   // copy assignment
+    //   auto v1 = absl::variant<int, std::string>("abc");
+    //   auto v2 = absl::variant<int, std::string>(10);
+    //   v2 = v1;  // copy assign
+    //
+    //   // move assignment
+    //   auto v1 = absl::variant<int, std::string>("abc");
+    //   v1 = absl::variant<int, std::string>(10);
+    //
+    //   // assignment through type conversion
+    //   a = 128;         // variant contains int
+    //   a = "128";       // variant contains std::string
+    //
+    // An `absl::variant` holding a value of one of its alternative types `T` holds
+    // an allocation of `T` directly within the variant itself. An `absl::variant`
+    // is not allowed to allocate additional storage, such as dynamic memory, to
+    // allocate the contained value. The contained value shall be allocated in a
+    // region of the variant storage suitably aligned for all alternative types.
+    template<typename... Ts>
+    class variant;
+
+    // swap()
+    //
+    // Swaps two `absl::variant` values. This function is equivalent to `v.swap(w)`
+    // where `v` and `w` are `absl::variant` types.
+    //
+    // Note that this function requires all alternative types to be both swappable
+    // and move-constructible, because any two variants may refer to either the same
+    // type (in which case, they will be swapped) or to two different types (in
+    // which case the values will need to be moved).
+    //
+    template<
+        typename... Ts,
+        absl::enable_if_t<
+            absl::conjunction<std::is_move_constructible<Ts>..., type_traits_internal::IsSwappable<Ts>...>::value,
+            int> = 0>
+    void swap(variant<Ts...>& v, variant<Ts...>& w) noexcept(noexcept(v.swap(w)))
+    {
+        v.swap(w);
+    }
+
+    // variant_size
+    //
+    // Returns the number of alternative types available for a given `absl::variant`
+    // type as a compile-time constant expression. As this is a class template, it
+    // is not generally useful for accessing the number of alternative types of
+    // any given `absl::variant` instance.
+    //
+    // Example:
+    //
+    //   auto a = absl::variant<int, std::string>;
+    //   constexpr int num_types =
+    //       absl::variant_size<absl::variant<int, std::string>>();
+    //
+    //   // You can also use the member constant `value`.
+    //   constexpr int num_types =
+    //       absl::variant_size<absl::variant<int, std::string>>::value;
+    //
+    //   // `absl::variant_size` is more valuable for use in generic code:
+    //   template <typename Variant>
+    //   constexpr bool IsVariantMultivalue() {
+    //       return absl::variant_size<Variant>() > 1;
+    //   }
+    //
+    // Note that the set of cv-qualified specializations of `variant_size` are
+    // provided to ensure that those specializations compile (especially when passed
+    // within template logic).
+    template<class T>
+    struct variant_size;
+
+    template<class... Ts>
+    struct variant_size<variant<Ts...>> : std::integral_constant<std::size_t, sizeof...(Ts)>
+    {
+    };
+
+    // Specialization of `variant_size` for const qualified variants.
+    template<class T>
+    struct variant_size<const T> : variant_size<T>::type
+    {
+    };
+
+    // Specialization of `variant_size` for volatile qualified variants.
+    template<class T>
+    struct variant_size<volatile T> : variant_size<T>::type
+    {
+    };
+
+    // Specialization of `variant_size` for const volatile qualified variants.
+    template<class T>
+    struct variant_size<const volatile T> : variant_size<T>::type
+    {
+    };
+
+    // variant_alternative
+    //
+    // Returns the alternative type for a given `absl::variant` at the passed
+    // index value as a compile-time constant expression. As this is a class
+    // template resulting in a type, it is not useful for access of the run-time
+    // value of any given `absl::variant` variable.
+    //
+    // Example:
+    //
+    //   // The type of the 0th alternative is "int".
+    //   using alternative_type_0
+    //     = absl::variant_alternative<0, absl::variant<int, std::string>>::type;
+    //
+    //   static_assert(std::is_same<alternative_type_0, int>::value, "");
+    //
+    //   // `absl::variant_alternative` is more valuable for use in generic code:
+    //   template <typename Variant>
+    //   constexpr bool IsFirstElementTrivial() {
+    //       return std::is_trivial_v<variant_alternative<0, Variant>::type>;
+    //   }
+    //
+    // Note that the set of cv-qualified specializations of `variant_alternative`
+    // are provided to ensure that those specializations compile (especially when
+    // passed within template logic).
+    template<std::size_t I, class T>
+    struct variant_alternative;
+
+    template<std::size_t I, class... Types>
+    struct variant_alternative<I, variant<Types...>>
+    {
+        using type =
+            variant_internal::VariantAlternativeSfinaeT<I, variant<Types...>>;
+    };
+
+    // Specialization of `variant_alternative` for const qualified variants.
+    template<std::size_t I, class T>
+    struct variant_alternative<I, const T>
+    {
+        using type = const typename variant_alternative<I, T>::type;
+    };
+
+    // Specialization of `variant_alternative` for volatile qualified variants.
+    template<std::size_t I, class T>
+    struct variant_alternative<I, volatile T>
+    {
+        using type = volatile typename variant_alternative<I, T>::type;
+    };
+
+    // Specialization of `variant_alternative` for const volatile qualified
+    // variants.
+    template<std::size_t I, class T>
+    struct variant_alternative<I, const volatile T>
+    {
+        using type = const volatile typename variant_alternative<I, T>::type;
+    };
+
+    // Template type alias for variant_alternative<I, T>::type.
+    //
+    // Example:
+    //
+    //   using alternative_type_0
+    //     = absl::variant_alternative_t<0, absl::variant<int, std::string>>;
+    //   static_assert(std::is_same<alternative_type_0, int>::value, "");
+    template<std::size_t I, class T>
+    using variant_alternative_t = typename variant_alternative<I, T>::type;
+
+    // holds_alternative()
+    //
+    // Checks whether the given variant currently holds a given alternative type,
+    // returning `true` if so.
+    //
+    // Example:
+    //
+    //   absl::variant<int, std::string> foo = 42;
+    //   if (absl::holds_alternative<int>(foo)) {
+    //       std::cout << "The variant holds an integer";
+    //   }
+    template<class T, class... Types>
+    constexpr bool holds_alternative(const variant<Types...>& v) noexcept
+    {
+        static_assert(
+            variant_internal::UnambiguousIndexOfImpl<variant<Types...>, T, 0>::value != sizeof...(Types),
+            "The type T must occur exactly once in Types..."
+        );
+        return v.index() ==
+               variant_internal::UnambiguousIndexOf<variant<Types...>, T>::value;
+    }
+
+    // get()
+    //
+    // Returns a reference to the value currently within a given variant, using
+    // either a unique alternative type amongst the variant's set of alternative
+    // types, or the variant's index value. Attempting to get a variant's value
+    // using a type that is not unique within the variant's set of alternative types
+    // is a compile-time error. If the index of the alternative being specified is
+    // different from the index of the alternative that is currently stored, throws
+    // `absl::bad_variant_access`.
+    //
+    // Example:
+    //
+    //   auto a = absl::variant<int, std::string>;
+    //
+    //   // Get the value by type (if unique).
+    //   int i = absl::get<int>(a);
+    //
+    //   auto b = absl::variant<int, int>;
+    //
+    //   // Getting the value by a type that is not unique is ill-formed.
+    //   int j = absl::get<int>(b);     // Compile Error!
+    //
+    //   // Getting value by index not ambiguous and allowed.
+    //   int k = absl::get<1>(b);
+
+    // Overload for getting a variant's lvalue by type.
+    template<class T, class... Types>
+    constexpr T& get(variant<Types...>& v)
+    {  // NOLINT
+        return variant_internal::VariantCoreAccess::CheckedAccess<
+            variant_internal::IndexOf<T, Types...>::value>(v);
+    }
+
+    // Overload for getting a variant's rvalue by type.
+    // Note: `absl::move()` is required to allow use of constexpr in C++11.
+    template<class T, class... Types>
+    constexpr T&& get(variant<Types...>&& v)
+    {
+        return variant_internal::VariantCoreAccess::CheckedAccess<
+            variant_internal::IndexOf<T, Types...>::value>(absl::move(v));
+    }
+
+    // Overload for getting a variant's const lvalue by type.
+    template<class T, class... Types>
+    constexpr const T& get(const variant<Types...>& v)
+    {
+        return variant_internal::VariantCoreAccess::CheckedAccess<
+            variant_internal::IndexOf<T, Types...>::value>(v);
+    }
+
+    // Overload for getting a variant's const rvalue by type.
+    // Note: `absl::move()` is required to allow use of constexpr in C++11.
+    template<class T, class... Types>
+    constexpr const T&& get(const variant<Types...>&& v)
+    {
+        return variant_internal::VariantCoreAccess::CheckedAccess<
+            variant_internal::IndexOf<T, Types...>::value>(absl::move(v));
+    }
+
+    // Overload for getting a variant's lvalue by index.
+    template<std::size_t I, class... Types>
+    constexpr variant_alternative_t<I, variant<Types...>>& get(
+        variant<Types...>& v
+    )
+    {  // NOLINT
+        return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
+    }
+
+    // Overload for getting a variant's rvalue by index.
+    // Note: `absl::move()` is required to allow use of constexpr in C++11.
+    template<std::size_t I, class... Types>
+    constexpr variant_alternative_t<I, variant<Types...>>&& get(
+        variant<Types...>&& v
+    )
+    {
+        return variant_internal::VariantCoreAccess::CheckedAccess<I>(absl::move(v));
+    }
+
+    // Overload for getting a variant's const lvalue by index.
+    template<std::size_t I, class... Types>
+    constexpr const variant_alternative_t<I, variant<Types...>>& get(
+        const variant<Types...>& v
+    )
+    {
+        return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
+    }
+
+    // Overload for getting a variant's const rvalue by index.
+    // Note: `absl::move()` is required to allow use of constexpr in C++11.
+    template<std::size_t I, class... Types>
+    constexpr const variant_alternative_t<I, variant<Types...>>&& get(
+        const variant<Types...>&& v
+    )
+    {
+        return variant_internal::VariantCoreAccess::CheckedAccess<I>(absl::move(v));
+    }
+
+    // get_if()
+    //
+    // Returns a pointer to the value currently stored within a given variant, if
+    // present, using either a unique alternative type amongst the variant's set of
+    // alternative types, or the variant's index value. If such a value does not
+    // exist, returns `nullptr`.
+    //
+    // As with `get`, attempting to get a variant's value using a type that is not
+    // unique within the variant's set of alternative types is a compile-time error.
+
+    // Overload for getting a pointer to the value stored in the given variant by
+    // index.
+    template<std::size_t I, class... Types>
+    constexpr absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>>
+        get_if(variant<Types...>* v) noexcept
+    {
+        return (v != nullptr && v->index() == I) ? std::addressof(
+                                                       variant_internal::VariantCoreAccess::Access<I>(*v)
+                                                   ) :
+                                                   nullptr;
+    }
+
+    // Overload for getting a pointer to the const value stored in the given
+    // variant by index.
+    template<std::size_t I, class... Types>
+    constexpr absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
+        get_if(const variant<Types...>* v) noexcept
+    {
+        return (v != nullptr && v->index() == I) ? std::addressof(
+                                                       variant_internal::VariantCoreAccess::Access<I>(*v)
+                                                   ) :
+                                                   nullptr;
+    }
+
+    // Overload for getting a pointer to the value stored in the given variant by
+    // type.
+    template<class T, class... Types>
+    constexpr absl::add_pointer_t<T> get_if(variant<Types...>* v) noexcept
+    {
+        return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
+    }
+
+    // Overload for getting a pointer to the const value stored in the given variant
+    // by type.
+    template<class T, class... Types>
+    constexpr absl::add_pointer_t<const T> get_if(
+        const variant<Types...>* v
+    ) noexcept
+    {
+        return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
+    }
+
+    // visit()
+    //
+    // Calls a provided functor on a given set of variants. `absl::visit()` is
+    // commonly used to conditionally inspect the state of a given variant (or set
+    // of variants).
+    //
+    // The functor must return the same type when called with any of the variants'
+    // alternatives.
+    //
+    // Example:
+    //
+    //   // Define a visitor functor
+    //   struct GetVariant {
+    //       template<typename T>
+    //       void operator()(const T& i) const {
+    //         std::cout << "The variant's value is: " << i;
+    //       }
+    //   };
+    //
+    //   // Declare our variant, and call `absl::visit()` on it.
+    //   // Note that `GetVariant()` returns void in either case.
+    //   absl::variant<int, std::string> foo = std::string("foo");
+    //   GetVariant visitor;
+    //   absl::visit(visitor, foo);  // Prints `The variant's value is: foo'
+    template<typename Visitor, typename... Variants>
+    variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis, Variants&&... vars)
+    {
+        return variant_internal::
+            VisitIndices<variant_size<absl::decay_t<Variants>>::value...>::Run(
+                variant_internal::PerformVisitation<Visitor, Variants...>{
+                    std::forward_as_tuple(absl::forward<Variants>(vars)...),
+                    absl::forward<Visitor>(vis)},
+                vars.index()...
+            );
+    }
+
+    // monostate
+    //
+    // The monostate class serves as a first alternative type for a variant for
+    // which the first variant type is otherwise not default-constructible.
+    struct monostate
+    {
+    };
+
+    // `absl::monostate` Relational Operators
+
+    constexpr bool operator<(monostate, monostate) noexcept
+    {
+        return false;
+    }
+    constexpr bool operator>(monostate, monostate) noexcept
+    {
+        return false;
+    }
+    constexpr bool operator<=(monostate, monostate) noexcept
+    {
+        return true;
+    }
+    constexpr bool operator>=(monostate, monostate) noexcept
+    {
+        return true;
+    }
+    constexpr bool operator==(monostate, monostate) noexcept
+    {
+        return true;
+    }
+    constexpr bool operator!=(monostate, monostate) noexcept
+    {
+        return false;
+    }
+
+    //------------------------------------------------------------------------------
+    // `absl::variant` Template Definition
+    //------------------------------------------------------------------------------
+    template<typename T0, typename... Tn>
+    class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...>
+    {
+        static_assert(absl::conjunction<std::is_object<T0>, std::is_object<Tn>...>::value, "Attempted to instantiate a variant containing a non-object "
+                                                                                           "type.");
+        // Intentionally not qualifying `negation` with `absl::` to work around a bug
+        // in MSVC 2015 with inline namespace and variadic template.
+        static_assert(absl::conjunction<negation<std::is_array<T0>>, negation<std::is_array<Tn>>...>::value, "Attempted to instantiate a variant containing an array type.");
+        static_assert(absl::conjunction<std::is_nothrow_destructible<T0>, std::is_nothrow_destructible<Tn>...>::value, "Attempted to instantiate a variant containing a non-nothrow "
+                                                                                                                       "destructible type.");
+
+        friend struct variant_internal::VariantCoreAccess;
+
+    private:
+        using Base = variant_internal::VariantBase<T0, Tn...>;
+
+    public:
+        // Constructors
+
+        // Constructs a variant holding a default-initialized value of the first
+        // alternative type.
+        constexpr variant() /*noexcept(see 111above)*/ = default;
+
+        // Copy constructor, standard semantics
+        variant(const variant& other) = default;
+
+        // Move constructor, standard semantics
+        variant(variant&& other) /*noexcept(see above)*/ = default;
+
+        // Constructs a variant of an alternative type specified by overload
+        // resolution of the provided forwarding arguments through
+        // direct-initialization.
+        //
+        // Note: If the selected constructor is a constexpr constructor, this
+        // constructor shall be a constexpr constructor.
+        //
+        // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
+        // has been voted passed the design phase in the C++ standard meeting in Mar
+        // 2018. It will be implemented and integrated into `absl::variant`.
+        template<
+            class T,
+            std::size_t I = std::enable_if<
+                variant_internal::IsNeitherSelfNorInPlace<variant, absl::decay_t<T>>::value,
+                variant_internal::IndexOfConstructedType<variant, T>>::type::value,
+            class Tj = absl::variant_alternative_t<I, variant>,
+            absl::enable_if_t<std::is_constructible<Tj, T>::value>* =
+                nullptr>
+        constexpr variant(T&& t) noexcept(std::is_nothrow_constructible<Tj, T>::value) :
+            Base(variant_internal::EmplaceTag<I>(), absl::forward<T>(t))
+        {
+        }
+
+        // Constructs a variant of an alternative type from the arguments through
+        // direct-initialization.
+        //
+        // Note: If the selected constructor is a constexpr constructor, this
+        // constructor shall be a constexpr constructor.
+        template<class T, class... Args, typename std::enable_if<std::is_constructible<variant_internal::UnambiguousTypeOfT<variant, T>, Args...>::value>::type* = nullptr>
+        constexpr explicit variant(in_place_type_t<T>, Args&&... args) :
+            Base(variant_internal::EmplaceTag<variant_internal::UnambiguousIndexOf<variant, T>::value>(), absl::forward<Args>(args)...)
+        {
+        }
+
+        // Constructs a variant of an alternative type from an initializer list
+        // and other arguments through direct-initialization.
+        //
+        // Note: If the selected constructor is a constexpr constructor, this
+        // constructor shall be a constexpr constructor.
+        template<class T, class U, class... Args, typename std::enable_if<std::is_constructible<variant_internal::UnambiguousTypeOfT<variant, T>, std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+        constexpr explicit variant(in_place_type_t<T>, std::initializer_list<U> il, Args&&... args) :
+            Base(variant_internal::EmplaceTag<variant_internal::UnambiguousIndexOf<variant, T>::value>(), il, absl::forward<Args>(args)...)
+        {
+        }
+
+        // Constructs a variant of an alternative type from a provided index,
+        // through value-initialization using the provided forwarded arguments.
+        template<std::size_t I, class... Args, typename std::enable_if<std::is_constructible<variant_internal::VariantAlternativeSfinaeT<I, variant>, Args...>::value>::type* = nullptr>
+        constexpr explicit variant(in_place_index_t<I>, Args&&... args) :
+            Base(variant_internal::EmplaceTag<I>(), absl::forward<Args>(args)...)
+        {
+        }
+
+        // Constructs a variant of an alternative type from a provided index,
+        // through value-initialization of an initializer list and the provided
+        // forwarded arguments.
+        template<std::size_t I, class U, class... Args, typename std::enable_if<std::is_constructible<variant_internal::VariantAlternativeSfinaeT<I, variant>, std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+        constexpr explicit variant(in_place_index_t<I>, std::initializer_list<U> il, Args&&... args) :
+            Base(variant_internal::EmplaceTag<I>(), il, absl::forward<Args>(args)...)
+        {
+        }
+
+        // Destructors
+
+        // Destroys the variant's currently contained value, provided that
+        // `absl::valueless_by_exception()` is false.
+        ~variant() = default;
+
+        // Assignment Operators
+
+        // Copy assignment operator
+        variant& operator=(const variant& other) = default;
+
+        // Move assignment operator
+        variant& operator=(variant&& other) /*noexcept(see above)*/ = default;
+
+        // Converting assignment operator
+        //
+        // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
+        // has been voted passed the design phase in the C++ standard meeting in Mar
+        // 2018. It will be implemented and integrated into `absl::variant`.
+        template<
+            class T,
+            std::size_t I = std::enable_if<
+                !std::is_same<absl::decay_t<T>, variant>::value,
+                variant_internal::IndexOfConstructedType<variant, T>>::type::value,
+            class Tj = absl::variant_alternative_t<I, variant>,
+            typename std::enable_if<std::is_assignable<Tj&, T>::value && std::is_constructible<Tj, T>::value>::type* =
+                nullptr>
+        variant& operator=(T&& t) noexcept(
+            std::is_nothrow_assignable<Tj&, T>::value&&
+                std::is_nothrow_constructible<Tj, T>::value
+        )
+        {
+            variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
+                variant_internal::VariantCoreAccess::MakeConversionAssignVisitor(
+                    this, absl::forward<T>(t)
+                ),
+                index()
+            );
+
+            return *this;
+        }
+
+        // emplace() Functions
+
+        // Constructs a value of the given alternative type T within the variant. The
+        // existing value of the variant is destroyed first (provided that
+        // `absl::valueless_by_exception()` is false). Requires that T is unambiguous
+        // in the variant.
+        //
+        // Example:
+        //
+        //   absl::variant<std::vector<int>, int, std::string> v;
+        //   v.emplace<int>(99);
+        //   v.emplace<std::string>("abc");
+        template<
+            class T,
+            class... Args,
             typename std::enable_if<std::is_constructible<
-                variant_internal::UnambiguousTypeOfT<variant, T>,
+                absl::variant_alternative_t<
+                    variant_internal::UnambiguousIndexOf<variant, T>::value,
+                    variant>,
                 Args...>::value>::type* = nullptr>
-  constexpr explicit variant(in_place_type_t<T>, Args&&... args)
-      : Base(variant_internal::EmplaceTag<
-                 variant_internal::UnambiguousIndexOf<variant, T>::value>(),
-             absl::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from an initializer list
-  // and other arguments through direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  template <class T, class U, class... Args,
+        T& emplace(Args&&... args)
+        {
+            return variant_internal::VariantCoreAccess::Replace<
+                variant_internal::UnambiguousIndexOf<variant, T>::value>(
+                this, absl::forward<Args>(args)...
+            );
+        }
+
+        // Constructs a value of the given alternative type T within the variant using
+        // an initializer list. The existing value of the variant is destroyed first
+        // (provided that `absl::valueless_by_exception()` is false). Requires that T
+        // is unambiguous in the variant.
+        //
+        // Example:
+        //
+        //   absl::variant<std::vector<int>, int, std::string> v;
+        //   v.emplace<std::vector<int>>({0, 1, 2});
+        template<
+            class T,
+            class U,
+            class... Args,
             typename std::enable_if<std::is_constructible<
-                variant_internal::UnambiguousTypeOfT<variant, T>,
-                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
-  constexpr explicit variant(in_place_type_t<T>, std::initializer_list<U> il,
-                             Args&&... args)
-      : Base(variant_internal::EmplaceTag<
-                 variant_internal::UnambiguousIndexOf<variant, T>::value>(),
-             il, absl::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from a provided index,
-  // through value-initialization using the provided forwarded arguments.
-  template <std::size_t I, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::VariantAlternativeSfinaeT<I, variant>,
+                absl::variant_alternative_t<
+                    variant_internal::UnambiguousIndexOf<variant, T>::value,
+                    variant>,
+                std::initializer_list<U>&,
                 Args...>::value>::type* = nullptr>
-  constexpr explicit variant(in_place_index_t<I>, Args&&... args)
-      : Base(variant_internal::EmplaceTag<I>(), absl::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from a provided index,
-  // through value-initialization of an initializer list and the provided
-  // forwarded arguments.
-  template <std::size_t I, class U, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::VariantAlternativeSfinaeT<I, variant>,
-                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
-  constexpr explicit variant(in_place_index_t<I>, std::initializer_list<U> il,
-                             Args&&... args)
-      : Base(variant_internal::EmplaceTag<I>(), il,
-             absl::forward<Args>(args)...) {}
-
-  // Destructors
-
-  // Destroys the variant's currently contained value, provided that
-  // `absl::valueless_by_exception()` is false.
-  ~variant() = default;
-
-  // Assignment Operators
-
-  // Copy assignment operator
-  variant& operator=(const variant& other) = default;
-
-  // Move assignment operator
-  variant& operator=(variant&& other) /*noexcept(see above)*/ = default;
-
-  // Converting assignment operator
-  //
-  // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
-  // has been voted passed the design phase in the C++ standard meeting in Mar
-  // 2018. It will be implemented and integrated into `absl::variant`.
-  template <
-      class T,
-      std::size_t I = std::enable_if<
-          !std::is_same<absl::decay_t<T>, variant>::value,
-          variant_internal::IndexOfConstructedType<variant, T>>::type::value,
-      class Tj = absl::variant_alternative_t<I, variant>,
-      typename std::enable_if<std::is_assignable<Tj&, T>::value &&
-                              std::is_constructible<Tj, T>::value>::type* =
-          nullptr>
-  variant& operator=(T&& t) noexcept(
-      std::is_nothrow_assignable<Tj&, T>::value&&
-          std::is_nothrow_constructible<Tj, T>::value) {
-    variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
-        variant_internal::VariantCoreAccess::MakeConversionAssignVisitor(
-            this, absl::forward<T>(t)),
-        index());
-
-    return *this;
-  }
-
-
-  // emplace() Functions
-
-  // Constructs a value of the given alternative type T within the variant. The
-  // existing value of the variant is destroyed first (provided that
-  // `absl::valueless_by_exception()` is false). Requires that T is unambiguous
-  // in the variant.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, std::string> v;
-  //   v.emplace<int>(99);
-  //   v.emplace<std::string>("abc");
-  template <
-      class T, class... Args,
-      typename std::enable_if<std::is_constructible<
-          absl::variant_alternative_t<
-              variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
-          Args...>::value>::type* = nullptr>
-  T& emplace(Args&&... args) {
-    return variant_internal::VariantCoreAccess::Replace<
-        variant_internal::UnambiguousIndexOf<variant, T>::value>(
-        this, absl::forward<Args>(args)...);
-  }
-
-  // Constructs a value of the given alternative type T within the variant using
-  // an initializer list. The existing value of the variant is destroyed first
-  // (provided that `absl::valueless_by_exception()` is false). Requires that T
-  // is unambiguous in the variant.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, std::string> v;
-  //   v.emplace<std::vector<int>>({0, 1, 2});
-  template <
-      class T, class U, class... Args,
-      typename std::enable_if<std::is_constructible<
-          absl::variant_alternative_t<
-              variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
-          std::initializer_list<U>&, Args...>::value>::type* = nullptr>
-  T& emplace(std::initializer_list<U> il, Args&&... args) {
-    return variant_internal::VariantCoreAccess::Replace<
-        variant_internal::UnambiguousIndexOf<variant, T>::value>(
-        this, il, absl::forward<Args>(args)...);
-  }
-
-  // Destroys the current value of the variant (provided that
-  // `absl::valueless_by_exception()` is false) and constructs a new value at
-  // the given index.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, int> v;
-  //   v.emplace<1>(99);
-  //   v.emplace<2>(98);
-  //   v.emplace<int>(99);  // Won't compile. 'int' isn't a unique type.
-  template <std::size_t I, class... Args,
-            typename std::enable_if<
-                std::is_constructible<absl::variant_alternative_t<I, variant>,
-                                      Args...>::value>::type* = nullptr>
-  absl::variant_alternative_t<I, variant>& emplace(Args&&... args) {
-    return variant_internal::VariantCoreAccess::Replace<I>(
-        this, absl::forward<Args>(args)...);
-  }
-
-  // Destroys the current value of the variant (provided that
-  // `absl::valueless_by_exception()` is false) and constructs a new value at
-  // the given index using an initializer list and the provided arguments.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, int> v;
-  //   v.emplace<0>({0, 1, 2});
-  template <std::size_t I, class U, class... Args,
-            typename std::enable_if<std::is_constructible<
-                absl::variant_alternative_t<I, variant>,
-                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
-  absl::variant_alternative_t<I, variant>& emplace(std::initializer_list<U> il,
-                                                   Args&&... args) {
-    return variant_internal::VariantCoreAccess::Replace<I>(
-        this, il, absl::forward<Args>(args)...);
-  }
-
-  // variant::valueless_by_exception()
-  //
-  // Returns false if and only if the variant currently holds a valid value.
-  constexpr bool valueless_by_exception() const noexcept {
-    return this->index_ == absl::variant_npos;
-  }
-
-  // variant::index()
-  //
-  // Returns the index value of the variant's currently selected alternative
-  // type.
-  constexpr std::size_t index() const noexcept { return this->index_; }
-
-  // variant::swap()
-  //
-  // Swaps the values of two variant objects.
-  //
-  void swap(variant& rhs) noexcept(
-      absl::conjunction<
-          std::is_nothrow_move_constructible<T0>,
-          std::is_nothrow_move_constructible<Tn>...,
-          type_traits_internal::IsNothrowSwappable<T0>,
-          type_traits_internal::IsNothrowSwappable<Tn>...>::value) {
-    return variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
-        variant_internal::Swap<T0, Tn...>{this, &rhs}, rhs.index());
-  }
-};
-
-// We need a valid declaration of variant<> for SFINAE and overload resolution
-// to work properly above, but we don't need a full declaration since this type
-// will never be constructed. This declaration, though incomplete, suffices.
-template <>
-class variant<>;
-
-//------------------------------------------------------------------------------
-// Relational Operators
-//------------------------------------------------------------------------------
-//
-// If neither operand is in the `variant::valueless_by_exception` state:
-//
-//   * If the index of both variants is the same, the relational operator
-//     returns the result of the corresponding relational operator for the
-//     corresponding alternative type.
-//   * If the index of both variants is not the same, the relational operator
-//     returns the result of that operation applied to the value of the left
-//     operand's index and the value of the right operand's index.
-//   * If at least one operand is in the valueless_by_exception state:
-//     - A variant in the valueless_by_exception state is only considered equal
-//       to another variant in the valueless_by_exception state.
-//     - If exactly one operand is in the valueless_by_exception state, the
-//       variant in the valueless_by_exception state is less than the variant
-//       that is not in the valueless_by_exception state.
-//
-// Note: The value 1 is added to each index in the relational comparisons such
-// that the index corresponding to the valueless_by_exception state wraps around
-// to 0 (the lowest value for the index type), and the remaining indices stay in
-// the same relative order.
-
-// Equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveEqualT<Types...> operator==(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() == b.index()) &&
-         variant_internal::VisitIndices<sizeof...(Types)>::Run(
-             variant_internal::EqualsOp<Types...>{&a, &b}, a.index());
-}
-
-// Not equal operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveNotEqualT<Types...> operator!=(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index()) ||
-         variant_internal::VisitIndices<sizeof...(Types)>::Run(
-             variant_internal::NotEqualsOp<Types...>{&a, &b}, a.index());
-}
-
-// Less-than operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveLessThanT<Types...> operator<(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) < (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::LessThanOp<Types...>{&a, &b}, a.index());
-}
-
-// Greater-than operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveGreaterThanT<Types...> operator>(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) > (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::GreaterThanOp<Types...>{&a, &b},
-                   a.index());
-}
-
-// Less-than or equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...> operator<=(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) < (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::LessThanOrEqualsOp<Types...>{&a, &b},
-                   a.index());
-}
-
-// Greater-than or equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...>
-operator>=(const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) > (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::GreaterThanOrEqualsOp<Types...>{&a, &b},
-                   a.index());
-}
-
-ABSL_NAMESPACE_END
+        T& emplace(std::initializer_list<U> il, Args&&... args)
+        {
+            return variant_internal::VariantCoreAccess::Replace<
+                variant_internal::UnambiguousIndexOf<variant, T>::value>(
+                this, il, absl::forward<Args>(args)...
+            );
+        }
+
+        // Destroys the current value of the variant (provided that
+        // `absl::valueless_by_exception()` is false) and constructs a new value at
+        // the given index.
+        //
+        // Example:
+        //
+        //   absl::variant<std::vector<int>, int, int> v;
+        //   v.emplace<1>(99);
+        //   v.emplace<2>(98);
+        //   v.emplace<int>(99);  // Won't compile. 'int' isn't a unique type.
+        template<std::size_t I, class... Args, typename std::enable_if<std::is_constructible<absl::variant_alternative_t<I, variant>, Args...>::value>::type* = nullptr>
+        absl::variant_alternative_t<I, variant>& emplace(Args&&... args)
+        {
+            return variant_internal::VariantCoreAccess::Replace<I>(
+                this, absl::forward<Args>(args)...
+            );
+        }
+
+        // Destroys the current value of the variant (provided that
+        // `absl::valueless_by_exception()` is false) and constructs a new value at
+        // the given index using an initializer list and the provided arguments.
+        //
+        // Example:
+        //
+        //   absl::variant<std::vector<int>, int, int> v;
+        //   v.emplace<0>({0, 1, 2});
+        template<std::size_t I, class U, class... Args, typename std::enable_if<std::is_constructible<absl::variant_alternative_t<I, variant>, std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+        absl::variant_alternative_t<I, variant>& emplace(std::initializer_list<U> il, Args&&... args)
+        {
+            return variant_internal::VariantCoreAccess::Replace<I>(
+                this, il, absl::forward<Args>(args)...
+            );
+        }
+
+        // variant::valueless_by_exception()
+        //
+        // Returns false if and only if the variant currently holds a valid value.
+        constexpr bool valueless_by_exception() const noexcept
+        {
+            return this->index_ == absl::variant_npos;
+        }
+
+        // variant::index()
+        //
+        // Returns the index value of the variant's currently selected alternative
+        // type.
+        constexpr std::size_t index() const noexcept
+        {
+            return this->index_;
+        }
+
+        // variant::swap()
+        //
+        // Swaps the values of two variant objects.
+        //
+        void swap(variant& rhs) noexcept(
+            absl::conjunction<
+                std::is_nothrow_move_constructible<T0>,
+                std::is_nothrow_move_constructible<Tn>...,
+                type_traits_internal::IsNothrowSwappable<T0>,
+                type_traits_internal::IsNothrowSwappable<Tn>...>::value
+        )
+        {
+            return variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
+                variant_internal::Swap<T0, Tn...>{this, &rhs}, rhs.index()
+            );
+        }
+    };
+
+    // We need a valid declaration of variant<> for SFINAE and overload resolution
+    // to work properly above, but we don't need a full declaration since this type
+    // will never be constructed. This declaration, though incomplete, suffices.
+    template<>
+    class variant<>;
+
+    //------------------------------------------------------------------------------
+    // Relational Operators
+    //------------------------------------------------------------------------------
+    //
+    // If neither operand is in the `variant::valueless_by_exception` state:
+    //
+    //   * If the index of both variants is the same, the relational operator
+    //     returns the result of the corresponding relational operator for the
+    //     corresponding alternative type.
+    //   * If the index of both variants is not the same, the relational operator
+    //     returns the result of that operation applied to the value of the left
+    //     operand's index and the value of the right operand's index.
+    //   * If at least one operand is in the valueless_by_exception state:
+    //     - A variant in the valueless_by_exception state is only considered equal
+    //       to another variant in the valueless_by_exception state.
+    //     - If exactly one operand is in the valueless_by_exception state, the
+    //       variant in the valueless_by_exception state is less than the variant
+    //       that is not in the valueless_by_exception state.
+    //
+    // Note: The value 1 is added to each index in the relational comparisons such
+    // that the index corresponding to the valueless_by_exception state wraps around
+    // to 0 (the lowest value for the index type), and the remaining indices stay in
+    // the same relative order.
+
+    // Equal-to operator
+    template<typename... Types>
+    constexpr variant_internal::RequireAllHaveEqualT<Types...> operator==(
+        const variant<Types...>& a, const variant<Types...>& b
+    )
+    {
+        return (a.index() == b.index()) &&
+               variant_internal::VisitIndices<sizeof...(Types)>::Run(
+                   variant_internal::EqualsOp<Types...>{&a, &b}, a.index()
+               );
+    }
+
+    // Not equal operator
+    template<typename... Types>
+    constexpr variant_internal::RequireAllHaveNotEqualT<Types...> operator!=(
+        const variant<Types...>& a, const variant<Types...>& b
+    )
+    {
+        return (a.index() != b.index()) ||
+               variant_internal::VisitIndices<sizeof...(Types)>::Run(
+                   variant_internal::NotEqualsOp<Types...>{&a, &b}, a.index()
+               );
+    }
+
+    // Less-than operator
+    template<typename... Types>
+    constexpr variant_internal::RequireAllHaveLessThanT<Types...> operator<(
+        const variant<Types...>& a, const variant<Types...>& b
+    )
+    {
+        return (a.index() != b.index()) ? (a.index() + 1) < (b.index() + 1) : variant_internal::VisitIndices<sizeof...(Types)>::Run(variant_internal::LessThanOp<Types...>{&a, &b}, a.index());
+    }
+
+    // Greater-than operator
+    template<typename... Types>
+    constexpr variant_internal::RequireAllHaveGreaterThanT<Types...> operator>(
+        const variant<Types...>& a, const variant<Types...>& b
+    )
+    {
+        return (a.index() != b.index()) ? (a.index() + 1) > (b.index() + 1) : variant_internal::VisitIndices<sizeof...(Types)>::Run(variant_internal::GreaterThanOp<Types...>{&a, &b}, a.index());
+    }
+
+    // Less-than or equal-to operator
+    template<typename... Types>
+    constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...> operator<=(
+        const variant<Types...>& a, const variant<Types...>& b
+    )
+    {
+        return (a.index() != b.index()) ? (a.index() + 1) < (b.index() + 1) : variant_internal::VisitIndices<sizeof...(Types)>::Run(variant_internal::LessThanOrEqualsOp<Types...>{&a, &b}, a.index());
+    }
+
+    // Greater-than or equal-to operator
+    template<typename... Types>
+    constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...>
+        operator>=(const variant<Types...>& a, const variant<Types...>& b)
+    {
+        return (a.index() != b.index()) ? (a.index() + 1) > (b.index() + 1) : variant_internal::VisitIndices<sizeof...(Types)>::Run(variant_internal::GreaterThanOrEqualsOp<Types...>{&a, &b}, a.index());
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
-namespace std {
+namespace std
+{
 
-// hash()
-template <>  // NOLINT
-struct hash<absl::monostate> {
-  std::size_t operator()(absl::monostate) const { return 0; }
-};
+    // hash()
+    template<>  // NOLINT
+    struct hash<absl::monostate>
+    {
+        std::size_t operator()(absl::monostate) const
+        {
+            return 0;
+        }
+    };
 
-template <class... T>  // NOLINT
-struct hash<absl::variant<T...>>
-    : absl::variant_internal::VariantHashBase<absl::variant<T...>, void,
-                                              absl::remove_const_t<T>...> {};
+    template<class... T>  // NOLINT
+    struct hash<absl::variant<T...>> : absl::variant_internal::VariantHashBase<absl::variant<T...>, void, absl::remove_const_t<T>...>
+    {
+    };
 
 }  // namespace std
 
 #endif  // ABSL_USES_STD_VARIANT
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace variant_internal {
-
-// Helper visitor for converting a variant<Ts...>` into another type (mostly
-// variant) that can be constructed from any type.
-template <typename To>
-struct ConversionVisitor {
-  template <typename T>
-  To operator()(T&& v) const {
-    return To(std::forward<T>(v));
-  }
-};
-
-}  // namespace variant_internal
-
-// ConvertVariantTo()
-//
-// Helper functions to convert an `absl::variant` to a variant of another set of
-// types, provided that the alternative type of the new variant type can be
-// converted from any type in the source variant.
-//
-// Example:
-//
-//   absl::variant<name1, name2, float> InternalReq(const Req&);
-//
-//   // name1 and name2 are convertible to name
-//   absl::variant<name, float> ExternalReq(const Req& req) {
-//     return absl::ConvertVariantTo<absl::variant<name, float>>(
-//              InternalReq(req));
-//   }
-template <typename To, typename Variant>
-To ConvertVariantTo(Variant&& variant) {
-  return absl::visit(variant_internal::ConversionVisitor<To>{},
-                     std::forward<Variant>(variant));
-}
-
-ABSL_NAMESPACE_END
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+    namespace variant_internal
+    {
+
+        // Helper visitor for converting a variant<Ts...>` into another type (mostly
+        // variant) that can be constructed from any type.
+        template<typename To>
+        struct ConversionVisitor
+        {
+            template<typename T>
+            To operator()(T&& v) const
+            {
+                return To(std::forward<T>(v));
+            }
+        };
+
+    }  // namespace variant_internal
+
+    // ConvertVariantTo()
+    //
+    // Helper functions to convert an `absl::variant` to a variant of another set of
+    // types, provided that the alternative type of the new variant type can be
+    // converted from any type in the source variant.
+    //
+    // Example:
+    //
+    //   absl::variant<name1, name2, float> InternalReq(const Req&);
+    //
+    //   // name1 and name2 are convertible to name
+    //   absl::variant<name, float> ExternalReq(const Req& req) {
+    //     return absl::ConvertVariantTo<absl::variant<name, float>>(
+    //              InternalReq(req));
+    //   }
+    template<typename To, typename Variant>
+    To ConvertVariantTo(Variant&& variant)
+    {
+        return absl::visit(variant_internal::ConversionVisitor<To>{}, std::forward<Variant>(variant));
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_TYPES_VARIANT_H_
diff --git a/CAPI/cpp/grpc/include/absl/utility/utility.h b/CAPI/cpp/grpc/include/absl/utility/utility.h
index bf92322..3ca3f79 100644
--- a/CAPI/cpp/grpc/include/absl/utility/utility.h
+++ b/CAPI/cpp/grpc/include/absl/utility/utility.h
@@ -50,301 +50,330 @@
 #include "absl/base/internal/invoke.h"
 #include "absl/meta/type_traits.h"
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// integer_sequence
-//
-// Class template representing a compile-time integer sequence. An instantiation
-// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
-// type through its template arguments (which is a common need when
-// working with C++11 variadic templates). `absl::integer_sequence` is designed
-// to be a drop-in replacement for C++14's `std::integer_sequence`.
-//
-// Example:
-//
-//   template< class T, T... Ints >
-//   void user_function(integer_sequence<T, Ints...>);
-//
-//   int main()
-//   {
-//     // user_function's `T` will be deduced to `int` and `Ints...`
-//     // will be deduced to `0, 1, 2, 3, 4`.
-//     user_function(make_integer_sequence<int, 5>());
-//   }
-template <typename T, T... Ints>
-struct integer_sequence {
-  using value_type = T;
-  static constexpr size_t size() noexcept { return sizeof...(Ints); }
-};
-
-// index_sequence
-//
-// A helper template for an `integer_sequence` of `size_t`,
-// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
-// `std::index_sequence`.
-template <size_t... Ints>
-using index_sequence = integer_sequence<size_t, Ints...>;
-
-namespace utility_internal {
-
-template <typename Seq, size_t SeqSize, size_t Rem>
-struct Extend;
-
-// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
-template <typename T, T... Ints, size_t SeqSize>
-struct Extend<integer_sequence<T, Ints...>, SeqSize, 0> {
-  using type = integer_sequence<T, Ints..., (Ints + SeqSize)...>;
-};
-
-template <typename T, T... Ints, size_t SeqSize>
-struct Extend<integer_sequence<T, Ints...>, SeqSize, 1> {
-  using type = integer_sequence<T, Ints..., (Ints + SeqSize)..., 2 * SeqSize>;
-};
-
-// Recursion helper for 'make_integer_sequence<T, N>'.
-// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
-template <typename T, size_t N>
-struct Gen {
-  using type =
-      typename Extend<typename Gen<T, N / 2>::type, N / 2, N % 2>::type;
-};
-
-template <typename T>
-struct Gen<T, 0> {
-  using type = integer_sequence<T>;
-};
-
-template <typename T>
-struct InPlaceTypeTag {
-  explicit InPlaceTypeTag() = delete;
-  InPlaceTypeTag(const InPlaceTypeTag&) = delete;
-  InPlaceTypeTag& operator=(const InPlaceTypeTag&) = delete;
-};
-
-template <size_t I>
-struct InPlaceIndexTag {
-  explicit InPlaceIndexTag() = delete;
-  InPlaceIndexTag(const InPlaceIndexTag&) = delete;
-  InPlaceIndexTag& operator=(const InPlaceIndexTag&) = delete;
-};
-
-}  // namespace utility_internal
-
-// Compile-time sequences of integers
-
-// make_integer_sequence
-//
-// This template alias is equivalent to
-// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
-// replacement for C++14's `std::make_integer_sequence`.
-template <typename T, T N>
-using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
-
-// make_index_sequence
-//
-// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
-// and is designed to be a drop-in replacement for C++14's
-// `std::make_index_sequence`.
-template <size_t N>
-using make_index_sequence = make_integer_sequence<size_t, N>;
-
-// index_sequence_for
-//
-// Converts a typename pack into an index sequence of the same length, and
-// is designed to be a drop-in replacement for C++14's
-// `std::index_sequence_for()`
-template <typename... Ts>
-using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-
-// Tag types
+namespace absl
+{
+    ABSL_NAMESPACE_BEGIN
+
+    // integer_sequence
+    //
+    // Class template representing a compile-time integer sequence. An instantiation
+    // of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+    // type through its template arguments (which is a common need when
+    // working with C++11 variadic templates). `absl::integer_sequence` is designed
+    // to be a drop-in replacement for C++14's `std::integer_sequence`.
+    //
+    // Example:
+    //
+    //   template< class T, T... Ints >
+    //   void user_function(integer_sequence<T, Ints...>);
+    //
+    //   int main()
+    //   {
+    //     // user_function's `T` will be deduced to `int` and `Ints...`
+    //     // will be deduced to `0, 1, 2, 3, 4`.
+    //     user_function(make_integer_sequence<int, 5>());
+    //   }
+    template<typename T, T... Ints>
+    struct integer_sequence
+    {
+        using value_type = T;
+        static constexpr size_t size() noexcept
+        {
+            return sizeof...(Ints);
+        }
+    };
+
+    // index_sequence
+    //
+    // A helper template for an `integer_sequence` of `size_t`,
+    // `absl::index_sequence` is designed to be a drop-in replacement for C++14's
+    // `std::index_sequence`.
+    template<size_t... Ints>
+    using index_sequence = integer_sequence<size_t, Ints...>;
+
+    namespace utility_internal
+    {
+
+        template<typename Seq, size_t SeqSize, size_t Rem>
+        struct Extend;
+
+        // Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+        template<typename T, T... Ints, size_t SeqSize>
+        struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
+        {
+            using type = integer_sequence<T, Ints..., (Ints + SeqSize)...>;
+        };
+
+        template<typename T, T... Ints, size_t SeqSize>
+        struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
+        {
+            using type = integer_sequence<T, Ints..., (Ints + SeqSize)..., 2 * SeqSize>;
+        };
+
+        // Recursion helper for 'make_integer_sequence<T, N>'.
+        // 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+        template<typename T, size_t N>
+        struct Gen
+        {
+            using type =
+                typename Extend<typename Gen<T, N / 2>::type, N / 2, N % 2>::type;
+        };
+
+        template<typename T>
+        struct Gen<T, 0>
+        {
+            using type = integer_sequence<T>;
+        };
+
+        template<typename T>
+        struct InPlaceTypeTag
+        {
+            explicit InPlaceTypeTag() = delete;
+            InPlaceTypeTag(const InPlaceTypeTag&) = delete;
+            InPlaceTypeTag& operator=(const InPlaceTypeTag&) = delete;
+        };
+
+        template<size_t I>
+        struct InPlaceIndexTag
+        {
+            explicit InPlaceIndexTag() = delete;
+            InPlaceIndexTag(const InPlaceIndexTag&) = delete;
+            InPlaceIndexTag& operator=(const InPlaceIndexTag&) = delete;
+        };
+
+    }  // namespace utility_internal
+
+    // Compile-time sequences of integers
+
+    // make_integer_sequence
+    //
+    // This template alias is equivalent to
+    // `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+    // replacement for C++14's `std::make_integer_sequence`.
+    template<typename T, T N>
+    using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+    // make_index_sequence
+    //
+    // This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+    // and is designed to be a drop-in replacement for C++14's
+    // `std::make_index_sequence`.
+    template<size_t N>
+    using make_index_sequence = make_integer_sequence<size_t, N>;
+
+    // index_sequence_for
+    //
+    // Converts a typename pack into an index sequence of the same length, and
+    // is designed to be a drop-in replacement for C++14's
+    // `std::index_sequence_for()`
+    template<typename... Ts>
+    using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+    // Tag types
 
 #ifdef ABSL_USES_STD_OPTIONAL
 
-using std::in_place_t;
-using std::in_place;
+    using std::in_place;
+    using std::in_place_t;
 
 #else  // ABSL_USES_STD_OPTIONAL
 
-// in_place_t
-//
-// Tag type used to specify in-place construction, such as with
-// `absl::optional`, designed to be a drop-in replacement for C++17's
-// `std::in_place_t`.
-struct in_place_t {};
+    // in_place_t
+    //
+    // Tag type used to specify in-place construction, such as with
+    // `absl::optional`, designed to be a drop-in replacement for C++17's
+    // `std::in_place_t`.
+    struct in_place_t
+    {
+    };
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
+    ABSL_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
 
 #endif  // ABSL_USES_STD_OPTIONAL
 
 #if defined(ABSL_USES_STD_ANY) || defined(ABSL_USES_STD_VARIANT)
-using std::in_place_type;
-using std::in_place_type_t;
+    using std::in_place_type;
+    using std::in_place_type_t;
 #else
 
-// in_place_type_t
-//
-// Tag type used for in-place construction when the type to construct needs to
-// be specified, such as with `absl::any`, designed to be a drop-in replacement
-// for C++17's `std::in_place_type_t`.
-template <typename T>
-using in_place_type_t = void (*)(utility_internal::InPlaceTypeTag<T>);
-
-template <typename T>
-void in_place_type(utility_internal::InPlaceTypeTag<T>) {}
+    // in_place_type_t
+    //
+    // Tag type used for in-place construction when the type to construct needs to
+    // be specified, such as with `absl::any`, designed to be a drop-in replacement
+    // for C++17's `std::in_place_type_t`.
+    template<typename T>
+    using in_place_type_t = void (*)(utility_internal::InPlaceTypeTag<T>);
+
+    template<typename T>
+    void in_place_type(utility_internal::InPlaceTypeTag<T>)
+    {
+    }
 #endif  // ABSL_USES_STD_ANY || ABSL_USES_STD_VARIANT
 
 #ifdef ABSL_USES_STD_VARIANT
-using std::in_place_index;
-using std::in_place_index_t;
+    using std::in_place_index;
+    using std::in_place_index_t;
 #else
 
-// in_place_index_t
-//
-// Tag type used for in-place construction when the type to construct needs to
-// be specified, such as with `absl::any`, designed to be a drop-in replacement
-// for C++17's `std::in_place_index_t`.
-template <size_t I>
-using in_place_index_t = void (*)(utility_internal::InPlaceIndexTag<I>);
-
-template <size_t I>
-void in_place_index(utility_internal::InPlaceIndexTag<I>) {}
+    // in_place_index_t
+    //
+    // Tag type used for in-place construction when the type to construct needs to
+    // be specified, such as with `absl::any`, designed to be a drop-in replacement
+    // for C++17's `std::in_place_index_t`.
+    template<size_t I>
+    using in_place_index_t = void (*)(utility_internal::InPlaceIndexTag<I>);
+
+    template<size_t I>
+    void in_place_index(utility_internal::InPlaceIndexTag<I>)
+    {
+    }
 #endif  // ABSL_USES_STD_VARIANT
 
-// Constexpr move and forward
-
-// move()
-//
-// A constexpr version of `std::move()`, designed to be a drop-in replacement
-// for C++14's `std::move()`.
-template <typename T>
-constexpr absl::remove_reference_t<T>&& move(T&& t) noexcept {
-  return static_cast<absl::remove_reference_t<T>&&>(t);
-}
-
-// forward()
-//
-// A constexpr version of `std::forward()`, designed to be a drop-in replacement
-// for C++14's `std::forward()`.
-template <typename T>
-constexpr T&& forward(
-    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
-  return static_cast<T&&>(t);
-}
-
-namespace utility_internal {
-// Helper method for expanding tuple into a called method.
-template <typename Functor, typename Tuple, std::size_t... Indexes>
-auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>)
-    -> decltype(absl::base_internal::invoke(
-        absl::forward<Functor>(functor),
-        std::get<Indexes>(absl::forward<Tuple>(t))...)) {
-  return absl::base_internal::invoke(
-      absl::forward<Functor>(functor),
-      std::get<Indexes>(absl::forward<Tuple>(t))...);
-}
-
-}  // namespace utility_internal
-
-// apply
-//
-// Invokes a Callable using elements of a tuple as its arguments.
-// Each element of the tuple corresponds to an argument of the call (in order).
-// Both the Callable argument and the tuple argument are perfect-forwarded.
-// For member-function Callables, the first tuple element acts as the `this`
-// pointer. `absl::apply` is designed to be a drop-in replacement for C++17's
-// `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`.
-//
-// Example:
-//
-//   class Foo {
-//    public:
-//     void Bar(int);
-//   };
-//   void user_function1(int, std::string);
-//   void user_function2(std::unique_ptr<Foo>);
-//   auto user_lambda = [](int, int) {};
-//
-//   int main()
-//   {
-//       std::tuple<int, std::string> tuple1(42, "bar");
-//       // Invokes the first user function on int, std::string.
-//       absl::apply(&user_function1, tuple1);
-//
-//       std::tuple<std::unique_ptr<Foo>> tuple2(absl::make_unique<Foo>());
-//       // Invokes the user function that takes ownership of the unique
-//       // pointer.
-//       absl::apply(&user_function2, std::move(tuple2));
-//
-//       auto foo = absl::make_unique<Foo>();
-//       std::tuple<Foo*, int> tuple3(foo.get(), 42);
-//       // Invokes the method Bar on foo with one argument, 42.
-//       absl::apply(&Foo::Bar, tuple3);
-//
-//       std::tuple<int, int> tuple4(8, 9);
-//       // Invokes a lambda.
-//       absl::apply(user_lambda, tuple4);
-//   }
-template <typename Functor, typename Tuple>
-auto apply(Functor&& functor, Tuple&& t)
-    -> decltype(utility_internal::apply_helper(
-        absl::forward<Functor>(functor), absl::forward<Tuple>(t),
-        absl::make_index_sequence<std::tuple_size<
-            typename std::remove_reference<Tuple>::type>::value>{})) {
-  return utility_internal::apply_helper(
-      absl::forward<Functor>(functor), absl::forward<Tuple>(t),
-      absl::make_index_sequence<std::tuple_size<
-          typename std::remove_reference<Tuple>::type>::value>{});
-}
-
-// exchange
-//
-// Replaces the value of `obj` with `new_value` and returns the old value of
-// `obj`.  `absl::exchange` is designed to be a drop-in replacement for C++14's
-// `std::exchange`.
-//
-// Example:
-//
-//   Foo& operator=(Foo&& other) {
-//     ptr1_ = absl::exchange(other.ptr1_, nullptr);
-//     int1_ = absl::exchange(other.int1_, -1);
-//     return *this;
-//   }
-template <typename T, typename U = T>
-T exchange(T& obj, U&& new_value) {
-  T old_value = absl::move(obj);
-  obj = absl::forward<U>(new_value);
-  return old_value;
-}
-
-namespace utility_internal {
-template <typename T, typename Tuple, size_t... I>
-T make_from_tuple_impl(Tuple&& tup, absl::index_sequence<I...>) {
-  return T(std::get<I>(std::forward<Tuple>(tup))...);
-}
-}  // namespace utility_internal
-
-// make_from_tuple
-//
-// Given the template parameter type `T` and a tuple of arguments
-// `std::tuple(arg0, arg1, ..., argN)` constructs an object of type `T` as if by
-// calling `T(arg0, arg1, ..., argN)`.
-//
-// Example:
-//
-//   std::tuple<const char*, size_t> args("hello world", 5);
-//   auto s = absl::make_from_tuple<std::string>(args);
-//   assert(s == "hello");
-//
-template <typename T, typename Tuple>
-constexpr T make_from_tuple(Tuple&& tup) {
-  return utility_internal::make_from_tuple_impl<T>(
-      std::forward<Tuple>(tup),
-      absl::make_index_sequence<
-          std::tuple_size<absl::decay_t<Tuple>>::value>{});
-}
-
-ABSL_NAMESPACE_END
+    // Constexpr move and forward
+
+    // move()
+    //
+    // A constexpr version of `std::move()`, designed to be a drop-in replacement
+    // for C++14's `std::move()`.
+    template<typename T>
+    constexpr absl::remove_reference_t<T>&& move(T&& t) noexcept
+    {
+        return static_cast<absl::remove_reference_t<T>&&>(t);
+    }
+
+    // forward()
+    //
+    // A constexpr version of `std::forward()`, designed to be a drop-in replacement
+    // for C++14's `std::forward()`.
+    template<typename T>
+    constexpr T&& forward(
+        absl::remove_reference_t<T>& t
+    ) noexcept
+    {  // NOLINT(runtime/references)
+        return static_cast<T&&>(t);
+    }
+
+    namespace utility_internal
+    {
+        // Helper method for expanding tuple into a called method.
+        template<typename Functor, typename Tuple, std::size_t... Indexes>
+        auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>)
+            -> decltype(absl::base_internal::invoke(
+                absl::forward<Functor>(functor),
+                std::get<Indexes>(absl::forward<Tuple>(t))...
+            ))
+        {
+            return absl::base_internal::invoke(
+                absl::forward<Functor>(functor),
+                std::get<Indexes>(absl::forward<Tuple>(t))...
+            );
+        }
+
+    }  // namespace utility_internal
+
+    // apply
+    //
+    // Invokes a Callable using elements of a tuple as its arguments.
+    // Each element of the tuple corresponds to an argument of the call (in order).
+    // Both the Callable argument and the tuple argument are perfect-forwarded.
+    // For member-function Callables, the first tuple element acts as the `this`
+    // pointer. `absl::apply` is designed to be a drop-in replacement for C++17's
+    // `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`.
+    //
+    // Example:
+    //
+    //   class Foo {
+    //    public:
+    //     void Bar(int);
+    //   };
+    //   void user_function1(int, std::string);
+    //   void user_function2(std::unique_ptr<Foo>);
+    //   auto user_lambda = [](int, int) {};
+    //
+    //   int main()
+    //   {
+    //       std::tuple<int, std::string> tuple1(42, "bar");
+    //       // Invokes the first user function on int, std::string.
+    //       absl::apply(&user_function1, tuple1);
+    //
+    //       std::tuple<std::unique_ptr<Foo>> tuple2(absl::make_unique<Foo>());
+    //       // Invokes the user function that takes ownership of the unique
+    //       // pointer.
+    //       absl::apply(&user_function2, std::move(tuple2));
+    //
+    //       auto foo = absl::make_unique<Foo>();
+    //       std::tuple<Foo*, int> tuple3(foo.get(), 42);
+    //       // Invokes the method Bar on foo with one argument, 42.
+    //       absl::apply(&Foo::Bar, tuple3);
+    //
+    //       std::tuple<int, int> tuple4(8, 9);
+    //       // Invokes a lambda.
+    //       absl::apply(user_lambda, tuple4);
+    //   }
+    template<typename Functor, typename Tuple>
+    auto apply(Functor&& functor, Tuple&& t)
+        -> decltype(utility_internal::apply_helper(
+            absl::forward<Functor>(functor), absl::forward<Tuple>(t), absl::make_index_sequence<std::tuple_size<typename std::remove_reference<Tuple>::type>::value>{}
+        ))
+    {
+        return utility_internal::apply_helper(
+            absl::forward<Functor>(functor), absl::forward<Tuple>(t), absl::make_index_sequence<std::tuple_size<typename std::remove_reference<Tuple>::type>::value>{}
+        );
+    }
+
+    // exchange
+    //
+    // Replaces the value of `obj` with `new_value` and returns the old value of
+    // `obj`.  `absl::exchange` is designed to be a drop-in replacement for C++14's
+    // `std::exchange`.
+    //
+    // Example:
+    //
+    //   Foo& operator=(Foo&& other) {
+    //     ptr1_ = absl::exchange(other.ptr1_, nullptr);
+    //     int1_ = absl::exchange(other.int1_, -1);
+    //     return *this;
+    //   }
+    template<typename T, typename U = T>
+    T exchange(T& obj, U&& new_value)
+    {
+        T old_value = absl::move(obj);
+        obj = absl::forward<U>(new_value);
+        return old_value;
+    }
+
+    namespace utility_internal
+    {
+        template<typename T, typename Tuple, size_t... I>
+        T make_from_tuple_impl(Tuple&& tup, absl::index_sequence<I...>)
+        {
+            return T(std::get<I>(std::forward<Tuple>(tup))...);
+        }
+    }  // namespace utility_internal
+
+    // make_from_tuple
+    //
+    // Given the template parameter type `T` and a tuple of arguments
+    // `std::tuple(arg0, arg1, ..., argN)` constructs an object of type `T` as if by
+    // calling `T(arg0, arg1, ..., argN)`.
+    //
+    // Example:
+    //
+    //   std::tuple<const char*, size_t> args("hello world", 5);
+    //   auto s = absl::make_from_tuple<std::string>(args);
+    //   assert(s == "hello");
+    //
+    template<typename T, typename Tuple>
+    constexpr T make_from_tuple(Tuple&& tup)
+    {
+        return utility_internal::make_from_tuple_impl<T>(
+            std::forward<Tuple>(tup),
+            absl::make_index_sequence<
+                std::tuple_size<absl::decay_t<Tuple>>::value>{}
+        );
+    }
+
+    ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_UTILITY_UTILITY_H_
diff --git a/CAPI/cpp/grpc/include/ares.h b/CAPI/cpp/grpc/include/ares.h
index 9831ff2..fd1f15e 100644
--- a/CAPI/cpp/grpc/include/ares.h
+++ b/CAPI/cpp/grpc/include/ares.h
@@ -18,17 +18,17 @@
 #ifndef ARES__H
 #define ARES__H
 
-#include "ares_version.h"  /* c-ares version defines   */
-#include "ares_build.h"    /* c-ares build definitions */
-#include "ares_rules.h"    /* c-ares rules enforcement */
+#include "ares_version.h" /* c-ares version defines   */
+#include "ares_build.h"   /* c-ares build definitions */
+#include "ares_rules.h"   /* c-ares rules enforcement */
 
 /*
  * Define WIN32 when build target is Win32 API
  */
 
 #if (defined(_WIN32) || defined(__WIN32__)) && \
-   !defined(WIN32) && !defined(__SYMBIAN32__)
-#  define WIN32
+    !defined(WIN32) && !defined(__SYMBIAN32__)
+#define WIN32
 #endif
 
 #include <sys/types.h>
@@ -36,9 +36,9 @@
 /* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish
    libc5-based Linux systems. Only include it on system that are known to
    require it! */
-#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \
+#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) ||   \
     defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \
-    defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) || \
+    defined(ANDROID) || defined(__ANDROID__) || defined(__OpenBSD__) ||   \
     defined(__QNXNTO__) || defined(__MVS__) || defined(__HAIKU__)
 #include <sys/select.h>
 #endif
@@ -47,708 +47,582 @@
 #endif
 
 #if defined(WATT32)
-#  include <netinet/in.h>
-#  include <sys/socket.h>
-#  include <tcp.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <tcp.h>
 #elif defined(_WIN32_WCE)
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  include <windows.h>
-#  include <winsock.h>
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock.h>
 #elif defined(WIN32)
-#  ifndef WIN32_LEAN_AND_MEAN
-#    define WIN32_LEAN_AND_MEAN
-#  endif
-#  include <windows.h>
-#  include <winsock2.h>
-#  include <ws2tcpip.h>
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
 #else
-#  include <sys/socket.h>
-#  include <netinet/in.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
 #endif
 
 #if defined(ANDROID) || defined(__ANDROID__)
 #include <jni.h>
 #endif
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-/*
-** c-ares external API function linkage decorations.
-*/
+    /*
+    ** c-ares external API function linkage decorations.
+    */
 
 #if 1
-#  define CARES_EXTERN
+#define CARES_EXTERN
 #elif defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)
-#  if defined(CARES_BUILDING_LIBRARY)
-#    define CARES_EXTERN  __declspec(dllexport)
-#  else
-#    define CARES_EXTERN  __declspec(dllimport)
-#  endif
+#if defined(CARES_BUILDING_LIBRARY)
+#define CARES_EXTERN __declspec(dllexport)
+#else
+#define CARES_EXTERN __declspec(dllimport)
+#endif
 #elif defined(CARES_BUILDING_LIBRARY) && defined(CARES_SYMBOL_HIDING)
-#  define CARES_EXTERN CARES_SYMBOL_SCOPE_EXTERN
+#define CARES_EXTERN CARES_SYMBOL_SCOPE_EXTERN
 #else
-#  define CARES_EXTERN
+#define CARES_EXTERN
 #endif
 
-
-#define ARES_SUCCESS            0
+#define ARES_SUCCESS 0
 
 /* Server error codes (ARES_ENODATA indicates no relevant answer) */
-#define ARES_ENODATA            1
-#define ARES_EFORMERR           2
-#define ARES_ESERVFAIL          3
-#define ARES_ENOTFOUND          4
-#define ARES_ENOTIMP            5
-#define ARES_EREFUSED           6
+#define ARES_ENODATA 1
+#define ARES_EFORMERR 2
+#define ARES_ESERVFAIL 3
+#define ARES_ENOTFOUND 4
+#define ARES_ENOTIMP 5
+#define ARES_EREFUSED 6
 
 /* Locally generated error codes */
-#define ARES_EBADQUERY          7
-#define ARES_EBADNAME           8
-#define ARES_EBADFAMILY         9
-#define ARES_EBADRESP           10
-#define ARES_ECONNREFUSED       11
-#define ARES_ETIMEOUT           12
-#define ARES_EOF                13
-#define ARES_EFILE              14
-#define ARES_ENOMEM             15
-#define ARES_EDESTRUCTION       16
-#define ARES_EBADSTR            17
+#define ARES_EBADQUERY 7
+#define ARES_EBADNAME 8
+#define ARES_EBADFAMILY 9
+#define ARES_EBADRESP 10
+#define ARES_ECONNREFUSED 11
+#define ARES_ETIMEOUT 12
+#define ARES_EOF 13
+#define ARES_EFILE 14
+#define ARES_ENOMEM 15
+#define ARES_EDESTRUCTION 16
+#define ARES_EBADSTR 17
 
 /* ares_getnameinfo error codes */
-#define ARES_EBADFLAGS          18
+#define ARES_EBADFLAGS 18
 
 /* ares_getaddrinfo error codes */
-#define ARES_ENONAME            19
-#define ARES_EBADHINTS          20
+#define ARES_ENONAME 19
+#define ARES_EBADHINTS 20
 
 /* Uninitialized library error code */
-#define ARES_ENOTINITIALIZED    21          /* introduced in 1.7.0 */
+#define ARES_ENOTINITIALIZED 21 /* introduced in 1.7.0 */
 
 /* ares_library_init error codes */
-#define ARES_ELOADIPHLPAPI           22     /* introduced in 1.7.0 */
-#define ARES_EADDRGETNETWORKPARAMS   23     /* introduced in 1.7.0 */
+#define ARES_ELOADIPHLPAPI 22         /* introduced in 1.7.0 */
+#define ARES_EADDRGETNETWORKPARAMS 23 /* introduced in 1.7.0 */
 
 /* More error codes */
-#define ARES_ECANCELLED         24          /* introduced in 1.7.0 */
+#define ARES_ECANCELLED 24 /* introduced in 1.7.0 */
 
 /* More ares_getaddrinfo error codes */
-#define ARES_ESERVICE           25          /* introduced in 1.?.0 */
+#define ARES_ESERVICE 25 /* introduced in 1.?.0 */
 
 /* Flag values */
-#define ARES_FLAG_USEVC         (1 << 0)
-#define ARES_FLAG_PRIMARY       (1 << 1)
-#define ARES_FLAG_IGNTC         (1 << 2)
-#define ARES_FLAG_NORECURSE     (1 << 3)
-#define ARES_FLAG_STAYOPEN      (1 << 4)
-#define ARES_FLAG_NOSEARCH      (1 << 5)
-#define ARES_FLAG_NOALIASES     (1 << 6)
-#define ARES_FLAG_NOCHECKRESP   (1 << 7)
-#define ARES_FLAG_EDNS          (1 << 8)
+#define ARES_FLAG_USEVC (1 << 0)
+#define ARES_FLAG_PRIMARY (1 << 1)
+#define ARES_FLAG_IGNTC (1 << 2)
+#define ARES_FLAG_NORECURSE (1 << 3)
+#define ARES_FLAG_STAYOPEN (1 << 4)
+#define ARES_FLAG_NOSEARCH (1 << 5)
+#define ARES_FLAG_NOALIASES (1 << 6)
+#define ARES_FLAG_NOCHECKRESP (1 << 7)
+#define ARES_FLAG_EDNS (1 << 8)
 
 /* Option mask values */
-#define ARES_OPT_FLAGS          (1 << 0)
-#define ARES_OPT_TIMEOUT        (1 << 1)
-#define ARES_OPT_TRIES          (1 << 2)
-#define ARES_OPT_NDOTS          (1 << 3)
-#define ARES_OPT_UDP_PORT       (1 << 4)
-#define ARES_OPT_TCP_PORT       (1 << 5)
-#define ARES_OPT_SERVERS        (1 << 6)
-#define ARES_OPT_DOMAINS        (1 << 7)
-#define ARES_OPT_LOOKUPS        (1 << 8)
-#define ARES_OPT_SOCK_STATE_CB  (1 << 9)
-#define ARES_OPT_SORTLIST       (1 << 10)
-#define ARES_OPT_SOCK_SNDBUF    (1 << 11)
-#define ARES_OPT_SOCK_RCVBUF    (1 << 12)
-#define ARES_OPT_TIMEOUTMS      (1 << 13)
-#define ARES_OPT_ROTATE         (1 << 14)
-#define ARES_OPT_EDNSPSZ        (1 << 15)
-#define ARES_OPT_NOROTATE       (1 << 16)
-#define ARES_OPT_RESOLVCONF     (1 << 17)
+#define ARES_OPT_FLAGS (1 << 0)
+#define ARES_OPT_TIMEOUT (1 << 1)
+#define ARES_OPT_TRIES (1 << 2)
+#define ARES_OPT_NDOTS (1 << 3)
+#define ARES_OPT_UDP_PORT (1 << 4)
+#define ARES_OPT_TCP_PORT (1 << 5)
+#define ARES_OPT_SERVERS (1 << 6)
+#define ARES_OPT_DOMAINS (1 << 7)
+#define ARES_OPT_LOOKUPS (1 << 8)
+#define ARES_OPT_SOCK_STATE_CB (1 << 9)
+#define ARES_OPT_SORTLIST (1 << 10)
+#define ARES_OPT_SOCK_SNDBUF (1 << 11)
+#define ARES_OPT_SOCK_RCVBUF (1 << 12)
+#define ARES_OPT_TIMEOUTMS (1 << 13)
+#define ARES_OPT_ROTATE (1 << 14)
+#define ARES_OPT_EDNSPSZ (1 << 15)
+#define ARES_OPT_NOROTATE (1 << 16)
+#define ARES_OPT_RESOLVCONF (1 << 17)
 
 /* Nameinfo flag values */
-#define ARES_NI_NOFQDN                  (1 << 0)
-#define ARES_NI_NUMERICHOST             (1 << 1)
-#define ARES_NI_NAMEREQD                (1 << 2)
-#define ARES_NI_NUMERICSERV             (1 << 3)
-#define ARES_NI_DGRAM                   (1 << 4)
-#define ARES_NI_TCP                     0
-#define ARES_NI_UDP                     ARES_NI_DGRAM
-#define ARES_NI_SCTP                    (1 << 5)
-#define ARES_NI_DCCP                    (1 << 6)
-#define ARES_NI_NUMERICSCOPE            (1 << 7)
-#define ARES_NI_LOOKUPHOST              (1 << 8)
-#define ARES_NI_LOOKUPSERVICE           (1 << 9)
+#define ARES_NI_NOFQDN (1 << 0)
+#define ARES_NI_NUMERICHOST (1 << 1)
+#define ARES_NI_NAMEREQD (1 << 2)
+#define ARES_NI_NUMERICSERV (1 << 3)
+#define ARES_NI_DGRAM (1 << 4)
+#define ARES_NI_TCP 0
+#define ARES_NI_UDP ARES_NI_DGRAM
+#define ARES_NI_SCTP (1 << 5)
+#define ARES_NI_DCCP (1 << 6)
+#define ARES_NI_NUMERICSCOPE (1 << 7)
+#define ARES_NI_LOOKUPHOST (1 << 8)
+#define ARES_NI_LOOKUPSERVICE (1 << 9)
 /* Reserved for future use */
-#define ARES_NI_IDN                     (1 << 10)
-#define ARES_NI_IDN_ALLOW_UNASSIGNED    (1 << 11)
+#define ARES_NI_IDN (1 << 10)
+#define ARES_NI_IDN_ALLOW_UNASSIGNED (1 << 11)
 #define ARES_NI_IDN_USE_STD3_ASCII_RULES (1 << 12)
 
 /* Addrinfo flag values */
-#define ARES_AI_CANONNAME               (1 << 0)
-#define ARES_AI_NUMERICHOST             (1 << 1)
-#define ARES_AI_PASSIVE                 (1 << 2)
-#define ARES_AI_NUMERICSERV             (1 << 3)
-#define ARES_AI_V4MAPPED                (1 << 4)
-#define ARES_AI_ALL                     (1 << 5)
-#define ARES_AI_ADDRCONFIG              (1 << 6)
-#define ARES_AI_NOSORT                  (1 << 7)
-#define ARES_AI_ENVHOSTS                (1 << 8)
+#define ARES_AI_CANONNAME (1 << 0)
+#define ARES_AI_NUMERICHOST (1 << 1)
+#define ARES_AI_PASSIVE (1 << 2)
+#define ARES_AI_NUMERICSERV (1 << 3)
+#define ARES_AI_V4MAPPED (1 << 4)
+#define ARES_AI_ALL (1 << 5)
+#define ARES_AI_ADDRCONFIG (1 << 6)
+#define ARES_AI_NOSORT (1 << 7)
+#define ARES_AI_ENVHOSTS (1 << 8)
 /* Reserved for future use */
-#define ARES_AI_IDN                     (1 << 10)
-#define ARES_AI_IDN_ALLOW_UNASSIGNED    (1 << 11)
+#define ARES_AI_IDN (1 << 10)
+#define ARES_AI_IDN_ALLOW_UNASSIGNED (1 << 11)
 #define ARES_AI_IDN_USE_STD3_ASCII_RULES (1 << 12)
-#define ARES_AI_CANONIDN                (1 << 13)
+#define ARES_AI_CANONIDN (1 << 13)
 
-#define ARES_AI_MASK (ARES_AI_CANONNAME|ARES_AI_NUMERICHOST|ARES_AI_PASSIVE| \
-                      ARES_AI_NUMERICSERV|ARES_AI_V4MAPPED|ARES_AI_ALL| \
-                      ARES_AI_ADDRCONFIG)
-#define ARES_GETSOCK_MAXNUM 16 /* ares_getsock() can return info about this
+#define ARES_AI_MASK (ARES_AI_CANONNAME | ARES_AI_NUMERICHOST | ARES_AI_PASSIVE | ARES_AI_NUMERICSERV | ARES_AI_V4MAPPED | ARES_AI_ALL | ARES_AI_ADDRCONFIG)
+#define ARES_GETSOCK_MAXNUM 16 /* ares_getsock() can return info about this \
                                   many sockets */
-#define ARES_GETSOCK_READABLE(bits,num) (bits & (1<< (num)))
-#define ARES_GETSOCK_WRITABLE(bits,num) (bits & (1 << ((num) + \
-                                         ARES_GETSOCK_MAXNUM)))
+#define ARES_GETSOCK_READABLE(bits, num) (bits & (1 << (num)))
+#define ARES_GETSOCK_WRITABLE(bits, num) (bits & (1 << ((num) + ARES_GETSOCK_MAXNUM)))
 
 /* c-ares library initialization flag values */
-#define ARES_LIB_INIT_NONE   (0)
-#define ARES_LIB_INIT_WIN32  (1 << 0)
-#define ARES_LIB_INIT_ALL    (ARES_LIB_INIT_WIN32)
+#define ARES_LIB_INIT_NONE (0)
+#define ARES_LIB_INIT_WIN32 (1 << 0)
+#define ARES_LIB_INIT_ALL (ARES_LIB_INIT_WIN32)
 
-
-/*
- * Typedef our socket type
- */
+    /*
+     * Typedef our socket type
+     */
 
 #ifndef ares_socket_typedef
 #ifdef WIN32
-typedef SOCKET ares_socket_t;
+    typedef SOCKET ares_socket_t;
 #define ARES_SOCKET_BAD INVALID_SOCKET
 #else
-typedef int ares_socket_t;
+    typedef int ares_socket_t;
 #define ARES_SOCKET_BAD -1
 #endif
 #define ares_socket_typedef
 #endif /* ares_socket_typedef */
 
-typedef void (*ares_sock_state_cb)(void *data,
-                                   ares_socket_t socket_fd,
-                                   int readable,
-                                   int writable);
+    typedef void (*ares_sock_state_cb)(void* data, ares_socket_t socket_fd, int readable, int writable);
 
-struct apattern;
+    struct apattern;
 
-/* NOTE about the ares_options struct to users and developers.
+    /* NOTE about the ares_options struct to users and developers.
 
-   This struct will remain looking like this. It will not be extended nor
-   shrunk in future releases, but all new options will be set by ares_set_*()
-   options instead of with the ares_init_options() function.
+       This struct will remain looking like this. It will not be extended nor
+       shrunk in future releases, but all new options will be set by ares_set_*()
+       options instead of with the ares_init_options() function.
 
-   Eventually (in a galaxy far far away), all options will be settable by
-   ares_set_*() options and the ares_init_options() function will become
-   deprecated.
+       Eventually (in a galaxy far far away), all options will be settable by
+       ares_set_*() options and the ares_init_options() function will become
+       deprecated.
 
-   When new options are added to c-ares, they are not added to this
-   struct. And they are not "saved" with the ares_save_options() function but
-   instead we encourage the use of the ares_dup() function. Needless to say,
-   if you add config options to c-ares you need to make sure ares_dup()
-   duplicates this new option.
+       When new options are added to c-ares, they are not added to this
+       struct. And they are not "saved" with the ares_save_options() function but
+       instead we encourage the use of the ares_dup() function. Needless to say,
+       if you add config options to c-ares you need to make sure ares_dup()
+       duplicates this new option.
 
- */
-struct ares_options {
-  int flags;
-  int timeout; /* in seconds or milliseconds, depending on options */
-  int tries;
-  int ndots;
-  unsigned short udp_port;
-  unsigned short tcp_port;
-  int socket_send_buffer_size;
-  int socket_receive_buffer_size;
-  struct in_addr *servers;
-  int nservers;
-  char **domains;
-  int ndomains;
-  char *lookups;
-  ares_sock_state_cb sock_state_cb;
-  void *sock_state_cb_data;
-  struct apattern *sortlist;
-  int nsort;
-  int ednspsz;
-  char *resolvconf_path;
-};
-
-struct hostent;
-struct timeval;
-struct sockaddr;
-struct ares_channeldata;
-struct ares_addrinfo;
-struct ares_addrinfo_hints;
-
-typedef struct ares_channeldata *ares_channel;
-
-typedef void (*ares_callback)(void *arg,
-                              int status,
-                              int timeouts,
-                              unsigned char *abuf,
-                              int alen);
-
-typedef void (*ares_host_callback)(void *arg,
-                                   int status,
-                                   int timeouts,
-                                   struct hostent *hostent);
-
-typedef void (*ares_nameinfo_callback)(void *arg,
-                                       int status,
-                                       int timeouts,
-                                       char *node,
-                                       char *service);
-
-typedef int  (*ares_sock_create_callback)(ares_socket_t socket_fd,
-                                          int type,
-                                          void *data);
-
-typedef int  (*ares_sock_config_callback)(ares_socket_t socket_fd,
-                                          int type,
-                                          void *data);
-
-typedef void (*ares_addrinfo_callback)(void *arg,
-                                   int status,
-                                   int timeouts,
-                                   struct ares_addrinfo *res);
-
-CARES_EXTERN int ares_library_init(int flags);
-
-CARES_EXTERN int ares_library_init_mem(int flags,
-                                       void *(*amalloc)(size_t size),
-                                       void (*afree)(void *ptr),
-                                       void *(*arealloc)(void *ptr, size_t size));
+     */
+    struct ares_options
+    {
+        int flags;
+        int timeout; /* in seconds or milliseconds, depending on options */
+        int tries;
+        int ndots;
+        unsigned short udp_port;
+        unsigned short tcp_port;
+        int socket_send_buffer_size;
+        int socket_receive_buffer_size;
+        struct in_addr* servers;
+        int nservers;
+        char** domains;
+        int ndomains;
+        char* lookups;
+        ares_sock_state_cb sock_state_cb;
+        void* sock_state_cb_data;
+        struct apattern* sortlist;
+        int nsort;
+        int ednspsz;
+        char* resolvconf_path;
+    };
+
+    struct hostent;
+    struct timeval;
+    struct sockaddr;
+    struct ares_channeldata;
+    struct ares_addrinfo;
+    struct ares_addrinfo_hints;
+
+    typedef struct ares_channeldata* ares_channel;
+
+    typedef void (*ares_callback)(void* arg, int status, int timeouts, unsigned char* abuf, int alen);
+
+    typedef void (*ares_host_callback)(void* arg, int status, int timeouts, struct hostent* hostent);
+
+    typedef void (*ares_nameinfo_callback)(void* arg, int status, int timeouts, char* node, char* service);
+
+    typedef int (*ares_sock_create_callback)(ares_socket_t socket_fd, int type, void* data);
+
+    typedef int (*ares_sock_config_callback)(ares_socket_t socket_fd, int type, void* data);
+
+    typedef void (*ares_addrinfo_callback)(void* arg, int status, int timeouts, struct ares_addrinfo* res);
+
+    CARES_EXTERN int ares_library_init(int flags);
+
+    CARES_EXTERN int ares_library_init_mem(int flags, void* (*amalloc)(size_t size), void (*afree)(void* ptr), void* (*arealloc)(void* ptr, size_t size));
 
 #if defined(ANDROID) || defined(__ANDROID__)
-CARES_EXTERN void ares_library_init_jvm(JavaVM *jvm);
-CARES_EXTERN int ares_library_init_android(jobject connectivity_manager);
-CARES_EXTERN int ares_library_android_initialized(void);
+    CARES_EXTERN void ares_library_init_jvm(JavaVM* jvm);
+    CARES_EXTERN int ares_library_init_android(jobject connectivity_manager);
+    CARES_EXTERN int ares_library_android_initialized(void);
 #endif
 
-CARES_EXTERN int ares_library_initialized(void);
+    CARES_EXTERN int ares_library_initialized(void);
 
-CARES_EXTERN void ares_library_cleanup(void);
+    CARES_EXTERN void ares_library_cleanup(void);
 
-CARES_EXTERN const char *ares_version(int *version);
+    CARES_EXTERN const char* ares_version(int* version);
 
-CARES_EXTERN int ares_init(ares_channel *channelptr);
+    CARES_EXTERN int ares_init(ares_channel* channelptr);
 
-CARES_EXTERN int ares_init_options(ares_channel *channelptr,
-                                   struct ares_options *options,
-                                   int optmask);
+    CARES_EXTERN int ares_init_options(ares_channel* channelptr, struct ares_options* options, int optmask);
 
-CARES_EXTERN int ares_save_options(ares_channel channel,
-                                   struct ares_options *options,
-                                   int *optmask);
+    CARES_EXTERN int ares_save_options(ares_channel channel, struct ares_options* options, int* optmask);
 
-CARES_EXTERN void ares_destroy_options(struct ares_options *options);
+    CARES_EXTERN void ares_destroy_options(struct ares_options* options);
 
-CARES_EXTERN int ares_dup(ares_channel *dest,
-                          ares_channel src);
+    CARES_EXTERN int ares_dup(ares_channel* dest, ares_channel src);
 
-CARES_EXTERN void ares_destroy(ares_channel channel);
+    CARES_EXTERN void ares_destroy(ares_channel channel);
 
-CARES_EXTERN void ares_cancel(ares_channel channel);
+    CARES_EXTERN void ares_cancel(ares_channel channel);
 
-/* These next 3 configure local binding for the out-going socket
- * connection.  Use these to specify source IP and/or network device
- * on multi-homed systems.
- */
-CARES_EXTERN void ares_set_local_ip4(ares_channel channel, unsigned int local_ip);
+    /* These next 3 configure local binding for the out-going socket
+     * connection.  Use these to specify source IP and/or network device
+     * on multi-homed systems.
+     */
+    CARES_EXTERN void ares_set_local_ip4(ares_channel channel, unsigned int local_ip);
 
-/* local_ip6 should be 16 bytes in length */
-CARES_EXTERN void ares_set_local_ip6(ares_channel channel,
-                                     const unsigned char* local_ip6);
+    /* local_ip6 should be 16 bytes in length */
+    CARES_EXTERN void ares_set_local_ip6(ares_channel channel, const unsigned char* local_ip6);
 
-/* local_dev_name should be null terminated. */
-CARES_EXTERN void ares_set_local_dev(ares_channel channel,
-                                     const char* local_dev_name);
+    /* local_dev_name should be null terminated. */
+    CARES_EXTERN void ares_set_local_dev(ares_channel channel, const char* local_dev_name);
 
-CARES_EXTERN void ares_set_socket_callback(ares_channel channel,
-                                           ares_sock_create_callback callback,
-                                           void *user_data);
+    CARES_EXTERN void ares_set_socket_callback(ares_channel channel, ares_sock_create_callback callback, void* user_data);
 
-CARES_EXTERN void ares_set_socket_configure_callback(ares_channel channel,
-                                                     ares_sock_config_callback callback,
-                                                     void *user_data);
+    CARES_EXTERN void ares_set_socket_configure_callback(ares_channel channel, ares_sock_config_callback callback, void* user_data);
 
-CARES_EXTERN int ares_set_sortlist(ares_channel channel,
-                                   const char *sortstr);
+    CARES_EXTERN int ares_set_sortlist(ares_channel channel, const char* sortstr);
 
-CARES_EXTERN void ares_getaddrinfo(ares_channel channel,
-                                   const char* node,
-                                   const char* service,
-                                   const struct ares_addrinfo_hints* hints,
-                                   ares_addrinfo_callback callback,
-                                   void* arg);
+    CARES_EXTERN void ares_getaddrinfo(ares_channel channel, const char* node, const char* service, const struct ares_addrinfo_hints* hints, ares_addrinfo_callback callback, void* arg);
 
-CARES_EXTERN void ares_freeaddrinfo(struct ares_addrinfo* ai);
+    CARES_EXTERN void ares_freeaddrinfo(struct ares_addrinfo* ai);
 
-/*
- * Virtual function set to have user-managed socket IO.
- * Note that all functions need to be defined, and when
- * set, the library will not do any bind nor set any
- * socket options, assuming the client handles these
- * through either socket creation or the
- * ares_sock_config_callback call.
- */
-struct iovec;
-struct ares_socket_functions {
-   ares_socket_t(*asocket)(int, int, int, void *);
-   int(*aclose)(ares_socket_t, void *);
-   int(*aconnect)(ares_socket_t, const struct sockaddr *, ares_socklen_t, void *);
-   ares_ssize_t(*arecvfrom)(ares_socket_t, void *, size_t, int, struct sockaddr *, ares_socklen_t *, void *);
-   ares_ssize_t(*asendv)(ares_socket_t, const struct iovec *, int, void *);
-};
-
-CARES_EXTERN void ares_set_socket_functions(ares_channel channel,
-					    const struct ares_socket_functions * funcs,
-					    void *user_data);
-
-CARES_EXTERN void ares_send(ares_channel channel,
-                            const unsigned char *qbuf,
-                            int qlen,
-                            ares_callback callback,
-                            void *arg);
-
-CARES_EXTERN void ares_query(ares_channel channel,
-                             const char *name,
-                             int dnsclass,
-                             int type,
-                             ares_callback callback,
-                             void *arg);
-
-CARES_EXTERN void ares_search(ares_channel channel,
-                              const char *name,
-                              int dnsclass,
-                              int type,
-                              ares_callback callback,
-                              void *arg);
-
-CARES_EXTERN void ares_gethostbyname(ares_channel channel,
-                                     const char *name,
-                                     int family,
-                                     ares_host_callback callback,
-                                     void *arg);
-
-CARES_EXTERN int ares_gethostbyname_file(ares_channel channel,
-                                         const char *name,
-                                         int family,
-                                         struct hostent **host);
-
-CARES_EXTERN void ares_gethostbyaddr(ares_channel channel,
-                                     const void *addr,
-                                     int addrlen,
-                                     int family,
-                                     ares_host_callback callback,
-                                     void *arg);
-
-CARES_EXTERN void ares_getnameinfo(ares_channel channel,
-                                   const struct sockaddr *sa,
-                                   ares_socklen_t salen,
-                                   int flags,
-                                   ares_nameinfo_callback callback,
-                                   void *arg);
-
-CARES_EXTERN int ares_fds(ares_channel channel,
-                          fd_set *read_fds,
-                          fd_set *write_fds);
-
-CARES_EXTERN int ares_getsock(ares_channel channel,
-                              ares_socket_t *socks,
-                              int numsocks);
-
-CARES_EXTERN struct timeval *ares_timeout(ares_channel channel,
-                                          struct timeval *maxtv,
-                                          struct timeval *tv);
-
-CARES_EXTERN void ares_process(ares_channel channel,
-                               fd_set *read_fds,
-                               fd_set *write_fds);
-
-CARES_EXTERN void ares_process_fd(ares_channel channel,
-                                  ares_socket_t read_fd,
-                                  ares_socket_t write_fd);
-
-CARES_EXTERN int ares_create_query(const char *name,
-                                   int dnsclass,
-                                   int type,
-                                   unsigned short id,
-                                   int rd,
-                                   unsigned char **buf,
-                                   int *buflen,
-                                   int max_udp_size);
-
-CARES_EXTERN int ares_mkquery(const char *name,
-                              int dnsclass,
-                              int type,
-                              unsigned short id,
-                              int rd,
-                              unsigned char **buf,
-                              int *buflen);
-
-CARES_EXTERN int ares_expand_name(const unsigned char *encoded,
-                                  const unsigned char *abuf,
-                                  int alen,
-                                  char **s,
-                                  long *enclen);
-
-CARES_EXTERN int ares_expand_string(const unsigned char *encoded,
-                                    const unsigned char *abuf,
-                                    int alen,
-                                    unsigned char **s,
-                                    long *enclen);
+    /*
+     * Virtual function set to have user-managed socket IO.
+     * Note that all functions need to be defined, and when
+     * set, the library will not do any bind nor set any
+     * socket options, assuming the client handles these
+     * through either socket creation or the
+     * ares_sock_config_callback call.
+     */
+    struct iovec;
+    struct ares_socket_functions
+    {
+        ares_socket_t (*asocket)(int, int, int, void*);
+        int (*aclose)(ares_socket_t, void*);
+        int (*aconnect)(ares_socket_t, const struct sockaddr*, ares_socklen_t, void*);
+        ares_ssize_t (*arecvfrom)(ares_socket_t, void*, size_t, int, struct sockaddr*, ares_socklen_t*, void*);
+        ares_ssize_t (*asendv)(ares_socket_t, const struct iovec*, int, void*);
+    };
 
-/*
- * NOTE: before c-ares 1.7.0 we would most often use the system in6_addr
- * struct below when ares itself was built, but many apps would use this
- * private version since the header checked a HAVE_* define for it. Starting
- * with 1.7.0 we always declare and use our own to stop relying on the
- * system's one.
- */
-struct ares_in6_addr {
-  union {
-    unsigned char _S6_u8[16];
-  } _S6_un;
-};
-
-struct ares_addrttl {
-  struct in_addr ipaddr;
-  int            ttl;
-};
-
-struct ares_addr6ttl {
-  struct ares_in6_addr ip6addr;
-  int             ttl;
-};
-
-struct ares_caa_reply {
-  struct ares_caa_reply  *next;
-  int                     critical;
-  unsigned char          *property;
-  size_t                  plength;  /* plength excludes null termination */
-  unsigned char          *value;
-  size_t                  length;   /* length excludes null termination */
-};
-
-struct ares_srv_reply {
-  struct ares_srv_reply  *next;
-  char                   *host;
-  unsigned short          priority;
-  unsigned short          weight;
-  unsigned short          port;
-};
-
-struct ares_mx_reply {
-  struct ares_mx_reply   *next;
-  char                   *host;
-  unsigned short          priority;
-};
-
-struct ares_txt_reply {
-  struct ares_txt_reply  *next;
-  unsigned char          *txt;
-  size_t                  length;  /* length excludes null termination */
-};
-
-/* NOTE: This structure is a superset of ares_txt_reply
- */
-struct ares_txt_ext {
-  struct ares_txt_ext      *next;
-  unsigned char            *txt;
-  size_t                   length;
-  /* 1 - if start of new record
-   * 0 - if a chunk in the same record */
-  unsigned char            record_start;
-};
-
-struct ares_naptr_reply {
-  struct ares_naptr_reply *next;
-  unsigned char           *flags;
-  unsigned char           *service;
-  unsigned char           *regexp;
-  char                    *replacement;
-  unsigned short           order;
-  unsigned short           preference;
-};
-
-struct ares_soa_reply {
-  char        *nsname;
-  char        *hostmaster;
-  unsigned int serial;
-  unsigned int refresh;
-  unsigned int retry;
-  unsigned int expire;
-  unsigned int minttl;
-};
-
-struct ares_uri_reply {
-  struct ares_uri_reply  *next;
-  unsigned short          priority;
-  unsigned short          weight;
-  char                   *uri;
-  int                     ttl;
-};
+    CARES_EXTERN void ares_set_socket_functions(ares_channel channel, const struct ares_socket_functions* funcs, void* user_data);
 
-/*
- * Similar to addrinfo, but with extra ttl and missing canonname.
- */
-struct ares_addrinfo_node {
-  int                        ai_ttl;
-  int                        ai_flags;
-  int                        ai_family;
-  int                        ai_socktype;
-  int                        ai_protocol;
-  ares_socklen_t             ai_addrlen;
-  struct sockaddr           *ai_addr;
-  struct ares_addrinfo_node *ai_next;
-};
+    CARES_EXTERN void ares_send(ares_channel channel, const unsigned char* qbuf, int qlen, ares_callback callback, void* arg);
 
-/*
- * alias - label of the resource record.
- * name - value (canonical name) of the resource record.
- * See RFC2181 10.1.1. CNAME terminology.
- */
-struct ares_addrinfo_cname {
-  int                         ttl;
-  char                       *alias;
-  char                       *name;
-  struct ares_addrinfo_cname *next;
-};
-
-struct ares_addrinfo {
-  struct ares_addrinfo_cname *cnames;
-  struct ares_addrinfo_node  *nodes;
-  char                       *name;
-};
-
-struct ares_addrinfo_hints {
-  int ai_flags;
-  int ai_family;
-  int ai_socktype;
-  int ai_protocol;
-};
+    CARES_EXTERN void ares_query(ares_channel channel, const char* name, int dnsclass, int type, ares_callback callback, void* arg);
 
-/*
-** Parse the buffer, starting at *abuf and of length alen bytes, previously
-** obtained from an ares_search call.  Put the results in *host, if nonnull.
-** Also, if addrttls is nonnull, put up to *naddrttls IPv4 addresses along with
-** their TTLs in that array, and set *naddrttls to the number of addresses
-** so written.
-*/
-
-CARES_EXTERN int ares_parse_a_reply(const unsigned char *abuf,
-                                    int alen,
-                                    struct hostent **host,
-                                    struct ares_addrttl *addrttls,
-                                    int *naddrttls);
-
-CARES_EXTERN int ares_parse_aaaa_reply(const unsigned char *abuf,
-                                       int alen,
-                                       struct hostent **host,
-                                       struct ares_addr6ttl *addrttls,
-                                       int *naddrttls);
-
-CARES_EXTERN int ares_parse_caa_reply(const unsigned char* abuf,
-				      int alen,
-				      struct ares_caa_reply** caa_out);
-
-CARES_EXTERN int ares_parse_ptr_reply(const unsigned char *abuf,
-                                      int alen,
-                                      const void *addr,
-                                      int addrlen,
-                                      int family,
-                                      struct hostent **host);
-
-CARES_EXTERN int ares_parse_ns_reply(const unsigned char *abuf,
-                                     int alen,
-                                     struct hostent **host);
-
-CARES_EXTERN int ares_parse_srv_reply(const unsigned char* abuf,
-                                      int alen,
-                                      struct ares_srv_reply** srv_out);
-
-CARES_EXTERN int ares_parse_mx_reply(const unsigned char* abuf,
-                                      int alen,
-                                      struct ares_mx_reply** mx_out);
-
-CARES_EXTERN int ares_parse_txt_reply(const unsigned char* abuf,
-                                      int alen,
-                                      struct ares_txt_reply** txt_out);
-
-CARES_EXTERN int ares_parse_txt_reply_ext(const unsigned char* abuf,
-                                          int alen,
-                                          struct ares_txt_ext** txt_out);
-
-CARES_EXTERN int ares_parse_naptr_reply(const unsigned char* abuf,
-                                        int alen,
-                                        struct ares_naptr_reply** naptr_out);
-
-CARES_EXTERN int ares_parse_soa_reply(const unsigned char* abuf,
-				      int alen,
-				      struct ares_soa_reply** soa_out);
-
-CARES_EXTERN int ares_parse_uri_reply(const unsigned char* abuf,
-                                      int alen,
-                                      struct ares_uri_reply** uri_out);
-
-CARES_EXTERN void ares_free_string(void *str);
-
-CARES_EXTERN void ares_free_hostent(struct hostent *host);
-
-CARES_EXTERN void ares_free_data(void *dataptr);
-
-CARES_EXTERN const char *ares_strerror(int code);
-
-struct ares_addr_node {
-  struct ares_addr_node *next;
-  int family;
-  union {
-    struct in_addr       addr4;
-    struct ares_in6_addr addr6;
-  } addr;
-};
-
-struct ares_addr_port_node {
-  struct ares_addr_port_node *next;
-  int family;
-  union {
-    struct in_addr       addr4;
-    struct ares_in6_addr addr6;
-  } addr;
-  int udp_port;
-  int tcp_port;
-};
-
-CARES_EXTERN int ares_set_servers(ares_channel channel,
-                                  struct ares_addr_node *servers);
-CARES_EXTERN int ares_set_servers_ports(ares_channel channel,
-                                        struct ares_addr_port_node *servers);
-
-/* Incomming string format: host[:port][,host[:port]]... */
-CARES_EXTERN int ares_set_servers_csv(ares_channel channel,
-                                      const char* servers);
-CARES_EXTERN int ares_set_servers_ports_csv(ares_channel channel,
-                                            const char* servers);
-
-CARES_EXTERN int ares_get_servers(ares_channel channel,
-                                  struct ares_addr_node **servers);
-CARES_EXTERN int ares_get_servers_ports(ares_channel channel,
-                                        struct ares_addr_port_node **servers);
-
-CARES_EXTERN const char *ares_inet_ntop(int af, const void *src, char *dst,
-                                        ares_socklen_t size);
-
-CARES_EXTERN int ares_inet_pton(int af, const char *src, void *dst);
-
-
-#ifdef  __cplusplus
+    CARES_EXTERN void ares_search(ares_channel channel, const char* name, int dnsclass, int type, ares_callback callback, void* arg);
+
+    CARES_EXTERN void ares_gethostbyname(ares_channel channel, const char* name, int family, ares_host_callback callback, void* arg);
+
+    CARES_EXTERN int ares_gethostbyname_file(ares_channel channel, const char* name, int family, struct hostent** host);
+
+    CARES_EXTERN void ares_gethostbyaddr(ares_channel channel, const void* addr, int addrlen, int family, ares_host_callback callback, void* arg);
+
+    CARES_EXTERN void ares_getnameinfo(ares_channel channel, const struct sockaddr* sa, ares_socklen_t salen, int flags, ares_nameinfo_callback callback, void* arg);
+
+    CARES_EXTERN int ares_fds(ares_channel channel, fd_set* read_fds, fd_set* write_fds);
+
+    CARES_EXTERN int ares_getsock(ares_channel channel, ares_socket_t* socks, int numsocks);
+
+    CARES_EXTERN struct timeval* ares_timeout(ares_channel channel, struct timeval* maxtv, struct timeval* tv);
+
+    CARES_EXTERN void ares_process(ares_channel channel, fd_set* read_fds, fd_set* write_fds);
+
+    CARES_EXTERN void ares_process_fd(ares_channel channel, ares_socket_t read_fd, ares_socket_t write_fd);
+
+    CARES_EXTERN int ares_create_query(const char* name, int dnsclass, int type, unsigned short id, int rd, unsigned char** buf, int* buflen, int max_udp_size);
+
+    CARES_EXTERN int ares_mkquery(const char* name, int dnsclass, int type, unsigned short id, int rd, unsigned char** buf, int* buflen);
+
+    CARES_EXTERN int ares_expand_name(const unsigned char* encoded, const unsigned char* abuf, int alen, char** s, long* enclen);
+
+    CARES_EXTERN int ares_expand_string(const unsigned char* encoded, const unsigned char* abuf, int alen, unsigned char** s, long* enclen);
+
+    /*
+     * NOTE: before c-ares 1.7.0 we would most often use the system in6_addr
+     * struct below when ares itself was built, but many apps would use this
+     * private version since the header checked a HAVE_* define for it. Starting
+     * with 1.7.0 we always declare and use our own to stop relying on the
+     * system's one.
+     */
+    struct ares_in6_addr
+    {
+        union
+        {
+            unsigned char _S6_u8[16];
+        } _S6_un;
+    };
+
+    struct ares_addrttl
+    {
+        struct in_addr ipaddr;
+        int ttl;
+    };
+
+    struct ares_addr6ttl
+    {
+        struct ares_in6_addr ip6addr;
+        int ttl;
+    };
+
+    struct ares_caa_reply
+    {
+        struct ares_caa_reply* next;
+        int critical;
+        unsigned char* property;
+        size_t plength; /* plength excludes null termination */
+        unsigned char* value;
+        size_t length; /* length excludes null termination */
+    };
+
+    struct ares_srv_reply
+    {
+        struct ares_srv_reply* next;
+        char* host;
+        unsigned short priority;
+        unsigned short weight;
+        unsigned short port;
+    };
+
+    struct ares_mx_reply
+    {
+        struct ares_mx_reply* next;
+        char* host;
+        unsigned short priority;
+    };
+
+    struct ares_txt_reply
+    {
+        struct ares_txt_reply* next;
+        unsigned char* txt;
+        size_t length; /* length excludes null termination */
+    };
+
+    /* NOTE: This structure is a superset of ares_txt_reply
+     */
+    struct ares_txt_ext
+    {
+        struct ares_txt_ext* next;
+        unsigned char* txt;
+        size_t length;
+        /* 1 - if start of new record
+         * 0 - if a chunk in the same record */
+        unsigned char record_start;
+    };
+
+    struct ares_naptr_reply
+    {
+        struct ares_naptr_reply* next;
+        unsigned char* flags;
+        unsigned char* service;
+        unsigned char* regexp;
+        char* replacement;
+        unsigned short order;
+        unsigned short preference;
+    };
+
+    struct ares_soa_reply
+    {
+        char* nsname;
+        char* hostmaster;
+        unsigned int serial;
+        unsigned int refresh;
+        unsigned int retry;
+        unsigned int expire;
+        unsigned int minttl;
+    };
+
+    struct ares_uri_reply
+    {
+        struct ares_uri_reply* next;
+        unsigned short priority;
+        unsigned short weight;
+        char* uri;
+        int ttl;
+    };
+
+    /*
+     * Similar to addrinfo, but with extra ttl and missing canonname.
+     */
+    struct ares_addrinfo_node
+    {
+        int ai_ttl;
+        int ai_flags;
+        int ai_family;
+        int ai_socktype;
+        int ai_protocol;
+        ares_socklen_t ai_addrlen;
+        struct sockaddr* ai_addr;
+        struct ares_addrinfo_node* ai_next;
+    };
+
+    /*
+     * alias - label of the resource record.
+     * name - value (canonical name) of the resource record.
+     * See RFC2181 10.1.1. CNAME terminology.
+     */
+    struct ares_addrinfo_cname
+    {
+        int ttl;
+        char* alias;
+        char* name;
+        struct ares_addrinfo_cname* next;
+    };
+
+    struct ares_addrinfo
+    {
+        struct ares_addrinfo_cname* cnames;
+        struct ares_addrinfo_node* nodes;
+        char* name;
+    };
+
+    struct ares_addrinfo_hints
+    {
+        int ai_flags;
+        int ai_family;
+        int ai_socktype;
+        int ai_protocol;
+    };
+
+    /*
+    ** Parse the buffer, starting at *abuf and of length alen bytes, previously
+    ** obtained from an ares_search call.  Put the results in *host, if nonnull.
+    ** Also, if addrttls is nonnull, put up to *naddrttls IPv4 addresses along with
+    ** their TTLs in that array, and set *naddrttls to the number of addresses
+    ** so written.
+    */
+
+    CARES_EXTERN int ares_parse_a_reply(const unsigned char* abuf, int alen, struct hostent** host, struct ares_addrttl* addrttls, int* naddrttls);
+
+    CARES_EXTERN int ares_parse_aaaa_reply(const unsigned char* abuf, int alen, struct hostent** host, struct ares_addr6ttl* addrttls, int* naddrttls);
+
+    CARES_EXTERN int ares_parse_caa_reply(const unsigned char* abuf, int alen, struct ares_caa_reply** caa_out);
+
+    CARES_EXTERN int ares_parse_ptr_reply(const unsigned char* abuf, int alen, const void* addr, int addrlen, int family, struct hostent** host);
+
+    CARES_EXTERN int ares_parse_ns_reply(const unsigned char* abuf, int alen, struct hostent** host);
+
+    CARES_EXTERN int ares_parse_srv_reply(const unsigned char* abuf, int alen, struct ares_srv_reply** srv_out);
+
+    CARES_EXTERN int ares_parse_mx_reply(const unsigned char* abuf, int alen, struct ares_mx_reply** mx_out);
+
+    CARES_EXTERN int ares_parse_txt_reply(const unsigned char* abuf, int alen, struct ares_txt_reply** txt_out);
+
+    CARES_EXTERN int ares_parse_txt_reply_ext(const unsigned char* abuf, int alen, struct ares_txt_ext** txt_out);
+
+    CARES_EXTERN int ares_parse_naptr_reply(const unsigned char* abuf, int alen, struct ares_naptr_reply** naptr_out);
+
+    CARES_EXTERN int ares_parse_soa_reply(const unsigned char* abuf, int alen, struct ares_soa_reply** soa_out);
+
+    CARES_EXTERN int ares_parse_uri_reply(const unsigned char* abuf, int alen, struct ares_uri_reply** uri_out);
+
+    CARES_EXTERN void ares_free_string(void* str);
+
+    CARES_EXTERN void ares_free_hostent(struct hostent* host);
+
+    CARES_EXTERN void ares_free_data(void* dataptr);
+
+    CARES_EXTERN const char* ares_strerror(int code);
+
+    struct ares_addr_node
+    {
+        struct ares_addr_node* next;
+        int family;
+        union
+        {
+            struct in_addr addr4;
+            struct ares_in6_addr addr6;
+        } addr;
+    };
+
+    struct ares_addr_port_node
+    {
+        struct ares_addr_port_node* next;
+        int family;
+        union
+        {
+            struct in_addr addr4;
+            struct ares_in6_addr addr6;
+        } addr;
+        int udp_port;
+        int tcp_port;
+    };
+
+    CARES_EXTERN int ares_set_servers(ares_channel channel, struct ares_addr_node* servers);
+    CARES_EXTERN int ares_set_servers_ports(ares_channel channel, struct ares_addr_port_node* servers);
+
+    /* Incomming string format: host[:port][,host[:port]]... */
+    CARES_EXTERN int ares_set_servers_csv(ares_channel channel, const char* servers);
+    CARES_EXTERN int ares_set_servers_ports_csv(ares_channel channel, const char* servers);
+
+    CARES_EXTERN int ares_get_servers(ares_channel channel, struct ares_addr_node** servers);
+    CARES_EXTERN int ares_get_servers_ports(ares_channel channel, struct ares_addr_port_node** servers);
+
+    CARES_EXTERN const char* ares_inet_ntop(int af, const void* src, char* dst, ares_socklen_t size);
+
+    CARES_EXTERN int ares_inet_pton(int af, const char* src, void* dst);
+
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/CAPI/cpp/grpc/include/ares_build.h b/CAPI/cpp/grpc/include/ares_build.h
index c3b9a31..c1891cb 100644
--- a/CAPI/cpp/grpc/include/ares_build.h
+++ b/CAPI/cpp/grpc/include/ares_build.h
@@ -17,26 +17,25 @@
 /* #undef CARES_HAVE_ARPA_NAMESER_COMPAT_H */
 
 #ifdef CARES_HAVE_SYS_TYPES_H
-#  include <sys/types.h>
+#include <sys/types.h>
 #endif
 
 #ifdef CARES_HAVE_SYS_SOCKET_H
-#  include <sys/socket.h>
+#include <sys/socket.h>
 #endif
 
 #ifdef CARES_HAVE_WINSOCK2_H
-#  include <winsock2.h>
+#include <winsock2.h>
 #endif
 
 #ifdef CARES_HAVE_WS2TCPIP_H
-#  include <ws2tcpip.h>
+#include <ws2tcpip.h>
 #endif
 
 #ifdef CARES_HAVE_WINDOWS_H
-#  include <windows.h>
+#include <windows.h>
 #endif
 
-
 typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;
 typedef CARES_TYPEOF_ARES_SSIZE_T ares_ssize_t;
 
diff --git a/CAPI/cpp/grpc/include/ares_dns.h b/CAPI/cpp/grpc/include/ares_dns.h
index bc8aa7b..d9f8db3 100644
--- a/CAPI/cpp/grpc/include/ares_dns.h
+++ b/CAPI/cpp/grpc/include/ares_dns.h
@@ -24,89 +24,78 @@
  * header in your project as it may be removed in the future.
  */
 
-
 /*
  * Macro DNS__16BIT reads a network short (16 bit) given in network
  * byte order, and returns its value as an unsigned short.
  */
-#define DNS__16BIT(p)  ((unsigned short)((unsigned int) 0xffff & \
-                         (((unsigned int)((unsigned char)(p)[0]) << 8U) | \
-                          ((unsigned int)((unsigned char)(p)[1])))))
+#define DNS__16BIT(p) ((unsigned short)((unsigned int)0xffff & (((unsigned int)((unsigned char)(p)[0]) << 8U) | ((unsigned int)((unsigned char)(p)[1])))))
 
 /*
  * Macro DNS__32BIT reads a network long (32 bit) given in network
  * byte order, and returns its value as an unsigned int.
  */
-#define DNS__32BIT(p)  ((unsigned int) \
-                         (((unsigned int)((unsigned char)(p)[0]) << 24U) | \
-                          ((unsigned int)((unsigned char)(p)[1]) << 16U) | \
-                          ((unsigned int)((unsigned char)(p)[2]) <<  8U) | \
-                          ((unsigned int)((unsigned char)(p)[3]))))
+#define DNS__32BIT(p) ((unsigned int)(((unsigned int)((unsigned char)(p)[0]) << 24U) | ((unsigned int)((unsigned char)(p)[1]) << 16U) | ((unsigned int)((unsigned char)(p)[2]) << 8U) | ((unsigned int)((unsigned char)(p)[3]))))
 
-#define DNS__SET16BIT(p, v)  (((p)[0] = (unsigned char)(((v) >> 8) & 0xff)), \
-                              ((p)[1] = (unsigned char)((v) & 0xff)))
-#define DNS__SET32BIT(p, v)  (((p)[0] = (unsigned char)(((v) >> 24) & 0xff)), \
-                              ((p)[1] = (unsigned char)(((v) >> 16) & 0xff)), \
-                              ((p)[2] = (unsigned char)(((v) >> 8) & 0xff)), \
-                              ((p)[3] = (unsigned char)((v) & 0xff)))
+#define DNS__SET16BIT(p, v) (((p)[0] = (unsigned char)(((v) >> 8) & 0xff)), ((p)[1] = (unsigned char)((v)&0xff)))
+#define DNS__SET32BIT(p, v) (((p)[0] = (unsigned char)(((v) >> 24) & 0xff)), ((p)[1] = (unsigned char)(((v) >> 16) & 0xff)), ((p)[2] = (unsigned char)(((v) >> 8) & 0xff)), ((p)[3] = (unsigned char)((v)&0xff)))
 
 #if 0
 /* we cannot use this approach on systems where we can't access 16/32 bit
    data on un-aligned addresses */
-#define DNS__16BIT(p)                   ntohs(*(unsigned short*)(p))
-#define DNS__32BIT(p)                   ntohl(*(unsigned long*)(p))
-#define DNS__SET16BIT(p, v)             *(unsigned short*)(p) = htons(v)
-#define DNS__SET32BIT(p, v)             *(unsigned long*)(p) = htonl(v)
+#define DNS__16BIT(p) ntohs(*(unsigned short*)(p))
+#define DNS__32BIT(p) ntohl(*(unsigned long*)(p))
+#define DNS__SET16BIT(p, v) *(unsigned short*)(p) = htons(v)
+#define DNS__SET32BIT(p, v) *(unsigned long*)(p) = htonl(v)
 #endif
 
 /* Macros for parsing a DNS header */
-#define DNS_HEADER_QID(h)               DNS__16BIT(h)
-#define DNS_HEADER_QR(h)                (((h)[2] >> 7) & 0x1)
-#define DNS_HEADER_OPCODE(h)            (((h)[2] >> 3) & 0xf)
-#define DNS_HEADER_AA(h)                (((h)[2] >> 2) & 0x1)
-#define DNS_HEADER_TC(h)                (((h)[2] >> 1) & 0x1)
-#define DNS_HEADER_RD(h)                ((h)[2] & 0x1)
-#define DNS_HEADER_RA(h)                (((h)[3] >> 7) & 0x1)
-#define DNS_HEADER_Z(h)                 (((h)[3] >> 4) & 0x7)
-#define DNS_HEADER_RCODE(h)             ((h)[3] & 0xf)
-#define DNS_HEADER_QDCOUNT(h)           DNS__16BIT((h) + 4)
-#define DNS_HEADER_ANCOUNT(h)           DNS__16BIT((h) + 6)
-#define DNS_HEADER_NSCOUNT(h)           DNS__16BIT((h) + 8)
-#define DNS_HEADER_ARCOUNT(h)           DNS__16BIT((h) + 10)
+#define DNS_HEADER_QID(h) DNS__16BIT(h)
+#define DNS_HEADER_QR(h) (((h)[2] >> 7) & 0x1)
+#define DNS_HEADER_OPCODE(h) (((h)[2] >> 3) & 0xf)
+#define DNS_HEADER_AA(h) (((h)[2] >> 2) & 0x1)
+#define DNS_HEADER_TC(h) (((h)[2] >> 1) & 0x1)
+#define DNS_HEADER_RD(h) ((h)[2] & 0x1)
+#define DNS_HEADER_RA(h) (((h)[3] >> 7) & 0x1)
+#define DNS_HEADER_Z(h) (((h)[3] >> 4) & 0x7)
+#define DNS_HEADER_RCODE(h) ((h)[3] & 0xf)
+#define DNS_HEADER_QDCOUNT(h) DNS__16BIT((h) + 4)
+#define DNS_HEADER_ANCOUNT(h) DNS__16BIT((h) + 6)
+#define DNS_HEADER_NSCOUNT(h) DNS__16BIT((h) + 8)
+#define DNS_HEADER_ARCOUNT(h) DNS__16BIT((h) + 10)
 
 /* Macros for constructing a DNS header */
-#define DNS_HEADER_SET_QID(h, v)      DNS__SET16BIT(h, v)
-#define DNS_HEADER_SET_QR(h, v)       ((h)[2] |= (unsigned char)(((v) & 0x1) << 7))
-#define DNS_HEADER_SET_OPCODE(h, v)   ((h)[2] |= (unsigned char)(((v) & 0xf) << 3))
-#define DNS_HEADER_SET_AA(h, v)       ((h)[2] |= (unsigned char)(((v) & 0x1) << 2))
-#define DNS_HEADER_SET_TC(h, v)       ((h)[2] |= (unsigned char)(((v) & 0x1) << 1))
-#define DNS_HEADER_SET_RD(h, v)       ((h)[2] |= (unsigned char)((v) & 0x1))
-#define DNS_HEADER_SET_RA(h, v)       ((h)[3] |= (unsigned char)(((v) & 0x1) << 7))
-#define DNS_HEADER_SET_Z(h, v)        ((h)[3] |= (unsigned char)(((v) & 0x7) << 4))
-#define DNS_HEADER_SET_RCODE(h, v)    ((h)[3] |= (unsigned char)((v) & 0xf))
-#define DNS_HEADER_SET_QDCOUNT(h, v)  DNS__SET16BIT((h) + 4, v)
-#define DNS_HEADER_SET_ANCOUNT(h, v)  DNS__SET16BIT((h) + 6, v)
-#define DNS_HEADER_SET_NSCOUNT(h, v)  DNS__SET16BIT((h) + 8, v)
-#define DNS_HEADER_SET_ARCOUNT(h, v)  DNS__SET16BIT((h) + 10, v)
+#define DNS_HEADER_SET_QID(h, v) DNS__SET16BIT(h, v)
+#define DNS_HEADER_SET_QR(h, v) ((h)[2] |= (unsigned char)(((v)&0x1) << 7))
+#define DNS_HEADER_SET_OPCODE(h, v) ((h)[2] |= (unsigned char)(((v)&0xf) << 3))
+#define DNS_HEADER_SET_AA(h, v) ((h)[2] |= (unsigned char)(((v)&0x1) << 2))
+#define DNS_HEADER_SET_TC(h, v) ((h)[2] |= (unsigned char)(((v)&0x1) << 1))
+#define DNS_HEADER_SET_RD(h, v) ((h)[2] |= (unsigned char)((v)&0x1))
+#define DNS_HEADER_SET_RA(h, v) ((h)[3] |= (unsigned char)(((v)&0x1) << 7))
+#define DNS_HEADER_SET_Z(h, v) ((h)[3] |= (unsigned char)(((v)&0x7) << 4))
+#define DNS_HEADER_SET_RCODE(h, v) ((h)[3] |= (unsigned char)((v)&0xf))
+#define DNS_HEADER_SET_QDCOUNT(h, v) DNS__SET16BIT((h) + 4, v)
+#define DNS_HEADER_SET_ANCOUNT(h, v) DNS__SET16BIT((h) + 6, v)
+#define DNS_HEADER_SET_NSCOUNT(h, v) DNS__SET16BIT((h) + 8, v)
+#define DNS_HEADER_SET_ARCOUNT(h, v) DNS__SET16BIT((h) + 10, v)
 
 /* Macros for parsing the fixed part of a DNS question */
-#define DNS_QUESTION_TYPE(q)            DNS__16BIT(q)
-#define DNS_QUESTION_CLASS(q)           DNS__16BIT((q) + 2)
+#define DNS_QUESTION_TYPE(q) DNS__16BIT(q)
+#define DNS_QUESTION_CLASS(q) DNS__16BIT((q) + 2)
 
 /* Macros for constructing the fixed part of a DNS question */
-#define DNS_QUESTION_SET_TYPE(q, v)     DNS__SET16BIT(q, v)
-#define DNS_QUESTION_SET_CLASS(q, v)    DNS__SET16BIT((q) + 2, v)
+#define DNS_QUESTION_SET_TYPE(q, v) DNS__SET16BIT(q, v)
+#define DNS_QUESTION_SET_CLASS(q, v) DNS__SET16BIT((q) + 2, v)
 
 /* Macros for parsing the fixed part of a DNS resource record */
-#define DNS_RR_TYPE(r)                  DNS__16BIT(r)
-#define DNS_RR_CLASS(r)                 DNS__16BIT((r) + 2)
-#define DNS_RR_TTL(r)                   DNS__32BIT((r) + 4)
-#define DNS_RR_LEN(r)                   DNS__16BIT((r) + 8)
+#define DNS_RR_TYPE(r) DNS__16BIT(r)
+#define DNS_RR_CLASS(r) DNS__16BIT((r) + 2)
+#define DNS_RR_TTL(r) DNS__32BIT((r) + 4)
+#define DNS_RR_LEN(r) DNS__16BIT((r) + 8)
 
 /* Macros for constructing the fixed part of a DNS resource record */
-#define DNS_RR_SET_TYPE(r, v)           DNS__SET16BIT(r, v)
-#define DNS_RR_SET_CLASS(r, v)          DNS__SET16BIT((r) + 2, v)
-#define DNS_RR_SET_TTL(r, v)            DNS__SET32BIT((r) + 4, v)
-#define DNS_RR_SET_LEN(r, v)            DNS__SET16BIT((r) + 8, v)
+#define DNS_RR_SET_TYPE(r, v) DNS__SET16BIT(r, v)
+#define DNS_RR_SET_CLASS(r, v) DNS__SET16BIT((r) + 2, v)
+#define DNS_RR_SET_TTL(r, v) DNS__SET32BIT((r) + 4, v)
+#define DNS_RR_SET_LEN(r, v) DNS__SET16BIT((r) + 8, v)
 
 #endif /* HEADER_CARES_DNS_H */
diff --git a/CAPI/cpp/grpc/include/ares_nameser.h b/CAPI/cpp/grpc/include/ares_nameser.h
index 18a9e5a..9c547da 100644
--- a/CAPI/cpp/grpc/include/ares_nameser.h
+++ b/CAPI/cpp/grpc/include/ares_nameser.h
@@ -5,10 +5,10 @@
 #include "ares_build.h"
 
 #ifdef CARES_HAVE_ARPA_NAMESER_H
-#  include <arpa/nameser.h>
+#include <arpa/nameser.h>
 #endif
 #ifdef CARES_HAVE_ARPA_NAMESER_COMPAT_H
-#  include <arpa/nameser_compat.h>
+#include <arpa/nameser_compat.h>
 #endif
 
 /* ============================================================================
@@ -18,51 +18,51 @@
  */
 
 #ifndef NS_PACKETSZ
-#  define NS_PACKETSZ     512   /* maximum packet size */
+#define NS_PACKETSZ 512 /* maximum packet size */
 #endif
 
 #ifndef NS_MAXDNAME
-#  define NS_MAXDNAME     256   /* maximum domain name */
+#define NS_MAXDNAME 256 /* maximum domain name */
 #endif
 
 #ifndef NS_MAXCDNAME
-#  define NS_MAXCDNAME    255   /* maximum compressed domain name */
+#define NS_MAXCDNAME 255 /* maximum compressed domain name */
 #endif
 
 #ifndef NS_MAXLABEL
-#  define NS_MAXLABEL     63
+#define NS_MAXLABEL 63
 #endif
 
 #ifndef NS_HFIXEDSZ
-#  define NS_HFIXEDSZ     12    /* #/bytes of fixed data in header */
+#define NS_HFIXEDSZ 12 /* #/bytes of fixed data in header */
 #endif
 
 #ifndef NS_QFIXEDSZ
-#  define NS_QFIXEDSZ     4     /* #/bytes of fixed data in query */
+#define NS_QFIXEDSZ 4 /* #/bytes of fixed data in query */
 #endif
 
 #ifndef NS_RRFIXEDSZ
-#  define NS_RRFIXEDSZ    10    /* #/bytes of fixed data in r record */
+#define NS_RRFIXEDSZ 10 /* #/bytes of fixed data in r record */
 #endif
 
 #ifndef NS_INT16SZ
-#  define NS_INT16SZ      2
+#define NS_INT16SZ 2
 #endif
 
 #ifndef NS_INADDRSZ
-#  define NS_INADDRSZ     4
+#define NS_INADDRSZ 4
 #endif
 
 #ifndef NS_IN6ADDRSZ
-#  define NS_IN6ADDRSZ    16
+#define NS_IN6ADDRSZ 16
 #endif
 
 #ifndef NS_CMPRSFLGS
-#  define NS_CMPRSFLGS    0xc0  /* Flag bits indicating name compression. */
+#define NS_CMPRSFLGS 0xc0 /* Flag bits indicating name compression. */
 #endif
 
 #ifndef NS_DEFAULTPORT
-#  define NS_DEFAULTPORT  53    /* For both TCP and UDP. */
+#define NS_DEFAULTPORT 53 /* For both TCP and UDP. */
 #endif
 
 /* ============================================================================
@@ -72,102 +72,106 @@
  */
 #ifndef CARES_HAVE_ARPA_NAMESER_H
 
-typedef enum __ns_class {
-    ns_c_invalid = 0,       /* Cookie. */
-    ns_c_in = 1,            /* Internet. */
-    ns_c_2 = 2,             /* unallocated/unsupported. */
-    ns_c_chaos = 3,         /* MIT Chaos-net. */
-    ns_c_hs = 4,            /* MIT Hesiod. */
+typedef enum __ns_class
+{
+    ns_c_invalid = 0, /* Cookie. */
+    ns_c_in = 1,      /* Internet. */
+    ns_c_2 = 2,       /* unallocated/unsupported. */
+    ns_c_chaos = 3,   /* MIT Chaos-net. */
+    ns_c_hs = 4,      /* MIT Hesiod. */
     /* Query class values which do not appear in resource records */
-    ns_c_none = 254,        /* for prereq. sections in update requests */
-    ns_c_any = 255,         /* Wildcard match. */
+    ns_c_none = 254, /* for prereq. sections in update requests */
+    ns_c_any = 255,  /* Wildcard match. */
     ns_c_max = 65536
 } ns_class;
 
-typedef enum __ns_type {
-    ns_t_invalid = 0,       /* Cookie. */
-    ns_t_a = 1,             /* Host address. */
-    ns_t_ns = 2,            /* Authoritative server. */
-    ns_t_md = 3,            /* Mail destination. */
-    ns_t_mf = 4,            /* Mail forwarder. */
-    ns_t_cname = 5,         /* Canonical name. */
-    ns_t_soa = 6,           /* Start of authority zone. */
-    ns_t_mb = 7,            /* Mailbox domain name. */
-    ns_t_mg = 8,            /* Mail group member. */
-    ns_t_mr = 9,            /* Mail rename name. */
-    ns_t_null = 10,         /* Null resource record. */
-    ns_t_wks = 11,          /* Well known service. */
-    ns_t_ptr = 12,          /* Domain name pointer. */
-    ns_t_hinfo = 13,        /* Host information. */
-    ns_t_minfo = 14,        /* Mailbox information. */
-    ns_t_mx = 15,           /* Mail routing information. */
-    ns_t_txt = 16,          /* Text strings. */
-    ns_t_rp = 17,           /* Responsible person. */
-    ns_t_afsdb = 18,        /* AFS cell database. */
-    ns_t_x25 = 19,          /* X_25 calling address. */
-    ns_t_isdn = 20,         /* ISDN calling address. */
-    ns_t_rt = 21,           /* Router. */
-    ns_t_nsap = 22,         /* NSAP address. */
-    ns_t_nsap_ptr = 23,     /* Reverse NSAP lookup (deprecated). */
-    ns_t_sig = 24,          /* Security signature. */
-    ns_t_key = 25,          /* Security key. */
-    ns_t_px = 26,           /* X.400 mail mapping. */
-    ns_t_gpos = 27,         /* Geographical position (withdrawn). */
-    ns_t_aaaa = 28,         /* Ip6 Address. */
-    ns_t_loc = 29,          /* Location Information. */
-    ns_t_nxt = 30,          /* Next domain (security). */
-    ns_t_eid = 31,          /* Endpoint identifier. */
-    ns_t_nimloc = 32,       /* Nimrod Locator. */
-    ns_t_srv = 33,          /* Server Selection. */
-    ns_t_atma = 34,         /* ATM Address */
-    ns_t_naptr = 35,        /* Naming Authority PoinTeR */
-    ns_t_kx = 36,           /* Key Exchange */
-    ns_t_cert = 37,         /* Certification record */
-    ns_t_a6 = 38,           /* IPv6 address (deprecates AAAA) */
-    ns_t_dname = 39,        /* Non-terminal DNAME (for IPv6) */
-    ns_t_sink = 40,         /* Kitchen sink (experimentatl) */
-    ns_t_opt = 41,          /* EDNS0 option (meta-RR) */
-    ns_t_apl = 42,          /* Address prefix list (RFC3123) */
-    ns_t_ds = 43,           /* Delegation Signer (RFC4034) */
-    ns_t_sshfp = 44,        /* SSH Key Fingerprint (RFC4255) */
-    ns_t_rrsig = 46,        /* Resource Record Signature (RFC4034) */
-    ns_t_nsec = 47,         /* Next Secure (RFC4034) */
-    ns_t_dnskey = 48,       /* DNS Public Key (RFC4034) */
-    ns_t_tkey = 249,        /* Transaction key */
-    ns_t_tsig = 250,        /* Transaction signature. */
-    ns_t_ixfr = 251,        /* Incremental zone transfer. */
-    ns_t_axfr = 252,        /* Transfer zone of authority. */
-    ns_t_mailb = 253,       /* Transfer mailbox records. */
-    ns_t_maila = 254,       /* Transfer mail agent records. */
-    ns_t_any = 255,         /* Wildcard match. */
-    ns_t_uri = 256,         /* Uniform Resource Identifier (RFC7553) */
-    ns_t_caa = 257,         /* Certification Authority Authorization. */
+typedef enum __ns_type
+{
+    ns_t_invalid = 0,   /* Cookie. */
+    ns_t_a = 1,         /* Host address. */
+    ns_t_ns = 2,        /* Authoritative server. */
+    ns_t_md = 3,        /* Mail destination. */
+    ns_t_mf = 4,        /* Mail forwarder. */
+    ns_t_cname = 5,     /* Canonical name. */
+    ns_t_soa = 6,       /* Start of authority zone. */
+    ns_t_mb = 7,        /* Mailbox domain name. */
+    ns_t_mg = 8,        /* Mail group member. */
+    ns_t_mr = 9,        /* Mail rename name. */
+    ns_t_null = 10,     /* Null resource record. */
+    ns_t_wks = 11,      /* Well known service. */
+    ns_t_ptr = 12,      /* Domain name pointer. */
+    ns_t_hinfo = 13,    /* Host information. */
+    ns_t_minfo = 14,    /* Mailbox information. */
+    ns_t_mx = 15,       /* Mail routing information. */
+    ns_t_txt = 16,      /* Text strings. */
+    ns_t_rp = 17,       /* Responsible person. */
+    ns_t_afsdb = 18,    /* AFS cell database. */
+    ns_t_x25 = 19,      /* X_25 calling address. */
+    ns_t_isdn = 20,     /* ISDN calling address. */
+    ns_t_rt = 21,       /* Router. */
+    ns_t_nsap = 22,     /* NSAP address. */
+    ns_t_nsap_ptr = 23, /* Reverse NSAP lookup (deprecated). */
+    ns_t_sig = 24,      /* Security signature. */
+    ns_t_key = 25,      /* Security key. */
+    ns_t_px = 26,       /* X.400 mail mapping. */
+    ns_t_gpos = 27,     /* Geographical position (withdrawn). */
+    ns_t_aaaa = 28,     /* Ip6 Address. */
+    ns_t_loc = 29,      /* Location Information. */
+    ns_t_nxt = 30,      /* Next domain (security). */
+    ns_t_eid = 31,      /* Endpoint identifier. */
+    ns_t_nimloc = 32,   /* Nimrod Locator. */
+    ns_t_srv = 33,      /* Server Selection. */
+    ns_t_atma = 34,     /* ATM Address */
+    ns_t_naptr = 35,    /* Naming Authority PoinTeR */
+    ns_t_kx = 36,       /* Key Exchange */
+    ns_t_cert = 37,     /* Certification record */
+    ns_t_a6 = 38,       /* IPv6 address (deprecates AAAA) */
+    ns_t_dname = 39,    /* Non-terminal DNAME (for IPv6) */
+    ns_t_sink = 40,     /* Kitchen sink (experimentatl) */
+    ns_t_opt = 41,      /* EDNS0 option (meta-RR) */
+    ns_t_apl = 42,      /* Address prefix list (RFC3123) */
+    ns_t_ds = 43,       /* Delegation Signer (RFC4034) */
+    ns_t_sshfp = 44,    /* SSH Key Fingerprint (RFC4255) */
+    ns_t_rrsig = 46,    /* Resource Record Signature (RFC4034) */
+    ns_t_nsec = 47,     /* Next Secure (RFC4034) */
+    ns_t_dnskey = 48,   /* DNS Public Key (RFC4034) */
+    ns_t_tkey = 249,    /* Transaction key */
+    ns_t_tsig = 250,    /* Transaction signature. */
+    ns_t_ixfr = 251,    /* Incremental zone transfer. */
+    ns_t_axfr = 252,    /* Transfer zone of authority. */
+    ns_t_mailb = 253,   /* Transfer mailbox records. */
+    ns_t_maila = 254,   /* Transfer mail agent records. */
+    ns_t_any = 255,     /* Wildcard match. */
+    ns_t_uri = 256,     /* Uniform Resource Identifier (RFC7553) */
+    ns_t_caa = 257,     /* Certification Authority Authorization. */
     ns_t_max = 65536
 } ns_type;
 
-typedef enum __ns_opcode {
-    ns_o_query = 0,         /* Standard query. */
-    ns_o_iquery = 1,        /* Inverse query (deprecated/unsupported). */
-    ns_o_status = 2,        /* Name server status query (unsupported). */
-                                /* Opcode 3 is undefined/reserved. */
-    ns_o_notify = 4,        /* Zone change notification. */
-    ns_o_update = 5,        /* Zone update message. */
+typedef enum __ns_opcode
+{
+    ns_o_query = 0,  /* Standard query. */
+    ns_o_iquery = 1, /* Inverse query (deprecated/unsupported). */
+    ns_o_status = 2, /* Name server status query (unsupported). */
+                     /* Opcode 3 is undefined/reserved. */
+    ns_o_notify = 4, /* Zone change notification. */
+    ns_o_update = 5, /* Zone update message. */
     ns_o_max = 6
 } ns_opcode;
 
-typedef enum __ns_rcode {
-    ns_r_noerror = 0,       /* No error occurred. */
-    ns_r_formerr = 1,       /* Format error. */
-    ns_r_servfail = 2,      /* Server failure. */
-    ns_r_nxdomain = 3,      /* Name error. */
-    ns_r_notimpl = 4,       /* Unimplemented. */
-    ns_r_refused = 5,       /* Operation refused. */
+typedef enum __ns_rcode
+{
+    ns_r_noerror = 0,  /* No error occurred. */
+    ns_r_formerr = 1,  /* Format error. */
+    ns_r_servfail = 2, /* Server failure. */
+    ns_r_nxdomain = 3, /* Name error. */
+    ns_r_notimpl = 4,  /* Unimplemented. */
+    ns_r_refused = 5,  /* Operation refused. */
     /* these are for BIND_UPDATE */
-    ns_r_yxdomain = 6,      /* Name exists */
-    ns_r_yxrrset = 7,       /* RRset exists */
-    ns_r_nxrrset = 8,       /* RRset does not exist */
-    ns_r_notauth = 9,       /* Not authoritative for zone */
-    ns_r_notzone = 10,      /* Zone of record different from zone section */
+    ns_r_yxdomain = 6, /* Name exists */
+    ns_r_yxrrset = 7,  /* RRset exists */
+    ns_r_nxrrset = 8,  /* RRset does not exist */
+    ns_r_notauth = 9,  /* Not authoritative for zone */
+    ns_r_notzone = 10, /* Zone of record different from zone section */
     ns_r_max = 11,
     /* The following are TSIG extended errors */
     ns_r_badsig = 16,
@@ -177,7 +181,6 @@ typedef enum __ns_rcode {
 
 #endif /* CARES_HAVE_ARPA_NAMESER_H */
 
-
 /* ============================================================================
  * arpa/nameser_compat.h typically sets these.  However on some systems
  * arpa/nameser.h does, but may not set all of them.  Lets conditionally
@@ -186,299 +189,294 @@ typedef enum __ns_rcode {
  */
 
 #ifndef PACKETSZ
-#  define PACKETSZ         NS_PACKETSZ
+#define PACKETSZ NS_PACKETSZ
 #endif
 
 #ifndef MAXDNAME
-#  define MAXDNAME         NS_MAXDNAME
+#define MAXDNAME NS_MAXDNAME
 #endif
 
 #ifndef MAXCDNAME
-#  define MAXCDNAME        NS_MAXCDNAME
+#define MAXCDNAME NS_MAXCDNAME
 #endif
 
 #ifndef MAXLABEL
-#  define MAXLABEL         NS_MAXLABEL
+#define MAXLABEL NS_MAXLABEL
 #endif
 
 #ifndef HFIXEDSZ
-#  define HFIXEDSZ         NS_HFIXEDSZ
+#define HFIXEDSZ NS_HFIXEDSZ
 #endif
 
 #ifndef QFIXEDSZ
-#  define QFIXEDSZ         NS_QFIXEDSZ
+#define QFIXEDSZ NS_QFIXEDSZ
 #endif
 
 #ifndef RRFIXEDSZ
-#  define RRFIXEDSZ        NS_RRFIXEDSZ
+#define RRFIXEDSZ NS_RRFIXEDSZ
 #endif
 
 #ifndef INDIR_MASK
-#  define INDIR_MASK       NS_CMPRSFLGS
+#define INDIR_MASK NS_CMPRSFLGS
 #endif
 
 #ifndef NAMESERVER_PORT
-#  define NAMESERVER_PORT  NS_DEFAULTPORT
+#define NAMESERVER_PORT NS_DEFAULTPORT
 #endif
 
-
 /* opcodes */
 #ifndef O_QUERY
-#  define O_QUERY 0  /* ns_o_query */
+#define O_QUERY 0 /* ns_o_query */
 #endif
 #ifndef O_IQUERY
-#  define O_IQUERY 1 /* ns_o_iquery */
+#define O_IQUERY 1 /* ns_o_iquery */
 #endif
 #ifndef O_STATUS
-#  define O_STATUS 2 /* ns_o_status */
+#define O_STATUS 2 /* ns_o_status */
 #endif
 #ifndef O_NOTIFY
-#  define O_NOTIFY 4 /* ns_o_notify */
+#define O_NOTIFY 4 /* ns_o_notify */
 #endif
 #ifndef O_UPDATE
-#  define O_UPDATE 5 /* ns_o_update */
+#define O_UPDATE 5 /* ns_o_update */
 #endif
 
-
 /* response codes */
 #ifndef SERVFAIL
-#  define SERVFAIL        ns_r_servfail
+#define SERVFAIL ns_r_servfail
 #endif
 #ifndef NOTIMP
-#  define NOTIMP          ns_r_notimpl
+#define NOTIMP ns_r_notimpl
 #endif
 #ifndef REFUSED
-#  define REFUSED         ns_r_refused
+#define REFUSED ns_r_refused
 #endif
 #if defined(_WIN32) && !defined(HAVE_ARPA_NAMESER_COMPAT_H) && defined(NOERROR)
-#  undef NOERROR /* it seems this is already defined in winerror.h */
+#undef NOERROR /* it seems this is already defined in winerror.h */
 #endif
 #ifndef NOERROR
-#  define NOERROR         ns_r_noerror
+#define NOERROR ns_r_noerror
 #endif
 #ifndef FORMERR
-#  define FORMERR         ns_r_formerr
+#define FORMERR ns_r_formerr
 #endif
 #ifndef NXDOMAIN
-#  define NXDOMAIN        ns_r_nxdomain
+#define NXDOMAIN ns_r_nxdomain
 #endif
 /* Non-standard response codes, use numeric values */
 #ifndef YXDOMAIN
-#  define YXDOMAIN        6 /* ns_r_yxdomain */
+#define YXDOMAIN 6 /* ns_r_yxdomain */
 #endif
 #ifndef YXRRSET
-#  define YXRRSET         7 /* ns_r_yxrrset */
+#define YXRRSET 7 /* ns_r_yxrrset */
 #endif
 #ifndef NXRRSET
-#  define NXRRSET         8 /* ns_r_nxrrset */
+#define NXRRSET 8 /* ns_r_nxrrset */
 #endif
 #ifndef NOTAUTH
-#  define NOTAUTH         9 /* ns_r_notauth */
+#define NOTAUTH 9 /* ns_r_notauth */
 #endif
 #ifndef NOTZONE
-#  define NOTZONE         10 /* ns_r_notzone */
+#define NOTZONE 10 /* ns_r_notzone */
 #endif
 #ifndef TSIG_BADSIG
-#  define TSIG_BADSIG     16 /* ns_r_badsig */
+#define TSIG_BADSIG 16 /* ns_r_badsig */
 #endif
 #ifndef TSIG_BADKEY
-#  define TSIG_BADKEY     17 /* ns_r_badkey */
+#define TSIG_BADKEY 17 /* ns_r_badkey */
 #endif
 #ifndef TSIG_BADTIME
-#  define TSIG_BADTIME    18 /* ns_r_badtime */
+#define TSIG_BADTIME 18 /* ns_r_badtime */
 #endif
 
-
 /* classes */
 #ifndef C_IN
-#  define C_IN            1 /* ns_c_in */
+#define C_IN 1 /* ns_c_in */
 #endif
 #ifndef C_CHAOS
-#  define C_CHAOS         3 /* ns_c_chaos */
+#define C_CHAOS 3 /* ns_c_chaos */
 #endif
 #ifndef C_HS
-#  define C_HS            4 /* ns_c_hs */
+#define C_HS 4 /* ns_c_hs */
 #endif
 #ifndef C_NONE
-#  define C_NONE          254 /* ns_c_none */
+#define C_NONE 254 /* ns_c_none */
 #endif
 #ifndef C_ANY
-#  define C_ANY           255 /*  ns_c_any */
+#define C_ANY 255 /*  ns_c_any */
 #endif
 
-
 /* types */
 #ifndef T_A
-#  define T_A             1   /* ns_t_a */
+#define T_A 1 /* ns_t_a */
 #endif
 #ifndef T_NS
-#  define T_NS            2   /* ns_t_ns */
+#define T_NS 2 /* ns_t_ns */
 #endif
 #ifndef T_MD
-#  define T_MD            3   /* ns_t_md */
+#define T_MD 3 /* ns_t_md */
 #endif
 #ifndef T_MF
-#  define T_MF            4   /* ns_t_mf */
+#define T_MF 4 /* ns_t_mf */
 #endif
 #ifndef T_CNAME
-#  define T_CNAME         5   /* ns_t_cname */
+#define T_CNAME 5 /* ns_t_cname */
 #endif
 #ifndef T_SOA
-#  define T_SOA           6   /* ns_t_soa */
+#define T_SOA 6 /* ns_t_soa */
 #endif
 #ifndef T_MB
-#  define T_MB            7   /* ns_t_mb */
+#define T_MB 7 /* ns_t_mb */
 #endif
 #ifndef T_MG
-#  define T_MG            8   /* ns_t_mg */
+#define T_MG 8 /* ns_t_mg */
 #endif
 #ifndef T_MR
-#  define T_MR            9   /* ns_t_mr */
+#define T_MR 9 /* ns_t_mr */
 #endif
 #ifndef T_NULL
-#  define T_NULL          10  /* ns_t_null */
+#define T_NULL 10 /* ns_t_null */
 #endif
 #ifndef T_WKS
-#  define T_WKS           11  /* ns_t_wks */
+#define T_WKS 11 /* ns_t_wks */
 #endif
 #ifndef T_PTR
-#  define T_PTR           12  /* ns_t_ptr */
+#define T_PTR 12 /* ns_t_ptr */
 #endif
 #ifndef T_HINFO
-#  define T_HINFO         13  /* ns_t_hinfo */
+#define T_HINFO 13 /* ns_t_hinfo */
 #endif
 #ifndef T_MINFO
-#  define T_MINFO         14  /* ns_t_minfo */
+#define T_MINFO 14 /* ns_t_minfo */
 #endif
 #ifndef T_MX
-#  define T_MX            15  /* ns_t_mx */
+#define T_MX 15 /* ns_t_mx */
 #endif
 #ifndef T_TXT
-#  define T_TXT           16  /* ns_t_txt */
+#define T_TXT 16 /* ns_t_txt */
 #endif
 #ifndef T_RP
-#  define T_RP            17  /* ns_t_rp */
+#define T_RP 17 /* ns_t_rp */
 #endif
 #ifndef T_AFSDB
-#  define T_AFSDB         18  /* ns_t_afsdb */
+#define T_AFSDB 18 /* ns_t_afsdb */
 #endif
 #ifndef T_X25
-#  define T_X25           19  /* ns_t_x25 */
+#define T_X25 19 /* ns_t_x25 */
 #endif
 #ifndef T_ISDN
-#  define T_ISDN          20  /* ns_t_isdn */
+#define T_ISDN 20 /* ns_t_isdn */
 #endif
 #ifndef T_RT
-#  define T_RT            21  /* ns_t_rt */
+#define T_RT 21 /* ns_t_rt */
 #endif
 #ifndef T_NSAP
-#  define T_NSAP          22  /* ns_t_nsap */
+#define T_NSAP 22 /* ns_t_nsap */
 #endif
 #ifndef T_NSAP_PTR
-#  define T_NSAP_PTR      23  /* ns_t_nsap_ptr */
+#define T_NSAP_PTR 23 /* ns_t_nsap_ptr */
 #endif
 #ifndef T_SIG
-#  define T_SIG           24  /* ns_t_sig */
+#define T_SIG 24 /* ns_t_sig */
 #endif
 #ifndef T_KEY
-#  define T_KEY           25  /* ns_t_key */
+#define T_KEY 25 /* ns_t_key */
 #endif
 #ifndef T_PX
-#  define T_PX            26  /* ns_t_px */
+#define T_PX 26 /* ns_t_px */
 #endif
 #ifndef T_GPOS
-#  define T_GPOS          27  /* ns_t_gpos */
+#define T_GPOS 27 /* ns_t_gpos */
 #endif
 #ifndef T_AAAA
-#  define T_AAAA          28  /* ns_t_aaaa */
+#define T_AAAA 28 /* ns_t_aaaa */
 #endif
 #ifndef T_LOC
-#  define T_LOC           29  /* ns_t_loc */
+#define T_LOC 29 /* ns_t_loc */
 #endif
 #ifndef T_NXT
-#  define T_NXT           30  /* ns_t_nxt */
+#define T_NXT 30 /* ns_t_nxt */
 #endif
 #ifndef T_EID
-#  define T_EID           31  /* ns_t_eid */
+#define T_EID 31 /* ns_t_eid */
 #endif
 #ifndef T_NIMLOC
-#  define T_NIMLOC        32  /* ns_t_nimloc */
+#define T_NIMLOC 32 /* ns_t_nimloc */
 #endif
 #ifndef T_SRV
-#  define T_SRV           33  /* ns_t_srv */
+#define T_SRV 33 /* ns_t_srv */
 #endif
 #ifndef T_ATMA
-#  define T_ATMA          34  /* ns_t_atma */
+#define T_ATMA 34 /* ns_t_atma */
 #endif
 #ifndef T_NAPTR
-#  define T_NAPTR         35  /* ns_t_naptr */
+#define T_NAPTR 35 /* ns_t_naptr */
 #endif
 #ifndef T_KX
-#  define T_KX            36  /* ns_t_kx */
+#define T_KX 36 /* ns_t_kx */
 #endif
 #ifndef T_CERT
-#  define T_CERT          37  /* ns_t_cert */
+#define T_CERT 37 /* ns_t_cert */
 #endif
 #ifndef T_A6
-#  define T_A6            38  /* ns_t_a6 */
+#define T_A6 38 /* ns_t_a6 */
 #endif
 #ifndef T_DNAME
-#  define T_DNAME         39  /* ns_t_dname */
+#define T_DNAME 39 /* ns_t_dname */
 #endif
 #ifndef T_SINK
-#  define T_SINK          40  /* ns_t_sink */
+#define T_SINK 40 /* ns_t_sink */
 #endif
 #ifndef T_OPT
-#  define T_OPT           41  /* ns_t_opt */
+#define T_OPT 41 /* ns_t_opt */
 #endif
 #ifndef T_APL
-#  define T_APL           42  /* ns_t_apl */
+#define T_APL 42 /* ns_t_apl */
 #endif
 #ifndef T_DS
-#  define T_DS            43  /* ns_t_ds */
+#define T_DS 43 /* ns_t_ds */
 #endif
 #ifndef T_SSHFP
-#  define T_SSHFP         44  /* ns_t_sshfp */
+#define T_SSHFP 44 /* ns_t_sshfp */
 #endif
 #ifndef T_RRSIG
-#  define T_RRSIG         46  /* ns_t_rrsig */
+#define T_RRSIG 46 /* ns_t_rrsig */
 #endif
 #ifndef T_NSEC
-#  define T_NSEC          47  /* ns_t_nsec */
+#define T_NSEC 47 /* ns_t_nsec */
 #endif
 #ifndef T_DNSKEY
-#  define T_DNSKEY        48  /* ns_t_dnskey */
+#define T_DNSKEY 48 /* ns_t_dnskey */
 #endif
 #ifndef T_TKEY
-#  define T_TKEY          249 /* ns_t_tkey */
+#define T_TKEY 249 /* ns_t_tkey */
 #endif
 #ifndef T_TSIG
-#  define T_TSIG          250 /* ns_t_tsig */
+#define T_TSIG 250 /* ns_t_tsig */
 #endif
 #ifndef T_IXFR
-#  define T_IXFR          251 /* ns_t_ixfr */
+#define T_IXFR 251 /* ns_t_ixfr */
 #endif
 #ifndef T_AXFR
-#  define T_AXFR          252 /* ns_t_axfr */
+#define T_AXFR 252 /* ns_t_axfr */
 #endif
 #ifndef T_MAILB
-#  define T_MAILB         253 /* ns_t_mailb */
+#define T_MAILB 253 /* ns_t_mailb */
 #endif
 #ifndef T_MAILA
-#  define T_MAILA         254 /* ns_t_maila */
+#define T_MAILA 254 /* ns_t_maila */
 #endif
 #ifndef T_ANY
-#  define T_ANY           255 /* ns_t_any */
+#define T_ANY 255 /* ns_t_any */
 #endif
 #ifndef T_URI
-#  define T_URI          256 /* ns_t_uri */
+#define T_URI 256 /* ns_t_uri */
 #endif
 #ifndef T_CAA
-#  define T_CAA           257 /* ns_t_caa */
+#define T_CAA 257 /* ns_t_caa */
 #endif
 #ifndef T_MAX
-#  define T_MAX         65536 /* ns_t_max */
+#define T_MAX 65536 /* ns_t_max */
 #endif
 
-
 #endif /* ARES_NAMESER_H */
diff --git a/CAPI/cpp/grpc/include/ares_rules.h b/CAPI/cpp/grpc/include/ares_rules.h
index 1706ab7..c3c2543 100644
--- a/CAPI/cpp/grpc/include/ares_rules.h
+++ b/CAPI/cpp/grpc/include/ares_rules.h
@@ -1,7 +1,6 @@
 #ifndef __CARES_RULES_H
 #define __CARES_RULES_H
 
-
 /* Copyright (C) 2009 - 2021 by Daniel Stenberg et al
  *
  * Permission to use, copy, modify, and distribute this software and its
@@ -69,8 +68,8 @@
  */
 
 #ifndef CARES_TYPEOF_ARES_SOCKLEN_T
-#  error "CARES_TYPEOF_ARES_SOCKLEN_T definition is missing!"
-   Error Compilation_aborted_CARES_TYPEOF_ARES_SOCKLEN_T_is_missing
+#error "CARES_TYPEOF_ARES_SOCKLEN_T definition is missing!"
+Error Compilation_aborted_CARES_TYPEOF_ARES_SOCKLEN_T_is_missing
 #endif
 
 /*
@@ -81,15 +80,15 @@
 
 #define CareschkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1
 
-/*
- * Verify that the size previously defined and expected for
- * ares_socklen_t is actually the same as the one reported
- * by sizeof() at compile time.
- */
+    /*
+     * Verify that the size previously defined and expected for
+     * ares_socklen_t is actually the same as the one reported
+     * by sizeof() at compile time.
+     */
 
-typedef char
-  __cares_rule_02__
-    [CareschkszEQ(ares_socklen_t, sizeof(CARES_TYPEOF_ARES_SOCKLEN_T))];
+    typedef char
+        __cares_rule_02__
+            [CareschkszEQ(ares_socklen_t, sizeof(CARES_TYPEOF_ARES_SOCKLEN_T))];
 
 /*
  * Verify at compile time that the size of ares_socklen_t as reported
@@ -98,8 +97,8 @@ typedef char
  */
 
 typedef char
-  __cares_rule_03__
-    [CareschkszGE(ares_socklen_t, int)];
+    __cares_rule_03__
+        [CareschkszGE(ares_socklen_t, int)];
 
 /* ================================================================ */
 /*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */
diff --git a/CAPI/cpp/grpc/include/ares_version.h b/CAPI/cpp/grpc/include/ares_version.h
index 22c6f62..5a7d465 100644
--- a/CAPI/cpp/grpc/include/ares_version.h
+++ b/CAPI/cpp/grpc/include/ares_version.h
@@ -8,17 +8,15 @@
 #define ARES_VERSION_MAJOR 1
 #define ARES_VERSION_MINOR 18
 #define ARES_VERSION_PATCH 1
-#define ARES_VERSION ((ARES_VERSION_MAJOR<<16)|\
-                       (ARES_VERSION_MINOR<<8)|\
-                       (ARES_VERSION_PATCH))
+#define ARES_VERSION ((ARES_VERSION_MAJOR << 16) | (ARES_VERSION_MINOR << 8) | (ARES_VERSION_PATCH))
 #define ARES_VERSION_STR "1.18.1"
 
 #if (ARES_VERSION >= 0x010700)
-#  define CARES_HAVE_ARES_LIBRARY_INIT 1
-#  define CARES_HAVE_ARES_LIBRARY_CLEANUP 1
+#define CARES_HAVE_ARES_LIBRARY_INIT 1
+#define CARES_HAVE_ARES_LIBRARY_CLEANUP 1
 #else
-#  undef CARES_HAVE_ARES_LIBRARY_INIT
-#  undef CARES_HAVE_ARES_LIBRARY_CLEANUP
+#undef CARES_HAVE_ARES_LIBRARY_INIT
+#undef CARES_HAVE_ARES_LIBRARY_CLEANUP
 #endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/google/protobuf/any.h b/CAPI/cpp/grpc/include/google/protobuf/any.h
index 92ea2bb..751055e 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/any.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/any.h
@@ -40,116 +40,117 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-class FieldDescriptor;
-class Message;
-
-namespace internal {
-
-extern const char kAnyFullTypeName[];          // "google.protobuf.Any".
-extern const char kTypeGoogleApisComPrefix[];  // "type.googleapis.com/".
-extern const char kTypeGoogleProdComPrefix[];  // "type.googleprod.com/".
-
-std::string GetTypeUrl(StringPiece message_name,
-                       StringPiece type_url_prefix);
-
-// Helper class used to implement google::protobuf::Any.
-class PROTOBUF_EXPORT AnyMetadata {
-  typedef ArenaStringPtr UrlType;
-  typedef ArenaStringPtr ValueType;
- public:
-  // AnyMetadata does not take ownership of "type_url" and "value".
-  constexpr AnyMetadata(UrlType* type_url, ValueType* value)
-      : type_url_(type_url), value_(value) {}
-
-  // Packs a message using the default type URL prefix: "type.googleapis.com".
-  // The resulted type URL will be "type.googleapis.com/<message_full_name>".
-  // Returns false if serializing the message failed.
-  template <typename T>
-  bool PackFrom(Arena* arena, const T& message) {
-    return InternalPackFrom(arena, message, kTypeGoogleApisComPrefix,
-                            T::FullMessageName());
-  }
-
-  bool PackFrom(Arena* arena, const Message& message);
-
-  // Packs a message using the given type URL prefix. The type URL will be
-  // constructed by concatenating the message type's full name to the prefix
-  // with an optional "/" separator if the prefix doesn't already end with "/".
-  // For example, both PackFrom(message, "type.googleapis.com") and
-  // PackFrom(message, "type.googleapis.com/") yield the same result type
-  // URL: "type.googleapis.com/<message_full_name>".
-  // Returns false if serializing the message failed.
-  template <typename T>
-  bool PackFrom(Arena* arena, const T& message,
-                StringPiece type_url_prefix) {
-    return InternalPackFrom(arena, message, type_url_prefix,
-                            T::FullMessageName());
-  }
-
-  bool PackFrom(Arena* arena, const Message& message,
-                StringPiece type_url_prefix);
-
-  // Unpacks the payload into the given message. Returns false if the message's
-  // type doesn't match the type specified in the type URL (i.e., the full
-  // name after the last "/" of the type URL doesn't match the message's actual
-  // full name) or parsing the payload has failed.
-  template <typename T>
-  bool UnpackTo(T* message) const {
-    return InternalUnpackTo(T::FullMessageName(), message);
-  }
-
-  bool UnpackTo(Message* message) const;
-
-  // Checks whether the type specified in the type URL matches the given type.
-  // A type is considered matching if its full name matches the full name after
-  // the last "/" in the type URL.
-  template <typename T>
-  bool Is() const {
-    return InternalIs(T::FullMessageName());
-  }
-
- private:
-  bool InternalPackFrom(Arena* arena, const MessageLite& message,
-                        StringPiece type_url_prefix,
-                        StringPiece type_name);
-  bool InternalUnpackTo(StringPiece type_name,
-                        MessageLite* message) const;
-  bool InternalIs(StringPiece type_name) const;
-
-  UrlType* type_url_;
-  ValueType* value_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AnyMetadata);
-};
-
-// Get the proto type name from Any::type_url value. For example, passing
-// "type.googleapis.com/rpc.QueryOrigin" will return "rpc.QueryOrigin" in
-// *full_type_name. Returns false if the type_url does not have a "/"
-// in the type url separating the full type name.
-//
-// NOTE: this function is available publicly as a static method on the
-// generated message type: google::protobuf::Any::ParseAnyTypeUrl()
-bool ParseAnyTypeUrl(StringPiece type_url, std::string* full_type_name);
-
-// Get the proto type name and prefix from Any::type_url value. For example,
-// passing "type.googleapis.com/rpc.QueryOrigin" will return
-// "type.googleapis.com/" in *url_prefix and "rpc.QueryOrigin" in
-// *full_type_name. Returns false if the type_url does not have a "/" in the
-// type url separating the full type name.
-bool ParseAnyTypeUrl(StringPiece type_url, std::string* url_prefix,
-                     std::string* full_type_name);
-
-// See if message is of type google.protobuf.Any, if so, return the descriptors
-// for "type_url" and "value" fields.
-bool GetAnyFieldDescriptors(const Message& message,
-                            const FieldDescriptor** type_url_field,
-                            const FieldDescriptor** value_field);
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        class FieldDescriptor;
+        class Message;
+
+        namespace internal
+        {
+
+            extern const char kAnyFullTypeName[];          // "google.protobuf.Any".
+            extern const char kTypeGoogleApisComPrefix[];  // "type.googleapis.com/".
+            extern const char kTypeGoogleProdComPrefix[];  // "type.googleprod.com/".
+
+            std::string GetTypeUrl(StringPiece message_name, StringPiece type_url_prefix);
+
+            // Helper class used to implement google::protobuf::Any.
+            class PROTOBUF_EXPORT AnyMetadata
+            {
+                typedef ArenaStringPtr UrlType;
+                typedef ArenaStringPtr ValueType;
+
+            public:
+                // AnyMetadata does not take ownership of "type_url" and "value".
+                constexpr AnyMetadata(UrlType* type_url, ValueType* value) :
+                    type_url_(type_url),
+                    value_(value)
+                {
+                }
+
+                // Packs a message using the default type URL prefix: "type.googleapis.com".
+                // The resulted type URL will be "type.googleapis.com/<message_full_name>".
+                // Returns false if serializing the message failed.
+                template<typename T>
+                bool PackFrom(Arena* arena, const T& message)
+                {
+                    return InternalPackFrom(arena, message, kTypeGoogleApisComPrefix, T::FullMessageName());
+                }
+
+                bool PackFrom(Arena* arena, const Message& message);
+
+                // Packs a message using the given type URL prefix. The type URL will be
+                // constructed by concatenating the message type's full name to the prefix
+                // with an optional "/" separator if the prefix doesn't already end with "/".
+                // For example, both PackFrom(message, "type.googleapis.com") and
+                // PackFrom(message, "type.googleapis.com/") yield the same result type
+                // URL: "type.googleapis.com/<message_full_name>".
+                // Returns false if serializing the message failed.
+                template<typename T>
+                bool PackFrom(Arena* arena, const T& message, StringPiece type_url_prefix)
+                {
+                    return InternalPackFrom(arena, message, type_url_prefix, T::FullMessageName());
+                }
+
+                bool PackFrom(Arena* arena, const Message& message, StringPiece type_url_prefix);
+
+                // Unpacks the payload into the given message. Returns false if the message's
+                // type doesn't match the type specified in the type URL (i.e., the full
+                // name after the last "/" of the type URL doesn't match the message's actual
+                // full name) or parsing the payload has failed.
+                template<typename T>
+                bool UnpackTo(T* message) const
+                {
+                    return InternalUnpackTo(T::FullMessageName(), message);
+                }
+
+                bool UnpackTo(Message* message) const;
+
+                // Checks whether the type specified in the type URL matches the given type.
+                // A type is considered matching if its full name matches the full name after
+                // the last "/" in the type URL.
+                template<typename T>
+                bool Is() const
+                {
+                    return InternalIs(T::FullMessageName());
+                }
+
+            private:
+                bool InternalPackFrom(Arena* arena, const MessageLite& message, StringPiece type_url_prefix, StringPiece type_name);
+                bool InternalUnpackTo(StringPiece type_name, MessageLite* message) const;
+                bool InternalIs(StringPiece type_name) const;
+
+                UrlType* type_url_;
+                ValueType* value_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AnyMetadata);
+            };
+
+            // Get the proto type name from Any::type_url value. For example, passing
+            // "type.googleapis.com/rpc.QueryOrigin" will return "rpc.QueryOrigin" in
+            // *full_type_name. Returns false if the type_url does not have a "/"
+            // in the type url separating the full type name.
+            //
+            // NOTE: this function is available publicly as a static method on the
+            // generated message type: google::protobuf::Any::ParseAnyTypeUrl()
+            bool ParseAnyTypeUrl(StringPiece type_url, std::string* full_type_name);
+
+            // Get the proto type name and prefix from Any::type_url value. For example,
+            // passing "type.googleapis.com/rpc.QueryOrigin" will return
+            // "type.googleapis.com/" in *url_prefix and "rpc.QueryOrigin" in
+            // *full_type_name. Returns false if the type_url does not have a "/" in the
+            // type url separating the full type name.
+            bool ParseAnyTypeUrl(StringPiece type_url, std::string* url_prefix, std::string* full_type_name);
+
+            // See if message is of type google.protobuf.Any, if so, return the descriptors
+            // for "type_url" and "value" fields.
+            bool GetAnyFieldDescriptors(const Message& message, const FieldDescriptor** type_url_field, const FieldDescriptor** value_field);
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/any.pb.h b/CAPI/cpp/grpc/include/google/protobuf/any.pb.h
index ac51c9b..86d51f8 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/any.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/any.pb.h
@@ -28,20 +28,22 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fany_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fany_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fany_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fany_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -50,328 +52,394 @@ struct AnyDefaultTypeInternal;
 PROTOBUF_EXPORT extern AnyDefaultTypeInternal _Any_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Any* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Any* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
 // ===================================================================
 
 class PROTOBUF_EXPORT Any final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ {
- public:
-  inline Any() : Any(nullptr) {}
-  ~Any() override;
-  explicit PROTOBUF_CONSTEXPR Any(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Any(const Any& from);
-  Any(Any&& from) noexcept
-    : Any() {
-    *this = ::std::move(from);
-  }
-
-  inline Any& operator=(const Any& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Any& operator=(Any&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Any) */
+{
+public:
+    inline Any() :
+        Any(nullptr)
+    {
     }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Any& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Any* internal_default_instance() {
-    return reinterpret_cast<const Any*>(
-               &_Any_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  // implements Any -----------------------------------------------
-
-  bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message) {
-    GOOGLE_DCHECK_NE(&message, this);
-    return _impl_._any_metadata_.PackFrom(GetArena(), message);
-  }
-  bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message,
-                ::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix) {
-    GOOGLE_DCHECK_NE(&message, this);
-    return _impl_._any_metadata_.PackFrom(GetArena(), message, type_url_prefix);
-  }
-  bool UnpackTo(::PROTOBUF_NAMESPACE_ID::Message* message) const {
-    return _impl_._any_metadata_.UnpackTo(message);
-  }
-  static bool GetAnyFieldDescriptors(
-      const ::PROTOBUF_NAMESPACE_ID::Message& message,
-      const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** type_url_field,
-      const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** value_field);
-  template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
-  bool PackFrom(const T& message) {
-    return _impl_._any_metadata_.PackFrom<T>(GetArena(), message);
-  }
-  template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
-  bool PackFrom(const T& message,
-                ::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix) {
-    return _impl_._any_metadata_.PackFrom<T>(GetArena(), message, type_url_prefix);}
-  template <typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
-  bool UnpackTo(T* message) const {
-    return _impl_._any_metadata_.UnpackTo<T>(message);
-  }
-  template<typename T> bool Is() const {
-    return _impl_._any_metadata_.Is<T>();
-  }
-  static bool ParseAnyTypeUrl(::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url,
-                              std::string* full_type_name);
-  friend void swap(Any& a, Any& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Any* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    ~Any() override;
+    explicit PROTOBUF_CONSTEXPR Any(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Any(const Any& from);
+    Any(Any&& from) noexcept
+        :
+        Any()
+    {
+        *this = ::std::move(from);
     }
-  }
-  void UnsafeArenaSwap(Any* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Any* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Any>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Any& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Any& from) {
-    Any::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Any* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Any";
-  }
-  protected:
-  explicit Any(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kTypeUrlFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  // string type_url = 1;
-  void clear_type_url();
-  const std::string& type_url() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_type_url(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_type_url();
-  PROTOBUF_NODISCARD std::string* release_type_url();
-  void set_allocated_type_url(std::string* type_url);
-  private:
-  const std::string& _internal_type_url() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_url(const std::string& value);
-  std::string* _internal_mutable_type_url();
-  public:
-
-  // bytes value = 2;
-  void clear_value();
-  const std::string& value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_value();
-  PROTOBUF_NODISCARD std::string* release_value();
-  void set_allocated_value(std::string* value);
-  private:
-  const std::string& _internal_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
-  std::string* _internal_mutable_value();
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Any)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata _any_metadata_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fany_2eproto;
+
+    inline Any& operator=(const Any& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Any& operator=(Any&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Any& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Any* internal_default_instance()
+    {
+        return reinterpret_cast<const Any*>(
+            &_Any_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    // implements Any -----------------------------------------------
+
+    bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message)
+    {
+        GOOGLE_DCHECK_NE(&message, this);
+        return _impl_._any_metadata_.PackFrom(GetArena(), message);
+    }
+    bool PackFrom(const ::PROTOBUF_NAMESPACE_ID::Message& message, ::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix)
+    {
+        GOOGLE_DCHECK_NE(&message, this);
+        return _impl_._any_metadata_.PackFrom(GetArena(), message, type_url_prefix);
+    }
+    bool UnpackTo(::PROTOBUF_NAMESPACE_ID::Message* message) const
+    {
+        return _impl_._any_metadata_.UnpackTo(message);
+    }
+    static bool GetAnyFieldDescriptors(
+        const ::PROTOBUF_NAMESPACE_ID::Message& message,
+        const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** type_url_field,
+        const ::PROTOBUF_NAMESPACE_ID::FieldDescriptor** value_field
+    );
+    template<typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
+    bool PackFrom(const T& message)
+    {
+        return _impl_._any_metadata_.PackFrom<T>(GetArena(), message);
+    }
+    template<typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
+    bool PackFrom(const T& message, ::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url_prefix)
+    {
+        return _impl_._any_metadata_.PackFrom<T>(GetArena(), message, type_url_prefix);
+    }
+    template<typename T, class = typename std::enable_if<!std::is_convertible<T, const ::PROTOBUF_NAMESPACE_ID::Message&>::value>::type>
+    bool UnpackTo(T* message) const
+    {
+        return _impl_._any_metadata_.UnpackTo<T>(message);
+    }
+    template<typename T>
+    bool Is() const
+    {
+        return _impl_._any_metadata_.Is<T>();
+    }
+    static bool ParseAnyTypeUrl(::PROTOBUF_NAMESPACE_ID::ConstStringParam type_url, std::string* full_type_name);
+    friend void swap(Any& a, Any& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Any* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Any* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Any* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Any>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Any& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Any& from)
+    {
+        Any::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Any* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Any";
+    }
+
+protected:
+    explicit Any(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kTypeUrlFieldNumber = 1,
+        kValueFieldNumber = 2,
+    };
+    // string type_url = 1;
+    void clear_type_url();
+    const std::string& type_url() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_type_url(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_type_url();
+    PROTOBUF_NODISCARD std::string* release_type_url();
+    void set_allocated_type_url(std::string* type_url);
+
+private:
+    const std::string& _internal_type_url() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_url(const std::string& value);
+    std::string* _internal_mutable_type_url();
+
+public:
+    // bytes value = 2;
+    void clear_value();
+    const std::string& value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_value();
+    PROTOBUF_NODISCARD std::string* release_value();
+    void set_allocated_value(std::string* value);
+
+private:
+    const std::string& _internal_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+    std::string* _internal_mutable_value();
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Any)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata _any_metadata_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fany_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // Any
 
 // string type_url = 1;
-inline void Any::clear_type_url() {
-  _impl_.type_url_.ClearToEmpty();
+inline void Any::clear_type_url()
+{
+    _impl_.type_url_.ClearToEmpty();
 }
-inline const std::string& Any::type_url() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Any.type_url)
-  return _internal_type_url();
+inline const std::string& Any::type_url() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Any.type_url)
+    return _internal_type_url();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Any::set_type_url(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Any.type_url)
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Any::set_type_url(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.type_url_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Any.type_url)
 }
-inline std::string* Any::mutable_type_url() {
-  std::string* _s = _internal_mutable_type_url();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Any.type_url)
-  return _s;
+inline std::string* Any::mutable_type_url()
+{
+    std::string* _s = _internal_mutable_type_url();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Any.type_url)
+    return _s;
 }
-inline const std::string& Any::_internal_type_url() const {
-  return _impl_.type_url_.Get();
+inline const std::string& Any::_internal_type_url() const
+{
+    return _impl_.type_url_.Get();
 }
-inline void Any::_internal_set_type_url(const std::string& value) {
-  
-  _impl_.type_url_.Set(value, GetArenaForAllocation());
+inline void Any::_internal_set_type_url(const std::string& value)
+{
+    _impl_.type_url_.Set(value, GetArenaForAllocation());
 }
-inline std::string* Any::_internal_mutable_type_url() {
-  
-  return _impl_.type_url_.Mutable(GetArenaForAllocation());
+inline std::string* Any::_internal_mutable_type_url()
+{
+    return _impl_.type_url_.Mutable(GetArenaForAllocation());
 }
-inline std::string* Any::release_type_url() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Any.type_url)
-  return _impl_.type_url_.Release();
+inline std::string* Any::release_type_url()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Any.type_url)
+    return _impl_.type_url_.Release();
 }
-inline void Any::set_allocated_type_url(std::string* type_url) {
-  if (type_url != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.type_url_.SetAllocated(type_url, GetArenaForAllocation());
+inline void Any::set_allocated_type_url(std::string* type_url)
+{
+    if (type_url != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.type_url_.SetAllocated(type_url, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.type_url_.IsDefault()) {
-    _impl_.type_url_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.type_url)
+    if (_impl_.type_url_.IsDefault())
+    {
+        _impl_.type_url_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.type_url)
 }
 
 // bytes value = 2;
-inline void Any::clear_value() {
-  _impl_.value_.ClearToEmpty();
+inline void Any::clear_value()
+{
+    _impl_.value_.ClearToEmpty();
 }
-inline const std::string& Any::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Any.value)
-  return _internal_value();
+inline const std::string& Any::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Any.value)
+    return _internal_value();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Any::set_value(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Any.value)
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Any::set_value(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.value_.SetBytes(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Any.value)
 }
-inline std::string* Any::mutable_value() {
-  std::string* _s = _internal_mutable_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Any.value)
-  return _s;
+inline std::string* Any::mutable_value()
+{
+    std::string* _s = _internal_mutable_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Any.value)
+    return _s;
 }
-inline const std::string& Any::_internal_value() const {
-  return _impl_.value_.Get();
+inline const std::string& Any::_internal_value() const
+{
+    return _impl_.value_.Get();
 }
-inline void Any::_internal_set_value(const std::string& value) {
-  
-  _impl_.value_.Set(value, GetArenaForAllocation());
+inline void Any::_internal_set_value(const std::string& value)
+{
+    _impl_.value_.Set(value, GetArenaForAllocation());
 }
-inline std::string* Any::_internal_mutable_value() {
-  
-  return _impl_.value_.Mutable(GetArenaForAllocation());
+inline std::string* Any::_internal_mutable_value()
+{
+    return _impl_.value_.Mutable(GetArenaForAllocation());
 }
-inline std::string* Any::release_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Any.value)
-  return _impl_.value_.Release();
+inline std::string* Any::release_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Any.value)
+    return _impl_.value_.Release();
 }
-inline void Any::set_allocated_value(std::string* value) {
-  if (value != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+inline void Any::set_allocated_value(std::string* value)
+{
+    if (value != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.value_.SetAllocated(value, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.value_.IsDefault()) {
-    _impl_.value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.value)
+    if (_impl_.value_.IsDefault())
+    {
+        _impl_.value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.value)
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 
 // @@protoc_insertion_point(namespace_scope)
diff --git a/CAPI/cpp/grpc/include/google/protobuf/api.pb.h b/CAPI/cpp/grpc/include/google/protobuf/api.pb.h
index 348bac8..f44dc0a 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/api.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/api.pb.h
@@ -28,7 +28,7 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 #include <google/protobuf/source_context.pb.h>
 #include <google/protobuf/type.pb.h>
@@ -36,14 +36,16 @@
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fapi_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fapi_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fapi_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fapi_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -58,1010 +60,1240 @@ struct MixinDefaultTypeInternal;
 PROTOBUF_EXPORT extern MixinDefaultTypeInternal _Mixin_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Api* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Api>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Method* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Method>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Mixin* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Mixin>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Api* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Api>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Method* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Method>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Mixin* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Mixin>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
 // ===================================================================
 
 class PROTOBUF_EXPORT Api final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Api) */ {
- public:
-  inline Api() : Api(nullptr) {}
-  ~Api() override;
-  explicit PROTOBUF_CONSTEXPR Api(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Api(const Api& from);
-  Api(Api&& from) noexcept
-    : Api() {
-    *this = ::std::move(from);
-  }
-
-  inline Api& operator=(const Api& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Api& operator=(Api&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Api& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Api* internal_default_instance() {
-    return reinterpret_cast<const Api*>(
-               &_Api_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(Api& a, Api& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Api* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Api* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Api* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Api>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Api& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Api& from) {
-    Api::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Api* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Api";
-  }
-  protected:
-  explicit Api(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kMethodsFieldNumber = 2,
-    kOptionsFieldNumber = 3,
-    kMixinsFieldNumber = 6,
-    kNameFieldNumber = 1,
-    kVersionFieldNumber = 4,
-    kSourceContextFieldNumber = 5,
-    kSyntaxFieldNumber = 7,
-  };
-  // repeated .google.protobuf.Method methods = 2;
-  int methods_size() const;
-  private:
-  int _internal_methods_size() const;
-  public:
-  void clear_methods();
-  ::PROTOBUF_NAMESPACE_ID::Method* mutable_methods(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >*
-      mutable_methods();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Method& _internal_methods(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Method* _internal_add_methods();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Method& methods(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Method* add_methods();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >&
-      methods() const;
-
-  // repeated .google.protobuf.Option options = 3;
-  int options_size() const;
-  private:
-  int _internal_options_size() const;
-  public:
-  void clear_options();
-  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-      mutable_options();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-      options() const;
-
-  // repeated .google.protobuf.Mixin mixins = 6;
-  int mixins_size() const;
-  private:
-  int _internal_mixins_size() const;
-  public:
-  void clear_mixins();
-  ::PROTOBUF_NAMESPACE_ID::Mixin* mutable_mixins(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >*
-      mutable_mixins();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Mixin& _internal_mixins(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Mixin* _internal_add_mixins();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Mixin& mixins(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Mixin* add_mixins();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >&
-      mixins() const;
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // string version = 4;
-  void clear_version();
-  const std::string& version() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_version(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_version();
-  PROTOBUF_NODISCARD std::string* release_version();
-  void set_allocated_version(std::string* version);
-  private:
-  const std::string& _internal_version() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
-  std::string* _internal_mutable_version();
-  public:
-
-  // .google.protobuf.SourceContext source_context = 5;
-  bool has_source_context() const;
-  private:
-  bool _internal_has_source_context() const;
-  public:
-  void clear_source_context();
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
-  void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
-  public:
-  void unsafe_arena_set_allocated_source_context(
-      ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
-
-  // .google.protobuf.Syntax syntax = 7;
-  void clear_syntax();
-  ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
-  void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
-  void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Api)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method > methods_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin > mixins_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
-    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
-    int syntax_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Api) */
+{
+public:
+    inline Api() :
+        Api(nullptr)
+    {
+    }
+    ~Api() override;
+    explicit PROTOBUF_CONSTEXPR Api(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Api(const Api& from);
+    Api(Api&& from) noexcept
+        :
+        Api()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Api& operator=(const Api& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Api& operator=(Api&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Api& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Api* internal_default_instance()
+    {
+        return reinterpret_cast<const Api*>(
+            &_Api_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(Api& a, Api& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Api* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Api* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Api* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Api>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Api& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Api& from)
+    {
+        Api::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Api* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Api";
+    }
+
+protected:
+    explicit Api(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kMethodsFieldNumber = 2,
+        kOptionsFieldNumber = 3,
+        kMixinsFieldNumber = 6,
+        kNameFieldNumber = 1,
+        kVersionFieldNumber = 4,
+        kSourceContextFieldNumber = 5,
+        kSyntaxFieldNumber = 7,
+    };
+    // repeated .google.protobuf.Method methods = 2;
+    int methods_size() const;
+
+private:
+    int _internal_methods_size() const;
+
+public:
+    void clear_methods();
+    ::PROTOBUF_NAMESPACE_ID::Method* mutable_methods(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Method>*
+        mutable_methods();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Method& _internal_methods(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Method* _internal_add_methods();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Method& methods(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Method* add_methods();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Method>&
+        methods() const;
+
+    // repeated .google.protobuf.Option options = 3;
+    int options_size() const;
+
+private:
+    int _internal_options_size() const;
+
+public:
+    void clear_options();
+    ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+        mutable_options();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+        options() const;
+
+    // repeated .google.protobuf.Mixin mixins = 6;
+    int mixins_size() const;
+
+private:
+    int _internal_mixins_size() const;
+
+public:
+    void clear_mixins();
+    ::PROTOBUF_NAMESPACE_ID::Mixin* mutable_mixins(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Mixin>*
+        mutable_mixins();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Mixin& _internal_mixins(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Mixin* _internal_add_mixins();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Mixin& mixins(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Mixin* add_mixins();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Mixin>&
+        mixins() const;
+
+    // string name = 1;
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // string version = 4;
+    void clear_version();
+    const std::string& version() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_version(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_version();
+    PROTOBUF_NODISCARD std::string* release_version();
+    void set_allocated_version(std::string* version);
+
+private:
+    const std::string& _internal_version() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+    std::string* _internal_mutable_version();
+
+public:
+    // .google.protobuf.SourceContext source_context = 5;
+    bool has_source_context() const;
+
+private:
+    bool _internal_has_source_context() const;
+
+public:
+    void clear_source_context();
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
+    void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
+
+public:
+    void unsafe_arena_set_allocated_source_context(
+        ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context
+    );
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
+
+    // .google.protobuf.Syntax syntax = 7;
+    void clear_syntax();
+    ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
+    void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
+    void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Api)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Method> methods_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option> options_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Mixin> mixins_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+        ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
+        int syntax_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Method final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Method) */ {
- public:
-  inline Method() : Method(nullptr) {}
-  ~Method() override;
-  explicit PROTOBUF_CONSTEXPR Method(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Method(const Method& from);
-  Method(Method&& from) noexcept
-    : Method() {
-    *this = ::std::move(from);
-  }
-
-  inline Method& operator=(const Method& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Method& operator=(Method&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Method& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Method* internal_default_instance() {
-    return reinterpret_cast<const Method*>(
-               &_Method_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(Method& a, Method& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Method* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Method* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Method* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Method>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Method& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Method& from) {
-    Method::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Method* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Method";
-  }
-  protected:
-  explicit Method(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kOptionsFieldNumber = 6,
-    kNameFieldNumber = 1,
-    kRequestTypeUrlFieldNumber = 2,
-    kResponseTypeUrlFieldNumber = 4,
-    kRequestStreamingFieldNumber = 3,
-    kResponseStreamingFieldNumber = 5,
-    kSyntaxFieldNumber = 7,
-  };
-  // repeated .google.protobuf.Option options = 6;
-  int options_size() const;
-  private:
-  int _internal_options_size() const;
-  public:
-  void clear_options();
-  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-      mutable_options();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-      options() const;
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // string request_type_url = 2;
-  void clear_request_type_url();
-  const std::string& request_type_url() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_request_type_url(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_request_type_url();
-  PROTOBUF_NODISCARD std::string* release_request_type_url();
-  void set_allocated_request_type_url(std::string* request_type_url);
-  private:
-  const std::string& _internal_request_type_url() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_type_url(const std::string& value);
-  std::string* _internal_mutable_request_type_url();
-  public:
-
-  // string response_type_url = 4;
-  void clear_response_type_url();
-  const std::string& response_type_url() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_response_type_url(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_response_type_url();
-  PROTOBUF_NODISCARD std::string* release_response_type_url();
-  void set_allocated_response_type_url(std::string* response_type_url);
-  private:
-  const std::string& _internal_response_type_url() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_response_type_url(const std::string& value);
-  std::string* _internal_mutable_response_type_url();
-  public:
-
-  // bool request_streaming = 3;
-  void clear_request_streaming();
-  bool request_streaming() const;
-  void set_request_streaming(bool value);
-  private:
-  bool _internal_request_streaming() const;
-  void _internal_set_request_streaming(bool value);
-  public:
-
-  // bool response_streaming = 5;
-  void clear_response_streaming();
-  bool response_streaming() const;
-  void set_response_streaming(bool value);
-  private:
-  bool _internal_response_streaming() const;
-  void _internal_set_response_streaming(bool value);
-  public:
-
-  // .google.protobuf.Syntax syntax = 7;
-  void clear_syntax();
-  ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
-  void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
-  void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Method)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_type_url_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_type_url_;
-    bool request_streaming_;
-    bool response_streaming_;
-    int syntax_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Method) */
+{
+public:
+    inline Method() :
+        Method(nullptr)
+    {
+    }
+    ~Method() override;
+    explicit PROTOBUF_CONSTEXPR Method(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Method(const Method& from);
+    Method(Method&& from) noexcept
+        :
+        Method()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Method& operator=(const Method& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Method& operator=(Method&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Method& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Method* internal_default_instance()
+    {
+        return reinterpret_cast<const Method*>(
+            &_Method_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        1;
+
+    friend void swap(Method& a, Method& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Method* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Method* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Method* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Method>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Method& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Method& from)
+    {
+        Method::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Method* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Method";
+    }
+
+protected:
+    explicit Method(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kOptionsFieldNumber = 6,
+        kNameFieldNumber = 1,
+        kRequestTypeUrlFieldNumber = 2,
+        kResponseTypeUrlFieldNumber = 4,
+        kRequestStreamingFieldNumber = 3,
+        kResponseStreamingFieldNumber = 5,
+        kSyntaxFieldNumber = 7,
+    };
+    // repeated .google.protobuf.Option options = 6;
+    int options_size() const;
+
+private:
+    int _internal_options_size() const;
+
+public:
+    void clear_options();
+    ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+        mutable_options();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+        options() const;
+
+    // string name = 1;
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // string request_type_url = 2;
+    void clear_request_type_url();
+    const std::string& request_type_url() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_request_type_url(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_request_type_url();
+    PROTOBUF_NODISCARD std::string* release_request_type_url();
+    void set_allocated_request_type_url(std::string* request_type_url);
+
+private:
+    const std::string& _internal_request_type_url() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_type_url(const std::string& value);
+    std::string* _internal_mutable_request_type_url();
+
+public:
+    // string response_type_url = 4;
+    void clear_response_type_url();
+    const std::string& response_type_url() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_response_type_url(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_response_type_url();
+    PROTOBUF_NODISCARD std::string* release_response_type_url();
+    void set_allocated_response_type_url(std::string* response_type_url);
+
+private:
+    const std::string& _internal_response_type_url() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_response_type_url(const std::string& value);
+    std::string* _internal_mutable_response_type_url();
+
+public:
+    // bool request_streaming = 3;
+    void clear_request_streaming();
+    bool request_streaming() const;
+    void set_request_streaming(bool value);
+
+private:
+    bool _internal_request_streaming() const;
+    void _internal_set_request_streaming(bool value);
+
+public:
+    // bool response_streaming = 5;
+    void clear_response_streaming();
+    bool response_streaming() const;
+    void set_response_streaming(bool value);
+
+private:
+    bool _internal_response_streaming() const;
+    void _internal_set_response_streaming(bool value);
+
+public:
+    // .google.protobuf.Syntax syntax = 7;
+    void clear_syntax();
+    ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
+    void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
+    void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Method)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option> options_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_type_url_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_type_url_;
+        bool request_streaming_;
+        bool response_streaming_;
+        int syntax_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Mixin final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Mixin) */ {
- public:
-  inline Mixin() : Mixin(nullptr) {}
-  ~Mixin() override;
-  explicit PROTOBUF_CONSTEXPR Mixin(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Mixin(const Mixin& from);
-  Mixin(Mixin&& from) noexcept
-    : Mixin() {
-    *this = ::std::move(from);
-  }
-
-  inline Mixin& operator=(const Mixin& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Mixin& operator=(Mixin&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Mixin& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Mixin* internal_default_instance() {
-    return reinterpret_cast<const Mixin*>(
-               &_Mixin_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(Mixin& a, Mixin& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Mixin* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Mixin* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Mixin* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Mixin>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Mixin& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Mixin& from) {
-    Mixin::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Mixin* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Mixin";
-  }
-  protected:
-  explicit Mixin(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 1,
-    kRootFieldNumber = 2,
-  };
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // string root = 2;
-  void clear_root();
-  const std::string& root() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_root(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_root();
-  PROTOBUF_NODISCARD std::string* release_root();
-  void set_allocated_root(std::string* root);
-  private:
-  const std::string& _internal_root() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_root(const std::string& value);
-  std::string* _internal_mutable_root();
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Mixin)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Mixin) */
+{
+public:
+    inline Mixin() :
+        Mixin(nullptr)
+    {
+    }
+    ~Mixin() override;
+    explicit PROTOBUF_CONSTEXPR Mixin(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Mixin(const Mixin& from);
+    Mixin(Mixin&& from) noexcept
+        :
+        Mixin()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Mixin& operator=(const Mixin& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Mixin& operator=(Mixin&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Mixin& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Mixin* internal_default_instance()
+    {
+        return reinterpret_cast<const Mixin*>(
+            &_Mixin_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        2;
+
+    friend void swap(Mixin& a, Mixin& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Mixin* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Mixin* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Mixin* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Mixin>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Mixin& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Mixin& from)
+    {
+        Mixin::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Mixin* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Mixin";
+    }
+
+protected:
+    explicit Mixin(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNameFieldNumber = 1,
+        kRootFieldNumber = 2,
+    };
+    // string name = 1;
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // string root = 2;
+    void clear_root();
+    const std::string& root() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_root(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_root();
+    PROTOBUF_NODISCARD std::string* release_root();
+    void set_allocated_root(std::string* root);
+
+private:
+    const std::string& _internal_root() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_root(const std::string& value);
+    std::string* _internal_mutable_root();
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Mixin)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr root_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fapi_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // Api
 
 // string name = 1;
-inline void Api::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& Api::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Api.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Api::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Api.name)
-}
-inline std::string* Api::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.name)
-  return _s;
-}
-inline const std::string& Api::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void Api::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Api::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Api::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Api.name)
-  return _impl_.name_.Release();
-}
-inline void Api::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+inline void Api::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Api::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Api.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Api::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Api.name)
+}
+inline std::string* Api::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Api.name)
+    return _s;
+}
+inline const std::string& Api::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void Api::_internal_set_name(const std::string& value)
+{
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Api::_internal_mutable_name()
+{
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Api::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Api.name)
+    return _impl_.name_.Release();
+}
+inline void Api::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.name)
 }
 
 // repeated .google.protobuf.Method methods = 2;
-inline int Api::_internal_methods_size() const {
-  return _impl_.methods_.size();
-}
-inline int Api::methods_size() const {
-  return _internal_methods_size();
-}
-inline void Api::clear_methods() {
-  _impl_.methods_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Method* Api::mutable_methods(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.methods)
-  return _impl_.methods_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >*
-Api::mutable_methods() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.methods)
-  return &_impl_.methods_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Method& Api::_internal_methods(int index) const {
-  return _impl_.methods_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Method& Api::methods(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Api.methods)
-  return _internal_methods(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Method* Api::_internal_add_methods() {
-  return _impl_.methods_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Method* Api::add_methods() {
-  ::PROTOBUF_NAMESPACE_ID::Method* _add = _internal_add_methods();
-  // @@protoc_insertion_point(field_add:google.protobuf.Api.methods)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Method >&
-Api::methods() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Api.methods)
-  return _impl_.methods_;
+inline int Api::_internal_methods_size() const
+{
+    return _impl_.methods_.size();
+}
+inline int Api::methods_size() const
+{
+    return _internal_methods_size();
+}
+inline void Api::clear_methods()
+{
+    _impl_.methods_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Method* Api::mutable_methods(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Api.methods)
+    return _impl_.methods_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Method>*
+    Api::mutable_methods()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.methods)
+    return &_impl_.methods_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Method& Api::_internal_methods(int index) const
+{
+    return _impl_.methods_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Method& Api::methods(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Api.methods)
+    return _internal_methods(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Method* Api::_internal_add_methods()
+{
+    return _impl_.methods_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Method* Api::add_methods()
+{
+    ::PROTOBUF_NAMESPACE_ID::Method* _add = _internal_add_methods();
+    // @@protoc_insertion_point(field_add:google.protobuf.Api.methods)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Method>&
+    Api::methods() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Api.methods)
+    return _impl_.methods_;
 }
 
 // repeated .google.protobuf.Option options = 3;
-inline int Api::_internal_options_size() const {
-  return _impl_.options_.size();
-}
-inline int Api::options_size() const {
-  return _internal_options_size();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Api::mutable_options(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.options)
-  return _impl_.options_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-Api::mutable_options() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.options)
-  return &_impl_.options_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Api::_internal_options(int index) const {
-  return _impl_.options_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Api::options(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Api.options)
-  return _internal_options(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Api::_internal_add_options() {
-  return _impl_.options_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Api::add_options() {
-  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
-  // @@protoc_insertion_point(field_add:google.protobuf.Api.options)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-Api::options() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Api.options)
-  return _impl_.options_;
+inline int Api::_internal_options_size() const
+{
+    return _impl_.options_.size();
+}
+inline int Api::options_size() const
+{
+    return _internal_options_size();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Api::mutable_options(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Api.options)
+    return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+    Api::mutable_options()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.options)
+    return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Api::_internal_options(int index) const
+{
+    return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Api::options(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Api.options)
+    return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Api::_internal_add_options()
+{
+    return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Api::add_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+    // @@protoc_insertion_point(field_add:google.protobuf.Api.options)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+    Api::options() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Api.options)
+    return _impl_.options_;
 }
 
 // string version = 4;
-inline void Api::clear_version() {
-  _impl_.version_.ClearToEmpty();
-}
-inline const std::string& Api::version() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Api.version)
-  return _internal_version();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Api::set_version(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Api.version)
-}
-inline std::string* Api::mutable_version() {
-  std::string* _s = _internal_mutable_version();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.version)
-  return _s;
-}
-inline const std::string& Api::_internal_version() const {
-  return _impl_.version_.Get();
-}
-inline void Api::_internal_set_version(const std::string& value) {
-  
-  _impl_.version_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Api::_internal_mutable_version() {
-  
-  return _impl_.version_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Api::release_version() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Api.version)
-  return _impl_.version_.Release();
-}
-inline void Api::set_allocated_version(std::string* version) {
-  if (version != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
+inline void Api::clear_version()
+{
+    _impl_.version_.ClearToEmpty();
+}
+inline const std::string& Api::version() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Api.version)
+    return _internal_version();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Api::set_version(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.version_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Api.version)
+}
+inline std::string* Api::mutable_version()
+{
+    std::string* _s = _internal_mutable_version();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Api.version)
+    return _s;
+}
+inline const std::string& Api::_internal_version() const
+{
+    return _impl_.version_.Get();
+}
+inline void Api::_internal_set_version(const std::string& value)
+{
+    _impl_.version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Api::_internal_mutable_version()
+{
+    return _impl_.version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Api::release_version()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Api.version)
+    return _impl_.version_.Release();
+}
+inline void Api::set_allocated_version(std::string* version)
+{
+    if (version != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.version_.SetAllocated(version, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.version_.IsDefault()) {
-    _impl_.version_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.version)
+    if (_impl_.version_.IsDefault())
+    {
+        _impl_.version_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.version)
 }
 
 // .google.protobuf.SourceContext source_context = 5;
-inline bool Api::_internal_has_source_context() const {
-  return this != internal_default_instance() && _impl_.source_context_ != nullptr;
+inline bool Api::_internal_has_source_context() const
+{
+    return this != internal_default_instance() && _impl_.source_context_ != nullptr;
 }
-inline bool Api::has_source_context() const {
-  return _internal_has_source_context();
+inline bool Api::has_source_context() const
+{
+    return _internal_has_source_context();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Api::_internal_source_context() const {
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(
-      ::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Api::_internal_source_context() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Api::source_context() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Api.source_context)
-  return _internal_source_context();
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Api::source_context() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Api.source_context)
+    return _internal_source_context();
 }
 inline void Api::unsafe_arena_set_allocated_source_context(
-    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
-  }
-  _impl_.source_context_ = source_context;
-  if (source_context) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Api.source_context)
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::release_source_context() {
-  
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
-  _impl_.source_context_ = nullptr;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+    }
+    _impl_.source_context_ = source_context;
+    if (source_context)
+    {
+    }
+    else
+    {
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Api.source_context)
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::release_source_context()
+{
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+    _impl_.source_context_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
+    }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::unsafe_arena_release_source_context() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Api.source_context)
-  
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
-  _impl_.source_context_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::_internal_mutable_source_context() {
-  
-  if (_impl_.source_context_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
-    _impl_.source_context_ = p;
-  }
-  return _impl_.source_context_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::mutable_source_context() {
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.source_context)
-  return _msg;
-}
-inline void Api::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
-  }
-  if (source_context) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
-                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context));
-    if (message_arena != submessage_arena) {
-      source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, source_context, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  _impl_.source_context_ = source_context;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.source_context)
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::unsafe_arena_release_source_context()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Api.source_context)
+
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+    _impl_.source_context_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::_internal_mutable_source_context()
+{
+    if (_impl_.source_context_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
+        _impl_.source_context_ = p;
+    }
+    return _impl_.source_context_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Api::mutable_source_context()
+{
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Api.source_context)
+    return _msg;
+}
+inline void Api::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+    }
+    if (source_context)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context)
+            );
+        if (message_arena != submessage_arena)
+        {
+            source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, source_context, submessage_arena
+            );
+        }
+    }
+    else
+    {
+    }
+    _impl_.source_context_ = source_context;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.source_context)
 }
 
 // repeated .google.protobuf.Mixin mixins = 6;
-inline int Api::_internal_mixins_size() const {
-  return _impl_.mixins_.size();
-}
-inline int Api::mixins_size() const {
-  return _internal_mixins_size();
-}
-inline void Api::clear_mixins() {
-  _impl_.mixins_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::mutable_mixins(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.mixins)
-  return _impl_.mixins_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >*
-Api::mutable_mixins() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.mixins)
-  return &_impl_.mixins_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Mixin& Api::_internal_mixins(int index) const {
-  return _impl_.mixins_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Mixin& Api::mixins(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Api.mixins)
-  return _internal_mixins(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::_internal_add_mixins() {
-  return _impl_.mixins_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::add_mixins() {
-  ::PROTOBUF_NAMESPACE_ID::Mixin* _add = _internal_add_mixins();
-  // @@protoc_insertion_point(field_add:google.protobuf.Api.mixins)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Mixin >&
-Api::mixins() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Api.mixins)
-  return _impl_.mixins_;
+inline int Api::_internal_mixins_size() const
+{
+    return _impl_.mixins_.size();
+}
+inline int Api::mixins_size() const
+{
+    return _internal_mixins_size();
+}
+inline void Api::clear_mixins()
+{
+    _impl_.mixins_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::mutable_mixins(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Api.mixins)
+    return _impl_.mixins_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Mixin>*
+    Api::mutable_mixins()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.mixins)
+    return &_impl_.mixins_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Mixin& Api::_internal_mixins(int index) const
+{
+    return _impl_.mixins_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Mixin& Api::mixins(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Api.mixins)
+    return _internal_mixins(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::_internal_add_mixins()
+{
+    return _impl_.mixins_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Mixin* Api::add_mixins()
+{
+    ::PROTOBUF_NAMESPACE_ID::Mixin* _add = _internal_add_mixins();
+    // @@protoc_insertion_point(field_add:google.protobuf.Api.mixins)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Mixin>&
+    Api::mixins() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Api.mixins)
+    return _impl_.mixins_;
 }
 
 // .google.protobuf.Syntax syntax = 7;
-inline void Api::clear_syntax() {
-  _impl_.syntax_ = 0;
+inline void Api::clear_syntax()
+{
+    _impl_.syntax_ = 0;
 }
-inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::_internal_syntax() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::_internal_syntax() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::Syntax>(_impl_.syntax_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::syntax() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Api.syntax)
-  return _internal_syntax();
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Api::syntax() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Api.syntax)
+    return _internal_syntax();
 }
-inline void Api::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
-  
-  _impl_.syntax_ = value;
+inline void Api::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value)
+{
+    _impl_.syntax_ = value;
 }
-inline void Api::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
-  _internal_set_syntax(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Api.syntax)
+inline void Api::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value)
+{
+    _internal_set_syntax(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Api.syntax)
 }
 
 // -------------------------------------------------------------------
@@ -1069,250 +1301,292 @@ inline void Api::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
 // Method
 
 // string name = 1;
-inline void Method::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& Method::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Method.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Method::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Method.name)
-}
-inline std::string* Method::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.name)
-  return _s;
-}
-inline const std::string& Method::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void Method::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Method::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Method::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Method.name)
-  return _impl_.name_.Release();
-}
-inline void Method::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+inline void Method::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Method::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Method.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Method::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Method.name)
+}
+inline std::string* Method::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Method.name)
+    return _s;
+}
+inline const std::string& Method::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void Method::_internal_set_name(const std::string& value)
+{
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Method::_internal_mutable_name()
+{
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Method::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Method.name)
+    return _impl_.name_.Release();
+}
+inline void Method::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.name)
 }
 
 // string request_type_url = 2;
-inline void Method::clear_request_type_url() {
-  _impl_.request_type_url_.ClearToEmpty();
-}
-inline const std::string& Method::request_type_url() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Method.request_type_url)
-  return _internal_request_type_url();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Method::set_request_type_url(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.request_type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Method.request_type_url)
-}
-inline std::string* Method::mutable_request_type_url() {
-  std::string* _s = _internal_mutable_request_type_url();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.request_type_url)
-  return _s;
-}
-inline const std::string& Method::_internal_request_type_url() const {
-  return _impl_.request_type_url_.Get();
-}
-inline void Method::_internal_set_request_type_url(const std::string& value) {
-  
-  _impl_.request_type_url_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Method::_internal_mutable_request_type_url() {
-  
-  return _impl_.request_type_url_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Method::release_request_type_url() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Method.request_type_url)
-  return _impl_.request_type_url_.Release();
-}
-inline void Method::set_allocated_request_type_url(std::string* request_type_url) {
-  if (request_type_url != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.request_type_url_.SetAllocated(request_type_url, GetArenaForAllocation());
+inline void Method::clear_request_type_url()
+{
+    _impl_.request_type_url_.ClearToEmpty();
+}
+inline const std::string& Method::request_type_url() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Method.request_type_url)
+    return _internal_request_type_url();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Method::set_request_type_url(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.request_type_url_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Method.request_type_url)
+}
+inline std::string* Method::mutable_request_type_url()
+{
+    std::string* _s = _internal_mutable_request_type_url();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Method.request_type_url)
+    return _s;
+}
+inline const std::string& Method::_internal_request_type_url() const
+{
+    return _impl_.request_type_url_.Get();
+}
+inline void Method::_internal_set_request_type_url(const std::string& value)
+{
+    _impl_.request_type_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Method::_internal_mutable_request_type_url()
+{
+    return _impl_.request_type_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Method::release_request_type_url()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Method.request_type_url)
+    return _impl_.request_type_url_.Release();
+}
+inline void Method::set_allocated_request_type_url(std::string* request_type_url)
+{
+    if (request_type_url != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.request_type_url_.SetAllocated(request_type_url, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.request_type_url_.IsDefault()) {
-    _impl_.request_type_url_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.request_type_url)
+    if (_impl_.request_type_url_.IsDefault())
+    {
+        _impl_.request_type_url_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.request_type_url)
 }
 
 // bool request_streaming = 3;
-inline void Method::clear_request_streaming() {
-  _impl_.request_streaming_ = false;
+inline void Method::clear_request_streaming()
+{
+    _impl_.request_streaming_ = false;
 }
-inline bool Method::_internal_request_streaming() const {
-  return _impl_.request_streaming_;
+inline bool Method::_internal_request_streaming() const
+{
+    return _impl_.request_streaming_;
 }
-inline bool Method::request_streaming() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Method.request_streaming)
-  return _internal_request_streaming();
+inline bool Method::request_streaming() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Method.request_streaming)
+    return _internal_request_streaming();
 }
-inline void Method::_internal_set_request_streaming(bool value) {
-  
-  _impl_.request_streaming_ = value;
+inline void Method::_internal_set_request_streaming(bool value)
+{
+    _impl_.request_streaming_ = value;
 }
-inline void Method::set_request_streaming(bool value) {
-  _internal_set_request_streaming(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Method.request_streaming)
+inline void Method::set_request_streaming(bool value)
+{
+    _internal_set_request_streaming(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Method.request_streaming)
 }
 
 // string response_type_url = 4;
-inline void Method::clear_response_type_url() {
-  _impl_.response_type_url_.ClearToEmpty();
-}
-inline const std::string& Method::response_type_url() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Method.response_type_url)
-  return _internal_response_type_url();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Method::set_response_type_url(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.response_type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Method.response_type_url)
-}
-inline std::string* Method::mutable_response_type_url() {
-  std::string* _s = _internal_mutable_response_type_url();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.response_type_url)
-  return _s;
-}
-inline const std::string& Method::_internal_response_type_url() const {
-  return _impl_.response_type_url_.Get();
-}
-inline void Method::_internal_set_response_type_url(const std::string& value) {
-  
-  _impl_.response_type_url_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Method::_internal_mutable_response_type_url() {
-  
-  return _impl_.response_type_url_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Method::release_response_type_url() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Method.response_type_url)
-  return _impl_.response_type_url_.Release();
-}
-inline void Method::set_allocated_response_type_url(std::string* response_type_url) {
-  if (response_type_url != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.response_type_url_.SetAllocated(response_type_url, GetArenaForAllocation());
+inline void Method::clear_response_type_url()
+{
+    _impl_.response_type_url_.ClearToEmpty();
+}
+inline const std::string& Method::response_type_url() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Method.response_type_url)
+    return _internal_response_type_url();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Method::set_response_type_url(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.response_type_url_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Method.response_type_url)
+}
+inline std::string* Method::mutable_response_type_url()
+{
+    std::string* _s = _internal_mutable_response_type_url();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Method.response_type_url)
+    return _s;
+}
+inline const std::string& Method::_internal_response_type_url() const
+{
+    return _impl_.response_type_url_.Get();
+}
+inline void Method::_internal_set_response_type_url(const std::string& value)
+{
+    _impl_.response_type_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Method::_internal_mutable_response_type_url()
+{
+    return _impl_.response_type_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Method::release_response_type_url()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Method.response_type_url)
+    return _impl_.response_type_url_.Release();
+}
+inline void Method::set_allocated_response_type_url(std::string* response_type_url)
+{
+    if (response_type_url != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.response_type_url_.SetAllocated(response_type_url, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.response_type_url_.IsDefault()) {
-    _impl_.response_type_url_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.response_type_url)
+    if (_impl_.response_type_url_.IsDefault())
+    {
+        _impl_.response_type_url_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.response_type_url)
 }
 
 // bool response_streaming = 5;
-inline void Method::clear_response_streaming() {
-  _impl_.response_streaming_ = false;
+inline void Method::clear_response_streaming()
+{
+    _impl_.response_streaming_ = false;
 }
-inline bool Method::_internal_response_streaming() const {
-  return _impl_.response_streaming_;
+inline bool Method::_internal_response_streaming() const
+{
+    return _impl_.response_streaming_;
 }
-inline bool Method::response_streaming() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Method.response_streaming)
-  return _internal_response_streaming();
+inline bool Method::response_streaming() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Method.response_streaming)
+    return _internal_response_streaming();
 }
-inline void Method::_internal_set_response_streaming(bool value) {
-  
-  _impl_.response_streaming_ = value;
+inline void Method::_internal_set_response_streaming(bool value)
+{
+    _impl_.response_streaming_ = value;
 }
-inline void Method::set_response_streaming(bool value) {
-  _internal_set_response_streaming(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Method.response_streaming)
+inline void Method::set_response_streaming(bool value)
+{
+    _internal_set_response_streaming(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Method.response_streaming)
 }
 
 // repeated .google.protobuf.Option options = 6;
-inline int Method::_internal_options_size() const {
-  return _impl_.options_.size();
-}
-inline int Method::options_size() const {
-  return _internal_options_size();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Method::mutable_options(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.options)
-  return _impl_.options_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-Method::mutable_options() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Method.options)
-  return &_impl_.options_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Method::_internal_options(int index) const {
-  return _impl_.options_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Method::options(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Method.options)
-  return _internal_options(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Method::_internal_add_options() {
-  return _impl_.options_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Method::add_options() {
-  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
-  // @@protoc_insertion_point(field_add:google.protobuf.Method.options)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-Method::options() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Method.options)
-  return _impl_.options_;
+inline int Method::_internal_options_size() const
+{
+    return _impl_.options_.size();
+}
+inline int Method::options_size() const
+{
+    return _internal_options_size();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Method::mutable_options(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Method.options)
+    return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+    Method::mutable_options()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Method.options)
+    return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Method::_internal_options(int index) const
+{
+    return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Method::options(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Method.options)
+    return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Method::_internal_add_options()
+{
+    return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Method::add_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+    // @@protoc_insertion_point(field_add:google.protobuf.Method.options)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+    Method::options() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Method.options)
+    return _impl_.options_;
 }
 
 // .google.protobuf.Syntax syntax = 7;
-inline void Method::clear_syntax() {
-  _impl_.syntax_ = 0;
+inline void Method::clear_syntax()
+{
+    _impl_.syntax_ = 0;
 }
-inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::_internal_syntax() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::_internal_syntax() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::Syntax>(_impl_.syntax_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::syntax() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Method.syntax)
-  return _internal_syntax();
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Method::syntax() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Method.syntax)
+    return _internal_syntax();
 }
-inline void Method::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
-  
-  _impl_.syntax_ = value;
+inline void Method::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value)
+{
+    _impl_.syntax_ = value;
 }
-inline void Method::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
-  _internal_set_syntax(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Method.syntax)
+inline void Method::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value)
+{
+    _internal_set_syntax(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Method.syntax)
 }
 
 // -------------------------------------------------------------------
@@ -1320,113 +1594,126 @@ inline void Method::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
 // Mixin
 
 // string name = 1;
-inline void Mixin::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& Mixin::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Mixin.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Mixin::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Mixin.name)
-}
-inline std::string* Mixin::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.name)
-  return _s;
-}
-inline const std::string& Mixin::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void Mixin::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Mixin::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Mixin::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Mixin.name)
-  return _impl_.name_.Release();
-}
-inline void Mixin::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+inline void Mixin::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Mixin::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Mixin.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Mixin::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Mixin.name)
+}
+inline std::string* Mixin::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.name)
+    return _s;
+}
+inline const std::string& Mixin::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void Mixin::_internal_set_name(const std::string& value)
+{
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Mixin::_internal_mutable_name()
+{
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Mixin::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Mixin.name)
+    return _impl_.name_.Release();
+}
+inline void Mixin::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.name)
 }
 
 // string root = 2;
-inline void Mixin::clear_root() {
-  _impl_.root_.ClearToEmpty();
-}
-inline const std::string& Mixin::root() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Mixin.root)
-  return _internal_root();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Mixin::set_root(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.root_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Mixin.root)
-}
-inline std::string* Mixin::mutable_root() {
-  std::string* _s = _internal_mutable_root();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.root)
-  return _s;
-}
-inline const std::string& Mixin::_internal_root() const {
-  return _impl_.root_.Get();
-}
-inline void Mixin::_internal_set_root(const std::string& value) {
-  
-  _impl_.root_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Mixin::_internal_mutable_root() {
-  
-  return _impl_.root_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Mixin::release_root() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Mixin.root)
-  return _impl_.root_.Release();
-}
-inline void Mixin::set_allocated_root(std::string* root) {
-  if (root != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.root_.SetAllocated(root, GetArenaForAllocation());
+inline void Mixin::clear_root()
+{
+    _impl_.root_.ClearToEmpty();
+}
+inline const std::string& Mixin::root() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Mixin.root)
+    return _internal_root();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Mixin::set_root(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.root_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Mixin.root)
+}
+inline std::string* Mixin::mutable_root()
+{
+    std::string* _s = _internal_mutable_root();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.root)
+    return _s;
+}
+inline const std::string& Mixin::_internal_root() const
+{
+    return _impl_.root_.Get();
+}
+inline void Mixin::_internal_set_root(const std::string& value)
+{
+    _impl_.root_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Mixin::_internal_mutable_root()
+{
+    return _impl_.root_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Mixin::release_root()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Mixin.root)
+    return _impl_.root_.Release();
+}
+inline void Mixin::set_allocated_root(std::string* root)
+{
+    if (root != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.root_.SetAllocated(root, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.root_.IsDefault()) {
-    _impl_.root_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.root)
+    if (_impl_.root_.IsDefault())
+    {
+        _impl_.root_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.root)
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 // -------------------------------------------------------------------
 
 // -------------------------------------------------------------------
 
-
 // @@protoc_insertion_point(namespace_scope)
 
 PROTOBUF_NAMESPACE_CLOSE
diff --git a/CAPI/cpp/grpc/include/google/protobuf/arena.h b/CAPI/cpp/grpc/include/google/protobuf/arena.h
index 3b5f16c..a60d22a 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/arena.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/arena.h
@@ -33,7 +33,6 @@
 #ifndef GOOGLE_PROTOBUF_ARENA_H__
 #define GOOGLE_PROTOBUF_ARENA_H__
 
-
 #include <limits>
 #include <type_traits>
 #include <utility>
@@ -41,8 +40,9 @@
 // Work around bugs in MSVC <typeinfo> header when _HAS_EXCEPTIONS=0.
 #include <exception>
 #include <typeinfo>
-namespace std {
-using type_info = ::type_info;
+namespace std
+{
+    using type_info = ::type_info;
 }
 #else
 #include <typeinfo>
@@ -59,132 +59,147 @@ using type_info = ::type_info;
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-struct ArenaOptions;  // defined below
-class Arena;    // defined below
-class Message;  // defined in message.h
-class MessageLite;
-template <typename Key, typename T>
-class Map;
-
-namespace arena_metrics {
-
-void EnableArenaMetrics(ArenaOptions* options);
-
-}  // namespace arena_metrics
-
-namespace TestUtil {
-class ReflectionTester;  // defined in test_util.h
-}  // namespace TestUtil
-
-namespace internal {
-
-struct ArenaTestPeer;        // defined in arena_test_util.h
-class InternalMetadata;      // defined in metadata_lite.h
-class LazyField;             // defined in lazy_field.h
-class EpsCopyInputStream;    // defined in parse_context.h
-class RepeatedPtrFieldBase;  // defined in repeated_ptr_field.h
-
-template <typename Type>
-class GenericTypeHandler;  // defined in repeated_field.h
-
-inline PROTOBUF_ALWAYS_INLINE
-void* AlignTo(void* ptr, size_t align) {
-  return reinterpret_cast<void*>(
-      (reinterpret_cast<uintptr_t>(ptr) + align - 1) & (~align + 1));
-}
-
-// Templated cleanup methods.
-template <typename T>
-void arena_destruct_object(void* object) {
-  reinterpret_cast<T*>(object)->~T();
-}
-
-template <bool destructor_skippable, typename T>
-struct ObjectDestructor {
-  constexpr static void (*destructor)(void*) = &arena_destruct_object<T>;
-};
-
-template <typename T>
-struct ObjectDestructor<true, T> {
-  constexpr static void (*destructor)(void*) = nullptr;
-};
-
-template <typename T>
-void arena_delete_object(void* object) {
-  delete reinterpret_cast<T*>(object);
-}
-}  // namespace internal
-
-// ArenaOptions provides optional additional parameters to arena construction
-// that control its block-allocation behavior.
-struct ArenaOptions {
-  // This defines the size of the first block requested from the system malloc.
-  // Subsequent block sizes will increase in a geometric series up to a maximum.
-  size_t start_block_size;
-
-  // This defines the maximum block size requested from system malloc (unless an
-  // individual arena allocation request occurs with a size larger than this
-  // maximum). Requested block sizes increase up to this value, then remain
-  // here.
-  size_t max_block_size;
-
-  // An initial block of memory for the arena to use, or NULL for none. If
-  // provided, the block must live at least as long as the arena itself. The
-  // creator of the Arena retains ownership of the block after the Arena is
-  // destroyed.
-  char* initial_block;
-
-  // The size of the initial block, if provided.
-  size_t initial_block_size;
-
-  // A function pointer to an alloc method that returns memory blocks of size
-  // requested. By default, it contains a ptr to the malloc function.
-  //
-  // NOTE: block_alloc and dealloc functions are expected to behave like
-  // malloc and free, including Asan poisoning.
-  void* (*block_alloc)(size_t);
-  // A function pointer to a dealloc method that takes ownership of the blocks
-  // from the arena. By default, it contains a ptr to a wrapper function that
-  // calls free.
-  void (*block_dealloc)(void*, size_t);
-
-  ArenaOptions()
-      : start_block_size(internal::AllocationPolicy::kDefaultStartBlockSize),
-        max_block_size(internal::AllocationPolicy::kDefaultMaxBlockSize),
-        initial_block(NULL),
-        initial_block_size(0),
-        block_alloc(nullptr),
-        block_dealloc(nullptr),
-        make_metrics_collector(nullptr) {}
-
- private:
-  // If make_metrics_collector is not nullptr, it will be called at Arena init
-  // time. It may return a pointer to a collector instance that will be notified
-  // of interesting events related to the arena.
-  internal::ArenaMetricsCollector* (*make_metrics_collector)();
-
-  internal::ArenaMetricsCollector* MetricsCollector() const {
-    return make_metrics_collector ? (*make_metrics_collector)() : nullptr;
-  }
-
-  internal::AllocationPolicy AllocationPolicy() const {
-    internal::AllocationPolicy res;
-    res.start_block_size = start_block_size;
-    res.max_block_size = max_block_size;
-    res.block_alloc = block_alloc;
-    res.block_dealloc = block_dealloc;
-    res.metrics_collector = MetricsCollector();
-    return res;
-  }
-
-  friend void arena_metrics::EnableArenaMetrics(ArenaOptions*);
-
-  friend class Arena;
-  friend class ArenaOptionsTestFriend;
-};
+namespace google
+{
+    namespace protobuf
+    {
+
+        struct ArenaOptions;  // defined below
+        class Arena;          // defined below
+        class Message;        // defined in message.h
+        class MessageLite;
+        template<typename Key, typename T>
+        class Map;
+
+        namespace arena_metrics
+        {
+
+            void EnableArenaMetrics(ArenaOptions* options);
+
+        }  // namespace arena_metrics
+
+        namespace TestUtil
+        {
+            class ReflectionTester;  // defined in test_util.h
+        }                            // namespace TestUtil
+
+        namespace internal
+        {
+
+            struct ArenaTestPeer;        // defined in arena_test_util.h
+            class InternalMetadata;      // defined in metadata_lite.h
+            class LazyField;             // defined in lazy_field.h
+            class EpsCopyInputStream;    // defined in parse_context.h
+            class RepeatedPtrFieldBase;  // defined in repeated_ptr_field.h
+
+            template<typename Type>
+            class GenericTypeHandler;  // defined in repeated_field.h
+
+            inline PROTOBUF_ALWAYS_INLINE void* AlignTo(void* ptr, size_t align)
+            {
+                return reinterpret_cast<void*>(
+                    (reinterpret_cast<uintptr_t>(ptr) + align - 1) & (~align + 1)
+                );
+            }
+
+            // Templated cleanup methods.
+            template<typename T>
+            void arena_destruct_object(void* object)
+            {
+                reinterpret_cast<T*>(object)->~T();
+            }
+
+            template<bool destructor_skippable, typename T>
+            struct ObjectDestructor
+            {
+                constexpr static void (*destructor)(void*) = &arena_destruct_object<T>;
+            };
+
+            template<typename T>
+            struct ObjectDestructor<true, T>
+            {
+                constexpr static void (*destructor)(void*) = nullptr;
+            };
+
+            template<typename T>
+            void arena_delete_object(void* object)
+            {
+                delete reinterpret_cast<T*>(object);
+            }
+        }  // namespace internal
+
+        // ArenaOptions provides optional additional parameters to arena construction
+        // that control its block-allocation behavior.
+        struct ArenaOptions
+        {
+            // This defines the size of the first block requested from the system malloc.
+            // Subsequent block sizes will increase in a geometric series up to a maximum.
+            size_t start_block_size;
+
+            // This defines the maximum block size requested from system malloc (unless an
+            // individual arena allocation request occurs with a size larger than this
+            // maximum). Requested block sizes increase up to this value, then remain
+            // here.
+            size_t max_block_size;
+
+            // An initial block of memory for the arena to use, or NULL for none. If
+            // provided, the block must live at least as long as the arena itself. The
+            // creator of the Arena retains ownership of the block after the Arena is
+            // destroyed.
+            char* initial_block;
+
+            // The size of the initial block, if provided.
+            size_t initial_block_size;
+
+            // A function pointer to an alloc method that returns memory blocks of size
+            // requested. By default, it contains a ptr to the malloc function.
+            //
+            // NOTE: block_alloc and dealloc functions are expected to behave like
+            // malloc and free, including Asan poisoning.
+            void* (*block_alloc)(size_t);
+            // A function pointer to a dealloc method that takes ownership of the blocks
+            // from the arena. By default, it contains a ptr to a wrapper function that
+            // calls free.
+            void (*block_dealloc)(void*, size_t);
+
+            ArenaOptions() :
+                start_block_size(internal::AllocationPolicy::kDefaultStartBlockSize),
+                max_block_size(internal::AllocationPolicy::kDefaultMaxBlockSize),
+                initial_block(NULL),
+                initial_block_size(0),
+                block_alloc(nullptr),
+                block_dealloc(nullptr),
+                make_metrics_collector(nullptr)
+            {
+            }
+
+        private:
+            // If make_metrics_collector is not nullptr, it will be called at Arena init
+            // time. It may return a pointer to a collector instance that will be notified
+            // of interesting events related to the arena.
+            internal::ArenaMetricsCollector* (*make_metrics_collector)();
+
+            internal::ArenaMetricsCollector* MetricsCollector() const
+            {
+                return make_metrics_collector ? (*make_metrics_collector)() : nullptr;
+            }
+
+            internal::AllocationPolicy AllocationPolicy() const
+            {
+                internal::AllocationPolicy res;
+                res.start_block_size = start_block_size;
+                res.max_block_size = max_block_size;
+                res.block_alloc = block_alloc;
+                res.block_dealloc = block_dealloc;
+                res.metrics_collector = MetricsCollector();
+                return res;
+            }
+
+            friend void arena_metrics::EnableArenaMetrics(ArenaOptions*);
+
+            friend class Arena;
+            friend class ArenaOptionsTestFriend;
+        };
 
 // Support for non-RTTI environments. (The metrics hooks API uses type
 // information.)
@@ -194,656 +209,752 @@ struct ArenaOptions {
 #define RTTI_TYPE_ID(type) (NULL)
 #endif
 
-// Arena allocator. Arena allocation replaces ordinary (heap-based) allocation
-// with new/delete, and improves performance by aggregating allocations into
-// larger blocks and freeing allocations all at once. Protocol messages are
-// allocated on an arena by using Arena::CreateMessage<T>(Arena*), below, and
-// are automatically freed when the arena is destroyed.
-//
-// This is a thread-safe implementation: multiple threads may allocate from the
-// arena concurrently. Destruction is not thread-safe and the destructing
-// thread must synchronize with users of the arena first.
-//
-// An arena provides two allocation interfaces: CreateMessage<T>, which works
-// for arena-enabled proto2 message types as well as other types that satisfy
-// the appropriate protocol (described below), and Create<T>, which works for
-// any arbitrary type T. CreateMessage<T> is better when the type T supports it,
-// because this interface (i) passes the arena pointer to the created object so
-// that its sub-objects and internal allocations can use the arena too, and (ii)
-// elides the object's destructor call when possible. Create<T> does not place
-// any special requirements on the type T, and will invoke the object's
-// destructor when the arena is destroyed.
-//
-// The arena message allocation protocol, required by
-// CreateMessage<T>(Arena* arena, Args&&... args), is as follows:
-//
-// - The type T must have (at least) two constructors: a constructor callable
-//   with `args` (without `arena`), called when a T is allocated on the heap;
-//   and a constructor callable with `Arena* arena, Args&&... args`, called when
-//   a T is allocated on an arena. If the second constructor is called with a
-//   NULL arena pointer, it must be equivalent to invoking the first
-//   (`args`-only) constructor.
-//
-// - The type T must have a particular type trait: a nested type
-//   |InternalArenaConstructable_|. This is usually a typedef to |void|. If no
-//   such type trait exists, then the instantiation CreateMessage<T> will fail
-//   to compile.
-//
-// - The type T *may* have the type trait |DestructorSkippable_|. If this type
-//   trait is present in the type, then its destructor will not be called if and
-//   only if it was passed a non-NULL arena pointer. If this type trait is not
-//   present on the type, then its destructor is always called when the
-//   containing arena is destroyed.
-//
-// This protocol is implemented by all arena-enabled proto2 message classes as
-// well as protobuf container types like RepeatedPtrField and Map. The protocol
-// is internal to protobuf and is not guaranteed to be stable. Non-proto types
-// should not rely on this protocol.
-class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final {
- public:
-  // Default constructor with sensible default options, tuned for average
-  // use-cases.
-  inline Arena() : impl_() {}
-
-  // Construct an arena with default options, except for the supplied
-  // initial block. It is more efficient to use this constructor
-  // instead of passing ArenaOptions if the only configuration needed
-  // by the caller is supplying an initial block.
-  inline Arena(char* initial_block, size_t initial_block_size)
-      : impl_(initial_block, initial_block_size) {}
-
-  // Arena constructor taking custom options. See ArenaOptions above for
-  // descriptions of the options available.
-  explicit Arena(const ArenaOptions& options)
-      : impl_(options.initial_block, options.initial_block_size,
-              options.AllocationPolicy()) {}
-
-  // Block overhead.  Use this as a guide for how much to over-allocate the
-  // initial block if you want an allocation of size N to fit inside it.
-  //
-  // WARNING: if you allocate multiple objects, it is difficult to guarantee
-  // that a series of allocations will fit in the initial block, especially if
-  // Arena changes its alignment guarantees in the future!
-  static const size_t kBlockOverhead =
-      internal::ThreadSafeArena::kBlockHeaderSize +
-      internal::ThreadSafeArena::kSerialArenaSize;
-
-  inline ~Arena() {}
-
-  // TODO(protobuf-team): Fix callers to use constructor and delete this method.
-  void Init(const ArenaOptions&) {}
-
-  // API to create proto2 message objects on the arena. If the arena passed in
-  // is NULL, then a heap allocated object is returned. Type T must be a message
-  // defined in a .proto file with cc_enable_arenas set to true, otherwise a
-  // compilation error will occur.
-  //
-  // RepeatedField and RepeatedPtrField may also be instantiated directly on an
-  // arena with this method.
-  //
-  // This function also accepts any type T that satisfies the arena message
-  // allocation protocol, documented above.
-  template <typename T, typename... Args>
-  PROTOBUF_ALWAYS_INLINE static T* CreateMessage(Arena* arena, Args&&... args) {
-    static_assert(
-        InternalHelper<T>::is_arena_constructable::value,
-        "CreateMessage can only construct types that are ArenaConstructable");
-    // We must delegate to CreateMaybeMessage() and NOT CreateMessageInternal()
-    // because protobuf generated classes specialize CreateMaybeMessage() and we
-    // need to use that specialization for code size reasons.
-    return Arena::CreateMaybeMessage<T>(arena, static_cast<Args&&>(args)...);
-  }
-
-  // API to create any objects on the arena. Note that only the object will
-  // be created on the arena; the underlying ptrs (in case of a proto2 message)
-  // will be still heap allocated. Proto messages should usually be allocated
-  // with CreateMessage<T>() instead.
-  //
-  // Note that even if T satisfies the arena message construction protocol
-  // (InternalArenaConstructable_ trait and optional DestructorSkippable_
-  // trait), as described above, this function does not follow the protocol;
-  // instead, it treats T as a black-box type, just as if it did not have these
-  // traits. Specifically, T's constructor arguments will always be only those
-  // passed to Create<T>() -- no additional arena pointer is implicitly added.
-  // Furthermore, the destructor will always be called at arena destruction time
-  // (unless the destructor is trivial). Hence, from T's point of view, it is as
-  // if the object were allocated on the heap (except that the underlying memory
-  // is obtained from the arena).
-  template <typename T, typename... Args>
-  PROTOBUF_NDEBUG_INLINE static T* Create(Arena* arena, Args&&... args) {
-    return CreateInternal<T>(arena, std::is_convertible<T*, MessageLite*>(),
-                             static_cast<Args&&>(args)...);
-  }
-
-  // Allocates memory with the specific size and alignment.
-  void* AllocateAligned(size_t size, size_t align = 8) {
-    if (align <= 8) {
-      return AllocateAlignedNoHook(internal::AlignUpTo8(size));
-    } else {
-      // We are wasting space by over allocating align - 8 bytes. Compared
-      // to a dedicated function that takes current alignment in consideration.
-      // Such a scheme would only waste (align - 8)/2 bytes on average, but
-      // requires a dedicated function in the outline arena allocation
-      // functions. Possibly re-evaluate tradeoffs later.
-      return internal::AlignTo(AllocateAlignedNoHook(size + align - 8), align);
-    }
-  }
-
-  // Create an array of object type T on the arena *without* invoking the
-  // constructor of T. If `arena` is null, then the return value should be freed
-  // with `delete[] x;` (or `::operator delete[](x);`).
-  // To ensure safe uses, this function checks at compile time
-  // (when compiled as C++11) that T is trivially default-constructible and
-  // trivially destructible.
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE static T* CreateArray(Arena* arena,
-                                               size_t num_elements) {
-    static_assert(std::is_trivial<T>::value,
-                  "CreateArray requires a trivially constructible type");
-    static_assert(std::is_trivially_destructible<T>::value,
-                  "CreateArray requires a trivially destructible type");
-    GOOGLE_CHECK_LE(num_elements, std::numeric_limits<size_t>::max() / sizeof(T))
-        << "Requested size is too large to fit into size_t.";
-    if (arena == NULL) {
-      return static_cast<T*>(::operator new[](num_elements * sizeof(T)));
-    } else {
-      return arena->CreateInternalRawArray<T>(num_elements);
-    }
-  }
-
-  // The following are routines are for monitoring. They will approximate the
-  // total sum allocated and used memory, but the exact value is an
-  // implementation deal. For instance allocated space depends on growth
-  // policies. Do not use these in unit tests.
-  // Returns the total space allocated by the arena, which is the sum of the
-  // sizes of the underlying blocks.
-  uint64_t SpaceAllocated() const { return impl_.SpaceAllocated(); }
-  // Returns the total space used by the arena. Similar to SpaceAllocated but
-  // does not include free space and block overhead. The total space returned
-  // may not include space used by other threads executing concurrently with
-  // the call to this method.
-  uint64_t SpaceUsed() const { return impl_.SpaceUsed(); }
-
-  // Frees all storage allocated by this arena after calling destructors
-  // registered with OwnDestructor() and freeing objects registered with Own().
-  // Any objects allocated on this arena are unusable after this call. It also
-  // returns the total space used by the arena which is the sums of the sizes
-  // of the allocated blocks. This method is not thread-safe.
-  uint64_t Reset() { return impl_.Reset(); }
-
-  // Adds |object| to a list of heap-allocated objects to be freed with |delete|
-  // when the arena is destroyed or reset.
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE void Own(T* object) {
-    OwnInternal(object, std::is_convertible<T*, MessageLite*>());
-  }
-
-  // Adds |object| to a list of objects whose destructors will be manually
-  // called when the arena is destroyed or reset. This differs from Own() in
-  // that it does not free the underlying memory with |delete|; hence, it is
-  // normally only used for objects that are placement-newed into
-  // arena-allocated memory.
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE void OwnDestructor(T* object) {
-    if (object != NULL) {
-      impl_.AddCleanup(object, &internal::arena_destruct_object<T>);
-    }
-  }
-
-  // Adds a custom member function on an object to the list of destructors that
-  // will be manually called when the arena is destroyed or reset. This differs
-  // from OwnDestructor() in that any member function may be specified, not only
-  // the class destructor.
-  PROTOBUF_ALWAYS_INLINE void OwnCustomDestructor(void* object,
-                                                  void (*destruct)(void*)) {
-    impl_.AddCleanup(object, destruct);
-  }
-
-  // Retrieves the arena associated with |value| if |value| is an arena-capable
-  // message, or NULL otherwise. If possible, the call resolves at compile time.
-  // Note that we can often devirtualize calls to `value->GetArena()` so usually
-  // calling this method is unnecessary.
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE static Arena* GetArena(const T* value) {
-    return GetArenaInternal(value);
-  }
-
-  template <typename T>
-  class InternalHelper {
-   private:
-    // Provides access to protected GetOwningArena to generated messages.
-    static Arena* GetOwningArena(const T* p) { return p->GetOwningArena(); }
-
-    static void InternalSwap(T* a, T* b) { a->InternalSwap(b); }
-
-    static Arena* GetArenaForAllocationInternal(
-        const T* p, std::true_type /*is_derived_from<MessageLite>*/) {
-      return p->GetArenaForAllocation();
-    }
-
-    static Arena* GetArenaForAllocationInternal(
-        const T* p, std::false_type /*is_derived_from<MessageLite>*/) {
-      return GetArenaForAllocationForNonMessage(
-          p, typename is_arena_constructable::type());
-    }
-
-    static Arena* GetArenaForAllocationForNonMessage(
-        const T* p, std::true_type /*is_arena_constructible*/) {
-      return p->GetArena();
-    }
-
-    static Arena* GetArenaForAllocationForNonMessage(
-        const T* p, std::false_type /*is_arena_constructible*/) {
-      return GetArenaForAllocationForNonMessageNonArenaConstructible(
-          p, typename has_get_arena::type());
-    }
-
-    static Arena* GetArenaForAllocationForNonMessageNonArenaConstructible(
-        const T* p, std::true_type /*has_get_arena*/) {
-      return p->GetArena();
-    }
-
-    static Arena* GetArenaForAllocationForNonMessageNonArenaConstructible(
-        const T* /* p */, std::false_type /*has_get_arena*/) {
-      return nullptr;
-    }
-
-    template <typename U>
-    static char DestructorSkippable(const typename U::DestructorSkippable_*);
-    template <typename U>
-    static double DestructorSkippable(...);
-
-    typedef std::integral_constant<
-        bool, sizeof(DestructorSkippable<T>(static_cast<const T*>(0))) ==
-                      sizeof(char) ||
-                  std::is_trivially_destructible<T>::value>
-        is_destructor_skippable;
-
-    template <typename U>
-    static char ArenaConstructable(
-        const typename U::InternalArenaConstructable_*);
-    template <typename U>
-    static double ArenaConstructable(...);
-
-    typedef std::integral_constant<bool, sizeof(ArenaConstructable<T>(
-                                             static_cast<const T*>(0))) ==
-                                             sizeof(char)>
-        is_arena_constructable;
-
-    template <typename U,
-              typename std::enable_if<
-                  std::is_same<Arena*, decltype(std::declval<const U>()
-                                                    .GetArena())>::value,
-                  int>::type = 0>
-    static char HasGetArena(decltype(&U::GetArena));
-    template <typename U>
-    static double HasGetArena(...);
-
-    typedef std::integral_constant<bool, sizeof(HasGetArena<T>(nullptr)) ==
-                                             sizeof(char)>
-        has_get_arena;
-
-    template <typename... Args>
-    static T* Construct(void* ptr, Args&&... args) {
-      return new (ptr) T(static_cast<Args&&>(args)...);
-    }
-
-    static inline PROTOBUF_ALWAYS_INLINE T* New() {
-      return new T(nullptr);
-    }
-
-    static Arena* GetArena(const T* p) { return p->GetArena(); }
-
-    friend class Arena;
-    friend class TestUtil::ReflectionTester;
-  };
-
-  // Provides access to protected GetOwningArena to generated messages.  For
-  // internal use only.
-  template <typename T>
-  static Arena* InternalGetOwningArena(const T* p) {
-    return InternalHelper<T>::GetOwningArena(p);
-  }
-
-  // Provides access to protected GetArenaForAllocation to generated messages.
-  // For internal use only.
-  template <typename T>
-  static Arena* InternalGetArenaForAllocation(const T* p) {
-    return InternalHelper<T>::GetArenaForAllocationInternal(
-        p, std::is_convertible<T*, MessageLite*>());
-  }
-
-  // Creates message-owned arena.  For internal use only.
-  static Arena* InternalCreateMessageOwnedArena() {
-    return new Arena(internal::MessageOwned{});
-  }
-
-  // Checks whether this arena is message-owned.  For internal use only.
-  bool InternalIsMessageOwnedArena() { return IsMessageOwned(); }
-
-  // Helper typetraits that indicates support for arenas in a type T at compile
-  // time. This is public only to allow construction of higher-level templated
-  // utilities.
-  //
-  // is_arena_constructable<T>::value is true if the message type T has arena
-  // support enabled, and false otherwise.
-  //
-  // is_destructor_skippable<T>::value is true if the message type T has told
-  // the arena that it is safe to skip the destructor, and false otherwise.
-  //
-  // This is inside Arena because only Arena has the friend relationships
-  // necessary to see the underlying generated code traits.
-  template <typename T>
-  struct is_arena_constructable : InternalHelper<T>::is_arena_constructable {};
-  template <typename T>
-  struct is_destructor_skippable : InternalHelper<T>::is_destructor_skippable {
-  };
-
- private:
-  internal::ThreadSafeArena impl_;
-
-  template <typename T>
-  struct has_get_arena : InternalHelper<T>::has_get_arena {};
-
-  // Constructor solely used by message-owned arena.
-  inline Arena(internal::MessageOwned) : impl_(internal::MessageOwned{}) {}
-
-  // Checks whether this arena is message-owned.
-  PROTOBUF_ALWAYS_INLINE bool IsMessageOwned() const {
-    return impl_.IsMessageOwned();
-  }
-
-  void ReturnArrayMemory(void* p, size_t size) {
-    impl_.ReturnArrayMemory(p, size);
-  }
-
-  template <typename T, typename... Args>
-  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena,
-                                                         Args&&... args) {
-    static_assert(
-        InternalHelper<T>::is_arena_constructable::value,
-        "CreateMessage can only construct types that are ArenaConstructable");
-    if (arena == NULL) {
-      return new T(nullptr, static_cast<Args&&>(args)...);
-    } else {
-      return arena->DoCreateMessage<T>(static_cast<Args&&>(args)...);
-    }
-  }
-
-  // This specialization for no arguments is necessary, because its behavior is
-  // slightly different.  When the arena pointer is nullptr, it calls T()
-  // instead of T(nullptr).
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
-    static_assert(
-        InternalHelper<T>::is_arena_constructable::value,
-        "CreateMessage can only construct types that are ArenaConstructable");
-    if (arena == NULL) {
-      // Generated arena constructor T(Arena*) is protected. Call via
-      // InternalHelper.
-      return InternalHelper<T>::New();
-    } else {
-      return arena->DoCreateMessage<T>();
-    }
-  }
-
-  // Allocate and also optionally call collector with the allocated type info
-  // when allocation recording is enabled.
-  PROTOBUF_NDEBUG_INLINE void* AllocateInternal(size_t size, size_t align,
-                                                void (*destructor)(void*),
-                                                const std::type_info* type) {
-    // Monitor allocation if needed.
-    if (destructor == nullptr) {
-      return AllocateAlignedWithHook(size, align, type);
-    } else {
-      if (align <= 8) {
-        auto res = AllocateAlignedWithCleanup(internal::AlignUpTo8(size), type);
-        res.second->elem = res.first;
-        res.second->cleanup = destructor;
-        return res.first;
-      } else {
-        auto res = AllocateAlignedWithCleanup(size + align - 8, type);
-        auto ptr = internal::AlignTo(res.first, align);
-        res.second->elem = ptr;
-        res.second->cleanup = destructor;
-        return ptr;
-      }
-    }
-  }
-
-  // CreateMessage<T> requires that T supports arenas, but this private method
-  // works whether or not T supports arenas. These are not exposed to user code
-  // as it can cause confusing API usages, and end up having double free in
-  // user code. These are used only internally from LazyField and Repeated
-  // fields, since they are designed to work in all mode combinations.
-  template <typename Msg, typename... Args>
-  PROTOBUF_ALWAYS_INLINE static Msg* DoCreateMaybeMessage(Arena* arena,
-                                                          std::true_type,
-                                                          Args&&... args) {
-    return CreateMessageInternal<Msg>(arena, std::forward<Args>(args)...);
-  }
-
-  template <typename T, typename... Args>
-  PROTOBUF_ALWAYS_INLINE static T* DoCreateMaybeMessage(Arena* arena,
-                                                        std::false_type,
-                                                        Args&&... args) {
-    return Create<T>(arena, std::forward<Args>(args)...);
-  }
-
-  template <typename T, typename... Args>
-  PROTOBUF_ALWAYS_INLINE static T* CreateMaybeMessage(Arena* arena,
-                                                      Args&&... args) {
-    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
-                                   std::forward<Args>(args)...);
-  }
-
-  // Just allocate the required size for the given type assuming the
-  // type has a trivial constructor.
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE T* CreateInternalRawArray(size_t num_elements) {
-    GOOGLE_CHECK_LE(num_elements, std::numeric_limits<size_t>::max() / sizeof(T))
-        << "Requested size is too large to fit into size_t.";
-    // We count on compiler to realize that if sizeof(T) is a multiple of
-    // 8 AlignUpTo can be elided.
-    const size_t n = sizeof(T) * num_elements;
-    return static_cast<T*>(
-        AllocateAlignedWithHookForArray(n, alignof(T), RTTI_TYPE_ID(T)));
-  }
-
-  template <typename T, typename... Args>
-  PROTOBUF_NDEBUG_INLINE T* DoCreateMessage(Args&&... args) {
-    return InternalHelper<T>::Construct(
-        AllocateInternal(sizeof(T), alignof(T),
-                         internal::ObjectDestructor<
-                             InternalHelper<T>::is_destructor_skippable::value,
-                             T>::destructor,
-                         RTTI_TYPE_ID(T)),
-        this, std::forward<Args>(args)...);
-  }
-
-  // CreateInArenaStorage is used to implement map field. Without it,
-  // Map need to call generated message's protected arena constructor,
-  // which needs to declare Map as friend of generated message.
-  template <typename T, typename... Args>
-  static void CreateInArenaStorage(T* ptr, Arena* arena, Args&&... args) {
-    CreateInArenaStorageInternal(ptr, arena,
-                                 typename is_arena_constructable<T>::type(),
-                                 std::forward<Args>(args)...);
-    if (arena != nullptr) {
-      RegisterDestructorInternal(
-          ptr, arena,
-          typename InternalHelper<T>::is_destructor_skippable::type());
-    }
-  }
-
-  template <typename T, typename... Args>
-  static void CreateInArenaStorageInternal(T* ptr, Arena* arena,
-                                           std::true_type, Args&&... args) {
-    InternalHelper<T>::Construct(ptr, arena, std::forward<Args>(args)...);
-  }
-  template <typename T, typename... Args>
-  static void CreateInArenaStorageInternal(T* ptr, Arena* /* arena */,
-                                           std::false_type, Args&&... args) {
-    new (ptr) T(std::forward<Args>(args)...);
-  }
-
-  template <typename T>
-  static void RegisterDestructorInternal(T* /* ptr */, Arena* /* arena */,
-                                         std::true_type) {}
-  template <typename T>
-  static void RegisterDestructorInternal(T* ptr, Arena* arena,
-                                         std::false_type) {
-    arena->OwnDestructor(ptr);
-  }
-
-  // These implement Create(). The second parameter has type 'true_type' if T is
-  // a subtype of Message and 'false_type' otherwise.
-  template <typename T, typename... Args>
-  PROTOBUF_ALWAYS_INLINE static T* CreateInternal(Arena* arena, std::true_type,
-                                                  Args&&... args) {
-    if (arena == nullptr) {
-      return new T(std::forward<Args>(args)...);
-    } else {
-      auto destructor =
-          internal::ObjectDestructor<std::is_trivially_destructible<T>::value,
-                                     T>::destructor;
-      T* result =
-          new (arena->AllocateInternal(sizeof(T), alignof(T), destructor,
-                                       RTTI_TYPE_ID(T)))
-          T(std::forward<Args>(args)...);
-      return result;
-    }
-  }
-  template <typename T, typename... Args>
-  PROTOBUF_ALWAYS_INLINE static T* CreateInternal(Arena* arena, std::false_type,
-                                                  Args&&... args) {
-    if (arena == nullptr) {
-      return new T(std::forward<Args>(args)...);
-    } else {
-      auto destructor =
-          internal::ObjectDestructor<std::is_trivially_destructible<T>::value,
-                                     T>::destructor;
-      return new (arena->AllocateInternal(sizeof(T), alignof(T), destructor,
-                                          RTTI_TYPE_ID(T)))
-          T(std::forward<Args>(args)...);
-    }
-  }
-
-  // These implement Own(), which registers an object for deletion (destructor
-  // call and operator delete()). The second parameter has type 'true_type' if T
-  // is a subtype of Message and 'false_type' otherwise. Collapsing
-  // all template instantiations to one for generic Message reduces code size,
-  // using the virtual destructor instead.
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE void OwnInternal(T* object, std::true_type) {
-    if (object != NULL) {
-      impl_.AddCleanup(object, &internal::arena_delete_object<MessageLite>);
-    }
-  }
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE void OwnInternal(T* object, std::false_type) {
-    if (object != NULL) {
-      impl_.AddCleanup(object, &internal::arena_delete_object<T>);
-    }
-  }
-
-  // Implementation for GetArena(). Only message objects with
-  // InternalArenaConstructable_ tags can be associated with an arena, and such
-  // objects must implement a GetArena() method.
-  template <typename T, typename std::enable_if<
-                            is_arena_constructable<T>::value, int>::type = 0>
-  PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) {
-    return InternalHelper<T>::GetArena(value);
-  }
-  template <typename T,
-            typename std::enable_if<!is_arena_constructable<T>::value &&
-                                        has_get_arena<T>::value,
-                                    int>::type = 0>
-  PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) {
-    return value->GetArena();
-  }
-  template <typename T,
-            typename std::enable_if<!is_arena_constructable<T>::value &&
-                                        !has_get_arena<T>::value,
-                                    int>::type = 0>
-  PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) {
-    (void)value;
-    return nullptr;
-  }
-
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArena(const T* value) {
-    return GetOwningArenaInternal(
-        value, std::is_convertible<T*, MessageLite*>());
-  }
-
-  // Implementation for GetOwningArena(). All and only message objects have
-  // GetOwningArena() method.
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArenaInternal(
-      const T* value, std::true_type) {
-    return InternalHelper<T>::GetOwningArena(value);
-  }
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArenaInternal(
-      const T* /* value */, std::false_type) {
-    return nullptr;
-  }
-
-  void* AllocateAlignedWithHookForArray(size_t n, size_t align,
-                                        const std::type_info* type) {
-    if (align <= 8) {
-      return AllocateAlignedWithHookForArray(internal::AlignUpTo8(n), type);
-    } else {
-      // We are wasting space by over allocating align - 8 bytes. Compared
-      // to a dedicated function that takes current alignment in consideration.
-      // Such a scheme would only waste (align - 8)/2 bytes on average, but
-      // requires a dedicated function in the outline arena allocation
-      // functions. Possibly re-evaluate tradeoffs later.
-      return internal::AlignTo(
-          AllocateAlignedWithHookForArray(n + align - 8, type), align);
-    }
-  }
-
-  void* AllocateAlignedWithHook(size_t n, size_t align,
-                                const std::type_info* type) {
-    if (align <= 8) {
-      return AllocateAlignedWithHook(internal::AlignUpTo8(n), type);
-    } else {
-      // We are wasting space by over allocating align - 8 bytes. Compared
-      // to a dedicated function that takes current alignment in consideration.
-      // Such a scheme would only waste (align - 8)/2 bytes on average, but
-      // requires a dedicated function in the outline arena allocation
-      // functions. Possibly re-evaluate tradeoffs later.
-      return internal::AlignTo(AllocateAlignedWithHook(n + align - 8, type),
-                               align);
-    }
-  }
-
-  void* AllocateAlignedNoHook(size_t n);
-  void* AllocateAlignedWithHook(size_t n, const std::type_info* type);
-  void* AllocateAlignedWithHookForArray(size_t n, const std::type_info* type);
-  std::pair<void*, internal::SerialArena::CleanupNode*>
-  AllocateAlignedWithCleanup(size_t n, const std::type_info* type);
-
-  template <typename Type>
-  friend class internal::GenericTypeHandler;
-  friend class internal::InternalMetadata;  // For user_arena().
-  friend class internal::LazyField;        // For CreateMaybeMessage.
-  friend class internal::EpsCopyInputStream;  // For parser performance
-  friend class MessageLite;
-  template <typename Key, typename T>
-  friend class Map;
-  template <typename>
-  friend class RepeatedField;                   // For ReturnArrayMemory
-  friend class internal::RepeatedPtrFieldBase;  // For ReturnArrayMemory
-  friend struct internal::ArenaTestPeer;
-};
+        // Arena allocator. Arena allocation replaces ordinary (heap-based) allocation
+        // with new/delete, and improves performance by aggregating allocations into
+        // larger blocks and freeing allocations all at once. Protocol messages are
+        // allocated on an arena by using Arena::CreateMessage<T>(Arena*), below, and
+        // are automatically freed when the arena is destroyed.
+        //
+        // This is a thread-safe implementation: multiple threads may allocate from the
+        // arena concurrently. Destruction is not thread-safe and the destructing
+        // thread must synchronize with users of the arena first.
+        //
+        // An arena provides two allocation interfaces: CreateMessage<T>, which works
+        // for arena-enabled proto2 message types as well as other types that satisfy
+        // the appropriate protocol (described below), and Create<T>, which works for
+        // any arbitrary type T. CreateMessage<T> is better when the type T supports it,
+        // because this interface (i) passes the arena pointer to the created object so
+        // that its sub-objects and internal allocations can use the arena too, and (ii)
+        // elides the object's destructor call when possible. Create<T> does not place
+        // any special requirements on the type T, and will invoke the object's
+        // destructor when the arena is destroyed.
+        //
+        // The arena message allocation protocol, required by
+        // CreateMessage<T>(Arena* arena, Args&&... args), is as follows:
+        //
+        // - The type T must have (at least) two constructors: a constructor callable
+        //   with `args` (without `arena`), called when a T is allocated on the heap;
+        //   and a constructor callable with `Arena* arena, Args&&... args`, called when
+        //   a T is allocated on an arena. If the second constructor is called with a
+        //   NULL arena pointer, it must be equivalent to invoking the first
+        //   (`args`-only) constructor.
+        //
+        // - The type T must have a particular type trait: a nested type
+        //   |InternalArenaConstructable_|. This is usually a typedef to |void|. If no
+        //   such type trait exists, then the instantiation CreateMessage<T> will fail
+        //   to compile.
+        //
+        // - The type T *may* have the type trait |DestructorSkippable_|. If this type
+        //   trait is present in the type, then its destructor will not be called if and
+        //   only if it was passed a non-NULL arena pointer. If this type trait is not
+        //   present on the type, then its destructor is always called when the
+        //   containing arena is destroyed.
+        //
+        // This protocol is implemented by all arena-enabled proto2 message classes as
+        // well as protobuf container types like RepeatedPtrField and Map. The protocol
+        // is internal to protobuf and is not guaranteed to be stable. Non-proto types
+        // should not rely on this protocol.
+        class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final
+        {
+        public:
+            // Default constructor with sensible default options, tuned for average
+            // use-cases.
+            inline Arena() :
+                impl_()
+            {
+            }
+
+            // Construct an arena with default options, except for the supplied
+            // initial block. It is more efficient to use this constructor
+            // instead of passing ArenaOptions if the only configuration needed
+            // by the caller is supplying an initial block.
+            inline Arena(char* initial_block, size_t initial_block_size) :
+                impl_(initial_block, initial_block_size)
+            {
+            }
+
+            // Arena constructor taking custom options. See ArenaOptions above for
+            // descriptions of the options available.
+            explicit Arena(const ArenaOptions& options) :
+                impl_(options.initial_block, options.initial_block_size, options.AllocationPolicy())
+            {
+            }
+
+            // Block overhead.  Use this as a guide for how much to over-allocate the
+            // initial block if you want an allocation of size N to fit inside it.
+            //
+            // WARNING: if you allocate multiple objects, it is difficult to guarantee
+            // that a series of allocations will fit in the initial block, especially if
+            // Arena changes its alignment guarantees in the future!
+            static const size_t kBlockOverhead =
+                internal::ThreadSafeArena::kBlockHeaderSize +
+                internal::ThreadSafeArena::kSerialArenaSize;
+
+            inline ~Arena()
+            {
+            }
+
+            // TODO(protobuf-team): Fix callers to use constructor and delete this method.
+            void Init(const ArenaOptions&)
+            {
+            }
+
+            // API to create proto2 message objects on the arena. If the arena passed in
+            // is NULL, then a heap allocated object is returned. Type T must be a message
+            // defined in a .proto file with cc_enable_arenas set to true, otherwise a
+            // compilation error will occur.
+            //
+            // RepeatedField and RepeatedPtrField may also be instantiated directly on an
+            // arena with this method.
+            //
+            // This function also accepts any type T that satisfies the arena message
+            // allocation protocol, documented above.
+            template<typename T, typename... Args>
+            PROTOBUF_ALWAYS_INLINE static T* CreateMessage(Arena* arena, Args&&... args)
+            {
+                static_assert(
+                    InternalHelper<T>::is_arena_constructable::value,
+                    "CreateMessage can only construct types that are ArenaConstructable"
+                );
+                // We must delegate to CreateMaybeMessage() and NOT CreateMessageInternal()
+                // because protobuf generated classes specialize CreateMaybeMessage() and we
+                // need to use that specialization for code size reasons.
+                return Arena::CreateMaybeMessage<T>(arena, static_cast<Args&&>(args)...);
+            }
+
+            // API to create any objects on the arena. Note that only the object will
+            // be created on the arena; the underlying ptrs (in case of a proto2 message)
+            // will be still heap allocated. Proto messages should usually be allocated
+            // with CreateMessage<T>() instead.
+            //
+            // Note that even if T satisfies the arena message construction protocol
+            // (InternalArenaConstructable_ trait and optional DestructorSkippable_
+            // trait), as described above, this function does not follow the protocol;
+            // instead, it treats T as a black-box type, just as if it did not have these
+            // traits. Specifically, T's constructor arguments will always be only those
+            // passed to Create<T>() -- no additional arena pointer is implicitly added.
+            // Furthermore, the destructor will always be called at arena destruction time
+            // (unless the destructor is trivial). Hence, from T's point of view, it is as
+            // if the object were allocated on the heap (except that the underlying memory
+            // is obtained from the arena).
+            template<typename T, typename... Args>
+            PROTOBUF_NDEBUG_INLINE static T* Create(Arena* arena, Args&&... args)
+            {
+                return CreateInternal<T>(arena, std::is_convertible<T*, MessageLite*>(), static_cast<Args&&>(args)...);
+            }
+
+            // Allocates memory with the specific size and alignment.
+            void* AllocateAligned(size_t size, size_t align = 8)
+            {
+                if (align <= 8)
+                {
+                    return AllocateAlignedNoHook(internal::AlignUpTo8(size));
+                }
+                else
+                {
+                    // We are wasting space by over allocating align - 8 bytes. Compared
+                    // to a dedicated function that takes current alignment in consideration.
+                    // Such a scheme would only waste (align - 8)/2 bytes on average, but
+                    // requires a dedicated function in the outline arena allocation
+                    // functions. Possibly re-evaluate tradeoffs later.
+                    return internal::AlignTo(AllocateAlignedNoHook(size + align - 8), align);
+                }
+            }
+
+            // Create an array of object type T on the arena *without* invoking the
+            // constructor of T. If `arena` is null, then the return value should be freed
+            // with `delete[] x;` (or `::operator delete[](x);`).
+            // To ensure safe uses, this function checks at compile time
+            // (when compiled as C++11) that T is trivially default-constructible and
+            // trivially destructible.
+            template<typename T>
+            PROTOBUF_NDEBUG_INLINE static T* CreateArray(Arena* arena, size_t num_elements)
+            {
+                static_assert(std::is_trivial<T>::value, "CreateArray requires a trivially constructible type");
+                static_assert(std::is_trivially_destructible<T>::value, "CreateArray requires a trivially destructible type");
+                GOOGLE_CHECK_LE(num_elements, std::numeric_limits<size_t>::max() / sizeof(T))
+                    << "Requested size is too large to fit into size_t.";
+                if (arena == NULL)
+                {
+                    return static_cast<T*>(::operator new[](num_elements * sizeof(T)));
+                }
+                else
+                {
+                    return arena->CreateInternalRawArray<T>(num_elements);
+                }
+            }
+
+            // The following are routines are for monitoring. They will approximate the
+            // total sum allocated and used memory, but the exact value is an
+            // implementation deal. For instance allocated space depends on growth
+            // policies. Do not use these in unit tests.
+            // Returns the total space allocated by the arena, which is the sum of the
+            // sizes of the underlying blocks.
+            uint64_t SpaceAllocated() const
+            {
+                return impl_.SpaceAllocated();
+            }
+            // Returns the total space used by the arena. Similar to SpaceAllocated but
+            // does not include free space and block overhead. The total space returned
+            // may not include space used by other threads executing concurrently with
+            // the call to this method.
+            uint64_t SpaceUsed() const
+            {
+                return impl_.SpaceUsed();
+            }
+
+            // Frees all storage allocated by this arena after calling destructors
+            // registered with OwnDestructor() and freeing objects registered with Own().
+            // Any objects allocated on this arena are unusable after this call. It also
+            // returns the total space used by the arena which is the sums of the sizes
+            // of the allocated blocks. This method is not thread-safe.
+            uint64_t Reset()
+            {
+                return impl_.Reset();
+            }
+
+            // Adds |object| to a list of heap-allocated objects to be freed with |delete|
+            // when the arena is destroyed or reset.
+            template<typename T>
+            PROTOBUF_ALWAYS_INLINE void Own(T* object)
+            {
+                OwnInternal(object, std::is_convertible<T*, MessageLite*>());
+            }
+
+            // Adds |object| to a list of objects whose destructors will be manually
+            // called when the arena is destroyed or reset. This differs from Own() in
+            // that it does not free the underlying memory with |delete|; hence, it is
+            // normally only used for objects that are placement-newed into
+            // arena-allocated memory.
+            template<typename T>
+            PROTOBUF_ALWAYS_INLINE void OwnDestructor(T* object)
+            {
+                if (object != NULL)
+                {
+                    impl_.AddCleanup(object, &internal::arena_destruct_object<T>);
+                }
+            }
+
+            // Adds a custom member function on an object to the list of destructors that
+            // will be manually called when the arena is destroyed or reset. This differs
+            // from OwnDestructor() in that any member function may be specified, not only
+            // the class destructor.
+            PROTOBUF_ALWAYS_INLINE void OwnCustomDestructor(void* object, void (*destruct)(void*))
+            {
+                impl_.AddCleanup(object, destruct);
+            }
+
+            // Retrieves the arena associated with |value| if |value| is an arena-capable
+            // message, or NULL otherwise. If possible, the call resolves at compile time.
+            // Note that we can often devirtualize calls to `value->GetArena()` so usually
+            // calling this method is unnecessary.
+            template<typename T>
+            PROTOBUF_ALWAYS_INLINE static Arena* GetArena(const T* value)
+            {
+                return GetArenaInternal(value);
+            }
+
+            template<typename T>
+            class InternalHelper
+            {
+            private:
+                // Provides access to protected GetOwningArena to generated messages.
+                static Arena* GetOwningArena(const T* p)
+                {
+                    return p->GetOwningArena();
+                }
+
+                static void InternalSwap(T* a, T* b)
+                {
+                    a->InternalSwap(b);
+                }
+
+                static Arena* GetArenaForAllocationInternal(
+                    const T* p, std::true_type /*is_derived_from<MessageLite>*/
+                )
+                {
+                    return p->GetArenaForAllocation();
+                }
+
+                static Arena* GetArenaForAllocationInternal(
+                    const T* p, std::false_type /*is_derived_from<MessageLite>*/
+                )
+                {
+                    return GetArenaForAllocationForNonMessage(
+                        p, typename is_arena_constructable::type()
+                    );
+                }
+
+                static Arena* GetArenaForAllocationForNonMessage(
+                    const T* p, std::true_type /*is_arena_constructible*/
+                )
+                {
+                    return p->GetArena();
+                }
+
+                static Arena* GetArenaForAllocationForNonMessage(
+                    const T* p, std::false_type /*is_arena_constructible*/
+                )
+                {
+                    return GetArenaForAllocationForNonMessageNonArenaConstructible(
+                        p, typename has_get_arena::type()
+                    );
+                }
+
+                static Arena* GetArenaForAllocationForNonMessageNonArenaConstructible(
+                    const T* p, std::true_type /*has_get_arena*/
+                )
+                {
+                    return p->GetArena();
+                }
+
+                static Arena* GetArenaForAllocationForNonMessageNonArenaConstructible(
+                    const T* /* p */, std::false_type /*has_get_arena*/
+                )
+                {
+                    return nullptr;
+                }
+
+                template<typename U>
+                static char DestructorSkippable(const typename U::DestructorSkippable_*);
+                template<typename U>
+                static double DestructorSkippable(...);
+
+                typedef std::integral_constant<
+                    bool,
+                    sizeof(DestructorSkippable<T>(static_cast<const T*>(0))) ==
+                            sizeof(char) ||
+                        std::is_trivially_destructible<T>::value>
+                    is_destructor_skippable;
+
+                template<typename U>
+                static char ArenaConstructable(
+                    const typename U::InternalArenaConstructable_*
+                );
+                template<typename U>
+                static double ArenaConstructable(...);
+
+                typedef std::integral_constant<bool, sizeof(ArenaConstructable<T>(static_cast<const T*>(0))) == sizeof(char)>
+                    is_arena_constructable;
+
+                template<typename U, typename std::enable_if<std::is_same<Arena*, decltype(std::declval<const U>().GetArena())>::value, int>::type = 0>
+                static char HasGetArena(decltype(&U::GetArena));
+                template<typename U>
+                static double HasGetArena(...);
+
+                typedef std::integral_constant<bool, sizeof(HasGetArena<T>(nullptr)) == sizeof(char)>
+                    has_get_arena;
+
+                template<typename... Args>
+                static T* Construct(void* ptr, Args&&... args)
+                {
+                    return new (ptr) T(static_cast<Args&&>(args)...);
+                }
+
+                static inline PROTOBUF_ALWAYS_INLINE T* New()
+                {
+                    return new T(nullptr);
+                }
+
+                static Arena* GetArena(const T* p)
+                {
+                    return p->GetArena();
+                }
+
+                friend class Arena;
+                friend class TestUtil::ReflectionTester;
+            };
+
+            // Provides access to protected GetOwningArena to generated messages.  For
+            // internal use only.
+            template<typename T>
+            static Arena* InternalGetOwningArena(const T* p)
+            {
+                return InternalHelper<T>::GetOwningArena(p);
+            }
+
+            // Provides access to protected GetArenaForAllocation to generated messages.
+            // For internal use only.
+            template<typename T>
+            static Arena* InternalGetArenaForAllocation(const T* p)
+            {
+                return InternalHelper<T>::GetArenaForAllocationInternal(
+                    p, std::is_convertible<T*, MessageLite*>()
+                );
+            }
+
+            // Creates message-owned arena.  For internal use only.
+            static Arena* InternalCreateMessageOwnedArena()
+            {
+                return new Arena(internal::MessageOwned{});
+            }
+
+            // Checks whether this arena is message-owned.  For internal use only.
+            bool InternalIsMessageOwnedArena()
+            {
+                return IsMessageOwned();
+            }
+
+            // Helper typetraits that indicates support for arenas in a type T at compile
+            // time. This is public only to allow construction of higher-level templated
+            // utilities.
+            //
+            // is_arena_constructable<T>::value is true if the message type T has arena
+            // support enabled, and false otherwise.
+            //
+            // is_destructor_skippable<T>::value is true if the message type T has told
+            // the arena that it is safe to skip the destructor, and false otherwise.
+            //
+            // This is inside Arena because only Arena has the friend relationships
+            // necessary to see the underlying generated code traits.
+            template<typename T>
+            struct is_arena_constructable : InternalHelper<T>::is_arena_constructable
+            {
+            };
+            template<typename T>
+            struct is_destructor_skippable : InternalHelper<T>::is_destructor_skippable
+            {
+            };
+
+        private:
+            internal::ThreadSafeArena impl_;
+
+            template<typename T>
+            struct has_get_arena : InternalHelper<T>::has_get_arena
+            {
+            };
+
+            // Constructor solely used by message-owned arena.
+            inline Arena(internal::MessageOwned) :
+                impl_(internal::MessageOwned{})
+            {
+            }
+
+            // Checks whether this arena is message-owned.
+            PROTOBUF_ALWAYS_INLINE bool IsMessageOwned() const
+            {
+                return impl_.IsMessageOwned();
+            }
+
+            void ReturnArrayMemory(void* p, size_t size)
+            {
+                impl_.ReturnArrayMemory(p, size);
+            }
+
+            template<typename T, typename... Args>
+            PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena, Args&&... args)
+            {
+                static_assert(
+                    InternalHelper<T>::is_arena_constructable::value,
+                    "CreateMessage can only construct types that are ArenaConstructable"
+                );
+                if (arena == NULL)
+                {
+                    return new T(nullptr, static_cast<Args&&>(args)...);
+                }
+                else
+                {
+                    return arena->DoCreateMessage<T>(static_cast<Args&&>(args)...);
+                }
+            }
+
+            // This specialization for no arguments is necessary, because its behavior is
+            // slightly different.  When the arena pointer is nullptr, it calls T()
+            // instead of T(nullptr).
+            template<typename T>
+            PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena)
+            {
+                static_assert(
+                    InternalHelper<T>::is_arena_constructable::value,
+                    "CreateMessage can only construct types that are ArenaConstructable"
+                );
+                if (arena == NULL)
+                {
+                    // Generated arena constructor T(Arena*) is protected. Call via
+                    // InternalHelper.
+                    return InternalHelper<T>::New();
+                }
+                else
+                {
+                    return arena->DoCreateMessage<T>();
+                }
+            }
+
+            // Allocate and also optionally call collector with the allocated type info
+            // when allocation recording is enabled.
+            PROTOBUF_NDEBUG_INLINE void* AllocateInternal(size_t size, size_t align, void (*destructor)(void*), const std::type_info* type)
+            {
+                // Monitor allocation if needed.
+                if (destructor == nullptr)
+                {
+                    return AllocateAlignedWithHook(size, align, type);
+                }
+                else
+                {
+                    if (align <= 8)
+                    {
+                        auto res = AllocateAlignedWithCleanup(internal::AlignUpTo8(size), type);
+                        res.second->elem = res.first;
+                        res.second->cleanup = destructor;
+                        return res.first;
+                    }
+                    else
+                    {
+                        auto res = AllocateAlignedWithCleanup(size + align - 8, type);
+                        auto ptr = internal::AlignTo(res.first, align);
+                        res.second->elem = ptr;
+                        res.second->cleanup = destructor;
+                        return ptr;
+                    }
+                }
+            }
+
+            // CreateMessage<T> requires that T supports arenas, but this private method
+            // works whether or not T supports arenas. These are not exposed to user code
+            // as it can cause confusing API usages, and end up having double free in
+            // user code. These are used only internally from LazyField and Repeated
+            // fields, since they are designed to work in all mode combinations.
+            template<typename Msg, typename... Args>
+            PROTOBUF_ALWAYS_INLINE static Msg* DoCreateMaybeMessage(Arena* arena, std::true_type, Args&&... args)
+            {
+                return CreateMessageInternal<Msg>(arena, std::forward<Args>(args)...);
+            }
+
+            template<typename T, typename... Args>
+            PROTOBUF_ALWAYS_INLINE static T* DoCreateMaybeMessage(Arena* arena, std::false_type, Args&&... args)
+            {
+                return Create<T>(arena, std::forward<Args>(args)...);
+            }
+
+            template<typename T, typename... Args>
+            PROTOBUF_ALWAYS_INLINE static T* CreateMaybeMessage(Arena* arena, Args&&... args)
+            {
+                return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(), std::forward<Args>(args)...);
+            }
+
+            // Just allocate the required size for the given type assuming the
+            // type has a trivial constructor.
+            template<typename T>
+            PROTOBUF_NDEBUG_INLINE T* CreateInternalRawArray(size_t num_elements)
+            {
+                GOOGLE_CHECK_LE(num_elements, std::numeric_limits<size_t>::max() / sizeof(T))
+                    << "Requested size is too large to fit into size_t.";
+                // We count on compiler to realize that if sizeof(T) is a multiple of
+                // 8 AlignUpTo can be elided.
+                const size_t n = sizeof(T) * num_elements;
+                return static_cast<T*>(
+                    AllocateAlignedWithHookForArray(n, alignof(T), RTTI_TYPE_ID(T))
+                );
+            }
+
+            template<typename T, typename... Args>
+            PROTOBUF_NDEBUG_INLINE T* DoCreateMessage(Args&&... args)
+            {
+                return InternalHelper<T>::Construct(
+                    AllocateInternal(sizeof(T), alignof(T), internal::ObjectDestructor<InternalHelper<T>::is_destructor_skippable::value, T>::destructor, RTTI_TYPE_ID(T)),
+                    this,
+                    std::forward<Args>(args)...
+                );
+            }
+
+            // CreateInArenaStorage is used to implement map field. Without it,
+            // Map need to call generated message's protected arena constructor,
+            // which needs to declare Map as friend of generated message.
+            template<typename T, typename... Args>
+            static void CreateInArenaStorage(T* ptr, Arena* arena, Args&&... args)
+            {
+                CreateInArenaStorageInternal(ptr, arena, typename is_arena_constructable<T>::type(), std::forward<Args>(args)...);
+                if (arena != nullptr)
+                {
+                    RegisterDestructorInternal(
+                        ptr, arena, typename InternalHelper<T>::is_destructor_skippable::type()
+                    );
+                }
+            }
+
+            template<typename T, typename... Args>
+            static void CreateInArenaStorageInternal(T* ptr, Arena* arena, std::true_type, Args&&... args)
+            {
+                InternalHelper<T>::Construct(ptr, arena, std::forward<Args>(args)...);
+            }
+            template<typename T, typename... Args>
+            static void CreateInArenaStorageInternal(T* ptr, Arena* /* arena */, std::false_type, Args&&... args)
+            {
+                new (ptr) T(std::forward<Args>(args)...);
+            }
+
+            template<typename T>
+            static void RegisterDestructorInternal(T* /* ptr */, Arena* /* arena */, std::true_type)
+            {
+            }
+            template<typename T>
+            static void RegisterDestructorInternal(T* ptr, Arena* arena, std::false_type)
+            {
+                arena->OwnDestructor(ptr);
+            }
+
+            // These implement Create(). The second parameter has type 'true_type' if T is
+            // a subtype of Message and 'false_type' otherwise.
+            template<typename T, typename... Args>
+            PROTOBUF_ALWAYS_INLINE static T* CreateInternal(Arena* arena, std::true_type, Args&&... args)
+            {
+                if (arena == nullptr)
+                {
+                    return new T(std::forward<Args>(args)...);
+                }
+                else
+                {
+                    auto destructor =
+                        internal::ObjectDestructor<std::is_trivially_destructible<T>::value, T>::destructor;
+                    T* result =
+                        new (arena->AllocateInternal(sizeof(T), alignof(T), destructor, RTTI_TYPE_ID(T)))
+                            T(std::forward<Args>(args)...);
+                    return result;
+                }
+            }
+            template<typename T, typename... Args>
+            PROTOBUF_ALWAYS_INLINE static T* CreateInternal(Arena* arena, std::false_type, Args&&... args)
+            {
+                if (arena == nullptr)
+                {
+                    return new T(std::forward<Args>(args)...);
+                }
+                else
+                {
+                    auto destructor =
+                        internal::ObjectDestructor<std::is_trivially_destructible<T>::value, T>::destructor;
+                    return new (arena->AllocateInternal(sizeof(T), alignof(T), destructor, RTTI_TYPE_ID(T)))
+                        T(std::forward<Args>(args)...);
+                }
+            }
+
+            // These implement Own(), which registers an object for deletion (destructor
+            // call and operator delete()). The second parameter has type 'true_type' if T
+            // is a subtype of Message and 'false_type' otherwise. Collapsing
+            // all template instantiations to one for generic Message reduces code size,
+            // using the virtual destructor instead.
+            template<typename T>
+            PROTOBUF_ALWAYS_INLINE void OwnInternal(T* object, std::true_type)
+            {
+                if (object != NULL)
+                {
+                    impl_.AddCleanup(object, &internal::arena_delete_object<MessageLite>);
+                }
+            }
+            template<typename T>
+            PROTOBUF_ALWAYS_INLINE void OwnInternal(T* object, std::false_type)
+            {
+                if (object != NULL)
+                {
+                    impl_.AddCleanup(object, &internal::arena_delete_object<T>);
+                }
+            }
+
+            // Implementation for GetArena(). Only message objects with
+            // InternalArenaConstructable_ tags can be associated with an arena, and such
+            // objects must implement a GetArena() method.
+            template<typename T, typename std::enable_if<is_arena_constructable<T>::value, int>::type = 0>
+            PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value)
+            {
+                return InternalHelper<T>::GetArena(value);
+            }
+            template<typename T, typename std::enable_if<!is_arena_constructable<T>::value && has_get_arena<T>::value, int>::type = 0>
+            PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value)
+            {
+                return value->GetArena();
+            }
+            template<typename T, typename std::enable_if<!is_arena_constructable<T>::value && !has_get_arena<T>::value, int>::type = 0>
+            PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value)
+            {
+                (void)value;
+                return nullptr;
+            }
+
+            template<typename T>
+            PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArena(const T* value)
+            {
+                return GetOwningArenaInternal(
+                    value, std::is_convertible<T*, MessageLite*>()
+                );
+            }
+
+            // Implementation for GetOwningArena(). All and only message objects have
+            // GetOwningArena() method.
+            template<typename T>
+            PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArenaInternal(
+                const T* value, std::true_type
+            )
+            {
+                return InternalHelper<T>::GetOwningArena(value);
+            }
+            template<typename T>
+            PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArenaInternal(
+                const T* /* value */, std::false_type
+            )
+            {
+                return nullptr;
+            }
+
+            void* AllocateAlignedWithHookForArray(size_t n, size_t align, const std::type_info* type)
+            {
+                if (align <= 8)
+                {
+                    return AllocateAlignedWithHookForArray(internal::AlignUpTo8(n), type);
+                }
+                else
+                {
+                    // We are wasting space by over allocating align - 8 bytes. Compared
+                    // to a dedicated function that takes current alignment in consideration.
+                    // Such a scheme would only waste (align - 8)/2 bytes on average, but
+                    // requires a dedicated function in the outline arena allocation
+                    // functions. Possibly re-evaluate tradeoffs later.
+                    return internal::AlignTo(
+                        AllocateAlignedWithHookForArray(n + align - 8, type), align
+                    );
+                }
+            }
+
+            void* AllocateAlignedWithHook(size_t n, size_t align, const std::type_info* type)
+            {
+                if (align <= 8)
+                {
+                    return AllocateAlignedWithHook(internal::AlignUpTo8(n), type);
+                }
+                else
+                {
+                    // We are wasting space by over allocating align - 8 bytes. Compared
+                    // to a dedicated function that takes current alignment in consideration.
+                    // Such a scheme would only waste (align - 8)/2 bytes on average, but
+                    // requires a dedicated function in the outline arena allocation
+                    // functions. Possibly re-evaluate tradeoffs later.
+                    return internal::AlignTo(AllocateAlignedWithHook(n + align - 8, type), align);
+                }
+            }
+
+            void* AllocateAlignedNoHook(size_t n);
+            void* AllocateAlignedWithHook(size_t n, const std::type_info* type);
+            void* AllocateAlignedWithHookForArray(size_t n, const std::type_info* type);
+            std::pair<void*, internal::SerialArena::CleanupNode*>
+                AllocateAlignedWithCleanup(size_t n, const std::type_info* type);
+
+            template<typename Type>
+            friend class internal::GenericTypeHandler;
+            friend class internal::InternalMetadata;    // For user_arena().
+            friend class internal::LazyField;           // For CreateMaybeMessage.
+            friend class internal::EpsCopyInputStream;  // For parser performance
+            friend class MessageLite;
+            template<typename Key, typename T>
+            friend class Map;
+            template<typename>
+            friend class RepeatedField;                   // For ReturnArrayMemory
+            friend class internal::RepeatedPtrFieldBase;  // For ReturnArrayMemory
+            friend struct internal::ArenaTestPeer;
+        };
 
 // Defined above for supporting environments without RTTI.
 #undef RTTI_TYPE_ID
 
-}  // namespace protobuf
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/arena_impl.h b/CAPI/cpp/grpc/include/google/protobuf/arena_impl.h
index 7672768..1b88b77 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/arena_impl.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/arena_impl.h
@@ -50,635 +50,774 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
 // To prevent sharing cache lines between threads
 #ifdef __cpp_aligned_new
-enum { kCacheAlignment = 64 };
+            enum
+            {
+                kCacheAlignment = 64
+            };
 #else
-enum { kCacheAlignment = alignof(max_align_t) };  // do the best we can
+            enum
+            {
+                kCacheAlignment = alignof(max_align_t)
+            };  // do the best we can
 #endif
 
-inline constexpr size_t AlignUpTo8(size_t n) {
-  // Align n to next multiple of 8 (from Hacker's Delight, Chapter 3.)
-  return (n + 7) & static_cast<size_t>(-8);
-}
-
-using LifecycleIdAtomic = uint64_t;
-
-// MetricsCollector collects stats for a particular arena.
-class PROTOBUF_EXPORT ArenaMetricsCollector {
- public:
-  ArenaMetricsCollector(bool record_allocs) : record_allocs_(record_allocs) {}
-
-  // Invoked when the arena is about to be destroyed. This method will
-  // typically finalize any metric collection and delete the collector.
-  // space_allocated is the space used by the arena.
-  virtual void OnDestroy(uint64_t space_allocated) = 0;
-
-  // OnReset() is called when the associated arena is reset.
-  // space_allocated is the space used by the arena just before the reset.
-  virtual void OnReset(uint64_t space_allocated) = 0;
-
-  // OnAlloc is called when an allocation happens.
-  // type_info is promised to be static - its lifetime extends to
-  // match program's lifetime (It is given by typeid operator).
-  // Note: typeid(void) will be passed as allocated_type every time we
-  // intentionally want to avoid monitoring an allocation. (i.e. internal
-  // allocations for managing the arena)
-  virtual void OnAlloc(const std::type_info* allocated_type,
-                       uint64_t alloc_size) = 0;
-
-  // Does OnAlloc() need to be called?  If false, metric collection overhead
-  // will be reduced since we will not do extra work per allocation.
-  bool RecordAllocs() { return record_allocs_; }
-
- protected:
-  // This class is destructed by the call to OnDestroy().
-  ~ArenaMetricsCollector() = default;
-  const bool record_allocs_;
-};
-
-struct AllocationPolicy {
-  static constexpr size_t kDefaultStartBlockSize = 256;
-  static constexpr size_t kDefaultMaxBlockSize = 8192;
-
-  size_t start_block_size = kDefaultStartBlockSize;
-  size_t max_block_size = kDefaultMaxBlockSize;
-  void* (*block_alloc)(size_t) = nullptr;
-  void (*block_dealloc)(void*, size_t) = nullptr;
-  ArenaMetricsCollector* metrics_collector = nullptr;
-
-  bool IsDefault() const {
-    return start_block_size == kDefaultMaxBlockSize &&
-           max_block_size == kDefaultMaxBlockSize && block_alloc == nullptr &&
-           block_dealloc == nullptr && metrics_collector == nullptr;
-  }
-};
-
-// Tagged pointer to an AllocationPolicy.
-class TaggedAllocationPolicyPtr {
- public:
-  constexpr TaggedAllocationPolicyPtr() : policy_(0) {}
-
-  explicit TaggedAllocationPolicyPtr(AllocationPolicy* policy)
-      : policy_(reinterpret_cast<uintptr_t>(policy)) {}
-
-  void set_policy(AllocationPolicy* policy) {
-    auto bits = policy_ & kTagsMask;
-    policy_ = reinterpret_cast<uintptr_t>(policy) | bits;
-  }
-
-  AllocationPolicy* get() {
-    return reinterpret_cast<AllocationPolicy*>(policy_ & kPtrMask);
-  }
-  const AllocationPolicy* get() const {
-    return reinterpret_cast<const AllocationPolicy*>(policy_ & kPtrMask);
-  }
-
-  AllocationPolicy& operator*() { return *get(); }
-  const AllocationPolicy& operator*() const { return *get(); }
-
-  AllocationPolicy* operator->() { return get(); }
-  const AllocationPolicy* operator->() const { return get(); }
-
-  bool is_user_owned_initial_block() const {
-    return static_cast<bool>(get_mask<kUserOwnedInitialBlock>());
-  }
-  void set_is_user_owned_initial_block(bool v) {
-    set_mask<kUserOwnedInitialBlock>(v);
-  }
-
-  bool should_record_allocs() const {
-    return static_cast<bool>(get_mask<kRecordAllocs>());
-  }
-  void set_should_record_allocs(bool v) { set_mask<kRecordAllocs>(v); }
-
-  uintptr_t get_raw() const { return policy_; }
-
-  inline void RecordAlloc(const std::type_info* allocated_type,
-                          size_t n) const {
-    get()->metrics_collector->OnAlloc(allocated_type, n);
-  }
-
- private:
-  enum : uintptr_t {
-    kUserOwnedInitialBlock = 1,
-    kRecordAllocs = 2,
-  };
-
-  static constexpr uintptr_t kTagsMask = 7;
-  static constexpr uintptr_t kPtrMask = ~kTagsMask;
-
-  template <uintptr_t kMask>
-  uintptr_t get_mask() const {
-    return policy_ & kMask;
-  }
-  template <uintptr_t kMask>
-  void set_mask(bool v) {
-    if (v) {
-      policy_ |= kMask;
-    } else {
-      policy_ &= ~kMask;
-    }
-  }
-  uintptr_t policy_;
-};
-
-enum class AllocationClient { kDefault, kArray };
-
-// A simple arena allocator. Calls to allocate functions must be properly
-// serialized by the caller, hence this class cannot be used as a general
-// purpose allocator in a multi-threaded program. It serves as a building block
-// for ThreadSafeArena, which provides a thread-safe arena allocator.
-//
-// This class manages
-// 1) Arena bump allocation + owning memory blocks.
-// 2) Maintaining a cleanup list.
-// It delagetes the actual memory allocation back to ThreadSafeArena, which
-// contains the information on block growth policy and backing memory allocation
-// used.
-class PROTOBUF_EXPORT SerialArena {
- public:
-  struct Memory {
-    void* ptr;
-    size_t size;
-  };
-
-  // Node contains the ptr of the object to be cleaned up and the associated
-  // cleanup function ptr.
-  struct CleanupNode {
-    void* elem;              // Pointer to the object to be cleaned up.
-    void (*cleanup)(void*);  // Function pointer to the destructor or deleter.
-  };
-
-  void CleanupList();
-  uint64_t SpaceAllocated() const {
-    return space_allocated_.load(std::memory_order_relaxed);
-  }
-  uint64_t SpaceUsed() const;
-
-  bool HasSpace(size_t n) const {
-    return n <= static_cast<size_t>(limit_ - ptr_);
-  }
-
-  // See comments on `cached_blocks_` member for details.
-  PROTOBUF_ALWAYS_INLINE void* TryAllocateFromCachedBlock(size_t size) {
-    if (PROTOBUF_PREDICT_FALSE(size < 16)) return nullptr;
-    // We round up to the next larger block in case the memory doesn't match
-    // the pattern we are looking for.
-    const size_t index = Bits::Log2FloorNonZero64(size - 1) - 3;
-
-    if (index >= cached_block_length_) return nullptr;
-    auto& cached_head = cached_blocks_[index];
-    if (cached_head == nullptr) return nullptr;
-
-    void* ret = cached_head;
+            inline constexpr size_t AlignUpTo8(size_t n)
+            {
+                // Align n to next multiple of 8 (from Hacker's Delight, Chapter 3.)
+                return (n + 7) & static_cast<size_t>(-8);
+            }
+
+            using LifecycleIdAtomic = uint64_t;
+
+            // MetricsCollector collects stats for a particular arena.
+            class PROTOBUF_EXPORT ArenaMetricsCollector
+            {
+            public:
+                ArenaMetricsCollector(bool record_allocs) :
+                    record_allocs_(record_allocs)
+                {
+                }
+
+                // Invoked when the arena is about to be destroyed. This method will
+                // typically finalize any metric collection and delete the collector.
+                // space_allocated is the space used by the arena.
+                virtual void OnDestroy(uint64_t space_allocated) = 0;
+
+                // OnReset() is called when the associated arena is reset.
+                // space_allocated is the space used by the arena just before the reset.
+                virtual void OnReset(uint64_t space_allocated) = 0;
+
+                // OnAlloc is called when an allocation happens.
+                // type_info is promised to be static - its lifetime extends to
+                // match program's lifetime (It is given by typeid operator).
+                // Note: typeid(void) will be passed as allocated_type every time we
+                // intentionally want to avoid monitoring an allocation. (i.e. internal
+                // allocations for managing the arena)
+                virtual void OnAlloc(const std::type_info* allocated_type, uint64_t alloc_size) = 0;
+
+                // Does OnAlloc() need to be called?  If false, metric collection overhead
+                // will be reduced since we will not do extra work per allocation.
+                bool RecordAllocs()
+                {
+                    return record_allocs_;
+                }
+
+            protected:
+                // This class is destructed by the call to OnDestroy().
+                ~ArenaMetricsCollector() = default;
+                const bool record_allocs_;
+            };
+
+            struct AllocationPolicy
+            {
+                static constexpr size_t kDefaultStartBlockSize = 256;
+                static constexpr size_t kDefaultMaxBlockSize = 8192;
+
+                size_t start_block_size = kDefaultStartBlockSize;
+                size_t max_block_size = kDefaultMaxBlockSize;
+                void* (*block_alloc)(size_t) = nullptr;
+                void (*block_dealloc)(void*, size_t) = nullptr;
+                ArenaMetricsCollector* metrics_collector = nullptr;
+
+                bool IsDefault() const
+                {
+                    return start_block_size == kDefaultMaxBlockSize &&
+                           max_block_size == kDefaultMaxBlockSize && block_alloc == nullptr &&
+                           block_dealloc == nullptr && metrics_collector == nullptr;
+                }
+            };
+
+            // Tagged pointer to an AllocationPolicy.
+            class TaggedAllocationPolicyPtr
+            {
+            public:
+                constexpr TaggedAllocationPolicyPtr() :
+                    policy_(0)
+                {
+                }
+
+                explicit TaggedAllocationPolicyPtr(AllocationPolicy* policy) :
+                    policy_(reinterpret_cast<uintptr_t>(policy))
+                {
+                }
+
+                void set_policy(AllocationPolicy* policy)
+                {
+                    auto bits = policy_ & kTagsMask;
+                    policy_ = reinterpret_cast<uintptr_t>(policy) | bits;
+                }
+
+                AllocationPolicy* get()
+                {
+                    return reinterpret_cast<AllocationPolicy*>(policy_ & kPtrMask);
+                }
+                const AllocationPolicy* get() const
+                {
+                    return reinterpret_cast<const AllocationPolicy*>(policy_ & kPtrMask);
+                }
+
+                AllocationPolicy& operator*()
+                {
+                    return *get();
+                }
+                const AllocationPolicy& operator*() const
+                {
+                    return *get();
+                }
+
+                AllocationPolicy* operator->()
+                {
+                    return get();
+                }
+                const AllocationPolicy* operator->() const
+                {
+                    return get();
+                }
+
+                bool is_user_owned_initial_block() const
+                {
+                    return static_cast<bool>(get_mask<kUserOwnedInitialBlock>());
+                }
+                void set_is_user_owned_initial_block(bool v)
+                {
+                    set_mask<kUserOwnedInitialBlock>(v);
+                }
+
+                bool should_record_allocs() const
+                {
+                    return static_cast<bool>(get_mask<kRecordAllocs>());
+                }
+                void set_should_record_allocs(bool v)
+                {
+                    set_mask<kRecordAllocs>(v);
+                }
+
+                uintptr_t get_raw() const
+                {
+                    return policy_;
+                }
+
+                inline void RecordAlloc(const std::type_info* allocated_type, size_t n) const
+                {
+                    get()->metrics_collector->OnAlloc(allocated_type, n);
+                }
+
+            private:
+                enum : uintptr_t
+                {
+                    kUserOwnedInitialBlock = 1,
+                    kRecordAllocs = 2,
+                };
+
+                static constexpr uintptr_t kTagsMask = 7;
+                static constexpr uintptr_t kPtrMask = ~kTagsMask;
+
+                template<uintptr_t kMask>
+                uintptr_t get_mask() const
+                {
+                    return policy_ & kMask;
+                }
+                template<uintptr_t kMask>
+                void set_mask(bool v)
+                {
+                    if (v)
+                    {
+                        policy_ |= kMask;
+                    }
+                    else
+                    {
+                        policy_ &= ~kMask;
+                    }
+                }
+                uintptr_t policy_;
+            };
+
+            enum class AllocationClient
+            {
+                kDefault,
+                kArray
+            };
+
+            // A simple arena allocator. Calls to allocate functions must be properly
+            // serialized by the caller, hence this class cannot be used as a general
+            // purpose allocator in a multi-threaded program. It serves as a building block
+            // for ThreadSafeArena, which provides a thread-safe arena allocator.
+            //
+            // This class manages
+            // 1) Arena bump allocation + owning memory blocks.
+            // 2) Maintaining a cleanup list.
+            // It delagetes the actual memory allocation back to ThreadSafeArena, which
+            // contains the information on block growth policy and backing memory allocation
+            // used.
+            class PROTOBUF_EXPORT SerialArena
+            {
+            public:
+                struct Memory
+                {
+                    void* ptr;
+                    size_t size;
+                };
+
+                // Node contains the ptr of the object to be cleaned up and the associated
+                // cleanup function ptr.
+                struct CleanupNode
+                {
+                    void* elem;              // Pointer to the object to be cleaned up.
+                    void (*cleanup)(void*);  // Function pointer to the destructor or deleter.
+                };
+
+                void CleanupList();
+                uint64_t SpaceAllocated() const
+                {
+                    return space_allocated_.load(std::memory_order_relaxed);
+                }
+                uint64_t SpaceUsed() const;
+
+                bool HasSpace(size_t n) const
+                {
+                    return n <= static_cast<size_t>(limit_ - ptr_);
+                }
+
+                // See comments on `cached_blocks_` member for details.
+                PROTOBUF_ALWAYS_INLINE void* TryAllocateFromCachedBlock(size_t size)
+                {
+                    if (PROTOBUF_PREDICT_FALSE(size < 16))
+                        return nullptr;
+                    // We round up to the next larger block in case the memory doesn't match
+                    // the pattern we are looking for.
+                    const size_t index = Bits::Log2FloorNonZero64(size - 1) - 3;
+
+                    if (index >= cached_block_length_)
+                        return nullptr;
+                    auto& cached_head = cached_blocks_[index];
+                    if (cached_head == nullptr)
+                        return nullptr;
+
+                    void* ret = cached_head;
 #ifdef ADDRESS_SANITIZER
-    ASAN_UNPOISON_MEMORY_REGION(ret, size);
+                    ASAN_UNPOISON_MEMORY_REGION(ret, size);
 #endif  // ADDRESS_SANITIZER
-    cached_head = cached_head->next;
-    return ret;
-  }
-
-  // In kArray mode we look through cached blocks.
-  // We do not do this by default because most non-array allocations will not
-  // have the right size and will fail to find an appropriate cached block.
-  //
-  // TODO(sbenza): Evaluate if we should use cached blocks for message types of
-  // the right size. We can statically know if the allocation size can benefit
-  // from it.
-  template <AllocationClient alloc_client = AllocationClient::kDefault>
-  void* AllocateAligned(size_t n, const AllocationPolicy* policy) {
-    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
-    GOOGLE_DCHECK_GE(limit_, ptr_);
-
-    if (alloc_client == AllocationClient::kArray) {
-      if (void* res = TryAllocateFromCachedBlock(n)) {
-        return res;
-      }
-    }
-
-    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n))) {
-      return AllocateAlignedFallback(n, policy);
-    }
-    return AllocateFromExisting(n);
-  }
-
- private:
-  void* AllocateFromExisting(size_t n) {
-    void* ret = ptr_;
-    ptr_ += n;
+                    cached_head = cached_head->next;
+                    return ret;
+                }
+
+                // In kArray mode we look through cached blocks.
+                // We do not do this by default because most non-array allocations will not
+                // have the right size and will fail to find an appropriate cached block.
+                //
+                // TODO(sbenza): Evaluate if we should use cached blocks for message types of
+                // the right size. We can statically know if the allocation size can benefit
+                // from it.
+                template<AllocationClient alloc_client = AllocationClient::kDefault>
+                void* AllocateAligned(size_t n, const AllocationPolicy* policy)
+                {
+                    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
+                    GOOGLE_DCHECK_GE(limit_, ptr_);
+
+                    if (alloc_client == AllocationClient::kArray)
+                    {
+                        if (void* res = TryAllocateFromCachedBlock(n))
+                        {
+                            return res;
+                        }
+                    }
+
+                    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n)))
+                    {
+                        return AllocateAlignedFallback(n, policy);
+                    }
+                    return AllocateFromExisting(n);
+                }
+
+            private:
+                void* AllocateFromExisting(size_t n)
+                {
+                    void* ret = ptr_;
+                    ptr_ += n;
 #ifdef ADDRESS_SANITIZER
-    ASAN_UNPOISON_MEMORY_REGION(ret, n);
+                    ASAN_UNPOISON_MEMORY_REGION(ret, n);
 #endif  // ADDRESS_SANITIZER
-    return ret;
-  }
-
-  // See comments on `cached_blocks_` member for details.
-  void ReturnArrayMemory(void* p, size_t size) {
-    // We only need to check for 32-bit platforms.
-    // In 64-bit platforms the minimum allocation size from Repeated*Field will
-    // be 16 guaranteed.
-    if (sizeof(void*) < 8) {
-      if (PROTOBUF_PREDICT_FALSE(size < 16)) return;
-    } else {
-      GOOGLE_DCHECK(size >= 16);
-    }
-
-    // We round down to the next smaller block in case the memory doesn't match
-    // the pattern we are looking for. eg, someone might have called Reserve()
-    // on the repeated field.
-    const size_t index = Bits::Log2FloorNonZero64(size) - 4;
-
-    if (PROTOBUF_PREDICT_FALSE(index >= cached_block_length_)) {
-      // We can't put this object on the freelist so make this object the
-      // freelist. It is guaranteed it is larger than the one we have, and
-      // large enough to hold another allocation of `size`.
-      CachedBlock** new_list = static_cast<CachedBlock**>(p);
-      size_t new_size = size / sizeof(CachedBlock*);
-
-      std::copy(cached_blocks_, cached_blocks_ + cached_block_length_,
-                new_list);
-      std::fill(new_list + cached_block_length_, new_list + new_size, nullptr);
-      cached_blocks_ = new_list;
-      // Make the size fit in uint8_t. This is the power of two, so we don't
-      // need anything larger.
-      cached_block_length_ =
-          static_cast<uint8_t>(std::min(size_t{64}, new_size));
-
-      return;
-    }
-
-    auto& cached_head = cached_blocks_[index];
-    auto* new_node = static_cast<CachedBlock*>(p);
-    new_node->next = cached_head;
-    cached_head = new_node;
+                    return ret;
+                }
+
+                // See comments on `cached_blocks_` member for details.
+                void ReturnArrayMemory(void* p, size_t size)
+                {
+                    // We only need to check for 32-bit platforms.
+                    // In 64-bit platforms the minimum allocation size from Repeated*Field will
+                    // be 16 guaranteed.
+                    if (sizeof(void*) < 8)
+                    {
+                        if (PROTOBUF_PREDICT_FALSE(size < 16))
+                            return;
+                    }
+                    else
+                    {
+                        GOOGLE_DCHECK(size >= 16);
+                    }
+
+                    // We round down to the next smaller block in case the memory doesn't match
+                    // the pattern we are looking for. eg, someone might have called Reserve()
+                    // on the repeated field.
+                    const size_t index = Bits::Log2FloorNonZero64(size) - 4;
+
+                    if (PROTOBUF_PREDICT_FALSE(index >= cached_block_length_))
+                    {
+                        // We can't put this object on the freelist so make this object the
+                        // freelist. It is guaranteed it is larger than the one we have, and
+                        // large enough to hold another allocation of `size`.
+                        CachedBlock** new_list = static_cast<CachedBlock**>(p);
+                        size_t new_size = size / sizeof(CachedBlock*);
+
+                        std::copy(cached_blocks_, cached_blocks_ + cached_block_length_, new_list);
+                        std::fill(new_list + cached_block_length_, new_list + new_size, nullptr);
+                        cached_blocks_ = new_list;
+                        // Make the size fit in uint8_t. This is the power of two, so we don't
+                        // need anything larger.
+                        cached_block_length_ =
+                            static_cast<uint8_t>(std::min(size_t{64}, new_size));
+
+                        return;
+                    }
+
+                    auto& cached_head = cached_blocks_[index];
+                    auto* new_node = static_cast<CachedBlock*>(p);
+                    new_node->next = cached_head;
+                    cached_head = new_node;
 #ifdef ADDRESS_SANITIZER
-    ASAN_POISON_MEMORY_REGION(p, size);
+                    ASAN_POISON_MEMORY_REGION(p, size);
 #endif  // ADDRESS_SANITIZER
-  }
-
- public:
-  // Allocate space if the current region provides enough space.
-  bool MaybeAllocateAligned(size_t n, void** out) {
-    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
-    GOOGLE_DCHECK_GE(limit_, ptr_);
-    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n))) return false;
-    *out = AllocateFromExisting(n);
-    return true;
-  }
-
-  std::pair<void*, CleanupNode*> AllocateAlignedWithCleanup(
-      size_t n, const AllocationPolicy* policy) {
-    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
-    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n + kCleanupSize))) {
-      return AllocateAlignedWithCleanupFallback(n, policy);
-    }
-    return AllocateFromExistingWithCleanupFallback(n);
-  }
-
- private:
-  std::pair<void*, CleanupNode*> AllocateFromExistingWithCleanupFallback(
-      size_t n) {
-    void* ret = ptr_;
-    ptr_ += n;
-    limit_ -= kCleanupSize;
+                }
+
+            public:
+                // Allocate space if the current region provides enough space.
+                bool MaybeAllocateAligned(size_t n, void** out)
+                {
+                    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
+                    GOOGLE_DCHECK_GE(limit_, ptr_);
+                    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n)))
+                        return false;
+                    *out = AllocateFromExisting(n);
+                    return true;
+                }
+
+                std::pair<void*, CleanupNode*> AllocateAlignedWithCleanup(
+                    size_t n, const AllocationPolicy* policy
+                )
+                {
+                    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
+                    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n + kCleanupSize)))
+                    {
+                        return AllocateAlignedWithCleanupFallback(n, policy);
+                    }
+                    return AllocateFromExistingWithCleanupFallback(n);
+                }
+
+            private:
+                std::pair<void*, CleanupNode*> AllocateFromExistingWithCleanupFallback(
+                    size_t n
+                )
+                {
+                    void* ret = ptr_;
+                    ptr_ += n;
+                    limit_ -= kCleanupSize;
 #ifdef ADDRESS_SANITIZER
-    ASAN_UNPOISON_MEMORY_REGION(ret, n);
-    ASAN_UNPOISON_MEMORY_REGION(limit_, kCleanupSize);
+                    ASAN_UNPOISON_MEMORY_REGION(ret, n);
+                    ASAN_UNPOISON_MEMORY_REGION(limit_, kCleanupSize);
 #endif  // ADDRESS_SANITIZER
-    return CreatePair(ret, reinterpret_cast<CleanupNode*>(limit_));
-  }
-
- public:
-  void AddCleanup(void* elem, void (*cleanup)(void*),
-                  const AllocationPolicy* policy) {
-    auto res = AllocateAlignedWithCleanup(0, policy);
-    res.second->elem = elem;
-    res.second->cleanup = cleanup;
-  }
-
-  void* owner() const { return owner_; }
-  SerialArena* next() const { return next_; }
-  void set_next(SerialArena* next) { next_ = next; }
-
- private:
-  friend class ThreadSafeArena;
-  friend class ArenaBenchmark;
-
-  // Creates a new SerialArena inside mem using the remaining memory as for
-  // future allocations.
-  static SerialArena* New(SerialArena::Memory mem, void* owner,
-                          ThreadSafeArenaStats* stats);
-  // Free SerialArena returning the memory passed in to New
-  template <typename Deallocator>
-  Memory Free(Deallocator deallocator);
-
-  // Blocks are variable length malloc-ed objects.  The following structure
-  // describes the common header for all blocks.
-  struct Block {
-    Block(Block* next, size_t size) : next(next), size(size), start(nullptr) {}
-
-    char* Pointer(size_t n) {
-      GOOGLE_DCHECK(n <= size);
-      return reinterpret_cast<char*>(this) + n;
-    }
-
-    Block* const next;
-    const size_t size;
-    CleanupNode* start;
-    // data follows
-  };
-
-  void* owner_;            // &ThreadCache of this thread;
-  Block* head_;            // Head of linked list of blocks.
-  SerialArena* next_;      // Next SerialArena in this linked list.
-  size_t space_used_ = 0;  // Necessary for metrics.
-  std::atomic<size_t> space_allocated_;
-
-  // Next pointer to allocate from.  Always 8-byte aligned.  Points inside
-  // head_ (and head_->pos will always be non-canonical).  We keep these
-  // here to reduce indirection.
-  char* ptr_;
-  // Limiting address up to which memory can be allocated from the head block.
-  char* limit_;
-  // For holding sampling information.  The pointer is owned by the
-  // ThreadSafeArena that holds this serial arena.
-  ThreadSafeArenaStats* arena_stats_;
-
-  // Repeated*Field and Arena play together to reduce memory consumption by
-  // reusing blocks. Currently, natural growth of the repeated field types makes
-  // them allocate blocks of size `8 + 2^N, N>=3`.
-  // When the repeated field grows returns the previous block and we put it in
-  // this free list.
-  // `cached_blocks_[i]` points to the free list for blocks of size `8+2^(i+3)`.
-  // The array of freelists is grown when needed in `ReturnArrayMemory()`.
-  struct CachedBlock {
-    // Simple linked list.
-    CachedBlock* next;
-  };
-  uint8_t cached_block_length_ = 0;
-  CachedBlock** cached_blocks_ = nullptr;
-
-  // Constructor is private as only New() should be used.
-  inline SerialArena(Block* b, void* owner, ThreadSafeArenaStats* stats);
-  void* AllocateAlignedFallback(size_t n, const AllocationPolicy* policy);
-  std::pair<void*, CleanupNode*> AllocateAlignedWithCleanupFallback(
-      size_t n, const AllocationPolicy* policy);
-  void AllocateNewBlock(size_t n, const AllocationPolicy* policy);
-
-  std::pair<void*, CleanupNode*> CreatePair(void* ptr, CleanupNode* node) {
-    return {ptr, node};
-  }
-
- public:
-  static constexpr size_t kBlockHeaderSize = AlignUpTo8(sizeof(Block));
-  static constexpr size_t kCleanupSize = AlignUpTo8(sizeof(CleanupNode));
-};
-
-// Tag type used to invoke the constructor of message-owned arena.
-// Only message-owned arenas use this constructor for creation.
-// Such constructors are internal implementation details of the library.
-struct MessageOwned {
-  explicit MessageOwned() = default;
-};
-
-// This class provides the core Arena memory allocation library. Different
-// implementations only need to implement the public interface below.
-// Arena is not a template type as that would only be useful if all protos
-// in turn would be templates, which will/cannot happen. However separating
-// the memory allocation part from the cruft of the API users expect we can
-// use #ifdef the select the best implementation based on hardware / OS.
-class PROTOBUF_EXPORT ThreadSafeArena {
- public:
-  ThreadSafeArena() { Init(); }
-
-  // Constructor solely used by message-owned arena.
-  ThreadSafeArena(internal::MessageOwned) : tag_and_id_(kMessageOwnedArena) {
-    Init();
-  }
-
-  ThreadSafeArena(char* mem, size_t size) { InitializeFrom(mem, size); }
-
-  explicit ThreadSafeArena(void* mem, size_t size,
-                           const AllocationPolicy& policy) {
-    InitializeWithPolicy(mem, size, policy);
-  }
-
-  // Destructor deletes all owned heap allocated objects, and destructs objects
-  // that have non-trivial destructors, except for proto2 message objects whose
-  // destructors can be skipped. Also, frees all blocks except the initial block
-  // if it was passed in.
-  ~ThreadSafeArena();
-
-  uint64_t Reset();
-
-  uint64_t SpaceAllocated() const;
-  uint64_t SpaceUsed() const;
-
-  template <AllocationClient alloc_client = AllocationClient::kDefault>
-  void* AllocateAligned(size_t n, const std::type_info* type) {
-    SerialArena* arena;
-    if (PROTOBUF_PREDICT_TRUE(!alloc_policy_.should_record_allocs() &&
-                              GetSerialArenaFast(&arena))) {
-      return arena->AllocateAligned<alloc_client>(n, AllocPolicy());
-    } else {
-      return AllocateAlignedFallback(n, type);
-    }
-  }
-
-  void ReturnArrayMemory(void* p, size_t size) {
-    SerialArena* arena;
-    if (PROTOBUF_PREDICT_TRUE(GetSerialArenaFast(&arena))) {
-      arena->ReturnArrayMemory(p, size);
-    }
-  }
-
-  // This function allocates n bytes if the common happy case is true and
-  // returns true. Otherwise does nothing and returns false. This strange
-  // semantics is necessary to allow callers to program functions that only
-  // have fallback function calls in tail position. This substantially improves
-  // code for the happy path.
-  PROTOBUF_NDEBUG_INLINE bool MaybeAllocateAligned(size_t n, void** out) {
-    SerialArena* arena;
-    if (PROTOBUF_PREDICT_TRUE(!alloc_policy_.should_record_allocs() &&
-                              GetSerialArenaFromThreadCache(&arena))) {
-      return arena->MaybeAllocateAligned(n, out);
-    }
-    return false;
-  }
-
-  std::pair<void*, SerialArena::CleanupNode*> AllocateAlignedWithCleanup(
-      size_t n, const std::type_info* type);
-
-  // Add object pointer and cleanup function pointer to the list.
-  void AddCleanup(void* elem, void (*cleanup)(void*));
-
-  // Checks whether this arena is message-owned.
-  PROTOBUF_ALWAYS_INLINE bool IsMessageOwned() const {
-    return tag_and_id_ & kMessageOwnedArena;
-  }
-
- private:
-  // Unique for each arena. Changes on Reset().
-  uint64_t tag_and_id_ = 0;
-  // The LSB of tag_and_id_ indicates if the arena is message-owned.
-  enum : uint64_t { kMessageOwnedArena = 1 };
-
-  TaggedAllocationPolicyPtr alloc_policy_;  // Tagged pointer to AllocPolicy.
-
-  static_assert(std::is_trivially_destructible<SerialArena>{},
-                "SerialArena needs to be trivially destructible.");
-  // Pointer to a linked list of SerialArena.
-  std::atomic<SerialArena*> threads_;
-  std::atomic<SerialArena*> hint_;  // Fast thread-local block access
-
-  const AllocationPolicy* AllocPolicy() const { return alloc_policy_.get(); }
-  void InitializeFrom(void* mem, size_t size);
-  void InitializeWithPolicy(void* mem, size_t size, AllocationPolicy policy);
-  void* AllocateAlignedFallback(size_t n, const std::type_info* type);
-  std::pair<void*, SerialArena::CleanupNode*>
-  AllocateAlignedWithCleanupFallback(size_t n, const std::type_info* type);
-
-  void Init();
-  void SetInitialBlock(void* mem, size_t size);
-
-  // Delete or Destruct all objects owned by the arena.
-  void CleanupList();
-
-  inline uint64_t LifeCycleId() const {
-    return tag_and_id_ & ~kMessageOwnedArena;
-  }
-
-  inline void CacheSerialArena(SerialArena* serial) {
-    thread_cache().last_serial_arena = serial;
-    thread_cache().last_lifecycle_id_seen = tag_and_id_;
-    // TODO(haberman): evaluate whether we would gain efficiency by getting rid
-    // of hint_.  It's the only write we do to ThreadSafeArena in the allocation
-    // path, which will dirty the cache line.
-
-    hint_.store(serial, std::memory_order_release);
-  }
-
-  PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFast(SerialArena** arena) {
-    if (GetSerialArenaFromThreadCache(arena)) return true;
-
-    // Check whether we own the last accessed SerialArena on this arena.  This
-    // fast path optimizes the case where a single thread uses multiple arenas.
-    ThreadCache* tc = &thread_cache();
-    SerialArena* serial = hint_.load(std::memory_order_acquire);
-    if (PROTOBUF_PREDICT_TRUE(serial != nullptr && serial->owner() == tc)) {
-      *arena = serial;
-      return true;
-    }
-    return false;
-  }
-
-  PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFromThreadCache(
-      SerialArena** arena) {
-    // If this thread already owns a block in this arena then try to use that.
-    // This fast path optimizes the case where multiple threads allocate from
-    // the same arena.
-    ThreadCache* tc = &thread_cache();
-    if (PROTOBUF_PREDICT_TRUE(tc->last_lifecycle_id_seen == tag_and_id_)) {
-      *arena = tc->last_serial_arena;
-      return true;
-    }
-    return false;
-  }
-  SerialArena* GetSerialArenaFallback(void* me);
-
-  template <typename Functor>
-  void PerSerialArena(Functor fn) {
-    // By omitting an Acquire barrier we ensure that any user code that doesn't
-    // properly synchronize Reset() or the destructor will throw a TSAN warning.
-    SerialArena* serial = threads_.load(std::memory_order_relaxed);
-
-    for (; serial; serial = serial->next()) fn(serial);
-  }
-
-  // Releases all memory except the first block which it returns. The first
-  // block might be owned by the user and thus need some extra checks before
-  // deleting.
-  SerialArena::Memory Free(size_t* space_allocated);
+                    return CreatePair(ret, reinterpret_cast<CleanupNode*>(limit_));
+                }
+
+            public:
+                void AddCleanup(void* elem, void (*cleanup)(void*), const AllocationPolicy* policy)
+                {
+                    auto res = AllocateAlignedWithCleanup(0, policy);
+                    res.second->elem = elem;
+                    res.second->cleanup = cleanup;
+                }
+
+                void* owner() const
+                {
+                    return owner_;
+                }
+                SerialArena* next() const
+                {
+                    return next_;
+                }
+                void set_next(SerialArena* next)
+                {
+                    next_ = next;
+                }
+
+            private:
+                friend class ThreadSafeArena;
+                friend class ArenaBenchmark;
+
+                // Creates a new SerialArena inside mem using the remaining memory as for
+                // future allocations.
+                static SerialArena* New(SerialArena::Memory mem, void* owner, ThreadSafeArenaStats* stats);
+                // Free SerialArena returning the memory passed in to New
+                template<typename Deallocator>
+                Memory Free(Deallocator deallocator);
+
+                // Blocks are variable length malloc-ed objects.  The following structure
+                // describes the common header for all blocks.
+                struct Block
+                {
+                    Block(Block* next, size_t size) :
+                        next(next),
+                        size(size),
+                        start(nullptr)
+                    {
+                    }
+
+                    char* Pointer(size_t n)
+                    {
+                        GOOGLE_DCHECK(n <= size);
+                        return reinterpret_cast<char*>(this) + n;
+                    }
+
+                    Block* const next;
+                    const size_t size;
+                    CleanupNode* start;
+                    // data follows
+                };
+
+                void* owner_;            // &ThreadCache of this thread;
+                Block* head_;            // Head of linked list of blocks.
+                SerialArena* next_;      // Next SerialArena in this linked list.
+                size_t space_used_ = 0;  // Necessary for metrics.
+                std::atomic<size_t> space_allocated_;
+
+                // Next pointer to allocate from.  Always 8-byte aligned.  Points inside
+                // head_ (and head_->pos will always be non-canonical).  We keep these
+                // here to reduce indirection.
+                char* ptr_;
+                // Limiting address up to which memory can be allocated from the head block.
+                char* limit_;
+                // For holding sampling information.  The pointer is owned by the
+                // ThreadSafeArena that holds this serial arena.
+                ThreadSafeArenaStats* arena_stats_;
+
+                // Repeated*Field and Arena play together to reduce memory consumption by
+                // reusing blocks. Currently, natural growth of the repeated field types makes
+                // them allocate blocks of size `8 + 2^N, N>=3`.
+                // When the repeated field grows returns the previous block and we put it in
+                // this free list.
+                // `cached_blocks_[i]` points to the free list for blocks of size `8+2^(i+3)`.
+                // The array of freelists is grown when needed in `ReturnArrayMemory()`.
+                struct CachedBlock
+                {
+                    // Simple linked list.
+                    CachedBlock* next;
+                };
+                uint8_t cached_block_length_ = 0;
+                CachedBlock** cached_blocks_ = nullptr;
+
+                // Constructor is private as only New() should be used.
+                inline SerialArena(Block* b, void* owner, ThreadSafeArenaStats* stats);
+                void* AllocateAlignedFallback(size_t n, const AllocationPolicy* policy);
+                std::pair<void*, CleanupNode*> AllocateAlignedWithCleanupFallback(
+                    size_t n, const AllocationPolicy* policy
+                );
+                void AllocateNewBlock(size_t n, const AllocationPolicy* policy);
+
+                std::pair<void*, CleanupNode*> CreatePair(void* ptr, CleanupNode* node)
+                {
+                    return {ptr, node};
+                }
+
+            public:
+                static constexpr size_t kBlockHeaderSize = AlignUpTo8(sizeof(Block));
+                static constexpr size_t kCleanupSize = AlignUpTo8(sizeof(CleanupNode));
+            };
+
+            // Tag type used to invoke the constructor of message-owned arena.
+            // Only message-owned arenas use this constructor for creation.
+            // Such constructors are internal implementation details of the library.
+            struct MessageOwned
+            {
+                explicit MessageOwned() = default;
+            };
+
+            // This class provides the core Arena memory allocation library. Different
+            // implementations only need to implement the public interface below.
+            // Arena is not a template type as that would only be useful if all protos
+            // in turn would be templates, which will/cannot happen. However separating
+            // the memory allocation part from the cruft of the API users expect we can
+            // use #ifdef the select the best implementation based on hardware / OS.
+            class PROTOBUF_EXPORT ThreadSafeArena
+            {
+            public:
+                ThreadSafeArena()
+                {
+                    Init();
+                }
+
+                // Constructor solely used by message-owned arena.
+                ThreadSafeArena(internal::MessageOwned) :
+                    tag_and_id_(kMessageOwnedArena)
+                {
+                    Init();
+                }
+
+                ThreadSafeArena(char* mem, size_t size)
+                {
+                    InitializeFrom(mem, size);
+                }
+
+                explicit ThreadSafeArena(void* mem, size_t size, const AllocationPolicy& policy)
+                {
+                    InitializeWithPolicy(mem, size, policy);
+                }
+
+                // Destructor deletes all owned heap allocated objects, and destructs objects
+                // that have non-trivial destructors, except for proto2 message objects whose
+                // destructors can be skipped. Also, frees all blocks except the initial block
+                // if it was passed in.
+                ~ThreadSafeArena();
+
+                uint64_t Reset();
+
+                uint64_t SpaceAllocated() const;
+                uint64_t SpaceUsed() const;
+
+                template<AllocationClient alloc_client = AllocationClient::kDefault>
+                void* AllocateAligned(size_t n, const std::type_info* type)
+                {
+                    SerialArena* arena;
+                    if (PROTOBUF_PREDICT_TRUE(!alloc_policy_.should_record_allocs() && GetSerialArenaFast(&arena)))
+                    {
+                        return arena->AllocateAligned<alloc_client>(n, AllocPolicy());
+                    }
+                    else
+                    {
+                        return AllocateAlignedFallback(n, type);
+                    }
+                }
+
+                void ReturnArrayMemory(void* p, size_t size)
+                {
+                    SerialArena* arena;
+                    if (PROTOBUF_PREDICT_TRUE(GetSerialArenaFast(&arena)))
+                    {
+                        arena->ReturnArrayMemory(p, size);
+                    }
+                }
+
+                // This function allocates n bytes if the common happy case is true and
+                // returns true. Otherwise does nothing and returns false. This strange
+                // semantics is necessary to allow callers to program functions that only
+                // have fallback function calls in tail position. This substantially improves
+                // code for the happy path.
+                PROTOBUF_NDEBUG_INLINE bool MaybeAllocateAligned(size_t n, void** out)
+                {
+                    SerialArena* arena;
+                    if (PROTOBUF_PREDICT_TRUE(!alloc_policy_.should_record_allocs() && GetSerialArenaFromThreadCache(&arena)))
+                    {
+                        return arena->MaybeAllocateAligned(n, out);
+                    }
+                    return false;
+                }
+
+                std::pair<void*, SerialArena::CleanupNode*> AllocateAlignedWithCleanup(
+                    size_t n, const std::type_info* type
+                );
+
+                // Add object pointer and cleanup function pointer to the list.
+                void AddCleanup(void* elem, void (*cleanup)(void*));
+
+                // Checks whether this arena is message-owned.
+                PROTOBUF_ALWAYS_INLINE bool IsMessageOwned() const
+                {
+                    return tag_and_id_ & kMessageOwnedArena;
+                }
+
+            private:
+                // Unique for each arena. Changes on Reset().
+                uint64_t tag_and_id_ = 0;
+                // The LSB of tag_and_id_ indicates if the arena is message-owned.
+                enum : uint64_t
+                {
+                    kMessageOwnedArena = 1
+                };
+
+                TaggedAllocationPolicyPtr alloc_policy_;  // Tagged pointer to AllocPolicy.
+
+                static_assert(std::is_trivially_destructible<SerialArena>{}, "SerialArena needs to be trivially destructible.");
+                // Pointer to a linked list of SerialArena.
+                std::atomic<SerialArena*> threads_;
+                std::atomic<SerialArena*> hint_;  // Fast thread-local block access
+
+                const AllocationPolicy* AllocPolicy() const
+                {
+                    return alloc_policy_.get();
+                }
+                void InitializeFrom(void* mem, size_t size);
+                void InitializeWithPolicy(void* mem, size_t size, AllocationPolicy policy);
+                void* AllocateAlignedFallback(size_t n, const std::type_info* type);
+                std::pair<void*, SerialArena::CleanupNode*>
+                    AllocateAlignedWithCleanupFallback(size_t n, const std::type_info* type);
+
+                void Init();
+                void SetInitialBlock(void* mem, size_t size);
+
+                // Delete or Destruct all objects owned by the arena.
+                void CleanupList();
+
+                inline uint64_t LifeCycleId() const
+                {
+                    return tag_and_id_ & ~kMessageOwnedArena;
+                }
+
+                inline void CacheSerialArena(SerialArena* serial)
+                {
+                    thread_cache().last_serial_arena = serial;
+                    thread_cache().last_lifecycle_id_seen = tag_and_id_;
+                    // TODO(haberman): evaluate whether we would gain efficiency by getting rid
+                    // of hint_.  It's the only write we do to ThreadSafeArena in the allocation
+                    // path, which will dirty the cache line.
+
+                    hint_.store(serial, std::memory_order_release);
+                }
+
+                PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFast(SerialArena** arena)
+                {
+                    if (GetSerialArenaFromThreadCache(arena))
+                        return true;
+
+                    // Check whether we own the last accessed SerialArena on this arena.  This
+                    // fast path optimizes the case where a single thread uses multiple arenas.
+                    ThreadCache* tc = &thread_cache();
+                    SerialArena* serial = hint_.load(std::memory_order_acquire);
+                    if (PROTOBUF_PREDICT_TRUE(serial != nullptr && serial->owner() == tc))
+                    {
+                        *arena = serial;
+                        return true;
+                    }
+                    return false;
+                }
+
+                PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFromThreadCache(
+                    SerialArena** arena
+                )
+                {
+                    // If this thread already owns a block in this arena then try to use that.
+                    // This fast path optimizes the case where multiple threads allocate from
+                    // the same arena.
+                    ThreadCache* tc = &thread_cache();
+                    if (PROTOBUF_PREDICT_TRUE(tc->last_lifecycle_id_seen == tag_and_id_))
+                    {
+                        *arena = tc->last_serial_arena;
+                        return true;
+                    }
+                    return false;
+                }
+                SerialArena* GetSerialArenaFallback(void* me);
+
+                template<typename Functor>
+                void PerSerialArena(Functor fn)
+                {
+                    // By omitting an Acquire barrier we ensure that any user code that doesn't
+                    // properly synchronize Reset() or the destructor will throw a TSAN warning.
+                    SerialArena* serial = threads_.load(std::memory_order_relaxed);
+
+                    for (; serial; serial = serial->next())
+                        fn(serial);
+                }
+
+                // Releases all memory except the first block which it returns. The first
+                // block might be owned by the user and thus need some extra checks before
+                // deleting.
+                SerialArena::Memory Free(size_t* space_allocated);
 
 #ifdef _MSC_VER
 #pragma warning(disable : 4324)
 #endif
-  struct alignas(kCacheAlignment) ThreadCache {
+                struct alignas(kCacheAlignment) ThreadCache
+                {
 #if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
-    // If we are using the ThreadLocalStorage class to store the ThreadCache,
-    // then the ThreadCache's default constructor has to be responsible for
-    // initializing it.
-    ThreadCache()
-        : next_lifecycle_id(0),
-          last_lifecycle_id_seen(-1),
-          last_serial_arena(nullptr) {}
+                    // If we are using the ThreadLocalStorage class to store the ThreadCache,
+                    // then the ThreadCache's default constructor has to be responsible for
+                    // initializing it.
+                    ThreadCache() :
+                        next_lifecycle_id(0),
+                        last_lifecycle_id_seen(-1),
+                        last_serial_arena(nullptr)
+                    {
+                    }
 #endif
 
-    // Number of per-thread lifecycle IDs to reserve. Must be power of two.
-    // To reduce contention on a global atomic, each thread reserves a batch of
-    // IDs.  The following number is calculated based on a stress test with
-    // ~6500 threads all frequently allocating a new arena.
-    static constexpr size_t kPerThreadIds = 256;
-    // Next lifecycle ID available to this thread. We need to reserve a new
-    // batch, if `next_lifecycle_id & (kPerThreadIds - 1) == 0`.
-    uint64_t next_lifecycle_id;
-    // The ThreadCache is considered valid as long as this matches the
-    // lifecycle_id of the arena being used.
-    uint64_t last_lifecycle_id_seen;
-    SerialArena* last_serial_arena;
-  };
-
-  // Lifecycle_id can be highly contended variable in a situation of lots of
-  // arena creation. Make sure that other global variables are not sharing the
-  // cacheline.
+                    // Number of per-thread lifecycle IDs to reserve. Must be power of two.
+                    // To reduce contention on a global atomic, each thread reserves a batch of
+                    // IDs.  The following number is calculated based on a stress test with
+                    // ~6500 threads all frequently allocating a new arena.
+                    static constexpr size_t kPerThreadIds = 256;
+                    // Next lifecycle ID available to this thread. We need to reserve a new
+                    // batch, if `next_lifecycle_id & (kPerThreadIds - 1) == 0`.
+                    uint64_t next_lifecycle_id;
+                    // The ThreadCache is considered valid as long as this matches the
+                    // lifecycle_id of the arena being used.
+                    uint64_t last_lifecycle_id_seen;
+                    SerialArena* last_serial_arena;
+                };
+
+                // Lifecycle_id can be highly contended variable in a situation of lots of
+                // arena creation. Make sure that other global variables are not sharing the
+                // cacheline.
 #ifdef _MSC_VER
 #pragma warning(disable : 4324)
 #endif
-  struct alignas(kCacheAlignment) CacheAlignedLifecycleIdGenerator {
-    std::atomic<LifecycleIdAtomic> id;
-  };
-  static CacheAlignedLifecycleIdGenerator lifecycle_id_generator_;
+                struct alignas(kCacheAlignment) CacheAlignedLifecycleIdGenerator
+                {
+                    std::atomic<LifecycleIdAtomic> id;
+                };
+                static CacheAlignedLifecycleIdGenerator lifecycle_id_generator_;
 #if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
-  // iOS does not support __thread keyword so we use a custom thread local
-  // storage class we implemented.
-  static ThreadCache& thread_cache();
+                // iOS does not support __thread keyword so we use a custom thread local
+                // storage class we implemented.
+                static ThreadCache& thread_cache();
 #elif defined(PROTOBUF_USE_DLLS)
-  // Thread local variables cannot be exposed through DLL interface but we can
-  // wrap them in static functions.
-  static ThreadCache& thread_cache();
+                // Thread local variables cannot be exposed through DLL interface but we can
+                // wrap them in static functions.
+                static ThreadCache& thread_cache();
 #else
-  static PROTOBUF_THREAD_LOCAL ThreadCache thread_cache_;
-  static ThreadCache& thread_cache() { return thread_cache_; }
+                static PROTOBUF_THREAD_LOCAL ThreadCache thread_cache_;
+                static ThreadCache& thread_cache()
+                {
+                    return thread_cache_;
+                }
 #endif
 
-  ThreadSafeArenaStatsHandle arena_stats_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadSafeArena);
-  // All protos have pointers back to the arena hence Arena must have
-  // pointer stability.
-  ThreadSafeArena(ThreadSafeArena&&) = delete;
-  ThreadSafeArena& operator=(ThreadSafeArena&&) = delete;
-
- public:
-  // kBlockHeaderSize is sizeof(Block), aligned up to the nearest multiple of 8
-  // to protect the invariant that pos is always at a multiple of 8.
-  static constexpr size_t kBlockHeaderSize = SerialArena::kBlockHeaderSize;
-  static constexpr size_t kSerialArenaSize =
-      (sizeof(SerialArena) + 7) & static_cast<size_t>(-8);
-  static_assert(kBlockHeaderSize % 8 == 0,
-                "kBlockHeaderSize must be a multiple of 8.");
-  static_assert(kSerialArenaSize % 8 == 0,
-                "kSerialArenaSize must be a multiple of 8.");
-};
-
-}  // namespace internal
-}  // namespace protobuf
+                ThreadSafeArenaStatsHandle arena_stats_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadSafeArena);
+                // All protos have pointers back to the arena hence Arena must have
+                // pointer stability.
+                ThreadSafeArena(ThreadSafeArena&&) = delete;
+                ThreadSafeArena& operator=(ThreadSafeArena&&) = delete;
+
+            public:
+                // kBlockHeaderSize is sizeof(Block), aligned up to the nearest multiple of 8
+                // to protect the invariant that pos is always at a multiple of 8.
+                static constexpr size_t kBlockHeaderSize = SerialArena::kBlockHeaderSize;
+                static constexpr size_t kSerialArenaSize =
+                    (sizeof(SerialArena) + 7) & static_cast<size_t>(-8);
+                static_assert(kBlockHeaderSize % 8 == 0, "kBlockHeaderSize must be a multiple of 8.");
+                static_assert(kSerialArenaSize % 8 == 0, "kSerialArenaSize must be a multiple of 8.");
+            };
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/arenastring.h b/CAPI/cpp/grpc/include/google/protobuf/arenastring.h
index 6bc8395..9b95e46 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/arenastring.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/arenastring.h
@@ -49,430 +49,502 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-
-namespace google {
-namespace protobuf {
-namespace internal {
-class EpsCopyInputStream;
-
-class SwapFieldHelper;
-
-// Declared in message_lite.h
-PROTOBUF_EXPORT extern ExplicitlyConstructedArenaString
-    fixed_address_empty_string;
-
-// Lazy string instance to support string fields with non-empty default.
-// These are initialized on the first call to .get().
-class PROTOBUF_EXPORT LazyString {
- public:
-  // We explicitly make LazyString an aggregate so that MSVC can do constant
-  // initialization on it without marking it `constexpr`.
-  // We do not want to use `constexpr` because it makes it harder to have extern
-  // storage for it and causes library bloat.
-  struct InitValue {
-    const char* ptr;
-    size_t size;
-  };
-  // We keep a union of the initialization value and the std::string to save on
-  // space. We don't need the string array after Init() is done.
-  union {
-    mutable InitValue init_value_;
-    alignas(std::string) mutable char string_buf_[sizeof(std::string)];
-  };
-  mutable std::atomic<const std::string*> inited_;
-
-  const std::string& get() const {
-    // This check generates less code than a call-once invocation.
-    auto* res = inited_.load(std::memory_order_acquire);
-    if (PROTOBUF_PREDICT_FALSE(res == nullptr)) return Init();
-    return *res;
-  }
-
- private:
-  // Initialize the string in `string_buf_`, update `inited_` and return it.
-  // We return it here to avoid having to read it again in the inlined code.
-  const std::string& Init() const;
-};
-
-class TaggedStringPtr {
- public:
-  // Bit flags qualifying string properties. We can use 2 bits as
-  // ptr_ is guaranteed and enforced to be aligned on 4 byte boundaries.
-  enum Flags {
-    kArenaBit = 0x1,      // ptr is arena allocated
-    kMutableBit = 0x2,    // ptr contents are fully mutable
-    kMask = 0x3           // Bit mask
-  };
-
-  // Composed logical types
-  enum Type {
-    // Default strings are immutable and never owned.
-    kDefault = 0,
-
-    // Allocated strings are mutable and (as the name implies) owned.
-    // A heap allocated string must be deleted.
-    kAllocated = kMutableBit,
-
-    // Mutable arena strings are strings where the string instance is owned
-    // by the arena, but the string contents itself are owned by the string
-    // instance. Mutable arena string instances need to be destroyed which is
-    // typically done through a cleanup action added to the arena owning it.
-    kMutableArena = kArenaBit | kMutableBit,
-
-    // Fixed size arena strings are strings where both the string instance and
-    // the string contents are fully owned by the arena. Fixed size arena
-    // strings are a platform and c++ library specific customization. Fixed
-    // size arena strings are immutable, with the exception of custom internal
-    // updates to the content that fit inside the existing capacity.
-    // Fixed size arena strings must never be deleted or destroyed.
-    kFixedSizeArena = kArenaBit,
-  };
-
-  TaggedStringPtr() = default;
-  explicit constexpr TaggedStringPtr(ExplicitlyConstructedArenaString* ptr)
-      : ptr_(ptr) {}
-
-  // Sets the value to `p`, tagging the value as being a 'default' value.
-  // See documentation for kDefault for more info.
-  inline const std::string* SetDefault(const std::string* p) {
-    return TagAs(kDefault, const_cast<std::string*>(p));
-  }
-
-  // Sets the value to `p`, tagging the value as a heap allocated value.
-  // Allocated strings are mutable and (as the name implies) owned.
-  // `p` must not be null
-  inline std::string* SetAllocated(std::string* p) {
-    return TagAs(kAllocated, p);
-  }
-
-  // Sets the value to `p`, tagging the value as a fixed size arena string.
-  // See documentation for kFixedSizeArena for more info.
-  // `p` must not be null
-  inline std::string* SetFixedSizeArena(std::string* p) {
-    return TagAs(kFixedSizeArena, p);
-  }
-
-  // Sets the value to `p`, tagging the value as a mutable arena string.
-  // See documentation for kMutableArena for more info.
-  // `p` must not be null
-  inline std::string* SetMutableArena(std::string* p) {
-    return TagAs(kMutableArena, p);
-  }
-
-  // Returns true if the contents of the current string are fully mutable.
-  inline bool IsMutable() const { return as_int() & kMutableBit; }
-
-  // Returns true if the current string is an immutable default value.
-  inline bool IsDefault() const { return (as_int() & kMask) == kDefault; }
-
-  // If the current string is a heap-allocated mutable value, returns a pointer
-  // to it.  Returns nullptr otherwise.
-  inline std::string *GetIfAllocated() const {
-    auto allocated = as_int() ^ kAllocated;
-    if (allocated & kMask) return nullptr;
-
-    auto ptr = reinterpret_cast<std::string*>(allocated);
-    PROTOBUF_ASSUME(ptr != nullptr);
-    return ptr;
-  }
-
-  // Returns true if the current string is an arena allocated value.
-  // This means it's either a mutable or fixed size arena string.
-  inline bool IsArena() const { return as_int() & kArenaBit; }
-
-  // Returns true if the current string is a fixed size arena allocated value.
-  inline bool IsFixedSizeArena() const {
-    return (as_int() & kMask) == kFixedSizeArena;
-  }
-
-  // Returns the contained string pointer.
-  inline std::string* Get() const {
-    return reinterpret_cast<std::string*>(as_int() & ~kMask);
-  }
-
-  // Returns true if the contained pointer is null, indicating some error.
-  // The Null value is only used during parsing for temporary values.
-  // A persisted ArenaStringPtr value is never null.
-  inline bool IsNull() { return ptr_ == nullptr; }
-
- private:
-  static inline void assert_aligned(const void* p) {
-    GOOGLE_DCHECK_EQ(reinterpret_cast<uintptr_t>(p) & kMask, 0UL);
-  }
-
-  inline std::string* TagAs(Type type, std::string* p) {
-    GOOGLE_DCHECK(p != nullptr);
-    assert_aligned(p);
-    ptr_ = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(p) | type);
-    return p;
-  }
-
-  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
-  void* ptr_;
-};
-
-static_assert(std::is_trivial<TaggedStringPtr>::value,
-              "TaggedStringPtr must be trivial");
-
-// This class encapsulates a pointer to a std::string with or without arena
-// owned contents, tagged by the bottom bits of the string pointer. It is a
-// high-level wrapper that almost directly corresponds to the interface required
-// by string fields in generated code. It replaces the old std::string* pointer
-// in such cases.
-//
-// The string pointer is tagged to be either a default, externally owned value,
-// a mutable heap allocated value, or an arena allocated value. The object uses
-// a single global instance of an empty string that is used as the initial
-// default value. Fields that have empty default values directly use this global
-// default. Fields that have non empty default values are supported through
-// lazily initialized default values managed by the LazyString class.
-//
-// Generated code and reflection code both ensure that ptr_ is never null.
-// Because ArenaStringPtr is used in oneof unions, its constructor is a NOP and
-// the field is always manually initialized via method calls.
-//
-// See TaggedStringPtr for more information about the types of string values
-// being held, and the mutable and ownership invariants for each type.
-struct PROTOBUF_EXPORT ArenaStringPtr {
-  ArenaStringPtr() = default;
-  constexpr ArenaStringPtr(ExplicitlyConstructedArenaString* default_value,
-                           ConstantInitialized)
-      : tagged_ptr_(default_value) {}
-
-  // Called from generated code / reflection runtime only. Resets value to point
-  // to a default string pointer, with the semantics that this ArenaStringPtr
-  // does not own the pointed-to memory. Disregards initial value of ptr_ (so
-  // this is the *ONLY* safe method to call after construction or when
-  // reinitializing after becoming the active field in a oneof union).
-  inline void InitDefault();
-
-  // Similar to `InitDefault` except that it allows the default value to be
-  // initialized to an externally owned string. This method is called from
-  // parsing code. `str` must not be null and outlive this instance.
-  inline void InitExternal(const std::string* str);
-
-  // Called from generated code / reflection runtime only. Resets the value of
-  // this instances to the heap allocated value in `str`. `str` must not be
-  // null. Invokes `arena->Own(str)` to transfer ownership into the arena if
-  // `arena` is not null, else, `str` will be owned by ArenaStringPtr. This
-  // function should only be used to initialize a ArenaStringPtr or on an
-  // instance known to not carry any heap allocated value.
-  inline void InitAllocated(std::string* str, Arena* arena);
-
-  void Set(ConstStringParam value, Arena* arena);
-  void Set(std::string&& value, Arena* arena);
-  void Set(const char* s, Arena* arena);
-  void Set(const char* s, size_t n, Arena* arena);
-
-  void SetBytes(ConstStringParam value, Arena* arena);
-  void SetBytes(std::string&& value, Arena* arena);
-  void SetBytes(const char* s, Arena* arena);
-  void SetBytes(const void* p, size_t n, Arena* arena);
-
-  template <typename RefWrappedType>
-  void Set(std::reference_wrapper<RefWrappedType> const_string_ref,
-           ::google::protobuf::Arena* arena) {
-    Set(const_string_ref.get(), arena);
-  }
-
-  // Returns a mutable std::string reference.
-  // The version accepting a `LazyString` value is used in the generated code to
-  // initialize mutable copies for fields with a non-empty default where the
-  // default value is lazily initialized.
-  std::string* Mutable(Arena* arena);
-  std::string* Mutable(const LazyString& default_value, Arena* arena);
-
-  // Gets a mutable pointer with unspecified contents.
-  // This function is identical to Mutable(), except it is optimized for the
-  // case where the caller is not interested in the current contents. For
-  // example, if the current field is not mutable, it will re-initialize the
-  // value with an empty string rather than a (non-empty) default value.
-  // Likewise, if the current value is a fixed size arena string with contents,
-  // it will be initialized into an empty mutable arena string.
-  std::string* MutableNoCopy(Arena* arena);
-
-  // Basic accessors.
-  PROTOBUF_NDEBUG_INLINE const std::string& Get() const {
-    // Unconditionally mask away the tag.
-    return *tagged_ptr_.Get();
-  }
-
-  // Returns a pointer to the stored contents for this instance.
-  // This method is for internal debugging and tracking purposes only.
-  PROTOBUF_NDEBUG_INLINE const std::string* UnsafeGetPointer() const
-      PROTOBUF_RETURNS_NONNULL {
-    return tagged_ptr_.Get();
-  }
-
-  // Release returns a std::string* instance that is heap-allocated and is not
-  // Own()'d by any arena. If the field is not set, this returns nullptr. The
-  // caller retains ownership. Clears this field back to the default state.
-  // Used to implement release_<field>() methods on generated classes.
-  PROTOBUF_NODISCARD std::string* Release();
-
-  // Takes a std::string that is heap-allocated, and takes ownership. The
-  // std::string's destructor is registered with the arena. Used to implement
-  // set_allocated_<field> in generated classes.
-  void SetAllocated(std::string* value, Arena* arena);
-
-  // Frees storage (if not on an arena).
-  void Destroy();
-
-  // Clears content, but keeps allocated std::string, to avoid the overhead of
-  // heap operations. After this returns, the content (as seen by the user) will
-  // always be the empty std::string. Assumes that |default_value| is an empty
-  // std::string.
-  void ClearToEmpty();
-
-  // Clears content, assuming that the current value is not the empty
-  // string default.
-  void ClearNonDefaultToEmpty();
-
-  // Clears content, but keeps allocated std::string if arena != nullptr, to
-  // avoid the overhead of heap operations. After this returns, the content
-  // (as seen by the user) will always be equal to |default_value|.
-  void ClearToDefault(const LazyString& default_value, ::google::protobuf::Arena* arena);
-
-  // Swaps internal pointers. Arena-safety semantics: this is guarded by the
-  // logic in Swap()/UnsafeArenaSwap() at the message level, so this method is
-  // 'unsafe' if called directly.
-  inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(ArenaStringPtr* rhs,
-                                                         Arena* rhs_arena,
-                                                         ArenaStringPtr* lhs,
-                                                         Arena* lhs_arena);
-
-  // Internal setter used only at parse time to directly set a donated string
-  // value.
-  void UnsafeSetTaggedPointer(TaggedStringPtr value) { tagged_ptr_ = value; }
-  // Generated code only! An optimization, in certain cases the generated
-  // code is certain we can obtain a std::string with no default checks and
-  // tag tests.
-  std::string* UnsafeMutablePointer() PROTOBUF_RETURNS_NONNULL;
-
-  // Returns true if this instances holds an immutable default value.
-  inline bool IsDefault() const { return tagged_ptr_.IsDefault(); }
-
- private:
-  template <typename... Args>
-  inline std::string* NewString(Arena* arena, Args&&... args) {
-    if (arena == nullptr) {
-      auto* s = new std::string(std::forward<Args>(args)...);
-      return tagged_ptr_.SetAllocated(s);
-    } else {
-      auto* s = Arena::Create<std::string>(arena, std::forward<Args>(args)...);
-      return tagged_ptr_.SetMutableArena(s);
-    }
-  }
-
-  TaggedStringPtr tagged_ptr_;
-
-  bool IsFixedSizeArena() const { return false; }
-
-  // Swaps tagged pointer without debug hardening. This is to allow python
-  // protobuf to maintain pointer stability even in DEBUG builds.
-  inline PROTOBUF_NDEBUG_INLINE static void UnsafeShallowSwap(
-      ArenaStringPtr* rhs, ArenaStringPtr* lhs) {
-    std::swap(lhs->tagged_ptr_, rhs->tagged_ptr_);
-  }
-
-  friend class ::google::protobuf::internal::SwapFieldHelper;
-  friend class TcParser;
-
-  // Slow paths.
-
-  // MutableSlow requires that !IsString() || IsDefault
-  // Variadic to support 0 args for empty default and 1 arg for LazyString.
-  template <typename... Lazy>
-  std::string* MutableSlow(::google::protobuf::Arena* arena, const Lazy&... lazy_default);
-
-  friend class EpsCopyInputStream;
-};
-
-inline void ArenaStringPtr::InitDefault() {
-  tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string);
-}
-
-inline void ArenaStringPtr::InitExternal(const std::string* str) {
-  tagged_ptr_.SetDefault(str);
-}
-
-inline void ArenaStringPtr::InitAllocated(std::string* str, Arena* arena) {
-  if (arena != nullptr) {
-    tagged_ptr_.SetMutableArena(str);
-    arena->Own(str);
-  } else {
-    tagged_ptr_.SetAllocated(str);
-  }
-}
-
-inline void ArenaStringPtr::Set(const char* s, Arena* arena) {
-  Set(ConstStringParam{s}, arena);
-}
-
-inline void ArenaStringPtr::Set(const char* s, size_t n, Arena* arena) {
-  Set(ConstStringParam{s, n}, arena);
-}
-
-inline void ArenaStringPtr::SetBytes(ConstStringParam value, Arena* arena) {
-  Set(value, arena);
-}
-
-inline void ArenaStringPtr::SetBytes(std::string&& value, Arena* arena) {
-  Set(std::move(value), arena);
-}
-
-inline void ArenaStringPtr::SetBytes(const char* s, Arena* arena) {
-  Set(s, arena);
-}
-
-inline void ArenaStringPtr::SetBytes(const void* p, size_t n, Arena* arena) {
-  Set(ConstStringParam{static_cast<const char*>(p), n}, arena);
-}
-
-// Make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
-inline PROTOBUF_NDEBUG_INLINE void ArenaStringPtr::InternalSwap(  //
-    ArenaStringPtr* rhs, Arena* rhs_arena,                        //
-    ArenaStringPtr* lhs, Arena* lhs_arena) {
-  // Silence unused variable warnings in release buildls.
-  (void)rhs_arena;
-  (void)lhs_arena;
-  std::swap(lhs->tagged_ptr_, rhs->tagged_ptr_);
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+            class EpsCopyInputStream;
+
+            class SwapFieldHelper;
+
+            // Declared in message_lite.h
+            PROTOBUF_EXPORT extern ExplicitlyConstructedArenaString
+                fixed_address_empty_string;
+
+            // Lazy string instance to support string fields with non-empty default.
+            // These are initialized on the first call to .get().
+            class PROTOBUF_EXPORT LazyString
+            {
+            public:
+                // We explicitly make LazyString an aggregate so that MSVC can do constant
+                // initialization on it without marking it `constexpr`.
+                // We do not want to use `constexpr` because it makes it harder to have extern
+                // storage for it and causes library bloat.
+                struct InitValue
+                {
+                    const char* ptr;
+                    size_t size;
+                };
+                // We keep a union of the initialization value and the std::string to save on
+                // space. We don't need the string array after Init() is done.
+                union
+                {
+                    mutable InitValue init_value_;
+                    alignas(std::string) mutable char string_buf_[sizeof(std::string)];
+                };
+                mutable std::atomic<const std::string*> inited_;
+
+                const std::string& get() const
+                {
+                    // This check generates less code than a call-once invocation.
+                    auto* res = inited_.load(std::memory_order_acquire);
+                    if (PROTOBUF_PREDICT_FALSE(res == nullptr))
+                        return Init();
+                    return *res;
+                }
+
+            private:
+                // Initialize the string in `string_buf_`, update `inited_` and return it.
+                // We return it here to avoid having to read it again in the inlined code.
+                const std::string& Init() const;
+            };
+
+            class TaggedStringPtr
+            {
+            public:
+                // Bit flags qualifying string properties. We can use 2 bits as
+                // ptr_ is guaranteed and enforced to be aligned on 4 byte boundaries.
+                enum Flags
+                {
+                    kArenaBit = 0x1,    // ptr is arena allocated
+                    kMutableBit = 0x2,  // ptr contents are fully mutable
+                    kMask = 0x3         // Bit mask
+                };
+
+                // Composed logical types
+                enum Type
+                {
+                    // Default strings are immutable and never owned.
+                    kDefault = 0,
+
+                    // Allocated strings are mutable and (as the name implies) owned.
+                    // A heap allocated string must be deleted.
+                    kAllocated = kMutableBit,
+
+                    // Mutable arena strings are strings where the string instance is owned
+                    // by the arena, but the string contents itself are owned by the string
+                    // instance. Mutable arena string instances need to be destroyed which is
+                    // typically done through a cleanup action added to the arena owning it.
+                    kMutableArena = kArenaBit | kMutableBit,
+
+                    // Fixed size arena strings are strings where both the string instance and
+                    // the string contents are fully owned by the arena. Fixed size arena
+                    // strings are a platform and c++ library specific customization. Fixed
+                    // size arena strings are immutable, with the exception of custom internal
+                    // updates to the content that fit inside the existing capacity.
+                    // Fixed size arena strings must never be deleted or destroyed.
+                    kFixedSizeArena = kArenaBit,
+                };
+
+                TaggedStringPtr() = default;
+                explicit constexpr TaggedStringPtr(ExplicitlyConstructedArenaString* ptr) :
+                    ptr_(ptr)
+                {
+                }
+
+                // Sets the value to `p`, tagging the value as being a 'default' value.
+                // See documentation for kDefault for more info.
+                inline const std::string* SetDefault(const std::string* p)
+                {
+                    return TagAs(kDefault, const_cast<std::string*>(p));
+                }
+
+                // Sets the value to `p`, tagging the value as a heap allocated value.
+                // Allocated strings are mutable and (as the name implies) owned.
+                // `p` must not be null
+                inline std::string* SetAllocated(std::string* p)
+                {
+                    return TagAs(kAllocated, p);
+                }
+
+                // Sets the value to `p`, tagging the value as a fixed size arena string.
+                // See documentation for kFixedSizeArena for more info.
+                // `p` must not be null
+                inline std::string* SetFixedSizeArena(std::string* p)
+                {
+                    return TagAs(kFixedSizeArena, p);
+                }
+
+                // Sets the value to `p`, tagging the value as a mutable arena string.
+                // See documentation for kMutableArena for more info.
+                // `p` must not be null
+                inline std::string* SetMutableArena(std::string* p)
+                {
+                    return TagAs(kMutableArena, p);
+                }
+
+                // Returns true if the contents of the current string are fully mutable.
+                inline bool IsMutable() const
+                {
+                    return as_int() & kMutableBit;
+                }
+
+                // Returns true if the current string is an immutable default value.
+                inline bool IsDefault() const
+                {
+                    return (as_int() & kMask) == kDefault;
+                }
+
+                // If the current string is a heap-allocated mutable value, returns a pointer
+                // to it.  Returns nullptr otherwise.
+                inline std::string* GetIfAllocated() const
+                {
+                    auto allocated = as_int() ^ kAllocated;
+                    if (allocated & kMask)
+                        return nullptr;
+
+                    auto ptr = reinterpret_cast<std::string*>(allocated);
+                    PROTOBUF_ASSUME(ptr != nullptr);
+                    return ptr;
+                }
+
+                // Returns true if the current string is an arena allocated value.
+                // This means it's either a mutable or fixed size arena string.
+                inline bool IsArena() const
+                {
+                    return as_int() & kArenaBit;
+                }
+
+                // Returns true if the current string is a fixed size arena allocated value.
+                inline bool IsFixedSizeArena() const
+                {
+                    return (as_int() & kMask) == kFixedSizeArena;
+                }
+
+                // Returns the contained string pointer.
+                inline std::string* Get() const
+                {
+                    return reinterpret_cast<std::string*>(as_int() & ~kMask);
+                }
+
+                // Returns true if the contained pointer is null, indicating some error.
+                // The Null value is only used during parsing for temporary values.
+                // A persisted ArenaStringPtr value is never null.
+                inline bool IsNull()
+                {
+                    return ptr_ == nullptr;
+                }
+
+            private:
+                static inline void assert_aligned(const void* p)
+                {
+                    GOOGLE_DCHECK_EQ(reinterpret_cast<uintptr_t>(p) & kMask, 0UL);
+                }
+
+                inline std::string* TagAs(Type type, std::string* p)
+                {
+                    GOOGLE_DCHECK(p != nullptr);
+                    assert_aligned(p);
+                    ptr_ = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(p) | type);
+                    return p;
+                }
+
+                uintptr_t as_int() const
+                {
+                    return reinterpret_cast<uintptr_t>(ptr_);
+                }
+                void* ptr_;
+            };
+
+            static_assert(std::is_trivial<TaggedStringPtr>::value, "TaggedStringPtr must be trivial");
+
+            // This class encapsulates a pointer to a std::string with or without arena
+            // owned contents, tagged by the bottom bits of the string pointer. It is a
+            // high-level wrapper that almost directly corresponds to the interface required
+            // by string fields in generated code. It replaces the old std::string* pointer
+            // in such cases.
+            //
+            // The string pointer is tagged to be either a default, externally owned value,
+            // a mutable heap allocated value, or an arena allocated value. The object uses
+            // a single global instance of an empty string that is used as the initial
+            // default value. Fields that have empty default values directly use this global
+            // default. Fields that have non empty default values are supported through
+            // lazily initialized default values managed by the LazyString class.
+            //
+            // Generated code and reflection code both ensure that ptr_ is never null.
+            // Because ArenaStringPtr is used in oneof unions, its constructor is a NOP and
+            // the field is always manually initialized via method calls.
+            //
+            // See TaggedStringPtr for more information about the types of string values
+            // being held, and the mutable and ownership invariants for each type.
+            struct PROTOBUF_EXPORT ArenaStringPtr
+            {
+                ArenaStringPtr() = default;
+                constexpr ArenaStringPtr(ExplicitlyConstructedArenaString* default_value, ConstantInitialized) :
+                    tagged_ptr_(default_value)
+                {
+                }
+
+                // Called from generated code / reflection runtime only. Resets value to point
+                // to a default string pointer, with the semantics that this ArenaStringPtr
+                // does not own the pointed-to memory. Disregards initial value of ptr_ (so
+                // this is the *ONLY* safe method to call after construction or when
+                // reinitializing after becoming the active field in a oneof union).
+                inline void InitDefault();
+
+                // Similar to `InitDefault` except that it allows the default value to be
+                // initialized to an externally owned string. This method is called from
+                // parsing code. `str` must not be null and outlive this instance.
+                inline void InitExternal(const std::string* str);
+
+                // Called from generated code / reflection runtime only. Resets the value of
+                // this instances to the heap allocated value in `str`. `str` must not be
+                // null. Invokes `arena->Own(str)` to transfer ownership into the arena if
+                // `arena` is not null, else, `str` will be owned by ArenaStringPtr. This
+                // function should only be used to initialize a ArenaStringPtr or on an
+                // instance known to not carry any heap allocated value.
+                inline void InitAllocated(std::string* str, Arena* arena);
+
+                void Set(ConstStringParam value, Arena* arena);
+                void Set(std::string&& value, Arena* arena);
+                void Set(const char* s, Arena* arena);
+                void Set(const char* s, size_t n, Arena* arena);
+
+                void SetBytes(ConstStringParam value, Arena* arena);
+                void SetBytes(std::string&& value, Arena* arena);
+                void SetBytes(const char* s, Arena* arena);
+                void SetBytes(const void* p, size_t n, Arena* arena);
+
+                template<typename RefWrappedType>
+                void Set(std::reference_wrapper<RefWrappedType> const_string_ref, ::google::protobuf::Arena* arena)
+                {
+                    Set(const_string_ref.get(), arena);
+                }
+
+                // Returns a mutable std::string reference.
+                // The version accepting a `LazyString` value is used in the generated code to
+                // initialize mutable copies for fields with a non-empty default where the
+                // default value is lazily initialized.
+                std::string* Mutable(Arena* arena);
+                std::string* Mutable(const LazyString& default_value, Arena* arena);
+
+                // Gets a mutable pointer with unspecified contents.
+                // This function is identical to Mutable(), except it is optimized for the
+                // case where the caller is not interested in the current contents. For
+                // example, if the current field is not mutable, it will re-initialize the
+                // value with an empty string rather than a (non-empty) default value.
+                // Likewise, if the current value is a fixed size arena string with contents,
+                // it will be initialized into an empty mutable arena string.
+                std::string* MutableNoCopy(Arena* arena);
+
+                // Basic accessors.
+                PROTOBUF_NDEBUG_INLINE const std::string& Get() const
+                {
+                    // Unconditionally mask away the tag.
+                    return *tagged_ptr_.Get();
+                }
+
+                // Returns a pointer to the stored contents for this instance.
+                // This method is for internal debugging and tracking purposes only.
+                PROTOBUF_NDEBUG_INLINE const std::string* UnsafeGetPointer() const
+                    PROTOBUF_RETURNS_NONNULL
+                {
+                    return tagged_ptr_.Get();
+                }
+
+                // Release returns a std::string* instance that is heap-allocated and is not
+                // Own()'d by any arena. If the field is not set, this returns nullptr. The
+                // caller retains ownership. Clears this field back to the default state.
+                // Used to implement release_<field>() methods on generated classes.
+                PROTOBUF_NODISCARD std::string* Release();
+
+                // Takes a std::string that is heap-allocated, and takes ownership. The
+                // std::string's destructor is registered with the arena. Used to implement
+                // set_allocated_<field> in generated classes.
+                void SetAllocated(std::string* value, Arena* arena);
+
+                // Frees storage (if not on an arena).
+                void Destroy();
+
+                // Clears content, but keeps allocated std::string, to avoid the overhead of
+                // heap operations. After this returns, the content (as seen by the user) will
+                // always be the empty std::string. Assumes that |default_value| is an empty
+                // std::string.
+                void ClearToEmpty();
+
+                // Clears content, assuming that the current value is not the empty
+                // string default.
+                void ClearNonDefaultToEmpty();
+
+                // Clears content, but keeps allocated std::string if arena != nullptr, to
+                // avoid the overhead of heap operations. After this returns, the content
+                // (as seen by the user) will always be equal to |default_value|.
+                void ClearToDefault(const LazyString& default_value, ::google::protobuf::Arena* arena);
+
+                // Swaps internal pointers. Arena-safety semantics: this is guarded by the
+                // logic in Swap()/UnsafeArenaSwap() at the message level, so this method is
+                // 'unsafe' if called directly.
+                inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(ArenaStringPtr* rhs, Arena* rhs_arena, ArenaStringPtr* lhs, Arena* lhs_arena);
+
+                // Internal setter used only at parse time to directly set a donated string
+                // value.
+                void UnsafeSetTaggedPointer(TaggedStringPtr value)
+                {
+                    tagged_ptr_ = value;
+                }
+                // Generated code only! An optimization, in certain cases the generated
+                // code is certain we can obtain a std::string with no default checks and
+                // tag tests.
+                std::string* UnsafeMutablePointer() PROTOBUF_RETURNS_NONNULL;
+
+                // Returns true if this instances holds an immutable default value.
+                inline bool IsDefault() const
+                {
+                    return tagged_ptr_.IsDefault();
+                }
+
+            private:
+                template<typename... Args>
+                inline std::string* NewString(Arena* arena, Args&&... args)
+                {
+                    if (arena == nullptr)
+                    {
+                        auto* s = new std::string(std::forward<Args>(args)...);
+                        return tagged_ptr_.SetAllocated(s);
+                    }
+                    else
+                    {
+                        auto* s = Arena::Create<std::string>(arena, std::forward<Args>(args)...);
+                        return tagged_ptr_.SetMutableArena(s);
+                    }
+                }
+
+                TaggedStringPtr tagged_ptr_;
+
+                bool IsFixedSizeArena() const
+                {
+                    return false;
+                }
+
+                // Swaps tagged pointer without debug hardening. This is to allow python
+                // protobuf to maintain pointer stability even in DEBUG builds.
+                inline PROTOBUF_NDEBUG_INLINE static void UnsafeShallowSwap(
+                    ArenaStringPtr* rhs, ArenaStringPtr* lhs
+                )
+                {
+                    std::swap(lhs->tagged_ptr_, rhs->tagged_ptr_);
+                }
+
+                friend class ::google::protobuf::internal::SwapFieldHelper;
+                friend class TcParser;
+
+                // Slow paths.
+
+                // MutableSlow requires that !IsString() || IsDefault
+                // Variadic to support 0 args for empty default and 1 arg for LazyString.
+                template<typename... Lazy>
+                std::string* MutableSlow(::google::protobuf::Arena* arena, const Lazy&... lazy_default);
+
+                friend class EpsCopyInputStream;
+            };
+
+            inline void ArenaStringPtr::InitDefault()
+            {
+                tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string);
+            }
+
+            inline void ArenaStringPtr::InitExternal(const std::string* str)
+            {
+                tagged_ptr_.SetDefault(str);
+            }
+
+            inline void ArenaStringPtr::InitAllocated(std::string* str, Arena* arena)
+            {
+                if (arena != nullptr)
+                {
+                    tagged_ptr_.SetMutableArena(str);
+                    arena->Own(str);
+                }
+                else
+                {
+                    tagged_ptr_.SetAllocated(str);
+                }
+            }
+
+            inline void ArenaStringPtr::Set(const char* s, Arena* arena)
+            {
+                Set(ConstStringParam{s}, arena);
+            }
+
+            inline void ArenaStringPtr::Set(const char* s, size_t n, Arena* arena)
+            {
+                Set(ConstStringParam{s, n}, arena);
+            }
+
+            inline void ArenaStringPtr::SetBytes(ConstStringParam value, Arena* arena)
+            {
+                Set(value, arena);
+            }
+
+            inline void ArenaStringPtr::SetBytes(std::string&& value, Arena* arena)
+            {
+                Set(std::move(value), arena);
+            }
+
+            inline void ArenaStringPtr::SetBytes(const char* s, Arena* arena)
+            {
+                Set(s, arena);
+            }
+
+            inline void ArenaStringPtr::SetBytes(const void* p, size_t n, Arena* arena)
+            {
+                Set(ConstStringParam{static_cast<const char*>(p), n}, arena);
+            }
+
+            // Make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
+            inline PROTOBUF_NDEBUG_INLINE void ArenaStringPtr::InternalSwap(  //
+                ArenaStringPtr* rhs,
+                Arena* rhs_arena,  //
+                ArenaStringPtr* lhs,
+                Arena* lhs_arena
+            )
+            {
+                // Silence unused variable warnings in release buildls.
+                (void)rhs_arena;
+                (void)lhs_arena;
+                std::swap(lhs->tagged_ptr_, rhs->tagged_ptr_);
 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-  auto force_realloc = [](ArenaStringPtr* p, Arena* arena) {
-    if (p->IsDefault()) return;
-    std::string* old_value = p->tagged_ptr_.Get();
-    std::string* new_value =
-        p->IsFixedSizeArena()
-            ? Arena::Create<std::string>(arena, *old_value)
-            : Arena::Create<std::string>(arena, std::move(*old_value));
-    if (arena == nullptr) {
-      delete old_value;
-      p->tagged_ptr_.SetAllocated(new_value);
-    } else {
-      p->tagged_ptr_.SetMutableArena(new_value);
-    }
-  };
-  // Because, at this point, tagged_ptr_ has been swapped, arena should also be
-  // swapped.
-  force_realloc(lhs, rhs_arena);
-  force_realloc(rhs, lhs_arena);
+                auto force_realloc = [](ArenaStringPtr* p, Arena* arena)
+                {
+                    if (p->IsDefault())
+                        return;
+                    std::string* old_value = p->tagged_ptr_.Get();
+                    std::string* new_value =
+                        p->IsFixedSizeArena() ? Arena::Create<std::string>(arena, *old_value) : Arena::Create<std::string>(arena, std::move(*old_value));
+                    if (arena == nullptr)
+                    {
+                        delete old_value;
+                        p->tagged_ptr_.SetAllocated(new_value);
+                    }
+                    else
+                    {
+                        p->tagged_ptr_.SetMutableArena(new_value);
+                    }
+                };
+                // Because, at this point, tagged_ptr_ has been swapped, arena should also be
+                // swapped.
+                force_realloc(lhs, rhs_arena);
+                force_realloc(rhs, lhs_arena);
 #endif  // PROTOBUF_FORCE_COPY_IN_SWAP
-}
-
-inline void ArenaStringPtr::ClearNonDefaultToEmpty() {
-  // Unconditionally mask away the tag.
-  tagged_ptr_.Get()->clear();
-}
-
-inline std::string* ArenaStringPtr::UnsafeMutablePointer() {
-  GOOGLE_DCHECK(tagged_ptr_.IsMutable());
-  GOOGLE_DCHECK(tagged_ptr_.Get() != nullptr);
-  return tagged_ptr_.Get();
-}
-
-
-}  // namespace internal
-}  // namespace protobuf
+            }
+
+            inline void ArenaStringPtr::ClearNonDefaultToEmpty()
+            {
+                // Unconditionally mask away the tag.
+                tagged_ptr_.Get()->clear();
+            }
+
+            inline std::string* ArenaStringPtr::UnsafeMutablePointer()
+            {
+                GOOGLE_DCHECK(tagged_ptr_.IsMutable());
+                GOOGLE_DCHECK(tagged_ptr_.Get() != nullptr);
+                return tagged_ptr_.Get();
+            }
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h b/CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h
index b04b0cc..de0c129 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/arenaz_sampler.h
@@ -35,172 +35,210 @@
 #include <cstddef>
 #include <cstdint>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
 #if defined(PROTOBUF_ARENAZ_SAMPLE)
-struct ThreadSafeArenaStats;
-void RecordResetSlow(ThreadSafeArenaStats* info);
-void RecordAllocateSlow(ThreadSafeArenaStats* info, size_t requested,
-                        size_t allocated, size_t wasted);
-// Stores information about a sampled thread safe arena.  All mutations to this
-// *must* be made through `Record*` functions below.  All reads from this *must*
-// only occur in the callback to `ThreadSafeArenazSampler::Iterate`.
-struct ThreadSafeArenaStats
-    : public absl::profiling_internal::Sample<ThreadSafeArenaStats> {
-  // Constructs the object but does not fill in any fields.
-  ThreadSafeArenaStats();
-  ~ThreadSafeArenaStats();
-
-  // Puts the object into a clean state, fills in the logically `const` members,
-  // blocking for any readers that are currently sampling the object.
-  void PrepareForSampling() ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
-
-  // These fields are mutated by the various Record* APIs and need to be
-  // thread-safe.
-  std::atomic<int> num_allocations;
-  std::atomic<int> num_resets;
-  std::atomic<size_t> bytes_requested;
-  std::atomic<size_t> bytes_allocated;
-  std::atomic<size_t> bytes_wasted;
-  // Records the largest size an arena ever had.  Maintained across resets.
-  std::atomic<size_t> max_bytes_allocated;
-  // Bit i when set to 1 indicates that a thread with tid % 63 = i accessed the
-  // underlying arena.  The field is maintained across resets.
-  std::atomic<uint64_t> thread_ids;
-
-  // All of the fields below are set by `PrepareForSampling`, they must not
-  // be mutated in `Record*` functions.  They are logically `const` in that
-  // sense. These are guarded by init_mu, but that is not externalized to
-  // clients, who can only read them during
-  // `ThreadSafeArenazSampler::Iterate` which will hold the lock.
-  static constexpr int kMaxStackDepth = 64;
-  int32_t depth;
-  void* stack[kMaxStackDepth];
-  static void RecordAllocateStats(ThreadSafeArenaStats* info, size_t requested,
-                                  size_t allocated, size_t wasted) {
-    if (PROTOBUF_PREDICT_TRUE(info == nullptr)) return;
-    RecordAllocateSlow(info, requested, allocated, wasted);
-  }
-};
-
-ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
-void UnsampleSlow(ThreadSafeArenaStats* info);
-
-class ThreadSafeArenaStatsHandle {
- public:
-  explicit ThreadSafeArenaStatsHandle() = default;
-  explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats* info)
-      : info_(info) {}
-
-  ~ThreadSafeArenaStatsHandle() {
-    if (PROTOBUF_PREDICT_TRUE(info_ == nullptr)) return;
-    UnsampleSlow(info_);
-  }
-
-  ThreadSafeArenaStatsHandle(ThreadSafeArenaStatsHandle&& other) noexcept
-      : info_(absl::exchange(other.info_, nullptr)) {}
-
-  ThreadSafeArenaStatsHandle& operator=(
-      ThreadSafeArenaStatsHandle&& other) noexcept {
-    if (PROTOBUF_PREDICT_FALSE(info_ != nullptr)) {
-      UnsampleSlow(info_);
-    }
-    info_ = absl::exchange(other.info_, nullptr);
-    return *this;
-  }
-
-  void RecordReset() {
-    if (PROTOBUF_PREDICT_TRUE(info_ == nullptr)) return;
-    RecordResetSlow(info_);
-  }
-
-  ThreadSafeArenaStats* MutableStats() { return info_; }
-
-  friend void swap(ThreadSafeArenaStatsHandle& lhs,
-                   ThreadSafeArenaStatsHandle& rhs) {
-    std::swap(lhs.info_, rhs.info_);
-  }
-
-  friend class ThreadSafeArenaStatsHandlePeer;
-
- private:
-  ThreadSafeArenaStats* info_ = nullptr;
-};
-
-using ThreadSafeArenazSampler =
-    ::absl::profiling_internal::SampleRecorder<ThreadSafeArenaStats>;
-
-extern PROTOBUF_THREAD_LOCAL int64_t global_next_sample;
-
-// Returns an RAII sampling handle that manages registration and unregistation
-// with the global sampler.
-inline ThreadSafeArenaStatsHandle Sample() {
-  if (PROTOBUF_PREDICT_TRUE(--global_next_sample > 0)) {
-    return ThreadSafeArenaStatsHandle(nullptr);
-  }
-  return ThreadSafeArenaStatsHandle(SampleSlow(&global_next_sample));
-}
+            struct ThreadSafeArenaStats;
+            void RecordResetSlow(ThreadSafeArenaStats* info);
+            void RecordAllocateSlow(ThreadSafeArenaStats* info, size_t requested, size_t allocated, size_t wasted);
+            // Stores information about a sampled thread safe arena.  All mutations to this
+            // *must* be made through `Record*` functions below.  All reads from this *must*
+            // only occur in the callback to `ThreadSafeArenazSampler::Iterate`.
+            struct ThreadSafeArenaStats : public absl::profiling_internal::Sample<ThreadSafeArenaStats>
+            {
+                // Constructs the object but does not fill in any fields.
+                ThreadSafeArenaStats();
+                ~ThreadSafeArenaStats();
+
+                // Puts the object into a clean state, fills in the logically `const` members,
+                // blocking for any readers that are currently sampling the object.
+                void PrepareForSampling() ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
+
+                // These fields are mutated by the various Record* APIs and need to be
+                // thread-safe.
+                std::atomic<int> num_allocations;
+                std::atomic<int> num_resets;
+                std::atomic<size_t> bytes_requested;
+                std::atomic<size_t> bytes_allocated;
+                std::atomic<size_t> bytes_wasted;
+                // Records the largest size an arena ever had.  Maintained across resets.
+                std::atomic<size_t> max_bytes_allocated;
+                // Bit i when set to 1 indicates that a thread with tid % 63 = i accessed the
+                // underlying arena.  The field is maintained across resets.
+                std::atomic<uint64_t> thread_ids;
+
+                // All of the fields below are set by `PrepareForSampling`, they must not
+                // be mutated in `Record*` functions.  They are logically `const` in that
+                // sense. These are guarded by init_mu, but that is not externalized to
+                // clients, who can only read them during
+                // `ThreadSafeArenazSampler::Iterate` which will hold the lock.
+                static constexpr int kMaxStackDepth = 64;
+                int32_t depth;
+                void* stack[kMaxStackDepth];
+                static void RecordAllocateStats(ThreadSafeArenaStats* info, size_t requested, size_t allocated, size_t wasted)
+                {
+                    if (PROTOBUF_PREDICT_TRUE(info == nullptr))
+                        return;
+                    RecordAllocateSlow(info, requested, allocated, wasted);
+                }
+            };
+
+            ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
+            void UnsampleSlow(ThreadSafeArenaStats* info);
+
+            class ThreadSafeArenaStatsHandle
+            {
+            public:
+                explicit ThreadSafeArenaStatsHandle() = default;
+                explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats* info) :
+                    info_(info)
+                {
+                }
+
+                ~ThreadSafeArenaStatsHandle()
+                {
+                    if (PROTOBUF_PREDICT_TRUE(info_ == nullptr))
+                        return;
+                    UnsampleSlow(info_);
+                }
+
+                ThreadSafeArenaStatsHandle(ThreadSafeArenaStatsHandle&& other) noexcept
+                    :
+                    info_(absl::exchange(other.info_, nullptr))
+                {
+                }
+
+                ThreadSafeArenaStatsHandle& operator=(
+                    ThreadSafeArenaStatsHandle&& other
+                ) noexcept
+                {
+                    if (PROTOBUF_PREDICT_FALSE(info_ != nullptr))
+                    {
+                        UnsampleSlow(info_);
+                    }
+                    info_ = absl::exchange(other.info_, nullptr);
+                    return *this;
+                }
+
+                void RecordReset()
+                {
+                    if (PROTOBUF_PREDICT_TRUE(info_ == nullptr))
+                        return;
+                    RecordResetSlow(info_);
+                }
+
+                ThreadSafeArenaStats* MutableStats()
+                {
+                    return info_;
+                }
+
+                friend void swap(ThreadSafeArenaStatsHandle& lhs, ThreadSafeArenaStatsHandle& rhs)
+                {
+                    std::swap(lhs.info_, rhs.info_);
+                }
+
+                friend class ThreadSafeArenaStatsHandlePeer;
+
+            private:
+                ThreadSafeArenaStats* info_ = nullptr;
+            };
+
+            using ThreadSafeArenazSampler =
+                ::absl::profiling_internal::SampleRecorder<ThreadSafeArenaStats>;
+
+            extern PROTOBUF_THREAD_LOCAL int64_t global_next_sample;
+
+            // Returns an RAII sampling handle that manages registration and unregistation
+            // with the global sampler.
+            inline ThreadSafeArenaStatsHandle Sample()
+            {
+                if (PROTOBUF_PREDICT_TRUE(--global_next_sample > 0))
+                {
+                    return ThreadSafeArenaStatsHandle(nullptr);
+                }
+                return ThreadSafeArenaStatsHandle(SampleSlow(&global_next_sample));
+            }
 
 #else
-struct ThreadSafeArenaStats {
-  static void RecordAllocateStats(ThreadSafeArenaStats*, size_t /*requested*/,
-                                  size_t /*allocated*/, size_t /*wasted*/) {}
-};
-
-ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
-void UnsampleSlow(ThreadSafeArenaStats* info);
-
-class ThreadSafeArenaStatsHandle {
- public:
-  explicit ThreadSafeArenaStatsHandle() = default;
-  explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats*) {}
-
-  void RecordReset() {}
-
-  ThreadSafeArenaStats* MutableStats() { return nullptr; }
-
-  friend void swap(ThreadSafeArenaStatsHandle&, ThreadSafeArenaStatsHandle&) {}
-
- private:
-  friend class ThreadSafeArenaStatsHandlePeer;
-};
-
-class ThreadSafeArenazSampler {
- public:
-  void Unregister(ThreadSafeArenaStats*) {}
-  void SetMaxSamples(int32_t) {}
-};
-
-// Returns an RAII sampling handle that manages registration and unregistation
-// with the global sampler.
-inline ThreadSafeArenaStatsHandle Sample() {
-  return ThreadSafeArenaStatsHandle(nullptr);
-}
+            struct ThreadSafeArenaStats
+            {
+                static void RecordAllocateStats(ThreadSafeArenaStats*, size_t /*requested*/, size_t /*allocated*/, size_t /*wasted*/)
+                {
+                }
+            };
+
+            ThreadSafeArenaStats* SampleSlow(int64_t* next_sample);
+            void UnsampleSlow(ThreadSafeArenaStats* info);
+
+            class ThreadSafeArenaStatsHandle
+            {
+            public:
+                explicit ThreadSafeArenaStatsHandle() = default;
+                explicit ThreadSafeArenaStatsHandle(ThreadSafeArenaStats*)
+                {
+                }
+
+                void RecordReset()
+                {
+                }
+
+                ThreadSafeArenaStats* MutableStats()
+                {
+                    return nullptr;
+                }
+
+                friend void swap(ThreadSafeArenaStatsHandle&, ThreadSafeArenaStatsHandle&)
+                {
+                }
+
+            private:
+                friend class ThreadSafeArenaStatsHandlePeer;
+            };
+
+            class ThreadSafeArenazSampler
+            {
+            public:
+                void Unregister(ThreadSafeArenaStats*)
+                {
+                }
+                void SetMaxSamples(int32_t)
+                {
+                }
+            };
+
+            // Returns an RAII sampling handle that manages registration and unregistation
+            // with the global sampler.
+            inline ThreadSafeArenaStatsHandle Sample()
+            {
+                return ThreadSafeArenaStatsHandle(nullptr);
+            }
 #endif  // defined(PROTOBUF_ARENAZ_SAMPLE)
 
-// Returns a global Sampler.
-ThreadSafeArenazSampler& GlobalThreadSafeArenazSampler();
+            // Returns a global Sampler.
+            ThreadSafeArenazSampler& GlobalThreadSafeArenazSampler();
 
-// Enables or disables sampling for thread safe arenas.
-void SetThreadSafeArenazEnabled(bool enabled);
+            // Enables or disables sampling for thread safe arenas.
+            void SetThreadSafeArenazEnabled(bool enabled);
 
-// Sets the rate at which thread safe arena will be sampled.
-void SetThreadSafeArenazSampleParameter(int32_t rate);
+            // Sets the rate at which thread safe arena will be sampled.
+            void SetThreadSafeArenazSampleParameter(int32_t rate);
 
-// Sets a soft max for the number of samples that will be kept.
-void SetThreadSafeArenazMaxSamples(int32_t max);
+            // Sets a soft max for the number of samples that will be kept.
+            void SetThreadSafeArenazMaxSamples(int32_t max);
 
-// Sets the current value for when arenas should be next sampled.
-void SetThreadSafeArenazGlobalNextSample(int64_t next_sample);
+            // Sets the current value for when arenas should be next sampled.
+            void SetThreadSafeArenazGlobalNextSample(int64_t next_sample);
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/code_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/code_generator.h
index 9c0b115..ab9bad0 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/code_generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/code_generator.h
@@ -46,160 +46,171 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-namespace io {
-class ZeroCopyOutputStream;
-}
-class FileDescriptor;
-class GeneratedCodeInfo;
-
-namespace compiler {
-class AccessInfoMap;
-
-class Version;
-
-// Defined in this file.
-class CodeGenerator;
-class GeneratorContext;
-
-// The abstract interface to a class which generates code implementing a
-// particular proto file in a particular language.  A number of these may
-// be registered with CommandLineInterface to support various languages.
-class PROTOC_EXPORT CodeGenerator {
- public:
-  inline CodeGenerator() {}
-  virtual ~CodeGenerator();
-
-  // Generates code for the given proto file, generating one or more files in
-  // the given output directory.
-  //
-  // A parameter to be passed to the generator can be specified on the command
-  // line. This is intended to be used to pass generator specific parameters.
-  // It is empty if no parameter was given. ParseGeneratorParameter (below),
-  // can be used to accept multiple parameters within the single parameter
-  // command line flag.
-  //
-  // Returns true if successful.  Otherwise, sets *error to a description of
-  // the problem (e.g. "invalid parameter") and returns false.
-  virtual bool Generate(const FileDescriptor* file,
-                        const std::string& parameter,
-                        GeneratorContext* generator_context,
-                        std::string* error) const = 0;
-
-  // Generates code for all given proto files.
-  //
-  // WARNING: The canonical code generator design produces one or two output
-  // files per input .proto file, and we do not wish to encourage alternate
-  // designs.
-  //
-  // A parameter is given as passed on the command line, as in |Generate()|
-  // above.
-  //
-  // Returns true if successful.  Otherwise, sets *error to a description of
-  // the problem (e.g. "invalid parameter") and returns false.
-  virtual bool GenerateAll(const std::vector<const FileDescriptor*>& files,
-                           const std::string& parameter,
-                           GeneratorContext* generator_context,
-                           std::string* error) const;
-
-  // This must be kept in sync with plugin.proto. See that file for
-  // documentation on each value.
-  enum Feature {
-    FEATURE_PROTO3_OPTIONAL = 1,
-  };
-
-  // Implement this to indicate what features this code generator supports.
-  //
-  // This must be a bitwise OR of values from the Feature enum above (or zero).
-  virtual uint64_t GetSupportedFeatures() const { return 0; }
-
-  // This is no longer used, but this class is part of the opensource protobuf
-  // library, so it has to remain to keep vtables the same for the current
-  // version of the library. When protobufs does a api breaking change, the
-  // method can be removed.
-  virtual bool HasGenerateAll() const { return true; }
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodeGenerator);
-};
-
-// CodeGenerators generate one or more files in a given directory.  This
-// abstract interface represents the directory to which the CodeGenerator is
-// to write and other information about the context in which the Generator
-// runs.
-class PROTOC_EXPORT GeneratorContext {
- public:
-  inline GeneratorContext() {
-  }
-  virtual ~GeneratorContext();
-
-  // Opens the given file, truncating it if it exists, and returns a
-  // ZeroCopyOutputStream that writes to the file.  The caller takes ownership
-  // of the returned object.  This method never fails (a dummy stream will be
-  // returned instead).
-  //
-  // The filename given should be relative to the root of the source tree.
-  // E.g. the C++ generator, when generating code for "foo/bar.proto", will
-  // generate the files "foo/bar.pb.h" and "foo/bar.pb.cc"; note that
-  // "foo/" is included in these filenames.  The filename is not allowed to
-  // contain "." or ".." components.
-  virtual io::ZeroCopyOutputStream* Open(const std::string& filename) = 0;
-
-  // Similar to Open() but the output will be appended to the file if exists
-  virtual io::ZeroCopyOutputStream* OpenForAppend(const std::string& filename);
-
-  // Creates a ZeroCopyOutputStream which will insert code into the given file
-  // at the given insertion point.  See plugin.proto (plugin.pb.h) for more
-  // information on insertion points.  The default implementation
-  // assert-fails -- it exists only for backwards-compatibility.
-  //
-  // WARNING:  This feature is currently EXPERIMENTAL and is subject to change.
-  virtual io::ZeroCopyOutputStream* OpenForInsert(
-      const std::string& filename, const std::string& insertion_point);
-
-  // Similar to OpenForInsert, but if `info` is non-empty, will open (or create)
-  // filename.pb.meta and insert info at the appropriate place with the
-  // necessary shifts. The default implementation ignores `info`.
-  //
-  // WARNING:  This feature will be REMOVED in the near future.
-  virtual io::ZeroCopyOutputStream* OpenForInsertWithGeneratedCodeInfo(
-      const std::string& filename, const std::string& insertion_point,
-      const google::protobuf::GeneratedCodeInfo& info);
-
-  // Returns a vector of FileDescriptors for all the files being compiled
-  // in this run.  Useful for languages, such as Go, that treat files
-  // differently when compiled as a set rather than individually.
-  virtual void ListParsedFiles(std::vector<const FileDescriptor*>* output);
-
-  // Retrieves the version number of the protocol compiler associated with
-  // this GeneratorContext.
-  virtual void GetCompilerVersion(Version* version) const;
-
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratorContext);
-};
-
-// The type GeneratorContext was once called OutputDirectory. This typedef
-// provides backward compatibility.
-typedef GeneratorContext OutputDirectory;
-
-// Several code generators treat the parameter argument as holding a
-// list of options separated by commas.  This helper function parses
-// a set of comma-delimited name/value pairs: e.g.,
-//   "foo=bar,baz,moo=corge"
-// parses to the pairs:
-//   ("foo", "bar"), ("baz", ""), ("moo", "corge")
-PROTOC_EXPORT void ParseGeneratorParameter(
-    const std::string&, std::vector<std::pair<std::string, std::string> >*);
-
-// Strips ".proto" or ".protodevel" from the end of a filename.
-PROTOC_EXPORT std::string StripProto(const std::string& filename);
-
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        namespace io
+        {
+            class ZeroCopyOutputStream;
+        }
+        class FileDescriptor;
+        class GeneratedCodeInfo;
+
+        namespace compiler
+        {
+            class AccessInfoMap;
+
+            class Version;
+
+            // Defined in this file.
+            class CodeGenerator;
+            class GeneratorContext;
+
+            // The abstract interface to a class which generates code implementing a
+            // particular proto file in a particular language.  A number of these may
+            // be registered with CommandLineInterface to support various languages.
+            class PROTOC_EXPORT CodeGenerator
+            {
+            public:
+                inline CodeGenerator()
+                {
+                }
+                virtual ~CodeGenerator();
+
+                // Generates code for the given proto file, generating one or more files in
+                // the given output directory.
+                //
+                // A parameter to be passed to the generator can be specified on the command
+                // line. This is intended to be used to pass generator specific parameters.
+                // It is empty if no parameter was given. ParseGeneratorParameter (below),
+                // can be used to accept multiple parameters within the single parameter
+                // command line flag.
+                //
+                // Returns true if successful.  Otherwise, sets *error to a description of
+                // the problem (e.g. "invalid parameter") and returns false.
+                virtual bool Generate(const FileDescriptor* file, const std::string& parameter, GeneratorContext* generator_context, std::string* error) const = 0;
+
+                // Generates code for all given proto files.
+                //
+                // WARNING: The canonical code generator design produces one or two output
+                // files per input .proto file, and we do not wish to encourage alternate
+                // designs.
+                //
+                // A parameter is given as passed on the command line, as in |Generate()|
+                // above.
+                //
+                // Returns true if successful.  Otherwise, sets *error to a description of
+                // the problem (e.g. "invalid parameter") and returns false.
+                virtual bool GenerateAll(const std::vector<const FileDescriptor*>& files, const std::string& parameter, GeneratorContext* generator_context, std::string* error) const;
+
+                // This must be kept in sync with plugin.proto. See that file for
+                // documentation on each value.
+                enum Feature
+                {
+                    FEATURE_PROTO3_OPTIONAL = 1,
+                };
+
+                // Implement this to indicate what features this code generator supports.
+                //
+                // This must be a bitwise OR of values from the Feature enum above (or zero).
+                virtual uint64_t GetSupportedFeatures() const
+                {
+                    return 0;
+                }
+
+                // This is no longer used, but this class is part of the opensource protobuf
+                // library, so it has to remain to keep vtables the same for the current
+                // version of the library. When protobufs does a api breaking change, the
+                // method can be removed.
+                virtual bool HasGenerateAll() const
+                {
+                    return true;
+                }
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodeGenerator);
+            };
+
+            // CodeGenerators generate one or more files in a given directory.  This
+            // abstract interface represents the directory to which the CodeGenerator is
+            // to write and other information about the context in which the Generator
+            // runs.
+            class PROTOC_EXPORT GeneratorContext
+            {
+            public:
+                inline GeneratorContext()
+                {
+                }
+                virtual ~GeneratorContext();
+
+                // Opens the given file, truncating it if it exists, and returns a
+                // ZeroCopyOutputStream that writes to the file.  The caller takes ownership
+                // of the returned object.  This method never fails (a dummy stream will be
+                // returned instead).
+                //
+                // The filename given should be relative to the root of the source tree.
+                // E.g. the C++ generator, when generating code for "foo/bar.proto", will
+                // generate the files "foo/bar.pb.h" and "foo/bar.pb.cc"; note that
+                // "foo/" is included in these filenames.  The filename is not allowed to
+                // contain "." or ".." components.
+                virtual io::ZeroCopyOutputStream* Open(const std::string& filename) = 0;
+
+                // Similar to Open() but the output will be appended to the file if exists
+                virtual io::ZeroCopyOutputStream* OpenForAppend(const std::string& filename);
+
+                // Creates a ZeroCopyOutputStream which will insert code into the given file
+                // at the given insertion point.  See plugin.proto (plugin.pb.h) for more
+                // information on insertion points.  The default implementation
+                // assert-fails -- it exists only for backwards-compatibility.
+                //
+                // WARNING:  This feature is currently EXPERIMENTAL and is subject to change.
+                virtual io::ZeroCopyOutputStream* OpenForInsert(
+                    const std::string& filename, const std::string& insertion_point
+                );
+
+                // Similar to OpenForInsert, but if `info` is non-empty, will open (or create)
+                // filename.pb.meta and insert info at the appropriate place with the
+                // necessary shifts. The default implementation ignores `info`.
+                //
+                // WARNING:  This feature will be REMOVED in the near future.
+                virtual io::ZeroCopyOutputStream* OpenForInsertWithGeneratedCodeInfo(
+                    const std::string& filename, const std::string& insertion_point, const google::protobuf::GeneratedCodeInfo& info
+                );
+
+                // Returns a vector of FileDescriptors for all the files being compiled
+                // in this run.  Useful for languages, such as Go, that treat files
+                // differently when compiled as a set rather than individually.
+                virtual void ListParsedFiles(std::vector<const FileDescriptor*>* output);
+
+                // Retrieves the version number of the protocol compiler associated with
+                // this GeneratorContext.
+                virtual void GetCompilerVersion(Version* version) const;
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratorContext);
+            };
+
+            // The type GeneratorContext was once called OutputDirectory. This typedef
+            // provides backward compatibility.
+            typedef GeneratorContext OutputDirectory;
+
+            // Several code generators treat the parameter argument as holding a
+            // list of options separated by commas.  This helper function parses
+            // a set of comma-delimited name/value pairs: e.g.,
+            //   "foo=bar,baz,moo=corge"
+            // parses to the pairs:
+            //   ("foo", "bar"), ("baz", ""), ("moo", "corge")
+            PROTOC_EXPORT void ParseGeneratorParameter(
+                const std::string&, std::vector<std::pair<std::string, std::string>>*
+            );
+
+            // Strips ".proto" or ".protodevel" from the end of a filename.
+            PROTOC_EXPORT std::string StripProto(const std::string& filename);
+
+        }  // namespace compiler
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/command_line_interface.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/command_line_interface.h
index e842550..cc33f52 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/command_line_interface.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/command_line_interface.h
@@ -53,410 +53,412 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-class Descriptor;           // descriptor.h
-class DescriptorDatabase;   // descriptor_database.h
-class DescriptorPool;       // descriptor.h
-class FileDescriptor;       // descriptor.h
-class FileDescriptorSet;    // descriptor.h
-class FileDescriptorProto;  // descriptor.pb.h
-template <typename T>
-class RepeatedPtrField;          // repeated_field.h
-class SimpleDescriptorDatabase;  // descriptor_database.h
-
-namespace compiler {
-
-class CodeGenerator;     // code_generator.h
-class GeneratorContext;  // code_generator.h
-class DiskSourceTree;    // importer.h
-
-// This class implements the command-line interface to the protocol compiler.
-// It is designed to make it very easy to create a custom protocol compiler
-// supporting the languages of your choice.  For example, if you wanted to
-// create a custom protocol compiler binary which includes both the regular
-// C++ support plus support for your own custom output "Foo", you would
-// write a class "FooGenerator" which implements the CodeGenerator interface,
-// then write a main() procedure like this:
-//
-//   int main(int argc, char* argv[]) {
-//     google::protobuf::compiler::CommandLineInterface cli;
-//
-//     // Support generation of C++ source and headers.
-//     google::protobuf::compiler::cpp::CppGenerator cpp_generator;
-//     cli.RegisterGenerator("--cpp_out", &cpp_generator,
-//       "Generate C++ source and header.");
-//
-//     // Support generation of Foo code.
-//     FooGenerator foo_generator;
-//     cli.RegisterGenerator("--foo_out", &foo_generator,
-//       "Generate Foo file.");
-//
-//     return cli.Run(argc, argv);
-//   }
-//
-// The compiler is invoked with syntax like:
-//   protoc --cpp_out=outdir --foo_out=outdir --proto_path=src src/foo.proto
-//
-// The .proto file to compile can be specified on the command line using either
-// its physical file path, or a virtual path relative to a directory specified
-// in --proto_path. For example, for src/foo.proto, the following two protoc
-// invocations work the same way:
-//   1. protoc --proto_path=src src/foo.proto (physical file path)
-//   2. protoc --proto_path=src foo.proto (virtual path relative to src)
-//
-// If a file path can be interpreted both as a physical file path and as a
-// relative virtual path, the physical file path takes precedence.
-//
-// For a full description of the command-line syntax, invoke it with --help.
-class PROTOC_EXPORT CommandLineInterface {
- public:
-  static const char* const kPathSeparator;
-
-  CommandLineInterface();
-  ~CommandLineInterface();
-
-  // Register a code generator for a language.
-  //
-  // Parameters:
-  // * flag_name: The command-line flag used to specify an output file of
-  //   this type.  The name must start with a '-'.  If the name is longer
-  //   than one letter, it must start with two '-'s.
-  // * generator: The CodeGenerator which will be called to generate files
-  //   of this type.
-  // * help_text: Text describing this flag in the --help output.
-  //
-  // Some generators accept extra parameters.  You can specify this parameter
-  // on the command-line by placing it before the output directory, separated
-  // by a colon:
-  //   protoc --foo_out=enable_bar:outdir
-  // The text before the colon is passed to CodeGenerator::Generate() as the
-  // "parameter".
-  void RegisterGenerator(const std::string& flag_name, CodeGenerator* generator,
-                         const std::string& help_text);
-
-  // Register a code generator for a language.
-  // Besides flag_name you can specify another option_flag_name that could be
-  // used to pass extra parameters to the registered code generator.
-  // Suppose you have registered a generator by calling:
-  //   command_line_interface.RegisterGenerator("--foo_out", "--foo_opt", ...)
-  // Then you could invoke the compiler with a command like:
-  //   protoc --foo_out=enable_bar:outdir --foo_opt=enable_baz
-  // This will pass "enable_bar,enable_baz" as the parameter to the generator.
-  void RegisterGenerator(const std::string& flag_name,
-                         const std::string& option_flag_name,
-                         CodeGenerator* generator,
-                         const std::string& help_text);
-
-  // Enables "plugins".  In this mode, if a command-line flag ends with "_out"
-  // but does not match any registered generator, the compiler will attempt to
-  // find a "plugin" to implement the generator.  Plugins are just executables.
-  // They should live somewhere in the PATH.
-  //
-  // The compiler determines the executable name to search for by concatenating
-  // exe_name_prefix with the unrecognized flag name, removing "_out".  So, for
-  // example, if exe_name_prefix is "protoc-" and you pass the flag --foo_out,
-  // the compiler will try to run the program "protoc-gen-foo".
-  //
-  // The plugin program should implement the following usage:
-  //   plugin [--out=OUTDIR] [--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS
-  // --out indicates the output directory (as passed to the --foo_out
-  // parameter); if omitted, the current directory should be used.  --parameter
-  // gives the generator parameter, if any was provided (see below).  The
-  // PROTO_FILES list the .proto files which were given on the compiler
-  // command-line; these are the files for which the plugin is expected to
-  // generate output code.  Finally, DESCRIPTORS is an encoded FileDescriptorSet
-  // (as defined in descriptor.proto).  This is piped to the plugin's stdin.
-  // The set will include descriptors for all the files listed in PROTO_FILES as
-  // well as all files that they import.  The plugin MUST NOT attempt to read
-  // the PROTO_FILES directly -- it must use the FileDescriptorSet.
-  //
-  // The plugin should generate whatever files are necessary, as code generators
-  // normally do.  It should write the names of all files it generates to
-  // stdout.  The names should be relative to the output directory, NOT absolute
-  // names or relative to the current directory.  If any errors occur, error
-  // messages should be written to stderr.  If an error is fatal, the plugin
-  // should exit with a non-zero exit code.
-  //
-  // Plugins can have generator parameters similar to normal built-in
-  // generators. Extra generator parameters can be passed in via a matching
-  // "_opt" parameter. For example:
-  //   protoc --plug_out=enable_bar:outdir --plug_opt=enable_baz
-  // This will pass "enable_bar,enable_baz" as the parameter to the plugin.
-  //
-  void AllowPlugins(const std::string& exe_name_prefix);
-
-  // Run the Protocol Compiler with the given command-line parameters.
-  // Returns the error code which should be returned by main().
-  //
-  // It may not be safe to call Run() in a multi-threaded environment because
-  // it calls strerror().  I'm not sure why you'd want to do this anyway.
-  int Run(int argc, const char* const argv[]);
-
-  // DEPRECATED. Calling this method has no effect. Protocol compiler now
-  // always try to find the .proto file relative to the current directory
-  // first and if the file is not found, it will then treat the input path
-  // as a virtual path.
-  void SetInputsAreProtoPathRelative(bool /* enable */) {}
-
-  // Provides some text which will be printed when the --version flag is
-  // used.  The version of libprotoc will also be printed on the next line
-  // after this text.
-  void SetVersionInfo(const std::string& text) { version_info_ = text; }
-
-
- private:
-  // -----------------------------------------------------------------
-
-  class ErrorPrinter;
-  class GeneratorContextImpl;
-  class MemoryOutputStream;
-  typedef std::unordered_map<std::string, std::unique_ptr<GeneratorContextImpl>>
-      GeneratorContextMap;
-
-  // Clear state from previous Run().
-  void Clear();
-
-  // Remaps the proto file so that it is relative to one of the directories
-  // in proto_path_.  Returns false if an error occurred.
-  bool MakeProtoProtoPathRelative(DiskSourceTree* source_tree,
-                                  std::string* proto,
-                                  DescriptorDatabase* fallback_database);
-
-  // Remaps each file in input_files_ so that it is relative to one of the
-  // directories in proto_path_.  Returns false if an error occurred.
-  bool MakeInputsBeProtoPathRelative(DiskSourceTree* source_tree,
-                                     DescriptorDatabase* fallback_database);
-
-  // Fails if these files use proto3 optional and the code generator doesn't
-  // support it. This is a permanent check.
-  bool EnforceProto3OptionalSupport(
-      const std::string& codegen_name, uint64_t supported_features,
-      const std::vector<const FileDescriptor*>& parsed_files) const;
-
-
-  // Return status for ParseArguments() and InterpretArgument().
-  enum ParseArgumentStatus {
-    PARSE_ARGUMENT_DONE_AND_CONTINUE,
-    PARSE_ARGUMENT_DONE_AND_EXIT,
-    PARSE_ARGUMENT_FAIL
-  };
-
-  // Parse all command-line arguments.
-  ParseArgumentStatus ParseArguments(int argc, const char* const argv[]);
-
-  // Read an argument file and append the file's content to the list of
-  // arguments. Return false if the file cannot be read.
-  bool ExpandArgumentFile(const std::string& file,
-                          std::vector<std::string>* arguments);
-
-  // Parses a command-line argument into a name/value pair.  Returns
-  // true if the next argument in the argv should be used as the value,
-  // false otherwise.
-  //
-  // Examples:
-  //   "-Isrc/protos" ->
-  //     name = "-I", value = "src/protos"
-  //   "--cpp_out=src/foo.pb2.cc" ->
-  //     name = "--cpp_out", value = "src/foo.pb2.cc"
-  //   "foo.proto" ->
-  //     name = "", value = "foo.proto"
-  bool ParseArgument(const char* arg, std::string* name, std::string* value);
-
-  // Interprets arguments parsed with ParseArgument.
-  ParseArgumentStatus InterpretArgument(const std::string& name,
-                                        const std::string& value);
-
-  // Print the --help text to stderr.
-  void PrintHelpText();
-
-  // Loads proto_path_ into the provided source_tree.
-  bool InitializeDiskSourceTree(DiskSourceTree* source_tree,
-                                DescriptorDatabase* fallback_database);
-
-  // Verify that all the input files exist in the given database.
-  bool VerifyInputFilesInDescriptors(DescriptorDatabase* fallback_database);
-
-  // Parses input_files_ into parsed_files
-  bool ParseInputFiles(DescriptorPool* descriptor_pool,
-                       DiskSourceTree* source_tree,
-                       std::vector<const FileDescriptor*>* parsed_files);
-
-  // Generate the given output file from the given input.
-  struct OutputDirective;  // see below
-  bool GenerateOutput(const std::vector<const FileDescriptor*>& parsed_files,
-                      const OutputDirective& output_directive,
-                      GeneratorContext* generator_context);
-  bool GeneratePluginOutput(
-      const std::vector<const FileDescriptor*>& parsed_files,
-      const std::string& plugin_name, const std::string& parameter,
-      GeneratorContext* generator_context, std::string* error);
-
-  // Implements --encode and --decode.
-  bool EncodeOrDecode(const DescriptorPool* pool);
-
-  // Implements the --descriptor_set_out option.
-  bool WriteDescriptorSet(
-      const std::vector<const FileDescriptor*>& parsed_files);
-
-  // Implements the --dependency_out option
-  bool GenerateDependencyManifestFile(
-      const std::vector<const FileDescriptor*>& parsed_files,
-      const GeneratorContextMap& output_directories,
-      DiskSourceTree* source_tree);
-
-  // Get all transitive dependencies of the given file (including the file
-  // itself), adding them to the given list of FileDescriptorProtos.  The
-  // protos will be ordered such that every file is listed before any file that
-  // depends on it, so that you can call DescriptorPool::BuildFile() on them
-  // in order.  Any files in *already_seen will not be added, and each file
-  // added will be inserted into *already_seen.  If include_source_code_info is
-  // true then include the source code information in the FileDescriptorProtos.
-  // If include_json_name is true, populate the json_name field of
-  // FieldDescriptorProto for all fields.
-  static void GetTransitiveDependencies(
-      const FileDescriptor* file, bool include_json_name,
-      bool include_source_code_info,
-      std::set<const FileDescriptor*>* already_seen,
-      RepeatedPtrField<FileDescriptorProto>* output);
-
-  // Implements the --print_free_field_numbers. This function prints free field
-  // numbers into stdout for the message and it's nested message types in
-  // post-order, i.e. nested types first. Printed range are left-right
-  // inclusive, i.e. [a, b].
-  //
-  // Groups:
-  // For historical reasons, groups are considered to share the same
-  // field number space with the parent message, thus it will not print free
-  // field numbers for groups. The field numbers used in the groups are
-  // excluded in the free field numbers of the parent message.
-  //
-  // Extension Ranges:
-  // Extension ranges are considered ocuppied field numbers and they will not be
-  // listed as free numbers in the output.
-  void PrintFreeFieldNumbers(const Descriptor* descriptor);
-
-  // -----------------------------------------------------------------
-
-  // The name of the executable as invoked (i.e. argv[0]).
-  std::string executable_name_;
-
-  // Version info set with SetVersionInfo().
-  std::string version_info_;
-
-  // Registered generators.
-  struct GeneratorInfo {
-    std::string flag_name;
-    std::string option_flag_name;
-    CodeGenerator* generator;
-    std::string help_text;
-  };
-  typedef std::map<std::string, GeneratorInfo> GeneratorMap;
-  GeneratorMap generators_by_flag_name_;
-  GeneratorMap generators_by_option_name_;
-  // A map from generator names to the parameters specified using the option
-  // flag. For example, if the user invokes the compiler with:
-  //   protoc --foo_out=outputdir --foo_opt=enable_bar ...
-  // Then there will be an entry ("--foo_out", "enable_bar") in this map.
-  std::map<std::string, std::string> generator_parameters_;
-  // Similar to generator_parameters_, but stores the parameters for plugins.
-  std::map<std::string, std::string> plugin_parameters_;
-
-  // See AllowPlugins().  If this is empty, plugins aren't allowed.
-  std::string plugin_prefix_;
-
-  // Maps specific plugin names to files.  When executing a plugin, this map
-  // is searched first to find the plugin executable.  If not found here, the
-  // PATH (or other OS-specific search strategy) is searched.
-  std::map<std::string, std::string> plugins_;
-
-  // Stuff parsed from command line.
-  enum Mode {
-    MODE_COMPILE,  // Normal mode:  parse .proto files and compile them.
-    MODE_ENCODE,   // --encode:  read text from stdin, write binary to stdout.
-    MODE_DECODE,   // --decode:  read binary from stdin, write text to stdout.
-    MODE_PRINT,    // Print mode: print info of the given .proto files and exit.
-  };
-
-  Mode mode_ = MODE_COMPILE;
-
-  enum PrintMode {
-    PRINT_NONE,         // Not in MODE_PRINT
-    PRINT_FREE_FIELDS,  // --print_free_fields
-  };
-
-  PrintMode print_mode_ = PRINT_NONE;
-
-  enum ErrorFormat {
-    ERROR_FORMAT_GCC,  // GCC error output format (default).
-    ERROR_FORMAT_MSVS  // Visual Studio output (--error_format=msvs).
-  };
-
-  ErrorFormat error_format_ = ERROR_FORMAT_GCC;
-
-  // True if we should treat warnings as errors that fail the compilation.
-  bool fatal_warnings_ = false;
-
-  std::vector<std::pair<std::string, std::string> >
-      proto_path_;                        // Search path for proto files.
-  std::vector<std::string> input_files_;  // Names of the input proto files.
-
-  // Names of proto files which are allowed to be imported. Used by build
-  // systems to enforce depend-on-what-you-import.
-  std::set<std::string> direct_dependencies_;
-  bool direct_dependencies_explicitly_set_ = false;
-
-  // If there's a violation of depend-on-what-you-import, this string will be
-  // presented to the user. "%s" will be replaced with the violating import.
-  std::string direct_dependencies_violation_msg_;
-
-  // output_directives_ lists all the files we are supposed to output and what
-  // generator to use for each.
-  struct OutputDirective {
-    std::string name;          // E.g. "--foo_out"
-    CodeGenerator* generator;  // NULL for plugins
-    std::string parameter;
-    std::string output_location;
-  };
-  std::vector<OutputDirective> output_directives_;
-
-  // When using --encode or --decode, this names the type we are encoding or
-  // decoding.  (Empty string indicates --decode_raw.)
-  std::string codec_type_;
-
-  // If --descriptor_set_in was given, these are filenames containing
-  // parsed FileDescriptorSets to be used for loading protos.  Otherwise, empty.
-  std::vector<std::string> descriptor_set_in_names_;
-
-  // If --descriptor_set_out was given, this is the filename to which the
-  // FileDescriptorSet should be written.  Otherwise, empty.
-  std::string descriptor_set_out_name_;
-
-  // If --dependency_out was given, this is the path to the file where the
-  // dependency file will be written. Otherwise, empty.
-  std::string dependency_out_name_;
-
-  // True if --include_imports was given, meaning that we should
-  // write all transitive dependencies to the DescriptorSet.  Otherwise, only
-  // the .proto files listed on the command-line are added.
-  bool imports_in_descriptor_set_;
-
-  // True if --include_source_info was given, meaning that we should not strip
-  // SourceCodeInfo from the DescriptorSet.
-  bool source_info_in_descriptor_set_ = false;
-
-  // Was the --disallow_services flag used?
-  bool disallow_services_ = false;
-
-  // When using --encode, this will be passed to SetSerializationDeterministic.
-  bool deterministic_output_ = false;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CommandLineInterface);
-};
-
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Descriptor;           // descriptor.h
+        class DescriptorDatabase;   // descriptor_database.h
+        class DescriptorPool;       // descriptor.h
+        class FileDescriptor;       // descriptor.h
+        class FileDescriptorSet;    // descriptor.h
+        class FileDescriptorProto;  // descriptor.pb.h
+        template<typename T>
+        class RepeatedPtrField;          // repeated_field.h
+        class SimpleDescriptorDatabase;  // descriptor_database.h
+
+        namespace compiler
+        {
+
+            class CodeGenerator;     // code_generator.h
+            class GeneratorContext;  // code_generator.h
+            class DiskSourceTree;    // importer.h
+
+            // This class implements the command-line interface to the protocol compiler.
+            // It is designed to make it very easy to create a custom protocol compiler
+            // supporting the languages of your choice.  For example, if you wanted to
+            // create a custom protocol compiler binary which includes both the regular
+            // C++ support plus support for your own custom output "Foo", you would
+            // write a class "FooGenerator" which implements the CodeGenerator interface,
+            // then write a main() procedure like this:
+            //
+            //   int main(int argc, char* argv[]) {
+            //     google::protobuf::compiler::CommandLineInterface cli;
+            //
+            //     // Support generation of C++ source and headers.
+            //     google::protobuf::compiler::cpp::CppGenerator cpp_generator;
+            //     cli.RegisterGenerator("--cpp_out", &cpp_generator,
+            //       "Generate C++ source and header.");
+            //
+            //     // Support generation of Foo code.
+            //     FooGenerator foo_generator;
+            //     cli.RegisterGenerator("--foo_out", &foo_generator,
+            //       "Generate Foo file.");
+            //
+            //     return cli.Run(argc, argv);
+            //   }
+            //
+            // The compiler is invoked with syntax like:
+            //   protoc --cpp_out=outdir --foo_out=outdir --proto_path=src src/foo.proto
+            //
+            // The .proto file to compile can be specified on the command line using either
+            // its physical file path, or a virtual path relative to a directory specified
+            // in --proto_path. For example, for src/foo.proto, the following two protoc
+            // invocations work the same way:
+            //   1. protoc --proto_path=src src/foo.proto (physical file path)
+            //   2. protoc --proto_path=src foo.proto (virtual path relative to src)
+            //
+            // If a file path can be interpreted both as a physical file path and as a
+            // relative virtual path, the physical file path takes precedence.
+            //
+            // For a full description of the command-line syntax, invoke it with --help.
+            class PROTOC_EXPORT CommandLineInterface
+            {
+            public:
+                static const char* const kPathSeparator;
+
+                CommandLineInterface();
+                ~CommandLineInterface();
+
+                // Register a code generator for a language.
+                //
+                // Parameters:
+                // * flag_name: The command-line flag used to specify an output file of
+                //   this type.  The name must start with a '-'.  If the name is longer
+                //   than one letter, it must start with two '-'s.
+                // * generator: The CodeGenerator which will be called to generate files
+                //   of this type.
+                // * help_text: Text describing this flag in the --help output.
+                //
+                // Some generators accept extra parameters.  You can specify this parameter
+                // on the command-line by placing it before the output directory, separated
+                // by a colon:
+                //   protoc --foo_out=enable_bar:outdir
+                // The text before the colon is passed to CodeGenerator::Generate() as the
+                // "parameter".
+                void RegisterGenerator(const std::string& flag_name, CodeGenerator* generator, const std::string& help_text);
+
+                // Register a code generator for a language.
+                // Besides flag_name you can specify another option_flag_name that could be
+                // used to pass extra parameters to the registered code generator.
+                // Suppose you have registered a generator by calling:
+                //   command_line_interface.RegisterGenerator("--foo_out", "--foo_opt", ...)
+                // Then you could invoke the compiler with a command like:
+                //   protoc --foo_out=enable_bar:outdir --foo_opt=enable_baz
+                // This will pass "enable_bar,enable_baz" as the parameter to the generator.
+                void RegisterGenerator(const std::string& flag_name, const std::string& option_flag_name, CodeGenerator* generator, const std::string& help_text);
+
+                // Enables "plugins".  In this mode, if a command-line flag ends with "_out"
+                // but does not match any registered generator, the compiler will attempt to
+                // find a "plugin" to implement the generator.  Plugins are just executables.
+                // They should live somewhere in the PATH.
+                //
+                // The compiler determines the executable name to search for by concatenating
+                // exe_name_prefix with the unrecognized flag name, removing "_out".  So, for
+                // example, if exe_name_prefix is "protoc-" and you pass the flag --foo_out,
+                // the compiler will try to run the program "protoc-gen-foo".
+                //
+                // The plugin program should implement the following usage:
+                //   plugin [--out=OUTDIR] [--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS
+                // --out indicates the output directory (as passed to the --foo_out
+                // parameter); if omitted, the current directory should be used.  --parameter
+                // gives the generator parameter, if any was provided (see below).  The
+                // PROTO_FILES list the .proto files which were given on the compiler
+                // command-line; these are the files for which the plugin is expected to
+                // generate output code.  Finally, DESCRIPTORS is an encoded FileDescriptorSet
+                // (as defined in descriptor.proto).  This is piped to the plugin's stdin.
+                // The set will include descriptors for all the files listed in PROTO_FILES as
+                // well as all files that they import.  The plugin MUST NOT attempt to read
+                // the PROTO_FILES directly -- it must use the FileDescriptorSet.
+                //
+                // The plugin should generate whatever files are necessary, as code generators
+                // normally do.  It should write the names of all files it generates to
+                // stdout.  The names should be relative to the output directory, NOT absolute
+                // names or relative to the current directory.  If any errors occur, error
+                // messages should be written to stderr.  If an error is fatal, the plugin
+                // should exit with a non-zero exit code.
+                //
+                // Plugins can have generator parameters similar to normal built-in
+                // generators. Extra generator parameters can be passed in via a matching
+                // "_opt" parameter. For example:
+                //   protoc --plug_out=enable_bar:outdir --plug_opt=enable_baz
+                // This will pass "enable_bar,enable_baz" as the parameter to the plugin.
+                //
+                void AllowPlugins(const std::string& exe_name_prefix);
+
+                // Run the Protocol Compiler with the given command-line parameters.
+                // Returns the error code which should be returned by main().
+                //
+                // It may not be safe to call Run() in a multi-threaded environment because
+                // it calls strerror().  I'm not sure why you'd want to do this anyway.
+                int Run(int argc, const char* const argv[]);
+
+                // DEPRECATED. Calling this method has no effect. Protocol compiler now
+                // always try to find the .proto file relative to the current directory
+                // first and if the file is not found, it will then treat the input path
+                // as a virtual path.
+                void SetInputsAreProtoPathRelative(bool /* enable */)
+                {
+                }
+
+                // Provides some text which will be printed when the --version flag is
+                // used.  The version of libprotoc will also be printed on the next line
+                // after this text.
+                void SetVersionInfo(const std::string& text)
+                {
+                    version_info_ = text;
+                }
+
+            private:
+                // -----------------------------------------------------------------
+
+                class ErrorPrinter;
+                class GeneratorContextImpl;
+                class MemoryOutputStream;
+                typedef std::unordered_map<std::string, std::unique_ptr<GeneratorContextImpl>>
+                    GeneratorContextMap;
+
+                // Clear state from previous Run().
+                void Clear();
+
+                // Remaps the proto file so that it is relative to one of the directories
+                // in proto_path_.  Returns false if an error occurred.
+                bool MakeProtoProtoPathRelative(DiskSourceTree* source_tree, std::string* proto, DescriptorDatabase* fallback_database);
+
+                // Remaps each file in input_files_ so that it is relative to one of the
+                // directories in proto_path_.  Returns false if an error occurred.
+                bool MakeInputsBeProtoPathRelative(DiskSourceTree* source_tree, DescriptorDatabase* fallback_database);
+
+                // Fails if these files use proto3 optional and the code generator doesn't
+                // support it. This is a permanent check.
+                bool EnforceProto3OptionalSupport(
+                    const std::string& codegen_name, uint64_t supported_features, const std::vector<const FileDescriptor*>& parsed_files
+                ) const;
+
+                // Return status for ParseArguments() and InterpretArgument().
+                enum ParseArgumentStatus
+                {
+                    PARSE_ARGUMENT_DONE_AND_CONTINUE,
+                    PARSE_ARGUMENT_DONE_AND_EXIT,
+                    PARSE_ARGUMENT_FAIL
+                };
+
+                // Parse all command-line arguments.
+                ParseArgumentStatus ParseArguments(int argc, const char* const argv[]);
+
+                // Read an argument file and append the file's content to the list of
+                // arguments. Return false if the file cannot be read.
+                bool ExpandArgumentFile(const std::string& file, std::vector<std::string>* arguments);
+
+                // Parses a command-line argument into a name/value pair.  Returns
+                // true if the next argument in the argv should be used as the value,
+                // false otherwise.
+                //
+                // Examples:
+                //   "-Isrc/protos" ->
+                //     name = "-I", value = "src/protos"
+                //   "--cpp_out=src/foo.pb2.cc" ->
+                //     name = "--cpp_out", value = "src/foo.pb2.cc"
+                //   "foo.proto" ->
+                //     name = "", value = "foo.proto"
+                bool ParseArgument(const char* arg, std::string* name, std::string* value);
+
+                // Interprets arguments parsed with ParseArgument.
+                ParseArgumentStatus InterpretArgument(const std::string& name, const std::string& value);
+
+                // Print the --help text to stderr.
+                void PrintHelpText();
+
+                // Loads proto_path_ into the provided source_tree.
+                bool InitializeDiskSourceTree(DiskSourceTree* source_tree, DescriptorDatabase* fallback_database);
+
+                // Verify that all the input files exist in the given database.
+                bool VerifyInputFilesInDescriptors(DescriptorDatabase* fallback_database);
+
+                // Parses input_files_ into parsed_files
+                bool ParseInputFiles(DescriptorPool* descriptor_pool, DiskSourceTree* source_tree, std::vector<const FileDescriptor*>* parsed_files);
+
+                // Generate the given output file from the given input.
+                struct OutputDirective;  // see below
+                bool GenerateOutput(const std::vector<const FileDescriptor*>& parsed_files, const OutputDirective& output_directive, GeneratorContext* generator_context);
+                bool GeneratePluginOutput(
+                    const std::vector<const FileDescriptor*>& parsed_files,
+                    const std::string& plugin_name,
+                    const std::string& parameter,
+                    GeneratorContext* generator_context,
+                    std::string* error
+                );
+
+                // Implements --encode and --decode.
+                bool EncodeOrDecode(const DescriptorPool* pool);
+
+                // Implements the --descriptor_set_out option.
+                bool WriteDescriptorSet(
+                    const std::vector<const FileDescriptor*>& parsed_files
+                );
+
+                // Implements the --dependency_out option
+                bool GenerateDependencyManifestFile(
+                    const std::vector<const FileDescriptor*>& parsed_files,
+                    const GeneratorContextMap& output_directories,
+                    DiskSourceTree* source_tree
+                );
+
+                // Get all transitive dependencies of the given file (including the file
+                // itself), adding them to the given list of FileDescriptorProtos.  The
+                // protos will be ordered such that every file is listed before any file that
+                // depends on it, so that you can call DescriptorPool::BuildFile() on them
+                // in order.  Any files in *already_seen will not be added, and each file
+                // added will be inserted into *already_seen.  If include_source_code_info is
+                // true then include the source code information in the FileDescriptorProtos.
+                // If include_json_name is true, populate the json_name field of
+                // FieldDescriptorProto for all fields.
+                static void GetTransitiveDependencies(
+                    const FileDescriptor* file, bool include_json_name, bool include_source_code_info, std::set<const FileDescriptor*>* already_seen, RepeatedPtrField<FileDescriptorProto>* output
+                );
+
+                // Implements the --print_free_field_numbers. This function prints free field
+                // numbers into stdout for the message and it's nested message types in
+                // post-order, i.e. nested types first. Printed range are left-right
+                // inclusive, i.e. [a, b].
+                //
+                // Groups:
+                // For historical reasons, groups are considered to share the same
+                // field number space with the parent message, thus it will not print free
+                // field numbers for groups. The field numbers used in the groups are
+                // excluded in the free field numbers of the parent message.
+                //
+                // Extension Ranges:
+                // Extension ranges are considered ocuppied field numbers and they will not be
+                // listed as free numbers in the output.
+                void PrintFreeFieldNumbers(const Descriptor* descriptor);
+
+                // -----------------------------------------------------------------
+
+                // The name of the executable as invoked (i.e. argv[0]).
+                std::string executable_name_;
+
+                // Version info set with SetVersionInfo().
+                std::string version_info_;
+
+                // Registered generators.
+                struct GeneratorInfo
+                {
+                    std::string flag_name;
+                    std::string option_flag_name;
+                    CodeGenerator* generator;
+                    std::string help_text;
+                };
+                typedef std::map<std::string, GeneratorInfo> GeneratorMap;
+                GeneratorMap generators_by_flag_name_;
+                GeneratorMap generators_by_option_name_;
+                // A map from generator names to the parameters specified using the option
+                // flag. For example, if the user invokes the compiler with:
+                //   protoc --foo_out=outputdir --foo_opt=enable_bar ...
+                // Then there will be an entry ("--foo_out", "enable_bar") in this map.
+                std::map<std::string, std::string> generator_parameters_;
+                // Similar to generator_parameters_, but stores the parameters for plugins.
+                std::map<std::string, std::string> plugin_parameters_;
+
+                // See AllowPlugins().  If this is empty, plugins aren't allowed.
+                std::string plugin_prefix_;
+
+                // Maps specific plugin names to files.  When executing a plugin, this map
+                // is searched first to find the plugin executable.  If not found here, the
+                // PATH (or other OS-specific search strategy) is searched.
+                std::map<std::string, std::string> plugins_;
+
+                // Stuff parsed from command line.
+                enum Mode
+                {
+                    MODE_COMPILE,  // Normal mode:  parse .proto files and compile them.
+                    MODE_ENCODE,   // --encode:  read text from stdin, write binary to stdout.
+                    MODE_DECODE,   // --decode:  read binary from stdin, write text to stdout.
+                    MODE_PRINT,    // Print mode: print info of the given .proto files and exit.
+                };
+
+                Mode mode_ = MODE_COMPILE;
+
+                enum PrintMode
+                {
+                    PRINT_NONE,         // Not in MODE_PRINT
+                    PRINT_FREE_FIELDS,  // --print_free_fields
+                };
+
+                PrintMode print_mode_ = PRINT_NONE;
+
+                enum ErrorFormat
+                {
+                    ERROR_FORMAT_GCC,  // GCC error output format (default).
+                    ERROR_FORMAT_MSVS  // Visual Studio output (--error_format=msvs).
+                };
+
+                ErrorFormat error_format_ = ERROR_FORMAT_GCC;
+
+                // True if we should treat warnings as errors that fail the compilation.
+                bool fatal_warnings_ = false;
+
+                std::vector<std::pair<std::string, std::string>>
+                    proto_path_;                        // Search path for proto files.
+                std::vector<std::string> input_files_;  // Names of the input proto files.
+
+                // Names of proto files which are allowed to be imported. Used by build
+                // systems to enforce depend-on-what-you-import.
+                std::set<std::string> direct_dependencies_;
+                bool direct_dependencies_explicitly_set_ = false;
+
+                // If there's a violation of depend-on-what-you-import, this string will be
+                // presented to the user. "%s" will be replaced with the violating import.
+                std::string direct_dependencies_violation_msg_;
+
+                // output_directives_ lists all the files we are supposed to output and what
+                // generator to use for each.
+                struct OutputDirective
+                {
+                    std::string name;          // E.g. "--foo_out"
+                    CodeGenerator* generator;  // NULL for plugins
+                    std::string parameter;
+                    std::string output_location;
+                };
+                std::vector<OutputDirective> output_directives_;
+
+                // When using --encode or --decode, this names the type we are encoding or
+                // decoding.  (Empty string indicates --decode_raw.)
+                std::string codec_type_;
+
+                // If --descriptor_set_in was given, these are filenames containing
+                // parsed FileDescriptorSets to be used for loading protos.  Otherwise, empty.
+                std::vector<std::string> descriptor_set_in_names_;
+
+                // If --descriptor_set_out was given, this is the filename to which the
+                // FileDescriptorSet should be written.  Otherwise, empty.
+                std::string descriptor_set_out_name_;
+
+                // If --dependency_out was given, this is the path to the file where the
+                // dependency file will be written. Otherwise, empty.
+                std::string dependency_out_name_;
+
+                // True if --include_imports was given, meaning that we should
+                // write all transitive dependencies to the DescriptorSet.  Otherwise, only
+                // the .proto files listed on the command-line are added.
+                bool imports_in_descriptor_set_;
+
+                // True if --include_source_info was given, meaning that we should not strip
+                // SourceCodeInfo from the DescriptorSet.
+                bool source_info_in_descriptor_set_ = false;
+
+                // Was the --disallow_services flag used?
+                bool disallow_services_ = false;
+
+                // When using --encode, this will be passed to SetSerializationDeterministic.
+                bool deterministic_output_ = false;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CommandLineInterface);
+            };
+
+        }  // namespace compiler
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/file.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/file.h
index ca05361..8595123 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/file.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/file.h
@@ -47,163 +47,173 @@
 #include <google/protobuf/compiler/scc.h>
 #include <google/protobuf/compiler/cpp/options.h>
 
-namespace google {
-namespace protobuf {
-class FileDescriptor;  // descriptor.h
-namespace io {
-class Printer;  // printer.h
-}
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        class FileDescriptor;  // descriptor.h
+        namespace io
+        {
+            class Printer;  // printer.h
+        }
+    }  // namespace protobuf
 }  // namespace google
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace cpp {
-
-class EnumGenerator;       // enum.h
-class MessageGenerator;    // message.h
-class ServiceGenerator;    // service.h
-class ExtensionGenerator;  // extension.h
-
-class FileGenerator {
- public:
-  // See generator.cc for the meaning of dllexport_decl.
-  FileGenerator(const FileDescriptor* file, const Options& options);
-  ~FileGenerator();
-
-  // Shared code between the two header generators below.
-  void GenerateHeader(io::Printer* printer);
-
-  // info_path, if non-empty, should be the path (relative to printer's
-  // output) to the metadata file describing this proto header.
-  void GenerateProtoHeader(io::Printer* printer, const std::string& info_path);
-  // info_path, if non-empty, should be the path (relative to printer's
-  // output) to the metadata file describing this PB header.
-  void GeneratePBHeader(io::Printer* printer, const std::string& info_path);
-  void GenerateSource(io::Printer* printer);
-
-  // The following member functions are used when the lite_implicit_weak_fields
-  // option is set. In this mode the code is organized a bit differently to
-  // promote better linker stripping of unused code. In particular, we generate
-  // one .cc file per message, one .cc file per extension, and a main pb.cc file
-  // containing everything else.
-
-  int NumMessages() const { return message_generators_.size(); }
-  int NumExtensions() const { return extension_generators_.size(); }
-  // Generates the source file for one message.
-  void GenerateSourceForMessage(int idx, io::Printer* printer);
-  // Generates the source file for one extension.
-  void GenerateSourceForExtension(int idx, io::Printer* printer);
-  // Generates a source file containing everything except messages and
-  // extensions.
-  void GenerateGlobalSource(io::Printer* printer);
-
- private:
-  // Internal type used by GenerateForwardDeclarations (defined in file.cc).
-  class ForwardDeclarations;
-  struct CrossFileReferences;
-
-  void IncludeFile(const std::string& google3_name, io::Printer* printer) {
-    DoIncludeFile(google3_name, false, printer);
-  }
-  void IncludeFileAndExport(const std::string& google3_name,
-                            io::Printer* printer) {
-    DoIncludeFile(google3_name, true, printer);
-  }
-  void DoIncludeFile(const std::string& google3_name, bool do_export,
-                     io::Printer* printer);
-
-  std::string CreateHeaderInclude(const std::string& basename,
-                                  const FileDescriptor* file);
-  void GetCrossFileReferencesForField(const FieldDescriptor* field,
-                                      CrossFileReferences* refs);
-  void GetCrossFileReferencesForFile(const FileDescriptor* file,
-                                     CrossFileReferences* refs);
-  void GenerateInternalForwardDeclarations(const CrossFileReferences& refs,
-                                           io::Printer* printer);
-  void GenerateSourceIncludes(io::Printer* printer);
-  void GenerateSourcePrelude(io::Printer* printer);
-  void GenerateSourceDefaultInstance(int idx, io::Printer* printer);
-
-  void GenerateInitForSCC(const SCC* scc, const CrossFileReferences& refs,
-                          io::Printer* printer);
-  void GenerateReflectionInitializationCode(io::Printer* printer);
-
-  // For other imports, generates their forward-declarations.
-  void GenerateForwardDeclarations(io::Printer* printer);
-
-  // Generates top or bottom of a header file.
-  void GenerateTopHeaderGuard(io::Printer* printer, bool pb_h);
-  void GenerateBottomHeaderGuard(io::Printer* printer, bool pb_h);
-
-  // Generates #include directives.
-  void GenerateLibraryIncludes(io::Printer* printer);
-  void GenerateDependencyIncludes(io::Printer* printer);
-
-  // Generate a pragma to pull in metadata using the given info_path (if
-  // non-empty). info_path should be relative to printer's output.
-  void GenerateMetadataPragma(io::Printer* printer,
-                              const std::string& info_path);
-
-  // Generates a couple of different pieces before definitions:
-  void GenerateGlobalStateFunctionDeclarations(io::Printer* printer);
-
-  // Generates types for classes.
-  void GenerateMessageDefinitions(io::Printer* printer);
-
-  void GenerateEnumDefinitions(io::Printer* printer);
-
-  // Generates generic service definitions.
-  void GenerateServiceDefinitions(io::Printer* printer);
-
-  // Generates extension identifiers.
-  void GenerateExtensionIdentifiers(io::Printer* printer);
-
-  // Generates inline function definitions.
-  void GenerateInlineFunctionDefinitions(io::Printer* printer);
-
-  void GenerateProto2NamespaceEnumSpecializations(io::Printer* printer);
-
-  // Sometimes the names we use in a .proto file happen to be defined as
-  // macros on some platforms (e.g., macro/minor used in plugin.proto are
-  // defined as macros in sys/types.h on FreeBSD and a few other platforms).
-  // To make the generated code compile on these platforms, we either have to
-  // undef the macro for these few platforms, or rename the field name for all
-  // platforms. Since these names are part of protobuf public API, renaming is
-  // generally a breaking change so we prefer the #undef approach.
-  void GenerateMacroUndefs(io::Printer* printer);
-
-  bool IsDepWeak(const FileDescriptor* dep) const {
-    if (weak_deps_.count(dep) != 0) {
-      GOOGLE_CHECK(!options_.opensource_runtime);
-      return true;
-    }
-    return false;
-  }
-
-  std::set<const FileDescriptor*> weak_deps_;
-
-  const FileDescriptor* file_;
-  const Options options_;
-
-  MessageSCCAnalyzer scc_analyzer_;
-
-  std::map<std::string, std::string> variables_;
-
-  // Contains the post-order walk of all the messages (and child messages) in
-  // this file. If you need a pre-order walk just reverse iterate.
-  std::vector<std::unique_ptr<MessageGenerator>> message_generators_;
-  std::vector<std::unique_ptr<EnumGenerator>> enum_generators_;
-  std::vector<std::unique_ptr<ServiceGenerator>> service_generators_;
-  std::vector<std::unique_ptr<ExtensionGenerator>> extension_generators_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileGenerator);
-};
-
-}  // namespace cpp
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace cpp
+            {
+
+                class EnumGenerator;       // enum.h
+                class MessageGenerator;    // message.h
+                class ServiceGenerator;    // service.h
+                class ExtensionGenerator;  // extension.h
+
+                class FileGenerator
+                {
+                public:
+                    // See generator.cc for the meaning of dllexport_decl.
+                    FileGenerator(const FileDescriptor* file, const Options& options);
+                    ~FileGenerator();
+
+                    // Shared code between the two header generators below.
+                    void GenerateHeader(io::Printer* printer);
+
+                    // info_path, if non-empty, should be the path (relative to printer's
+                    // output) to the metadata file describing this proto header.
+                    void GenerateProtoHeader(io::Printer* printer, const std::string& info_path);
+                    // info_path, if non-empty, should be the path (relative to printer's
+                    // output) to the metadata file describing this PB header.
+                    void GeneratePBHeader(io::Printer* printer, const std::string& info_path);
+                    void GenerateSource(io::Printer* printer);
+
+                    // The following member functions are used when the lite_implicit_weak_fields
+                    // option is set. In this mode the code is organized a bit differently to
+                    // promote better linker stripping of unused code. In particular, we generate
+                    // one .cc file per message, one .cc file per extension, and a main pb.cc file
+                    // containing everything else.
+
+                    int NumMessages() const
+                    {
+                        return message_generators_.size();
+                    }
+                    int NumExtensions() const
+                    {
+                        return extension_generators_.size();
+                    }
+                    // Generates the source file for one message.
+                    void GenerateSourceForMessage(int idx, io::Printer* printer);
+                    // Generates the source file for one extension.
+                    void GenerateSourceForExtension(int idx, io::Printer* printer);
+                    // Generates a source file containing everything except messages and
+                    // extensions.
+                    void GenerateGlobalSource(io::Printer* printer);
+
+                private:
+                    // Internal type used by GenerateForwardDeclarations (defined in file.cc).
+                    class ForwardDeclarations;
+                    struct CrossFileReferences;
+
+                    void IncludeFile(const std::string& google3_name, io::Printer* printer)
+                    {
+                        DoIncludeFile(google3_name, false, printer);
+                    }
+                    void IncludeFileAndExport(const std::string& google3_name, io::Printer* printer)
+                    {
+                        DoIncludeFile(google3_name, true, printer);
+                    }
+                    void DoIncludeFile(const std::string& google3_name, bool do_export, io::Printer* printer);
+
+                    std::string CreateHeaderInclude(const std::string& basename, const FileDescriptor* file);
+                    void GetCrossFileReferencesForField(const FieldDescriptor* field, CrossFileReferences* refs);
+                    void GetCrossFileReferencesForFile(const FileDescriptor* file, CrossFileReferences* refs);
+                    void GenerateInternalForwardDeclarations(const CrossFileReferences& refs, io::Printer* printer);
+                    void GenerateSourceIncludes(io::Printer* printer);
+                    void GenerateSourcePrelude(io::Printer* printer);
+                    void GenerateSourceDefaultInstance(int idx, io::Printer* printer);
+
+                    void GenerateInitForSCC(const SCC* scc, const CrossFileReferences& refs, io::Printer* printer);
+                    void GenerateReflectionInitializationCode(io::Printer* printer);
+
+                    // For other imports, generates their forward-declarations.
+                    void GenerateForwardDeclarations(io::Printer* printer);
+
+                    // Generates top or bottom of a header file.
+                    void GenerateTopHeaderGuard(io::Printer* printer, bool pb_h);
+                    void GenerateBottomHeaderGuard(io::Printer* printer, bool pb_h);
+
+                    // Generates #include directives.
+                    void GenerateLibraryIncludes(io::Printer* printer);
+                    void GenerateDependencyIncludes(io::Printer* printer);
+
+                    // Generate a pragma to pull in metadata using the given info_path (if
+                    // non-empty). info_path should be relative to printer's output.
+                    void GenerateMetadataPragma(io::Printer* printer, const std::string& info_path);
+
+                    // Generates a couple of different pieces before definitions:
+                    void GenerateGlobalStateFunctionDeclarations(io::Printer* printer);
+
+                    // Generates types for classes.
+                    void GenerateMessageDefinitions(io::Printer* printer);
+
+                    void GenerateEnumDefinitions(io::Printer* printer);
+
+                    // Generates generic service definitions.
+                    void GenerateServiceDefinitions(io::Printer* printer);
+
+                    // Generates extension identifiers.
+                    void GenerateExtensionIdentifiers(io::Printer* printer);
+
+                    // Generates inline function definitions.
+                    void GenerateInlineFunctionDefinitions(io::Printer* printer);
+
+                    void GenerateProto2NamespaceEnumSpecializations(io::Printer* printer);
+
+                    // Sometimes the names we use in a .proto file happen to be defined as
+                    // macros on some platforms (e.g., macro/minor used in plugin.proto are
+                    // defined as macros in sys/types.h on FreeBSD and a few other platforms).
+                    // To make the generated code compile on these platforms, we either have to
+                    // undef the macro for these few platforms, or rename the field name for all
+                    // platforms. Since these names are part of protobuf public API, renaming is
+                    // generally a breaking change so we prefer the #undef approach.
+                    void GenerateMacroUndefs(io::Printer* printer);
+
+                    bool IsDepWeak(const FileDescriptor* dep) const
+                    {
+                        if (weak_deps_.count(dep) != 0)
+                        {
+                            GOOGLE_CHECK(!options_.opensource_runtime);
+                            return true;
+                        }
+                        return false;
+                    }
+
+                    std::set<const FileDescriptor*> weak_deps_;
+
+                    const FileDescriptor* file_;
+                    const Options options_;
+
+                    MessageSCCAnalyzer scc_analyzer_;
+
+                    std::map<std::string, std::string> variables_;
+
+                    // Contains the post-order walk of all the messages (and child messages) in
+                    // this file. If you need a pre-order walk just reverse iterate.
+                    std::vector<std::unique_ptr<MessageGenerator>> message_generators_;
+                    std::vector<std::unique_ptr<EnumGenerator>> enum_generators_;
+                    std::vector<std::unique_ptr<ServiceGenerator>> service_generators_;
+                    std::vector<std::unique_ptr<ExtensionGenerator>> extension_generators_;
+
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileGenerator);
+                };
+
+            }  // namespace cpp
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CPP_FILE_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/generator.h
index 1a374b9..c23a6eb 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/generator.h
@@ -43,63 +43,70 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace cpp {
-
-// CodeGenerator implementation which generates a C++ source file and
-// header.  If you create your own protocol compiler binary and you want
-// it to support C++ output, you can do so by registering an instance of this
-// CodeGenerator with the CommandLineInterface in your main() function.
-class PROTOC_EXPORT CppGenerator : public CodeGenerator {
- public:
-  CppGenerator();
-  ~CppGenerator() override;
-
-  enum class Runtime {
-    kGoogle3,     // Use the internal google3 runtime.
-    kOpensource,  // Use the open-source runtime.
-
-    // Use the open-source runtime with google3 #include paths.  We make these
-    // absolute to avoid ambiguity, so the runtime will be #included like:
-    //   #include "third_party/protobuf/.../google/protobuf/message.h"
-    kOpensourceGoogle3
-  };
-
-  void set_opensource_runtime(bool opensource) {
-    opensource_runtime_ = opensource;
-  }
-
-  // If set to a non-empty string, generated code will do:
-  //   #include "<BASE>/google/protobuf/message.h"
-  // instead of:
-  //   #include <google/protobuf/message.h>
-  // This has no effect if opensource_runtime = false.
-  void set_runtime_include_base(const std::string& base) {
-    runtime_include_base_ = base;
-  }
-
-  // implements CodeGenerator ----------------------------------------
-  bool Generate(const FileDescriptor* file, const std::string& parameter,
-                GeneratorContext* generator_context,
-                std::string* error) const override;
-
-  uint64_t GetSupportedFeatures() const override {
-    // We don't fully support this yet, but this is needed to unblock the tests,
-    // and we will have full support before the experimental flag is removed.
-    return FEATURE_PROTO3_OPTIONAL;
-  }
-
- private:
-  bool opensource_runtime_ = true;
-  std::string runtime_include_base_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CppGenerator);
-};
-
-}  // namespace cpp
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace cpp
+            {
+
+                // CodeGenerator implementation which generates a C++ source file and
+                // header.  If you create your own protocol compiler binary and you want
+                // it to support C++ output, you can do so by registering an instance of this
+                // CodeGenerator with the CommandLineInterface in your main() function.
+                class PROTOC_EXPORT CppGenerator : public CodeGenerator
+                {
+                public:
+                    CppGenerator();
+                    ~CppGenerator() override;
+
+                    enum class Runtime
+                    {
+                        kGoogle3,     // Use the internal google3 runtime.
+                        kOpensource,  // Use the open-source runtime.
+
+                        // Use the open-source runtime with google3 #include paths.  We make these
+                        // absolute to avoid ambiguity, so the runtime will be #included like:
+                        //   #include "third_party/protobuf/.../google/protobuf/message.h"
+                        kOpensourceGoogle3
+                    };
+
+                    void set_opensource_runtime(bool opensource)
+                    {
+                        opensource_runtime_ = opensource;
+                    }
+
+                    // If set to a non-empty string, generated code will do:
+                    //   #include "<BASE>/google/protobuf/message.h"
+                    // instead of:
+                    //   #include <google/protobuf/message.h>
+                    // This has no effect if opensource_runtime = false.
+                    void set_runtime_include_base(const std::string& base)
+                    {
+                        runtime_include_base_ = base;
+                    }
+
+                    // implements CodeGenerator ----------------------------------------
+                    bool Generate(const FileDescriptor* file, const std::string& parameter, GeneratorContext* generator_context, std::string* error) const override;
+
+                    uint64_t GetSupportedFeatures() const override
+                    {
+                        // We don't fully support this yet, but this is needed to unblock the tests,
+                        // and we will have full support before the experimental flag is removed.
+                        return FEATURE_PROTO3_OPTIONAL;
+                    }
+
+                private:
+                    bool opensource_runtime_ = true;
+                    std::string runtime_include_base_;
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CppGenerator);
+                };
+
+            }  // namespace cpp
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/helpers.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/helpers.h
index d8dcda7..54ecb71 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/helpers.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/helpers.h
@@ -54,1009 +54,1132 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace cpp {
-
-enum class ArenaDtorNeeds { kNone = 0, kOnDemand = 1, kRequired = 2 };
-
-inline std::string ProtobufNamespace(const Options& /* options */) {
-  return "PROTOBUF_NAMESPACE_ID";
-}
-
-inline std::string MacroPrefix(const Options& /* options */) {
-  return "GOOGLE_PROTOBUF";
-}
-
-inline std::string DeprecatedAttribute(const Options& /* options */,
-                                       const FieldDescriptor* d) {
-  return d->options().deprecated() ? "PROTOBUF_DEPRECATED " : "";
-}
-
-inline std::string DeprecatedAttribute(const Options& /* options */,
-                                       const EnumValueDescriptor* d) {
-  return d->options().deprecated() ? "PROTOBUF_DEPRECATED_ENUM " : "";
-}
-
-// Commonly-used separator comments.  Thick is a line of '=', thin is a line
-// of '-'.
-extern const char kThickSeparator[];
-extern const char kThinSeparator[];
-
-void SetCommonVars(const Options& options,
-                   std::map<std::string, std::string>* variables);
-
-// Variables to access message data from the message scope.
-void SetCommonMessageDataVariables(
-    const Descriptor* descriptor,
-    std::map<std::string, std::string>* variables);
-
-void SetUnknownFieldsVariable(const Descriptor* descriptor,
-                              const Options& options,
-                              std::map<std::string, std::string>* variables);
-
-bool GetBootstrapBasename(const Options& options, const std::string& basename,
-                          std::string* bootstrap_basename);
-bool MaybeBootstrap(const Options& options, GeneratorContext* generator_context,
-                    bool bootstrap_flag, std::string* basename);
-bool IsBootstrapProto(const Options& options, const FileDescriptor* file);
-
-// Name space of the proto file. This namespace is such that the string
-// "<namespace>::some_name" is the correct fully qualified namespace.
-// This means if the package is empty the namespace is "", and otherwise
-// the namespace is "::foo::bar::...::baz" without trailing semi-colons.
-std::string Namespace(const FileDescriptor* d, const Options& options);
-std::string Namespace(const Descriptor* d, const Options& options);
-std::string Namespace(const FieldDescriptor* d, const Options& options);
-std::string Namespace(const EnumDescriptor* d, const Options& options);
-
-// Returns true if it's safe to reset "field" to zero.
-bool CanInitializeByZeroing(const FieldDescriptor* field);
-
-std::string ClassName(const Descriptor* descriptor);
-std::string ClassName(const EnumDescriptor* enum_descriptor);
-
-std::string QualifiedClassName(const Descriptor* d, const Options& options);
-std::string QualifiedClassName(const EnumDescriptor* d, const Options& options);
-
-std::string QualifiedClassName(const Descriptor* d);
-std::string QualifiedClassName(const EnumDescriptor* d);
-
-// DEPRECATED just use ClassName or QualifiedClassName, a boolean is very
-// unreadable at the callsite.
-// Returns the non-nested type name for the given type.  If "qualified" is
-// true, prefix the type with the full namespace.  For example, if you had:
-//   package foo.bar;
-//   message Baz { message Moo {} }
-// Then the qualified ClassName for Moo would be:
-//   ::foo::bar::Baz_Moo
-// While the non-qualified version would be:
-//   Baz_Moo
-inline std::string ClassName(const Descriptor* descriptor, bool qualified) {
-  return qualified ? QualifiedClassName(descriptor, Options())
-                   : ClassName(descriptor);
-}
-
-inline std::string ClassName(const EnumDescriptor* descriptor, bool qualified) {
-  return qualified ? QualifiedClassName(descriptor, Options())
-                   : ClassName(descriptor);
-}
-
-// Returns the extension name prefixed with the class name if nested but without
-// the package name.
-std::string ExtensionName(const FieldDescriptor* d);
-
-std::string QualifiedExtensionName(const FieldDescriptor* d,
-                                   const Options& options);
-std::string QualifiedExtensionName(const FieldDescriptor* d);
-
-// Type name of default instance.
-std::string DefaultInstanceType(const Descriptor* descriptor,
-                                const Options& options, bool split = false);
-
-// Non-qualified name of the default_instance of this message.
-std::string DefaultInstanceName(const Descriptor* descriptor,
-                                const Options& options, bool split = false);
-
-// Non-qualified name of the default instance pointer. This is used only for
-// implicit weak fields, where we need an extra indirection.
-std::string DefaultInstancePtr(const Descriptor* descriptor,
-                               const Options& options, bool split = false);
-
-// Fully qualified name of the default_instance of this message.
-std::string QualifiedDefaultInstanceName(const Descriptor* descriptor,
-                                         const Options& options,
-                                         bool split = false);
-
-// Fully qualified name of the default instance pointer.
-std::string QualifiedDefaultInstancePtr(const Descriptor* descriptor,
-                                        const Options& options,
-                                        bool split = false);
-
-// DescriptorTable variable name.
-std::string DescriptorTableName(const FileDescriptor* file,
-                                const Options& options);
-
-// When declaring symbol externs from another file, this macro will supply the
-// dllexport needed for the target file, if any.
-std::string FileDllExport(const FileDescriptor* file, const Options& options);
-
-// Name of the base class: google::protobuf::Message or google::protobuf::MessageLite.
-std::string SuperClassName(const Descriptor* descriptor,
-                           const Options& options);
-
-// Adds an underscore if necessary to prevent conflicting with a keyword.
-std::string ResolveKeyword(const std::string& name);
-
-// Get the (unqualified) name that should be used for this field in C++ code.
-// The name is coerced to lower-case to emulate proto1 behavior.  People
-// should be using lowercase-with-underscores style for proto field names
-// anyway, so normally this just returns field->name().
-std::string FieldName(const FieldDescriptor* field);
-
-// Returns the (unqualified) private member name for this field in C++ code.
-std::string FieldMemberName(const FieldDescriptor* field, bool split);
-
-// Returns an estimate of the compiler's alignment for the field.  This
-// can't guarantee to be correct because the generated code could be compiled on
-// different systems with different alignment rules.  The estimates below assume
-// 64-bit pointers.
-int EstimateAlignmentSize(const FieldDescriptor* field);
-
-// Get the unqualified name that should be used for a field's field
-// number constant.
-std::string FieldConstantName(const FieldDescriptor* field);
-
-// Returns the scope where the field was defined (for extensions, this is
-// different from the message type to which the field applies).
-inline const Descriptor* FieldScope(const FieldDescriptor* field) {
-  return field->is_extension() ? field->extension_scope()
-                               : field->containing_type();
-}
-
-// Returns the fully-qualified type name field->message_type().  Usually this
-// is just ClassName(field->message_type(), true);
-std::string FieldMessageTypeName(const FieldDescriptor* field,
-                                 const Options& options);
-
-// Get the C++ type name for a primitive type (e.g. "double", "::google::protobuf::int32", etc.).
-const char* PrimitiveTypeName(FieldDescriptor::CppType type);
-std::string PrimitiveTypeName(const Options& options,
-                              FieldDescriptor::CppType type);
-
-// Get the declared type name in CamelCase format, as is used e.g. for the
-// methods of WireFormat.  For example, TYPE_INT32 becomes "Int32".
-const char* DeclaredTypeMethodName(FieldDescriptor::Type type);
-
-// Return the code that evaluates to the number when compiled.
-std::string Int32ToString(int number);
-
-// Get code that evaluates to the field's default value.
-std::string DefaultValue(const Options& options, const FieldDescriptor* field);
-
-// Compatibility function for callers outside proto2.
-std::string DefaultValue(const FieldDescriptor* field);
-
-// Convert a file name into a valid identifier.
-std::string FilenameIdentifier(const std::string& filename);
-
-// For each .proto file generates a unique name. To prevent collisions of
-// symbols in the global namespace
-std::string UniqueName(const std::string& name, const std::string& filename,
-                       const Options& options);
-inline std::string UniqueName(const std::string& name, const FileDescriptor* d,
-                              const Options& options) {
-  return UniqueName(name, d->name(), options);
-}
-inline std::string UniqueName(const std::string& name, const Descriptor* d,
-                              const Options& options) {
-  return UniqueName(name, d->file(), options);
-}
-inline std::string UniqueName(const std::string& name, const EnumDescriptor* d,
-                              const Options& options) {
-  return UniqueName(name, d->file(), options);
-}
-inline std::string UniqueName(const std::string& name,
-                              const ServiceDescriptor* d,
-                              const Options& options) {
-  return UniqueName(name, d->file(), options);
-}
-
-// Versions for call sites that only support the internal runtime (like proto1
-// support).
-inline Options InternalRuntimeOptions() {
-  Options options;
-  options.opensource_runtime = false;
-  return options;
-}
-inline std::string UniqueName(const std::string& name,
-                              const std::string& filename) {
-  return UniqueName(name, filename, InternalRuntimeOptions());
-}
-inline std::string UniqueName(const std::string& name,
-                              const FileDescriptor* d) {
-  return UniqueName(name, d->name(), InternalRuntimeOptions());
-}
-inline std::string UniqueName(const std::string& name, const Descriptor* d) {
-  return UniqueName(name, d->file(), InternalRuntimeOptions());
-}
-inline std::string UniqueName(const std::string& name,
-                              const EnumDescriptor* d) {
-  return UniqueName(name, d->file(), InternalRuntimeOptions());
-}
-inline std::string UniqueName(const std::string& name,
-                              const ServiceDescriptor* d) {
-  return UniqueName(name, d->file(), InternalRuntimeOptions());
-}
-
-// Return the qualified C++ name for a file level symbol.
-std::string QualifiedFileLevelSymbol(const FileDescriptor* file,
-                                     const std::string& name,
-                                     const Options& options);
-
-// Escape C++ trigraphs by escaping question marks to \?
-std::string EscapeTrigraphs(const std::string& to_escape);
-
-// Escaped function name to eliminate naming conflict.
-std::string SafeFunctionName(const Descriptor* descriptor,
-                             const FieldDescriptor* field,
-                             const std::string& prefix);
-
-// Returns true if generated messages have public unknown fields accessors
-inline bool PublicUnknownFieldsAccessors(const Descriptor* message) {
-  return message->file()->syntax() != FileDescriptor::SYNTAX_PROTO3;
-}
-
-// Returns the optimize mode for <file>, respecting <options.enforce_lite>.
-FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file,
-                                        const Options& options);
-
-// Determines whether unknown fields will be stored in an UnknownFieldSet or
-// a string.
-inline bool UseUnknownFieldSet(const FileDescriptor* file,
-                               const Options& options) {
-  return GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME;
-}
-
-inline bool IsWeak(const FieldDescriptor* field, const Options& options) {
-  if (field->options().weak()) {
-    GOOGLE_CHECK(!options.opensource_runtime);
-    return true;
-  }
-  return false;
-}
-
-bool IsStringInlined(const FieldDescriptor* descriptor, const Options& options);
-
-// For a string field, returns the effective ctype.  If the actual ctype is
-// not supported, returns the default of STRING.
-FieldOptions::CType EffectiveStringCType(const FieldDescriptor* field,
-                                         const Options& options);
-
-inline bool IsCord(const FieldDescriptor* field, const Options& options) {
-  return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
-         EffectiveStringCType(field, options) == FieldOptions::CORD;
-}
-
-inline bool IsString(const FieldDescriptor* field, const Options& options) {
-  return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
-         EffectiveStringCType(field, options) == FieldOptions::STRING;
-}
-
-inline bool IsStringPiece(const FieldDescriptor* field,
-                          const Options& options) {
-  return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
-         EffectiveStringCType(field, options) == FieldOptions::STRING_PIECE;
-}
-
-class MessageSCCAnalyzer;
-
-// Does the given FileDescriptor use lazy fields?
-bool HasLazyFields(const FileDescriptor* file, const Options& options,
-                   MessageSCCAnalyzer* scc_analyzer);
-
-// Is the given field a supported lazy field?
-bool IsLazy(const FieldDescriptor* field, const Options& options,
-            MessageSCCAnalyzer* scc_analyzer);
-
-// Is this an explicit (non-profile driven) lazy field, as denoted by
-// lazy/unverified_lazy in the descriptor?
-inline bool IsExplicitLazy(const FieldDescriptor* field) {
-  return field->options().lazy() || field->options().unverified_lazy();
-}
-
-bool IsEagerlyVerifiedLazy(const FieldDescriptor* field, const Options& options,
-                           MessageSCCAnalyzer* scc_analyzer);
-
-bool IsLazilyVerifiedLazy(const FieldDescriptor* field, const Options& options);
-
-// Is the given message being split (go/pdsplit)?
-bool ShouldSplit(const Descriptor* desc, const Options& options);
-
-// Is the given field being split out?
-bool ShouldSplit(const FieldDescriptor* field, const Options& options);
-
-inline bool IsFieldUsed(const FieldDescriptor* /* field */,
-                        const Options& /* options */) {
-  return true;
-}
-
-// Returns true if "field" is stripped.
-inline bool IsFieldStripped(const FieldDescriptor* /*field*/,
-                            const Options& /*options*/) {
-  return false;
-}
-
-// Does the file contain any definitions that need extension_set.h?
-bool HasExtensionsOrExtendableMessage(const FileDescriptor* file);
-
-// Does the file have any repeated fields, necessitating the file to include
-// repeated_field.h? This does not include repeated extensions, since those are
-// all stored internally in an ExtensionSet, not a separate RepeatedField*.
-bool HasRepeatedFields(const FileDescriptor* file);
-
-// Does the file have any string/bytes fields with ctype=STRING_PIECE? This
-// does not include extensions, since ctype is ignored for extensions.
-bool HasStringPieceFields(const FileDescriptor* file, const Options& options);
-
-// Does the file have any string/bytes fields with ctype=CORD? This does not
-// include extensions, since ctype is ignored for extensions.
-bool HasCordFields(const FileDescriptor* file, const Options& options);
-
-// Does the file have any map fields, necessitating the file to include
-// map_field_inl.h and map.h.
-bool HasMapFields(const FileDescriptor* file);
-
-// Does this file have any enum type definitions?
-bool HasEnumDefinitions(const FileDescriptor* file);
-
-// Does this file have generated parsing, serialization, and other
-// standard methods for which reflection-based fallback implementations exist?
-inline bool HasGeneratedMethods(const FileDescriptor* file,
-                                const Options& options) {
-  return GetOptimizeFor(file, options) != FileOptions::CODE_SIZE;
-}
-
-// Do message classes in this file have descriptor and reflection methods?
-inline bool HasDescriptorMethods(const FileDescriptor* file,
-                                 const Options& options) {
-  return GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME;
-}
-
-// Should we generate generic services for this file?
-inline bool HasGenericServices(const FileDescriptor* file,
-                               const Options& options) {
-  return file->service_count() > 0 &&
-         GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME &&
-         file->options().cc_generic_services();
-}
-
-inline bool IsProto2MessageSet(const Descriptor* descriptor,
-                               const Options& options) {
-  return !options.opensource_runtime &&
-         options.enforce_mode != EnforceOptimizeMode::kLiteRuntime &&
-         !options.lite_implicit_weak_fields &&
-         descriptor->options().message_set_wire_format() &&
-         descriptor->full_name() == "google.protobuf.bridge.MessageSet";
-}
-
-inline bool IsMapEntryMessage(const Descriptor* descriptor) {
-  return descriptor->options().map_entry();
-}
-
-// Returns true if the field's CPPTYPE is string or message.
-bool IsStringOrMessage(const FieldDescriptor* field);
-
-std::string UnderscoresToCamelCase(const std::string& input,
-                                   bool cap_next_letter);
-
-inline bool IsProto3(const FileDescriptor* file) {
-  return file->syntax() == FileDescriptor::SYNTAX_PROTO3;
-}
-
-inline bool HasHasbit(const FieldDescriptor* field) {
-  // This predicate includes proto3 message fields only if they have "optional".
-  //   Foo submsg1 = 1;           // HasHasbit() == false
-  //   optional Foo submsg2 = 2;  // HasHasbit() == true
-  // This is slightly odd, as adding "optional" to a singular proto3 field does
-  // not change the semantics or API. However whenever any field in a message
-  // has a hasbit, it forces reflection to include hasbit offsets for *all*
-  // fields, even if almost all of them are set to -1 (no hasbit). So to avoid
-  // causing a sudden size regression for ~all proto3 messages, we give proto3
-  // message fields a hasbit only if "optional" is present. If the user is
-  // explicitly writing "optional", it is likely they are writing it on
-  // primitive fields also.
-  return (field->has_optional_keyword() || field->is_required()) &&
-         !field->options().weak();
-}
-
-// Returns true if 'enum' semantics are such that unknown values are preserved
-// in the enum field itself, rather than going to the UnknownFieldSet.
-inline bool HasPreservingUnknownEnumSemantics(const FieldDescriptor* field) {
-  return field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3;
-}
-
-inline bool IsCrossFileMessage(const FieldDescriptor* field) {
-  return field->type() == FieldDescriptor::TYPE_MESSAGE &&
-         field->message_type()->file() != field->file();
-}
-
-inline std::string MakeDefaultName(const FieldDescriptor* field) {
-  return StrCat("_i_give_permission_to_break_this_code_default_",
-                      FieldName(field), "_");
-}
-
-// Semantically distinct from MakeDefaultName in that it gives the C++ code
-// referencing a default field from the message scope, rather than just the
-// variable name.
-// For example, declarations of default variables should always use just
-// MakeDefaultName to produce code like:
-//   Type _i_give_permission_to_break_this_code_default_field_;
-//
-// Code that references these should use MakeDefaultFieldName, in case the field
-// exists at some nested level like:
-//   internal_container_._i_give_permission_to_break_this_code_default_field_;
-inline std::string MakeDefaultFieldName(const FieldDescriptor* field) {
-  return StrCat("Impl_::", MakeDefaultName(field));
-}
-
-inline std::string MakeVarintCachedSizeName(const FieldDescriptor* field) {
-  return StrCat("_", FieldName(field), "_cached_byte_size_");
-}
-
-// Semantically distinct from MakeVarintCachedSizeName in that it gives the C++
-// code referencing the object from the message scope, rather than just the
-// variable name.
-// For example, declarations of default variables should always use just
-// MakeVarintCachedSizeName to produce code like:
-//   Type _field_cached_byte_size_;
-//
-// Code that references these variables should use
-// MakeVarintCachedSizeFieldName, in case the field exists at some nested level
-// like:
-//   internal_container_._field_cached_byte_size_;
-inline std::string MakeVarintCachedSizeFieldName(const FieldDescriptor* field,
-                                                 bool split) {
-  return StrCat("_impl_.", split ? "_split_->" : "", "_",
-                      FieldName(field), "_cached_byte_size_");
-}
-
-// Note: A lot of libraries detect Any protos based on Descriptor::full_name()
-// while the two functions below use FileDescriptor::name(). In a sane world the
-// two approaches should be equivalent. But if you are dealing with descriptors
-// from untrusted sources, you might need to match semantics across libraries.
-bool IsAnyMessage(const FileDescriptor* descriptor, const Options& options);
-bool IsAnyMessage(const Descriptor* descriptor, const Options& options);
-
-bool IsWellKnownMessage(const FileDescriptor* descriptor);
-
-inline std::string IncludeGuard(const FileDescriptor* file, bool pb_h,
-                                const Options& options) {
-  // If we are generating a .pb.h file and the proto_h option is enabled, then
-  // the .pb.h gets an extra suffix.
-  std::string filename_identifier = FilenameIdentifier(
-      file->name() + (pb_h && options.proto_h ? ".pb.h" : ""));
-
-  if (IsWellKnownMessage(file)) {
-    // For well-known messages we need third_party/protobuf and net/proto2 to
-    // have distinct include guards, because some source files include both and
-    // both need to be defined (the third_party copies will be in the
-    // google::protobuf_opensource namespace).
-    return MacroPrefix(options) + "_INCLUDED_" + filename_identifier;
-  } else {
-    // Ideally this case would use distinct include guards for opensource and
-    // google3 protos also.  (The behavior of "first #included wins" is not
-    // ideal).  But unfortunately some legacy code includes both and depends on
-    // the identical include guards to avoid compile errors.
-    //
-    // We should clean this up so that this case can be removed.
-    return "GOOGLE_PROTOBUF_INCLUDED_" + filename_identifier;
-  }
-}
-
-// Returns the OptimizeMode for this file, furthermore it updates a status
-// bool if has_opt_codesize_extension is non-null. If this status bool is true
-// it means this file contains an extension that itself is defined as
-// optimized_for = CODE_SIZE.
-FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file,
-                                        const Options& options,
-                                        bool* has_opt_codesize_extension);
-inline FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file,
-                                               const Options& options) {
-  return GetOptimizeFor(file, options, nullptr);
-}
-inline bool NeedsEagerDescriptorAssignment(const FileDescriptor* file,
-                                           const Options& options) {
-  bool has_opt_codesize_extension;
-  if (GetOptimizeFor(file, options, &has_opt_codesize_extension) ==
-          FileOptions::CODE_SIZE &&
-      has_opt_codesize_extension) {
-    // If this filedescriptor contains an extension from another file which
-    // is optimized_for = CODE_SIZE. We need to be careful in the ordering so
-    // we eagerly build the descriptors in the dependencies before building
-    // the descriptors of this file.
-    return true;
-  } else {
-    // If we have a generated code based parser we never need eager
-    // initialization of descriptors of our deps.
-    return false;
-  }
-}
-
-// This orders the messages in a .pb.cc as it's outputted by file.cc
-void FlattenMessagesInFile(const FileDescriptor* file,
-                           std::vector<const Descriptor*>* result);
-inline std::vector<const Descriptor*> FlattenMessagesInFile(
-    const FileDescriptor* file) {
-  std::vector<const Descriptor*> result;
-  FlattenMessagesInFile(file, &result);
-  return result;
-}
-
-template <typename F>
-void ForEachMessage(const Descriptor* descriptor, F&& func) {
-  for (int i = 0; i < descriptor->nested_type_count(); i++)
-    ForEachMessage(descriptor->nested_type(i), std::forward<F&&>(func));
-  func(descriptor);
-}
-
-template <typename F>
-void ForEachMessage(const FileDescriptor* descriptor, F&& func) {
-  for (int i = 0; i < descriptor->message_type_count(); i++)
-    ForEachMessage(descriptor->message_type(i), std::forward<F&&>(func));
-}
-
-bool HasWeakFields(const Descriptor* desc, const Options& options);
-bool HasWeakFields(const FileDescriptor* desc, const Options& options);
-
-// Returns true if the "required" restriction check should be ignored for the
-// given field.
-inline static bool ShouldIgnoreRequiredFieldCheck(const FieldDescriptor* field,
-                                                  const Options& options) {
-  // Do not check "required" for lazily verified lazy fields.
-  return IsLazilyVerifiedLazy(field, options);
-}
-
-struct MessageAnalysis {
-  bool is_recursive = false;
-  bool contains_cord = false;
-  bool contains_extension = false;
-  bool contains_required = false;
-  bool contains_weak = false;  // Implicit weak as well.
-};
-
-// This class is used in FileGenerator, to ensure linear instead of
-// quadratic performance, if we do this per message we would get O(V*(V+E)).
-// Logically this is just only used in message.cc, but in the header for
-// FileGenerator to help share it.
-class PROTOC_EXPORT MessageSCCAnalyzer {
- public:
-  explicit MessageSCCAnalyzer(const Options& options) : options_(options) {}
-
-  MessageAnalysis GetSCCAnalysis(const SCC* scc);
-
-  bool HasRequiredFields(const Descriptor* descriptor) {
-    MessageAnalysis result = GetSCCAnalysis(GetSCC(descriptor));
-    return result.contains_required || result.contains_extension;
-  }
-  bool HasWeakField(const Descriptor* descriptor) {
-    MessageAnalysis result = GetSCCAnalysis(GetSCC(descriptor));
-    return result.contains_weak;
-  }
-  const SCC* GetSCC(const Descriptor* descriptor) {
-    return analyzer_.GetSCC(descriptor);
-  }
-
- private:
-  struct DepsGenerator {
-    std::vector<const Descriptor*> operator()(const Descriptor* desc) const {
-      std::vector<const Descriptor*> deps;
-      for (int i = 0; i < desc->field_count(); i++) {
-        if (desc->field(i)->message_type()) {
-          deps.push_back(desc->field(i)->message_type());
-        }
-      }
-      return deps;
-    }
-  };
-  SCCAnalyzer<DepsGenerator> analyzer_;
-  Options options_;
-  std::map<const SCC*, MessageAnalysis> analysis_cache_;
-};
-
-void ListAllFields(const Descriptor* d,
-                   std::vector<const FieldDescriptor*>* fields);
-void ListAllFields(const FileDescriptor* d,
-                   std::vector<const FieldDescriptor*>* fields);
-
-template <class T>
-void ForEachField(const Descriptor* d, T&& func) {
-  for (int i = 0; i < d->nested_type_count(); i++) {
-    ForEachField(d->nested_type(i), std::forward<T&&>(func));
-  }
-  for (int i = 0; i < d->extension_count(); i++) {
-    func(d->extension(i));
-  }
-  for (int i = 0; i < d->field_count(); i++) {
-    func(d->field(i));
-  }
-}
-
-template <class T>
-void ForEachField(const FileDescriptor* d, T&& func) {
-  for (int i = 0; i < d->message_type_count(); i++) {
-    ForEachField(d->message_type(i), std::forward<T&&>(func));
-  }
-  for (int i = 0; i < d->extension_count(); i++) {
-    func(d->extension(i));
-  }
-}
-
-void ListAllTypesForServices(const FileDescriptor* fd,
-                             std::vector<const Descriptor*>* types);
-
-// Indicates whether we should use implicit weak fields for this file.
-bool UsingImplicitWeakFields(const FileDescriptor* file,
-                             const Options& options);
-
-// Indicates whether to treat this field as implicitly weak.
-bool IsImplicitWeakField(const FieldDescriptor* field, const Options& options,
-                         MessageSCCAnalyzer* scc_analyzer);
-
-inline bool HasSimpleBaseClass(const Descriptor* desc, const Options& options) {
-  if (!HasDescriptorMethods(desc->file(), options)) return false;
-  if (desc->extension_range_count() != 0) return false;
-  if (desc->field_count() == 0) return true;
-  // TODO(jorg): Support additional common message types with only one
-  // or two fields
-  return false;
-}
-
-inline bool HasSimpleBaseClasses(const FileDescriptor* file,
-                                 const Options& options) {
-  bool v = false;
-  ForEachMessage(file, [&v, &options](const Descriptor* desc) {
-    v |= HasSimpleBaseClass(desc, options);
-  });
-  return v;
-}
-
-inline std::string SimpleBaseClass(const Descriptor* desc,
-                                   const Options& options) {
-  if (!HasDescriptorMethods(desc->file(), options)) return "";
-  if (desc->extension_range_count() != 0) return "";
-  if (desc->field_count() == 0) {
-    return "ZeroFieldsBase";
-  }
-  // TODO(jorg): Support additional common message types with only one
-  // or two fields
-  return "";
-}
-
-// Returns true if this message has a _tracker_ field.
-inline bool HasTracker(const Descriptor* desc, const Options& options) {
-  return options.field_listener_options.inject_field_listener_events &&
-         desc->file()->options().optimize_for() !=
-             google::protobuf::FileOptions::LITE_RUNTIME;
-}
-
-// Returns true if this message needs an Impl_ struct for it's data.
-inline bool HasImplData(const Descriptor* desc, const Options& options) {
-  return !HasSimpleBaseClass(desc, options);
-}
-
-// Formatter is a functor class which acts as a closure around printer and
-// the variable map. It's much like printer->Print except it supports both named
-// variables that are substituted using a key value map and direct arguments. In
-// the format string $1$, $2$, etc... are substituted for the first, second, ...
-// direct argument respectively in the format call, it accepts both strings and
-// integers. The implementation verifies all arguments are used and are "first"
-// used in order of appearance in the argument list. For example,
-//
-// Format("return array[$1$];", 3) -> "return array[3];"
-// Format("array[$2$] = $1$;", "Bla", 3) -> FATAL error (wrong order)
-// Format("array[$1$] = $2$;", 3, "Bla") -> "array[3] = Bla;"
-//
-// The arguments can be used more than once like
-//
-// Format("array[$1$] = $2$;  // Index = $1$", 3, "Bla") ->
-//        "array[3] = Bla;  // Index = 3"
-//
-// If you use more arguments use the following style to help the reader,
-//
-// Format("int $1$() {\n"
-//        "  array[$2$] = $3$;\n"
-//        "  return $4$;"
-//        "}\n",
-//        funname, // 1
-//        idx,  // 2
-//        varname,  // 3
-//        retval);  // 4
-//
-// but consider using named variables. Named variables like $foo$, with some
-// identifier foo, are looked up in the map. One additional feature is that
-// spaces are accepted between the '$' delimiters, $ foo$ will
-// substitute to " bar" if foo stands for "bar", but in case it's empty
-// will substitute to "". Hence, for example,
-//
-// Format(vars, "$dllexport $void fun();") -> "void fun();"
-//                                            "__declspec(export) void fun();"
-//
-// which is convenient to prevent double, leading or trailing spaces.
-class PROTOC_EXPORT Formatter {
- public:
-  explicit Formatter(io::Printer* printer) : printer_(printer) {}
-  Formatter(io::Printer* printer,
-            const std::map<std::string, std::string>& vars)
-      : printer_(printer), vars_(vars) {}
-
-  template <typename T>
-  void Set(const std::string& key, const T& value) {
-    vars_[key] = ToString(value);
-  }
-
-  void AddMap(const std::map<std::string, std::string>& vars) {
-    for (const auto& keyval : vars) vars_[keyval.first] = keyval.second;
-  }
-
-  template <typename... Args>
-  void operator()(const char* format, const Args&... args) const {
-    printer_->FormatInternal({ToString(args)...}, vars_, format);
-  }
-
-  void Indent() const { printer_->Indent(); }
-  void Outdent() const { printer_->Outdent(); }
-  io::Printer* printer() const { return printer_; }
-
-  class PROTOC_EXPORT ScopedIndenter {
-   public:
-    explicit ScopedIndenter(Formatter* format) : format_(format) {
-      format_->Indent();
-    }
-    ~ScopedIndenter() { format_->Outdent(); }
-
-   private:
-    Formatter* format_;
-  };
-
-  PROTOBUF_NODISCARD ScopedIndenter ScopedIndent() {
-    return ScopedIndenter(this);
-  }
-  template <typename... Args>
-  PROTOBUF_NODISCARD ScopedIndenter ScopedIndent(const char* format,
-                                                 const Args&&... args) {
-    (*this)(format, static_cast<Args&&>(args)...);
-    return ScopedIndenter(this);
-  }
-
-  class PROTOC_EXPORT SaveState {
-   public:
-    explicit SaveState(Formatter* format)
-        : format_(format), vars_(format->vars_) {}
-    ~SaveState() { format_->vars_.swap(vars_); }
-
-   private:
-    Formatter* format_;
-    std::map<std::string, std::string> vars_;
-  };
-
- private:
-  io::Printer* printer_;
-  std::map<std::string, std::string> vars_;
-
-  // Convenience overloads to accept different types as arguments.
-  static std::string ToString(const std::string& s) { return s; }
-  template <typename I, typename = typename std::enable_if<
-                            std::is_integral<I>::value>::type>
-  static std::string ToString(I x) {
-    return StrCat(x);
-  }
-  static std::string ToString(strings::Hex x) { return StrCat(x); }
-  static std::string ToString(const FieldDescriptor* d) { return Payload(d); }
-  static std::string ToString(const Descriptor* d) { return Payload(d); }
-  static std::string ToString(const EnumDescriptor* d) { return Payload(d); }
-  static std::string ToString(const EnumValueDescriptor* d) {
-    return Payload(d);
-  }
-  static std::string ToString(const OneofDescriptor* d) { return Payload(d); }
-
-  template <typename Descriptor>
-  static std::string Payload(const Descriptor* descriptor) {
-    std::vector<int> path;
-    descriptor->GetLocationPath(&path);
-    GeneratedCodeInfo::Annotation annotation;
-    for (int index : path) {
-      annotation.add_path(index);
-    }
-    annotation.set_source_file(descriptor->file()->name());
-    return annotation.SerializeAsString();
-  }
-};
-
-template <class T>
-void PrintFieldComment(const Formatter& format, const T* field) {
-  // Print the field's (or oneof's) proto-syntax definition as a comment.
-  // We don't want to print group bodies so we cut off after the first
-  // line.
-  DebugStringOptions options;
-  options.elide_group_body = true;
-  options.elide_oneof_body = true;
-  std::string def = field->DebugStringWithOptions(options);
-  format("// $1$\n", def.substr(0, def.find_first_of('\n')));
-}
-
-class PROTOC_EXPORT NamespaceOpener {
- public:
-  explicit NamespaceOpener(const Formatter& format)
-      : printer_(format.printer()) {}
-  NamespaceOpener(const std::string& name, const Formatter& format)
-      : NamespaceOpener(format) {
-    ChangeTo(name);
-  }
-  ~NamespaceOpener() { ChangeTo(""); }
-
-  void ChangeTo(const std::string& name) {
-    std::vector<std::string> new_stack_ =
-        Split(name, "::", true);
-    size_t len = std::min(name_stack_.size(), new_stack_.size());
-    size_t common_idx = 0;
-    while (common_idx < len) {
-      if (name_stack_[common_idx] != new_stack_[common_idx]) break;
-      common_idx++;
-    }
-    for (auto it = name_stack_.crbegin();
-         it != name_stack_.crend() - common_idx; ++it) {
-      if (*it == "PROTOBUF_NAMESPACE_ID") {
-        printer_->Print("PROTOBUF_NAMESPACE_CLOSE\n");
-      } else {
-        printer_->Print("}  // namespace $ns$\n", "ns", *it);
-      }
-    }
-    name_stack_.swap(new_stack_);
-    for (size_t i = common_idx; i < name_stack_.size(); ++i) {
-      if (name_stack_[i] == "PROTOBUF_NAMESPACE_ID") {
-        printer_->Print("PROTOBUF_NAMESPACE_OPEN\n");
-      } else {
-        printer_->Print("namespace $ns$ {\n", "ns", name_stack_[i]);
-      }
-    }
-  }
-
- private:
-  io::Printer* printer_;
-  std::vector<std::string> name_stack_;
-};
-
-enum class Utf8CheckMode {
-  kStrict = 0,  // Parsing will fail if non UTF-8 data is in string fields.
-  kVerify = 1,  // Only log an error but parsing will succeed.
-  kNone = 2,    // No UTF-8 check.
-};
-
-Utf8CheckMode GetUtf8CheckMode(const FieldDescriptor* field,
-                               const Options& options);
-
-void GenerateUtf8CheckCodeForString(const FieldDescriptor* field,
-                                    const Options& options, bool for_parse,
-                                    const char* parameters,
-                                    const Formatter& format);
-
-void GenerateUtf8CheckCodeForCord(const FieldDescriptor* field,
-                                  const Options& options, bool for_parse,
-                                  const char* parameters,
-                                  const Formatter& format);
-
-template <typename T>
-struct FieldRangeImpl {
-  struct Iterator {
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = const FieldDescriptor*;
-    using difference_type = int;
-
-    value_type operator*() { return descriptor->field(idx); }
-
-    friend bool operator==(const Iterator& a, const Iterator& b) {
-      GOOGLE_DCHECK(a.descriptor == b.descriptor);
-      return a.idx == b.idx;
-    }
-    friend bool operator!=(const Iterator& a, const Iterator& b) {
-      return !(a == b);
-    }
-
-    Iterator& operator++() {
-      idx++;
-      return *this;
-    }
-
-    int idx;
-    const T* descriptor;
-  };
-
-  Iterator begin() const { return {0, descriptor}; }
-  Iterator end() const { return {descriptor->field_count(), descriptor}; }
-
-  const T* descriptor;
-};
-
-template <typename T>
-FieldRangeImpl<T> FieldRange(const T* desc) {
-  return {desc};
-}
-
-struct OneOfRangeImpl {
-  struct Iterator {
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = const OneofDescriptor*;
-    using difference_type = int;
-
-    value_type operator*() { return descriptor->oneof_decl(idx); }
-
-    friend bool operator==(const Iterator& a, const Iterator& b) {
-      GOOGLE_DCHECK(a.descriptor == b.descriptor);
-      return a.idx == b.idx;
-    }
-    friend bool operator!=(const Iterator& a, const Iterator& b) {
-      return !(a == b);
-    }
-
-    Iterator& operator++() {
-      idx++;
-      return *this;
-    }
-
-    int idx;
-    const Descriptor* descriptor;
-  };
-
-  Iterator begin() const { return {0, descriptor}; }
-  Iterator end() const {
-    return {descriptor->real_oneof_decl_count(), descriptor};
-  }
-
-  const Descriptor* descriptor;
-};
-
-inline OneOfRangeImpl OneOfRange(const Descriptor* desc) { return {desc}; }
-
-PROTOC_EXPORT std::string StripProto(const std::string& filename);
-
-bool EnableMessageOwnedArena(const Descriptor* desc, const Options& options);
-
-bool EnableMessageOwnedArenaTrial(const Descriptor* desc,
-                                  const Options& options);
-
-bool ShouldVerify(const Descriptor* descriptor, const Options& options,
-                  MessageSCCAnalyzer* scc_analyzer);
-bool ShouldVerify(const FileDescriptor* file, const Options& options,
-                  MessageSCCAnalyzer* scc_analyzer);
-
-// Indicates whether to use predefined verify methods for a given message. If a
-// message is "simple" and needs no special verification per field (e.g. message
-// field, repeated packed, UTF8 string, etc.), we can use either VerifySimple or
-// VerifySimpleAlwaysCheckInt32 methods as all verification can be done based on
-// the wire type.
-//
-// Otherwise, we need "custom" verify methods tailored to a message to pass
-// which field needs a special verification; i.e. InternalVerify.
-enum class VerifySimpleType {
-  kSimpleInt32Never,   // Use VerifySimple
-  kSimpleInt32Always,  // Use VerifySimpleAlwaysCheckInt32
-  kCustom,             // Use InternalVerify and check only for int32
-  kCustomInt32Never,   // Use InternalVerify but never check for int32
-  kCustomInt32Always,  // Use InternalVerify and always check for int32
-};
-
-// Returns VerifySimpleType if messages can be verified by predefined methods.
-VerifySimpleType ShouldVerifySimple(const Descriptor* descriptor);
-
-bool IsUtf8String(const FieldDescriptor* field);
-
-bool HasMessageFieldOrExtension(const Descriptor* desc);
-
-}  // namespace cpp
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace cpp
+            {
+
+                enum class ArenaDtorNeeds
+                {
+                    kNone = 0,
+                    kOnDemand = 1,
+                    kRequired = 2
+                };
+
+                inline std::string ProtobufNamespace(const Options& /* options */)
+                {
+                    return "PROTOBUF_NAMESPACE_ID";
+                }
+
+                inline std::string MacroPrefix(const Options& /* options */)
+                {
+                    return "GOOGLE_PROTOBUF";
+                }
+
+                inline std::string DeprecatedAttribute(const Options& /* options */, const FieldDescriptor* d)
+                {
+                    return d->options().deprecated() ? "PROTOBUF_DEPRECATED " : "";
+                }
+
+                inline std::string DeprecatedAttribute(const Options& /* options */, const EnumValueDescriptor* d)
+                {
+                    return d->options().deprecated() ? "PROTOBUF_DEPRECATED_ENUM " : "";
+                }
+
+                // Commonly-used separator comments.  Thick is a line of '=', thin is a line
+                // of '-'.
+                extern const char kThickSeparator[];
+                extern const char kThinSeparator[];
+
+                void SetCommonVars(const Options& options, std::map<std::string, std::string>* variables);
+
+                // Variables to access message data from the message scope.
+                void SetCommonMessageDataVariables(
+                    const Descriptor* descriptor,
+                    std::map<std::string, std::string>* variables
+                );
+
+                void SetUnknownFieldsVariable(const Descriptor* descriptor, const Options& options, std::map<std::string, std::string>* variables);
+
+                bool GetBootstrapBasename(const Options& options, const std::string& basename, std::string* bootstrap_basename);
+                bool MaybeBootstrap(const Options& options, GeneratorContext* generator_context, bool bootstrap_flag, std::string* basename);
+                bool IsBootstrapProto(const Options& options, const FileDescriptor* file);
+
+                // Name space of the proto file. This namespace is such that the string
+                // "<namespace>::some_name" is the correct fully qualified namespace.
+                // This means if the package is empty the namespace is "", and otherwise
+                // the namespace is "::foo::bar::...::baz" without trailing semi-colons.
+                std::string Namespace(const FileDescriptor* d, const Options& options);
+                std::string Namespace(const Descriptor* d, const Options& options);
+                std::string Namespace(const FieldDescriptor* d, const Options& options);
+                std::string Namespace(const EnumDescriptor* d, const Options& options);
+
+                // Returns true if it's safe to reset "field" to zero.
+                bool CanInitializeByZeroing(const FieldDescriptor* field);
+
+                std::string ClassName(const Descriptor* descriptor);
+                std::string ClassName(const EnumDescriptor* enum_descriptor);
+
+                std::string QualifiedClassName(const Descriptor* d, const Options& options);
+                std::string QualifiedClassName(const EnumDescriptor* d, const Options& options);
+
+                std::string QualifiedClassName(const Descriptor* d);
+                std::string QualifiedClassName(const EnumDescriptor* d);
+
+                // DEPRECATED just use ClassName or QualifiedClassName, a boolean is very
+                // unreadable at the callsite.
+                // Returns the non-nested type name for the given type.  If "qualified" is
+                // true, prefix the type with the full namespace.  For example, if you had:
+                //   package foo.bar;
+                //   message Baz { message Moo {} }
+                // Then the qualified ClassName for Moo would be:
+                //   ::foo::bar::Baz_Moo
+                // While the non-qualified version would be:
+                //   Baz_Moo
+                inline std::string ClassName(const Descriptor* descriptor, bool qualified)
+                {
+                    return qualified ? QualifiedClassName(descriptor, Options()) : ClassName(descriptor);
+                }
+
+                inline std::string ClassName(const EnumDescriptor* descriptor, bool qualified)
+                {
+                    return qualified ? QualifiedClassName(descriptor, Options()) : ClassName(descriptor);
+                }
+
+                // Returns the extension name prefixed with the class name if nested but without
+                // the package name.
+                std::string ExtensionName(const FieldDescriptor* d);
+
+                std::string QualifiedExtensionName(const FieldDescriptor* d, const Options& options);
+                std::string QualifiedExtensionName(const FieldDescriptor* d);
+
+                // Type name of default instance.
+                std::string DefaultInstanceType(const Descriptor* descriptor, const Options& options, bool split = false);
+
+                // Non-qualified name of the default_instance of this message.
+                std::string DefaultInstanceName(const Descriptor* descriptor, const Options& options, bool split = false);
+
+                // Non-qualified name of the default instance pointer. This is used only for
+                // implicit weak fields, where we need an extra indirection.
+                std::string DefaultInstancePtr(const Descriptor* descriptor, const Options& options, bool split = false);
+
+                // Fully qualified name of the default_instance of this message.
+                std::string QualifiedDefaultInstanceName(const Descriptor* descriptor, const Options& options, bool split = false);
+
+                // Fully qualified name of the default instance pointer.
+                std::string QualifiedDefaultInstancePtr(const Descriptor* descriptor, const Options& options, bool split = false);
+
+                // DescriptorTable variable name.
+                std::string DescriptorTableName(const FileDescriptor* file, const Options& options);
+
+                // When declaring symbol externs from another file, this macro will supply the
+                // dllexport needed for the target file, if any.
+                std::string FileDllExport(const FileDescriptor* file, const Options& options);
+
+                // Name of the base class: google::protobuf::Message or google::protobuf::MessageLite.
+                std::string SuperClassName(const Descriptor* descriptor, const Options& options);
+
+                // Adds an underscore if necessary to prevent conflicting with a keyword.
+                std::string ResolveKeyword(const std::string& name);
+
+                // Get the (unqualified) name that should be used for this field in C++ code.
+                // The name is coerced to lower-case to emulate proto1 behavior.  People
+                // should be using lowercase-with-underscores style for proto field names
+                // anyway, so normally this just returns field->name().
+                std::string FieldName(const FieldDescriptor* field);
+
+                // Returns the (unqualified) private member name for this field in C++ code.
+                std::string FieldMemberName(const FieldDescriptor* field, bool split);
+
+                // Returns an estimate of the compiler's alignment for the field.  This
+                // can't guarantee to be correct because the generated code could be compiled on
+                // different systems with different alignment rules.  The estimates below assume
+                // 64-bit pointers.
+                int EstimateAlignmentSize(const FieldDescriptor* field);
+
+                // Get the unqualified name that should be used for a field's field
+                // number constant.
+                std::string FieldConstantName(const FieldDescriptor* field);
+
+                // Returns the scope where the field was defined (for extensions, this is
+                // different from the message type to which the field applies).
+                inline const Descriptor* FieldScope(const FieldDescriptor* field)
+                {
+                    return field->is_extension() ? field->extension_scope() : field->containing_type();
+                }
+
+                // Returns the fully-qualified type name field->message_type().  Usually this
+                // is just ClassName(field->message_type(), true);
+                std::string FieldMessageTypeName(const FieldDescriptor* field, const Options& options);
+
+                // Get the C++ type name for a primitive type (e.g. "double", "::google::protobuf::int32", etc.).
+                const char* PrimitiveTypeName(FieldDescriptor::CppType type);
+                std::string PrimitiveTypeName(const Options& options, FieldDescriptor::CppType type);
+
+                // Get the declared type name in CamelCase format, as is used e.g. for the
+                // methods of WireFormat.  For example, TYPE_INT32 becomes "Int32".
+                const char* DeclaredTypeMethodName(FieldDescriptor::Type type);
+
+                // Return the code that evaluates to the number when compiled.
+                std::string Int32ToString(int number);
+
+                // Get code that evaluates to the field's default value.
+                std::string DefaultValue(const Options& options, const FieldDescriptor* field);
+
+                // Compatibility function for callers outside proto2.
+                std::string DefaultValue(const FieldDescriptor* field);
+
+                // Convert a file name into a valid identifier.
+                std::string FilenameIdentifier(const std::string& filename);
+
+                // For each .proto file generates a unique name. To prevent collisions of
+                // symbols in the global namespace
+                std::string UniqueName(const std::string& name, const std::string& filename, const Options& options);
+                inline std::string UniqueName(const std::string& name, const FileDescriptor* d, const Options& options)
+                {
+                    return UniqueName(name, d->name(), options);
+                }
+                inline std::string UniqueName(const std::string& name, const Descriptor* d, const Options& options)
+                {
+                    return UniqueName(name, d->file(), options);
+                }
+                inline std::string UniqueName(const std::string& name, const EnumDescriptor* d, const Options& options)
+                {
+                    return UniqueName(name, d->file(), options);
+                }
+                inline std::string UniqueName(const std::string& name, const ServiceDescriptor* d, const Options& options)
+                {
+                    return UniqueName(name, d->file(), options);
+                }
+
+                // Versions for call sites that only support the internal runtime (like proto1
+                // support).
+                inline Options InternalRuntimeOptions()
+                {
+                    Options options;
+                    options.opensource_runtime = false;
+                    return options;
+                }
+                inline std::string UniqueName(const std::string& name, const std::string& filename)
+                {
+                    return UniqueName(name, filename, InternalRuntimeOptions());
+                }
+                inline std::string UniqueName(const std::string& name, const FileDescriptor* d)
+                {
+                    return UniqueName(name, d->name(), InternalRuntimeOptions());
+                }
+                inline std::string UniqueName(const std::string& name, const Descriptor* d)
+                {
+                    return UniqueName(name, d->file(), InternalRuntimeOptions());
+                }
+                inline std::string UniqueName(const std::string& name, const EnumDescriptor* d)
+                {
+                    return UniqueName(name, d->file(), InternalRuntimeOptions());
+                }
+                inline std::string UniqueName(const std::string& name, const ServiceDescriptor* d)
+                {
+                    return UniqueName(name, d->file(), InternalRuntimeOptions());
+                }
+
+                // Return the qualified C++ name for a file level symbol.
+                std::string QualifiedFileLevelSymbol(const FileDescriptor* file, const std::string& name, const Options& options);
+
+                // Escape C++ trigraphs by escaping question marks to \?
+                std::string EscapeTrigraphs(const std::string& to_escape);
+
+                // Escaped function name to eliminate naming conflict.
+                std::string SafeFunctionName(const Descriptor* descriptor, const FieldDescriptor* field, const std::string& prefix);
+
+                // Returns true if generated messages have public unknown fields accessors
+                inline bool PublicUnknownFieldsAccessors(const Descriptor* message)
+                {
+                    return message->file()->syntax() != FileDescriptor::SYNTAX_PROTO3;
+                }
+
+                // Returns the optimize mode for <file>, respecting <options.enforce_lite>.
+                FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file, const Options& options);
+
+                // Determines whether unknown fields will be stored in an UnknownFieldSet or
+                // a string.
+                inline bool UseUnknownFieldSet(const FileDescriptor* file, const Options& options)
+                {
+                    return GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME;
+                }
+
+                inline bool IsWeak(const FieldDescriptor* field, const Options& options)
+                {
+                    if (field->options().weak())
+                    {
+                        GOOGLE_CHECK(!options.opensource_runtime);
+                        return true;
+                    }
+                    return false;
+                }
+
+                bool IsStringInlined(const FieldDescriptor* descriptor, const Options& options);
+
+                // For a string field, returns the effective ctype.  If the actual ctype is
+                // not supported, returns the default of STRING.
+                FieldOptions::CType EffectiveStringCType(const FieldDescriptor* field, const Options& options);
+
+                inline bool IsCord(const FieldDescriptor* field, const Options& options)
+                {
+                    return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
+                           EffectiveStringCType(field, options) == FieldOptions::CORD;
+                }
+
+                inline bool IsString(const FieldDescriptor* field, const Options& options)
+                {
+                    return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
+                           EffectiveStringCType(field, options) == FieldOptions::STRING;
+                }
+
+                inline bool IsStringPiece(const FieldDescriptor* field, const Options& options)
+                {
+                    return field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
+                           EffectiveStringCType(field, options) == FieldOptions::STRING_PIECE;
+                }
+
+                class MessageSCCAnalyzer;
+
+                // Does the given FileDescriptor use lazy fields?
+                bool HasLazyFields(const FileDescriptor* file, const Options& options, MessageSCCAnalyzer* scc_analyzer);
+
+                // Is the given field a supported lazy field?
+                bool IsLazy(const FieldDescriptor* field, const Options& options, MessageSCCAnalyzer* scc_analyzer);
+
+                // Is this an explicit (non-profile driven) lazy field, as denoted by
+                // lazy/unverified_lazy in the descriptor?
+                inline bool IsExplicitLazy(const FieldDescriptor* field)
+                {
+                    return field->options().lazy() || field->options().unverified_lazy();
+                }
+
+                bool IsEagerlyVerifiedLazy(const FieldDescriptor* field, const Options& options, MessageSCCAnalyzer* scc_analyzer);
+
+                bool IsLazilyVerifiedLazy(const FieldDescriptor* field, const Options& options);
+
+                // Is the given message being split (go/pdsplit)?
+                bool ShouldSplit(const Descriptor* desc, const Options& options);
+
+                // Is the given field being split out?
+                bool ShouldSplit(const FieldDescriptor* field, const Options& options);
+
+                inline bool IsFieldUsed(const FieldDescriptor* /* field */, const Options& /* options */)
+                {
+                    return true;
+                }
+
+                // Returns true if "field" is stripped.
+                inline bool IsFieldStripped(const FieldDescriptor* /*field*/, const Options& /*options*/)
+                {
+                    return false;
+                }
+
+                // Does the file contain any definitions that need extension_set.h?
+                bool HasExtensionsOrExtendableMessage(const FileDescriptor* file);
+
+                // Does the file have any repeated fields, necessitating the file to include
+                // repeated_field.h? This does not include repeated extensions, since those are
+                // all stored internally in an ExtensionSet, not a separate RepeatedField*.
+                bool HasRepeatedFields(const FileDescriptor* file);
+
+                // Does the file have any string/bytes fields with ctype=STRING_PIECE? This
+                // does not include extensions, since ctype is ignored for extensions.
+                bool HasStringPieceFields(const FileDescriptor* file, const Options& options);
+
+                // Does the file have any string/bytes fields with ctype=CORD? This does not
+                // include extensions, since ctype is ignored for extensions.
+                bool HasCordFields(const FileDescriptor* file, const Options& options);
+
+                // Does the file have any map fields, necessitating the file to include
+                // map_field_inl.h and map.h.
+                bool HasMapFields(const FileDescriptor* file);
+
+                // Does this file have any enum type definitions?
+                bool HasEnumDefinitions(const FileDescriptor* file);
+
+                // Does this file have generated parsing, serialization, and other
+                // standard methods for which reflection-based fallback implementations exist?
+                inline bool HasGeneratedMethods(const FileDescriptor* file, const Options& options)
+                {
+                    return GetOptimizeFor(file, options) != FileOptions::CODE_SIZE;
+                }
+
+                // Do message classes in this file have descriptor and reflection methods?
+                inline bool HasDescriptorMethods(const FileDescriptor* file, const Options& options)
+                {
+                    return GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME;
+                }
+
+                // Should we generate generic services for this file?
+                inline bool HasGenericServices(const FileDescriptor* file, const Options& options)
+                {
+                    return file->service_count() > 0 &&
+                           GetOptimizeFor(file, options) != FileOptions::LITE_RUNTIME &&
+                           file->options().cc_generic_services();
+                }
+
+                inline bool IsProto2MessageSet(const Descriptor* descriptor, const Options& options)
+                {
+                    return !options.opensource_runtime &&
+                           options.enforce_mode != EnforceOptimizeMode::kLiteRuntime &&
+                           !options.lite_implicit_weak_fields &&
+                           descriptor->options().message_set_wire_format() &&
+                           descriptor->full_name() == "google.protobuf.bridge.MessageSet";
+                }
+
+                inline bool IsMapEntryMessage(const Descriptor* descriptor)
+                {
+                    return descriptor->options().map_entry();
+                }
+
+                // Returns true if the field's CPPTYPE is string or message.
+                bool IsStringOrMessage(const FieldDescriptor* field);
+
+                std::string UnderscoresToCamelCase(const std::string& input, bool cap_next_letter);
+
+                inline bool IsProto3(const FileDescriptor* file)
+                {
+                    return file->syntax() == FileDescriptor::SYNTAX_PROTO3;
+                }
+
+                inline bool HasHasbit(const FieldDescriptor* field)
+                {
+                    // This predicate includes proto3 message fields only if they have "optional".
+                    //   Foo submsg1 = 1;           // HasHasbit() == false
+                    //   optional Foo submsg2 = 2;  // HasHasbit() == true
+                    // This is slightly odd, as adding "optional" to a singular proto3 field does
+                    // not change the semantics or API. However whenever any field in a message
+                    // has a hasbit, it forces reflection to include hasbit offsets for *all*
+                    // fields, even if almost all of them are set to -1 (no hasbit). So to avoid
+                    // causing a sudden size regression for ~all proto3 messages, we give proto3
+                    // message fields a hasbit only if "optional" is present. If the user is
+                    // explicitly writing "optional", it is likely they are writing it on
+                    // primitive fields also.
+                    return (field->has_optional_keyword() || field->is_required()) &&
+                           !field->options().weak();
+                }
+
+                // Returns true if 'enum' semantics are such that unknown values are preserved
+                // in the enum field itself, rather than going to the UnknownFieldSet.
+                inline bool HasPreservingUnknownEnumSemantics(const FieldDescriptor* field)
+                {
+                    return field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3;
+                }
+
+                inline bool IsCrossFileMessage(const FieldDescriptor* field)
+                {
+                    return field->type() == FieldDescriptor::TYPE_MESSAGE &&
+                           field->message_type()->file() != field->file();
+                }
+
+                inline std::string MakeDefaultName(const FieldDescriptor* field)
+                {
+                    return StrCat("_i_give_permission_to_break_this_code_default_", FieldName(field), "_");
+                }
+
+                // Semantically distinct from MakeDefaultName in that it gives the C++ code
+                // referencing a default field from the message scope, rather than just the
+                // variable name.
+                // For example, declarations of default variables should always use just
+                // MakeDefaultName to produce code like:
+                //   Type _i_give_permission_to_break_this_code_default_field_;
+                //
+                // Code that references these should use MakeDefaultFieldName, in case the field
+                // exists at some nested level like:
+                //   internal_container_._i_give_permission_to_break_this_code_default_field_;
+                inline std::string MakeDefaultFieldName(const FieldDescriptor* field)
+                {
+                    return StrCat("Impl_::", MakeDefaultName(field));
+                }
+
+                inline std::string MakeVarintCachedSizeName(const FieldDescriptor* field)
+                {
+                    return StrCat("_", FieldName(field), "_cached_byte_size_");
+                }
+
+                // Semantically distinct from MakeVarintCachedSizeName in that it gives the C++
+                // code referencing the object from the message scope, rather than just the
+                // variable name.
+                // For example, declarations of default variables should always use just
+                // MakeVarintCachedSizeName to produce code like:
+                //   Type _field_cached_byte_size_;
+                //
+                // Code that references these variables should use
+                // MakeVarintCachedSizeFieldName, in case the field exists at some nested level
+                // like:
+                //   internal_container_._field_cached_byte_size_;
+                inline std::string MakeVarintCachedSizeFieldName(const FieldDescriptor* field, bool split)
+                {
+                    return StrCat("_impl_.", split ? "_split_->" : "", "_", FieldName(field), "_cached_byte_size_");
+                }
+
+                // Note: A lot of libraries detect Any protos based on Descriptor::full_name()
+                // while the two functions below use FileDescriptor::name(). In a sane world the
+                // two approaches should be equivalent. But if you are dealing with descriptors
+                // from untrusted sources, you might need to match semantics across libraries.
+                bool IsAnyMessage(const FileDescriptor* descriptor, const Options& options);
+                bool IsAnyMessage(const Descriptor* descriptor, const Options& options);
+
+                bool IsWellKnownMessage(const FileDescriptor* descriptor);
+
+                inline std::string IncludeGuard(const FileDescriptor* file, bool pb_h, const Options& options)
+                {
+                    // If we are generating a .pb.h file and the proto_h option is enabled, then
+                    // the .pb.h gets an extra suffix.
+                    std::string filename_identifier = FilenameIdentifier(
+                        file->name() + (pb_h && options.proto_h ? ".pb.h" : "")
+                    );
+
+                    if (IsWellKnownMessage(file))
+                    {
+                        // For well-known messages we need third_party/protobuf and net/proto2 to
+                        // have distinct include guards, because some source files include both and
+                        // both need to be defined (the third_party copies will be in the
+                        // google::protobuf_opensource namespace).
+                        return MacroPrefix(options) + "_INCLUDED_" + filename_identifier;
+                    }
+                    else
+                    {
+                        // Ideally this case would use distinct include guards for opensource and
+                        // google3 protos also.  (The behavior of "first #included wins" is not
+                        // ideal).  But unfortunately some legacy code includes both and depends on
+                        // the identical include guards to avoid compile errors.
+                        //
+                        // We should clean this up so that this case can be removed.
+                        return "GOOGLE_PROTOBUF_INCLUDED_" + filename_identifier;
+                    }
+                }
+
+                // Returns the OptimizeMode for this file, furthermore it updates a status
+                // bool if has_opt_codesize_extension is non-null. If this status bool is true
+                // it means this file contains an extension that itself is defined as
+                // optimized_for = CODE_SIZE.
+                FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file, const Options& options, bool* has_opt_codesize_extension);
+                inline FileOptions_OptimizeMode GetOptimizeFor(const FileDescriptor* file, const Options& options)
+                {
+                    return GetOptimizeFor(file, options, nullptr);
+                }
+                inline bool NeedsEagerDescriptorAssignment(const FileDescriptor* file, const Options& options)
+                {
+                    bool has_opt_codesize_extension;
+                    if (GetOptimizeFor(file, options, &has_opt_codesize_extension) ==
+                            FileOptions::CODE_SIZE &&
+                        has_opt_codesize_extension)
+                    {
+                        // If this filedescriptor contains an extension from another file which
+                        // is optimized_for = CODE_SIZE. We need to be careful in the ordering so
+                        // we eagerly build the descriptors in the dependencies before building
+                        // the descriptors of this file.
+                        return true;
+                    }
+                    else
+                    {
+                        // If we have a generated code based parser we never need eager
+                        // initialization of descriptors of our deps.
+                        return false;
+                    }
+                }
+
+                // This orders the messages in a .pb.cc as it's outputted by file.cc
+                void FlattenMessagesInFile(const FileDescriptor* file, std::vector<const Descriptor*>* result);
+                inline std::vector<const Descriptor*> FlattenMessagesInFile(
+                    const FileDescriptor* file
+                )
+                {
+                    std::vector<const Descriptor*> result;
+                    FlattenMessagesInFile(file, &result);
+                    return result;
+                }
+
+                template<typename F>
+                void ForEachMessage(const Descriptor* descriptor, F&& func)
+                {
+                    for (int i = 0; i < descriptor->nested_type_count(); i++)
+                        ForEachMessage(descriptor->nested_type(i), std::forward<F&&>(func));
+                    func(descriptor);
+                }
+
+                template<typename F>
+                void ForEachMessage(const FileDescriptor* descriptor, F&& func)
+                {
+                    for (int i = 0; i < descriptor->message_type_count(); i++)
+                        ForEachMessage(descriptor->message_type(i), std::forward<F&&>(func));
+                }
+
+                bool HasWeakFields(const Descriptor* desc, const Options& options);
+                bool HasWeakFields(const FileDescriptor* desc, const Options& options);
+
+                // Returns true if the "required" restriction check should be ignored for the
+                // given field.
+                inline static bool ShouldIgnoreRequiredFieldCheck(const FieldDescriptor* field, const Options& options)
+                {
+                    // Do not check "required" for lazily verified lazy fields.
+                    return IsLazilyVerifiedLazy(field, options);
+                }
+
+                struct MessageAnalysis
+                {
+                    bool is_recursive = false;
+                    bool contains_cord = false;
+                    bool contains_extension = false;
+                    bool contains_required = false;
+                    bool contains_weak = false;  // Implicit weak as well.
+                };
+
+                // This class is used in FileGenerator, to ensure linear instead of
+                // quadratic performance, if we do this per message we would get O(V*(V+E)).
+                // Logically this is just only used in message.cc, but in the header for
+                // FileGenerator to help share it.
+                class PROTOC_EXPORT MessageSCCAnalyzer
+                {
+                public:
+                    explicit MessageSCCAnalyzer(const Options& options) :
+                        options_(options)
+                    {
+                    }
+
+                    MessageAnalysis GetSCCAnalysis(const SCC* scc);
+
+                    bool HasRequiredFields(const Descriptor* descriptor)
+                    {
+                        MessageAnalysis result = GetSCCAnalysis(GetSCC(descriptor));
+                        return result.contains_required || result.contains_extension;
+                    }
+                    bool HasWeakField(const Descriptor* descriptor)
+                    {
+                        MessageAnalysis result = GetSCCAnalysis(GetSCC(descriptor));
+                        return result.contains_weak;
+                    }
+                    const SCC* GetSCC(const Descriptor* descriptor)
+                    {
+                        return analyzer_.GetSCC(descriptor);
+                    }
+
+                private:
+                    struct DepsGenerator
+                    {
+                        std::vector<const Descriptor*> operator()(const Descriptor* desc) const
+                        {
+                            std::vector<const Descriptor*> deps;
+                            for (int i = 0; i < desc->field_count(); i++)
+                            {
+                                if (desc->field(i)->message_type())
+                                {
+                                    deps.push_back(desc->field(i)->message_type());
+                                }
+                            }
+                            return deps;
+                        }
+                    };
+                    SCCAnalyzer<DepsGenerator> analyzer_;
+                    Options options_;
+                    std::map<const SCC*, MessageAnalysis> analysis_cache_;
+                };
+
+                void ListAllFields(const Descriptor* d, std::vector<const FieldDescriptor*>* fields);
+                void ListAllFields(const FileDescriptor* d, std::vector<const FieldDescriptor*>* fields);
+
+                template<class T>
+                void ForEachField(const Descriptor* d, T&& func)
+                {
+                    for (int i = 0; i < d->nested_type_count(); i++)
+                    {
+                        ForEachField(d->nested_type(i), std::forward<T&&>(func));
+                    }
+                    for (int i = 0; i < d->extension_count(); i++)
+                    {
+                        func(d->extension(i));
+                    }
+                    for (int i = 0; i < d->field_count(); i++)
+                    {
+                        func(d->field(i));
+                    }
+                }
+
+                template<class T>
+                void ForEachField(const FileDescriptor* d, T&& func)
+                {
+                    for (int i = 0; i < d->message_type_count(); i++)
+                    {
+                        ForEachField(d->message_type(i), std::forward<T&&>(func));
+                    }
+                    for (int i = 0; i < d->extension_count(); i++)
+                    {
+                        func(d->extension(i));
+                    }
+                }
+
+                void ListAllTypesForServices(const FileDescriptor* fd, std::vector<const Descriptor*>* types);
+
+                // Indicates whether we should use implicit weak fields for this file.
+                bool UsingImplicitWeakFields(const FileDescriptor* file, const Options& options);
+
+                // Indicates whether to treat this field as implicitly weak.
+                bool IsImplicitWeakField(const FieldDescriptor* field, const Options& options, MessageSCCAnalyzer* scc_analyzer);
+
+                inline bool HasSimpleBaseClass(const Descriptor* desc, const Options& options)
+                {
+                    if (!HasDescriptorMethods(desc->file(), options))
+                        return false;
+                    if (desc->extension_range_count() != 0)
+                        return false;
+                    if (desc->field_count() == 0)
+                        return true;
+                    // TODO(jorg): Support additional common message types with only one
+                    // or two fields
+                    return false;
+                }
+
+                inline bool HasSimpleBaseClasses(const FileDescriptor* file, const Options& options)
+                {
+                    bool v = false;
+                    ForEachMessage(file, [&v, &options](const Descriptor* desc)
+                                   { v |= HasSimpleBaseClass(desc, options); });
+                    return v;
+                }
+
+                inline std::string SimpleBaseClass(const Descriptor* desc, const Options& options)
+                {
+                    if (!HasDescriptorMethods(desc->file(), options))
+                        return "";
+                    if (desc->extension_range_count() != 0)
+                        return "";
+                    if (desc->field_count() == 0)
+                    {
+                        return "ZeroFieldsBase";
+                    }
+                    // TODO(jorg): Support additional common message types with only one
+                    // or two fields
+                    return "";
+                }
+
+                // Returns true if this message has a _tracker_ field.
+                inline bool HasTracker(const Descriptor* desc, const Options& options)
+                {
+                    return options.field_listener_options.inject_field_listener_events &&
+                           desc->file()->options().optimize_for() !=
+                               google::protobuf::FileOptions::LITE_RUNTIME;
+                }
+
+                // Returns true if this message needs an Impl_ struct for it's data.
+                inline bool HasImplData(const Descriptor* desc, const Options& options)
+                {
+                    return !HasSimpleBaseClass(desc, options);
+                }
+
+                // Formatter is a functor class which acts as a closure around printer and
+                // the variable map. It's much like printer->Print except it supports both named
+                // variables that are substituted using a key value map and direct arguments. In
+                // the format string $1$, $2$, etc... are substituted for the first, second, ...
+                // direct argument respectively in the format call, it accepts both strings and
+                // integers. The implementation verifies all arguments are used and are "first"
+                // used in order of appearance in the argument list. For example,
+                //
+                // Format("return array[$1$];", 3) -> "return array[3];"
+                // Format("array[$2$] = $1$;", "Bla", 3) -> FATAL error (wrong order)
+                // Format("array[$1$] = $2$;", 3, "Bla") -> "array[3] = Bla;"
+                //
+                // The arguments can be used more than once like
+                //
+                // Format("array[$1$] = $2$;  // Index = $1$", 3, "Bla") ->
+                //        "array[3] = Bla;  // Index = 3"
+                //
+                // If you use more arguments use the following style to help the reader,
+                //
+                // Format("int $1$() {\n"
+                //        "  array[$2$] = $3$;\n"
+                //        "  return $4$;"
+                //        "}\n",
+                //        funname, // 1
+                //        idx,  // 2
+                //        varname,  // 3
+                //        retval);  // 4
+                //
+                // but consider using named variables. Named variables like $foo$, with some
+                // identifier foo, are looked up in the map. One additional feature is that
+                // spaces are accepted between the '$' delimiters, $ foo$ will
+                // substitute to " bar" if foo stands for "bar", but in case it's empty
+                // will substitute to "". Hence, for example,
+                //
+                // Format(vars, "$dllexport $void fun();") -> "void fun();"
+                //                                            "__declspec(export) void fun();"
+                //
+                // which is convenient to prevent double, leading or trailing spaces.
+                class PROTOC_EXPORT Formatter
+                {
+                public:
+                    explicit Formatter(io::Printer* printer) :
+                        printer_(printer)
+                    {
+                    }
+                    Formatter(io::Printer* printer, const std::map<std::string, std::string>& vars) :
+                        printer_(printer),
+                        vars_(vars)
+                    {
+                    }
+
+                    template<typename T>
+                    void Set(const std::string& key, const T& value)
+                    {
+                        vars_[key] = ToString(value);
+                    }
+
+                    void AddMap(const std::map<std::string, std::string>& vars)
+                    {
+                        for (const auto& keyval : vars)
+                            vars_[keyval.first] = keyval.second;
+                    }
+
+                    template<typename... Args>
+                    void operator()(const char* format, const Args&... args) const
+                    {
+                        printer_->FormatInternal({ToString(args)...}, vars_, format);
+                    }
+
+                    void Indent() const
+                    {
+                        printer_->Indent();
+                    }
+                    void Outdent() const
+                    {
+                        printer_->Outdent();
+                    }
+                    io::Printer* printer() const
+                    {
+                        return printer_;
+                    }
+
+                    class PROTOC_EXPORT ScopedIndenter
+                    {
+                    public:
+                        explicit ScopedIndenter(Formatter* format) :
+                            format_(format)
+                        {
+                            format_->Indent();
+                        }
+                        ~ScopedIndenter()
+                        {
+                            format_->Outdent();
+                        }
+
+                    private:
+                        Formatter* format_;
+                    };
+
+                    PROTOBUF_NODISCARD ScopedIndenter ScopedIndent()
+                    {
+                        return ScopedIndenter(this);
+                    }
+                    template<typename... Args>
+                    PROTOBUF_NODISCARD ScopedIndenter ScopedIndent(const char* format, const Args&&... args)
+                    {
+                        (*this)(format, static_cast<Args&&>(args)...);
+                        return ScopedIndenter(this);
+                    }
+
+                    class PROTOC_EXPORT SaveState
+                    {
+                    public:
+                        explicit SaveState(Formatter* format) :
+                            format_(format),
+                            vars_(format->vars_)
+                        {
+                        }
+                        ~SaveState()
+                        {
+                            format_->vars_.swap(vars_);
+                        }
+
+                    private:
+                        Formatter* format_;
+                        std::map<std::string, std::string> vars_;
+                    };
+
+                private:
+                    io::Printer* printer_;
+                    std::map<std::string, std::string> vars_;
+
+                    // Convenience overloads to accept different types as arguments.
+                    static std::string ToString(const std::string& s)
+                    {
+                        return s;
+                    }
+                    template<typename I, typename = typename std::enable_if<std::is_integral<I>::value>::type>
+                    static std::string ToString(I x)
+                    {
+                        return StrCat(x);
+                    }
+                    static std::string ToString(strings::Hex x)
+                    {
+                        return StrCat(x);
+                    }
+                    static std::string ToString(const FieldDescriptor* d)
+                    {
+                        return Payload(d);
+                    }
+                    static std::string ToString(const Descriptor* d)
+                    {
+                        return Payload(d);
+                    }
+                    static std::string ToString(const EnumDescriptor* d)
+                    {
+                        return Payload(d);
+                    }
+                    static std::string ToString(const EnumValueDescriptor* d)
+                    {
+                        return Payload(d);
+                    }
+                    static std::string ToString(const OneofDescriptor* d)
+                    {
+                        return Payload(d);
+                    }
+
+                    template<typename Descriptor>
+                    static std::string Payload(const Descriptor* descriptor)
+                    {
+                        std::vector<int> path;
+                        descriptor->GetLocationPath(&path);
+                        GeneratedCodeInfo::Annotation annotation;
+                        for (int index : path)
+                        {
+                            annotation.add_path(index);
+                        }
+                        annotation.set_source_file(descriptor->file()->name());
+                        return annotation.SerializeAsString();
+                    }
+                };
+
+                template<class T>
+                void PrintFieldComment(const Formatter& format, const T* field)
+                {
+                    // Print the field's (or oneof's) proto-syntax definition as a comment.
+                    // We don't want to print group bodies so we cut off after the first
+                    // line.
+                    DebugStringOptions options;
+                    options.elide_group_body = true;
+                    options.elide_oneof_body = true;
+                    std::string def = field->DebugStringWithOptions(options);
+                    format("// $1$\n", def.substr(0, def.find_first_of('\n')));
+                }
+
+                class PROTOC_EXPORT NamespaceOpener
+                {
+                public:
+                    explicit NamespaceOpener(const Formatter& format) :
+                        printer_(format.printer())
+                    {
+                    }
+                    NamespaceOpener(const std::string& name, const Formatter& format) :
+                        NamespaceOpener(format)
+                    {
+                        ChangeTo(name);
+                    }
+                    ~NamespaceOpener()
+                    {
+                        ChangeTo("");
+                    }
+
+                    void ChangeTo(const std::string& name)
+                    {
+                        std::vector<std::string> new_stack_ =
+                            Split(name, "::", true);
+                        size_t len = std::min(name_stack_.size(), new_stack_.size());
+                        size_t common_idx = 0;
+                        while (common_idx < len)
+                        {
+                            if (name_stack_[common_idx] != new_stack_[common_idx])
+                                break;
+                            common_idx++;
+                        }
+                        for (auto it = name_stack_.crbegin();
+                             it != name_stack_.crend() - common_idx;
+                             ++it)
+                        {
+                            if (*it == "PROTOBUF_NAMESPACE_ID")
+                            {
+                                printer_->Print("PROTOBUF_NAMESPACE_CLOSE\n");
+                            }
+                            else
+                            {
+                                printer_->Print("}  // namespace $ns$\n", "ns", *it);
+                            }
+                        }
+                        name_stack_.swap(new_stack_);
+                        for (size_t i = common_idx; i < name_stack_.size(); ++i)
+                        {
+                            if (name_stack_[i] == "PROTOBUF_NAMESPACE_ID")
+                            {
+                                printer_->Print("PROTOBUF_NAMESPACE_OPEN\n");
+                            }
+                            else
+                            {
+                                printer_->Print("namespace $ns$ {\n", "ns", name_stack_[i]);
+                            }
+                        }
+                    }
+
+                private:
+                    io::Printer* printer_;
+                    std::vector<std::string> name_stack_;
+                };
+
+                enum class Utf8CheckMode
+                {
+                    kStrict = 0,  // Parsing will fail if non UTF-8 data is in string fields.
+                    kVerify = 1,  // Only log an error but parsing will succeed.
+                    kNone = 2,    // No UTF-8 check.
+                };
+
+                Utf8CheckMode GetUtf8CheckMode(const FieldDescriptor* field, const Options& options);
+
+                void GenerateUtf8CheckCodeForString(const FieldDescriptor* field, const Options& options, bool for_parse, const char* parameters, const Formatter& format);
+
+                void GenerateUtf8CheckCodeForCord(const FieldDescriptor* field, const Options& options, bool for_parse, const char* parameters, const Formatter& format);
+
+                template<typename T>
+                struct FieldRangeImpl
+                {
+                    struct Iterator
+                    {
+                        using iterator_category = std::forward_iterator_tag;
+                        using value_type = const FieldDescriptor*;
+                        using difference_type = int;
+
+                        value_type operator*()
+                        {
+                            return descriptor->field(idx);
+                        }
+
+                        friend bool operator==(const Iterator& a, const Iterator& b)
+                        {
+                            GOOGLE_DCHECK(a.descriptor == b.descriptor);
+                            return a.idx == b.idx;
+                        }
+                        friend bool operator!=(const Iterator& a, const Iterator& b)
+                        {
+                            return !(a == b);
+                        }
+
+                        Iterator& operator++()
+                        {
+                            idx++;
+                            return *this;
+                        }
+
+                        int idx;
+                        const T* descriptor;
+                    };
+
+                    Iterator begin() const
+                    {
+                        return {0, descriptor};
+                    }
+                    Iterator end() const
+                    {
+                        return {descriptor->field_count(), descriptor};
+                    }
+
+                    const T* descriptor;
+                };
+
+                template<typename T>
+                FieldRangeImpl<T> FieldRange(const T* desc)
+                {
+                    return {desc};
+                }
+
+                struct OneOfRangeImpl
+                {
+                    struct Iterator
+                    {
+                        using iterator_category = std::forward_iterator_tag;
+                        using value_type = const OneofDescriptor*;
+                        using difference_type = int;
+
+                        value_type operator*()
+                        {
+                            return descriptor->oneof_decl(idx);
+                        }
+
+                        friend bool operator==(const Iterator& a, const Iterator& b)
+                        {
+                            GOOGLE_DCHECK(a.descriptor == b.descriptor);
+                            return a.idx == b.idx;
+                        }
+                        friend bool operator!=(const Iterator& a, const Iterator& b)
+                        {
+                            return !(a == b);
+                        }
+
+                        Iterator& operator++()
+                        {
+                            idx++;
+                            return *this;
+                        }
+
+                        int idx;
+                        const Descriptor* descriptor;
+                    };
+
+                    Iterator begin() const
+                    {
+                        return {0, descriptor};
+                    }
+                    Iterator end() const
+                    {
+                        return {descriptor->real_oneof_decl_count(), descriptor};
+                    }
+
+                    const Descriptor* descriptor;
+                };
+
+                inline OneOfRangeImpl OneOfRange(const Descriptor* desc)
+                {
+                    return {desc};
+                }
+
+                PROTOC_EXPORT std::string StripProto(const std::string& filename);
+
+                bool EnableMessageOwnedArena(const Descriptor* desc, const Options& options);
+
+                bool EnableMessageOwnedArenaTrial(const Descriptor* desc, const Options& options);
+
+                bool ShouldVerify(const Descriptor* descriptor, const Options& options, MessageSCCAnalyzer* scc_analyzer);
+                bool ShouldVerify(const FileDescriptor* file, const Options& options, MessageSCCAnalyzer* scc_analyzer);
+
+                // Indicates whether to use predefined verify methods for a given message. If a
+                // message is "simple" and needs no special verification per field (e.g. message
+                // field, repeated packed, UTF8 string, etc.), we can use either VerifySimple or
+                // VerifySimpleAlwaysCheckInt32 methods as all verification can be done based on
+                // the wire type.
+                //
+                // Otherwise, we need "custom" verify methods tailored to a message to pass
+                // which field needs a special verification; i.e. InternalVerify.
+                enum class VerifySimpleType
+                {
+                    kSimpleInt32Never,   // Use VerifySimple
+                    kSimpleInt32Always,  // Use VerifySimpleAlwaysCheckInt32
+                    kCustom,             // Use InternalVerify and check only for int32
+                    kCustomInt32Never,   // Use InternalVerify but never check for int32
+                    kCustomInt32Always,  // Use InternalVerify and always check for int32
+                };
+
+                // Returns VerifySimpleType if messages can be verified by predefined methods.
+                VerifySimpleType ShouldVerifySimple(const Descriptor* descriptor);
+
+                bool IsUtf8String(const FieldDescriptor* field);
+
+                bool HasMessageFieldOrExtension(const Descriptor* desc);
+
+            }  // namespace cpp
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/names.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/names.h
index 7404ac5..bb115ab 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/names.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/cpp/names.h
@@ -36,60 +36,64 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
+namespace google
+{
+    namespace protobuf
+    {
 
-class Descriptor;
-class EnumDescriptor;
-class EnumValueDescriptor;
-class FieldDescriptor;
+        class Descriptor;
+        class EnumDescriptor;
+        class EnumValueDescriptor;
+        class FieldDescriptor;
 
-namespace compiler {
-namespace cpp {
+        namespace compiler
+        {
+            namespace cpp
+            {
 
-// Returns the unqualified C++ name.
-//
-// For example, if you had:
-//   package foo.bar;
-//   message Baz { message Moo {} }
-// Then the non-qualified version would be:
-//   Baz_Moo
-std::string ClassName(const Descriptor* descriptor);
-std::string ClassName(const EnumDescriptor* enum_descriptor);
+                // Returns the unqualified C++ name.
+                //
+                // For example, if you had:
+                //   package foo.bar;
+                //   message Baz { message Moo {} }
+                // Then the non-qualified version would be:
+                //   Baz_Moo
+                std::string ClassName(const Descriptor* descriptor);
+                std::string ClassName(const EnumDescriptor* enum_descriptor);
 
-// Returns the fully qualified C++ name.
-//
-// For example, if you had:
-//   package foo.bar;
-//   message Baz { message Moo {} }
-// Then the qualified ClassName for Moo would be:
-//   ::foo::bar::Baz_Moo
-std::string QualifiedClassName(const Descriptor* d);
-std::string QualifiedClassName(const EnumDescriptor* d);
-std::string QualifiedExtensionName(const FieldDescriptor* d);
+                // Returns the fully qualified C++ name.
+                //
+                // For example, if you had:
+                //   package foo.bar;
+                //   message Baz { message Moo {} }
+                // Then the qualified ClassName for Moo would be:
+                //   ::foo::bar::Baz_Moo
+                std::string QualifiedClassName(const Descriptor* d);
+                std::string QualifiedClassName(const EnumDescriptor* d);
+                std::string QualifiedExtensionName(const FieldDescriptor* d);
 
-// Get the (unqualified) name that should be used for this field in C++ code.
-// The name is coerced to lower-case to emulate proto1 behavior.  People
-// should be using lowercase-with-underscores style for proto field names
-// anyway, so normally this just returns field->name().
-std::string FieldName(const FieldDescriptor* field);
+                // Get the (unqualified) name that should be used for this field in C++ code.
+                // The name is coerced to lower-case to emulate proto1 behavior.  People
+                // should be using lowercase-with-underscores style for proto field names
+                // anyway, so normally this just returns field->name().
+                std::string FieldName(const FieldDescriptor* field);
 
-// Requires that this field is in a oneof. Returns the (unqualified) case
-// constant for this field.
-std::string OneofCaseConstantName(const FieldDescriptor* field);
-// Returns the quafilied case constant for this field.
-std::string QualifiedOneofCaseConstantName(const FieldDescriptor* field);
+                // Requires that this field is in a oneof. Returns the (unqualified) case
+                // constant for this field.
+                std::string OneofCaseConstantName(const FieldDescriptor* field);
+                // Returns the quafilied case constant for this field.
+                std::string QualifiedOneofCaseConstantName(const FieldDescriptor* field);
 
-// Get the (unqualified) name that should be used for this enum value in C++
-// code.
-std::string EnumValueName(const EnumValueDescriptor* enum_value);
+                // Get the (unqualified) name that should be used for this enum value in C++
+                // code.
+                std::string EnumValueName(const EnumValueDescriptor* enum_value);
 
-// Strips ".proto" or ".protodevel" from the end of a filename.
-PROTOC_EXPORT std::string StripProto(const std::string& filename);
+                // Strips ".proto" or ".protodevel" from the end of a filename.
+                PROTOC_EXPORT std::string StripProto(const std::string& filename);
 
-}  // namespace cpp
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace cpp
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_doc_comment.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_doc_comment.h
index 75eb0ea..dd15ac1 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_doc_comment.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_doc_comment.h
@@ -28,24 +28,27 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 #ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_DOC_COMMENT_H__
 #define GOOGLE_PROTOBUF_COMPILER_CSHARP_DOC_COMMENT_H__
 
 #include <google/protobuf/io/printer.h>
 #include <google/protobuf/descriptor.h>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace csharp {
-    void WriteMessageDocComment(io::Printer* printer, const Descriptor* message);
-    void WritePropertyDocComment(io::Printer* printer, const FieldDescriptor* field);
-    void WriteEnumDocComment(io::Printer* printer, const EnumDescriptor* enumDescriptor);
-    void WriteEnumValueDocComment(io::Printer* printer, const EnumValueDescriptor* value);
-    void WriteMethodDocComment(io::Printer* printer, const MethodDescriptor* method);
-}  // namespace csharp
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace csharp
+            {
+                void WriteMessageDocComment(io::Printer* printer, const Descriptor* message);
+                void WritePropertyDocComment(io::Printer* printer, const FieldDescriptor* field);
+                void WriteEnumDocComment(io::Printer* printer, const EnumDescriptor* enumDescriptor);
+                void WriteEnumValueDocComment(io::Printer* printer, const EnumValueDescriptor* value);
+                void WriteMethodDocComment(io::Printer* printer, const MethodDescriptor* method);
+            }  // namespace csharp
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_DOC_COMMENT_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_generator.h
index f41f9b8..93d7783 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_generator.h
@@ -39,30 +39,36 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace csharp {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace csharp
+            {
 
-// CodeGenerator implementation which generates a C# source file and
-// header.  If you create your own protocol compiler binary and you want
-// it to support C# output, you can do so by registering an instance of this
-// CodeGenerator with the CommandLineInterface in your main() function.
-class PROTOC_EXPORT Generator : public CodeGenerator {
- public:
-  Generator();
-  ~Generator();
-  bool Generate(
-    const FileDescriptor* file,
-    const std::string& parameter,
-    GeneratorContext* generator_context,
-    std::string* error) const override;
-  uint64_t GetSupportedFeatures() const override;
-};
+                // CodeGenerator implementation which generates a C# source file and
+                // header.  If you create your own protocol compiler binary and you want
+                // it to support C# output, you can do so by registering an instance of this
+                // CodeGenerator with the CommandLineInterface in your main() function.
+                class PROTOC_EXPORT Generator : public CodeGenerator
+                {
+                public:
+                    Generator();
+                    ~Generator();
+                    bool Generate(
+                        const FileDescriptor* file,
+                        const std::string& parameter,
+                        GeneratorContext* generator_context,
+                        std::string* error
+                    ) const override;
+                    uint64_t GetSupportedFeatures() const override;
+                };
 
-}  // namespace csharp
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace csharp
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_names.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_names.h
index 67e53b6..719b25d 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_names.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_names.h
@@ -44,64 +44,64 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
+namespace google
+{
+    namespace protobuf
+    {
 
-class Descriptor;
-class EnumDescriptor;
-class FileDescriptor;
-class ServiceDescriptor;
+        class Descriptor;
+        class EnumDescriptor;
+        class FileDescriptor;
+        class ServiceDescriptor;
 
-namespace compiler {
-namespace csharp {
+        namespace compiler
+        {
+            namespace csharp
+            {
 
-// Requires:
-//   descriptor != NULL
-//
-// Returns:
-//   The namespace to use for given file descriptor.
-std::string PROTOC_EXPORT GetFileNamespace(const FileDescriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                //
+                // Returns:
+                //   The namespace to use for given file descriptor.
+                std::string PROTOC_EXPORT GetFileNamespace(const FileDescriptor* descriptor);
 
-// Requires:
-//   descriptor != NULL
-//
-// Returns:
-//   The fully-qualified C# class name.
-std::string PROTOC_EXPORT GetClassName(const Descriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                //
+                // Returns:
+                //   The fully-qualified C# class name.
+                std::string PROTOC_EXPORT GetClassName(const Descriptor* descriptor);
 
-// Requires:
-//   descriptor != NULL
-//
-// Returns:
-//   The fully-qualified name of the C# class that provides
-//   access to the file descriptor. Proto compiler generates
-//   such class for each .proto file processed.
-std::string PROTOC_EXPORT
-GetReflectionClassName(const FileDescriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                //
+                // Returns:
+                //   The fully-qualified name of the C# class that provides
+                //   access to the file descriptor. Proto compiler generates
+                //   such class for each .proto file processed.
+                std::string PROTOC_EXPORT
+                    GetReflectionClassName(const FileDescriptor* descriptor);
 
-// Generates output file name for given file descriptor. If generate_directories
-// is true, the output file will be put under directory corresponding to file's
-// namespace. base_namespace can be used to strip some of the top level
-// directories. E.g. for file with namespace "Bar.Foo" and base_namespace="Bar",
-// the resulting file will be put under directory "Foo" (and not "Bar/Foo").
-//
-// Requires:
-//   descriptor != NULL
-//   error != NULL
-//
-//  Returns:
-//    The file name to use as output file for given file descriptor. In case
-//    of failure, this function will return empty string and error parameter
-//    will contain the error message.
-std::string PROTOC_EXPORT GetOutputFile(const FileDescriptor* descriptor,
-                                        const std::string file_extension,
-                                        const bool generate_directories,
-                                        const std::string base_namespace,
-                                        std::string* error);
+                // Generates output file name for given file descriptor. If generate_directories
+                // is true, the output file will be put under directory corresponding to file's
+                // namespace. base_namespace can be used to strip some of the top level
+                // directories. E.g. for file with namespace "Bar.Foo" and base_namespace="Bar",
+                // the resulting file will be put under directory "Foo" (and not "Bar/Foo").
+                //
+                // Requires:
+                //   descriptor != NULL
+                //   error != NULL
+                //
+                //  Returns:
+                //    The file name to use as output file for given file descriptor. In case
+                //    of failure, this function will return empty string and error parameter
+                //    will contain the error message.
+                std::string PROTOC_EXPORT GetOutputFile(const FileDescriptor* descriptor, const std::string file_extension, const bool generate_directories, const std::string base_namespace, std::string* error);
 
-}  // namespace csharp
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace csharp
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_options.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_options.h
index 42ff6d8..32c03de 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_options.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/csharp/csharp_options.h
@@ -33,49 +33,55 @@
 
 #include <string>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace csharp {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace csharp
+            {
 
-// Generator options (used by csharp_generator.cc):
-struct Options {
-  Options() :
-      file_extension(".cs"),
-      base_namespace(""),
-      base_namespace_specified(false),
-      internal_access(false),
-      serializable(false) {
-  }
-  // Extension of the generated file. Defaults to ".cs"
-  std::string file_extension;
-  // Base namespace to use to create directory hierarchy. Defaults to "".
-  // This option allows the simple creation of a conventional C# file layout,
-  // where directories are created relative to a project-specific base
-  // namespace. For example, in a project with a base namespace of PetShop, a
-  // proto of user.proto with a C# namespace of PetShop.Model.Shared would
-  // generate Model/Shared/User.cs underneath the specified --csharp_out
-  // directory.
-  //
-  // If no base namespace is specified, all files are generated in the
-  // --csharp_out directory, with no subdirectories created automatically.
-  std::string base_namespace;
-  // Whether the base namespace has been explicitly specified by the user.
-  // This is required as the base namespace can be explicitly set to the empty
-  // string, meaning "create a full directory hierarchy, starting from the first
-  // segment of the namespace."
-  bool base_namespace_specified;
-  // Whether the generated classes should have accessibility level of "internal".
-  // Defaults to false that generates "public" classes.
-  bool internal_access;
-  // Whether the generated classes should have a global::System.Serializable attribute added
-  // Defaults to false
-  bool serializable;
-};
+                // Generator options (used by csharp_generator.cc):
+                struct Options
+                {
+                    Options() :
+                        file_extension(".cs"),
+                        base_namespace(""),
+                        base_namespace_specified(false),
+                        internal_access(false),
+                        serializable(false)
+                    {
+                    }
+                    // Extension of the generated file. Defaults to ".cs"
+                    std::string file_extension;
+                    // Base namespace to use to create directory hierarchy. Defaults to "".
+                    // This option allows the simple creation of a conventional C# file layout,
+                    // where directories are created relative to a project-specific base
+                    // namespace. For example, in a project with a base namespace of PetShop, a
+                    // proto of user.proto with a C# namespace of PetShop.Model.Shared would
+                    // generate Model/Shared/User.cs underneath the specified --csharp_out
+                    // directory.
+                    //
+                    // If no base namespace is specified, all files are generated in the
+                    // --csharp_out directory, with no subdirectories created automatically.
+                    std::string base_namespace;
+                    // Whether the base namespace has been explicitly specified by the user.
+                    // This is required as the base namespace can be explicitly set to the empty
+                    // string, meaning "create a full directory hierarchy, starting from the first
+                    // segment of the namespace."
+                    bool base_namespace_specified;
+                    // Whether the generated classes should have accessibility level of "internal".
+                    // Defaults to false that generates "public" classes.
+                    bool internal_access;
+                    // Whether the generated classes should have a global::System.Serializable attribute added
+                    // Defaults to false
+                    bool serializable;
+                };
 
-}  // namespace csharp
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace csharp
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_OPTIONS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/importer.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/importer.h
index 2fb88b9..faacae3 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/importer.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/importer.h
@@ -49,288 +49,296 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-namespace io {
-class ZeroCopyInputStream;
-}
-
-namespace compiler {
-
-// Defined in this file.
-class Importer;
-class MultiFileErrorCollector;
-class SourceTree;
-class DiskSourceTree;
-
-// TODO(kenton):  Move all SourceTree stuff to a separate file?
-
-// An implementation of DescriptorDatabase which loads files from a SourceTree
-// and parses them.
-//
-// Note:  This class is not thread-safe since it maintains a table of source
-//   code locations for error reporting.  However, when a DescriptorPool wraps
-//   a DescriptorDatabase, it uses mutex locking to make sure only one method
-//   of the database is called at a time, even if the DescriptorPool is used
-//   from multiple threads.  Therefore, there is only a problem if you create
-//   multiple DescriptorPools wrapping the same SourceTreeDescriptorDatabase
-//   and use them from multiple threads.
-//
-// Note:  This class does not implement FindFileContainingSymbol() or
-//   FindFileContainingExtension(); these will always return false.
-class PROTOBUF_EXPORT SourceTreeDescriptorDatabase : public DescriptorDatabase {
- public:
-  SourceTreeDescriptorDatabase(SourceTree* source_tree);
-
-  // If non-NULL, fallback_database will be checked if a file doesn't exist in
-  // the specified source_tree.
-  SourceTreeDescriptorDatabase(SourceTree* source_tree,
-                               DescriptorDatabase* fallback_database);
-  ~SourceTreeDescriptorDatabase() override;
-
-  // Instructs the SourceTreeDescriptorDatabase to report any parse errors
-  // to the given MultiFileErrorCollector.  This should be called before
-  // parsing.  error_collector must remain valid until either this method
-  // is called again or the SourceTreeDescriptorDatabase is destroyed.
-  void RecordErrorsTo(MultiFileErrorCollector* error_collector) {
-    error_collector_ = error_collector;
-  }
-
-  // Gets a DescriptorPool::ErrorCollector which records errors to the
-  // MultiFileErrorCollector specified with RecordErrorsTo().  This collector
-  // has the ability to determine exact line and column numbers of errors
-  // from the information given to it by the DescriptorPool.
-  DescriptorPool::ErrorCollector* GetValidationErrorCollector() {
-    using_validation_error_collector_ = true;
-    return &validation_error_collector_;
-  }
-
-  // implements DescriptorDatabase -----------------------------------
-  bool FindFileByName(const std::string& filename,
-                      FileDescriptorProto* output) override;
-  bool FindFileContainingSymbol(const std::string& symbol_name,
-                                FileDescriptorProto* output) override;
-  bool FindFileContainingExtension(const std::string& containing_type,
-                                   int field_number,
-                                   FileDescriptorProto* output) override;
-
- private:
-  class SingleFileErrorCollector;
-
-  SourceTree* source_tree_;
-  DescriptorDatabase* fallback_database_;
-  MultiFileErrorCollector* error_collector_;
-
-  class PROTOBUF_EXPORT ValidationErrorCollector
-      : public DescriptorPool::ErrorCollector {
-   public:
-    ValidationErrorCollector(SourceTreeDescriptorDatabase* owner);
-    ~ValidationErrorCollector() override;
-
-    // implements ErrorCollector ---------------------------------------
-    void AddError(const std::string& filename, const std::string& element_name,
-                  const Message* descriptor, ErrorLocation location,
-                  const std::string& message) override;
-
-    void AddWarning(const std::string& filename,
-                    const std::string& element_name, const Message* descriptor,
-                    ErrorLocation location,
-                    const std::string& message) override;
-
-   private:
-    SourceTreeDescriptorDatabase* owner_;
-  };
-  friend class ValidationErrorCollector;
-
-  bool using_validation_error_collector_;
-  SourceLocationTable source_locations_;
-  ValidationErrorCollector validation_error_collector_;
-};
-
-// Simple interface for parsing .proto files.  This wraps the process
-// of opening the file, parsing it with a Parser, recursively parsing all its
-// imports, and then cross-linking the results to produce a FileDescriptor.
-//
-// This is really just a thin wrapper around SourceTreeDescriptorDatabase.
-// You may find that SourceTreeDescriptorDatabase is more flexible.
-//
-// TODO(kenton):  I feel like this class is not well-named.
-class PROTOBUF_EXPORT Importer {
- public:
-  Importer(SourceTree* source_tree, MultiFileErrorCollector* error_collector);
-  ~Importer();
-
-  // Import the given file and build a FileDescriptor representing it.  If
-  // the file is already in the DescriptorPool, the existing FileDescriptor
-  // will be returned.  The FileDescriptor is property of the DescriptorPool,
-  // and will remain valid until it is destroyed.  If any errors occur, they
-  // will be reported using the error collector and Import() will return NULL.
-  //
-  // A particular Importer object will only report errors for a particular
-  // file once.  All future attempts to import the same file will return NULL
-  // without reporting any errors.  The idea is that you might want to import
-  // a lot of files without seeing the same errors over and over again.  If
-  // you want to see errors for the same files repeatedly, you can use a
-  // separate Importer object to import each one (but use the same
-  // DescriptorPool so that they can be cross-linked).
-  const FileDescriptor* Import(const std::string& filename);
-
-  // The DescriptorPool in which all imported FileDescriptors and their
-  // contents are stored.
-  inline const DescriptorPool* pool() const { return &pool_; }
-
-  void AddUnusedImportTrackFile(const std::string& file_name,
-                                bool is_error = false);
-  void ClearUnusedImportTrackFiles();
-
-
- private:
-  SourceTreeDescriptorDatabase database_;
-  DescriptorPool pool_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Importer);
-};
-
-// If the importer encounters problems while trying to import the proto files,
-// it reports them to a MultiFileErrorCollector.
-class PROTOBUF_EXPORT MultiFileErrorCollector {
- public:
-  inline MultiFileErrorCollector() {}
-  virtual ~MultiFileErrorCollector();
-
-  // Line and column numbers are zero-based.  A line number of -1 indicates
-  // an error with the entire file (e.g. "not found").
-  virtual void AddError(const std::string& filename, int line, int column,
-                        const std::string& message) = 0;
-
-  virtual void AddWarning(const std::string& /* filename */, int /* line */,
-                          int /* column */, const std::string& /* message */) {}
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultiFileErrorCollector);
-};
-
-// Abstract interface which represents a directory tree containing proto files.
-// Used by the default implementation of Importer to resolve import statements
-// Most users will probably want to use the DiskSourceTree implementation,
-// below.
-class PROTOBUF_EXPORT SourceTree {
- public:
-  inline SourceTree() {}
-  virtual ~SourceTree();
-
-  // Open the given file and return a stream that reads it, or NULL if not
-  // found.  The caller takes ownership of the returned object.  The filename
-  // must be a path relative to the root of the source tree and must not
-  // contain "." or ".." components.
-  virtual io::ZeroCopyInputStream* Open(const std::string& filename) = 0;
-
-  // If Open() returns NULL, calling this method immediately will return an
-  // description of the error.
-  // Subclasses should implement this method and return a meaningful value for
-  // better error reporting.
-  // TODO(xiaofeng): change this to a pure virtual function.
-  virtual std::string GetLastErrorMessage();
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SourceTree);
-};
-
-// An implementation of SourceTree which loads files from locations on disk.
-// Multiple mappings can be set up to map locations in the DiskSourceTree to
-// locations in the physical filesystem.
-class PROTOBUF_EXPORT DiskSourceTree : public SourceTree {
- public:
-  DiskSourceTree();
-  ~DiskSourceTree() override;
-
-  // Map a path on disk to a location in the SourceTree.  The path may be
-  // either a file or a directory.  If it is a directory, the entire tree
-  // under it will be mapped to the given virtual location.  To map a directory
-  // to the root of the source tree, pass an empty string for virtual_path.
-  //
-  // If multiple mapped paths apply when opening a file, they will be searched
-  // in order.  For example, if you do:
-  //   MapPath("bar", "foo/bar");
-  //   MapPath("", "baz");
-  // and then you do:
-  //   Open("bar/qux");
-  // the DiskSourceTree will first try to open foo/bar/qux, then baz/bar/qux,
-  // returning the first one that opens successfully.
-  //
-  // disk_path may be an absolute path or relative to the current directory,
-  // just like a path you'd pass to open().
-  void MapPath(const std::string& virtual_path, const std::string& disk_path);
-
-  // Return type for DiskFileToVirtualFile().
-  enum DiskFileToVirtualFileResult {
-    SUCCESS,
-    SHADOWED,
-    CANNOT_OPEN,
-    NO_MAPPING
-  };
-
-  // Given a path to a file on disk, find a virtual path mapping to that
-  // file.  The first mapping created with MapPath() whose disk_path contains
-  // the filename is used.  However, that virtual path may not actually be
-  // usable to open the given file.  Possible return values are:
-  // * SUCCESS: The mapping was found.  *virtual_file is filled in so that
-  //   calling Open(*virtual_file) will open the file named by disk_file.
-  // * SHADOWED: A mapping was found, but using Open() to open this virtual
-  //   path will end up returning some different file.  This is because some
-  //   other mapping with a higher precedence also matches this virtual path
-  //   and maps it to a different file that exists on disk.  *virtual_file
-  //   is filled in as it would be in the SUCCESS case.  *shadowing_disk_file
-  //   is filled in with the disk path of the file which would be opened if
-  //   you were to call Open(*virtual_file).
-  // * CANNOT_OPEN: The mapping was found and was not shadowed, but the
-  //   file specified cannot be opened.  When this value is returned,
-  //   errno will indicate the reason the file cannot be opened.  *virtual_file
-  //   will be set to the virtual path as in the SUCCESS case, even though
-  //   it is not useful.
-  // * NO_MAPPING: Indicates that no mapping was found which contains this
-  //   file.
-  DiskFileToVirtualFileResult DiskFileToVirtualFile(
-      const std::string& disk_file, std::string* virtual_file,
-      std::string* shadowing_disk_file);
-
-  // Given a virtual path, find the path to the file on disk.
-  // Return true and update disk_file with the on-disk path if the file exists.
-  // Return false and leave disk_file untouched if the file doesn't exist.
-  bool VirtualFileToDiskFile(const std::string& virtual_file,
-                             std::string* disk_file);
-
-  // implements SourceTree -------------------------------------------
-  io::ZeroCopyInputStream* Open(const std::string& filename) override;
-
-  std::string GetLastErrorMessage() override;
-
- private:
-  struct Mapping {
-    std::string virtual_path;
-    std::string disk_path;
-
-    inline Mapping(const std::string& virtual_path_param,
-                   const std::string& disk_path_param)
-        : virtual_path(virtual_path_param), disk_path(disk_path_param) {}
-  };
-  std::vector<Mapping> mappings_;
-  std::string last_error_message_;
-
-  // Like Open(), but returns the on-disk path in disk_file if disk_file is
-  // non-NULL and the file could be successfully opened.
-  io::ZeroCopyInputStream* OpenVirtualFile(const std::string& virtual_file,
-                                           std::string* disk_file);
-
-  // Like Open() but given the actual on-disk path.
-  io::ZeroCopyInputStream* OpenDiskFile(const std::string& filename);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DiskSourceTree);
-};
-
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        namespace io
+        {
+            class ZeroCopyInputStream;
+        }
+
+        namespace compiler
+        {
+
+            // Defined in this file.
+            class Importer;
+            class MultiFileErrorCollector;
+            class SourceTree;
+            class DiskSourceTree;
+
+            // TODO(kenton):  Move all SourceTree stuff to a separate file?
+
+            // An implementation of DescriptorDatabase which loads files from a SourceTree
+            // and parses them.
+            //
+            // Note:  This class is not thread-safe since it maintains a table of source
+            //   code locations for error reporting.  However, when a DescriptorPool wraps
+            //   a DescriptorDatabase, it uses mutex locking to make sure only one method
+            //   of the database is called at a time, even if the DescriptorPool is used
+            //   from multiple threads.  Therefore, there is only a problem if you create
+            //   multiple DescriptorPools wrapping the same SourceTreeDescriptorDatabase
+            //   and use them from multiple threads.
+            //
+            // Note:  This class does not implement FindFileContainingSymbol() or
+            //   FindFileContainingExtension(); these will always return false.
+            class PROTOBUF_EXPORT SourceTreeDescriptorDatabase : public DescriptorDatabase
+            {
+            public:
+                SourceTreeDescriptorDatabase(SourceTree* source_tree);
+
+                // If non-NULL, fallback_database will be checked if a file doesn't exist in
+                // the specified source_tree.
+                SourceTreeDescriptorDatabase(SourceTree* source_tree, DescriptorDatabase* fallback_database);
+                ~SourceTreeDescriptorDatabase() override;
+
+                // Instructs the SourceTreeDescriptorDatabase to report any parse errors
+                // to the given MultiFileErrorCollector.  This should be called before
+                // parsing.  error_collector must remain valid until either this method
+                // is called again or the SourceTreeDescriptorDatabase is destroyed.
+                void RecordErrorsTo(MultiFileErrorCollector* error_collector)
+                {
+                    error_collector_ = error_collector;
+                }
+
+                // Gets a DescriptorPool::ErrorCollector which records errors to the
+                // MultiFileErrorCollector specified with RecordErrorsTo().  This collector
+                // has the ability to determine exact line and column numbers of errors
+                // from the information given to it by the DescriptorPool.
+                DescriptorPool::ErrorCollector* GetValidationErrorCollector()
+                {
+                    using_validation_error_collector_ = true;
+                    return &validation_error_collector_;
+                }
+
+                // implements DescriptorDatabase -----------------------------------
+                bool FindFileByName(const std::string& filename, FileDescriptorProto* output) override;
+                bool FindFileContainingSymbol(const std::string& symbol_name, FileDescriptorProto* output) override;
+                bool FindFileContainingExtension(const std::string& containing_type, int field_number, FileDescriptorProto* output) override;
+
+            private:
+                class SingleFileErrorCollector;
+
+                SourceTree* source_tree_;
+                DescriptorDatabase* fallback_database_;
+                MultiFileErrorCollector* error_collector_;
+
+                class PROTOBUF_EXPORT ValidationErrorCollector : public DescriptorPool::ErrorCollector
+                {
+                public:
+                    ValidationErrorCollector(SourceTreeDescriptorDatabase* owner);
+                    ~ValidationErrorCollector() override;
+
+                    // implements ErrorCollector ---------------------------------------
+                    void AddError(const std::string& filename, const std::string& element_name, const Message* descriptor, ErrorLocation location, const std::string& message) override;
+
+                    void AddWarning(const std::string& filename, const std::string& element_name, const Message* descriptor, ErrorLocation location, const std::string& message) override;
+
+                private:
+                    SourceTreeDescriptorDatabase* owner_;
+                };
+                friend class ValidationErrorCollector;
+
+                bool using_validation_error_collector_;
+                SourceLocationTable source_locations_;
+                ValidationErrorCollector validation_error_collector_;
+            };
+
+            // Simple interface for parsing .proto files.  This wraps the process
+            // of opening the file, parsing it with a Parser, recursively parsing all its
+            // imports, and then cross-linking the results to produce a FileDescriptor.
+            //
+            // This is really just a thin wrapper around SourceTreeDescriptorDatabase.
+            // You may find that SourceTreeDescriptorDatabase is more flexible.
+            //
+            // TODO(kenton):  I feel like this class is not well-named.
+            class PROTOBUF_EXPORT Importer
+            {
+            public:
+                Importer(SourceTree* source_tree, MultiFileErrorCollector* error_collector);
+                ~Importer();
+
+                // Import the given file and build a FileDescriptor representing it.  If
+                // the file is already in the DescriptorPool, the existing FileDescriptor
+                // will be returned.  The FileDescriptor is property of the DescriptorPool,
+                // and will remain valid until it is destroyed.  If any errors occur, they
+                // will be reported using the error collector and Import() will return NULL.
+                //
+                // A particular Importer object will only report errors for a particular
+                // file once.  All future attempts to import the same file will return NULL
+                // without reporting any errors.  The idea is that you might want to import
+                // a lot of files without seeing the same errors over and over again.  If
+                // you want to see errors for the same files repeatedly, you can use a
+                // separate Importer object to import each one (but use the same
+                // DescriptorPool so that they can be cross-linked).
+                const FileDescriptor* Import(const std::string& filename);
+
+                // The DescriptorPool in which all imported FileDescriptors and their
+                // contents are stored.
+                inline const DescriptorPool* pool() const
+                {
+                    return &pool_;
+                }
+
+                void AddUnusedImportTrackFile(const std::string& file_name, bool is_error = false);
+                void ClearUnusedImportTrackFiles();
+
+            private:
+                SourceTreeDescriptorDatabase database_;
+                DescriptorPool pool_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Importer);
+            };
+
+            // If the importer encounters problems while trying to import the proto files,
+            // it reports them to a MultiFileErrorCollector.
+            class PROTOBUF_EXPORT MultiFileErrorCollector
+            {
+            public:
+                inline MultiFileErrorCollector()
+                {
+                }
+                virtual ~MultiFileErrorCollector();
+
+                // Line and column numbers are zero-based.  A line number of -1 indicates
+                // an error with the entire file (e.g. "not found").
+                virtual void AddError(const std::string& filename, int line, int column, const std::string& message) = 0;
+
+                virtual void AddWarning(const std::string& /* filename */, int /* line */, int /* column */, const std::string& /* message */)
+                {
+                }
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultiFileErrorCollector);
+            };
+
+            // Abstract interface which represents a directory tree containing proto files.
+            // Used by the default implementation of Importer to resolve import statements
+            // Most users will probably want to use the DiskSourceTree implementation,
+            // below.
+            class PROTOBUF_EXPORT SourceTree
+            {
+            public:
+                inline SourceTree()
+                {
+                }
+                virtual ~SourceTree();
+
+                // Open the given file and return a stream that reads it, or NULL if not
+                // found.  The caller takes ownership of the returned object.  The filename
+                // must be a path relative to the root of the source tree and must not
+                // contain "." or ".." components.
+                virtual io::ZeroCopyInputStream* Open(const std::string& filename) = 0;
+
+                // If Open() returns NULL, calling this method immediately will return an
+                // description of the error.
+                // Subclasses should implement this method and return a meaningful value for
+                // better error reporting.
+                // TODO(xiaofeng): change this to a pure virtual function.
+                virtual std::string GetLastErrorMessage();
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SourceTree);
+            };
+
+            // An implementation of SourceTree which loads files from locations on disk.
+            // Multiple mappings can be set up to map locations in the DiskSourceTree to
+            // locations in the physical filesystem.
+            class PROTOBUF_EXPORT DiskSourceTree : public SourceTree
+            {
+            public:
+                DiskSourceTree();
+                ~DiskSourceTree() override;
+
+                // Map a path on disk to a location in the SourceTree.  The path may be
+                // either a file or a directory.  If it is a directory, the entire tree
+                // under it will be mapped to the given virtual location.  To map a directory
+                // to the root of the source tree, pass an empty string for virtual_path.
+                //
+                // If multiple mapped paths apply when opening a file, they will be searched
+                // in order.  For example, if you do:
+                //   MapPath("bar", "foo/bar");
+                //   MapPath("", "baz");
+                // and then you do:
+                //   Open("bar/qux");
+                // the DiskSourceTree will first try to open foo/bar/qux, then baz/bar/qux,
+                // returning the first one that opens successfully.
+                //
+                // disk_path may be an absolute path or relative to the current directory,
+                // just like a path you'd pass to open().
+                void MapPath(const std::string& virtual_path, const std::string& disk_path);
+
+                // Return type for DiskFileToVirtualFile().
+                enum DiskFileToVirtualFileResult
+                {
+                    SUCCESS,
+                    SHADOWED,
+                    CANNOT_OPEN,
+                    NO_MAPPING
+                };
+
+                // Given a path to a file on disk, find a virtual path mapping to that
+                // file.  The first mapping created with MapPath() whose disk_path contains
+                // the filename is used.  However, that virtual path may not actually be
+                // usable to open the given file.  Possible return values are:
+                // * SUCCESS: The mapping was found.  *virtual_file is filled in so that
+                //   calling Open(*virtual_file) will open the file named by disk_file.
+                // * SHADOWED: A mapping was found, but using Open() to open this virtual
+                //   path will end up returning some different file.  This is because some
+                //   other mapping with a higher precedence also matches this virtual path
+                //   and maps it to a different file that exists on disk.  *virtual_file
+                //   is filled in as it would be in the SUCCESS case.  *shadowing_disk_file
+                //   is filled in with the disk path of the file which would be opened if
+                //   you were to call Open(*virtual_file).
+                // * CANNOT_OPEN: The mapping was found and was not shadowed, but the
+                //   file specified cannot be opened.  When this value is returned,
+                //   errno will indicate the reason the file cannot be opened.  *virtual_file
+                //   will be set to the virtual path as in the SUCCESS case, even though
+                //   it is not useful.
+                // * NO_MAPPING: Indicates that no mapping was found which contains this
+                //   file.
+                DiskFileToVirtualFileResult DiskFileToVirtualFile(
+                    const std::string& disk_file, std::string* virtual_file, std::string* shadowing_disk_file
+                );
+
+                // Given a virtual path, find the path to the file on disk.
+                // Return true and update disk_file with the on-disk path if the file exists.
+                // Return false and leave disk_file untouched if the file doesn't exist.
+                bool VirtualFileToDiskFile(const std::string& virtual_file, std::string* disk_file);
+
+                // implements SourceTree -------------------------------------------
+                io::ZeroCopyInputStream* Open(const std::string& filename) override;
+
+                std::string GetLastErrorMessage() override;
+
+            private:
+                struct Mapping
+                {
+                    std::string virtual_path;
+                    std::string disk_path;
+
+                    inline Mapping(const std::string& virtual_path_param, const std::string& disk_path_param) :
+                        virtual_path(virtual_path_param),
+                        disk_path(disk_path_param)
+                    {
+                    }
+                };
+                std::vector<Mapping> mappings_;
+                std::string last_error_message_;
+
+                // Like Open(), but returns the on-disk path in disk_file if disk_file is
+                // non-NULL and the file could be successfully opened.
+                io::ZeroCopyInputStream* OpenVirtualFile(const std::string& virtual_file, std::string* disk_file);
+
+                // Like Open() but given the actual on-disk path.
+                io::ZeroCopyInputStream* OpenDiskFile(const std::string& filename);
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DiskSourceTree);
+            };
+
+        }  // namespace compiler
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/generator.h
index bbc7170..c3a3466 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/generator.h
@@ -43,33 +43,37 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace java {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace java
+            {
 
-// CodeGenerator implementation which generates Java code.  If you create your
-// own protocol compiler binary and you want it to support Java output, you
-// can do so by registering an instance of this CodeGenerator with the
-// CommandLineInterface in your main() function.
-class PROTOC_EXPORT JavaGenerator : public CodeGenerator {
- public:
-  JavaGenerator();
-  ~JavaGenerator() override;
+                // CodeGenerator implementation which generates Java code.  If you create your
+                // own protocol compiler binary and you want it to support Java output, you
+                // can do so by registering an instance of this CodeGenerator with the
+                // CommandLineInterface in your main() function.
+                class PROTOC_EXPORT JavaGenerator : public CodeGenerator
+                {
+                public:
+                    JavaGenerator();
+                    ~JavaGenerator() override;
 
-  // implements CodeGenerator ----------------------------------------
-  bool Generate(const FileDescriptor* file, const std::string& parameter,
-                GeneratorContext* context, std::string* error) const override;
+                    // implements CodeGenerator ----------------------------------------
+                    bool Generate(const FileDescriptor* file, const std::string& parameter, GeneratorContext* context, std::string* error) const override;
 
-  uint64_t GetSupportedFeatures() const override;
+                    uint64_t GetSupportedFeatures() const override;
 
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(JavaGenerator);
-};
+                private:
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(JavaGenerator);
+                };
 
-}  // namespace java
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace java
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/kotlin_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/kotlin_generator.h
index ccd9688..ec2772c 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/kotlin_generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/kotlin_generator.h
@@ -40,33 +40,37 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace java {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace java
+            {
 
-// CodeGenerator implementation which generates Kotlin code.  If you create your
-// own protocol compiler binary and you want it to support Kotlin output, you
-// can do so by registering an instance of this CodeGenerator with the
-// CommandLineInterface in your main() function.
-class PROTOC_EXPORT KotlinGenerator : public CodeGenerator {
- public:
-  KotlinGenerator();
-  ~KotlinGenerator() override;
+                // CodeGenerator implementation which generates Kotlin code.  If you create your
+                // own protocol compiler binary and you want it to support Kotlin output, you
+                // can do so by registering an instance of this CodeGenerator with the
+                // CommandLineInterface in your main() function.
+                class PROTOC_EXPORT KotlinGenerator : public CodeGenerator
+                {
+                public:
+                    KotlinGenerator();
+                    ~KotlinGenerator() override;
 
-  // implements CodeGenerator ----------------------------------------
-  bool Generate(const FileDescriptor* file, const std::string& parameter,
-                GeneratorContext* context, std::string* error) const override;
+                    // implements CodeGenerator ----------------------------------------
+                    bool Generate(const FileDescriptor* file, const std::string& parameter, GeneratorContext* context, std::string* error) const override;
 
-  uint64_t GetSupportedFeatures() const override;
+                    uint64_t GetSupportedFeatures() const override;
 
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(KotlinGenerator);
-};
+                private:
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(KotlinGenerator);
+                };
 
-}  // namespace java
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace java
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/names.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/names.h
index 313ace4..cd28c8d 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/java/names.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/java/names.h
@@ -40,61 +40,65 @@
 
 #include <string>
 
-namespace google {
-namespace protobuf {
+namespace google
+{
+    namespace protobuf
+    {
 
-class Descriptor;
-class EnumDescriptor;
-class FileDescriptor;
-class FieldDescriptor;
-class ServiceDescriptor;
+        class Descriptor;
+        class EnumDescriptor;
+        class FileDescriptor;
+        class FieldDescriptor;
+        class ServiceDescriptor;
 
-namespace compiler {
-namespace java {
+        namespace compiler
+        {
+            namespace java
+            {
 
-// Requires:
-//   descriptor != NULL
-//
-// Returns:
-//   The fully-qualified Java class name.
-std::string ClassName(const Descriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                //
+                // Returns:
+                //   The fully-qualified Java class name.
+                std::string ClassName(const Descriptor* descriptor);
 
-// Requires:
-//   descriptor != NULL
-//
-// Returns:
-//   The fully-qualified Java class name.
-std::string ClassName(const EnumDescriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                //
+                // Returns:
+                //   The fully-qualified Java class name.
+                std::string ClassName(const EnumDescriptor* descriptor);
 
-// Requires:
-//   descriptor != NULL
-//
-// Returns:
-//   The fully-qualified Java class name.
-std::string ClassName(const FileDescriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                //
+                // Returns:
+                //   The fully-qualified Java class name.
+                std::string ClassName(const FileDescriptor* descriptor);
 
-// Requires:
-//   descriptor != NULL
-//
-// Returns:
-//   The fully-qualified Java class name.
-std::string ClassName(const ServiceDescriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                //
+                // Returns:
+                //   The fully-qualified Java class name.
+                std::string ClassName(const ServiceDescriptor* descriptor);
 
-// Requires:
-//   descriptor != NULL
-//
-// Returns:
-//   Java package name.
-std::string FileJavaPackage(const FileDescriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                //
+                // Returns:
+                //   Java package name.
+                std::string FileJavaPackage(const FileDescriptor* descriptor);
 
-// Requires:
-//   descriptor != NULL
-// Returns:
-//   Capitalized camel case name field name.
-std::string CapitalizedFieldName(const FieldDescriptor* descriptor);
+                // Requires:
+                //   descriptor != NULL
+                // Returns:
+                //   Capitalized camel case name field name.
+                std::string CapitalizedFieldName(const FieldDescriptor* descriptor);
 
-}  // namespace java
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace java
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_generator.h
index 1dbc666..683f0d6 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_generator.h
@@ -39,39 +39,42 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace objectivec {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace objectivec
+            {
 
-// CodeGenerator implementation which generates a ObjectiveC source file and
-// header.  If you create your own protocol compiler binary and you want it to
-// support ObjectiveC output, you can do so by registering an instance of this
-// CodeGenerator with the CommandLineInterface in your main() function.
-class PROTOC_EXPORT ObjectiveCGenerator : public CodeGenerator {
- public:
-  ObjectiveCGenerator();
-  ~ObjectiveCGenerator();
+                // CodeGenerator implementation which generates a ObjectiveC source file and
+                // header.  If you create your own protocol compiler binary and you want it to
+                // support ObjectiveC output, you can do so by registering an instance of this
+                // CodeGenerator with the CommandLineInterface in your main() function.
+                class PROTOC_EXPORT ObjectiveCGenerator : public CodeGenerator
+                {
+                public:
+                    ObjectiveCGenerator();
+                    ~ObjectiveCGenerator();
 
-  ObjectiveCGenerator(const ObjectiveCGenerator&) = delete;
-  ObjectiveCGenerator& operator=(const ObjectiveCGenerator&) = delete;
+                    ObjectiveCGenerator(const ObjectiveCGenerator&) = delete;
+                    ObjectiveCGenerator& operator=(const ObjectiveCGenerator&) = delete;
 
-  // implements CodeGenerator ----------------------------------------
-  bool HasGenerateAll() const override;
-  bool Generate(const FileDescriptor* file, const std::string& parameter,
-                GeneratorContext* context, std::string* error) const override;
-  bool GenerateAll(const std::vector<const FileDescriptor*>& files,
-                   const std::string& parameter, GeneratorContext* context,
-                   std::string* error) const override;
+                    // implements CodeGenerator ----------------------------------------
+                    bool HasGenerateAll() const override;
+                    bool Generate(const FileDescriptor* file, const std::string& parameter, GeneratorContext* context, std::string* error) const override;
+                    bool GenerateAll(const std::vector<const FileDescriptor*>& files, const std::string& parameter, GeneratorContext* context, std::string* error) const override;
 
-  uint64_t GetSupportedFeatures() const override {
-    return FEATURE_PROTO3_OPTIONAL;
-  }
-};
+                    uint64_t GetSupportedFeatures() const override
+                    {
+                        return FEATURE_PROTO3_OPTIONAL;
+                    }
+                };
 
-}  // namespace objectivec
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace objectivec
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_helpers.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_helpers.h
index d21fed2..f98fe6a 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_helpers.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/objectivec/objectivec_helpers.h
@@ -42,310 +42,325 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace objectivec {
-
-// Get/Set the path to a file to load for objc class prefix lookups.
-std::string PROTOC_EXPORT GetPackageToPrefixMappingsPath();
-void PROTOC_EXPORT SetPackageToPrefixMappingsPath(
-    const std::string& file_path);
-// Get/Set if the proto package should be used to make the default prefix for
-// symbols. This will then impact most of the type naming apis below. It is done
-// as a global to not break any other generator reusing the methods since they
-// are exported.
-bool PROTOC_EXPORT UseProtoPackageAsDefaultPrefix();
-void PROTOC_EXPORT SetUseProtoPackageAsDefaultPrefix(bool on_or_off);
-// Get/Set the path to a file to load as exceptions when
-// `UseProtoPackageAsDefaultPrefix()` is `true`. An empty string means there
-// should be no exceptions.
-std::string PROTOC_EXPORT GetProtoPackagePrefixExceptionList();
-void PROTOC_EXPORT SetProtoPackagePrefixExceptionList(
-    const std::string& file_path);
-
-// Generator Prefix Validation Options (see objectivec_generator.cc for a
-// description of each):
-struct Options {
-  Options();
-  std::string expected_prefixes_path;
-  std::vector<std::string> expected_prefixes_suppressions;
-  bool prefixes_must_be_registered;
-  bool require_prefixes;
-};
-
-// Escape C++ trigraphs by escaping question marks to "\?".
-std::string PROTOC_EXPORT EscapeTrigraphs(const std::string& to_escape);
-
-// Remove white space from either end of a StringPiece.
-void PROTOC_EXPORT TrimWhitespace(StringPiece* input);
-
-// Returns true if the name requires a ns_returns_not_retained attribute applied
-// to it.
-bool PROTOC_EXPORT IsRetainedName(const std::string& name);
-
-// Returns true if the name starts with "init" and will need to have special
-// handling under ARC.
-bool PROTOC_EXPORT IsInitName(const std::string& name);
-
-// Gets the objc_class_prefix or the prefix made from the proto package.
-std::string PROTOC_EXPORT FileClassPrefix(const FileDescriptor* file);
-
-// Gets the path of the file we're going to generate (sans the .pb.h
-// extension).  The path will be dependent on the objectivec package
-// declared in the proto package.
-std::string PROTOC_EXPORT FilePath(const FileDescriptor* file);
-
-// Just like FilePath(), but without the directory part.
-std::string PROTOC_EXPORT FilePathBasename(const FileDescriptor* file);
-
-// Gets the name of the root class we'll generate in the file.  This class
-// is not meant for external consumption, but instead contains helpers that
-// the rest of the classes need
-std::string PROTOC_EXPORT FileClassName(const FileDescriptor* file);
-
-// These return the fully-qualified class name corresponding to the given
-// descriptor.
-std::string PROTOC_EXPORT ClassName(const Descriptor* descriptor);
-std::string PROTOC_EXPORT ClassName(const Descriptor* descriptor,
-                                    std::string* out_suffix_added);
-std::string PROTOC_EXPORT EnumName(const EnumDescriptor* descriptor);
-
-// Returns the fully-qualified name of the enum value corresponding to the
-// the descriptor.
-std::string PROTOC_EXPORT EnumValueName(const EnumValueDescriptor* descriptor);
-
-// Returns the name of the enum value corresponding to the descriptor.
-std::string PROTOC_EXPORT EnumValueShortName(const EnumValueDescriptor* descriptor);
-
-// Reverse what an enum does.
-std::string PROTOC_EXPORT UnCamelCaseEnumShortName(const std::string& name);
-
-// Returns the name to use for the extension (used as the method off the file's
-// Root class).
-std::string PROTOC_EXPORT ExtensionMethodName(const FieldDescriptor* descriptor);
-
-// Returns the transformed field name.
-std::string PROTOC_EXPORT FieldName(const FieldDescriptor* field);
-std::string PROTOC_EXPORT FieldNameCapitalized(const FieldDescriptor* field);
-
-// Returns the transformed oneof name.
-std::string PROTOC_EXPORT OneofEnumName(const OneofDescriptor* descriptor);
-std::string PROTOC_EXPORT OneofName(const OneofDescriptor* descriptor);
-std::string PROTOC_EXPORT OneofNameCapitalized(const OneofDescriptor* descriptor);
-
-// Returns a symbol that can be used in C code to refer to an Objective C
-// class without initializing the class.
-std::string PROTOC_EXPORT ObjCClass(const std::string& class_name);
-
-// Declares an Objective C class without initializing the class so that it can
-// be refrerred to by ObjCClass.
-std::string PROTOC_EXPORT ObjCClassDeclaration(const std::string& class_name);
-
-inline bool HasPreservingUnknownEnumSemantics(const FileDescriptor* file) {
-  return file->syntax() == FileDescriptor::SYNTAX_PROTO3;
-}
-
-inline bool IsMapEntryMessage(const Descriptor* descriptor) {
-  return descriptor->options().map_entry();
-}
-
-// Reverse of the above.
-std::string PROTOC_EXPORT UnCamelCaseFieldName(const std::string& name,
-                                               const FieldDescriptor* field);
-
-enum ObjectiveCType {
-  OBJECTIVECTYPE_INT32,
-  OBJECTIVECTYPE_UINT32,
-  OBJECTIVECTYPE_INT64,
-  OBJECTIVECTYPE_UINT64,
-  OBJECTIVECTYPE_FLOAT,
-  OBJECTIVECTYPE_DOUBLE,
-  OBJECTIVECTYPE_BOOLEAN,
-  OBJECTIVECTYPE_STRING,
-  OBJECTIVECTYPE_DATA,
-  OBJECTIVECTYPE_ENUM,
-  OBJECTIVECTYPE_MESSAGE
-};
-
-enum FlagType {
-  FLAGTYPE_DESCRIPTOR_INITIALIZATION,
-  FLAGTYPE_EXTENSION,
-  FLAGTYPE_FIELD
-};
-
-template <class TDescriptor>
-std::string GetOptionalDeprecatedAttribute(const TDescriptor* descriptor,
-                                           const FileDescriptor* file = NULL,
-                                           bool preSpace = true,
-                                           bool postNewline = false) {
-  bool isDeprecated = descriptor->options().deprecated();
-  // The file is only passed when checking Messages & Enums, so those types
-  // get tagged. At the moment, it doesn't seem to make sense to tag every
-  // field or enum value with when the file is deprecated.
-  bool isFileLevelDeprecation = false;
-  if (!isDeprecated && file) {
-    isFileLevelDeprecation = file->options().deprecated();
-    isDeprecated = isFileLevelDeprecation;
-  }
-  if (isDeprecated) {
-    std::string message;
-    const FileDescriptor* sourceFile = descriptor->file();
-    if (isFileLevelDeprecation) {
-      message = sourceFile->name() + " is deprecated.";
-    } else {
-      message = descriptor->full_name() + " is deprecated (see " +
-                sourceFile->name() + ").";
-    }
-
-    std::string result = std::string("GPB_DEPRECATED_MSG(\"") + message + "\")";
-    if (preSpace) {
-      result.insert(0, " ");
-    }
-    if (postNewline) {
-      result.append("\n");
-    }
-    return result;
-  } else {
-    return "";
-  }
-}
-
-std::string PROTOC_EXPORT GetCapitalizedType(const FieldDescriptor* field);
-
-ObjectiveCType PROTOC_EXPORT
-GetObjectiveCType(FieldDescriptor::Type field_type);
-
-inline ObjectiveCType GetObjectiveCType(const FieldDescriptor* field) {
-  return GetObjectiveCType(field->type());
-}
-
-bool PROTOC_EXPORT IsPrimitiveType(const FieldDescriptor* field);
-bool PROTOC_EXPORT IsReferenceType(const FieldDescriptor* field);
-
-std::string PROTOC_EXPORT
-GPBGenericValueFieldName(const FieldDescriptor* field);
-std::string PROTOC_EXPORT DefaultValue(const FieldDescriptor* field);
-bool PROTOC_EXPORT HasNonZeroDefaultValue(const FieldDescriptor* field);
-
-std::string PROTOC_EXPORT
-BuildFlagsString(const FlagType type, const std::vector<std::string>& strings);
-
-// Builds HeaderDoc/appledoc style comments out of the comments in the .proto
-// file.
-std::string PROTOC_EXPORT BuildCommentsString(const SourceLocation& location,
-                                              bool prefer_single_line);
-
-// The name the commonly used by the library when built as a framework.
-// This lines up to the name used in the CocoaPod.
-extern PROTOC_EXPORT const char* const ProtobufLibraryFrameworkName;
-// Returns the CPP symbol name to use as the gate for framework style imports
-// for the given framework name to use.
-std::string PROTOC_EXPORT
-ProtobufFrameworkImportSymbol(const std::string& framework_name);
-
-// Checks if the file is one of the proto's bundled with the library.
-bool PROTOC_EXPORT
-IsProtobufLibraryBundledProtoFile(const FileDescriptor* file);
-
-// Checks the prefix for the given files and outputs any warnings as needed. If
-// there are flat out errors, then out_error is filled in with the first error
-// and the result is false.
-bool PROTOC_EXPORT ValidateObjCClassPrefixes(
-    const std::vector<const FileDescriptor*>& files,
-    const Options& validation_options, std::string* out_error);
-// Same was the other ValidateObjCClassPrefixes() calls, but the options all
-// come from the environment variables.
-bool PROTOC_EXPORT ValidateObjCClassPrefixes(
-    const std::vector<const FileDescriptor*>& files, std::string* out_error);
-
-// Generate decode data needed for ObjC's GPBDecodeTextFormatName() to transform
-// the input into the expected output.
-class PROTOC_EXPORT TextFormatDecodeData {
- public:
-  TextFormatDecodeData();
-  ~TextFormatDecodeData();
-
-  TextFormatDecodeData(const TextFormatDecodeData&) = delete;
-  TextFormatDecodeData& operator=(const TextFormatDecodeData&) = delete;
-
-  void AddString(int32_t key, const std::string& input_for_decode,
-                 const std::string& desired_output);
-  size_t num_entries() const { return entries_.size(); }
-  std::string Data() const;
-
-  static std::string DecodeDataForString(const std::string& input_for_decode,
-                                         const std::string& desired_output);
-
- private:
-  typedef std::pair<int32_t, std::string> DataEntry;
-  std::vector<DataEntry> entries_;
-};
-
-// Helper for parsing simple files.
-class PROTOC_EXPORT LineConsumer {
- public:
-  LineConsumer();
-  virtual ~LineConsumer();
-  virtual bool ConsumeLine(const StringPiece& line, std::string* out_error) = 0;
-};
-
-bool PROTOC_EXPORT ParseSimpleFile(const std::string& path,
-                                   LineConsumer* line_consumer,
-                                   std::string* out_error);
-
-bool PROTOC_EXPORT ParseSimpleStream(io::ZeroCopyInputStream& input_stream,
-                                     const std::string& stream_name,
-                                     LineConsumer* line_consumer,
-                                     std::string* out_error);
-
-// Helper class for parsing framework import mappings and generating
-// import statements.
-class PROTOC_EXPORT ImportWriter {
- public:
-  ImportWriter(const std::string& generate_for_named_framework,
-               const std::string& named_framework_to_proto_path_mappings_path,
-               const std::string& runtime_import_prefix,
-               bool include_wkt_imports);
-  ~ImportWriter();
-
-  void AddFile(const FileDescriptor* file, const std::string& header_extension);
-  void Print(io::Printer* printer) const;
-
-  static void PrintRuntimeImports(io::Printer* printer,
-                                  const std::vector<std::string>& header_to_import,
-                                  const std::string& runtime_import_prefix,
-                                  bool default_cpp_symbol = false);
-
- private:
-  class ProtoFrameworkCollector : public LineConsumer {
-   public:
-    ProtoFrameworkCollector(std::map<std::string, std::string>* inout_proto_file_to_framework_name)
-        : map_(inout_proto_file_to_framework_name) {}
-
-    virtual bool ConsumeLine(const StringPiece& line, std::string* out_error) override;
-
-   private:
-    std::map<std::string, std::string>* map_;
-  };
-
-  void ParseFrameworkMappings();
-
-  const std::string generate_for_named_framework_;
-  const std::string named_framework_to_proto_path_mappings_path_;
-  const std::string runtime_import_prefix_;
-  const bool include_wkt_imports_;
-  std::map<std::string, std::string> proto_file_to_framework_name_;
-  bool need_to_parse_mapping_file_;
-
-  std::vector<std::string> protobuf_imports_;
-  std::vector<std::string> other_framework_imports_;
-  std::vector<std::string> other_imports_;
-};
-
-}  // namespace objectivec
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace objectivec
+            {
+
+                // Get/Set the path to a file to load for objc class prefix lookups.
+                std::string PROTOC_EXPORT GetPackageToPrefixMappingsPath();
+                void PROTOC_EXPORT SetPackageToPrefixMappingsPath(
+                    const std::string& file_path
+                );
+                // Get/Set if the proto package should be used to make the default prefix for
+                // symbols. This will then impact most of the type naming apis below. It is done
+                // as a global to not break any other generator reusing the methods since they
+                // are exported.
+                bool PROTOC_EXPORT UseProtoPackageAsDefaultPrefix();
+                void PROTOC_EXPORT SetUseProtoPackageAsDefaultPrefix(bool on_or_off);
+                // Get/Set the path to a file to load as exceptions when
+                // `UseProtoPackageAsDefaultPrefix()` is `true`. An empty string means there
+                // should be no exceptions.
+                std::string PROTOC_EXPORT GetProtoPackagePrefixExceptionList();
+                void PROTOC_EXPORT SetProtoPackagePrefixExceptionList(
+                    const std::string& file_path
+                );
+
+                // Generator Prefix Validation Options (see objectivec_generator.cc for a
+                // description of each):
+                struct Options
+                {
+                    Options();
+                    std::string expected_prefixes_path;
+                    std::vector<std::string> expected_prefixes_suppressions;
+                    bool prefixes_must_be_registered;
+                    bool require_prefixes;
+                };
+
+                // Escape C++ trigraphs by escaping question marks to "\?".
+                std::string PROTOC_EXPORT EscapeTrigraphs(const std::string& to_escape);
+
+                // Remove white space from either end of a StringPiece.
+                void PROTOC_EXPORT TrimWhitespace(StringPiece* input);
+
+                // Returns true if the name requires a ns_returns_not_retained attribute applied
+                // to it.
+                bool PROTOC_EXPORT IsRetainedName(const std::string& name);
+
+                // Returns true if the name starts with "init" and will need to have special
+                // handling under ARC.
+                bool PROTOC_EXPORT IsInitName(const std::string& name);
+
+                // Gets the objc_class_prefix or the prefix made from the proto package.
+                std::string PROTOC_EXPORT FileClassPrefix(const FileDescriptor* file);
+
+                // Gets the path of the file we're going to generate (sans the .pb.h
+                // extension).  The path will be dependent on the objectivec package
+                // declared in the proto package.
+                std::string PROTOC_EXPORT FilePath(const FileDescriptor* file);
+
+                // Just like FilePath(), but without the directory part.
+                std::string PROTOC_EXPORT FilePathBasename(const FileDescriptor* file);
+
+                // Gets the name of the root class we'll generate in the file.  This class
+                // is not meant for external consumption, but instead contains helpers that
+                // the rest of the classes need
+                std::string PROTOC_EXPORT FileClassName(const FileDescriptor* file);
+
+                // These return the fully-qualified class name corresponding to the given
+                // descriptor.
+                std::string PROTOC_EXPORT ClassName(const Descriptor* descriptor);
+                std::string PROTOC_EXPORT ClassName(const Descriptor* descriptor, std::string* out_suffix_added);
+                std::string PROTOC_EXPORT EnumName(const EnumDescriptor* descriptor);
+
+                // Returns the fully-qualified name of the enum value corresponding to the
+                // the descriptor.
+                std::string PROTOC_EXPORT EnumValueName(const EnumValueDescriptor* descriptor);
+
+                // Returns the name of the enum value corresponding to the descriptor.
+                std::string PROTOC_EXPORT EnumValueShortName(const EnumValueDescriptor* descriptor);
+
+                // Reverse what an enum does.
+                std::string PROTOC_EXPORT UnCamelCaseEnumShortName(const std::string& name);
+
+                // Returns the name to use for the extension (used as the method off the file's
+                // Root class).
+                std::string PROTOC_EXPORT ExtensionMethodName(const FieldDescriptor* descriptor);
+
+                // Returns the transformed field name.
+                std::string PROTOC_EXPORT FieldName(const FieldDescriptor* field);
+                std::string PROTOC_EXPORT FieldNameCapitalized(const FieldDescriptor* field);
+
+                // Returns the transformed oneof name.
+                std::string PROTOC_EXPORT OneofEnumName(const OneofDescriptor* descriptor);
+                std::string PROTOC_EXPORT OneofName(const OneofDescriptor* descriptor);
+                std::string PROTOC_EXPORT OneofNameCapitalized(const OneofDescriptor* descriptor);
+
+                // Returns a symbol that can be used in C code to refer to an Objective C
+                // class without initializing the class.
+                std::string PROTOC_EXPORT ObjCClass(const std::string& class_name);
+
+                // Declares an Objective C class without initializing the class so that it can
+                // be refrerred to by ObjCClass.
+                std::string PROTOC_EXPORT ObjCClassDeclaration(const std::string& class_name);
+
+                inline bool HasPreservingUnknownEnumSemantics(const FileDescriptor* file)
+                {
+                    return file->syntax() == FileDescriptor::SYNTAX_PROTO3;
+                }
+
+                inline bool IsMapEntryMessage(const Descriptor* descriptor)
+                {
+                    return descriptor->options().map_entry();
+                }
+
+                // Reverse of the above.
+                std::string PROTOC_EXPORT UnCamelCaseFieldName(const std::string& name, const FieldDescriptor* field);
+
+                enum ObjectiveCType
+                {
+                    OBJECTIVECTYPE_INT32,
+                    OBJECTIVECTYPE_UINT32,
+                    OBJECTIVECTYPE_INT64,
+                    OBJECTIVECTYPE_UINT64,
+                    OBJECTIVECTYPE_FLOAT,
+                    OBJECTIVECTYPE_DOUBLE,
+                    OBJECTIVECTYPE_BOOLEAN,
+                    OBJECTIVECTYPE_STRING,
+                    OBJECTIVECTYPE_DATA,
+                    OBJECTIVECTYPE_ENUM,
+                    OBJECTIVECTYPE_MESSAGE
+                };
+
+                enum FlagType
+                {
+                    FLAGTYPE_DESCRIPTOR_INITIALIZATION,
+                    FLAGTYPE_EXTENSION,
+                    FLAGTYPE_FIELD
+                };
+
+                template<class TDescriptor>
+                std::string GetOptionalDeprecatedAttribute(const TDescriptor* descriptor, const FileDescriptor* file = NULL, bool preSpace = true, bool postNewline = false)
+                {
+                    bool isDeprecated = descriptor->options().deprecated();
+                    // The file is only passed when checking Messages & Enums, so those types
+                    // get tagged. At the moment, it doesn't seem to make sense to tag every
+                    // field or enum value with when the file is deprecated.
+                    bool isFileLevelDeprecation = false;
+                    if (!isDeprecated && file)
+                    {
+                        isFileLevelDeprecation = file->options().deprecated();
+                        isDeprecated = isFileLevelDeprecation;
+                    }
+                    if (isDeprecated)
+                    {
+                        std::string message;
+                        const FileDescriptor* sourceFile = descriptor->file();
+                        if (isFileLevelDeprecation)
+                        {
+                            message = sourceFile->name() + " is deprecated.";
+                        }
+                        else
+                        {
+                            message = descriptor->full_name() + " is deprecated (see " +
+                                      sourceFile->name() + ").";
+                        }
+
+                        std::string result = std::string("GPB_DEPRECATED_MSG(\"") + message + "\")";
+                        if (preSpace)
+                        {
+                            result.insert(0, " ");
+                        }
+                        if (postNewline)
+                        {
+                            result.append("\n");
+                        }
+                        return result;
+                    }
+                    else
+                    {
+                        return "";
+                    }
+                }
+
+                std::string PROTOC_EXPORT GetCapitalizedType(const FieldDescriptor* field);
+
+                ObjectiveCType PROTOC_EXPORT
+                    GetObjectiveCType(FieldDescriptor::Type field_type);
+
+                inline ObjectiveCType GetObjectiveCType(const FieldDescriptor* field)
+                {
+                    return GetObjectiveCType(field->type());
+                }
+
+                bool PROTOC_EXPORT IsPrimitiveType(const FieldDescriptor* field);
+                bool PROTOC_EXPORT IsReferenceType(const FieldDescriptor* field);
+
+                std::string PROTOC_EXPORT
+                    GPBGenericValueFieldName(const FieldDescriptor* field);
+                std::string PROTOC_EXPORT DefaultValue(const FieldDescriptor* field);
+                bool PROTOC_EXPORT HasNonZeroDefaultValue(const FieldDescriptor* field);
+
+                std::string PROTOC_EXPORT
+                    BuildFlagsString(const FlagType type, const std::vector<std::string>& strings);
+
+                // Builds HeaderDoc/appledoc style comments out of the comments in the .proto
+                // file.
+                std::string PROTOC_EXPORT BuildCommentsString(const SourceLocation& location, bool prefer_single_line);
+
+                // The name the commonly used by the library when built as a framework.
+                // This lines up to the name used in the CocoaPod.
+                extern PROTOC_EXPORT const char* const ProtobufLibraryFrameworkName;
+                // Returns the CPP symbol name to use as the gate for framework style imports
+                // for the given framework name to use.
+                std::string PROTOC_EXPORT
+                    ProtobufFrameworkImportSymbol(const std::string& framework_name);
+
+                // Checks if the file is one of the proto's bundled with the library.
+                bool PROTOC_EXPORT
+                    IsProtobufLibraryBundledProtoFile(const FileDescriptor* file);
+
+                // Checks the prefix for the given files and outputs any warnings as needed. If
+                // there are flat out errors, then out_error is filled in with the first error
+                // and the result is false.
+                bool PROTOC_EXPORT ValidateObjCClassPrefixes(
+                    const std::vector<const FileDescriptor*>& files,
+                    const Options& validation_options,
+                    std::string* out_error
+                );
+                // Same was the other ValidateObjCClassPrefixes() calls, but the options all
+                // come from the environment variables.
+                bool PROTOC_EXPORT ValidateObjCClassPrefixes(
+                    const std::vector<const FileDescriptor*>& files, std::string* out_error
+                );
+
+                // Generate decode data needed for ObjC's GPBDecodeTextFormatName() to transform
+                // the input into the expected output.
+                class PROTOC_EXPORT TextFormatDecodeData
+                {
+                public:
+                    TextFormatDecodeData();
+                    ~TextFormatDecodeData();
+
+                    TextFormatDecodeData(const TextFormatDecodeData&) = delete;
+                    TextFormatDecodeData& operator=(const TextFormatDecodeData&) = delete;
+
+                    void AddString(int32_t key, const std::string& input_for_decode, const std::string& desired_output);
+                    size_t num_entries() const
+                    {
+                        return entries_.size();
+                    }
+                    std::string Data() const;
+
+                    static std::string DecodeDataForString(const std::string& input_for_decode, const std::string& desired_output);
+
+                private:
+                    typedef std::pair<int32_t, std::string> DataEntry;
+                    std::vector<DataEntry> entries_;
+                };
+
+                // Helper for parsing simple files.
+                class PROTOC_EXPORT LineConsumer
+                {
+                public:
+                    LineConsumer();
+                    virtual ~LineConsumer();
+                    virtual bool ConsumeLine(const StringPiece& line, std::string* out_error) = 0;
+                };
+
+                bool PROTOC_EXPORT ParseSimpleFile(const std::string& path, LineConsumer* line_consumer, std::string* out_error);
+
+                bool PROTOC_EXPORT ParseSimpleStream(io::ZeroCopyInputStream& input_stream, const std::string& stream_name, LineConsumer* line_consumer, std::string* out_error);
+
+                // Helper class for parsing framework import mappings and generating
+                // import statements.
+                class PROTOC_EXPORT ImportWriter
+                {
+                public:
+                    ImportWriter(const std::string& generate_for_named_framework, const std::string& named_framework_to_proto_path_mappings_path, const std::string& runtime_import_prefix, bool include_wkt_imports);
+                    ~ImportWriter();
+
+                    void AddFile(const FileDescriptor* file, const std::string& header_extension);
+                    void Print(io::Printer* printer) const;
+
+                    static void PrintRuntimeImports(io::Printer* printer, const std::vector<std::string>& header_to_import, const std::string& runtime_import_prefix, bool default_cpp_symbol = false);
+
+                private:
+                    class ProtoFrameworkCollector : public LineConsumer
+                    {
+                    public:
+                        ProtoFrameworkCollector(std::map<std::string, std::string>* inout_proto_file_to_framework_name) :
+                            map_(inout_proto_file_to_framework_name)
+                        {
+                        }
+
+                        virtual bool ConsumeLine(const StringPiece& line, std::string* out_error) override;
+
+                    private:
+                        std::map<std::string, std::string>* map_;
+                    };
+
+                    void ParseFrameworkMappings();
+
+                    const std::string generate_for_named_framework_;
+                    const std::string named_framework_to_proto_path_mappings_path_;
+                    const std::string runtime_import_prefix_;
+                    const bool include_wkt_imports_;
+                    std::map<std::string, std::string> proto_file_to_framework_name_;
+                    bool need_to_parse_mapping_file_;
+
+                    std::vector<std::string> protobuf_imports_;
+                    std::vector<std::string> other_framework_imports_;
+                    std::vector<std::string> other_imports_;
+                };
+
+            }  // namespace objectivec
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/parser.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/parser.h
index d4eb763..f97e5c3 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/parser.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/parser.h
@@ -50,551 +50,484 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-class Message;
-
-namespace compiler {
-
-// Defined in this file.
-class Parser;
-class SourceLocationTable;
-
-// Implements parsing of protocol definitions (such as .proto files).
-//
-// Note that most users will be more interested in the Importer class.
-// Parser is a lower-level class which simply converts a single .proto file
-// to a FileDescriptorProto.  It does not resolve import directives or perform
-// many other kinds of validation needed to construct a complete
-// FileDescriptor.
-class PROTOBUF_EXPORT Parser {
- public:
-  Parser();
-  ~Parser();
-
-  // Parse the entire input and construct a FileDescriptorProto representing
-  // it.  Returns true if no errors occurred, false otherwise.
-  bool Parse(io::Tokenizer* input, FileDescriptorProto* file);
-
-  // Optional features:
-
-  // DEPRECATED:  New code should use the SourceCodeInfo embedded in the
-  //   FileDescriptorProto.
-  //
-  // Requests that locations of certain definitions be recorded to the given
-  // SourceLocationTable while parsing.  This can be used to look up exact line
-  // and column numbers for errors reported by DescriptorPool during validation.
-  // Set to NULL (the default) to discard source location information.
-  void RecordSourceLocationsTo(SourceLocationTable* location_table) {
-    source_location_table_ = location_table;
-  }
-
-  // Requests that errors be recorded to the given ErrorCollector while
-  // parsing.  Set to NULL (the default) to discard error messages.
-  void RecordErrorsTo(io::ErrorCollector* error_collector) {
-    error_collector_ = error_collector;
-  }
-
-  // Returns the identifier used in the "syntax = " declaration, if one was
-  // seen during the last call to Parse(), or the empty string otherwise.
-  const std::string& GetSyntaxIdentifier() { return syntax_identifier_; }
-
-  // If set true, input files will be required to begin with a syntax
-  // identifier.  Otherwise, files may omit this.  If a syntax identifier
-  // is provided, it must be 'syntax = "proto2";' and must appear at the
-  // top of this file regardless of whether or not it was required.
-  void SetRequireSyntaxIdentifier(bool value) {
-    require_syntax_identifier_ = value;
-  }
-
-  // Call SetStopAfterSyntaxIdentifier(true) to tell the parser to stop
-  // parsing as soon as it has seen the syntax identifier, or lack thereof.
-  // This is useful for quickly identifying the syntax of the file without
-  // parsing the whole thing.  If this is enabled, no error will be recorded
-  // if the syntax identifier is something other than "proto2" (since
-  // presumably the caller intends to deal with that), but other kinds of
-  // errors (e.g. parse errors) will still be reported.  When this is enabled,
-  // you may pass a NULL FileDescriptorProto to Parse().
-  void SetStopAfterSyntaxIdentifier(bool value) {
-    stop_after_syntax_identifier_ = value;
-  }
-
- private:
-  class LocationRecorder;
-  struct MapField;
-
-  // =================================================================
-  // Error recovery helpers
-
-  // Consume the rest of the current statement.  This consumes tokens
-  // until it sees one of:
-  //   ';'  Consumes the token and returns.
-  //   '{'  Consumes the brace then calls SkipRestOfBlock().
-  //   '}'  Returns without consuming.
-  //   EOF  Returns (can't consume).
-  // The Parser often calls SkipStatement() after encountering a syntax
-  // error.  This allows it to go on parsing the following lines, allowing
-  // it to report more than just one error in the file.
-  void SkipStatement();
-
-  // Consume the rest of the current block, including nested blocks,
-  // ending after the closing '}' is encountered and consumed, or at EOF.
-  void SkipRestOfBlock();
-
-  // -----------------------------------------------------------------
-  // Single-token consuming helpers
-  //
-  // These make parsing code more readable.
-
-  // True if the current token is TYPE_END.
-  inline bool AtEnd();
-
-  // True if the next token matches the given text.
-  inline bool LookingAt(const char* text);
-  // True if the next token is of the given type.
-  inline bool LookingAtType(io::Tokenizer::TokenType token_type);
-
-  // If the next token exactly matches the text given, consume it and return
-  // true.  Otherwise, return false without logging an error.
-  bool TryConsume(const char* text);
-
-  // These attempt to read some kind of token from the input.  If successful,
-  // they return true.  Otherwise they return false and add the given error
-  // to the error list.
-
-  // Consume a token with the exact text given.
-  bool Consume(const char* text, const char* error);
-  // Same as above, but automatically generates the error "Expected \"text\".",
-  // where "text" is the expected token text.
-  bool Consume(const char* text);
-  // Consume a token of type IDENTIFIER and store its text in "output".
-  bool ConsumeIdentifier(std::string* output, const char* error);
-  // Consume an integer and store its value in "output".
-  bool ConsumeInteger(int* output, const char* error);
-  // Consume a signed integer and store its value in "output".
-  bool ConsumeSignedInteger(int* output, const char* error);
-  // Consume a 64-bit integer and store its value in "output".  If the value
-  // is greater than max_value, an error will be reported.
-  bool ConsumeInteger64(uint64_t max_value, uint64_t* output,
-                        const char* error);
-  // Consume a number and store its value in "output".  This will accept
-  // tokens of either INTEGER or FLOAT type.
-  bool ConsumeNumber(double* output, const char* error);
-  // Consume a string literal and store its (unescaped) value in "output".
-  bool ConsumeString(std::string* output, const char* error);
-
-  // Consume a token representing the end of the statement.  Comments between
-  // this token and the next will be harvested for documentation.  The given
-  // LocationRecorder should refer to the declaration that was just parsed;
-  // it will be populated with these comments.
-  //
-  // TODO(kenton):  The LocationRecorder is const because historically locations
-  //   have been passed around by const reference, for no particularly good
-  //   reason.  We should probably go through and change them all to mutable
-  //   pointer to make this more intuitive.
-  bool TryConsumeEndOfDeclaration(const char* text,
-                                  const LocationRecorder* location);
-  bool TryConsumeEndOfDeclarationFinishScope(const char* text,
-                                             const LocationRecorder* location);
-
-  bool ConsumeEndOfDeclaration(const char* text,
-                               const LocationRecorder* location);
-
-  // -----------------------------------------------------------------
-  // Error logging helpers
-
-  // Invokes error_collector_->AddError(), if error_collector_ is not NULL.
-  void AddError(int line, int column, const std::string& error);
-
-  // Invokes error_collector_->AddError() with the line and column number
-  // of the current token.
-  void AddError(const std::string& error);
-
-  // Invokes error_collector_->AddWarning() with the line and column number
-  // of the current token.
-  void AddWarning(const std::string& warning);
-
-  // Records a location in the SourceCodeInfo.location table (see
-  // descriptor.proto).  We use RAII to ensure that the start and end locations
-  // are recorded -- the constructor records the start location and the
-  // destructor records the end location.  Since the parser is
-  // recursive-descent, this works out beautifully.
-  class PROTOBUF_EXPORT LocationRecorder {
-   public:
-    // Construct the file's "root" location.
-    LocationRecorder(Parser* parser);
-
-    // Construct a location that represents a declaration nested within the
-    // given parent.  E.g. a field's location is nested within the location
-    // for a message type.  The parent's path will be copied, so you should
-    // call AddPath() only to add the path components leading from the parent
-    // to the child (as opposed to leading from the root to the child).
-    LocationRecorder(const LocationRecorder& parent);
-
-    // Convenience constructors that call AddPath() one or two times.
-    LocationRecorder(const LocationRecorder& parent, int path1);
-    LocationRecorder(const LocationRecorder& parent, int path1, int path2);
-
-    // Creates a recorder that generates locations into given source code info.
-    LocationRecorder(const LocationRecorder& parent, int path1,
-                     SourceCodeInfo* source_code_info);
-
-    ~LocationRecorder();
-
-    // Add a path component.  See SourceCodeInfo.Location.path in
-    // descriptor.proto.
-    void AddPath(int path_component);
-
-    // By default the location is considered to start at the current token at
-    // the time the LocationRecorder is created.  StartAt() sets the start
-    // location to the given token instead.
-    void StartAt(const io::Tokenizer::Token& token);
-
-    // Start at the same location as some other LocationRecorder.
-    void StartAt(const LocationRecorder& other);
-
-    // By default the location is considered to end at the previous token at
-    // the time the LocationRecorder is destroyed.  EndAt() sets the end
-    // location to the given token instead.
-    void EndAt(const io::Tokenizer::Token& token);
-
-    // Records the start point of this location to the SourceLocationTable that
-    // was passed to RecordSourceLocationsTo(), if any.  SourceLocationTable
-    // is an older way of keeping track of source locations which is still
-    // used in some places.
-    void RecordLegacyLocation(
-        const Message* descriptor,
-        DescriptorPool::ErrorCollector::ErrorLocation location);
-    void RecordLegacyImportLocation(const Message* descriptor,
-                                    const std::string& name);
-
-    // Returns the number of path components in the recorder's current location.
-    int CurrentPathSize() const;
-
-    // Attaches leading and trailing comments to the location.  The two strings
-    // will be swapped into place, so after this is called *leading and
-    // *trailing will be empty.
-    //
-    // TODO(kenton):  See comment on TryConsumeEndOfDeclaration(), above, for
-    //   why this is const.
-    void AttachComments(std::string* leading, std::string* trailing,
-                        std::vector<std::string>* detached_comments) const;
-
-   private:
-    Parser* parser_;
-    SourceCodeInfo* source_code_info_;
-    SourceCodeInfo::Location* location_;
-
-    void Init(const LocationRecorder& parent, SourceCodeInfo* source_code_info);
-  };
-
-  // =================================================================
-  // Parsers for various language constructs
-
-  // Parses the "syntax = \"proto2\";" line at the top of the file.  Returns
-  // false if it failed to parse or if the syntax identifier was not
-  // recognized.
-  bool ParseSyntaxIdentifier(const LocationRecorder& parent);
-
-  // These methods parse various individual bits of code.  They return
-  // false if they completely fail to parse the construct.  In this case,
-  // it is probably necessary to skip the rest of the statement to recover.
-  // However, if these methods return true, it does NOT mean that there
-  // were no errors; only that there were no *syntax* errors.  For instance,
-  // if a service method is defined using proper syntax but uses a primitive
-  // type as its input or output, ParseMethodField() still returns true
-  // and only reports the error by calling AddError().  In practice, this
-  // makes logic much simpler for the caller.
-
-  // Parse a top-level message, enum, service, etc.
-  bool ParseTopLevelStatement(FileDescriptorProto* file,
-                              const LocationRecorder& root_location);
-
-  // Parse various language high-level language construrcts.
-  bool ParseMessageDefinition(DescriptorProto* message,
-                              const LocationRecorder& message_location,
-                              const FileDescriptorProto* containing_file);
-  bool ParseEnumDefinition(EnumDescriptorProto* enum_type,
-                           const LocationRecorder& enum_location,
-                           const FileDescriptorProto* containing_file);
-  bool ParseServiceDefinition(ServiceDescriptorProto* service,
-                              const LocationRecorder& service_location,
-                              const FileDescriptorProto* containing_file);
-  bool ParsePackage(FileDescriptorProto* file,
-                    const LocationRecorder& root_location,
-                    const FileDescriptorProto* containing_file);
-  bool ParseImport(RepeatedPtrField<std::string>* dependency,
-                   RepeatedField<int32_t>* public_dependency,
-                   RepeatedField<int32_t>* weak_dependency,
-                   const LocationRecorder& root_location,
-                   const FileDescriptorProto* containing_file);
-
-  // These methods parse the contents of a message, enum, or service type and
-  // add them to the given object.  They consume the entire block including
-  // the beginning and ending brace.
-  bool ParseMessageBlock(DescriptorProto* message,
-                         const LocationRecorder& message_location,
-                         const FileDescriptorProto* containing_file);
-  bool ParseEnumBlock(EnumDescriptorProto* enum_type,
-                      const LocationRecorder& enum_location,
-                      const FileDescriptorProto* containing_file);
-  bool ParseServiceBlock(ServiceDescriptorProto* service,
-                         const LocationRecorder& service_location,
-                         const FileDescriptorProto* containing_file);
-
-  // Parse one statement within a message, enum, or service block, including
-  // final semicolon.
-  bool ParseMessageStatement(DescriptorProto* message,
-                             const LocationRecorder& message_location,
-                             const FileDescriptorProto* containing_file);
-  bool ParseEnumStatement(EnumDescriptorProto* message,
-                          const LocationRecorder& enum_location,
-                          const FileDescriptorProto* containing_file);
-  bool ParseServiceStatement(ServiceDescriptorProto* message,
-                             const LocationRecorder& service_location,
-                             const FileDescriptorProto* containing_file);
-
-  // Parse a field of a message.  If the field is a group, its type will be
-  // added to "messages".
-  //
-  // parent_location and location_field_number_for_nested_type are needed when
-  // parsing groups -- we need to generate a nested message type within the
-  // parent and record its location accordingly.  Since the parent could be
-  // either a FileDescriptorProto or a DescriptorProto, we must pass in the
-  // correct field number to use.
-  bool ParseMessageField(FieldDescriptorProto* field,
-                         RepeatedPtrField<DescriptorProto>* messages,
-                         const LocationRecorder& parent_location,
-                         int location_field_number_for_nested_type,
-                         const LocationRecorder& field_location,
-                         const FileDescriptorProto* containing_file);
-
-  // Like ParseMessageField() but expects the label has already been filled in
-  // by the caller.
-  bool ParseMessageFieldNoLabel(FieldDescriptorProto* field,
-                                RepeatedPtrField<DescriptorProto>* messages,
-                                const LocationRecorder& parent_location,
-                                int location_field_number_for_nested_type,
-                                const LocationRecorder& field_location,
-                                const FileDescriptorProto* containing_file);
-
-  bool ParseMapType(MapField* map_field, FieldDescriptorProto* field,
-                    LocationRecorder& type_name_location);
-
-  // Parse an "extensions" declaration.
-  bool ParseExtensions(DescriptorProto* message,
-                       const LocationRecorder& extensions_location,
-                       const FileDescriptorProto* containing_file);
-
-  // Parse a "reserved" declaration.
-  bool ParseReserved(DescriptorProto* message,
-                     const LocationRecorder& message_location);
-  bool ParseReservedNames(DescriptorProto* message,
-                          const LocationRecorder& parent_location);
-  bool ParseReservedNumbers(DescriptorProto* message,
-                            const LocationRecorder& parent_location);
-  bool ParseReserved(EnumDescriptorProto* message,
-                     const LocationRecorder& message_location);
-  bool ParseReservedNames(EnumDescriptorProto* message,
-                          const LocationRecorder& parent_location);
-  bool ParseReservedNumbers(EnumDescriptorProto* message,
-                            const LocationRecorder& parent_location);
-
-  // Parse an "extend" declaration.  (See also comments for
-  // ParseMessageField().)
-  bool ParseExtend(RepeatedPtrField<FieldDescriptorProto>* extensions,
-                   RepeatedPtrField<DescriptorProto>* messages,
-                   const LocationRecorder& parent_location,
-                   int location_field_number_for_nested_type,
-                   const LocationRecorder& extend_location,
-                   const FileDescriptorProto* containing_file);
-
-  // Parse a "oneof" declaration.  The caller is responsible for setting
-  // oneof_decl->label() since it will have had to parse the label before it
-  // knew it was parsing a oneof.
-  bool ParseOneof(OneofDescriptorProto* oneof_decl,
-                  DescriptorProto* containing_type, int oneof_index,
-                  const LocationRecorder& oneof_location,
-                  const LocationRecorder& containing_type_location,
-                  const FileDescriptorProto* containing_file);
-
-  // Parse a single enum value within an enum block.
-  bool ParseEnumConstant(EnumValueDescriptorProto* enum_value,
-                         const LocationRecorder& enum_value_location,
-                         const FileDescriptorProto* containing_file);
-
-  // Parse enum constant options, i.e. the list in square brackets at the end
-  // of the enum constant value definition.
-  bool ParseEnumConstantOptions(EnumValueDescriptorProto* value,
-                                const LocationRecorder& enum_value_location,
-                                const FileDescriptorProto* containing_file);
-
-  // Parse a single method within a service definition.
-  bool ParseServiceMethod(MethodDescriptorProto* method,
-                          const LocationRecorder& method_location,
-                          const FileDescriptorProto* containing_file);
-
-  // Parse options of a single method or stream.
-  bool ParseMethodOptions(const LocationRecorder& parent_location,
-                          const FileDescriptorProto* containing_file,
-                          const int optionsFieldNumber,
-                          Message* mutable_options);
-
-  // Parse "required", "optional", or "repeated" and fill in "label"
-  // with the value. Returns true if such a label is consumed.
-  bool ParseLabel(FieldDescriptorProto::Label* label,
-                  const LocationRecorder& field_location);
-
-  // Parse a type name and fill in "type" (if it is a primitive) or
-  // "type_name" (if it is not) with the type parsed.
-  bool ParseType(FieldDescriptorProto::Type* type, std::string* type_name);
-  // Parse a user-defined type and fill in "type_name" with the name.
-  // If a primitive type is named, it is treated as an error.
-  bool ParseUserDefinedType(std::string* type_name);
-
-  // Parses field options, i.e. the stuff in square brackets at the end
-  // of a field definition.  Also parses default value.
-  bool ParseFieldOptions(FieldDescriptorProto* field,
-                         const LocationRecorder& field_location,
-                         const FileDescriptorProto* containing_file);
-
-  // Parse the "default" option.  This needs special handling because its
-  // type is the field's type.
-  bool ParseDefaultAssignment(FieldDescriptorProto* field,
-                              const LocationRecorder& field_location,
-                              const FileDescriptorProto* containing_file);
-
-  bool ParseJsonName(FieldDescriptorProto* field,
-                     const LocationRecorder& field_location,
-                     const FileDescriptorProto* containing_file);
-
-  enum OptionStyle {
-    OPTION_ASSIGNMENT,  // just "name = value"
-    OPTION_STATEMENT    // "option name = value;"
-  };
-
-  // Parse a single option name/value pair, e.g. "ctype = CORD".  The name
-  // identifies a field of the given Message, and the value of that field
-  // is set to the parsed value.
-  bool ParseOption(Message* options, const LocationRecorder& options_location,
-                   const FileDescriptorProto* containing_file,
-                   OptionStyle style);
-
-  // Parses a single part of a multipart option name. A multipart name consists
-  // of names separated by dots. Each name is either an identifier or a series
-  // of identifiers separated by dots and enclosed in parentheses. E.g.,
-  // "foo.(bar.baz).moo".
-  bool ParseOptionNamePart(UninterpretedOption* uninterpreted_option,
-                           const LocationRecorder& part_location,
-                           const FileDescriptorProto* containing_file);
-
-  // Parses a string surrounded by balanced braces.  Strips off the outer
-  // braces and stores the enclosed string in *value.
-  // E.g.,
-  //     { foo }                     *value gets 'foo'
-  //     { foo { bar: box } }        *value gets 'foo { bar: box }'
-  //     {}                          *value gets ''
-  //
-  // REQUIRES: LookingAt("{")
-  // When finished successfully, we are looking at the first token past
-  // the ending brace.
-  bool ParseUninterpretedBlock(std::string* value);
-
-  struct MapField {
-    // Whether the field is a map field.
-    bool is_map_field;
-    // The types of the key and value if they are primitive types.
-    FieldDescriptorProto::Type key_type;
-    FieldDescriptorProto::Type value_type;
-    // Or the type names string if the types are customized types.
-    std::string key_type_name;
-    std::string value_type_name;
-
-    MapField() : is_map_field(false) {}
-  };
-  // Desugar the map syntax to generate a nested map entry message.
-  void GenerateMapEntry(const MapField& map_field, FieldDescriptorProto* field,
-                        RepeatedPtrField<DescriptorProto>* messages);
-
-  // Whether fields without label default to optional fields.
-  bool DefaultToOptionalFields() const {
-    return syntax_identifier_ == "proto3";
-  }
-
-  bool ValidateEnum(const EnumDescriptorProto* proto);
-
-  // =================================================================
-
-  io::Tokenizer* input_;
-  io::ErrorCollector* error_collector_;
-  SourceCodeInfo* source_code_info_;
-  SourceLocationTable* source_location_table_;  // legacy
-  bool had_errors_;
-  bool require_syntax_identifier_;
-  bool stop_after_syntax_identifier_;
-  std::string syntax_identifier_;
-
-  // Leading doc comments for the next declaration.  These are not complete
-  // yet; use ConsumeEndOfDeclaration() to get the complete comments.
-  std::string upcoming_doc_comments_;
-
-  // Detached comments are not connected to any syntax entities. Elements in
-  // this vector are paragraphs of comments separated by empty lines. The
-  // detached comments will be put into the leading_detached_comments field for
-  // the next element (See SourceCodeInfo.Location in descriptor.proto), when
-  // ConsumeEndOfDeclaration() is called.
-  std::vector<std::string> upcoming_detached_comments_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Parser);
-};
-
-// A table mapping (descriptor, ErrorLocation) pairs -- as reported by
-// DescriptorPool when validating descriptors -- to line and column numbers
-// within the original source code.
-//
-// This is semi-obsolete:  FileDescriptorProto.source_code_info now contains
-// far more complete information about source locations.  However, as of this
-// writing you still need to use SourceLocationTable when integrating with
-// DescriptorPool.
-class PROTOBUF_EXPORT SourceLocationTable {
- public:
-  SourceLocationTable();
-  ~SourceLocationTable();
-
-  // Finds the precise location of the given error and fills in *line and
-  // *column with the line and column numbers.  If not found, sets *line to
-  // -1 and *column to 0 (since line = -1 is used to mean "error has no exact
-  // location" in the ErrorCollector interface).  Returns true if found, false
-  // otherwise.
-  bool Find(const Message* descriptor,
-            DescriptorPool::ErrorCollector::ErrorLocation location, int* line,
-            int* column) const;
-  bool FindImport(const Message* descriptor, const std::string& name, int* line,
-                  int* column) const;
-
-  // Adds a location to the table.
-  void Add(const Message* descriptor,
-           DescriptorPool::ErrorCollector::ErrorLocation location, int line,
-           int column);
-  void AddImport(const Message* descriptor, const std::string& name, int line,
-                 int column);
-
-  // Clears the contents of the table.
-  void Clear();
-
- private:
-  typedef std::map<
-      std::pair<const Message*, DescriptorPool::ErrorCollector::ErrorLocation>,
-      std::pair<int, int> >
-      LocationMap;
-  LocationMap location_map_;
-  std::map<std::pair<const Message*, std::string>, std::pair<int, int> >
-      import_location_map_;
-};
-
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Message;
+
+        namespace compiler
+        {
+
+            // Defined in this file.
+            class Parser;
+            class SourceLocationTable;
+
+            // Implements parsing of protocol definitions (such as .proto files).
+            //
+            // Note that most users will be more interested in the Importer class.
+            // Parser is a lower-level class which simply converts a single .proto file
+            // to a FileDescriptorProto.  It does not resolve import directives or perform
+            // many other kinds of validation needed to construct a complete
+            // FileDescriptor.
+            class PROTOBUF_EXPORT Parser
+            {
+            public:
+                Parser();
+                ~Parser();
+
+                // Parse the entire input and construct a FileDescriptorProto representing
+                // it.  Returns true if no errors occurred, false otherwise.
+                bool Parse(io::Tokenizer* input, FileDescriptorProto* file);
+
+                // Optional features:
+
+                // DEPRECATED:  New code should use the SourceCodeInfo embedded in the
+                //   FileDescriptorProto.
+                //
+                // Requests that locations of certain definitions be recorded to the given
+                // SourceLocationTable while parsing.  This can be used to look up exact line
+                // and column numbers for errors reported by DescriptorPool during validation.
+                // Set to NULL (the default) to discard source location information.
+                void RecordSourceLocationsTo(SourceLocationTable* location_table)
+                {
+                    source_location_table_ = location_table;
+                }
+
+                // Requests that errors be recorded to the given ErrorCollector while
+                // parsing.  Set to NULL (the default) to discard error messages.
+                void RecordErrorsTo(io::ErrorCollector* error_collector)
+                {
+                    error_collector_ = error_collector;
+                }
+
+                // Returns the identifier used in the "syntax = " declaration, if one was
+                // seen during the last call to Parse(), or the empty string otherwise.
+                const std::string& GetSyntaxIdentifier()
+                {
+                    return syntax_identifier_;
+                }
+
+                // If set true, input files will be required to begin with a syntax
+                // identifier.  Otherwise, files may omit this.  If a syntax identifier
+                // is provided, it must be 'syntax = "proto2";' and must appear at the
+                // top of this file regardless of whether or not it was required.
+                void SetRequireSyntaxIdentifier(bool value)
+                {
+                    require_syntax_identifier_ = value;
+                }
+
+                // Call SetStopAfterSyntaxIdentifier(true) to tell the parser to stop
+                // parsing as soon as it has seen the syntax identifier, or lack thereof.
+                // This is useful for quickly identifying the syntax of the file without
+                // parsing the whole thing.  If this is enabled, no error will be recorded
+                // if the syntax identifier is something other than "proto2" (since
+                // presumably the caller intends to deal with that), but other kinds of
+                // errors (e.g. parse errors) will still be reported.  When this is enabled,
+                // you may pass a NULL FileDescriptorProto to Parse().
+                void SetStopAfterSyntaxIdentifier(bool value)
+                {
+                    stop_after_syntax_identifier_ = value;
+                }
+
+            private:
+                class LocationRecorder;
+                struct MapField;
+
+                // =================================================================
+                // Error recovery helpers
+
+                // Consume the rest of the current statement.  This consumes tokens
+                // until it sees one of:
+                //   ';'  Consumes the token and returns.
+                //   '{'  Consumes the brace then calls SkipRestOfBlock().
+                //   '}'  Returns without consuming.
+                //   EOF  Returns (can't consume).
+                // The Parser often calls SkipStatement() after encountering a syntax
+                // error.  This allows it to go on parsing the following lines, allowing
+                // it to report more than just one error in the file.
+                void SkipStatement();
+
+                // Consume the rest of the current block, including nested blocks,
+                // ending after the closing '}' is encountered and consumed, or at EOF.
+                void SkipRestOfBlock();
+
+                // -----------------------------------------------------------------
+                // Single-token consuming helpers
+                //
+                // These make parsing code more readable.
+
+                // True if the current token is TYPE_END.
+                inline bool AtEnd();
+
+                // True if the next token matches the given text.
+                inline bool LookingAt(const char* text);
+                // True if the next token is of the given type.
+                inline bool LookingAtType(io::Tokenizer::TokenType token_type);
+
+                // If the next token exactly matches the text given, consume it and return
+                // true.  Otherwise, return false without logging an error.
+                bool TryConsume(const char* text);
+
+                // These attempt to read some kind of token from the input.  If successful,
+                // they return true.  Otherwise they return false and add the given error
+                // to the error list.
+
+                // Consume a token with the exact text given.
+                bool Consume(const char* text, const char* error);
+                // Same as above, but automatically generates the error "Expected \"text\".",
+                // where "text" is the expected token text.
+                bool Consume(const char* text);
+                // Consume a token of type IDENTIFIER and store its text in "output".
+                bool ConsumeIdentifier(std::string* output, const char* error);
+                // Consume an integer and store its value in "output".
+                bool ConsumeInteger(int* output, const char* error);
+                // Consume a signed integer and store its value in "output".
+                bool ConsumeSignedInteger(int* output, const char* error);
+                // Consume a 64-bit integer and store its value in "output".  If the value
+                // is greater than max_value, an error will be reported.
+                bool ConsumeInteger64(uint64_t max_value, uint64_t* output, const char* error);
+                // Consume a number and store its value in "output".  This will accept
+                // tokens of either INTEGER or FLOAT type.
+                bool ConsumeNumber(double* output, const char* error);
+                // Consume a string literal and store its (unescaped) value in "output".
+                bool ConsumeString(std::string* output, const char* error);
+
+                // Consume a token representing the end of the statement.  Comments between
+                // this token and the next will be harvested for documentation.  The given
+                // LocationRecorder should refer to the declaration that was just parsed;
+                // it will be populated with these comments.
+                //
+                // TODO(kenton):  The LocationRecorder is const because historically locations
+                //   have been passed around by const reference, for no particularly good
+                //   reason.  We should probably go through and change them all to mutable
+                //   pointer to make this more intuitive.
+                bool TryConsumeEndOfDeclaration(const char* text, const LocationRecorder* location);
+                bool TryConsumeEndOfDeclarationFinishScope(const char* text, const LocationRecorder* location);
+
+                bool ConsumeEndOfDeclaration(const char* text, const LocationRecorder* location);
+
+                // -----------------------------------------------------------------
+                // Error logging helpers
+
+                // Invokes error_collector_->AddError(), if error_collector_ is not NULL.
+                void AddError(int line, int column, const std::string& error);
+
+                // Invokes error_collector_->AddError() with the line and column number
+                // of the current token.
+                void AddError(const std::string& error);
+
+                // Invokes error_collector_->AddWarning() with the line and column number
+                // of the current token.
+                void AddWarning(const std::string& warning);
+
+                // Records a location in the SourceCodeInfo.location table (see
+                // descriptor.proto).  We use RAII to ensure that the start and end locations
+                // are recorded -- the constructor records the start location and the
+                // destructor records the end location.  Since the parser is
+                // recursive-descent, this works out beautifully.
+                class PROTOBUF_EXPORT LocationRecorder
+                {
+                public:
+                    // Construct the file's "root" location.
+                    LocationRecorder(Parser* parser);
+
+                    // Construct a location that represents a declaration nested within the
+                    // given parent.  E.g. a field's location is nested within the location
+                    // for a message type.  The parent's path will be copied, so you should
+                    // call AddPath() only to add the path components leading from the parent
+                    // to the child (as opposed to leading from the root to the child).
+                    LocationRecorder(const LocationRecorder& parent);
+
+                    // Convenience constructors that call AddPath() one or two times.
+                    LocationRecorder(const LocationRecorder& parent, int path1);
+                    LocationRecorder(const LocationRecorder& parent, int path1, int path2);
+
+                    // Creates a recorder that generates locations into given source code info.
+                    LocationRecorder(const LocationRecorder& parent, int path1, SourceCodeInfo* source_code_info);
+
+                    ~LocationRecorder();
+
+                    // Add a path component.  See SourceCodeInfo.Location.path in
+                    // descriptor.proto.
+                    void AddPath(int path_component);
+
+                    // By default the location is considered to start at the current token at
+                    // the time the LocationRecorder is created.  StartAt() sets the start
+                    // location to the given token instead.
+                    void StartAt(const io::Tokenizer::Token& token);
+
+                    // Start at the same location as some other LocationRecorder.
+                    void StartAt(const LocationRecorder& other);
+
+                    // By default the location is considered to end at the previous token at
+                    // the time the LocationRecorder is destroyed.  EndAt() sets the end
+                    // location to the given token instead.
+                    void EndAt(const io::Tokenizer::Token& token);
+
+                    // Records the start point of this location to the SourceLocationTable that
+                    // was passed to RecordSourceLocationsTo(), if any.  SourceLocationTable
+                    // is an older way of keeping track of source locations which is still
+                    // used in some places.
+                    void RecordLegacyLocation(
+                        const Message* descriptor,
+                        DescriptorPool::ErrorCollector::ErrorLocation location
+                    );
+                    void RecordLegacyImportLocation(const Message* descriptor, const std::string& name);
+
+                    // Returns the number of path components in the recorder's current location.
+                    int CurrentPathSize() const;
+
+                    // Attaches leading and trailing comments to the location.  The two strings
+                    // will be swapped into place, so after this is called *leading and
+                    // *trailing will be empty.
+                    //
+                    // TODO(kenton):  See comment on TryConsumeEndOfDeclaration(), above, for
+                    //   why this is const.
+                    void AttachComments(std::string* leading, std::string* trailing, std::vector<std::string>* detached_comments) const;
+
+                private:
+                    Parser* parser_;
+                    SourceCodeInfo* source_code_info_;
+                    SourceCodeInfo::Location* location_;
+
+                    void Init(const LocationRecorder& parent, SourceCodeInfo* source_code_info);
+                };
+
+                // =================================================================
+                // Parsers for various language constructs
+
+                // Parses the "syntax = \"proto2\";" line at the top of the file.  Returns
+                // false if it failed to parse or if the syntax identifier was not
+                // recognized.
+                bool ParseSyntaxIdentifier(const LocationRecorder& parent);
+
+                // These methods parse various individual bits of code.  They return
+                // false if they completely fail to parse the construct.  In this case,
+                // it is probably necessary to skip the rest of the statement to recover.
+                // However, if these methods return true, it does NOT mean that there
+                // were no errors; only that there were no *syntax* errors.  For instance,
+                // if a service method is defined using proper syntax but uses a primitive
+                // type as its input or output, ParseMethodField() still returns true
+                // and only reports the error by calling AddError().  In practice, this
+                // makes logic much simpler for the caller.
+
+                // Parse a top-level message, enum, service, etc.
+                bool ParseTopLevelStatement(FileDescriptorProto* file, const LocationRecorder& root_location);
+
+                // Parse various language high-level language construrcts.
+                bool ParseMessageDefinition(DescriptorProto* message, const LocationRecorder& message_location, const FileDescriptorProto* containing_file);
+                bool ParseEnumDefinition(EnumDescriptorProto* enum_type, const LocationRecorder& enum_location, const FileDescriptorProto* containing_file);
+                bool ParseServiceDefinition(ServiceDescriptorProto* service, const LocationRecorder& service_location, const FileDescriptorProto* containing_file);
+                bool ParsePackage(FileDescriptorProto* file, const LocationRecorder& root_location, const FileDescriptorProto* containing_file);
+                bool ParseImport(RepeatedPtrField<std::string>* dependency, RepeatedField<int32_t>* public_dependency, RepeatedField<int32_t>* weak_dependency, const LocationRecorder& root_location, const FileDescriptorProto* containing_file);
+
+                // These methods parse the contents of a message, enum, or service type and
+                // add them to the given object.  They consume the entire block including
+                // the beginning and ending brace.
+                bool ParseMessageBlock(DescriptorProto* message, const LocationRecorder& message_location, const FileDescriptorProto* containing_file);
+                bool ParseEnumBlock(EnumDescriptorProto* enum_type, const LocationRecorder& enum_location, const FileDescriptorProto* containing_file);
+                bool ParseServiceBlock(ServiceDescriptorProto* service, const LocationRecorder& service_location, const FileDescriptorProto* containing_file);
+
+                // Parse one statement within a message, enum, or service block, including
+                // final semicolon.
+                bool ParseMessageStatement(DescriptorProto* message, const LocationRecorder& message_location, const FileDescriptorProto* containing_file);
+                bool ParseEnumStatement(EnumDescriptorProto* message, const LocationRecorder& enum_location, const FileDescriptorProto* containing_file);
+                bool ParseServiceStatement(ServiceDescriptorProto* message, const LocationRecorder& service_location, const FileDescriptorProto* containing_file);
+
+                // Parse a field of a message.  If the field is a group, its type will be
+                // added to "messages".
+                //
+                // parent_location and location_field_number_for_nested_type are needed when
+                // parsing groups -- we need to generate a nested message type within the
+                // parent and record its location accordingly.  Since the parent could be
+                // either a FileDescriptorProto or a DescriptorProto, we must pass in the
+                // correct field number to use.
+                bool ParseMessageField(FieldDescriptorProto* field, RepeatedPtrField<DescriptorProto>* messages, const LocationRecorder& parent_location, int location_field_number_for_nested_type, const LocationRecorder& field_location, const FileDescriptorProto* containing_file);
+
+                // Like ParseMessageField() but expects the label has already been filled in
+                // by the caller.
+                bool ParseMessageFieldNoLabel(FieldDescriptorProto* field, RepeatedPtrField<DescriptorProto>* messages, const LocationRecorder& parent_location, int location_field_number_for_nested_type, const LocationRecorder& field_location, const FileDescriptorProto* containing_file);
+
+                bool ParseMapType(MapField* map_field, FieldDescriptorProto* field, LocationRecorder& type_name_location);
+
+                // Parse an "extensions" declaration.
+                bool ParseExtensions(DescriptorProto* message, const LocationRecorder& extensions_location, const FileDescriptorProto* containing_file);
+
+                // Parse a "reserved" declaration.
+                bool ParseReserved(DescriptorProto* message, const LocationRecorder& message_location);
+                bool ParseReservedNames(DescriptorProto* message, const LocationRecorder& parent_location);
+                bool ParseReservedNumbers(DescriptorProto* message, const LocationRecorder& parent_location);
+                bool ParseReserved(EnumDescriptorProto* message, const LocationRecorder& message_location);
+                bool ParseReservedNames(EnumDescriptorProto* message, const LocationRecorder& parent_location);
+                bool ParseReservedNumbers(EnumDescriptorProto* message, const LocationRecorder& parent_location);
+
+                // Parse an "extend" declaration.  (See also comments for
+                // ParseMessageField().)
+                bool ParseExtend(RepeatedPtrField<FieldDescriptorProto>* extensions, RepeatedPtrField<DescriptorProto>* messages, const LocationRecorder& parent_location, int location_field_number_for_nested_type, const LocationRecorder& extend_location, const FileDescriptorProto* containing_file);
+
+                // Parse a "oneof" declaration.  The caller is responsible for setting
+                // oneof_decl->label() since it will have had to parse the label before it
+                // knew it was parsing a oneof.
+                bool ParseOneof(OneofDescriptorProto* oneof_decl, DescriptorProto* containing_type, int oneof_index, const LocationRecorder& oneof_location, const LocationRecorder& containing_type_location, const FileDescriptorProto* containing_file);
+
+                // Parse a single enum value within an enum block.
+                bool ParseEnumConstant(EnumValueDescriptorProto* enum_value, const LocationRecorder& enum_value_location, const FileDescriptorProto* containing_file);
+
+                // Parse enum constant options, i.e. the list in square brackets at the end
+                // of the enum constant value definition.
+                bool ParseEnumConstantOptions(EnumValueDescriptorProto* value, const LocationRecorder& enum_value_location, const FileDescriptorProto* containing_file);
+
+                // Parse a single method within a service definition.
+                bool ParseServiceMethod(MethodDescriptorProto* method, const LocationRecorder& method_location, const FileDescriptorProto* containing_file);
+
+                // Parse options of a single method or stream.
+                bool ParseMethodOptions(const LocationRecorder& parent_location, const FileDescriptorProto* containing_file, const int optionsFieldNumber, Message* mutable_options);
+
+                // Parse "required", "optional", or "repeated" and fill in "label"
+                // with the value. Returns true if such a label is consumed.
+                bool ParseLabel(FieldDescriptorProto::Label* label, const LocationRecorder& field_location);
+
+                // Parse a type name and fill in "type" (if it is a primitive) or
+                // "type_name" (if it is not) with the type parsed.
+                bool ParseType(FieldDescriptorProto::Type* type, std::string* type_name);
+                // Parse a user-defined type and fill in "type_name" with the name.
+                // If a primitive type is named, it is treated as an error.
+                bool ParseUserDefinedType(std::string* type_name);
+
+                // Parses field options, i.e. the stuff in square brackets at the end
+                // of a field definition.  Also parses default value.
+                bool ParseFieldOptions(FieldDescriptorProto* field, const LocationRecorder& field_location, const FileDescriptorProto* containing_file);
+
+                // Parse the "default" option.  This needs special handling because its
+                // type is the field's type.
+                bool ParseDefaultAssignment(FieldDescriptorProto* field, const LocationRecorder& field_location, const FileDescriptorProto* containing_file);
+
+                bool ParseJsonName(FieldDescriptorProto* field, const LocationRecorder& field_location, const FileDescriptorProto* containing_file);
+
+                enum OptionStyle
+                {
+                    OPTION_ASSIGNMENT,  // just "name = value"
+                    OPTION_STATEMENT    // "option name = value;"
+                };
+
+                // Parse a single option name/value pair, e.g. "ctype = CORD".  The name
+                // identifies a field of the given Message, and the value of that field
+                // is set to the parsed value.
+                bool ParseOption(Message* options, const LocationRecorder& options_location, const FileDescriptorProto* containing_file, OptionStyle style);
+
+                // Parses a single part of a multipart option name. A multipart name consists
+                // of names separated by dots. Each name is either an identifier or a series
+                // of identifiers separated by dots and enclosed in parentheses. E.g.,
+                // "foo.(bar.baz).moo".
+                bool ParseOptionNamePart(UninterpretedOption* uninterpreted_option, const LocationRecorder& part_location, const FileDescriptorProto* containing_file);
+
+                // Parses a string surrounded by balanced braces.  Strips off the outer
+                // braces and stores the enclosed string in *value.
+                // E.g.,
+                //     { foo }                     *value gets 'foo'
+                //     { foo { bar: box } }        *value gets 'foo { bar: box }'
+                //     {}                          *value gets ''
+                //
+                // REQUIRES: LookingAt("{")
+                // When finished successfully, we are looking at the first token past
+                // the ending brace.
+                bool ParseUninterpretedBlock(std::string* value);
+
+                struct MapField
+                {
+                    // Whether the field is a map field.
+                    bool is_map_field;
+                    // The types of the key and value if they are primitive types.
+                    FieldDescriptorProto::Type key_type;
+                    FieldDescriptorProto::Type value_type;
+                    // Or the type names string if the types are customized types.
+                    std::string key_type_name;
+                    std::string value_type_name;
+
+                    MapField() :
+                        is_map_field(false)
+                    {
+                    }
+                };
+                // Desugar the map syntax to generate a nested map entry message.
+                void GenerateMapEntry(const MapField& map_field, FieldDescriptorProto* field, RepeatedPtrField<DescriptorProto>* messages);
+
+                // Whether fields without label default to optional fields.
+                bool DefaultToOptionalFields() const
+                {
+                    return syntax_identifier_ == "proto3";
+                }
+
+                bool ValidateEnum(const EnumDescriptorProto* proto);
+
+                // =================================================================
+
+                io::Tokenizer* input_;
+                io::ErrorCollector* error_collector_;
+                SourceCodeInfo* source_code_info_;
+                SourceLocationTable* source_location_table_;  // legacy
+                bool had_errors_;
+                bool require_syntax_identifier_;
+                bool stop_after_syntax_identifier_;
+                std::string syntax_identifier_;
+
+                // Leading doc comments for the next declaration.  These are not complete
+                // yet; use ConsumeEndOfDeclaration() to get the complete comments.
+                std::string upcoming_doc_comments_;
+
+                // Detached comments are not connected to any syntax entities. Elements in
+                // this vector are paragraphs of comments separated by empty lines. The
+                // detached comments will be put into the leading_detached_comments field for
+                // the next element (See SourceCodeInfo.Location in descriptor.proto), when
+                // ConsumeEndOfDeclaration() is called.
+                std::vector<std::string> upcoming_detached_comments_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Parser);
+            };
+
+            // A table mapping (descriptor, ErrorLocation) pairs -- as reported by
+            // DescriptorPool when validating descriptors -- to line and column numbers
+            // within the original source code.
+            //
+            // This is semi-obsolete:  FileDescriptorProto.source_code_info now contains
+            // far more complete information about source locations.  However, as of this
+            // writing you still need to use SourceLocationTable when integrating with
+            // DescriptorPool.
+            class PROTOBUF_EXPORT SourceLocationTable
+            {
+            public:
+                SourceLocationTable();
+                ~SourceLocationTable();
+
+                // Finds the precise location of the given error and fills in *line and
+                // *column with the line and column numbers.  If not found, sets *line to
+                // -1 and *column to 0 (since line = -1 is used to mean "error has no exact
+                // location" in the ErrorCollector interface).  Returns true if found, false
+                // otherwise.
+                bool Find(const Message* descriptor, DescriptorPool::ErrorCollector::ErrorLocation location, int* line, int* column) const;
+                bool FindImport(const Message* descriptor, const std::string& name, int* line, int* column) const;
+
+                // Adds a location to the table.
+                void Add(const Message* descriptor, DescriptorPool::ErrorCollector::ErrorLocation location, int line, int column);
+                void AddImport(const Message* descriptor, const std::string& name, int line, int column);
+
+                // Clears the contents of the table.
+                void Clear();
+
+            private:
+                typedef std::map<
+                    std::pair<const Message*, DescriptorPool::ErrorCollector::ErrorLocation>,
+                    std::pair<int, int>>
+                    LocationMap;
+                LocationMap location_map_;
+                std::map<std::pair<const Message*, std::string>, std::pair<int, int>>
+                    import_location_map_;
+            };
+
+        }  // namespace compiler
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/php/php_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/php/php_generator.h
index 17cb59c..74d8088 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/php/php_generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/php/php_generator.h
@@ -38,53 +38,59 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace php {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace php
+            {
 
-struct Options;
+                struct Options;
 
-class PROTOC_EXPORT Generator : public CodeGenerator {
- public:
-  virtual bool Generate(
-      const FileDescriptor* file,
-      const std::string& parameter,
-      GeneratorContext* generator_context,
-      std::string* error) const override;
+                class PROTOC_EXPORT Generator : public CodeGenerator
+                {
+                public:
+                    virtual bool Generate(
+                        const FileDescriptor* file,
+                        const std::string& parameter,
+                        GeneratorContext* generator_context,
+                        std::string* error
+                    ) const override;
 
-  bool GenerateAll(const std::vector<const FileDescriptor*>& files,
-                   const std::string& parameter,
-                   GeneratorContext* generator_context,
-                   std::string* error) const override;
+                    bool GenerateAll(const std::vector<const FileDescriptor*>& files, const std::string& parameter, GeneratorContext* generator_context, std::string* error) const override;
 
-  uint64_t GetSupportedFeatures() const override {
-    return FEATURE_PROTO3_OPTIONAL;
-  }
+                    uint64_t GetSupportedFeatures() const override
+                    {
+                        return FEATURE_PROTO3_OPTIONAL;
+                    }
 
- private:
-  bool Generate(
-      const FileDescriptor* file,
-      const Options& options,
-      GeneratorContext* generator_context,
-      std::string* error) const;
-};
+                private:
+                    bool Generate(
+                        const FileDescriptor* file,
+                        const Options& options,
+                        GeneratorContext* generator_context,
+                        std::string* error
+                    ) const;
+                };
 
-// To skip reserved keywords in php, some generated classname are prefixed.
-// Other code generators may need following API to figure out the actual
-// classname.
-PROTOC_EXPORT std::string GeneratedClassName(const Descriptor* desc);
-PROTOC_EXPORT std::string GeneratedClassName(const EnumDescriptor* desc);
-PROTOC_EXPORT std::string GeneratedClassName(const ServiceDescriptor* desc);
+                // To skip reserved keywords in php, some generated classname are prefixed.
+                // Other code generators may need following API to figure out the actual
+                // classname.
+                PROTOC_EXPORT std::string GeneratedClassName(const Descriptor* desc);
+                PROTOC_EXPORT std::string GeneratedClassName(const EnumDescriptor* desc);
+                PROTOC_EXPORT std::string GeneratedClassName(const ServiceDescriptor* desc);
 
-inline bool IsWrapperType(const FieldDescriptor* descriptor) {
-  return descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
-      descriptor->message_type()->file()->name() == "google/protobuf/wrappers.proto";
-}
+                inline bool IsWrapperType(const FieldDescriptor* descriptor)
+                {
+                    return descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
+                           descriptor->message_type()->file()->name() == "google/protobuf/wrappers.proto";
+                }
 
-}  // namespace php
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace php
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.h
index 611713e..8571743 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.h
@@ -67,28 +67,27 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
 
-class CodeGenerator;  // code_generator.h
-class CodeGeneratorRequest;
-class CodeGeneratorResponse;
+            class CodeGenerator;  // code_generator.h
+            class CodeGeneratorRequest;
+            class CodeGeneratorResponse;
 
-// Implements main() for a protoc plugin exposing the given code generator.
-PROTOC_EXPORT int PluginMain(int argc, char* argv[],
-                             const CodeGenerator* generator);
+            // Implements main() for a protoc plugin exposing the given code generator.
+            PROTOC_EXPORT int PluginMain(int argc, char* argv[], const CodeGenerator* generator);
 
+            // Generates code using the given code generator. Returns true if the code
+            // generation is successful. If the code generation fails, error_msg may be
+            // populated to describe the failure cause.
+            bool GenerateCode(const CodeGeneratorRequest& request, const CodeGenerator& generator, CodeGeneratorResponse* response, std::string* error_msg);
 
-// Generates code using the given code generator. Returns true if the code
-// generation is successful. If the code generation fails, error_msg may be
-// populated to describe the failure cause.
-bool GenerateCode(const CodeGeneratorRequest& request,
-                  const CodeGenerator& generator,
-                  CodeGeneratorResponse* response, std::string* error_msg);
-
-}  // namespace compiler
-}  // namespace protobuf
+        }  // namespace compiler
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.pb.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.pb.h
index 97bf2f0..1041317 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/plugin.pb.h
@@ -28,7 +28,7 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
 #include <google/protobuf/descriptor.pb.h>
@@ -42,1855 +42,2316 @@
 #undef minor
 #endif
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOC_EXPORT TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
-  static const uint32_t offsets[];
+struct PROTOC_EXPORT TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOC_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
 PROTOBUF_NAMESPACE_OPEN
-namespace compiler {
-class CodeGeneratorRequest;
-struct CodeGeneratorRequestDefaultTypeInternal;
-PROTOC_EXPORT extern CodeGeneratorRequestDefaultTypeInternal _CodeGeneratorRequest_default_instance_;
-class CodeGeneratorResponse;
-struct CodeGeneratorResponseDefaultTypeInternal;
-PROTOC_EXPORT extern CodeGeneratorResponseDefaultTypeInternal _CodeGeneratorResponse_default_instance_;
-class CodeGeneratorResponse_File;
-struct CodeGeneratorResponse_FileDefaultTypeInternal;
-PROTOC_EXPORT extern CodeGeneratorResponse_FileDefaultTypeInternal _CodeGeneratorResponse_File_default_instance_;
-class Version;
-struct VersionDefaultTypeInternal;
-PROTOC_EXPORT extern VersionDefaultTypeInternal _Version_default_instance_;
+namespace compiler
+{
+    class CodeGeneratorRequest;
+    struct CodeGeneratorRequestDefaultTypeInternal;
+    PROTOC_EXPORT extern CodeGeneratorRequestDefaultTypeInternal _CodeGeneratorRequest_default_instance_;
+    class CodeGeneratorResponse;
+    struct CodeGeneratorResponseDefaultTypeInternal;
+    PROTOC_EXPORT extern CodeGeneratorResponseDefaultTypeInternal _CodeGeneratorResponse_default_instance_;
+    class CodeGeneratorResponse_File;
+    struct CodeGeneratorResponse_FileDefaultTypeInternal;
+    PROTOC_EXPORT extern CodeGeneratorResponse_FileDefaultTypeInternal _CodeGeneratorResponse_File_default_instance_;
+    class Version;
+    struct VersionDefaultTypeInternal;
+    PROTOC_EXPORT extern VersionDefaultTypeInternal _Version_default_instance_;
 }  // namespace compiler
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest>(Arena*);
-template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse>(Arena*);
-template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>(Arena*);
-template<> PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::Version* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(Arena*);
+template<>
+PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorRequest>(Arena*);
+template<>
+PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse>(Arena*);
+template<>
+PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>(Arena*);
+template<>
+PROTOC_EXPORT ::PROTOBUF_NAMESPACE_ID::compiler::Version* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-namespace compiler {
-
-enum CodeGeneratorResponse_Feature : int {
-  CodeGeneratorResponse_Feature_FEATURE_NONE = 0,
-  CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL = 1
-};
-PROTOC_EXPORT bool CodeGeneratorResponse_Feature_IsValid(int value);
-constexpr CodeGeneratorResponse_Feature CodeGeneratorResponse_Feature_Feature_MIN = CodeGeneratorResponse_Feature_FEATURE_NONE;
-constexpr CodeGeneratorResponse_Feature CodeGeneratorResponse_Feature_Feature_MAX = CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL;
-constexpr int CodeGeneratorResponse_Feature_Feature_ARRAYSIZE = CodeGeneratorResponse_Feature_Feature_MAX + 1;
-
-PROTOC_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CodeGeneratorResponse_Feature_descriptor();
-template<typename T>
-inline const std::string& CodeGeneratorResponse_Feature_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, CodeGeneratorResponse_Feature>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function CodeGeneratorResponse_Feature_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    CodeGeneratorResponse_Feature_descriptor(), enum_t_value);
-}
-inline bool CodeGeneratorResponse_Feature_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CodeGeneratorResponse_Feature* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CodeGeneratorResponse_Feature>(
-    CodeGeneratorResponse_Feature_descriptor(), name, value);
-}
-// ===================================================================
-
-class PROTOC_EXPORT Version final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.Version) */ {
- public:
-  inline Version() : Version(nullptr) {}
-  ~Version() override;
-  explicit PROTOBUF_CONSTEXPR Version(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Version(const Version& from);
-  Version(Version&& from) noexcept
-    : Version() {
-    *this = ::std::move(from);
-  }
-
-  inline Version& operator=(const Version& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Version& operator=(Version&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Version& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Version* internal_default_instance() {
-    return reinterpret_cast<const Version*>(
-               &_Version_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(Version& a, Version& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Version* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Version* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Version* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Version>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Version& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Version& from) {
-    Version::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Version* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.compiler.Version";
-  }
-  protected:
-  explicit Version(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kSuffixFieldNumber = 4,
-    kMajorFieldNumber = 1,
-    kMinorFieldNumber = 2,
-    kPatchFieldNumber = 3,
-  };
-  // optional string suffix = 4;
-  bool has_suffix() const;
-  private:
-  bool _internal_has_suffix() const;
-  public:
-  void clear_suffix();
-  const std::string& suffix() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_suffix(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_suffix();
-  PROTOBUF_NODISCARD std::string* release_suffix();
-  void set_allocated_suffix(std::string* suffix);
-  private:
-  const std::string& _internal_suffix() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_suffix(const std::string& value);
-  std::string* _internal_mutable_suffix();
-  public:
-
-  // optional int32 major = 1;
-  bool has_major() const;
-  private:
-  bool _internal_has_major() const;
-  public:
-  void clear_major();
-  int32_t major() const;
-  void set_major(int32_t value);
-  private:
-  int32_t _internal_major() const;
-  void _internal_set_major(int32_t value);
-  public:
-
-  // optional int32 minor = 2;
-  bool has_minor() const;
-  private:
-  bool _internal_has_minor() const;
-  public:
-  void clear_minor();
-  int32_t minor() const;
-  void set_minor(int32_t value);
-  private:
-  int32_t _internal_minor() const;
-  void _internal_set_minor(int32_t value);
-  public:
-
-  // optional int32 patch = 3;
-  bool has_patch() const;
-  private:
-  bool _internal_has_patch() const;
-  public:
-  void clear_patch();
-  int32_t patch() const;
-  void set_patch(int32_t value);
-  private:
-  int32_t _internal_patch() const;
-  void _internal_set_patch(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.Version)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr suffix_;
-    int32_t major_;
-    int32_t minor_;
-    int32_t patch_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
-};
-// -------------------------------------------------------------------
-
-class PROTOC_EXPORT CodeGeneratorRequest final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorRequest) */ {
- public:
-  inline CodeGeneratorRequest() : CodeGeneratorRequest(nullptr) {}
-  ~CodeGeneratorRequest() override;
-  explicit PROTOBUF_CONSTEXPR CodeGeneratorRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  CodeGeneratorRequest(const CodeGeneratorRequest& from);
-  CodeGeneratorRequest(CodeGeneratorRequest&& from) noexcept
-    : CodeGeneratorRequest() {
-    *this = ::std::move(from);
-  }
-
-  inline CodeGeneratorRequest& operator=(const CodeGeneratorRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline CodeGeneratorRequest& operator=(CodeGeneratorRequest&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const CodeGeneratorRequest& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const CodeGeneratorRequest* internal_default_instance() {
-    return reinterpret_cast<const CodeGeneratorRequest*>(
-               &_CodeGeneratorRequest_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(CodeGeneratorRequest& a, CodeGeneratorRequest& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(CodeGeneratorRequest* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(CodeGeneratorRequest* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  CodeGeneratorRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<CodeGeneratorRequest>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const CodeGeneratorRequest& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const CodeGeneratorRequest& from) {
-    CodeGeneratorRequest::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(CodeGeneratorRequest* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.compiler.CodeGeneratorRequest";
-  }
-  protected:
-  explicit CodeGeneratorRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFileToGenerateFieldNumber = 1,
-    kProtoFileFieldNumber = 15,
-    kParameterFieldNumber = 2,
-    kCompilerVersionFieldNumber = 3,
-  };
-  // repeated string file_to_generate = 1;
-  int file_to_generate_size() const;
-  private:
-  int _internal_file_to_generate_size() const;
-  public:
-  void clear_file_to_generate();
-  const std::string& file_to_generate(int index) const;
-  std::string* mutable_file_to_generate(int index);
-  void set_file_to_generate(int index, const std::string& value);
-  void set_file_to_generate(int index, std::string&& value);
-  void set_file_to_generate(int index, const char* value);
-  void set_file_to_generate(int index, const char* value, size_t size);
-  std::string* add_file_to_generate();
-  void add_file_to_generate(const std::string& value);
-  void add_file_to_generate(std::string&& value);
-  void add_file_to_generate(const char* value);
-  void add_file_to_generate(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& file_to_generate() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_file_to_generate();
-  private:
-  const std::string& _internal_file_to_generate(int index) const;
-  std::string* _internal_add_file_to_generate();
-  public:
-
-  // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
-  int proto_file_size() const;
-  private:
-  int _internal_proto_file_size() const;
-  public:
-  void clear_proto_file();
-  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* mutable_proto_file(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
-      mutable_proto_file();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& _internal_proto_file(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _internal_add_proto_file();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& proto_file(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* add_proto_file();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
-      proto_file() const;
-
-  // optional string parameter = 2;
-  bool has_parameter() const;
-  private:
-  bool _internal_has_parameter() const;
-  public:
-  void clear_parameter();
-  const std::string& parameter() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_parameter(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_parameter();
-  PROTOBUF_NODISCARD std::string* release_parameter();
-  void set_allocated_parameter(std::string* parameter);
-  private:
-  const std::string& _internal_parameter() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_parameter(const std::string& value);
-  std::string* _internal_mutable_parameter();
-  public:
-
-  // optional .google.protobuf.compiler.Version compiler_version = 3;
-  bool has_compiler_version() const;
-  private:
-  bool _internal_has_compiler_version() const;
-  public:
-  void clear_compiler_version();
-  const ::PROTOBUF_NAMESPACE_ID::compiler::Version& compiler_version() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::compiler::Version* release_compiler_version();
-  ::PROTOBUF_NAMESPACE_ID::compiler::Version* mutable_compiler_version();
-  void set_allocated_compiler_version(::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::compiler::Version& _internal_compiler_version() const;
-  ::PROTOBUF_NAMESPACE_ID::compiler::Version* _internal_mutable_compiler_version();
-  public:
-  void unsafe_arena_set_allocated_compiler_version(
-      ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version);
-  ::PROTOBUF_NAMESPACE_ID::compiler::Version* unsafe_arena_release_compiler_version();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> file_to_generate_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto > proto_file_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parameter_;
-    ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
-};
-// -------------------------------------------------------------------
-
-class PROTOC_EXPORT CodeGeneratorResponse_File final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse.File) */ {
- public:
-  inline CodeGeneratorResponse_File() : CodeGeneratorResponse_File(nullptr) {}
-  ~CodeGeneratorResponse_File() override;
-  explicit PROTOBUF_CONSTEXPR CodeGeneratorResponse_File(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  CodeGeneratorResponse_File(const CodeGeneratorResponse_File& from);
-  CodeGeneratorResponse_File(CodeGeneratorResponse_File&& from) noexcept
-    : CodeGeneratorResponse_File() {
-    *this = ::std::move(from);
-  }
-
-  inline CodeGeneratorResponse_File& operator=(const CodeGeneratorResponse_File& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline CodeGeneratorResponse_File& operator=(CodeGeneratorResponse_File&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const CodeGeneratorResponse_File& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const CodeGeneratorResponse_File* internal_default_instance() {
-    return reinterpret_cast<const CodeGeneratorResponse_File*>(
-               &_CodeGeneratorResponse_File_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(CodeGeneratorResponse_File& a, CodeGeneratorResponse_File& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(CodeGeneratorResponse_File* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(CodeGeneratorResponse_File* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  CodeGeneratorResponse_File* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<CodeGeneratorResponse_File>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const CodeGeneratorResponse_File& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const CodeGeneratorResponse_File& from) {
-    CodeGeneratorResponse_File::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(CodeGeneratorResponse_File* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.compiler.CodeGeneratorResponse.File";
-  }
-  protected:
-  explicit CodeGeneratorResponse_File(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 1,
-    kInsertionPointFieldNumber = 2,
-    kContentFieldNumber = 15,
-    kGeneratedCodeInfoFieldNumber = 16,
-  };
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional string insertion_point = 2;
-  bool has_insertion_point() const;
-  private:
-  bool _internal_has_insertion_point() const;
-  public:
-  void clear_insertion_point();
-  const std::string& insertion_point() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_insertion_point(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_insertion_point();
-  PROTOBUF_NODISCARD std::string* release_insertion_point();
-  void set_allocated_insertion_point(std::string* insertion_point);
-  private:
-  const std::string& _internal_insertion_point() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_insertion_point(const std::string& value);
-  std::string* _internal_mutable_insertion_point();
-  public:
-
-  // optional string content = 15;
-  bool has_content() const;
-  private:
-  bool _internal_has_content() const;
-  public:
-  void clear_content();
-  const std::string& content() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_content(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_content();
-  PROTOBUF_NODISCARD std::string* release_content();
-  void set_allocated_content(std::string* content);
-  private:
-  const std::string& _internal_content() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
-  std::string* _internal_mutable_content();
-  public:
-
-  // optional .google.protobuf.GeneratedCodeInfo generated_code_info = 16;
-  bool has_generated_code_info() const;
-  private:
-  bool _internal_has_generated_code_info() const;
-  public:
-  void clear_generated_code_info();
-  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& generated_code_info() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* release_generated_code_info();
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* mutable_generated_code_info();
-  void set_allocated_generated_code_info(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& _internal_generated_code_info() const;
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* _internal_mutable_generated_code_info();
-  public:
-  void unsafe_arena_set_allocated_generated_code_info(
-      ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info);
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* unsafe_arena_release_generated_code_info();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr insertion_point_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
-    ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
-};
-// -------------------------------------------------------------------
-
-class PROTOC_EXPORT CodeGeneratorResponse final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse) */ {
- public:
-  inline CodeGeneratorResponse() : CodeGeneratorResponse(nullptr) {}
-  ~CodeGeneratorResponse() override;
-  explicit PROTOBUF_CONSTEXPR CodeGeneratorResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  CodeGeneratorResponse(const CodeGeneratorResponse& from);
-  CodeGeneratorResponse(CodeGeneratorResponse&& from) noexcept
-    : CodeGeneratorResponse() {
-    *this = ::std::move(from);
-  }
-
-  inline CodeGeneratorResponse& operator=(const CodeGeneratorResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline CodeGeneratorResponse& operator=(CodeGeneratorResponse&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const CodeGeneratorResponse& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const CodeGeneratorResponse* internal_default_instance() {
-    return reinterpret_cast<const CodeGeneratorResponse*>(
-               &_CodeGeneratorResponse_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    3;
-
-  friend void swap(CodeGeneratorResponse& a, CodeGeneratorResponse& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(CodeGeneratorResponse* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(CodeGeneratorResponse* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  CodeGeneratorResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<CodeGeneratorResponse>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const CodeGeneratorResponse& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const CodeGeneratorResponse& from) {
-    CodeGeneratorResponse::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(CodeGeneratorResponse* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.compiler.CodeGeneratorResponse";
-  }
-  protected:
-  explicit CodeGeneratorResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef CodeGeneratorResponse_File File;
-
-  typedef CodeGeneratorResponse_Feature Feature;
-  static constexpr Feature FEATURE_NONE =
-    CodeGeneratorResponse_Feature_FEATURE_NONE;
-  static constexpr Feature FEATURE_PROTO3_OPTIONAL =
-    CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL;
-  static inline bool Feature_IsValid(int value) {
-    return CodeGeneratorResponse_Feature_IsValid(value);
-  }
-  static constexpr Feature Feature_MIN =
-    CodeGeneratorResponse_Feature_Feature_MIN;
-  static constexpr Feature Feature_MAX =
-    CodeGeneratorResponse_Feature_Feature_MAX;
-  static constexpr int Feature_ARRAYSIZE =
-    CodeGeneratorResponse_Feature_Feature_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  Feature_descriptor() {
-    return CodeGeneratorResponse_Feature_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& Feature_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, Feature>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function Feature_Name.");
-    return CodeGeneratorResponse_Feature_Name(enum_t_value);
-  }
-  static inline bool Feature_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      Feature* value) {
-    return CodeGeneratorResponse_Feature_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFileFieldNumber = 15,
-    kErrorFieldNumber = 1,
-    kSupportedFeaturesFieldNumber = 2,
-  };
-  // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
-  int file_size() const;
-  private:
-  int _internal_file_size() const;
-  public:
-  void clear_file();
-  ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* mutable_file(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >*
-      mutable_file();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& _internal_file(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* _internal_add_file();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& file(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* add_file();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >&
-      file() const;
-
-  // optional string error = 1;
-  bool has_error() const;
-  private:
-  bool _internal_has_error() const;
-  public:
-  void clear_error();
-  const std::string& error() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_error(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_error();
-  PROTOBUF_NODISCARD std::string* release_error();
-  void set_allocated_error(std::string* error);
-  private:
-  const std::string& _internal_error() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_error(const std::string& value);
-  std::string* _internal_mutable_error();
-  public:
-
-  // optional uint64 supported_features = 2;
-  bool has_supported_features() const;
-  private:
-  bool _internal_has_supported_features() const;
-  public:
-  void clear_supported_features();
-  uint64_t supported_features() const;
-  void set_supported_features(uint64_t value);
-  private:
-  uint64_t _internal_supported_features() const;
-  void _internal_set_supported_features(uint64_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File > file_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_;
-    uint64_t supported_features_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
-};
-// ===================================================================
-
-
-// ===================================================================
+namespace compiler
+{
+
+    enum CodeGeneratorResponse_Feature : int
+    {
+        CodeGeneratorResponse_Feature_FEATURE_NONE = 0,
+        CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL = 1
+    };
+    PROTOC_EXPORT bool CodeGeneratorResponse_Feature_IsValid(int value);
+    constexpr CodeGeneratorResponse_Feature CodeGeneratorResponse_Feature_Feature_MIN = CodeGeneratorResponse_Feature_FEATURE_NONE;
+    constexpr CodeGeneratorResponse_Feature CodeGeneratorResponse_Feature_Feature_MAX = CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL;
+    constexpr int CodeGeneratorResponse_Feature_Feature_ARRAYSIZE = CodeGeneratorResponse_Feature_Feature_MAX + 1;
+
+    PROTOC_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CodeGeneratorResponse_Feature_descriptor();
+    template<typename T>
+    inline const std::string& CodeGeneratorResponse_Feature_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, CodeGeneratorResponse_Feature>::value || ::std::is_integral<T>::value, "Incorrect type passed to function CodeGeneratorResponse_Feature_Name.");
+        return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+            CodeGeneratorResponse_Feature_descriptor(), enum_t_value
+        );
+    }
+    inline bool CodeGeneratorResponse_Feature_Parse(
+        ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CodeGeneratorResponse_Feature* value
+    )
+    {
+        return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CodeGeneratorResponse_Feature>(
+            CodeGeneratorResponse_Feature_descriptor(), name, value
+        );
+    }
+    // ===================================================================
+
+    class PROTOC_EXPORT Version final :
+        public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.Version) */
+    {
+    public:
+        inline Version() :
+            Version(nullptr)
+        {
+        }
+        ~Version() override;
+        explicit PROTOBUF_CONSTEXPR Version(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+        Version(const Version& from);
+        Version(Version&& from) noexcept
+            :
+            Version()
+        {
+            *this = ::std::move(from);
+        }
+
+        inline Version& operator=(const Version& from)
+        {
+            CopyFrom(from);
+            return *this;
+        }
+        inline Version& operator=(Version&& from) noexcept
+        {
+            if (this == &from)
+                return *this;
+            if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+                && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+            )
+            {
+                InternalSwap(&from);
+            }
+            else
+            {
+                CopyFrom(from);
+            }
+            return *this;
+        }
+
+        inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+        {
+            return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+        }
+        inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+        {
+            return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+        }
+
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+        {
+            return GetDescriptor();
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+        {
+            return default_instance().GetMetadata().descriptor;
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+        {
+            return default_instance().GetMetadata().reflection;
+        }
+        static const Version& default_instance()
+        {
+            return *internal_default_instance();
+        }
+        static inline const Version* internal_default_instance()
+        {
+            return reinterpret_cast<const Version*>(
+                &_Version_default_instance_
+            );
+        }
+        static constexpr int kIndexInFileMessages =
+            0;
+
+        friend void swap(Version& a, Version& b)
+        {
+            a.Swap(&b);
+        }
+        inline void Swap(Version* other)
+        {
+            if (other == this)
+                return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() != nullptr &&
+                GetOwningArena() == other->GetOwningArena())
+            {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() == other->GetOwningArena())
+            {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+                InternalSwap(other);
+            }
+            else
+            {
+                ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+            }
+        }
+        void UnsafeArenaSwap(Version* other)
+        {
+            if (other == this)
+                return;
+            GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+            InternalSwap(other);
+        }
+
+        // implements Message ----------------------------------------------
+
+        Version* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+        {
+            return CreateMaybeMessage<Version>(arena);
+        }
+        using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+        void CopyFrom(const Version& from);
+        using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+        void MergeFrom(const Version& from)
+        {
+            Version::MergeImpl(*this, from);
+        }
+
+    private:
+        static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+    public:
+        PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+        bool IsInitialized() const final;
+
+        size_t ByteSizeLong() const final;
+        const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+        uint8_t* _InternalSerialize(
+            uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+        ) const final;
+        int GetCachedSize() const final
+        {
+            return _impl_._cached_size_.Get();
+        }
+
+    private:
+        void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+        void SharedDtor();
+        void SetCachedSize(int size) const final;
+        void InternalSwap(Version* other);
+
+    private:
+        friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+        static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+        {
+            return "google.protobuf.compiler.Version";
+        }
+
+    protected:
+        explicit Version(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+    public:
+        static const ClassData _class_data_;
+        const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+        ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+        // nested types ----------------------------------------------------
+
+        // accessors -------------------------------------------------------
+
+        enum : int
+        {
+            kSuffixFieldNumber = 4,
+            kMajorFieldNumber = 1,
+            kMinorFieldNumber = 2,
+            kPatchFieldNumber = 3,
+        };
+        // optional string suffix = 4;
+        bool has_suffix() const;
+
+    private:
+        bool _internal_has_suffix() const;
+
+    public:
+        void clear_suffix();
+        const std::string& suffix() const;
+        template<typename ArgT0 = const std::string&, typename... ArgT>
+        void set_suffix(ArgT0&& arg0, ArgT... args);
+        std::string* mutable_suffix();
+        PROTOBUF_NODISCARD std::string* release_suffix();
+        void set_allocated_suffix(std::string* suffix);
+
+    private:
+        const std::string& _internal_suffix() const;
+        inline PROTOBUF_ALWAYS_INLINE void _internal_set_suffix(const std::string& value);
+        std::string* _internal_mutable_suffix();
+
+    public:
+        // optional int32 major = 1;
+        bool has_major() const;
+
+    private:
+        bool _internal_has_major() const;
+
+    public:
+        void clear_major();
+        int32_t major() const;
+        void set_major(int32_t value);
+
+    private:
+        int32_t _internal_major() const;
+        void _internal_set_major(int32_t value);
+
+    public:
+        // optional int32 minor = 2;
+        bool has_minor() const;
+
+    private:
+        bool _internal_has_minor() const;
+
+    public:
+        void clear_minor();
+        int32_t minor() const;
+        void set_minor(int32_t value);
+
+    private:
+        int32_t _internal_minor() const;
+        void _internal_set_minor(int32_t value);
+
+    public:
+        // optional int32 patch = 3;
+        bool has_patch() const;
+
+    private:
+        bool _internal_has_patch() const;
+
+    public:
+        void clear_patch();
+        int32_t patch() const;
+        void set_patch(int32_t value);
+
+    private:
+        int32_t _internal_patch() const;
+        void _internal_set_patch(int32_t value);
+
+    public:
+        // @@protoc_insertion_point(class_scope:google.protobuf.compiler.Version)
+
+    private:
+        class _Internal;
+
+        template<typename T>
+        friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+        typedef void InternalArenaConstructable_;
+        typedef void DestructorSkippable_;
+        struct Impl_
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+            mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+            ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr suffix_;
+            int32_t major_;
+            int32_t minor_;
+            int32_t patch_;
+        };
+        union
+        {
+            Impl_ _impl_;
+        };
+        friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+    };
+    // -------------------------------------------------------------------
+
+    class PROTOC_EXPORT CodeGeneratorRequest final :
+        public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorRequest) */
+    {
+    public:
+        inline CodeGeneratorRequest() :
+            CodeGeneratorRequest(nullptr)
+        {
+        }
+        ~CodeGeneratorRequest() override;
+        explicit PROTOBUF_CONSTEXPR CodeGeneratorRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+        CodeGeneratorRequest(const CodeGeneratorRequest& from);
+        CodeGeneratorRequest(CodeGeneratorRequest&& from) noexcept
+            :
+            CodeGeneratorRequest()
+        {
+            *this = ::std::move(from);
+        }
+
+        inline CodeGeneratorRequest& operator=(const CodeGeneratorRequest& from)
+        {
+            CopyFrom(from);
+            return *this;
+        }
+        inline CodeGeneratorRequest& operator=(CodeGeneratorRequest&& from) noexcept
+        {
+            if (this == &from)
+                return *this;
+            if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+                && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+            )
+            {
+                InternalSwap(&from);
+            }
+            else
+            {
+                CopyFrom(from);
+            }
+            return *this;
+        }
+
+        inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+        {
+            return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+        }
+        inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+        {
+            return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+        }
+
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+        {
+            return GetDescriptor();
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+        {
+            return default_instance().GetMetadata().descriptor;
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+        {
+            return default_instance().GetMetadata().reflection;
+        }
+        static const CodeGeneratorRequest& default_instance()
+        {
+            return *internal_default_instance();
+        }
+        static inline const CodeGeneratorRequest* internal_default_instance()
+        {
+            return reinterpret_cast<const CodeGeneratorRequest*>(
+                &_CodeGeneratorRequest_default_instance_
+            );
+        }
+        static constexpr int kIndexInFileMessages =
+            1;
+
+        friend void swap(CodeGeneratorRequest& a, CodeGeneratorRequest& b)
+        {
+            a.Swap(&b);
+        }
+        inline void Swap(CodeGeneratorRequest* other)
+        {
+            if (other == this)
+                return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() != nullptr &&
+                GetOwningArena() == other->GetOwningArena())
+            {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() == other->GetOwningArena())
+            {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+                InternalSwap(other);
+            }
+            else
+            {
+                ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+            }
+        }
+        void UnsafeArenaSwap(CodeGeneratorRequest* other)
+        {
+            if (other == this)
+                return;
+            GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+            InternalSwap(other);
+        }
+
+        // implements Message ----------------------------------------------
+
+        CodeGeneratorRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+        {
+            return CreateMaybeMessage<CodeGeneratorRequest>(arena);
+        }
+        using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+        void CopyFrom(const CodeGeneratorRequest& from);
+        using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+        void MergeFrom(const CodeGeneratorRequest& from)
+        {
+            CodeGeneratorRequest::MergeImpl(*this, from);
+        }
+
+    private:
+        static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+    public:
+        PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+        bool IsInitialized() const final;
+
+        size_t ByteSizeLong() const final;
+        const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+        uint8_t* _InternalSerialize(
+            uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+        ) const final;
+        int GetCachedSize() const final
+        {
+            return _impl_._cached_size_.Get();
+        }
+
+    private:
+        void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+        void SharedDtor();
+        void SetCachedSize(int size) const final;
+        void InternalSwap(CodeGeneratorRequest* other);
+
+    private:
+        friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+        static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+        {
+            return "google.protobuf.compiler.CodeGeneratorRequest";
+        }
+
+    protected:
+        explicit CodeGeneratorRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+    public:
+        static const ClassData _class_data_;
+        const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+        ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+        // nested types ----------------------------------------------------
+
+        // accessors -------------------------------------------------------
+
+        enum : int
+        {
+            kFileToGenerateFieldNumber = 1,
+            kProtoFileFieldNumber = 15,
+            kParameterFieldNumber = 2,
+            kCompilerVersionFieldNumber = 3,
+        };
+        // repeated string file_to_generate = 1;
+        int file_to_generate_size() const;
+
+    private:
+        int _internal_file_to_generate_size() const;
+
+    public:
+        void clear_file_to_generate();
+        const std::string& file_to_generate(int index) const;
+        std::string* mutable_file_to_generate(int index);
+        void set_file_to_generate(int index, const std::string& value);
+        void set_file_to_generate(int index, std::string&& value);
+        void set_file_to_generate(int index, const char* value);
+        void set_file_to_generate(int index, const char* value, size_t size);
+        std::string* add_file_to_generate();
+        void add_file_to_generate(const std::string& value);
+        void add_file_to_generate(std::string&& value);
+        void add_file_to_generate(const char* value);
+        void add_file_to_generate(const char* value, size_t size);
+        const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& file_to_generate() const;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_file_to_generate();
+
+    private:
+        const std::string& _internal_file_to_generate(int index) const;
+        std::string* _internal_add_file_to_generate();
+
+    public:
+        // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
+        int proto_file_size() const;
+
+    private:
+        int _internal_proto_file_size() const;
+
+    public:
+        void clear_proto_file();
+        ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* mutable_proto_file(int index);
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>*
+            mutable_proto_file();
+
+    private:
+        const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& _internal_proto_file(int index) const;
+        ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _internal_add_proto_file();
+
+    public:
+        const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& proto_file(int index) const;
+        ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* add_proto_file();
+        const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>&
+            proto_file() const;
+
+        // optional string parameter = 2;
+        bool has_parameter() const;
+
+    private:
+        bool _internal_has_parameter() const;
+
+    public:
+        void clear_parameter();
+        const std::string& parameter() const;
+        template<typename ArgT0 = const std::string&, typename... ArgT>
+        void set_parameter(ArgT0&& arg0, ArgT... args);
+        std::string* mutable_parameter();
+        PROTOBUF_NODISCARD std::string* release_parameter();
+        void set_allocated_parameter(std::string* parameter);
+
+    private:
+        const std::string& _internal_parameter() const;
+        inline PROTOBUF_ALWAYS_INLINE void _internal_set_parameter(const std::string& value);
+        std::string* _internal_mutable_parameter();
+
+    public:
+        // optional .google.protobuf.compiler.Version compiler_version = 3;
+        bool has_compiler_version() const;
+
+    private:
+        bool _internal_has_compiler_version() const;
+
+    public:
+        void clear_compiler_version();
+        const ::PROTOBUF_NAMESPACE_ID::compiler::Version& compiler_version() const;
+        PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::compiler::Version* release_compiler_version();
+        ::PROTOBUF_NAMESPACE_ID::compiler::Version* mutable_compiler_version();
+        void set_allocated_compiler_version(::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version);
+
+    private:
+        const ::PROTOBUF_NAMESPACE_ID::compiler::Version& _internal_compiler_version() const;
+        ::PROTOBUF_NAMESPACE_ID::compiler::Version* _internal_mutable_compiler_version();
+
+    public:
+        void unsafe_arena_set_allocated_compiler_version(
+            ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version
+        );
+        ::PROTOBUF_NAMESPACE_ID::compiler::Version* unsafe_arena_release_compiler_version();
+
+        // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
+
+    private:
+        class _Internal;
+
+        template<typename T>
+        friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+        typedef void InternalArenaConstructable_;
+        typedef void DestructorSkippable_;
+        struct Impl_
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+            mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+            ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> file_to_generate_;
+            ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto> proto_file_;
+            ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parameter_;
+            ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version_;
+        };
+        union
+        {
+            Impl_ _impl_;
+        };
+        friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+    };
+    // -------------------------------------------------------------------
+
+    class PROTOC_EXPORT CodeGeneratorResponse_File final :
+        public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse.File) */
+    {
+    public:
+        inline CodeGeneratorResponse_File() :
+            CodeGeneratorResponse_File(nullptr)
+        {
+        }
+        ~CodeGeneratorResponse_File() override;
+        explicit PROTOBUF_CONSTEXPR CodeGeneratorResponse_File(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+        CodeGeneratorResponse_File(const CodeGeneratorResponse_File& from);
+        CodeGeneratorResponse_File(CodeGeneratorResponse_File&& from) noexcept
+            :
+            CodeGeneratorResponse_File()
+        {
+            *this = ::std::move(from);
+        }
+
+        inline CodeGeneratorResponse_File& operator=(const CodeGeneratorResponse_File& from)
+        {
+            CopyFrom(from);
+            return *this;
+        }
+        inline CodeGeneratorResponse_File& operator=(CodeGeneratorResponse_File&& from) noexcept
+        {
+            if (this == &from)
+                return *this;
+            if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+                && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+            )
+            {
+                InternalSwap(&from);
+            }
+            else
+            {
+                CopyFrom(from);
+            }
+            return *this;
+        }
+
+        inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+        {
+            return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+        }
+        inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+        {
+            return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+        }
+
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+        {
+            return GetDescriptor();
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+        {
+            return default_instance().GetMetadata().descriptor;
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+        {
+            return default_instance().GetMetadata().reflection;
+        }
+        static const CodeGeneratorResponse_File& default_instance()
+        {
+            return *internal_default_instance();
+        }
+        static inline const CodeGeneratorResponse_File* internal_default_instance()
+        {
+            return reinterpret_cast<const CodeGeneratorResponse_File*>(
+                &_CodeGeneratorResponse_File_default_instance_
+            );
+        }
+        static constexpr int kIndexInFileMessages =
+            2;
+
+        friend void swap(CodeGeneratorResponse_File& a, CodeGeneratorResponse_File& b)
+        {
+            a.Swap(&b);
+        }
+        inline void Swap(CodeGeneratorResponse_File* other)
+        {
+            if (other == this)
+                return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() != nullptr &&
+                GetOwningArena() == other->GetOwningArena())
+            {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() == other->GetOwningArena())
+            {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+                InternalSwap(other);
+            }
+            else
+            {
+                ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+            }
+        }
+        void UnsafeArenaSwap(CodeGeneratorResponse_File* other)
+        {
+            if (other == this)
+                return;
+            GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+            InternalSwap(other);
+        }
+
+        // implements Message ----------------------------------------------
+
+        CodeGeneratorResponse_File* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+        {
+            return CreateMaybeMessage<CodeGeneratorResponse_File>(arena);
+        }
+        using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+        void CopyFrom(const CodeGeneratorResponse_File& from);
+        using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+        void MergeFrom(const CodeGeneratorResponse_File& from)
+        {
+            CodeGeneratorResponse_File::MergeImpl(*this, from);
+        }
+
+    private:
+        static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+    public:
+        PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+        bool IsInitialized() const final;
+
+        size_t ByteSizeLong() const final;
+        const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+        uint8_t* _InternalSerialize(
+            uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+        ) const final;
+        int GetCachedSize() const final
+        {
+            return _impl_._cached_size_.Get();
+        }
+
+    private:
+        void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+        void SharedDtor();
+        void SetCachedSize(int size) const final;
+        void InternalSwap(CodeGeneratorResponse_File* other);
+
+    private:
+        friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+        static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+        {
+            return "google.protobuf.compiler.CodeGeneratorResponse.File";
+        }
+
+    protected:
+        explicit CodeGeneratorResponse_File(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+    public:
+        static const ClassData _class_data_;
+        const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+        ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+        // nested types ----------------------------------------------------
+
+        // accessors -------------------------------------------------------
+
+        enum : int
+        {
+            kNameFieldNumber = 1,
+            kInsertionPointFieldNumber = 2,
+            kContentFieldNumber = 15,
+            kGeneratedCodeInfoFieldNumber = 16,
+        };
+        // optional string name = 1;
+        bool has_name() const;
+
+    private:
+        bool _internal_has_name() const;
+
+    public:
+        void clear_name();
+        const std::string& name() const;
+        template<typename ArgT0 = const std::string&, typename... ArgT>
+        void set_name(ArgT0&& arg0, ArgT... args);
+        std::string* mutable_name();
+        PROTOBUF_NODISCARD std::string* release_name();
+        void set_allocated_name(std::string* name);
+
+    private:
+        const std::string& _internal_name() const;
+        inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+        std::string* _internal_mutable_name();
+
+    public:
+        // optional string insertion_point = 2;
+        bool has_insertion_point() const;
+
+    private:
+        bool _internal_has_insertion_point() const;
+
+    public:
+        void clear_insertion_point();
+        const std::string& insertion_point() const;
+        template<typename ArgT0 = const std::string&, typename... ArgT>
+        void set_insertion_point(ArgT0&& arg0, ArgT... args);
+        std::string* mutable_insertion_point();
+        PROTOBUF_NODISCARD std::string* release_insertion_point();
+        void set_allocated_insertion_point(std::string* insertion_point);
+
+    private:
+        const std::string& _internal_insertion_point() const;
+        inline PROTOBUF_ALWAYS_INLINE void _internal_set_insertion_point(const std::string& value);
+        std::string* _internal_mutable_insertion_point();
+
+    public:
+        // optional string content = 15;
+        bool has_content() const;
+
+    private:
+        bool _internal_has_content() const;
+
+    public:
+        void clear_content();
+        const std::string& content() const;
+        template<typename ArgT0 = const std::string&, typename... ArgT>
+        void set_content(ArgT0&& arg0, ArgT... args);
+        std::string* mutable_content();
+        PROTOBUF_NODISCARD std::string* release_content();
+        void set_allocated_content(std::string* content);
+
+    private:
+        const std::string& _internal_content() const;
+        inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
+        std::string* _internal_mutable_content();
+
+    public:
+        // optional .google.protobuf.GeneratedCodeInfo generated_code_info = 16;
+        bool has_generated_code_info() const;
+
+    private:
+        bool _internal_has_generated_code_info() const;
+
+    public:
+        void clear_generated_code_info();
+        const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& generated_code_info() const;
+        PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* release_generated_code_info();
+        ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* mutable_generated_code_info();
+        void set_allocated_generated_code_info(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info);
+
+    private:
+        const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& _internal_generated_code_info() const;
+        ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* _internal_mutable_generated_code_info();
+
+    public:
+        void unsafe_arena_set_allocated_generated_code_info(
+            ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info
+        );
+        ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* unsafe_arena_release_generated_code_info();
+
+        // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
+
+    private:
+        class _Internal;
+
+        template<typename T>
+        friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+        typedef void InternalArenaConstructable_;
+        typedef void DestructorSkippable_;
+        struct Impl_
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+            mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+            ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+            ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr insertion_point_;
+            ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
+            ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info_;
+        };
+        union
+        {
+            Impl_ _impl_;
+        };
+        friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+    };
+    // -------------------------------------------------------------------
+
+    class PROTOC_EXPORT CodeGeneratorResponse final :
+        public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse) */
+    {
+    public:
+        inline CodeGeneratorResponse() :
+            CodeGeneratorResponse(nullptr)
+        {
+        }
+        ~CodeGeneratorResponse() override;
+        explicit PROTOBUF_CONSTEXPR CodeGeneratorResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+        CodeGeneratorResponse(const CodeGeneratorResponse& from);
+        CodeGeneratorResponse(CodeGeneratorResponse&& from) noexcept
+            :
+            CodeGeneratorResponse()
+        {
+            *this = ::std::move(from);
+        }
+
+        inline CodeGeneratorResponse& operator=(const CodeGeneratorResponse& from)
+        {
+            CopyFrom(from);
+            return *this;
+        }
+        inline CodeGeneratorResponse& operator=(CodeGeneratorResponse&& from) noexcept
+        {
+            if (this == &from)
+                return *this;
+            if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+                && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+            )
+            {
+                InternalSwap(&from);
+            }
+            else
+            {
+                CopyFrom(from);
+            }
+            return *this;
+        }
+
+        inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+        {
+            return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+        }
+        inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+        {
+            return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+        }
+
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+        {
+            return GetDescriptor();
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+        {
+            return default_instance().GetMetadata().descriptor;
+        }
+        static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+        {
+            return default_instance().GetMetadata().reflection;
+        }
+        static const CodeGeneratorResponse& default_instance()
+        {
+            return *internal_default_instance();
+        }
+        static inline const CodeGeneratorResponse* internal_default_instance()
+        {
+            return reinterpret_cast<const CodeGeneratorResponse*>(
+                &_CodeGeneratorResponse_default_instance_
+            );
+        }
+        static constexpr int kIndexInFileMessages =
+            3;
+
+        friend void swap(CodeGeneratorResponse& a, CodeGeneratorResponse& b)
+        {
+            a.Swap(&b);
+        }
+        inline void Swap(CodeGeneratorResponse* other)
+        {
+            if (other == this)
+                return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() != nullptr &&
+                GetOwningArena() == other->GetOwningArena())
+            {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+            if (GetOwningArena() == other->GetOwningArena())
+            {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+                InternalSwap(other);
+            }
+            else
+            {
+                ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+            }
+        }
+        void UnsafeArenaSwap(CodeGeneratorResponse* other)
+        {
+            if (other == this)
+                return;
+            GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+            InternalSwap(other);
+        }
+
+        // implements Message ----------------------------------------------
+
+        CodeGeneratorResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+        {
+            return CreateMaybeMessage<CodeGeneratorResponse>(arena);
+        }
+        using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+        void CopyFrom(const CodeGeneratorResponse& from);
+        using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+        void MergeFrom(const CodeGeneratorResponse& from)
+        {
+            CodeGeneratorResponse::MergeImpl(*this, from);
+        }
+
+    private:
+        static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+    public:
+        PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+        bool IsInitialized() const final;
+
+        size_t ByteSizeLong() const final;
+        const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+        uint8_t* _InternalSerialize(
+            uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+        ) const final;
+        int GetCachedSize() const final
+        {
+            return _impl_._cached_size_.Get();
+        }
+
+    private:
+        void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+        void SharedDtor();
+        void SetCachedSize(int size) const final;
+        void InternalSwap(CodeGeneratorResponse* other);
+
+    private:
+        friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+        static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+        {
+            return "google.protobuf.compiler.CodeGeneratorResponse";
+        }
+
+    protected:
+        explicit CodeGeneratorResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+    public:
+        static const ClassData _class_data_;
+        const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+        ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+        // nested types ----------------------------------------------------
+
+        typedef CodeGeneratorResponse_File File;
+
+        typedef CodeGeneratorResponse_Feature Feature;
+        static constexpr Feature FEATURE_NONE =
+            CodeGeneratorResponse_Feature_FEATURE_NONE;
+        static constexpr Feature FEATURE_PROTO3_OPTIONAL =
+            CodeGeneratorResponse_Feature_FEATURE_PROTO3_OPTIONAL;
+        static inline bool Feature_IsValid(int value)
+        {
+            return CodeGeneratorResponse_Feature_IsValid(value);
+        }
+        static constexpr Feature Feature_MIN =
+            CodeGeneratorResponse_Feature_Feature_MIN;
+        static constexpr Feature Feature_MAX =
+            CodeGeneratorResponse_Feature_Feature_MAX;
+        static constexpr int Feature_ARRAYSIZE =
+            CodeGeneratorResponse_Feature_Feature_ARRAYSIZE;
+        static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+            Feature_descriptor()
+        {
+            return CodeGeneratorResponse_Feature_descriptor();
+        }
+        template<typename T>
+        static inline const std::string& Feature_Name(T enum_t_value)
+        {
+            static_assert(::std::is_same<T, Feature>::value || ::std::is_integral<T>::value, "Incorrect type passed to function Feature_Name.");
+            return CodeGeneratorResponse_Feature_Name(enum_t_value);
+        }
+        static inline bool Feature_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Feature* value)
+        {
+            return CodeGeneratorResponse_Feature_Parse(name, value);
+        }
+
+        // accessors -------------------------------------------------------
+
+        enum : int
+        {
+            kFileFieldNumber = 15,
+            kErrorFieldNumber = 1,
+            kSupportedFeaturesFieldNumber = 2,
+        };
+        // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
+        int file_size() const;
+
+    private:
+        int _internal_file_size() const;
+
+    public:
+        void clear_file();
+        ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* mutable_file(int index);
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>*
+            mutable_file();
+
+    private:
+        const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& _internal_file(int index) const;
+        ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* _internal_add_file();
+
+    public:
+        const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& file(int index) const;
+        ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* add_file();
+        const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>&
+            file() const;
+
+        // optional string error = 1;
+        bool has_error() const;
+
+    private:
+        bool _internal_has_error() const;
+
+    public:
+        void clear_error();
+        const std::string& error() const;
+        template<typename ArgT0 = const std::string&, typename... ArgT>
+        void set_error(ArgT0&& arg0, ArgT... args);
+        std::string* mutable_error();
+        PROTOBUF_NODISCARD std::string* release_error();
+        void set_allocated_error(std::string* error);
+
+    private:
+        const std::string& _internal_error() const;
+        inline PROTOBUF_ALWAYS_INLINE void _internal_set_error(const std::string& value);
+        std::string* _internal_mutable_error();
+
+    public:
+        // optional uint64 supported_features = 2;
+        bool has_supported_features() const;
+
+    private:
+        bool _internal_has_supported_features() const;
+
+    public:
+        void clear_supported_features();
+        uint64_t supported_features() const;
+        void set_supported_features(uint64_t value);
+
+    private:
+        uint64_t _internal_supported_features() const;
+        void _internal_set_supported_features(uint64_t value);
+
+    public:
+        // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
+
+    private:
+        class _Internal;
+
+        template<typename T>
+        friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+        typedef void InternalArenaConstructable_;
+        typedef void DestructorSkippable_;
+        struct Impl_
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+            mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+            ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File> file_;
+            ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_;
+            uint64_t supported_features_;
+        };
+        union
+        {
+            Impl_ _impl_;
+        };
+        friend struct ::TableStruct_google_2fprotobuf_2fcompiler_2fplugin_2eproto;
+    };
+    // ===================================================================
+
+    // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
-// Version
+    // Version
 
-// optional int32 major = 1;
-inline bool Version::_internal_has_major() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool Version::has_major() const {
-  return _internal_has_major();
-}
-inline void Version::clear_major() {
-  _impl_.major_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline int32_t Version::_internal_major() const {
-  return _impl_.major_;
-}
-inline int32_t Version::major() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.major)
-  return _internal_major();
-}
-inline void Version::_internal_set_major(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.major_ = value;
-}
-inline void Version::set_major(int32_t value) {
-  _internal_set_major(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.major)
-}
+    // optional int32 major = 1;
+    inline bool Version::_internal_has_major() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+        return value;
+    }
+    inline bool Version::has_major() const
+    {
+        return _internal_has_major();
+    }
+    inline void Version::clear_major()
+    {
+        _impl_.major_ = 0;
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    inline int32_t Version::_internal_major() const
+    {
+        return _impl_.major_;
+    }
+    inline int32_t Version::major() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.major)
+        return _internal_major();
+    }
+    inline void Version::_internal_set_major(int32_t value)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+        _impl_.major_ = value;
+    }
+    inline void Version::set_major(int32_t value)
+    {
+        _internal_set_major(value);
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.major)
+    }
 
-// optional int32 minor = 2;
-inline bool Version::_internal_has_minor() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool Version::has_minor() const {
-  return _internal_has_minor();
-}
-inline void Version::clear_minor() {
-  _impl_.minor_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000004u;
-}
-inline int32_t Version::_internal_minor() const {
-  return _impl_.minor_;
-}
-inline int32_t Version::minor() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.minor)
-  return _internal_minor();
-}
-inline void Version::_internal_set_minor(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.minor_ = value;
-}
-inline void Version::set_minor(int32_t value) {
-  _internal_set_minor(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.minor)
-}
+    // optional int32 minor = 2;
+    inline bool Version::_internal_has_minor() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+        return value;
+    }
+    inline bool Version::has_minor() const
+    {
+        return _internal_has_minor();
+    }
+    inline void Version::clear_minor()
+    {
+        _impl_.minor_ = 0;
+        _impl_._has_bits_[0] &= ~0x00000004u;
+    }
+    inline int32_t Version::_internal_minor() const
+    {
+        return _impl_.minor_;
+    }
+    inline int32_t Version::minor() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.minor)
+        return _internal_minor();
+    }
+    inline void Version::_internal_set_minor(int32_t value)
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+        _impl_.minor_ = value;
+    }
+    inline void Version::set_minor(int32_t value)
+    {
+        _internal_set_minor(value);
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.minor)
+    }
 
-// optional int32 patch = 3;
-inline bool Version::_internal_has_patch() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool Version::has_patch() const {
-  return _internal_has_patch();
-}
-inline void Version::clear_patch() {
-  _impl_.patch_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000008u;
-}
-inline int32_t Version::_internal_patch() const {
-  return _impl_.patch_;
-}
-inline int32_t Version::patch() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.patch)
-  return _internal_patch();
-}
-inline void Version::_internal_set_patch(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  _impl_.patch_ = value;
-}
-inline void Version::set_patch(int32_t value) {
-  _internal_set_patch(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.patch)
-}
+    // optional int32 patch = 3;
+    inline bool Version::_internal_has_patch() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+        return value;
+    }
+    inline bool Version::has_patch() const
+    {
+        return _internal_has_patch();
+    }
+    inline void Version::clear_patch()
+    {
+        _impl_.patch_ = 0;
+        _impl_._has_bits_[0] &= ~0x00000008u;
+    }
+    inline int32_t Version::_internal_patch() const
+    {
+        return _impl_.patch_;
+    }
+    inline int32_t Version::patch() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.patch)
+        return _internal_patch();
+    }
+    inline void Version::_internal_set_patch(int32_t value)
+    {
+        _impl_._has_bits_[0] |= 0x00000008u;
+        _impl_.patch_ = value;
+    }
+    inline void Version::set_patch(int32_t value)
+    {
+        _internal_set_patch(value);
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.patch)
+    }
 
-// optional string suffix = 4;
-inline bool Version::_internal_has_suffix() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool Version::has_suffix() const {
-  return _internal_has_suffix();
-}
-inline void Version::clear_suffix() {
-  _impl_.suffix_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& Version::suffix() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.suffix)
-  return _internal_suffix();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Version::set_suffix(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.suffix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.suffix)
-}
-inline std::string* Version::mutable_suffix() {
-  std::string* _s = _internal_mutable_suffix();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.Version.suffix)
-  return _s;
-}
-inline const std::string& Version::_internal_suffix() const {
-  return _impl_.suffix_.Get();
-}
-inline void Version::_internal_set_suffix(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.suffix_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Version::_internal_mutable_suffix() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.suffix_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Version::release_suffix() {
-  // @@protoc_insertion_point(field_release:google.protobuf.compiler.Version.suffix)
-  if (!_internal_has_suffix()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.suffix_.Release();
+    // optional string suffix = 4;
+    inline bool Version::_internal_has_suffix() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+        return value;
+    }
+    inline bool Version::has_suffix() const
+    {
+        return _internal_has_suffix();
+    }
+    inline void Version::clear_suffix()
+    {
+        _impl_.suffix_.ClearToEmpty();
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    inline const std::string& Version::suffix() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.suffix)
+        return _internal_suffix();
+    }
+    template<typename ArgT0, typename... ArgT>
+    inline PROTOBUF_ALWAYS_INLINE void Version::set_suffix(ArgT0&& arg0, ArgT... args)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        _impl_.suffix_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.suffix)
+    }
+    inline std::string* Version::mutable_suffix()
+    {
+        std::string* _s = _internal_mutable_suffix();
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.Version.suffix)
+        return _s;
+    }
+    inline const std::string& Version::_internal_suffix() const
+    {
+        return _impl_.suffix_.Get();
+    }
+    inline void Version::_internal_set_suffix(const std::string& value)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        _impl_.suffix_.Set(value, GetArenaForAllocation());
+    }
+    inline std::string* Version::_internal_mutable_suffix()
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        return _impl_.suffix_.Mutable(GetArenaForAllocation());
+    }
+    inline std::string* Version::release_suffix()
+    {
+        // @@protoc_insertion_point(field_release:google.protobuf.compiler.Version.suffix)
+        if (!_internal_has_suffix())
+        {
+            return nullptr;
+        }
+        _impl_._has_bits_[0] &= ~0x00000001u;
+        auto* p = _impl_.suffix_.Release();
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.suffix_.IsDefault()) {
-    _impl_.suffix_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void Version::set_allocated_suffix(std::string* suffix) {
-  if (suffix != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.suffix_.SetAllocated(suffix, GetArenaForAllocation());
+        if (_impl_.suffix_.IsDefault())
+        {
+            _impl_.suffix_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        return p;
+    }
+    inline void Version::set_allocated_suffix(std::string* suffix)
+    {
+        if (suffix != nullptr)
+        {
+            _impl_._has_bits_[0] |= 0x00000001u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000001u;
+        }
+        _impl_.suffix_.SetAllocated(suffix, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.suffix_.IsDefault()) {
-    _impl_.suffix_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.Version.suffix)
-}
+        if (_impl_.suffix_.IsDefault())
+        {
+            _impl_.suffix_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.Version.suffix)
+    }
 
-// -------------------------------------------------------------------
+    // -------------------------------------------------------------------
 
-// CodeGeneratorRequest
+    // CodeGeneratorRequest
 
-// repeated string file_to_generate = 1;
-inline int CodeGeneratorRequest::_internal_file_to_generate_size() const {
-  return _impl_.file_to_generate_.size();
-}
-inline int CodeGeneratorRequest::file_to_generate_size() const {
-  return _internal_file_to_generate_size();
-}
-inline void CodeGeneratorRequest::clear_file_to_generate() {
-  _impl_.file_to_generate_.Clear();
-}
-inline std::string* CodeGeneratorRequest::add_file_to_generate() {
-  std::string* _s = _internal_add_file_to_generate();
-  // @@protoc_insertion_point(field_add_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-  return _s;
-}
-inline const std::string& CodeGeneratorRequest::_internal_file_to_generate(int index) const {
-  return _impl_.file_to_generate_.Get(index);
-}
-inline const std::string& CodeGeneratorRequest::file_to_generate(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-  return _internal_file_to_generate(index);
-}
-inline std::string* CodeGeneratorRequest::mutable_file_to_generate(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-  return _impl_.file_to_generate_.Mutable(index);
-}
-inline void CodeGeneratorRequest::set_file_to_generate(int index, const std::string& value) {
-  _impl_.file_to_generate_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-}
-inline void CodeGeneratorRequest::set_file_to_generate(int index, std::string&& value) {
-  _impl_.file_to_generate_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-}
-inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.file_to_generate_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-}
-inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value, size_t size) {
-  _impl_.file_to_generate_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-}
-inline std::string* CodeGeneratorRequest::_internal_add_file_to_generate() {
-  return _impl_.file_to_generate_.Add();
-}
-inline void CodeGeneratorRequest::add_file_to_generate(const std::string& value) {
-  _impl_.file_to_generate_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-}
-inline void CodeGeneratorRequest::add_file_to_generate(std::string&& value) {
-  _impl_.file_to_generate_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-}
-inline void CodeGeneratorRequest::add_file_to_generate(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.file_to_generate_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-}
-inline void CodeGeneratorRequest::add_file_to_generate(const char* value, size_t size) {
-  _impl_.file_to_generate_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-CodeGeneratorRequest::file_to_generate() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-  return _impl_.file_to_generate_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-CodeGeneratorRequest::mutable_file_to_generate() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
-  return &_impl_.file_to_generate_;
-}
+    // repeated string file_to_generate = 1;
+    inline int CodeGeneratorRequest::_internal_file_to_generate_size() const
+    {
+        return _impl_.file_to_generate_.size();
+    }
+    inline int CodeGeneratorRequest::file_to_generate_size() const
+    {
+        return _internal_file_to_generate_size();
+    }
+    inline void CodeGeneratorRequest::clear_file_to_generate()
+    {
+        _impl_.file_to_generate_.Clear();
+    }
+    inline std::string* CodeGeneratorRequest::add_file_to_generate()
+    {
+        std::string* _s = _internal_add_file_to_generate();
+        // @@protoc_insertion_point(field_add_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+        return _s;
+    }
+    inline const std::string& CodeGeneratorRequest::_internal_file_to_generate(int index) const
+    {
+        return _impl_.file_to_generate_.Get(index);
+    }
+    inline const std::string& CodeGeneratorRequest::file_to_generate(int index) const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+        return _internal_file_to_generate(index);
+    }
+    inline std::string* CodeGeneratorRequest::mutable_file_to_generate(int index)
+    {
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+        return _impl_.file_to_generate_.Mutable(index);
+    }
+    inline void CodeGeneratorRequest::set_file_to_generate(int index, const std::string& value)
+    {
+        _impl_.file_to_generate_.Mutable(index)->assign(value);
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+    }
+    inline void CodeGeneratorRequest::set_file_to_generate(int index, std::string&& value)
+    {
+        _impl_.file_to_generate_.Mutable(index)->assign(std::move(value));
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+    }
+    inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value)
+    {
+        GOOGLE_DCHECK(value != nullptr);
+        _impl_.file_to_generate_.Mutable(index)->assign(value);
+        // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+    }
+    inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value, size_t size)
+    {
+        _impl_.file_to_generate_.Mutable(index)->assign(
+            reinterpret_cast<const char*>(value), size
+        );
+        // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+    }
+    inline std::string* CodeGeneratorRequest::_internal_add_file_to_generate()
+    {
+        return _impl_.file_to_generate_.Add();
+    }
+    inline void CodeGeneratorRequest::add_file_to_generate(const std::string& value)
+    {
+        _impl_.file_to_generate_.Add()->assign(value);
+        // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+    }
+    inline void CodeGeneratorRequest::add_file_to_generate(std::string&& value)
+    {
+        _impl_.file_to_generate_.Add(std::move(value));
+        // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+    }
+    inline void CodeGeneratorRequest::add_file_to_generate(const char* value)
+    {
+        GOOGLE_DCHECK(value != nullptr);
+        _impl_.file_to_generate_.Add()->assign(value);
+        // @@protoc_insertion_point(field_add_char:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+    }
+    inline void CodeGeneratorRequest::add_file_to_generate(const char* value, size_t size)
+    {
+        _impl_.file_to_generate_.Add()->assign(reinterpret_cast<const char*>(value), size);
+        // @@protoc_insertion_point(field_add_pointer:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+        CodeGeneratorRequest::file_to_generate() const
+    {
+        // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+        return _impl_.file_to_generate_;
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+        CodeGeneratorRequest::mutable_file_to_generate()
+    {
+        // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+        return &_impl_.file_to_generate_;
+    }
 
-// optional string parameter = 2;
-inline bool CodeGeneratorRequest::_internal_has_parameter() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool CodeGeneratorRequest::has_parameter() const {
-  return _internal_has_parameter();
-}
-inline void CodeGeneratorRequest::clear_parameter() {
-  _impl_.parameter_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& CodeGeneratorRequest::parameter() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.parameter)
-  return _internal_parameter();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CodeGeneratorRequest::set_parameter(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.parameter_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.parameter)
-}
-inline std::string* CodeGeneratorRequest::mutable_parameter() {
-  std::string* _s = _internal_mutable_parameter();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.parameter)
-  return _s;
-}
-inline const std::string& CodeGeneratorRequest::_internal_parameter() const {
-  return _impl_.parameter_.Get();
-}
-inline void CodeGeneratorRequest::_internal_set_parameter(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.parameter_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorRequest::_internal_mutable_parameter() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.parameter_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorRequest::release_parameter() {
-  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.parameter)
-  if (!_internal_has_parameter()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.parameter_.Release();
+    // optional string parameter = 2;
+    inline bool CodeGeneratorRequest::_internal_has_parameter() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+        return value;
+    }
+    inline bool CodeGeneratorRequest::has_parameter() const
+    {
+        return _internal_has_parameter();
+    }
+    inline void CodeGeneratorRequest::clear_parameter()
+    {
+        _impl_.parameter_.ClearToEmpty();
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    inline const std::string& CodeGeneratorRequest::parameter() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+        return _internal_parameter();
+    }
+    template<typename ArgT0, typename... ArgT>
+    inline PROTOBUF_ALWAYS_INLINE void CodeGeneratorRequest::set_parameter(ArgT0&& arg0, ArgT... args)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        _impl_.parameter_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+    }
+    inline std::string* CodeGeneratorRequest::mutable_parameter()
+    {
+        std::string* _s = _internal_mutable_parameter();
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+        return _s;
+    }
+    inline const std::string& CodeGeneratorRequest::_internal_parameter() const
+    {
+        return _impl_.parameter_.Get();
+    }
+    inline void CodeGeneratorRequest::_internal_set_parameter(const std::string& value)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        _impl_.parameter_.Set(value, GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorRequest::_internal_mutable_parameter()
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        return _impl_.parameter_.Mutable(GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorRequest::release_parameter()
+    {
+        // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+        if (!_internal_has_parameter())
+        {
+            return nullptr;
+        }
+        _impl_._has_bits_[0] &= ~0x00000001u;
+        auto* p = _impl_.parameter_.Release();
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.parameter_.IsDefault()) {
-    _impl_.parameter_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void CodeGeneratorRequest::set_allocated_parameter(std::string* parameter) {
-  if (parameter != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.parameter_.SetAllocated(parameter, GetArenaForAllocation());
+        if (_impl_.parameter_.IsDefault())
+        {
+            _impl_.parameter_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        return p;
+    }
+    inline void CodeGeneratorRequest::set_allocated_parameter(std::string* parameter)
+    {
+        if (parameter != nullptr)
+        {
+            _impl_._has_bits_[0] |= 0x00000001u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000001u;
+        }
+        _impl_.parameter_.SetAllocated(parameter, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.parameter_.IsDefault()) {
-    _impl_.parameter_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.parameter)
-}
+        if (_impl_.parameter_.IsDefault())
+        {
+            _impl_.parameter_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+    }
 
-// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
-inline int CodeGeneratorRequest::_internal_proto_file_size() const {
-  return _impl_.proto_file_.size();
-}
-inline int CodeGeneratorRequest::proto_file_size() const {
-  return _internal_proto_file_size();
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::mutable_proto_file(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
-  return _impl_.proto_file_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
-CodeGeneratorRequest::mutable_proto_file() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
-  return &_impl_.proto_file_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& CodeGeneratorRequest::_internal_proto_file(int index) const {
-  return _impl_.proto_file_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& CodeGeneratorRequest::proto_file(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
-  return _internal_proto_file(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::_internal_add_proto_file() {
-  return _impl_.proto_file_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::add_proto_file() {
-  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _add = _internal_add_proto_file();
-  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
-CodeGeneratorRequest::proto_file() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
-  return _impl_.proto_file_;
-}
+    // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
+    inline int CodeGeneratorRequest::_internal_proto_file_size() const
+    {
+        return _impl_.proto_file_.size();
+    }
+    inline int CodeGeneratorRequest::proto_file_size() const
+    {
+        return _internal_proto_file_size();
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::mutable_proto_file(int index)
+    {
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+        return _impl_.proto_file_.Mutable(index);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>*
+        CodeGeneratorRequest::mutable_proto_file()
+    {
+        // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+        return &_impl_.proto_file_;
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& CodeGeneratorRequest::_internal_proto_file(int index) const
+    {
+        return _impl_.proto_file_.Get(index);
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& CodeGeneratorRequest::proto_file(int index) const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+        return _internal_proto_file(index);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::_internal_add_proto_file()
+    {
+        return _impl_.proto_file_.Add();
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* CodeGeneratorRequest::add_proto_file()
+    {
+        ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _add = _internal_add_proto_file();
+        // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+        return _add;
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>&
+        CodeGeneratorRequest::proto_file() const
+    {
+        // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+        return _impl_.proto_file_;
+    }
 
-// optional .google.protobuf.compiler.Version compiler_version = 3;
-inline bool CodeGeneratorRequest::_internal_has_compiler_version() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.compiler_version_ != nullptr);
-  return value;
-}
-inline bool CodeGeneratorRequest::has_compiler_version() const {
-  return _internal_has_compiler_version();
-}
-inline void CodeGeneratorRequest::clear_compiler_version() {
-  if (_impl_.compiler_version_ != nullptr) _impl_.compiler_version_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::_internal_compiler_version() const {
-  const ::PROTOBUF_NAMESPACE_ID::compiler::Version* p = _impl_.compiler_version_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::compiler::Version&>(
-      ::PROTOBUF_NAMESPACE_ID::compiler::_Version_default_instance_);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::compiler_version() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
-  return _internal_compiler_version();
-}
-inline void CodeGeneratorRequest::unsafe_arena_set_allocated_compiler_version(
-    ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compiler_version_);
-  }
-  _impl_.compiler_version_ = compiler_version;
-  if (compiler_version) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
-}
-inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::release_compiler_version() {
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::compiler::Version* temp = _impl_.compiler_version_;
-  _impl_.compiler_version_ = nullptr;
+    // optional .google.protobuf.compiler.Version compiler_version = 3;
+    inline bool CodeGeneratorRequest::_internal_has_compiler_version() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+        PROTOBUF_ASSUME(!value || _impl_.compiler_version_ != nullptr);
+        return value;
+    }
+    inline bool CodeGeneratorRequest::has_compiler_version() const
+    {
+        return _internal_has_compiler_version();
+    }
+    inline void CodeGeneratorRequest::clear_compiler_version()
+    {
+        if (_impl_.compiler_version_ != nullptr)
+            _impl_.compiler_version_->Clear();
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::_internal_compiler_version() const
+    {
+        const ::PROTOBUF_NAMESPACE_ID::compiler::Version* p = _impl_.compiler_version_;
+        return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::compiler::Version&>(::PROTOBUF_NAMESPACE_ID::compiler::_Version_default_instance_);
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::compiler::Version& CodeGeneratorRequest::compiler_version() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+        return _internal_compiler_version();
+    }
+    inline void CodeGeneratorRequest::unsafe_arena_set_allocated_compiler_version(
+        ::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version
+    )
+    {
+        if (GetArenaForAllocation() == nullptr)
+        {
+            delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compiler_version_);
+        }
+        _impl_.compiler_version_ = compiler_version;
+        if (compiler_version)
+        {
+            _impl_._has_bits_[0] |= 0x00000002u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000002u;
+        }
+        // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::release_compiler_version()
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+        ::PROTOBUF_NAMESPACE_ID::compiler::Version* temp = _impl_.compiler_version_;
+        _impl_.compiler_version_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
+        auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+        if (GetArenaForAllocation() == nullptr)
+        {
+            delete old;
+        }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+        if (GetArenaForAllocation() != nullptr)
+        {
+            temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+        }
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::unsafe_arena_release_compiler_version() {
-  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::compiler::Version* temp = _impl_.compiler_version_;
-  _impl_.compiler_version_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::_internal_mutable_compiler_version() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  if (_impl_.compiler_version_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(GetArenaForAllocation());
-    _impl_.compiler_version_ = p;
-  }
-  return _impl_.compiler_version_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::mutable_compiler_version() {
-  ::PROTOBUF_NAMESPACE_ID::compiler::Version* _msg = _internal_mutable_compiler_version();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
-  return _msg;
-}
-inline void CodeGeneratorRequest::set_allocated_compiler_version(::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.compiler_version_;
-  }
-  if (compiler_version) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compiler_version);
-    if (message_arena != submessage_arena) {
-      compiler_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, compiler_version, submessage_arena);
-    }
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.compiler_version_ = compiler_version;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
-}
+        return temp;
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::unsafe_arena_release_compiler_version()
+    {
+        // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+        _impl_._has_bits_[0] &= ~0x00000002u;
+        ::PROTOBUF_NAMESPACE_ID::compiler::Version* temp = _impl_.compiler_version_;
+        _impl_.compiler_version_ = nullptr;
+        return temp;
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::_internal_mutable_compiler_version()
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+        if (_impl_.compiler_version_ == nullptr)
+        {
+            auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::compiler::Version>(GetArenaForAllocation());
+            _impl_.compiler_version_ = p;
+        }
+        return _impl_.compiler_version_;
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::compiler::Version* CodeGeneratorRequest::mutable_compiler_version()
+    {
+        ::PROTOBUF_NAMESPACE_ID::compiler::Version* _msg = _internal_mutable_compiler_version();
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+        return _msg;
+    }
+    inline void CodeGeneratorRequest::set_allocated_compiler_version(::PROTOBUF_NAMESPACE_ID::compiler::Version* compiler_version)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+        if (message_arena == nullptr)
+        {
+            delete _impl_.compiler_version_;
+        }
+        if (compiler_version)
+        {
+            ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+                ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compiler_version);
+            if (message_arena != submessage_arena)
+            {
+                compiler_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                    message_arena, compiler_version, submessage_arena
+                );
+            }
+            _impl_._has_bits_[0] |= 0x00000002u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000002u;
+        }
+        _impl_.compiler_version_ = compiler_version;
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+    }
 
-// -------------------------------------------------------------------
+    // -------------------------------------------------------------------
 
-// CodeGeneratorResponse_File
+    // CodeGeneratorResponse_File
 
-// optional string name = 1;
-inline bool CodeGeneratorResponse_File::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool CodeGeneratorResponse_File::has_name() const {
-  return _internal_has_name();
-}
-inline void CodeGeneratorResponse_File::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& CodeGeneratorResponse_File::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CodeGeneratorResponse_File::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.name)
-}
-inline std::string* CodeGeneratorResponse_File::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.name)
-  return _s;
-}
-inline const std::string& CodeGeneratorResponse_File::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void CodeGeneratorResponse_File::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorResponse_File::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorResponse_File::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
+    // optional string name = 1;
+    inline bool CodeGeneratorResponse_File::_internal_has_name() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+        return value;
+    }
+    inline bool CodeGeneratorResponse_File::has_name() const
+    {
+        return _internal_has_name();
+    }
+    inline void CodeGeneratorResponse_File::clear_name()
+    {
+        _impl_.name_.ClearToEmpty();
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    inline const std::string& CodeGeneratorResponse_File::name() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+        return _internal_name();
+    }
+    template<typename ArgT0, typename... ArgT>
+    inline PROTOBUF_ALWAYS_INLINE void CodeGeneratorResponse_File::set_name(ArgT0&& arg0, ArgT... args)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+    }
+    inline std::string* CodeGeneratorResponse_File::mutable_name()
+    {
+        std::string* _s = _internal_mutable_name();
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+        return _s;
+    }
+    inline const std::string& CodeGeneratorResponse_File::_internal_name() const
+    {
+        return _impl_.name_.Get();
+    }
+    inline void CodeGeneratorResponse_File::_internal_set_name(const std::string& value)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        _impl_.name_.Set(value, GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorResponse_File::_internal_mutable_name()
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        return _impl_.name_.Mutable(GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorResponse_File::release_name()
+    {
+        // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+        if (!_internal_has_name())
+        {
+            return nullptr;
+        }
+        _impl_._has_bits_[0] &= ~0x00000001u;
+        auto* p = _impl_.name_.Release();
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void CodeGeneratorResponse_File::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+        if (_impl_.name_.IsDefault())
+        {
+            _impl_.name_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        return p;
+    }
+    inline void CodeGeneratorResponse_File::set_allocated_name(std::string* name)
+    {
+        if (name != nullptr)
+        {
+            _impl_._has_bits_[0] |= 0x00000001u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000001u;
+        }
+        _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.name)
-}
+        if (_impl_.name_.IsDefault())
+        {
+            _impl_.name_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+    }
 
-// optional string insertion_point = 2;
-inline bool CodeGeneratorResponse_File::_internal_has_insertion_point() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool CodeGeneratorResponse_File::has_insertion_point() const {
-  return _internal_has_insertion_point();
-}
-inline void CodeGeneratorResponse_File::clear_insertion_point() {
-  _impl_.insertion_point_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& CodeGeneratorResponse_File::insertion_point() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
-  return _internal_insertion_point();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CodeGeneratorResponse_File::set_insertion_point(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000002u;
- _impl_.insertion_point_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
-}
-inline std::string* CodeGeneratorResponse_File::mutable_insertion_point() {
-  std::string* _s = _internal_mutable_insertion_point();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
-  return _s;
-}
-inline const std::string& CodeGeneratorResponse_File::_internal_insertion_point() const {
-  return _impl_.insertion_point_.Get();
-}
-inline void CodeGeneratorResponse_File::_internal_set_insertion_point(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.insertion_point_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorResponse_File::_internal_mutable_insertion_point() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  return _impl_.insertion_point_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorResponse_File::release_insertion_point() {
-  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
-  if (!_internal_has_insertion_point()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  auto* p = _impl_.insertion_point_.Release();
+    // optional string insertion_point = 2;
+    inline bool CodeGeneratorResponse_File::_internal_has_insertion_point() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+        return value;
+    }
+    inline bool CodeGeneratorResponse_File::has_insertion_point() const
+    {
+        return _internal_has_insertion_point();
+    }
+    inline void CodeGeneratorResponse_File::clear_insertion_point()
+    {
+        _impl_.insertion_point_.ClearToEmpty();
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    inline const std::string& CodeGeneratorResponse_File::insertion_point() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+        return _internal_insertion_point();
+    }
+    template<typename ArgT0, typename... ArgT>
+    inline PROTOBUF_ALWAYS_INLINE void CodeGeneratorResponse_File::set_insertion_point(ArgT0&& arg0, ArgT... args)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+        _impl_.insertion_point_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+    }
+    inline std::string* CodeGeneratorResponse_File::mutable_insertion_point()
+    {
+        std::string* _s = _internal_mutable_insertion_point();
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+        return _s;
+    }
+    inline const std::string& CodeGeneratorResponse_File::_internal_insertion_point() const
+    {
+        return _impl_.insertion_point_.Get();
+    }
+    inline void CodeGeneratorResponse_File::_internal_set_insertion_point(const std::string& value)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+        _impl_.insertion_point_.Set(value, GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorResponse_File::_internal_mutable_insertion_point()
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+        return _impl_.insertion_point_.Mutable(GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorResponse_File::release_insertion_point()
+    {
+        // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+        if (!_internal_has_insertion_point())
+        {
+            return nullptr;
+        }
+        _impl_._has_bits_[0] &= ~0x00000002u;
+        auto* p = _impl_.insertion_point_.Release();
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.insertion_point_.IsDefault()) {
-    _impl_.insertion_point_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void CodeGeneratorResponse_File::set_allocated_insertion_point(std::string* insertion_point) {
-  if (insertion_point != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.insertion_point_.SetAllocated(insertion_point, GetArenaForAllocation());
+        if (_impl_.insertion_point_.IsDefault())
+        {
+            _impl_.insertion_point_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        return p;
+    }
+    inline void CodeGeneratorResponse_File::set_allocated_insertion_point(std::string* insertion_point)
+    {
+        if (insertion_point != nullptr)
+        {
+            _impl_._has_bits_[0] |= 0x00000002u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000002u;
+        }
+        _impl_.insertion_point_.SetAllocated(insertion_point, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.insertion_point_.IsDefault()) {
-    _impl_.insertion_point_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
-}
+        if (_impl_.insertion_point_.IsDefault())
+        {
+            _impl_.insertion_point_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+    }
 
-// optional string content = 15;
-inline bool CodeGeneratorResponse_File::_internal_has_content() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool CodeGeneratorResponse_File::has_content() const {
-  return _internal_has_content();
-}
-inline void CodeGeneratorResponse_File::clear_content() {
-  _impl_.content_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& CodeGeneratorResponse_File::content() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.content)
-  return _internal_content();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CodeGeneratorResponse_File::set_content(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000004u;
- _impl_.content_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.content)
-}
-inline std::string* CodeGeneratorResponse_File::mutable_content() {
-  std::string* _s = _internal_mutable_content();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.content)
-  return _s;
-}
-inline const std::string& CodeGeneratorResponse_File::_internal_content() const {
-  return _impl_.content_.Get();
-}
-inline void CodeGeneratorResponse_File::_internal_set_content(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.content_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorResponse_File::_internal_mutable_content() {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  return _impl_.content_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorResponse_File::release_content() {
-  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.content)
-  if (!_internal_has_content()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000004u;
-  auto* p = _impl_.content_.Release();
+    // optional string content = 15;
+    inline bool CodeGeneratorResponse_File::_internal_has_content() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+        return value;
+    }
+    inline bool CodeGeneratorResponse_File::has_content() const
+    {
+        return _internal_has_content();
+    }
+    inline void CodeGeneratorResponse_File::clear_content()
+    {
+        _impl_.content_.ClearToEmpty();
+        _impl_._has_bits_[0] &= ~0x00000004u;
+    }
+    inline const std::string& CodeGeneratorResponse_File::content() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+        return _internal_content();
+    }
+    template<typename ArgT0, typename... ArgT>
+    inline PROTOBUF_ALWAYS_INLINE void CodeGeneratorResponse_File::set_content(ArgT0&& arg0, ArgT... args)
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+        _impl_.content_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+    }
+    inline std::string* CodeGeneratorResponse_File::mutable_content()
+    {
+        std::string* _s = _internal_mutable_content();
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+        return _s;
+    }
+    inline const std::string& CodeGeneratorResponse_File::_internal_content() const
+    {
+        return _impl_.content_.Get();
+    }
+    inline void CodeGeneratorResponse_File::_internal_set_content(const std::string& value)
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+        _impl_.content_.Set(value, GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorResponse_File::_internal_mutable_content()
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+        return _impl_.content_.Mutable(GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorResponse_File::release_content()
+    {
+        // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+        if (!_internal_has_content())
+        {
+            return nullptr;
+        }
+        _impl_._has_bits_[0] &= ~0x00000004u;
+        auto* p = _impl_.content_.Release();
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.content_.IsDefault()) {
-    _impl_.content_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void CodeGeneratorResponse_File::set_allocated_content(std::string* content) {
-  if (content != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000004u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000004u;
-  }
-  _impl_.content_.SetAllocated(content, GetArenaForAllocation());
+        if (_impl_.content_.IsDefault())
+        {
+            _impl_.content_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        return p;
+    }
+    inline void CodeGeneratorResponse_File::set_allocated_content(std::string* content)
+    {
+        if (content != nullptr)
+        {
+            _impl_._has_bits_[0] |= 0x00000004u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000004u;
+        }
+        _impl_.content_.SetAllocated(content, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.content_.IsDefault()) {
-    _impl_.content_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.content)
-}
+        if (_impl_.content_.IsDefault())
+        {
+            _impl_.content_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+    }
 
-// optional .google.protobuf.GeneratedCodeInfo generated_code_info = 16;
-inline bool CodeGeneratorResponse_File::_internal_has_generated_code_info() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.generated_code_info_ != nullptr);
-  return value;
-}
-inline bool CodeGeneratorResponse_File::has_generated_code_info() const {
-  return _internal_has_generated_code_info();
-}
-inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& CodeGeneratorResponse_File::_internal_generated_code_info() const {
-  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* p = _impl_.generated_code_info_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo&>(
-      ::PROTOBUF_NAMESPACE_ID::_GeneratedCodeInfo_default_instance_);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& CodeGeneratorResponse_File::generated_code_info() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
-  return _internal_generated_code_info();
-}
-inline void CodeGeneratorResponse_File::unsafe_arena_set_allocated_generated_code_info(
-    ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.generated_code_info_);
-  }
-  _impl_.generated_code_info_ = generated_code_info;
-  if (generated_code_info) {
-    _impl_._has_bits_[0] |= 0x00000008u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000008u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
-}
-inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::release_generated_code_info() {
-  _impl_._has_bits_[0] &= ~0x00000008u;
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* temp = _impl_.generated_code_info_;
-  _impl_.generated_code_info_ = nullptr;
+    // optional .google.protobuf.GeneratedCodeInfo generated_code_info = 16;
+    inline bool CodeGeneratorResponse_File::_internal_has_generated_code_info() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+        PROTOBUF_ASSUME(!value || _impl_.generated_code_info_ != nullptr);
+        return value;
+    }
+    inline bool CodeGeneratorResponse_File::has_generated_code_info() const
+    {
+        return _internal_has_generated_code_info();
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& CodeGeneratorResponse_File::_internal_generated_code_info() const
+    {
+        const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* p = _impl_.generated_code_info_;
+        return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo&>(::PROTOBUF_NAMESPACE_ID::_GeneratedCodeInfo_default_instance_);
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo& CodeGeneratorResponse_File::generated_code_info() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+        return _internal_generated_code_info();
+    }
+    inline void CodeGeneratorResponse_File::unsafe_arena_set_allocated_generated_code_info(
+        ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info
+    )
+    {
+        if (GetArenaForAllocation() == nullptr)
+        {
+            delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.generated_code_info_);
+        }
+        _impl_.generated_code_info_ = generated_code_info;
+        if (generated_code_info)
+        {
+            _impl_._has_bits_[0] |= 0x00000008u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000008u;
+        }
+        // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::release_generated_code_info()
+    {
+        _impl_._has_bits_[0] &= ~0x00000008u;
+        ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* temp = _impl_.generated_code_info_;
+        _impl_.generated_code_info_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
-    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
+        auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+        if (GetArenaForAllocation() == nullptr)
+        {
+            delete old;
+        }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+        if (GetArenaForAllocation() != nullptr)
+        {
+            temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+        }
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::unsafe_arena_release_generated_code_info() {
-  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
-  _impl_._has_bits_[0] &= ~0x00000008u;
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* temp = _impl_.generated_code_info_;
-  _impl_.generated_code_info_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::_internal_mutable_generated_code_info() {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  if (_impl_.generated_code_info_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(GetArenaForAllocation());
-    _impl_.generated_code_info_ = p;
-  }
-  return _impl_.generated_code_info_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::mutable_generated_code_info() {
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* _msg = _internal_mutable_generated_code_info();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
-  return _msg;
-}
-inline void CodeGeneratorResponse_File::set_allocated_generated_code_info(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.generated_code_info_);
-  }
-  if (generated_code_info) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
-                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(generated_code_info));
-    if (message_arena != submessage_arena) {
-      generated_code_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, generated_code_info, submessage_arena);
-    }
-    _impl_._has_bits_[0] |= 0x00000008u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000008u;
-  }
-  _impl_.generated_code_info_ = generated_code_info;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
-}
+        return temp;
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::unsafe_arena_release_generated_code_info()
+    {
+        // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+        _impl_._has_bits_[0] &= ~0x00000008u;
+        ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* temp = _impl_.generated_code_info_;
+        _impl_.generated_code_info_ = nullptr;
+        return temp;
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::_internal_mutable_generated_code_info()
+    {
+        _impl_._has_bits_[0] |= 0x00000008u;
+        if (_impl_.generated_code_info_ == nullptr)
+        {
+            auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(GetArenaForAllocation());
+            _impl_.generated_code_info_ = p;
+        }
+        return _impl_.generated_code_info_;
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* CodeGeneratorResponse_File::mutable_generated_code_info()
+    {
+        ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* _msg = _internal_mutable_generated_code_info();
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+        return _msg;
+    }
+    inline void CodeGeneratorResponse_File::set_allocated_generated_code_info(::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* generated_code_info)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+        if (message_arena == nullptr)
+        {
+            delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.generated_code_info_);
+        }
+        if (generated_code_info)
+        {
+            ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+                ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                    reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(generated_code_info)
+                );
+            if (message_arena != submessage_arena)
+            {
+                generated_code_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                    message_arena, generated_code_info, submessage_arena
+                );
+            }
+            _impl_._has_bits_[0] |= 0x00000008u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000008u;
+        }
+        _impl_.generated_code_info_ = generated_code_info;
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.generated_code_info)
+    }
 
-// -------------------------------------------------------------------
+    // -------------------------------------------------------------------
 
-// CodeGeneratorResponse
+    // CodeGeneratorResponse
 
-// optional string error = 1;
-inline bool CodeGeneratorResponse::_internal_has_error() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool CodeGeneratorResponse::has_error() const {
-  return _internal_has_error();
-}
-inline void CodeGeneratorResponse::clear_error() {
-  _impl_.error_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& CodeGeneratorResponse::error() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.error)
-  return _internal_error();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void CodeGeneratorResponse::set_error(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.error_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.error)
-}
-inline std::string* CodeGeneratorResponse::mutable_error() {
-  std::string* _s = _internal_mutable_error();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.error)
-  return _s;
-}
-inline const std::string& CodeGeneratorResponse::_internal_error() const {
-  return _impl_.error_.Get();
-}
-inline void CodeGeneratorResponse::_internal_set_error(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.error_.Set(value, GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorResponse::_internal_mutable_error() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.error_.Mutable(GetArenaForAllocation());
-}
-inline std::string* CodeGeneratorResponse::release_error() {
-  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.error)
-  if (!_internal_has_error()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.error_.Release();
+    // optional string error = 1;
+    inline bool CodeGeneratorResponse::_internal_has_error() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+        return value;
+    }
+    inline bool CodeGeneratorResponse::has_error() const
+    {
+        return _internal_has_error();
+    }
+    inline void CodeGeneratorResponse::clear_error()
+    {
+        _impl_.error_.ClearToEmpty();
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    inline const std::string& CodeGeneratorResponse::error() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.error)
+        return _internal_error();
+    }
+    template<typename ArgT0, typename... ArgT>
+    inline PROTOBUF_ALWAYS_INLINE void CodeGeneratorResponse::set_error(ArgT0&& arg0, ArgT... args)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        _impl_.error_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.error)
+    }
+    inline std::string* CodeGeneratorResponse::mutable_error()
+    {
+        std::string* _s = _internal_mutable_error();
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.error)
+        return _s;
+    }
+    inline const std::string& CodeGeneratorResponse::_internal_error() const
+    {
+        return _impl_.error_.Get();
+    }
+    inline void CodeGeneratorResponse::_internal_set_error(const std::string& value)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        _impl_.error_.Set(value, GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorResponse::_internal_mutable_error()
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+        return _impl_.error_.Mutable(GetArenaForAllocation());
+    }
+    inline std::string* CodeGeneratorResponse::release_error()
+    {
+        // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.error)
+        if (!_internal_has_error())
+        {
+            return nullptr;
+        }
+        _impl_._has_bits_[0] &= ~0x00000001u;
+        auto* p = _impl_.error_.Release();
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.error_.IsDefault()) {
-    _impl_.error_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void CodeGeneratorResponse::set_allocated_error(std::string* error) {
-  if (error != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.error_.SetAllocated(error, GetArenaForAllocation());
+        if (_impl_.error_.IsDefault())
+        {
+            _impl_.error_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        return p;
+    }
+    inline void CodeGeneratorResponse::set_allocated_error(std::string* error)
+    {
+        if (error != nullptr)
+        {
+            _impl_._has_bits_[0] |= 0x00000001u;
+        }
+        else
+        {
+            _impl_._has_bits_[0] &= ~0x00000001u;
+        }
+        _impl_.error_.SetAllocated(error, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.error_.IsDefault()) {
-    _impl_.error_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.error)
-}
+        if (_impl_.error_.IsDefault())
+        {
+            _impl_.error_.Set("", GetArenaForAllocation());
+        }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.error)
+    }
 
-// optional uint64 supported_features = 2;
-inline bool CodeGeneratorResponse::_internal_has_supported_features() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool CodeGeneratorResponse::has_supported_features() const {
-  return _internal_has_supported_features();
-}
-inline void CodeGeneratorResponse::clear_supported_features() {
-  _impl_.supported_features_ = uint64_t{0u};
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline uint64_t CodeGeneratorResponse::_internal_supported_features() const {
-  return _impl_.supported_features_;
-}
-inline uint64_t CodeGeneratorResponse::supported_features() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.supported_features)
-  return _internal_supported_features();
-}
-inline void CodeGeneratorResponse::_internal_set_supported_features(uint64_t value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.supported_features_ = value;
-}
-inline void CodeGeneratorResponse::set_supported_features(uint64_t value) {
-  _internal_set_supported_features(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.supported_features)
-}
+    // optional uint64 supported_features = 2;
+    inline bool CodeGeneratorResponse::_internal_has_supported_features() const
+    {
+        bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+        return value;
+    }
+    inline bool CodeGeneratorResponse::has_supported_features() const
+    {
+        return _internal_has_supported_features();
+    }
+    inline void CodeGeneratorResponse::clear_supported_features()
+    {
+        _impl_.supported_features_ = uint64_t{0u};
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    inline uint64_t CodeGeneratorResponse::_internal_supported_features() const
+    {
+        return _impl_.supported_features_;
+    }
+    inline uint64_t CodeGeneratorResponse::supported_features() const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.supported_features)
+        return _internal_supported_features();
+    }
+    inline void CodeGeneratorResponse::_internal_set_supported_features(uint64_t value)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+        _impl_.supported_features_ = value;
+    }
+    inline void CodeGeneratorResponse::set_supported_features(uint64_t value)
+    {
+        _internal_set_supported_features(value);
+        // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.supported_features)
+    }
 
-// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
-inline int CodeGeneratorResponse::_internal_file_size() const {
-  return _impl_.file_.size();
-}
-inline int CodeGeneratorResponse::file_size() const {
-  return _internal_file_size();
-}
-inline void CodeGeneratorResponse::clear_file() {
-  _impl_.file_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::mutable_file(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.file)
-  return _impl_.file_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >*
-CodeGeneratorResponse::mutable_file() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorResponse.file)
-  return &_impl_.file_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::_internal_file(int index) const {
-  return _impl_.file_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::file(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.file)
-  return _internal_file(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::_internal_add_file() {
-  return _impl_.file_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::add_file() {
-  ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* _add = _internal_add_file();
-  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorResponse.file)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File >&
-CodeGeneratorResponse::file() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorResponse.file)
-  return _impl_.file_;
-}
+    // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
+    inline int CodeGeneratorResponse::_internal_file_size() const
+    {
+        return _impl_.file_.size();
+    }
+    inline int CodeGeneratorResponse::file_size() const
+    {
+        return _internal_file_size();
+    }
+    inline void CodeGeneratorResponse::clear_file()
+    {
+        _impl_.file_.Clear();
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::mutable_file(int index)
+    {
+        // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.file)
+        return _impl_.file_.Mutable(index);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>*
+        CodeGeneratorResponse::mutable_file()
+    {
+        // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorResponse.file)
+        return &_impl_.file_;
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::_internal_file(int index) const
+    {
+        return _impl_.file_.Get(index);
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::file(int index) const
+    {
+        // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.file)
+        return _internal_file(index);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::_internal_add_file()
+    {
+        return _impl_.file_.Add();
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::add_file()
+    {
+        ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File* _add = _internal_add_file();
+        // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorResponse.file)
+        return _add;
+    }
+    inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_File>&
+        CodeGeneratorResponse::file() const
+    {
+        // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorResponse.file)
+        return _impl_.file_;
+    }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
-// -------------------------------------------------------------------
+    // -------------------------------------------------------------------
 
-// -------------------------------------------------------------------
+    // -------------------------------------------------------------------
 
-// -------------------------------------------------------------------
+    // -------------------------------------------------------------------
 
-
-// @@protoc_insertion_point(namespace_scope)
+    // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace compiler
 PROTOBUF_NAMESPACE_CLOSE
 
 PROTOBUF_NAMESPACE_OPEN
 
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature>() {
-  return ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature_descriptor();
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::compiler::CodeGeneratorResponse_Feature_descriptor();
 }
 
 PROTOBUF_NAMESPACE_CLOSE
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/python/generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/generator.h
index f1fecbc..c6b7243 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/python/generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/generator.h
@@ -43,141 +43,138 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-class Descriptor;
-class EnumDescriptor;
-class EnumValueDescriptor;
-class FieldDescriptor;
-class OneofDescriptor;
-class ServiceDescriptor;
-
-namespace io {
-class Printer;
-}
-
-namespace compiler {
-namespace python {
-
-// CodeGenerator implementation for generated Python protocol buffer classes.
-// If you create your own protocol compiler binary and you want it to support
-// Python output, you can do so by registering an instance of this
-// CodeGenerator with the CommandLineInterface in your main() function.
-class PROTOC_EXPORT Generator : public CodeGenerator {
- public:
-  Generator();
-  ~Generator() override;
-
-  // CodeGenerator methods.
-  bool Generate(const FileDescriptor* file, const std::string& parameter,
-                GeneratorContext* generator_context,
-                std::string* error) const override;
-
-  uint64_t GetSupportedFeatures() const override;
-
- private:
-  void PrintImports() const;
-  void PrintFileDescriptor() const;
-  void PrintAllNestedEnumsInFile() const;
-  void PrintNestedEnums(const Descriptor& descriptor) const;
-  void PrintEnum(const EnumDescriptor& enum_descriptor) const;
-
-  void PrintFieldDescriptor(const FieldDescriptor& field,
-                            bool is_extension) const;
-  void PrintFieldDescriptorsInDescriptor(
-      const Descriptor& message_descriptor, bool is_extension,
-      const std::string& list_variable_name, int (Descriptor::*CountFn)() const,
-      const FieldDescriptor* (Descriptor::*GetterFn)(int)const) const;
-  void PrintFieldsInDescriptor(const Descriptor& message_descriptor) const;
-  void PrintExtensionsInDescriptor(const Descriptor& message_descriptor) const;
-  void PrintMessageDescriptors() const;
-  void PrintDescriptor(const Descriptor& message_descriptor) const;
-  void PrintNestedDescriptors(const Descriptor& containing_descriptor) const;
-
-  void PrintMessages() const;
-  void PrintMessage(const Descriptor& message_descriptor,
-                    const std::string& prefix,
-                    std::vector<std::string>* to_register,
-                    bool is_nested) const;
-  void PrintNestedMessages(const Descriptor& containing_descriptor,
-                           const std::string& prefix,
-                           std::vector<std::string>* to_register) const;
-
-  void FixForeignFieldsInDescriptors() const;
-  void FixForeignFieldsInDescriptor(
-      const Descriptor& descriptor,
-      const Descriptor* containing_descriptor) const;
-  void FixForeignFieldsInField(const Descriptor* containing_type,
-                               const FieldDescriptor& field,
-                               const std::string& python_dict_name) const;
-  void AddMessageToFileDescriptor(const Descriptor& descriptor) const;
-  void AddEnumToFileDescriptor(const EnumDescriptor& descriptor) const;
-  void AddExtensionToFileDescriptor(const FieldDescriptor& descriptor) const;
-  void AddServiceToFileDescriptor(const ServiceDescriptor& descriptor) const;
-  std::string FieldReferencingExpression(
-      const Descriptor* containing_type, const FieldDescriptor& field,
-      const std::string& python_dict_name) const;
-  template <typename DescriptorT>
-  void FixContainingTypeInDescriptor(
-      const DescriptorT& descriptor,
-      const Descriptor* containing_descriptor) const;
-
-  void FixForeignFieldsInExtensions() const;
-  void FixForeignFieldsInExtension(
-      const FieldDescriptor& extension_field) const;
-  void FixForeignFieldsInNestedExtensions(const Descriptor& descriptor) const;
-
-  void PrintServices() const;
-  void PrintServiceDescriptors() const;
-  void PrintServiceDescriptor(const ServiceDescriptor& descriptor) const;
-  void PrintServiceClass(const ServiceDescriptor& descriptor) const;
-  void PrintServiceStub(const ServiceDescriptor& descriptor) const;
-  void PrintDescriptorKeyAndModuleName(
-      const ServiceDescriptor& descriptor) const;
-
-  void PrintEnumValueDescriptor(const EnumValueDescriptor& descriptor) const;
-  std::string OptionsValue(const std::string& serialized_options) const;
-  bool GeneratingDescriptorProto() const;
-
-  template <typename DescriptorT>
-  std::string ModuleLevelDescriptorName(const DescriptorT& descriptor) const;
-  std::string ModuleLevelMessageName(const Descriptor& descriptor) const;
-  std::string ModuleLevelServiceDescriptorName(
-      const ServiceDescriptor& descriptor) const;
-
-  template <typename DescriptorT, typename DescriptorProtoT>
-  void PrintSerializedPbInterval(const DescriptorT& descriptor,
-                                 DescriptorProtoT& proto,
-                                 const std::string& name) const;
-
-  void FixAllDescriptorOptions() const;
-  void FixOptionsForField(const FieldDescriptor& field) const;
-  void FixOptionsForOneof(const OneofDescriptor& oneof) const;
-  void FixOptionsForEnum(const EnumDescriptor& descriptor) const;
-  void FixOptionsForService(const ServiceDescriptor& descriptor) const;
-  void FixOptionsForMessage(const Descriptor& descriptor) const;
-
-  void SetSerializedPbInterval() const;
-  void SetMessagePbInterval(const Descriptor& descriptor) const;
-
-  void CopyPublicDependenciesAliases(const std::string& copy_from,
-                                     const FileDescriptor* file) const;
-
-  // Very coarse-grained lock to ensure that Generate() is reentrant.
-  // Guards file_, printer_ and file_descriptor_serialized_.
-  mutable Mutex mutex_;
-  mutable const FileDescriptor* file_;  // Set in Generate().  Under mutex_.
-  mutable std::string file_descriptor_serialized_;
-  mutable io::Printer* printer_;  // Set in Generate().  Under mutex_.
-  mutable bool pure_python_workable_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Generator);
-};
-
-}  // namespace python
-}  // namespace compiler
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Descriptor;
+        class EnumDescriptor;
+        class EnumValueDescriptor;
+        class FieldDescriptor;
+        class OneofDescriptor;
+        class ServiceDescriptor;
+
+        namespace io
+        {
+            class Printer;
+        }
+
+        namespace compiler
+        {
+            namespace python
+            {
+
+                // CodeGenerator implementation for generated Python protocol buffer classes.
+                // If you create your own protocol compiler binary and you want it to support
+                // Python output, you can do so by registering an instance of this
+                // CodeGenerator with the CommandLineInterface in your main() function.
+                class PROTOC_EXPORT Generator : public CodeGenerator
+                {
+                public:
+                    Generator();
+                    ~Generator() override;
+
+                    // CodeGenerator methods.
+                    bool Generate(const FileDescriptor* file, const std::string& parameter, GeneratorContext* generator_context, std::string* error) const override;
+
+                    uint64_t GetSupportedFeatures() const override;
+
+                private:
+                    void PrintImports() const;
+                    void PrintFileDescriptor() const;
+                    void PrintAllNestedEnumsInFile() const;
+                    void PrintNestedEnums(const Descriptor& descriptor) const;
+                    void PrintEnum(const EnumDescriptor& enum_descriptor) const;
+
+                    void PrintFieldDescriptor(const FieldDescriptor& field, bool is_extension) const;
+                    void PrintFieldDescriptorsInDescriptor(
+                        const Descriptor& message_descriptor, bool is_extension, const std::string& list_variable_name, int (Descriptor::*CountFn)() const, const FieldDescriptor* (Descriptor::*GetterFn)(int) const
+                    ) const;
+                    void PrintFieldsInDescriptor(const Descriptor& message_descriptor) const;
+                    void PrintExtensionsInDescriptor(const Descriptor& message_descriptor) const;
+                    void PrintMessageDescriptors() const;
+                    void PrintDescriptor(const Descriptor& message_descriptor) const;
+                    void PrintNestedDescriptors(const Descriptor& containing_descriptor) const;
+
+                    void PrintMessages() const;
+                    void PrintMessage(const Descriptor& message_descriptor, const std::string& prefix, std::vector<std::string>* to_register, bool is_nested) const;
+                    void PrintNestedMessages(const Descriptor& containing_descriptor, const std::string& prefix, std::vector<std::string>* to_register) const;
+
+                    void FixForeignFieldsInDescriptors() const;
+                    void FixForeignFieldsInDescriptor(
+                        const Descriptor& descriptor,
+                        const Descriptor* containing_descriptor
+                    ) const;
+                    void FixForeignFieldsInField(const Descriptor* containing_type, const FieldDescriptor& field, const std::string& python_dict_name) const;
+                    void AddMessageToFileDescriptor(const Descriptor& descriptor) const;
+                    void AddEnumToFileDescriptor(const EnumDescriptor& descriptor) const;
+                    void AddExtensionToFileDescriptor(const FieldDescriptor& descriptor) const;
+                    void AddServiceToFileDescriptor(const ServiceDescriptor& descriptor) const;
+                    std::string FieldReferencingExpression(
+                        const Descriptor* containing_type, const FieldDescriptor& field, const std::string& python_dict_name
+                    ) const;
+                    template<typename DescriptorT>
+                    void FixContainingTypeInDescriptor(
+                        const DescriptorT& descriptor,
+                        const Descriptor* containing_descriptor
+                    ) const;
+
+                    void FixForeignFieldsInExtensions() const;
+                    void FixForeignFieldsInExtension(
+                        const FieldDescriptor& extension_field
+                    ) const;
+                    void FixForeignFieldsInNestedExtensions(const Descriptor& descriptor) const;
+
+                    void PrintServices() const;
+                    void PrintServiceDescriptors() const;
+                    void PrintServiceDescriptor(const ServiceDescriptor& descriptor) const;
+                    void PrintServiceClass(const ServiceDescriptor& descriptor) const;
+                    void PrintServiceStub(const ServiceDescriptor& descriptor) const;
+                    void PrintDescriptorKeyAndModuleName(
+                        const ServiceDescriptor& descriptor
+                    ) const;
+
+                    void PrintEnumValueDescriptor(const EnumValueDescriptor& descriptor) const;
+                    std::string OptionsValue(const std::string& serialized_options) const;
+                    bool GeneratingDescriptorProto() const;
+
+                    template<typename DescriptorT>
+                    std::string ModuleLevelDescriptorName(const DescriptorT& descriptor) const;
+                    std::string ModuleLevelMessageName(const Descriptor& descriptor) const;
+                    std::string ModuleLevelServiceDescriptorName(
+                        const ServiceDescriptor& descriptor
+                    ) const;
+
+                    template<typename DescriptorT, typename DescriptorProtoT>
+                    void PrintSerializedPbInterval(const DescriptorT& descriptor, DescriptorProtoT& proto, const std::string& name) const;
+
+                    void FixAllDescriptorOptions() const;
+                    void FixOptionsForField(const FieldDescriptor& field) const;
+                    void FixOptionsForOneof(const OneofDescriptor& oneof) const;
+                    void FixOptionsForEnum(const EnumDescriptor& descriptor) const;
+                    void FixOptionsForService(const ServiceDescriptor& descriptor) const;
+                    void FixOptionsForMessage(const Descriptor& descriptor) const;
+
+                    void SetSerializedPbInterval() const;
+                    void SetMessagePbInterval(const Descriptor& descriptor) const;
+
+                    void CopyPublicDependenciesAliases(const std::string& copy_from, const FileDescriptor* file) const;
+
+                    // Very coarse-grained lock to ensure that Generate() is reentrant.
+                    // Guards file_, printer_ and file_descriptor_serialized_.
+                    mutable Mutex mutex_;
+                    mutable const FileDescriptor* file_;  // Set in Generate().  Under mutex_.
+                    mutable std::string file_descriptor_serialized_;
+                    mutable io::Printer* printer_;  // Set in Generate().  Under mutex_.
+                    mutable bool pure_python_workable_;
+
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Generator);
+                };
+
+            }  // namespace python
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/python/pyi_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/pyi_generator.h
index 9611ed4..ac02dd6 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/python/pyi_generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/python/pyi_generator.h
@@ -45,74 +45,74 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-class Descriptor;
-class EnumDescriptor;
-class FieldDescriptor;
-class MethodDescriptor;
-class ServiceDescriptor;
+namespace google
+{
+    namespace protobuf
+    {
+        class Descriptor;
+        class EnumDescriptor;
+        class FieldDescriptor;
+        class MethodDescriptor;
+        class ServiceDescriptor;
 
-namespace io {
-class Printer;
-}
+        namespace io
+        {
+            class Printer;
+        }
 
-namespace compiler {
-namespace python {
+        namespace compiler
+        {
+            namespace python
+            {
 
-class PROTOC_EXPORT PyiGenerator : public google::protobuf::compiler::CodeGenerator {
- public:
-  PyiGenerator();
-  ~PyiGenerator() override;
+                class PROTOC_EXPORT PyiGenerator : public google::protobuf::compiler::CodeGenerator
+                {
+                public:
+                    PyiGenerator();
+                    ~PyiGenerator() override;
 
-  // CodeGenerator methods.
-  uint64_t GetSupportedFeatures() const override {
-    // Code generators must explicitly support proto3 optional.
-    return CodeGenerator::FEATURE_PROTO3_OPTIONAL;
-  }
-  bool Generate(const FileDescriptor* file, const std::string& parameter,
-                GeneratorContext* generator_context,
-                std::string* error) const override;
+                    // CodeGenerator methods.
+                    uint64_t GetSupportedFeatures() const override
+                    {
+                        // Code generators must explicitly support proto3 optional.
+                        return CodeGenerator::FEATURE_PROTO3_OPTIONAL;
+                    }
+                    bool Generate(const FileDescriptor* file, const std::string& parameter, GeneratorContext* generator_context, std::string* error) const override;
 
- private:
-  void PrintImportForDescriptor(const FileDescriptor& desc,
-                                std::map<std::string, std::string>* import_map,
-                                std::set<std::string>* seen_aliases) const;
-  void PrintImports(std::map<std::string, std::string>* item_map,
-                    std::map<std::string, std::string>* import_map) const;
-  void PrintEnum(const EnumDescriptor& enum_descriptor) const;
-  void AddEnumValue(const EnumDescriptor& enum_descriptor,
-                    std::map<std::string, std::string>* item_map,
-                    const std::map<std::string, std::string>& import_map) const;
-  void PrintTopLevelEnums() const;
-  template <typename DescriptorT>
-  void AddExtensions(const DescriptorT& descriptor,
-                     std::map<std::string, std::string>* item_map) const;
-  void PrintMessages(
-      const std::map<std::string, std::string>& import_map) const;
-  void PrintMessage(const Descriptor& message_descriptor, bool is_nested,
-                    const std::map<std::string, std::string>& import_map) const;
-  void PrintServices() const;
-  void PrintItemMap(const std::map<std::string, std::string>& item_map) const;
-  std::string GetFieldType(
-      const FieldDescriptor& field_des, const Descriptor& containing_des,
-      const std::map<std::string, std::string>& import_map) const;
-  template <typename DescriptorT>
-  std::string ModuleLevelName(
-      const DescriptorT& descriptor,
-      const std::map<std::string, std::string>& import_map) const;
+                private:
+                    void PrintImportForDescriptor(const FileDescriptor& desc, std::map<std::string, std::string>* import_map, std::set<std::string>* seen_aliases) const;
+                    void PrintImports(std::map<std::string, std::string>* item_map, std::map<std::string, std::string>* import_map) const;
+                    void PrintEnum(const EnumDescriptor& enum_descriptor) const;
+                    void AddEnumValue(const EnumDescriptor& enum_descriptor, std::map<std::string, std::string>* item_map, const std::map<std::string, std::string>& import_map) const;
+                    void PrintTopLevelEnums() const;
+                    template<typename DescriptorT>
+                    void AddExtensions(const DescriptorT& descriptor, std::map<std::string, std::string>* item_map) const;
+                    void PrintMessages(
+                        const std::map<std::string, std::string>& import_map
+                    ) const;
+                    void PrintMessage(const Descriptor& message_descriptor, bool is_nested, const std::map<std::string, std::string>& import_map) const;
+                    void PrintServices() const;
+                    void PrintItemMap(const std::map<std::string, std::string>& item_map) const;
+                    std::string GetFieldType(
+                        const FieldDescriptor& field_des, const Descriptor& containing_des, const std::map<std::string, std::string>& import_map
+                    ) const;
+                    template<typename DescriptorT>
+                    std::string ModuleLevelName(
+                        const DescriptorT& descriptor,
+                        const std::map<std::string, std::string>& import_map
+                    ) const;
 
-  // Very coarse-grained lock to ensure that Generate() is reentrant.
-  // Guards file_ and printer_.
-  mutable Mutex mutex_;
-  mutable const FileDescriptor* file_;  // Set in Generate().  Under mutex_.
-  mutable io::Printer* printer_;        // Set in Generate().  Under mutex_.
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PyiGenerator);
-};
+                    // Very coarse-grained lock to ensure that Generate() is reentrant.
+                    // Guards file_ and printer_.
+                    mutable Mutex mutex_;
+                    mutable const FileDescriptor* file_;  // Set in Generate().  Under mutex_.
+                    mutable io::Printer* printer_;        // Set in Generate().  Under mutex_.
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PyiGenerator);
+                };
 
-}  // namespace python
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace python
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/compiler/ruby/ruby_generator.h b/CAPI/cpp/grpc/include/google/protobuf/compiler/ruby/ruby_generator.h
index 647bb83..4acbd3e 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/compiler/ruby/ruby_generator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/compiler/ruby/ruby_generator.h
@@ -39,27 +39,31 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace compiler {
-namespace ruby {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace compiler
+        {
+            namespace ruby
+            {
 
-// CodeGenerator implementation for generated Ruby protocol buffer classes.
-// If you create your own protocol compiler binary and you want it to support
-// Ruby output, you can do so by registering an instance of this
-// CodeGenerator with the CommandLineInterface in your main() function.
-class PROTOC_EXPORT Generator : public CodeGenerator {
-  bool Generate(const FileDescriptor* file, const std::string& parameter,
-                GeneratorContext* generator_context,
-                std::string* error) const override;
-  uint64_t GetSupportedFeatures() const override {
-    return FEATURE_PROTO3_OPTIONAL;
-  }
-};
+                // CodeGenerator implementation for generated Ruby protocol buffer classes.
+                // If you create your own protocol compiler binary and you want it to support
+                // Ruby output, you can do so by registering an instance of this
+                // CodeGenerator with the CommandLineInterface in your main() function.
+                class PROTOC_EXPORT Generator : public CodeGenerator
+                {
+                    bool Generate(const FileDescriptor* file, const std::string& parameter, GeneratorContext* generator_context, std::string* error) const override;
+                    uint64_t GetSupportedFeatures() const override
+                    {
+                        return FEATURE_PROTO3_OPTIONAL;
+                    }
+                };
 
-}  // namespace ruby
-}  // namespace compiler
-}  // namespace protobuf
+            }  // namespace ruby
+        }      // namespace compiler
+    }          // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/descriptor.h b/CAPI/cpp/grpc/include/google/protobuf/descriptor.h
index 1b8728e..664f45e 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/descriptor.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/descriptor.h
@@ -54,7 +54,6 @@
 #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_H__
 #define GOOGLE_PROTOBUF_DESCRIPTOR_H__
 
-
 #include <atomic>
 #include <map>
 #include <memory>
@@ -80,2358 +79,2502 @@
 #define PROTOBUF_EXPORT
 #endif
 
-
-namespace google {
-namespace protobuf {
-
-// Defined in this file.
-class Descriptor;
-class FieldDescriptor;
-class OneofDescriptor;
-class EnumDescriptor;
-class EnumValueDescriptor;
-class ServiceDescriptor;
-class MethodDescriptor;
-class FileDescriptor;
-class DescriptorDatabase;
-class DescriptorPool;
-
-// Defined in descriptor.proto
-class DescriptorProto;
-class DescriptorProto_ExtensionRange;
-class FieldDescriptorProto;
-class OneofDescriptorProto;
-class EnumDescriptorProto;
-class EnumValueDescriptorProto;
-class ServiceDescriptorProto;
-class MethodDescriptorProto;
-class FileDescriptorProto;
-class MessageOptions;
-class FieldOptions;
-class OneofOptions;
-class EnumOptions;
-class EnumValueOptions;
-class ExtensionRangeOptions;
-class ServiceOptions;
-class MethodOptions;
-class FileOptions;
-class UninterpretedOption;
-class SourceCodeInfo;
-
-// Defined in message.h
-class Message;
-class Reflection;
-
-// Defined in descriptor.cc
-class DescriptorBuilder;
-class FileDescriptorTables;
-class Symbol;
-
-// Defined in unknown_field_set.h.
-class UnknownField;
-
-// Defined in command_line_interface.cc
-namespace compiler {
-class CommandLineInterface;
-namespace cpp {
-// Defined in helpers.h
-class Formatter;
-}  // namespace cpp
-}  // namespace compiler
-
-namespace descriptor_unittest {
-class DescriptorTest;
-}  // namespace descriptor_unittest
-
-// Defined in printer.h
-namespace io {
-class Printer;
-}  // namespace io
-
-// NB, all indices are zero-based.
-struct SourceLocation {
-  int start_line;
-  int end_line;
-  int start_column;
-  int end_column;
-
-  // Doc comments found at the source location.
-  // See the comments in SourceCodeInfo.Location (descriptor.proto) for details.
-  std::string leading_comments;
-  std::string trailing_comments;
-  std::vector<std::string> leading_detached_comments;
-};
-
-// Options when generating machine-parsable output from a descriptor with
-// DebugString().
-struct DebugStringOptions {
-  // include original user comments as recorded in SourceLocation entries. N.B.
-  // that this must be |false| by default: several other pieces of code (for
-  // example, the C++ code generation for fields in the proto compiler) rely on
-  // DebugString() output being unobstructed by user comments.
-  bool include_comments;
-  // If true, elide the braced body in the debug string.
-  bool elide_group_body;
-  bool elide_oneof_body;
-
-  DebugStringOptions()
-      : include_comments(false),
-        elide_group_body(false),
-        elide_oneof_body(false) {
-  }
-};
-
-// A class to handle the simplest cases of a lazily linked descriptor
-// for a message type that isn't built at the time of cross linking,
-// which is needed when a pool has lazily_build_dependencies_ set.
-// Must be instantiated as mutable in a descriptor.
-namespace internal {
-
-// The classes in this file represent a significant memory footprint for the
-// library. We make sure we are not accidentally making them larger by
-// hardcoding the struct size for a specific platform. Use as:
-//
-//   PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(type, expected_size_in_x84-64);
-//
+namespace google
+{
+    namespace protobuf
+    {
+
+        // Defined in this file.
+        class Descriptor;
+        class FieldDescriptor;
+        class OneofDescriptor;
+        class EnumDescriptor;
+        class EnumValueDescriptor;
+        class ServiceDescriptor;
+        class MethodDescriptor;
+        class FileDescriptor;
+        class DescriptorDatabase;
+        class DescriptorPool;
+
+        // Defined in descriptor.proto
+        class DescriptorProto;
+        class DescriptorProto_ExtensionRange;
+        class FieldDescriptorProto;
+        class OneofDescriptorProto;
+        class EnumDescriptorProto;
+        class EnumValueDescriptorProto;
+        class ServiceDescriptorProto;
+        class MethodDescriptorProto;
+        class FileDescriptorProto;
+        class MessageOptions;
+        class FieldOptions;
+        class OneofOptions;
+        class EnumOptions;
+        class EnumValueOptions;
+        class ExtensionRangeOptions;
+        class ServiceOptions;
+        class MethodOptions;
+        class FileOptions;
+        class UninterpretedOption;
+        class SourceCodeInfo;
+
+        // Defined in message.h
+        class Message;
+        class Reflection;
+
+        // Defined in descriptor.cc
+        class DescriptorBuilder;
+        class FileDescriptorTables;
+        class Symbol;
+
+        // Defined in unknown_field_set.h.
+        class UnknownField;
+
+        // Defined in command_line_interface.cc
+        namespace compiler
+        {
+            class CommandLineInterface;
+            namespace cpp
+            {
+                // Defined in helpers.h
+                class Formatter;
+            }  // namespace cpp
+        }      // namespace compiler
+
+        namespace descriptor_unittest
+        {
+            class DescriptorTest;
+        }  // namespace descriptor_unittest
+
+        // Defined in printer.h
+        namespace io
+        {
+            class Printer;
+        }  // namespace io
+
+        // NB, all indices are zero-based.
+        struct SourceLocation
+        {
+            int start_line;
+            int end_line;
+            int start_column;
+            int end_column;
+
+            // Doc comments found at the source location.
+            // See the comments in SourceCodeInfo.Location (descriptor.proto) for details.
+            std::string leading_comments;
+            std::string trailing_comments;
+            std::vector<std::string> leading_detached_comments;
+        };
+
+        // Options when generating machine-parsable output from a descriptor with
+        // DebugString().
+        struct DebugStringOptions
+        {
+            // include original user comments as recorded in SourceLocation entries. N.B.
+            // that this must be |false| by default: several other pieces of code (for
+            // example, the C++ code generation for fields in the proto compiler) rely on
+            // DebugString() output being unobstructed by user comments.
+            bool include_comments;
+            // If true, elide the braced body in the debug string.
+            bool elide_group_body;
+            bool elide_oneof_body;
+
+            DebugStringOptions() :
+                include_comments(false),
+                elide_group_body(false),
+                elide_oneof_body(false)
+            {
+            }
+        };
+
+        // A class to handle the simplest cases of a lazily linked descriptor
+        // for a message type that isn't built at the time of cross linking,
+        // which is needed when a pool has lazily_build_dependencies_ set.
+        // Must be instantiated as mutable in a descriptor.
+        namespace internal
+        {
+
+            // The classes in this file represent a significant memory footprint for the
+            // library. We make sure we are not accidentally making them larger by
+            // hardcoding the struct size for a specific platform. Use as:
+            //
+            //   PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(type, expected_size_in_x84-64);
+            //
 
 #if !defined(PROTOBUF_INTERNAL_CHECK_CLASS_SIZE)
 #define PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(t, expected)
 #endif
 
-class FlatAllocator;
-
-class PROTOBUF_EXPORT LazyDescriptor {
- public:
-  // Init function to be called at init time of a descriptor containing
-  // a LazyDescriptor.
-  void Init() {
-    descriptor_ = nullptr;
-    once_ = nullptr;
-  }
-
-  // Sets the value of the descriptor if it is known during the descriptor
-  // building process. Not thread safe, should only be called during the
-  // descriptor build process. Should not be called after SetLazy has been
-  // called.
-  void Set(const Descriptor* descriptor);
-
-  // Sets the information needed to lazily cross link the descriptor at a later
-  // time, SetLazy is not thread safe, should be called only once at descriptor
-  // build time if the symbol wasn't found and building of the file containing
-  // that type is delayed because lazily_build_dependencies_ is set on the pool.
-  // Should not be called after Set() has been called.
-  void SetLazy(StringPiece name, const FileDescriptor* file);
-
-  // Returns the current value of the descriptor, thread-safe. If SetLazy(...)
-  // has been called, will do a one-time cross link of the type specified,
-  // building the descriptor file that contains the type if necessary.
-  inline const Descriptor* Get(const ServiceDescriptor* service) {
-    Once(service);
-    return descriptor_;
-  }
-
- private:
-  void Once(const ServiceDescriptor* service);
-
-  const Descriptor* descriptor_;
-  // The once_ flag is followed by a NUL terminated string for the type name.
-  internal::once_flag* once_;
-};
-
-class PROTOBUF_EXPORT SymbolBase {
- private:
-  friend class google::protobuf::Symbol;
-  uint8_t symbol_type_;
-};
-
-// Some types have more than one SymbolBase because they have multiple
-// identities in the table. We can't have duplicate direct bases, so we use this
-// intermediate base to do so.
-// See BuildEnumValue for details.
-template <int N>
-class PROTOBUF_EXPORT SymbolBaseN : public SymbolBase {};
-
-}  // namespace internal
-
-// Describes a type of protocol message, or a particular group within a
-// message.  To obtain the Descriptor for a given message object, call
-// Message::GetDescriptor().  Generated message classes also have a
-// static method called descriptor() which returns the type's descriptor.
-// Use DescriptorPool to construct your own descriptors.
-class PROTOBUF_EXPORT Descriptor : private internal::SymbolBase {
- public:
-  typedef DescriptorProto Proto;
-
-  // The name of the message type, not including its scope.
-  const std::string& name() const;
-
-  // The fully-qualified name of the message type, scope delimited by
-  // periods.  For example, message type "Foo" which is declared in package
-  // "bar" has full name "bar.Foo".  If a type "Baz" is nested within
-  // Foo, Baz's full_name is "bar.Foo.Baz".  To get only the part that
-  // comes after the last '.', use name().
-  const std::string& full_name() const;
-
-  // Index of this descriptor within the file or containing type's message
-  // type array.
-  int index() const;
-
-  // The .proto file in which this message type was defined.  Never nullptr.
-  const FileDescriptor* file() const;
-
-  // If this Descriptor describes a nested type, this returns the type
-  // in which it is nested.  Otherwise, returns nullptr.
-  const Descriptor* containing_type() const;
-
-  // Get options for this message type.  These are specified in the .proto file
-  // by placing lines like "option foo = 1234;" in the message definition.
-  // Allowed options are defined by MessageOptions in descriptor.proto, and any
-  // available extensions of that message.
-  const MessageOptions& options() const;
-
-  // Write the contents of this Descriptor into the given DescriptorProto.
-  // The target DescriptorProto must be clear before calling this; if it
-  // isn't, the result may be garbage.
-  void CopyTo(DescriptorProto* proto) const;
-
-  // Write the contents of this descriptor in a human-readable form. Output
-  // will be suitable for re-parsing.
-  std::string DebugString() const;
-
-  // Similar to DebugString(), but additionally takes options (e.g.,
-  // include original user comments in output).
-  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
-
-  // Returns true if this is a placeholder for an unknown type. This will
-  // only be the case if this descriptor comes from a DescriptorPool
-  // with AllowUnknownDependencies() set.
-  bool is_placeholder() const;
-
-  enum WellKnownType {
-    WELLKNOWNTYPE_UNSPECIFIED,  // Not a well-known type.
-
-    // Wrapper types.
-    WELLKNOWNTYPE_DOUBLEVALUE,  // google.protobuf.DoubleValue
-    WELLKNOWNTYPE_FLOATVALUE,   // google.protobuf.FloatValue
-    WELLKNOWNTYPE_INT64VALUE,   // google.protobuf.Int64Value
-    WELLKNOWNTYPE_UINT64VALUE,  // google.protobuf.UInt64Value
-    WELLKNOWNTYPE_INT32VALUE,   // google.protobuf.Int32Value
-    WELLKNOWNTYPE_UINT32VALUE,  // google.protobuf.UInt32Value
-    WELLKNOWNTYPE_STRINGVALUE,  // google.protobuf.StringValue
-    WELLKNOWNTYPE_BYTESVALUE,   // google.protobuf.BytesValue
-    WELLKNOWNTYPE_BOOLVALUE,    // google.protobuf.BoolValue
-
-    // Other well known types.
-    WELLKNOWNTYPE_ANY,        // google.protobuf.Any
-    WELLKNOWNTYPE_FIELDMASK,  // google.protobuf.FieldMask
-    WELLKNOWNTYPE_DURATION,   // google.protobuf.Duration
-    WELLKNOWNTYPE_TIMESTAMP,  // google.protobuf.Timestamp
-    WELLKNOWNTYPE_VALUE,      // google.protobuf.Value
-    WELLKNOWNTYPE_LISTVALUE,  // google.protobuf.ListValue
-    WELLKNOWNTYPE_STRUCT,     // google.protobuf.Struct
-
-    // New well-known types may be added in the future.
-    // Please make sure any switch() statements have a 'default' case.
-    __WELLKNOWNTYPE__DO_NOT_USE__ADD_DEFAULT_INSTEAD__,
-  };
-
-  WellKnownType well_known_type() const;
-
-  // Field stuff -----------------------------------------------------
-
-  // The number of fields in this message type.
-  int field_count() const;
-  // Gets a field by index, where 0 <= index < field_count().
-  // These are returned in the order they were defined in the .proto file.
-  const FieldDescriptor* field(int index) const;
-
-  // Looks up a field by declared tag number.  Returns nullptr if no such field
-  // exists.
-  const FieldDescriptor* FindFieldByNumber(int number) const;
-  // Looks up a field by name.  Returns nullptr if no such field exists.
-  const FieldDescriptor* FindFieldByName(ConstStringParam name) const;
-
-  // Looks up a field by lowercased name (as returned by lowercase_name()).
-  // This lookup may be ambiguous if multiple field names differ only by case,
-  // in which case the field returned is chosen arbitrarily from the matches.
-  const FieldDescriptor* FindFieldByLowercaseName(
-      ConstStringParam lowercase_name) const;
-
-  // Looks up a field by camel-case name (as returned by camelcase_name()).
-  // This lookup may be ambiguous if multiple field names differ in a way that
-  // leads them to have identical camel-case names, in which case the field
-  // returned is chosen arbitrarily from the matches.
-  const FieldDescriptor* FindFieldByCamelcaseName(
-      ConstStringParam camelcase_name) const;
-
-  // The number of oneofs in this message type.
-  int oneof_decl_count() const;
-  // The number of oneofs in this message type, excluding synthetic oneofs.
-  // Real oneofs always come first, so iterating up to real_oneof_decl_cout()
-  // will yield all real oneofs.
-  int real_oneof_decl_count() const;
-  // Get a oneof by index, where 0 <= index < oneof_decl_count().
-  // These are returned in the order they were defined in the .proto file.
-  const OneofDescriptor* oneof_decl(int index) const;
-
-  // Looks up a oneof by name.  Returns nullptr if no such oneof exists.
-  const OneofDescriptor* FindOneofByName(ConstStringParam name) const;
-
-  // Nested type stuff -----------------------------------------------
-
-  // The number of nested types in this message type.
-  int nested_type_count() const;
-  // Gets a nested type by index, where 0 <= index < nested_type_count().
-  // These are returned in the order they were defined in the .proto file.
-  const Descriptor* nested_type(int index) const;
-
-  // Looks up a nested type by name.  Returns nullptr if no such nested type
-  // exists.
-  const Descriptor* FindNestedTypeByName(ConstStringParam name) const;
-
-  // Enum stuff ------------------------------------------------------
-
-  // The number of enum types in this message type.
-  int enum_type_count() const;
-  // Gets an enum type by index, where 0 <= index < enum_type_count().
-  // These are returned in the order they were defined in the .proto file.
-  const EnumDescriptor* enum_type(int index) const;
-
-  // Looks up an enum type by name.  Returns nullptr if no such enum type
-  // exists.
-  const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
-
-  // Looks up an enum value by name, among all enum types in this message.
-  // Returns nullptr if no such value exists.
-  const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
-
-  // Extensions ------------------------------------------------------
-
-  // A range of field numbers which are designated for third-party
-  // extensions.
-  struct ExtensionRange {
-    typedef DescriptorProto_ExtensionRange Proto;
-
-    typedef ExtensionRangeOptions OptionsType;
-
-    // See Descriptor::CopyTo().
-    void CopyTo(DescriptorProto_ExtensionRange* proto) const;
-
-    int start;  // inclusive
-    int end;    // exclusive
-
-    const ExtensionRangeOptions* options_;
-  };
-
-  // The number of extension ranges in this message type.
-  int extension_range_count() const;
-  // Gets an extension range by index, where 0 <= index <
-  // extension_range_count(). These are returned in the order they were defined
-  // in the .proto file.
-  const ExtensionRange* extension_range(int index) const;
-
-  // Returns true if the number is in one of the extension ranges.
-  bool IsExtensionNumber(int number) const;
-
-  // Returns nullptr if no extension range contains the given number.
-  const ExtensionRange* FindExtensionRangeContainingNumber(int number) const;
-
-  // The number of extensions defined nested within this message type's scope.
-  // See doc:
-  // https://developers.google.com/protocol-buffers/docs/proto#nested-extensions
-  //
-  // Note that the extensions may be extending *other* messages.
-  //
-  // For example:
-  // message M1 {
-  //   extensions 1 to max;
-  // }
-  //
-  // message M2 {
-  //   extend M1 {
-  //     optional int32 foo = 1;
-  //   }
-  // }
-  //
-  // In this case,
-  // DescriptorPool::generated_pool()
-  //     ->FindMessageTypeByName("M2")
-  //     ->extension(0)
-  // will return "foo", even though "foo" is an extension of M1.
-  // To find all known extensions of a given message, instead use
-  // DescriptorPool::FindAllExtensions.
-  int extension_count() const;
-  // Get an extension by index, where 0 <= index < extension_count().
-  // These are returned in the order they were defined in the .proto file.
-  const FieldDescriptor* extension(int index) const;
-
-  // Looks up a named extension (which extends some *other* message type)
-  // defined within this message type's scope.
-  const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
-
-  // Similar to FindFieldByLowercaseName(), but finds extensions defined within
-  // this message type's scope.
-  const FieldDescriptor* FindExtensionByLowercaseName(
-      ConstStringParam name) const;
-
-  // Similar to FindFieldByCamelcaseName(), but finds extensions defined within
-  // this message type's scope.
-  const FieldDescriptor* FindExtensionByCamelcaseName(
-      ConstStringParam name) const;
-
-  // Reserved fields -------------------------------------------------
-
-  // A range of reserved field numbers.
-  struct ReservedRange {
-    int start;  // inclusive
-    int end;    // exclusive
-  };
-
-  // The number of reserved ranges in this message type.
-  int reserved_range_count() const;
-  // Gets an reserved range by index, where 0 <= index <
-  // reserved_range_count(). These are returned in the order they were defined
-  // in the .proto file.
-  const ReservedRange* reserved_range(int index) const;
-
-  // Returns true if the number is in one of the reserved ranges.
-  bool IsReservedNumber(int number) const;
-
-  // Returns nullptr if no reserved range contains the given number.
-  const ReservedRange* FindReservedRangeContainingNumber(int number) const;
-
-  // The number of reserved field names in this message type.
-  int reserved_name_count() const;
-
-  // Gets a reserved name by index, where 0 <= index < reserved_name_count().
-  const std::string& reserved_name(int index) const;
-
-  // Returns true if the field name is reserved.
-  bool IsReservedName(ConstStringParam name) const;
-
-  // Source Location ---------------------------------------------------
-
-  // Updates |*out_location| to the source location of the complete
-  // extent of this message declaration.  Returns false and leaves
-  // |*out_location| unchanged iff location information was not available.
-  bool GetSourceLocation(SourceLocation* out_location) const;
-
-  // Maps --------------------------------------------------------------
-
-  // Returns the FieldDescriptor for the "key" field. If this isn't a map entry
-  // field, returns nullptr.
-  const FieldDescriptor* map_key() const;
-
-  // Returns the FieldDescriptor for the "value" field. If this isn't a map
-  // entry field, returns nullptr.
-  const FieldDescriptor* map_value() const;
-
- private:
-  friend class Symbol;
-  typedef MessageOptions OptionsType;
-
-  // Allows tests to test CopyTo(proto, true).
-  friend class descriptor_unittest::DescriptorTest;
-
-  // Allows access to GetLocationPath for annotations.
-  friend class io::Printer;
-  friend class compiler::cpp::Formatter;
-
-  // Fill the json_name field of FieldDescriptorProto.
-  void CopyJsonNameTo(DescriptorProto* proto) const;
-
-  // Internal version of DebugString; controls the level of indenting for
-  // correct depth. Takes |options| to control debug-string options, and
-  // |include_opening_clause| to indicate whether the "message ... " part of the
-  // clause has already been generated (this varies depending on context).
-  void DebugString(int depth, std::string* contents,
-                   const DebugStringOptions& options,
-                   bool include_opening_clause) const;
-
-  // Walks up the descriptor tree to generate the source location path
-  // to this descriptor from the file root.
-  void GetLocationPath(std::vector<int>* output) const;
-
-  // True if this is a placeholder for an unknown type.
-  bool is_placeholder_ : 1;
-  // True if this is a placeholder and the type name wasn't fully-qualified.
-  bool is_unqualified_placeholder_ : 1;
-  // Well known type.  Stored like this to conserve space.
-  uint8_t well_known_type_ : 5;
-
-  // This points to the last field _number_ that is part of the sequence
-  // starting at 1, where
-  //     `desc->field(i)->number() == i + 1`
-  // A value of `0` means no field matches. That is, there are no fields or the
-  // first field is not field `1`.
-  // Uses 16-bit to avoid extra padding. Unlikely to have more than 2^16
-  // sequentially numbered fields in a message.
-  uint16_t sequential_field_limit_;
-
-  int field_count_;
-
-  // all_names_ = [name, full_name]
-  const std::string* all_names_;
-  const FileDescriptor* file_;
-  const Descriptor* containing_type_;
-  const MessageOptions* options_;
-
-  // These arrays are separated from their sizes to minimize padding on 64-bit.
-  FieldDescriptor* fields_;
-  OneofDescriptor* oneof_decls_;
-  Descriptor* nested_types_;
-  EnumDescriptor* enum_types_;
-  ExtensionRange* extension_ranges_;
-  FieldDescriptor* extensions_;
-  ReservedRange* reserved_ranges_;
-  const std::string** reserved_names_;
-
-  int oneof_decl_count_;
-  int real_oneof_decl_count_;
-  int nested_type_count_;
-  int enum_type_count_;
-  int extension_range_count_;
-  int extension_count_;
-  int reserved_range_count_;
-  int reserved_name_count_;
-
-  // IMPORTANT:  If you add a new field, make sure to search for all instances
-  // of Allocate<Descriptor>() and AllocateArray<Descriptor>() in descriptor.cc
-  // and update them to initialize the field.
-
-  // Must be constructed using DescriptorPool.
-  Descriptor() {}
-  friend class DescriptorBuilder;
-  friend class DescriptorPool;
-  friend class EnumDescriptor;
-  friend class FieldDescriptor;
-  friend class FileDescriptorTables;
-  friend class OneofDescriptor;
-  friend class MethodDescriptor;
-  friend class FileDescriptor;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Descriptor);
-};
-
-PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(Descriptor, 136);
-
-// Describes a single field of a message.  To get the descriptor for a given
-// field, first get the Descriptor for the message in which it is defined,
-// then call Descriptor::FindFieldByName().  To get a FieldDescriptor for
-// an extension, do one of the following:
-// - Get the Descriptor or FileDescriptor for its containing scope, then
-//   call Descriptor::FindExtensionByName() or
-//   FileDescriptor::FindExtensionByName().
-// - Given a DescriptorPool, call DescriptorPool::FindExtensionByNumber() or
-//   DescriptorPool::FindExtensionByPrintableName().
-// Use DescriptorPool to construct your own descriptors.
-class PROTOBUF_EXPORT FieldDescriptor : private internal::SymbolBase {
- public:
-  typedef FieldDescriptorProto Proto;
-
-  // Identifies a field type.  0 is reserved for errors.  The order is weird
-  // for historical reasons.  Types 12 and up are new in proto2.
-  enum Type {
-    TYPE_DOUBLE = 1,    // double, exactly eight bytes on the wire.
-    TYPE_FLOAT = 2,     // float, exactly four bytes on the wire.
-    TYPE_INT64 = 3,     // int64, varint on the wire.  Negative numbers
-                        // take 10 bytes.  Use TYPE_SINT64 if negative
-                        // values are likely.
-    TYPE_UINT64 = 4,    // uint64, varint on the wire.
-    TYPE_INT32 = 5,     // int32, varint on the wire.  Negative numbers
-                        // take 10 bytes.  Use TYPE_SINT32 if negative
-                        // values are likely.
-    TYPE_FIXED64 = 6,   // uint64, exactly eight bytes on the wire.
-    TYPE_FIXED32 = 7,   // uint32, exactly four bytes on the wire.
-    TYPE_BOOL = 8,      // bool, varint on the wire.
-    TYPE_STRING = 9,    // UTF-8 text.
-    TYPE_GROUP = 10,    // Tag-delimited message.  Deprecated.
-    TYPE_MESSAGE = 11,  // Length-delimited message.
-
-    TYPE_BYTES = 12,     // Arbitrary byte array.
-    TYPE_UINT32 = 13,    // uint32, varint on the wire
-    TYPE_ENUM = 14,      // Enum, varint on the wire
-    TYPE_SFIXED32 = 15,  // int32, exactly four bytes on the wire
-    TYPE_SFIXED64 = 16,  // int64, exactly eight bytes on the wire
-    TYPE_SINT32 = 17,    // int32, ZigZag-encoded varint on the wire
-    TYPE_SINT64 = 18,    // int64, ZigZag-encoded varint on the wire
-
-    MAX_TYPE = 18,  // Constant useful for defining lookup tables
-                    // indexed by Type.
-  };
-
-  // Specifies the C++ data type used to represent the field.  There is a
-  // fixed mapping from Type to CppType where each Type maps to exactly one
-  // CppType.  0 is reserved for errors.
-  enum CppType {
-    CPPTYPE_INT32 = 1,     // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32
-    CPPTYPE_INT64 = 2,     // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64
-    CPPTYPE_UINT32 = 3,    // TYPE_UINT32, TYPE_FIXED32
-    CPPTYPE_UINT64 = 4,    // TYPE_UINT64, TYPE_FIXED64
-    CPPTYPE_DOUBLE = 5,    // TYPE_DOUBLE
-    CPPTYPE_FLOAT = 6,     // TYPE_FLOAT
-    CPPTYPE_BOOL = 7,      // TYPE_BOOL
-    CPPTYPE_ENUM = 8,      // TYPE_ENUM
-    CPPTYPE_STRING = 9,    // TYPE_STRING, TYPE_BYTES
-    CPPTYPE_MESSAGE = 10,  // TYPE_MESSAGE, TYPE_GROUP
-
-    MAX_CPPTYPE = 10,  // Constant useful for defining lookup tables
-                       // indexed by CppType.
-  };
-
-  // Identifies whether the field is optional, required, or repeated.  0 is
-  // reserved for errors.
-  enum Label {
-    LABEL_OPTIONAL = 1,  // optional
-    LABEL_REQUIRED = 2,  // required
-    LABEL_REPEATED = 3,  // repeated
-
-    MAX_LABEL = 3,  // Constant useful for defining lookup tables
-                    // indexed by Label.
-  };
-
-  // Valid field numbers are positive integers up to kMaxNumber.
-  static const int kMaxNumber = (1 << 29) - 1;
-
-  // First field number reserved for the protocol buffer library implementation.
-  // Users may not declare fields that use reserved numbers.
-  static const int kFirstReservedNumber = 19000;
-  // Last field number reserved for the protocol buffer library implementation.
-  // Users may not declare fields that use reserved numbers.
-  static const int kLastReservedNumber = 19999;
-
-  const std::string& name() const;  // Name of this field within the message.
-  const std::string& full_name() const;  // Fully-qualified name of the field.
-  const std::string& json_name() const;  // JSON name of this field.
-  const FileDescriptor* file() const;  // File in which this field was defined.
-  bool is_extension() const;           // Is this an extension field?
-  int number() const;                  // Declared tag number.
-
-  // Same as name() except converted to lower-case.  This (and especially the
-  // FindFieldByLowercaseName() method) can be useful when parsing formats
-  // which prefer to use lowercase naming style.  (Although, technically
-  // field names should be lowercased anyway according to the protobuf style
-  // guide, so this only makes a difference when dealing with old .proto files
-  // which do not follow the guide.)
-  const std::string& lowercase_name() const;
-
-  // Same as name() except converted to camel-case.  In this conversion, any
-  // time an underscore appears in the name, it is removed and the next
-  // letter is capitalized.  Furthermore, the first letter of the name is
-  // lower-cased.  Examples:
-  //   FooBar -> fooBar
-  //   foo_bar -> fooBar
-  //   fooBar -> fooBar
-  // This (and especially the FindFieldByCamelcaseName() method) can be useful
-  // when parsing formats which prefer to use camel-case naming style.
-  const std::string& camelcase_name() const;
-
-  Type type() const;                  // Declared type of this field.
-  const char* type_name() const;      // Name of the declared type.
-  CppType cpp_type() const;           // C++ type of this field.
-  const char* cpp_type_name() const;  // Name of the C++ type.
-  Label label() const;                // optional/required/repeated
-
-  bool is_required() const;  // shorthand for label() == LABEL_REQUIRED
-  bool is_optional() const;  // shorthand for label() == LABEL_OPTIONAL
-  bool is_repeated() const;  // shorthand for label() == LABEL_REPEATED
-  bool is_packable() const;  // shorthand for is_repeated() &&
-                             //               IsTypePackable(type())
-  bool is_packed() const;    // shorthand for is_packable() &&
-                             //               options().packed()
-  bool is_map() const;       // shorthand for type() == TYPE_MESSAGE &&
-                             // message_type()->options().map_entry()
-
-  // Returns true if this field was syntactically written with "optional" in the
-  // .proto file. Excludes singular proto3 fields that do not have a label.
-  bool has_optional_keyword() const;
-
-  // Returns true if this field tracks presence, ie. does the field
-  // distinguish between "unset" and "present with default value."
-  // This includes required, optional, and oneof fields. It excludes maps,
-  // repeated fields, and singular proto3 fields without "optional".
-  //
-  // For fields where has_presence() == true, the return value of
-  // Reflection::HasField() is semantically meaningful.
-  bool has_presence() const;
-
-  // Index of this field within the message's field array, or the file or
-  // extension scope's extensions array.
-  int index() const;
-
-  // Does this field have an explicitly-declared default value?
-  bool has_default_value() const;
-
-  // Whether the user has specified the json_name field option in the .proto
-  // file.
-  bool has_json_name() const;
-
-  // Get the field default value if cpp_type() == CPPTYPE_INT32.  If no
-  // explicit default was defined, the default is 0.
-  int32_t default_value_int32_t() const;
-  int32_t default_value_int32() const { return default_value_int32_t(); }
-  // Get the field default value if cpp_type() == CPPTYPE_INT64.  If no
-  // explicit default was defined, the default is 0.
-  int64_t default_value_int64_t() const;
-  int64_t default_value_int64() const { return default_value_int64_t(); }
-  // Get the field default value if cpp_type() == CPPTYPE_UINT32.  If no
-  // explicit default was defined, the default is 0.
-  uint32_t default_value_uint32_t() const;
-  uint32_t default_value_uint32() const { return default_value_uint32_t(); }
-  // Get the field default value if cpp_type() == CPPTYPE_UINT64.  If no
-  // explicit default was defined, the default is 0.
-  uint64_t default_value_uint64_t() const;
-  uint64_t default_value_uint64() const { return default_value_uint64_t(); }
-  // Get the field default value if cpp_type() == CPPTYPE_FLOAT.  If no
-  // explicit default was defined, the default is 0.0.
-  float default_value_float() const;
-  // Get the field default value if cpp_type() == CPPTYPE_DOUBLE.  If no
-  // explicit default was defined, the default is 0.0.
-  double default_value_double() const;
-  // Get the field default value if cpp_type() == CPPTYPE_BOOL.  If no
-  // explicit default was defined, the default is false.
-  bool default_value_bool() const;
-  // Get the field default value if cpp_type() == CPPTYPE_ENUM.  If no
-  // explicit default was defined, the default is the first value defined
-  // in the enum type (all enum types are required to have at least one value).
-  // This never returns nullptr.
-  const EnumValueDescriptor* default_value_enum() const;
-  // Get the field default value if cpp_type() == CPPTYPE_STRING.  If no
-  // explicit default was defined, the default is the empty string.
-  const std::string& default_value_string() const;
-
-  // The Descriptor for the message of which this is a field.  For extensions,
-  // this is the extended type.  Never nullptr.
-  const Descriptor* containing_type() const;
-
-  // If the field is a member of a oneof, this is the one, otherwise this is
-  // nullptr.
-  const OneofDescriptor* containing_oneof() const;
-
-  // If the field is a member of a non-synthetic oneof, returns the descriptor
-  // for the oneof, otherwise returns nullptr.
-  const OneofDescriptor* real_containing_oneof() const;
-
-  // If the field is a member of a oneof, returns the index in that oneof.
-  int index_in_oneof() const;
-
-  // An extension may be declared within the scope of another message.  If this
-  // field is an extension (is_extension() is true), then extension_scope()
-  // returns that message, or nullptr if the extension was declared at global
-  // scope.  If this is not an extension, extension_scope() is undefined (may
-  // assert-fail).
-  const Descriptor* extension_scope() const;
-
-  // If type is TYPE_MESSAGE or TYPE_GROUP, returns a descriptor for the
-  // message or the group type.  Otherwise, returns null.
-  const Descriptor* message_type() const;
-  // If type is TYPE_ENUM, returns a descriptor for the enum.  Otherwise,
-  // returns null.
-  const EnumDescriptor* enum_type() const;
-
-  // Get the FieldOptions for this field.  This includes things listed in
-  // square brackets after the field definition.  E.g., the field:
-  //   optional string text = 1 [ctype=CORD];
-  // has the "ctype" option set.  Allowed options are defined by FieldOptions in
-  // descriptor.proto, and any available extensions of that message.
-  const FieldOptions& options() const;
-
-  // See Descriptor::CopyTo().
-  void CopyTo(FieldDescriptorProto* proto) const;
-
-  // See Descriptor::DebugString().
-  std::string DebugString() const;
-
-  // See Descriptor::DebugStringWithOptions().
-  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
-
-  // Helper method to get the CppType for a particular Type.
-  static CppType TypeToCppType(Type type);
-
-  // Helper method to get the name of a Type.
-  static const char* TypeName(Type type);
-
-  // Helper method to get the name of a CppType.
-  static const char* CppTypeName(CppType cpp_type);
-
-  // Return true iff [packed = true] is valid for fields of this type.
-  static inline bool IsTypePackable(Type field_type);
-
-  // Returns full_name() except if the field is a MessageSet extension,
-  // in which case it returns the full_name() of the containing message type
-  // for backwards compatibility with proto1.
-  //
-  // A MessageSet extension is defined as an optional message extension
-  // whose containing type has the message_set_wire_format option set.
-  // This should be true of extensions of google.protobuf.bridge.MessageSet;
-  // by convention, such extensions are named "message_set_extension".
-  //
-  // The opposite operation (looking up an extension's FieldDescriptor given
-  // its printable name) can be accomplished with
-  //     message->file()->pool()->FindExtensionByPrintableName(message, name)
-  // where the extension extends "message".
-  const std::string& PrintableNameForExtension() const;
-
-  // Source Location ---------------------------------------------------
-
-  // Updates |*out_location| to the source location of the complete
-  // extent of this field declaration.  Returns false and leaves
-  // |*out_location| unchanged iff location information was not available.
-  bool GetSourceLocation(SourceLocation* out_location) const;
-
- private:
-  friend class Symbol;
-  typedef FieldOptions OptionsType;
-
-  // Allows access to GetLocationPath for annotations.
-  friend class io::Printer;
-  friend class compiler::cpp::Formatter;
-  friend class Reflection;
-
-  // Fill the json_name field of FieldDescriptorProto.
-  void CopyJsonNameTo(FieldDescriptorProto* proto) const;
-
-  // See Descriptor::DebugString().
-  void DebugString(int depth, std::string* contents,
-                   const DebugStringOptions& options) const;
-
-  // formats the default value appropriately and returns it as a string.
-  // Must have a default value to call this. If quote_string_type is true, then
-  // types of CPPTYPE_STRING whill be surrounded by quotes and CEscaped.
-  std::string DefaultValueAsString(bool quote_string_type) const;
-
-  // Helper function that returns the field type name for DebugString.
-  std::string FieldTypeNameDebugString() const;
-
-  // Walks up the descriptor tree to generate the source location path
-  // to this descriptor from the file root.
-  void GetLocationPath(std::vector<int>* output) const;
-
-  // Returns true if this is a map message type.
-  bool is_map_message_type() const;
-
-  bool has_default_value_ : 1;
-  bool proto3_optional_ : 1;
-  // Whether the user has specified the json_name field option in the .proto
-  // file.
-  bool has_json_name_ : 1;
-  bool is_extension_ : 1;
-  bool is_oneof_ : 1;
-
-  // Actually a `Label` but stored as uint8_t to save space.
-  uint8_t label_ : 2;
-
-  // Actually a `Type`, but stored as uint8_t to save space.
-  mutable uint8_t type_;
-
-  // Logically:
-  //   all_names_ = [name, full_name, lower, camel, json]
-  // However:
-  //   duplicates will be omitted, so lower/camel/json might be in the same
-  //   position.
-  // We store the true offset for each name here, and the bit width must be
-  // large enough to account for the worst case where all names are present.
-  uint8_t lowercase_name_index_ : 2;
-  uint8_t camelcase_name_index_ : 2;
-  uint8_t json_name_index_ : 3;
-  // Sadly, `number_` located here to reduce padding. Unrelated to all_names_
-  // and its indices above.
-  int number_;
-  const std::string* all_names_;
-  const FileDescriptor* file_;
-
-  // The once_flag is followed by a NUL terminated string for the type name and
-  // enum default value (or empty string if no default enum).
-  internal::once_flag* type_once_;
-  static void TypeOnceInit(const FieldDescriptor* to_init);
-  void InternalTypeOnceInit() const;
-  const Descriptor* containing_type_;
-  union {
-    const OneofDescriptor* containing_oneof;
-    const Descriptor* extension_scope;
-  } scope_;
-  union {
-    mutable const Descriptor* message_type;
-    mutable const EnumDescriptor* enum_type;
-  } type_descriptor_;
-  const FieldOptions* options_;
-  // IMPORTANT:  If you add a new field, make sure to search for all instances
-  // of Allocate<FieldDescriptor>() and AllocateArray<FieldDescriptor>() in
-  // descriptor.cc and update them to initialize the field.
-
-  union {
-    int32_t default_value_int32_t_;
-    int64_t default_value_int64_t_;
-    uint32_t default_value_uint32_t_;
-    uint64_t default_value_uint64_t_;
-    float default_value_float_;
-    double default_value_double_;
-    bool default_value_bool_;
-
-    mutable const EnumValueDescriptor* default_value_enum_;
-    const std::string* default_value_string_;
-    mutable std::atomic<const Message*> default_generated_instance_;
-  };
-
-  static const CppType kTypeToCppTypeMap[MAX_TYPE + 1];
-
-  static const char* const kTypeToName[MAX_TYPE + 1];
-
-  static const char* const kCppTypeToName[MAX_CPPTYPE + 1];
-
-  static const char* const kLabelToName[MAX_LABEL + 1];
-
-  // Must be constructed using DescriptorPool.
-  FieldDescriptor() {}
-  friend class DescriptorBuilder;
-  friend class FileDescriptor;
-  friend class Descriptor;
-  friend class OneofDescriptor;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldDescriptor);
-};
-
-PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(FieldDescriptor, 72);
-
-// Describes a oneof defined in a message type.
-class PROTOBUF_EXPORT OneofDescriptor : private internal::SymbolBase {
- public:
-  typedef OneofDescriptorProto Proto;
-
-  const std::string& name() const;       // Name of this oneof.
-  const std::string& full_name() const;  // Fully-qualified name of the oneof.
-
-  // Index of this oneof within the message's oneof array.
-  int index() const;
-
-  // Returns whether this oneof was inserted by the compiler to wrap a proto3
-  // optional field. If this returns true, code generators should *not* emit it.
-  bool is_synthetic() const;
-
-  // The .proto file in which this oneof was defined.  Never nullptr.
-  const FileDescriptor* file() const;
-  // The Descriptor for the message containing this oneof.
-  const Descriptor* containing_type() const;
-
-  // The number of (non-extension) fields which are members of this oneof.
-  int field_count() const;
-  // Get a member of this oneof, in the order in which they were declared in the
-  // .proto file.  Does not include extensions.
-  const FieldDescriptor* field(int index) const;
-
-  const OneofOptions& options() const;
-
-  // See Descriptor::CopyTo().
-  void CopyTo(OneofDescriptorProto* proto) const;
-
-  // See Descriptor::DebugString().
-  std::string DebugString() const;
-
-  // See Descriptor::DebugStringWithOptions().
-  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
-
-  // Source Location ---------------------------------------------------
-
-  // Updates |*out_location| to the source location of the complete
-  // extent of this oneof declaration.  Returns false and leaves
-  // |*out_location| unchanged iff location information was not available.
-  bool GetSourceLocation(SourceLocation* out_location) const;
-
- private:
-  friend class Symbol;
-  typedef OneofOptions OptionsType;
-
-  // Allows access to GetLocationPath for annotations.
-  friend class io::Printer;
-  friend class compiler::cpp::Formatter;
-
-  // See Descriptor::DebugString().
-  void DebugString(int depth, std::string* contents,
-                   const DebugStringOptions& options) const;
-
-  // Walks up the descriptor tree to generate the source location path
-  // to this descriptor from the file root.
-  void GetLocationPath(std::vector<int>* output) const;
-
-  int field_count_;
-
-  // all_names_ = [name, full_name]
-  const std::string* all_names_;
-  const Descriptor* containing_type_;
-  const OneofOptions* options_;
-  const FieldDescriptor* fields_;
-
-  // IMPORTANT:  If you add a new field, make sure to search for all instances
-  // of Allocate<OneofDescriptor>() and AllocateArray<OneofDescriptor>()
-  // in descriptor.cc and update them to initialize the field.
-
-  // Must be constructed using DescriptorPool.
-  OneofDescriptor() {}
-  friend class DescriptorBuilder;
-  friend class Descriptor;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OneofDescriptor);
-};
-
-PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(OneofDescriptor, 40);
-
-// Describes an enum type defined in a .proto file.  To get the EnumDescriptor
-// for a generated enum type, call TypeName_descriptor().  Use DescriptorPool
-// to construct your own descriptors.
-class PROTOBUF_EXPORT EnumDescriptor : private internal::SymbolBase {
- public:
-  typedef EnumDescriptorProto Proto;
-
-  // The name of this enum type in the containing scope.
-  const std::string& name() const;
-
-  // The fully-qualified name of the enum type, scope delimited by periods.
-  const std::string& full_name() const;
-
-  // Index of this enum within the file or containing message's enum array.
-  int index() const;
-
-  // The .proto file in which this enum type was defined.  Never nullptr.
-  const FileDescriptor* file() const;
-
-  // The number of values for this EnumDescriptor.  Guaranteed to be greater
-  // than zero.
-  int value_count() const;
-  // Gets a value by index, where 0 <= index < value_count().
-  // These are returned in the order they were defined in the .proto file.
-  const EnumValueDescriptor* value(int index) const;
-
-  // Looks up a value by name.  Returns nullptr if no such value exists.
-  const EnumValueDescriptor* FindValueByName(ConstStringParam name) const;
-  // Looks up a value by number.  Returns nullptr if no such value exists.  If
-  // multiple values have this number, the first one defined is returned.
-  const EnumValueDescriptor* FindValueByNumber(int number) const;
-
-  // If this enum type is nested in a message type, this is that message type.
-  // Otherwise, nullptr.
-  const Descriptor* containing_type() const;
-
-  // Get options for this enum type.  These are specified in the .proto file by
-  // placing lines like "option foo = 1234;" in the enum definition.  Allowed
-  // options are defined by EnumOptions in descriptor.proto, and any available
-  // extensions of that message.
-  const EnumOptions& options() const;
-
-  // See Descriptor::CopyTo().
-  void CopyTo(EnumDescriptorProto* proto) const;
-
-  // See Descriptor::DebugString().
-  std::string DebugString() const;
-
-  // See Descriptor::DebugStringWithOptions().
-  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
-
-  // Returns true if this is a placeholder for an unknown enum. This will
-  // only be the case if this descriptor comes from a DescriptorPool
-  // with AllowUnknownDependencies() set.
-  bool is_placeholder() const;
-
-  // Reserved fields -------------------------------------------------
-
-  // A range of reserved field numbers.
-  struct ReservedRange {
-    int start;  // inclusive
-    int end;    // inclusive
-  };
-
-  // The number of reserved ranges in this message type.
-  int reserved_range_count() const;
-  // Gets an reserved range by index, where 0 <= index <
-  // reserved_range_count(). These are returned in the order they were defined
-  // in the .proto file.
-  const EnumDescriptor::ReservedRange* reserved_range(int index) const;
-
-  // Returns true if the number is in one of the reserved ranges.
-  bool IsReservedNumber(int number) const;
-
-  // Returns nullptr if no reserved range contains the given number.
-  const EnumDescriptor::ReservedRange* FindReservedRangeContainingNumber(
-      int number) const;
-
-  // The number of reserved field names in this message type.
-  int reserved_name_count() const;
-
-  // Gets a reserved name by index, where 0 <= index < reserved_name_count().
-  const std::string& reserved_name(int index) const;
-
-  // Returns true if the field name is reserved.
-  bool IsReservedName(ConstStringParam name) const;
-
-  // Source Location ---------------------------------------------------
-
-  // Updates |*out_location| to the source location of the complete
-  // extent of this enum declaration.  Returns false and leaves
-  // |*out_location| unchanged iff location information was not available.
-  bool GetSourceLocation(SourceLocation* out_location) const;
-
- private:
-  friend class Symbol;
-  typedef EnumOptions OptionsType;
-
-  // Allows access to GetLocationPath for annotations.
-  friend class io::Printer;
-  friend class compiler::cpp::Formatter;
-
-  // Allow access to FindValueByNumberCreatingIfUnknown.
-  friend class descriptor_unittest::DescriptorTest;
-
-  // Looks up a value by number.  If the value does not exist, dynamically
-  // creates a new EnumValueDescriptor for that value, assuming that it was
-  // unknown. If a new descriptor is created, this is done in a thread-safe way,
-  // and future calls will return the same value descriptor pointer.
-  //
-  // This is private but is used by Reflection (which is friended below) to
-  // return a valid EnumValueDescriptor from GetEnum() when this feature is
-  // enabled.
-  const EnumValueDescriptor* FindValueByNumberCreatingIfUnknown(
-      int number) const;
-
-  // See Descriptor::DebugString().
-  void DebugString(int depth, std::string* contents,
-                   const DebugStringOptions& options) const;
-
-  // Walks up the descriptor tree to generate the source location path
-  // to this descriptor from the file root.
-  void GetLocationPath(std::vector<int>* output) const;
-
-  // True if this is a placeholder for an unknown type.
-  bool is_placeholder_ : 1;
-  // True if this is a placeholder and the type name wasn't fully-qualified.
-  bool is_unqualified_placeholder_ : 1;
-
-  // This points to the last value _index_ that is part of the sequence starting
-  // with the first label, where
-  //   `enum->value(i)->number() == enum->value(0)->number() + i`
-  // We measure relative to the first label to adapt to enum labels starting at
-  // 0 or 1.
-  // Uses 16-bit to avoid extra padding. Unlikely to have more than 2^15
-  // sequentially numbered labels in an enum.
-  int16_t sequential_value_limit_;
-
-  int value_count_;
-
-  // all_names_ = [name, full_name]
-  const std::string* all_names_;
-  const FileDescriptor* file_;
-  const Descriptor* containing_type_;
-  const EnumOptions* options_;
-  EnumValueDescriptor* values_;
-
-  int reserved_range_count_;
-  int reserved_name_count_;
-  EnumDescriptor::ReservedRange* reserved_ranges_;
-  const std::string** reserved_names_;
-
-  // IMPORTANT:  If you add a new field, make sure to search for all instances
-  // of Allocate<EnumDescriptor>() and AllocateArray<EnumDescriptor>() in
-  // descriptor.cc and update them to initialize the field.
-
-  // Must be constructed using DescriptorPool.
-  EnumDescriptor() {}
-  friend class DescriptorBuilder;
-  friend class Descriptor;
-  friend class FieldDescriptor;
-  friend class FileDescriptorTables;
-  friend class EnumValueDescriptor;
-  friend class FileDescriptor;
-  friend class DescriptorPool;
-  friend class Reflection;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumDescriptor);
-};
-
-PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(EnumDescriptor, 72);
-
-// Describes an individual enum constant of a particular type.  To get the
-// EnumValueDescriptor for a given enum value, first get the EnumDescriptor
-// for its type, then use EnumDescriptor::FindValueByName() or
-// EnumDescriptor::FindValueByNumber().  Use DescriptorPool to construct
-// your own descriptors.
-class PROTOBUF_EXPORT EnumValueDescriptor : private internal::SymbolBaseN<0>,
-                                            private internal::SymbolBaseN<1> {
- public:
-  typedef EnumValueDescriptorProto Proto;
-
-  const std::string& name() const;  // Name of this enum constant.
-  int index() const;                // Index within the enums's Descriptor.
-  int number() const;               // Numeric value of this enum constant.
-
-  // The full_name of an enum value is a sibling symbol of the enum type.
-  // e.g. the full name of FieldDescriptorProto::TYPE_INT32 is actually
-  // "google.protobuf.FieldDescriptorProto.TYPE_INT32", NOT
-  // "google.protobuf.FieldDescriptorProto.Type.TYPE_INT32".  This is to conform
-  // with C++ scoping rules for enums.
-  const std::string& full_name() const;
-
-  // The .proto file in which this value was defined.  Never nullptr.
-  const FileDescriptor* file() const;
-  // The type of this value.  Never nullptr.
-  const EnumDescriptor* type() const;
-
-  // Get options for this enum value.  These are specified in the .proto file by
-  // adding text like "[foo = 1234]" after an enum value definition.  Allowed
-  // options are defined by EnumValueOptions in descriptor.proto, and any
-  // available extensions of that message.
-  const EnumValueOptions& options() const;
-
-  // See Descriptor::CopyTo().
-  void CopyTo(EnumValueDescriptorProto* proto) const;
-
-  // See Descriptor::DebugString().
-  std::string DebugString() const;
-
-  // See Descriptor::DebugStringWithOptions().
-  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
-
-  // Source Location ---------------------------------------------------
-
-  // Updates |*out_location| to the source location of the complete
-  // extent of this enum value declaration.  Returns false and leaves
-  // |*out_location| unchanged iff location information was not available.
-  bool GetSourceLocation(SourceLocation* out_location) const;
-
- private:
-  friend class Symbol;
-  typedef EnumValueOptions OptionsType;
-
-  // Allows access to GetLocationPath for annotations.
-  friend class io::Printer;
-  friend class compiler::cpp::Formatter;
-
-  // See Descriptor::DebugString().
-  void DebugString(int depth, std::string* contents,
-                   const DebugStringOptions& options) const;
-
-  // Walks up the descriptor tree to generate the source location path
-  // to this descriptor from the file root.
-  void GetLocationPath(std::vector<int>* output) const;
-
-  int number_;
-  // all_names_ = [name, full_name]
-  const std::string* all_names_;
-  const EnumDescriptor* type_;
-  const EnumValueOptions* options_;
-  // IMPORTANT:  If you add a new field, make sure to search for all instances
-  // of Allocate<EnumValueDescriptor>() and AllocateArray<EnumValueDescriptor>()
-  // in descriptor.cc and update them to initialize the field.
-
-  // Must be constructed using DescriptorPool.
-  EnumValueDescriptor() {}
-  friend class DescriptorBuilder;
-  friend class EnumDescriptor;
-  friend class DescriptorPool;
-  friend class FileDescriptorTables;
-  friend class Reflection;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumValueDescriptor);
-};
-
-PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(EnumValueDescriptor, 32);
-
-// Describes an RPC service. Use DescriptorPool to construct your own
-// descriptors.
-class PROTOBUF_EXPORT ServiceDescriptor : private internal::SymbolBase {
- public:
-  typedef ServiceDescriptorProto Proto;
-
-  // The name of the service, not including its containing scope.
-  const std::string& name() const;
-  // The fully-qualified name of the service, scope delimited by periods.
-  const std::string& full_name() const;
-  // Index of this service within the file's services array.
-  int index() const;
-
-  // The .proto file in which this service was defined.  Never nullptr.
-  const FileDescriptor* file() const;
-
-  // Get options for this service type.  These are specified in the .proto file
-  // by placing lines like "option foo = 1234;" in the service definition.
-  // Allowed options are defined by ServiceOptions in descriptor.proto, and any
-  // available extensions of that message.
-  const ServiceOptions& options() const;
-
-  // The number of methods this service defines.
-  int method_count() const;
-  // Gets a MethodDescriptor by index, where 0 <= index < method_count().
-  // These are returned in the order they were defined in the .proto file.
-  const MethodDescriptor* method(int index) const;
-
-  // Look up a MethodDescriptor by name.
-  const MethodDescriptor* FindMethodByName(ConstStringParam name) const;
-
-  // See Descriptor::CopyTo().
-  void CopyTo(ServiceDescriptorProto* proto) const;
-
-  // See Descriptor::DebugString().
-  std::string DebugString() const;
-
-  // See Descriptor::DebugStringWithOptions().
-  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
-
-  // Source Location ---------------------------------------------------
-
-  // Updates |*out_location| to the source location of the complete
-  // extent of this service declaration.  Returns false and leaves
-  // |*out_location| unchanged iff location information was not available.
-  bool GetSourceLocation(SourceLocation* out_location) const;
-
- private:
-  friend class Symbol;
-  typedef ServiceOptions OptionsType;
-
-  // Allows access to GetLocationPath for annotations.
-  friend class io::Printer;
-  friend class compiler::cpp::Formatter;
-
-  // See Descriptor::DebugString().
-  void DebugString(std::string* contents,
-                   const DebugStringOptions& options) const;
-
-  // Walks up the descriptor tree to generate the source location path
-  // to this descriptor from the file root.
-  void GetLocationPath(std::vector<int>* output) const;
-
-  // all_names_ = [name, full_name]
-  const std::string* all_names_;
-  const FileDescriptor* file_;
-  const ServiceOptions* options_;
-  MethodDescriptor* methods_;
-  int method_count_;
-  // IMPORTANT:  If you add a new field, make sure to search for all instances
-  // of Allocate<ServiceDescriptor>() and AllocateArray<ServiceDescriptor>() in
-  // descriptor.cc and update them to initialize the field.
-
-  // Must be constructed using DescriptorPool.
-  ServiceDescriptor() {}
-  friend class DescriptorBuilder;
-  friend class FileDescriptor;
-  friend class MethodDescriptor;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ServiceDescriptor);
-};
-
-PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(ServiceDescriptor, 48);
-
-// Describes an individual service method.  To obtain a MethodDescriptor given
-// a service, first get its ServiceDescriptor, then call
-// ServiceDescriptor::FindMethodByName().  Use DescriptorPool to construct your
-// own descriptors.
-class PROTOBUF_EXPORT MethodDescriptor : private internal::SymbolBase {
- public:
-  typedef MethodDescriptorProto Proto;
-
-  // Name of this method, not including containing scope.
-  const std::string& name() const;
-  // The fully-qualified name of the method, scope delimited by periods.
-  const std::string& full_name() const;
-  // Index within the service's Descriptor.
-  int index() const;
-
-  // The .proto file in which this method was defined.  Never nullptr.
-  const FileDescriptor* file() const;
-  // Gets the service to which this method belongs.  Never nullptr.
-  const ServiceDescriptor* service() const;
-
-  // Gets the type of protocol message which this method accepts as input.
-  const Descriptor* input_type() const;
-  // Gets the type of protocol message which this message produces as output.
-  const Descriptor* output_type() const;
-
-  // Gets whether the client streams multiple requests.
-  bool client_streaming() const;
-  // Gets whether the server streams multiple responses.
-  bool server_streaming() const;
-
-  // Get options for this method.  These are specified in the .proto file by
-  // placing lines like "option foo = 1234;" in curly-braces after a method
-  // declaration.  Allowed options are defined by MethodOptions in
-  // descriptor.proto, and any available extensions of that message.
-  const MethodOptions& options() const;
-
-  // See Descriptor::CopyTo().
-  void CopyTo(MethodDescriptorProto* proto) const;
-
-  // See Descriptor::DebugString().
-  std::string DebugString() const;
-
-  // See Descriptor::DebugStringWithOptions().
-  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
-
-  // Source Location ---------------------------------------------------
-
-  // Updates |*out_location| to the source location of the complete
-  // extent of this method declaration.  Returns false and leaves
-  // |*out_location| unchanged iff location information was not available.
-  bool GetSourceLocation(SourceLocation* out_location) const;
-
- private:
-  friend class Symbol;
-  typedef MethodOptions OptionsType;
-
-  // Allows access to GetLocationPath for annotations.
-  friend class io::Printer;
-  friend class compiler::cpp::Formatter;
-
-  // See Descriptor::DebugString().
-  void DebugString(int depth, std::string* contents,
-                   const DebugStringOptions& options) const;
-
-  // Walks up the descriptor tree to generate the source location path
-  // to this descriptor from the file root.
-  void GetLocationPath(std::vector<int>* output) const;
-
-  bool client_streaming_;
-  bool server_streaming_;
-  // all_names_ = [name, full_name]
-  const std::string* all_names_;
-  const ServiceDescriptor* service_;
-  mutable internal::LazyDescriptor input_type_;
-  mutable internal::LazyDescriptor output_type_;
-  const MethodOptions* options_;
-  // IMPORTANT:  If you add a new field, make sure to search for all instances
-  // of Allocate<MethodDescriptor>() and AllocateArray<MethodDescriptor>() in
-  // descriptor.cc and update them to initialize the field.
-
-  // Must be constructed using DescriptorPool.
-  MethodDescriptor() {}
-  friend class DescriptorBuilder;
-  friend class ServiceDescriptor;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MethodDescriptor);
-};
-
-PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(MethodDescriptor, 64);
-
-// Describes a whole .proto file.  To get the FileDescriptor for a compiled-in
-// file, get the descriptor for something defined in that file and call
-// descriptor->file().  Use DescriptorPool to construct your own descriptors.
-class PROTOBUF_EXPORT FileDescriptor : private internal::SymbolBase {
- public:
-  typedef FileDescriptorProto Proto;
-
-  // The filename, relative to the source tree.
-  // e.g. "foo/bar/baz.proto"
-  const std::string& name() const;
-
-  // The package, e.g. "google.protobuf.compiler".
-  const std::string& package() const;
-
-  // The DescriptorPool in which this FileDescriptor and all its contents were
-  // allocated.  Never nullptr.
-  const DescriptorPool* pool() const;
-
-  // The number of files imported by this one.
-  int dependency_count() const;
-  // Gets an imported file by index, where 0 <= index < dependency_count().
-  // These are returned in the order they were defined in the .proto file.
-  const FileDescriptor* dependency(int index) const;
-
-  // The number of files public imported by this one.
-  // The public dependency list is a subset of the dependency list.
-  int public_dependency_count() const;
-  // Gets a public imported file by index, where 0 <= index <
-  // public_dependency_count().
-  // These are returned in the order they were defined in the .proto file.
-  const FileDescriptor* public_dependency(int index) const;
-
-  // The number of files that are imported for weak fields.
-  // The weak dependency list is a subset of the dependency list.
-  int weak_dependency_count() const;
-  // Gets a weak imported file by index, where 0 <= index <
-  // weak_dependency_count().
-  // These are returned in the order they were defined in the .proto file.
-  const FileDescriptor* weak_dependency(int index) const;
-
-  // Number of top-level message types defined in this file.  (This does not
-  // include nested types.)
-  int message_type_count() const;
-  // Gets a top-level message type, where 0 <= index < message_type_count().
-  // These are returned in the order they were defined in the .proto file.
-  const Descriptor* message_type(int index) const;
-
-  // Number of top-level enum types defined in this file.  (This does not
-  // include nested types.)
-  int enum_type_count() const;
-  // Gets a top-level enum type, where 0 <= index < enum_type_count().
-  // These are returned in the order they were defined in the .proto file.
-  const EnumDescriptor* enum_type(int index) const;
-
-  // Number of services defined in this file.
-  int service_count() const;
-  // Gets a service, where 0 <= index < service_count().
-  // These are returned in the order they were defined in the .proto file.
-  const ServiceDescriptor* service(int index) const;
-
-  // Number of extensions defined at file scope.  (This does not include
-  // extensions nested within message types.)
-  int extension_count() const;
-  // Gets an extension's descriptor, where 0 <= index < extension_count().
-  // These are returned in the order they were defined in the .proto file.
-  const FieldDescriptor* extension(int index) const;
-
-  // Get options for this file.  These are specified in the .proto file by
-  // placing lines like "option foo = 1234;" at the top level, outside of any
-  // other definitions.  Allowed options are defined by FileOptions in
-  // descriptor.proto, and any available extensions of that message.
-  const FileOptions& options() const;
-
-  // Syntax of this file.
-  enum Syntax {
-    SYNTAX_UNKNOWN = 0,
-    SYNTAX_PROTO2 = 2,
-    SYNTAX_PROTO3 = 3,
-  };
-  Syntax syntax() const;
-  static const char* SyntaxName(Syntax syntax);
-
-  // Find a top-level message type by name (not full_name).  Returns nullptr if
-  // not found.
-  const Descriptor* FindMessageTypeByName(ConstStringParam name) const;
-  // Find a top-level enum type by name.  Returns nullptr if not found.
-  const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
-  // Find an enum value defined in any top-level enum by name.  Returns nullptr
-  // if not found.
-  const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
-  // Find a service definition by name.  Returns nullptr if not found.
-  const ServiceDescriptor* FindServiceByName(ConstStringParam name) const;
-  // Find a top-level extension definition by name.  Returns nullptr if not
-  // found.
-  const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
-  // Similar to FindExtensionByName(), but searches by lowercased-name.  See
-  // Descriptor::FindFieldByLowercaseName().
-  const FieldDescriptor* FindExtensionByLowercaseName(
-      ConstStringParam name) const;
-  // Similar to FindExtensionByName(), but searches by camelcased-name.  See
-  // Descriptor::FindFieldByCamelcaseName().
-  const FieldDescriptor* FindExtensionByCamelcaseName(
-      ConstStringParam name) const;
-
-  // See Descriptor::CopyTo().
-  // Notes:
-  // - This method does NOT copy source code information since it is relatively
-  //   large and rarely needed.  See CopySourceCodeInfoTo() below.
-  void CopyTo(FileDescriptorProto* proto) const;
-  // Write the source code information of this FileDescriptor into the given
-  // FileDescriptorProto.  See CopyTo() above.
-  void CopySourceCodeInfoTo(FileDescriptorProto* proto) const;
-  // Fill the json_name field of FieldDescriptorProto for all fields. Can only
-  // be called after CopyTo().
-  void CopyJsonNameTo(FileDescriptorProto* proto) const;
-
-  // See Descriptor::DebugString().
-  std::string DebugString() const;
-
-  // See Descriptor::DebugStringWithOptions().
-  std::string DebugStringWithOptions(const DebugStringOptions& options) const;
-
-  // Returns true if this is a placeholder for an unknown file. This will
-  // only be the case if this descriptor comes from a DescriptorPool
-  // with AllowUnknownDependencies() set.
-  bool is_placeholder() const;
-
-  // Updates |*out_location| to the source location of the complete extent of
-  // this file declaration (namely, the empty path).
-  bool GetSourceLocation(SourceLocation* out_location) const;
-
-  // Updates |*out_location| to the source location of the complete
-  // extent of the declaration or declaration-part denoted by |path|.
-  // Returns false and leaves |*out_location| unchanged iff location
-  // information was not available.  (See SourceCodeInfo for
-  // description of path encoding.)
-  bool GetSourceLocation(const std::vector<int>& path,
-                         SourceLocation* out_location) const;
-
- private:
-  friend class Symbol;
-  typedef FileOptions OptionsType;
-
-  bool is_placeholder_;
-  // Indicates the FileDescriptor is completed building. Used to verify
-  // that type accessor functions that can possibly build a dependent file
-  // aren't called during the process of building the file.
-  bool finished_building_;
-  // Actually a `Syntax` but stored as uint8_t to save space.
-  uint8_t syntax_;
-  // This one is here to fill the padding.
-  int extension_count_;
-
-  const std::string* name_;
-  const std::string* package_;
-  const DescriptorPool* pool_;
-
-  // dependencies_once_ contain a once_flag followed by N NUL terminated
-  // strings. Dependencies that do not need to be loaded will be empty. ie just
-  // {'\0'}
-  internal::once_flag* dependencies_once_;
-  static void DependenciesOnceInit(const FileDescriptor* to_init);
-  void InternalDependenciesOnceInit() const;
-
-  // These are arranged to minimize padding on 64-bit.
-  int dependency_count_;
-  int public_dependency_count_;
-  int weak_dependency_count_;
-  int message_type_count_;
-  int enum_type_count_;
-  int service_count_;
-
-  mutable const FileDescriptor** dependencies_;
-  int* public_dependencies_;
-  int* weak_dependencies_;
-  Descriptor* message_types_;
-  EnumDescriptor* enum_types_;
-  ServiceDescriptor* services_;
-  FieldDescriptor* extensions_;
-  const FileOptions* options_;
-
-  const FileDescriptorTables* tables_;
-  const SourceCodeInfo* source_code_info_;
-
-  // IMPORTANT:  If you add a new field, make sure to search for all instances
-  // of Allocate<FileDescriptor>() and AllocateArray<FileDescriptor>() in
-  // descriptor.cc and update them to initialize the field.
-
-  FileDescriptor() {}
-  friend class DescriptorBuilder;
-  friend class DescriptorPool;
-  friend class Descriptor;
-  friend class FieldDescriptor;
-  friend class internal::LazyDescriptor;
-  friend class OneofDescriptor;
-  friend class EnumDescriptor;
-  friend class EnumValueDescriptor;
-  friend class MethodDescriptor;
-  friend class ServiceDescriptor;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileDescriptor);
-};
-
-PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(FileDescriptor, 144);
-
-// ===================================================================
-
-// Used to construct descriptors.
-//
-// Normally you won't want to build your own descriptors.  Message classes
-// constructed by the protocol compiler will provide them for you.  However,
-// if you are implementing Message on your own, or if you are writing a
-// program which can operate on totally arbitrary types and needs to load
-// them from some sort of database, you might need to.
-//
-// Since Descriptors are composed of a whole lot of cross-linked bits of
-// data that would be a pain to put together manually, the
-// DescriptorPool class is provided to make the process easier.  It can
-// take a FileDescriptorProto (defined in descriptor.proto), validate it,
-// and convert it to a set of nicely cross-linked Descriptors.
-//
-// DescriptorPool also helps with memory management.  Descriptors are
-// composed of many objects containing static data and pointers to each
-// other.  In all likelihood, when it comes time to delete this data,
-// you'll want to delete it all at once.  In fact, it is not uncommon to
-// have a whole pool of descriptors all cross-linked with each other which
-// you wish to delete all at once.  This class represents such a pool, and
-// handles the memory management for you.
-//
-// You can also search for descriptors within a DescriptorPool by name, and
-// extensions by number.
-class PROTOBUF_EXPORT DescriptorPool {
- public:
-  // Create a normal, empty DescriptorPool.
-  DescriptorPool();
-
-  // Constructs a DescriptorPool that, when it can't find something among the
-  // descriptors already in the pool, looks for it in the given
-  // DescriptorDatabase.
-  // Notes:
-  // - If a DescriptorPool is constructed this way, its BuildFile*() methods
-  //   must not be called (they will assert-fail).  The only way to populate
-  //   the pool with descriptors is to call the Find*By*() methods.
-  // - The Find*By*() methods may block the calling thread if the
-  //   DescriptorDatabase blocks.  This in turn means that parsing messages
-  //   may block if they need to look up extensions.
-  // - The Find*By*() methods will use mutexes for thread-safety, thus making
-  //   them slower even when they don't have to fall back to the database.
-  //   In fact, even the Find*By*() methods of descriptor objects owned by
-  //   this pool will be slower, since they will have to obtain locks too.
-  // - An ErrorCollector may optionally be given to collect validation errors
-  //   in files loaded from the database.  If not given, errors will be printed
-  //   to GOOGLE_LOG(ERROR).  Remember that files are built on-demand, so this
-  //   ErrorCollector may be called from any thread that calls one of the
-  //   Find*By*() methods.
-  // - The DescriptorDatabase must not be mutated during the lifetime of
-  //   the DescriptorPool. Even if the client takes care to avoid data races,
-  //   changes to the content of the DescriptorDatabase may not be reflected
-  //   in subsequent lookups in the DescriptorPool.
-  class ErrorCollector;
-  explicit DescriptorPool(DescriptorDatabase* fallback_database,
-                          ErrorCollector* error_collector = nullptr);
-
-  ~DescriptorPool();
-
-  // Get a pointer to the generated pool.  Generated protocol message classes
-  // which are compiled into the binary will allocate their descriptors in
-  // this pool.  Do not add your own descriptors to this pool.
-  static const DescriptorPool* generated_pool();
-
-
-  // Find a FileDescriptor in the pool by file name.  Returns nullptr if not
-  // found.
-  const FileDescriptor* FindFileByName(ConstStringParam name) const;
-
-  // Find the FileDescriptor in the pool which defines the given symbol.
-  // If any of the Find*ByName() methods below would succeed, then this is
-  // equivalent to calling that method and calling the result's file() method.
-  // Otherwise this returns nullptr.
-  const FileDescriptor* FindFileContainingSymbol(
-      ConstStringParam symbol_name) const;
-
-  // Looking up descriptors ------------------------------------------
-  // These find descriptors by fully-qualified name.  These will find both
-  // top-level descriptors and nested descriptors.  They return nullptr if not
-  // found.
-
-  const Descriptor* FindMessageTypeByName(ConstStringParam name) const;
-  const FieldDescriptor* FindFieldByName(ConstStringParam name) const;
-  const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
-  const OneofDescriptor* FindOneofByName(ConstStringParam name) const;
-  const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
-  const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
-  const ServiceDescriptor* FindServiceByName(ConstStringParam name) const;
-  const MethodDescriptor* FindMethodByName(ConstStringParam name) const;
-
-  // Finds an extension of the given type by number.  The extendee must be
-  // a member of this DescriptorPool or one of its underlays.
-  const FieldDescriptor* FindExtensionByNumber(const Descriptor* extendee,
-                                               int number) const;
-
-  // Finds an extension of the given type by its printable name.
-  // See comments above PrintableNameForExtension() for the definition of
-  // "printable name".  The extendee must be a member of this DescriptorPool
-  // or one of its underlays.  Returns nullptr if there is no known message
-  // extension with the given printable name.
-  const FieldDescriptor* FindExtensionByPrintableName(
-      const Descriptor* extendee, ConstStringParam printable_name) const;
-
-  // Finds extensions of extendee. The extensions will be appended to
-  // out in an undefined order. Only extensions defined directly in
-  // this DescriptorPool or one of its underlays are guaranteed to be
-  // found: extensions defined in the fallback database might not be found
-  // depending on the database implementation.
-  void FindAllExtensions(const Descriptor* extendee,
-                         std::vector<const FieldDescriptor*>* out) const;
-
-  // Building descriptors --------------------------------------------
-
-  // When converting a FileDescriptorProto to a FileDescriptor, various
-  // errors might be detected in the input.  The caller may handle these
-  // programmatically by implementing an ErrorCollector.
-  class PROTOBUF_EXPORT ErrorCollector {
-   public:
-    inline ErrorCollector() {}
-    virtual ~ErrorCollector();
-
-    // These constants specify what exact part of the construct is broken.
-    // This is useful e.g. for mapping the error back to an exact location
-    // in a .proto file.
-    enum ErrorLocation {
-      NAME,           // the symbol name, or the package name for files
-      NUMBER,         // field or extension range number
-      TYPE,           // field type
-      EXTENDEE,       // field extendee
-      DEFAULT_VALUE,  // field default value
-      INPUT_TYPE,     // method input type
-      OUTPUT_TYPE,    // method output type
-      OPTION_NAME,    // name in assignment
-      OPTION_VALUE,   // value in option assignment
-      IMPORT,         // import error
-      OTHER           // some other problem
-    };
-
-    // Reports an error in the FileDescriptorProto. Use this function if the
-    // problem occurred should interrupt building the FileDescriptorProto.
-    virtual void AddError(
-        const std::string& filename,  // File name in which the error occurred.
-        const std::string& element_name,  // Full name of the erroneous element.
-        const Message* descriptor,  // Descriptor of the erroneous element.
-        ErrorLocation location,     // One of the location constants, above.
-        const std::string& message  // Human-readable error message.
-        ) = 0;
-
-    // Reports a warning in the FileDescriptorProto. Use this function if the
-    // problem occurred should NOT interrupt building the FileDescriptorProto.
-    virtual void AddWarning(
-        const std::string& /*filename*/,      // File name in which the error
-                                              // occurred.
-        const std::string& /*element_name*/,  // Full name of the erroneous
-                                              // element.
-        const Message* /*descriptor*/,  // Descriptor of the erroneous element.
-        ErrorLocation /*location*/,     // One of the location constants, above.
-        const std::string& /*message*/  // Human-readable error message.
-    ) {}
-
-   private:
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
-  };
-
-  // Convert the FileDescriptorProto to real descriptors and place them in
-  // this DescriptorPool.  All dependencies of the file must already be in
-  // the pool.  Returns the resulting FileDescriptor, or nullptr if there were
-  // problems with the input (e.g. the message was invalid, or dependencies
-  // were missing).  Details about the errors are written to GOOGLE_LOG(ERROR).
-  const FileDescriptor* BuildFile(const FileDescriptorProto& proto);
-
-  // Same as BuildFile() except errors are sent to the given ErrorCollector.
-  const FileDescriptor* BuildFileCollectingErrors(
-      const FileDescriptorProto& proto, ErrorCollector* error_collector);
-
-  // By default, it is an error if a FileDescriptorProto contains references
-  // to types or other files that are not found in the DescriptorPool (or its
-  // backing DescriptorDatabase, if any).  If you call
-  // AllowUnknownDependencies(), however, then unknown types and files
-  // will be replaced by placeholder descriptors (which can be identified by
-  // the is_placeholder() method).  This can allow you to
-  // perform some useful operations with a .proto file even if you do not
-  // have access to other .proto files on which it depends.  However, some
-  // heuristics must be used to fill in the gaps in information, and these
-  // can lead to descriptors which are inaccurate.  For example, the
-  // DescriptorPool may be forced to guess whether an unknown type is a message
-  // or an enum, as well as what package it resides in.  Furthermore,
-  // placeholder types will not be discoverable via FindMessageTypeByName()
-  // and similar methods, which could confuse some descriptor-based algorithms.
-  // Generally, the results of this option should be handled with extreme care.
-  void AllowUnknownDependencies() { allow_unknown_ = true; }
-
-  // By default, weak imports are allowed to be missing, in which case we will
-  // use a placeholder for the dependency and convert the field to be an Empty
-  // message field. If you call EnforceWeakDependencies(true), however, the
-  // DescriptorPool will report a import not found error.
-  void EnforceWeakDependencies(bool enforce) { enforce_weak_ = enforce; }
-
-  // Internal stuff --------------------------------------------------
-  // These methods MUST NOT be called from outside the proto2 library.
-  // These methods may contain hidden pitfalls and may be removed in a
-  // future library version.
-
-  // Create a DescriptorPool which is overlaid on top of some other pool.
-  // If you search for a descriptor in the overlay and it is not found, the
-  // underlay will be searched as a backup.  If the underlay has its own
-  // underlay, that will be searched next, and so on.  This also means that
-  // files built in the overlay will be cross-linked with the underlay's
-  // descriptors if necessary.  The underlay remains property of the caller;
-  // it must remain valid for the lifetime of the newly-constructed pool.
-  //
-  // Example:  Say you want to parse a .proto file at runtime in order to use
-  // its type with a DynamicMessage.  Say this .proto file has dependencies,
-  // but you know that all the dependencies will be things that are already
-  // compiled into the binary.  For ease of use, you'd like to load the types
-  // right out of generated_pool() rather than have to parse redundant copies
-  // of all these .protos and runtime.  But, you don't want to add the parsed
-  // types directly into generated_pool(): this is not allowed, and would be
-  // bad design anyway.  So, instead, you could use generated_pool() as an
-  // underlay for a new DescriptorPool in which you add only the new file.
-  //
-  // WARNING:  Use of underlays can lead to many subtle gotchas.  Instead,
-  //   try to formulate what you want to do in terms of DescriptorDatabases.
-  explicit DescriptorPool(const DescriptorPool* underlay);
-
-  // Called by generated classes at init time to add their descriptors to
-  // generated_pool.  Do NOT call this in your own code!  filename must be a
-  // permanent string (e.g. a string literal).
-  static void InternalAddGeneratedFile(const void* encoded_file_descriptor,
-                                       int size);
-
-  // Disallow [enforce_utf8 = false] in .proto files.
-  void DisallowEnforceUtf8() { disallow_enforce_utf8_ = true; }
-
-
-  // For internal use only:  Gets a non-const pointer to the generated pool.
-  // This is called at static-initialization time only, so thread-safety is
-  // not a concern.  If both an underlay and a fallback database are present,
-  // the underlay takes precedence.
-  static DescriptorPool* internal_generated_pool();
-
-  // For internal use only:  Gets a non-const pointer to the generated
-  // descriptor database.
-  // Only used for testing.
-  static DescriptorDatabase* internal_generated_database();
-
-  // For internal use only:  Changes the behavior of BuildFile() such that it
-  // allows the file to make reference to message types declared in other files
-  // which it did not officially declare as dependencies.
-  void InternalDontEnforceDependencies();
-
-  // For internal use only: Enables lazy building of dependencies of a file.
-  // Delay the building of dependencies of a file descriptor until absolutely
-  // necessary, like when message_type() is called on a field that is defined
-  // in that dependency's file. This will cause functional issues if a proto
-  // or one of its dependencies has errors. Should only be enabled for the
-  // generated_pool_ (because no descriptor build errors are guaranteed by
-  // the compilation generation process), testing, or if a lack of descriptor
-  // build errors can be guaranteed for a pool.
-  void InternalSetLazilyBuildDependencies() {
-    lazily_build_dependencies_ = true;
-    // This needs to be set when lazily building dependencies, as it breaks
-    // dependency checking.
-    InternalDontEnforceDependencies();
-  }
-
-  // For internal use only.
-  void internal_set_underlay(const DescriptorPool* underlay) {
-    underlay_ = underlay;
-  }
-
-  // For internal (unit test) use only:  Returns true if a FileDescriptor has
-  // been constructed for the given file, false otherwise.  Useful for testing
-  // lazy descriptor initialization behavior.
-  bool InternalIsFileLoaded(ConstStringParam filename) const;
-
-  // Add a file to unused_import_track_files_. DescriptorBuilder will log
-  // warnings or errors for those files if there is any unused import.
-  void AddUnusedImportTrackFile(ConstStringParam file_name,
-                                bool is_error = false);
-  void ClearUnusedImportTrackFiles();
-
- private:
-  friend class Descriptor;
-  friend class internal::LazyDescriptor;
-  friend class FieldDescriptor;
-  friend class EnumDescriptor;
-  friend class ServiceDescriptor;
-  friend class MethodDescriptor;
-  friend class FileDescriptor;
-  friend class DescriptorBuilder;
-  friend class FileDescriptorTables;
-
-  // Return true if the given name is a sub-symbol of any non-package
-  // descriptor that already exists in the descriptor pool.  (The full
-  // definition of such types is already known.)
-  bool IsSubSymbolOfBuiltType(StringPiece name) const;
-
-  // Tries to find something in the fallback database and link in the
-  // corresponding proto file.  Returns true if successful, in which case
-  // the caller should search for the thing again.  These are declared
-  // const because they are called by (semantically) const methods.
-  bool TryFindFileInFallbackDatabase(StringPiece name) const;
-  bool TryFindSymbolInFallbackDatabase(StringPiece name) const;
-  bool TryFindExtensionInFallbackDatabase(const Descriptor* containing_type,
-                                          int field_number) const;
-
-  // This internal find extension method only check with its table and underlay
-  // descriptor_pool's table. It does not check with fallback DB and no
-  // additional proto file will be build in this method.
-  const FieldDescriptor* InternalFindExtensionByNumberNoLock(
-      const Descriptor* extendee, int number) const;
-
-  // Like BuildFile() but called internally when the file has been loaded from
-  // fallback_database_.  Declared const because it is called by (semantically)
-  // const methods.
-  const FileDescriptor* BuildFileFromDatabase(
-      const FileDescriptorProto& proto) const;
-
-  // Helper for when lazily_build_dependencies_ is set, can look up a symbol
-  // after the file's descriptor is built, and can build the file where that
-  // symbol is defined if necessary. Will create a placeholder if the type
-  // doesn't exist in the fallback database, or the file doesn't build
-  // successfully.
-  Symbol CrossLinkOnDemandHelper(StringPiece name,
-                                 bool expecting_enum) const;
-
-  // Create a placeholder FileDescriptor of the specified name
-  FileDescriptor* NewPlaceholderFile(StringPiece name) const;
-  FileDescriptor* NewPlaceholderFileWithMutexHeld(
-      StringPiece name, internal::FlatAllocator& alloc) const;
-
-  enum PlaceholderType {
-    PLACEHOLDER_MESSAGE,
-    PLACEHOLDER_ENUM,
-    PLACEHOLDER_EXTENDABLE_MESSAGE
-  };
-  // Create a placeholder Descriptor of the specified name
-  Symbol NewPlaceholder(StringPiece name,
-                        PlaceholderType placeholder_type) const;
-  Symbol NewPlaceholderWithMutexHeld(StringPiece name,
-                                     PlaceholderType placeholder_type) const;
-
-  // If fallback_database_ is nullptr, this is nullptr.  Otherwise, this is a
-  // mutex which must be locked while accessing tables_.
-  internal::WrappedMutex* mutex_;
-
-  // See constructor.
-  DescriptorDatabase* fallback_database_;
-  ErrorCollector* default_error_collector_;
-  const DescriptorPool* underlay_;
-
-  // This class contains a lot of hash maps with complicated types that
-  // we'd like to keep out of the header.
-  class Tables;
-  std::unique_ptr<Tables> tables_;
-
-  bool enforce_dependencies_;
-  bool lazily_build_dependencies_;
-  bool allow_unknown_;
-  bool enforce_weak_;
-  bool disallow_enforce_utf8_;
-
-  // Set of files to track for unused imports. The bool value when true means
-  // unused imports are treated as errors (and as warnings when false).
-  std::map<std::string, bool> unused_import_track_files_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPool);
-};
+            class FlatAllocator;
+
+            class PROTOBUF_EXPORT LazyDescriptor
+            {
+            public:
+                // Init function to be called at init time of a descriptor containing
+                // a LazyDescriptor.
+                void Init()
+                {
+                    descriptor_ = nullptr;
+                    once_ = nullptr;
+                }
+
+                // Sets the value of the descriptor if it is known during the descriptor
+                // building process. Not thread safe, should only be called during the
+                // descriptor build process. Should not be called after SetLazy has been
+                // called.
+                void Set(const Descriptor* descriptor);
+
+                // Sets the information needed to lazily cross link the descriptor at a later
+                // time, SetLazy is not thread safe, should be called only once at descriptor
+                // build time if the symbol wasn't found and building of the file containing
+                // that type is delayed because lazily_build_dependencies_ is set on the pool.
+                // Should not be called after Set() has been called.
+                void SetLazy(StringPiece name, const FileDescriptor* file);
+
+                // Returns the current value of the descriptor, thread-safe. If SetLazy(...)
+                // has been called, will do a one-time cross link of the type specified,
+                // building the descriptor file that contains the type if necessary.
+                inline const Descriptor* Get(const ServiceDescriptor* service)
+                {
+                    Once(service);
+                    return descriptor_;
+                }
+
+            private:
+                void Once(const ServiceDescriptor* service);
+
+                const Descriptor* descriptor_;
+                // The once_ flag is followed by a NUL terminated string for the type name.
+                internal::once_flag* once_;
+            };
+
+            class PROTOBUF_EXPORT SymbolBase
+            {
+            private:
+                friend class google::protobuf::Symbol;
+                uint8_t symbol_type_;
+            };
+
+            // Some types have more than one SymbolBase because they have multiple
+            // identities in the table. We can't have duplicate direct bases, so we use this
+            // intermediate base to do so.
+            // See BuildEnumValue for details.
+            template<int N>
+            class PROTOBUF_EXPORT SymbolBaseN : public SymbolBase
+            {
+            };
+
+        }  // namespace internal
+
+        // Describes a type of protocol message, or a particular group within a
+        // message.  To obtain the Descriptor for a given message object, call
+        // Message::GetDescriptor().  Generated message classes also have a
+        // static method called descriptor() which returns the type's descriptor.
+        // Use DescriptorPool to construct your own descriptors.
+        class PROTOBUF_EXPORT Descriptor : private internal::SymbolBase
+        {
+        public:
+            typedef DescriptorProto Proto;
+
+            // The name of the message type, not including its scope.
+            const std::string& name() const;
+
+            // The fully-qualified name of the message type, scope delimited by
+            // periods.  For example, message type "Foo" which is declared in package
+            // "bar" has full name "bar.Foo".  If a type "Baz" is nested within
+            // Foo, Baz's full_name is "bar.Foo.Baz".  To get only the part that
+            // comes after the last '.', use name().
+            const std::string& full_name() const;
+
+            // Index of this descriptor within the file or containing type's message
+            // type array.
+            int index() const;
+
+            // The .proto file in which this message type was defined.  Never nullptr.
+            const FileDescriptor* file() const;
+
+            // If this Descriptor describes a nested type, this returns the type
+            // in which it is nested.  Otherwise, returns nullptr.
+            const Descriptor* containing_type() const;
+
+            // Get options for this message type.  These are specified in the .proto file
+            // by placing lines like "option foo = 1234;" in the message definition.
+            // Allowed options are defined by MessageOptions in descriptor.proto, and any
+            // available extensions of that message.
+            const MessageOptions& options() const;
+
+            // Write the contents of this Descriptor into the given DescriptorProto.
+            // The target DescriptorProto must be clear before calling this; if it
+            // isn't, the result may be garbage.
+            void CopyTo(DescriptorProto* proto) const;
+
+            // Write the contents of this descriptor in a human-readable form. Output
+            // will be suitable for re-parsing.
+            std::string DebugString() const;
+
+            // Similar to DebugString(), but additionally takes options (e.g.,
+            // include original user comments in output).
+            std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+            // Returns true if this is a placeholder for an unknown type. This will
+            // only be the case if this descriptor comes from a DescriptorPool
+            // with AllowUnknownDependencies() set.
+            bool is_placeholder() const;
+
+            enum WellKnownType
+            {
+                WELLKNOWNTYPE_UNSPECIFIED,  // Not a well-known type.
+
+                // Wrapper types.
+                WELLKNOWNTYPE_DOUBLEVALUE,  // google.protobuf.DoubleValue
+                WELLKNOWNTYPE_FLOATVALUE,   // google.protobuf.FloatValue
+                WELLKNOWNTYPE_INT64VALUE,   // google.protobuf.Int64Value
+                WELLKNOWNTYPE_UINT64VALUE,  // google.protobuf.UInt64Value
+                WELLKNOWNTYPE_INT32VALUE,   // google.protobuf.Int32Value
+                WELLKNOWNTYPE_UINT32VALUE,  // google.protobuf.UInt32Value
+                WELLKNOWNTYPE_STRINGVALUE,  // google.protobuf.StringValue
+                WELLKNOWNTYPE_BYTESVALUE,   // google.protobuf.BytesValue
+                WELLKNOWNTYPE_BOOLVALUE,    // google.protobuf.BoolValue
+
+                // Other well known types.
+                WELLKNOWNTYPE_ANY,        // google.protobuf.Any
+                WELLKNOWNTYPE_FIELDMASK,  // google.protobuf.FieldMask
+                WELLKNOWNTYPE_DURATION,   // google.protobuf.Duration
+                WELLKNOWNTYPE_TIMESTAMP,  // google.protobuf.Timestamp
+                WELLKNOWNTYPE_VALUE,      // google.protobuf.Value
+                WELLKNOWNTYPE_LISTVALUE,  // google.protobuf.ListValue
+                WELLKNOWNTYPE_STRUCT,     // google.protobuf.Struct
+
+                // New well-known types may be added in the future.
+                // Please make sure any switch() statements have a 'default' case.
+                __WELLKNOWNTYPE__DO_NOT_USE__ADD_DEFAULT_INSTEAD__,
+            };
+
+            WellKnownType well_known_type() const;
+
+            // Field stuff -----------------------------------------------------
+
+            // The number of fields in this message type.
+            int field_count() const;
+            // Gets a field by index, where 0 <= index < field_count().
+            // These are returned in the order they were defined in the .proto file.
+            const FieldDescriptor* field(int index) const;
+
+            // Looks up a field by declared tag number.  Returns nullptr if no such field
+            // exists.
+            const FieldDescriptor* FindFieldByNumber(int number) const;
+            // Looks up a field by name.  Returns nullptr if no such field exists.
+            const FieldDescriptor* FindFieldByName(ConstStringParam name) const;
+
+            // Looks up a field by lowercased name (as returned by lowercase_name()).
+            // This lookup may be ambiguous if multiple field names differ only by case,
+            // in which case the field returned is chosen arbitrarily from the matches.
+            const FieldDescriptor* FindFieldByLowercaseName(
+                ConstStringParam lowercase_name
+            ) const;
+
+            // Looks up a field by camel-case name (as returned by camelcase_name()).
+            // This lookup may be ambiguous if multiple field names differ in a way that
+            // leads them to have identical camel-case names, in which case the field
+            // returned is chosen arbitrarily from the matches.
+            const FieldDescriptor* FindFieldByCamelcaseName(
+                ConstStringParam camelcase_name
+            ) const;
+
+            // The number of oneofs in this message type.
+            int oneof_decl_count() const;
+            // The number of oneofs in this message type, excluding synthetic oneofs.
+            // Real oneofs always come first, so iterating up to real_oneof_decl_cout()
+            // will yield all real oneofs.
+            int real_oneof_decl_count() const;
+            // Get a oneof by index, where 0 <= index < oneof_decl_count().
+            // These are returned in the order they were defined in the .proto file.
+            const OneofDescriptor* oneof_decl(int index) const;
+
+            // Looks up a oneof by name.  Returns nullptr if no such oneof exists.
+            const OneofDescriptor* FindOneofByName(ConstStringParam name) const;
+
+            // Nested type stuff -----------------------------------------------
+
+            // The number of nested types in this message type.
+            int nested_type_count() const;
+            // Gets a nested type by index, where 0 <= index < nested_type_count().
+            // These are returned in the order they were defined in the .proto file.
+            const Descriptor* nested_type(int index) const;
+
+            // Looks up a nested type by name.  Returns nullptr if no such nested type
+            // exists.
+            const Descriptor* FindNestedTypeByName(ConstStringParam name) const;
+
+            // Enum stuff ------------------------------------------------------
+
+            // The number of enum types in this message type.
+            int enum_type_count() const;
+            // Gets an enum type by index, where 0 <= index < enum_type_count().
+            // These are returned in the order they were defined in the .proto file.
+            const EnumDescriptor* enum_type(int index) const;
+
+            // Looks up an enum type by name.  Returns nullptr if no such enum type
+            // exists.
+            const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
+
+            // Looks up an enum value by name, among all enum types in this message.
+            // Returns nullptr if no such value exists.
+            const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
+
+            // Extensions ------------------------------------------------------
+
+            // A range of field numbers which are designated for third-party
+            // extensions.
+            struct ExtensionRange
+            {
+                typedef DescriptorProto_ExtensionRange Proto;
+
+                typedef ExtensionRangeOptions OptionsType;
+
+                // See Descriptor::CopyTo().
+                void CopyTo(DescriptorProto_ExtensionRange* proto) const;
+
+                int start;  // inclusive
+                int end;    // exclusive
+
+                const ExtensionRangeOptions* options_;
+            };
+
+            // The number of extension ranges in this message type.
+            int extension_range_count() const;
+            // Gets an extension range by index, where 0 <= index <
+            // extension_range_count(). These are returned in the order they were defined
+            // in the .proto file.
+            const ExtensionRange* extension_range(int index) const;
+
+            // Returns true if the number is in one of the extension ranges.
+            bool IsExtensionNumber(int number) const;
+
+            // Returns nullptr if no extension range contains the given number.
+            const ExtensionRange* FindExtensionRangeContainingNumber(int number) const;
+
+            // The number of extensions defined nested within this message type's scope.
+            // See doc:
+            // https://developers.google.com/protocol-buffers/docs/proto#nested-extensions
+            //
+            // Note that the extensions may be extending *other* messages.
+            //
+            // For example:
+            // message M1 {
+            //   extensions 1 to max;
+            // }
+            //
+            // message M2 {
+            //   extend M1 {
+            //     optional int32 foo = 1;
+            //   }
+            // }
+            //
+            // In this case,
+            // DescriptorPool::generated_pool()
+            //     ->FindMessageTypeByName("M2")
+            //     ->extension(0)
+            // will return "foo", even though "foo" is an extension of M1.
+            // To find all known extensions of a given message, instead use
+            // DescriptorPool::FindAllExtensions.
+            int extension_count() const;
+            // Get an extension by index, where 0 <= index < extension_count().
+            // These are returned in the order they were defined in the .proto file.
+            const FieldDescriptor* extension(int index) const;
+
+            // Looks up a named extension (which extends some *other* message type)
+            // defined within this message type's scope.
+            const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
+
+            // Similar to FindFieldByLowercaseName(), but finds extensions defined within
+            // this message type's scope.
+            const FieldDescriptor* FindExtensionByLowercaseName(
+                ConstStringParam name
+            ) const;
+
+            // Similar to FindFieldByCamelcaseName(), but finds extensions defined within
+            // this message type's scope.
+            const FieldDescriptor* FindExtensionByCamelcaseName(
+                ConstStringParam name
+            ) const;
+
+            // Reserved fields -------------------------------------------------
+
+            // A range of reserved field numbers.
+            struct ReservedRange
+            {
+                int start;  // inclusive
+                int end;    // exclusive
+            };
+
+            // The number of reserved ranges in this message type.
+            int reserved_range_count() const;
+            // Gets an reserved range by index, where 0 <= index <
+            // reserved_range_count(). These are returned in the order they were defined
+            // in the .proto file.
+            const ReservedRange* reserved_range(int index) const;
+
+            // Returns true if the number is in one of the reserved ranges.
+            bool IsReservedNumber(int number) const;
+
+            // Returns nullptr if no reserved range contains the given number.
+            const ReservedRange* FindReservedRangeContainingNumber(int number) const;
+
+            // The number of reserved field names in this message type.
+            int reserved_name_count() const;
+
+            // Gets a reserved name by index, where 0 <= index < reserved_name_count().
+            const std::string& reserved_name(int index) const;
+
+            // Returns true if the field name is reserved.
+            bool IsReservedName(ConstStringParam name) const;
+
+            // Source Location ---------------------------------------------------
+
+            // Updates |*out_location| to the source location of the complete
+            // extent of this message declaration.  Returns false and leaves
+            // |*out_location| unchanged iff location information was not available.
+            bool GetSourceLocation(SourceLocation* out_location) const;
+
+            // Maps --------------------------------------------------------------
+
+            // Returns the FieldDescriptor for the "key" field. If this isn't a map entry
+            // field, returns nullptr.
+            const FieldDescriptor* map_key() const;
+
+            // Returns the FieldDescriptor for the "value" field. If this isn't a map
+            // entry field, returns nullptr.
+            const FieldDescriptor* map_value() const;
+
+        private:
+            friend class Symbol;
+            typedef MessageOptions OptionsType;
+
+            // Allows tests to test CopyTo(proto, true).
+            friend class descriptor_unittest::DescriptorTest;
+
+            // Allows access to GetLocationPath for annotations.
+            friend class io::Printer;
+            friend class compiler::cpp::Formatter;
+
+            // Fill the json_name field of FieldDescriptorProto.
+            void CopyJsonNameTo(DescriptorProto* proto) const;
+
+            // Internal version of DebugString; controls the level of indenting for
+            // correct depth. Takes |options| to control debug-string options, and
+            // |include_opening_clause| to indicate whether the "message ... " part of the
+            // clause has already been generated (this varies depending on context).
+            void DebugString(int depth, std::string* contents, const DebugStringOptions& options, bool include_opening_clause) const;
+
+            // Walks up the descriptor tree to generate the source location path
+            // to this descriptor from the file root.
+            void GetLocationPath(std::vector<int>* output) const;
+
+            // True if this is a placeholder for an unknown type.
+            bool is_placeholder_ : 1;
+            // True if this is a placeholder and the type name wasn't fully-qualified.
+            bool is_unqualified_placeholder_ : 1;
+            // Well known type.  Stored like this to conserve space.
+            uint8_t well_known_type_ : 5;
+
+            // This points to the last field _number_ that is part of the sequence
+            // starting at 1, where
+            //     `desc->field(i)->number() == i + 1`
+            // A value of `0` means no field matches. That is, there are no fields or the
+            // first field is not field `1`.
+            // Uses 16-bit to avoid extra padding. Unlikely to have more than 2^16
+            // sequentially numbered fields in a message.
+            uint16_t sequential_field_limit_;
+
+            int field_count_;
+
+            // all_names_ = [name, full_name]
+            const std::string* all_names_;
+            const FileDescriptor* file_;
+            const Descriptor* containing_type_;
+            const MessageOptions* options_;
+
+            // These arrays are separated from their sizes to minimize padding on 64-bit.
+            FieldDescriptor* fields_;
+            OneofDescriptor* oneof_decls_;
+            Descriptor* nested_types_;
+            EnumDescriptor* enum_types_;
+            ExtensionRange* extension_ranges_;
+            FieldDescriptor* extensions_;
+            ReservedRange* reserved_ranges_;
+            const std::string** reserved_names_;
+
+            int oneof_decl_count_;
+            int real_oneof_decl_count_;
+            int nested_type_count_;
+            int enum_type_count_;
+            int extension_range_count_;
+            int extension_count_;
+            int reserved_range_count_;
+            int reserved_name_count_;
+
+            // IMPORTANT:  If you add a new field, make sure to search for all instances
+            // of Allocate<Descriptor>() and AllocateArray<Descriptor>() in descriptor.cc
+            // and update them to initialize the field.
+
+            // Must be constructed using DescriptorPool.
+            Descriptor()
+            {
+            }
+            friend class DescriptorBuilder;
+            friend class DescriptorPool;
+            friend class EnumDescriptor;
+            friend class FieldDescriptor;
+            friend class FileDescriptorTables;
+            friend class OneofDescriptor;
+            friend class MethodDescriptor;
+            friend class FileDescriptor;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Descriptor);
+        };
+
+        PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(Descriptor, 136);
+
+        // Describes a single field of a message.  To get the descriptor for a given
+        // field, first get the Descriptor for the message in which it is defined,
+        // then call Descriptor::FindFieldByName().  To get a FieldDescriptor for
+        // an extension, do one of the following:
+        // - Get the Descriptor or FileDescriptor for its containing scope, then
+        //   call Descriptor::FindExtensionByName() or
+        //   FileDescriptor::FindExtensionByName().
+        // - Given a DescriptorPool, call DescriptorPool::FindExtensionByNumber() or
+        //   DescriptorPool::FindExtensionByPrintableName().
+        // Use DescriptorPool to construct your own descriptors.
+        class PROTOBUF_EXPORT FieldDescriptor : private internal::SymbolBase
+        {
+        public:
+            typedef FieldDescriptorProto Proto;
+
+            // Identifies a field type.  0 is reserved for errors.  The order is weird
+            // for historical reasons.  Types 12 and up are new in proto2.
+            enum Type
+            {
+                TYPE_DOUBLE = 1,    // double, exactly eight bytes on the wire.
+                TYPE_FLOAT = 2,     // float, exactly four bytes on the wire.
+                TYPE_INT64 = 3,     // int64, varint on the wire.  Negative numbers
+                                    // take 10 bytes.  Use TYPE_SINT64 if negative
+                                    // values are likely.
+                TYPE_UINT64 = 4,    // uint64, varint on the wire.
+                TYPE_INT32 = 5,     // int32, varint on the wire.  Negative numbers
+                                    // take 10 bytes.  Use TYPE_SINT32 if negative
+                                    // values are likely.
+                TYPE_FIXED64 = 6,   // uint64, exactly eight bytes on the wire.
+                TYPE_FIXED32 = 7,   // uint32, exactly four bytes on the wire.
+                TYPE_BOOL = 8,      // bool, varint on the wire.
+                TYPE_STRING = 9,    // UTF-8 text.
+                TYPE_GROUP = 10,    // Tag-delimited message.  Deprecated.
+                TYPE_MESSAGE = 11,  // Length-delimited message.
+
+                TYPE_BYTES = 12,     // Arbitrary byte array.
+                TYPE_UINT32 = 13,    // uint32, varint on the wire
+                TYPE_ENUM = 14,      // Enum, varint on the wire
+                TYPE_SFIXED32 = 15,  // int32, exactly four bytes on the wire
+                TYPE_SFIXED64 = 16,  // int64, exactly eight bytes on the wire
+                TYPE_SINT32 = 17,    // int32, ZigZag-encoded varint on the wire
+                TYPE_SINT64 = 18,    // int64, ZigZag-encoded varint on the wire
+
+                MAX_TYPE = 18,  // Constant useful for defining lookup tables
+                                // indexed by Type.
+            };
+
+            // Specifies the C++ data type used to represent the field.  There is a
+            // fixed mapping from Type to CppType where each Type maps to exactly one
+            // CppType.  0 is reserved for errors.
+            enum CppType
+            {
+                CPPTYPE_INT32 = 1,     // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32
+                CPPTYPE_INT64 = 2,     // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64
+                CPPTYPE_UINT32 = 3,    // TYPE_UINT32, TYPE_FIXED32
+                CPPTYPE_UINT64 = 4,    // TYPE_UINT64, TYPE_FIXED64
+                CPPTYPE_DOUBLE = 5,    // TYPE_DOUBLE
+                CPPTYPE_FLOAT = 6,     // TYPE_FLOAT
+                CPPTYPE_BOOL = 7,      // TYPE_BOOL
+                CPPTYPE_ENUM = 8,      // TYPE_ENUM
+                CPPTYPE_STRING = 9,    // TYPE_STRING, TYPE_BYTES
+                CPPTYPE_MESSAGE = 10,  // TYPE_MESSAGE, TYPE_GROUP
+
+                MAX_CPPTYPE = 10,  // Constant useful for defining lookup tables
+                                   // indexed by CppType.
+            };
+
+            // Identifies whether the field is optional, required, or repeated.  0 is
+            // reserved for errors.
+            enum Label
+            {
+                LABEL_OPTIONAL = 1,  // optional
+                LABEL_REQUIRED = 2,  // required
+                LABEL_REPEATED = 3,  // repeated
+
+                MAX_LABEL = 3,  // Constant useful for defining lookup tables
+                                // indexed by Label.
+            };
+
+            // Valid field numbers are positive integers up to kMaxNumber.
+            static const int kMaxNumber = (1 << 29) - 1;
+
+            // First field number reserved for the protocol buffer library implementation.
+            // Users may not declare fields that use reserved numbers.
+            static const int kFirstReservedNumber = 19000;
+            // Last field number reserved for the protocol buffer library implementation.
+            // Users may not declare fields that use reserved numbers.
+            static const int kLastReservedNumber = 19999;
+
+            const std::string& name() const;       // Name of this field within the message.
+            const std::string& full_name() const;  // Fully-qualified name of the field.
+            const std::string& json_name() const;  // JSON name of this field.
+            const FileDescriptor* file() const;    // File in which this field was defined.
+            bool is_extension() const;             // Is this an extension field?
+            int number() const;                    // Declared tag number.
+
+            // Same as name() except converted to lower-case.  This (and especially the
+            // FindFieldByLowercaseName() method) can be useful when parsing formats
+            // which prefer to use lowercase naming style.  (Although, technically
+            // field names should be lowercased anyway according to the protobuf style
+            // guide, so this only makes a difference when dealing with old .proto files
+            // which do not follow the guide.)
+            const std::string& lowercase_name() const;
+
+            // Same as name() except converted to camel-case.  In this conversion, any
+            // time an underscore appears in the name, it is removed and the next
+            // letter is capitalized.  Furthermore, the first letter of the name is
+            // lower-cased.  Examples:
+            //   FooBar -> fooBar
+            //   foo_bar -> fooBar
+            //   fooBar -> fooBar
+            // This (and especially the FindFieldByCamelcaseName() method) can be useful
+            // when parsing formats which prefer to use camel-case naming style.
+            const std::string& camelcase_name() const;
+
+            Type type() const;                  // Declared type of this field.
+            const char* type_name() const;      // Name of the declared type.
+            CppType cpp_type() const;           // C++ type of this field.
+            const char* cpp_type_name() const;  // Name of the C++ type.
+            Label label() const;                // optional/required/repeated
+
+            bool is_required() const;  // shorthand for label() == LABEL_REQUIRED
+            bool is_optional() const;  // shorthand for label() == LABEL_OPTIONAL
+            bool is_repeated() const;  // shorthand for label() == LABEL_REPEATED
+            bool is_packable() const;  // shorthand for is_repeated() &&
+                                       //               IsTypePackable(type())
+            bool is_packed() const;    // shorthand for is_packable() &&
+                                       //               options().packed()
+            bool is_map() const;       // shorthand for type() == TYPE_MESSAGE &&
+                                       // message_type()->options().map_entry()
+
+            // Returns true if this field was syntactically written with "optional" in the
+            // .proto file. Excludes singular proto3 fields that do not have a label.
+            bool has_optional_keyword() const;
+
+            // Returns true if this field tracks presence, ie. does the field
+            // distinguish between "unset" and "present with default value."
+            // This includes required, optional, and oneof fields. It excludes maps,
+            // repeated fields, and singular proto3 fields without "optional".
+            //
+            // For fields where has_presence() == true, the return value of
+            // Reflection::HasField() is semantically meaningful.
+            bool has_presence() const;
+
+            // Index of this field within the message's field array, or the file or
+            // extension scope's extensions array.
+            int index() const;
+
+            // Does this field have an explicitly-declared default value?
+            bool has_default_value() const;
+
+            // Whether the user has specified the json_name field option in the .proto
+            // file.
+            bool has_json_name() const;
+
+            // Get the field default value if cpp_type() == CPPTYPE_INT32.  If no
+            // explicit default was defined, the default is 0.
+            int32_t default_value_int32_t() const;
+            int32_t default_value_int32() const
+            {
+                return default_value_int32_t();
+            }
+            // Get the field default value if cpp_type() == CPPTYPE_INT64.  If no
+            // explicit default was defined, the default is 0.
+            int64_t default_value_int64_t() const;
+            int64_t default_value_int64() const
+            {
+                return default_value_int64_t();
+            }
+            // Get the field default value if cpp_type() == CPPTYPE_UINT32.  If no
+            // explicit default was defined, the default is 0.
+            uint32_t default_value_uint32_t() const;
+            uint32_t default_value_uint32() const
+            {
+                return default_value_uint32_t();
+            }
+            // Get the field default value if cpp_type() == CPPTYPE_UINT64.  If no
+            // explicit default was defined, the default is 0.
+            uint64_t default_value_uint64_t() const;
+            uint64_t default_value_uint64() const
+            {
+                return default_value_uint64_t();
+            }
+            // Get the field default value if cpp_type() == CPPTYPE_FLOAT.  If no
+            // explicit default was defined, the default is 0.0.
+            float default_value_float() const;
+            // Get the field default value if cpp_type() == CPPTYPE_DOUBLE.  If no
+            // explicit default was defined, the default is 0.0.
+            double default_value_double() const;
+            // Get the field default value if cpp_type() == CPPTYPE_BOOL.  If no
+            // explicit default was defined, the default is false.
+            bool default_value_bool() const;
+            // Get the field default value if cpp_type() == CPPTYPE_ENUM.  If no
+            // explicit default was defined, the default is the first value defined
+            // in the enum type (all enum types are required to have at least one value).
+            // This never returns nullptr.
+            const EnumValueDescriptor* default_value_enum() const;
+            // Get the field default value if cpp_type() == CPPTYPE_STRING.  If no
+            // explicit default was defined, the default is the empty string.
+            const std::string& default_value_string() const;
+
+            // The Descriptor for the message of which this is a field.  For extensions,
+            // this is the extended type.  Never nullptr.
+            const Descriptor* containing_type() const;
+
+            // If the field is a member of a oneof, this is the one, otherwise this is
+            // nullptr.
+            const OneofDescriptor* containing_oneof() const;
+
+            // If the field is a member of a non-synthetic oneof, returns the descriptor
+            // for the oneof, otherwise returns nullptr.
+            const OneofDescriptor* real_containing_oneof() const;
+
+            // If the field is a member of a oneof, returns the index in that oneof.
+            int index_in_oneof() const;
+
+            // An extension may be declared within the scope of another message.  If this
+            // field is an extension (is_extension() is true), then extension_scope()
+            // returns that message, or nullptr if the extension was declared at global
+            // scope.  If this is not an extension, extension_scope() is undefined (may
+            // assert-fail).
+            const Descriptor* extension_scope() const;
+
+            // If type is TYPE_MESSAGE or TYPE_GROUP, returns a descriptor for the
+            // message or the group type.  Otherwise, returns null.
+            const Descriptor* message_type() const;
+            // If type is TYPE_ENUM, returns a descriptor for the enum.  Otherwise,
+            // returns null.
+            const EnumDescriptor* enum_type() const;
+
+            // Get the FieldOptions for this field.  This includes things listed in
+            // square brackets after the field definition.  E.g., the field:
+            //   optional string text = 1 [ctype=CORD];
+            // has the "ctype" option set.  Allowed options are defined by FieldOptions in
+            // descriptor.proto, and any available extensions of that message.
+            const FieldOptions& options() const;
+
+            // See Descriptor::CopyTo().
+            void CopyTo(FieldDescriptorProto* proto) const;
+
+            // See Descriptor::DebugString().
+            std::string DebugString() const;
+
+            // See Descriptor::DebugStringWithOptions().
+            std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+            // Helper method to get the CppType for a particular Type.
+            static CppType TypeToCppType(Type type);
+
+            // Helper method to get the name of a Type.
+            static const char* TypeName(Type type);
+
+            // Helper method to get the name of a CppType.
+            static const char* CppTypeName(CppType cpp_type);
+
+            // Return true iff [packed = true] is valid for fields of this type.
+            static inline bool IsTypePackable(Type field_type);
+
+            // Returns full_name() except if the field is a MessageSet extension,
+            // in which case it returns the full_name() of the containing message type
+            // for backwards compatibility with proto1.
+            //
+            // A MessageSet extension is defined as an optional message extension
+            // whose containing type has the message_set_wire_format option set.
+            // This should be true of extensions of google.protobuf.bridge.MessageSet;
+            // by convention, such extensions are named "message_set_extension".
+            //
+            // The opposite operation (looking up an extension's FieldDescriptor given
+            // its printable name) can be accomplished with
+            //     message->file()->pool()->FindExtensionByPrintableName(message, name)
+            // where the extension extends "message".
+            const std::string& PrintableNameForExtension() const;
+
+            // Source Location ---------------------------------------------------
+
+            // Updates |*out_location| to the source location of the complete
+            // extent of this field declaration.  Returns false and leaves
+            // |*out_location| unchanged iff location information was not available.
+            bool GetSourceLocation(SourceLocation* out_location) const;
+
+        private:
+            friend class Symbol;
+            typedef FieldOptions OptionsType;
+
+            // Allows access to GetLocationPath for annotations.
+            friend class io::Printer;
+            friend class compiler::cpp::Formatter;
+            friend class Reflection;
+
+            // Fill the json_name field of FieldDescriptorProto.
+            void CopyJsonNameTo(FieldDescriptorProto* proto) const;
+
+            // See Descriptor::DebugString().
+            void DebugString(int depth, std::string* contents, const DebugStringOptions& options) const;
+
+            // formats the default value appropriately and returns it as a string.
+            // Must have a default value to call this. If quote_string_type is true, then
+            // types of CPPTYPE_STRING whill be surrounded by quotes and CEscaped.
+            std::string DefaultValueAsString(bool quote_string_type) const;
+
+            // Helper function that returns the field type name for DebugString.
+            std::string FieldTypeNameDebugString() const;
+
+            // Walks up the descriptor tree to generate the source location path
+            // to this descriptor from the file root.
+            void GetLocationPath(std::vector<int>* output) const;
+
+            // Returns true if this is a map message type.
+            bool is_map_message_type() const;
+
+            bool has_default_value_ : 1;
+            bool proto3_optional_ : 1;
+            // Whether the user has specified the json_name field option in the .proto
+            // file.
+            bool has_json_name_ : 1;
+            bool is_extension_ : 1;
+            bool is_oneof_ : 1;
+
+            // Actually a `Label` but stored as uint8_t to save space.
+            uint8_t label_ : 2;
+
+            // Actually a `Type`, but stored as uint8_t to save space.
+            mutable uint8_t type_;
+
+            // Logically:
+            //   all_names_ = [name, full_name, lower, camel, json]
+            // However:
+            //   duplicates will be omitted, so lower/camel/json might be in the same
+            //   position.
+            // We store the true offset for each name here, and the bit width must be
+            // large enough to account for the worst case where all names are present.
+            uint8_t lowercase_name_index_ : 2;
+            uint8_t camelcase_name_index_ : 2;
+            uint8_t json_name_index_ : 3;
+            // Sadly, `number_` located here to reduce padding. Unrelated to all_names_
+            // and its indices above.
+            int number_;
+            const std::string* all_names_;
+            const FileDescriptor* file_;
+
+            // The once_flag is followed by a NUL terminated string for the type name and
+            // enum default value (or empty string if no default enum).
+            internal::once_flag* type_once_;
+            static void TypeOnceInit(const FieldDescriptor* to_init);
+            void InternalTypeOnceInit() const;
+            const Descriptor* containing_type_;
+            union
+            {
+                const OneofDescriptor* containing_oneof;
+                const Descriptor* extension_scope;
+            } scope_;
+            union
+            {
+                mutable const Descriptor* message_type;
+                mutable const EnumDescriptor* enum_type;
+            } type_descriptor_;
+            const FieldOptions* options_;
+            // IMPORTANT:  If you add a new field, make sure to search for all instances
+            // of Allocate<FieldDescriptor>() and AllocateArray<FieldDescriptor>() in
+            // descriptor.cc and update them to initialize the field.
+
+            union
+            {
+                int32_t default_value_int32_t_;
+                int64_t default_value_int64_t_;
+                uint32_t default_value_uint32_t_;
+                uint64_t default_value_uint64_t_;
+                float default_value_float_;
+                double default_value_double_;
+                bool default_value_bool_;
+
+                mutable const EnumValueDescriptor* default_value_enum_;
+                const std::string* default_value_string_;
+                mutable std::atomic<const Message*> default_generated_instance_;
+            };
+
+            static const CppType kTypeToCppTypeMap[MAX_TYPE + 1];
+
+            static const char* const kTypeToName[MAX_TYPE + 1];
+
+            static const char* const kCppTypeToName[MAX_CPPTYPE + 1];
+
+            static const char* const kLabelToName[MAX_LABEL + 1];
+
+            // Must be constructed using DescriptorPool.
+            FieldDescriptor()
+            {
+            }
+            friend class DescriptorBuilder;
+            friend class FileDescriptor;
+            friend class Descriptor;
+            friend class OneofDescriptor;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldDescriptor);
+        };
+
+        PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(FieldDescriptor, 72);
+
+        // Describes a oneof defined in a message type.
+        class PROTOBUF_EXPORT OneofDescriptor : private internal::SymbolBase
+        {
+        public:
+            typedef OneofDescriptorProto Proto;
+
+            const std::string& name() const;       // Name of this oneof.
+            const std::string& full_name() const;  // Fully-qualified name of the oneof.
+
+            // Index of this oneof within the message's oneof array.
+            int index() const;
+
+            // Returns whether this oneof was inserted by the compiler to wrap a proto3
+            // optional field. If this returns true, code generators should *not* emit it.
+            bool is_synthetic() const;
+
+            // The .proto file in which this oneof was defined.  Never nullptr.
+            const FileDescriptor* file() const;
+            // The Descriptor for the message containing this oneof.
+            const Descriptor* containing_type() const;
+
+            // The number of (non-extension) fields which are members of this oneof.
+            int field_count() const;
+            // Get a member of this oneof, in the order in which they were declared in the
+            // .proto file.  Does not include extensions.
+            const FieldDescriptor* field(int index) const;
+
+            const OneofOptions& options() const;
+
+            // See Descriptor::CopyTo().
+            void CopyTo(OneofDescriptorProto* proto) const;
+
+            // See Descriptor::DebugString().
+            std::string DebugString() const;
+
+            // See Descriptor::DebugStringWithOptions().
+            std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+            // Source Location ---------------------------------------------------
+
+            // Updates |*out_location| to the source location of the complete
+            // extent of this oneof declaration.  Returns false and leaves
+            // |*out_location| unchanged iff location information was not available.
+            bool GetSourceLocation(SourceLocation* out_location) const;
+
+        private:
+            friend class Symbol;
+            typedef OneofOptions OptionsType;
+
+            // Allows access to GetLocationPath for annotations.
+            friend class io::Printer;
+            friend class compiler::cpp::Formatter;
+
+            // See Descriptor::DebugString().
+            void DebugString(int depth, std::string* contents, const DebugStringOptions& options) const;
+
+            // Walks up the descriptor tree to generate the source location path
+            // to this descriptor from the file root.
+            void GetLocationPath(std::vector<int>* output) const;
+
+            int field_count_;
+
+            // all_names_ = [name, full_name]
+            const std::string* all_names_;
+            const Descriptor* containing_type_;
+            const OneofOptions* options_;
+            const FieldDescriptor* fields_;
+
+            // IMPORTANT:  If you add a new field, make sure to search for all instances
+            // of Allocate<OneofDescriptor>() and AllocateArray<OneofDescriptor>()
+            // in descriptor.cc and update them to initialize the field.
+
+            // Must be constructed using DescriptorPool.
+            OneofDescriptor()
+            {
+            }
+            friend class DescriptorBuilder;
+            friend class Descriptor;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OneofDescriptor);
+        };
 
+        PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(OneofDescriptor, 40);
+
+        // Describes an enum type defined in a .proto file.  To get the EnumDescriptor
+        // for a generated enum type, call TypeName_descriptor().  Use DescriptorPool
+        // to construct your own descriptors.
+        class PROTOBUF_EXPORT EnumDescriptor : private internal::SymbolBase
+        {
+        public:
+            typedef EnumDescriptorProto Proto;
+
+            // The name of this enum type in the containing scope.
+            const std::string& name() const;
+
+            // The fully-qualified name of the enum type, scope delimited by periods.
+            const std::string& full_name() const;
+
+            // Index of this enum within the file or containing message's enum array.
+            int index() const;
+
+            // The .proto file in which this enum type was defined.  Never nullptr.
+            const FileDescriptor* file() const;
+
+            // The number of values for this EnumDescriptor.  Guaranteed to be greater
+            // than zero.
+            int value_count() const;
+            // Gets a value by index, where 0 <= index < value_count().
+            // These are returned in the order they were defined in the .proto file.
+            const EnumValueDescriptor* value(int index) const;
+
+            // Looks up a value by name.  Returns nullptr if no such value exists.
+            const EnumValueDescriptor* FindValueByName(ConstStringParam name) const;
+            // Looks up a value by number.  Returns nullptr if no such value exists.  If
+            // multiple values have this number, the first one defined is returned.
+            const EnumValueDescriptor* FindValueByNumber(int number) const;
+
+            // If this enum type is nested in a message type, this is that message type.
+            // Otherwise, nullptr.
+            const Descriptor* containing_type() const;
+
+            // Get options for this enum type.  These are specified in the .proto file by
+            // placing lines like "option foo = 1234;" in the enum definition.  Allowed
+            // options are defined by EnumOptions in descriptor.proto, and any available
+            // extensions of that message.
+            const EnumOptions& options() const;
+
+            // See Descriptor::CopyTo().
+            void CopyTo(EnumDescriptorProto* proto) const;
+
+            // See Descriptor::DebugString().
+            std::string DebugString() const;
+
+            // See Descriptor::DebugStringWithOptions().
+            std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+            // Returns true if this is a placeholder for an unknown enum. This will
+            // only be the case if this descriptor comes from a DescriptorPool
+            // with AllowUnknownDependencies() set.
+            bool is_placeholder() const;
+
+            // Reserved fields -------------------------------------------------
+
+            // A range of reserved field numbers.
+            struct ReservedRange
+            {
+                int start;  // inclusive
+                int end;    // inclusive
+            };
+
+            // The number of reserved ranges in this message type.
+            int reserved_range_count() const;
+            // Gets an reserved range by index, where 0 <= index <
+            // reserved_range_count(). These are returned in the order they were defined
+            // in the .proto file.
+            const EnumDescriptor::ReservedRange* reserved_range(int index) const;
+
+            // Returns true if the number is in one of the reserved ranges.
+            bool IsReservedNumber(int number) const;
+
+            // Returns nullptr if no reserved range contains the given number.
+            const EnumDescriptor::ReservedRange* FindReservedRangeContainingNumber(
+                int number
+            ) const;
+
+            // The number of reserved field names in this message type.
+            int reserved_name_count() const;
+
+            // Gets a reserved name by index, where 0 <= index < reserved_name_count().
+            const std::string& reserved_name(int index) const;
+
+            // Returns true if the field name is reserved.
+            bool IsReservedName(ConstStringParam name) const;
+
+            // Source Location ---------------------------------------------------
+
+            // Updates |*out_location| to the source location of the complete
+            // extent of this enum declaration.  Returns false and leaves
+            // |*out_location| unchanged iff location information was not available.
+            bool GetSourceLocation(SourceLocation* out_location) const;
+
+        private:
+            friend class Symbol;
+            typedef EnumOptions OptionsType;
+
+            // Allows access to GetLocationPath for annotations.
+            friend class io::Printer;
+            friend class compiler::cpp::Formatter;
+
+            // Allow access to FindValueByNumberCreatingIfUnknown.
+            friend class descriptor_unittest::DescriptorTest;
+
+            // Looks up a value by number.  If the value does not exist, dynamically
+            // creates a new EnumValueDescriptor for that value, assuming that it was
+            // unknown. If a new descriptor is created, this is done in a thread-safe way,
+            // and future calls will return the same value descriptor pointer.
+            //
+            // This is private but is used by Reflection (which is friended below) to
+            // return a valid EnumValueDescriptor from GetEnum() when this feature is
+            // enabled.
+            const EnumValueDescriptor* FindValueByNumberCreatingIfUnknown(
+                int number
+            ) const;
+
+            // See Descriptor::DebugString().
+            void DebugString(int depth, std::string* contents, const DebugStringOptions& options) const;
+
+            // Walks up the descriptor tree to generate the source location path
+            // to this descriptor from the file root.
+            void GetLocationPath(std::vector<int>* output) const;
+
+            // True if this is a placeholder for an unknown type.
+            bool is_placeholder_ : 1;
+            // True if this is a placeholder and the type name wasn't fully-qualified.
+            bool is_unqualified_placeholder_ : 1;
+
+            // This points to the last value _index_ that is part of the sequence starting
+            // with the first label, where
+            //   `enum->value(i)->number() == enum->value(0)->number() + i`
+            // We measure relative to the first label to adapt to enum labels starting at
+            // 0 or 1.
+            // Uses 16-bit to avoid extra padding. Unlikely to have more than 2^15
+            // sequentially numbered labels in an enum.
+            int16_t sequential_value_limit_;
+
+            int value_count_;
+
+            // all_names_ = [name, full_name]
+            const std::string* all_names_;
+            const FileDescriptor* file_;
+            const Descriptor* containing_type_;
+            const EnumOptions* options_;
+            EnumValueDescriptor* values_;
+
+            int reserved_range_count_;
+            int reserved_name_count_;
+            EnumDescriptor::ReservedRange* reserved_ranges_;
+            const std::string** reserved_names_;
+
+            // IMPORTANT:  If you add a new field, make sure to search for all instances
+            // of Allocate<EnumDescriptor>() and AllocateArray<EnumDescriptor>() in
+            // descriptor.cc and update them to initialize the field.
+
+            // Must be constructed using DescriptorPool.
+            EnumDescriptor()
+            {
+            }
+            friend class DescriptorBuilder;
+            friend class Descriptor;
+            friend class FieldDescriptor;
+            friend class FileDescriptorTables;
+            friend class EnumValueDescriptor;
+            friend class FileDescriptor;
+            friend class DescriptorPool;
+            friend class Reflection;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumDescriptor);
+        };
+
+        PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(EnumDescriptor, 72);
+
+        // Describes an individual enum constant of a particular type.  To get the
+        // EnumValueDescriptor for a given enum value, first get the EnumDescriptor
+        // for its type, then use EnumDescriptor::FindValueByName() or
+        // EnumDescriptor::FindValueByNumber().  Use DescriptorPool to construct
+        // your own descriptors.
+        class PROTOBUF_EXPORT EnumValueDescriptor : private internal::SymbolBaseN<0>, private internal::SymbolBaseN<1>
+        {
+        public:
+            typedef EnumValueDescriptorProto Proto;
+
+            const std::string& name() const;  // Name of this enum constant.
+            int index() const;                // Index within the enums's Descriptor.
+            int number() const;               // Numeric value of this enum constant.
+
+            // The full_name of an enum value is a sibling symbol of the enum type.
+            // e.g. the full name of FieldDescriptorProto::TYPE_INT32 is actually
+            // "google.protobuf.FieldDescriptorProto.TYPE_INT32", NOT
+            // "google.protobuf.FieldDescriptorProto.Type.TYPE_INT32".  This is to conform
+            // with C++ scoping rules for enums.
+            const std::string& full_name() const;
+
+            // The .proto file in which this value was defined.  Never nullptr.
+            const FileDescriptor* file() const;
+            // The type of this value.  Never nullptr.
+            const EnumDescriptor* type() const;
+
+            // Get options for this enum value.  These are specified in the .proto file by
+            // adding text like "[foo = 1234]" after an enum value definition.  Allowed
+            // options are defined by EnumValueOptions in descriptor.proto, and any
+            // available extensions of that message.
+            const EnumValueOptions& options() const;
+
+            // See Descriptor::CopyTo().
+            void CopyTo(EnumValueDescriptorProto* proto) const;
+
+            // See Descriptor::DebugString().
+            std::string DebugString() const;
+
+            // See Descriptor::DebugStringWithOptions().
+            std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+            // Source Location ---------------------------------------------------
+
+            // Updates |*out_location| to the source location of the complete
+            // extent of this enum value declaration.  Returns false and leaves
+            // |*out_location| unchanged iff location information was not available.
+            bool GetSourceLocation(SourceLocation* out_location) const;
+
+        private:
+            friend class Symbol;
+            typedef EnumValueOptions OptionsType;
+
+            // Allows access to GetLocationPath for annotations.
+            friend class io::Printer;
+            friend class compiler::cpp::Formatter;
+
+            // See Descriptor::DebugString().
+            void DebugString(int depth, std::string* contents, const DebugStringOptions& options) const;
+
+            // Walks up the descriptor tree to generate the source location path
+            // to this descriptor from the file root.
+            void GetLocationPath(std::vector<int>* output) const;
+
+            int number_;
+            // all_names_ = [name, full_name]
+            const std::string* all_names_;
+            const EnumDescriptor* type_;
+            const EnumValueOptions* options_;
+            // IMPORTANT:  If you add a new field, make sure to search for all instances
+            // of Allocate<EnumValueDescriptor>() and AllocateArray<EnumValueDescriptor>()
+            // in descriptor.cc and update them to initialize the field.
+
+            // Must be constructed using DescriptorPool.
+            EnumValueDescriptor()
+            {
+            }
+            friend class DescriptorBuilder;
+            friend class EnumDescriptor;
+            friend class DescriptorPool;
+            friend class FileDescriptorTables;
+            friend class Reflection;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumValueDescriptor);
+        };
+
+        PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(EnumValueDescriptor, 32);
+
+        // Describes an RPC service. Use DescriptorPool to construct your own
+        // descriptors.
+        class PROTOBUF_EXPORT ServiceDescriptor : private internal::SymbolBase
+        {
+        public:
+            typedef ServiceDescriptorProto Proto;
+
+            // The name of the service, not including its containing scope.
+            const std::string& name() const;
+            // The fully-qualified name of the service, scope delimited by periods.
+            const std::string& full_name() const;
+            // Index of this service within the file's services array.
+            int index() const;
+
+            // The .proto file in which this service was defined.  Never nullptr.
+            const FileDescriptor* file() const;
+
+            // Get options for this service type.  These are specified in the .proto file
+            // by placing lines like "option foo = 1234;" in the service definition.
+            // Allowed options are defined by ServiceOptions in descriptor.proto, and any
+            // available extensions of that message.
+            const ServiceOptions& options() const;
+
+            // The number of methods this service defines.
+            int method_count() const;
+            // Gets a MethodDescriptor by index, where 0 <= index < method_count().
+            // These are returned in the order they were defined in the .proto file.
+            const MethodDescriptor* method(int index) const;
+
+            // Look up a MethodDescriptor by name.
+            const MethodDescriptor* FindMethodByName(ConstStringParam name) const;
+
+            // See Descriptor::CopyTo().
+            void CopyTo(ServiceDescriptorProto* proto) const;
+
+            // See Descriptor::DebugString().
+            std::string DebugString() const;
+
+            // See Descriptor::DebugStringWithOptions().
+            std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+            // Source Location ---------------------------------------------------
+
+            // Updates |*out_location| to the source location of the complete
+            // extent of this service declaration.  Returns false and leaves
+            // |*out_location| unchanged iff location information was not available.
+            bool GetSourceLocation(SourceLocation* out_location) const;
+
+        private:
+            friend class Symbol;
+            typedef ServiceOptions OptionsType;
+
+            // Allows access to GetLocationPath for annotations.
+            friend class io::Printer;
+            friend class compiler::cpp::Formatter;
+
+            // See Descriptor::DebugString().
+            void DebugString(std::string* contents, const DebugStringOptions& options) const;
+
+            // Walks up the descriptor tree to generate the source location path
+            // to this descriptor from the file root.
+            void GetLocationPath(std::vector<int>* output) const;
+
+            // all_names_ = [name, full_name]
+            const std::string* all_names_;
+            const FileDescriptor* file_;
+            const ServiceOptions* options_;
+            MethodDescriptor* methods_;
+            int method_count_;
+            // IMPORTANT:  If you add a new field, make sure to search for all instances
+            // of Allocate<ServiceDescriptor>() and AllocateArray<ServiceDescriptor>() in
+            // descriptor.cc and update them to initialize the field.
+
+            // Must be constructed using DescriptorPool.
+            ServiceDescriptor()
+            {
+            }
+            friend class DescriptorBuilder;
+            friend class FileDescriptor;
+            friend class MethodDescriptor;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ServiceDescriptor);
+        };
+
+        PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(ServiceDescriptor, 48);
+
+        // Describes an individual service method.  To obtain a MethodDescriptor given
+        // a service, first get its ServiceDescriptor, then call
+        // ServiceDescriptor::FindMethodByName().  Use DescriptorPool to construct your
+        // own descriptors.
+        class PROTOBUF_EXPORT MethodDescriptor : private internal::SymbolBase
+        {
+        public:
+            typedef MethodDescriptorProto Proto;
+
+            // Name of this method, not including containing scope.
+            const std::string& name() const;
+            // The fully-qualified name of the method, scope delimited by periods.
+            const std::string& full_name() const;
+            // Index within the service's Descriptor.
+            int index() const;
+
+            // The .proto file in which this method was defined.  Never nullptr.
+            const FileDescriptor* file() const;
+            // Gets the service to which this method belongs.  Never nullptr.
+            const ServiceDescriptor* service() const;
+
+            // Gets the type of protocol message which this method accepts as input.
+            const Descriptor* input_type() const;
+            // Gets the type of protocol message which this message produces as output.
+            const Descriptor* output_type() const;
+
+            // Gets whether the client streams multiple requests.
+            bool client_streaming() const;
+            // Gets whether the server streams multiple responses.
+            bool server_streaming() const;
+
+            // Get options for this method.  These are specified in the .proto file by
+            // placing lines like "option foo = 1234;" in curly-braces after a method
+            // declaration.  Allowed options are defined by MethodOptions in
+            // descriptor.proto, and any available extensions of that message.
+            const MethodOptions& options() const;
+
+            // See Descriptor::CopyTo().
+            void CopyTo(MethodDescriptorProto* proto) const;
+
+            // See Descriptor::DebugString().
+            std::string DebugString() const;
+
+            // See Descriptor::DebugStringWithOptions().
+            std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+            // Source Location ---------------------------------------------------
+
+            // Updates |*out_location| to the source location of the complete
+            // extent of this method declaration.  Returns false and leaves
+            // |*out_location| unchanged iff location information was not available.
+            bool GetSourceLocation(SourceLocation* out_location) const;
+
+        private:
+            friend class Symbol;
+            typedef MethodOptions OptionsType;
+
+            // Allows access to GetLocationPath for annotations.
+            friend class io::Printer;
+            friend class compiler::cpp::Formatter;
+
+            // See Descriptor::DebugString().
+            void DebugString(int depth, std::string* contents, const DebugStringOptions& options) const;
+
+            // Walks up the descriptor tree to generate the source location path
+            // to this descriptor from the file root.
+            void GetLocationPath(std::vector<int>* output) const;
+
+            bool client_streaming_;
+            bool server_streaming_;
+            // all_names_ = [name, full_name]
+            const std::string* all_names_;
+            const ServiceDescriptor* service_;
+            mutable internal::LazyDescriptor input_type_;
+            mutable internal::LazyDescriptor output_type_;
+            const MethodOptions* options_;
+            // IMPORTANT:  If you add a new field, make sure to search for all instances
+            // of Allocate<MethodDescriptor>() and AllocateArray<MethodDescriptor>() in
+            // descriptor.cc and update them to initialize the field.
+
+            // Must be constructed using DescriptorPool.
+            MethodDescriptor()
+            {
+            }
+            friend class DescriptorBuilder;
+            friend class ServiceDescriptor;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MethodDescriptor);
+        };
+
+        PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(MethodDescriptor, 64);
+
+        // Describes a whole .proto file.  To get the FileDescriptor for a compiled-in
+        // file, get the descriptor for something defined in that file and call
+        // descriptor->file().  Use DescriptorPool to construct your own descriptors.
+        class PROTOBUF_EXPORT FileDescriptor : private internal::SymbolBase
+        {
+        public:
+            typedef FileDescriptorProto Proto;
+
+            // The filename, relative to the source tree.
+            // e.g. "foo/bar/baz.proto"
+            const std::string& name() const;
+
+            // The package, e.g. "google.protobuf.compiler".
+            const std::string& package() const;
+
+            // The DescriptorPool in which this FileDescriptor and all its contents were
+            // allocated.  Never nullptr.
+            const DescriptorPool* pool() const;
+
+            // The number of files imported by this one.
+            int dependency_count() const;
+            // Gets an imported file by index, where 0 <= index < dependency_count().
+            // These are returned in the order they were defined in the .proto file.
+            const FileDescriptor* dependency(int index) const;
+
+            // The number of files public imported by this one.
+            // The public dependency list is a subset of the dependency list.
+            int public_dependency_count() const;
+            // Gets a public imported file by index, where 0 <= index <
+            // public_dependency_count().
+            // These are returned in the order they were defined in the .proto file.
+            const FileDescriptor* public_dependency(int index) const;
+
+            // The number of files that are imported for weak fields.
+            // The weak dependency list is a subset of the dependency list.
+            int weak_dependency_count() const;
+            // Gets a weak imported file by index, where 0 <= index <
+            // weak_dependency_count().
+            // These are returned in the order they were defined in the .proto file.
+            const FileDescriptor* weak_dependency(int index) const;
+
+            // Number of top-level message types defined in this file.  (This does not
+            // include nested types.)
+            int message_type_count() const;
+            // Gets a top-level message type, where 0 <= index < message_type_count().
+            // These are returned in the order they were defined in the .proto file.
+            const Descriptor* message_type(int index) const;
+
+            // Number of top-level enum types defined in this file.  (This does not
+            // include nested types.)
+            int enum_type_count() const;
+            // Gets a top-level enum type, where 0 <= index < enum_type_count().
+            // These are returned in the order they were defined in the .proto file.
+            const EnumDescriptor* enum_type(int index) const;
+
+            // Number of services defined in this file.
+            int service_count() const;
+            // Gets a service, where 0 <= index < service_count().
+            // These are returned in the order they were defined in the .proto file.
+            const ServiceDescriptor* service(int index) const;
+
+            // Number of extensions defined at file scope.  (This does not include
+            // extensions nested within message types.)
+            int extension_count() const;
+            // Gets an extension's descriptor, where 0 <= index < extension_count().
+            // These are returned in the order they were defined in the .proto file.
+            const FieldDescriptor* extension(int index) const;
+
+            // Get options for this file.  These are specified in the .proto file by
+            // placing lines like "option foo = 1234;" at the top level, outside of any
+            // other definitions.  Allowed options are defined by FileOptions in
+            // descriptor.proto, and any available extensions of that message.
+            const FileOptions& options() const;
+
+            // Syntax of this file.
+            enum Syntax
+            {
+                SYNTAX_UNKNOWN = 0,
+                SYNTAX_PROTO2 = 2,
+                SYNTAX_PROTO3 = 3,
+            };
+            Syntax syntax() const;
+            static const char* SyntaxName(Syntax syntax);
+
+            // Find a top-level message type by name (not full_name).  Returns nullptr if
+            // not found.
+            const Descriptor* FindMessageTypeByName(ConstStringParam name) const;
+            // Find a top-level enum type by name.  Returns nullptr if not found.
+            const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
+            // Find an enum value defined in any top-level enum by name.  Returns nullptr
+            // if not found.
+            const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
+            // Find a service definition by name.  Returns nullptr if not found.
+            const ServiceDescriptor* FindServiceByName(ConstStringParam name) const;
+            // Find a top-level extension definition by name.  Returns nullptr if not
+            // found.
+            const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
+            // Similar to FindExtensionByName(), but searches by lowercased-name.  See
+            // Descriptor::FindFieldByLowercaseName().
+            const FieldDescriptor* FindExtensionByLowercaseName(
+                ConstStringParam name
+            ) const;
+            // Similar to FindExtensionByName(), but searches by camelcased-name.  See
+            // Descriptor::FindFieldByCamelcaseName().
+            const FieldDescriptor* FindExtensionByCamelcaseName(
+                ConstStringParam name
+            ) const;
+
+            // See Descriptor::CopyTo().
+            // Notes:
+            // - This method does NOT copy source code information since it is relatively
+            //   large and rarely needed.  See CopySourceCodeInfoTo() below.
+            void CopyTo(FileDescriptorProto* proto) const;
+            // Write the source code information of this FileDescriptor into the given
+            // FileDescriptorProto.  See CopyTo() above.
+            void CopySourceCodeInfoTo(FileDescriptorProto* proto) const;
+            // Fill the json_name field of FieldDescriptorProto for all fields. Can only
+            // be called after CopyTo().
+            void CopyJsonNameTo(FileDescriptorProto* proto) const;
+
+            // See Descriptor::DebugString().
+            std::string DebugString() const;
+
+            // See Descriptor::DebugStringWithOptions().
+            std::string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+            // Returns true if this is a placeholder for an unknown file. This will
+            // only be the case if this descriptor comes from a DescriptorPool
+            // with AllowUnknownDependencies() set.
+            bool is_placeholder() const;
+
+            // Updates |*out_location| to the source location of the complete extent of
+            // this file declaration (namely, the empty path).
+            bool GetSourceLocation(SourceLocation* out_location) const;
+
+            // Updates |*out_location| to the source location of the complete
+            // extent of the declaration or declaration-part denoted by |path|.
+            // Returns false and leaves |*out_location| unchanged iff location
+            // information was not available.  (See SourceCodeInfo for
+            // description of path encoding.)
+            bool GetSourceLocation(const std::vector<int>& path, SourceLocation* out_location) const;
+
+        private:
+            friend class Symbol;
+            typedef FileOptions OptionsType;
+
+            bool is_placeholder_;
+            // Indicates the FileDescriptor is completed building. Used to verify
+            // that type accessor functions that can possibly build a dependent file
+            // aren't called during the process of building the file.
+            bool finished_building_;
+            // Actually a `Syntax` but stored as uint8_t to save space.
+            uint8_t syntax_;
+            // This one is here to fill the padding.
+            int extension_count_;
+
+            const std::string* name_;
+            const std::string* package_;
+            const DescriptorPool* pool_;
+
+            // dependencies_once_ contain a once_flag followed by N NUL terminated
+            // strings. Dependencies that do not need to be loaded will be empty. ie just
+            // {'\0'}
+            internal::once_flag* dependencies_once_;
+            static void DependenciesOnceInit(const FileDescriptor* to_init);
+            void InternalDependenciesOnceInit() const;
+
+            // These are arranged to minimize padding on 64-bit.
+            int dependency_count_;
+            int public_dependency_count_;
+            int weak_dependency_count_;
+            int message_type_count_;
+            int enum_type_count_;
+            int service_count_;
+
+            mutable const FileDescriptor** dependencies_;
+            int* public_dependencies_;
+            int* weak_dependencies_;
+            Descriptor* message_types_;
+            EnumDescriptor* enum_types_;
+            ServiceDescriptor* services_;
+            FieldDescriptor* extensions_;
+            const FileOptions* options_;
+
+            const FileDescriptorTables* tables_;
+            const SourceCodeInfo* source_code_info_;
+
+            // IMPORTANT:  If you add a new field, make sure to search for all instances
+            // of Allocate<FileDescriptor>() and AllocateArray<FileDescriptor>() in
+            // descriptor.cc and update them to initialize the field.
+
+            FileDescriptor()
+            {
+            }
+            friend class DescriptorBuilder;
+            friend class DescriptorPool;
+            friend class Descriptor;
+            friend class FieldDescriptor;
+            friend class internal::LazyDescriptor;
+            friend class OneofDescriptor;
+            friend class EnumDescriptor;
+            friend class EnumValueDescriptor;
+            friend class MethodDescriptor;
+            friend class ServiceDescriptor;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileDescriptor);
+        };
+
+        PROTOBUF_INTERNAL_CHECK_CLASS_SIZE(FileDescriptor, 144);
+
+        // ===================================================================
+
+        // Used to construct descriptors.
+        //
+        // Normally you won't want to build your own descriptors.  Message classes
+        // constructed by the protocol compiler will provide them for you.  However,
+        // if you are implementing Message on your own, or if you are writing a
+        // program which can operate on totally arbitrary types and needs to load
+        // them from some sort of database, you might need to.
+        //
+        // Since Descriptors are composed of a whole lot of cross-linked bits of
+        // data that would be a pain to put together manually, the
+        // DescriptorPool class is provided to make the process easier.  It can
+        // take a FileDescriptorProto (defined in descriptor.proto), validate it,
+        // and convert it to a set of nicely cross-linked Descriptors.
+        //
+        // DescriptorPool also helps with memory management.  Descriptors are
+        // composed of many objects containing static data and pointers to each
+        // other.  In all likelihood, when it comes time to delete this data,
+        // you'll want to delete it all at once.  In fact, it is not uncommon to
+        // have a whole pool of descriptors all cross-linked with each other which
+        // you wish to delete all at once.  This class represents such a pool, and
+        // handles the memory management for you.
+        //
+        // You can also search for descriptors within a DescriptorPool by name, and
+        // extensions by number.
+        class PROTOBUF_EXPORT DescriptorPool
+        {
+        public:
+            // Create a normal, empty DescriptorPool.
+            DescriptorPool();
+
+            // Constructs a DescriptorPool that, when it can't find something among the
+            // descriptors already in the pool, looks for it in the given
+            // DescriptorDatabase.
+            // Notes:
+            // - If a DescriptorPool is constructed this way, its BuildFile*() methods
+            //   must not be called (they will assert-fail).  The only way to populate
+            //   the pool with descriptors is to call the Find*By*() methods.
+            // - The Find*By*() methods may block the calling thread if the
+            //   DescriptorDatabase blocks.  This in turn means that parsing messages
+            //   may block if they need to look up extensions.
+            // - The Find*By*() methods will use mutexes for thread-safety, thus making
+            //   them slower even when they don't have to fall back to the database.
+            //   In fact, even the Find*By*() methods of descriptor objects owned by
+            //   this pool will be slower, since they will have to obtain locks too.
+            // - An ErrorCollector may optionally be given to collect validation errors
+            //   in files loaded from the database.  If not given, errors will be printed
+            //   to GOOGLE_LOG(ERROR).  Remember that files are built on-demand, so this
+            //   ErrorCollector may be called from any thread that calls one of the
+            //   Find*By*() methods.
+            // - The DescriptorDatabase must not be mutated during the lifetime of
+            //   the DescriptorPool. Even if the client takes care to avoid data races,
+            //   changes to the content of the DescriptorDatabase may not be reflected
+            //   in subsequent lookups in the DescriptorPool.
+            class ErrorCollector;
+            explicit DescriptorPool(DescriptorDatabase* fallback_database, ErrorCollector* error_collector = nullptr);
+
+            ~DescriptorPool();
+
+            // Get a pointer to the generated pool.  Generated protocol message classes
+            // which are compiled into the binary will allocate their descriptors in
+            // this pool.  Do not add your own descriptors to this pool.
+            static const DescriptorPool* generated_pool();
+
+            // Find a FileDescriptor in the pool by file name.  Returns nullptr if not
+            // found.
+            const FileDescriptor* FindFileByName(ConstStringParam name) const;
+
+            // Find the FileDescriptor in the pool which defines the given symbol.
+            // If any of the Find*ByName() methods below would succeed, then this is
+            // equivalent to calling that method and calling the result's file() method.
+            // Otherwise this returns nullptr.
+            const FileDescriptor* FindFileContainingSymbol(
+                ConstStringParam symbol_name
+            ) const;
+
+            // Looking up descriptors ------------------------------------------
+            // These find descriptors by fully-qualified name.  These will find both
+            // top-level descriptors and nested descriptors.  They return nullptr if not
+            // found.
+
+            const Descriptor* FindMessageTypeByName(ConstStringParam name) const;
+            const FieldDescriptor* FindFieldByName(ConstStringParam name) const;
+            const FieldDescriptor* FindExtensionByName(ConstStringParam name) const;
+            const OneofDescriptor* FindOneofByName(ConstStringParam name) const;
+            const EnumDescriptor* FindEnumTypeByName(ConstStringParam name) const;
+            const EnumValueDescriptor* FindEnumValueByName(ConstStringParam name) const;
+            const ServiceDescriptor* FindServiceByName(ConstStringParam name) const;
+            const MethodDescriptor* FindMethodByName(ConstStringParam name) const;
+
+            // Finds an extension of the given type by number.  The extendee must be
+            // a member of this DescriptorPool or one of its underlays.
+            const FieldDescriptor* FindExtensionByNumber(const Descriptor* extendee, int number) const;
+
+            // Finds an extension of the given type by its printable name.
+            // See comments above PrintableNameForExtension() for the definition of
+            // "printable name".  The extendee must be a member of this DescriptorPool
+            // or one of its underlays.  Returns nullptr if there is no known message
+            // extension with the given printable name.
+            const FieldDescriptor* FindExtensionByPrintableName(
+                const Descriptor* extendee, ConstStringParam printable_name
+            ) const;
+
+            // Finds extensions of extendee. The extensions will be appended to
+            // out in an undefined order. Only extensions defined directly in
+            // this DescriptorPool or one of its underlays are guaranteed to be
+            // found: extensions defined in the fallback database might not be found
+            // depending on the database implementation.
+            void FindAllExtensions(const Descriptor* extendee, std::vector<const FieldDescriptor*>* out) const;
+
+            // Building descriptors --------------------------------------------
+
+            // When converting a FileDescriptorProto to a FileDescriptor, various
+            // errors might be detected in the input.  The caller may handle these
+            // programmatically by implementing an ErrorCollector.
+            class PROTOBUF_EXPORT ErrorCollector
+            {
+            public:
+                inline ErrorCollector()
+                {
+                }
+                virtual ~ErrorCollector();
+
+                // These constants specify what exact part of the construct is broken.
+                // This is useful e.g. for mapping the error back to an exact location
+                // in a .proto file.
+                enum ErrorLocation
+                {
+                    NAME,           // the symbol name, or the package name for files
+                    NUMBER,         // field or extension range number
+                    TYPE,           // field type
+                    EXTENDEE,       // field extendee
+                    DEFAULT_VALUE,  // field default value
+                    INPUT_TYPE,     // method input type
+                    OUTPUT_TYPE,    // method output type
+                    OPTION_NAME,    // name in assignment
+                    OPTION_VALUE,   // value in option assignment
+                    IMPORT,         // import error
+                    OTHER           // some other problem
+                };
+
+                // Reports an error in the FileDescriptorProto. Use this function if the
+                // problem occurred should interrupt building the FileDescriptorProto.
+                virtual void AddError(
+                    const std::string& filename,      // File name in which the error occurred.
+                    const std::string& element_name,  // Full name of the erroneous element.
+                    const Message* descriptor,        // Descriptor of the erroneous element.
+                    ErrorLocation location,           // One of the location constants, above.
+                    const std::string& message        // Human-readable error message.
+                ) = 0;
+
+                // Reports a warning in the FileDescriptorProto. Use this function if the
+                // problem occurred should NOT interrupt building the FileDescriptorProto.
+                virtual void AddWarning(
+                    const std::string& /*filename*/,      // File name in which the error
+                                                          // occurred.
+                    const std::string& /*element_name*/,  // Full name of the erroneous
+                                                          // element.
+                    const Message* /*descriptor*/,        // Descriptor of the erroneous element.
+                    ErrorLocation /*location*/,           // One of the location constants, above.
+                    const std::string& /*message*/        // Human-readable error message.
+                )
+                {
+                }
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
+            };
+
+            // Convert the FileDescriptorProto to real descriptors and place them in
+            // this DescriptorPool.  All dependencies of the file must already be in
+            // the pool.  Returns the resulting FileDescriptor, or nullptr if there were
+            // problems with the input (e.g. the message was invalid, or dependencies
+            // were missing).  Details about the errors are written to GOOGLE_LOG(ERROR).
+            const FileDescriptor* BuildFile(const FileDescriptorProto& proto);
+
+            // Same as BuildFile() except errors are sent to the given ErrorCollector.
+            const FileDescriptor* BuildFileCollectingErrors(
+                const FileDescriptorProto& proto, ErrorCollector* error_collector
+            );
+
+            // By default, it is an error if a FileDescriptorProto contains references
+            // to types or other files that are not found in the DescriptorPool (or its
+            // backing DescriptorDatabase, if any).  If you call
+            // AllowUnknownDependencies(), however, then unknown types and files
+            // will be replaced by placeholder descriptors (which can be identified by
+            // the is_placeholder() method).  This can allow you to
+            // perform some useful operations with a .proto file even if you do not
+            // have access to other .proto files on which it depends.  However, some
+            // heuristics must be used to fill in the gaps in information, and these
+            // can lead to descriptors which are inaccurate.  For example, the
+            // DescriptorPool may be forced to guess whether an unknown type is a message
+            // or an enum, as well as what package it resides in.  Furthermore,
+            // placeholder types will not be discoverable via FindMessageTypeByName()
+            // and similar methods, which could confuse some descriptor-based algorithms.
+            // Generally, the results of this option should be handled with extreme care.
+            void AllowUnknownDependencies()
+            {
+                allow_unknown_ = true;
+            }
+
+            // By default, weak imports are allowed to be missing, in which case we will
+            // use a placeholder for the dependency and convert the field to be an Empty
+            // message field. If you call EnforceWeakDependencies(true), however, the
+            // DescriptorPool will report a import not found error.
+            void EnforceWeakDependencies(bool enforce)
+            {
+                enforce_weak_ = enforce;
+            }
+
+            // Internal stuff --------------------------------------------------
+            // These methods MUST NOT be called from outside the proto2 library.
+            // These methods may contain hidden pitfalls and may be removed in a
+            // future library version.
+
+            // Create a DescriptorPool which is overlaid on top of some other pool.
+            // If you search for a descriptor in the overlay and it is not found, the
+            // underlay will be searched as a backup.  If the underlay has its own
+            // underlay, that will be searched next, and so on.  This also means that
+            // files built in the overlay will be cross-linked with the underlay's
+            // descriptors if necessary.  The underlay remains property of the caller;
+            // it must remain valid for the lifetime of the newly-constructed pool.
+            //
+            // Example:  Say you want to parse a .proto file at runtime in order to use
+            // its type with a DynamicMessage.  Say this .proto file has dependencies,
+            // but you know that all the dependencies will be things that are already
+            // compiled into the binary.  For ease of use, you'd like to load the types
+            // right out of generated_pool() rather than have to parse redundant copies
+            // of all these .protos and runtime.  But, you don't want to add the parsed
+            // types directly into generated_pool(): this is not allowed, and would be
+            // bad design anyway.  So, instead, you could use generated_pool() as an
+            // underlay for a new DescriptorPool in which you add only the new file.
+            //
+            // WARNING:  Use of underlays can lead to many subtle gotchas.  Instead,
+            //   try to formulate what you want to do in terms of DescriptorDatabases.
+            explicit DescriptorPool(const DescriptorPool* underlay);
+
+            // Called by generated classes at init time to add their descriptors to
+            // generated_pool.  Do NOT call this in your own code!  filename must be a
+            // permanent string (e.g. a string literal).
+            static void InternalAddGeneratedFile(const void* encoded_file_descriptor, int size);
+
+            // Disallow [enforce_utf8 = false] in .proto files.
+            void DisallowEnforceUtf8()
+            {
+                disallow_enforce_utf8_ = true;
+            }
+
+            // For internal use only:  Gets a non-const pointer to the generated pool.
+            // This is called at static-initialization time only, so thread-safety is
+            // not a concern.  If both an underlay and a fallback database are present,
+            // the underlay takes precedence.
+            static DescriptorPool* internal_generated_pool();
+
+            // For internal use only:  Gets a non-const pointer to the generated
+            // descriptor database.
+            // Only used for testing.
+            static DescriptorDatabase* internal_generated_database();
+
+            // For internal use only:  Changes the behavior of BuildFile() such that it
+            // allows the file to make reference to message types declared in other files
+            // which it did not officially declare as dependencies.
+            void InternalDontEnforceDependencies();
+
+            // For internal use only: Enables lazy building of dependencies of a file.
+            // Delay the building of dependencies of a file descriptor until absolutely
+            // necessary, like when message_type() is called on a field that is defined
+            // in that dependency's file. This will cause functional issues if a proto
+            // or one of its dependencies has errors. Should only be enabled for the
+            // generated_pool_ (because no descriptor build errors are guaranteed by
+            // the compilation generation process), testing, or if a lack of descriptor
+            // build errors can be guaranteed for a pool.
+            void InternalSetLazilyBuildDependencies()
+            {
+                lazily_build_dependencies_ = true;
+                // This needs to be set when lazily building dependencies, as it breaks
+                // dependency checking.
+                InternalDontEnforceDependencies();
+            }
+
+            // For internal use only.
+            void internal_set_underlay(const DescriptorPool* underlay)
+            {
+                underlay_ = underlay;
+            }
+
+            // For internal (unit test) use only:  Returns true if a FileDescriptor has
+            // been constructed for the given file, false otherwise.  Useful for testing
+            // lazy descriptor initialization behavior.
+            bool InternalIsFileLoaded(ConstStringParam filename) const;
+
+            // Add a file to unused_import_track_files_. DescriptorBuilder will log
+            // warnings or errors for those files if there is any unused import.
+            void AddUnusedImportTrackFile(ConstStringParam file_name, bool is_error = false);
+            void ClearUnusedImportTrackFiles();
+
+        private:
+            friend class Descriptor;
+            friend class internal::LazyDescriptor;
+            friend class FieldDescriptor;
+            friend class EnumDescriptor;
+            friend class ServiceDescriptor;
+            friend class MethodDescriptor;
+            friend class FileDescriptor;
+            friend class DescriptorBuilder;
+            friend class FileDescriptorTables;
+
+            // Return true if the given name is a sub-symbol of any non-package
+            // descriptor that already exists in the descriptor pool.  (The full
+            // definition of such types is already known.)
+            bool IsSubSymbolOfBuiltType(StringPiece name) const;
+
+            // Tries to find something in the fallback database and link in the
+            // corresponding proto file.  Returns true if successful, in which case
+            // the caller should search for the thing again.  These are declared
+            // const because they are called by (semantically) const methods.
+            bool TryFindFileInFallbackDatabase(StringPiece name) const;
+            bool TryFindSymbolInFallbackDatabase(StringPiece name) const;
+            bool TryFindExtensionInFallbackDatabase(const Descriptor* containing_type, int field_number) const;
+
+            // This internal find extension method only check with its table and underlay
+            // descriptor_pool's table. It does not check with fallback DB and no
+            // additional proto file will be build in this method.
+            const FieldDescriptor* InternalFindExtensionByNumberNoLock(
+                const Descriptor* extendee, int number
+            ) const;
+
+            // Like BuildFile() but called internally when the file has been loaded from
+            // fallback_database_.  Declared const because it is called by (semantically)
+            // const methods.
+            const FileDescriptor* BuildFileFromDatabase(
+                const FileDescriptorProto& proto
+            ) const;
+
+            // Helper for when lazily_build_dependencies_ is set, can look up a symbol
+            // after the file's descriptor is built, and can build the file where that
+            // symbol is defined if necessary. Will create a placeholder if the type
+            // doesn't exist in the fallback database, or the file doesn't build
+            // successfully.
+            Symbol CrossLinkOnDemandHelper(StringPiece name, bool expecting_enum) const;
+
+            // Create a placeholder FileDescriptor of the specified name
+            FileDescriptor* NewPlaceholderFile(StringPiece name) const;
+            FileDescriptor* NewPlaceholderFileWithMutexHeld(
+                StringPiece name, internal::FlatAllocator& alloc
+            ) const;
+
+            enum PlaceholderType
+            {
+                PLACEHOLDER_MESSAGE,
+                PLACEHOLDER_ENUM,
+                PLACEHOLDER_EXTENDABLE_MESSAGE
+            };
+            // Create a placeholder Descriptor of the specified name
+            Symbol NewPlaceholder(StringPiece name, PlaceholderType placeholder_type) const;
+            Symbol NewPlaceholderWithMutexHeld(StringPiece name, PlaceholderType placeholder_type) const;
+
+            // If fallback_database_ is nullptr, this is nullptr.  Otherwise, this is a
+            // mutex which must be locked while accessing tables_.
+            internal::WrappedMutex* mutex_;
+
+            // See constructor.
+            DescriptorDatabase* fallback_database_;
+            ErrorCollector* default_error_collector_;
+            const DescriptorPool* underlay_;
+
+            // This class contains a lot of hash maps with complicated types that
+            // we'd like to keep out of the header.
+            class Tables;
+            std::unique_ptr<Tables> tables_;
+
+            bool enforce_dependencies_;
+            bool lazily_build_dependencies_;
+            bool allow_unknown_;
+            bool enforce_weak_;
+            bool disallow_enforce_utf8_;
+
+            // Set of files to track for unused imports. The bool value when true means
+            // unused imports are treated as errors (and as warnings when false).
+            std::map<std::string, bool> unused_import_track_files_;
+
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPool);
+        };
 
 // inline methods ====================================================
 
 // These macros makes this repetitive code more readable.
 #define PROTOBUF_DEFINE_ACCESSOR(CLASS, FIELD, TYPE) \
-  inline TYPE CLASS::FIELD() const { return FIELD##_; }
+    inline TYPE CLASS::FIELD() const                 \
+    {                                                \
+        return FIELD##_;                             \
+    }
 
 // Strings fields are stored as pointers but returned as const references.
 #define PROTOBUF_DEFINE_STRING_ACCESSOR(CLASS, FIELD) \
-  inline const std::string& CLASS::FIELD() const { return *FIELD##_; }
+    inline const std::string& CLASS::FIELD() const    \
+    {                                                 \
+        return *FIELD##_;                             \
+    }
 
 // Name and full name are stored in a single array to save space.
-#define PROTOBUF_DEFINE_NAME_ACCESSOR(CLASS)                              \
-  inline const std::string& CLASS::name() const { return all_names_[0]; } \
-  inline const std::string& CLASS::full_name() const { return all_names_[1]; }
+#define PROTOBUF_DEFINE_NAME_ACCESSOR(CLASS)           \
+    inline const std::string& CLASS::name() const      \
+    {                                                  \
+        return all_names_[0];                          \
+    }                                                  \
+    inline const std::string& CLASS::full_name() const \
+    {                                                  \
+        return all_names_[1];                          \
+    }
 
 // Arrays take an index parameter, obviously.
 #define PROTOBUF_DEFINE_ARRAY_ACCESSOR(CLASS, FIELD, TYPE) \
-  inline TYPE CLASS::FIELD(int index) const { return FIELD##s_ + index; }
+    inline TYPE CLASS::FIELD(int index) const              \
+    {                                                      \
+        return FIELD##s_ + index;                          \
+    }
 
 #define PROTOBUF_DEFINE_OPTIONS_ACCESSOR(CLASS, TYPE) \
-  inline const TYPE& CLASS::options() const { return *options_; }
-
-PROTOBUF_DEFINE_NAME_ACCESSOR(Descriptor)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, containing_type, const Descriptor*)
-
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, field_count, int)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, oneof_decl_count, int)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, real_oneof_decl_count, int)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, nested_type_count, int)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, enum_type_count, int)
-
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, field, const FieldDescriptor*)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, oneof_decl, const OneofDescriptor*)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, nested_type, const Descriptor*)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, enum_type, const EnumDescriptor*)
-
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_range_count, int)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_count, int)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension_range,
-                               const Descriptor::ExtensionRange*)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension, const FieldDescriptor*)
-
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_range_count, int)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, reserved_range,
-                               const Descriptor::ReservedRange*)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_name_count, int)
-
-PROTOBUF_DEFINE_OPTIONS_ACCESSOR(Descriptor, MessageOptions)
-PROTOBUF_DEFINE_ACCESSOR(Descriptor, is_placeholder, bool)
-
-PROTOBUF_DEFINE_NAME_ACCESSOR(FieldDescriptor)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, file, const FileDescriptor*)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, number, int)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, is_extension, bool)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, containing_type, const Descriptor*)
-PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FieldDescriptor, FieldOptions)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_default_value, bool)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_json_name, bool)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32_t, int32_t)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64_t, int64_t)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint32_t, uint32_t)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint64_t, uint64_t)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float, float)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_double, double)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool, bool)
-PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, default_value_string)
-
-PROTOBUF_DEFINE_NAME_ACCESSOR(OneofDescriptor)
-PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, containing_type, const Descriptor*)
-PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, field_count, int)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(OneofDescriptor, field, const FieldDescriptor*)
-PROTOBUF_DEFINE_OPTIONS_ACCESSOR(OneofDescriptor, OneofOptions)
-
-PROTOBUF_DEFINE_NAME_ACCESSOR(EnumDescriptor)
-PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, file, const FileDescriptor*)
-PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, containing_type, const Descriptor*)
-PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, value_count, int)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, value,
-                               const EnumValueDescriptor*)
-PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumDescriptor, EnumOptions)
-PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, is_placeholder, bool)
-PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_range_count, int)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, reserved_range,
-                               const EnumDescriptor::ReservedRange*)
-PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_name_count, int)
-
-PROTOBUF_DEFINE_NAME_ACCESSOR(EnumValueDescriptor)
-PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, number, int)
-PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, type, const EnumDescriptor*)
-PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumValueDescriptor, EnumValueOptions)
-
-PROTOBUF_DEFINE_NAME_ACCESSOR(ServiceDescriptor)
-PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, file, const FileDescriptor*)
-PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, method_count, int)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(ServiceDescriptor, method,
-                               const MethodDescriptor*)
-PROTOBUF_DEFINE_OPTIONS_ACCESSOR(ServiceDescriptor, ServiceOptions)
-
-PROTOBUF_DEFINE_NAME_ACCESSOR(MethodDescriptor)
-PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, service, const ServiceDescriptor*)
-PROTOBUF_DEFINE_OPTIONS_ACCESSOR(MethodDescriptor, MethodOptions)
-PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, client_streaming, bool)
-PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, server_streaming, bool)
-
-PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, name)
-PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, package)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, pool, const DescriptorPool*)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, dependency_count, int)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, public_dependency_count, int)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, weak_dependency_count, int)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, message_type_count, int)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, enum_type_count, int)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, service_count, int)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, extension_count, int)
-PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FileDescriptor, FileOptions)
-PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, is_placeholder, bool)
-
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, message_type, const Descriptor*)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, enum_type, const EnumDescriptor*)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, service,
-                               const ServiceDescriptor*)
-PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, extension,
-                               const FieldDescriptor*)
+    inline const TYPE& CLASS::options() const         \
+    {                                                 \
+        return *options_;                             \
+    }
+
+        PROTOBUF_DEFINE_NAME_ACCESSOR(Descriptor)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, containing_type, const Descriptor*)
+
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, field_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, oneof_decl_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, real_oneof_decl_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, nested_type_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, enum_type_count, int)
+
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, field, const FieldDescriptor*)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, oneof_decl, const OneofDescriptor*)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, nested_type, const Descriptor*)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, enum_type, const EnumDescriptor*)
+
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_range_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_count, int)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension_range, const Descriptor::ExtensionRange*)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension, const FieldDescriptor*)
+
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_range_count, int)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, reserved_range, const Descriptor::ReservedRange*)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_name_count, int)
+
+        PROTOBUF_DEFINE_OPTIONS_ACCESSOR(Descriptor, MessageOptions)
+        PROTOBUF_DEFINE_ACCESSOR(Descriptor, is_placeholder, bool)
+
+        PROTOBUF_DEFINE_NAME_ACCESSOR(FieldDescriptor)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, file, const FileDescriptor*)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, number, int)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, is_extension, bool)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, containing_type, const Descriptor*)
+        PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FieldDescriptor, FieldOptions)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_default_value, bool)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_json_name, bool)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32_t, int32_t)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64_t, int64_t)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint32_t, uint32_t)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint64_t, uint64_t)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float, float)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_double, double)
+        PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool, bool)
+        PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, default_value_string)
+
+        PROTOBUF_DEFINE_NAME_ACCESSOR(OneofDescriptor)
+        PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, containing_type, const Descriptor*)
+        PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, field_count, int)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(OneofDescriptor, field, const FieldDescriptor*)
+        PROTOBUF_DEFINE_OPTIONS_ACCESSOR(OneofDescriptor, OneofOptions)
+
+        PROTOBUF_DEFINE_NAME_ACCESSOR(EnumDescriptor)
+        PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, file, const FileDescriptor*)
+        PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, containing_type, const Descriptor*)
+        PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, value_count, int)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, value, const EnumValueDescriptor*)
+        PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumDescriptor, EnumOptions)
+        PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, is_placeholder, bool)
+        PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_range_count, int)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, reserved_range, const EnumDescriptor::ReservedRange*)
+        PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_name_count, int)
+
+        PROTOBUF_DEFINE_NAME_ACCESSOR(EnumValueDescriptor)
+        PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, number, int)
+        PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, type, const EnumDescriptor*)
+        PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumValueDescriptor, EnumValueOptions)
+
+        PROTOBUF_DEFINE_NAME_ACCESSOR(ServiceDescriptor)
+        PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, file, const FileDescriptor*)
+        PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, method_count, int)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(ServiceDescriptor, method, const MethodDescriptor*)
+        PROTOBUF_DEFINE_OPTIONS_ACCESSOR(ServiceDescriptor, ServiceOptions)
+
+        PROTOBUF_DEFINE_NAME_ACCESSOR(MethodDescriptor)
+        PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, service, const ServiceDescriptor*)
+        PROTOBUF_DEFINE_OPTIONS_ACCESSOR(MethodDescriptor, MethodOptions)
+        PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, client_streaming, bool)
+        PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, server_streaming, bool)
+
+        PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, name)
+        PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, package)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, pool, const DescriptorPool*)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, dependency_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, public_dependency_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, weak_dependency_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, message_type_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, enum_type_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, service_count, int)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, extension_count, int)
+        PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FileDescriptor, FileOptions)
+        PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, is_placeholder, bool)
+
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, message_type, const Descriptor*)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, enum_type, const EnumDescriptor*)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, service, const ServiceDescriptor*)
+        PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, extension, const FieldDescriptor*)
 
 #undef PROTOBUF_DEFINE_ACCESSOR
 #undef PROTOBUF_DEFINE_STRING_ACCESSOR
 #undef PROTOBUF_DEFINE_ARRAY_ACCESSOR
 
-// A few accessors differ from the macros...
-
-inline Descriptor::WellKnownType Descriptor::well_known_type() const {
-  return static_cast<Descriptor::WellKnownType>(well_known_type_);
-}
-
-inline bool Descriptor::IsExtensionNumber(int number) const {
-  return FindExtensionRangeContainingNumber(number) != nullptr;
-}
-
-inline bool Descriptor::IsReservedNumber(int number) const {
-  return FindReservedRangeContainingNumber(number) != nullptr;
-}
-
-inline bool Descriptor::IsReservedName(ConstStringParam name) const {
-  for (int i = 0; i < reserved_name_count(); i++) {
-    if (name == static_cast<ConstStringParam>(reserved_name(i))) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
-// an array of pointers rather than the usual array of objects.
-inline const std::string& Descriptor::reserved_name(int index) const {
-  return *reserved_names_[index];
-}
-
-inline bool EnumDescriptor::IsReservedNumber(int number) const {
-  return FindReservedRangeContainingNumber(number) != nullptr;
-}
-
-inline bool EnumDescriptor::IsReservedName(ConstStringParam name) const {
-  for (int i = 0; i < reserved_name_count(); i++) {
-    if (name == static_cast<ConstStringParam>(reserved_name(i))) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
-// an array of pointers rather than the usual array of objects.
-inline const std::string& EnumDescriptor::reserved_name(int index) const {
-  return *reserved_names_[index];
-}
-
-inline const std::string& FieldDescriptor::lowercase_name() const {
-  return all_names_[lowercase_name_index_];
-}
-
-inline const std::string& FieldDescriptor::camelcase_name() const {
-  return all_names_[camelcase_name_index_];
-}
-
-inline const std::string& FieldDescriptor::json_name() const {
-  return all_names_[json_name_index_];
-}
-
-inline const OneofDescriptor* FieldDescriptor::containing_oneof() const {
-  return is_oneof_ ? scope_.containing_oneof : nullptr;
-}
-
-inline int FieldDescriptor::index_in_oneof() const {
-  GOOGLE_DCHECK(is_oneof_);
-  return static_cast<int>(this - scope_.containing_oneof->field(0));
-}
-
-inline const Descriptor* FieldDescriptor::extension_scope() const {
-  GOOGLE_CHECK(is_extension_);
-  return scope_.extension_scope;
-}
-
-inline FieldDescriptor::Label FieldDescriptor::label() const {
-  return static_cast<Label>(label_);
-}
-
-inline FieldDescriptor::Type FieldDescriptor::type() const {
-  if (type_once_) {
-    internal::call_once(*type_once_, &FieldDescriptor::TypeOnceInit, this);
-  }
-  return static_cast<Type>(type_);
-}
-
-inline bool FieldDescriptor::is_required() const {
-  return label() == LABEL_REQUIRED;
-}
-
-inline bool FieldDescriptor::is_optional() const {
-  return label() == LABEL_OPTIONAL;
-}
-
-inline bool FieldDescriptor::is_repeated() const {
-  return label() == LABEL_REPEATED;
-}
-
-inline bool FieldDescriptor::is_packable() const {
-  return is_repeated() && IsTypePackable(type());
-}
-
-inline bool FieldDescriptor::is_map() const {
-  return type() == TYPE_MESSAGE && is_map_message_type();
-}
-
-inline bool FieldDescriptor::has_optional_keyword() const {
-  return proto3_optional_ ||
-         (file()->syntax() == FileDescriptor::SYNTAX_PROTO2 && is_optional() &&
-          !containing_oneof());
-}
-
-inline const OneofDescriptor* FieldDescriptor::real_containing_oneof() const {
-  auto* oneof = containing_oneof();
-  return oneof && !oneof->is_synthetic() ? oneof : nullptr;
-}
-
-inline bool FieldDescriptor::has_presence() const {
-  if (is_repeated()) return false;
-  return cpp_type() == CPPTYPE_MESSAGE || containing_oneof() ||
-         file()->syntax() == FileDescriptor::SYNTAX_PROTO2;
-}
-
-// To save space, index() is computed by looking at the descriptor's position
-// in the parent's array of children.
-inline int FieldDescriptor::index() const {
-  if (!is_extension_) {
-    return static_cast<int>(this - containing_type()->fields_);
-  } else if (extension_scope() != nullptr) {
-    return static_cast<int>(this - extension_scope()->extensions_);
-  } else {
-    return static_cast<int>(this - file_->extensions_);
-  }
-}
-
-inline int Descriptor::index() const {
-  if (containing_type_ == nullptr) {
-    return static_cast<int>(this - file_->message_types_);
-  } else {
-    return static_cast<int>(this - containing_type_->nested_types_);
-  }
-}
-
-inline const FileDescriptor* OneofDescriptor::file() const {
-  return containing_type()->file();
-}
-
-inline int OneofDescriptor::index() const {
-  return static_cast<int>(this - containing_type_->oneof_decls_);
-}
-
-inline bool OneofDescriptor::is_synthetic() const {
-  return field_count() == 1 && field(0)->proto3_optional_;
-}
-
-inline int EnumDescriptor::index() const {
-  if (containing_type_ == nullptr) {
-    return static_cast<int>(this - file_->enum_types_);
-  } else {
-    return static_cast<int>(this - containing_type_->enum_types_);
-  }
-}
-
-inline const FileDescriptor* EnumValueDescriptor::file() const {
-  return type()->file();
-}
-
-inline int EnumValueDescriptor::index() const {
-  return static_cast<int>(this - type_->values_);
-}
-
-inline int ServiceDescriptor::index() const {
-  return static_cast<int>(this - file_->services_);
-}
-
-inline const FileDescriptor* MethodDescriptor::file() const {
-  return service()->file();
-}
-
-inline int MethodDescriptor::index() const {
-  return static_cast<int>(this - service_->methods_);
-}
-
-inline const char* FieldDescriptor::type_name() const {
-  return kTypeToName[type()];
-}
-
-inline FieldDescriptor::CppType FieldDescriptor::cpp_type() const {
-  return kTypeToCppTypeMap[type()];
-}
-
-inline const char* FieldDescriptor::cpp_type_name() const {
-  return kCppTypeToName[kTypeToCppTypeMap[type()]];
-}
-
-inline FieldDescriptor::CppType FieldDescriptor::TypeToCppType(Type type) {
-  return kTypeToCppTypeMap[type];
-}
-
-inline const char* FieldDescriptor::TypeName(Type type) {
-  return kTypeToName[type];
-}
-
-inline const char* FieldDescriptor::CppTypeName(CppType cpp_type) {
-  return kCppTypeToName[cpp_type];
-}
-
-inline bool FieldDescriptor::IsTypePackable(Type field_type) {
-  return (field_type != FieldDescriptor::TYPE_STRING &&
-          field_type != FieldDescriptor::TYPE_GROUP &&
-          field_type != FieldDescriptor::TYPE_MESSAGE &&
-          field_type != FieldDescriptor::TYPE_BYTES);
-}
-
-inline const FileDescriptor* FileDescriptor::public_dependency(
-    int index) const {
-  return dependency(public_dependencies_[index]);
-}
-
-inline const FileDescriptor* FileDescriptor::weak_dependency(int index) const {
-  return dependency(weak_dependencies_[index]);
-}
-
-inline FileDescriptor::Syntax FileDescriptor::syntax() const {
-  return static_cast<Syntax>(syntax_);
-}
-
-}  // namespace protobuf
+        // A few accessors differ from the macros...
+
+        inline Descriptor::WellKnownType Descriptor::well_known_type() const
+        {
+            return static_cast<Descriptor::WellKnownType>(well_known_type_);
+        }
+
+        inline bool Descriptor::IsExtensionNumber(int number) const
+        {
+            return FindExtensionRangeContainingNumber(number) != nullptr;
+        }
+
+        inline bool Descriptor::IsReservedNumber(int number) const
+        {
+            return FindReservedRangeContainingNumber(number) != nullptr;
+        }
+
+        inline bool Descriptor::IsReservedName(ConstStringParam name) const
+        {
+            for (int i = 0; i < reserved_name_count(); i++)
+            {
+                if (name == static_cast<ConstStringParam>(reserved_name(i)))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        // Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
+        // an array of pointers rather than the usual array of objects.
+        inline const std::string& Descriptor::reserved_name(int index) const
+        {
+            return *reserved_names_[index];
+        }
+
+        inline bool EnumDescriptor::IsReservedNumber(int number) const
+        {
+            return FindReservedRangeContainingNumber(number) != nullptr;
+        }
+
+        inline bool EnumDescriptor::IsReservedName(ConstStringParam name) const
+        {
+            for (int i = 0; i < reserved_name_count(); i++)
+            {
+                if (name == static_cast<ConstStringParam>(reserved_name(i)))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        // Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
+        // an array of pointers rather than the usual array of objects.
+        inline const std::string& EnumDescriptor::reserved_name(int index) const
+        {
+            return *reserved_names_[index];
+        }
+
+        inline const std::string& FieldDescriptor::lowercase_name() const
+        {
+            return all_names_[lowercase_name_index_];
+        }
+
+        inline const std::string& FieldDescriptor::camelcase_name() const
+        {
+            return all_names_[camelcase_name_index_];
+        }
+
+        inline const std::string& FieldDescriptor::json_name() const
+        {
+            return all_names_[json_name_index_];
+        }
+
+        inline const OneofDescriptor* FieldDescriptor::containing_oneof() const
+        {
+            return is_oneof_ ? scope_.containing_oneof : nullptr;
+        }
+
+        inline int FieldDescriptor::index_in_oneof() const
+        {
+            GOOGLE_DCHECK(is_oneof_);
+            return static_cast<int>(this - scope_.containing_oneof->field(0));
+        }
+
+        inline const Descriptor* FieldDescriptor::extension_scope() const
+        {
+            GOOGLE_CHECK(is_extension_);
+            return scope_.extension_scope;
+        }
+
+        inline FieldDescriptor::Label FieldDescriptor::label() const
+        {
+            return static_cast<Label>(label_);
+        }
+
+        inline FieldDescriptor::Type FieldDescriptor::type() const
+        {
+            if (type_once_)
+            {
+                internal::call_once(*type_once_, &FieldDescriptor::TypeOnceInit, this);
+            }
+            return static_cast<Type>(type_);
+        }
+
+        inline bool FieldDescriptor::is_required() const
+        {
+            return label() == LABEL_REQUIRED;
+        }
+
+        inline bool FieldDescriptor::is_optional() const
+        {
+            return label() == LABEL_OPTIONAL;
+        }
+
+        inline bool FieldDescriptor::is_repeated() const
+        {
+            return label() == LABEL_REPEATED;
+        }
+
+        inline bool FieldDescriptor::is_packable() const
+        {
+            return is_repeated() && IsTypePackable(type());
+        }
+
+        inline bool FieldDescriptor::is_map() const
+        {
+            return type() == TYPE_MESSAGE && is_map_message_type();
+        }
+
+        inline bool FieldDescriptor::has_optional_keyword() const
+        {
+            return proto3_optional_ ||
+                   (file()->syntax() == FileDescriptor::SYNTAX_PROTO2 && is_optional() &&
+                    !containing_oneof());
+        }
+
+        inline const OneofDescriptor* FieldDescriptor::real_containing_oneof() const
+        {
+            auto* oneof = containing_oneof();
+            return oneof && !oneof->is_synthetic() ? oneof : nullptr;
+        }
+
+        inline bool FieldDescriptor::has_presence() const
+        {
+            if (is_repeated())
+                return false;
+            return cpp_type() == CPPTYPE_MESSAGE || containing_oneof() ||
+                   file()->syntax() == FileDescriptor::SYNTAX_PROTO2;
+        }
+
+        // To save space, index() is computed by looking at the descriptor's position
+        // in the parent's array of children.
+        inline int FieldDescriptor::index() const
+        {
+            if (!is_extension_)
+            {
+                return static_cast<int>(this - containing_type()->fields_);
+            }
+            else if (extension_scope() != nullptr)
+            {
+                return static_cast<int>(this - extension_scope()->extensions_);
+            }
+            else
+            {
+                return static_cast<int>(this - file_->extensions_);
+            }
+        }
+
+        inline int Descriptor::index() const
+        {
+            if (containing_type_ == nullptr)
+            {
+                return static_cast<int>(this - file_->message_types_);
+            }
+            else
+            {
+                return static_cast<int>(this - containing_type_->nested_types_);
+            }
+        }
+
+        inline const FileDescriptor* OneofDescriptor::file() const
+        {
+            return containing_type()->file();
+        }
+
+        inline int OneofDescriptor::index() const
+        {
+            return static_cast<int>(this - containing_type_->oneof_decls_);
+        }
+
+        inline bool OneofDescriptor::is_synthetic() const
+        {
+            return field_count() == 1 && field(0)->proto3_optional_;
+        }
+
+        inline int EnumDescriptor::index() const
+        {
+            if (containing_type_ == nullptr)
+            {
+                return static_cast<int>(this - file_->enum_types_);
+            }
+            else
+            {
+                return static_cast<int>(this - containing_type_->enum_types_);
+            }
+        }
+
+        inline const FileDescriptor* EnumValueDescriptor::file() const
+        {
+            return type()->file();
+        }
+
+        inline int EnumValueDescriptor::index() const
+        {
+            return static_cast<int>(this - type_->values_);
+        }
+
+        inline int ServiceDescriptor::index() const
+        {
+            return static_cast<int>(this - file_->services_);
+        }
+
+        inline const FileDescriptor* MethodDescriptor::file() const
+        {
+            return service()->file();
+        }
+
+        inline int MethodDescriptor::index() const
+        {
+            return static_cast<int>(this - service_->methods_);
+        }
+
+        inline const char* FieldDescriptor::type_name() const
+        {
+            return kTypeToName[type()];
+        }
+
+        inline FieldDescriptor::CppType FieldDescriptor::cpp_type() const
+        {
+            return kTypeToCppTypeMap[type()];
+        }
+
+        inline const char* FieldDescriptor::cpp_type_name() const
+        {
+            return kCppTypeToName[kTypeToCppTypeMap[type()]];
+        }
+
+        inline FieldDescriptor::CppType FieldDescriptor::TypeToCppType(Type type)
+        {
+            return kTypeToCppTypeMap[type];
+        }
+
+        inline const char* FieldDescriptor::TypeName(Type type)
+        {
+            return kTypeToName[type];
+        }
+
+        inline const char* FieldDescriptor::CppTypeName(CppType cpp_type)
+        {
+            return kCppTypeToName[cpp_type];
+        }
+
+        inline bool FieldDescriptor::IsTypePackable(Type field_type)
+        {
+            return (field_type != FieldDescriptor::TYPE_STRING && field_type != FieldDescriptor::TYPE_GROUP && field_type != FieldDescriptor::TYPE_MESSAGE && field_type != FieldDescriptor::TYPE_BYTES);
+        }
+
+        inline const FileDescriptor* FileDescriptor::public_dependency(
+            int index
+        ) const
+        {
+            return dependency(public_dependencies_[index]);
+        }
+
+        inline const FileDescriptor* FileDescriptor::weak_dependency(int index) const
+        {
+            return dependency(weak_dependencies_[index]);
+        }
+
+        inline FileDescriptor::Syntax FileDescriptor::syntax() const
+        {
+            return static_cast<Syntax>(syntax_);
+        }
+
+    }  // namespace protobuf
 }  // namespace google
 
 #undef PROTOBUF_INTERNAL_CHECK_CLASS_SIZE
diff --git a/CAPI/cpp/grpc/include/google/protobuf/descriptor.pb.h b/CAPI/cpp/grpc/include/google/protobuf/descriptor.pb.h
index 2d9c790..329b74e 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/descriptor.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/descriptor.pb.h
@@ -28,21 +28,23 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fdescriptor_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fdescriptor_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fdescriptor_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fdescriptor_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -129,55 +131,83 @@ struct UninterpretedOption_NamePartDefaultTypeInternal;
 PROTOBUF_EXPORT extern UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorSet* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorSet>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MessageOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MessageOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceOptions>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileDescriptorSet* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileDescriptorSet>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FileOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MessageOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MessageOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::MethodOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::OneofOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ServiceOptions* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceOptions>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
-enum FieldDescriptorProto_Type : int {
-  FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
-  FieldDescriptorProto_Type_TYPE_FLOAT = 2,
-  FieldDescriptorProto_Type_TYPE_INT64 = 3,
-  FieldDescriptorProto_Type_TYPE_UINT64 = 4,
-  FieldDescriptorProto_Type_TYPE_INT32 = 5,
-  FieldDescriptorProto_Type_TYPE_FIXED64 = 6,
-  FieldDescriptorProto_Type_TYPE_FIXED32 = 7,
-  FieldDescriptorProto_Type_TYPE_BOOL = 8,
-  FieldDescriptorProto_Type_TYPE_STRING = 9,
-  FieldDescriptorProto_Type_TYPE_GROUP = 10,
-  FieldDescriptorProto_Type_TYPE_MESSAGE = 11,
-  FieldDescriptorProto_Type_TYPE_BYTES = 12,
-  FieldDescriptorProto_Type_TYPE_UINT32 = 13,
-  FieldDescriptorProto_Type_TYPE_ENUM = 14,
-  FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,
-  FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,
-  FieldDescriptorProto_Type_TYPE_SINT32 = 17,
-  FieldDescriptorProto_Type_TYPE_SINT64 = 18
+enum FieldDescriptorProto_Type : int
+{
+    FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
+    FieldDescriptorProto_Type_TYPE_FLOAT = 2,
+    FieldDescriptorProto_Type_TYPE_INT64 = 3,
+    FieldDescriptorProto_Type_TYPE_UINT64 = 4,
+    FieldDescriptorProto_Type_TYPE_INT32 = 5,
+    FieldDescriptorProto_Type_TYPE_FIXED64 = 6,
+    FieldDescriptorProto_Type_TYPE_FIXED32 = 7,
+    FieldDescriptorProto_Type_TYPE_BOOL = 8,
+    FieldDescriptorProto_Type_TYPE_STRING = 9,
+    FieldDescriptorProto_Type_TYPE_GROUP = 10,
+    FieldDescriptorProto_Type_TYPE_MESSAGE = 11,
+    FieldDescriptorProto_Type_TYPE_BYTES = 12,
+    FieldDescriptorProto_Type_TYPE_UINT32 = 13,
+    FieldDescriptorProto_Type_TYPE_ENUM = 14,
+    FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,
+    FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,
+    FieldDescriptorProto_Type_TYPE_SINT32 = 17,
+    FieldDescriptorProto_Type_TYPE_SINT64 = 18
 };
 PROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value);
 constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE;
@@ -186,22 +216,26 @@ constexpr int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Ty
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Type_descriptor();
 template<typename T>
-inline const std::string& FieldDescriptorProto_Type_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, FieldDescriptorProto_Type>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function FieldDescriptorProto_Type_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    FieldDescriptorProto_Type_descriptor(), enum_t_value);
+inline const std::string& FieldDescriptorProto_Type_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, FieldDescriptorProto_Type>::value || ::std::is_integral<T>::value, "Incorrect type passed to function FieldDescriptorProto_Type_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        FieldDescriptorProto_Type_descriptor(), enum_t_value
+    );
 }
 inline bool FieldDescriptorProto_Type_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Type* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Type>(
-    FieldDescriptorProto_Type_descriptor(), name, value);
-}
-enum FieldDescriptorProto_Label : int {
-  FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
-  FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
-  FieldDescriptorProto_Label_LABEL_REPEATED = 3
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Type* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Type>(
+        FieldDescriptorProto_Type_descriptor(), name, value
+    );
+}
+enum FieldDescriptorProto_Label : int
+{
+    FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
+    FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
+    FieldDescriptorProto_Label_LABEL_REPEATED = 3
 };
 PROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value);
 constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL;
@@ -210,22 +244,26 @@ constexpr int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldDescriptorProto_Label_descriptor();
 template<typename T>
-inline const std::string& FieldDescriptorProto_Label_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, FieldDescriptorProto_Label>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function FieldDescriptorProto_Label_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    FieldDescriptorProto_Label_descriptor(), enum_t_value);
+inline const std::string& FieldDescriptorProto_Label_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, FieldDescriptorProto_Label>::value || ::std::is_integral<T>::value, "Incorrect type passed to function FieldDescriptorProto_Label_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        FieldDescriptorProto_Label_descriptor(), enum_t_value
+    );
 }
 inline bool FieldDescriptorProto_Label_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Label* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Label>(
-    FieldDescriptorProto_Label_descriptor(), name, value);
-}
-enum FileOptions_OptimizeMode : int {
-  FileOptions_OptimizeMode_SPEED = 1,
-  FileOptions_OptimizeMode_CODE_SIZE = 2,
-  FileOptions_OptimizeMode_LITE_RUNTIME = 3
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldDescriptorProto_Label* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldDescriptorProto_Label>(
+        FieldDescriptorProto_Label_descriptor(), name, value
+    );
+}
+enum FileOptions_OptimizeMode : int
+{
+    FileOptions_OptimizeMode_SPEED = 1,
+    FileOptions_OptimizeMode_CODE_SIZE = 2,
+    FileOptions_OptimizeMode_LITE_RUNTIME = 3
 };
 PROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value);
 constexpr FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED;
@@ -234,22 +272,26 @@ constexpr int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_Opti
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FileOptions_OptimizeMode_descriptor();
 template<typename T>
-inline const std::string& FileOptions_OptimizeMode_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, FileOptions_OptimizeMode>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function FileOptions_OptimizeMode_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    FileOptions_OptimizeMode_descriptor(), enum_t_value);
+inline const std::string& FileOptions_OptimizeMode_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, FileOptions_OptimizeMode>::value || ::std::is_integral<T>::value, "Incorrect type passed to function FileOptions_OptimizeMode_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        FileOptions_OptimizeMode_descriptor(), enum_t_value
+    );
 }
 inline bool FileOptions_OptimizeMode_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FileOptions_OptimizeMode* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FileOptions_OptimizeMode>(
-    FileOptions_OptimizeMode_descriptor(), name, value);
-}
-enum FieldOptions_CType : int {
-  FieldOptions_CType_STRING = 0,
-  FieldOptions_CType_CORD = 1,
-  FieldOptions_CType_STRING_PIECE = 2
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FileOptions_OptimizeMode* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FileOptions_OptimizeMode>(
+        FileOptions_OptimizeMode_descriptor(), name, value
+    );
+}
+enum FieldOptions_CType : int
+{
+    FieldOptions_CType_STRING = 0,
+    FieldOptions_CType_CORD = 1,
+    FieldOptions_CType_STRING_PIECE = 2
 };
 PROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value);
 constexpr FieldOptions_CType FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING;
@@ -258,22 +300,26 @@ constexpr int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldOptions_CType_descriptor();
 template<typename T>
-inline const std::string& FieldOptions_CType_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, FieldOptions_CType>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function FieldOptions_CType_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    FieldOptions_CType_descriptor(), enum_t_value);
+inline const std::string& FieldOptions_CType_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, FieldOptions_CType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function FieldOptions_CType_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        FieldOptions_CType_descriptor(), enum_t_value
+    );
 }
 inline bool FieldOptions_CType_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldOptions_CType* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_CType>(
-    FieldOptions_CType_descriptor(), name, value);
-}
-enum FieldOptions_JSType : int {
-  FieldOptions_JSType_JS_NORMAL = 0,
-  FieldOptions_JSType_JS_STRING = 1,
-  FieldOptions_JSType_JS_NUMBER = 2
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldOptions_CType* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_CType>(
+        FieldOptions_CType_descriptor(), name, value
+    );
+}
+enum FieldOptions_JSType : int
+{
+    FieldOptions_JSType_JS_NORMAL = 0,
+    FieldOptions_JSType_JS_STRING = 1,
+    FieldOptions_JSType_JS_NUMBER = 2
 };
 PROTOBUF_EXPORT bool FieldOptions_JSType_IsValid(int value);
 constexpr FieldOptions_JSType FieldOptions_JSType_JSType_MIN = FieldOptions_JSType_JS_NORMAL;
@@ -282,22 +328,26 @@ constexpr int FieldOptions_JSType_JSType_ARRAYSIZE = FieldOptions_JSType_JSType_
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FieldOptions_JSType_descriptor();
 template<typename T>
-inline const std::string& FieldOptions_JSType_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, FieldOptions_JSType>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function FieldOptions_JSType_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    FieldOptions_JSType_descriptor(), enum_t_value);
+inline const std::string& FieldOptions_JSType_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, FieldOptions_JSType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function FieldOptions_JSType_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        FieldOptions_JSType_descriptor(), enum_t_value
+    );
 }
 inline bool FieldOptions_JSType_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldOptions_JSType* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_JSType>(
-    FieldOptions_JSType_descriptor(), name, value);
-}
-enum MethodOptions_IdempotencyLevel : int {
-  MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN = 0,
-  MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS = 1,
-  MethodOptions_IdempotencyLevel_IDEMPOTENT = 2
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FieldOptions_JSType* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FieldOptions_JSType>(
+        FieldOptions_JSType_descriptor(), name, value
+    );
+}
+enum MethodOptions_IdempotencyLevel : int
+{
+    MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN = 0,
+    MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS = 1,
+    MethodOptions_IdempotencyLevel_IDEMPOTENT = 2
 };
 PROTOBUF_EXPORT bool MethodOptions_IdempotencyLevel_IsValid(int value);
 constexpr MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN = MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
@@ -306,8273 +356,10179 @@ constexpr int MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE = Method
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MethodOptions_IdempotencyLevel_descriptor();
 template<typename T>
-inline const std::string& MethodOptions_IdempotencyLevel_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, MethodOptions_IdempotencyLevel>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function MethodOptions_IdempotencyLevel_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    MethodOptions_IdempotencyLevel_descriptor(), enum_t_value);
+inline const std::string& MethodOptions_IdempotencyLevel_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, MethodOptions_IdempotencyLevel>::value || ::std::is_integral<T>::value, "Incorrect type passed to function MethodOptions_IdempotencyLevel_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        MethodOptions_IdempotencyLevel_descriptor(), enum_t_value
+    );
 }
 inline bool MethodOptions_IdempotencyLevel_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MethodOptions_IdempotencyLevel* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MethodOptions_IdempotencyLevel>(
-    MethodOptions_IdempotencyLevel_descriptor(), name, value);
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MethodOptions_IdempotencyLevel* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MethodOptions_IdempotencyLevel>(
+        MethodOptions_IdempotencyLevel_descriptor(), name, value
+    );
 }
 // ===================================================================
 
 class PROTOBUF_EXPORT FileDescriptorSet final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorSet) */ {
- public:
-  inline FileDescriptorSet() : FileDescriptorSet(nullptr) {}
-  ~FileDescriptorSet() override;
-  explicit PROTOBUF_CONSTEXPR FileDescriptorSet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  FileDescriptorSet(const FileDescriptorSet& from);
-  FileDescriptorSet(FileDescriptorSet&& from) noexcept
-    : FileDescriptorSet() {
-    *this = ::std::move(from);
-  }
-
-  inline FileDescriptorSet& operator=(const FileDescriptorSet& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FileDescriptorSet& operator=(FileDescriptorSet&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const FileDescriptorSet& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const FileDescriptorSet* internal_default_instance() {
-    return reinterpret_cast<const FileDescriptorSet*>(
-               &_FileDescriptorSet_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(FileDescriptorSet& a, FileDescriptorSet& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FileDescriptorSet* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(FileDescriptorSet* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  FileDescriptorSet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<FileDescriptorSet>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const FileDescriptorSet& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const FileDescriptorSet& from) {
-    FileDescriptorSet::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(FileDescriptorSet* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.FileDescriptorSet";
-  }
-  protected:
-  explicit FileDescriptorSet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFileFieldNumber = 1,
-  };
-  // repeated .google.protobuf.FileDescriptorProto file = 1;
-  int file_size() const;
-  private:
-  int _internal_file_size() const;
-  public:
-  void clear_file();
-  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* mutable_file(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
-      mutable_file();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& _internal_file(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _internal_add_file();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& file(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* add_file();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
-      file() const;
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorSet)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto > file_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorSet) */
+{
+public:
+    inline FileDescriptorSet() :
+        FileDescriptorSet(nullptr)
+    {
+    }
+    ~FileDescriptorSet() override;
+    explicit PROTOBUF_CONSTEXPR FileDescriptorSet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    FileDescriptorSet(const FileDescriptorSet& from);
+    FileDescriptorSet(FileDescriptorSet&& from) noexcept
+        :
+        FileDescriptorSet()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline FileDescriptorSet& operator=(const FileDescriptorSet& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline FileDescriptorSet& operator=(FileDescriptorSet&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const FileDescriptorSet& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const FileDescriptorSet* internal_default_instance()
+    {
+        return reinterpret_cast<const FileDescriptorSet*>(
+            &_FileDescriptorSet_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(FileDescriptorSet& a, FileDescriptorSet& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(FileDescriptorSet* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(FileDescriptorSet* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    FileDescriptorSet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<FileDescriptorSet>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const FileDescriptorSet& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const FileDescriptorSet& from)
+    {
+        FileDescriptorSet::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(FileDescriptorSet* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.FileDescriptorSet";
+    }
+
+protected:
+    explicit FileDescriptorSet(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kFileFieldNumber = 1,
+    };
+    // repeated .google.protobuf.FileDescriptorProto file = 1;
+    int file_size() const;
+
+private:
+    int _internal_file_size() const;
+
+public:
+    void clear_file();
+    ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* mutable_file(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>*
+        mutable_file();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& _internal_file(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _internal_add_file();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& file(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* add_file();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>&
+        file() const;
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorSet)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto> file_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT FileDescriptorProto final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorProto) */ {
- public:
-  inline FileDescriptorProto() : FileDescriptorProto(nullptr) {}
-  ~FileDescriptorProto() override;
-  explicit PROTOBUF_CONSTEXPR FileDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  FileDescriptorProto(const FileDescriptorProto& from);
-  FileDescriptorProto(FileDescriptorProto&& from) noexcept
-    : FileDescriptorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline FileDescriptorProto& operator=(const FileDescriptorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FileDescriptorProto& operator=(FileDescriptorProto&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const FileDescriptorProto& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const FileDescriptorProto* internal_default_instance() {
-    return reinterpret_cast<const FileDescriptorProto*>(
-               &_FileDescriptorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(FileDescriptorProto& a, FileDescriptorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FileDescriptorProto* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(FileDescriptorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  FileDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<FileDescriptorProto>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const FileDescriptorProto& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const FileDescriptorProto& from) {
-    FileDescriptorProto::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(FileDescriptorProto* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.FileDescriptorProto";
-  }
-  protected:
-  explicit FileDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kDependencyFieldNumber = 3,
-    kMessageTypeFieldNumber = 4,
-    kEnumTypeFieldNumber = 5,
-    kServiceFieldNumber = 6,
-    kExtensionFieldNumber = 7,
-    kPublicDependencyFieldNumber = 10,
-    kWeakDependencyFieldNumber = 11,
-    kNameFieldNumber = 1,
-    kPackageFieldNumber = 2,
-    kSyntaxFieldNumber = 12,
-    kOptionsFieldNumber = 8,
-    kSourceCodeInfoFieldNumber = 9,
-  };
-  // repeated string dependency = 3;
-  int dependency_size() const;
-  private:
-  int _internal_dependency_size() const;
-  public:
-  void clear_dependency();
-  const std::string& dependency(int index) const;
-  std::string* mutable_dependency(int index);
-  void set_dependency(int index, const std::string& value);
-  void set_dependency(int index, std::string&& value);
-  void set_dependency(int index, const char* value);
-  void set_dependency(int index, const char* value, size_t size);
-  std::string* add_dependency();
-  void add_dependency(const std::string& value);
-  void add_dependency(std::string&& value);
-  void add_dependency(const char* value);
-  void add_dependency(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dependency() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dependency();
-  private:
-  const std::string& _internal_dependency(int index) const;
-  std::string* _internal_add_dependency();
-  public:
-
-  // repeated .google.protobuf.DescriptorProto message_type = 4;
-  int message_type_size() const;
-  private:
-  int _internal_message_type_size() const;
-  public:
-  void clear_message_type();
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* mutable_message_type(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >*
-      mutable_message_type();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& _internal_message_type(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _internal_add_message_type();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& message_type(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* add_message_type();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >&
-      message_type() const;
-
-  // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
-  int enum_type_size() const;
-  private:
-  int _internal_enum_type_size() const;
-  public:
-  void clear_enum_type();
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* mutable_enum_type(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
-      mutable_enum_type();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& _internal_enum_type(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _internal_add_enum_type();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& enum_type(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* add_enum_type();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
-      enum_type() const;
-
-  // repeated .google.protobuf.ServiceDescriptorProto service = 6;
-  int service_size() const;
-  private:
-  int _internal_service_size() const;
-  public:
-  void clear_service();
-  ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* mutable_service(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >*
-      mutable_service();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& _internal_service(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* _internal_add_service();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& service(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* add_service();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >&
-      service() const;
-
-  // repeated .google.protobuf.FieldDescriptorProto extension = 7;
-  int extension_size() const;
-  private:
-  int _internal_extension_size() const;
-  public:
-  void clear_extension();
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_extension(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
-      mutable_extension();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_extension(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_extension();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& extension(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_extension();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
-      extension() const;
-
-  // repeated int32 public_dependency = 10;
-  int public_dependency_size() const;
-  private:
-  int _internal_public_dependency_size() const;
-  public:
-  void clear_public_dependency();
-  private:
-  int32_t _internal_public_dependency(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      _internal_public_dependency() const;
-  void _internal_add_public_dependency(int32_t value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      _internal_mutable_public_dependency();
-  public:
-  int32_t public_dependency(int index) const;
-  void set_public_dependency(int index, int32_t value);
-  void add_public_dependency(int32_t value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      public_dependency() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      mutable_public_dependency();
-
-  // repeated int32 weak_dependency = 11;
-  int weak_dependency_size() const;
-  private:
-  int _internal_weak_dependency_size() const;
-  public:
-  void clear_weak_dependency();
-  private:
-  int32_t _internal_weak_dependency(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      _internal_weak_dependency() const;
-  void _internal_add_weak_dependency(int32_t value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      _internal_mutable_weak_dependency();
-  public:
-  int32_t weak_dependency(int index) const;
-  void set_weak_dependency(int index, int32_t value);
-  void add_weak_dependency(int32_t value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      weak_dependency() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      mutable_weak_dependency();
-
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional string package = 2;
-  bool has_package() const;
-  private:
-  bool _internal_has_package() const;
-  public:
-  void clear_package();
-  const std::string& package() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_package(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_package();
-  PROTOBUF_NODISCARD std::string* release_package();
-  void set_allocated_package(std::string* package);
-  private:
-  const std::string& _internal_package() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_package(const std::string& value);
-  std::string* _internal_mutable_package();
-  public:
-
-  // optional string syntax = 12;
-  bool has_syntax() const;
-  private:
-  bool _internal_has_syntax() const;
-  public:
-  void clear_syntax();
-  const std::string& syntax() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_syntax(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_syntax();
-  PROTOBUF_NODISCARD std::string* release_syntax();
-  void set_allocated_syntax(std::string* syntax);
-  private:
-  const std::string& _internal_syntax() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_syntax(const std::string& value);
-  std::string* _internal_mutable_syntax();
-  public:
-
-  // optional .google.protobuf.FileOptions options = 8;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::FileOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FileOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::FileOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::FileOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::FileOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::FileOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::FileOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::FileOptions* unsafe_arena_release_options();
-
-  // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
-  bool has_source_code_info() const;
-  private:
-  bool _internal_has_source_code_info() const;
-  public:
-  void clear_source_code_info();
-  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& source_code_info() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* release_source_code_info();
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* mutable_source_code_info();
-  void set_allocated_source_code_info(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& _internal_source_code_info() const;
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* _internal_mutable_source_code_info();
-  public:
-  void unsafe_arena_set_allocated_source_code_info(
-      ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info);
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* unsafe_arena_release_source_code_info();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dependency_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto > message_type_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto > enum_type_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto > service_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > extension_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > public_dependency_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > weak_dependency_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr syntax_;
-    ::PROTOBUF_NAMESPACE_ID::FileOptions* options_;
-    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorProto) */
+{
+public:
+    inline FileDescriptorProto() :
+        FileDescriptorProto(nullptr)
+    {
+    }
+    ~FileDescriptorProto() override;
+    explicit PROTOBUF_CONSTEXPR FileDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    FileDescriptorProto(const FileDescriptorProto& from);
+    FileDescriptorProto(FileDescriptorProto&& from) noexcept
+        :
+        FileDescriptorProto()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline FileDescriptorProto& operator=(const FileDescriptorProto& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline FileDescriptorProto& operator=(FileDescriptorProto&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const FileDescriptorProto& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const FileDescriptorProto* internal_default_instance()
+    {
+        return reinterpret_cast<const FileDescriptorProto*>(
+            &_FileDescriptorProto_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        1;
+
+    friend void swap(FileDescriptorProto& a, FileDescriptorProto& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(FileDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(FileDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    FileDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<FileDescriptorProto>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const FileDescriptorProto& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const FileDescriptorProto& from)
+    {
+        FileDescriptorProto::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(FileDescriptorProto* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.FileDescriptorProto";
+    }
+
+protected:
+    explicit FileDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kDependencyFieldNumber = 3,
+        kMessageTypeFieldNumber = 4,
+        kEnumTypeFieldNumber = 5,
+        kServiceFieldNumber = 6,
+        kExtensionFieldNumber = 7,
+        kPublicDependencyFieldNumber = 10,
+        kWeakDependencyFieldNumber = 11,
+        kNameFieldNumber = 1,
+        kPackageFieldNumber = 2,
+        kSyntaxFieldNumber = 12,
+        kOptionsFieldNumber = 8,
+        kSourceCodeInfoFieldNumber = 9,
+    };
+    // repeated string dependency = 3;
+    int dependency_size() const;
+
+private:
+    int _internal_dependency_size() const;
+
+public:
+    void clear_dependency();
+    const std::string& dependency(int index) const;
+    std::string* mutable_dependency(int index);
+    void set_dependency(int index, const std::string& value);
+    void set_dependency(int index, std::string&& value);
+    void set_dependency(int index, const char* value);
+    void set_dependency(int index, const char* value, size_t size);
+    std::string* add_dependency();
+    void add_dependency(const std::string& value);
+    void add_dependency(std::string&& value);
+    void add_dependency(const char* value);
+    void add_dependency(const char* value, size_t size);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dependency() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dependency();
+
+private:
+    const std::string& _internal_dependency(int index) const;
+    std::string* _internal_add_dependency();
+
+public:
+    // repeated .google.protobuf.DescriptorProto message_type = 4;
+    int message_type_size() const;
+
+private:
+    int _internal_message_type_size() const;
+
+public:
+    void clear_message_type();
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto* mutable_message_type(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto>*
+        mutable_message_type();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& _internal_message_type(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _internal_add_message_type();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& message_type(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto* add_message_type();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto>&
+        message_type() const;
+
+    // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
+    int enum_type_size() const;
+
+private:
+    int _internal_enum_type_size() const;
+
+public:
+    void clear_enum_type();
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* mutable_enum_type(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>*
+        mutable_enum_type();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& _internal_enum_type(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _internal_add_enum_type();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& enum_type(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* add_enum_type();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>&
+        enum_type() const;
+
+    // repeated .google.protobuf.ServiceDescriptorProto service = 6;
+    int service_size() const;
+
+private:
+    int _internal_service_size() const;
+
+public:
+    void clear_service();
+    ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* mutable_service(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>*
+        mutable_service();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& _internal_service(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* _internal_add_service();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& service(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* add_service();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>&
+        service() const;
+
+    // repeated .google.protobuf.FieldDescriptorProto extension = 7;
+    int extension_size() const;
+
+private:
+    int _internal_extension_size() const;
+
+public:
+    void clear_extension();
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_extension(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>*
+        mutable_extension();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_extension(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_extension();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& extension(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_extension();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>&
+        extension() const;
+
+    // repeated int32 public_dependency = 10;
+    int public_dependency_size() const;
+
+private:
+    int _internal_public_dependency_size() const;
+
+public:
+    void clear_public_dependency();
+
+private:
+    int32_t _internal_public_dependency(int index) const;
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        _internal_public_dependency() const;
+    void _internal_add_public_dependency(int32_t value);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        _internal_mutable_public_dependency();
+
+public:
+    int32_t public_dependency(int index) const;
+    void set_public_dependency(int index, int32_t value);
+    void add_public_dependency(int32_t value);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        public_dependency() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        mutable_public_dependency();
+
+    // repeated int32 weak_dependency = 11;
+    int weak_dependency_size() const;
+
+private:
+    int _internal_weak_dependency_size() const;
+
+public:
+    void clear_weak_dependency();
+
+private:
+    int32_t _internal_weak_dependency(int index) const;
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        _internal_weak_dependency() const;
+    void _internal_add_weak_dependency(int32_t value);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        _internal_mutable_weak_dependency();
+
+public:
+    int32_t weak_dependency(int index) const;
+    void set_weak_dependency(int index, int32_t value);
+    void add_weak_dependency(int32_t value);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        weak_dependency() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        mutable_weak_dependency();
+
+    // optional string name = 1;
+    bool has_name() const;
+
+private:
+    bool _internal_has_name() const;
+
+public:
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // optional string package = 2;
+    bool has_package() const;
+
+private:
+    bool _internal_has_package() const;
+
+public:
+    void clear_package();
+    const std::string& package() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_package(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_package();
+    PROTOBUF_NODISCARD std::string* release_package();
+    void set_allocated_package(std::string* package);
+
+private:
+    const std::string& _internal_package() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_package(const std::string& value);
+    std::string* _internal_mutable_package();
+
+public:
+    // optional string syntax = 12;
+    bool has_syntax() const;
+
+private:
+    bool _internal_has_syntax() const;
+
+public:
+    void clear_syntax();
+    const std::string& syntax() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_syntax(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_syntax();
+    PROTOBUF_NODISCARD std::string* release_syntax();
+    void set_allocated_syntax(std::string* syntax);
+
+private:
+    const std::string& _internal_syntax() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_syntax(const std::string& value);
+    std::string* _internal_mutable_syntax();
+
+public:
+    // optional .google.protobuf.FileOptions options = 8;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::FileOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FileOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::FileOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::FileOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::FileOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* unsafe_arena_release_options();
+
+    // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
+    bool has_source_code_info() const;
+
+private:
+    bool _internal_has_source_code_info() const;
+
+public:
+    void clear_source_code_info();
+    const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& source_code_info() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* release_source_code_info();
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* mutable_source_code_info();
+    void set_allocated_source_code_info(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& _internal_source_code_info() const;
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* _internal_mutable_source_code_info();
+
+public:
+    void unsafe_arena_set_allocated_source_code_info(
+        ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info
+    );
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* unsafe_arena_release_source_code_info();
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorProto)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dependency_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto> message_type_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto> enum_type_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto> service_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto> extension_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t> public_dependency_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t> weak_dependency_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr syntax_;
+        ::PROTOBUF_NAMESPACE_ID::FileOptions* options_;
+        ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT DescriptorProto_ExtensionRange final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ExtensionRange) */ {
- public:
-  inline DescriptorProto_ExtensionRange() : DescriptorProto_ExtensionRange(nullptr) {}
-  ~DescriptorProto_ExtensionRange() override;
-  explicit PROTOBUF_CONSTEXPR DescriptorProto_ExtensionRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from);
-  DescriptorProto_ExtensionRange(DescriptorProto_ExtensionRange&& from) noexcept
-    : DescriptorProto_ExtensionRange() {
-    *this = ::std::move(from);
-  }
-
-  inline DescriptorProto_ExtensionRange& operator=(const DescriptorProto_ExtensionRange& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline DescriptorProto_ExtensionRange& operator=(DescriptorProto_ExtensionRange&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const DescriptorProto_ExtensionRange& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const DescriptorProto_ExtensionRange* internal_default_instance() {
-    return reinterpret_cast<const DescriptorProto_ExtensionRange*>(
-               &_DescriptorProto_ExtensionRange_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(DescriptorProto_ExtensionRange& a, DescriptorProto_ExtensionRange& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(DescriptorProto_ExtensionRange* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(DescriptorProto_ExtensionRange* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  DescriptorProto_ExtensionRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<DescriptorProto_ExtensionRange>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const DescriptorProto_ExtensionRange& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const DescriptorProto_ExtensionRange& from) {
-    DescriptorProto_ExtensionRange::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(DescriptorProto_ExtensionRange* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.DescriptorProto.ExtensionRange";
-  }
-  protected:
-  explicit DescriptorProto_ExtensionRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kOptionsFieldNumber = 3,
-    kStartFieldNumber = 1,
-    kEndFieldNumber = 2,
-  };
-  // optional .google.protobuf.ExtensionRangeOptions options = 3;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* unsafe_arena_release_options();
-
-  // optional int32 start = 1;
-  bool has_start() const;
-  private:
-  bool _internal_has_start() const;
-  public:
-  void clear_start();
-  int32_t start() const;
-  void set_start(int32_t value);
-  private:
-  int32_t _internal_start() const;
-  void _internal_set_start(int32_t value);
-  public:
-
-  // optional int32 end = 2;
-  bool has_end() const;
-  private:
-  bool _internal_has_end() const;
-  public:
-  void clear_end();
-  int32_t end() const;
-  void set_end(int32_t value);
-  private:
-  int32_t _internal_end() const;
-  void _internal_set_end(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ExtensionRange)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options_;
-    int32_t start_;
-    int32_t end_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ExtensionRange) */
+{
+public:
+    inline DescriptorProto_ExtensionRange() :
+        DescriptorProto_ExtensionRange(nullptr)
+    {
+    }
+    ~DescriptorProto_ExtensionRange() override;
+    explicit PROTOBUF_CONSTEXPR DescriptorProto_ExtensionRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from);
+    DescriptorProto_ExtensionRange(DescriptorProto_ExtensionRange&& from) noexcept
+        :
+        DescriptorProto_ExtensionRange()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline DescriptorProto_ExtensionRange& operator=(const DescriptorProto_ExtensionRange& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline DescriptorProto_ExtensionRange& operator=(DescriptorProto_ExtensionRange&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const DescriptorProto_ExtensionRange& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const DescriptorProto_ExtensionRange* internal_default_instance()
+    {
+        return reinterpret_cast<const DescriptorProto_ExtensionRange*>(
+            &_DescriptorProto_ExtensionRange_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        2;
+
+    friend void swap(DescriptorProto_ExtensionRange& a, DescriptorProto_ExtensionRange& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(DescriptorProto_ExtensionRange* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(DescriptorProto_ExtensionRange* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    DescriptorProto_ExtensionRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<DescriptorProto_ExtensionRange>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const DescriptorProto_ExtensionRange& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const DescriptorProto_ExtensionRange& from)
+    {
+        DescriptorProto_ExtensionRange::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(DescriptorProto_ExtensionRange* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.DescriptorProto.ExtensionRange";
+    }
+
+protected:
+    explicit DescriptorProto_ExtensionRange(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kOptionsFieldNumber = 3,
+        kStartFieldNumber = 1,
+        kEndFieldNumber = 2,
+    };
+    // optional .google.protobuf.ExtensionRangeOptions options = 3;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* unsafe_arena_release_options();
+
+    // optional int32 start = 1;
+    bool has_start() const;
+
+private:
+    bool _internal_has_start() const;
+
+public:
+    void clear_start();
+    int32_t start() const;
+    void set_start(int32_t value);
+
+private:
+    int32_t _internal_start() const;
+    void _internal_set_start(int32_t value);
+
+public:
+    // optional int32 end = 2;
+    bool has_end() const;
+
+private:
+    bool _internal_has_end() const;
+
+public:
+    void clear_end();
+    int32_t end() const;
+    void set_end(int32_t value);
+
+private:
+    int32_t _internal_end() const;
+    void _internal_set_end(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ExtensionRange)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options_;
+        int32_t start_;
+        int32_t end_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT DescriptorProto_ReservedRange final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ReservedRange) */ {
- public:
-  inline DescriptorProto_ReservedRange() : DescriptorProto_ReservedRange(nullptr) {}
-  ~DescriptorProto_ReservedRange() override;
-  explicit PROTOBUF_CONSTEXPR DescriptorProto_ReservedRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange& from);
-  DescriptorProto_ReservedRange(DescriptorProto_ReservedRange&& from) noexcept
-    : DescriptorProto_ReservedRange() {
-    *this = ::std::move(from);
-  }
-
-  inline DescriptorProto_ReservedRange& operator=(const DescriptorProto_ReservedRange& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline DescriptorProto_ReservedRange& operator=(DescriptorProto_ReservedRange&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const DescriptorProto_ReservedRange& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const DescriptorProto_ReservedRange* internal_default_instance() {
-    return reinterpret_cast<const DescriptorProto_ReservedRange*>(
-               &_DescriptorProto_ReservedRange_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    3;
-
-  friend void swap(DescriptorProto_ReservedRange& a, DescriptorProto_ReservedRange& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(DescriptorProto_ReservedRange* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(DescriptorProto_ReservedRange* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  DescriptorProto_ReservedRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<DescriptorProto_ReservedRange>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const DescriptorProto_ReservedRange& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const DescriptorProto_ReservedRange& from) {
-    DescriptorProto_ReservedRange::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(DescriptorProto_ReservedRange* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.DescriptorProto.ReservedRange";
-  }
-  protected:
-  explicit DescriptorProto_ReservedRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kStartFieldNumber = 1,
-    kEndFieldNumber = 2,
-  };
-  // optional int32 start = 1;
-  bool has_start() const;
-  private:
-  bool _internal_has_start() const;
-  public:
-  void clear_start();
-  int32_t start() const;
-  void set_start(int32_t value);
-  private:
-  int32_t _internal_start() const;
-  void _internal_set_start(int32_t value);
-  public:
-
-  // optional int32 end = 2;
-  bool has_end() const;
-  private:
-  bool _internal_has_end() const;
-  public:
-  void clear_end();
-  int32_t end() const;
-  void set_end(int32_t value);
-  private:
-  int32_t _internal_end() const;
-  void _internal_set_end(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ReservedRange)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    int32_t start_;
-    int32_t end_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ReservedRange) */
+{
+public:
+    inline DescriptorProto_ReservedRange() :
+        DescriptorProto_ReservedRange(nullptr)
+    {
+    }
+    ~DescriptorProto_ReservedRange() override;
+    explicit PROTOBUF_CONSTEXPR DescriptorProto_ReservedRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange& from);
+    DescriptorProto_ReservedRange(DescriptorProto_ReservedRange&& from) noexcept
+        :
+        DescriptorProto_ReservedRange()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline DescriptorProto_ReservedRange& operator=(const DescriptorProto_ReservedRange& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline DescriptorProto_ReservedRange& operator=(DescriptorProto_ReservedRange&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const DescriptorProto_ReservedRange& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const DescriptorProto_ReservedRange* internal_default_instance()
+    {
+        return reinterpret_cast<const DescriptorProto_ReservedRange*>(
+            &_DescriptorProto_ReservedRange_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        3;
+
+    friend void swap(DescriptorProto_ReservedRange& a, DescriptorProto_ReservedRange& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(DescriptorProto_ReservedRange* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(DescriptorProto_ReservedRange* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    DescriptorProto_ReservedRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<DescriptorProto_ReservedRange>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const DescriptorProto_ReservedRange& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const DescriptorProto_ReservedRange& from)
+    {
+        DescriptorProto_ReservedRange::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(DescriptorProto_ReservedRange* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.DescriptorProto.ReservedRange";
+    }
+
+protected:
+    explicit DescriptorProto_ReservedRange(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kStartFieldNumber = 1,
+        kEndFieldNumber = 2,
+    };
+    // optional int32 start = 1;
+    bool has_start() const;
+
+private:
+    bool _internal_has_start() const;
+
+public:
+    void clear_start();
+    int32_t start() const;
+    void set_start(int32_t value);
+
+private:
+    int32_t _internal_start() const;
+    void _internal_set_start(int32_t value);
+
+public:
+    // optional int32 end = 2;
+    bool has_end() const;
+
+private:
+    bool _internal_has_end() const;
+
+public:
+    void clear_end();
+    int32_t end() const;
+    void set_end(int32_t value);
+
+private:
+    int32_t _internal_end() const;
+    void _internal_set_end(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ReservedRange)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        int32_t start_;
+        int32_t end_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT DescriptorProto final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto) */ {
- public:
-  inline DescriptorProto() : DescriptorProto(nullptr) {}
-  ~DescriptorProto() override;
-  explicit PROTOBUF_CONSTEXPR DescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  DescriptorProto(const DescriptorProto& from);
-  DescriptorProto(DescriptorProto&& from) noexcept
-    : DescriptorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline DescriptorProto& operator=(const DescriptorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline DescriptorProto& operator=(DescriptorProto&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const DescriptorProto& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const DescriptorProto* internal_default_instance() {
-    return reinterpret_cast<const DescriptorProto*>(
-               &_DescriptorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    4;
-
-  friend void swap(DescriptorProto& a, DescriptorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(DescriptorProto* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(DescriptorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  DescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<DescriptorProto>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const DescriptorProto& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const DescriptorProto& from) {
-    DescriptorProto::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(DescriptorProto* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.DescriptorProto";
-  }
-  protected:
-  explicit DescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef DescriptorProto_ExtensionRange ExtensionRange;
-  typedef DescriptorProto_ReservedRange ReservedRange;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFieldFieldNumber = 2,
-    kNestedTypeFieldNumber = 3,
-    kEnumTypeFieldNumber = 4,
-    kExtensionRangeFieldNumber = 5,
-    kExtensionFieldNumber = 6,
-    kOneofDeclFieldNumber = 8,
-    kReservedRangeFieldNumber = 9,
-    kReservedNameFieldNumber = 10,
-    kNameFieldNumber = 1,
-    kOptionsFieldNumber = 7,
-  };
-  // repeated .google.protobuf.FieldDescriptorProto field = 2;
-  int field_size() const;
-  private:
-  int _internal_field_size() const;
-  public:
-  void clear_field();
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_field(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
-      mutable_field();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_field(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_field();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& field(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_field();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
-      field() const;
-
-  // repeated .google.protobuf.DescriptorProto nested_type = 3;
-  int nested_type_size() const;
-  private:
-  int _internal_nested_type_size() const;
-  public:
-  void clear_nested_type();
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* mutable_nested_type(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >*
-      mutable_nested_type();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& _internal_nested_type(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _internal_add_nested_type();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& nested_type(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* add_nested_type();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >&
-      nested_type() const;
-
-  // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
-  int enum_type_size() const;
-  private:
-  int _internal_enum_type_size() const;
-  public:
-  void clear_enum_type();
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* mutable_enum_type(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
-      mutable_enum_type();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& _internal_enum_type(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _internal_add_enum_type();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& enum_type(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* add_enum_type();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
-      enum_type() const;
-
-  // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
-  int extension_range_size() const;
-  private:
-  int _internal_extension_range_size() const;
-  public:
-  void clear_extension_range();
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* mutable_extension_range(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >*
-      mutable_extension_range();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& _internal_extension_range(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* _internal_add_extension_range();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& extension_range(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* add_extension_range();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >&
-      extension_range() const;
-
-  // repeated .google.protobuf.FieldDescriptorProto extension = 6;
-  int extension_size() const;
-  private:
-  int _internal_extension_size() const;
-  public:
-  void clear_extension();
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_extension(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
-      mutable_extension();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_extension(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_extension();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& extension(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_extension();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
-      extension() const;
-
-  // repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
-  int oneof_decl_size() const;
-  private:
-  int _internal_oneof_decl_size() const;
-  public:
-  void clear_oneof_decl();
-  ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* mutable_oneof_decl(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >*
-      mutable_oneof_decl();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& _internal_oneof_decl(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* _internal_add_oneof_decl();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& oneof_decl(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* add_oneof_decl();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >&
-      oneof_decl() const;
-
-  // repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
-  int reserved_range_size() const;
-  private:
-  int _internal_reserved_range_size() const;
-  public:
-  void clear_reserved_range();
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* mutable_reserved_range(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >*
-      mutable_reserved_range();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& _internal_reserved_range(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* _internal_add_reserved_range();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& reserved_range(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* add_reserved_range();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >&
-      reserved_range() const;
-
-  // repeated string reserved_name = 10;
-  int reserved_name_size() const;
-  private:
-  int _internal_reserved_name_size() const;
-  public:
-  void clear_reserved_name();
-  const std::string& reserved_name(int index) const;
-  std::string* mutable_reserved_name(int index);
-  void set_reserved_name(int index, const std::string& value);
-  void set_reserved_name(int index, std::string&& value);
-  void set_reserved_name(int index, const char* value);
-  void set_reserved_name(int index, const char* value, size_t size);
-  std::string* add_reserved_name();
-  void add_reserved_name(const std::string& value);
-  void add_reserved_name(std::string&& value);
-  void add_reserved_name(const char* value);
-  void add_reserved_name(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& reserved_name() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_reserved_name();
-  private:
-  const std::string& _internal_reserved_name(int index) const;
-  std::string* _internal_add_reserved_name();
-  public:
-
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional .google.protobuf.MessageOptions options = 7;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::MessageOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::MessageOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::MessageOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::MessageOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::MessageOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::MessageOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::MessageOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::MessageOptions* unsafe_arena_release_options();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > field_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto > nested_type_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto > enum_type_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange > extension_range_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto > extension_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto > oneof_decl_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange > reserved_range_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> reserved_name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::MessageOptions* options_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto) */
+{
+public:
+    inline DescriptorProto() :
+        DescriptorProto(nullptr)
+    {
+    }
+    ~DescriptorProto() override;
+    explicit PROTOBUF_CONSTEXPR DescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    DescriptorProto(const DescriptorProto& from);
+    DescriptorProto(DescriptorProto&& from) noexcept
+        :
+        DescriptorProto()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline DescriptorProto& operator=(const DescriptorProto& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline DescriptorProto& operator=(DescriptorProto&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const DescriptorProto& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const DescriptorProto* internal_default_instance()
+    {
+        return reinterpret_cast<const DescriptorProto*>(
+            &_DescriptorProto_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        4;
+
+    friend void swap(DescriptorProto& a, DescriptorProto& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(DescriptorProto* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(DescriptorProto* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    DescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<DescriptorProto>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const DescriptorProto& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const DescriptorProto& from)
+    {
+        DescriptorProto::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(DescriptorProto* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.DescriptorProto";
+    }
+
+protected:
+    explicit DescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef DescriptorProto_ExtensionRange ExtensionRange;
+    typedef DescriptorProto_ReservedRange ReservedRange;
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kFieldFieldNumber = 2,
+        kNestedTypeFieldNumber = 3,
+        kEnumTypeFieldNumber = 4,
+        kExtensionRangeFieldNumber = 5,
+        kExtensionFieldNumber = 6,
+        kOneofDeclFieldNumber = 8,
+        kReservedRangeFieldNumber = 9,
+        kReservedNameFieldNumber = 10,
+        kNameFieldNumber = 1,
+        kOptionsFieldNumber = 7,
+    };
+    // repeated .google.protobuf.FieldDescriptorProto field = 2;
+    int field_size() const;
+
+private:
+    int _internal_field_size() const;
+
+public:
+    void clear_field();
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_field(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>*
+        mutable_field();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_field(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_field();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& field(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_field();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>&
+        field() const;
+
+    // repeated .google.protobuf.DescriptorProto nested_type = 3;
+    int nested_type_size() const;
+
+private:
+    int _internal_nested_type_size() const;
+
+public:
+    void clear_nested_type();
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto* mutable_nested_type(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto>*
+        mutable_nested_type();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& _internal_nested_type(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _internal_add_nested_type();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& nested_type(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto* add_nested_type();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto>&
+        nested_type() const;
+
+    // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
+    int enum_type_size() const;
+
+private:
+    int _internal_enum_type_size() const;
+
+public:
+    void clear_enum_type();
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* mutable_enum_type(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>*
+        mutable_enum_type();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& _internal_enum_type(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _internal_add_enum_type();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& enum_type(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* add_enum_type();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>&
+        enum_type() const;
+
+    // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
+    int extension_range_size() const;
+
+private:
+    int _internal_extension_range_size() const;
+
+public:
+    void clear_extension_range();
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* mutable_extension_range(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>*
+        mutable_extension_range();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& _internal_extension_range(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* _internal_add_extension_range();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& extension_range(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* add_extension_range();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>&
+        extension_range() const;
+
+    // repeated .google.protobuf.FieldDescriptorProto extension = 6;
+    int extension_size() const;
+
+private:
+    int _internal_extension_size() const;
+
+public:
+    void clear_extension();
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* mutable_extension(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>*
+        mutable_extension();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& _internal_extension(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _internal_add_extension();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& extension(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* add_extension();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>&
+        extension() const;
+
+    // repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
+    int oneof_decl_size() const;
+
+private:
+    int _internal_oneof_decl_size() const;
+
+public:
+    void clear_oneof_decl();
+    ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* mutable_oneof_decl(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>*
+        mutable_oneof_decl();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& _internal_oneof_decl(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* _internal_add_oneof_decl();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& oneof_decl(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* add_oneof_decl();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>&
+        oneof_decl() const;
+
+    // repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
+    int reserved_range_size() const;
+
+private:
+    int _internal_reserved_range_size() const;
+
+public:
+    void clear_reserved_range();
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* mutable_reserved_range(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>*
+        mutable_reserved_range();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& _internal_reserved_range(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* _internal_add_reserved_range();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& reserved_range(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* add_reserved_range();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>&
+        reserved_range() const;
+
+    // repeated string reserved_name = 10;
+    int reserved_name_size() const;
+
+private:
+    int _internal_reserved_name_size() const;
+
+public:
+    void clear_reserved_name();
+    const std::string& reserved_name(int index) const;
+    std::string* mutable_reserved_name(int index);
+    void set_reserved_name(int index, const std::string& value);
+    void set_reserved_name(int index, std::string&& value);
+    void set_reserved_name(int index, const char* value);
+    void set_reserved_name(int index, const char* value, size_t size);
+    std::string* add_reserved_name();
+    void add_reserved_name(const std::string& value);
+    void add_reserved_name(std::string&& value);
+    void add_reserved_name(const char* value);
+    void add_reserved_name(const char* value, size_t size);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& reserved_name() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_reserved_name();
+
+private:
+    const std::string& _internal_reserved_name(int index) const;
+    std::string* _internal_add_reserved_name();
+
+public:
+    // optional string name = 1;
+    bool has_name() const;
+
+private:
+    bool _internal_has_name() const;
+
+public:
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // optional .google.protobuf.MessageOptions options = 7;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::MessageOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::MessageOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::MessageOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::MessageOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::MessageOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* unsafe_arena_release_options();
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto> field_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto> nested_type_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto> enum_type_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange> extension_range_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto> extension_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto> oneof_decl_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange> reserved_range_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> reserved_name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::MessageOptions* options_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT ExtensionRangeOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */ {
- public:
-  inline ExtensionRangeOptions() : ExtensionRangeOptions(nullptr) {}
-  ~ExtensionRangeOptions() override;
-  explicit PROTOBUF_CONSTEXPR ExtensionRangeOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  ExtensionRangeOptions(const ExtensionRangeOptions& from);
-  ExtensionRangeOptions(ExtensionRangeOptions&& from) noexcept
-    : ExtensionRangeOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline ExtensionRangeOptions& operator=(const ExtensionRangeOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ExtensionRangeOptions& operator=(ExtensionRangeOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const ExtensionRangeOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const ExtensionRangeOptions* internal_default_instance() {
-    return reinterpret_cast<const ExtensionRangeOptions*>(
-               &_ExtensionRangeOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    5;
-
-  friend void swap(ExtensionRangeOptions& a, ExtensionRangeOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ExtensionRangeOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ExtensionRangeOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  ExtensionRangeOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<ExtensionRangeOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const ExtensionRangeOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const ExtensionRangeOptions& from) {
-    ExtensionRangeOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(ExtensionRangeOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.ExtensionRangeOptions";
-  }
-  protected:
-  explicit ExtensionRangeOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ExtensionRangeOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.ExtensionRangeOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */
+{
+public:
+    inline ExtensionRangeOptions() :
+        ExtensionRangeOptions(nullptr)
+    {
+    }
+    ~ExtensionRangeOptions() override;
+    explicit PROTOBUF_CONSTEXPR ExtensionRangeOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    ExtensionRangeOptions(const ExtensionRangeOptions& from);
+    ExtensionRangeOptions(ExtensionRangeOptions&& from) noexcept
+        :
+        ExtensionRangeOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline ExtensionRangeOptions& operator=(const ExtensionRangeOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline ExtensionRangeOptions& operator=(ExtensionRangeOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const ExtensionRangeOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const ExtensionRangeOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const ExtensionRangeOptions*>(
+            &_ExtensionRangeOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        5;
+
+    friend void swap(ExtensionRangeOptions& a, ExtensionRangeOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(ExtensionRangeOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(ExtensionRangeOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    ExtensionRangeOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<ExtensionRangeOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const ExtensionRangeOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const ExtensionRangeOptions& from)
+    {
+        ExtensionRangeOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(ExtensionRangeOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.ExtensionRangeOptions";
+    }
+
+protected:
+    explicit ExtensionRangeOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                ExtensionRangeOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                ExtensionRangeOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ExtensionRangeOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                ExtensionRangeOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                ExtensionRangeOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.ExtensionRangeOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT FieldDescriptorProto final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldDescriptorProto) */ {
- public:
-  inline FieldDescriptorProto() : FieldDescriptorProto(nullptr) {}
-  ~FieldDescriptorProto() override;
-  explicit PROTOBUF_CONSTEXPR FieldDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  FieldDescriptorProto(const FieldDescriptorProto& from);
-  FieldDescriptorProto(FieldDescriptorProto&& from) noexcept
-    : FieldDescriptorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline FieldDescriptorProto& operator=(const FieldDescriptorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FieldDescriptorProto& operator=(FieldDescriptorProto&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const FieldDescriptorProto& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const FieldDescriptorProto* internal_default_instance() {
-    return reinterpret_cast<const FieldDescriptorProto*>(
-               &_FieldDescriptorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    6;
-
-  friend void swap(FieldDescriptorProto& a, FieldDescriptorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FieldDescriptorProto* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(FieldDescriptorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  FieldDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<FieldDescriptorProto>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const FieldDescriptorProto& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const FieldDescriptorProto& from) {
-    FieldDescriptorProto::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(FieldDescriptorProto* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.FieldDescriptorProto";
-  }
-  protected:
-  explicit FieldDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef FieldDescriptorProto_Type Type;
-  static constexpr Type TYPE_DOUBLE =
-    FieldDescriptorProto_Type_TYPE_DOUBLE;
-  static constexpr Type TYPE_FLOAT =
-    FieldDescriptorProto_Type_TYPE_FLOAT;
-  static constexpr Type TYPE_INT64 =
-    FieldDescriptorProto_Type_TYPE_INT64;
-  static constexpr Type TYPE_UINT64 =
-    FieldDescriptorProto_Type_TYPE_UINT64;
-  static constexpr Type TYPE_INT32 =
-    FieldDescriptorProto_Type_TYPE_INT32;
-  static constexpr Type TYPE_FIXED64 =
-    FieldDescriptorProto_Type_TYPE_FIXED64;
-  static constexpr Type TYPE_FIXED32 =
-    FieldDescriptorProto_Type_TYPE_FIXED32;
-  static constexpr Type TYPE_BOOL =
-    FieldDescriptorProto_Type_TYPE_BOOL;
-  static constexpr Type TYPE_STRING =
-    FieldDescriptorProto_Type_TYPE_STRING;
-  static constexpr Type TYPE_GROUP =
-    FieldDescriptorProto_Type_TYPE_GROUP;
-  static constexpr Type TYPE_MESSAGE =
-    FieldDescriptorProto_Type_TYPE_MESSAGE;
-  static constexpr Type TYPE_BYTES =
-    FieldDescriptorProto_Type_TYPE_BYTES;
-  static constexpr Type TYPE_UINT32 =
-    FieldDescriptorProto_Type_TYPE_UINT32;
-  static constexpr Type TYPE_ENUM =
-    FieldDescriptorProto_Type_TYPE_ENUM;
-  static constexpr Type TYPE_SFIXED32 =
-    FieldDescriptorProto_Type_TYPE_SFIXED32;
-  static constexpr Type TYPE_SFIXED64 =
-    FieldDescriptorProto_Type_TYPE_SFIXED64;
-  static constexpr Type TYPE_SINT32 =
-    FieldDescriptorProto_Type_TYPE_SINT32;
-  static constexpr Type TYPE_SINT64 =
-    FieldDescriptorProto_Type_TYPE_SINT64;
-  static inline bool Type_IsValid(int value) {
-    return FieldDescriptorProto_Type_IsValid(value);
-  }
-  static constexpr Type Type_MIN =
-    FieldDescriptorProto_Type_Type_MIN;
-  static constexpr Type Type_MAX =
-    FieldDescriptorProto_Type_Type_MAX;
-  static constexpr int Type_ARRAYSIZE =
-    FieldDescriptorProto_Type_Type_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  Type_descriptor() {
-    return FieldDescriptorProto_Type_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& Type_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, Type>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function Type_Name.");
-    return FieldDescriptorProto_Type_Name(enum_t_value);
-  }
-  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      Type* value) {
-    return FieldDescriptorProto_Type_Parse(name, value);
-  }
-
-  typedef FieldDescriptorProto_Label Label;
-  static constexpr Label LABEL_OPTIONAL =
-    FieldDescriptorProto_Label_LABEL_OPTIONAL;
-  static constexpr Label LABEL_REQUIRED =
-    FieldDescriptorProto_Label_LABEL_REQUIRED;
-  static constexpr Label LABEL_REPEATED =
-    FieldDescriptorProto_Label_LABEL_REPEATED;
-  static inline bool Label_IsValid(int value) {
-    return FieldDescriptorProto_Label_IsValid(value);
-  }
-  static constexpr Label Label_MIN =
-    FieldDescriptorProto_Label_Label_MIN;
-  static constexpr Label Label_MAX =
-    FieldDescriptorProto_Label_Label_MAX;
-  static constexpr int Label_ARRAYSIZE =
-    FieldDescriptorProto_Label_Label_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  Label_descriptor() {
-    return FieldDescriptorProto_Label_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& Label_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, Label>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function Label_Name.");
-    return FieldDescriptorProto_Label_Name(enum_t_value);
-  }
-  static inline bool Label_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      Label* value) {
-    return FieldDescriptorProto_Label_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 1,
-    kExtendeeFieldNumber = 2,
-    kTypeNameFieldNumber = 6,
-    kDefaultValueFieldNumber = 7,
-    kJsonNameFieldNumber = 10,
-    kOptionsFieldNumber = 8,
-    kNumberFieldNumber = 3,
-    kOneofIndexFieldNumber = 9,
-    kProto3OptionalFieldNumber = 17,
-    kLabelFieldNumber = 4,
-    kTypeFieldNumber = 5,
-  };
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional string extendee = 2;
-  bool has_extendee() const;
-  private:
-  bool _internal_has_extendee() const;
-  public:
-  void clear_extendee();
-  const std::string& extendee() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_extendee(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_extendee();
-  PROTOBUF_NODISCARD std::string* release_extendee();
-  void set_allocated_extendee(std::string* extendee);
-  private:
-  const std::string& _internal_extendee() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_extendee(const std::string& value);
-  std::string* _internal_mutable_extendee();
-  public:
-
-  // optional string type_name = 6;
-  bool has_type_name() const;
-  private:
-  bool _internal_has_type_name() const;
-  public:
-  void clear_type_name();
-  const std::string& type_name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_type_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_type_name();
-  PROTOBUF_NODISCARD std::string* release_type_name();
-  void set_allocated_type_name(std::string* type_name);
-  private:
-  const std::string& _internal_type_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_name(const std::string& value);
-  std::string* _internal_mutable_type_name();
-  public:
-
-  // optional string default_value = 7;
-  bool has_default_value() const;
-  private:
-  bool _internal_has_default_value() const;
-  public:
-  void clear_default_value();
-  const std::string& default_value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_default_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_default_value();
-  PROTOBUF_NODISCARD std::string* release_default_value();
-  void set_allocated_default_value(std::string* default_value);
-  private:
-  const std::string& _internal_default_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_value(const std::string& value);
-  std::string* _internal_mutable_default_value();
-  public:
-
-  // optional string json_name = 10;
-  bool has_json_name() const;
-  private:
-  bool _internal_has_json_name() const;
-  public:
-  void clear_json_name();
-  const std::string& json_name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_json_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_json_name();
-  PROTOBUF_NODISCARD std::string* release_json_name();
-  void set_allocated_json_name(std::string* json_name);
-  private:
-  const std::string& _internal_json_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_name(const std::string& value);
-  std::string* _internal_mutable_json_name();
-  public:
-
-  // optional .google.protobuf.FieldOptions options = 8;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::FieldOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FieldOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::FieldOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::FieldOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::FieldOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions* unsafe_arena_release_options();
-
-  // optional int32 number = 3;
-  bool has_number() const;
-  private:
-  bool _internal_has_number() const;
-  public:
-  void clear_number();
-  int32_t number() const;
-  void set_number(int32_t value);
-  private:
-  int32_t _internal_number() const;
-  void _internal_set_number(int32_t value);
-  public:
-
-  // optional int32 oneof_index = 9;
-  bool has_oneof_index() const;
-  private:
-  bool _internal_has_oneof_index() const;
-  public:
-  void clear_oneof_index();
-  int32_t oneof_index() const;
-  void set_oneof_index(int32_t value);
-  private:
-  int32_t _internal_oneof_index() const;
-  void _internal_set_oneof_index(int32_t value);
-  public:
-
-  // optional bool proto3_optional = 17;
-  bool has_proto3_optional() const;
-  private:
-  bool _internal_has_proto3_optional() const;
-  public:
-  void clear_proto3_optional();
-  bool proto3_optional() const;
-  void set_proto3_optional(bool value);
-  private:
-  bool _internal_proto3_optional() const;
-  void _internal_set_proto3_optional(bool value);
-  public:
-
-  // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
-  bool has_label() const;
-  private:
-  bool _internal_has_label() const;
-  public:
-  void clear_label();
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label label() const;
-  void set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label _internal_label() const;
-  void _internal_set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value);
-  public:
-
-  // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
-  bool has_type() const;
-  private:
-  bool _internal_has_type() const;
-  public:
-  void clear_type();
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type type() const;
-  void set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type _internal_type() const;
-  void _internal_set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.FieldDescriptorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extendee_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_name_;
-    ::PROTOBUF_NAMESPACE_ID::FieldOptions* options_;
-    int32_t number_;
-    int32_t oneof_index_;
-    bool proto3_optional_;
-    int label_;
-    int type_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldDescriptorProto) */
+{
+public:
+    inline FieldDescriptorProto() :
+        FieldDescriptorProto(nullptr)
+    {
+    }
+    ~FieldDescriptorProto() override;
+    explicit PROTOBUF_CONSTEXPR FieldDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    FieldDescriptorProto(const FieldDescriptorProto& from);
+    FieldDescriptorProto(FieldDescriptorProto&& from) noexcept
+        :
+        FieldDescriptorProto()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline FieldDescriptorProto& operator=(const FieldDescriptorProto& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline FieldDescriptorProto& operator=(FieldDescriptorProto&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const FieldDescriptorProto& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const FieldDescriptorProto* internal_default_instance()
+    {
+        return reinterpret_cast<const FieldDescriptorProto*>(
+            &_FieldDescriptorProto_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        6;
+
+    friend void swap(FieldDescriptorProto& a, FieldDescriptorProto& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(FieldDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(FieldDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    FieldDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<FieldDescriptorProto>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const FieldDescriptorProto& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const FieldDescriptorProto& from)
+    {
+        FieldDescriptorProto::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(FieldDescriptorProto* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.FieldDescriptorProto";
+    }
+
+protected:
+    explicit FieldDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef FieldDescriptorProto_Type Type;
+    static constexpr Type TYPE_DOUBLE =
+        FieldDescriptorProto_Type_TYPE_DOUBLE;
+    static constexpr Type TYPE_FLOAT =
+        FieldDescriptorProto_Type_TYPE_FLOAT;
+    static constexpr Type TYPE_INT64 =
+        FieldDescriptorProto_Type_TYPE_INT64;
+    static constexpr Type TYPE_UINT64 =
+        FieldDescriptorProto_Type_TYPE_UINT64;
+    static constexpr Type TYPE_INT32 =
+        FieldDescriptorProto_Type_TYPE_INT32;
+    static constexpr Type TYPE_FIXED64 =
+        FieldDescriptorProto_Type_TYPE_FIXED64;
+    static constexpr Type TYPE_FIXED32 =
+        FieldDescriptorProto_Type_TYPE_FIXED32;
+    static constexpr Type TYPE_BOOL =
+        FieldDescriptorProto_Type_TYPE_BOOL;
+    static constexpr Type TYPE_STRING =
+        FieldDescriptorProto_Type_TYPE_STRING;
+    static constexpr Type TYPE_GROUP =
+        FieldDescriptorProto_Type_TYPE_GROUP;
+    static constexpr Type TYPE_MESSAGE =
+        FieldDescriptorProto_Type_TYPE_MESSAGE;
+    static constexpr Type TYPE_BYTES =
+        FieldDescriptorProto_Type_TYPE_BYTES;
+    static constexpr Type TYPE_UINT32 =
+        FieldDescriptorProto_Type_TYPE_UINT32;
+    static constexpr Type TYPE_ENUM =
+        FieldDescriptorProto_Type_TYPE_ENUM;
+    static constexpr Type TYPE_SFIXED32 =
+        FieldDescriptorProto_Type_TYPE_SFIXED32;
+    static constexpr Type TYPE_SFIXED64 =
+        FieldDescriptorProto_Type_TYPE_SFIXED64;
+    static constexpr Type TYPE_SINT32 =
+        FieldDescriptorProto_Type_TYPE_SINT32;
+    static constexpr Type TYPE_SINT64 =
+        FieldDescriptorProto_Type_TYPE_SINT64;
+    static inline bool Type_IsValid(int value)
+    {
+        return FieldDescriptorProto_Type_IsValid(value);
+    }
+    static constexpr Type Type_MIN =
+        FieldDescriptorProto_Type_Type_MIN;
+    static constexpr Type Type_MAX =
+        FieldDescriptorProto_Type_Type_MAX;
+    static constexpr int Type_ARRAYSIZE =
+        FieldDescriptorProto_Type_Type_ARRAYSIZE;
+    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+        Type_descriptor()
+    {
+        return FieldDescriptorProto_Type_descriptor();
+    }
+    template<typename T>
+    static inline const std::string& Type_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, Type>::value || ::std::is_integral<T>::value, "Incorrect type passed to function Type_Name.");
+        return FieldDescriptorProto_Type_Name(enum_t_value);
+    }
+    static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type* value)
+    {
+        return FieldDescriptorProto_Type_Parse(name, value);
+    }
+
+    typedef FieldDescriptorProto_Label Label;
+    static constexpr Label LABEL_OPTIONAL =
+        FieldDescriptorProto_Label_LABEL_OPTIONAL;
+    static constexpr Label LABEL_REQUIRED =
+        FieldDescriptorProto_Label_LABEL_REQUIRED;
+    static constexpr Label LABEL_REPEATED =
+        FieldDescriptorProto_Label_LABEL_REPEATED;
+    static inline bool Label_IsValid(int value)
+    {
+        return FieldDescriptorProto_Label_IsValid(value);
+    }
+    static constexpr Label Label_MIN =
+        FieldDescriptorProto_Label_Label_MIN;
+    static constexpr Label Label_MAX =
+        FieldDescriptorProto_Label_Label_MAX;
+    static constexpr int Label_ARRAYSIZE =
+        FieldDescriptorProto_Label_Label_ARRAYSIZE;
+    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+        Label_descriptor()
+    {
+        return FieldDescriptorProto_Label_descriptor();
+    }
+    template<typename T>
+    static inline const std::string& Label_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, Label>::value || ::std::is_integral<T>::value, "Incorrect type passed to function Label_Name.");
+        return FieldDescriptorProto_Label_Name(enum_t_value);
+    }
+    static inline bool Label_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Label* value)
+    {
+        return FieldDescriptorProto_Label_Parse(name, value);
+    }
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNameFieldNumber = 1,
+        kExtendeeFieldNumber = 2,
+        kTypeNameFieldNumber = 6,
+        kDefaultValueFieldNumber = 7,
+        kJsonNameFieldNumber = 10,
+        kOptionsFieldNumber = 8,
+        kNumberFieldNumber = 3,
+        kOneofIndexFieldNumber = 9,
+        kProto3OptionalFieldNumber = 17,
+        kLabelFieldNumber = 4,
+        kTypeFieldNumber = 5,
+    };
+    // optional string name = 1;
+    bool has_name() const;
+
+private:
+    bool _internal_has_name() const;
+
+public:
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // optional string extendee = 2;
+    bool has_extendee() const;
+
+private:
+    bool _internal_has_extendee() const;
+
+public:
+    void clear_extendee();
+    const std::string& extendee() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_extendee(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_extendee();
+    PROTOBUF_NODISCARD std::string* release_extendee();
+    void set_allocated_extendee(std::string* extendee);
+
+private:
+    const std::string& _internal_extendee() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_extendee(const std::string& value);
+    std::string* _internal_mutable_extendee();
+
+public:
+    // optional string type_name = 6;
+    bool has_type_name() const;
+
+private:
+    bool _internal_has_type_name() const;
+
+public:
+    void clear_type_name();
+    const std::string& type_name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_type_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_type_name();
+    PROTOBUF_NODISCARD std::string* release_type_name();
+    void set_allocated_type_name(std::string* type_name);
+
+private:
+    const std::string& _internal_type_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_name(const std::string& value);
+    std::string* _internal_mutable_type_name();
+
+public:
+    // optional string default_value = 7;
+    bool has_default_value() const;
+
+private:
+    bool _internal_has_default_value() const;
+
+public:
+    void clear_default_value();
+    const std::string& default_value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_default_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_default_value();
+    PROTOBUF_NODISCARD std::string* release_default_value();
+    void set_allocated_default_value(std::string* default_value);
+
+private:
+    const std::string& _internal_default_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_value(const std::string& value);
+    std::string* _internal_mutable_default_value();
+
+public:
+    // optional string json_name = 10;
+    bool has_json_name() const;
+
+private:
+    bool _internal_has_json_name() const;
+
+public:
+    void clear_json_name();
+    const std::string& json_name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_json_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_json_name();
+    PROTOBUF_NODISCARD std::string* release_json_name();
+    void set_allocated_json_name(std::string* json_name);
+
+private:
+    const std::string& _internal_json_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_name(const std::string& value);
+    std::string* _internal_mutable_json_name();
+
+public:
+    // optional .google.protobuf.FieldOptions options = 8;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::FieldOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::FieldOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::FieldOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::FieldOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::FieldOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* unsafe_arena_release_options();
+
+    // optional int32 number = 3;
+    bool has_number() const;
+
+private:
+    bool _internal_has_number() const;
+
+public:
+    void clear_number();
+    int32_t number() const;
+    void set_number(int32_t value);
+
+private:
+    int32_t _internal_number() const;
+    void _internal_set_number(int32_t value);
+
+public:
+    // optional int32 oneof_index = 9;
+    bool has_oneof_index() const;
+
+private:
+    bool _internal_has_oneof_index() const;
+
+public:
+    void clear_oneof_index();
+    int32_t oneof_index() const;
+    void set_oneof_index(int32_t value);
+
+private:
+    int32_t _internal_oneof_index() const;
+    void _internal_set_oneof_index(int32_t value);
+
+public:
+    // optional bool proto3_optional = 17;
+    bool has_proto3_optional() const;
+
+private:
+    bool _internal_has_proto3_optional() const;
+
+public:
+    void clear_proto3_optional();
+    bool proto3_optional() const;
+    void set_proto3_optional(bool value);
+
+private:
+    bool _internal_proto3_optional() const;
+    void _internal_set_proto3_optional(bool value);
+
+public:
+    // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
+    bool has_label() const;
+
+private:
+    bool _internal_has_label() const;
+
+public:
+    void clear_label();
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label label() const;
+    void set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label _internal_label() const;
+    void _internal_set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value);
+
+public:
+    // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
+    bool has_type() const;
+
+private:
+    bool _internal_has_type() const;
+
+public:
+    void clear_type();
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type type() const;
+    void set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type _internal_type() const;
+    void _internal_set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.FieldDescriptorProto)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extendee_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_name_;
+        ::PROTOBUF_NAMESPACE_ID::FieldOptions* options_;
+        int32_t number_;
+        int32_t oneof_index_;
+        bool proto3_optional_;
+        int label_;
+        int type_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT OneofDescriptorProto final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofDescriptorProto) */ {
- public:
-  inline OneofDescriptorProto() : OneofDescriptorProto(nullptr) {}
-  ~OneofDescriptorProto() override;
-  explicit PROTOBUF_CONSTEXPR OneofDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  OneofDescriptorProto(const OneofDescriptorProto& from);
-  OneofDescriptorProto(OneofDescriptorProto&& from) noexcept
-    : OneofDescriptorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline OneofDescriptorProto& operator=(const OneofDescriptorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline OneofDescriptorProto& operator=(OneofDescriptorProto&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const OneofDescriptorProto& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const OneofDescriptorProto* internal_default_instance() {
-    return reinterpret_cast<const OneofDescriptorProto*>(
-               &_OneofDescriptorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    7;
-
-  friend void swap(OneofDescriptorProto& a, OneofDescriptorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(OneofDescriptorProto* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(OneofDescriptorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  OneofDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<OneofDescriptorProto>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const OneofDescriptorProto& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const OneofDescriptorProto& from) {
-    OneofDescriptorProto::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(OneofDescriptorProto* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.OneofDescriptorProto";
-  }
-  protected:
-  explicit OneofDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 1,
-    kOptionsFieldNumber = 2,
-  };
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional .google.protobuf.OneofOptions options = 2;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::OneofOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::OneofOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::OneofOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::OneofOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::OneofOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::OneofOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::OneofOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::OneofOptions* unsafe_arena_release_options();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.OneofDescriptorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::OneofOptions* options_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofDescriptorProto) */
+{
+public:
+    inline OneofDescriptorProto() :
+        OneofDescriptorProto(nullptr)
+    {
+    }
+    ~OneofDescriptorProto() override;
+    explicit PROTOBUF_CONSTEXPR OneofDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    OneofDescriptorProto(const OneofDescriptorProto& from);
+    OneofDescriptorProto(OneofDescriptorProto&& from) noexcept
+        :
+        OneofDescriptorProto()
+    {
+        *this = ::std::move(from);
+    }
 
-class PROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto.EnumReservedRange) */ {
- public:
-  inline EnumDescriptorProto_EnumReservedRange() : EnumDescriptorProto_EnumReservedRange(nullptr) {}
-  ~EnumDescriptorProto_EnumReservedRange() override;
-  explicit PROTOBUF_CONSTEXPR EnumDescriptorProto_EnumReservedRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  EnumDescriptorProto_EnumReservedRange(const EnumDescriptorProto_EnumReservedRange& from);
-  EnumDescriptorProto_EnumReservedRange(EnumDescriptorProto_EnumReservedRange&& from) noexcept
-    : EnumDescriptorProto_EnumReservedRange() {
-    *this = ::std::move(from);
-  }
-
-  inline EnumDescriptorProto_EnumReservedRange& operator=(const EnumDescriptorProto_EnumReservedRange& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline EnumDescriptorProto_EnumReservedRange& operator=(EnumDescriptorProto_EnumReservedRange&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const EnumDescriptorProto_EnumReservedRange& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const EnumDescriptorProto_EnumReservedRange* internal_default_instance() {
-    return reinterpret_cast<const EnumDescriptorProto_EnumReservedRange*>(
-               &_EnumDescriptorProto_EnumReservedRange_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    8;
-
-  friend void swap(EnumDescriptorProto_EnumReservedRange& a, EnumDescriptorProto_EnumReservedRange& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(EnumDescriptorProto_EnumReservedRange* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(EnumDescriptorProto_EnumReservedRange* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  EnumDescriptorProto_EnumReservedRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<EnumDescriptorProto_EnumReservedRange>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const EnumDescriptorProto_EnumReservedRange& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const EnumDescriptorProto_EnumReservedRange& from) {
-    EnumDescriptorProto_EnumReservedRange::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(EnumDescriptorProto_EnumReservedRange* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.EnumDescriptorProto.EnumReservedRange";
-  }
-  protected:
-  explicit EnumDescriptorProto_EnumReservedRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kStartFieldNumber = 1,
-    kEndFieldNumber = 2,
-  };
-  // optional int32 start = 1;
-  bool has_start() const;
-  private:
-  bool _internal_has_start() const;
-  public:
-  void clear_start();
-  int32_t start() const;
-  void set_start(int32_t value);
-  private:
-  int32_t _internal_start() const;
-  void _internal_set_start(int32_t value);
-  public:
-
-  // optional int32 end = 2;
-  bool has_end() const;
-  private:
-  bool _internal_has_end() const;
-  public:
-  void clear_end();
-  int32_t end() const;
-  void set_end(int32_t value);
-  private:
-  int32_t _internal_end() const;
-  void _internal_set_end(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto.EnumReservedRange)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    int32_t start_;
-    int32_t end_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    inline OneofDescriptorProto& operator=(const OneofDescriptorProto& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline OneofDescriptorProto& operator=(OneofDescriptorProto&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
 
-class PROTOBUF_EXPORT EnumDescriptorProto final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto) */ {
- public:
-  inline EnumDescriptorProto() : EnumDescriptorProto(nullptr) {}
-  ~EnumDescriptorProto() override;
-  explicit PROTOBUF_CONSTEXPR EnumDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  EnumDescriptorProto(const EnumDescriptorProto& from);
-  EnumDescriptorProto(EnumDescriptorProto&& from) noexcept
-    : EnumDescriptorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline EnumDescriptorProto& operator=(const EnumDescriptorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline EnumDescriptorProto& operator=(EnumDescriptorProto&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const EnumDescriptorProto& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const EnumDescriptorProto* internal_default_instance() {
-    return reinterpret_cast<const EnumDescriptorProto*>(
-               &_EnumDescriptorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    9;
-
-  friend void swap(EnumDescriptorProto& a, EnumDescriptorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(EnumDescriptorProto* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(EnumDescriptorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  EnumDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<EnumDescriptorProto>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const EnumDescriptorProto& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const EnumDescriptorProto& from) {
-    EnumDescriptorProto::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(EnumDescriptorProto* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.EnumDescriptorProto";
-  }
-  protected:
-  explicit EnumDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef EnumDescriptorProto_EnumReservedRange EnumReservedRange;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 2,
-    kReservedRangeFieldNumber = 4,
-    kReservedNameFieldNumber = 5,
-    kNameFieldNumber = 1,
-    kOptionsFieldNumber = 3,
-  };
-  // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
-  int value_size() const;
-  private:
-  int _internal_value_size() const;
-  public:
-  void clear_value();
-  ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* mutable_value(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >*
-      mutable_value();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& _internal_value(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* _internal_add_value();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& value(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* add_value();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >&
-      value() const;
-
-  // repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
-  int reserved_range_size() const;
-  private:
-  int _internal_reserved_range_size() const;
-  public:
-  void clear_reserved_range();
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* mutable_reserved_range(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >*
-      mutable_reserved_range();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& _internal_reserved_range(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* _internal_add_reserved_range();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& reserved_range(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* add_reserved_range();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >&
-      reserved_range() const;
-
-  // repeated string reserved_name = 5;
-  int reserved_name_size() const;
-  private:
-  int _internal_reserved_name_size() const;
-  public:
-  void clear_reserved_name();
-  const std::string& reserved_name(int index) const;
-  std::string* mutable_reserved_name(int index);
-  void set_reserved_name(int index, const std::string& value);
-  void set_reserved_name(int index, std::string&& value);
-  void set_reserved_name(int index, const char* value);
-  void set_reserved_name(int index, const char* value, size_t size);
-  std::string* add_reserved_name();
-  void add_reserved_name(const std::string& value);
-  void add_reserved_name(std::string&& value);
-  void add_reserved_name(const char* value);
-  void add_reserved_name(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& reserved_name() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_reserved_name();
-  private:
-  const std::string& _internal_reserved_name(int index) const;
-  std::string* _internal_add_reserved_name();
-  public:
-
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional .google.protobuf.EnumOptions options = 3;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::EnumOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::EnumOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::EnumOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::EnumOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::EnumOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::EnumOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::EnumOptions* unsafe_arena_release_options();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto > value_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange > reserved_range_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> reserved_name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::EnumOptions* options_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const OneofDescriptorProto& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const OneofDescriptorProto* internal_default_instance()
+    {
+        return reinterpret_cast<const OneofDescriptorProto*>(
+            &_OneofDescriptorProto_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        7;
+
+    friend void swap(OneofDescriptorProto& a, OneofDescriptorProto& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(OneofDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(OneofDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    OneofDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<OneofDescriptorProto>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const OneofDescriptorProto& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const OneofDescriptorProto& from)
+    {
+        OneofDescriptorProto::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(OneofDescriptorProto* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.OneofDescriptorProto";
+    }
+
+protected:
+    explicit OneofDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNameFieldNumber = 1,
+        kOptionsFieldNumber = 2,
+    };
+    // optional string name = 1;
+    bool has_name() const;
+
+private:
+    bool _internal_has_name() const;
+
+public:
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // optional .google.protobuf.OneofOptions options = 2;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::OneofOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::OneofOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::OneofOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::OneofOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::OneofOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* unsafe_arena_release_options();
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.OneofDescriptorProto)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::OneofOptions* options_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto.EnumReservedRange) */
+{
+public:
+    inline EnumDescriptorProto_EnumReservedRange() :
+        EnumDescriptorProto_EnumReservedRange(nullptr)
+    {
+    }
+    ~EnumDescriptorProto_EnumReservedRange() override;
+    explicit PROTOBUF_CONSTEXPR EnumDescriptorProto_EnumReservedRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    EnumDescriptorProto_EnumReservedRange(const EnumDescriptorProto_EnumReservedRange& from);
+    EnumDescriptorProto_EnumReservedRange(EnumDescriptorProto_EnumReservedRange&& from) noexcept
+        :
+        EnumDescriptorProto_EnumReservedRange()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline EnumDescriptorProto_EnumReservedRange& operator=(const EnumDescriptorProto_EnumReservedRange& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline EnumDescriptorProto_EnumReservedRange& operator=(EnumDescriptorProto_EnumReservedRange&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const EnumDescriptorProto_EnumReservedRange& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const EnumDescriptorProto_EnumReservedRange* internal_default_instance()
+    {
+        return reinterpret_cast<const EnumDescriptorProto_EnumReservedRange*>(
+            &_EnumDescriptorProto_EnumReservedRange_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        8;
+
+    friend void swap(EnumDescriptorProto_EnumReservedRange& a, EnumDescriptorProto_EnumReservedRange& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(EnumDescriptorProto_EnumReservedRange* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(EnumDescriptorProto_EnumReservedRange* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    EnumDescriptorProto_EnumReservedRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<EnumDescriptorProto_EnumReservedRange>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const EnumDescriptorProto_EnumReservedRange& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const EnumDescriptorProto_EnumReservedRange& from)
+    {
+        EnumDescriptorProto_EnumReservedRange::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(EnumDescriptorProto_EnumReservedRange* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.EnumDescriptorProto.EnumReservedRange";
+    }
+
+protected:
+    explicit EnumDescriptorProto_EnumReservedRange(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kStartFieldNumber = 1,
+        kEndFieldNumber = 2,
+    };
+    // optional int32 start = 1;
+    bool has_start() const;
+
+private:
+    bool _internal_has_start() const;
+
+public:
+    void clear_start();
+    int32_t start() const;
+    void set_start(int32_t value);
+
+private:
+    int32_t _internal_start() const;
+    void _internal_set_start(int32_t value);
+
+public:
+    // optional int32 end = 2;
+    bool has_end() const;
+
+private:
+    bool _internal_has_end() const;
+
+public:
+    void clear_end();
+    int32_t end() const;
+    void set_end(int32_t value);
+
+private:
+    int32_t _internal_end() const;
+    void _internal_set_end(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto.EnumReservedRange)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        int32_t start_;
+        int32_t end_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto) */
+{
+public:
+    inline EnumDescriptorProto() :
+        EnumDescriptorProto(nullptr)
+    {
+    }
+    ~EnumDescriptorProto() override;
+    explicit PROTOBUF_CONSTEXPR EnumDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    EnumDescriptorProto(const EnumDescriptorProto& from);
+    EnumDescriptorProto(EnumDescriptorProto&& from) noexcept
+        :
+        EnumDescriptorProto()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline EnumDescriptorProto& operator=(const EnumDescriptorProto& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline EnumDescriptorProto& operator=(EnumDescriptorProto&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const EnumDescriptorProto& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const EnumDescriptorProto* internal_default_instance()
+    {
+        return reinterpret_cast<const EnumDescriptorProto*>(
+            &_EnumDescriptorProto_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        9;
+
+    friend void swap(EnumDescriptorProto& a, EnumDescriptorProto& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(EnumDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(EnumDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    EnumDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<EnumDescriptorProto>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const EnumDescriptorProto& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const EnumDescriptorProto& from)
+    {
+        EnumDescriptorProto::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(EnumDescriptorProto* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.EnumDescriptorProto";
+    }
+
+protected:
+    explicit EnumDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef EnumDescriptorProto_EnumReservedRange EnumReservedRange;
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 2,
+        kReservedRangeFieldNumber = 4,
+        kReservedNameFieldNumber = 5,
+        kNameFieldNumber = 1,
+        kOptionsFieldNumber = 3,
+    };
+    // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
+    int value_size() const;
+
+private:
+    int _internal_value_size() const;
+
+public:
+    void clear_value();
+    ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* mutable_value(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>*
+        mutable_value();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& _internal_value(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* _internal_add_value();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& value(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* add_value();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>&
+        value() const;
+
+    // repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
+    int reserved_range_size() const;
+
+private:
+    int _internal_reserved_range_size() const;
+
+public:
+    void clear_reserved_range();
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* mutable_reserved_range(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>*
+        mutable_reserved_range();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& _internal_reserved_range(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* _internal_add_reserved_range();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& reserved_range(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* add_reserved_range();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>&
+        reserved_range() const;
+
+    // repeated string reserved_name = 5;
+    int reserved_name_size() const;
+
+private:
+    int _internal_reserved_name_size() const;
+
+public:
+    void clear_reserved_name();
+    const std::string& reserved_name(int index) const;
+    std::string* mutable_reserved_name(int index);
+    void set_reserved_name(int index, const std::string& value);
+    void set_reserved_name(int index, std::string&& value);
+    void set_reserved_name(int index, const char* value);
+    void set_reserved_name(int index, const char* value, size_t size);
+    std::string* add_reserved_name();
+    void add_reserved_name(const std::string& value);
+    void add_reserved_name(std::string&& value);
+    void add_reserved_name(const char* value);
+    void add_reserved_name(const char* value, size_t size);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& reserved_name() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_reserved_name();
+
+private:
+    const std::string& _internal_reserved_name(int index) const;
+    std::string* _internal_add_reserved_name();
+
+public:
+    // optional string name = 1;
+    bool has_name() const;
+
+private:
+    bool _internal_has_name() const;
+
+public:
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // optional .google.protobuf.EnumOptions options = 3;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::EnumOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::EnumOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::EnumOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::EnumOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* unsafe_arena_release_options();
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto> value_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange> reserved_range_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> reserved_name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::EnumOptions* options_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumValueDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueDescriptorProto) */
+{
+public:
+    inline EnumValueDescriptorProto() :
+        EnumValueDescriptorProto(nullptr)
+    {
+    }
+    ~EnumValueDescriptorProto() override;
+    explicit PROTOBUF_CONSTEXPR EnumValueDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    EnumValueDescriptorProto(const EnumValueDescriptorProto& from);
+    EnumValueDescriptorProto(EnumValueDescriptorProto&& from) noexcept
+        :
+        EnumValueDescriptorProto()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline EnumValueDescriptorProto& operator=(EnumValueDescriptorProto&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const EnumValueDescriptorProto& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const EnumValueDescriptorProto* internal_default_instance()
+    {
+        return reinterpret_cast<const EnumValueDescriptorProto*>(
+            &_EnumValueDescriptorProto_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        10;
+
+    friend void swap(EnumValueDescriptorProto& a, EnumValueDescriptorProto& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(EnumValueDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(EnumValueDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    EnumValueDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<EnumValueDescriptorProto>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const EnumValueDescriptorProto& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const EnumValueDescriptorProto& from)
+    {
+        EnumValueDescriptorProto::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(EnumValueDescriptorProto* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.EnumValueDescriptorProto";
+    }
+
+protected:
+    explicit EnumValueDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNameFieldNumber = 1,
+        kOptionsFieldNumber = 3,
+        kNumberFieldNumber = 2,
+    };
+    // optional string name = 1;
+    bool has_name() const;
+
+private:
+    bool _internal_has_name() const;
+
+public:
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // optional .google.protobuf.EnumValueOptions options = 3;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* unsafe_arena_release_options();
+
+    // optional int32 number = 2;
+    bool has_number() const;
+
+private:
+    bool _internal_has_number() const;
+
+public:
+    void clear_number();
+    int32_t number() const;
+    void set_number(int32_t value);
+
+private:
+    int32_t _internal_number() const;
+    void _internal_set_number(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueDescriptorProto)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options_;
+        int32_t number_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT ServiceDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceDescriptorProto) */
+{
+public:
+    inline ServiceDescriptorProto() :
+        ServiceDescriptorProto(nullptr)
+    {
+    }
+    ~ServiceDescriptorProto() override;
+    explicit PROTOBUF_CONSTEXPR ServiceDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    ServiceDescriptorProto(const ServiceDescriptorProto& from);
+    ServiceDescriptorProto(ServiceDescriptorProto&& from) noexcept
+        :
+        ServiceDescriptorProto()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline ServiceDescriptorProto& operator=(const ServiceDescriptorProto& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline ServiceDescriptorProto& operator=(ServiceDescriptorProto&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const ServiceDescriptorProto& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const ServiceDescriptorProto* internal_default_instance()
+    {
+        return reinterpret_cast<const ServiceDescriptorProto*>(
+            &_ServiceDescriptorProto_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        11;
+
+    friend void swap(ServiceDescriptorProto& a, ServiceDescriptorProto& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(ServiceDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(ServiceDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    ServiceDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<ServiceDescriptorProto>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const ServiceDescriptorProto& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const ServiceDescriptorProto& from)
+    {
+        ServiceDescriptorProto::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(ServiceDescriptorProto* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.ServiceDescriptorProto";
+    }
+
+protected:
+    explicit ServiceDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kMethodFieldNumber = 2,
+        kNameFieldNumber = 1,
+        kOptionsFieldNumber = 3,
+    };
+    // repeated .google.protobuf.MethodDescriptorProto method = 2;
+    int method_size() const;
+
+private:
+    int _internal_method_size() const;
+
+public:
+    void clear_method();
+    ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* mutable_method(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>*
+        mutable_method();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& _internal_method(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* _internal_add_method();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& method(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* add_method();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>&
+        method() const;
+
+    // optional string name = 1;
+    bool has_name() const;
+
+private:
+    bool _internal_has_name() const;
+
+public:
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // optional .google.protobuf.ServiceOptions options = 3;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ServiceOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::ServiceOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* unsafe_arena_release_options();
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.ServiceDescriptorProto)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto> method_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT MethodDescriptorProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodDescriptorProto) */
+{
+public:
+    inline MethodDescriptorProto() :
+        MethodDescriptorProto(nullptr)
+    {
+    }
+    ~MethodDescriptorProto() override;
+    explicit PROTOBUF_CONSTEXPR MethodDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    MethodDescriptorProto(const MethodDescriptorProto& from);
+    MethodDescriptorProto(MethodDescriptorProto&& from) noexcept
+        :
+        MethodDescriptorProto()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline MethodDescriptorProto& operator=(const MethodDescriptorProto& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline MethodDescriptorProto& operator=(MethodDescriptorProto&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const MethodDescriptorProto& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const MethodDescriptorProto* internal_default_instance()
+    {
+        return reinterpret_cast<const MethodDescriptorProto*>(
+            &_MethodDescriptorProto_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        12;
+
+    friend void swap(MethodDescriptorProto& a, MethodDescriptorProto& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(MethodDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(MethodDescriptorProto* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    MethodDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<MethodDescriptorProto>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const MethodDescriptorProto& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const MethodDescriptorProto& from)
+    {
+        MethodDescriptorProto::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(MethodDescriptorProto* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.MethodDescriptorProto";
+    }
+
+protected:
+    explicit MethodDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNameFieldNumber = 1,
+        kInputTypeFieldNumber = 2,
+        kOutputTypeFieldNumber = 3,
+        kOptionsFieldNumber = 4,
+        kClientStreamingFieldNumber = 5,
+        kServerStreamingFieldNumber = 6,
+    };
+    // optional string name = 1;
+    bool has_name() const;
+
+private:
+    bool _internal_has_name() const;
+
+public:
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // optional string input_type = 2;
+    bool has_input_type() const;
+
+private:
+    bool _internal_has_input_type() const;
+
+public:
+    void clear_input_type();
+    const std::string& input_type() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_input_type(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_input_type();
+    PROTOBUF_NODISCARD std::string* release_input_type();
+    void set_allocated_input_type(std::string* input_type);
+
+private:
+    const std::string& _internal_input_type() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_type(const std::string& value);
+    std::string* _internal_mutable_input_type();
+
+public:
+    // optional string output_type = 3;
+    bool has_output_type() const;
+
+private:
+    bool _internal_has_output_type() const;
+
+public:
+    void clear_output_type();
+    const std::string& output_type() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_output_type(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_output_type();
+    PROTOBUF_NODISCARD std::string* release_output_type();
+    void set_allocated_output_type(std::string* output_type);
+
+private:
+    const std::string& _internal_output_type() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_type(const std::string& value);
+    std::string* _internal_mutable_output_type();
+
+public:
+    // optional .google.protobuf.MethodOptions options = 4;
+    bool has_options() const;
+
+private:
+    bool _internal_has_options() const;
+
+public:
+    void clear_options();
+    const ::PROTOBUF_NAMESPACE_ID::MethodOptions& options() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::MethodOptions* release_options();
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* mutable_options();
+    void set_allocated_options(::PROTOBUF_NAMESPACE_ID::MethodOptions* options);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::MethodOptions& _internal_options() const;
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* _internal_mutable_options();
+
+public:
+    void unsafe_arena_set_allocated_options(
+        ::PROTOBUF_NAMESPACE_ID::MethodOptions* options
+    );
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* unsafe_arena_release_options();
+
+    // optional bool client_streaming = 5 [default = false];
+    bool has_client_streaming() const;
+
+private:
+    bool _internal_has_client_streaming() const;
+
+public:
+    void clear_client_streaming();
+    bool client_streaming() const;
+    void set_client_streaming(bool value);
+
+private:
+    bool _internal_client_streaming() const;
+    void _internal_set_client_streaming(bool value);
+
+public:
+    // optional bool server_streaming = 6 [default = false];
+    bool has_server_streaming() const;
+
+private:
+    bool _internal_has_server_streaming() const;
+
+public:
+    void clear_server_streaming();
+    bool server_streaming() const;
+    void set_server_streaming(bool value);
+
+private:
+    bool _internal_server_streaming() const;
+    void _internal_set_server_streaming(bool value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.MethodDescriptorProto)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_type_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_type_;
+        ::PROTOBUF_NAMESPACE_ID::MethodOptions* options_;
+        bool client_streaming_;
+        bool server_streaming_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT FileOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileOptions) */
+{
+public:
+    inline FileOptions() :
+        FileOptions(nullptr)
+    {
+    }
+    ~FileOptions() override;
+    explicit PROTOBUF_CONSTEXPR FileOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    FileOptions(const FileOptions& from);
+    FileOptions(FileOptions&& from) noexcept
+        :
+        FileOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline FileOptions& operator=(const FileOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline FileOptions& operator=(FileOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const FileOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const FileOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const FileOptions*>(
+            &_FileOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        13;
+
+    friend void swap(FileOptions& a, FileOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(FileOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(FileOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    FileOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<FileOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const FileOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const FileOptions& from)
+    {
+        FileOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(FileOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.FileOptions";
+    }
+
+protected:
+    explicit FileOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef FileOptions_OptimizeMode OptimizeMode;
+    static constexpr OptimizeMode SPEED =
+        FileOptions_OptimizeMode_SPEED;
+    static constexpr OptimizeMode CODE_SIZE =
+        FileOptions_OptimizeMode_CODE_SIZE;
+    static constexpr OptimizeMode LITE_RUNTIME =
+        FileOptions_OptimizeMode_LITE_RUNTIME;
+    static inline bool OptimizeMode_IsValid(int value)
+    {
+        return FileOptions_OptimizeMode_IsValid(value);
+    }
+    static constexpr OptimizeMode OptimizeMode_MIN =
+        FileOptions_OptimizeMode_OptimizeMode_MIN;
+    static constexpr OptimizeMode OptimizeMode_MAX =
+        FileOptions_OptimizeMode_OptimizeMode_MAX;
+    static constexpr int OptimizeMode_ARRAYSIZE =
+        FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE;
+    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+        OptimizeMode_descriptor()
+    {
+        return FileOptions_OptimizeMode_descriptor();
+    }
+    template<typename T>
+    static inline const std::string& OptimizeMode_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, OptimizeMode>::value || ::std::is_integral<T>::value, "Incorrect type passed to function OptimizeMode_Name.");
+        return FileOptions_OptimizeMode_Name(enum_t_value);
+    }
+    static inline bool OptimizeMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OptimizeMode* value)
+    {
+        return FileOptions_OptimizeMode_Parse(name, value);
+    }
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+        kJavaPackageFieldNumber = 1,
+        kJavaOuterClassnameFieldNumber = 8,
+        kGoPackageFieldNumber = 11,
+        kObjcClassPrefixFieldNumber = 36,
+        kCsharpNamespaceFieldNumber = 37,
+        kSwiftPrefixFieldNumber = 39,
+        kPhpClassPrefixFieldNumber = 40,
+        kPhpNamespaceFieldNumber = 41,
+        kPhpMetadataNamespaceFieldNumber = 44,
+        kRubyPackageFieldNumber = 45,
+        kJavaMultipleFilesFieldNumber = 10,
+        kJavaGenerateEqualsAndHashFieldNumber = 20,
+        kJavaStringCheckUtf8FieldNumber = 27,
+        kCcGenericServicesFieldNumber = 16,
+        kJavaGenericServicesFieldNumber = 17,
+        kPyGenericServicesFieldNumber = 18,
+        kPhpGenericServicesFieldNumber = 42,
+        kDeprecatedFieldNumber = 23,
+        kOptimizeForFieldNumber = 9,
+        kCcEnableArenasFieldNumber = 31,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    // optional string java_package = 1;
+    bool has_java_package() const;
+
+private:
+    bool _internal_has_java_package() const;
+
+public:
+    void clear_java_package();
+    const std::string& java_package() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_java_package(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_java_package();
+    PROTOBUF_NODISCARD std::string* release_java_package();
+    void set_allocated_java_package(std::string* java_package);
+
+private:
+    const std::string& _internal_java_package() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_java_package(const std::string& value);
+    std::string* _internal_mutable_java_package();
+
+public:
+    // optional string java_outer_classname = 8;
+    bool has_java_outer_classname() const;
+
+private:
+    bool _internal_has_java_outer_classname() const;
+
+public:
+    void clear_java_outer_classname();
+    const std::string& java_outer_classname() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_java_outer_classname(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_java_outer_classname();
+    PROTOBUF_NODISCARD std::string* release_java_outer_classname();
+    void set_allocated_java_outer_classname(std::string* java_outer_classname);
+
+private:
+    const std::string& _internal_java_outer_classname() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_java_outer_classname(const std::string& value);
+    std::string* _internal_mutable_java_outer_classname();
+
+public:
+    // optional string go_package = 11;
+    bool has_go_package() const;
+
+private:
+    bool _internal_has_go_package() const;
+
+public:
+    void clear_go_package();
+    const std::string& go_package() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_go_package(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_go_package();
+    PROTOBUF_NODISCARD std::string* release_go_package();
+    void set_allocated_go_package(std::string* go_package);
+
+private:
+    const std::string& _internal_go_package() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_go_package(const std::string& value);
+    std::string* _internal_mutable_go_package();
+
+public:
+    // optional string objc_class_prefix = 36;
+    bool has_objc_class_prefix() const;
+
+private:
+    bool _internal_has_objc_class_prefix() const;
+
+public:
+    void clear_objc_class_prefix();
+    const std::string& objc_class_prefix() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_objc_class_prefix(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_objc_class_prefix();
+    PROTOBUF_NODISCARD std::string* release_objc_class_prefix();
+    void set_allocated_objc_class_prefix(std::string* objc_class_prefix);
+
+private:
+    const std::string& _internal_objc_class_prefix() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_objc_class_prefix(const std::string& value);
+    std::string* _internal_mutable_objc_class_prefix();
+
+public:
+    // optional string csharp_namespace = 37;
+    bool has_csharp_namespace() const;
+
+private:
+    bool _internal_has_csharp_namespace() const;
+
+public:
+    void clear_csharp_namespace();
+    const std::string& csharp_namespace() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_csharp_namespace(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_csharp_namespace();
+    PROTOBUF_NODISCARD std::string* release_csharp_namespace();
+    void set_allocated_csharp_namespace(std::string* csharp_namespace);
+
+private:
+    const std::string& _internal_csharp_namespace() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_csharp_namespace(const std::string& value);
+    std::string* _internal_mutable_csharp_namespace();
+
+public:
+    // optional string swift_prefix = 39;
+    bool has_swift_prefix() const;
+
+private:
+    bool _internal_has_swift_prefix() const;
+
+public:
+    void clear_swift_prefix();
+    const std::string& swift_prefix() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_swift_prefix(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_swift_prefix();
+    PROTOBUF_NODISCARD std::string* release_swift_prefix();
+    void set_allocated_swift_prefix(std::string* swift_prefix);
+
+private:
+    const std::string& _internal_swift_prefix() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_swift_prefix(const std::string& value);
+    std::string* _internal_mutable_swift_prefix();
+
+public:
+    // optional string php_class_prefix = 40;
+    bool has_php_class_prefix() const;
+
+private:
+    bool _internal_has_php_class_prefix() const;
+
+public:
+    void clear_php_class_prefix();
+    const std::string& php_class_prefix() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_php_class_prefix(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_php_class_prefix();
+    PROTOBUF_NODISCARD std::string* release_php_class_prefix();
+    void set_allocated_php_class_prefix(std::string* php_class_prefix);
+
+private:
+    const std::string& _internal_php_class_prefix() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_class_prefix(const std::string& value);
+    std::string* _internal_mutable_php_class_prefix();
+
+public:
+    // optional string php_namespace = 41;
+    bool has_php_namespace() const;
+
+private:
+    bool _internal_has_php_namespace() const;
+
+public:
+    void clear_php_namespace();
+    const std::string& php_namespace() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_php_namespace(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_php_namespace();
+    PROTOBUF_NODISCARD std::string* release_php_namespace();
+    void set_allocated_php_namespace(std::string* php_namespace);
+
+private:
+    const std::string& _internal_php_namespace() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_namespace(const std::string& value);
+    std::string* _internal_mutable_php_namespace();
+
+public:
+    // optional string php_metadata_namespace = 44;
+    bool has_php_metadata_namespace() const;
+
+private:
+    bool _internal_has_php_metadata_namespace() const;
+
+public:
+    void clear_php_metadata_namespace();
+    const std::string& php_metadata_namespace() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_php_metadata_namespace(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_php_metadata_namespace();
+    PROTOBUF_NODISCARD std::string* release_php_metadata_namespace();
+    void set_allocated_php_metadata_namespace(std::string* php_metadata_namespace);
+
+private:
+    const std::string& _internal_php_metadata_namespace() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_metadata_namespace(const std::string& value);
+    std::string* _internal_mutable_php_metadata_namespace();
+
+public:
+    // optional string ruby_package = 45;
+    bool has_ruby_package() const;
+
+private:
+    bool _internal_has_ruby_package() const;
+
+public:
+    void clear_ruby_package();
+    const std::string& ruby_package() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_ruby_package(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_ruby_package();
+    PROTOBUF_NODISCARD std::string* release_ruby_package();
+    void set_allocated_ruby_package(std::string* ruby_package);
+
+private:
+    const std::string& _internal_ruby_package() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_ruby_package(const std::string& value);
+    std::string* _internal_mutable_ruby_package();
+
+public:
+    // optional bool java_multiple_files = 10 [default = false];
+    bool has_java_multiple_files() const;
+
+private:
+    bool _internal_has_java_multiple_files() const;
+
+public:
+    void clear_java_multiple_files();
+    bool java_multiple_files() const;
+    void set_java_multiple_files(bool value);
+
+private:
+    bool _internal_java_multiple_files() const;
+    void _internal_set_java_multiple_files(bool value);
+
+public:
+    // optional bool java_generate_equals_and_hash = 20 [deprecated = true];
+    PROTOBUF_DEPRECATED bool has_java_generate_equals_and_hash() const;
+
+private:
+    bool _internal_has_java_generate_equals_and_hash() const;
+
+public:
+    PROTOBUF_DEPRECATED void clear_java_generate_equals_and_hash();
+    PROTOBUF_DEPRECATED bool java_generate_equals_and_hash() const;
+    PROTOBUF_DEPRECATED void set_java_generate_equals_and_hash(bool value);
+
+private:
+    bool _internal_java_generate_equals_and_hash() const;
+    void _internal_set_java_generate_equals_and_hash(bool value);
+
+public:
+    // optional bool java_string_check_utf8 = 27 [default = false];
+    bool has_java_string_check_utf8() const;
+
+private:
+    bool _internal_has_java_string_check_utf8() const;
+
+public:
+    void clear_java_string_check_utf8();
+    bool java_string_check_utf8() const;
+    void set_java_string_check_utf8(bool value);
+
+private:
+    bool _internal_java_string_check_utf8() const;
+    void _internal_set_java_string_check_utf8(bool value);
+
+public:
+    // optional bool cc_generic_services = 16 [default = false];
+    bool has_cc_generic_services() const;
+
+private:
+    bool _internal_has_cc_generic_services() const;
+
+public:
+    void clear_cc_generic_services();
+    bool cc_generic_services() const;
+    void set_cc_generic_services(bool value);
+
+private:
+    bool _internal_cc_generic_services() const;
+    void _internal_set_cc_generic_services(bool value);
+
+public:
+    // optional bool java_generic_services = 17 [default = false];
+    bool has_java_generic_services() const;
+
+private:
+    bool _internal_has_java_generic_services() const;
+
+public:
+    void clear_java_generic_services();
+    bool java_generic_services() const;
+    void set_java_generic_services(bool value);
+
+private:
+    bool _internal_java_generic_services() const;
+    void _internal_set_java_generic_services(bool value);
+
+public:
+    // optional bool py_generic_services = 18 [default = false];
+    bool has_py_generic_services() const;
+
+private:
+    bool _internal_has_py_generic_services() const;
+
+public:
+    void clear_py_generic_services();
+    bool py_generic_services() const;
+    void set_py_generic_services(bool value);
+
+private:
+    bool _internal_py_generic_services() const;
+    void _internal_set_py_generic_services(bool value);
+
+public:
+    // optional bool php_generic_services = 42 [default = false];
+    bool has_php_generic_services() const;
+
+private:
+    bool _internal_has_php_generic_services() const;
+
+public:
+    void clear_php_generic_services();
+    bool php_generic_services() const;
+    void set_php_generic_services(bool value);
+
+private:
+    bool _internal_php_generic_services() const;
+    void _internal_set_php_generic_services(bool value);
+
+public:
+    // optional bool deprecated = 23 [default = false];
+    bool has_deprecated() const;
+
+private:
+    bool _internal_has_deprecated() const;
+
+public:
+    void clear_deprecated();
+    bool deprecated() const;
+    void set_deprecated(bool value);
+
+private:
+    bool _internal_deprecated() const;
+    void _internal_set_deprecated(bool value);
+
+public:
+    // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
+    bool has_optimize_for() const;
+
+private:
+    bool _internal_has_optimize_for() const;
+
+public:
+    void clear_optimize_for();
+    ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode optimize_for() const;
+    void set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode _internal_optimize_for() const;
+    void _internal_set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value);
+
+public:
+    // optional bool cc_enable_arenas = 31 [default = true];
+    bool has_cc_enable_arenas() const;
+
+private:
+    bool _internal_has_cc_enable_arenas() const;
+
+public:
+    void clear_cc_enable_arenas();
+    bool cc_enable_arenas() const;
+    void set_cc_enable_arenas(bool value);
+
+private:
+    bool _internal_cc_enable_arenas() const;
+    void _internal_set_cc_enable_arenas(bool value);
+
+public:
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                FileOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                FileOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FileOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                FileOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                FileOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.FileOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr java_package_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr java_outer_classname_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr go_package_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr objc_class_prefix_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr csharp_namespace_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr swift_prefix_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_class_prefix_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_namespace_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_metadata_namespace_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ruby_package_;
+        bool java_multiple_files_;
+        bool java_generate_equals_and_hash_;
+        bool java_string_check_utf8_;
+        bool cc_generic_services_;
+        bool java_generic_services_;
+        bool py_generic_services_;
+        bool php_generic_services_;
+        bool deprecated_;
+        int optimize_for_;
+        bool cc_enable_arenas_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT MessageOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MessageOptions) */
+{
+public:
+    inline MessageOptions() :
+        MessageOptions(nullptr)
+    {
+    }
+    ~MessageOptions() override;
+    explicit PROTOBUF_CONSTEXPR MessageOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    MessageOptions(const MessageOptions& from);
+    MessageOptions(MessageOptions&& from) noexcept
+        :
+        MessageOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline MessageOptions& operator=(const MessageOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline MessageOptions& operator=(MessageOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const MessageOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const MessageOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const MessageOptions*>(
+            &_MessageOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        14;
+
+    friend void swap(MessageOptions& a, MessageOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(MessageOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(MessageOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    MessageOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<MessageOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const MessageOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const MessageOptions& from)
+    {
+        MessageOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(MessageOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.MessageOptions";
+    }
+
+protected:
+    explicit MessageOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+        kMessageSetWireFormatFieldNumber = 1,
+        kNoStandardDescriptorAccessorFieldNumber = 2,
+        kDeprecatedFieldNumber = 3,
+        kMapEntryFieldNumber = 7,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    // optional bool message_set_wire_format = 1 [default = false];
+    bool has_message_set_wire_format() const;
+
+private:
+    bool _internal_has_message_set_wire_format() const;
+
+public:
+    void clear_message_set_wire_format();
+    bool message_set_wire_format() const;
+    void set_message_set_wire_format(bool value);
+
+private:
+    bool _internal_message_set_wire_format() const;
+    void _internal_set_message_set_wire_format(bool value);
+
+public:
+    // optional bool no_standard_descriptor_accessor = 2 [default = false];
+    bool has_no_standard_descriptor_accessor() const;
+
+private:
+    bool _internal_has_no_standard_descriptor_accessor() const;
+
+public:
+    void clear_no_standard_descriptor_accessor();
+    bool no_standard_descriptor_accessor() const;
+    void set_no_standard_descriptor_accessor(bool value);
+
+private:
+    bool _internal_no_standard_descriptor_accessor() const;
+    void _internal_set_no_standard_descriptor_accessor(bool value);
+
+public:
+    // optional bool deprecated = 3 [default = false];
+    bool has_deprecated() const;
+
+private:
+    bool _internal_has_deprecated() const;
+
+public:
+    void clear_deprecated();
+    bool deprecated() const;
+    void set_deprecated(bool value);
+
+private:
+    bool _internal_deprecated() const;
+    void _internal_set_deprecated(bool value);
+
+public:
+    // optional bool map_entry = 7;
+    bool has_map_entry() const;
+
+private:
+    bool _internal_has_map_entry() const;
+
+public:
+    void clear_map_entry();
+    bool map_entry() const;
+    void set_map_entry(bool value);
+
+private:
+    bool _internal_map_entry() const;
+    void _internal_set_map_entry(bool value);
+
+public:
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                MessageOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                MessageOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MessageOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                MessageOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                MessageOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        bool message_set_wire_format_;
+        bool no_standard_descriptor_accessor_;
+        bool deprecated_;
+        bool map_entry_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT FieldOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldOptions) */
+{
+public:
+    inline FieldOptions() :
+        FieldOptions(nullptr)
+    {
+    }
+    ~FieldOptions() override;
+    explicit PROTOBUF_CONSTEXPR FieldOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    FieldOptions(const FieldOptions& from);
+    FieldOptions(FieldOptions&& from) noexcept
+        :
+        FieldOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline FieldOptions& operator=(const FieldOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline FieldOptions& operator=(FieldOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const FieldOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const FieldOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const FieldOptions*>(
+            &_FieldOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        15;
+
+    friend void swap(FieldOptions& a, FieldOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(FieldOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(FieldOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    FieldOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<FieldOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const FieldOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const FieldOptions& from)
+    {
+        FieldOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(FieldOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.FieldOptions";
+    }
+
+protected:
+    explicit FieldOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef FieldOptions_CType CType;
+    static constexpr CType STRING =
+        FieldOptions_CType_STRING;
+    static constexpr CType CORD =
+        FieldOptions_CType_CORD;
+    static constexpr CType STRING_PIECE =
+        FieldOptions_CType_STRING_PIECE;
+    static inline bool CType_IsValid(int value)
+    {
+        return FieldOptions_CType_IsValid(value);
+    }
+    static constexpr CType CType_MIN =
+        FieldOptions_CType_CType_MIN;
+    static constexpr CType CType_MAX =
+        FieldOptions_CType_CType_MAX;
+    static constexpr int CType_ARRAYSIZE =
+        FieldOptions_CType_CType_ARRAYSIZE;
+    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+        CType_descriptor()
+    {
+        return FieldOptions_CType_descriptor();
+    }
+    template<typename T>
+    static inline const std::string& CType_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, CType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function CType_Name.");
+        return FieldOptions_CType_Name(enum_t_value);
+    }
+    static inline bool CType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CType* value)
+    {
+        return FieldOptions_CType_Parse(name, value);
+    }
+
+    typedef FieldOptions_JSType JSType;
+    static constexpr JSType JS_NORMAL =
+        FieldOptions_JSType_JS_NORMAL;
+    static constexpr JSType JS_STRING =
+        FieldOptions_JSType_JS_STRING;
+    static constexpr JSType JS_NUMBER =
+        FieldOptions_JSType_JS_NUMBER;
+    static inline bool JSType_IsValid(int value)
+    {
+        return FieldOptions_JSType_IsValid(value);
+    }
+    static constexpr JSType JSType_MIN =
+        FieldOptions_JSType_JSType_MIN;
+    static constexpr JSType JSType_MAX =
+        FieldOptions_JSType_JSType_MAX;
+    static constexpr int JSType_ARRAYSIZE =
+        FieldOptions_JSType_JSType_ARRAYSIZE;
+    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+        JSType_descriptor()
+    {
+        return FieldOptions_JSType_descriptor();
+    }
+    template<typename T>
+    static inline const std::string& JSType_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, JSType>::value || ::std::is_integral<T>::value, "Incorrect type passed to function JSType_Name.");
+        return FieldOptions_JSType_Name(enum_t_value);
+    }
+    static inline bool JSType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JSType* value)
+    {
+        return FieldOptions_JSType_Parse(name, value);
+    }
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+        kCtypeFieldNumber = 1,
+        kJstypeFieldNumber = 6,
+        kPackedFieldNumber = 2,
+        kLazyFieldNumber = 5,
+        kUnverifiedLazyFieldNumber = 15,
+        kDeprecatedFieldNumber = 3,
+        kWeakFieldNumber = 10,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
+    bool has_ctype() const;
+
+private:
+    bool _internal_has_ctype() const;
+
+public:
+    void clear_ctype();
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType ctype() const;
+    void set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType _internal_ctype() const;
+    void _internal_set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value);
+
+public:
+    // optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
+    bool has_jstype() const;
+
+private:
+    bool _internal_has_jstype() const;
+
+public:
+    void clear_jstype();
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType jstype() const;
+    void set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType _internal_jstype() const;
+    void _internal_set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value);
+
+public:
+    // optional bool packed = 2;
+    bool has_packed() const;
+
+private:
+    bool _internal_has_packed() const;
+
+public:
+    void clear_packed();
+    bool packed() const;
+    void set_packed(bool value);
+
+private:
+    bool _internal_packed() const;
+    void _internal_set_packed(bool value);
+
+public:
+    // optional bool lazy = 5 [default = false];
+    bool has_lazy() const;
+
+private:
+    bool _internal_has_lazy() const;
+
+public:
+    void clear_lazy();
+    bool lazy() const;
+    void set_lazy(bool value);
+
+private:
+    bool _internal_lazy() const;
+    void _internal_set_lazy(bool value);
+
+public:
+    // optional bool unverified_lazy = 15 [default = false];
+    bool has_unverified_lazy() const;
+
+private:
+    bool _internal_has_unverified_lazy() const;
+
+public:
+    void clear_unverified_lazy();
+    bool unverified_lazy() const;
+    void set_unverified_lazy(bool value);
+
+private:
+    bool _internal_unverified_lazy() const;
+    void _internal_set_unverified_lazy(bool value);
+
+public:
+    // optional bool deprecated = 3 [default = false];
+    bool has_deprecated() const;
+
+private:
+    bool _internal_has_deprecated() const;
+
+public:
+    void clear_deprecated();
+    bool deprecated() const;
+    void set_deprecated(bool value);
+
+private:
+    bool _internal_deprecated() const;
+    void _internal_set_deprecated(bool value);
+
+public:
+    // optional bool weak = 10 [default = false];
+    bool has_weak() const;
+
+private:
+    bool _internal_has_weak() const;
+
+public:
+    void clear_weak();
+    bool weak() const;
+    void set_weak(bool value);
+
+private:
+    bool _internal_weak() const;
+    void _internal_set_weak(bool value);
+
+public:
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                FieldOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                FieldOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            FieldOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                FieldOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                FieldOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        int ctype_;
+        int jstype_;
+        bool packed_;
+        bool lazy_;
+        bool unverified_lazy_;
+        bool deprecated_;
+        bool weak_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT OneofOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofOptions) */
+{
+public:
+    inline OneofOptions() :
+        OneofOptions(nullptr)
+    {
+    }
+    ~OneofOptions() override;
+    explicit PROTOBUF_CONSTEXPR OneofOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    OneofOptions(const OneofOptions& from);
+    OneofOptions(OneofOptions&& from) noexcept
+        :
+        OneofOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline OneofOptions& operator=(const OneofOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline OneofOptions& operator=(OneofOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const OneofOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const OneofOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const OneofOptions*>(
+            &_OneofOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        16;
+
+    friend void swap(OneofOptions& a, OneofOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(OneofOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(OneofOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    OneofOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<OneofOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const OneofOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const OneofOptions& from)
+    {
+        OneofOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(OneofOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.OneofOptions";
+    }
+
+protected:
+    explicit OneofOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                OneofOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                OneofOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            OneofOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                OneofOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                OneofOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.OneofOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumOptions) */
+{
+public:
+    inline EnumOptions() :
+        EnumOptions(nullptr)
+    {
+    }
+    ~EnumOptions() override;
+    explicit PROTOBUF_CONSTEXPR EnumOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    EnumOptions(const EnumOptions& from);
+    EnumOptions(EnumOptions&& from) noexcept
+        :
+        EnumOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline EnumOptions& operator=(const EnumOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline EnumOptions& operator=(EnumOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const EnumOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const EnumOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const EnumOptions*>(
+            &_EnumOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        17;
+
+    friend void swap(EnumOptions& a, EnumOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(EnumOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(EnumOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    EnumOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<EnumOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const EnumOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const EnumOptions& from)
+    {
+        EnumOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(EnumOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.EnumOptions";
+    }
+
+protected:
+    explicit EnumOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+        kAllowAliasFieldNumber = 2,
+        kDeprecatedFieldNumber = 3,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    // optional bool allow_alias = 2;
+    bool has_allow_alias() const;
+
+private:
+    bool _internal_has_allow_alias() const;
+
+public:
+    void clear_allow_alias();
+    bool allow_alias() const;
+    void set_allow_alias(bool value);
+
+private:
+    bool _internal_allow_alias() const;
+    void _internal_set_allow_alias(bool value);
+
+public:
+    // optional bool deprecated = 3 [default = false];
+    bool has_deprecated() const;
+
+private:
+    bool _internal_has_deprecated() const;
+
+public:
+    void clear_deprecated();
+    bool deprecated() const;
+    void set_deprecated(bool value);
+
+private:
+    bool _internal_deprecated() const;
+    void _internal_set_deprecated(bool value);
+
+public:
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                EnumOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                EnumOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                EnumOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                EnumOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        bool allow_alias_;
+        bool deprecated_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT EnumValueOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueOptions) */
+{
+public:
+    inline EnumValueOptions() :
+        EnumValueOptions(nullptr)
+    {
+    }
+    ~EnumValueOptions() override;
+    explicit PROTOBUF_CONSTEXPR EnumValueOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    EnumValueOptions(const EnumValueOptions& from);
+    EnumValueOptions(EnumValueOptions&& from) noexcept
+        :
+        EnumValueOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline EnumValueOptions& operator=(const EnumValueOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline EnumValueOptions& operator=(EnumValueOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const EnumValueOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const EnumValueOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const EnumValueOptions*>(
+            &_EnumValueOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        18;
+
+    friend void swap(EnumValueOptions& a, EnumValueOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(EnumValueOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(EnumValueOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    EnumValueOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<EnumValueOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const EnumValueOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const EnumValueOptions& from)
+    {
+        EnumValueOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(EnumValueOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.EnumValueOptions";
+    }
+
+protected:
+    explicit EnumValueOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+        kDeprecatedFieldNumber = 1,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    // optional bool deprecated = 1 [default = false];
+    bool has_deprecated() const;
+
+private:
+    bool _internal_has_deprecated() const;
+
+public:
+    void clear_deprecated();
+    bool deprecated() const;
+    void set_deprecated(bool value);
+
+private:
+    bool _internal_deprecated() const;
+    void _internal_set_deprecated(bool value);
+
+public:
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                EnumValueOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                EnumValueOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            EnumValueOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                EnumValueOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                EnumValueOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        bool deprecated_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT ServiceOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */
+{
+public:
+    inline ServiceOptions() :
+        ServiceOptions(nullptr)
+    {
+    }
+    ~ServiceOptions() override;
+    explicit PROTOBUF_CONSTEXPR ServiceOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    ServiceOptions(const ServiceOptions& from);
+    ServiceOptions(ServiceOptions&& from) noexcept
+        :
+        ServiceOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline ServiceOptions& operator=(const ServiceOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline ServiceOptions& operator=(ServiceOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const ServiceOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const ServiceOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const ServiceOptions*>(
+            &_ServiceOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        19;
+
+    friend void swap(ServiceOptions& a, ServiceOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(ServiceOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(ServiceOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    ServiceOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<ServiceOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const ServiceOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const ServiceOptions& from)
+    {
+        ServiceOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(ServiceOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.ServiceOptions";
+    }
+
+protected:
+    explicit ServiceOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+        kDeprecatedFieldNumber = 33,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    // optional bool deprecated = 33 [default = false];
+    bool has_deprecated() const;
+
+private:
+    bool _internal_has_deprecated() const;
+
+public:
+    void clear_deprecated();
+    bool deprecated() const;
+    void set_deprecated(bool value);
+
+private:
+    bool _internal_deprecated() const;
+    void _internal_set_deprecated(bool value);
+
+public:
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                ServiceOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                ServiceOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            ServiceOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                ServiceOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                ServiceOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        bool deprecated_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT MethodOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodOptions) */
+{
+public:
+    inline MethodOptions() :
+        MethodOptions(nullptr)
+    {
+    }
+    ~MethodOptions() override;
+    explicit PROTOBUF_CONSTEXPR MethodOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    MethodOptions(const MethodOptions& from);
+    MethodOptions(MethodOptions&& from) noexcept
+        :
+        MethodOptions()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline MethodOptions& operator=(const MethodOptions& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline MethodOptions& operator=(MethodOptions&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const MethodOptions& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const MethodOptions* internal_default_instance()
+    {
+        return reinterpret_cast<const MethodOptions*>(
+            &_MethodOptions_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        20;
+
+    friend void swap(MethodOptions& a, MethodOptions& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(MethodOptions* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(MethodOptions* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    MethodOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<MethodOptions>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const MethodOptions& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const MethodOptions& from)
+    {
+        MethodOptions::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(MethodOptions* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.MethodOptions";
+    }
+
+protected:
+    explicit MethodOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef MethodOptions_IdempotencyLevel IdempotencyLevel;
+    static constexpr IdempotencyLevel IDEMPOTENCY_UNKNOWN =
+        MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
+    static constexpr IdempotencyLevel NO_SIDE_EFFECTS =
+        MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS;
+    static constexpr IdempotencyLevel IDEMPOTENT =
+        MethodOptions_IdempotencyLevel_IDEMPOTENT;
+    static inline bool IdempotencyLevel_IsValid(int value)
+    {
+        return MethodOptions_IdempotencyLevel_IsValid(value);
+    }
+    static constexpr IdempotencyLevel IdempotencyLevel_MIN =
+        MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN;
+    static constexpr IdempotencyLevel IdempotencyLevel_MAX =
+        MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX;
+    static constexpr int IdempotencyLevel_ARRAYSIZE =
+        MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE;
+    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+        IdempotencyLevel_descriptor()
+    {
+        return MethodOptions_IdempotencyLevel_descriptor();
+    }
+    template<typename T>
+    static inline const std::string& IdempotencyLevel_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, IdempotencyLevel>::value || ::std::is_integral<T>::value, "Incorrect type passed to function IdempotencyLevel_Name.");
+        return MethodOptions_IdempotencyLevel_Name(enum_t_value);
+    }
+    static inline bool IdempotencyLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IdempotencyLevel* value)
+    {
+        return MethodOptions_IdempotencyLevel_Parse(name, value);
+    }
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kUninterpretedOptionFieldNumber = 999,
+        kDeprecatedFieldNumber = 33,
+        kIdempotencyLevelFieldNumber = 34,
+    };
+    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+    int uninterpreted_option_size() const;
+
+private:
+    int _internal_uninterpreted_option_size() const;
+
+public:
+    void clear_uninterpreted_option();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+        mutable_uninterpreted_option();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+        uninterpreted_option() const;
+
+    // optional bool deprecated = 33 [default = false];
+    bool has_deprecated() const;
+
+private:
+    bool _internal_has_deprecated() const;
+
+public:
+    void clear_deprecated();
+    bool deprecated() const;
+    void set_deprecated(bool value);
+
+private:
+    bool _internal_deprecated() const;
+    void _internal_set_deprecated(bool value);
+
+public:
+    // optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
+    bool has_idempotency_level() const;
+
+private:
+    bool _internal_has_idempotency_level() const;
+
+public:
+    void clear_idempotency_level();
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel idempotency_level() const;
+    void set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel _internal_idempotency_level() const;
+    void _internal_set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value);
+
+public:
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline bool HasExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.Has(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void ClearExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        _impl_._extensions_.ClearExtension(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline int ExtensionSize(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _impl_._extensions_.ExtensionSize(id.number());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::SetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void UnsafeArenaSetAllocatedExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Singular::MutableType value
+    )
+    {
+        _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type, value, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    PROTOBUF_NODISCARD inline
+        typename _proto_TypeTraits::Singular::MutableType
+        ReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                MethodOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::Release(id.number(), _field_type, &_impl_._extensions_);
+    }
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Singular::MutableType
+        UnsafeArenaReleaseExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                MethodOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    ) const
+    {
+        return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index
+    )
+    {
+        return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void SetExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        int index,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id
+    )
+    {
+        typename _proto_TypeTraits::Repeated::MutableType to_add =
+            _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
+
+        return to_add;
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline void AddExtension(
+        const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+            MethodOptions,
+            _proto_TypeTraits,
+            _field_type,
+            _is_packed>& id,
+        typename _proto_TypeTraits::Repeated::ConstType value
+    )
+    {
+        _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value, &_impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
+        GetRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                MethodOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        ) const
+    {
+        return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
+    }
+
+    template<typename _proto_TypeTraits, ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type, bool _is_packed>
+    inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
+        MutableRepeatedExtension(
+            const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
+                MethodOptions,
+                _proto_TypeTraits,
+                _field_type,
+                _is_packed>& id
+        )
+    {
+        return _proto_TypeTraits::MutableRepeated(id.number(), _field_type, _is_packed, &_impl_._extensions_);
+    }
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
+
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption> uninterpreted_option_;
+        bool deprecated_;
+        int idempotency_level_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT UninterpretedOption_NamePart final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */
+{
+public:
+    inline UninterpretedOption_NamePart() :
+        UninterpretedOption_NamePart(nullptr)
+    {
+    }
+    ~UninterpretedOption_NamePart() override;
+    explicit PROTOBUF_CONSTEXPR UninterpretedOption_NamePart(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from);
+    UninterpretedOption_NamePart(UninterpretedOption_NamePart&& from) noexcept
+        :
+        UninterpretedOption_NamePart()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline UninterpretedOption_NamePart& operator=(UninterpretedOption_NamePart&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const UninterpretedOption_NamePart& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const UninterpretedOption_NamePart* internal_default_instance()
+    {
+        return reinterpret_cast<const UninterpretedOption_NamePart*>(
+            &_UninterpretedOption_NamePart_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        21;
+
+    friend void swap(UninterpretedOption_NamePart& a, UninterpretedOption_NamePart& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(UninterpretedOption_NamePart* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(UninterpretedOption_NamePart* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    UninterpretedOption_NamePart* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<UninterpretedOption_NamePart>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const UninterpretedOption_NamePart& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const UninterpretedOption_NamePart& from)
+    {
+        UninterpretedOption_NamePart::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(UninterpretedOption_NamePart* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.UninterpretedOption.NamePart";
+    }
+
+protected:
+    explicit UninterpretedOption_NamePart(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNamePartFieldNumber = 1,
+        kIsExtensionFieldNumber = 2,
+    };
+    // required string name_part = 1;
+    bool has_name_part() const;
+
+private:
+    bool _internal_has_name_part() const;
+
+public:
+    void clear_name_part();
+    const std::string& name_part() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name_part(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name_part();
+    PROTOBUF_NODISCARD std::string* release_name_part();
+    void set_allocated_name_part(std::string* name_part);
+
+private:
+    const std::string& _internal_name_part() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name_part(const std::string& value);
+    std::string* _internal_mutable_name_part();
+
+public:
+    // required bool is_extension = 2;
+    bool has_is_extension() const;
+
+private:
+    bool _internal_has_is_extension() const;
+
+public:
+    void clear_is_extension();
+    bool is_extension() const;
+    void set_is_extension(bool value);
+
+private:
+    bool _internal_is_extension() const;
+    void _internal_set_is_extension(bool value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart)
+
+private:
+    class _Internal;
+
+    // helper for ByteSizeLong()
+    size_t RequiredFieldsByteSizeFallback() const;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_part_;
+        bool is_extension_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT UninterpretedOption final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption) */
+{
+public:
+    inline UninterpretedOption() :
+        UninterpretedOption(nullptr)
+    {
+    }
+    ~UninterpretedOption() override;
+    explicit PROTOBUF_CONSTEXPR UninterpretedOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    UninterpretedOption(const UninterpretedOption& from);
+    UninterpretedOption(UninterpretedOption&& from) noexcept
+        :
+        UninterpretedOption()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline UninterpretedOption& operator=(const UninterpretedOption& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline UninterpretedOption& operator=(UninterpretedOption&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const UninterpretedOption& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const UninterpretedOption* internal_default_instance()
+    {
+        return reinterpret_cast<const UninterpretedOption*>(
+            &_UninterpretedOption_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        22;
+
+    friend void swap(UninterpretedOption& a, UninterpretedOption& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(UninterpretedOption* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(UninterpretedOption* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    UninterpretedOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<UninterpretedOption>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const UninterpretedOption& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const UninterpretedOption& from)
+    {
+        UninterpretedOption::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(UninterpretedOption* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.UninterpretedOption";
+    }
+
+protected:
+    explicit UninterpretedOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef UninterpretedOption_NamePart NamePart;
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNameFieldNumber = 2,
+        kIdentifierValueFieldNumber = 3,
+        kStringValueFieldNumber = 7,
+        kAggregateValueFieldNumber = 8,
+        kPositiveIntValueFieldNumber = 4,
+        kNegativeIntValueFieldNumber = 5,
+        kDoubleValueFieldNumber = 6,
+    };
+    // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
+    int name_size() const;
+
+private:
+    int _internal_name_size() const;
+
+public:
+    void clear_name();
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* mutable_name(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>*
+        mutable_name();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& _internal_name(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* _internal_add_name();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& name(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* add_name();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>&
+        name() const;
+
+    // optional string identifier_value = 3;
+    bool has_identifier_value() const;
+
+private:
+    bool _internal_has_identifier_value() const;
+
+public:
+    void clear_identifier_value();
+    const std::string& identifier_value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_identifier_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_identifier_value();
+    PROTOBUF_NODISCARD std::string* release_identifier_value();
+    void set_allocated_identifier_value(std::string* identifier_value);
+
+private:
+    const std::string& _internal_identifier_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_identifier_value(const std::string& value);
+    std::string* _internal_mutable_identifier_value();
+
+public:
+    // optional bytes string_value = 7;
+    bool has_string_value() const;
+
+private:
+    bool _internal_has_string_value() const;
+
+public:
+    void clear_string_value();
+    const std::string& string_value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_string_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_string_value();
+    PROTOBUF_NODISCARD std::string* release_string_value();
+    void set_allocated_string_value(std::string* string_value);
+
+private:
+    const std::string& _internal_string_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
+    std::string* _internal_mutable_string_value();
+
+public:
+    // optional string aggregate_value = 8;
+    bool has_aggregate_value() const;
+
+private:
+    bool _internal_has_aggregate_value() const;
+
+public:
+    void clear_aggregate_value();
+    const std::string& aggregate_value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_aggregate_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_aggregate_value();
+    PROTOBUF_NODISCARD std::string* release_aggregate_value();
+    void set_allocated_aggregate_value(std::string* aggregate_value);
+
+private:
+    const std::string& _internal_aggregate_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregate_value(const std::string& value);
+    std::string* _internal_mutable_aggregate_value();
+
+public:
+    // optional uint64 positive_int_value = 4;
+    bool has_positive_int_value() const;
+
+private:
+    bool _internal_has_positive_int_value() const;
+
+public:
+    void clear_positive_int_value();
+    uint64_t positive_int_value() const;
+    void set_positive_int_value(uint64_t value);
+
+private:
+    uint64_t _internal_positive_int_value() const;
+    void _internal_set_positive_int_value(uint64_t value);
+
+public:
+    // optional int64 negative_int_value = 5;
+    bool has_negative_int_value() const;
+
+private:
+    bool _internal_has_negative_int_value() const;
+
+public:
+    void clear_negative_int_value();
+    int64_t negative_int_value() const;
+    void set_negative_int_value(int64_t value);
+
+private:
+    int64_t _internal_negative_int_value() const;
+    void _internal_set_negative_int_value(int64_t value);
+
+public:
+    // optional double double_value = 6;
+    bool has_double_value() const;
+
+private:
+    bool _internal_has_double_value() const;
+
+public:
+    void clear_double_value();
+    double double_value() const;
+    void set_double_value(double value);
+
+private:
+    double _internal_double_value() const;
+    void _internal_set_double_value(double value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart> name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identifier_value_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregate_value_;
+        uint64_t positive_int_value_;
+        int64_t negative_int_value_;
+        double double_value_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT SourceCodeInfo_Location final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */
+{
+public:
+    inline SourceCodeInfo_Location() :
+        SourceCodeInfo_Location(nullptr)
+    {
+    }
+    ~SourceCodeInfo_Location() override;
+    explicit PROTOBUF_CONSTEXPR SourceCodeInfo_Location(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    SourceCodeInfo_Location(const SourceCodeInfo_Location& from);
+    SourceCodeInfo_Location(SourceCodeInfo_Location&& from) noexcept
+        :
+        SourceCodeInfo_Location()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline SourceCodeInfo_Location& operator=(const SourceCodeInfo_Location& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline SourceCodeInfo_Location& operator=(SourceCodeInfo_Location&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const SourceCodeInfo_Location& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const SourceCodeInfo_Location* internal_default_instance()
+    {
+        return reinterpret_cast<const SourceCodeInfo_Location*>(
+            &_SourceCodeInfo_Location_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        23;
+
+    friend void swap(SourceCodeInfo_Location& a, SourceCodeInfo_Location& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(SourceCodeInfo_Location* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(SourceCodeInfo_Location* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    SourceCodeInfo_Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<SourceCodeInfo_Location>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const SourceCodeInfo_Location& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const SourceCodeInfo_Location& from)
+    {
+        SourceCodeInfo_Location::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(SourceCodeInfo_Location* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.SourceCodeInfo.Location";
+    }
+
+protected:
+    explicit SourceCodeInfo_Location(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kPathFieldNumber = 1,
+        kSpanFieldNumber = 2,
+        kLeadingDetachedCommentsFieldNumber = 6,
+        kLeadingCommentsFieldNumber = 3,
+        kTrailingCommentsFieldNumber = 4,
+    };
+    // repeated int32 path = 1 [packed = true];
+    int path_size() const;
+
+private:
+    int _internal_path_size() const;
+
+public:
+    void clear_path();
+
+private:
+    int32_t _internal_path(int index) const;
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        _internal_path() const;
+    void _internal_add_path(int32_t value);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        _internal_mutable_path();
+
+public:
+    int32_t path(int index) const;
+    void set_path(int index, int32_t value);
+    void add_path(int32_t value);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        path() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        mutable_path();
+
+    // repeated int32 span = 2 [packed = true];
+    int span_size() const;
+
+private:
+    int _internal_span_size() const;
+
+public:
+    void clear_span();
+
+private:
+    int32_t _internal_span(int index) const;
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        _internal_span() const;
+    void _internal_add_span(int32_t value);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        _internal_mutable_span();
+
+public:
+    int32_t span(int index) const;
+    void set_span(int index, int32_t value);
+    void add_span(int32_t value);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        span() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        mutable_span();
+
+    // repeated string leading_detached_comments = 6;
+    int leading_detached_comments_size() const;
+
+private:
+    int _internal_leading_detached_comments_size() const;
+
+public:
+    void clear_leading_detached_comments();
+    const std::string& leading_detached_comments(int index) const;
+    std::string* mutable_leading_detached_comments(int index);
+    void set_leading_detached_comments(int index, const std::string& value);
+    void set_leading_detached_comments(int index, std::string&& value);
+    void set_leading_detached_comments(int index, const char* value);
+    void set_leading_detached_comments(int index, const char* value, size_t size);
+    std::string* add_leading_detached_comments();
+    void add_leading_detached_comments(const std::string& value);
+    void add_leading_detached_comments(std::string&& value);
+    void add_leading_detached_comments(const char* value);
+    void add_leading_detached_comments(const char* value, size_t size);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& leading_detached_comments() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_leading_detached_comments();
+
+private:
+    const std::string& _internal_leading_detached_comments(int index) const;
+    std::string* _internal_add_leading_detached_comments();
+
+public:
+    // optional string leading_comments = 3;
+    bool has_leading_comments() const;
+
+private:
+    bool _internal_has_leading_comments() const;
+
+public:
+    void clear_leading_comments();
+    const std::string& leading_comments() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_leading_comments(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_leading_comments();
+    PROTOBUF_NODISCARD std::string* release_leading_comments();
+    void set_allocated_leading_comments(std::string* leading_comments);
+
+private:
+    const std::string& _internal_leading_comments() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_leading_comments(const std::string& value);
+    std::string* _internal_mutable_leading_comments();
+
+public:
+    // optional string trailing_comments = 4;
+    bool has_trailing_comments() const;
+
+private:
+    bool _internal_has_trailing_comments() const;
+
+public:
+    void clear_trailing_comments();
+    const std::string& trailing_comments() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_trailing_comments(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_trailing_comments();
+    PROTOBUF_NODISCARD std::string* release_trailing_comments();
+    void set_allocated_trailing_comments(std::string* trailing_comments);
+
+private:
+    const std::string& _internal_trailing_comments() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_trailing_comments(const std::string& value);
+    std::string* _internal_mutable_trailing_comments();
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo.Location)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t> path_;
+        mutable std::atomic<int> _path_cached_byte_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t> span_;
+        mutable std::atomic<int> _span_cached_byte_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> leading_detached_comments_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr leading_comments_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trailing_comments_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT SourceCodeInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo) */
+{
+public:
+    inline SourceCodeInfo() :
+        SourceCodeInfo(nullptr)
+    {
+    }
+    ~SourceCodeInfo() override;
+    explicit PROTOBUF_CONSTEXPR SourceCodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    SourceCodeInfo(const SourceCodeInfo& from);
+    SourceCodeInfo(SourceCodeInfo&& from) noexcept
+        :
+        SourceCodeInfo()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline SourceCodeInfo& operator=(const SourceCodeInfo& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline SourceCodeInfo& operator=(SourceCodeInfo&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const SourceCodeInfo& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const SourceCodeInfo* internal_default_instance()
+    {
+        return reinterpret_cast<const SourceCodeInfo*>(
+            &_SourceCodeInfo_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        24;
+
+    friend void swap(SourceCodeInfo& a, SourceCodeInfo& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(SourceCodeInfo* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(SourceCodeInfo* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    SourceCodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<SourceCodeInfo>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const SourceCodeInfo& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const SourceCodeInfo& from)
+    {
+        SourceCodeInfo::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(SourceCodeInfo* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.SourceCodeInfo";
+    }
+
+protected:
+    explicit SourceCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef SourceCodeInfo_Location Location;
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kLocationFieldNumber = 1,
+    };
+    // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
+    int location_size() const;
+
+private:
+    int _internal_location_size() const;
+
+public:
+    void clear_location();
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* mutable_location(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>*
+        mutable_location();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& _internal_location(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* _internal_add_location();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& location(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* add_location();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>&
+        location() const;
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location> location_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo.Annotation) */
+{
+public:
+    inline GeneratedCodeInfo_Annotation() :
+        GeneratedCodeInfo_Annotation(nullptr)
+    {
+    }
+    ~GeneratedCodeInfo_Annotation() override;
+    explicit PROTOBUF_CONSTEXPR GeneratedCodeInfo_Annotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    GeneratedCodeInfo_Annotation(const GeneratedCodeInfo_Annotation& from);
+    GeneratedCodeInfo_Annotation(GeneratedCodeInfo_Annotation&& from) noexcept
+        :
+        GeneratedCodeInfo_Annotation()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline GeneratedCodeInfo_Annotation& operator=(const GeneratedCodeInfo_Annotation& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline GeneratedCodeInfo_Annotation& operator=(GeneratedCodeInfo_Annotation&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
 
-class PROTOBUF_EXPORT EnumValueDescriptorProto final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueDescriptorProto) */ {
- public:
-  inline EnumValueDescriptorProto() : EnumValueDescriptorProto(nullptr) {}
-  ~EnumValueDescriptorProto() override;
-  explicit PROTOBUF_CONSTEXPR EnumValueDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  EnumValueDescriptorProto(const EnumValueDescriptorProto& from);
-  EnumValueDescriptorProto(EnumValueDescriptorProto&& from) noexcept
-    : EnumValueDescriptorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline EnumValueDescriptorProto& operator=(EnumValueDescriptorProto&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const EnumValueDescriptorProto& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const EnumValueDescriptorProto* internal_default_instance() {
-    return reinterpret_cast<const EnumValueDescriptorProto*>(
-               &_EnumValueDescriptorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    10;
-
-  friend void swap(EnumValueDescriptorProto& a, EnumValueDescriptorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(EnumValueDescriptorProto* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(EnumValueDescriptorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  EnumValueDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<EnumValueDescriptorProto>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const EnumValueDescriptorProto& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const EnumValueDescriptorProto& from) {
-    EnumValueDescriptorProto::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(EnumValueDescriptorProto* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.EnumValueDescriptorProto";
-  }
-  protected:
-  explicit EnumValueDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 1,
-    kOptionsFieldNumber = 3,
-    kNumberFieldNumber = 2,
-  };
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional .google.protobuf.EnumValueOptions options = 3;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* unsafe_arena_release_options();
-
-  // optional int32 number = 2;
-  bool has_number() const;
-  private:
-  bool _internal_has_number() const;
-  public:
-  void clear_number();
-  int32_t number() const;
-  void set_number(int32_t value);
-  private:
-  int32_t _internal_number() const;
-  void _internal_set_number(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueDescriptorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options_;
-    int32_t number_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const GeneratedCodeInfo_Annotation& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const GeneratedCodeInfo_Annotation* internal_default_instance()
+    {
+        return reinterpret_cast<const GeneratedCodeInfo_Annotation*>(
+            &_GeneratedCodeInfo_Annotation_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        25;
 
-class PROTOBUF_EXPORT ServiceDescriptorProto final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceDescriptorProto) */ {
- public:
-  inline ServiceDescriptorProto() : ServiceDescriptorProto(nullptr) {}
-  ~ServiceDescriptorProto() override;
-  explicit PROTOBUF_CONSTEXPR ServiceDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  ServiceDescriptorProto(const ServiceDescriptorProto& from);
-  ServiceDescriptorProto(ServiceDescriptorProto&& from) noexcept
-    : ServiceDescriptorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline ServiceDescriptorProto& operator=(const ServiceDescriptorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ServiceDescriptorProto& operator=(ServiceDescriptorProto&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const ServiceDescriptorProto& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const ServiceDescriptorProto* internal_default_instance() {
-    return reinterpret_cast<const ServiceDescriptorProto*>(
-               &_ServiceDescriptorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    11;
-
-  friend void swap(ServiceDescriptorProto& a, ServiceDescriptorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ServiceDescriptorProto* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ServiceDescriptorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  ServiceDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<ServiceDescriptorProto>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const ServiceDescriptorProto& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const ServiceDescriptorProto& from) {
-    ServiceDescriptorProto::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(ServiceDescriptorProto* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.ServiceDescriptorProto";
-  }
-  protected:
-  explicit ServiceDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kMethodFieldNumber = 2,
-    kNameFieldNumber = 1,
-    kOptionsFieldNumber = 3,
-  };
-  // repeated .google.protobuf.MethodDescriptorProto method = 2;
-  int method_size() const;
-  private:
-  int _internal_method_size() const;
-  public:
-  void clear_method();
-  ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* mutable_method(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >*
-      mutable_method();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& _internal_method(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* _internal_add_method();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& method(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* add_method();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >&
-      method() const;
-
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional .google.protobuf.ServiceOptions options = 3;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ServiceOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::ServiceOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* unsafe_arena_release_options();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.ServiceDescriptorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto > method_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    friend void swap(GeneratedCodeInfo_Annotation& a, GeneratedCodeInfo_Annotation& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(GeneratedCodeInfo_Annotation* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(GeneratedCodeInfo_Annotation* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
 
-class PROTOBUF_EXPORT MethodDescriptorProto final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodDescriptorProto) */ {
- public:
-  inline MethodDescriptorProto() : MethodDescriptorProto(nullptr) {}
-  ~MethodDescriptorProto() override;
-  explicit PROTOBUF_CONSTEXPR MethodDescriptorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  MethodDescriptorProto(const MethodDescriptorProto& from);
-  MethodDescriptorProto(MethodDescriptorProto&& from) noexcept
-    : MethodDescriptorProto() {
-    *this = ::std::move(from);
-  }
-
-  inline MethodDescriptorProto& operator=(const MethodDescriptorProto& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline MethodDescriptorProto& operator=(MethodDescriptorProto&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const MethodDescriptorProto& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const MethodDescriptorProto* internal_default_instance() {
-    return reinterpret_cast<const MethodDescriptorProto*>(
-               &_MethodDescriptorProto_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    12;
-
-  friend void swap(MethodDescriptorProto& a, MethodDescriptorProto& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(MethodDescriptorProto* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(MethodDescriptorProto* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  MethodDescriptorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<MethodDescriptorProto>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const MethodDescriptorProto& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const MethodDescriptorProto& from) {
-    MethodDescriptorProto::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(MethodDescriptorProto* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.MethodDescriptorProto";
-  }
-  protected:
-  explicit MethodDescriptorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 1,
-    kInputTypeFieldNumber = 2,
-    kOutputTypeFieldNumber = 3,
-    kOptionsFieldNumber = 4,
-    kClientStreamingFieldNumber = 5,
-    kServerStreamingFieldNumber = 6,
-  };
-  // optional string name = 1;
-  bool has_name() const;
-  private:
-  bool _internal_has_name() const;
-  public:
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // optional string input_type = 2;
-  bool has_input_type() const;
-  private:
-  bool _internal_has_input_type() const;
-  public:
-  void clear_input_type();
-  const std::string& input_type() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_input_type(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_input_type();
-  PROTOBUF_NODISCARD std::string* release_input_type();
-  void set_allocated_input_type(std::string* input_type);
-  private:
-  const std::string& _internal_input_type() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_type(const std::string& value);
-  std::string* _internal_mutable_input_type();
-  public:
-
-  // optional string output_type = 3;
-  bool has_output_type() const;
-  private:
-  bool _internal_has_output_type() const;
-  public:
-  void clear_output_type();
-  const std::string& output_type() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_output_type(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_output_type();
-  PROTOBUF_NODISCARD std::string* release_output_type();
-  void set_allocated_output_type(std::string* output_type);
-  private:
-  const std::string& _internal_output_type() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_type(const std::string& value);
-  std::string* _internal_mutable_output_type();
-  public:
-
-  // optional .google.protobuf.MethodOptions options = 4;
-  bool has_options() const;
-  private:
-  bool _internal_has_options() const;
-  public:
-  void clear_options();
-  const ::PROTOBUF_NAMESPACE_ID::MethodOptions& options() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::MethodOptions* release_options();
-  ::PROTOBUF_NAMESPACE_ID::MethodOptions* mutable_options();
-  void set_allocated_options(::PROTOBUF_NAMESPACE_ID::MethodOptions* options);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::MethodOptions& _internal_options() const;
-  ::PROTOBUF_NAMESPACE_ID::MethodOptions* _internal_mutable_options();
-  public:
-  void unsafe_arena_set_allocated_options(
-      ::PROTOBUF_NAMESPACE_ID::MethodOptions* options);
-  ::PROTOBUF_NAMESPACE_ID::MethodOptions* unsafe_arena_release_options();
-
-  // optional bool client_streaming = 5 [default = false];
-  bool has_client_streaming() const;
-  private:
-  bool _internal_has_client_streaming() const;
-  public:
-  void clear_client_streaming();
-  bool client_streaming() const;
-  void set_client_streaming(bool value);
-  private:
-  bool _internal_client_streaming() const;
-  void _internal_set_client_streaming(bool value);
-  public:
-
-  // optional bool server_streaming = 6 [default = false];
-  bool has_server_streaming() const;
-  private:
-  bool _internal_has_server_streaming() const;
-  public:
-  void clear_server_streaming();
-  bool server_streaming() const;
-  void set_server_streaming(bool value);
-  private:
-  bool _internal_server_streaming() const;
-  void _internal_set_server_streaming(bool value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.MethodDescriptorProto)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_type_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_type_;
-    ::PROTOBUF_NAMESPACE_ID::MethodOptions* options_;
-    bool client_streaming_;
-    bool server_streaming_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    // implements Message ----------------------------------------------
 
-class PROTOBUF_EXPORT FileOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileOptions) */ {
- public:
-  inline FileOptions() : FileOptions(nullptr) {}
-  ~FileOptions() override;
-  explicit PROTOBUF_CONSTEXPR FileOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  FileOptions(const FileOptions& from);
-  FileOptions(FileOptions&& from) noexcept
-    : FileOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline FileOptions& operator=(const FileOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FileOptions& operator=(FileOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const FileOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const FileOptions* internal_default_instance() {
-    return reinterpret_cast<const FileOptions*>(
-               &_FileOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    13;
-
-  friend void swap(FileOptions& a, FileOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FileOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(FileOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  FileOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<FileOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const FileOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const FileOptions& from) {
-    FileOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(FileOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.FileOptions";
-  }
-  protected:
-  explicit FileOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef FileOptions_OptimizeMode OptimizeMode;
-  static constexpr OptimizeMode SPEED =
-    FileOptions_OptimizeMode_SPEED;
-  static constexpr OptimizeMode CODE_SIZE =
-    FileOptions_OptimizeMode_CODE_SIZE;
-  static constexpr OptimizeMode LITE_RUNTIME =
-    FileOptions_OptimizeMode_LITE_RUNTIME;
-  static inline bool OptimizeMode_IsValid(int value) {
-    return FileOptions_OptimizeMode_IsValid(value);
-  }
-  static constexpr OptimizeMode OptimizeMode_MIN =
-    FileOptions_OptimizeMode_OptimizeMode_MIN;
-  static constexpr OptimizeMode OptimizeMode_MAX =
-    FileOptions_OptimizeMode_OptimizeMode_MAX;
-  static constexpr int OptimizeMode_ARRAYSIZE =
-    FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  OptimizeMode_descriptor() {
-    return FileOptions_OptimizeMode_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& OptimizeMode_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, OptimizeMode>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function OptimizeMode_Name.");
-    return FileOptions_OptimizeMode_Name(enum_t_value);
-  }
-  static inline bool OptimizeMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      OptimizeMode* value) {
-    return FileOptions_OptimizeMode_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-    kJavaPackageFieldNumber = 1,
-    kJavaOuterClassnameFieldNumber = 8,
-    kGoPackageFieldNumber = 11,
-    kObjcClassPrefixFieldNumber = 36,
-    kCsharpNamespaceFieldNumber = 37,
-    kSwiftPrefixFieldNumber = 39,
-    kPhpClassPrefixFieldNumber = 40,
-    kPhpNamespaceFieldNumber = 41,
-    kPhpMetadataNamespaceFieldNumber = 44,
-    kRubyPackageFieldNumber = 45,
-    kJavaMultipleFilesFieldNumber = 10,
-    kJavaGenerateEqualsAndHashFieldNumber = 20,
-    kJavaStringCheckUtf8FieldNumber = 27,
-    kCcGenericServicesFieldNumber = 16,
-    kJavaGenericServicesFieldNumber = 17,
-    kPyGenericServicesFieldNumber = 18,
-    kPhpGenericServicesFieldNumber = 42,
-    kDeprecatedFieldNumber = 23,
-    kOptimizeForFieldNumber = 9,
-    kCcEnableArenasFieldNumber = 31,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-  // optional string java_package = 1;
-  bool has_java_package() const;
-  private:
-  bool _internal_has_java_package() const;
-  public:
-  void clear_java_package();
-  const std::string& java_package() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_java_package(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_java_package();
-  PROTOBUF_NODISCARD std::string* release_java_package();
-  void set_allocated_java_package(std::string* java_package);
-  private:
-  const std::string& _internal_java_package() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_java_package(const std::string& value);
-  std::string* _internal_mutable_java_package();
-  public:
-
-  // optional string java_outer_classname = 8;
-  bool has_java_outer_classname() const;
-  private:
-  bool _internal_has_java_outer_classname() const;
-  public:
-  void clear_java_outer_classname();
-  const std::string& java_outer_classname() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_java_outer_classname(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_java_outer_classname();
-  PROTOBUF_NODISCARD std::string* release_java_outer_classname();
-  void set_allocated_java_outer_classname(std::string* java_outer_classname);
-  private:
-  const std::string& _internal_java_outer_classname() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_java_outer_classname(const std::string& value);
-  std::string* _internal_mutable_java_outer_classname();
-  public:
-
-  // optional string go_package = 11;
-  bool has_go_package() const;
-  private:
-  bool _internal_has_go_package() const;
-  public:
-  void clear_go_package();
-  const std::string& go_package() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_go_package(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_go_package();
-  PROTOBUF_NODISCARD std::string* release_go_package();
-  void set_allocated_go_package(std::string* go_package);
-  private:
-  const std::string& _internal_go_package() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_go_package(const std::string& value);
-  std::string* _internal_mutable_go_package();
-  public:
-
-  // optional string objc_class_prefix = 36;
-  bool has_objc_class_prefix() const;
-  private:
-  bool _internal_has_objc_class_prefix() const;
-  public:
-  void clear_objc_class_prefix();
-  const std::string& objc_class_prefix() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_objc_class_prefix(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_objc_class_prefix();
-  PROTOBUF_NODISCARD std::string* release_objc_class_prefix();
-  void set_allocated_objc_class_prefix(std::string* objc_class_prefix);
-  private:
-  const std::string& _internal_objc_class_prefix() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_objc_class_prefix(const std::string& value);
-  std::string* _internal_mutable_objc_class_prefix();
-  public:
-
-  // optional string csharp_namespace = 37;
-  bool has_csharp_namespace() const;
-  private:
-  bool _internal_has_csharp_namespace() const;
-  public:
-  void clear_csharp_namespace();
-  const std::string& csharp_namespace() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_csharp_namespace(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_csharp_namespace();
-  PROTOBUF_NODISCARD std::string* release_csharp_namespace();
-  void set_allocated_csharp_namespace(std::string* csharp_namespace);
-  private:
-  const std::string& _internal_csharp_namespace() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_csharp_namespace(const std::string& value);
-  std::string* _internal_mutable_csharp_namespace();
-  public:
-
-  // optional string swift_prefix = 39;
-  bool has_swift_prefix() const;
-  private:
-  bool _internal_has_swift_prefix() const;
-  public:
-  void clear_swift_prefix();
-  const std::string& swift_prefix() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_swift_prefix(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_swift_prefix();
-  PROTOBUF_NODISCARD std::string* release_swift_prefix();
-  void set_allocated_swift_prefix(std::string* swift_prefix);
-  private:
-  const std::string& _internal_swift_prefix() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_swift_prefix(const std::string& value);
-  std::string* _internal_mutable_swift_prefix();
-  public:
-
-  // optional string php_class_prefix = 40;
-  bool has_php_class_prefix() const;
-  private:
-  bool _internal_has_php_class_prefix() const;
-  public:
-  void clear_php_class_prefix();
-  const std::string& php_class_prefix() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_php_class_prefix(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_php_class_prefix();
-  PROTOBUF_NODISCARD std::string* release_php_class_prefix();
-  void set_allocated_php_class_prefix(std::string* php_class_prefix);
-  private:
-  const std::string& _internal_php_class_prefix() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_class_prefix(const std::string& value);
-  std::string* _internal_mutable_php_class_prefix();
-  public:
-
-  // optional string php_namespace = 41;
-  bool has_php_namespace() const;
-  private:
-  bool _internal_has_php_namespace() const;
-  public:
-  void clear_php_namespace();
-  const std::string& php_namespace() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_php_namespace(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_php_namespace();
-  PROTOBUF_NODISCARD std::string* release_php_namespace();
-  void set_allocated_php_namespace(std::string* php_namespace);
-  private:
-  const std::string& _internal_php_namespace() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_namespace(const std::string& value);
-  std::string* _internal_mutable_php_namespace();
-  public:
-
-  // optional string php_metadata_namespace = 44;
-  bool has_php_metadata_namespace() const;
-  private:
-  bool _internal_has_php_metadata_namespace() const;
-  public:
-  void clear_php_metadata_namespace();
-  const std::string& php_metadata_namespace() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_php_metadata_namespace(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_php_metadata_namespace();
-  PROTOBUF_NODISCARD std::string* release_php_metadata_namespace();
-  void set_allocated_php_metadata_namespace(std::string* php_metadata_namespace);
-  private:
-  const std::string& _internal_php_metadata_namespace() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_php_metadata_namespace(const std::string& value);
-  std::string* _internal_mutable_php_metadata_namespace();
-  public:
-
-  // optional string ruby_package = 45;
-  bool has_ruby_package() const;
-  private:
-  bool _internal_has_ruby_package() const;
-  public:
-  void clear_ruby_package();
-  const std::string& ruby_package() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_ruby_package(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_ruby_package();
-  PROTOBUF_NODISCARD std::string* release_ruby_package();
-  void set_allocated_ruby_package(std::string* ruby_package);
-  private:
-  const std::string& _internal_ruby_package() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ruby_package(const std::string& value);
-  std::string* _internal_mutable_ruby_package();
-  public:
-
-  // optional bool java_multiple_files = 10 [default = false];
-  bool has_java_multiple_files() const;
-  private:
-  bool _internal_has_java_multiple_files() const;
-  public:
-  void clear_java_multiple_files();
-  bool java_multiple_files() const;
-  void set_java_multiple_files(bool value);
-  private:
-  bool _internal_java_multiple_files() const;
-  void _internal_set_java_multiple_files(bool value);
-  public:
-
-  // optional bool java_generate_equals_and_hash = 20 [deprecated = true];
-  PROTOBUF_DEPRECATED bool has_java_generate_equals_and_hash() const;
-  private:
-  bool _internal_has_java_generate_equals_and_hash() const;
-  public:
-  PROTOBUF_DEPRECATED void clear_java_generate_equals_and_hash();
-  PROTOBUF_DEPRECATED bool java_generate_equals_and_hash() const;
-  PROTOBUF_DEPRECATED void set_java_generate_equals_and_hash(bool value);
-  private:
-  bool _internal_java_generate_equals_and_hash() const;
-  void _internal_set_java_generate_equals_and_hash(bool value);
-  public:
-
-  // optional bool java_string_check_utf8 = 27 [default = false];
-  bool has_java_string_check_utf8() const;
-  private:
-  bool _internal_has_java_string_check_utf8() const;
-  public:
-  void clear_java_string_check_utf8();
-  bool java_string_check_utf8() const;
-  void set_java_string_check_utf8(bool value);
-  private:
-  bool _internal_java_string_check_utf8() const;
-  void _internal_set_java_string_check_utf8(bool value);
-  public:
-
-  // optional bool cc_generic_services = 16 [default = false];
-  bool has_cc_generic_services() const;
-  private:
-  bool _internal_has_cc_generic_services() const;
-  public:
-  void clear_cc_generic_services();
-  bool cc_generic_services() const;
-  void set_cc_generic_services(bool value);
-  private:
-  bool _internal_cc_generic_services() const;
-  void _internal_set_cc_generic_services(bool value);
-  public:
-
-  // optional bool java_generic_services = 17 [default = false];
-  bool has_java_generic_services() const;
-  private:
-  bool _internal_has_java_generic_services() const;
-  public:
-  void clear_java_generic_services();
-  bool java_generic_services() const;
-  void set_java_generic_services(bool value);
-  private:
-  bool _internal_java_generic_services() const;
-  void _internal_set_java_generic_services(bool value);
-  public:
-
-  // optional bool py_generic_services = 18 [default = false];
-  bool has_py_generic_services() const;
-  private:
-  bool _internal_has_py_generic_services() const;
-  public:
-  void clear_py_generic_services();
-  bool py_generic_services() const;
-  void set_py_generic_services(bool value);
-  private:
-  bool _internal_py_generic_services() const;
-  void _internal_set_py_generic_services(bool value);
-  public:
-
-  // optional bool php_generic_services = 42 [default = false];
-  bool has_php_generic_services() const;
-  private:
-  bool _internal_has_php_generic_services() const;
-  public:
-  void clear_php_generic_services();
-  bool php_generic_services() const;
-  void set_php_generic_services(bool value);
-  private:
-  bool _internal_php_generic_services() const;
-  void _internal_set_php_generic_services(bool value);
-  public:
-
-  // optional bool deprecated = 23 [default = false];
-  bool has_deprecated() const;
-  private:
-  bool _internal_has_deprecated() const;
-  public:
-  void clear_deprecated();
-  bool deprecated() const;
-  void set_deprecated(bool value);
-  private:
-  bool _internal_deprecated() const;
-  void _internal_set_deprecated(bool value);
-  public:
-
-  // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
-  bool has_optimize_for() const;
-  private:
-  bool _internal_has_optimize_for() const;
-  public:
-  void clear_optimize_for();
-  ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode optimize_for() const;
-  void set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode _internal_optimize_for() const;
-  void _internal_set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value);
-  public:
-
-  // optional bool cc_enable_arenas = 31 [default = true];
-  bool has_cc_enable_arenas() const;
-  private:
-  bool _internal_has_cc_enable_arenas() const;
-  public:
-  void clear_cc_enable_arenas();
-  bool cc_enable_arenas() const;
-  void set_cc_enable_arenas(bool value);
-  private:
-  bool _internal_cc_enable_arenas() const;
-  void _internal_set_cc_enable_arenas(bool value);
-  public:
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FileOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.FileOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr java_package_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr java_outer_classname_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr go_package_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr objc_class_prefix_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr csharp_namespace_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr swift_prefix_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_class_prefix_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_namespace_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr php_metadata_namespace_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ruby_package_;
-    bool java_multiple_files_;
-    bool java_generate_equals_and_hash_;
-    bool java_string_check_utf8_;
-    bool cc_generic_services_;
-    bool java_generic_services_;
-    bool py_generic_services_;
-    bool php_generic_services_;
-    bool deprecated_;
-    int optimize_for_;
-    bool cc_enable_arenas_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    GeneratedCodeInfo_Annotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<GeneratedCodeInfo_Annotation>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const GeneratedCodeInfo_Annotation& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const GeneratedCodeInfo_Annotation& from)
+    {
+        GeneratedCodeInfo_Annotation::MergeImpl(*this, from);
+    }
 
-class PROTOBUF_EXPORT MessageOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MessageOptions) */ {
- public:
-  inline MessageOptions() : MessageOptions(nullptr) {}
-  ~MessageOptions() override;
-  explicit PROTOBUF_CONSTEXPR MessageOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  MessageOptions(const MessageOptions& from);
-  MessageOptions(MessageOptions&& from) noexcept
-    : MessageOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline MessageOptions& operator=(const MessageOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline MessageOptions& operator=(MessageOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const MessageOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const MessageOptions* internal_default_instance() {
-    return reinterpret_cast<const MessageOptions*>(
-               &_MessageOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    14;
-
-  friend void swap(MessageOptions& a, MessageOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(MessageOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(MessageOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  MessageOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<MessageOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const MessageOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const MessageOptions& from) {
-    MessageOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(MessageOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.MessageOptions";
-  }
-  protected:
-  explicit MessageOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-    kMessageSetWireFormatFieldNumber = 1,
-    kNoStandardDescriptorAccessorFieldNumber = 2,
-    kDeprecatedFieldNumber = 3,
-    kMapEntryFieldNumber = 7,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-  // optional bool message_set_wire_format = 1 [default = false];
-  bool has_message_set_wire_format() const;
-  private:
-  bool _internal_has_message_set_wire_format() const;
-  public:
-  void clear_message_set_wire_format();
-  bool message_set_wire_format() const;
-  void set_message_set_wire_format(bool value);
-  private:
-  bool _internal_message_set_wire_format() const;
-  void _internal_set_message_set_wire_format(bool value);
-  public:
-
-  // optional bool no_standard_descriptor_accessor = 2 [default = false];
-  bool has_no_standard_descriptor_accessor() const;
-  private:
-  bool _internal_has_no_standard_descriptor_accessor() const;
-  public:
-  void clear_no_standard_descriptor_accessor();
-  bool no_standard_descriptor_accessor() const;
-  void set_no_standard_descriptor_accessor(bool value);
-  private:
-  bool _internal_no_standard_descriptor_accessor() const;
-  void _internal_set_no_standard_descriptor_accessor(bool value);
-  public:
-
-  // optional bool deprecated = 3 [default = false];
-  bool has_deprecated() const;
-  private:
-  bool _internal_has_deprecated() const;
-  public:
-  void clear_deprecated();
-  bool deprecated() const;
-  void set_deprecated(bool value);
-  private:
-  bool _internal_deprecated() const;
-  void _internal_set_deprecated(bool value);
-  public:
-
-  // optional bool map_entry = 7;
-  bool has_map_entry() const;
-  private:
-  bool _internal_has_map_entry() const;
-  public:
-  void clear_map_entry();
-  bool map_entry() const;
-  void set_map_entry(bool value);
-  private:
-  bool _internal_map_entry() const;
-  void _internal_set_map_entry(bool value);
-  public:
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MessageOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    bool message_set_wire_format_;
-    bool no_standard_descriptor_accessor_;
-    bool deprecated_;
-    bool map_entry_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
 
-class PROTOBUF_EXPORT FieldOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldOptions) */ {
- public:
-  inline FieldOptions() : FieldOptions(nullptr) {}
-  ~FieldOptions() override;
-  explicit PROTOBUF_CONSTEXPR FieldOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  FieldOptions(const FieldOptions& from);
-  FieldOptions(FieldOptions&& from) noexcept
-    : FieldOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline FieldOptions& operator=(const FieldOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FieldOptions& operator=(FieldOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const FieldOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const FieldOptions* internal_default_instance() {
-    return reinterpret_cast<const FieldOptions*>(
-               &_FieldOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    15;
-
-  friend void swap(FieldOptions& a, FieldOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FieldOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(FieldOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  FieldOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<FieldOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const FieldOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const FieldOptions& from) {
-    FieldOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(FieldOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.FieldOptions";
-  }
-  protected:
-  explicit FieldOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef FieldOptions_CType CType;
-  static constexpr CType STRING =
-    FieldOptions_CType_STRING;
-  static constexpr CType CORD =
-    FieldOptions_CType_CORD;
-  static constexpr CType STRING_PIECE =
-    FieldOptions_CType_STRING_PIECE;
-  static inline bool CType_IsValid(int value) {
-    return FieldOptions_CType_IsValid(value);
-  }
-  static constexpr CType CType_MIN =
-    FieldOptions_CType_CType_MIN;
-  static constexpr CType CType_MAX =
-    FieldOptions_CType_CType_MAX;
-  static constexpr int CType_ARRAYSIZE =
-    FieldOptions_CType_CType_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  CType_descriptor() {
-    return FieldOptions_CType_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& CType_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, CType>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function CType_Name.");
-    return FieldOptions_CType_Name(enum_t_value);
-  }
-  static inline bool CType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      CType* value) {
-    return FieldOptions_CType_Parse(name, value);
-  }
-
-  typedef FieldOptions_JSType JSType;
-  static constexpr JSType JS_NORMAL =
-    FieldOptions_JSType_JS_NORMAL;
-  static constexpr JSType JS_STRING =
-    FieldOptions_JSType_JS_STRING;
-  static constexpr JSType JS_NUMBER =
-    FieldOptions_JSType_JS_NUMBER;
-  static inline bool JSType_IsValid(int value) {
-    return FieldOptions_JSType_IsValid(value);
-  }
-  static constexpr JSType JSType_MIN =
-    FieldOptions_JSType_JSType_MIN;
-  static constexpr JSType JSType_MAX =
-    FieldOptions_JSType_JSType_MAX;
-  static constexpr int JSType_ARRAYSIZE =
-    FieldOptions_JSType_JSType_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  JSType_descriptor() {
-    return FieldOptions_JSType_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& JSType_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, JSType>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function JSType_Name.");
-    return FieldOptions_JSType_Name(enum_t_value);
-  }
-  static inline bool JSType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      JSType* value) {
-    return FieldOptions_JSType_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-    kCtypeFieldNumber = 1,
-    kJstypeFieldNumber = 6,
-    kPackedFieldNumber = 2,
-    kLazyFieldNumber = 5,
-    kUnverifiedLazyFieldNumber = 15,
-    kDeprecatedFieldNumber = 3,
-    kWeakFieldNumber = 10,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-  // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
-  bool has_ctype() const;
-  private:
-  bool _internal_has_ctype() const;
-  public:
-  void clear_ctype();
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType ctype() const;
-  void set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType _internal_ctype() const;
-  void _internal_set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value);
-  public:
-
-  // optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
-  bool has_jstype() const;
-  private:
-  bool _internal_has_jstype() const;
-  public:
-  void clear_jstype();
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType jstype() const;
-  void set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType _internal_jstype() const;
-  void _internal_set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value);
-  public:
-
-  // optional bool packed = 2;
-  bool has_packed() const;
-  private:
-  bool _internal_has_packed() const;
-  public:
-  void clear_packed();
-  bool packed() const;
-  void set_packed(bool value);
-  private:
-  bool _internal_packed() const;
-  void _internal_set_packed(bool value);
-  public:
-
-  // optional bool lazy = 5 [default = false];
-  bool has_lazy() const;
-  private:
-  bool _internal_has_lazy() const;
-  public:
-  void clear_lazy();
-  bool lazy() const;
-  void set_lazy(bool value);
-  private:
-  bool _internal_lazy() const;
-  void _internal_set_lazy(bool value);
-  public:
-
-  // optional bool unverified_lazy = 15 [default = false];
-  bool has_unverified_lazy() const;
-  private:
-  bool _internal_has_unverified_lazy() const;
-  public:
-  void clear_unverified_lazy();
-  bool unverified_lazy() const;
-  void set_unverified_lazy(bool value);
-  private:
-  bool _internal_unverified_lazy() const;
-  void _internal_set_unverified_lazy(bool value);
-  public:
-
-  // optional bool deprecated = 3 [default = false];
-  bool has_deprecated() const;
-  private:
-  bool _internal_has_deprecated() const;
-  public:
-  void clear_deprecated();
-  bool deprecated() const;
-  void set_deprecated(bool value);
-  private:
-  bool _internal_deprecated() const;
-  void _internal_set_deprecated(bool value);
-  public:
-
-  // optional bool weak = 10 [default = false];
-  bool has_weak() const;
-  private:
-  bool _internal_has_weak() const;
-  public:
-  void clear_weak();
-  bool weak() const;
-  void set_weak(bool value);
-  private:
-  bool _internal_weak() const;
-  void _internal_set_weak(bool value);
-  public:
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          FieldOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    int ctype_;
-    int jstype_;
-    bool packed_;
-    bool lazy_;
-    bool unverified_lazy_;
-    bool deprecated_;
-    bool weak_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(GeneratedCodeInfo_Annotation* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.GeneratedCodeInfo.Annotation";
+    }
 
-class PROTOBUF_EXPORT OneofOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofOptions) */ {
- public:
-  inline OneofOptions() : OneofOptions(nullptr) {}
-  ~OneofOptions() override;
-  explicit PROTOBUF_CONSTEXPR OneofOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  OneofOptions(const OneofOptions& from);
-  OneofOptions(OneofOptions&& from) noexcept
-    : OneofOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline OneofOptions& operator=(const OneofOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline OneofOptions& operator=(OneofOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const OneofOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const OneofOptions* internal_default_instance() {
-    return reinterpret_cast<const OneofOptions*>(
-               &_OneofOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    16;
-
-  friend void swap(OneofOptions& a, OneofOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(OneofOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(OneofOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  OneofOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<OneofOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const OneofOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const OneofOptions& from) {
-    OneofOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(OneofOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.OneofOptions";
-  }
-  protected:
-  explicit OneofOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          OneofOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.OneofOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+protected:
+    explicit GeneratedCodeInfo_Annotation(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kPathFieldNumber = 1,
+        kSourceFileFieldNumber = 2,
+        kBeginFieldNumber = 3,
+        kEndFieldNumber = 4,
+    };
+    // repeated int32 path = 1 [packed = true];
+    int path_size() const;
+
+private:
+    int _internal_path_size() const;
+
+public:
+    void clear_path();
+
+private:
+    int32_t _internal_path(int index) const;
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        _internal_path() const;
+    void _internal_add_path(int32_t value);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        _internal_mutable_path();
+
+public:
+    int32_t path(int index) const;
+    void set_path(int index, int32_t value);
+    void add_path(int32_t value);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+        path() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+        mutable_path();
+
+    // optional string source_file = 2;
+    bool has_source_file() const;
+
+private:
+    bool _internal_has_source_file() const;
+
+public:
+    void clear_source_file();
+    const std::string& source_file() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_source_file(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_source_file();
+    PROTOBUF_NODISCARD std::string* release_source_file();
+    void set_allocated_source_file(std::string* source_file);
+
+private:
+    const std::string& _internal_source_file() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_source_file(const std::string& value);
+    std::string* _internal_mutable_source_file();
+
+public:
+    // optional int32 begin = 3;
+    bool has_begin() const;
+
+private:
+    bool _internal_has_begin() const;
+
+public:
+    void clear_begin();
+    int32_t begin() const;
+    void set_begin(int32_t value);
+
+private:
+    int32_t _internal_begin() const;
+    void _internal_set_begin(int32_t value);
+
+public:
+    // optional int32 end = 4;
+    bool has_end() const;
+
+private:
+    bool _internal_has_end() const;
+
+public:
+    void clear_end();
+    int32_t end() const;
+    void set_end(int32_t value);
+
+private:
+    int32_t _internal_end() const;
+    void _internal_set_end(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo.Annotation)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t> path_;
+        mutable std::atomic<int> _path_cached_byte_size_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_file_;
+        int32_t begin_;
+        int32_t end_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // -------------------------------------------------------------------
 
-class PROTOBUF_EXPORT EnumOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumOptions) */ {
- public:
-  inline EnumOptions() : EnumOptions(nullptr) {}
-  ~EnumOptions() override;
-  explicit PROTOBUF_CONSTEXPR EnumOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  EnumOptions(const EnumOptions& from);
-  EnumOptions(EnumOptions&& from) noexcept
-    : EnumOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline EnumOptions& operator=(const EnumOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline EnumOptions& operator=(EnumOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const EnumOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const EnumOptions* internal_default_instance() {
-    return reinterpret_cast<const EnumOptions*>(
-               &_EnumOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    17;
-
-  friend void swap(EnumOptions& a, EnumOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(EnumOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(EnumOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  EnumOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<EnumOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const EnumOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const EnumOptions& from) {
-    EnumOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(EnumOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.EnumOptions";
-  }
-  protected:
-  explicit EnumOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-    kAllowAliasFieldNumber = 2,
-    kDeprecatedFieldNumber = 3,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-  // optional bool allow_alias = 2;
-  bool has_allow_alias() const;
-  private:
-  bool _internal_has_allow_alias() const;
-  public:
-  void clear_allow_alias();
-  bool allow_alias() const;
-  void set_allow_alias(bool value);
-  private:
-  bool _internal_allow_alias() const;
-  void _internal_set_allow_alias(bool value);
-  public:
-
-  // optional bool deprecated = 3 [default = false];
-  bool has_deprecated() const;
-  private:
-  bool _internal_has_deprecated() const;
-  public:
-  void clear_deprecated();
-  bool deprecated() const;
-  void set_deprecated(bool value);
-  private:
-  bool _internal_deprecated() const;
-  void _internal_set_deprecated(bool value);
-  public:
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    bool allow_alias_;
-    bool deprecated_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+class PROTOBUF_EXPORT GeneratedCodeInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo) */
+{
+public:
+    inline GeneratedCodeInfo() :
+        GeneratedCodeInfo(nullptr)
+    {
+    }
+    ~GeneratedCodeInfo() override;
+    explicit PROTOBUF_CONSTEXPR GeneratedCodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    GeneratedCodeInfo(const GeneratedCodeInfo& from);
+    GeneratedCodeInfo(GeneratedCodeInfo&& from) noexcept
+        :
+        GeneratedCodeInfo()
+    {
+        *this = ::std::move(from);
+    }
 
-class PROTOBUF_EXPORT EnumValueOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueOptions) */ {
- public:
-  inline EnumValueOptions() : EnumValueOptions(nullptr) {}
-  ~EnumValueOptions() override;
-  explicit PROTOBUF_CONSTEXPR EnumValueOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  EnumValueOptions(const EnumValueOptions& from);
-  EnumValueOptions(EnumValueOptions&& from) noexcept
-    : EnumValueOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline EnumValueOptions& operator=(const EnumValueOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline EnumValueOptions& operator=(EnumValueOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const EnumValueOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const EnumValueOptions* internal_default_instance() {
-    return reinterpret_cast<const EnumValueOptions*>(
-               &_EnumValueOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    18;
-
-  friend void swap(EnumValueOptions& a, EnumValueOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(EnumValueOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(EnumValueOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  EnumValueOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<EnumValueOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const EnumValueOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const EnumValueOptions& from) {
-    EnumValueOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(EnumValueOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.EnumValueOptions";
-  }
-  protected:
-  explicit EnumValueOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-    kDeprecatedFieldNumber = 1,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-  // optional bool deprecated = 1 [default = false];
-  bool has_deprecated() const;
-  private:
-  bool _internal_has_deprecated() const;
-  public:
-  void clear_deprecated();
-  bool deprecated() const;
-  void set_deprecated(bool value);
-  private:
-  bool _internal_deprecated() const;
-  void _internal_set_deprecated(bool value);
-  public:
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          EnumValueOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    bool deprecated_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    inline GeneratedCodeInfo& operator=(const GeneratedCodeInfo& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline GeneratedCodeInfo& operator=(GeneratedCodeInfo&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
 
-class PROTOBUF_EXPORT ServiceOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */ {
- public:
-  inline ServiceOptions() : ServiceOptions(nullptr) {}
-  ~ServiceOptions() override;
-  explicit PROTOBUF_CONSTEXPR ServiceOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  ServiceOptions(const ServiceOptions& from);
-  ServiceOptions(ServiceOptions&& from) noexcept
-    : ServiceOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline ServiceOptions& operator=(const ServiceOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ServiceOptions& operator=(ServiceOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const ServiceOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const ServiceOptions* internal_default_instance() {
-    return reinterpret_cast<const ServiceOptions*>(
-               &_ServiceOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    19;
-
-  friend void swap(ServiceOptions& a, ServiceOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ServiceOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ServiceOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  ServiceOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<ServiceOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const ServiceOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const ServiceOptions& from) {
-    ServiceOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(ServiceOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.ServiceOptions";
-  }
-  protected:
-  explicit ServiceOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-    kDeprecatedFieldNumber = 33,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-  // optional bool deprecated = 33 [default = false];
-  bool has_deprecated() const;
-  private:
-  bool _internal_has_deprecated() const;
-  public:
-  void clear_deprecated();
-  bool deprecated() const;
-  void set_deprecated(bool value);
-  private:
-  bool _internal_deprecated() const;
-  void _internal_set_deprecated(bool value);
-  public:
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          ServiceOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    bool deprecated_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const
+    {
+        return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+    }
+    inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields()
+    {
+        return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+    }
 
-class PROTOBUF_EXPORT MethodOptions final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodOptions) */ {
- public:
-  inline MethodOptions() : MethodOptions(nullptr) {}
-  ~MethodOptions() override;
-  explicit PROTOBUF_CONSTEXPR MethodOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  MethodOptions(const MethodOptions& from);
-  MethodOptions(MethodOptions&& from) noexcept
-    : MethodOptions() {
-    *this = ::std::move(from);
-  }
-
-  inline MethodOptions& operator=(const MethodOptions& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline MethodOptions& operator=(MethodOptions&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const MethodOptions& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const MethodOptions* internal_default_instance() {
-    return reinterpret_cast<const MethodOptions*>(
-               &_MethodOptions_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    20;
-
-  friend void swap(MethodOptions& a, MethodOptions& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(MethodOptions* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(MethodOptions* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  MethodOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<MethodOptions>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const MethodOptions& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const MethodOptions& from) {
-    MethodOptions::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(MethodOptions* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.MethodOptions";
-  }
-  protected:
-  explicit MethodOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef MethodOptions_IdempotencyLevel IdempotencyLevel;
-  static constexpr IdempotencyLevel IDEMPOTENCY_UNKNOWN =
-    MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
-  static constexpr IdempotencyLevel NO_SIDE_EFFECTS =
-    MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS;
-  static constexpr IdempotencyLevel IDEMPOTENT =
-    MethodOptions_IdempotencyLevel_IDEMPOTENT;
-  static inline bool IdempotencyLevel_IsValid(int value) {
-    return MethodOptions_IdempotencyLevel_IsValid(value);
-  }
-  static constexpr IdempotencyLevel IdempotencyLevel_MIN =
-    MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN;
-  static constexpr IdempotencyLevel IdempotencyLevel_MAX =
-    MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX;
-  static constexpr int IdempotencyLevel_ARRAYSIZE =
-    MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  IdempotencyLevel_descriptor() {
-    return MethodOptions_IdempotencyLevel_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& IdempotencyLevel_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, IdempotencyLevel>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function IdempotencyLevel_Name.");
-    return MethodOptions_IdempotencyLevel_Name(enum_t_value);
-  }
-  static inline bool IdempotencyLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      IdempotencyLevel* value) {
-    return MethodOptions_IdempotencyLevel_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kUninterpretedOptionFieldNumber = 999,
-    kDeprecatedFieldNumber = 33,
-    kIdempotencyLevelFieldNumber = 34,
-  };
-  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-  int uninterpreted_option_size() const;
-  private:
-  int _internal_uninterpreted_option_size() const;
-  public:
-  void clear_uninterpreted_option();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* mutable_uninterpreted_option(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-      mutable_uninterpreted_option();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& _internal_uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _internal_add_uninterpreted_option();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& uninterpreted_option(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* add_uninterpreted_option();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-      uninterpreted_option() const;
-
-  // optional bool deprecated = 33 [default = false];
-  bool has_deprecated() const;
-  private:
-  bool _internal_has_deprecated() const;
-  public:
-  void clear_deprecated();
-  bool deprecated() const;
-  void set_deprecated(bool value);
-  private:
-  bool _internal_deprecated() const;
-  void _internal_set_deprecated(bool value);
-  public:
-
-  // optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
-  bool has_idempotency_level() const;
-  private:
-  bool _internal_has_idempotency_level() const;
-  public:
-  void clear_idempotency_level();
-  ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel idempotency_level() const;
-  void set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel _internal_idempotency_level() const;
-  void _internal_set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value);
-  public:
-
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline bool HasExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.Has(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void ClearExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    _impl_._extensions_.ClearExtension(id.number());
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline int ExtensionSize(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _impl_._extensions_.ExtensionSize(id.number());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_,
-                                  id.default_value());
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Mutable(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), _field_type, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::SetAllocated(id.number(), _field_type, value,
-                                    &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void UnsafeArenaSetAllocatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Singular::MutableType value) {
-    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,
-                                               value, &_impl_._extensions_);
-
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  PROTOBUF_NODISCARD inline
-      typename _proto_TypeTraits::Singular::MutableType
-      ReleaseExtension(
-          const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-              MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::Release(id.number(), _field_type,
-                                      &_impl_._extensions_);
-  }
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Singular::MutableType
-  UnsafeArenaReleaseExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,
-                                                 &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) const {
-
-    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index) {
-
-    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void SetExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-    typename _proto_TypeTraits::Repeated::MutableType to_add =
-        _proto_TypeTraits::Add(id.number(), _field_type, &_impl_._extensions_);
-
-    return to_add;
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline void AddExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id,
-      typename _proto_TypeTraits::Repeated::ConstType value) {
-    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed, value,
-                           &_impl_._extensions_);
-
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&
-  GetRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) const {
-
-    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
-  }
-
-  template <typename _proto_TypeTraits,
-            ::PROTOBUF_NAMESPACE_ID::internal::FieldType _field_type,
-            bool _is_packed>
-  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*
-  MutableRepeatedExtension(
-      const ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier<
-          MethodOptions, _proto_TypeTraits, _field_type, _is_packed>& id) {
-
-    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,
-                                              _is_packed, &_impl_._extensions_);
-  }
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ExtensionSet _extensions_;
-
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption > uninterpreted_option_;
-    bool deprecated_;
-    int idempotency_level_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const GeneratedCodeInfo& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const GeneratedCodeInfo* internal_default_instance()
+    {
+        return reinterpret_cast<const GeneratedCodeInfo*>(
+            &_GeneratedCodeInfo_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        26;
 
-class PROTOBUF_EXPORT UninterpretedOption_NamePart final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */ {
- public:
-  inline UninterpretedOption_NamePart() : UninterpretedOption_NamePart(nullptr) {}
-  ~UninterpretedOption_NamePart() override;
-  explicit PROTOBUF_CONSTEXPR UninterpretedOption_NamePart(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from);
-  UninterpretedOption_NamePart(UninterpretedOption_NamePart&& from) noexcept
-    : UninterpretedOption_NamePart() {
-    *this = ::std::move(from);
-  }
-
-  inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline UninterpretedOption_NamePart& operator=(UninterpretedOption_NamePart&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const UninterpretedOption_NamePart& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const UninterpretedOption_NamePart* internal_default_instance() {
-    return reinterpret_cast<const UninterpretedOption_NamePart*>(
-               &_UninterpretedOption_NamePart_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    21;
-
-  friend void swap(UninterpretedOption_NamePart& a, UninterpretedOption_NamePart& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(UninterpretedOption_NamePart* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(UninterpretedOption_NamePart* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  UninterpretedOption_NamePart* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<UninterpretedOption_NamePart>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const UninterpretedOption_NamePart& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const UninterpretedOption_NamePart& from) {
-    UninterpretedOption_NamePart::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(UninterpretedOption_NamePart* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.UninterpretedOption.NamePart";
-  }
-  protected:
-  explicit UninterpretedOption_NamePart(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNamePartFieldNumber = 1,
-    kIsExtensionFieldNumber = 2,
-  };
-  // required string name_part = 1;
-  bool has_name_part() const;
-  private:
-  bool _internal_has_name_part() const;
-  public:
-  void clear_name_part();
-  const std::string& name_part() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name_part(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name_part();
-  PROTOBUF_NODISCARD std::string* release_name_part();
-  void set_allocated_name_part(std::string* name_part);
-  private:
-  const std::string& _internal_name_part() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name_part(const std::string& value);
-  std::string* _internal_mutable_name_part();
-  public:
-
-  // required bool is_extension = 2;
-  bool has_is_extension() const;
-  private:
-  bool _internal_has_is_extension() const;
-  public:
-  void clear_is_extension();
-  bool is_extension() const;
-  void set_is_extension(bool value);
-  private:
-  bool _internal_is_extension() const;
-  void _internal_set_is_extension(bool value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart)
- private:
-  class _Internal;
-
-  // helper for ByteSizeLong()
-  size_t RequiredFieldsByteSizeFallback() const;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_part_;
-    bool is_extension_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    friend void swap(GeneratedCodeInfo& a, GeneratedCodeInfo& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(GeneratedCodeInfo* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(GeneratedCodeInfo* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
 
-class PROTOBUF_EXPORT UninterpretedOption final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption) */ {
- public:
-  inline UninterpretedOption() : UninterpretedOption(nullptr) {}
-  ~UninterpretedOption() override;
-  explicit PROTOBUF_CONSTEXPR UninterpretedOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  UninterpretedOption(const UninterpretedOption& from);
-  UninterpretedOption(UninterpretedOption&& from) noexcept
-    : UninterpretedOption() {
-    *this = ::std::move(from);
-  }
-
-  inline UninterpretedOption& operator=(const UninterpretedOption& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline UninterpretedOption& operator=(UninterpretedOption&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const UninterpretedOption& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const UninterpretedOption* internal_default_instance() {
-    return reinterpret_cast<const UninterpretedOption*>(
-               &_UninterpretedOption_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    22;
-
-  friend void swap(UninterpretedOption& a, UninterpretedOption& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(UninterpretedOption* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(UninterpretedOption* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  UninterpretedOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<UninterpretedOption>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const UninterpretedOption& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const UninterpretedOption& from) {
-    UninterpretedOption::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(UninterpretedOption* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.UninterpretedOption";
-  }
-  protected:
-  explicit UninterpretedOption(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef UninterpretedOption_NamePart NamePart;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 2,
-    kIdentifierValueFieldNumber = 3,
-    kStringValueFieldNumber = 7,
-    kAggregateValueFieldNumber = 8,
-    kPositiveIntValueFieldNumber = 4,
-    kNegativeIntValueFieldNumber = 5,
-    kDoubleValueFieldNumber = 6,
-  };
-  // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
-  int name_size() const;
-  private:
-  int _internal_name_size() const;
-  public:
-  void clear_name();
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* mutable_name(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >*
-      mutable_name();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& _internal_name(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* _internal_add_name();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& name(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* add_name();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >&
-      name() const;
-
-  // optional string identifier_value = 3;
-  bool has_identifier_value() const;
-  private:
-  bool _internal_has_identifier_value() const;
-  public:
-  void clear_identifier_value();
-  const std::string& identifier_value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_identifier_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_identifier_value();
-  PROTOBUF_NODISCARD std::string* release_identifier_value();
-  void set_allocated_identifier_value(std::string* identifier_value);
-  private:
-  const std::string& _internal_identifier_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_identifier_value(const std::string& value);
-  std::string* _internal_mutable_identifier_value();
-  public:
-
-  // optional bytes string_value = 7;
-  bool has_string_value() const;
-  private:
-  bool _internal_has_string_value() const;
-  public:
-  void clear_string_value();
-  const std::string& string_value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_string_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_string_value();
-  PROTOBUF_NODISCARD std::string* release_string_value();
-  void set_allocated_string_value(std::string* string_value);
-  private:
-  const std::string& _internal_string_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
-  std::string* _internal_mutable_string_value();
-  public:
-
-  // optional string aggregate_value = 8;
-  bool has_aggregate_value() const;
-  private:
-  bool _internal_has_aggregate_value() const;
-  public:
-  void clear_aggregate_value();
-  const std::string& aggregate_value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_aggregate_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_aggregate_value();
-  PROTOBUF_NODISCARD std::string* release_aggregate_value();
-  void set_allocated_aggregate_value(std::string* aggregate_value);
-  private:
-  const std::string& _internal_aggregate_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregate_value(const std::string& value);
-  std::string* _internal_mutable_aggregate_value();
-  public:
-
-  // optional uint64 positive_int_value = 4;
-  bool has_positive_int_value() const;
-  private:
-  bool _internal_has_positive_int_value() const;
-  public:
-  void clear_positive_int_value();
-  uint64_t positive_int_value() const;
-  void set_positive_int_value(uint64_t value);
-  private:
-  uint64_t _internal_positive_int_value() const;
-  void _internal_set_positive_int_value(uint64_t value);
-  public:
-
-  // optional int64 negative_int_value = 5;
-  bool has_negative_int_value() const;
-  private:
-  bool _internal_has_negative_int_value() const;
-  public:
-  void clear_negative_int_value();
-  int64_t negative_int_value() const;
-  void set_negative_int_value(int64_t value);
-  private:
-  int64_t _internal_negative_int_value() const;
-  void _internal_set_negative_int_value(int64_t value);
-  public:
-
-  // optional double double_value = 6;
-  bool has_double_value() const;
-  private:
-  bool _internal_has_double_value() const;
-  public:
-  void clear_double_value();
-  double double_value() const;
-  void set_double_value(double value);
-  private:
-  double _internal_double_value() const;
-  void _internal_set_double_value(double value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart > name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identifier_value_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregate_value_;
-    uint64_t positive_int_value_;
-    int64_t negative_int_value_;
-    double double_value_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    // implements Message ----------------------------------------------
 
-class PROTOBUF_EXPORT SourceCodeInfo_Location final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */ {
- public:
-  inline SourceCodeInfo_Location() : SourceCodeInfo_Location(nullptr) {}
-  ~SourceCodeInfo_Location() override;
-  explicit PROTOBUF_CONSTEXPR SourceCodeInfo_Location(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  SourceCodeInfo_Location(const SourceCodeInfo_Location& from);
-  SourceCodeInfo_Location(SourceCodeInfo_Location&& from) noexcept
-    : SourceCodeInfo_Location() {
-    *this = ::std::move(from);
-  }
-
-  inline SourceCodeInfo_Location& operator=(const SourceCodeInfo_Location& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline SourceCodeInfo_Location& operator=(SourceCodeInfo_Location&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const SourceCodeInfo_Location& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const SourceCodeInfo_Location* internal_default_instance() {
-    return reinterpret_cast<const SourceCodeInfo_Location*>(
-               &_SourceCodeInfo_Location_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    23;
-
-  friend void swap(SourceCodeInfo_Location& a, SourceCodeInfo_Location& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(SourceCodeInfo_Location* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(SourceCodeInfo_Location* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  SourceCodeInfo_Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<SourceCodeInfo_Location>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const SourceCodeInfo_Location& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const SourceCodeInfo_Location& from) {
-    SourceCodeInfo_Location::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(SourceCodeInfo_Location* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.SourceCodeInfo.Location";
-  }
-  protected:
-  explicit SourceCodeInfo_Location(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kPathFieldNumber = 1,
-    kSpanFieldNumber = 2,
-    kLeadingDetachedCommentsFieldNumber = 6,
-    kLeadingCommentsFieldNumber = 3,
-    kTrailingCommentsFieldNumber = 4,
-  };
-  // repeated int32 path = 1 [packed = true];
-  int path_size() const;
-  private:
-  int _internal_path_size() const;
-  public:
-  void clear_path();
-  private:
-  int32_t _internal_path(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      _internal_path() const;
-  void _internal_add_path(int32_t value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      _internal_mutable_path();
-  public:
-  int32_t path(int index) const;
-  void set_path(int index, int32_t value);
-  void add_path(int32_t value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      path() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      mutable_path();
-
-  // repeated int32 span = 2 [packed = true];
-  int span_size() const;
-  private:
-  int _internal_span_size() const;
-  public:
-  void clear_span();
-  private:
-  int32_t _internal_span(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      _internal_span() const;
-  void _internal_add_span(int32_t value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      _internal_mutable_span();
-  public:
-  int32_t span(int index) const;
-  void set_span(int index, int32_t value);
-  void add_span(int32_t value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      span() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      mutable_span();
-
-  // repeated string leading_detached_comments = 6;
-  int leading_detached_comments_size() const;
-  private:
-  int _internal_leading_detached_comments_size() const;
-  public:
-  void clear_leading_detached_comments();
-  const std::string& leading_detached_comments(int index) const;
-  std::string* mutable_leading_detached_comments(int index);
-  void set_leading_detached_comments(int index, const std::string& value);
-  void set_leading_detached_comments(int index, std::string&& value);
-  void set_leading_detached_comments(int index, const char* value);
-  void set_leading_detached_comments(int index, const char* value, size_t size);
-  std::string* add_leading_detached_comments();
-  void add_leading_detached_comments(const std::string& value);
-  void add_leading_detached_comments(std::string&& value);
-  void add_leading_detached_comments(const char* value);
-  void add_leading_detached_comments(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& leading_detached_comments() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_leading_detached_comments();
-  private:
-  const std::string& _internal_leading_detached_comments(int index) const;
-  std::string* _internal_add_leading_detached_comments();
-  public:
-
-  // optional string leading_comments = 3;
-  bool has_leading_comments() const;
-  private:
-  bool _internal_has_leading_comments() const;
-  public:
-  void clear_leading_comments();
-  const std::string& leading_comments() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_leading_comments(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_leading_comments();
-  PROTOBUF_NODISCARD std::string* release_leading_comments();
-  void set_allocated_leading_comments(std::string* leading_comments);
-  private:
-  const std::string& _internal_leading_comments() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_leading_comments(const std::string& value);
-  std::string* _internal_mutable_leading_comments();
-  public:
-
-  // optional string trailing_comments = 4;
-  bool has_trailing_comments() const;
-  private:
-  bool _internal_has_trailing_comments() const;
-  public:
-  void clear_trailing_comments();
-  const std::string& trailing_comments() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_trailing_comments(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_trailing_comments();
-  PROTOBUF_NODISCARD std::string* release_trailing_comments();
-  void set_allocated_trailing_comments(std::string* trailing_comments);
-  private:
-  const std::string& _internal_trailing_comments() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_trailing_comments(const std::string& value);
-  std::string* _internal_mutable_trailing_comments();
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo.Location)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > path_;
-    mutable std::atomic<int> _path_cached_byte_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > span_;
-    mutable std::atomic<int> _span_cached_byte_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> leading_detached_comments_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr leading_comments_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr trailing_comments_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+    GeneratedCodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<GeneratedCodeInfo>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const GeneratedCodeInfo& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const GeneratedCodeInfo& from)
+    {
+        GeneratedCodeInfo::MergeImpl(*this, from);
+    }
 
-class PROTOBUF_EXPORT SourceCodeInfo final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo) */ {
- public:
-  inline SourceCodeInfo() : SourceCodeInfo(nullptr) {}
-  ~SourceCodeInfo() override;
-  explicit PROTOBUF_CONSTEXPR SourceCodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  SourceCodeInfo(const SourceCodeInfo& from);
-  SourceCodeInfo(SourceCodeInfo&& from) noexcept
-    : SourceCodeInfo() {
-    *this = ::std::move(from);
-  }
-
-  inline SourceCodeInfo& operator=(const SourceCodeInfo& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline SourceCodeInfo& operator=(SourceCodeInfo&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const SourceCodeInfo& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const SourceCodeInfo* internal_default_instance() {
-    return reinterpret_cast<const SourceCodeInfo*>(
-               &_SourceCodeInfo_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    24;
-
-  friend void swap(SourceCodeInfo& a, SourceCodeInfo& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(SourceCodeInfo* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(SourceCodeInfo* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  SourceCodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<SourceCodeInfo>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const SourceCodeInfo& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const SourceCodeInfo& from) {
-    SourceCodeInfo::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(SourceCodeInfo* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.SourceCodeInfo";
-  }
-  protected:
-  explicit SourceCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef SourceCodeInfo_Location Location;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kLocationFieldNumber = 1,
-  };
-  // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
-  int location_size() const;
-  private:
-  int _internal_location_size() const;
-  public:
-  void clear_location();
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* mutable_location(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >*
-      mutable_location();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& _internal_location(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* _internal_add_location();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& location(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* add_location();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >&
-      location() const;
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location > location_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
 
-class PROTOBUF_EXPORT GeneratedCodeInfo_Annotation final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo.Annotation) */ {
- public:
-  inline GeneratedCodeInfo_Annotation() : GeneratedCodeInfo_Annotation(nullptr) {}
-  ~GeneratedCodeInfo_Annotation() override;
-  explicit PROTOBUF_CONSTEXPR GeneratedCodeInfo_Annotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  GeneratedCodeInfo_Annotation(const GeneratedCodeInfo_Annotation& from);
-  GeneratedCodeInfo_Annotation(GeneratedCodeInfo_Annotation&& from) noexcept
-    : GeneratedCodeInfo_Annotation() {
-    *this = ::std::move(from);
-  }
-
-  inline GeneratedCodeInfo_Annotation& operator=(const GeneratedCodeInfo_Annotation& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline GeneratedCodeInfo_Annotation& operator=(GeneratedCodeInfo_Annotation&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const GeneratedCodeInfo_Annotation& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const GeneratedCodeInfo_Annotation* internal_default_instance() {
-    return reinterpret_cast<const GeneratedCodeInfo_Annotation*>(
-               &_GeneratedCodeInfo_Annotation_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    25;
-
-  friend void swap(GeneratedCodeInfo_Annotation& a, GeneratedCodeInfo_Annotation& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(GeneratedCodeInfo_Annotation* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(GeneratedCodeInfo_Annotation* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  GeneratedCodeInfo_Annotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<GeneratedCodeInfo_Annotation>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const GeneratedCodeInfo_Annotation& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const GeneratedCodeInfo_Annotation& from) {
-    GeneratedCodeInfo_Annotation::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(GeneratedCodeInfo_Annotation* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.GeneratedCodeInfo.Annotation";
-  }
-  protected:
-  explicit GeneratedCodeInfo_Annotation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kPathFieldNumber = 1,
-    kSourceFileFieldNumber = 2,
-    kBeginFieldNumber = 3,
-    kEndFieldNumber = 4,
-  };
-  // repeated int32 path = 1 [packed = true];
-  int path_size() const;
-  private:
-  int _internal_path_size() const;
-  public:
-  void clear_path();
-  private:
-  int32_t _internal_path(int index) const;
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      _internal_path() const;
-  void _internal_add_path(int32_t value);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      _internal_mutable_path();
-  public:
-  int32_t path(int index) const;
-  void set_path(int index, int32_t value);
-  void add_path(int32_t value);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-      path() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-      mutable_path();
-
-  // optional string source_file = 2;
-  bool has_source_file() const;
-  private:
-  bool _internal_has_source_file() const;
-  public:
-  void clear_source_file();
-  const std::string& source_file() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_source_file(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_source_file();
-  PROTOBUF_NODISCARD std::string* release_source_file();
-  void set_allocated_source_file(std::string* source_file);
-  private:
-  const std::string& _internal_source_file() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source_file(const std::string& value);
-  std::string* _internal_mutable_source_file();
-  public:
-
-  // optional int32 begin = 3;
-  bool has_begin() const;
-  private:
-  bool _internal_has_begin() const;
-  public:
-  void clear_begin();
-  int32_t begin() const;
-  void set_begin(int32_t value);
-  private:
-  int32_t _internal_begin() const;
-  void _internal_set_begin(int32_t value);
-  public:
-
-  // optional int32 end = 4;
-  bool has_end() const;
-  private:
-  bool _internal_has_end() const;
-  public:
-  void clear_end();
-  int32_t end() const;
-  void set_end(int32_t value);
-  private:
-  int32_t _internal_end() const;
-  void _internal_set_end(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo.Annotation)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > path_;
-    mutable std::atomic<int> _path_cached_byte_size_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_file_;
-    int32_t begin_;
-    int32_t end_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
-};
-// -------------------------------------------------------------------
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(GeneratedCodeInfo* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.GeneratedCodeInfo";
+    }
 
-class PROTOBUF_EXPORT GeneratedCodeInfo final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo) */ {
- public:
-  inline GeneratedCodeInfo() : GeneratedCodeInfo(nullptr) {}
-  ~GeneratedCodeInfo() override;
-  explicit PROTOBUF_CONSTEXPR GeneratedCodeInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  GeneratedCodeInfo(const GeneratedCodeInfo& from);
-  GeneratedCodeInfo(GeneratedCodeInfo&& from) noexcept
-    : GeneratedCodeInfo() {
-    *this = ::std::move(from);
-  }
-
-  inline GeneratedCodeInfo& operator=(const GeneratedCodeInfo& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline GeneratedCodeInfo& operator=(GeneratedCodeInfo&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
-    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
-  }
-  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
-    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const GeneratedCodeInfo& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const GeneratedCodeInfo* internal_default_instance() {
-    return reinterpret_cast<const GeneratedCodeInfo*>(
-               &_GeneratedCodeInfo_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    26;
-
-  friend void swap(GeneratedCodeInfo& a, GeneratedCodeInfo& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(GeneratedCodeInfo* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(GeneratedCodeInfo* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  GeneratedCodeInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<GeneratedCodeInfo>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const GeneratedCodeInfo& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const GeneratedCodeInfo& from) {
-    GeneratedCodeInfo::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(GeneratedCodeInfo* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.GeneratedCodeInfo";
-  }
-  protected:
-  explicit GeneratedCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef GeneratedCodeInfo_Annotation Annotation;
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kAnnotationFieldNumber = 1,
-  };
-  // repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
-  int annotation_size() const;
-  private:
-  int _internal_annotation_size() const;
-  public:
-  void clear_annotation();
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* mutable_annotation(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >*
-      mutable_annotation();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& _internal_annotation(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* _internal_add_annotation();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& annotation(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* add_annotation();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >&
-      annotation() const;
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation > annotation_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
+protected:
+    explicit GeneratedCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef GeneratedCodeInfo_Annotation Annotation;
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kAnnotationFieldNumber = 1,
+    };
+    // repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
+    int annotation_size() const;
+
+private:
+    int _internal_annotation_size() const;
+
+public:
+    void clear_annotation();
+    ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* mutable_annotation(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>*
+        mutable_annotation();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& _internal_annotation(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* _internal_add_annotation();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& annotation(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* add_annotation();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>&
+        annotation() const;
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation> annotation_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fdescriptor_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // FileDescriptorSet
 
 // repeated .google.protobuf.FileDescriptorProto file = 1;
-inline int FileDescriptorSet::_internal_file_size() const {
-  return _impl_.file_.size();
-}
-inline int FileDescriptorSet::file_size() const {
-  return _internal_file_size();
-}
-inline void FileDescriptorSet::clear_file() {
-  _impl_.file_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorSet.file)
-  return _impl_.file_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >*
-FileDescriptorSet::mutable_file() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorSet.file)
-  return &_impl_.file_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& FileDescriptorSet::_internal_file(int index) const {
-  return _impl_.file_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& FileDescriptorSet::file(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorSet.file)
-  return _internal_file(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::_internal_add_file() {
-  return _impl_.file_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::add_file() {
-  ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _add = _internal_add_file();
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorSet.file)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto >&
-FileDescriptorSet::file() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorSet.file)
-  return _impl_.file_;
+inline int FileDescriptorSet::_internal_file_size() const
+{
+    return _impl_.file_.size();
+}
+inline int FileDescriptorSet::file_size() const
+{
+    return _internal_file_size();
+}
+inline void FileDescriptorSet::clear_file()
+{
+    _impl_.file_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::mutable_file(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorSet.file)
+    return _impl_.file_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>*
+    FileDescriptorSet::mutable_file()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorSet.file)
+    return &_impl_.file_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& FileDescriptorSet::_internal_file(int index) const
+{
+    return _impl_.file_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto& FileDescriptorSet::file(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorSet.file)
+    return _internal_file(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::_internal_add_file()
+{
+    return _impl_.file_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* FileDescriptorSet::add_file()
+{
+    ::PROTOBUF_NAMESPACE_ID::FileDescriptorProto* _add = _internal_add_file();
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorSet.file)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FileDescriptorProto>&
+    FileDescriptorSet::file() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorSet.file)
+    return _impl_.file_;
 }
 
 // -------------------------------------------------------------------
@@ -8580,716 +10536,901 @@ FileDescriptorSet::file() const {
 // FileDescriptorProto
 
 // optional string name = 1;
-inline bool FileDescriptorProto::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool FileDescriptorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void FileDescriptorProto::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& FileDescriptorProto::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.name)
-}
-inline std::string* FileDescriptorProto::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.name)
-  return _s;
-}
-inline const std::string& FileDescriptorProto::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void FileDescriptorProto::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileDescriptorProto::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileDescriptorProto::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileDescriptorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+inline bool FileDescriptorProto::_internal_has_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool FileDescriptorProto::has_name() const
+{
+    return _internal_has_name();
+}
+inline void FileDescriptorProto::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.name)
-}
-
-// optional string package = 2;
-inline bool FileDescriptorProto::_internal_has_package() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool FileDescriptorProto::has_package() const {
-  return _internal_has_package();
-}
-inline void FileDescriptorProto::clear_package() {
-  _impl_.package_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& FileDescriptorProto::package() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.package)
-  return _internal_package();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileDescriptorProto::set_package(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000002u;
- _impl_.package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.package)
-}
-inline std::string* FileDescriptorProto::mutable_package() {
-  std::string* _s = _internal_mutable_package();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.package)
-  return _s;
-}
-inline const std::string& FileDescriptorProto::_internal_package() const {
-  return _impl_.package_.Get();
-}
-inline void FileDescriptorProto::_internal_set_package(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.package_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileDescriptorProto::_internal_mutable_package() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  return _impl_.package_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileDescriptorProto::release_package() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.package)
-  if (!_internal_has_package()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  auto* p = _impl_.package_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.package_.IsDefault()) {
-    _impl_.package_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileDescriptorProto::set_allocated_package(std::string* package) {
-  if (package != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.package_.SetAllocated(package, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.package_.IsDefault()) {
-    _impl_.package_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.package)
-}
-
-// repeated string dependency = 3;
-inline int FileDescriptorProto::_internal_dependency_size() const {
-  return _impl_.dependency_.size();
-}
-inline int FileDescriptorProto::dependency_size() const {
-  return _internal_dependency_size();
 }
-inline void FileDescriptorProto::clear_dependency() {
-  _impl_.dependency_.Clear();
+inline const std::string& FileDescriptorProto::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.name)
+    return _internal_name();
 }
-inline std::string* FileDescriptorProto::add_dependency() {
-  std::string* _s = _internal_add_dependency();
-  // @@protoc_insertion_point(field_add_mutable:google.protobuf.FileDescriptorProto.dependency)
-  return _s;
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileDescriptorProto::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.name)
 }
-inline const std::string& FileDescriptorProto::_internal_dependency(int index) const {
-  return _impl_.dependency_.Get(index);
+inline std::string* FileDescriptorProto::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.name)
+    return _s;
 }
-inline const std::string& FileDescriptorProto::dependency(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.dependency)
-  return _internal_dependency(index);
+inline const std::string& FileDescriptorProto::_internal_name() const
+{
+    return _impl_.name_.Get();
 }
-inline std::string* FileDescriptorProto::mutable_dependency(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.dependency)
-  return _impl_.dependency_.Mutable(index);
+inline void FileDescriptorProto::_internal_set_name(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(value, GetArenaForAllocation());
 }
-inline void FileDescriptorProto::set_dependency(int index, const std::string& value) {
-  _impl_.dependency_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
+inline std::string* FileDescriptorProto::_internal_mutable_name()
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.name)
+    if (!_internal_has_name())
+    {
+        return nullptr;
+    }
+    _impl_._has_bits_[0] &= ~0x00000001u;
+    auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileDescriptorProto::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.name)
 }
-inline void FileDescriptorProto::set_dependency(int index, std::string&& value) {
-  _impl_.dependency_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
+
+// optional string package = 2;
+inline bool FileDescriptorProto::_internal_has_package() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool FileDescriptorProto::has_package() const
+{
+    return _internal_has_package();
+}
+inline void FileDescriptorProto::clear_package()
+{
+    _impl_.package_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline void FileDescriptorProto::set_dependency(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.dependency_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.dependency)
+inline const std::string& FileDescriptorProto::package() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.package)
+    return _internal_package();
 }
-inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) {
-  _impl_.dependency_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.dependency)
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileDescriptorProto::set_package(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.package_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.package)
 }
-inline std::string* FileDescriptorProto::_internal_add_dependency() {
-  return _impl_.dependency_.Add();
+inline std::string* FileDescriptorProto::mutable_package()
+{
+    std::string* _s = _internal_mutable_package();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.package)
+    return _s;
 }
-inline void FileDescriptorProto::add_dependency(const std::string& value) {
-  _impl_.dependency_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
+inline const std::string& FileDescriptorProto::_internal_package() const
+{
+    return _impl_.package_.Get();
 }
-inline void FileDescriptorProto::add_dependency(std::string&& value) {
-  _impl_.dependency_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
+inline void FileDescriptorProto::_internal_set_package(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.package_.Set(value, GetArenaForAllocation());
 }
-inline void FileDescriptorProto::add_dependency(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.dependency_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:google.protobuf.FileDescriptorProto.dependency)
+inline std::string* FileDescriptorProto::_internal_mutable_package()
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    return _impl_.package_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::release_package()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.package)
+    if (!_internal_has_package())
+    {
+        return nullptr;
+    }
+    _impl_._has_bits_[0] &= ~0x00000002u;
+    auto* p = _impl_.package_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.package_.IsDefault())
+    {
+        _impl_.package_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileDescriptorProto::set_allocated_package(std::string* package)
+{
+    if (package != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.package_.SetAllocated(package, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.package_.IsDefault())
+    {
+        _impl_.package_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.package)
 }
-inline void FileDescriptorProto::add_dependency(const char* value, size_t size) {
-  _impl_.dependency_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:google.protobuf.FileDescriptorProto.dependency)
+
+// repeated string dependency = 3;
+inline int FileDescriptorProto::_internal_dependency_size() const
+{
+    return _impl_.dependency_.size();
+}
+inline int FileDescriptorProto::dependency_size() const
+{
+    return _internal_dependency_size();
+}
+inline void FileDescriptorProto::clear_dependency()
+{
+    _impl_.dependency_.Clear();
+}
+inline std::string* FileDescriptorProto::add_dependency()
+{
+    std::string* _s = _internal_add_dependency();
+    // @@protoc_insertion_point(field_add_mutable:google.protobuf.FileDescriptorProto.dependency)
+    return _s;
+}
+inline const std::string& FileDescriptorProto::_internal_dependency(int index) const
+{
+    return _impl_.dependency_.Get(index);
+}
+inline const std::string& FileDescriptorProto::dependency(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.dependency)
+    return _internal_dependency(index);
+}
+inline std::string* FileDescriptorProto::mutable_dependency(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.dependency)
+    return _impl_.dependency_.Mutable(index);
+}
+inline void FileDescriptorProto::set_dependency(int index, const std::string& value)
+{
+    _impl_.dependency_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::set_dependency(int index, std::string&& value)
+{
+    _impl_.dependency_.Mutable(index)->assign(std::move(value));
+    // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::set_dependency(int index, const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.dependency_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size)
+{
+    _impl_.dependency_.Mutable(index)->assign(
+        reinterpret_cast<const char*>(value), size
+    );
+    // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.dependency)
+}
+inline std::string* FileDescriptorProto::_internal_add_dependency()
+{
+    return _impl_.dependency_.Add();
+}
+inline void FileDescriptorProto::add_dependency(const std::string& value)
+{
+    _impl_.dependency_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::add_dependency(std::string&& value)
+{
+    _impl_.dependency_.Add(std::move(value));
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::add_dependency(const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.dependency_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add_char:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::add_dependency(const char* value, size_t size)
+{
+    _impl_.dependency_.Add()->assign(reinterpret_cast<const char*>(value), size);
+    // @@protoc_insertion_point(field_add_pointer:google.protobuf.FileDescriptorProto.dependency)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-FileDescriptorProto::dependency() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.dependency)
-  return _impl_.dependency_;
+    FileDescriptorProto::dependency() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.dependency)
+    return _impl_.dependency_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-FileDescriptorProto::mutable_dependency() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.dependency)
-  return &_impl_.dependency_;
+    FileDescriptorProto::mutable_dependency()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.dependency)
+    return &_impl_.dependency_;
 }
 
 // repeated int32 public_dependency = 10;
-inline int FileDescriptorProto::_internal_public_dependency_size() const {
-  return _impl_.public_dependency_.size();
-}
-inline int FileDescriptorProto::public_dependency_size() const {
-  return _internal_public_dependency_size();
-}
-inline void FileDescriptorProto::clear_public_dependency() {
-  _impl_.public_dependency_.Clear();
-}
-inline int32_t FileDescriptorProto::_internal_public_dependency(int index) const {
-  return _impl_.public_dependency_.Get(index);
-}
-inline int32_t FileDescriptorProto::public_dependency(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.public_dependency)
-  return _internal_public_dependency(index);
-}
-inline void FileDescriptorProto::set_public_dependency(int index, int32_t value) {
-  _impl_.public_dependency_.Set(index, value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.public_dependency)
-}
-inline void FileDescriptorProto::_internal_add_public_dependency(int32_t value) {
-  _impl_.public_dependency_.Add(value);
-}
-inline void FileDescriptorProto::add_public_dependency(int32_t value) {
-  _internal_add_public_dependency(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.public_dependency)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-FileDescriptorProto::_internal_public_dependency() const {
-  return _impl_.public_dependency_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-FileDescriptorProto::public_dependency() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.public_dependency)
-  return _internal_public_dependency();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-FileDescriptorProto::_internal_mutable_public_dependency() {
-  return &_impl_.public_dependency_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-FileDescriptorProto::mutable_public_dependency() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.public_dependency)
-  return _internal_mutable_public_dependency();
+inline int FileDescriptorProto::_internal_public_dependency_size() const
+{
+    return _impl_.public_dependency_.size();
+}
+inline int FileDescriptorProto::public_dependency_size() const
+{
+    return _internal_public_dependency_size();
+}
+inline void FileDescriptorProto::clear_public_dependency()
+{
+    _impl_.public_dependency_.Clear();
+}
+inline int32_t FileDescriptorProto::_internal_public_dependency(int index) const
+{
+    return _impl_.public_dependency_.Get(index);
+}
+inline int32_t FileDescriptorProto::public_dependency(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.public_dependency)
+    return _internal_public_dependency(index);
+}
+inline void FileDescriptorProto::set_public_dependency(int index, int32_t value)
+{
+    _impl_.public_dependency_.Set(index, value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.public_dependency)
+}
+inline void FileDescriptorProto::_internal_add_public_dependency(int32_t value)
+{
+    _impl_.public_dependency_.Add(value);
+}
+inline void FileDescriptorProto::add_public_dependency(int32_t value)
+{
+    _internal_add_public_dependency(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.public_dependency)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    FileDescriptorProto::_internal_public_dependency() const
+{
+    return _impl_.public_dependency_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    FileDescriptorProto::public_dependency() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.public_dependency)
+    return _internal_public_dependency();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    FileDescriptorProto::_internal_mutable_public_dependency()
+{
+    return &_impl_.public_dependency_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    FileDescriptorProto::mutable_public_dependency()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.public_dependency)
+    return _internal_mutable_public_dependency();
 }
 
 // repeated int32 weak_dependency = 11;
-inline int FileDescriptorProto::_internal_weak_dependency_size() const {
-  return _impl_.weak_dependency_.size();
-}
-inline int FileDescriptorProto::weak_dependency_size() const {
-  return _internal_weak_dependency_size();
-}
-inline void FileDescriptorProto::clear_weak_dependency() {
-  _impl_.weak_dependency_.Clear();
-}
-inline int32_t FileDescriptorProto::_internal_weak_dependency(int index) const {
-  return _impl_.weak_dependency_.Get(index);
-}
-inline int32_t FileDescriptorProto::weak_dependency(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.weak_dependency)
-  return _internal_weak_dependency(index);
-}
-inline void FileDescriptorProto::set_weak_dependency(int index, int32_t value) {
-  _impl_.weak_dependency_.Set(index, value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.weak_dependency)
-}
-inline void FileDescriptorProto::_internal_add_weak_dependency(int32_t value) {
-  _impl_.weak_dependency_.Add(value);
-}
-inline void FileDescriptorProto::add_weak_dependency(int32_t value) {
-  _internal_add_weak_dependency(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.weak_dependency)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-FileDescriptorProto::_internal_weak_dependency() const {
-  return _impl_.weak_dependency_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-FileDescriptorProto::weak_dependency() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.weak_dependency)
-  return _internal_weak_dependency();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-FileDescriptorProto::_internal_mutable_weak_dependency() {
-  return &_impl_.weak_dependency_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-FileDescriptorProto::mutable_weak_dependency() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.weak_dependency)
-  return _internal_mutable_weak_dependency();
+inline int FileDescriptorProto::_internal_weak_dependency_size() const
+{
+    return _impl_.weak_dependency_.size();
+}
+inline int FileDescriptorProto::weak_dependency_size() const
+{
+    return _internal_weak_dependency_size();
+}
+inline void FileDescriptorProto::clear_weak_dependency()
+{
+    _impl_.weak_dependency_.Clear();
+}
+inline int32_t FileDescriptorProto::_internal_weak_dependency(int index) const
+{
+    return _impl_.weak_dependency_.Get(index);
+}
+inline int32_t FileDescriptorProto::weak_dependency(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.weak_dependency)
+    return _internal_weak_dependency(index);
+}
+inline void FileDescriptorProto::set_weak_dependency(int index, int32_t value)
+{
+    _impl_.weak_dependency_.Set(index, value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.weak_dependency)
+}
+inline void FileDescriptorProto::_internal_add_weak_dependency(int32_t value)
+{
+    _impl_.weak_dependency_.Add(value);
+}
+inline void FileDescriptorProto::add_weak_dependency(int32_t value)
+{
+    _internal_add_weak_dependency(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.weak_dependency)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    FileDescriptorProto::_internal_weak_dependency() const
+{
+    return _impl_.weak_dependency_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    FileDescriptorProto::weak_dependency() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.weak_dependency)
+    return _internal_weak_dependency();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    FileDescriptorProto::_internal_mutable_weak_dependency()
+{
+    return &_impl_.weak_dependency_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    FileDescriptorProto::mutable_weak_dependency()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.weak_dependency)
+    return _internal_mutable_weak_dependency();
 }
 
 // repeated .google.protobuf.DescriptorProto message_type = 4;
-inline int FileDescriptorProto::_internal_message_type_size() const {
-  return _impl_.message_type_.size();
-}
-inline int FileDescriptorProto::message_type_size() const {
-  return _internal_message_type_size();
-}
-inline void FileDescriptorProto::clear_message_type() {
-  _impl_.message_type_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.message_type)
-  return _impl_.message_type_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >*
-FileDescriptorProto::mutable_message_type() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.message_type)
-  return &_impl_.message_type_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& FileDescriptorProto::_internal_message_type(int index) const {
-  return _impl_.message_type_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& FileDescriptorProto::message_type(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.message_type)
-  return _internal_message_type(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::_internal_add_message_type() {
-  return _impl_.message_type_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::add_message_type() {
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _add = _internal_add_message_type();
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.message_type)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >&
-FileDescriptorProto::message_type() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.message_type)
-  return _impl_.message_type_;
+inline int FileDescriptorProto::_internal_message_type_size() const
+{
+    return _impl_.message_type_.size();
+}
+inline int FileDescriptorProto::message_type_size() const
+{
+    return _internal_message_type_size();
+}
+inline void FileDescriptorProto::clear_message_type()
+{
+    _impl_.message_type_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::mutable_message_type(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.message_type)
+    return _impl_.message_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto>*
+    FileDescriptorProto::mutable_message_type()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.message_type)
+    return &_impl_.message_type_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& FileDescriptorProto::_internal_message_type(int index) const
+{
+    return _impl_.message_type_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& FileDescriptorProto::message_type(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.message_type)
+    return _internal_message_type(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::_internal_add_message_type()
+{
+    return _impl_.message_type_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* FileDescriptorProto::add_message_type()
+{
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _add = _internal_add_message_type();
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.message_type)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto>&
+    FileDescriptorProto::message_type() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.message_type)
+    return _impl_.message_type_;
 }
 
 // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
-inline int FileDescriptorProto::_internal_enum_type_size() const {
-  return _impl_.enum_type_.size();
-}
-inline int FileDescriptorProto::enum_type_size() const {
-  return _internal_enum_type_size();
-}
-inline void FileDescriptorProto::clear_enum_type() {
-  _impl_.enum_type_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.enum_type)
-  return _impl_.enum_type_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
-FileDescriptorProto::mutable_enum_type() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.enum_type)
-  return &_impl_.enum_type_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& FileDescriptorProto::_internal_enum_type(int index) const {
-  return _impl_.enum_type_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.enum_type)
-  return _internal_enum_type(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::_internal_add_enum_type() {
-  return _impl_.enum_type_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::add_enum_type() {
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _add = _internal_add_enum_type();
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.enum_type)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
-FileDescriptorProto::enum_type() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.enum_type)
-  return _impl_.enum_type_;
+inline int FileDescriptorProto::_internal_enum_type_size() const
+{
+    return _impl_.enum_type_.size();
+}
+inline int FileDescriptorProto::enum_type_size() const
+{
+    return _internal_enum_type_size();
+}
+inline void FileDescriptorProto::clear_enum_type()
+{
+    _impl_.enum_type_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.enum_type)
+    return _impl_.enum_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>*
+    FileDescriptorProto::mutable_enum_type()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.enum_type)
+    return &_impl_.enum_type_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& FileDescriptorProto::_internal_enum_type(int index) const
+{
+    return _impl_.enum_type_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.enum_type)
+    return _internal_enum_type(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::_internal_add_enum_type()
+{
+    return _impl_.enum_type_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* FileDescriptorProto::add_enum_type()
+{
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _add = _internal_add_enum_type();
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.enum_type)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>&
+    FileDescriptorProto::enum_type() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.enum_type)
+    return _impl_.enum_type_;
 }
 
 // repeated .google.protobuf.ServiceDescriptorProto service = 6;
-inline int FileDescriptorProto::_internal_service_size() const {
-  return _impl_.service_.size();
-}
-inline int FileDescriptorProto::service_size() const {
-  return _internal_service_size();
-}
-inline void FileDescriptorProto::clear_service() {
-  _impl_.service_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.service)
-  return _impl_.service_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >*
-FileDescriptorProto::mutable_service() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.service)
-  return &_impl_.service_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& FileDescriptorProto::_internal_service(int index) const {
-  return _impl_.service_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& FileDescriptorProto::service(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.service)
-  return _internal_service(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::_internal_add_service() {
-  return _impl_.service_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::add_service() {
-  ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* _add = _internal_add_service();
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.service)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto >&
-FileDescriptorProto::service() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.service)
-  return _impl_.service_;
+inline int FileDescriptorProto::_internal_service_size() const
+{
+    return _impl_.service_.size();
+}
+inline int FileDescriptorProto::service_size() const
+{
+    return _internal_service_size();
+}
+inline void FileDescriptorProto::clear_service()
+{
+    _impl_.service_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.service)
+    return _impl_.service_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>*
+    FileDescriptorProto::mutable_service()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.service)
+    return &_impl_.service_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& FileDescriptorProto::_internal_service(int index) const
+{
+    return _impl_.service_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto& FileDescriptorProto::service(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.service)
+    return _internal_service(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::_internal_add_service()
+{
+    return _impl_.service_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* FileDescriptorProto::add_service()
+{
+    ::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto* _add = _internal_add_service();
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.service)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::ServiceDescriptorProto>&
+    FileDescriptorProto::service() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.service)
+    return _impl_.service_;
 }
 
 // repeated .google.protobuf.FieldDescriptorProto extension = 7;
-inline int FileDescriptorProto::_internal_extension_size() const {
-  return _impl_.extension_.size();
-}
-inline int FileDescriptorProto::extension_size() const {
-  return _internal_extension_size();
-}
-inline void FileDescriptorProto::clear_extension() {
-  _impl_.extension_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.extension)
-  return _impl_.extension_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
-FileDescriptorProto::mutable_extension() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.extension)
-  return &_impl_.extension_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& FileDescriptorProto::_internal_extension(int index) const {
-  return _impl_.extension_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& FileDescriptorProto::extension(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.extension)
-  return _internal_extension(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::_internal_add_extension() {
-  return _impl_.extension_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::add_extension() {
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_extension();
-  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.extension)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
-FileDescriptorProto::extension() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.extension)
-  return _impl_.extension_;
+inline int FileDescriptorProto::_internal_extension_size() const
+{
+    return _impl_.extension_.size();
+}
+inline int FileDescriptorProto::extension_size() const
+{
+    return _internal_extension_size();
+}
+inline void FileDescriptorProto::clear_extension()
+{
+    _impl_.extension_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.extension)
+    return _impl_.extension_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>*
+    FileDescriptorProto::mutable_extension()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.extension)
+    return &_impl_.extension_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& FileDescriptorProto::_internal_extension(int index) const
+{
+    return _impl_.extension_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& FileDescriptorProto::extension(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.extension)
+    return _internal_extension(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::_internal_add_extension()
+{
+    return _impl_.extension_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* FileDescriptorProto::add_extension()
+{
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_extension();
+    // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.extension)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>&
+    FileDescriptorProto::extension() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.extension)
+    return _impl_.extension_;
 }
 
 // optional .google.protobuf.FileOptions options = 8;
-inline bool FileDescriptorProto::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool FileDescriptorProto::has_options() const {
-  return _internal_has_options();
-}
-inline void FileDescriptorProto::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000008u;
+inline bool FileDescriptorProto::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool FileDescriptorProto::has_options() const
+{
+    return _internal_has_options();
+}
+inline void FileDescriptorProto::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000008u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::FileOptions& FileDescriptorProto::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::FileOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FileOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_FileOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::FileOptions& FileDescriptorProto::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::FileOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FileOptions&>(::PROTOBUF_NAMESPACE_ID::_FileOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::FileOptions& FileDescriptorProto::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::FileOptions& FileDescriptorProto::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.options)
+    return _internal_options();
 }
 inline void FileDescriptorProto::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::FileOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000008u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000008u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000008u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000008u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000008u;
-  ::PROTOBUF_NAMESPACE_ID::FileOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000008u;
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.options)
-  _impl_._has_bits_[0] &= ~0x00000008u;
-  ::PROTOBUF_NAMESPACE_ID::FileOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::FileOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.options)
-  return _msg;
-}
-inline void FileDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::FileOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000008u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.options)
     _impl_._has_bits_[0] &= ~0x00000008u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FileOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions* FileDescriptorProto::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::FileOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.options)
+    return _msg;
+}
+inline void FileDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::FileOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000008u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000008u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.options)
 }
 
 // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
-inline bool FileDescriptorProto::_internal_has_source_code_info() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.source_code_info_ != nullptr);
-  return value;
-}
-inline bool FileDescriptorProto::has_source_code_info() const {
-  return _internal_has_source_code_info();
-}
-inline void FileDescriptorProto::clear_source_code_info() {
-  if (_impl_.source_code_info_ != nullptr) _impl_.source_code_info_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000010u;
+inline bool FileDescriptorProto::_internal_has_source_code_info() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.source_code_info_ != nullptr);
+    return value;
+}
+inline bool FileDescriptorProto::has_source_code_info() const
+{
+    return _internal_has_source_code_info();
+}
+inline void FileDescriptorProto::clear_source_code_info()
+{
+    if (_impl_.source_code_info_ != nullptr)
+        _impl_.source_code_info_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000010u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& FileDescriptorProto::_internal_source_code_info() const {
-  const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* p = _impl_.source_code_info_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo&>(
-      ::PROTOBUF_NAMESPACE_ID::_SourceCodeInfo_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& FileDescriptorProto::_internal_source_code_info() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* p = _impl_.source_code_info_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo&>(::PROTOBUF_NAMESPACE_ID::_SourceCodeInfo_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& FileDescriptorProto::source_code_info() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.source_code_info)
-  return _internal_source_code_info();
+inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo& FileDescriptorProto::source_code_info() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.source_code_info)
+    return _internal_source_code_info();
 }
 inline void FileDescriptorProto::unsafe_arena_set_allocated_source_code_info(
-    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_code_info_);
-  }
-  _impl_.source_code_info_ = source_code_info;
-  if (source_code_info) {
-    _impl_._has_bits_[0] |= 0x00000010u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000010u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_code_info_);
+    }
+    _impl_.source_code_info_ = source_code_info;
+    if (source_code_info)
+    {
+        _impl_._has_bits_[0] |= 0x00000010u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000010u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
 }
-inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::release_source_code_info() {
-  _impl_._has_bits_[0] &= ~0x00000010u;
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* temp = _impl_.source_code_info_;
-  _impl_.source_code_info_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::release_source_code_info()
+{
+    _impl_._has_bits_[0] &= ~0x00000010u;
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* temp = _impl_.source_code_info_;
+    _impl_.source_code_info_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::unsafe_arena_release_source_code_info() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.source_code_info)
-  _impl_._has_bits_[0] &= ~0x00000010u;
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* temp = _impl_.source_code_info_;
-  _impl_.source_code_info_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::_internal_mutable_source_code_info() {
-  _impl_._has_bits_[0] |= 0x00000010u;
-  if (_impl_.source_code_info_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(GetArenaForAllocation());
-    _impl_.source_code_info_ = p;
-  }
-  return _impl_.source_code_info_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::mutable_source_code_info() {
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* _msg = _internal_mutable_source_code_info();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.source_code_info)
-  return _msg;
-}
-inline void FileDescriptorProto::set_allocated_source_code_info(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.source_code_info_;
-  }
-  if (source_code_info) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(source_code_info);
-    if (message_arena != submessage_arena) {
-      source_code_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, source_code_info, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000010u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::unsafe_arena_release_source_code_info()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.source_code_info)
     _impl_._has_bits_[0] &= ~0x00000010u;
-  }
-  _impl_.source_code_info_ = source_code_info;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* temp = _impl_.source_code_info_;
+    _impl_.source_code_info_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::_internal_mutable_source_code_info()
+{
+    _impl_._has_bits_[0] |= 0x00000010u;
+    if (_impl_.source_code_info_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo>(GetArenaForAllocation());
+        _impl_.source_code_info_ = p;
+    }
+    return _impl_.source_code_info_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* FileDescriptorProto::mutable_source_code_info()
+{
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* _msg = _internal_mutable_source_code_info();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.source_code_info)
+    return _msg;
+}
+inline void FileDescriptorProto::set_allocated_source_code_info(::PROTOBUF_NAMESPACE_ID::SourceCodeInfo* source_code_info)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.source_code_info_;
+    }
+    if (source_code_info)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(source_code_info);
+        if (message_arena != submessage_arena)
+        {
+            source_code_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, source_code_info, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000010u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000010u;
+    }
+    _impl_.source_code_info_ = source_code_info;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
 }
 
 // optional string syntax = 12;
-inline bool FileDescriptorProto::_internal_has_syntax() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool FileDescriptorProto::has_syntax() const {
-  return _internal_has_syntax();
-}
-inline void FileDescriptorProto::clear_syntax() {
-  _impl_.syntax_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& FileDescriptorProto::syntax() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.syntax)
-  return _internal_syntax();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileDescriptorProto::set_syntax(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000004u;
- _impl_.syntax_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.syntax)
-}
-inline std::string* FileDescriptorProto::mutable_syntax() {
-  std::string* _s = _internal_mutable_syntax();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.syntax)
-  return _s;
-}
-inline const std::string& FileDescriptorProto::_internal_syntax() const {
-  return _impl_.syntax_.Get();
-}
-inline void FileDescriptorProto::_internal_set_syntax(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.syntax_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileDescriptorProto::_internal_mutable_syntax() {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  return _impl_.syntax_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileDescriptorProto::release_syntax() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.syntax)
-  if (!_internal_has_syntax()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000004u;
-  auto* p = _impl_.syntax_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.syntax_.IsDefault()) {
-    _impl_.syntax_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileDescriptorProto::set_allocated_syntax(std::string* syntax) {
-  if (syntax != nullptr) {
+inline bool FileDescriptorProto::_internal_has_syntax() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool FileDescriptorProto::has_syntax() const
+{
+    return _internal_has_syntax();
+}
+inline void FileDescriptorProto::clear_syntax()
+{
+    _impl_.syntax_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& FileDescriptorProto::syntax() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.syntax)
+    return _internal_syntax();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileDescriptorProto::set_syntax(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.syntax_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.syntax)
+}
+inline std::string* FileDescriptorProto::mutable_syntax()
+{
+    std::string* _s = _internal_mutable_syntax();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.syntax)
+    return _s;
+}
+inline const std::string& FileDescriptorProto::_internal_syntax() const
+{
+    return _impl_.syntax_.Get();
+}
+inline void FileDescriptorProto::_internal_set_syntax(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.syntax_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::_internal_mutable_syntax()
+{
     _impl_._has_bits_[0] |= 0x00000004u;
-  } else {
+    return _impl_.syntax_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileDescriptorProto::release_syntax()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.syntax)
+    if (!_internal_has_syntax())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000004u;
-  }
-  _impl_.syntax_.SetAllocated(syntax, GetArenaForAllocation());
+    auto* p = _impl_.syntax_.Release();
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.syntax_.IsDefault()) {
-    _impl_.syntax_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.syntax)
+    if (_impl_.syntax_.IsDefault())
+    {
+        _impl_.syntax_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileDescriptorProto::set_allocated_syntax(std::string* syntax)
+{
+    if (syntax != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000004u;
+    }
+    _impl_.syntax_.SetAllocated(syntax, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.syntax_.IsDefault())
+    {
+        _impl_.syntax_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.syntax)
 }
 
 // -------------------------------------------------------------------
@@ -9297,149 +11438,190 @@ inline void FileDescriptorProto::set_allocated_syntax(std::string* syntax) {
 // DescriptorProto_ExtensionRange
 
 // optional int32 start = 1;
-inline bool DescriptorProto_ExtensionRange::_internal_has_start() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool DescriptorProto_ExtensionRange::has_start() const {
-  return _internal_has_start();
-}
-inline void DescriptorProto_ExtensionRange::clear_start() {
-  _impl_.start_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool DescriptorProto_ExtensionRange::_internal_has_start() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool DescriptorProto_ExtensionRange::has_start() const
+{
+    return _internal_has_start();
+}
+inline void DescriptorProto_ExtensionRange::clear_start()
+{
+    _impl_.start_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline int32_t DescriptorProto_ExtensionRange::_internal_start() const {
-  return _impl_.start_;
+inline int32_t DescriptorProto_ExtensionRange::_internal_start() const
+{
+    return _impl_.start_;
 }
-inline int32_t DescriptorProto_ExtensionRange::start() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.start)
-  return _internal_start();
+inline int32_t DescriptorProto_ExtensionRange::start() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.start)
+    return _internal_start();
 }
-inline void DescriptorProto_ExtensionRange::_internal_set_start(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.start_ = value;
+inline void DescriptorProto_ExtensionRange::_internal_set_start(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.start_ = value;
 }
-inline void DescriptorProto_ExtensionRange::set_start(int32_t value) {
-  _internal_set_start(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.start)
+inline void DescriptorProto_ExtensionRange::set_start(int32_t value)
+{
+    _internal_set_start(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.start)
 }
 
 // optional int32 end = 2;
-inline bool DescriptorProto_ExtensionRange::_internal_has_end() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool DescriptorProto_ExtensionRange::has_end() const {
-  return _internal_has_end();
-}
-inline void DescriptorProto_ExtensionRange::clear_end() {
-  _impl_.end_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000004u;
+inline bool DescriptorProto_ExtensionRange::_internal_has_end() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool DescriptorProto_ExtensionRange::has_end() const
+{
+    return _internal_has_end();
+}
+inline void DescriptorProto_ExtensionRange::clear_end()
+{
+    _impl_.end_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000004u;
 }
-inline int32_t DescriptorProto_ExtensionRange::_internal_end() const {
-  return _impl_.end_;
+inline int32_t DescriptorProto_ExtensionRange::_internal_end() const
+{
+    return _impl_.end_;
 }
-inline int32_t DescriptorProto_ExtensionRange::end() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.end)
-  return _internal_end();
+inline int32_t DescriptorProto_ExtensionRange::end() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.end)
+    return _internal_end();
 }
-inline void DescriptorProto_ExtensionRange::_internal_set_end(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.end_ = value;
+inline void DescriptorProto_ExtensionRange::_internal_set_end(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.end_ = value;
 }
-inline void DescriptorProto_ExtensionRange::set_end(int32_t value) {
-  _internal_set_end(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.end)
+inline void DescriptorProto_ExtensionRange::set_end(int32_t value)
+{
+    _internal_set_end(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.end)
 }
 
 // optional .google.protobuf.ExtensionRangeOptions options = 3;
-inline bool DescriptorProto_ExtensionRange::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool DescriptorProto_ExtensionRange::has_options() const {
-  return _internal_has_options();
-}
-inline void DescriptorProto_ExtensionRange::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool DescriptorProto_ExtensionRange::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool DescriptorProto_ExtensionRange::has_options() const
+{
+    return _internal_has_options();
+}
+inline void DescriptorProto_ExtensionRange::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& DescriptorProto_ExtensionRange::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_ExtensionRangeOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& DescriptorProto_ExtensionRange::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions&>(::PROTOBUF_NAMESPACE_ID::_ExtensionRangeOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& DescriptorProto_ExtensionRange::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions& DescriptorProto_ExtensionRange::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.options)
+    return _internal_options();
 }
 inline void DescriptorProto_ExtensionRange::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000001u;
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.ExtensionRange.options)
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.ExtensionRange.options)
-  return _msg;
-}
-inline void DescriptorProto_ExtensionRange::set_allocated_options(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.ExtensionRange.options)
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* DescriptorProto_ExtensionRange::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.ExtensionRange.options)
+    return _msg;
+}
+inline void DescriptorProto_ExtensionRange::set_allocated_options(::PROTOBUF_NAMESPACE_ID::ExtensionRangeOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
 }
 
 // -------------------------------------------------------------------
@@ -9447,59 +11629,73 @@ inline void DescriptorProto_ExtensionRange::set_allocated_options(::PROTOBUF_NAM
 // DescriptorProto_ReservedRange
 
 // optional int32 start = 1;
-inline bool DescriptorProto_ReservedRange::_internal_has_start() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool DescriptorProto_ReservedRange::has_start() const {
-  return _internal_has_start();
-}
-inline void DescriptorProto_ReservedRange::clear_start() {
-  _impl_.start_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool DescriptorProto_ReservedRange::_internal_has_start() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool DescriptorProto_ReservedRange::has_start() const
+{
+    return _internal_has_start();
+}
+inline void DescriptorProto_ReservedRange::clear_start()
+{
+    _impl_.start_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline int32_t DescriptorProto_ReservedRange::_internal_start() const {
-  return _impl_.start_;
+inline int32_t DescriptorProto_ReservedRange::_internal_start() const
+{
+    return _impl_.start_;
 }
-inline int32_t DescriptorProto_ReservedRange::start() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.start)
-  return _internal_start();
+inline int32_t DescriptorProto_ReservedRange::start() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.start)
+    return _internal_start();
 }
-inline void DescriptorProto_ReservedRange::_internal_set_start(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.start_ = value;
+inline void DescriptorProto_ReservedRange::_internal_set_start(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.start_ = value;
 }
-inline void DescriptorProto_ReservedRange::set_start(int32_t value) {
-  _internal_set_start(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.start)
+inline void DescriptorProto_ReservedRange::set_start(int32_t value)
+{
+    _internal_set_start(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.start)
 }
 
 // optional int32 end = 2;
-inline bool DescriptorProto_ReservedRange::_internal_has_end() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool DescriptorProto_ReservedRange::has_end() const {
-  return _internal_has_end();
-}
-inline void DescriptorProto_ReservedRange::clear_end() {
-  _impl_.end_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool DescriptorProto_ReservedRange::_internal_has_end() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool DescriptorProto_ReservedRange::has_end() const
+{
+    return _internal_has_end();
+}
+inline void DescriptorProto_ReservedRange::clear_end()
+{
+    _impl_.end_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline int32_t DescriptorProto_ReservedRange::_internal_end() const {
-  return _impl_.end_;
+inline int32_t DescriptorProto_ReservedRange::_internal_end() const
+{
+    return _impl_.end_;
 }
-inline int32_t DescriptorProto_ReservedRange::end() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.end)
-  return _internal_end();
+inline int32_t DescriptorProto_ReservedRange::end() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.end)
+    return _internal_end();
 }
-inline void DescriptorProto_ReservedRange::_internal_set_end(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.end_ = value;
+inline void DescriptorProto_ReservedRange::_internal_set_end(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.end_ = value;
 }
-inline void DescriptorProto_ReservedRange::set_end(int32_t value) {
-  _internal_set_end(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.end)
+inline void DescriptorProto_ReservedRange::set_end(int32_t value)
+{
+    _internal_set_end(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.end)
 }
 
 // -------------------------------------------------------------------
@@ -9507,516 +11703,648 @@ inline void DescriptorProto_ReservedRange::set_end(int32_t value) {
 // DescriptorProto
 
 // optional string name = 1;
-inline bool DescriptorProto::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool DescriptorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void DescriptorProto::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& DescriptorProto::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void DescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.name)
-}
-inline std::string* DescriptorProto::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.name)
-  return _s;
-}
-inline const std::string& DescriptorProto::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void DescriptorProto::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* DescriptorProto::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* DescriptorProto::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void DescriptorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+inline bool DescriptorProto::_internal_has_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool DescriptorProto::has_name() const
+{
+    return _internal_has_name();
+}
+inline void DescriptorProto::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.name)
-}
-
-// repeated .google.protobuf.FieldDescriptorProto field = 2;
-inline int DescriptorProto::_internal_field_size() const {
-  return _impl_.field_.size();
-}
-inline int DescriptorProto::field_size() const {
-  return _internal_field_size();
 }
-inline void DescriptorProto::clear_field() {
-  _impl_.field_.Clear();
+inline const std::string& DescriptorProto::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.name)
+    return _internal_name();
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::mutable_field(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.field)
-  return _impl_.field_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
-DescriptorProto::mutable_field() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.field)
-  return &_impl_.field_;
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void DescriptorProto::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.name)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::_internal_field(int index) const {
-  return _impl_.field_.Get(index);
+inline std::string* DescriptorProto::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.name)
+    return _s;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::field(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.field)
-  return _internal_field(index);
+inline const std::string& DescriptorProto::_internal_name() const
+{
+    return _impl_.name_.Get();
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::_internal_add_field() {
-  return _impl_.field_.Add();
+inline void DescriptorProto::_internal_set_name(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(value, GetArenaForAllocation());
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::add_field() {
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_field();
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.field)
-  return _add;
+inline std::string* DescriptorProto::_internal_mutable_name()
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* DescriptorProto::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.name)
+    if (!_internal_has_name())
+    {
+        return nullptr;
+    }
+    _impl_._has_bits_[0] &= ~0x00000001u;
+    auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void DescriptorProto::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.name)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
-DescriptorProto::field() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.field)
-  return _impl_.field_;
+
+// repeated .google.protobuf.FieldDescriptorProto field = 2;
+inline int DescriptorProto::_internal_field_size() const
+{
+    return _impl_.field_.size();
+}
+inline int DescriptorProto::field_size() const
+{
+    return _internal_field_size();
+}
+inline void DescriptorProto::clear_field()
+{
+    _impl_.field_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::mutable_field(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.field)
+    return _impl_.field_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>*
+    DescriptorProto::mutable_field()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.field)
+    return &_impl_.field_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::_internal_field(int index) const
+{
+    return _impl_.field_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::field(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.field)
+    return _internal_field(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::_internal_add_field()
+{
+    return _impl_.field_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::add_field()
+{
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_field();
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.field)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>&
+    DescriptorProto::field() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.field)
+    return _impl_.field_;
 }
 
 // repeated .google.protobuf.FieldDescriptorProto extension = 6;
-inline int DescriptorProto::_internal_extension_size() const {
-  return _impl_.extension_.size();
-}
-inline int DescriptorProto::extension_size() const {
-  return _internal_extension_size();
-}
-inline void DescriptorProto::clear_extension() {
-  _impl_.extension_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension)
-  return _impl_.extension_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >*
-DescriptorProto::mutable_extension() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension)
-  return &_impl_.extension_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::_internal_extension(int index) const {
-  return _impl_.extension_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::extension(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension)
-  return _internal_extension(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::_internal_add_extension() {
-  return _impl_.extension_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::add_extension() {
-  ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_extension();
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto >&
-DescriptorProto::extension() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension)
-  return _impl_.extension_;
+inline int DescriptorProto::_internal_extension_size() const
+{
+    return _impl_.extension_.size();
+}
+inline int DescriptorProto::extension_size() const
+{
+    return _internal_extension_size();
+}
+inline void DescriptorProto::clear_extension()
+{
+    _impl_.extension_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::mutable_extension(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension)
+    return _impl_.extension_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>*
+    DescriptorProto::mutable_extension()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension)
+    return &_impl_.extension_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::_internal_extension(int index) const
+{
+    return _impl_.extension_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto& DescriptorProto::extension(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension)
+    return _internal_extension(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::_internal_add_extension()
+{
+    return _impl_.extension_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* DescriptorProto::add_extension()
+{
+    ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto* _add = _internal_add_extension();
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto>&
+    DescriptorProto::extension() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension)
+    return _impl_.extension_;
 }
 
 // repeated .google.protobuf.DescriptorProto nested_type = 3;
-inline int DescriptorProto::_internal_nested_type_size() const {
-  return _impl_.nested_type_.size();
-}
-inline int DescriptorProto::nested_type_size() const {
-  return _internal_nested_type_size();
-}
-inline void DescriptorProto::clear_nested_type() {
-  _impl_.nested_type_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::mutable_nested_type(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.nested_type)
-  return _impl_.nested_type_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >*
-DescriptorProto::mutable_nested_type() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.nested_type)
-  return &_impl_.nested_type_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& DescriptorProto::_internal_nested_type(int index) const {
-  return _impl_.nested_type_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& DescriptorProto::nested_type(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.nested_type)
-  return _internal_nested_type(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::_internal_add_nested_type() {
-  return _impl_.nested_type_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::add_nested_type() {
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _add = _internal_add_nested_type();
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.nested_type)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto >&
-DescriptorProto::nested_type() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.nested_type)
-  return _impl_.nested_type_;
+inline int DescriptorProto::_internal_nested_type_size() const
+{
+    return _impl_.nested_type_.size();
+}
+inline int DescriptorProto::nested_type_size() const
+{
+    return _internal_nested_type_size();
+}
+inline void DescriptorProto::clear_nested_type()
+{
+    _impl_.nested_type_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::mutable_nested_type(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.nested_type)
+    return _impl_.nested_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto>*
+    DescriptorProto::mutable_nested_type()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.nested_type)
+    return &_impl_.nested_type_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& DescriptorProto::_internal_nested_type(int index) const
+{
+    return _impl_.nested_type_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto& DescriptorProto::nested_type(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.nested_type)
+    return _internal_nested_type(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::_internal_add_nested_type()
+{
+    return _impl_.nested_type_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto* DescriptorProto::add_nested_type()
+{
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto* _add = _internal_add_nested_type();
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.nested_type)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto>&
+    DescriptorProto::nested_type() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.nested_type)
+    return _impl_.nested_type_;
 }
 
 // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
-inline int DescriptorProto::_internal_enum_type_size() const {
-  return _impl_.enum_type_.size();
-}
-inline int DescriptorProto::enum_type_size() const {
-  return _internal_enum_type_size();
-}
-inline void DescriptorProto::clear_enum_type() {
-  _impl_.enum_type_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.enum_type)
-  return _impl_.enum_type_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >*
-DescriptorProto::mutable_enum_type() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.enum_type)
-  return &_impl_.enum_type_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& DescriptorProto::_internal_enum_type(int index) const {
-  return _impl_.enum_type_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& DescriptorProto::enum_type(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.enum_type)
-  return _internal_enum_type(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::_internal_add_enum_type() {
-  return _impl_.enum_type_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::add_enum_type() {
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _add = _internal_add_enum_type();
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.enum_type)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto >&
-DescriptorProto::enum_type() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.enum_type)
-  return _impl_.enum_type_;
+inline int DescriptorProto::_internal_enum_type_size() const
+{
+    return _impl_.enum_type_.size();
+}
+inline int DescriptorProto::enum_type_size() const
+{
+    return _internal_enum_type_size();
+}
+inline void DescriptorProto::clear_enum_type()
+{
+    _impl_.enum_type_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.enum_type)
+    return _impl_.enum_type_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>*
+    DescriptorProto::mutable_enum_type()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.enum_type)
+    return &_impl_.enum_type_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& DescriptorProto::_internal_enum_type(int index) const
+{
+    return _impl_.enum_type_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto& DescriptorProto::enum_type(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.enum_type)
+    return _internal_enum_type(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::_internal_add_enum_type()
+{
+    return _impl_.enum_type_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* DescriptorProto::add_enum_type()
+{
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto* _add = _internal_add_enum_type();
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.enum_type)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto>&
+    DescriptorProto::enum_type() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.enum_type)
+    return _impl_.enum_type_;
 }
 
 // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
-inline int DescriptorProto::_internal_extension_range_size() const {
-  return _impl_.extension_range_.size();
-}
-inline int DescriptorProto::extension_range_size() const {
-  return _internal_extension_range_size();
-}
-inline void DescriptorProto::clear_extension_range() {
-  _impl_.extension_range_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension_range)
-  return _impl_.extension_range_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >*
-DescriptorProto::mutable_extension_range() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension_range)
-  return &_impl_.extension_range_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& DescriptorProto::_internal_extension_range(int index) const {
-  return _impl_.extension_range_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension_range)
-  return _internal_extension_range(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::_internal_add_extension_range() {
-  return _impl_.extension_range_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() {
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* _add = _internal_add_extension_range();
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension_range)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange >&
-DescriptorProto::extension_range() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension_range)
-  return _impl_.extension_range_;
+inline int DescriptorProto::_internal_extension_range_size() const
+{
+    return _impl_.extension_range_.size();
+}
+inline int DescriptorProto::extension_range_size() const
+{
+    return _internal_extension_range_size();
+}
+inline void DescriptorProto::clear_extension_range()
+{
+    _impl_.extension_range_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension_range)
+    return _impl_.extension_range_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>*
+    DescriptorProto::mutable_extension_range()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension_range)
+    return &_impl_.extension_range_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& DescriptorProto::_internal_extension_range(int index) const
+{
+    return _impl_.extension_range_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension_range)
+    return _internal_extension_range(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::_internal_add_extension_range()
+{
+    return _impl_.extension_range_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range()
+{
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange* _add = _internal_add_extension_range();
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension_range)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ExtensionRange>&
+    DescriptorProto::extension_range() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension_range)
+    return _impl_.extension_range_;
 }
 
 // repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
-inline int DescriptorProto::_internal_oneof_decl_size() const {
-  return _impl_.oneof_decl_.size();
-}
-inline int DescriptorProto::oneof_decl_size() const {
-  return _internal_oneof_decl_size();
-}
-inline void DescriptorProto::clear_oneof_decl() {
-  _impl_.oneof_decl_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::mutable_oneof_decl(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.oneof_decl)
-  return _impl_.oneof_decl_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >*
-DescriptorProto::mutable_oneof_decl() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.oneof_decl)
-  return &_impl_.oneof_decl_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& DescriptorProto::_internal_oneof_decl(int index) const {
-  return _impl_.oneof_decl_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& DescriptorProto::oneof_decl(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.oneof_decl)
-  return _internal_oneof_decl(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::_internal_add_oneof_decl() {
-  return _impl_.oneof_decl_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::add_oneof_decl() {
-  ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* _add = _internal_add_oneof_decl();
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.oneof_decl)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >&
-DescriptorProto::oneof_decl() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.oneof_decl)
-  return _impl_.oneof_decl_;
+inline int DescriptorProto::_internal_oneof_decl_size() const
+{
+    return _impl_.oneof_decl_.size();
+}
+inline int DescriptorProto::oneof_decl_size() const
+{
+    return _internal_oneof_decl_size();
+}
+inline void DescriptorProto::clear_oneof_decl()
+{
+    _impl_.oneof_decl_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::mutable_oneof_decl(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.oneof_decl)
+    return _impl_.oneof_decl_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>*
+    DescriptorProto::mutable_oneof_decl()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.oneof_decl)
+    return &_impl_.oneof_decl_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& DescriptorProto::_internal_oneof_decl(int index) const
+{
+    return _impl_.oneof_decl_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto& DescriptorProto::oneof_decl(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.oneof_decl)
+    return _internal_oneof_decl(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::_internal_add_oneof_decl()
+{
+    return _impl_.oneof_decl_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* DescriptorProto::add_oneof_decl()
+{
+    ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto* _add = _internal_add_oneof_decl();
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.oneof_decl)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto>&
+    DescriptorProto::oneof_decl() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.oneof_decl)
+    return _impl_.oneof_decl_;
 }
 
 // optional .google.protobuf.MessageOptions options = 7;
-inline bool DescriptorProto::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool DescriptorProto::has_options() const {
-  return _internal_has_options();
-}
-inline void DescriptorProto::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool DescriptorProto::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool DescriptorProto::has_options() const
+{
+    return _internal_has_options();
+}
+inline void DescriptorProto::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::MessageOptions& DescriptorProto::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::MessageOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::MessageOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_MessageOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::MessageOptions& DescriptorProto::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::MessageOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::MessageOptions&>(::PROTOBUF_NAMESPACE_ID::_MessageOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::MessageOptions& DescriptorProto::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::MessageOptions& DescriptorProto::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.options)
+    return _internal_options();
 }
 inline void DescriptorProto::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::MessageOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::MessageOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000002u;
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.options)
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::MessageOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MessageOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::MessageOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.options)
-  return _msg;
-}
-inline void DescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::MessageOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.options)
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MessageOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MessageOptions* DescriptorProto::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::MessageOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.options)
+    return _msg;
+}
+inline void DescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::MessageOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.options)
 }
 
 // repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
-inline int DescriptorProto::_internal_reserved_range_size() const {
-  return _impl_.reserved_range_.size();
-}
-inline int DescriptorProto::reserved_range_size() const {
-  return _internal_reserved_range_size();
-}
-inline void DescriptorProto::clear_reserved_range() {
-  _impl_.reserved_range_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::mutable_reserved_range(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_range)
-  return _impl_.reserved_range_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >*
-DescriptorProto::mutable_reserved_range() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_range)
-  return &_impl_.reserved_range_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& DescriptorProto::_internal_reserved_range(int index) const {
-  return _impl_.reserved_range_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& DescriptorProto::reserved_range(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_range)
-  return _internal_reserved_range(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::_internal_add_reserved_range() {
-  return _impl_.reserved_range_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::add_reserved_range() {
-  ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* _add = _internal_add_reserved_range();
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_range)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange >&
-DescriptorProto::reserved_range() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_range)
-  return _impl_.reserved_range_;
+inline int DescriptorProto::_internal_reserved_range_size() const
+{
+    return _impl_.reserved_range_.size();
+}
+inline int DescriptorProto::reserved_range_size() const
+{
+    return _internal_reserved_range_size();
+}
+inline void DescriptorProto::clear_reserved_range()
+{
+    _impl_.reserved_range_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::mutable_reserved_range(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_range)
+    return _impl_.reserved_range_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>*
+    DescriptorProto::mutable_reserved_range()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_range)
+    return &_impl_.reserved_range_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& DescriptorProto::_internal_reserved_range(int index) const
+{
+    return _impl_.reserved_range_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange& DescriptorProto::reserved_range(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_range)
+    return _internal_reserved_range(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::_internal_add_reserved_range()
+{
+    return _impl_.reserved_range_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* DescriptorProto::add_reserved_range()
+{
+    ::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange* _add = _internal_add_reserved_range();
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_range)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::DescriptorProto_ReservedRange>&
+    DescriptorProto::reserved_range() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_range)
+    return _impl_.reserved_range_;
 }
 
 // repeated string reserved_name = 10;
-inline int DescriptorProto::_internal_reserved_name_size() const {
-  return _impl_.reserved_name_.size();
-}
-inline int DescriptorProto::reserved_name_size() const {
-  return _internal_reserved_name_size();
-}
-inline void DescriptorProto::clear_reserved_name() {
-  _impl_.reserved_name_.Clear();
-}
-inline std::string* DescriptorProto::add_reserved_name() {
-  std::string* _s = _internal_add_reserved_name();
-  // @@protoc_insertion_point(field_add_mutable:google.protobuf.DescriptorProto.reserved_name)
-  return _s;
-}
-inline const std::string& DescriptorProto::_internal_reserved_name(int index) const {
-  return _impl_.reserved_name_.Get(index);
-}
-inline const std::string& DescriptorProto::reserved_name(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_name)
-  return _internal_reserved_name(index);
-}
-inline std::string* DescriptorProto::mutable_reserved_name(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_name)
-  return _impl_.reserved_name_.Mutable(index);
-}
-inline void DescriptorProto::set_reserved_name(int index, const std::string& value) {
-  _impl_.reserved_name_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
-}
-inline void DescriptorProto::set_reserved_name(int index, std::string&& value) {
-  _impl_.reserved_name_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
-}
-inline void DescriptorProto::set_reserved_name(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.reserved_name_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:google.protobuf.DescriptorProto.reserved_name)
-}
-inline void DescriptorProto::set_reserved_name(int index, const char* value, size_t size) {
-  _impl_.reserved_name_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:google.protobuf.DescriptorProto.reserved_name)
-}
-inline std::string* DescriptorProto::_internal_add_reserved_name() {
-  return _impl_.reserved_name_.Add();
-}
-inline void DescriptorProto::add_reserved_name(const std::string& value) {
-  _impl_.reserved_name_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
-}
-inline void DescriptorProto::add_reserved_name(std::string&& value) {
-  _impl_.reserved_name_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
-}
-inline void DescriptorProto::add_reserved_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.reserved_name_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:google.protobuf.DescriptorProto.reserved_name)
-}
-inline void DescriptorProto::add_reserved_name(const char* value, size_t size) {
-  _impl_.reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:google.protobuf.DescriptorProto.reserved_name)
+inline int DescriptorProto::_internal_reserved_name_size() const
+{
+    return _impl_.reserved_name_.size();
+}
+inline int DescriptorProto::reserved_name_size() const
+{
+    return _internal_reserved_name_size();
+}
+inline void DescriptorProto::clear_reserved_name()
+{
+    _impl_.reserved_name_.Clear();
+}
+inline std::string* DescriptorProto::add_reserved_name()
+{
+    std::string* _s = _internal_add_reserved_name();
+    // @@protoc_insertion_point(field_add_mutable:google.protobuf.DescriptorProto.reserved_name)
+    return _s;
+}
+inline const std::string& DescriptorProto::_internal_reserved_name(int index) const
+{
+    return _impl_.reserved_name_.Get(index);
+}
+inline const std::string& DescriptorProto::reserved_name(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_name)
+    return _internal_reserved_name(index);
+}
+inline std::string* DescriptorProto::mutable_reserved_name(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_name)
+    return _impl_.reserved_name_.Mutable(index);
+}
+inline void DescriptorProto::set_reserved_name(int index, const std::string& value)
+{
+    _impl_.reserved_name_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::set_reserved_name(int index, std::string&& value)
+{
+    _impl_.reserved_name_.Mutable(index)->assign(std::move(value));
+    // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::set_reserved_name(int index, const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.reserved_name_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set_char:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::set_reserved_name(int index, const char* value, size_t size)
+{
+    _impl_.reserved_name_.Mutable(index)->assign(
+        reinterpret_cast<const char*>(value), size
+    );
+    // @@protoc_insertion_point(field_set_pointer:google.protobuf.DescriptorProto.reserved_name)
+}
+inline std::string* DescriptorProto::_internal_add_reserved_name()
+{
+    return _impl_.reserved_name_.Add();
+}
+inline void DescriptorProto::add_reserved_name(const std::string& value)
+{
+    _impl_.reserved_name_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::add_reserved_name(std::string&& value)
+{
+    _impl_.reserved_name_.Add(std::move(value));
+    // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::add_reserved_name(const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.reserved_name_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add_char:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::add_reserved_name(const char* value, size_t size)
+{
+    _impl_.reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
+    // @@protoc_insertion_point(field_add_pointer:google.protobuf.DescriptorProto.reserved_name)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-DescriptorProto::reserved_name() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_name)
-  return _impl_.reserved_name_;
+    DescriptorProto::reserved_name() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_name)
+    return _impl_.reserved_name_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-DescriptorProto::mutable_reserved_name() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_name)
-  return &_impl_.reserved_name_;
+    DescriptorProto::mutable_reserved_name()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_name)
+    return &_impl_.reserved_name_;
 }
 
 // -------------------------------------------------------------------
@@ -10024,43 +12352,53 @@ DescriptorProto::mutable_reserved_name() {
 // ExtensionRangeOptions
 
 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int ExtensionRangeOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
-}
-inline int ExtensionRangeOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
-}
-inline void ExtensionRangeOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-ExtensionRangeOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ExtensionRangeOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ExtensionRangeOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-ExtensionRangeOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+inline int ExtensionRangeOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int ExtensionRangeOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void ExtensionRangeOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    ExtensionRangeOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ExtensionRangeOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ExtensionRangeOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ExtensionRangeOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    ExtensionRangeOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
 
 // -------------------------------------------------------------------
@@ -10068,575 +12406,717 @@ ExtensionRangeOptions::uninterpreted_option() const {
 // FieldDescriptorProto
 
 // optional string name = 1;
-inline bool FieldDescriptorProto::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void FieldDescriptorProto::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& FieldDescriptorProto::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FieldDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.name)
-}
-inline std::string* FieldDescriptorProto::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.name)
-  return _s;
-}
-inline const std::string& FieldDescriptorProto::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void FieldDescriptorProto::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FieldDescriptorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
+inline bool FieldDescriptorProto::_internal_has_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_name() const
+{
+    return _internal_has_name();
+}
+inline void FieldDescriptorProto::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& FieldDescriptorProto::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FieldDescriptorProto::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.name)
+}
+inline std::string* FieldDescriptorProto::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.name)
+    return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_name(const std::string& value)
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_name()
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.name)
+    if (!_internal_has_name())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+    auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FieldDescriptorProto::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.name)
 }
 
 // optional int32 number = 3;
-inline bool FieldDescriptorProto::_internal_has_number() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_number() const {
-  return _internal_has_number();
-}
-inline void FieldDescriptorProto::clear_number() {
-  _impl_.number_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000040u;
+inline bool FieldDescriptorProto::_internal_has_number() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_number() const
+{
+    return _internal_has_number();
+}
+inline void FieldDescriptorProto::clear_number()
+{
+    _impl_.number_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000040u;
 }
-inline int32_t FieldDescriptorProto::_internal_number() const {
-  return _impl_.number_;
+inline int32_t FieldDescriptorProto::_internal_number() const
+{
+    return _impl_.number_;
 }
-inline int32_t FieldDescriptorProto::number() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.number)
-  return _internal_number();
+inline int32_t FieldDescriptorProto::number() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.number)
+    return _internal_number();
 }
-inline void FieldDescriptorProto::_internal_set_number(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000040u;
-  _impl_.number_ = value;
+inline void FieldDescriptorProto::_internal_set_number(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000040u;
+    _impl_.number_ = value;
 }
-inline void FieldDescriptorProto::set_number(int32_t value) {
-  _internal_set_number(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.number)
+inline void FieldDescriptorProto::set_number(int32_t value)
+{
+    _internal_set_number(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.number)
 }
 
 // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
-inline bool FieldDescriptorProto::_internal_has_label() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_label() const {
-  return _internal_has_label();
-}
-inline void FieldDescriptorProto::clear_label() {
-  _impl_.label_ = 1;
-  _impl_._has_bits_[0] &= ~0x00000200u;
+inline bool FieldDescriptorProto::_internal_has_label() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_label() const
+{
+    return _internal_has_label();
+}
+inline void FieldDescriptorProto::clear_label()
+{
+    _impl_.label_ = 1;
+    _impl_._has_bits_[0] &= ~0x00000200u;
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label FieldDescriptorProto::_internal_label() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label >(_impl_.label_);
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label FieldDescriptorProto::_internal_label() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label>(_impl_.label_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label FieldDescriptorProto::label() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.label)
-  return _internal_label();
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label FieldDescriptorProto::label() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.label)
+    return _internal_label();
 }
-inline void FieldDescriptorProto::_internal_set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value) {
-  assert(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_IsValid(value));
-  _impl_._has_bits_[0] |= 0x00000200u;
-  _impl_.label_ = value;
+inline void FieldDescriptorProto::_internal_set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value)
+{
+    assert(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_IsValid(value));
+    _impl_._has_bits_[0] |= 0x00000200u;
+    _impl_.label_ = value;
 }
-inline void FieldDescriptorProto::set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value) {
-  _internal_set_label(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.label)
+inline void FieldDescriptorProto::set_label(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label value)
+{
+    _internal_set_label(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.label)
 }
 
 // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
-inline bool FieldDescriptorProto::_internal_has_type() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
-  return value;
+inline bool FieldDescriptorProto::_internal_has_type() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+    return value;
 }
-inline bool FieldDescriptorProto::has_type() const {
-  return _internal_has_type();
+inline bool FieldDescriptorProto::has_type() const
+{
+    return _internal_has_type();
 }
-inline void FieldDescriptorProto::clear_type() {
-  _impl_.type_ = 1;
-  _impl_._has_bits_[0] &= ~0x00000400u;
+inline void FieldDescriptorProto::clear_type()
+{
+    _impl_.type_ = 1;
+    _impl_._has_bits_[0] &= ~0x00000400u;
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type FieldDescriptorProto::_internal_type() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type >(_impl_.type_);
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type FieldDescriptorProto::_internal_type() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type>(_impl_.type_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type FieldDescriptorProto::type() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type)
-  return _internal_type();
+inline ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type FieldDescriptorProto::type() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type)
+    return _internal_type();
 }
-inline void FieldDescriptorProto::_internal_set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value) {
-  assert(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_IsValid(value));
-  _impl_._has_bits_[0] |= 0x00000400u;
-  _impl_.type_ = value;
+inline void FieldDescriptorProto::_internal_set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value)
+{
+    assert(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_IsValid(value));
+    _impl_._has_bits_[0] |= 0x00000400u;
+    _impl_.type_ = value;
 }
-inline void FieldDescriptorProto::set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value) {
-  _internal_set_type(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type)
+inline void FieldDescriptorProto::set_type(::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type value)
+{
+    _internal_set_type(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type)
 }
 
 // optional string type_name = 6;
-inline bool FieldDescriptorProto::_internal_has_type_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_type_name() const {
-  return _internal_has_type_name();
-}
-inline void FieldDescriptorProto::clear_type_name() {
-  _impl_.type_name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& FieldDescriptorProto::type_name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type_name)
-  return _internal_type_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FieldDescriptorProto::set_type_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000004u;
- _impl_.type_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type_name)
-}
-inline std::string* FieldDescriptorProto::mutable_type_name() {
-  std::string* _s = _internal_mutable_type_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.type_name)
-  return _s;
-}
-inline const std::string& FieldDescriptorProto::_internal_type_name() const {
-  return _impl_.type_name_.Get();
-}
-inline void FieldDescriptorProto::_internal_set_type_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.type_name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::_internal_mutable_type_name() {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  return _impl_.type_name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::release_type_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.type_name)
-  if (!_internal_has_type_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000004u;
-  auto* p = _impl_.type_name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.type_name_.IsDefault()) {
-    _impl_.type_name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FieldDescriptorProto::set_allocated_type_name(std::string* type_name) {
-  if (type_name != nullptr) {
+inline bool FieldDescriptorProto::_internal_has_type_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_type_name() const
+{
+    return _internal_has_type_name();
+}
+inline void FieldDescriptorProto::clear_type_name()
+{
+    _impl_.type_name_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& FieldDescriptorProto::type_name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type_name)
+    return _internal_type_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FieldDescriptorProto::set_type_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.type_name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type_name)
+}
+inline std::string* FieldDescriptorProto::mutable_type_name()
+{
+    std::string* _s = _internal_mutable_type_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.type_name)
+    return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_type_name() const
+{
+    return _impl_.type_name_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_type_name(const std::string& value)
+{
     _impl_._has_bits_[0] |= 0x00000004u;
-  } else {
+    _impl_.type_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_type_name()
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    return _impl_.type_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_type_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.type_name)
+    if (!_internal_has_type_name())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000004u;
-  }
-  _impl_.type_name_.SetAllocated(type_name, GetArenaForAllocation());
+    auto* p = _impl_.type_name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.type_name_.IsDefault())
+    {
+        _impl_.type_name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FieldDescriptorProto::set_allocated_type_name(std::string* type_name)
+{
+    if (type_name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000004u;
+    }
+    _impl_.type_name_.SetAllocated(type_name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.type_name_.IsDefault()) {
-    _impl_.type_name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.type_name)
+    if (_impl_.type_name_.IsDefault())
+    {
+        _impl_.type_name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.type_name)
 }
 
 // optional string extendee = 2;
-inline bool FieldDescriptorProto::_internal_has_extendee() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_extendee() const {
-  return _internal_has_extendee();
-}
-inline void FieldDescriptorProto::clear_extendee() {
-  _impl_.extendee_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& FieldDescriptorProto::extendee() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.extendee)
-  return _internal_extendee();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FieldDescriptorProto::set_extendee(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000002u;
- _impl_.extendee_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.extendee)
-}
-inline std::string* FieldDescriptorProto::mutable_extendee() {
-  std::string* _s = _internal_mutable_extendee();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.extendee)
-  return _s;
-}
-inline const std::string& FieldDescriptorProto::_internal_extendee() const {
-  return _impl_.extendee_.Get();
-}
-inline void FieldDescriptorProto::_internal_set_extendee(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.extendee_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::_internal_mutable_extendee() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  return _impl_.extendee_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::release_extendee() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.extendee)
-  if (!_internal_has_extendee()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  auto* p = _impl_.extendee_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.extendee_.IsDefault()) {
-    _impl_.extendee_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FieldDescriptorProto::set_allocated_extendee(std::string* extendee) {
-  if (extendee != nullptr) {
+inline bool FieldDescriptorProto::_internal_has_extendee() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_extendee() const
+{
+    return _internal_has_extendee();
+}
+inline void FieldDescriptorProto::clear_extendee()
+{
+    _impl_.extendee_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& FieldDescriptorProto::extendee() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.extendee)
+    return _internal_extendee();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FieldDescriptorProto::set_extendee(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.extendee_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.extendee)
+}
+inline std::string* FieldDescriptorProto::mutable_extendee()
+{
+    std::string* _s = _internal_mutable_extendee();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.extendee)
+    return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_extendee() const
+{
+    return _impl_.extendee_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_extendee(const std::string& value)
+{
     _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+    _impl_.extendee_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_extendee()
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    return _impl_.extendee_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_extendee()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.extendee)
+    if (!_internal_has_extendee())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.extendee_.SetAllocated(extendee, GetArenaForAllocation());
+    auto* p = _impl_.extendee_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.extendee_.IsDefault())
+    {
+        _impl_.extendee_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FieldDescriptorProto::set_allocated_extendee(std::string* extendee)
+{
+    if (extendee != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.extendee_.SetAllocated(extendee, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.extendee_.IsDefault()) {
-    _impl_.extendee_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.extendee)
+    if (_impl_.extendee_.IsDefault())
+    {
+        _impl_.extendee_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.extendee)
 }
 
 // optional string default_value = 7;
-inline bool FieldDescriptorProto::_internal_has_default_value() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_default_value() const {
-  return _internal_has_default_value();
-}
-inline void FieldDescriptorProto::clear_default_value() {
-  _impl_.default_value_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000008u;
-}
-inline const std::string& FieldDescriptorProto::default_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.default_value)
-  return _internal_default_value();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FieldDescriptorProto::set_default_value(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000008u;
- _impl_.default_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.default_value)
-}
-inline std::string* FieldDescriptorProto::mutable_default_value() {
-  std::string* _s = _internal_mutable_default_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.default_value)
-  return _s;
-}
-inline const std::string& FieldDescriptorProto::_internal_default_value() const {
-  return _impl_.default_value_.Get();
-}
-inline void FieldDescriptorProto::_internal_set_default_value(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  _impl_.default_value_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::_internal_mutable_default_value() {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  return _impl_.default_value_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::release_default_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.default_value)
-  if (!_internal_has_default_value()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000008u;
-  auto* p = _impl_.default_value_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.default_value_.IsDefault()) {
-    _impl_.default_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FieldDescriptorProto::set_allocated_default_value(std::string* default_value) {
-  if (default_value != nullptr) {
+inline bool FieldDescriptorProto::_internal_has_default_value() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_default_value() const
+{
+    return _internal_has_default_value();
+}
+inline void FieldDescriptorProto::clear_default_value()
+{
+    _impl_.default_value_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& FieldDescriptorProto::default_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.default_value)
+    return _internal_default_value();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FieldDescriptorProto::set_default_value(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    _impl_.default_value_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.default_value)
+}
+inline std::string* FieldDescriptorProto::mutable_default_value()
+{
+    std::string* _s = _internal_mutable_default_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.default_value)
+    return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_default_value() const
+{
+    return _impl_.default_value_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_default_value(const std::string& value)
+{
     _impl_._has_bits_[0] |= 0x00000008u;
-  } else {
+    _impl_.default_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_default_value()
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    return _impl_.default_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_default_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.default_value)
+    if (!_internal_has_default_value())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000008u;
-  }
-  _impl_.default_value_.SetAllocated(default_value, GetArenaForAllocation());
+    auto* p = _impl_.default_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.default_value_.IsDefault())
+    {
+        _impl_.default_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FieldDescriptorProto::set_allocated_default_value(std::string* default_value)
+{
+    if (default_value != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000008u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000008u;
+    }
+    _impl_.default_value_.SetAllocated(default_value, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.default_value_.IsDefault()) {
-    _impl_.default_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.default_value)
+    if (_impl_.default_value_.IsDefault())
+    {
+        _impl_.default_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.default_value)
 }
 
 // optional int32 oneof_index = 9;
-inline bool FieldDescriptorProto::_internal_has_oneof_index() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_oneof_index() const {
-  return _internal_has_oneof_index();
-}
-inline void FieldDescriptorProto::clear_oneof_index() {
-  _impl_.oneof_index_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000080u;
+inline bool FieldDescriptorProto::_internal_has_oneof_index() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_oneof_index() const
+{
+    return _internal_has_oneof_index();
+}
+inline void FieldDescriptorProto::clear_oneof_index()
+{
+    _impl_.oneof_index_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000080u;
 }
-inline int32_t FieldDescriptorProto::_internal_oneof_index() const {
-  return _impl_.oneof_index_;
+inline int32_t FieldDescriptorProto::_internal_oneof_index() const
+{
+    return _impl_.oneof_index_;
 }
-inline int32_t FieldDescriptorProto::oneof_index() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.oneof_index)
-  return _internal_oneof_index();
+inline int32_t FieldDescriptorProto::oneof_index() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.oneof_index)
+    return _internal_oneof_index();
 }
-inline void FieldDescriptorProto::_internal_set_oneof_index(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000080u;
-  _impl_.oneof_index_ = value;
+inline void FieldDescriptorProto::_internal_set_oneof_index(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000080u;
+    _impl_.oneof_index_ = value;
 }
-inline void FieldDescriptorProto::set_oneof_index(int32_t value) {
-  _internal_set_oneof_index(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.oneof_index)
+inline void FieldDescriptorProto::set_oneof_index(int32_t value)
+{
+    _internal_set_oneof_index(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.oneof_index)
 }
 
 // optional string json_name = 10;
-inline bool FieldDescriptorProto::_internal_has_json_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_json_name() const {
-  return _internal_has_json_name();
-}
-inline void FieldDescriptorProto::clear_json_name() {
-  _impl_.json_name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000010u;
-}
-inline const std::string& FieldDescriptorProto::json_name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.json_name)
-  return _internal_json_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FieldDescriptorProto::set_json_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000010u;
- _impl_.json_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.json_name)
-}
-inline std::string* FieldDescriptorProto::mutable_json_name() {
-  std::string* _s = _internal_mutable_json_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.json_name)
-  return _s;
-}
-inline const std::string& FieldDescriptorProto::_internal_json_name() const {
-  return _impl_.json_name_.Get();
-}
-inline void FieldDescriptorProto::_internal_set_json_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000010u;
-  _impl_.json_name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::_internal_mutable_json_name() {
-  _impl_._has_bits_[0] |= 0x00000010u;
-  return _impl_.json_name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FieldDescriptorProto::release_json_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.json_name)
-  if (!_internal_has_json_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000010u;
-  auto* p = _impl_.json_name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.json_name_.IsDefault()) {
-    _impl_.json_name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FieldDescriptorProto::set_allocated_json_name(std::string* json_name) {
-  if (json_name != nullptr) {
+inline bool FieldDescriptorProto::_internal_has_json_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_json_name() const
+{
+    return _internal_has_json_name();
+}
+inline void FieldDescriptorProto::clear_json_name()
+{
+    _impl_.json_name_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& FieldDescriptorProto::json_name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.json_name)
+    return _internal_json_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FieldDescriptorProto::set_json_name(ArgT0&& arg0, ArgT... args)
+{
     _impl_._has_bits_[0] |= 0x00000010u;
-  } else {
+    _impl_.json_name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.json_name)
+}
+inline std::string* FieldDescriptorProto::mutable_json_name()
+{
+    std::string* _s = _internal_mutable_json_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.json_name)
+    return _s;
+}
+inline const std::string& FieldDescriptorProto::_internal_json_name() const
+{
+    return _impl_.json_name_.Get();
+}
+inline void FieldDescriptorProto::_internal_set_json_name(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000010u;
+    _impl_.json_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::_internal_mutable_json_name()
+{
+    _impl_._has_bits_[0] |= 0x00000010u;
+    return _impl_.json_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FieldDescriptorProto::release_json_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.json_name)
+    if (!_internal_has_json_name())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000010u;
-  }
-  _impl_.json_name_.SetAllocated(json_name, GetArenaForAllocation());
+    auto* p = _impl_.json_name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.json_name_.IsDefault())
+    {
+        _impl_.json_name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FieldDescriptorProto::set_allocated_json_name(std::string* json_name)
+{
+    if (json_name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000010u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000010u;
+    }
+    _impl_.json_name_.SetAllocated(json_name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.json_name_.IsDefault()) {
-    _impl_.json_name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.json_name)
+    if (_impl_.json_name_.IsDefault())
+    {
+        _impl_.json_name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.json_name)
 }
 
 // optional .google.protobuf.FieldOptions options = 8;
-inline bool FieldDescriptorProto::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool FieldDescriptorProto::has_options() const {
-  return _internal_has_options();
-}
-inline void FieldDescriptorProto::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000020u;
+inline bool FieldDescriptorProto::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool FieldDescriptorProto::has_options() const
+{
+    return _internal_has_options();
+}
+inline void FieldDescriptorProto::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000020u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::FieldOptions& FieldDescriptorProto::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::FieldOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FieldOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_FieldOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::FieldOptions& FieldDescriptorProto::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::FieldOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::FieldOptions&>(::PROTOBUF_NAMESPACE_ID::_FieldOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::FieldOptions& FieldDescriptorProto::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::FieldOptions& FieldDescriptorProto::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.options)
+    return _internal_options();
 }
 inline void FieldDescriptorProto::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::FieldOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000020u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000020u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000020u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000020u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000020u;
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000020u;
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.options)
-  _impl_._has_bits_[0] &= ~0x00000020u;
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000020u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::FieldOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.options)
-  return _msg;
-}
-inline void FieldDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::FieldOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000020u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.options)
     _impl_._has_bits_[0] &= ~0x00000020u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000020u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions* FieldDescriptorProto::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::FieldOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.options)
+    return _msg;
+}
+inline void FieldDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::FieldOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000020u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000020u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.options)
 }
 
 // optional bool proto3_optional = 17;
-inline bool FieldDescriptorProto::_internal_has_proto3_optional() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
-  return value;
-}
-inline bool FieldDescriptorProto::has_proto3_optional() const {
-  return _internal_has_proto3_optional();
-}
-inline void FieldDescriptorProto::clear_proto3_optional() {
-  _impl_.proto3_optional_ = false;
-  _impl_._has_bits_[0] &= ~0x00000100u;
+inline bool FieldDescriptorProto::_internal_has_proto3_optional() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+    return value;
+}
+inline bool FieldDescriptorProto::has_proto3_optional() const
+{
+    return _internal_has_proto3_optional();
+}
+inline void FieldDescriptorProto::clear_proto3_optional()
+{
+    _impl_.proto3_optional_ = false;
+    _impl_._has_bits_[0] &= ~0x00000100u;
 }
-inline bool FieldDescriptorProto::_internal_proto3_optional() const {
-  return _impl_.proto3_optional_;
+inline bool FieldDescriptorProto::_internal_proto3_optional() const
+{
+    return _impl_.proto3_optional_;
 }
-inline bool FieldDescriptorProto::proto3_optional() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.proto3_optional)
-  return _internal_proto3_optional();
+inline bool FieldDescriptorProto::proto3_optional() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.proto3_optional)
+    return _internal_proto3_optional();
 }
-inline void FieldDescriptorProto::_internal_set_proto3_optional(bool value) {
-  _impl_._has_bits_[0] |= 0x00000100u;
-  _impl_.proto3_optional_ = value;
+inline void FieldDescriptorProto::_internal_set_proto3_optional(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000100u;
+    _impl_.proto3_optional_ = value;
 }
-inline void FieldDescriptorProto::set_proto3_optional(bool value) {
-  _internal_set_proto3_optional(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.proto3_optional)
+inline void FieldDescriptorProto::set_proto3_optional(bool value)
+{
+    _internal_set_proto3_optional(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.proto3_optional)
 }
 
 // -------------------------------------------------------------------
@@ -10644,161 +13124,204 @@ inline void FieldDescriptorProto::set_proto3_optional(bool value) {
 // OneofDescriptorProto
 
 // optional string name = 1;
-inline bool OneofDescriptorProto::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool OneofDescriptorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void OneofDescriptorProto::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& OneofDescriptorProto::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void OneofDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.OneofDescriptorProto.name)
-}
-inline std::string* OneofDescriptorProto::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.name)
-  return _s;
-}
-inline const std::string& OneofDescriptorProto::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void OneofDescriptorProto::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* OneofDescriptorProto::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* OneofDescriptorProto::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void OneofDescriptorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
+inline bool OneofDescriptorProto::_internal_has_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool OneofDescriptorProto::has_name() const
+{
+    return _internal_has_name();
+}
+inline void OneofDescriptorProto::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& OneofDescriptorProto::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void OneofDescriptorProto::set_name(ArgT0&& arg0, ArgT... args)
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.OneofDescriptorProto.name)
+}
+inline std::string* OneofDescriptorProto::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.name)
+    return _s;
+}
+inline const std::string& OneofDescriptorProto::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void OneofDescriptorProto::_internal_set_name(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* OneofDescriptorProto::_internal_mutable_name()
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* OneofDescriptorProto::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.name)
+    if (!_internal_has_name())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+    auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void OneofDescriptorProto::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.name)
 }
 
 // optional .google.protobuf.OneofOptions options = 2;
-inline bool OneofDescriptorProto::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool OneofDescriptorProto::has_options() const {
-  return _internal_has_options();
-}
-inline void OneofDescriptorProto::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool OneofDescriptorProto::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool OneofDescriptorProto::has_options() const
+{
+    return _internal_has_options();
+}
+inline void OneofDescriptorProto::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::OneofOptions& OneofDescriptorProto::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::OneofOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::OneofOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_OneofOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::OneofOptions& OneofDescriptorProto::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::OneofOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::OneofOptions&>(::PROTOBUF_NAMESPACE_ID::_OneofOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::OneofOptions& OneofDescriptorProto::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::OneofOptions& OneofDescriptorProto::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.options)
+    return _internal_options();
 }
 inline void OneofDescriptorProto::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::OneofOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.OneofDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.OneofDescriptorProto.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::OneofOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000002u;
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.options)
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::OneofOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::OneofOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.options)
-  return _msg;
-}
-inline void OneofDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::OneofOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.options)
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::OneofOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::OneofOptions* OneofDescriptorProto::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::OneofOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.options)
+    return _msg;
+}
+inline void OneofDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::OneofOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.options)
 }
 
 // -------------------------------------------------------------------
@@ -10806,59 +13329,73 @@ inline void OneofDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID:
 // EnumDescriptorProto_EnumReservedRange
 
 // optional int32 start = 1;
-inline bool EnumDescriptorProto_EnumReservedRange::_internal_has_start() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool EnumDescriptorProto_EnumReservedRange::has_start() const {
-  return _internal_has_start();
-}
-inline void EnumDescriptorProto_EnumReservedRange::clear_start() {
-  _impl_.start_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool EnumDescriptorProto_EnumReservedRange::_internal_has_start() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool EnumDescriptorProto_EnumReservedRange::has_start() const
+{
+    return _internal_has_start();
+}
+inline void EnumDescriptorProto_EnumReservedRange::clear_start()
+{
+    _impl_.start_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline int32_t EnumDescriptorProto_EnumReservedRange::_internal_start() const {
-  return _impl_.start_;
+inline int32_t EnumDescriptorProto_EnumReservedRange::_internal_start() const
+{
+    return _impl_.start_;
 }
-inline int32_t EnumDescriptorProto_EnumReservedRange::start() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
-  return _internal_start();
+inline int32_t EnumDescriptorProto_EnumReservedRange::start() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
+    return _internal_start();
 }
-inline void EnumDescriptorProto_EnumReservedRange::_internal_set_start(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.start_ = value;
+inline void EnumDescriptorProto_EnumReservedRange::_internal_set_start(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.start_ = value;
 }
-inline void EnumDescriptorProto_EnumReservedRange::set_start(int32_t value) {
-  _internal_set_start(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
+inline void EnumDescriptorProto_EnumReservedRange::set_start(int32_t value)
+{
+    _internal_set_start(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
 }
 
 // optional int32 end = 2;
-inline bool EnumDescriptorProto_EnumReservedRange::_internal_has_end() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool EnumDescriptorProto_EnumReservedRange::has_end() const {
-  return _internal_has_end();
-}
-inline void EnumDescriptorProto_EnumReservedRange::clear_end() {
-  _impl_.end_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool EnumDescriptorProto_EnumReservedRange::_internal_has_end() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool EnumDescriptorProto_EnumReservedRange::has_end() const
+{
+    return _internal_has_end();
+}
+inline void EnumDescriptorProto_EnumReservedRange::clear_end()
+{
+    _impl_.end_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline int32_t EnumDescriptorProto_EnumReservedRange::_internal_end() const {
-  return _impl_.end_;
+inline int32_t EnumDescriptorProto_EnumReservedRange::_internal_end() const
+{
+    return _impl_.end_;
 }
-inline int32_t EnumDescriptorProto_EnumReservedRange::end() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
-  return _internal_end();
+inline int32_t EnumDescriptorProto_EnumReservedRange::end() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
+    return _internal_end();
 }
-inline void EnumDescriptorProto_EnumReservedRange::_internal_set_end(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.end_ = value;
+inline void EnumDescriptorProto_EnumReservedRange::_internal_set_end(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.end_ = value;
 }
-inline void EnumDescriptorProto_EnumReservedRange::set_end(int32_t value) {
-  _internal_set_end(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
+inline void EnumDescriptorProto_EnumReservedRange::set_end(int32_t value)
+{
+    _internal_set_end(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
 }
 
 // -------------------------------------------------------------------
@@ -10866,316 +13403,398 @@ inline void EnumDescriptorProto_EnumReservedRange::set_end(int32_t value) {
 // EnumDescriptorProto
 
 // optional string name = 1;
-inline bool EnumDescriptorProto::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool EnumDescriptorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void EnumDescriptorProto::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& EnumDescriptorProto::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void EnumDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.name)
-}
-inline std::string* EnumDescriptorProto::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.name)
-  return _s;
-}
-inline const std::string& EnumDescriptorProto::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void EnumDescriptorProto::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* EnumDescriptorProto::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* EnumDescriptorProto::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void EnumDescriptorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+inline bool EnumDescriptorProto::_internal_has_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool EnumDescriptorProto::has_name() const
+{
+    return _internal_has_name();
+}
+inline void EnumDescriptorProto::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.name)
-}
-
-// repeated .google.protobuf.EnumValueDescriptorProto value = 2;
-inline int EnumDescriptorProto::_internal_value_size() const {
-  return _impl_.value_.size();
-}
-inline int EnumDescriptorProto::value_size() const {
-  return _internal_value_size();
-}
-inline void EnumDescriptorProto::clear_value() {
-  _impl_.value_.Clear();
 }
-inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.value)
-  return _impl_.value_.Mutable(index);
+inline const std::string& EnumDescriptorProto::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.name)
+    return _internal_name();
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >*
-EnumDescriptorProto::mutable_value() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.value)
-  return &_impl_.value_;
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void EnumDescriptorProto::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.name)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& EnumDescriptorProto::_internal_value(int index) const {
-  return _impl_.value_.Get(index);
+inline std::string* EnumDescriptorProto::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.name)
+    return _s;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.value)
-  return _internal_value(index);
+inline const std::string& EnumDescriptorProto::_internal_name() const
+{
+    return _impl_.name_.Get();
 }
-inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::_internal_add_value() {
-  return _impl_.value_.Add();
+inline void EnumDescriptorProto::_internal_set_name(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(value, GetArenaForAllocation());
 }
-inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::add_value() {
-  ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* _add = _internal_add_value();
-  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.value)
-  return _add;
+inline std::string* EnumDescriptorProto::_internal_mutable_name()
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* EnumDescriptorProto::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.name)
+    if (!_internal_has_name())
+    {
+        return nullptr;
+    }
+    _impl_._has_bits_[0] &= ~0x00000001u;
+    auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void EnumDescriptorProto::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.name)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto >&
-EnumDescriptorProto::value() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.value)
-  return _impl_.value_;
+
+// repeated .google.protobuf.EnumValueDescriptorProto value = 2;
+inline int EnumDescriptorProto::_internal_value_size() const
+{
+    return _impl_.value_.size();
+}
+inline int EnumDescriptorProto::value_size() const
+{
+    return _internal_value_size();
+}
+inline void EnumDescriptorProto::clear_value()
+{
+    _impl_.value_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.value)
+    return _impl_.value_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>*
+    EnumDescriptorProto::mutable_value()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.value)
+    return &_impl_.value_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& EnumDescriptorProto::_internal_value(int index) const
+{
+    return _impl_.value_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.value)
+    return _internal_value(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::_internal_add_value()
+{
+    return _impl_.value_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* EnumDescriptorProto::add_value()
+{
+    ::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto* _add = _internal_add_value();
+    // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.value)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValueDescriptorProto>&
+    EnumDescriptorProto::value() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.value)
+    return _impl_.value_;
 }
 
 // optional .google.protobuf.EnumOptions options = 3;
-inline bool EnumDescriptorProto::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool EnumDescriptorProto::has_options() const {
-  return _internal_has_options();
-}
-inline void EnumDescriptorProto::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool EnumDescriptorProto::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool EnumDescriptorProto::has_options() const
+{
+    return _internal_has_options();
+}
+inline void EnumDescriptorProto::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::EnumOptions& EnumDescriptorProto::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::EnumOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::EnumOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_EnumOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::EnumOptions& EnumDescriptorProto::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::EnumOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::EnumOptions&>(::PROTOBUF_NAMESPACE_ID::_EnumOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::EnumOptions& EnumDescriptorProto::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::EnumOptions& EnumDescriptorProto::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.options)
+    return _internal_options();
 }
 inline void EnumDescriptorProto::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::EnumOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumDescriptorProto.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::EnumOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000002u;
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.options)
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::EnumOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::EnumOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.options)
-  return _msg;
-}
-inline void EnumDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.options)
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::EnumOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.options)
+    return _msg;
+}
+inline void EnumDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.options)
 }
 
 // repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
-inline int EnumDescriptorProto::_internal_reserved_range_size() const {
-  return _impl_.reserved_range_.size();
-}
-inline int EnumDescriptorProto::reserved_range_size() const {
-  return _internal_reserved_range_size();
-}
-inline void EnumDescriptorProto::clear_reserved_range() {
-  _impl_.reserved_range_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::mutable_reserved_range(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_range)
-  return _impl_.reserved_range_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >*
-EnumDescriptorProto::mutable_reserved_range() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_range)
-  return &_impl_.reserved_range_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::_internal_reserved_range(int index) const {
-  return _impl_.reserved_range_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::reserved_range(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_range)
-  return _internal_reserved_range(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::_internal_add_reserved_range() {
-  return _impl_.reserved_range_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::add_reserved_range() {
-  ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* _add = _internal_add_reserved_range();
-  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_range)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange >&
-EnumDescriptorProto::reserved_range() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_range)
-  return _impl_.reserved_range_;
+inline int EnumDescriptorProto::_internal_reserved_range_size() const
+{
+    return _impl_.reserved_range_.size();
+}
+inline int EnumDescriptorProto::reserved_range_size() const
+{
+    return _internal_reserved_range_size();
+}
+inline void EnumDescriptorProto::clear_reserved_range()
+{
+    _impl_.reserved_range_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::mutable_reserved_range(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_range)
+    return _impl_.reserved_range_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>*
+    EnumDescriptorProto::mutable_reserved_range()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_range)
+    return &_impl_.reserved_range_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::_internal_reserved_range(int index) const
+{
+    return _impl_.reserved_range_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::reserved_range(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_range)
+    return _internal_reserved_range(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::_internal_add_reserved_range()
+{
+    return _impl_.reserved_range_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::add_reserved_range()
+{
+    ::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange* _add = _internal_add_reserved_range();
+    // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_range)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumDescriptorProto_EnumReservedRange>&
+    EnumDescriptorProto::reserved_range() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_range)
+    return _impl_.reserved_range_;
 }
 
 // repeated string reserved_name = 5;
-inline int EnumDescriptorProto::_internal_reserved_name_size() const {
-  return _impl_.reserved_name_.size();
-}
-inline int EnumDescriptorProto::reserved_name_size() const {
-  return _internal_reserved_name_size();
-}
-inline void EnumDescriptorProto::clear_reserved_name() {
-  _impl_.reserved_name_.Clear();
-}
-inline std::string* EnumDescriptorProto::add_reserved_name() {
-  std::string* _s = _internal_add_reserved_name();
-  // @@protoc_insertion_point(field_add_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
-  return _s;
-}
-inline const std::string& EnumDescriptorProto::_internal_reserved_name(int index) const {
-  return _impl_.reserved_name_.Get(index);
-}
-inline const std::string& EnumDescriptorProto::reserved_name(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_name)
-  return _internal_reserved_name(index);
-}
-inline std::string* EnumDescriptorProto::mutable_reserved_name(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
-  return _impl_.reserved_name_.Mutable(index);
-}
-inline void EnumDescriptorProto::set_reserved_name(int index, const std::string& value) {
-  _impl_.reserved_name_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
-}
-inline void EnumDescriptorProto::set_reserved_name(int index, std::string&& value) {
-  _impl_.reserved_name_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
-}
-inline void EnumDescriptorProto::set_reserved_name(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.reserved_name_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:google.protobuf.EnumDescriptorProto.reserved_name)
-}
-inline void EnumDescriptorProto::set_reserved_name(int index, const char* value, size_t size) {
-  _impl_.reserved_name_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
-}
-inline std::string* EnumDescriptorProto::_internal_add_reserved_name() {
-  return _impl_.reserved_name_.Add();
-}
-inline void EnumDescriptorProto::add_reserved_name(const std::string& value) {
-  _impl_.reserved_name_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
-}
-inline void EnumDescriptorProto::add_reserved_name(std::string&& value) {
-  _impl_.reserved_name_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
-}
-inline void EnumDescriptorProto::add_reserved_name(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.reserved_name_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:google.protobuf.EnumDescriptorProto.reserved_name)
-}
-inline void EnumDescriptorProto::add_reserved_name(const char* value, size_t size) {
-  _impl_.reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
+inline int EnumDescriptorProto::_internal_reserved_name_size() const
+{
+    return _impl_.reserved_name_.size();
+}
+inline int EnumDescriptorProto::reserved_name_size() const
+{
+    return _internal_reserved_name_size();
+}
+inline void EnumDescriptorProto::clear_reserved_name()
+{
+    _impl_.reserved_name_.Clear();
+}
+inline std::string* EnumDescriptorProto::add_reserved_name()
+{
+    std::string* _s = _internal_add_reserved_name();
+    // @@protoc_insertion_point(field_add_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
+    return _s;
+}
+inline const std::string& EnumDescriptorProto::_internal_reserved_name(int index) const
+{
+    return _impl_.reserved_name_.Get(index);
+}
+inline const std::string& EnumDescriptorProto::reserved_name(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_name)
+    return _internal_reserved_name(index);
+}
+inline std::string* EnumDescriptorProto::mutable_reserved_name(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
+    return _impl_.reserved_name_.Mutable(index);
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, const std::string& value)
+{
+    _impl_.reserved_name_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, std::string&& value)
+{
+    _impl_.reserved_name_.Mutable(index)->assign(std::move(value));
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.reserved_name_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set_char:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, const char* value, size_t size)
+{
+    _impl_.reserved_name_.Mutable(index)->assign(
+        reinterpret_cast<const char*>(value), size
+    );
+    // @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline std::string* EnumDescriptorProto::_internal_add_reserved_name()
+{
+    return _impl_.reserved_name_.Add();
+}
+inline void EnumDescriptorProto::add_reserved_name(const std::string& value)
+{
+    _impl_.reserved_name_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::add_reserved_name(std::string&& value)
+{
+    _impl_.reserved_name_.Add(std::move(value));
+    // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::add_reserved_name(const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.reserved_name_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add_char:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::add_reserved_name(const char* value, size_t size)
+{
+    _impl_.reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
+    // @@protoc_insertion_point(field_add_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-EnumDescriptorProto::reserved_name() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_name)
-  return _impl_.reserved_name_;
+    EnumDescriptorProto::reserved_name() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_name)
+    return _impl_.reserved_name_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-EnumDescriptorProto::mutable_reserved_name() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_name)
-  return &_impl_.reserved_name_;
+    EnumDescriptorProto::mutable_reserved_name()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_name)
+    return &_impl_.reserved_name_;
 }
 
 // -------------------------------------------------------------------
@@ -11183,189 +13802,239 @@ EnumDescriptorProto::mutable_reserved_name() {
 // EnumValueDescriptorProto
 
 // optional string name = 1;
-inline bool EnumValueDescriptorProto::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool EnumValueDescriptorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void EnumValueDescriptorProto::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& EnumValueDescriptorProto::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void EnumValueDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.name)
-}
-inline std::string* EnumValueDescriptorProto::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.name)
-  return _s;
-}
-inline const std::string& EnumValueDescriptorProto::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void EnumValueDescriptorProto::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* EnumValueDescriptorProto::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* EnumValueDescriptorProto::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void EnumValueDescriptorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
+inline bool EnumValueDescriptorProto::_internal_has_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool EnumValueDescriptorProto::has_name() const
+{
+    return _internal_has_name();
+}
+inline void EnumValueDescriptorProto::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& EnumValueDescriptorProto::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void EnumValueDescriptorProto::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.name)
+}
+inline std::string* EnumValueDescriptorProto::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.name)
+    return _s;
+}
+inline const std::string& EnumValueDescriptorProto::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void EnumValueDescriptorProto::_internal_set_name(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* EnumValueDescriptorProto::_internal_mutable_name()
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* EnumValueDescriptorProto::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.name)
+    if (!_internal_has_name())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+    auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void EnumValueDescriptorProto::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.name)
 }
 
 // optional int32 number = 2;
-inline bool EnumValueDescriptorProto::_internal_has_number() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool EnumValueDescriptorProto::has_number() const {
-  return _internal_has_number();
-}
-inline void EnumValueDescriptorProto::clear_number() {
-  _impl_.number_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000004u;
+inline bool EnumValueDescriptorProto::_internal_has_number() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool EnumValueDescriptorProto::has_number() const
+{
+    return _internal_has_number();
+}
+inline void EnumValueDescriptorProto::clear_number()
+{
+    _impl_.number_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000004u;
 }
-inline int32_t EnumValueDescriptorProto::_internal_number() const {
-  return _impl_.number_;
+inline int32_t EnumValueDescriptorProto::_internal_number() const
+{
+    return _impl_.number_;
 }
-inline int32_t EnumValueDescriptorProto::number() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.number)
-  return _internal_number();
+inline int32_t EnumValueDescriptorProto::number() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.number)
+    return _internal_number();
 }
-inline void EnumValueDescriptorProto::_internal_set_number(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.number_ = value;
+inline void EnumValueDescriptorProto::_internal_set_number(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.number_ = value;
 }
-inline void EnumValueDescriptorProto::set_number(int32_t value) {
-  _internal_set_number(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.number)
+inline void EnumValueDescriptorProto::set_number(int32_t value)
+{
+    _internal_set_number(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.number)
 }
 
 // optional .google.protobuf.EnumValueOptions options = 3;
-inline bool EnumValueDescriptorProto::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool EnumValueDescriptorProto::has_options() const {
-  return _internal_has_options();
-}
-inline void EnumValueDescriptorProto::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool EnumValueDescriptorProto::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool EnumValueDescriptorProto::has_options() const
+{
+    return _internal_has_options();
+}
+inline void EnumValueDescriptorProto::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& EnumValueDescriptorProto::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_EnumValueOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& EnumValueDescriptorProto::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions&>(::PROTOBUF_NAMESPACE_ID::_EnumValueOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& EnumValueDescriptorProto::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValueOptions& EnumValueDescriptorProto::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.options)
+    return _internal_options();
 }
 inline void EnumValueDescriptorProto::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000002u;
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.options)
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.options)
-  return _msg;
-}
-inline void EnumValueDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.options)
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValueOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* EnumValueDescriptorProto::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::EnumValueOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.options)
+    return _msg;
+}
+inline void EnumValueDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::EnumValueOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
 }
 
 // -------------------------------------------------------------------
@@ -11373,201 +14042,254 @@ inline void EnumValueDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE
 // ServiceDescriptorProto
 
 // optional string name = 1;
-inline bool ServiceDescriptorProto::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool ServiceDescriptorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void ServiceDescriptorProto::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& ServiceDescriptorProto::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void ServiceDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.ServiceDescriptorProto.name)
-}
-inline std::string* ServiceDescriptorProto::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.name)
-  return _s;
-}
-inline const std::string& ServiceDescriptorProto::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void ServiceDescriptorProto::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* ServiceDescriptorProto::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* ServiceDescriptorProto::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void ServiceDescriptorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+inline bool ServiceDescriptorProto::_internal_has_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool ServiceDescriptorProto::has_name() const
+{
+    return _internal_has_name();
+}
+inline void ServiceDescriptorProto::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.name)
-}
-
-// repeated .google.protobuf.MethodDescriptorProto method = 2;
-inline int ServiceDescriptorProto::_internal_method_size() const {
-  return _impl_.method_.size();
-}
-inline int ServiceDescriptorProto::method_size() const {
-  return _internal_method_size();
 }
-inline void ServiceDescriptorProto::clear_method() {
-  _impl_.method_.Clear();
+inline const std::string& ServiceDescriptorProto::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.name)
+    return _internal_name();
 }
-inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.method)
-  return _impl_.method_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >*
-ServiceDescriptorProto::mutable_method() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceDescriptorProto.method)
-  return &_impl_.method_;
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void ServiceDescriptorProto::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.ServiceDescriptorProto.name)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& ServiceDescriptorProto::_internal_method(int index) const {
-  return _impl_.method_.Get(index);
+inline std::string* ServiceDescriptorProto::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.name)
+    return _s;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.method)
-  return _internal_method(index);
+inline const std::string& ServiceDescriptorProto::_internal_name() const
+{
+    return _impl_.name_.Get();
 }
-inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::_internal_add_method() {
-  return _impl_.method_.Add();
+inline void ServiceDescriptorProto::_internal_set_name(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(value, GetArenaForAllocation());
 }
-inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::add_method() {
-  ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* _add = _internal_add_method();
-  // @@protoc_insertion_point(field_add:google.protobuf.ServiceDescriptorProto.method)
-  return _add;
+inline std::string* ServiceDescriptorProto::_internal_mutable_name()
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* ServiceDescriptorProto::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.name)
+    if (!_internal_has_name())
+    {
+        return nullptr;
+    }
+    _impl_._has_bits_[0] &= ~0x00000001u;
+    auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void ServiceDescriptorProto::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.name)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto >&
-ServiceDescriptorProto::method() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.ServiceDescriptorProto.method)
-  return _impl_.method_;
+
+// repeated .google.protobuf.MethodDescriptorProto method = 2;
+inline int ServiceDescriptorProto::_internal_method_size() const
+{
+    return _impl_.method_.size();
+}
+inline int ServiceDescriptorProto::method_size() const
+{
+    return _internal_method_size();
+}
+inline void ServiceDescriptorProto::clear_method()
+{
+    _impl_.method_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.method)
+    return _impl_.method_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>*
+    ServiceDescriptorProto::mutable_method()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceDescriptorProto.method)
+    return &_impl_.method_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& ServiceDescriptorProto::_internal_method(int index) const
+{
+    return _impl_.method_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.method)
+    return _internal_method(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::_internal_add_method()
+{
+    return _impl_.method_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* ServiceDescriptorProto::add_method()
+{
+    ::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto* _add = _internal_add_method();
+    // @@protoc_insertion_point(field_add:google.protobuf.ServiceDescriptorProto.method)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::MethodDescriptorProto>&
+    ServiceDescriptorProto::method() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.ServiceDescriptorProto.method)
+    return _impl_.method_;
 }
 
 // optional .google.protobuf.ServiceOptions options = 3;
-inline bool ServiceDescriptorProto::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool ServiceDescriptorProto::has_options() const {
-  return _internal_has_options();
-}
-inline void ServiceDescriptorProto::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool ServiceDescriptorProto::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool ServiceDescriptorProto::has_options() const
+{
+    return _internal_has_options();
+}
+inline void ServiceDescriptorProto::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& ServiceDescriptorProto::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::ServiceOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::ServiceOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_ServiceOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& ServiceDescriptorProto::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::ServiceOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::ServiceOptions&>(::PROTOBUF_NAMESPACE_ID::_ServiceOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& ServiceDescriptorProto::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::ServiceOptions& ServiceDescriptorProto::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.options)
+    return _internal_options();
 }
 inline void ServiceDescriptorProto::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.ServiceDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.ServiceDescriptorProto.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000002u;
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.options)
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::ServiceOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.options)
-  return _msg;
-}
-inline void ServiceDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::ServiceOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.options)
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ServiceOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::ServiceOptions* ServiceDescriptorProto::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::ServiceOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.options)
+    return _msg;
+}
+inline void ServiceDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::ServiceOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.options)
 }
 
 // -------------------------------------------------------------------
@@ -11575,353 +14297,442 @@ inline void ServiceDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_I
 // MethodDescriptorProto
 
 // optional string name = 1;
-inline bool MethodDescriptorProto::_internal_has_name() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool MethodDescriptorProto::has_name() const {
-  return _internal_has_name();
-}
-inline void MethodDescriptorProto::clear_name() {
-  _impl_.name_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& MethodDescriptorProto::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void MethodDescriptorProto::set_name(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.name)
-}
-inline std::string* MethodDescriptorProto::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.name)
-  return _s;
-}
-inline const std::string& MethodDescriptorProto::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void MethodDescriptorProto::_internal_set_name(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* MethodDescriptorProto::_internal_mutable_name() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* MethodDescriptorProto::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.name)
-  if (!_internal_has_name()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void MethodDescriptorProto::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
+inline bool MethodDescriptorProto::_internal_has_name() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool MethodDescriptorProto::has_name() const
+{
+    return _internal_has_name();
+}
+inline void MethodDescriptorProto::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MethodDescriptorProto::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void MethodDescriptorProto::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.name)
+}
+inline std::string* MethodDescriptorProto::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.name)
+    return _s;
+}
+inline const std::string& MethodDescriptorProto::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void MethodDescriptorProto::_internal_set_name(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::_internal_mutable_name()
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.name)
+    if (!_internal_has_name())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+    auto* p = _impl_.name_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void MethodDescriptorProto::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.name)
 }
 
 // optional string input_type = 2;
-inline bool MethodDescriptorProto::_internal_has_input_type() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool MethodDescriptorProto::has_input_type() const {
-  return _internal_has_input_type();
-}
-inline void MethodDescriptorProto::clear_input_type() {
-  _impl_.input_type_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& MethodDescriptorProto::input_type() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.input_type)
-  return _internal_input_type();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void MethodDescriptorProto::set_input_type(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000002u;
- _impl_.input_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.input_type)
-}
-inline std::string* MethodDescriptorProto::mutable_input_type() {
-  std::string* _s = _internal_mutable_input_type();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.input_type)
-  return _s;
-}
-inline const std::string& MethodDescriptorProto::_internal_input_type() const {
-  return _impl_.input_type_.Get();
-}
-inline void MethodDescriptorProto::_internal_set_input_type(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.input_type_.Set(value, GetArenaForAllocation());
-}
-inline std::string* MethodDescriptorProto::_internal_mutable_input_type() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  return _impl_.input_type_.Mutable(GetArenaForAllocation());
-}
-inline std::string* MethodDescriptorProto::release_input_type() {
-  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.input_type)
-  if (!_internal_has_input_type()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  auto* p = _impl_.input_type_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.input_type_.IsDefault()) {
-    _impl_.input_type_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void MethodDescriptorProto::set_allocated_input_type(std::string* input_type) {
-  if (input_type != nullptr) {
+inline bool MethodDescriptorProto::_internal_has_input_type() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool MethodDescriptorProto::has_input_type() const
+{
+    return _internal_has_input_type();
+}
+inline void MethodDescriptorProto::clear_input_type()
+{
+    _impl_.input_type_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& MethodDescriptorProto::input_type() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.input_type)
+    return _internal_input_type();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void MethodDescriptorProto::set_input_type(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.input_type_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.input_type)
+}
+inline std::string* MethodDescriptorProto::mutable_input_type()
+{
+    std::string* _s = _internal_mutable_input_type();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.input_type)
+    return _s;
+}
+inline const std::string& MethodDescriptorProto::_internal_input_type() const
+{
+    return _impl_.input_type_.Get();
+}
+inline void MethodDescriptorProto::_internal_set_input_type(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.input_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::_internal_mutable_input_type()
+{
     _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+    return _impl_.input_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::release_input_type()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.input_type)
+    if (!_internal_has_input_type())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.input_type_.SetAllocated(input_type, GetArenaForAllocation());
+    auto* p = _impl_.input_type_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.input_type_.IsDefault())
+    {
+        _impl_.input_type_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void MethodDescriptorProto::set_allocated_input_type(std::string* input_type)
+{
+    if (input_type != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.input_type_.SetAllocated(input_type, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.input_type_.IsDefault()) {
-    _impl_.input_type_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.input_type)
+    if (_impl_.input_type_.IsDefault())
+    {
+        _impl_.input_type_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.input_type)
 }
 
 // optional string output_type = 3;
-inline bool MethodDescriptorProto::_internal_has_output_type() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool MethodDescriptorProto::has_output_type() const {
-  return _internal_has_output_type();
-}
-inline void MethodDescriptorProto::clear_output_type() {
-  _impl_.output_type_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& MethodDescriptorProto::output_type() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.output_type)
-  return _internal_output_type();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void MethodDescriptorProto::set_output_type(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000004u;
- _impl_.output_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.output_type)
-}
-inline std::string* MethodDescriptorProto::mutable_output_type() {
-  std::string* _s = _internal_mutable_output_type();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.output_type)
-  return _s;
-}
-inline const std::string& MethodDescriptorProto::_internal_output_type() const {
-  return _impl_.output_type_.Get();
-}
-inline void MethodDescriptorProto::_internal_set_output_type(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.output_type_.Set(value, GetArenaForAllocation());
-}
-inline std::string* MethodDescriptorProto::_internal_mutable_output_type() {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  return _impl_.output_type_.Mutable(GetArenaForAllocation());
-}
-inline std::string* MethodDescriptorProto::release_output_type() {
-  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.output_type)
-  if (!_internal_has_output_type()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000004u;
-  auto* p = _impl_.output_type_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.output_type_.IsDefault()) {
-    _impl_.output_type_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void MethodDescriptorProto::set_allocated_output_type(std::string* output_type) {
-  if (output_type != nullptr) {
+inline bool MethodDescriptorProto::_internal_has_output_type() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool MethodDescriptorProto::has_output_type() const
+{
+    return _internal_has_output_type();
+}
+inline void MethodDescriptorProto::clear_output_type()
+{
+    _impl_.output_type_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& MethodDescriptorProto::output_type() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.output_type)
+    return _internal_output_type();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void MethodDescriptorProto::set_output_type(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.output_type_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.output_type)
+}
+inline std::string* MethodDescriptorProto::mutable_output_type()
+{
+    std::string* _s = _internal_mutable_output_type();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.output_type)
+    return _s;
+}
+inline const std::string& MethodDescriptorProto::_internal_output_type() const
+{
+    return _impl_.output_type_.Get();
+}
+inline void MethodDescriptorProto::_internal_set_output_type(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.output_type_.Set(value, GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::_internal_mutable_output_type()
+{
     _impl_._has_bits_[0] |= 0x00000004u;
-  } else {
+    return _impl_.output_type_.Mutable(GetArenaForAllocation());
+}
+inline std::string* MethodDescriptorProto::release_output_type()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.output_type)
+    if (!_internal_has_output_type())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000004u;
-  }
-  _impl_.output_type_.SetAllocated(output_type, GetArenaForAllocation());
+    auto* p = _impl_.output_type_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.output_type_.IsDefault())
+    {
+        _impl_.output_type_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void MethodDescriptorProto::set_allocated_output_type(std::string* output_type)
+{
+    if (output_type != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000004u;
+    }
+    _impl_.output_type_.SetAllocated(output_type, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.output_type_.IsDefault()) {
-    _impl_.output_type_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.output_type)
+    if (_impl_.output_type_.IsDefault())
+    {
+        _impl_.output_type_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.output_type)
 }
 
 // optional .google.protobuf.MethodOptions options = 4;
-inline bool MethodDescriptorProto::_internal_has_options() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
-  return value;
-}
-inline bool MethodDescriptorProto::has_options() const {
-  return _internal_has_options();
-}
-inline void MethodDescriptorProto::clear_options() {
-  if (_impl_.options_ != nullptr) _impl_.options_->Clear();
-  _impl_._has_bits_[0] &= ~0x00000008u;
+inline bool MethodDescriptorProto::_internal_has_options() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+    PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
+    return value;
+}
+inline bool MethodDescriptorProto::has_options() const
+{
+    return _internal_has_options();
+}
+inline void MethodDescriptorProto::clear_options()
+{
+    if (_impl_.options_ != nullptr)
+        _impl_.options_->Clear();
+    _impl_._has_bits_[0] &= ~0x00000008u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::MethodOptions& MethodDescriptorProto::_internal_options() const {
-  const ::PROTOBUF_NAMESPACE_ID::MethodOptions* p = _impl_.options_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::MethodOptions&>(
-      ::PROTOBUF_NAMESPACE_ID::_MethodOptions_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::MethodOptions& MethodDescriptorProto::_internal_options() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::MethodOptions* p = _impl_.options_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::MethodOptions&>(::PROTOBUF_NAMESPACE_ID::_MethodOptions_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::MethodOptions& MethodDescriptorProto::options() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.options)
-  return _internal_options();
+inline const ::PROTOBUF_NAMESPACE_ID::MethodOptions& MethodDescriptorProto::options() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.options)
+    return _internal_options();
 }
 inline void MethodDescriptorProto::unsafe_arena_set_allocated_options(
-    ::PROTOBUF_NAMESPACE_ID::MethodOptions* options) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
-  }
-  _impl_.options_ = options;
-  if (options) {
-    _impl_._has_bits_[0] |= 0x00000008u;
-  } else {
-    _impl_._has_bits_[0] &= ~0x00000008u;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.MethodDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* options
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
+    }
+    _impl_.options_ = options;
+    if (options)
+    {
+        _impl_._has_bits_[0] |= 0x00000008u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000008u;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.MethodDescriptorProto.options)
 }
-inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::release_options() {
-  _impl_._has_bits_[0] &= ~0x00000008u;
-  ::PROTOBUF_NAMESPACE_ID::MethodOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::release_options()
+{
+    _impl_._has_bits_[0] &= ~0x00000008u;
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
-#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::unsafe_arena_release_options() {
-  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.options)
-  _impl_._has_bits_[0] &= ~0x00000008u;
-  ::PROTOBUF_NAMESPACE_ID::MethodOptions* temp = _impl_.options_;
-  _impl_.options_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::_internal_mutable_options() {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  if (_impl_.options_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodOptions>(GetArenaForAllocation());
-    _impl_.options_ = p;
-  }
-  return _impl_.options_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::mutable_options() {
-  ::PROTOBUF_NAMESPACE_ID::MethodOptions* _msg = _internal_mutable_options();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.options)
-  return _msg;
-}
-inline void MethodDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::MethodOptions* options) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete _impl_.options_;
-  }
-  if (options) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
-    if (message_arena != submessage_arena) {
-      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, options, submessage_arena);
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
     }
-    _impl_._has_bits_[0] |= 0x00000008u;
-  } else {
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::unsafe_arena_release_options()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.options)
     _impl_._has_bits_[0] &= ~0x00000008u;
-  }
-  _impl_.options_ = options;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.options)
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* temp = _impl_.options_;
+    _impl_.options_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::_internal_mutable_options()
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    if (_impl_.options_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::MethodOptions>(GetArenaForAllocation());
+        _impl_.options_ = p;
+    }
+    return _impl_.options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions* MethodDescriptorProto::mutable_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::MethodOptions* _msg = _internal_mutable_options();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.options)
+    return _msg;
+}
+inline void MethodDescriptorProto::set_allocated_options(::PROTOBUF_NAMESPACE_ID::MethodOptions* options)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete _impl_.options_;
+    }
+    if (options)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
+        if (message_arena != submessage_arena)
+        {
+            options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, options, submessage_arena
+            );
+        }
+        _impl_._has_bits_[0] |= 0x00000008u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000008u;
+    }
+    _impl_.options_ = options;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.options)
 }
 
 // optional bool client_streaming = 5 [default = false];
-inline bool MethodDescriptorProto::_internal_has_client_streaming() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
-  return value;
-}
-inline bool MethodDescriptorProto::has_client_streaming() const {
-  return _internal_has_client_streaming();
-}
-inline void MethodDescriptorProto::clear_client_streaming() {
-  _impl_.client_streaming_ = false;
-  _impl_._has_bits_[0] &= ~0x00000010u;
+inline bool MethodDescriptorProto::_internal_has_client_streaming() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+    return value;
+}
+inline bool MethodDescriptorProto::has_client_streaming() const
+{
+    return _internal_has_client_streaming();
+}
+inline void MethodDescriptorProto::clear_client_streaming()
+{
+    _impl_.client_streaming_ = false;
+    _impl_._has_bits_[0] &= ~0x00000010u;
 }
-inline bool MethodDescriptorProto::_internal_client_streaming() const {
-  return _impl_.client_streaming_;
+inline bool MethodDescriptorProto::_internal_client_streaming() const
+{
+    return _impl_.client_streaming_;
 }
-inline bool MethodDescriptorProto::client_streaming() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.client_streaming)
-  return _internal_client_streaming();
+inline bool MethodDescriptorProto::client_streaming() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.client_streaming)
+    return _internal_client_streaming();
 }
-inline void MethodDescriptorProto::_internal_set_client_streaming(bool value) {
-  _impl_._has_bits_[0] |= 0x00000010u;
-  _impl_.client_streaming_ = value;
+inline void MethodDescriptorProto::_internal_set_client_streaming(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000010u;
+    _impl_.client_streaming_ = value;
 }
-inline void MethodDescriptorProto::set_client_streaming(bool value) {
-  _internal_set_client_streaming(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.client_streaming)
+inline void MethodDescriptorProto::set_client_streaming(bool value)
+{
+    _internal_set_client_streaming(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.client_streaming)
 }
 
 // optional bool server_streaming = 6 [default = false];
-inline bool MethodDescriptorProto::_internal_has_server_streaming() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
-  return value;
-}
-inline bool MethodDescriptorProto::has_server_streaming() const {
-  return _internal_has_server_streaming();
-}
-inline void MethodDescriptorProto::clear_server_streaming() {
-  _impl_.server_streaming_ = false;
-  _impl_._has_bits_[0] &= ~0x00000020u;
+inline bool MethodDescriptorProto::_internal_has_server_streaming() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+    return value;
+}
+inline bool MethodDescriptorProto::has_server_streaming() const
+{
+    return _internal_has_server_streaming();
+}
+inline void MethodDescriptorProto::clear_server_streaming()
+{
+    _impl_.server_streaming_ = false;
+    _impl_._has_bits_[0] &= ~0x00000020u;
 }
-inline bool MethodDescriptorProto::_internal_server_streaming() const {
-  return _impl_.server_streaming_;
+inline bool MethodDescriptorProto::_internal_server_streaming() const
+{
+    return _impl_.server_streaming_;
 }
-inline bool MethodDescriptorProto::server_streaming() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.server_streaming)
-  return _internal_server_streaming();
+inline bool MethodDescriptorProto::server_streaming() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.server_streaming)
+    return _internal_server_streaming();
 }
-inline void MethodDescriptorProto::_internal_set_server_streaming(bool value) {
-  _impl_._has_bits_[0] |= 0x00000020u;
-  _impl_.server_streaming_ = value;
+inline void MethodDescriptorProto::_internal_set_server_streaming(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000020u;
+    _impl_.server_streaming_ = value;
 }
-inline void MethodDescriptorProto::set_server_streaming(bool value) {
-  _internal_set_server_streaming(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.server_streaming)
+inline void MethodDescriptorProto::set_server_streaming(bool value)
+{
+    _internal_set_server_streaming(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.server_streaming)
 }
 
 // -------------------------------------------------------------------
@@ -11929,1004 +14740,1244 @@ inline void MethodDescriptorProto::set_server_streaming(bool value) {
 // FileOptions
 
 // optional string java_package = 1;
-inline bool FileOptions::_internal_has_java_package() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool FileOptions::has_java_package() const {
-  return _internal_has_java_package();
-}
-inline void FileOptions::clear_java_package() {
-  _impl_.java_package_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& FileOptions::java_package() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_package)
-  return _internal_java_package();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_java_package(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.java_package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_package)
-}
-inline std::string* FileOptions::mutable_java_package() {
-  std::string* _s = _internal_mutable_java_package();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_package)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_java_package() const {
-  return _impl_.java_package_.Get();
-}
-inline void FileOptions::_internal_set_java_package(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.java_package_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_java_package() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.java_package_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_java_package() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_package)
-  if (!_internal_has_java_package()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.java_package_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.java_package_.IsDefault()) {
-    _impl_.java_package_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_java_package(std::string* java_package) {
-  if (java_package != nullptr) {
+inline bool FileOptions::_internal_has_java_package() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool FileOptions::has_java_package() const
+{
+    return _internal_has_java_package();
+}
+inline void FileOptions::clear_java_package()
+{
+    _impl_.java_package_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& FileOptions::java_package() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_package)
+    return _internal_java_package();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_java_package(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.java_package_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_package)
+}
+inline std::string* FileOptions::mutable_java_package()
+{
+    std::string* _s = _internal_mutable_java_package();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_package)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_java_package() const
+{
+    return _impl_.java_package_.Get();
+}
+inline void FileOptions::_internal_set_java_package(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.java_package_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_java_package()
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    return _impl_.java_package_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_java_package()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_package)
+    if (!_internal_has_java_package())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.java_package_.SetAllocated(java_package, GetArenaForAllocation());
+    auto* p = _impl_.java_package_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.java_package_.IsDefault())
+    {
+        _impl_.java_package_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_java_package(std::string* java_package)
+{
+    if (java_package != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.java_package_.SetAllocated(java_package, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.java_package_.IsDefault()) {
-    _impl_.java_package_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_package)
+    if (_impl_.java_package_.IsDefault())
+    {
+        _impl_.java_package_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_package)
 }
 
 // optional string java_outer_classname = 8;
-inline bool FileOptions::_internal_has_java_outer_classname() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool FileOptions::has_java_outer_classname() const {
-  return _internal_has_java_outer_classname();
-}
-inline void FileOptions::clear_java_outer_classname() {
-  _impl_.java_outer_classname_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& FileOptions::java_outer_classname() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_outer_classname)
-  return _internal_java_outer_classname();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_java_outer_classname(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000002u;
- _impl_.java_outer_classname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_outer_classname)
-}
-inline std::string* FileOptions::mutable_java_outer_classname() {
-  std::string* _s = _internal_mutable_java_outer_classname();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_outer_classname)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_java_outer_classname() const {
-  return _impl_.java_outer_classname_.Get();
-}
-inline void FileOptions::_internal_set_java_outer_classname(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.java_outer_classname_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_java_outer_classname() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  return _impl_.java_outer_classname_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_java_outer_classname() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_outer_classname)
-  if (!_internal_has_java_outer_classname()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  auto* p = _impl_.java_outer_classname_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.java_outer_classname_.IsDefault()) {
-    _impl_.java_outer_classname_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_java_outer_classname(std::string* java_outer_classname) {
-  if (java_outer_classname != nullptr) {
+inline bool FileOptions::_internal_has_java_outer_classname() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool FileOptions::has_java_outer_classname() const
+{
+    return _internal_has_java_outer_classname();
+}
+inline void FileOptions::clear_java_outer_classname()
+{
+    _impl_.java_outer_classname_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& FileOptions::java_outer_classname() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_outer_classname)
+    return _internal_java_outer_classname();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_java_outer_classname(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.java_outer_classname_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_outer_classname)
+}
+inline std::string* FileOptions::mutable_java_outer_classname()
+{
+    std::string* _s = _internal_mutable_java_outer_classname();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_outer_classname)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_java_outer_classname() const
+{
+    return _impl_.java_outer_classname_.Get();
+}
+inline void FileOptions::_internal_set_java_outer_classname(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.java_outer_classname_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_java_outer_classname()
+{
     _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+    return _impl_.java_outer_classname_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_java_outer_classname()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_outer_classname)
+    if (!_internal_has_java_outer_classname())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.java_outer_classname_.SetAllocated(java_outer_classname, GetArenaForAllocation());
+    auto* p = _impl_.java_outer_classname_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.java_outer_classname_.IsDefault())
+    {
+        _impl_.java_outer_classname_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_java_outer_classname(std::string* java_outer_classname)
+{
+    if (java_outer_classname != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.java_outer_classname_.SetAllocated(java_outer_classname, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.java_outer_classname_.IsDefault()) {
-    _impl_.java_outer_classname_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_outer_classname)
+    if (_impl_.java_outer_classname_.IsDefault())
+    {
+        _impl_.java_outer_classname_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_outer_classname)
 }
 
 // optional bool java_multiple_files = 10 [default = false];
-inline bool FileOptions::_internal_has_java_multiple_files() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_java_multiple_files() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
+    return value;
 }
-inline bool FileOptions::has_java_multiple_files() const {
-  return _internal_has_java_multiple_files();
+inline bool FileOptions::has_java_multiple_files() const
+{
+    return _internal_has_java_multiple_files();
 }
-inline void FileOptions::clear_java_multiple_files() {
-  _impl_.java_multiple_files_ = false;
-  _impl_._has_bits_[0] &= ~0x00000400u;
+inline void FileOptions::clear_java_multiple_files()
+{
+    _impl_.java_multiple_files_ = false;
+    _impl_._has_bits_[0] &= ~0x00000400u;
 }
-inline bool FileOptions::_internal_java_multiple_files() const {
-  return _impl_.java_multiple_files_;
+inline bool FileOptions::_internal_java_multiple_files() const
+{
+    return _impl_.java_multiple_files_;
 }
-inline bool FileOptions::java_multiple_files() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_multiple_files)
-  return _internal_java_multiple_files();
+inline bool FileOptions::java_multiple_files() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_multiple_files)
+    return _internal_java_multiple_files();
 }
-inline void FileOptions::_internal_set_java_multiple_files(bool value) {
-  _impl_._has_bits_[0] |= 0x00000400u;
-  _impl_.java_multiple_files_ = value;
+inline void FileOptions::_internal_set_java_multiple_files(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000400u;
+    _impl_.java_multiple_files_ = value;
 }
-inline void FileOptions::set_java_multiple_files(bool value) {
-  _internal_set_java_multiple_files(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_multiple_files)
+inline void FileOptions::set_java_multiple_files(bool value)
+{
+    _internal_set_java_multiple_files(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_multiple_files)
 }
 
 // optional bool java_generate_equals_and_hash = 20 [deprecated = true];
-inline bool FileOptions::_internal_has_java_generate_equals_and_hash() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_java_generate_equals_and_hash() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
+    return value;
 }
-inline bool FileOptions::has_java_generate_equals_and_hash() const {
-  return _internal_has_java_generate_equals_and_hash();
+inline bool FileOptions::has_java_generate_equals_and_hash() const
+{
+    return _internal_has_java_generate_equals_and_hash();
 }
-inline void FileOptions::clear_java_generate_equals_and_hash() {
-  _impl_.java_generate_equals_and_hash_ = false;
-  _impl_._has_bits_[0] &= ~0x00000800u;
+inline void FileOptions::clear_java_generate_equals_and_hash()
+{
+    _impl_.java_generate_equals_and_hash_ = false;
+    _impl_._has_bits_[0] &= ~0x00000800u;
 }
-inline bool FileOptions::_internal_java_generate_equals_and_hash() const {
-  return _impl_.java_generate_equals_and_hash_;
+inline bool FileOptions::_internal_java_generate_equals_and_hash() const
+{
+    return _impl_.java_generate_equals_and_hash_;
 }
-inline bool FileOptions::java_generate_equals_and_hash() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generate_equals_and_hash)
-  return _internal_java_generate_equals_and_hash();
+inline bool FileOptions::java_generate_equals_and_hash() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generate_equals_and_hash)
+    return _internal_java_generate_equals_and_hash();
 }
-inline void FileOptions::_internal_set_java_generate_equals_and_hash(bool value) {
-  _impl_._has_bits_[0] |= 0x00000800u;
-  _impl_.java_generate_equals_and_hash_ = value;
+inline void FileOptions::_internal_set_java_generate_equals_and_hash(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000800u;
+    _impl_.java_generate_equals_and_hash_ = value;
 }
-inline void FileOptions::set_java_generate_equals_and_hash(bool value) {
-  _internal_set_java_generate_equals_and_hash(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generate_equals_and_hash)
+inline void FileOptions::set_java_generate_equals_and_hash(bool value)
+{
+    _internal_set_java_generate_equals_and_hash(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generate_equals_and_hash)
 }
 
 // optional bool java_string_check_utf8 = 27 [default = false];
-inline bool FileOptions::_internal_has_java_string_check_utf8() const {
-  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_java_string_check_utf8() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
+    return value;
 }
-inline bool FileOptions::has_java_string_check_utf8() const {
-  return _internal_has_java_string_check_utf8();
+inline bool FileOptions::has_java_string_check_utf8() const
+{
+    return _internal_has_java_string_check_utf8();
 }
-inline void FileOptions::clear_java_string_check_utf8() {
-  _impl_.java_string_check_utf8_ = false;
-  _impl_._has_bits_[0] &= ~0x00001000u;
+inline void FileOptions::clear_java_string_check_utf8()
+{
+    _impl_.java_string_check_utf8_ = false;
+    _impl_._has_bits_[0] &= ~0x00001000u;
 }
-inline bool FileOptions::_internal_java_string_check_utf8() const {
-  return _impl_.java_string_check_utf8_;
+inline bool FileOptions::_internal_java_string_check_utf8() const
+{
+    return _impl_.java_string_check_utf8_;
 }
-inline bool FileOptions::java_string_check_utf8() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_string_check_utf8)
-  return _internal_java_string_check_utf8();
+inline bool FileOptions::java_string_check_utf8() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_string_check_utf8)
+    return _internal_java_string_check_utf8();
 }
-inline void FileOptions::_internal_set_java_string_check_utf8(bool value) {
-  _impl_._has_bits_[0] |= 0x00001000u;
-  _impl_.java_string_check_utf8_ = value;
+inline void FileOptions::_internal_set_java_string_check_utf8(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00001000u;
+    _impl_.java_string_check_utf8_ = value;
 }
-inline void FileOptions::set_java_string_check_utf8(bool value) {
-  _internal_set_java_string_check_utf8(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_string_check_utf8)
+inline void FileOptions::set_java_string_check_utf8(bool value)
+{
+    _internal_set_java_string_check_utf8(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_string_check_utf8)
 }
 
 // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
-inline bool FileOptions::_internal_has_optimize_for() const {
-  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_optimize_for() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
+    return value;
 }
-inline bool FileOptions::has_optimize_for() const {
-  return _internal_has_optimize_for();
+inline bool FileOptions::has_optimize_for() const
+{
+    return _internal_has_optimize_for();
 }
-inline void FileOptions::clear_optimize_for() {
-  _impl_.optimize_for_ = 1;
-  _impl_._has_bits_[0] &= ~0x00040000u;
+inline void FileOptions::clear_optimize_for()
+{
+    _impl_.optimize_for_ = 1;
+    _impl_._has_bits_[0] &= ~0x00040000u;
 }
-inline ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode FileOptions::_internal_optimize_for() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode >(_impl_.optimize_for_);
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode FileOptions::_internal_optimize_for() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode>(_impl_.optimize_for_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode FileOptions::optimize_for() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.optimize_for)
-  return _internal_optimize_for();
+inline ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode FileOptions::optimize_for() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.optimize_for)
+    return _internal_optimize_for();
 }
-inline void FileOptions::_internal_set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value) {
-  assert(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_IsValid(value));
-  _impl_._has_bits_[0] |= 0x00040000u;
-  _impl_.optimize_for_ = value;
+inline void FileOptions::_internal_set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value)
+{
+    assert(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_IsValid(value));
+    _impl_._has_bits_[0] |= 0x00040000u;
+    _impl_.optimize_for_ = value;
 }
-inline void FileOptions::set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value) {
-  _internal_set_optimize_for(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.optimize_for)
+inline void FileOptions::set_optimize_for(::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode value)
+{
+    _internal_set_optimize_for(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.optimize_for)
 }
 
 // optional string go_package = 11;
-inline bool FileOptions::_internal_has_go_package() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool FileOptions::has_go_package() const {
-  return _internal_has_go_package();
-}
-inline void FileOptions::clear_go_package() {
-  _impl_.go_package_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& FileOptions::go_package() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.go_package)
-  return _internal_go_package();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_go_package(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000004u;
- _impl_.go_package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.go_package)
-}
-inline std::string* FileOptions::mutable_go_package() {
-  std::string* _s = _internal_mutable_go_package();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.go_package)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_go_package() const {
-  return _impl_.go_package_.Get();
-}
-inline void FileOptions::_internal_set_go_package(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.go_package_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_go_package() {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  return _impl_.go_package_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_go_package() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.go_package)
-  if (!_internal_has_go_package()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000004u;
-  auto* p = _impl_.go_package_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.go_package_.IsDefault()) {
-    _impl_.go_package_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_go_package(std::string* go_package) {
-  if (go_package != nullptr) {
+inline bool FileOptions::_internal_has_go_package() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool FileOptions::has_go_package() const
+{
+    return _internal_has_go_package();
+}
+inline void FileOptions::clear_go_package()
+{
+    _impl_.go_package_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& FileOptions::go_package() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.go_package)
+    return _internal_go_package();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_go_package(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.go_package_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.go_package)
+}
+inline std::string* FileOptions::mutable_go_package()
+{
+    std::string* _s = _internal_mutable_go_package();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.go_package)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_go_package() const
+{
+    return _impl_.go_package_.Get();
+}
+inline void FileOptions::_internal_set_go_package(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.go_package_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_go_package()
+{
     _impl_._has_bits_[0] |= 0x00000004u;
-  } else {
+    return _impl_.go_package_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_go_package()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.go_package)
+    if (!_internal_has_go_package())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000004u;
-  }
-  _impl_.go_package_.SetAllocated(go_package, GetArenaForAllocation());
+    auto* p = _impl_.go_package_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.go_package_.IsDefault())
+    {
+        _impl_.go_package_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_go_package(std::string* go_package)
+{
+    if (go_package != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000004u;
+    }
+    _impl_.go_package_.SetAllocated(go_package, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.go_package_.IsDefault()) {
-    _impl_.go_package_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.go_package)
+    if (_impl_.go_package_.IsDefault())
+    {
+        _impl_.go_package_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.go_package)
 }
 
 // optional bool cc_generic_services = 16 [default = false];
-inline bool FileOptions::_internal_has_cc_generic_services() const {
-  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_cc_generic_services() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
+    return value;
 }
-inline bool FileOptions::has_cc_generic_services() const {
-  return _internal_has_cc_generic_services();
+inline bool FileOptions::has_cc_generic_services() const
+{
+    return _internal_has_cc_generic_services();
 }
-inline void FileOptions::clear_cc_generic_services() {
-  _impl_.cc_generic_services_ = false;
-  _impl_._has_bits_[0] &= ~0x00002000u;
+inline void FileOptions::clear_cc_generic_services()
+{
+    _impl_.cc_generic_services_ = false;
+    _impl_._has_bits_[0] &= ~0x00002000u;
 }
-inline bool FileOptions::_internal_cc_generic_services() const {
-  return _impl_.cc_generic_services_;
+inline bool FileOptions::_internal_cc_generic_services() const
+{
+    return _impl_.cc_generic_services_;
 }
-inline bool FileOptions::cc_generic_services() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_generic_services)
-  return _internal_cc_generic_services();
+inline bool FileOptions::cc_generic_services() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_generic_services)
+    return _internal_cc_generic_services();
 }
-inline void FileOptions::_internal_set_cc_generic_services(bool value) {
-  _impl_._has_bits_[0] |= 0x00002000u;
-  _impl_.cc_generic_services_ = value;
+inline void FileOptions::_internal_set_cc_generic_services(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00002000u;
+    _impl_.cc_generic_services_ = value;
 }
-inline void FileOptions::set_cc_generic_services(bool value) {
-  _internal_set_cc_generic_services(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_generic_services)
+inline void FileOptions::set_cc_generic_services(bool value)
+{
+    _internal_set_cc_generic_services(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_generic_services)
 }
 
 // optional bool java_generic_services = 17 [default = false];
-inline bool FileOptions::_internal_has_java_generic_services() const {
-  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_java_generic_services() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
+    return value;
 }
-inline bool FileOptions::has_java_generic_services() const {
-  return _internal_has_java_generic_services();
+inline bool FileOptions::has_java_generic_services() const
+{
+    return _internal_has_java_generic_services();
 }
-inline void FileOptions::clear_java_generic_services() {
-  _impl_.java_generic_services_ = false;
-  _impl_._has_bits_[0] &= ~0x00004000u;
+inline void FileOptions::clear_java_generic_services()
+{
+    _impl_.java_generic_services_ = false;
+    _impl_._has_bits_[0] &= ~0x00004000u;
 }
-inline bool FileOptions::_internal_java_generic_services() const {
-  return _impl_.java_generic_services_;
+inline bool FileOptions::_internal_java_generic_services() const
+{
+    return _impl_.java_generic_services_;
 }
-inline bool FileOptions::java_generic_services() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generic_services)
-  return _internal_java_generic_services();
+inline bool FileOptions::java_generic_services() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generic_services)
+    return _internal_java_generic_services();
 }
-inline void FileOptions::_internal_set_java_generic_services(bool value) {
-  _impl_._has_bits_[0] |= 0x00004000u;
-  _impl_.java_generic_services_ = value;
+inline void FileOptions::_internal_set_java_generic_services(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00004000u;
+    _impl_.java_generic_services_ = value;
 }
-inline void FileOptions::set_java_generic_services(bool value) {
-  _internal_set_java_generic_services(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generic_services)
+inline void FileOptions::set_java_generic_services(bool value)
+{
+    _internal_set_java_generic_services(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generic_services)
 }
 
 // optional bool py_generic_services = 18 [default = false];
-inline bool FileOptions::_internal_has_py_generic_services() const {
-  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_py_generic_services() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
+    return value;
 }
-inline bool FileOptions::has_py_generic_services() const {
-  return _internal_has_py_generic_services();
+inline bool FileOptions::has_py_generic_services() const
+{
+    return _internal_has_py_generic_services();
 }
-inline void FileOptions::clear_py_generic_services() {
-  _impl_.py_generic_services_ = false;
-  _impl_._has_bits_[0] &= ~0x00008000u;
+inline void FileOptions::clear_py_generic_services()
+{
+    _impl_.py_generic_services_ = false;
+    _impl_._has_bits_[0] &= ~0x00008000u;
 }
-inline bool FileOptions::_internal_py_generic_services() const {
-  return _impl_.py_generic_services_;
+inline bool FileOptions::_internal_py_generic_services() const
+{
+    return _impl_.py_generic_services_;
 }
-inline bool FileOptions::py_generic_services() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.py_generic_services)
-  return _internal_py_generic_services();
+inline bool FileOptions::py_generic_services() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.py_generic_services)
+    return _internal_py_generic_services();
 }
-inline void FileOptions::_internal_set_py_generic_services(bool value) {
-  _impl_._has_bits_[0] |= 0x00008000u;
-  _impl_.py_generic_services_ = value;
+inline void FileOptions::_internal_set_py_generic_services(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00008000u;
+    _impl_.py_generic_services_ = value;
 }
-inline void FileOptions::set_py_generic_services(bool value) {
-  _internal_set_py_generic_services(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.py_generic_services)
+inline void FileOptions::set_py_generic_services(bool value)
+{
+    _internal_set_py_generic_services(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.py_generic_services)
 }
 
 // optional bool php_generic_services = 42 [default = false];
-inline bool FileOptions::_internal_has_php_generic_services() const {
-  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_php_generic_services() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
+    return value;
 }
-inline bool FileOptions::has_php_generic_services() const {
-  return _internal_has_php_generic_services();
+inline bool FileOptions::has_php_generic_services() const
+{
+    return _internal_has_php_generic_services();
 }
-inline void FileOptions::clear_php_generic_services() {
-  _impl_.php_generic_services_ = false;
-  _impl_._has_bits_[0] &= ~0x00010000u;
+inline void FileOptions::clear_php_generic_services()
+{
+    _impl_.php_generic_services_ = false;
+    _impl_._has_bits_[0] &= ~0x00010000u;
 }
-inline bool FileOptions::_internal_php_generic_services() const {
-  return _impl_.php_generic_services_;
+inline bool FileOptions::_internal_php_generic_services() const
+{
+    return _impl_.php_generic_services_;
 }
-inline bool FileOptions::php_generic_services() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_generic_services)
-  return _internal_php_generic_services();
+inline bool FileOptions::php_generic_services() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_generic_services)
+    return _internal_php_generic_services();
 }
-inline void FileOptions::_internal_set_php_generic_services(bool value) {
-  _impl_._has_bits_[0] |= 0x00010000u;
-  _impl_.php_generic_services_ = value;
+inline void FileOptions::_internal_set_php_generic_services(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00010000u;
+    _impl_.php_generic_services_ = value;
 }
-inline void FileOptions::set_php_generic_services(bool value) {
-  _internal_set_php_generic_services(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_generic_services)
+inline void FileOptions::set_php_generic_services(bool value)
+{
+    _internal_set_php_generic_services(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_generic_services)
 }
 
 // optional bool deprecated = 23 [default = false];
-inline bool FileOptions::_internal_has_deprecated() const {
-  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_deprecated() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
+    return value;
 }
-inline bool FileOptions::has_deprecated() const {
-  return _internal_has_deprecated();
+inline bool FileOptions::has_deprecated() const
+{
+    return _internal_has_deprecated();
 }
-inline void FileOptions::clear_deprecated() {
-  _impl_.deprecated_ = false;
-  _impl_._has_bits_[0] &= ~0x00020000u;
+inline void FileOptions::clear_deprecated()
+{
+    _impl_.deprecated_ = false;
+    _impl_._has_bits_[0] &= ~0x00020000u;
 }
-inline bool FileOptions::_internal_deprecated() const {
-  return _impl_.deprecated_;
+inline bool FileOptions::_internal_deprecated() const
+{
+    return _impl_.deprecated_;
 }
-inline bool FileOptions::deprecated() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.deprecated)
-  return _internal_deprecated();
+inline bool FileOptions::deprecated() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.deprecated)
+    return _internal_deprecated();
 }
-inline void FileOptions::_internal_set_deprecated(bool value) {
-  _impl_._has_bits_[0] |= 0x00020000u;
-  _impl_.deprecated_ = value;
+inline void FileOptions::_internal_set_deprecated(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00020000u;
+    _impl_.deprecated_ = value;
 }
-inline void FileOptions::set_deprecated(bool value) {
-  _internal_set_deprecated(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.deprecated)
+inline void FileOptions::set_deprecated(bool value)
+{
+    _internal_set_deprecated(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.deprecated)
 }
 
 // optional bool cc_enable_arenas = 31 [default = true];
-inline bool FileOptions::_internal_has_cc_enable_arenas() const {
-  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
-  return value;
+inline bool FileOptions::_internal_has_cc_enable_arenas() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
+    return value;
 }
-inline bool FileOptions::has_cc_enable_arenas() const {
-  return _internal_has_cc_enable_arenas();
+inline bool FileOptions::has_cc_enable_arenas() const
+{
+    return _internal_has_cc_enable_arenas();
 }
-inline void FileOptions::clear_cc_enable_arenas() {
-  _impl_.cc_enable_arenas_ = true;
-  _impl_._has_bits_[0] &= ~0x00080000u;
+inline void FileOptions::clear_cc_enable_arenas()
+{
+    _impl_.cc_enable_arenas_ = true;
+    _impl_._has_bits_[0] &= ~0x00080000u;
 }
-inline bool FileOptions::_internal_cc_enable_arenas() const {
-  return _impl_.cc_enable_arenas_;
+inline bool FileOptions::_internal_cc_enable_arenas() const
+{
+    return _impl_.cc_enable_arenas_;
 }
-inline bool FileOptions::cc_enable_arenas() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_enable_arenas)
-  return _internal_cc_enable_arenas();
+inline bool FileOptions::cc_enable_arenas() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_enable_arenas)
+    return _internal_cc_enable_arenas();
 }
-inline void FileOptions::_internal_set_cc_enable_arenas(bool value) {
-  _impl_._has_bits_[0] |= 0x00080000u;
-  _impl_.cc_enable_arenas_ = value;
+inline void FileOptions::_internal_set_cc_enable_arenas(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00080000u;
+    _impl_.cc_enable_arenas_ = value;
 }
-inline void FileOptions::set_cc_enable_arenas(bool value) {
-  _internal_set_cc_enable_arenas(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_enable_arenas)
+inline void FileOptions::set_cc_enable_arenas(bool value)
+{
+    _internal_set_cc_enable_arenas(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_enable_arenas)
 }
 
 // optional string objc_class_prefix = 36;
-inline bool FileOptions::_internal_has_objc_class_prefix() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool FileOptions::has_objc_class_prefix() const {
-  return _internal_has_objc_class_prefix();
-}
-inline void FileOptions::clear_objc_class_prefix() {
-  _impl_.objc_class_prefix_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000008u;
-}
-inline const std::string& FileOptions::objc_class_prefix() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.objc_class_prefix)
-  return _internal_objc_class_prefix();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_objc_class_prefix(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000008u;
- _impl_.objc_class_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.objc_class_prefix)
-}
-inline std::string* FileOptions::mutable_objc_class_prefix() {
-  std::string* _s = _internal_mutable_objc_class_prefix();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.objc_class_prefix)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_objc_class_prefix() const {
-  return _impl_.objc_class_prefix_.Get();
-}
-inline void FileOptions::_internal_set_objc_class_prefix(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  _impl_.objc_class_prefix_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_objc_class_prefix() {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  return _impl_.objc_class_prefix_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_objc_class_prefix() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.objc_class_prefix)
-  if (!_internal_has_objc_class_prefix()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000008u;
-  auto* p = _impl_.objc_class_prefix_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.objc_class_prefix_.IsDefault()) {
-    _impl_.objc_class_prefix_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_objc_class_prefix(std::string* objc_class_prefix) {
-  if (objc_class_prefix != nullptr) {
+inline bool FileOptions::_internal_has_objc_class_prefix() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+    return value;
+}
+inline bool FileOptions::has_objc_class_prefix() const
+{
+    return _internal_has_objc_class_prefix();
+}
+inline void FileOptions::clear_objc_class_prefix()
+{
+    _impl_.objc_class_prefix_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& FileOptions::objc_class_prefix() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.objc_class_prefix)
+    return _internal_objc_class_prefix();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_objc_class_prefix(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    _impl_.objc_class_prefix_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.objc_class_prefix)
+}
+inline std::string* FileOptions::mutable_objc_class_prefix()
+{
+    std::string* _s = _internal_mutable_objc_class_prefix();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.objc_class_prefix)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_objc_class_prefix() const
+{
+    return _impl_.objc_class_prefix_.Get();
+}
+inline void FileOptions::_internal_set_objc_class_prefix(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    _impl_.objc_class_prefix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_objc_class_prefix()
+{
     _impl_._has_bits_[0] |= 0x00000008u;
-  } else {
+    return _impl_.objc_class_prefix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_objc_class_prefix()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.objc_class_prefix)
+    if (!_internal_has_objc_class_prefix())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000008u;
-  }
-  _impl_.objc_class_prefix_.SetAllocated(objc_class_prefix, GetArenaForAllocation());
+    auto* p = _impl_.objc_class_prefix_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.objc_class_prefix_.IsDefault())
+    {
+        _impl_.objc_class_prefix_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_objc_class_prefix(std::string* objc_class_prefix)
+{
+    if (objc_class_prefix != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000008u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000008u;
+    }
+    _impl_.objc_class_prefix_.SetAllocated(objc_class_prefix, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.objc_class_prefix_.IsDefault()) {
-    _impl_.objc_class_prefix_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.objc_class_prefix)
+    if (_impl_.objc_class_prefix_.IsDefault())
+    {
+        _impl_.objc_class_prefix_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.objc_class_prefix)
 }
 
 // optional string csharp_namespace = 37;
-inline bool FileOptions::_internal_has_csharp_namespace() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
-  return value;
-}
-inline bool FileOptions::has_csharp_namespace() const {
-  return _internal_has_csharp_namespace();
-}
-inline void FileOptions::clear_csharp_namespace() {
-  _impl_.csharp_namespace_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000010u;
-}
-inline const std::string& FileOptions::csharp_namespace() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.csharp_namespace)
-  return _internal_csharp_namespace();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_csharp_namespace(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000010u;
- _impl_.csharp_namespace_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.csharp_namespace)
-}
-inline std::string* FileOptions::mutable_csharp_namespace() {
-  std::string* _s = _internal_mutable_csharp_namespace();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.csharp_namespace)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_csharp_namespace() const {
-  return _impl_.csharp_namespace_.Get();
-}
-inline void FileOptions::_internal_set_csharp_namespace(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000010u;
-  _impl_.csharp_namespace_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_csharp_namespace() {
-  _impl_._has_bits_[0] |= 0x00000010u;
-  return _impl_.csharp_namespace_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_csharp_namespace() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.csharp_namespace)
-  if (!_internal_has_csharp_namespace()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000010u;
-  auto* p = _impl_.csharp_namespace_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.csharp_namespace_.IsDefault()) {
-    _impl_.csharp_namespace_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_csharp_namespace(std::string* csharp_namespace) {
-  if (csharp_namespace != nullptr) {
+inline bool FileOptions::_internal_has_csharp_namespace() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+    return value;
+}
+inline bool FileOptions::has_csharp_namespace() const
+{
+    return _internal_has_csharp_namespace();
+}
+inline void FileOptions::clear_csharp_namespace()
+{
+    _impl_.csharp_namespace_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& FileOptions::csharp_namespace() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.csharp_namespace)
+    return _internal_csharp_namespace();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_csharp_namespace(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000010u;
+    _impl_.csharp_namespace_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.csharp_namespace)
+}
+inline std::string* FileOptions::mutable_csharp_namespace()
+{
+    std::string* _s = _internal_mutable_csharp_namespace();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.csharp_namespace)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_csharp_namespace() const
+{
+    return _impl_.csharp_namespace_.Get();
+}
+inline void FileOptions::_internal_set_csharp_namespace(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000010u;
+    _impl_.csharp_namespace_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_csharp_namespace()
+{
     _impl_._has_bits_[0] |= 0x00000010u;
-  } else {
+    return _impl_.csharp_namespace_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_csharp_namespace()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.csharp_namespace)
+    if (!_internal_has_csharp_namespace())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000010u;
-  }
-  _impl_.csharp_namespace_.SetAllocated(csharp_namespace, GetArenaForAllocation());
+    auto* p = _impl_.csharp_namespace_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.csharp_namespace_.IsDefault())
+    {
+        _impl_.csharp_namespace_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_csharp_namespace(std::string* csharp_namespace)
+{
+    if (csharp_namespace != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000010u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000010u;
+    }
+    _impl_.csharp_namespace_.SetAllocated(csharp_namespace, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.csharp_namespace_.IsDefault()) {
-    _impl_.csharp_namespace_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.csharp_namespace)
+    if (_impl_.csharp_namespace_.IsDefault())
+    {
+        _impl_.csharp_namespace_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.csharp_namespace)
 }
 
 // optional string swift_prefix = 39;
-inline bool FileOptions::_internal_has_swift_prefix() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
-  return value;
-}
-inline bool FileOptions::has_swift_prefix() const {
-  return _internal_has_swift_prefix();
-}
-inline void FileOptions::clear_swift_prefix() {
-  _impl_.swift_prefix_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000020u;
-}
-inline const std::string& FileOptions::swift_prefix() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.swift_prefix)
-  return _internal_swift_prefix();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_swift_prefix(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000020u;
- _impl_.swift_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.swift_prefix)
-}
-inline std::string* FileOptions::mutable_swift_prefix() {
-  std::string* _s = _internal_mutable_swift_prefix();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.swift_prefix)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_swift_prefix() const {
-  return _impl_.swift_prefix_.Get();
-}
-inline void FileOptions::_internal_set_swift_prefix(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000020u;
-  _impl_.swift_prefix_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_swift_prefix() {
-  _impl_._has_bits_[0] |= 0x00000020u;
-  return _impl_.swift_prefix_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_swift_prefix() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.swift_prefix)
-  if (!_internal_has_swift_prefix()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000020u;
-  auto* p = _impl_.swift_prefix_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.swift_prefix_.IsDefault()) {
-    _impl_.swift_prefix_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_swift_prefix(std::string* swift_prefix) {
-  if (swift_prefix != nullptr) {
+inline bool FileOptions::_internal_has_swift_prefix() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+    return value;
+}
+inline bool FileOptions::has_swift_prefix() const
+{
+    return _internal_has_swift_prefix();
+}
+inline void FileOptions::clear_swift_prefix()
+{
+    _impl_.swift_prefix_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& FileOptions::swift_prefix() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.swift_prefix)
+    return _internal_swift_prefix();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_swift_prefix(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000020u;
+    _impl_.swift_prefix_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.swift_prefix)
+}
+inline std::string* FileOptions::mutable_swift_prefix()
+{
+    std::string* _s = _internal_mutable_swift_prefix();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.swift_prefix)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_swift_prefix() const
+{
+    return _impl_.swift_prefix_.Get();
+}
+inline void FileOptions::_internal_set_swift_prefix(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000020u;
+    _impl_.swift_prefix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_swift_prefix()
+{
     _impl_._has_bits_[0] |= 0x00000020u;
-  } else {
+    return _impl_.swift_prefix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_swift_prefix()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.swift_prefix)
+    if (!_internal_has_swift_prefix())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000020u;
-  }
-  _impl_.swift_prefix_.SetAllocated(swift_prefix, GetArenaForAllocation());
+    auto* p = _impl_.swift_prefix_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.swift_prefix_.IsDefault())
+    {
+        _impl_.swift_prefix_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_swift_prefix(std::string* swift_prefix)
+{
+    if (swift_prefix != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000020u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000020u;
+    }
+    _impl_.swift_prefix_.SetAllocated(swift_prefix, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.swift_prefix_.IsDefault()) {
-    _impl_.swift_prefix_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.swift_prefix)
+    if (_impl_.swift_prefix_.IsDefault())
+    {
+        _impl_.swift_prefix_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.swift_prefix)
 }
 
 // optional string php_class_prefix = 40;
-inline bool FileOptions::_internal_has_php_class_prefix() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
-  return value;
-}
-inline bool FileOptions::has_php_class_prefix() const {
-  return _internal_has_php_class_prefix();
-}
-inline void FileOptions::clear_php_class_prefix() {
-  _impl_.php_class_prefix_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000040u;
-}
-inline const std::string& FileOptions::php_class_prefix() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_class_prefix)
-  return _internal_php_class_prefix();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_php_class_prefix(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000040u;
- _impl_.php_class_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_class_prefix)
-}
-inline std::string* FileOptions::mutable_php_class_prefix() {
-  std::string* _s = _internal_mutable_php_class_prefix();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_class_prefix)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_php_class_prefix() const {
-  return _impl_.php_class_prefix_.Get();
-}
-inline void FileOptions::_internal_set_php_class_prefix(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000040u;
-  _impl_.php_class_prefix_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_php_class_prefix() {
-  _impl_._has_bits_[0] |= 0x00000040u;
-  return _impl_.php_class_prefix_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_php_class_prefix() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_class_prefix)
-  if (!_internal_has_php_class_prefix()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000040u;
-  auto* p = _impl_.php_class_prefix_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.php_class_prefix_.IsDefault()) {
-    _impl_.php_class_prefix_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_php_class_prefix(std::string* php_class_prefix) {
-  if (php_class_prefix != nullptr) {
+inline bool FileOptions::_internal_has_php_class_prefix() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+    return value;
+}
+inline bool FileOptions::has_php_class_prefix() const
+{
+    return _internal_has_php_class_prefix();
+}
+inline void FileOptions::clear_php_class_prefix()
+{
+    _impl_.php_class_prefix_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& FileOptions::php_class_prefix() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_class_prefix)
+    return _internal_php_class_prefix();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_php_class_prefix(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000040u;
+    _impl_.php_class_prefix_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_class_prefix)
+}
+inline std::string* FileOptions::mutable_php_class_prefix()
+{
+    std::string* _s = _internal_mutable_php_class_prefix();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_class_prefix)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_php_class_prefix() const
+{
+    return _impl_.php_class_prefix_.Get();
+}
+inline void FileOptions::_internal_set_php_class_prefix(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000040u;
+    _impl_.php_class_prefix_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_php_class_prefix()
+{
     _impl_._has_bits_[0] |= 0x00000040u;
-  } else {
+    return _impl_.php_class_prefix_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_php_class_prefix()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_class_prefix)
+    if (!_internal_has_php_class_prefix())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000040u;
-  }
-  _impl_.php_class_prefix_.SetAllocated(php_class_prefix, GetArenaForAllocation());
+    auto* p = _impl_.php_class_prefix_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.php_class_prefix_.IsDefault())
+    {
+        _impl_.php_class_prefix_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_php_class_prefix(std::string* php_class_prefix)
+{
+    if (php_class_prefix != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000040u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000040u;
+    }
+    _impl_.php_class_prefix_.SetAllocated(php_class_prefix, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.php_class_prefix_.IsDefault()) {
-    _impl_.php_class_prefix_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_class_prefix)
+    if (_impl_.php_class_prefix_.IsDefault())
+    {
+        _impl_.php_class_prefix_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_class_prefix)
 }
 
 // optional string php_namespace = 41;
-inline bool FileOptions::_internal_has_php_namespace() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
-  return value;
-}
-inline bool FileOptions::has_php_namespace() const {
-  return _internal_has_php_namespace();
-}
-inline void FileOptions::clear_php_namespace() {
-  _impl_.php_namespace_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000080u;
-}
-inline const std::string& FileOptions::php_namespace() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_namespace)
-  return _internal_php_namespace();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_php_namespace(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000080u;
- _impl_.php_namespace_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_namespace)
-}
-inline std::string* FileOptions::mutable_php_namespace() {
-  std::string* _s = _internal_mutable_php_namespace();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_namespace)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_php_namespace() const {
-  return _impl_.php_namespace_.Get();
-}
-inline void FileOptions::_internal_set_php_namespace(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000080u;
-  _impl_.php_namespace_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_php_namespace() {
-  _impl_._has_bits_[0] |= 0x00000080u;
-  return _impl_.php_namespace_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_php_namespace() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_namespace)
-  if (!_internal_has_php_namespace()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000080u;
-  auto* p = _impl_.php_namespace_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.php_namespace_.IsDefault()) {
-    _impl_.php_namespace_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_php_namespace(std::string* php_namespace) {
-  if (php_namespace != nullptr) {
+inline bool FileOptions::_internal_has_php_namespace() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
+    return value;
+}
+inline bool FileOptions::has_php_namespace() const
+{
+    return _internal_has_php_namespace();
+}
+inline void FileOptions::clear_php_namespace()
+{
+    _impl_.php_namespace_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& FileOptions::php_namespace() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_namespace)
+    return _internal_php_namespace();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_php_namespace(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000080u;
+    _impl_.php_namespace_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_namespace)
+}
+inline std::string* FileOptions::mutable_php_namespace()
+{
+    std::string* _s = _internal_mutable_php_namespace();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_namespace)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_php_namespace() const
+{
+    return _impl_.php_namespace_.Get();
+}
+inline void FileOptions::_internal_set_php_namespace(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000080u;
+    _impl_.php_namespace_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_php_namespace()
+{
     _impl_._has_bits_[0] |= 0x00000080u;
-  } else {
+    return _impl_.php_namespace_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_php_namespace()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_namespace)
+    if (!_internal_has_php_namespace())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000080u;
-  }
-  _impl_.php_namespace_.SetAllocated(php_namespace, GetArenaForAllocation());
+    auto* p = _impl_.php_namespace_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.php_namespace_.IsDefault())
+    {
+        _impl_.php_namespace_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_php_namespace(std::string* php_namespace)
+{
+    if (php_namespace != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000080u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000080u;
+    }
+    _impl_.php_namespace_.SetAllocated(php_namespace, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.php_namespace_.IsDefault()) {
-    _impl_.php_namespace_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_namespace)
+    if (_impl_.php_namespace_.IsDefault())
+    {
+        _impl_.php_namespace_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_namespace)
 }
 
 // optional string php_metadata_namespace = 44;
-inline bool FileOptions::_internal_has_php_metadata_namespace() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
-  return value;
-}
-inline bool FileOptions::has_php_metadata_namespace() const {
-  return _internal_has_php_metadata_namespace();
-}
-inline void FileOptions::clear_php_metadata_namespace() {
-  _impl_.php_metadata_namespace_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000100u;
-}
-inline const std::string& FileOptions::php_metadata_namespace() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_metadata_namespace)
-  return _internal_php_metadata_namespace();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_php_metadata_namespace(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000100u;
- _impl_.php_metadata_namespace_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_metadata_namespace)
-}
-inline std::string* FileOptions::mutable_php_metadata_namespace() {
-  std::string* _s = _internal_mutable_php_metadata_namespace();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_metadata_namespace)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_php_metadata_namespace() const {
-  return _impl_.php_metadata_namespace_.Get();
-}
-inline void FileOptions::_internal_set_php_metadata_namespace(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000100u;
-  _impl_.php_metadata_namespace_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_php_metadata_namespace() {
-  _impl_._has_bits_[0] |= 0x00000100u;
-  return _impl_.php_metadata_namespace_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_php_metadata_namespace() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_metadata_namespace)
-  if (!_internal_has_php_metadata_namespace()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000100u;
-  auto* p = _impl_.php_metadata_namespace_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.php_metadata_namespace_.IsDefault()) {
-    _impl_.php_metadata_namespace_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_php_metadata_namespace(std::string* php_metadata_namespace) {
-  if (php_metadata_namespace != nullptr) {
+inline bool FileOptions::_internal_has_php_metadata_namespace() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
+    return value;
+}
+inline bool FileOptions::has_php_metadata_namespace() const
+{
+    return _internal_has_php_metadata_namespace();
+}
+inline void FileOptions::clear_php_metadata_namespace()
+{
+    _impl_.php_metadata_namespace_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& FileOptions::php_metadata_namespace() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_metadata_namespace)
+    return _internal_php_metadata_namespace();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_php_metadata_namespace(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000100u;
+    _impl_.php_metadata_namespace_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_metadata_namespace)
+}
+inline std::string* FileOptions::mutable_php_metadata_namespace()
+{
+    std::string* _s = _internal_mutable_php_metadata_namespace();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_metadata_namespace)
+    return _s;
+}
+inline const std::string& FileOptions::_internal_php_metadata_namespace() const
+{
+    return _impl_.php_metadata_namespace_.Get();
+}
+inline void FileOptions::_internal_set_php_metadata_namespace(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000100u;
+    _impl_.php_metadata_namespace_.Set(value, GetArenaForAllocation());
+}
+inline std::string* FileOptions::_internal_mutable_php_metadata_namespace()
+{
     _impl_._has_bits_[0] |= 0x00000100u;
-  } else {
+    return _impl_.php_metadata_namespace_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_php_metadata_namespace()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_metadata_namespace)
+    if (!_internal_has_php_metadata_namespace())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000100u;
-  }
-  _impl_.php_metadata_namespace_.SetAllocated(php_metadata_namespace, GetArenaForAllocation());
+    auto* p = _impl_.php_metadata_namespace_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.php_metadata_namespace_.IsDefault())
+    {
+        _impl_.php_metadata_namespace_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_php_metadata_namespace(std::string* php_metadata_namespace)
+{
+    if (php_metadata_namespace != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000100u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000100u;
+    }
+    _impl_.php_metadata_namespace_.SetAllocated(php_metadata_namespace, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.php_metadata_namespace_.IsDefault()) {
-    _impl_.php_metadata_namespace_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_metadata_namespace)
+    if (_impl_.php_metadata_namespace_.IsDefault())
+    {
+        _impl_.php_metadata_namespace_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_metadata_namespace)
 }
 
 // optional string ruby_package = 45;
-inline bool FileOptions::_internal_has_ruby_package() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
-  return value;
-}
-inline bool FileOptions::has_ruby_package() const {
-  return _internal_has_ruby_package();
-}
-inline void FileOptions::clear_ruby_package() {
-  _impl_.ruby_package_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000200u;
-}
-inline const std::string& FileOptions::ruby_package() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.ruby_package)
-  return _internal_ruby_package();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void FileOptions::set_ruby_package(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000200u;
- _impl_.ruby_package_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.ruby_package)
-}
-inline std::string* FileOptions::mutable_ruby_package() {
-  std::string* _s = _internal_mutable_ruby_package();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.ruby_package)
-  return _s;
-}
-inline const std::string& FileOptions::_internal_ruby_package() const {
-  return _impl_.ruby_package_.Get();
-}
-inline void FileOptions::_internal_set_ruby_package(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000200u;
-  _impl_.ruby_package_.Set(value, GetArenaForAllocation());
-}
-inline std::string* FileOptions::_internal_mutable_ruby_package() {
-  _impl_._has_bits_[0] |= 0x00000200u;
-  return _impl_.ruby_package_.Mutable(GetArenaForAllocation());
-}
-inline std::string* FileOptions::release_ruby_package() {
-  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.ruby_package)
-  if (!_internal_has_ruby_package()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000200u;
-  auto* p = _impl_.ruby_package_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.ruby_package_.IsDefault()) {
-    _impl_.ruby_package_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void FileOptions::set_allocated_ruby_package(std::string* ruby_package) {
-  if (ruby_package != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000200u;
-  } else {
+inline bool FileOptions::_internal_has_ruby_package() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
+    return value;
+}
+inline bool FileOptions::has_ruby_package() const
+{
+    return _internal_has_ruby_package();
+}
+inline void FileOptions::clear_ruby_package()
+{
+    _impl_.ruby_package_.ClearToEmpty();
     _impl_._has_bits_[0] &= ~0x00000200u;
-  }
-  _impl_.ruby_package_.SetAllocated(ruby_package, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.ruby_package_.IsDefault()) {
-    _impl_.ruby_package_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.ruby_package)
-}
-
-// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int FileOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
 }
-inline int FileOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
+inline const std::string& FileOptions::ruby_package() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.ruby_package)
+    return _internal_ruby_package();
 }
-inline void FileOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-FileOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void FileOptions::set_ruby_package(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000200u;
+    _impl_.ruby_package_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.ruby_package)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FileOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
+inline std::string* FileOptions::mutable_ruby_package()
+{
+    std::string* _s = _internal_mutable_ruby_package();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.ruby_package)
+    return _s;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FileOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
+inline const std::string& FileOptions::_internal_ruby_package() const
+{
+    return _impl_.ruby_package_.Get();
 }
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
+inline void FileOptions::_internal_set_ruby_package(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000200u;
+    _impl_.ruby_package_.Set(value, GetArenaForAllocation());
 }
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.FileOptions.uninterpreted_option)
-  return _add;
+inline std::string* FileOptions::_internal_mutable_ruby_package()
+{
+    _impl_._has_bits_[0] |= 0x00000200u;
+    return _impl_.ruby_package_.Mutable(GetArenaForAllocation());
+}
+inline std::string* FileOptions::release_ruby_package()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.ruby_package)
+    if (!_internal_has_ruby_package())
+    {
+        return nullptr;
+    }
+    _impl_._has_bits_[0] &= ~0x00000200u;
+    auto* p = _impl_.ruby_package_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.ruby_package_.IsDefault())
+    {
+        _impl_.ruby_package_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void FileOptions::set_allocated_ruby_package(std::string* ruby_package)
+{
+    if (ruby_package != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000200u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000200u;
+    }
+    _impl_.ruby_package_.SetAllocated(ruby_package, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.ruby_package_.IsDefault())
+    {
+        _impl_.ruby_package_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.ruby_package)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-FileOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FileOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int FileOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int FileOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void FileOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    FileOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FileOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FileOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FileOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.FileOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    FileOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FileOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
 
 // -------------------------------------------------------------------
@@ -12934,155 +15985,193 @@ FileOptions::uninterpreted_option() const {
 // MessageOptions
 
 // optional bool message_set_wire_format = 1 [default = false];
-inline bool MessageOptions::_internal_has_message_set_wire_format() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool MessageOptions::has_message_set_wire_format() const {
-  return _internal_has_message_set_wire_format();
-}
-inline void MessageOptions::clear_message_set_wire_format() {
-  _impl_.message_set_wire_format_ = false;
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool MessageOptions::_internal_has_message_set_wire_format() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool MessageOptions::has_message_set_wire_format() const
+{
+    return _internal_has_message_set_wire_format();
+}
+inline void MessageOptions::clear_message_set_wire_format()
+{
+    _impl_.message_set_wire_format_ = false;
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline bool MessageOptions::_internal_message_set_wire_format() const {
-  return _impl_.message_set_wire_format_;
+inline bool MessageOptions::_internal_message_set_wire_format() const
+{
+    return _impl_.message_set_wire_format_;
 }
-inline bool MessageOptions::message_set_wire_format() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.message_set_wire_format)
-  return _internal_message_set_wire_format();
+inline bool MessageOptions::message_set_wire_format() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.message_set_wire_format)
+    return _internal_message_set_wire_format();
 }
-inline void MessageOptions::_internal_set_message_set_wire_format(bool value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.message_set_wire_format_ = value;
+inline void MessageOptions::_internal_set_message_set_wire_format(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.message_set_wire_format_ = value;
 }
-inline void MessageOptions::set_message_set_wire_format(bool value) {
-  _internal_set_message_set_wire_format(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.message_set_wire_format)
+inline void MessageOptions::set_message_set_wire_format(bool value)
+{
+    _internal_set_message_set_wire_format(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.message_set_wire_format)
 }
 
 // optional bool no_standard_descriptor_accessor = 2 [default = false];
-inline bool MessageOptions::_internal_has_no_standard_descriptor_accessor() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool MessageOptions::has_no_standard_descriptor_accessor() const {
-  return _internal_has_no_standard_descriptor_accessor();
-}
-inline void MessageOptions::clear_no_standard_descriptor_accessor() {
-  _impl_.no_standard_descriptor_accessor_ = false;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool MessageOptions::_internal_has_no_standard_descriptor_accessor() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool MessageOptions::has_no_standard_descriptor_accessor() const
+{
+    return _internal_has_no_standard_descriptor_accessor();
+}
+inline void MessageOptions::clear_no_standard_descriptor_accessor()
+{
+    _impl_.no_standard_descriptor_accessor_ = false;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline bool MessageOptions::_internal_no_standard_descriptor_accessor() const {
-  return _impl_.no_standard_descriptor_accessor_;
+inline bool MessageOptions::_internal_no_standard_descriptor_accessor() const
+{
+    return _impl_.no_standard_descriptor_accessor_;
 }
-inline bool MessageOptions::no_standard_descriptor_accessor() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
-  return _internal_no_standard_descriptor_accessor();
+inline bool MessageOptions::no_standard_descriptor_accessor() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
+    return _internal_no_standard_descriptor_accessor();
 }
-inline void MessageOptions::_internal_set_no_standard_descriptor_accessor(bool value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.no_standard_descriptor_accessor_ = value;
+inline void MessageOptions::_internal_set_no_standard_descriptor_accessor(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.no_standard_descriptor_accessor_ = value;
 }
-inline void MessageOptions::set_no_standard_descriptor_accessor(bool value) {
-  _internal_set_no_standard_descriptor_accessor(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
+inline void MessageOptions::set_no_standard_descriptor_accessor(bool value)
+{
+    _internal_set_no_standard_descriptor_accessor(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
 }
 
 // optional bool deprecated = 3 [default = false];
-inline bool MessageOptions::_internal_has_deprecated() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool MessageOptions::has_deprecated() const {
-  return _internal_has_deprecated();
-}
-inline void MessageOptions::clear_deprecated() {
-  _impl_.deprecated_ = false;
-  _impl_._has_bits_[0] &= ~0x00000004u;
+inline bool MessageOptions::_internal_has_deprecated() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool MessageOptions::has_deprecated() const
+{
+    return _internal_has_deprecated();
+}
+inline void MessageOptions::clear_deprecated()
+{
+    _impl_.deprecated_ = false;
+    _impl_._has_bits_[0] &= ~0x00000004u;
 }
-inline bool MessageOptions::_internal_deprecated() const {
-  return _impl_.deprecated_;
+inline bool MessageOptions::_internal_deprecated() const
+{
+    return _impl_.deprecated_;
 }
-inline bool MessageOptions::deprecated() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.deprecated)
-  return _internal_deprecated();
+inline bool MessageOptions::deprecated() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.deprecated)
+    return _internal_deprecated();
 }
-inline void MessageOptions::_internal_set_deprecated(bool value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.deprecated_ = value;
+inline void MessageOptions::_internal_set_deprecated(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.deprecated_ = value;
 }
-inline void MessageOptions::set_deprecated(bool value) {
-  _internal_set_deprecated(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.deprecated)
+inline void MessageOptions::set_deprecated(bool value)
+{
+    _internal_set_deprecated(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.deprecated)
 }
 
 // optional bool map_entry = 7;
-inline bool MessageOptions::_internal_has_map_entry() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool MessageOptions::has_map_entry() const {
-  return _internal_has_map_entry();
-}
-inline void MessageOptions::clear_map_entry() {
-  _impl_.map_entry_ = false;
-  _impl_._has_bits_[0] &= ~0x00000008u;
+inline bool MessageOptions::_internal_has_map_entry() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+    return value;
+}
+inline bool MessageOptions::has_map_entry() const
+{
+    return _internal_has_map_entry();
+}
+inline void MessageOptions::clear_map_entry()
+{
+    _impl_.map_entry_ = false;
+    _impl_._has_bits_[0] &= ~0x00000008u;
 }
-inline bool MessageOptions::_internal_map_entry() const {
-  return _impl_.map_entry_;
+inline bool MessageOptions::_internal_map_entry() const
+{
+    return _impl_.map_entry_;
 }
-inline bool MessageOptions::map_entry() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.map_entry)
-  return _internal_map_entry();
+inline bool MessageOptions::map_entry() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.map_entry)
+    return _internal_map_entry();
 }
-inline void MessageOptions::_internal_set_map_entry(bool value) {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  _impl_.map_entry_ = value;
+inline void MessageOptions::_internal_set_map_entry(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    _impl_.map_entry_ = value;
 }
-inline void MessageOptions::set_map_entry(bool value) {
-  _internal_set_map_entry(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.map_entry)
+inline void MessageOptions::set_map_entry(bool value)
+{
+    _internal_set_map_entry(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.map_entry)
 }
 
 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int MessageOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
-}
-inline int MessageOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
-}
-inline void MessageOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.MessageOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-MessageOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.MessageOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MessageOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.MessageOptions.uninterpreted_option)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-MessageOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.MessageOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+inline int MessageOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int MessageOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void MessageOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.MessageOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    MessageOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.MessageOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MessageOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MessageOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.MessageOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    MessageOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.MessageOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
 
 // -------------------------------------------------------------------
@@ -13090,285 +16179,354 @@ MessageOptions::uninterpreted_option() const {
 // FieldOptions
 
 // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
-inline bool FieldOptions::_internal_has_ctype() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool FieldOptions::has_ctype() const {
-  return _internal_has_ctype();
-}
-inline void FieldOptions::clear_ctype() {
-  _impl_.ctype_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool FieldOptions::_internal_has_ctype() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool FieldOptions::has_ctype() const
+{
+    return _internal_has_ctype();
+}
+inline void FieldOptions::clear_ctype()
+{
+    _impl_.ctype_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType FieldOptions::_internal_ctype() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType >(_impl_.ctype_);
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType FieldOptions::_internal_ctype() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::FieldOptions_CType>(_impl_.ctype_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType FieldOptions::ctype() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.ctype)
-  return _internal_ctype();
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType FieldOptions::ctype() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.ctype)
+    return _internal_ctype();
 }
-inline void FieldOptions::_internal_set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value) {
-  assert(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType_IsValid(value));
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.ctype_ = value;
+inline void FieldOptions::_internal_set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value)
+{
+    assert(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType_IsValid(value));
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.ctype_ = value;
 }
-inline void FieldOptions::set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value) {
-  _internal_set_ctype(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.ctype)
+inline void FieldOptions::set_ctype(::PROTOBUF_NAMESPACE_ID::FieldOptions_CType value)
+{
+    _internal_set_ctype(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.ctype)
 }
 
 // optional bool packed = 2;
-inline bool FieldOptions::_internal_has_packed() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool FieldOptions::has_packed() const {
-  return _internal_has_packed();
-}
-inline void FieldOptions::clear_packed() {
-  _impl_.packed_ = false;
-  _impl_._has_bits_[0] &= ~0x00000004u;
+inline bool FieldOptions::_internal_has_packed() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool FieldOptions::has_packed() const
+{
+    return _internal_has_packed();
+}
+inline void FieldOptions::clear_packed()
+{
+    _impl_.packed_ = false;
+    _impl_._has_bits_[0] &= ~0x00000004u;
 }
-inline bool FieldOptions::_internal_packed() const {
-  return _impl_.packed_;
+inline bool FieldOptions::_internal_packed() const
+{
+    return _impl_.packed_;
 }
-inline bool FieldOptions::packed() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.packed)
-  return _internal_packed();
+inline bool FieldOptions::packed() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.packed)
+    return _internal_packed();
 }
-inline void FieldOptions::_internal_set_packed(bool value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.packed_ = value;
+inline void FieldOptions::_internal_set_packed(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.packed_ = value;
 }
-inline void FieldOptions::set_packed(bool value) {
-  _internal_set_packed(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.packed)
+inline void FieldOptions::set_packed(bool value)
+{
+    _internal_set_packed(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.packed)
 }
 
 // optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
-inline bool FieldOptions::_internal_has_jstype() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool FieldOptions::has_jstype() const {
-  return _internal_has_jstype();
-}
-inline void FieldOptions::clear_jstype() {
-  _impl_.jstype_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool FieldOptions::_internal_has_jstype() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool FieldOptions::has_jstype() const
+{
+    return _internal_has_jstype();
+}
+inline void FieldOptions::clear_jstype()
+{
+    _impl_.jstype_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType FieldOptions::_internal_jstype() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType >(_impl_.jstype_);
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType FieldOptions::_internal_jstype() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType>(_impl_.jstype_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType FieldOptions::jstype() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.jstype)
-  return _internal_jstype();
+inline ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType FieldOptions::jstype() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.jstype)
+    return _internal_jstype();
 }
-inline void FieldOptions::_internal_set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value) {
-  assert(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_IsValid(value));
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.jstype_ = value;
+inline void FieldOptions::_internal_set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value)
+{
+    assert(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_IsValid(value));
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.jstype_ = value;
 }
-inline void FieldOptions::set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value) {
-  _internal_set_jstype(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.jstype)
+inline void FieldOptions::set_jstype(::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType value)
+{
+    _internal_set_jstype(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.jstype)
 }
 
 // optional bool lazy = 5 [default = false];
-inline bool FieldOptions::_internal_has_lazy() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool FieldOptions::has_lazy() const {
-  return _internal_has_lazy();
-}
-inline void FieldOptions::clear_lazy() {
-  _impl_.lazy_ = false;
-  _impl_._has_bits_[0] &= ~0x00000008u;
+inline bool FieldOptions::_internal_has_lazy() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+    return value;
+}
+inline bool FieldOptions::has_lazy() const
+{
+    return _internal_has_lazy();
+}
+inline void FieldOptions::clear_lazy()
+{
+    _impl_.lazy_ = false;
+    _impl_._has_bits_[0] &= ~0x00000008u;
 }
-inline bool FieldOptions::_internal_lazy() const {
-  return _impl_.lazy_;
+inline bool FieldOptions::_internal_lazy() const
+{
+    return _impl_.lazy_;
 }
-inline bool FieldOptions::lazy() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.lazy)
-  return _internal_lazy();
+inline bool FieldOptions::lazy() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.lazy)
+    return _internal_lazy();
 }
-inline void FieldOptions::_internal_set_lazy(bool value) {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  _impl_.lazy_ = value;
+inline void FieldOptions::_internal_set_lazy(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    _impl_.lazy_ = value;
 }
-inline void FieldOptions::set_lazy(bool value) {
-  _internal_set_lazy(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.lazy)
+inline void FieldOptions::set_lazy(bool value)
+{
+    _internal_set_lazy(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.lazy)
 }
 
 // optional bool unverified_lazy = 15 [default = false];
-inline bool FieldOptions::_internal_has_unverified_lazy() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
-  return value;
-}
-inline bool FieldOptions::has_unverified_lazy() const {
-  return _internal_has_unverified_lazy();
-}
-inline void FieldOptions::clear_unverified_lazy() {
-  _impl_.unverified_lazy_ = false;
-  _impl_._has_bits_[0] &= ~0x00000010u;
+inline bool FieldOptions::_internal_has_unverified_lazy() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+    return value;
+}
+inline bool FieldOptions::has_unverified_lazy() const
+{
+    return _internal_has_unverified_lazy();
+}
+inline void FieldOptions::clear_unverified_lazy()
+{
+    _impl_.unverified_lazy_ = false;
+    _impl_._has_bits_[0] &= ~0x00000010u;
 }
-inline bool FieldOptions::_internal_unverified_lazy() const {
-  return _impl_.unverified_lazy_;
+inline bool FieldOptions::_internal_unverified_lazy() const
+{
+    return _impl_.unverified_lazy_;
 }
-inline bool FieldOptions::unverified_lazy() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.unverified_lazy)
-  return _internal_unverified_lazy();
+inline bool FieldOptions::unverified_lazy() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.unverified_lazy)
+    return _internal_unverified_lazy();
 }
-inline void FieldOptions::_internal_set_unverified_lazy(bool value) {
-  _impl_._has_bits_[0] |= 0x00000010u;
-  _impl_.unverified_lazy_ = value;
+inline void FieldOptions::_internal_set_unverified_lazy(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000010u;
+    _impl_.unverified_lazy_ = value;
 }
-inline void FieldOptions::set_unverified_lazy(bool value) {
-  _internal_set_unverified_lazy(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.unverified_lazy)
+inline void FieldOptions::set_unverified_lazy(bool value)
+{
+    _internal_set_unverified_lazy(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.unverified_lazy)
 }
 
 // optional bool deprecated = 3 [default = false];
-inline bool FieldOptions::_internal_has_deprecated() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
-  return value;
-}
-inline bool FieldOptions::has_deprecated() const {
-  return _internal_has_deprecated();
-}
-inline void FieldOptions::clear_deprecated() {
-  _impl_.deprecated_ = false;
-  _impl_._has_bits_[0] &= ~0x00000020u;
+inline bool FieldOptions::_internal_has_deprecated() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+    return value;
+}
+inline bool FieldOptions::has_deprecated() const
+{
+    return _internal_has_deprecated();
+}
+inline void FieldOptions::clear_deprecated()
+{
+    _impl_.deprecated_ = false;
+    _impl_._has_bits_[0] &= ~0x00000020u;
 }
-inline bool FieldOptions::_internal_deprecated() const {
-  return _impl_.deprecated_;
+inline bool FieldOptions::_internal_deprecated() const
+{
+    return _impl_.deprecated_;
 }
-inline bool FieldOptions::deprecated() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.deprecated)
-  return _internal_deprecated();
+inline bool FieldOptions::deprecated() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.deprecated)
+    return _internal_deprecated();
 }
-inline void FieldOptions::_internal_set_deprecated(bool value) {
-  _impl_._has_bits_[0] |= 0x00000020u;
-  _impl_.deprecated_ = value;
+inline void FieldOptions::_internal_set_deprecated(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000020u;
+    _impl_.deprecated_ = value;
 }
-inline void FieldOptions::set_deprecated(bool value) {
-  _internal_set_deprecated(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.deprecated)
+inline void FieldOptions::set_deprecated(bool value)
+{
+    _internal_set_deprecated(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.deprecated)
 }
 
 // optional bool weak = 10 [default = false];
-inline bool FieldOptions::_internal_has_weak() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
-  return value;
-}
-inline bool FieldOptions::has_weak() const {
-  return _internal_has_weak();
-}
-inline void FieldOptions::clear_weak() {
-  _impl_.weak_ = false;
-  _impl_._has_bits_[0] &= ~0x00000040u;
-}
-inline bool FieldOptions::_internal_weak() const {
-  return _impl_.weak_;
-}
-inline bool FieldOptions::weak() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.weak)
-  return _internal_weak();
-}
-inline void FieldOptions::_internal_set_weak(bool value) {
-  _impl_._has_bits_[0] |= 0x00000040u;
-  _impl_.weak_ = value;
-}
-inline void FieldOptions::set_weak(bool value) {
-  _internal_set_weak(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.weak)
-}
-
-// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int FieldOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
-}
-inline int FieldOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
-}
-inline void FieldOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-FieldOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FieldOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
+inline bool FieldOptions::_internal_has_weak() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
+    return value;
+}
+inline bool FieldOptions::has_weak() const
+{
+    return _internal_has_weak();
+}
+inline void FieldOptions::clear_weak()
+{
+    _impl_.weak_ = false;
+    _impl_._has_bits_[0] &= ~0x00000040u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
+inline bool FieldOptions::_internal_weak() const
+{
+    return _impl_.weak_;
 }
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
+inline bool FieldOptions::weak() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.weak)
+    return _internal_weak();
 }
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.FieldOptions.uninterpreted_option)
-  return _add;
+inline void FieldOptions::_internal_set_weak(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000040u;
+    _impl_.weak_ = value;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-FieldOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FieldOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+inline void FieldOptions::set_weak(bool value)
+{
+    _internal_set_weak(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.weak)
 }
 
-// -------------------------------------------------------------------
-
-// OneofOptions
-
 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int OneofOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
-}
-inline int OneofOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
-}
-inline void OneofOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-OneofOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.OneofOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& OneofOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& OneofOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.OneofOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.OneofOptions.uninterpreted_option)
-  return _add;
+inline int FieldOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int FieldOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void FieldOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FieldOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    FieldOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FieldOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* FieldOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.FieldOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    FieldOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FieldOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-OneofOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.OneofOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+
+// -------------------------------------------------------------------
+
+// OneofOptions
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int OneofOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int OneofOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void OneofOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.OneofOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    OneofOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.OneofOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& OneofOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& OneofOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.OneofOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* OneofOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.OneofOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    OneofOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.OneofOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
 
 // -------------------------------------------------------------------
@@ -13376,99 +16534,123 @@ OneofOptions::uninterpreted_option() const {
 // EnumOptions
 
 // optional bool allow_alias = 2;
-inline bool EnumOptions::_internal_has_allow_alias() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool EnumOptions::has_allow_alias() const {
-  return _internal_has_allow_alias();
-}
-inline void EnumOptions::clear_allow_alias() {
-  _impl_.allow_alias_ = false;
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool EnumOptions::_internal_has_allow_alias() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool EnumOptions::has_allow_alias() const
+{
+    return _internal_has_allow_alias();
+}
+inline void EnumOptions::clear_allow_alias()
+{
+    _impl_.allow_alias_ = false;
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline bool EnumOptions::_internal_allow_alias() const {
-  return _impl_.allow_alias_;
+inline bool EnumOptions::_internal_allow_alias() const
+{
+    return _impl_.allow_alias_;
 }
-inline bool EnumOptions::allow_alias() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.allow_alias)
-  return _internal_allow_alias();
+inline bool EnumOptions::allow_alias() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.allow_alias)
+    return _internal_allow_alias();
 }
-inline void EnumOptions::_internal_set_allow_alias(bool value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.allow_alias_ = value;
+inline void EnumOptions::_internal_set_allow_alias(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.allow_alias_ = value;
 }
-inline void EnumOptions::set_allow_alias(bool value) {
-  _internal_set_allow_alias(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.allow_alias)
+inline void EnumOptions::set_allow_alias(bool value)
+{
+    _internal_set_allow_alias(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.allow_alias)
 }
 
 // optional bool deprecated = 3 [default = false];
-inline bool EnumOptions::_internal_has_deprecated() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool EnumOptions::has_deprecated() const {
-  return _internal_has_deprecated();
-}
-inline void EnumOptions::clear_deprecated() {
-  _impl_.deprecated_ = false;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool EnumOptions::_internal_has_deprecated() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool EnumOptions::has_deprecated() const
+{
+    return _internal_has_deprecated();
+}
+inline void EnumOptions::clear_deprecated()
+{
+    _impl_.deprecated_ = false;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline bool EnumOptions::_internal_deprecated() const {
-  return _impl_.deprecated_;
+inline bool EnumOptions::_internal_deprecated() const
+{
+    return _impl_.deprecated_;
 }
-inline bool EnumOptions::deprecated() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.deprecated)
-  return _internal_deprecated();
+inline bool EnumOptions::deprecated() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.deprecated)
+    return _internal_deprecated();
 }
-inline void EnumOptions::_internal_set_deprecated(bool value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.deprecated_ = value;
+inline void EnumOptions::_internal_set_deprecated(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.deprecated_ = value;
 }
-inline void EnumOptions::set_deprecated(bool value) {
-  _internal_set_deprecated(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.deprecated)
+inline void EnumOptions::set_deprecated(bool value)
+{
+    _internal_set_deprecated(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.deprecated)
 }
 
 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int EnumOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
-}
-inline int EnumOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
-}
-inline void EnumOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-EnumOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.EnumOptions.uninterpreted_option)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-EnumOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.EnumOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+inline int EnumOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int EnumOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void EnumOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    EnumOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.EnumOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    EnumOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.EnumOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
 
 // -------------------------------------------------------------------
@@ -13476,71 +16658,88 @@ EnumOptions::uninterpreted_option() const {
 // EnumValueOptions
 
 // optional bool deprecated = 1 [default = false];
-inline bool EnumValueOptions::_internal_has_deprecated() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool EnumValueOptions::has_deprecated() const {
-  return _internal_has_deprecated();
-}
-inline void EnumValueOptions::clear_deprecated() {
-  _impl_.deprecated_ = false;
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool EnumValueOptions::_internal_has_deprecated() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool EnumValueOptions::has_deprecated() const
+{
+    return _internal_has_deprecated();
+}
+inline void EnumValueOptions::clear_deprecated()
+{
+    _impl_.deprecated_ = false;
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline bool EnumValueOptions::_internal_deprecated() const {
-  return _impl_.deprecated_;
+inline bool EnumValueOptions::_internal_deprecated() const
+{
+    return _impl_.deprecated_;
 }
-inline bool EnumValueOptions::deprecated() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.deprecated)
-  return _internal_deprecated();
+inline bool EnumValueOptions::deprecated() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.deprecated)
+    return _internal_deprecated();
 }
-inline void EnumValueOptions::_internal_set_deprecated(bool value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.deprecated_ = value;
+inline void EnumValueOptions::_internal_set_deprecated(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.deprecated_ = value;
 }
-inline void EnumValueOptions::set_deprecated(bool value) {
-  _internal_set_deprecated(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueOptions.deprecated)
+inline void EnumValueOptions::set_deprecated(bool value)
+{
+    _internal_set_deprecated(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumValueOptions.deprecated)
 }
 
 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int EnumValueOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
-}
-inline int EnumValueOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
-}
-inline void EnumValueOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-EnumValueOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValueOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumValueOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.EnumValueOptions.uninterpreted_option)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-EnumValueOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.EnumValueOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+inline int EnumValueOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int EnumValueOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void EnumValueOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    EnumValueOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValueOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumValueOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* EnumValueOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.EnumValueOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    EnumValueOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.EnumValueOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
 
 // -------------------------------------------------------------------
@@ -13548,71 +16747,88 @@ EnumValueOptions::uninterpreted_option() const {
 // ServiceOptions
 
 // optional bool deprecated = 33 [default = false];
-inline bool ServiceOptions::_internal_has_deprecated() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool ServiceOptions::has_deprecated() const {
-  return _internal_has_deprecated();
-}
-inline void ServiceOptions::clear_deprecated() {
-  _impl_.deprecated_ = false;
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool ServiceOptions::_internal_has_deprecated() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool ServiceOptions::has_deprecated() const
+{
+    return _internal_has_deprecated();
+}
+inline void ServiceOptions::clear_deprecated()
+{
+    _impl_.deprecated_ = false;
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline bool ServiceOptions::_internal_deprecated() const {
-  return _impl_.deprecated_;
+inline bool ServiceOptions::_internal_deprecated() const
+{
+    return _impl_.deprecated_;
 }
-inline bool ServiceOptions::deprecated() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.deprecated)
-  return _internal_deprecated();
+inline bool ServiceOptions::deprecated() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.deprecated)
+    return _internal_deprecated();
 }
-inline void ServiceOptions::_internal_set_deprecated(bool value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.deprecated_ = value;
+inline void ServiceOptions::_internal_set_deprecated(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.deprecated_ = value;
 }
-inline void ServiceOptions::set_deprecated(bool value) {
-  _internal_set_deprecated(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.ServiceOptions.deprecated)
+inline void ServiceOptions::set_deprecated(bool value)
+{
+    _internal_set_deprecated(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.ServiceOptions.deprecated)
 }
 
 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int ServiceOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
-}
-inline int ServiceOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
-}
-inline void ServiceOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-ServiceOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ServiceOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.ServiceOptions.uninterpreted_option)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-ServiceOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.ServiceOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+inline int ServiceOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int ServiceOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void ServiceOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    ServiceOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ServiceOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* ServiceOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.ServiceOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    ServiceOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.ServiceOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
 
 // -------------------------------------------------------------------
@@ -13620,100 +16836,124 @@ ServiceOptions::uninterpreted_option() const {
 // MethodOptions
 
 // optional bool deprecated = 33 [default = false];
-inline bool MethodOptions::_internal_has_deprecated() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool MethodOptions::has_deprecated() const {
-  return _internal_has_deprecated();
-}
-inline void MethodOptions::clear_deprecated() {
-  _impl_.deprecated_ = false;
-  _impl_._has_bits_[0] &= ~0x00000001u;
+inline bool MethodOptions::_internal_has_deprecated() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool MethodOptions::has_deprecated() const
+{
+    return _internal_has_deprecated();
+}
+inline void MethodOptions::clear_deprecated()
+{
+    _impl_.deprecated_ = false;
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline bool MethodOptions::_internal_deprecated() const {
-  return _impl_.deprecated_;
+inline bool MethodOptions::_internal_deprecated() const
+{
+    return _impl_.deprecated_;
 }
-inline bool MethodOptions::deprecated() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.deprecated)
-  return _internal_deprecated();
+inline bool MethodOptions::deprecated() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.deprecated)
+    return _internal_deprecated();
 }
-inline void MethodOptions::_internal_set_deprecated(bool value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.deprecated_ = value;
+inline void MethodOptions::_internal_set_deprecated(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.deprecated_ = value;
 }
-inline void MethodOptions::set_deprecated(bool value) {
-  _internal_set_deprecated(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.deprecated)
+inline void MethodOptions::set_deprecated(bool value)
+{
+    _internal_set_deprecated(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.deprecated)
 }
 
 // optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
-inline bool MethodOptions::_internal_has_idempotency_level() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool MethodOptions::has_idempotency_level() const {
-  return _internal_has_idempotency_level();
-}
-inline void MethodOptions::clear_idempotency_level() {
-  _impl_.idempotency_level_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool MethodOptions::_internal_has_idempotency_level() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool MethodOptions::has_idempotency_level() const
+{
+    return _internal_has_idempotency_level();
+}
+inline void MethodOptions::clear_idempotency_level()
+{
+    _impl_.idempotency_level_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel MethodOptions::_internal_idempotency_level() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel >(_impl_.idempotency_level_);
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel MethodOptions::_internal_idempotency_level() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel>(_impl_.idempotency_level_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel MethodOptions::idempotency_level() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.idempotency_level)
-  return _internal_idempotency_level();
+inline ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel MethodOptions::idempotency_level() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.idempotency_level)
+    return _internal_idempotency_level();
 }
-inline void MethodOptions::_internal_set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value) {
-  assert(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_IsValid(value));
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.idempotency_level_ = value;
+inline void MethodOptions::_internal_set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value)
+{
+    assert(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_IsValid(value));
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.idempotency_level_ = value;
 }
-inline void MethodOptions::set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value) {
-  _internal_set_idempotency_level(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.idempotency_level)
+inline void MethodOptions::set_idempotency_level(::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel value)
+{
+    _internal_set_idempotency_level(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.idempotency_level)
 }
 
 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
-inline int MethodOptions::_internal_uninterpreted_option_size() const {
-  return _impl_.uninterpreted_option_.size();
-}
-inline int MethodOptions::uninterpreted_option_size() const {
-  return _internal_uninterpreted_option_size();
-}
-inline void MethodOptions::clear_uninterpreted_option() {
-  _impl_.uninterpreted_option_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >*
-MethodOptions::mutable_uninterpreted_option() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.MethodOptions.uninterpreted_option)
-  return &_impl_.uninterpreted_option_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MethodOptions::_internal_uninterpreted_option(int index) const {
-  return _impl_.uninterpreted_option_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.uninterpreted_option)
-  return _internal_uninterpreted_option(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::_internal_add_uninterpreted_option() {
-  return _impl_.uninterpreted_option_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::add_uninterpreted_option() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
-  // @@protoc_insertion_point(field_add:google.protobuf.MethodOptions.uninterpreted_option)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption >&
-MethodOptions::uninterpreted_option() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.MethodOptions.uninterpreted_option)
-  return _impl_.uninterpreted_option_;
+inline int MethodOptions::_internal_uninterpreted_option_size() const
+{
+    return _impl_.uninterpreted_option_.size();
+}
+inline int MethodOptions::uninterpreted_option_size() const
+{
+    return _internal_uninterpreted_option_size();
+}
+inline void MethodOptions::clear_uninterpreted_option()
+{
+    _impl_.uninterpreted_option_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.MethodOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>*
+    MethodOptions::mutable_uninterpreted_option()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.MethodOptions.uninterpreted_option)
+    return &_impl_.uninterpreted_option_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MethodOptions::_internal_uninterpreted_option(int index) const
+{
+    return _impl_.uninterpreted_option_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.uninterpreted_option)
+    return _internal_uninterpreted_option(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::_internal_add_uninterpreted_option()
+{
+    return _impl_.uninterpreted_option_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* MethodOptions::add_uninterpreted_option()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption* _add = _internal_add_uninterpreted_option();
+    // @@protoc_insertion_point(field_add:google.protobuf.MethodOptions.uninterpreted_option)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption>&
+    MethodOptions::uninterpreted_option() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.MethodOptions.uninterpreted_option)
+    return _impl_.uninterpreted_option_;
 }
 
 // -------------------------------------------------------------------
@@ -13721,99 +16961,122 @@ MethodOptions::uninterpreted_option() const {
 // UninterpretedOption_NamePart
 
 // required string name_part = 1;
-inline bool UninterpretedOption_NamePart::_internal_has_name_part() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool UninterpretedOption_NamePart::has_name_part() const {
-  return _internal_has_name_part();
-}
-inline void UninterpretedOption_NamePart::clear_name_part() {
-  _impl_.name_part_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& UninterpretedOption_NamePart::name_part() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.name_part)
-  return _internal_name_part();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void UninterpretedOption_NamePart::set_name_part(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.name_part_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.name_part)
-}
-inline std::string* UninterpretedOption_NamePart::mutable_name_part() {
-  std::string* _s = _internal_mutable_name_part();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.NamePart.name_part)
-  return _s;
-}
-inline const std::string& UninterpretedOption_NamePart::_internal_name_part() const {
-  return _impl_.name_part_.Get();
-}
-inline void UninterpretedOption_NamePart::_internal_set_name_part(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.name_part_.Set(value, GetArenaForAllocation());
-}
-inline std::string* UninterpretedOption_NamePart::_internal_mutable_name_part() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.name_part_.Mutable(GetArenaForAllocation());
-}
-inline std::string* UninterpretedOption_NamePart::release_name_part() {
-  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.NamePart.name_part)
-  if (!_internal_has_name_part()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.name_part_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_part_.IsDefault()) {
-    _impl_.name_part_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void UninterpretedOption_NamePart::set_allocated_name_part(std::string* name_part) {
-  if (name_part != nullptr) {
+inline bool UninterpretedOption_NamePart::_internal_has_name_part() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool UninterpretedOption_NamePart::has_name_part() const
+{
+    return _internal_has_name_part();
+}
+inline void UninterpretedOption_NamePart::clear_name_part()
+{
+    _impl_.name_part_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& UninterpretedOption_NamePart::name_part() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.name_part)
+    return _internal_name_part();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void UninterpretedOption_NamePart::set_name_part(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_part_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+inline std::string* UninterpretedOption_NamePart::mutable_name_part()
+{
+    std::string* _s = _internal_mutable_name_part();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.NamePart.name_part)
+    return _s;
+}
+inline const std::string& UninterpretedOption_NamePart::_internal_name_part() const
+{
+    return _impl_.name_part_.Get();
+}
+inline void UninterpretedOption_NamePart::_internal_set_name_part(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.name_part_.Set(value, GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption_NamePart::_internal_mutable_name_part()
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    return _impl_.name_part_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption_NamePart::release_name_part()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.NamePart.name_part)
+    if (!_internal_has_name_part())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.name_part_.SetAllocated(name_part, GetArenaForAllocation());
+    auto* p = _impl_.name_part_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.name_part_.IsDefault())
+    {
+        _impl_.name_part_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void UninterpretedOption_NamePart::set_allocated_name_part(std::string* name_part)
+{
+    if (name_part != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.name_part_.SetAllocated(name_part, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_part_.IsDefault()) {
-    _impl_.name_part_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.NamePart.name_part)
+    if (_impl_.name_part_.IsDefault())
+    {
+        _impl_.name_part_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.NamePart.name_part)
 }
 
 // required bool is_extension = 2;
-inline bool UninterpretedOption_NamePart::_internal_has_is_extension() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool UninterpretedOption_NamePart::has_is_extension() const {
-  return _internal_has_is_extension();
-}
-inline void UninterpretedOption_NamePart::clear_is_extension() {
-  _impl_.is_extension_ = false;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool UninterpretedOption_NamePart::_internal_has_is_extension() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool UninterpretedOption_NamePart::has_is_extension() const
+{
+    return _internal_has_is_extension();
+}
+inline void UninterpretedOption_NamePart::clear_is_extension()
+{
+    _impl_.is_extension_ = false;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline bool UninterpretedOption_NamePart::_internal_is_extension() const {
-  return _impl_.is_extension_;
+inline bool UninterpretedOption_NamePart::_internal_is_extension() const
+{
+    return _impl_.is_extension_;
 }
-inline bool UninterpretedOption_NamePart::is_extension() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.is_extension)
-  return _internal_is_extension();
+inline bool UninterpretedOption_NamePart::is_extension() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.is_extension)
+    return _internal_is_extension();
 }
-inline void UninterpretedOption_NamePart::_internal_set_is_extension(bool value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.is_extension_ = value;
+inline void UninterpretedOption_NamePart::_internal_set_is_extension(bool value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.is_extension_ = value;
 }
-inline void UninterpretedOption_NamePart::set_is_extension(bool value) {
-  _internal_set_is_extension(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.is_extension)
+inline void UninterpretedOption_NamePart::set_is_extension(bool value)
+{
+    _internal_set_is_extension(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.is_extension)
 }
 
 // -------------------------------------------------------------------
@@ -13821,331 +17084,410 @@ inline void UninterpretedOption_NamePart::set_is_extension(bool value) {
 // UninterpretedOption
 
 // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
-inline int UninterpretedOption::_internal_name_size() const {
-  return _impl_.name_.size();
-}
-inline int UninterpretedOption::name_size() const {
-  return _internal_name_size();
-}
-inline void UninterpretedOption::clear_name() {
-  _impl_.name_.Clear();
+inline int UninterpretedOption::_internal_name_size() const
+{
+    return _impl_.name_.size();
+}
+inline int UninterpretedOption::name_size() const
+{
+    return _internal_name_size();
+}
+inline void UninterpretedOption::clear_name()
+{
+    _impl_.name_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.name)
+    return _impl_.name_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>*
+    UninterpretedOption::mutable_name()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.UninterpretedOption.name)
+    return &_impl_.name_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& UninterpretedOption::_internal_name(int index) const
+{
+    return _impl_.name_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.name)
+    return _internal_name(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::_internal_add_name()
+{
+    return _impl_.name_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::add_name()
+{
+    ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* _add = _internal_add_name();
+    // @@protoc_insertion_point(field_add:google.protobuf.UninterpretedOption.name)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart>&
+    UninterpretedOption::name() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.UninterpretedOption.name)
+    return _impl_.name_;
 }
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.name)
-  return _impl_.name_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >*
-UninterpretedOption::mutable_name() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.UninterpretedOption.name)
-  return &_impl_.name_;
+
+// optional string identifier_value = 3;
+inline bool UninterpretedOption::_internal_has_identifier_value() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool UninterpretedOption::has_identifier_value() const
+{
+    return _internal_has_identifier_value();
+}
+inline void UninterpretedOption::clear_identifier_value()
+{
+    _impl_.identifier_value_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& UninterpretedOption::_internal_name(int index) const {
-  return _impl_.name_.Get(index);
+inline const std::string& UninterpretedOption::identifier_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.identifier_value)
+    return _internal_identifier_value();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.name)
-  return _internal_name(index);
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void UninterpretedOption::set_identifier_value(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.identifier_value_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.identifier_value)
 }
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::_internal_add_name() {
-  return _impl_.name_.Add();
+inline std::string* UninterpretedOption::mutable_identifier_value()
+{
+    std::string* _s = _internal_mutable_identifier_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.identifier_value)
+    return _s;
 }
-inline ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* UninterpretedOption::add_name() {
-  ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart* _add = _internal_add_name();
-  // @@protoc_insertion_point(field_add:google.protobuf.UninterpretedOption.name)
-  return _add;
+inline const std::string& UninterpretedOption::_internal_identifier_value() const
+{
+    return _impl_.identifier_value_.Get();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::UninterpretedOption_NamePart >&
-UninterpretedOption::name() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.UninterpretedOption.name)
-  return _impl_.name_;
+inline void UninterpretedOption::_internal_set_identifier_value(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.identifier_value_.Set(value, GetArenaForAllocation());
 }
-
-// optional string identifier_value = 3;
-inline bool UninterpretedOption::_internal_has_identifier_value() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool UninterpretedOption::has_identifier_value() const {
-  return _internal_has_identifier_value();
-}
-inline void UninterpretedOption::clear_identifier_value() {
-  _impl_.identifier_value_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& UninterpretedOption::identifier_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.identifier_value)
-  return _internal_identifier_value();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void UninterpretedOption::set_identifier_value(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.identifier_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.identifier_value)
-}
-inline std::string* UninterpretedOption::mutable_identifier_value() {
-  std::string* _s = _internal_mutable_identifier_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.identifier_value)
-  return _s;
-}
-inline const std::string& UninterpretedOption::_internal_identifier_value() const {
-  return _impl_.identifier_value_.Get();
-}
-inline void UninterpretedOption::_internal_set_identifier_value(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.identifier_value_.Set(value, GetArenaForAllocation());
-}
-inline std::string* UninterpretedOption::_internal_mutable_identifier_value() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.identifier_value_.Mutable(GetArenaForAllocation());
-}
-inline std::string* UninterpretedOption::release_identifier_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.identifier_value)
-  if (!_internal_has_identifier_value()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.identifier_value_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.identifier_value_.IsDefault()) {
-    _impl_.identifier_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void UninterpretedOption::set_allocated_identifier_value(std::string* identifier_value) {
-  if (identifier_value != nullptr) {
+inline std::string* UninterpretedOption::_internal_mutable_identifier_value()
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    return _impl_.identifier_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::release_identifier_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.identifier_value)
+    if (!_internal_has_identifier_value())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.identifier_value_.SetAllocated(identifier_value, GetArenaForAllocation());
+    auto* p = _impl_.identifier_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.identifier_value_.IsDefault())
+    {
+        _impl_.identifier_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void UninterpretedOption::set_allocated_identifier_value(std::string* identifier_value)
+{
+    if (identifier_value != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.identifier_value_.SetAllocated(identifier_value, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.identifier_value_.IsDefault()) {
-    _impl_.identifier_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.identifier_value)
+    if (_impl_.identifier_value_.IsDefault())
+    {
+        _impl_.identifier_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.identifier_value)
 }
 
 // optional uint64 positive_int_value = 4;
-inline bool UninterpretedOption::_internal_has_positive_int_value() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
-  return value;
-}
-inline bool UninterpretedOption::has_positive_int_value() const {
-  return _internal_has_positive_int_value();
-}
-inline void UninterpretedOption::clear_positive_int_value() {
-  _impl_.positive_int_value_ = uint64_t{0u};
-  _impl_._has_bits_[0] &= ~0x00000008u;
+inline bool UninterpretedOption::_internal_has_positive_int_value() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
+    return value;
+}
+inline bool UninterpretedOption::has_positive_int_value() const
+{
+    return _internal_has_positive_int_value();
+}
+inline void UninterpretedOption::clear_positive_int_value()
+{
+    _impl_.positive_int_value_ = uint64_t{0u};
+    _impl_._has_bits_[0] &= ~0x00000008u;
 }
-inline uint64_t UninterpretedOption::_internal_positive_int_value() const {
-  return _impl_.positive_int_value_;
+inline uint64_t UninterpretedOption::_internal_positive_int_value() const
+{
+    return _impl_.positive_int_value_;
 }
-inline uint64_t UninterpretedOption::positive_int_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.positive_int_value)
-  return _internal_positive_int_value();
+inline uint64_t UninterpretedOption::positive_int_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.positive_int_value)
+    return _internal_positive_int_value();
 }
-inline void UninterpretedOption::_internal_set_positive_int_value(uint64_t value) {
-  _impl_._has_bits_[0] |= 0x00000008u;
-  _impl_.positive_int_value_ = value;
+inline void UninterpretedOption::_internal_set_positive_int_value(uint64_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000008u;
+    _impl_.positive_int_value_ = value;
 }
-inline void UninterpretedOption::set_positive_int_value(uint64_t value) {
-  _internal_set_positive_int_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.positive_int_value)
+inline void UninterpretedOption::set_positive_int_value(uint64_t value)
+{
+    _internal_set_positive_int_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.positive_int_value)
 }
 
 // optional int64 negative_int_value = 5;
-inline bool UninterpretedOption::_internal_has_negative_int_value() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
-  return value;
-}
-inline bool UninterpretedOption::has_negative_int_value() const {
-  return _internal_has_negative_int_value();
-}
-inline void UninterpretedOption::clear_negative_int_value() {
-  _impl_.negative_int_value_ = int64_t{0};
-  _impl_._has_bits_[0] &= ~0x00000010u;
+inline bool UninterpretedOption::_internal_has_negative_int_value() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
+    return value;
+}
+inline bool UninterpretedOption::has_negative_int_value() const
+{
+    return _internal_has_negative_int_value();
+}
+inline void UninterpretedOption::clear_negative_int_value()
+{
+    _impl_.negative_int_value_ = int64_t{0};
+    _impl_._has_bits_[0] &= ~0x00000010u;
 }
-inline int64_t UninterpretedOption::_internal_negative_int_value() const {
-  return _impl_.negative_int_value_;
+inline int64_t UninterpretedOption::_internal_negative_int_value() const
+{
+    return _impl_.negative_int_value_;
 }
-inline int64_t UninterpretedOption::negative_int_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.negative_int_value)
-  return _internal_negative_int_value();
+inline int64_t UninterpretedOption::negative_int_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.negative_int_value)
+    return _internal_negative_int_value();
 }
-inline void UninterpretedOption::_internal_set_negative_int_value(int64_t value) {
-  _impl_._has_bits_[0] |= 0x00000010u;
-  _impl_.negative_int_value_ = value;
+inline void UninterpretedOption::_internal_set_negative_int_value(int64_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000010u;
+    _impl_.negative_int_value_ = value;
 }
-inline void UninterpretedOption::set_negative_int_value(int64_t value) {
-  _internal_set_negative_int_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.negative_int_value)
+inline void UninterpretedOption::set_negative_int_value(int64_t value)
+{
+    _internal_set_negative_int_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.negative_int_value)
 }
 
 // optional double double_value = 6;
-inline bool UninterpretedOption::_internal_has_double_value() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
-  return value;
-}
-inline bool UninterpretedOption::has_double_value() const {
-  return _internal_has_double_value();
-}
-inline void UninterpretedOption::clear_double_value() {
-  _impl_.double_value_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000020u;
+inline bool UninterpretedOption::_internal_has_double_value() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
+    return value;
+}
+inline bool UninterpretedOption::has_double_value() const
+{
+    return _internal_has_double_value();
+}
+inline void UninterpretedOption::clear_double_value()
+{
+    _impl_.double_value_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000020u;
 }
-inline double UninterpretedOption::_internal_double_value() const {
-  return _impl_.double_value_;
+inline double UninterpretedOption::_internal_double_value() const
+{
+    return _impl_.double_value_;
 }
-inline double UninterpretedOption::double_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.double_value)
-  return _internal_double_value();
+inline double UninterpretedOption::double_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.double_value)
+    return _internal_double_value();
 }
-inline void UninterpretedOption::_internal_set_double_value(double value) {
-  _impl_._has_bits_[0] |= 0x00000020u;
-  _impl_.double_value_ = value;
+inline void UninterpretedOption::_internal_set_double_value(double value)
+{
+    _impl_._has_bits_[0] |= 0x00000020u;
+    _impl_.double_value_ = value;
 }
-inline void UninterpretedOption::set_double_value(double value) {
-  _internal_set_double_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.double_value)
+inline void UninterpretedOption::set_double_value(double value)
+{
+    _internal_set_double_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.double_value)
 }
 
 // optional bytes string_value = 7;
-inline bool UninterpretedOption::_internal_has_string_value() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool UninterpretedOption::has_string_value() const {
-  return _internal_has_string_value();
-}
-inline void UninterpretedOption::clear_string_value() {
-  _impl_.string_value_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& UninterpretedOption::string_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.string_value)
-  return _internal_string_value();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void UninterpretedOption::set_string_value(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000002u;
- _impl_.string_value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.string_value)
-}
-inline std::string* UninterpretedOption::mutable_string_value() {
-  std::string* _s = _internal_mutable_string_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.string_value)
-  return _s;
-}
-inline const std::string& UninterpretedOption::_internal_string_value() const {
-  return _impl_.string_value_.Get();
-}
-inline void UninterpretedOption::_internal_set_string_value(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.string_value_.Set(value, GetArenaForAllocation());
-}
-inline std::string* UninterpretedOption::_internal_mutable_string_value() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  return _impl_.string_value_.Mutable(GetArenaForAllocation());
-}
-inline std::string* UninterpretedOption::release_string_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.string_value)
-  if (!_internal_has_string_value()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  auto* p = _impl_.string_value_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.string_value_.IsDefault()) {
-    _impl_.string_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void UninterpretedOption::set_allocated_string_value(std::string* string_value) {
-  if (string_value != nullptr) {
+inline bool UninterpretedOption::_internal_has_string_value() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool UninterpretedOption::has_string_value() const
+{
+    return _internal_has_string_value();
+}
+inline void UninterpretedOption::clear_string_value()
+{
+    _impl_.string_value_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& UninterpretedOption::string_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.string_value)
+    return _internal_string_value();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void UninterpretedOption::set_string_value(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.string_value_.SetBytes(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.string_value)
+}
+inline std::string* UninterpretedOption::mutable_string_value()
+{
+    std::string* _s = _internal_mutable_string_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.string_value)
+    return _s;
+}
+inline const std::string& UninterpretedOption::_internal_string_value() const
+{
+    return _impl_.string_value_.Get();
+}
+inline void UninterpretedOption::_internal_set_string_value(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.string_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::_internal_mutable_string_value()
+{
     _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+    return _impl_.string_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::release_string_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.string_value)
+    if (!_internal_has_string_value())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.string_value_.SetAllocated(string_value, GetArenaForAllocation());
+    auto* p = _impl_.string_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.string_value_.IsDefault())
+    {
+        _impl_.string_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void UninterpretedOption::set_allocated_string_value(std::string* string_value)
+{
+    if (string_value != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.string_value_.SetAllocated(string_value, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.string_value_.IsDefault()) {
-    _impl_.string_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.string_value)
+    if (_impl_.string_value_.IsDefault())
+    {
+        _impl_.string_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.string_value)
 }
 
 // optional string aggregate_value = 8;
-inline bool UninterpretedOption::_internal_has_aggregate_value() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool UninterpretedOption::has_aggregate_value() const {
-  return _internal_has_aggregate_value();
-}
-inline void UninterpretedOption::clear_aggregate_value() {
-  _impl_.aggregate_value_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000004u;
-}
-inline const std::string& UninterpretedOption::aggregate_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.aggregate_value)
-  return _internal_aggregate_value();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void UninterpretedOption::set_aggregate_value(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000004u;
- _impl_.aggregate_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.aggregate_value)
-}
-inline std::string* UninterpretedOption::mutable_aggregate_value() {
-  std::string* _s = _internal_mutable_aggregate_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.aggregate_value)
-  return _s;
-}
-inline const std::string& UninterpretedOption::_internal_aggregate_value() const {
-  return _impl_.aggregate_value_.Get();
-}
-inline void UninterpretedOption::_internal_set_aggregate_value(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.aggregate_value_.Set(value, GetArenaForAllocation());
-}
-inline std::string* UninterpretedOption::_internal_mutable_aggregate_value() {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  return _impl_.aggregate_value_.Mutable(GetArenaForAllocation());
-}
-inline std::string* UninterpretedOption::release_aggregate_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.aggregate_value)
-  if (!_internal_has_aggregate_value()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000004u;
-  auto* p = _impl_.aggregate_value_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.aggregate_value_.IsDefault()) {
-    _impl_.aggregate_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void UninterpretedOption::set_allocated_aggregate_value(std::string* aggregate_value) {
-  if (aggregate_value != nullptr) {
+inline bool UninterpretedOption::_internal_has_aggregate_value() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool UninterpretedOption::has_aggregate_value() const
+{
+    return _internal_has_aggregate_value();
+}
+inline void UninterpretedOption::clear_aggregate_value()
+{
+    _impl_.aggregate_value_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& UninterpretedOption::aggregate_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.aggregate_value)
+    return _internal_aggregate_value();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void UninterpretedOption::set_aggregate_value(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.aggregate_value_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.aggregate_value)
+}
+inline std::string* UninterpretedOption::mutable_aggregate_value()
+{
+    std::string* _s = _internal_mutable_aggregate_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.aggregate_value)
+    return _s;
+}
+inline const std::string& UninterpretedOption::_internal_aggregate_value() const
+{
+    return _impl_.aggregate_value_.Get();
+}
+inline void UninterpretedOption::_internal_set_aggregate_value(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.aggregate_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::_internal_mutable_aggregate_value()
+{
     _impl_._has_bits_[0] |= 0x00000004u;
-  } else {
+    return _impl_.aggregate_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* UninterpretedOption::release_aggregate_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.aggregate_value)
+    if (!_internal_has_aggregate_value())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000004u;
-  }
-  _impl_.aggregate_value_.SetAllocated(aggregate_value, GetArenaForAllocation());
+    auto* p = _impl_.aggregate_value_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.aggregate_value_.IsDefault())
+    {
+        _impl_.aggregate_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void UninterpretedOption::set_allocated_aggregate_value(std::string* aggregate_value)
+{
+    if (aggregate_value != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000004u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000004u;
+    }
+    _impl_.aggregate_value_.SetAllocated(aggregate_value, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.aggregate_value_.IsDefault()) {
-    _impl_.aggregate_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.aggregate_value)
+    if (_impl_.aggregate_value_.IsDefault())
+    {
+        _impl_.aggregate_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.aggregate_value)
 }
 
 // -------------------------------------------------------------------
@@ -14153,308 +17495,383 @@ inline void UninterpretedOption::set_allocated_aggregate_value(std::string* aggr
 // SourceCodeInfo_Location
 
 // repeated int32 path = 1 [packed = true];
-inline int SourceCodeInfo_Location::_internal_path_size() const {
-  return _impl_.path_.size();
-}
-inline int SourceCodeInfo_Location::path_size() const {
-  return _internal_path_size();
-}
-inline void SourceCodeInfo_Location::clear_path() {
-  _impl_.path_.Clear();
-}
-inline int32_t SourceCodeInfo_Location::_internal_path(int index) const {
-  return _impl_.path_.Get(index);
-}
-inline int32_t SourceCodeInfo_Location::path(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.path)
-  return _internal_path(index);
-}
-inline void SourceCodeInfo_Location::set_path(int index, int32_t value) {
-  _impl_.path_.Set(index, value);
-  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.path)
-}
-inline void SourceCodeInfo_Location::_internal_add_path(int32_t value) {
-  _impl_.path_.Add(value);
-}
-inline void SourceCodeInfo_Location::add_path(int32_t value) {
-  _internal_add_path(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.path)
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-SourceCodeInfo_Location::_internal_path() const {
-  return _impl_.path_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-SourceCodeInfo_Location::path() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.path)
-  return _internal_path();
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-SourceCodeInfo_Location::_internal_mutable_path() {
-  return &_impl_.path_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-SourceCodeInfo_Location::mutable_path() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.path)
-  return _internal_mutable_path();
+inline int SourceCodeInfo_Location::_internal_path_size() const
+{
+    return _impl_.path_.size();
+}
+inline int SourceCodeInfo_Location::path_size() const
+{
+    return _internal_path_size();
+}
+inline void SourceCodeInfo_Location::clear_path()
+{
+    _impl_.path_.Clear();
+}
+inline int32_t SourceCodeInfo_Location::_internal_path(int index) const
+{
+    return _impl_.path_.Get(index);
+}
+inline int32_t SourceCodeInfo_Location::path(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.path)
+    return _internal_path(index);
+}
+inline void SourceCodeInfo_Location::set_path(int index, int32_t value)
+{
+    _impl_.path_.Set(index, value);
+    // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.path)
+}
+inline void SourceCodeInfo_Location::_internal_add_path(int32_t value)
+{
+    _impl_.path_.Add(value);
+}
+inline void SourceCodeInfo_Location::add_path(int32_t value)
+{
+    _internal_add_path(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.path)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    SourceCodeInfo_Location::_internal_path() const
+{
+    return _impl_.path_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    SourceCodeInfo_Location::path() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.path)
+    return _internal_path();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    SourceCodeInfo_Location::_internal_mutable_path()
+{
+    return &_impl_.path_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    SourceCodeInfo_Location::mutable_path()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.path)
+    return _internal_mutable_path();
 }
 
 // repeated int32 span = 2 [packed = true];
-inline int SourceCodeInfo_Location::_internal_span_size() const {
-  return _impl_.span_.size();
-}
-inline int SourceCodeInfo_Location::span_size() const {
-  return _internal_span_size();
-}
-inline void SourceCodeInfo_Location::clear_span() {
-  _impl_.span_.Clear();
+inline int SourceCodeInfo_Location::_internal_span_size() const
+{
+    return _impl_.span_.size();
+}
+inline int SourceCodeInfo_Location::span_size() const
+{
+    return _internal_span_size();
+}
+inline void SourceCodeInfo_Location::clear_span()
+{
+    _impl_.span_.Clear();
+}
+inline int32_t SourceCodeInfo_Location::_internal_span(int index) const
+{
+    return _impl_.span_.Get(index);
+}
+inline int32_t SourceCodeInfo_Location::span(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.span)
+    return _internal_span(index);
+}
+inline void SourceCodeInfo_Location::set_span(int index, int32_t value)
+{
+    _impl_.span_.Set(index, value);
+    // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.span)
+}
+inline void SourceCodeInfo_Location::_internal_add_span(int32_t value)
+{
+    _impl_.span_.Add(value);
+}
+inline void SourceCodeInfo_Location::add_span(int32_t value)
+{
+    _internal_add_span(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.span)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    SourceCodeInfo_Location::_internal_span() const
+{
+    return _impl_.span_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    SourceCodeInfo_Location::span() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.span)
+    return _internal_span();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    SourceCodeInfo_Location::_internal_mutable_span()
+{
+    return &_impl_.span_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    SourceCodeInfo_Location::mutable_span()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.span)
+    return _internal_mutable_span();
 }
-inline int32_t SourceCodeInfo_Location::_internal_span(int index) const {
-  return _impl_.span_.Get(index);
-}
-inline int32_t SourceCodeInfo_Location::span(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.span)
-  return _internal_span(index);
-}
-inline void SourceCodeInfo_Location::set_span(int index, int32_t value) {
-  _impl_.span_.Set(index, value);
-  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.span)
-}
-inline void SourceCodeInfo_Location::_internal_add_span(int32_t value) {
-  _impl_.span_.Add(value);
+
+// optional string leading_comments = 3;
+inline bool SourceCodeInfo_Location::_internal_has_leading_comments() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool SourceCodeInfo_Location::has_leading_comments() const
+{
+    return _internal_has_leading_comments();
+}
+inline void SourceCodeInfo_Location::clear_leading_comments()
+{
+    _impl_.leading_comments_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline void SourceCodeInfo_Location::add_span(int32_t value) {
-  _internal_add_span(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.span)
+inline const std::string& SourceCodeInfo_Location::leading_comments() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_comments)
+    return _internal_leading_comments();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-SourceCodeInfo_Location::_internal_span() const {
-  return _impl_.span_;
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void SourceCodeInfo_Location::set_leading_comments(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.leading_comments_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_comments)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-SourceCodeInfo_Location::span() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.span)
-  return _internal_span();
+inline std::string* SourceCodeInfo_Location::mutable_leading_comments()
+{
+    std::string* _s = _internal_mutable_leading_comments();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_comments)
+    return _s;
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-SourceCodeInfo_Location::_internal_mutable_span() {
-  return &_impl_.span_;
+inline const std::string& SourceCodeInfo_Location::_internal_leading_comments() const
+{
+    return _impl_.leading_comments_.Get();
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-SourceCodeInfo_Location::mutable_span() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.span)
-  return _internal_mutable_span();
+inline void SourceCodeInfo_Location::_internal_set_leading_comments(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.leading_comments_.Set(value, GetArenaForAllocation());
 }
-
-// optional string leading_comments = 3;
-inline bool SourceCodeInfo_Location::_internal_has_leading_comments() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool SourceCodeInfo_Location::has_leading_comments() const {
-  return _internal_has_leading_comments();
-}
-inline void SourceCodeInfo_Location::clear_leading_comments() {
-  _impl_.leading_comments_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& SourceCodeInfo_Location::leading_comments() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_comments)
-  return _internal_leading_comments();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void SourceCodeInfo_Location::set_leading_comments(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.leading_comments_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_comments)
-}
-inline std::string* SourceCodeInfo_Location::mutable_leading_comments() {
-  std::string* _s = _internal_mutable_leading_comments();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_comments)
-  return _s;
-}
-inline const std::string& SourceCodeInfo_Location::_internal_leading_comments() const {
-  return _impl_.leading_comments_.Get();
-}
-inline void SourceCodeInfo_Location::_internal_set_leading_comments(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.leading_comments_.Set(value, GetArenaForAllocation());
-}
-inline std::string* SourceCodeInfo_Location::_internal_mutable_leading_comments() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.leading_comments_.Mutable(GetArenaForAllocation());
-}
-inline std::string* SourceCodeInfo_Location::release_leading_comments() {
-  // @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.leading_comments)
-  if (!_internal_has_leading_comments()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.leading_comments_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.leading_comments_.IsDefault()) {
-    _impl_.leading_comments_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void SourceCodeInfo_Location::set_allocated_leading_comments(std::string* leading_comments) {
-  if (leading_comments != nullptr) {
+inline std::string* SourceCodeInfo_Location::_internal_mutable_leading_comments()
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    return _impl_.leading_comments_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SourceCodeInfo_Location::release_leading_comments()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.leading_comments)
+    if (!_internal_has_leading_comments())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.leading_comments_.SetAllocated(leading_comments, GetArenaForAllocation());
+    auto* p = _impl_.leading_comments_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.leading_comments_.IsDefault())
+    {
+        _impl_.leading_comments_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void SourceCodeInfo_Location::set_allocated_leading_comments(std::string* leading_comments)
+{
+    if (leading_comments != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.leading_comments_.SetAllocated(leading_comments, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.leading_comments_.IsDefault()) {
-    _impl_.leading_comments_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.leading_comments)
+    if (_impl_.leading_comments_.IsDefault())
+    {
+        _impl_.leading_comments_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.leading_comments)
 }
 
 // optional string trailing_comments = 4;
-inline bool SourceCodeInfo_Location::_internal_has_trailing_comments() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool SourceCodeInfo_Location::has_trailing_comments() const {
-  return _internal_has_trailing_comments();
-}
-inline void SourceCodeInfo_Location::clear_trailing_comments() {
-  _impl_.trailing_comments_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000002u;
-}
-inline const std::string& SourceCodeInfo_Location::trailing_comments() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.trailing_comments)
-  return _internal_trailing_comments();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void SourceCodeInfo_Location::set_trailing_comments(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000002u;
- _impl_.trailing_comments_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.trailing_comments)
-}
-inline std::string* SourceCodeInfo_Location::mutable_trailing_comments() {
-  std::string* _s = _internal_mutable_trailing_comments();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.trailing_comments)
-  return _s;
-}
-inline const std::string& SourceCodeInfo_Location::_internal_trailing_comments() const {
-  return _impl_.trailing_comments_.Get();
-}
-inline void SourceCodeInfo_Location::_internal_set_trailing_comments(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.trailing_comments_.Set(value, GetArenaForAllocation());
-}
-inline std::string* SourceCodeInfo_Location::_internal_mutable_trailing_comments() {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  return _impl_.trailing_comments_.Mutable(GetArenaForAllocation());
-}
-inline std::string* SourceCodeInfo_Location::release_trailing_comments() {
-  // @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.trailing_comments)
-  if (!_internal_has_trailing_comments()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000002u;
-  auto* p = _impl_.trailing_comments_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.trailing_comments_.IsDefault()) {
-    _impl_.trailing_comments_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void SourceCodeInfo_Location::set_allocated_trailing_comments(std::string* trailing_comments) {
-  if (trailing_comments != nullptr) {
-    _impl_._has_bits_[0] |= 0x00000002u;
-  } else {
+inline bool SourceCodeInfo_Location::_internal_has_trailing_comments() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool SourceCodeInfo_Location::has_trailing_comments() const
+{
+    return _internal_has_trailing_comments();
+}
+inline void SourceCodeInfo_Location::clear_trailing_comments()
+{
+    _impl_.trailing_comments_.ClearToEmpty();
     _impl_._has_bits_[0] &= ~0x00000002u;
-  }
-  _impl_.trailing_comments_.SetAllocated(trailing_comments, GetArenaForAllocation());
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.trailing_comments_.IsDefault()) {
-    _impl_.trailing_comments_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.trailing_comments)
-}
-
-// repeated string leading_detached_comments = 6;
-inline int SourceCodeInfo_Location::_internal_leading_detached_comments_size() const {
-  return _impl_.leading_detached_comments_.size();
-}
-inline int SourceCodeInfo_Location::leading_detached_comments_size() const {
-  return _internal_leading_detached_comments_size();
 }
-inline void SourceCodeInfo_Location::clear_leading_detached_comments() {
-  _impl_.leading_detached_comments_.Clear();
+inline const std::string& SourceCodeInfo_Location::trailing_comments() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+    return _internal_trailing_comments();
 }
-inline std::string* SourceCodeInfo_Location::add_leading_detached_comments() {
-  std::string* _s = _internal_add_leading_detached_comments();
-  // @@protoc_insertion_point(field_add_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
-  return _s;
-}
-inline const std::string& SourceCodeInfo_Location::_internal_leading_detached_comments(int index) const {
-  return _impl_.leading_detached_comments_.Get(index);
-}
-inline const std::string& SourceCodeInfo_Location::leading_detached_comments(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
-  return _internal_leading_detached_comments(index);
-}
-inline std::string* SourceCodeInfo_Location::mutable_leading_detached_comments(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
-  return _impl_.leading_detached_comments_.Mutable(index);
-}
-inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const std::string& value) {
-  _impl_.leading_detached_comments_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
-}
-inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, std::string&& value) {
-  _impl_.leading_detached_comments_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
-}
-inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.leading_detached_comments_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
-}
-inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value, size_t size) {
-  _impl_.leading_detached_comments_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void SourceCodeInfo_Location::set_trailing_comments(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.trailing_comments_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.trailing_comments)
 }
-inline std::string* SourceCodeInfo_Location::_internal_add_leading_detached_comments() {
-  return _impl_.leading_detached_comments_.Add();
+inline std::string* SourceCodeInfo_Location::mutable_trailing_comments()
+{
+    std::string* _s = _internal_mutable_trailing_comments();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+    return _s;
 }
-inline void SourceCodeInfo_Location::add_leading_detached_comments(const std::string& value) {
-  _impl_.leading_detached_comments_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+inline const std::string& SourceCodeInfo_Location::_internal_trailing_comments() const
+{
+    return _impl_.trailing_comments_.Get();
 }
-inline void SourceCodeInfo_Location::add_leading_detached_comments(std::string&& value) {
-  _impl_.leading_detached_comments_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+inline void SourceCodeInfo_Location::_internal_set_trailing_comments(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.trailing_comments_.Set(value, GetArenaForAllocation());
 }
-inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.leading_detached_comments_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+inline std::string* SourceCodeInfo_Location::_internal_mutable_trailing_comments()
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    return _impl_.trailing_comments_.Mutable(GetArenaForAllocation());
+}
+inline std::string* SourceCodeInfo_Location::release_trailing_comments()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+    if (!_internal_has_trailing_comments())
+    {
+        return nullptr;
+    }
+    _impl_._has_bits_[0] &= ~0x00000002u;
+    auto* p = _impl_.trailing_comments_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.trailing_comments_.IsDefault())
+    {
+        _impl_.trailing_comments_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void SourceCodeInfo_Location::set_allocated_trailing_comments(std::string* trailing_comments)
+{
+    if (trailing_comments != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000002u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000002u;
+    }
+    _impl_.trailing_comments_.SetAllocated(trailing_comments, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.trailing_comments_.IsDefault())
+    {
+        _impl_.trailing_comments_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.trailing_comments)
 }
-inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value, size_t size) {
-  _impl_.leading_detached_comments_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+
+// repeated string leading_detached_comments = 6;
+inline int SourceCodeInfo_Location::_internal_leading_detached_comments_size() const
+{
+    return _impl_.leading_detached_comments_.size();
+}
+inline int SourceCodeInfo_Location::leading_detached_comments_size() const
+{
+    return _internal_leading_detached_comments_size();
+}
+inline void SourceCodeInfo_Location::clear_leading_detached_comments()
+{
+    _impl_.leading_detached_comments_.Clear();
+}
+inline std::string* SourceCodeInfo_Location::add_leading_detached_comments()
+{
+    std::string* _s = _internal_add_leading_detached_comments();
+    // @@protoc_insertion_point(field_add_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+    return _s;
+}
+inline const std::string& SourceCodeInfo_Location::_internal_leading_detached_comments(int index) const
+{
+    return _impl_.leading_detached_comments_.Get(index);
+}
+inline const std::string& SourceCodeInfo_Location::leading_detached_comments(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+    return _internal_leading_detached_comments(index);
+}
+inline std::string* SourceCodeInfo_Location::mutable_leading_detached_comments(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+    return _impl_.leading_detached_comments_.Mutable(index);
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const std::string& value)
+{
+    _impl_.leading_detached_comments_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, std::string&& value)
+{
+    _impl_.leading_detached_comments_.Mutable(index)->assign(std::move(value));
+    // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.leading_detached_comments_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value, size_t size)
+{
+    _impl_.leading_detached_comments_.Mutable(index)->assign(
+        reinterpret_cast<const char*>(value), size
+    );
+    // @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline std::string* SourceCodeInfo_Location::_internal_add_leading_detached_comments()
+{
+    return _impl_.leading_detached_comments_.Add();
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const std::string& value)
+{
+    _impl_.leading_detached_comments_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(std::string&& value)
+{
+    _impl_.leading_detached_comments_.Add(std::move(value));
+    // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.leading_detached_comments_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value, size_t size)
+{
+    _impl_.leading_detached_comments_.Add()->assign(reinterpret_cast<const char*>(value), size);
+    // @@protoc_insertion_point(field_add_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-SourceCodeInfo_Location::leading_detached_comments() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
-  return _impl_.leading_detached_comments_;
+    SourceCodeInfo_Location::leading_detached_comments() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+    return _impl_.leading_detached_comments_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-SourceCodeInfo_Location::mutable_leading_detached_comments() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
-  return &_impl_.leading_detached_comments_;
+    SourceCodeInfo_Location::mutable_leading_detached_comments()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+    return &_impl_.leading_detached_comments_;
 }
 
 // -------------------------------------------------------------------
@@ -14462,43 +17879,53 @@ SourceCodeInfo_Location::mutable_leading_detached_comments() {
 // SourceCodeInfo
 
 // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
-inline int SourceCodeInfo::_internal_location_size() const {
-  return _impl_.location_.size();
-}
-inline int SourceCodeInfo::location_size() const {
-  return _internal_location_size();
-}
-inline void SourceCodeInfo::clear_location() {
-  _impl_.location_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::mutable_location(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.location)
-  return _impl_.location_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >*
-SourceCodeInfo::mutable_location() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.location)
-  return &_impl_.location_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& SourceCodeInfo::_internal_location(int index) const {
-  return _impl_.location_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& SourceCodeInfo::location(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.location)
-  return _internal_location(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::_internal_add_location() {
-  return _impl_.location_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::add_location() {
-  ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* _add = _internal_add_location();
-  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.location)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location >&
-SourceCodeInfo::location() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.location)
-  return _impl_.location_;
+inline int SourceCodeInfo::_internal_location_size() const
+{
+    return _impl_.location_.size();
+}
+inline int SourceCodeInfo::location_size() const
+{
+    return _internal_location_size();
+}
+inline void SourceCodeInfo::clear_location()
+{
+    _impl_.location_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::mutable_location(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.location)
+    return _impl_.location_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>*
+    SourceCodeInfo::mutable_location()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.location)
+    return &_impl_.location_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& SourceCodeInfo::_internal_location(int index) const
+{
+    return _impl_.location_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location& SourceCodeInfo::location(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.location)
+    return _internal_location(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::_internal_add_location()
+{
+    return _impl_.location_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* SourceCodeInfo::add_location()
+{
+    ::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location* _add = _internal_add_location();
+    // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.location)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::SourceCodeInfo_Location>&
+    SourceCodeInfo::location() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.location)
+    return _impl_.location_;
 }
 
 // -------------------------------------------------------------------
@@ -14506,174 +17933,216 @@ SourceCodeInfo::location() const {
 // GeneratedCodeInfo_Annotation
 
 // repeated int32 path = 1 [packed = true];
-inline int GeneratedCodeInfo_Annotation::_internal_path_size() const {
-  return _impl_.path_.size();
-}
-inline int GeneratedCodeInfo_Annotation::path_size() const {
-  return _internal_path_size();
-}
-inline void GeneratedCodeInfo_Annotation::clear_path() {
-  _impl_.path_.Clear();
-}
-inline int32_t GeneratedCodeInfo_Annotation::_internal_path(int index) const {
-  return _impl_.path_.Get(index);
+inline int GeneratedCodeInfo_Annotation::_internal_path_size() const
+{
+    return _impl_.path_.size();
+}
+inline int GeneratedCodeInfo_Annotation::path_size() const
+{
+    return _internal_path_size();
+}
+inline void GeneratedCodeInfo_Annotation::clear_path()
+{
+    _impl_.path_.Clear();
+}
+inline int32_t GeneratedCodeInfo_Annotation::_internal_path(int index) const
+{
+    return _impl_.path_.Get(index);
+}
+inline int32_t GeneratedCodeInfo_Annotation::path(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.path)
+    return _internal_path(index);
+}
+inline void GeneratedCodeInfo_Annotation::set_path(int index, int32_t value)
+{
+    _impl_.path_.Set(index, value);
+    // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.path)
+}
+inline void GeneratedCodeInfo_Annotation::_internal_add_path(int32_t value)
+{
+    _impl_.path_.Add(value);
+}
+inline void GeneratedCodeInfo_Annotation::add_path(int32_t value)
+{
+    _internal_add_path(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.Annotation.path)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    GeneratedCodeInfo_Annotation::_internal_path() const
+{
+    return _impl_.path_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>&
+    GeneratedCodeInfo_Annotation::path() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
+    return _internal_path();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    GeneratedCodeInfo_Annotation::_internal_mutable_path()
+{
+    return &_impl_.path_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int32_t>*
+    GeneratedCodeInfo_Annotation::mutable_path()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
+    return _internal_mutable_path();
 }
-inline int32_t GeneratedCodeInfo_Annotation::path(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.path)
-  return _internal_path(index);
-}
-inline void GeneratedCodeInfo_Annotation::set_path(int index, int32_t value) {
-  _impl_.path_.Set(index, value);
-  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.path)
-}
-inline void GeneratedCodeInfo_Annotation::_internal_add_path(int32_t value) {
-  _impl_.path_.Add(value);
+
+// optional string source_file = 2;
+inline bool GeneratedCodeInfo_Annotation::_internal_has_source_file() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
+    return value;
+}
+inline bool GeneratedCodeInfo_Annotation::has_source_file() const
+{
+    return _internal_has_source_file();
+}
+inline void GeneratedCodeInfo_Annotation::clear_source_file()
+{
+    _impl_.source_file_.ClearToEmpty();
+    _impl_._has_bits_[0] &= ~0x00000001u;
 }
-inline void GeneratedCodeInfo_Annotation::add_path(int32_t value) {
-  _internal_add_path(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.Annotation.path)
+inline const std::string& GeneratedCodeInfo_Annotation::source_file() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+    return _internal_source_file();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-GeneratedCodeInfo_Annotation::_internal_path() const {
-  return _impl_.path_;
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void GeneratedCodeInfo_Annotation::set_source_file(ArgT0&& arg0, ArgT... args)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.source_file_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
 }
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
-GeneratedCodeInfo_Annotation::path() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
-  return _internal_path();
+inline std::string* GeneratedCodeInfo_Annotation::mutable_source_file()
+{
+    std::string* _s = _internal_mutable_source_file();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+    return _s;
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-GeneratedCodeInfo_Annotation::_internal_mutable_path() {
-  return &_impl_.path_;
+inline const std::string& GeneratedCodeInfo_Annotation::_internal_source_file() const
+{
+    return _impl_.source_file_.Get();
 }
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
-GeneratedCodeInfo_Annotation::mutable_path() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
-  return _internal_mutable_path();
+inline void GeneratedCodeInfo_Annotation::_internal_set_source_file(const std::string& value)
+{
+    _impl_._has_bits_[0] |= 0x00000001u;
+    _impl_.source_file_.Set(value, GetArenaForAllocation());
 }
-
-// optional string source_file = 2;
-inline bool GeneratedCodeInfo_Annotation::_internal_has_source_file() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
-  return value;
-}
-inline bool GeneratedCodeInfo_Annotation::has_source_file() const {
-  return _internal_has_source_file();
-}
-inline void GeneratedCodeInfo_Annotation::clear_source_file() {
-  _impl_.source_file_.ClearToEmpty();
-  _impl_._has_bits_[0] &= ~0x00000001u;
-}
-inline const std::string& GeneratedCodeInfo_Annotation::source_file() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
-  return _internal_source_file();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void GeneratedCodeInfo_Annotation::set_source_file(ArgT0&& arg0, ArgT... args) {
- _impl_._has_bits_[0] |= 0x00000001u;
- _impl_.source_file_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
-}
-inline std::string* GeneratedCodeInfo_Annotation::mutable_source_file() {
-  std::string* _s = _internal_mutable_source_file();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
-  return _s;
-}
-inline const std::string& GeneratedCodeInfo_Annotation::_internal_source_file() const {
-  return _impl_.source_file_.Get();
-}
-inline void GeneratedCodeInfo_Annotation::_internal_set_source_file(const std::string& value) {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  _impl_.source_file_.Set(value, GetArenaForAllocation());
-}
-inline std::string* GeneratedCodeInfo_Annotation::_internal_mutable_source_file() {
-  _impl_._has_bits_[0] |= 0x00000001u;
-  return _impl_.source_file_.Mutable(GetArenaForAllocation());
-}
-inline std::string* GeneratedCodeInfo_Annotation::release_source_file() {
-  // @@protoc_insertion_point(field_release:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
-  if (!_internal_has_source_file()) {
-    return nullptr;
-  }
-  _impl_._has_bits_[0] &= ~0x00000001u;
-  auto* p = _impl_.source_file_.Release();
-#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.source_file_.IsDefault()) {
-    _impl_.source_file_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  return p;
-}
-inline void GeneratedCodeInfo_Annotation::set_allocated_source_file(std::string* source_file) {
-  if (source_file != nullptr) {
+inline std::string* GeneratedCodeInfo_Annotation::_internal_mutable_source_file()
+{
     _impl_._has_bits_[0] |= 0x00000001u;
-  } else {
+    return _impl_.source_file_.Mutable(GetArenaForAllocation());
+}
+inline std::string* GeneratedCodeInfo_Annotation::release_source_file()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+    if (!_internal_has_source_file())
+    {
+        return nullptr;
+    }
     _impl_._has_bits_[0] &= ~0x00000001u;
-  }
-  _impl_.source_file_.SetAllocated(source_file, GetArenaForAllocation());
+    auto* p = _impl_.source_file_.Release();
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    if (_impl_.source_file_.IsDefault())
+    {
+        _impl_.source_file_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    return p;
+}
+inline void GeneratedCodeInfo_Annotation::set_allocated_source_file(std::string* source_file)
+{
+    if (source_file != nullptr)
+    {
+        _impl_._has_bits_[0] |= 0x00000001u;
+    }
+    else
+    {
+        _impl_._has_bits_[0] &= ~0x00000001u;
+    }
+    _impl_.source_file_.SetAllocated(source_file, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.source_file_.IsDefault()) {
-    _impl_.source_file_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+    if (_impl_.source_file_.IsDefault())
+    {
+        _impl_.source_file_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
 }
 
 // optional int32 begin = 3;
-inline bool GeneratedCodeInfo_Annotation::_internal_has_begin() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
-  return value;
-}
-inline bool GeneratedCodeInfo_Annotation::has_begin() const {
-  return _internal_has_begin();
-}
-inline void GeneratedCodeInfo_Annotation::clear_begin() {
-  _impl_.begin_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000002u;
+inline bool GeneratedCodeInfo_Annotation::_internal_has_begin() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
+    return value;
+}
+inline bool GeneratedCodeInfo_Annotation::has_begin() const
+{
+    return _internal_has_begin();
+}
+inline void GeneratedCodeInfo_Annotation::clear_begin()
+{
+    _impl_.begin_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000002u;
 }
-inline int32_t GeneratedCodeInfo_Annotation::_internal_begin() const {
-  return _impl_.begin_;
+inline int32_t GeneratedCodeInfo_Annotation::_internal_begin() const
+{
+    return _impl_.begin_;
 }
-inline int32_t GeneratedCodeInfo_Annotation::begin() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.begin)
-  return _internal_begin();
+inline int32_t GeneratedCodeInfo_Annotation::begin() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.begin)
+    return _internal_begin();
 }
-inline void GeneratedCodeInfo_Annotation::_internal_set_begin(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000002u;
-  _impl_.begin_ = value;
+inline void GeneratedCodeInfo_Annotation::_internal_set_begin(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000002u;
+    _impl_.begin_ = value;
 }
-inline void GeneratedCodeInfo_Annotation::set_begin(int32_t value) {
-  _internal_set_begin(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.begin)
+inline void GeneratedCodeInfo_Annotation::set_begin(int32_t value)
+{
+    _internal_set_begin(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.begin)
 }
 
 // optional int32 end = 4;
-inline bool GeneratedCodeInfo_Annotation::_internal_has_end() const {
-  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
-  return value;
-}
-inline bool GeneratedCodeInfo_Annotation::has_end() const {
-  return _internal_has_end();
-}
-inline void GeneratedCodeInfo_Annotation::clear_end() {
-  _impl_.end_ = 0;
-  _impl_._has_bits_[0] &= ~0x00000004u;
+inline bool GeneratedCodeInfo_Annotation::_internal_has_end() const
+{
+    bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
+    return value;
+}
+inline bool GeneratedCodeInfo_Annotation::has_end() const
+{
+    return _internal_has_end();
+}
+inline void GeneratedCodeInfo_Annotation::clear_end()
+{
+    _impl_.end_ = 0;
+    _impl_._has_bits_[0] &= ~0x00000004u;
 }
-inline int32_t GeneratedCodeInfo_Annotation::_internal_end() const {
-  return _impl_.end_;
+inline int32_t GeneratedCodeInfo_Annotation::_internal_end() const
+{
+    return _impl_.end_;
 }
-inline int32_t GeneratedCodeInfo_Annotation::end() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.end)
-  return _internal_end();
+inline int32_t GeneratedCodeInfo_Annotation::end() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.end)
+    return _internal_end();
 }
-inline void GeneratedCodeInfo_Annotation::_internal_set_end(int32_t value) {
-  _impl_._has_bits_[0] |= 0x00000004u;
-  _impl_.end_ = value;
+inline void GeneratedCodeInfo_Annotation::_internal_set_end(int32_t value)
+{
+    _impl_._has_bits_[0] |= 0x00000004u;
+    _impl_.end_ = value;
 }
-inline void GeneratedCodeInfo_Annotation::set_end(int32_t value) {
-  _internal_set_end(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.end)
+inline void GeneratedCodeInfo_Annotation::set_end(int32_t value)
+{
+    _internal_set_end(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.end)
 }
 
 // -------------------------------------------------------------------
@@ -14681,47 +18150,57 @@ inline void GeneratedCodeInfo_Annotation::set_end(int32_t value) {
 // GeneratedCodeInfo
 
 // repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
-inline int GeneratedCodeInfo::_internal_annotation_size() const {
-  return _impl_.annotation_.size();
-}
-inline int GeneratedCodeInfo::annotation_size() const {
-  return _internal_annotation_size();
-}
-inline void GeneratedCodeInfo::clear_annotation() {
-  _impl_.annotation_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::mutable_annotation(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.annotation)
-  return _impl_.annotation_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >*
-GeneratedCodeInfo::mutable_annotation() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.annotation)
-  return &_impl_.annotation_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::_internal_annotation(int index) const {
-  return _impl_.annotation_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::annotation(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.annotation)
-  return _internal_annotation(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::_internal_add_annotation() {
-  return _impl_.annotation_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::add_annotation() {
-  ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* _add = _internal_add_annotation();
-  // @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.annotation)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation >&
-GeneratedCodeInfo::annotation() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.annotation)
-  return _impl_.annotation_;
+inline int GeneratedCodeInfo::_internal_annotation_size() const
+{
+    return _impl_.annotation_.size();
+}
+inline int GeneratedCodeInfo::annotation_size() const
+{
+    return _internal_annotation_size();
+}
+inline void GeneratedCodeInfo::clear_annotation()
+{
+    _impl_.annotation_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::mutable_annotation(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.annotation)
+    return _impl_.annotation_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>*
+    GeneratedCodeInfo::mutable_annotation()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.annotation)
+    return &_impl_.annotation_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::_internal_annotation(int index) const
+{
+    return _impl_.annotation_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::annotation(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.annotation)
+    return _internal_annotation(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::_internal_add_annotation()
+{
+    return _impl_.annotation_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::add_annotation()
+{
+    ::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation* _add = _internal_add_annotation();
+    // @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.annotation)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::GeneratedCodeInfo_Annotation>&
+    GeneratedCodeInfo::annotation() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.annotation)
+    return _impl_.annotation_;
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 // -------------------------------------------------------------------
 
@@ -14775,42 +18254,65 @@ GeneratedCodeInfo::annotation() const {
 
 // -------------------------------------------------------------------
 
-
 // @@protoc_insertion_point(namespace_scope)
 
 PROTOBUF_NAMESPACE_CLOSE
 
 PROTOBUF_NAMESPACE_OPEN
 
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type>() {
-  return ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_descriptor();
-}
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label>() {
-  return ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_descriptor();
-}
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode>() {
-  return ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_descriptor();
-}
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType>() {
-  return ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType_descriptor();
-}
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType>() {
-  return ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_descriptor();
-}
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel>() {
-  return ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_descriptor();
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Type_descriptor();
+}
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::FieldDescriptorProto_Label_descriptor();
+}
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::FileOptions_OptimizeMode_descriptor();
+}
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::FieldOptions_CType> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::FieldOptions_CType>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::FieldOptions_CType_descriptor();
+}
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::FieldOptions_JSType_descriptor();
+}
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::MethodOptions_IdempotencyLevel_descriptor();
 }
 
 PROTOBUF_NAMESPACE_CLOSE
diff --git a/CAPI/cpp/grpc/include/google/protobuf/descriptor_database.h b/CAPI/cpp/grpc/include/google/protobuf/descriptor_database.h
index f4f06bb..51102d7 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/descriptor_database.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/descriptor_database.h
@@ -37,7 +37,6 @@
 #ifndef GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__
 #define GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__
 
-
 #include <map>
 #include <string>
 #include <utility>
@@ -53,344 +52,324 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-// Defined in this file.
-class DescriptorDatabase;
-class SimpleDescriptorDatabase;
-class EncodedDescriptorDatabase;
-class DescriptorPoolDatabase;
-class MergedDescriptorDatabase;
-
-// Abstract interface for a database of descriptors.
-//
-// This is useful if you want to create a DescriptorPool which loads
-// descriptors on-demand from some sort of large database.  If the database
-// is large, it may be inefficient to enumerate every .proto file inside it
-// calling DescriptorPool::BuildFile() for each one.  Instead, a DescriptorPool
-// can be created which wraps a DescriptorDatabase and only builds particular
-// descriptors when they are needed.
-class PROTOBUF_EXPORT DescriptorDatabase {
- public:
-  inline DescriptorDatabase() {}
-  virtual ~DescriptorDatabase();
-
-  // Find a file by file name.  Fills in in *output and returns true if found.
-  // Otherwise, returns false, leaving the contents of *output undefined.
-  virtual bool FindFileByName(const std::string& filename,
-                              FileDescriptorProto* output) = 0;
-
-  // Find the file that declares the given fully-qualified symbol name.
-  // If found, fills in *output and returns true, otherwise returns false
-  // and leaves *output undefined.
-  virtual bool FindFileContainingSymbol(const std::string& symbol_name,
-                                        FileDescriptorProto* output) = 0;
-
-  // Find the file which defines an extension extending the given message type
-  // with the given field number.  If found, fills in *output and returns true,
-  // otherwise returns false and leaves *output undefined.  containing_type
-  // must be a fully-qualified type name.
-  virtual bool FindFileContainingExtension(const std::string& containing_type,
-                                           int field_number,
-                                           FileDescriptorProto* output) = 0;
-
-  // Finds the tag numbers used by all known extensions of
-  // extendee_type, and appends them to output in an undefined
-  // order. This method is best-effort: it's not guaranteed that the
-  // database will find all extensions, and it's not guaranteed that
-  // FindFileContainingExtension will return true on all of the found
-  // numbers. Returns true if the search was successful, otherwise
-  // returns false and leaves output unchanged.
-  //
-  // This method has a default implementation that always returns
-  // false.
-  virtual bool FindAllExtensionNumbers(const std::string& /* extendee_type */,
-                                       std::vector<int>* /* output */) {
-    return false;
-  }
-
-
-  // Finds the file names and appends them to the output in an
-  // undefined order. This method is best-effort: it's not guaranteed that the
-  // database will find all files. Returns true if the database supports
-  // searching all file names, otherwise returns false and leaves output
-  // unchanged.
-  //
-  // This method has a default implementation that always returns
-  // false.
-  virtual bool FindAllFileNames(std::vector<std::string>* /*output*/) {
-    return false;
-  }
-
-  // Finds the package names and appends them to the output in an
-  // undefined order. This method is best-effort: it's not guaranteed that the
-  // database will find all packages. Returns true if the database supports
-  // searching all package names, otherwise returns false and leaves output
-  // unchanged.
-  bool FindAllPackageNames(std::vector<std::string>* output);
-
-  // Finds the message names and appends them to the output in an
-  // undefined order. This method is best-effort: it's not guaranteed that the
-  // database will find all messages. Returns true if the database supports
-  // searching all message names, otherwise returns false and leaves output
-  // unchanged.
-  bool FindAllMessageNames(std::vector<std::string>* output);
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorDatabase);
-};
-
-// A DescriptorDatabase into which you can insert files manually.
-//
-// FindFileContainingSymbol() is fully-implemented.  When you add a file, its
-// symbols will be indexed for this purpose.  Note that the implementation
-// may return false positives, but only if it isn't possible for the symbol
-// to be defined in any other file.  In particular, if a file defines a symbol
-// "Foo", then searching for "Foo.[anything]" will match that file.  This way,
-// the database does not need to aggressively index all children of a symbol.
-//
-// FindFileContainingExtension() is mostly-implemented.  It works if and only
-// if the original FieldDescriptorProto defining the extension has a
-// fully-qualified type name in its "extendee" field (i.e. starts with a '.').
-// If the extendee is a relative name, SimpleDescriptorDatabase will not
-// attempt to resolve the type, so it will not know what type the extension is
-// extending.  Therefore, calling FindFileContainingExtension() with the
-// extension's containing type will never actually find that extension.  Note
-// that this is an unlikely problem, as all FileDescriptorProtos created by the
-// protocol compiler (as well as ones created by calling
-// FileDescriptor::CopyTo()) will always use fully-qualified names for all
-// types.  You only need to worry if you are constructing FileDescriptorProtos
-// yourself, or are calling compiler::Parser directly.
-class PROTOBUF_EXPORT SimpleDescriptorDatabase : public DescriptorDatabase {
- public:
-  SimpleDescriptorDatabase();
-  ~SimpleDescriptorDatabase() override;
-
-  // Adds the FileDescriptorProto to the database, making a copy.  The object
-  // can be deleted after Add() returns.  Returns false if the file conflicted
-  // with a file already in the database, in which case an error will have
-  // been written to GOOGLE_LOG(ERROR).
-  bool Add(const FileDescriptorProto& file);
-
-  // Adds the FileDescriptorProto to the database and takes ownership of it.
-  bool AddAndOwn(const FileDescriptorProto* file);
-
-  // implements DescriptorDatabase -----------------------------------
-  bool FindFileByName(const std::string& filename,
-                      FileDescriptorProto* output) override;
-  bool FindFileContainingSymbol(const std::string& symbol_name,
-                                FileDescriptorProto* output) override;
-  bool FindFileContainingExtension(const std::string& containing_type,
-                                   int field_number,
-                                   FileDescriptorProto* output) override;
-  bool FindAllExtensionNumbers(const std::string& extendee_type,
-                               std::vector<int>* output) override;
-
-  bool FindAllFileNames(std::vector<std::string>* output) override;
-
- private:
-  // An index mapping file names, symbol names, and extension numbers to
-  // some sort of values.
-  template <typename Value>
-  class DescriptorIndex {
-   public:
-    // Helpers to recursively add particular descriptors and all their contents
-    // to the index.
-    bool AddFile(const FileDescriptorProto& file, Value value);
-    bool AddSymbol(const std::string& name, Value value);
-    bool AddNestedExtensions(const std::string& filename,
-                             const DescriptorProto& message_type, Value value);
-    bool AddExtension(const std::string& filename,
-                      const FieldDescriptorProto& field, Value value);
-
-    Value FindFile(const std::string& filename);
-    Value FindSymbol(const std::string& name);
-    Value FindExtension(const std::string& containing_type, int field_number);
-    bool FindAllExtensionNumbers(const std::string& containing_type,
-                                 std::vector<int>* output);
-    void FindAllFileNames(std::vector<std::string>* output);
-
-   private:
-    std::map<std::string, Value> by_name_;
-    std::map<std::string, Value> by_symbol_;
-    std::map<std::pair<std::string, int>, Value> by_extension_;
-
-    // Invariant:  The by_symbol_ map does not contain any symbols which are
-    // prefixes of other symbols in the map.  For example, "foo.bar" is a
-    // prefix of "foo.bar.baz" (but is not a prefix of "foo.barbaz").
-    //
-    // This invariant is important because it means that given a symbol name,
-    // we can find a key in the map which is a prefix of the symbol in O(lg n)
-    // time, and we know that there is at most one such key.
-    //
-    // The prefix lookup algorithm works like so:
-    // 1) Find the last key in the map which is less than or equal to the
-    //    search key.
-    // 2) If the found key is a prefix of the search key, then return it.
-    //    Otherwise, there is no match.
-    //
-    // I am sure this algorithm has been described elsewhere, but since I
-    // wasn't able to find it quickly I will instead prove that it works
-    // myself.  The key to the algorithm is that if a match exists, step (1)
-    // will find it.  Proof:
-    // 1) Define the "search key" to be the key we are looking for, the "found
-    //    key" to be the key found in step (1), and the "match key" to be the
-    //    key which actually matches the search key (i.e. the key we're trying
-    //    to find).
-    // 2) The found key must be less than or equal to the search key by
-    //    definition.
-    // 3) The match key must also be less than or equal to the search key
-    //    (because it is a prefix).
-    // 4) The match key cannot be greater than the found key, because if it
-    //    were, then step (1) of the algorithm would have returned the match
-    //    key instead (since it finds the *greatest* key which is less than or
-    //    equal to the search key).
-    // 5) Therefore, the found key must be between the match key and the search
-    //    key, inclusive.
-    // 6) Since the search key must be a sub-symbol of the match key, if it is
-    //    not equal to the match key, then search_key[match_key.size()] must
-    //    be '.'.
-    // 7) Since '.' sorts before any other character that is valid in a symbol
-    //    name, then if the found key is not equal to the match key, then
-    //    found_key[match_key.size()] must also be '.', because any other value
-    //    would make it sort after the search key.
-    // 8) Therefore, if the found key is not equal to the match key, then the
-    //    found key must be a sub-symbol of the match key.  However, this would
-    //    contradict our map invariant which says that no symbol in the map is
-    //    a sub-symbol of any other.
-    // 9) Therefore, the found key must match the match key.
-    //
-    // The above proof assumes the match key exists.  In the case that the
-    // match key does not exist, then step (1) will return some other symbol.
-    // That symbol cannot be a super-symbol of the search key since if it were,
-    // then it would be a match, and we're assuming the match key doesn't exist.
-    // Therefore, step 2 will correctly return no match.
-  };
-
-  DescriptorIndex<const FileDescriptorProto*> index_;
-  std::vector<std::unique_ptr<const FileDescriptorProto>> files_to_delete_;
-
-  // If file is non-nullptr, copy it into *output and return true, otherwise
-  // return false.
-  bool MaybeCopy(const FileDescriptorProto* file, FileDescriptorProto* output);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleDescriptorDatabase);
-};
-
-// Very similar to SimpleDescriptorDatabase, but stores all the descriptors
-// as raw bytes and generally tries to use as little memory as possible.
-//
-// The same caveats regarding FindFileContainingExtension() apply as with
-// SimpleDescriptorDatabase.
-class PROTOBUF_EXPORT EncodedDescriptorDatabase : public DescriptorDatabase {
- public:
-  EncodedDescriptorDatabase();
-  ~EncodedDescriptorDatabase() override;
-
-  // Adds the FileDescriptorProto to the database.  The descriptor is provided
-  // in encoded form.  The database does not make a copy of the bytes, nor
-  // does it take ownership; it's up to the caller to make sure the bytes
-  // remain valid for the life of the database.  Returns false and logs an error
-  // if the bytes are not a valid FileDescriptorProto or if the file conflicted
-  // with a file already in the database.
-  bool Add(const void* encoded_file_descriptor, int size);
-
-  // Like Add(), but makes a copy of the data, so that the caller does not
-  // need to keep it around.
-  bool AddCopy(const void* encoded_file_descriptor, int size);
-
-  // Like FindFileContainingSymbol but returns only the name of the file.
-  bool FindNameOfFileContainingSymbol(const std::string& symbol_name,
-                                      std::string* output);
-
-  // implements DescriptorDatabase -----------------------------------
-  bool FindFileByName(const std::string& filename,
-                      FileDescriptorProto* output) override;
-  bool FindFileContainingSymbol(const std::string& symbol_name,
-                                FileDescriptorProto* output) override;
-  bool FindFileContainingExtension(const std::string& containing_type,
-                                   int field_number,
-                                   FileDescriptorProto* output) override;
-  bool FindAllExtensionNumbers(const std::string& extendee_type,
-                               std::vector<int>* output) override;
-  bool FindAllFileNames(std::vector<std::string>* output) override;
-
- private:
-  class DescriptorIndex;
-  // Keep DescriptorIndex by pointer to hide the implementation to keep a
-  // cleaner header.
-  std::unique_ptr<DescriptorIndex> index_;
-  std::vector<void*> files_to_delete_;
-
-  // If encoded_file.first is non-nullptr, parse the data into *output and
-  // return true, otherwise return false.
-  bool MaybeParse(std::pair<const void*, int> encoded_file,
-                  FileDescriptorProto* output);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EncodedDescriptorDatabase);
-};
-
-// A DescriptorDatabase that fetches files from a given pool.
-class PROTOBUF_EXPORT DescriptorPoolDatabase : public DescriptorDatabase {
- public:
-  explicit DescriptorPoolDatabase(const DescriptorPool& pool);
-  ~DescriptorPoolDatabase() override;
-
-  // implements DescriptorDatabase -----------------------------------
-  bool FindFileByName(const std::string& filename,
-                      FileDescriptorProto* output) override;
-  bool FindFileContainingSymbol(const std::string& symbol_name,
-                                FileDescriptorProto* output) override;
-  bool FindFileContainingExtension(const std::string& containing_type,
-                                   int field_number,
-                                   FileDescriptorProto* output) override;
-  bool FindAllExtensionNumbers(const std::string& extendee_type,
-                               std::vector<int>* output) override;
-
- private:
-  const DescriptorPool& pool_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPoolDatabase);
-};
-
-// A DescriptorDatabase that wraps two or more others.  It first searches the
-// first database and, if that fails, tries the second, and so on.
-class PROTOBUF_EXPORT MergedDescriptorDatabase : public DescriptorDatabase {
- public:
-  // Merge just two databases.  The sources remain property of the caller.
-  MergedDescriptorDatabase(DescriptorDatabase* source1,
-                           DescriptorDatabase* source2);
-  // Merge more than two databases.  The sources remain property of the caller.
-  // The vector may be deleted after the constructor returns but the
-  // DescriptorDatabases need to stick around.
-  explicit MergedDescriptorDatabase(
-      const std::vector<DescriptorDatabase*>& sources);
-  ~MergedDescriptorDatabase() override;
-
-  // implements DescriptorDatabase -----------------------------------
-  bool FindFileByName(const std::string& filename,
-                      FileDescriptorProto* output) override;
-  bool FindFileContainingSymbol(const std::string& symbol_name,
-                                FileDescriptorProto* output) override;
-  bool FindFileContainingExtension(const std::string& containing_type,
-                                   int field_number,
-                                   FileDescriptorProto* output) override;
-  // Merges the results of calling all databases. Returns true iff any
-  // of the databases returned true.
-  bool FindAllExtensionNumbers(const std::string& extendee_type,
-                               std::vector<int>* output) override;
-
-
-  // This function is best-effort. Returns true if at least one underlying
-  // DescriptorDatabase returns true.
-  bool FindAllFileNames(std::vector<std::string>* output) override;
-
- private:
-  std::vector<DescriptorDatabase*> sources_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MergedDescriptorDatabase);
-};
-
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        // Defined in this file.
+        class DescriptorDatabase;
+        class SimpleDescriptorDatabase;
+        class EncodedDescriptorDatabase;
+        class DescriptorPoolDatabase;
+        class MergedDescriptorDatabase;
+
+        // Abstract interface for a database of descriptors.
+        //
+        // This is useful if you want to create a DescriptorPool which loads
+        // descriptors on-demand from some sort of large database.  If the database
+        // is large, it may be inefficient to enumerate every .proto file inside it
+        // calling DescriptorPool::BuildFile() for each one.  Instead, a DescriptorPool
+        // can be created which wraps a DescriptorDatabase and only builds particular
+        // descriptors when they are needed.
+        class PROTOBUF_EXPORT DescriptorDatabase
+        {
+        public:
+            inline DescriptorDatabase()
+            {
+            }
+            virtual ~DescriptorDatabase();
+
+            // Find a file by file name.  Fills in in *output and returns true if found.
+            // Otherwise, returns false, leaving the contents of *output undefined.
+            virtual bool FindFileByName(const std::string& filename, FileDescriptorProto* output) = 0;
+
+            // Find the file that declares the given fully-qualified symbol name.
+            // If found, fills in *output and returns true, otherwise returns false
+            // and leaves *output undefined.
+            virtual bool FindFileContainingSymbol(const std::string& symbol_name, FileDescriptorProto* output) = 0;
+
+            // Find the file which defines an extension extending the given message type
+            // with the given field number.  If found, fills in *output and returns true,
+            // otherwise returns false and leaves *output undefined.  containing_type
+            // must be a fully-qualified type name.
+            virtual bool FindFileContainingExtension(const std::string& containing_type, int field_number, FileDescriptorProto* output) = 0;
+
+            // Finds the tag numbers used by all known extensions of
+            // extendee_type, and appends them to output in an undefined
+            // order. This method is best-effort: it's not guaranteed that the
+            // database will find all extensions, and it's not guaranteed that
+            // FindFileContainingExtension will return true on all of the found
+            // numbers. Returns true if the search was successful, otherwise
+            // returns false and leaves output unchanged.
+            //
+            // This method has a default implementation that always returns
+            // false.
+            virtual bool FindAllExtensionNumbers(const std::string& /* extendee_type */, std::vector<int>* /* output */)
+            {
+                return false;
+            }
+
+            // Finds the file names and appends them to the output in an
+            // undefined order. This method is best-effort: it's not guaranteed that the
+            // database will find all files. Returns true if the database supports
+            // searching all file names, otherwise returns false and leaves output
+            // unchanged.
+            //
+            // This method has a default implementation that always returns
+            // false.
+            virtual bool FindAllFileNames(std::vector<std::string>* /*output*/)
+            {
+                return false;
+            }
+
+            // Finds the package names and appends them to the output in an
+            // undefined order. This method is best-effort: it's not guaranteed that the
+            // database will find all packages. Returns true if the database supports
+            // searching all package names, otherwise returns false and leaves output
+            // unchanged.
+            bool FindAllPackageNames(std::vector<std::string>* output);
+
+            // Finds the message names and appends them to the output in an
+            // undefined order. This method is best-effort: it's not guaranteed that the
+            // database will find all messages. Returns true if the database supports
+            // searching all message names, otherwise returns false and leaves output
+            // unchanged.
+            bool FindAllMessageNames(std::vector<std::string>* output);
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorDatabase);
+        };
+
+        // A DescriptorDatabase into which you can insert files manually.
+        //
+        // FindFileContainingSymbol() is fully-implemented.  When you add a file, its
+        // symbols will be indexed for this purpose.  Note that the implementation
+        // may return false positives, but only if it isn't possible for the symbol
+        // to be defined in any other file.  In particular, if a file defines a symbol
+        // "Foo", then searching for "Foo.[anything]" will match that file.  This way,
+        // the database does not need to aggressively index all children of a symbol.
+        //
+        // FindFileContainingExtension() is mostly-implemented.  It works if and only
+        // if the original FieldDescriptorProto defining the extension has a
+        // fully-qualified type name in its "extendee" field (i.e. starts with a '.').
+        // If the extendee is a relative name, SimpleDescriptorDatabase will not
+        // attempt to resolve the type, so it will not know what type the extension is
+        // extending.  Therefore, calling FindFileContainingExtension() with the
+        // extension's containing type will never actually find that extension.  Note
+        // that this is an unlikely problem, as all FileDescriptorProtos created by the
+        // protocol compiler (as well as ones created by calling
+        // FileDescriptor::CopyTo()) will always use fully-qualified names for all
+        // types.  You only need to worry if you are constructing FileDescriptorProtos
+        // yourself, or are calling compiler::Parser directly.
+        class PROTOBUF_EXPORT SimpleDescriptorDatabase : public DescriptorDatabase
+        {
+        public:
+            SimpleDescriptorDatabase();
+            ~SimpleDescriptorDatabase() override;
+
+            // Adds the FileDescriptorProto to the database, making a copy.  The object
+            // can be deleted after Add() returns.  Returns false if the file conflicted
+            // with a file already in the database, in which case an error will have
+            // been written to GOOGLE_LOG(ERROR).
+            bool Add(const FileDescriptorProto& file);
+
+            // Adds the FileDescriptorProto to the database and takes ownership of it.
+            bool AddAndOwn(const FileDescriptorProto* file);
+
+            // implements DescriptorDatabase -----------------------------------
+            bool FindFileByName(const std::string& filename, FileDescriptorProto* output) override;
+            bool FindFileContainingSymbol(const std::string& symbol_name, FileDescriptorProto* output) override;
+            bool FindFileContainingExtension(const std::string& containing_type, int field_number, FileDescriptorProto* output) override;
+            bool FindAllExtensionNumbers(const std::string& extendee_type, std::vector<int>* output) override;
+
+            bool FindAllFileNames(std::vector<std::string>* output) override;
+
+        private:
+            // An index mapping file names, symbol names, and extension numbers to
+            // some sort of values.
+            template<typename Value>
+            class DescriptorIndex
+            {
+            public:
+                // Helpers to recursively add particular descriptors and all their contents
+                // to the index.
+                bool AddFile(const FileDescriptorProto& file, Value value);
+                bool AddSymbol(const std::string& name, Value value);
+                bool AddNestedExtensions(const std::string& filename, const DescriptorProto& message_type, Value value);
+                bool AddExtension(const std::string& filename, const FieldDescriptorProto& field, Value value);
+
+                Value FindFile(const std::string& filename);
+                Value FindSymbol(const std::string& name);
+                Value FindExtension(const std::string& containing_type, int field_number);
+                bool FindAllExtensionNumbers(const std::string& containing_type, std::vector<int>* output);
+                void FindAllFileNames(std::vector<std::string>* output);
+
+            private:
+                std::map<std::string, Value> by_name_;
+                std::map<std::string, Value> by_symbol_;
+                std::map<std::pair<std::string, int>, Value> by_extension_;
+
+                // Invariant:  The by_symbol_ map does not contain any symbols which are
+                // prefixes of other symbols in the map.  For example, "foo.bar" is a
+                // prefix of "foo.bar.baz" (but is not a prefix of "foo.barbaz").
+                //
+                // This invariant is important because it means that given a symbol name,
+                // we can find a key in the map which is a prefix of the symbol in O(lg n)
+                // time, and we know that there is at most one such key.
+                //
+                // The prefix lookup algorithm works like so:
+                // 1) Find the last key in the map which is less than or equal to the
+                //    search key.
+                // 2) If the found key is a prefix of the search key, then return it.
+                //    Otherwise, there is no match.
+                //
+                // I am sure this algorithm has been described elsewhere, but since I
+                // wasn't able to find it quickly I will instead prove that it works
+                // myself.  The key to the algorithm is that if a match exists, step (1)
+                // will find it.  Proof:
+                // 1) Define the "search key" to be the key we are looking for, the "found
+                //    key" to be the key found in step (1), and the "match key" to be the
+                //    key which actually matches the search key (i.e. the key we're trying
+                //    to find).
+                // 2) The found key must be less than or equal to the search key by
+                //    definition.
+                // 3) The match key must also be less than or equal to the search key
+                //    (because it is a prefix).
+                // 4) The match key cannot be greater than the found key, because if it
+                //    were, then step (1) of the algorithm would have returned the match
+                //    key instead (since it finds the *greatest* key which is less than or
+                //    equal to the search key).
+                // 5) Therefore, the found key must be between the match key and the search
+                //    key, inclusive.
+                // 6) Since the search key must be a sub-symbol of the match key, if it is
+                //    not equal to the match key, then search_key[match_key.size()] must
+                //    be '.'.
+                // 7) Since '.' sorts before any other character that is valid in a symbol
+                //    name, then if the found key is not equal to the match key, then
+                //    found_key[match_key.size()] must also be '.', because any other value
+                //    would make it sort after the search key.
+                // 8) Therefore, if the found key is not equal to the match key, then the
+                //    found key must be a sub-symbol of the match key.  However, this would
+                //    contradict our map invariant which says that no symbol in the map is
+                //    a sub-symbol of any other.
+                // 9) Therefore, the found key must match the match key.
+                //
+                // The above proof assumes the match key exists.  In the case that the
+                // match key does not exist, then step (1) will return some other symbol.
+                // That symbol cannot be a super-symbol of the search key since if it were,
+                // then it would be a match, and we're assuming the match key doesn't exist.
+                // Therefore, step 2 will correctly return no match.
+            };
+
+            DescriptorIndex<const FileDescriptorProto*> index_;
+            std::vector<std::unique_ptr<const FileDescriptorProto>> files_to_delete_;
+
+            // If file is non-nullptr, copy it into *output and return true, otherwise
+            // return false.
+            bool MaybeCopy(const FileDescriptorProto* file, FileDescriptorProto* output);
+
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleDescriptorDatabase);
+        };
+
+        // Very similar to SimpleDescriptorDatabase, but stores all the descriptors
+        // as raw bytes and generally tries to use as little memory as possible.
+        //
+        // The same caveats regarding FindFileContainingExtension() apply as with
+        // SimpleDescriptorDatabase.
+        class PROTOBUF_EXPORT EncodedDescriptorDatabase : public DescriptorDatabase
+        {
+        public:
+            EncodedDescriptorDatabase();
+            ~EncodedDescriptorDatabase() override;
+
+            // Adds the FileDescriptorProto to the database.  The descriptor is provided
+            // in encoded form.  The database does not make a copy of the bytes, nor
+            // does it take ownership; it's up to the caller to make sure the bytes
+            // remain valid for the life of the database.  Returns false and logs an error
+            // if the bytes are not a valid FileDescriptorProto or if the file conflicted
+            // with a file already in the database.
+            bool Add(const void* encoded_file_descriptor, int size);
+
+            // Like Add(), but makes a copy of the data, so that the caller does not
+            // need to keep it around.
+            bool AddCopy(const void* encoded_file_descriptor, int size);
+
+            // Like FindFileContainingSymbol but returns only the name of the file.
+            bool FindNameOfFileContainingSymbol(const std::string& symbol_name, std::string* output);
+
+            // implements DescriptorDatabase -----------------------------------
+            bool FindFileByName(const std::string& filename, FileDescriptorProto* output) override;
+            bool FindFileContainingSymbol(const std::string& symbol_name, FileDescriptorProto* output) override;
+            bool FindFileContainingExtension(const std::string& containing_type, int field_number, FileDescriptorProto* output) override;
+            bool FindAllExtensionNumbers(const std::string& extendee_type, std::vector<int>* output) override;
+            bool FindAllFileNames(std::vector<std::string>* output) override;
+
+        private:
+            class DescriptorIndex;
+            // Keep DescriptorIndex by pointer to hide the implementation to keep a
+            // cleaner header.
+            std::unique_ptr<DescriptorIndex> index_;
+            std::vector<void*> files_to_delete_;
+
+            // If encoded_file.first is non-nullptr, parse the data into *output and
+            // return true, otherwise return false.
+            bool MaybeParse(std::pair<const void*, int> encoded_file, FileDescriptorProto* output);
+
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EncodedDescriptorDatabase);
+        };
+
+        // A DescriptorDatabase that fetches files from a given pool.
+        class PROTOBUF_EXPORT DescriptorPoolDatabase : public DescriptorDatabase
+        {
+        public:
+            explicit DescriptorPoolDatabase(const DescriptorPool& pool);
+            ~DescriptorPoolDatabase() override;
+
+            // implements DescriptorDatabase -----------------------------------
+            bool FindFileByName(const std::string& filename, FileDescriptorProto* output) override;
+            bool FindFileContainingSymbol(const std::string& symbol_name, FileDescriptorProto* output) override;
+            bool FindFileContainingExtension(const std::string& containing_type, int field_number, FileDescriptorProto* output) override;
+            bool FindAllExtensionNumbers(const std::string& extendee_type, std::vector<int>* output) override;
+
+        private:
+            const DescriptorPool& pool_;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPoolDatabase);
+        };
+
+        // A DescriptorDatabase that wraps two or more others.  It first searches the
+        // first database and, if that fails, tries the second, and so on.
+        class PROTOBUF_EXPORT MergedDescriptorDatabase : public DescriptorDatabase
+        {
+        public:
+            // Merge just two databases.  The sources remain property of the caller.
+            MergedDescriptorDatabase(DescriptorDatabase* source1, DescriptorDatabase* source2);
+            // Merge more than two databases.  The sources remain property of the caller.
+            // The vector may be deleted after the constructor returns but the
+            // DescriptorDatabases need to stick around.
+            explicit MergedDescriptorDatabase(
+                const std::vector<DescriptorDatabase*>& sources
+            );
+            ~MergedDescriptorDatabase() override;
+
+            // implements DescriptorDatabase -----------------------------------
+            bool FindFileByName(const std::string& filename, FileDescriptorProto* output) override;
+            bool FindFileContainingSymbol(const std::string& symbol_name, FileDescriptorProto* output) override;
+            bool FindFileContainingExtension(const std::string& containing_type, int field_number, FileDescriptorProto* output) override;
+            // Merges the results of calling all databases. Returns true iff any
+            // of the databases returned true.
+            bool FindAllExtensionNumbers(const std::string& extendee_type, std::vector<int>* output) override;
+
+            // This function is best-effort. Returns true if at least one underlying
+            // DescriptorDatabase returns true.
+            bool FindAllFileNames(std::vector<std::string>* output) override;
+
+        private:
+            std::vector<DescriptorDatabase*> sources_;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MergedDescriptorDatabase);
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/duration.pb.h b/CAPI/cpp/grpc/include/google/protobuf/duration.pb.h
index c4a94c5..df646e4 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/duration.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/duration.pb.h
@@ -28,20 +28,22 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fduration_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fduration_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fduration_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fduration_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -50,222 +52,275 @@ struct DurationDefaultTypeInternal;
 PROTOBUF_EXPORT extern DurationDefaultTypeInternal _Duration_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Duration* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Duration* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
 // ===================================================================
 
 class PROTOBUF_EXPORT Duration final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Duration) */ {
- public:
-  inline Duration() : Duration(nullptr) {}
-  ~Duration() override;
-  explicit PROTOBUF_CONSTEXPR Duration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Duration(const Duration& from);
-  Duration(Duration&& from) noexcept
-    : Duration() {
-    *this = ::std::move(from);
-  }
-
-  inline Duration& operator=(const Duration& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Duration& operator=(Duration&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Duration) */
+{
+public:
+    inline Duration() :
+        Duration(nullptr)
+    {
     }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Duration& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Duration* internal_default_instance() {
-    return reinterpret_cast<const Duration*>(
-               &_Duration_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(Duration& a, Duration& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Duration* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    ~Duration() override;
+    explicit PROTOBUF_CONSTEXPR Duration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Duration(const Duration& from);
+    Duration(Duration&& from) noexcept
+        :
+        Duration()
+    {
+        *this = ::std::move(from);
     }
-  }
-  void UnsafeArenaSwap(Duration* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Duration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Duration>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Duration& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Duration& from) {
-    Duration::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Duration* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Duration";
-  }
-  protected:
-  explicit Duration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kSecondsFieldNumber = 1,
-    kNanosFieldNumber = 2,
-  };
-  // int64 seconds = 1;
-  void clear_seconds();
-  int64_t seconds() const;
-  void set_seconds(int64_t value);
-  private:
-  int64_t _internal_seconds() const;
-  void _internal_set_seconds(int64_t value);
-  public:
-
-  // int32 nanos = 2;
-  void clear_nanos();
-  int32_t nanos() const;
-  void set_nanos(int32_t value);
-  private:
-  int32_t _internal_nanos() const;
-  void _internal_set_nanos(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Duration)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    int64_t seconds_;
-    int32_t nanos_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fduration_2eproto;
+
+    inline Duration& operator=(const Duration& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Duration& operator=(Duration&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Duration& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Duration* internal_default_instance()
+    {
+        return reinterpret_cast<const Duration*>(
+            &_Duration_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(Duration& a, Duration& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Duration* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Duration* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Duration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Duration>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Duration& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Duration& from)
+    {
+        Duration::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Duration* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Duration";
+    }
+
+protected:
+    explicit Duration(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kSecondsFieldNumber = 1,
+        kNanosFieldNumber = 2,
+    };
+    // int64 seconds = 1;
+    void clear_seconds();
+    int64_t seconds() const;
+    void set_seconds(int64_t value);
+
+private:
+    int64_t _internal_seconds() const;
+    void _internal_set_seconds(int64_t value);
+
+public:
+    // int32 nanos = 2;
+    void clear_nanos();
+    int32_t nanos() const;
+    void set_nanos(int32_t value);
+
+private:
+    int32_t _internal_nanos() const;
+    void _internal_set_nanos(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Duration)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        int64_t seconds_;
+        int32_t nanos_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fduration_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // Duration
 
 // int64 seconds = 1;
-inline void Duration::clear_seconds() {
-  _impl_.seconds_ = int64_t{0};
+inline void Duration::clear_seconds()
+{
+    _impl_.seconds_ = int64_t{0};
 }
-inline int64_t Duration::_internal_seconds() const {
-  return _impl_.seconds_;
+inline int64_t Duration::_internal_seconds() const
+{
+    return _impl_.seconds_;
 }
-inline int64_t Duration::seconds() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Duration.seconds)
-  return _internal_seconds();
+inline int64_t Duration::seconds() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Duration.seconds)
+    return _internal_seconds();
 }
-inline void Duration::_internal_set_seconds(int64_t value) {
-  
-  _impl_.seconds_ = value;
+inline void Duration::_internal_set_seconds(int64_t value)
+{
+    _impl_.seconds_ = value;
 }
-inline void Duration::set_seconds(int64_t value) {
-  _internal_set_seconds(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Duration.seconds)
+inline void Duration::set_seconds(int64_t value)
+{
+    _internal_set_seconds(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Duration.seconds)
 }
 
 // int32 nanos = 2;
-inline void Duration::clear_nanos() {
-  _impl_.nanos_ = 0;
+inline void Duration::clear_nanos()
+{
+    _impl_.nanos_ = 0;
 }
-inline int32_t Duration::_internal_nanos() const {
-  return _impl_.nanos_;
+inline int32_t Duration::_internal_nanos() const
+{
+    return _impl_.nanos_;
 }
-inline int32_t Duration::nanos() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Duration.nanos)
-  return _internal_nanos();
+inline int32_t Duration::nanos() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Duration.nanos)
+    return _internal_nanos();
 }
-inline void Duration::_internal_set_nanos(int32_t value) {
-  
-  _impl_.nanos_ = value;
+inline void Duration::_internal_set_nanos(int32_t value)
+{
+    _impl_.nanos_ = value;
 }
-inline void Duration::set_nanos(int32_t value) {
-  _internal_set_nanos(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Duration.nanos)
+inline void Duration::set_nanos(int32_t value)
+{
+    _internal_set_nanos(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Duration.nanos)
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 
 // @@protoc_insertion_point(namespace_scope)
diff --git a/CAPI/cpp/grpc/include/google/protobuf/dynamic_message.h b/CAPI/cpp/grpc/include/google/protobuf/dynamic_message.h
index 6fa6425..1b92dde 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/dynamic_message.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/dynamic_message.h
@@ -38,7 +38,6 @@
 #ifndef GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
 #define GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
 
-
 #include <algorithm>
 #include <memory>
 #include <unordered_map>
@@ -57,169 +56,185 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-// Defined in other files.
-class Descriptor;      // descriptor.h
-class DescriptorPool;  // descriptor.h
-
-// Constructs implementations of Message which can emulate types which are not
-// known at compile-time.
-//
-// Sometimes you want to be able to manipulate protocol types that you don't
-// know about at compile time.  It would be nice to be able to construct
-// a Message object which implements the message type given by any arbitrary
-// Descriptor.  DynamicMessage provides this.
-//
-// As it turns out, a DynamicMessage needs to construct extra
-// information about its type in order to operate.  Most of this information
-// can be shared between all DynamicMessages of the same type.  But, caching
-// this information in some sort of global map would be a bad idea, since
-// the cached information for a particular descriptor could outlive the
-// descriptor itself.  To avoid this problem, DynamicMessageFactory
-// encapsulates this "cache".  All DynamicMessages of the same type created
-// from the same factory will share the same support data.  Any Descriptors
-// used with a particular factory must outlive the factory.
-class PROTOBUF_EXPORT DynamicMessageFactory : public MessageFactory {
- public:
-  // Construct a DynamicMessageFactory that will search for extensions in
-  // the DescriptorPool in which the extendee is defined.
-  DynamicMessageFactory();
-
-  // Construct a DynamicMessageFactory that will search for extensions in
-  // the given DescriptorPool.
-  //
-  // DEPRECATED:  Use CodedInputStream::SetExtensionRegistry() to tell the
-  //   parser to look for extensions in an alternate pool.  However, note that
-  //   this is almost never what you want to do.  Almost all users should use
-  //   the zero-arg constructor.
-  DynamicMessageFactory(const DescriptorPool* pool);
-
-  ~DynamicMessageFactory() override;
-
-  // Call this to tell the DynamicMessageFactory that if it is given a
-  // Descriptor d for which:
-  //   d->file()->pool() == DescriptorPool::generated_pool(),
-  // then it should delegate to MessageFactory::generated_factory() instead
-  // of constructing a dynamic implementation of the message.  In theory there
-  // is no down side to doing this, so it may become the default in the future.
-  void SetDelegateToGeneratedFactory(bool enable) {
-    delegate_to_generated_factory_ = enable;
-  }
-
-  // implements MessageFactory ---------------------------------------
-
-  // Given a Descriptor, constructs the default (prototype) Message of that
-  // type.  You can then call that message's New() method to construct a
-  // mutable message of that type.
-  //
-  // Calling this method twice with the same Descriptor returns the same
-  // object.  The returned object remains property of the factory and will
-  // be destroyed when the factory is destroyed.  Also, any objects created
-  // by calling the prototype's New() method share some data with the
-  // prototype, so these must be destroyed before the DynamicMessageFactory
-  // is destroyed.
-  //
-  // The given descriptor must outlive the returned message, and hence must
-  // outlive the DynamicMessageFactory.
-  //
-  // The method is thread-safe.
-  const Message* GetPrototype(const Descriptor* type) override;
-
- private:
-  const DescriptorPool* pool_;
-  bool delegate_to_generated_factory_;
-
-  struct TypeInfo;
-  std::unordered_map<const Descriptor*, const TypeInfo*> prototypes_;
-  mutable internal::WrappedMutex prototypes_mutex_;
-
-  friend class DynamicMessage;
-  const Message* GetPrototypeNoLock(const Descriptor* type);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMessageFactory);
-};
-
-// Helper for computing a sorted list of map entries via reflection.
-class PROTOBUF_EXPORT DynamicMapSorter {
- public:
-  static std::vector<const Message*> Sort(const Message& message, int map_size,
-                                          const Reflection* reflection,
-                                          const FieldDescriptor* field) {
-    std::vector<const Message*> result;
-    result.reserve(map_size);
-    RepeatedFieldRef<Message> map_field =
-        reflection->GetRepeatedFieldRef<Message>(message, field);
-    for (auto it = map_field.begin(); it != map_field.end(); ++it) {
-      result.push_back(&*it);
-    }
-    MapEntryMessageComparator comparator(field->message_type());
-    std::stable_sort(result.begin(), result.end(), comparator);
-    // Complain if the keys aren't in ascending order.
+namespace google
+{
+    namespace protobuf
+    {
+
+        // Defined in other files.
+        class Descriptor;      // descriptor.h
+        class DescriptorPool;  // descriptor.h
+
+        // Constructs implementations of Message which can emulate types which are not
+        // known at compile-time.
+        //
+        // Sometimes you want to be able to manipulate protocol types that you don't
+        // know about at compile time.  It would be nice to be able to construct
+        // a Message object which implements the message type given by any arbitrary
+        // Descriptor.  DynamicMessage provides this.
+        //
+        // As it turns out, a DynamicMessage needs to construct extra
+        // information about its type in order to operate.  Most of this information
+        // can be shared between all DynamicMessages of the same type.  But, caching
+        // this information in some sort of global map would be a bad idea, since
+        // the cached information for a particular descriptor could outlive the
+        // descriptor itself.  To avoid this problem, DynamicMessageFactory
+        // encapsulates this "cache".  All DynamicMessages of the same type created
+        // from the same factory will share the same support data.  Any Descriptors
+        // used with a particular factory must outlive the factory.
+        class PROTOBUF_EXPORT DynamicMessageFactory : public MessageFactory
+        {
+        public:
+            // Construct a DynamicMessageFactory that will search for extensions in
+            // the DescriptorPool in which the extendee is defined.
+            DynamicMessageFactory();
+
+            // Construct a DynamicMessageFactory that will search for extensions in
+            // the given DescriptorPool.
+            //
+            // DEPRECATED:  Use CodedInputStream::SetExtensionRegistry() to tell the
+            //   parser to look for extensions in an alternate pool.  However, note that
+            //   this is almost never what you want to do.  Almost all users should use
+            //   the zero-arg constructor.
+            DynamicMessageFactory(const DescriptorPool* pool);
+
+            ~DynamicMessageFactory() override;
+
+            // Call this to tell the DynamicMessageFactory that if it is given a
+            // Descriptor d for which:
+            //   d->file()->pool() == DescriptorPool::generated_pool(),
+            // then it should delegate to MessageFactory::generated_factory() instead
+            // of constructing a dynamic implementation of the message.  In theory there
+            // is no down side to doing this, so it may become the default in the future.
+            void SetDelegateToGeneratedFactory(bool enable)
+            {
+                delegate_to_generated_factory_ = enable;
+            }
+
+            // implements MessageFactory ---------------------------------------
+
+            // Given a Descriptor, constructs the default (prototype) Message of that
+            // type.  You can then call that message's New() method to construct a
+            // mutable message of that type.
+            //
+            // Calling this method twice with the same Descriptor returns the same
+            // object.  The returned object remains property of the factory and will
+            // be destroyed when the factory is destroyed.  Also, any objects created
+            // by calling the prototype's New() method share some data with the
+            // prototype, so these must be destroyed before the DynamicMessageFactory
+            // is destroyed.
+            //
+            // The given descriptor must outlive the returned message, and hence must
+            // outlive the DynamicMessageFactory.
+            //
+            // The method is thread-safe.
+            const Message* GetPrototype(const Descriptor* type) override;
+
+        private:
+            const DescriptorPool* pool_;
+            bool delegate_to_generated_factory_;
+
+            struct TypeInfo;
+            std::unordered_map<const Descriptor*, const TypeInfo*> prototypes_;
+            mutable internal::WrappedMutex prototypes_mutex_;
+
+            friend class DynamicMessage;
+            const Message* GetPrototypeNoLock(const Descriptor* type);
+
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMessageFactory);
+        };
+
+        // Helper for computing a sorted list of map entries via reflection.
+        class PROTOBUF_EXPORT DynamicMapSorter
+        {
+        public:
+            static std::vector<const Message*> Sort(const Message& message, int map_size, const Reflection* reflection, const FieldDescriptor* field)
+            {
+                std::vector<const Message*> result;
+                result.reserve(map_size);
+                RepeatedFieldRef<Message> map_field =
+                    reflection->GetRepeatedFieldRef<Message>(message, field);
+                for (auto it = map_field.begin(); it != map_field.end(); ++it)
+                {
+                    result.push_back(&*it);
+                }
+                MapEntryMessageComparator comparator(field->message_type());
+                std::stable_sort(result.begin(), result.end(), comparator);
+                // Complain if the keys aren't in ascending order.
 #ifndef NDEBUG
-    for (size_t j = 1; j < static_cast<size_t>(map_size); j++) {
-      if (!comparator(result[j - 1], result[j])) {
-        GOOGLE_LOG(ERROR) << (comparator(result[j], result[j - 1])
-                           ? "internal error in map key sorting"
-                           : "map keys are not unique");
-      }
-    }
+                for (size_t j = 1; j < static_cast<size_t>(map_size); j++)
+                {
+                    if (!comparator(result[j - 1], result[j]))
+                    {
+                        GOOGLE_LOG(ERROR) << (comparator(result[j], result[j - 1]) ? "internal error in map key sorting" : "map keys are not unique");
+                    }
+                }
 #endif
-    return result;
-  }
-
- private:
-  class PROTOBUF_EXPORT MapEntryMessageComparator {
-   public:
-    explicit MapEntryMessageComparator(const Descriptor* descriptor)
-        : field_(descriptor->field(0)) {}
-
-    bool operator()(const Message* a, const Message* b) {
-      const Reflection* reflection = a->GetReflection();
-      switch (field_->cpp_type()) {
-        case FieldDescriptor::CPPTYPE_BOOL: {
-          bool first = reflection->GetBool(*a, field_);
-          bool second = reflection->GetBool(*b, field_);
-          return first < second;
-        }
-        case FieldDescriptor::CPPTYPE_INT32: {
-          int32_t first = reflection->GetInt32(*a, field_);
-          int32_t second = reflection->GetInt32(*b, field_);
-          return first < second;
-        }
-        case FieldDescriptor::CPPTYPE_INT64: {
-          int64_t first = reflection->GetInt64(*a, field_);
-          int64_t second = reflection->GetInt64(*b, field_);
-          return first < second;
-        }
-        case FieldDescriptor::CPPTYPE_UINT32: {
-          uint32_t first = reflection->GetUInt32(*a, field_);
-          uint32_t second = reflection->GetUInt32(*b, field_);
-          return first < second;
-        }
-        case FieldDescriptor::CPPTYPE_UINT64: {
-          uint64_t first = reflection->GetUInt64(*a, field_);
-          uint64_t second = reflection->GetUInt64(*b, field_);
-          return first < second;
-        }
-        case FieldDescriptor::CPPTYPE_STRING: {
-          std::string first = reflection->GetString(*a, field_);
-          std::string second = reflection->GetString(*b, field_);
-          return first < second;
-        }
-        default:
-          GOOGLE_LOG(DFATAL) << "Invalid key for map field.";
-          return true;
-      }
-    }
-
-   private:
-    const FieldDescriptor* field_;
-  };
-};
-
-}  // namespace protobuf
+                return result;
+            }
+
+        private:
+            class PROTOBUF_EXPORT MapEntryMessageComparator
+            {
+            public:
+                explicit MapEntryMessageComparator(const Descriptor* descriptor) :
+                    field_(descriptor->field(0))
+                {
+                }
+
+                bool operator()(const Message* a, const Message* b)
+                {
+                    const Reflection* reflection = a->GetReflection();
+                    switch (field_->cpp_type())
+                    {
+                        case FieldDescriptor::CPPTYPE_BOOL:
+                            {
+                                bool first = reflection->GetBool(*a, field_);
+                                bool second = reflection->GetBool(*b, field_);
+                                return first < second;
+                            }
+                        case FieldDescriptor::CPPTYPE_INT32:
+                            {
+                                int32_t first = reflection->GetInt32(*a, field_);
+                                int32_t second = reflection->GetInt32(*b, field_);
+                                return first < second;
+                            }
+                        case FieldDescriptor::CPPTYPE_INT64:
+                            {
+                                int64_t first = reflection->GetInt64(*a, field_);
+                                int64_t second = reflection->GetInt64(*b, field_);
+                                return first < second;
+                            }
+                        case FieldDescriptor::CPPTYPE_UINT32:
+                            {
+                                uint32_t first = reflection->GetUInt32(*a, field_);
+                                uint32_t second = reflection->GetUInt32(*b, field_);
+                                return first < second;
+                            }
+                        case FieldDescriptor::CPPTYPE_UINT64:
+                            {
+                                uint64_t first = reflection->GetUInt64(*a, field_);
+                                uint64_t second = reflection->GetUInt64(*b, field_);
+                                return first < second;
+                            }
+                        case FieldDescriptor::CPPTYPE_STRING:
+                            {
+                                std::string first = reflection->GetString(*a, field_);
+                                std::string second = reflection->GetString(*b, field_);
+                                return first < second;
+                            }
+                        default:
+                            GOOGLE_LOG(DFATAL) << "Invalid key for map field.";
+                            return true;
+                    }
+                }
+
+            private:
+                const FieldDescriptor* field_;
+            };
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/empty.pb.h b/CAPI/cpp/grpc/include/google/protobuf/empty.pb.h
index 00a4481..06cc93a 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/empty.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/empty.pb.h
@@ -29,20 +29,22 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fempty_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fempty_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fempty_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fempty_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -51,141 +53,176 @@ struct EmptyDefaultTypeInternal;
 PROTOBUF_EXPORT extern EmptyDefaultTypeInternal _Empty_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Empty* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Empty>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Empty* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Empty>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
 // ===================================================================
 
 class PROTOBUF_EXPORT Empty final :
-    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:google.protobuf.Empty) */ {
- public:
-  inline Empty() : Empty(nullptr) {}
-  explicit PROTOBUF_CONSTEXPR Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Empty(const Empty& from);
-  Empty(Empty&& from) noexcept
-    : Empty() {
-    *this = ::std::move(from);
-  }
-
-  inline Empty& operator=(const Empty& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Empty& operator=(Empty&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Empty& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Empty* internal_default_instance() {
-    return reinterpret_cast<const Empty*>(
-               &_Empty_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(Empty& a, Empty& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Empty* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Empty* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Empty>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
-  inline void CopyFrom(const Empty& from) {
-    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
-  void MergeFrom(const Empty& from) {
-    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
-  }
-  public:
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Empty";
-  }
-  protected:
-  explicit Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Empty)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-  };
-  friend struct ::TableStruct_google_2fprotobuf_2fempty_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:google.protobuf.Empty) */
+{
+public:
+    inline Empty() :
+        Empty(nullptr)
+    {
+    }
+    explicit PROTOBUF_CONSTEXPR Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Empty(const Empty& from);
+    Empty(Empty&& from) noexcept
+        :
+        Empty()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Empty& operator=(const Empty& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Empty& operator=(Empty&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Empty& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Empty* internal_default_instance()
+    {
+        return reinterpret_cast<const Empty*>(
+            &_Empty_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(Empty& a, Empty& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Empty* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Empty* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Empty>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+    inline void CopyFrom(const Empty& from)
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+    void MergeFrom(const Empty& from)
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
+    }
+
+public:
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Empty";
+    }
+
+protected:
+    explicit Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.Empty)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fempty_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // Empty
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 
 // @@protoc_insertion_point(namespace_scope)
diff --git a/CAPI/cpp/grpc/include/google/protobuf/endian.h b/CAPI/cpp/grpc/include/google/protobuf/endian.h
index e0ee6cd..8f628af 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/endian.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/endian.h
@@ -40,157 +40,166 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-inline uint64_t BSwap64(uint64_t host_int) {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            inline uint64_t BSwap64(uint64_t host_int)
+            {
 #if defined(PROTOBUF_BUILTIN_BSWAP64)
-  return PROTOBUF_BUILTIN_BSWAP64(host_int);
+                return PROTOBUF_BUILTIN_BSWAP64(host_int);
 #elif defined(_MSC_VER)
-  return _byteswap_uint64(host_int);
+                return _byteswap_uint64(host_int);
 #else
-  return (((host_int & uint64_t{0xFF}) << 56) |
-          ((host_int & uint64_t{0xFF00}) << 40) |
-          ((host_int & uint64_t{0xFF0000}) << 24) |
-          ((host_int & uint64_t{0xFF000000}) << 8) |
-          ((host_int & uint64_t{0xFF00000000}) >> 8) |
-          ((host_int & uint64_t{0xFF0000000000}) >> 24) |
-          ((host_int & uint64_t{0xFF000000000000}) >> 40) |
-          ((host_int & uint64_t{0xFF00000000000000}) >> 56));
-#endif
-}
-
-inline uint32_t BSwap32(uint32_t host_int) {
+                return (((host_int & uint64_t{0xFF}) << 56) | ((host_int & uint64_t{0xFF00}) << 40) | ((host_int & uint64_t{0xFF0000}) << 24) | ((host_int & uint64_t{0xFF000000}) << 8) | ((host_int & uint64_t{0xFF00000000}) >> 8) | ((host_int & uint64_t{0xFF0000000000}) >> 24) | ((host_int & uint64_t{0xFF000000000000}) >> 40) | ((host_int & uint64_t{0xFF00000000000000}) >> 56));
+#endif
+            }
+
+            inline uint32_t BSwap32(uint32_t host_int)
+            {
 #if defined(PROTOBUF_BUILTIN_BSWAP32)
-  return PROTOBUF_BUILTIN_BSWAP32(host_int);
+                return PROTOBUF_BUILTIN_BSWAP32(host_int);
 #elif defined(_MSC_VER)
-  return _byteswap_ulong(host_int);
+                return _byteswap_ulong(host_int);
 #else
-  return (((host_int & uint32_t{0xFF}) << 24) |
-          ((host_int & uint32_t{0xFF00}) << 8) |
-          ((host_int & uint32_t{0xFF0000}) >> 8) |
-          ((host_int & uint32_t{0xFF000000}) >> 24));
+                return (((host_int & uint32_t{0xFF}) << 24) | ((host_int & uint32_t{0xFF00}) << 8) | ((host_int & uint32_t{0xFF0000}) >> 8) | ((host_int & uint32_t{0xFF000000}) >> 24));
 #endif
-}
+            }
 
-inline uint16_t BSwap16(uint16_t host_int) {
+            inline uint16_t BSwap16(uint16_t host_int)
+            {
 #if defined(PROTOBUF_BUILTIN_BSWAP16)
-  return PROTOBUF_BUILTIN_BSWAP16(host_int);
+                return PROTOBUF_BUILTIN_BSWAP16(host_int);
 #elif defined(_MSC_VER)
-  return _byteswap_ushort(host_int);
+                return _byteswap_ushort(host_int);
 #else
-  return (((host_int & uint16_t{0xFF}) << 8) |
-          ((host_int & uint16_t{0xFF00}) >> 8));
+                return (((host_int & uint16_t{0xFF}) << 8) | ((host_int & uint16_t{0xFF00}) >> 8));
 #endif
-}
+            }
 
-namespace little_endian {
+            namespace little_endian
+            {
 
-inline uint16_t FromHost(uint16_t value) {
+                inline uint16_t FromHost(uint16_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return BSwap16(value);
+                    return BSwap16(value);
 #else
-  return value;
+                    return value;
 #endif
-}
+                }
 
-inline uint32_t FromHost(uint32_t value) {
+                inline uint32_t FromHost(uint32_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return BSwap32(value);
+                    return BSwap32(value);
 #else
-  return value;
+                    return value;
 #endif
-}
+                }
 
-inline uint64_t FromHost(uint64_t value) {
+                inline uint64_t FromHost(uint64_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return BSwap64(value);
+                    return BSwap64(value);
 #else
-  return value;
+                    return value;
 #endif
-}
+                }
 
-inline uint16_t ToHost(uint16_t value) {
+                inline uint16_t ToHost(uint16_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return BSwap16(value);
+                    return BSwap16(value);
 #else
-  return value;
+                    return value;
 #endif
-}
+                }
 
-inline uint32_t ToHost(uint32_t value) {
+                inline uint32_t ToHost(uint32_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return BSwap32(value);
+                    return BSwap32(value);
 #else
-  return value;
+                    return value;
 #endif
-}
+                }
 
-inline uint64_t ToHost(uint64_t value) {
+                inline uint64_t ToHost(uint64_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return BSwap64(value);
+                    return BSwap64(value);
 #else
-  return value;
+                    return value;
 #endif
-}
+                }
 
-}  // namespace little_endian
+            }  // namespace little_endian
 
-namespace big_endian {
+            namespace big_endian
+            {
 
-inline uint16_t FromHost(uint16_t value) {
+                inline uint16_t FromHost(uint16_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return value;
+                    return value;
 #else
-  return BSwap16(value);
+                    return BSwap16(value);
 #endif
-}
+                }
 
-inline uint32_t FromHost(uint32_t value) {
+                inline uint32_t FromHost(uint32_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return value;
+                    return value;
 #else
-  return BSwap32(value);
+                    return BSwap32(value);
 #endif
-}
+                }
 
-inline uint64_t FromHost(uint64_t value) {
+                inline uint64_t FromHost(uint64_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return value;
+                    return value;
 #else
-  return BSwap64(value);
+                    return BSwap64(value);
 #endif
-}
+                }
 
-inline uint16_t ToHost(uint16_t value) {
+                inline uint16_t ToHost(uint16_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return value;
+                    return value;
 #else
-  return BSwap16(value);
+                    return BSwap16(value);
 #endif
-}
+                }
 
-inline uint32_t ToHost(uint32_t value) {
+                inline uint32_t ToHost(uint32_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return value;
+                    return value;
 #else
-  return BSwap32(value);
+                    return BSwap32(value);
 #endif
-}
+                }
 
-inline uint64_t ToHost(uint64_t value) {
+                inline uint64_t ToHost(uint64_t value)
+                {
 #if defined(PROTOBUF_BIG_ENDIAN)
-  return value;
+                    return value;
 #else
-  return BSwap64(value);
+                    return BSwap64(value);
 #endif
-}
+                }
 
-}  // namespace big_endian
+            }  // namespace big_endian
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/explicitly_constructed.h b/CAPI/cpp/grpc/include/google/protobuf/explicitly_constructed.h
index 174c59a..5bd4afe 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/explicitly_constructed.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/explicitly_constructed.h
@@ -42,54 +42,71 @@
 #include <google/protobuf/port_def.inc>
 // clang-format on
 
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
-// Wraps a variable whose constructor and destructor are explicitly
-// called. It is particularly useful for a global variable, without its
-// constructor and destructor run on start and end of the program lifetime.
-// This circumvents the initial construction order fiasco, while keeping
-// the address of the empty string a compile time constant.
-//
-// Pay special attention to the initialization state of the object.
-// 1. The object is "uninitialized" to begin with.
-// 2. Call Construct() or DefaultConstruct() only if the object is
-//    uninitialized. After the call, the object becomes "initialized".
-// 3. Call get() and get_mutable() only if the object is initialized.
-// 4. Call Destruct() only if the object is initialized.
-//    After the call, the object becomes uninitialized.
-template <typename T, size_t min_align = 1>
-class ExplicitlyConstructed {
- public:
-  void DefaultConstruct() { new (&union_) T(); }
+            // Wraps a variable whose constructor and destructor are explicitly
+            // called. It is particularly useful for a global variable, without its
+            // constructor and destructor run on start and end of the program lifetime.
+            // This circumvents the initial construction order fiasco, while keeping
+            // the address of the empty string a compile time constant.
+            //
+            // Pay special attention to the initialization state of the object.
+            // 1. The object is "uninitialized" to begin with.
+            // 2. Call Construct() or DefaultConstruct() only if the object is
+            //    uninitialized. After the call, the object becomes "initialized".
+            // 3. Call get() and get_mutable() only if the object is initialized.
+            // 4. Call Destruct() only if the object is initialized.
+            //    After the call, the object becomes uninitialized.
+            template<typename T, size_t min_align = 1>
+            class ExplicitlyConstructed
+            {
+            public:
+                void DefaultConstruct()
+                {
+                    new (&union_) T();
+                }
 
-  template <typename... Args>
-  void Construct(Args&&... args) {
-    new (&union_) T(std::forward<Args>(args)...);
-  }
+                template<typename... Args>
+                void Construct(Args&&... args)
+                {
+                    new (&union_) T(std::forward<Args>(args)...);
+                }
 
-  void Destruct() { get_mutable()->~T(); }
+                void Destruct()
+                {
+                    get_mutable()->~T();
+                }
 
-  constexpr const T& get() const { return reinterpret_cast<const T&>(union_); }
-  T* get_mutable() { return reinterpret_cast<T*>(&union_); }
+                constexpr const T& get() const
+                {
+                    return reinterpret_cast<const T&>(union_);
+                }
+                T* get_mutable()
+                {
+                    return reinterpret_cast<T*>(&union_);
+                }
 
- private:
-  union AlignedUnion {
-    alignas(min_align > alignof(T) ? min_align
-                                   : alignof(T)) char space[sizeof(T)];
-    int64_t align_to_int64;
-    void* align_to_ptr;
-  } union_;
-};
+            private:
+                union AlignedUnion
+                {
+                    alignas(min_align > alignof(T) ? min_align : alignof(T)) char space[sizeof(T)];
+                    int64_t align_to_int64;
+                    void* align_to_ptr;
+                } union_;
+            };
 
-// ArenaStringPtr compatible explicitly constructed string type.
-// This empty string type is aligned with a minimum alignment of 8 bytes
-// which is the minimum requirement of ArenaStringPtr
-using ExplicitlyConstructedArenaString = ExplicitlyConstructed<std::string, 8>;
+            // ArenaStringPtr compatible explicitly constructed string type.
+            // This empty string type is aligned with a minimum alignment of 8 bytes
+            // which is the minimum requirement of ArenaStringPtr
+            using ExplicitlyConstructedArenaString = ExplicitlyConstructed<std::string, 8>;
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/extension_set.h b/CAPI/cpp/grpc/include/google/protobuf/extension_set.h
index 0e6d052..125facd 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/extension_set.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/extension_set.h
@@ -38,7 +38,6 @@
 #ifndef GOOGLE_PROTOBUF_EXTENSION_SET_H__
 #define GOOGLE_PROTOBUF_EXTENSION_SET_H__
 
-
 #include <algorithm>
 #include <cassert>
 #include <map>
@@ -62,1498 +61,1532 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-class Arena;
-class Descriptor;       // descriptor.h
-class FieldDescriptor;  // descriptor.h
-class DescriptorPool;   // descriptor.h
-class MessageLite;      // message_lite.h
-class Message;          // message.h
-class MessageFactory;   // message.h
-class Reflection;       // message.h
-class UnknownFieldSet;  // unknown_field_set.h
-namespace internal {
-class FieldSkipper;  // wire_format_lite.h
-enum class LazyVerifyOption;
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        class Arena;
+        class Descriptor;       // descriptor.h
+        class FieldDescriptor;  // descriptor.h
+        class DescriptorPool;   // descriptor.h
+        class MessageLite;      // message_lite.h
+        class Message;          // message.h
+        class MessageFactory;   // message.h
+        class Reflection;       // message.h
+        class UnknownFieldSet;  // unknown_field_set.h
+        namespace internal
+        {
+            class FieldSkipper;  // wire_format_lite.h
+            enum class LazyVerifyOption;
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-class InternalMetadata;
-
-// Used to store values of type WireFormatLite::FieldType without having to
-// #include wire_format_lite.h.  Also, ensures that we use only one byte to
-// store these values, which is important to keep the layout of
-// ExtensionSet::Extension small.
-typedef uint8_t FieldType;
-
-// A function which, given an integer value, returns true if the number
-// matches one of the defined values for the corresponding enum type.  This
-// is used with RegisterEnumExtension, below.
-typedef bool EnumValidityFunc(int number);
-
-// Version of the above which takes an argument.  This is needed to deal with
-// extensions that are not compiled in.
-typedef bool EnumValidityFuncWithArg(const void* arg, int number);
-
-// Information about a registered extension.
-struct ExtensionInfo {
-  constexpr ExtensionInfo() : enum_validity_check() {}
-  constexpr ExtensionInfo(const MessageLite* extendee, int param_number,
-                          FieldType type_param, bool isrepeated, bool ispacked,
-                          LazyEagerVerifyFnType verify_func)
-      : message(extendee),
-        number(param_number),
-        type(type_param),
-        is_repeated(isrepeated),
-        is_packed(ispacked),
-        enum_validity_check(),
-        lazy_eager_verify_func(verify_func) {}
-
-  const MessageLite* message = nullptr;
-  int number = 0;
-
-  FieldType type = 0;
-  bool is_repeated = false;
-  bool is_packed = false;
-
-  struct EnumValidityCheck {
-    EnumValidityFuncWithArg* func;
-    const void* arg;
-  };
-
-  struct MessageInfo {
-    const MessageLite* prototype;
-  };
-
-  union {
-    EnumValidityCheck enum_validity_check;
-    MessageInfo message_info;
-  };
-
-  // The descriptor for this extension, if one exists and is known.  May be
-  // nullptr.  Must not be nullptr if the descriptor for the extension does not
-  // live in the same pool as the descriptor for the containing type.
-  const FieldDescriptor* descriptor = nullptr;
-
-  // If this field is potentially lazy this function can be used as a cheap
-  // verification of the raw bytes.
-  // If nullptr then no verification is performed.
-  LazyEagerVerifyFnType lazy_eager_verify_func = nullptr;
-};
-
-// An ExtensionFinder is an object which looks up extension definitions.  It
-// must implement this method:
-//
-// bool Find(int number, ExtensionInfo* output);
-
-// GeneratedExtensionFinder is an ExtensionFinder which finds extensions
-// defined in .proto files which have been compiled into the binary.
-class PROTOBUF_EXPORT GeneratedExtensionFinder {
- public:
-  explicit GeneratedExtensionFinder(const MessageLite* extendee)
-      : extendee_(extendee) {}
-
-  // Returns true and fills in *output if found, otherwise returns false.
-  bool Find(int number, ExtensionInfo* output);
-
- private:
-  const MessageLite* extendee_;
-};
-
-// Note:  extension_set_heavy.cc defines DescriptorPoolExtensionFinder for
-// finding extensions from a DescriptorPool.
-
-// This is an internal helper class intended for use within the protocol buffer
-// library and generated classes.  Clients should not use it directly.  Instead,
-// use the generated accessors such as GetExtension() of the class being
-// extended.
-//
-// This class manages extensions for a protocol message object.  The
-// message's HasExtension(), GetExtension(), MutableExtension(), and
-// ClearExtension() methods are just thin wrappers around the embedded
-// ExtensionSet.  When parsing, if a tag number is encountered which is
-// inside one of the message type's extension ranges, the tag is passed
-// off to the ExtensionSet for parsing.  Etc.
-class PROTOBUF_EXPORT ExtensionSet {
- public:
-  constexpr ExtensionSet();
-  explicit ExtensionSet(Arena* arena);
-  ExtensionSet(ArenaInitialized, Arena* arena) : ExtensionSet(arena) {}
-  ~ExtensionSet();
-
-  // These are called at startup by protocol-compiler-generated code to
-  // register known extensions.  The registrations are used by ParseField()
-  // to look up extensions for parsed field numbers.  Note that dynamic parsing
-  // does not use ParseField(); only protocol-compiler-generated parsing
-  // methods do.
-  static void RegisterExtension(const MessageLite* extendee, int number,
-                                FieldType type, bool is_repeated,
-                                bool is_packed,
-                                LazyEagerVerifyFnType verify_func);
-  static void RegisterEnumExtension(const MessageLite* extendee, int number,
-                                    FieldType type, bool is_repeated,
-                                    bool is_packed, EnumValidityFunc* is_valid);
-  static void RegisterMessageExtension(const MessageLite* extendee, int number,
-                                       FieldType type, bool is_repeated,
-                                       bool is_packed,
-                                       const MessageLite* prototype,
-                                       LazyEagerVerifyFnType verify_func);
-
-  // =================================================================
-
-  // Add all fields which are currently present to the given vector.  This
-  // is useful to implement Reflection::ListFields().
-  void AppendToList(const Descriptor* extendee, const DescriptorPool* pool,
-                    std::vector<const FieldDescriptor*>* output) const;
-
-  // =================================================================
-  // Accessors
-  //
-  // Generated message classes include type-safe templated wrappers around
-  // these methods.  Generally you should use those rather than call these
-  // directly, unless you are doing low-level memory management.
-  //
-  // When calling any of these accessors, the extension number requested
-  // MUST exist in the DescriptorPool provided to the constructor.  Otherwise,
-  // the method will fail an assert.  Normally, though, you would not call
-  // these directly; you would either call the generated accessors of your
-  // message class (e.g. GetExtension()) or you would call the accessors
-  // of the reflection interface.  In both cases, it is impossible to
-  // trigger this assert failure:  the generated accessors only accept
-  // linked-in extension types as parameters, while the Reflection interface
-  // requires you to provide the FieldDescriptor describing the extension.
-  //
-  // When calling any of these accessors, a protocol-compiler-generated
-  // implementation of the extension corresponding to the number MUST
-  // be linked in, and the FieldDescriptor used to refer to it MUST be
-  // the one generated by that linked-in code.  Otherwise, the method will
-  // die on an assert failure.  The message objects returned by the message
-  // accessors are guaranteed to be of the correct linked-in type.
-  //
-  // These methods pretty much match Reflection except that:
-  // - They're not virtual.
-  // - They identify fields by number rather than FieldDescriptors.
-  // - They identify enum values using integers rather than descriptors.
-  // - Strings provide Mutable() in addition to Set() accessors.
-
-  bool Has(int number) const;
-  int ExtensionSize(int number) const;  // Size of a repeated extension.
-  int NumExtensions() const;            // The number of extensions
-  FieldType ExtensionType(int number) const;
-  void ClearExtension(int number);
-
-  // singular fields -------------------------------------------------
-
-  int32_t GetInt32(int number, int32_t default_value) const;
-  int64_t GetInt64(int number, int64_t default_value) const;
-  uint32_t GetUInt32(int number, uint32_t default_value) const;
-  uint64_t GetUInt64(int number, uint64_t default_value) const;
-  float GetFloat(int number, float default_value) const;
-  double GetDouble(int number, double default_value) const;
-  bool GetBool(int number, bool default_value) const;
-  int GetEnum(int number, int default_value) const;
-  const std::string& GetString(int number,
-                               const std::string& default_value) const;
-  const MessageLite& GetMessage(int number,
-                                const MessageLite& default_value) const;
-  const MessageLite& GetMessage(int number, const Descriptor* message_type,
-                                MessageFactory* factory) const;
-
-  // |descriptor| may be nullptr so long as it is known that the descriptor for
-  // the extension lives in the same pool as the descriptor for the containing
-  // type.
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            class InternalMetadata;
+
+            // Used to store values of type WireFormatLite::FieldType without having to
+            // #include wire_format_lite.h.  Also, ensures that we use only one byte to
+            // store these values, which is important to keep the layout of
+            // ExtensionSet::Extension small.
+            typedef uint8_t FieldType;
+
+            // A function which, given an integer value, returns true if the number
+            // matches one of the defined values for the corresponding enum type.  This
+            // is used with RegisterEnumExtension, below.
+            typedef bool EnumValidityFunc(int number);
+
+            // Version of the above which takes an argument.  This is needed to deal with
+            // extensions that are not compiled in.
+            typedef bool EnumValidityFuncWithArg(const void* arg, int number);
+
+            // Information about a registered extension.
+            struct ExtensionInfo
+            {
+                constexpr ExtensionInfo() :
+                    enum_validity_check()
+                {
+                }
+                constexpr ExtensionInfo(const MessageLite* extendee, int param_number, FieldType type_param, bool isrepeated, bool ispacked, LazyEagerVerifyFnType verify_func) :
+                    message(extendee),
+                    number(param_number),
+                    type(type_param),
+                    is_repeated(isrepeated),
+                    is_packed(ispacked),
+                    enum_validity_check(),
+                    lazy_eager_verify_func(verify_func)
+                {
+                }
+
+                const MessageLite* message = nullptr;
+                int number = 0;
+
+                FieldType type = 0;
+                bool is_repeated = false;
+                bool is_packed = false;
+
+                struct EnumValidityCheck
+                {
+                    EnumValidityFuncWithArg* func;
+                    const void* arg;
+                };
+
+                struct MessageInfo
+                {
+                    const MessageLite* prototype;
+                };
+
+                union
+                {
+                    EnumValidityCheck enum_validity_check;
+                    MessageInfo message_info;
+                };
+
+                // The descriptor for this extension, if one exists and is known.  May be
+                // nullptr.  Must not be nullptr if the descriptor for the extension does not
+                // live in the same pool as the descriptor for the containing type.
+                const FieldDescriptor* descriptor = nullptr;
+
+                // If this field is potentially lazy this function can be used as a cheap
+                // verification of the raw bytes.
+                // If nullptr then no verification is performed.
+                LazyEagerVerifyFnType lazy_eager_verify_func = nullptr;
+            };
+
+            // An ExtensionFinder is an object which looks up extension definitions.  It
+            // must implement this method:
+            //
+            // bool Find(int number, ExtensionInfo* output);
+
+            // GeneratedExtensionFinder is an ExtensionFinder which finds extensions
+            // defined in .proto files which have been compiled into the binary.
+            class PROTOBUF_EXPORT GeneratedExtensionFinder
+            {
+            public:
+                explicit GeneratedExtensionFinder(const MessageLite* extendee) :
+                    extendee_(extendee)
+                {
+                }
+
+                // Returns true and fills in *output if found, otherwise returns false.
+                bool Find(int number, ExtensionInfo* output);
+
+            private:
+                const MessageLite* extendee_;
+            };
+
+            // Note:  extension_set_heavy.cc defines DescriptorPoolExtensionFinder for
+            // finding extensions from a DescriptorPool.
+
+            // This is an internal helper class intended for use within the protocol buffer
+            // library and generated classes.  Clients should not use it directly.  Instead,
+            // use the generated accessors such as GetExtension() of the class being
+            // extended.
+            //
+            // This class manages extensions for a protocol message object.  The
+            // message's HasExtension(), GetExtension(), MutableExtension(), and
+            // ClearExtension() methods are just thin wrappers around the embedded
+            // ExtensionSet.  When parsing, if a tag number is encountered which is
+            // inside one of the message type's extension ranges, the tag is passed
+            // off to the ExtensionSet for parsing.  Etc.
+            class PROTOBUF_EXPORT ExtensionSet
+            {
+            public:
+                constexpr ExtensionSet();
+                explicit ExtensionSet(Arena* arena);
+                ExtensionSet(ArenaInitialized, Arena* arena) :
+                    ExtensionSet(arena)
+                {
+                }
+                ~ExtensionSet();
+
+                // These are called at startup by protocol-compiler-generated code to
+                // register known extensions.  The registrations are used by ParseField()
+                // to look up extensions for parsed field numbers.  Note that dynamic parsing
+                // does not use ParseField(); only protocol-compiler-generated parsing
+                // methods do.
+                static void RegisterExtension(const MessageLite* extendee, int number, FieldType type, bool is_repeated, bool is_packed, LazyEagerVerifyFnType verify_func);
+                static void RegisterEnumExtension(const MessageLite* extendee, int number, FieldType type, bool is_repeated, bool is_packed, EnumValidityFunc* is_valid);
+                static void RegisterMessageExtension(const MessageLite* extendee, int number, FieldType type, bool is_repeated, bool is_packed, const MessageLite* prototype, LazyEagerVerifyFnType verify_func);
+
+                // =================================================================
+
+                // Add all fields which are currently present to the given vector.  This
+                // is useful to implement Reflection::ListFields().
+                void AppendToList(const Descriptor* extendee, const DescriptorPool* pool, std::vector<const FieldDescriptor*>* output) const;
+
+                // =================================================================
+                // Accessors
+                //
+                // Generated message classes include type-safe templated wrappers around
+                // these methods.  Generally you should use those rather than call these
+                // directly, unless you are doing low-level memory management.
+                //
+                // When calling any of these accessors, the extension number requested
+                // MUST exist in the DescriptorPool provided to the constructor.  Otherwise,
+                // the method will fail an assert.  Normally, though, you would not call
+                // these directly; you would either call the generated accessors of your
+                // message class (e.g. GetExtension()) or you would call the accessors
+                // of the reflection interface.  In both cases, it is impossible to
+                // trigger this assert failure:  the generated accessors only accept
+                // linked-in extension types as parameters, while the Reflection interface
+                // requires you to provide the FieldDescriptor describing the extension.
+                //
+                // When calling any of these accessors, a protocol-compiler-generated
+                // implementation of the extension corresponding to the number MUST
+                // be linked in, and the FieldDescriptor used to refer to it MUST be
+                // the one generated by that linked-in code.  Otherwise, the method will
+                // die on an assert failure.  The message objects returned by the message
+                // accessors are guaranteed to be of the correct linked-in type.
+                //
+                // These methods pretty much match Reflection except that:
+                // - They're not virtual.
+                // - They identify fields by number rather than FieldDescriptors.
+                // - They identify enum values using integers rather than descriptors.
+                // - Strings provide Mutable() in addition to Set() accessors.
+
+                bool Has(int number) const;
+                int ExtensionSize(int number) const;  // Size of a repeated extension.
+                int NumExtensions() const;            // The number of extensions
+                FieldType ExtensionType(int number) const;
+                void ClearExtension(int number);
+
+                // singular fields -------------------------------------------------
+
+                int32_t GetInt32(int number, int32_t default_value) const;
+                int64_t GetInt64(int number, int64_t default_value) const;
+                uint32_t GetUInt32(int number, uint32_t default_value) const;
+                uint64_t GetUInt64(int number, uint64_t default_value) const;
+                float GetFloat(int number, float default_value) const;
+                double GetDouble(int number, double default_value) const;
+                bool GetBool(int number, bool default_value) const;
+                int GetEnum(int number, int default_value) const;
+                const std::string& GetString(int number, const std::string& default_value) const;
+                const MessageLite& GetMessage(int number, const MessageLite& default_value) const;
+                const MessageLite& GetMessage(int number, const Descriptor* message_type, MessageFactory* factory) const;
+
+                // |descriptor| may be nullptr so long as it is known that the descriptor for
+                // the extension lives in the same pool as the descriptor for the containing
+                // type.
 #define desc const FieldDescriptor* descriptor  // avoid line wrapping
-  void SetInt32(int number, FieldType type, int32_t value, desc);
-  void SetInt64(int number, FieldType type, int64_t value, desc);
-  void SetUInt32(int number, FieldType type, uint32_t value, desc);
-  void SetUInt64(int number, FieldType type, uint64_t value, desc);
-  void SetFloat(int number, FieldType type, float value, desc);
-  void SetDouble(int number, FieldType type, double value, desc);
-  void SetBool(int number, FieldType type, bool value, desc);
-  void SetEnum(int number, FieldType type, int value, desc);
-  void SetString(int number, FieldType type, std::string value, desc);
-  std::string* MutableString(int number, FieldType type, desc);
-  MessageLite* MutableMessage(int number, FieldType type,
-                              const MessageLite& prototype, desc);
-  MessageLite* MutableMessage(const FieldDescriptor* descriptor,
-                              MessageFactory* factory);
-  // Adds the given message to the ExtensionSet, taking ownership of the
-  // message object. Existing message with the same number will be deleted.
-  // If "message" is nullptr, this is equivalent to "ClearExtension(number)".
-  void SetAllocatedMessage(int number, FieldType type,
-                           const FieldDescriptor* descriptor,
-                           MessageLite* message);
-  void UnsafeArenaSetAllocatedMessage(int number, FieldType type,
-                                      const FieldDescriptor* descriptor,
-                                      MessageLite* message);
-  PROTOBUF_NODISCARD MessageLite* ReleaseMessage(int number,
-                                                 const MessageLite& prototype);
-  MessageLite* UnsafeArenaReleaseMessage(int number,
-                                         const MessageLite& prototype);
-
-  PROTOBUF_NODISCARD MessageLite* ReleaseMessage(
-      const FieldDescriptor* descriptor, MessageFactory* factory);
-  MessageLite* UnsafeArenaReleaseMessage(const FieldDescriptor* descriptor,
-                                         MessageFactory* factory);
+                void SetInt32(int number, FieldType type, int32_t value, desc);
+                void SetInt64(int number, FieldType type, int64_t value, desc);
+                void SetUInt32(int number, FieldType type, uint32_t value, desc);
+                void SetUInt64(int number, FieldType type, uint64_t value, desc);
+                void SetFloat(int number, FieldType type, float value, desc);
+                void SetDouble(int number, FieldType type, double value, desc);
+                void SetBool(int number, FieldType type, bool value, desc);
+                void SetEnum(int number, FieldType type, int value, desc);
+                void SetString(int number, FieldType type, std::string value, desc);
+                std::string* MutableString(int number, FieldType type, desc);
+                MessageLite* MutableMessage(int number, FieldType type, const MessageLite& prototype, desc);
+                MessageLite* MutableMessage(const FieldDescriptor* descriptor, MessageFactory* factory);
+                // Adds the given message to the ExtensionSet, taking ownership of the
+                // message object. Existing message with the same number will be deleted.
+                // If "message" is nullptr, this is equivalent to "ClearExtension(number)".
+                void SetAllocatedMessage(int number, FieldType type, const FieldDescriptor* descriptor, MessageLite* message);
+                void UnsafeArenaSetAllocatedMessage(int number, FieldType type, const FieldDescriptor* descriptor, MessageLite* message);
+                PROTOBUF_NODISCARD MessageLite* ReleaseMessage(int number, const MessageLite& prototype);
+                MessageLite* UnsafeArenaReleaseMessage(int number, const MessageLite& prototype);
+
+                PROTOBUF_NODISCARD MessageLite* ReleaseMessage(
+                    const FieldDescriptor* descriptor, MessageFactory* factory
+                );
+                MessageLite* UnsafeArenaReleaseMessage(const FieldDescriptor* descriptor, MessageFactory* factory);
 #undef desc
-  Arena* GetArena() const { return arena_; }
-
-  // repeated fields -------------------------------------------------
-
-  // Fetches a RepeatedField extension by number; returns |default_value|
-  // if no such extension exists. User should not touch this directly; it is
-  // used by the GetRepeatedExtension() method.
-  const void* GetRawRepeatedField(int number, const void* default_value) const;
-  // Fetches a mutable version of a RepeatedField extension by number,
-  // instantiating one if none exists. Similar to above, user should not use
-  // this directly; it underlies MutableRepeatedExtension().
-  void* MutableRawRepeatedField(int number, FieldType field_type, bool packed,
-                                const FieldDescriptor* desc);
-
-  // This is an overload of MutableRawRepeatedField to maintain compatibility
-  // with old code using a previous API. This version of
-  // MutableRawRepeatedField() will GOOGLE_CHECK-fail on a missing extension.
-  // (E.g.: borg/clients/internal/proto1/proto2_reflection.cc.)
-  void* MutableRawRepeatedField(int number);
-
-  int32_t GetRepeatedInt32(int number, int index) const;
-  int64_t GetRepeatedInt64(int number, int index) const;
-  uint32_t GetRepeatedUInt32(int number, int index) const;
-  uint64_t GetRepeatedUInt64(int number, int index) const;
-  float GetRepeatedFloat(int number, int index) const;
-  double GetRepeatedDouble(int number, int index) const;
-  bool GetRepeatedBool(int number, int index) const;
-  int GetRepeatedEnum(int number, int index) const;
-  const std::string& GetRepeatedString(int number, int index) const;
-  const MessageLite& GetRepeatedMessage(int number, int index) const;
-
-  void SetRepeatedInt32(int number, int index, int32_t value);
-  void SetRepeatedInt64(int number, int index, int64_t value);
-  void SetRepeatedUInt32(int number, int index, uint32_t value);
-  void SetRepeatedUInt64(int number, int index, uint64_t value);
-  void SetRepeatedFloat(int number, int index, float value);
-  void SetRepeatedDouble(int number, int index, double value);
-  void SetRepeatedBool(int number, int index, bool value);
-  void SetRepeatedEnum(int number, int index, int value);
-  void SetRepeatedString(int number, int index, std::string value);
-  std::string* MutableRepeatedString(int number, int index);
-  MessageLite* MutableRepeatedMessage(int number, int index);
+                Arena* GetArena() const
+                {
+                    return arena_;
+                }
+
+                // repeated fields -------------------------------------------------
+
+                // Fetches a RepeatedField extension by number; returns |default_value|
+                // if no such extension exists. User should not touch this directly; it is
+                // used by the GetRepeatedExtension() method.
+                const void* GetRawRepeatedField(int number, const void* default_value) const;
+                // Fetches a mutable version of a RepeatedField extension by number,
+                // instantiating one if none exists. Similar to above, user should not use
+                // this directly; it underlies MutableRepeatedExtension().
+                void* MutableRawRepeatedField(int number, FieldType field_type, bool packed, const FieldDescriptor* desc);
+
+                // This is an overload of MutableRawRepeatedField to maintain compatibility
+                // with old code using a previous API. This version of
+                // MutableRawRepeatedField() will GOOGLE_CHECK-fail on a missing extension.
+                // (E.g.: borg/clients/internal/proto1/proto2_reflection.cc.)
+                void* MutableRawRepeatedField(int number);
+
+                int32_t GetRepeatedInt32(int number, int index) const;
+                int64_t GetRepeatedInt64(int number, int index) const;
+                uint32_t GetRepeatedUInt32(int number, int index) const;
+                uint64_t GetRepeatedUInt64(int number, int index) const;
+                float GetRepeatedFloat(int number, int index) const;
+                double GetRepeatedDouble(int number, int index) const;
+                bool GetRepeatedBool(int number, int index) const;
+                int GetRepeatedEnum(int number, int index) const;
+                const std::string& GetRepeatedString(int number, int index) const;
+                const MessageLite& GetRepeatedMessage(int number, int index) const;
+
+                void SetRepeatedInt32(int number, int index, int32_t value);
+                void SetRepeatedInt64(int number, int index, int64_t value);
+                void SetRepeatedUInt32(int number, int index, uint32_t value);
+                void SetRepeatedUInt64(int number, int index, uint64_t value);
+                void SetRepeatedFloat(int number, int index, float value);
+                void SetRepeatedDouble(int number, int index, double value);
+                void SetRepeatedBool(int number, int index, bool value);
+                void SetRepeatedEnum(int number, int index, int value);
+                void SetRepeatedString(int number, int index, std::string value);
+                std::string* MutableRepeatedString(int number, int index);
+                MessageLite* MutableRepeatedMessage(int number, int index);
 
 #define desc const FieldDescriptor* descriptor  // avoid line wrapping
-  void AddInt32(int number, FieldType type, bool packed, int32_t value, desc);
-  void AddInt64(int number, FieldType type, bool packed, int64_t value, desc);
-  void AddUInt32(int number, FieldType type, bool packed, uint32_t value, desc);
-  void AddUInt64(int number, FieldType type, bool packed, uint64_t value, desc);
-  void AddFloat(int number, FieldType type, bool packed, float value, desc);
-  void AddDouble(int number, FieldType type, bool packed, double value, desc);
-  void AddBool(int number, FieldType type, bool packed, bool value, desc);
-  void AddEnum(int number, FieldType type, bool packed, int value, desc);
-  void AddString(int number, FieldType type, std::string value, desc);
-  std::string* AddString(int number, FieldType type, desc);
-  MessageLite* AddMessage(int number, FieldType type,
-                          const MessageLite& prototype, desc);
-  MessageLite* AddMessage(const FieldDescriptor* descriptor,
-                          MessageFactory* factory);
-  void AddAllocatedMessage(const FieldDescriptor* descriptor,
-                           MessageLite* new_entry);
-  void UnsafeArenaAddAllocatedMessage(const FieldDescriptor* descriptor,
-                                      MessageLite* new_entry);
+                void AddInt32(int number, FieldType type, bool packed, int32_t value, desc);
+                void AddInt64(int number, FieldType type, bool packed, int64_t value, desc);
+                void AddUInt32(int number, FieldType type, bool packed, uint32_t value, desc);
+                void AddUInt64(int number, FieldType type, bool packed, uint64_t value, desc);
+                void AddFloat(int number, FieldType type, bool packed, float value, desc);
+                void AddDouble(int number, FieldType type, bool packed, double value, desc);
+                void AddBool(int number, FieldType type, bool packed, bool value, desc);
+                void AddEnum(int number, FieldType type, bool packed, int value, desc);
+                void AddString(int number, FieldType type, std::string value, desc);
+                std::string* AddString(int number, FieldType type, desc);
+                MessageLite* AddMessage(int number, FieldType type, const MessageLite& prototype, desc);
+                MessageLite* AddMessage(const FieldDescriptor* descriptor, MessageFactory* factory);
+                void AddAllocatedMessage(const FieldDescriptor* descriptor, MessageLite* new_entry);
+                void UnsafeArenaAddAllocatedMessage(const FieldDescriptor* descriptor, MessageLite* new_entry);
 #undef desc
 
-  void RemoveLast(int number);
-  PROTOBUF_NODISCARD MessageLite* ReleaseLast(int number);
-  MessageLite* UnsafeArenaReleaseLast(int number);
-  void SwapElements(int number, int index1, int index2);
-
-  // =================================================================
-  // convenience methods for implementing methods of Message
-  //
-  // These could all be implemented in terms of the other methods of this
-  // class, but providing them here helps keep the generated code size down.
-
-  void Clear();
-  void MergeFrom(const MessageLite* extendee, const ExtensionSet& other);
-  void Swap(const MessageLite* extendee, ExtensionSet* other);
-  void InternalSwap(ExtensionSet* other);
-  void SwapExtension(const MessageLite* extendee, ExtensionSet* other,
-                     int number);
-  void UnsafeShallowSwapExtension(ExtensionSet* other, int number);
-  bool IsInitialized() const;
-
-  // Lite parser
-  const char* ParseField(uint64_t tag, const char* ptr,
-                         const MessageLite* extendee,
-                         internal::InternalMetadata* metadata,
-                         internal::ParseContext* ctx);
-  // Full parser
-  const char* ParseField(uint64_t tag, const char* ptr, const Message* extendee,
-                         internal::InternalMetadata* metadata,
-                         internal::ParseContext* ctx);
-  template <typename Msg>
-  const char* ParseMessageSet(const char* ptr, const Msg* extendee,
-                              InternalMetadata* metadata,
-                              internal::ParseContext* ctx) {
-    struct MessageSetItem {
-      const char* _InternalParse(const char* ptr, ParseContext* ctx) {
-        return me->ParseMessageSetItem(ptr, extendee, metadata, ctx);
-      }
-      ExtensionSet* me;
-      const Msg* extendee;
-      InternalMetadata* metadata;
-    } item{this, extendee, metadata};
-    while (!ctx->Done(&ptr)) {
-      uint32_t tag;
-      ptr = ReadTag(ptr, &tag);
-      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-      if (tag == WireFormatLite::kMessageSetItemStartTag) {
-        ptr = ctx->ParseGroup(&item, ptr, tag);
-        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-      } else {
-        if (tag == 0 || (tag & 7) == 4) {
-          ctx->SetLastTag(tag);
-          return ptr;
-        }
-        ptr = ParseField(tag, ptr, extendee, metadata, ctx);
-        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-      }
-    }
-    return ptr;
-  }
-
-  // Write all extension fields with field numbers in the range
-  //   [start_field_number, end_field_number)
-  // to the output stream, using the cached sizes computed when ByteSize() was
-  // last called.  Note that the range bounds are inclusive-exclusive.
-  void SerializeWithCachedSizes(const MessageLite* extendee,
-                                int start_field_number, int end_field_number,
-                                io::CodedOutputStream* output) const {
-    output->SetCur(_InternalSerialize(extendee, start_field_number,
-                                      end_field_number, output->Cur(),
-                                      output->EpsCopy()));
-  }
-
-  // Same as SerializeWithCachedSizes, but without any bounds checking.
-  // The caller must ensure that target has sufficient capacity for the
-  // serialized extensions.
-  //
-  // Returns a pointer past the last written byte.
-
-  uint8_t* _InternalSerialize(const MessageLite* extendee,
-                              int start_field_number, int end_field_number,
-                              uint8_t* target,
-                              io::EpsCopyOutputStream* stream) const {
-    if (flat_size_ == 0) {
-      assert(!is_large());
-      return target;
-    }
-    return _InternalSerializeImpl(extendee, start_field_number,
-                                  end_field_number, target, stream);
-  }
-
-  // Like above but serializes in MessageSet format.
-  void SerializeMessageSetWithCachedSizes(const MessageLite* extendee,
-                                          io::CodedOutputStream* output) const {
-    output->SetCur(InternalSerializeMessageSetWithCachedSizesToArray(
-        extendee, output->Cur(), output->EpsCopy()));
-  }
-  uint8_t* InternalSerializeMessageSetWithCachedSizesToArray(
-      const MessageLite* extendee, uint8_t* target,
-      io::EpsCopyOutputStream* stream) const;
-
-  // For backward-compatibility, versions of two of the above methods that
-  // serialize deterministically iff SetDefaultSerializationDeterministic()
-  // has been called.
-  uint8_t* SerializeWithCachedSizesToArray(int start_field_number,
-                                           int end_field_number,
-                                           uint8_t* target) const;
-  uint8_t* SerializeMessageSetWithCachedSizesToArray(
-      const MessageLite* extendee, uint8_t* target) const;
-
-  // Returns the total serialized size of all the extensions.
-  size_t ByteSize() const;
-
-  // Like ByteSize() but uses MessageSet format.
-  size_t MessageSetByteSize() const;
-
-  // Returns (an estimate of) the total number of bytes used for storing the
-  // extensions in memory, excluding sizeof(*this).  If the ExtensionSet is
-  // for a lite message (and thus possibly contains lite messages), the results
-  // are undefined (might work, might crash, might corrupt data, might not even
-  // be linked in).  It's up to the protocol compiler to avoid calling this on
-  // such ExtensionSets (easy enough since lite messages don't implement
-  // SpaceUsed()).
-  size_t SpaceUsedExcludingSelfLong() const;
-
-  // This method just calls SpaceUsedExcludingSelfLong() but it can not be
-  // inlined because the definition of SpaceUsedExcludingSelfLong() is not
-  // included in lite runtime and when an inline method refers to it MSVC
-  // will complain about unresolved symbols when building the lite runtime
-  // as .dll.
-  int SpaceUsedExcludingSelf() const;
-
- private:
-  template <typename Type>
-  friend class PrimitiveTypeTraits;
-
-  template <typename Type>
-  friend class RepeatedPrimitiveTypeTraits;
-
-  template <typename Type, bool IsValid(int)>
-  friend class EnumTypeTraits;
-
-  template <typename Type, bool IsValid(int)>
-  friend class RepeatedEnumTypeTraits;
-
-  friend class google::protobuf::Reflection;
-
-  const int32_t& GetRefInt32(int number, const int32_t& default_value) const;
-  const int64_t& GetRefInt64(int number, const int64_t& default_value) const;
-  const uint32_t& GetRefUInt32(int number, const uint32_t& default_value) const;
-  const uint64_t& GetRefUInt64(int number, const uint64_t& default_value) const;
-  const float& GetRefFloat(int number, const float& default_value) const;
-  const double& GetRefDouble(int number, const double& default_value) const;
-  const bool& GetRefBool(int number, const bool& default_value) const;
-  const int& GetRefEnum(int number, const int& default_value) const;
-  const int32_t& GetRefRepeatedInt32(int number, int index) const;
-  const int64_t& GetRefRepeatedInt64(int number, int index) const;
-  const uint32_t& GetRefRepeatedUInt32(int number, int index) const;
-  const uint64_t& GetRefRepeatedUInt64(int number, int index) const;
-  const float& GetRefRepeatedFloat(int number, int index) const;
-  const double& GetRefRepeatedDouble(int number, int index) const;
-  const bool& GetRefRepeatedBool(int number, int index) const;
-  const int& GetRefRepeatedEnum(int number, int index) const;
-
-  // Implementation of _InternalSerialize for non-empty map_.
-  uint8_t* _InternalSerializeImpl(const MessageLite* extendee,
-                                  int start_field_number, int end_field_number,
-                                  uint8_t* target,
-                                  io::EpsCopyOutputStream* stream) const;
-  // Interface of a lazily parsed singular message extension.
-  class PROTOBUF_EXPORT LazyMessageExtension {
-   public:
-    LazyMessageExtension() {}
-    virtual ~LazyMessageExtension() {}
-
-    virtual LazyMessageExtension* New(Arena* arena) const = 0;
-    virtual const MessageLite& GetMessage(const MessageLite& prototype,
-                                          Arena* arena) const = 0;
-    virtual MessageLite* MutableMessage(const MessageLite& prototype,
-                                        Arena* arena) = 0;
-    virtual void SetAllocatedMessage(MessageLite* message, Arena* arena) = 0;
-    virtual void UnsafeArenaSetAllocatedMessage(MessageLite* message,
-                                                Arena* arena) = 0;
-    PROTOBUF_NODISCARD virtual MessageLite* ReleaseMessage(
-        const MessageLite& prototype, Arena* arena) = 0;
-    virtual MessageLite* UnsafeArenaReleaseMessage(const MessageLite& prototype,
-                                                   Arena* arena) = 0;
-
-    virtual bool IsInitialized() const = 0;
-
-    PROTOBUF_DEPRECATED_MSG("Please use ByteSizeLong() instead")
-    virtual int ByteSize() const { return internal::ToIntSize(ByteSizeLong()); }
-    virtual size_t ByteSizeLong() const = 0;
-    virtual size_t SpaceUsedLong() const = 0;
-
-    virtual void MergeFrom(const MessageLite* prototype,
-                           const LazyMessageExtension& other, Arena* arena) = 0;
-    virtual void MergeFromMessage(const MessageLite& msg, Arena* arena) = 0;
-    virtual void Clear() = 0;
-
-    virtual const char* _InternalParse(const Message& prototype, Arena* arena,
-                                       LazyVerifyOption option, const char* ptr,
-                                       ParseContext* ctx) = 0;
-    virtual uint8_t* WriteMessageToArray(
-        const MessageLite* prototype, int number, uint8_t* target,
-        io::EpsCopyOutputStream* stream) const = 0;
-
-   private:
-    virtual void UnusedKeyMethod();  // Dummy key method to avoid weak vtable.
-
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LazyMessageExtension);
-  };
-  // Give access to function defined below to see LazyMessageExtension.
-  friend LazyMessageExtension* MaybeCreateLazyExtension(Arena* arena);
-  struct Extension {
-    // The order of these fields packs Extension into 24 bytes when using 8
-    // byte alignment. Consider this when adding or removing fields here.
-    union {
-      int32_t int32_t_value;
-      int64_t int64_t_value;
-      uint32_t uint32_t_value;
-      uint64_t uint64_t_value;
-      float float_value;
-      double double_value;
-      bool bool_value;
-      int enum_value;
-      std::string* string_value;
-      MessageLite* message_value;
-      LazyMessageExtension* lazymessage_value;
-
-      RepeatedField<int32_t>* repeated_int32_t_value;
-      RepeatedField<int64_t>* repeated_int64_t_value;
-      RepeatedField<uint32_t>* repeated_uint32_t_value;
-      RepeatedField<uint64_t>* repeated_uint64_t_value;
-      RepeatedField<float>* repeated_float_value;
-      RepeatedField<double>* repeated_double_value;
-      RepeatedField<bool>* repeated_bool_value;
-      RepeatedField<int>* repeated_enum_value;
-      RepeatedPtrField<std::string>* repeated_string_value;
-      RepeatedPtrField<MessageLite>* repeated_message_value;
-    };
-
-    FieldType type;
-    bool is_repeated;
-
-    // For singular types, indicates if the extension is "cleared".  This
-    // happens when an extension is set and then later cleared by the caller.
-    // We want to keep the Extension object around for reuse, so instead of
-    // removing it from the map, we just set is_cleared = true.  This has no
-    // meaning for repeated types; for those, the size of the RepeatedField
-    // simply becomes zero when cleared.
-    bool is_cleared : 4;
-
-    // For singular message types, indicates whether lazy parsing is enabled
-    // for this extension. This field is only valid when type == TYPE_MESSAGE
-    // and !is_repeated because we only support lazy parsing for singular
-    // message types currently. If is_lazy = true, the extension is stored in
-    // lazymessage_value. Otherwise, the extension will be message_value.
-    bool is_lazy : 4;
-
-    // For repeated types, this indicates if the [packed=true] option is set.
-    bool is_packed;
-
-    // For packed fields, the size of the packed data is recorded here when
-    // ByteSize() is called then used during serialization.
-    // TODO(kenton):  Use atomic<int> when C++ supports it.
-    mutable int cached_size;
-
-    // The descriptor for this extension, if one exists and is known.  May be
-    // nullptr.  Must not be nullptr if the descriptor for the extension does
-    // not live in the same pool as the descriptor for the containing type.
-    const FieldDescriptor* descriptor;
-
-    // Some helper methods for operations on a single Extension.
-    uint8_t* InternalSerializeFieldWithCachedSizesToArray(
-        const MessageLite* extendee, const ExtensionSet* extension_set,
-        int number, uint8_t* target, io::EpsCopyOutputStream* stream) const;
-    uint8_t* InternalSerializeMessageSetItemWithCachedSizesToArray(
-        const MessageLite* extendee, const ExtensionSet* extension_set,
-        int number, uint8_t* target, io::EpsCopyOutputStream* stream) const;
-    size_t ByteSize(int number) const;
-    size_t MessageSetItemByteSize(int number) const;
-    void Clear();
-    int GetSize() const;
-    void Free();
-    size_t SpaceUsedExcludingSelfLong() const;
-    bool IsInitialized() const;
-  };
-
-  // The Extension struct is small enough to be passed by value, so we use it
-  // directly as the value type in mappings rather than use pointers.  We use
-  // sorted maps rather than hash-maps because we expect most ExtensionSets will
-  // only contain a small number of extension.  Also, we want AppendToList and
-  // deterministic serialization to order fields by field number.
-
-  struct KeyValue {
-    int first;
-    Extension second;
-
-    struct FirstComparator {
-      bool operator()(const KeyValue& lhs, const KeyValue& rhs) const {
-        return lhs.first < rhs.first;
-      }
-      bool operator()(const KeyValue& lhs, int key) const {
-        return lhs.first < key;
-      }
-      bool operator()(int key, const KeyValue& rhs) const {
-        return key < rhs.first;
-      }
-    };
-  };
-
-  typedef std::map<int, Extension> LargeMap;
-
-  // Wrapper API that switches between flat-map and LargeMap.
-
-  // Finds a key (if present) in the ExtensionSet.
-  const Extension* FindOrNull(int key) const;
-  Extension* FindOrNull(int key);
-
-  // Helper-functions that only inspect the LargeMap.
-  const Extension* FindOrNullInLargeMap(int key) const;
-  Extension* FindOrNullInLargeMap(int key);
-
-  // Inserts a new (key, Extension) into the ExtensionSet (and returns true), or
-  // finds the already-existing Extension for that key (returns false).
-  // The Extension* will point to the new-or-found Extension.
-  std::pair<Extension*, bool> Insert(int key);
-
-  // Grows the flat_capacity_.
-  // If flat_capacity_ > kMaximumFlatCapacity, converts to LargeMap.
-  void GrowCapacity(size_t minimum_new_capacity);
-  static constexpr uint16_t kMaximumFlatCapacity = 256;
-  bool is_large() const { return static_cast<int16_t>(flat_size_) < 0; }
-
-  // Removes a key from the ExtensionSet.
-  void Erase(int key);
-
-  size_t Size() const {
-    return PROTOBUF_PREDICT_FALSE(is_large()) ? map_.large->size() : flat_size_;
-  }
-
-  // Similar to std::for_each.
-  // Each Iterator is decomposed into ->first and ->second fields, so
-  // that the KeyValueFunctor can be agnostic vis-a-vis KeyValue-vs-std::pair.
-  template <typename Iterator, typename KeyValueFunctor>
-  static KeyValueFunctor ForEach(Iterator begin, Iterator end,
-                                 KeyValueFunctor func) {
-    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
-    return std::move(func);
-  }
-
-  // Applies a functor to the <int, Extension&> pairs in sorted order.
-  template <typename KeyValueFunctor>
-  KeyValueFunctor ForEach(KeyValueFunctor func) {
-    if (PROTOBUF_PREDICT_FALSE(is_large())) {
-      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
-    }
-    return ForEach(flat_begin(), flat_end(), std::move(func));
-  }
-
-  // Applies a functor to the <int, const Extension&> pairs in sorted order.
-  template <typename KeyValueFunctor>
-  KeyValueFunctor ForEach(KeyValueFunctor func) const {
-    if (PROTOBUF_PREDICT_FALSE(is_large())) {
-      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
-    }
-    return ForEach(flat_begin(), flat_end(), std::move(func));
-  }
-
-  // Merges existing Extension from other_extension
-  void InternalExtensionMergeFrom(const MessageLite* extendee, int number,
-                                  const Extension& other_extension,
-                                  Arena* other_arena);
-
-  inline static bool is_packable(WireFormatLite::WireType type) {
-    switch (type) {
-      case WireFormatLite::WIRETYPE_VARINT:
-      case WireFormatLite::WIRETYPE_FIXED64:
-      case WireFormatLite::WIRETYPE_FIXED32:
-        return true;
-      case WireFormatLite::WIRETYPE_LENGTH_DELIMITED:
-      case WireFormatLite::WIRETYPE_START_GROUP:
-      case WireFormatLite::WIRETYPE_END_GROUP:
-        return false;
-
-        // Do not add a default statement. Let the compiler complain when
-        // someone
-        // adds a new wire type.
-    }
-    PROTOBUF_ASSUME(false);  // switch handles all possible enum values
-    return false;
-  }
-
-  // Returns true and fills field_number and extension if extension is found.
-  // Note to support packed repeated field compatibility, it also fills whether
-  // the tag on wire is packed, which can be different from
-  // extension->is_packed (whether packed=true is specified).
-  template <typename ExtensionFinder>
-  bool FindExtensionInfoFromTag(uint32_t tag, ExtensionFinder* extension_finder,
-                                int* field_number, ExtensionInfo* extension,
-                                bool* was_packed_on_wire) {
-    *field_number = WireFormatLite::GetTagFieldNumber(tag);
-    WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
-    return FindExtensionInfoFromFieldNumber(wire_type, *field_number,
-                                            extension_finder, extension,
-                                            was_packed_on_wire);
-  }
-
-  // Returns true and fills extension if extension is found.
-  // Note to support packed repeated field compatibility, it also fills whether
-  // the tag on wire is packed, which can be different from
-  // extension->is_packed (whether packed=true is specified).
-  template <typename ExtensionFinder>
-  bool FindExtensionInfoFromFieldNumber(int wire_type, int field_number,
-                                        ExtensionFinder* extension_finder,
-                                        ExtensionInfo* extension,
-                                        bool* was_packed_on_wire) const {
-    if (!extension_finder->Find(field_number, extension)) {
-      return false;
+                void RemoveLast(int number);
+                PROTOBUF_NODISCARD MessageLite* ReleaseLast(int number);
+                MessageLite* UnsafeArenaReleaseLast(int number);
+                void SwapElements(int number, int index1, int index2);
+
+                // =================================================================
+                // convenience methods for implementing methods of Message
+                //
+                // These could all be implemented in terms of the other methods of this
+                // class, but providing them here helps keep the generated code size down.
+
+                void Clear();
+                void MergeFrom(const MessageLite* extendee, const ExtensionSet& other);
+                void Swap(const MessageLite* extendee, ExtensionSet* other);
+                void InternalSwap(ExtensionSet* other);
+                void SwapExtension(const MessageLite* extendee, ExtensionSet* other, int number);
+                void UnsafeShallowSwapExtension(ExtensionSet* other, int number);
+                bool IsInitialized() const;
+
+                // Lite parser
+                const char* ParseField(uint64_t tag, const char* ptr, const MessageLite* extendee, internal::InternalMetadata* metadata, internal::ParseContext* ctx);
+                // Full parser
+                const char* ParseField(uint64_t tag, const char* ptr, const Message* extendee, internal::InternalMetadata* metadata, internal::ParseContext* ctx);
+                template<typename Msg>
+                const char* ParseMessageSet(const char* ptr, const Msg* extendee, InternalMetadata* metadata, internal::ParseContext* ctx)
+                {
+                    struct MessageSetItem
+                    {
+                        const char* _InternalParse(const char* ptr, ParseContext* ctx)
+                        {
+                            return me->ParseMessageSetItem(ptr, extendee, metadata, ctx);
+                        }
+                        ExtensionSet* me;
+                        const Msg* extendee;
+                        InternalMetadata* metadata;
+                    } item{this, extendee, metadata};
+                    while (!ctx->Done(&ptr))
+                    {
+                        uint32_t tag;
+                        ptr = ReadTag(ptr, &tag);
+                        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                        if (tag == WireFormatLite::kMessageSetItemStartTag)
+                        {
+                            ptr = ctx->ParseGroup(&item, ptr, tag);
+                            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                        }
+                        else
+                        {
+                            if (tag == 0 || (tag & 7) == 4)
+                            {
+                                ctx->SetLastTag(tag);
+                                return ptr;
+                            }
+                            ptr = ParseField(tag, ptr, extendee, metadata, ctx);
+                            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                        }
+                    }
+                    return ptr;
+                }
+
+                // Write all extension fields with field numbers in the range
+                //   [start_field_number, end_field_number)
+                // to the output stream, using the cached sizes computed when ByteSize() was
+                // last called.  Note that the range bounds are inclusive-exclusive.
+                void SerializeWithCachedSizes(const MessageLite* extendee, int start_field_number, int end_field_number, io::CodedOutputStream* output) const
+                {
+                    output->SetCur(_InternalSerialize(extendee, start_field_number, end_field_number, output->Cur(), output->EpsCopy()));
+                }
+
+                // Same as SerializeWithCachedSizes, but without any bounds checking.
+                // The caller must ensure that target has sufficient capacity for the
+                // serialized extensions.
+                //
+                // Returns a pointer past the last written byte.
+
+                uint8_t* _InternalSerialize(const MessageLite* extendee, int start_field_number, int end_field_number, uint8_t* target, io::EpsCopyOutputStream* stream) const
+                {
+                    if (flat_size_ == 0)
+                    {
+                        assert(!is_large());
+                        return target;
+                    }
+                    return _InternalSerializeImpl(extendee, start_field_number, end_field_number, target, stream);
+                }
+
+                // Like above but serializes in MessageSet format.
+                void SerializeMessageSetWithCachedSizes(const MessageLite* extendee, io::CodedOutputStream* output) const
+                {
+                    output->SetCur(InternalSerializeMessageSetWithCachedSizesToArray(
+                        extendee, output->Cur(), output->EpsCopy()
+                    ));
+                }
+                uint8_t* InternalSerializeMessageSetWithCachedSizesToArray(
+                    const MessageLite* extendee, uint8_t* target, io::EpsCopyOutputStream* stream
+                ) const;
+
+                // For backward-compatibility, versions of two of the above methods that
+                // serialize deterministically iff SetDefaultSerializationDeterministic()
+                // has been called.
+                uint8_t* SerializeWithCachedSizesToArray(int start_field_number, int end_field_number, uint8_t* target) const;
+                uint8_t* SerializeMessageSetWithCachedSizesToArray(
+                    const MessageLite* extendee, uint8_t* target
+                ) const;
+
+                // Returns the total serialized size of all the extensions.
+                size_t ByteSize() const;
+
+                // Like ByteSize() but uses MessageSet format.
+                size_t MessageSetByteSize() const;
+
+                // Returns (an estimate of) the total number of bytes used for storing the
+                // extensions in memory, excluding sizeof(*this).  If the ExtensionSet is
+                // for a lite message (and thus possibly contains lite messages), the results
+                // are undefined (might work, might crash, might corrupt data, might not even
+                // be linked in).  It's up to the protocol compiler to avoid calling this on
+                // such ExtensionSets (easy enough since lite messages don't implement
+                // SpaceUsed()).
+                size_t SpaceUsedExcludingSelfLong() const;
+
+                // This method just calls SpaceUsedExcludingSelfLong() but it can not be
+                // inlined because the definition of SpaceUsedExcludingSelfLong() is not
+                // included in lite runtime and when an inline method refers to it MSVC
+                // will complain about unresolved symbols when building the lite runtime
+                // as .dll.
+                int SpaceUsedExcludingSelf() const;
+
+            private:
+                template<typename Type>
+                friend class PrimitiveTypeTraits;
+
+                template<typename Type>
+                friend class RepeatedPrimitiveTypeTraits;
+
+                template<typename Type, bool IsValid(int)>
+                friend class EnumTypeTraits;
+
+                template<typename Type, bool IsValid(int)>
+                friend class RepeatedEnumTypeTraits;
+
+                friend class google::protobuf::Reflection;
+
+                const int32_t& GetRefInt32(int number, const int32_t& default_value) const;
+                const int64_t& GetRefInt64(int number, const int64_t& default_value) const;
+                const uint32_t& GetRefUInt32(int number, const uint32_t& default_value) const;
+                const uint64_t& GetRefUInt64(int number, const uint64_t& default_value) const;
+                const float& GetRefFloat(int number, const float& default_value) const;
+                const double& GetRefDouble(int number, const double& default_value) const;
+                const bool& GetRefBool(int number, const bool& default_value) const;
+                const int& GetRefEnum(int number, const int& default_value) const;
+                const int32_t& GetRefRepeatedInt32(int number, int index) const;
+                const int64_t& GetRefRepeatedInt64(int number, int index) const;
+                const uint32_t& GetRefRepeatedUInt32(int number, int index) const;
+                const uint64_t& GetRefRepeatedUInt64(int number, int index) const;
+                const float& GetRefRepeatedFloat(int number, int index) const;
+                const double& GetRefRepeatedDouble(int number, int index) const;
+                const bool& GetRefRepeatedBool(int number, int index) const;
+                const int& GetRefRepeatedEnum(int number, int index) const;
+
+                // Implementation of _InternalSerialize for non-empty map_.
+                uint8_t* _InternalSerializeImpl(const MessageLite* extendee, int start_field_number, int end_field_number, uint8_t* target, io::EpsCopyOutputStream* stream) const;
+                // Interface of a lazily parsed singular message extension.
+                class PROTOBUF_EXPORT LazyMessageExtension
+                {
+                public:
+                    LazyMessageExtension()
+                    {
+                    }
+                    virtual ~LazyMessageExtension()
+                    {
+                    }
+
+                    virtual LazyMessageExtension* New(Arena* arena) const = 0;
+                    virtual const MessageLite& GetMessage(const MessageLite& prototype, Arena* arena) const = 0;
+                    virtual MessageLite* MutableMessage(const MessageLite& prototype, Arena* arena) = 0;
+                    virtual void SetAllocatedMessage(MessageLite* message, Arena* arena) = 0;
+                    virtual void UnsafeArenaSetAllocatedMessage(MessageLite* message, Arena* arena) = 0;
+                    PROTOBUF_NODISCARD virtual MessageLite* ReleaseMessage(
+                        const MessageLite& prototype, Arena* arena
+                    ) = 0;
+                    virtual MessageLite* UnsafeArenaReleaseMessage(const MessageLite& prototype, Arena* arena) = 0;
+
+                    virtual bool IsInitialized() const = 0;
+
+                    PROTOBUF_DEPRECATED_MSG("Please use ByteSizeLong() instead")
+                    virtual int ByteSize() const
+                    {
+                        return internal::ToIntSize(ByteSizeLong());
+                    }
+                    virtual size_t ByteSizeLong() const = 0;
+                    virtual size_t SpaceUsedLong() const = 0;
+
+                    virtual void MergeFrom(const MessageLite* prototype, const LazyMessageExtension& other, Arena* arena) = 0;
+                    virtual void MergeFromMessage(const MessageLite& msg, Arena* arena) = 0;
+                    virtual void Clear() = 0;
+
+                    virtual const char* _InternalParse(const Message& prototype, Arena* arena, LazyVerifyOption option, const char* ptr, ParseContext* ctx) = 0;
+                    virtual uint8_t* WriteMessageToArray(
+                        const MessageLite* prototype, int number, uint8_t* target, io::EpsCopyOutputStream* stream
+                    ) const = 0;
+
+                private:
+                    virtual void UnusedKeyMethod();  // Dummy key method to avoid weak vtable.
+
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LazyMessageExtension);
+                };
+                // Give access to function defined below to see LazyMessageExtension.
+                friend LazyMessageExtension* MaybeCreateLazyExtension(Arena* arena);
+                struct Extension
+                {
+                    // The order of these fields packs Extension into 24 bytes when using 8
+                    // byte alignment. Consider this when adding or removing fields here.
+                    union
+                    {
+                        int32_t int32_t_value;
+                        int64_t int64_t_value;
+                        uint32_t uint32_t_value;
+                        uint64_t uint64_t_value;
+                        float float_value;
+                        double double_value;
+                        bool bool_value;
+                        int enum_value;
+                        std::string* string_value;
+                        MessageLite* message_value;
+                        LazyMessageExtension* lazymessage_value;
+
+                        RepeatedField<int32_t>* repeated_int32_t_value;
+                        RepeatedField<int64_t>* repeated_int64_t_value;
+                        RepeatedField<uint32_t>* repeated_uint32_t_value;
+                        RepeatedField<uint64_t>* repeated_uint64_t_value;
+                        RepeatedField<float>* repeated_float_value;
+                        RepeatedField<double>* repeated_double_value;
+                        RepeatedField<bool>* repeated_bool_value;
+                        RepeatedField<int>* repeated_enum_value;
+                        RepeatedPtrField<std::string>* repeated_string_value;
+                        RepeatedPtrField<MessageLite>* repeated_message_value;
+                    };
+
+                    FieldType type;
+                    bool is_repeated;
+
+                    // For singular types, indicates if the extension is "cleared".  This
+                    // happens when an extension is set and then later cleared by the caller.
+                    // We want to keep the Extension object around for reuse, so instead of
+                    // removing it from the map, we just set is_cleared = true.  This has no
+                    // meaning for repeated types; for those, the size of the RepeatedField
+                    // simply becomes zero when cleared.
+                    bool is_cleared : 4;
+
+                    // For singular message types, indicates whether lazy parsing is enabled
+                    // for this extension. This field is only valid when type == TYPE_MESSAGE
+                    // and !is_repeated because we only support lazy parsing for singular
+                    // message types currently. If is_lazy = true, the extension is stored in
+                    // lazymessage_value. Otherwise, the extension will be message_value.
+                    bool is_lazy : 4;
+
+                    // For repeated types, this indicates if the [packed=true] option is set.
+                    bool is_packed;
+
+                    // For packed fields, the size of the packed data is recorded here when
+                    // ByteSize() is called then used during serialization.
+                    // TODO(kenton):  Use atomic<int> when C++ supports it.
+                    mutable int cached_size;
+
+                    // The descriptor for this extension, if one exists and is known.  May be
+                    // nullptr.  Must not be nullptr if the descriptor for the extension does
+                    // not live in the same pool as the descriptor for the containing type.
+                    const FieldDescriptor* descriptor;
+
+                    // Some helper methods for operations on a single Extension.
+                    uint8_t* InternalSerializeFieldWithCachedSizesToArray(
+                        const MessageLite* extendee, const ExtensionSet* extension_set, int number, uint8_t* target, io::EpsCopyOutputStream* stream
+                    ) const;
+                    uint8_t* InternalSerializeMessageSetItemWithCachedSizesToArray(
+                        const MessageLite* extendee, const ExtensionSet* extension_set, int number, uint8_t* target, io::EpsCopyOutputStream* stream
+                    ) const;
+                    size_t ByteSize(int number) const;
+                    size_t MessageSetItemByteSize(int number) const;
+                    void Clear();
+                    int GetSize() const;
+                    void Free();
+                    size_t SpaceUsedExcludingSelfLong() const;
+                    bool IsInitialized() const;
+                };
+
+                // The Extension struct is small enough to be passed by value, so we use it
+                // directly as the value type in mappings rather than use pointers.  We use
+                // sorted maps rather than hash-maps because we expect most ExtensionSets will
+                // only contain a small number of extension.  Also, we want AppendToList and
+                // deterministic serialization to order fields by field number.
+
+                struct KeyValue
+                {
+                    int first;
+                    Extension second;
+
+                    struct FirstComparator
+                    {
+                        bool operator()(const KeyValue& lhs, const KeyValue& rhs) const
+                        {
+                            return lhs.first < rhs.first;
+                        }
+                        bool operator()(const KeyValue& lhs, int key) const
+                        {
+                            return lhs.first < key;
+                        }
+                        bool operator()(int key, const KeyValue& rhs) const
+                        {
+                            return key < rhs.first;
+                        }
+                    };
+                };
+
+                typedef std::map<int, Extension> LargeMap;
+
+                // Wrapper API that switches between flat-map and LargeMap.
+
+                // Finds a key (if present) in the ExtensionSet.
+                const Extension* FindOrNull(int key) const;
+                Extension* FindOrNull(int key);
+
+                // Helper-functions that only inspect the LargeMap.
+                const Extension* FindOrNullInLargeMap(int key) const;
+                Extension* FindOrNullInLargeMap(int key);
+
+                // Inserts a new (key, Extension) into the ExtensionSet (and returns true), or
+                // finds the already-existing Extension for that key (returns false).
+                // The Extension* will point to the new-or-found Extension.
+                std::pair<Extension*, bool> Insert(int key);
+
+                // Grows the flat_capacity_.
+                // If flat_capacity_ > kMaximumFlatCapacity, converts to LargeMap.
+                void GrowCapacity(size_t minimum_new_capacity);
+                static constexpr uint16_t kMaximumFlatCapacity = 256;
+                bool is_large() const
+                {
+                    return static_cast<int16_t>(flat_size_) < 0;
+                }
+
+                // Removes a key from the ExtensionSet.
+                void Erase(int key);
+
+                size_t Size() const
+                {
+                    return PROTOBUF_PREDICT_FALSE(is_large()) ? map_.large->size() : flat_size_;
+                }
+
+                // Similar to std::for_each.
+                // Each Iterator is decomposed into ->first and ->second fields, so
+                // that the KeyValueFunctor can be agnostic vis-a-vis KeyValue-vs-std::pair.
+                template<typename Iterator, typename KeyValueFunctor>
+                static KeyValueFunctor ForEach(Iterator begin, Iterator end, KeyValueFunctor func)
+                {
+                    for (Iterator it = begin; it != end; ++it)
+                        func(it->first, it->second);
+                    return std::move(func);
+                }
+
+                // Applies a functor to the <int, Extension&> pairs in sorted order.
+                template<typename KeyValueFunctor>
+                KeyValueFunctor ForEach(KeyValueFunctor func)
+                {
+                    if (PROTOBUF_PREDICT_FALSE(is_large()))
+                    {
+                        return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
+                    }
+                    return ForEach(flat_begin(), flat_end(), std::move(func));
+                }
+
+                // Applies a functor to the <int, const Extension&> pairs in sorted order.
+                template<typename KeyValueFunctor>
+                KeyValueFunctor ForEach(KeyValueFunctor func) const
+                {
+                    if (PROTOBUF_PREDICT_FALSE(is_large()))
+                    {
+                        return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
+                    }
+                    return ForEach(flat_begin(), flat_end(), std::move(func));
+                }
+
+                // Merges existing Extension from other_extension
+                void InternalExtensionMergeFrom(const MessageLite* extendee, int number, const Extension& other_extension, Arena* other_arena);
+
+                inline static bool is_packable(WireFormatLite::WireType type)
+                {
+                    switch (type)
+                    {
+                        case WireFormatLite::WIRETYPE_VARINT:
+                        case WireFormatLite::WIRETYPE_FIXED64:
+                        case WireFormatLite::WIRETYPE_FIXED32:
+                            return true;
+                        case WireFormatLite::WIRETYPE_LENGTH_DELIMITED:
+                        case WireFormatLite::WIRETYPE_START_GROUP:
+                        case WireFormatLite::WIRETYPE_END_GROUP:
+                            return false;
+
+                            // Do not add a default statement. Let the compiler complain when
+                            // someone
+                            // adds a new wire type.
+                    }
+                    PROTOBUF_ASSUME(false);  // switch handles all possible enum values
+                    return false;
+                }
+
+                // Returns true and fills field_number and extension if extension is found.
+                // Note to support packed repeated field compatibility, it also fills whether
+                // the tag on wire is packed, which can be different from
+                // extension->is_packed (whether packed=true is specified).
+                template<typename ExtensionFinder>
+                bool FindExtensionInfoFromTag(uint32_t tag, ExtensionFinder* extension_finder, int* field_number, ExtensionInfo* extension, bool* was_packed_on_wire)
+                {
+                    *field_number = WireFormatLite::GetTagFieldNumber(tag);
+                    WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
+                    return FindExtensionInfoFromFieldNumber(wire_type, *field_number, extension_finder, extension, was_packed_on_wire);
+                }
+
+                // Returns true and fills extension if extension is found.
+                // Note to support packed repeated field compatibility, it also fills whether
+                // the tag on wire is packed, which can be different from
+                // extension->is_packed (whether packed=true is specified).
+                template<typename ExtensionFinder>
+                bool FindExtensionInfoFromFieldNumber(int wire_type, int field_number, ExtensionFinder* extension_finder, ExtensionInfo* extension, bool* was_packed_on_wire) const
+                {
+                    if (!extension_finder->Find(field_number, extension))
+                    {
+                        return false;
+                    }
+
+                    GOOGLE_DCHECK(extension->type > 0 && extension->type <= WireFormatLite::MAX_FIELD_TYPE);
+                    auto real_type = static_cast<WireFormatLite::FieldType>(extension->type);
+
+                    WireFormatLite::WireType expected_wire_type =
+                        WireFormatLite::WireTypeForFieldType(real_type);
+
+                    // Check if this is a packed field.
+                    *was_packed_on_wire = false;
+                    if (extension->is_repeated &&
+                        wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED &&
+                        is_packable(expected_wire_type))
+                    {
+                        *was_packed_on_wire = true;
+                        return true;
+                    }
+                    // Otherwise the wire type must match.
+                    return expected_wire_type == wire_type;
+                }
+
+                // Find the prototype for a LazyMessage from the extension registry. Returns
+                // null if the extension is not found.
+                const MessageLite* GetPrototypeForLazyMessage(const MessageLite* extendee, int number) const;
+
+                // Returns true if extension is present and lazy.
+                bool HasLazy(int number) const;
+
+                // Gets the extension with the given number, creating it if it does not
+                // already exist.  Returns true if the extension did not already exist.
+                bool MaybeNewExtension(int number, const FieldDescriptor* descriptor, Extension** result);
+
+                // Gets the repeated extension for the given descriptor, creating it if
+                // it does not exist.
+                Extension* MaybeNewRepeatedExtension(const FieldDescriptor* descriptor);
+
+                bool FindExtension(int wire_type, uint32_t field, const MessageLite* extendee, const internal::ParseContext* /*ctx*/, ExtensionInfo* extension, bool* was_packed_on_wire)
+                {
+                    GeneratedExtensionFinder finder(extendee);
+                    return FindExtensionInfoFromFieldNumber(wire_type, field, &finder, extension, was_packed_on_wire);
+                }
+                inline bool FindExtension(int wire_type, uint32_t field, const Message* extendee, const internal::ParseContext* ctx, ExtensionInfo* extension, bool* was_packed_on_wire);
+                // Used for MessageSet only
+                const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr, const MessageLite* extendee, internal::InternalMetadata* metadata, internal::ParseContext* ctx)
+                {
+                    // Lite MessageSet doesn't implement lazy.
+                    return ParseField(tag, ptr, extendee, metadata, ctx);
+                }
+                const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr, const Message* extendee, internal::InternalMetadata* metadata, internal::ParseContext* ctx);
+                const char* ParseMessageSetItem(const char* ptr, const MessageLite* extendee, internal::InternalMetadata* metadata, internal::ParseContext* ctx);
+                const char* ParseMessageSetItem(const char* ptr, const Message* extendee, internal::InternalMetadata* metadata, internal::ParseContext* ctx);
+
+                // Implemented in extension_set_inl.h to keep code out of the header file.
+                template<typename T>
+                const char* ParseFieldWithExtensionInfo(int number, bool was_packed_on_wire, const ExtensionInfo& info, internal::InternalMetadata* metadata, const char* ptr, internal::ParseContext* ctx);
+                template<typename Msg, typename T>
+                const char* ParseMessageSetItemTmpl(const char* ptr, const Msg* extendee, internal::InternalMetadata* metadata, internal::ParseContext* ctx);
+
+                // Hack:  RepeatedPtrFieldBase declares ExtensionSet as a friend.  This
+                //   friendship should automatically extend to ExtensionSet::Extension, but
+                //   unfortunately some older compilers (e.g. GCC 3.4.4) do not implement this
+                //   correctly.  So, we must provide helpers for calling methods of that
+                //   class.
+
+                // Defined in extension_set_heavy.cc.
+                static inline size_t RepeatedMessage_SpaceUsedExcludingSelfLong(
+                    RepeatedPtrFieldBase* field
+                );
+
+                KeyValue* flat_begin()
+                {
+                    assert(!is_large());
+                    return map_.flat;
+                }
+                const KeyValue* flat_begin() const
+                {
+                    assert(!is_large());
+                    return map_.flat;
+                }
+                KeyValue* flat_end()
+                {
+                    assert(!is_large());
+                    return map_.flat + flat_size_;
+                }
+                const KeyValue* flat_end() const
+                {
+                    assert(!is_large());
+                    return map_.flat + flat_size_;
+                }
+
+                Arena* arena_;
+
+                // Manual memory-management:
+                // map_.flat is an allocated array of flat_capacity_ elements.
+                // [map_.flat, map_.flat + flat_size_) is the currently-in-use prefix.
+                uint16_t flat_capacity_;
+                uint16_t flat_size_;  // negative int16_t(flat_size_) indicates is_large()
+                union AllocatedData
+                {
+                    KeyValue* flat;
+
+                    // If flat_capacity_ > kMaximumFlatCapacity, switch to LargeMap,
+                    // which guarantees O(n lg n) CPU but larger constant factors.
+                    LargeMap* large;
+                } map_;
+
+                static void DeleteFlatMap(const KeyValue* flat, uint16_t flat_capacity);
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ExtensionSet);
+            };
+
+            constexpr ExtensionSet::ExtensionSet() :
+                arena_(nullptr),
+                flat_capacity_(0),
+                flat_size_(0),
+                map_{nullptr}
+            {
+            }
+
+            // These are just for convenience...
+            inline void ExtensionSet::SetString(int number, FieldType type, std::string value, const FieldDescriptor* descriptor)
+            {
+                MutableString(number, type, descriptor)->assign(std::move(value));
+            }
+            inline void ExtensionSet::SetRepeatedString(int number, int index, std::string value)
+            {
+                MutableRepeatedString(number, index)->assign(std::move(value));
+            }
+            inline void ExtensionSet::AddString(int number, FieldType type, std::string value, const FieldDescriptor* descriptor)
+            {
+                AddString(number, type, descriptor)->assign(std::move(value));
+            }
+            // ===================================================================
+            // Glue for generated extension accessors
+
+            // -------------------------------------------------------------------
+            // Template magic
+
+            // First we have a set of classes representing "type traits" for different
+            // field types.  A type traits class knows how to implement basic accessors
+            // for extensions of a particular type given an ExtensionSet.  The signature
+            // for a type traits class looks like this:
+            //
+            //   class TypeTraits {
+            //    public:
+            //     typedef ? ConstType;
+            //     typedef ? MutableType;
+            //     // TypeTraits for singular fields and repeated fields will define the
+            //     // symbol "Singular" or "Repeated" respectively. These two symbols will
+            //     // be used in extension accessors to distinguish between singular
+            //     // extensions and repeated extensions. If the TypeTraits for the passed
+            //     // in extension doesn't have the expected symbol defined, it means the
+            //     // user is passing a repeated extension to a singular accessor, or the
+            //     // opposite. In that case the C++ compiler will generate an error
+            //     // message "no matching member function" to inform the user.
+            //     typedef ? Singular
+            //     typedef ? Repeated
+            //
+            //     static inline ConstType Get(int number, const ExtensionSet& set);
+            //     static inline void Set(int number, ConstType value, ExtensionSet* set);
+            //     static inline MutableType Mutable(int number, ExtensionSet* set);
+            //
+            //     // Variants for repeated fields.
+            //     static inline ConstType Get(int number, const ExtensionSet& set,
+            //                                 int index);
+            //     static inline void Set(int number, int index,
+            //                            ConstType value, ExtensionSet* set);
+            //     static inline MutableType Mutable(int number, int index,
+            //                                       ExtensionSet* set);
+            //     static inline void Add(int number, ConstType value, ExtensionSet* set);
+            //     static inline MutableType Add(int number, ExtensionSet* set);
+            //     This is used by the ExtensionIdentifier constructor to register
+            //     the extension at dynamic initialization.
+            //     template <typename ExtendeeT>
+            //     static void Register(int number, FieldType type, bool is_packed);
+            //   };
+            //
+            // Not all of these methods make sense for all field types.  For example, the
+            // "Mutable" methods only make sense for strings and messages, and the
+            // repeated methods only make sense for repeated types.  So, each type
+            // traits class implements only the set of methods from this signature that it
+            // actually supports.  This will cause a compiler error if the user tries to
+            // access an extension using a method that doesn't make sense for its type.
+            // For example, if "foo" is an extension of type "optional int32", then if you
+            // try to write code like:
+            //   my_message.MutableExtension(foo)
+            // you will get a compile error because PrimitiveTypeTraits<int32_t> does not
+            // have a "Mutable()" method.
+
+            // -------------------------------------------------------------------
+            // PrimitiveTypeTraits
+
+            // Since the ExtensionSet has different methods for each primitive type,
+            // we must explicitly define the methods of the type traits class for each
+            // known type.
+            template<typename Type>
+            class PrimitiveTypeTraits
+            {
+            public:
+                typedef Type ConstType;
+                typedef Type MutableType;
+                typedef PrimitiveTypeTraits<Type> Singular;
+
+                static inline ConstType Get(int number, const ExtensionSet& set, ConstType default_value);
+
+                static inline const ConstType* GetPtr(int number, const ExtensionSet& set, const ConstType& default_value);
+                static inline void Set(int number, FieldType field_type, ConstType value, ExtensionSet* set);
+                template<typename ExtendeeT>
+                static void Register(int number, FieldType type, bool is_packed, LazyEagerVerifyFnType verify_func)
+                {
+                    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number, type, false, is_packed, verify_func);
+                }
+            };
+
+            template<typename Type>
+            class RepeatedPrimitiveTypeTraits
+            {
+            public:
+                typedef Type ConstType;
+                typedef Type MutableType;
+                typedef RepeatedPrimitiveTypeTraits<Type> Repeated;
+
+                typedef RepeatedField<Type> RepeatedFieldType;
+
+                static inline Type Get(int number, const ExtensionSet& set, int index);
+                static inline const Type* GetPtr(int number, const ExtensionSet& set, int index);
+                static inline const RepeatedField<ConstType>* GetRepeatedPtr(
+                    int number, const ExtensionSet& set
+                );
+                static inline void Set(int number, int index, Type value, ExtensionSet* set);
+                static inline void Add(int number, FieldType field_type, bool is_packed, Type value, ExtensionSet* set);
+
+                static inline const RepeatedField<ConstType>& GetRepeated(
+                    int number, const ExtensionSet& set
+                );
+                static inline RepeatedField<Type>* MutableRepeated(int number, FieldType field_type, bool is_packed, ExtensionSet* set);
+
+                static const RepeatedFieldType* GetDefaultRepeatedField();
+                template<typename ExtendeeT>
+                static void Register(int number, FieldType type, bool is_packed, LazyEagerVerifyFnType verify_func)
+                {
+                    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number, type, true, is_packed, verify_func);
+                }
+            };
+
+            class PROTOBUF_EXPORT RepeatedPrimitiveDefaults
+            {
+            private:
+                template<typename Type>
+                friend class RepeatedPrimitiveTypeTraits;
+                static const RepeatedPrimitiveDefaults* default_instance();
+                RepeatedField<int32_t> default_repeated_field_int32_t_;
+                RepeatedField<int64_t> default_repeated_field_int64_t_;
+                RepeatedField<uint32_t> default_repeated_field_uint32_t_;
+                RepeatedField<uint64_t> default_repeated_field_uint64_t_;
+                RepeatedField<double> default_repeated_field_double_;
+                RepeatedField<float> default_repeated_field_float_;
+                RepeatedField<bool> default_repeated_field_bool_;
+            };
+
+#define PROTOBUF_DEFINE_PRIMITIVE_TYPE(TYPE, METHOD)                                                            \
+    template<>                                                                                                  \
+    inline TYPE PrimitiveTypeTraits<TYPE>::Get(                                                                 \
+        int number, const ExtensionSet& set, TYPE default_value                                                 \
+    )                                                                                                           \
+    {                                                                                                           \
+        return set.Get##METHOD(number, default_value);                                                          \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline const TYPE* PrimitiveTypeTraits<TYPE>::GetPtr(                                                       \
+        int number, const ExtensionSet& set, const TYPE& default_value                                          \
+    )                                                                                                           \
+    {                                                                                                           \
+        return &set.GetRef##METHOD(number, default_value);                                                      \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline void PrimitiveTypeTraits<TYPE>::Set(int number, FieldType field_type, TYPE value, ExtensionSet* set) \
+    {                                                                                                           \
+        set->Set##METHOD(number, field_type, value, nullptr);                                                   \
+    }                                                                                                           \
+                                                                                                                \
+    template<>                                                                                                  \
+    inline TYPE RepeatedPrimitiveTypeTraits<TYPE>::Get(                                                         \
+        int number, const ExtensionSet& set, int index                                                          \
+    )                                                                                                           \
+    {                                                                                                           \
+        return set.GetRepeated##METHOD(number, index);                                                          \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline const TYPE* RepeatedPrimitiveTypeTraits<TYPE>::GetPtr(                                               \
+        int number, const ExtensionSet& set, int index                                                          \
+    )                                                                                                           \
+    {                                                                                                           \
+        return &set.GetRefRepeated##METHOD(number, index);                                                      \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline void RepeatedPrimitiveTypeTraits<TYPE>::Set(                                                         \
+        int number, int index, TYPE value, ExtensionSet* set                                                    \
+    )                                                                                                           \
+    {                                                                                                           \
+        set->SetRepeated##METHOD(number, index, value);                                                         \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline void RepeatedPrimitiveTypeTraits<TYPE>::Add(                                                         \
+        int number, FieldType field_type, bool is_packed, TYPE value, ExtensionSet* set                         \
+    )                                                                                                           \
+    {                                                                                                           \
+        set->Add##METHOD(number, field_type, is_packed, value, nullptr);                                        \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline const RepeatedField<TYPE>*                                                                           \
+        RepeatedPrimitiveTypeTraits<TYPE>::GetDefaultRepeatedField()                                            \
+    {                                                                                                           \
+        return &RepeatedPrimitiveDefaults::default_instance()                                                   \
+                    ->default_repeated_field_##TYPE##_;                                                         \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline const RepeatedField<TYPE>&                                                                           \
+        RepeatedPrimitiveTypeTraits<TYPE>::GetRepeated(int number, const ExtensionSet& set)                     \
+    {                                                                                                           \
+        return *reinterpret_cast<const RepeatedField<TYPE>*>(                                                   \
+            set.GetRawRepeatedField(number, GetDefaultRepeatedField())                                          \
+        );                                                                                                      \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline const RepeatedField<TYPE>*                                                                           \
+        RepeatedPrimitiveTypeTraits<TYPE>::GetRepeatedPtr(int number, const ExtensionSet& set)                  \
+    {                                                                                                           \
+        return &GetRepeated(number, set);                                                                       \
+    }                                                                                                           \
+    template<>                                                                                                  \
+    inline RepeatedField<TYPE>*                                                                                 \
+        RepeatedPrimitiveTypeTraits<TYPE>::MutableRepeated(                                                     \
+            int number, FieldType field_type, bool is_packed, ExtensionSet* set                                 \
+        )                                                                                                       \
+    {                                                                                                           \
+        return reinterpret_cast<RepeatedField<TYPE>*>(                                                          \
+            set->MutableRawRepeatedField(number, field_type, is_packed, nullptr)                                \
+        );                                                                                                      \
     }
 
-    GOOGLE_DCHECK(extension->type > 0 &&
-           extension->type <= WireFormatLite::MAX_FIELD_TYPE);
-    auto real_type = static_cast<WireFormatLite::FieldType>(extension->type);
-
-    WireFormatLite::WireType expected_wire_type =
-        WireFormatLite::WireTypeForFieldType(real_type);
-
-    // Check if this is a packed field.
-    *was_packed_on_wire = false;
-    if (extension->is_repeated &&
-        wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED &&
-        is_packable(expected_wire_type)) {
-      *was_packed_on_wire = true;
-      return true;
-    }
-    // Otherwise the wire type must match.
-    return expected_wire_type == wire_type;
-  }
-
-  // Find the prototype for a LazyMessage from the extension registry. Returns
-  // null if the extension is not found.
-  const MessageLite* GetPrototypeForLazyMessage(const MessageLite* extendee,
-                                                int number) const;
-
-  // Returns true if extension is present and lazy.
-  bool HasLazy(int number) const;
-
-  // Gets the extension with the given number, creating it if it does not
-  // already exist.  Returns true if the extension did not already exist.
-  bool MaybeNewExtension(int number, const FieldDescriptor* descriptor,
-                         Extension** result);
-
-  // Gets the repeated extension for the given descriptor, creating it if
-  // it does not exist.
-  Extension* MaybeNewRepeatedExtension(const FieldDescriptor* descriptor);
-
-  bool FindExtension(int wire_type, uint32_t field, const MessageLite* extendee,
-                     const internal::ParseContext* /*ctx*/,
-                     ExtensionInfo* extension, bool* was_packed_on_wire) {
-    GeneratedExtensionFinder finder(extendee);
-    return FindExtensionInfoFromFieldNumber(wire_type, field, &finder,
-                                            extension, was_packed_on_wire);
-  }
-  inline bool FindExtension(int wire_type, uint32_t field,
-                            const Message* extendee,
-                            const internal::ParseContext* ctx,
-                            ExtensionInfo* extension, bool* was_packed_on_wire);
-  // Used for MessageSet only
-  const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr,
-                                    const MessageLite* extendee,
-                                    internal::InternalMetadata* metadata,
-                                    internal::ParseContext* ctx) {
-    // Lite MessageSet doesn't implement lazy.
-    return ParseField(tag, ptr, extendee, metadata, ctx);
-  }
-  const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr,
-                                    const Message* extendee,
-                                    internal::InternalMetadata* metadata,
-                                    internal::ParseContext* ctx);
-  const char* ParseMessageSetItem(const char* ptr, const MessageLite* extendee,
-                                  internal::InternalMetadata* metadata,
-                                  internal::ParseContext* ctx);
-  const char* ParseMessageSetItem(const char* ptr, const Message* extendee,
-                                  internal::InternalMetadata* metadata,
-                                  internal::ParseContext* ctx);
-
-  // Implemented in extension_set_inl.h to keep code out of the header file.
-  template <typename T>
-  const char* ParseFieldWithExtensionInfo(int number, bool was_packed_on_wire,
-                                          const ExtensionInfo& info,
-                                          internal::InternalMetadata* metadata,
-                                          const char* ptr,
-                                          internal::ParseContext* ctx);
-  template <typename Msg, typename T>
-  const char* ParseMessageSetItemTmpl(const char* ptr, const Msg* extendee,
-                                      internal::InternalMetadata* metadata,
-                                      internal::ParseContext* ctx);
-
-  // Hack:  RepeatedPtrFieldBase declares ExtensionSet as a friend.  This
-  //   friendship should automatically extend to ExtensionSet::Extension, but
-  //   unfortunately some older compilers (e.g. GCC 3.4.4) do not implement this
-  //   correctly.  So, we must provide helpers for calling methods of that
-  //   class.
-
-  // Defined in extension_set_heavy.cc.
-  static inline size_t RepeatedMessage_SpaceUsedExcludingSelfLong(
-      RepeatedPtrFieldBase* field);
-
-  KeyValue* flat_begin() {
-    assert(!is_large());
-    return map_.flat;
-  }
-  const KeyValue* flat_begin() const {
-    assert(!is_large());
-    return map_.flat;
-  }
-  KeyValue* flat_end() {
-    assert(!is_large());
-    return map_.flat + flat_size_;
-  }
-  const KeyValue* flat_end() const {
-    assert(!is_large());
-    return map_.flat + flat_size_;
-  }
-
-  Arena* arena_;
-
-  // Manual memory-management:
-  // map_.flat is an allocated array of flat_capacity_ elements.
-  // [map_.flat, map_.flat + flat_size_) is the currently-in-use prefix.
-  uint16_t flat_capacity_;
-  uint16_t flat_size_;  // negative int16_t(flat_size_) indicates is_large()
-  union AllocatedData {
-    KeyValue* flat;
-
-    // If flat_capacity_ > kMaximumFlatCapacity, switch to LargeMap,
-    // which guarantees O(n lg n) CPU but larger constant factors.
-    LargeMap* large;
-  } map_;
-
-  static void DeleteFlatMap(const KeyValue* flat, uint16_t flat_capacity);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ExtensionSet);
-};
-
-constexpr ExtensionSet::ExtensionSet()
-    : arena_(nullptr), flat_capacity_(0), flat_size_(0), map_{nullptr} {}
-
-// These are just for convenience...
-inline void ExtensionSet::SetString(int number, FieldType type,
-                                    std::string value,
-                                    const FieldDescriptor* descriptor) {
-  MutableString(number, type, descriptor)->assign(std::move(value));
-}
-inline void ExtensionSet::SetRepeatedString(int number, int index,
-                                            std::string value) {
-  MutableRepeatedString(number, index)->assign(std::move(value));
-}
-inline void ExtensionSet::AddString(int number, FieldType type,
-                                    std::string value,
-                                    const FieldDescriptor* descriptor) {
-  AddString(number, type, descriptor)->assign(std::move(value));
-}
-// ===================================================================
-// Glue for generated extension accessors
-
-// -------------------------------------------------------------------
-// Template magic
-
-// First we have a set of classes representing "type traits" for different
-// field types.  A type traits class knows how to implement basic accessors
-// for extensions of a particular type given an ExtensionSet.  The signature
-// for a type traits class looks like this:
-//
-//   class TypeTraits {
-//    public:
-//     typedef ? ConstType;
-//     typedef ? MutableType;
-//     // TypeTraits for singular fields and repeated fields will define the
-//     // symbol "Singular" or "Repeated" respectively. These two symbols will
-//     // be used in extension accessors to distinguish between singular
-//     // extensions and repeated extensions. If the TypeTraits for the passed
-//     // in extension doesn't have the expected symbol defined, it means the
-//     // user is passing a repeated extension to a singular accessor, or the
-//     // opposite. In that case the C++ compiler will generate an error
-//     // message "no matching member function" to inform the user.
-//     typedef ? Singular
-//     typedef ? Repeated
-//
-//     static inline ConstType Get(int number, const ExtensionSet& set);
-//     static inline void Set(int number, ConstType value, ExtensionSet* set);
-//     static inline MutableType Mutable(int number, ExtensionSet* set);
-//
-//     // Variants for repeated fields.
-//     static inline ConstType Get(int number, const ExtensionSet& set,
-//                                 int index);
-//     static inline void Set(int number, int index,
-//                            ConstType value, ExtensionSet* set);
-//     static inline MutableType Mutable(int number, int index,
-//                                       ExtensionSet* set);
-//     static inline void Add(int number, ConstType value, ExtensionSet* set);
-//     static inline MutableType Add(int number, ExtensionSet* set);
-//     This is used by the ExtensionIdentifier constructor to register
-//     the extension at dynamic initialization.
-//     template <typename ExtendeeT>
-//     static void Register(int number, FieldType type, bool is_packed);
-//   };
-//
-// Not all of these methods make sense for all field types.  For example, the
-// "Mutable" methods only make sense for strings and messages, and the
-// repeated methods only make sense for repeated types.  So, each type
-// traits class implements only the set of methods from this signature that it
-// actually supports.  This will cause a compiler error if the user tries to
-// access an extension using a method that doesn't make sense for its type.
-// For example, if "foo" is an extension of type "optional int32", then if you
-// try to write code like:
-//   my_message.MutableExtension(foo)
-// you will get a compile error because PrimitiveTypeTraits<int32_t> does not
-// have a "Mutable()" method.
-
-// -------------------------------------------------------------------
-// PrimitiveTypeTraits
-
-// Since the ExtensionSet has different methods for each primitive type,
-// we must explicitly define the methods of the type traits class for each
-// known type.
-template <typename Type>
-class PrimitiveTypeTraits {
- public:
-  typedef Type ConstType;
-  typedef Type MutableType;
-  typedef PrimitiveTypeTraits<Type> Singular;
-
-  static inline ConstType Get(int number, const ExtensionSet& set,
-                              ConstType default_value);
-
-  static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
-                                        const ConstType& default_value);
-  static inline void Set(int number, FieldType field_type, ConstType value,
-                         ExtensionSet* set);
-  template <typename ExtendeeT>
-  static void Register(int number, FieldType type, bool is_packed,
-                       LazyEagerVerifyFnType verify_func) {
-    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
-                                    type, false, is_packed, verify_func);
-  }
-};
-
-template <typename Type>
-class RepeatedPrimitiveTypeTraits {
- public:
-  typedef Type ConstType;
-  typedef Type MutableType;
-  typedef RepeatedPrimitiveTypeTraits<Type> Repeated;
-
-  typedef RepeatedField<Type> RepeatedFieldType;
-
-  static inline Type Get(int number, const ExtensionSet& set, int index);
-  static inline const Type* GetPtr(int number, const ExtensionSet& set,
-                                   int index);
-  static inline const RepeatedField<ConstType>* GetRepeatedPtr(
-      int number, const ExtensionSet& set);
-  static inline void Set(int number, int index, Type value, ExtensionSet* set);
-  static inline void Add(int number, FieldType field_type, bool is_packed,
-                         Type value, ExtensionSet* set);
-
-  static inline const RepeatedField<ConstType>& GetRepeated(
-      int number, const ExtensionSet& set);
-  static inline RepeatedField<Type>* MutableRepeated(int number,
-                                                     FieldType field_type,
-                                                     bool is_packed,
-                                                     ExtensionSet* set);
-
-  static const RepeatedFieldType* GetDefaultRepeatedField();
-  template <typename ExtendeeT>
-  static void Register(int number, FieldType type, bool is_packed,
-                       LazyEagerVerifyFnType verify_func) {
-    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
-                                    type, true, is_packed, verify_func);
-  }
-};
-
-class PROTOBUF_EXPORT RepeatedPrimitiveDefaults {
- private:
-  template <typename Type>
-  friend class RepeatedPrimitiveTypeTraits;
-  static const RepeatedPrimitiveDefaults* default_instance();
-  RepeatedField<int32_t> default_repeated_field_int32_t_;
-  RepeatedField<int64_t> default_repeated_field_int64_t_;
-  RepeatedField<uint32_t> default_repeated_field_uint32_t_;
-  RepeatedField<uint64_t> default_repeated_field_uint64_t_;
-  RepeatedField<double> default_repeated_field_double_;
-  RepeatedField<float> default_repeated_field_float_;
-  RepeatedField<bool> default_repeated_field_bool_;
-};
-
-#define PROTOBUF_DEFINE_PRIMITIVE_TYPE(TYPE, METHOD)                           \
-  template <>                                                                  \
-  inline TYPE PrimitiveTypeTraits<TYPE>::Get(                                  \
-      int number, const ExtensionSet& set, TYPE default_value) {               \
-    return set.Get##METHOD(number, default_value);                             \
-  }                                                                            \
-  template <>                                                                  \
-  inline const TYPE* PrimitiveTypeTraits<TYPE>::GetPtr(                        \
-      int number, const ExtensionSet& set, const TYPE& default_value) {        \
-    return &set.GetRef##METHOD(number, default_value);                         \
-  }                                                                            \
-  template <>                                                                  \
-  inline void PrimitiveTypeTraits<TYPE>::Set(int number, FieldType field_type, \
-                                             TYPE value, ExtensionSet* set) {  \
-    set->Set##METHOD(number, field_type, value, nullptr);                      \
-  }                                                                            \
-                                                                               \
-  template <>                                                                  \
-  inline TYPE RepeatedPrimitiveTypeTraits<TYPE>::Get(                          \
-      int number, const ExtensionSet& set, int index) {                        \
-    return set.GetRepeated##METHOD(number, index);                             \
-  }                                                                            \
-  template <>                                                                  \
-  inline const TYPE* RepeatedPrimitiveTypeTraits<TYPE>::GetPtr(                \
-      int number, const ExtensionSet& set, int index) {                        \
-    return &set.GetRefRepeated##METHOD(number, index);                         \
-  }                                                                            \
-  template <>                                                                  \
-  inline void RepeatedPrimitiveTypeTraits<TYPE>::Set(                          \
-      int number, int index, TYPE value, ExtensionSet* set) {                  \
-    set->SetRepeated##METHOD(number, index, value);                            \
-  }                                                                            \
-  template <>                                                                  \
-  inline void RepeatedPrimitiveTypeTraits<TYPE>::Add(                          \
-      int number, FieldType field_type, bool is_packed, TYPE value,            \
-      ExtensionSet* set) {                                                     \
-    set->Add##METHOD(number, field_type, is_packed, value, nullptr);           \
-  }                                                                            \
-  template <>                                                                  \
-  inline const RepeatedField<TYPE>*                                            \
-  RepeatedPrimitiveTypeTraits<TYPE>::GetDefaultRepeatedField() {               \
-    return &RepeatedPrimitiveDefaults::default_instance()                      \
-                ->default_repeated_field_##TYPE##_;                            \
-  }                                                                            \
-  template <>                                                                  \
-  inline const RepeatedField<TYPE>&                                            \
-  RepeatedPrimitiveTypeTraits<TYPE>::GetRepeated(int number,                   \
-                                                 const ExtensionSet& set) {    \
-    return *reinterpret_cast<const RepeatedField<TYPE>*>(                      \
-        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));           \
-  }                                                                            \
-  template <>                                                                  \
-  inline const RepeatedField<TYPE>*                                            \
-  RepeatedPrimitiveTypeTraits<TYPE>::GetRepeatedPtr(int number,                \
-                                                    const ExtensionSet& set) { \
-    return &GetRepeated(number, set);                                          \
-  }                                                                            \
-  template <>                                                                  \
-  inline RepeatedField<TYPE>*                                                  \
-  RepeatedPrimitiveTypeTraits<TYPE>::MutableRepeated(                          \
-      int number, FieldType field_type, bool is_packed, ExtensionSet* set) {   \
-    return reinterpret_cast<RepeatedField<TYPE>*>(                             \
-        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr)); \
-  }
-
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(int32_t, Int32)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(int64_t, Int64)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint32_t, UInt32)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint64_t, UInt64)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(float, Float)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(double, Double)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(bool, Bool)
+            PROTOBUF_DEFINE_PRIMITIVE_TYPE(int32_t, Int32)
+            PROTOBUF_DEFINE_PRIMITIVE_TYPE(int64_t, Int64)
+            PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint32_t, UInt32)
+            PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint64_t, UInt64)
+            PROTOBUF_DEFINE_PRIMITIVE_TYPE(float, Float)
+            PROTOBUF_DEFINE_PRIMITIVE_TYPE(double, Double)
+            PROTOBUF_DEFINE_PRIMITIVE_TYPE(bool, Bool)
 
 #undef PROTOBUF_DEFINE_PRIMITIVE_TYPE
 
-// -------------------------------------------------------------------
-// StringTypeTraits
-
-// Strings support both Set() and Mutable().
-class PROTOBUF_EXPORT StringTypeTraits {
- public:
-  typedef const std::string& ConstType;
-  typedef std::string* MutableType;
-  typedef StringTypeTraits Singular;
-
-  static inline const std::string& Get(int number, const ExtensionSet& set,
-                                       ConstType default_value) {
-    return set.GetString(number, default_value);
-  }
-  static inline const std::string* GetPtr(int number, const ExtensionSet& set,
-                                          ConstType default_value) {
-    return &Get(number, set, default_value);
-  }
-  static inline void Set(int number, FieldType field_type,
-                         const std::string& value, ExtensionSet* set) {
-    set->SetString(number, field_type, value, nullptr);
-  }
-  static inline std::string* Mutable(int number, FieldType field_type,
-                                     ExtensionSet* set) {
-    return set->MutableString(number, field_type, nullptr);
-  }
-  template <typename ExtendeeT>
-  static void Register(int number, FieldType type, bool is_packed,
-                       LazyEagerVerifyFnType verify_func) {
-    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
-                                    type, false, is_packed, verify_func);
-  }
-};
-
-class PROTOBUF_EXPORT RepeatedStringTypeTraits {
- public:
-  typedef const std::string& ConstType;
-  typedef std::string* MutableType;
-  typedef RepeatedStringTypeTraits Repeated;
-
-  typedef RepeatedPtrField<std::string> RepeatedFieldType;
-
-  static inline const std::string& Get(int number, const ExtensionSet& set,
-                                       int index) {
-    return set.GetRepeatedString(number, index);
-  }
-  static inline const std::string* GetPtr(int number, const ExtensionSet& set,
-                                          int index) {
-    return &Get(number, set, index);
-  }
-  static inline const RepeatedPtrField<std::string>* GetRepeatedPtr(
-      int number, const ExtensionSet& set) {
-    return &GetRepeated(number, set);
-  }
-  static inline void Set(int number, int index, const std::string& value,
-                         ExtensionSet* set) {
-    set->SetRepeatedString(number, index, value);
-  }
-  static inline std::string* Mutable(int number, int index, ExtensionSet* set) {
-    return set->MutableRepeatedString(number, index);
-  }
-  static inline void Add(int number, FieldType field_type, bool /*is_packed*/,
-                         const std::string& value, ExtensionSet* set) {
-    set->AddString(number, field_type, value, nullptr);
-  }
-  static inline std::string* Add(int number, FieldType field_type,
-                                 ExtensionSet* set) {
-    return set->AddString(number, field_type, nullptr);
-  }
-  static inline const RepeatedPtrField<std::string>& GetRepeated(
-      int number, const ExtensionSet& set) {
-    return *reinterpret_cast<const RepeatedPtrField<std::string>*>(
-        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
-  }
-
-  static inline RepeatedPtrField<std::string>* MutableRepeated(
-      int number, FieldType field_type, bool is_packed, ExtensionSet* set) {
-    return reinterpret_cast<RepeatedPtrField<std::string>*>(
-        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
-  }
-
-  static const RepeatedFieldType* GetDefaultRepeatedField();
-
-  template <typename ExtendeeT>
-  static void Register(int number, FieldType type, bool is_packed,
-                       LazyEagerVerifyFnType fn) {
-    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
-                                    type, true, is_packed, fn);
-  }
-
- private:
-  static void InitializeDefaultRepeatedFields();
-  static void DestroyDefaultRepeatedFields();
-};
-
-// -------------------------------------------------------------------
-// EnumTypeTraits
-
-// ExtensionSet represents enums using integers internally, so we have to
-// static_cast around.
-template <typename Type, bool IsValid(int)>
-class EnumTypeTraits {
- public:
-  typedef Type ConstType;
-  typedef Type MutableType;
-  typedef EnumTypeTraits<Type, IsValid> Singular;
-
-  static inline ConstType Get(int number, const ExtensionSet& set,
-                              ConstType default_value) {
-    return static_cast<Type>(set.GetEnum(number, default_value));
-  }
-  static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
-                                        const ConstType& default_value) {
-    return reinterpret_cast<const Type*>(
-        &set.GetRefEnum(number, default_value));
-  }
-  static inline void Set(int number, FieldType field_type, ConstType value,
-                         ExtensionSet* set) {
-    GOOGLE_DCHECK(IsValid(value));
-    set->SetEnum(number, field_type, value, nullptr);
-  }
-  template <typename ExtendeeT>
-  static void Register(int number, FieldType type, bool is_packed,
-                       LazyEagerVerifyFnType fn) {
-    ExtensionSet::RegisterEnumExtension(&ExtendeeT::default_instance(), number,
-                                        type, false, is_packed, IsValid);
-  }
-};
-
-template <typename Type, bool IsValid(int)>
-class RepeatedEnumTypeTraits {
- public:
-  typedef Type ConstType;
-  typedef Type MutableType;
-  typedef RepeatedEnumTypeTraits<Type, IsValid> Repeated;
-
-  typedef RepeatedField<Type> RepeatedFieldType;
-
-  static inline ConstType Get(int number, const ExtensionSet& set, int index) {
-    return static_cast<Type>(set.GetRepeatedEnum(number, index));
-  }
-  static inline const ConstType* GetPtr(int number, const ExtensionSet& set,
-                                        int index) {
-    return reinterpret_cast<const Type*>(
-        &set.GetRefRepeatedEnum(number, index));
-  }
-  static inline void Set(int number, int index, ConstType value,
-                         ExtensionSet* set) {
-    GOOGLE_DCHECK(IsValid(value));
-    set->SetRepeatedEnum(number, index, value);
-  }
-  static inline void Add(int number, FieldType field_type, bool is_packed,
-                         ConstType value, ExtensionSet* set) {
-    GOOGLE_DCHECK(IsValid(value));
-    set->AddEnum(number, field_type, is_packed, value, nullptr);
-  }
-  static inline const RepeatedField<Type>& GetRepeated(
-      int number, const ExtensionSet& set) {
-    // Hack: the `Extension` struct stores a RepeatedField<int> for enums.
-    // RepeatedField<int> cannot implicitly convert to RepeatedField<EnumType>
-    // so we need to do some casting magic. See message.h for similar
-    // contortions for non-extension fields.
-    return *reinterpret_cast<const RepeatedField<Type>*>(
-        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
-  }
-  static inline const RepeatedField<Type>* GetRepeatedPtr(
-      int number, const ExtensionSet& set) {
-    return &GetRepeated(number, set);
-  }
-  static inline RepeatedField<Type>* MutableRepeated(int number,
-                                                     FieldType field_type,
-                                                     bool is_packed,
-                                                     ExtensionSet* set) {
-    return reinterpret_cast<RepeatedField<Type>*>(
-        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
-  }
-
-  static const RepeatedFieldType* GetDefaultRepeatedField() {
-    // Hack: as noted above, repeated enum fields are internally stored as a
-    // RepeatedField<int>. We need to be able to instantiate global static
-    // objects to return as default (empty) repeated fields on non-existent
-    // extensions. We would not be able to know a-priori all of the enum types
-    // (values of |Type|) to instantiate all of these, so we just re-use
-    // int32_t's default repeated field object.
-    return reinterpret_cast<const RepeatedField<Type>*>(
-        RepeatedPrimitiveTypeTraits<int32_t>::GetDefaultRepeatedField());
-  }
-  template <typename ExtendeeT>
-  static void Register(int number, FieldType type, bool is_packed,
-                       LazyEagerVerifyFnType fn) {
-    ExtensionSet::RegisterEnumExtension(&ExtendeeT::default_instance(), number,
-                                        type, true, is_packed, IsValid);
-  }
-};
-
-// -------------------------------------------------------------------
-// MessageTypeTraits
-
-// ExtensionSet guarantees that when manipulating extensions with message
-// types, the implementation used will be the compiled-in class representing
-// that type.  So, we can static_cast down to the exact type we expect.
-template <typename Type>
-class MessageTypeTraits {
- public:
-  typedef const Type& ConstType;
-  typedef Type* MutableType;
-  typedef MessageTypeTraits<Type> Singular;
-
-  static inline ConstType Get(int number, const ExtensionSet& set,
-                              ConstType default_value) {
-    return static_cast<const Type&>(set.GetMessage(number, default_value));
-  }
-  static inline std::nullptr_t GetPtr(int /* number */,
-                                      const ExtensionSet& /* set */,
-                                      ConstType /* default_value */) {
-    // Cannot be implemented because of forward declared messages?
-    return nullptr;
-  }
-  static inline MutableType Mutable(int number, FieldType field_type,
-                                    ExtensionSet* set) {
-    return static_cast<Type*>(set->MutableMessage(
-        number, field_type, Type::default_instance(), nullptr));
-  }
-  static inline void SetAllocated(int number, FieldType field_type,
-                                  MutableType message, ExtensionSet* set) {
-    set->SetAllocatedMessage(number, field_type, nullptr, message);
-  }
-  static inline void UnsafeArenaSetAllocated(int number, FieldType field_type,
-                                             MutableType message,
-                                             ExtensionSet* set) {
-    set->UnsafeArenaSetAllocatedMessage(number, field_type, nullptr, message);
-  }
-  PROTOBUF_NODISCARD static inline MutableType Release(
-      int number, FieldType /* field_type */, ExtensionSet* set) {
-    return static_cast<Type*>(
-        set->ReleaseMessage(number, Type::default_instance()));
-  }
-  static inline MutableType UnsafeArenaRelease(int number,
-                                               FieldType /* field_type */,
-                                               ExtensionSet* set) {
-    return static_cast<Type*>(
-        set->UnsafeArenaReleaseMessage(number, Type::default_instance()));
-  }
-  template <typename ExtendeeT>
-  static void Register(int number, FieldType type, bool is_packed,
-                       LazyEagerVerifyFnType fn) {
-    ExtensionSet::RegisterMessageExtension(&ExtendeeT::default_instance(),
-                                           number, type, false, is_packed,
-                                           &Type::default_instance(), fn);
-  }
-};
-
-// Used by WireFormatVerify to extract the verify function from the registry.
-LazyEagerVerifyFnType FindExtensionLazyEagerVerifyFn(
-    const MessageLite* extendee, int number);
-
-// forward declaration.
-class RepeatedMessageGenericTypeTraits;
-
-template <typename Type>
-class RepeatedMessageTypeTraits {
- public:
-  typedef const Type& ConstType;
-  typedef Type* MutableType;
-  typedef RepeatedMessageTypeTraits<Type> Repeated;
-
-  typedef RepeatedPtrField<Type> RepeatedFieldType;
-
-  static inline ConstType Get(int number, const ExtensionSet& set, int index) {
-    return static_cast<const Type&>(set.GetRepeatedMessage(number, index));
-  }
-  static inline std::nullptr_t GetPtr(int /* number */,
-                                      const ExtensionSet& /* set */,
-                                      int /* index */) {
-    // Cannot be implemented because of forward declared messages?
-    return nullptr;
-  }
-  static inline std::nullptr_t GetRepeatedPtr(int /* number */,
-                                              const ExtensionSet& /* set */) {
-    // Cannot be implemented because of forward declared messages?
-    return nullptr;
-  }
-  static inline MutableType Mutable(int number, int index, ExtensionSet* set) {
-    return static_cast<Type*>(set->MutableRepeatedMessage(number, index));
-  }
-  static inline MutableType Add(int number, FieldType field_type,
-                                ExtensionSet* set) {
-    return static_cast<Type*>(
-        set->AddMessage(number, field_type, Type::default_instance(), nullptr));
-  }
-  static inline const RepeatedPtrField<Type>& GetRepeated(
-      int number, const ExtensionSet& set) {
-    // See notes above in RepeatedEnumTypeTraits::GetRepeated(): same
-    // casting hack applies here, because a RepeatedPtrField<MessageLite>
-    // cannot naturally become a RepeatedPtrType<Type> even though Type is
-    // presumably a message. google::protobuf::Message goes through similar contortions
-    // with a reinterpret_cast<>.
-    return *reinterpret_cast<const RepeatedPtrField<Type>*>(
-        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
-  }
-  static inline RepeatedPtrField<Type>* MutableRepeated(int number,
-                                                        FieldType field_type,
-                                                        bool is_packed,
-                                                        ExtensionSet* set) {
-    return reinterpret_cast<RepeatedPtrField<Type>*>(
-        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr));
-  }
-
-  static const RepeatedFieldType* GetDefaultRepeatedField();
-  template <typename ExtendeeT>
-  static void Register(int number, FieldType type, bool is_packed,
-                       LazyEagerVerifyFnType fn) {
-    ExtensionSet::RegisterMessageExtension(&ExtendeeT::default_instance(),
-                                           number, type, true, is_packed,
-                                           &Type::default_instance(), fn);
-  }
-};
-
-template <typename Type>
-inline const typename RepeatedMessageTypeTraits<Type>::RepeatedFieldType*
-RepeatedMessageTypeTraits<Type>::GetDefaultRepeatedField() {
-  static auto instance = OnShutdownDelete(new RepeatedFieldType);
-  return instance;
-}
-
-// -------------------------------------------------------------------
-// ExtensionIdentifier
-
-// This is the type of actual extension objects.  E.g. if you have:
-//   extend Foo {
-//     optional int32 bar = 1234;
-//   }
-// then "bar" will be defined in C++ as:
-//   ExtensionIdentifier<Foo, PrimitiveTypeTraits<int32_t>, 5, false> bar(1234);
-//
-// Note that we could, in theory, supply the field number as a template
-// parameter, and thus make an instance of ExtensionIdentifier have no
-// actual contents.  However, if we did that, then using an extension
-// identifier would not necessarily cause the compiler to output any sort
-// of reference to any symbol defined in the extension's .pb.o file.  Some
-// linkers will actually drop object files that are not explicitly referenced,
-// but that would be bad because it would cause this extension to not be
-// registered at static initialization, and therefore using it would crash.
-
-template <typename ExtendeeType, typename TypeTraitsType, FieldType field_type,
-          bool is_packed>
-class ExtensionIdentifier {
- public:
-  typedef TypeTraitsType TypeTraits;
-  typedef ExtendeeType Extendee;
-
-  ExtensionIdentifier(int number, typename TypeTraits::ConstType default_value,
-                      LazyEagerVerifyFnType verify_func = nullptr)
-      : number_(number), default_value_(default_value) {
-    Register(number, verify_func);
-  }
-  inline int number() const { return number_; }
-  typename TypeTraits::ConstType default_value() const {
-    return default_value_;
-  }
-
-  static void Register(int number, LazyEagerVerifyFnType verify_func) {
-    TypeTraits::template Register<ExtendeeType>(number, field_type, is_packed,
-                                                verify_func);
-  }
-
-  typename TypeTraits::ConstType const& default_value_ref() const {
-    return default_value_;
-  }
-
- private:
-  const int number_;
-  typename TypeTraits::ConstType default_value_;
-};
-
-// -------------------------------------------------------------------
-// Generated accessors
-
-
-// Used to retrieve a lazy extension, may return nullptr in some environments.
-extern PROTOBUF_ATTRIBUTE_WEAK ExtensionSet::LazyMessageExtension*
-MaybeCreateLazyExtension(Arena* arena);
-
-}  // namespace internal
-
-// Call this function to ensure that this extensions's reflection is linked into
-// the binary:
-//
-//   google::protobuf::LinkExtensionReflection(Foo::my_extension);
-//
-// This will ensure that the following lookup will succeed:
-//
-//   DescriptorPool::generated_pool()->FindExtensionByName("Foo.my_extension");
-//
-// This is often relevant for parsing extensions in text mode.
-//
-// As a side-effect, it will also guarantee that anything else from the same
-// .proto file will also be available for lookup in the generated pool.
-//
-// This function does not actually register the extension, so it does not need
-// to be called before the lookup.  However it does need to occur in a function
-// that cannot be stripped from the binary (ie. it must be reachable from main).
-//
-// Best practice is to call this function as close as possible to where the
-// reflection is actually needed.  This function is very cheap to call, so you
-// should not need to worry about its runtime overhead except in tight loops (on
-// x86-64 it compiles into two "mov" instructions).
-template <typename ExtendeeType, typename TypeTraitsType,
-          internal::FieldType field_type, bool is_packed>
-void LinkExtensionReflection(
-    const google::protobuf::internal::ExtensionIdentifier<
-        ExtendeeType, TypeTraitsType, field_type, is_packed>& extension) {
-  internal::StrongReference(extension);
-}
-
-}  // namespace protobuf
+            // -------------------------------------------------------------------
+            // StringTypeTraits
+
+            // Strings support both Set() and Mutable().
+            class PROTOBUF_EXPORT StringTypeTraits
+            {
+            public:
+                typedef const std::string& ConstType;
+                typedef std::string* MutableType;
+                typedef StringTypeTraits Singular;
+
+                static inline const std::string& Get(int number, const ExtensionSet& set, ConstType default_value)
+                {
+                    return set.GetString(number, default_value);
+                }
+                static inline const std::string* GetPtr(int number, const ExtensionSet& set, ConstType default_value)
+                {
+                    return &Get(number, set, default_value);
+                }
+                static inline void Set(int number, FieldType field_type, const std::string& value, ExtensionSet* set)
+                {
+                    set->SetString(number, field_type, value, nullptr);
+                }
+                static inline std::string* Mutable(int number, FieldType field_type, ExtensionSet* set)
+                {
+                    return set->MutableString(number, field_type, nullptr);
+                }
+                template<typename ExtendeeT>
+                static void Register(int number, FieldType type, bool is_packed, LazyEagerVerifyFnType verify_func)
+                {
+                    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number, type, false, is_packed, verify_func);
+                }
+            };
+
+            class PROTOBUF_EXPORT RepeatedStringTypeTraits
+            {
+            public:
+                typedef const std::string& ConstType;
+                typedef std::string* MutableType;
+                typedef RepeatedStringTypeTraits Repeated;
+
+                typedef RepeatedPtrField<std::string> RepeatedFieldType;
+
+                static inline const std::string& Get(int number, const ExtensionSet& set, int index)
+                {
+                    return set.GetRepeatedString(number, index);
+                }
+                static inline const std::string* GetPtr(int number, const ExtensionSet& set, int index)
+                {
+                    return &Get(number, set, index);
+                }
+                static inline const RepeatedPtrField<std::string>* GetRepeatedPtr(
+                    int number, const ExtensionSet& set
+                )
+                {
+                    return &GetRepeated(number, set);
+                }
+                static inline void Set(int number, int index, const std::string& value, ExtensionSet* set)
+                {
+                    set->SetRepeatedString(number, index, value);
+                }
+                static inline std::string* Mutable(int number, int index, ExtensionSet* set)
+                {
+                    return set->MutableRepeatedString(number, index);
+                }
+                static inline void Add(int number, FieldType field_type, bool /*is_packed*/, const std::string& value, ExtensionSet* set)
+                {
+                    set->AddString(number, field_type, value, nullptr);
+                }
+                static inline std::string* Add(int number, FieldType field_type, ExtensionSet* set)
+                {
+                    return set->AddString(number, field_type, nullptr);
+                }
+                static inline const RepeatedPtrField<std::string>& GetRepeated(
+                    int number, const ExtensionSet& set
+                )
+                {
+                    return *reinterpret_cast<const RepeatedPtrField<std::string>*>(
+                        set.GetRawRepeatedField(number, GetDefaultRepeatedField())
+                    );
+                }
+
+                static inline RepeatedPtrField<std::string>* MutableRepeated(
+                    int number, FieldType field_type, bool is_packed, ExtensionSet* set
+                )
+                {
+                    return reinterpret_cast<RepeatedPtrField<std::string>*>(
+                        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr)
+                    );
+                }
+
+                static const RepeatedFieldType* GetDefaultRepeatedField();
+
+                template<typename ExtendeeT>
+                static void Register(int number, FieldType type, bool is_packed, LazyEagerVerifyFnType fn)
+                {
+                    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number, type, true, is_packed, fn);
+                }
+
+            private:
+                static void InitializeDefaultRepeatedFields();
+                static void DestroyDefaultRepeatedFields();
+            };
+
+            // -------------------------------------------------------------------
+            // EnumTypeTraits
+
+            // ExtensionSet represents enums using integers internally, so we have to
+            // static_cast around.
+            template<typename Type, bool IsValid(int)>
+            class EnumTypeTraits
+            {
+            public:
+                typedef Type ConstType;
+                typedef Type MutableType;
+                typedef EnumTypeTraits<Type, IsValid> Singular;
+
+                static inline ConstType Get(int number, const ExtensionSet& set, ConstType default_value)
+                {
+                    return static_cast<Type>(set.GetEnum(number, default_value));
+                }
+                static inline const ConstType* GetPtr(int number, const ExtensionSet& set, const ConstType& default_value)
+                {
+                    return reinterpret_cast<const Type*>(
+                        &set.GetRefEnum(number, default_value)
+                    );
+                }
+                static inline void Set(int number, FieldType field_type, ConstType value, ExtensionSet* set)
+                {
+                    GOOGLE_DCHECK(IsValid(value));
+                    set->SetEnum(number, field_type, value, nullptr);
+                }
+                template<typename ExtendeeT>
+                static void Register(int number, FieldType type, bool is_packed, LazyEagerVerifyFnType fn)
+                {
+                    ExtensionSet::RegisterEnumExtension(&ExtendeeT::default_instance(), number, type, false, is_packed, IsValid);
+                }
+            };
+
+            template<typename Type, bool IsValid(int)>
+            class RepeatedEnumTypeTraits
+            {
+            public:
+                typedef Type ConstType;
+                typedef Type MutableType;
+                typedef RepeatedEnumTypeTraits<Type, IsValid> Repeated;
+
+                typedef RepeatedField<Type> RepeatedFieldType;
+
+                static inline ConstType Get(int number, const ExtensionSet& set, int index)
+                {
+                    return static_cast<Type>(set.GetRepeatedEnum(number, index));
+                }
+                static inline const ConstType* GetPtr(int number, const ExtensionSet& set, int index)
+                {
+                    return reinterpret_cast<const Type*>(
+                        &set.GetRefRepeatedEnum(number, index)
+                    );
+                }
+                static inline void Set(int number, int index, ConstType value, ExtensionSet* set)
+                {
+                    GOOGLE_DCHECK(IsValid(value));
+                    set->SetRepeatedEnum(number, index, value);
+                }
+                static inline void Add(int number, FieldType field_type, bool is_packed, ConstType value, ExtensionSet* set)
+                {
+                    GOOGLE_DCHECK(IsValid(value));
+                    set->AddEnum(number, field_type, is_packed, value, nullptr);
+                }
+                static inline const RepeatedField<Type>& GetRepeated(
+                    int number, const ExtensionSet& set
+                )
+                {
+                    // Hack: the `Extension` struct stores a RepeatedField<int> for enums.
+                    // RepeatedField<int> cannot implicitly convert to RepeatedField<EnumType>
+                    // so we need to do some casting magic. See message.h for similar
+                    // contortions for non-extension fields.
+                    return *reinterpret_cast<const RepeatedField<Type>*>(
+                        set.GetRawRepeatedField(number, GetDefaultRepeatedField())
+                    );
+                }
+                static inline const RepeatedField<Type>* GetRepeatedPtr(
+                    int number, const ExtensionSet& set
+                )
+                {
+                    return &GetRepeated(number, set);
+                }
+                static inline RepeatedField<Type>* MutableRepeated(int number, FieldType field_type, bool is_packed, ExtensionSet* set)
+                {
+                    return reinterpret_cast<RepeatedField<Type>*>(
+                        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr)
+                    );
+                }
+
+                static const RepeatedFieldType* GetDefaultRepeatedField()
+                {
+                    // Hack: as noted above, repeated enum fields are internally stored as a
+                    // RepeatedField<int>. We need to be able to instantiate global static
+                    // objects to return as default (empty) repeated fields on non-existent
+                    // extensions. We would not be able to know a-priori all of the enum types
+                    // (values of |Type|) to instantiate all of these, so we just re-use
+                    // int32_t's default repeated field object.
+                    return reinterpret_cast<const RepeatedField<Type>*>(
+                        RepeatedPrimitiveTypeTraits<int32_t>::GetDefaultRepeatedField()
+                    );
+                }
+                template<typename ExtendeeT>
+                static void Register(int number, FieldType type, bool is_packed, LazyEagerVerifyFnType fn)
+                {
+                    ExtensionSet::RegisterEnumExtension(&ExtendeeT::default_instance(), number, type, true, is_packed, IsValid);
+                }
+            };
+
+            // -------------------------------------------------------------------
+            // MessageTypeTraits
+
+            // ExtensionSet guarantees that when manipulating extensions with message
+            // types, the implementation used will be the compiled-in class representing
+            // that type.  So, we can static_cast down to the exact type we expect.
+            template<typename Type>
+            class MessageTypeTraits
+            {
+            public:
+                typedef const Type& ConstType;
+                typedef Type* MutableType;
+                typedef MessageTypeTraits<Type> Singular;
+
+                static inline ConstType Get(int number, const ExtensionSet& set, ConstType default_value)
+                {
+                    return static_cast<const Type&>(set.GetMessage(number, default_value));
+                }
+                static inline std::nullptr_t GetPtr(int /* number */, const ExtensionSet& /* set */, ConstType /* default_value */)
+                {
+                    // Cannot be implemented because of forward declared messages?
+                    return nullptr;
+                }
+                static inline MutableType Mutable(int number, FieldType field_type, ExtensionSet* set)
+                {
+                    return static_cast<Type*>(set->MutableMessage(
+                        number, field_type, Type::default_instance(), nullptr
+                    ));
+                }
+                static inline void SetAllocated(int number, FieldType field_type, MutableType message, ExtensionSet* set)
+                {
+                    set->SetAllocatedMessage(number, field_type, nullptr, message);
+                }
+                static inline void UnsafeArenaSetAllocated(int number, FieldType field_type, MutableType message, ExtensionSet* set)
+                {
+                    set->UnsafeArenaSetAllocatedMessage(number, field_type, nullptr, message);
+                }
+                PROTOBUF_NODISCARD static inline MutableType Release(
+                    int number, FieldType /* field_type */, ExtensionSet* set
+                )
+                {
+                    return static_cast<Type*>(
+                        set->ReleaseMessage(number, Type::default_instance())
+                    );
+                }
+                static inline MutableType UnsafeArenaRelease(int number, FieldType /* field_type */, ExtensionSet* set)
+                {
+                    return static_cast<Type*>(
+                        set->UnsafeArenaReleaseMessage(number, Type::default_instance())
+                    );
+                }
+                template<typename ExtendeeT>
+                static void Register(int number, FieldType type, bool is_packed, LazyEagerVerifyFnType fn)
+                {
+                    ExtensionSet::RegisterMessageExtension(&ExtendeeT::default_instance(), number, type, false, is_packed, &Type::default_instance(), fn);
+                }
+            };
+
+            // Used by WireFormatVerify to extract the verify function from the registry.
+            LazyEagerVerifyFnType FindExtensionLazyEagerVerifyFn(
+                const MessageLite* extendee, int number
+            );
+
+            // forward declaration.
+            class RepeatedMessageGenericTypeTraits;
+
+            template<typename Type>
+            class RepeatedMessageTypeTraits
+            {
+            public:
+                typedef const Type& ConstType;
+                typedef Type* MutableType;
+                typedef RepeatedMessageTypeTraits<Type> Repeated;
+
+                typedef RepeatedPtrField<Type> RepeatedFieldType;
+
+                static inline ConstType Get(int number, const ExtensionSet& set, int index)
+                {
+                    return static_cast<const Type&>(set.GetRepeatedMessage(number, index));
+                }
+                static inline std::nullptr_t GetPtr(int /* number */, const ExtensionSet& /* set */, int /* index */)
+                {
+                    // Cannot be implemented because of forward declared messages?
+                    return nullptr;
+                }
+                static inline std::nullptr_t GetRepeatedPtr(int /* number */, const ExtensionSet& /* set */)
+                {
+                    // Cannot be implemented because of forward declared messages?
+                    return nullptr;
+                }
+                static inline MutableType Mutable(int number, int index, ExtensionSet* set)
+                {
+                    return static_cast<Type*>(set->MutableRepeatedMessage(number, index));
+                }
+                static inline MutableType Add(int number, FieldType field_type, ExtensionSet* set)
+                {
+                    return static_cast<Type*>(
+                        set->AddMessage(number, field_type, Type::default_instance(), nullptr)
+                    );
+                }
+                static inline const RepeatedPtrField<Type>& GetRepeated(
+                    int number, const ExtensionSet& set
+                )
+                {
+                    // See notes above in RepeatedEnumTypeTraits::GetRepeated(): same
+                    // casting hack applies here, because a RepeatedPtrField<MessageLite>
+                    // cannot naturally become a RepeatedPtrType<Type> even though Type is
+                    // presumably a message. google::protobuf::Message goes through similar contortions
+                    // with a reinterpret_cast<>.
+                    return *reinterpret_cast<const RepeatedPtrField<Type>*>(
+                        set.GetRawRepeatedField(number, GetDefaultRepeatedField())
+                    );
+                }
+                static inline RepeatedPtrField<Type>* MutableRepeated(int number, FieldType field_type, bool is_packed, ExtensionSet* set)
+                {
+                    return reinterpret_cast<RepeatedPtrField<Type>*>(
+                        set->MutableRawRepeatedField(number, field_type, is_packed, nullptr)
+                    );
+                }
+
+                static const RepeatedFieldType* GetDefaultRepeatedField();
+                template<typename ExtendeeT>
+                static void Register(int number, FieldType type, bool is_packed, LazyEagerVerifyFnType fn)
+                {
+                    ExtensionSet::RegisterMessageExtension(&ExtendeeT::default_instance(), number, type, true, is_packed, &Type::default_instance(), fn);
+                }
+            };
+
+            template<typename Type>
+            inline const typename RepeatedMessageTypeTraits<Type>::RepeatedFieldType*
+                RepeatedMessageTypeTraits<Type>::GetDefaultRepeatedField()
+            {
+                static auto instance = OnShutdownDelete(new RepeatedFieldType);
+                return instance;
+            }
+
+            // -------------------------------------------------------------------
+            // ExtensionIdentifier
+
+            // This is the type of actual extension objects.  E.g. if you have:
+            //   extend Foo {
+            //     optional int32 bar = 1234;
+            //   }
+            // then "bar" will be defined in C++ as:
+            //   ExtensionIdentifier<Foo, PrimitiveTypeTraits<int32_t>, 5, false> bar(1234);
+            //
+            // Note that we could, in theory, supply the field number as a template
+            // parameter, and thus make an instance of ExtensionIdentifier have no
+            // actual contents.  However, if we did that, then using an extension
+            // identifier would not necessarily cause the compiler to output any sort
+            // of reference to any symbol defined in the extension's .pb.o file.  Some
+            // linkers will actually drop object files that are not explicitly referenced,
+            // but that would be bad because it would cause this extension to not be
+            // registered at static initialization, and therefore using it would crash.
+
+            template<typename ExtendeeType, typename TypeTraitsType, FieldType field_type, bool is_packed>
+            class ExtensionIdentifier
+            {
+            public:
+                typedef TypeTraitsType TypeTraits;
+                typedef ExtendeeType Extendee;
+
+                ExtensionIdentifier(int number, typename TypeTraits::ConstType default_value, LazyEagerVerifyFnType verify_func = nullptr) :
+                    number_(number),
+                    default_value_(default_value)
+                {
+                    Register(number, verify_func);
+                }
+                inline int number() const
+                {
+                    return number_;
+                }
+                typename TypeTraits::ConstType default_value() const
+                {
+                    return default_value_;
+                }
+
+                static void Register(int number, LazyEagerVerifyFnType verify_func)
+                {
+                    TypeTraits::template Register<ExtendeeType>(number, field_type, is_packed, verify_func);
+                }
+
+                typename TypeTraits::ConstType const& default_value_ref() const
+                {
+                    return default_value_;
+                }
+
+            private:
+                const int number_;
+                typename TypeTraits::ConstType default_value_;
+            };
+
+            // -------------------------------------------------------------------
+            // Generated accessors
+
+            // Used to retrieve a lazy extension, may return nullptr in some environments.
+            extern PROTOBUF_ATTRIBUTE_WEAK ExtensionSet::LazyMessageExtension*
+                MaybeCreateLazyExtension(Arena* arena);
+
+        }  // namespace internal
+
+        // Call this function to ensure that this extensions's reflection is linked into
+        // the binary:
+        //
+        //   google::protobuf::LinkExtensionReflection(Foo::my_extension);
+        //
+        // This will ensure that the following lookup will succeed:
+        //
+        //   DescriptorPool::generated_pool()->FindExtensionByName("Foo.my_extension");
+        //
+        // This is often relevant for parsing extensions in text mode.
+        //
+        // As a side-effect, it will also guarantee that anything else from the same
+        // .proto file will also be available for lookup in the generated pool.
+        //
+        // This function does not actually register the extension, so it does not need
+        // to be called before the lookup.  However it does need to occur in a function
+        // that cannot be stripped from the binary (ie. it must be reachable from main).
+        //
+        // Best practice is to call this function as close as possible to where the
+        // reflection is actually needed.  This function is very cheap to call, so you
+        // should not need to worry about its runtime overhead except in tight loops (on
+        // x86-64 it compiles into two "mov" instructions).
+        template<typename ExtendeeType, typename TypeTraitsType, internal::FieldType field_type, bool is_packed>
+        void LinkExtensionReflection(
+            const google::protobuf::internal::ExtensionIdentifier<
+                ExtendeeType,
+                TypeTraitsType,
+                field_type,
+                is_packed>& extension
+        )
+        {
+            internal::StrongReference(extension);
+        }
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/extension_set_inl.h b/CAPI/cpp/grpc/include/google/protobuf/extension_set_inl.h
index e4e7117..4c55f94 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/extension_set_inl.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/extension_set_inl.h
@@ -35,251 +35,280 @@
 #include <google/protobuf/metadata_lite.h>
 #include <google/protobuf/parse_context.h>
 
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
-template <typename T>
-const char* ExtensionSet::ParseFieldWithExtensionInfo(
-    int number, bool was_packed_on_wire, const ExtensionInfo& extension,
-    InternalMetadata* metadata, const char* ptr, internal::ParseContext* ctx) {
-  if (was_packed_on_wire) {
-    switch (extension.type) {
-#define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE)                                \
-  case WireFormatLite::TYPE_##UPPERCASE:                                     \
-    return internal::Packed##CPP_CAMELCASE##Parser(                          \
-        MutableRawRepeatedField(number, extension.type, extension.is_packed, \
-                                extension.descriptor),                       \
-        ptr, ctx);
-      HANDLE_TYPE(INT32, Int32);
-      HANDLE_TYPE(INT64, Int64);
-      HANDLE_TYPE(UINT32, UInt32);
-      HANDLE_TYPE(UINT64, UInt64);
-      HANDLE_TYPE(SINT32, SInt32);
-      HANDLE_TYPE(SINT64, SInt64);
-      HANDLE_TYPE(FIXED32, Fixed32);
-      HANDLE_TYPE(FIXED64, Fixed64);
-      HANDLE_TYPE(SFIXED32, SFixed32);
-      HANDLE_TYPE(SFIXED64, SFixed64);
-      HANDLE_TYPE(FLOAT, Float);
-      HANDLE_TYPE(DOUBLE, Double);
-      HANDLE_TYPE(BOOL, Bool);
+            template<typename T>
+            const char* ExtensionSet::ParseFieldWithExtensionInfo(
+                int number, bool was_packed_on_wire, const ExtensionInfo& extension, InternalMetadata* metadata, const char* ptr, internal::ParseContext* ctx
+            )
+            {
+                if (was_packed_on_wire)
+                {
+                    switch (extension.type)
+                    {
+#define HANDLE_TYPE(UPPERCASE, CPP_CAMELCASE)                                                           \
+    case WireFormatLite::TYPE_##UPPERCASE:                                                              \
+        return internal::Packed##CPP_CAMELCASE##Parser(                                                 \
+            MutableRawRepeatedField(number, extension.type, extension.is_packed, extension.descriptor), \
+            ptr,                                                                                        \
+            ctx                                                                                         \
+        );
+                        HANDLE_TYPE(INT32, Int32);
+                        HANDLE_TYPE(INT64, Int64);
+                        HANDLE_TYPE(UINT32, UInt32);
+                        HANDLE_TYPE(UINT64, UInt64);
+                        HANDLE_TYPE(SINT32, SInt32);
+                        HANDLE_TYPE(SINT64, SInt64);
+                        HANDLE_TYPE(FIXED32, Fixed32);
+                        HANDLE_TYPE(FIXED64, Fixed64);
+                        HANDLE_TYPE(SFIXED32, SFixed32);
+                        HANDLE_TYPE(SFIXED64, SFixed64);
+                        HANDLE_TYPE(FLOAT, Float);
+                        HANDLE_TYPE(DOUBLE, Double);
+                        HANDLE_TYPE(BOOL, Bool);
 #undef HANDLE_TYPE
 
-      case WireFormatLite::TYPE_ENUM:
-        return internal::PackedEnumParserArg<T>(
-            MutableRawRepeatedField(number, extension.type, extension.is_packed,
-                                    extension.descriptor),
-            ptr, ctx, extension.enum_validity_check.func,
-            extension.enum_validity_check.arg, metadata, number);
-      case WireFormatLite::TYPE_STRING:
-      case WireFormatLite::TYPE_BYTES:
-      case WireFormatLite::TYPE_GROUP:
-      case WireFormatLite::TYPE_MESSAGE:
-        GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed.";
-        break;
-    }
-  } else {
-    switch (extension.type) {
-#define HANDLE_VARINT_TYPE(UPPERCASE, CPP_CAMELCASE)                        \
-  case WireFormatLite::TYPE_##UPPERCASE: {                                  \
-    uint64_t value;                                                         \
-    ptr = VarintParse(ptr, &value);                                         \
-    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);                                    \
-    if (extension.is_repeated) {                                            \
-      Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE,          \
-                         extension.is_packed, value, extension.descriptor); \
-    } else {                                                                \
-      Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value,   \
-                         extension.descriptor);                             \
-    }                                                                       \
-  } break
+                        case WireFormatLite::TYPE_ENUM:
+                            return internal::PackedEnumParserArg<T>(
+                                MutableRawRepeatedField(number, extension.type, extension.is_packed, extension.descriptor),
+                                ptr,
+                                ctx,
+                                extension.enum_validity_check.func,
+                                extension.enum_validity_check.arg,
+                                metadata,
+                                number
+                            );
+                        case WireFormatLite::TYPE_STRING:
+                        case WireFormatLite::TYPE_BYTES:
+                        case WireFormatLite::TYPE_GROUP:
+                        case WireFormatLite::TYPE_MESSAGE:
+                            GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed.";
+                            break;
+                    }
+                }
+                else
+                {
+                    switch (extension.type)
+                    {
+#define HANDLE_VARINT_TYPE(UPPERCASE, CPP_CAMELCASE)                                                                            \
+    case WireFormatLite::TYPE_##UPPERCASE:                                                                                      \
+        {                                                                                                                       \
+            uint64_t value;                                                                                                     \
+            ptr = VarintParse(ptr, &value);                                                                                     \
+            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);                                                                                 \
+            if (extension.is_repeated)                                                                                          \
+            {                                                                                                                   \
+                Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, extension.is_packed, value, extension.descriptor); \
+            }                                                                                                                   \
+            else                                                                                                                \
+            {                                                                                                                   \
+                Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value, extension.descriptor);                      \
+            }                                                                                                                   \
+        }                                                                                                                       \
+        break
 
-      HANDLE_VARINT_TYPE(INT32, Int32);
-      HANDLE_VARINT_TYPE(INT64, Int64);
-      HANDLE_VARINT_TYPE(UINT32, UInt32);
-      HANDLE_VARINT_TYPE(UINT64, UInt64);
-      HANDLE_VARINT_TYPE(BOOL, Bool);
+                        HANDLE_VARINT_TYPE(INT32, Int32);
+                        HANDLE_VARINT_TYPE(INT64, Int64);
+                        HANDLE_VARINT_TYPE(UINT32, UInt32);
+                        HANDLE_VARINT_TYPE(UINT64, UInt64);
+                        HANDLE_VARINT_TYPE(BOOL, Bool);
 #undef HANDLE_VARINT_TYPE
-#define HANDLE_SVARINT_TYPE(UPPERCASE, CPP_CAMELCASE, SIZE)                 \
-  case WireFormatLite::TYPE_##UPPERCASE: {                                  \
-    uint64_t val;                                                           \
-    ptr = VarintParse(ptr, &val);                                           \
-    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);                                    \
-    auto value = WireFormatLite::ZigZagDecode##SIZE(val);                   \
-    if (extension.is_repeated) {                                            \
-      Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE,          \
-                         extension.is_packed, value, extension.descriptor); \
-    } else {                                                                \
-      Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value,   \
-                         extension.descriptor);                             \
-    }                                                                       \
-  } break
+#define HANDLE_SVARINT_TYPE(UPPERCASE, CPP_CAMELCASE, SIZE)                                                                     \
+    case WireFormatLite::TYPE_##UPPERCASE:                                                                                      \
+        {                                                                                                                       \
+            uint64_t val;                                                                                                       \
+            ptr = VarintParse(ptr, &val);                                                                                       \
+            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);                                                                                 \
+            auto value = WireFormatLite::ZigZagDecode##SIZE(val);                                                               \
+            if (extension.is_repeated)                                                                                          \
+            {                                                                                                                   \
+                Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, extension.is_packed, value, extension.descriptor); \
+            }                                                                                                                   \
+            else                                                                                                                \
+            {                                                                                                                   \
+                Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value, extension.descriptor);                      \
+            }                                                                                                                   \
+        }                                                                                                                       \
+        break
 
-      HANDLE_SVARINT_TYPE(SINT32, Int32, 32);
-      HANDLE_SVARINT_TYPE(SINT64, Int64, 64);
+                        HANDLE_SVARINT_TYPE(SINT32, Int32, 32);
+                        HANDLE_SVARINT_TYPE(SINT64, Int64, 64);
 #undef HANDLE_SVARINT_TYPE
-#define HANDLE_FIXED_TYPE(UPPERCASE, CPP_CAMELCASE, CPPTYPE)                \
-  case WireFormatLite::TYPE_##UPPERCASE: {                                  \
-    auto value = UnalignedLoad<CPPTYPE>(ptr);                               \
-    ptr += sizeof(CPPTYPE);                                                 \
-    if (extension.is_repeated) {                                            \
-      Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE,          \
-                         extension.is_packed, value, extension.descriptor); \
-    } else {                                                                \
-      Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value,   \
-                         extension.descriptor);                             \
-    }                                                                       \
-  } break
+#define HANDLE_FIXED_TYPE(UPPERCASE, CPP_CAMELCASE, CPPTYPE)                                                                    \
+    case WireFormatLite::TYPE_##UPPERCASE:                                                                                      \
+        {                                                                                                                       \
+            auto value = UnalignedLoad<CPPTYPE>(ptr);                                                                           \
+            ptr += sizeof(CPPTYPE);                                                                                             \
+            if (extension.is_repeated)                                                                                          \
+            {                                                                                                                   \
+                Add##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, extension.is_packed, value, extension.descriptor); \
+            }                                                                                                                   \
+            else                                                                                                                \
+            {                                                                                                                   \
+                Set##CPP_CAMELCASE(number, WireFormatLite::TYPE_##UPPERCASE, value, extension.descriptor);                      \
+            }                                                                                                                   \
+        }                                                                                                                       \
+        break
 
-      HANDLE_FIXED_TYPE(FIXED32, UInt32, uint32_t);
-      HANDLE_FIXED_TYPE(FIXED64, UInt64, uint64_t);
-      HANDLE_FIXED_TYPE(SFIXED32, Int32, int32_t);
-      HANDLE_FIXED_TYPE(SFIXED64, Int64, int64_t);
-      HANDLE_FIXED_TYPE(FLOAT, Float, float);
-      HANDLE_FIXED_TYPE(DOUBLE, Double, double);
+                        HANDLE_FIXED_TYPE(FIXED32, UInt32, uint32_t);
+                        HANDLE_FIXED_TYPE(FIXED64, UInt64, uint64_t);
+                        HANDLE_FIXED_TYPE(SFIXED32, Int32, int32_t);
+                        HANDLE_FIXED_TYPE(SFIXED64, Int64, int64_t);
+                        HANDLE_FIXED_TYPE(FLOAT, Float, float);
+                        HANDLE_FIXED_TYPE(DOUBLE, Double, double);
 #undef HANDLE_FIXED_TYPE
 
-      case WireFormatLite::TYPE_ENUM: {
-        uint64_t val;
-        ptr = VarintParse(ptr, &val);
-        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-        int value = val;
+                        case WireFormatLite::TYPE_ENUM:
+                            {
+                                uint64_t val;
+                                ptr = VarintParse(ptr, &val);
+                                GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                                int value = val;
 
-        if (!extension.enum_validity_check.func(
-                extension.enum_validity_check.arg, value)) {
-          WriteVarint(number, val, metadata->mutable_unknown_fields<T>());
-        } else if (extension.is_repeated) {
-          AddEnum(number, WireFormatLite::TYPE_ENUM, extension.is_packed, value,
-                  extension.descriptor);
-        } else {
-          SetEnum(number, WireFormatLite::TYPE_ENUM, value,
-                  extension.descriptor);
-        }
-        break;
-      }
+                                if (!extension.enum_validity_check.func(
+                                        extension.enum_validity_check.arg, value
+                                    ))
+                                {
+                                    WriteVarint(number, val, metadata->mutable_unknown_fields<T>());
+                                }
+                                else if (extension.is_repeated)
+                                {
+                                    AddEnum(number, WireFormatLite::TYPE_ENUM, extension.is_packed, value, extension.descriptor);
+                                }
+                                else
+                                {
+                                    SetEnum(number, WireFormatLite::TYPE_ENUM, value, extension.descriptor);
+                                }
+                                break;
+                            }
 
-      case WireFormatLite::TYPE_BYTES:
-      case WireFormatLite::TYPE_STRING: {
-        std::string* value =
-            extension.is_repeated
-                ? AddString(number, WireFormatLite::TYPE_STRING,
-                            extension.descriptor)
-                : MutableString(number, WireFormatLite::TYPE_STRING,
-                                extension.descriptor);
-        int size = ReadSize(&ptr);
-        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-        return ctx->ReadString(ptr, size, value);
-      }
+                        case WireFormatLite::TYPE_BYTES:
+                        case WireFormatLite::TYPE_STRING:
+                            {
+                                std::string* value =
+                                    extension.is_repeated ? AddString(number, WireFormatLite::TYPE_STRING, extension.descriptor) : MutableString(number, WireFormatLite::TYPE_STRING, extension.descriptor);
+                                int size = ReadSize(&ptr);
+                                GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                                return ctx->ReadString(ptr, size, value);
+                            }
 
-      case WireFormatLite::TYPE_GROUP: {
-        MessageLite* value =
-            extension.is_repeated
-                ? AddMessage(number, WireFormatLite::TYPE_GROUP,
-                             *extension.message_info.prototype,
-                             extension.descriptor)
-                : MutableMessage(number, WireFormatLite::TYPE_GROUP,
-                                 *extension.message_info.prototype,
-                                 extension.descriptor);
-        uint32_t tag = (number << 3) + WireFormatLite::WIRETYPE_START_GROUP;
-        return ctx->ParseGroup(value, ptr, tag);
-      }
+                        case WireFormatLite::TYPE_GROUP:
+                            {
+                                MessageLite* value =
+                                    extension.is_repeated ? AddMessage(number, WireFormatLite::TYPE_GROUP, *extension.message_info.prototype, extension.descriptor) : MutableMessage(number, WireFormatLite::TYPE_GROUP, *extension.message_info.prototype, extension.descriptor);
+                                uint32_t tag = (number << 3) + WireFormatLite::WIRETYPE_START_GROUP;
+                                return ctx->ParseGroup(value, ptr, tag);
+                            }
 
-      case WireFormatLite::TYPE_MESSAGE: {
-        MessageLite* value =
-            extension.is_repeated
-                ? AddMessage(number, WireFormatLite::TYPE_MESSAGE,
-                             *extension.message_info.prototype,
-                             extension.descriptor)
-                : MutableMessage(number, WireFormatLite::TYPE_MESSAGE,
-                                 *extension.message_info.prototype,
-                                 extension.descriptor);
-        return ctx->ParseMessage(value, ptr);
-      }
-    }
-  }
-  return ptr;
-}
+                        case WireFormatLite::TYPE_MESSAGE:
+                            {
+                                MessageLite* value =
+                                    extension.is_repeated ? AddMessage(number, WireFormatLite::TYPE_MESSAGE, *extension.message_info.prototype, extension.descriptor) : MutableMessage(number, WireFormatLite::TYPE_MESSAGE, *extension.message_info.prototype, extension.descriptor);
+                                return ctx->ParseMessage(value, ptr);
+                            }
+                    }
+                }
+                return ptr;
+            }
 
-template <typename Msg, typename T>
-const char* ExtensionSet::ParseMessageSetItemTmpl(
-    const char* ptr, const Msg* extendee, internal::InternalMetadata* metadata,
-    internal::ParseContext* ctx) {
-  std::string payload;
-  uint32_t type_id;
-  enum class State { kNoTag, kHasType, kHasPayload, kDone };
-  State state = State::kNoTag;
+            template<typename Msg, typename T>
+            const char* ExtensionSet::ParseMessageSetItemTmpl(
+                const char* ptr, const Msg* extendee, internal::InternalMetadata* metadata, internal::ParseContext* ctx
+            )
+            {
+                std::string payload;
+                uint32_t type_id;
+                enum class State
+                {
+                    kNoTag,
+                    kHasType,
+                    kHasPayload,
+                    kDone
+                };
+                State state = State::kNoTag;
 
-  while (!ctx->Done(&ptr)) {
-    uint32_t tag = static_cast<uint8_t>(*ptr++);
-    if (tag == WireFormatLite::kMessageSetTypeIdTag) {
-      uint64_t tmp;
-      ptr = ParseBigVarint(ptr, &tmp);
-      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-      if (state == State::kNoTag) {
-        type_id = tmp;
-        state = State::kHasType;
-      } else if (state == State::kHasPayload) {
-        type_id = tmp;
-        ExtensionInfo extension;
-        bool was_packed_on_wire;
-        if (!FindExtension(2, type_id, extendee, ctx, &extension,
-                           &was_packed_on_wire)) {
-          WriteLengthDelimited(type_id, payload,
-                               metadata->mutable_unknown_fields<T>());
-        } else {
-          MessageLite* value =
-              extension.is_repeated
-                  ? AddMessage(type_id, WireFormatLite::TYPE_MESSAGE,
-                               *extension.message_info.prototype,
-                               extension.descriptor)
-                  : MutableMessage(type_id, WireFormatLite::TYPE_MESSAGE,
-                                   *extension.message_info.prototype,
-                                   extension.descriptor);
+                while (!ctx->Done(&ptr))
+                {
+                    uint32_t tag = static_cast<uint8_t>(*ptr++);
+                    if (tag == WireFormatLite::kMessageSetTypeIdTag)
+                    {
+                        uint64_t tmp;
+                        ptr = ParseBigVarint(ptr, &tmp);
+                        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                        if (state == State::kNoTag)
+                        {
+                            type_id = tmp;
+                            state = State::kHasType;
+                        }
+                        else if (state == State::kHasPayload)
+                        {
+                            type_id = tmp;
+                            ExtensionInfo extension;
+                            bool was_packed_on_wire;
+                            if (!FindExtension(2, type_id, extendee, ctx, &extension, &was_packed_on_wire))
+                            {
+                                WriteLengthDelimited(type_id, payload, metadata->mutable_unknown_fields<T>());
+                            }
+                            else
+                            {
+                                MessageLite* value =
+                                    extension.is_repeated ? AddMessage(type_id, WireFormatLite::TYPE_MESSAGE, *extension.message_info.prototype, extension.descriptor) : MutableMessage(type_id, WireFormatLite::TYPE_MESSAGE, *extension.message_info.prototype, extension.descriptor);
 
-          const char* p;
-          // We can't use regular parse from string as we have to track
-          // proper recursion depth and descriptor pools.
-          ParseContext tmp_ctx(ctx->depth(), false, &p, payload);
-          tmp_ctx.data().pool = ctx->data().pool;
-          tmp_ctx.data().factory = ctx->data().factory;
-          GOOGLE_PROTOBUF_PARSER_ASSERT(value->_InternalParse(p, &tmp_ctx) &&
-                                         tmp_ctx.EndedAtLimit());
-        }
-        state = State::kDone;
-      }
-    } else if (tag == WireFormatLite::kMessageSetMessageTag) {
-      if (state == State::kHasType) {
-        ptr = ParseFieldMaybeLazily(static_cast<uint64_t>(type_id) * 8 + 2, ptr,
-                                    extendee, metadata, ctx);
-        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
-        state = State::kDone;
-      } else {
-        std::string tmp;
-        int32_t size = ReadSize(&ptr);
-        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-        ptr = ctx->ReadString(ptr, size, &tmp);
-        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-        if (state == State::kNoTag) {
-          payload = std::move(tmp);
-          state = State::kHasPayload;
-        }
-      }
-    } else {
-      ptr = ReadTag(ptr - 1, &tag);
-      if (tag == 0 || (tag & 7) == 4) {
-        ctx->SetLastTag(tag);
-        return ptr;
-      }
-      ptr = ParseField(tag, ptr, extendee, metadata, ctx);
-      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-    }
-  }
-  return ptr;
-}
+                                const char* p;
+                                // We can't use regular parse from string as we have to track
+                                // proper recursion depth and descriptor pools.
+                                ParseContext tmp_ctx(ctx->depth(), false, &p, payload);
+                                tmp_ctx.data().pool = ctx->data().pool;
+                                tmp_ctx.data().factory = ctx->data().factory;
+                                GOOGLE_PROTOBUF_PARSER_ASSERT(value->_InternalParse(p, &tmp_ctx) && tmp_ctx.EndedAtLimit());
+                            }
+                            state = State::kDone;
+                        }
+                    }
+                    else if (tag == WireFormatLite::kMessageSetMessageTag)
+                    {
+                        if (state == State::kHasType)
+                        {
+                            ptr = ParseFieldMaybeLazily(static_cast<uint64_t>(type_id) * 8 + 2, ptr, extendee, metadata, ctx);
+                            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+                            state = State::kDone;
+                        }
+                        else
+                        {
+                            std::string tmp;
+                            int32_t size = ReadSize(&ptr);
+                            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                            ptr = ctx->ReadString(ptr, size, &tmp);
+                            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                            if (state == State::kNoTag)
+                            {
+                                payload = std::move(tmp);
+                                state = State::kHasPayload;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        ptr = ReadTag(ptr - 1, &tag);
+                        if (tag == 0 || (tag & 7) == 4)
+                        {
+                            ctx->SetLastTag(tag);
+                            return ptr;
+                        }
+                        ptr = ParseField(tag, ptr, extendee, metadata, ctx);
+                        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                    }
+                }
+                return ptr;
+            }
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_EXTENSION_SET_INL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/field_access_listener.h b/CAPI/cpp/grpc/include/google/protobuf/field_access_listener.h
index 47422e6..00fc398 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/field_access_listener.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/field_access_listener.h
@@ -36,132 +36,181 @@
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/message_lite.h>
 
-
-namespace google {
-namespace protobuf {
-
-// A default/no-op implementation of message hooks.
-//
-// See go/statically-dispatched-message-hooks for details.
-template <typename Proto>
-struct NoOpAccessListener {
-  // Number of fields are provided at compile time for the trackers to be able
-  // to have stack allocated bitmaps for the fields. This is useful for
-  // performance critical trackers. This is also to avoid cyclic dependencies
-  // if the number of fields is needed.
-  static constexpr int kFields = Proto::_kInternalFieldNumber;
-  // Default constructor is called during the static global initialization of
-  // the program.
-  // We provide a pointer to extract the name of the proto not to get cyclic
-  // dependencies on GetDescriptor() and OnGetMetadata() calls. If you want
-  // to differentiate the protos during the runtime before the start of the
-  // program, use this functor to get its name. We either way need it for
-  // LITE_RUNTIME protos as they don't have descriptors at all.
-  explicit NoOpAccessListener(StringPiece (*name_extractor)()) {}
-  // called repeatedly during serialization/deserialization/ByteSize of
-  // Reflection as:
-  //   AccessListener<MessageT>::OnSerialize(this);
-  static void OnSerialize(const MessageLite* msg) {}
-  static void OnDeserialize(const MessageLite* msg) {}
-  static void OnByteSize(const MessageLite* msg) {}
-  static void OnMergeFrom(const MessageLite* to, const MessageLite* from) {}
-
-  // NOTE: This function can be called pre-main. Make sure it does not make
-  // the state of the listener invalid.
-  static void OnGetMetadata() {}
-
-  // called from accessors as:
-  //   AccessListener<MessageT>::On$operation(this, &field_storage_);
-  // If you need to override this with type, in your hook implementation
-  // introduce
-  // template <int kFieldNum, typename T>
-  // static void On$operation(const MessageLite* msg,
-  //                          const T* field) {}
-  // And overloads for std::nullptr_t for incomplete types such as Messages,
-  // Maps. Extract them using reflection if you need. Consequently, second
-  // argument can be null pointer.
-  // For an example, see proto_hooks/testing/memory_test_field_listener.h
-  // And argument template deduction will deduce the type itself without
-  // changing the generated code.
-
-  // add_<field>(f)
-  template <int kFieldNum>
-  static void OnAdd(const MessageLite* msg, const void* field) {}
-
-  // add_<field>()
-  template <int kFieldNum>
-  static void OnAddMutable(const MessageLite* msg, const void* field) {}
-
-  // <field>() and <repeated_field>(i)
-  template <int kFieldNum>
-  static void OnGet(const MessageLite* msg, const void* field) {}
-
-  // clear_<field>()
-  template <int kFieldNum>
-  static void OnClear(const MessageLite* msg, const void* field) {}
-
-  // has_<field>()
-  template <int kFieldNum>
-  static void OnHas(const MessageLite* msg, const void* field) {}
-
-  // <repeated_field>()
-  template <int kFieldNum>
-  static void OnList(const MessageLite* msg, const void* field) {}
-
-  // mutable_<field>()
-  template <int kFieldNum>
-  static void OnMutable(const MessageLite* msg, const void* field) {}
-
-  // mutable_<repeated_field>()
-  template <int kFieldNum>
-  static void OnMutableList(const MessageLite* msg, const void* field) {}
-
-  // release_<field>()
-  template <int kFieldNum>
-  static void OnRelease(const MessageLite* msg, const void* field) {}
-
-  // set_<field>() and set_<repeated_field>(i)
-  template <int kFieldNum>
-  static void OnSet(const MessageLite* msg, const void* field) {}
-
-  // <repeated_field>_size()
-  template <int kFieldNum>
-  static void OnSize(const MessageLite* msg, const void* field) {}
-
-  static void OnHasExtension(const MessageLite* msg, int extension_tag,
-                             const void* field) {}
-  // TODO(b/190614678): Support clear in the proto compiler.
-  static void OnClearExtension(const MessageLite* msg, int extension_tag,
-                               const void* field) {}
-  static void OnExtensionSize(const MessageLite* msg, int extension_tag,
-                              const void* field) {}
-  static void OnGetExtension(const MessageLite* msg, int extension_tag,
-                             const void* field) {}
-  static void OnMutableExtension(const MessageLite* msg, int extension_tag,
-                                 const void* field) {}
-  static void OnSetExtension(const MessageLite* msg, int extension_tag,
-                             const void* field) {}
-  static void OnReleaseExtension(const MessageLite* msg, int extension_tag,
-                                 const void* field) {}
-  static void OnAddExtension(const MessageLite* msg, int extension_tag,
-                             const void* field) {}
-  static void OnAddMutableExtension(const MessageLite* msg, int extension_tag,
-                                    const void* field) {}
-  static void OnListExtension(const MessageLite* msg, int extension_tag,
-                              const void* field) {}
-  static void OnMutableListExtension(const MessageLite* msg, int extension_tag,
-                                     const void* field) {}
-};
-
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        // A default/no-op implementation of message hooks.
+        //
+        // See go/statically-dispatched-message-hooks for details.
+        template<typename Proto>
+        struct NoOpAccessListener
+        {
+            // Number of fields are provided at compile time for the trackers to be able
+            // to have stack allocated bitmaps for the fields. This is useful for
+            // performance critical trackers. This is also to avoid cyclic dependencies
+            // if the number of fields is needed.
+            static constexpr int kFields = Proto::_kInternalFieldNumber;
+            // Default constructor is called during the static global initialization of
+            // the program.
+            // We provide a pointer to extract the name of the proto not to get cyclic
+            // dependencies on GetDescriptor() and OnGetMetadata() calls. If you want
+            // to differentiate the protos during the runtime before the start of the
+            // program, use this functor to get its name. We either way need it for
+            // LITE_RUNTIME protos as they don't have descriptors at all.
+            explicit NoOpAccessListener(StringPiece (*name_extractor)())
+            {
+            }
+            // called repeatedly during serialization/deserialization/ByteSize of
+            // Reflection as:
+            //   AccessListener<MessageT>::OnSerialize(this);
+            static void OnSerialize(const MessageLite* msg)
+            {
+            }
+            static void OnDeserialize(const MessageLite* msg)
+            {
+            }
+            static void OnByteSize(const MessageLite* msg)
+            {
+            }
+            static void OnMergeFrom(const MessageLite* to, const MessageLite* from)
+            {
+            }
+
+            // NOTE: This function can be called pre-main. Make sure it does not make
+            // the state of the listener invalid.
+            static void OnGetMetadata()
+            {
+            }
+
+            // called from accessors as:
+            //   AccessListener<MessageT>::On$operation(this, &field_storage_);
+            // If you need to override this with type, in your hook implementation
+            // introduce
+            // template <int kFieldNum, typename T>
+            // static void On$operation(const MessageLite* msg,
+            //                          const T* field) {}
+            // And overloads for std::nullptr_t for incomplete types such as Messages,
+            // Maps. Extract them using reflection if you need. Consequently, second
+            // argument can be null pointer.
+            // For an example, see proto_hooks/testing/memory_test_field_listener.h
+            // And argument template deduction will deduce the type itself without
+            // changing the generated code.
+
+            // add_<field>(f)
+            template<int kFieldNum>
+            static void OnAdd(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // add_<field>()
+            template<int kFieldNum>
+            static void OnAddMutable(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // <field>() and <repeated_field>(i)
+            template<int kFieldNum>
+            static void OnGet(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // clear_<field>()
+            template<int kFieldNum>
+            static void OnClear(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // has_<field>()
+            template<int kFieldNum>
+            static void OnHas(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // <repeated_field>()
+            template<int kFieldNum>
+            static void OnList(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // mutable_<field>()
+            template<int kFieldNum>
+            static void OnMutable(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // mutable_<repeated_field>()
+            template<int kFieldNum>
+            static void OnMutableList(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // release_<field>()
+            template<int kFieldNum>
+            static void OnRelease(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // set_<field>() and set_<repeated_field>(i)
+            template<int kFieldNum>
+            static void OnSet(const MessageLite* msg, const void* field)
+            {
+            }
+
+            // <repeated_field>_size()
+            template<int kFieldNum>
+            static void OnSize(const MessageLite* msg, const void* field)
+            {
+            }
+
+            static void OnHasExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            // TODO(b/190614678): Support clear in the proto compiler.
+            static void OnClearExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnExtensionSize(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnGetExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnMutableExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnSetExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnReleaseExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnAddExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnAddMutableExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnListExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+            static void OnMutableListExtension(const MessageLite* msg, int extension_tag, const void* field)
+            {
+            }
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #ifndef REPLACE_PROTO_LISTENER_IMPL
-namespace google {
-namespace protobuf {
-template <class T>
-using AccessListener = NoOpAccessListener<T>;
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        template<class T>
+        using AccessListener = NoOpAccessListener<T>;
+    }  // namespace protobuf
 }  // namespace google
 #else
 // You can put your implementations of hooks/listeners here.
diff --git a/CAPI/cpp/grpc/include/google/protobuf/field_mask.pb.h b/CAPI/cpp/grpc/include/google/protobuf/field_mask.pb.h
index ecc6ede..adea365 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/field_mask.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/field_mask.pb.h
@@ -28,20 +28,22 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2ffield_5fmask_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ffield_5fmask_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -50,261 +52,326 @@ struct FieldMaskDefaultTypeInternal;
 PROTOBUF_EXPORT extern FieldMaskDefaultTypeInternal _FieldMask_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldMask* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldMask>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FieldMask* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FieldMask>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
 // ===================================================================
 
 class PROTOBUF_EXPORT FieldMask final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldMask) */ {
- public:
-  inline FieldMask() : FieldMask(nullptr) {}
-  ~FieldMask() override;
-  explicit PROTOBUF_CONSTEXPR FieldMask(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  FieldMask(const FieldMask& from);
-  FieldMask(FieldMask&& from) noexcept
-    : FieldMask() {
-    *this = ::std::move(from);
-  }
-
-  inline FieldMask& operator=(const FieldMask& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FieldMask& operator=(FieldMask&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldMask) */
+{
+public:
+    inline FieldMask() :
+        FieldMask(nullptr)
+    {
     }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const FieldMask& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const FieldMask* internal_default_instance() {
-    return reinterpret_cast<const FieldMask*>(
-               &_FieldMask_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(FieldMask& a, FieldMask& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FieldMask* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    ~FieldMask() override;
+    explicit PROTOBUF_CONSTEXPR FieldMask(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    FieldMask(const FieldMask& from);
+    FieldMask(FieldMask&& from) noexcept
+        :
+        FieldMask()
+    {
+        *this = ::std::move(from);
     }
-  }
-  void UnsafeArenaSwap(FieldMask* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  FieldMask* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<FieldMask>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const FieldMask& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const FieldMask& from) {
-    FieldMask::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(FieldMask* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.FieldMask";
-  }
-  protected:
-  explicit FieldMask(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kPathsFieldNumber = 1,
-  };
-  // repeated string paths = 1;
-  int paths_size() const;
-  private:
-  int _internal_paths_size() const;
-  public:
-  void clear_paths();
-  const std::string& paths(int index) const;
-  std::string* mutable_paths(int index);
-  void set_paths(int index, const std::string& value);
-  void set_paths(int index, std::string&& value);
-  void set_paths(int index, const char* value);
-  void set_paths(int index, const char* value, size_t size);
-  std::string* add_paths();
-  void add_paths(const std::string& value);
-  void add_paths(std::string&& value);
-  void add_paths(const char* value);
-  void add_paths(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& paths() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_paths();
-  private:
-  const std::string& _internal_paths(int index) const;
-  std::string* _internal_add_paths();
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.FieldMask)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> paths_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto;
+
+    inline FieldMask& operator=(const FieldMask& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline FieldMask& operator=(FieldMask&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const FieldMask& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const FieldMask* internal_default_instance()
+    {
+        return reinterpret_cast<const FieldMask*>(
+            &_FieldMask_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(FieldMask& a, FieldMask& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(FieldMask* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(FieldMask* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    FieldMask* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<FieldMask>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const FieldMask& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const FieldMask& from)
+    {
+        FieldMask::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(FieldMask* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.FieldMask";
+    }
+
+protected:
+    explicit FieldMask(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kPathsFieldNumber = 1,
+    };
+    // repeated string paths = 1;
+    int paths_size() const;
+
+private:
+    int _internal_paths_size() const;
+
+public:
+    void clear_paths();
+    const std::string& paths(int index) const;
+    std::string* mutable_paths(int index);
+    void set_paths(int index, const std::string& value);
+    void set_paths(int index, std::string&& value);
+    void set_paths(int index, const char* value);
+    void set_paths(int index, const char* value, size_t size);
+    std::string* add_paths();
+    void add_paths(const std::string& value);
+    void add_paths(std::string&& value);
+    void add_paths(const char* value);
+    void add_paths(const char* value, size_t size);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& paths() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_paths();
+
+private:
+    const std::string& _internal_paths(int index) const;
+    std::string* _internal_add_paths();
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.FieldMask)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> paths_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2ffield_5fmask_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // FieldMask
 
 // repeated string paths = 1;
-inline int FieldMask::_internal_paths_size() const {
-  return _impl_.paths_.size();
+inline int FieldMask::_internal_paths_size() const
+{
+    return _impl_.paths_.size();
 }
-inline int FieldMask::paths_size() const {
-  return _internal_paths_size();
+inline int FieldMask::paths_size() const
+{
+    return _internal_paths_size();
 }
-inline void FieldMask::clear_paths() {
-  _impl_.paths_.Clear();
+inline void FieldMask::clear_paths()
+{
+    _impl_.paths_.Clear();
 }
-inline std::string* FieldMask::add_paths() {
-  std::string* _s = _internal_add_paths();
-  // @@protoc_insertion_point(field_add_mutable:google.protobuf.FieldMask.paths)
-  return _s;
+inline std::string* FieldMask::add_paths()
+{
+    std::string* _s = _internal_add_paths();
+    // @@protoc_insertion_point(field_add_mutable:google.protobuf.FieldMask.paths)
+    return _s;
 }
-inline const std::string& FieldMask::_internal_paths(int index) const {
-  return _impl_.paths_.Get(index);
+inline const std::string& FieldMask::_internal_paths(int index) const
+{
+    return _impl_.paths_.Get(index);
 }
-inline const std::string& FieldMask::paths(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FieldMask.paths)
-  return _internal_paths(index);
+inline const std::string& FieldMask::paths(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FieldMask.paths)
+    return _internal_paths(index);
 }
-inline std::string* FieldMask::mutable_paths(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldMask.paths)
-  return _impl_.paths_.Mutable(index);
+inline std::string* FieldMask::mutable_paths(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.FieldMask.paths)
+    return _impl_.paths_.Mutable(index);
 }
-inline void FieldMask::set_paths(int index, const std::string& value) {
-  _impl_.paths_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldMask.paths)
+inline void FieldMask::set_paths(int index, const std::string& value)
+{
+    _impl_.paths_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldMask.paths)
 }
-inline void FieldMask::set_paths(int index, std::string&& value) {
-  _impl_.paths_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:google.protobuf.FieldMask.paths)
+inline void FieldMask::set_paths(int index, std::string&& value)
+{
+    _impl_.paths_.Mutable(index)->assign(std::move(value));
+    // @@protoc_insertion_point(field_set:google.protobuf.FieldMask.paths)
 }
-inline void FieldMask::set_paths(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.paths_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:google.protobuf.FieldMask.paths)
+inline void FieldMask::set_paths(int index, const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.paths_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set_char:google.protobuf.FieldMask.paths)
 }
-inline void FieldMask::set_paths(int index, const char* value, size_t size) {
-  _impl_.paths_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldMask.paths)
+inline void FieldMask::set_paths(int index, const char* value, size_t size)
+{
+    _impl_.paths_.Mutable(index)->assign(
+        reinterpret_cast<const char*>(value), size
+    );
+    // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldMask.paths)
 }
-inline std::string* FieldMask::_internal_add_paths() {
-  return _impl_.paths_.Add();
+inline std::string* FieldMask::_internal_add_paths()
+{
+    return _impl_.paths_.Add();
 }
-inline void FieldMask::add_paths(const std::string& value) {
-  _impl_.paths_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.FieldMask.paths)
+inline void FieldMask::add_paths(const std::string& value)
+{
+    _impl_.paths_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.FieldMask.paths)
 }
-inline void FieldMask::add_paths(std::string&& value) {
-  _impl_.paths_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:google.protobuf.FieldMask.paths)
+inline void FieldMask::add_paths(std::string&& value)
+{
+    _impl_.paths_.Add(std::move(value));
+    // @@protoc_insertion_point(field_add:google.protobuf.FieldMask.paths)
 }
-inline void FieldMask::add_paths(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.paths_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:google.protobuf.FieldMask.paths)
+inline void FieldMask::add_paths(const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.paths_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add_char:google.protobuf.FieldMask.paths)
 }
-inline void FieldMask::add_paths(const char* value, size_t size) {
-  _impl_.paths_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:google.protobuf.FieldMask.paths)
+inline void FieldMask::add_paths(const char* value, size_t size)
+{
+    _impl_.paths_.Add()->assign(reinterpret_cast<const char*>(value), size);
+    // @@protoc_insertion_point(field_add_pointer:google.protobuf.FieldMask.paths)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-FieldMask::paths() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.FieldMask.paths)
-  return _impl_.paths_;
+    FieldMask::paths() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.FieldMask.paths)
+    return _impl_.paths_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-FieldMask::mutable_paths() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldMask.paths)
-  return &_impl_.paths_;
+    FieldMask::mutable_paths()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldMask.paths)
+    return &_impl_.paths_;
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 
 // @@protoc_insertion_point(namespace_scope)
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_enum_reflection.h b/CAPI/cpp/grpc/include/google/protobuf/generated_enum_reflection.h
index b96a9c6..c031fac 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/generated_enum_reflection.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_enum_reflection.h
@@ -39,7 +39,6 @@
 #ifndef GOOGLE_PROTOBUF_GENERATED_ENUM_REFLECTION_H__
 #define GOOGLE_PROTOBUF_GENERATED_ENUM_REFLECTION_H__
 
-
 #include <string>
 
 #include <google/protobuf/port.h>
@@ -53,46 +52,50 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-class EnumDescriptor;
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        class EnumDescriptor;
+    }  // namespace protobuf
 }  // namespace google
 
-namespace google {
-namespace protobuf {
-
-// Returns the EnumDescriptor for enum type E, which must be a
-// proto-declared enum type.  Code generated by the protocol compiler
-// will include specializations of this template for each enum type declared.
-template <typename E>
-const EnumDescriptor* GetEnumDescriptor();
-
-namespace internal {
-
-// Helper for EnumType_Parse functions: try to parse the string 'name' as
-// an enum name of the given type, returning true and filling in value on
-// success, or returning false and leaving value unchanged on failure.
-PROTOBUF_EXPORT bool ParseNamedEnum(const EnumDescriptor* descriptor,
-                                    ConstStringParam name, int* value);
-
-template <typename EnumType>
-bool ParseNamedEnum(const EnumDescriptor* descriptor, ConstStringParam name,
-                    EnumType* value) {
-  int tmp;
-  if (!ParseNamedEnum(descriptor, name, &tmp)) return false;
-  *value = static_cast<EnumType>(tmp);
-  return true;
-}
-
-// Just a wrapper around printing the name of a value. The main point of this
-// function is not to be inlined, so that you can do this without including
-// descriptor.h.
-PROTOBUF_EXPORT const std::string& NameOfEnum(const EnumDescriptor* descriptor,
-                                              int value);
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        // Returns the EnumDescriptor for enum type E, which must be a
+        // proto-declared enum type.  Code generated by the protocol compiler
+        // will include specializations of this template for each enum type declared.
+        template<typename E>
+        const EnumDescriptor* GetEnumDescriptor();
+
+        namespace internal
+        {
+
+            // Helper for EnumType_Parse functions: try to parse the string 'name' as
+            // an enum name of the given type, returning true and filling in value on
+            // success, or returning false and leaving value unchanged on failure.
+            PROTOBUF_EXPORT bool ParseNamedEnum(const EnumDescriptor* descriptor, ConstStringParam name, int* value);
+
+            template<typename EnumType>
+            bool ParseNamedEnum(const EnumDescriptor* descriptor, ConstStringParam name, EnumType* value)
+            {
+                int tmp;
+                if (!ParseNamedEnum(descriptor, name, &tmp))
+                    return false;
+                *value = static_cast<EnumType>(tmp);
+                return true;
+            }
+
+            // Just a wrapper around printing the name of a value. The main point of this
+            // function is not to be inlined, so that you can do this without including
+            // descriptor.h.
+            PROTOBUF_EXPORT const std::string& NameOfEnum(const EnumDescriptor* descriptor, int value);
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_enum_util.h b/CAPI/cpp/grpc/include/google/protobuf/generated_enum_util.h
index 5d10ac0..06c9489 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/generated_enum_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_enum_util.h
@@ -31,7 +31,6 @@
 #ifndef GOOGLE_PROTOBUF_GENERATED_ENUM_UTIL_H__
 #define GOOGLE_PROTOBUF_GENERATED_ENUM_UTIL_H__
 
-
 #include <type_traits>
 
 #include <google/protobuf/stubs/strutil.h>
@@ -44,40 +43,43 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-// This type trait can be used to cause templates to only match proto2 enum
-// types.
-template <typename T>
-struct is_proto_enum : ::std::false_type {};
-
-namespace internal {
-
-// The table entry format for storing enum name-to-value mapping used with lite
-// protos. This struct and the following related functions should only be used
-// by protobuf generated code.
-struct EnumEntry {
-  StringPiece name;
-  int value;
-};
-
-// Looks up a numeric enum value given the string name.
-PROTOBUF_EXPORT bool LookUpEnumValue(const EnumEntry* enums, size_t size,
-                                     StringPiece name, int* value);
-
-// Looks up an enum name given the numeric value.
-PROTOBUF_EXPORT int LookUpEnumName(const EnumEntry* enums,
-                                   const int* sorted_indices, size_t size,
-                                   int value);
-
-// Initializes the list of enum names in std::string form.
-PROTOBUF_EXPORT bool InitializeEnumStrings(
-    const EnumEntry* enums, const int* sorted_indices, size_t size,
-    internal::ExplicitlyConstructed<std::string>* enum_strings);
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        // This type trait can be used to cause templates to only match proto2 enum
+        // types.
+        template<typename T>
+        struct is_proto_enum : ::std::false_type
+        {
+        };
+
+        namespace internal
+        {
+
+            // The table entry format for storing enum name-to-value mapping used with lite
+            // protos. This struct and the following related functions should only be used
+            // by protobuf generated code.
+            struct EnumEntry
+            {
+                StringPiece name;
+                int value;
+            };
+
+            // Looks up a numeric enum value given the string name.
+            PROTOBUF_EXPORT bool LookUpEnumValue(const EnumEntry* enums, size_t size, StringPiece name, int* value);
+
+            // Looks up an enum name given the numeric value.
+            PROTOBUF_EXPORT int LookUpEnumName(const EnumEntry* enums, const int* sorted_indices, size_t size, int value);
+
+            // Initializes the list of enum names in std::string form.
+            PROTOBUF_EXPORT bool InitializeEnumStrings(
+                const EnumEntry* enums, const int* sorted_indices, size_t size, internal::ExplicitlyConstructed<std::string>* enum_strings
+            );
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_bases.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_bases.h
index b295218..17f272c 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/generated_message_bases.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_bases.h
@@ -44,42 +44,57 @@
 // Must come last:
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
-// To save code size, protos without any fields are derived from ZeroFieldsBase
-// rather than Message.
-class PROTOBUF_EXPORT ZeroFieldsBase : public Message {
- public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final { return true; }
-  size_t ByteSizeLong() const final;
-  int GetCachedSize() const final { return _cached_size_.Get(); }
-  const char* _InternalParse(const char* ptr,
-                             internal::ParseContext* ctx) final;
-  ::uint8_t* _InternalSerialize(::uint8_t* target,
-                                io::EpsCopyOutputStream* stream) const final;
+            // To save code size, protos without any fields are derived from ZeroFieldsBase
+            // rather than Message.
+            class PROTOBUF_EXPORT ZeroFieldsBase : public Message
+            {
+            public:
+                PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+                bool IsInitialized() const final
+                {
+                    return true;
+                }
+                size_t ByteSizeLong() const final;
+                int GetCachedSize() const final
+                {
+                    return _cached_size_.Get();
+                }
+                const char* _InternalParse(const char* ptr, internal::ParseContext* ctx) final;
+                ::uint8_t* _InternalSerialize(::uint8_t* target, io::EpsCopyOutputStream* stream) const final;
 
- protected:
-  constexpr ZeroFieldsBase() {}
-  explicit ZeroFieldsBase(Arena* arena, bool is_message_owned)
-      : Message(arena, is_message_owned) {}
-  ZeroFieldsBase(const ZeroFieldsBase&) = delete;
-  ZeroFieldsBase& operator=(const ZeroFieldsBase&) = delete;
-  ~ZeroFieldsBase() override;
+            protected:
+                constexpr ZeroFieldsBase()
+                {
+                }
+                explicit ZeroFieldsBase(Arena* arena, bool is_message_owned) :
+                    Message(arena, is_message_owned)
+                {
+                }
+                ZeroFieldsBase(const ZeroFieldsBase&) = delete;
+                ZeroFieldsBase& operator=(const ZeroFieldsBase&) = delete;
+                ~ZeroFieldsBase() override;
 
-  void SetCachedSize(int size) const final { _cached_size_.Set(size); }
+                void SetCachedSize(int size) const final
+                {
+                    _cached_size_.Set(size);
+                }
 
-  static void MergeImpl(Message& to, const Message& from);
-  static void CopyImpl(Message& to, const Message& from);
-  void InternalSwap(ZeroFieldsBase* other);
+                static void MergeImpl(Message& to, const Message& from);
+                static void CopyImpl(Message& to, const Message& from);
+                void InternalSwap(ZeroFieldsBase* other);
 
-  mutable internal::CachedSize _cached_size_;
-};
+                mutable internal::CachedSize _cached_size_;
+            };
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_reflection.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_reflection.h
index 334b2cc..a8cd561 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/generated_message_reflection.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_reflection.h
@@ -46,7 +46,6 @@
 #include <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
@@ -54,299 +53,347 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-class MapKey;
-class MapValueRef;
-class MessageLayoutInspector;
-class Message;
-struct Metadata;
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        class MapKey;
+        class MapValueRef;
+        class MessageLayoutInspector;
+        class Message;
+        struct Metadata;
+    }  // namespace protobuf
 }  // namespace google
 
-namespace google {
-namespace protobuf {
-namespace internal {
-class DefaultEmptyOneof;
-// Defined in other files.
-class ExtensionSet;  // extension_set.h
-class WeakFieldMap;  // weak_field_map.h
-
-// This struct describes the internal layout of the message, hence this is
-// used to act on the message reflectively.
-//   default_instance:  The default instance of the message.  This is only
-//                  used to obtain pointers to default instances of embedded
-//                  messages, which GetMessage() will return if the particular
-//                  sub-message has not been initialized yet.  (Thus, all
-//                  embedded message fields *must* have non-null pointers
-//                  in the default instance.)
-//   offsets:       An array of ints giving the byte offsets.
-//                  For each oneof or weak field, the offset is relative to the
-//                  default_instance. These can be computed at compile time
-//                  using the
-//                  PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET()
-//                  macro. For each none oneof field, the offset is related to
-//                  the start of the message object.  These can be computed at
-//                  compile time using the
-//                  PROTO2_GENERATED_MESSAGE_FIELD_OFFSET() macro.
-//                  Besides offsets for all fields, this array also contains
-//                  offsets for oneof unions. The offset of the i-th oneof union
-//                  is offsets[descriptor->field_count() + i].
-//   has_bit_indices:  Mapping from field indexes to their index in the has
-//                  bit array.
-//   has_bits_offset:  Offset in the message of an array of uint32s of size
-//                  descriptor->field_count()/32, rounded up.  This is a
-//                  bitfield where each bit indicates whether or not the
-//                  corresponding field of the message has been initialized.
-//                  The bit for field index i is obtained by the expression:
-//                    has_bits[i / 32] & (1 << (i % 32))
-//   unknown_fields_offset:  Offset in the message of the UnknownFieldSet for
-//                  the message.
-//   extensions_offset:  Offset in the message of the ExtensionSet for the
-//                  message, or -1 if the message type has no extension
-//                  ranges.
-//   oneof_case_offset:  Offset in the message of an array of uint32s of
-//                  size descriptor->oneof_decl_count().  Each uint32_t
-//                  indicates what field is set for each oneof.
-//   object_size:   The size of a message object of this type, as measured
-//                  by sizeof().
-//   arena_offset:  If a message doesn't have a unknown_field_set that stores
-//                  the arena, it must have a direct pointer to the arena.
-//   weak_field_map_offset: If the message proto has weak fields, this is the
-//                  offset of _weak_field_map_ in the generated proto. Otherwise
-//                  -1.
-struct ReflectionSchema {
- public:
-  // Size of a google::protobuf::Message object of this type.
-  uint32_t GetObjectSize() const { return static_cast<uint32_t>(object_size_); }
-
-  bool InRealOneof(const FieldDescriptor* field) const {
-    return field->containing_oneof() &&
-           !field->containing_oneof()->is_synthetic();
-  }
-
-  // Offset of a non-oneof field.  Getting a field offset is slightly more
-  // efficient when we know statically that it is not a oneof field.
-  uint32_t GetFieldOffsetNonOneof(const FieldDescriptor* field) const {
-    GOOGLE_DCHECK(!InRealOneof(field));
-    return OffsetValue(offsets_[field->index()], field->type());
-  }
-
-  // Offset of any field.
-  uint32_t GetFieldOffset(const FieldDescriptor* field) const {
-    if (InRealOneof(field)) {
-      size_t offset =
-          static_cast<size_t>(field->containing_type()->field_count()) +
-          field->containing_oneof()->index();
-      return OffsetValue(offsets_[offset], field->type());
-    } else {
-      return GetFieldOffsetNonOneof(field);
-    }
-  }
-
-  bool IsFieldInlined(const FieldDescriptor* field) const {
-    return Inlined(offsets_[field->index()], field->type());
-  }
-
-  uint32_t GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const {
-    return static_cast<uint32_t>(oneof_case_offset_) +
-           static_cast<uint32_t>(
-               static_cast<size_t>(oneof_descriptor->index()) *
-               sizeof(uint32_t));
-  }
-
-  bool HasHasbits() const { return has_bits_offset_ != -1; }
-
-  // Bit index within the bit array of hasbits.  Bit order is low-to-high.
-  uint32_t HasBitIndex(const FieldDescriptor* field) const {
-    if (has_bits_offset_ == -1) return static_cast<uint32_t>(-1);
-    GOOGLE_DCHECK(HasHasbits());
-    return has_bit_indices_[field->index()];
-  }
-
-  // Byte offset of the hasbits array.
-  uint32_t HasBitsOffset() const {
-    GOOGLE_DCHECK(HasHasbits());
-    return static_cast<uint32_t>(has_bits_offset_);
-  }
-
-  bool HasInlinedString() const { return inlined_string_donated_offset_ != -1; }
-
-  // Bit index within the bit array of _inlined_string_donated_.  Bit order is
-  // low-to-high.
-  uint32_t InlinedStringIndex(const FieldDescriptor* field) const {
-    GOOGLE_DCHECK(HasInlinedString());
-    return inlined_string_indices_[field->index()];
-  }
-
-  // Byte offset of the _inlined_string_donated_ array.
-  uint32_t InlinedStringDonatedOffset() const {
-    GOOGLE_DCHECK(HasInlinedString());
-    return static_cast<uint32_t>(inlined_string_donated_offset_);
-  }
-
-  // The offset of the InternalMetadataWithArena member.
-  // For Lite this will actually be an InternalMetadataWithArenaLite.
-  // The schema doesn't contain enough information to distinguish between
-  // these two cases.
-  uint32_t GetMetadataOffset() const {
-    return static_cast<uint32_t>(metadata_offset_);
-  }
-
-  // Whether this message has an ExtensionSet.
-  bool HasExtensionSet() const { return extensions_offset_ != -1; }
-
-  // The offset of the ExtensionSet in this message.
-  uint32_t GetExtensionSetOffset() const {
-    GOOGLE_DCHECK(HasExtensionSet());
-    return static_cast<uint32_t>(extensions_offset_);
-  }
-
-  // The off set of WeakFieldMap when the message contains weak fields.
-  // The default is 0 for now.
-  int GetWeakFieldMapOffset() const { return weak_field_map_offset_; }
-
-  bool IsDefaultInstance(const Message& message) const {
-    return &message == default_instance_;
-  }
-
-  // Returns a pointer to the default value for this field.  The size and type
-  // of the underlying data depends on the field's type.
-  const void* GetFieldDefault(const FieldDescriptor* field) const {
-    return reinterpret_cast<const uint8_t*>(default_instance_) +
-           OffsetValue(offsets_[field->index()], field->type());
-  }
-
-  // Returns true if the field is implicitly backed by LazyField.
-  bool IsEagerlyVerifiedLazyField(const FieldDescriptor* field) const {
-    GOOGLE_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_MESSAGE);
-    (void)field;
-    return false;
-  }
-
-  bool IsFieldStripped(const FieldDescriptor* field) const {
-    (void)field;
-    return false;
-  }
-
-  bool IsMessageStripped(const Descriptor* descriptor) const {
-    (void)descriptor;
-    return false;
-  }
-
-
-  bool HasWeakFields() const { return weak_field_map_offset_ > 0; }
-
-  // These members are intended to be private, but we cannot actually make them
-  // private because this prevents us from using aggregate initialization of
-  // them, ie.
-  //
-  //   ReflectionSchema schema = {a, b, c, d, e, ...};
-  // private:
-  const Message* default_instance_;
-  const uint32_t* offsets_;
-  const uint32_t* has_bit_indices_;
-  int has_bits_offset_;
-  int metadata_offset_;
-  int extensions_offset_;
-  int oneof_case_offset_;
-  int object_size_;
-  int weak_field_map_offset_;
-  const uint32_t* inlined_string_indices_;
-  int inlined_string_donated_offset_;
-
-  // We tag offset values to provide additional data about fields (such as
-  // "unused" or "lazy" or "inlined").
-  static uint32_t OffsetValue(uint32_t v, FieldDescriptor::Type type) {
-    if (type == FieldDescriptor::TYPE_MESSAGE ||
-        type == FieldDescriptor::TYPE_STRING ||
-        type == FieldDescriptor::TYPE_BYTES) {
-      return v & 0xFFFFFFFEu;
-    }
-    return v;
-  }
-
-  static bool Inlined(uint32_t v, FieldDescriptor::Type type) {
-    if (type == FieldDescriptor::TYPE_STRING ||
-        type == FieldDescriptor::TYPE_BYTES) {
-      return (v & 1u) != 0u;
-    } else {
-      // Non string/byte fields are not inlined.
-      return false;
-    }
-  }
-};
-
-// Structs that the code generator emits directly to describe a message.
-// These should never used directly except to build a ReflectionSchema
-// object.
-//
-// EXPERIMENTAL: these are changing rapidly, and may completely disappear
-// or merge with ReflectionSchema.
-struct MigrationSchema {
-  int32_t offsets_index;
-  int32_t has_bit_indices_index;
-  int32_t inlined_string_indices_index;
-  int object_size;
-};
-
-// This struct tries to reduce unnecessary padding.
-// The num_xxx might not be close to their respective pointer, but this saves
-// padding.
-struct PROTOBUF_EXPORT DescriptorTable {
-  mutable bool is_initialized;
-  bool is_eager;
-  int size;  // of serialized descriptor
-  const char* descriptor;
-  const char* filename;
-  once_flag* once;
-  const DescriptorTable* const* deps;
-  int num_deps;
-  int num_messages;
-  const MigrationSchema* schemas;
-  const Message* const* default_instances;
-  const uint32_t* offsets;
-  // update the following descriptor arrays.
-  Metadata* file_level_metadata;
-  const EnumDescriptor** file_level_enum_descriptors;
-  const ServiceDescriptor** file_level_service_descriptors;
-};
-
-enum {
-  // Tag used on offsets for fields that don't have a real offset.
-  // For example, weak message fields go into the WeakFieldMap and not in an
-  // actual field.
-  kInvalidFieldOffsetTag = 0x40000000u,
-};
-
-// AssignDescriptors() pulls the compiled FileDescriptor from the DescriptorPool
-// and uses it to populate all of the global variables which store pointers to
-// the descriptor objects.  It also constructs the reflection objects.  It is
-// called the first time anyone calls descriptor() or GetReflection() on one of
-// the types defined in the file.  AssignDescriptors() is thread-safe.
-void PROTOBUF_EXPORT AssignDescriptors(const DescriptorTable* table,
-                                       bool eager = false);
-
-// Overload used to implement GetMetadataStatic in the generated code.
-// See comments in compiler/cpp/internal/file.cc as to why.
-// It takes a `Metadata` and returns it to allow for tail calls and reduce
-// binary size.
-Metadata PROTOBUF_EXPORT AssignDescriptors(const DescriptorTable* (*table)(),
-                                           internal::once_flag* once,
-                                           const Metadata& metadata);
-
-// These cannot be in lite so we put them in the reflection.
-PROTOBUF_EXPORT void UnknownFieldSetSerializer(const uint8_t* base,
-                                               uint32_t offset, uint32_t tag,
-                                               uint32_t has_offset,
-                                               io::CodedOutputStream* output);
-
-struct PROTOBUF_EXPORT AddDescriptorsRunner {
-  explicit AddDescriptorsRunner(const DescriptorTable* table);
-};
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+            class DefaultEmptyOneof;
+            // Defined in other files.
+            class ExtensionSet;  // extension_set.h
+            class WeakFieldMap;  // weak_field_map.h
+
+            // This struct describes the internal layout of the message, hence this is
+            // used to act on the message reflectively.
+            //   default_instance:  The default instance of the message.  This is only
+            //                  used to obtain pointers to default instances of embedded
+            //                  messages, which GetMessage() will return if the particular
+            //                  sub-message has not been initialized yet.  (Thus, all
+            //                  embedded message fields *must* have non-null pointers
+            //                  in the default instance.)
+            //   offsets:       An array of ints giving the byte offsets.
+            //                  For each oneof or weak field, the offset is relative to the
+            //                  default_instance. These can be computed at compile time
+            //                  using the
+            //                  PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET()
+            //                  macro. For each none oneof field, the offset is related to
+            //                  the start of the message object.  These can be computed at
+            //                  compile time using the
+            //                  PROTO2_GENERATED_MESSAGE_FIELD_OFFSET() macro.
+            //                  Besides offsets for all fields, this array also contains
+            //                  offsets for oneof unions. The offset of the i-th oneof union
+            //                  is offsets[descriptor->field_count() + i].
+            //   has_bit_indices:  Mapping from field indexes to their index in the has
+            //                  bit array.
+            //   has_bits_offset:  Offset in the message of an array of uint32s of size
+            //                  descriptor->field_count()/32, rounded up.  This is a
+            //                  bitfield where each bit indicates whether or not the
+            //                  corresponding field of the message has been initialized.
+            //                  The bit for field index i is obtained by the expression:
+            //                    has_bits[i / 32] & (1 << (i % 32))
+            //   unknown_fields_offset:  Offset in the message of the UnknownFieldSet for
+            //                  the message.
+            //   extensions_offset:  Offset in the message of the ExtensionSet for the
+            //                  message, or -1 if the message type has no extension
+            //                  ranges.
+            //   oneof_case_offset:  Offset in the message of an array of uint32s of
+            //                  size descriptor->oneof_decl_count().  Each uint32_t
+            //                  indicates what field is set for each oneof.
+            //   object_size:   The size of a message object of this type, as measured
+            //                  by sizeof().
+            //   arena_offset:  If a message doesn't have a unknown_field_set that stores
+            //                  the arena, it must have a direct pointer to the arena.
+            //   weak_field_map_offset: If the message proto has weak fields, this is the
+            //                  offset of _weak_field_map_ in the generated proto. Otherwise
+            //                  -1.
+            struct ReflectionSchema
+            {
+            public:
+                // Size of a google::protobuf::Message object of this type.
+                uint32_t GetObjectSize() const
+                {
+                    return static_cast<uint32_t>(object_size_);
+                }
+
+                bool InRealOneof(const FieldDescriptor* field) const
+                {
+                    return field->containing_oneof() &&
+                           !field->containing_oneof()->is_synthetic();
+                }
+
+                // Offset of a non-oneof field.  Getting a field offset is slightly more
+                // efficient when we know statically that it is not a oneof field.
+                uint32_t GetFieldOffsetNonOneof(const FieldDescriptor* field) const
+                {
+                    GOOGLE_DCHECK(!InRealOneof(field));
+                    return OffsetValue(offsets_[field->index()], field->type());
+                }
+
+                // Offset of any field.
+                uint32_t GetFieldOffset(const FieldDescriptor* field) const
+                {
+                    if (InRealOneof(field))
+                    {
+                        size_t offset =
+                            static_cast<size_t>(field->containing_type()->field_count()) +
+                            field->containing_oneof()->index();
+                        return OffsetValue(offsets_[offset], field->type());
+                    }
+                    else
+                    {
+                        return GetFieldOffsetNonOneof(field);
+                    }
+                }
+
+                bool IsFieldInlined(const FieldDescriptor* field) const
+                {
+                    return Inlined(offsets_[field->index()], field->type());
+                }
+
+                uint32_t GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const
+                {
+                    return static_cast<uint32_t>(oneof_case_offset_) +
+                           static_cast<uint32_t>(
+                               static_cast<size_t>(oneof_descriptor->index()) *
+                               sizeof(uint32_t)
+                           );
+                }
+
+                bool HasHasbits() const
+                {
+                    return has_bits_offset_ != -1;
+                }
+
+                // Bit index within the bit array of hasbits.  Bit order is low-to-high.
+                uint32_t HasBitIndex(const FieldDescriptor* field) const
+                {
+                    if (has_bits_offset_ == -1)
+                        return static_cast<uint32_t>(-1);
+                    GOOGLE_DCHECK(HasHasbits());
+                    return has_bit_indices_[field->index()];
+                }
+
+                // Byte offset of the hasbits array.
+                uint32_t HasBitsOffset() const
+                {
+                    GOOGLE_DCHECK(HasHasbits());
+                    return static_cast<uint32_t>(has_bits_offset_);
+                }
+
+                bool HasInlinedString() const
+                {
+                    return inlined_string_donated_offset_ != -1;
+                }
+
+                // Bit index within the bit array of _inlined_string_donated_.  Bit order is
+                // low-to-high.
+                uint32_t InlinedStringIndex(const FieldDescriptor* field) const
+                {
+                    GOOGLE_DCHECK(HasInlinedString());
+                    return inlined_string_indices_[field->index()];
+                }
+
+                // Byte offset of the _inlined_string_donated_ array.
+                uint32_t InlinedStringDonatedOffset() const
+                {
+                    GOOGLE_DCHECK(HasInlinedString());
+                    return static_cast<uint32_t>(inlined_string_donated_offset_);
+                }
+
+                // The offset of the InternalMetadataWithArena member.
+                // For Lite this will actually be an InternalMetadataWithArenaLite.
+                // The schema doesn't contain enough information to distinguish between
+                // these two cases.
+                uint32_t GetMetadataOffset() const
+                {
+                    return static_cast<uint32_t>(metadata_offset_);
+                }
+
+                // Whether this message has an ExtensionSet.
+                bool HasExtensionSet() const
+                {
+                    return extensions_offset_ != -1;
+                }
+
+                // The offset of the ExtensionSet in this message.
+                uint32_t GetExtensionSetOffset() const
+                {
+                    GOOGLE_DCHECK(HasExtensionSet());
+                    return static_cast<uint32_t>(extensions_offset_);
+                }
+
+                // The off set of WeakFieldMap when the message contains weak fields.
+                // The default is 0 for now.
+                int GetWeakFieldMapOffset() const
+                {
+                    return weak_field_map_offset_;
+                }
+
+                bool IsDefaultInstance(const Message& message) const
+                {
+                    return &message == default_instance_;
+                }
+
+                // Returns a pointer to the default value for this field.  The size and type
+                // of the underlying data depends on the field's type.
+                const void* GetFieldDefault(const FieldDescriptor* field) const
+                {
+                    return reinterpret_cast<const uint8_t*>(default_instance_) +
+                           OffsetValue(offsets_[field->index()], field->type());
+                }
+
+                // Returns true if the field is implicitly backed by LazyField.
+                bool IsEagerlyVerifiedLazyField(const FieldDescriptor* field) const
+                {
+                    GOOGLE_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_MESSAGE);
+                    (void)field;
+                    return false;
+                }
+
+                bool IsFieldStripped(const FieldDescriptor* field) const
+                {
+                    (void)field;
+                    return false;
+                }
+
+                bool IsMessageStripped(const Descriptor* descriptor) const
+                {
+                    (void)descriptor;
+                    return false;
+                }
+
+                bool HasWeakFields() const
+                {
+                    return weak_field_map_offset_ > 0;
+                }
+
+                // These members are intended to be private, but we cannot actually make them
+                // private because this prevents us from using aggregate initialization of
+                // them, ie.
+                //
+                //   ReflectionSchema schema = {a, b, c, d, e, ...};
+                // private:
+                const Message* default_instance_;
+                const uint32_t* offsets_;
+                const uint32_t* has_bit_indices_;
+                int has_bits_offset_;
+                int metadata_offset_;
+                int extensions_offset_;
+                int oneof_case_offset_;
+                int object_size_;
+                int weak_field_map_offset_;
+                const uint32_t* inlined_string_indices_;
+                int inlined_string_donated_offset_;
+
+                // We tag offset values to provide additional data about fields (such as
+                // "unused" or "lazy" or "inlined").
+                static uint32_t OffsetValue(uint32_t v, FieldDescriptor::Type type)
+                {
+                    if (type == FieldDescriptor::TYPE_MESSAGE ||
+                        type == FieldDescriptor::TYPE_STRING ||
+                        type == FieldDescriptor::TYPE_BYTES)
+                    {
+                        return v & 0xFFFFFFFEu;
+                    }
+                    return v;
+                }
+
+                static bool Inlined(uint32_t v, FieldDescriptor::Type type)
+                {
+                    if (type == FieldDescriptor::TYPE_STRING ||
+                        type == FieldDescriptor::TYPE_BYTES)
+                    {
+                        return (v & 1u) != 0u;
+                    }
+                    else
+                    {
+                        // Non string/byte fields are not inlined.
+                        return false;
+                    }
+                }
+            };
+
+            // Structs that the code generator emits directly to describe a message.
+            // These should never used directly except to build a ReflectionSchema
+            // object.
+            //
+            // EXPERIMENTAL: these are changing rapidly, and may completely disappear
+            // or merge with ReflectionSchema.
+            struct MigrationSchema
+            {
+                int32_t offsets_index;
+                int32_t has_bit_indices_index;
+                int32_t inlined_string_indices_index;
+                int object_size;
+            };
+
+            // This struct tries to reduce unnecessary padding.
+            // The num_xxx might not be close to their respective pointer, but this saves
+            // padding.
+            struct PROTOBUF_EXPORT DescriptorTable
+            {
+                mutable bool is_initialized;
+                bool is_eager;
+                int size;  // of serialized descriptor
+                const char* descriptor;
+                const char* filename;
+                once_flag* once;
+                const DescriptorTable* const* deps;
+                int num_deps;
+                int num_messages;
+                const MigrationSchema* schemas;
+                const Message* const* default_instances;
+                const uint32_t* offsets;
+                // update the following descriptor arrays.
+                Metadata* file_level_metadata;
+                const EnumDescriptor** file_level_enum_descriptors;
+                const ServiceDescriptor** file_level_service_descriptors;
+            };
+
+            enum
+            {
+                // Tag used on offsets for fields that don't have a real offset.
+                // For example, weak message fields go into the WeakFieldMap and not in an
+                // actual field.
+                kInvalidFieldOffsetTag = 0x40000000u,
+            };
+
+            // AssignDescriptors() pulls the compiled FileDescriptor from the DescriptorPool
+            // and uses it to populate all of the global variables which store pointers to
+            // the descriptor objects.  It also constructs the reflection objects.  It is
+            // called the first time anyone calls descriptor() or GetReflection() on one of
+            // the types defined in the file.  AssignDescriptors() is thread-safe.
+            void PROTOBUF_EXPORT AssignDescriptors(const DescriptorTable* table, bool eager = false);
+
+            // Overload used to implement GetMetadataStatic in the generated code.
+            // See comments in compiler/cpp/internal/file.cc as to why.
+            // It takes a `Metadata` and returns it to allow for tail calls and reduce
+            // binary size.
+            Metadata PROTOBUF_EXPORT AssignDescriptors(const DescriptorTable* (*table)(), internal::once_flag* once, const Metadata& metadata);
+
+            // These cannot be in lite so we put them in the reflection.
+            PROTOBUF_EXPORT void UnknownFieldSetSerializer(const uint8_t* base, uint32_t offset, uint32_t tag, uint32_t has_offset, io::CodedOutputStream* output);
+
+            struct PROTOBUF_EXPORT AddDescriptorsRunner
+            {
+                explicit AddDescriptorsRunner(const DescriptorTable* table);
+            };
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_decl.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_decl.h
index b1bb1de..1f4a2c5 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_decl.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_decl.h
@@ -46,73 +46,99 @@
 // Must come last:
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// Additional information about this field:
-struct TcFieldData {
-  constexpr TcFieldData() : data(0) {}
-
-  // Fast table entry constructor:
-  constexpr TcFieldData(uint16_t coded_tag, uint8_t hasbit_idx, uint8_t aux_idx,
-                        uint16_t offset)
-      : data(uint64_t{offset} << 48 |      //
-             uint64_t{aux_idx} << 24 |     //
-             uint64_t{hasbit_idx} << 16 |  //
-             uint64_t{coded_tag}) {}
-
-  // Fields used in fast table parsing:
-  //
-  //     Bit:
-  //     +-----------+-------------------+
-  //     |63    ..     32|31     ..     0|
-  //     +---------------+---------------+
-  //     :   .   :   .   :   . 16|=======| [16] coded_tag()
-  //     :   .   :   .   : 24|===|   .   : [ 8] hasbit_idx()
-  //     :   .   :   . 32|===|   :   .   : [ 8] aux_idx()
-  //     :   . 48:---.---:   .   :   .   : [16] (unused)
-  //     |=======|   .   :   .   :   .   : [16] offset()
-  //     +-----------+-------------------+
-  //     |63    ..     32|31     ..     0|
-  //     +---------------+---------------+
-
-  template <typename TagType = uint16_t>
-  TagType coded_tag() const {
-    return static_cast<TagType>(data);
-  }
-  uint8_t hasbit_idx() const { return static_cast<uint8_t>(data >> 16); }
-  uint8_t aux_idx() const { return static_cast<uint8_t>(data >> 24); }
-  uint16_t offset() const { return static_cast<uint16_t>(data >> 48); }
-
-  // Fields used in mini table parsing:
-  //
-  //     Bit:
-  //     +-----------+-------------------+
-  //     |63    ..     32|31     ..     0|
-  //     +---------------+---------------+
-  //     :   .   :   .   |===============| [32] tag() (decoded)
-  //     |===============|   .   :   .   : [32] entry_offset()
-  //     +-----------+-------------------+
-  //     |63    ..     32|31     ..     0|
-  //     +---------------+---------------+
-
-  uint32_t tag() const { return static_cast<uint32_t>(data); }
-  uint32_t entry_offset() const { return static_cast<uint32_t>(data >> 32); }
-
-  uint64_t data;
-};
-
-struct TcParseTableBase;
-
-// TailCallParseFunc is the function pointer type used in the tailcall table.
-typedef const char* (*TailCallParseFunc)(PROTOBUF_TC_PARAM_DECL);
-
-namespace field_layout {
-struct Offset {
-  uint32_t off;
-};
-}  // namespace field_layout
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // Additional information about this field:
+            struct TcFieldData
+            {
+                constexpr TcFieldData() :
+                    data(0)
+                {
+                }
+
+                // Fast table entry constructor:
+                constexpr TcFieldData(uint16_t coded_tag, uint8_t hasbit_idx, uint8_t aux_idx, uint16_t offset) :
+                    data(uint64_t{offset} << 48 |      //
+                         uint64_t{aux_idx} << 24 |     //
+                         uint64_t{hasbit_idx} << 16 |  //
+                         uint64_t{coded_tag})
+                {
+                }
+
+                // Fields used in fast table parsing:
+                //
+                //     Bit:
+                //     +-----------+-------------------+
+                //     |63    ..     32|31     ..     0|
+                //     +---------------+---------------+
+                //     :   .   :   .   :   . 16|=======| [16] coded_tag()
+                //     :   .   :   .   : 24|===|   .   : [ 8] hasbit_idx()
+                //     :   .   :   . 32|===|   :   .   : [ 8] aux_idx()
+                //     :   . 48:---.---:   .   :   .   : [16] (unused)
+                //     |=======|   .   :   .   :   .   : [16] offset()
+                //     +-----------+-------------------+
+                //     |63    ..     32|31     ..     0|
+                //     +---------------+---------------+
+
+                template<typename TagType = uint16_t>
+                TagType coded_tag() const
+                {
+                    return static_cast<TagType>(data);
+                }
+                uint8_t hasbit_idx() const
+                {
+                    return static_cast<uint8_t>(data >> 16);
+                }
+                uint8_t aux_idx() const
+                {
+                    return static_cast<uint8_t>(data >> 24);
+                }
+                uint16_t offset() const
+                {
+                    return static_cast<uint16_t>(data >> 48);
+                }
+
+                // Fields used in mini table parsing:
+                //
+                //     Bit:
+                //     +-----------+-------------------+
+                //     |63    ..     32|31     ..     0|
+                //     +---------------+---------------+
+                //     :   .   :   .   |===============| [32] tag() (decoded)
+                //     |===============|   .   :   .   : [32] entry_offset()
+                //     +-----------+-------------------+
+                //     |63    ..     32|31     ..     0|
+                //     +---------------+---------------+
+
+                uint32_t tag() const
+                {
+                    return static_cast<uint32_t>(data);
+                }
+                uint32_t entry_offset() const
+                {
+                    return static_cast<uint32_t>(data >> 32);
+                }
+
+                uint64_t data;
+            };
+
+            struct TcParseTableBase;
+
+            // TailCallParseFunc is the function pointer type used in the tailcall table.
+            typedef const char* (*TailCallParseFunc)(PROTOBUF_TC_PARAM_DECL);
+
+            namespace field_layout
+            {
+                struct Offset
+                {
+                    uint32_t off;
+                };
+            }  // namespace field_layout
 
 #if defined(_MSC_VER) && !defined(_WIN64)
 #pragma warning(push)
@@ -120,191 +146,203 @@ struct Offset {
 #pragma warning(disable : 4324)
 #endif
 
-// Base class for message-level table with info for the tail-call parser.
-struct alignas(uint64_t) TcParseTableBase {
-  // Common attributes for message layout:
-  uint16_t has_bits_offset;
-  uint16_t extension_offset;
-  uint32_t extension_range_low;
-  uint32_t extension_range_high;
-  uint32_t max_field_number;
-  uint8_t fast_idx_mask;
-  uint16_t lookup_table_offset;
-  uint32_t skipmap32;
-  uint32_t field_entries_offset;
-  uint16_t num_field_entries;
-
-  uint16_t num_aux_entries;
-  uint32_t aux_offset;
-
-  const MessageLite* default_instance;
-
-  // Handler for fields which are not handled by table dispatch.
-  TailCallParseFunc fallback;
-
-  // This constructor exactly follows the field layout, so it's technically
-  // not necessary.  However, it makes it much much easier to add or re-arrange
-  // fields, because it can be overloaded with an additional constructor,
-  // temporarily allowing both old and new protocol buffer headers to be
-  // compiled.
-  constexpr TcParseTableBase(
-      uint16_t has_bits_offset, uint16_t extension_offset,
-      uint32_t extension_range_low, uint32_t extension_range_high,
-      uint32_t max_field_number, uint8_t fast_idx_mask,
-      uint16_t lookup_table_offset, uint32_t skipmap32,
-      uint32_t field_entries_offset, uint16_t num_field_entries,
-      uint16_t num_aux_entries, uint32_t aux_offset,
-      const MessageLite* default_instance, TailCallParseFunc fallback)
-      : has_bits_offset(has_bits_offset),
-        extension_offset(extension_offset),
-        extension_range_low(extension_range_low),
-        extension_range_high(extension_range_high),
-        max_field_number(max_field_number),
-        fast_idx_mask(fast_idx_mask),
-        lookup_table_offset(lookup_table_offset),
-        skipmap32(skipmap32),
-        field_entries_offset(field_entries_offset),
-        num_field_entries(num_field_entries),
-        num_aux_entries(num_aux_entries),
-        aux_offset(aux_offset),
-        default_instance(default_instance),
-        fallback(fallback) {}
-
-  // Table entry for fast-path tailcall dispatch handling.
-  struct FastFieldEntry {
-    // Target function for dispatch:
-    TailCallParseFunc target;
-    // Field data used during parse:
-    TcFieldData bits;
-  };
-  // There is always at least one table entry.
-  const FastFieldEntry* fast_entry(size_t idx) const {
-    return reinterpret_cast<const FastFieldEntry*>(this + 1) + idx;
-  }
-
-  // Returns a begin iterator (pointer) to the start of the field lookup table.
-  const uint16_t* field_lookup_begin() const {
-    return reinterpret_cast<const uint16_t*>(reinterpret_cast<uintptr_t>(this) +
-                                             lookup_table_offset);
-  }
-
-  // Field entry for all fields.
-  struct FieldEntry {
-    uint32_t offset;     // offset in the message object
-    int32_t has_idx;     // has-bit index
-    uint16_t aux_idx;    // index for `field_aux`.
-    uint16_t type_card;  // `FieldType` and `Cardinality` (see _impl.h)
-  };
-
-  // Returns a begin iterator (pointer) to the start of the field entries array.
-  const FieldEntry* field_entries_begin() const {
-    return reinterpret_cast<const FieldEntry*>(
-        reinterpret_cast<uintptr_t>(this) + field_entries_offset);
-  }
-
-  // Auxiliary entries for field types that need extra information.
-  union FieldAux {
-    constexpr FieldAux() : message_default(nullptr) {}
-    constexpr FieldAux(bool (*enum_validator)(int))
-        : enum_validator(enum_validator) {}
-    constexpr FieldAux(field_layout::Offset off) : offset(off.off) {}
-    constexpr FieldAux(int16_t range_start, uint16_t range_length)
-        : enum_range{range_start, range_length} {}
-    constexpr FieldAux(const MessageLite* msg) : message_default(msg) {}
-    bool (*enum_validator)(int);
-    struct {
-      int16_t start;    // minimum enum number (if it fits)
-      uint16_t length;  // length of range (i.e., max = start + length - 1)
-    } enum_range;
-    uint32_t offset;
-    const MessageLite* message_default;
-  };
-  const FieldAux* field_aux(uint32_t idx) const {
-    return reinterpret_cast<const FieldAux*>(reinterpret_cast<uintptr_t>(this) +
-                                             aux_offset) +
-           idx;
-  }
-  const FieldAux* field_aux(const FieldEntry* entry) const {
-    return field_aux(entry->aux_idx);
-  }
-
-  // Field name data
-  const char* name_data() const {
-    return reinterpret_cast<const char*>(reinterpret_cast<uintptr_t>(this) +
-                                         aux_offset +
-                                         num_aux_entries * sizeof(FieldAux));
-  }
-};
+            // Base class for message-level table with info for the tail-call parser.
+            struct alignas(uint64_t) TcParseTableBase
+            {
+                // Common attributes for message layout:
+                uint16_t has_bits_offset;
+                uint16_t extension_offset;
+                uint32_t extension_range_low;
+                uint32_t extension_range_high;
+                uint32_t max_field_number;
+                uint8_t fast_idx_mask;
+                uint16_t lookup_table_offset;
+                uint32_t skipmap32;
+                uint32_t field_entries_offset;
+                uint16_t num_field_entries;
+
+                uint16_t num_aux_entries;
+                uint32_t aux_offset;
+
+                const MessageLite* default_instance;
+
+                // Handler for fields which are not handled by table dispatch.
+                TailCallParseFunc fallback;
+
+                // This constructor exactly follows the field layout, so it's technically
+                // not necessary.  However, it makes it much much easier to add or re-arrange
+                // fields, because it can be overloaded with an additional constructor,
+                // temporarily allowing both old and new protocol buffer headers to be
+                // compiled.
+                constexpr TcParseTableBase(
+                    uint16_t has_bits_offset, uint16_t extension_offset, uint32_t extension_range_low, uint32_t extension_range_high, uint32_t max_field_number, uint8_t fast_idx_mask, uint16_t lookup_table_offset, uint32_t skipmap32, uint32_t field_entries_offset, uint16_t num_field_entries, uint16_t num_aux_entries, uint32_t aux_offset, const MessageLite* default_instance, TailCallParseFunc fallback
+                ) :
+                    has_bits_offset(has_bits_offset),
+                    extension_offset(extension_offset),
+                    extension_range_low(extension_range_low),
+                    extension_range_high(extension_range_high),
+                    max_field_number(max_field_number),
+                    fast_idx_mask(fast_idx_mask),
+                    lookup_table_offset(lookup_table_offset),
+                    skipmap32(skipmap32),
+                    field_entries_offset(field_entries_offset),
+                    num_field_entries(num_field_entries),
+                    num_aux_entries(num_aux_entries),
+                    aux_offset(aux_offset),
+                    default_instance(default_instance),
+                    fallback(fallback)
+                {
+                }
+
+                // Table entry for fast-path tailcall dispatch handling.
+                struct FastFieldEntry
+                {
+                    // Target function for dispatch:
+                    TailCallParseFunc target;
+                    // Field data used during parse:
+                    TcFieldData bits;
+                };
+                // There is always at least one table entry.
+                const FastFieldEntry* fast_entry(size_t idx) const
+                {
+                    return reinterpret_cast<const FastFieldEntry*>(this + 1) + idx;
+                }
+
+                // Returns a begin iterator (pointer) to the start of the field lookup table.
+                const uint16_t* field_lookup_begin() const
+                {
+                    return reinterpret_cast<const uint16_t*>(reinterpret_cast<uintptr_t>(this) + lookup_table_offset);
+                }
+
+                // Field entry for all fields.
+                struct FieldEntry
+                {
+                    uint32_t offset;     // offset in the message object
+                    int32_t has_idx;     // has-bit index
+                    uint16_t aux_idx;    // index for `field_aux`.
+                    uint16_t type_card;  // `FieldType` and `Cardinality` (see _impl.h)
+                };
+
+                // Returns a begin iterator (pointer) to the start of the field entries array.
+                const FieldEntry* field_entries_begin() const
+                {
+                    return reinterpret_cast<const FieldEntry*>(
+                        reinterpret_cast<uintptr_t>(this) + field_entries_offset
+                    );
+                }
+
+                // Auxiliary entries for field types that need extra information.
+                union FieldAux
+                {
+                    constexpr FieldAux() :
+                        message_default(nullptr)
+                    {
+                    }
+                    constexpr FieldAux(bool (*enum_validator)(int)) :
+                        enum_validator(enum_validator)
+                    {
+                    }
+                    constexpr FieldAux(field_layout::Offset off) :
+                        offset(off.off)
+                    {
+                    }
+                    constexpr FieldAux(int16_t range_start, uint16_t range_length) :
+                        enum_range{range_start, range_length}
+                    {
+                    }
+                    constexpr FieldAux(const MessageLite* msg) :
+                        message_default(msg)
+                    {
+                    }
+                    bool (*enum_validator)(int);
+                    struct
+                    {
+                        int16_t start;    // minimum enum number (if it fits)
+                        uint16_t length;  // length of range (i.e., max = start + length - 1)
+                    } enum_range;
+                    uint32_t offset;
+                    const MessageLite* message_default;
+                };
+                const FieldAux* field_aux(uint32_t idx) const
+                {
+                    return reinterpret_cast<const FieldAux*>(reinterpret_cast<uintptr_t>(this) + aux_offset) +
+                           idx;
+                }
+                const FieldAux* field_aux(const FieldEntry* entry) const
+                {
+                    return field_aux(entry->aux_idx);
+                }
+
+                // Field name data
+                const char* name_data() const
+                {
+                    return reinterpret_cast<const char*>(reinterpret_cast<uintptr_t>(this) + aux_offset + num_aux_entries * sizeof(FieldAux));
+                }
+            };
 
 #if defined(_MSC_VER) && !defined(_WIN64)
 #pragma warning(pop)
 #endif
 
-static_assert(sizeof(TcParseTableBase::FastFieldEntry) <= 16,
-              "Fast field entry is too big.");
-static_assert(sizeof(TcParseTableBase::FieldEntry) <= 16,
-              "Field entry is too big.");
-
-template <size_t kFastTableSizeLog2, size_t kNumFieldEntries = 0,
-          size_t kNumFieldAux = 0, size_t kNameTableSize = 0,
-          size_t kFieldLookupSize = 2>
-struct TcParseTable {
-  TcParseTableBase header;
-
-  // Entries for each field.
-  //
-  // Fields are indexed by the lowest bits of their field number. The field
-  // number is masked to fit inside the table. Note that the parsing logic
-  // generally calls `TailCallParseTableBase::fast_entry()` instead of accessing
-  // this field directly.
-  std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
-      fast_entries;
-
-  // Just big enough to find all the field entries.
-  std::array<uint16_t, kFieldLookupSize> field_lookup_table;
-  // Entries for all fields:
-  std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
-  std::array<TcParseTableBase::FieldAux, kNumFieldAux> aux_entries;
-  std::array<char, kNameTableSize> field_names;
-};
-
-// Partial specialization: if there are no aux entries, there will be no array.
-// In C++, arrays cannot have length 0, but (C++11) std::array<T, 0> is valid.
-// However, different implementations have different sizeof(std::array<T, 0>).
-// Skipping the member makes offset computations portable.
-template <size_t kFastTableSizeLog2, size_t kNumFieldEntries,
-          size_t kNameTableSize, size_t kFieldLookupSize>
-struct TcParseTable<kFastTableSizeLog2, kNumFieldEntries, 0, kNameTableSize,
-                    kFieldLookupSize> {
-  TcParseTableBase header;
-  std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
-      fast_entries;
-  std::array<uint16_t, kFieldLookupSize> field_lookup_table;
-  std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
-  std::array<char, kNameTableSize> field_names;
-};
-
-// Partial specialization: if there are no fields at all, then we can save space
-// by skipping the field numbers and entries.
-template <size_t kNameTableSize, size_t kFieldLookupSize>
-struct TcParseTable<0, 0, 0, kNameTableSize, kFieldLookupSize> {
-  TcParseTableBase header;
-  // N.B.: the fast entries are sized by log2, so 2**0 fields = 1 entry.
-  // The fast parsing loop will always use this entry, so it must be present.
-  std::array<TcParseTableBase::FastFieldEntry, 1> fast_entries;
-  std::array<uint16_t, kFieldLookupSize> field_lookup_table;
-  std::array<char, kNameTableSize> field_names;
-};
-
-static_assert(std::is_standard_layout<TcParseTable<1>>::value,
-              "TcParseTable must be standard layout.");
-
-static_assert(offsetof(TcParseTable<1>, fast_entries) ==
-                  sizeof(TcParseTableBase),
-              "Table entries must be laid out after TcParseTableBase.");
-
-}  // namespace internal
-}  // namespace protobuf
+            static_assert(sizeof(TcParseTableBase::FastFieldEntry) <= 16, "Fast field entry is too big.");
+            static_assert(sizeof(TcParseTableBase::FieldEntry) <= 16, "Field entry is too big.");
+
+            template<size_t kFastTableSizeLog2, size_t kNumFieldEntries = 0, size_t kNumFieldAux = 0, size_t kNameTableSize = 0, size_t kFieldLookupSize = 2>
+            struct TcParseTable
+            {
+                TcParseTableBase header;
+
+                // Entries for each field.
+                //
+                // Fields are indexed by the lowest bits of their field number. The field
+                // number is masked to fit inside the table. Note that the parsing logic
+                // generally calls `TailCallParseTableBase::fast_entry()` instead of accessing
+                // this field directly.
+                std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
+                    fast_entries;
+
+                // Just big enough to find all the field entries.
+                std::array<uint16_t, kFieldLookupSize> field_lookup_table;
+                // Entries for all fields:
+                std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
+                std::array<TcParseTableBase::FieldAux, kNumFieldAux> aux_entries;
+                std::array<char, kNameTableSize> field_names;
+            };
+
+            // Partial specialization: if there are no aux entries, there will be no array.
+            // In C++, arrays cannot have length 0, but (C++11) std::array<T, 0> is valid.
+            // However, different implementations have different sizeof(std::array<T, 0>).
+            // Skipping the member makes offset computations portable.
+            template<size_t kFastTableSizeLog2, size_t kNumFieldEntries, size_t kNameTableSize, size_t kFieldLookupSize>
+            struct TcParseTable<kFastTableSizeLog2, kNumFieldEntries, 0, kNameTableSize, kFieldLookupSize>
+            {
+                TcParseTableBase header;
+                std::array<TcParseTableBase::FastFieldEntry, (1 << kFastTableSizeLog2)>
+                    fast_entries;
+                std::array<uint16_t, kFieldLookupSize> field_lookup_table;
+                std::array<TcParseTableBase::FieldEntry, kNumFieldEntries> field_entries;
+                std::array<char, kNameTableSize> field_names;
+            };
+
+            // Partial specialization: if there are no fields at all, then we can save space
+            // by skipping the field numbers and entries.
+            template<size_t kNameTableSize, size_t kFieldLookupSize>
+            struct TcParseTable<0, 0, 0, kNameTableSize, kFieldLookupSize>
+            {
+                TcParseTableBase header;
+                // N.B.: the fast entries are sized by log2, so 2**0 fields = 1 entry.
+                // The fast parsing loop will always use this entry, so it must be present.
+                std::array<TcParseTableBase::FastFieldEntry, 1> fast_entries;
+                std::array<uint16_t, kFieldLookupSize> field_lookup_table;
+                std::array<char, kNameTableSize> field_names;
+            };
+
+            static_assert(std::is_standard_layout<TcParseTable<1>>::value, "TcParseTable must be standard layout.");
+
+            static_assert(offsetof(TcParseTable<1>, fast_entries) == sizeof(TcParseTableBase), "Table entries must be laid out after TcParseTableBase.");
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_impl.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_impl.h
index 21fa533..1a0b077 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_impl.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_tctable_impl.h
@@ -45,35 +45,39 @@
 // Must come last:
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-class Message;
-class UnknownFieldSet;
-
-namespace internal {
-
-// Field layout enums.
-//
-// Structural information about fields is packed into a 16-bit value. The enum
-// types below represent bitwise fields, along with their respective widths,
-// shifts, and masks.
-//
-//     Bit:
-//     +-----------------------+-----------------------+
-//     |15        ..          8|7         ..          0|
-//     +-----------------------+-----------------------+
-//     :  .  :  .  :  .  :  .  :  .  :  .  : 3|========| [3] FieldType
-//     :     :     :     :     :     : 5|=====|  :     : [2] FieldCardinality
-//     :  .  :  .  :  .  :  . 8|========|  :  .  :  .  : [3] FieldRep
-//     :     :     :   10|=====|     :     :     :     : [2] TransformValidation
-//     :  .  :  .12|=====|  .  :  .  :  .  :  .  :  .  : [2] FormatDiscriminator
-//     +-----------------------+-----------------------+
-//     |15        ..          8|7         ..          0|
-//     +-----------------------+-----------------------+
-//
-namespace field_layout {
-// clang-format off
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Message;
+        class UnknownFieldSet;
+
+        namespace internal
+        {
+
+            // Field layout enums.
+            //
+            // Structural information about fields is packed into a 16-bit value. The enum
+            // types below represent bitwise fields, along with their respective widths,
+            // shifts, and masks.
+            //
+            //     Bit:
+            //     +-----------------------+-----------------------+
+            //     |15        ..          8|7         ..          0|
+            //     +-----------------------+-----------------------+
+            //     :  .  :  .  :  .  :  .  :  .  :  .  : 3|========| [3] FieldType
+            //     :     :     :     :     :     : 5|=====|  :     : [2] FieldCardinality
+            //     :  .  :  .  :  .  :  . 8|========|  :  .  :  .  : [3] FieldRep
+            //     :     :     :   10|=====|     :     :     :     : [2] TransformValidation
+            //     :  .  :  .12|=====|  .  :  .  :  .  :  .  :  .  : [2] FormatDiscriminator
+            //     +-----------------------+-----------------------+
+            //     |15        ..          8|7         ..          0|
+            //     +-----------------------+-----------------------+
+            //
+            namespace field_layout
+            {
+                // clang-format off
 
 // Field kind (3 bits):
 // These values broadly represent a wire type and an in-memory storage class.
@@ -233,8 +237,8 @@ enum FieldType : uint16_t {
   kMap             = kFkMap,
 };
 
-// clang-format on
-}  // namespace field_layout
+                // clang-format on
+            }  // namespace field_layout
 
 // PROTOBUF_TC_PARAM_DECL are the parameters for tailcall functions, it is
 // defined in port_def.inc.
@@ -247,305 +251,315 @@ enum FieldType : uint16_t {
 #define PROTOBUF_TC_PARAM_PASS msg, ptr, ctx, table, hasbits, data
 
 #ifndef NDEBUG
-template <size_t align>
+            template<size_t align>
 #ifndef _MSC_VER
-[[noreturn]]
+            [[noreturn]]
 #endif
-void AlignFail(uintptr_t address) {
-  GOOGLE_LOG(FATAL) << "Unaligned (" << align << ") access at " << address;
-}
+            void AlignFail(uintptr_t address)
+            {
+                GOOGLE_LOG(FATAL) << "Unaligned (" << align << ") access at " << address;
+            }
 
-extern template void AlignFail<4>(uintptr_t);
-extern template void AlignFail<8>(uintptr_t);
+            extern template void AlignFail<4>(uintptr_t);
+            extern template void AlignFail<8>(uintptr_t);
 #endif
 
-// TcParser implements most of the parsing logic for tailcall tables.
-class PROTOBUF_EXPORT TcParser final {
- public:
-  static const char* GenericFallback(PROTOBUF_TC_PARAM_DECL);
-  static const char* GenericFallbackLite(PROTOBUF_TC_PARAM_DECL);
-
-  static const char* ParseLoop(MessageLite* msg, const char* ptr,
-                               ParseContext* ctx,
-                               const TcParseTableBase* table);
-
-  // Functions referenced by generated fast tables (numeric types):
-  //   F: fixed      V: varint     Z: zigzag
-  //   8/32/64: storage type width (bits)
-  //   S: singular   R: repeated   P: packed
-  //   1/2: tag length (bytes)
-
-  // Fixed:
-  static const char* FastF32S1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF32S2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF32R1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF32R2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF32P1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF32P2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF64S1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF64S2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF64R1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF64R2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF64P1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastF64P2(PROTOBUF_TC_PARAM_DECL);
-
-  // Varint:
-  static const char* FastV8S1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV8S2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV8R1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV8R2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV8P1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV8P2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV32S1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV32S2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV32R1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV32R2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV32P1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV32P2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV64S1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV64S2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV64R1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV64R2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV64P1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastV64P2(PROTOBUF_TC_PARAM_DECL);
-
-  // Varint (with zigzag):
-  static const char* FastZ32S1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ32S2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ32R1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ32R2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ32P1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ32P2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ64S1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ64S2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ64R1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ64R2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ64P1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastZ64P2(PROTOBUF_TC_PARAM_DECL);
-
-  // Functions referenced by generated fast tables (closed enum):
-  //   E: closed enum (N.B.: open enums use V32, above)
-  //   r: enum range  v: enum validator (_IsValid function)
-  //   S: singular   R: repeated
-  //   1/2: tag length (bytes)
-  static const char* FastErS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastErS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastErR1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastErR2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastEvS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastEvS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastEvR1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastEvR2(PROTOBUF_TC_PARAM_DECL);
-
-  // Functions referenced by generated fast tables (string types):
-  //   B: bytes      S: string     U: UTF-8 string
-  //   (empty): ArenaStringPtr     i: InlinedString
-  //   S: singular   R: repeated
-  //   1/2: tag length (bytes)
-  static const char* FastBS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastBS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastBR1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastBR2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastSS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastSS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastSR1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastSR2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastUS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastUS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastUR1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastUR2(PROTOBUF_TC_PARAM_DECL);
-
-  static const char* FastBiS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastBiS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastSiS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastSiS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastUiS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastUiS2(PROTOBUF_TC_PARAM_DECL);
-
-  // Functions referenced by generated fast tables (message types):
-  //   M: message    G: group
-  //   S: singular   R: repeated
-  //   1/2: tag length (bytes)
-  static const char* FastMS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastMS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastMR1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastMR2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastGS1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastGS2(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastGR1(PROTOBUF_TC_PARAM_DECL);
-  static const char* FastGR2(PROTOBUF_TC_PARAM_DECL);
-
-  template <typename T>
-  static inline T& RefAt(void* x, size_t offset) {
-    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
+            // TcParser implements most of the parsing logic for tailcall tables.
+            class PROTOBUF_EXPORT TcParser final
+            {
+            public:
+                static const char* GenericFallback(PROTOBUF_TC_PARAM_DECL);
+                static const char* GenericFallbackLite(PROTOBUF_TC_PARAM_DECL);
+
+                static const char* ParseLoop(MessageLite* msg, const char* ptr, ParseContext* ctx, const TcParseTableBase* table);
+
+                // Functions referenced by generated fast tables (numeric types):
+                //   F: fixed      V: varint     Z: zigzag
+                //   8/32/64: storage type width (bits)
+                //   S: singular   R: repeated   P: packed
+                //   1/2: tag length (bytes)
+
+                // Fixed:
+                static const char* FastF32S1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF32S2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF32R1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF32R2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF32P1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF32P2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF64S1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF64S2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF64R1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF64R2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF64P1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastF64P2(PROTOBUF_TC_PARAM_DECL);
+
+                // Varint:
+                static const char* FastV8S1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV8S2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV8R1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV8R2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV8P1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV8P2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV32S1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV32S2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV32R1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV32R2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV32P1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV32P2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV64S1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV64S2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV64R1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV64R2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV64P1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastV64P2(PROTOBUF_TC_PARAM_DECL);
+
+                // Varint (with zigzag):
+                static const char* FastZ32S1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ32S2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ32R1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ32R2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ32P1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ32P2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ64S1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ64S2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ64R1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ64R2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ64P1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastZ64P2(PROTOBUF_TC_PARAM_DECL);
+
+                // Functions referenced by generated fast tables (closed enum):
+                //   E: closed enum (N.B.: open enums use V32, above)
+                //   r: enum range  v: enum validator (_IsValid function)
+                //   S: singular   R: repeated
+                //   1/2: tag length (bytes)
+                static const char* FastErS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastErS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastErR1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastErR2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastEvS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastEvS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastEvR1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastEvR2(PROTOBUF_TC_PARAM_DECL);
+
+                // Functions referenced by generated fast tables (string types):
+                //   B: bytes      S: string     U: UTF-8 string
+                //   (empty): ArenaStringPtr     i: InlinedString
+                //   S: singular   R: repeated
+                //   1/2: tag length (bytes)
+                static const char* FastBS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastBS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastBR1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastBR2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastSS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastSS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastSR1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastSR2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastUS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastUS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastUR1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastUR2(PROTOBUF_TC_PARAM_DECL);
+
+                static const char* FastBiS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastBiS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastSiS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastSiS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastUiS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastUiS2(PROTOBUF_TC_PARAM_DECL);
+
+                // Functions referenced by generated fast tables (message types):
+                //   M: message    G: group
+                //   S: singular   R: repeated
+                //   1/2: tag length (bytes)
+                static const char* FastMS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastMS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastMR1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastMR2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastGS1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastGS2(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastGR1(PROTOBUF_TC_PARAM_DECL);
+                static const char* FastGR2(PROTOBUF_TC_PARAM_DECL);
+
+                template<typename T>
+                static inline T& RefAt(void* x, size_t offset)
+                {
+                    T* target = reinterpret_cast<T*>(static_cast<char*>(x) + offset);
 #ifndef NDEBUG
-    if (PROTOBUF_PREDICT_FALSE(
-            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
-      AlignFail<alignof(T)>(reinterpret_cast<uintptr_t>(target));
-    }
+                    if (PROTOBUF_PREDICT_FALSE(
+                            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0
+                        ))
+                    {
+                        AlignFail<alignof(T)>(reinterpret_cast<uintptr_t>(target));
+                    }
 #endif
-    return *target;
-  }
-
-  template <typename T>
-  static inline const T& RefAt(const void* x, size_t offset) {
-    const T* target =
-        reinterpret_cast<const T*>(static_cast<const char*>(x) + offset);
+                    return *target;
+                }
+
+                template<typename T>
+                static inline const T& RefAt(const void* x, size_t offset)
+                {
+                    const T* target =
+                        reinterpret_cast<const T*>(static_cast<const char*>(x) + offset);
 #ifndef NDEBUG
-    if (PROTOBUF_PREDICT_FALSE(
-            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0)) {
-      AlignFail<alignof(T)>(reinterpret_cast<uintptr_t>(target));
-    }
+                    if (PROTOBUF_PREDICT_FALSE(
+                            reinterpret_cast<uintptr_t>(target) % alignof(T) != 0
+                        ))
+                    {
+                        AlignFail<alignof(T)>(reinterpret_cast<uintptr_t>(target));
+                    }
 #endif
-    return *target;
-  }
-
-  template <typename T>
-  static inline T ReadAt(const void* x, size_t offset) {
-    T out;
-    memcpy(&out, static_cast<const char*>(x) + offset, sizeof(T));
-    return out;
-  }
-
-  // Mini parsing:
-  //
-  // This function parses a field from incoming data based on metadata stored in
-  // the message definition. If the field is not defined in the message, it is
-  // stored in either the ExtensionSet (if applicable) or the UnknownFieldSet.
-  //
-  // NOTE: Currently, this function only calls the table-level fallback
-  // function, so it should only be called as the fallback from fast table
-  // parsing.
-  static const char* MiniParse(PROTOBUF_TC_PARAM_DECL);
-
- private:
-  friend class GeneratedTcTableLiteTest;
-
-  template <typename TagType, bool group_coding>
-  static inline const char* SingularParseMessageAuxImpl(PROTOBUF_TC_PARAM_DECL);
-  template <typename TagType, bool group_coding>
-  static inline const char* RepeatedParseMessageAuxImpl(PROTOBUF_TC_PARAM_DECL);
-
-  static inline PROTOBUF_ALWAYS_INLINE void SyncHasbits(
-      MessageLite* msg, uint64_t hasbits, const TcParseTableBase* table) {
-    const uint32_t has_bits_offset = table->has_bits_offset;
-    if (has_bits_offset) {
-      // Only the first 32 has-bits are updated. Nothing above those is stored,
-      // but e.g. messages without has-bits update the upper bits.
-      RefAt<uint32_t>(msg, has_bits_offset) = static_cast<uint32_t>(hasbits);
-    }
-  }
-
-  static const char* TagDispatch(PROTOBUF_TC_PARAM_DECL);
-  static const char* ToTagDispatch(PROTOBUF_TC_PARAM_DECL);
-  static const char* ToParseLoop(PROTOBUF_TC_PARAM_DECL);
-  static const char* Error(PROTOBUF_TC_PARAM_DECL);
-
-  static const char* FastUnknownEnumFallback(PROTOBUF_TC_PARAM_DECL);
-
-  class ScopedArenaSwap;
-
-  template <class MessageBaseT, class UnknownFieldsT>
-  static const char* GenericFallbackImpl(PROTOBUF_TC_PARAM_DECL) {
-#define CHK_(x) \
-  if (PROTOBUF_PREDICT_FALSE(!(x))) return nullptr /* NOLINT */
-
-    SyncHasbits(msg, hasbits, table);
-    CHK_(ptr);
-    uint32_t tag = data.tag();
-    if ((tag & 7) == WireFormatLite::WIRETYPE_END_GROUP || tag == 0) {
-      ctx->SetLastTag(tag);
-      return ptr;
-    }
-    uint32_t num = tag >> 3;
-    if (table->extension_range_low <= num &&
-        num <= table->extension_range_high) {
-      return RefAt<ExtensionSet>(msg, table->extension_offset)
-          .ParseField(tag, ptr,
-                      static_cast<const MessageBaseT*>(table->default_instance),
-                      &msg->_internal_metadata_, ctx);
-    }
-    return UnknownFieldParse(
-        tag, msg->_internal_metadata_.mutable_unknown_fields<UnknownFieldsT>(),
-        ptr, ctx);
+                    return *target;
+                }
+
+                template<typename T>
+                static inline T ReadAt(const void* x, size_t offset)
+                {
+                    T out;
+                    memcpy(&out, static_cast<const char*>(x) + offset, sizeof(T));
+                    return out;
+                }
+
+                // Mini parsing:
+                //
+                // This function parses a field from incoming data based on metadata stored in
+                // the message definition. If the field is not defined in the message, it is
+                // stored in either the ExtensionSet (if applicable) or the UnknownFieldSet.
+                //
+                // NOTE: Currently, this function only calls the table-level fallback
+                // function, so it should only be called as the fallback from fast table
+                // parsing.
+                static const char* MiniParse(PROTOBUF_TC_PARAM_DECL);
+
+            private:
+                friend class GeneratedTcTableLiteTest;
+
+                template<typename TagType, bool group_coding>
+                static inline const char* SingularParseMessageAuxImpl(PROTOBUF_TC_PARAM_DECL);
+                template<typename TagType, bool group_coding>
+                static inline const char* RepeatedParseMessageAuxImpl(PROTOBUF_TC_PARAM_DECL);
+
+                static inline PROTOBUF_ALWAYS_INLINE void SyncHasbits(
+                    MessageLite* msg, uint64_t hasbits, const TcParseTableBase* table
+                )
+                {
+                    const uint32_t has_bits_offset = table->has_bits_offset;
+                    if (has_bits_offset)
+                    {
+                        // Only the first 32 has-bits are updated. Nothing above those is stored,
+                        // but e.g. messages without has-bits update the upper bits.
+                        RefAt<uint32_t>(msg, has_bits_offset) = static_cast<uint32_t>(hasbits);
+                    }
+                }
+
+                static const char* TagDispatch(PROTOBUF_TC_PARAM_DECL);
+                static const char* ToTagDispatch(PROTOBUF_TC_PARAM_DECL);
+                static const char* ToParseLoop(PROTOBUF_TC_PARAM_DECL);
+                static const char* Error(PROTOBUF_TC_PARAM_DECL);
+
+                static const char* FastUnknownEnumFallback(PROTOBUF_TC_PARAM_DECL);
+
+                class ScopedArenaSwap;
+
+                template<class MessageBaseT, class UnknownFieldsT>
+                static const char* GenericFallbackImpl(PROTOBUF_TC_PARAM_DECL)
+                {
+#define CHK_(x)                       \
+    if (PROTOBUF_PREDICT_FALSE(!(x))) \
+    return nullptr /* NOLINT */
+
+                    SyncHasbits(msg, hasbits, table);
+                    CHK_(ptr);
+                    uint32_t tag = data.tag();
+                    if ((tag & 7) == WireFormatLite::WIRETYPE_END_GROUP || tag == 0)
+                    {
+                        ctx->SetLastTag(tag);
+                        return ptr;
+                    }
+                    uint32_t num = tag >> 3;
+                    if (table->extension_range_low <= num &&
+                        num <= table->extension_range_high)
+                    {
+                        return RefAt<ExtensionSet>(msg, table->extension_offset)
+                            .ParseField(tag, ptr, static_cast<const MessageBaseT*>(table->default_instance), &msg->_internal_metadata_, ctx);
+                    }
+                    return UnknownFieldParse(
+                        tag, msg->_internal_metadata_.mutable_unknown_fields<UnknownFieldsT>(), ptr, ctx
+                    );
 #undef CHK_
-  }
-
-  // Note: `inline` is needed on template function declarations below to avoid
-  // -Wattributes diagnostic in GCC.
-
-  // Implementations for fast fixed field parsing functions:
-  template <typename LayoutType, typename TagType>
-  static inline const char* SingularFixed(PROTOBUF_TC_PARAM_DECL);
-  template <typename LayoutType, typename TagType>
-  static inline const char* RepeatedFixed(PROTOBUF_TC_PARAM_DECL);
-  template <typename LayoutType, typename TagType>
-  static inline const char* PackedFixed(PROTOBUF_TC_PARAM_DECL);
-
-  // Implementations for fast varint field parsing functions:
-  template <typename FieldType, typename TagType, bool zigzag = false>
-  static inline const char* SingularVarint(PROTOBUF_TC_PARAM_DECL);
-  template <typename FieldType, typename TagType, bool zigzag = false>
-  static inline const char* RepeatedVarint(PROTOBUF_TC_PARAM_DECL);
-  template <typename FieldType, typename TagType, bool zigzag = false>
-  static inline const char* PackedVarint(PROTOBUF_TC_PARAM_DECL);
-
-  // Helper for ints > 127:
-  template <typename FieldType, typename TagType, bool zigzag = false>
-  static const char* SingularVarBigint(PROTOBUF_TC_PARAM_DECL);
-
-  // Implementations for fast enum field parsing functions:
-  template <typename TagType, uint16_t xform_val>
-  static inline const char* SingularEnum(PROTOBUF_TC_PARAM_DECL);
-  template <typename TagType, uint16_t xform_val>
-  static inline const char* RepeatedEnum(PROTOBUF_TC_PARAM_DECL);
-
-  // Implementations for fast string field parsing functions:
-  enum Utf8Type { kNoUtf8 = 0, kUtf8 = 1, kUtf8ValidateOnly = 2 };
-  template <typename TagType, Utf8Type utf8>
-  static inline const char* SingularString(PROTOBUF_TC_PARAM_DECL);
-  template <typename TagType, Utf8Type utf8>
-  static inline const char* RepeatedString(PROTOBUF_TC_PARAM_DECL);
-
-  // Mini field lookup:
-  static const TcParseTableBase::FieldEntry* FindFieldEntry(
-      const TcParseTableBase* table, uint32_t field_num);
-  static StringPiece MessageName(const TcParseTableBase* table);
-  static StringPiece FieldName(const TcParseTableBase* table,
-                                     const TcParseTableBase::FieldEntry*);
-  static bool ChangeOneof(const TcParseTableBase* table,
-                          const TcParseTableBase::FieldEntry& entry,
-                          uint32_t field_num, ParseContext* ctx,
-                          MessageLite* msg);
-
-  // UTF-8 validation:
-  static void ReportFastUtf8Error(uint32_t decoded_tag,
-                                  const TcParseTableBase* table);
-  static bool MpVerifyUtf8(StringPiece wire_bytes,
-                           const TcParseTableBase* table,
-                           const TcParseTableBase::FieldEntry& entry,
-                           uint16_t xform_val);
-
-  // For FindFieldEntry tests:
-  friend class FindFieldEntryTest;
-  static constexpr const uint32_t kMtSmallScanSize = 4;
-
-  // Mini parsing:
-  static const char* MpVarint(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpRepeatedVarint(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpPackedVarint(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpFixed(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpRepeatedFixed(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpPackedFixed(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpString(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpRepeatedString(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpMessage(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpRepeatedMessage(PROTOBUF_TC_PARAM_DECL);
-  static const char* MpMap(PROTOBUF_TC_PARAM_DECL);
-};
-
-}  // namespace internal
-}  // namespace protobuf
+                }
+
+                // Note: `inline` is needed on template function declarations below to avoid
+                // -Wattributes diagnostic in GCC.
+
+                // Implementations for fast fixed field parsing functions:
+                template<typename LayoutType, typename TagType>
+                static inline const char* SingularFixed(PROTOBUF_TC_PARAM_DECL);
+                template<typename LayoutType, typename TagType>
+                static inline const char* RepeatedFixed(PROTOBUF_TC_PARAM_DECL);
+                template<typename LayoutType, typename TagType>
+                static inline const char* PackedFixed(PROTOBUF_TC_PARAM_DECL);
+
+                // Implementations for fast varint field parsing functions:
+                template<typename FieldType, typename TagType, bool zigzag = false>
+                static inline const char* SingularVarint(PROTOBUF_TC_PARAM_DECL);
+                template<typename FieldType, typename TagType, bool zigzag = false>
+                static inline const char* RepeatedVarint(PROTOBUF_TC_PARAM_DECL);
+                template<typename FieldType, typename TagType, bool zigzag = false>
+                static inline const char* PackedVarint(PROTOBUF_TC_PARAM_DECL);
+
+                // Helper for ints > 127:
+                template<typename FieldType, typename TagType, bool zigzag = false>
+                static const char* SingularVarBigint(PROTOBUF_TC_PARAM_DECL);
+
+                // Implementations for fast enum field parsing functions:
+                template<typename TagType, uint16_t xform_val>
+                static inline const char* SingularEnum(PROTOBUF_TC_PARAM_DECL);
+                template<typename TagType, uint16_t xform_val>
+                static inline const char* RepeatedEnum(PROTOBUF_TC_PARAM_DECL);
+
+                // Implementations for fast string field parsing functions:
+                enum Utf8Type
+                {
+                    kNoUtf8 = 0,
+                    kUtf8 = 1,
+                    kUtf8ValidateOnly = 2
+                };
+                template<typename TagType, Utf8Type utf8>
+                static inline const char* SingularString(PROTOBUF_TC_PARAM_DECL);
+                template<typename TagType, Utf8Type utf8>
+                static inline const char* RepeatedString(PROTOBUF_TC_PARAM_DECL);
+
+                // Mini field lookup:
+                static const TcParseTableBase::FieldEntry* FindFieldEntry(
+                    const TcParseTableBase* table, uint32_t field_num
+                );
+                static StringPiece MessageName(const TcParseTableBase* table);
+                static StringPiece FieldName(const TcParseTableBase* table, const TcParseTableBase::FieldEntry*);
+                static bool ChangeOneof(const TcParseTableBase* table, const TcParseTableBase::FieldEntry& entry, uint32_t field_num, ParseContext* ctx, MessageLite* msg);
+
+                // UTF-8 validation:
+                static void ReportFastUtf8Error(uint32_t decoded_tag, const TcParseTableBase* table);
+                static bool MpVerifyUtf8(StringPiece wire_bytes, const TcParseTableBase* table, const TcParseTableBase::FieldEntry& entry, uint16_t xform_val);
+
+                // For FindFieldEntry tests:
+                friend class FindFieldEntryTest;
+                static constexpr const uint32_t kMtSmallScanSize = 4;
+
+                // Mini parsing:
+                static const char* MpVarint(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpRepeatedVarint(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpPackedVarint(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpFixed(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpRepeatedFixed(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpPackedFixed(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpString(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpRepeatedString(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpMessage(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpRepeatedMessage(PROTOBUF_TC_PARAM_DECL);
+                static const char* MpMap(PROTOBUF_TC_PARAM_DECL);
+            };
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/generated_message_util.h b/CAPI/cpp/grpc/include/google/protobuf/generated_message_util.h
index 71d15cd..1bbffa4 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/generated_message_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/generated_message_util.h
@@ -64,149 +64,167 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-class Arena;
-class Message;
-
-namespace io {
-class CodedInputStream;
-}
-
-namespace internal {
-
-template <typename To, typename From>
-inline To DownCast(From* f) {
-  return PROTOBUF_NAMESPACE_ID::internal::down_cast<To>(f);
-}
-template <typename To, typename From>
-inline To DownCast(From& f) {
-  return PROTOBUF_NAMESPACE_ID::internal::down_cast<To>(f);
-}
-
-
-// This fastpath inlines a single branch instead of having to make the
-// InitProtobufDefaults function call.
-// It also generates less inlined code than a function-scope static initializer.
-PROTOBUF_EXPORT extern std::atomic<bool> init_protobuf_defaults_state;
-PROTOBUF_EXPORT void InitProtobufDefaultsSlow();
-PROTOBUF_EXPORT inline void InitProtobufDefaults() {
-  if (PROTOBUF_PREDICT_FALSE(
-          !init_protobuf_defaults_state.load(std::memory_order_acquire))) {
-    InitProtobufDefaultsSlow();
-  }
-}
-
-// This used by proto1
-PROTOBUF_EXPORT inline const std::string& GetEmptyString() {
-  InitProtobufDefaults();
-  return GetEmptyStringAlreadyInited();
-}
-
-
-// True if IsInitialized() is true for all elements of t.  Type is expected
-// to be a RepeatedPtrField<some message type>.  It's useful to have this
-// helper here to keep the protobuf compiler from ever having to emit loops in
-// IsInitialized() methods.  We want the C++ compiler to inline this or not
-// as it sees fit.
-template <typename Msg>
-bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
-  for (int i = t.size(); --i >= 0;) {
-    if (!t.Get(i).IsInitialized()) return false;
-  }
-  return true;
-}
-
-// "Weak" variant of AllAreInitialized, used to implement implicit weak fields.
-// This version operates on MessageLite to avoid introducing a dependency on the
-// concrete message type.
-template <class T>
-bool AllAreInitializedWeak(const RepeatedPtrField<T>& t) {
-  for (int i = t.size(); --i >= 0;) {
-    if (!reinterpret_cast<const RepeatedPtrFieldBase&>(t)
-             .Get<ImplicitWeakTypeHandler<T> >(i)
-             .IsInitialized()) {
-      return false;
-    }
-  }
-  return true;
-}
-
-inline bool IsPresent(const void* base, uint32_t hasbit) {
-  const uint32_t* has_bits_array = static_cast<const uint32_t*>(base);
-  return (has_bits_array[hasbit / 32] & (1u << (hasbit & 31))) != 0;
-}
-
-inline bool IsOneofPresent(const void* base, uint32_t offset, uint32_t tag) {
-  const uint32_t* oneof = reinterpret_cast<const uint32_t*>(
-      static_cast<const uint8_t*>(base) + offset);
-  return *oneof == tag >> 3;
-}
-
-typedef void (*SpecialSerializer)(const uint8_t* base, uint32_t offset,
-                                  uint32_t tag, uint32_t has_offset,
-                                  io::CodedOutputStream* output);
-
-PROTOBUF_EXPORT void ExtensionSerializer(const MessageLite* extendee,
-                                         const uint8_t* ptr, uint32_t offset,
-                                         uint32_t tag, uint32_t has_offset,
-                                         io::CodedOutputStream* output);
-PROTOBUF_EXPORT void UnknownFieldSerializerLite(const uint8_t* base,
-                                                uint32_t offset, uint32_t tag,
-                                                uint32_t has_offset,
-                                                io::CodedOutputStream* output);
-
-PROTOBUF_EXPORT MessageLite* DuplicateIfNonNullInternal(MessageLite* message);
-PROTOBUF_EXPORT MessageLite* GetOwnedMessageInternal(Arena* message_arena,
-                                                     MessageLite* submessage,
-                                                     Arena* submessage_arena);
-PROTOBUF_EXPORT void GenericSwap(MessageLite* m1, MessageLite* m2);
-// We specialize GenericSwap for non-lite messages to benefit from reflection.
-PROTOBUF_EXPORT void GenericSwap(Message* m1, Message* m2);
-
-template <typename T>
-T* DuplicateIfNonNull(T* message) {
-  // The casts must be reinterpret_cast<> because T might be a forward-declared
-  // type that the compiler doesn't know is related to MessageLite.
-  return reinterpret_cast<T*>(
-      DuplicateIfNonNullInternal(reinterpret_cast<MessageLite*>(message)));
-}
-
-template <typename T>
-T* GetOwnedMessage(Arena* message_arena, T* submessage,
-                   Arena* submessage_arena) {
-  // The casts must be reinterpret_cast<> because T might be a forward-declared
-  // type that the compiler doesn't know is related to MessageLite.
-  return reinterpret_cast<T*>(GetOwnedMessageInternal(
-      message_arena, reinterpret_cast<MessageLite*>(submessage),
-      submessage_arena));
-}
-
-// Hide atomic from the public header and allow easy change to regular int
-// on platforms where the atomic might have a perf impact.
-class PROTOBUF_EXPORT CachedSize {
- public:
-  int Get() const { return size_.load(std::memory_order_relaxed); }
-  void Set(int size) { size_.store(size, std::memory_order_relaxed); }
-
- private:
-  std::atomic<int> size_{0};
-};
-
-PROTOBUF_EXPORT void DestroyMessage(const void* message);
-PROTOBUF_EXPORT void DestroyString(const void* s);
-// Destroy (not delete) the message
-inline void OnShutdownDestroyMessage(const void* ptr) {
-  OnShutdownRun(DestroyMessage, ptr);
-}
-// Destroy the string (call std::string destructor)
-inline void OnShutdownDestroyString(const std::string* ptr) {
-  OnShutdownRun(DestroyString, ptr);
-}
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Arena;
+        class Message;
+
+        namespace io
+        {
+            class CodedInputStream;
+        }
+
+        namespace internal
+        {
+
+            template<typename To, typename From>
+            inline To DownCast(From* f)
+            {
+                return PROTOBUF_NAMESPACE_ID::internal::down_cast<To>(f);
+            }
+            template<typename To, typename From>
+            inline To DownCast(From& f)
+            {
+                return PROTOBUF_NAMESPACE_ID::internal::down_cast<To>(f);
+            }
+
+            // This fastpath inlines a single branch instead of having to make the
+            // InitProtobufDefaults function call.
+            // It also generates less inlined code than a function-scope static initializer.
+            PROTOBUF_EXPORT extern std::atomic<bool> init_protobuf_defaults_state;
+            PROTOBUF_EXPORT void InitProtobufDefaultsSlow();
+            PROTOBUF_EXPORT inline void InitProtobufDefaults()
+            {
+                if (PROTOBUF_PREDICT_FALSE(
+                        !init_protobuf_defaults_state.load(std::memory_order_acquire)
+                    ))
+                {
+                    InitProtobufDefaultsSlow();
+                }
+            }
+
+            // This used by proto1
+            PROTOBUF_EXPORT inline const std::string& GetEmptyString()
+            {
+                InitProtobufDefaults();
+                return GetEmptyStringAlreadyInited();
+            }
+
+            // True if IsInitialized() is true for all elements of t.  Type is expected
+            // to be a RepeatedPtrField<some message type>.  It's useful to have this
+            // helper here to keep the protobuf compiler from ever having to emit loops in
+            // IsInitialized() methods.  We want the C++ compiler to inline this or not
+            // as it sees fit.
+            template<typename Msg>
+            bool AllAreInitialized(const RepeatedPtrField<Msg>& t)
+            {
+                for (int i = t.size(); --i >= 0;)
+                {
+                    if (!t.Get(i).IsInitialized())
+                        return false;
+                }
+                return true;
+            }
+
+            // "Weak" variant of AllAreInitialized, used to implement implicit weak fields.
+            // This version operates on MessageLite to avoid introducing a dependency on the
+            // concrete message type.
+            template<class T>
+            bool AllAreInitializedWeak(const RepeatedPtrField<T>& t)
+            {
+                for (int i = t.size(); --i >= 0;)
+                {
+                    if (!reinterpret_cast<const RepeatedPtrFieldBase&>(t)
+                             .Get<ImplicitWeakTypeHandler<T>>(i)
+                             .IsInitialized())
+                    {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            inline bool IsPresent(const void* base, uint32_t hasbit)
+            {
+                const uint32_t* has_bits_array = static_cast<const uint32_t*>(base);
+                return (has_bits_array[hasbit / 32] & (1u << (hasbit & 31))) != 0;
+            }
+
+            inline bool IsOneofPresent(const void* base, uint32_t offset, uint32_t tag)
+            {
+                const uint32_t* oneof = reinterpret_cast<const uint32_t*>(
+                    static_cast<const uint8_t*>(base) + offset
+                );
+                return *oneof == tag >> 3;
+            }
+
+            typedef void (*SpecialSerializer)(const uint8_t* base, uint32_t offset, uint32_t tag, uint32_t has_offset, io::CodedOutputStream* output);
+
+            PROTOBUF_EXPORT void ExtensionSerializer(const MessageLite* extendee, const uint8_t* ptr, uint32_t offset, uint32_t tag, uint32_t has_offset, io::CodedOutputStream* output);
+            PROTOBUF_EXPORT void UnknownFieldSerializerLite(const uint8_t* base, uint32_t offset, uint32_t tag, uint32_t has_offset, io::CodedOutputStream* output);
+
+            PROTOBUF_EXPORT MessageLite* DuplicateIfNonNullInternal(MessageLite* message);
+            PROTOBUF_EXPORT MessageLite* GetOwnedMessageInternal(Arena* message_arena, MessageLite* submessage, Arena* submessage_arena);
+            PROTOBUF_EXPORT void GenericSwap(MessageLite* m1, MessageLite* m2);
+            // We specialize GenericSwap for non-lite messages to benefit from reflection.
+            PROTOBUF_EXPORT void GenericSwap(Message* m1, Message* m2);
+
+            template<typename T>
+            T* DuplicateIfNonNull(T* message)
+            {
+                // The casts must be reinterpret_cast<> because T might be a forward-declared
+                // type that the compiler doesn't know is related to MessageLite.
+                return reinterpret_cast<T*>(
+                    DuplicateIfNonNullInternal(reinterpret_cast<MessageLite*>(message))
+                );
+            }
+
+            template<typename T>
+            T* GetOwnedMessage(Arena* message_arena, T* submessage, Arena* submessage_arena)
+            {
+                // The casts must be reinterpret_cast<> because T might be a forward-declared
+                // type that the compiler doesn't know is related to MessageLite.
+                return reinterpret_cast<T*>(GetOwnedMessageInternal(
+                    message_arena, reinterpret_cast<MessageLite*>(submessage), submessage_arena
+                ));
+            }
+
+            // Hide atomic from the public header and allow easy change to regular int
+            // on platforms where the atomic might have a perf impact.
+            class PROTOBUF_EXPORT CachedSize
+            {
+            public:
+                int Get() const
+                {
+                    return size_.load(std::memory_order_relaxed);
+                }
+                void Set(int size)
+                {
+                    size_.store(size, std::memory_order_relaxed);
+                }
+
+            private:
+                std::atomic<int> size_{0};
+            };
+
+            PROTOBUF_EXPORT void DestroyMessage(const void* message);
+            PROTOBUF_EXPORT void DestroyString(const void* s);
+            // Destroy (not delete) the message
+            inline void OnShutdownDestroyMessage(const void* ptr)
+            {
+                OnShutdownRun(DestroyMessage, ptr);
+            }
+            // Destroy the string (call std::string destructor)
+            inline void OnShutdownDestroyString(const std::string* ptr)
+            {
+                OnShutdownRun(DestroyString, ptr);
+            }
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/has_bits.h b/CAPI/cpp/grpc/include/google/protobuf/has_bits.h
index f8a4587..e4859f3 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/has_bits.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/has_bits.h
@@ -41,75 +41,96 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-template <size_t doublewords>
-class HasBits {
- public:
-  PROTOBUF_NDEBUG_INLINE constexpr HasBits() : has_bits_{} {}
-
-  PROTOBUF_NDEBUG_INLINE void Clear() {
-    memset(has_bits_, 0, sizeof(has_bits_));
-  }
-
-  PROTOBUF_NDEBUG_INLINE uint32_t& operator[](int index) {
-    return has_bits_[index];
-  }
-
-  PROTOBUF_NDEBUG_INLINE const uint32_t& operator[](int index) const {
-    return has_bits_[index];
-  }
-
-  bool operator==(const HasBits<doublewords>& rhs) const {
-    return memcmp(has_bits_, rhs.has_bits_, sizeof(has_bits_)) == 0;
-  }
-
-  bool operator!=(const HasBits<doublewords>& rhs) const {
-    return !(*this == rhs);
-  }
-
-  void Or(const HasBits<doublewords>& rhs) {
-    for (size_t i = 0; i < doublewords; i++) has_bits_[i] |= rhs[i];
-  }
-
-  bool empty() const;
-
- private:
-  uint32_t has_bits_[doublewords];
-};
-
-template <>
-inline bool HasBits<1>::empty() const {
-  return !has_bits_[0];
-}
-
-template <>
-inline bool HasBits<2>::empty() const {
-  return !(has_bits_[0] | has_bits_[1]);
-}
-
-template <>
-inline bool HasBits<3>::empty() const {
-  return !(has_bits_[0] | has_bits_[1] | has_bits_[2]);
-}
-
-template <>
-inline bool HasBits<4>::empty() const {
-  return !(has_bits_[0] | has_bits_[1] | has_bits_[2] | has_bits_[3]);
-}
-
-template <size_t doublewords>
-inline bool HasBits<doublewords>::empty() const {
-  for (size_t i = 0; i < doublewords; ++i) {
-    if (has_bits_[i]) return false;
-  }
-  return true;
-}
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            template<size_t doublewords>
+            class HasBits
+            {
+            public:
+                PROTOBUF_NDEBUG_INLINE constexpr HasBits() :
+                    has_bits_{}
+                {
+                }
+
+                PROTOBUF_NDEBUG_INLINE void Clear()
+                {
+                    memset(has_bits_, 0, sizeof(has_bits_));
+                }
+
+                PROTOBUF_NDEBUG_INLINE uint32_t& operator[](int index)
+                {
+                    return has_bits_[index];
+                }
+
+                PROTOBUF_NDEBUG_INLINE const uint32_t& operator[](int index) const
+                {
+                    return has_bits_[index];
+                }
+
+                bool operator==(const HasBits<doublewords>& rhs) const
+                {
+                    return memcmp(has_bits_, rhs.has_bits_, sizeof(has_bits_)) == 0;
+                }
+
+                bool operator!=(const HasBits<doublewords>& rhs) const
+                {
+                    return !(*this == rhs);
+                }
+
+                void Or(const HasBits<doublewords>& rhs)
+                {
+                    for (size_t i = 0; i < doublewords; i++)
+                        has_bits_[i] |= rhs[i];
+                }
+
+                bool empty() const;
+
+            private:
+                uint32_t has_bits_[doublewords];
+            };
+
+            template<>
+            inline bool HasBits<1>::empty() const
+            {
+                return !has_bits_[0];
+            }
+
+            template<>
+            inline bool HasBits<2>::empty() const
+            {
+                return !(has_bits_[0] | has_bits_[1]);
+            }
+
+            template<>
+            inline bool HasBits<3>::empty() const
+            {
+                return !(has_bits_[0] | has_bits_[1] | has_bits_[2]);
+            }
+
+            template<>
+            inline bool HasBits<4>::empty() const
+            {
+                return !(has_bits_[0] | has_bits_[1] | has_bits_[2] | has_bits_[3]);
+            }
+
+            template<size_t doublewords>
+            inline bool HasBits<doublewords>::empty() const
+            {
+                for (size_t i = 0; i < doublewords; ++i)
+                {
+                    if (has_bits_[i])
+                        return false;
+                }
+                return true;
+            }
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/implicit_weak_message.h b/CAPI/cpp/grpc/include/google/protobuf/implicit_weak_message.h
index b894ab4..9295af4 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/implicit_weak_message.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/implicit_weak_message.h
@@ -48,164 +48,246 @@
 // This file is logically internal-only and should only be used by protobuf
 // generated code.
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// An implementation of MessageLite that treats all data as unknown. This type
-// acts as a placeholder for an implicit weak field in the case where the true
-// message type does not get linked into the binary.
-class PROTOBUF_EXPORT ImplicitWeakMessage : public MessageLite {
- public:
-  ImplicitWeakMessage() : data_(new std::string) {}
-  explicit constexpr ImplicitWeakMessage(ConstantInitialized)
-      : data_(nullptr) {}
-  explicit ImplicitWeakMessage(Arena* arena)
-      : MessageLite(arena), data_(new std::string) {}
-
-  ~ImplicitWeakMessage() override {
-    // data_ will be null in the default instance, but we can safely call delete
-    // here because the default instance will never be destroyed.
-    delete data_;
-  }
-
-  static const ImplicitWeakMessage* default_instance();
-
-  std::string GetTypeName() const override { return ""; }
-
-  MessageLite* New(Arena* arena) const override {
-    return Arena::CreateMessage<ImplicitWeakMessage>(arena);
-  }
-
-  void Clear() override { data_->clear(); }
-
-  bool IsInitialized() const override { return true; }
-
-  void CheckTypeAndMergeFrom(const MessageLite& other) override {
-    const std::string* other_data =
-        static_cast<const ImplicitWeakMessage&>(other).data_;
-    if (other_data != nullptr) {
-      data_->append(*other_data);
-    }
-  }
-
-  const char* _InternalParse(const char* ptr, ParseContext* ctx) final;
-
-  size_t ByteSizeLong() const override {
-    return data_ == nullptr ? 0 : data_->size();
-  }
-
-  uint8_t* _InternalSerialize(uint8_t* target,
-                              io::EpsCopyOutputStream* stream) const final {
-    if (data_ == nullptr) {
-      return target;
-    }
-    return stream->WriteRaw(data_->data(), static_cast<int>(data_->size()),
-                            target);
-  }
-
-  int GetCachedSize() const override {
-    return data_ == nullptr ? 0 : static_cast<int>(data_->size());
-  }
-
-  typedef void InternalArenaConstructable_;
-
- private:
-  // This std::string is allocated on the heap, but we use a raw pointer so that
-  // the default instance can be constant-initialized. In the const methods, we
-  // have to handle the possibility of data_ being null.
-  std::string* data_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImplicitWeakMessage);
-};
-
-struct ImplicitWeakMessageDefaultType;
-extern ImplicitWeakMessageDefaultType implicit_weak_message_default_instance;
-
-// A type handler for use with implicit weak repeated message fields.
-template <typename ImplicitWeakType>
-class ImplicitWeakTypeHandler {
- public:
-  typedef MessageLite Type;
-  static constexpr bool Moveable = false;
-
-  static inline MessageLite* NewFromPrototype(const MessageLite* prototype,
-                                              Arena* arena = nullptr) {
-    return prototype->New(arena);
-  }
-
-  static inline void Delete(MessageLite* value, Arena* arena) {
-    if (arena == nullptr) {
-      delete value;
-    }
-  }
-  static inline Arena* GetArena(MessageLite* value) {
-    return value->GetArena();
-  }
-  static inline void Clear(MessageLite* value) { value->Clear(); }
-  static void Merge(const MessageLite& from, MessageLite* to) {
-    to->CheckTypeAndMergeFrom(from);
-  }
-};
-
-}  // namespace internal
-
-template <typename T>
-struct WeakRepeatedPtrField {
-  using TypeHandler = internal::ImplicitWeakTypeHandler<T>;
-  constexpr WeakRepeatedPtrField() : weak() {}
-  explicit WeakRepeatedPtrField(Arena* arena) : weak(arena) {}
-  ~WeakRepeatedPtrField() { weak.template Destroy<TypeHandler>(); }
-
-  typedef internal::RepeatedPtrIterator<MessageLite> iterator;
-  typedef internal::RepeatedPtrIterator<const MessageLite> const_iterator;
-  typedef internal::RepeatedPtrOverPtrsIterator<MessageLite*, void*>
-      pointer_iterator;
-  typedef internal::RepeatedPtrOverPtrsIterator<const MessageLite* const,
-                                                const void* const>
-      const_pointer_iterator;
-
-  iterator begin() { return iterator(base().raw_data()); }
-  const_iterator begin() const { return iterator(base().raw_data()); }
-  const_iterator cbegin() const { return begin(); }
-  iterator end() { return begin() + base().size(); }
-  const_iterator end() const { return begin() + base().size(); }
-  const_iterator cend() const { return end(); }
-  pointer_iterator pointer_begin() {
-    return pointer_iterator(base().raw_mutable_data());
-  }
-  const_pointer_iterator pointer_begin() const {
-    return const_pointer_iterator(base().raw_mutable_data());
-  }
-  pointer_iterator pointer_end() {
-    return pointer_iterator(base().raw_mutable_data() + base().size());
-  }
-  const_pointer_iterator pointer_end() const {
-    return const_pointer_iterator(base().raw_mutable_data() + base().size());
-  }
-
-  MessageLite* AddWeak(const MessageLite* prototype) {
-    return base().AddWeak(prototype);
-  }
-  T* Add() { return weak.Add(); }
-  void Clear() { base().template Clear<TypeHandler>(); }
-  void MergeFrom(const WeakRepeatedPtrField& other) {
-    base().template MergeFrom<TypeHandler>(other.base());
-  }
-  void InternalSwap(WeakRepeatedPtrField* other) {
-    base().InternalSwap(&other->base());
-  }
-
-  const internal::RepeatedPtrFieldBase& base() const { return weak; }
-  internal::RepeatedPtrFieldBase& base() { return weak; }
-  // Union disables running the destructor. Which would create a strong link.
-  // Instead we explicitly destroy the underlying base through the virtual
-  // destructor.
-  union {
-    RepeatedPtrField<T> weak;
-  };
-};
-
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // An implementation of MessageLite that treats all data as unknown. This type
+            // acts as a placeholder for an implicit weak field in the case where the true
+            // message type does not get linked into the binary.
+            class PROTOBUF_EXPORT ImplicitWeakMessage : public MessageLite
+            {
+            public:
+                ImplicitWeakMessage() :
+                    data_(new std::string)
+                {
+                }
+                explicit constexpr ImplicitWeakMessage(ConstantInitialized) :
+                    data_(nullptr)
+                {
+                }
+                explicit ImplicitWeakMessage(Arena* arena) :
+                    MessageLite(arena),
+                    data_(new std::string)
+                {
+                }
+
+                ~ImplicitWeakMessage() override
+                {
+                    // data_ will be null in the default instance, but we can safely call delete
+                    // here because the default instance will never be destroyed.
+                    delete data_;
+                }
+
+                static const ImplicitWeakMessage* default_instance();
+
+                std::string GetTypeName() const override
+                {
+                    return "";
+                }
+
+                MessageLite* New(Arena* arena) const override
+                {
+                    return Arena::CreateMessage<ImplicitWeakMessage>(arena);
+                }
+
+                void Clear() override
+                {
+                    data_->clear();
+                }
+
+                bool IsInitialized() const override
+                {
+                    return true;
+                }
+
+                void CheckTypeAndMergeFrom(const MessageLite& other) override
+                {
+                    const std::string* other_data =
+                        static_cast<const ImplicitWeakMessage&>(other).data_;
+                    if (other_data != nullptr)
+                    {
+                        data_->append(*other_data);
+                    }
+                }
+
+                const char* _InternalParse(const char* ptr, ParseContext* ctx) final;
+
+                size_t ByteSizeLong() const override
+                {
+                    return data_ == nullptr ? 0 : data_->size();
+                }
+
+                uint8_t* _InternalSerialize(uint8_t* target, io::EpsCopyOutputStream* stream) const final
+                {
+                    if (data_ == nullptr)
+                    {
+                        return target;
+                    }
+                    return stream->WriteRaw(data_->data(), static_cast<int>(data_->size()), target);
+                }
+
+                int GetCachedSize() const override
+                {
+                    return data_ == nullptr ? 0 : static_cast<int>(data_->size());
+                }
+
+                typedef void InternalArenaConstructable_;
+
+            private:
+                // This std::string is allocated on the heap, but we use a raw pointer so that
+                // the default instance can be constant-initialized. In the const methods, we
+                // have to handle the possibility of data_ being null.
+                std::string* data_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ImplicitWeakMessage);
+            };
+
+            struct ImplicitWeakMessageDefaultType;
+            extern ImplicitWeakMessageDefaultType implicit_weak_message_default_instance;
+
+            // A type handler for use with implicit weak repeated message fields.
+            template<typename ImplicitWeakType>
+            class ImplicitWeakTypeHandler
+            {
+            public:
+                typedef MessageLite Type;
+                static constexpr bool Moveable = false;
+
+                static inline MessageLite* NewFromPrototype(const MessageLite* prototype, Arena* arena = nullptr)
+                {
+                    return prototype->New(arena);
+                }
+
+                static inline void Delete(MessageLite* value, Arena* arena)
+                {
+                    if (arena == nullptr)
+                    {
+                        delete value;
+                    }
+                }
+                static inline Arena* GetArena(MessageLite* value)
+                {
+                    return value->GetArena();
+                }
+                static inline void Clear(MessageLite* value)
+                {
+                    value->Clear();
+                }
+                static void Merge(const MessageLite& from, MessageLite* to)
+                {
+                    to->CheckTypeAndMergeFrom(from);
+                }
+            };
+
+        }  // namespace internal
+
+        template<typename T>
+        struct WeakRepeatedPtrField
+        {
+            using TypeHandler = internal::ImplicitWeakTypeHandler<T>;
+            constexpr WeakRepeatedPtrField() :
+                weak()
+            {
+            }
+            explicit WeakRepeatedPtrField(Arena* arena) :
+                weak(arena)
+            {
+            }
+            ~WeakRepeatedPtrField()
+            {
+                weak.template Destroy<TypeHandler>();
+            }
+
+            typedef internal::RepeatedPtrIterator<MessageLite> iterator;
+            typedef internal::RepeatedPtrIterator<const MessageLite> const_iterator;
+            typedef internal::RepeatedPtrOverPtrsIterator<MessageLite*, void*>
+                pointer_iterator;
+            typedef internal::RepeatedPtrOverPtrsIterator<const MessageLite* const, const void* const>
+                const_pointer_iterator;
+
+            iterator begin()
+            {
+                return iterator(base().raw_data());
+            }
+            const_iterator begin() const
+            {
+                return iterator(base().raw_data());
+            }
+            const_iterator cbegin() const
+            {
+                return begin();
+            }
+            iterator end()
+            {
+                return begin() + base().size();
+            }
+            const_iterator end() const
+            {
+                return begin() + base().size();
+            }
+            const_iterator cend() const
+            {
+                return end();
+            }
+            pointer_iterator pointer_begin()
+            {
+                return pointer_iterator(base().raw_mutable_data());
+            }
+            const_pointer_iterator pointer_begin() const
+            {
+                return const_pointer_iterator(base().raw_mutable_data());
+            }
+            pointer_iterator pointer_end()
+            {
+                return pointer_iterator(base().raw_mutable_data() + base().size());
+            }
+            const_pointer_iterator pointer_end() const
+            {
+                return const_pointer_iterator(base().raw_mutable_data() + base().size());
+            }
+
+            MessageLite* AddWeak(const MessageLite* prototype)
+            {
+                return base().AddWeak(prototype);
+            }
+            T* Add()
+            {
+                return weak.Add();
+            }
+            void Clear()
+            {
+                base().template Clear<TypeHandler>();
+            }
+            void MergeFrom(const WeakRepeatedPtrField& other)
+            {
+                base().template MergeFrom<TypeHandler>(other.base());
+            }
+            void InternalSwap(WeakRepeatedPtrField* other)
+            {
+                base().InternalSwap(&other->base());
+            }
+
+            const internal::RepeatedPtrFieldBase& base() const
+            {
+                return weak;
+            }
+            internal::RepeatedPtrFieldBase& base()
+            {
+                return weak;
+            }
+            // Union disables running the destructor. Which would create a strong link.
+            // Instead we explicitly destroy the underlying base through the virtual
+            // destructor.
+            union
+            {
+                RepeatedPtrField<T> weak;
+            };
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/inlined_string_field.h b/CAPI/cpp/grpc/include/google/protobuf/inlined_string_field.h
index 79e37d4..7aea7bc 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/inlined_string_field.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/inlined_string_field.h
@@ -48,483 +48,509 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-class Arena;
-
-namespace internal {
-
-// InlinedStringField wraps a std::string instance and exposes an API similar to
-// ArenaStringPtr's wrapping of a std::string* instance.
-//
-// default_value parameters are taken for consistency with ArenaStringPtr, but
-// are not used for most methods. With inlining, these should be removed from
-// the generated binary.
-//
-// InlinedStringField has a donating mechanism that allows string buffer
-// allocated on arena. A string is donated means both the string container and
-// the data buffer are on arena. The donating mechanism here is similar to the
-// one in ArenaStringPtr with some differences:
-//
-// When an InlinedStringField is constructed, the donating state is true. This
-// is because the string container is directly stored in the message on the
-// arena:
-//
-//   Construction: donated=true
-//   Arena:
-//   +-----------------------+
-//   |Message foo:           |
-//   | +-------------------+ |
-//   | |InlinedStringField:| |
-//   | | +-----+           | |
-//   | | | | | |           | |
-//   | | +-----+           | |
-//   | +-------------------+ |
-//   +-----------------------+
-//
-// When lvalue Set is called, the donating state is still true. String data will
-// be allocated on the arena:
-//
-//   Lvalue Set: donated=true
-//   Arena:
-//   +-----------------------+
-//   |Message foo:           |
-//   | +-------------------+ |
-//   | |InlinedStringField:| |
-//   | | +-----+           | |
-//   | | | | | |           | |
-//   | | +|----+           | |
-//   | +--|----------------+ |
-//   |    V                  |
-//   |  +----------------+   |
-//   |  |'f','o','o',... |   |
-//   |  +----------------+   |
-//   +-----------------------+
-//
-// Some operations will undonate a donated string, including: Mutable,
-// SetAllocated, Rvalue Set, and Swap with a non-donated string.
-//
-// For more details of the donating states transitions, go/pd-inlined-string.
-class PROTOBUF_EXPORT InlinedStringField {
- public:
-  InlinedStringField() { Init(); }
-  inline void Init() { new (get_mutable()) std::string(); }
-  // Add the dummy parameter just to make InlinedStringField(nullptr)
-  // unambiguous.
-  constexpr InlinedStringField(
-      const ExplicitlyConstructed<std::string>* /*default_value*/,
-      bool /*dummy*/)
-      : value_{} {}
-  explicit InlinedStringField(const std::string& default_value);
-  explicit InlinedStringField(Arena* arena);
-  ~InlinedStringField() { Destruct(); }
-
-  // Lvalue Set. To save space, we pack the donating states of multiple
-  // InlinedStringFields into an uint32_t `donating_states`. The `mask`
-  // indicates the position of the bit for this InlinedStringField. `donated` is
-  // whether this field is donated.
-  //
-  // The caller should guarantee that:
-  //
-  //   `donated == ((donating_states & ~mask) != 0)`
-  //
-  // This method never changes the `donating_states`.
-  void Set(ConstStringParam value, Arena* arena, bool donated,
-           uint32_t* donating_states, uint32_t mask, MessageLite* msg);
-
-  // Rvalue Set. If this field is donated, this method will undonate this field
-  // by mutating the `donating_states` according to `mask`.
-  void Set(std::string&& value, Arena* arena, bool donated,
-           uint32_t* donating_states, uint32_t mask, MessageLite* msg);
-
-  void Set(const char* str, ::google::protobuf::Arena* arena, bool donated,
-           uint32_t* donating_states, uint32_t mask, MessageLite* msg);
-
-  void Set(const char* str, size_t size, ::google::protobuf::Arena* arena, bool donated,
-           uint32_t* donating_states, uint32_t mask, MessageLite* msg);
-
-  template <typename RefWrappedType>
-  void Set(std::reference_wrapper<RefWrappedType> const_string_ref,
-           ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-           uint32_t mask, MessageLite* msg);
-
-  void SetBytes(ConstStringParam value, Arena* arena, bool donated,
-                uint32_t* donating_states, uint32_t mask, MessageLite* msg);
-
-  void SetBytes(std::string&& value, Arena* arena, bool donated,
-                uint32_t* donating_states, uint32_t mask, MessageLite* msg);
-
-  void SetBytes(const char* str, ::google::protobuf::Arena* arena, bool donated,
-                uint32_t* donating_states, uint32_t mask, MessageLite* msg);
-
-  void SetBytes(const void* p, size_t size, ::google::protobuf::Arena* arena,
-                bool donated, uint32_t* donating_states, uint32_t mask,
-                MessageLite* msg);
-
-  template <typename RefWrappedType>
-  void SetBytes(std::reference_wrapper<RefWrappedType> const_string_ref,
-                ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-                uint32_t mask, MessageLite* msg);
-
-  PROTOBUF_NDEBUG_INLINE void SetNoArena(StringPiece value);
-  PROTOBUF_NDEBUG_INLINE void SetNoArena(std::string&& value);
-
-  // Basic accessors.
-  PROTOBUF_NDEBUG_INLINE const std::string& Get() const { return GetNoArena(); }
-  PROTOBUF_NDEBUG_INLINE const std::string& GetNoArena() const;
-
-  // Mutable returns a std::string* instance that is heap-allocated. If this
-  // field is donated, this method undonates this field by mutating the
-  // `donating_states` according to `mask`, and copies the content of the
-  // original string to the returning string.
-  std::string* Mutable(Arena* arena, bool donated, uint32_t* donating_states,
-                       uint32_t mask, MessageLite* msg);
-  std::string* Mutable(const LazyString& default_value, Arena* arena,
-                       bool donated, uint32_t* donating_states, uint32_t mask,
-                       MessageLite* msg);
-
-  // Mutable(nullptr_t) is an overload to explicitly support Mutable(nullptr)
-  // calls used by the internal parser logic. This provides API equivalence with
-  // ArenaStringPtr, while still protecting against calls with arena pointers.
-  std::string* Mutable(std::nullptr_t);
-  std::string* MutableNoCopy(std::nullptr_t);
-
-  // Takes a std::string that is heap-allocated, and takes ownership. The
-  // std::string's destructor is registered with the arena. Used to implement
-  // set_allocated_<field> in generated classes.
-  //
-  // If this field is donated, this method undonates this field by mutating the
-  // `donating_states` according to `mask`.
-  void SetAllocated(const std::string* default_value, std::string* value,
-                    Arena* arena, bool donated, uint32_t* donating_states,
-                    uint32_t mask, MessageLite* msg);
-
-  void SetAllocatedNoArena(const std::string* default_value,
-                           std::string* value);
-
-  // Release returns a std::string* instance that is heap-allocated and is not
-  // Own()'d by any arena. If the field is not set, this returns nullptr. The
-  // caller retains ownership. Clears this field back to nullptr state. Used to
-  // implement release_<field>() methods on generated classes.
-  PROTOBUF_NODISCARD std::string* Release(Arena* arena, bool donated);
-  PROTOBUF_NODISCARD std::string* Release();
-
-  // --------------------------------------------------------
-  // Below functions will be removed in subsequent code change
-  // --------------------------------------------------------
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Arena;
+
+        namespace internal
+        {
+
+            // InlinedStringField wraps a std::string instance and exposes an API similar to
+            // ArenaStringPtr's wrapping of a std::string* instance.
+            //
+            // default_value parameters are taken for consistency with ArenaStringPtr, but
+            // are not used for most methods. With inlining, these should be removed from
+            // the generated binary.
+            //
+            // InlinedStringField has a donating mechanism that allows string buffer
+            // allocated on arena. A string is donated means both the string container and
+            // the data buffer are on arena. The donating mechanism here is similar to the
+            // one in ArenaStringPtr with some differences:
+            //
+            // When an InlinedStringField is constructed, the donating state is true. This
+            // is because the string container is directly stored in the message on the
+            // arena:
+            //
+            //   Construction: donated=true
+            //   Arena:
+            //   +-----------------------+
+            //   |Message foo:           |
+            //   | +-------------------+ |
+            //   | |InlinedStringField:| |
+            //   | | +-----+           | |
+            //   | | | | | |           | |
+            //   | | +-----+           | |
+            //   | +-------------------+ |
+            //   +-----------------------+
+            //
+            // When lvalue Set is called, the donating state is still true. String data will
+            // be allocated on the arena:
+            //
+            //   Lvalue Set: donated=true
+            //   Arena:
+            //   +-----------------------+
+            //   |Message foo:           |
+            //   | +-------------------+ |
+            //   | |InlinedStringField:| |
+            //   | | +-----+           | |
+            //   | | | | | |           | |
+            //   | | +|----+           | |
+            //   | +--|----------------+ |
+            //   |    V                  |
+            //   |  +----------------+   |
+            //   |  |'f','o','o',... |   |
+            //   |  +----------------+   |
+            //   +-----------------------+
+            //
+            // Some operations will undonate a donated string, including: Mutable,
+            // SetAllocated, Rvalue Set, and Swap with a non-donated string.
+            //
+            // For more details of the donating states transitions, go/pd-inlined-string.
+            class PROTOBUF_EXPORT InlinedStringField
+            {
+            public:
+                InlinedStringField()
+                {
+                    Init();
+                }
+                inline void Init()
+                {
+                    new (get_mutable()) std::string();
+                }
+                // Add the dummy parameter just to make InlinedStringField(nullptr)
+                // unambiguous.
+                constexpr InlinedStringField(
+                    const ExplicitlyConstructed<std::string>* /*default_value*/,
+                    bool /*dummy*/
+                ) :
+                    value_{}
+                {
+                }
+                explicit InlinedStringField(const std::string& default_value);
+                explicit InlinedStringField(Arena* arena);
+                ~InlinedStringField()
+                {
+                    Destruct();
+                }
+
+                // Lvalue Set. To save space, we pack the donating states of multiple
+                // InlinedStringFields into an uint32_t `donating_states`. The `mask`
+                // indicates the position of the bit for this InlinedStringField. `donated` is
+                // whether this field is donated.
+                //
+                // The caller should guarantee that:
+                //
+                //   `donated == ((donating_states & ~mask) != 0)`
+                //
+                // This method never changes the `donating_states`.
+                void Set(ConstStringParam value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                // Rvalue Set. If this field is donated, this method will undonate this field
+                // by mutating the `donating_states` according to `mask`.
+                void Set(std::string&& value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                void Set(const char* str, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                void Set(const char* str, size_t size, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                template<typename RefWrappedType>
+                void Set(std::reference_wrapper<RefWrappedType> const_string_ref, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                void SetBytes(ConstStringParam value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                void SetBytes(std::string&& value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                void SetBytes(const char* str, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                void SetBytes(const void* p, size_t size, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                template<typename RefWrappedType>
+                void SetBytes(std::reference_wrapper<RefWrappedType> const_string_ref, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                PROTOBUF_NDEBUG_INLINE void SetNoArena(StringPiece value);
+                PROTOBUF_NDEBUG_INLINE void SetNoArena(std::string&& value);
+
+                // Basic accessors.
+                PROTOBUF_NDEBUG_INLINE const std::string& Get() const
+                {
+                    return GetNoArena();
+                }
+                PROTOBUF_NDEBUG_INLINE const std::string& GetNoArena() const;
+
+                // Mutable returns a std::string* instance that is heap-allocated. If this
+                // field is donated, this method undonates this field by mutating the
+                // `donating_states` according to `mask`, and copies the content of the
+                // original string to the returning string.
+                std::string* Mutable(Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+                std::string* Mutable(const LazyString& default_value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                // Mutable(nullptr_t) is an overload to explicitly support Mutable(nullptr)
+                // calls used by the internal parser logic. This provides API equivalence with
+                // ArenaStringPtr, while still protecting against calls with arena pointers.
+                std::string* Mutable(std::nullptr_t);
+                std::string* MutableNoCopy(std::nullptr_t);
+
+                // Takes a std::string that is heap-allocated, and takes ownership. The
+                // std::string's destructor is registered with the arena. Used to implement
+                // set_allocated_<field> in generated classes.
+                //
+                // If this field is donated, this method undonates this field by mutating the
+                // `donating_states` according to `mask`.
+                void SetAllocated(const std::string* default_value, std::string* value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                void SetAllocatedNoArena(const std::string* default_value, std::string* value);
+
+                // Release returns a std::string* instance that is heap-allocated and is not
+                // Own()'d by any arena. If the field is not set, this returns nullptr. The
+                // caller retains ownership. Clears this field back to nullptr state. Used to
+                // implement release_<field>() methods on generated classes.
+                PROTOBUF_NODISCARD std::string* Release(Arena* arena, bool donated);
+                PROTOBUF_NODISCARD std::string* Release();
+
+                // --------------------------------------------------------
+                // Below functions will be removed in subsequent code change
+                // --------------------------------------------------------
 #ifdef DEPRECATED_METHODS_TO_BE_DELETED
-  PROTOBUF_NODISCARD std::string* Release(const std::string*, Arena* arena,
-                                          bool donated) {
-    return Release(arena, donated);
-  }
-
-  PROTOBUF_NODISCARD std::string* ReleaseNonDefault(const std::string*,
-                                                    Arena* arena) {
-    return Release();
-  }
-
-  std::string* ReleaseNonDefaultNoArena(const std::string* default_value) {
-    return Release();
-  }
-
-  void Set(const std::string*, ConstStringParam value, Arena* arena,
-           bool donated, uint32_t* donating_states, uint32_t mask,
-           MessageLite* msg) {
-    Set(value, arena, donated, donating_states, mask, msg);
-  }
-
-  void Set(const std::string*, std::string&& value, Arena* arena, bool donated,
-           uint32_t* donating_states, uint32_t mask, MessageLite* msg) {
-    Set(std::move(value), arena, donated, donating_states, mask, msg);
-  }
-
-
-  template <typename FirstParam>
-  void Set(FirstParam, const char* str, ::google::protobuf::Arena* arena, bool donated,
-           uint32_t* donating_states, uint32_t mask, MessageLite* msg) {
-    Set(str, arena, donated, donating_states, mask, msg);
-  }
-
-  template <typename FirstParam>
-  void Set(FirstParam p1, const char* str, size_t size, ::google::protobuf::Arena* arena,
-           bool donated, uint32_t* donating_states, uint32_t mask,
-           MessageLite* msg) {
-    Set(str, size, arena, donated, donating_states, mask, msg);
-  }
-
-  template <typename FirstParam, typename RefWrappedType>
-  void Set(FirstParam p1,
-           std::reference_wrapper<RefWrappedType> const_string_ref,
-           ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-           uint32_t mask, MessageLite* msg) {
-    Set(const_string_ref, arena, donated, donating_states, mask, msg);
-  }
-
-  void SetBytes(const std::string*, ConstStringParam value, Arena* arena,
-                bool donated, uint32_t* donating_states, uint32_t mask,
-                MessageLite* msg) {
-    Set(value, arena, donated, donating_states, mask, msg);
-  }
-
-
-  void SetBytes(const std::string*, std::string&& value, Arena* arena,
-                bool donated, uint32_t* donating_states, uint32_t mask,
-                MessageLite* msg) {
-    Set(std::move(value), arena, donated, donating_states, mask, msg);
-  }
-
-  template <typename FirstParam>
-  void SetBytes(FirstParam p1, const char* str, ::google::protobuf::Arena* arena,
-                bool donated, uint32_t* donating_states, uint32_t mask,
-                MessageLite* msg) {
-    SetBytes(str, arena, donated, donating_states, mask, msg);
-  }
-
-  template <typename FirstParam>
-  void SetBytes(FirstParam p1, const void* p, size_t size,
-                ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-                uint32_t mask, MessageLite* msg) {
-    SetBytes(p, size, arena, donated, donating_states, mask, msg);
-  }
-
-  template <typename FirstParam, typename RefWrappedType>
-  void SetBytes(FirstParam p1,
-                std::reference_wrapper<RefWrappedType> const_string_ref,
-                ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-                uint32_t mask, MessageLite* msg) {
-    SetBytes(const_string_ref.get(), arena, donated, donating_states, mask,
-             msg);
-  }
-
-  void SetNoArena(const std::string*, StringPiece value) {
-    SetNoArena(value);
-  }
-  void SetNoArena(const std::string*, std::string&& value) {
-    SetNoArena(std::move(value));
-  }
-
-  std::string* Mutable(ArenaStringPtr::EmptyDefault, Arena* arena, bool donated,
-                       uint32_t* donating_states, uint32_t mask,
-                       MessageLite* msg) {
-    return Mutable(arena, donated, donating_states, mask, msg);
-  }
-
-  PROTOBUF_NDEBUG_INLINE std::string* MutableNoArenaNoDefault(
-      const std::string* /*default_value*/) {
-    return MutableNoCopy(nullptr);
-  }
+                PROTOBUF_NODISCARD std::string* Release(const std::string*, Arena* arena, bool donated)
+                {
+                    return Release(arena, donated);
+                }
+
+                PROTOBUF_NODISCARD std::string* ReleaseNonDefault(const std::string*, Arena* arena)
+                {
+                    return Release();
+                }
+
+                std::string* ReleaseNonDefaultNoArena(const std::string* default_value)
+                {
+                    return Release();
+                }
+
+                void Set(const std::string*, ConstStringParam value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    Set(value, arena, donated, donating_states, mask, msg);
+                }
+
+                void Set(const std::string*, std::string&& value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    Set(std::move(value), arena, donated, donating_states, mask, msg);
+                }
+
+                template<typename FirstParam>
+                void Set(FirstParam, const char* str, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    Set(str, arena, donated, donating_states, mask, msg);
+                }
+
+                template<typename FirstParam>
+                void Set(FirstParam p1, const char* str, size_t size, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    Set(str, size, arena, donated, donating_states, mask, msg);
+                }
+
+                template<typename FirstParam, typename RefWrappedType>
+                void Set(FirstParam p1, std::reference_wrapper<RefWrappedType> const_string_ref, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    Set(const_string_ref, arena, donated, donating_states, mask, msg);
+                }
+
+                void SetBytes(const std::string*, ConstStringParam value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    Set(value, arena, donated, donating_states, mask, msg);
+                }
+
+                void SetBytes(const std::string*, std::string&& value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    Set(std::move(value), arena, donated, donating_states, mask, msg);
+                }
+
+                template<typename FirstParam>
+                void SetBytes(FirstParam p1, const char* str, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    SetBytes(str, arena, donated, donating_states, mask, msg);
+                }
+
+                template<typename FirstParam>
+                void SetBytes(FirstParam p1, const void* p, size_t size, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    SetBytes(p, size, arena, donated, donating_states, mask, msg);
+                }
+
+                template<typename FirstParam, typename RefWrappedType>
+                void SetBytes(FirstParam p1, std::reference_wrapper<RefWrappedType> const_string_ref, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    SetBytes(const_string_ref.get(), arena, donated, donating_states, mask, msg);
+                }
+
+                void SetNoArena(const std::string*, StringPiece value)
+                {
+                    SetNoArena(value);
+                }
+                void SetNoArena(const std::string*, std::string&& value)
+                {
+                    SetNoArena(std::move(value));
+                }
+
+                std::string* Mutable(ArenaStringPtr::EmptyDefault, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+                {
+                    return Mutable(arena, donated, donating_states, mask, msg);
+                }
+
+                PROTOBUF_NDEBUG_INLINE std::string* MutableNoArenaNoDefault(
+                    const std::string* /*default_value*/
+                )
+                {
+                    return MutableNoCopy(nullptr);
+                }
 
 #endif  // DEPRECATED_METHODS_TO_BE_DELETED
 
-  // Arena-safety semantics: this is guarded by the logic in
-  // Swap()/UnsafeArenaSwap() at the message level, so this method is
-  // 'unsafe' if called directly.
-  inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(
-      InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
-      MessageLite* lhs_msg,  //
-      InlinedStringField* rhs, Arena* rhs_arena, bool rhs_arena_dtor_registered,
-      MessageLite* rhs_msg);
-
-  // Frees storage (if not on an arena).
-  PROTOBUF_NDEBUG_INLINE void Destroy(const std::string* default_value,
-                                      Arena* arena) {
-    if (arena == nullptr) {
-      DestroyNoArena(default_value);
-    }
-  }
-  PROTOBUF_NDEBUG_INLINE void DestroyNoArena(const std::string* default_value);
-
-  // Clears content, but keeps allocated std::string, to avoid the overhead of
-  // heap operations. After this returns, the content (as seen by the user) will
-  // always be the empty std::string.
-  PROTOBUF_NDEBUG_INLINE void ClearToEmpty() { ClearNonDefaultToEmpty(); }
-  PROTOBUF_NDEBUG_INLINE void ClearNonDefaultToEmpty() {
-    get_mutable()->clear();
-  }
-
-  // Clears content, but keeps allocated std::string if arena != nullptr, to
-  // avoid the overhead of heap operations. After this returns, the content (as
-  // seen by the user) will always be equal to |default_value|.
-  void ClearToDefault(const LazyString& default_value, Arena* arena,
-                      bool donated);
-
-  // Generated code / reflection only! Returns a mutable pointer to the string.
-  PROTOBUF_NDEBUG_INLINE std::string* UnsafeMutablePointer();
-
-  // InlinedStringField doesn't have things like the `default_value` pointer in
-  // ArenaStringPtr.
-  static constexpr bool IsDefault() { return false; }
-  static constexpr bool IsDefault(const std::string*) { return false; }
-
- private:
-  void Destruct() { get_mutable()->~basic_string(); }
-
-  PROTOBUF_NDEBUG_INLINE std::string* get_mutable();
-  PROTOBUF_NDEBUG_INLINE const std::string* get_const() const;
-
-  alignas(std::string) char value_[sizeof(std::string)];
-
-  std::string* MutableSlow(::google::protobuf::Arena* arena, bool donated,
-                           uint32_t* donating_states, uint32_t mask,
-                           MessageLite* msg);
-
-
-  // When constructed in an Arena, we want our destructor to be skipped.
-  friend class ::google::protobuf::Arena;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-};
-
-inline std::string* InlinedStringField::get_mutable() {
-  return reinterpret_cast<std::string*>(&value_);
-}
-
-inline const std::string* InlinedStringField::get_const() const {
-  return reinterpret_cast<const std::string*>(&value_);
-}
-
-inline InlinedStringField::InlinedStringField(
-    const std::string& default_value) {
-  new (get_mutable()) std::string(default_value);
-}
-
-
-inline InlinedStringField::InlinedStringField(Arena* /*arena*/) { Init(); }
-
-inline const std::string& InlinedStringField::GetNoArena() const {
-  return *get_const();
-}
-
-inline void InlinedStringField::SetAllocatedNoArena(
-    const std::string* /*default_value*/, std::string* value) {
-  if (value == nullptr) {
-    // Currently, inlined string field can't have non empty default.
-    get_mutable()->clear();
-  } else {
-    get_mutable()->assign(std::move(*value));
-    delete value;
-  }
-}
-
-inline void InlinedStringField::DestroyNoArena(const std::string*) {
-  // This is invoked from the generated message's ArenaDtor, which is used to
-  // clean up objects not allocated on the Arena.
-  this->~InlinedStringField();
-}
-
-inline void InlinedStringField::SetNoArena(StringPiece value) {
-  get_mutable()->assign(value.data(), value.length());
-}
-
-inline void InlinedStringField::SetNoArena(std::string&& value) {
-  get_mutable()->assign(std::move(value));
-}
-
-// Caller should make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
-inline PROTOBUF_NDEBUG_INLINE void InlinedStringField::InternalSwap(
-    InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
-    MessageLite* lhs_msg,  //
-    InlinedStringField* rhs, Arena* rhs_arena, bool rhs_arena_dtor_registered,
-    MessageLite* rhs_msg) {
+                // Arena-safety semantics: this is guarded by the logic in
+                // Swap()/UnsafeArenaSwap() at the message level, so this method is
+                // 'unsafe' if called directly.
+                inline PROTOBUF_NDEBUG_INLINE static void InternalSwap(
+                    InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
+                    MessageLite* lhs_msg,  //
+                    InlinedStringField* rhs,
+                    Arena* rhs_arena,
+                    bool rhs_arena_dtor_registered,
+                    MessageLite* rhs_msg
+                );
+
+                // Frees storage (if not on an arena).
+                PROTOBUF_NDEBUG_INLINE void Destroy(const std::string* default_value, Arena* arena)
+                {
+                    if (arena == nullptr)
+                    {
+                        DestroyNoArena(default_value);
+                    }
+                }
+                PROTOBUF_NDEBUG_INLINE void DestroyNoArena(const std::string* default_value);
+
+                // Clears content, but keeps allocated std::string, to avoid the overhead of
+                // heap operations. After this returns, the content (as seen by the user) will
+                // always be the empty std::string.
+                PROTOBUF_NDEBUG_INLINE void ClearToEmpty()
+                {
+                    ClearNonDefaultToEmpty();
+                }
+                PROTOBUF_NDEBUG_INLINE void ClearNonDefaultToEmpty()
+                {
+                    get_mutable()->clear();
+                }
+
+                // Clears content, but keeps allocated std::string if arena != nullptr, to
+                // avoid the overhead of heap operations. After this returns, the content (as
+                // seen by the user) will always be equal to |default_value|.
+                void ClearToDefault(const LazyString& default_value, Arena* arena, bool donated);
+
+                // Generated code / reflection only! Returns a mutable pointer to the string.
+                PROTOBUF_NDEBUG_INLINE std::string* UnsafeMutablePointer();
+
+                // InlinedStringField doesn't have things like the `default_value` pointer in
+                // ArenaStringPtr.
+                static constexpr bool IsDefault()
+                {
+                    return false;
+                }
+                static constexpr bool IsDefault(const std::string*)
+                {
+                    return false;
+                }
+
+            private:
+                void Destruct()
+                {
+                    get_mutable()->~basic_string();
+                }
+
+                PROTOBUF_NDEBUG_INLINE std::string* get_mutable();
+                PROTOBUF_NDEBUG_INLINE const std::string* get_const() const;
+
+                alignas(std::string) char value_[sizeof(std::string)];
+
+                std::string* MutableSlow(::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg);
+
+                // When constructed in an Arena, we want our destructor to be skipped.
+                friend class ::google::protobuf::Arena;
+                typedef void InternalArenaConstructable_;
+                typedef void DestructorSkippable_;
+            };
+
+            inline std::string* InlinedStringField::get_mutable()
+            {
+                return reinterpret_cast<std::string*>(&value_);
+            }
+
+            inline const std::string* InlinedStringField::get_const() const
+            {
+                return reinterpret_cast<const std::string*>(&value_);
+            }
+
+            inline InlinedStringField::InlinedStringField(
+                const std::string& default_value
+            )
+            {
+                new (get_mutable()) std::string(default_value);
+            }
+
+            inline InlinedStringField::InlinedStringField(Arena* /*arena*/)
+            {
+                Init();
+            }
+
+            inline const std::string& InlinedStringField::GetNoArena() const
+            {
+                return *get_const();
+            }
+
+            inline void InlinedStringField::SetAllocatedNoArena(
+                const std::string* /*default_value*/, std::string* value
+            )
+            {
+                if (value == nullptr)
+                {
+                    // Currently, inlined string field can't have non empty default.
+                    get_mutable()->clear();
+                }
+                else
+                {
+                    get_mutable()->assign(std::move(*value));
+                    delete value;
+                }
+            }
+
+            inline void InlinedStringField::DestroyNoArena(const std::string*)
+            {
+                // This is invoked from the generated message's ArenaDtor, which is used to
+                // clean up objects not allocated on the Arena.
+                this->~InlinedStringField();
+            }
+
+            inline void InlinedStringField::SetNoArena(StringPiece value)
+            {
+                get_mutable()->assign(value.data(), value.length());
+            }
+
+            inline void InlinedStringField::SetNoArena(std::string&& value)
+            {
+                get_mutable()->assign(std::move(value));
+            }
+
+            // Caller should make sure rhs_arena allocated rhs, and lhs_arena allocated lhs.
+            inline PROTOBUF_NDEBUG_INLINE void InlinedStringField::InternalSwap(
+                InlinedStringField* lhs, Arena* lhs_arena, bool lhs_arena_dtor_registered,
+                MessageLite* lhs_msg,  //
+                InlinedStringField* rhs,
+                Arena* rhs_arena,
+                bool rhs_arena_dtor_registered,
+                MessageLite* rhs_msg
+            )
+            {
 #if GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE
-  lhs->get_mutable()->swap(*rhs->get_mutable());
-  if (!lhs_arena_dtor_registered && rhs_arena_dtor_registered) {
-    lhs_msg->OnDemandRegisterArenaDtor(lhs_arena);
-  } else if (lhs_arena_dtor_registered && !rhs_arena_dtor_registered) {
-    rhs_msg->OnDemandRegisterArenaDtor(rhs_arena);
-  }
+                lhs->get_mutable()->swap(*rhs->get_mutable());
+                if (!lhs_arena_dtor_registered && rhs_arena_dtor_registered)
+                {
+                    lhs_msg->OnDemandRegisterArenaDtor(lhs_arena);
+                }
+                else if (lhs_arena_dtor_registered && !rhs_arena_dtor_registered)
+                {
+                    rhs_msg->OnDemandRegisterArenaDtor(rhs_arena);
+                }
 #else
-  (void)lhs_arena;
-  (void)rhs_arena;
-  (void)lhs_arena_dtor_registered;
-  (void)rhs_arena_dtor_registered;
-  (void)lhs_msg;
-  (void)rhs_msg;
-  lhs->get_mutable()->swap(*rhs->get_mutable());
+                (void)lhs_arena;
+                (void)rhs_arena;
+                (void)lhs_arena_dtor_registered;
+                (void)rhs_arena_dtor_registered;
+                (void)lhs_msg;
+                (void)rhs_msg;
+                lhs->get_mutable()->swap(*rhs->get_mutable());
 #endif
-}
-
-inline void InlinedStringField::Set(ConstStringParam value, Arena* arena,
-                                    bool donated, uint32_t* /*donating_states*/,
-                                    uint32_t /*mask*/, MessageLite* /*msg*/) {
-  (void)arena;
-  (void)donated;
-  SetNoArena(value);
-}
-
-inline void InlinedStringField::Set(const char* str, ::google::protobuf::Arena* arena,
-                                    bool donated, uint32_t* donating_states,
-                                    uint32_t mask, MessageLite* msg) {
-  Set(ConstStringParam(str), arena, donated, donating_states, mask, msg);
-}
-
-inline void InlinedStringField::Set(const char* str, size_t size,
-                                    ::google::protobuf::Arena* arena, bool donated,
-                                    uint32_t* donating_states, uint32_t mask,
-                                    MessageLite* msg) {
-  Set(ConstStringParam{str, size}, arena, donated, donating_states, mask, msg);
-}
-
-inline void InlinedStringField::SetBytes(ConstStringParam value, Arena* arena,
-                                         bool donated,
-                                         uint32_t* donating_states,
-                                         uint32_t mask, MessageLite* msg) {
-  Set(value, arena, donated, donating_states, mask, msg);
-}
-
-inline void InlinedStringField::SetBytes(std::string&& value, Arena* arena,
-                                         bool donated,
-                                         uint32_t* donating_states,
-                                         uint32_t mask, MessageLite* msg) {
-  Set(std::move(value), arena, donated, donating_states, mask, msg);
-}
-
-inline void InlinedStringField::SetBytes(const char* str,
-                                         ::google::protobuf::Arena* arena, bool donated,
-                                         uint32_t* donating_states,
-                                         uint32_t mask, MessageLite* msg) {
-  Set(str, arena, donated, donating_states, mask, msg);
-}
-
-inline void InlinedStringField::SetBytes(const void* p, size_t size,
-                                         ::google::protobuf::Arena* arena, bool donated,
-                                         uint32_t* donating_states,
-                                         uint32_t mask, MessageLite* msg) {
-  Set(static_cast<const char*>(p), size, arena, donated, donating_states, mask,
-      msg);
-}
-
-template <typename RefWrappedType>
-inline void InlinedStringField::Set(
-    std::reference_wrapper<RefWrappedType> const_string_ref,
-    ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-    uint32_t mask, MessageLite* msg) {
-  Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
-}
-
-template <typename RefWrappedType>
-inline void InlinedStringField::SetBytes(
-    std::reference_wrapper<RefWrappedType> const_string_ref,
-    ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-    uint32_t mask, MessageLite* msg) {
-  Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
-}
-
-inline std::string* InlinedStringField::UnsafeMutablePointer() {
-  return get_mutable();
-}
-
-inline std::string* InlinedStringField::Mutable(std::nullptr_t) {
-  return get_mutable();
-}
-
-inline std::string* InlinedStringField::MutableNoCopy(std::nullptr_t) {
-  return get_mutable();
-}
-
-}  // namespace internal
-}  // namespace protobuf
+            }
+
+            inline void InlinedStringField::Set(ConstStringParam value, Arena* arena, bool donated, uint32_t* /*donating_states*/, uint32_t /*mask*/, MessageLite* /*msg*/)
+            {
+                (void)arena;
+                (void)donated;
+                SetNoArena(value);
+            }
+
+            inline void InlinedStringField::Set(const char* str, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+            {
+                Set(ConstStringParam(str), arena, donated, donating_states, mask, msg);
+            }
+
+            inline void InlinedStringField::Set(const char* str, size_t size, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+            {
+                Set(ConstStringParam{str, size}, arena, donated, donating_states, mask, msg);
+            }
+
+            inline void InlinedStringField::SetBytes(ConstStringParam value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+            {
+                Set(value, arena, donated, donating_states, mask, msg);
+            }
+
+            inline void InlinedStringField::SetBytes(std::string&& value, Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+            {
+                Set(std::move(value), arena, donated, donating_states, mask, msg);
+            }
+
+            inline void InlinedStringField::SetBytes(const char* str, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+            {
+                Set(str, arena, donated, donating_states, mask, msg);
+            }
+
+            inline void InlinedStringField::SetBytes(const void* p, size_t size, ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states, uint32_t mask, MessageLite* msg)
+            {
+                Set(static_cast<const char*>(p), size, arena, donated, donating_states, mask, msg);
+            }
+
+            template<typename RefWrappedType>
+            inline void InlinedStringField::Set(
+                std::reference_wrapper<RefWrappedType> const_string_ref,
+                ::google::protobuf::Arena* arena,
+                bool donated,
+                uint32_t* donating_states,
+                uint32_t mask,
+                MessageLite* msg
+            )
+            {
+                Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
+            }
+
+            template<typename RefWrappedType>
+            inline void InlinedStringField::SetBytes(
+                std::reference_wrapper<RefWrappedType> const_string_ref,
+                ::google::protobuf::Arena* arena,
+                bool donated,
+                uint32_t* donating_states,
+                uint32_t mask,
+                MessageLite* msg
+            )
+            {
+                Set(const_string_ref.get(), arena, donated, donating_states, mask, msg);
+            }
+
+            inline std::string* InlinedStringField::UnsafeMutablePointer()
+            {
+                return get_mutable();
+            }
+
+            inline std::string* InlinedStringField::Mutable(std::nullptr_t)
+            {
+                return get_mutable();
+            }
+
+            inline std::string* InlinedStringField::MutableNoCopy(std::nullptr_t)
+            {
+                return get_mutable();
+            }
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/coded_stream.h b/CAPI/cpp/grpc/include/google/protobuf/io/coded_stream.h
index c8fc994..11c9336 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/coded_stream.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/coded_stream.h
@@ -109,7 +109,6 @@
 #ifndef GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
 #define GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
 
-
 #include <assert.h>
 
 #include <atomic>
@@ -127,1667 +126,1838 @@
 #pragma runtime_checks("c", off)
 #endif
 
-
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/port.h>
 #include <google/protobuf/stubs/port.h>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-class DescriptorPool;
-class MessageFactory;
-class ZeroCopyCodedInputStream;
-
-namespace internal {
-void MapTestForceDeterministic();
-class EpsCopyByteStream;
-}  // namespace internal
-
-namespace io {
-
-// Defined in this file.
-class CodedInputStream;
-class CodedOutputStream;
-
-// Defined in other files.
-class ZeroCopyInputStream;   // zero_copy_stream.h
-class ZeroCopyOutputStream;  // zero_copy_stream.h
-
-// Class which reads and decodes binary data which is composed of varint-
-// encoded integers and fixed-width pieces.  Wraps a ZeroCopyInputStream.
-// Most users will not need to deal with CodedInputStream.
-//
-// Most methods of CodedInputStream that return a bool return false if an
-// underlying I/O error occurs or if the data is malformed.  Once such a
-// failure occurs, the CodedInputStream is broken and is no longer useful.
-// After a failure, callers also should assume writes to "out" args may have
-// occurred, though nothing useful can be determined from those writes.
-class PROTOBUF_EXPORT CodedInputStream {
- public:
-  // Create a CodedInputStream that reads from the given ZeroCopyInputStream.
-  explicit CodedInputStream(ZeroCopyInputStream* input);
-
-  // Create a CodedInputStream that reads from the given flat array.  This is
-  // faster than using an ArrayInputStream.  PushLimit(size) is implied by
-  // this constructor.
-  explicit CodedInputStream(const uint8_t* buffer, int size);
-
-  // Destroy the CodedInputStream and position the underlying
-  // ZeroCopyInputStream at the first unread byte.  If an error occurred while
-  // reading (causing a method to return false), then the exact position of
-  // the input stream may be anywhere between the last value that was read
-  // successfully and the stream's byte limit.
-  ~CodedInputStream();
-
-  // Return true if this CodedInputStream reads from a flat array instead of
-  // a ZeroCopyInputStream.
-  inline bool IsFlat() const;
-
-  // Skips a number of bytes.  Returns false if an underlying read error
-  // occurs.
-  inline bool Skip(int count);
-
-  // Sets *data to point directly at the unread part of the CodedInputStream's
-  // underlying buffer, and *size to the size of that buffer, but does not
-  // advance the stream's current position.  This will always either produce
-  // a non-empty buffer or return false.  If the caller consumes any of
-  // this data, it should then call Skip() to skip over the consumed bytes.
-  // This may be useful for implementing external fast parsing routines for
-  // types of data not covered by the CodedInputStream interface.
-  bool GetDirectBufferPointer(const void** data, int* size);
-
-  // Like GetDirectBufferPointer, but this method is inlined, and does not
-  // attempt to Refresh() if the buffer is currently empty.
-  PROTOBUF_ALWAYS_INLINE
-  void GetDirectBufferPointerInline(const void** data, int* size);
-
-  // Read raw bytes, copying them into the given buffer.
-  bool ReadRaw(void* buffer, int size);
-
-  // Like ReadRaw, but reads into a string.
-  bool ReadString(std::string* buffer, int size);
-
-
-  // Read a 32-bit little-endian integer.
-  bool ReadLittleEndian32(uint32_t* value);
-  // Read a 64-bit little-endian integer.
-  bool ReadLittleEndian64(uint64_t* value);
-
-  // These methods read from an externally provided buffer. The caller is
-  // responsible for ensuring that the buffer has sufficient space.
-  // Read a 32-bit little-endian integer.
-  static const uint8_t* ReadLittleEndian32FromArray(const uint8_t* buffer,
-                                                    uint32_t* value);
-  // Read a 64-bit little-endian integer.
-  static const uint8_t* ReadLittleEndian64FromArray(const uint8_t* buffer,
-                                                    uint64_t* value);
-
-  // Read an unsigned integer with Varint encoding, truncating to 32 bits.
-  // Reading a 32-bit value is equivalent to reading a 64-bit one and casting
-  // it to uint32_t, but may be more efficient.
-  bool ReadVarint32(uint32_t* value);
-  // Read an unsigned integer with Varint encoding.
-  bool ReadVarint64(uint64_t* value);
-
-  // Reads a varint off the wire into an "int". This should be used for reading
-  // sizes off the wire (sizes of strings, submessages, bytes fields, etc).
-  //
-  // The value from the wire is interpreted as unsigned.  If its value exceeds
-  // the representable value of an integer on this platform, instead of
-  // truncating we return false. Truncating (as performed by ReadVarint32()
-  // above) is an acceptable approach for fields representing an integer, but
-  // when we are parsing a size from the wire, truncating the value would result
-  // in us misparsing the payload.
-  bool ReadVarintSizeAsInt(int* value);
-
-  // Read a tag.  This calls ReadVarint32() and returns the result, or returns
-  // zero (which is not a valid tag) if ReadVarint32() fails.  Also, ReadTag
-  // (but not ReadTagNoLastTag) updates the last tag value, which can be checked
-  // with LastTagWas().
-  //
-  // Always inline because this is only called in one place per parse loop
-  // but it is called for every iteration of said loop, so it should be fast.
-  // GCC doesn't want to inline this by default.
-  PROTOBUF_ALWAYS_INLINE uint32_t ReadTag() {
-    return last_tag_ = ReadTagNoLastTag();
-  }
-
-  PROTOBUF_ALWAYS_INLINE uint32_t ReadTagNoLastTag();
-
-  // This usually a faster alternative to ReadTag() when cutoff is a manifest
-  // constant.  It does particularly well for cutoff >= 127.  The first part
-  // of the return value is the tag that was read, though it can also be 0 in
-  // the cases where ReadTag() would return 0.  If the second part is true
-  // then the tag is known to be in [0, cutoff].  If not, the tag either is
-  // above cutoff or is 0.  (There's intentional wiggle room when tag is 0,
-  // because that can arise in several ways, and for best performance we want
-  // to avoid an extra "is tag == 0?" check here.)
-  PROTOBUF_ALWAYS_INLINE
-  std::pair<uint32_t, bool> ReadTagWithCutoff(uint32_t cutoff) {
-    std::pair<uint32_t, bool> result = ReadTagWithCutoffNoLastTag(cutoff);
-    last_tag_ = result.first;
-    return result;
-  }
-
-  PROTOBUF_ALWAYS_INLINE
-  std::pair<uint32_t, bool> ReadTagWithCutoffNoLastTag(uint32_t cutoff);
-
-  // Usually returns true if calling ReadVarint32() now would produce the given
-  // value.  Will always return false if ReadVarint32() would not return the
-  // given value.  If ExpectTag() returns true, it also advances past
-  // the varint.  For best performance, use a compile-time constant as the
-  // parameter.
-  // Always inline because this collapses to a small number of instructions
-  // when given a constant parameter, but GCC doesn't want to inline by default.
-  PROTOBUF_ALWAYS_INLINE bool ExpectTag(uint32_t expected);
-
-  // Like above, except this reads from the specified buffer. The caller is
-  // responsible for ensuring that the buffer is large enough to read a varint
-  // of the expected size. For best performance, use a compile-time constant as
-  // the expected tag parameter.
-  //
-  // Returns a pointer beyond the expected tag if it was found, or NULL if it
-  // was not.
-  PROTOBUF_ALWAYS_INLINE
-  static const uint8_t* ExpectTagFromArray(const uint8_t* buffer,
-                                           uint32_t expected);
-
-  // Usually returns true if no more bytes can be read.  Always returns false
-  // if more bytes can be read.  If ExpectAtEnd() returns true, a subsequent
-  // call to LastTagWas() will act as if ReadTag() had been called and returned
-  // zero, and ConsumedEntireMessage() will return true.
-  bool ExpectAtEnd();
-
-  // If the last call to ReadTag() or ReadTagWithCutoff() returned the given
-  // value, returns true.  Otherwise, returns false.
-  // ReadTagNoLastTag/ReadTagWithCutoffNoLastTag do not preserve the last
-  // returned value.
-  //
-  // This is needed because parsers for some types of embedded messages
-  // (with field type TYPE_GROUP) don't actually know that they've reached the
-  // end of a message until they see an ENDGROUP tag, which was actually part
-  // of the enclosing message.  The enclosing message would like to check that
-  // tag to make sure it had the right number, so it calls LastTagWas() on
-  // return from the embedded parser to check.
-  bool LastTagWas(uint32_t expected);
-  void SetLastTag(uint32_t tag) { last_tag_ = tag; }
-
-  // When parsing message (but NOT a group), this method must be called
-  // immediately after MergeFromCodedStream() returns (if it returns true)
-  // to further verify that the message ended in a legitimate way.  For
-  // example, this verifies that parsing did not end on an end-group tag.
-  // It also checks for some cases where, due to optimizations,
-  // MergeFromCodedStream() can incorrectly return true.
-  bool ConsumedEntireMessage();
-  void SetConsumed() { legitimate_message_end_ = true; }
-
-  // Limits ----------------------------------------------------------
-  // Limits are used when parsing length-delimited embedded messages.
-  // After the message's length is read, PushLimit() is used to prevent
-  // the CodedInputStream from reading beyond that length.  Once the
-  // embedded message has been parsed, PopLimit() is called to undo the
-  // limit.
-
-  // Opaque type used with PushLimit() and PopLimit().  Do not modify
-  // values of this type yourself.  The only reason that this isn't a
-  // struct with private internals is for efficiency.
-  typedef int Limit;
-
-  // Places a limit on the number of bytes that the stream may read,
-  // starting from the current position.  Once the stream hits this limit,
-  // it will act like the end of the input has been reached until PopLimit()
-  // is called.
-  //
-  // As the names imply, the stream conceptually has a stack of limits.  The
-  // shortest limit on the stack is always enforced, even if it is not the
-  // top limit.
-  //
-  // The value returned by PushLimit() is opaque to the caller, and must
-  // be passed unchanged to the corresponding call to PopLimit().
-  Limit PushLimit(int byte_limit);
-
-  // Pops the last limit pushed by PushLimit().  The input must be the value
-  // returned by that call to PushLimit().
-  void PopLimit(Limit limit);
-
-  // Returns the number of bytes left until the nearest limit on the
-  // stack is hit, or -1 if no limits are in place.
-  int BytesUntilLimit() const;
-
-  // Returns current position relative to the beginning of the input stream.
-  int CurrentPosition() const;
-
-  // Total Bytes Limit -----------------------------------------------
-  // To prevent malicious users from sending excessively large messages
-  // and causing memory exhaustion, CodedInputStream imposes a hard limit on
-  // the total number of bytes it will read.
-
-  // Sets the maximum number of bytes that this CodedInputStream will read
-  // before refusing to continue.  To prevent servers from allocating enormous
-  // amounts of memory to hold parsed messages, the maximum message length
-  // should be limited to the shortest length that will not harm usability.
-  // The default limit is INT_MAX (~2GB) and apps should set shorter limits
-  // if possible. An error will always be printed to stderr if the limit is
-  // reached.
-  //
-  // Note: setting a limit less than the current read position is interpreted
-  // as a limit on the current position.
-  //
-  // This is unrelated to PushLimit()/PopLimit().
-  void SetTotalBytesLimit(int total_bytes_limit);
-
-  // The Total Bytes Limit minus the Current Position, or -1 if the total bytes
-  // limit is INT_MAX.
-  int BytesUntilTotalBytesLimit() const;
-
-  // Recursion Limit -------------------------------------------------
-  // To prevent corrupt or malicious messages from causing stack overflows,
-  // we must keep track of the depth of recursion when parsing embedded
-  // messages and groups.  CodedInputStream keeps track of this because it
-  // is the only object that is passed down the stack during parsing.
-
-  // Sets the maximum recursion depth.  The default is 100.
-  void SetRecursionLimit(int limit);
-  int RecursionBudget() { return recursion_budget_; }
-
-  static int GetDefaultRecursionLimit() { return default_recursion_limit_; }
-
-  // Increments the current recursion depth.  Returns true if the depth is
-  // under the limit, false if it has gone over.
-  bool IncrementRecursionDepth();
-
-  // Decrements the recursion depth if possible.
-  void DecrementRecursionDepth();
-
-  // Decrements the recursion depth blindly.  This is faster than
-  // DecrementRecursionDepth().  It should be used only if all previous
-  // increments to recursion depth were successful.
-  void UnsafeDecrementRecursionDepth();
-
-  // Shorthand for make_pair(PushLimit(byte_limit), --recursion_budget_).
-  // Using this can reduce code size and complexity in some cases.  The caller
-  // is expected to check that the second part of the result is non-negative (to
-  // bail out if the depth of recursion is too high) and, if all is well, to
-  // later pass the first part of the result to PopLimit() or similar.
-  std::pair<CodedInputStream::Limit, int> IncrementRecursionDepthAndPushLimit(
-      int byte_limit);
-
-  // Shorthand for PushLimit(ReadVarint32(&length) ? length : 0).
-  Limit ReadLengthAndPushLimit();
-
-  // Helper that is equivalent to: {
-  //  bool result = ConsumedEntireMessage();
-  //  PopLimit(limit);
-  //  UnsafeDecrementRecursionDepth();
-  //  return result; }
-  // Using this can reduce code size and complexity in some cases.
-  // Do not use unless the current recursion depth is greater than zero.
-  bool DecrementRecursionDepthAndPopLimit(Limit limit);
-
-  // Helper that is equivalent to: {
-  //  bool result = ConsumedEntireMessage();
-  //  PopLimit(limit);
-  //  return result; }
-  // Using this can reduce code size and complexity in some cases.
-  bool CheckEntireMessageConsumedAndPopLimit(Limit limit);
-
-  // Extension Registry ----------------------------------------------
-  // ADVANCED USAGE:  99.9% of people can ignore this section.
-  //
-  // By default, when parsing extensions, the parser looks for extension
-  // definitions in the pool which owns the outer message's Descriptor.
-  // However, you may call SetExtensionRegistry() to provide an alternative
-  // pool instead.  This makes it possible, for example, to parse a message
-  // using a generated class, but represent some extensions using
-  // DynamicMessage.
-
-  // Set the pool used to look up extensions.  Most users do not need to call
-  // this as the correct pool will be chosen automatically.
-  //
-  // WARNING:  It is very easy to misuse this.  Carefully read the requirements
-  //   below.  Do not use this unless you are sure you need it.  Almost no one
-  //   does.
-  //
-  // Let's say you are parsing a message into message object m, and you want
-  // to take advantage of SetExtensionRegistry().  You must follow these
-  // requirements:
-  //
-  // The given DescriptorPool must contain m->GetDescriptor().  It is not
-  // sufficient for it to simply contain a descriptor that has the same name
-  // and content -- it must be the *exact object*.  In other words:
-  //   assert(pool->FindMessageTypeByName(m->GetDescriptor()->full_name()) ==
-  //          m->GetDescriptor());
-  // There are two ways to satisfy this requirement:
-  // 1) Use m->GetDescriptor()->pool() as the pool.  This is generally useless
-  //    because this is the pool that would be used anyway if you didn't call
-  //    SetExtensionRegistry() at all.
-  // 2) Use a DescriptorPool which has m->GetDescriptor()->pool() as an
-  //    "underlay".  Read the documentation for DescriptorPool for more
-  //    information about underlays.
-  //
-  // You must also provide a MessageFactory.  This factory will be used to
-  // construct Message objects representing extensions.  The factory's
-  // GetPrototype() MUST return non-NULL for any Descriptor which can be found
-  // through the provided pool.
-  //
-  // If the provided factory might return instances of protocol-compiler-
-  // generated (i.e. compiled-in) types, or if the outer message object m is
-  // a generated type, then the given factory MUST have this property:  If
-  // GetPrototype() is given a Descriptor which resides in
-  // DescriptorPool::generated_pool(), the factory MUST return the same
-  // prototype which MessageFactory::generated_factory() would return.  That
-  // is, given a descriptor for a generated type, the factory must return an
-  // instance of the generated class (NOT DynamicMessage).  However, when
-  // given a descriptor for a type that is NOT in generated_pool, the factory
-  // is free to return any implementation.
-  //
-  // The reason for this requirement is that generated sub-objects may be
-  // accessed via the standard (non-reflection) extension accessor methods,
-  // and these methods will down-cast the object to the generated class type.
-  // If the object is not actually of that type, the results would be undefined.
-  // On the other hand, if an extension is not compiled in, then there is no
-  // way the code could end up accessing it via the standard accessors -- the
-  // only way to access the extension is via reflection.  When using reflection,
-  // DynamicMessage and generated messages are indistinguishable, so it's fine
-  // if these objects are represented using DynamicMessage.
-  //
-  // Using DynamicMessageFactory on which you have called
-  // SetDelegateToGeneratedFactory(true) should be sufficient to satisfy the
-  // above requirement.
-  //
-  // If either pool or factory is NULL, both must be NULL.
-  //
-  // Note that this feature is ignored when parsing "lite" messages as they do
-  // not have descriptors.
-  void SetExtensionRegistry(const DescriptorPool* pool,
-                            MessageFactory* factory);
-
-  // Get the DescriptorPool set via SetExtensionRegistry(), or NULL if no pool
-  // has been provided.
-  const DescriptorPool* GetExtensionPool();
-
-  // Get the MessageFactory set via SetExtensionRegistry(), or NULL if no
-  // factory has been provided.
-  MessageFactory* GetExtensionFactory();
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedInputStream);
-
-  const uint8_t* buffer_;
-  const uint8_t* buffer_end_;  // pointer to the end of the buffer.
-  ZeroCopyInputStream* input_;
-  int total_bytes_read_;  // total bytes read from input_, including
-                          // the current buffer
-
-  // If total_bytes_read_ surpasses INT_MAX, we record the extra bytes here
-  // so that we can BackUp() on destruction.
-  int overflow_bytes_;
-
-  // LastTagWas() stuff.
-  uint32_t last_tag_;  // result of last ReadTag() or ReadTagWithCutoff().
-
-  // This is set true by ReadTag{Fallback/Slow}() if it is called when exactly
-  // at EOF, or by ExpectAtEnd() when it returns true.  This happens when we
-  // reach the end of a message and attempt to read another tag.
-  bool legitimate_message_end_;
-
-  // See EnableAliasing().
-  bool aliasing_enabled_;
-
-  // Limits
-  Limit current_limit_;  // if position = -1, no limit is applied
-
-  // For simplicity, if the current buffer crosses a limit (either a normal
-  // limit created by PushLimit() or the total bytes limit), buffer_size_
-  // only tracks the number of bytes before that limit.  This field
-  // contains the number of bytes after it.  Note that this implies that if
-  // buffer_size_ == 0 and buffer_size_after_limit_ > 0, we know we've
-  // hit a limit.  However, if both are zero, it doesn't necessarily mean
-  // we aren't at a limit -- the buffer may have ended exactly at the limit.
-  int buffer_size_after_limit_;
-
-  // Maximum number of bytes to read, period.  This is unrelated to
-  // current_limit_.  Set using SetTotalBytesLimit().
-  int total_bytes_limit_;
-
-  // Current recursion budget, controlled by IncrementRecursionDepth() and
-  // similar.  Starts at recursion_limit_ and goes down: if this reaches
-  // -1 we are over budget.
-  int recursion_budget_;
-  // Recursion depth limit, set by SetRecursionLimit().
-  int recursion_limit_;
-
-  // See SetExtensionRegistry().
-  const DescriptorPool* extension_pool_;
-  MessageFactory* extension_factory_;
-
-  // Private member functions.
-
-  // Fallback when Skip() goes past the end of the current buffer.
-  bool SkipFallback(int count, int original_buffer_size);
-
-  // Advance the buffer by a given number of bytes.
-  void Advance(int amount);
-
-  // Back up input_ to the current buffer position.
-  void BackUpInputToCurrentPosition();
-
-  // Recomputes the value of buffer_size_after_limit_.  Must be called after
-  // current_limit_ or total_bytes_limit_ changes.
-  void RecomputeBufferLimits();
-
-  // Writes an error message saying that we hit total_bytes_limit_.
-  void PrintTotalBytesLimitError();
-
-  // Called when the buffer runs out to request more data.  Implies an
-  // Advance(BufferSize()).
-  bool Refresh();
-
-  // When parsing varints, we optimize for the common case of small values, and
-  // then optimize for the case when the varint fits within the current buffer
-  // piece. The Fallback method is used when we can't use the one-byte
-  // optimization. The Slow method is yet another fallback when the buffer is
-  // not large enough. Making the slow path out-of-line speeds up the common
-  // case by 10-15%. The slow path is fairly uncommon: it only triggers when a
-  // message crosses multiple buffers.  Note: ReadVarint32Fallback() and
-  // ReadVarint64Fallback() are called frequently and generally not inlined, so
-  // they have been optimized to avoid "out" parameters.  The former returns -1
-  // if it fails and the uint32_t it read otherwise.  The latter has a bool
-  // indicating success or failure as part of its return type.
-  int64_t ReadVarint32Fallback(uint32_t first_byte_or_zero);
-  int ReadVarintSizeAsIntFallback();
-  std::pair<uint64_t, bool> ReadVarint64Fallback();
-  bool ReadVarint32Slow(uint32_t* value);
-  bool ReadVarint64Slow(uint64_t* value);
-  int ReadVarintSizeAsIntSlow();
-  bool ReadLittleEndian32Fallback(uint32_t* value);
-  bool ReadLittleEndian64Fallback(uint64_t* value);
-
-  // Fallback/slow methods for reading tags. These do not update last_tag_,
-  // but will set legitimate_message_end_ if we are at the end of the input
-  // stream.
-  uint32_t ReadTagFallback(uint32_t first_byte_or_zero);
-  uint32_t ReadTagSlow();
-  bool ReadStringFallback(std::string* buffer, int size);
-
-  // Return the size of the buffer.
-  int BufferSize() const;
-
-  static const int kDefaultTotalBytesLimit = INT_MAX;
-
-  static int default_recursion_limit_;  // 100 by default.
-
-  friend class google::protobuf::ZeroCopyCodedInputStream;
-  friend class google::protobuf::internal::EpsCopyByteStream;
-};
-
-// EpsCopyOutputStream wraps a ZeroCopyOutputStream and exposes a new stream,
-// which has the property you can write kSlopBytes (16 bytes) from the current
-// position without bounds checks. The cursor into the stream is managed by
-// the user of the class and is an explicit parameter in the methods. Careful
-// use of this class, ie. keep ptr a local variable, eliminates the need to
-// for the compiler to sync the ptr value between register and memory.
-class PROTOBUF_EXPORT EpsCopyOutputStream {
- public:
-  enum { kSlopBytes = 16 };
-
-  // Initialize from a stream.
-  EpsCopyOutputStream(ZeroCopyOutputStream* stream, bool deterministic,
-                      uint8_t** pp)
-      : end_(buffer_),
-        stream_(stream),
-        is_serialization_deterministic_(deterministic) {
-    *pp = buffer_;
-  }
-
-  // Only for array serialization. No overflow protection, end_ will be the
-  // pointed to the end of the array. When using this the total size is already
-  // known, so no need to maintain the slop region.
-  EpsCopyOutputStream(void* data, int size, bool deterministic)
-      : end_(static_cast<uint8_t*>(data) + size),
-        buffer_end_(nullptr),
-        stream_(nullptr),
-        is_serialization_deterministic_(deterministic) {}
-
-  // Initialize from stream but with the first buffer already given (eager).
-  EpsCopyOutputStream(void* data, int size, ZeroCopyOutputStream* stream,
-                      bool deterministic, uint8_t** pp)
-      : stream_(stream), is_serialization_deterministic_(deterministic) {
-    *pp = SetInitialBuffer(data, size);
-  }
-
-  // Flush everything that's written into the underlying ZeroCopyOutputStream
-  // and trims the underlying stream to the location of ptr.
-  uint8_t* Trim(uint8_t* ptr);
-
-  // After this it's guaranteed you can safely write kSlopBytes to ptr. This
-  // will never fail! The underlying stream can produce an error. Use HadError
-  // to check for errors.
-  PROTOBUF_NODISCARD uint8_t* EnsureSpace(uint8_t* ptr) {
-    if (PROTOBUF_PREDICT_FALSE(ptr >= end_)) {
-      return EnsureSpaceFallback(ptr);
-    }
-    return ptr;
-  }
-
-  uint8_t* WriteRaw(const void* data, int size, uint8_t* ptr) {
-    if (PROTOBUF_PREDICT_FALSE(end_ - ptr < size)) {
-      return WriteRawFallback(data, size, ptr);
-    }
-    std::memcpy(ptr, data, size);
-    return ptr + size;
-  }
-  // Writes the buffer specified by data, size to the stream. Possibly by
-  // aliasing the buffer (ie. not copying the data). The caller is responsible
-  // to make sure the buffer is alive for the duration of the
-  // ZeroCopyOutputStream.
+namespace google
+{
+    namespace protobuf
+    {
+
+        class DescriptorPool;
+        class MessageFactory;
+        class ZeroCopyCodedInputStream;
+
+        namespace internal
+        {
+            void MapTestForceDeterministic();
+            class EpsCopyByteStream;
+        }  // namespace internal
+
+        namespace io
+        {
+
+            // Defined in this file.
+            class CodedInputStream;
+            class CodedOutputStream;
+
+            // Defined in other files.
+            class ZeroCopyInputStream;   // zero_copy_stream.h
+            class ZeroCopyOutputStream;  // zero_copy_stream.h
+
+            // Class which reads and decodes binary data which is composed of varint-
+            // encoded integers and fixed-width pieces.  Wraps a ZeroCopyInputStream.
+            // Most users will not need to deal with CodedInputStream.
+            //
+            // Most methods of CodedInputStream that return a bool return false if an
+            // underlying I/O error occurs or if the data is malformed.  Once such a
+            // failure occurs, the CodedInputStream is broken and is no longer useful.
+            // After a failure, callers also should assume writes to "out" args may have
+            // occurred, though nothing useful can be determined from those writes.
+            class PROTOBUF_EXPORT CodedInputStream
+            {
+            public:
+                // Create a CodedInputStream that reads from the given ZeroCopyInputStream.
+                explicit CodedInputStream(ZeroCopyInputStream* input);
+
+                // Create a CodedInputStream that reads from the given flat array.  This is
+                // faster than using an ArrayInputStream.  PushLimit(size) is implied by
+                // this constructor.
+                explicit CodedInputStream(const uint8_t* buffer, int size);
+
+                // Destroy the CodedInputStream and position the underlying
+                // ZeroCopyInputStream at the first unread byte.  If an error occurred while
+                // reading (causing a method to return false), then the exact position of
+                // the input stream may be anywhere between the last value that was read
+                // successfully and the stream's byte limit.
+                ~CodedInputStream();
+
+                // Return true if this CodedInputStream reads from a flat array instead of
+                // a ZeroCopyInputStream.
+                inline bool IsFlat() const;
+
+                // Skips a number of bytes.  Returns false if an underlying read error
+                // occurs.
+                inline bool Skip(int count);
+
+                // Sets *data to point directly at the unread part of the CodedInputStream's
+                // underlying buffer, and *size to the size of that buffer, but does not
+                // advance the stream's current position.  This will always either produce
+                // a non-empty buffer or return false.  If the caller consumes any of
+                // this data, it should then call Skip() to skip over the consumed bytes.
+                // This may be useful for implementing external fast parsing routines for
+                // types of data not covered by the CodedInputStream interface.
+                bool GetDirectBufferPointer(const void** data, int* size);
+
+                // Like GetDirectBufferPointer, but this method is inlined, and does not
+                // attempt to Refresh() if the buffer is currently empty.
+                PROTOBUF_ALWAYS_INLINE
+                void GetDirectBufferPointerInline(const void** data, int* size);
+
+                // Read raw bytes, copying them into the given buffer.
+                bool ReadRaw(void* buffer, int size);
+
+                // Like ReadRaw, but reads into a string.
+                bool ReadString(std::string* buffer, int size);
+
+                // Read a 32-bit little-endian integer.
+                bool ReadLittleEndian32(uint32_t* value);
+                // Read a 64-bit little-endian integer.
+                bool ReadLittleEndian64(uint64_t* value);
+
+                // These methods read from an externally provided buffer. The caller is
+                // responsible for ensuring that the buffer has sufficient space.
+                // Read a 32-bit little-endian integer.
+                static const uint8_t* ReadLittleEndian32FromArray(const uint8_t* buffer, uint32_t* value);
+                // Read a 64-bit little-endian integer.
+                static const uint8_t* ReadLittleEndian64FromArray(const uint8_t* buffer, uint64_t* value);
+
+                // Read an unsigned integer with Varint encoding, truncating to 32 bits.
+                // Reading a 32-bit value is equivalent to reading a 64-bit one and casting
+                // it to uint32_t, but may be more efficient.
+                bool ReadVarint32(uint32_t* value);
+                // Read an unsigned integer with Varint encoding.
+                bool ReadVarint64(uint64_t* value);
+
+                // Reads a varint off the wire into an "int". This should be used for reading
+                // sizes off the wire (sizes of strings, submessages, bytes fields, etc).
+                //
+                // The value from the wire is interpreted as unsigned.  If its value exceeds
+                // the representable value of an integer on this platform, instead of
+                // truncating we return false. Truncating (as performed by ReadVarint32()
+                // above) is an acceptable approach for fields representing an integer, but
+                // when we are parsing a size from the wire, truncating the value would result
+                // in us misparsing the payload.
+                bool ReadVarintSizeAsInt(int* value);
+
+                // Read a tag.  This calls ReadVarint32() and returns the result, or returns
+                // zero (which is not a valid tag) if ReadVarint32() fails.  Also, ReadTag
+                // (but not ReadTagNoLastTag) updates the last tag value, which can be checked
+                // with LastTagWas().
+                //
+                // Always inline because this is only called in one place per parse loop
+                // but it is called for every iteration of said loop, so it should be fast.
+                // GCC doesn't want to inline this by default.
+                PROTOBUF_ALWAYS_INLINE uint32_t ReadTag()
+                {
+                    return last_tag_ = ReadTagNoLastTag();
+                }
+
+                PROTOBUF_ALWAYS_INLINE uint32_t ReadTagNoLastTag();
+
+                // This usually a faster alternative to ReadTag() when cutoff is a manifest
+                // constant.  It does particularly well for cutoff >= 127.  The first part
+                // of the return value is the tag that was read, though it can also be 0 in
+                // the cases where ReadTag() would return 0.  If the second part is true
+                // then the tag is known to be in [0, cutoff].  If not, the tag either is
+                // above cutoff or is 0.  (There's intentional wiggle room when tag is 0,
+                // because that can arise in several ways, and for best performance we want
+                // to avoid an extra "is tag == 0?" check here.)
+                PROTOBUF_ALWAYS_INLINE
+                std::pair<uint32_t, bool> ReadTagWithCutoff(uint32_t cutoff)
+                {
+                    std::pair<uint32_t, bool> result = ReadTagWithCutoffNoLastTag(cutoff);
+                    last_tag_ = result.first;
+                    return result;
+                }
+
+                PROTOBUF_ALWAYS_INLINE
+                std::pair<uint32_t, bool> ReadTagWithCutoffNoLastTag(uint32_t cutoff);
+
+                // Usually returns true if calling ReadVarint32() now would produce the given
+                // value.  Will always return false if ReadVarint32() would not return the
+                // given value.  If ExpectTag() returns true, it also advances past
+                // the varint.  For best performance, use a compile-time constant as the
+                // parameter.
+                // Always inline because this collapses to a small number of instructions
+                // when given a constant parameter, but GCC doesn't want to inline by default.
+                PROTOBUF_ALWAYS_INLINE bool ExpectTag(uint32_t expected);
+
+                // Like above, except this reads from the specified buffer. The caller is
+                // responsible for ensuring that the buffer is large enough to read a varint
+                // of the expected size. For best performance, use a compile-time constant as
+                // the expected tag parameter.
+                //
+                // Returns a pointer beyond the expected tag if it was found, or NULL if it
+                // was not.
+                PROTOBUF_ALWAYS_INLINE
+                static const uint8_t* ExpectTagFromArray(const uint8_t* buffer, uint32_t expected);
+
+                // Usually returns true if no more bytes can be read.  Always returns false
+                // if more bytes can be read.  If ExpectAtEnd() returns true, a subsequent
+                // call to LastTagWas() will act as if ReadTag() had been called and returned
+                // zero, and ConsumedEntireMessage() will return true.
+                bool ExpectAtEnd();
+
+                // If the last call to ReadTag() or ReadTagWithCutoff() returned the given
+                // value, returns true.  Otherwise, returns false.
+                // ReadTagNoLastTag/ReadTagWithCutoffNoLastTag do not preserve the last
+                // returned value.
+                //
+                // This is needed because parsers for some types of embedded messages
+                // (with field type TYPE_GROUP) don't actually know that they've reached the
+                // end of a message until they see an ENDGROUP tag, which was actually part
+                // of the enclosing message.  The enclosing message would like to check that
+                // tag to make sure it had the right number, so it calls LastTagWas() on
+                // return from the embedded parser to check.
+                bool LastTagWas(uint32_t expected);
+                void SetLastTag(uint32_t tag)
+                {
+                    last_tag_ = tag;
+                }
+
+                // When parsing message (but NOT a group), this method must be called
+                // immediately after MergeFromCodedStream() returns (if it returns true)
+                // to further verify that the message ended in a legitimate way.  For
+                // example, this verifies that parsing did not end on an end-group tag.
+                // It also checks for some cases where, due to optimizations,
+                // MergeFromCodedStream() can incorrectly return true.
+                bool ConsumedEntireMessage();
+                void SetConsumed()
+                {
+                    legitimate_message_end_ = true;
+                }
+
+                // Limits ----------------------------------------------------------
+                // Limits are used when parsing length-delimited embedded messages.
+                // After the message's length is read, PushLimit() is used to prevent
+                // the CodedInputStream from reading beyond that length.  Once the
+                // embedded message has been parsed, PopLimit() is called to undo the
+                // limit.
+
+                // Opaque type used with PushLimit() and PopLimit().  Do not modify
+                // values of this type yourself.  The only reason that this isn't a
+                // struct with private internals is for efficiency.
+                typedef int Limit;
+
+                // Places a limit on the number of bytes that the stream may read,
+                // starting from the current position.  Once the stream hits this limit,
+                // it will act like the end of the input has been reached until PopLimit()
+                // is called.
+                //
+                // As the names imply, the stream conceptually has a stack of limits.  The
+                // shortest limit on the stack is always enforced, even if it is not the
+                // top limit.
+                //
+                // The value returned by PushLimit() is opaque to the caller, and must
+                // be passed unchanged to the corresponding call to PopLimit().
+                Limit PushLimit(int byte_limit);
+
+                // Pops the last limit pushed by PushLimit().  The input must be the value
+                // returned by that call to PushLimit().
+                void PopLimit(Limit limit);
+
+                // Returns the number of bytes left until the nearest limit on the
+                // stack is hit, or -1 if no limits are in place.
+                int BytesUntilLimit() const;
+
+                // Returns current position relative to the beginning of the input stream.
+                int CurrentPosition() const;
+
+                // Total Bytes Limit -----------------------------------------------
+                // To prevent malicious users from sending excessively large messages
+                // and causing memory exhaustion, CodedInputStream imposes a hard limit on
+                // the total number of bytes it will read.
+
+                // Sets the maximum number of bytes that this CodedInputStream will read
+                // before refusing to continue.  To prevent servers from allocating enormous
+                // amounts of memory to hold parsed messages, the maximum message length
+                // should be limited to the shortest length that will not harm usability.
+                // The default limit is INT_MAX (~2GB) and apps should set shorter limits
+                // if possible. An error will always be printed to stderr if the limit is
+                // reached.
+                //
+                // Note: setting a limit less than the current read position is interpreted
+                // as a limit on the current position.
+                //
+                // This is unrelated to PushLimit()/PopLimit().
+                void SetTotalBytesLimit(int total_bytes_limit);
+
+                // The Total Bytes Limit minus the Current Position, or -1 if the total bytes
+                // limit is INT_MAX.
+                int BytesUntilTotalBytesLimit() const;
+
+                // Recursion Limit -------------------------------------------------
+                // To prevent corrupt or malicious messages from causing stack overflows,
+                // we must keep track of the depth of recursion when parsing embedded
+                // messages and groups.  CodedInputStream keeps track of this because it
+                // is the only object that is passed down the stack during parsing.
+
+                // Sets the maximum recursion depth.  The default is 100.
+                void SetRecursionLimit(int limit);
+                int RecursionBudget()
+                {
+                    return recursion_budget_;
+                }
+
+                static int GetDefaultRecursionLimit()
+                {
+                    return default_recursion_limit_;
+                }
+
+                // Increments the current recursion depth.  Returns true if the depth is
+                // under the limit, false if it has gone over.
+                bool IncrementRecursionDepth();
+
+                // Decrements the recursion depth if possible.
+                void DecrementRecursionDepth();
+
+                // Decrements the recursion depth blindly.  This is faster than
+                // DecrementRecursionDepth().  It should be used only if all previous
+                // increments to recursion depth were successful.
+                void UnsafeDecrementRecursionDepth();
+
+                // Shorthand for make_pair(PushLimit(byte_limit), --recursion_budget_).
+                // Using this can reduce code size and complexity in some cases.  The caller
+                // is expected to check that the second part of the result is non-negative (to
+                // bail out if the depth of recursion is too high) and, if all is well, to
+                // later pass the first part of the result to PopLimit() or similar.
+                std::pair<CodedInputStream::Limit, int> IncrementRecursionDepthAndPushLimit(
+                    int byte_limit
+                );
+
+                // Shorthand for PushLimit(ReadVarint32(&length) ? length : 0).
+                Limit ReadLengthAndPushLimit();
+
+                // Helper that is equivalent to: {
+                //  bool result = ConsumedEntireMessage();
+                //  PopLimit(limit);
+                //  UnsafeDecrementRecursionDepth();
+                //  return result; }
+                // Using this can reduce code size and complexity in some cases.
+                // Do not use unless the current recursion depth is greater than zero.
+                bool DecrementRecursionDepthAndPopLimit(Limit limit);
+
+                // Helper that is equivalent to: {
+                //  bool result = ConsumedEntireMessage();
+                //  PopLimit(limit);
+                //  return result; }
+                // Using this can reduce code size and complexity in some cases.
+                bool CheckEntireMessageConsumedAndPopLimit(Limit limit);
+
+                // Extension Registry ----------------------------------------------
+                // ADVANCED USAGE:  99.9% of people can ignore this section.
+                //
+                // By default, when parsing extensions, the parser looks for extension
+                // definitions in the pool which owns the outer message's Descriptor.
+                // However, you may call SetExtensionRegistry() to provide an alternative
+                // pool instead.  This makes it possible, for example, to parse a message
+                // using a generated class, but represent some extensions using
+                // DynamicMessage.
+
+                // Set the pool used to look up extensions.  Most users do not need to call
+                // this as the correct pool will be chosen automatically.
+                //
+                // WARNING:  It is very easy to misuse this.  Carefully read the requirements
+                //   below.  Do not use this unless you are sure you need it.  Almost no one
+                //   does.
+                //
+                // Let's say you are parsing a message into message object m, and you want
+                // to take advantage of SetExtensionRegistry().  You must follow these
+                // requirements:
+                //
+                // The given DescriptorPool must contain m->GetDescriptor().  It is not
+                // sufficient for it to simply contain a descriptor that has the same name
+                // and content -- it must be the *exact object*.  In other words:
+                //   assert(pool->FindMessageTypeByName(m->GetDescriptor()->full_name()) ==
+                //          m->GetDescriptor());
+                // There are two ways to satisfy this requirement:
+                // 1) Use m->GetDescriptor()->pool() as the pool.  This is generally useless
+                //    because this is the pool that would be used anyway if you didn't call
+                //    SetExtensionRegistry() at all.
+                // 2) Use a DescriptorPool which has m->GetDescriptor()->pool() as an
+                //    "underlay".  Read the documentation for DescriptorPool for more
+                //    information about underlays.
+                //
+                // You must also provide a MessageFactory.  This factory will be used to
+                // construct Message objects representing extensions.  The factory's
+                // GetPrototype() MUST return non-NULL for any Descriptor which can be found
+                // through the provided pool.
+                //
+                // If the provided factory might return instances of protocol-compiler-
+                // generated (i.e. compiled-in) types, or if the outer message object m is
+                // a generated type, then the given factory MUST have this property:  If
+                // GetPrototype() is given a Descriptor which resides in
+                // DescriptorPool::generated_pool(), the factory MUST return the same
+                // prototype which MessageFactory::generated_factory() would return.  That
+                // is, given a descriptor for a generated type, the factory must return an
+                // instance of the generated class (NOT DynamicMessage).  However, when
+                // given a descriptor for a type that is NOT in generated_pool, the factory
+                // is free to return any implementation.
+                //
+                // The reason for this requirement is that generated sub-objects may be
+                // accessed via the standard (non-reflection) extension accessor methods,
+                // and these methods will down-cast the object to the generated class type.
+                // If the object is not actually of that type, the results would be undefined.
+                // On the other hand, if an extension is not compiled in, then there is no
+                // way the code could end up accessing it via the standard accessors -- the
+                // only way to access the extension is via reflection.  When using reflection,
+                // DynamicMessage and generated messages are indistinguishable, so it's fine
+                // if these objects are represented using DynamicMessage.
+                //
+                // Using DynamicMessageFactory on which you have called
+                // SetDelegateToGeneratedFactory(true) should be sufficient to satisfy the
+                // above requirement.
+                //
+                // If either pool or factory is NULL, both must be NULL.
+                //
+                // Note that this feature is ignored when parsing "lite" messages as they do
+                // not have descriptors.
+                void SetExtensionRegistry(const DescriptorPool* pool, MessageFactory* factory);
+
+                // Get the DescriptorPool set via SetExtensionRegistry(), or NULL if no pool
+                // has been provided.
+                const DescriptorPool* GetExtensionPool();
+
+                // Get the MessageFactory set via SetExtensionRegistry(), or NULL if no
+                // factory has been provided.
+                MessageFactory* GetExtensionFactory();
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedInputStream);
+
+                const uint8_t* buffer_;
+                const uint8_t* buffer_end_;  // pointer to the end of the buffer.
+                ZeroCopyInputStream* input_;
+                int total_bytes_read_;  // total bytes read from input_, including
+                                        // the current buffer
+
+                // If total_bytes_read_ surpasses INT_MAX, we record the extra bytes here
+                // so that we can BackUp() on destruction.
+                int overflow_bytes_;
+
+                // LastTagWas() stuff.
+                uint32_t last_tag_;  // result of last ReadTag() or ReadTagWithCutoff().
+
+                // This is set true by ReadTag{Fallback/Slow}() if it is called when exactly
+                // at EOF, or by ExpectAtEnd() when it returns true.  This happens when we
+                // reach the end of a message and attempt to read another tag.
+                bool legitimate_message_end_;
+
+                // See EnableAliasing().
+                bool aliasing_enabled_;
+
+                // Limits
+                Limit current_limit_;  // if position = -1, no limit is applied
+
+                // For simplicity, if the current buffer crosses a limit (either a normal
+                // limit created by PushLimit() or the total bytes limit), buffer_size_
+                // only tracks the number of bytes before that limit.  This field
+                // contains the number of bytes after it.  Note that this implies that if
+                // buffer_size_ == 0 and buffer_size_after_limit_ > 0, we know we've
+                // hit a limit.  However, if both are zero, it doesn't necessarily mean
+                // we aren't at a limit -- the buffer may have ended exactly at the limit.
+                int buffer_size_after_limit_;
+
+                // Maximum number of bytes to read, period.  This is unrelated to
+                // current_limit_.  Set using SetTotalBytesLimit().
+                int total_bytes_limit_;
+
+                // Current recursion budget, controlled by IncrementRecursionDepth() and
+                // similar.  Starts at recursion_limit_ and goes down: if this reaches
+                // -1 we are over budget.
+                int recursion_budget_;
+                // Recursion depth limit, set by SetRecursionLimit().
+                int recursion_limit_;
+
+                // See SetExtensionRegistry().
+                const DescriptorPool* extension_pool_;
+                MessageFactory* extension_factory_;
+
+                // Private member functions.
+
+                // Fallback when Skip() goes past the end of the current buffer.
+                bool SkipFallback(int count, int original_buffer_size);
+
+                // Advance the buffer by a given number of bytes.
+                void Advance(int amount);
+
+                // Back up input_ to the current buffer position.
+                void BackUpInputToCurrentPosition();
+
+                // Recomputes the value of buffer_size_after_limit_.  Must be called after
+                // current_limit_ or total_bytes_limit_ changes.
+                void RecomputeBufferLimits();
+
+                // Writes an error message saying that we hit total_bytes_limit_.
+                void PrintTotalBytesLimitError();
+
+                // Called when the buffer runs out to request more data.  Implies an
+                // Advance(BufferSize()).
+                bool Refresh();
+
+                // When parsing varints, we optimize for the common case of small values, and
+                // then optimize for the case when the varint fits within the current buffer
+                // piece. The Fallback method is used when we can't use the one-byte
+                // optimization. The Slow method is yet another fallback when the buffer is
+                // not large enough. Making the slow path out-of-line speeds up the common
+                // case by 10-15%. The slow path is fairly uncommon: it only triggers when a
+                // message crosses multiple buffers.  Note: ReadVarint32Fallback() and
+                // ReadVarint64Fallback() are called frequently and generally not inlined, so
+                // they have been optimized to avoid "out" parameters.  The former returns -1
+                // if it fails and the uint32_t it read otherwise.  The latter has a bool
+                // indicating success or failure as part of its return type.
+                int64_t ReadVarint32Fallback(uint32_t first_byte_or_zero);
+                int ReadVarintSizeAsIntFallback();
+                std::pair<uint64_t, bool> ReadVarint64Fallback();
+                bool ReadVarint32Slow(uint32_t* value);
+                bool ReadVarint64Slow(uint64_t* value);
+                int ReadVarintSizeAsIntSlow();
+                bool ReadLittleEndian32Fallback(uint32_t* value);
+                bool ReadLittleEndian64Fallback(uint64_t* value);
+
+                // Fallback/slow methods for reading tags. These do not update last_tag_,
+                // but will set legitimate_message_end_ if we are at the end of the input
+                // stream.
+                uint32_t ReadTagFallback(uint32_t first_byte_or_zero);
+                uint32_t ReadTagSlow();
+                bool ReadStringFallback(std::string* buffer, int size);
+
+                // Return the size of the buffer.
+                int BufferSize() const;
+
+                static const int kDefaultTotalBytesLimit = INT_MAX;
+
+                static int default_recursion_limit_;  // 100 by default.
+
+                friend class google::protobuf::ZeroCopyCodedInputStream;
+                friend class google::protobuf::internal::EpsCopyByteStream;
+            };
+
+            // EpsCopyOutputStream wraps a ZeroCopyOutputStream and exposes a new stream,
+            // which has the property you can write kSlopBytes (16 bytes) from the current
+            // position without bounds checks. The cursor into the stream is managed by
+            // the user of the class and is an explicit parameter in the methods. Careful
+            // use of this class, ie. keep ptr a local variable, eliminates the need to
+            // for the compiler to sync the ptr value between register and memory.
+            class PROTOBUF_EXPORT EpsCopyOutputStream
+            {
+            public:
+                enum
+                {
+                    kSlopBytes = 16
+                };
+
+                // Initialize from a stream.
+                EpsCopyOutputStream(ZeroCopyOutputStream* stream, bool deterministic, uint8_t** pp) :
+                    end_(buffer_),
+                    stream_(stream),
+                    is_serialization_deterministic_(deterministic)
+                {
+                    *pp = buffer_;
+                }
+
+                // Only for array serialization. No overflow protection, end_ will be the
+                // pointed to the end of the array. When using this the total size is already
+                // known, so no need to maintain the slop region.
+                EpsCopyOutputStream(void* data, int size, bool deterministic) :
+                    end_(static_cast<uint8_t*>(data) + size),
+                    buffer_end_(nullptr),
+                    stream_(nullptr),
+                    is_serialization_deterministic_(deterministic)
+                {
+                }
+
+                // Initialize from stream but with the first buffer already given (eager).
+                EpsCopyOutputStream(void* data, int size, ZeroCopyOutputStream* stream, bool deterministic, uint8_t** pp) :
+                    stream_(stream),
+                    is_serialization_deterministic_(deterministic)
+                {
+                    *pp = SetInitialBuffer(data, size);
+                }
+
+                // Flush everything that's written into the underlying ZeroCopyOutputStream
+                // and trims the underlying stream to the location of ptr.
+                uint8_t* Trim(uint8_t* ptr);
+
+                // After this it's guaranteed you can safely write kSlopBytes to ptr. This
+                // will never fail! The underlying stream can produce an error. Use HadError
+                // to check for errors.
+                PROTOBUF_NODISCARD uint8_t* EnsureSpace(uint8_t* ptr)
+                {
+                    if (PROTOBUF_PREDICT_FALSE(ptr >= end_))
+                    {
+                        return EnsureSpaceFallback(ptr);
+                    }
+                    return ptr;
+                }
+
+                uint8_t* WriteRaw(const void* data, int size, uint8_t* ptr)
+                {
+                    if (PROTOBUF_PREDICT_FALSE(end_ - ptr < size))
+                    {
+                        return WriteRawFallback(data, size, ptr);
+                    }
+                    std::memcpy(ptr, data, size);
+                    return ptr + size;
+                }
+                // Writes the buffer specified by data, size to the stream. Possibly by
+                // aliasing the buffer (ie. not copying the data). The caller is responsible
+                // to make sure the buffer is alive for the duration of the
+                // ZeroCopyOutputStream.
 #ifndef NDEBUG
-  PROTOBUF_NOINLINE
+                PROTOBUF_NOINLINE
 #endif
-  uint8_t* WriteRawMaybeAliased(const void* data, int size, uint8_t* ptr) {
-    if (aliasing_enabled_) {
-      return WriteAliasedRaw(data, size, ptr);
-    } else {
-      return WriteRaw(data, size, ptr);
-    }
-  }
-
+                uint8_t* WriteRawMaybeAliased(const void* data, int size, uint8_t* ptr)
+                {
+                    if (aliasing_enabled_)
+                    {
+                        return WriteAliasedRaw(data, size, ptr);
+                    }
+                    else
+                    {
+                        return WriteRaw(data, size, ptr);
+                    }
+                }
 
 #ifndef NDEBUG
-  PROTOBUF_NOINLINE
+                PROTOBUF_NOINLINE
 #endif
-  uint8_t* WriteStringMaybeAliased(uint32_t num, const std::string& s,
-                                   uint8_t* ptr) {
-    std::ptrdiff_t size = s.size();
-    if (PROTOBUF_PREDICT_FALSE(
-            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
-      return WriteStringMaybeAliasedOutline(num, s, ptr);
-    }
-    ptr = UnsafeVarint((num << 3) | 2, ptr);
-    *ptr++ = static_cast<uint8_t>(size);
-    std::memcpy(ptr, s.data(), size);
-    return ptr + size;
-  }
-  uint8_t* WriteBytesMaybeAliased(uint32_t num, const std::string& s,
-                                  uint8_t* ptr) {
-    return WriteStringMaybeAliased(num, s, ptr);
-  }
-
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteString(uint32_t num, const T& s,
-                                              uint8_t* ptr) {
-    std::ptrdiff_t size = s.size();
-    if (PROTOBUF_PREDICT_FALSE(
-            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
-      return WriteStringOutline(num, s, ptr);
-    }
-    ptr = UnsafeVarint((num << 3) | 2, ptr);
-    *ptr++ = static_cast<uint8_t>(size);
-    std::memcpy(ptr, s.data(), size);
-    return ptr + size;
-  }
-  template <typename T>
+                uint8_t* WriteStringMaybeAliased(uint32_t num, const std::string& s, uint8_t* ptr)
+                {
+                    std::ptrdiff_t size = s.size();
+                    if (PROTOBUF_PREDICT_FALSE(
+                            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size
+                        ))
+                    {
+                        return WriteStringMaybeAliasedOutline(num, s, ptr);
+                    }
+                    ptr = UnsafeVarint((num << 3) | 2, ptr);
+                    *ptr++ = static_cast<uint8_t>(size);
+                    std::memcpy(ptr, s.data(), size);
+                    return ptr + size;
+                }
+                uint8_t* WriteBytesMaybeAliased(uint32_t num, const std::string& s, uint8_t* ptr)
+                {
+                    return WriteStringMaybeAliased(num, s, ptr);
+                }
+
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteString(uint32_t num, const T& s, uint8_t* ptr)
+                {
+                    std::ptrdiff_t size = s.size();
+                    if (PROTOBUF_PREDICT_FALSE(
+                            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size
+                        ))
+                    {
+                        return WriteStringOutline(num, s, ptr);
+                    }
+                    ptr = UnsafeVarint((num << 3) | 2, ptr);
+                    *ptr++ = static_cast<uint8_t>(size);
+                    std::memcpy(ptr, s.data(), size);
+                    return ptr + size;
+                }
+                template<typename T>
 #ifndef NDEBUG
-  PROTOBUF_NOINLINE
+                PROTOBUF_NOINLINE
 #endif
-  uint8_t* WriteBytes(uint32_t num, const T& s, uint8_t* ptr) {
-    return WriteString(num, s, ptr);
-  }
-
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteInt32Packed(int num, const T& r,
-                                                   int size, uint8_t* ptr) {
-    return WriteVarintPacked(num, r, size, ptr, Encode64);
-  }
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteUInt32Packed(int num, const T& r,
-                                                    int size, uint8_t* ptr) {
-    return WriteVarintPacked(num, r, size, ptr, Encode32);
-  }
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteSInt32Packed(int num, const T& r,
-                                                    int size, uint8_t* ptr) {
-    return WriteVarintPacked(num, r, size, ptr, ZigZagEncode32);
-  }
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteInt64Packed(int num, const T& r,
-                                                   int size, uint8_t* ptr) {
-    return WriteVarintPacked(num, r, size, ptr, Encode64);
-  }
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteUInt64Packed(int num, const T& r,
-                                                    int size, uint8_t* ptr) {
-    return WriteVarintPacked(num, r, size, ptr, Encode64);
-  }
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteSInt64Packed(int num, const T& r,
-                                                    int size, uint8_t* ptr) {
-    return WriteVarintPacked(num, r, size, ptr, ZigZagEncode64);
-  }
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteEnumPacked(int num, const T& r, int size,
-                                                  uint8_t* ptr) {
-    return WriteVarintPacked(num, r, size, ptr, Encode64);
-  }
-
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteFixedPacked(int num, const T& r,
-                                                   uint8_t* ptr) {
-    ptr = EnsureSpace(ptr);
-    constexpr auto element_size = sizeof(typename T::value_type);
-    auto size = r.size() * element_size;
-    ptr = WriteLengthDelim(num, size, ptr);
-    return WriteRawLittleEndian<element_size>(r.data(), static_cast<int>(size),
-                                              ptr);
-  }
-
-  // Returns true if there was an underlying I/O error since this object was
-  // created.
-  bool HadError() const { return had_error_; }
-
-  // Instructs the EpsCopyOutputStream to allow the underlying
-  // ZeroCopyOutputStream to hold pointers to the original structure instead of
-  // copying, if it supports it (i.e. output->AllowsAliasing() is true).  If the
-  // underlying stream does not support aliasing, then enabling it has no
-  // affect.  For now, this only affects the behavior of
-  // WriteRawMaybeAliased().
-  //
-  // NOTE: It is caller's responsibility to ensure that the chunk of memory
-  // remains live until all of the data has been consumed from the stream.
-  void EnableAliasing(bool enabled);
-
-  // See documentation on CodedOutputStream::SetSerializationDeterministic.
-  void SetSerializationDeterministic(bool value) {
-    is_serialization_deterministic_ = value;
-  }
-
-  // See documentation on CodedOutputStream::IsSerializationDeterministic.
-  bool IsSerializationDeterministic() const {
-    return is_serialization_deterministic_;
-  }
-
-  // The number of bytes written to the stream at position ptr, relative to the
-  // stream's overall position.
-  int64_t ByteCount(uint8_t* ptr) const;
-
-
- private:
-  uint8_t* end_;
-  uint8_t* buffer_end_ = buffer_;
-  uint8_t buffer_[2 * kSlopBytes];
-  ZeroCopyOutputStream* stream_;
-  bool had_error_ = false;
-  bool aliasing_enabled_ = false;  // See EnableAliasing().
-  bool is_serialization_deterministic_;
-  bool skip_check_consistency = false;
-
-  uint8_t* EnsureSpaceFallback(uint8_t* ptr);
-  inline uint8_t* Next();
-  int Flush(uint8_t* ptr);
-  std::ptrdiff_t GetSize(uint8_t* ptr) const {
-    GOOGLE_DCHECK(ptr <= end_ + kSlopBytes);  // NOLINT
-    return end_ + kSlopBytes - ptr;
-  }
-
-  uint8_t* Error() {
-    had_error_ = true;
-    // We use the patch buffer to always guarantee space to write to.
-    end_ = buffer_ + kSlopBytes;
-    return buffer_;
-  }
-
-  static constexpr int TagSize(uint32_t tag) {
-    return (tag < (1 << 7))    ? 1
-           : (tag < (1 << 14)) ? 2
-           : (tag < (1 << 21)) ? 3
-           : (tag < (1 << 28)) ? 4
-                               : 5;
-  }
-
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteTag(uint32_t num, uint32_t wt,
-                                           uint8_t* ptr) {
-    GOOGLE_DCHECK(ptr < end_);  // NOLINT
-    return UnsafeVarint((num << 3) | wt, ptr);
-  }
-
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteLengthDelim(int num, uint32_t size,
-                                                   uint8_t* ptr) {
-    ptr = WriteTag(num, 2, ptr);
-    return UnsafeWriteSize(size, ptr);
-  }
-
-  uint8_t* WriteRawFallback(const void* data, int size, uint8_t* ptr);
-
-  uint8_t* WriteAliasedRaw(const void* data, int size, uint8_t* ptr);
-
-  uint8_t* WriteStringMaybeAliasedOutline(uint32_t num, const std::string& s,
-                                          uint8_t* ptr);
-  uint8_t* WriteStringOutline(uint32_t num, const std::string& s, uint8_t* ptr);
-
-  template <typename T, typename E>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteVarintPacked(int num, const T& r,
-                                                    int size, uint8_t* ptr,
-                                                    const E& encode) {
-    ptr = EnsureSpace(ptr);
-    ptr = WriteLengthDelim(num, size, ptr);
-    auto it = r.data();
-    auto end = it + r.size();
-    do {
-      ptr = EnsureSpace(ptr);
-      ptr = UnsafeVarint(encode(*it++), ptr);
-    } while (it < end);
-    return ptr;
-  }
-
-  static uint32_t Encode32(uint32_t v) { return v; }
-  static uint64_t Encode64(uint64_t v) { return v; }
-  static uint32_t ZigZagEncode32(int32_t v) {
-    return (static_cast<uint32_t>(v) << 1) ^ static_cast<uint32_t>(v >> 31);
-  }
-  static uint64_t ZigZagEncode64(int64_t v) {
-    return (static_cast<uint64_t>(v) << 1) ^ static_cast<uint64_t>(v >> 63);
-  }
-
-  template <typename T>
-  PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeVarint(T value, uint8_t* ptr) {
-    static_assert(std::is_unsigned<T>::value,
-                  "Varint serialization must be unsigned");
-    ptr[0] = static_cast<uint8_t>(value);
-    if (value < 0x80) {
-      return ptr + 1;
-    }
-    // Turn on continuation bit in the byte we just wrote.
-    ptr[0] |= static_cast<uint8_t>(0x80);
-    value >>= 7;
-    ptr[1] = static_cast<uint8_t>(value);
-    if (value < 0x80) {
-      return ptr + 2;
-    }
-    ptr += 2;
-    do {
-      // Turn on continuation bit in the byte we just wrote.
-      ptr[-1] |= static_cast<uint8_t>(0x80);
-      value >>= 7;
-      *ptr = static_cast<uint8_t>(value);
-      ++ptr;
-    } while (value >= 0x80);
-    return ptr;
-  }
-
-  PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeWriteSize(uint32_t value,
-                                                         uint8_t* ptr) {
-    while (PROTOBUF_PREDICT_FALSE(value >= 0x80)) {
-      *ptr = static_cast<uint8_t>(value | 0x80);
-      value >>= 7;
-      ++ptr;
-    }
-    *ptr++ = static_cast<uint8_t>(value);
-    return ptr;
-  }
-
-  template <int S>
-  uint8_t* WriteRawLittleEndian(const void* data, int size, uint8_t* ptr);
+                    uint8_t*
+                    WriteBytes(uint32_t num, const T& s, uint8_t* ptr)
+                {
+                    return WriteString(num, s, ptr);
+                }
+
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteInt32Packed(int num, const T& r, int size, uint8_t* ptr)
+                {
+                    return WriteVarintPacked(num, r, size, ptr, Encode64);
+                }
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteUInt32Packed(int num, const T& r, int size, uint8_t* ptr)
+                {
+                    return WriteVarintPacked(num, r, size, ptr, Encode32);
+                }
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteSInt32Packed(int num, const T& r, int size, uint8_t* ptr)
+                {
+                    return WriteVarintPacked(num, r, size, ptr, ZigZagEncode32);
+                }
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteInt64Packed(int num, const T& r, int size, uint8_t* ptr)
+                {
+                    return WriteVarintPacked(num, r, size, ptr, Encode64);
+                }
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteUInt64Packed(int num, const T& r, int size, uint8_t* ptr)
+                {
+                    return WriteVarintPacked(num, r, size, ptr, Encode64);
+                }
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteSInt64Packed(int num, const T& r, int size, uint8_t* ptr)
+                {
+                    return WriteVarintPacked(num, r, size, ptr, ZigZagEncode64);
+                }
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteEnumPacked(int num, const T& r, int size, uint8_t* ptr)
+                {
+                    return WriteVarintPacked(num, r, size, ptr, Encode64);
+                }
+
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteFixedPacked(int num, const T& r, uint8_t* ptr)
+                {
+                    ptr = EnsureSpace(ptr);
+                    constexpr auto element_size = sizeof(typename T::value_type);
+                    auto size = r.size() * element_size;
+                    ptr = WriteLengthDelim(num, size, ptr);
+                    return WriteRawLittleEndian<element_size>(r.data(), static_cast<int>(size), ptr);
+                }
+
+                // Returns true if there was an underlying I/O error since this object was
+                // created.
+                bool HadError() const
+                {
+                    return had_error_;
+                }
+
+                // Instructs the EpsCopyOutputStream to allow the underlying
+                // ZeroCopyOutputStream to hold pointers to the original structure instead of
+                // copying, if it supports it (i.e. output->AllowsAliasing() is true).  If the
+                // underlying stream does not support aliasing, then enabling it has no
+                // affect.  For now, this only affects the behavior of
+                // WriteRawMaybeAliased().
+                //
+                // NOTE: It is caller's responsibility to ensure that the chunk of memory
+                // remains live until all of the data has been consumed from the stream.
+                void EnableAliasing(bool enabled);
+
+                // See documentation on CodedOutputStream::SetSerializationDeterministic.
+                void SetSerializationDeterministic(bool value)
+                {
+                    is_serialization_deterministic_ = value;
+                }
+
+                // See documentation on CodedOutputStream::IsSerializationDeterministic.
+                bool IsSerializationDeterministic() const
+                {
+                    return is_serialization_deterministic_;
+                }
+
+                // The number of bytes written to the stream at position ptr, relative to the
+                // stream's overall position.
+                int64_t ByteCount(uint8_t* ptr) const;
+
+            private:
+                uint8_t* end_;
+                uint8_t* buffer_end_ = buffer_;
+                uint8_t buffer_[2 * kSlopBytes];
+                ZeroCopyOutputStream* stream_;
+                bool had_error_ = false;
+                bool aliasing_enabled_ = false;  // See EnableAliasing().
+                bool is_serialization_deterministic_;
+                bool skip_check_consistency = false;
+
+                uint8_t* EnsureSpaceFallback(uint8_t* ptr);
+                inline uint8_t* Next();
+                int Flush(uint8_t* ptr);
+                std::ptrdiff_t GetSize(uint8_t* ptr) const
+                {
+                    GOOGLE_DCHECK(ptr <= end_ + kSlopBytes);  // NOLINT
+                    return end_ + kSlopBytes - ptr;
+                }
+
+                uint8_t* Error()
+                {
+                    had_error_ = true;
+                    // We use the patch buffer to always guarantee space to write to.
+                    end_ = buffer_ + kSlopBytes;
+                    return buffer_;
+                }
+
+                static constexpr int TagSize(uint32_t tag)
+                {
+                    return (tag < (1 << 7)) ? 1 : (tag < (1 << 14)) ? 2 :
+                                              (tag < (1 << 21))     ? 3 :
+                                              (tag < (1 << 28))     ? 4 :
+                                                                      5;
+                }
+
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteTag(uint32_t num, uint32_t wt, uint8_t* ptr)
+                {
+                    GOOGLE_DCHECK(ptr < end_);  // NOLINT
+                    return UnsafeVarint((num << 3) | wt, ptr);
+                }
+
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteLengthDelim(int num, uint32_t size, uint8_t* ptr)
+                {
+                    ptr = WriteTag(num, 2, ptr);
+                    return UnsafeWriteSize(size, ptr);
+                }
+
+                uint8_t* WriteRawFallback(const void* data, int size, uint8_t* ptr);
+
+                uint8_t* WriteAliasedRaw(const void* data, int size, uint8_t* ptr);
+
+                uint8_t* WriteStringMaybeAliasedOutline(uint32_t num, const std::string& s, uint8_t* ptr);
+                uint8_t* WriteStringOutline(uint32_t num, const std::string& s, uint8_t* ptr);
+
+                template<typename T, typename E>
+                PROTOBUF_ALWAYS_INLINE uint8_t* WriteVarintPacked(int num, const T& r, int size, uint8_t* ptr, const E& encode)
+                {
+                    ptr = EnsureSpace(ptr);
+                    ptr = WriteLengthDelim(num, size, ptr);
+                    auto it = r.data();
+                    auto end = it + r.size();
+                    do
+                    {
+                        ptr = EnsureSpace(ptr);
+                        ptr = UnsafeVarint(encode(*it++), ptr);
+                    } while (it < end);
+                    return ptr;
+                }
+
+                static uint32_t Encode32(uint32_t v)
+                {
+                    return v;
+                }
+                static uint64_t Encode64(uint64_t v)
+                {
+                    return v;
+                }
+                static uint32_t ZigZagEncode32(int32_t v)
+                {
+                    return (static_cast<uint32_t>(v) << 1) ^ static_cast<uint32_t>(v >> 31);
+                }
+                static uint64_t ZigZagEncode64(int64_t v)
+                {
+                    return (static_cast<uint64_t>(v) << 1) ^ static_cast<uint64_t>(v >> 63);
+                }
+
+                template<typename T>
+                PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeVarint(T value, uint8_t* ptr)
+                {
+                    static_assert(std::is_unsigned<T>::value, "Varint serialization must be unsigned");
+                    ptr[0] = static_cast<uint8_t>(value);
+                    if (value < 0x80)
+                    {
+                        return ptr + 1;
+                    }
+                    // Turn on continuation bit in the byte we just wrote.
+                    ptr[0] |= static_cast<uint8_t>(0x80);
+                    value >>= 7;
+                    ptr[1] = static_cast<uint8_t>(value);
+                    if (value < 0x80)
+                    {
+                        return ptr + 2;
+                    }
+                    ptr += 2;
+                    do
+                    {
+                        // Turn on continuation bit in the byte we just wrote.
+                        ptr[-1] |= static_cast<uint8_t>(0x80);
+                        value >>= 7;
+                        *ptr = static_cast<uint8_t>(value);
+                        ++ptr;
+                    } while (value >= 0x80);
+                    return ptr;
+                }
+
+                PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeWriteSize(uint32_t value, uint8_t* ptr)
+                {
+                    while (PROTOBUF_PREDICT_FALSE(value >= 0x80))
+                    {
+                        *ptr = static_cast<uint8_t>(value | 0x80);
+                        value >>= 7;
+                        ++ptr;
+                    }
+                    *ptr++ = static_cast<uint8_t>(value);
+                    return ptr;
+                }
+
+                template<int S>
+                uint8_t* WriteRawLittleEndian(const void* data, int size, uint8_t* ptr);
 #if !defined(PROTOBUF_LITTLE_ENDIAN) || \
     defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  uint8_t* WriteRawLittleEndian32(const void* data, int size, uint8_t* ptr);
-  uint8_t* WriteRawLittleEndian64(const void* data, int size, uint8_t* ptr);
+                uint8_t* WriteRawLittleEndian32(const void* data, int size, uint8_t* ptr);
+                uint8_t* WriteRawLittleEndian64(const void* data, int size, uint8_t* ptr);
 #endif
 
-  // These methods are for CodedOutputStream. Ideally they should be private
-  // but to match current behavior of CodedOutputStream as close as possible
-  // we allow it some functionality.
- public:
-  uint8_t* SetInitialBuffer(void* data, int size) {
-    auto ptr = static_cast<uint8_t*>(data);
-    if (size > kSlopBytes) {
-      end_ = ptr + size - kSlopBytes;
-      buffer_end_ = nullptr;
-      return ptr;
-    } else {
-      end_ = buffer_ + size;
-      buffer_end_ = ptr;
-      return buffer_;
-    }
-  }
-
- private:
-  // Needed by CodedOutputStream HadError. HadError needs to flush the patch
-  // buffers to ensure there is no error as of yet.
-  uint8_t* FlushAndResetBuffer(uint8_t*);
-
-  // The following functions mimic the old CodedOutputStream behavior as close
-  // as possible. They flush the current state to the stream, behave as
-  // the old CodedOutputStream and then return to normal operation.
-  bool Skip(int count, uint8_t** pp);
-  bool GetDirectBufferPointer(void** data, int* size, uint8_t** pp);
-  uint8_t* GetDirectBufferForNBytesAndAdvance(int size, uint8_t** pp);
-
-  friend class CodedOutputStream;
-};
-
-template <>
-inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<1>(const void* data,
-                                                             int size,
-                                                             uint8_t* ptr) {
-  return WriteRaw(data, size, ptr);
-}
-template <>
-inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<4>(const void* data,
-                                                             int size,
-                                                             uint8_t* ptr) {
+                // These methods are for CodedOutputStream. Ideally they should be private
+                // but to match current behavior of CodedOutputStream as close as possible
+                // we allow it some functionality.
+
+            public:
+                uint8_t* SetInitialBuffer(void* data, int size)
+                {
+                    auto ptr = static_cast<uint8_t*>(data);
+                    if (size > kSlopBytes)
+                    {
+                        end_ = ptr + size - kSlopBytes;
+                        buffer_end_ = nullptr;
+                        return ptr;
+                    }
+                    else
+                    {
+                        end_ = buffer_ + size;
+                        buffer_end_ = ptr;
+                        return buffer_;
+                    }
+                }
+
+            private:
+                // Needed by CodedOutputStream HadError. HadError needs to flush the patch
+                // buffers to ensure there is no error as of yet.
+                uint8_t* FlushAndResetBuffer(uint8_t*);
+
+                // The following functions mimic the old CodedOutputStream behavior as close
+                // as possible. They flush the current state to the stream, behave as
+                // the old CodedOutputStream and then return to normal operation.
+                bool Skip(int count, uint8_t** pp);
+                bool GetDirectBufferPointer(void** data, int* size, uint8_t** pp);
+                uint8_t* GetDirectBufferForNBytesAndAdvance(int size, uint8_t** pp);
+
+                friend class CodedOutputStream;
+            };
+
+            template<>
+            inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<1>(const void* data, int size, uint8_t* ptr)
+            {
+                return WriteRaw(data, size, ptr);
+            }
+            template<>
+            inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<4>(const void* data, int size, uint8_t* ptr)
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  return WriteRaw(data, size, ptr);
+                return WriteRaw(data, size, ptr);
 #else
-  return WriteRawLittleEndian32(data, size, ptr);
+                return WriteRawLittleEndian32(data, size, ptr);
 #endif
-}
-template <>
-inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<8>(const void* data,
-                                                             int size,
-                                                             uint8_t* ptr) {
+            }
+            template<>
+            inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<8>(const void* data, int size, uint8_t* ptr)
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  return WriteRaw(data, size, ptr);
+                return WriteRaw(data, size, ptr);
 #else
-  return WriteRawLittleEndian64(data, size, ptr);
+                return WriteRawLittleEndian64(data, size, ptr);
 #endif
-}
-
-// Class which encodes and writes binary data which is composed of varint-
-// encoded integers and fixed-width pieces.  Wraps a ZeroCopyOutputStream.
-// Most users will not need to deal with CodedOutputStream.
-//
-// Most methods of CodedOutputStream which return a bool return false if an
-// underlying I/O error occurs.  Once such a failure occurs, the
-// CodedOutputStream is broken and is no longer useful. The Write* methods do
-// not return the stream status, but will invalidate the stream if an error
-// occurs. The client can probe HadError() to determine the status.
-//
-// Note that every method of CodedOutputStream which writes some data has
-// a corresponding static "ToArray" version. These versions write directly
-// to the provided buffer, returning a pointer past the last written byte.
-// They require that the buffer has sufficient capacity for the encoded data.
-// This allows an optimization where we check if an output stream has enough
-// space for an entire message before we start writing and, if there is, we
-// call only the ToArray methods to avoid doing bound checks for each
-// individual value.
-// i.e., in the example above:
-//
-//   CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
-//   int magic_number = 1234;
-//   char text[] = "Hello world!";
-//
-//   int coded_size = sizeof(magic_number) +
-//                    CodedOutputStream::VarintSize32(strlen(text)) +
-//                    strlen(text);
-//
-//   uint8_t* buffer =
-//       coded_output->GetDirectBufferForNBytesAndAdvance(coded_size);
-//   if (buffer != nullptr) {
-//     // The output stream has enough space in the buffer: write directly to
-//     // the array.
-//     buffer = CodedOutputStream::WriteLittleEndian32ToArray(magic_number,
-//                                                            buffer);
-//     buffer = CodedOutputStream::WriteVarint32ToArray(strlen(text), buffer);
-//     buffer = CodedOutputStream::WriteRawToArray(text, strlen(text), buffer);
-//   } else {
-//     // Make bound-checked writes, which will ask the underlying stream for
-//     // more space as needed.
-//     coded_output->WriteLittleEndian32(magic_number);
-//     coded_output->WriteVarint32(strlen(text));
-//     coded_output->WriteRaw(text, strlen(text));
-//   }
-//
-//   delete coded_output;
-class PROTOBUF_EXPORT CodedOutputStream {
- public:
-  // Creates a CodedOutputStream that writes to the given `stream`.
-  // The provided stream must publicly derive from `ZeroCopyOutputStream`.
-  template <class Stream, class = typename std::enable_if<std::is_base_of<
-                              ZeroCopyOutputStream, Stream>::value>::type>
-  explicit CodedOutputStream(Stream* stream);
-
-  // Creates a CodedOutputStream that writes to the given `stream`, and does
-  // an 'eager initialization' of the internal state if `eager_init` is true.
-  // The provided stream must publicly derive from `ZeroCopyOutputStream`.
-  template <class Stream, class = typename std::enable_if<std::is_base_of<
-                              ZeroCopyOutputStream, Stream>::value>::type>
-  CodedOutputStream(Stream* stream, bool eager_init);
-
-  // Destroy the CodedOutputStream and position the underlying
-  // ZeroCopyOutputStream immediately after the last byte written.
-  ~CodedOutputStream();
-
-  // Returns true if there was an underlying I/O error since this object was
-  // created. On should call Trim before this function in order to catch all
-  // errors.
-  bool HadError() {
-    cur_ = impl_.FlushAndResetBuffer(cur_);
-    GOOGLE_DCHECK(cur_);
-    return impl_.HadError();
-  }
-
-  // Trims any unused space in the underlying buffer so that its size matches
-  // the number of bytes written by this stream. The underlying buffer will
-  // automatically be trimmed when this stream is destroyed; this call is only
-  // necessary if the underlying buffer is accessed *before* the stream is
-  // destroyed.
-  void Trim() { cur_ = impl_.Trim(cur_); }
-
-  // Skips a number of bytes, leaving the bytes unmodified in the underlying
-  // buffer.  Returns false if an underlying write error occurs.  This is
-  // mainly useful with GetDirectBufferPointer().
-  // Note of caution, the skipped bytes may contain uninitialized data. The
-  // caller must make sure that the skipped bytes are properly initialized,
-  // otherwise you might leak bytes from your heap.
-  bool Skip(int count) { return impl_.Skip(count, &cur_); }
-
-  // Sets *data to point directly at the unwritten part of the
-  // CodedOutputStream's underlying buffer, and *size to the size of that
-  // buffer, but does not advance the stream's current position.  This will
-  // always either produce a non-empty buffer or return false.  If the caller
-  // writes any data to this buffer, it should then call Skip() to skip over
-  // the consumed bytes.  This may be useful for implementing external fast
-  // serialization routines for types of data not covered by the
-  // CodedOutputStream interface.
-  bool GetDirectBufferPointer(void** data, int* size) {
-    return impl_.GetDirectBufferPointer(data, size, &cur_);
-  }
-
-  // If there are at least "size" bytes available in the current buffer,
-  // returns a pointer directly into the buffer and advances over these bytes.
-  // The caller may then write directly into this buffer (e.g. using the
-  // *ToArray static methods) rather than go through CodedOutputStream.  If
-  // there are not enough bytes available, returns NULL.  The return pointer is
-  // invalidated as soon as any other non-const method of CodedOutputStream
-  // is called.
-  inline uint8_t* GetDirectBufferForNBytesAndAdvance(int size) {
-    return impl_.GetDirectBufferForNBytesAndAdvance(size, &cur_);
-  }
-
-  // Write raw bytes, copying them from the given buffer.
-  void WriteRaw(const void* buffer, int size) {
-    cur_ = impl_.WriteRaw(buffer, size, cur_);
-  }
-  // Like WriteRaw()  but will try to write aliased data if aliasing is
-  // turned on.
-  void WriteRawMaybeAliased(const void* data, int size);
-  // Like WriteRaw()  but writing directly to the target array.
-  // This is _not_ inlined, as the compiler often optimizes memcpy into inline
-  // copy loops. Since this gets called by every field with string or bytes
-  // type, inlining may lead to a significant amount of code bloat, with only a
-  // minor performance gain.
-  static uint8_t* WriteRawToArray(const void* buffer, int size,
-                                  uint8_t* target);
-
-  // Equivalent to WriteRaw(str.data(), str.size()).
-  void WriteString(const std::string& str);
-  // Like WriteString()  but writing directly to the target array.
-  static uint8_t* WriteStringToArray(const std::string& str, uint8_t* target);
-  // Write the varint-encoded size of str followed by str.
-  static uint8_t* WriteStringWithSizeToArray(const std::string& str,
-                                             uint8_t* target);
-
-
-  // Write a 32-bit little-endian integer.
-  void WriteLittleEndian32(uint32_t value) {
-    cur_ = impl_.EnsureSpace(cur_);
-    SetCur(WriteLittleEndian32ToArray(value, Cur()));
-  }
-  // Like WriteLittleEndian32()  but writing directly to the target array.
-  static uint8_t* WriteLittleEndian32ToArray(uint32_t value, uint8_t* target);
-  // Write a 64-bit little-endian integer.
-  void WriteLittleEndian64(uint64_t value) {
-    cur_ = impl_.EnsureSpace(cur_);
-    SetCur(WriteLittleEndian64ToArray(value, Cur()));
-  }
-  // Like WriteLittleEndian64()  but writing directly to the target array.
-  static uint8_t* WriteLittleEndian64ToArray(uint64_t value, uint8_t* target);
-
-  // Write an unsigned integer with Varint encoding.  Writing a 32-bit value
-  // is equivalent to casting it to uint64_t and writing it as a 64-bit value,
-  // but may be more efficient.
-  void WriteVarint32(uint32_t value);
-  // Like WriteVarint32()  but writing directly to the target array.
-  static uint8_t* WriteVarint32ToArray(uint32_t value, uint8_t* target);
-  // Like WriteVarint32()  but writing directly to the target array, and with
-  // the less common-case paths being out of line rather than inlined.
-  static uint8_t* WriteVarint32ToArrayOutOfLine(uint32_t value,
-                                                uint8_t* target);
-  // Write an unsigned integer with Varint encoding.
-  void WriteVarint64(uint64_t value);
-  // Like WriteVarint64()  but writing directly to the target array.
-  static uint8_t* WriteVarint64ToArray(uint64_t value, uint8_t* target);
-
-  // Equivalent to WriteVarint32() except when the value is negative,
-  // in which case it must be sign-extended to a full 10 bytes.
-  void WriteVarint32SignExtended(int32_t value);
-  // Like WriteVarint32SignExtended()  but writing directly to the target array.
-  static uint8_t* WriteVarint32SignExtendedToArray(int32_t value,
-                                                   uint8_t* target);
-
-  // This is identical to WriteVarint32(), but optimized for writing tags.
-  // In particular, if the input is a compile-time constant, this method
-  // compiles down to a couple instructions.
-  // Always inline because otherwise the aforementioned optimization can't work,
-  // but GCC by default doesn't want to inline this.
-  void WriteTag(uint32_t value);
-  // Like WriteTag()  but writing directly to the target array.
-  PROTOBUF_ALWAYS_INLINE
-  static uint8_t* WriteTagToArray(uint32_t value, uint8_t* target);
-
-  // Returns the number of bytes needed to encode the given value as a varint.
-  static size_t VarintSize32(uint32_t value);
-  // Returns the number of bytes needed to encode the given value as a varint.
-  static size_t VarintSize64(uint64_t value);
-
-  // If negative, 10 bytes.  Otherwise, same as VarintSize32().
-  static size_t VarintSize32SignExtended(int32_t value);
-
-  // Same as above, plus one.  The additional one comes at no compute cost.
-  static size_t VarintSize32PlusOne(uint32_t value);
-  static size_t VarintSize64PlusOne(uint64_t value);
-  static size_t VarintSize32SignExtendedPlusOne(int32_t value);
-
-  // Compile-time equivalent of VarintSize32().
-  template <uint32_t Value>
-  struct StaticVarintSize32 {
-    static const size_t value = (Value < (1 << 7))    ? 1
-                                : (Value < (1 << 14)) ? 2
-                                : (Value < (1 << 21)) ? 3
-                                : (Value < (1 << 28)) ? 4
-                                                      : 5;
-  };
-
-  // Returns the total number of bytes written since this object was created.
-  int ByteCount() const {
-    return static_cast<int>(impl_.ByteCount(cur_) - start_count_);
-  }
-
-  // Instructs the CodedOutputStream to allow the underlying
-  // ZeroCopyOutputStream to hold pointers to the original structure instead of
-  // copying, if it supports it (i.e. output->AllowsAliasing() is true).  If the
-  // underlying stream does not support aliasing, then enabling it has no
-  // affect.  For now, this only affects the behavior of
-  // WriteRawMaybeAliased().
-  //
-  // NOTE: It is caller's responsibility to ensure that the chunk of memory
-  // remains live until all of the data has been consumed from the stream.
-  void EnableAliasing(bool enabled) { impl_.EnableAliasing(enabled); }
-
-  // Indicate to the serializer whether the user wants deterministic
-  // serialization. The default when this is not called comes from the global
-  // default, controlled by SetDefaultSerializationDeterministic.
-  //
-  // What deterministic serialization means is entirely up to the driver of the
-  // serialization process (i.e. the caller of methods like WriteVarint32). In
-  // the case of serializing a proto buffer message using one of the methods of
-  // MessageLite, this means that for a given binary equal messages will always
-  // be serialized to the same bytes. This implies:
-  //
-  //   * Repeated serialization of a message will return the same bytes.
-  //
-  //   * Different processes running the same binary (including on different
-  //     machines) will serialize equal messages to the same bytes.
-  //
-  // Note that this is *not* canonical across languages. It is also unstable
-  // across different builds with intervening message definition changes, due to
-  // unknown fields. Users who need canonical serialization (e.g. persistent
-  // storage in a canonical form, fingerprinting) should define their own
-  // canonicalization specification and implement the serializer using
-  // reflection APIs rather than relying on this API.
-  void SetSerializationDeterministic(bool value) {
-    impl_.SetSerializationDeterministic(value);
-  }
-
-  // Return whether the user wants deterministic serialization. See above.
-  bool IsSerializationDeterministic() const {
-    return impl_.IsSerializationDeterministic();
-  }
-
-  static bool IsDefaultSerializationDeterministic() {
-    return default_serialization_deterministic_.load(
-               std::memory_order_relaxed) != 0;
-  }
-
-  template <typename Func>
-  void Serialize(const Func& func);
-
-  uint8_t* Cur() const { return cur_; }
-  void SetCur(uint8_t* ptr) { cur_ = ptr; }
-  EpsCopyOutputStream* EpsCopy() { return &impl_; }
-
- private:
-  template <class Stream>
-  void InitEagerly(Stream* stream);
-
-  EpsCopyOutputStream impl_;
-  uint8_t* cur_;
-  int64_t start_count_;
-  static std::atomic<bool> default_serialization_deterministic_;
-
-  // See above.  Other projects may use "friend" to allow them to call this.
-  // After SetDefaultSerializationDeterministic() completes, all protocol
-  // buffer serializations will be deterministic by default.  Thread safe.
-  // However, the meaning of "after" is subtle here: to be safe, each thread
-  // that wants deterministic serialization by default needs to call
-  // SetDefaultSerializationDeterministic() or ensure on its own that another
-  // thread has done so.
-  friend void internal::MapTestForceDeterministic();
-  static void SetDefaultSerializationDeterministic() {
-    default_serialization_deterministic_.store(true, std::memory_order_relaxed);
-  }
-  // REQUIRES: value >= 0x80, and that (value & 7f) has been written to *target.
-  static uint8_t* WriteVarint32ToArrayOutOfLineHelper(uint32_t value,
-                                                      uint8_t* target);
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedOutputStream);
-};
-
-// inline methods ====================================================
-// The vast majority of varints are only one byte.  These inline
-// methods optimize for that case.
-
-inline bool CodedInputStream::ReadVarint32(uint32_t* value) {
-  uint32_t v = 0;
-  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
-    v = *buffer_;
-    if (v < 0x80) {
-      *value = v;
-      Advance(1);
-      return true;
-    }
-  }
-  int64_t result = ReadVarint32Fallback(v);
-  *value = static_cast<uint32_t>(result);
-  return result >= 0;
-}
-
-inline bool CodedInputStream::ReadVarint64(uint64_t* value) {
-  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
-    *value = *buffer_;
-    Advance(1);
-    return true;
-  }
-  std::pair<uint64_t, bool> p = ReadVarint64Fallback();
-  *value = p.first;
-  return p.second;
-}
-
-inline bool CodedInputStream::ReadVarintSizeAsInt(int* value) {
-  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
-    int v = *buffer_;
-    if (v < 0x80) {
-      *value = v;
-      Advance(1);
-      return true;
-    }
-  }
-  *value = ReadVarintSizeAsIntFallback();
-  return *value >= 0;
-}
-
-// static
-inline const uint8_t* CodedInputStream::ReadLittleEndian32FromArray(
-    const uint8_t* buffer, uint32_t* value) {
+            }
+
+            // Class which encodes and writes binary data which is composed of varint-
+            // encoded integers and fixed-width pieces.  Wraps a ZeroCopyOutputStream.
+            // Most users will not need to deal with CodedOutputStream.
+            //
+            // Most methods of CodedOutputStream which return a bool return false if an
+            // underlying I/O error occurs.  Once such a failure occurs, the
+            // CodedOutputStream is broken and is no longer useful. The Write* methods do
+            // not return the stream status, but will invalidate the stream if an error
+            // occurs. The client can probe HadError() to determine the status.
+            //
+            // Note that every method of CodedOutputStream which writes some data has
+            // a corresponding static "ToArray" version. These versions write directly
+            // to the provided buffer, returning a pointer past the last written byte.
+            // They require that the buffer has sufficient capacity for the encoded data.
+            // This allows an optimization where we check if an output stream has enough
+            // space for an entire message before we start writing and, if there is, we
+            // call only the ToArray methods to avoid doing bound checks for each
+            // individual value.
+            // i.e., in the example above:
+            //
+            //   CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
+            //   int magic_number = 1234;
+            //   char text[] = "Hello world!";
+            //
+            //   int coded_size = sizeof(magic_number) +
+            //                    CodedOutputStream::VarintSize32(strlen(text)) +
+            //                    strlen(text);
+            //
+            //   uint8_t* buffer =
+            //       coded_output->GetDirectBufferForNBytesAndAdvance(coded_size);
+            //   if (buffer != nullptr) {
+            //     // The output stream has enough space in the buffer: write directly to
+            //     // the array.
+            //     buffer = CodedOutputStream::WriteLittleEndian32ToArray(magic_number,
+            //                                                            buffer);
+            //     buffer = CodedOutputStream::WriteVarint32ToArray(strlen(text), buffer);
+            //     buffer = CodedOutputStream::WriteRawToArray(text, strlen(text), buffer);
+            //   } else {
+            //     // Make bound-checked writes, which will ask the underlying stream for
+            //     // more space as needed.
+            //     coded_output->WriteLittleEndian32(magic_number);
+            //     coded_output->WriteVarint32(strlen(text));
+            //     coded_output->WriteRaw(text, strlen(text));
+            //   }
+            //
+            //   delete coded_output;
+            class PROTOBUF_EXPORT CodedOutputStream
+            {
+            public:
+                // Creates a CodedOutputStream that writes to the given `stream`.
+                // The provided stream must publicly derive from `ZeroCopyOutputStream`.
+                template<class Stream, class = typename std::enable_if<std::is_base_of<ZeroCopyOutputStream, Stream>::value>::type>
+                explicit CodedOutputStream(Stream* stream);
+
+                // Creates a CodedOutputStream that writes to the given `stream`, and does
+                // an 'eager initialization' of the internal state if `eager_init` is true.
+                // The provided stream must publicly derive from `ZeroCopyOutputStream`.
+                template<class Stream, class = typename std::enable_if<std::is_base_of<ZeroCopyOutputStream, Stream>::value>::type>
+                CodedOutputStream(Stream* stream, bool eager_init);
+
+                // Destroy the CodedOutputStream and position the underlying
+                // ZeroCopyOutputStream immediately after the last byte written.
+                ~CodedOutputStream();
+
+                // Returns true if there was an underlying I/O error since this object was
+                // created. On should call Trim before this function in order to catch all
+                // errors.
+                bool HadError()
+                {
+                    cur_ = impl_.FlushAndResetBuffer(cur_);
+                    GOOGLE_DCHECK(cur_);
+                    return impl_.HadError();
+                }
+
+                // Trims any unused space in the underlying buffer so that its size matches
+                // the number of bytes written by this stream. The underlying buffer will
+                // automatically be trimmed when this stream is destroyed; this call is only
+                // necessary if the underlying buffer is accessed *before* the stream is
+                // destroyed.
+                void Trim()
+                {
+                    cur_ = impl_.Trim(cur_);
+                }
+
+                // Skips a number of bytes, leaving the bytes unmodified in the underlying
+                // buffer.  Returns false if an underlying write error occurs.  This is
+                // mainly useful with GetDirectBufferPointer().
+                // Note of caution, the skipped bytes may contain uninitialized data. The
+                // caller must make sure that the skipped bytes are properly initialized,
+                // otherwise you might leak bytes from your heap.
+                bool Skip(int count)
+                {
+                    return impl_.Skip(count, &cur_);
+                }
+
+                // Sets *data to point directly at the unwritten part of the
+                // CodedOutputStream's underlying buffer, and *size to the size of that
+                // buffer, but does not advance the stream's current position.  This will
+                // always either produce a non-empty buffer or return false.  If the caller
+                // writes any data to this buffer, it should then call Skip() to skip over
+                // the consumed bytes.  This may be useful for implementing external fast
+                // serialization routines for types of data not covered by the
+                // CodedOutputStream interface.
+                bool GetDirectBufferPointer(void** data, int* size)
+                {
+                    return impl_.GetDirectBufferPointer(data, size, &cur_);
+                }
+
+                // If there are at least "size" bytes available in the current buffer,
+                // returns a pointer directly into the buffer and advances over these bytes.
+                // The caller may then write directly into this buffer (e.g. using the
+                // *ToArray static methods) rather than go through CodedOutputStream.  If
+                // there are not enough bytes available, returns NULL.  The return pointer is
+                // invalidated as soon as any other non-const method of CodedOutputStream
+                // is called.
+                inline uint8_t* GetDirectBufferForNBytesAndAdvance(int size)
+                {
+                    return impl_.GetDirectBufferForNBytesAndAdvance(size, &cur_);
+                }
+
+                // Write raw bytes, copying them from the given buffer.
+                void WriteRaw(const void* buffer, int size)
+                {
+                    cur_ = impl_.WriteRaw(buffer, size, cur_);
+                }
+                // Like WriteRaw()  but will try to write aliased data if aliasing is
+                // turned on.
+                void WriteRawMaybeAliased(const void* data, int size);
+                // Like WriteRaw()  but writing directly to the target array.
+                // This is _not_ inlined, as the compiler often optimizes memcpy into inline
+                // copy loops. Since this gets called by every field with string or bytes
+                // type, inlining may lead to a significant amount of code bloat, with only a
+                // minor performance gain.
+                static uint8_t* WriteRawToArray(const void* buffer, int size, uint8_t* target);
+
+                // Equivalent to WriteRaw(str.data(), str.size()).
+                void WriteString(const std::string& str);
+                // Like WriteString()  but writing directly to the target array.
+                static uint8_t* WriteStringToArray(const std::string& str, uint8_t* target);
+                // Write the varint-encoded size of str followed by str.
+                static uint8_t* WriteStringWithSizeToArray(const std::string& str, uint8_t* target);
+
+                // Write a 32-bit little-endian integer.
+                void WriteLittleEndian32(uint32_t value)
+                {
+                    cur_ = impl_.EnsureSpace(cur_);
+                    SetCur(WriteLittleEndian32ToArray(value, Cur()));
+                }
+                // Like WriteLittleEndian32()  but writing directly to the target array.
+                static uint8_t* WriteLittleEndian32ToArray(uint32_t value, uint8_t* target);
+                // Write a 64-bit little-endian integer.
+                void WriteLittleEndian64(uint64_t value)
+                {
+                    cur_ = impl_.EnsureSpace(cur_);
+                    SetCur(WriteLittleEndian64ToArray(value, Cur()));
+                }
+                // Like WriteLittleEndian64()  but writing directly to the target array.
+                static uint8_t* WriteLittleEndian64ToArray(uint64_t value, uint8_t* target);
+
+                // Write an unsigned integer with Varint encoding.  Writing a 32-bit value
+                // is equivalent to casting it to uint64_t and writing it as a 64-bit value,
+                // but may be more efficient.
+                void WriteVarint32(uint32_t value);
+                // Like WriteVarint32()  but writing directly to the target array.
+                static uint8_t* WriteVarint32ToArray(uint32_t value, uint8_t* target);
+                // Like WriteVarint32()  but writing directly to the target array, and with
+                // the less common-case paths being out of line rather than inlined.
+                static uint8_t* WriteVarint32ToArrayOutOfLine(uint32_t value, uint8_t* target);
+                // Write an unsigned integer with Varint encoding.
+                void WriteVarint64(uint64_t value);
+                // Like WriteVarint64()  but writing directly to the target array.
+                static uint8_t* WriteVarint64ToArray(uint64_t value, uint8_t* target);
+
+                // Equivalent to WriteVarint32() except when the value is negative,
+                // in which case it must be sign-extended to a full 10 bytes.
+                void WriteVarint32SignExtended(int32_t value);
+                // Like WriteVarint32SignExtended()  but writing directly to the target array.
+                static uint8_t* WriteVarint32SignExtendedToArray(int32_t value, uint8_t* target);
+
+                // This is identical to WriteVarint32(), but optimized for writing tags.
+                // In particular, if the input is a compile-time constant, this method
+                // compiles down to a couple instructions.
+                // Always inline because otherwise the aforementioned optimization can't work,
+                // but GCC by default doesn't want to inline this.
+                void WriteTag(uint32_t value);
+                // Like WriteTag()  but writing directly to the target array.
+                PROTOBUF_ALWAYS_INLINE
+                static uint8_t* WriteTagToArray(uint32_t value, uint8_t* target);
+
+                // Returns the number of bytes needed to encode the given value as a varint.
+                static size_t VarintSize32(uint32_t value);
+                // Returns the number of bytes needed to encode the given value as a varint.
+                static size_t VarintSize64(uint64_t value);
+
+                // If negative, 10 bytes.  Otherwise, same as VarintSize32().
+                static size_t VarintSize32SignExtended(int32_t value);
+
+                // Same as above, plus one.  The additional one comes at no compute cost.
+                static size_t VarintSize32PlusOne(uint32_t value);
+                static size_t VarintSize64PlusOne(uint64_t value);
+                static size_t VarintSize32SignExtendedPlusOne(int32_t value);
+
+                // Compile-time equivalent of VarintSize32().
+                template<uint32_t Value>
+                struct StaticVarintSize32
+                {
+                    static const size_t value = (Value < (1 << 7)) ? 1 : (Value < (1 << 14)) ? 2 :
+                                                                     (Value < (1 << 21))     ? 3 :
+                                                                     (Value < (1 << 28))     ? 4 :
+                                                                                               5;
+                };
+
+                // Returns the total number of bytes written since this object was created.
+                int ByteCount() const
+                {
+                    return static_cast<int>(impl_.ByteCount(cur_) - start_count_);
+                }
+
+                // Instructs the CodedOutputStream to allow the underlying
+                // ZeroCopyOutputStream to hold pointers to the original structure instead of
+                // copying, if it supports it (i.e. output->AllowsAliasing() is true).  If the
+                // underlying stream does not support aliasing, then enabling it has no
+                // affect.  For now, this only affects the behavior of
+                // WriteRawMaybeAliased().
+                //
+                // NOTE: It is caller's responsibility to ensure that the chunk of memory
+                // remains live until all of the data has been consumed from the stream.
+                void EnableAliasing(bool enabled)
+                {
+                    impl_.EnableAliasing(enabled);
+                }
+
+                // Indicate to the serializer whether the user wants deterministic
+                // serialization. The default when this is not called comes from the global
+                // default, controlled by SetDefaultSerializationDeterministic.
+                //
+                // What deterministic serialization means is entirely up to the driver of the
+                // serialization process (i.e. the caller of methods like WriteVarint32). In
+                // the case of serializing a proto buffer message using one of the methods of
+                // MessageLite, this means that for a given binary equal messages will always
+                // be serialized to the same bytes. This implies:
+                //
+                //   * Repeated serialization of a message will return the same bytes.
+                //
+                //   * Different processes running the same binary (including on different
+                //     machines) will serialize equal messages to the same bytes.
+                //
+                // Note that this is *not* canonical across languages. It is also unstable
+                // across different builds with intervening message definition changes, due to
+                // unknown fields. Users who need canonical serialization (e.g. persistent
+                // storage in a canonical form, fingerprinting) should define their own
+                // canonicalization specification and implement the serializer using
+                // reflection APIs rather than relying on this API.
+                void SetSerializationDeterministic(bool value)
+                {
+                    impl_.SetSerializationDeterministic(value);
+                }
+
+                // Return whether the user wants deterministic serialization. See above.
+                bool IsSerializationDeterministic() const
+                {
+                    return impl_.IsSerializationDeterministic();
+                }
+
+                static bool IsDefaultSerializationDeterministic()
+                {
+                    return default_serialization_deterministic_.load(
+                               std::memory_order_relaxed
+                           ) != 0;
+                }
+
+                template<typename Func>
+                void Serialize(const Func& func);
+
+                uint8_t* Cur() const
+                {
+                    return cur_;
+                }
+                void SetCur(uint8_t* ptr)
+                {
+                    cur_ = ptr;
+                }
+                EpsCopyOutputStream* EpsCopy()
+                {
+                    return &impl_;
+                }
+
+            private:
+                template<class Stream>
+                void InitEagerly(Stream* stream);
+
+                EpsCopyOutputStream impl_;
+                uint8_t* cur_;
+                int64_t start_count_;
+                static std::atomic<bool> default_serialization_deterministic_;
+
+                // See above.  Other projects may use "friend" to allow them to call this.
+                // After SetDefaultSerializationDeterministic() completes, all protocol
+                // buffer serializations will be deterministic by default.  Thread safe.
+                // However, the meaning of "after" is subtle here: to be safe, each thread
+                // that wants deterministic serialization by default needs to call
+                // SetDefaultSerializationDeterministic() or ensure on its own that another
+                // thread has done so.
+                friend void internal::MapTestForceDeterministic();
+                static void SetDefaultSerializationDeterministic()
+                {
+                    default_serialization_deterministic_.store(true, std::memory_order_relaxed);
+                }
+                // REQUIRES: value >= 0x80, and that (value & 7f) has been written to *target.
+                static uint8_t* WriteVarint32ToArrayOutOfLineHelper(uint32_t value, uint8_t* target);
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedOutputStream);
+            };
+
+            // inline methods ====================================================
+            // The vast majority of varints are only one byte.  These inline
+            // methods optimize for that case.
+
+            inline bool CodedInputStream::ReadVarint32(uint32_t* value)
+            {
+                uint32_t v = 0;
+                if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_))
+                {
+                    v = *buffer_;
+                    if (v < 0x80)
+                    {
+                        *value = v;
+                        Advance(1);
+                        return true;
+                    }
+                }
+                int64_t result = ReadVarint32Fallback(v);
+                *value = static_cast<uint32_t>(result);
+                return result >= 0;
+            }
+
+            inline bool CodedInputStream::ReadVarint64(uint64_t* value)
+            {
+                if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80)
+                {
+                    *value = *buffer_;
+                    Advance(1);
+                    return true;
+                }
+                std::pair<uint64_t, bool> p = ReadVarint64Fallback();
+                *value = p.first;
+                return p.second;
+            }
+
+            inline bool CodedInputStream::ReadVarintSizeAsInt(int* value)
+            {
+                if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_))
+                {
+                    int v = *buffer_;
+                    if (v < 0x80)
+                    {
+                        *value = v;
+                        Advance(1);
+                        return true;
+                    }
+                }
+                *value = ReadVarintSizeAsIntFallback();
+                return *value >= 0;
+            }
+
+            // static
+            inline const uint8_t* CodedInputStream::ReadLittleEndian32FromArray(
+                const uint8_t* buffer, uint32_t* value
+            )
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  memcpy(value, buffer, sizeof(*value));
-  return buffer + sizeof(*value);
+                memcpy(value, buffer, sizeof(*value));
+                return buffer + sizeof(*value);
 #else
-  *value = (static_cast<uint32_t>(buffer[0])) |
-           (static_cast<uint32_t>(buffer[1]) << 8) |
-           (static_cast<uint32_t>(buffer[2]) << 16) |
-           (static_cast<uint32_t>(buffer[3]) << 24);
-  return buffer + sizeof(*value);
+                *value = (static_cast<uint32_t>(buffer[0])) |
+                         (static_cast<uint32_t>(buffer[1]) << 8) |
+                         (static_cast<uint32_t>(buffer[2]) << 16) |
+                         (static_cast<uint32_t>(buffer[3]) << 24);
+                return buffer + sizeof(*value);
 #endif
-}
-// static
-inline const uint8_t* CodedInputStream::ReadLittleEndian64FromArray(
-    const uint8_t* buffer, uint64_t* value) {
+            }
+            // static
+            inline const uint8_t* CodedInputStream::ReadLittleEndian64FromArray(
+                const uint8_t* buffer, uint64_t* value
+            )
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  memcpy(value, buffer, sizeof(*value));
-  return buffer + sizeof(*value);
+                memcpy(value, buffer, sizeof(*value));
+                return buffer + sizeof(*value);
 #else
-  uint32_t part0 = (static_cast<uint32_t>(buffer[0])) |
-                   (static_cast<uint32_t>(buffer[1]) << 8) |
-                   (static_cast<uint32_t>(buffer[2]) << 16) |
-                   (static_cast<uint32_t>(buffer[3]) << 24);
-  uint32_t part1 = (static_cast<uint32_t>(buffer[4])) |
-                   (static_cast<uint32_t>(buffer[5]) << 8) |
-                   (static_cast<uint32_t>(buffer[6]) << 16) |
-                   (static_cast<uint32_t>(buffer[7]) << 24);
-  *value = static_cast<uint64_t>(part0) | (static_cast<uint64_t>(part1) << 32);
-  return buffer + sizeof(*value);
+                uint32_t part0 = (static_cast<uint32_t>(buffer[0])) |
+                                 (static_cast<uint32_t>(buffer[1]) << 8) |
+                                 (static_cast<uint32_t>(buffer[2]) << 16) |
+                                 (static_cast<uint32_t>(buffer[3]) << 24);
+                uint32_t part1 = (static_cast<uint32_t>(buffer[4])) |
+                                 (static_cast<uint32_t>(buffer[5]) << 8) |
+                                 (static_cast<uint32_t>(buffer[6]) << 16) |
+                                 (static_cast<uint32_t>(buffer[7]) << 24);
+                *value = static_cast<uint64_t>(part0) | (static_cast<uint64_t>(part1) << 32);
+                return buffer + sizeof(*value);
 #endif
-}
+            }
 
-inline bool CodedInputStream::ReadLittleEndian32(uint32_t* value) {
+            inline bool CodedInputStream::ReadLittleEndian32(uint32_t* value)
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
-    buffer_ = ReadLittleEndian32FromArray(buffer_, value);
-    return true;
-  } else {
-    return ReadLittleEndian32Fallback(value);
-  }
+                if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value))))
+                {
+                    buffer_ = ReadLittleEndian32FromArray(buffer_, value);
+                    return true;
+                }
+                else
+                {
+                    return ReadLittleEndian32Fallback(value);
+                }
 #else
-  return ReadLittleEndian32Fallback(value);
+                return ReadLittleEndian32Fallback(value);
 #endif
-}
+            }
 
-inline bool CodedInputStream::ReadLittleEndian64(uint64_t* value) {
+            inline bool CodedInputStream::ReadLittleEndian64(uint64_t* value)
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
-    buffer_ = ReadLittleEndian64FromArray(buffer_, value);
-    return true;
-  } else {
-    return ReadLittleEndian64Fallback(value);
-  }
+                if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value))))
+                {
+                    buffer_ = ReadLittleEndian64FromArray(buffer_, value);
+                    return true;
+                }
+                else
+                {
+                    return ReadLittleEndian64Fallback(value);
+                }
 #else
-  return ReadLittleEndian64Fallback(value);
+                return ReadLittleEndian64Fallback(value);
 #endif
-}
-
-inline uint32_t CodedInputStream::ReadTagNoLastTag() {
-  uint32_t v = 0;
-  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
-    v = *buffer_;
-    if (v < 0x80) {
-      Advance(1);
-      return v;
-    }
-  }
-  v = ReadTagFallback(v);
-  return v;
-}
-
-inline std::pair<uint32_t, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
-    uint32_t cutoff) {
-  // In performance-sensitive code we can expect cutoff to be a compile-time
-  // constant, and things like "cutoff >= kMax1ByteVarint" to be evaluated at
-  // compile time.
-  uint32_t first_byte_or_zero = 0;
-  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
-    // Hot case: buffer_ non_empty, buffer_[0] in [1, 128).
-    // TODO(gpike): Is it worth rearranging this? E.g., if the number of fields
-    // is large enough then is it better to check for the two-byte case first?
-    first_byte_or_zero = buffer_[0];
-    if (static_cast<int8_t>(buffer_[0]) > 0) {
-      const uint32_t kMax1ByteVarint = 0x7f;
-      uint32_t tag = buffer_[0];
-      Advance(1);
-      return std::make_pair(tag, cutoff >= kMax1ByteVarint || tag <= cutoff);
-    }
-    // Other hot case: cutoff >= 0x80, buffer_ has at least two bytes available,
-    // and tag is two bytes.  The latter is tested by bitwise-and-not of the
-    // first byte and the second byte.
-    if (cutoff >= 0x80 && PROTOBUF_PREDICT_TRUE(buffer_ + 1 < buffer_end_) &&
-        PROTOBUF_PREDICT_TRUE((buffer_[0] & ~buffer_[1]) >= 0x80)) {
-      const uint32_t kMax2ByteVarint = (0x7f << 7) + 0x7f;
-      uint32_t tag = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
-      Advance(2);
-      // It might make sense to test for tag == 0 now, but it is so rare that
-      // that we don't bother.  A varint-encoded 0 should be one byte unless
-      // the encoder lost its mind.  The second part of the return value of
-      // this function is allowed to be either true or false if the tag is 0,
-      // so we don't have to check for tag == 0.  We may need to check whether
-      // it exceeds cutoff.
-      bool at_or_below_cutoff = cutoff >= kMax2ByteVarint || tag <= cutoff;
-      return std::make_pair(tag, at_or_below_cutoff);
-    }
-  }
-  // Slow path
-  const uint32_t tag = ReadTagFallback(first_byte_or_zero);
-  return std::make_pair(tag, static_cast<uint32_t>(tag - 1) < cutoff);
-}
-
-inline bool CodedInputStream::LastTagWas(uint32_t expected) {
-  return last_tag_ == expected;
-}
-
-inline bool CodedInputStream::ConsumedEntireMessage() {
-  return legitimate_message_end_;
-}
-
-inline bool CodedInputStream::ExpectTag(uint32_t expected) {
-  if (expected < (1 << 7)) {
-    if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) &&
-        buffer_[0] == expected) {
-      Advance(1);
-      return true;
-    } else {
-      return false;
-    }
-  } else if (expected < (1 << 14)) {
-    if (PROTOBUF_PREDICT_TRUE(BufferSize() >= 2) &&
-        buffer_[0] == static_cast<uint8_t>(expected | 0x80) &&
-        buffer_[1] == static_cast<uint8_t>(expected >> 7)) {
-      Advance(2);
-      return true;
-    } else {
-      return false;
-    }
-  } else {
-    // Don't bother optimizing for larger values.
-    return false;
-  }
-}
-
-inline const uint8_t* CodedInputStream::ExpectTagFromArray(
-    const uint8_t* buffer, uint32_t expected) {
-  if (expected < (1 << 7)) {
-    if (buffer[0] == expected) {
-      return buffer + 1;
-    }
-  } else if (expected < (1 << 14)) {
-    if (buffer[0] == static_cast<uint8_t>(expected | 0x80) &&
-        buffer[1] == static_cast<uint8_t>(expected >> 7)) {
-      return buffer + 2;
-    }
-  }
-  return nullptr;
-}
-
-inline void CodedInputStream::GetDirectBufferPointerInline(const void** data,
-                                                           int* size) {
-  *data = buffer_;
-  *size = static_cast<int>(buffer_end_ - buffer_);
-}
-
-inline bool CodedInputStream::ExpectAtEnd() {
-  // If we are at a limit we know no more bytes can be read.  Otherwise, it's
-  // hard to say without calling Refresh(), and we'd rather not do that.
-
-  if (buffer_ == buffer_end_ && ((buffer_size_after_limit_ != 0) ||
-                                 (total_bytes_read_ == current_limit_))) {
-    last_tag_ = 0;                   // Pretend we called ReadTag()...
-    legitimate_message_end_ = true;  // ... and it hit EOF.
-    return true;
-  } else {
-    return false;
-  }
-}
-
-inline int CodedInputStream::CurrentPosition() const {
-  return total_bytes_read_ - (BufferSize() + buffer_size_after_limit_);
-}
-
-inline void CodedInputStream::Advance(int amount) { buffer_ += amount; }
-
-inline void CodedInputStream::SetRecursionLimit(int limit) {
-  recursion_budget_ += limit - recursion_limit_;
-  recursion_limit_ = limit;
-}
-
-inline bool CodedInputStream::IncrementRecursionDepth() {
-  --recursion_budget_;
-  return recursion_budget_ >= 0;
-}
-
-inline void CodedInputStream::DecrementRecursionDepth() {
-  if (recursion_budget_ < recursion_limit_) ++recursion_budget_;
-}
-
-inline void CodedInputStream::UnsafeDecrementRecursionDepth() {
-  assert(recursion_budget_ < recursion_limit_);
-  ++recursion_budget_;
-}
-
-inline void CodedInputStream::SetExtensionRegistry(const DescriptorPool* pool,
-                                                   MessageFactory* factory) {
-  extension_pool_ = pool;
-  extension_factory_ = factory;
-}
-
-inline const DescriptorPool* CodedInputStream::GetExtensionPool() {
-  return extension_pool_;
-}
-
-inline MessageFactory* CodedInputStream::GetExtensionFactory() {
-  return extension_factory_;
-}
-
-inline int CodedInputStream::BufferSize() const {
-  return static_cast<int>(buffer_end_ - buffer_);
-}
-
-inline CodedInputStream::CodedInputStream(ZeroCopyInputStream* input)
-    : buffer_(nullptr),
-      buffer_end_(nullptr),
-      input_(input),
-      total_bytes_read_(0),
-      overflow_bytes_(0),
-      last_tag_(0),
-      legitimate_message_end_(false),
-      aliasing_enabled_(false),
-      current_limit_(std::numeric_limits<int32_t>::max()),
-      buffer_size_after_limit_(0),
-      total_bytes_limit_(kDefaultTotalBytesLimit),
-      recursion_budget_(default_recursion_limit_),
-      recursion_limit_(default_recursion_limit_),
-      extension_pool_(nullptr),
-      extension_factory_(nullptr) {
-  // Eagerly Refresh() so buffer space is immediately available.
-  Refresh();
-}
-
-inline CodedInputStream::CodedInputStream(const uint8_t* buffer, int size)
-    : buffer_(buffer),
-      buffer_end_(buffer + size),
-      input_(nullptr),
-      total_bytes_read_(size),
-      overflow_bytes_(0),
-      last_tag_(0),
-      legitimate_message_end_(false),
-      aliasing_enabled_(false),
-      current_limit_(size),
-      buffer_size_after_limit_(0),
-      total_bytes_limit_(kDefaultTotalBytesLimit),
-      recursion_budget_(default_recursion_limit_),
-      recursion_limit_(default_recursion_limit_),
-      extension_pool_(nullptr),
-      extension_factory_(nullptr) {
-  // Note that setting current_limit_ == size is important to prevent some
-  // code paths from trying to access input_ and segfaulting.
-}
-
-inline bool CodedInputStream::IsFlat() const { return input_ == nullptr; }
-
-inline bool CodedInputStream::Skip(int count) {
-  if (count < 0) return false;  // security: count is often user-supplied
-
-  const int original_buffer_size = BufferSize();
-
-  if (count <= original_buffer_size) {
-    // Just skipping within the current buffer.  Easy.
-    Advance(count);
-    return true;
-  }
-
-  return SkipFallback(count, original_buffer_size);
-}
-
-template <class Stream, class>
-inline CodedOutputStream::CodedOutputStream(Stream* stream)
-    : impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
-      start_count_(stream->ByteCount()) {
-  InitEagerly(stream);
-}
-
-template <class Stream, class>
-inline CodedOutputStream::CodedOutputStream(Stream* stream, bool eager_init)
-    : impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
-      start_count_(stream->ByteCount()) {
-  if (eager_init) {
-    InitEagerly(stream);
-  }
-}
-
-template <class Stream>
-inline void CodedOutputStream::InitEagerly(Stream* stream) {
-  void* data;
-  int size;
-  if (PROTOBUF_PREDICT_TRUE(stream->Next(&data, &size) && size > 0)) {
-    cur_ = impl_.SetInitialBuffer(data, size);
-  }
-}
-
-inline uint8_t* CodedOutputStream::WriteVarint32ToArray(uint32_t value,
-                                                        uint8_t* target) {
-  return EpsCopyOutputStream::UnsafeVarint(value, target);
-}
-
-inline uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLine(
-    uint32_t value, uint8_t* target) {
-  target[0] = static_cast<uint8_t>(value);
-  if (value < 0x80) {
-    return target + 1;
-  } else {
-    return WriteVarint32ToArrayOutOfLineHelper(value, target);
-  }
-}
-
-inline uint8_t* CodedOutputStream::WriteVarint64ToArray(uint64_t value,
-                                                        uint8_t* target) {
-  return EpsCopyOutputStream::UnsafeVarint(value, target);
-}
-
-inline void CodedOutputStream::WriteVarint32SignExtended(int32_t value) {
-  WriteVarint64(static_cast<uint64_t>(value));
-}
-
-inline uint8_t* CodedOutputStream::WriteVarint32SignExtendedToArray(
-    int32_t value, uint8_t* target) {
-  return WriteVarint64ToArray(static_cast<uint64_t>(value), target);
-}
-
-inline uint8_t* CodedOutputStream::WriteLittleEndian32ToArray(uint32_t value,
-                                                              uint8_t* target) {
+            }
+
+            inline uint32_t CodedInputStream::ReadTagNoLastTag()
+            {
+                uint32_t v = 0;
+                if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_))
+                {
+                    v = *buffer_;
+                    if (v < 0x80)
+                    {
+                        Advance(1);
+                        return v;
+                    }
+                }
+                v = ReadTagFallback(v);
+                return v;
+            }
+
+            inline std::pair<uint32_t, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
+                uint32_t cutoff
+            )
+            {
+                // In performance-sensitive code we can expect cutoff to be a compile-time
+                // constant, and things like "cutoff >= kMax1ByteVarint" to be evaluated at
+                // compile time.
+                uint32_t first_byte_or_zero = 0;
+                if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_))
+                {
+                    // Hot case: buffer_ non_empty, buffer_[0] in [1, 128).
+                    // TODO(gpike): Is it worth rearranging this? E.g., if the number of fields
+                    // is large enough then is it better to check for the two-byte case first?
+                    first_byte_or_zero = buffer_[0];
+                    if (static_cast<int8_t>(buffer_[0]) > 0)
+                    {
+                        const uint32_t kMax1ByteVarint = 0x7f;
+                        uint32_t tag = buffer_[0];
+                        Advance(1);
+                        return std::make_pair(tag, cutoff >= kMax1ByteVarint || tag <= cutoff);
+                    }
+                    // Other hot case: cutoff >= 0x80, buffer_ has at least two bytes available,
+                    // and tag is two bytes.  The latter is tested by bitwise-and-not of the
+                    // first byte and the second byte.
+                    if (cutoff >= 0x80 && PROTOBUF_PREDICT_TRUE(buffer_ + 1 < buffer_end_) &&
+                        PROTOBUF_PREDICT_TRUE((buffer_[0] & ~buffer_[1]) >= 0x80))
+                    {
+                        const uint32_t kMax2ByteVarint = (0x7f << 7) + 0x7f;
+                        uint32_t tag = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
+                        Advance(2);
+                        // It might make sense to test for tag == 0 now, but it is so rare that
+                        // that we don't bother.  A varint-encoded 0 should be one byte unless
+                        // the encoder lost its mind.  The second part of the return value of
+                        // this function is allowed to be either true or false if the tag is 0,
+                        // so we don't have to check for tag == 0.  We may need to check whether
+                        // it exceeds cutoff.
+                        bool at_or_below_cutoff = cutoff >= kMax2ByteVarint || tag <= cutoff;
+                        return std::make_pair(tag, at_or_below_cutoff);
+                    }
+                }
+                // Slow path
+                const uint32_t tag = ReadTagFallback(first_byte_or_zero);
+                return std::make_pair(tag, static_cast<uint32_t>(tag - 1) < cutoff);
+            }
+
+            inline bool CodedInputStream::LastTagWas(uint32_t expected)
+            {
+                return last_tag_ == expected;
+            }
+
+            inline bool CodedInputStream::ConsumedEntireMessage()
+            {
+                return legitimate_message_end_;
+            }
+
+            inline bool CodedInputStream::ExpectTag(uint32_t expected)
+            {
+                if (expected < (1 << 7))
+                {
+                    if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) &&
+                        buffer_[0] == expected)
+                    {
+                        Advance(1);
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                else if (expected < (1 << 14))
+                {
+                    if (PROTOBUF_PREDICT_TRUE(BufferSize() >= 2) &&
+                        buffer_[0] == static_cast<uint8_t>(expected | 0x80) &&
+                        buffer_[1] == static_cast<uint8_t>(expected >> 7))
+                    {
+                        Advance(2);
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    // Don't bother optimizing for larger values.
+                    return false;
+                }
+            }
+
+            inline const uint8_t* CodedInputStream::ExpectTagFromArray(
+                const uint8_t* buffer, uint32_t expected
+            )
+            {
+                if (expected < (1 << 7))
+                {
+                    if (buffer[0] == expected)
+                    {
+                        return buffer + 1;
+                    }
+                }
+                else if (expected < (1 << 14))
+                {
+                    if (buffer[0] == static_cast<uint8_t>(expected | 0x80) &&
+                        buffer[1] == static_cast<uint8_t>(expected >> 7))
+                    {
+                        return buffer + 2;
+                    }
+                }
+                return nullptr;
+            }
+
+            inline void CodedInputStream::GetDirectBufferPointerInline(const void** data, int* size)
+            {
+                *data = buffer_;
+                *size = static_cast<int>(buffer_end_ - buffer_);
+            }
+
+            inline bool CodedInputStream::ExpectAtEnd()
+            {
+                // If we are at a limit we know no more bytes can be read.  Otherwise, it's
+                // hard to say without calling Refresh(), and we'd rather not do that.
+
+                if (buffer_ == buffer_end_ && ((buffer_size_after_limit_ != 0) ||
+                                               (total_bytes_read_ == current_limit_)))
+                {
+                    last_tag_ = 0;                   // Pretend we called ReadTag()...
+                    legitimate_message_end_ = true;  // ... and it hit EOF.
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            inline int CodedInputStream::CurrentPosition() const
+            {
+                return total_bytes_read_ - (BufferSize() + buffer_size_after_limit_);
+            }
+
+            inline void CodedInputStream::Advance(int amount)
+            {
+                buffer_ += amount;
+            }
+
+            inline void CodedInputStream::SetRecursionLimit(int limit)
+            {
+                recursion_budget_ += limit - recursion_limit_;
+                recursion_limit_ = limit;
+            }
+
+            inline bool CodedInputStream::IncrementRecursionDepth()
+            {
+                --recursion_budget_;
+                return recursion_budget_ >= 0;
+            }
+
+            inline void CodedInputStream::DecrementRecursionDepth()
+            {
+                if (recursion_budget_ < recursion_limit_)
+                    ++recursion_budget_;
+            }
+
+            inline void CodedInputStream::UnsafeDecrementRecursionDepth()
+            {
+                assert(recursion_budget_ < recursion_limit_);
+                ++recursion_budget_;
+            }
+
+            inline void CodedInputStream::SetExtensionRegistry(const DescriptorPool* pool, MessageFactory* factory)
+            {
+                extension_pool_ = pool;
+                extension_factory_ = factory;
+            }
+
+            inline const DescriptorPool* CodedInputStream::GetExtensionPool()
+            {
+                return extension_pool_;
+            }
+
+            inline MessageFactory* CodedInputStream::GetExtensionFactory()
+            {
+                return extension_factory_;
+            }
+
+            inline int CodedInputStream::BufferSize() const
+            {
+                return static_cast<int>(buffer_end_ - buffer_);
+            }
+
+            inline CodedInputStream::CodedInputStream(ZeroCopyInputStream* input) :
+                buffer_(nullptr),
+                buffer_end_(nullptr),
+                input_(input),
+                total_bytes_read_(0),
+                overflow_bytes_(0),
+                last_tag_(0),
+                legitimate_message_end_(false),
+                aliasing_enabled_(false),
+                current_limit_(std::numeric_limits<int32_t>::max()),
+                buffer_size_after_limit_(0),
+                total_bytes_limit_(kDefaultTotalBytesLimit),
+                recursion_budget_(default_recursion_limit_),
+                recursion_limit_(default_recursion_limit_),
+                extension_pool_(nullptr),
+                extension_factory_(nullptr)
+            {
+                // Eagerly Refresh() so buffer space is immediately available.
+                Refresh();
+            }
+
+            inline CodedInputStream::CodedInputStream(const uint8_t* buffer, int size) :
+                buffer_(buffer),
+                buffer_end_(buffer + size),
+                input_(nullptr),
+                total_bytes_read_(size),
+                overflow_bytes_(0),
+                last_tag_(0),
+                legitimate_message_end_(false),
+                aliasing_enabled_(false),
+                current_limit_(size),
+                buffer_size_after_limit_(0),
+                total_bytes_limit_(kDefaultTotalBytesLimit),
+                recursion_budget_(default_recursion_limit_),
+                recursion_limit_(default_recursion_limit_),
+                extension_pool_(nullptr),
+                extension_factory_(nullptr)
+            {
+                // Note that setting current_limit_ == size is important to prevent some
+                // code paths from trying to access input_ and segfaulting.
+            }
+
+            inline bool CodedInputStream::IsFlat() const
+            {
+                return input_ == nullptr;
+            }
+
+            inline bool CodedInputStream::Skip(int count)
+            {
+                if (count < 0)
+                    return false;  // security: count is often user-supplied
+
+                const int original_buffer_size = BufferSize();
+
+                if (count <= original_buffer_size)
+                {
+                    // Just skipping within the current buffer.  Easy.
+                    Advance(count);
+                    return true;
+                }
+
+                return SkipFallback(count, original_buffer_size);
+            }
+
+            template<class Stream, class>
+            inline CodedOutputStream::CodedOutputStream(Stream* stream) :
+                impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
+                start_count_(stream->ByteCount())
+            {
+                InitEagerly(stream);
+            }
+
+            template<class Stream, class>
+            inline CodedOutputStream::CodedOutputStream(Stream* stream, bool eager_init) :
+                impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
+                start_count_(stream->ByteCount())
+            {
+                if (eager_init)
+                {
+                    InitEagerly(stream);
+                }
+            }
+
+            template<class Stream>
+            inline void CodedOutputStream::InitEagerly(Stream* stream)
+            {
+                void* data;
+                int size;
+                if (PROTOBUF_PREDICT_TRUE(stream->Next(&data, &size) && size > 0))
+                {
+                    cur_ = impl_.SetInitialBuffer(data, size);
+                }
+            }
+
+            inline uint8_t* CodedOutputStream::WriteVarint32ToArray(uint32_t value, uint8_t* target)
+            {
+                return EpsCopyOutputStream::UnsafeVarint(value, target);
+            }
+
+            inline uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLine(
+                uint32_t value, uint8_t* target
+            )
+            {
+                target[0] = static_cast<uint8_t>(value);
+                if (value < 0x80)
+                {
+                    return target + 1;
+                }
+                else
+                {
+                    return WriteVarint32ToArrayOutOfLineHelper(value, target);
+                }
+            }
+
+            inline uint8_t* CodedOutputStream::WriteVarint64ToArray(uint64_t value, uint8_t* target)
+            {
+                return EpsCopyOutputStream::UnsafeVarint(value, target);
+            }
+
+            inline void CodedOutputStream::WriteVarint32SignExtended(int32_t value)
+            {
+                WriteVarint64(static_cast<uint64_t>(value));
+            }
+
+            inline uint8_t* CodedOutputStream::WriteVarint32SignExtendedToArray(
+                int32_t value, uint8_t* target
+            )
+            {
+                return WriteVarint64ToArray(static_cast<uint64_t>(value), target);
+            }
+
+            inline uint8_t* CodedOutputStream::WriteLittleEndian32ToArray(uint32_t value, uint8_t* target)
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  memcpy(target, &value, sizeof(value));
+                memcpy(target, &value, sizeof(value));
 #else
-  target[0] = static_cast<uint8_t>(value);
-  target[1] = static_cast<uint8_t>(value >> 8);
-  target[2] = static_cast<uint8_t>(value >> 16);
-  target[3] = static_cast<uint8_t>(value >> 24);
+                target[0] = static_cast<uint8_t>(value);
+                target[1] = static_cast<uint8_t>(value >> 8);
+                target[2] = static_cast<uint8_t>(value >> 16);
+                target[3] = static_cast<uint8_t>(value >> 24);
 #endif
-  return target + sizeof(value);
-}
+                return target + sizeof(value);
+            }
 
-inline uint8_t* CodedOutputStream::WriteLittleEndian64ToArray(uint64_t value,
-                                                              uint8_t* target) {
+            inline uint8_t* CodedOutputStream::WriteLittleEndian64ToArray(uint64_t value, uint8_t* target)
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-  memcpy(target, &value, sizeof(value));
+                memcpy(target, &value, sizeof(value));
 #else
-  uint32_t part0 = static_cast<uint32_t>(value);
-  uint32_t part1 = static_cast<uint32_t>(value >> 32);
-
-  target[0] = static_cast<uint8_t>(part0);
-  target[1] = static_cast<uint8_t>(part0 >> 8);
-  target[2] = static_cast<uint8_t>(part0 >> 16);
-  target[3] = static_cast<uint8_t>(part0 >> 24);
-  target[4] = static_cast<uint8_t>(part1);
-  target[5] = static_cast<uint8_t>(part1 >> 8);
-  target[6] = static_cast<uint8_t>(part1 >> 16);
-  target[7] = static_cast<uint8_t>(part1 >> 24);
+                uint32_t part0 = static_cast<uint32_t>(value);
+                uint32_t part1 = static_cast<uint32_t>(value >> 32);
+
+                target[0] = static_cast<uint8_t>(part0);
+                target[1] = static_cast<uint8_t>(part0 >> 8);
+                target[2] = static_cast<uint8_t>(part0 >> 16);
+                target[3] = static_cast<uint8_t>(part0 >> 24);
+                target[4] = static_cast<uint8_t>(part1);
+                target[5] = static_cast<uint8_t>(part1 >> 8);
+                target[6] = static_cast<uint8_t>(part1 >> 16);
+                target[7] = static_cast<uint8_t>(part1 >> 24);
 #endif
-  return target + sizeof(value);
-}
-
-inline void CodedOutputStream::WriteVarint32(uint32_t value) {
-  cur_ = impl_.EnsureSpace(cur_);
-  SetCur(WriteVarint32ToArray(value, Cur()));
-}
-
-inline void CodedOutputStream::WriteVarint64(uint64_t value) {
-  cur_ = impl_.EnsureSpace(cur_);
-  SetCur(WriteVarint64ToArray(value, Cur()));
-}
-
-inline void CodedOutputStream::WriteTag(uint32_t value) {
-  WriteVarint32(value);
-}
-
-inline uint8_t* CodedOutputStream::WriteTagToArray(uint32_t value,
-                                                   uint8_t* target) {
-  return WriteVarint32ToArray(value, target);
-}
-
-inline size_t CodedOutputStream::VarintSize32(uint32_t value) {
-  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
-  // Use an explicit multiplication to implement the divide of
-  // a number in the 1..31 range.
-  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
-  // undefined.
-  uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
-  return static_cast<size_t>((log2value * 9 + 73) / 64);
-}
-
-inline size_t CodedOutputStream::VarintSize32PlusOne(uint32_t value) {
-  // Same as above, but one more.
-  uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
-  return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
-}
-
-inline size_t CodedOutputStream::VarintSize64(uint64_t value) {
-  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
-  // Use an explicit multiplication to implement the divide of
-  // a number in the 1..63 range.
-  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
-  // undefined.
-  uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
-  return static_cast<size_t>((log2value * 9 + 73) / 64);
-}
-
-inline size_t CodedOutputStream::VarintSize64PlusOne(uint64_t value) {
-  // Same as above, but one more.
-  uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
-  return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
-}
-
-inline size_t CodedOutputStream::VarintSize32SignExtended(int32_t value) {
-  return VarintSize64(static_cast<uint64_t>(int64_t{value}));
-}
-
-inline size_t CodedOutputStream::VarintSize32SignExtendedPlusOne(
-    int32_t value) {
-  return VarintSize64PlusOne(static_cast<uint64_t>(int64_t{value}));
-}
-
-inline void CodedOutputStream::WriteString(const std::string& str) {
-  WriteRaw(str.data(), static_cast<int>(str.size()));
-}
-
-inline void CodedOutputStream::WriteRawMaybeAliased(const void* data,
-                                                    int size) {
-  cur_ = impl_.WriteRawMaybeAliased(data, size, cur_);
-}
-
-inline uint8_t* CodedOutputStream::WriteRawToArray(const void* data, int size,
-                                                   uint8_t* target) {
-  memcpy(target, data, size);
-  return target + size;
-}
-
-inline uint8_t* CodedOutputStream::WriteStringToArray(const std::string& str,
-                                                      uint8_t* target) {
-  return WriteRawToArray(str.data(), static_cast<int>(str.size()), target);
-}
-
-}  // namespace io
-}  // namespace protobuf
+                return target + sizeof(value);
+            }
+
+            inline void CodedOutputStream::WriteVarint32(uint32_t value)
+            {
+                cur_ = impl_.EnsureSpace(cur_);
+                SetCur(WriteVarint32ToArray(value, Cur()));
+            }
+
+            inline void CodedOutputStream::WriteVarint64(uint64_t value)
+            {
+                cur_ = impl_.EnsureSpace(cur_);
+                SetCur(WriteVarint64ToArray(value, Cur()));
+            }
+
+            inline void CodedOutputStream::WriteTag(uint32_t value)
+            {
+                WriteVarint32(value);
+            }
+
+            inline uint8_t* CodedOutputStream::WriteTagToArray(uint32_t value, uint8_t* target)
+            {
+                return WriteVarint32ToArray(value, target);
+            }
+
+            inline size_t CodedOutputStream::VarintSize32(uint32_t value)
+            {
+                // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
+                // Use an explicit multiplication to implement the divide of
+                // a number in the 1..31 range.
+                // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
+                // undefined.
+                uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
+                return static_cast<size_t>((log2value * 9 + 73) / 64);
+            }
+
+            inline size_t CodedOutputStream::VarintSize32PlusOne(uint32_t value)
+            {
+                // Same as above, but one more.
+                uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
+                return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
+            }
+
+            inline size_t CodedOutputStream::VarintSize64(uint64_t value)
+            {
+                // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
+                // Use an explicit multiplication to implement the divide of
+                // a number in the 1..63 range.
+                // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
+                // undefined.
+                uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
+                return static_cast<size_t>((log2value * 9 + 73) / 64);
+            }
+
+            inline size_t CodedOutputStream::VarintSize64PlusOne(uint64_t value)
+            {
+                // Same as above, but one more.
+                uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
+                return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
+            }
+
+            inline size_t CodedOutputStream::VarintSize32SignExtended(int32_t value)
+            {
+                return VarintSize64(static_cast<uint64_t>(int64_t{value}));
+            }
+
+            inline size_t CodedOutputStream::VarintSize32SignExtendedPlusOne(
+                int32_t value
+            )
+            {
+                return VarintSize64PlusOne(static_cast<uint64_t>(int64_t{value}));
+            }
+
+            inline void CodedOutputStream::WriteString(const std::string& str)
+            {
+                WriteRaw(str.data(), static_cast<int>(str.size()));
+            }
+
+            inline void CodedOutputStream::WriteRawMaybeAliased(const void* data, int size)
+            {
+                cur_ = impl_.WriteRawMaybeAliased(data, size, cur_);
+            }
+
+            inline uint8_t* CodedOutputStream::WriteRawToArray(const void* data, int size, uint8_t* target)
+            {
+                memcpy(target, data, size);
+                return target + size;
+            }
+
+            inline uint8_t* CodedOutputStream::WriteStringToArray(const std::string& str, uint8_t* target)
+            {
+                return WriteRawToArray(str.data(), static_cast<int>(str.size()), target);
+            }
+
+        }  // namespace io
+    }      // namespace protobuf
 }  // namespace google
 
 #if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/gzip_stream.h b/CAPI/cpp/grpc/include/google/protobuf/io/gzip_stream.h
index 4cf71b6..e0f2ae9 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/gzip_stream.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/gzip_stream.h
@@ -43,7 +43,6 @@
 #ifndef GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
 #define GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
 
-
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/io/zero_copy_stream.h>
 #include <google/protobuf/port.h>
@@ -52,152 +51,169 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace io {
-
-// A ZeroCopyInputStream that reads compressed data through zlib
-class PROTOBUF_EXPORT GzipInputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyInputStream {
- public:
-  // Format key for constructor
-  enum Format {
-    // zlib will autodetect gzip header or deflate stream
-    AUTO = 0,
-
-    // GZIP streams have some extra header data for file attributes.
-    GZIP = 1,
-
-    // Simpler zlib stream format.
-    ZLIB = 2,
-  };
-
-  // buffer_size and format may be -1 for default of 64kB and GZIP format
-  explicit GzipInputStream(ZeroCopyInputStream* sub_stream,
-                           Format format = AUTO, int buffer_size = -1);
-  virtual ~GzipInputStream();
-
-  // Return last error message or NULL if no error.
-  inline const char* ZlibErrorMessage() const { return zcontext_.msg; }
-  inline int ZlibErrorCode() const { return zerror_; }
-
-  // implements ZeroCopyInputStream ----------------------------------
-  bool Next(const void** data, int* size) override;
-  void BackUp(int count) override;
-  bool Skip(int count) override;
-  int64_t ByteCount() const override;
-
- private:
-  Format format_;
-
-  ZeroCopyInputStream* sub_stream_;
-
-  z_stream zcontext_;
-  int zerror_;
-
-  void* output_buffer_;
-  void* output_position_;
-  size_t output_buffer_length_;
-  int64_t byte_count_;
-
-  int Inflate(int flush);
-  void DoNextOutput(const void** data, int* size);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipInputStream);
-};
-
-class PROTOBUF_EXPORT GzipOutputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyOutputStream {
- public:
-  // Format key for constructor
-  enum Format {
-    // GZIP streams have some extra header data for file attributes.
-    GZIP = 1,
-
-    // Simpler zlib stream format.
-    ZLIB = 2,
-  };
-
-  struct PROTOBUF_EXPORT Options {
-    // Defaults to GZIP.
-    Format format;
-
-    // What size buffer to use internally.  Defaults to 64kB.
-    int buffer_size;
-
-    // A number between 0 and 9, where 0 is no compression and 9 is best
-    // compression.  Defaults to Z_DEFAULT_COMPRESSION (see zlib.h).
-    int compression_level;
-
-    // Defaults to Z_DEFAULT_STRATEGY.  Can also be set to Z_FILTERED,
-    // Z_HUFFMAN_ONLY, or Z_RLE.  See the documentation for deflateInit2 in
-    // zlib.h for definitions of these constants.
-    int compression_strategy;
-
-    Options();  // Initializes with default values.
-  };
-
-  // Create a GzipOutputStream with default options.
-  explicit GzipOutputStream(ZeroCopyOutputStream* sub_stream);
-
-  // Create a GzipOutputStream with the given options.
-  GzipOutputStream(ZeroCopyOutputStream* sub_stream, const Options& options);
-
-  virtual ~GzipOutputStream();
-
-  // Return last error message or NULL if no error.
-  inline const char* ZlibErrorMessage() const { return zcontext_.msg; }
-  inline int ZlibErrorCode() const { return zerror_; }
-
-  // Flushes data written so far to zipped data in the underlying stream.
-  // It is the caller's responsibility to flush the underlying stream if
-  // necessary.
-  // Compression may be less efficient stopping and starting around flushes.
-  // Returns true if no error.
-  //
-  // Please ensure that block size is > 6. Here is an excerpt from the zlib
-  // doc that explains why:
-  //
-  // In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that avail_out
-  // is greater than six to avoid repeated flush markers due to
-  // avail_out == 0 on return.
-  bool Flush();
-
-  // Writes out all data and closes the gzip stream.
-  // It is the caller's responsibility to close the underlying stream if
-  // necessary.
-  // Returns true if no error.
-  bool Close();
-
-  // implements ZeroCopyOutputStream ---------------------------------
-  bool Next(void** data, int* size) override;
-  void BackUp(int count) override;
-  int64_t ByteCount() const override;
-
- private:
-  ZeroCopyOutputStream* sub_stream_;
-  // Result from calling Next() on sub_stream_
-  void* sub_data_;
-  int sub_data_size_;
-
-  z_stream zcontext_;
-  int zerror_;
-  void* input_buffer_;
-  size_t input_buffer_length_;
-
-  // Shared constructor code.
-  void Init(ZeroCopyOutputStream* sub_stream, const Options& options);
-
-  // Do some compression.
-  // Takes zlib flush mode.
-  // Returns zlib error code.
-  int Deflate(int flush);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipOutputStream);
-};
-
-}  // namespace io
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
+
+            // A ZeroCopyInputStream that reads compressed data through zlib
+            class PROTOBUF_EXPORT GzipInputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyInputStream
+            {
+            public:
+                // Format key for constructor
+                enum Format
+                {
+                    // zlib will autodetect gzip header or deflate stream
+                    AUTO = 0,
+
+                    // GZIP streams have some extra header data for file attributes.
+                    GZIP = 1,
+
+                    // Simpler zlib stream format.
+                    ZLIB = 2,
+                };
+
+                // buffer_size and format may be -1 for default of 64kB and GZIP format
+                explicit GzipInputStream(ZeroCopyInputStream* sub_stream, Format format = AUTO, int buffer_size = -1);
+                virtual ~GzipInputStream();
+
+                // Return last error message or NULL if no error.
+                inline const char* ZlibErrorMessage() const
+                {
+                    return zcontext_.msg;
+                }
+                inline int ZlibErrorCode() const
+                {
+                    return zerror_;
+                }
+
+                // implements ZeroCopyInputStream ----------------------------------
+                bool Next(const void** data, int* size) override;
+                void BackUp(int count) override;
+                bool Skip(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                Format format_;
+
+                ZeroCopyInputStream* sub_stream_;
+
+                z_stream zcontext_;
+                int zerror_;
+
+                void* output_buffer_;
+                void* output_position_;
+                size_t output_buffer_length_;
+                int64_t byte_count_;
+
+                int Inflate(int flush);
+                void DoNextOutput(const void** data, int* size);
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipInputStream);
+            };
+
+            class PROTOBUF_EXPORT GzipOutputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyOutputStream
+            {
+            public:
+                // Format key for constructor
+                enum Format
+                {
+                    // GZIP streams have some extra header data for file attributes.
+                    GZIP = 1,
+
+                    // Simpler zlib stream format.
+                    ZLIB = 2,
+                };
+
+                struct PROTOBUF_EXPORT Options
+                {
+                    // Defaults to GZIP.
+                    Format format;
+
+                    // What size buffer to use internally.  Defaults to 64kB.
+                    int buffer_size;
+
+                    // A number between 0 and 9, where 0 is no compression and 9 is best
+                    // compression.  Defaults to Z_DEFAULT_COMPRESSION (see zlib.h).
+                    int compression_level;
+
+                    // Defaults to Z_DEFAULT_STRATEGY.  Can also be set to Z_FILTERED,
+                    // Z_HUFFMAN_ONLY, or Z_RLE.  See the documentation for deflateInit2 in
+                    // zlib.h for definitions of these constants.
+                    int compression_strategy;
+
+                    Options();  // Initializes with default values.
+                };
+
+                // Create a GzipOutputStream with default options.
+                explicit GzipOutputStream(ZeroCopyOutputStream* sub_stream);
+
+                // Create a GzipOutputStream with the given options.
+                GzipOutputStream(ZeroCopyOutputStream* sub_stream, const Options& options);
+
+                virtual ~GzipOutputStream();
+
+                // Return last error message or NULL if no error.
+                inline const char* ZlibErrorMessage() const
+                {
+                    return zcontext_.msg;
+                }
+                inline int ZlibErrorCode() const
+                {
+                    return zerror_;
+                }
+
+                // Flushes data written so far to zipped data in the underlying stream.
+                // It is the caller's responsibility to flush the underlying stream if
+                // necessary.
+                // Compression may be less efficient stopping and starting around flushes.
+                // Returns true if no error.
+                //
+                // Please ensure that block size is > 6. Here is an excerpt from the zlib
+                // doc that explains why:
+                //
+                // In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that avail_out
+                // is greater than six to avoid repeated flush markers due to
+                // avail_out == 0 on return.
+                bool Flush();
+
+                // Writes out all data and closes the gzip stream.
+                // It is the caller's responsibility to close the underlying stream if
+                // necessary.
+                // Returns true if no error.
+                bool Close();
+
+                // implements ZeroCopyOutputStream ---------------------------------
+                bool Next(void** data, int* size) override;
+                void BackUp(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                ZeroCopyOutputStream* sub_stream_;
+                // Result from calling Next() on sub_stream_
+                void* sub_data_;
+                int sub_data_size_;
+
+                z_stream zcontext_;
+                int zerror_;
+                void* input_buffer_;
+                size_t input_buffer_length_;
+
+                // Shared constructor code.
+                void Init(ZeroCopyOutputStream* sub_stream, const Options& options);
+
+                // Do some compression.
+                // Takes zlib flush mode.
+                // Returns zlib error code.
+                int Deflate(int flush);
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipOutputStream);
+            };
+
+        }  // namespace io
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/io_win32.h b/CAPI/cpp/grpc/include/google/protobuf/io/io_win32.h
index a72b4ea..fa0b8b5 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/io_win32.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/io_win32.h
@@ -59,63 +59,69 @@
 
 // Compilers on Windows other than MSVC (e.g. Cygwin, MinGW32) define the
 // following functions already, except for mkdir.
-namespace google {
-namespace protobuf {
-namespace io {
-namespace win32 {
-
-PROTOBUF_EXPORT FILE* fopen(const char* path, const char* mode);
-PROTOBUF_EXPORT int access(const char* path, int mode);
-PROTOBUF_EXPORT int chdir(const char* path);
-PROTOBUF_EXPORT int close(int fd);
-PROTOBUF_EXPORT int dup(int fd);
-PROTOBUF_EXPORT int dup2(int fd1, int fd2);
-PROTOBUF_EXPORT int mkdir(const char* path, int _mode);
-PROTOBUF_EXPORT int open(const char* path, int flags, int mode = 0);
-PROTOBUF_EXPORT int read(int fd, void* buffer, size_t size);
-PROTOBUF_EXPORT int setmode(int fd, int mode);
-PROTOBUF_EXPORT int stat(const char* path, struct _stat* buffer);
-PROTOBUF_EXPORT int write(int fd, const void* buffer, size_t size);
-PROTOBUF_EXPORT std::wstring testonly_utf8_to_winpath(const char* path);
-
-enum class ExpandWildcardsResult {
-  kSuccess = 0,
-  kErrorNoMatchingFile = 1,
-  kErrorInputPathConversion = 2,
-  kErrorOutputPathConversion = 3,
-};
-
-// Expand wildcards in a path pattern, feed the result to a consumer function.
-//
-// `path` must be a valid, Windows-style path. It may be absolute, or relative
-// to the current working directory, and it may contain wildcards ("*" and "?")
-// in the last path segment. This function passes all matching file names to
-// `consume`. The resulting paths may not be absolute nor normalized.
-//
-// The function returns a value from `ExpandWildcardsResult`.
-PROTOBUF_EXPORT ExpandWildcardsResult ExpandWildcards(
-    const std::string& path, std::function<void(const std::string&)> consume);
-
-namespace strings {
-
-// Convert from UTF-16 to Active-Code-Page-encoded or to UTF-8-encoded text.
-PROTOBUF_EXPORT bool wcs_to_mbs(const wchar_t* s, std::string* out,
-                                bool outUtf8);
-
-// Convert from Active-Code-Page-encoded or UTF-8-encoded text to UTF-16.
-PROTOBUF_EXPORT bool mbs_to_wcs(const char* s, std::wstring* out, bool inUtf8);
-
-// Convert from UTF-8-encoded text to UTF-16.
-PROTOBUF_EXPORT bool utf8_to_wcs(const char* input, std::wstring* out);
-
-// Convert from UTF-16-encoded text to UTF-8.
-PROTOBUF_EXPORT bool wcs_to_utf8(const wchar_t* input, std::string* out);
-
-}  // namespace strings
-
-}  // namespace win32
-}  // namespace io
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
+            namespace win32
+            {
+
+                PROTOBUF_EXPORT FILE* fopen(const char* path, const char* mode);
+                PROTOBUF_EXPORT int access(const char* path, int mode);
+                PROTOBUF_EXPORT int chdir(const char* path);
+                PROTOBUF_EXPORT int close(int fd);
+                PROTOBUF_EXPORT int dup(int fd);
+                PROTOBUF_EXPORT int dup2(int fd1, int fd2);
+                PROTOBUF_EXPORT int mkdir(const char* path, int _mode);
+                PROTOBUF_EXPORT int open(const char* path, int flags, int mode = 0);
+                PROTOBUF_EXPORT int read(int fd, void* buffer, size_t size);
+                PROTOBUF_EXPORT int setmode(int fd, int mode);
+                PROTOBUF_EXPORT int stat(const char* path, struct _stat* buffer);
+                PROTOBUF_EXPORT int write(int fd, const void* buffer, size_t size);
+                PROTOBUF_EXPORT std::wstring testonly_utf8_to_winpath(const char* path);
+
+                enum class ExpandWildcardsResult
+                {
+                    kSuccess = 0,
+                    kErrorNoMatchingFile = 1,
+                    kErrorInputPathConversion = 2,
+                    kErrorOutputPathConversion = 3,
+                };
+
+                // Expand wildcards in a path pattern, feed the result to a consumer function.
+                //
+                // `path` must be a valid, Windows-style path. It may be absolute, or relative
+                // to the current working directory, and it may contain wildcards ("*" and "?")
+                // in the last path segment. This function passes all matching file names to
+                // `consume`. The resulting paths may not be absolute nor normalized.
+                //
+                // The function returns a value from `ExpandWildcardsResult`.
+                PROTOBUF_EXPORT ExpandWildcardsResult ExpandWildcards(
+                    const std::string& path, std::function<void(const std::string&)> consume
+                );
+
+                namespace strings
+                {
+
+                    // Convert from UTF-16 to Active-Code-Page-encoded or to UTF-8-encoded text.
+                    PROTOBUF_EXPORT bool wcs_to_mbs(const wchar_t* s, std::string* out, bool outUtf8);
+
+                    // Convert from Active-Code-Page-encoded or UTF-8-encoded text to UTF-16.
+                    PROTOBUF_EXPORT bool mbs_to_wcs(const char* s, std::wstring* out, bool inUtf8);
+
+                    // Convert from UTF-8-encoded text to UTF-16.
+                    PROTOBUF_EXPORT bool utf8_to_wcs(const char* input, std::wstring* out);
+
+                    // Convert from UTF-16-encoded text to UTF-8.
+                    PROTOBUF_EXPORT bool wcs_to_utf8(const wchar_t* input, std::string* out);
+
+                }  // namespace strings
+
+            }  // namespace win32
+        }      // namespace io
+    }          // namespace protobuf
 }  // namespace google
 
 #ifndef W_OK
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/printer.h b/CAPI/cpp/grpc/include/google/protobuf/io/printer.h
index 92a4321..dae67bf 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/printer.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/printer.h
@@ -37,7 +37,6 @@
 #ifndef GOOGLE_PROTOBUF_IO_PRINTER_H__
 #define GOOGLE_PROTOBUF_IO_PRINTER_H__
 
-
 #include <map>
 #include <string>
 #include <vector>
@@ -47,339 +46,357 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace io {
-
-class ZeroCopyOutputStream;  // zero_copy_stream.h
-
-// Records annotations about a Printer's output.
-class PROTOBUF_EXPORT AnnotationCollector {
- public:
-  // Annotation is a offset range and a payload pair.
-  typedef std::pair<std::pair<size_t, size_t>, std::string> Annotation;
-
-  // Records that the bytes in file_path beginning with begin_offset and ending
-  // before end_offset are associated with the SourceCodeInfo-style path.
-  virtual void AddAnnotation(size_t begin_offset, size_t end_offset,
-                             const std::string& file_path,
-                             const std::vector<int>& path) = 0;
-
-  // TODO(gerbens) I don't see why we need virtuals here. Just a vector of
-  // range, payload pairs stored in a context should suffice.
-  virtual void AddAnnotationNew(Annotation& /* a */) {}
-
-  virtual ~AnnotationCollector() {}
-};
-
-// Records annotations about a Printer's output to the given protocol buffer,
-// assuming that the buffer has an ::Annotation message exposing path,
-// source_file, begin and end fields.
-template <typename AnnotationProto>
-class AnnotationProtoCollector : public AnnotationCollector {
- public:
-  // annotation_proto is the protocol buffer to which new Annotations should be
-  // added. It is not owned by the AnnotationProtoCollector.
-  explicit AnnotationProtoCollector(AnnotationProto* annotation_proto)
-      : annotation_proto_(annotation_proto) {}
-
-  // Override for AnnotationCollector::AddAnnotation.
-  void AddAnnotation(size_t begin_offset, size_t end_offset,
-                     const std::string& file_path,
-                     const std::vector<int>& path) override {
-    typename AnnotationProto::Annotation* annotation =
-        annotation_proto_->add_annotation();
-    for (int i = 0; i < path.size(); ++i) {
-      annotation->add_path(path[i]);
-    }
-    annotation->set_source_file(file_path);
-    annotation->set_begin(begin_offset);
-    annotation->set_end(end_offset);
-  }
-  // Override for AnnotationCollector::AddAnnotation.
-  void AddAnnotationNew(Annotation& a) override {
-    auto* annotation = annotation_proto_->add_annotation();
-    annotation->ParseFromString(a.second);
-    annotation->set_begin(a.first.first);
-    annotation->set_end(a.first.second);
-  }
-
- private:
-  // The protocol buffer to which new annotations should be added.
-  AnnotationProto* const annotation_proto_;
-};
-
-// This simple utility class assists in code generation.  It basically
-// allows the caller to define a set of variables and then output some
-// text with variable substitutions.  Example usage:
-//
-//   Printer printer(output, '$');
-//   map<string, string> vars;
-//   vars["name"] = "Bob";
-//   printer.Print(vars, "My name is $name$.");
-//
-// The above writes "My name is Bob." to the output stream.
-//
-// Printer aggressively enforces correct usage, crashing (with assert failures)
-// in the case of undefined variables in debug builds. This helps greatly in
-// debugging code which uses it.
-//
-// If a Printer is constructed with an AnnotationCollector, it will provide it
-// with annotations that connect the Printer's output to paths that can identify
-// various descriptors.  In the above example, if person_ is a descriptor that
-// identifies Bob, we can associate the output string "My name is Bob." with
-// a source path pointing to that descriptor with:
-//
-//   printer.Annotate("name", person_);
-//
-// The AnnotationCollector will be sent an annotation linking the output range
-// covering "Bob" to the logical path provided by person_.  Tools may use
-// this association to (for example) link "Bob" in the output back to the
-// source file that defined the person_ descriptor identifying Bob.
-//
-// Annotate can only examine variables substituted during the last call to
-// Print.  It is invalid to refer to a variable that was used multiple times
-// in a single Print call.
-//
-// In full generality, one may specify a range of output text using a beginning
-// substitution variable and an ending variable.  The resulting annotation will
-// span from the first character of the substituted value for the beginning
-// variable to the last character of the substituted value for the ending
-// variable.  For example, the Annotate call above is equivalent to this one:
-//
-//   printer.Annotate("name", "name", person_);
-//
-// This is useful if multiple variables combine to form a single span of output
-// that should be annotated with the same source path.  For example:
-//
-//   Printer printer(output, '$');
-//   map<string, string> vars;
-//   vars["first"] = "Alice";
-//   vars["last"] = "Smith";
-//   printer.Print(vars, "My name is $first$ $last$.");
-//   printer.Annotate("first", "last", person_);
-//
-// This code would associate the span covering "Alice Smith" in the output with
-// the person_ descriptor.
-//
-// Note that the beginning variable must come before (or overlap with, in the
-// case of zero-sized substitution values) the ending variable.
-//
-// It is also sometimes useful to use variables with zero-sized values as
-// markers.  This avoids issues with multiple references to the same variable
-// and also allows annotation ranges to span literal text from the Print
-// templates:
-//
-//   Printer printer(output, '$');
-//   map<string, string> vars;
-//   vars["foo"] = "bar";
-//   vars["function"] = "call";
-//   vars["mark"] = "";
-//   printer.Print(vars, "$function$($foo$,$foo$)$mark$");
-//   printer.Annotate("function", "mark", call_);
-//
-// This code associates the span covering "call(bar,bar)" in the output with the
-// call_ descriptor.
-
-class PROTOBUF_EXPORT Printer {
- public:
-  // Create a printer that writes text to the given output stream.  Use the
-  // given character as the delimiter for variables.
-  Printer(ZeroCopyOutputStream* output, char variable_delimiter);
-
-  // Create a printer that writes text to the given output stream.  Use the
-  // given character as the delimiter for variables.  If annotation_collector
-  // is not null, Printer will provide it with annotations about code written
-  // to the stream.  annotation_collector is not owned by Printer.
-  Printer(ZeroCopyOutputStream* output, char variable_delimiter,
-          AnnotationCollector* annotation_collector);
-
-  ~Printer();
-
-  // Link a substitution variable emitted by the last call to Print to the
-  // object described by descriptor.
-  template <typename SomeDescriptor>
-  void Annotate(const char* varname, const SomeDescriptor* descriptor) {
-    Annotate(varname, varname, descriptor);
-  }
-
-  // Link the output range defined by the substitution variables as emitted by
-  // the last call to Print to the object described by descriptor. The range
-  // begins at begin_varname's value and ends after the last character of the
-  // value substituted for end_varname.
-  template <typename SomeDescriptor>
-  void Annotate(const char* begin_varname, const char* end_varname,
-                const SomeDescriptor* descriptor) {
-    if (annotation_collector_ == NULL) {
-      // Annotations aren't turned on for this Printer, so don't pay the cost
-      // of building the location path.
-      return;
-    }
-    std::vector<int> path;
-    descriptor->GetLocationPath(&path);
-    Annotate(begin_varname, end_varname, descriptor->file()->name(), path);
-  }
-
-  // Link a substitution variable emitted by the last call to Print to the file
-  // with path file_name.
-  void Annotate(const char* varname, const std::string& file_name) {
-    Annotate(varname, varname, file_name);
-  }
-
-  // Link the output range defined by the substitution variables as emitted by
-  // the last call to Print to the file with path file_name. The range begins
-  // at begin_varname's value and ends after the last character of the value
-  // substituted for end_varname.
-  void Annotate(const char* begin_varname, const char* end_varname,
-                const std::string& file_name) {
-    if (annotation_collector_ == NULL) {
-      // Annotations aren't turned on for this Printer.
-      return;
-    }
-    std::vector<int> empty_path;
-    Annotate(begin_varname, end_varname, file_name, empty_path);
-  }
-
-  // Print some text after applying variable substitutions.  If a particular
-  // variable in the text is not defined, this will crash.  Variables to be
-  // substituted are identified by their names surrounded by delimiter
-  // characters (as given to the constructor).  The variable bindings are
-  // defined by the given map.
-  void Print(const std::map<std::string, std::string>& variables,
-             const char* text);
-
-  // Like the first Print(), except the substitutions are given as parameters.
-  template <typename... Args>
-  void Print(const char* text, const Args&... args) {
-    std::map<std::string, std::string> vars;
-    PrintInternal(&vars, text, args...);
-  }
-
-  // Indent text by two spaces.  After calling Indent(), two spaces will be
-  // inserted at the beginning of each line of text.  Indent() may be called
-  // multiple times to produce deeper indents.
-  void Indent();
-
-  // Reduces the current indent level by two spaces, or crashes if the indent
-  // level is zero.
-  void Outdent();
-
-  // Write a string to the output buffer.
-  // This method does not look for newlines to add indentation.
-  void PrintRaw(const std::string& data);
-
-  // Write a zero-delimited string to output buffer.
-  // This method does not look for newlines to add indentation.
-  void PrintRaw(const char* data);
-
-  // Write some bytes to the output buffer.
-  // This method does not look for newlines to add indentation.
-  void WriteRaw(const char* data, int size);
-
-  // FormatInternal is a helper function not meant to use directly, use
-  // compiler::cpp::Formatter instead. This function is meant to support
-  // formatting text using named variables (eq. "$foo$) from a lookup map (vars)
-  // and variables directly supplied by arguments (eq "$1$" meaning first
-  // argument which is the zero index element of args).
-  void FormatInternal(const std::vector<std::string>& args,
-                      const std::map<std::string, std::string>& vars,
-                      const char* format);
-
-  // True if any write to the underlying stream failed.  (We don't just
-  // crash in this case because this is an I/O failure, not a programming
-  // error.)
-  bool failed() const { return failed_; }
-
- private:
-  // Link the output range defined by the substitution variables as emitted by
-  // the last call to Print to the object found at the SourceCodeInfo-style path
-  // in a file with path file_path. The range begins at the start of
-  // begin_varname's value and ends after the last character of the value
-  // substituted for end_varname. Note that begin_varname and end_varname
-  // may refer to the same variable.
-  void Annotate(const char* begin_varname, const char* end_varname,
-                const std::string& file_path, const std::vector<int>& path);
-
-  // Base case
-  void PrintInternal(std::map<std::string, std::string>* vars,
-                     const char* text) {
-    Print(*vars, text);
-  }
-
-  template <typename... Args>
-  void PrintInternal(std::map<std::string, std::string>* vars, const char* text,
-                     const char* key, const std::string& value,
-                     const Args&... args) {
-    (*vars)[key] = value;
-    PrintInternal(vars, text, args...);
-  }
-
-  // Copy size worth of bytes from data to buffer_.
-  void CopyToBuffer(const char* data, int size);
-
-  void push_back(char c) {
-    if (failed_) return;
-    if (buffer_size_ == 0) {
-      if (!Next()) return;
-    }
-    *buffer_++ = c;
-    buffer_size_--;
-    offset_++;
-  }
-
-  bool Next();
-
-  inline void IndentIfAtStart();
-  const char* WriteVariable(
-      const std::vector<std::string>& args,
-      const std::map<std::string, std::string>& vars, const char* format,
-      int* arg_index,
-      std::vector<AnnotationCollector::Annotation>* annotations);
-
-  const char variable_delimiter_;
-
-  ZeroCopyOutputStream* const output_;
-  char* buffer_;
-  int buffer_size_;
-  // The current position, in bytes, in the output stream.  This is equivalent
-  // to the total number of bytes that have been written so far.  This value is
-  // used to calculate annotation ranges in the substitutions_ map below.
-  size_t offset_;
-
-  std::string indent_;
-  bool at_start_of_line_;
-  bool failed_;
-
-  // A map from variable name to [start, end) offsets in the output buffer.
-  // These refer to the offsets used for a variable after the last call to
-  // Print.  If a variable was used more than once, the entry used in
-  // this map is set to a negative-length span.  For singly-used variables, the
-  // start offset is the beginning of the substitution; the end offset is the
-  // last byte of the substitution plus one (such that (end - start) is the
-  // length of the substituted string).
-  std::map<std::string, std::pair<size_t, size_t> > substitutions_;
-
-  // Keeps track of the keys in substitutions_ that need to be updated when
-  // indents are inserted. These are keys that refer to the beginning of the
-  // current line.
-  std::vector<std::string> line_start_variables_;
-
-  // Returns true and sets range to the substitution range in the output for
-  // varname if varname was used once in the last call to Print. If varname
-  // was not used, or if it was used multiple times, returns false (and
-  // fails a debug assertion).
-  bool GetSubstitutionRange(const char* varname,
-                            std::pair<size_t, size_t>* range);
-
-  // If non-null, annotation_collector_ is used to store annotations about
-  // generated code.
-  AnnotationCollector* const annotation_collector_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Printer);
-};
-
-}  // namespace io
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
+
+            class ZeroCopyOutputStream;  // zero_copy_stream.h
+
+            // Records annotations about a Printer's output.
+            class PROTOBUF_EXPORT AnnotationCollector
+            {
+            public:
+                // Annotation is a offset range and a payload pair.
+                typedef std::pair<std::pair<size_t, size_t>, std::string> Annotation;
+
+                // Records that the bytes in file_path beginning with begin_offset and ending
+                // before end_offset are associated with the SourceCodeInfo-style path.
+                virtual void AddAnnotation(size_t begin_offset, size_t end_offset, const std::string& file_path, const std::vector<int>& path) = 0;
+
+                // TODO(gerbens) I don't see why we need virtuals here. Just a vector of
+                // range, payload pairs stored in a context should suffice.
+                virtual void AddAnnotationNew(Annotation& /* a */)
+                {
+                }
+
+                virtual ~AnnotationCollector()
+                {
+                }
+            };
+
+            // Records annotations about a Printer's output to the given protocol buffer,
+            // assuming that the buffer has an ::Annotation message exposing path,
+            // source_file, begin and end fields.
+            template<typename AnnotationProto>
+            class AnnotationProtoCollector : public AnnotationCollector
+            {
+            public:
+                // annotation_proto is the protocol buffer to which new Annotations should be
+                // added. It is not owned by the AnnotationProtoCollector.
+                explicit AnnotationProtoCollector(AnnotationProto* annotation_proto) :
+                    annotation_proto_(annotation_proto)
+                {
+                }
+
+                // Override for AnnotationCollector::AddAnnotation.
+                void AddAnnotation(size_t begin_offset, size_t end_offset, const std::string& file_path, const std::vector<int>& path) override
+                {
+                    typename AnnotationProto::Annotation* annotation =
+                        annotation_proto_->add_annotation();
+                    for (int i = 0; i < path.size(); ++i)
+                    {
+                        annotation->add_path(path[i]);
+                    }
+                    annotation->set_source_file(file_path);
+                    annotation->set_begin(begin_offset);
+                    annotation->set_end(end_offset);
+                }
+                // Override for AnnotationCollector::AddAnnotation.
+                void AddAnnotationNew(Annotation& a) override
+                {
+                    auto* annotation = annotation_proto_->add_annotation();
+                    annotation->ParseFromString(a.second);
+                    annotation->set_begin(a.first.first);
+                    annotation->set_end(a.first.second);
+                }
+
+            private:
+                // The protocol buffer to which new annotations should be added.
+                AnnotationProto* const annotation_proto_;
+            };
+
+            // This simple utility class assists in code generation.  It basically
+            // allows the caller to define a set of variables and then output some
+            // text with variable substitutions.  Example usage:
+            //
+            //   Printer printer(output, '$');
+            //   map<string, string> vars;
+            //   vars["name"] = "Bob";
+            //   printer.Print(vars, "My name is $name$.");
+            //
+            // The above writes "My name is Bob." to the output stream.
+            //
+            // Printer aggressively enforces correct usage, crashing (with assert failures)
+            // in the case of undefined variables in debug builds. This helps greatly in
+            // debugging code which uses it.
+            //
+            // If a Printer is constructed with an AnnotationCollector, it will provide it
+            // with annotations that connect the Printer's output to paths that can identify
+            // various descriptors.  In the above example, if person_ is a descriptor that
+            // identifies Bob, we can associate the output string "My name is Bob." with
+            // a source path pointing to that descriptor with:
+            //
+            //   printer.Annotate("name", person_);
+            //
+            // The AnnotationCollector will be sent an annotation linking the output range
+            // covering "Bob" to the logical path provided by person_.  Tools may use
+            // this association to (for example) link "Bob" in the output back to the
+            // source file that defined the person_ descriptor identifying Bob.
+            //
+            // Annotate can only examine variables substituted during the last call to
+            // Print.  It is invalid to refer to a variable that was used multiple times
+            // in a single Print call.
+            //
+            // In full generality, one may specify a range of output text using a beginning
+            // substitution variable and an ending variable.  The resulting annotation will
+            // span from the first character of the substituted value for the beginning
+            // variable to the last character of the substituted value for the ending
+            // variable.  For example, the Annotate call above is equivalent to this one:
+            //
+            //   printer.Annotate("name", "name", person_);
+            //
+            // This is useful if multiple variables combine to form a single span of output
+            // that should be annotated with the same source path.  For example:
+            //
+            //   Printer printer(output, '$');
+            //   map<string, string> vars;
+            //   vars["first"] = "Alice";
+            //   vars["last"] = "Smith";
+            //   printer.Print(vars, "My name is $first$ $last$.");
+            //   printer.Annotate("first", "last", person_);
+            //
+            // This code would associate the span covering "Alice Smith" in the output with
+            // the person_ descriptor.
+            //
+            // Note that the beginning variable must come before (or overlap with, in the
+            // case of zero-sized substitution values) the ending variable.
+            //
+            // It is also sometimes useful to use variables with zero-sized values as
+            // markers.  This avoids issues with multiple references to the same variable
+            // and also allows annotation ranges to span literal text from the Print
+            // templates:
+            //
+            //   Printer printer(output, '$');
+            //   map<string, string> vars;
+            //   vars["foo"] = "bar";
+            //   vars["function"] = "call";
+            //   vars["mark"] = "";
+            //   printer.Print(vars, "$function$($foo$,$foo$)$mark$");
+            //   printer.Annotate("function", "mark", call_);
+            //
+            // This code associates the span covering "call(bar,bar)" in the output with the
+            // call_ descriptor.
+
+            class PROTOBUF_EXPORT Printer
+            {
+            public:
+                // Create a printer that writes text to the given output stream.  Use the
+                // given character as the delimiter for variables.
+                Printer(ZeroCopyOutputStream* output, char variable_delimiter);
+
+                // Create a printer that writes text to the given output stream.  Use the
+                // given character as the delimiter for variables.  If annotation_collector
+                // is not null, Printer will provide it with annotations about code written
+                // to the stream.  annotation_collector is not owned by Printer.
+                Printer(ZeroCopyOutputStream* output, char variable_delimiter, AnnotationCollector* annotation_collector);
+
+                ~Printer();
+
+                // Link a substitution variable emitted by the last call to Print to the
+                // object described by descriptor.
+                template<typename SomeDescriptor>
+                void Annotate(const char* varname, const SomeDescriptor* descriptor)
+                {
+                    Annotate(varname, varname, descriptor);
+                }
+
+                // Link the output range defined by the substitution variables as emitted by
+                // the last call to Print to the object described by descriptor. The range
+                // begins at begin_varname's value and ends after the last character of the
+                // value substituted for end_varname.
+                template<typename SomeDescriptor>
+                void Annotate(const char* begin_varname, const char* end_varname, const SomeDescriptor* descriptor)
+                {
+                    if (annotation_collector_ == NULL)
+                    {
+                        // Annotations aren't turned on for this Printer, so don't pay the cost
+                        // of building the location path.
+                        return;
+                    }
+                    std::vector<int> path;
+                    descriptor->GetLocationPath(&path);
+                    Annotate(begin_varname, end_varname, descriptor->file()->name(), path);
+                }
+
+                // Link a substitution variable emitted by the last call to Print to the file
+                // with path file_name.
+                void Annotate(const char* varname, const std::string& file_name)
+                {
+                    Annotate(varname, varname, file_name);
+                }
+
+                // Link the output range defined by the substitution variables as emitted by
+                // the last call to Print to the file with path file_name. The range begins
+                // at begin_varname's value and ends after the last character of the value
+                // substituted for end_varname.
+                void Annotate(const char* begin_varname, const char* end_varname, const std::string& file_name)
+                {
+                    if (annotation_collector_ == NULL)
+                    {
+                        // Annotations aren't turned on for this Printer.
+                        return;
+                    }
+                    std::vector<int> empty_path;
+                    Annotate(begin_varname, end_varname, file_name, empty_path);
+                }
+
+                // Print some text after applying variable substitutions.  If a particular
+                // variable in the text is not defined, this will crash.  Variables to be
+                // substituted are identified by their names surrounded by delimiter
+                // characters (as given to the constructor).  The variable bindings are
+                // defined by the given map.
+                void Print(const std::map<std::string, std::string>& variables, const char* text);
+
+                // Like the first Print(), except the substitutions are given as parameters.
+                template<typename... Args>
+                void Print(const char* text, const Args&... args)
+                {
+                    std::map<std::string, std::string> vars;
+                    PrintInternal(&vars, text, args...);
+                }
+
+                // Indent text by two spaces.  After calling Indent(), two spaces will be
+                // inserted at the beginning of each line of text.  Indent() may be called
+                // multiple times to produce deeper indents.
+                void Indent();
+
+                // Reduces the current indent level by two spaces, or crashes if the indent
+                // level is zero.
+                void Outdent();
+
+                // Write a string to the output buffer.
+                // This method does not look for newlines to add indentation.
+                void PrintRaw(const std::string& data);
+
+                // Write a zero-delimited string to output buffer.
+                // This method does not look for newlines to add indentation.
+                void PrintRaw(const char* data);
+
+                // Write some bytes to the output buffer.
+                // This method does not look for newlines to add indentation.
+                void WriteRaw(const char* data, int size);
+
+                // FormatInternal is a helper function not meant to use directly, use
+                // compiler::cpp::Formatter instead. This function is meant to support
+                // formatting text using named variables (eq. "$foo$) from a lookup map (vars)
+                // and variables directly supplied by arguments (eq "$1$" meaning first
+                // argument which is the zero index element of args).
+                void FormatInternal(const std::vector<std::string>& args, const std::map<std::string, std::string>& vars, const char* format);
+
+                // True if any write to the underlying stream failed.  (We don't just
+                // crash in this case because this is an I/O failure, not a programming
+                // error.)
+                bool failed() const
+                {
+                    return failed_;
+                }
+
+            private:
+                // Link the output range defined by the substitution variables as emitted by
+                // the last call to Print to the object found at the SourceCodeInfo-style path
+                // in a file with path file_path. The range begins at the start of
+                // begin_varname's value and ends after the last character of the value
+                // substituted for end_varname. Note that begin_varname and end_varname
+                // may refer to the same variable.
+                void Annotate(const char* begin_varname, const char* end_varname, const std::string& file_path, const std::vector<int>& path);
+
+                // Base case
+                void PrintInternal(std::map<std::string, std::string>* vars, const char* text)
+                {
+                    Print(*vars, text);
+                }
+
+                template<typename... Args>
+                void PrintInternal(std::map<std::string, std::string>* vars, const char* text, const char* key, const std::string& value, const Args&... args)
+                {
+                    (*vars)[key] = value;
+                    PrintInternal(vars, text, args...);
+                }
+
+                // Copy size worth of bytes from data to buffer_.
+                void CopyToBuffer(const char* data, int size);
+
+                void push_back(char c)
+                {
+                    if (failed_)
+                        return;
+                    if (buffer_size_ == 0)
+                    {
+                        if (!Next())
+                            return;
+                    }
+                    *buffer_++ = c;
+                    buffer_size_--;
+                    offset_++;
+                }
+
+                bool Next();
+
+                inline void IndentIfAtStart();
+                const char* WriteVariable(
+                    const std::vector<std::string>& args,
+                    const std::map<std::string, std::string>& vars,
+                    const char* format,
+                    int* arg_index,
+                    std::vector<AnnotationCollector::Annotation>* annotations
+                );
+
+                const char variable_delimiter_;
+
+                ZeroCopyOutputStream* const output_;
+                char* buffer_;
+                int buffer_size_;
+                // The current position, in bytes, in the output stream.  This is equivalent
+                // to the total number of bytes that have been written so far.  This value is
+                // used to calculate annotation ranges in the substitutions_ map below.
+                size_t offset_;
+
+                std::string indent_;
+                bool at_start_of_line_;
+                bool failed_;
+
+                // A map from variable name to [start, end) offsets in the output buffer.
+                // These refer to the offsets used for a variable after the last call to
+                // Print.  If a variable was used more than once, the entry used in
+                // this map is set to a negative-length span.  For singly-used variables, the
+                // start offset is the beginning of the substitution; the end offset is the
+                // last byte of the substitution plus one (such that (end - start) is the
+                // length of the substituted string).
+                std::map<std::string, std::pair<size_t, size_t>> substitutions_;
+
+                // Keeps track of the keys in substitutions_ that need to be updated when
+                // indents are inserted. These are keys that refer to the beginning of the
+                // current line.
+                std::vector<std::string> line_start_variables_;
+
+                // Returns true and sets range to the substitution range in the output for
+                // varname if varname was used once in the last call to Print. If varname
+                // was not used, or if it was used multiple times, returns false (and
+                // fails a debug assertion).
+                bool GetSubstitutionRange(const char* varname, std::pair<size_t, size_t>* range);
+
+                // If non-null, annotation_collector_ is used to store annotations about
+                // generated code.
+                AnnotationCollector* const annotation_collector_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Printer);
+            };
+
+        }  // namespace io
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/strtod.h b/CAPI/cpp/grpc/include/google/protobuf/io/strtod.h
index 38f544a..4a3ae69 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/strtod.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/strtod.h
@@ -35,21 +35,24 @@
 #ifndef GOOGLE_PROTOBUF_IO_STRTOD_H__
 #define GOOGLE_PROTOBUF_IO_STRTOD_H__
 
-namespace google {
-namespace protobuf {
-namespace io {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
 
-// A locale-independent version of the standard strtod(), which always
-// uses a dot as the decimal separator.
-double NoLocaleStrtod(const char* str, char** endptr);
+            // A locale-independent version of the standard strtod(), which always
+            // uses a dot as the decimal separator.
+            double NoLocaleStrtod(const char* str, char** endptr);
 
-// Casts a double value to a float value. If the value is outside of the
-// representable range of float, it will be converted to positive or negative
-// infinity.
-float SafeDoubleToFloat(double value);
+            // Casts a double value to a float value. If the value is outside of the
+            // representable range of float, it will be converted to positive or negative
+            // infinity.
+            float SafeDoubleToFloat(double value);
 
-}  // namespace io
-}  // namespace protobuf
+        }  // namespace io
+    }      // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_IO_STRTOD_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/tokenizer.h b/CAPI/cpp/grpc/include/google/protobuf/io/tokenizer.h
index 4abab7e..647fa7b 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/tokenizer.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/tokenizer.h
@@ -37,7 +37,6 @@
 #ifndef GOOGLE_PROTOBUF_IO_TOKENIZER_H__
 #define GOOGLE_PROTOBUF_IO_TOKENIZER_H__
 
-
 #include <string>
 #include <vector>
 
@@ -47,394 +46,418 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace io {
-
-class ZeroCopyInputStream;  // zero_copy_stream.h
-
-// Defined in this file.
-class ErrorCollector;
-class Tokenizer;
-
-// By "column number", the proto compiler refers to a count of the number
-// of bytes before a given byte, except that a tab character advances to
-// the next multiple of 8 bytes.  Note in particular that column numbers
-// are zero-based, while many user interfaces use one-based column numbers.
-typedef int ColumnNumber;
-
-// Abstract interface for an object which collects the errors that occur
-// during parsing.  A typical implementation might simply print the errors
-// to stdout.
-class PROTOBUF_EXPORT ErrorCollector {
- public:
-  inline ErrorCollector() {}
-  virtual ~ErrorCollector();
-
-  // Indicates that there was an error in the input at the given line and
-  // column numbers.  The numbers are zero-based, so you may want to add
-  // 1 to each before printing them.
-  virtual void AddError(int line, ColumnNumber column,
-                        const std::string& message) = 0;
-
-  // Indicates that there was a warning in the input at the given line and
-  // column numbers.  The numbers are zero-based, so you may want to add
-  // 1 to each before printing them.
-  virtual void AddWarning(int /* line */, ColumnNumber /* column */,
-                          const std::string& /* message */) {}
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
-};
-
-// This class converts a stream of raw text into a stream of tokens for
-// the protocol definition parser to parse.  The tokens recognized are
-// similar to those that make up the C language; see the TokenType enum for
-// precise descriptions.  Whitespace and comments are skipped.  By default,
-// C- and C++-style comments are recognized, but other styles can be used by
-// calling set_comment_style().
-class PROTOBUF_EXPORT Tokenizer {
- public:
-  // Construct a Tokenizer that reads and tokenizes text from the given
-  // input stream and writes errors to the given error_collector.
-  // The caller keeps ownership of input and error_collector.
-  Tokenizer(ZeroCopyInputStream* input, ErrorCollector* error_collector);
-  ~Tokenizer();
-
-  enum TokenType {
-    TYPE_START,  // Next() has not yet been called.
-    TYPE_END,    // End of input reached.  "text" is empty.
-
-    TYPE_IDENTIFIER,  // A sequence of letters, digits, and underscores, not
-                      // starting with a digit.  It is an error for a number
-                      // to be followed by an identifier with no space in
-                      // between.
-    TYPE_INTEGER,     // A sequence of digits representing an integer.  Normally
-                      // the digits are decimal, but a prefix of "0x" indicates
-                      // a hex number and a leading zero indicates octal, just
-                      // like with C numeric literals.  A leading negative sign
-                      // is NOT included in the token; it's up to the parser to
-                      // interpret the unary minus operator on its own.
-    TYPE_FLOAT,       // A floating point literal, with a fractional part and/or
-                      // an exponent.  Always in decimal.  Again, never
-                      // negative.
-    TYPE_STRING,      // A quoted sequence of escaped characters.  Either single
-                      // or double quotes can be used, but they must match.
-                      // A string literal cannot cross a line break.
-    TYPE_SYMBOL,      // Any other printable character, like '!' or '+'.
-                      // Symbols are always a single character, so "!+$%" is
-                      // four tokens.
-    TYPE_WHITESPACE,  // A sequence of whitespace.  This token type is only
-                      // produced if report_whitespace() is true.  It is not
-                      // reported for whitespace within comments or strings.
-    TYPE_NEWLINE,     // A newline (\n).  This token type is only
-                      // produced if report_whitespace() is true and
-                      // report_newlines() is true.  It is not reported for
-                      // newlines in comments or strings.
-  };
-
-  // Structure representing a token read from the token stream.
-  struct Token {
-    TokenType type;
-    std::string text;  // The exact text of the token as it appeared in
-                       // the input.  e.g. tokens of TYPE_STRING will still
-                       // be escaped and in quotes.
-
-    // "line" and "column" specify the position of the first character of
-    // the token within the input stream.  They are zero-based.
-    int line;
-    ColumnNumber column;
-    ColumnNumber end_column;
-  };
-
-  // Get the current token.  This is updated when Next() is called.  Before
-  // the first call to Next(), current() has type TYPE_START and no contents.
-  const Token& current();
-
-  // Return the previous token -- i.e. what current() returned before the
-  // previous call to Next().
-  const Token& previous();
-
-  // Advance to the next token.  Returns false if the end of the input is
-  // reached.
-  bool Next();
-
-  // Like Next(), but also collects comments which appear between the previous
-  // and next tokens.
-  //
-  // Comments which appear to be attached to the previous token are stored
-  // in *prev_tailing_comments.  Comments which appear to be attached to the
-  // next token are stored in *next_leading_comments.  Comments appearing in
-  // between which do not appear to be attached to either will be added to
-  // detached_comments.  Any of these parameters can be NULL to simply discard
-  // the comments.
-  //
-  // A series of line comments appearing on consecutive lines, with no other
-  // tokens appearing on those lines, will be treated as a single comment.
-  //
-  // Only the comment content is returned; comment markers (e.g. //) are
-  // stripped out.  For block comments, leading whitespace and an asterisk will
-  // be stripped from the beginning of each line other than the first.  Newlines
-  // are included in the output.
-  //
-  // Examples:
-  //
-  //   optional int32 foo = 1;  // Comment attached to foo.
-  //   // Comment attached to bar.
-  //   optional int32 bar = 2;
-  //
-  //   optional string baz = 3;
-  //   // Comment attached to baz.
-  //   // Another line attached to baz.
-  //
-  //   // Comment attached to qux.
-  //   //
-  //   // Another line attached to qux.
-  //   optional double qux = 4;
-  //
-  //   // Detached comment.  This is not attached to qux or corge
-  //   // because there are blank lines separating it from both.
-  //
-  //   optional string corge = 5;
-  //   /* Block comment attached
-  //    * to corge.  Leading asterisks
-  //    * will be removed. */
-  //   /* Block comment attached to
-  //    * grault. */
-  //   optional int32 grault = 6;
-  bool NextWithComments(std::string* prev_trailing_comments,
-                        std::vector<std::string>* detached_comments,
-                        std::string* next_leading_comments);
-
-  // Parse helpers ---------------------------------------------------
-
-  // Parses a TYPE_FLOAT token.  This never fails, so long as the text actually
-  // comes from a TYPE_FLOAT token parsed by Tokenizer.  If it doesn't, the
-  // result is undefined (possibly an assert failure).
-  static double ParseFloat(const std::string& text);
-
-  // Parses a TYPE_STRING token.  This never fails, so long as the text actually
-  // comes from a TYPE_STRING token parsed by Tokenizer.  If it doesn't, the
-  // result is undefined (possibly an assert failure).
-  static void ParseString(const std::string& text, std::string* output);
-
-  // Identical to ParseString, but appends to output.
-  static void ParseStringAppend(const std::string& text, std::string* output);
-
-  // Parses a TYPE_INTEGER token.  Returns false if the result would be
-  // greater than max_value.  Otherwise, returns true and sets *output to the
-  // result.  If the text is not from a Token of type TYPE_INTEGER originally
-  // parsed by a Tokenizer, the result is undefined (possibly an assert
-  // failure).
-  static bool ParseInteger(const std::string& text, uint64_t max_value,
-                           uint64_t* output);
-
-  // Options ---------------------------------------------------------
-
-  // Set true to allow floats to be suffixed with the letter 'f'.  Tokens
-  // which would otherwise be integers but which have the 'f' suffix will be
-  // forced to be interpreted as floats.  For all other purposes, the 'f' is
-  // ignored.
-  void set_allow_f_after_float(bool value) { allow_f_after_float_ = value; }
-
-  // Valid values for set_comment_style().
-  enum CommentStyle {
-    // Line comments begin with "//", block comments are delimited by "/*" and
-    // "*/".
-    CPP_COMMENT_STYLE,
-    // Line comments begin with "#".  No way to write block comments.
-    SH_COMMENT_STYLE
-  };
-
-  // Sets the comment style.
-  void set_comment_style(CommentStyle style) { comment_style_ = style; }
-
-  // Whether to require whitespace between a number and a field name.
-  // Default is true. Do not use this; for Google-internal cleanup only.
-  void set_require_space_after_number(bool require) {
-    require_space_after_number_ = require;
-  }
-
-  // Whether to allow string literals to span multiple lines. Default is false.
-  // Do not use this; for Google-internal cleanup only.
-  void set_allow_multiline_strings(bool allow) {
-    allow_multiline_strings_ = allow;
-  }
-
-  // If true, whitespace tokens are reported by Next().
-  // Note: `set_report_whitespace(false)` implies `set_report_newlines(false)`.
-  bool report_whitespace() const;
-  void set_report_whitespace(bool report);
-
-  // If true, newline tokens are reported by Next().
-  // Note: `set_report_newlines(true)` implies `set_report_whitespace(true)`.
-  bool report_newlines() const;
-  void set_report_newlines(bool report);
-
-  // External helper: validate an identifier.
-  static bool IsIdentifier(const std::string& text);
-
-  // -----------------------------------------------------------------
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Tokenizer);
-
-  Token current_;   // Returned by current().
-  Token previous_;  // Returned by previous().
-
-  ZeroCopyInputStream* input_;
-  ErrorCollector* error_collector_;
-
-  char current_char_;   // == buffer_[buffer_pos_], updated by NextChar().
-  const char* buffer_;  // Current buffer returned from input_.
-  int buffer_size_;     // Size of buffer_.
-  int buffer_pos_;      // Current position within the buffer.
-  bool read_error_;     // Did we previously encounter a read error?
-
-  // Line and column number of current_char_ within the whole input stream.
-  int line_;
-  ColumnNumber column_;
-
-  // String to which text should be appended as we advance through it.
-  // Call RecordTo(&str) to start recording and StopRecording() to stop.
-  // E.g. StartToken() calls RecordTo(&current_.text).  record_start_ is the
-  // position within the current buffer where recording started.
-  std::string* record_target_;
-  int record_start_;
-
-  // Options.
-  bool allow_f_after_float_;
-  CommentStyle comment_style_;
-  bool require_space_after_number_;
-  bool allow_multiline_strings_;
-  bool report_whitespace_ = false;
-  bool report_newlines_ = false;
-
-  // Since we count columns we need to interpret tabs somehow.  We'll take
-  // the standard 8-character definition for lack of any way to do better.
-  // This must match the documentation of ColumnNumber.
-  static const int kTabWidth = 8;
-
-  // -----------------------------------------------------------------
-  // Helper methods.
-
-  // Consume this character and advance to the next one.
-  void NextChar();
-
-  // Read a new buffer from the input.
-  void Refresh();
-
-  inline void RecordTo(std::string* target);
-  inline void StopRecording();
-
-  // Called when the current character is the first character of a new
-  // token (not including whitespace or comments).
-  inline void StartToken();
-  // Called when the current character is the first character after the
-  // end of the last token.  After this returns, current_.text will
-  // contain all text consumed since StartToken() was called.
-  inline void EndToken();
-
-  // Convenience method to add an error at the current line and column.
-  void AddError(const std::string& message) {
-    error_collector_->AddError(line_, column_, message);
-  }
-
-  // -----------------------------------------------------------------
-  // The following four methods are used to consume tokens of specific
-  // types.  They are actually used to consume all characters *after*
-  // the first, since the calling function consumes the first character
-  // in order to decide what kind of token is being read.
-
-  // Read and consume a string, ending when the given delimiter is
-  // consumed.
-  void ConsumeString(char delimiter);
-
-  // Read and consume a number, returning TYPE_FLOAT or TYPE_INTEGER
-  // depending on what was read.  This needs to know if the first
-  // character was a zero in order to correctly recognize hex and octal
-  // numbers.
-  // It also needs to know if the first character was a . to parse floating
-  // point correctly.
-  TokenType ConsumeNumber(bool started_with_zero, bool started_with_dot);
-
-  // Consume the rest of a line.
-  void ConsumeLineComment(std::string* content);
-  // Consume until "*/".
-  void ConsumeBlockComment(std::string* content);
-
-  enum NextCommentStatus {
-    // Started a line comment.
-    LINE_COMMENT,
-
-    // Started a block comment.
-    BLOCK_COMMENT,
-
-    // Consumed a slash, then realized it wasn't a comment.  current_ has
-    // been filled in with a slash token.  The caller should return it.
-    SLASH_NOT_COMMENT,
-
-    // We do not appear to be starting a comment here.
-    NO_COMMENT
-  };
-
-  // If we're at the start of a new comment, consume it and return what kind
-  // of comment it is.
-  NextCommentStatus TryConsumeCommentStart();
-
-  // If we're looking at a TYPE_WHITESPACE token and `report_whitespace_` is
-  // true, consume it and return true.
-  bool TryConsumeWhitespace();
-
-  // If we're looking at a TYPE_NEWLINE token and `report_newlines_` is true,
-  // consume it and return true.
-  bool TryConsumeNewline();
-
-  // -----------------------------------------------------------------
-  // These helper methods make the parsing code more readable.  The
-  // "character classes" referred to are defined at the top of the .cc file.
-  // Basically it is a C++ class with one method:
-  //   static bool InClass(char c);
-  // The method returns true if c is a member of this "class", like "Letter"
-  // or "Digit".
-
-  // Returns true if the current character is of the given character
-  // class, but does not consume anything.
-  template <typename CharacterClass>
-  inline bool LookingAt();
-
-  // If the current character is in the given class, consume it and return
-  // true.  Otherwise return false.
-  // e.g. TryConsumeOne<Letter>()
-  template <typename CharacterClass>
-  inline bool TryConsumeOne();
-
-  // Like above, but try to consume the specific character indicated.
-  inline bool TryConsume(char c);
-
-  // Consume zero or more of the given character class.
-  template <typename CharacterClass>
-  inline void ConsumeZeroOrMore();
-
-  // Consume one or more of the given character class or log the given
-  // error message.
-  // e.g. ConsumeOneOrMore<Digit>("Expected digits.");
-  template <typename CharacterClass>
-  inline void ConsumeOneOrMore(const char* error);
-};
-
-// inline methods ====================================================
-inline const Tokenizer::Token& Tokenizer::current() { return current_; }
-
-inline const Tokenizer::Token& Tokenizer::previous() { return previous_; }
-
-inline void Tokenizer::ParseString(const std::string& text,
-                                   std::string* output) {
-  output->clear();
-  ParseStringAppend(text, output);
-}
-
-}  // namespace io
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
+
+            class ZeroCopyInputStream;  // zero_copy_stream.h
+
+            // Defined in this file.
+            class ErrorCollector;
+            class Tokenizer;
+
+            // By "column number", the proto compiler refers to a count of the number
+            // of bytes before a given byte, except that a tab character advances to
+            // the next multiple of 8 bytes.  Note in particular that column numbers
+            // are zero-based, while many user interfaces use one-based column numbers.
+            typedef int ColumnNumber;
+
+            // Abstract interface for an object which collects the errors that occur
+            // during parsing.  A typical implementation might simply print the errors
+            // to stdout.
+            class PROTOBUF_EXPORT ErrorCollector
+            {
+            public:
+                inline ErrorCollector()
+                {
+                }
+                virtual ~ErrorCollector();
+
+                // Indicates that there was an error in the input at the given line and
+                // column numbers.  The numbers are zero-based, so you may want to add
+                // 1 to each before printing them.
+                virtual void AddError(int line, ColumnNumber column, const std::string& message) = 0;
+
+                // Indicates that there was a warning in the input at the given line and
+                // column numbers.  The numbers are zero-based, so you may want to add
+                // 1 to each before printing them.
+                virtual void AddWarning(int /* line */, ColumnNumber /* column */, const std::string& /* message */)
+                {
+                }
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
+            };
+
+            // This class converts a stream of raw text into a stream of tokens for
+            // the protocol definition parser to parse.  The tokens recognized are
+            // similar to those that make up the C language; see the TokenType enum for
+            // precise descriptions.  Whitespace and comments are skipped.  By default,
+            // C- and C++-style comments are recognized, but other styles can be used by
+            // calling set_comment_style().
+            class PROTOBUF_EXPORT Tokenizer
+            {
+            public:
+                // Construct a Tokenizer that reads and tokenizes text from the given
+                // input stream and writes errors to the given error_collector.
+                // The caller keeps ownership of input and error_collector.
+                Tokenizer(ZeroCopyInputStream* input, ErrorCollector* error_collector);
+                ~Tokenizer();
+
+                enum TokenType
+                {
+                    TYPE_START,  // Next() has not yet been called.
+                    TYPE_END,    // End of input reached.  "text" is empty.
+
+                    TYPE_IDENTIFIER,  // A sequence of letters, digits, and underscores, not
+                                      // starting with a digit.  It is an error for a number
+                                      // to be followed by an identifier with no space in
+                                      // between.
+                    TYPE_INTEGER,     // A sequence of digits representing an integer.  Normally
+                                      // the digits are decimal, but a prefix of "0x" indicates
+                                      // a hex number and a leading zero indicates octal, just
+                                      // like with C numeric literals.  A leading negative sign
+                                      // is NOT included in the token; it's up to the parser to
+                                      // interpret the unary minus operator on its own.
+                    TYPE_FLOAT,       // A floating point literal, with a fractional part and/or
+                                      // an exponent.  Always in decimal.  Again, never
+                                      // negative.
+                    TYPE_STRING,      // A quoted sequence of escaped characters.  Either single
+                                      // or double quotes can be used, but they must match.
+                                      // A string literal cannot cross a line break.
+                    TYPE_SYMBOL,      // Any other printable character, like '!' or '+'.
+                                      // Symbols are always a single character, so "!+$%" is
+                                      // four tokens.
+                    TYPE_WHITESPACE,  // A sequence of whitespace.  This token type is only
+                                      // produced if report_whitespace() is true.  It is not
+                                      // reported for whitespace within comments or strings.
+                    TYPE_NEWLINE,     // A newline (\n).  This token type is only
+                                      // produced if report_whitespace() is true and
+                                      // report_newlines() is true.  It is not reported for
+                                      // newlines in comments or strings.
+                };
+
+                // Structure representing a token read from the token stream.
+                struct Token
+                {
+                    TokenType type;
+                    std::string text;  // The exact text of the token as it appeared in
+                                       // the input.  e.g. tokens of TYPE_STRING will still
+                                       // be escaped and in quotes.
+
+                    // "line" and "column" specify the position of the first character of
+                    // the token within the input stream.  They are zero-based.
+                    int line;
+                    ColumnNumber column;
+                    ColumnNumber end_column;
+                };
+
+                // Get the current token.  This is updated when Next() is called.  Before
+                // the first call to Next(), current() has type TYPE_START and no contents.
+                const Token& current();
+
+                // Return the previous token -- i.e. what current() returned before the
+                // previous call to Next().
+                const Token& previous();
+
+                // Advance to the next token.  Returns false if the end of the input is
+                // reached.
+                bool Next();
+
+                // Like Next(), but also collects comments which appear between the previous
+                // and next tokens.
+                //
+                // Comments which appear to be attached to the previous token are stored
+                // in *prev_tailing_comments.  Comments which appear to be attached to the
+                // next token are stored in *next_leading_comments.  Comments appearing in
+                // between which do not appear to be attached to either will be added to
+                // detached_comments.  Any of these parameters can be NULL to simply discard
+                // the comments.
+                //
+                // A series of line comments appearing on consecutive lines, with no other
+                // tokens appearing on those lines, will be treated as a single comment.
+                //
+                // Only the comment content is returned; comment markers (e.g. //) are
+                // stripped out.  For block comments, leading whitespace and an asterisk will
+                // be stripped from the beginning of each line other than the first.  Newlines
+                // are included in the output.
+                //
+                // Examples:
+                //
+                //   optional int32 foo = 1;  // Comment attached to foo.
+                //   // Comment attached to bar.
+                //   optional int32 bar = 2;
+                //
+                //   optional string baz = 3;
+                //   // Comment attached to baz.
+                //   // Another line attached to baz.
+                //
+                //   // Comment attached to qux.
+                //   //
+                //   // Another line attached to qux.
+                //   optional double qux = 4;
+                //
+                //   // Detached comment.  This is not attached to qux or corge
+                //   // because there are blank lines separating it from both.
+                //
+                //   optional string corge = 5;
+                //   /* Block comment attached
+                //    * to corge.  Leading asterisks
+                //    * will be removed. */
+                //   /* Block comment attached to
+                //    * grault. */
+                //   optional int32 grault = 6;
+                bool NextWithComments(std::string* prev_trailing_comments, std::vector<std::string>* detached_comments, std::string* next_leading_comments);
+
+                // Parse helpers ---------------------------------------------------
+
+                // Parses a TYPE_FLOAT token.  This never fails, so long as the text actually
+                // comes from a TYPE_FLOAT token parsed by Tokenizer.  If it doesn't, the
+                // result is undefined (possibly an assert failure).
+                static double ParseFloat(const std::string& text);
+
+                // Parses a TYPE_STRING token.  This never fails, so long as the text actually
+                // comes from a TYPE_STRING token parsed by Tokenizer.  If it doesn't, the
+                // result is undefined (possibly an assert failure).
+                static void ParseString(const std::string& text, std::string* output);
+
+                // Identical to ParseString, but appends to output.
+                static void ParseStringAppend(const std::string& text, std::string* output);
+
+                // Parses a TYPE_INTEGER token.  Returns false if the result would be
+                // greater than max_value.  Otherwise, returns true and sets *output to the
+                // result.  If the text is not from a Token of type TYPE_INTEGER originally
+                // parsed by a Tokenizer, the result is undefined (possibly an assert
+                // failure).
+                static bool ParseInteger(const std::string& text, uint64_t max_value, uint64_t* output);
+
+                // Options ---------------------------------------------------------
+
+                // Set true to allow floats to be suffixed with the letter 'f'.  Tokens
+                // which would otherwise be integers but which have the 'f' suffix will be
+                // forced to be interpreted as floats.  For all other purposes, the 'f' is
+                // ignored.
+                void set_allow_f_after_float(bool value)
+                {
+                    allow_f_after_float_ = value;
+                }
+
+                // Valid values for set_comment_style().
+                enum CommentStyle
+                {
+                    // Line comments begin with "//", block comments are delimited by "/*" and
+                    // "*/".
+                    CPP_COMMENT_STYLE,
+                    // Line comments begin with "#".  No way to write block comments.
+                    SH_COMMENT_STYLE
+                };
+
+                // Sets the comment style.
+                void set_comment_style(CommentStyle style)
+                {
+                    comment_style_ = style;
+                }
+
+                // Whether to require whitespace between a number and a field name.
+                // Default is true. Do not use this; for Google-internal cleanup only.
+                void set_require_space_after_number(bool require)
+                {
+                    require_space_after_number_ = require;
+                }
+
+                // Whether to allow string literals to span multiple lines. Default is false.
+                // Do not use this; for Google-internal cleanup only.
+                void set_allow_multiline_strings(bool allow)
+                {
+                    allow_multiline_strings_ = allow;
+                }
+
+                // If true, whitespace tokens are reported by Next().
+                // Note: `set_report_whitespace(false)` implies `set_report_newlines(false)`.
+                bool report_whitespace() const;
+                void set_report_whitespace(bool report);
+
+                // If true, newline tokens are reported by Next().
+                // Note: `set_report_newlines(true)` implies `set_report_whitespace(true)`.
+                bool report_newlines() const;
+                void set_report_newlines(bool report);
+
+                // External helper: validate an identifier.
+                static bool IsIdentifier(const std::string& text);
+
+                // -----------------------------------------------------------------
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Tokenizer);
+
+                Token current_;   // Returned by current().
+                Token previous_;  // Returned by previous().
+
+                ZeroCopyInputStream* input_;
+                ErrorCollector* error_collector_;
+
+                char current_char_;   // == buffer_[buffer_pos_], updated by NextChar().
+                const char* buffer_;  // Current buffer returned from input_.
+                int buffer_size_;     // Size of buffer_.
+                int buffer_pos_;      // Current position within the buffer.
+                bool read_error_;     // Did we previously encounter a read error?
+
+                // Line and column number of current_char_ within the whole input stream.
+                int line_;
+                ColumnNumber column_;
+
+                // String to which text should be appended as we advance through it.
+                // Call RecordTo(&str) to start recording and StopRecording() to stop.
+                // E.g. StartToken() calls RecordTo(&current_.text).  record_start_ is the
+                // position within the current buffer where recording started.
+                std::string* record_target_;
+                int record_start_;
+
+                // Options.
+                bool allow_f_after_float_;
+                CommentStyle comment_style_;
+                bool require_space_after_number_;
+                bool allow_multiline_strings_;
+                bool report_whitespace_ = false;
+                bool report_newlines_ = false;
+
+                // Since we count columns we need to interpret tabs somehow.  We'll take
+                // the standard 8-character definition for lack of any way to do better.
+                // This must match the documentation of ColumnNumber.
+                static const int kTabWidth = 8;
+
+                // -----------------------------------------------------------------
+                // Helper methods.
+
+                // Consume this character and advance to the next one.
+                void NextChar();
+
+                // Read a new buffer from the input.
+                void Refresh();
+
+                inline void RecordTo(std::string* target);
+                inline void StopRecording();
+
+                // Called when the current character is the first character of a new
+                // token (not including whitespace or comments).
+                inline void StartToken();
+                // Called when the current character is the first character after the
+                // end of the last token.  After this returns, current_.text will
+                // contain all text consumed since StartToken() was called.
+                inline void EndToken();
+
+                // Convenience method to add an error at the current line and column.
+                void AddError(const std::string& message)
+                {
+                    error_collector_->AddError(line_, column_, message);
+                }
+
+                // -----------------------------------------------------------------
+                // The following four methods are used to consume tokens of specific
+                // types.  They are actually used to consume all characters *after*
+                // the first, since the calling function consumes the first character
+                // in order to decide what kind of token is being read.
+
+                // Read and consume a string, ending when the given delimiter is
+                // consumed.
+                void ConsumeString(char delimiter);
+
+                // Read and consume a number, returning TYPE_FLOAT or TYPE_INTEGER
+                // depending on what was read.  This needs to know if the first
+                // character was a zero in order to correctly recognize hex and octal
+                // numbers.
+                // It also needs to know if the first character was a . to parse floating
+                // point correctly.
+                TokenType ConsumeNumber(bool started_with_zero, bool started_with_dot);
+
+                // Consume the rest of a line.
+                void ConsumeLineComment(std::string* content);
+                // Consume until "*/".
+                void ConsumeBlockComment(std::string* content);
+
+                enum NextCommentStatus
+                {
+                    // Started a line comment.
+                    LINE_COMMENT,
+
+                    // Started a block comment.
+                    BLOCK_COMMENT,
+
+                    // Consumed a slash, then realized it wasn't a comment.  current_ has
+                    // been filled in with a slash token.  The caller should return it.
+                    SLASH_NOT_COMMENT,
+
+                    // We do not appear to be starting a comment here.
+                    NO_COMMENT
+                };
+
+                // If we're at the start of a new comment, consume it and return what kind
+                // of comment it is.
+                NextCommentStatus TryConsumeCommentStart();
+
+                // If we're looking at a TYPE_WHITESPACE token and `report_whitespace_` is
+                // true, consume it and return true.
+                bool TryConsumeWhitespace();
+
+                // If we're looking at a TYPE_NEWLINE token and `report_newlines_` is true,
+                // consume it and return true.
+                bool TryConsumeNewline();
+
+                // -----------------------------------------------------------------
+                // These helper methods make the parsing code more readable.  The
+                // "character classes" referred to are defined at the top of the .cc file.
+                // Basically it is a C++ class with one method:
+                //   static bool InClass(char c);
+                // The method returns true if c is a member of this "class", like "Letter"
+                // or "Digit".
+
+                // Returns true if the current character is of the given character
+                // class, but does not consume anything.
+                template<typename CharacterClass>
+                inline bool LookingAt();
+
+                // If the current character is in the given class, consume it and return
+                // true.  Otherwise return false.
+                // e.g. TryConsumeOne<Letter>()
+                template<typename CharacterClass>
+                inline bool TryConsumeOne();
+
+                // Like above, but try to consume the specific character indicated.
+                inline bool TryConsume(char c);
+
+                // Consume zero or more of the given character class.
+                template<typename CharacterClass>
+                inline void ConsumeZeroOrMore();
+
+                // Consume one or more of the given character class or log the given
+                // error message.
+                // e.g. ConsumeOneOrMore<Digit>("Expected digits.");
+                template<typename CharacterClass>
+                inline void ConsumeOneOrMore(const char* error);
+            };
+
+            // inline methods ====================================================
+            inline const Tokenizer::Token& Tokenizer::current()
+            {
+                return current_;
+            }
+
+            inline const Tokenizer::Token& Tokenizer::previous()
+            {
+                return previous_;
+            }
+
+            inline void Tokenizer::ParseString(const std::string& text, std::string* output)
+            {
+                output->clear();
+                ParseStringAppend(text, output);
+            }
+
+        }  // namespace io
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream.h b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream.h
index 2041cbf..a745841 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream.h
@@ -107,152 +107,164 @@
 #ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_H__
 #define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_H__
 
-
 #include <google/protobuf/stubs/common.h>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace io {
-
-// Defined in this file.
-class ZeroCopyInputStream;
-class ZeroCopyOutputStream;
-
-// Abstract interface similar to an input stream but designed to minimize
-// copying.
-class PROTOBUF_EXPORT ZeroCopyInputStream {
- public:
-  ZeroCopyInputStream() {}
-  virtual ~ZeroCopyInputStream() {}
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
 
-  // Obtains a chunk of data from the stream.
-  //
-  // Preconditions:
-  // * "size" and "data" are not NULL.
-  //
-  // Postconditions:
-  // * If the returned value is false, there is no more data to return or
-  //   an error occurred.  All errors are permanent.
-  // * Otherwise, "size" points to the actual number of bytes read and "data"
-  //   points to a pointer to a buffer containing these bytes.
-  // * Ownership of this buffer remains with the stream, and the buffer
-  //   remains valid only until some other method of the stream is called
-  //   or the stream is destroyed.
-  // * It is legal for the returned buffer to have zero size, as long
-  //   as repeatedly calling Next() eventually yields a buffer with non-zero
-  //   size.
-  virtual bool Next(const void** data, int* size) = 0;
+            // Defined in this file.
+            class ZeroCopyInputStream;
+            class ZeroCopyOutputStream;
 
-  // Backs up a number of bytes, so that the next call to Next() returns
-  // data again that was already returned by the last call to Next().  This
-  // is useful when writing procedures that are only supposed to read up
-  // to a certain point in the input, then return.  If Next() returns a
-  // buffer that goes beyond what you wanted to read, you can use BackUp()
-  // to return to the point where you intended to finish.
-  //
-  // This method can be called with `count = 0` to finalize (flush) any
-  // previously returned buffer. For example, a file output stream can
-  // flush buffers returned from a previous call to Next() upon such
-  // BackUp(0) invocations. ZeroCopyOutputStream callers should always
-  // invoke BackUp() after a final Next() call, even if there is no
-  // excess buffer data to be backed up to indicate a flush point.
-  //
-  // Preconditions:
-  // * The last method called must have been Next().
-  // * count must be less than or equal to the size of the last buffer
-  //   returned by Next().
-  //
-  // Postconditions:
-  // * The last "count" bytes of the last buffer returned by Next() will be
-  //   pushed back into the stream.  Subsequent calls to Next() will return
-  //   the same data again before producing new data.
-  virtual void BackUp(int count) = 0;
+            // Abstract interface similar to an input stream but designed to minimize
+            // copying.
+            class PROTOBUF_EXPORT ZeroCopyInputStream
+            {
+            public:
+                ZeroCopyInputStream()
+                {
+                }
+                virtual ~ZeroCopyInputStream()
+                {
+                }
 
-  // Skips a number of bytes.  Returns false if the end of the stream is
-  // reached or some input error occurred.  In the end-of-stream case, the
-  // stream is advanced to the end of the stream (so ByteCount() will return
-  // the total size of the stream).
-  virtual bool Skip(int count) = 0;
+                // Obtains a chunk of data from the stream.
+                //
+                // Preconditions:
+                // * "size" and "data" are not NULL.
+                //
+                // Postconditions:
+                // * If the returned value is false, there is no more data to return or
+                //   an error occurred.  All errors are permanent.
+                // * Otherwise, "size" points to the actual number of bytes read and "data"
+                //   points to a pointer to a buffer containing these bytes.
+                // * Ownership of this buffer remains with the stream, and the buffer
+                //   remains valid only until some other method of the stream is called
+                //   or the stream is destroyed.
+                // * It is legal for the returned buffer to have zero size, as long
+                //   as repeatedly calling Next() eventually yields a buffer with non-zero
+                //   size.
+                virtual bool Next(const void** data, int* size) = 0;
 
-  // Returns the total number of bytes read since this object was created.
-  virtual int64_t ByteCount() const = 0;
+                // Backs up a number of bytes, so that the next call to Next() returns
+                // data again that was already returned by the last call to Next().  This
+                // is useful when writing procedures that are only supposed to read up
+                // to a certain point in the input, then return.  If Next() returns a
+                // buffer that goes beyond what you wanted to read, you can use BackUp()
+                // to return to the point where you intended to finish.
+                //
+                // This method can be called with `count = 0` to finalize (flush) any
+                // previously returned buffer. For example, a file output stream can
+                // flush buffers returned from a previous call to Next() upon such
+                // BackUp(0) invocations. ZeroCopyOutputStream callers should always
+                // invoke BackUp() after a final Next() call, even if there is no
+                // excess buffer data to be backed up to indicate a flush point.
+                //
+                // Preconditions:
+                // * The last method called must have been Next().
+                // * count must be less than or equal to the size of the last buffer
+                //   returned by Next().
+                //
+                // Postconditions:
+                // * The last "count" bytes of the last buffer returned by Next() will be
+                //   pushed back into the stream.  Subsequent calls to Next() will return
+                //   the same data again before producing new data.
+                virtual void BackUp(int count) = 0;
 
+                // Skips a number of bytes.  Returns false if the end of the stream is
+                // reached or some input error occurred.  In the end-of-stream case, the
+                // stream is advanced to the end of the stream (so ByteCount() will return
+                // the total size of the stream).
+                virtual bool Skip(int count) = 0;
 
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyInputStream);
-};
+                // Returns the total number of bytes read since this object was created.
+                virtual int64_t ByteCount() const = 0;
 
-// Abstract interface similar to an output stream but designed to minimize
-// copying.
-class PROTOBUF_EXPORT ZeroCopyOutputStream {
- public:
-  ZeroCopyOutputStream() {}
-  virtual ~ZeroCopyOutputStream() {}
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyInputStream);
+            };
 
-  // Obtains a buffer into which data can be written.  Any data written
-  // into this buffer will eventually (maybe instantly, maybe later on)
-  // be written to the output.
-  //
-  // Preconditions:
-  // * "size" and "data" are not NULL.
-  //
-  // Postconditions:
-  // * If the returned value is false, an error occurred.  All errors are
-  //   permanent.
-  // * Otherwise, "size" points to the actual number of bytes in the buffer
-  //   and "data" points to the buffer.
-  // * Ownership of this buffer remains with the stream, and the buffer
-  //   remains valid only until some other method of the stream is called
-  //   or the stream is destroyed.
-  // * Any data which the caller stores in this buffer will eventually be
-  //   written to the output (unless BackUp() is called).
-  // * It is legal for the returned buffer to have zero size, as long
-  //   as repeatedly calling Next() eventually yields a buffer with non-zero
-  //   size.
-  virtual bool Next(void** data, int* size) = 0;
+            // Abstract interface similar to an output stream but designed to minimize
+            // copying.
+            class PROTOBUF_EXPORT ZeroCopyOutputStream
+            {
+            public:
+                ZeroCopyOutputStream()
+                {
+                }
+                virtual ~ZeroCopyOutputStream()
+                {
+                }
 
-  // Backs up a number of bytes, so that the end of the last buffer returned
-  // by Next() is not actually written.  This is needed when you finish
-  // writing all the data you want to write, but the last buffer was bigger
-  // than you needed.  You don't want to write a bunch of garbage after the
-  // end of your data, so you use BackUp() to back up.
-  //
-  // Preconditions:
-  // * The last method called must have been Next().
-  // * count must be less than or equal to the size of the last buffer
-  //   returned by Next().
-  // * The caller must not have written anything to the last "count" bytes
-  //   of that buffer.
-  //
-  // Postconditions:
-  // * The last "count" bytes of the last buffer returned by Next() will be
-  //   ignored.
-  virtual void BackUp(int count) = 0;
+                // Obtains a buffer into which data can be written.  Any data written
+                // into this buffer will eventually (maybe instantly, maybe later on)
+                // be written to the output.
+                //
+                // Preconditions:
+                // * "size" and "data" are not NULL.
+                //
+                // Postconditions:
+                // * If the returned value is false, an error occurred.  All errors are
+                //   permanent.
+                // * Otherwise, "size" points to the actual number of bytes in the buffer
+                //   and "data" points to the buffer.
+                // * Ownership of this buffer remains with the stream, and the buffer
+                //   remains valid only until some other method of the stream is called
+                //   or the stream is destroyed.
+                // * Any data which the caller stores in this buffer will eventually be
+                //   written to the output (unless BackUp() is called).
+                // * It is legal for the returned buffer to have zero size, as long
+                //   as repeatedly calling Next() eventually yields a buffer with non-zero
+                //   size.
+                virtual bool Next(void** data, int* size) = 0;
 
-  // Returns the total number of bytes written since this object was created.
-  virtual int64_t ByteCount() const = 0;
+                // Backs up a number of bytes, so that the end of the last buffer returned
+                // by Next() is not actually written.  This is needed when you finish
+                // writing all the data you want to write, but the last buffer was bigger
+                // than you needed.  You don't want to write a bunch of garbage after the
+                // end of your data, so you use BackUp() to back up.
+                //
+                // Preconditions:
+                // * The last method called must have been Next().
+                // * count must be less than or equal to the size of the last buffer
+                //   returned by Next().
+                // * The caller must not have written anything to the last "count" bytes
+                //   of that buffer.
+                //
+                // Postconditions:
+                // * The last "count" bytes of the last buffer returned by Next() will be
+                //   ignored.
+                virtual void BackUp(int count) = 0;
 
-  // Write a given chunk of data to the output.  Some output streams may
-  // implement this in a way that avoids copying. Check AllowsAliasing() before
-  // calling WriteAliasedRaw(). It will GOOGLE_CHECK fail if WriteAliasedRaw() is
-  // called on a stream that does not allow aliasing.
-  //
-  // NOTE: It is caller's responsibility to ensure that the chunk of memory
-  // remains live until all of the data has been consumed from the stream.
-  virtual bool WriteAliasedRaw(const void* data, int size);
-  virtual bool AllowsAliasing() const { return false; }
+                // Returns the total number of bytes written since this object was created.
+                virtual int64_t ByteCount() const = 0;
 
+                // Write a given chunk of data to the output.  Some output streams may
+                // implement this in a way that avoids copying. Check AllowsAliasing() before
+                // calling WriteAliasedRaw(). It will GOOGLE_CHECK fail if WriteAliasedRaw() is
+                // called on a stream that does not allow aliasing.
+                //
+                // NOTE: It is caller's responsibility to ensure that the chunk of memory
+                // remains live until all of the data has been consumed from the stream.
+                virtual bool WriteAliasedRaw(const void* data, int size);
+                virtual bool AllowsAliasing() const
+                {
+                    return false;
+                }
 
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyOutputStream);
-};
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyOutputStream);
+            };
 
-}  // namespace io
-}  // namespace protobuf
+        }  // namespace io
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl.h b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl.h
index a385992..cd49ef6 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl.h
@@ -40,7 +40,6 @@
 #ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
 #define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
 
-
 #include <iosfwd>
 #include <string>
 
@@ -51,284 +50,310 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace io {
-
-// ===================================================================
-
-// A ZeroCopyInputStream which reads from a file descriptor.
-//
-// FileInputStream is preferred over using an ifstream with IstreamInputStream.
-// The latter will introduce an extra layer of buffering, harming performance.
-// Also, it's conceivable that FileInputStream could someday be enhanced
-// to use zero-copy file descriptors on OSs which support them.
-class PROTOBUF_EXPORT FileInputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyInputStream {
- public:
-  // Creates a stream that reads from the given Unix file descriptor.
-  // If a block_size is given, it specifies the number of bytes that
-  // should be read and returned with each call to Next().  Otherwise,
-  // a reasonable default is used.
-  explicit FileInputStream(int file_descriptor, int block_size = -1);
-
-  // Flushes any buffers and closes the underlying file.  Returns false if
-  // an error occurs during the process; use GetErrno() to examine the error.
-  // Even if an error occurs, the file descriptor is closed when this returns.
-  bool Close();
-
-  // By default, the file descriptor is not closed when the stream is
-  // destroyed.  Call SetCloseOnDelete(true) to change that.  WARNING:
-  // This leaves no way for the caller to detect if close() fails.  If
-  // detecting close() errors is important to you, you should arrange
-  // to close the descriptor yourself.
-  void SetCloseOnDelete(bool value) { copying_input_.SetCloseOnDelete(value); }
-
-  // If an I/O error has occurred on this file descriptor, this is the
-  // errno from that error.  Otherwise, this is zero.  Once an error
-  // occurs, the stream is broken and all subsequent operations will
-  // fail.
-  int GetErrno() const { return copying_input_.GetErrno(); }
-
-  // implements ZeroCopyInputStream ----------------------------------
-  bool Next(const void** data, int* size) override;
-  void BackUp(int count) override;
-  bool Skip(int count) override;
-  int64_t ByteCount() const override;
-
- private:
-  class PROTOBUF_EXPORT CopyingFileInputStream PROTOBUF_FUTURE_FINAL
-      : public CopyingInputStream {
-   public:
-    CopyingFileInputStream(int file_descriptor);
-    ~CopyingFileInputStream() override;
-
-    bool Close();
-    void SetCloseOnDelete(bool value) { close_on_delete_ = value; }
-    int GetErrno() const { return errno_; }
-
-    // implements CopyingInputStream ---------------------------------
-    int Read(void* buffer, int size) override;
-    int Skip(int count) override;
-
-   private:
-    // The file descriptor.
-    const int file_;
-    bool close_on_delete_;
-    bool is_closed_;
-
-    // The errno of the I/O error, if one has occurred.  Otherwise, zero.
-    int errno_;
-
-    // Did we try to seek once and fail?  If so, we assume this file descriptor
-    // doesn't support seeking and won't try again.
-    bool previous_seek_failed_;
-
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingFileInputStream);
-  };
-
-  CopyingFileInputStream copying_input_;
-  CopyingInputStreamAdaptor impl_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileInputStream);
-};
-
-// ===================================================================
-
-// A ZeroCopyOutputStream which writes to a file descriptor.
-//
-// FileOutputStream is preferred over using an ofstream with
-// OstreamOutputStream.  The latter will introduce an extra layer of buffering,
-// harming performance.  Also, it's conceivable that FileOutputStream could
-// someday be enhanced to use zero-copy file descriptors on OSs which
-// support them.
-class PROTOBUF_EXPORT FileOutputStream PROTOBUF_FUTURE_FINAL
-    : public CopyingOutputStreamAdaptor {
- public:
-  // Creates a stream that writes to the given Unix file descriptor.
-  // If a block_size is given, it specifies the size of the buffers
-  // that should be returned by Next().  Otherwise, a reasonable default
-  // is used.
-  explicit FileOutputStream(int file_descriptor, int block_size = -1);
-
-  ~FileOutputStream() override;
-
-  // Flushes any buffers and closes the underlying file.  Returns false if
-  // an error occurs during the process; use GetErrno() to examine the error.
-  // Even if an error occurs, the file descriptor is closed when this returns.
-  bool Close();
-
-  // By default, the file descriptor is not closed when the stream is
-  // destroyed.  Call SetCloseOnDelete(true) to change that.  WARNING:
-  // This leaves no way for the caller to detect if close() fails.  If
-  // detecting close() errors is important to you, you should arrange
-  // to close the descriptor yourself.
-  void SetCloseOnDelete(bool value) { copying_output_.SetCloseOnDelete(value); }
-
-  // If an I/O error has occurred on this file descriptor, this is the
-  // errno from that error.  Otherwise, this is zero.  Once an error
-  // occurs, the stream is broken and all subsequent operations will
-  // fail.
-  int GetErrno() const { return copying_output_.GetErrno(); }
-
- private:
-  class PROTOBUF_EXPORT CopyingFileOutputStream PROTOBUF_FUTURE_FINAL
-      : public CopyingOutputStream {
-   public:
-    CopyingFileOutputStream(int file_descriptor);
-    ~CopyingFileOutputStream() override;
-
-    bool Close();
-    void SetCloseOnDelete(bool value) { close_on_delete_ = value; }
-    int GetErrno() const { return errno_; }
-
-    // implements CopyingOutputStream --------------------------------
-    bool Write(const void* buffer, int size) override;
-
-   private:
-    // The file descriptor.
-    const int file_;
-    bool close_on_delete_;
-    bool is_closed_;
-
-    // The errno of the I/O error, if one has occurred.  Otherwise, zero.
-    int errno_;
-
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingFileOutputStream);
-  };
-
-  CopyingFileOutputStream copying_output_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileOutputStream);
-};
-
-// ===================================================================
-
-// A ZeroCopyInputStream which reads from a C++ istream.
-//
-// Note that for reading files (or anything represented by a file descriptor),
-// FileInputStream is more efficient.
-class PROTOBUF_EXPORT IstreamInputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyInputStream {
- public:
-  // Creates a stream that reads from the given C++ istream.
-  // If a block_size is given, it specifies the number of bytes that
-  // should be read and returned with each call to Next().  Otherwise,
-  // a reasonable default is used.
-  explicit IstreamInputStream(std::istream* stream, int block_size = -1);
-
-  // implements ZeroCopyInputStream ----------------------------------
-  bool Next(const void** data, int* size) override;
-  void BackUp(int count) override;
-  bool Skip(int count) override;
-  int64_t ByteCount() const override;
-
- private:
-  class PROTOBUF_EXPORT CopyingIstreamInputStream PROTOBUF_FUTURE_FINAL
-      : public CopyingInputStream {
-   public:
-    CopyingIstreamInputStream(std::istream* input);
-    ~CopyingIstreamInputStream() override;
-
-    // implements CopyingInputStream ---------------------------------
-    int Read(void* buffer, int size) override;
-    // (We use the default implementation of Skip().)
-
-   private:
-    // The stream.
-    std::istream* input_;
-
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingIstreamInputStream);
-  };
-
-  CopyingIstreamInputStream copying_input_;
-  CopyingInputStreamAdaptor impl_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(IstreamInputStream);
-};
-
-// ===================================================================
-
-// A ZeroCopyOutputStream which writes to a C++ ostream.
-//
-// Note that for writing files (or anything represented by a file descriptor),
-// FileOutputStream is more efficient.
-class PROTOBUF_EXPORT OstreamOutputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyOutputStream {
- public:
-  // Creates a stream that writes to the given C++ ostream.
-  // If a block_size is given, it specifies the size of the buffers
-  // that should be returned by Next().  Otherwise, a reasonable default
-  // is used.
-  explicit OstreamOutputStream(std::ostream* stream, int block_size = -1);
-  ~OstreamOutputStream() override;
-
-  // implements ZeroCopyOutputStream ---------------------------------
-  bool Next(void** data, int* size) override;
-  void BackUp(int count) override;
-  int64_t ByteCount() const override;
-
- private:
-  class PROTOBUF_EXPORT CopyingOstreamOutputStream PROTOBUF_FUTURE_FINAL
-      : public CopyingOutputStream {
-   public:
-    CopyingOstreamOutputStream(std::ostream* output);
-    ~CopyingOstreamOutputStream() override;
-
-    // implements CopyingOutputStream --------------------------------
-    bool Write(const void* buffer, int size) override;
-
-   private:
-    // The stream.
-    std::ostream* output_;
-
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingOstreamOutputStream);
-  };
-
-  CopyingOstreamOutputStream copying_output_;
-  CopyingOutputStreamAdaptor impl_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OstreamOutputStream);
-};
-
-// ===================================================================
-
-// A ZeroCopyInputStream which reads from several other streams in sequence.
-// ConcatenatingInputStream is unable to distinguish between end-of-stream
-// and read errors in the underlying streams, so it assumes any errors mean
-// end-of-stream.  So, if the underlying streams fail for any other reason,
-// ConcatenatingInputStream may do odd things.  It is suggested that you do
-// not use ConcatenatingInputStream on streams that might produce read errors
-// other than end-of-stream.
-class PROTOBUF_EXPORT ConcatenatingInputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyInputStream {
- public:
-  // All streams passed in as well as the array itself must remain valid
-  // until the ConcatenatingInputStream is destroyed.
-  ConcatenatingInputStream(ZeroCopyInputStream* const streams[], int count);
-  ~ConcatenatingInputStream() override = default;
-
-  // implements ZeroCopyInputStream ----------------------------------
-  bool Next(const void** data, int* size) override;
-  void BackUp(int count) override;
-  bool Skip(int count) override;
-  int64_t ByteCount() const override;
-
-
- private:
-  // As streams are retired, streams_ is incremented and count_ is
-  // decremented.
-  ZeroCopyInputStream* const* streams_;
-  int stream_count_;
-  int64_t bytes_retired_;  // Bytes read from previous streams.
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ConcatenatingInputStream);
-};
-
-// ===================================================================
-
-}  // namespace io
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
+
+            // ===================================================================
+
+            // A ZeroCopyInputStream which reads from a file descriptor.
+            //
+            // FileInputStream is preferred over using an ifstream with IstreamInputStream.
+            // The latter will introduce an extra layer of buffering, harming performance.
+            // Also, it's conceivable that FileInputStream could someday be enhanced
+            // to use zero-copy file descriptors on OSs which support them.
+            class PROTOBUF_EXPORT FileInputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyInputStream
+            {
+            public:
+                // Creates a stream that reads from the given Unix file descriptor.
+                // If a block_size is given, it specifies the number of bytes that
+                // should be read and returned with each call to Next().  Otherwise,
+                // a reasonable default is used.
+                explicit FileInputStream(int file_descriptor, int block_size = -1);
+
+                // Flushes any buffers and closes the underlying file.  Returns false if
+                // an error occurs during the process; use GetErrno() to examine the error.
+                // Even if an error occurs, the file descriptor is closed when this returns.
+                bool Close();
+
+                // By default, the file descriptor is not closed when the stream is
+                // destroyed.  Call SetCloseOnDelete(true) to change that.  WARNING:
+                // This leaves no way for the caller to detect if close() fails.  If
+                // detecting close() errors is important to you, you should arrange
+                // to close the descriptor yourself.
+                void SetCloseOnDelete(bool value)
+                {
+                    copying_input_.SetCloseOnDelete(value);
+                }
+
+                // If an I/O error has occurred on this file descriptor, this is the
+                // errno from that error.  Otherwise, this is zero.  Once an error
+                // occurs, the stream is broken and all subsequent operations will
+                // fail.
+                int GetErrno() const
+                {
+                    return copying_input_.GetErrno();
+                }
+
+                // implements ZeroCopyInputStream ----------------------------------
+                bool Next(const void** data, int* size) override;
+                void BackUp(int count) override;
+                bool Skip(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                class PROTOBUF_EXPORT CopyingFileInputStream PROTOBUF_FUTURE_FINAL : public CopyingInputStream
+                {
+                public:
+                    CopyingFileInputStream(int file_descriptor);
+                    ~CopyingFileInputStream() override;
+
+                    bool Close();
+                    void SetCloseOnDelete(bool value)
+                    {
+                        close_on_delete_ = value;
+                    }
+                    int GetErrno() const
+                    {
+                        return errno_;
+                    }
+
+                    // implements CopyingInputStream ---------------------------------
+                    int Read(void* buffer, int size) override;
+                    int Skip(int count) override;
+
+                private:
+                    // The file descriptor.
+                    const int file_;
+                    bool close_on_delete_;
+                    bool is_closed_;
+
+                    // The errno of the I/O error, if one has occurred.  Otherwise, zero.
+                    int errno_;
+
+                    // Did we try to seek once and fail?  If so, we assume this file descriptor
+                    // doesn't support seeking and won't try again.
+                    bool previous_seek_failed_;
+
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingFileInputStream);
+                };
+
+                CopyingFileInputStream copying_input_;
+                CopyingInputStreamAdaptor impl_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileInputStream);
+            };
+
+            // ===================================================================
+
+            // A ZeroCopyOutputStream which writes to a file descriptor.
+            //
+            // FileOutputStream is preferred over using an ofstream with
+            // OstreamOutputStream.  The latter will introduce an extra layer of buffering,
+            // harming performance.  Also, it's conceivable that FileOutputStream could
+            // someday be enhanced to use zero-copy file descriptors on OSs which
+            // support them.
+            class PROTOBUF_EXPORT FileOutputStream PROTOBUF_FUTURE_FINAL : public CopyingOutputStreamAdaptor
+            {
+            public:
+                // Creates a stream that writes to the given Unix file descriptor.
+                // If a block_size is given, it specifies the size of the buffers
+                // that should be returned by Next().  Otherwise, a reasonable default
+                // is used.
+                explicit FileOutputStream(int file_descriptor, int block_size = -1);
+
+                ~FileOutputStream() override;
+
+                // Flushes any buffers and closes the underlying file.  Returns false if
+                // an error occurs during the process; use GetErrno() to examine the error.
+                // Even if an error occurs, the file descriptor is closed when this returns.
+                bool Close();
+
+                // By default, the file descriptor is not closed when the stream is
+                // destroyed.  Call SetCloseOnDelete(true) to change that.  WARNING:
+                // This leaves no way for the caller to detect if close() fails.  If
+                // detecting close() errors is important to you, you should arrange
+                // to close the descriptor yourself.
+                void SetCloseOnDelete(bool value)
+                {
+                    copying_output_.SetCloseOnDelete(value);
+                }
+
+                // If an I/O error has occurred on this file descriptor, this is the
+                // errno from that error.  Otherwise, this is zero.  Once an error
+                // occurs, the stream is broken and all subsequent operations will
+                // fail.
+                int GetErrno() const
+                {
+                    return copying_output_.GetErrno();
+                }
+
+            private:
+                class PROTOBUF_EXPORT CopyingFileOutputStream PROTOBUF_FUTURE_FINAL : public CopyingOutputStream
+                {
+                public:
+                    CopyingFileOutputStream(int file_descriptor);
+                    ~CopyingFileOutputStream() override;
+
+                    bool Close();
+                    void SetCloseOnDelete(bool value)
+                    {
+                        close_on_delete_ = value;
+                    }
+                    int GetErrno() const
+                    {
+                        return errno_;
+                    }
+
+                    // implements CopyingOutputStream --------------------------------
+                    bool Write(const void* buffer, int size) override;
+
+                private:
+                    // The file descriptor.
+                    const int file_;
+                    bool close_on_delete_;
+                    bool is_closed_;
+
+                    // The errno of the I/O error, if one has occurred.  Otherwise, zero.
+                    int errno_;
+
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingFileOutputStream);
+                };
+
+                CopyingFileOutputStream copying_output_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileOutputStream);
+            };
+
+            // ===================================================================
+
+            // A ZeroCopyInputStream which reads from a C++ istream.
+            //
+            // Note that for reading files (or anything represented by a file descriptor),
+            // FileInputStream is more efficient.
+            class PROTOBUF_EXPORT IstreamInputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyInputStream
+            {
+            public:
+                // Creates a stream that reads from the given C++ istream.
+                // If a block_size is given, it specifies the number of bytes that
+                // should be read and returned with each call to Next().  Otherwise,
+                // a reasonable default is used.
+                explicit IstreamInputStream(std::istream* stream, int block_size = -1);
+
+                // implements ZeroCopyInputStream ----------------------------------
+                bool Next(const void** data, int* size) override;
+                void BackUp(int count) override;
+                bool Skip(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                class PROTOBUF_EXPORT CopyingIstreamInputStream PROTOBUF_FUTURE_FINAL : public CopyingInputStream
+                {
+                public:
+                    CopyingIstreamInputStream(std::istream* input);
+                    ~CopyingIstreamInputStream() override;
+
+                    // implements CopyingInputStream ---------------------------------
+                    int Read(void* buffer, int size) override;
+                    // (We use the default implementation of Skip().)
+
+                private:
+                    // The stream.
+                    std::istream* input_;
+
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingIstreamInputStream);
+                };
+
+                CopyingIstreamInputStream copying_input_;
+                CopyingInputStreamAdaptor impl_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(IstreamInputStream);
+            };
+
+            // ===================================================================
+
+            // A ZeroCopyOutputStream which writes to a C++ ostream.
+            //
+            // Note that for writing files (or anything represented by a file descriptor),
+            // FileOutputStream is more efficient.
+            class PROTOBUF_EXPORT OstreamOutputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyOutputStream
+            {
+            public:
+                // Creates a stream that writes to the given C++ ostream.
+                // If a block_size is given, it specifies the size of the buffers
+                // that should be returned by Next().  Otherwise, a reasonable default
+                // is used.
+                explicit OstreamOutputStream(std::ostream* stream, int block_size = -1);
+                ~OstreamOutputStream() override;
+
+                // implements ZeroCopyOutputStream ---------------------------------
+                bool Next(void** data, int* size) override;
+                void BackUp(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                class PROTOBUF_EXPORT CopyingOstreamOutputStream PROTOBUF_FUTURE_FINAL : public CopyingOutputStream
+                {
+                public:
+                    CopyingOstreamOutputStream(std::ostream* output);
+                    ~CopyingOstreamOutputStream() override;
+
+                    // implements CopyingOutputStream --------------------------------
+                    bool Write(const void* buffer, int size) override;
+
+                private:
+                    // The stream.
+                    std::ostream* output_;
+
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingOstreamOutputStream);
+                };
+
+                CopyingOstreamOutputStream copying_output_;
+                CopyingOutputStreamAdaptor impl_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OstreamOutputStream);
+            };
+
+            // ===================================================================
+
+            // A ZeroCopyInputStream which reads from several other streams in sequence.
+            // ConcatenatingInputStream is unable to distinguish between end-of-stream
+            // and read errors in the underlying streams, so it assumes any errors mean
+            // end-of-stream.  So, if the underlying streams fail for any other reason,
+            // ConcatenatingInputStream may do odd things.  It is suggested that you do
+            // not use ConcatenatingInputStream on streams that might produce read errors
+            // other than end-of-stream.
+            class PROTOBUF_EXPORT ConcatenatingInputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyInputStream
+            {
+            public:
+                // All streams passed in as well as the array itself must remain valid
+                // until the ConcatenatingInputStream is destroyed.
+                ConcatenatingInputStream(ZeroCopyInputStream* const streams[], int count);
+                ~ConcatenatingInputStream() override = default;
+
+                // implements ZeroCopyInputStream ----------------------------------
+                bool Next(const void** data, int* size) override;
+                void BackUp(int count) override;
+                bool Skip(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                // As streams are retired, streams_ is incremented and count_ is
+                // decremented.
+                ZeroCopyInputStream* const* streams_;
+                int stream_count_;
+                int64_t bytes_retired_;  // Bytes read from previous streams.
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ConcatenatingInputStream);
+            };
+
+            // ===================================================================
+
+        }  // namespace io
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl_lite.h b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl_lite.h
index cbda328..1acf3ed 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl_lite.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/io/zero_copy_stream_impl_lite.h
@@ -44,7 +44,6 @@
 #ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
 #define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
 
-
 #include <iosfwd>
 #include <memory>
 #include <string>
@@ -54,358 +53,374 @@
 #include <google/protobuf/io/zero_copy_stream.h>
 #include <google/protobuf/stubs/stl_util.h>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace io {
-
-// ===================================================================
-
-// A ZeroCopyInputStream backed by an in-memory array of bytes.
-class PROTOBUF_EXPORT ArrayInputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyInputStream {
- public:
-  // Create an InputStream that returns the bytes pointed to by "data".
-  // "data" remains the property of the caller but must remain valid until
-  // the stream is destroyed.  If a block_size is given, calls to Next()
-  // will return data blocks no larger than the given size.  Otherwise, the
-  // first call to Next() returns the entire array.  block_size is mainly
-  // useful for testing; in production you would probably never want to set
-  // it.
-  ArrayInputStream(const void* data, int size, int block_size = -1);
-  ~ArrayInputStream() override = default;
-
-  // implements ZeroCopyInputStream ----------------------------------
-  bool Next(const void** data, int* size) override;
-  void BackUp(int count) override;
-  bool Skip(int count) override;
-  int64_t ByteCount() const override;
-
-
- private:
-  const uint8_t* const data_;  // The byte array.
-  const int size_;           // Total size of the array.
-  const int block_size_;     // How many bytes to return at a time.
-
-  int position_;
-  int last_returned_size_;  // How many bytes we returned last time Next()
-                            // was called (used for error checking only).
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayInputStream);
-};
-
-// ===================================================================
-
-// A ZeroCopyOutputStream backed by an in-memory array of bytes.
-class PROTOBUF_EXPORT ArrayOutputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyOutputStream {
- public:
-  // Create an OutputStream that writes to the bytes pointed to by "data".
-  // "data" remains the property of the caller but must remain valid until
-  // the stream is destroyed.  If a block_size is given, calls to Next()
-  // will return data blocks no larger than the given size.  Otherwise, the
-  // first call to Next() returns the entire array.  block_size is mainly
-  // useful for testing; in production you would probably never want to set
-  // it.
-  ArrayOutputStream(void* data, int size, int block_size = -1);
-  ~ArrayOutputStream() override = default;
-
-  // implements ZeroCopyOutputStream ---------------------------------
-  bool Next(void** data, int* size) override;
-  void BackUp(int count) override;
-  int64_t ByteCount() const override;
-
- private:
-  uint8_t* const data_;     // The byte array.
-  const int size_;        // Total size of the array.
-  const int block_size_;  // How many bytes to return at a time.
-
-  int position_;
-  int last_returned_size_;  // How many bytes we returned last time Next()
-                            // was called (used for error checking only).
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayOutputStream);
-};
-
-// ===================================================================
-
-// A ZeroCopyOutputStream which appends bytes to a string.
-class PROTOBUF_EXPORT StringOutputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyOutputStream {
- public:
-  // Create a StringOutputStream which appends bytes to the given string.
-  // The string remains property of the caller, but it is mutated in arbitrary
-  // ways and MUST NOT be accessed in any way until you're done with the
-  // stream. Either be sure there's no further usage, or (safest) destroy the
-  // stream before using the contents.
-  //
-  // Hint:  If you call target->reserve(n) before creating the stream,
-  //   the first call to Next() will return at least n bytes of buffer
-  //   space.
-  explicit StringOutputStream(std::string* target);
-  ~StringOutputStream() override = default;
-
-  // implements ZeroCopyOutputStream ---------------------------------
-  bool Next(void** data, int* size) override;
-  void BackUp(int count) override;
-  int64_t ByteCount() const override;
-
- private:
-  static constexpr size_t kMinimumSize = 16;
-
-  std::string* target_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringOutputStream);
-};
-
-// Note:  There is no StringInputStream.  Instead, just create an
-// ArrayInputStream as follows:
-//   ArrayInputStream input(str.data(), str.size());
-
-// ===================================================================
-
-// A generic traditional input stream interface.
-//
-// Lots of traditional input streams (e.g. file descriptors, C stdio
-// streams, and C++ iostreams) expose an interface where every read
-// involves copying bytes into a buffer.  If you want to take such an
-// interface and make a ZeroCopyInputStream based on it, simply implement
-// CopyingInputStream and then use CopyingInputStreamAdaptor.
-//
-// CopyingInputStream implementations should avoid buffering if possible.
-// CopyingInputStreamAdaptor does its own buffering and will read data
-// in large blocks.
-class PROTOBUF_EXPORT CopyingInputStream {
- public:
-  virtual ~CopyingInputStream() {}
-
-  // Reads up to "size" bytes into the given buffer.  Returns the number of
-  // bytes read.  Read() waits until at least one byte is available, or
-  // returns zero if no bytes will ever become available (EOF), or -1 if a
-  // permanent read error occurred.
-  virtual int Read(void* buffer, int size) = 0;
-
-  // Skips the next "count" bytes of input.  Returns the number of bytes
-  // actually skipped.  This will always be exactly equal to "count" unless
-  // EOF was reached or a permanent read error occurred.
-  //
-  // The default implementation just repeatedly calls Read() into a scratch
-  // buffer.
-  virtual int Skip(int count);
-};
-
-// A ZeroCopyInputStream which reads from a CopyingInputStream.  This is
-// useful for implementing ZeroCopyInputStreams that read from traditional
-// streams.  Note that this class is not really zero-copy.
-//
-// If you want to read from file descriptors or C++ istreams, this is
-// already implemented for you:  use FileInputStream or IstreamInputStream
-// respectively.
-class PROTOBUF_EXPORT CopyingInputStreamAdaptor : public ZeroCopyInputStream {
- public:
-  // Creates a stream that reads from the given CopyingInputStream.
-  // If a block_size is given, it specifies the number of bytes that
-  // should be read and returned with each call to Next().  Otherwise,
-  // a reasonable default is used.  The caller retains ownership of
-  // copying_stream unless SetOwnsCopyingStream(true) is called.
-  explicit CopyingInputStreamAdaptor(CopyingInputStream* copying_stream,
-                                     int block_size = -1);
-  ~CopyingInputStreamAdaptor() override;
-
-  // Call SetOwnsCopyingStream(true) to tell the CopyingInputStreamAdaptor to
-  // delete the underlying CopyingInputStream when it is destroyed.
-  void SetOwnsCopyingStream(bool value) { owns_copying_stream_ = value; }
-
-  // implements ZeroCopyInputStream ----------------------------------
-  bool Next(const void** data, int* size) override;
-  void BackUp(int count) override;
-  bool Skip(int count) override;
-  int64_t ByteCount() const override;
-
- private:
-  // Insures that buffer_ is not NULL.
-  void AllocateBufferIfNeeded();
-  // Frees the buffer and resets buffer_used_.
-  void FreeBuffer();
-
-  // The underlying copying stream.
-  CopyingInputStream* copying_stream_;
-  bool owns_copying_stream_;
-
-  // True if we have seen a permanent error from the underlying stream.
-  bool failed_;
-
-  // The current position of copying_stream_, relative to the point where
-  // we started reading.
-  int64_t position_;
-
-  // Data is read into this buffer.  It may be NULL if no buffer is currently
-  // in use.  Otherwise, it points to an array of size buffer_size_.
-  std::unique_ptr<uint8_t[]> buffer_;
-  const int buffer_size_;
-
-  // Number of valid bytes currently in the buffer (i.e. the size last
-  // returned by Next()).  0 <= buffer_used_ <= buffer_size_.
-  int buffer_used_;
-
-  // Number of bytes in the buffer which were backed up over by a call to
-  // BackUp().  These need to be returned again.
-  // 0 <= backup_bytes_ <= buffer_used_
-  int backup_bytes_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingInputStreamAdaptor);
-};
-
-// ===================================================================
-
-// A generic traditional output stream interface.
-//
-// Lots of traditional output streams (e.g. file descriptors, C stdio
-// streams, and C++ iostreams) expose an interface where every write
-// involves copying bytes from a buffer.  If you want to take such an
-// interface and make a ZeroCopyOutputStream based on it, simply implement
-// CopyingOutputStream and then use CopyingOutputStreamAdaptor.
-//
-// CopyingOutputStream implementations should avoid buffering if possible.
-// CopyingOutputStreamAdaptor does its own buffering and will write data
-// in large blocks.
-class PROTOBUF_EXPORT CopyingOutputStream {
- public:
-  virtual ~CopyingOutputStream() {}
-
-  // Writes "size" bytes from the given buffer to the output.  Returns true
-  // if successful, false on a write error.
-  virtual bool Write(const void* buffer, int size) = 0;
-};
-
-// A ZeroCopyOutputStream which writes to a CopyingOutputStream.  This is
-// useful for implementing ZeroCopyOutputStreams that write to traditional
-// streams.  Note that this class is not really zero-copy.
-//
-// If you want to write to file descriptors or C++ ostreams, this is
-// already implemented for you:  use FileOutputStream or OstreamOutputStream
-// respectively.
-class PROTOBUF_EXPORT CopyingOutputStreamAdaptor : public ZeroCopyOutputStream {
- public:
-  // Creates a stream that writes to the given Unix file descriptor.
-  // If a block_size is given, it specifies the size of the buffers
-  // that should be returned by Next().  Otherwise, a reasonable default
-  // is used.
-  explicit CopyingOutputStreamAdaptor(CopyingOutputStream* copying_stream,
-                                      int block_size = -1);
-  ~CopyingOutputStreamAdaptor() override;
-
-  // Writes all pending data to the underlying stream.  Returns false if a
-  // write error occurred on the underlying stream.  (The underlying
-  // stream itself is not necessarily flushed.)
-  bool Flush();
-
-  // Call SetOwnsCopyingStream(true) to tell the CopyingOutputStreamAdaptor to
-  // delete the underlying CopyingOutputStream when it is destroyed.
-  void SetOwnsCopyingStream(bool value) { owns_copying_stream_ = value; }
-
-  // implements ZeroCopyOutputStream ---------------------------------
-  bool Next(void** data, int* size) override;
-  void BackUp(int count) override;
-  int64_t ByteCount() const override;
-  bool WriteAliasedRaw(const void* data, int size) override;
-  bool AllowsAliasing() const override { return true; }
-
- private:
-  // Write the current buffer, if it is present.
-  bool WriteBuffer();
-  // Insures that buffer_ is not NULL.
-  void AllocateBufferIfNeeded();
-  // Frees the buffer.
-  void FreeBuffer();
-
-  // The underlying copying stream.
-  CopyingOutputStream* copying_stream_;
-  bool owns_copying_stream_;
-
-  // True if we have seen a permanent error from the underlying stream.
-  bool failed_;
-
-  // The current position of copying_stream_, relative to the point where
-  // we started writing.
-  int64_t position_;
-
-  // Data is written from this buffer.  It may be NULL if no buffer is
-  // currently in use.  Otherwise, it points to an array of size buffer_size_.
-  std::unique_ptr<uint8_t[]> buffer_;
-  const int buffer_size_;
-
-  // Number of valid bytes currently in the buffer (i.e. the size last
-  // returned by Next()).  When BackUp() is called, we just reduce this.
-  // 0 <= buffer_used_ <= buffer_size_.
-  int buffer_used_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingOutputStreamAdaptor);
-};
-
-// ===================================================================
-
-// A ZeroCopyInputStream which wraps some other stream and limits it to
-// a particular byte count.
-class PROTOBUF_EXPORT LimitingInputStream PROTOBUF_FUTURE_FINAL
-    : public ZeroCopyInputStream {
- public:
-  LimitingInputStream(ZeroCopyInputStream* input, int64_t limit);
-  ~LimitingInputStream() override;
-
-  // implements ZeroCopyInputStream ----------------------------------
-  bool Next(const void** data, int* size) override;
-  void BackUp(int count) override;
-  bool Skip(int count) override;
-  int64_t ByteCount() const override;
-
-
- private:
-  ZeroCopyInputStream* input_;
-  int64_t limit_;  // Decreases as we go, becomes negative if we overshoot.
-  int64_t prior_bytes_read_;  // Bytes read on underlying stream at construction
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LimitingInputStream);
-};
-
-
-// ===================================================================
-
-// mutable_string_data() and as_string_data() are workarounds to improve
-// the performance of writing new data to an existing string.  Unfortunately
-// the methods provided by the string class are suboptimal, and using memcpy()
-// is mildly annoying because it requires its pointer args to be non-NULL even
-// if we ask it to copy 0 bytes.  Furthermore, string_as_array() has the
-// property that it always returns NULL if its arg is the empty string, exactly
-// what we want to avoid if we're using it in conjunction with memcpy()!
-// With C++11, the desired memcpy() boils down to memcpy(..., &(*s)[0], size),
-// where s is a string*.  Without C++11, &(*s)[0] is not guaranteed to be safe,
-// so we use string_as_array(), and live with the extra logic that tests whether
-// *s is empty.
-
-// Return a pointer to mutable characters underlying the given string.  The
-// return value is valid until the next time the string is resized.  We
-// trust the caller to treat the return value as an array of length s->size().
-inline char* mutable_string_data(std::string* s) {
-  // This should be simpler & faster than string_as_array() because the latter
-  // is guaranteed to return NULL when *s is empty, so it has to check for that.
-  return &(*s)[0];
-}
-
-// as_string_data(s) is equivalent to
-//  ({ char* p = mutable_string_data(s); make_pair(p, p != NULL); })
-// Sometimes it's faster: in some scenarios p cannot be NULL, and then the
-// code can avoid that check.
-inline std::pair<char*, bool> as_string_data(std::string* s) {
-  char* p = mutable_string_data(s);
-  return std::make_pair(p, true);
-}
-
-}  // namespace io
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
+
+            // ===================================================================
+
+            // A ZeroCopyInputStream backed by an in-memory array of bytes.
+            class PROTOBUF_EXPORT ArrayInputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyInputStream
+            {
+            public:
+                // Create an InputStream that returns the bytes pointed to by "data".
+                // "data" remains the property of the caller but must remain valid until
+                // the stream is destroyed.  If a block_size is given, calls to Next()
+                // will return data blocks no larger than the given size.  Otherwise, the
+                // first call to Next() returns the entire array.  block_size is mainly
+                // useful for testing; in production you would probably never want to set
+                // it.
+                ArrayInputStream(const void* data, int size, int block_size = -1);
+                ~ArrayInputStream() override = default;
+
+                // implements ZeroCopyInputStream ----------------------------------
+                bool Next(const void** data, int* size) override;
+                void BackUp(int count) override;
+                bool Skip(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                const uint8_t* const data_;  // The byte array.
+                const int size_;             // Total size of the array.
+                const int block_size_;       // How many bytes to return at a time.
+
+                int position_;
+                int last_returned_size_;  // How many bytes we returned last time Next()
+                                          // was called (used for error checking only).
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayInputStream);
+            };
+
+            // ===================================================================
+
+            // A ZeroCopyOutputStream backed by an in-memory array of bytes.
+            class PROTOBUF_EXPORT ArrayOutputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyOutputStream
+            {
+            public:
+                // Create an OutputStream that writes to the bytes pointed to by "data".
+                // "data" remains the property of the caller but must remain valid until
+                // the stream is destroyed.  If a block_size is given, calls to Next()
+                // will return data blocks no larger than the given size.  Otherwise, the
+                // first call to Next() returns the entire array.  block_size is mainly
+                // useful for testing; in production you would probably never want to set
+                // it.
+                ArrayOutputStream(void* data, int size, int block_size = -1);
+                ~ArrayOutputStream() override = default;
+
+                // implements ZeroCopyOutputStream ---------------------------------
+                bool Next(void** data, int* size) override;
+                void BackUp(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                uint8_t* const data_;   // The byte array.
+                const int size_;        // Total size of the array.
+                const int block_size_;  // How many bytes to return at a time.
+
+                int position_;
+                int last_returned_size_;  // How many bytes we returned last time Next()
+                                          // was called (used for error checking only).
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayOutputStream);
+            };
+
+            // ===================================================================
+
+            // A ZeroCopyOutputStream which appends bytes to a string.
+            class PROTOBUF_EXPORT StringOutputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyOutputStream
+            {
+            public:
+                // Create a StringOutputStream which appends bytes to the given string.
+                // The string remains property of the caller, but it is mutated in arbitrary
+                // ways and MUST NOT be accessed in any way until you're done with the
+                // stream. Either be sure there's no further usage, or (safest) destroy the
+                // stream before using the contents.
+                //
+                // Hint:  If you call target->reserve(n) before creating the stream,
+                //   the first call to Next() will return at least n bytes of buffer
+                //   space.
+                explicit StringOutputStream(std::string* target);
+                ~StringOutputStream() override = default;
+
+                // implements ZeroCopyOutputStream ---------------------------------
+                bool Next(void** data, int* size) override;
+                void BackUp(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                static constexpr size_t kMinimumSize = 16;
+
+                std::string* target_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringOutputStream);
+            };
+
+            // Note:  There is no StringInputStream.  Instead, just create an
+            // ArrayInputStream as follows:
+            //   ArrayInputStream input(str.data(), str.size());
+
+            // ===================================================================
+
+            // A generic traditional input stream interface.
+            //
+            // Lots of traditional input streams (e.g. file descriptors, C stdio
+            // streams, and C++ iostreams) expose an interface where every read
+            // involves copying bytes into a buffer.  If you want to take such an
+            // interface and make a ZeroCopyInputStream based on it, simply implement
+            // CopyingInputStream and then use CopyingInputStreamAdaptor.
+            //
+            // CopyingInputStream implementations should avoid buffering if possible.
+            // CopyingInputStreamAdaptor does its own buffering and will read data
+            // in large blocks.
+            class PROTOBUF_EXPORT CopyingInputStream
+            {
+            public:
+                virtual ~CopyingInputStream()
+                {
+                }
+
+                // Reads up to "size" bytes into the given buffer.  Returns the number of
+                // bytes read.  Read() waits until at least one byte is available, or
+                // returns zero if no bytes will ever become available (EOF), or -1 if a
+                // permanent read error occurred.
+                virtual int Read(void* buffer, int size) = 0;
+
+                // Skips the next "count" bytes of input.  Returns the number of bytes
+                // actually skipped.  This will always be exactly equal to "count" unless
+                // EOF was reached or a permanent read error occurred.
+                //
+                // The default implementation just repeatedly calls Read() into a scratch
+                // buffer.
+                virtual int Skip(int count);
+            };
+
+            // A ZeroCopyInputStream which reads from a CopyingInputStream.  This is
+            // useful for implementing ZeroCopyInputStreams that read from traditional
+            // streams.  Note that this class is not really zero-copy.
+            //
+            // If you want to read from file descriptors or C++ istreams, this is
+            // already implemented for you:  use FileInputStream or IstreamInputStream
+            // respectively.
+            class PROTOBUF_EXPORT CopyingInputStreamAdaptor : public ZeroCopyInputStream
+            {
+            public:
+                // Creates a stream that reads from the given CopyingInputStream.
+                // If a block_size is given, it specifies the number of bytes that
+                // should be read and returned with each call to Next().  Otherwise,
+                // a reasonable default is used.  The caller retains ownership of
+                // copying_stream unless SetOwnsCopyingStream(true) is called.
+                explicit CopyingInputStreamAdaptor(CopyingInputStream* copying_stream, int block_size = -1);
+                ~CopyingInputStreamAdaptor() override;
+
+                // Call SetOwnsCopyingStream(true) to tell the CopyingInputStreamAdaptor to
+                // delete the underlying CopyingInputStream when it is destroyed.
+                void SetOwnsCopyingStream(bool value)
+                {
+                    owns_copying_stream_ = value;
+                }
+
+                // implements ZeroCopyInputStream ----------------------------------
+                bool Next(const void** data, int* size) override;
+                void BackUp(int count) override;
+                bool Skip(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                // Insures that buffer_ is not NULL.
+                void AllocateBufferIfNeeded();
+                // Frees the buffer and resets buffer_used_.
+                void FreeBuffer();
+
+                // The underlying copying stream.
+                CopyingInputStream* copying_stream_;
+                bool owns_copying_stream_;
+
+                // True if we have seen a permanent error from the underlying stream.
+                bool failed_;
+
+                // The current position of copying_stream_, relative to the point where
+                // we started reading.
+                int64_t position_;
+
+                // Data is read into this buffer.  It may be NULL if no buffer is currently
+                // in use.  Otherwise, it points to an array of size buffer_size_.
+                std::unique_ptr<uint8_t[]> buffer_;
+                const int buffer_size_;
+
+                // Number of valid bytes currently in the buffer (i.e. the size last
+                // returned by Next()).  0 <= buffer_used_ <= buffer_size_.
+                int buffer_used_;
+
+                // Number of bytes in the buffer which were backed up over by a call to
+                // BackUp().  These need to be returned again.
+                // 0 <= backup_bytes_ <= buffer_used_
+                int backup_bytes_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingInputStreamAdaptor);
+            };
+
+            // ===================================================================
+
+            // A generic traditional output stream interface.
+            //
+            // Lots of traditional output streams (e.g. file descriptors, C stdio
+            // streams, and C++ iostreams) expose an interface where every write
+            // involves copying bytes from a buffer.  If you want to take such an
+            // interface and make a ZeroCopyOutputStream based on it, simply implement
+            // CopyingOutputStream and then use CopyingOutputStreamAdaptor.
+            //
+            // CopyingOutputStream implementations should avoid buffering if possible.
+            // CopyingOutputStreamAdaptor does its own buffering and will write data
+            // in large blocks.
+            class PROTOBUF_EXPORT CopyingOutputStream
+            {
+            public:
+                virtual ~CopyingOutputStream()
+                {
+                }
+
+                // Writes "size" bytes from the given buffer to the output.  Returns true
+                // if successful, false on a write error.
+                virtual bool Write(const void* buffer, int size) = 0;
+            };
+
+            // A ZeroCopyOutputStream which writes to a CopyingOutputStream.  This is
+            // useful for implementing ZeroCopyOutputStreams that write to traditional
+            // streams.  Note that this class is not really zero-copy.
+            //
+            // If you want to write to file descriptors or C++ ostreams, this is
+            // already implemented for you:  use FileOutputStream or OstreamOutputStream
+            // respectively.
+            class PROTOBUF_EXPORT CopyingOutputStreamAdaptor : public ZeroCopyOutputStream
+            {
+            public:
+                // Creates a stream that writes to the given Unix file descriptor.
+                // If a block_size is given, it specifies the size of the buffers
+                // that should be returned by Next().  Otherwise, a reasonable default
+                // is used.
+                explicit CopyingOutputStreamAdaptor(CopyingOutputStream* copying_stream, int block_size = -1);
+                ~CopyingOutputStreamAdaptor() override;
+
+                // Writes all pending data to the underlying stream.  Returns false if a
+                // write error occurred on the underlying stream.  (The underlying
+                // stream itself is not necessarily flushed.)
+                bool Flush();
+
+                // Call SetOwnsCopyingStream(true) to tell the CopyingOutputStreamAdaptor to
+                // delete the underlying CopyingOutputStream when it is destroyed.
+                void SetOwnsCopyingStream(bool value)
+                {
+                    owns_copying_stream_ = value;
+                }
+
+                // implements ZeroCopyOutputStream ---------------------------------
+                bool Next(void** data, int* size) override;
+                void BackUp(int count) override;
+                int64_t ByteCount() const override;
+                bool WriteAliasedRaw(const void* data, int size) override;
+                bool AllowsAliasing() const override
+                {
+                    return true;
+                }
+
+            private:
+                // Write the current buffer, if it is present.
+                bool WriteBuffer();
+                // Insures that buffer_ is not NULL.
+                void AllocateBufferIfNeeded();
+                // Frees the buffer.
+                void FreeBuffer();
+
+                // The underlying copying stream.
+                CopyingOutputStream* copying_stream_;
+                bool owns_copying_stream_;
+
+                // True if we have seen a permanent error from the underlying stream.
+                bool failed_;
+
+                // The current position of copying_stream_, relative to the point where
+                // we started writing.
+                int64_t position_;
+
+                // Data is written from this buffer.  It may be NULL if no buffer is
+                // currently in use.  Otherwise, it points to an array of size buffer_size_.
+                std::unique_ptr<uint8_t[]> buffer_;
+                const int buffer_size_;
+
+                // Number of valid bytes currently in the buffer (i.e. the size last
+                // returned by Next()).  When BackUp() is called, we just reduce this.
+                // 0 <= buffer_used_ <= buffer_size_.
+                int buffer_used_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingOutputStreamAdaptor);
+            };
+
+            // ===================================================================
+
+            // A ZeroCopyInputStream which wraps some other stream and limits it to
+            // a particular byte count.
+            class PROTOBUF_EXPORT LimitingInputStream PROTOBUF_FUTURE_FINAL : public ZeroCopyInputStream
+            {
+            public:
+                LimitingInputStream(ZeroCopyInputStream* input, int64_t limit);
+                ~LimitingInputStream() override;
+
+                // implements ZeroCopyInputStream ----------------------------------
+                bool Next(const void** data, int* size) override;
+                void BackUp(int count) override;
+                bool Skip(int count) override;
+                int64_t ByteCount() const override;
+
+            private:
+                ZeroCopyInputStream* input_;
+                int64_t limit_;             // Decreases as we go, becomes negative if we overshoot.
+                int64_t prior_bytes_read_;  // Bytes read on underlying stream at construction
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LimitingInputStream);
+            };
+
+            // ===================================================================
+
+            // mutable_string_data() and as_string_data() are workarounds to improve
+            // the performance of writing new data to an existing string.  Unfortunately
+            // the methods provided by the string class are suboptimal, and using memcpy()
+            // is mildly annoying because it requires its pointer args to be non-NULL even
+            // if we ask it to copy 0 bytes.  Furthermore, string_as_array() has the
+            // property that it always returns NULL if its arg is the empty string, exactly
+            // what we want to avoid if we're using it in conjunction with memcpy()!
+            // With C++11, the desired memcpy() boils down to memcpy(..., &(*s)[0], size),
+            // where s is a string*.  Without C++11, &(*s)[0] is not guaranteed to be safe,
+            // so we use string_as_array(), and live with the extra logic that tests whether
+            // *s is empty.
+
+            // Return a pointer to mutable characters underlying the given string.  The
+            // return value is valid until the next time the string is resized.  We
+            // trust the caller to treat the return value as an array of length s->size().
+            inline char* mutable_string_data(std::string* s)
+            {
+                // This should be simpler & faster than string_as_array() because the latter
+                // is guaranteed to return NULL when *s is empty, so it has to check for that.
+                return &(*s)[0];
+            }
+
+            // as_string_data(s) is equivalent to
+            //  ({ char* p = mutable_string_data(s); make_pair(p, p != NULL); })
+            // Sometimes it's faster: in some scenarios p cannot be NULL, and then the
+            // code can avoid that check.
+            inline std::pair<char*, bool> as_string_data(std::string* s)
+            {
+                char* p = mutable_string_data(s);
+                return std::make_pair(p, true);
+            }
+
+        }  // namespace io
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map.h b/CAPI/cpp/grpc/include/google/protobuf/map.h
index 008c192..6d353e9 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/map.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/map.h
@@ -37,7 +37,6 @@
 #ifndef GOOGLE_PROTOBUF_MAP_H__
 #define GOOGLE_PROTOBUF_MAP_H__
 
-
 #include <functional>
 #include <initializer_list>
 #include <iterator>
@@ -69,1378 +68,1752 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-template <typename Key, typename T>
-class Map;
-
-class MapIterator;
-
-template <typename Enum>
-struct is_proto_enum;
-
-namespace internal {
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType key_wire_type,
-          WireFormatLite::FieldType value_wire_type>
-class MapFieldLite;
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType key_wire_type,
-          WireFormatLite::FieldType value_wire_type>
-class MapField;
-
-template <typename Key, typename T>
-class TypeDefinedMapFieldBase;
-
-class DynamicMapField;
-
-class GeneratedMessageReflection;
-
-// re-implement std::allocator to use arena allocator for memory allocation.
-// Used for Map implementation. Users should not use this class
-// directly.
-template <typename U>
-class MapAllocator {
- public:
-  using value_type = U;
-  using pointer = value_type*;
-  using const_pointer = const value_type*;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-
-  constexpr MapAllocator() : arena_(nullptr) {}
-  explicit constexpr MapAllocator(Arena* arena) : arena_(arena) {}
-  template <typename X>
-  MapAllocator(const MapAllocator<X>& allocator)  // NOLINT(runtime/explicit)
-      : arena_(allocator.arena()) {}
-
-  // MapAllocator does not support alignments beyond 8. Technically we should
-  // support up to std::max_align_t, but this fails with ubsan and tcmalloc
-  // debug allocation logic which assume 8 as default alignment.
-  static_assert(alignof(value_type) <= 8, "");
-
-  pointer allocate(size_type n, const void* /* hint */ = nullptr) {
-    // If arena is not given, malloc needs to be called which doesn't
-    // construct element object.
-    if (arena_ == nullptr) {
-      return static_cast<pointer>(::operator new(n * sizeof(value_type)));
-    } else {
-      return reinterpret_cast<pointer>(
-          Arena::CreateArray<uint8_t>(arena_, n * sizeof(value_type)));
-    }
-  }
-
-  void deallocate(pointer p, size_type n) {
-    if (arena_ == nullptr) {
-      internal::SizedDelete(p, n * sizeof(value_type));
-    }
-  }
+namespace google
+{
+    namespace protobuf
+    {
+
+        template<typename Key, typename T>
+        class Map;
+
+        class MapIterator;
+
+        template<typename Enum>
+        struct is_proto_enum;
+
+        namespace internal
+        {
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
+            class MapFieldLite;
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
+            class MapField;
+
+            template<typename Key, typename T>
+            class TypeDefinedMapFieldBase;
+
+            class DynamicMapField;
+
+            class GeneratedMessageReflection;
+
+            // re-implement std::allocator to use arena allocator for memory allocation.
+            // Used for Map implementation. Users should not use this class
+            // directly.
+            template<typename U>
+            class MapAllocator
+            {
+            public:
+                using value_type = U;
+                using pointer = value_type*;
+                using const_pointer = const value_type*;
+                using reference = value_type&;
+                using const_reference = const value_type&;
+                using size_type = size_t;
+                using difference_type = ptrdiff_t;
+
+                constexpr MapAllocator() :
+                    arena_(nullptr)
+                {
+                }
+                explicit constexpr MapAllocator(Arena* arena) :
+                    arena_(arena)
+                {
+                }
+                template<typename X>
+                MapAllocator(const MapAllocator<X>& allocator)  // NOLINT(runtime/explicit)
+                    :
+                    arena_(allocator.arena())
+                {
+                }
+
+                // MapAllocator does not support alignments beyond 8. Technically we should
+                // support up to std::max_align_t, but this fails with ubsan and tcmalloc
+                // debug allocation logic which assume 8 as default alignment.
+                static_assert(alignof(value_type) <= 8, "");
+
+                pointer allocate(size_type n, const void* /* hint */ = nullptr)
+                {
+                    // If arena is not given, malloc needs to be called which doesn't
+                    // construct element object.
+                    if (arena_ == nullptr)
+                    {
+                        return static_cast<pointer>(::operator new(n * sizeof(value_type)));
+                    }
+                    else
+                    {
+                        return reinterpret_cast<pointer>(
+                            Arena::CreateArray<uint8_t>(arena_, n * sizeof(value_type))
+                        );
+                    }
+                }
+
+                void deallocate(pointer p, size_type n)
+                {
+                    if (arena_ == nullptr)
+                    {
+                        internal::SizedDelete(p, n * sizeof(value_type));
+                    }
+                }
 
 #if !defined(GOOGLE_PROTOBUF_OS_APPLE) && !defined(GOOGLE_PROTOBUF_OS_NACL) && \
     !defined(GOOGLE_PROTOBUF_OS_EMSCRIPTEN)
-  template <class NodeType, class... Args>
-  void construct(NodeType* p, Args&&... args) {
-    // Clang 3.6 doesn't compile static casting to void* directly. (Issue
-    // #1266) According C++ standard 5.2.9/1: "The static_cast operator shall
-    // not cast away constness". So first the maybe const pointer is casted to
-    // const void* and after the const void* is const casted.
-    new (const_cast<void*>(static_cast<const void*>(p)))
-        NodeType(std::forward<Args>(args)...);
-  }
-
-  template <class NodeType>
-  void destroy(NodeType* p) {
-    p->~NodeType();
-  }
+                template<class NodeType, class... Args>
+                void construct(NodeType* p, Args&&... args)
+                {
+                    // Clang 3.6 doesn't compile static casting to void* directly. (Issue
+                    // #1266) According C++ standard 5.2.9/1: "The static_cast operator shall
+                    // not cast away constness". So first the maybe const pointer is casted to
+                    // const void* and after the const void* is const casted.
+                    new (const_cast<void*>(static_cast<const void*>(p)))
+                        NodeType(std::forward<Args>(args)...);
+                }
+
+                template<class NodeType>
+                void destroy(NodeType* p)
+                {
+                    p->~NodeType();
+                }
 #else
-  void construct(pointer p, const_reference t) { new (p) value_type(t); }
-
-  void destroy(pointer p) { p->~value_type(); }
+                void construct(pointer p, const_reference t)
+                {
+                    new (p) value_type(t);
+                }
+
+                void destroy(pointer p)
+                {
+                    p->~value_type();
+                }
 #endif
 
-  template <typename X>
-  struct rebind {
-    using other = MapAllocator<X>;
-  };
-
-  template <typename X>
-  bool operator==(const MapAllocator<X>& other) const {
-    return arena_ == other.arena_;
-  }
-
-  template <typename X>
-  bool operator!=(const MapAllocator<X>& other) const {
-    return arena_ != other.arena_;
-  }
-
-  // To support Visual Studio 2008
-  size_type max_size() const {
-    // parentheses around (std::...:max) prevents macro warning of max()
-    return (std::numeric_limits<size_type>::max)();
-  }
-
-  // To support gcc-4.4, which does not properly
-  // support templated friend classes
-  Arena* arena() const { return arena_; }
-
- private:
-  using DestructorSkippable_ = void;
-  Arena* arena_;
-};
-
-template <typename T>
-using KeyForTree =
-    typename std::conditional<std::is_scalar<T>::value, T,
-                              std::reference_wrapper<const T>>::type;
-
-// Default case: Not transparent.
-// We use std::hash<key_type>/std::less<key_type> and all the lookup functions
-// only accept `key_type`.
-template <typename key_type>
-struct TransparentSupport {
-  using hash = std::hash<key_type>;
-  using less = std::less<key_type>;
-
-  static bool Equals(const key_type& a, const key_type& b) { return a == b; }
-
-  template <typename K>
-  using key_arg = key_type;
-};
+                template<typename X>
+                struct rebind
+                {
+                    using other = MapAllocator<X>;
+                };
+
+                template<typename X>
+                bool operator==(const MapAllocator<X>& other) const
+                {
+                    return arena_ == other.arena_;
+                }
+
+                template<typename X>
+                bool operator!=(const MapAllocator<X>& other) const
+                {
+                    return arena_ != other.arena_;
+                }
+
+                // To support Visual Studio 2008
+                size_type max_size() const
+                {
+                    // parentheses around (std::...:max) prevents macro warning of max()
+                    return (std::numeric_limits<size_type>::max)();
+                }
+
+                // To support gcc-4.4, which does not properly
+                // support templated friend classes
+                Arena* arena() const
+                {
+                    return arena_;
+                }
+
+            private:
+                using DestructorSkippable_ = void;
+                Arena* arena_;
+            };
+
+            template<typename T>
+            using KeyForTree =
+                typename std::conditional<std::is_scalar<T>::value, T, std::reference_wrapper<const T>>::type;
+
+            // Default case: Not transparent.
+            // We use std::hash<key_type>/std::less<key_type> and all the lookup functions
+            // only accept `key_type`.
+            template<typename key_type>
+            struct TransparentSupport
+            {
+                using hash = std::hash<key_type>;
+                using less = std::less<key_type>;
+
+                static bool Equals(const key_type& a, const key_type& b)
+                {
+                    return a == b;
+                }
+
+                template<typename K>
+                using key_arg = key_type;
+            };
 
 #if defined(__cpp_lib_string_view)
-// If std::string_view is available, we add transparent support for std::string
-// keys. We use std::hash<std::string_view> as it supports the input types we
-// care about. The lookup functions accept arbitrary `K`. This will include any
-// key type that is convertible to std::string_view.
-template <>
-struct TransparentSupport<std::string> {
-  static std::string_view ImplicitConvert(std::string_view str) { return str; }
-  // If the element is not convertible to std::string_view, try to convert to
-  // std::string first.
-  // The template makes this overload lose resolution when both have the same
-  // rank otherwise.
-  template <typename = void>
-  static std::string_view ImplicitConvert(const std::string& str) {
-    return str;
-  }
-
-  struct hash : private std::hash<std::string_view> {
-    using is_transparent = void;
-
-    template <typename T>
-    size_t operator()(const T& str) const {
-      return base()(ImplicitConvert(str));
-    }
-
-   private:
-    const std::hash<std::string_view>& base() const { return *this; }
-  };
-  struct less {
-    using is_transparent = void;
-
-    template <typename T, typename U>
-    bool operator()(const T& t, const U& u) const {
-      return ImplicitConvert(t) < ImplicitConvert(u);
-    }
-  };
-
-  template <typename T, typename U>
-  static bool Equals(const T& t, const U& u) {
-    return ImplicitConvert(t) == ImplicitConvert(u);
-  }
-
-  template <typename K>
-  using key_arg = K;
-};
+            // If std::string_view is available, we add transparent support for std::string
+            // keys. We use std::hash<std::string_view> as it supports the input types we
+            // care about. The lookup functions accept arbitrary `K`. This will include any
+            // key type that is convertible to std::string_view.
+            template<>
+            struct TransparentSupport<std::string>
+            {
+                static std::string_view ImplicitConvert(std::string_view str)
+                {
+                    return str;
+                }
+                // If the element is not convertible to std::string_view, try to convert to
+                // std::string first.
+                // The template makes this overload lose resolution when both have the same
+                // rank otherwise.
+                template<typename = void>
+                static std::string_view ImplicitConvert(const std::string& str)
+                {
+                    return str;
+                }
+
+                struct hash : private std::hash<std::string_view>
+                {
+                    using is_transparent = void;
+
+                    template<typename T>
+                    size_t operator()(const T& str) const
+                    {
+                        return base()(ImplicitConvert(str));
+                    }
+
+                private:
+                    const std::hash<std::string_view>& base() const
+                    {
+                        return *this;
+                    }
+                };
+                struct less
+                {
+                    using is_transparent = void;
+
+                    template<typename T, typename U>
+                    bool operator()(const T& t, const U& u) const
+                    {
+                        return ImplicitConvert(t) < ImplicitConvert(u);
+                    }
+                };
+
+                template<typename T, typename U>
+                static bool Equals(const T& t, const U& u)
+                {
+                    return ImplicitConvert(t) == ImplicitConvert(u);
+                }
+
+                template<typename K>
+                using key_arg = K;
+            };
 #endif  // defined(__cpp_lib_string_view)
 
-template <typename Key>
-using TreeForMap =
-    std::map<KeyForTree<Key>, void*, typename TransparentSupport<Key>::less,
-             MapAllocator<std::pair<const KeyForTree<Key>, void*>>>;
-
-inline bool TableEntryIsEmpty(void* const* table, size_t b) {
-  return table[b] == nullptr;
-}
-inline bool TableEntryIsNonEmptyList(void* const* table, size_t b) {
-  return table[b] != nullptr && table[b] != table[b ^ 1];
-}
-inline bool TableEntryIsTree(void* const* table, size_t b) {
-  return !TableEntryIsEmpty(table, b) && !TableEntryIsNonEmptyList(table, b);
-}
-inline bool TableEntryIsList(void* const* table, size_t b) {
-  return !TableEntryIsTree(table, b);
-}
-
-// This captures all numeric types.
-inline size_t MapValueSpaceUsedExcludingSelfLong(bool) { return 0; }
-inline size_t MapValueSpaceUsedExcludingSelfLong(const std::string& str) {
-  return StringSpaceUsedExcludingSelfLong(str);
-}
-template <typename T,
-          typename = decltype(std::declval<const T&>().SpaceUsedLong())>
-size_t MapValueSpaceUsedExcludingSelfLong(const T& message) {
-  return message.SpaceUsedLong() - sizeof(T);
-}
-
-constexpr size_t kGlobalEmptyTableSize = 1;
-PROTOBUF_EXPORT extern void* const kGlobalEmptyTable[kGlobalEmptyTableSize];
-
-// Space used for the table, trees, and nodes.
-// Does not include the indirect space used. Eg the data of a std::string.
-template <typename Key>
-PROTOBUF_NOINLINE size_t SpaceUsedInTable(void** table, size_t num_buckets,
-                                          size_t num_elements,
-                                          size_t sizeof_node) {
-  size_t size = 0;
-  // The size of the table.
-  size += sizeof(void*) * num_buckets;
-  // All the nodes.
-  size += sizeof_node * num_elements;
-  // For each tree, count the overhead of the those nodes.
-  // Two buckets at a time because we only care about trees.
-  for (size_t b = 0; b < num_buckets; b += 2) {
-    if (internal::TableEntryIsTree(table, b)) {
-      using Tree = TreeForMap<Key>;
-      Tree* tree = static_cast<Tree*>(table[b]);
-      // Estimated cost of the red-black tree nodes, 3 pointers plus a
-      // bool (plus alignment, so 4 pointers).
-      size += tree->size() *
-              (sizeof(typename Tree::value_type) + sizeof(void*) * 4);
-    }
-  }
-  return size;
-}
-
-template <typename Map,
-          typename = typename std::enable_if<
-              !std::is_scalar<typename Map::key_type>::value ||
-              !std::is_scalar<typename Map::mapped_type>::value>::type>
-size_t SpaceUsedInValues(const Map* map) {
-  size_t size = 0;
-  for (const auto& v : *map) {
-    size += internal::MapValueSpaceUsedExcludingSelfLong(v.first) +
-            internal::MapValueSpaceUsedExcludingSelfLong(v.second);
-  }
-  return size;
-}
-
-inline size_t SpaceUsedInValues(const void*) { return 0; }
-
-}  // namespace internal
-
-// This is the class for Map's internal value_type. Instead of using
-// std::pair as value_type, we use this class which provides us more control of
-// its process of construction and destruction.
-template <typename Key, typename T>
-struct PROTOBUF_ATTRIBUTE_STANDALONE_DEBUG MapPair {
-  using first_type = const Key;
-  using second_type = T;
-
-  MapPair(const Key& other_first, const T& other_second)
-      : first(other_first), second(other_second) {}
-  explicit MapPair(const Key& other_first) : first(other_first), second() {}
-  explicit MapPair(Key&& other_first)
-      : first(std::move(other_first)), second() {}
-  MapPair(const MapPair& other) : first(other.first), second(other.second) {}
-
-  ~MapPair() {}
-
-  // Implicitly convertible to std::pair of compatible types.
-  template <typename T1, typename T2>
-  operator std::pair<T1, T2>() const {  // NOLINT(runtime/explicit)
-    return std::pair<T1, T2>(first, second);
-  }
-
-  const Key first;
-  T second;
-
- private:
-  friend class Arena;
-  friend class Map<Key, T>;
-};
-
-// Map is an associative container type used to store protobuf map
-// fields.  Each Map instance may or may not use a different hash function, a
-// different iteration order, and so on.  E.g., please don't examine
-// implementation details to decide if the following would work:
-//  Map<int, int> m0, m1;
-//  m0[0] = m1[0] = m0[1] = m1[1] = 0;
-//  assert(m0.begin()->first == m1.begin()->first);  // Bug!
-//
-// Map's interface is similar to std::unordered_map, except that Map is not
-// designed to play well with exceptions.
-template <typename Key, typename T>
-class Map {
- public:
-  using key_type = Key;
-  using mapped_type = T;
-  using value_type = MapPair<Key, T>;
-
-  using pointer = value_type*;
-  using const_pointer = const value_type*;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-
-  using size_type = size_t;
-  using hasher = typename internal::TransparentSupport<Key>::hash;
-
-  constexpr Map() : elements_(nullptr) {}
-  explicit Map(Arena* arena) : elements_(arena) {}
-
-  Map(const Map& other) : Map() { insert(other.begin(), other.end()); }
-
-  Map(Map&& other) noexcept : Map() {
-    if (other.arena() != nullptr) {
-      *this = other;
-    } else {
-      swap(other);
-    }
-  }
-
-  Map& operator=(Map&& other) noexcept {
-    if (this != &other) {
-      if (arena() != other.arena()) {
-        *this = other;
-      } else {
-        swap(other);
-      }
-    }
-    return *this;
-  }
-
-  template <class InputIt>
-  Map(const InputIt& first, const InputIt& last) : Map() {
-    insert(first, last);
-  }
-
-  ~Map() {}
-
- private:
-  using Allocator = internal::MapAllocator<void*>;
-
-  // InnerMap is a generic hash-based map.  It doesn't contain any
-  // protocol-buffer-specific logic.  It is a chaining hash map with the
-  // additional feature that some buckets can be converted to use an ordered
-  // container.  This ensures O(lg n) bounds on find, insert, and erase, while
-  // avoiding the overheads of ordered containers most of the time.
-  //
-  // The implementation doesn't need the full generality of unordered_map,
-  // and it doesn't have it.  More bells and whistles can be added as needed.
-  // Some implementation details:
-  // 1. The hash function has type hasher and the equality function
-  //    equal_to<Key>.  We inherit from hasher to save space
-  //    (empty-base-class optimization).
-  // 2. The number of buckets is a power of two.
-  // 3. Buckets are converted to trees in pairs: if we convert bucket b then
-  //    buckets b and b^1 will share a tree.  Invariant: buckets b and b^1 have
-  //    the same non-null value iff they are sharing a tree.  (An alternative
-  //    implementation strategy would be to have a tag bit per bucket.)
-  // 4. As is typical for hash_map and such, the Keys and Values are always
-  //    stored in linked list nodes.  Pointers to elements are never invalidated
-  //    until the element is deleted.
-  // 5. The trees' payload type is pointer to linked-list node.  Tree-converting
-  //    a bucket doesn't copy Key-Value pairs.
-  // 6. Once we've tree-converted a bucket, it is never converted back. However,
-  //    the items a tree contains may wind up assigned to trees or lists upon a
-  //    rehash.
-  // 7. The code requires no C++ features from C++14 or later.
-  // 8. Mutations to a map do not invalidate the map's iterators, pointers to
-  //    elements, or references to elements.
-  // 9. Except for erase(iterator), any non-const method can reorder iterators.
-  // 10. InnerMap uses KeyForTree<Key> when using the Tree representation, which
-  //    is either `Key`, if Key is a scalar, or `reference_wrapper<const Key>`
-  //    otherwise. This avoids unnecessary copies of string keys, for example.
-  class InnerMap : private hasher {
-   public:
-    explicit constexpr InnerMap(Arena* arena)
-        : hasher(),
-          num_elements_(0),
-          num_buckets_(internal::kGlobalEmptyTableSize),
-          seed_(0),
-          index_of_first_non_null_(internal::kGlobalEmptyTableSize),
-          table_(const_cast<void**>(internal::kGlobalEmptyTable)),
-          alloc_(arena) {}
-
-    ~InnerMap() {
-      if (alloc_.arena() == nullptr &&
-          num_buckets_ != internal::kGlobalEmptyTableSize) {
-        clear();
-        Dealloc<void*>(table_, num_buckets_);
-      }
-    }
-
-   private:
-    enum { kMinTableSize = 8 };
-
-    // Linked-list nodes, as one would expect for a chaining hash table.
-    struct Node {
-      value_type kv;
-      Node* next;
-    };
-
-    // Trees. The payload type is a copy of Key, so that we can query the tree
-    // with Keys that are not in any particular data structure.
-    // The value is a void* pointing to Node. We use void* instead of Node* to
-    // avoid code bloat. That way there is only one instantiation of the tree
-    // class per key type.
-    using Tree = internal::TreeForMap<Key>;
-    using TreeIterator = typename Tree::iterator;
-
-    static Node* NodeFromTreeIterator(TreeIterator it) {
-      return static_cast<Node*>(it->second);
-    }
-
-    // iterator and const_iterator are instantiations of iterator_base.
-    template <typename KeyValueType>
-    class iterator_base {
-     public:
-      using reference = KeyValueType&;
-      using pointer = KeyValueType*;
-
-      // Invariants:
-      // node_ is always correct. This is handy because the most common
-      // operations are operator* and operator-> and they only use node_.
-      // When node_ is set to a non-null value, all the other non-const fields
-      // are updated to be correct also, but those fields can become stale
-      // if the underlying map is modified.  When those fields are needed they
-      // are rechecked, and updated if necessary.
-      iterator_base() : node_(nullptr), m_(nullptr), bucket_index_(0) {}
-
-      explicit iterator_base(const InnerMap* m) : m_(m) {
-        SearchFrom(m->index_of_first_non_null_);
-      }
-
-      // Any iterator_base can convert to any other.  This is overkill, and we
-      // rely on the enclosing class to use it wisely.  The standard "iterator
-      // can convert to const_iterator" is OK but the reverse direction is not.
-      template <typename U>
-      explicit iterator_base(const iterator_base<U>& it)
-          : node_(it.node_), m_(it.m_), bucket_index_(it.bucket_index_) {}
-
-      iterator_base(Node* n, const InnerMap* m, size_type index)
-          : node_(n), m_(m), bucket_index_(index) {}
-
-      iterator_base(TreeIterator tree_it, const InnerMap* m, size_type index)
-          : node_(NodeFromTreeIterator(tree_it)), m_(m), bucket_index_(index) {
-        // Invariant: iterators that use buckets with trees have an even
-        // bucket_index_.
-        GOOGLE_DCHECK_EQ(bucket_index_ % 2, 0u);
-      }
-
-      // Advance through buckets, looking for the first that isn't empty.
-      // If nothing non-empty is found then leave node_ == nullptr.
-      void SearchFrom(size_type start_bucket) {
-        GOOGLE_DCHECK(m_->index_of_first_non_null_ == m_->num_buckets_ ||
-               m_->table_[m_->index_of_first_non_null_] != nullptr);
-        node_ = nullptr;
-        for (bucket_index_ = start_bucket; bucket_index_ < m_->num_buckets_;
-             bucket_index_++) {
-          if (m_->TableEntryIsNonEmptyList(bucket_index_)) {
-            node_ = static_cast<Node*>(m_->table_[bucket_index_]);
-            break;
-          } else if (m_->TableEntryIsTree(bucket_index_)) {
-            Tree* tree = static_cast<Tree*>(m_->table_[bucket_index_]);
-            GOOGLE_DCHECK(!tree->empty());
-            node_ = NodeFromTreeIterator(tree->begin());
-            break;
-          }
-        }
-      }
-
-      reference operator*() const { return node_->kv; }
-      pointer operator->() const { return &(operator*()); }
-
-      friend bool operator==(const iterator_base& a, const iterator_base& b) {
-        return a.node_ == b.node_;
-      }
-      friend bool operator!=(const iterator_base& a, const iterator_base& b) {
-        return a.node_ != b.node_;
-      }
-
-      iterator_base& operator++() {
-        if (node_->next == nullptr) {
-          TreeIterator tree_it;
-          const bool is_list = revalidate_if_necessary(&tree_it);
-          if (is_list) {
-            SearchFrom(bucket_index_ + 1);
-          } else {
-            GOOGLE_DCHECK_EQ(bucket_index_ & 1, 0u);
-            Tree* tree = static_cast<Tree*>(m_->table_[bucket_index_]);
-            if (++tree_it == tree->end()) {
-              SearchFrom(bucket_index_ + 2);
-            } else {
-              node_ = NodeFromTreeIterator(tree_it);
+            template<typename Key>
+            using TreeForMap =
+                std::map<KeyForTree<Key>, void*, typename TransparentSupport<Key>::less, MapAllocator<std::pair<const KeyForTree<Key>, void*>>>;
+
+            inline bool TableEntryIsEmpty(void* const* table, size_t b)
+            {
+                return table[b] == nullptr;
+            }
+            inline bool TableEntryIsNonEmptyList(void* const* table, size_t b)
+            {
+                return table[b] != nullptr && table[b] != table[b ^ 1];
+            }
+            inline bool TableEntryIsTree(void* const* table, size_t b)
+            {
+                return !TableEntryIsEmpty(table, b) && !TableEntryIsNonEmptyList(table, b);
+            }
+            inline bool TableEntryIsList(void* const* table, size_t b)
+            {
+                return !TableEntryIsTree(table, b);
+            }
+
+            // This captures all numeric types.
+            inline size_t MapValueSpaceUsedExcludingSelfLong(bool)
+            {
+                return 0;
+            }
+            inline size_t MapValueSpaceUsedExcludingSelfLong(const std::string& str)
+            {
+                return StringSpaceUsedExcludingSelfLong(str);
+            }
+            template<typename T, typename = decltype(std::declval<const T&>().SpaceUsedLong())>
+            size_t MapValueSpaceUsedExcludingSelfLong(const T& message)
+            {
+                return message.SpaceUsedLong() - sizeof(T);
+            }
+
+            constexpr size_t kGlobalEmptyTableSize = 1;
+            PROTOBUF_EXPORT extern void* const kGlobalEmptyTable[kGlobalEmptyTableSize];
+
+            // Space used for the table, trees, and nodes.
+            // Does not include the indirect space used. Eg the data of a std::string.
+            template<typename Key>
+            PROTOBUF_NOINLINE size_t SpaceUsedInTable(void** table, size_t num_buckets, size_t num_elements, size_t sizeof_node)
+            {
+                size_t size = 0;
+                // The size of the table.
+                size += sizeof(void*) * num_buckets;
+                // All the nodes.
+                size += sizeof_node * num_elements;
+                // For each tree, count the overhead of the those nodes.
+                // Two buckets at a time because we only care about trees.
+                for (size_t b = 0; b < num_buckets; b += 2)
+                {
+                    if (internal::TableEntryIsTree(table, b))
+                    {
+                        using Tree = TreeForMap<Key>;
+                        Tree* tree = static_cast<Tree*>(table[b]);
+                        // Estimated cost of the red-black tree nodes, 3 pointers plus a
+                        // bool (plus alignment, so 4 pointers).
+                        size += tree->size() *
+                                (sizeof(typename Tree::value_type) + sizeof(void*) * 4);
+                    }
+                }
+                return size;
+            }
+
+            template<typename Map, typename = typename std::enable_if<!std::is_scalar<typename Map::key_type>::value || !std::is_scalar<typename Map::mapped_type>::value>::type>
+            size_t SpaceUsedInValues(const Map* map)
+            {
+                size_t size = 0;
+                for (const auto& v : *map)
+                {
+                    size += internal::MapValueSpaceUsedExcludingSelfLong(v.first) +
+                            internal::MapValueSpaceUsedExcludingSelfLong(v.second);
+                }
+                return size;
+            }
+
+            inline size_t SpaceUsedInValues(const void*)
+            {
+                return 0;
+            }
+
+        }  // namespace internal
+
+        // This is the class for Map's internal value_type. Instead of using
+        // std::pair as value_type, we use this class which provides us more control of
+        // its process of construction and destruction.
+        template<typename Key, typename T>
+        struct PROTOBUF_ATTRIBUTE_STANDALONE_DEBUG MapPair
+        {
+            using first_type = const Key;
+            using second_type = T;
+
+            MapPair(const Key& other_first, const T& other_second) :
+                first(other_first),
+                second(other_second)
+            {
+            }
+            explicit MapPair(const Key& other_first) :
+                first(other_first),
+                second()
+            {
+            }
+            explicit MapPair(Key&& other_first) :
+                first(std::move(other_first)),
+                second()
+            {
+            }
+            MapPair(const MapPair& other) :
+                first(other.first),
+                second(other.second)
+            {
+            }
+
+            ~MapPair()
+            {
+            }
+
+            // Implicitly convertible to std::pair of compatible types.
+            template<typename T1, typename T2>
+            operator std::pair<T1, T2>() const
+            {  // NOLINT(runtime/explicit)
+                return std::pair<T1, T2>(first, second);
+            }
+
+            const Key first;
+            T second;
+
+        private:
+            friend class Arena;
+            friend class Map<Key, T>;
+        };
+
+        // Map is an associative container type used to store protobuf map
+        // fields.  Each Map instance may or may not use a different hash function, a
+        // different iteration order, and so on.  E.g., please don't examine
+        // implementation details to decide if the following would work:
+        //  Map<int, int> m0, m1;
+        //  m0[0] = m1[0] = m0[1] = m1[1] = 0;
+        //  assert(m0.begin()->first == m1.begin()->first);  // Bug!
+        //
+        // Map's interface is similar to std::unordered_map, except that Map is not
+        // designed to play well with exceptions.
+        template<typename Key, typename T>
+        class Map
+        {
+        public:
+            using key_type = Key;
+            using mapped_type = T;
+            using value_type = MapPair<Key, T>;
+
+            using pointer = value_type*;
+            using const_pointer = const value_type*;
+            using reference = value_type&;
+            using const_reference = const value_type&;
+
+            using size_type = size_t;
+            using hasher = typename internal::TransparentSupport<Key>::hash;
+
+            constexpr Map() :
+                elements_(nullptr)
+            {
+            }
+            explicit Map(Arena* arena) :
+                elements_(arena)
+            {
             }
-          }
-        } else {
-          node_ = node_->next;
-        }
-        return *this;
-      }
-
-      iterator_base operator++(int /* unused */) {
-        iterator_base tmp = *this;
-        ++*this;
-        return tmp;
-      }
-
-      // Assumes node_ and m_ are correct and non-null, but other fields may be
-      // stale.  Fix them as needed.  Then return true iff node_ points to a
-      // Node in a list.  If false is returned then *it is modified to be
-      // a valid iterator for node_.
-      bool revalidate_if_necessary(TreeIterator* it) {
-        GOOGLE_DCHECK(node_ != nullptr && m_ != nullptr);
-        // Force bucket_index_ to be in range.
-        bucket_index_ &= (m_->num_buckets_ - 1);
-        // Common case: the bucket we think is relevant points to node_.
-        if (m_->table_[bucket_index_] == static_cast<void*>(node_)) return true;
-        // Less common: the bucket is a linked list with node_ somewhere in it,
-        // but not at the head.
-        if (m_->TableEntryIsNonEmptyList(bucket_index_)) {
-          Node* l = static_cast<Node*>(m_->table_[bucket_index_]);
-          while ((l = l->next) != nullptr) {
-            if (l == node_) {
-              return true;
+
+            Map(const Map& other) :
+                Map()
+            {
+                insert(other.begin(), other.end());
+            }
+
+            Map(Map&& other) noexcept :
+                Map()
+            {
+                if (other.arena() != nullptr)
+                {
+                    *this = other;
+                }
+                else
+                {
+                    swap(other);
+                }
             }
-          }
-        }
-        // Well, bucket_index_ still might be correct, but probably
-        // not.  Revalidate just to be sure.  This case is rare enough that we
-        // don't worry about potential optimizations, such as having a custom
-        // find-like method that compares Node* instead of the key.
-        iterator_base i(m_->find(node_->kv.first, it));
-        bucket_index_ = i.bucket_index_;
-        return m_->TableEntryIsList(bucket_index_);
-      }
-
-      Node* node_;
-      const InnerMap* m_;
-      size_type bucket_index_;
-    };
-
-   public:
-    using iterator = iterator_base<value_type>;
-    using const_iterator = iterator_base<const value_type>;
-
-    Arena* arena() const { return alloc_.arena(); }
-
-    void Swap(InnerMap* other) {
-      std::swap(num_elements_, other->num_elements_);
-      std::swap(num_buckets_, other->num_buckets_);
-      std::swap(seed_, other->seed_);
-      std::swap(index_of_first_non_null_, other->index_of_first_non_null_);
-      std::swap(table_, other->table_);
-      std::swap(alloc_, other->alloc_);
-    }
-
-    iterator begin() { return iterator(this); }
-    iterator end() { return iterator(); }
-    const_iterator begin() const { return const_iterator(this); }
-    const_iterator end() const { return const_iterator(); }
-
-    void clear() {
-      for (size_type b = 0; b < num_buckets_; b++) {
-        if (TableEntryIsNonEmptyList(b)) {
-          Node* node = static_cast<Node*>(table_[b]);
-          table_[b] = nullptr;
-          do {
-            Node* next = node->next;
-            DestroyNode(node);
-            node = next;
-          } while (node != nullptr);
-        } else if (TableEntryIsTree(b)) {
-          Tree* tree = static_cast<Tree*>(table_[b]);
-          GOOGLE_DCHECK(table_[b] == table_[b + 1] && (b & 1) == 0);
-          table_[b] = table_[b + 1] = nullptr;
-          typename Tree::iterator tree_it = tree->begin();
-          do {
-            Node* node = NodeFromTreeIterator(tree_it);
-            typename Tree::iterator next = tree_it;
-            ++next;
-            tree->erase(tree_it);
-            DestroyNode(node);
-            tree_it = next;
-          } while (tree_it != tree->end());
-          DestroyTree(tree);
-          b++;
-        }
-      }
-      num_elements_ = 0;
-      index_of_first_non_null_ = num_buckets_;
-    }
-
-    const hasher& hash_function() const { return *this; }
-
-    static size_type max_size() {
-      return static_cast<size_type>(1) << (sizeof(void**) >= 8 ? 60 : 28);
-    }
-    size_type size() const { return num_elements_; }
-    bool empty() const { return size() == 0; }
-
-    template <typename K>
-    iterator find(const K& k) {
-      return iterator(FindHelper(k).first);
-    }
-
-    template <typename K>
-    const_iterator find(const K& k) const {
-      return FindHelper(k).first;
-    }
-
-    // Inserts a new element into the container if there is no element with the
-    // key in the container.
-    // The new element is:
-    //  (1) Constructed in-place with the given args, if mapped_type is not
-    //      arena constructible.
-    //  (2) Constructed in-place with the arena and then assigned with a
-    //      mapped_type temporary constructed with the given args, otherwise.
-    template <typename K, typename... Args>
-    std::pair<iterator, bool> try_emplace(K&& k, Args&&... args) {
-      return ArenaAwareTryEmplace(Arena::is_arena_constructable<mapped_type>(),
-                                  std::forward<K>(k),
-                                  std::forward<Args>(args)...);
-    }
-
-    // Inserts the key into the map, if not present. In that case, the value
-    // will be value initialized.
-    template <typename K>
-    std::pair<iterator, bool> insert(K&& k) {
-      return try_emplace(std::forward<K>(k));
-    }
-
-    template <typename K>
-    value_type& operator[](K&& k) {
-      return *try_emplace(std::forward<K>(k)).first;
-    }
-
-    void erase(iterator it) {
-      GOOGLE_DCHECK_EQ(it.m_, this);
-      typename Tree::iterator tree_it;
-      const bool is_list = it.revalidate_if_necessary(&tree_it);
-      size_type b = it.bucket_index_;
-      Node* const item = it.node_;
-      if (is_list) {
-        GOOGLE_DCHECK(TableEntryIsNonEmptyList(b));
-        Node* head = static_cast<Node*>(table_[b]);
-        head = EraseFromLinkedList(item, head);
-        table_[b] = static_cast<void*>(head);
-      } else {
-        GOOGLE_DCHECK(TableEntryIsTree(b));
-        Tree* tree = static_cast<Tree*>(table_[b]);
-        tree->erase(tree_it);
-        if (tree->empty()) {
-          // Force b to be the minimum of b and b ^ 1.  This is important
-          // only because we want index_of_first_non_null_ to be correct.
-          b &= ~static_cast<size_type>(1);
-          DestroyTree(tree);
-          table_[b] = table_[b + 1] = nullptr;
-        }
-      }
-      DestroyNode(item);
-      --num_elements_;
-      if (PROTOBUF_PREDICT_FALSE(b == index_of_first_non_null_)) {
-        while (index_of_first_non_null_ < num_buckets_ &&
-               table_[index_of_first_non_null_] == nullptr) {
-          ++index_of_first_non_null_;
-        }
-      }
-    }
-
-    size_t SpaceUsedInternal() const {
-      return internal::SpaceUsedInTable<Key>(table_, num_buckets_,
-                                             num_elements_, sizeof(Node));
-    }
-
-   private:
-    template <typename K, typename... Args>
-    std::pair<iterator, bool> TryEmplaceInternal(K&& k, Args&&... args) {
-      std::pair<const_iterator, size_type> p = FindHelper(k);
-      // Case 1: key was already present.
-      if (p.first.node_ != nullptr)
-        return std::make_pair(iterator(p.first), false);
-      // Case 2: insert.
-      if (ResizeIfLoadIsOutOfRange(num_elements_ + 1)) {
-        p = FindHelper(k);
-      }
-      const size_type b = p.second;  // bucket number
-      // If K is not key_type, make the conversion to key_type explicit.
-      using TypeToInit = typename std::conditional<
-          std::is_same<typename std::decay<K>::type, key_type>::value, K&&,
-          key_type>::type;
-      Node* node = Alloc<Node>(1);
-      // Even when arena is nullptr, CreateInArenaStorage is still used to
-      // ensure the arena of submessage will be consistent. Otherwise,
-      // submessage may have its own arena when message-owned arena is enabled.
-      // Note: This only works if `Key` is not arena constructible.
-      Arena::CreateInArenaStorage(const_cast<Key*>(&node->kv.first),
-                                  alloc_.arena(),
-                                  static_cast<TypeToInit>(std::forward<K>(k)));
-      // Note: if `T` is arena constructible, `Args` needs to be empty.
-      Arena::CreateInArenaStorage(&node->kv.second, alloc_.arena(),
-                                  std::forward<Args>(args)...);
-
-      iterator result = InsertUnique(b, node);
-      ++num_elements_;
-      return std::make_pair(result, true);
-    }
-
-    // A helper function to perform an assignment of `mapped_type`.
-    // If the first argument is true, then it is a regular assignment.
-    // Otherwise, we first create a temporary and then perform an assignment.
-    template <typename V>
-    static void AssignMapped(std::true_type, mapped_type& mapped, V&& v) {
-      mapped = std::forward<V>(v);
-    }
-    template <typename... Args>
-    static void AssignMapped(std::false_type, mapped_type& mapped,
-                             Args&&... args) {
-      mapped = mapped_type(std::forward<Args>(args)...);
-    }
-
-    // Case 1: `mapped_type` is arena constructible. A temporary object is
-    // created and then (if `Args` are not empty) assigned to a mapped value
-    // that was created with the arena.
-    template <typename K>
-    std::pair<iterator, bool> ArenaAwareTryEmplace(std::true_type, K&& k) {
-      // case 1.1: "default" constructed (e.g. from arena only).
-      return TryEmplaceInternal(std::forward<K>(k));
-    }
-    template <typename K, typename... Args>
-    std::pair<iterator, bool> ArenaAwareTryEmplace(std::true_type, K&& k,
-                                                   Args&&... args) {
-      // case 1.2: "default" constructed + copy/move assignment
-      auto p = TryEmplaceInternal(std::forward<K>(k));
-      if (p.second) {
-        AssignMapped(std::is_same<void(typename std::decay<Args>::type...),
-                                  void(mapped_type)>(),
-                     p.first->second, std::forward<Args>(args)...);
-      }
-      return p;
-    }
-    // Case 2: `mapped_type` is not arena constructible. Using in-place
-    // construction.
-    template <typename... Args>
-    std::pair<iterator, bool> ArenaAwareTryEmplace(std::false_type,
-                                                   Args&&... args) {
-      return TryEmplaceInternal(std::forward<Args>(args)...);
-    }
-
-    const_iterator find(const Key& k, TreeIterator* it) const {
-      return FindHelper(k, it).first;
-    }
-    template <typename K>
-    std::pair<const_iterator, size_type> FindHelper(const K& k) const {
-      return FindHelper(k, nullptr);
-    }
-    template <typename K>
-    std::pair<const_iterator, size_type> FindHelper(const K& k,
-                                                    TreeIterator* it) const {
-      size_type b = BucketNumber(k);
-      if (TableEntryIsNonEmptyList(b)) {
-        Node* node = static_cast<Node*>(table_[b]);
-        do {
-          if (internal::TransparentSupport<Key>::Equals(node->kv.first, k)) {
-            return std::make_pair(const_iterator(node, this, b), b);
-          } else {
-            node = node->next;
-          }
-        } while (node != nullptr);
-      } else if (TableEntryIsTree(b)) {
-        GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
-        b &= ~static_cast<size_t>(1);
-        Tree* tree = static_cast<Tree*>(table_[b]);
-        auto tree_it = tree->find(k);
-        if (tree_it != tree->end()) {
-          if (it != nullptr) *it = tree_it;
-          return std::make_pair(const_iterator(tree_it, this, b), b);
-        }
-      }
-      return std::make_pair(end(), b);
-    }
-
-    // Insert the given Node in bucket b.  If that would make bucket b too big,
-    // and bucket b is not a tree, create a tree for buckets b and b^1 to share.
-    // Requires count(*KeyPtrFromNodePtr(node)) == 0 and that b is the correct
-    // bucket.  num_elements_ is not modified.
-    iterator InsertUnique(size_type b, Node* node) {
-      GOOGLE_DCHECK(index_of_first_non_null_ == num_buckets_ ||
-             table_[index_of_first_non_null_] != nullptr);
-      // In practice, the code that led to this point may have already
-      // determined whether we are inserting into an empty list, a short list,
-      // or whatever.  But it's probably cheap enough to recompute that here;
-      // it's likely that we're inserting into an empty or short list.
-      iterator result;
-      GOOGLE_DCHECK(find(node->kv.first) == end());
-      if (TableEntryIsEmpty(b)) {
-        result = InsertUniqueInList(b, node);
-      } else if (TableEntryIsNonEmptyList(b)) {
-        if (PROTOBUF_PREDICT_FALSE(TableEntryIsTooLong(b))) {
-          TreeConvert(b);
-          result = InsertUniqueInTree(b, node);
-          GOOGLE_DCHECK_EQ(result.bucket_index_, b & ~static_cast<size_type>(1));
-        } else {
-          // Insert into a pre-existing list.  This case cannot modify
-          // index_of_first_non_null_, so we skip the code to update it.
-          return InsertUniqueInList(b, node);
-        }
-      } else {
-        // Insert into a pre-existing tree.  This case cannot modify
-        // index_of_first_non_null_, so we skip the code to update it.
-        return InsertUniqueInTree(b, node);
-      }
-      // parentheses around (std::min) prevents macro expansion of min(...)
-      index_of_first_non_null_ =
-          (std::min)(index_of_first_non_null_, result.bucket_index_);
-      return result;
-    }
-
-    // Returns whether we should insert after the head of the list. For
-    // non-optimized builds, we randomly decide whether to insert right at the
-    // head of the list or just after the head. This helps add a little bit of
-    // non-determinism to the map ordering.
-    bool ShouldInsertAfterHead(void* node) {
+
+            Map& operator=(Map&& other) noexcept
+            {
+                if (this != &other)
+                {
+                    if (arena() != other.arena())
+                    {
+                        *this = other;
+                    }
+                    else
+                    {
+                        swap(other);
+                    }
+                }
+                return *this;
+            }
+
+            template<class InputIt>
+            Map(const InputIt& first, const InputIt& last) :
+                Map()
+            {
+                insert(first, last);
+            }
+
+            ~Map()
+            {
+            }
+
+        private:
+            using Allocator = internal::MapAllocator<void*>;
+
+            // InnerMap is a generic hash-based map.  It doesn't contain any
+            // protocol-buffer-specific logic.  It is a chaining hash map with the
+            // additional feature that some buckets can be converted to use an ordered
+            // container.  This ensures O(lg n) bounds on find, insert, and erase, while
+            // avoiding the overheads of ordered containers most of the time.
+            //
+            // The implementation doesn't need the full generality of unordered_map,
+            // and it doesn't have it.  More bells and whistles can be added as needed.
+            // Some implementation details:
+            // 1. The hash function has type hasher and the equality function
+            //    equal_to<Key>.  We inherit from hasher to save space
+            //    (empty-base-class optimization).
+            // 2. The number of buckets is a power of two.
+            // 3. Buckets are converted to trees in pairs: if we convert bucket b then
+            //    buckets b and b^1 will share a tree.  Invariant: buckets b and b^1 have
+            //    the same non-null value iff they are sharing a tree.  (An alternative
+            //    implementation strategy would be to have a tag bit per bucket.)
+            // 4. As is typical for hash_map and such, the Keys and Values are always
+            //    stored in linked list nodes.  Pointers to elements are never invalidated
+            //    until the element is deleted.
+            // 5. The trees' payload type is pointer to linked-list node.  Tree-converting
+            //    a bucket doesn't copy Key-Value pairs.
+            // 6. Once we've tree-converted a bucket, it is never converted back. However,
+            //    the items a tree contains may wind up assigned to trees or lists upon a
+            //    rehash.
+            // 7. The code requires no C++ features from C++14 or later.
+            // 8. Mutations to a map do not invalidate the map's iterators, pointers to
+            //    elements, or references to elements.
+            // 9. Except for erase(iterator), any non-const method can reorder iterators.
+            // 10. InnerMap uses KeyForTree<Key> when using the Tree representation, which
+            //    is either `Key`, if Key is a scalar, or `reference_wrapper<const Key>`
+            //    otherwise. This avoids unnecessary copies of string keys, for example.
+            class InnerMap : private hasher
+            {
+            public:
+                explicit constexpr InnerMap(Arena* arena) :
+                    hasher(),
+                    num_elements_(0),
+                    num_buckets_(internal::kGlobalEmptyTableSize),
+                    seed_(0),
+                    index_of_first_non_null_(internal::kGlobalEmptyTableSize),
+                    table_(const_cast<void**>(internal::kGlobalEmptyTable)),
+                    alloc_(arena)
+                {
+                }
+
+                ~InnerMap()
+                {
+                    if (alloc_.arena() == nullptr &&
+                        num_buckets_ != internal::kGlobalEmptyTableSize)
+                    {
+                        clear();
+                        Dealloc<void*>(table_, num_buckets_);
+                    }
+                }
+
+            private:
+                enum
+                {
+                    kMinTableSize = 8
+                };
+
+                // Linked-list nodes, as one would expect for a chaining hash table.
+                struct Node
+                {
+                    value_type kv;
+                    Node* next;
+                };
+
+                // Trees. The payload type is a copy of Key, so that we can query the tree
+                // with Keys that are not in any particular data structure.
+                // The value is a void* pointing to Node. We use void* instead of Node* to
+                // avoid code bloat. That way there is only one instantiation of the tree
+                // class per key type.
+                using Tree = internal::TreeForMap<Key>;
+                using TreeIterator = typename Tree::iterator;
+
+                static Node* NodeFromTreeIterator(TreeIterator it)
+                {
+                    return static_cast<Node*>(it->second);
+                }
+
+                // iterator and const_iterator are instantiations of iterator_base.
+                template<typename KeyValueType>
+                class iterator_base
+                {
+                public:
+                    using reference = KeyValueType&;
+                    using pointer = KeyValueType*;
+
+                    // Invariants:
+                    // node_ is always correct. This is handy because the most common
+                    // operations are operator* and operator-> and they only use node_.
+                    // When node_ is set to a non-null value, all the other non-const fields
+                    // are updated to be correct also, but those fields can become stale
+                    // if the underlying map is modified.  When those fields are needed they
+                    // are rechecked, and updated if necessary.
+                    iterator_base() :
+                        node_(nullptr),
+                        m_(nullptr),
+                        bucket_index_(0)
+                    {
+                    }
+
+                    explicit iterator_base(const InnerMap* m) :
+                        m_(m)
+                    {
+                        SearchFrom(m->index_of_first_non_null_);
+                    }
+
+                    // Any iterator_base can convert to any other.  This is overkill, and we
+                    // rely on the enclosing class to use it wisely.  The standard "iterator
+                    // can convert to const_iterator" is OK but the reverse direction is not.
+                    template<typename U>
+                    explicit iterator_base(const iterator_base<U>& it) :
+                        node_(it.node_),
+                        m_(it.m_),
+                        bucket_index_(it.bucket_index_)
+                    {
+                    }
+
+                    iterator_base(Node* n, const InnerMap* m, size_type index) :
+                        node_(n),
+                        m_(m),
+                        bucket_index_(index)
+                    {
+                    }
+
+                    iterator_base(TreeIterator tree_it, const InnerMap* m, size_type index) :
+                        node_(NodeFromTreeIterator(tree_it)),
+                        m_(m),
+                        bucket_index_(index)
+                    {
+                        // Invariant: iterators that use buckets with trees have an even
+                        // bucket_index_.
+                        GOOGLE_DCHECK_EQ(bucket_index_ % 2, 0u);
+                    }
+
+                    // Advance through buckets, looking for the first that isn't empty.
+                    // If nothing non-empty is found then leave node_ == nullptr.
+                    void SearchFrom(size_type start_bucket)
+                    {
+                        GOOGLE_DCHECK(m_->index_of_first_non_null_ == m_->num_buckets_ || m_->table_[m_->index_of_first_non_null_] != nullptr);
+                        node_ = nullptr;
+                        for (bucket_index_ = start_bucket; bucket_index_ < m_->num_buckets_;
+                             bucket_index_++)
+                        {
+                            if (m_->TableEntryIsNonEmptyList(bucket_index_))
+                            {
+                                node_ = static_cast<Node*>(m_->table_[bucket_index_]);
+                                break;
+                            }
+                            else if (m_->TableEntryIsTree(bucket_index_))
+                            {
+                                Tree* tree = static_cast<Tree*>(m_->table_[bucket_index_]);
+                                GOOGLE_DCHECK(!tree->empty());
+                                node_ = NodeFromTreeIterator(tree->begin());
+                                break;
+                            }
+                        }
+                    }
+
+                    reference operator*() const
+                    {
+                        return node_->kv;
+                    }
+                    pointer operator->() const
+                    {
+                        return &(operator*());
+                    }
+
+                    friend bool operator==(const iterator_base& a, const iterator_base& b)
+                    {
+                        return a.node_ == b.node_;
+                    }
+                    friend bool operator!=(const iterator_base& a, const iterator_base& b)
+                    {
+                        return a.node_ != b.node_;
+                    }
+
+                    iterator_base& operator++()
+                    {
+                        if (node_->next == nullptr)
+                        {
+                            TreeIterator tree_it;
+                            const bool is_list = revalidate_if_necessary(&tree_it);
+                            if (is_list)
+                            {
+                                SearchFrom(bucket_index_ + 1);
+                            }
+                            else
+                            {
+                                GOOGLE_DCHECK_EQ(bucket_index_ & 1, 0u);
+                                Tree* tree = static_cast<Tree*>(m_->table_[bucket_index_]);
+                                if (++tree_it == tree->end())
+                                {
+                                    SearchFrom(bucket_index_ + 2);
+                                }
+                                else
+                                {
+                                    node_ = NodeFromTreeIterator(tree_it);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            node_ = node_->next;
+                        }
+                        return *this;
+                    }
+
+                    iterator_base operator++(int /* unused */)
+                    {
+                        iterator_base tmp = *this;
+                        ++*this;
+                        return tmp;
+                    }
+
+                    // Assumes node_ and m_ are correct and non-null, but other fields may be
+                    // stale.  Fix them as needed.  Then return true iff node_ points to a
+                    // Node in a list.  If false is returned then *it is modified to be
+                    // a valid iterator for node_.
+                    bool revalidate_if_necessary(TreeIterator* it)
+                    {
+                        GOOGLE_DCHECK(node_ != nullptr && m_ != nullptr);
+                        // Force bucket_index_ to be in range.
+                        bucket_index_ &= (m_->num_buckets_ - 1);
+                        // Common case: the bucket we think is relevant points to node_.
+                        if (m_->table_[bucket_index_] == static_cast<void*>(node_))
+                            return true;
+                        // Less common: the bucket is a linked list with node_ somewhere in it,
+                        // but not at the head.
+                        if (m_->TableEntryIsNonEmptyList(bucket_index_))
+                        {
+                            Node* l = static_cast<Node*>(m_->table_[bucket_index_]);
+                            while ((l = l->next) != nullptr)
+                            {
+                                if (l == node_)
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                        // Well, bucket_index_ still might be correct, but probably
+                        // not.  Revalidate just to be sure.  This case is rare enough that we
+                        // don't worry about potential optimizations, such as having a custom
+                        // find-like method that compares Node* instead of the key.
+                        iterator_base i(m_->find(node_->kv.first, it));
+                        bucket_index_ = i.bucket_index_;
+                        return m_->TableEntryIsList(bucket_index_);
+                    }
+
+                    Node* node_;
+                    const InnerMap* m_;
+                    size_type bucket_index_;
+                };
+
+            public:
+                using iterator = iterator_base<value_type>;
+                using const_iterator = iterator_base<const value_type>;
+
+                Arena* arena() const
+                {
+                    return alloc_.arena();
+                }
+
+                void Swap(InnerMap* other)
+                {
+                    std::swap(num_elements_, other->num_elements_);
+                    std::swap(num_buckets_, other->num_buckets_);
+                    std::swap(seed_, other->seed_);
+                    std::swap(index_of_first_non_null_, other->index_of_first_non_null_);
+                    std::swap(table_, other->table_);
+                    std::swap(alloc_, other->alloc_);
+                }
+
+                iterator begin()
+                {
+                    return iterator(this);
+                }
+                iterator end()
+                {
+                    return iterator();
+                }
+                const_iterator begin() const
+                {
+                    return const_iterator(this);
+                }
+                const_iterator end() const
+                {
+                    return const_iterator();
+                }
+
+                void clear()
+                {
+                    for (size_type b = 0; b < num_buckets_; b++)
+                    {
+                        if (TableEntryIsNonEmptyList(b))
+                        {
+                            Node* node = static_cast<Node*>(table_[b]);
+                            table_[b] = nullptr;
+                            do
+                            {
+                                Node* next = node->next;
+                                DestroyNode(node);
+                                node = next;
+                            } while (node != nullptr);
+                        }
+                        else if (TableEntryIsTree(b))
+                        {
+                            Tree* tree = static_cast<Tree*>(table_[b]);
+                            GOOGLE_DCHECK(table_[b] == table_[b + 1] && (b & 1) == 0);
+                            table_[b] = table_[b + 1] = nullptr;
+                            typename Tree::iterator tree_it = tree->begin();
+                            do
+                            {
+                                Node* node = NodeFromTreeIterator(tree_it);
+                                typename Tree::iterator next = tree_it;
+                                ++next;
+                                tree->erase(tree_it);
+                                DestroyNode(node);
+                                tree_it = next;
+                            } while (tree_it != tree->end());
+                            DestroyTree(tree);
+                            b++;
+                        }
+                    }
+                    num_elements_ = 0;
+                    index_of_first_non_null_ = num_buckets_;
+                }
+
+                const hasher& hash_function() const
+                {
+                    return *this;
+                }
+
+                static size_type max_size()
+                {
+                    return static_cast<size_type>(1) << (sizeof(void**) >= 8 ? 60 : 28);
+                }
+                size_type size() const
+                {
+                    return num_elements_;
+                }
+                bool empty() const
+                {
+                    return size() == 0;
+                }
+
+                template<typename K>
+                iterator find(const K& k)
+                {
+                    return iterator(FindHelper(k).first);
+                }
+
+                template<typename K>
+                const_iterator find(const K& k) const
+                {
+                    return FindHelper(k).first;
+                }
+
+                // Inserts a new element into the container if there is no element with the
+                // key in the container.
+                // The new element is:
+                //  (1) Constructed in-place with the given args, if mapped_type is not
+                //      arena constructible.
+                //  (2) Constructed in-place with the arena and then assigned with a
+                //      mapped_type temporary constructed with the given args, otherwise.
+                template<typename K, typename... Args>
+                std::pair<iterator, bool> try_emplace(K&& k, Args&&... args)
+                {
+                    return ArenaAwareTryEmplace(Arena::is_arena_constructable<mapped_type>(), std::forward<K>(k), std::forward<Args>(args)...);
+                }
+
+                // Inserts the key into the map, if not present. In that case, the value
+                // will be value initialized.
+                template<typename K>
+                std::pair<iterator, bool> insert(K&& k)
+                {
+                    return try_emplace(std::forward<K>(k));
+                }
+
+                template<typename K>
+                value_type& operator[](K&& k)
+                {
+                    return *try_emplace(std::forward<K>(k)).first;
+                }
+
+                void erase(iterator it)
+                {
+                    GOOGLE_DCHECK_EQ(it.m_, this);
+                    typename Tree::iterator tree_it;
+                    const bool is_list = it.revalidate_if_necessary(&tree_it);
+                    size_type b = it.bucket_index_;
+                    Node* const item = it.node_;
+                    if (is_list)
+                    {
+                        GOOGLE_DCHECK(TableEntryIsNonEmptyList(b));
+                        Node* head = static_cast<Node*>(table_[b]);
+                        head = EraseFromLinkedList(item, head);
+                        table_[b] = static_cast<void*>(head);
+                    }
+                    else
+                    {
+                        GOOGLE_DCHECK(TableEntryIsTree(b));
+                        Tree* tree = static_cast<Tree*>(table_[b]);
+                        tree->erase(tree_it);
+                        if (tree->empty())
+                        {
+                            // Force b to be the minimum of b and b ^ 1.  This is important
+                            // only because we want index_of_first_non_null_ to be correct.
+                            b &= ~static_cast<size_type>(1);
+                            DestroyTree(tree);
+                            table_[b] = table_[b + 1] = nullptr;
+                        }
+                    }
+                    DestroyNode(item);
+                    --num_elements_;
+                    if (PROTOBUF_PREDICT_FALSE(b == index_of_first_non_null_))
+                    {
+                        while (index_of_first_non_null_ < num_buckets_ &&
+                               table_[index_of_first_non_null_] == nullptr)
+                        {
+                            ++index_of_first_non_null_;
+                        }
+                    }
+                }
+
+                size_t SpaceUsedInternal() const
+                {
+                    return internal::SpaceUsedInTable<Key>(table_, num_buckets_, num_elements_, sizeof(Node));
+                }
+
+            private:
+                template<typename K, typename... Args>
+                std::pair<iterator, bool> TryEmplaceInternal(K&& k, Args&&... args)
+                {
+                    std::pair<const_iterator, size_type> p = FindHelper(k);
+                    // Case 1: key was already present.
+                    if (p.first.node_ != nullptr)
+                        return std::make_pair(iterator(p.first), false);
+                    // Case 2: insert.
+                    if (ResizeIfLoadIsOutOfRange(num_elements_ + 1))
+                    {
+                        p = FindHelper(k);
+                    }
+                    const size_type b = p.second;  // bucket number
+                    // If K is not key_type, make the conversion to key_type explicit.
+                    using TypeToInit = typename std::conditional<
+                        std::is_same<typename std::decay<K>::type, key_type>::value,
+                        K&&,
+                        key_type>::type;
+                    Node* node = Alloc<Node>(1);
+                    // Even when arena is nullptr, CreateInArenaStorage is still used to
+                    // ensure the arena of submessage will be consistent. Otherwise,
+                    // submessage may have its own arena when message-owned arena is enabled.
+                    // Note: This only works if `Key` is not arena constructible.
+                    Arena::CreateInArenaStorage(const_cast<Key*>(&node->kv.first), alloc_.arena(), static_cast<TypeToInit>(std::forward<K>(k)));
+                    // Note: if `T` is arena constructible, `Args` needs to be empty.
+                    Arena::CreateInArenaStorage(&node->kv.second, alloc_.arena(), std::forward<Args>(args)...);
+
+                    iterator result = InsertUnique(b, node);
+                    ++num_elements_;
+                    return std::make_pair(result, true);
+                }
+
+                // A helper function to perform an assignment of `mapped_type`.
+                // If the first argument is true, then it is a regular assignment.
+                // Otherwise, we first create a temporary and then perform an assignment.
+                template<typename V>
+                static void AssignMapped(std::true_type, mapped_type& mapped, V&& v)
+                {
+                    mapped = std::forward<V>(v);
+                }
+                template<typename... Args>
+                static void AssignMapped(std::false_type, mapped_type& mapped, Args&&... args)
+                {
+                    mapped = mapped_type(std::forward<Args>(args)...);
+                }
+
+                // Case 1: `mapped_type` is arena constructible. A temporary object is
+                // created and then (if `Args` are not empty) assigned to a mapped value
+                // that was created with the arena.
+                template<typename K>
+                std::pair<iterator, bool> ArenaAwareTryEmplace(std::true_type, K&& k)
+                {
+                    // case 1.1: "default" constructed (e.g. from arena only).
+                    return TryEmplaceInternal(std::forward<K>(k));
+                }
+                template<typename K, typename... Args>
+                std::pair<iterator, bool> ArenaAwareTryEmplace(std::true_type, K&& k, Args&&... args)
+                {
+                    // case 1.2: "default" constructed + copy/move assignment
+                    auto p = TryEmplaceInternal(std::forward<K>(k));
+                    if (p.second)
+                    {
+                        AssignMapped(std::is_same<void(typename std::decay<Args>::type...), void(mapped_type)>(), p.first->second, std::forward<Args>(args)...);
+                    }
+                    return p;
+                }
+                // Case 2: `mapped_type` is not arena constructible. Using in-place
+                // construction.
+                template<typename... Args>
+                std::pair<iterator, bool> ArenaAwareTryEmplace(std::false_type, Args&&... args)
+                {
+                    return TryEmplaceInternal(std::forward<Args>(args)...);
+                }
+
+                const_iterator find(const Key& k, TreeIterator* it) const
+                {
+                    return FindHelper(k, it).first;
+                }
+                template<typename K>
+                std::pair<const_iterator, size_type> FindHelper(const K& k) const
+                {
+                    return FindHelper(k, nullptr);
+                }
+                template<typename K>
+                std::pair<const_iterator, size_type> FindHelper(const K& k, TreeIterator* it) const
+                {
+                    size_type b = BucketNumber(k);
+                    if (TableEntryIsNonEmptyList(b))
+                    {
+                        Node* node = static_cast<Node*>(table_[b]);
+                        do
+                        {
+                            if (internal::TransparentSupport<Key>::Equals(node->kv.first, k))
+                            {
+                                return std::make_pair(const_iterator(node, this, b), b);
+                            }
+                            else
+                            {
+                                node = node->next;
+                            }
+                        } while (node != nullptr);
+                    }
+                    else if (TableEntryIsTree(b))
+                    {
+                        GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
+                        b &= ~static_cast<size_t>(1);
+                        Tree* tree = static_cast<Tree*>(table_[b]);
+                        auto tree_it = tree->find(k);
+                        if (tree_it != tree->end())
+                        {
+                            if (it != nullptr)
+                                *it = tree_it;
+                            return std::make_pair(const_iterator(tree_it, this, b), b);
+                        }
+                    }
+                    return std::make_pair(end(), b);
+                }
+
+                // Insert the given Node in bucket b.  If that would make bucket b too big,
+                // and bucket b is not a tree, create a tree for buckets b and b^1 to share.
+                // Requires count(*KeyPtrFromNodePtr(node)) == 0 and that b is the correct
+                // bucket.  num_elements_ is not modified.
+                iterator InsertUnique(size_type b, Node* node)
+                {
+                    GOOGLE_DCHECK(index_of_first_non_null_ == num_buckets_ || table_[index_of_first_non_null_] != nullptr);
+                    // In practice, the code that led to this point may have already
+                    // determined whether we are inserting into an empty list, a short list,
+                    // or whatever.  But it's probably cheap enough to recompute that here;
+                    // it's likely that we're inserting into an empty or short list.
+                    iterator result;
+                    GOOGLE_DCHECK(find(node->kv.first) == end());
+                    if (TableEntryIsEmpty(b))
+                    {
+                        result = InsertUniqueInList(b, node);
+                    }
+                    else if (TableEntryIsNonEmptyList(b))
+                    {
+                        if (PROTOBUF_PREDICT_FALSE(TableEntryIsTooLong(b)))
+                        {
+                            TreeConvert(b);
+                            result = InsertUniqueInTree(b, node);
+                            GOOGLE_DCHECK_EQ(result.bucket_index_, b & ~static_cast<size_type>(1));
+                        }
+                        else
+                        {
+                            // Insert into a pre-existing list.  This case cannot modify
+                            // index_of_first_non_null_, so we skip the code to update it.
+                            return InsertUniqueInList(b, node);
+                        }
+                    }
+                    else
+                    {
+                        // Insert into a pre-existing tree.  This case cannot modify
+                        // index_of_first_non_null_, so we skip the code to update it.
+                        return InsertUniqueInTree(b, node);
+                    }
+                    // parentheses around (std::min) prevents macro expansion of min(...)
+                    index_of_first_non_null_ =
+                        (std::min)(index_of_first_non_null_, result.bucket_index_);
+                    return result;
+                }
+
+                // Returns whether we should insert after the head of the list. For
+                // non-optimized builds, we randomly decide whether to insert right at the
+                // head of the list or just after the head. This helps add a little bit of
+                // non-determinism to the map ordering.
+                bool ShouldInsertAfterHead(void* node)
+                {
 #ifdef NDEBUG
-      (void)node;
-      return false;
+                    (void)node;
+                    return false;
 #else
-      // Doing modulo with a prime mixes the bits more.
-      return (reinterpret_cast<uintptr_t>(node) ^ seed_) % 13 > 6;
+                    // Doing modulo with a prime mixes the bits more.
+                    return (reinterpret_cast<uintptr_t>(node) ^ seed_) % 13 > 6;
 #endif
-    }
-
-    // Helper for InsertUnique.  Handles the case where bucket b is a
-    // not-too-long linked list.
-    iterator InsertUniqueInList(size_type b, Node* node) {
-      if (table_[b] != nullptr && ShouldInsertAfterHead(node)) {
-        Node* first = static_cast<Node*>(table_[b]);
-        node->next = first->next;
-        first->next = node;
-        return iterator(node, this, b);
-      }
-
-      node->next = static_cast<Node*>(table_[b]);
-      table_[b] = static_cast<void*>(node);
-      return iterator(node, this, b);
-    }
-
-    // Helper for InsertUnique.  Handles the case where bucket b points to a
-    // Tree.
-    iterator InsertUniqueInTree(size_type b, Node* node) {
-      GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
-      // Maintain the invariant that node->next is null for all Nodes in Trees.
-      node->next = nullptr;
-      return iterator(
-          static_cast<Tree*>(table_[b])->insert({node->kv.first, node}).first,
-          this, b & ~static_cast<size_t>(1));
-    }
-
-    // Returns whether it did resize.  Currently this is only used when
-    // num_elements_ increases, though it could be used in other situations.
-    // It checks for load too low as well as load too high: because any number
-    // of erases can occur between inserts, the load could be as low as 0 here.
-    // Resizing to a lower size is not always helpful, but failing to do so can
-    // destroy the expected big-O bounds for some operations. By having the
-    // policy that sometimes we resize down as well as up, clients can easily
-    // keep O(size()) = O(number of buckets) if they want that.
-    bool ResizeIfLoadIsOutOfRange(size_type new_size) {
-      const size_type kMaxMapLoadTimes16 = 12;  // controls RAM vs CPU tradeoff
-      const size_type hi_cutoff = num_buckets_ * kMaxMapLoadTimes16 / 16;
-      const size_type lo_cutoff = hi_cutoff / 4;
-      // We don't care how many elements are in trees.  If a lot are,
-      // we may resize even though there are many empty buckets.  In
-      // practice, this seems fine.
-      if (PROTOBUF_PREDICT_FALSE(new_size >= hi_cutoff)) {
-        if (num_buckets_ <= max_size() / 2) {
-          Resize(num_buckets_ * 2);
-          return true;
-        }
-      } else if (PROTOBUF_PREDICT_FALSE(new_size <= lo_cutoff &&
-                                        num_buckets_ > kMinTableSize)) {
-        size_type lg2_of_size_reduction_factor = 1;
-        // It's possible we want to shrink a lot here... size() could even be 0.
-        // So, estimate how much to shrink by making sure we don't shrink so
-        // much that we would need to grow the table after a few inserts.
-        const size_type hypothetical_size = new_size * 5 / 4 + 1;
-        while ((hypothetical_size << lg2_of_size_reduction_factor) <
-               hi_cutoff) {
-          ++lg2_of_size_reduction_factor;
-        }
-        size_type new_num_buckets = std::max<size_type>(
-            kMinTableSize, num_buckets_ >> lg2_of_size_reduction_factor);
-        if (new_num_buckets != num_buckets_) {
-          Resize(new_num_buckets);
-          return true;
-        }
-      }
-      return false;
-    }
-
-    // Resize to the given number of buckets.
-    void Resize(size_t new_num_buckets) {
-      if (num_buckets_ == internal::kGlobalEmptyTableSize) {
-        // This is the global empty array.
-        // Just overwrite with a new one. No need to transfer or free anything.
-        num_buckets_ = index_of_first_non_null_ = kMinTableSize;
-        table_ = CreateEmptyTable(num_buckets_);
-        seed_ = Seed();
-        return;
-      }
-
-      GOOGLE_DCHECK_GE(new_num_buckets, kMinTableSize);
-      void** const old_table = table_;
-      const size_type old_table_size = num_buckets_;
-      num_buckets_ = new_num_buckets;
-      table_ = CreateEmptyTable(num_buckets_);
-      const size_type start = index_of_first_non_null_;
-      index_of_first_non_null_ = num_buckets_;
-      for (size_type i = start; i < old_table_size; i++) {
-        if (internal::TableEntryIsNonEmptyList(old_table, i)) {
-          TransferList(old_table, i);
-        } else if (internal::TableEntryIsTree(old_table, i)) {
-          TransferTree(old_table, i++);
-        }
-      }
-      Dealloc<void*>(old_table, old_table_size);
-    }
-
-    void TransferList(void* const* table, size_type index) {
-      Node* node = static_cast<Node*>(table[index]);
-      do {
-        Node* next = node->next;
-        InsertUnique(BucketNumber(node->kv.first), node);
-        node = next;
-      } while (node != nullptr);
-    }
-
-    void TransferTree(void* const* table, size_type index) {
-      Tree* tree = static_cast<Tree*>(table[index]);
-      typename Tree::iterator tree_it = tree->begin();
-      do {
-        InsertUnique(BucketNumber(std::cref(tree_it->first).get()),
-                     NodeFromTreeIterator(tree_it));
-      } while (++tree_it != tree->end());
-      DestroyTree(tree);
-    }
-
-    Node* EraseFromLinkedList(Node* item, Node* head) {
-      if (head == item) {
-        return head->next;
-      } else {
-        head->next = EraseFromLinkedList(item, head->next);
-        return head;
-      }
-    }
-
-    bool TableEntryIsEmpty(size_type b) const {
-      return internal::TableEntryIsEmpty(table_, b);
-    }
-    bool TableEntryIsNonEmptyList(size_type b) const {
-      return internal::TableEntryIsNonEmptyList(table_, b);
-    }
-    bool TableEntryIsTree(size_type b) const {
-      return internal::TableEntryIsTree(table_, b);
-    }
-    bool TableEntryIsList(size_type b) const {
-      return internal::TableEntryIsList(table_, b);
-    }
-
-    void TreeConvert(size_type b) {
-      GOOGLE_DCHECK(!TableEntryIsTree(b) && !TableEntryIsTree(b ^ 1));
-      Tree* tree =
-          Arena::Create<Tree>(alloc_.arena(), typename Tree::key_compare(),
-                              typename Tree::allocator_type(alloc_));
-      size_type count = CopyListToTree(b, tree) + CopyListToTree(b ^ 1, tree);
-      GOOGLE_DCHECK_EQ(count, tree->size());
-      table_[b] = table_[b ^ 1] = static_cast<void*>(tree);
-    }
-
-    // Copy a linked list in the given bucket to a tree.
-    // Returns the number of things it copied.
-    size_type CopyListToTree(size_type b, Tree* tree) {
-      size_type count = 0;
-      Node* node = static_cast<Node*>(table_[b]);
-      while (node != nullptr) {
-        tree->insert({node->kv.first, node});
-        ++count;
-        Node* next = node->next;
-        node->next = nullptr;
-        node = next;
-      }
-      return count;
-    }
-
-    // Return whether table_[b] is a linked list that seems awfully long.
-    // Requires table_[b] to point to a non-empty linked list.
-    bool TableEntryIsTooLong(size_type b) {
-      const size_type kMaxLength = 8;
-      size_type count = 0;
-      Node* node = static_cast<Node*>(table_[b]);
-      do {
-        ++count;
-        node = node->next;
-      } while (node != nullptr);
-      // Invariant: no linked list ever is more than kMaxLength in length.
-      GOOGLE_DCHECK_LE(count, kMaxLength);
-      return count >= kMaxLength;
-    }
-
-    template <typename K>
-    size_type BucketNumber(const K& k) const {
-      // We xor the hash value against the random seed so that we effectively
-      // have a random hash function.
-      uint64_t h = hash_function()(k) ^ seed_;
-
-      // We use the multiplication method to determine the bucket number from
-      // the hash value. The constant kPhi (suggested by Knuth) is roughly
-      // (sqrt(5) - 1) / 2 * 2^64.
-      constexpr uint64_t kPhi = uint64_t{0x9e3779b97f4a7c15};
-      return ((kPhi * h) >> 32) & (num_buckets_ - 1);
-    }
-
-    // Return a power of two no less than max(kMinTableSize, n).
-    // Assumes either n < kMinTableSize or n is a power of two.
-    size_type TableSize(size_type n) {
-      return n < static_cast<size_type>(kMinTableSize)
-                 ? static_cast<size_type>(kMinTableSize)
-                 : n;
-    }
-
-    // Use alloc_ to allocate an array of n objects of type U.
-    template <typename U>
-    U* Alloc(size_type n) {
-      using alloc_type = typename Allocator::template rebind<U>::other;
-      return alloc_type(alloc_).allocate(n);
-    }
-
-    // Use alloc_ to deallocate an array of n objects of type U.
-    template <typename U>
-    void Dealloc(U* t, size_type n) {
-      using alloc_type = typename Allocator::template rebind<U>::other;
-      alloc_type(alloc_).deallocate(t, n);
-    }
-
-    void DestroyNode(Node* node) {
-      if (alloc_.arena() == nullptr) {
-        delete node;
-      }
-    }
-
-    void DestroyTree(Tree* tree) {
-      if (alloc_.arena() == nullptr) {
-        delete tree;
-      }
-    }
-
-    void** CreateEmptyTable(size_type n) {
-      GOOGLE_DCHECK(n >= kMinTableSize);
-      GOOGLE_DCHECK_EQ(n & (n - 1), 0u);
-      void** result = Alloc<void*>(n);
-      memset(result, 0, n * sizeof(result[0]));
-      return result;
-    }
-
-    // Return a randomish value.
-    size_type Seed() const {
-      // We get a little bit of randomness from the address of the map. The
-      // lower bits are not very random, due to alignment, so we discard them
-      // and shift the higher bits into their place.
-      size_type s = reinterpret_cast<uintptr_t>(this) >> 4;
+                }
+
+                // Helper for InsertUnique.  Handles the case where bucket b is a
+                // not-too-long linked list.
+                iterator InsertUniqueInList(size_type b, Node* node)
+                {
+                    if (table_[b] != nullptr && ShouldInsertAfterHead(node))
+                    {
+                        Node* first = static_cast<Node*>(table_[b]);
+                        node->next = first->next;
+                        first->next = node;
+                        return iterator(node, this, b);
+                    }
+
+                    node->next = static_cast<Node*>(table_[b]);
+                    table_[b] = static_cast<void*>(node);
+                    return iterator(node, this, b);
+                }
+
+                // Helper for InsertUnique.  Handles the case where bucket b points to a
+                // Tree.
+                iterator InsertUniqueInTree(size_type b, Node* node)
+                {
+                    GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
+                    // Maintain the invariant that node->next is null for all Nodes in Trees.
+                    node->next = nullptr;
+                    return iterator(
+                        static_cast<Tree*>(table_[b])->insert({node->kv.first, node}).first,
+                        this,
+                        b & ~static_cast<size_t>(1)
+                    );
+                }
+
+                // Returns whether it did resize.  Currently this is only used when
+                // num_elements_ increases, though it could be used in other situations.
+                // It checks for load too low as well as load too high: because any number
+                // of erases can occur between inserts, the load could be as low as 0 here.
+                // Resizing to a lower size is not always helpful, but failing to do so can
+                // destroy the expected big-O bounds for some operations. By having the
+                // policy that sometimes we resize down as well as up, clients can easily
+                // keep O(size()) = O(number of buckets) if they want that.
+                bool ResizeIfLoadIsOutOfRange(size_type new_size)
+                {
+                    const size_type kMaxMapLoadTimes16 = 12;  // controls RAM vs CPU tradeoff
+                    const size_type hi_cutoff = num_buckets_ * kMaxMapLoadTimes16 / 16;
+                    const size_type lo_cutoff = hi_cutoff / 4;
+                    // We don't care how many elements are in trees.  If a lot are,
+                    // we may resize even though there are many empty buckets.  In
+                    // practice, this seems fine.
+                    if (PROTOBUF_PREDICT_FALSE(new_size >= hi_cutoff))
+                    {
+                        if (num_buckets_ <= max_size() / 2)
+                        {
+                            Resize(num_buckets_ * 2);
+                            return true;
+                        }
+                    }
+                    else if (PROTOBUF_PREDICT_FALSE(new_size <= lo_cutoff && num_buckets_ > kMinTableSize))
+                    {
+                        size_type lg2_of_size_reduction_factor = 1;
+                        // It's possible we want to shrink a lot here... size() could even be 0.
+                        // So, estimate how much to shrink by making sure we don't shrink so
+                        // much that we would need to grow the table after a few inserts.
+                        const size_type hypothetical_size = new_size * 5 / 4 + 1;
+                        while ((hypothetical_size << lg2_of_size_reduction_factor) <
+                               hi_cutoff)
+                        {
+                            ++lg2_of_size_reduction_factor;
+                        }
+                        size_type new_num_buckets = std::max<size_type>(
+                            kMinTableSize, num_buckets_ >> lg2_of_size_reduction_factor
+                        );
+                        if (new_num_buckets != num_buckets_)
+                        {
+                            Resize(new_num_buckets);
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+
+                // Resize to the given number of buckets.
+                void Resize(size_t new_num_buckets)
+                {
+                    if (num_buckets_ == internal::kGlobalEmptyTableSize)
+                    {
+                        // This is the global empty array.
+                        // Just overwrite with a new one. No need to transfer or free anything.
+                        num_buckets_ = index_of_first_non_null_ = kMinTableSize;
+                        table_ = CreateEmptyTable(num_buckets_);
+                        seed_ = Seed();
+                        return;
+                    }
+
+                    GOOGLE_DCHECK_GE(new_num_buckets, kMinTableSize);
+                    void** const old_table = table_;
+                    const size_type old_table_size = num_buckets_;
+                    num_buckets_ = new_num_buckets;
+                    table_ = CreateEmptyTable(num_buckets_);
+                    const size_type start = index_of_first_non_null_;
+                    index_of_first_non_null_ = num_buckets_;
+                    for (size_type i = start; i < old_table_size; i++)
+                    {
+                        if (internal::TableEntryIsNonEmptyList(old_table, i))
+                        {
+                            TransferList(old_table, i);
+                        }
+                        else if (internal::TableEntryIsTree(old_table, i))
+                        {
+                            TransferTree(old_table, i++);
+                        }
+                    }
+                    Dealloc<void*>(old_table, old_table_size);
+                }
+
+                void TransferList(void* const* table, size_type index)
+                {
+                    Node* node = static_cast<Node*>(table[index]);
+                    do
+                    {
+                        Node* next = node->next;
+                        InsertUnique(BucketNumber(node->kv.first), node);
+                        node = next;
+                    } while (node != nullptr);
+                }
+
+                void TransferTree(void* const* table, size_type index)
+                {
+                    Tree* tree = static_cast<Tree*>(table[index]);
+                    typename Tree::iterator tree_it = tree->begin();
+                    do
+                    {
+                        InsertUnique(BucketNumber(std::cref(tree_it->first).get()), NodeFromTreeIterator(tree_it));
+                    } while (++tree_it != tree->end());
+                    DestroyTree(tree);
+                }
+
+                Node* EraseFromLinkedList(Node* item, Node* head)
+                {
+                    if (head == item)
+                    {
+                        return head->next;
+                    }
+                    else
+                    {
+                        head->next = EraseFromLinkedList(item, head->next);
+                        return head;
+                    }
+                }
+
+                bool TableEntryIsEmpty(size_type b) const
+                {
+                    return internal::TableEntryIsEmpty(table_, b);
+                }
+                bool TableEntryIsNonEmptyList(size_type b) const
+                {
+                    return internal::TableEntryIsNonEmptyList(table_, b);
+                }
+                bool TableEntryIsTree(size_type b) const
+                {
+                    return internal::TableEntryIsTree(table_, b);
+                }
+                bool TableEntryIsList(size_type b) const
+                {
+                    return internal::TableEntryIsList(table_, b);
+                }
+
+                void TreeConvert(size_type b)
+                {
+                    GOOGLE_DCHECK(!TableEntryIsTree(b) && !TableEntryIsTree(b ^ 1));
+                    Tree* tree =
+                        Arena::Create<Tree>(alloc_.arena(), typename Tree::key_compare(), typename Tree::allocator_type(alloc_));
+                    size_type count = CopyListToTree(b, tree) + CopyListToTree(b ^ 1, tree);
+                    GOOGLE_DCHECK_EQ(count, tree->size());
+                    table_[b] = table_[b ^ 1] = static_cast<void*>(tree);
+                }
+
+                // Copy a linked list in the given bucket to a tree.
+                // Returns the number of things it copied.
+                size_type CopyListToTree(size_type b, Tree* tree)
+                {
+                    size_type count = 0;
+                    Node* node = static_cast<Node*>(table_[b]);
+                    while (node != nullptr)
+                    {
+                        tree->insert({node->kv.first, node});
+                        ++count;
+                        Node* next = node->next;
+                        node->next = nullptr;
+                        node = next;
+                    }
+                    return count;
+                }
+
+                // Return whether table_[b] is a linked list that seems awfully long.
+                // Requires table_[b] to point to a non-empty linked list.
+                bool TableEntryIsTooLong(size_type b)
+                {
+                    const size_type kMaxLength = 8;
+                    size_type count = 0;
+                    Node* node = static_cast<Node*>(table_[b]);
+                    do
+                    {
+                        ++count;
+                        node = node->next;
+                    } while (node != nullptr);
+                    // Invariant: no linked list ever is more than kMaxLength in length.
+                    GOOGLE_DCHECK_LE(count, kMaxLength);
+                    return count >= kMaxLength;
+                }
+
+                template<typename K>
+                size_type BucketNumber(const K& k) const
+                {
+                    // We xor the hash value against the random seed so that we effectively
+                    // have a random hash function.
+                    uint64_t h = hash_function()(k) ^ seed_;
+
+                    // We use the multiplication method to determine the bucket number from
+                    // the hash value. The constant kPhi (suggested by Knuth) is roughly
+                    // (sqrt(5) - 1) / 2 * 2^64.
+                    constexpr uint64_t kPhi = uint64_t{0x9e3779b97f4a7c15};
+                    return ((kPhi * h) >> 32) & (num_buckets_ - 1);
+                }
+
+                // Return a power of two no less than max(kMinTableSize, n).
+                // Assumes either n < kMinTableSize or n is a power of two.
+                size_type TableSize(size_type n)
+                {
+                    return n < static_cast<size_type>(kMinTableSize) ? static_cast<size_type>(kMinTableSize) : n;
+                }
+
+                // Use alloc_ to allocate an array of n objects of type U.
+                template<typename U>
+                U* Alloc(size_type n)
+                {
+                    using alloc_type = typename Allocator::template rebind<U>::other;
+                    return alloc_type(alloc_).allocate(n);
+                }
+
+                // Use alloc_ to deallocate an array of n objects of type U.
+                template<typename U>
+                void Dealloc(U* t, size_type n)
+                {
+                    using alloc_type = typename Allocator::template rebind<U>::other;
+                    alloc_type(alloc_).deallocate(t, n);
+                }
+
+                void DestroyNode(Node* node)
+                {
+                    if (alloc_.arena() == nullptr)
+                    {
+                        delete node;
+                    }
+                }
+
+                void DestroyTree(Tree* tree)
+                {
+                    if (alloc_.arena() == nullptr)
+                    {
+                        delete tree;
+                    }
+                }
+
+                void** CreateEmptyTable(size_type n)
+                {
+                    GOOGLE_DCHECK(n >= kMinTableSize);
+                    GOOGLE_DCHECK_EQ(n & (n - 1), 0u);
+                    void** result = Alloc<void*>(n);
+                    memset(result, 0, n * sizeof(result[0]));
+                    return result;
+                }
+
+                // Return a randomish value.
+                size_type Seed() const
+                {
+                    // We get a little bit of randomness from the address of the map. The
+                    // lower bits are not very random, due to alignment, so we discard them
+                    // and shift the higher bits into their place.
+                    size_type s = reinterpret_cast<uintptr_t>(this) >> 4;
 #if !defined(GOOGLE_PROTOBUF_NO_RDTSC)
 #if defined(__APPLE__)
-      // Use a commpage-based fast time function on Apple environments (MacOS,
-      // iOS, tvOS, watchOS, etc).
-      s += mach_absolute_time();
+                    // Use a commpage-based fast time function on Apple environments (MacOS,
+                    // iOS, tvOS, watchOS, etc).
+                    s += mach_absolute_time();
 #elif defined(__x86_64__) && defined(__GNUC__)
-      uint32_t hi, lo;
-      asm volatile("rdtsc" : "=a"(lo), "=d"(hi));
-      s += ((static_cast<uint64_t>(hi) << 32) | lo);
+                    uint32_t hi, lo;
+                    asm volatile("rdtsc"
+                                 : "=a"(lo), "=d"(hi));
+                    s += ((static_cast<uint64_t>(hi) << 32) | lo);
 #elif defined(__aarch64__) && defined(__GNUC__)
-      // There is no rdtsc on ARMv8. CNTVCT_EL0 is the virtual counter of the
-      // system timer. It runs at a different frequency than the CPU's, but is
-      // the best source of time-based entropy we get.
-      uint64_t virtual_timer_value;
-      asm volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
-      s += virtual_timer_value;
+                    // There is no rdtsc on ARMv8. CNTVCT_EL0 is the virtual counter of the
+                    // system timer. It runs at a different frequency than the CPU's, but is
+                    // the best source of time-based entropy we get.
+                    uint64_t virtual_timer_value;
+                    asm volatile("mrs %0, cntvct_el0"
+                                 : "=r"(virtual_timer_value));
+                    s += virtual_timer_value;
 #endif
 #endif  // !defined(GOOGLE_PROTOBUF_NO_RDTSC)
-      return s;
-    }
-
-    friend class Arena;
-    using InternalArenaConstructable_ = void;
-    using DestructorSkippable_ = void;
-
-    size_type num_elements_;
-    size_type num_buckets_;
-    size_type seed_;
-    size_type index_of_first_non_null_;
-    void** table_;  // an array with num_buckets_ entries
-    Allocator alloc_;
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(InnerMap);
-  };  // end of class InnerMap
-
-  template <typename LookupKey>
-  using key_arg = typename internal::TransparentSupport<
-      key_type>::template key_arg<LookupKey>;
-
- public:
-  // Iterators
-  class const_iterator {
-    using InnerIt = typename InnerMap::const_iterator;
-
-   public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = typename Map::value_type;
-    using difference_type = ptrdiff_t;
-    using pointer = const value_type*;
-    using reference = const value_type&;
-
-    const_iterator() {}
-    explicit const_iterator(const InnerIt& it) : it_(it) {}
-
-    const_reference operator*() const { return *it_; }
-    const_pointer operator->() const { return &(operator*()); }
-
-    const_iterator& operator++() {
-      ++it_;
-      return *this;
-    }
-    const_iterator operator++(int) { return const_iterator(it_++); }
-
-    friend bool operator==(const const_iterator& a, const const_iterator& b) {
-      return a.it_ == b.it_;
-    }
-    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
-      return !(a == b);
-    }
-
-   private:
-    InnerIt it_;
-  };
-
-  class iterator {
-    using InnerIt = typename InnerMap::iterator;
-
-   public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = typename Map::value_type;
-    using difference_type = ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
-
-    iterator() {}
-    explicit iterator(const InnerIt& it) : it_(it) {}
-
-    reference operator*() const { return *it_; }
-    pointer operator->() const { return &(operator*()); }
-
-    iterator& operator++() {
-      ++it_;
-      return *this;
-    }
-    iterator operator++(int) { return iterator(it_++); }
-
-    // Allow implicit conversion to const_iterator.
-    operator const_iterator() const {  // NOLINT(runtime/explicit)
-      return const_iterator(typename InnerMap::const_iterator(it_));
-    }
-
-    friend bool operator==(const iterator& a, const iterator& b) {
-      return a.it_ == b.it_;
-    }
-    friend bool operator!=(const iterator& a, const iterator& b) {
-      return !(a == b);
-    }
-
-   private:
-    friend class Map;
-
-    InnerIt it_;
-  };
-
-  iterator begin() { return iterator(elements_.begin()); }
-  iterator end() { return iterator(elements_.end()); }
-  const_iterator begin() const { return const_iterator(elements_.begin()); }
-  const_iterator end() const { return const_iterator(elements_.end()); }
-  const_iterator cbegin() const { return begin(); }
-  const_iterator cend() const { return end(); }
-
-  // Capacity
-  size_type size() const { return elements_.size(); }
-  bool empty() const { return size() == 0; }
-
-  // Element access
-  template <typename K = key_type>
-  T& operator[](const key_arg<K>& key) {
-    return elements_[key].second;
-  }
-  template <
-      typename K = key_type,
-      // Disable for integral types to reduce code bloat.
-      typename = typename std::enable_if<!std::is_integral<K>::value>::type>
-  T& operator[](key_arg<K>&& key) {
-    return elements_[std::forward<K>(key)].second;
-  }
-
-  template <typename K = key_type>
-  const T& at(const key_arg<K>& key) const {
-    const_iterator it = find(key);
-    GOOGLE_CHECK(it != end()) << "key not found: " << static_cast<Key>(key);
-    return it->second;
-  }
-
-  template <typename K = key_type>
-  T& at(const key_arg<K>& key) {
-    iterator it = find(key);
-    GOOGLE_CHECK(it != end()) << "key not found: " << static_cast<Key>(key);
-    return it->second;
-  }
-
-  // Lookup
-  template <typename K = key_type>
-  size_type count(const key_arg<K>& key) const {
-    return find(key) == end() ? 0 : 1;
-  }
-
-  template <typename K = key_type>
-  const_iterator find(const key_arg<K>& key) const {
-    return const_iterator(elements_.find(key));
-  }
-  template <typename K = key_type>
-  iterator find(const key_arg<K>& key) {
-    return iterator(elements_.find(key));
-  }
-
-  template <typename K = key_type>
-  bool contains(const key_arg<K>& key) const {
-    return find(key) != end();
-  }
-
-  template <typename K = key_type>
-  std::pair<const_iterator, const_iterator> equal_range(
-      const key_arg<K>& key) const {
-    const_iterator it = find(key);
-    if (it == end()) {
-      return std::pair<const_iterator, const_iterator>(it, it);
-    } else {
-      const_iterator begin = it++;
-      return std::pair<const_iterator, const_iterator>(begin, it);
-    }
-  }
-
-  template <typename K = key_type>
-  std::pair<iterator, iterator> equal_range(const key_arg<K>& key) {
-    iterator it = find(key);
-    if (it == end()) {
-      return std::pair<iterator, iterator>(it, it);
-    } else {
-      iterator begin = it++;
-      return std::pair<iterator, iterator>(begin, it);
-    }
-  }
-
-  // insert
-  template <typename K, typename... Args>
-  std::pair<iterator, bool> try_emplace(K&& k, Args&&... args) {
-    auto p =
-        elements_.try_emplace(std::forward<K>(k), std::forward<Args>(args)...);
-    return std::pair<iterator, bool>(iterator(p.first), p.second);
-  }
-  std::pair<iterator, bool> insert(const value_type& value) {
-    return try_emplace(value.first, value.second);
-  }
-  std::pair<iterator, bool> insert(value_type&& value) {
-    return try_emplace(value.first, std::move(value.second));
-  }
-  template <typename... Args>
-  std::pair<iterator, bool> emplace(Args&&... args) {
-    return insert(value_type(std::forward<Args>(args)...));
-  }
-  template <class InputIt>
-  void insert(InputIt first, InputIt last) {
-    for (; first != last; ++first) {
-      try_emplace(first->first, first->second);
-    }
-  }
-  void insert(std::initializer_list<value_type> values) {
-    insert(values.begin(), values.end());
-  }
-
-  // Erase and clear
-  template <typename K = key_type>
-  size_type erase(const key_arg<K>& key) {
-    iterator it = find(key);
-    if (it == end()) {
-      return 0;
-    } else {
-      erase(it);
-      return 1;
-    }
-  }
-  iterator erase(iterator pos) {
-    iterator i = pos++;
-    elements_.erase(i.it_);
-    return pos;
-  }
-  void erase(iterator first, iterator last) {
-    while (first != last) {
-      first = erase(first);
-    }
-  }
-  void clear() { elements_.clear(); }
-
-  // Assign
-  Map& operator=(const Map& other) {
-    if (this != &other) {
-      clear();
-      insert(other.begin(), other.end());
-    }
-    return *this;
-  }
-
-  void swap(Map& other) {
-    if (arena() == other.arena()) {
-      InternalSwap(other);
-    } else {
-      // TODO(zuguang): optimize this. The temporary copy can be allocated
-      // in the same arena as the other message, and the "other = copy" can
-      // be replaced with the fast-path swap above.
-      Map copy = *this;
-      *this = other;
-      other = copy;
-    }
-  }
-
-  void InternalSwap(Map& other) { elements_.Swap(&other.elements_); }
-
-  // Access to hasher.  Currently this returns a copy, but it may
-  // be modified to return a const reference in the future.
-  hasher hash_function() const { return elements_.hash_function(); }
-
-  size_t SpaceUsedExcludingSelfLong() const {
-    if (empty()) return 0;
-    return elements_.SpaceUsedInternal() + internal::SpaceUsedInValues(this);
-  }
-
- private:
-  Arena* arena() const { return elements_.arena(); }
-  InnerMap elements_;
-
-  friend class Arena;
-  using InternalArenaConstructable_ = void;
-  using DestructorSkippable_ = void;
-  template <typename Derived, typename K, typename V,
-            internal::WireFormatLite::FieldType key_wire_type,
-            internal::WireFormatLite::FieldType value_wire_type>
-  friend class internal::MapFieldLite;
-};
-
-}  // namespace protobuf
+                    return s;
+                }
+
+                friend class Arena;
+                using InternalArenaConstructable_ = void;
+                using DestructorSkippable_ = void;
+
+                size_type num_elements_;
+                size_type num_buckets_;
+                size_type seed_;
+                size_type index_of_first_non_null_;
+                void** table_;  // an array with num_buckets_ entries
+                Allocator alloc_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(InnerMap);
+            };  // end of class InnerMap
+
+            template<typename LookupKey>
+            using key_arg = typename internal::TransparentSupport<
+                key_type>::template key_arg<LookupKey>;
+
+        public:
+            // Iterators
+            class const_iterator
+            {
+                using InnerIt = typename InnerMap::const_iterator;
+
+            public:
+                using iterator_category = std::forward_iterator_tag;
+                using value_type = typename Map::value_type;
+                using difference_type = ptrdiff_t;
+                using pointer = const value_type*;
+                using reference = const value_type&;
+
+                const_iterator()
+                {
+                }
+                explicit const_iterator(const InnerIt& it) :
+                    it_(it)
+                {
+                }
+
+                const_reference operator*() const
+                {
+                    return *it_;
+                }
+                const_pointer operator->() const
+                {
+                    return &(operator*());
+                }
+
+                const_iterator& operator++()
+                {
+                    ++it_;
+                    return *this;
+                }
+                const_iterator operator++(int)
+                {
+                    return const_iterator(it_++);
+                }
+
+                friend bool operator==(const const_iterator& a, const const_iterator& b)
+                {
+                    return a.it_ == b.it_;
+                }
+                friend bool operator!=(const const_iterator& a, const const_iterator& b)
+                {
+                    return !(a == b);
+                }
+
+            private:
+                InnerIt it_;
+            };
+
+            class iterator
+            {
+                using InnerIt = typename InnerMap::iterator;
+
+            public:
+                using iterator_category = std::forward_iterator_tag;
+                using value_type = typename Map::value_type;
+                using difference_type = ptrdiff_t;
+                using pointer = value_type*;
+                using reference = value_type&;
+
+                iterator()
+                {
+                }
+                explicit iterator(const InnerIt& it) :
+                    it_(it)
+                {
+                }
+
+                reference operator*() const
+                {
+                    return *it_;
+                }
+                pointer operator->() const
+                {
+                    return &(operator*());
+                }
+
+                iterator& operator++()
+                {
+                    ++it_;
+                    return *this;
+                }
+                iterator operator++(int)
+                {
+                    return iterator(it_++);
+                }
+
+                // Allow implicit conversion to const_iterator.
+                operator const_iterator() const
+                {  // NOLINT(runtime/explicit)
+                    return const_iterator(typename InnerMap::const_iterator(it_));
+                }
+
+                friend bool operator==(const iterator& a, const iterator& b)
+                {
+                    return a.it_ == b.it_;
+                }
+                friend bool operator!=(const iterator& a, const iterator& b)
+                {
+                    return !(a == b);
+                }
+
+            private:
+                friend class Map;
+
+                InnerIt it_;
+            };
+
+            iterator begin()
+            {
+                return iterator(elements_.begin());
+            }
+            iterator end()
+            {
+                return iterator(elements_.end());
+            }
+            const_iterator begin() const
+            {
+                return const_iterator(elements_.begin());
+            }
+            const_iterator end() const
+            {
+                return const_iterator(elements_.end());
+            }
+            const_iterator cbegin() const
+            {
+                return begin();
+            }
+            const_iterator cend() const
+            {
+                return end();
+            }
+
+            // Capacity
+            size_type size() const
+            {
+                return elements_.size();
+            }
+            bool empty() const
+            {
+                return size() == 0;
+            }
+
+            // Element access
+            template<typename K = key_type>
+            T& operator[](const key_arg<K>& key)
+            {
+                return elements_[key].second;
+            }
+            template<
+                typename K = key_type,
+                // Disable for integral types to reduce code bloat.
+                typename = typename std::enable_if<!std::is_integral<K>::value>::type>
+            T& operator[](key_arg<K>&& key)
+            {
+                return elements_[std::forward<K>(key)].second;
+            }
+
+            template<typename K = key_type>
+            const T& at(const key_arg<K>& key) const
+            {
+                const_iterator it = find(key);
+                GOOGLE_CHECK(it != end()) << "key not found: " << static_cast<Key>(key);
+                return it->second;
+            }
+
+            template<typename K = key_type>
+            T& at(const key_arg<K>& key)
+            {
+                iterator it = find(key);
+                GOOGLE_CHECK(it != end()) << "key not found: " << static_cast<Key>(key);
+                return it->second;
+            }
+
+            // Lookup
+            template<typename K = key_type>
+            size_type count(const key_arg<K>& key) const
+            {
+                return find(key) == end() ? 0 : 1;
+            }
+
+            template<typename K = key_type>
+            const_iterator find(const key_arg<K>& key) const
+            {
+                return const_iterator(elements_.find(key));
+            }
+            template<typename K = key_type>
+            iterator find(const key_arg<K>& key)
+            {
+                return iterator(elements_.find(key));
+            }
+
+            template<typename K = key_type>
+            bool contains(const key_arg<K>& key) const
+            {
+                return find(key) != end();
+            }
+
+            template<typename K = key_type>
+            std::pair<const_iterator, const_iterator> equal_range(
+                const key_arg<K>& key
+            ) const
+            {
+                const_iterator it = find(key);
+                if (it == end())
+                {
+                    return std::pair<const_iterator, const_iterator>(it, it);
+                }
+                else
+                {
+                    const_iterator begin = it++;
+                    return std::pair<const_iterator, const_iterator>(begin, it);
+                }
+            }
+
+            template<typename K = key_type>
+            std::pair<iterator, iterator> equal_range(const key_arg<K>& key)
+            {
+                iterator it = find(key);
+                if (it == end())
+                {
+                    return std::pair<iterator, iterator>(it, it);
+                }
+                else
+                {
+                    iterator begin = it++;
+                    return std::pair<iterator, iterator>(begin, it);
+                }
+            }
+
+            // insert
+            template<typename K, typename... Args>
+            std::pair<iterator, bool> try_emplace(K&& k, Args&&... args)
+            {
+                auto p =
+                    elements_.try_emplace(std::forward<K>(k), std::forward<Args>(args)...);
+                return std::pair<iterator, bool>(iterator(p.first), p.second);
+            }
+            std::pair<iterator, bool> insert(const value_type& value)
+            {
+                return try_emplace(value.first, value.second);
+            }
+            std::pair<iterator, bool> insert(value_type&& value)
+            {
+                return try_emplace(value.first, std::move(value.second));
+            }
+            template<typename... Args>
+            std::pair<iterator, bool> emplace(Args&&... args)
+            {
+                return insert(value_type(std::forward<Args>(args)...));
+            }
+            template<class InputIt>
+            void insert(InputIt first, InputIt last)
+            {
+                for (; first != last; ++first)
+                {
+                    try_emplace(first->first, first->second);
+                }
+            }
+            void insert(std::initializer_list<value_type> values)
+            {
+                insert(values.begin(), values.end());
+            }
+
+            // Erase and clear
+            template<typename K = key_type>
+            size_type erase(const key_arg<K>& key)
+            {
+                iterator it = find(key);
+                if (it == end())
+                {
+                    return 0;
+                }
+                else
+                {
+                    erase(it);
+                    return 1;
+                }
+            }
+            iterator erase(iterator pos)
+            {
+                iterator i = pos++;
+                elements_.erase(i.it_);
+                return pos;
+            }
+            void erase(iterator first, iterator last)
+            {
+                while (first != last)
+                {
+                    first = erase(first);
+                }
+            }
+            void clear()
+            {
+                elements_.clear();
+            }
+
+            // Assign
+            Map& operator=(const Map& other)
+            {
+                if (this != &other)
+                {
+                    clear();
+                    insert(other.begin(), other.end());
+                }
+                return *this;
+            }
+
+            void swap(Map& other)
+            {
+                if (arena() == other.arena())
+                {
+                    InternalSwap(other);
+                }
+                else
+                {
+                    // TODO(zuguang): optimize this. The temporary copy can be allocated
+                    // in the same arena as the other message, and the "other = copy" can
+                    // be replaced with the fast-path swap above.
+                    Map copy = *this;
+                    *this = other;
+                    other = copy;
+                }
+            }
+
+            void InternalSwap(Map& other)
+            {
+                elements_.Swap(&other.elements_);
+            }
+
+            // Access to hasher.  Currently this returns a copy, but it may
+            // be modified to return a const reference in the future.
+            hasher hash_function() const
+            {
+                return elements_.hash_function();
+            }
+
+            size_t SpaceUsedExcludingSelfLong() const
+            {
+                if (empty())
+                    return 0;
+                return elements_.SpaceUsedInternal() + internal::SpaceUsedInValues(this);
+            }
+
+        private:
+            Arena* arena() const
+            {
+                return elements_.arena();
+            }
+            InnerMap elements_;
+
+            friend class Arena;
+            using InternalArenaConstructable_ = void;
+            using DestructorSkippable_ = void;
+            template<typename Derived, typename K, typename V, internal::WireFormatLite::FieldType key_wire_type, internal::WireFormatLite::FieldType value_wire_type>
+            friend class internal::MapFieldLite;
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_entry.h b/CAPI/cpp/grpc/include/google/protobuf/map_entry.h
index 536dec9..d7edcab 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/map_entry.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_entry.h
@@ -46,87 +46,91 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-class Arena;
-namespace internal {
-template <typename Derived, typename Key, typename Value,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-class MapField;
-}
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        class Arena;
+        namespace internal
+        {
+            template<typename Derived, typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            class MapField;
+        }
+    }  // namespace protobuf
 }  // namespace google
 
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
-// MapEntry is the returned google::protobuf::Message when calling AddMessage of
-// google::protobuf::Reflection. In order to let it work with generated message
-// reflection, its in-memory type is the same as generated message with the same
-// fields. However, in order to decide the in-memory type of key/value, we need
-// to know both their cpp type in generated api and proto type. In
-// implementation, all in-memory types have related wire format functions to
-// support except ArenaStringPtr. Therefore, we need to define another type with
-// supporting wire format functions. Since this type is only used as return type
-// of MapEntry accessors, it's named MapEntry accessor type.
-//
-// cpp type:               the type visible to users in public API.
-// proto type:             WireFormatLite::FieldType of the field.
-// in-memory type:         type of the data member used to stored this field.
-// MapEntry accessor type: type used in MapEntry getters/mutators to access the
-//                         field.
-//
-// cpp type | proto type  | in-memory type | MapEntry accessor type
-// int32_t    TYPE_INT32    int32_t          int32_t
-// int32_t    TYPE_FIXED32  int32_t          int32_t
-// string     TYPE_STRING   ArenaStringPtr   string
-// FooEnum    TYPE_ENUM     int              int
-// FooMessage TYPE_MESSAGE  FooMessage*      FooMessage
-//
-// The in-memory types of primitive types can be inferred from its proto type,
-// while we need to explicitly specify the cpp type if proto type is
-// TYPE_MESSAGE to infer the in-memory type.
-template <typename Derived, typename Key, typename Value,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-class MapEntry : public MapEntryImpl<Derived, Message, Key, Value,
-                                     kKeyFieldType, kValueFieldType> {
- public:
-  constexpr MapEntry() {}
-  explicit MapEntry(Arena* arena)
-      : MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType,
-                     kValueFieldType>(arena) {}
-  ~MapEntry() override {
-    Message::_internal_metadata_.template Delete<UnknownFieldSet>();
-  }
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
+            // MapEntry is the returned google::protobuf::Message when calling AddMessage of
+            // google::protobuf::Reflection. In order to let it work with generated message
+            // reflection, its in-memory type is the same as generated message with the same
+            // fields. However, in order to decide the in-memory type of key/value, we need
+            // to know both their cpp type in generated api and proto type. In
+            // implementation, all in-memory types have related wire format functions to
+            // support except ArenaStringPtr. Therefore, we need to define another type with
+            // supporting wire format functions. Since this type is only used as return type
+            // of MapEntry accessors, it's named MapEntry accessor type.
+            //
+            // cpp type:               the type visible to users in public API.
+            // proto type:             WireFormatLite::FieldType of the field.
+            // in-memory type:         type of the data member used to stored this field.
+            // MapEntry accessor type: type used in MapEntry getters/mutators to access the
+            //                         field.
+            //
+            // cpp type | proto type  | in-memory type | MapEntry accessor type
+            // int32_t    TYPE_INT32    int32_t          int32_t
+            // int32_t    TYPE_FIXED32  int32_t          int32_t
+            // string     TYPE_STRING   ArenaStringPtr   string
+            // FooEnum    TYPE_ENUM     int              int
+            // FooMessage TYPE_MESSAGE  FooMessage*      FooMessage
+            //
+            // The in-memory types of primitive types can be inferred from its proto type,
+            // while we need to explicitly specify the cpp type if proto type is
+            // TYPE_MESSAGE to infer the in-memory type.
+            template<typename Derived, typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            class MapEntry : public MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, kValueFieldType>
+            {
+            public:
+                constexpr MapEntry()
+                {
+                }
+                explicit MapEntry(Arena* arena) :
+                    MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, kValueFieldType>(arena)
+                {
+                }
+                ~MapEntry() override
+                {
+                    Message::_internal_metadata_.template Delete<UnknownFieldSet>();
+                }
+                typedef void InternalArenaConstructable_;
+                typedef void DestructorSkippable_;
 
-  typedef typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType,
-                                kValueFieldType>::KeyTypeHandler KeyTypeHandler;
-  typedef
-      typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType,
-                            kValueFieldType>::ValueTypeHandler ValueTypeHandler;
-  size_t SpaceUsedLong() const override {
-    size_t size = sizeof(Derived);
-    size += KeyTypeHandler::SpaceUsedInMapEntryLong(this->key_);
-    size += ValueTypeHandler::SpaceUsedInMapEntryLong(this->value_);
-    return size;
-  }
+                typedef typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, kValueFieldType>::KeyTypeHandler KeyTypeHandler;
+                typedef
+                    typename MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType, kValueFieldType>::ValueTypeHandler ValueTypeHandler;
+                size_t SpaceUsedLong() const override
+                {
+                    size_t size = sizeof(Derived);
+                    size += KeyTypeHandler::SpaceUsedInMapEntryLong(this->key_);
+                    size += ValueTypeHandler::SpaceUsedInMapEntryLong(this->value_);
+                    return size;
+                }
 
- private:
-  friend class ::PROTOBUF_NAMESPACE_ID::Arena;
-  template <typename C, typename K, typename V,
-            WireFormatLite::FieldType k_wire_type, WireFormatLite::FieldType>
-  friend class internal::MapField;
+            private:
+                friend class ::PROTOBUF_NAMESPACE_ID::Arena;
+                template<typename C, typename K, typename V, WireFormatLite::FieldType k_wire_type, WireFormatLite::FieldType>
+                friend class internal::MapField;
 
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntry);
-};
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntry);
+            };
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_entry_lite.h b/CAPI/cpp/grpc/include/google/protobuf/map_entry_lite.h
index 6b08cd9..a074039 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/map_entry_lite.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_entry_lite.h
@@ -54,508 +54,679 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-namespace internal {
-template <typename Derived, typename Key, typename Value,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-class MapEntry;
-template <typename Derived, typename Key, typename Value,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-class MapFieldLite;
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+            template<typename Derived, typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            class MapEntry;
+            template<typename Derived, typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            class MapFieldLite;
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// MoveHelper::Move is used to set *dest.  It copies *src, or moves it (in
-// the C++11 sense), or swaps it. *src is left in a sane state for
-// subsequent destruction, but shouldn't be used for anything.
-template <bool is_enum, bool is_message, bool is_stringlike, typename T>
-struct MoveHelper {  // primitives
-  static void Move(T* src, T* dest) { *dest = *src; }
-};
-
-template <bool is_message, bool is_stringlike, typename T>
-struct MoveHelper<true, is_message, is_stringlike, T> {  // enums
-  static void Move(T* src, T* dest) { *dest = *src; }
-  // T is an enum here, so allow conversions to and from int.
-  static void Move(T* src, int* dest) { *dest = static_cast<int>(*src); }
-  static void Move(int* src, T* dest) { *dest = static_cast<T>(*src); }
-};
-
-template <bool is_stringlike, typename T>
-struct MoveHelper<false, true, is_stringlike, T> {  // messages
-  static void Move(T* src, T* dest) { dest->Swap(src); }
-};
-
-template <typename T>
-struct MoveHelper<false, false, true, T> {  // strings and similar
-  static void Move(T* src, T* dest) {
-    *dest = std::move(*src);
-  }
-};
-
-// MapEntryImpl is used to implement parsing and serialization of map entries.
-// It uses Curious Recursive Template Pattern (CRTP) to provide the type of
-// the eventual code to the template code.
-template <typename Derived, typename Base, typename Key, typename Value,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-class MapEntryImpl : public Base {
- public:
-  typedef MapEntryFuncs<Key, Value, kKeyFieldType, kValueFieldType> Funcs;
-
- protected:
-  // Provide utilities to parse/serialize key/value.  Provide utilities to
-  // manipulate internal stored type.
-  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
-  typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
-
-  // Define internal memory layout. Strings and messages are stored as
-  // pointers, while other types are stored as values.
-  typedef typename KeyTypeHandler::TypeOnMemory KeyOnMemory;
-  typedef typename ValueTypeHandler::TypeOnMemory ValueOnMemory;
-
-  // Enum type cannot be used for MapTypeHandler::Read. Define a type
-  // which will replace Enum with int.
-  typedef typename KeyTypeHandler::MapEntryAccessorType KeyMapEntryAccessorType;
-  typedef
-      typename ValueTypeHandler::MapEntryAccessorType ValueMapEntryAccessorType;
-
-  // Constants for field number.
-  static const int kKeyFieldNumber = 1;
-  static const int kValueFieldNumber = 2;
-
-  // Constants for field tag.
-  static const uint8_t kKeyTag =
-      GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kKeyFieldNumber, KeyTypeHandler::kWireType);
-  static const uint8_t kValueTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
-      kValueFieldNumber, ValueTypeHandler::kWireType);
-  static const size_t kTagSize = 1;
-
- public:
-  // Work-around for a compiler bug (see repeated_field.h).
-  typedef void MapEntryHasMergeTypeTrait;
-  typedef Derived EntryType;
-  typedef Key EntryKeyType;
-  typedef Value EntryValueType;
-  static const WireFormatLite::FieldType kEntryKeyFieldType = kKeyFieldType;
-  static const WireFormatLite::FieldType kEntryValueFieldType = kValueFieldType;
-
-  constexpr MapEntryImpl()
-      : key_(KeyTypeHandler::Constinit()),
-        value_(ValueTypeHandler::Constinit()),
-        _has_bits_{} {}
-
-  explicit MapEntryImpl(Arena* arena)
-      : Base(arena),
-        key_(KeyTypeHandler::Constinit()),
-        value_(ValueTypeHandler::Constinit()),
-        _has_bits_{} {}
-
-  ~MapEntryImpl() override {
-    if (Base::GetArenaForAllocation() != nullptr) return;
-    KeyTypeHandler::DeleteNoArena(key_);
-    ValueTypeHandler::DeleteNoArena(value_);
-  }
-
-  // accessors ======================================================
-
-  virtual inline const KeyMapEntryAccessorType& key() const {
-    return KeyTypeHandler::GetExternalReference(key_);
-  }
-  virtual inline const ValueMapEntryAccessorType& value() const {
-    return ValueTypeHandler::DefaultIfNotInitialized(value_);
-  }
-  inline KeyMapEntryAccessorType* mutable_key() {
-    set_has_key();
-    return KeyTypeHandler::EnsureMutable(&key_, Base::GetArenaForAllocation());
-  }
-  inline ValueMapEntryAccessorType* mutable_value() {
-    set_has_value();
-    return ValueTypeHandler::EnsureMutable(&value_,
-                                           Base::GetArenaForAllocation());
-  }
-
-  // implements MessageLite =========================================
-
-  // MapEntryImpl is for implementation only and this function isn't called
-  // anywhere. Just provide a fake implementation here for MessageLite.
-  std::string GetTypeName() const override { return ""; }
-
-  void CheckTypeAndMergeFrom(const MessageLite& other) override {
-    MergeFromInternal(*::google::protobuf::internal::DownCast<const Derived*>(&other));
-  }
-
-  const char* _InternalParse(const char* ptr, ParseContext* ctx) final {
-    while (!ctx->Done(&ptr)) {
-      uint32_t tag;
-      ptr = ReadTag(ptr, &tag);
-      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-      if (tag == kKeyTag) {
-        set_has_key();
-        KeyMapEntryAccessorType* key = mutable_key();
-        ptr = KeyTypeHandler::Read(ptr, ctx, key);
-        if (!Derived::ValidateKey(key)) return nullptr;
-      } else if (tag == kValueTag) {
-        set_has_value();
-        ValueMapEntryAccessorType* value = mutable_value();
-        ptr = ValueTypeHandler::Read(ptr, ctx, value);
-        if (!Derived::ValidateValue(value)) return nullptr;
-      } else {
-        if (tag == 0 || WireFormatLite::GetTagWireType(tag) ==
-                            WireFormatLite::WIRETYPE_END_GROUP) {
-          ctx->SetLastTag(tag);
-          return ptr;
-        }
-        ptr = UnknownFieldParse(tag, static_cast<std::string*>(nullptr), ptr,
-                                ctx);
-      }
-      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-    }
-    return ptr;
-  }
-
-  size_t ByteSizeLong() const override {
-    size_t size = 0;
-    size += kTagSize + static_cast<size_t>(KeyTypeHandler::ByteSize(key()));
-    size += kTagSize + static_cast<size_t>(ValueTypeHandler::ByteSize(value()));
-    return size;
-  }
-
-  ::uint8_t* _InternalSerialize(
-      ::uint8_t* ptr, io::EpsCopyOutputStream* stream) const override {
-    ptr = KeyTypeHandler::Write(kKeyFieldNumber, key(), ptr, stream);
-    return ValueTypeHandler::Write(kValueFieldNumber, value(), ptr, stream);
-  }
-
-  // Don't override SerializeWithCachedSizesToArray.  Use MessageLite's.
-
-  int GetCachedSize() const override {
-    int size = 0;
-    size += has_key() ? static_cast<int>(kTagSize) +
-                            KeyTypeHandler::GetCachedSize(key())
-                      : 0;
-    size += has_value() ? static_cast<int>(kTagSize) +
-                              ValueTypeHandler::GetCachedSize(value())
-                        : 0;
-    return size;
-  }
-
-  bool IsInitialized() const override {
-    return ValueTypeHandler::IsInitialized(value_);
-  }
-
-  Base* New(Arena* arena) const override {
-    Derived* entry = Arena::CreateMessage<Derived>(arena);
-    return entry;
-  }
-
- protected:
-  // We can't declare this function directly here as it would hide the other
-  // overload (const Message&).
-  void MergeFromInternal(const MapEntryImpl& from) {
-    if (from._has_bits_[0]) {
-      if (from.has_key()) {
-        KeyTypeHandler::EnsureMutable(&key_, Base::GetArenaForAllocation());
-        KeyTypeHandler::Merge(from.key(), &key_, Base::GetArenaForAllocation());
-        set_has_key();
-      }
-      if (from.has_value()) {
-        ValueTypeHandler::EnsureMutable(&value_, Base::GetArenaForAllocation());
-        ValueTypeHandler::Merge(from.value(), &value_,
-                                Base::GetArenaForAllocation());
-        set_has_value();
-      }
-    }
-  }
-
- public:
-  void Clear() override {
-    KeyTypeHandler::Clear(&key_, Base::GetArenaForAllocation());
-    ValueTypeHandler::Clear(&value_, Base::GetArenaForAllocation());
-    clear_has_key();
-    clear_has_value();
-  }
-
-  // Parsing using MergePartialFromCodedStream, above, is not as
-  // efficient as it could be.  This helper class provides a speedier way.
-  template <typename MapField, typename Map>
-  class Parser {
-   public:
-    explicit Parser(MapField* mf) : mf_(mf), map_(mf->MutableMap()) {}
-    ~Parser() {
-      if (entry_ != nullptr && entry_->GetArenaForAllocation() == nullptr)
-        delete entry_;
-    }
-
-    const char* _InternalParse(const char* ptr, ParseContext* ctx) {
-      if (PROTOBUF_PREDICT_TRUE(!ctx->Done(&ptr) && *ptr == kKeyTag)) {
-        ptr = KeyTypeHandler::Read(ptr + 1, ctx, &key_);
-        if (PROTOBUF_PREDICT_FALSE(!ptr || !Derived::ValidateKey(&key_))) {
-          return nullptr;
-        }
-        if (PROTOBUF_PREDICT_TRUE(!ctx->Done(&ptr) && *ptr == kValueTag)) {
-          typename Map::size_type map_size = map_->size();
-          value_ptr_ = &(*map_)[key_];
-          if (PROTOBUF_PREDICT_TRUE(map_size != map_->size())) {
-            using T =
-                typename MapIf<ValueTypeHandler::kIsEnum, int*, Value*>::type;
-            ptr = ValueTypeHandler::Read(ptr + 1, ctx,
-                                         reinterpret_cast<T>(value_ptr_));
-            if (PROTOBUF_PREDICT_FALSE(!ptr ||
-                                       !Derived::ValidateValue(value_ptr_))) {
-              map_->erase(key_);  // Failure! Undo insertion.
-              return nullptr;
-            }
-            if (PROTOBUF_PREDICT_TRUE(ctx->Done(&ptr))) return ptr;
-            if (!ptr) return nullptr;
-            NewEntry();
-            ValueMover::Move(value_ptr_, entry_->mutable_value());
-            map_->erase(key_);
-            goto move_key;
-          }
-        } else {
-          if (!ptr) return nullptr;
-        }
-        NewEntry();
-      move_key:
-        KeyMover::Move(&key_, entry_->mutable_key());
-      } else {
-        if (!ptr) return nullptr;
-        NewEntry();
-      }
-      ptr = entry_->_InternalParse(ptr, ctx);
-      if (ptr) UseKeyAndValueFromEntry();
-      return ptr;
-    }
-
-    template <typename UnknownType>
-    const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
-                                        bool (*is_valid)(int),
-                                        uint32_t field_num,
-                                        InternalMetadata* metadata) {
-      auto entry = NewEntry();
-      ptr = entry->_InternalParse(ptr, ctx);
-      if (!ptr) return nullptr;
-      if (is_valid(entry->value())) {
-        UseKeyAndValueFromEntry();
-      } else {
-        WriteLengthDelimited(field_num, entry->SerializeAsString(),
-                             metadata->mutable_unknown_fields<UnknownType>());
-      }
-      return ptr;
-    }
-
-    MapEntryImpl* NewEntry() { return entry_ = mf_->NewEntry(); }
-
-    const Key& key() const { return key_; }
-    const Value& value() const { return *value_ptr_; }
-
-    const Key& entry_key() const { return entry_->key(); }
-    const Value& entry_value() const { return entry_->value(); }
-
-   private:
-    void UseKeyAndValueFromEntry() {
-      // Update key_ in case we need it later (because key() is called).
-      // This is potentially inefficient, especially if the key is
-      // expensive to copy (e.g., a long string), but this is a cold
-      // path, so it's not a big deal.
-      key_ = entry_->key();
-      value_ptr_ = &(*map_)[key_];
-      ValueMover::Move(entry_->mutable_value(), value_ptr_);
-    }
-
-    // After reading a key and value successfully, and inserting that data
-    // into map_, we are not at the end of the input.  This is unusual, but
-    // allowed by the spec.
-    bool ReadBeyondKeyValuePair(io::CodedInputStream* input) PROTOBUF_COLD {
-      NewEntry();
-      ValueMover::Move(value_ptr_, entry_->mutable_value());
-      map_->erase(key_);
-      KeyMover::Move(&key_, entry_->mutable_key());
-      const bool result = entry_->MergePartialFromCodedStream(input);
-      if (result) UseKeyAndValueFromEntry();
-      return result;
-    }
-
-    typedef MoveHelper<KeyTypeHandler::kIsEnum, KeyTypeHandler::kIsMessage,
-                       KeyTypeHandler::kWireType ==
-                           WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-                       Key>
-        KeyMover;
-    typedef MoveHelper<ValueTypeHandler::kIsEnum, ValueTypeHandler::kIsMessage,
-                       ValueTypeHandler::kWireType ==
-                           WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-                       Value>
-        ValueMover;
-
-    MapField* const mf_;
-    Map* const map_;
-    Key key_;
-    Value* value_ptr_;
-    MapEntryImpl* entry_ = nullptr;
-  };
-
- protected:
-  void set_has_key() { _has_bits_[0] |= 0x00000001u; }
-  bool has_key() const { return (_has_bits_[0] & 0x00000001u) != 0; }
-  void clear_has_key() { _has_bits_[0] &= ~0x00000001u; }
-  void set_has_value() { _has_bits_[0] |= 0x00000002u; }
-  bool has_value() const { return (_has_bits_[0] & 0x00000002u) != 0; }
-  void clear_has_value() { _has_bits_[0] &= ~0x00000002u; }
-
- public:
-  inline Arena* GetArena() const { return Base::GetArena(); }
-
- protected:  // Needed for constructing tables
-  KeyOnMemory key_;
-  ValueOnMemory value_;
-  uint32_t _has_bits_[1];
-
- private:
-  friend class ::PROTOBUF_NAMESPACE_ID::Arena;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  template <typename C, typename K, typename V, WireFormatLite::FieldType,
-            WireFormatLite::FieldType>
-  friend class internal::MapEntry;
-  template <typename C, typename K, typename V, WireFormatLite::FieldType,
-            WireFormatLite::FieldType>
-  friend class internal::MapFieldLite;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryImpl);
-};
-
-template <typename T, typename Key, typename Value,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-class MapEntryLite : public MapEntryImpl<T, MessageLite, Key, Value,
-                                         kKeyFieldType, kValueFieldType> {
- public:
-  typedef MapEntryImpl<T, MessageLite, Key, Value, kKeyFieldType,
-                       kValueFieldType>
-      SuperType;
-  constexpr MapEntryLite() {}
-  explicit MapEntryLite(Arena* arena) : SuperType(arena) {}
-  ~MapEntryLite() override {
-    MessageLite::_internal_metadata_.template Delete<std::string>();
-  }
-  void MergeFrom(const MapEntryLite& other) { MergeFromInternal(other); }
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryLite);
-};
-
-// Helpers for deterministic serialization =============================
-
-// Iterator base for MapSorterFlat and MapSorterPtr.
-template <typename storage_type>
-struct MapSorterIt {
-  storage_type* ptr;
-  MapSorterIt(storage_type* ptr) : ptr(ptr) {}
-  bool operator==(const MapSorterIt& other) const { return ptr == other.ptr; }
-  bool operator!=(const MapSorterIt& other) const { return !(*this == other); }
-  MapSorterIt& operator++() { ++ptr; return *this; }
-  MapSorterIt operator++(int) { auto other = *this; ++ptr; return other; }
-  MapSorterIt operator+(int v) { return MapSorterIt{ptr + v}; }
-};
-
-// MapSorterFlat stores keys inline with pointers to map entries, so that
-// keys can be compared without indirection. This type is used for maps with
-// keys that are not strings.
-template <typename MapT>
-class MapSorterFlat {
- public:
-  using value_type = typename MapT::value_type;
-  using storage_type = std::pair<typename MapT::key_type, const value_type*>;
-
-  // This const_iterator dereferenes to the map entry stored in the sorting
-  // array pairs. This is the same interface as the Map::const_iterator type,
-  // and allows generated code to use the same loop body with either form:
-  //   for (const auto& entry : map) { ... }
-  //   for (const auto& entry : MapSorterFlat(map)) { ... }
-  struct const_iterator : public MapSorterIt<storage_type> {
-    using pointer = const typename MapT::value_type*;
-    using reference = const typename MapT::value_type&;
-    using MapSorterIt<storage_type>::MapSorterIt;
-
-    pointer operator->() const { return this->ptr->second; }
-    reference operator*() const { return *this->operator->(); }
-  };
-
-  explicit MapSorterFlat(const MapT& m)
-      : size_(m.size()), items_(size_ ? new storage_type[size_] : nullptr) {
-    if (!size_) return;
-    storage_type* it = &items_[0];
-    for (const auto& entry : m) {
-      *it++ = {entry.first, &entry};
-    }
-    std::sort(&items_[0], &items_[size_],
-              [](const storage_type& a, const storage_type& b) {
-                return a.first < b.first;
-              });
-  }
-  size_t size() const { return size_; }
-  const_iterator begin() const { return {items_.get()}; }
-  const_iterator end() const { return {items_.get() + size_}; }
-
- private:
-  size_t size_;
-  std::unique_ptr<storage_type[]> items_;
-};
-
-// MapSorterPtr stores and sorts pointers to map entries. This type is used for
-// maps with keys that are strings.
-template <typename MapT>
-class MapSorterPtr {
- public:
-  using value_type = typename MapT::value_type;
-  using storage_type = const typename MapT::value_type*;
-
-  // This const_iterator dereferenes the map entry pointer stored in the sorting
-  // array. This is the same interface as the Map::const_iterator type, and
-  // allows generated code to use the same loop body with either form:
-  //   for (const auto& entry : map) { ... }
-  //   for (const auto& entry : MapSorterPtr(map)) { ... }
-  struct const_iterator : public MapSorterIt<storage_type> {
-    using pointer = const typename MapT::value_type*;
-    using reference = const typename MapT::value_type&;
-    using MapSorterIt<storage_type>::MapSorterIt;
-
-    pointer operator->() const { return *this->ptr; }
-    reference operator*() const { return *this->operator->(); }
-  };
-
-  explicit MapSorterPtr(const MapT& m)
-      : size_(m.size()), items_(size_ ? new storage_type[size_] : nullptr) {
-    if (!size_) return;
-    storage_type* it = &items_[0];
-    for (const auto& entry : m) {
-      *it++ = &entry;
-    }
-    std::sort(&items_[0], &items_[size_],
-              [](const storage_type& a, const storage_type& b) {
-                return a->first < b->first;
-              });
-  }
-  size_t size() const { return size_; }
-  const_iterator begin() const { return {items_.get()}; }
-  const_iterator end() const { return {items_.get() + size_}; }
-
- private:
-  size_t size_;
-  std::unique_ptr<storage_type[]> items_;
-};
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // MoveHelper::Move is used to set *dest.  It copies *src, or moves it (in
+            // the C++11 sense), or swaps it. *src is left in a sane state for
+            // subsequent destruction, but shouldn't be used for anything.
+            template<bool is_enum, bool is_message, bool is_stringlike, typename T>
+            struct MoveHelper
+            {  // primitives
+                static void Move(T* src, T* dest)
+                {
+                    *dest = *src;
+                }
+            };
+
+            template<bool is_message, bool is_stringlike, typename T>
+            struct MoveHelper<true, is_message, is_stringlike, T>
+            {  // enums
+                static void Move(T* src, T* dest)
+                {
+                    *dest = *src;
+                }
+                // T is an enum here, so allow conversions to and from int.
+                static void Move(T* src, int* dest)
+                {
+                    *dest = static_cast<int>(*src);
+                }
+                static void Move(int* src, T* dest)
+                {
+                    *dest = static_cast<T>(*src);
+                }
+            };
+
+            template<bool is_stringlike, typename T>
+            struct MoveHelper<false, true, is_stringlike, T>
+            {  // messages
+                static void Move(T* src, T* dest)
+                {
+                    dest->Swap(src);
+                }
+            };
+
+            template<typename T>
+            struct MoveHelper<false, false, true, T>
+            {  // strings and similar
+                static void Move(T* src, T* dest)
+                {
+                    *dest = std::move(*src);
+                }
+            };
+
+            // MapEntryImpl is used to implement parsing and serialization of map entries.
+            // It uses Curious Recursive Template Pattern (CRTP) to provide the type of
+            // the eventual code to the template code.
+            template<typename Derived, typename Base, typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            class MapEntryImpl : public Base
+            {
+            public:
+                typedef MapEntryFuncs<Key, Value, kKeyFieldType, kValueFieldType> Funcs;
+
+            protected:
+                // Provide utilities to parse/serialize key/value.  Provide utilities to
+                // manipulate internal stored type.
+                typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+                typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
+
+                // Define internal memory layout. Strings and messages are stored as
+                // pointers, while other types are stored as values.
+                typedef typename KeyTypeHandler::TypeOnMemory KeyOnMemory;
+                typedef typename ValueTypeHandler::TypeOnMemory ValueOnMemory;
+
+                // Enum type cannot be used for MapTypeHandler::Read. Define a type
+                // which will replace Enum with int.
+                typedef typename KeyTypeHandler::MapEntryAccessorType KeyMapEntryAccessorType;
+                typedef
+                    typename ValueTypeHandler::MapEntryAccessorType ValueMapEntryAccessorType;
+
+                // Constants for field number.
+                static const int kKeyFieldNumber = 1;
+                static const int kValueFieldNumber = 2;
+
+                // Constants for field tag.
+                static const uint8_t kKeyTag =
+                    GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kKeyFieldNumber, KeyTypeHandler::kWireType);
+                static const uint8_t kValueTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+                    kValueFieldNumber, ValueTypeHandler::kWireType
+                );
+                static const size_t kTagSize = 1;
+
+            public:
+                // Work-around for a compiler bug (see repeated_field.h).
+                typedef void MapEntryHasMergeTypeTrait;
+                typedef Derived EntryType;
+                typedef Key EntryKeyType;
+                typedef Value EntryValueType;
+                static const WireFormatLite::FieldType kEntryKeyFieldType = kKeyFieldType;
+                static const WireFormatLite::FieldType kEntryValueFieldType = kValueFieldType;
+
+                constexpr MapEntryImpl() :
+                    key_(KeyTypeHandler::Constinit()),
+                    value_(ValueTypeHandler::Constinit()),
+                    _has_bits_{}
+                {
+                }
+
+                explicit MapEntryImpl(Arena* arena) :
+                    Base(arena),
+                    key_(KeyTypeHandler::Constinit()),
+                    value_(ValueTypeHandler::Constinit()),
+                    _has_bits_{}
+                {
+                }
+
+                ~MapEntryImpl() override
+                {
+                    if (Base::GetArenaForAllocation() != nullptr)
+                        return;
+                    KeyTypeHandler::DeleteNoArena(key_);
+                    ValueTypeHandler::DeleteNoArena(value_);
+                }
+
+                // accessors ======================================================
+
+                virtual inline const KeyMapEntryAccessorType& key() const
+                {
+                    return KeyTypeHandler::GetExternalReference(key_);
+                }
+                virtual inline const ValueMapEntryAccessorType& value() const
+                {
+                    return ValueTypeHandler::DefaultIfNotInitialized(value_);
+                }
+                inline KeyMapEntryAccessorType* mutable_key()
+                {
+                    set_has_key();
+                    return KeyTypeHandler::EnsureMutable(&key_, Base::GetArenaForAllocation());
+                }
+                inline ValueMapEntryAccessorType* mutable_value()
+                {
+                    set_has_value();
+                    return ValueTypeHandler::EnsureMutable(&value_, Base::GetArenaForAllocation());
+                }
+
+                // implements MessageLite =========================================
+
+                // MapEntryImpl is for implementation only and this function isn't called
+                // anywhere. Just provide a fake implementation here for MessageLite.
+                std::string GetTypeName() const override
+                {
+                    return "";
+                }
+
+                void CheckTypeAndMergeFrom(const MessageLite& other) override
+                {
+                    MergeFromInternal(*::google::protobuf::internal::DownCast<const Derived*>(&other));
+                }
+
+                const char* _InternalParse(const char* ptr, ParseContext* ctx) final
+                {
+                    while (!ctx->Done(&ptr))
+                    {
+                        uint32_t tag;
+                        ptr = ReadTag(ptr, &tag);
+                        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                        if (tag == kKeyTag)
+                        {
+                            set_has_key();
+                            KeyMapEntryAccessorType* key = mutable_key();
+                            ptr = KeyTypeHandler::Read(ptr, ctx, key);
+                            if (!Derived::ValidateKey(key))
+                                return nullptr;
+                        }
+                        else if (tag == kValueTag)
+                        {
+                            set_has_value();
+                            ValueMapEntryAccessorType* value = mutable_value();
+                            ptr = ValueTypeHandler::Read(ptr, ctx, value);
+                            if (!Derived::ValidateValue(value))
+                                return nullptr;
+                        }
+                        else
+                        {
+                            if (tag == 0 || WireFormatLite::GetTagWireType(tag) ==
+                                                WireFormatLite::WIRETYPE_END_GROUP)
+                            {
+                                ctx->SetLastTag(tag);
+                                return ptr;
+                            }
+                            ptr = UnknownFieldParse(tag, static_cast<std::string*>(nullptr), ptr, ctx);
+                        }
+                        GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                    }
+                    return ptr;
+                }
+
+                size_t ByteSizeLong() const override
+                {
+                    size_t size = 0;
+                    size += kTagSize + static_cast<size_t>(KeyTypeHandler::ByteSize(key()));
+                    size += kTagSize + static_cast<size_t>(ValueTypeHandler::ByteSize(value()));
+                    return size;
+                }
+
+                ::uint8_t* _InternalSerialize(
+                    ::uint8_t* ptr, io::EpsCopyOutputStream* stream
+                ) const override
+                {
+                    ptr = KeyTypeHandler::Write(kKeyFieldNumber, key(), ptr, stream);
+                    return ValueTypeHandler::Write(kValueFieldNumber, value(), ptr, stream);
+                }
+
+                // Don't override SerializeWithCachedSizesToArray.  Use MessageLite's.
+
+                int GetCachedSize() const override
+                {
+                    int size = 0;
+                    size += has_key() ? static_cast<int>(kTagSize) +
+                                            KeyTypeHandler::GetCachedSize(key()) :
+                                        0;
+                    size += has_value() ? static_cast<int>(kTagSize) +
+                                              ValueTypeHandler::GetCachedSize(value()) :
+                                          0;
+                    return size;
+                }
+
+                bool IsInitialized() const override
+                {
+                    return ValueTypeHandler::IsInitialized(value_);
+                }
+
+                Base* New(Arena* arena) const override
+                {
+                    Derived* entry = Arena::CreateMessage<Derived>(arena);
+                    return entry;
+                }
+
+            protected:
+                // We can't declare this function directly here as it would hide the other
+                // overload (const Message&).
+                void MergeFromInternal(const MapEntryImpl& from)
+                {
+                    if (from._has_bits_[0])
+                    {
+                        if (from.has_key())
+                        {
+                            KeyTypeHandler::EnsureMutable(&key_, Base::GetArenaForAllocation());
+                            KeyTypeHandler::Merge(from.key(), &key_, Base::GetArenaForAllocation());
+                            set_has_key();
+                        }
+                        if (from.has_value())
+                        {
+                            ValueTypeHandler::EnsureMutable(&value_, Base::GetArenaForAllocation());
+                            ValueTypeHandler::Merge(from.value(), &value_, Base::GetArenaForAllocation());
+                            set_has_value();
+                        }
+                    }
+                }
+
+            public:
+                void Clear() override
+                {
+                    KeyTypeHandler::Clear(&key_, Base::GetArenaForAllocation());
+                    ValueTypeHandler::Clear(&value_, Base::GetArenaForAllocation());
+                    clear_has_key();
+                    clear_has_value();
+                }
+
+                // Parsing using MergePartialFromCodedStream, above, is not as
+                // efficient as it could be.  This helper class provides a speedier way.
+                template<typename MapField, typename Map>
+                class Parser
+                {
+                public:
+                    explicit Parser(MapField* mf) :
+                        mf_(mf),
+                        map_(mf->MutableMap())
+                    {
+                    }
+                    ~Parser()
+                    {
+                        if (entry_ != nullptr && entry_->GetArenaForAllocation() == nullptr)
+                            delete entry_;
+                    }
+
+                    const char* _InternalParse(const char* ptr, ParseContext* ctx)
+                    {
+                        if (PROTOBUF_PREDICT_TRUE(!ctx->Done(&ptr) && *ptr == kKeyTag))
+                        {
+                            ptr = KeyTypeHandler::Read(ptr + 1, ctx, &key_);
+                            if (PROTOBUF_PREDICT_FALSE(!ptr || !Derived::ValidateKey(&key_)))
+                            {
+                                return nullptr;
+                            }
+                            if (PROTOBUF_PREDICT_TRUE(!ctx->Done(&ptr) && *ptr == kValueTag))
+                            {
+                                typename Map::size_type map_size = map_->size();
+                                value_ptr_ = &(*map_)[key_];
+                                if (PROTOBUF_PREDICT_TRUE(map_size != map_->size()))
+                                {
+                                    using T =
+                                        typename MapIf<ValueTypeHandler::kIsEnum, int*, Value*>::type;
+                                    ptr = ValueTypeHandler::Read(ptr + 1, ctx, reinterpret_cast<T>(value_ptr_));
+                                    if (PROTOBUF_PREDICT_FALSE(!ptr || !Derived::ValidateValue(value_ptr_)))
+                                    {
+                                        map_->erase(key_);  // Failure! Undo insertion.
+                                        return nullptr;
+                                    }
+                                    if (PROTOBUF_PREDICT_TRUE(ctx->Done(&ptr)))
+                                        return ptr;
+                                    if (!ptr)
+                                        return nullptr;
+                                    NewEntry();
+                                    ValueMover::Move(value_ptr_, entry_->mutable_value());
+                                    map_->erase(key_);
+                                    goto move_key;
+                                }
+                            }
+                            else
+                            {
+                                if (!ptr)
+                                    return nullptr;
+                            }
+                            NewEntry();
+                        move_key:
+                            KeyMover::Move(&key_, entry_->mutable_key());
+                        }
+                        else
+                        {
+                            if (!ptr)
+                                return nullptr;
+                            NewEntry();
+                        }
+                        ptr = entry_->_InternalParse(ptr, ctx);
+                        if (ptr)
+                            UseKeyAndValueFromEntry();
+                        return ptr;
+                    }
+
+                    template<typename UnknownType>
+                    const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx, bool (*is_valid)(int), uint32_t field_num, InternalMetadata* metadata)
+                    {
+                        auto entry = NewEntry();
+                        ptr = entry->_InternalParse(ptr, ctx);
+                        if (!ptr)
+                            return nullptr;
+                        if (is_valid(entry->value()))
+                        {
+                            UseKeyAndValueFromEntry();
+                        }
+                        else
+                        {
+                            WriteLengthDelimited(field_num, entry->SerializeAsString(), metadata->mutable_unknown_fields<UnknownType>());
+                        }
+                        return ptr;
+                    }
+
+                    MapEntryImpl* NewEntry()
+                    {
+                        return entry_ = mf_->NewEntry();
+                    }
+
+                    const Key& key() const
+                    {
+                        return key_;
+                    }
+                    const Value& value() const
+                    {
+                        return *value_ptr_;
+                    }
+
+                    const Key& entry_key() const
+                    {
+                        return entry_->key();
+                    }
+                    const Value& entry_value() const
+                    {
+                        return entry_->value();
+                    }
+
+                private:
+                    void UseKeyAndValueFromEntry()
+                    {
+                        // Update key_ in case we need it later (because key() is called).
+                        // This is potentially inefficient, especially if the key is
+                        // expensive to copy (e.g., a long string), but this is a cold
+                        // path, so it's not a big deal.
+                        key_ = entry_->key();
+                        value_ptr_ = &(*map_)[key_];
+                        ValueMover::Move(entry_->mutable_value(), value_ptr_);
+                    }
+
+                    // After reading a key and value successfully, and inserting that data
+                    // into map_, we are not at the end of the input.  This is unusual, but
+                    // allowed by the spec.
+                    bool ReadBeyondKeyValuePair(io::CodedInputStream* input) PROTOBUF_COLD
+                    {
+                        NewEntry();
+                        ValueMover::Move(value_ptr_, entry_->mutable_value());
+                        map_->erase(key_);
+                        KeyMover::Move(&key_, entry_->mutable_key());
+                        const bool result = entry_->MergePartialFromCodedStream(input);
+                        if (result)
+                            UseKeyAndValueFromEntry();
+                        return result;
+                    }
+
+                    typedef MoveHelper<KeyTypeHandler::kIsEnum, KeyTypeHandler::kIsMessage, KeyTypeHandler::kWireType == WireFormatLite::WIRETYPE_LENGTH_DELIMITED, Key>
+                        KeyMover;
+                    typedef MoveHelper<ValueTypeHandler::kIsEnum, ValueTypeHandler::kIsMessage, ValueTypeHandler::kWireType == WireFormatLite::WIRETYPE_LENGTH_DELIMITED, Value>
+                        ValueMover;
+
+                    MapField* const mf_;
+                    Map* const map_;
+                    Key key_;
+                    Value* value_ptr_;
+                    MapEntryImpl* entry_ = nullptr;
+                };
+
+            protected:
+                void set_has_key()
+                {
+                    _has_bits_[0] |= 0x00000001u;
+                }
+                bool has_key() const
+                {
+                    return (_has_bits_[0] & 0x00000001u) != 0;
+                }
+                void clear_has_key()
+                {
+                    _has_bits_[0] &= ~0x00000001u;
+                }
+                void set_has_value()
+                {
+                    _has_bits_[0] |= 0x00000002u;
+                }
+                bool has_value() const
+                {
+                    return (_has_bits_[0] & 0x00000002u) != 0;
+                }
+                void clear_has_value()
+                {
+                    _has_bits_[0] &= ~0x00000002u;
+                }
+
+            public:
+                inline Arena* GetArena() const
+                {
+                    return Base::GetArena();
+                }
+
+            protected:  // Needed for constructing tables
+                KeyOnMemory key_;
+                ValueOnMemory value_;
+                uint32_t _has_bits_[1];
+
+            private:
+                friend class ::PROTOBUF_NAMESPACE_ID::Arena;
+                typedef void InternalArenaConstructable_;
+                typedef void DestructorSkippable_;
+                template<typename C, typename K, typename V, WireFormatLite::FieldType, WireFormatLite::FieldType>
+                friend class internal::MapEntry;
+                template<typename C, typename K, typename V, WireFormatLite::FieldType, WireFormatLite::FieldType>
+                friend class internal::MapFieldLite;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryImpl);
+            };
+
+            template<typename T, typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            class MapEntryLite : public MapEntryImpl<T, MessageLite, Key, Value, kKeyFieldType, kValueFieldType>
+            {
+            public:
+                typedef MapEntryImpl<T, MessageLite, Key, Value, kKeyFieldType, kValueFieldType>
+                    SuperType;
+                constexpr MapEntryLite()
+                {
+                }
+                explicit MapEntryLite(Arena* arena) :
+                    SuperType(arena)
+                {
+                }
+                ~MapEntryLite() override
+                {
+                    MessageLite::_internal_metadata_.template Delete<std::string>();
+                }
+                void MergeFrom(const MapEntryLite& other)
+                {
+                    MergeFromInternal(other);
+                }
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryLite);
+            };
+
+            // Helpers for deterministic serialization =============================
+
+            // Iterator base for MapSorterFlat and MapSorterPtr.
+            template<typename storage_type>
+            struct MapSorterIt
+            {
+                storage_type* ptr;
+                MapSorterIt(storage_type* ptr) :
+                    ptr(ptr)
+                {
+                }
+                bool operator==(const MapSorterIt& other) const
+                {
+                    return ptr == other.ptr;
+                }
+                bool operator!=(const MapSorterIt& other) const
+                {
+                    return !(*this == other);
+                }
+                MapSorterIt& operator++()
+                {
+                    ++ptr;
+                    return *this;
+                }
+                MapSorterIt operator++(int)
+                {
+                    auto other = *this;
+                    ++ptr;
+                    return other;
+                }
+                MapSorterIt operator+(int v)
+                {
+                    return MapSorterIt{ptr + v};
+                }
+            };
+
+            // MapSorterFlat stores keys inline with pointers to map entries, so that
+            // keys can be compared without indirection. This type is used for maps with
+            // keys that are not strings.
+            template<typename MapT>
+            class MapSorterFlat
+            {
+            public:
+                using value_type = typename MapT::value_type;
+                using storage_type = std::pair<typename MapT::key_type, const value_type*>;
+
+                // This const_iterator dereferenes to the map entry stored in the sorting
+                // array pairs. This is the same interface as the Map::const_iterator type,
+                // and allows generated code to use the same loop body with either form:
+                //   for (const auto& entry : map) { ... }
+                //   for (const auto& entry : MapSorterFlat(map)) { ... }
+                struct const_iterator : public MapSorterIt<storage_type>
+                {
+                    using pointer = const typename MapT::value_type*;
+                    using reference = const typename MapT::value_type&;
+                    using MapSorterIt<storage_type>::MapSorterIt;
+
+                    pointer operator->() const
+                    {
+                        return this->ptr->second;
+                    }
+                    reference operator*() const
+                    {
+                        return *this->operator->();
+                    }
+                };
+
+                explicit MapSorterFlat(const MapT& m) :
+                    size_(m.size()),
+                    items_(size_ ? new storage_type[size_] : nullptr)
+                {
+                    if (!size_)
+                        return;
+                    storage_type* it = &items_[0];
+                    for (const auto& entry : m)
+                    {
+                        *it++ = {entry.first, &entry};
+                    }
+                    std::sort(&items_[0], &items_[size_], [](const storage_type& a, const storage_type& b)
+                              { return a.first < b.first; });
+                }
+                size_t size() const
+                {
+                    return size_;
+                }
+                const_iterator begin() const
+                {
+                    return {items_.get()};
+                }
+                const_iterator end() const
+                {
+                    return {items_.get() + size_};
+                }
+
+            private:
+                size_t size_;
+                std::unique_ptr<storage_type[]> items_;
+            };
+
+            // MapSorterPtr stores and sorts pointers to map entries. This type is used for
+            // maps with keys that are strings.
+            template<typename MapT>
+            class MapSorterPtr
+            {
+            public:
+                using value_type = typename MapT::value_type;
+                using storage_type = const typename MapT::value_type*;
+
+                // This const_iterator dereferenes the map entry pointer stored in the sorting
+                // array. This is the same interface as the Map::const_iterator type, and
+                // allows generated code to use the same loop body with either form:
+                //   for (const auto& entry : map) { ... }
+                //   for (const auto& entry : MapSorterPtr(map)) { ... }
+                struct const_iterator : public MapSorterIt<storage_type>
+                {
+                    using pointer = const typename MapT::value_type*;
+                    using reference = const typename MapT::value_type&;
+                    using MapSorterIt<storage_type>::MapSorterIt;
+
+                    pointer operator->() const
+                    {
+                        return *this->ptr;
+                    }
+                    reference operator*() const
+                    {
+                        return *this->operator->();
+                    }
+                };
+
+                explicit MapSorterPtr(const MapT& m) :
+                    size_(m.size()),
+                    items_(size_ ? new storage_type[size_] : nullptr)
+                {
+                    if (!size_)
+                        return;
+                    storage_type* it = &items_[0];
+                    for (const auto& entry : m)
+                    {
+                        *it++ = &entry;
+                    }
+                    std::sort(&items_[0], &items_[size_], [](const storage_type& a, const storage_type& b)
+                              { return a->first < b->first; });
+                }
+                size_t size() const
+                {
+                    return size_;
+                }
+                const_iterator begin() const
+                {
+                    return {items_.get()};
+                }
+                const_iterator end() const
+                {
+                    return {items_.get() + size_};
+                }
+
+            private:
+                size_t size_;
+                std::unique_ptr<storage_type[]> items_;
+            };
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_field.h b/CAPI/cpp/grpc/include/google/protobuf/map_field.h
index 287d58f..b36c7c7 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/map_field.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_field.h
@@ -47,7 +47,6 @@
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/unknown_field_set.h>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
@@ -55,10 +54,12 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-class DynamicMessage;
-class MapIterator;
+namespace google
+{
+    namespace protobuf
+    {
+        class DynamicMessage;
+        class MapIterator;
 
 // Microsoft compiler complains about non-virtual destructor,
 // even when the destructor is private.
@@ -67,874 +68,1029 @@ class MapIterator;
 #pragma warning(disable : 4265)
 #endif  // _MSC_VER
 
-#define TYPE_CHECK(EXPECTEDTYPE, METHOD)                                   \
-  if (type() != EXPECTEDTYPE) {                                            \
-    GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n"                     \
-               << METHOD << " type does not match\n"                       \
-               << "  Expected : "                                          \
-               << FieldDescriptor::CppTypeName(EXPECTEDTYPE) << "\n"       \
-               << "  Actual   : " << FieldDescriptor::CppTypeName(type()); \
-  }
-
-// MapKey is an union type for representing any possible
-// map key.
-class PROTOBUF_EXPORT MapKey {
- public:
-  MapKey() : type_() {}
-  MapKey(const MapKey& other) : type_() { CopyFrom(other); }
-
-  MapKey& operator=(const MapKey& other) {
-    CopyFrom(other);
-    return *this;
-  }
-
-  ~MapKey() {
-    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
-      val_.string_value_.Destruct();
-    }
-  }
-
-  FieldDescriptor::CppType type() const {
-    if (type_ == FieldDescriptor::CppType()) {
-      GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n"
-                 << "MapKey::type MapKey is not initialized. "
-                 << "Call set methods to initialize MapKey.";
-    }
-    return type_;
-  }
-
-  void SetInt64Value(int64_t value) {
-    SetType(FieldDescriptor::CPPTYPE_INT64);
-    val_.int64_value_ = value;
-  }
-  void SetUInt64Value(uint64_t value) {
-    SetType(FieldDescriptor::CPPTYPE_UINT64);
-    val_.uint64_value_ = value;
-  }
-  void SetInt32Value(int32_t value) {
-    SetType(FieldDescriptor::CPPTYPE_INT32);
-    val_.int32_value_ = value;
-  }
-  void SetUInt32Value(uint32_t value) {
-    SetType(FieldDescriptor::CPPTYPE_UINT32);
-    val_.uint32_value_ = value;
-  }
-  void SetBoolValue(bool value) {
-    SetType(FieldDescriptor::CPPTYPE_BOOL);
-    val_.bool_value_ = value;
-  }
-  void SetStringValue(std::string val) {
-    SetType(FieldDescriptor::CPPTYPE_STRING);
-    *val_.string_value_.get_mutable() = std::move(val);
-  }
-
-  int64_t GetInt64Value() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapKey::GetInt64Value");
-    return val_.int64_value_;
-  }
-  uint64_t GetUInt64Value() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapKey::GetUInt64Value");
-    return val_.uint64_value_;
-  }
-  int32_t GetInt32Value() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapKey::GetInt32Value");
-    return val_.int32_value_;
-  }
-  uint32_t GetUInt32Value() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapKey::GetUInt32Value");
-    return val_.uint32_value_;
-  }
-  bool GetBoolValue() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapKey::GetBoolValue");
-    return val_.bool_value_;
-  }
-  const std::string& GetStringValue() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapKey::GetStringValue");
-    return val_.string_value_.get();
-  }
-
-  bool operator<(const MapKey& other) const {
-    if (type_ != other.type_) {
-      // We could define a total order that handles this case, but
-      // there currently no need.  So, for now, fail.
-      GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
-    }
-    switch (type()) {
-      case FieldDescriptor::CPPTYPE_DOUBLE:
-      case FieldDescriptor::CPPTYPE_FLOAT:
-      case FieldDescriptor::CPPTYPE_ENUM:
-      case FieldDescriptor::CPPTYPE_MESSAGE:
-        GOOGLE_LOG(FATAL) << "Unsupported";
-        return false;
-      case FieldDescriptor::CPPTYPE_STRING:
-        return val_.string_value_.get() < other.val_.string_value_.get();
-      case FieldDescriptor::CPPTYPE_INT64:
-        return val_.int64_value_ < other.val_.int64_value_;
-      case FieldDescriptor::CPPTYPE_INT32:
-        return val_.int32_value_ < other.val_.int32_value_;
-      case FieldDescriptor::CPPTYPE_UINT64:
-        return val_.uint64_value_ < other.val_.uint64_value_;
-      case FieldDescriptor::CPPTYPE_UINT32:
-        return val_.uint32_value_ < other.val_.uint32_value_;
-      case FieldDescriptor::CPPTYPE_BOOL:
-        return val_.bool_value_ < other.val_.bool_value_;
-    }
-    return false;
-  }
-
-  bool operator==(const MapKey& other) const {
-    if (type_ != other.type_) {
-      // To be consistent with operator<, we don't allow this either.
-      GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
-    }
-    switch (type()) {
-      case FieldDescriptor::CPPTYPE_DOUBLE:
-      case FieldDescriptor::CPPTYPE_FLOAT:
-      case FieldDescriptor::CPPTYPE_ENUM:
-      case FieldDescriptor::CPPTYPE_MESSAGE:
-        GOOGLE_LOG(FATAL) << "Unsupported";
-        break;
-      case FieldDescriptor::CPPTYPE_STRING:
-        return val_.string_value_.get() == other.val_.string_value_.get();
-      case FieldDescriptor::CPPTYPE_INT64:
-        return val_.int64_value_ == other.val_.int64_value_;
-      case FieldDescriptor::CPPTYPE_INT32:
-        return val_.int32_value_ == other.val_.int32_value_;
-      case FieldDescriptor::CPPTYPE_UINT64:
-        return val_.uint64_value_ == other.val_.uint64_value_;
-      case FieldDescriptor::CPPTYPE_UINT32:
-        return val_.uint32_value_ == other.val_.uint32_value_;
-      case FieldDescriptor::CPPTYPE_BOOL:
-        return val_.bool_value_ == other.val_.bool_value_;
+#define TYPE_CHECK(EXPECTEDTYPE, METHOD)                                              \
+    if (type() != EXPECTEDTYPE)                                                       \
+    {                                                                                 \
+        GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n"                     \
+                          << METHOD << " type does not match\n"                       \
+                          << "  Expected : "                                          \
+                          << FieldDescriptor::CppTypeName(EXPECTEDTYPE) << "\n"       \
+                          << "  Actual   : " << FieldDescriptor::CppTypeName(type()); \
     }
-    GOOGLE_LOG(FATAL) << "Can't get here.";
-    return false;
-  }
-
-  void CopyFrom(const MapKey& other) {
-    SetType(other.type());
-    switch (type_) {
-      case FieldDescriptor::CPPTYPE_DOUBLE:
-      case FieldDescriptor::CPPTYPE_FLOAT:
-      case FieldDescriptor::CPPTYPE_ENUM:
-      case FieldDescriptor::CPPTYPE_MESSAGE:
-        GOOGLE_LOG(FATAL) << "Unsupported";
-        break;
-      case FieldDescriptor::CPPTYPE_STRING:
-        *val_.string_value_.get_mutable() = other.val_.string_value_.get();
-        break;
-      case FieldDescriptor::CPPTYPE_INT64:
-        val_.int64_value_ = other.val_.int64_value_;
-        break;
-      case FieldDescriptor::CPPTYPE_INT32:
-        val_.int32_value_ = other.val_.int32_value_;
-        break;
-      case FieldDescriptor::CPPTYPE_UINT64:
-        val_.uint64_value_ = other.val_.uint64_value_;
-        break;
-      case FieldDescriptor::CPPTYPE_UINT32:
-        val_.uint32_value_ = other.val_.uint32_value_;
-        break;
-      case FieldDescriptor::CPPTYPE_BOOL:
-        val_.bool_value_ = other.val_.bool_value_;
-        break;
-    }
-  }
-
- private:
-  template <typename K, typename V>
-  friend class internal::TypeDefinedMapFieldBase;
-  friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
-  friend class internal::DynamicMapField;
-
-  union KeyValue {
-    KeyValue() {}
-    internal::ExplicitlyConstructed<std::string> string_value_;
-    int64_t int64_value_;
-    int32_t int32_value_;
-    uint64_t uint64_value_;
-    uint32_t uint32_value_;
-    bool bool_value_;
-  } val_;
-
-  void SetType(FieldDescriptor::CppType type) {
-    if (type_ == type) return;
-    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
-      val_.string_value_.Destruct();
-    }
-    type_ = type;
-    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
-      val_.string_value_.DefaultConstruct();
-    }
-  }
-
-  // type_ is 0 or a valid FieldDescriptor::CppType.
-  // Use "CppType()" to indicate zero.
-  FieldDescriptor::CppType type_;
-};
 
-}  // namespace protobuf
+        // MapKey is an union type for representing any possible
+        // map key.
+        class PROTOBUF_EXPORT MapKey
+        {
+        public:
+            MapKey() :
+                type_()
+            {
+            }
+            MapKey(const MapKey& other) :
+                type_()
+            {
+                CopyFrom(other);
+            }
+
+            MapKey& operator=(const MapKey& other)
+            {
+                CopyFrom(other);
+                return *this;
+            }
+
+            ~MapKey()
+            {
+                if (type_ == FieldDescriptor::CPPTYPE_STRING)
+                {
+                    val_.string_value_.Destruct();
+                }
+            }
+
+            FieldDescriptor::CppType type() const
+            {
+                if (type_ == FieldDescriptor::CppType())
+                {
+                    GOOGLE_LOG(FATAL) << "Protocol Buffer map usage error:\n"
+                                      << "MapKey::type MapKey is not initialized. "
+                                      << "Call set methods to initialize MapKey.";
+                }
+                return type_;
+            }
+
+            void SetInt64Value(int64_t value)
+            {
+                SetType(FieldDescriptor::CPPTYPE_INT64);
+                val_.int64_value_ = value;
+            }
+            void SetUInt64Value(uint64_t value)
+            {
+                SetType(FieldDescriptor::CPPTYPE_UINT64);
+                val_.uint64_value_ = value;
+            }
+            void SetInt32Value(int32_t value)
+            {
+                SetType(FieldDescriptor::CPPTYPE_INT32);
+                val_.int32_value_ = value;
+            }
+            void SetUInt32Value(uint32_t value)
+            {
+                SetType(FieldDescriptor::CPPTYPE_UINT32);
+                val_.uint32_value_ = value;
+            }
+            void SetBoolValue(bool value)
+            {
+                SetType(FieldDescriptor::CPPTYPE_BOOL);
+                val_.bool_value_ = value;
+            }
+            void SetStringValue(std::string val)
+            {
+                SetType(FieldDescriptor::CPPTYPE_STRING);
+                *val_.string_value_.get_mutable() = std::move(val);
+            }
+
+            int64_t GetInt64Value() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapKey::GetInt64Value");
+                return val_.int64_value_;
+            }
+            uint64_t GetUInt64Value() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapKey::GetUInt64Value");
+                return val_.uint64_value_;
+            }
+            int32_t GetInt32Value() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapKey::GetInt32Value");
+                return val_.int32_value_;
+            }
+            uint32_t GetUInt32Value() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapKey::GetUInt32Value");
+                return val_.uint32_value_;
+            }
+            bool GetBoolValue() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapKey::GetBoolValue");
+                return val_.bool_value_;
+            }
+            const std::string& GetStringValue() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapKey::GetStringValue");
+                return val_.string_value_.get();
+            }
+
+            bool operator<(const MapKey& other) const
+            {
+                if (type_ != other.type_)
+                {
+                    // We could define a total order that handles this case, but
+                    // there currently no need.  So, for now, fail.
+                    GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
+                }
+                switch (type())
+                {
+                    case FieldDescriptor::CPPTYPE_DOUBLE:
+                    case FieldDescriptor::CPPTYPE_FLOAT:
+                    case FieldDescriptor::CPPTYPE_ENUM:
+                    case FieldDescriptor::CPPTYPE_MESSAGE:
+                        GOOGLE_LOG(FATAL) << "Unsupported";
+                        return false;
+                    case FieldDescriptor::CPPTYPE_STRING:
+                        return val_.string_value_.get() < other.val_.string_value_.get();
+                    case FieldDescriptor::CPPTYPE_INT64:
+                        return val_.int64_value_ < other.val_.int64_value_;
+                    case FieldDescriptor::CPPTYPE_INT32:
+                        return val_.int32_value_ < other.val_.int32_value_;
+                    case FieldDescriptor::CPPTYPE_UINT64:
+                        return val_.uint64_value_ < other.val_.uint64_value_;
+                    case FieldDescriptor::CPPTYPE_UINT32:
+                        return val_.uint32_value_ < other.val_.uint32_value_;
+                    case FieldDescriptor::CPPTYPE_BOOL:
+                        return val_.bool_value_ < other.val_.bool_value_;
+                }
+                return false;
+            }
+
+            bool operator==(const MapKey& other) const
+            {
+                if (type_ != other.type_)
+                {
+                    // To be consistent with operator<, we don't allow this either.
+                    GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
+                }
+                switch (type())
+                {
+                    case FieldDescriptor::CPPTYPE_DOUBLE:
+                    case FieldDescriptor::CPPTYPE_FLOAT:
+                    case FieldDescriptor::CPPTYPE_ENUM:
+                    case FieldDescriptor::CPPTYPE_MESSAGE:
+                        GOOGLE_LOG(FATAL) << "Unsupported";
+                        break;
+                    case FieldDescriptor::CPPTYPE_STRING:
+                        return val_.string_value_.get() == other.val_.string_value_.get();
+                    case FieldDescriptor::CPPTYPE_INT64:
+                        return val_.int64_value_ == other.val_.int64_value_;
+                    case FieldDescriptor::CPPTYPE_INT32:
+                        return val_.int32_value_ == other.val_.int32_value_;
+                    case FieldDescriptor::CPPTYPE_UINT64:
+                        return val_.uint64_value_ == other.val_.uint64_value_;
+                    case FieldDescriptor::CPPTYPE_UINT32:
+                        return val_.uint32_value_ == other.val_.uint32_value_;
+                    case FieldDescriptor::CPPTYPE_BOOL:
+                        return val_.bool_value_ == other.val_.bool_value_;
+                }
+                GOOGLE_LOG(FATAL) << "Can't get here.";
+                return false;
+            }
+
+            void CopyFrom(const MapKey& other)
+            {
+                SetType(other.type());
+                switch (type_)
+                {
+                    case FieldDescriptor::CPPTYPE_DOUBLE:
+                    case FieldDescriptor::CPPTYPE_FLOAT:
+                    case FieldDescriptor::CPPTYPE_ENUM:
+                    case FieldDescriptor::CPPTYPE_MESSAGE:
+                        GOOGLE_LOG(FATAL) << "Unsupported";
+                        break;
+                    case FieldDescriptor::CPPTYPE_STRING:
+                        *val_.string_value_.get_mutable() = other.val_.string_value_.get();
+                        break;
+                    case FieldDescriptor::CPPTYPE_INT64:
+                        val_.int64_value_ = other.val_.int64_value_;
+                        break;
+                    case FieldDescriptor::CPPTYPE_INT32:
+                        val_.int32_value_ = other.val_.int32_value_;
+                        break;
+                    case FieldDescriptor::CPPTYPE_UINT64:
+                        val_.uint64_value_ = other.val_.uint64_value_;
+                        break;
+                    case FieldDescriptor::CPPTYPE_UINT32:
+                        val_.uint32_value_ = other.val_.uint32_value_;
+                        break;
+                    case FieldDescriptor::CPPTYPE_BOOL:
+                        val_.bool_value_ = other.val_.bool_value_;
+                        break;
+                }
+            }
+
+        private:
+            template<typename K, typename V>
+            friend class internal::TypeDefinedMapFieldBase;
+            friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
+            friend class internal::DynamicMapField;
+
+            union KeyValue
+            {
+                KeyValue()
+                {
+                }
+                internal::ExplicitlyConstructed<std::string> string_value_;
+                int64_t int64_value_;
+                int32_t int32_value_;
+                uint64_t uint64_value_;
+                uint32_t uint32_value_;
+                bool bool_value_;
+            } val_;
+
+            void SetType(FieldDescriptor::CppType type)
+            {
+                if (type_ == type)
+                    return;
+                if (type_ == FieldDescriptor::CPPTYPE_STRING)
+                {
+                    val_.string_value_.Destruct();
+                }
+                type_ = type;
+                if (type_ == FieldDescriptor::CPPTYPE_STRING)
+                {
+                    val_.string_value_.DefaultConstruct();
+                }
+            }
+
+            // type_ is 0 or a valid FieldDescriptor::CppType.
+            // Use "CppType()" to indicate zero.
+            FieldDescriptor::CppType type_;
+        };
+
+    }  // namespace protobuf
 }  // namespace google
-namespace std {
-template <>
-struct hash<::PROTOBUF_NAMESPACE_ID::MapKey> {
-  size_t operator()(const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key) const {
-    switch (map_key.type()) {
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_DOUBLE:
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_FLOAT:
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_ENUM:
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_MESSAGE:
-        GOOGLE_LOG(FATAL) << "Unsupported";
-        break;
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_STRING:
-        return hash<std::string>()(map_key.GetStringValue());
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_INT64: {
-        auto value = map_key.GetInt64Value();
-        return hash<decltype(value)>()(value);
-      }
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_INT32: {
-        auto value = map_key.GetInt32Value();
-        return hash<decltype(value)>()(map_key.GetInt32Value());
-      }
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_UINT64: {
-        auto value = map_key.GetUInt64Value();
-        return hash<decltype(value)>()(map_key.GetUInt64Value());
-      }
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_UINT32: {
-        auto value = map_key.GetUInt32Value();
-        return hash<decltype(value)>()(map_key.GetUInt32Value());
-      }
-      case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_BOOL: {
-        return hash<bool>()(map_key.GetBoolValue());
-      }
-    }
-    GOOGLE_LOG(FATAL) << "Can't get here.";
-    return 0;
-  }
-  bool operator()(const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key1,
-                  const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key2) const {
-    return map_key1 < map_key2;
-  }
-};
+namespace std
+{
+    template<>
+    struct hash<::PROTOBUF_NAMESPACE_ID::MapKey>
+    {
+        size_t operator()(const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key) const
+        {
+            switch (map_key.type())
+            {
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_DOUBLE:
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_FLOAT:
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_ENUM:
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_MESSAGE:
+                    GOOGLE_LOG(FATAL) << "Unsupported";
+                    break;
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_STRING:
+                    return hash<std::string>()(map_key.GetStringValue());
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_INT64:
+                    {
+                        auto value = map_key.GetInt64Value();
+                        return hash<decltype(value)>()(value);
+                    }
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_INT32:
+                    {
+                        auto value = map_key.GetInt32Value();
+                        return hash<decltype(value)>()(map_key.GetInt32Value());
+                    }
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_UINT64:
+                    {
+                        auto value = map_key.GetUInt64Value();
+                        return hash<decltype(value)>()(map_key.GetUInt64Value());
+                    }
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_UINT32:
+                    {
+                        auto value = map_key.GetUInt32Value();
+                        return hash<decltype(value)>()(map_key.GetUInt32Value());
+                    }
+                case ::PROTOBUF_NAMESPACE_ID::FieldDescriptor::CPPTYPE_BOOL:
+                    {
+                        return hash<bool>()(map_key.GetBoolValue());
+                    }
+            }
+            GOOGLE_LOG(FATAL) << "Can't get here.";
+            return 0;
+        }
+        bool operator()(const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key1, const ::PROTOBUF_NAMESPACE_ID::MapKey& map_key2) const
+        {
+            return map_key1 < map_key2;
+        }
+    };
 }  // namespace std
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-class ContendedMapCleanTest;
-class GeneratedMessageReflection;
-class MapFieldAccessor;
-
-// This class provides access to map field using reflection, which is the same
-// as those provided for RepeatedPtrField<Message>. It is used for internal
-// reflection implementation only. Users should never use this directly.
-class PROTOBUF_EXPORT MapFieldBase {
- public:
-  MapFieldBase()
-      : arena_(nullptr), repeated_field_(nullptr), state_(STATE_MODIFIED_MAP) {}
-
-  // This constructor is for constant initialized global instances.
-  // It uses a linker initialized mutex, so it is not compatible with regular
-  // runtime instances.
-  // Except in MSVC, where we can't have a constinit mutex.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr MapFieldBase(ConstantInitialized)
-      : arena_(nullptr),
-        repeated_field_(nullptr),
-        mutex_(GOOGLE_PROTOBUF_LINKER_INITIALIZED),
-        state_(STATE_MODIFIED_MAP) {}
-  explicit MapFieldBase(Arena* arena)
-      : arena_(arena), repeated_field_(nullptr), state_(STATE_MODIFIED_MAP) {}
-
- protected:
-  ~MapFieldBase() {  // "protected" stops users from deleting a `MapFieldBase *`
-    GOOGLE_DCHECK(repeated_field_ == nullptr);
-  }
-  void Destruct();
-
- public:
-  // Returns reference to internal repeated field. Data written using
-  // Map's api prior to calling this function is guarantted to be
-  // included in repeated field.
-  const RepeatedPtrFieldBase& GetRepeatedField() const;
-
-  // Like above. Returns mutable pointer to the internal repeated field.
-  RepeatedPtrFieldBase* MutableRepeatedField();
-
-  // Pure virtual map APIs for Map Reflection.
-  virtual bool ContainsMapKey(const MapKey& map_key) const = 0;
-  virtual bool InsertOrLookupMapValue(const MapKey& map_key,
-                                      MapValueRef* val) = 0;
-  virtual bool LookupMapValue(const MapKey& map_key,
-                              MapValueConstRef* val) const = 0;
-  bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
-
-  // Returns whether changes to the map are reflected in the repeated field.
-  bool IsRepeatedFieldValid() const;
-  // Insures operations after won't get executed before calling this.
-  bool IsMapValid() const;
-  virtual bool DeleteMapValue(const MapKey& map_key) = 0;
-  virtual bool EqualIterator(const MapIterator& a,
-                             const MapIterator& b) const = 0;
-  virtual void MapBegin(MapIterator* map_iter) const = 0;
-  virtual void MapEnd(MapIterator* map_iter) const = 0;
-  virtual void MergeFrom(const MapFieldBase& other) = 0;
-  virtual void Swap(MapFieldBase* other);
-  virtual void UnsafeShallowSwap(MapFieldBase* other);
-  // Sync Map with repeated field and returns the size of map.
-  virtual int size() const = 0;
-  virtual void Clear() = 0;
-
-  // Returns the number of bytes used by the repeated field, excluding
-  // sizeof(*this)
-  size_t SpaceUsedExcludingSelfLong() const;
-
-  int SpaceUsedExcludingSelf() const {
-    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
-  }
-
- protected:
-  // Gets the size of space used by map field.
-  virtual size_t SpaceUsedExcludingSelfNoLock() const;
-
-  // Synchronizes the content in Map to RepeatedPtrField if there is any change
-  // to Map after last synchronization.
-  void SyncRepeatedFieldWithMap() const;
-  virtual void SyncRepeatedFieldWithMapNoLock() const;
-
-  // Synchronizes the content in RepeatedPtrField to Map if there is any change
-  // to RepeatedPtrField after last synchronization.
-  void SyncMapWithRepeatedField() const;
-  virtual void SyncMapWithRepeatedFieldNoLock() const {}
-
-  // Tells MapFieldBase that there is new change to Map.
-  void SetMapDirty();
-
-  // Tells MapFieldBase that there is new change to RepeatedPtrField.
-  void SetRepeatedDirty();
-
-  // Provides derived class the access to repeated field.
-  void* MutableRepeatedPtrField() const;
-
-  void InternalSwap(MapFieldBase* other);
-
-  // Support thread sanitizer (tsan) by making const / mutable races
-  // more apparent.  If one thread calls MutableAccess() while another
-  // thread calls either ConstAccess() or MutableAccess(), on the same
-  // MapFieldBase-derived object, and there is no synchronization going
-  // on between them, tsan will alert.
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            class ContendedMapCleanTest;
+            class GeneratedMessageReflection;
+            class MapFieldAccessor;
+
+            // This class provides access to map field using reflection, which is the same
+            // as those provided for RepeatedPtrField<Message>. It is used for internal
+            // reflection implementation only. Users should never use this directly.
+            class PROTOBUF_EXPORT MapFieldBase
+            {
+            public:
+                MapFieldBase() :
+                    arena_(nullptr),
+                    repeated_field_(nullptr),
+                    state_(STATE_MODIFIED_MAP)
+                {
+                }
+
+                // This constructor is for constant initialized global instances.
+                // It uses a linker initialized mutex, so it is not compatible with regular
+                // runtime instances.
+                // Except in MSVC, where we can't have a constinit mutex.
+                // NOLINTNEXTLINE(google-explicit-constructor)
+                constexpr MapFieldBase(ConstantInitialized) :
+                    arena_(nullptr),
+                    repeated_field_(nullptr),
+                    mutex_(GOOGLE_PROTOBUF_LINKER_INITIALIZED),
+                    state_(STATE_MODIFIED_MAP)
+                {
+                }
+                explicit MapFieldBase(Arena* arena) :
+                    arena_(arena),
+                    repeated_field_(nullptr),
+                    state_(STATE_MODIFIED_MAP)
+                {
+                }
+
+            protected:
+                ~MapFieldBase()
+                {  // "protected" stops users from deleting a `MapFieldBase *`
+                    GOOGLE_DCHECK(repeated_field_ == nullptr);
+                }
+                void Destruct();
+
+            public:
+                // Returns reference to internal repeated field. Data written using
+                // Map's api prior to calling this function is guarantted to be
+                // included in repeated field.
+                const RepeatedPtrFieldBase& GetRepeatedField() const;
+
+                // Like above. Returns mutable pointer to the internal repeated field.
+                RepeatedPtrFieldBase* MutableRepeatedField();
+
+                // Pure virtual map APIs for Map Reflection.
+                virtual bool ContainsMapKey(const MapKey& map_key) const = 0;
+                virtual bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val) = 0;
+                virtual bool LookupMapValue(const MapKey& map_key, MapValueConstRef* val) const = 0;
+                bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
+
+                // Returns whether changes to the map are reflected in the repeated field.
+                bool IsRepeatedFieldValid() const;
+                // Insures operations after won't get executed before calling this.
+                bool IsMapValid() const;
+                virtual bool DeleteMapValue(const MapKey& map_key) = 0;
+                virtual bool EqualIterator(const MapIterator& a, const MapIterator& b) const = 0;
+                virtual void MapBegin(MapIterator* map_iter) const = 0;
+                virtual void MapEnd(MapIterator* map_iter) const = 0;
+                virtual void MergeFrom(const MapFieldBase& other) = 0;
+                virtual void Swap(MapFieldBase* other);
+                virtual void UnsafeShallowSwap(MapFieldBase* other);
+                // Sync Map with repeated field and returns the size of map.
+                virtual int size() const = 0;
+                virtual void Clear() = 0;
+
+                // Returns the number of bytes used by the repeated field, excluding
+                // sizeof(*this)
+                size_t SpaceUsedExcludingSelfLong() const;
+
+                int SpaceUsedExcludingSelf() const
+                {
+                    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+                }
+
+            protected:
+                // Gets the size of space used by map field.
+                virtual size_t SpaceUsedExcludingSelfNoLock() const;
+
+                // Synchronizes the content in Map to RepeatedPtrField if there is any change
+                // to Map after last synchronization.
+                void SyncRepeatedFieldWithMap() const;
+                virtual void SyncRepeatedFieldWithMapNoLock() const;
+
+                // Synchronizes the content in RepeatedPtrField to Map if there is any change
+                // to RepeatedPtrField after last synchronization.
+                void SyncMapWithRepeatedField() const;
+                virtual void SyncMapWithRepeatedFieldNoLock() const
+                {
+                }
+
+                // Tells MapFieldBase that there is new change to Map.
+                void SetMapDirty();
+
+                // Tells MapFieldBase that there is new change to RepeatedPtrField.
+                void SetRepeatedDirty();
+
+                // Provides derived class the access to repeated field.
+                void* MutableRepeatedPtrField() const;
+
+                void InternalSwap(MapFieldBase* other);
+
+                // Support thread sanitizer (tsan) by making const / mutable races
+                // more apparent.  If one thread calls MutableAccess() while another
+                // thread calls either ConstAccess() or MutableAccess(), on the same
+                // MapFieldBase-derived object, and there is no synchronization going
+                // on between them, tsan will alert.
 #if defined(__SANITIZE_THREAD__) || defined(THREAD_SANITIZER)
-  void ConstAccess() const { GOOGLE_CHECK_EQ(seq1_, seq2_); }
-  void MutableAccess() {
-    if (seq1_ & 1) {
-      seq2_ = ++seq1_;
-    } else {
-      seq1_ = ++seq2_;
-    }
-  }
-  unsigned int seq1_ = 0, seq2_ = 0;
+                void ConstAccess() const
+                {
+                    GOOGLE_CHECK_EQ(seq1_, seq2_);
+                }
+                void MutableAccess()
+                {
+                    if (seq1_ & 1)
+                    {
+                        seq2_ = ++seq1_;
+                    }
+                    else
+                    {
+                        seq1_ = ++seq2_;
+                    }
+                }
+                unsigned int seq1_ = 0, seq2_ = 0;
 #else
-  void ConstAccess() const {}
-  void MutableAccess() {}
+                void ConstAccess() const
+                {
+                }
+                void MutableAccess()
+                {
+                }
 #endif
-  enum State {
-    STATE_MODIFIED_MAP = 0,       // map has newly added data that has not been
-                                  // synchronized to repeated field
-    STATE_MODIFIED_REPEATED = 1,  // repeated field has newly added data that
-                                  // has not been synchronized to map
-    CLEAN = 2,                    // data in map and repeated field are same
-  };
-
-  Arena* arena_;
-  mutable RepeatedPtrField<Message>* repeated_field_;
-
-  mutable internal::WrappedMutex
-      mutex_;  // The thread to synchronize map and repeated field
-               // needs to get lock first;
-  mutable std::atomic<State> state_;
-
- private:
-  friend class ContendedMapCleanTest;
-  friend class GeneratedMessageReflection;
-  friend class MapFieldAccessor;
-  friend class ::PROTOBUF_NAMESPACE_ID::Reflection;
-  friend class ::PROTOBUF_NAMESPACE_ID::DynamicMessage;
-
-  // Virtual helper methods for MapIterator. MapIterator doesn't have the
-  // type helper for key and value. Call these help methods to deal with
-  // different types. Real helper methods are implemented in
-  // TypeDefinedMapFieldBase.
-  friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
-  // Allocate map<...>::iterator for MapIterator.
-  virtual void InitializeIterator(MapIterator* map_iter) const = 0;
-
-  // DeleteIterator() is called by the destructor of MapIterator only.
-  // It deletes map<...>::iterator for MapIterator.
-  virtual void DeleteIterator(MapIterator* map_iter) const = 0;
-
-  // Copy the map<...>::iterator from other_iterator to
-  // this_iterator.
-  virtual void CopyIterator(MapIterator* this_iterator,
-                            const MapIterator& other_iterator) const = 0;
-
-  // IncreaseIterator() is called by operator++() of MapIterator only.
-  // It implements the ++ operator of MapIterator.
-  virtual void IncreaseIterator(MapIterator* map_iter) const = 0;
-
-  // Swaps state_ with another MapFieldBase
-  void SwapState(MapFieldBase* other);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapFieldBase);
-};
-
-// This class provides common Map Reflection implementations for generated
-// message and dynamic message.
-template <typename Key, typename T>
-class TypeDefinedMapFieldBase : public MapFieldBase {
- public:
-  TypeDefinedMapFieldBase() {}
-
-  // This constructor is for constant initialized global instances.
-  // It uses a linker initialized mutex, so it is not compatible with regular
-  // runtime instances.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr TypeDefinedMapFieldBase(ConstantInitialized tag)
-      : MapFieldBase(tag) {}
-  explicit TypeDefinedMapFieldBase(Arena* arena) : MapFieldBase(arena) {}
-  TypeDefinedMapFieldBase(ArenaInitialized, Arena* arena)
-      : TypeDefinedMapFieldBase(arena) {}
-
- protected:
-  ~TypeDefinedMapFieldBase() {}
-  using MapFieldBase::Destruct;
-
- public:
-  void MapBegin(MapIterator* map_iter) const override;
-  void MapEnd(MapIterator* map_iter) const override;
-  bool EqualIterator(const MapIterator& a, const MapIterator& b) const override;
-
-  virtual const Map<Key, T>& GetMap() const = 0;
-  virtual Map<Key, T>* MutableMap() = 0;
-
- protected:
-  typename Map<Key, T>::const_iterator& InternalGetIterator(
-      const MapIterator* map_iter) const;
-
- private:
-  void InitializeIterator(MapIterator* map_iter) const override;
-  void DeleteIterator(MapIterator* map_iter) const override;
-  void CopyIterator(MapIterator* this_iteratorm,
-                    const MapIterator& that_iterator) const override;
-  void IncreaseIterator(MapIterator* map_iter) const override;
-
-  virtual void SetMapIteratorValue(MapIterator* map_iter) const = 0;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeDefinedMapFieldBase);
-};
-
-// This class provides access to map field using generated api. It is used for
-// internal generated message implementation only. Users should never use this
-// directly.
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-class MapField : public TypeDefinedMapFieldBase<Key, T> {
-  // Provide utilities to parse/serialize key/value.  Provide utilities to
-  // manipulate internal stored type.
-  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
-  typedef MapTypeHandler<kValueFieldType, T> ValueTypeHandler;
-
-  // Define message type for internal repeated field.
-  typedef Derived EntryType;
-
-  // Define abbreviation for parent MapFieldLite
-  typedef MapFieldLite<Derived, Key, T, kKeyFieldType, kValueFieldType>
-      MapFieldLiteType;
-
-  // Enum needs to be handled differently from other types because it has
-  // different exposed type in Map's api and repeated field's api. For
-  // details see the comment in the implementation of
-  // SyncMapWithRepeatedFieldNoLock.
-  static constexpr bool kIsValueEnum = ValueTypeHandler::kIsEnum;
-  typedef typename MapIf<kIsValueEnum, T, const T&>::type CastValueType;
-
- public:
-  typedef Map<Key, T> MapType;
-
-  MapField() : impl_() {}
-  virtual ~MapField() {}  // Destruct() must already have been called!
-  void Destruct() {
-    impl_.Destruct();
-    TypeDefinedMapFieldBase<Key, T>::Destruct();
-  }
-
-  // This constructor is for constant initialized global instances.
-  // It uses a linker initialized mutex, so it is not compatible with regular
-  // runtime instances.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr MapField(ConstantInitialized tag)
-      : TypeDefinedMapFieldBase<Key, T>(tag), impl_() {}
-  explicit MapField(Arena* arena)
-      : TypeDefinedMapFieldBase<Key, T>(arena), impl_(arena) {}
-  MapField(ArenaInitialized, Arena* arena) : MapField(arena) {}
-
-  // Implement MapFieldBase
-  bool ContainsMapKey(const MapKey& map_key) const override;
-  bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val) override;
-  bool LookupMapValue(const MapKey& map_key,
-                      MapValueConstRef* val) const override;
-  bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
-  bool DeleteMapValue(const MapKey& map_key) override;
-
-  const Map<Key, T>& GetMap() const override {
-    MapFieldBase::SyncMapWithRepeatedField();
-    return impl_.GetMap();
-  }
-
-  Map<Key, T>* MutableMap() override {
-    MapFieldBase::SyncMapWithRepeatedField();
-    Map<Key, T>* result = impl_.MutableMap();
-    MapFieldBase::SetMapDirty();
-    return result;
-  }
-
-  int size() const override;
-  void Clear() override;
-  void MergeFrom(const MapFieldBase& other) override;
-  void Swap(MapFieldBase* other) override;
-  void UnsafeShallowSwap(MapFieldBase* other) override;
-  void InternalSwap(MapField* other);
-
-  // Used in the implementation of parsing. Caller should take the ownership iff
-  // arena_ is nullptr.
-  EntryType* NewEntry() const { return impl_.NewEntry(); }
-
-  const char* _InternalParse(const char* ptr, ParseContext* ctx) {
-    return impl_._InternalParse(ptr, ctx);
-  }
-  template <typename UnknownType>
-  const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
-                                      bool (*is_valid)(int), uint32_t field_num,
-                                      InternalMetadata* metadata) {
-    return impl_.template ParseWithEnumValidation<UnknownType>(
-        ptr, ctx, is_valid, field_num, metadata);
-  }
-
- private:
-  MapFieldLiteType impl_;
-
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-
-  // Implements MapFieldBase
-  void SyncRepeatedFieldWithMapNoLock() const override;
-  void SyncMapWithRepeatedFieldNoLock() const override;
-  size_t SpaceUsedExcludingSelfNoLock() const override;
-
-  void SetMapIteratorValue(MapIterator* map_iter) const override;
-
-  friend class ::PROTOBUF_NAMESPACE_ID::Arena;
-  friend class MapFieldStateTest;  // For testing, it needs raw access to impl_
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapField);
-};
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType key_wire_type,
-          WireFormatLite::FieldType value_wire_type>
-bool AllAreInitialized(
-    const MapField<Derived, Key, T, key_wire_type, value_wire_type>& field) {
-  const auto& t = field.GetMap();
-  for (typename Map<Key, T>::const_iterator it = t.begin(); it != t.end();
-       ++it) {
-    if (!it->second.IsInitialized()) return false;
-  }
-  return true;
-}
-
-template <typename T, typename Key, typename Value,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-struct MapEntryToMapField<
-    MapEntry<T, Key, Value, kKeyFieldType, kValueFieldType>> {
-  typedef MapField<T, Key, Value, kKeyFieldType, kValueFieldType> MapFieldType;
-};
-
-class PROTOBUF_EXPORT DynamicMapField
-    : public TypeDefinedMapFieldBase<MapKey, MapValueRef> {
- public:
-  explicit DynamicMapField(const Message* default_entry);
-  DynamicMapField(const Message* default_entry, Arena* arena);
-  virtual ~DynamicMapField();
-
-  // Implement MapFieldBase
-  bool ContainsMapKey(const MapKey& map_key) const override;
-  bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val) override;
-  bool LookupMapValue(const MapKey& map_key,
-                      MapValueConstRef* val) const override;
-  bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
-  bool DeleteMapValue(const MapKey& map_key) override;
-  void MergeFrom(const MapFieldBase& other) override;
-  void Swap(MapFieldBase* other) override;
-  void UnsafeShallowSwap(MapFieldBase* other) override { Swap(other); }
-
-  const Map<MapKey, MapValueRef>& GetMap() const override;
-  Map<MapKey, MapValueRef>* MutableMap() override;
-
-  int size() const override;
-  void Clear() override;
-
- private:
-  Map<MapKey, MapValueRef> map_;
-  const Message* default_entry_;
-
-  void AllocateMapValue(MapValueRef* map_val);
-
-  // Implements MapFieldBase
-  void SyncRepeatedFieldWithMapNoLock() const override;
-  void SyncMapWithRepeatedFieldNoLock() const override;
-  size_t SpaceUsedExcludingSelfNoLock() const override;
-  void SetMapIteratorValue(MapIterator* map_iter) const override;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMapField);
-};
-
-}  // namespace internal
-
-// MapValueConstRef points to a map value. Users can NOT modify
-// the map value.
-class PROTOBUF_EXPORT MapValueConstRef {
- public:
-  MapValueConstRef() : data_(nullptr), type_() {}
-
-  int64_t GetInt64Value() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
-               "MapValueConstRef::GetInt64Value");
-    return *reinterpret_cast<int64_t*>(data_);
-  }
-  uint64_t GetUInt64Value() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
-               "MapValueConstRef::GetUInt64Value");
-    return *reinterpret_cast<uint64_t*>(data_);
-  }
-  int32_t GetInt32Value() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
-               "MapValueConstRef::GetInt32Value");
-    return *reinterpret_cast<int32_t*>(data_);
-  }
-  uint32_t GetUInt32Value() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
-               "MapValueConstRef::GetUInt32Value");
-    return *reinterpret_cast<uint32_t*>(data_);
-  }
-  bool GetBoolValue() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueConstRef::GetBoolValue");
-    return *reinterpret_cast<bool*>(data_);
-  }
-  int GetEnumValue() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM, "MapValueConstRef::GetEnumValue");
-    return *reinterpret_cast<int*>(data_);
-  }
-  const std::string& GetStringValue() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
-               "MapValueConstRef::GetStringValue");
-    return *reinterpret_cast<std::string*>(data_);
-  }
-  float GetFloatValue() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT,
-               "MapValueConstRef::GetFloatValue");
-    return *reinterpret_cast<float*>(data_);
-  }
-  double GetDoubleValue() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE,
-               "MapValueConstRef::GetDoubleValue");
-    return *reinterpret_cast<double*>(data_);
-  }
-
-  const Message& GetMessageValue() const {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE,
-               "MapValueConstRef::GetMessageValue");
-    return *reinterpret_cast<Message*>(data_);
-  }
-
- protected:
-  // data_ point to a map value. MapValueConstRef does not
-  // own this value.
-  void* data_;
-  // type_ is 0 or a valid FieldDescriptor::CppType.
-  // Use "CppType()" to indicate zero.
-  FieldDescriptor::CppType type_;
-
-  FieldDescriptor::CppType type() const {
-    if (type_ == FieldDescriptor::CppType() || data_ == nullptr) {
-      GOOGLE_LOG(FATAL)
-          << "Protocol Buffer map usage error:\n"
-          << "MapValueConstRef::type MapValueConstRef is not initialized.";
-    }
-    return type_;
-  }
-
- private:
-  template <typename Derived, typename K, typename V,
-            internal::WireFormatLite::FieldType key_wire_type,
-            internal::WireFormatLite::FieldType value_wire_type>
-  friend class internal::MapField;
-  template <typename K, typename V>
-  friend class internal::TypeDefinedMapFieldBase;
-  friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
-  friend class Reflection;
-  friend class internal::DynamicMapField;
-
-  void SetType(FieldDescriptor::CppType type) { type_ = type; }
-  void SetValue(const void* val) { data_ = const_cast<void*>(val); }
-  void CopyFrom(const MapValueConstRef& other) {
-    type_ = other.type_;
-    data_ = other.data_;
-  }
-};
-
-// MapValueRef points to a map value. Users are able to modify
-// the map value.
-class PROTOBUF_EXPORT MapValueRef final : public MapValueConstRef {
- public:
-  MapValueRef() {}
-
-  void SetInt64Value(int64_t value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapValueRef::SetInt64Value");
-    *reinterpret_cast<int64_t*>(data_) = value;
-  }
-  void SetUInt64Value(uint64_t value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapValueRef::SetUInt64Value");
-    *reinterpret_cast<uint64_t*>(data_) = value;
-  }
-  void SetInt32Value(int32_t value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapValueRef::SetInt32Value");
-    *reinterpret_cast<int32_t*>(data_) = value;
-  }
-  void SetUInt32Value(uint32_t value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapValueRef::SetUInt32Value");
-    *reinterpret_cast<uint32_t*>(data_) = value;
-  }
-  void SetBoolValue(bool value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueRef::SetBoolValue");
-    *reinterpret_cast<bool*>(data_) = value;
-  }
-  // TODO(jieluo) - Checks that enum is member.
-  void SetEnumValue(int value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM, "MapValueRef::SetEnumValue");
-    *reinterpret_cast<int*>(data_) = value;
-  }
-  void SetStringValue(const std::string& value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapValueRef::SetStringValue");
-    *reinterpret_cast<std::string*>(data_) = value;
-  }
-  void SetFloatValue(float value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT, "MapValueRef::SetFloatValue");
-    *reinterpret_cast<float*>(data_) = value;
-  }
-  void SetDoubleValue(double value) {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE, "MapValueRef::SetDoubleValue");
-    *reinterpret_cast<double*>(data_) = value;
-  }
-
-  Message* MutableMessageValue() {
-    TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE,
-               "MapValueRef::MutableMessageValue");
-    return reinterpret_cast<Message*>(data_);
-  }
-
- private:
-  friend class internal::DynamicMapField;
-
-  // Only used in DynamicMapField
-  void DeleteData() {
-    switch (type_) {
-#define HANDLE_TYPE(CPPTYPE, TYPE)           \
-  case FieldDescriptor::CPPTYPE_##CPPTYPE: { \
-    delete reinterpret_cast<TYPE*>(data_);   \
-    break;                                   \
-  }
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64_t);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64_t);
-      HANDLE_TYPE(DOUBLE, double);
-      HANDLE_TYPE(FLOAT, float);
-      HANDLE_TYPE(BOOL, bool);
-      HANDLE_TYPE(STRING, std::string);
-      HANDLE_TYPE(ENUM, int32_t);
-      HANDLE_TYPE(MESSAGE, Message);
+                enum State
+                {
+                    STATE_MODIFIED_MAP = 0,       // map has newly added data that has not been
+                                                  // synchronized to repeated field
+                    STATE_MODIFIED_REPEATED = 1,  // repeated field has newly added data that
+                                                  // has not been synchronized to map
+                    CLEAN = 2,                    // data in map and repeated field are same
+                };
+
+                Arena* arena_;
+                mutable RepeatedPtrField<Message>* repeated_field_;
+
+                mutable internal::WrappedMutex
+                    mutex_;  // The thread to synchronize map and repeated field
+                             // needs to get lock first;
+                mutable std::atomic<State> state_;
+
+            private:
+                friend class ContendedMapCleanTest;
+                friend class GeneratedMessageReflection;
+                friend class MapFieldAccessor;
+                friend class ::PROTOBUF_NAMESPACE_ID::Reflection;
+                friend class ::PROTOBUF_NAMESPACE_ID::DynamicMessage;
+
+                // Virtual helper methods for MapIterator. MapIterator doesn't have the
+                // type helper for key and value. Call these help methods to deal with
+                // different types. Real helper methods are implemented in
+                // TypeDefinedMapFieldBase.
+                friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
+                // Allocate map<...>::iterator for MapIterator.
+                virtual void InitializeIterator(MapIterator* map_iter) const = 0;
+
+                // DeleteIterator() is called by the destructor of MapIterator only.
+                // It deletes map<...>::iterator for MapIterator.
+                virtual void DeleteIterator(MapIterator* map_iter) const = 0;
+
+                // Copy the map<...>::iterator from other_iterator to
+                // this_iterator.
+                virtual void CopyIterator(MapIterator* this_iterator, const MapIterator& other_iterator) const = 0;
+
+                // IncreaseIterator() is called by operator++() of MapIterator only.
+                // It implements the ++ operator of MapIterator.
+                virtual void IncreaseIterator(MapIterator* map_iter) const = 0;
+
+                // Swaps state_ with another MapFieldBase
+                void SwapState(MapFieldBase* other);
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapFieldBase);
+            };
+
+            // This class provides common Map Reflection implementations for generated
+            // message and dynamic message.
+            template<typename Key, typename T>
+            class TypeDefinedMapFieldBase : public MapFieldBase
+            {
+            public:
+                TypeDefinedMapFieldBase()
+                {
+                }
+
+                // This constructor is for constant initialized global instances.
+                // It uses a linker initialized mutex, so it is not compatible with regular
+                // runtime instances.
+                // NOLINTNEXTLINE(google-explicit-constructor)
+                constexpr TypeDefinedMapFieldBase(ConstantInitialized tag) :
+                    MapFieldBase(tag)
+                {
+                }
+                explicit TypeDefinedMapFieldBase(Arena* arena) :
+                    MapFieldBase(arena)
+                {
+                }
+                TypeDefinedMapFieldBase(ArenaInitialized, Arena* arena) :
+                    TypeDefinedMapFieldBase(arena)
+                {
+                }
+
+            protected:
+                ~TypeDefinedMapFieldBase()
+                {
+                }
+                using MapFieldBase::Destruct;
+
+            public:
+                void MapBegin(MapIterator* map_iter) const override;
+                void MapEnd(MapIterator* map_iter) const override;
+                bool EqualIterator(const MapIterator& a, const MapIterator& b) const override;
+
+                virtual const Map<Key, T>& GetMap() const = 0;
+                virtual Map<Key, T>* MutableMap() = 0;
+
+            protected:
+                typename Map<Key, T>::const_iterator& InternalGetIterator(
+                    const MapIterator* map_iter
+                ) const;
+
+            private:
+                void InitializeIterator(MapIterator* map_iter) const override;
+                void DeleteIterator(MapIterator* map_iter) const override;
+                void CopyIterator(MapIterator* this_iteratorm, const MapIterator& that_iterator) const override;
+                void IncreaseIterator(MapIterator* map_iter) const override;
+
+                virtual void SetMapIteratorValue(MapIterator* map_iter) const = 0;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeDefinedMapFieldBase);
+            };
+
+            // This class provides access to map field using generated api. It is used for
+            // internal generated message implementation only. Users should never use this
+            // directly.
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            class MapField : public TypeDefinedMapFieldBase<Key, T>
+            {
+                // Provide utilities to parse/serialize key/value.  Provide utilities to
+                // manipulate internal stored type.
+                typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+                typedef MapTypeHandler<kValueFieldType, T> ValueTypeHandler;
+
+                // Define message type for internal repeated field.
+                typedef Derived EntryType;
+
+                // Define abbreviation for parent MapFieldLite
+                typedef MapFieldLite<Derived, Key, T, kKeyFieldType, kValueFieldType>
+                    MapFieldLiteType;
+
+                // Enum needs to be handled differently from other types because it has
+                // different exposed type in Map's api and repeated field's api. For
+                // details see the comment in the implementation of
+                // SyncMapWithRepeatedFieldNoLock.
+                static constexpr bool kIsValueEnum = ValueTypeHandler::kIsEnum;
+                typedef typename MapIf<kIsValueEnum, T, const T&>::type CastValueType;
+
+            public:
+                typedef Map<Key, T> MapType;
+
+                MapField() :
+                    impl_()
+                {
+                }
+                virtual ~MapField()
+                {
+                }  // Destruct() must already have been called!
+                void Destruct()
+                {
+                    impl_.Destruct();
+                    TypeDefinedMapFieldBase<Key, T>::Destruct();
+                }
+
+                // This constructor is for constant initialized global instances.
+                // It uses a linker initialized mutex, so it is not compatible with regular
+                // runtime instances.
+                // NOLINTNEXTLINE(google-explicit-constructor)
+                constexpr MapField(ConstantInitialized tag) :
+                    TypeDefinedMapFieldBase<Key, T>(tag),
+                    impl_()
+                {
+                }
+                explicit MapField(Arena* arena) :
+                    TypeDefinedMapFieldBase<Key, T>(arena),
+                    impl_(arena)
+                {
+                }
+                MapField(ArenaInitialized, Arena* arena) :
+                    MapField(arena)
+                {
+                }
+
+                // Implement MapFieldBase
+                bool ContainsMapKey(const MapKey& map_key) const override;
+                bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val) override;
+                bool LookupMapValue(const MapKey& map_key, MapValueConstRef* val) const override;
+                bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
+                bool DeleteMapValue(const MapKey& map_key) override;
+
+                const Map<Key, T>& GetMap() const override
+                {
+                    MapFieldBase::SyncMapWithRepeatedField();
+                    return impl_.GetMap();
+                }
+
+                Map<Key, T>* MutableMap() override
+                {
+                    MapFieldBase::SyncMapWithRepeatedField();
+                    Map<Key, T>* result = impl_.MutableMap();
+                    MapFieldBase::SetMapDirty();
+                    return result;
+                }
+
+                int size() const override;
+                void Clear() override;
+                void MergeFrom(const MapFieldBase& other) override;
+                void Swap(MapFieldBase* other) override;
+                void UnsafeShallowSwap(MapFieldBase* other) override;
+                void InternalSwap(MapField* other);
+
+                // Used in the implementation of parsing. Caller should take the ownership iff
+                // arena_ is nullptr.
+                EntryType* NewEntry() const
+                {
+                    return impl_.NewEntry();
+                }
+
+                const char* _InternalParse(const char* ptr, ParseContext* ctx)
+                {
+                    return impl_._InternalParse(ptr, ctx);
+                }
+                template<typename UnknownType>
+                const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx, bool (*is_valid)(int), uint32_t field_num, InternalMetadata* metadata)
+                {
+                    return impl_.template ParseWithEnumValidation<UnknownType>(
+                        ptr, ctx, is_valid, field_num, metadata
+                    );
+                }
+
+            private:
+                MapFieldLiteType impl_;
+
+                typedef void InternalArenaConstructable_;
+                typedef void DestructorSkippable_;
+
+                // Implements MapFieldBase
+                void SyncRepeatedFieldWithMapNoLock() const override;
+                void SyncMapWithRepeatedFieldNoLock() const override;
+                size_t SpaceUsedExcludingSelfNoLock() const override;
+
+                void SetMapIteratorValue(MapIterator* map_iter) const override;
+
+                friend class ::PROTOBUF_NAMESPACE_ID::Arena;
+                friend class MapFieldStateTest;  // For testing, it needs raw access to impl_
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapField);
+            };
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
+            bool AllAreInitialized(
+                const MapField<Derived, Key, T, key_wire_type, value_wire_type>& field
+            )
+            {
+                const auto& t = field.GetMap();
+                for (typename Map<Key, T>::const_iterator it = t.begin(); it != t.end();
+                     ++it)
+                {
+                    if (!it->second.IsInitialized())
+                        return false;
+                }
+                return true;
+            }
+
+            template<typename T, typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            struct MapEntryToMapField<
+                MapEntry<T, Key, Value, kKeyFieldType, kValueFieldType>>
+            {
+                typedef MapField<T, Key, Value, kKeyFieldType, kValueFieldType> MapFieldType;
+            };
+
+            class PROTOBUF_EXPORT DynamicMapField : public TypeDefinedMapFieldBase<MapKey, MapValueRef>
+            {
+            public:
+                explicit DynamicMapField(const Message* default_entry);
+                DynamicMapField(const Message* default_entry, Arena* arena);
+                virtual ~DynamicMapField();
+
+                // Implement MapFieldBase
+                bool ContainsMapKey(const MapKey& map_key) const override;
+                bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val) override;
+                bool LookupMapValue(const MapKey& map_key, MapValueConstRef* val) const override;
+                bool LookupMapValue(const MapKey&, MapValueRef*) const = delete;
+                bool DeleteMapValue(const MapKey& map_key) override;
+                void MergeFrom(const MapFieldBase& other) override;
+                void Swap(MapFieldBase* other) override;
+                void UnsafeShallowSwap(MapFieldBase* other) override
+                {
+                    Swap(other);
+                }
+
+                const Map<MapKey, MapValueRef>& GetMap() const override;
+                Map<MapKey, MapValueRef>* MutableMap() override;
+
+                int size() const override;
+                void Clear() override;
+
+            private:
+                Map<MapKey, MapValueRef> map_;
+                const Message* default_entry_;
+
+                void AllocateMapValue(MapValueRef* map_val);
+
+                // Implements MapFieldBase
+                void SyncRepeatedFieldWithMapNoLock() const override;
+                void SyncMapWithRepeatedFieldNoLock() const override;
+                size_t SpaceUsedExcludingSelfNoLock() const override;
+                void SetMapIteratorValue(MapIterator* map_iter) const override;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMapField);
+            };
+
+        }  // namespace internal
+
+        // MapValueConstRef points to a map value. Users can NOT modify
+        // the map value.
+        class PROTOBUF_EXPORT MapValueConstRef
+        {
+        public:
+            MapValueConstRef() :
+                data_(nullptr),
+                type_()
+            {
+            }
+
+            int64_t GetInt64Value() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapValueConstRef::GetInt64Value");
+                return *reinterpret_cast<int64_t*>(data_);
+            }
+            uint64_t GetUInt64Value() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapValueConstRef::GetUInt64Value");
+                return *reinterpret_cast<uint64_t*>(data_);
+            }
+            int32_t GetInt32Value() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapValueConstRef::GetInt32Value");
+                return *reinterpret_cast<int32_t*>(data_);
+            }
+            uint32_t GetUInt32Value() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapValueConstRef::GetUInt32Value");
+                return *reinterpret_cast<uint32_t*>(data_);
+            }
+            bool GetBoolValue() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueConstRef::GetBoolValue");
+                return *reinterpret_cast<bool*>(data_);
+            }
+            int GetEnumValue() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM, "MapValueConstRef::GetEnumValue");
+                return *reinterpret_cast<int*>(data_);
+            }
+            const std::string& GetStringValue() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapValueConstRef::GetStringValue");
+                return *reinterpret_cast<std::string*>(data_);
+            }
+            float GetFloatValue() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT, "MapValueConstRef::GetFloatValue");
+                return *reinterpret_cast<float*>(data_);
+            }
+            double GetDoubleValue() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE, "MapValueConstRef::GetDoubleValue");
+                return *reinterpret_cast<double*>(data_);
+            }
+
+            const Message& GetMessageValue() const
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE, "MapValueConstRef::GetMessageValue");
+                return *reinterpret_cast<Message*>(data_);
+            }
+
+        protected:
+            // data_ point to a map value. MapValueConstRef does not
+            // own this value.
+            void* data_;
+            // type_ is 0 or a valid FieldDescriptor::CppType.
+            // Use "CppType()" to indicate zero.
+            FieldDescriptor::CppType type_;
+
+            FieldDescriptor::CppType type() const
+            {
+                if (type_ == FieldDescriptor::CppType() || data_ == nullptr)
+                {
+                    GOOGLE_LOG(FATAL)
+                        << "Protocol Buffer map usage error:\n"
+                        << "MapValueConstRef::type MapValueConstRef is not initialized.";
+                }
+                return type_;
+            }
+
+        private:
+            template<typename Derived, typename K, typename V, internal::WireFormatLite::FieldType key_wire_type, internal::WireFormatLite::FieldType value_wire_type>
+            friend class internal::MapField;
+            template<typename K, typename V>
+            friend class internal::TypeDefinedMapFieldBase;
+            friend class ::PROTOBUF_NAMESPACE_ID::MapIterator;
+            friend class Reflection;
+            friend class internal::DynamicMapField;
+
+            void SetType(FieldDescriptor::CppType type)
+            {
+                type_ = type;
+            }
+            void SetValue(const void* val)
+            {
+                data_ = const_cast<void*>(val);
+            }
+            void CopyFrom(const MapValueConstRef& other)
+            {
+                type_ = other.type_;
+                data_ = other.data_;
+            }
+        };
+
+        // MapValueRef points to a map value. Users are able to modify
+        // the map value.
+        class PROTOBUF_EXPORT MapValueRef final : public MapValueConstRef
+        {
+        public:
+            MapValueRef()
+            {
+            }
+
+            void SetInt64Value(int64_t value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapValueRef::SetInt64Value");
+                *reinterpret_cast<int64_t*>(data_) = value;
+            }
+            void SetUInt64Value(uint64_t value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapValueRef::SetUInt64Value");
+                *reinterpret_cast<uint64_t*>(data_) = value;
+            }
+            void SetInt32Value(int32_t value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapValueRef::SetInt32Value");
+                *reinterpret_cast<int32_t*>(data_) = value;
+            }
+            void SetUInt32Value(uint32_t value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapValueRef::SetUInt32Value");
+                *reinterpret_cast<uint32_t*>(data_) = value;
+            }
+            void SetBoolValue(bool value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueRef::SetBoolValue");
+                *reinterpret_cast<bool*>(data_) = value;
+            }
+            // TODO(jieluo) - Checks that enum is member.
+            void SetEnumValue(int value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM, "MapValueRef::SetEnumValue");
+                *reinterpret_cast<int*>(data_) = value;
+            }
+            void SetStringValue(const std::string& value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING, "MapValueRef::SetStringValue");
+                *reinterpret_cast<std::string*>(data_) = value;
+            }
+            void SetFloatValue(float value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT, "MapValueRef::SetFloatValue");
+                *reinterpret_cast<float*>(data_) = value;
+            }
+            void SetDoubleValue(double value)
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE, "MapValueRef::SetDoubleValue");
+                *reinterpret_cast<double*>(data_) = value;
+            }
+
+            Message* MutableMessageValue()
+            {
+                TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE, "MapValueRef::MutableMessageValue");
+                return reinterpret_cast<Message*>(data_);
+            }
+
+        private:
+            friend class internal::DynamicMapField;
+
+            // Only used in DynamicMapField
+            void DeleteData()
+            {
+                switch (type_)
+                {
+#define HANDLE_TYPE(CPPTYPE, TYPE)                 \
+    case FieldDescriptor::CPPTYPE_##CPPTYPE:       \
+        {                                          \
+            delete reinterpret_cast<TYPE*>(data_); \
+            break;                                 \
+        }
+                    HANDLE_TYPE(INT32, int32_t);
+                    HANDLE_TYPE(INT64, int64_t);
+                    HANDLE_TYPE(UINT32, uint32_t);
+                    HANDLE_TYPE(UINT64, uint64_t);
+                    HANDLE_TYPE(DOUBLE, double);
+                    HANDLE_TYPE(FLOAT, float);
+                    HANDLE_TYPE(BOOL, bool);
+                    HANDLE_TYPE(STRING, std::string);
+                    HANDLE_TYPE(ENUM, int32_t);
+                    HANDLE_TYPE(MESSAGE, Message);
 #undef HANDLE_TYPE
-    }
-  }
-};
+                }
+            }
+        };
 
 #undef TYPE_CHECK
 
-class PROTOBUF_EXPORT MapIterator {
- public:
-  MapIterator(Message* message, const FieldDescriptor* field) {
-    const Reflection* reflection = message->GetReflection();
-    map_ = reflection->MutableMapData(message, field);
-    key_.SetType(field->message_type()->map_key()->cpp_type());
-    value_.SetType(field->message_type()->map_value()->cpp_type());
-    map_->InitializeIterator(this);
-  }
-  MapIterator(const MapIterator& other) {
-    map_ = other.map_;
-    map_->InitializeIterator(this);
-    map_->CopyIterator(this, other);
-  }
-  ~MapIterator() { map_->DeleteIterator(this); }
-  MapIterator& operator=(const MapIterator& other) {
-    map_ = other.map_;
-    map_->CopyIterator(this, other);
-    return *this;
-  }
-  friend bool operator==(const MapIterator& a, const MapIterator& b) {
-    return a.map_->EqualIterator(a, b);
-  }
-  friend bool operator!=(const MapIterator& a, const MapIterator& b) {
-    return !a.map_->EqualIterator(a, b);
-  }
-  MapIterator& operator++() {
-    map_->IncreaseIterator(this);
-    return *this;
-  }
-  MapIterator operator++(int) {
-    // iter_ is copied from Map<...>::iterator, no need to
-    // copy from its self again. Use the same implementation
-    // with operator++()
-    map_->IncreaseIterator(this);
-    return *this;
-  }
-  const MapKey& GetKey() { return key_; }
-  const MapValueRef& GetValueRef() { return value_; }
-  MapValueRef* MutableValueRef() {
-    map_->SetMapDirty();
-    return &value_;
-  }
-
- private:
-  template <typename Key, typename T>
-  friend class internal::TypeDefinedMapFieldBase;
-  friend class internal::DynamicMapField;
-  template <typename Derived, typename Key, typename T,
-            internal::WireFormatLite::FieldType kKeyFieldType,
-            internal::WireFormatLite::FieldType kValueFieldType>
-  friend class internal::MapField;
-
-  // reinterpret_cast from heap-allocated Map<...>::iterator*. MapIterator owns
-  // the iterator. It is allocated by MapField<...>::InitializeIterator() called
-  // in constructor and deleted by MapField<...>::DeleteIterator() called in
-  // destructor.
-  void* iter_;
-  // Point to a MapField to call helper methods implemented in MapField.
-  // MapIterator does not own this object.
-  internal::MapFieldBase* map_;
-  MapKey key_;
-  MapValueRef value_;
-};
-
-}  // namespace protobuf
+        class PROTOBUF_EXPORT MapIterator
+        {
+        public:
+            MapIterator(Message* message, const FieldDescriptor* field)
+            {
+                const Reflection* reflection = message->GetReflection();
+                map_ = reflection->MutableMapData(message, field);
+                key_.SetType(field->message_type()->map_key()->cpp_type());
+                value_.SetType(field->message_type()->map_value()->cpp_type());
+                map_->InitializeIterator(this);
+            }
+            MapIterator(const MapIterator& other)
+            {
+                map_ = other.map_;
+                map_->InitializeIterator(this);
+                map_->CopyIterator(this, other);
+            }
+            ~MapIterator()
+            {
+                map_->DeleteIterator(this);
+            }
+            MapIterator& operator=(const MapIterator& other)
+            {
+                map_ = other.map_;
+                map_->CopyIterator(this, other);
+                return *this;
+            }
+            friend bool operator==(const MapIterator& a, const MapIterator& b)
+            {
+                return a.map_->EqualIterator(a, b);
+            }
+            friend bool operator!=(const MapIterator& a, const MapIterator& b)
+            {
+                return !a.map_->EqualIterator(a, b);
+            }
+            MapIterator& operator++()
+            {
+                map_->IncreaseIterator(this);
+                return *this;
+            }
+            MapIterator operator++(int)
+            {
+                // iter_ is copied from Map<...>::iterator, no need to
+                // copy from its self again. Use the same implementation
+                // with operator++()
+                map_->IncreaseIterator(this);
+                return *this;
+            }
+            const MapKey& GetKey()
+            {
+                return key_;
+            }
+            const MapValueRef& GetValueRef()
+            {
+                return value_;
+            }
+            MapValueRef* MutableValueRef()
+            {
+                map_->SetMapDirty();
+                return &value_;
+            }
+
+        private:
+            template<typename Key, typename T>
+            friend class internal::TypeDefinedMapFieldBase;
+            friend class internal::DynamicMapField;
+            template<typename Derived, typename Key, typename T, internal::WireFormatLite::FieldType kKeyFieldType, internal::WireFormatLite::FieldType kValueFieldType>
+            friend class internal::MapField;
+
+            // reinterpret_cast from heap-allocated Map<...>::iterator*. MapIterator owns
+            // the iterator. It is allocated by MapField<...>::InitializeIterator() called
+            // in constructor and deleted by MapField<...>::DeleteIterator() called in
+            // destructor.
+            void* iter_;
+            // Point to a MapField to call helper methods implemented in MapField.
+            // MapIterator does not own this object.
+            internal::MapFieldBase* map_;
+            MapKey key_;
+            MapValueRef value_;
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #ifdef _MSC_VER
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_field_inl.h b/CAPI/cpp/grpc/include/google/protobuf/map_field_inl.h
index 7c4c232..e184d15 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/map_field_inl.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_field_inl.h
@@ -42,334 +42,364 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-namespace internal {
-// UnwrapMapKey template
-template <typename T>
-T UnwrapMapKey(const MapKey& map_key);
-template <>
-inline int32_t UnwrapMapKey<int32_t>(const MapKey& map_key) {
-  return map_key.GetInt32Value();
-}
-template <>
-inline uint32_t UnwrapMapKey<uint32_t>(const MapKey& map_key) {
-  return map_key.GetUInt32Value();
-}
-template <>
-inline int64_t UnwrapMapKey<int64_t>(const MapKey& map_key) {
-  return map_key.GetInt64Value();
-}
-template <>
-inline uint64_t UnwrapMapKey<uint64_t>(const MapKey& map_key) {
-  return map_key.GetUInt64Value();
-}
-template <>
-inline bool UnwrapMapKey<bool>(const MapKey& map_key) {
-  return map_key.GetBoolValue();
-}
-template <>
-inline std::string UnwrapMapKey<std::string>(const MapKey& map_key) {
-  return map_key.GetStringValue();
-}
-
-// SetMapKey template
-template <typename T>
-inline void SetMapKey(MapKey* map_key, const T& value);
-template <>
-inline void SetMapKey<int32_t>(MapKey* map_key, const int32_t& value) {
-  map_key->SetInt32Value(value);
-}
-template <>
-inline void SetMapKey<uint32_t>(MapKey* map_key, const uint32_t& value) {
-  map_key->SetUInt32Value(value);
-}
-template <>
-inline void SetMapKey<int64_t>(MapKey* map_key, const int64_t& value) {
-  map_key->SetInt64Value(value);
-}
-template <>
-inline void SetMapKey<uint64_t>(MapKey* map_key, const uint64_t& value) {
-  map_key->SetUInt64Value(value);
-}
-template <>
-inline void SetMapKey<bool>(MapKey* map_key, const bool& value) {
-  map_key->SetBoolValue(value);
-}
-template <>
-inline void SetMapKey<std::string>(MapKey* map_key, const std::string& value) {
-  map_key->SetStringValue(value);
-}
-
-// ------------------------TypeDefinedMapFieldBase---------------
-template <typename Key, typename T>
-typename Map<Key, T>::const_iterator&
-TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(
-    const MapIterator* map_iter) const {
-  return *reinterpret_cast<typename Map<Key, T>::const_iterator*>(
-      map_iter->iter_);
-}
-
-template <typename Key, typename T>
-void TypeDefinedMapFieldBase<Key, T>::MapBegin(MapIterator* map_iter) const {
-  InternalGetIterator(map_iter) = GetMap().begin();
-  SetMapIteratorValue(map_iter);
-}
-
-template <typename Key, typename T>
-void TypeDefinedMapFieldBase<Key, T>::MapEnd(MapIterator* map_iter) const {
-  InternalGetIterator(map_iter) = GetMap().end();
-}
-
-template <typename Key, typename T>
-bool TypeDefinedMapFieldBase<Key, T>::EqualIterator(
-    const MapIterator& a, const MapIterator& b) const {
-  return InternalGetIterator(&a) == InternalGetIterator(&b);
-}
-
-template <typename Key, typename T>
-void TypeDefinedMapFieldBase<Key, T>::IncreaseIterator(
-    MapIterator* map_iter) const {
-  ++InternalGetIterator(map_iter);
-  SetMapIteratorValue(map_iter);
-}
-
-template <typename Key, typename T>
-void TypeDefinedMapFieldBase<Key, T>::InitializeIterator(
-    MapIterator* map_iter) const {
-  map_iter->iter_ = new typename Map<Key, T>::const_iterator;
-  GOOGLE_CHECK(map_iter->iter_ != nullptr);
-}
-
-template <typename Key, typename T>
-void TypeDefinedMapFieldBase<Key, T>::DeleteIterator(
-    MapIterator* map_iter) const {
-  delete reinterpret_cast<typename Map<Key, T>::const_iterator*>(
-      map_iter->iter_);
-}
-
-template <typename Key, typename T>
-void TypeDefinedMapFieldBase<Key, T>::CopyIterator(
-    MapIterator* this_iter, const MapIterator& that_iter) const {
-  InternalGetIterator(this_iter) = InternalGetIterator(&that_iter);
-  this_iter->key_.SetType(that_iter.key_.type());
-  // MapValueRef::type() fails when containing data is null. However, if
-  // this_iter points to MapEnd, data can be null.
-  this_iter->value_.SetType(
-      static_cast<FieldDescriptor::CppType>(that_iter.value_.type_));
-  SetMapIteratorValue(this_iter);
-}
-
-// ----------------------------------------------------------------------
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-int MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::size() const {
-  MapFieldBase::SyncMapWithRepeatedField();
-  return static_cast<int>(impl_.GetMap().size());
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::Clear() {
-  if (this->MapFieldBase::repeated_field_ != nullptr) {
-    RepeatedPtrField<EntryType>* repeated_field =
-        reinterpret_cast<RepeatedPtrField<EntryType>*>(
-            this->MapFieldBase::repeated_field_);
-    repeated_field->Clear();
-  }
-
-  impl_.MutableMap()->clear();
-  // Data in map and repeated field are both empty, but we can't set status
-  // CLEAN. Because clear is a generated API, we cannot invalidate previous
-  // reference to map.
-  MapFieldBase::SetMapDirty();
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-void MapField<Derived, Key, T, kKeyFieldType,
-              kValueFieldType>::SetMapIteratorValue(MapIterator* map_iter)
-    const {
-  const Map<Key, T>& map = impl_.GetMap();
-  typename Map<Key, T>::const_iterator iter =
-      TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(map_iter);
-  if (iter == map.end()) return;
-  SetMapKey(&map_iter->key_, iter->first);
-  map_iter->value_.SetValue(&iter->second);
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::ContainsMapKey(
-    const MapKey& map_key) const {
-  const Map<Key, T>& map = impl_.GetMap();
-  const Key& key = UnwrapMapKey<Key>(map_key);
-  typename Map<Key, T>::const_iterator iter = map.find(key);
-  return iter != map.end();
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-bool MapField<Derived, Key, T, kKeyFieldType,
-              kValueFieldType>::InsertOrLookupMapValue(const MapKey& map_key,
-                                                       MapValueRef* val) {
-  // Always use mutable map because users may change the map value by
-  // MapValueRef.
-  Map<Key, T>* map = MutableMap();
-  const Key& key = UnwrapMapKey<Key>(map_key);
-  typename Map<Key, T>::iterator iter = map->find(key);
-  if (map->end() == iter) {
-    val->SetValue(&((*map)[key]));
-    return true;
-  }
-  // Key is already in the map. Make sure (*map)[key] is not called.
-  // [] may reorder the map and iterators.
-  val->SetValue(&(iter->second));
-  return false;
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::LookupMapValue(
-    const MapKey& map_key, MapValueConstRef* val) const {
-  const Map<Key, T>& map = GetMap();
-  const Key& key = UnwrapMapKey<Key>(map_key);
-  typename Map<Key, T>::const_iterator iter = map.find(key);
-  if (map.end() == iter) {
-    return false;
-  }
-  // Key is already in the map. Make sure (*map)[key] is not called.
-  // [] may reorder the map and iterators.
-  val->SetValue(&(iter->second));
-  return true;
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::DeleteMapValue(
-    const MapKey& map_key) {
-  const Key& key = UnwrapMapKey<Key>(map_key);
-  return MutableMap()->erase(key);
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::MergeFrom(
-    const MapFieldBase& other) {
-  MapFieldBase::SyncMapWithRepeatedField();
-  const MapField& other_field = static_cast<const MapField&>(other);
-  other_field.SyncMapWithRepeatedField();
-  impl_.MergeFrom(other_field.impl_);
-  MapFieldBase::SetMapDirty();
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::Swap(
-    MapFieldBase* other) {
-  MapFieldBase::Swap(other);
-  MapField* other_field = down_cast<MapField*>(other);
-  impl_.Swap(&other_field->impl_);
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-void MapField<Derived, Key, T, kKeyFieldType,
-              kValueFieldType>::UnsafeShallowSwap(MapFieldBase* other) {
-  InternalSwap(down_cast<MapField*>(other));
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::InternalSwap(
-    MapField* other) {
-  MapFieldBase::InternalSwap(other);
-  impl_.InternalSwap(&other->impl_);
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-void MapField<Derived, Key, T, kKeyFieldType,
-              kValueFieldType>::SyncRepeatedFieldWithMapNoLock() const {
-  if (this->MapFieldBase::repeated_field_ == nullptr) {
-    this->MapFieldBase::repeated_field_ =
-        Arena::CreateMessage<RepeatedPtrField<Message> >(
-            this->MapFieldBase::arena_);
-  }
-  const Map<Key, T>& map = impl_.GetMap();
-  RepeatedPtrField<EntryType>* repeated_field =
-      reinterpret_cast<RepeatedPtrField<EntryType>*>(
-          this->MapFieldBase::repeated_field_);
-
-  repeated_field->Clear();
-
-  // The only way we can get at this point is through reflection and the
-  // only way we can get the reflection object is by having called GetReflection
-  // on the encompassing field. So that type must have existed and hence we
-  // know that this MapEntry default_type has also already been constructed.
-  // So it's safe to just call internal_default_instance().
-  const Message* default_entry = Derived::internal_default_instance();
-  for (typename Map<Key, T>::const_iterator it = map.begin(); it != map.end();
-       ++it) {
-    EntryType* new_entry =
-        down_cast<EntryType*>(default_entry->New(this->MapFieldBase::arena_));
-    repeated_field->AddAllocated(new_entry);
-    (*new_entry->mutable_key()) = it->first;
-    (*new_entry->mutable_value()) = it->second;
-  }
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-void MapField<Derived, Key, T, kKeyFieldType,
-              kValueFieldType>::SyncMapWithRepeatedFieldNoLock() const {
-  Map<Key, T>* map = const_cast<MapField*>(this)->impl_.MutableMap();
-  RepeatedPtrField<EntryType>* repeated_field =
-      reinterpret_cast<RepeatedPtrField<EntryType>*>(
-          this->MapFieldBase::repeated_field_);
-  GOOGLE_CHECK(this->MapFieldBase::repeated_field_ != nullptr);
-  map->clear();
-  for (typename RepeatedPtrField<EntryType>::iterator it =
-           repeated_field->begin();
-       it != repeated_field->end(); ++it) {
-    // Cast is needed because Map's api and internal storage is different when
-    // value is enum. For enum, we cannot cast an int to enum. Thus, we have to
-    // copy value. For other types, they have same exposed api type and internal
-    // stored type. We should not introduce value copy for them. We achieve this
-    // by casting to value for enum while casting to reference for other types.
-    (*map)[it->key()] = static_cast<CastValueType>(it->value());
-  }
-}
-
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-size_t MapField<Derived, Key, T, kKeyFieldType,
-                kValueFieldType>::SpaceUsedExcludingSelfNoLock() const {
-  size_t size = 0;
-  if (this->MapFieldBase::repeated_field_ != nullptr) {
-    size += this->MapFieldBase::repeated_field_->SpaceUsedExcludingSelfLong();
-  }
-  size += impl_.GetMap().SpaceUsedExcludingSelfLong();
-
-  return size;
-}
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+            // UnwrapMapKey template
+            template<typename T>
+            T UnwrapMapKey(const MapKey& map_key);
+            template<>
+            inline int32_t UnwrapMapKey<int32_t>(const MapKey& map_key)
+            {
+                return map_key.GetInt32Value();
+            }
+            template<>
+            inline uint32_t UnwrapMapKey<uint32_t>(const MapKey& map_key)
+            {
+                return map_key.GetUInt32Value();
+            }
+            template<>
+            inline int64_t UnwrapMapKey<int64_t>(const MapKey& map_key)
+            {
+                return map_key.GetInt64Value();
+            }
+            template<>
+            inline uint64_t UnwrapMapKey<uint64_t>(const MapKey& map_key)
+            {
+                return map_key.GetUInt64Value();
+            }
+            template<>
+            inline bool UnwrapMapKey<bool>(const MapKey& map_key)
+            {
+                return map_key.GetBoolValue();
+            }
+            template<>
+            inline std::string UnwrapMapKey<std::string>(const MapKey& map_key)
+            {
+                return map_key.GetStringValue();
+            }
+
+            // SetMapKey template
+            template<typename T>
+            inline void SetMapKey(MapKey* map_key, const T& value);
+            template<>
+            inline void SetMapKey<int32_t>(MapKey* map_key, const int32_t& value)
+            {
+                map_key->SetInt32Value(value);
+            }
+            template<>
+            inline void SetMapKey<uint32_t>(MapKey* map_key, const uint32_t& value)
+            {
+                map_key->SetUInt32Value(value);
+            }
+            template<>
+            inline void SetMapKey<int64_t>(MapKey* map_key, const int64_t& value)
+            {
+                map_key->SetInt64Value(value);
+            }
+            template<>
+            inline void SetMapKey<uint64_t>(MapKey* map_key, const uint64_t& value)
+            {
+                map_key->SetUInt64Value(value);
+            }
+            template<>
+            inline void SetMapKey<bool>(MapKey* map_key, const bool& value)
+            {
+                map_key->SetBoolValue(value);
+            }
+            template<>
+            inline void SetMapKey<std::string>(MapKey* map_key, const std::string& value)
+            {
+                map_key->SetStringValue(value);
+            }
+
+            // ------------------------TypeDefinedMapFieldBase---------------
+            template<typename Key, typename T>
+            typename Map<Key, T>::const_iterator&
+                TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(
+                    const MapIterator* map_iter
+                ) const
+            {
+                return *reinterpret_cast<typename Map<Key, T>::const_iterator*>(
+                    map_iter->iter_
+                );
+            }
+
+            template<typename Key, typename T>
+            void TypeDefinedMapFieldBase<Key, T>::MapBegin(MapIterator* map_iter) const
+            {
+                InternalGetIterator(map_iter) = GetMap().begin();
+                SetMapIteratorValue(map_iter);
+            }
+
+            template<typename Key, typename T>
+            void TypeDefinedMapFieldBase<Key, T>::MapEnd(MapIterator* map_iter) const
+            {
+                InternalGetIterator(map_iter) = GetMap().end();
+            }
+
+            template<typename Key, typename T>
+            bool TypeDefinedMapFieldBase<Key, T>::EqualIterator(
+                const MapIterator& a, const MapIterator& b
+            ) const
+            {
+                return InternalGetIterator(&a) == InternalGetIterator(&b);
+            }
+
+            template<typename Key, typename T>
+            void TypeDefinedMapFieldBase<Key, T>::IncreaseIterator(
+                MapIterator* map_iter
+            ) const
+            {
+                ++InternalGetIterator(map_iter);
+                SetMapIteratorValue(map_iter);
+            }
+
+            template<typename Key, typename T>
+            void TypeDefinedMapFieldBase<Key, T>::InitializeIterator(
+                MapIterator* map_iter
+            ) const
+            {
+                map_iter->iter_ = new typename Map<Key, T>::const_iterator;
+                GOOGLE_CHECK(map_iter->iter_ != nullptr);
+            }
+
+            template<typename Key, typename T>
+            void TypeDefinedMapFieldBase<Key, T>::DeleteIterator(
+                MapIterator* map_iter
+            ) const
+            {
+                delete reinterpret_cast<typename Map<Key, T>::const_iterator*>(
+                    map_iter->iter_
+                );
+            }
+
+            template<typename Key, typename T>
+            void TypeDefinedMapFieldBase<Key, T>::CopyIterator(
+                MapIterator* this_iter, const MapIterator& that_iter
+            ) const
+            {
+                InternalGetIterator(this_iter) = InternalGetIterator(&that_iter);
+                this_iter->key_.SetType(that_iter.key_.type());
+                // MapValueRef::type() fails when containing data is null. However, if
+                // this_iter points to MapEnd, data can be null.
+                this_iter->value_.SetType(
+                    static_cast<FieldDescriptor::CppType>(that_iter.value_.type_)
+                );
+                SetMapIteratorValue(this_iter);
+            }
+
+            // ----------------------------------------------------------------------
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            int MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::size() const
+            {
+                MapFieldBase::SyncMapWithRepeatedField();
+                return static_cast<int>(impl_.GetMap().size());
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::Clear()
+            {
+                if (this->MapFieldBase::repeated_field_ != nullptr)
+                {
+                    RepeatedPtrField<EntryType>* repeated_field =
+                        reinterpret_cast<RepeatedPtrField<EntryType>*>(
+                            this->MapFieldBase::repeated_field_
+                        );
+                    repeated_field->Clear();
+                }
+
+                impl_.MutableMap()->clear();
+                // Data in map and repeated field are both empty, but we can't set status
+                // CLEAN. Because clear is a generated API, we cannot invalidate previous
+                // reference to map.
+                MapFieldBase::SetMapDirty();
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::SetMapIteratorValue(MapIterator* map_iter)
+                const
+            {
+                const Map<Key, T>& map = impl_.GetMap();
+                typename Map<Key, T>::const_iterator iter =
+                    TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(map_iter);
+                if (iter == map.end())
+                    return;
+                SetMapKey(&map_iter->key_, iter->first);
+                map_iter->value_.SetValue(&iter->second);
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::ContainsMapKey(
+                const MapKey& map_key
+            ) const
+            {
+                const Map<Key, T>& map = impl_.GetMap();
+                const Key& key = UnwrapMapKey<Key>(map_key);
+                typename Map<Key, T>::const_iterator iter = map.find(key);
+                return iter != map.end();
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val)
+            {
+                // Always use mutable map because users may change the map value by
+                // MapValueRef.
+                Map<Key, T>* map = MutableMap();
+                const Key& key = UnwrapMapKey<Key>(map_key);
+                typename Map<Key, T>::iterator iter = map->find(key);
+                if (map->end() == iter)
+                {
+                    val->SetValue(&((*map)[key]));
+                    return true;
+                }
+                // Key is already in the map. Make sure (*map)[key] is not called.
+                // [] may reorder the map and iterators.
+                val->SetValue(&(iter->second));
+                return false;
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::LookupMapValue(
+                const MapKey& map_key, MapValueConstRef* val
+            ) const
+            {
+                const Map<Key, T>& map = GetMap();
+                const Key& key = UnwrapMapKey<Key>(map_key);
+                typename Map<Key, T>::const_iterator iter = map.find(key);
+                if (map.end() == iter)
+                {
+                    return false;
+                }
+                // Key is already in the map. Make sure (*map)[key] is not called.
+                // [] may reorder the map and iterators.
+                val->SetValue(&(iter->second));
+                return true;
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::DeleteMapValue(
+                const MapKey& map_key
+            )
+            {
+                const Key& key = UnwrapMapKey<Key>(map_key);
+                return MutableMap()->erase(key);
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::MergeFrom(
+                const MapFieldBase& other
+            )
+            {
+                MapFieldBase::SyncMapWithRepeatedField();
+                const MapField& other_field = static_cast<const MapField&>(other);
+                other_field.SyncMapWithRepeatedField();
+                impl_.MergeFrom(other_field.impl_);
+                MapFieldBase::SetMapDirty();
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::Swap(
+                MapFieldBase* other
+            )
+            {
+                MapFieldBase::Swap(other);
+                MapField* other_field = down_cast<MapField*>(other);
+                impl_.Swap(&other_field->impl_);
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::UnsafeShallowSwap(MapFieldBase* other)
+            {
+                InternalSwap(down_cast<MapField*>(other));
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::InternalSwap(
+                MapField* other
+            )
+            {
+                MapFieldBase::InternalSwap(other);
+                impl_.InternalSwap(&other->impl_);
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::SyncRepeatedFieldWithMapNoLock() const
+            {
+                if (this->MapFieldBase::repeated_field_ == nullptr)
+                {
+                    this->MapFieldBase::repeated_field_ =
+                        Arena::CreateMessage<RepeatedPtrField<Message>>(
+                            this->MapFieldBase::arena_
+                        );
+                }
+                const Map<Key, T>& map = impl_.GetMap();
+                RepeatedPtrField<EntryType>* repeated_field =
+                    reinterpret_cast<RepeatedPtrField<EntryType>*>(
+                        this->MapFieldBase::repeated_field_
+                    );
+
+                repeated_field->Clear();
+
+                // The only way we can get at this point is through reflection and the
+                // only way we can get the reflection object is by having called GetReflection
+                // on the encompassing field. So that type must have existed and hence we
+                // know that this MapEntry default_type has also already been constructed.
+                // So it's safe to just call internal_default_instance().
+                const Message* default_entry = Derived::internal_default_instance();
+                for (typename Map<Key, T>::const_iterator it = map.begin(); it != map.end();
+                     ++it)
+                {
+                    EntryType* new_entry =
+                        down_cast<EntryType*>(default_entry->New(this->MapFieldBase::arena_));
+                    repeated_field->AddAllocated(new_entry);
+                    (*new_entry->mutable_key()) = it->first;
+                    (*new_entry->mutable_value()) = it->second;
+                }
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::SyncMapWithRepeatedFieldNoLock() const
+            {
+                Map<Key, T>* map = const_cast<MapField*>(this)->impl_.MutableMap();
+                RepeatedPtrField<EntryType>* repeated_field =
+                    reinterpret_cast<RepeatedPtrField<EntryType>*>(
+                        this->MapFieldBase::repeated_field_
+                    );
+                GOOGLE_CHECK(this->MapFieldBase::repeated_field_ != nullptr);
+                map->clear();
+                for (typename RepeatedPtrField<EntryType>::iterator it =
+                         repeated_field->begin();
+                     it != repeated_field->end();
+                     ++it)
+                {
+                    // Cast is needed because Map's api and internal storage is different when
+                    // value is enum. For enum, we cannot cast an int to enum. Thus, we have to
+                    // copy value. For other types, they have same exposed api type and internal
+                    // stored type. We should not introduce value copy for them. We achieve this
+                    // by casting to value for enum while casting to reference for other types.
+                    (*map)[it->key()] = static_cast<CastValueType>(it->value());
+                }
+            }
+
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            size_t MapField<Derived, Key, T, kKeyFieldType, kValueFieldType>::SpaceUsedExcludingSelfNoLock() const
+            {
+                size_t size = 0;
+                if (this->MapFieldBase::repeated_field_ != nullptr)
+                {
+                    size += this->MapFieldBase::repeated_field_->SpaceUsedExcludingSelfLong();
+                }
+                size += impl_.GetMap().SpaceUsedExcludingSelfLong();
+
+                return size;
+            }
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_MAP_FIELD_INL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_field_lite.h b/CAPI/cpp/grpc/include/google/protobuf/map_field_lite.h
index 53bf7a0..0f162b8 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/map_field_lite.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_field_lite.h
@@ -47,161 +47,212 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
 #ifndef NDEBUG
-void MapFieldLiteNotDestructed(void* map_field_lite);
+            void MapFieldLiteNotDestructed(void* map_field_lite);
 #endif
 
-// This class provides access to map field using generated api. It is used for
-// internal generated message implementation only. Users should never use this
-// directly.
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType key_wire_type,
-          WireFormatLite::FieldType value_wire_type>
-class MapFieldLite {
-  // Define message type for internal repeated field.
-  typedef Derived EntryType;
+            // This class provides access to map field using generated api. It is used for
+            // internal generated message implementation only. Users should never use this
+            // directly.
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
+            class MapFieldLite
+            {
+                // Define message type for internal repeated field.
+                typedef Derived EntryType;
 
- public:
-  typedef Map<Key, T> MapType;
+            public:
+                typedef Map<Key, T> MapType;
 
-  constexpr MapFieldLite() : map_() {}
-  explicit MapFieldLite(Arena* arena) : map_(arena) {}
-  MapFieldLite(ArenaInitialized, Arena* arena) : MapFieldLite(arena) {}
+                constexpr MapFieldLite() :
+                    map_()
+                {
+                }
+                explicit MapFieldLite(Arena* arena) :
+                    map_(arena)
+                {
+                }
+                MapFieldLite(ArenaInitialized, Arena* arena) :
+                    MapFieldLite(arena)
+                {
+                }
 
 #ifdef NDEBUG
-  void Destruct() { map_.~Map(); }
-  ~MapFieldLite() {}
+                void Destruct()
+                {
+                    map_.~Map();
+                }
+                ~MapFieldLite()
+                {
+                }
 #else
-  void Destruct() {
-    // We want to destruct the map in such a way that we can verify
-    // that we've done that, but also be sure that we've deallocated
-    // everything (as opposed to leaving an allocation behind with no
-    // data in it, as would happen if a vector was resize'd to zero.
-    // Map::Swap with an empty map accomplishes that.
-    decltype(map_) swapped_map(map_.arena());
-    map_.InternalSwap(swapped_map);
-  }
-  ~MapFieldLite() {
-    if (map_.arena() == nullptr && !map_.empty()) {
-      MapFieldLiteNotDestructed(this);
-    }
-  }
+                void Destruct()
+                {
+                    // We want to destruct the map in such a way that we can verify
+                    // that we've done that, but also be sure that we've deallocated
+                    // everything (as opposed to leaving an allocation behind with no
+                    // data in it, as would happen if a vector was resize'd to zero.
+                    // Map::Swap with an empty map accomplishes that.
+                    decltype(map_) swapped_map(map_.arena());
+                    map_.InternalSwap(swapped_map);
+                }
+                ~MapFieldLite()
+                {
+                    if (map_.arena() == nullptr && !map_.empty())
+                    {
+                        MapFieldLiteNotDestructed(this);
+                    }
+                }
 #endif
-  // Accessors
-  const Map<Key, T>& GetMap() const { return map_; }
-  Map<Key, T>* MutableMap() { return &map_; }
-
-  // Convenient methods for generated message implementation.
-  int size() const { return static_cast<int>(map_.size()); }
-  void Clear() { return map_.clear(); }
-  void MergeFrom(const MapFieldLite& other) {
-    for (typename Map<Key, T>::const_iterator it = other.map_.begin();
-         it != other.map_.end(); ++it) {
-      map_[it->first] = it->second;
-    }
-  }
-  void Swap(MapFieldLite* other) { map_.swap(other->map_); }
-  void InternalSwap(MapFieldLite* other) { map_.InternalSwap(other->map_); }
-
-  // Used in the implementation of parsing. Caller should take the ownership iff
-  // arena_ is nullptr.
-  EntryType* NewEntry() const {
-    return Arena::CreateMessage<EntryType>(map_.arena());
-  }
-
-  const char* _InternalParse(const char* ptr, ParseContext* ctx) {
-    typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
-    return parser._InternalParse(ptr, ctx);
-  }
-
-  template <typename UnknownType>
-  const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
-                                      bool (*is_valid)(int), uint32_t field_num,
-                                      InternalMetadata* metadata) {
-    typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
-    return parser.template ParseWithEnumValidation<UnknownType>(
-        ptr, ctx, is_valid, field_num, metadata);
-  }
-
- private:
-  typedef void DestructorSkippable_;
-
-  // map_ is inside an anonymous union so we can explicitly control its
-  // destruction
-  union {
-    Map<Key, T> map_;
-  };
-
-  friend class ::PROTOBUF_NAMESPACE_ID::Arena;
-};
-
-template <typename UnknownType, typename T>
-struct EnumParseWrapper {
-  const char* _InternalParse(const char* ptr, ParseContext* ctx) {
-    return map_field->template ParseWithEnumValidation<UnknownType>(
-        ptr, ctx, is_valid, field_num, metadata);
-  }
-  T* map_field;
-  bool (*is_valid)(int);
-  uint32_t field_num;
-  InternalMetadata* metadata;
-};
-
-// Helper function because the typenames of maps are horrendous to print. This
-// leverages compiler type deduction, to keep all type data out of the
-// generated code
-template <typename UnknownType, typename T>
-EnumParseWrapper<UnknownType, T> InitEnumParseWrapper(
-    T* map_field, bool (*is_valid)(int), uint32_t field_num,
-    InternalMetadata* metadata) {
-  return EnumParseWrapper<UnknownType, T>{map_field, is_valid, field_num,
-                                          metadata};
-}
-
-// True if IsInitialized() is true for value field in all elements of t. T is
-// expected to be message.  It's useful to have this helper here to keep the
-// protobuf compiler from ever having to emit loops in IsInitialized() methods.
-// We want the C++ compiler to inline this or not as it sees fit.
-template <typename Derived, typename Key, typename T,
-          WireFormatLite::FieldType key_wire_type,
-          WireFormatLite::FieldType value_wire_type>
-bool AllAreInitialized(const MapFieldLite<Derived, Key, T, key_wire_type,
-                                          value_wire_type>& field) {
-  const auto& t = field.GetMap();
-  for (typename Map<Key, T>::const_iterator it = t.begin(); it != t.end();
-       ++it) {
-    if (!it->second.IsInitialized()) return false;
-  }
-  return true;
-}
-
-template <typename MEntry>
-struct MapEntryToMapField : MapEntryToMapField<typename MEntry::SuperType> {};
-
-template <typename T, typename Key, typename Value,
-          WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-struct MapEntryToMapField<
-    MapEntryLite<T, Key, Value, kKeyFieldType, kValueFieldType>> {
-  typedef MapFieldLite<
-      MapEntryLite<T, Key, Value, kKeyFieldType, kValueFieldType>, Key, Value,
-      kKeyFieldType, kValueFieldType>
-      MapFieldType;
-};
+                // Accessors
+                const Map<Key, T>& GetMap() const
+                {
+                    return map_;
+                }
+                Map<Key, T>* MutableMap()
+                {
+                    return &map_;
+                }
+
+                // Convenient methods for generated message implementation.
+                int size() const
+                {
+                    return static_cast<int>(map_.size());
+                }
+                void Clear()
+                {
+                    return map_.clear();
+                }
+                void MergeFrom(const MapFieldLite& other)
+                {
+                    for (typename Map<Key, T>::const_iterator it = other.map_.begin();
+                         it != other.map_.end();
+                         ++it)
+                    {
+                        map_[it->first] = it->second;
+                    }
+                }
+                void Swap(MapFieldLite* other)
+                {
+                    map_.swap(other->map_);
+                }
+                void InternalSwap(MapFieldLite* other)
+                {
+                    map_.InternalSwap(other->map_);
+                }
+
+                // Used in the implementation of parsing. Caller should take the ownership iff
+                // arena_ is nullptr.
+                EntryType* NewEntry() const
+                {
+                    return Arena::CreateMessage<EntryType>(map_.arena());
+                }
+
+                const char* _InternalParse(const char* ptr, ParseContext* ctx)
+                {
+                    typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
+                    return parser._InternalParse(ptr, ctx);
+                }
+
+                template<typename UnknownType>
+                const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx, bool (*is_valid)(int), uint32_t field_num, InternalMetadata* metadata)
+                {
+                    typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
+                    return parser.template ParseWithEnumValidation<UnknownType>(
+                        ptr, ctx, is_valid, field_num, metadata
+                    );
+                }
+
+            private:
+                typedef void DestructorSkippable_;
+
+                // map_ is inside an anonymous union so we can explicitly control its
+                // destruction
+                union
+                {
+                    Map<Key, T> map_;
+                };
+
+                friend class ::PROTOBUF_NAMESPACE_ID::Arena;
+            };
+
+            template<typename UnknownType, typename T>
+            struct EnumParseWrapper
+            {
+                const char* _InternalParse(const char* ptr, ParseContext* ctx)
+                {
+                    return map_field->template ParseWithEnumValidation<UnknownType>(
+                        ptr, ctx, is_valid, field_num, metadata
+                    );
+                }
+                T* map_field;
+                bool (*is_valid)(int);
+                uint32_t field_num;
+                InternalMetadata* metadata;
+            };
+
+            // Helper function because the typenames of maps are horrendous to print. This
+            // leverages compiler type deduction, to keep all type data out of the
+            // generated code
+            template<typename UnknownType, typename T>
+            EnumParseWrapper<UnknownType, T> InitEnumParseWrapper(
+                T* map_field, bool (*is_valid)(int), uint32_t field_num, InternalMetadata* metadata
+            )
+            {
+                return EnumParseWrapper<UnknownType, T>{map_field, is_valid, field_num, metadata};
+            }
+
+            // True if IsInitialized() is true for value field in all elements of t. T is
+            // expected to be message.  It's useful to have this helper here to keep the
+            // protobuf compiler from ever having to emit loops in IsInitialized() methods.
+            // We want the C++ compiler to inline this or not as it sees fit.
+            template<typename Derived, typename Key, typename T, WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
+            bool AllAreInitialized(const MapFieldLite<Derived, Key, T, key_wire_type, value_wire_type>& field)
+            {
+                const auto& t = field.GetMap();
+                for (typename Map<Key, T>::const_iterator it = t.begin(); it != t.end();
+                     ++it)
+                {
+                    if (!it->second.IsInitialized())
+                        return false;
+                }
+                return true;
+            }
+
+            template<typename MEntry>
+            struct MapEntryToMapField : MapEntryToMapField<typename MEntry::SuperType>
+            {
+            };
+
+            template<typename T, typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            struct MapEntryToMapField<
+                MapEntryLite<T, Key, Value, kKeyFieldType, kValueFieldType>>
+            {
+                typedef MapFieldLite<
+                    MapEntryLite<T, Key, Value, kKeyFieldType, kValueFieldType>,
+                    Key,
+                    Value,
+                    kKeyFieldType,
+                    kValueFieldType>
+                    MapFieldType;
+            };
 
 #ifndef NDEBUG
-inline PROTOBUF_NOINLINE void MapFieldLiteNotDestructed(void* map_field_lite) {
-  bool proper_destruct = false;
-  GOOGLE_CHECK(proper_destruct) << map_field_lite;
-}
+            inline PROTOBUF_NOINLINE void MapFieldLiteNotDestructed(void* map_field_lite)
+            {
+                bool proper_destruct = false;
+                GOOGLE_CHECK(proper_destruct) << map_field_lite;
+            }
 #endif
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/map_type_handler.h b/CAPI/cpp/grpc/include/google/protobuf/map_type_handler.h
index c210c63..9fd423e 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/map_type_handler.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/map_type_handler.h
@@ -41,696 +41,781 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// Used for compile time type selection. MapIf::type will be TrueType if Flag is
-// true and FalseType otherwise.
-template <bool Flag, typename TrueType, typename FalseType>
-struct MapIf;
-
-template <typename TrueType, typename FalseType>
-struct MapIf<true, TrueType, FalseType> {
-  typedef TrueType type;
-};
-
-template <typename TrueType, typename FalseType>
-struct MapIf<false, TrueType, FalseType> {
-  typedef FalseType type;
-};
-
-template <typename Type, bool is_arena_constructable>
-class MapArenaMessageCreator {
- public:
-  // Use arena to create message if Type is arena constructable. Otherwise,
-  // create the message on heap.
-  static inline Type* CreateMessage(Arena* arena);
-};
-template <typename Type>
-class MapArenaMessageCreator<Type, true> {
- public:
-  static inline Type* CreateMessage(Arena* arena) {
-    return Arena::CreateMessage<Type>(arena);
-  }
-};
-template <typename Type>
-class MapArenaMessageCreator<Type, false> {
- public:
-  static inline Type* CreateMessage(Arena* arena) {
-    return Arena::Create<Type>(arena);
-  }
-};
-
-// Define constants for given wire field type
-template <WireFormatLite::FieldType field_type, typename Type>
-class MapWireFieldTypeTraits {};
-
-#define TYPE_TRAITS(FieldType, CType, WireFormatType, IsMessage, IsEnum)   \
-  template <typename Type>                                                 \
-  class MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type> {   \
-   public:                                                                 \
-    static const bool kIsMessage = IsMessage;                              \
-    static const bool kIsEnum = IsEnum;                                    \
-    typedef typename MapIf<kIsMessage, Type*, CType>::type TypeOnMemory;   \
-    typedef typename MapIf<kIsEnum, int, Type>::type MapEntryAccessorType; \
-    static const WireFormatLite::WireType kWireType =                      \
-        WireFormatLite::WIRETYPE_##WireFormatType;                         \
-  };
-
-TYPE_TRAITS(MESSAGE, Type, LENGTH_DELIMITED, true, false)
-TYPE_TRAITS(STRING, ArenaStringPtr, LENGTH_DELIMITED, false, false)
-TYPE_TRAITS(BYTES, ArenaStringPtr, LENGTH_DELIMITED, false, false)
-TYPE_TRAITS(INT64, int64_t, VARINT, false, false)
-TYPE_TRAITS(UINT64, uint64_t, VARINT, false, false)
-TYPE_TRAITS(INT32, int32_t, VARINT, false, false)
-TYPE_TRAITS(UINT32, uint32_t, VARINT, false, false)
-TYPE_TRAITS(SINT64, int64_t, VARINT, false, false)
-TYPE_TRAITS(SINT32, int32_t, VARINT, false, false)
-TYPE_TRAITS(ENUM, int, VARINT, false, true)
-TYPE_TRAITS(DOUBLE, double, FIXED64, false, false)
-TYPE_TRAITS(FLOAT, float, FIXED32, false, false)
-TYPE_TRAITS(FIXED64, uint64_t, FIXED64, false, false)
-TYPE_TRAITS(FIXED32, uint32_t, FIXED32, false, false)
-TYPE_TRAITS(SFIXED64, int64_t, FIXED64, false, false)
-TYPE_TRAITS(SFIXED32, int32_t, FIXED32, false, false)
-TYPE_TRAITS(BOOL, bool, VARINT, false, false)
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // Used for compile time type selection. MapIf::type will be TrueType if Flag is
+            // true and FalseType otherwise.
+            template<bool Flag, typename TrueType, typename FalseType>
+            struct MapIf;
+
+            template<typename TrueType, typename FalseType>
+            struct MapIf<true, TrueType, FalseType>
+            {
+                typedef TrueType type;
+            };
+
+            template<typename TrueType, typename FalseType>
+            struct MapIf<false, TrueType, FalseType>
+            {
+                typedef FalseType type;
+            };
+
+            template<typename Type, bool is_arena_constructable>
+            class MapArenaMessageCreator
+            {
+            public:
+                // Use arena to create message if Type is arena constructable. Otherwise,
+                // create the message on heap.
+                static inline Type* CreateMessage(Arena* arena);
+            };
+            template<typename Type>
+            class MapArenaMessageCreator<Type, true>
+            {
+            public:
+                static inline Type* CreateMessage(Arena* arena)
+                {
+                    return Arena::CreateMessage<Type>(arena);
+                }
+            };
+            template<typename Type>
+            class MapArenaMessageCreator<Type, false>
+            {
+            public:
+                static inline Type* CreateMessage(Arena* arena)
+                {
+                    return Arena::Create<Type>(arena);
+                }
+            };
+
+            // Define constants for given wire field type
+            template<WireFormatLite::FieldType field_type, typename Type>
+            class MapWireFieldTypeTraits
+            {
+            };
+
+#define TYPE_TRAITS(FieldType, CType, WireFormatType, IsMessage, IsEnum)       \
+    template<typename Type>                                                    \
+    class MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type>       \
+    {                                                                          \
+    public:                                                                    \
+        static const bool kIsMessage = IsMessage;                              \
+        static const bool kIsEnum = IsEnum;                                    \
+        typedef typename MapIf<kIsMessage, Type*, CType>::type TypeOnMemory;   \
+        typedef typename MapIf<kIsEnum, int, Type>::type MapEntryAccessorType; \
+        static const WireFormatLite::WireType kWireType =                      \
+            WireFormatLite::WIRETYPE_##WireFormatType;                         \
+    };
+
+            TYPE_TRAITS(MESSAGE, Type, LENGTH_DELIMITED, true, false)
+            TYPE_TRAITS(STRING, ArenaStringPtr, LENGTH_DELIMITED, false, false)
+            TYPE_TRAITS(BYTES, ArenaStringPtr, LENGTH_DELIMITED, false, false)
+            TYPE_TRAITS(INT64, int64_t, VARINT, false, false)
+            TYPE_TRAITS(UINT64, uint64_t, VARINT, false, false)
+            TYPE_TRAITS(INT32, int32_t, VARINT, false, false)
+            TYPE_TRAITS(UINT32, uint32_t, VARINT, false, false)
+            TYPE_TRAITS(SINT64, int64_t, VARINT, false, false)
+            TYPE_TRAITS(SINT32, int32_t, VARINT, false, false)
+            TYPE_TRAITS(ENUM, int, VARINT, false, true)
+            TYPE_TRAITS(DOUBLE, double, FIXED64, false, false)
+            TYPE_TRAITS(FLOAT, float, FIXED32, false, false)
+            TYPE_TRAITS(FIXED64, uint64_t, FIXED64, false, false)
+            TYPE_TRAITS(FIXED32, uint32_t, FIXED32, false, false)
+            TYPE_TRAITS(SFIXED64, int64_t, FIXED64, false, false)
+            TYPE_TRAITS(SFIXED32, int32_t, FIXED32, false, false)
+            TYPE_TRAITS(BOOL, bool, VARINT, false, false)
 
 #undef TYPE_TRAITS
 
-template <WireFormatLite::FieldType field_type, typename Type>
-class MapTypeHandler {};
-
-template <typename Type>
-class MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type> {
- public:
-  // Enum type cannot be used for MapTypeHandler::Read. Define a type which will
-  // replace Enum with int.
-  typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
-                                          Type>::MapEntryAccessorType
-      MapEntryAccessorType;
-  // Internal stored type in MapEntryLite for given wire field type.
-  typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
-                                          Type>::TypeOnMemory TypeOnMemory;
-  // Corresponding wire type for field type.
-  static constexpr WireFormatLite::WireType kWireType =
-      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kWireType;
-  // Whether wire type is for message.
-  static constexpr bool kIsMessage =
-      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsMessage;
-  // Whether wire type is for enum.
-  static constexpr bool kIsEnum =
-      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsEnum;
-
-  // Functions used in parsing and serialization. ===================
-  static inline size_t ByteSize(const MapEntryAccessorType& value);
-  static inline int GetCachedSize(const MapEntryAccessorType& value);
-  static inline bool Read(io::CodedInputStream* input,
-                          MapEntryAccessorType* value);
-  static inline const char* Read(const char* ptr, ParseContext* ctx,
-                                 MapEntryAccessorType* value);
-
-  static inline uint8_t* Write(int field, const MapEntryAccessorType& value,
-                               uint8_t* ptr, io::EpsCopyOutputStream* stream);
-
-  // Functions to manipulate data on memory. ========================
-  static inline const Type& GetExternalReference(const Type* value);
-  static inline void DeleteNoArena(const Type* x);
-  static inline void Merge(const Type& from, Type** to, Arena* arena);
-  static inline void Clear(Type** value, Arena* arena);
-  static constexpr TypeOnMemory Constinit();
-
-  static inline Type* EnsureMutable(Type** value, Arena* arena);
-  // SpaceUsedInMapEntry: Return bytes used by value in MapEntry, excluding
-  // those already calculate in sizeof(MapField).
-  static inline size_t SpaceUsedInMapEntryLong(const Type* value);
-  // Return default instance if value is not initialized when calling const
-  // reference accessor.
-  static inline const Type& DefaultIfNotInitialized(const Type* value);
-  // Check if all required fields have values set.
-  static inline bool IsInitialized(Type* value);
-};
-
-#define MAP_HANDLER(FieldType)                                                 \
-  template <typename Type>                                                     \
-  class MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type> {               \
-   public:                                                                     \
-    typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,  \
-                                            Type>::MapEntryAccessorType        \
-        MapEntryAccessorType;                                                  \
-    typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,  \
-                                            Type>::TypeOnMemory TypeOnMemory;  \
-    static const WireFormatLite::WireType kWireType =                          \
-        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,               \
-                               Type>::kWireType;                               \
-    static const bool kIsMessage =                                             \
-        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,               \
-                               Type>::kIsMessage;                              \
-    static const bool kIsEnum =                                                \
-        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,               \
-                               Type>::kIsEnum;                                 \
-    static inline int ByteSize(const MapEntryAccessorType& value);             \
-    static inline int GetCachedSize(const MapEntryAccessorType& value);        \
-    static inline bool Read(io::CodedInputStream* input,                       \
-                            MapEntryAccessorType* value);                      \
-    static inline const char* Read(const char* begin, ParseContext* ctx,       \
-                                   MapEntryAccessorType* value);               \
-    static inline uint8_t* Write(int field, const MapEntryAccessorType& value, \
-                                 uint8_t* ptr,                                 \
-                                 io::EpsCopyOutputStream* stream);             \
-    static inline const MapEntryAccessorType& GetExternalReference(            \
-        const TypeOnMemory& value);                                            \
-    static inline void DeleteNoArena(const TypeOnMemory& x);                   \
-    static inline void Merge(const MapEntryAccessorType& from,                 \
-                             TypeOnMemory* to, Arena* arena);                  \
-    static inline void Clear(TypeOnMemory* value, Arena* arena);               \
-    static inline size_t SpaceUsedInMapEntryLong(const TypeOnMemory& value);   \
-    static inline const MapEntryAccessorType& DefaultIfNotInitialized(         \
-        const TypeOnMemory& value);                                            \
-    static inline bool IsInitialized(const TypeOnMemory& value);               \
-    static void DeleteNoArena(TypeOnMemory& value);                            \
-    static constexpr TypeOnMemory Constinit();                                 \
-    static inline MapEntryAccessorType* EnsureMutable(TypeOnMemory* value,     \
-                                                      Arena* arena);           \
-  };
-MAP_HANDLER(STRING)
-MAP_HANDLER(BYTES)
-MAP_HANDLER(INT64)
-MAP_HANDLER(UINT64)
-MAP_HANDLER(INT32)
-MAP_HANDLER(UINT32)
-MAP_HANDLER(SINT64)
-MAP_HANDLER(SINT32)
-MAP_HANDLER(ENUM)
-MAP_HANDLER(DOUBLE)
-MAP_HANDLER(FLOAT)
-MAP_HANDLER(FIXED64)
-MAP_HANDLER(FIXED32)
-MAP_HANDLER(SFIXED64)
-MAP_HANDLER(SFIXED32)
-MAP_HANDLER(BOOL)
+            template<WireFormatLite::FieldType field_type, typename Type>
+            class MapTypeHandler
+            {
+            };
+
+            template<typename Type>
+            class MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>
+            {
+            public:
+                // Enum type cannot be used for MapTypeHandler::Read. Define a type which will
+                // replace Enum with int.
+                typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::MapEntryAccessorType
+                    MapEntryAccessorType;
+                // Internal stored type in MapEntryLite for given wire field type.
+                typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::TypeOnMemory TypeOnMemory;
+                // Corresponding wire type for field type.
+                static constexpr WireFormatLite::WireType kWireType =
+                    MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kWireType;
+                // Whether wire type is for message.
+                static constexpr bool kIsMessage =
+                    MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsMessage;
+                // Whether wire type is for enum.
+                static constexpr bool kIsEnum =
+                    MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsEnum;
+
+                // Functions used in parsing and serialization. ===================
+                static inline size_t ByteSize(const MapEntryAccessorType& value);
+                static inline int GetCachedSize(const MapEntryAccessorType& value);
+                static inline bool Read(io::CodedInputStream* input, MapEntryAccessorType* value);
+                static inline const char* Read(const char* ptr, ParseContext* ctx, MapEntryAccessorType* value);
+
+                static inline uint8_t* Write(int field, const MapEntryAccessorType& value, uint8_t* ptr, io::EpsCopyOutputStream* stream);
+
+                // Functions to manipulate data on memory. ========================
+                static inline const Type& GetExternalReference(const Type* value);
+                static inline void DeleteNoArena(const Type* x);
+                static inline void Merge(const Type& from, Type** to, Arena* arena);
+                static inline void Clear(Type** value, Arena* arena);
+                static constexpr TypeOnMemory Constinit();
+
+                static inline Type* EnsureMutable(Type** value, Arena* arena);
+                // SpaceUsedInMapEntry: Return bytes used by value in MapEntry, excluding
+                // those already calculate in sizeof(MapField).
+                static inline size_t SpaceUsedInMapEntryLong(const Type* value);
+                // Return default instance if value is not initialized when calling const
+                // reference accessor.
+                static inline const Type& DefaultIfNotInitialized(const Type* value);
+                // Check if all required fields have values set.
+                static inline bool IsInitialized(Type* value);
+            };
+
+#define MAP_HANDLER(FieldType)                                                                                                     \
+    template<typename Type>                                                                                                        \
+    class MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>                                                                   \
+    {                                                                                                                              \
+    public:                                                                                                                        \
+        typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type>::MapEntryAccessorType                      \
+            MapEntryAccessorType;                                                                                                  \
+        typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type>::TypeOnMemory TypeOnMemory;                \
+        static const WireFormatLite::WireType kWireType =                                                                          \
+            MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type>::kWireType;                                             \
+        static const bool kIsMessage =                                                                                             \
+            MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type>::kIsMessage;                                            \
+        static const bool kIsEnum =                                                                                                \
+            MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type>::kIsEnum;                                               \
+        static inline int ByteSize(const MapEntryAccessorType& value);                                                             \
+        static inline int GetCachedSize(const MapEntryAccessorType& value);                                                        \
+        static inline bool Read(io::CodedInputStream* input, MapEntryAccessorType* value);                                         \
+        static inline const char* Read(const char* begin, ParseContext* ctx, MapEntryAccessorType* value);                         \
+        static inline uint8_t* Write(int field, const MapEntryAccessorType& value, uint8_t* ptr, io::EpsCopyOutputStream* stream); \
+        static inline const MapEntryAccessorType& GetExternalReference(                                                            \
+            const TypeOnMemory& value                                                                                              \
+        );                                                                                                                         \
+        static inline void DeleteNoArena(const TypeOnMemory& x);                                                                   \
+        static inline void Merge(const MapEntryAccessorType& from, TypeOnMemory* to, Arena* arena);                                \
+        static inline void Clear(TypeOnMemory* value, Arena* arena);                                                               \
+        static inline size_t SpaceUsedInMapEntryLong(const TypeOnMemory& value);                                                   \
+        static inline const MapEntryAccessorType& DefaultIfNotInitialized(                                                         \
+            const TypeOnMemory& value                                                                                              \
+        );                                                                                                                         \
+        static inline bool IsInitialized(const TypeOnMemory& value);                                                               \
+        static void DeleteNoArena(TypeOnMemory& value);                                                                            \
+        static constexpr TypeOnMemory Constinit();                                                                                 \
+        static inline MapEntryAccessorType* EnsureMutable(TypeOnMemory* value, Arena* arena);                                      \
+    };
+            MAP_HANDLER(STRING)
+            MAP_HANDLER(BYTES)
+            MAP_HANDLER(INT64)
+            MAP_HANDLER(UINT64)
+            MAP_HANDLER(INT32)
+            MAP_HANDLER(UINT32)
+            MAP_HANDLER(SINT64)
+            MAP_HANDLER(SINT32)
+            MAP_HANDLER(ENUM)
+            MAP_HANDLER(DOUBLE)
+            MAP_HANDLER(FLOAT)
+            MAP_HANDLER(FIXED64)
+            MAP_HANDLER(FIXED32)
+            MAP_HANDLER(SFIXED64)
+            MAP_HANDLER(SFIXED32)
+            MAP_HANDLER(BOOL)
 #undef MAP_HANDLER
 
-template <typename Type>
-inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ByteSize(
-    const MapEntryAccessorType& value) {
-  return WireFormatLite::MessageSizeNoVirtual(value);
-}
-
-#define GOOGLE_PROTOBUF_BYTE_SIZE(FieldType, DeclaredType)                     \
-  template <typename Type>                                                     \
-  inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
-      const MapEntryAccessorType& value) {                                     \
-    return static_cast<int>(WireFormatLite::DeclaredType##Size(value));        \
-  }
-
-GOOGLE_PROTOBUF_BYTE_SIZE(STRING, String)
-GOOGLE_PROTOBUF_BYTE_SIZE(BYTES, Bytes)
-GOOGLE_PROTOBUF_BYTE_SIZE(INT64, Int64)
-GOOGLE_PROTOBUF_BYTE_SIZE(UINT64, UInt64)
-GOOGLE_PROTOBUF_BYTE_SIZE(INT32, Int32)
-GOOGLE_PROTOBUF_BYTE_SIZE(UINT32, UInt32)
-GOOGLE_PROTOBUF_BYTE_SIZE(SINT64, SInt64)
-GOOGLE_PROTOBUF_BYTE_SIZE(SINT32, SInt32)
-GOOGLE_PROTOBUF_BYTE_SIZE(ENUM, Enum)
+            template<typename Type>
+            inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ByteSize(
+                const MapEntryAccessorType& value
+            )
+            {
+                return WireFormatLite::MessageSizeNoVirtual(value);
+            }
+
+#define GOOGLE_PROTOBUF_BYTE_SIZE(FieldType, DeclaredType)                       \
+    template<typename Type>                                                      \
+    inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
+        const MapEntryAccessorType& value                                        \
+    )                                                                            \
+    {                                                                            \
+        return static_cast<int>(WireFormatLite::DeclaredType##Size(value));      \
+    }
+
+            GOOGLE_PROTOBUF_BYTE_SIZE(STRING, String)
+            GOOGLE_PROTOBUF_BYTE_SIZE(BYTES, Bytes)
+            GOOGLE_PROTOBUF_BYTE_SIZE(INT64, Int64)
+            GOOGLE_PROTOBUF_BYTE_SIZE(UINT64, UInt64)
+            GOOGLE_PROTOBUF_BYTE_SIZE(INT32, Int32)
+            GOOGLE_PROTOBUF_BYTE_SIZE(UINT32, UInt32)
+            GOOGLE_PROTOBUF_BYTE_SIZE(SINT64, SInt64)
+            GOOGLE_PROTOBUF_BYTE_SIZE(SINT32, SInt32)
+            GOOGLE_PROTOBUF_BYTE_SIZE(ENUM, Enum)
 
 #undef GOOGLE_PROTOBUF_BYTE_SIZE
 
-#define FIXED_BYTE_SIZE(FieldType, DeclaredType)                               \
-  template <typename Type>                                                     \
-  inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
-      const MapEntryAccessorType& /* value */) {                               \
-    return WireFormatLite::k##DeclaredType##Size;                              \
-  }
-
-FIXED_BYTE_SIZE(DOUBLE, Double)
-FIXED_BYTE_SIZE(FLOAT, Float)
-FIXED_BYTE_SIZE(FIXED64, Fixed64)
-FIXED_BYTE_SIZE(FIXED32, Fixed32)
-FIXED_BYTE_SIZE(SFIXED64, SFixed64)
-FIXED_BYTE_SIZE(SFIXED32, SFixed32)
-FIXED_BYTE_SIZE(BOOL, Bool)
+#define FIXED_BYTE_SIZE(FieldType, DeclaredType)                                 \
+    template<typename Type>                                                      \
+    inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
+        const MapEntryAccessorType& /* value */                                  \
+    )                                                                            \
+    {                                                                            \
+        return WireFormatLite::k##DeclaredType##Size;                            \
+    }
+
+            FIXED_BYTE_SIZE(DOUBLE, Double)
+            FIXED_BYTE_SIZE(FLOAT, Float)
+            FIXED_BYTE_SIZE(FIXED64, Fixed64)
+            FIXED_BYTE_SIZE(FIXED32, Fixed32)
+            FIXED_BYTE_SIZE(SFIXED64, SFixed64)
+            FIXED_BYTE_SIZE(SFIXED32, SFixed32)
+            FIXED_BYTE_SIZE(BOOL, Bool)
 
 #undef FIXED_BYTE_SIZE
 
-template <typename Type>
-inline int MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetCachedSize(
-    const MapEntryAccessorType& value) {
-  return static_cast<int>(WireFormatLite::LengthDelimitedSize(
-      static_cast<size_t>(value.GetCachedSize())));
-}
-
-#define GET_CACHED_SIZE(FieldType, DeclaredType)                         \
-  template <typename Type>                                               \
-  inline int                                                             \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
-      const MapEntryAccessorType& value) {                               \
-    return static_cast<int>(WireFormatLite::DeclaredType##Size(value));  \
-  }
-
-GET_CACHED_SIZE(STRING, String)
-GET_CACHED_SIZE(BYTES, Bytes)
-GET_CACHED_SIZE(INT64, Int64)
-GET_CACHED_SIZE(UINT64, UInt64)
-GET_CACHED_SIZE(INT32, Int32)
-GET_CACHED_SIZE(UINT32, UInt32)
-GET_CACHED_SIZE(SINT64, SInt64)
-GET_CACHED_SIZE(SINT32, SInt32)
-GET_CACHED_SIZE(ENUM, Enum)
+            template<typename Type>
+            inline int MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetCachedSize(
+                const MapEntryAccessorType& value
+            )
+            {
+                return static_cast<int>(WireFormatLite::LengthDelimitedSize(
+                    static_cast<size_t>(value.GetCachedSize())
+                ));
+            }
+
+#define GET_CACHED_SIZE(FieldType, DeclaredType)                               \
+    template<typename Type>                                                    \
+    inline int                                                                 \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
+            const MapEntryAccessorType& value                                  \
+        )                                                                      \
+    {                                                                          \
+        return static_cast<int>(WireFormatLite::DeclaredType##Size(value));    \
+    }
+
+            GET_CACHED_SIZE(STRING, String)
+            GET_CACHED_SIZE(BYTES, Bytes)
+            GET_CACHED_SIZE(INT64, Int64)
+            GET_CACHED_SIZE(UINT64, UInt64)
+            GET_CACHED_SIZE(INT32, Int32)
+            GET_CACHED_SIZE(UINT32, UInt32)
+            GET_CACHED_SIZE(SINT64, SInt64)
+            GET_CACHED_SIZE(SINT32, SInt32)
+            GET_CACHED_SIZE(ENUM, Enum)
 
 #undef GET_CACHED_SIZE
 
-#define GET_FIXED_CACHED_SIZE(FieldType, DeclaredType)                   \
-  template <typename Type>                                               \
-  inline int                                                             \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
-      const MapEntryAccessorType& /* value */) {                         \
-    return WireFormatLite::k##DeclaredType##Size;                        \
-  }
-
-GET_FIXED_CACHED_SIZE(DOUBLE, Double)
-GET_FIXED_CACHED_SIZE(FLOAT, Float)
-GET_FIXED_CACHED_SIZE(FIXED64, Fixed64)
-GET_FIXED_CACHED_SIZE(FIXED32, Fixed32)
-GET_FIXED_CACHED_SIZE(SFIXED64, SFixed64)
-GET_FIXED_CACHED_SIZE(SFIXED32, SFixed32)
-GET_FIXED_CACHED_SIZE(BOOL, Bool)
+#define GET_FIXED_CACHED_SIZE(FieldType, DeclaredType)                         \
+    template<typename Type>                                                    \
+    inline int                                                                 \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
+            const MapEntryAccessorType& /* value */                            \
+        )                                                                      \
+    {                                                                          \
+        return WireFormatLite::k##DeclaredType##Size;                          \
+    }
+
+            GET_FIXED_CACHED_SIZE(DOUBLE, Double)
+            GET_FIXED_CACHED_SIZE(FLOAT, Float)
+            GET_FIXED_CACHED_SIZE(FIXED64, Fixed64)
+            GET_FIXED_CACHED_SIZE(FIXED32, Fixed32)
+            GET_FIXED_CACHED_SIZE(SFIXED64, SFixed64)
+            GET_FIXED_CACHED_SIZE(SFIXED32, SFixed32)
+            GET_FIXED_CACHED_SIZE(BOOL, Bool)
 
 #undef GET_FIXED_CACHED_SIZE
 
-template <typename Type>
-inline uint8_t* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Write(
-    int field, const MapEntryAccessorType& value, uint8_t* ptr,
-    io::EpsCopyOutputStream* stream) {
-  ptr = stream->EnsureSpace(ptr);
-  return WireFormatLite::InternalWriteMessage(
-      field, value, value.GetCachedSize(), ptr, stream);
-}
-
-#define WRITE_METHOD(FieldType, DeclaredType)                     \
-  template <typename Type>                                        \
-  inline uint8_t*                                                 \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write(  \
-      int field, const MapEntryAccessorType& value, uint8_t* ptr, \
-      io::EpsCopyOutputStream* stream) {                          \
-    ptr = stream->EnsureSpace(ptr);                               \
-    return stream->Write##DeclaredType(field, value, ptr);        \
-  }
-
-WRITE_METHOD(STRING, String)
-WRITE_METHOD(BYTES, Bytes)
+            template<typename Type>
+            inline uint8_t* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Write(
+                int field, const MapEntryAccessorType& value, uint8_t* ptr, io::EpsCopyOutputStream* stream
+            )
+            {
+                ptr = stream->EnsureSpace(ptr);
+                return WireFormatLite::InternalWriteMessage(
+                    field, value, value.GetCachedSize(), ptr, stream
+                );
+            }
+
+#define WRITE_METHOD(FieldType, DeclaredType)                                                           \
+    template<typename Type>                                                                             \
+    inline uint8_t*                                                                                     \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write(                                  \
+            int field, const MapEntryAccessorType& value, uint8_t* ptr, io::EpsCopyOutputStream* stream \
+        )                                                                                               \
+    {                                                                                                   \
+        ptr = stream->EnsureSpace(ptr);                                                                 \
+        return stream->Write##DeclaredType(field, value, ptr);                                          \
+    }
+
+            WRITE_METHOD(STRING, String)
+            WRITE_METHOD(BYTES, Bytes)
 
 #undef WRITE_METHOD
-#define WRITE_METHOD(FieldType, DeclaredType)                               \
-  template <typename Type>                                                  \
-  inline uint8_t*                                                           \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write(            \
-      int field, const MapEntryAccessorType& value, uint8_t* ptr,           \
-      io::EpsCopyOutputStream* stream) {                                    \
-    ptr = stream->EnsureSpace(ptr);                                         \
-    return WireFormatLite::Write##DeclaredType##ToArray(field, value, ptr); \
-  }
-
-WRITE_METHOD(INT64, Int64)
-WRITE_METHOD(UINT64, UInt64)
-WRITE_METHOD(INT32, Int32)
-WRITE_METHOD(UINT32, UInt32)
-WRITE_METHOD(SINT64, SInt64)
-WRITE_METHOD(SINT32, SInt32)
-WRITE_METHOD(ENUM, Enum)
-WRITE_METHOD(DOUBLE, Double)
-WRITE_METHOD(FLOAT, Float)
-WRITE_METHOD(FIXED64, Fixed64)
-WRITE_METHOD(FIXED32, Fixed32)
-WRITE_METHOD(SFIXED64, SFixed64)
-WRITE_METHOD(SFIXED32, SFixed32)
-WRITE_METHOD(BOOL, Bool)
+#define WRITE_METHOD(FieldType, DeclaredType)                                                           \
+    template<typename Type>                                                                             \
+    inline uint8_t*                                                                                     \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write(                                  \
+            int field, const MapEntryAccessorType& value, uint8_t* ptr, io::EpsCopyOutputStream* stream \
+        )                                                                                               \
+    {                                                                                                   \
+        ptr = stream->EnsureSpace(ptr);                                                                 \
+        return WireFormatLite::Write##DeclaredType##ToArray(field, value, ptr);                         \
+    }
+
+            WRITE_METHOD(INT64, Int64)
+            WRITE_METHOD(UINT64, UInt64)
+            WRITE_METHOD(INT32, Int32)
+            WRITE_METHOD(UINT32, UInt32)
+            WRITE_METHOD(SINT64, SInt64)
+            WRITE_METHOD(SINT32, SInt32)
+            WRITE_METHOD(ENUM, Enum)
+            WRITE_METHOD(DOUBLE, Double)
+            WRITE_METHOD(FLOAT, Float)
+            WRITE_METHOD(FIXED64, Fixed64)
+            WRITE_METHOD(FIXED32, Fixed32)
+            WRITE_METHOD(SFIXED64, SFixed64)
+            WRITE_METHOD(SFIXED32, SFixed32)
+            WRITE_METHOD(BOOL, Bool)
 
 #undef WRITE_METHOD
 
-template <typename Type>
-inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
-    io::CodedInputStream* input, MapEntryAccessorType* value) {
-  return WireFormatLite::ReadMessageNoVirtual(input, value);
-}
-
-template <typename Type>
-inline bool MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
-    io::CodedInputStream* input, MapEntryAccessorType* value) {
-  return WireFormatLite::ReadString(input, value);
-}
-
-template <typename Type>
-inline bool MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
-    io::CodedInputStream* input, MapEntryAccessorType* value) {
-  return WireFormatLite::ReadBytes(input, value);
-}
-
-template <typename Type>
-const char* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
-    const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
-  return ctx->ParseMessage(value, ptr);
-}
-
-template <typename Type>
-const char* MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
-    const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
-  int size = ReadSize(&ptr);
-  GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-  return ctx->ReadString(ptr, size, value);
-}
-
-template <typename Type>
-const char* MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
-    const char* ptr, ParseContext* ctx, MapEntryAccessorType* value) {
-  int size = ReadSize(&ptr);
-  GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-  return ctx->ReadString(ptr, size, value);
-}
-
-inline const char* ReadINT64(const char* ptr, int64_t* value) {
-  return VarintParse(ptr, reinterpret_cast<uint64_t*>(value));
-}
-inline const char* ReadUINT64(const char* ptr, uint64_t* value) {
-  return VarintParse(ptr, value);
-}
-inline const char* ReadINT32(const char* ptr, int32_t* value) {
-  return VarintParse(ptr, reinterpret_cast<uint32_t*>(value));
-}
-inline const char* ReadUINT32(const char* ptr, uint32_t* value) {
-  return VarintParse(ptr, value);
-}
-inline const char* ReadSINT64(const char* ptr, int64_t* value) {
-  *value = ReadVarintZigZag64(&ptr);
-  return ptr;
-}
-inline const char* ReadSINT32(const char* ptr, int32_t* value) {
-  *value = ReadVarintZigZag32(&ptr);
-  return ptr;
-}
-template <typename E>
-inline const char* ReadENUM(const char* ptr, E* value) {
-  *value = static_cast<E>(ReadVarint32(&ptr));
-  return ptr;
-}
-inline const char* ReadBOOL(const char* ptr, bool* value) {
-  *value = static_cast<bool>(ReadVarint32(&ptr));
-  return ptr;
-}
-
-template <typename F>
-inline const char* ReadUnaligned(const char* ptr, F* value) {
-  *value = UnalignedLoad<F>(ptr);
-  return ptr + sizeof(F);
-}
-inline const char* ReadFLOAT(const char* ptr, float* value) {
-  return ReadUnaligned(ptr, value);
-}
-inline const char* ReadDOUBLE(const char* ptr, double* value) {
-  return ReadUnaligned(ptr, value);
-}
-inline const char* ReadFIXED64(const char* ptr, uint64_t* value) {
-  return ReadUnaligned(ptr, value);
-}
-inline const char* ReadFIXED32(const char* ptr, uint32_t* value) {
-  return ReadUnaligned(ptr, value);
-}
-inline const char* ReadSFIXED64(const char* ptr, int64_t* value) {
-  return ReadUnaligned(ptr, value);
-}
-inline const char* ReadSFIXED32(const char* ptr, int32_t* value) {
-  return ReadUnaligned(ptr, value);
-}
-
-#define READ_METHOD(FieldType)                                              \
-  template <typename Type>                                                  \
-  inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read( \
-      io::CodedInputStream* input, MapEntryAccessorType* value) {           \
-    return WireFormatLite::ReadPrimitive<TypeOnMemory,                      \
-                                         WireFormatLite::TYPE_##FieldType>( \
-        input, value);                                                      \
-  }                                                                         \
-  template <typename Type>                                                  \
-  const char* MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read( \
-      const char* begin, ParseContext* ctx, MapEntryAccessorType* value) {  \
-    (void)ctx;                                                              \
-    return Read##FieldType(begin, value);                                   \
-  }
-
-READ_METHOD(INT64)
-READ_METHOD(UINT64)
-READ_METHOD(INT32)
-READ_METHOD(UINT32)
-READ_METHOD(SINT64)
-READ_METHOD(SINT32)
-READ_METHOD(ENUM)
-READ_METHOD(DOUBLE)
-READ_METHOD(FLOAT)
-READ_METHOD(FIXED64)
-READ_METHOD(FIXED32)
-READ_METHOD(SFIXED64)
-READ_METHOD(SFIXED32)
-READ_METHOD(BOOL)
+            template<typename Type>
+            inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
+                io::CodedInputStream* input, MapEntryAccessorType* value
+            )
+            {
+                return WireFormatLite::ReadMessageNoVirtual(input, value);
+            }
+
+            template<typename Type>
+            inline bool MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
+                io::CodedInputStream* input, MapEntryAccessorType* value
+            )
+            {
+                return WireFormatLite::ReadString(input, value);
+            }
+
+            template<typename Type>
+            inline bool MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
+                io::CodedInputStream* input, MapEntryAccessorType* value
+            )
+            {
+                return WireFormatLite::ReadBytes(input, value);
+            }
+
+            template<typename Type>
+            const char* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
+                const char* ptr, ParseContext* ctx, MapEntryAccessorType* value
+            )
+            {
+                return ctx->ParseMessage(value, ptr);
+            }
+
+            template<typename Type>
+            const char* MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
+                const char* ptr, ParseContext* ctx, MapEntryAccessorType* value
+            )
+            {
+                int size = ReadSize(&ptr);
+                GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                return ctx->ReadString(ptr, size, value);
+            }
+
+            template<typename Type>
+            const char* MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
+                const char* ptr, ParseContext* ctx, MapEntryAccessorType* value
+            )
+            {
+                int size = ReadSize(&ptr);
+                GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                return ctx->ReadString(ptr, size, value);
+            }
+
+            inline const char* ReadINT64(const char* ptr, int64_t* value)
+            {
+                return VarintParse(ptr, reinterpret_cast<uint64_t*>(value));
+            }
+            inline const char* ReadUINT64(const char* ptr, uint64_t* value)
+            {
+                return VarintParse(ptr, value);
+            }
+            inline const char* ReadINT32(const char* ptr, int32_t* value)
+            {
+                return VarintParse(ptr, reinterpret_cast<uint32_t*>(value));
+            }
+            inline const char* ReadUINT32(const char* ptr, uint32_t* value)
+            {
+                return VarintParse(ptr, value);
+            }
+            inline const char* ReadSINT64(const char* ptr, int64_t* value)
+            {
+                *value = ReadVarintZigZag64(&ptr);
+                return ptr;
+            }
+            inline const char* ReadSINT32(const char* ptr, int32_t* value)
+            {
+                *value = ReadVarintZigZag32(&ptr);
+                return ptr;
+            }
+            template<typename E>
+            inline const char* ReadENUM(const char* ptr, E* value)
+            {
+                *value = static_cast<E>(ReadVarint32(&ptr));
+                return ptr;
+            }
+            inline const char* ReadBOOL(const char* ptr, bool* value)
+            {
+                *value = static_cast<bool>(ReadVarint32(&ptr));
+                return ptr;
+            }
+
+            template<typename F>
+            inline const char* ReadUnaligned(const char* ptr, F* value)
+            {
+                *value = UnalignedLoad<F>(ptr);
+                return ptr + sizeof(F);
+            }
+            inline const char* ReadFLOAT(const char* ptr, float* value)
+            {
+                return ReadUnaligned(ptr, value);
+            }
+            inline const char* ReadDOUBLE(const char* ptr, double* value)
+            {
+                return ReadUnaligned(ptr, value);
+            }
+            inline const char* ReadFIXED64(const char* ptr, uint64_t* value)
+            {
+                return ReadUnaligned(ptr, value);
+            }
+            inline const char* ReadFIXED32(const char* ptr, uint32_t* value)
+            {
+                return ReadUnaligned(ptr, value);
+            }
+            inline const char* ReadSFIXED64(const char* ptr, int64_t* value)
+            {
+                return ReadUnaligned(ptr, value);
+            }
+            inline const char* ReadSFIXED32(const char* ptr, int32_t* value)
+            {
+                return ReadUnaligned(ptr, value);
+            }
+
+#define READ_METHOD(FieldType)                                                                \
+    template<typename Type>                                                                   \
+    inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read(                 \
+        io::CodedInputStream* input, MapEntryAccessorType* value                              \
+    )                                                                                         \
+    {                                                                                         \
+        return WireFormatLite::ReadPrimitive<TypeOnMemory, WireFormatLite::TYPE_##FieldType>( \
+            input, value                                                                      \
+        );                                                                                    \
+    }                                                                                         \
+    template<typename Type>                                                                   \
+    const char* MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read(                 \
+        const char* begin, ParseContext* ctx, MapEntryAccessorType* value                     \
+    )                                                                                         \
+    {                                                                                         \
+        (void)ctx;                                                                            \
+        return Read##FieldType(begin, value);                                                 \
+    }
+
+            READ_METHOD(INT64)
+            READ_METHOD(UINT64)
+            READ_METHOD(INT32)
+            READ_METHOD(UINT32)
+            READ_METHOD(SINT64)
+            READ_METHOD(SINT32)
+            READ_METHOD(ENUM)
+            READ_METHOD(DOUBLE)
+            READ_METHOD(FLOAT)
+            READ_METHOD(FIXED64)
+            READ_METHOD(FIXED32)
+            READ_METHOD(SFIXED64)
+            READ_METHOD(SFIXED32)
+            READ_METHOD(BOOL)
 
 #undef READ_METHOD
 
-// Definition for message handler
-
-template <typename Type>
-inline const Type&
-MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetExternalReference(
-    const Type* value) {
-  return *value;
-}
-
-template <typename Type>
-inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
-                             Type>::SpaceUsedInMapEntryLong(const Type* value) {
-  return value->SpaceUsedLong();
-}
-
-template <typename Type>
-inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Clear(
-    Type** value, Arena* /* arena */) {
-  if (*value != nullptr) (*value)->Clear();
-}
-template <typename Type>
-inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Merge(
-    const Type& from, Type** to, Arena* /* arena */) {
-  (*to)->MergeFrom(from);
-}
-
-template <typename Type>
-void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DeleteNoArena(
-    const Type* ptr) {
-  delete ptr;
-}
-
-template <typename Type>
-constexpr auto MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Constinit()
-    -> TypeOnMemory {
-  return nullptr;
-}
-
-template <typename Type>
-inline Type* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::EnsureMutable(
-    Type** value, Arena* arena) {
-  if (*value == nullptr) {
-    *value = MapArenaMessageCreator<
-        Type,
-        Arena::is_arena_constructable<Type>::type::value>::CreateMessage(arena);
-  }
-  return *value;
-}
-
-template <typename Type>
-inline const Type&
-MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DefaultIfNotInitialized(
-    const Type* value) {
-  return value != nullptr ? *value : *Type::internal_default_instance();
-}
-
-template <typename Type>
-inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::IsInitialized(
-    Type* value) {
-  return value ? value->IsInitialized() : false;
-}
-
-// Definition for string/bytes handler
-
-#define STRING_OR_BYTES_HANDLER_FUNCTIONS(FieldType)                          \
-  template <typename Type>                                                    \
-  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,      \
-                                       Type>::MapEntryAccessorType&           \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                            \
-                 Type>::GetExternalReference(const TypeOnMemory& value) {     \
-    return value.Get();                                                       \
-  }                                                                           \
-  template <typename Type>                                                    \
-  inline size_t                                                               \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                            \
-                 Type>::SpaceUsedInMapEntryLong(const TypeOnMemory& value) {  \
-    return sizeof(value);                                                     \
-  }                                                                           \
-  template <typename Type>                                                    \
-  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear(  \
-      TypeOnMemory* value, Arena* /* arena */) {                              \
-    value->ClearToEmpty();                                                    \
-  }                                                                           \
-  template <typename Type>                                                    \
-  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge(  \
-      const MapEntryAccessorType& from, TypeOnMemory* to, Arena* arena) {     \
-    to->Set(from, arena);                                                     \
-  }                                                                           \
-  template <typename Type>                                                    \
-  void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DeleteNoArena( \
-      TypeOnMemory& value) {                                                  \
-    value.Destroy();                                                          \
-  }                                                                           \
-  template <typename Type>                                                    \
-  constexpr auto                                                              \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit()         \
-      ->TypeOnMemory {                                                        \
-    return TypeOnMemory(&internal::fixed_address_empty_string,                \
-                        ConstantInitialized{});                               \
-  }                                                                           \
-  template <typename Type>                                                    \
-  inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,            \
-                                 Type>::MapEntryAccessorType*                 \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(      \
-      TypeOnMemory* value, Arena* arena) {                                    \
-    return value->Mutable(arena);                                             \
-  }                                                                           \
-  template <typename Type>                                                    \
-  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,      \
-                                       Type>::MapEntryAccessorType&           \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                            \
-                 Type>::DefaultIfNotInitialized(const TypeOnMemory& value) {  \
-    return value.Get();                                                       \
-  }                                                                           \
-  template <typename Type>                                                    \
-  inline bool                                                                 \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized(      \
-      const TypeOnMemory& /* value */) {                                      \
-    return true;                                                              \
-  }
-STRING_OR_BYTES_HANDLER_FUNCTIONS(STRING)
-STRING_OR_BYTES_HANDLER_FUNCTIONS(BYTES)
+            // Definition for message handler
+
+            template<typename Type>
+            inline const Type&
+                MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetExternalReference(
+                    const Type* value
+                )
+            {
+                return *value;
+            }
+
+            template<typename Type>
+            inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::SpaceUsedInMapEntryLong(const Type* value)
+            {
+                return value->SpaceUsedLong();
+            }
+
+            template<typename Type>
+            inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Clear(
+                Type** value, Arena* /* arena */
+            )
+            {
+                if (*value != nullptr)
+                    (*value)->Clear();
+            }
+            template<typename Type>
+            inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Merge(
+                const Type& from, Type** to, Arena* /* arena */
+            )
+            {
+                (*to)->MergeFrom(from);
+            }
+
+            template<typename Type>
+            void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DeleteNoArena(
+                const Type* ptr
+            )
+            {
+                delete ptr;
+            }
+
+            template<typename Type>
+            constexpr auto MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Constinit()
+                -> TypeOnMemory
+            {
+                return nullptr;
+            }
+
+            template<typename Type>
+            inline Type* MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::EnsureMutable(
+                Type** value, Arena* arena
+            )
+            {
+                if (*value == nullptr)
+                {
+                    *value = MapArenaMessageCreator<
+                        Type,
+                        Arena::is_arena_constructable<Type>::type::value>::CreateMessage(arena);
+                }
+                return *value;
+            }
+
+            template<typename Type>
+            inline const Type&
+                MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DefaultIfNotInitialized(
+                    const Type* value
+                )
+            {
+                return value != nullptr ? *value : *Type::internal_default_instance();
+            }
+
+            template<typename Type>
+            inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::IsInitialized(
+                Type* value
+            )
+            {
+                return value ? value->IsInitialized() : false;
+            }
+
+            // Definition for string/bytes handler
+
+#define STRING_OR_BYTES_HANDLER_FUNCTIONS(FieldType)                                                               \
+    template<typename Type>                                                                                        \
+    inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::MapEntryAccessorType&            \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetExternalReference(const TypeOnMemory& value)    \
+    {                                                                                                              \
+        return value.Get();                                                                                        \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline size_t                                                                                                  \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::SpaceUsedInMapEntryLong(const TypeOnMemory& value) \
+    {                                                                                                              \
+        return sizeof(value);                                                                                      \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear(                                     \
+        TypeOnMemory* value, Arena* /* arena */                                                                    \
+    )                                                                                                              \
+    {                                                                                                              \
+        value->ClearToEmpty();                                                                                     \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge(                                     \
+        const MapEntryAccessorType& from, TypeOnMemory* to, Arena* arena                                           \
+    )                                                                                                              \
+    {                                                                                                              \
+        to->Set(from, arena);                                                                                      \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DeleteNoArena(                                    \
+        TypeOnMemory& value                                                                                        \
+    )                                                                                                              \
+    {                                                                                                              \
+        value.Destroy();                                                                                           \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    constexpr auto                                                                                                 \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit()                                        \
+            ->TypeOnMemory                                                                                         \
+    {                                                                                                              \
+        return TypeOnMemory(&internal::fixed_address_empty_string, ConstantInitialized{});                         \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::MapEntryAccessorType*                  \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(                                     \
+            TypeOnMemory* value, Arena* arena                                                                      \
+        )                                                                                                          \
+    {                                                                                                              \
+        return value->Mutable(arena);                                                                              \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::MapEntryAccessorType&            \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DefaultIfNotInitialized(const TypeOnMemory& value) \
+    {                                                                                                              \
+        return value.Get();                                                                                        \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline bool                                                                                                    \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized(                                     \
+            const TypeOnMemory& /* value */                                                                        \
+        )                                                                                                          \
+    {                                                                                                              \
+        return true;                                                                                               \
+    }
+            STRING_OR_BYTES_HANDLER_FUNCTIONS(STRING)
+            STRING_OR_BYTES_HANDLER_FUNCTIONS(BYTES)
 #undef STRING_OR_BYTES_HANDLER_FUNCTIONS
 
-#define PRIMITIVE_HANDLER_FUNCTIONS(FieldType)                               \
-  template <typename Type>                                                   \
-  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,     \
-                                       Type>::MapEntryAccessorType&          \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                           \
-                 Type>::GetExternalReference(const TypeOnMemory& value) {    \
-    return value;                                                            \
-  }                                                                          \
-  template <typename Type>                                                   \
-  inline size_t MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::     \
-      SpaceUsedInMapEntryLong(const TypeOnMemory& /* value */) {             \
-    return 0;                                                                \
-  }                                                                          \
-  template <typename Type>                                                   \
-  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear( \
-      TypeOnMemory* value, Arena* /* arena */) {                             \
-    *value = 0;                                                              \
-  }                                                                          \
-  template <typename Type>                                                   \
-  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge( \
-      const MapEntryAccessorType& from, TypeOnMemory* to,                    \
-      Arena* /* arena */) {                                                  \
-    *to = from;                                                              \
-  }                                                                          \
-  template <typename Type>                                                   \
-  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType,               \
-                             Type>::DeleteNoArena(TypeOnMemory& /* x */) {}  \
-  template <typename Type>                                                   \
-  constexpr auto                                                             \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit()        \
-      ->TypeOnMemory {                                                       \
-    return 0;                                                                \
-  }                                                                          \
-  template <typename Type>                                                   \
-  inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,           \
-                                 Type>::MapEntryAccessorType*                \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(     \
-      TypeOnMemory* value, Arena* /* arena */) {                             \
-    return value;                                                            \
-  }                                                                          \
-  template <typename Type>                                                   \
-  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,     \
-                                       Type>::MapEntryAccessorType&          \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                           \
-                 Type>::DefaultIfNotInitialized(const TypeOnMemory& value) { \
-    return value;                                                            \
-  }                                                                          \
-  template <typename Type>                                                   \
-  inline bool                                                                \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized(     \
-      const TypeOnMemory& /* value */) {                                     \
-    return true;                                                             \
-  }
-PRIMITIVE_HANDLER_FUNCTIONS(INT64)
-PRIMITIVE_HANDLER_FUNCTIONS(UINT64)
-PRIMITIVE_HANDLER_FUNCTIONS(INT32)
-PRIMITIVE_HANDLER_FUNCTIONS(UINT32)
-PRIMITIVE_HANDLER_FUNCTIONS(SINT64)
-PRIMITIVE_HANDLER_FUNCTIONS(SINT32)
-PRIMITIVE_HANDLER_FUNCTIONS(ENUM)
-PRIMITIVE_HANDLER_FUNCTIONS(DOUBLE)
-PRIMITIVE_HANDLER_FUNCTIONS(FLOAT)
-PRIMITIVE_HANDLER_FUNCTIONS(FIXED64)
-PRIMITIVE_HANDLER_FUNCTIONS(FIXED32)
-PRIMITIVE_HANDLER_FUNCTIONS(SFIXED64)
-PRIMITIVE_HANDLER_FUNCTIONS(SFIXED32)
-PRIMITIVE_HANDLER_FUNCTIONS(BOOL)
+#define PRIMITIVE_HANDLER_FUNCTIONS(FieldType)                                                                     \
+    template<typename Type>                                                                                        \
+    inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::MapEntryAccessorType&            \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetExternalReference(const TypeOnMemory& value)    \
+    {                                                                                                              \
+        return value;                                                                                              \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline size_t MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::                                         \
+        SpaceUsedInMapEntryLong(const TypeOnMemory& /* value */)                                                   \
+    {                                                                                                              \
+        return 0;                                                                                                  \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear(                                     \
+        TypeOnMemory* value, Arena* /* arena */                                                                    \
+    )                                                                                                              \
+    {                                                                                                              \
+        *value = 0;                                                                                                \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge(                                     \
+        const MapEntryAccessorType& from, TypeOnMemory* to, Arena* /* arena */                                     \
+    )                                                                                                              \
+    {                                                                                                              \
+        *to = from;                                                                                                \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DeleteNoArena(TypeOnMemory& /* x */)       \
+    {                                                                                                              \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    constexpr auto                                                                                                 \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit()                                        \
+            ->TypeOnMemory                                                                                         \
+    {                                                                                                              \
+        return 0;                                                                                                  \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::MapEntryAccessorType*                  \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(                                     \
+            TypeOnMemory* value, Arena* /* arena */                                                                \
+        )                                                                                                          \
+    {                                                                                                              \
+        return value;                                                                                              \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::MapEntryAccessorType&            \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DefaultIfNotInitialized(const TypeOnMemory& value) \
+    {                                                                                                              \
+        return value;                                                                                              \
+    }                                                                                                              \
+    template<typename Type>                                                                                        \
+    inline bool                                                                                                    \
+        MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::IsInitialized(                                     \
+            const TypeOnMemory& /* value */                                                                        \
+        )                                                                                                          \
+    {                                                                                                              \
+        return true;                                                                                               \
+    }
+            PRIMITIVE_HANDLER_FUNCTIONS(INT64)
+            PRIMITIVE_HANDLER_FUNCTIONS(UINT64)
+            PRIMITIVE_HANDLER_FUNCTIONS(INT32)
+            PRIMITIVE_HANDLER_FUNCTIONS(UINT32)
+            PRIMITIVE_HANDLER_FUNCTIONS(SINT64)
+            PRIMITIVE_HANDLER_FUNCTIONS(SINT32)
+            PRIMITIVE_HANDLER_FUNCTIONS(ENUM)
+            PRIMITIVE_HANDLER_FUNCTIONS(DOUBLE)
+            PRIMITIVE_HANDLER_FUNCTIONS(FLOAT)
+            PRIMITIVE_HANDLER_FUNCTIONS(FIXED64)
+            PRIMITIVE_HANDLER_FUNCTIONS(FIXED32)
+            PRIMITIVE_HANDLER_FUNCTIONS(SFIXED64)
+            PRIMITIVE_HANDLER_FUNCTIONS(SFIXED32)
+            PRIMITIVE_HANDLER_FUNCTIONS(BOOL)
 #undef PRIMITIVE_HANDLER_FUNCTIONS
 
-// Functions for operating on a map entry using type handlers.
-//
-// Does not contain any representation (this class is not intended to be
-// instantiated).
-template <typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType>
-struct MapEntryFuncs {
-  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
-  typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
-  enum : int {
-    kKeyFieldNumber = 1,
-    kValueFieldNumber = 2
-  };
-
-  static uint8_t* InternalSerialize(int field_number, const Key& key,
-                                    const Value& value, uint8_t* ptr,
-                                    io::EpsCopyOutputStream* stream) {
-    ptr = stream->EnsureSpace(ptr);
-    ptr = WireFormatLite::WriteTagToArray(
-        field_number, WireFormatLite::WIRETYPE_LENGTH_DELIMITED, ptr);
-    ptr = io::CodedOutputStream::WriteVarint32ToArray(GetCachedSize(key, value),
-                                                      ptr);
-
-    ptr = KeyTypeHandler::Write(kKeyFieldNumber, key, ptr, stream);
-    return ValueTypeHandler::Write(kValueFieldNumber, value, ptr, stream);
-  }
-
-  static size_t ByteSizeLong(const Key& key, const Value& value) {
-    // Tags for key and value will both be one byte (field numbers 1 and 2).
-    size_t inner_length =
-        2 + KeyTypeHandler::ByteSize(key) + ValueTypeHandler::ByteSize(value);
-    return inner_length + io::CodedOutputStream::VarintSize32(
-                              static_cast<uint32_t>(inner_length));
-  }
-
-  static int GetCachedSize(const Key& key, const Value& value) {
-    // Tags for key and value will both be one byte (field numbers 1 and 2).
-    return 2 + KeyTypeHandler::GetCachedSize(key) +
-           ValueTypeHandler::GetCachedSize(value);
-  }
-};
-
-}  // namespace internal
-}  // namespace protobuf
+            // Functions for operating on a map entry using type handlers.
+            //
+            // Does not contain any representation (this class is not intended to be
+            // instantiated).
+            template<typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType, WireFormatLite::FieldType kValueFieldType>
+            struct MapEntryFuncs
+            {
+                typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+                typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
+                enum : int
+                {
+                    kKeyFieldNumber = 1,
+                    kValueFieldNumber = 2
+                };
+
+                static uint8_t* InternalSerialize(int field_number, const Key& key, const Value& value, uint8_t* ptr, io::EpsCopyOutputStream* stream)
+                {
+                    ptr = stream->EnsureSpace(ptr);
+                    ptr = WireFormatLite::WriteTagToArray(
+                        field_number, WireFormatLite::WIRETYPE_LENGTH_DELIMITED, ptr
+                    );
+                    ptr = io::CodedOutputStream::WriteVarint32ToArray(GetCachedSize(key, value), ptr);
+
+                    ptr = KeyTypeHandler::Write(kKeyFieldNumber, key, ptr, stream);
+                    return ValueTypeHandler::Write(kValueFieldNumber, value, ptr, stream);
+                }
+
+                static size_t ByteSizeLong(const Key& key, const Value& value)
+                {
+                    // Tags for key and value will both be one byte (field numbers 1 and 2).
+                    size_t inner_length =
+                        2 + KeyTypeHandler::ByteSize(key) + ValueTypeHandler::ByteSize(value);
+                    return inner_length + io::CodedOutputStream::VarintSize32(
+                                              static_cast<uint32_t>(inner_length)
+                                          );
+                }
+
+                static int GetCachedSize(const Key& key, const Value& value)
+                {
+                    // Tags for key and value will both be one byte (field numbers 1 and 2).
+                    return 2 + KeyTypeHandler::GetCachedSize(key) +
+                           ValueTypeHandler::GetCachedSize(value);
+                }
+            };
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_MAP_TYPE_HANDLER_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/message.h b/CAPI/cpp/grpc/include/google/protobuf/message.h
index 39ec154..b63d396 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/message.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/message.h
@@ -110,7 +110,6 @@
 #ifndef GOOGLE_PROTOBUF_MESSAGE_H__
 #define GOOGLE_PROTOBUF_MESSAGE_H__
 
-
 #include <iosfwd>
 #include <string>
 #include <type_traits>
@@ -126,7 +125,6 @@
 #include <google/protobuf/map.h>  // TODO(b/211442718): cleanup
 #include <google/protobuf/message_lite.h>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
@@ -134,1362 +132,1299 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-// Defined in this file.
-class Message;
-class Reflection;
-class MessageFactory;
-
-// Defined in other files.
-class AssignDescriptorsHelper;
-class DynamicMessageFactory;
-class GeneratedMessageReflectionTestHelper;
-class MapKey;
-class MapValueConstRef;
-class MapValueRef;
-class MapIterator;
-class MapReflectionTester;
-
-namespace internal {
-struct DescriptorTable;
-class MapFieldBase;
-class SwapFieldHelper;
-class CachedSize;
-}  // namespace internal
-class UnknownFieldSet;  // unknown_field_set.h
-namespace io {
-class ZeroCopyInputStream;   // zero_copy_stream.h
-class ZeroCopyOutputStream;  // zero_copy_stream.h
-class CodedInputStream;      // coded_stream.h
-class CodedOutputStream;     // coded_stream.h
-}  // namespace io
-namespace python {
-class MapReflectionFriend;  // scalar_map_container.h
-class MessageReflectionFriend;
-}  // namespace python
-namespace expr {
-class CelMapReflectionFriend;  // field_backed_map_impl.cc
-}
-
-namespace internal {
-class MapFieldPrinterHelper;  // text_format.cc
-}
-namespace util {
-class MessageDifferencer;
-}
-
-
-namespace internal {
-class ReflectionAccessor;      // message.cc
-class ReflectionOps;           // reflection_ops.h
-class MapKeySorter;            // wire_format.cc
-class WireFormat;              // wire_format.h
-class MapFieldReflectionTest;  // map_test.cc
-}  // namespace internal
-
-template <typename T>
-class RepeatedField;  // repeated_field.h
-
-template <typename T>
-class RepeatedPtrField;  // repeated_field.h
-
-// A container to hold message metadata.
-struct Metadata {
-  const Descriptor* descriptor;
-  const Reflection* reflection;
-};
-
-namespace internal {
-template <class To>
-inline To* GetPointerAtOffset(Message* message, uint32_t offset) {
-  return reinterpret_cast<To*>(reinterpret_cast<char*>(message) + offset);
-}
-
-template <class To>
-const To* GetConstPointerAtOffset(const Message* message, uint32_t offset) {
-  return reinterpret_cast<const To*>(reinterpret_cast<const char*>(message) +
-                                     offset);
-}
-
-template <class To>
-const To& GetConstRefAtOffset(const Message& message, uint32_t offset) {
-  return *GetConstPointerAtOffset<To>(&message, offset);
-}
-
-bool CreateUnknownEnumValues(const FieldDescriptor* field);
-
-// Returns true if "message" is a descendant of "root".
-PROTOBUF_EXPORT bool IsDescendant(Message& root, const Message& message);
-}  // namespace internal
-
-// Abstract interface for protocol messages.
-//
-// See also MessageLite, which contains most every-day operations.  Message
-// adds descriptors and reflection on top of that.
-//
-// The methods of this class that are virtual but not pure-virtual have
-// default implementations based on reflection.  Message classes which are
-// optimized for speed will want to override these with faster implementations,
-// but classes optimized for code size may be happy with keeping them.  See
-// the optimize_for option in descriptor.proto.
-//
-// Users must not derive from this class. Only the protocol compiler and
-// the internal library are allowed to create subclasses.
-class PROTOBUF_EXPORT Message : public MessageLite {
- public:
-  constexpr Message() {}
-
-  // Basic Operations ------------------------------------------------
-
-  // Construct a new instance of the same type.  Ownership is passed to the
-  // caller.  (This is also defined in MessageLite, but is defined again here
-  // for return-type covariance.)
-  Message* New() const { return New(nullptr); }
-
-  // Construct a new instance on the arena. Ownership is passed to the caller
-  // if arena is a nullptr.
-  Message* New(Arena* arena) const override = 0;
-
-  // Make this message into a copy of the given message.  The given message
-  // must have the same descriptor, but need not necessarily be the same class.
-  // By default this is just implemented as "Clear(); MergeFrom(from);".
-  void CopyFrom(const Message& from);
-
-  // Merge the fields from the given message into this message.  Singular
-  // fields will be overwritten, if specified in from, except for embedded
-  // messages which will be merged.  Repeated fields will be concatenated.
-  // The given message must be of the same type as this message (i.e. the
-  // exact same class).
-  virtual void MergeFrom(const Message& from);
-
-  // Verifies that IsInitialized() returns true.  GOOGLE_CHECK-fails otherwise, with
-  // a nice error message.
-  void CheckInitialized() const;
-
-  // Slowly build a list of all required fields that are not set.
-  // This is much, much slower than IsInitialized() as it is implemented
-  // purely via reflection.  Generally, you should not call this unless you
-  // have already determined that an error exists by calling IsInitialized().
-  void FindInitializationErrors(std::vector<std::string>* errors) const;
-
-  // Like FindInitializationErrors, but joins all the strings, delimited by
-  // commas, and returns them.
-  std::string InitializationErrorString() const override;
-
-  // Clears all unknown fields from this message and all embedded messages.
-  // Normally, if unknown tag numbers are encountered when parsing a message,
-  // the tag and value are stored in the message's UnknownFieldSet and
-  // then written back out when the message is serialized.  This allows servers
-  // which simply route messages to other servers to pass through messages
-  // that have new field definitions which they don't yet know about.  However,
-  // this behavior can have security implications.  To avoid it, call this
-  // method after parsing.
-  //
-  // See Reflection::GetUnknownFields() for more on unknown fields.
-  void DiscardUnknownFields();
-
-  // Computes (an estimate of) the total number of bytes currently used for
-  // storing the message in memory.  The default implementation calls the
-  // Reflection object's SpaceUsed() method.
-  //
-  // SpaceUsed() is noticeably slower than ByteSize(), as it is implemented
-  // using reflection (rather than the generated code implementation for
-  // ByteSize()). Like ByteSize(), its CPU time is linear in the number of
-  // fields defined for the proto.
-  virtual size_t SpaceUsedLong() const;
-
-  PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
-  int SpaceUsed() const { return internal::ToIntSize(SpaceUsedLong()); }
-
-  // Debugging & Testing----------------------------------------------
-
-  // Generates a human-readable form of this message for debugging purposes.
-  // Note that the format and content of a debug string is not guaranteed, may
-  // change without notice, and should not be depended on. Code that does
-  // anything except display a string to assist in debugging should use
-  // TextFormat instead.
-  std::string DebugString() const;
-  // Like DebugString(), but with less whitespace.
-  std::string ShortDebugString() const;
-  // Like DebugString(), but do not escape UTF-8 byte sequences.
-  std::string Utf8DebugString() const;
-  // Convenience function useful in GDB.  Prints DebugString() to stdout.
-  void PrintDebugString() const;
-
-  // Reflection-based methods ----------------------------------------
-  // These methods are pure-virtual in MessageLite, but Message provides
-  // reflection-based default implementations.
-
-  std::string GetTypeName() const override;
-  void Clear() override;
-
-  // Returns whether all required fields have been set. Note that required
-  // fields no longer exist starting in proto3.
-  bool IsInitialized() const override;
-
-  void CheckTypeAndMergeFrom(const MessageLite& other) override;
-  // Reflective parser
-  const char* _InternalParse(const char* ptr,
-                             internal::ParseContext* ctx) override;
-  size_t ByteSizeLong() const override;
-  uint8_t* _InternalSerialize(uint8_t* target,
-                              io::EpsCopyOutputStream* stream) const override;
-
- private:
-  // This is called only by the default implementation of ByteSize(), to
-  // update the cached size.  If you override ByteSize(), you do not need
-  // to override this.  If you do not override ByteSize(), you MUST override
-  // this; the default implementation will crash.
-  //
-  // The method is private because subclasses should never call it; only
-  // override it.  Yes, C++ lets you do that.  Crazy, huh?
-  virtual void SetCachedSize(int size) const;
-
- public:
-  // Introspection ---------------------------------------------------
-
-
-  // Get a non-owning pointer to a Descriptor for this message's type.  This
-  // describes what fields the message contains, the types of those fields, etc.
-  // This object remains property of the Message.
-  const Descriptor* GetDescriptor() const { return GetMetadata().descriptor; }
-
-  // Get a non-owning pointer to the Reflection interface for this Message,
-  // which can be used to read and modify the fields of the Message dynamically
-  // (in other words, without knowing the message type at compile time).  This
-  // object remains property of the Message.
-  const Reflection* GetReflection() const { return GetMetadata().reflection; }
-
- protected:
-  // Get a struct containing the metadata for the Message, which is used in turn
-  // to implement GetDescriptor() and GetReflection() above.
-  virtual Metadata GetMetadata() const = 0;
-
-  struct ClassData {
-    // Note: The order of arguments (to, then from) is chosen so that the ABI
-    // of this function is the same as the CopyFrom method.  That is, the
-    // hidden "this" parameter comes first.
-    void (*copy_to_from)(Message& to, const Message& from_msg);
-    void (*merge_to_from)(Message& to, const Message& from_msg);
-  };
-  // GetClassData() returns a pointer to a ClassData struct which
-  // exists in global memory and is unique to each subclass.  This uniqueness
-  // property is used in order to quickly determine whether two messages are
-  // of the same type.
-  // TODO(jorg): change to pure virtual
-  virtual const ClassData* GetClassData() const { return nullptr; }
-
-  // CopyWithSourceCheck calls Clear() and then MergeFrom(), and in debug
-  // builds, checks that calling Clear() on the destination message doesn't
-  // alter the source.  It assumes the messages are known to be of the same
-  // type, and thus uses GetClassData().
-  static void CopyWithSourceCheck(Message& to, const Message& from);
-
-  // Fail if "from" is a descendant of "to" as such copy is not allowed.
-  static void FailIfCopyFromDescendant(Message& to, const Message& from);
-
-  inline explicit Message(Arena* arena, bool is_message_owned = false)
-      : MessageLite(arena, is_message_owned) {}
-  size_t ComputeUnknownFieldsSize(size_t total_size,
-                                  internal::CachedSize* cached_size) const;
-  size_t MaybeComputeUnknownFieldsSize(size_t total_size,
-                                       internal::CachedSize* cached_size) const;
-
-
- protected:
-  static uint64_t GetInvariantPerBuild(uint64_t salt);
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
-};
-
-namespace internal {
-// Forward-declare interfaces used to implement RepeatedFieldRef.
-// These are protobuf internals that users shouldn't care about.
-class RepeatedFieldAccessor;
-}  // namespace internal
-
-// Forward-declare RepeatedFieldRef templates. The second type parameter is
-// used for SFINAE tricks. Users should ignore it.
-template <typename T, typename Enable = void>
-class RepeatedFieldRef;
-
-template <typename T, typename Enable = void>
-class MutableRepeatedFieldRef;
-
-// This interface contains methods that can be used to dynamically access
-// and modify the fields of a protocol message.  Their semantics are
-// similar to the accessors the protocol compiler generates.
-//
-// To get the Reflection for a given Message, call Message::GetReflection().
-//
-// This interface is separate from Message only for efficiency reasons;
-// the vast majority of implementations of Message will share the same
-// implementation of Reflection (GeneratedMessageReflection,
-// defined in generated_message.h), and all Messages of a particular class
-// should share the same Reflection object (though you should not rely on
-// the latter fact).
-//
-// There are several ways that these methods can be used incorrectly.  For
-// example, any of the following conditions will lead to undefined
-// results (probably assertion failures):
-// - The FieldDescriptor is not a field of this message type.
-// - The method called is not appropriate for the field's type.  For
-//   each field type in FieldDescriptor::TYPE_*, there is only one
-//   Get*() method, one Set*() method, and one Add*() method that is
-//   valid for that type.  It should be obvious which (except maybe
-//   for TYPE_BYTES, which are represented using strings in C++).
-// - A Get*() or Set*() method for singular fields is called on a repeated
-//   field.
-// - GetRepeated*(), SetRepeated*(), or Add*() is called on a non-repeated
-//   field.
-// - The Message object passed to any method is not of the right type for
-//   this Reflection object (i.e. message.GetReflection() != reflection).
-//
-// You might wonder why there is not any abstract representation for a field
-// of arbitrary type.  E.g., why isn't there just a "GetField()" method that
-// returns "const Field&", where "Field" is some class with accessors like
-// "GetInt32Value()".  The problem is that someone would have to deal with
-// allocating these Field objects.  For generated message classes, having to
-// allocate space for an additional object to wrap every field would at least
-// double the message's memory footprint, probably worse.  Allocating the
-// objects on-demand, on the other hand, would be expensive and prone to
-// memory leaks.  So, instead we ended up with this flat interface.
-class PROTOBUF_EXPORT Reflection final {
- public:
-  // Get the UnknownFieldSet for the message.  This contains fields which
-  // were seen when the Message was parsed but were not recognized according
-  // to the Message's definition.
-  const UnknownFieldSet& GetUnknownFields(const Message& message) const;
-  // Get a mutable pointer to the UnknownFieldSet for the message.  This
-  // contains fields which were seen when the Message was parsed but were not
-  // recognized according to the Message's definition.
-  UnknownFieldSet* MutableUnknownFields(Message* message) const;
-
-  // Estimate the amount of memory used by the message object.
-  size_t SpaceUsedLong(const Message& message) const;
-
-  PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
-  int SpaceUsed(const Message& message) const {
-    return internal::ToIntSize(SpaceUsedLong(message));
-  }
-
-  // Check if the given non-repeated field is set.
-  bool HasField(const Message& message, const FieldDescriptor* field) const;
-
-  // Get the number of elements of a repeated field.
-  int FieldSize(const Message& message, const FieldDescriptor* field) const;
-
-  // Clear the value of a field, so that HasField() returns false or
-  // FieldSize() returns zero.
-  void ClearField(Message* message, const FieldDescriptor* field) const;
-
-  // Check if the oneof is set. Returns true if any field in oneof
-  // is set, false otherwise.
-  bool HasOneof(const Message& message,
-                const OneofDescriptor* oneof_descriptor) const;
-
-  void ClearOneof(Message* message,
-                  const OneofDescriptor* oneof_descriptor) const;
-
-  // Returns the field descriptor if the oneof is set. nullptr otherwise.
-  const FieldDescriptor* GetOneofFieldDescriptor(
-      const Message& message, const OneofDescriptor* oneof_descriptor) const;
-
-  // Removes the last element of a repeated field.
-  // We don't provide a way to remove any element other than the last
-  // because it invites inefficient use, such as O(n^2) filtering loops
-  // that should have been O(n).  If you want to remove an element other
-  // than the last, the best way to do it is to re-arrange the elements
-  // (using Swap()) so that the one you want removed is at the end, then
-  // call RemoveLast().
-  void RemoveLast(Message* message, const FieldDescriptor* field) const;
-  // Removes the last element of a repeated message field, and returns the
-  // pointer to the caller.  Caller takes ownership of the returned pointer.
-  PROTOBUF_NODISCARD Message* ReleaseLast(Message* message,
-                                          const FieldDescriptor* field) const;
-
-  // Similar to ReleaseLast() without internal safety and ownershp checks. This
-  // method should only be used when the objects are on the same arena or paired
-  // with a call to `UnsafeArenaAddAllocatedMessage`.
-  Message* UnsafeArenaReleaseLast(Message* message,
-                                  const FieldDescriptor* field) const;
-
-  // Swap the complete contents of two messages.
-  void Swap(Message* message1, Message* message2) const;
-
-  // Swap fields listed in fields vector of two messages.
-  void SwapFields(Message* message1, Message* message2,
-                  const std::vector<const FieldDescriptor*>& fields) const;
-
-  // Swap two elements of a repeated field.
-  void SwapElements(Message* message, const FieldDescriptor* field, int index1,
-                    int index2) const;
-
-  // Swap without internal safety and ownership checks. This method should only
-  // be used when the objects are on the same arena.
-  void UnsafeArenaSwap(Message* lhs, Message* rhs) const;
-
-  // SwapFields without internal safety and ownership checks. This method should
-  // only be used when the objects are on the same arena.
-  void UnsafeArenaSwapFields(
-      Message* lhs, Message* rhs,
-      const std::vector<const FieldDescriptor*>& fields) const;
-
-  // List all fields of the message which are currently set, except for unknown
-  // fields, but including extension known to the parser (i.e. compiled in).
-  // Singular fields will only be listed if HasField(field) would return true
-  // and repeated fields will only be listed if FieldSize(field) would return
-  // non-zero.  Fields (both normal fields and extension fields) will be listed
-  // ordered by field number.
-  // Use Reflection::GetUnknownFields() or message.unknown_fields() to also get
-  // access to fields/extensions unknown to the parser.
-  void ListFields(const Message& message,
-                  std::vector<const FieldDescriptor*>* output) const;
-
-  // Singular field getters ------------------------------------------
-  // These get the value of a non-repeated field.  They return the default
-  // value for fields that aren't set.
-
-  int32_t GetInt32(const Message& message, const FieldDescriptor* field) const;
-  int64_t GetInt64(const Message& message, const FieldDescriptor* field) const;
-  uint32_t GetUInt32(const Message& message,
-                     const FieldDescriptor* field) const;
-  uint64_t GetUInt64(const Message& message,
-                     const FieldDescriptor* field) const;
-  float GetFloat(const Message& message, const FieldDescriptor* field) const;
-  double GetDouble(const Message& message, const FieldDescriptor* field) const;
-  bool GetBool(const Message& message, const FieldDescriptor* field) const;
-  std::string GetString(const Message& message,
-                        const FieldDescriptor* field) const;
-  const EnumValueDescriptor* GetEnum(const Message& message,
-                                     const FieldDescriptor* field) const;
-
-  // GetEnumValue() returns an enum field's value as an integer rather than
-  // an EnumValueDescriptor*. If the integer value does not correspond to a
-  // known value descriptor, a new value descriptor is created. (Such a value
-  // will only be present when the new unknown-enum-value semantics are enabled
-  // for a message.)
-  int GetEnumValue(const Message& message, const FieldDescriptor* field) const;
-
-  // See MutableMessage() for the meaning of the "factory" parameter.
-  const Message& GetMessage(const Message& message,
-                            const FieldDescriptor* field,
-                            MessageFactory* factory = nullptr) const;
-
-  // Get a string value without copying, if possible.
-  //
-  // GetString() necessarily returns a copy of the string.  This can be
-  // inefficient when the std::string is already stored in a std::string object
-  // in the underlying message.  GetStringReference() will return a reference to
-  // the underlying std::string in this case.  Otherwise, it will copy the
-  // string into *scratch and return that.
-  //
-  // Note:  It is perfectly reasonable and useful to write code like:
-  //     str = reflection->GetStringReference(message, field, &str);
-  //   This line would ensure that only one copy of the string is made
-  //   regardless of the field's underlying representation.  When initializing
-  //   a newly-constructed string, though, it's just as fast and more
-  //   readable to use code like:
-  //     std::string str = reflection->GetString(message, field);
-  const std::string& GetStringReference(const Message& message,
-                                        const FieldDescriptor* field,
-                                        std::string* scratch) const;
-
-
-  // Singular field mutators -----------------------------------------
-  // These mutate the value of a non-repeated field.
-
-  void SetInt32(Message* message, const FieldDescriptor* field,
-                int32_t value) const;
-  void SetInt64(Message* message, const FieldDescriptor* field,
-                int64_t value) const;
-  void SetUInt32(Message* message, const FieldDescriptor* field,
-                 uint32_t value) const;
-  void SetUInt64(Message* message, const FieldDescriptor* field,
-                 uint64_t value) const;
-  void SetFloat(Message* message, const FieldDescriptor* field,
-                float value) const;
-  void SetDouble(Message* message, const FieldDescriptor* field,
-                 double value) const;
-  void SetBool(Message* message, const FieldDescriptor* field,
-               bool value) const;
-  void SetString(Message* message, const FieldDescriptor* field,
-                 std::string value) const;
-  void SetEnum(Message* message, const FieldDescriptor* field,
-               const EnumValueDescriptor* value) const;
-  // Set an enum field's value with an integer rather than EnumValueDescriptor.
-  // For proto3 this is just setting the enum field to the value specified, for
-  // proto2 it's more complicated. If value is a known enum value the field is
-  // set as usual. If the value is unknown then it is added to the unknown field
-  // set. Note this matches the behavior of parsing unknown enum values.
-  // If multiple calls with unknown values happen than they are all added to the
-  // unknown field set in order of the calls.
-  void SetEnumValue(Message* message, const FieldDescriptor* field,
-                    int value) const;
-
-  // Get a mutable pointer to a field with a message type.  If a MessageFactory
-  // is provided, it will be used to construct instances of the sub-message;
-  // otherwise, the default factory is used.  If the field is an extension that
-  // does not live in the same pool as the containing message's descriptor (e.g.
-  // it lives in an overlay pool), then a MessageFactory must be provided.
-  // If you have no idea what that meant, then you probably don't need to worry
-  // about it (don't provide a MessageFactory).  WARNING:  If the
-  // FieldDescriptor is for a compiled-in extension, then
-  // factory->GetPrototype(field->message_type()) MUST return an instance of
-  // the compiled-in class for this type, NOT DynamicMessage.
-  Message* MutableMessage(Message* message, const FieldDescriptor* field,
-                          MessageFactory* factory = nullptr) const;
-
-  // Replaces the message specified by 'field' with the already-allocated object
-  // sub_message, passing ownership to the message.  If the field contained a
-  // message, that message is deleted.  If sub_message is nullptr, the field is
-  // cleared.
-  void SetAllocatedMessage(Message* message, Message* sub_message,
-                           const FieldDescriptor* field) const;
-
-  // Similar to `SetAllocatedMessage`, but omits all internal safety and
-  // ownership checks.  This method should only be used when the objects are on
-  // the same arena or paired with a call to `UnsafeArenaReleaseMessage`.
-  void UnsafeArenaSetAllocatedMessage(Message* message, Message* sub_message,
-                                      const FieldDescriptor* field) const;
-
-  // Releases the message specified by 'field' and returns the pointer,
-  // ReleaseMessage() will return the message the message object if it exists.
-  // Otherwise, it may or may not return nullptr.  In any case, if the return
-  // value is non-null, the caller takes ownership of the pointer.
-  // If the field existed (HasField() is true), then the returned pointer will
-  // be the same as the pointer returned by MutableMessage().
-  // This function has the same effect as ClearField().
-  PROTOBUF_NODISCARD Message* ReleaseMessage(
-      Message* message, const FieldDescriptor* field,
-      MessageFactory* factory = nullptr) const;
-
-  // Similar to `ReleaseMessage`, but omits all internal safety and ownership
-  // checks.  This method should only be used when the objects are on the same
-  // arena or paired with a call to `UnsafeArenaSetAllocatedMessage`.
-  Message* UnsafeArenaReleaseMessage(Message* message,
-                                     const FieldDescriptor* field,
-                                     MessageFactory* factory = nullptr) const;
-
-
-  // Repeated field getters ------------------------------------------
-  // These get the value of one element of a repeated field.
-
-  int32_t GetRepeatedInt32(const Message& message, const FieldDescriptor* field,
-                           int index) const;
-  int64_t GetRepeatedInt64(const Message& message, const FieldDescriptor* field,
-                           int index) const;
-  uint32_t GetRepeatedUInt32(const Message& message,
-                             const FieldDescriptor* field, int index) const;
-  uint64_t GetRepeatedUInt64(const Message& message,
-                             const FieldDescriptor* field, int index) const;
-  float GetRepeatedFloat(const Message& message, const FieldDescriptor* field,
-                         int index) const;
-  double GetRepeatedDouble(const Message& message, const FieldDescriptor* field,
-                           int index) const;
-  bool GetRepeatedBool(const Message& message, const FieldDescriptor* field,
-                       int index) const;
-  std::string GetRepeatedString(const Message& message,
-                                const FieldDescriptor* field, int index) const;
-  const EnumValueDescriptor* GetRepeatedEnum(const Message& message,
-                                             const FieldDescriptor* field,
-                                             int index) const;
-  // GetRepeatedEnumValue() returns an enum field's value as an integer rather
-  // than an EnumValueDescriptor*. If the integer value does not correspond to a
-  // known value descriptor, a new value descriptor is created. (Such a value
-  // will only be present when the new unknown-enum-value semantics are enabled
-  // for a message.)
-  int GetRepeatedEnumValue(const Message& message, const FieldDescriptor* field,
-                           int index) const;
-  const Message& GetRepeatedMessage(const Message& message,
-                                    const FieldDescriptor* field,
-                                    int index) const;
-
-  // See GetStringReference(), above.
-  const std::string& GetRepeatedStringReference(const Message& message,
-                                                const FieldDescriptor* field,
-                                                int index,
-                                                std::string* scratch) const;
-
-
-  // Repeated field mutators -----------------------------------------
-  // These mutate the value of one element of a repeated field.
-
-  void SetRepeatedInt32(Message* message, const FieldDescriptor* field,
-                        int index, int32_t value) const;
-  void SetRepeatedInt64(Message* message, const FieldDescriptor* field,
-                        int index, int64_t value) const;
-  void SetRepeatedUInt32(Message* message, const FieldDescriptor* field,
-                         int index, uint32_t value) const;
-  void SetRepeatedUInt64(Message* message, const FieldDescriptor* field,
-                         int index, uint64_t value) const;
-  void SetRepeatedFloat(Message* message, const FieldDescriptor* field,
-                        int index, float value) const;
-  void SetRepeatedDouble(Message* message, const FieldDescriptor* field,
-                         int index, double value) const;
-  void SetRepeatedBool(Message* message, const FieldDescriptor* field,
-                       int index, bool value) const;
-  void SetRepeatedString(Message* message, const FieldDescriptor* field,
-                         int index, std::string value) const;
-  void SetRepeatedEnum(Message* message, const FieldDescriptor* field,
-                       int index, const EnumValueDescriptor* value) const;
-  // Set an enum field's value with an integer rather than EnumValueDescriptor.
-  // For proto3 this is just setting the enum field to the value specified, for
-  // proto2 it's more complicated. If value is a known enum value the field is
-  // set as usual. If the value is unknown then it is added to the unknown field
-  // set. Note this matches the behavior of parsing unknown enum values.
-  // If multiple calls with unknown values happen than they are all added to the
-  // unknown field set in order of the calls.
-  void SetRepeatedEnumValue(Message* message, const FieldDescriptor* field,
-                            int index, int value) const;
-  // Get a mutable pointer to an element of a repeated field with a message
-  // type.
-  Message* MutableRepeatedMessage(Message* message,
-                                  const FieldDescriptor* field,
-                                  int index) const;
-
-
-  // Repeated field adders -------------------------------------------
-  // These add an element to a repeated field.
-
-  void AddInt32(Message* message, const FieldDescriptor* field,
-                int32_t value) const;
-  void AddInt64(Message* message, const FieldDescriptor* field,
-                int64_t value) const;
-  void AddUInt32(Message* message, const FieldDescriptor* field,
-                 uint32_t value) const;
-  void AddUInt64(Message* message, const FieldDescriptor* field,
-                 uint64_t value) const;
-  void AddFloat(Message* message, const FieldDescriptor* field,
-                float value) const;
-  void AddDouble(Message* message, const FieldDescriptor* field,
-                 double value) const;
-  void AddBool(Message* message, const FieldDescriptor* field,
-               bool value) const;
-  void AddString(Message* message, const FieldDescriptor* field,
-                 std::string value) const;
-  void AddEnum(Message* message, const FieldDescriptor* field,
-               const EnumValueDescriptor* value) const;
-  // Add an integer value to a repeated enum field rather than
-  // EnumValueDescriptor. For proto3 this is just setting the enum field to the
-  // value specified, for proto2 it's more complicated. If value is a known enum
-  // value the field is set as usual. If the value is unknown then it is added
-  // to the unknown field set. Note this matches the behavior of parsing unknown
-  // enum values. If multiple calls with unknown values happen than they are all
-  // added to the unknown field set in order of the calls.
-  void AddEnumValue(Message* message, const FieldDescriptor* field,
-                    int value) const;
-  // See MutableMessage() for comments on the "factory" parameter.
-  Message* AddMessage(Message* message, const FieldDescriptor* field,
-                      MessageFactory* factory = nullptr) const;
-
-  // Appends an already-allocated object 'new_entry' to the repeated field
-  // specified by 'field' passing ownership to the message.
-  void AddAllocatedMessage(Message* message, const FieldDescriptor* field,
-                           Message* new_entry) const;
-
-  // Similar to AddAllocatedMessage() without internal safety and ownership
-  // checks. This method should only be used when the objects are on the same
-  // arena or paired with a call to `UnsafeArenaReleaseLast`.
-  void UnsafeArenaAddAllocatedMessage(Message* message,
-                                      const FieldDescriptor* field,
-                                      Message* new_entry) const;
-
-
-  // Get a RepeatedFieldRef object that can be used to read the underlying
-  // repeated field. The type parameter T must be set according to the
-  // field's cpp type. The following table shows the mapping from cpp type
-  // to acceptable T.
-  //
-  //   field->cpp_type()      T
-  //   CPPTYPE_INT32        int32_t
-  //   CPPTYPE_UINT32       uint32_t
-  //   CPPTYPE_INT64        int64_t
-  //   CPPTYPE_UINT64       uint64_t
-  //   CPPTYPE_DOUBLE       double
-  //   CPPTYPE_FLOAT        float
-  //   CPPTYPE_BOOL         bool
-  //   CPPTYPE_ENUM         generated enum type or int32_t
-  //   CPPTYPE_STRING       std::string
-  //   CPPTYPE_MESSAGE      generated message type or google::protobuf::Message
-  //
-  // A RepeatedFieldRef object can be copied and the resulted object will point
-  // to the same repeated field in the same message. The object can be used as
-  // long as the message is not destroyed.
-  //
-  // Note that to use this method users need to include the header file
-  // "reflection.h" (which defines the RepeatedFieldRef class templates).
-  template <typename T>
-  RepeatedFieldRef<T> GetRepeatedFieldRef(const Message& message,
-                                          const FieldDescriptor* field) const;
-
-  // Like GetRepeatedFieldRef() but return an object that can also be used
-  // manipulate the underlying repeated field.
-  template <typename T>
-  MutableRepeatedFieldRef<T> GetMutableRepeatedFieldRef(
-      Message* message, const FieldDescriptor* field) const;
-
-  // DEPRECATED. Please use Get(Mutable)RepeatedFieldRef() for repeated field
-  // access. The following repeated field accessors will be removed in the
-  // future.
-  //
-  // Repeated field accessors  -------------------------------------------------
-  // The methods above, e.g. GetRepeatedInt32(msg, fd, index), provide singular
-  // access to the data in a RepeatedField.  The methods below provide aggregate
-  // access by exposing the RepeatedField object itself with the Message.
-  // Applying these templates to inappropriate types will lead to an undefined
-  // reference at link time (e.g. GetRepeatedField<***double>), or possibly a
-  // template matching error at compile time (e.g. GetRepeatedPtrField<File>).
-  //
-  // Usage example: my_doubs = refl->GetRepeatedField<double>(msg, fd);
-
-  // DEPRECATED. Please use GetRepeatedFieldRef().
-  //
-  // for T = Cord and all protobuf scalar types except enums.
-  template <typename T>
-  PROTOBUF_DEPRECATED_MSG("Please use GetRepeatedFieldRef() instead")
-  const RepeatedField<T>& GetRepeatedField(const Message& msg,
-                                           const FieldDescriptor* d) const {
-    return GetRepeatedFieldInternal<T>(msg, d);
-  }
-
-  // DEPRECATED. Please use GetMutableRepeatedFieldRef().
-  //
-  // for T = Cord and all protobuf scalar types except enums.
-  template <typename T>
-  PROTOBUF_DEPRECATED_MSG("Please use GetMutableRepeatedFieldRef() instead")
-  RepeatedField<T>* MutableRepeatedField(Message* msg,
-                                         const FieldDescriptor* d) const {
-    return MutableRepeatedFieldInternal<T>(msg, d);
-  }
-
-  // DEPRECATED. Please use GetRepeatedFieldRef().
-  //
-  // for T = std::string, google::protobuf::internal::StringPieceField
-  //         google::protobuf::Message & descendants.
-  template <typename T>
-  PROTOBUF_DEPRECATED_MSG("Please use GetRepeatedFieldRef() instead")
-  const RepeatedPtrField<T>& GetRepeatedPtrField(
-      const Message& msg, const FieldDescriptor* d) const {
-    return GetRepeatedPtrFieldInternal<T>(msg, d);
-  }
-
-  // DEPRECATED. Please use GetMutableRepeatedFieldRef().
-  //
-  // for T = std::string, google::protobuf::internal::StringPieceField
-  //         google::protobuf::Message & descendants.
-  template <typename T>
-  PROTOBUF_DEPRECATED_MSG("Please use GetMutableRepeatedFieldRef() instead")
-  RepeatedPtrField<T>* MutableRepeatedPtrField(Message* msg,
-                                               const FieldDescriptor* d) const {
-    return MutableRepeatedPtrFieldInternal<T>(msg, d);
-  }
-
-  // Extensions ----------------------------------------------------------------
-
-  // Try to find an extension of this message type by fully-qualified field
-  // name.  Returns nullptr if no extension is known for this name or number.
-  const FieldDescriptor* FindKnownExtensionByName(
-      const std::string& name) const;
-
-  // Try to find an extension of this message type by field number.
-  // Returns nullptr if no extension is known for this name or number.
-  const FieldDescriptor* FindKnownExtensionByNumber(int number) const;
-
-  // Feature Flags -------------------------------------------------------------
-
-  // Does this message support storing arbitrary integer values in enum fields?
-  // If |true|, GetEnumValue/SetEnumValue and associated repeated-field versions
-  // take arbitrary integer values, and the legacy GetEnum() getter will
-  // dynamically create an EnumValueDescriptor for any integer value without
-  // one. If |false|, setting an unknown enum value via the integer-based
-  // setters results in undefined behavior (in practice, GOOGLE_DCHECK-fails).
-  //
-  // Generic code that uses reflection to handle messages with enum fields
-  // should check this flag before using the integer-based setter, and either
-  // downgrade to a compatible value or use the UnknownFieldSet if not. For
-  // example:
-  //
-  //   int new_value = GetValueFromApplicationLogic();
-  //   if (reflection->SupportsUnknownEnumValues()) {
-  //     reflection->SetEnumValue(message, field, new_value);
-  //   } else {
-  //     if (field_descriptor->enum_type()->
-  //             FindValueByNumber(new_value) != nullptr) {
-  //       reflection->SetEnumValue(message, field, new_value);
-  //     } else if (emit_unknown_enum_values) {
-  //       reflection->MutableUnknownFields(message)->AddVarint(
-  //           field->number(), new_value);
-  //     } else {
-  //       // convert value to a compatible/default value.
-  //       new_value = CompatibleDowngrade(new_value);
-  //       reflection->SetEnumValue(message, field, new_value);
-  //     }
-  //   }
-  bool SupportsUnknownEnumValues() const;
-
-  // Returns the MessageFactory associated with this message.  This can be
-  // useful for determining if a message is a generated message or not, for
-  // example:
-  //   if (message->GetReflection()->GetMessageFactory() ==
-  //       google::protobuf::MessageFactory::generated_factory()) {
-  //     // This is a generated message.
-  //   }
-  // It can also be used to create more messages of this type, though
-  // Message::New() is an easier way to accomplish this.
-  MessageFactory* GetMessageFactory() const;
-
- private:
-  template <typename T>
-  const RepeatedField<T>& GetRepeatedFieldInternal(
-      const Message& message, const FieldDescriptor* field) const;
-  template <typename T>
-  RepeatedField<T>* MutableRepeatedFieldInternal(
-      Message* message, const FieldDescriptor* field) const;
-  template <typename T>
-  const RepeatedPtrField<T>& GetRepeatedPtrFieldInternal(
-      const Message& message, const FieldDescriptor* field) const;
-  template <typename T>
-  RepeatedPtrField<T>* MutableRepeatedPtrFieldInternal(
-      Message* message, const FieldDescriptor* field) const;
-  // Obtain a pointer to a Repeated Field Structure and do some type checking:
-  //   on field->cpp_type(),
-  //   on field->field_option().ctype() (if ctype >= 0)
-  //   of field->message_type() (if message_type != nullptr).
-  // We use 2 routine rather than 4 (const vs mutable) x (scalar vs pointer).
-  void* MutableRawRepeatedField(Message* message, const FieldDescriptor* field,
-                                FieldDescriptor::CppType, int ctype,
-                                const Descriptor* message_type) const;
-
-  const void* GetRawRepeatedField(const Message& message,
-                                  const FieldDescriptor* field,
-                                  FieldDescriptor::CppType cpptype, int ctype,
-                                  const Descriptor* message_type) const;
-
-  // The following methods are used to implement (Mutable)RepeatedFieldRef.
-  // A Ref object will store a raw pointer to the repeated field data (obtained
-  // from RepeatedFieldData()) and a pointer to a Accessor (obtained from
-  // RepeatedFieldAccessor) which will be used to access the raw data.
-
-  // Returns a raw pointer to the repeated field
-  //
-  // "cpp_type" and "message_type" are deduced from the type parameter T passed
-  // to Get(Mutable)RepeatedFieldRef. If T is a generated message type,
-  // "message_type" should be set to its descriptor. Otherwise "message_type"
-  // should be set to nullptr. Implementations of this method should check
-  // whether "cpp_type"/"message_type" is consistent with the actual type of the
-  // field. We use 1 routine rather than 2 (const vs mutable) because it is
-  // protected and it doesn't change the message.
-  void* RepeatedFieldData(Message* message, const FieldDescriptor* field,
-                          FieldDescriptor::CppType cpp_type,
-                          const Descriptor* message_type) const;
-
-  // The returned pointer should point to a singleton instance which implements
-  // the RepeatedFieldAccessor interface.
-  const internal::RepeatedFieldAccessor* RepeatedFieldAccessor(
-      const FieldDescriptor* field) const;
-
-  // Lists all fields of the message which are currently set, except for unknown
-  // fields and stripped fields. See ListFields for details.
-  void ListFieldsOmitStripped(
-      const Message& message,
-      std::vector<const FieldDescriptor*>* output) const;
-
-  bool IsMessageStripped(const Descriptor* descriptor) const {
-    return schema_.IsMessageStripped(descriptor);
-  }
-
-  friend class TextFormat;
-
-  void ListFieldsMayFailOnStripped(
-      const Message& message, bool should_fail,
-      std::vector<const FieldDescriptor*>* output) const;
-
-  // Returns true if the message field is backed by a LazyField.
-  //
-  // A message field may be backed by a LazyField without the user annotation
-  // ([lazy = true]). While the user-annotated LazyField is lazily verified on
-  // first touch (i.e. failure on access rather than parsing if the LazyField is
-  // not initialized), the inferred LazyField is eagerly verified to avoid lazy
-  // parsing error at the cost of lower efficiency. When reflecting a message
-  // field, use this API instead of checking field->options().lazy().
-  bool IsLazyField(const FieldDescriptor* field) const {
-    return IsLazilyVerifiedLazyField(field) ||
-           IsEagerlyVerifiedLazyField(field);
-  }
-
-  // Returns true if the field is lazy extension. It is meant to allow python
-  // reparse lazy field until b/157559327 is fixed.
-  bool IsLazyExtension(const Message& message,
-                       const FieldDescriptor* field) const;
-
-  bool IsLazilyVerifiedLazyField(const FieldDescriptor* field) const;
-  bool IsEagerlyVerifiedLazyField(const FieldDescriptor* field) const;
-
-  friend class FastReflectionMessageMutator;
-  friend bool internal::IsDescendant(Message& root, const Message& message);
-
-  const Descriptor* const descriptor_;
-  const internal::ReflectionSchema schema_;
-  const DescriptorPool* const descriptor_pool_;
-  MessageFactory* const message_factory_;
-
-  // Last non weak field index. This is an optimization when most weak fields
-  // are at the end of the containing message. If a message proto doesn't
-  // contain weak fields, then this field equals descriptor_->field_count().
-  int last_non_weak_field_index_;
-
-  template <typename T, typename Enable>
-  friend class RepeatedFieldRef;
-  template <typename T, typename Enable>
-  friend class MutableRepeatedFieldRef;
-  friend class ::PROTOBUF_NAMESPACE_ID::MessageLayoutInspector;
-  friend class ::PROTOBUF_NAMESPACE_ID::AssignDescriptorsHelper;
-  friend class DynamicMessageFactory;
-  friend class GeneratedMessageReflectionTestHelper;
-  friend class python::MapReflectionFriend;
-  friend class python::MessageReflectionFriend;
-  friend class util::MessageDifferencer;
+namespace google
+{
+    namespace protobuf
+    {
+
+        // Defined in this file.
+        class Message;
+        class Reflection;
+        class MessageFactory;
+
+        // Defined in other files.
+        class AssignDescriptorsHelper;
+        class DynamicMessageFactory;
+        class GeneratedMessageReflectionTestHelper;
+        class MapKey;
+        class MapValueConstRef;
+        class MapValueRef;
+        class MapIterator;
+        class MapReflectionTester;
+
+        namespace internal
+        {
+            struct DescriptorTable;
+            class MapFieldBase;
+            class SwapFieldHelper;
+            class CachedSize;
+        }                       // namespace internal
+        class UnknownFieldSet;  // unknown_field_set.h
+        namespace io
+        {
+            class ZeroCopyInputStream;   // zero_copy_stream.h
+            class ZeroCopyOutputStream;  // zero_copy_stream.h
+            class CodedInputStream;      // coded_stream.h
+            class CodedOutputStream;     // coded_stream.h
+        }                                // namespace io
+        namespace python
+        {
+            class MapReflectionFriend;  // scalar_map_container.h
+            class MessageReflectionFriend;
+        }  // namespace python
+        namespace expr
+        {
+            class CelMapReflectionFriend;  // field_backed_map_impl.cc
+        }
+
+        namespace internal
+        {
+            class MapFieldPrinterHelper;  // text_format.cc
+        }
+        namespace util
+        {
+            class MessageDifferencer;
+        }
+
+        namespace internal
+        {
+            class ReflectionAccessor;      // message.cc
+            class ReflectionOps;           // reflection_ops.h
+            class MapKeySorter;            // wire_format.cc
+            class WireFormat;              // wire_format.h
+            class MapFieldReflectionTest;  // map_test.cc
+        }                                  // namespace internal
+
+        template<typename T>
+        class RepeatedField;  // repeated_field.h
+
+        template<typename T>
+        class RepeatedPtrField;  // repeated_field.h
+
+        // A container to hold message metadata.
+        struct Metadata
+        {
+            const Descriptor* descriptor;
+            const Reflection* reflection;
+        };
+
+        namespace internal
+        {
+            template<class To>
+            inline To* GetPointerAtOffset(Message* message, uint32_t offset)
+            {
+                return reinterpret_cast<To*>(reinterpret_cast<char*>(message) + offset);
+            }
+
+            template<class To>
+            const To* GetConstPointerAtOffset(const Message* message, uint32_t offset)
+            {
+                return reinterpret_cast<const To*>(reinterpret_cast<const char*>(message) + offset);
+            }
+
+            template<class To>
+            const To& GetConstRefAtOffset(const Message& message, uint32_t offset)
+            {
+                return *GetConstPointerAtOffset<To>(&message, offset);
+            }
+
+            bool CreateUnknownEnumValues(const FieldDescriptor* field);
+
+            // Returns true if "message" is a descendant of "root".
+            PROTOBUF_EXPORT bool IsDescendant(Message& root, const Message& message);
+        }  // namespace internal
+
+        // Abstract interface for protocol messages.
+        //
+        // See also MessageLite, which contains most every-day operations.  Message
+        // adds descriptors and reflection on top of that.
+        //
+        // The methods of this class that are virtual but not pure-virtual have
+        // default implementations based on reflection.  Message classes which are
+        // optimized for speed will want to override these with faster implementations,
+        // but classes optimized for code size may be happy with keeping them.  See
+        // the optimize_for option in descriptor.proto.
+        //
+        // Users must not derive from this class. Only the protocol compiler and
+        // the internal library are allowed to create subclasses.
+        class PROTOBUF_EXPORT Message : public MessageLite
+        {
+        public:
+            constexpr Message()
+            {
+            }
+
+            // Basic Operations ------------------------------------------------
+
+            // Construct a new instance of the same type.  Ownership is passed to the
+            // caller.  (This is also defined in MessageLite, but is defined again here
+            // for return-type covariance.)
+            Message* New() const
+            {
+                return New(nullptr);
+            }
+
+            // Construct a new instance on the arena. Ownership is passed to the caller
+            // if arena is a nullptr.
+            Message* New(Arena* arena) const override = 0;
+
+            // Make this message into a copy of the given message.  The given message
+            // must have the same descriptor, but need not necessarily be the same class.
+            // By default this is just implemented as "Clear(); MergeFrom(from);".
+            void CopyFrom(const Message& from);
+
+            // Merge the fields from the given message into this message.  Singular
+            // fields will be overwritten, if specified in from, except for embedded
+            // messages which will be merged.  Repeated fields will be concatenated.
+            // The given message must be of the same type as this message (i.e. the
+            // exact same class).
+            virtual void MergeFrom(const Message& from);
+
+            // Verifies that IsInitialized() returns true.  GOOGLE_CHECK-fails otherwise, with
+            // a nice error message.
+            void CheckInitialized() const;
+
+            // Slowly build a list of all required fields that are not set.
+            // This is much, much slower than IsInitialized() as it is implemented
+            // purely via reflection.  Generally, you should not call this unless you
+            // have already determined that an error exists by calling IsInitialized().
+            void FindInitializationErrors(std::vector<std::string>* errors) const;
+
+            // Like FindInitializationErrors, but joins all the strings, delimited by
+            // commas, and returns them.
+            std::string InitializationErrorString() const override;
+
+            // Clears all unknown fields from this message and all embedded messages.
+            // Normally, if unknown tag numbers are encountered when parsing a message,
+            // the tag and value are stored in the message's UnknownFieldSet and
+            // then written back out when the message is serialized.  This allows servers
+            // which simply route messages to other servers to pass through messages
+            // that have new field definitions which they don't yet know about.  However,
+            // this behavior can have security implications.  To avoid it, call this
+            // method after parsing.
+            //
+            // See Reflection::GetUnknownFields() for more on unknown fields.
+            void DiscardUnknownFields();
+
+            // Computes (an estimate of) the total number of bytes currently used for
+            // storing the message in memory.  The default implementation calls the
+            // Reflection object's SpaceUsed() method.
+            //
+            // SpaceUsed() is noticeably slower than ByteSize(), as it is implemented
+            // using reflection (rather than the generated code implementation for
+            // ByteSize()). Like ByteSize(), its CPU time is linear in the number of
+            // fields defined for the proto.
+            virtual size_t SpaceUsedLong() const;
+
+            PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
+            int SpaceUsed() const
+            {
+                return internal::ToIntSize(SpaceUsedLong());
+            }
+
+            // Debugging & Testing----------------------------------------------
+
+            // Generates a human-readable form of this message for debugging purposes.
+            // Note that the format and content of a debug string is not guaranteed, may
+            // change without notice, and should not be depended on. Code that does
+            // anything except display a string to assist in debugging should use
+            // TextFormat instead.
+            std::string DebugString() const;
+            // Like DebugString(), but with less whitespace.
+            std::string ShortDebugString() const;
+            // Like DebugString(), but do not escape UTF-8 byte sequences.
+            std::string Utf8DebugString() const;
+            // Convenience function useful in GDB.  Prints DebugString() to stdout.
+            void PrintDebugString() const;
+
+            // Reflection-based methods ----------------------------------------
+            // These methods are pure-virtual in MessageLite, but Message provides
+            // reflection-based default implementations.
+
+            std::string GetTypeName() const override;
+            void Clear() override;
+
+            // Returns whether all required fields have been set. Note that required
+            // fields no longer exist starting in proto3.
+            bool IsInitialized() const override;
+
+            void CheckTypeAndMergeFrom(const MessageLite& other) override;
+            // Reflective parser
+            const char* _InternalParse(const char* ptr, internal::ParseContext* ctx) override;
+            size_t ByteSizeLong() const override;
+            uint8_t* _InternalSerialize(uint8_t* target, io::EpsCopyOutputStream* stream) const override;
+
+        private:
+            // This is called only by the default implementation of ByteSize(), to
+            // update the cached size.  If you override ByteSize(), you do not need
+            // to override this.  If you do not override ByteSize(), you MUST override
+            // this; the default implementation will crash.
+            //
+            // The method is private because subclasses should never call it; only
+            // override it.  Yes, C++ lets you do that.  Crazy, huh?
+            virtual void SetCachedSize(int size) const;
+
+        public:
+            // Introspection ---------------------------------------------------
+
+            // Get a non-owning pointer to a Descriptor for this message's type.  This
+            // describes what fields the message contains, the types of those fields, etc.
+            // This object remains property of the Message.
+            const Descriptor* GetDescriptor() const
+            {
+                return GetMetadata().descriptor;
+            }
+
+            // Get a non-owning pointer to the Reflection interface for this Message,
+            // which can be used to read and modify the fields of the Message dynamically
+            // (in other words, without knowing the message type at compile time).  This
+            // object remains property of the Message.
+            const Reflection* GetReflection() const
+            {
+                return GetMetadata().reflection;
+            }
+
+        protected:
+            // Get a struct containing the metadata for the Message, which is used in turn
+            // to implement GetDescriptor() and GetReflection() above.
+            virtual Metadata GetMetadata() const = 0;
+
+            struct ClassData
+            {
+                // Note: The order of arguments (to, then from) is chosen so that the ABI
+                // of this function is the same as the CopyFrom method.  That is, the
+                // hidden "this" parameter comes first.
+                void (*copy_to_from)(Message& to, const Message& from_msg);
+                void (*merge_to_from)(Message& to, const Message& from_msg);
+            };
+            // GetClassData() returns a pointer to a ClassData struct which
+            // exists in global memory and is unique to each subclass.  This uniqueness
+            // property is used in order to quickly determine whether two messages are
+            // of the same type.
+            // TODO(jorg): change to pure virtual
+            virtual const ClassData* GetClassData() const
+            {
+                return nullptr;
+            }
+
+            // CopyWithSourceCheck calls Clear() and then MergeFrom(), and in debug
+            // builds, checks that calling Clear() on the destination message doesn't
+            // alter the source.  It assumes the messages are known to be of the same
+            // type, and thus uses GetClassData().
+            static void CopyWithSourceCheck(Message& to, const Message& from);
+
+            // Fail if "from" is a descendant of "to" as such copy is not allowed.
+            static void FailIfCopyFromDescendant(Message& to, const Message& from);
+
+            inline explicit Message(Arena* arena, bool is_message_owned = false) :
+                MessageLite(arena, is_message_owned)
+            {
+            }
+            size_t ComputeUnknownFieldsSize(size_t total_size, internal::CachedSize* cached_size) const;
+            size_t MaybeComputeUnknownFieldsSize(size_t total_size, internal::CachedSize* cached_size) const;
+
+        protected:
+            static uint64_t GetInvariantPerBuild(uint64_t salt);
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
+        };
+
+        namespace internal
+        {
+            // Forward-declare interfaces used to implement RepeatedFieldRef.
+            // These are protobuf internals that users shouldn't care about.
+            class RepeatedFieldAccessor;
+        }  // namespace internal
+
+        // Forward-declare RepeatedFieldRef templates. The second type parameter is
+        // used for SFINAE tricks. Users should ignore it.
+        template<typename T, typename Enable = void>
+        class RepeatedFieldRef;
+
+        template<typename T, typename Enable = void>
+        class MutableRepeatedFieldRef;
+
+        // This interface contains methods that can be used to dynamically access
+        // and modify the fields of a protocol message.  Their semantics are
+        // similar to the accessors the protocol compiler generates.
+        //
+        // To get the Reflection for a given Message, call Message::GetReflection().
+        //
+        // This interface is separate from Message only for efficiency reasons;
+        // the vast majority of implementations of Message will share the same
+        // implementation of Reflection (GeneratedMessageReflection,
+        // defined in generated_message.h), and all Messages of a particular class
+        // should share the same Reflection object (though you should not rely on
+        // the latter fact).
+        //
+        // There are several ways that these methods can be used incorrectly.  For
+        // example, any of the following conditions will lead to undefined
+        // results (probably assertion failures):
+        // - The FieldDescriptor is not a field of this message type.
+        // - The method called is not appropriate for the field's type.  For
+        //   each field type in FieldDescriptor::TYPE_*, there is only one
+        //   Get*() method, one Set*() method, and one Add*() method that is
+        //   valid for that type.  It should be obvious which (except maybe
+        //   for TYPE_BYTES, which are represented using strings in C++).
+        // - A Get*() or Set*() method for singular fields is called on a repeated
+        //   field.
+        // - GetRepeated*(), SetRepeated*(), or Add*() is called on a non-repeated
+        //   field.
+        // - The Message object passed to any method is not of the right type for
+        //   this Reflection object (i.e. message.GetReflection() != reflection).
+        //
+        // You might wonder why there is not any abstract representation for a field
+        // of arbitrary type.  E.g., why isn't there just a "GetField()" method that
+        // returns "const Field&", where "Field" is some class with accessors like
+        // "GetInt32Value()".  The problem is that someone would have to deal with
+        // allocating these Field objects.  For generated message classes, having to
+        // allocate space for an additional object to wrap every field would at least
+        // double the message's memory footprint, probably worse.  Allocating the
+        // objects on-demand, on the other hand, would be expensive and prone to
+        // memory leaks.  So, instead we ended up with this flat interface.
+        class PROTOBUF_EXPORT Reflection final
+        {
+        public:
+            // Get the UnknownFieldSet for the message.  This contains fields which
+            // were seen when the Message was parsed but were not recognized according
+            // to the Message's definition.
+            const UnknownFieldSet& GetUnknownFields(const Message& message) const;
+            // Get a mutable pointer to the UnknownFieldSet for the message.  This
+            // contains fields which were seen when the Message was parsed but were not
+            // recognized according to the Message's definition.
+            UnknownFieldSet* MutableUnknownFields(Message* message) const;
+
+            // Estimate the amount of memory used by the message object.
+            size_t SpaceUsedLong(const Message& message) const;
+
+            PROTOBUF_DEPRECATED_MSG("Please use SpaceUsedLong() instead")
+            int SpaceUsed(const Message& message) const
+            {
+                return internal::ToIntSize(SpaceUsedLong(message));
+            }
+
+            // Check if the given non-repeated field is set.
+            bool HasField(const Message& message, const FieldDescriptor* field) const;
+
+            // Get the number of elements of a repeated field.
+            int FieldSize(const Message& message, const FieldDescriptor* field) const;
+
+            // Clear the value of a field, so that HasField() returns false or
+            // FieldSize() returns zero.
+            void ClearField(Message* message, const FieldDescriptor* field) const;
+
+            // Check if the oneof is set. Returns true if any field in oneof
+            // is set, false otherwise.
+            bool HasOneof(const Message& message, const OneofDescriptor* oneof_descriptor) const;
+
+            void ClearOneof(Message* message, const OneofDescriptor* oneof_descriptor) const;
+
+            // Returns the field descriptor if the oneof is set. nullptr otherwise.
+            const FieldDescriptor* GetOneofFieldDescriptor(
+                const Message& message, const OneofDescriptor* oneof_descriptor
+            ) const;
+
+            // Removes the last element of a repeated field.
+            // We don't provide a way to remove any element other than the last
+            // because it invites inefficient use, such as O(n^2) filtering loops
+            // that should have been O(n).  If you want to remove an element other
+            // than the last, the best way to do it is to re-arrange the elements
+            // (using Swap()) so that the one you want removed is at the end, then
+            // call RemoveLast().
+            void RemoveLast(Message* message, const FieldDescriptor* field) const;
+            // Removes the last element of a repeated message field, and returns the
+            // pointer to the caller.  Caller takes ownership of the returned pointer.
+            PROTOBUF_NODISCARD Message* ReleaseLast(Message* message, const FieldDescriptor* field) const;
+
+            // Similar to ReleaseLast() without internal safety and ownershp checks. This
+            // method should only be used when the objects are on the same arena or paired
+            // with a call to `UnsafeArenaAddAllocatedMessage`.
+            Message* UnsafeArenaReleaseLast(Message* message, const FieldDescriptor* field) const;
+
+            // Swap the complete contents of two messages.
+            void Swap(Message* message1, Message* message2) const;
+
+            // Swap fields listed in fields vector of two messages.
+            void SwapFields(Message* message1, Message* message2, const std::vector<const FieldDescriptor*>& fields) const;
+
+            // Swap two elements of a repeated field.
+            void SwapElements(Message* message, const FieldDescriptor* field, int index1, int index2) const;
+
+            // Swap without internal safety and ownership checks. This method should only
+            // be used when the objects are on the same arena.
+            void UnsafeArenaSwap(Message* lhs, Message* rhs) const;
+
+            // SwapFields without internal safety and ownership checks. This method should
+            // only be used when the objects are on the same arena.
+            void UnsafeArenaSwapFields(
+                Message* lhs, Message* rhs, const std::vector<const FieldDescriptor*>& fields
+            ) const;
+
+            // List all fields of the message which are currently set, except for unknown
+            // fields, but including extension known to the parser (i.e. compiled in).
+            // Singular fields will only be listed if HasField(field) would return true
+            // and repeated fields will only be listed if FieldSize(field) would return
+            // non-zero.  Fields (both normal fields and extension fields) will be listed
+            // ordered by field number.
+            // Use Reflection::GetUnknownFields() or message.unknown_fields() to also get
+            // access to fields/extensions unknown to the parser.
+            void ListFields(const Message& message, std::vector<const FieldDescriptor*>* output) const;
+
+            // Singular field getters ------------------------------------------
+            // These get the value of a non-repeated field.  They return the default
+            // value for fields that aren't set.
+
+            int32_t GetInt32(const Message& message, const FieldDescriptor* field) const;
+            int64_t GetInt64(const Message& message, const FieldDescriptor* field) const;
+            uint32_t GetUInt32(const Message& message, const FieldDescriptor* field) const;
+            uint64_t GetUInt64(const Message& message, const FieldDescriptor* field) const;
+            float GetFloat(const Message& message, const FieldDescriptor* field) const;
+            double GetDouble(const Message& message, const FieldDescriptor* field) const;
+            bool GetBool(const Message& message, const FieldDescriptor* field) const;
+            std::string GetString(const Message& message, const FieldDescriptor* field) const;
+            const EnumValueDescriptor* GetEnum(const Message& message, const FieldDescriptor* field) const;
+
+            // GetEnumValue() returns an enum field's value as an integer rather than
+            // an EnumValueDescriptor*. If the integer value does not correspond to a
+            // known value descriptor, a new value descriptor is created. (Such a value
+            // will only be present when the new unknown-enum-value semantics are enabled
+            // for a message.)
+            int GetEnumValue(const Message& message, const FieldDescriptor* field) const;
+
+            // See MutableMessage() for the meaning of the "factory" parameter.
+            const Message& GetMessage(const Message& message, const FieldDescriptor* field, MessageFactory* factory = nullptr) const;
+
+            // Get a string value without copying, if possible.
+            //
+            // GetString() necessarily returns a copy of the string.  This can be
+            // inefficient when the std::string is already stored in a std::string object
+            // in the underlying message.  GetStringReference() will return a reference to
+            // the underlying std::string in this case.  Otherwise, it will copy the
+            // string into *scratch and return that.
+            //
+            // Note:  It is perfectly reasonable and useful to write code like:
+            //     str = reflection->GetStringReference(message, field, &str);
+            //   This line would ensure that only one copy of the string is made
+            //   regardless of the field's underlying representation.  When initializing
+            //   a newly-constructed string, though, it's just as fast and more
+            //   readable to use code like:
+            //     std::string str = reflection->GetString(message, field);
+            const std::string& GetStringReference(const Message& message, const FieldDescriptor* field, std::string* scratch) const;
+
+            // Singular field mutators -----------------------------------------
+            // These mutate the value of a non-repeated field.
+
+            void SetInt32(Message* message, const FieldDescriptor* field, int32_t value) const;
+            void SetInt64(Message* message, const FieldDescriptor* field, int64_t value) const;
+            void SetUInt32(Message* message, const FieldDescriptor* field, uint32_t value) const;
+            void SetUInt64(Message* message, const FieldDescriptor* field, uint64_t value) const;
+            void SetFloat(Message* message, const FieldDescriptor* field, float value) const;
+            void SetDouble(Message* message, const FieldDescriptor* field, double value) const;
+            void SetBool(Message* message, const FieldDescriptor* field, bool value) const;
+            void SetString(Message* message, const FieldDescriptor* field, std::string value) const;
+            void SetEnum(Message* message, const FieldDescriptor* field, const EnumValueDescriptor* value) const;
+            // Set an enum field's value with an integer rather than EnumValueDescriptor.
+            // For proto3 this is just setting the enum field to the value specified, for
+            // proto2 it's more complicated. If value is a known enum value the field is
+            // set as usual. If the value is unknown then it is added to the unknown field
+            // set. Note this matches the behavior of parsing unknown enum values.
+            // If multiple calls with unknown values happen than they are all added to the
+            // unknown field set in order of the calls.
+            void SetEnumValue(Message* message, const FieldDescriptor* field, int value) const;
+
+            // Get a mutable pointer to a field with a message type.  If a MessageFactory
+            // is provided, it will be used to construct instances of the sub-message;
+            // otherwise, the default factory is used.  If the field is an extension that
+            // does not live in the same pool as the containing message's descriptor (e.g.
+            // it lives in an overlay pool), then a MessageFactory must be provided.
+            // If you have no idea what that meant, then you probably don't need to worry
+            // about it (don't provide a MessageFactory).  WARNING:  If the
+            // FieldDescriptor is for a compiled-in extension, then
+            // factory->GetPrototype(field->message_type()) MUST return an instance of
+            // the compiled-in class for this type, NOT DynamicMessage.
+            Message* MutableMessage(Message* message, const FieldDescriptor* field, MessageFactory* factory = nullptr) const;
+
+            // Replaces the message specified by 'field' with the already-allocated object
+            // sub_message, passing ownership to the message.  If the field contained a
+            // message, that message is deleted.  If sub_message is nullptr, the field is
+            // cleared.
+            void SetAllocatedMessage(Message* message, Message* sub_message, const FieldDescriptor* field) const;
+
+            // Similar to `SetAllocatedMessage`, but omits all internal safety and
+            // ownership checks.  This method should only be used when the objects are on
+            // the same arena or paired with a call to `UnsafeArenaReleaseMessage`.
+            void UnsafeArenaSetAllocatedMessage(Message* message, Message* sub_message, const FieldDescriptor* field) const;
+
+            // Releases the message specified by 'field' and returns the pointer,
+            // ReleaseMessage() will return the message the message object if it exists.
+            // Otherwise, it may or may not return nullptr.  In any case, if the return
+            // value is non-null, the caller takes ownership of the pointer.
+            // If the field existed (HasField() is true), then the returned pointer will
+            // be the same as the pointer returned by MutableMessage().
+            // This function has the same effect as ClearField().
+            PROTOBUF_NODISCARD Message* ReleaseMessage(
+                Message* message, const FieldDescriptor* field, MessageFactory* factory = nullptr
+            ) const;
+
+            // Similar to `ReleaseMessage`, but omits all internal safety and ownership
+            // checks.  This method should only be used when the objects are on the same
+            // arena or paired with a call to `UnsafeArenaSetAllocatedMessage`.
+            Message* UnsafeArenaReleaseMessage(Message* message, const FieldDescriptor* field, MessageFactory* factory = nullptr) const;
+
+            // Repeated field getters ------------------------------------------
+            // These get the value of one element of a repeated field.
+
+            int32_t GetRepeatedInt32(const Message& message, const FieldDescriptor* field, int index) const;
+            int64_t GetRepeatedInt64(const Message& message, const FieldDescriptor* field, int index) const;
+            uint32_t GetRepeatedUInt32(const Message& message, const FieldDescriptor* field, int index) const;
+            uint64_t GetRepeatedUInt64(const Message& message, const FieldDescriptor* field, int index) const;
+            float GetRepeatedFloat(const Message& message, const FieldDescriptor* field, int index) const;
+            double GetRepeatedDouble(const Message& message, const FieldDescriptor* field, int index) const;
+            bool GetRepeatedBool(const Message& message, const FieldDescriptor* field, int index) const;
+            std::string GetRepeatedString(const Message& message, const FieldDescriptor* field, int index) const;
+            const EnumValueDescriptor* GetRepeatedEnum(const Message& message, const FieldDescriptor* field, int index) const;
+            // GetRepeatedEnumValue() returns an enum field's value as an integer rather
+            // than an EnumValueDescriptor*. If the integer value does not correspond to a
+            // known value descriptor, a new value descriptor is created. (Such a value
+            // will only be present when the new unknown-enum-value semantics are enabled
+            // for a message.)
+            int GetRepeatedEnumValue(const Message& message, const FieldDescriptor* field, int index) const;
+            const Message& GetRepeatedMessage(const Message& message, const FieldDescriptor* field, int index) const;
+
+            // See GetStringReference(), above.
+            const std::string& GetRepeatedStringReference(const Message& message, const FieldDescriptor* field, int index, std::string* scratch) const;
+
+            // Repeated field mutators -----------------------------------------
+            // These mutate the value of one element of a repeated field.
+
+            void SetRepeatedInt32(Message* message, const FieldDescriptor* field, int index, int32_t value) const;
+            void SetRepeatedInt64(Message* message, const FieldDescriptor* field, int index, int64_t value) const;
+            void SetRepeatedUInt32(Message* message, const FieldDescriptor* field, int index, uint32_t value) const;
+            void SetRepeatedUInt64(Message* message, const FieldDescriptor* field, int index, uint64_t value) const;
+            void SetRepeatedFloat(Message* message, const FieldDescriptor* field, int index, float value) const;
+            void SetRepeatedDouble(Message* message, const FieldDescriptor* field, int index, double value) const;
+            void SetRepeatedBool(Message* message, const FieldDescriptor* field, int index, bool value) const;
+            void SetRepeatedString(Message* message, const FieldDescriptor* field, int index, std::string value) const;
+            void SetRepeatedEnum(Message* message, const FieldDescriptor* field, int index, const EnumValueDescriptor* value) const;
+            // Set an enum field's value with an integer rather than EnumValueDescriptor.
+            // For proto3 this is just setting the enum field to the value specified, for
+            // proto2 it's more complicated. If value is a known enum value the field is
+            // set as usual. If the value is unknown then it is added to the unknown field
+            // set. Note this matches the behavior of parsing unknown enum values.
+            // If multiple calls with unknown values happen than they are all added to the
+            // unknown field set in order of the calls.
+            void SetRepeatedEnumValue(Message* message, const FieldDescriptor* field, int index, int value) const;
+            // Get a mutable pointer to an element of a repeated field with a message
+            // type.
+            Message* MutableRepeatedMessage(Message* message, const FieldDescriptor* field, int index) const;
+
+            // Repeated field adders -------------------------------------------
+            // These add an element to a repeated field.
+
+            void AddInt32(Message* message, const FieldDescriptor* field, int32_t value) const;
+            void AddInt64(Message* message, const FieldDescriptor* field, int64_t value) const;
+            void AddUInt32(Message* message, const FieldDescriptor* field, uint32_t value) const;
+            void AddUInt64(Message* message, const FieldDescriptor* field, uint64_t value) const;
+            void AddFloat(Message* message, const FieldDescriptor* field, float value) const;
+            void AddDouble(Message* message, const FieldDescriptor* field, double value) const;
+            void AddBool(Message* message, const FieldDescriptor* field, bool value) const;
+            void AddString(Message* message, const FieldDescriptor* field, std::string value) const;
+            void AddEnum(Message* message, const FieldDescriptor* field, const EnumValueDescriptor* value) const;
+            // Add an integer value to a repeated enum field rather than
+            // EnumValueDescriptor. For proto3 this is just setting the enum field to the
+            // value specified, for proto2 it's more complicated. If value is a known enum
+            // value the field is set as usual. If the value is unknown then it is added
+            // to the unknown field set. Note this matches the behavior of parsing unknown
+            // enum values. If multiple calls with unknown values happen than they are all
+            // added to the unknown field set in order of the calls.
+            void AddEnumValue(Message* message, const FieldDescriptor* field, int value) const;
+            // See MutableMessage() for comments on the "factory" parameter.
+            Message* AddMessage(Message* message, const FieldDescriptor* field, MessageFactory* factory = nullptr) const;
+
+            // Appends an already-allocated object 'new_entry' to the repeated field
+            // specified by 'field' passing ownership to the message.
+            void AddAllocatedMessage(Message* message, const FieldDescriptor* field, Message* new_entry) const;
+
+            // Similar to AddAllocatedMessage() without internal safety and ownership
+            // checks. This method should only be used when the objects are on the same
+            // arena or paired with a call to `UnsafeArenaReleaseLast`.
+            void UnsafeArenaAddAllocatedMessage(Message* message, const FieldDescriptor* field, Message* new_entry) const;
+
+            // Get a RepeatedFieldRef object that can be used to read the underlying
+            // repeated field. The type parameter T must be set according to the
+            // field's cpp type. The following table shows the mapping from cpp type
+            // to acceptable T.
+            //
+            //   field->cpp_type()      T
+            //   CPPTYPE_INT32        int32_t
+            //   CPPTYPE_UINT32       uint32_t
+            //   CPPTYPE_INT64        int64_t
+            //   CPPTYPE_UINT64       uint64_t
+            //   CPPTYPE_DOUBLE       double
+            //   CPPTYPE_FLOAT        float
+            //   CPPTYPE_BOOL         bool
+            //   CPPTYPE_ENUM         generated enum type or int32_t
+            //   CPPTYPE_STRING       std::string
+            //   CPPTYPE_MESSAGE      generated message type or google::protobuf::Message
+            //
+            // A RepeatedFieldRef object can be copied and the resulted object will point
+            // to the same repeated field in the same message. The object can be used as
+            // long as the message is not destroyed.
+            //
+            // Note that to use this method users need to include the header file
+            // "reflection.h" (which defines the RepeatedFieldRef class templates).
+            template<typename T>
+            RepeatedFieldRef<T> GetRepeatedFieldRef(const Message& message, const FieldDescriptor* field) const;
+
+            // Like GetRepeatedFieldRef() but return an object that can also be used
+            // manipulate the underlying repeated field.
+            template<typename T>
+            MutableRepeatedFieldRef<T> GetMutableRepeatedFieldRef(
+                Message* message, const FieldDescriptor* field
+            ) const;
+
+            // DEPRECATED. Please use Get(Mutable)RepeatedFieldRef() for repeated field
+            // access. The following repeated field accessors will be removed in the
+            // future.
+            //
+            // Repeated field accessors  -------------------------------------------------
+            // The methods above, e.g. GetRepeatedInt32(msg, fd, index), provide singular
+            // access to the data in a RepeatedField.  The methods below provide aggregate
+            // access by exposing the RepeatedField object itself with the Message.
+            // Applying these templates to inappropriate types will lead to an undefined
+            // reference at link time (e.g. GetRepeatedField<***double>), or possibly a
+            // template matching error at compile time (e.g. GetRepeatedPtrField<File>).
+            //
+            // Usage example: my_doubs = refl->GetRepeatedField<double>(msg, fd);
+
+            // DEPRECATED. Please use GetRepeatedFieldRef().
+            //
+            // for T = Cord and all protobuf scalar types except enums.
+            template<typename T>
+            PROTOBUF_DEPRECATED_MSG("Please use GetRepeatedFieldRef() instead")
+            const RepeatedField<T>& GetRepeatedField(const Message& msg, const FieldDescriptor* d) const
+            {
+                return GetRepeatedFieldInternal<T>(msg, d);
+            }
+
+            // DEPRECATED. Please use GetMutableRepeatedFieldRef().
+            //
+            // for T = Cord and all protobuf scalar types except enums.
+            template<typename T>
+            PROTOBUF_DEPRECATED_MSG("Please use GetMutableRepeatedFieldRef() instead")
+            RepeatedField<T>* MutableRepeatedField(Message* msg, const FieldDescriptor* d) const
+            {
+                return MutableRepeatedFieldInternal<T>(msg, d);
+            }
+
+            // DEPRECATED. Please use GetRepeatedFieldRef().
+            //
+            // for T = std::string, google::protobuf::internal::StringPieceField
+            //         google::protobuf::Message & descendants.
+            template<typename T>
+            PROTOBUF_DEPRECATED_MSG("Please use GetRepeatedFieldRef() instead")
+            const RepeatedPtrField<T>& GetRepeatedPtrField(
+                const Message& msg, const FieldDescriptor* d
+            ) const
+            {
+                return GetRepeatedPtrFieldInternal<T>(msg, d);
+            }
+
+            // DEPRECATED. Please use GetMutableRepeatedFieldRef().
+            //
+            // for T = std::string, google::protobuf::internal::StringPieceField
+            //         google::protobuf::Message & descendants.
+            template<typename T>
+            PROTOBUF_DEPRECATED_MSG("Please use GetMutableRepeatedFieldRef() instead")
+            RepeatedPtrField<T>* MutableRepeatedPtrField(Message* msg, const FieldDescriptor* d) const
+            {
+                return MutableRepeatedPtrFieldInternal<T>(msg, d);
+            }
+
+            // Extensions ----------------------------------------------------------------
+
+            // Try to find an extension of this message type by fully-qualified field
+            // name.  Returns nullptr if no extension is known for this name or number.
+            const FieldDescriptor* FindKnownExtensionByName(
+                const std::string& name
+            ) const;
+
+            // Try to find an extension of this message type by field number.
+            // Returns nullptr if no extension is known for this name or number.
+            const FieldDescriptor* FindKnownExtensionByNumber(int number) const;
+
+            // Feature Flags -------------------------------------------------------------
+
+            // Does this message support storing arbitrary integer values in enum fields?
+            // If |true|, GetEnumValue/SetEnumValue and associated repeated-field versions
+            // take arbitrary integer values, and the legacy GetEnum() getter will
+            // dynamically create an EnumValueDescriptor for any integer value without
+            // one. If |false|, setting an unknown enum value via the integer-based
+            // setters results in undefined behavior (in practice, GOOGLE_DCHECK-fails).
+            //
+            // Generic code that uses reflection to handle messages with enum fields
+            // should check this flag before using the integer-based setter, and either
+            // downgrade to a compatible value or use the UnknownFieldSet if not. For
+            // example:
+            //
+            //   int new_value = GetValueFromApplicationLogic();
+            //   if (reflection->SupportsUnknownEnumValues()) {
+            //     reflection->SetEnumValue(message, field, new_value);
+            //   } else {
+            //     if (field_descriptor->enum_type()->
+            //             FindValueByNumber(new_value) != nullptr) {
+            //       reflection->SetEnumValue(message, field, new_value);
+            //     } else if (emit_unknown_enum_values) {
+            //       reflection->MutableUnknownFields(message)->AddVarint(
+            //           field->number(), new_value);
+            //     } else {
+            //       // convert value to a compatible/default value.
+            //       new_value = CompatibleDowngrade(new_value);
+            //       reflection->SetEnumValue(message, field, new_value);
+            //     }
+            //   }
+            bool SupportsUnknownEnumValues() const;
+
+            // Returns the MessageFactory associated with this message.  This can be
+            // useful for determining if a message is a generated message or not, for
+            // example:
+            //   if (message->GetReflection()->GetMessageFactory() ==
+            //       google::protobuf::MessageFactory::generated_factory()) {
+            //     // This is a generated message.
+            //   }
+            // It can also be used to create more messages of this type, though
+            // Message::New() is an easier way to accomplish this.
+            MessageFactory* GetMessageFactory() const;
+
+        private:
+            template<typename T>
+            const RepeatedField<T>& GetRepeatedFieldInternal(
+                const Message& message, const FieldDescriptor* field
+            ) const;
+            template<typename T>
+            RepeatedField<T>* MutableRepeatedFieldInternal(
+                Message* message, const FieldDescriptor* field
+            ) const;
+            template<typename T>
+            const RepeatedPtrField<T>& GetRepeatedPtrFieldInternal(
+                const Message& message, const FieldDescriptor* field
+            ) const;
+            template<typename T>
+            RepeatedPtrField<T>* MutableRepeatedPtrFieldInternal(
+                Message* message, const FieldDescriptor* field
+            ) const;
+            // Obtain a pointer to a Repeated Field Structure and do some type checking:
+            //   on field->cpp_type(),
+            //   on field->field_option().ctype() (if ctype >= 0)
+            //   of field->message_type() (if message_type != nullptr).
+            // We use 2 routine rather than 4 (const vs mutable) x (scalar vs pointer).
+            void* MutableRawRepeatedField(Message* message, const FieldDescriptor* field, FieldDescriptor::CppType, int ctype, const Descriptor* message_type) const;
+
+            const void* GetRawRepeatedField(const Message& message, const FieldDescriptor* field, FieldDescriptor::CppType cpptype, int ctype, const Descriptor* message_type) const;
+
+            // The following methods are used to implement (Mutable)RepeatedFieldRef.
+            // A Ref object will store a raw pointer to the repeated field data (obtained
+            // from RepeatedFieldData()) and a pointer to a Accessor (obtained from
+            // RepeatedFieldAccessor) which will be used to access the raw data.
+
+            // Returns a raw pointer to the repeated field
+            //
+            // "cpp_type" and "message_type" are deduced from the type parameter T passed
+            // to Get(Mutable)RepeatedFieldRef. If T is a generated message type,
+            // "message_type" should be set to its descriptor. Otherwise "message_type"
+            // should be set to nullptr. Implementations of this method should check
+            // whether "cpp_type"/"message_type" is consistent with the actual type of the
+            // field. We use 1 routine rather than 2 (const vs mutable) because it is
+            // protected and it doesn't change the message.
+            void* RepeatedFieldData(Message* message, const FieldDescriptor* field, FieldDescriptor::CppType cpp_type, const Descriptor* message_type) const;
+
+            // The returned pointer should point to a singleton instance which implements
+            // the RepeatedFieldAccessor interface.
+            const internal::RepeatedFieldAccessor* RepeatedFieldAccessor(
+                const FieldDescriptor* field
+            ) const;
+
+            // Lists all fields of the message which are currently set, except for unknown
+            // fields and stripped fields. See ListFields for details.
+            void ListFieldsOmitStripped(
+                const Message& message,
+                std::vector<const FieldDescriptor*>* output
+            ) const;
+
+            bool IsMessageStripped(const Descriptor* descriptor) const
+            {
+                return schema_.IsMessageStripped(descriptor);
+            }
+
+            friend class TextFormat;
+
+            void ListFieldsMayFailOnStripped(
+                const Message& message, bool should_fail, std::vector<const FieldDescriptor*>* output
+            ) const;
+
+            // Returns true if the message field is backed by a LazyField.
+            //
+            // A message field may be backed by a LazyField without the user annotation
+            // ([lazy = true]). While the user-annotated LazyField is lazily verified on
+            // first touch (i.e. failure on access rather than parsing if the LazyField is
+            // not initialized), the inferred LazyField is eagerly verified to avoid lazy
+            // parsing error at the cost of lower efficiency. When reflecting a message
+            // field, use this API instead of checking field->options().lazy().
+            bool IsLazyField(const FieldDescriptor* field) const
+            {
+                return IsLazilyVerifiedLazyField(field) ||
+                       IsEagerlyVerifiedLazyField(field);
+            }
+
+            // Returns true if the field is lazy extension. It is meant to allow python
+            // reparse lazy field until b/157559327 is fixed.
+            bool IsLazyExtension(const Message& message, const FieldDescriptor* field) const;
+
+            bool IsLazilyVerifiedLazyField(const FieldDescriptor* field) const;
+            bool IsEagerlyVerifiedLazyField(const FieldDescriptor* field) const;
+
+            friend class FastReflectionMessageMutator;
+            friend bool internal::IsDescendant(Message& root, const Message& message);
+
+            const Descriptor* const descriptor_;
+            const internal::ReflectionSchema schema_;
+            const DescriptorPool* const descriptor_pool_;
+            MessageFactory* const message_factory_;
+
+            // Last non weak field index. This is an optimization when most weak fields
+            // are at the end of the containing message. If a message proto doesn't
+            // contain weak fields, then this field equals descriptor_->field_count().
+            int last_non_weak_field_index_;
+
+            template<typename T, typename Enable>
+            friend class RepeatedFieldRef;
+            template<typename T, typename Enable>
+            friend class MutableRepeatedFieldRef;
+            friend class ::PROTOBUF_NAMESPACE_ID::MessageLayoutInspector;
+            friend class ::PROTOBUF_NAMESPACE_ID::AssignDescriptorsHelper;
+            friend class DynamicMessageFactory;
+            friend class GeneratedMessageReflectionTestHelper;
+            friend class python::MapReflectionFriend;
+            friend class python::MessageReflectionFriend;
+            friend class util::MessageDifferencer;
 #define GOOGLE_PROTOBUF_HAS_CEL_MAP_REFLECTION_FRIEND
-  friend class expr::CelMapReflectionFriend;
-  friend class internal::MapFieldReflectionTest;
-  friend class internal::MapKeySorter;
-  friend class internal::WireFormat;
-  friend class internal::ReflectionOps;
-  friend class internal::SwapFieldHelper;
-  // Needed for implementing text format for map.
-  friend class internal::MapFieldPrinterHelper;
-
-  Reflection(const Descriptor* descriptor,
-             const internal::ReflectionSchema& schema,
-             const DescriptorPool* pool, MessageFactory* factory);
-
-  // Special version for specialized implementations of string.  We can't
-  // call MutableRawRepeatedField directly here because we don't have access to
-  // FieldOptions::* which are defined in descriptor.pb.h.  Including that
-  // file here is not possible because it would cause a circular include cycle.
-  // We use 1 routine rather than 2 (const vs mutable) because it is private
-  // and mutable a repeated string field doesn't change the message.
-  void* MutableRawRepeatedString(Message* message, const FieldDescriptor* field,
-                                 bool is_string) const;
-
-  friend class MapReflectionTester;
-  // Returns true if key is in map. Returns false if key is not in map field.
-  bool ContainsMapKey(const Message& message, const FieldDescriptor* field,
-                      const MapKey& key) const;
-
-  // If key is in map field: Saves the value pointer to val and returns
-  // false. If key in not in map field: Insert the key into map, saves
-  // value pointer to val and returns true. Users are able to modify the
-  // map value by MapValueRef.
-  bool InsertOrLookupMapValue(Message* message, const FieldDescriptor* field,
-                              const MapKey& key, MapValueRef* val) const;
-
-  // If key is in map field: Saves the value pointer to val and returns true.
-  // Returns false if key is not in map field. Users are NOT able to modify
-  // the value by MapValueConstRef.
-  bool LookupMapValue(const Message& message, const FieldDescriptor* field,
-                      const MapKey& key, MapValueConstRef* val) const;
-  bool LookupMapValue(const Message&, const FieldDescriptor*, const MapKey&,
-                      MapValueRef*) const = delete;
-
-  // Delete and returns true if key is in the map field. Returns false
-  // otherwise.
-  bool DeleteMapValue(Message* message, const FieldDescriptor* field,
-                      const MapKey& key) const;
-
-  // Returns a MapIterator referring to the first element in the map field.
-  // If the map field is empty, this function returns the same as
-  // reflection::MapEnd. Mutation to the field may invalidate the iterator.
-  MapIterator MapBegin(Message* message, const FieldDescriptor* field) const;
-
-  // Returns a MapIterator referring to the theoretical element that would
-  // follow the last element in the map field. It does not point to any
-  // real element. Mutation to the field may invalidate the iterator.
-  MapIterator MapEnd(Message* message, const FieldDescriptor* field) const;
-
-  // Get the number of <key, value> pair of a map field. The result may be
-  // different from FieldSize which can have duplicate keys.
-  int MapSize(const Message& message, const FieldDescriptor* field) const;
-
-  // Help method for MapIterator.
-  friend class MapIterator;
-  friend class WireFormatForMapFieldTest;
-  internal::MapFieldBase* MutableMapData(Message* message,
-                                         const FieldDescriptor* field) const;
-
-  const internal::MapFieldBase* GetMapData(const Message& message,
-                                           const FieldDescriptor* field) const;
-
-  template <class T>
-  const T& GetRawNonOneof(const Message& message,
-                          const FieldDescriptor* field) const;
-  template <class T>
-  T* MutableRawNonOneof(Message* message, const FieldDescriptor* field) const;
-
-  template <typename Type>
-  const Type& GetRaw(const Message& message,
-                     const FieldDescriptor* field) const;
-  template <typename Type>
-  inline Type* MutableRaw(Message* message, const FieldDescriptor* field) const;
-  template <typename Type>
-  const Type& DefaultRaw(const FieldDescriptor* field) const;
-
-  const Message* GetDefaultMessageInstance(const FieldDescriptor* field) const;
-
-  inline const uint32_t* GetHasBits(const Message& message) const;
-  inline uint32_t* MutableHasBits(Message* message) const;
-  inline uint32_t GetOneofCase(const Message& message,
-                               const OneofDescriptor* oneof_descriptor) const;
-  inline uint32_t* MutableOneofCase(
-      Message* message, const OneofDescriptor* oneof_descriptor) const;
-  inline bool HasExtensionSet(const Message& /* message */) const {
-    return schema_.HasExtensionSet();
-  }
-  const internal::ExtensionSet& GetExtensionSet(const Message& message) const;
-  internal::ExtensionSet* MutableExtensionSet(Message* message) const;
-
-  const internal::InternalMetadata& GetInternalMetadata(
-      const Message& message) const;
-
-  internal::InternalMetadata* MutableInternalMetadata(Message* message) const;
-
-  inline bool IsInlined(const FieldDescriptor* field) const;
-
-  inline bool HasBit(const Message& message,
-                     const FieldDescriptor* field) const;
-  inline void SetBit(Message* message, const FieldDescriptor* field) const;
-  inline void ClearBit(Message* message, const FieldDescriptor* field) const;
-  inline void SwapBit(Message* message1, Message* message2,
-                      const FieldDescriptor* field) const;
-
-  inline const uint32_t* GetInlinedStringDonatedArray(
-      const Message& message) const;
-  inline uint32_t* MutableInlinedStringDonatedArray(Message* message) const;
-  inline bool IsInlinedStringDonated(const Message& message,
-                                     const FieldDescriptor* field) const;
-  inline void SwapInlinedStringDonated(Message* lhs, Message* rhs,
-                                       const FieldDescriptor* field) const;
-
-  // Shallow-swap fields listed in fields vector of two messages. It is the
-  // caller's responsibility to make sure shallow swap is safe.
-  void UnsafeShallowSwapFields(
-      Message* message1, Message* message2,
-      const std::vector<const FieldDescriptor*>& fields) const;
-
-  // This function only swaps the field. Should swap corresponding has_bit
-  // before or after using this function.
-  void SwapField(Message* message1, Message* message2,
-                 const FieldDescriptor* field) const;
-
-  // Unsafe but shallow version of SwapField.
-  void UnsafeShallowSwapField(Message* message1, Message* message2,
-                              const FieldDescriptor* field) const;
-
-  template <bool unsafe_shallow_swap>
-  void SwapFieldsImpl(Message* message1, Message* message2,
-                      const std::vector<const FieldDescriptor*>& fields) const;
-
-  template <bool unsafe_shallow_swap>
-  void SwapOneofField(Message* lhs, Message* rhs,
-                      const OneofDescriptor* oneof_descriptor) const;
-
-  inline bool HasOneofField(const Message& message,
-                            const FieldDescriptor* field) const;
-  inline void SetOneofCase(Message* message,
-                           const FieldDescriptor* field) const;
-  inline void ClearOneofField(Message* message,
-                              const FieldDescriptor* field) const;
-
-  template <typename Type>
-  inline const Type& GetField(const Message& message,
-                              const FieldDescriptor* field) const;
-  template <typename Type>
-  inline void SetField(Message* message, const FieldDescriptor* field,
-                       const Type& value) const;
-  template <typename Type>
-  inline Type* MutableField(Message* message,
-                            const FieldDescriptor* field) const;
-  template <typename Type>
-  inline const Type& GetRepeatedField(const Message& message,
-                                      const FieldDescriptor* field,
-                                      int index) const;
-  template <typename Type>
-  inline const Type& GetRepeatedPtrField(const Message& message,
-                                         const FieldDescriptor* field,
-                                         int index) const;
-  template <typename Type>
-  inline void SetRepeatedField(Message* message, const FieldDescriptor* field,
-                               int index, Type value) const;
-  template <typename Type>
-  inline Type* MutableRepeatedField(Message* message,
-                                    const FieldDescriptor* field,
-                                    int index) const;
-  template <typename Type>
-  inline void AddField(Message* message, const FieldDescriptor* field,
-                       const Type& value) const;
-  template <typename Type>
-  inline Type* AddField(Message* message, const FieldDescriptor* field) const;
-
-  int GetExtensionNumberOrDie(const Descriptor* type) const;
-
-  // Internal versions of EnumValue API perform no checking. Called after checks
-  // by public methods.
-  void SetEnumValueInternal(Message* message, const FieldDescriptor* field,
-                            int value) const;
-  void SetRepeatedEnumValueInternal(Message* message,
-                                    const FieldDescriptor* field, int index,
-                                    int value) const;
-  void AddEnumValueInternal(Message* message, const FieldDescriptor* field,
-                            int value) const;
-
-  friend inline  // inline so nobody can call this function.
-      void
-      RegisterAllTypesInternal(const Metadata* file_level_metadata, int size);
-  friend inline const char* ParseLenDelim(int field_number,
-                                          const FieldDescriptor* field,
-                                          Message* msg,
-                                          const Reflection* reflection,
-                                          const char* ptr,
-                                          internal::ParseContext* ctx);
-  friend inline const char* ParsePackedField(const FieldDescriptor* field,
-                                             Message* msg,
-                                             const Reflection* reflection,
-                                             const char* ptr,
-                                             internal::ParseContext* ctx);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reflection);
-};
-
-// Abstract interface for a factory for message objects.
-class PROTOBUF_EXPORT MessageFactory {
- public:
-  inline MessageFactory() {}
-  virtual ~MessageFactory();
-
-  // Given a Descriptor, gets or constructs the default (prototype) Message
-  // of that type.  You can then call that message's New() method to construct
-  // a mutable message of that type.
-  //
-  // Calling this method twice with the same Descriptor returns the same
-  // object.  The returned object remains property of the factory.  Also, any
-  // objects created by calling the prototype's New() method share some data
-  // with the prototype, so these must be destroyed before the MessageFactory
-  // is destroyed.
-  //
-  // The given descriptor must outlive the returned message, and hence must
-  // outlive the MessageFactory.
-  //
-  // Some implementations do not support all types.  GetPrototype() will
-  // return nullptr if the descriptor passed in is not supported.
-  //
-  // This method may or may not be thread-safe depending on the implementation.
-  // Each implementation should document its own degree thread-safety.
-  virtual const Message* GetPrototype(const Descriptor* type) = 0;
-
-  // Gets a MessageFactory which supports all generated, compiled-in messages.
-  // In other words, for any compiled-in type FooMessage, the following is true:
-  //   MessageFactory::generated_factory()->GetPrototype(
-  //     FooMessage::descriptor()) == FooMessage::default_instance()
-  // This factory supports all types which are found in
-  // DescriptorPool::generated_pool().  If given a descriptor from any other
-  // pool, GetPrototype() will return nullptr.  (You can also check if a
-  // descriptor is for a generated message by checking if
-  // descriptor->file()->pool() == DescriptorPool::generated_pool().)
-  //
-  // This factory is 100% thread-safe; calling GetPrototype() does not modify
-  // any shared data.
-  //
-  // This factory is a singleton.  The caller must not delete the object.
-  static MessageFactory* generated_factory();
-
-  // For internal use only:  Registers a .proto file at static initialization
-  // time, to be placed in generated_factory.  The first time GetPrototype()
-  // is called with a descriptor from this file, |register_messages| will be
-  // called, with the file name as the parameter.  It must call
-  // InternalRegisterGeneratedMessage() (below) to register each message type
-  // in the file.  This strange mechanism is necessary because descriptors are
-  // built lazily, so we can't register types by their descriptor until we
-  // know that the descriptor exists.  |filename| must be a permanent string.
-  static void InternalRegisterGeneratedFile(
-      const google::protobuf::internal::DescriptorTable* table);
-
-  // For internal use only:  Registers a message type.  Called only by the
-  // functions which are registered with InternalRegisterGeneratedFile(),
-  // above.
-  static void InternalRegisterGeneratedMessage(const Descriptor* descriptor,
-                                               const Message* prototype);
-
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFactory);
-};
-
-#define DECLARE_GET_REPEATED_FIELD(TYPE)                           \
-  template <>                                                      \
-  PROTOBUF_EXPORT const RepeatedField<TYPE>&                       \
-  Reflection::GetRepeatedFieldInternal<TYPE>(                      \
-      const Message& message, const FieldDescriptor* field) const; \
-                                                                   \
-  template <>                                                      \
-  PROTOBUF_EXPORT RepeatedField<TYPE>*                             \
-  Reflection::MutableRepeatedFieldInternal<TYPE>(                  \
-      Message * message, const FieldDescriptor* field) const;
-
-DECLARE_GET_REPEATED_FIELD(int32_t)
-DECLARE_GET_REPEATED_FIELD(int64_t)
-DECLARE_GET_REPEATED_FIELD(uint32_t)
-DECLARE_GET_REPEATED_FIELD(uint64_t)
-DECLARE_GET_REPEATED_FIELD(float)
-DECLARE_GET_REPEATED_FIELD(double)
-DECLARE_GET_REPEATED_FIELD(bool)
+            friend class expr::CelMapReflectionFriend;
+            friend class internal::MapFieldReflectionTest;
+            friend class internal::MapKeySorter;
+            friend class internal::WireFormat;
+            friend class internal::ReflectionOps;
+            friend class internal::SwapFieldHelper;
+            // Needed for implementing text format for map.
+            friend class internal::MapFieldPrinterHelper;
+
+            Reflection(const Descriptor* descriptor, const internal::ReflectionSchema& schema, const DescriptorPool* pool, MessageFactory* factory);
+
+            // Special version for specialized implementations of string.  We can't
+            // call MutableRawRepeatedField directly here because we don't have access to
+            // FieldOptions::* which are defined in descriptor.pb.h.  Including that
+            // file here is not possible because it would cause a circular include cycle.
+            // We use 1 routine rather than 2 (const vs mutable) because it is private
+            // and mutable a repeated string field doesn't change the message.
+            void* MutableRawRepeatedString(Message* message, const FieldDescriptor* field, bool is_string) const;
+
+            friend class MapReflectionTester;
+            // Returns true if key is in map. Returns false if key is not in map field.
+            bool ContainsMapKey(const Message& message, const FieldDescriptor* field, const MapKey& key) const;
+
+            // If key is in map field: Saves the value pointer to val and returns
+            // false. If key in not in map field: Insert the key into map, saves
+            // value pointer to val and returns true. Users are able to modify the
+            // map value by MapValueRef.
+            bool InsertOrLookupMapValue(Message* message, const FieldDescriptor* field, const MapKey& key, MapValueRef* val) const;
+
+            // If key is in map field: Saves the value pointer to val and returns true.
+            // Returns false if key is not in map field. Users are NOT able to modify
+            // the value by MapValueConstRef.
+            bool LookupMapValue(const Message& message, const FieldDescriptor* field, const MapKey& key, MapValueConstRef* val) const;
+            bool LookupMapValue(const Message&, const FieldDescriptor*, const MapKey&, MapValueRef*) const = delete;
+
+            // Delete and returns true if key is in the map field. Returns false
+            // otherwise.
+            bool DeleteMapValue(Message* message, const FieldDescriptor* field, const MapKey& key) const;
+
+            // Returns a MapIterator referring to the first element in the map field.
+            // If the map field is empty, this function returns the same as
+            // reflection::MapEnd. Mutation to the field may invalidate the iterator.
+            MapIterator MapBegin(Message* message, const FieldDescriptor* field) const;
+
+            // Returns a MapIterator referring to the theoretical element that would
+            // follow the last element in the map field. It does not point to any
+            // real element. Mutation to the field may invalidate the iterator.
+            MapIterator MapEnd(Message* message, const FieldDescriptor* field) const;
+
+            // Get the number of <key, value> pair of a map field. The result may be
+            // different from FieldSize which can have duplicate keys.
+            int MapSize(const Message& message, const FieldDescriptor* field) const;
+
+            // Help method for MapIterator.
+            friend class MapIterator;
+            friend class WireFormatForMapFieldTest;
+            internal::MapFieldBase* MutableMapData(Message* message, const FieldDescriptor* field) const;
+
+            const internal::MapFieldBase* GetMapData(const Message& message, const FieldDescriptor* field) const;
+
+            template<class T>
+            const T& GetRawNonOneof(const Message& message, const FieldDescriptor* field) const;
+            template<class T>
+            T* MutableRawNonOneof(Message* message, const FieldDescriptor* field) const;
+
+            template<typename Type>
+            const Type& GetRaw(const Message& message, const FieldDescriptor* field) const;
+            template<typename Type>
+            inline Type* MutableRaw(Message* message, const FieldDescriptor* field) const;
+            template<typename Type>
+            const Type& DefaultRaw(const FieldDescriptor* field) const;
+
+            const Message* GetDefaultMessageInstance(const FieldDescriptor* field) const;
+
+            inline const uint32_t* GetHasBits(const Message& message) const;
+            inline uint32_t* MutableHasBits(Message* message) const;
+            inline uint32_t GetOneofCase(const Message& message, const OneofDescriptor* oneof_descriptor) const;
+            inline uint32_t* MutableOneofCase(
+                Message* message, const OneofDescriptor* oneof_descriptor
+            ) const;
+            inline bool HasExtensionSet(const Message& /* message */) const
+            {
+                return schema_.HasExtensionSet();
+            }
+            const internal::ExtensionSet& GetExtensionSet(const Message& message) const;
+            internal::ExtensionSet* MutableExtensionSet(Message* message) const;
+
+            const internal::InternalMetadata& GetInternalMetadata(
+                const Message& message
+            ) const;
+
+            internal::InternalMetadata* MutableInternalMetadata(Message* message) const;
+
+            inline bool IsInlined(const FieldDescriptor* field) const;
+
+            inline bool HasBit(const Message& message, const FieldDescriptor* field) const;
+            inline void SetBit(Message* message, const FieldDescriptor* field) const;
+            inline void ClearBit(Message* message, const FieldDescriptor* field) const;
+            inline void SwapBit(Message* message1, Message* message2, const FieldDescriptor* field) const;
+
+            inline const uint32_t* GetInlinedStringDonatedArray(
+                const Message& message
+            ) const;
+            inline uint32_t* MutableInlinedStringDonatedArray(Message* message) const;
+            inline bool IsInlinedStringDonated(const Message& message, const FieldDescriptor* field) const;
+            inline void SwapInlinedStringDonated(Message* lhs, Message* rhs, const FieldDescriptor* field) const;
+
+            // Shallow-swap fields listed in fields vector of two messages. It is the
+            // caller's responsibility to make sure shallow swap is safe.
+            void UnsafeShallowSwapFields(
+                Message* message1, Message* message2, const std::vector<const FieldDescriptor*>& fields
+            ) const;
+
+            // This function only swaps the field. Should swap corresponding has_bit
+            // before or after using this function.
+            void SwapField(Message* message1, Message* message2, const FieldDescriptor* field) const;
+
+            // Unsafe but shallow version of SwapField.
+            void UnsafeShallowSwapField(Message* message1, Message* message2, const FieldDescriptor* field) const;
+
+            template<bool unsafe_shallow_swap>
+            void SwapFieldsImpl(Message* message1, Message* message2, const std::vector<const FieldDescriptor*>& fields) const;
+
+            template<bool unsafe_shallow_swap>
+            void SwapOneofField(Message* lhs, Message* rhs, const OneofDescriptor* oneof_descriptor) const;
+
+            inline bool HasOneofField(const Message& message, const FieldDescriptor* field) const;
+            inline void SetOneofCase(Message* message, const FieldDescriptor* field) const;
+            inline void ClearOneofField(Message* message, const FieldDescriptor* field) const;
+
+            template<typename Type>
+            inline const Type& GetField(const Message& message, const FieldDescriptor* field) const;
+            template<typename Type>
+            inline void SetField(Message* message, const FieldDescriptor* field, const Type& value) const;
+            template<typename Type>
+            inline Type* MutableField(Message* message, const FieldDescriptor* field) const;
+            template<typename Type>
+            inline const Type& GetRepeatedField(const Message& message, const FieldDescriptor* field, int index) const;
+            template<typename Type>
+            inline const Type& GetRepeatedPtrField(const Message& message, const FieldDescriptor* field, int index) const;
+            template<typename Type>
+            inline void SetRepeatedField(Message* message, const FieldDescriptor* field, int index, Type value) const;
+            template<typename Type>
+            inline Type* MutableRepeatedField(Message* message, const FieldDescriptor* field, int index) const;
+            template<typename Type>
+            inline void AddField(Message* message, const FieldDescriptor* field, const Type& value) const;
+            template<typename Type>
+            inline Type* AddField(Message* message, const FieldDescriptor* field) const;
+
+            int GetExtensionNumberOrDie(const Descriptor* type) const;
+
+            // Internal versions of EnumValue API perform no checking. Called after checks
+            // by public methods.
+            void SetEnumValueInternal(Message* message, const FieldDescriptor* field, int value) const;
+            void SetRepeatedEnumValueInternal(Message* message, const FieldDescriptor* field, int index, int value) const;
+            void AddEnumValueInternal(Message* message, const FieldDescriptor* field, int value) const;
+
+            friend inline  // inline so nobody can call this function.
+                void
+                RegisterAllTypesInternal(const Metadata* file_level_metadata, int size);
+            friend inline const char* ParseLenDelim(int field_number, const FieldDescriptor* field, Message* msg, const Reflection* reflection, const char* ptr, internal::ParseContext* ctx);
+            friend inline const char* ParsePackedField(const FieldDescriptor* field, Message* msg, const Reflection* reflection, const char* ptr, internal::ParseContext* ctx);
+
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reflection);
+        };
+
+        // Abstract interface for a factory for message objects.
+        class PROTOBUF_EXPORT MessageFactory
+        {
+        public:
+            inline MessageFactory()
+            {
+            }
+            virtual ~MessageFactory();
+
+            // Given a Descriptor, gets or constructs the default (prototype) Message
+            // of that type.  You can then call that message's New() method to construct
+            // a mutable message of that type.
+            //
+            // Calling this method twice with the same Descriptor returns the same
+            // object.  The returned object remains property of the factory.  Also, any
+            // objects created by calling the prototype's New() method share some data
+            // with the prototype, so these must be destroyed before the MessageFactory
+            // is destroyed.
+            //
+            // The given descriptor must outlive the returned message, and hence must
+            // outlive the MessageFactory.
+            //
+            // Some implementations do not support all types.  GetPrototype() will
+            // return nullptr if the descriptor passed in is not supported.
+            //
+            // This method may or may not be thread-safe depending on the implementation.
+            // Each implementation should document its own degree thread-safety.
+            virtual const Message* GetPrototype(const Descriptor* type) = 0;
+
+            // Gets a MessageFactory which supports all generated, compiled-in messages.
+            // In other words, for any compiled-in type FooMessage, the following is true:
+            //   MessageFactory::generated_factory()->GetPrototype(
+            //     FooMessage::descriptor()) == FooMessage::default_instance()
+            // This factory supports all types which are found in
+            // DescriptorPool::generated_pool().  If given a descriptor from any other
+            // pool, GetPrototype() will return nullptr.  (You can also check if a
+            // descriptor is for a generated message by checking if
+            // descriptor->file()->pool() == DescriptorPool::generated_pool().)
+            //
+            // This factory is 100% thread-safe; calling GetPrototype() does not modify
+            // any shared data.
+            //
+            // This factory is a singleton.  The caller must not delete the object.
+            static MessageFactory* generated_factory();
+
+            // For internal use only:  Registers a .proto file at static initialization
+            // time, to be placed in generated_factory.  The first time GetPrototype()
+            // is called with a descriptor from this file, |register_messages| will be
+            // called, with the file name as the parameter.  It must call
+            // InternalRegisterGeneratedMessage() (below) to register each message type
+            // in the file.  This strange mechanism is necessary because descriptors are
+            // built lazily, so we can't register types by their descriptor until we
+            // know that the descriptor exists.  |filename| must be a permanent string.
+            static void InternalRegisterGeneratedFile(
+                const google::protobuf::internal::DescriptorTable* table
+            );
+
+            // For internal use only:  Registers a message type.  Called only by the
+            // functions which are registered with InternalRegisterGeneratedFile(),
+            // above.
+            static void InternalRegisterGeneratedMessage(const Descriptor* descriptor, const Message* prototype);
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFactory);
+        };
+
+#define DECLARE_GET_REPEATED_FIELD(TYPE)                         \
+    template<>                                                   \
+    PROTOBUF_EXPORT const RepeatedField<TYPE>&                   \
+        Reflection::GetRepeatedFieldInternal<TYPE>(              \
+            const Message& message, const FieldDescriptor* field \
+        ) const;                                                 \
+                                                                 \
+    template<>                                                   \
+    PROTOBUF_EXPORT RepeatedField<TYPE>*                         \
+        Reflection::MutableRepeatedFieldInternal<TYPE>(          \
+            Message * message, const FieldDescriptor* field      \
+        ) const;
+
+        DECLARE_GET_REPEATED_FIELD(int32_t)
+        DECLARE_GET_REPEATED_FIELD(int64_t)
+        DECLARE_GET_REPEATED_FIELD(uint32_t)
+        DECLARE_GET_REPEATED_FIELD(uint64_t)
+        DECLARE_GET_REPEATED_FIELD(float)
+        DECLARE_GET_REPEATED_FIELD(double)
+        DECLARE_GET_REPEATED_FIELD(bool)
 
 #undef DECLARE_GET_REPEATED_FIELD
 
-// Tries to downcast this message to a generated message type.  Returns nullptr
-// if this class is not an instance of T.  This works even if RTTI is disabled.
-//
-// This also has the effect of creating a strong reference to T that will
-// prevent the linker from stripping it out at link time.  This can be important
-// if you are using a DynamicMessageFactory that delegates to the generated
-// factory.
-template <typename T>
-const T* DynamicCastToGenerated(const Message* from) {
-  // Compile-time assert that T is a generated type that has a
-  // default_instance() accessor, but avoid actually calling it.
-  const T& (*get_default_instance)() = &T::default_instance;
-  (void)get_default_instance;
-
-  // Compile-time assert that T is a subclass of google::protobuf::Message.
-  const Message* unused = static_cast<T*>(nullptr);
-  (void)unused;
+        // Tries to downcast this message to a generated message type.  Returns nullptr
+        // if this class is not an instance of T.  This works even if RTTI is disabled.
+        //
+        // This also has the effect of creating a strong reference to T that will
+        // prevent the linker from stripping it out at link time.  This can be important
+        // if you are using a DynamicMessageFactory that delegates to the generated
+        // factory.
+        template<typename T>
+        const T* DynamicCastToGenerated(const Message* from)
+        {
+            // Compile-time assert that T is a generated type that has a
+            // default_instance() accessor, but avoid actually calling it.
+            const T& (*get_default_instance)() = &T::default_instance;
+            (void)get_default_instance;
+
+            // Compile-time assert that T is a subclass of google::protobuf::Message.
+            const Message* unused = static_cast<T*>(nullptr);
+            (void)unused;
 
 #if PROTOBUF_RTTI
-  return dynamic_cast<const T*>(from);
+            return dynamic_cast<const T*>(from);
 #else
-  bool ok = from != nullptr &&
-            T::default_instance().GetReflection() == from->GetReflection();
-  return ok ? down_cast<const T*>(from) : nullptr;
+            bool ok = from != nullptr &&
+                      T::default_instance().GetReflection() == from->GetReflection();
+            return ok ? down_cast<const T*>(from) : nullptr;
 #endif
-}
-
-template <typename T>
-T* DynamicCastToGenerated(Message* from) {
-  const Message* message_const = from;
-  return const_cast<T*>(DynamicCastToGenerated<T>(message_const));
-}
-
-// Call this function to ensure that this message's reflection is linked into
-// the binary:
-//
-//   google::protobuf::LinkMessageReflection<pkg::FooMessage>();
-//
-// This will ensure that the following lookup will succeed:
-//
-//   DescriptorPool::generated_pool()->FindMessageTypeByName("pkg.FooMessage");
-//
-// As a side-effect, it will also guarantee that anything else from the same
-// .proto file will also be available for lookup in the generated pool.
-//
-// This function does not actually register the message, so it does not need
-// to be called before the lookup.  However it does need to occur in a function
-// that cannot be stripped from the binary (ie. it must be reachable from main).
-//
-// Best practice is to call this function as close as possible to where the
-// reflection is actually needed.  This function is very cheap to call, so you
-// should not need to worry about its runtime overhead except in the tightest
-// of loops (on x86-64 it compiles into two "mov" instructions).
-template <typename T>
-void LinkMessageReflection() {
-  internal::StrongReference(T::default_instance);
-}
-
-// =============================================================================
-// Implementation details for {Get,Mutable}RawRepeatedPtrField.  We provide
-// specializations for <std::string>, <StringPieceField> and <Message> and
-// handle everything else with the default template which will match any type
-// having a method with signature "static const google::protobuf::Descriptor*
-// descriptor()". Such a type presumably is a descendant of google::protobuf::Message.
-
-template <>
-inline const RepeatedPtrField<std::string>&
-Reflection::GetRepeatedPtrFieldInternal<std::string>(
-    const Message& message, const FieldDescriptor* field) const {
-  return *static_cast<RepeatedPtrField<std::string>*>(
-      MutableRawRepeatedString(const_cast<Message*>(&message), field, true));
-}
-
-template <>
-inline RepeatedPtrField<std::string>*
-Reflection::MutableRepeatedPtrFieldInternal<std::string>(
-    Message* message, const FieldDescriptor* field) const {
-  return static_cast<RepeatedPtrField<std::string>*>(
-      MutableRawRepeatedString(message, field, true));
-}
-
-
-// -----
-
-template <>
-inline const RepeatedPtrField<Message>& Reflection::GetRepeatedPtrFieldInternal(
-    const Message& message, const FieldDescriptor* field) const {
-  return *static_cast<const RepeatedPtrField<Message>*>(GetRawRepeatedField(
-      message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, nullptr));
-}
-
-template <>
-inline RepeatedPtrField<Message>* Reflection::MutableRepeatedPtrFieldInternal(
-    Message* message, const FieldDescriptor* field) const {
-  return static_cast<RepeatedPtrField<Message>*>(MutableRawRepeatedField(
-      message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, nullptr));
-}
-
-template <typename PB>
-inline const RepeatedPtrField<PB>& Reflection::GetRepeatedPtrFieldInternal(
-    const Message& message, const FieldDescriptor* field) const {
-  return *static_cast<const RepeatedPtrField<PB>*>(
-      GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1,
-                          PB::default_instance().GetDescriptor()));
-}
-
-template <typename PB>
-inline RepeatedPtrField<PB>* Reflection::MutableRepeatedPtrFieldInternal(
-    Message* message, const FieldDescriptor* field) const {
-  return static_cast<RepeatedPtrField<PB>*>(
-      MutableRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE,
-                              -1, PB::default_instance().GetDescriptor()));
-}
-
-template <typename Type>
-const Type& Reflection::DefaultRaw(const FieldDescriptor* field) const {
-  return *reinterpret_cast<const Type*>(schema_.GetFieldDefault(field));
-}
-
-uint32_t Reflection::GetOneofCase(
-    const Message& message, const OneofDescriptor* oneof_descriptor) const {
-  GOOGLE_DCHECK(!oneof_descriptor->is_synthetic());
-  return internal::GetConstRefAtOffset<uint32_t>(
-      message, schema_.GetOneofCaseOffset(oneof_descriptor));
-}
-
-bool Reflection::HasOneofField(const Message& message,
-                               const FieldDescriptor* field) const {
-  return (GetOneofCase(message, field->containing_oneof()) ==
-          static_cast<uint32_t>(field->number()));
-}
-
-template <typename Type>
-const Type& Reflection::GetRaw(const Message& message,
-                               const FieldDescriptor* field) const {
-  GOOGLE_DCHECK(!schema_.InRealOneof(field) || HasOneofField(message, field))
-      << "Field = " << field->full_name();
-  return internal::GetConstRefAtOffset<Type>(message,
-                                             schema_.GetFieldOffset(field));
-}
-}  // namespace protobuf
+        }
+
+        template<typename T>
+        T* DynamicCastToGenerated(Message* from)
+        {
+            const Message* message_const = from;
+            return const_cast<T*>(DynamicCastToGenerated<T>(message_const));
+        }
+
+        // Call this function to ensure that this message's reflection is linked into
+        // the binary:
+        //
+        //   google::protobuf::LinkMessageReflection<pkg::FooMessage>();
+        //
+        // This will ensure that the following lookup will succeed:
+        //
+        //   DescriptorPool::generated_pool()->FindMessageTypeByName("pkg.FooMessage");
+        //
+        // As a side-effect, it will also guarantee that anything else from the same
+        // .proto file will also be available for lookup in the generated pool.
+        //
+        // This function does not actually register the message, so it does not need
+        // to be called before the lookup.  However it does need to occur in a function
+        // that cannot be stripped from the binary (ie. it must be reachable from main).
+        //
+        // Best practice is to call this function as close as possible to where the
+        // reflection is actually needed.  This function is very cheap to call, so you
+        // should not need to worry about its runtime overhead except in the tightest
+        // of loops (on x86-64 it compiles into two "mov" instructions).
+        template<typename T>
+        void LinkMessageReflection()
+        {
+            internal::StrongReference(T::default_instance);
+        }
+
+        // =============================================================================
+        // Implementation details for {Get,Mutable}RawRepeatedPtrField.  We provide
+        // specializations for <std::string>, <StringPieceField> and <Message> and
+        // handle everything else with the default template which will match any type
+        // having a method with signature "static const google::protobuf::Descriptor*
+        // descriptor()". Such a type presumably is a descendant of google::protobuf::Message.
+
+        template<>
+        inline const RepeatedPtrField<std::string>&
+            Reflection::GetRepeatedPtrFieldInternal<std::string>(
+                const Message& message, const FieldDescriptor* field
+            ) const
+        {
+            return *static_cast<RepeatedPtrField<std::string>*>(
+                MutableRawRepeatedString(const_cast<Message*>(&message), field, true)
+            );
+        }
+
+        template<>
+        inline RepeatedPtrField<std::string>*
+            Reflection::MutableRepeatedPtrFieldInternal<std::string>(
+                Message* message, const FieldDescriptor* field
+            ) const
+        {
+            return static_cast<RepeatedPtrField<std::string>*>(
+                MutableRawRepeatedString(message, field, true)
+            );
+        }
+
+        // -----
+
+        template<>
+        inline const RepeatedPtrField<Message>& Reflection::GetRepeatedPtrFieldInternal(
+            const Message& message, const FieldDescriptor* field
+        ) const
+        {
+            return *static_cast<const RepeatedPtrField<Message>*>(GetRawRepeatedField(
+                message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, nullptr
+            ));
+        }
+
+        template<>
+        inline RepeatedPtrField<Message>* Reflection::MutableRepeatedPtrFieldInternal(
+            Message* message, const FieldDescriptor* field
+        ) const
+        {
+            return static_cast<RepeatedPtrField<Message>*>(MutableRawRepeatedField(
+                message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, nullptr
+            ));
+        }
+
+        template<typename PB>
+        inline const RepeatedPtrField<PB>& Reflection::GetRepeatedPtrFieldInternal(
+            const Message& message, const FieldDescriptor* field
+        ) const
+        {
+            return *static_cast<const RepeatedPtrField<PB>*>(
+                GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, PB::default_instance().GetDescriptor())
+            );
+        }
+
+        template<typename PB>
+        inline RepeatedPtrField<PB>* Reflection::MutableRepeatedPtrFieldInternal(
+            Message* message, const FieldDescriptor* field
+        ) const
+        {
+            return static_cast<RepeatedPtrField<PB>*>(
+                MutableRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE, -1, PB::default_instance().GetDescriptor())
+            );
+        }
+
+        template<typename Type>
+        const Type& Reflection::DefaultRaw(const FieldDescriptor* field) const
+        {
+            return *reinterpret_cast<const Type*>(schema_.GetFieldDefault(field));
+        }
+
+        uint32_t Reflection::GetOneofCase(
+            const Message& message, const OneofDescriptor* oneof_descriptor
+        ) const
+        {
+            GOOGLE_DCHECK(!oneof_descriptor->is_synthetic());
+            return internal::GetConstRefAtOffset<uint32_t>(
+                message, schema_.GetOneofCaseOffset(oneof_descriptor)
+            );
+        }
+
+        bool Reflection::HasOneofField(const Message& message, const FieldDescriptor* field) const
+        {
+            return (GetOneofCase(message, field->containing_oneof()) == static_cast<uint32_t>(field->number()));
+        }
+
+        template<typename Type>
+        const Type& Reflection::GetRaw(const Message& message, const FieldDescriptor* field) const
+        {
+            GOOGLE_DCHECK(!schema_.InRealOneof(field) || HasOneofField(message, field))
+                << "Field = " << field->full_name();
+            return internal::GetConstRefAtOffset<Type>(message, schema_.GetFieldOffset(field));
+        }
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/message_lite.h b/CAPI/cpp/grpc/include/google/protobuf/message_lite.h
index 950ae1a..20ea34c 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/message_lite.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/message_lite.h
@@ -39,7 +39,6 @@
 #ifndef GOOGLE_PROTOBUF_MESSAGE_LITE_H__
 #define GOOGLE_PROTOBUF_MESSAGE_LITE_H__
 
-
 #include <climits>
 #include <string>
 
@@ -62,528 +61,572 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-template <typename T>
-class RepeatedPtrField;
-
-class FastReflectionMessageMutator;
-class FastReflectionStringSetter;
-class Reflection;
-
-namespace io {
-
-class CodedInputStream;
-class CodedOutputStream;
-class ZeroCopyInputStream;
-class ZeroCopyOutputStream;
-
-}  // namespace io
-namespace internal {
-
-class SwapFieldHelper;
-
-// See parse_context.h for explanation
-class ParseContext;
-
-class ExtensionSet;
-class LazyField;
-class RepeatedPtrFieldBase;
-class TcParser;
-class WireFormatLite;
-class WeakFieldMap;
-
-template <typename Type>
-class GenericTypeHandler;  // defined in repeated_field.h
-
-// We compute sizes as size_t but cache them as int.  This function converts a
-// computed size to a cached size.  Since we don't proceed with serialization
-// if the total size was > INT_MAX, it is not important what this function
-// returns for inputs > INT_MAX.  However this case should not error or
-// GOOGLE_CHECK-fail, because the full size_t resolution is still returned from
-// ByteSizeLong() and checked against INT_MAX; we can catch the overflow
-// there.
-inline int ToCachedSize(size_t size) { return static_cast<int>(size); }
-
-// We mainly calculate sizes in terms of size_t, but some functions that
-// compute sizes return "int".  These int sizes are expected to always be
-// positive. This function is more efficient than casting an int to size_t
-// directly on 64-bit platforms because it avoids making the compiler emit a
-// sign extending instruction, which we don't want and don't want to pay for.
-inline size_t FromIntSize(int size) {
-  // Convert to unsigned before widening so sign extension is not necessary.
-  return static_cast<unsigned int>(size);
-}
-
-// For cases where a legacy function returns an integer size.  We GOOGLE_DCHECK()
-// that the conversion will fit within an integer; if this is false then we
-// are losing information.
-inline int ToIntSize(size_t size) {
-  GOOGLE_DCHECK_LE(size, static_cast<size_t>(INT_MAX));
-  return static_cast<int>(size);
-}
-
-// Default empty string object. Don't use this directly. Instead, call
-// GetEmptyString() to get the reference. This empty string is aligned with a
-// minimum alignment of 8 bytes to match the requirement of ArenaStringPtr.
-PROTOBUF_EXPORT extern ExplicitlyConstructedArenaString
-    fixed_address_empty_string;
-
-
-PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited() {
-  return fixed_address_empty_string.get();
-}
-
-PROTOBUF_EXPORT size_t StringSpaceUsedExcludingSelfLong(const std::string& str);
-
-}  // namespace internal
-
-// Interface to light weight protocol messages.
-//
-// This interface is implemented by all protocol message objects.  Non-lite
-// messages additionally implement the Message interface, which is a
-// subclass of MessageLite.  Use MessageLite instead when you only need
-// the subset of features which it supports -- namely, nothing that uses
-// descriptors or reflection.  You can instruct the protocol compiler
-// to generate classes which implement only MessageLite, not the full
-// Message interface, by adding the following line to the .proto file:
-//
-//   option optimize_for = LITE_RUNTIME;
-//
-// This is particularly useful on resource-constrained systems where
-// the full protocol buffers runtime library is too big.
-//
-// Note that on non-constrained systems (e.g. servers) when you need
-// to link in lots of protocol definitions, a better way to reduce
-// total code footprint is to use optimize_for = CODE_SIZE.  This
-// will make the generated code smaller while still supporting all the
-// same features (at the expense of speed).  optimize_for = LITE_RUNTIME
-// is best when you only have a small number of message types linked
-// into your binary, in which case the size of the protocol buffers
-// runtime itself is the biggest problem.
-//
-// Users must not derive from this class. Only the protocol compiler and
-// the internal library are allowed to create subclasses.
-class PROTOBUF_EXPORT MessageLite {
- public:
-  constexpr MessageLite() {}
-  virtual ~MessageLite() = default;
-
-  // Basic Operations ------------------------------------------------
-
-  // Get the name of this message type, e.g. "foo.bar.BazProto".
-  virtual std::string GetTypeName() const = 0;
-
-  // Construct a new instance of the same type.  Ownership is passed to the
-  // caller.
-  MessageLite* New() const { return New(nullptr); }
-
-  // Construct a new instance on the arena. Ownership is passed to the caller
-  // if arena is a nullptr.
-  virtual MessageLite* New(Arena* arena) const = 0;
-
-  // Returns user-owned arena; nullptr if it's message owned.
-  Arena* GetArena() const { return _internal_metadata_.user_arena(); }
-
-  // Clear all fields of the message and set them to their default values.
-  // Clear() assumes that any memory allocated to hold parts of the message
-  // will likely be needed again, so the memory used may not be freed.
-  // To ensure that all memory used by a Message is freed, you must delete it.
-  virtual void Clear() = 0;
-
-  // Quickly check if all required fields have values set.
-  virtual bool IsInitialized() const = 0;
-
-  // This is not implemented for Lite messages -- it just returns "(cannot
-  // determine missing fields for lite message)".  However, it is implemented
-  // for full messages.  See message.h.
-  virtual std::string InitializationErrorString() const;
-
-  // If |other| is the exact same class as this, calls MergeFrom(). Otherwise,
-  // results are undefined (probably crash).
-  virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0;
-
-  // These methods return a human-readable summary of the message. Note that
-  // since the MessageLite interface does not support reflection, there is very
-  // little information that these methods can provide. They are shadowed by
-  // methods of the same name on the Message interface which provide much more
-  // information. The methods here are intended primarily to facilitate code
-  // reuse for logic that needs to interoperate with both full and lite protos.
-  //
-  // The format of the returned string is subject to change, so please do not
-  // assume it will remain stable over time.
-  std::string DebugString() const;
-  std::string ShortDebugString() const { return DebugString(); }
-  // MessageLite::DebugString is already Utf8 Safe. This is to add compatibility
-  // with Message.
-  std::string Utf8DebugString() const { return DebugString(); }
-
-  // Parsing ---------------------------------------------------------
-  // Methods for parsing in protocol buffer format.  Most of these are
-  // just simple wrappers around MergeFromCodedStream().  Clear() will be
-  // called before merging the input.
-
-  // Fill the message with a protocol buffer parsed from the given input
-  // stream. Returns false on a read error or if the input is in the wrong
-  // format.  A successful return does not indicate the entire input is
-  // consumed, ensure you call ConsumedEntireMessage() to check that if
-  // applicable.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromCodedStream(
-      io::CodedInputStream* input);
-  // Like ParseFromCodedStream(), but accepts messages that are missing
-  // required fields.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromCodedStream(
-      io::CodedInputStream* input);
-  // Read a protocol buffer from the given zero-copy input stream.  If
-  // successful, the entire input will be consumed.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromZeroCopyStream(
-      io::ZeroCopyInputStream* input);
-  // Like ParseFromZeroCopyStream(), but accepts messages that are missing
-  // required fields.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromZeroCopyStream(
-      io::ZeroCopyInputStream* input);
-  // Parse a protocol buffer from a file descriptor.  If successful, the entire
-  // input will be consumed.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromFileDescriptor(
-      int file_descriptor);
-  // Like ParseFromFileDescriptor(), but accepts messages that are missing
-  // required fields.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromFileDescriptor(
-      int file_descriptor);
-  // Parse a protocol buffer from a C++ istream.  If successful, the entire
-  // input will be consumed.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromIstream(std::istream* input);
-  // Like ParseFromIstream(), but accepts messages that are missing
-  // required fields.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromIstream(
-      std::istream* input);
-  // Read a protocol buffer from the given zero-copy input stream, expecting
-  // the message to be exactly "size" bytes long.  If successful, exactly
-  // this many bytes will have been consumed from the input.
-  bool MergePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
-                                             int size);
-  // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
-  // missing required fields.
-  bool MergeFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromBoundedZeroCopyStream(
-      io::ZeroCopyInputStream* input, int size);
-  // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
-  // missing required fields.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromBoundedZeroCopyStream(
-      io::ZeroCopyInputStream* input, int size);
-  // Parses a protocol buffer contained in a string. Returns true on success.
-  // This function takes a string in the (non-human-readable) binary wire
-  // format, matching the encoding output by MessageLite::SerializeToString().
-  // If you'd like to convert a human-readable string into a protocol buffer
-  // object, see google::protobuf::TextFormat::ParseFromString().
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromString(ConstStringParam data);
-  // Like ParseFromString(), but accepts messages that are missing
-  // required fields.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromString(
-      ConstStringParam data);
-  // Parse a protocol buffer contained in an array of bytes.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromArray(const void* data,
-                                                       int size);
-  // Like ParseFromArray(), but accepts messages that are missing
-  // required fields.
-  PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromArray(const void* data,
-                                                              int size);
-
-
-  // Reads a protocol buffer from the stream and merges it into this
-  // Message.  Singular fields read from the what is
-  // already in the Message and repeated fields are appended to those
-  // already present.
-  //
-  // It is the responsibility of the caller to call input->LastTagWas()
-  // (for groups) or input->ConsumedEntireMessage() (for non-groups) after
-  // this returns to verify that the message's end was delimited correctly.
-  //
-  // ParseFromCodedStream() is implemented as Clear() followed by
-  // MergeFromCodedStream().
-  bool MergeFromCodedStream(io::CodedInputStream* input);
-
-  // Like MergeFromCodedStream(), but succeeds even if required fields are
-  // missing in the input.
-  //
-  // MergeFromCodedStream() is just implemented as MergePartialFromCodedStream()
-  // followed by IsInitialized().
-  bool MergePartialFromCodedStream(io::CodedInputStream* input);
-
-  // Merge a protocol buffer contained in a string.
-  bool MergeFromString(ConstStringParam data);
-
-
-  // Serialization ---------------------------------------------------
-  // Methods for serializing in protocol buffer format.  Most of these
-  // are just simple wrappers around ByteSize() and SerializeWithCachedSizes().
-
-  // Write a protocol buffer of this message to the given output.  Returns
-  // false on a write error.  If the message is missing required fields,
-  // this may GOOGLE_CHECK-fail.
-  bool SerializeToCodedStream(io::CodedOutputStream* output) const;
-  // Like SerializeToCodedStream(), but allows missing required fields.
-  bool SerializePartialToCodedStream(io::CodedOutputStream* output) const;
-  // Write the message to the given zero-copy output stream.  All required
-  // fields must be set.
-  bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
-  // Like SerializeToZeroCopyStream(), but allows missing required fields.
-  bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
-  // Serialize the message and store it in the given string.  All required
-  // fields must be set.
-  bool SerializeToString(std::string* output) const;
-  // Like SerializeToString(), but allows missing required fields.
-  bool SerializePartialToString(std::string* output) const;
-  // Serialize the message and store it in the given byte array.  All required
-  // fields must be set.
-  bool SerializeToArray(void* data, int size) const;
-  // Like SerializeToArray(), but allows missing required fields.
-  bool SerializePartialToArray(void* data, int size) const;
-
-  // Make a string encoding the message. Is equivalent to calling
-  // SerializeToString() on a string and using that.  Returns the empty
-  // string if SerializeToString() would have returned an error.
-  // Note: If you intend to generate many such strings, you may
-  // reduce heap fragmentation by instead re-using the same string
-  // object with calls to SerializeToString().
-  std::string SerializeAsString() const;
-  // Like SerializeAsString(), but allows missing required fields.
-  std::string SerializePartialAsString() const;
-
-  // Serialize the message and write it to the given file descriptor.  All
-  // required fields must be set.
-  bool SerializeToFileDescriptor(int file_descriptor) const;
-  // Like SerializeToFileDescriptor(), but allows missing required fields.
-  bool SerializePartialToFileDescriptor(int file_descriptor) const;
-  // Serialize the message and write it to the given C++ ostream.  All
-  // required fields must be set.
-  bool SerializeToOstream(std::ostream* output) const;
-  // Like SerializeToOstream(), but allows missing required fields.
-  bool SerializePartialToOstream(std::ostream* output) const;
-
-  // Like SerializeToString(), but appends to the data to the string's
-  // existing contents.  All required fields must be set.
-  bool AppendToString(std::string* output) const;
-  // Like AppendToString(), but allows missing required fields.
-  bool AppendPartialToString(std::string* output) const;
-
-
-  // Computes the serialized size of the message.  This recursively calls
-  // ByteSizeLong() on all embedded messages.
-  //
-  // ByteSizeLong() is generally linear in the number of fields defined for the
-  // proto.
-  virtual size_t ByteSizeLong() const = 0;
-
-  // Legacy ByteSize() API.
-  PROTOBUF_DEPRECATED_MSG("Please use ByteSizeLong() instead")
-  int ByteSize() const { return internal::ToIntSize(ByteSizeLong()); }
-
-  // Serializes the message without recomputing the size.  The message must not
-  // have changed since the last call to ByteSize(), and the value returned by
-  // ByteSize must be non-negative.  Otherwise the results are undefined.
-  void SerializeWithCachedSizes(io::CodedOutputStream* output) const {
-    output->SetCur(_InternalSerialize(output->Cur(), output->EpsCopy()));
-  }
-
-  // Functions below here are not part of the public interface.  It isn't
-  // enforced, but they should be treated as private, and will be private
-  // at some future time.  Unfortunately the implementation of the "friend"
-  // keyword in GCC is broken at the moment, but we expect it will be fixed.
-
-  // Like SerializeWithCachedSizes, but writes directly to *target, returning
-  // a pointer to the byte immediately after the last byte written.  "target"
-  // must point at a byte array of at least ByteSize() bytes.  Whether to use
-  // deterministic serialization, e.g., maps in sorted order, is determined by
-  // CodedOutputStream::IsDefaultSerializationDeterministic().
-  uint8_t* SerializeWithCachedSizesToArray(uint8_t* target) const;
-
-  // Returns the result of the last call to ByteSize().  An embedded message's
-  // size is needed both to serialize it (because embedded messages are
-  // length-delimited) and to compute the outer message's size.  Caching
-  // the size avoids computing it multiple times.
-  //
-  // ByteSize() does not automatically use the cached size when available
-  // because this would require invalidating it every time the message was
-  // modified, which would be too hard and expensive.  (E.g. if a deeply-nested
-  // sub-message is changed, all of its parents' cached sizes would need to be
-  // invalidated, which is too much work for an otherwise inlined setter
-  // method.)
-  virtual int GetCachedSize() const = 0;
-
-  virtual const char* _InternalParse(const char* /*ptr*/,
-                                     internal::ParseContext* /*ctx*/) {
-    return nullptr;
-  }
-
-  virtual void OnDemandRegisterArenaDtor(Arena* /*arena*/) {}
-
- protected:
-  template <typename T>
-  static T* CreateMaybeMessage(Arena* arena) {
-    return Arena::CreateMaybeMessage<T>(arena);
-  }
-
-  inline explicit MessageLite(Arena* arena, bool is_message_owned = false)
-      : _internal_metadata_(arena, is_message_owned) {}
-
-  // Returns the arena, if any, that directly owns this message and its internal
-  // memory (Arena::Own is different in that the arena doesn't directly own the
-  // internal memory). This method is used in proto's implementation for
-  // swapping, moving and setting allocated, for deciding whether the ownership
-  // of this message or its internal memory could be changed.
-  Arena* GetOwningArena() const { return _internal_metadata_.owning_arena(); }
-
-  // Returns the arena, used for allocating internal objects(e.g., child
-  // messages, etc), or owning incoming objects (e.g., set allocated).
-  Arena* GetArenaForAllocation() const { return _internal_metadata_.arena(); }
-
-  // Returns true if this message is enabled for message-owned arena (MOA)
-  // trials. No lite messages are eligible for MOA.
-  static bool InMoaTrial() { return false; }
-
-  internal::InternalMetadata _internal_metadata_;
-
- public:
-  enum ParseFlags {
-    kMerge = 0,
-    kParse = 1,
-    kMergePartial = 2,
-    kParsePartial = 3,
-    kMergeWithAliasing = 4,
-    kParseWithAliasing = 5,
-    kMergePartialWithAliasing = 6,
-    kParsePartialWithAliasing = 7
-  };
-
-  template <ParseFlags flags, typename T>
-  bool ParseFrom(const T& input);
-
-  // Fast path when conditions match (ie. non-deterministic)
-  //  uint8_t* _InternalSerialize(uint8_t* ptr) const;
-  virtual uint8_t* _InternalSerialize(
-      uint8_t* ptr, io::EpsCopyOutputStream* stream) const = 0;
-
-  // Identical to IsInitialized() except that it logs an error message.
-  bool IsInitializedWithErrors() const {
-    if (IsInitialized()) return true;
-    LogInitializationErrorMessage();
-    return false;
-  }
-
- private:
-  friend class FastReflectionMessageMutator;
-  friend class FastReflectionStringSetter;
-  friend class Message;
-  friend class Reflection;
-  friend class internal::ExtensionSet;
-  friend class internal::LazyField;
-  friend class internal::SwapFieldHelper;
-  friend class internal::TcParser;
-  friend class internal::WeakFieldMap;
-  friend class internal::WireFormatLite;
-
-  template <typename Type>
-  friend class Arena::InternalHelper;
-  template <typename Type>
-  friend class internal::GenericTypeHandler;
-
-  void LogInitializationErrorMessage() const;
-
-  bool MergeFromImpl(io::CodedInputStream* input, ParseFlags parse_flags);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite);
-};
-
-namespace internal {
-
-template <bool alias>
-bool MergeFromImpl(StringPiece input, MessageLite* msg,
-                   MessageLite::ParseFlags parse_flags);
-extern template bool MergeFromImpl<false>(StringPiece input,
-                                          MessageLite* msg,
-                                          MessageLite::ParseFlags parse_flags);
-extern template bool MergeFromImpl<true>(StringPiece input,
-                                         MessageLite* msg,
-                                         MessageLite::ParseFlags parse_flags);
-
-template <bool alias>
-bool MergeFromImpl(io::ZeroCopyInputStream* input, MessageLite* msg,
-                   MessageLite::ParseFlags parse_flags);
-extern template bool MergeFromImpl<false>(io::ZeroCopyInputStream* input,
-                                          MessageLite* msg,
-                                          MessageLite::ParseFlags parse_flags);
-extern template bool MergeFromImpl<true>(io::ZeroCopyInputStream* input,
-                                         MessageLite* msg,
-                                         MessageLite::ParseFlags parse_flags);
-
-struct BoundedZCIS {
-  io::ZeroCopyInputStream* zcis;
-  int limit;
-};
-
-template <bool alias>
-bool MergeFromImpl(BoundedZCIS input, MessageLite* msg,
-                   MessageLite::ParseFlags parse_flags);
-extern template bool MergeFromImpl<false>(BoundedZCIS input, MessageLite* msg,
-                                          MessageLite::ParseFlags parse_flags);
-extern template bool MergeFromImpl<true>(BoundedZCIS input, MessageLite* msg,
-                                         MessageLite::ParseFlags parse_flags);
-
-template <typename T>
-struct SourceWrapper;
-
-template <bool alias, typename T>
-bool MergeFromImpl(const SourceWrapper<T>& input, MessageLite* msg,
-                   MessageLite::ParseFlags parse_flags) {
-  return input.template MergeInto<alias>(msg, parse_flags);
-}
-
-}  // namespace internal
-
-template <MessageLite::ParseFlags flags, typename T>
-bool MessageLite::ParseFrom(const T& input) {
-  if (flags & kParse) Clear();
-  constexpr bool alias = (flags & kMergeWithAliasing) != 0;
-  return internal::MergeFromImpl<alias>(input, this, flags);
-}
-
-// ===================================================================
-// Shutdown support.
-
-
-// Shut down the entire protocol buffers library, deleting all static-duration
-// objects allocated by the library or by generated .pb.cc files.
-//
-// There are two reasons you might want to call this:
-// * You use a draconian definition of "memory leak" in which you expect
-//   every single malloc() to have a corresponding free(), even for objects
-//   which live until program exit.
-// * You are writing a dynamically-loaded library which needs to clean up
-//   after itself when the library is unloaded.
-//
-// It is safe to call this multiple times.  However, it is not safe to use
-// any other part of the protocol buffers library after
-// ShutdownProtobufLibrary() has been called. Furthermore this call is not
-// thread safe, user needs to synchronize multiple calls.
-PROTOBUF_EXPORT void ShutdownProtobufLibrary();
-
-namespace internal {
-
-// Register a function to be called when ShutdownProtocolBuffers() is called.
-PROTOBUF_EXPORT void OnShutdown(void (*func)());
-// Run an arbitrary function on an arg
-PROTOBUF_EXPORT void OnShutdownRun(void (*f)(const void*), const void* arg);
-
-template <typename T>
-T* OnShutdownDelete(T* p) {
-  OnShutdownRun([](const void* pp) { delete static_cast<const T*>(pp); }, p);
-  return p;
-}
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        template<typename T>
+        class RepeatedPtrField;
+
+        class FastReflectionMessageMutator;
+        class FastReflectionStringSetter;
+        class Reflection;
+
+        namespace io
+        {
+
+            class CodedInputStream;
+            class CodedOutputStream;
+            class ZeroCopyInputStream;
+            class ZeroCopyOutputStream;
+
+        }  // namespace io
+        namespace internal
+        {
+
+            class SwapFieldHelper;
+
+            // See parse_context.h for explanation
+            class ParseContext;
+
+            class ExtensionSet;
+            class LazyField;
+            class RepeatedPtrFieldBase;
+            class TcParser;
+            class WireFormatLite;
+            class WeakFieldMap;
+
+            template<typename Type>
+            class GenericTypeHandler;  // defined in repeated_field.h
+
+            // We compute sizes as size_t but cache them as int.  This function converts a
+            // computed size to a cached size.  Since we don't proceed with serialization
+            // if the total size was > INT_MAX, it is not important what this function
+            // returns for inputs > INT_MAX.  However this case should not error or
+            // GOOGLE_CHECK-fail, because the full size_t resolution is still returned from
+            // ByteSizeLong() and checked against INT_MAX; we can catch the overflow
+            // there.
+            inline int ToCachedSize(size_t size)
+            {
+                return static_cast<int>(size);
+            }
+
+            // We mainly calculate sizes in terms of size_t, but some functions that
+            // compute sizes return "int".  These int sizes are expected to always be
+            // positive. This function is more efficient than casting an int to size_t
+            // directly on 64-bit platforms because it avoids making the compiler emit a
+            // sign extending instruction, which we don't want and don't want to pay for.
+            inline size_t FromIntSize(int size)
+            {
+                // Convert to unsigned before widening so sign extension is not necessary.
+                return static_cast<unsigned int>(size);
+            }
+
+            // For cases where a legacy function returns an integer size.  We GOOGLE_DCHECK()
+            // that the conversion will fit within an integer; if this is false then we
+            // are losing information.
+            inline int ToIntSize(size_t size)
+            {
+                GOOGLE_DCHECK_LE(size, static_cast<size_t>(INT_MAX));
+                return static_cast<int>(size);
+            }
+
+            // Default empty string object. Don't use this directly. Instead, call
+            // GetEmptyString() to get the reference. This empty string is aligned with a
+            // minimum alignment of 8 bytes to match the requirement of ArenaStringPtr.
+            PROTOBUF_EXPORT extern ExplicitlyConstructedArenaString
+                fixed_address_empty_string;
+
+            PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited()
+            {
+                return fixed_address_empty_string.get();
+            }
+
+            PROTOBUF_EXPORT size_t StringSpaceUsedExcludingSelfLong(const std::string& str);
+
+        }  // namespace internal
+
+        // Interface to light weight protocol messages.
+        //
+        // This interface is implemented by all protocol message objects.  Non-lite
+        // messages additionally implement the Message interface, which is a
+        // subclass of MessageLite.  Use MessageLite instead when you only need
+        // the subset of features which it supports -- namely, nothing that uses
+        // descriptors or reflection.  You can instruct the protocol compiler
+        // to generate classes which implement only MessageLite, not the full
+        // Message interface, by adding the following line to the .proto file:
+        //
+        //   option optimize_for = LITE_RUNTIME;
+        //
+        // This is particularly useful on resource-constrained systems where
+        // the full protocol buffers runtime library is too big.
+        //
+        // Note that on non-constrained systems (e.g. servers) when you need
+        // to link in lots of protocol definitions, a better way to reduce
+        // total code footprint is to use optimize_for = CODE_SIZE.  This
+        // will make the generated code smaller while still supporting all the
+        // same features (at the expense of speed).  optimize_for = LITE_RUNTIME
+        // is best when you only have a small number of message types linked
+        // into your binary, in which case the size of the protocol buffers
+        // runtime itself is the biggest problem.
+        //
+        // Users must not derive from this class. Only the protocol compiler and
+        // the internal library are allowed to create subclasses.
+        class PROTOBUF_EXPORT MessageLite
+        {
+        public:
+            constexpr MessageLite()
+            {
+            }
+            virtual ~MessageLite() = default;
+
+            // Basic Operations ------------------------------------------------
+
+            // Get the name of this message type, e.g. "foo.bar.BazProto".
+            virtual std::string GetTypeName() const = 0;
+
+            // Construct a new instance of the same type.  Ownership is passed to the
+            // caller.
+            MessageLite* New() const
+            {
+                return New(nullptr);
+            }
+
+            // Construct a new instance on the arena. Ownership is passed to the caller
+            // if arena is a nullptr.
+            virtual MessageLite* New(Arena* arena) const = 0;
+
+            // Returns user-owned arena; nullptr if it's message owned.
+            Arena* GetArena() const
+            {
+                return _internal_metadata_.user_arena();
+            }
+
+            // Clear all fields of the message and set them to their default values.
+            // Clear() assumes that any memory allocated to hold parts of the message
+            // will likely be needed again, so the memory used may not be freed.
+            // To ensure that all memory used by a Message is freed, you must delete it.
+            virtual void Clear() = 0;
+
+            // Quickly check if all required fields have values set.
+            virtual bool IsInitialized() const = 0;
+
+            // This is not implemented for Lite messages -- it just returns "(cannot
+            // determine missing fields for lite message)".  However, it is implemented
+            // for full messages.  See message.h.
+            virtual std::string InitializationErrorString() const;
+
+            // If |other| is the exact same class as this, calls MergeFrom(). Otherwise,
+            // results are undefined (probably crash).
+            virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0;
+
+            // These methods return a human-readable summary of the message. Note that
+            // since the MessageLite interface does not support reflection, there is very
+            // little information that these methods can provide. They are shadowed by
+            // methods of the same name on the Message interface which provide much more
+            // information. The methods here are intended primarily to facilitate code
+            // reuse for logic that needs to interoperate with both full and lite protos.
+            //
+            // The format of the returned string is subject to change, so please do not
+            // assume it will remain stable over time.
+            std::string DebugString() const;
+            std::string ShortDebugString() const
+            {
+                return DebugString();
+            }
+            // MessageLite::DebugString is already Utf8 Safe. This is to add compatibility
+            // with Message.
+            std::string Utf8DebugString() const
+            {
+                return DebugString();
+            }
+
+            // Parsing ---------------------------------------------------------
+            // Methods for parsing in protocol buffer format.  Most of these are
+            // just simple wrappers around MergeFromCodedStream().  Clear() will be
+            // called before merging the input.
+
+            // Fill the message with a protocol buffer parsed from the given input
+            // stream. Returns false on a read error or if the input is in the wrong
+            // format.  A successful return does not indicate the entire input is
+            // consumed, ensure you call ConsumedEntireMessage() to check that if
+            // applicable.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromCodedStream(
+                io::CodedInputStream* input
+            );
+            // Like ParseFromCodedStream(), but accepts messages that are missing
+            // required fields.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromCodedStream(
+                io::CodedInputStream* input
+            );
+            // Read a protocol buffer from the given zero-copy input stream.  If
+            // successful, the entire input will be consumed.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromZeroCopyStream(
+                io::ZeroCopyInputStream* input
+            );
+            // Like ParseFromZeroCopyStream(), but accepts messages that are missing
+            // required fields.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromZeroCopyStream(
+                io::ZeroCopyInputStream* input
+            );
+            // Parse a protocol buffer from a file descriptor.  If successful, the entire
+            // input will be consumed.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromFileDescriptor(
+                int file_descriptor
+            );
+            // Like ParseFromFileDescriptor(), but accepts messages that are missing
+            // required fields.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromFileDescriptor(
+                int file_descriptor
+            );
+            // Parse a protocol buffer from a C++ istream.  If successful, the entire
+            // input will be consumed.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromIstream(std::istream* input);
+            // Like ParseFromIstream(), but accepts messages that are missing
+            // required fields.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromIstream(
+                std::istream* input
+            );
+            // Read a protocol buffer from the given zero-copy input stream, expecting
+            // the message to be exactly "size" bytes long.  If successful, exactly
+            // this many bytes will have been consumed from the input.
+            bool MergePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
+            // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
+            // missing required fields.
+            bool MergeFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromBoundedZeroCopyStream(
+                io::ZeroCopyInputStream* input, int size
+            );
+            // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
+            // missing required fields.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromBoundedZeroCopyStream(
+                io::ZeroCopyInputStream* input, int size
+            );
+            // Parses a protocol buffer contained in a string. Returns true on success.
+            // This function takes a string in the (non-human-readable) binary wire
+            // format, matching the encoding output by MessageLite::SerializeToString().
+            // If you'd like to convert a human-readable string into a protocol buffer
+            // object, see google::protobuf::TextFormat::ParseFromString().
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromString(ConstStringParam data);
+            // Like ParseFromString(), but accepts messages that are missing
+            // required fields.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromString(
+                ConstStringParam data
+            );
+            // Parse a protocol buffer contained in an array of bytes.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromArray(const void* data, int size);
+            // Like ParseFromArray(), but accepts messages that are missing
+            // required fields.
+            PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromArray(const void* data, int size);
+
+            // Reads a protocol buffer from the stream and merges it into this
+            // Message.  Singular fields read from the what is
+            // already in the Message and repeated fields are appended to those
+            // already present.
+            //
+            // It is the responsibility of the caller to call input->LastTagWas()
+            // (for groups) or input->ConsumedEntireMessage() (for non-groups) after
+            // this returns to verify that the message's end was delimited correctly.
+            //
+            // ParseFromCodedStream() is implemented as Clear() followed by
+            // MergeFromCodedStream().
+            bool MergeFromCodedStream(io::CodedInputStream* input);
+
+            // Like MergeFromCodedStream(), but succeeds even if required fields are
+            // missing in the input.
+            //
+            // MergeFromCodedStream() is just implemented as MergePartialFromCodedStream()
+            // followed by IsInitialized().
+            bool MergePartialFromCodedStream(io::CodedInputStream* input);
+
+            // Merge a protocol buffer contained in a string.
+            bool MergeFromString(ConstStringParam data);
+
+            // Serialization ---------------------------------------------------
+            // Methods for serializing in protocol buffer format.  Most of these
+            // are just simple wrappers around ByteSize() and SerializeWithCachedSizes().
+
+            // Write a protocol buffer of this message to the given output.  Returns
+            // false on a write error.  If the message is missing required fields,
+            // this may GOOGLE_CHECK-fail.
+            bool SerializeToCodedStream(io::CodedOutputStream* output) const;
+            // Like SerializeToCodedStream(), but allows missing required fields.
+            bool SerializePartialToCodedStream(io::CodedOutputStream* output) const;
+            // Write the message to the given zero-copy output stream.  All required
+            // fields must be set.
+            bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
+            // Like SerializeToZeroCopyStream(), but allows missing required fields.
+            bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
+            // Serialize the message and store it in the given string.  All required
+            // fields must be set.
+            bool SerializeToString(std::string* output) const;
+            // Like SerializeToString(), but allows missing required fields.
+            bool SerializePartialToString(std::string* output) const;
+            // Serialize the message and store it in the given byte array.  All required
+            // fields must be set.
+            bool SerializeToArray(void* data, int size) const;
+            // Like SerializeToArray(), but allows missing required fields.
+            bool SerializePartialToArray(void* data, int size) const;
+
+            // Make a string encoding the message. Is equivalent to calling
+            // SerializeToString() on a string and using that.  Returns the empty
+            // string if SerializeToString() would have returned an error.
+            // Note: If you intend to generate many such strings, you may
+            // reduce heap fragmentation by instead re-using the same string
+            // object with calls to SerializeToString().
+            std::string SerializeAsString() const;
+            // Like SerializeAsString(), but allows missing required fields.
+            std::string SerializePartialAsString() const;
+
+            // Serialize the message and write it to the given file descriptor.  All
+            // required fields must be set.
+            bool SerializeToFileDescriptor(int file_descriptor) const;
+            // Like SerializeToFileDescriptor(), but allows missing required fields.
+            bool SerializePartialToFileDescriptor(int file_descriptor) const;
+            // Serialize the message and write it to the given C++ ostream.  All
+            // required fields must be set.
+            bool SerializeToOstream(std::ostream* output) const;
+            // Like SerializeToOstream(), but allows missing required fields.
+            bool SerializePartialToOstream(std::ostream* output) const;
+
+            // Like SerializeToString(), but appends to the data to the string's
+            // existing contents.  All required fields must be set.
+            bool AppendToString(std::string* output) const;
+            // Like AppendToString(), but allows missing required fields.
+            bool AppendPartialToString(std::string* output) const;
+
+            // Computes the serialized size of the message.  This recursively calls
+            // ByteSizeLong() on all embedded messages.
+            //
+            // ByteSizeLong() is generally linear in the number of fields defined for the
+            // proto.
+            virtual size_t ByteSizeLong() const = 0;
+
+            // Legacy ByteSize() API.
+            PROTOBUF_DEPRECATED_MSG("Please use ByteSizeLong() instead")
+            int ByteSize() const
+            {
+                return internal::ToIntSize(ByteSizeLong());
+            }
+
+            // Serializes the message without recomputing the size.  The message must not
+            // have changed since the last call to ByteSize(), and the value returned by
+            // ByteSize must be non-negative.  Otherwise the results are undefined.
+            void SerializeWithCachedSizes(io::CodedOutputStream* output) const
+            {
+                output->SetCur(_InternalSerialize(output->Cur(), output->EpsCopy()));
+            }
+
+            // Functions below here are not part of the public interface.  It isn't
+            // enforced, but they should be treated as private, and will be private
+            // at some future time.  Unfortunately the implementation of the "friend"
+            // keyword in GCC is broken at the moment, but we expect it will be fixed.
+
+            // Like SerializeWithCachedSizes, but writes directly to *target, returning
+            // a pointer to the byte immediately after the last byte written.  "target"
+            // must point at a byte array of at least ByteSize() bytes.  Whether to use
+            // deterministic serialization, e.g., maps in sorted order, is determined by
+            // CodedOutputStream::IsDefaultSerializationDeterministic().
+            uint8_t* SerializeWithCachedSizesToArray(uint8_t* target) const;
+
+            // Returns the result of the last call to ByteSize().  An embedded message's
+            // size is needed both to serialize it (because embedded messages are
+            // length-delimited) and to compute the outer message's size.  Caching
+            // the size avoids computing it multiple times.
+            //
+            // ByteSize() does not automatically use the cached size when available
+            // because this would require invalidating it every time the message was
+            // modified, which would be too hard and expensive.  (E.g. if a deeply-nested
+            // sub-message is changed, all of its parents' cached sizes would need to be
+            // invalidated, which is too much work for an otherwise inlined setter
+            // method.)
+            virtual int GetCachedSize() const = 0;
+
+            virtual const char* _InternalParse(const char* /*ptr*/, internal::ParseContext* /*ctx*/)
+            {
+                return nullptr;
+            }
+
+            virtual void OnDemandRegisterArenaDtor(Arena* /*arena*/)
+            {
+            }
+
+        protected:
+            template<typename T>
+            static T* CreateMaybeMessage(Arena* arena)
+            {
+                return Arena::CreateMaybeMessage<T>(arena);
+            }
+
+            inline explicit MessageLite(Arena* arena, bool is_message_owned = false) :
+                _internal_metadata_(arena, is_message_owned)
+            {
+            }
+
+            // Returns the arena, if any, that directly owns this message and its internal
+            // memory (Arena::Own is different in that the arena doesn't directly own the
+            // internal memory). This method is used in proto's implementation for
+            // swapping, moving and setting allocated, for deciding whether the ownership
+            // of this message or its internal memory could be changed.
+            Arena* GetOwningArena() const
+            {
+                return _internal_metadata_.owning_arena();
+            }
+
+            // Returns the arena, used for allocating internal objects(e.g., child
+            // messages, etc), or owning incoming objects (e.g., set allocated).
+            Arena* GetArenaForAllocation() const
+            {
+                return _internal_metadata_.arena();
+            }
+
+            // Returns true if this message is enabled for message-owned arena (MOA)
+            // trials. No lite messages are eligible for MOA.
+            static bool InMoaTrial()
+            {
+                return false;
+            }
+
+            internal::InternalMetadata _internal_metadata_;
+
+        public:
+            enum ParseFlags
+            {
+                kMerge = 0,
+                kParse = 1,
+                kMergePartial = 2,
+                kParsePartial = 3,
+                kMergeWithAliasing = 4,
+                kParseWithAliasing = 5,
+                kMergePartialWithAliasing = 6,
+                kParsePartialWithAliasing = 7
+            };
+
+            template<ParseFlags flags, typename T>
+            bool ParseFrom(const T& input);
+
+            // Fast path when conditions match (ie. non-deterministic)
+            //  uint8_t* _InternalSerialize(uint8_t* ptr) const;
+            virtual uint8_t* _InternalSerialize(
+                uint8_t* ptr, io::EpsCopyOutputStream* stream
+            ) const = 0;
+
+            // Identical to IsInitialized() except that it logs an error message.
+            bool IsInitializedWithErrors() const
+            {
+                if (IsInitialized())
+                    return true;
+                LogInitializationErrorMessage();
+                return false;
+            }
+
+        private:
+            friend class FastReflectionMessageMutator;
+            friend class FastReflectionStringSetter;
+            friend class Message;
+            friend class Reflection;
+            friend class internal::ExtensionSet;
+            friend class internal::LazyField;
+            friend class internal::SwapFieldHelper;
+            friend class internal::TcParser;
+            friend class internal::WeakFieldMap;
+            friend class internal::WireFormatLite;
+
+            template<typename Type>
+            friend class Arena::InternalHelper;
+            template<typename Type>
+            friend class internal::GenericTypeHandler;
+
+            void LogInitializationErrorMessage() const;
+
+            bool MergeFromImpl(io::CodedInputStream* input, ParseFlags parse_flags);
+
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite);
+        };
+
+        namespace internal
+        {
+
+            template<bool alias>
+            bool MergeFromImpl(StringPiece input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+            extern template bool MergeFromImpl<false>(StringPiece input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+            extern template bool MergeFromImpl<true>(StringPiece input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+
+            template<bool alias>
+            bool MergeFromImpl(io::ZeroCopyInputStream* input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+            extern template bool MergeFromImpl<false>(io::ZeroCopyInputStream* input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+            extern template bool MergeFromImpl<true>(io::ZeroCopyInputStream* input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+
+            struct BoundedZCIS
+            {
+                io::ZeroCopyInputStream* zcis;
+                int limit;
+            };
+
+            template<bool alias>
+            bool MergeFromImpl(BoundedZCIS input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+            extern template bool MergeFromImpl<false>(BoundedZCIS input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+            extern template bool MergeFromImpl<true>(BoundedZCIS input, MessageLite* msg, MessageLite::ParseFlags parse_flags);
+
+            template<typename T>
+            struct SourceWrapper;
+
+            template<bool alias, typename T>
+            bool MergeFromImpl(const SourceWrapper<T>& input, MessageLite* msg, MessageLite::ParseFlags parse_flags)
+            {
+                return input.template MergeInto<alias>(msg, parse_flags);
+            }
+
+        }  // namespace internal
+
+        template<MessageLite::ParseFlags flags, typename T>
+        bool MessageLite::ParseFrom(const T& input)
+        {
+            if (flags & kParse)
+                Clear();
+            constexpr bool alias = (flags & kMergeWithAliasing) != 0;
+            return internal::MergeFromImpl<alias>(input, this, flags);
+        }
+
+        // ===================================================================
+        // Shutdown support.
+
+        // Shut down the entire protocol buffers library, deleting all static-duration
+        // objects allocated by the library or by generated .pb.cc files.
+        //
+        // There are two reasons you might want to call this:
+        // * You use a draconian definition of "memory leak" in which you expect
+        //   every single malloc() to have a corresponding free(), even for objects
+        //   which live until program exit.
+        // * You are writing a dynamically-loaded library which needs to clean up
+        //   after itself when the library is unloaded.
+        //
+        // It is safe to call this multiple times.  However, it is not safe to use
+        // any other part of the protocol buffers library after
+        // ShutdownProtobufLibrary() has been called. Furthermore this call is not
+        // thread safe, user needs to synchronize multiple calls.
+        PROTOBUF_EXPORT void ShutdownProtobufLibrary();
+
+        namespace internal
+        {
+
+            // Register a function to be called when ShutdownProtocolBuffers() is called.
+            PROTOBUF_EXPORT void OnShutdown(void (*func)());
+            // Run an arbitrary function on an arg
+            PROTOBUF_EXPORT void OnShutdownRun(void (*f)(const void*), const void* arg);
+
+            template<typename T>
+            T* OnShutdownDelete(T* p)
+            {
+                OnShutdownRun([](const void* pp)
+                              { delete static_cast<const T*>(pp); },
+                              p);
+                return p;
+            }
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/metadata_lite.h b/CAPI/cpp/grpc/include/google/protobuf/metadata_lite.h
index 0c31517..85908b5 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/metadata_lite.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/metadata_lite.h
@@ -43,272 +43,332 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// This is the representation for messages that support arena allocation. It
-// uses a tagged pointer to either store the owning Arena pointer, if there are
-// no unknown fields, or a pointer to a block of memory with both the owning
-// Arena pointer and the UnknownFieldSet, if there are unknown fields. Besides,
-// it also uses the tag to distinguish whether the owning Arena pointer is also
-// used by sub-structure allocation. This optimization allows for
-// "zero-overhead" storage of the Arena pointer, relative to the above baseline
-// implementation.
-//
-// The tagged pointer uses the least two significant bits to disambiguate cases.
-// It uses bit 0 == 0 to indicate an arena pointer and bit 0 == 1 to indicate a
-// UFS+Arena-container pointer. Besides it uses bit 1 == 0 to indicate arena
-// allocation and bit 1 == 1 to indicate heap allocation.
-class PROTOBUF_EXPORT InternalMetadata {
- public:
-  constexpr InternalMetadata() : ptr_(0) {}
-  explicit InternalMetadata(Arena* arena, bool is_message_owned = false) {
-    SetArena(arena, is_message_owned);
-  }
-
-  void SetArena(Arena* arena, bool is_message_owned) {
-    ptr_ = is_message_owned
-               ? reinterpret_cast<intptr_t>(arena) | kMessageOwnedArenaTagMask
-               : reinterpret_cast<intptr_t>(arena);
-    GOOGLE_DCHECK(!is_message_owned || arena != nullptr);
-  }
-
-  // To keep the ABI identical between debug and non-debug builds,
-  // the destructor is always defined here even though it may delegate
-  // to a non-inline private method.
-  // (see https://github.com/protocolbuffers/protobuf/issues/9947)
-  ~InternalMetadata() {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // This is the representation for messages that support arena allocation. It
+            // uses a tagged pointer to either store the owning Arena pointer, if there are
+            // no unknown fields, or a pointer to a block of memory with both the owning
+            // Arena pointer and the UnknownFieldSet, if there are unknown fields. Besides,
+            // it also uses the tag to distinguish whether the owning Arena pointer is also
+            // used by sub-structure allocation. This optimization allows for
+            // "zero-overhead" storage of the Arena pointer, relative to the above baseline
+            // implementation.
+            //
+            // The tagged pointer uses the least two significant bits to disambiguate cases.
+            // It uses bit 0 == 0 to indicate an arena pointer and bit 0 == 1 to indicate a
+            // UFS+Arena-container pointer. Besides it uses bit 1 == 0 to indicate arena
+            // allocation and bit 1 == 1 to indicate heap allocation.
+            class PROTOBUF_EXPORT InternalMetadata
+            {
+            public:
+                constexpr InternalMetadata() :
+                    ptr_(0)
+                {
+                }
+                explicit InternalMetadata(Arena* arena, bool is_message_owned = false)
+                {
+                    SetArena(arena, is_message_owned);
+                }
+
+                void SetArena(Arena* arena, bool is_message_owned)
+                {
+                    ptr_ = is_message_owned ? reinterpret_cast<intptr_t>(arena) | kMessageOwnedArenaTagMask : reinterpret_cast<intptr_t>(arena);
+                    GOOGLE_DCHECK(!is_message_owned || arena != nullptr);
+                }
+
+                // To keep the ABI identical between debug and non-debug builds,
+                // the destructor is always defined here even though it may delegate
+                // to a non-inline private method.
+                // (see https://github.com/protocolbuffers/protobuf/issues/9947)
+                ~InternalMetadata()
+                {
 #if defined(NDEBUG) || defined(_MSC_VER)
-    if (HasMessageOwnedArenaTag()) {
-      delete reinterpret_cast<Arena*>(ptr_ - kMessageOwnedArenaTagMask);
-    }
+                    if (HasMessageOwnedArenaTag())
+                    {
+                        delete reinterpret_cast<Arena*>(ptr_ - kMessageOwnedArenaTagMask);
+                    }
 #else
-    CheckedDestruct();
+                    CheckedDestruct();
 #endif
-  }
-
-  template <typename T>
-  void Delete() {
-    // Note that Delete<> should be called not more than once.
-    if (have_unknown_fields()) {
-      DeleteOutOfLineHelper<T>();
-    }
-  }
-
-  // DeleteReturnArena will delete the unknown fields only if they weren't
-  // allocated on an arena.  Then it updates the flags so that if you call
-  // have_unknown_fields(), it will return false.  Finally, it returns the
-  // current value of arena().  It is designed to be used as part of a
-  // Message class's destructor call, so that when control eventually gets
-  // to ~InternalMetadata(), we don't need to check for have_unknown_fields()
-  // again.
-  template <typename T>
-  Arena* DeleteReturnArena() {
-    if (have_unknown_fields()) {
-      return DeleteOutOfLineHelper<T>();
-    } else {
-      return PtrValue<Arena>();
-    }
-  }
-
-  PROTOBUF_NDEBUG_INLINE Arena* owning_arena() const {
-    return HasMessageOwnedArenaTag() ? nullptr : arena();
-  }
-
-  PROTOBUF_NDEBUG_INLINE Arena* user_arena() const {
-    Arena* a = arena();
-    return a && !a->IsMessageOwned() ? a : nullptr;
-  }
-
-  PROTOBUF_NDEBUG_INLINE Arena* arena() const {
-    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
-      return PtrValue<ContainerBase>()->arena;
-    } else {
-      return PtrValue<Arena>();
-    }
-  }
-
-  PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const {
-    return HasUnknownFieldsTag();
-  }
-
-  PROTOBUF_NDEBUG_INLINE void* raw_arena_ptr() const {
-    return reinterpret_cast<void*>(ptr_);
-  }
-
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE const T& unknown_fields(
-      const T& (*default_instance)()) const {
-    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
-      return PtrValue<Container<T>>()->unknown_fields;
-    } else {
-      return default_instance();
-    }
-  }
-
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE T* mutable_unknown_fields() {
-    if (PROTOBUF_PREDICT_TRUE(have_unknown_fields())) {
-      return &PtrValue<Container<T>>()->unknown_fields;
-    } else {
-      return mutable_unknown_fields_slow<T>();
-    }
-  }
-
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE void Swap(InternalMetadata* other) {
-    // Semantics here are that we swap only the unknown fields, not the arena
-    // pointer. We cannot simply swap ptr_ with other->ptr_ because we need to
-    // maintain our own arena ptr. Also, our ptr_ and other's ptr_ may be in
-    // different states (direct arena pointer vs. container with UFS) so we
-    // cannot simply swap ptr_ and then restore the arena pointers. We reuse
-    // UFS's swap implementation instead.
-    if (have_unknown_fields() || other->have_unknown_fields()) {
-      DoSwap<T>(other->mutable_unknown_fields<T>());
-    }
-  }
-
-  PROTOBUF_NDEBUG_INLINE void InternalSwap(InternalMetadata* other) {
-    std::swap(ptr_, other->ptr_);
-  }
-
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE void MergeFrom(const InternalMetadata& other) {
-    if (other.have_unknown_fields()) {
-      DoMergeFrom<T>(other.unknown_fields<T>(nullptr));
-    }
-  }
-
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE void Clear() {
-    if (have_unknown_fields()) {
-      DoClear<T>();
-    }
-  }
-
- private:
-  intptr_t ptr_;
-
-  // Tagged pointer implementation.
-  static constexpr intptr_t kUnknownFieldsTagMask = 1;
-  static constexpr intptr_t kMessageOwnedArenaTagMask = 2;
-  static constexpr intptr_t kPtrTagMask =
-      kUnknownFieldsTagMask | kMessageOwnedArenaTagMask;
-  static constexpr intptr_t kPtrValueMask = ~kPtrTagMask;
-
-  // Accessors for pointer tag and pointer value.
-  PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const {
-    return ptr_ & kUnknownFieldsTagMask;
-  }
-  PROTOBUF_ALWAYS_INLINE bool HasMessageOwnedArenaTag() const {
-    return ptr_ & kMessageOwnedArenaTagMask;
-  }
-
-  template <typename U>
-  U* PtrValue() const {
-    return reinterpret_cast<U*>(ptr_ & kPtrValueMask);
-  }
-
-  // If ptr_'s tag is kTagContainer, it points to an instance of this struct.
-  struct ContainerBase {
-    Arena* arena;
-  };
-
-  template <typename T>
-  struct Container : public ContainerBase {
-    T unknown_fields;
-  };
-
-  template <typename T>
-  PROTOBUF_NOINLINE Arena* DeleteOutOfLineHelper() {
-    if (auto* a = arena()) {
-      // Subtle: we want to preserve the message-owned arena flag, while at the
-      // same time replacing the pointer to Container<T> with a pointer to the
-      // arena.
-      intptr_t message_owned_arena_tag = ptr_ & kMessageOwnedArenaTagMask;
-      ptr_ = reinterpret_cast<intptr_t>(a) | message_owned_arena_tag;
-      return a;
-    } else {
-      delete PtrValue<Container<T>>();
-      ptr_ = 0;
-      return nullptr;
-    }
-  }
-
-  template <typename T>
-  PROTOBUF_NOINLINE T* mutable_unknown_fields_slow() {
-    Arena* my_arena = arena();
-    Container<T>* container = Arena::Create<Container<T>>(my_arena);
-    intptr_t message_owned_arena_tag = ptr_ & kMessageOwnedArenaTagMask;
-    // Two-step assignment works around a bug in clang's static analyzer:
-    // https://bugs.llvm.org/show_bug.cgi?id=34198.
-    ptr_ = reinterpret_cast<intptr_t>(container);
-    ptr_ |= kUnknownFieldsTagMask | message_owned_arena_tag;
-    container->arena = my_arena;
-    return &(container->unknown_fields);
-  }
-
-  // Templated functions.
-
-  template <typename T>
-  PROTOBUF_NOINLINE void DoClear() {
-    mutable_unknown_fields<T>()->Clear();
-  }
-
-  template <typename T>
-  PROTOBUF_NOINLINE void DoMergeFrom(const T& other) {
-    mutable_unknown_fields<T>()->MergeFrom(other);
-  }
-
-  template <typename T>
-  PROTOBUF_NOINLINE void DoSwap(T* other) {
-    mutable_unknown_fields<T>()->Swap(other);
-  }
-
-  // Private helper with debug checks for ~InternalMetadata()
-  void CheckedDestruct();
-};
-
-// String Template specializations.
-
-template <>
-PROTOBUF_EXPORT void InternalMetadata::DoClear<std::string>();
-template <>
-PROTOBUF_EXPORT void InternalMetadata::DoMergeFrom<std::string>(
-    const std::string& other);
-template <>
-PROTOBUF_EXPORT void InternalMetadata::DoSwap<std::string>(std::string* other);
-
-// This helper RAII class is needed to efficiently parse unknown fields. We
-// should only call mutable_unknown_fields if there are actual unknown fields.
-// The obvious thing to just use a stack string and swap it at the end of
-// the parse won't work, because the destructor of StringOutputStream needs to
-// be called before we can modify the string (it check-fails). Using
-// LiteUnknownFieldSetter setter(&_internal_metadata_);
-// StringOutputStream stream(setter.buffer());
-// guarantees that the string is only swapped after stream is destroyed.
-class PROTOBUF_EXPORT LiteUnknownFieldSetter {
- public:
-  explicit LiteUnknownFieldSetter(InternalMetadata* metadata)
-      : metadata_(metadata) {
-    if (metadata->have_unknown_fields()) {
-      buffer_.swap(*metadata->mutable_unknown_fields<std::string>());
-    }
-  }
-  ~LiteUnknownFieldSetter() {
-    if (!buffer_.empty())
-      metadata_->mutable_unknown_fields<std::string>()->swap(buffer_);
-  }
-  std::string* buffer() { return &buffer_; }
-
- private:
-  InternalMetadata* metadata_;
-  std::string buffer_;
-};
-
-}  // namespace internal
-}  // namespace protobuf
+                }
+
+                template<typename T>
+                void Delete()
+                {
+                    // Note that Delete<> should be called not more than once.
+                    if (have_unknown_fields())
+                    {
+                        DeleteOutOfLineHelper<T>();
+                    }
+                }
+
+                // DeleteReturnArena will delete the unknown fields only if they weren't
+                // allocated on an arena.  Then it updates the flags so that if you call
+                // have_unknown_fields(), it will return false.  Finally, it returns the
+                // current value of arena().  It is designed to be used as part of a
+                // Message class's destructor call, so that when control eventually gets
+                // to ~InternalMetadata(), we don't need to check for have_unknown_fields()
+                // again.
+                template<typename T>
+                Arena* DeleteReturnArena()
+                {
+                    if (have_unknown_fields())
+                    {
+                        return DeleteOutOfLineHelper<T>();
+                    }
+                    else
+                    {
+                        return PtrValue<Arena>();
+                    }
+                }
+
+                PROTOBUF_NDEBUG_INLINE Arena* owning_arena() const
+                {
+                    return HasMessageOwnedArenaTag() ? nullptr : arena();
+                }
+
+                PROTOBUF_NDEBUG_INLINE Arena* user_arena() const
+                {
+                    Arena* a = arena();
+                    return a && !a->IsMessageOwned() ? a : nullptr;
+                }
+
+                PROTOBUF_NDEBUG_INLINE Arena* arena() const
+                {
+                    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields()))
+                    {
+                        return PtrValue<ContainerBase>()->arena;
+                    }
+                    else
+                    {
+                        return PtrValue<Arena>();
+                    }
+                }
+
+                PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const
+                {
+                    return HasUnknownFieldsTag();
+                }
+
+                PROTOBUF_NDEBUG_INLINE void* raw_arena_ptr() const
+                {
+                    return reinterpret_cast<void*>(ptr_);
+                }
+
+                template<typename T>
+                PROTOBUF_NDEBUG_INLINE const T& unknown_fields(
+                    const T& (*default_instance)()
+                ) const
+                {
+                    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields()))
+                    {
+                        return PtrValue<Container<T>>()->unknown_fields;
+                    }
+                    else
+                    {
+                        return default_instance();
+                    }
+                }
+
+                template<typename T>
+                PROTOBUF_NDEBUG_INLINE T* mutable_unknown_fields()
+                {
+                    if (PROTOBUF_PREDICT_TRUE(have_unknown_fields()))
+                    {
+                        return &PtrValue<Container<T>>()->unknown_fields;
+                    }
+                    else
+                    {
+                        return mutable_unknown_fields_slow<T>();
+                    }
+                }
+
+                template<typename T>
+                PROTOBUF_NDEBUG_INLINE void Swap(InternalMetadata* other)
+                {
+                    // Semantics here are that we swap only the unknown fields, not the arena
+                    // pointer. We cannot simply swap ptr_ with other->ptr_ because we need to
+                    // maintain our own arena ptr. Also, our ptr_ and other's ptr_ may be in
+                    // different states (direct arena pointer vs. container with UFS) so we
+                    // cannot simply swap ptr_ and then restore the arena pointers. We reuse
+                    // UFS's swap implementation instead.
+                    if (have_unknown_fields() || other->have_unknown_fields())
+                    {
+                        DoSwap<T>(other->mutable_unknown_fields<T>());
+                    }
+                }
+
+                PROTOBUF_NDEBUG_INLINE void InternalSwap(InternalMetadata* other)
+                {
+                    std::swap(ptr_, other->ptr_);
+                }
+
+                template<typename T>
+                PROTOBUF_NDEBUG_INLINE void MergeFrom(const InternalMetadata& other)
+                {
+                    if (other.have_unknown_fields())
+                    {
+                        DoMergeFrom<T>(other.unknown_fields<T>(nullptr));
+                    }
+                }
+
+                template<typename T>
+                PROTOBUF_NDEBUG_INLINE void Clear()
+                {
+                    if (have_unknown_fields())
+                    {
+                        DoClear<T>();
+                    }
+                }
+
+            private:
+                intptr_t ptr_;
+
+                // Tagged pointer implementation.
+                static constexpr intptr_t kUnknownFieldsTagMask = 1;
+                static constexpr intptr_t kMessageOwnedArenaTagMask = 2;
+                static constexpr intptr_t kPtrTagMask =
+                    kUnknownFieldsTagMask | kMessageOwnedArenaTagMask;
+                static constexpr intptr_t kPtrValueMask = ~kPtrTagMask;
+
+                // Accessors for pointer tag and pointer value.
+                PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const
+                {
+                    return ptr_ & kUnknownFieldsTagMask;
+                }
+                PROTOBUF_ALWAYS_INLINE bool HasMessageOwnedArenaTag() const
+                {
+                    return ptr_ & kMessageOwnedArenaTagMask;
+                }
+
+                template<typename U>
+                U* PtrValue() const
+                {
+                    return reinterpret_cast<U*>(ptr_ & kPtrValueMask);
+                }
+
+                // If ptr_'s tag is kTagContainer, it points to an instance of this struct.
+                struct ContainerBase
+                {
+                    Arena* arena;
+                };
+
+                template<typename T>
+                struct Container : public ContainerBase
+                {
+                    T unknown_fields;
+                };
+
+                template<typename T>
+                PROTOBUF_NOINLINE Arena* DeleteOutOfLineHelper()
+                {
+                    if (auto* a = arena())
+                    {
+                        // Subtle: we want to preserve the message-owned arena flag, while at the
+                        // same time replacing the pointer to Container<T> with a pointer to the
+                        // arena.
+                        intptr_t message_owned_arena_tag = ptr_ & kMessageOwnedArenaTagMask;
+                        ptr_ = reinterpret_cast<intptr_t>(a) | message_owned_arena_tag;
+                        return a;
+                    }
+                    else
+                    {
+                        delete PtrValue<Container<T>>();
+                        ptr_ = 0;
+                        return nullptr;
+                    }
+                }
+
+                template<typename T>
+                PROTOBUF_NOINLINE T* mutable_unknown_fields_slow()
+                {
+                    Arena* my_arena = arena();
+                    Container<T>* container = Arena::Create<Container<T>>(my_arena);
+                    intptr_t message_owned_arena_tag = ptr_ & kMessageOwnedArenaTagMask;
+                    // Two-step assignment works around a bug in clang's static analyzer:
+                    // https://bugs.llvm.org/show_bug.cgi?id=34198.
+                    ptr_ = reinterpret_cast<intptr_t>(container);
+                    ptr_ |= kUnknownFieldsTagMask | message_owned_arena_tag;
+                    container->arena = my_arena;
+                    return &(container->unknown_fields);
+                }
+
+                // Templated functions.
+
+                template<typename T>
+                PROTOBUF_NOINLINE void DoClear()
+                {
+                    mutable_unknown_fields<T>()->Clear();
+                }
+
+                template<typename T>
+                PROTOBUF_NOINLINE void DoMergeFrom(const T& other)
+                {
+                    mutable_unknown_fields<T>()->MergeFrom(other);
+                }
+
+                template<typename T>
+                PROTOBUF_NOINLINE void DoSwap(T* other)
+                {
+                    mutable_unknown_fields<T>()->Swap(other);
+                }
+
+                // Private helper with debug checks for ~InternalMetadata()
+                void CheckedDestruct();
+            };
+
+            // String Template specializations.
+
+            template<>
+            PROTOBUF_EXPORT void InternalMetadata::DoClear<std::string>();
+            template<>
+            PROTOBUF_EXPORT void InternalMetadata::DoMergeFrom<std::string>(
+                const std::string& other
+            );
+            template<>
+            PROTOBUF_EXPORT void InternalMetadata::DoSwap<std::string>(std::string* other);
+
+            // This helper RAII class is needed to efficiently parse unknown fields. We
+            // should only call mutable_unknown_fields if there are actual unknown fields.
+            // The obvious thing to just use a stack string and swap it at the end of
+            // the parse won't work, because the destructor of StringOutputStream needs to
+            // be called before we can modify the string (it check-fails). Using
+            // LiteUnknownFieldSetter setter(&_internal_metadata_);
+            // StringOutputStream stream(setter.buffer());
+            // guarantees that the string is only swapped after stream is destroyed.
+            class PROTOBUF_EXPORT LiteUnknownFieldSetter
+            {
+            public:
+                explicit LiteUnknownFieldSetter(InternalMetadata* metadata) :
+                    metadata_(metadata)
+                {
+                    if (metadata->have_unknown_fields())
+                    {
+                        buffer_.swap(*metadata->mutable_unknown_fields<std::string>());
+                    }
+                }
+                ~LiteUnknownFieldSetter()
+                {
+                    if (!buffer_.empty())
+                        metadata_->mutable_unknown_fields<std::string>()->swap(buffer_);
+                }
+                std::string* buffer()
+                {
+                    return &buffer_;
+                }
+
+            private:
+                InternalMetadata* metadata_;
+                std::string buffer_;
+            };
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/parse_context.h b/CAPI/cpp/grpc/include/google/protobuf/parse_context.h
index 7aea50c..e49e019 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/parse_context.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/parse_context.h
@@ -52,972 +52,1146 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-
-namespace google {
-namespace protobuf {
-
-class UnknownFieldSet;
-class DescriptorPool;
-class MessageFactory;
-
-namespace internal {
-
-// Template code below needs to know about the existence of these functions.
-PROTOBUF_EXPORT void WriteVarint(uint32_t num, uint64_t val, std::string* s);
-PROTOBUF_EXPORT void WriteLengthDelimited(uint32_t num, StringPiece val,
-                                          std::string* s);
-// Inline because it is just forwarding to s->WriteVarint
-inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* s);
-inline void WriteLengthDelimited(uint32_t num, StringPiece val,
-                                 UnknownFieldSet* s);
-
-
-// The basic abstraction the parser is designed for is a slight modification
-// of the ZeroCopyInputStream (ZCIS) abstraction. A ZCIS presents a serialized
-// stream as a series of buffers that concatenate to the full stream.
-// Pictorially a ZCIS presents a stream in chunks like so
-// [---------------------------------------------------------------]
-// [---------------------] chunk 1
-//                      [----------------------------] chunk 2
-//                                          chunk 3 [--------------]
-//
-// Where the '-' represent the bytes which are vertically lined up with the
-// bytes of the stream. The proto parser requires its input to be presented
-// similarly with the extra
-// property that each chunk has kSlopBytes past its end that overlaps with the
-// first kSlopBytes of the next chunk, or if there is no next chunk at least its
-// still valid to read those bytes. Again, pictorially, we now have
-//
-// [---------------------------------------------------------------]
-// [-------------------....] chunk 1
-//                    [------------------------....] chunk 2
-//                                    chunk 3 [------------------..**]
-//                                                      chunk 4 [--****]
-// Here '-' mean the bytes of the stream or chunk and '.' means bytes past the
-// chunk that match up with the start of the next chunk. Above each chunk has
-// 4 '.' after the chunk. In the case these 'overflow' bytes represents bytes
-// past the stream, indicated by '*' above, their values are unspecified. It is
-// still legal to read them (ie. should not segfault). Reading past the
-// end should be detected by the user and indicated as an error.
-//
-// The reason for this, admittedly, unconventional invariant is to ruthlessly
-// optimize the protobuf parser. Having an overlap helps in two important ways.
-// Firstly it alleviates having to performing bounds checks if a piece of code
-// is guaranteed to not read more than kSlopBytes. Secondly, and more
-// importantly, the protobuf wireformat is such that reading a key/value pair is
-// always less than 16 bytes. This removes the need to change to next buffer in
-// the middle of reading primitive values. Hence there is no need to store and
-// load the current position.
-
-class PROTOBUF_EXPORT EpsCopyInputStream {
- public:
-  enum { kSlopBytes = 16, kMaxCordBytesToCopy = 512 };
-
-  explicit EpsCopyInputStream(bool enable_aliasing)
-      : aliasing_(enable_aliasing ? kOnPatch : kNoAliasing) {}
-
-  void BackUp(const char* ptr) {
-    GOOGLE_DCHECK(ptr <= buffer_end_ + kSlopBytes);
-    int count;
-    if (next_chunk_ == buffer_) {
-      count = static_cast<int>(buffer_end_ + kSlopBytes - ptr);
-    } else {
-      count = size_ + static_cast<int>(buffer_end_ - ptr);
-    }
-    if (count > 0) StreamBackUp(count);
-  }
-
-  // If return value is negative it's an error
-  PROTOBUF_NODISCARD int PushLimit(const char* ptr, int limit) {
-    GOOGLE_DCHECK(limit >= 0 && limit <= INT_MAX - kSlopBytes);
-    // This add is safe due to the invariant above, because
-    // ptr - buffer_end_ <= kSlopBytes.
-    limit += static_cast<int>(ptr - buffer_end_);
-    limit_end_ = buffer_end_ + (std::min)(0, limit);
-    auto old_limit = limit_;
-    limit_ = limit;
-    return old_limit - limit;
-  }
-
-  PROTOBUF_NODISCARD bool PopLimit(int delta) {
-    if (PROTOBUF_PREDICT_FALSE(!EndedAtLimit())) return false;
-    limit_ = limit_ + delta;
-    // TODO(gerbens) We could remove this line and hoist the code to
-    // DoneFallback. Study the perf/bin-size effects.
-    limit_end_ = buffer_end_ + (std::min)(0, limit_);
-    return true;
-  }
-
-  PROTOBUF_NODISCARD const char* Skip(const char* ptr, int size) {
-    if (size <= buffer_end_ + kSlopBytes - ptr) {
-      return ptr + size;
-    }
-    return SkipFallback(ptr, size);
-  }
-  PROTOBUF_NODISCARD const char* ReadString(const char* ptr, int size,
-                                            std::string* s) {
-    if (size <= buffer_end_ + kSlopBytes - ptr) {
-      s->assign(ptr, size);
-      return ptr + size;
-    }
-    return ReadStringFallback(ptr, size, s);
-  }
-  PROTOBUF_NODISCARD const char* AppendString(const char* ptr, int size,
-                                              std::string* s) {
-    if (size <= buffer_end_ + kSlopBytes - ptr) {
-      s->append(ptr, size);
-      return ptr + size;
-    }
-    return AppendStringFallback(ptr, size, s);
-  }
-  // Implemented in arenastring.cc
-  PROTOBUF_NODISCARD const char* ReadArenaString(const char* ptr,
-                                                 ArenaStringPtr* s,
-                                                 Arena* arena);
-
-  template <typename Tag, typename T>
-  PROTOBUF_NODISCARD const char* ReadRepeatedFixed(const char* ptr,
-                                                   Tag expected_tag,
-                                                   RepeatedField<T>* out);
-
-  template <typename T>
-  PROTOBUF_NODISCARD const char* ReadPackedFixed(const char* ptr, int size,
-                                                 RepeatedField<T>* out);
-  template <typename Add>
-  PROTOBUF_NODISCARD const char* ReadPackedVarint(const char* ptr, Add add);
-
-  uint32_t LastTag() const { return last_tag_minus_1_ + 1; }
-  bool ConsumeEndGroup(uint32_t start_tag) {
-    bool res = last_tag_minus_1_ == start_tag;
-    last_tag_minus_1_ = 0;
-    return res;
-  }
-  bool EndedAtLimit() const { return last_tag_minus_1_ == 0; }
-  bool EndedAtEndOfStream() const { return last_tag_minus_1_ == 1; }
-  void SetLastTag(uint32_t tag) { last_tag_minus_1_ = tag - 1; }
-  void SetEndOfStream() { last_tag_minus_1_ = 1; }
-  bool IsExceedingLimit(const char* ptr) {
-    return ptr > limit_end_ &&
-           (next_chunk_ == nullptr || ptr - buffer_end_ > limit_);
-  }
-  bool AliasingEnabled() const { return aliasing_ != kNoAliasing; }
-  int BytesUntilLimit(const char* ptr) const {
-    return limit_ + static_cast<int>(buffer_end_ - ptr);
-  }
-  // Returns true if more data is available, if false is returned one has to
-  // call Done for further checks.
-  bool DataAvailable(const char* ptr) { return ptr < limit_end_; }
-
- protected:
-  // Returns true is limit (either an explicit limit or end of stream) is
-  // reached. It aligns *ptr across buffer seams.
-  // If limit is exceeded it returns true and ptr is set to null.
-  bool DoneWithCheck(const char** ptr, int d) {
-    GOOGLE_DCHECK(*ptr);
-    if (PROTOBUF_PREDICT_TRUE(*ptr < limit_end_)) return false;
-    int overrun = static_cast<int>(*ptr - buffer_end_);
-    GOOGLE_DCHECK_LE(overrun, kSlopBytes);  // Guaranteed by parse loop.
-    if (overrun ==
-        limit_) {  //  No need to flip buffers if we ended on a limit.
-      // If we actually overrun the buffer and next_chunk_ is null. It means
-      // the stream ended and we passed the stream end.
-      if (overrun > 0 && next_chunk_ == nullptr) *ptr = nullptr;
-      return true;
-    }
-    auto res = DoneFallback(overrun, d);
-    *ptr = res.first;
-    return res.second;
-  }
-
-  const char* InitFrom(StringPiece flat) {
-    overall_limit_ = 0;
-    if (flat.size() > kSlopBytes) {
-      limit_ = kSlopBytes;
-      limit_end_ = buffer_end_ = flat.data() + flat.size() - kSlopBytes;
-      next_chunk_ = buffer_;
-      if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
-      return flat.data();
-    } else {
-      std::memcpy(buffer_, flat.data(), flat.size());
-      limit_ = 0;
-      limit_end_ = buffer_end_ = buffer_ + flat.size();
-      next_chunk_ = nullptr;
-      if (aliasing_ == kOnPatch) {
-        aliasing_ = reinterpret_cast<std::uintptr_t>(flat.data()) -
-                    reinterpret_cast<std::uintptr_t>(buffer_);
-      }
-      return buffer_;
-    }
-  }
-
-  const char* InitFrom(io::ZeroCopyInputStream* zcis);
-
-  const char* InitFrom(io::ZeroCopyInputStream* zcis, int limit) {
-    if (limit == -1) return InitFrom(zcis);
-    overall_limit_ = limit;
-    auto res = InitFrom(zcis);
-    limit_ = limit - static_cast<int>(buffer_end_ - res);
-    limit_end_ = buffer_end_ + (std::min)(0, limit_);
-    return res;
-  }
-
- private:
-  const char* limit_end_;  // buffer_end_ + min(limit_, 0)
-  const char* buffer_end_;
-  const char* next_chunk_;
-  int size_;
-  int limit_;  // relative to buffer_end_;
-  io::ZeroCopyInputStream* zcis_ = nullptr;
-  char buffer_[2 * kSlopBytes] = {};
-  enum { kNoAliasing = 0, kOnPatch = 1, kNoDelta = 2 };
-  std::uintptr_t aliasing_ = kNoAliasing;
-  // This variable is used to communicate how the parse ended, in order to
-  // completely verify the parsed data. A wire-format parse can end because of
-  // one of the following conditions:
-  // 1) A parse can end on a pushed limit.
-  // 2) A parse can end on End Of Stream (EOS).
-  // 3) A parse can end on 0 tag (only valid for toplevel message).
-  // 4) A parse can end on an end-group tag.
-  // This variable should always be set to 0, which indicates case 1. If the
-  // parse terminated due to EOS (case 2), it's set to 1. In case the parse
-  // ended due to a terminating tag (case 3 and 4) it's set to (tag - 1).
-  // This var doesn't really belong in EpsCopyInputStream and should be part of
-  // the ParseContext, but case 2 is most easily and optimally implemented in
-  // DoneFallback.
-  uint32_t last_tag_minus_1_ = 0;
-  int overall_limit_ = INT_MAX;  // Overall limit independent of pushed limits.
-  // Pretty random large number that seems like a safe allocation on most
-  // systems. TODO(gerbens) do we need to set this as build flag?
-  enum { kSafeStringSize = 50000000 };
-
-  // Advances to next buffer chunk returns a pointer to the same logical place
-  // in the stream as set by overrun. Overrun indicates the position in the slop
-  // region the parse was left (0 <= overrun <= kSlopBytes). Returns true if at
-  // limit, at which point the returned pointer maybe null if there was an
-  // error. The invariant of this function is that it's guaranteed that
-  // kSlopBytes bytes can be accessed from the returned ptr. This function might
-  // advance more buffers than one in the underlying ZeroCopyInputStream.
-  std::pair<const char*, bool> DoneFallback(int overrun, int depth);
-  // Advances to the next buffer, at most one call to Next() on the underlying
-  // ZeroCopyInputStream is made. This function DOES NOT match the returned
-  // pointer to where in the slop region the parse ends, hence no overrun
-  // parameter. This is useful for string operations where you always copy
-  // to the end of the buffer (including the slop region).
-  const char* Next();
-  // overrun is the location in the slop region the stream currently is
-  // (0 <= overrun <= kSlopBytes). To prevent flipping to the next buffer of
-  // the ZeroCopyInputStream in the case the parse will end in the last
-  // kSlopBytes of the current buffer. depth is the current depth of nested
-  // groups (or negative if the use case does not need careful tracking).
-  inline const char* NextBuffer(int overrun, int depth);
-  const char* SkipFallback(const char* ptr, int size);
-  const char* AppendStringFallback(const char* ptr, int size, std::string* str);
-  const char* ReadStringFallback(const char* ptr, int size, std::string* str);
-  bool StreamNext(const void** data) {
-    bool res = zcis_->Next(data, &size_);
-    if (res) overall_limit_ -= size_;
-    return res;
-  }
-  void StreamBackUp(int count) {
-    zcis_->BackUp(count);
-    overall_limit_ += count;
-  }
-
-  template <typename A>
-  const char* AppendSize(const char* ptr, int size, const A& append) {
-    int chunk_size = buffer_end_ + kSlopBytes - ptr;
-    do {
-      GOOGLE_DCHECK(size > chunk_size);
-      if (next_chunk_ == nullptr) return nullptr;
-      append(ptr, chunk_size);
-      ptr += chunk_size;
-      size -= chunk_size;
-      // TODO(gerbens) Next calls NextBuffer which generates buffers with
-      // overlap and thus incurs cost of copying the slop regions. This is not
-      // necessary for reading strings. We should just call Next buffers.
-      if (limit_ <= kSlopBytes) return nullptr;
-      ptr = Next();
-      if (ptr == nullptr) return nullptr;  // passed the limit
-      ptr += kSlopBytes;
-      chunk_size = buffer_end_ + kSlopBytes - ptr;
-    } while (size > chunk_size);
-    append(ptr, size);
-    return ptr + size;
-  }
-
-  // AppendUntilEnd appends data until a limit (either a PushLimit or end of
-  // stream. Normal payloads are from length delimited fields which have an
-  // explicit size. Reading until limit only comes when the string takes
-  // the place of a protobuf, ie RawMessage/StringRawMessage, lazy fields and
-  // implicit weak messages. We keep these methods private and friend them.
-  template <typename A>
-  const char* AppendUntilEnd(const char* ptr, const A& append) {
-    if (ptr - buffer_end_ > limit_) return nullptr;
-    while (limit_ > kSlopBytes) {
-      size_t chunk_size = buffer_end_ + kSlopBytes - ptr;
-      append(ptr, chunk_size);
-      ptr = Next();
-      if (ptr == nullptr) return limit_end_;
-      ptr += kSlopBytes;
-    }
-    auto end = buffer_end_ + limit_;
-    GOOGLE_DCHECK(end >= ptr);
-    append(ptr, end - ptr);
-    return end;
-  }
-
-  PROTOBUF_NODISCARD const char* AppendString(const char* ptr,
-                                              std::string* str) {
-    return AppendUntilEnd(
-        ptr, [str](const char* p, ptrdiff_t s) { str->append(p, s); });
-  }
-  friend class ImplicitWeakMessage;
-};
-
-using LazyEagerVerifyFnType = const char* (*)(const char* ptr,
-                                              ParseContext* ctx);
-using LazyEagerVerifyFnRef = std::remove_pointer<LazyEagerVerifyFnType>::type&;
-
-// ParseContext holds all data that is global to the entire parse. Most
-// importantly it contains the input stream, but also recursion depth and also
-// stores the end group tag, in case a parser ended on a endgroup, to verify
-// matching start/end group tags.
-class PROTOBUF_EXPORT ParseContext : public EpsCopyInputStream {
- public:
-  struct Data {
-    const DescriptorPool* pool = nullptr;
-    MessageFactory* factory = nullptr;
-    Arena* arena = nullptr;
-  };
-
-  template <typename... T>
-  ParseContext(int depth, bool aliasing, const char** start, T&&... args)
-      : EpsCopyInputStream(aliasing), depth_(depth) {
-    *start = InitFrom(std::forward<T>(args)...);
-  }
-
-  void TrackCorrectEnding() { group_depth_ = 0; }
-
-  bool Done(const char** ptr) { return DoneWithCheck(ptr, group_depth_); }
-
-  int depth() const { return depth_; }
-
-  Data& data() { return data_; }
-  const Data& data() const { return data_; }
-
-  const char* ParseMessage(MessageLite* msg, const char* ptr);
-
-  // Spawns a child parsing context that inherits key properties. New context
-  // inherits the following:
-  // --depth_, data_, check_required_fields_, lazy_parse_mode_
-  // The spawned context always disables aliasing (different input).
-  template <typename... T>
-  ParseContext Spawn(const char** start, T&&... args) {
-    ParseContext spawned(depth_, false, start, std::forward<T>(args)...);
-    // Transfer key context states.
-    spawned.data_ = data_;
-    return spawned;
-  }
-
-  // This overload supports those few cases where ParseMessage is called
-  // on a class that is not actually a proto message.
-  // TODO(jorg): Eliminate this use case.
-  template <typename T,
-            typename std::enable_if<!std::is_base_of<MessageLite, T>::value,
-                                    bool>::type = true>
-  PROTOBUF_NODISCARD const char* ParseMessage(T* msg, const char* ptr);
-
-  template <typename T>
-  PROTOBUF_NODISCARD PROTOBUF_NDEBUG_INLINE const char* ParseGroup(
-      T* msg, const char* ptr, uint32_t tag) {
-    if (--depth_ < 0) return nullptr;
-    group_depth_++;
-    ptr = msg->_InternalParse(ptr, this);
-    group_depth_--;
-    depth_++;
-    if (PROTOBUF_PREDICT_FALSE(!ConsumeEndGroup(tag))) return nullptr;
-    return ptr;
-  }
-
- private:
-  // Out-of-line routine to save space in ParseContext::ParseMessage<T>
-  //   int old;
-  //   ptr = ReadSizeAndPushLimitAndDepth(ptr, &old)
-  // is equivalent to:
-  //   int size = ReadSize(&ptr);
-  //   if (!ptr) return nullptr;
-  //   int old = PushLimit(ptr, size);
-  //   if (--depth_ < 0) return nullptr;
-  PROTOBUF_NODISCARD const char* ReadSizeAndPushLimitAndDepth(const char* ptr,
-                                                              int* old_limit);
-
-  // The context keeps an internal stack to keep track of the recursive
-  // part of the parse state.
-  // Current depth of the active parser, depth counts down.
-  // This is used to limit recursion depth (to prevent overflow on malicious
-  // data), but is also used to index in stack_ to store the current state.
-  int depth_;
-  // Unfortunately necessary for the fringe case of ending on 0 or end-group tag
-  // in the last kSlopBytes of a ZeroCopyInputStream chunk.
-  int group_depth_ = INT_MIN;
-  Data data_;
-};
-
-template <uint32_t tag>
-bool ExpectTag(const char* ptr) {
-  if (tag < 128) {
-    return *ptr == static_cast<char>(tag);
-  } else {
-    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
-    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
-    return std::memcmp(ptr, buf, 2) == 0;
-  }
-}
-
-template <int>
-struct EndianHelper;
-
-template <>
-struct EndianHelper<1> {
-  static uint8_t Load(const void* p) { return *static_cast<const uint8_t*>(p); }
-};
-
-template <>
-struct EndianHelper<2> {
-  static uint16_t Load(const void* p) {
-    uint16_t tmp;
-    std::memcpy(&tmp, p, 2);
-    return little_endian::ToHost(tmp);
-  }
-};
-
-template <>
-struct EndianHelper<4> {
-  static uint32_t Load(const void* p) {
-    uint32_t tmp;
-    std::memcpy(&tmp, p, 4);
-    return little_endian::ToHost(tmp);
-  }
-};
-
-template <>
-struct EndianHelper<8> {
-  static uint64_t Load(const void* p) {
-    uint64_t tmp;
-    std::memcpy(&tmp, p, 8);
-    return little_endian::ToHost(tmp);
-  }
-};
-
-template <typename T>
-T UnalignedLoad(const char* p) {
-  auto tmp = EndianHelper<sizeof(T)>::Load(p);
-  T res;
-  memcpy(&res, &tmp, sizeof(T));
-  return res;
-}
-
-PROTOBUF_EXPORT
-std::pair<const char*, uint32_t> VarintParseSlow32(const char* p, uint32_t res);
-PROTOBUF_EXPORT
-std::pair<const char*, uint64_t> VarintParseSlow64(const char* p, uint32_t res);
-
-inline const char* VarintParseSlow(const char* p, uint32_t res, uint32_t* out) {
-  auto tmp = VarintParseSlow32(p, res);
-  *out = tmp.second;
-  return tmp.first;
-}
-
-inline const char* VarintParseSlow(const char* p, uint32_t res, uint64_t* out) {
-  auto tmp = VarintParseSlow64(p, res);
-  *out = tmp.second;
-  return tmp.first;
-}
-
-template <typename T>
-PROTOBUF_NODISCARD const char* VarintParse(const char* p, T* out) {
-  auto ptr = reinterpret_cast<const uint8_t*>(p);
-  uint32_t res = ptr[0];
-  if (!(res & 0x80)) {
-    *out = res;
-    return p + 1;
-  }
-  uint32_t byte = ptr[1];
-  res += (byte - 1) << 7;
-  if (!(byte & 0x80)) {
-    *out = res;
-    return p + 2;
-  }
-  return VarintParseSlow(p, res, out);
-}
-
-// Used for tags, could read up to 5 bytes which must be available.
-// Caller must ensure its safe to call.
-
-PROTOBUF_EXPORT
-std::pair<const char*, uint32_t> ReadTagFallback(const char* p, uint32_t res);
-
-// Same as ParseVarint but only accept 5 bytes at most.
-inline const char* ReadTag(const char* p, uint32_t* out,
-                           uint32_t /*max_tag*/ = 0) {
-  uint32_t res = static_cast<uint8_t>(p[0]);
-  if (res < 128) {
-    *out = res;
-    return p + 1;
-  }
-  uint32_t second = static_cast<uint8_t>(p[1]);
-  res += (second - 1) << 7;
-  if (second < 128) {
-    *out = res;
-    return p + 2;
-  }
-  auto tmp = ReadTagFallback(p, res);
-  *out = tmp.second;
-  return tmp.first;
-}
-
-// As above, but optimized to consume very few registers while still being fast,
-// ReadTagInlined is useful for callers that don't mind the extra code but would
-// like to avoid an extern function call causing spills into the stack.
-//
-// Two support routines for ReadTagInlined come first...
-template <class T>
-PROTOBUF_NODISCARD PROTOBUF_ALWAYS_INLINE constexpr T RotateLeft(
-    T x, int s) noexcept {
-  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
-}
-
-PROTOBUF_NODISCARD inline PROTOBUF_ALWAYS_INLINE uint64_t
-RotRight7AndReplaceLowByte(uint64_t res, const char& byte) {
+namespace google
+{
+    namespace protobuf
+    {
+
+        class UnknownFieldSet;
+        class DescriptorPool;
+        class MessageFactory;
+
+        namespace internal
+        {
+
+            // Template code below needs to know about the existence of these functions.
+            PROTOBUF_EXPORT void WriteVarint(uint32_t num, uint64_t val, std::string* s);
+            PROTOBUF_EXPORT void WriteLengthDelimited(uint32_t num, StringPiece val, std::string* s);
+            // Inline because it is just forwarding to s->WriteVarint
+            inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* s);
+            inline void WriteLengthDelimited(uint32_t num, StringPiece val, UnknownFieldSet* s);
+
+            // The basic abstraction the parser is designed for is a slight modification
+            // of the ZeroCopyInputStream (ZCIS) abstraction. A ZCIS presents a serialized
+            // stream as a series of buffers that concatenate to the full stream.
+            // Pictorially a ZCIS presents a stream in chunks like so
+            // [---------------------------------------------------------------]
+            // [---------------------] chunk 1
+            //                      [----------------------------] chunk 2
+            //                                          chunk 3 [--------------]
+            //
+            // Where the '-' represent the bytes which are vertically lined up with the
+            // bytes of the stream. The proto parser requires its input to be presented
+            // similarly with the extra
+            // property that each chunk has kSlopBytes past its end that overlaps with the
+            // first kSlopBytes of the next chunk, or if there is no next chunk at least its
+            // still valid to read those bytes. Again, pictorially, we now have
+            //
+            // [---------------------------------------------------------------]
+            // [-------------------....] chunk 1
+            //                    [------------------------....] chunk 2
+            //                                    chunk 3 [------------------..**]
+            //                                                      chunk 4 [--****]
+            // Here '-' mean the bytes of the stream or chunk and '.' means bytes past the
+            // chunk that match up with the start of the next chunk. Above each chunk has
+            // 4 '.' after the chunk. In the case these 'overflow' bytes represents bytes
+            // past the stream, indicated by '*' above, their values are unspecified. It is
+            // still legal to read them (ie. should not segfault). Reading past the
+            // end should be detected by the user and indicated as an error.
+            //
+            // The reason for this, admittedly, unconventional invariant is to ruthlessly
+            // optimize the protobuf parser. Having an overlap helps in two important ways.
+            // Firstly it alleviates having to performing bounds checks if a piece of code
+            // is guaranteed to not read more than kSlopBytes. Secondly, and more
+            // importantly, the protobuf wireformat is such that reading a key/value pair is
+            // always less than 16 bytes. This removes the need to change to next buffer in
+            // the middle of reading primitive values. Hence there is no need to store and
+            // load the current position.
+
+            class PROTOBUF_EXPORT EpsCopyInputStream
+            {
+            public:
+                enum
+                {
+                    kSlopBytes = 16,
+                    kMaxCordBytesToCopy = 512
+                };
+
+                explicit EpsCopyInputStream(bool enable_aliasing) :
+                    aliasing_(enable_aliasing ? kOnPatch : kNoAliasing)
+                {
+                }
+
+                void BackUp(const char* ptr)
+                {
+                    GOOGLE_DCHECK(ptr <= buffer_end_ + kSlopBytes);
+                    int count;
+                    if (next_chunk_ == buffer_)
+                    {
+                        count = static_cast<int>(buffer_end_ + kSlopBytes - ptr);
+                    }
+                    else
+                    {
+                        count = size_ + static_cast<int>(buffer_end_ - ptr);
+                    }
+                    if (count > 0)
+                        StreamBackUp(count);
+                }
+
+                // If return value is negative it's an error
+                PROTOBUF_NODISCARD int PushLimit(const char* ptr, int limit)
+                {
+                    GOOGLE_DCHECK(limit >= 0 && limit <= INT_MAX - kSlopBytes);
+                    // This add is safe due to the invariant above, because
+                    // ptr - buffer_end_ <= kSlopBytes.
+                    limit += static_cast<int>(ptr - buffer_end_);
+                    limit_end_ = buffer_end_ + (std::min)(0, limit);
+                    auto old_limit = limit_;
+                    limit_ = limit;
+                    return old_limit - limit;
+                }
+
+                PROTOBUF_NODISCARD bool PopLimit(int delta)
+                {
+                    if (PROTOBUF_PREDICT_FALSE(!EndedAtLimit()))
+                        return false;
+                    limit_ = limit_ + delta;
+                    // TODO(gerbens) We could remove this line and hoist the code to
+                    // DoneFallback. Study the perf/bin-size effects.
+                    limit_end_ = buffer_end_ + (std::min)(0, limit_);
+                    return true;
+                }
+
+                PROTOBUF_NODISCARD const char* Skip(const char* ptr, int size)
+                {
+                    if (size <= buffer_end_ + kSlopBytes - ptr)
+                    {
+                        return ptr + size;
+                    }
+                    return SkipFallback(ptr, size);
+                }
+                PROTOBUF_NODISCARD const char* ReadString(const char* ptr, int size, std::string* s)
+                {
+                    if (size <= buffer_end_ + kSlopBytes - ptr)
+                    {
+                        s->assign(ptr, size);
+                        return ptr + size;
+                    }
+                    return ReadStringFallback(ptr, size, s);
+                }
+                PROTOBUF_NODISCARD const char* AppendString(const char* ptr, int size, std::string* s)
+                {
+                    if (size <= buffer_end_ + kSlopBytes - ptr)
+                    {
+                        s->append(ptr, size);
+                        return ptr + size;
+                    }
+                    return AppendStringFallback(ptr, size, s);
+                }
+                // Implemented in arenastring.cc
+                PROTOBUF_NODISCARD const char* ReadArenaString(const char* ptr, ArenaStringPtr* s, Arena* arena);
+
+                template<typename Tag, typename T>
+                PROTOBUF_NODISCARD const char* ReadRepeatedFixed(const char* ptr, Tag expected_tag, RepeatedField<T>* out);
+
+                template<typename T>
+                PROTOBUF_NODISCARD const char* ReadPackedFixed(const char* ptr, int size, RepeatedField<T>* out);
+                template<typename Add>
+                PROTOBUF_NODISCARD const char* ReadPackedVarint(const char* ptr, Add add);
+
+                uint32_t LastTag() const
+                {
+                    return last_tag_minus_1_ + 1;
+                }
+                bool ConsumeEndGroup(uint32_t start_tag)
+                {
+                    bool res = last_tag_minus_1_ == start_tag;
+                    last_tag_minus_1_ = 0;
+                    return res;
+                }
+                bool EndedAtLimit() const
+                {
+                    return last_tag_minus_1_ == 0;
+                }
+                bool EndedAtEndOfStream() const
+                {
+                    return last_tag_minus_1_ == 1;
+                }
+                void SetLastTag(uint32_t tag)
+                {
+                    last_tag_minus_1_ = tag - 1;
+                }
+                void SetEndOfStream()
+                {
+                    last_tag_minus_1_ = 1;
+                }
+                bool IsExceedingLimit(const char* ptr)
+                {
+                    return ptr > limit_end_ &&
+                           (next_chunk_ == nullptr || ptr - buffer_end_ > limit_);
+                }
+                bool AliasingEnabled() const
+                {
+                    return aliasing_ != kNoAliasing;
+                }
+                int BytesUntilLimit(const char* ptr) const
+                {
+                    return limit_ + static_cast<int>(buffer_end_ - ptr);
+                }
+                // Returns true if more data is available, if false is returned one has to
+                // call Done for further checks.
+                bool DataAvailable(const char* ptr)
+                {
+                    return ptr < limit_end_;
+                }
+
+            protected:
+                // Returns true is limit (either an explicit limit or end of stream) is
+                // reached. It aligns *ptr across buffer seams.
+                // If limit is exceeded it returns true and ptr is set to null.
+                bool DoneWithCheck(const char** ptr, int d)
+                {
+                    GOOGLE_DCHECK(*ptr);
+                    if (PROTOBUF_PREDICT_TRUE(*ptr < limit_end_))
+                        return false;
+                    int overrun = static_cast<int>(*ptr - buffer_end_);
+                    GOOGLE_DCHECK_LE(overrun, kSlopBytes);  // Guaranteed by parse loop.
+                    if (overrun ==
+                        limit_)
+                    {  //  No need to flip buffers if we ended on a limit.
+                        // If we actually overrun the buffer and next_chunk_ is null. It means
+                        // the stream ended and we passed the stream end.
+                        if (overrun > 0 && next_chunk_ == nullptr)
+                            *ptr = nullptr;
+                        return true;
+                    }
+                    auto res = DoneFallback(overrun, d);
+                    *ptr = res.first;
+                    return res.second;
+                }
+
+                const char* InitFrom(StringPiece flat)
+                {
+                    overall_limit_ = 0;
+                    if (flat.size() > kSlopBytes)
+                    {
+                        limit_ = kSlopBytes;
+                        limit_end_ = buffer_end_ = flat.data() + flat.size() - kSlopBytes;
+                        next_chunk_ = buffer_;
+                        if (aliasing_ == kOnPatch)
+                            aliasing_ = kNoDelta;
+                        return flat.data();
+                    }
+                    else
+                    {
+                        std::memcpy(buffer_, flat.data(), flat.size());
+                        limit_ = 0;
+                        limit_end_ = buffer_end_ = buffer_ + flat.size();
+                        next_chunk_ = nullptr;
+                        if (aliasing_ == kOnPatch)
+                        {
+                            aliasing_ = reinterpret_cast<std::uintptr_t>(flat.data()) -
+                                        reinterpret_cast<std::uintptr_t>(buffer_);
+                        }
+                        return buffer_;
+                    }
+                }
+
+                const char* InitFrom(io::ZeroCopyInputStream* zcis);
+
+                const char* InitFrom(io::ZeroCopyInputStream* zcis, int limit)
+                {
+                    if (limit == -1)
+                        return InitFrom(zcis);
+                    overall_limit_ = limit;
+                    auto res = InitFrom(zcis);
+                    limit_ = limit - static_cast<int>(buffer_end_ - res);
+                    limit_end_ = buffer_end_ + (std::min)(0, limit_);
+                    return res;
+                }
+
+            private:
+                const char* limit_end_;  // buffer_end_ + min(limit_, 0)
+                const char* buffer_end_;
+                const char* next_chunk_;
+                int size_;
+                int limit_;  // relative to buffer_end_;
+                io::ZeroCopyInputStream* zcis_ = nullptr;
+                char buffer_[2 * kSlopBytes] = {};
+                enum
+                {
+                    kNoAliasing = 0,
+                    kOnPatch = 1,
+                    kNoDelta = 2
+                };
+                std::uintptr_t aliasing_ = kNoAliasing;
+                // This variable is used to communicate how the parse ended, in order to
+                // completely verify the parsed data. A wire-format parse can end because of
+                // one of the following conditions:
+                // 1) A parse can end on a pushed limit.
+                // 2) A parse can end on End Of Stream (EOS).
+                // 3) A parse can end on 0 tag (only valid for toplevel message).
+                // 4) A parse can end on an end-group tag.
+                // This variable should always be set to 0, which indicates case 1. If the
+                // parse terminated due to EOS (case 2), it's set to 1. In case the parse
+                // ended due to a terminating tag (case 3 and 4) it's set to (tag - 1).
+                // This var doesn't really belong in EpsCopyInputStream and should be part of
+                // the ParseContext, but case 2 is most easily and optimally implemented in
+                // DoneFallback.
+                uint32_t last_tag_minus_1_ = 0;
+                int overall_limit_ = INT_MAX;  // Overall limit independent of pushed limits.
+                // Pretty random large number that seems like a safe allocation on most
+                // systems. TODO(gerbens) do we need to set this as build flag?
+                enum
+                {
+                    kSafeStringSize = 50000000
+                };
+
+                // Advances to next buffer chunk returns a pointer to the same logical place
+                // in the stream as set by overrun. Overrun indicates the position in the slop
+                // region the parse was left (0 <= overrun <= kSlopBytes). Returns true if at
+                // limit, at which point the returned pointer maybe null if there was an
+                // error. The invariant of this function is that it's guaranteed that
+                // kSlopBytes bytes can be accessed from the returned ptr. This function might
+                // advance more buffers than one in the underlying ZeroCopyInputStream.
+                std::pair<const char*, bool> DoneFallback(int overrun, int depth);
+                // Advances to the next buffer, at most one call to Next() on the underlying
+                // ZeroCopyInputStream is made. This function DOES NOT match the returned
+                // pointer to where in the slop region the parse ends, hence no overrun
+                // parameter. This is useful for string operations where you always copy
+                // to the end of the buffer (including the slop region).
+                const char* Next();
+                // overrun is the location in the slop region the stream currently is
+                // (0 <= overrun <= kSlopBytes). To prevent flipping to the next buffer of
+                // the ZeroCopyInputStream in the case the parse will end in the last
+                // kSlopBytes of the current buffer. depth is the current depth of nested
+                // groups (or negative if the use case does not need careful tracking).
+                inline const char* NextBuffer(int overrun, int depth);
+                const char* SkipFallback(const char* ptr, int size);
+                const char* AppendStringFallback(const char* ptr, int size, std::string* str);
+                const char* ReadStringFallback(const char* ptr, int size, std::string* str);
+                bool StreamNext(const void** data)
+                {
+                    bool res = zcis_->Next(data, &size_);
+                    if (res)
+                        overall_limit_ -= size_;
+                    return res;
+                }
+                void StreamBackUp(int count)
+                {
+                    zcis_->BackUp(count);
+                    overall_limit_ += count;
+                }
+
+                template<typename A>
+                const char* AppendSize(const char* ptr, int size, const A& append)
+                {
+                    int chunk_size = buffer_end_ + kSlopBytes - ptr;
+                    do
+                    {
+                        GOOGLE_DCHECK(size > chunk_size);
+                        if (next_chunk_ == nullptr)
+                            return nullptr;
+                        append(ptr, chunk_size);
+                        ptr += chunk_size;
+                        size -= chunk_size;
+                        // TODO(gerbens) Next calls NextBuffer which generates buffers with
+                        // overlap and thus incurs cost of copying the slop regions. This is not
+                        // necessary for reading strings. We should just call Next buffers.
+                        if (limit_ <= kSlopBytes)
+                            return nullptr;
+                        ptr = Next();
+                        if (ptr == nullptr)
+                            return nullptr;  // passed the limit
+                        ptr += kSlopBytes;
+                        chunk_size = buffer_end_ + kSlopBytes - ptr;
+                    } while (size > chunk_size);
+                    append(ptr, size);
+                    return ptr + size;
+                }
+
+                // AppendUntilEnd appends data until a limit (either a PushLimit or end of
+                // stream. Normal payloads are from length delimited fields which have an
+                // explicit size. Reading until limit only comes when the string takes
+                // the place of a protobuf, ie RawMessage/StringRawMessage, lazy fields and
+                // implicit weak messages. We keep these methods private and friend them.
+                template<typename A>
+                const char* AppendUntilEnd(const char* ptr, const A& append)
+                {
+                    if (ptr - buffer_end_ > limit_)
+                        return nullptr;
+                    while (limit_ > kSlopBytes)
+                    {
+                        size_t chunk_size = buffer_end_ + kSlopBytes - ptr;
+                        append(ptr, chunk_size);
+                        ptr = Next();
+                        if (ptr == nullptr)
+                            return limit_end_;
+                        ptr += kSlopBytes;
+                    }
+                    auto end = buffer_end_ + limit_;
+                    GOOGLE_DCHECK(end >= ptr);
+                    append(ptr, end - ptr);
+                    return end;
+                }
+
+                PROTOBUF_NODISCARD const char* AppendString(const char* ptr, std::string* str)
+                {
+                    return AppendUntilEnd(
+                        ptr, [str](const char* p, ptrdiff_t s)
+                        { str->append(p, s); }
+                    );
+                }
+                friend class ImplicitWeakMessage;
+            };
+
+            using LazyEagerVerifyFnType = const char* (*)(const char* ptr, ParseContext* ctx);
+            using LazyEagerVerifyFnRef = std::remove_pointer<LazyEagerVerifyFnType>::type&;
+
+            // ParseContext holds all data that is global to the entire parse. Most
+            // importantly it contains the input stream, but also recursion depth and also
+            // stores the end group tag, in case a parser ended on a endgroup, to verify
+            // matching start/end group tags.
+            class PROTOBUF_EXPORT ParseContext : public EpsCopyInputStream
+            {
+            public:
+                struct Data
+                {
+                    const DescriptorPool* pool = nullptr;
+                    MessageFactory* factory = nullptr;
+                    Arena* arena = nullptr;
+                };
+
+                template<typename... T>
+                ParseContext(int depth, bool aliasing, const char** start, T&&... args) :
+                    EpsCopyInputStream(aliasing),
+                    depth_(depth)
+                {
+                    *start = InitFrom(std::forward<T>(args)...);
+                }
+
+                void TrackCorrectEnding()
+                {
+                    group_depth_ = 0;
+                }
+
+                bool Done(const char** ptr)
+                {
+                    return DoneWithCheck(ptr, group_depth_);
+                }
+
+                int depth() const
+                {
+                    return depth_;
+                }
+
+                Data& data()
+                {
+                    return data_;
+                }
+                const Data& data() const
+                {
+                    return data_;
+                }
+
+                const char* ParseMessage(MessageLite* msg, const char* ptr);
+
+                // Spawns a child parsing context that inherits key properties. New context
+                // inherits the following:
+                // --depth_, data_, check_required_fields_, lazy_parse_mode_
+                // The spawned context always disables aliasing (different input).
+                template<typename... T>
+                ParseContext Spawn(const char** start, T&&... args)
+                {
+                    ParseContext spawned(depth_, false, start, std::forward<T>(args)...);
+                    // Transfer key context states.
+                    spawned.data_ = data_;
+                    return spawned;
+                }
+
+                // This overload supports those few cases where ParseMessage is called
+                // on a class that is not actually a proto message.
+                // TODO(jorg): Eliminate this use case.
+                template<typename T, typename std::enable_if<!std::is_base_of<MessageLite, T>::value, bool>::type = true>
+                PROTOBUF_NODISCARD const char* ParseMessage(T* msg, const char* ptr);
+
+                template<typename T>
+                PROTOBUF_NODISCARD PROTOBUF_NDEBUG_INLINE const char* ParseGroup(
+                    T* msg, const char* ptr, uint32_t tag
+                )
+                {
+                    if (--depth_ < 0)
+                        return nullptr;
+                    group_depth_++;
+                    ptr = msg->_InternalParse(ptr, this);
+                    group_depth_--;
+                    depth_++;
+                    if (PROTOBUF_PREDICT_FALSE(!ConsumeEndGroup(tag)))
+                        return nullptr;
+                    return ptr;
+                }
+
+            private:
+                // Out-of-line routine to save space in ParseContext::ParseMessage<T>
+                //   int old;
+                //   ptr = ReadSizeAndPushLimitAndDepth(ptr, &old)
+                // is equivalent to:
+                //   int size = ReadSize(&ptr);
+                //   if (!ptr) return nullptr;
+                //   int old = PushLimit(ptr, size);
+                //   if (--depth_ < 0) return nullptr;
+                PROTOBUF_NODISCARD const char* ReadSizeAndPushLimitAndDepth(const char* ptr, int* old_limit);
+
+                // The context keeps an internal stack to keep track of the recursive
+                // part of the parse state.
+                // Current depth of the active parser, depth counts down.
+                // This is used to limit recursion depth (to prevent overflow on malicious
+                // data), but is also used to index in stack_ to store the current state.
+                int depth_;
+                // Unfortunately necessary for the fringe case of ending on 0 or end-group tag
+                // in the last kSlopBytes of a ZeroCopyInputStream chunk.
+                int group_depth_ = INT_MIN;
+                Data data_;
+            };
+
+            template<uint32_t tag>
+            bool ExpectTag(const char* ptr)
+            {
+                if (tag < 128)
+                {
+                    return *ptr == static_cast<char>(tag);
+                }
+                else
+                {
+                    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
+                    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
+                    return std::memcmp(ptr, buf, 2) == 0;
+                }
+            }
+
+            template<int>
+            struct EndianHelper;
+
+            template<>
+            struct EndianHelper<1>
+            {
+                static uint8_t Load(const void* p)
+                {
+                    return *static_cast<const uint8_t*>(p);
+                }
+            };
+
+            template<>
+            struct EndianHelper<2>
+            {
+                static uint16_t Load(const void* p)
+                {
+                    uint16_t tmp;
+                    std::memcpy(&tmp, p, 2);
+                    return little_endian::ToHost(tmp);
+                }
+            };
+
+            template<>
+            struct EndianHelper<4>
+            {
+                static uint32_t Load(const void* p)
+                {
+                    uint32_t tmp;
+                    std::memcpy(&tmp, p, 4);
+                    return little_endian::ToHost(tmp);
+                }
+            };
+
+            template<>
+            struct EndianHelper<8>
+            {
+                static uint64_t Load(const void* p)
+                {
+                    uint64_t tmp;
+                    std::memcpy(&tmp, p, 8);
+                    return little_endian::ToHost(tmp);
+                }
+            };
+
+            template<typename T>
+            T UnalignedLoad(const char* p)
+            {
+                auto tmp = EndianHelper<sizeof(T)>::Load(p);
+                T res;
+                memcpy(&res, &tmp, sizeof(T));
+                return res;
+            }
+
+            PROTOBUF_EXPORT
+            std::pair<const char*, uint32_t> VarintParseSlow32(const char* p, uint32_t res);
+            PROTOBUF_EXPORT
+            std::pair<const char*, uint64_t> VarintParseSlow64(const char* p, uint32_t res);
+
+            inline const char* VarintParseSlow(const char* p, uint32_t res, uint32_t* out)
+            {
+                auto tmp = VarintParseSlow32(p, res);
+                *out = tmp.second;
+                return tmp.first;
+            }
+
+            inline const char* VarintParseSlow(const char* p, uint32_t res, uint64_t* out)
+            {
+                auto tmp = VarintParseSlow64(p, res);
+                *out = tmp.second;
+                return tmp.first;
+            }
+
+            template<typename T>
+            PROTOBUF_NODISCARD const char* VarintParse(const char* p, T* out)
+            {
+                auto ptr = reinterpret_cast<const uint8_t*>(p);
+                uint32_t res = ptr[0];
+                if (!(res & 0x80))
+                {
+                    *out = res;
+                    return p + 1;
+                }
+                uint32_t byte = ptr[1];
+                res += (byte - 1) << 7;
+                if (!(byte & 0x80))
+                {
+                    *out = res;
+                    return p + 2;
+                }
+                return VarintParseSlow(p, res, out);
+            }
+
+            // Used for tags, could read up to 5 bytes which must be available.
+            // Caller must ensure its safe to call.
+
+            PROTOBUF_EXPORT
+            std::pair<const char*, uint32_t> ReadTagFallback(const char* p, uint32_t res);
+
+            // Same as ParseVarint but only accept 5 bytes at most.
+            inline const char* ReadTag(const char* p, uint32_t* out, uint32_t /*max_tag*/ = 0)
+            {
+                uint32_t res = static_cast<uint8_t>(p[0]);
+                if (res < 128)
+                {
+                    *out = res;
+                    return p + 1;
+                }
+                uint32_t second = static_cast<uint8_t>(p[1]);
+                res += (second - 1) << 7;
+                if (second < 128)
+                {
+                    *out = res;
+                    return p + 2;
+                }
+                auto tmp = ReadTagFallback(p, res);
+                *out = tmp.second;
+                return tmp.first;
+            }
+
+            // As above, but optimized to consume very few registers while still being fast,
+            // ReadTagInlined is useful for callers that don't mind the extra code but would
+            // like to avoid an extern function call causing spills into the stack.
+            //
+            // Two support routines for ReadTagInlined come first...
+            template<class T>
+            PROTOBUF_NODISCARD PROTOBUF_ALWAYS_INLINE constexpr T RotateLeft(
+                T x, int s
+            ) noexcept
+            {
+                return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
+                       static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
+            }
+
+            PROTOBUF_NODISCARD inline PROTOBUF_ALWAYS_INLINE uint64_t
+                RotRight7AndReplaceLowByte(uint64_t res, const char& byte)
+            {
 #if defined(__x86_64__) && defined(__GNUC__)
-  // This will only use one register for `res`.
-  // `byte` comes as a reference to allow the compiler to generate code like:
-  //
-  //   rorq    $7, %rcx
-  //   movb    1(%rax), %cl
-  //
-  // which avoids loading the incoming bytes into a separate register first.
-  asm("ror $7,%0\n\t"
-      "movb %1,%b0"
-      : "+r"(res)
-      : "m"(byte));
+                // This will only use one register for `res`.
+                // `byte` comes as a reference to allow the compiler to generate code like:
+                //
+                //   rorq    $7, %rcx
+                //   movb    1(%rax), %cl
+                //
+                // which avoids loading the incoming bytes into a separate register first.
+                asm("ror $7,%0\n\t"
+                    "movb %1,%b0"
+                    : "+r"(res)
+                    : "m"(byte));
 #else
-  res = RotateLeft(res, -7);
-  res = res & ~0xFF;
-  res |= 0xFF & byte;
+                res = RotateLeft(res, -7);
+                res = res & ~0xFF;
+                res |= 0xFF & byte;
 #endif
-  return res;
-};
-
-inline PROTOBUF_ALWAYS_INLINE
-const char* ReadTagInlined(const char* ptr, uint32_t* out) {
-  uint64_t res = 0xFF & ptr[0];
-  if (PROTOBUF_PREDICT_FALSE(res >= 128)) {
-    res = RotRight7AndReplaceLowByte(res, ptr[1]);
-    if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
-      res = RotRight7AndReplaceLowByte(res, ptr[2]);
-      if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
-        res = RotRight7AndReplaceLowByte(res, ptr[3]);
-        if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
-          // Note: this wouldn't work if res were 32-bit,
-          // because then replacing the low byte would overwrite
-          // the bottom 4 bits of the result.
-          res = RotRight7AndReplaceLowByte(res, ptr[4]);
-          if (PROTOBUF_PREDICT_FALSE(res & 0x80)) {
-            // The proto format does not permit longer than 5-byte encodings for
-            // tags.
-            *out = 0;
-            return nullptr;
-          }
-          *out = static_cast<uint32_t>(RotateLeft(res, 28));
+                return res;
+            };
+
+            inline PROTOBUF_ALWAYS_INLINE const char* ReadTagInlined(const char* ptr, uint32_t* out)
+            {
+                uint64_t res = 0xFF & ptr[0];
+                if (PROTOBUF_PREDICT_FALSE(res >= 128))
+                {
+                    res = RotRight7AndReplaceLowByte(res, ptr[1]);
+                    if (PROTOBUF_PREDICT_FALSE(res & 0x80))
+                    {
+                        res = RotRight7AndReplaceLowByte(res, ptr[2]);
+                        if (PROTOBUF_PREDICT_FALSE(res & 0x80))
+                        {
+                            res = RotRight7AndReplaceLowByte(res, ptr[3]);
+                            if (PROTOBUF_PREDICT_FALSE(res & 0x80))
+                            {
+                                // Note: this wouldn't work if res were 32-bit,
+                                // because then replacing the low byte would overwrite
+                                // the bottom 4 bits of the result.
+                                res = RotRight7AndReplaceLowByte(res, ptr[4]);
+                                if (PROTOBUF_PREDICT_FALSE(res & 0x80))
+                                {
+                                    // The proto format does not permit longer than 5-byte encodings for
+                                    // tags.
+                                    *out = 0;
+                                    return nullptr;
+                                }
+                                *out = static_cast<uint32_t>(RotateLeft(res, 28));
 #if defined(__GNUC__)
-          // Note: this asm statement prevents the compiler from
-          // trying to share the "return ptr + constant" among all
-          // branches.
-          asm("" : "+r"(ptr));
+                                // Note: this asm statement prevents the compiler from
+                                // trying to share the "return ptr + constant" among all
+                                // branches.
+                                asm(""
+                                    : "+r"(ptr));
 #endif
-          return ptr + 5;
-        }
-        *out = static_cast<uint32_t>(RotateLeft(res, 21));
-        return ptr + 4;
-      }
-      *out = static_cast<uint32_t>(RotateLeft(res, 14));
-      return ptr + 3;
-    }
-    *out = static_cast<uint32_t>(RotateLeft(res, 7));
-    return ptr + 2;
-  }
-  *out = static_cast<uint32_t>(res);
-  return ptr + 1;
-}
-
-// Decode 2 consecutive bytes of a varint and returns the value, shifted left
-// by 1. It simultaneous updates *ptr to *ptr + 1 or *ptr + 2 depending if the
-// first byte's continuation bit is set.
-// If bit 15 of return value is set (equivalent to the continuation bits of both
-// bytes being set) the varint continues, otherwise the parse is done. On x86
-// movsx eax, dil
-// and edi, eax
-// add eax, edi
-// adc [rsi], 1
-inline uint32_t DecodeTwoBytes(const char** ptr) {
-  uint32_t value = UnalignedLoad<uint16_t>(*ptr);
-  // Sign extend the low byte continuation bit
-  uint32_t x = static_cast<int8_t>(value);
-  value &= x;  // Mask out the high byte iff no continuation
-  // This add is an amazing operation, it cancels the low byte continuation bit
-  // from y transferring it to the carry. Simultaneously it also shifts the 7
-  // LSB left by one tightly against high byte varint bits. Hence value now
-  // contains the unpacked value shifted left by 1.
-  value += x;
-  // Use the carry to update the ptr appropriately.
-  *ptr += value < x ? 2 : 1;
-  return value;
-}
-
-// More efficient varint parsing for big varints
-inline const char* ParseBigVarint(const char* p, uint64_t* out) {
-  auto pnew = p;
-  auto tmp = DecodeTwoBytes(&pnew);
-  uint64_t res = tmp >> 1;
-  if (PROTOBUF_PREDICT_TRUE(static_cast<std::int16_t>(tmp) >= 0)) {
-    *out = res;
-    return pnew;
-  }
-  for (std::uint32_t i = 1; i < 5; i++) {
-    pnew = p + 2 * i;
-    tmp = DecodeTwoBytes(&pnew);
-    res += (static_cast<std::uint64_t>(tmp) - 2) << (14 * i - 1);
-    if (PROTOBUF_PREDICT_TRUE(static_cast<std::int16_t>(tmp) >= 0)) {
-      *out = res;
-      return pnew;
-    }
-  }
-  return nullptr;
-}
-
-PROTOBUF_EXPORT
-std::pair<const char*, int32_t> ReadSizeFallback(const char* p, uint32_t first);
-// Used for tags, could read up to 5 bytes which must be available. Additionally
-// it makes sure the unsigned value fits a int32_t, otherwise returns nullptr.
-// Caller must ensure its safe to call.
-inline uint32_t ReadSize(const char** pp) {
-  auto p = *pp;
-  uint32_t res = static_cast<uint8_t>(p[0]);
-  if (res < 128) {
-    *pp = p + 1;
-    return res;
-  }
-  auto x = ReadSizeFallback(p, res);
-  *pp = x.first;
-  return x.second;
-}
-
-// Some convenience functions to simplify the generated parse loop code.
-// Returning the value and updating the buffer pointer allows for nicer
-// function composition. We rely on the compiler to inline this.
-// Also in debug compiles having local scoped variables tend to generated
-// stack frames that scale as O(num fields).
-inline uint64_t ReadVarint64(const char** p) {
-  uint64_t tmp;
-  *p = VarintParse(*p, &tmp);
-  return tmp;
-}
-
-inline uint32_t ReadVarint32(const char** p) {
-  uint32_t tmp;
-  *p = VarintParse(*p, &tmp);
-  return tmp;
-}
-
-inline int64_t ReadVarintZigZag64(const char** p) {
-  uint64_t tmp;
-  *p = VarintParse(*p, &tmp);
-  return WireFormatLite::ZigZagDecode64(tmp);
-}
-
-inline int32_t ReadVarintZigZag32(const char** p) {
-  uint64_t tmp;
-  *p = VarintParse(*p, &tmp);
-  return WireFormatLite::ZigZagDecode32(static_cast<uint32_t>(tmp));
-}
-
-template <typename T, typename std::enable_if<
-                          !std::is_base_of<MessageLite, T>::value, bool>::type>
-PROTOBUF_NODISCARD const char* ParseContext::ParseMessage(T* msg,
-                                                          const char* ptr) {
-  int old;
-  ptr = ReadSizeAndPushLimitAndDepth(ptr, &old);
-  ptr = ptr ? msg->_InternalParse(ptr, this) : nullptr;
-  depth_++;
-  if (!PopLimit(old)) return nullptr;
-  return ptr;
-}
-
-template <typename Tag, typename T>
-const char* EpsCopyInputStream::ReadRepeatedFixed(const char* ptr,
-                                                  Tag expected_tag,
-                                                  RepeatedField<T>* out) {
-  do {
-    out->Add(UnalignedLoad<T>(ptr));
-    ptr += sizeof(T);
-    if (PROTOBUF_PREDICT_FALSE(ptr >= limit_end_)) return ptr;
-  } while (UnalignedLoad<Tag>(ptr) == expected_tag && (ptr += sizeof(Tag)));
-  return ptr;
-}
-
-// Add any of the following lines to debug which parse function is failing.
+                                return ptr + 5;
+                            }
+                            *out = static_cast<uint32_t>(RotateLeft(res, 21));
+                            return ptr + 4;
+                        }
+                        *out = static_cast<uint32_t>(RotateLeft(res, 14));
+                        return ptr + 3;
+                    }
+                    *out = static_cast<uint32_t>(RotateLeft(res, 7));
+                    return ptr + 2;
+                }
+                *out = static_cast<uint32_t>(res);
+                return ptr + 1;
+            }
+
+            // Decode 2 consecutive bytes of a varint and returns the value, shifted left
+            // by 1. It simultaneous updates *ptr to *ptr + 1 or *ptr + 2 depending if the
+            // first byte's continuation bit is set.
+            // If bit 15 of return value is set (equivalent to the continuation bits of both
+            // bytes being set) the varint continues, otherwise the parse is done. On x86
+            // movsx eax, dil
+            // and edi, eax
+            // add eax, edi
+            // adc [rsi], 1
+            inline uint32_t DecodeTwoBytes(const char** ptr)
+            {
+                uint32_t value = UnalignedLoad<uint16_t>(*ptr);
+                // Sign extend the low byte continuation bit
+                uint32_t x = static_cast<int8_t>(value);
+                value &= x;  // Mask out the high byte iff no continuation
+                // This add is an amazing operation, it cancels the low byte continuation bit
+                // from y transferring it to the carry. Simultaneously it also shifts the 7
+                // LSB left by one tightly against high byte varint bits. Hence value now
+                // contains the unpacked value shifted left by 1.
+                value += x;
+                // Use the carry to update the ptr appropriately.
+                *ptr += value < x ? 2 : 1;
+                return value;
+            }
+
+            // More efficient varint parsing for big varints
+            inline const char* ParseBigVarint(const char* p, uint64_t* out)
+            {
+                auto pnew = p;
+                auto tmp = DecodeTwoBytes(&pnew);
+                uint64_t res = tmp >> 1;
+                if (PROTOBUF_PREDICT_TRUE(static_cast<std::int16_t>(tmp) >= 0))
+                {
+                    *out = res;
+                    return pnew;
+                }
+                for (std::uint32_t i = 1; i < 5; i++)
+                {
+                    pnew = p + 2 * i;
+                    tmp = DecodeTwoBytes(&pnew);
+                    res += (static_cast<std::uint64_t>(tmp) - 2) << (14 * i - 1);
+                    if (PROTOBUF_PREDICT_TRUE(static_cast<std::int16_t>(tmp) >= 0))
+                    {
+                        *out = res;
+                        return pnew;
+                    }
+                }
+                return nullptr;
+            }
+
+            PROTOBUF_EXPORT
+            std::pair<const char*, int32_t> ReadSizeFallback(const char* p, uint32_t first);
+            // Used for tags, could read up to 5 bytes which must be available. Additionally
+            // it makes sure the unsigned value fits a int32_t, otherwise returns nullptr.
+            // Caller must ensure its safe to call.
+            inline uint32_t ReadSize(const char** pp)
+            {
+                auto p = *pp;
+                uint32_t res = static_cast<uint8_t>(p[0]);
+                if (res < 128)
+                {
+                    *pp = p + 1;
+                    return res;
+                }
+                auto x = ReadSizeFallback(p, res);
+                *pp = x.first;
+                return x.second;
+            }
+
+            // Some convenience functions to simplify the generated parse loop code.
+            // Returning the value and updating the buffer pointer allows for nicer
+            // function composition. We rely on the compiler to inline this.
+            // Also in debug compiles having local scoped variables tend to generated
+            // stack frames that scale as O(num fields).
+            inline uint64_t ReadVarint64(const char** p)
+            {
+                uint64_t tmp;
+                *p = VarintParse(*p, &tmp);
+                return tmp;
+            }
+
+            inline uint32_t ReadVarint32(const char** p)
+            {
+                uint32_t tmp;
+                *p = VarintParse(*p, &tmp);
+                return tmp;
+            }
+
+            inline int64_t ReadVarintZigZag64(const char** p)
+            {
+                uint64_t tmp;
+                *p = VarintParse(*p, &tmp);
+                return WireFormatLite::ZigZagDecode64(tmp);
+            }
+
+            inline int32_t ReadVarintZigZag32(const char** p)
+            {
+                uint64_t tmp;
+                *p = VarintParse(*p, &tmp);
+                return WireFormatLite::ZigZagDecode32(static_cast<uint32_t>(tmp));
+            }
+
+            template<typename T, typename std::enable_if<!std::is_base_of<MessageLite, T>::value, bool>::type>
+            PROTOBUF_NODISCARD const char* ParseContext::ParseMessage(T* msg, const char* ptr)
+            {
+                int old;
+                ptr = ReadSizeAndPushLimitAndDepth(ptr, &old);
+                ptr = ptr ? msg->_InternalParse(ptr, this) : nullptr;
+                depth_++;
+                if (!PopLimit(old))
+                    return nullptr;
+                return ptr;
+            }
+
+            template<typename Tag, typename T>
+            const char* EpsCopyInputStream::ReadRepeatedFixed(const char* ptr, Tag expected_tag, RepeatedField<T>* out)
+            {
+                do
+                {
+                    out->Add(UnalignedLoad<T>(ptr));
+                    ptr += sizeof(T);
+                    if (PROTOBUF_PREDICT_FALSE(ptr >= limit_end_))
+                        return ptr;
+                } while (UnalignedLoad<Tag>(ptr) == expected_tag && (ptr += sizeof(Tag)));
+                return ptr;
+            }
+
+            // Add any of the following lines to debug which parse function is failing.
 
 #define GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, ret) \
-  if (!(predicate)) {                                  \
-    /*  ::raise(SIGINT);  */                           \
-    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
-    return ret;                                        \
-  }
+    if (!(predicate))                                 \
+    {                                                 \
+        /*  ::raise(SIGINT);  */                      \
+        /*  GOOGLE_LOG(ERROR) << "Parse failure";  */ \
+        return ret;                                   \
+    }
 
 #define GOOGLE_PROTOBUF_PARSER_ASSERT(predicate) \
-  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
-
-template <typename T>
-const char* EpsCopyInputStream::ReadPackedFixed(const char* ptr, int size,
-                                                RepeatedField<T>* out) {
-  GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-  int nbytes = buffer_end_ + kSlopBytes - ptr;
-  while (size > nbytes) {
-    int num = nbytes / sizeof(T);
-    int old_entries = out->size();
-    out->Reserve(old_entries + num);
-    int block_size = num * sizeof(T);
-    auto dst = out->AddNAlreadyReserved(num);
+    GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
+
+            template<typename T>
+            const char* EpsCopyInputStream::ReadPackedFixed(const char* ptr, int size, RepeatedField<T>* out)
+            {
+                GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                int nbytes = buffer_end_ + kSlopBytes - ptr;
+                while (size > nbytes)
+                {
+                    int num = nbytes / sizeof(T);
+                    int old_entries = out->size();
+                    out->Reserve(old_entries + num);
+                    int block_size = num * sizeof(T);
+                    auto dst = out->AddNAlreadyReserved(num);
 #ifdef PROTOBUF_LITTLE_ENDIAN
-    std::memcpy(dst, ptr, block_size);
+                    std::memcpy(dst, ptr, block_size);
 #else
-    for (int i = 0; i < num; i++)
-      dst[i] = UnalignedLoad<T>(ptr + i * sizeof(T));
+                    for (int i = 0; i < num; i++)
+                        dst[i] = UnalignedLoad<T>(ptr + i * sizeof(T));
 #endif
-    size -= block_size;
-    if (limit_ <= kSlopBytes) return nullptr;
-    ptr = Next();
-    if (ptr == nullptr) return nullptr;
-    ptr += kSlopBytes - (nbytes - block_size);
-    nbytes = buffer_end_ + kSlopBytes - ptr;
-  }
-  int num = size / sizeof(T);
-  int old_entries = out->size();
-  out->Reserve(old_entries + num);
-  int block_size = num * sizeof(T);
-  auto dst = out->AddNAlreadyReserved(num);
+                    size -= block_size;
+                    if (limit_ <= kSlopBytes)
+                        return nullptr;
+                    ptr = Next();
+                    if (ptr == nullptr)
+                        return nullptr;
+                    ptr += kSlopBytes - (nbytes - block_size);
+                    nbytes = buffer_end_ + kSlopBytes - ptr;
+                }
+                int num = size / sizeof(T);
+                int old_entries = out->size();
+                out->Reserve(old_entries + num);
+                int block_size = num * sizeof(T);
+                auto dst = out->AddNAlreadyReserved(num);
 #ifdef PROTOBUF_LITTLE_ENDIAN
-  std::memcpy(dst, ptr, block_size);
+                std::memcpy(dst, ptr, block_size);
 #else
-  for (int i = 0; i < num; i++) dst[i] = UnalignedLoad<T>(ptr + i * sizeof(T));
+                for (int i = 0; i < num; i++)
+                    dst[i] = UnalignedLoad<T>(ptr + i * sizeof(T));
 #endif
-  ptr += block_size;
-  if (size != block_size) return nullptr;
-  return ptr;
-}
-
-template <typename Add>
-const char* ReadPackedVarintArray(const char* ptr, const char* end, Add add) {
-  while (ptr < end) {
-    uint64_t varint;
-    ptr = VarintParse(ptr, &varint);
-    if (ptr == nullptr) return nullptr;
-    add(varint);
-  }
-  return ptr;
-}
-
-template <typename Add>
-const char* EpsCopyInputStream::ReadPackedVarint(const char* ptr, Add add) {
-  int size = ReadSize(&ptr);
-  GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-  int chunk_size = buffer_end_ - ptr;
-  while (size > chunk_size) {
-    ptr = ReadPackedVarintArray(ptr, buffer_end_, add);
-    if (ptr == nullptr) return nullptr;
-    int overrun = ptr - buffer_end_;
-    GOOGLE_DCHECK(overrun >= 0 && overrun <= kSlopBytes);
-    if (size - chunk_size <= kSlopBytes) {
-      // The current buffer contains all the information needed, we don't need
-      // to flip buffers. However we must parse from a buffer with enough space
-      // so we are not prone to a buffer overflow.
-      char buf[kSlopBytes + 10] = {};
-      std::memcpy(buf, buffer_end_, kSlopBytes);
-      GOOGLE_CHECK_LE(size - chunk_size, kSlopBytes);
-      auto end = buf + (size - chunk_size);
-      auto res = ReadPackedVarintArray(buf + overrun, end, add);
-      if (res == nullptr || res != end) return nullptr;
-      return buffer_end_ + (res - buf);
-    }
-    size -= overrun + chunk_size;
-    GOOGLE_DCHECK_GT(size, 0);
-    // We must flip buffers
-    if (limit_ <= kSlopBytes) return nullptr;
-    ptr = Next();
-    if (ptr == nullptr) return nullptr;
-    ptr += overrun;
-    chunk_size = buffer_end_ - ptr;
-  }
-  auto end = ptr + size;
-  ptr = ReadPackedVarintArray(ptr, end, add);
-  return end == ptr ? ptr : nullptr;
-}
-
-// Helper for verification of utf8
-PROTOBUF_EXPORT
-bool VerifyUTF8(StringPiece s, const char* field_name);
-
-inline bool VerifyUTF8(const std::string* s, const char* field_name) {
-  return VerifyUTF8(*s, field_name);
-}
-
-// All the string parsers with or without UTF checking and for all CTypes.
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* InlineGreedyStringParser(
-    std::string* s, const char* ptr, ParseContext* ctx);
-
-
-template <typename T>
-PROTOBUF_NODISCARD const char* FieldParser(uint64_t tag, T& field_parser,
-                                           const char* ptr, ParseContext* ctx) {
-  uint32_t number = tag >> 3;
-  GOOGLE_PROTOBUF_PARSER_ASSERT(number != 0);
-  using WireType = internal::WireFormatLite::WireType;
-  switch (tag & 7) {
-    case WireType::WIRETYPE_VARINT: {
-      uint64_t value;
-      ptr = VarintParse(ptr, &value);
-      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-      field_parser.AddVarint(number, value);
-      break;
-    }
-    case WireType::WIRETYPE_FIXED64: {
-      uint64_t value = UnalignedLoad<uint64_t>(ptr);
-      ptr += 8;
-      field_parser.AddFixed64(number, value);
-      break;
-    }
-    case WireType::WIRETYPE_LENGTH_DELIMITED: {
-      ptr = field_parser.ParseLengthDelimited(number, ptr, ctx);
-      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-      break;
-    }
-    case WireType::WIRETYPE_START_GROUP: {
-      ptr = field_parser.ParseGroup(number, ptr, ctx);
-      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
-      break;
-    }
-    case WireType::WIRETYPE_END_GROUP: {
-      GOOGLE_LOG(FATAL) << "Can't happen";
-      break;
-    }
-    case WireType::WIRETYPE_FIXED32: {
-      uint32_t value = UnalignedLoad<uint32_t>(ptr);
-      ptr += 4;
-      field_parser.AddFixed32(number, value);
-      break;
-    }
-    default:
-      return nullptr;
-  }
-  return ptr;
-}
-
-template <typename T>
-PROTOBUF_NODISCARD const char* WireFormatParser(T& field_parser,
-                                                const char* ptr,
-                                                ParseContext* ctx) {
-  while (!ctx->Done(&ptr)) {
-    uint32_t tag;
-    ptr = ReadTag(ptr, &tag);
-    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
-    if (tag == 0 || (tag & 7) == 4) {
-      ctx->SetLastTag(tag);
-      return ptr;
-    }
-    ptr = FieldParser(tag, field_parser, ptr, ctx);
-    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
-  }
-  return ptr;
-}
-
-// The packed parsers parse repeated numeric primitives directly into  the
-// corresponding field
-
-// These are packed varints
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedInt32Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedUInt32Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedInt64Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedUInt64Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSInt32Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSInt64Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedEnumParser(
-    void* object, const char* ptr, ParseContext* ctx);
-
-template <typename T>
-PROTOBUF_NODISCARD const char* PackedEnumParser(void* object, const char* ptr,
-                                                ParseContext* ctx,
-                                                bool (*is_valid)(int),
-                                                InternalMetadata* metadata,
-                                                int field_num) {
-  return ctx->ReadPackedVarint(
-      ptr, [object, is_valid, metadata, field_num](uint64_t val) {
+                ptr += block_size;
+                if (size != block_size)
+                    return nullptr;
+                return ptr;
+            }
+
+            template<typename Add>
+            const char* ReadPackedVarintArray(const char* ptr, const char* end, Add add)
+            {
+                while (ptr < end)
+                {
+                    uint64_t varint;
+                    ptr = VarintParse(ptr, &varint);
+                    if (ptr == nullptr)
+                        return nullptr;
+                    add(varint);
+                }
+                return ptr;
+            }
+
+            template<typename Add>
+            const char* EpsCopyInputStream::ReadPackedVarint(const char* ptr, Add add)
+            {
+                int size = ReadSize(&ptr);
+                GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                int chunk_size = buffer_end_ - ptr;
+                while (size > chunk_size)
+                {
+                    ptr = ReadPackedVarintArray(ptr, buffer_end_, add);
+                    if (ptr == nullptr)
+                        return nullptr;
+                    int overrun = ptr - buffer_end_;
+                    GOOGLE_DCHECK(overrun >= 0 && overrun <= kSlopBytes);
+                    if (size - chunk_size <= kSlopBytes)
+                    {
+                        // The current buffer contains all the information needed, we don't need
+                        // to flip buffers. However we must parse from a buffer with enough space
+                        // so we are not prone to a buffer overflow.
+                        char buf[kSlopBytes + 10] = {};
+                        std::memcpy(buf, buffer_end_, kSlopBytes);
+                        GOOGLE_CHECK_LE(size - chunk_size, kSlopBytes);
+                        auto end = buf + (size - chunk_size);
+                        auto res = ReadPackedVarintArray(buf + overrun, end, add);
+                        if (res == nullptr || res != end)
+                            return nullptr;
+                        return buffer_end_ + (res - buf);
+                    }
+                    size -= overrun + chunk_size;
+                    GOOGLE_DCHECK_GT(size, 0);
+                    // We must flip buffers
+                    if (limit_ <= kSlopBytes)
+                        return nullptr;
+                    ptr = Next();
+                    if (ptr == nullptr)
+                        return nullptr;
+                    ptr += overrun;
+                    chunk_size = buffer_end_ - ptr;
+                }
+                auto end = ptr + size;
+                ptr = ReadPackedVarintArray(ptr, end, add);
+                return end == ptr ? ptr : nullptr;
+            }
+
+            // Helper for verification of utf8
+            PROTOBUF_EXPORT
+            bool VerifyUTF8(StringPiece s, const char* field_name);
+
+            inline bool VerifyUTF8(const std::string* s, const char* field_name)
+            {
+                return VerifyUTF8(*s, field_name);
+            }
+
+            // All the string parsers with or without UTF checking and for all CTypes.
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* InlineGreedyStringParser(
+                std::string* s, const char* ptr, ParseContext* ctx
+            );
+
+            template<typename T>
+            PROTOBUF_NODISCARD const char* FieldParser(uint64_t tag, T& field_parser, const char* ptr, ParseContext* ctx)
+            {
+                uint32_t number = tag >> 3;
+                GOOGLE_PROTOBUF_PARSER_ASSERT(number != 0);
+                using WireType = internal::WireFormatLite::WireType;
+                switch (tag & 7)
+                {
+                    case WireType::WIRETYPE_VARINT:
+                        {
+                            uint64_t value;
+                            ptr = VarintParse(ptr, &value);
+                            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                            field_parser.AddVarint(number, value);
+                            break;
+                        }
+                    case WireType::WIRETYPE_FIXED64:
+                        {
+                            uint64_t value = UnalignedLoad<uint64_t>(ptr);
+                            ptr += 8;
+                            field_parser.AddFixed64(number, value);
+                            break;
+                        }
+                    case WireType::WIRETYPE_LENGTH_DELIMITED:
+                        {
+                            ptr = field_parser.ParseLengthDelimited(number, ptr, ctx);
+                            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                            break;
+                        }
+                    case WireType::WIRETYPE_START_GROUP:
+                        {
+                            ptr = field_parser.ParseGroup(number, ptr, ctx);
+                            GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
+                            break;
+                        }
+                    case WireType::WIRETYPE_END_GROUP:
+                        {
+                            GOOGLE_LOG(FATAL) << "Can't happen";
+                            break;
+                        }
+                    case WireType::WIRETYPE_FIXED32:
+                        {
+                            uint32_t value = UnalignedLoad<uint32_t>(ptr);
+                            ptr += 4;
+                            field_parser.AddFixed32(number, value);
+                            break;
+                        }
+                    default:
+                        return nullptr;
+                }
+                return ptr;
+            }
+
+            template<typename T>
+            PROTOBUF_NODISCARD const char* WireFormatParser(T& field_parser, const char* ptr, ParseContext* ctx)
+            {
+                while (!ctx->Done(&ptr))
+                {
+                    uint32_t tag;
+                    ptr = ReadTag(ptr, &tag);
+                    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+                    if (tag == 0 || (tag & 7) == 4)
+                    {
+                        ctx->SetLastTag(tag);
+                        return ptr;
+                    }
+                    ptr = FieldParser(tag, field_parser, ptr, ctx);
+                    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
+                }
+                return ptr;
+            }
+
+            // The packed parsers parse repeated numeric primitives directly into  the
+            // corresponding field
+
+            // These are packed varints
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedInt32Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedUInt32Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedInt64Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedUInt64Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSInt32Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSInt64Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedEnumParser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+
+            template<typename T>
+            PROTOBUF_NODISCARD const char* PackedEnumParser(void* object, const char* ptr, ParseContext* ctx, bool (*is_valid)(int), InternalMetadata* metadata, int field_num)
+            {
+                return ctx->ReadPackedVarint(
+                    ptr, [object, is_valid, metadata, field_num](uint64_t val)
+                    {
         if (is_valid(val)) {
           static_cast<RepeatedField<int>*>(object)->Add(val);
         } else {
           WriteVarint(field_num, val, metadata->mutable_unknown_fields<T>());
-        }
-      });
-}
-
-template <typename T>
-PROTOBUF_NODISCARD const char* PackedEnumParserArg(
-    void* object, const char* ptr, ParseContext* ctx,
-    bool (*is_valid)(const void*, int), const void* data,
-    InternalMetadata* metadata, int field_num) {
-  return ctx->ReadPackedVarint(
-      ptr, [object, is_valid, data, metadata, field_num](uint64_t val) {
+        } }
+                );
+            }
+
+            template<typename T>
+            PROTOBUF_NODISCARD const char* PackedEnumParserArg(
+                void* object, const char* ptr, ParseContext* ctx, bool (*is_valid)(const void*, int), const void* data, InternalMetadata* metadata, int field_num
+            )
+            {
+                return ctx->ReadPackedVarint(
+                    ptr, [object, is_valid, data, metadata, field_num](uint64_t val)
+                    {
         if (is_valid(data, val)) {
           static_cast<RepeatedField<int>*>(object)->Add(val);
         } else {
           WriteVarint(field_num, val, metadata->mutable_unknown_fields<T>());
-        }
-      });
-}
-
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedBoolParser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFixed32Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSFixed32Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFixed64Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSFixed64Parser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFloatParser(
-    void* object, const char* ptr, ParseContext* ctx);
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedDoubleParser(
-    void* object, const char* ptr, ParseContext* ctx);
-
-// This is the only recursive parser.
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* UnknownGroupLiteParse(
-    std::string* unknown, const char* ptr, ParseContext* ctx);
-// This is a helper to for the UnknownGroupLiteParse but is actually also
-// useful in the generated code. It uses overload on std::string* vs
-// UnknownFieldSet* to make the generated code isomorphic between full and lite.
-PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* UnknownFieldParse(
-    uint32_t tag, std::string* unknown, const char* ptr, ParseContext* ctx);
-
-}  // namespace internal
-}  // namespace protobuf
+        } }
+                );
+            }
+
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedBoolParser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFixed32Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSFixed32Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFixed64Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedSFixed64Parser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedFloatParser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* PackedDoubleParser(
+                void* object, const char* ptr, ParseContext* ctx
+            );
+
+            // This is the only recursive parser.
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* UnknownGroupLiteParse(
+                std::string* unknown, const char* ptr, ParseContext* ctx
+            );
+            // This is a helper to for the UnknownGroupLiteParse but is actually also
+            // useful in the generated code. It uses overload on std::string* vs
+            // UnknownFieldSet* to make the generated code isomorphic between full and lite.
+            PROTOBUF_NODISCARD PROTOBUF_EXPORT const char* UnknownFieldParse(
+                uint32_t tag, std::string* unknown, const char* ptr, ParseContext* ctx
+            );
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/port.h b/CAPI/cpp/grpc/include/google/protobuf/port.h
index a5c060b..4fc8307 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/port.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/port.h
@@ -39,42 +39,48 @@
 #include <cstddef>
 #include <new>
 
-
-namespace google {
-namespace protobuf {
-namespace internal {
-inline void SizedDelete(void* p, size_t size) {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+            inline void SizedDelete(void* p, size_t size)
+            {
 #if defined(__cpp_sized_deallocation)
-  ::operator delete(p, size);
+                ::operator delete(p, size);
 #else
-  ::operator delete(p);
+                ::operator delete(p);
 #endif
-}
-inline void SizedArrayDelete(void* p, size_t size) {
+            }
+            inline void SizedArrayDelete(void* p, size_t size)
+            {
 #if defined(__cpp_sized_deallocation)
-  ::operator delete[](p, size);
+                ::operator delete[](p, size);
 #else
-  ::operator delete[](p);
+                ::operator delete[](p);
 #endif
-}
+            }
 
-// Tag type used to invoke the constinit constructor overload of classes
-// such as ArenaStringPtr and MapFieldBase. Such constructors are internal
-// implementation details of the library.
-struct ConstantInitialized {
-  explicit ConstantInitialized() = default;
-};
+            // Tag type used to invoke the constinit constructor overload of classes
+            // such as ArenaStringPtr and MapFieldBase. Such constructors are internal
+            // implementation details of the library.
+            struct ConstantInitialized
+            {
+                explicit ConstantInitialized() = default;
+            };
 
-// Tag type used to invoke the arena constructor overload of classes such
-// as ExtensionSet and MapFieldLite in aggregate initialization. These
-// classes typically don't have move/copy constructors, which rules out
-// explicit initialization in pre-C++17.
-struct ArenaInitialized {
-  explicit ArenaInitialized() = default;
-};
+            // Tag type used to invoke the arena constructor overload of classes such
+            // as ExtensionSet and MapFieldLite in aggregate initialization. These
+            // classes typically don't have move/copy constructors, which rules out
+            // explicit initialization in pre-C++17.
+            struct ArenaInitialized
+            {
+                explicit ArenaInitialized() = default;
+            };
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_PORT_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/reflection.h b/CAPI/cpp/grpc/include/google/protobuf/reflection.h
index 7b75a43..c4fc8ca 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/reflection.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/reflection.h
@@ -33,7 +33,6 @@
 #ifndef GOOGLE_PROTOBUF_REFLECTION_H__
 #define GOOGLE_PROTOBUF_REFLECTION_H__
 
-
 #include <memory>
 
 #include <google/protobuf/message.h>
@@ -46,523 +45,657 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace internal {
-template <typename T, typename Enable = void>
-struct RefTypeTraits;
-}  // namespace internal
-
-template <typename T>
-RepeatedFieldRef<T> Reflection::GetRepeatedFieldRef(
-    const Message& message, const FieldDescriptor* field) const {
-  return RepeatedFieldRef<T>(message, field);
-}
-
-template <typename T>
-MutableRepeatedFieldRef<T> Reflection::GetMutableRepeatedFieldRef(
-    Message* message, const FieldDescriptor* field) const {
-  return MutableRepeatedFieldRef<T>(message, field);
-}
-
-// RepeatedFieldRef definition for non-message types.
-template <typename T>
-class RepeatedFieldRef<
-    T, typename std::enable_if<!std::is_base_of<Message, T>::value>::type> {
-  typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
-  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
-
- public:
-  bool empty() const { return accessor_->IsEmpty(data_); }
-  int size() const { return accessor_->Size(data_); }
-  T Get(int index) const { return accessor_->template Get<T>(data_, index); }
-
-  typedef IteratorType iterator;
-  typedef IteratorType const_iterator;
-  typedef T value_type;
-  typedef T& reference;
-  typedef const T& const_reference;
-  typedef int size_type;
-  typedef ptrdiff_t difference_type;
-
-  iterator begin() const { return iterator(data_, accessor_, true); }
-  iterator end() const { return iterator(data_, accessor_, false); }
-
- private:
-  friend class Reflection;
-  RepeatedFieldRef(const Message& message, const FieldDescriptor* field) {
-    const Reflection* reflection = message.GetReflection();
-    data_ = reflection->RepeatedFieldData(const_cast<Message*>(&message), field,
-                                          internal::RefTypeTraits<T>::cpp_type,
-                                          nullptr);
-    accessor_ = reflection->RepeatedFieldAccessor(field);
-  }
-
-  const void* data_;
-  const AccessorType* accessor_;
-};
-
-// MutableRepeatedFieldRef definition for non-message types.
-template <typename T>
-class MutableRepeatedFieldRef<
-    T, typename std::enable_if<!std::is_base_of<Message, T>::value>::type> {
-  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
-
- public:
-  bool empty() const { return accessor_->IsEmpty(data_); }
-  int size() const { return accessor_->Size(data_); }
-  T Get(int index) const { return accessor_->template Get<T>(data_, index); }
-
-  void Set(int index, const T& value) const {
-    accessor_->template Set<T>(data_, index, value);
-  }
-  void Add(const T& value) const { accessor_->template Add<T>(data_, value); }
-  void RemoveLast() const { accessor_->RemoveLast(data_); }
-  void SwapElements(int index1, int index2) const {
-    accessor_->SwapElements(data_, index1, index2);
-  }
-  void Clear() const { accessor_->Clear(data_); }
-
-  void Swap(const MutableRepeatedFieldRef& other) const {
-    accessor_->Swap(data_, other.accessor_, other.data_);
-  }
-
-  template <typename Container>
-  void MergeFrom(const Container& container) const {
-    typedef typename Container::const_iterator Iterator;
-    for (Iterator it = container.begin(); it != container.end(); ++it) {
-      Add(*it);
-    }
-  }
-  template <typename Container>
-  void CopyFrom(const Container& container) const {
-    Clear();
-    MergeFrom(container);
-  }
-
- private:
-  friend class Reflection;
-  MutableRepeatedFieldRef(Message* message, const FieldDescriptor* field) {
-    const Reflection* reflection = message->GetReflection();
-    data_ = reflection->RepeatedFieldData(
-        message, field, internal::RefTypeTraits<T>::cpp_type, nullptr);
-    accessor_ = reflection->RepeatedFieldAccessor(field);
-  }
-
-  void* data_;
-  const AccessorType* accessor_;
-};
-
-// RepeatedFieldRef definition for message types.
-template <typename T>
-class RepeatedFieldRef<
-    T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
-  typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
-  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
-
- public:
-  bool empty() const { return accessor_->IsEmpty(data_); }
-  int size() const { return accessor_->Size(data_); }
-  // This method returns a reference to the underlying message object if it
-  // exists. If a message object doesn't exist (e.g., data stored in serialized
-  // form), scratch_space will be filled with the data and a reference to it
-  // will be returned.
-  //
-  // Example:
-  //   RepeatedFieldRef<Message> h = ...
-  //   unique_ptr<Message> scratch_space(h.NewMessage());
-  //   const Message& item = h.Get(index, scratch_space.get());
-  const T& Get(int index, T* scratch_space) const {
-    return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
-  }
-  // Create a new message of the same type as the messages stored in this
-  // repeated field. Caller takes ownership of the returned object.
-  T* NewMessage() const { return static_cast<T*>(default_instance_->New()); }
-
-  typedef IteratorType iterator;
-  typedef IteratorType const_iterator;
-  typedef T value_type;
-  typedef T& reference;
-  typedef const T& const_reference;
-  typedef int size_type;
-  typedef ptrdiff_t difference_type;
-
-  iterator begin() const {
-    return iterator(data_, accessor_, true, NewMessage());
-  }
-  iterator end() const {
-    // The end iterator must not be dereferenced, no need for scratch space.
-    return iterator(data_, accessor_, false, nullptr);
-  }
-
- private:
-  friend class Reflection;
-  RepeatedFieldRef(const Message& message, const FieldDescriptor* field) {
-    const Reflection* reflection = message.GetReflection();
-    data_ = reflection->RepeatedFieldData(
-        const_cast<Message*>(&message), field,
-        internal::RefTypeTraits<T>::cpp_type,
-        internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
-    accessor_ = reflection->RepeatedFieldAccessor(field);
-    default_instance_ =
-        reflection->GetMessageFactory()->GetPrototype(field->message_type());
-  }
-
-  const void* data_;
-  const AccessorType* accessor_;
-  const Message* default_instance_;
-};
-
-// MutableRepeatedFieldRef definition for message types.
-template <typename T>
-class MutableRepeatedFieldRef<
-    T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
-  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
-
- public:
-  bool empty() const { return accessor_->IsEmpty(data_); }
-  int size() const { return accessor_->Size(data_); }
-  // See comments for RepeatedFieldRef<Message>::Get()
-  const T& Get(int index, T* scratch_space) const {
-    return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
-  }
-  // Create a new message of the same type as the messages stored in this
-  // repeated field. Caller takes ownership of the returned object.
-  T* NewMessage() const { return static_cast<T*>(default_instance_->New()); }
-
-  void Set(int index, const T& value) const {
-    accessor_->Set(data_, index, &value);
-  }
-  void Add(const T& value) const { accessor_->Add(data_, &value); }
-  void RemoveLast() const { accessor_->RemoveLast(data_); }
-  void SwapElements(int index1, int index2) const {
-    accessor_->SwapElements(data_, index1, index2);
-  }
-  void Clear() const { accessor_->Clear(data_); }
-
-  void Swap(const MutableRepeatedFieldRef& other) const {
-    accessor_->Swap(data_, other.accessor_, other.data_);
-  }
-
-  template <typename Container>
-  void MergeFrom(const Container& container) const {
-    typedef typename Container::const_iterator Iterator;
-    for (Iterator it = container.begin(); it != container.end(); ++it) {
-      Add(*it);
-    }
-  }
-  template <typename Container>
-  void CopyFrom(const Container& container) const {
-    Clear();
-    MergeFrom(container);
-  }
-
- private:
-  friend class Reflection;
-  MutableRepeatedFieldRef(Message* message, const FieldDescriptor* field) {
-    const Reflection* reflection = message->GetReflection();
-    data_ = reflection->RepeatedFieldData(
-        message, field, internal::RefTypeTraits<T>::cpp_type,
-        internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
-    accessor_ = reflection->RepeatedFieldAccessor(field);
-    default_instance_ =
-        reflection->GetMessageFactory()->GetPrototype(field->message_type());
-  }
-
-  void* data_;
-  const AccessorType* accessor_;
-  const Message* default_instance_;
-};
-
-namespace internal {
-// Interfaces used to implement reflection RepeatedFieldRef API.
-// Reflection::GetRepeatedAccessor() should return a pointer to an singleton
-// object that implements the below interface.
-//
-// This interface passes/returns values using void pointers. The actual type
-// of the value depends on the field's cpp_type. Following is a mapping from
-// cpp_type to the type that should be used in this interface:
-//
-//   field->cpp_type()      T                Actual type of void*
-//   CPPTYPE_INT32        int32_t                 int32_t
-//   CPPTYPE_UINT32       uint32_t                uint32_t
-//   CPPTYPE_INT64        int64_t                 int64_t
-//   CPPTYPE_UINT64       uint64_t                uint64_t
-//   CPPTYPE_DOUBLE       double                  double
-//   CPPTYPE_FLOAT        float                   float
-//   CPPTYPE_BOOL         bool                    bool
-//   CPPTYPE_ENUM         generated enum type     int32_t
-//   CPPTYPE_STRING       string                  std::string
-//   CPPTYPE_MESSAGE      generated message type  google::protobuf::Message
-//                        or google::protobuf::Message
-//
-// Note that for enums we use int32_t in the interface.
-//
-// You can map from T to the actual type using RefTypeTraits:
-//   typedef RefTypeTraits<T>::AccessorValueType ActualType;
-class PROTOBUF_EXPORT RepeatedFieldAccessor {
- public:
-  // Typedefs for clarity.
-  typedef void Field;
-  typedef void Value;
-  typedef void Iterator;
-
-  virtual bool IsEmpty(const Field* data) const = 0;
-  virtual int Size(const Field* data) const = 0;
-  // Depends on the underlying representation of the repeated field, this
-  // method can return a pointer to the underlying object if such an object
-  // exists, or fill the data into scratch_space and return scratch_space.
-  // Callers of this method must ensure scratch_space is a valid pointer
-  // to a mutable object of the correct type.
-  virtual const Value* Get(const Field* data, int index,
-                           Value* scratch_space) const = 0;
-
-  virtual void Clear(Field* data) const = 0;
-  virtual void Set(Field* data, int index, const Value* value) const = 0;
-  virtual void Add(Field* data, const Value* value) const = 0;
-  virtual void RemoveLast(Field* data) const = 0;
-  virtual void SwapElements(Field* data, int index1, int index2) const = 0;
-  virtual void Swap(Field* data, const RepeatedFieldAccessor* other_mutator,
-                    Field* other_data) const = 0;
-
-  // Create an iterator that points at the beginning of the repeated field.
-  virtual Iterator* BeginIterator(const Field* data) const = 0;
-  // Create an iterator that points at the end of the repeated field.
-  virtual Iterator* EndIterator(const Field* data) const = 0;
-  // Make a copy of an iterator and return the new copy.
-  virtual Iterator* CopyIterator(const Field* data,
-                                 const Iterator* iterator) const = 0;
-  // Move an iterator to point to the next element.
-  virtual Iterator* AdvanceIterator(const Field* data,
-                                    Iterator* iterator) const = 0;
-  // Compare whether two iterators point to the same element.
-  virtual bool EqualsIterator(const Field* data, const Iterator* a,
-                              const Iterator* b) const = 0;
-  // Delete an iterator created by BeginIterator(), EndIterator() and
-  // CopyIterator().
-  virtual void DeleteIterator(const Field* data, Iterator* iterator) const = 0;
-  // Like Get() but for iterators.
-  virtual const Value* GetIteratorValue(const Field* data,
-                                        const Iterator* iterator,
-                                        Value* scratch_space) const = 0;
-
-  // Templated methods that make using this interface easier for non-message
-  // types.
-  template <typename T>
-  T Get(const Field* data, int index) const {
-    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
-    ActualType scratch_space;
-    return static_cast<T>(*reinterpret_cast<const ActualType*>(
-        Get(data, index, static_cast<Value*>(&scratch_space))));
-  }
-
-  template <typename T, typename ValueType>
-  void Set(Field* data, int index, const ValueType& value) const {
-    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
-    // In this RepeatedFieldAccessor interface we pass/return data using
-    // raw pointers. Type of the data these raw pointers point to should
-    // be ActualType. Here we have a ValueType object and want a ActualType
-    // pointer. We can't cast a ValueType pointer to an ActualType pointer
-    // directly because their type might be different (for enums ValueType
-    // may be a generated enum type while ActualType is int32_t). To be safe
-    // we make a copy to get a temporary ActualType object and use it.
-    ActualType tmp = static_cast<ActualType>(value);
-    Set(data, index, static_cast<const Value*>(&tmp));
-  }
-
-  template <typename T, typename ValueType>
-  void Add(Field* data, const ValueType& value) const {
-    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
-    // In this RepeatedFieldAccessor interface we pass/return data using
-    // raw pointers. Type of the data these raw pointers point to should
-    // be ActualType. Here we have a ValueType object and want a ActualType
-    // pointer. We can't cast a ValueType pointer to an ActualType pointer
-    // directly because their type might be different (for enums ValueType
-    // may be a generated enum type while ActualType is int32_t). To be safe
-    // we make a copy to get a temporary ActualType object and use it.
-    ActualType tmp = static_cast<ActualType>(value);
-    Add(data, static_cast<const Value*>(&tmp));
-  }
-
- protected:
-  // We want the destructor to be completely trivial as to allow it to be
-  // a function local static. Hence we make it non-virtual and protected,
-  // this class only live as part of a global singleton and should not be
-  // deleted.
-  ~RepeatedFieldAccessor() = default;
-};
-
-// Implement (Mutable)RepeatedFieldRef::iterator
-template <typename T>
-class RepeatedFieldRefIterator {
-  typedef typename RefTypeTraits<T>::AccessorValueType AccessorValueType;
-  typedef typename RefTypeTraits<T>::IteratorValueType IteratorValueType;
-  typedef typename RefTypeTraits<T>::IteratorPointerType IteratorPointerType;
-
- public:
-  using iterator_category = std::forward_iterator_tag;
-  using value_type = T;
-  using pointer = T*;
-  using reference = T&;
-  using difference_type = std::ptrdiff_t;
-
-  // Constructor for non-message fields.
-  RepeatedFieldRefIterator(const void* data,
-                           const RepeatedFieldAccessor* accessor, bool begin)
-      : data_(data),
-        accessor_(accessor),
-        iterator_(begin ? accessor->BeginIterator(data)
-                        : accessor->EndIterator(data)),
-        // The end iterator must not be dereferenced, no need for scratch space.
-        scratch_space_(begin ? new AccessorValueType : nullptr) {}
-  // Constructor for message fields.
-  RepeatedFieldRefIterator(const void* data,
-                           const RepeatedFieldAccessor* accessor, bool begin,
-                           AccessorValueType* scratch_space)
-      : data_(data),
-        accessor_(accessor),
-        iterator_(begin ? accessor->BeginIterator(data)
-                        : accessor->EndIterator(data)),
-        scratch_space_(scratch_space) {}
-  ~RepeatedFieldRefIterator() { accessor_->DeleteIterator(data_, iterator_); }
-  RepeatedFieldRefIterator operator++(int) {
-    RepeatedFieldRefIterator tmp(*this);
-    iterator_ = accessor_->AdvanceIterator(data_, iterator_);
-    return tmp;
-  }
-  RepeatedFieldRefIterator& operator++() {
-    iterator_ = accessor_->AdvanceIterator(data_, iterator_);
-    return *this;
-  }
-  IteratorValueType operator*() const {
-    return static_cast<IteratorValueType>(
-        *static_cast<const AccessorValueType*>(accessor_->GetIteratorValue(
-            data_, iterator_, scratch_space_.get())));
-  }
-  IteratorPointerType operator->() const {
-    return static_cast<IteratorPointerType>(
-        accessor_->GetIteratorValue(data_, iterator_, scratch_space_.get()));
-  }
-  bool operator!=(const RepeatedFieldRefIterator& other) const {
-    assert(data_ == other.data_);
-    assert(accessor_ == other.accessor_);
-    return !accessor_->EqualsIterator(data_, iterator_, other.iterator_);
-  }
-  bool operator==(const RepeatedFieldRefIterator& other) const {
-    return !this->operator!=(other);
-  }
-
-  RepeatedFieldRefIterator(const RepeatedFieldRefIterator& other)
-      : data_(other.data_),
-        accessor_(other.accessor_),
-        iterator_(accessor_->CopyIterator(data_, other.iterator_)) {}
-  RepeatedFieldRefIterator& operator=(const RepeatedFieldRefIterator& other) {
-    if (this != &other) {
-      accessor_->DeleteIterator(data_, iterator_);
-      data_ = other.data_;
-      accessor_ = other.accessor_;
-      iterator_ = accessor_->CopyIterator(data_, other.iterator_);
-    }
-    return *this;
-  }
-
- protected:
-  const void* data_;
-  const RepeatedFieldAccessor* accessor_;
-  void* iterator_;
-  std::unique_ptr<AccessorValueType> scratch_space_;
-};
-
-// TypeTraits that maps the type parameter T of RepeatedFieldRef or
-// MutableRepeatedFieldRef to corresponding iterator type,
-// RepeatedFieldAccessor type, etc.
-template <typename T>
-struct PrimitiveTraits {
-  static constexpr bool is_primitive = false;
-};
-#define DEFINE_PRIMITIVE(TYPE, type)                 \
-  template <>                                        \
-  struct PrimitiveTraits<type> {                     \
-    static const bool is_primitive = true;           \
-    static const FieldDescriptor::CppType cpp_type = \
-        FieldDescriptor::CPPTYPE_##TYPE;             \
-  };
-DEFINE_PRIMITIVE(INT32, int32_t)
-DEFINE_PRIMITIVE(UINT32, uint32_t)
-DEFINE_PRIMITIVE(INT64, int64_t)
-DEFINE_PRIMITIVE(UINT64, uint64_t)
-DEFINE_PRIMITIVE(FLOAT, float)
-DEFINE_PRIMITIVE(DOUBLE, double)
-DEFINE_PRIMITIVE(BOOL, bool)
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+            template<typename T, typename Enable = void>
+            struct RefTypeTraits;
+        }  // namespace internal
+
+        template<typename T>
+        RepeatedFieldRef<T> Reflection::GetRepeatedFieldRef(
+            const Message& message, const FieldDescriptor* field
+        ) const
+        {
+            return RepeatedFieldRef<T>(message, field);
+        }
+
+        template<typename T>
+        MutableRepeatedFieldRef<T> Reflection::GetMutableRepeatedFieldRef(
+            Message* message, const FieldDescriptor* field
+        ) const
+        {
+            return MutableRepeatedFieldRef<T>(message, field);
+        }
+
+        // RepeatedFieldRef definition for non-message types.
+        template<typename T>
+        class RepeatedFieldRef<
+            T,
+            typename std::enable_if<!std::is_base_of<Message, T>::value>::type>
+        {
+            typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
+            typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+        public:
+            bool empty() const
+            {
+                return accessor_->IsEmpty(data_);
+            }
+            int size() const
+            {
+                return accessor_->Size(data_);
+            }
+            T Get(int index) const
+            {
+                return accessor_->template Get<T>(data_, index);
+            }
+
+            typedef IteratorType iterator;
+            typedef IteratorType const_iterator;
+            typedef T value_type;
+            typedef T& reference;
+            typedef const T& const_reference;
+            typedef int size_type;
+            typedef ptrdiff_t difference_type;
+
+            iterator begin() const
+            {
+                return iterator(data_, accessor_, true);
+            }
+            iterator end() const
+            {
+                return iterator(data_, accessor_, false);
+            }
+
+        private:
+            friend class Reflection;
+            RepeatedFieldRef(const Message& message, const FieldDescriptor* field)
+            {
+                const Reflection* reflection = message.GetReflection();
+                data_ = reflection->RepeatedFieldData(const_cast<Message*>(&message), field, internal::RefTypeTraits<T>::cpp_type, nullptr);
+                accessor_ = reflection->RepeatedFieldAccessor(field);
+            }
+
+            const void* data_;
+            const AccessorType* accessor_;
+        };
+
+        // MutableRepeatedFieldRef definition for non-message types.
+        template<typename T>
+        class MutableRepeatedFieldRef<
+            T,
+            typename std::enable_if<!std::is_base_of<Message, T>::value>::type>
+        {
+            typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+        public:
+            bool empty() const
+            {
+                return accessor_->IsEmpty(data_);
+            }
+            int size() const
+            {
+                return accessor_->Size(data_);
+            }
+            T Get(int index) const
+            {
+                return accessor_->template Get<T>(data_, index);
+            }
+
+            void Set(int index, const T& value) const
+            {
+                accessor_->template Set<T>(data_, index, value);
+            }
+            void Add(const T& value) const
+            {
+                accessor_->template Add<T>(data_, value);
+            }
+            void RemoveLast() const
+            {
+                accessor_->RemoveLast(data_);
+            }
+            void SwapElements(int index1, int index2) const
+            {
+                accessor_->SwapElements(data_, index1, index2);
+            }
+            void Clear() const
+            {
+                accessor_->Clear(data_);
+            }
+
+            void Swap(const MutableRepeatedFieldRef& other) const
+            {
+                accessor_->Swap(data_, other.accessor_, other.data_);
+            }
+
+            template<typename Container>
+            void MergeFrom(const Container& container) const
+            {
+                typedef typename Container::const_iterator Iterator;
+                for (Iterator it = container.begin(); it != container.end(); ++it)
+                {
+                    Add(*it);
+                }
+            }
+            template<typename Container>
+            void CopyFrom(const Container& container) const
+            {
+                Clear();
+                MergeFrom(container);
+            }
+
+        private:
+            friend class Reflection;
+            MutableRepeatedFieldRef(Message* message, const FieldDescriptor* field)
+            {
+                const Reflection* reflection = message->GetReflection();
+                data_ = reflection->RepeatedFieldData(
+                    message, field, internal::RefTypeTraits<T>::cpp_type, nullptr
+                );
+                accessor_ = reflection->RepeatedFieldAccessor(field);
+            }
+
+            void* data_;
+            const AccessorType* accessor_;
+        };
+
+        // RepeatedFieldRef definition for message types.
+        template<typename T>
+        class RepeatedFieldRef<
+            T,
+            typename std::enable_if<std::is_base_of<Message, T>::value>::type>
+        {
+            typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
+            typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+        public:
+            bool empty() const
+            {
+                return accessor_->IsEmpty(data_);
+            }
+            int size() const
+            {
+                return accessor_->Size(data_);
+            }
+            // This method returns a reference to the underlying message object if it
+            // exists. If a message object doesn't exist (e.g., data stored in serialized
+            // form), scratch_space will be filled with the data and a reference to it
+            // will be returned.
+            //
+            // Example:
+            //   RepeatedFieldRef<Message> h = ...
+            //   unique_ptr<Message> scratch_space(h.NewMessage());
+            //   const Message& item = h.Get(index, scratch_space.get());
+            const T& Get(int index, T* scratch_space) const
+            {
+                return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
+            }
+            // Create a new message of the same type as the messages stored in this
+            // repeated field. Caller takes ownership of the returned object.
+            T* NewMessage() const
+            {
+                return static_cast<T*>(default_instance_->New());
+            }
+
+            typedef IteratorType iterator;
+            typedef IteratorType const_iterator;
+            typedef T value_type;
+            typedef T& reference;
+            typedef const T& const_reference;
+            typedef int size_type;
+            typedef ptrdiff_t difference_type;
+
+            iterator begin() const
+            {
+                return iterator(data_, accessor_, true, NewMessage());
+            }
+            iterator end() const
+            {
+                // The end iterator must not be dereferenced, no need for scratch space.
+                return iterator(data_, accessor_, false, nullptr);
+            }
+
+        private:
+            friend class Reflection;
+            RepeatedFieldRef(const Message& message, const FieldDescriptor* field)
+            {
+                const Reflection* reflection = message.GetReflection();
+                data_ = reflection->RepeatedFieldData(
+                    const_cast<Message*>(&message), field, internal::RefTypeTraits<T>::cpp_type, internal::RefTypeTraits<T>::GetMessageFieldDescriptor()
+                );
+                accessor_ = reflection->RepeatedFieldAccessor(field);
+                default_instance_ =
+                    reflection->GetMessageFactory()->GetPrototype(field->message_type());
+            }
+
+            const void* data_;
+            const AccessorType* accessor_;
+            const Message* default_instance_;
+        };
+
+        // MutableRepeatedFieldRef definition for message types.
+        template<typename T>
+        class MutableRepeatedFieldRef<
+            T,
+            typename std::enable_if<std::is_base_of<Message, T>::value>::type>
+        {
+            typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+        public:
+            bool empty() const
+            {
+                return accessor_->IsEmpty(data_);
+            }
+            int size() const
+            {
+                return accessor_->Size(data_);
+            }
+            // See comments for RepeatedFieldRef<Message>::Get()
+            const T& Get(int index, T* scratch_space) const
+            {
+                return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
+            }
+            // Create a new message of the same type as the messages stored in this
+            // repeated field. Caller takes ownership of the returned object.
+            T* NewMessage() const
+            {
+                return static_cast<T*>(default_instance_->New());
+            }
+
+            void Set(int index, const T& value) const
+            {
+                accessor_->Set(data_, index, &value);
+            }
+            void Add(const T& value) const
+            {
+                accessor_->Add(data_, &value);
+            }
+            void RemoveLast() const
+            {
+                accessor_->RemoveLast(data_);
+            }
+            void SwapElements(int index1, int index2) const
+            {
+                accessor_->SwapElements(data_, index1, index2);
+            }
+            void Clear() const
+            {
+                accessor_->Clear(data_);
+            }
+
+            void Swap(const MutableRepeatedFieldRef& other) const
+            {
+                accessor_->Swap(data_, other.accessor_, other.data_);
+            }
+
+            template<typename Container>
+            void MergeFrom(const Container& container) const
+            {
+                typedef typename Container::const_iterator Iterator;
+                for (Iterator it = container.begin(); it != container.end(); ++it)
+                {
+                    Add(*it);
+                }
+            }
+            template<typename Container>
+            void CopyFrom(const Container& container) const
+            {
+                Clear();
+                MergeFrom(container);
+            }
+
+        private:
+            friend class Reflection;
+            MutableRepeatedFieldRef(Message* message, const FieldDescriptor* field)
+            {
+                const Reflection* reflection = message->GetReflection();
+                data_ = reflection->RepeatedFieldData(
+                    message, field, internal::RefTypeTraits<T>::cpp_type, internal::RefTypeTraits<T>::GetMessageFieldDescriptor()
+                );
+                accessor_ = reflection->RepeatedFieldAccessor(field);
+                default_instance_ =
+                    reflection->GetMessageFactory()->GetPrototype(field->message_type());
+            }
+
+            void* data_;
+            const AccessorType* accessor_;
+            const Message* default_instance_;
+        };
+
+        namespace internal
+        {
+            // Interfaces used to implement reflection RepeatedFieldRef API.
+            // Reflection::GetRepeatedAccessor() should return a pointer to an singleton
+            // object that implements the below interface.
+            //
+            // This interface passes/returns values using void pointers. The actual type
+            // of the value depends on the field's cpp_type. Following is a mapping from
+            // cpp_type to the type that should be used in this interface:
+            //
+            //   field->cpp_type()      T                Actual type of void*
+            //   CPPTYPE_INT32        int32_t                 int32_t
+            //   CPPTYPE_UINT32       uint32_t                uint32_t
+            //   CPPTYPE_INT64        int64_t                 int64_t
+            //   CPPTYPE_UINT64       uint64_t                uint64_t
+            //   CPPTYPE_DOUBLE       double                  double
+            //   CPPTYPE_FLOAT        float                   float
+            //   CPPTYPE_BOOL         bool                    bool
+            //   CPPTYPE_ENUM         generated enum type     int32_t
+            //   CPPTYPE_STRING       string                  std::string
+            //   CPPTYPE_MESSAGE      generated message type  google::protobuf::Message
+            //                        or google::protobuf::Message
+            //
+            // Note that for enums we use int32_t in the interface.
+            //
+            // You can map from T to the actual type using RefTypeTraits:
+            //   typedef RefTypeTraits<T>::AccessorValueType ActualType;
+            class PROTOBUF_EXPORT RepeatedFieldAccessor
+            {
+            public:
+                // Typedefs for clarity.
+                typedef void Field;
+                typedef void Value;
+                typedef void Iterator;
+
+                virtual bool IsEmpty(const Field* data) const = 0;
+                virtual int Size(const Field* data) const = 0;
+                // Depends on the underlying representation of the repeated field, this
+                // method can return a pointer to the underlying object if such an object
+                // exists, or fill the data into scratch_space and return scratch_space.
+                // Callers of this method must ensure scratch_space is a valid pointer
+                // to a mutable object of the correct type.
+                virtual const Value* Get(const Field* data, int index, Value* scratch_space) const = 0;
+
+                virtual void Clear(Field* data) const = 0;
+                virtual void Set(Field* data, int index, const Value* value) const = 0;
+                virtual void Add(Field* data, const Value* value) const = 0;
+                virtual void RemoveLast(Field* data) const = 0;
+                virtual void SwapElements(Field* data, int index1, int index2) const = 0;
+                virtual void Swap(Field* data, const RepeatedFieldAccessor* other_mutator, Field* other_data) const = 0;
+
+                // Create an iterator that points at the beginning of the repeated field.
+                virtual Iterator* BeginIterator(const Field* data) const = 0;
+                // Create an iterator that points at the end of the repeated field.
+                virtual Iterator* EndIterator(const Field* data) const = 0;
+                // Make a copy of an iterator and return the new copy.
+                virtual Iterator* CopyIterator(const Field* data, const Iterator* iterator) const = 0;
+                // Move an iterator to point to the next element.
+                virtual Iterator* AdvanceIterator(const Field* data, Iterator* iterator) const = 0;
+                // Compare whether two iterators point to the same element.
+                virtual bool EqualsIterator(const Field* data, const Iterator* a, const Iterator* b) const = 0;
+                // Delete an iterator created by BeginIterator(), EndIterator() and
+                // CopyIterator().
+                virtual void DeleteIterator(const Field* data, Iterator* iterator) const = 0;
+                // Like Get() but for iterators.
+                virtual const Value* GetIteratorValue(const Field* data, const Iterator* iterator, Value* scratch_space) const = 0;
+
+                // Templated methods that make using this interface easier for non-message
+                // types.
+                template<typename T>
+                T Get(const Field* data, int index) const
+                {
+                    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+                    ActualType scratch_space;
+                    return static_cast<T>(*reinterpret_cast<const ActualType*>(
+                        Get(data, index, static_cast<Value*>(&scratch_space))
+                    ));
+                }
+
+                template<typename T, typename ValueType>
+                void Set(Field* data, int index, const ValueType& value) const
+                {
+                    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+                    // In this RepeatedFieldAccessor interface we pass/return data using
+                    // raw pointers. Type of the data these raw pointers point to should
+                    // be ActualType. Here we have a ValueType object and want a ActualType
+                    // pointer. We can't cast a ValueType pointer to an ActualType pointer
+                    // directly because their type might be different (for enums ValueType
+                    // may be a generated enum type while ActualType is int32_t). To be safe
+                    // we make a copy to get a temporary ActualType object and use it.
+                    ActualType tmp = static_cast<ActualType>(value);
+                    Set(data, index, static_cast<const Value*>(&tmp));
+                }
+
+                template<typename T, typename ValueType>
+                void Add(Field* data, const ValueType& value) const
+                {
+                    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+                    // In this RepeatedFieldAccessor interface we pass/return data using
+                    // raw pointers. Type of the data these raw pointers point to should
+                    // be ActualType. Here we have a ValueType object and want a ActualType
+                    // pointer. We can't cast a ValueType pointer to an ActualType pointer
+                    // directly because their type might be different (for enums ValueType
+                    // may be a generated enum type while ActualType is int32_t). To be safe
+                    // we make a copy to get a temporary ActualType object and use it.
+                    ActualType tmp = static_cast<ActualType>(value);
+                    Add(data, static_cast<const Value*>(&tmp));
+                }
+
+            protected:
+                // We want the destructor to be completely trivial as to allow it to be
+                // a function local static. Hence we make it non-virtual and protected,
+                // this class only live as part of a global singleton and should not be
+                // deleted.
+                ~RepeatedFieldAccessor() = default;
+            };
+
+            // Implement (Mutable)RepeatedFieldRef::iterator
+            template<typename T>
+            class RepeatedFieldRefIterator
+            {
+                typedef typename RefTypeTraits<T>::AccessorValueType AccessorValueType;
+                typedef typename RefTypeTraits<T>::IteratorValueType IteratorValueType;
+                typedef typename RefTypeTraits<T>::IteratorPointerType IteratorPointerType;
+
+            public:
+                using iterator_category = std::forward_iterator_tag;
+                using value_type = T;
+                using pointer = T*;
+                using reference = T&;
+                using difference_type = std::ptrdiff_t;
+
+                // Constructor for non-message fields.
+                RepeatedFieldRefIterator(const void* data, const RepeatedFieldAccessor* accessor, bool begin) :
+                    data_(data),
+                    accessor_(accessor),
+                    iterator_(begin ? accessor->BeginIterator(data) : accessor->EndIterator(data)),
+                    // The end iterator must not be dereferenced, no need for scratch space.
+                    scratch_space_(begin ? new AccessorValueType : nullptr)
+                {
+                }
+                // Constructor for message fields.
+                RepeatedFieldRefIterator(const void* data, const RepeatedFieldAccessor* accessor, bool begin, AccessorValueType* scratch_space) :
+                    data_(data),
+                    accessor_(accessor),
+                    iterator_(begin ? accessor->BeginIterator(data) : accessor->EndIterator(data)),
+                    scratch_space_(scratch_space)
+                {
+                }
+                ~RepeatedFieldRefIterator()
+                {
+                    accessor_->DeleteIterator(data_, iterator_);
+                }
+                RepeatedFieldRefIterator operator++(int)
+                {
+                    RepeatedFieldRefIterator tmp(*this);
+                    iterator_ = accessor_->AdvanceIterator(data_, iterator_);
+                    return tmp;
+                }
+                RepeatedFieldRefIterator& operator++()
+                {
+                    iterator_ = accessor_->AdvanceIterator(data_, iterator_);
+                    return *this;
+                }
+                IteratorValueType operator*() const
+                {
+                    return static_cast<IteratorValueType>(
+                        *static_cast<const AccessorValueType*>(accessor_->GetIteratorValue(
+                            data_, iterator_, scratch_space_.get()
+                        ))
+                    );
+                }
+                IteratorPointerType operator->() const
+                {
+                    return static_cast<IteratorPointerType>(
+                        accessor_->GetIteratorValue(data_, iterator_, scratch_space_.get())
+                    );
+                }
+                bool operator!=(const RepeatedFieldRefIterator& other) const
+                {
+                    assert(data_ == other.data_);
+                    assert(accessor_ == other.accessor_);
+                    return !accessor_->EqualsIterator(data_, iterator_, other.iterator_);
+                }
+                bool operator==(const RepeatedFieldRefIterator& other) const
+                {
+                    return !this->operator!=(other);
+                }
+
+                RepeatedFieldRefIterator(const RepeatedFieldRefIterator& other) :
+                    data_(other.data_),
+                    accessor_(other.accessor_),
+                    iterator_(accessor_->CopyIterator(data_, other.iterator_))
+                {
+                }
+                RepeatedFieldRefIterator& operator=(const RepeatedFieldRefIterator& other)
+                {
+                    if (this != &other)
+                    {
+                        accessor_->DeleteIterator(data_, iterator_);
+                        data_ = other.data_;
+                        accessor_ = other.accessor_;
+                        iterator_ = accessor_->CopyIterator(data_, other.iterator_);
+                    }
+                    return *this;
+                }
+
+            protected:
+                const void* data_;
+                const RepeatedFieldAccessor* accessor_;
+                void* iterator_;
+                std::unique_ptr<AccessorValueType> scratch_space_;
+            };
+
+            // TypeTraits that maps the type parameter T of RepeatedFieldRef or
+            // MutableRepeatedFieldRef to corresponding iterator type,
+            // RepeatedFieldAccessor type, etc.
+            template<typename T>
+            struct PrimitiveTraits
+            {
+                static constexpr bool is_primitive = false;
+            };
+#define DEFINE_PRIMITIVE(TYPE, type)                     \
+    template<>                                           \
+    struct PrimitiveTraits<type>                         \
+    {                                                    \
+        static const bool is_primitive = true;           \
+        static const FieldDescriptor::CppType cpp_type = \
+            FieldDescriptor::CPPTYPE_##TYPE;             \
+    };
+            DEFINE_PRIMITIVE(INT32, int32_t)
+            DEFINE_PRIMITIVE(UINT32, uint32_t)
+            DEFINE_PRIMITIVE(INT64, int64_t)
+            DEFINE_PRIMITIVE(UINT64, uint64_t)
+            DEFINE_PRIMITIVE(FLOAT, float)
+            DEFINE_PRIMITIVE(DOUBLE, double)
+            DEFINE_PRIMITIVE(BOOL, bool)
 #undef DEFINE_PRIMITIVE
 
-template <typename T>
-struct RefTypeTraits<
-    T, typename std::enable_if<PrimitiveTraits<T>::is_primitive>::type> {
-  typedef RepeatedFieldRefIterator<T> iterator;
-  typedef RepeatedFieldAccessor AccessorType;
-  typedef T AccessorValueType;
-  typedef T IteratorValueType;
-  typedef T* IteratorPointerType;
-  static constexpr FieldDescriptor::CppType cpp_type =
-      PrimitiveTraits<T>::cpp_type;
-  static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
-};
-
-template <typename T>
-struct RefTypeTraits<
-    T, typename std::enable_if<is_proto_enum<T>::value>::type> {
-  typedef RepeatedFieldRefIterator<T> iterator;
-  typedef RepeatedFieldAccessor AccessorType;
-  // We use int32_t for repeated enums in RepeatedFieldAccessor.
-  typedef int32_t AccessorValueType;
-  typedef T IteratorValueType;
-  typedef int32_t* IteratorPointerType;
-  static constexpr FieldDescriptor::CppType cpp_type =
-      FieldDescriptor::CPPTYPE_ENUM;
-  static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
-};
-
-template <typename T>
-struct RefTypeTraits<
-    T, typename std::enable_if<std::is_same<std::string, T>::value>::type> {
-  typedef RepeatedFieldRefIterator<T> iterator;
-  typedef RepeatedFieldAccessor AccessorType;
-  typedef std::string AccessorValueType;
-  typedef const std::string IteratorValueType;
-  typedef const std::string* IteratorPointerType;
-  static constexpr FieldDescriptor::CppType cpp_type =
-      FieldDescriptor::CPPTYPE_STRING;
-  static const Descriptor* GetMessageFieldDescriptor() { return nullptr; }
-};
-
-template <typename T>
-struct MessageDescriptorGetter {
-  static const Descriptor* get() {
-    return T::default_instance().GetDescriptor();
-  }
-};
-template <>
-struct MessageDescriptorGetter<Message> {
-  static const Descriptor* get() { return nullptr; }
-};
-
-template <typename T>
-struct RefTypeTraits<
-    T, typename std::enable_if<std::is_base_of<Message, T>::value>::type> {
-  typedef RepeatedFieldRefIterator<T> iterator;
-  typedef RepeatedFieldAccessor AccessorType;
-  typedef Message AccessorValueType;
-  typedef const T& IteratorValueType;
-  typedef const T* IteratorPointerType;
-  static constexpr FieldDescriptor::CppType cpp_type =
-      FieldDescriptor::CPPTYPE_MESSAGE;
-  static const Descriptor* GetMessageFieldDescriptor() {
-    return MessageDescriptorGetter<T>::get();
-  }
-};
-}  // namespace internal
-}  // namespace protobuf
+            template<typename T>
+            struct RefTypeTraits<
+                T,
+                typename std::enable_if<PrimitiveTraits<T>::is_primitive>::type>
+            {
+                typedef RepeatedFieldRefIterator<T> iterator;
+                typedef RepeatedFieldAccessor AccessorType;
+                typedef T AccessorValueType;
+                typedef T IteratorValueType;
+                typedef T* IteratorPointerType;
+                static constexpr FieldDescriptor::CppType cpp_type =
+                    PrimitiveTraits<T>::cpp_type;
+                static const Descriptor* GetMessageFieldDescriptor()
+                {
+                    return nullptr;
+                }
+            };
+
+            template<typename T>
+            struct RefTypeTraits<
+                T,
+                typename std::enable_if<is_proto_enum<T>::value>::type>
+            {
+                typedef RepeatedFieldRefIterator<T> iterator;
+                typedef RepeatedFieldAccessor AccessorType;
+                // We use int32_t for repeated enums in RepeatedFieldAccessor.
+                typedef int32_t AccessorValueType;
+                typedef T IteratorValueType;
+                typedef int32_t* IteratorPointerType;
+                static constexpr FieldDescriptor::CppType cpp_type =
+                    FieldDescriptor::CPPTYPE_ENUM;
+                static const Descriptor* GetMessageFieldDescriptor()
+                {
+                    return nullptr;
+                }
+            };
+
+            template<typename T>
+            struct RefTypeTraits<
+                T,
+                typename std::enable_if<std::is_same<std::string, T>::value>::type>
+            {
+                typedef RepeatedFieldRefIterator<T> iterator;
+                typedef RepeatedFieldAccessor AccessorType;
+                typedef std::string AccessorValueType;
+                typedef const std::string IteratorValueType;
+                typedef const std::string* IteratorPointerType;
+                static constexpr FieldDescriptor::CppType cpp_type =
+                    FieldDescriptor::CPPTYPE_STRING;
+                static const Descriptor* GetMessageFieldDescriptor()
+                {
+                    return nullptr;
+                }
+            };
+
+            template<typename T>
+            struct MessageDescriptorGetter
+            {
+                static const Descriptor* get()
+                {
+                    return T::default_instance().GetDescriptor();
+                }
+            };
+            template<>
+            struct MessageDescriptorGetter<Message>
+            {
+                static const Descriptor* get()
+                {
+                    return nullptr;
+                }
+            };
+
+            template<typename T>
+            struct RefTypeTraits<
+                T,
+                typename std::enable_if<std::is_base_of<Message, T>::value>::type>
+            {
+                typedef RepeatedFieldRefIterator<T> iterator;
+                typedef RepeatedFieldAccessor AccessorType;
+                typedef Message AccessorValueType;
+                typedef const T& IteratorValueType;
+                typedef const T* IteratorPointerType;
+                static constexpr FieldDescriptor::CppType cpp_type =
+                    FieldDescriptor::CPPTYPE_MESSAGE;
+                static const Descriptor* GetMessageFieldDescriptor()
+                {
+                    return MessageDescriptorGetter<T>::get();
+                }
+            };
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/reflection_ops.h b/CAPI/cpp/grpc/include/google/protobuf/reflection_ops.h
index 0a45702..d5ca86d 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/reflection_ops.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/reflection_ops.h
@@ -48,43 +48,44 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
-// Basic operations that can be performed using reflection.
-// These can be used as a cheap way to implement the corresponding
-// methods of the Message interface, though they are likely to be
-// slower than implementations tailored for the specific message type.
-//
-// This class should stay limited to operations needed to implement
-// the Message interface.
-//
-// This class is really a namespace that contains only static methods.
-class PROTOBUF_EXPORT ReflectionOps {
- public:
-  static void Copy(const Message& from, Message* to);
-  static void Merge(const Message& from, Message* to);
-  static void Clear(Message* message);
-  static bool IsInitialized(const Message& message);
-  static bool IsInitialized(const Message& message, bool check_fields,
-                            bool check_descendants);
-  static void DiscardUnknownFields(Message* message);
+            // Basic operations that can be performed using reflection.
+            // These can be used as a cheap way to implement the corresponding
+            // methods of the Message interface, though they are likely to be
+            // slower than implementations tailored for the specific message type.
+            //
+            // This class should stay limited to operations needed to implement
+            // the Message interface.
+            //
+            // This class is really a namespace that contains only static methods.
+            class PROTOBUF_EXPORT ReflectionOps
+            {
+            public:
+                static void Copy(const Message& from, Message* to);
+                static void Merge(const Message& from, Message* to);
+                static void Clear(Message* message);
+                static bool IsInitialized(const Message& message);
+                static bool IsInitialized(const Message& message, bool check_fields, bool check_descendants);
+                static void DiscardUnknownFields(Message* message);
 
-  // Finds all unset required fields in the message and adds their full
-  // paths (e.g. "foo.bar[5].baz") to *names.  "prefix" will be attached to
-  // the front of each name.
-  static void FindInitializationErrors(const Message& message,
-                                       const std::string& prefix,
-                                       std::vector<std::string>* errors);
+                // Finds all unset required fields in the message and adds their full
+                // paths (e.g. "foo.bar[5].baz") to *names.  "prefix" will be attached to
+                // the front of each name.
+                static void FindInitializationErrors(const Message& message, const std::string& prefix, std::vector<std::string>* errors);
 
- private:
-  // All methods are static.  No need to construct.
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ReflectionOps);
-};
+            private:
+                // All methods are static.  No need to construct.
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ReflectionOps);
+            };
 
-}  // namespace internal
-}  // namespace protobuf
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/repeated_field.h b/CAPI/cpp/grpc/include/google/protobuf/repeated_field.h
index 3fb734e..e43d646 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/repeated_field.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/repeated_field.h
@@ -44,7 +44,6 @@
 #ifndef GOOGLE_PROTOBUF_REPEATED_FIELD_H__
 #define GOOGLE_PROTOBUF_REPEATED_FIELD_H__
 
-
 #include <algorithm>
 #include <iterator>
 #include <limits>
@@ -59,7 +58,6 @@
 #include <google/protobuf/message_lite.h>
 #include <google/protobuf/repeated_ptr_field.h>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
@@ -67,1151 +65,1349 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-class Message;
-
-namespace internal {
-
-template <typename T, int kRepHeaderSize>
-constexpr int RepeatedFieldLowerClampLimit() {
-  // The header is padded to be at least `sizeof(T)` when it would be smaller
-  // otherwise.
-  static_assert(sizeof(T) <= kRepHeaderSize, "");
-  // We want to pad the minimum size to be a power of two bytes, including the
-  // header.
-  // The first allocation is kRepHeaderSize bytes worth of elements for a total
-  // of 2*kRepHeaderSize bytes.
-  // For an 8-byte header, we allocate 8 bool, 2 ints, or 1 int64.
-  return kRepHeaderSize / sizeof(T);
-}
-
-// kRepeatedFieldUpperClampLimit is the lowest signed integer value that
-// overflows when multiplied by 2 (which is undefined behavior). Sizes above
-// this will clamp to the maximum int value instead of following exponential
-// growth when growing a repeated field.
-constexpr int kRepeatedFieldUpperClampLimit =
-    (std::numeric_limits<int>::max() / 2) + 1;
-
-template <typename Iter>
-inline int CalculateReserve(Iter begin, Iter end, std::forward_iterator_tag) {
-  return static_cast<int>(std::distance(begin, end));
-}
-
-template <typename Iter>
-inline int CalculateReserve(Iter /*begin*/, Iter /*end*/,
-                            std::input_iterator_tag /*unused*/) {
-  return -1;
-}
-
-template <typename Iter>
-inline int CalculateReserve(Iter begin, Iter end) {
-  typedef typename std::iterator_traits<Iter>::iterator_category Category;
-  return CalculateReserve(begin, end, Category());
-}
-
-// Swaps two blocks of memory of size sizeof(T).
-template <typename T>
-inline void SwapBlock(char* p, char* q) {
-  T tmp;
-  memcpy(&tmp, p, sizeof(T));
-  memcpy(p, q, sizeof(T));
-  memcpy(q, &tmp, sizeof(T));
-}
-
-// Swaps two blocks of memory of size kSize:
-//  template <int kSize> void memswap(char* p, char* q);
-template <int kSize>
-inline typename std::enable_if<(kSize == 0), void>::type memswap(char*, char*) {
-}
-
-#define PROTO_MEMSWAP_DEF_SIZE(reg_type, max_size)                           \
-  template <int kSize>                                                       \
-  typename std::enable_if<(kSize >= sizeof(reg_type) && kSize < (max_size)), \
-                          void>::type                                        \
-  memswap(char* p, char* q) {                                                \
-    SwapBlock<reg_type>(p, q);                                               \
-    memswap<kSize - sizeof(reg_type)>(p + sizeof(reg_type),                  \
-                                      q + sizeof(reg_type));                 \
-  }
-
-PROTO_MEMSWAP_DEF_SIZE(uint8_t, 2)
-PROTO_MEMSWAP_DEF_SIZE(uint16_t, 4)
-PROTO_MEMSWAP_DEF_SIZE(uint32_t, 8)
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Message;
+
+        namespace internal
+        {
+
+            template<typename T, int kRepHeaderSize>
+            constexpr int RepeatedFieldLowerClampLimit()
+            {
+                // The header is padded to be at least `sizeof(T)` when it would be smaller
+                // otherwise.
+                static_assert(sizeof(T) <= kRepHeaderSize, "");
+                // We want to pad the minimum size to be a power of two bytes, including the
+                // header.
+                // The first allocation is kRepHeaderSize bytes worth of elements for a total
+                // of 2*kRepHeaderSize bytes.
+                // For an 8-byte header, we allocate 8 bool, 2 ints, or 1 int64.
+                return kRepHeaderSize / sizeof(T);
+            }
+
+            // kRepeatedFieldUpperClampLimit is the lowest signed integer value that
+            // overflows when multiplied by 2 (which is undefined behavior). Sizes above
+            // this will clamp to the maximum int value instead of following exponential
+            // growth when growing a repeated field.
+            constexpr int kRepeatedFieldUpperClampLimit =
+                (std::numeric_limits<int>::max() / 2) + 1;
+
+            template<typename Iter>
+            inline int CalculateReserve(Iter begin, Iter end, std::forward_iterator_tag)
+            {
+                return static_cast<int>(std::distance(begin, end));
+            }
+
+            template<typename Iter>
+            inline int CalculateReserve(Iter /*begin*/, Iter /*end*/, std::input_iterator_tag /*unused*/)
+            {
+                return -1;
+            }
+
+            template<typename Iter>
+            inline int CalculateReserve(Iter begin, Iter end)
+            {
+                typedef typename std::iterator_traits<Iter>::iterator_category Category;
+                return CalculateReserve(begin, end, Category());
+            }
+
+            // Swaps two blocks of memory of size sizeof(T).
+            template<typename T>
+            inline void SwapBlock(char* p, char* q)
+            {
+                T tmp;
+                memcpy(&tmp, p, sizeof(T));
+                memcpy(p, q, sizeof(T));
+                memcpy(q, &tmp, sizeof(T));
+            }
+
+            // Swaps two blocks of memory of size kSize:
+            //  template <int kSize> void memswap(char* p, char* q);
+            template<int kSize>
+            inline typename std::enable_if<(kSize == 0), void>::type memswap(char*, char*)
+            {
+            }
+
+#define PROTO_MEMSWAP_DEF_SIZE(reg_type, max_size)                                         \
+    template<int kSize>                                                                    \
+    typename std::enable_if<(kSize >= sizeof(reg_type) && kSize < (max_size)), void>::type \
+        memswap(char* p, char* q)                                                          \
+    {                                                                                      \
+        SwapBlock<reg_type>(p, q);                                                         \
+        memswap<kSize - sizeof(reg_type)>(p + sizeof(reg_type), q + sizeof(reg_type));     \
+    }
+
+            PROTO_MEMSWAP_DEF_SIZE(uint8_t, 2)
+            PROTO_MEMSWAP_DEF_SIZE(uint16_t, 4)
+            PROTO_MEMSWAP_DEF_SIZE(uint32_t, 8)
 
 #ifdef __SIZEOF_INT128__
-PROTO_MEMSWAP_DEF_SIZE(uint64_t, 16)
-PROTO_MEMSWAP_DEF_SIZE(__uint128_t, (1u << 31))
+            PROTO_MEMSWAP_DEF_SIZE(uint64_t, 16)
+            PROTO_MEMSWAP_DEF_SIZE(__uint128_t, (1u << 31))
 #else
-PROTO_MEMSWAP_DEF_SIZE(uint64_t, (1u << 31))
+            PROTO_MEMSWAP_DEF_SIZE(uint64_t, (1u << 31))
 #endif
 
 #undef PROTO_MEMSWAP_DEF_SIZE
 
-template <typename Element>
-class RepeatedIterator;
-
-}  // namespace internal
-
-// RepeatedField is used to represent repeated fields of a primitive type (in
-// other words, everything except strings and nested Messages).  Most users will
-// not ever use a RepeatedField directly; they will use the get-by-index,
-// set-by-index, and add accessors that are generated for all repeated fields.
-template <typename Element>
-class RepeatedField final {
-  static_assert(
-      alignof(Arena) >= alignof(Element),
-      "We only support types that have an alignment smaller than Arena");
-
- public:
-  constexpr RepeatedField();
-  explicit RepeatedField(Arena* arena);
-
-  RepeatedField(const RepeatedField& other);
-
-  template <typename Iter,
-            typename = typename std::enable_if<std::is_constructible<
-                Element, decltype(*std::declval<Iter>())>::value>::type>
-  RepeatedField(Iter begin, Iter end);
-
-  ~RepeatedField();
-
-  RepeatedField& operator=(const RepeatedField& other);
-
-  RepeatedField(RepeatedField&& other) noexcept;
-  RepeatedField& operator=(RepeatedField&& other) noexcept;
-
-  bool empty() const;
-  int size() const;
-
-  const Element& Get(int index) const;
-  Element* Mutable(int index);
-
-  const Element& operator[](int index) const { return Get(index); }
-  Element& operator[](int index) { return *Mutable(index); }
-
-  const Element& at(int index) const;
-  Element& at(int index);
-
-  void Set(int index, const Element& value);
-  void Add(const Element& value);
-  // Appends a new element and returns a pointer to it.
-  // The new element is uninitialized if |Element| is a POD type.
-  Element* Add();
-  // Appends elements in the range [begin, end) after reserving
-  // the appropriate number of elements.
-  template <typename Iter>
-  void Add(Iter begin, Iter end);
-
-  // Removes the last element in the array.
-  void RemoveLast();
-
-  // Extracts elements with indices in "[start .. start+num-1]".
-  // Copies them into "elements[0 .. num-1]" if "elements" is not nullptr.
-  // Caution: also moves elements with indices [start+num ..].
-  // Calling this routine inside a loop can cause quadratic behavior.
-  void ExtractSubrange(int start, int num, Element* elements);
-
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear();
-  void MergeFrom(const RepeatedField& other);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void CopyFrom(const RepeatedField& other);
-
-  // Replaces the contents with RepeatedField(begin, end).
-  template <typename Iter>
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Assign(Iter begin, Iter end);
-
-  // Reserves space to expand the field to at least the given size.  If the
-  // array is grown, it will always be at least doubled in size.
-  void Reserve(int new_size);
-
-  // Resizes the RepeatedField to a new, smaller size.  This is O(1).
-  void Truncate(int new_size);
-
-  void AddAlreadyReserved(const Element& value);
-  // Appends a new element and return a pointer to it.
-  // The new element is uninitialized if |Element| is a POD type.
-  // Should be called only if Capacity() > Size().
-  Element* AddAlreadyReserved();
-  Element* AddNAlreadyReserved(int elements);
-  int Capacity() const;
-
-  // Like STL resize.  Uses value to fill appended elements.
-  // Like Truncate() if new_size <= size(), otherwise this is
-  // O(new_size - size()).
-  void Resize(int new_size, const Element& value);
-
-  // Gets the underlying array.  This pointer is possibly invalidated by
-  // any add or remove operation.
-  Element* mutable_data();
-  const Element* data() const;
-
-  // Swaps entire contents with "other". If they are separate arenas then,
-  // copies data between each other.
-  void Swap(RepeatedField* other);
-
-  // Swaps entire contents with "other". Should be called only if the caller can
-  // guarantee that both repeated fields are on the same arena or are on the
-  // heap. Swapping between different arenas is disallowed and caught by a
-  // GOOGLE_DCHECK (see API docs for details).
-  void UnsafeArenaSwap(RepeatedField* other);
-
-  // Swaps two elements.
-  void SwapElements(int index1, int index2);
-
-  // STL-like iterator support
-  typedef internal::RepeatedIterator<Element> iterator;
-  typedef internal::RepeatedIterator<const Element> const_iterator;
-  typedef Element value_type;
-  typedef value_type& reference;
-  typedef const value_type& const_reference;
-  typedef value_type* pointer;
-  typedef const value_type* const_pointer;
-  typedef int size_type;
-  typedef ptrdiff_t difference_type;
-
-  iterator begin();
-  const_iterator begin() const;
-  const_iterator cbegin() const;
-  iterator end();
-  const_iterator end() const;
-  const_iterator cend() const;
-
-  // Reverse iterator support
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef std::reverse_iterator<iterator> reverse_iterator;
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  // Returns the number of bytes used by the repeated field, excluding
-  // sizeof(*this)
-  size_t SpaceUsedExcludingSelfLong() const;
-
-  int SpaceUsedExcludingSelf() const {
-    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
-  }
-
-  // Removes the element referenced by position.
-  //
-  // Returns an iterator to the element immediately following the removed
-  // element.
-  //
-  // Invalidates all iterators at or after the removed element, including end().
-  iterator erase(const_iterator position);
-
-  // Removes the elements in the range [first, last).
-  //
-  // Returns an iterator to the element immediately following the removed range.
-  //
-  // Invalidates all iterators at or after the removed range, including end().
-  iterator erase(const_iterator first, const_iterator last);
-
-  // Gets the Arena on which this RepeatedField stores its elements.
-  inline Arena* GetArena() const {
-    return GetOwningArena();
-  }
-
-  // For internal use only.
-  //
-  // This is public due to it being called by generated code.
-  inline void InternalSwap(RepeatedField* other);
-
- private:
-  template <typename T> friend class Arena::InternalHelper;
-
-  // Gets the Arena on which this RepeatedField stores its elements.
-  inline Arena* GetOwningArena() const {
-    return (total_size_ == 0) ? static_cast<Arena*>(arena_or_elements_)
-                              : rep()->arena;
-  }
-
-  static constexpr int kInitialSize = 0;
-  // A note on the representation here (see also comment below for
-  // RepeatedPtrFieldBase's struct Rep):
-  //
-  // We maintain the same sizeof(RepeatedField) as before we added arena support
-  // so that we do not degrade performance by bloating memory usage. Directly
-  // adding an arena_ element to RepeatedField is quite costly. By using
-  // indirection in this way, we keep the same size when the RepeatedField is
-  // empty (common case), and add only an 8-byte header to the elements array
-  // when non-empty. We make sure to place the size fields directly in the
-  // RepeatedField class to avoid costly cache misses due to the indirection.
-  int current_size_;
-  int total_size_;
-  // Pad the Rep after arena allow for power-of-two byte sizes when
-  // sizeof(Element) > sizeof(Arena*). eg for 16-byte objects.
-  static PROTOBUF_CONSTEXPR const size_t kRepHeaderSize =
-      sizeof(Arena*) < sizeof(Element) ? sizeof(Element) : sizeof(Arena*);
-  struct Rep {
-    Arena* arena;
-    Element* elements() {
-      return reinterpret_cast<Element*>(reinterpret_cast<char*>(this) +
-                                        kRepHeaderSize);
-    }
-  };
-
-  // If total_size_ == 0 this points to an Arena otherwise it points to the
-  // elements member of a Rep struct. Using this invariant allows the storage of
-  // the arena pointer without an extra allocation in the constructor.
-  void* arena_or_elements_;
-
-  // Returns a pointer to elements array.
-  // pre-condition: the array must have been allocated.
-  Element* elements() const {
-    GOOGLE_DCHECK_GT(total_size_, 0);
-    // Because of above pre-condition this cast is safe.
-    return unsafe_elements();
-  }
-
-  // Returns a pointer to elements array if it exists; otherwise either null or
-  // an invalid pointer is returned. This only happens for empty repeated
-  // fields, where you can't dereference this pointer anyway (it's empty).
-  Element* unsafe_elements() const {
-    return static_cast<Element*>(arena_or_elements_);
-  }
-
-  // Returns a pointer to the Rep struct.
-  // pre-condition: the Rep must have been allocated, ie elements() is safe.
-  Rep* rep() const {
-    return reinterpret_cast<Rep*>(reinterpret_cast<char*>(elements()) -
-                                  kRepHeaderSize);
-  }
-
-  friend class Arena;
-  typedef void InternalArenaConstructable_;
-
-  // Moves the contents of |from| into |to|, possibly clobbering |from| in the
-  // process.  For primitive types this is just a memcpy(), but it could be
-  // specialized for non-primitive types to, say, swap each element instead.
-  void MoveArray(Element* to, Element* from, int size);
-
-  // Copies the elements of |from| into |to|.
-  void CopyArray(Element* to, const Element* from, int size);
-
-  // Internal helper to delete all elements and deallocate the storage.
-  void InternalDeallocate(Rep* rep, int size, bool in_destructor) {
-    if (rep != nullptr) {
-      Element* e = &rep->elements()[0];
-      if (!std::is_trivial<Element>::value) {
-        Element* limit = &rep->elements()[size];
-        for (; e < limit; e++) {
-          e->~Element();
+            template<typename Element>
+            class RepeatedIterator;
+
+        }  // namespace internal
+
+        // RepeatedField is used to represent repeated fields of a primitive type (in
+        // other words, everything except strings and nested Messages).  Most users will
+        // not ever use a RepeatedField directly; they will use the get-by-index,
+        // set-by-index, and add accessors that are generated for all repeated fields.
+        template<typename Element>
+        class RepeatedField final
+        {
+            static_assert(
+                alignof(Arena) >= alignof(Element),
+                "We only support types that have an alignment smaller than Arena"
+            );
+
+        public:
+            constexpr RepeatedField();
+            explicit RepeatedField(Arena* arena);
+
+            RepeatedField(const RepeatedField& other);
+
+            template<typename Iter, typename = typename std::enable_if<std::is_constructible<Element, decltype(*std::declval<Iter>())>::value>::type>
+            RepeatedField(Iter begin, Iter end);
+
+            ~RepeatedField();
+
+            RepeatedField& operator=(const RepeatedField& other);
+
+            RepeatedField(RepeatedField&& other) noexcept;
+            RepeatedField& operator=(RepeatedField&& other) noexcept;
+
+            bool empty() const;
+            int size() const;
+
+            const Element& Get(int index) const;
+            Element* Mutable(int index);
+
+            const Element& operator[](int index) const
+            {
+                return Get(index);
+            }
+            Element& operator[](int index)
+            {
+                return *Mutable(index);
+            }
+
+            const Element& at(int index) const;
+            Element& at(int index);
+
+            void Set(int index, const Element& value);
+            void Add(const Element& value);
+            // Appends a new element and returns a pointer to it.
+            // The new element is uninitialized if |Element| is a POD type.
+            Element* Add();
+            // Appends elements in the range [begin, end) after reserving
+            // the appropriate number of elements.
+            template<typename Iter>
+            void Add(Iter begin, Iter end);
+
+            // Removes the last element in the array.
+            void RemoveLast();
+
+            // Extracts elements with indices in "[start .. start+num-1]".
+            // Copies them into "elements[0 .. num-1]" if "elements" is not nullptr.
+            // Caution: also moves elements with indices [start+num ..].
+            // Calling this routine inside a loop can cause quadratic behavior.
+            void ExtractSubrange(int start, int num, Element* elements);
+
+            PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear();
+            void MergeFrom(const RepeatedField& other);
+            PROTOBUF_ATTRIBUTE_REINITIALIZES void CopyFrom(const RepeatedField& other);
+
+            // Replaces the contents with RepeatedField(begin, end).
+            template<typename Iter>
+            PROTOBUF_ATTRIBUTE_REINITIALIZES void Assign(Iter begin, Iter end);
+
+            // Reserves space to expand the field to at least the given size.  If the
+            // array is grown, it will always be at least doubled in size.
+            void Reserve(int new_size);
+
+            // Resizes the RepeatedField to a new, smaller size.  This is O(1).
+            void Truncate(int new_size);
+
+            void AddAlreadyReserved(const Element& value);
+            // Appends a new element and return a pointer to it.
+            // The new element is uninitialized if |Element| is a POD type.
+            // Should be called only if Capacity() > Size().
+            Element* AddAlreadyReserved();
+            Element* AddNAlreadyReserved(int elements);
+            int Capacity() const;
+
+            // Like STL resize.  Uses value to fill appended elements.
+            // Like Truncate() if new_size <= size(), otherwise this is
+            // O(new_size - size()).
+            void Resize(int new_size, const Element& value);
+
+            // Gets the underlying array.  This pointer is possibly invalidated by
+            // any add or remove operation.
+            Element* mutable_data();
+            const Element* data() const;
+
+            // Swaps entire contents with "other". If they are separate arenas then,
+            // copies data between each other.
+            void Swap(RepeatedField* other);
+
+            // Swaps entire contents with "other". Should be called only if the caller can
+            // guarantee that both repeated fields are on the same arena or are on the
+            // heap. Swapping between different arenas is disallowed and caught by a
+            // GOOGLE_DCHECK (see API docs for details).
+            void UnsafeArenaSwap(RepeatedField* other);
+
+            // Swaps two elements.
+            void SwapElements(int index1, int index2);
+
+            // STL-like iterator support
+            typedef internal::RepeatedIterator<Element> iterator;
+            typedef internal::RepeatedIterator<const Element> const_iterator;
+            typedef Element value_type;
+            typedef value_type& reference;
+            typedef const value_type& const_reference;
+            typedef value_type* pointer;
+            typedef const value_type* const_pointer;
+            typedef int size_type;
+            typedef ptrdiff_t difference_type;
+
+            iterator begin();
+            const_iterator begin() const;
+            const_iterator cbegin() const;
+            iterator end();
+            const_iterator end() const;
+            const_iterator cend() const;
+
+            // Reverse iterator support
+            typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+            typedef std::reverse_iterator<iterator> reverse_iterator;
+            reverse_iterator rbegin()
+            {
+                return reverse_iterator(end());
+            }
+            const_reverse_iterator rbegin() const
+            {
+                return const_reverse_iterator(end());
+            }
+            reverse_iterator rend()
+            {
+                return reverse_iterator(begin());
+            }
+            const_reverse_iterator rend() const
+            {
+                return const_reverse_iterator(begin());
+            }
+
+            // Returns the number of bytes used by the repeated field, excluding
+            // sizeof(*this)
+            size_t SpaceUsedExcludingSelfLong() const;
+
+            int SpaceUsedExcludingSelf() const
+            {
+                return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+            }
+
+            // Removes the element referenced by position.
+            //
+            // Returns an iterator to the element immediately following the removed
+            // element.
+            //
+            // Invalidates all iterators at or after the removed element, including end().
+            iterator erase(const_iterator position);
+
+            // Removes the elements in the range [first, last).
+            //
+            // Returns an iterator to the element immediately following the removed range.
+            //
+            // Invalidates all iterators at or after the removed range, including end().
+            iterator erase(const_iterator first, const_iterator last);
+
+            // Gets the Arena on which this RepeatedField stores its elements.
+            inline Arena* GetArena() const
+            {
+                return GetOwningArena();
+            }
+
+            // For internal use only.
+            //
+            // This is public due to it being called by generated code.
+            inline void InternalSwap(RepeatedField* other);
+
+        private:
+            template<typename T>
+            friend class Arena::InternalHelper;
+
+            // Gets the Arena on which this RepeatedField stores its elements.
+            inline Arena* GetOwningArena() const
+            {
+                return (total_size_ == 0) ? static_cast<Arena*>(arena_or_elements_) : rep()->arena;
+            }
+
+            static constexpr int kInitialSize = 0;
+            // A note on the representation here (see also comment below for
+            // RepeatedPtrFieldBase's struct Rep):
+            //
+            // We maintain the same sizeof(RepeatedField) as before we added arena support
+            // so that we do not degrade performance by bloating memory usage. Directly
+            // adding an arena_ element to RepeatedField is quite costly. By using
+            // indirection in this way, we keep the same size when the RepeatedField is
+            // empty (common case), and add only an 8-byte header to the elements array
+            // when non-empty. We make sure to place the size fields directly in the
+            // RepeatedField class to avoid costly cache misses due to the indirection.
+            int current_size_;
+            int total_size_;
+            // Pad the Rep after arena allow for power-of-two byte sizes when
+            // sizeof(Element) > sizeof(Arena*). eg for 16-byte objects.
+            static PROTOBUF_CONSTEXPR const size_t kRepHeaderSize =
+                sizeof(Arena*) < sizeof(Element) ? sizeof(Element) : sizeof(Arena*);
+            struct Rep
+            {
+                Arena* arena;
+                Element* elements()
+                {
+                    return reinterpret_cast<Element*>(reinterpret_cast<char*>(this) + kRepHeaderSize);
+                }
+            };
+
+            // If total_size_ == 0 this points to an Arena otherwise it points to the
+            // elements member of a Rep struct. Using this invariant allows the storage of
+            // the arena pointer without an extra allocation in the constructor.
+            void* arena_or_elements_;
+
+            // Returns a pointer to elements array.
+            // pre-condition: the array must have been allocated.
+            Element* elements() const
+            {
+                GOOGLE_DCHECK_GT(total_size_, 0);
+                // Because of above pre-condition this cast is safe.
+                return unsafe_elements();
+            }
+
+            // Returns a pointer to elements array if it exists; otherwise either null or
+            // an invalid pointer is returned. This only happens for empty repeated
+            // fields, where you can't dereference this pointer anyway (it's empty).
+            Element* unsafe_elements() const
+            {
+                return static_cast<Element*>(arena_or_elements_);
+            }
+
+            // Returns a pointer to the Rep struct.
+            // pre-condition: the Rep must have been allocated, ie elements() is safe.
+            Rep* rep() const
+            {
+                return reinterpret_cast<Rep*>(reinterpret_cast<char*>(elements()) - kRepHeaderSize);
+            }
+
+            friend class Arena;
+            typedef void InternalArenaConstructable_;
+
+            // Moves the contents of |from| into |to|, possibly clobbering |from| in the
+            // process.  For primitive types this is just a memcpy(), but it could be
+            // specialized for non-primitive types to, say, swap each element instead.
+            void MoveArray(Element* to, Element* from, int size);
+
+            // Copies the elements of |from| into |to|.
+            void CopyArray(Element* to, const Element* from, int size);
+
+            // Internal helper to delete all elements and deallocate the storage.
+            void InternalDeallocate(Rep* rep, int size, bool in_destructor)
+            {
+                if (rep != nullptr)
+                {
+                    Element* e = &rep->elements()[0];
+                    if (!std::is_trivial<Element>::value)
+                    {
+                        Element* limit = &rep->elements()[size];
+                        for (; e < limit; e++)
+                        {
+                            e->~Element();
+                        }
+                    }
+                    const size_t bytes = size * sizeof(*e) + kRepHeaderSize;
+                    if (rep->arena == nullptr)
+                    {
+                        internal::SizedDelete(rep, bytes);
+                    }
+                    else if (!in_destructor)
+                    {
+                        // If we are in the destructor, we might be being destroyed as part of
+                        // the arena teardown. We can't try and return blocks to the arena then.
+                        rep->arena->ReturnArrayMemory(rep, bytes);
+                    }
+                }
+            }
+
+            // This class is a performance wrapper around RepeatedField::Add(const T&)
+            // function. In general unless a RepeatedField is a local stack variable LLVM
+            // has a hard time optimizing Add. The machine code tends to be
+            // loop:
+            // mov %size, dword ptr [%repeated_field]       // load
+            // cmp %size, dword ptr [%repeated_field + 4]
+            // jae fallback
+            // mov %buffer, qword ptr [%repeated_field + 8]
+            // mov dword [%buffer + %size * 4], %value
+            // inc %size                                    // increment
+            // mov dword ptr [%repeated_field], %size       // store
+            // jmp loop
+            //
+            // This puts a load/store in each iteration of the important loop variable
+            // size. It's a pretty bad compile that happens even in simple cases, but
+            // largely the presence of the fallback path disturbs the compilers mem-to-reg
+            // analysis.
+            //
+            // This class takes ownership of a repeated field for the duration of its
+            // lifetime. The repeated field should not be accessed during this time, ie.
+            // only access through this class is allowed. This class should always be a
+            // function local stack variable. Intended use
+            //
+            // void AddSequence(const int* begin, const int* end, RepeatedField<int>* out)
+            // {
+            //   RepeatedFieldAdder<int> adder(out);  // Take ownership of out
+            //   for (auto it = begin; it != end; ++it) {
+            //     adder.Add(*it);
+            //   }
+            // }
+            //
+            // Typically, due to the fact that adder is a local stack variable, the
+            // compiler will be successful in mem-to-reg transformation and the machine
+            // code will be loop: cmp %size, %capacity jae fallback mov dword ptr [%buffer
+            // + %size * 4], %val inc %size jmp loop
+            //
+            // The first version executes at 7 cycles per iteration while the second
+            // version executes at only 1 or 2 cycles.
+            template<int = 0, bool = std::is_trivial<Element>::value>
+            class FastAdderImpl
+            {
+            public:
+                explicit FastAdderImpl(RepeatedField* rf) :
+                    repeated_field_(rf)
+                {
+                    index_ = repeated_field_->current_size_;
+                    capacity_ = repeated_field_->total_size_;
+                    buffer_ = repeated_field_->unsafe_elements();
+                }
+                ~FastAdderImpl()
+                {
+                    repeated_field_->current_size_ = index_;
+                }
+
+                void Add(Element val)
+                {
+                    if (index_ == capacity_)
+                    {
+                        repeated_field_->current_size_ = index_;
+                        repeated_field_->Reserve(index_ + 1);
+                        capacity_ = repeated_field_->total_size_;
+                        buffer_ = repeated_field_->unsafe_elements();
+                    }
+                    buffer_[index_++] = val;
+                }
+
+            private:
+                RepeatedField* repeated_field_;
+                int index_;
+                int capacity_;
+                Element* buffer_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastAdderImpl);
+            };
+
+            // FastAdder is a wrapper for adding fields. The specialization above handles
+            // POD types more efficiently than RepeatedField.
+            template<int I>
+            class FastAdderImpl<I, false>
+            {
+            public:
+                explicit FastAdderImpl(RepeatedField* rf) :
+                    repeated_field_(rf)
+                {
+                }
+                void Add(const Element& val)
+                {
+                    repeated_field_->Add(val);
+                }
+
+            private:
+                RepeatedField* repeated_field_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastAdderImpl);
+            };
+
+            using FastAdder = FastAdderImpl<>;
+
+            friend class TestRepeatedFieldHelper;
+            friend class ::google::protobuf::internal::ParseContext;
+        };
+
+        namespace internal
+        {
+
+            // This is a helper template to copy an array of elements efficiently when they
+            // have a trivial copy constructor, and correctly otherwise. This really
+            // shouldn't be necessary, but our compiler doesn't optimize std::copy very
+            // effectively.
+            template<typename Element, bool HasTrivialCopy = std::is_trivial<Element>::value>
+            struct ElementCopier
+            {
+                void operator()(Element* to, const Element* from, int array_size);
+            };
+
+        }  // namespace internal
+
+        // implementation ====================================================
+
+        template<typename Element>
+        constexpr RepeatedField<Element>::RepeatedField() :
+            current_size_(0),
+            total_size_(0),
+            arena_or_elements_(nullptr)
+        {
+        }
+
+        template<typename Element>
+        inline RepeatedField<Element>::RepeatedField(Arena* arena) :
+            current_size_(0),
+            total_size_(0),
+            arena_or_elements_(arena)
+        {
+        }
+
+        template<typename Element>
+        inline RepeatedField<Element>::RepeatedField(const RepeatedField& other) :
+            current_size_(0),
+            total_size_(0),
+            arena_or_elements_(nullptr)
+        {
+            if (other.current_size_ != 0)
+            {
+                Reserve(other.size());
+                AddNAlreadyReserved(other.size());
+                CopyArray(Mutable(0), &other.Get(0), other.size());
+            }
+        }
+
+        template<typename Element>
+        template<typename Iter, typename>
+        RepeatedField<Element>::RepeatedField(Iter begin, Iter end) :
+            current_size_(0),
+            total_size_(0),
+            arena_or_elements_(nullptr)
+        {
+            Add(begin, end);
         }
-      }
-      const size_t bytes = size * sizeof(*e) + kRepHeaderSize;
-      if (rep->arena == nullptr) {
-        internal::SizedDelete(rep, bytes);
-      } else if (!in_destructor) {
-        // If we are in the destructor, we might be being destroyed as part of
-        // the arena teardown. We can't try and return blocks to the arena then.
-        rep->arena->ReturnArrayMemory(rep, bytes);
-      }
-    }
-  }
-
-  // This class is a performance wrapper around RepeatedField::Add(const T&)
-  // function. In general unless a RepeatedField is a local stack variable LLVM
-  // has a hard time optimizing Add. The machine code tends to be
-  // loop:
-  // mov %size, dword ptr [%repeated_field]       // load
-  // cmp %size, dword ptr [%repeated_field + 4]
-  // jae fallback
-  // mov %buffer, qword ptr [%repeated_field + 8]
-  // mov dword [%buffer + %size * 4], %value
-  // inc %size                                    // increment
-  // mov dword ptr [%repeated_field], %size       // store
-  // jmp loop
-  //
-  // This puts a load/store in each iteration of the important loop variable
-  // size. It's a pretty bad compile that happens even in simple cases, but
-  // largely the presence of the fallback path disturbs the compilers mem-to-reg
-  // analysis.
-  //
-  // This class takes ownership of a repeated field for the duration of its
-  // lifetime. The repeated field should not be accessed during this time, ie.
-  // only access through this class is allowed. This class should always be a
-  // function local stack variable. Intended use
-  //
-  // void AddSequence(const int* begin, const int* end, RepeatedField<int>* out)
-  // {
-  //   RepeatedFieldAdder<int> adder(out);  // Take ownership of out
-  //   for (auto it = begin; it != end; ++it) {
-  //     adder.Add(*it);
-  //   }
-  // }
-  //
-  // Typically, due to the fact that adder is a local stack variable, the
-  // compiler will be successful in mem-to-reg transformation and the machine
-  // code will be loop: cmp %size, %capacity jae fallback mov dword ptr [%buffer
-  // + %size * 4], %val inc %size jmp loop
-  //
-  // The first version executes at 7 cycles per iteration while the second
-  // version executes at only 1 or 2 cycles.
-  template <int = 0, bool = std::is_trivial<Element>::value>
-  class FastAdderImpl {
-   public:
-    explicit FastAdderImpl(RepeatedField* rf) : repeated_field_(rf) {
-      index_ = repeated_field_->current_size_;
-      capacity_ = repeated_field_->total_size_;
-      buffer_ = repeated_field_->unsafe_elements();
-    }
-    ~FastAdderImpl() { repeated_field_->current_size_ = index_; }
-
-    void Add(Element val) {
-      if (index_ == capacity_) {
-        repeated_field_->current_size_ = index_;
-        repeated_field_->Reserve(index_ + 1);
-        capacity_ = repeated_field_->total_size_;
-        buffer_ = repeated_field_->unsafe_elements();
-      }
-      buffer_[index_++] = val;
-    }
 
-   private:
-    RepeatedField* repeated_field_;
-    int index_;
-    int capacity_;
-    Element* buffer_;
-
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastAdderImpl);
-  };
-
-  // FastAdder is a wrapper for adding fields. The specialization above handles
-  // POD types more efficiently than RepeatedField.
-  template <int I>
-  class FastAdderImpl<I, false> {
-   public:
-    explicit FastAdderImpl(RepeatedField* rf) : repeated_field_(rf) {}
-    void Add(const Element& val) { repeated_field_->Add(val); }
-
-   private:
-    RepeatedField* repeated_field_;
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastAdderImpl);
-  };
-
-  using FastAdder = FastAdderImpl<>;
-
-  friend class TestRepeatedFieldHelper;
-  friend class ::google::protobuf::internal::ParseContext;
-};
-
-namespace internal {
-
-// This is a helper template to copy an array of elements efficiently when they
-// have a trivial copy constructor, and correctly otherwise. This really
-// shouldn't be necessary, but our compiler doesn't optimize std::copy very
-// effectively.
-template <typename Element,
-          bool HasTrivialCopy = std::is_trivial<Element>::value>
-struct ElementCopier {
-  void operator()(Element* to, const Element* from, int array_size);
-};
-
-}  // namespace internal
-
-// implementation ====================================================
-
-template <typename Element>
-constexpr RepeatedField<Element>::RepeatedField()
-    : current_size_(0), total_size_(0), arena_or_elements_(nullptr) {}
-
-template <typename Element>
-inline RepeatedField<Element>::RepeatedField(Arena* arena)
-    : current_size_(0), total_size_(0), arena_or_elements_(arena) {}
-
-template <typename Element>
-inline RepeatedField<Element>::RepeatedField(const RepeatedField& other)
-    : current_size_(0), total_size_(0), arena_or_elements_(nullptr) {
-  if (other.current_size_ != 0) {
-    Reserve(other.size());
-    AddNAlreadyReserved(other.size());
-    CopyArray(Mutable(0), &other.Get(0), other.size());
-  }
-}
-
-template <typename Element>
-template <typename Iter, typename>
-RepeatedField<Element>::RepeatedField(Iter begin, Iter end)
-    : current_size_(0), total_size_(0), arena_or_elements_(nullptr) {
-  Add(begin, end);
-}
-
-template <typename Element>
-RepeatedField<Element>::~RepeatedField() {
+        template<typename Element>
+        RepeatedField<Element>::~RepeatedField()
+        {
 #ifndef NDEBUG
-  // Try to trigger segfault / asan failure in non-opt builds if arena_
-  // lifetime has ended before the destructor.
-  auto arena = GetOwningArena();
-  if (arena) (void)arena->SpaceAllocated();
+            // Try to trigger segfault / asan failure in non-opt builds if arena_
+            // lifetime has ended before the destructor.
+            auto arena = GetOwningArena();
+            if (arena)
+                (void)arena->SpaceAllocated();
 #endif
-  if (total_size_ > 0) {
-    InternalDeallocate(rep(), total_size_, true);
-  }
-}
-
-template <typename Element>
-inline RepeatedField<Element>& RepeatedField<Element>::operator=(
-    const RepeatedField& other) {
-  if (this != &other) CopyFrom(other);
-  return *this;
-}
-
-template <typename Element>
-inline RepeatedField<Element>::RepeatedField(RepeatedField&& other) noexcept
-    : RepeatedField() {
+            if (total_size_ > 0)
+            {
+                InternalDeallocate(rep(), total_size_, true);
+            }
+        }
+
+        template<typename Element>
+        inline RepeatedField<Element>& RepeatedField<Element>::operator=(
+            const RepeatedField& other
+        )
+        {
+            if (this != &other)
+                CopyFrom(other);
+            return *this;
+        }
+
+        template<typename Element>
+        inline RepeatedField<Element>::RepeatedField(RepeatedField&& other) noexcept
+            :
+            RepeatedField()
+        {
 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-  CopyFrom(other);
+            CopyFrom(other);
 #else   // PROTOBUF_FORCE_COPY_IN_MOVE
-  // We don't just call Swap(&other) here because it would perform 3 copies if
-  // other is on an arena. This field can't be on an arena because arena
-  // construction always uses the Arena* accepting constructor.
-  if (other.GetOwningArena()) {
-    CopyFrom(other);
-  } else {
-    InternalSwap(&other);
-  }
+        // We don't just call Swap(&other) here because it would perform 3 copies if
+        // other is on an arena. This field can't be on an arena because arena
+        // construction always uses the Arena* accepting constructor.
+            if (other.GetOwningArena())
+            {
+                CopyFrom(other);
+            }
+            else
+            {
+                InternalSwap(&other);
+            }
 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-}
-
-template <typename Element>
-inline RepeatedField<Element>& RepeatedField<Element>::operator=(
-    RepeatedField&& other) noexcept {
-  // We don't just call Swap(&other) here because it would perform 3 copies if
-  // the two fields are on different arenas.
-  if (this != &other) {
-    if (GetOwningArena() != other.GetOwningArena()
+        }
+
+        template<typename Element>
+        inline RepeatedField<Element>& RepeatedField<Element>::operator=(
+            RepeatedField&& other
+        ) noexcept
+        {
+            // We don't just call Swap(&other) here because it would perform 3 copies if
+            // the two fields are on different arenas.
+            if (this != &other)
+            {
+                if (GetOwningArena() != other.GetOwningArena()
 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        || GetOwningArena() == nullptr
+                    || GetOwningArena() == nullptr
 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      CopyFrom(other);
-    } else {
-      InternalSwap(&other);
-    }
-  }
-  return *this;
-}
-
-template <typename Element>
-inline bool RepeatedField<Element>::empty() const {
-  return current_size_ == 0;
-}
-
-template <typename Element>
-inline int RepeatedField<Element>::size() const {
-  return current_size_;
-}
-
-template <typename Element>
-inline int RepeatedField<Element>::Capacity() const {
-  return total_size_;
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::AddAlreadyReserved(const Element& value) {
-  GOOGLE_DCHECK_LT(current_size_, total_size_);
-  elements()[current_size_++] = value;
-}
-
-template <typename Element>
-inline Element* RepeatedField<Element>::AddAlreadyReserved() {
-  GOOGLE_DCHECK_LT(current_size_, total_size_);
-  return &elements()[current_size_++];
-}
-
-template <typename Element>
-inline Element* RepeatedField<Element>::AddNAlreadyReserved(int elements) {
-  GOOGLE_DCHECK_GE(total_size_ - current_size_, elements)
-      << total_size_ << ", " << current_size_;
-  // Warning: sometimes people call this when elements == 0 and
-  // total_size_ == 0. In this case the return pointer points to a zero size
-  // array (n == 0). Hence we can just use unsafe_elements(), because the user
-  // cannot dereference the pointer anyway.
-  Element* ret = unsafe_elements() + current_size_;
-  current_size_ += elements;
-  return ret;
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::Resize(int new_size, const Element& value) {
-  GOOGLE_DCHECK_GE(new_size, 0);
-  if (new_size > current_size_) {
-    Reserve(new_size);
-    std::fill(&elements()[current_size_], &elements()[new_size], value);
-  }
-  current_size_ = new_size;
-}
-
-template <typename Element>
-inline const Element& RepeatedField<Element>::Get(int index) const {
-  GOOGLE_DCHECK_GE(index, 0);
-  GOOGLE_DCHECK_LT(index, current_size_);
-  return elements()[index];
-}
-
-template <typename Element>
-inline const Element& RepeatedField<Element>::at(int index) const {
-  GOOGLE_CHECK_GE(index, 0);
-  GOOGLE_CHECK_LT(index, current_size_);
-  return elements()[index];
-}
-
-template <typename Element>
-inline Element& RepeatedField<Element>::at(int index) {
-  GOOGLE_CHECK_GE(index, 0);
-  GOOGLE_CHECK_LT(index, current_size_);
-  return elements()[index];
-}
-
-template <typename Element>
-inline Element* RepeatedField<Element>::Mutable(int index) {
-  GOOGLE_DCHECK_GE(index, 0);
-  GOOGLE_DCHECK_LT(index, current_size_);
-  return &elements()[index];
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::Set(int index, const Element& value) {
-  GOOGLE_DCHECK_GE(index, 0);
-  GOOGLE_DCHECK_LT(index, current_size_);
-  elements()[index] = value;
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::Add(const Element& value) {
-  uint32_t size = current_size_;
-  if (static_cast<int>(size) == total_size_) {
-    // value could reference an element of the array. Reserving new space will
-    // invalidate the reference. So we must make a copy first.
-    auto tmp = value;
-    Reserve(total_size_ + 1);
-    elements()[size] = std::move(tmp);
-  } else {
-    elements()[size] = value;
-  }
-  current_size_ = size + 1;
-}
-
-template <typename Element>
-inline Element* RepeatedField<Element>::Add() {
-  uint32_t size = current_size_;
-  if (static_cast<int>(size) == total_size_) Reserve(total_size_ + 1);
-  auto ptr = &elements()[size];
-  current_size_ = size + 1;
-  return ptr;
-}
-
-template <typename Element>
-template <typename Iter>
-inline void RepeatedField<Element>::Add(Iter begin, Iter end) {
-  int reserve = internal::CalculateReserve(begin, end);
-  if (reserve != -1) {
-    if (reserve == 0) {
-      return;
-    }
+                )
+                {
+                    CopyFrom(other);
+                }
+                else
+                {
+                    InternalSwap(&other);
+                }
+            }
+            return *this;
+        }
+
+        template<typename Element>
+        inline bool RepeatedField<Element>::empty() const
+        {
+            return current_size_ == 0;
+        }
+
+        template<typename Element>
+        inline int RepeatedField<Element>::size() const
+        {
+            return current_size_;
+        }
+
+        template<typename Element>
+        inline int RepeatedField<Element>::Capacity() const
+        {
+            return total_size_;
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::AddAlreadyReserved(const Element& value)
+        {
+            GOOGLE_DCHECK_LT(current_size_, total_size_);
+            elements()[current_size_++] = value;
+        }
+
+        template<typename Element>
+        inline Element* RepeatedField<Element>::AddAlreadyReserved()
+        {
+            GOOGLE_DCHECK_LT(current_size_, total_size_);
+            return &elements()[current_size_++];
+        }
+
+        template<typename Element>
+        inline Element* RepeatedField<Element>::AddNAlreadyReserved(int elements)
+        {
+            GOOGLE_DCHECK_GE(total_size_ - current_size_, elements)
+                << total_size_ << ", " << current_size_;
+            // Warning: sometimes people call this when elements == 0 and
+            // total_size_ == 0. In this case the return pointer points to a zero size
+            // array (n == 0). Hence we can just use unsafe_elements(), because the user
+            // cannot dereference the pointer anyway.
+            Element* ret = unsafe_elements() + current_size_;
+            current_size_ += elements;
+            return ret;
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::Resize(int new_size, const Element& value)
+        {
+            GOOGLE_DCHECK_GE(new_size, 0);
+            if (new_size > current_size_)
+            {
+                Reserve(new_size);
+                std::fill(&elements()[current_size_], &elements()[new_size], value);
+            }
+            current_size_ = new_size;
+        }
+
+        template<typename Element>
+        inline const Element& RepeatedField<Element>::Get(int index) const
+        {
+            GOOGLE_DCHECK_GE(index, 0);
+            GOOGLE_DCHECK_LT(index, current_size_);
+            return elements()[index];
+        }
+
+        template<typename Element>
+        inline const Element& RepeatedField<Element>::at(int index) const
+        {
+            GOOGLE_CHECK_GE(index, 0);
+            GOOGLE_CHECK_LT(index, current_size_);
+            return elements()[index];
+        }
+
+        template<typename Element>
+        inline Element& RepeatedField<Element>::at(int index)
+        {
+            GOOGLE_CHECK_GE(index, 0);
+            GOOGLE_CHECK_LT(index, current_size_);
+            return elements()[index];
+        }
+
+        template<typename Element>
+        inline Element* RepeatedField<Element>::Mutable(int index)
+        {
+            GOOGLE_DCHECK_GE(index, 0);
+            GOOGLE_DCHECK_LT(index, current_size_);
+            return &elements()[index];
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::Set(int index, const Element& value)
+        {
+            GOOGLE_DCHECK_GE(index, 0);
+            GOOGLE_DCHECK_LT(index, current_size_);
+            elements()[index] = value;
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::Add(const Element& value)
+        {
+            uint32_t size = current_size_;
+            if (static_cast<int>(size) == total_size_)
+            {
+                // value could reference an element of the array. Reserving new space will
+                // invalidate the reference. So we must make a copy first.
+                auto tmp = value;
+                Reserve(total_size_ + 1);
+                elements()[size] = std::move(tmp);
+            }
+            else
+            {
+                elements()[size] = value;
+            }
+            current_size_ = size + 1;
+        }
+
+        template<typename Element>
+        inline Element* RepeatedField<Element>::Add()
+        {
+            uint32_t size = current_size_;
+            if (static_cast<int>(size) == total_size_)
+                Reserve(total_size_ + 1);
+            auto ptr = &elements()[size];
+            current_size_ = size + 1;
+            return ptr;
+        }
 
-    Reserve(reserve + size());
-    // TODO(ckennelly):  The compiler loses track of the buffer freshly
-    // allocated by Reserve() by the time we call elements, so it cannot
-    // guarantee that elements does not alias [begin(), end()).
-    //
-    // If restrict is available, annotating the pointer obtained from elements()
-    // causes this to lower to memcpy instead of memmove.
-    std::copy(begin, end, elements() + size());
-    current_size_ = reserve + size();
-  } else {
-    FastAdder fast_adder(this);
-    for (; begin != end; ++begin) fast_adder.Add(*begin);
-  }
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::RemoveLast() {
-  GOOGLE_DCHECK_GT(current_size_, 0);
-  current_size_--;
-}
-
-template <typename Element>
-void RepeatedField<Element>::ExtractSubrange(int start, int num,
-                                             Element* elements) {
-  GOOGLE_DCHECK_GE(start, 0);
-  GOOGLE_DCHECK_GE(num, 0);
-  GOOGLE_DCHECK_LE(start + num, this->current_size_);
-
-  // Save the values of the removed elements if requested.
-  if (elements != nullptr) {
-    for (int i = 0; i < num; ++i) elements[i] = this->Get(i + start);
-  }
-
-  // Slide remaining elements down to fill the gap.
-  if (num > 0) {
-    for (int i = start + num; i < this->current_size_; ++i)
-      this->Set(i - num, this->Get(i));
-    this->Truncate(this->current_size_ - num);
-  }
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::Clear() {
-  current_size_ = 0;
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::MergeFrom(const RepeatedField& other) {
-  GOOGLE_DCHECK_NE(&other, this);
-  if (other.current_size_ != 0) {
-    int existing_size = size();
-    Reserve(existing_size + other.size());
-    AddNAlreadyReserved(other.size());
-    CopyArray(Mutable(existing_size), &other.Get(0), other.size());
-  }
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
-  if (&other == this) return;
-  Clear();
-  MergeFrom(other);
-}
-
-template <typename Element>
-template <typename Iter>
-inline void RepeatedField<Element>::Assign(Iter begin, Iter end) {
-  Clear();
-  Add(begin, end);
-}
-
-template <typename Element>
-inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
-    const_iterator position) {
-  return erase(position, position + 1);
-}
-
-template <typename Element>
-inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
-    const_iterator first, const_iterator last) {
-  size_type first_offset = first - cbegin();
-  if (first != last) {
-    Truncate(std::copy(last, cend(), begin() + first_offset) - cbegin());
-  }
-  return begin() + first_offset;
-}
-
-template <typename Element>
-inline Element* RepeatedField<Element>::mutable_data() {
-  return unsafe_elements();
-}
-
-template <typename Element>
-inline const Element* RepeatedField<Element>::data() const {
-  return unsafe_elements();
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::InternalSwap(RepeatedField* other) {
-  GOOGLE_DCHECK(this != other);
-
-  // Swap all fields at once.
-  static_assert(std::is_standard_layout<RepeatedField<Element>>::value,
-                "offsetof() requires standard layout before c++17");
-  internal::memswap<offsetof(RepeatedField, arena_or_elements_) +
-                    sizeof(this->arena_or_elements_) -
-                    offsetof(RepeatedField, current_size_)>(
-      reinterpret_cast<char*>(this) + offsetof(RepeatedField, current_size_),
-      reinterpret_cast<char*>(other) + offsetof(RepeatedField, current_size_));
-}
-
-template <typename Element>
-void RepeatedField<Element>::Swap(RepeatedField* other) {
-  if (this == other) return;
+        template<typename Element>
+        template<typename Iter>
+        inline void RepeatedField<Element>::Add(Iter begin, Iter end)
+        {
+            int reserve = internal::CalculateReserve(begin, end);
+            if (reserve != -1)
+            {
+                if (reserve == 0)
+                {
+                    return;
+                }
+
+                Reserve(reserve + size());
+                // TODO(ckennelly):  The compiler loses track of the buffer freshly
+                // allocated by Reserve() by the time we call elements, so it cannot
+                // guarantee that elements does not alias [begin(), end()).
+                //
+                // If restrict is available, annotating the pointer obtained from elements()
+                // causes this to lower to memcpy instead of memmove.
+                std::copy(begin, end, elements() + size());
+                current_size_ = reserve + size();
+            }
+            else
+            {
+                FastAdder fast_adder(this);
+                for (; begin != end; ++begin)
+                    fast_adder.Add(*begin);
+            }
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::RemoveLast()
+        {
+            GOOGLE_DCHECK_GT(current_size_, 0);
+            current_size_--;
+        }
+
+        template<typename Element>
+        void RepeatedField<Element>::ExtractSubrange(int start, int num, Element* elements)
+        {
+            GOOGLE_DCHECK_GE(start, 0);
+            GOOGLE_DCHECK_GE(num, 0);
+            GOOGLE_DCHECK_LE(start + num, this->current_size_);
+
+            // Save the values of the removed elements if requested.
+            if (elements != nullptr)
+            {
+                for (int i = 0; i < num; ++i)
+                    elements[i] = this->Get(i + start);
+            }
+
+            // Slide remaining elements down to fill the gap.
+            if (num > 0)
+            {
+                for (int i = start + num; i < this->current_size_; ++i)
+                    this->Set(i - num, this->Get(i));
+                this->Truncate(this->current_size_ - num);
+            }
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::Clear()
+        {
+            current_size_ = 0;
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::MergeFrom(const RepeatedField& other)
+        {
+            GOOGLE_DCHECK_NE(&other, this);
+            if (other.current_size_ != 0)
+            {
+                int existing_size = size();
+                Reserve(existing_size + other.size());
+                AddNAlreadyReserved(other.size());
+                CopyArray(Mutable(existing_size), &other.Get(0), other.size());
+            }
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other)
+        {
+            if (&other == this)
+                return;
+            Clear();
+            MergeFrom(other);
+        }
+
+        template<typename Element>
+        template<typename Iter>
+        inline void RepeatedField<Element>::Assign(Iter begin, Iter end)
+        {
+            Clear();
+            Add(begin, end);
+        }
+
+        template<typename Element>
+        inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
+            const_iterator position
+        )
+        {
+            return erase(position, position + 1);
+        }
+
+        template<typename Element>
+        inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
+            const_iterator first, const_iterator last
+        )
+        {
+            size_type first_offset = first - cbegin();
+            if (first != last)
+            {
+                Truncate(std::copy(last, cend(), begin() + first_offset) - cbegin());
+            }
+            return begin() + first_offset;
+        }
+
+        template<typename Element>
+        inline Element* RepeatedField<Element>::mutable_data()
+        {
+            return unsafe_elements();
+        }
+
+        template<typename Element>
+        inline const Element* RepeatedField<Element>::data() const
+        {
+            return unsafe_elements();
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::InternalSwap(RepeatedField* other)
+        {
+            GOOGLE_DCHECK(this != other);
+
+            // Swap all fields at once.
+            static_assert(std::is_standard_layout<RepeatedField<Element>>::value, "offsetof() requires standard layout before c++17");
+            internal::memswap<offsetof(RepeatedField, arena_or_elements_) + sizeof(this->arena_or_elements_) - offsetof(RepeatedField, current_size_)>(
+                reinterpret_cast<char*>(this) + offsetof(RepeatedField, current_size_),
+                reinterpret_cast<char*>(other) + offsetof(RepeatedField, current_size_)
+            );
+        }
+
+        template<typename Element>
+        void RepeatedField<Element>::Swap(RepeatedField* other)
+        {
+            if (this == other)
+                return;
 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-  if (GetOwningArena() != nullptr &&
-      GetOwningArena() == other->GetOwningArena()) {
+            if (GetOwningArena() != nullptr &&
+                GetOwningArena() == other->GetOwningArena())
+            {
 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
-  if (GetOwningArena() == other->GetOwningArena()) {
+            if (GetOwningArena() == other->GetOwningArena())
+            {
 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-    InternalSwap(other);
-  } else {
-    RepeatedField<Element> temp(other->GetOwningArena());
-    temp.MergeFrom(*this);
-    CopyFrom(*other);
-    other->UnsafeArenaSwap(&temp);
-  }
-}
-
-template <typename Element>
-void RepeatedField<Element>::UnsafeArenaSwap(RepeatedField* other) {
-  if (this == other) return;
-  GOOGLE_DCHECK_EQ(GetOwningArena(), other->GetOwningArena());
-  InternalSwap(other);
-}
-
-template <typename Element>
-void RepeatedField<Element>::SwapElements(int index1, int index2) {
-  using std::swap;  // enable ADL with fallback
-  swap(elements()[index1], elements()[index2]);
-}
-
-template <typename Element>
-inline typename RepeatedField<Element>::iterator
-RepeatedField<Element>::begin() {
-  return iterator(unsafe_elements());
-}
-template <typename Element>
-inline typename RepeatedField<Element>::const_iterator
-RepeatedField<Element>::begin() const {
-  return const_iterator(unsafe_elements());
-}
-template <typename Element>
-inline typename RepeatedField<Element>::const_iterator
-RepeatedField<Element>::cbegin() const {
-  return const_iterator(unsafe_elements());
-}
-template <typename Element>
-inline typename RepeatedField<Element>::iterator RepeatedField<Element>::end() {
-  return iterator(unsafe_elements() + current_size_);
-}
-template <typename Element>
-inline typename RepeatedField<Element>::const_iterator
-RepeatedField<Element>::end() const {
-  return const_iterator(unsafe_elements() + current_size_);
-}
-template <typename Element>
-inline typename RepeatedField<Element>::const_iterator
-RepeatedField<Element>::cend() const {
-  return const_iterator(unsafe_elements() + current_size_);
-}
-
-template <typename Element>
-inline size_t RepeatedField<Element>::SpaceUsedExcludingSelfLong() const {
-  return total_size_ > 0 ? (total_size_ * sizeof(Element) + kRepHeaderSize) : 0;
-}
-
-namespace internal {
-// Returns the new size for a reserved field based on its 'total_size' and the
-// requested 'new_size'. The result is clamped to the closed interval:
-//   [internal::kMinRepeatedFieldAllocationSize,
-//    std::numeric_limits<int>::max()]
-// Requires:
-//     new_size > total_size &&
-//     (total_size == 0 ||
-//      total_size >= kRepeatedFieldLowerClampLimit)
-template <typename T, int kRepHeaderSize>
-inline int CalculateReserveSize(int total_size, int new_size) {
-  constexpr int lower_limit = RepeatedFieldLowerClampLimit<T, kRepHeaderSize>();
-  if (new_size < lower_limit) {
-    // Clamp to smallest allowed size.
-    return lower_limit;
-  }
-  constexpr int kMaxSizeBeforeClamp =
-      (std::numeric_limits<int>::max() - kRepHeaderSize) / 2;
-  if (PROTOBUF_PREDICT_FALSE(total_size > kMaxSizeBeforeClamp)) {
-    return std::numeric_limits<int>::max();
-  }
-  // We want to double the number of bytes, not the number of elements, to try
-  // to stay within power-of-two allocations.
-  // The allocation has kRepHeaderSize + sizeof(T) * capacity.
-  int doubled_size = 2 * total_size + kRepHeaderSize / sizeof(T);
-  return std::max(doubled_size, new_size);
-}
-}  // namespace internal
-
-// Avoid inlining of Reserve(): new, copy, and delete[] lead to a significant
-// amount of code bloat.
-template <typename Element>
-void RepeatedField<Element>::Reserve(int new_size) {
-  if (total_size_ >= new_size) return;
-  Rep* old_rep = total_size_ > 0 ? rep() : nullptr;
-  Rep* new_rep;
-  Arena* arena = GetOwningArena();
-
-  new_size = internal::CalculateReserveSize<Element, kRepHeaderSize>(
-      total_size_, new_size);
-
-  GOOGLE_DCHECK_LE(
-      static_cast<size_t>(new_size),
-      (std::numeric_limits<size_t>::max() - kRepHeaderSize) / sizeof(Element))
-      << "Requested size is too large to fit into size_t.";
-  size_t bytes =
-      kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
-  if (arena == nullptr) {
-    new_rep = static_cast<Rep*>(::operator new(bytes));
-  } else {
-    new_rep = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
-  }
-  new_rep->arena = arena;
-  int old_total_size = total_size_;
-  // Already known: new_size >= internal::kMinRepeatedFieldAllocationSize
-  // Maintain invariant:
-  //     total_size_ == 0 ||
-  //     total_size_ >= internal::kMinRepeatedFieldAllocationSize
-  total_size_ = new_size;
-  arena_or_elements_ = new_rep->elements();
-  // Invoke placement-new on newly allocated elements. We shouldn't have to do
-  // this, since Element is supposed to be POD, but a previous version of this
-  // code allocated storage with "new Element[size]" and some code uses
-  // RepeatedField with non-POD types, relying on constructor invocation. If
-  // Element has a trivial constructor (e.g., int32_t), gcc (tested with -O2)
-  // completely removes this loop because the loop body is empty, so this has no
-  // effect unless its side-effects are required for correctness.
-  // Note that we do this before MoveArray() below because Element's copy
-  // assignment implementation will want an initialized instance first.
-  Element* e = &elements()[0];
-  Element* limit = e + total_size_;
-  for (; e < limit; e++) {
-    new (e) Element;
-  }
-  if (current_size_ > 0) {
-    MoveArray(&elements()[0], old_rep->elements(), current_size_);
-  }
-
-  // Likewise, we need to invoke destructors on the old array.
-  InternalDeallocate(old_rep, old_total_size, false);
-
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::Truncate(int new_size) {
-  GOOGLE_DCHECK_LE(new_size, current_size_);
-  if (current_size_ > 0) {
-    current_size_ = new_size;
-  }
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::MoveArray(Element* to, Element* from,
-                                              int array_size) {
-  CopyArray(to, from, array_size);
-}
-
-template <typename Element>
-inline void RepeatedField<Element>::CopyArray(Element* to, const Element* from,
-                                              int array_size) {
-  internal::ElementCopier<Element>()(to, from, array_size);
-}
-
-namespace internal {
-
-template <typename Element, bool HasTrivialCopy>
-void ElementCopier<Element, HasTrivialCopy>::operator()(Element* to,
-                                                        const Element* from,
-                                                        int array_size) {
-  std::copy(from, from + array_size, to);
-}
-
-template <typename Element>
-struct ElementCopier<Element, true> {
-  void operator()(Element* to, const Element* from, int array_size) {
-    memcpy(to, from, static_cast<size_t>(array_size) * sizeof(Element));
-  }
-};
-
-}  // namespace internal
-
-
-// -------------------------------------------------------------------
-
-// Iterators and helper functions that follow the spirit of the STL
-// std::back_insert_iterator and std::back_inserter but are tailor-made
-// for RepeatedField and RepeatedPtrField. Typical usage would be:
-//
-//   std::copy(some_sequence.begin(), some_sequence.end(),
-//             RepeatedFieldBackInserter(proto.mutable_sequence()));
-//
-// Ported by johannes from util/gtl/proto-array-iterators.h
+                InternalSwap(other);
+            }
+            else
+            {
+                RepeatedField<Element> temp(other->GetOwningArena());
+                temp.MergeFrom(*this);
+                CopyFrom(*other);
+                other->UnsafeArenaSwap(&temp);
+            }
+        }
 
-namespace internal {
+        template<typename Element>
+        void RepeatedField<Element>::UnsafeArenaSwap(RepeatedField* other)
+        {
+            if (this == other)
+                return;
+            GOOGLE_DCHECK_EQ(GetOwningArena(), other->GetOwningArena());
+            InternalSwap(other);
+        }
 
-// STL-like iterator implementation for RepeatedField.  You should not
-// refer to this class directly; use RepeatedField<T>::iterator instead.
-//
-// Note: All of the iterator operators *must* be inlined to avoid performance
-// regressions.  This is caused by the extern template declarations below (which
-// are required because of the RepeatedField extern template declarations).  If
-// any of these functions aren't explicitly inlined (e.g. defined in the class),
-// the compiler isn't allowed to inline them.
-template <typename Element>
-class RepeatedIterator {
- public:
-  using iterator_category = std::random_access_iterator_tag;
-  // Note: remove_const is necessary for std::partial_sum, which uses value_type
-  // to determine the summation variable type.
-  using value_type = typename std::remove_const<Element>::type;
-  using difference_type = std::ptrdiff_t;
-  using pointer = Element*;
-  using reference = Element&;
-
-  constexpr RepeatedIterator() noexcept : it_(nullptr) {}
-
-  // Allows "upcasting" from RepeatedIterator<T**> to
-  // RepeatedIterator<const T*const*>.
-  template <typename OtherElement,
-            typename std::enable_if<std::is_convertible<
-                OtherElement*, pointer>::value>::type* = nullptr>
-  constexpr RepeatedIterator(
-      const RepeatedIterator<OtherElement>& other) noexcept
-      : it_(other.it_) {}
-
-  // dereferenceable
-  constexpr reference operator*() const noexcept { return *it_; }
-  constexpr pointer operator->() const noexcept { return it_; }
-
- private:
-  // Helper alias to hide the internal type.
-  using iterator = RepeatedIterator<Element>;
-
- public:
-  // {inc,dec}rementable
-  iterator& operator++() noexcept {
-    ++it_;
-    return *this;
-  }
-  iterator operator++(int) noexcept { return iterator(it_++); }
-  iterator& operator--() noexcept {
-    --it_;
-    return *this;
-  }
-  iterator operator--(int) noexcept { return iterator(it_--); }
-
-  // equality_comparable
-  friend constexpr bool operator==(const iterator& x,
-                                   const iterator& y) noexcept {
-    return x.it_ == y.it_;
-  }
-  friend constexpr bool operator!=(const iterator& x,
-                                   const iterator& y) noexcept {
-    return x.it_ != y.it_;
-  }
-
-  // less_than_comparable
-  friend constexpr bool operator<(const iterator& x,
-                                  const iterator& y) noexcept {
-    return x.it_ < y.it_;
-  }
-  friend constexpr bool operator<=(const iterator& x,
-                                   const iterator& y) noexcept {
-    return x.it_ <= y.it_;
-  }
-  friend constexpr bool operator>(const iterator& x,
-                                  const iterator& y) noexcept {
-    return x.it_ > y.it_;
-  }
-  friend constexpr bool operator>=(const iterator& x,
-                                   const iterator& y) noexcept {
-    return x.it_ >= y.it_;
-  }
-
-  // addable, subtractable
-  iterator& operator+=(difference_type d) noexcept {
-    it_ += d;
-    return *this;
-  }
-  constexpr iterator operator+(difference_type d) const noexcept {
-    return iterator(it_ + d);
-  }
-  friend constexpr iterator operator+(const difference_type d,
-                                      iterator it) noexcept {
-    return it + d;
-  }
-
-  iterator& operator-=(difference_type d) noexcept {
-    it_ -= d;
-    return *this;
-  }
-  iterator constexpr operator-(difference_type d) const noexcept {
-    return iterator(it_ - d);
-  }
-
-  // indexable
-  constexpr reference operator[](difference_type d) const noexcept {
-    return it_[d];
-  }
-
-  // random access iterator
-  friend constexpr difference_type operator-(iterator it1,
-                                             iterator it2) noexcept {
-    return it1.it_ - it2.it_;
-  }
-
- private:
-  template <typename OtherElement>
-  friend class RepeatedIterator;
-
-  // Allow construction from RepeatedField.
-  friend class RepeatedField<value_type>;
-  explicit RepeatedIterator(Element* it) noexcept : it_(it) {}
-
-  // The internal iterator.
-  Element* it_;
-};
-
-// A back inserter for RepeatedField objects.
-template <typename T>
-class RepeatedFieldBackInsertIterator {
- public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = T;
-  using pointer = void;
-  using reference = void;
-  using difference_type = std::ptrdiff_t;
-
-  explicit RepeatedFieldBackInsertIterator(
-      RepeatedField<T>* const mutable_field)
-      : field_(mutable_field) {}
-  RepeatedFieldBackInsertIterator<T>& operator=(const T& value) {
-    field_->Add(value);
-    return *this;
-  }
-  RepeatedFieldBackInsertIterator<T>& operator*() { return *this; }
-  RepeatedFieldBackInsertIterator<T>& operator++() { return *this; }
-  RepeatedFieldBackInsertIterator<T>& operator++(int /* unused */) {
-    return *this;
-  }
-
- private:
-  RepeatedField<T>* field_;
-};
-
-}  // namespace internal
-
-// Provides a back insert iterator for RepeatedField instances,
-// similar to std::back_inserter().
-template <typename T>
-internal::RepeatedFieldBackInsertIterator<T> RepeatedFieldBackInserter(
-    RepeatedField<T>* const mutable_field) {
-  return internal::RepeatedFieldBackInsertIterator<T>(mutable_field);
-}
-
-// Extern declarations of common instantiations to reduce library bloat.
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<bool>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<int32_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<uint32_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<int64_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<uint64_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<float>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<double>;
-
-namespace internal {
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<bool>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
-    RepeatedIterator<int32_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
-    RepeatedIterator<uint32_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
-    RepeatedIterator<int64_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
-    RepeatedIterator<uint64_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<float>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<double>;
-}  // namespace internal
-
-}  // namespace protobuf
+        template<typename Element>
+        void RepeatedField<Element>::SwapElements(int index1, int index2)
+        {
+            using std::swap;  // enable ADL with fallback
+            swap(elements()[index1], elements()[index2]);
+        }
+
+        template<typename Element>
+        inline typename RepeatedField<Element>::iterator
+            RepeatedField<Element>::begin()
+        {
+            return iterator(unsafe_elements());
+        }
+        template<typename Element>
+        inline typename RepeatedField<Element>::const_iterator
+            RepeatedField<Element>::begin() const
+        {
+            return const_iterator(unsafe_elements());
+        }
+        template<typename Element>
+        inline typename RepeatedField<Element>::const_iterator
+            RepeatedField<Element>::cbegin() const
+        {
+            return const_iterator(unsafe_elements());
+        }
+        template<typename Element>
+        inline typename RepeatedField<Element>::iterator RepeatedField<Element>::end()
+        {
+            return iterator(unsafe_elements() + current_size_);
+        }
+        template<typename Element>
+        inline typename RepeatedField<Element>::const_iterator
+            RepeatedField<Element>::end() const
+        {
+            return const_iterator(unsafe_elements() + current_size_);
+        }
+        template<typename Element>
+        inline typename RepeatedField<Element>::const_iterator
+            RepeatedField<Element>::cend() const
+        {
+            return const_iterator(unsafe_elements() + current_size_);
+        }
+
+        template<typename Element>
+        inline size_t RepeatedField<Element>::SpaceUsedExcludingSelfLong() const
+        {
+            return total_size_ > 0 ? (total_size_ * sizeof(Element) + kRepHeaderSize) : 0;
+        }
+
+        namespace internal
+        {
+            // Returns the new size for a reserved field based on its 'total_size' and the
+            // requested 'new_size'. The result is clamped to the closed interval:
+            //   [internal::kMinRepeatedFieldAllocationSize,
+            //    std::numeric_limits<int>::max()]
+            // Requires:
+            //     new_size > total_size &&
+            //     (total_size == 0 ||
+            //      total_size >= kRepeatedFieldLowerClampLimit)
+            template<typename T, int kRepHeaderSize>
+            inline int CalculateReserveSize(int total_size, int new_size)
+            {
+                constexpr int lower_limit = RepeatedFieldLowerClampLimit<T, kRepHeaderSize>();
+                if (new_size < lower_limit)
+                {
+                    // Clamp to smallest allowed size.
+                    return lower_limit;
+                }
+                constexpr int kMaxSizeBeforeClamp =
+                    (std::numeric_limits<int>::max() - kRepHeaderSize) / 2;
+                if (PROTOBUF_PREDICT_FALSE(total_size > kMaxSizeBeforeClamp))
+                {
+                    return std::numeric_limits<int>::max();
+                }
+                // We want to double the number of bytes, not the number of elements, to try
+                // to stay within power-of-two allocations.
+                // The allocation has kRepHeaderSize + sizeof(T) * capacity.
+                int doubled_size = 2 * total_size + kRepHeaderSize / sizeof(T);
+                return std::max(doubled_size, new_size);
+            }
+        }  // namespace internal
+
+        // Avoid inlining of Reserve(): new, copy, and delete[] lead to a significant
+        // amount of code bloat.
+        template<typename Element>
+        void RepeatedField<Element>::Reserve(int new_size)
+        {
+            if (total_size_ >= new_size)
+                return;
+            Rep* old_rep = total_size_ > 0 ? rep() : nullptr;
+            Rep* new_rep;
+            Arena* arena = GetOwningArena();
+
+            new_size = internal::CalculateReserveSize<Element, kRepHeaderSize>(
+                total_size_, new_size
+            );
+
+            GOOGLE_DCHECK_LE(
+                static_cast<size_t>(new_size),
+                (std::numeric_limits<size_t>::max() - kRepHeaderSize) / sizeof(Element)
+            )
+                << "Requested size is too large to fit into size_t.";
+            size_t bytes =
+                kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
+            if (arena == nullptr)
+            {
+                new_rep = static_cast<Rep*>(::operator new(bytes));
+            }
+            else
+            {
+                new_rep = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
+            }
+            new_rep->arena = arena;
+            int old_total_size = total_size_;
+            // Already known: new_size >= internal::kMinRepeatedFieldAllocationSize
+            // Maintain invariant:
+            //     total_size_ == 0 ||
+            //     total_size_ >= internal::kMinRepeatedFieldAllocationSize
+            total_size_ = new_size;
+            arena_or_elements_ = new_rep->elements();
+            // Invoke placement-new on newly allocated elements. We shouldn't have to do
+            // this, since Element is supposed to be POD, but a previous version of this
+            // code allocated storage with "new Element[size]" and some code uses
+            // RepeatedField with non-POD types, relying on constructor invocation. If
+            // Element has a trivial constructor (e.g., int32_t), gcc (tested with -O2)
+            // completely removes this loop because the loop body is empty, so this has no
+            // effect unless its side-effects are required for correctness.
+            // Note that we do this before MoveArray() below because Element's copy
+            // assignment implementation will want an initialized instance first.
+            Element* e = &elements()[0];
+            Element* limit = e + total_size_;
+            for (; e < limit; e++)
+            {
+                new (e) Element;
+            }
+            if (current_size_ > 0)
+            {
+                MoveArray(&elements()[0], old_rep->elements(), current_size_);
+            }
+
+            // Likewise, we need to invoke destructors on the old array.
+            InternalDeallocate(old_rep, old_total_size, false);
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::Truncate(int new_size)
+        {
+            GOOGLE_DCHECK_LE(new_size, current_size_);
+            if (current_size_ > 0)
+            {
+                current_size_ = new_size;
+            }
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::MoveArray(Element* to, Element* from, int array_size)
+        {
+            CopyArray(to, from, array_size);
+        }
+
+        template<typename Element>
+        inline void RepeatedField<Element>::CopyArray(Element* to, const Element* from, int array_size)
+        {
+            internal::ElementCopier<Element>()(to, from, array_size);
+        }
+
+        namespace internal
+        {
+
+            template<typename Element, bool HasTrivialCopy>
+            void ElementCopier<Element, HasTrivialCopy>::operator()(Element* to, const Element* from, int array_size)
+            {
+                std::copy(from, from + array_size, to);
+            }
+
+            template<typename Element>
+            struct ElementCopier<Element, true>
+            {
+                void operator()(Element* to, const Element* from, int array_size)
+                {
+                    memcpy(to, from, static_cast<size_t>(array_size) * sizeof(Element));
+                }
+            };
+
+        }  // namespace internal
+
+        // -------------------------------------------------------------------
+
+        // Iterators and helper functions that follow the spirit of the STL
+        // std::back_insert_iterator and std::back_inserter but are tailor-made
+        // for RepeatedField and RepeatedPtrField. Typical usage would be:
+        //
+        //   std::copy(some_sequence.begin(), some_sequence.end(),
+        //             RepeatedFieldBackInserter(proto.mutable_sequence()));
+        //
+        // Ported by johannes from util/gtl/proto-array-iterators.h
+
+        namespace internal
+        {
+
+            // STL-like iterator implementation for RepeatedField.  You should not
+            // refer to this class directly; use RepeatedField<T>::iterator instead.
+            //
+            // Note: All of the iterator operators *must* be inlined to avoid performance
+            // regressions.  This is caused by the extern template declarations below (which
+            // are required because of the RepeatedField extern template declarations).  If
+            // any of these functions aren't explicitly inlined (e.g. defined in the class),
+            // the compiler isn't allowed to inline them.
+            template<typename Element>
+            class RepeatedIterator
+            {
+            public:
+                using iterator_category = std::random_access_iterator_tag;
+                // Note: remove_const is necessary for std::partial_sum, which uses value_type
+                // to determine the summation variable type.
+                using value_type = typename std::remove_const<Element>::type;
+                using difference_type = std::ptrdiff_t;
+                using pointer = Element*;
+                using reference = Element&;
+
+                constexpr RepeatedIterator() noexcept :
+                    it_(nullptr)
+                {
+                }
+
+                // Allows "upcasting" from RepeatedIterator<T**> to
+                // RepeatedIterator<const T*const*>.
+                template<typename OtherElement, typename std::enable_if<std::is_convertible<OtherElement*, pointer>::value>::type* = nullptr>
+                constexpr RepeatedIterator(
+                    const RepeatedIterator<OtherElement>& other
+                ) noexcept
+                    :
+                    it_(other.it_)
+                {
+                }
+
+                // dereferenceable
+                constexpr reference operator*() const noexcept
+                {
+                    return *it_;
+                }
+                constexpr pointer operator->() const noexcept
+                {
+                    return it_;
+                }
+
+            private:
+                // Helper alias to hide the internal type.
+                using iterator = RepeatedIterator<Element>;
+
+            public:
+                // {inc,dec}rementable
+                iterator& operator++() noexcept
+                {
+                    ++it_;
+                    return *this;
+                }
+                iterator operator++(int) noexcept
+                {
+                    return iterator(it_++);
+                }
+                iterator& operator--() noexcept
+                {
+                    --it_;
+                    return *this;
+                }
+                iterator operator--(int) noexcept
+                {
+                    return iterator(it_--);
+                }
+
+                // equality_comparable
+                friend constexpr bool operator==(const iterator& x, const iterator& y) noexcept
+                {
+                    return x.it_ == y.it_;
+                }
+                friend constexpr bool operator!=(const iterator& x, const iterator& y) noexcept
+                {
+                    return x.it_ != y.it_;
+                }
+
+                // less_than_comparable
+                friend constexpr bool operator<(const iterator& x, const iterator& y) noexcept
+                {
+                    return x.it_ < y.it_;
+                }
+                friend constexpr bool operator<=(const iterator& x, const iterator& y) noexcept
+                {
+                    return x.it_ <= y.it_;
+                }
+                friend constexpr bool operator>(const iterator& x, const iterator& y) noexcept
+                {
+                    return x.it_ > y.it_;
+                }
+                friend constexpr bool operator>=(const iterator& x, const iterator& y) noexcept
+                {
+                    return x.it_ >= y.it_;
+                }
+
+                // addable, subtractable
+                iterator& operator+=(difference_type d) noexcept
+                {
+                    it_ += d;
+                    return *this;
+                }
+                constexpr iterator operator+(difference_type d) const noexcept
+                {
+                    return iterator(it_ + d);
+                }
+                friend constexpr iterator operator+(const difference_type d, iterator it) noexcept
+                {
+                    return it + d;
+                }
+
+                iterator& operator-=(difference_type d) noexcept
+                {
+                    it_ -= d;
+                    return *this;
+                }
+                iterator constexpr operator-(difference_type d) const noexcept
+                {
+                    return iterator(it_ - d);
+                }
+
+                // indexable
+                constexpr reference operator[](difference_type d) const noexcept
+                {
+                    return it_[d];
+                }
+
+                // random access iterator
+                friend constexpr difference_type operator-(iterator it1, iterator it2) noexcept
+                {
+                    return it1.it_ - it2.it_;
+                }
+
+            private:
+                template<typename OtherElement>
+                friend class RepeatedIterator;
+
+                // Allow construction from RepeatedField.
+                friend class RepeatedField<value_type>;
+                explicit RepeatedIterator(Element* it) noexcept :
+                    it_(it)
+                {
+                }
+
+                // The internal iterator.
+                Element* it_;
+            };
+
+            // A back inserter for RepeatedField objects.
+            template<typename T>
+            class RepeatedFieldBackInsertIterator
+            {
+            public:
+                using iterator_category = std::output_iterator_tag;
+                using value_type = T;
+                using pointer = void;
+                using reference = void;
+                using difference_type = std::ptrdiff_t;
+
+                explicit RepeatedFieldBackInsertIterator(
+                    RepeatedField<T>* const mutable_field
+                ) :
+                    field_(mutable_field)
+                {
+                }
+                RepeatedFieldBackInsertIterator<T>& operator=(const T& value)
+                {
+                    field_->Add(value);
+                    return *this;
+                }
+                RepeatedFieldBackInsertIterator<T>& operator*()
+                {
+                    return *this;
+                }
+                RepeatedFieldBackInsertIterator<T>& operator++()
+                {
+                    return *this;
+                }
+                RepeatedFieldBackInsertIterator<T>& operator++(int /* unused */)
+                {
+                    return *this;
+                }
+
+            private:
+                RepeatedField<T>* field_;
+            };
+
+        }  // namespace internal
+
+        // Provides a back insert iterator for RepeatedField instances,
+        // similar to std::back_inserter().
+        template<typename T>
+        internal::RepeatedFieldBackInsertIterator<T> RepeatedFieldBackInserter(
+            RepeatedField<T>* const mutable_field
+        )
+        {
+            return internal::RepeatedFieldBackInsertIterator<T>(mutable_field);
+        }
+
+        // Extern declarations of common instantiations to reduce library bloat.
+        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<bool>;
+        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<int32_t>;
+        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<uint32_t>;
+        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<int64_t>;
+        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<uint64_t>;
+        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<float>;
+        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<double>;
+
+        namespace internal
+        {
+            extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<bool>;
+            extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+                RepeatedIterator<int32_t>;
+            extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+                RepeatedIterator<uint32_t>;
+            extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+                RepeatedIterator<int64_t>;
+            extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+                RepeatedIterator<uint64_t>;
+            extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<float>;
+            extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedIterator<double>;
+        }  // namespace internal
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.h b/CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.h
index 401230b..9f68bed 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/repeated_ptr_field.h
@@ -64,7 +64,6 @@
 #include <google/protobuf/port.h>
 #include <google/protobuf/message_lite.h>
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
@@ -72,1897 +71,2282 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-class Message;
-class Reflection;
-
-template <typename T>
-struct WeakRepeatedPtrField;
-
-namespace internal {
-
-class MergePartialFromCodedStreamHelper;
-class SwapFieldHelper;
-
-
-}  // namespace internal
-
-namespace internal {
-template <typename It>
-class RepeatedPtrIterator;
-template <typename It, typename VoidPtr>
-class RepeatedPtrOverPtrsIterator;
-}  // namespace internal
-
-namespace internal {
-
-// type-traits helper for RepeatedPtrFieldBase: we only want to invoke
-// arena-related "copy if on different arena" behavior if the necessary methods
-// exist on the contained type. In particular, we rely on MergeFrom() existing
-// as a general proxy for the fact that a copy will work, and we also provide a
-// specific override for std::string*.
-template <typename T>
-struct TypeImplementsMergeBehaviorProbeForMergeFrom {
-  typedef char HasMerge;
-  typedef long HasNoMerge;
-
-  // We accept either of:
-  // - void MergeFrom(const T& other)
-  // - bool MergeFrom(const T& other)
-  //
-  // We mangle these names a bit to avoid compatibility issues in 'unclean'
-  // include environments that may have, e.g., "#define test ..." (yes, this
-  // exists).
-  template <typename U, typename RetType, RetType (U::*)(const U& arg)>
-  struct CheckType;
-  template <typename U>
-  static HasMerge Check(CheckType<U, void, &U::MergeFrom>*);
-  template <typename U>
-  static HasMerge Check(CheckType<U, bool, &U::MergeFrom>*);
-  template <typename U>
-  static HasNoMerge Check(...);
-
-  // Resolves to either std::true_type or std::false_type.
-  typedef std::integral_constant<bool,
-                                 (sizeof(Check<T>(0)) == sizeof(HasMerge))>
-      type;
-};
-
-template <typename T, typename = void>
-struct TypeImplementsMergeBehavior
-    : TypeImplementsMergeBehaviorProbeForMergeFrom<T> {};
-
-
-template <>
-struct TypeImplementsMergeBehavior<std::string> {
-  typedef std::true_type type;
-};
-
-template <typename T>
-struct IsMovable
-    : std::integral_constant<bool, std::is_move_constructible<T>::value &&
-                                       std::is_move_assignable<T>::value> {};
-
-// This is the common base class for RepeatedPtrFields.  It deals only in void*
-// pointers.  Users should not use this interface directly.
-//
-// The methods of this interface correspond to the methods of RepeatedPtrField,
-// but may have a template argument called TypeHandler.  Its signature is:
-//   class TypeHandler {
-//    public:
-//     typedef MyType Type;
-//     static Type* New();
-//     static Type* NewFromPrototype(const Type* prototype,
-//                                       Arena* arena);
-//     static void Delete(Type*);
-//     static void Clear(Type*);
-//     static void Merge(const Type& from, Type* to);
-//
-//     // Only needs to be implemented if SpaceUsedExcludingSelf() is called.
-//     static int SpaceUsedLong(const Type&);
-//   };
-class PROTOBUF_EXPORT RepeatedPtrFieldBase {
- protected:
-  constexpr RepeatedPtrFieldBase()
-      : arena_(nullptr), current_size_(0), total_size_(0), rep_(nullptr) {}
-  explicit RepeatedPtrFieldBase(Arena* arena)
-      : arena_(arena), current_size_(0), total_size_(0), rep_(nullptr) {}
-
-  RepeatedPtrFieldBase(const RepeatedPtrFieldBase&) = delete;
-  RepeatedPtrFieldBase& operator=(const RepeatedPtrFieldBase&) = delete;
-
-  ~RepeatedPtrFieldBase() {
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Message;
+        class Reflection;
+
+        template<typename T>
+        struct WeakRepeatedPtrField;
+
+        namespace internal
+        {
+
+            class MergePartialFromCodedStreamHelper;
+            class SwapFieldHelper;
+
+        }  // namespace internal
+
+        namespace internal
+        {
+            template<typename It>
+            class RepeatedPtrIterator;
+            template<typename It, typename VoidPtr>
+            class RepeatedPtrOverPtrsIterator;
+        }  // namespace internal
+
+        namespace internal
+        {
+
+            // type-traits helper for RepeatedPtrFieldBase: we only want to invoke
+            // arena-related "copy if on different arena" behavior if the necessary methods
+            // exist on the contained type. In particular, we rely on MergeFrom() existing
+            // as a general proxy for the fact that a copy will work, and we also provide a
+            // specific override for std::string*.
+            template<typename T>
+            struct TypeImplementsMergeBehaviorProbeForMergeFrom
+            {
+                typedef char HasMerge;
+                typedef long HasNoMerge;
+
+                // We accept either of:
+                // - void MergeFrom(const T& other)
+                // - bool MergeFrom(const T& other)
+                //
+                // We mangle these names a bit to avoid compatibility issues in 'unclean'
+                // include environments that may have, e.g., "#define test ..." (yes, this
+                // exists).
+                template<typename U, typename RetType, RetType (U::*)(const U& arg)>
+                struct CheckType;
+                template<typename U>
+                static HasMerge Check(CheckType<U, void, &U::MergeFrom>*);
+                template<typename U>
+                static HasMerge Check(CheckType<U, bool, &U::MergeFrom>*);
+                template<typename U>
+                static HasNoMerge Check(...);
+
+                // Resolves to either std::true_type or std::false_type.
+                typedef std::integral_constant<bool, (sizeof(Check<T>(0)) == sizeof(HasMerge))>
+                    type;
+            };
+
+            template<typename T, typename = void>
+            struct TypeImplementsMergeBehavior : TypeImplementsMergeBehaviorProbeForMergeFrom<T>
+            {
+            };
+
+            template<>
+            struct TypeImplementsMergeBehavior<std::string>
+            {
+                typedef std::true_type type;
+            };
+
+            template<typename T>
+            struct IsMovable : std::integral_constant<bool, std::is_move_constructible<T>::value && std::is_move_assignable<T>::value>
+            {
+            };
+
+            // This is the common base class for RepeatedPtrFields.  It deals only in void*
+            // pointers.  Users should not use this interface directly.
+            //
+            // The methods of this interface correspond to the methods of RepeatedPtrField,
+            // but may have a template argument called TypeHandler.  Its signature is:
+            //   class TypeHandler {
+            //    public:
+            //     typedef MyType Type;
+            //     static Type* New();
+            //     static Type* NewFromPrototype(const Type* prototype,
+            //                                       Arena* arena);
+            //     static void Delete(Type*);
+            //     static void Clear(Type*);
+            //     static void Merge(const Type& from, Type* to);
+            //
+            //     // Only needs to be implemented if SpaceUsedExcludingSelf() is called.
+            //     static int SpaceUsedLong(const Type&);
+            //   };
+            class PROTOBUF_EXPORT RepeatedPtrFieldBase
+            {
+            protected:
+                constexpr RepeatedPtrFieldBase() :
+                    arena_(nullptr),
+                    current_size_(0),
+                    total_size_(0),
+                    rep_(nullptr)
+                {
+                }
+                explicit RepeatedPtrFieldBase(Arena* arena) :
+                    arena_(arena),
+                    current_size_(0),
+                    total_size_(0),
+                    rep_(nullptr)
+                {
+                }
+
+                RepeatedPtrFieldBase(const RepeatedPtrFieldBase&) = delete;
+                RepeatedPtrFieldBase& operator=(const RepeatedPtrFieldBase&) = delete;
+
+                ~RepeatedPtrFieldBase()
+                {
 #ifndef NDEBUG
-    // Try to trigger segfault / asan failure in non-opt builds. If arena_
-    // lifetime has ended before the destructor.
-    if (arena_) (void)arena_->SpaceAllocated();
+                    // Try to trigger segfault / asan failure in non-opt builds. If arena_
+                    // lifetime has ended before the destructor.
+                    if (arena_)
+                        (void)arena_->SpaceAllocated();
 #endif
-  }
-
-  bool empty() const { return current_size_ == 0; }
-  int size() const { return current_size_; }
-  int Capacity() const { return total_size_; }
-
-  template <typename TypeHandler>
-  const typename TypeHandler::Type& at(int index) const {
-    GOOGLE_CHECK_GE(index, 0);
-    GOOGLE_CHECK_LT(index, current_size_);
-    return *cast<TypeHandler>(rep_->elements[index]);
-  }
-
-  template <typename TypeHandler>
-  typename TypeHandler::Type& at(int index) {
-    GOOGLE_CHECK_GE(index, 0);
-    GOOGLE_CHECK_LT(index, current_size_);
-    return *cast<TypeHandler>(rep_->elements[index]);
-  }
-
-  template <typename TypeHandler>
-  typename TypeHandler::Type* Mutable(int index) {
-    GOOGLE_DCHECK_GE(index, 0);
-    GOOGLE_DCHECK_LT(index, current_size_);
-    return cast<TypeHandler>(rep_->elements[index]);
-  }
-
-  template <typename TypeHandler>
-  typename TypeHandler::Type* Add(
-      const typename TypeHandler::Type* prototype = nullptr) {
-    if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
-      return cast<TypeHandler>(rep_->elements[current_size_++]);
-    }
-    typename TypeHandler::Type* result =
-        TypeHandler::NewFromPrototype(prototype, arena_);
-    return reinterpret_cast<typename TypeHandler::Type*>(
-        AddOutOfLineHelper(result));
-  }
-
-  template <
-      typename TypeHandler,
-      typename std::enable_if<TypeHandler::Movable::value>::type* = nullptr>
-  inline void Add(typename TypeHandler::Type&& value) {
-    if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
-      *cast<TypeHandler>(rep_->elements[current_size_++]) = std::move(value);
-      return;
-    }
-    if (!rep_ || rep_->allocated_size == total_size_) {
-      Reserve(total_size_ + 1);
-    }
-    ++rep_->allocated_size;
-    typename TypeHandler::Type* result =
-        TypeHandler::New(arena_, std::move(value));
-    rep_->elements[current_size_++] = result;
-  }
-
-  template <typename TypeHandler>
-  void Delete(int index) {
-    GOOGLE_DCHECK_GE(index, 0);
-    GOOGLE_DCHECK_LT(index, current_size_);
-    TypeHandler::Delete(cast<TypeHandler>(rep_->elements[index]), arena_);
-  }
-
-  // Must be called from destructor.
-  template <typename TypeHandler>
-  void Destroy() {
-    if (rep_ != nullptr && arena_ == nullptr) {
-      int n = rep_->allocated_size;
-      void* const* elements = rep_->elements;
-      for (int i = 0; i < n; i++) {
-        TypeHandler::Delete(cast<TypeHandler>(elements[i]), nullptr);
-      }
-      const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
-      internal::SizedDelete(rep_, size);
-    }
-    rep_ = nullptr;
-  }
-
-  bool NeedsDestroy() const { return rep_ != nullptr && arena_ == nullptr; }
-  void DestroyProtos();  // implemented in the cc file
-
- public:
-  // The next few methods are public so that they can be called from generated
-  // code when implicit weak fields are used, but they should never be called by
-  // application code.
-
-  template <typename TypeHandler>
-  const typename TypeHandler::Type& Get(int index) const {
-    GOOGLE_DCHECK_GE(index, 0);
-    GOOGLE_DCHECK_LT(index, current_size_);
-    return *cast<TypeHandler>(rep_->elements[index]);
-  }
-
-  // Creates and adds an element using the given prototype, without introducing
-  // a link-time dependency on the concrete message type. This method is used to
-  // implement implicit weak fields. The prototype may be nullptr, in which case
-  // an ImplicitWeakMessage will be used as a placeholder.
-  MessageLite* AddWeak(const MessageLite* prototype);
-
-  template <typename TypeHandler>
-  void Clear() {
-    const int n = current_size_;
-    GOOGLE_DCHECK_GE(n, 0);
-    if (n > 0) {
-      void* const* elements = rep_->elements;
-      int i = 0;
-      do {
-        TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
-      } while (i < n);
-      current_size_ = 0;
-    }
-  }
-
-  template <typename TypeHandler>
-  void MergeFrom(const RepeatedPtrFieldBase& other) {
-    // To avoid unnecessary code duplication and reduce binary size, we use a
-    // layered approach to implementing MergeFrom(). The toplevel method is
-    // templated, so we get a small thunk per concrete message type in the
-    // binary. This calls a shared implementation with most of the logic,
-    // passing a function pointer to another type-specific piece of code that
-    // calls the object-allocate and merge handlers.
-    GOOGLE_DCHECK_NE(&other, this);
-    if (other.current_size_ == 0) return;
-    MergeFromInternal(other,
-                      &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
-  }
-
-  inline void InternalSwap(RepeatedPtrFieldBase* rhs) {
-    GOOGLE_DCHECK(this != rhs);
-
-    // Swap all fields at once.
-    auto temp = std::make_tuple(rhs->arena_, rhs->current_size_,
-                                rhs->total_size_, rhs->rep_);
-    std::tie(rhs->arena_, rhs->current_size_, rhs->total_size_, rhs->rep_) =
-        std::make_tuple(arena_, current_size_, total_size_, rep_);
-    std::tie(arena_, current_size_, total_size_, rep_) = temp;
-  }
-
- protected:
-  template <typename TypeHandler>
-  void RemoveLast() {
-    GOOGLE_DCHECK_GT(current_size_, 0);
-    TypeHandler::Clear(cast<TypeHandler>(rep_->elements[--current_size_]));
-  }
-
-  template <typename TypeHandler>
-  void CopyFrom(const RepeatedPtrFieldBase& other) {
-    if (&other == this) return;
-    RepeatedPtrFieldBase::Clear<TypeHandler>();
-    RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
-  }
-
-  void CloseGap(int start, int num);  // implemented in the cc file
-
-  void Reserve(int new_size);  // implemented in the cc file
-
-  template <typename TypeHandler>
-  static inline typename TypeHandler::Type* copy(
-      typename TypeHandler::Type* value) {
-    auto* new_value = TypeHandler::NewFromPrototype(value, nullptr);
-    TypeHandler::Merge(*value, new_value);
-    return new_value;
-  }
-
-  // Used for constructing iterators.
-  void* const* raw_data() const { return rep_ ? rep_->elements : nullptr; }
-  void** raw_mutable_data() const {
-    return rep_ ? const_cast<void**>(rep_->elements) : nullptr;
-  }
-
-  template <typename TypeHandler>
-  typename TypeHandler::Type** mutable_data() {
-    // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
-    //   method entirely.
-    return reinterpret_cast<typename TypeHandler::Type**>(raw_mutable_data());
-  }
-
-  template <typename TypeHandler>
-  const typename TypeHandler::Type* const* data() const {
-    // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
-    //   method entirely.
-    return reinterpret_cast<const typename TypeHandler::Type* const*>(
-        raw_data());
-  }
-
-  template <typename TypeHandler>
-  PROTOBUF_NDEBUG_INLINE void Swap(RepeatedPtrFieldBase* other) {
+                }
+
+                bool empty() const
+                {
+                    return current_size_ == 0;
+                }
+                int size() const
+                {
+                    return current_size_;
+                }
+                int Capacity() const
+                {
+                    return total_size_;
+                }
+
+                template<typename TypeHandler>
+                const typename TypeHandler::Type& at(int index) const
+                {
+                    GOOGLE_CHECK_GE(index, 0);
+                    GOOGLE_CHECK_LT(index, current_size_);
+                    return *cast<TypeHandler>(rep_->elements[index]);
+                }
+
+                template<typename TypeHandler>
+                typename TypeHandler::Type& at(int index)
+                {
+                    GOOGLE_CHECK_GE(index, 0);
+                    GOOGLE_CHECK_LT(index, current_size_);
+                    return *cast<TypeHandler>(rep_->elements[index]);
+                }
+
+                template<typename TypeHandler>
+                typename TypeHandler::Type* Mutable(int index)
+                {
+                    GOOGLE_DCHECK_GE(index, 0);
+                    GOOGLE_DCHECK_LT(index, current_size_);
+                    return cast<TypeHandler>(rep_->elements[index]);
+                }
+
+                template<typename TypeHandler>
+                typename TypeHandler::Type* Add(
+                    const typename TypeHandler::Type* prototype = nullptr
+                )
+                {
+                    if (rep_ != nullptr && current_size_ < rep_->allocated_size)
+                    {
+                        return cast<TypeHandler>(rep_->elements[current_size_++]);
+                    }
+                    typename TypeHandler::Type* result =
+                        TypeHandler::NewFromPrototype(prototype, arena_);
+                    return reinterpret_cast<typename TypeHandler::Type*>(
+                        AddOutOfLineHelper(result)
+                    );
+                }
+
+                template<
+                    typename TypeHandler,
+                    typename std::enable_if<TypeHandler::Movable::value>::type* = nullptr>
+                inline void Add(typename TypeHandler::Type&& value)
+                {
+                    if (rep_ != nullptr && current_size_ < rep_->allocated_size)
+                    {
+                        *cast<TypeHandler>(rep_->elements[current_size_++]) = std::move(value);
+                        return;
+                    }
+                    if (!rep_ || rep_->allocated_size == total_size_)
+                    {
+                        Reserve(total_size_ + 1);
+                    }
+                    ++rep_->allocated_size;
+                    typename TypeHandler::Type* result =
+                        TypeHandler::New(arena_, std::move(value));
+                    rep_->elements[current_size_++] = result;
+                }
+
+                template<typename TypeHandler>
+                void Delete(int index)
+                {
+                    GOOGLE_DCHECK_GE(index, 0);
+                    GOOGLE_DCHECK_LT(index, current_size_);
+                    TypeHandler::Delete(cast<TypeHandler>(rep_->elements[index]), arena_);
+                }
+
+                // Must be called from destructor.
+                template<typename TypeHandler>
+                void Destroy()
+                {
+                    if (rep_ != nullptr && arena_ == nullptr)
+                    {
+                        int n = rep_->allocated_size;
+                        void* const* elements = rep_->elements;
+                        for (int i = 0; i < n; i++)
+                        {
+                            TypeHandler::Delete(cast<TypeHandler>(elements[i]), nullptr);
+                        }
+                        const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
+                        internal::SizedDelete(rep_, size);
+                    }
+                    rep_ = nullptr;
+                }
+
+                bool NeedsDestroy() const
+                {
+                    return rep_ != nullptr && arena_ == nullptr;
+                }
+                void DestroyProtos();  // implemented in the cc file
+
+            public:
+                // The next few methods are public so that they can be called from generated
+                // code when implicit weak fields are used, but they should never be called by
+                // application code.
+
+                template<typename TypeHandler>
+                const typename TypeHandler::Type& Get(int index) const
+                {
+                    GOOGLE_DCHECK_GE(index, 0);
+                    GOOGLE_DCHECK_LT(index, current_size_);
+                    return *cast<TypeHandler>(rep_->elements[index]);
+                }
+
+                // Creates and adds an element using the given prototype, without introducing
+                // a link-time dependency on the concrete message type. This method is used to
+                // implement implicit weak fields. The prototype may be nullptr, in which case
+                // an ImplicitWeakMessage will be used as a placeholder.
+                MessageLite* AddWeak(const MessageLite* prototype);
+
+                template<typename TypeHandler>
+                void Clear()
+                {
+                    const int n = current_size_;
+                    GOOGLE_DCHECK_GE(n, 0);
+                    if (n > 0)
+                    {
+                        void* const* elements = rep_->elements;
+                        int i = 0;
+                        do
+                        {
+                            TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
+                        } while (i < n);
+                        current_size_ = 0;
+                    }
+                }
+
+                template<typename TypeHandler>
+                void MergeFrom(const RepeatedPtrFieldBase& other)
+                {
+                    // To avoid unnecessary code duplication and reduce binary size, we use a
+                    // layered approach to implementing MergeFrom(). The toplevel method is
+                    // templated, so we get a small thunk per concrete message type in the
+                    // binary. This calls a shared implementation with most of the logic,
+                    // passing a function pointer to another type-specific piece of code that
+                    // calls the object-allocate and merge handlers.
+                    GOOGLE_DCHECK_NE(&other, this);
+                    if (other.current_size_ == 0)
+                        return;
+                    MergeFromInternal(other, &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
+                }
+
+                inline void InternalSwap(RepeatedPtrFieldBase* rhs)
+                {
+                    GOOGLE_DCHECK(this != rhs);
+
+                    // Swap all fields at once.
+                    auto temp = std::make_tuple(rhs->arena_, rhs->current_size_, rhs->total_size_, rhs->rep_);
+                    std::tie(rhs->arena_, rhs->current_size_, rhs->total_size_, rhs->rep_) =
+                        std::make_tuple(arena_, current_size_, total_size_, rep_);
+                    std::tie(arena_, current_size_, total_size_, rep_) = temp;
+                }
+
+            protected:
+                template<typename TypeHandler>
+                void RemoveLast()
+                {
+                    GOOGLE_DCHECK_GT(current_size_, 0);
+                    TypeHandler::Clear(cast<TypeHandler>(rep_->elements[--current_size_]));
+                }
+
+                template<typename TypeHandler>
+                void CopyFrom(const RepeatedPtrFieldBase& other)
+                {
+                    if (&other == this)
+                        return;
+                    RepeatedPtrFieldBase::Clear<TypeHandler>();
+                    RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
+                }
+
+                void CloseGap(int start, int num);  // implemented in the cc file
+
+                void Reserve(int new_size);  // implemented in the cc file
+
+                template<typename TypeHandler>
+                static inline typename TypeHandler::Type* copy(
+                    typename TypeHandler::Type* value
+                )
+                {
+                    auto* new_value = TypeHandler::NewFromPrototype(value, nullptr);
+                    TypeHandler::Merge(*value, new_value);
+                    return new_value;
+                }
+
+                // Used for constructing iterators.
+                void* const* raw_data() const
+                {
+                    return rep_ ? rep_->elements : nullptr;
+                }
+                void** raw_mutable_data() const
+                {
+                    return rep_ ? const_cast<void**>(rep_->elements) : nullptr;
+                }
+
+                template<typename TypeHandler>
+                typename TypeHandler::Type** mutable_data()
+                {
+                    // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
+                    //   method entirely.
+                    return reinterpret_cast<typename TypeHandler::Type**>(raw_mutable_data());
+                }
+
+                template<typename TypeHandler>
+                const typename TypeHandler::Type* const* data() const
+                {
+                    // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
+                    //   method entirely.
+                    return reinterpret_cast<const typename TypeHandler::Type* const*>(
+                        raw_data()
+                    );
+                }
+
+                template<typename TypeHandler>
+                PROTOBUF_NDEBUG_INLINE void Swap(RepeatedPtrFieldBase* other)
+                {
 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena())
+                    if (GetOwningArena() != nullptr &&
+                        GetOwningArena() == other->GetOwningArena())
 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena())
+                    if (GetOwningArena() == other->GetOwningArena())
 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-    {
-      InternalSwap(other);
-    } else {
-      SwapFallback<TypeHandler>(other);
-    }
-  }
-
-  void SwapElements(int index1, int index2) {
-    using std::swap;  // enable ADL with fallback
-    swap(rep_->elements[index1], rep_->elements[index2]);
-  }
-
-  template <typename TypeHandler>
-  size_t SpaceUsedExcludingSelfLong() const {
-    size_t allocated_bytes = static_cast<size_t>(total_size_) * sizeof(void*);
-    if (rep_ != nullptr) {
-      for (int i = 0; i < rep_->allocated_size; ++i) {
-        allocated_bytes +=
-            TypeHandler::SpaceUsedLong(*cast<TypeHandler>(rep_->elements[i]));
-      }
-      allocated_bytes += kRepHeaderSize;
-    }
-    return allocated_bytes;
-  }
-
-  // Advanced memory management --------------------------------------
-
-  // Like Add(), but if there are no cleared objects to use, returns nullptr.
-  template <typename TypeHandler>
-  typename TypeHandler::Type* AddFromCleared() {
-    if (rep_ != nullptr && current_size_ < rep_->allocated_size) {
-      return cast<TypeHandler>(rep_->elements[current_size_++]);
-    } else {
-      return nullptr;
-    }
-  }
-
-  template <typename TypeHandler>
-  void AddAllocated(typename TypeHandler::Type* value) {
-    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
-    AddAllocatedInternal<TypeHandler>(value, t);
-  }
-
-  template <typename TypeHandler>
-  void UnsafeArenaAddAllocated(typename TypeHandler::Type* value) {
-    // Make room for the new pointer.
-    if (!rep_ || current_size_ == total_size_) {
-      // The array is completely full with no cleared objects, so grow it.
-      Reserve(total_size_ + 1);
-      ++rep_->allocated_size;
-    } else if (rep_->allocated_size == total_size_) {
-      // There is no more space in the pointer array because it contains some
-      // cleared objects awaiting reuse.  We don't want to grow the array in
-      // this case because otherwise a loop calling AddAllocated() followed by
-      // Clear() would leak memory.
-      TypeHandler::Delete(cast<TypeHandler>(rep_->elements[current_size_]),
-                          arena_);
-    } else if (current_size_ < rep_->allocated_size) {
-      // We have some cleared objects.  We don't care about their order, so we
-      // can just move the first one to the end to make space.
-      rep_->elements[rep_->allocated_size] = rep_->elements[current_size_];
-      ++rep_->allocated_size;
-    } else {
-      // There are no cleared objects.
-      ++rep_->allocated_size;
-    }
-
-    rep_->elements[current_size_++] = value;
-  }
-
-  template <typename TypeHandler>
-  PROTOBUF_NODISCARD typename TypeHandler::Type* ReleaseLast() {
-    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
-    return ReleaseLastInternal<TypeHandler>(t);
-  }
-
-  // Releases and returns the last element, but does not do out-of-arena copy.
-  // Instead, just returns the raw pointer to the contained element in the
-  // arena.
-  template <typename TypeHandler>
-  typename TypeHandler::Type* UnsafeArenaReleaseLast() {
-    GOOGLE_DCHECK_GT(current_size_, 0);
-    typename TypeHandler::Type* result =
-        cast<TypeHandler>(rep_->elements[--current_size_]);
-    --rep_->allocated_size;
-    if (current_size_ < rep_->allocated_size) {
-      // There are cleared elements on the end; replace the removed element
-      // with the last allocated element.
-      rep_->elements[current_size_] = rep_->elements[rep_->allocated_size];
-    }
-    return result;
-  }
-
-  int ClearedCount() const {
-    return rep_ ? (rep_->allocated_size - current_size_) : 0;
-  }
-
-  template <typename TypeHandler>
-  void AddCleared(typename TypeHandler::Type* value) {
-    GOOGLE_DCHECK(GetOwningArena() == nullptr) << "AddCleared() can only be used on a "
-                                           "RepeatedPtrField not on an arena.";
-    GOOGLE_DCHECK(TypeHandler::GetOwningArena(value) == nullptr)
-        << "AddCleared() can only accept values not on an arena.";
-    if (!rep_ || rep_->allocated_size == total_size_) {
-      Reserve(total_size_ + 1);
-    }
-    rep_->elements[rep_->allocated_size++] = value;
-  }
-
-  template <typename TypeHandler>
-  PROTOBUF_NODISCARD typename TypeHandler::Type* ReleaseCleared() {
-    GOOGLE_DCHECK(GetOwningArena() == nullptr)
-        << "ReleaseCleared() can only be used on a RepeatedPtrField not on "
-        << "an arena.";
-    GOOGLE_DCHECK(GetOwningArena() == nullptr);
-    GOOGLE_DCHECK(rep_ != nullptr);
-    GOOGLE_DCHECK_GT(rep_->allocated_size, current_size_);
-    return cast<TypeHandler>(rep_->elements[--rep_->allocated_size]);
-  }
-
-  template <typename TypeHandler>
-  void AddAllocatedInternal(typename TypeHandler::Type* value, std::true_type) {
-    // AddAllocated version that implements arena-safe copying behavior.
-    Arena* element_arena =
-        reinterpret_cast<Arena*>(TypeHandler::GetOwningArena(value));
-    Arena* arena = GetOwningArena();
-    if (arena == element_arena && rep_ && rep_->allocated_size < total_size_) {
-      // Fast path: underlying arena representation (tagged pointer) is equal to
-      // our arena pointer, and we can add to array without resizing it (at
-      // least one slot that is not allocated).
-      void** elems = rep_->elements;
-      if (current_size_ < rep_->allocated_size) {
-        // Make space at [current] by moving first allocated element to end of
-        // allocated list.
-        elems[rep_->allocated_size] = elems[current_size_];
-      }
-      elems[current_size_] = value;
-      current_size_ = current_size_ + 1;
-      rep_->allocated_size = rep_->allocated_size + 1;
-    } else {
-      AddAllocatedSlowWithCopy<TypeHandler>(value, element_arena, arena);
-    }
-  }
-
-  template <typename TypeHandler>
-  void AddAllocatedInternal(
-      // AddAllocated version that does not implement arena-safe copying
-      // behavior.
-      typename TypeHandler::Type* value, std::false_type) {
-    if (rep_ && rep_->allocated_size < total_size_) {
-      // Fast path: underlying arena representation (tagged pointer) is equal to
-      // our arena pointer, and we can add to array without resizing it (at
-      // least one slot that is not allocated).
-      void** elems = rep_->elements;
-      if (current_size_ < rep_->allocated_size) {
-        // Make space at [current] by moving first allocated element to end of
-        // allocated list.
-        elems[rep_->allocated_size] = elems[current_size_];
-      }
-      elems[current_size_] = value;
-      current_size_ = current_size_ + 1;
-      ++rep_->allocated_size;
-    } else {
-      UnsafeArenaAddAllocated<TypeHandler>(value);
-    }
-  }
-
-  // Slowpath handles all cases, copying if necessary.
-  template <typename TypeHandler>
-  PROTOBUF_NOINLINE void AddAllocatedSlowWithCopy(
-      // Pass value_arena and my_arena to avoid duplicate virtual call (value)
-      // or load (mine).
-      typename TypeHandler::Type* value, Arena* value_arena, Arena* my_arena) {
-    // Ensure that either the value is in the same arena, or if not, we do the
-    // appropriate thing: Own() it (if it's on heap and we're in an arena) or
-    // copy it to our arena/heap (otherwise).
-    if (my_arena != nullptr && value_arena == nullptr) {
-      my_arena->Own(value);
-    } else if (my_arena != value_arena) {
-      typename TypeHandler::Type* new_value =
-          TypeHandler::NewFromPrototype(value, my_arena);
-      TypeHandler::Merge(*value, new_value);
-      TypeHandler::Delete(value, value_arena);
-      value = new_value;
-    }
-
-    UnsafeArenaAddAllocated<TypeHandler>(value);
-  }
-
-  template <typename TypeHandler>
-  typename TypeHandler::Type* ReleaseLastInternal(std::true_type) {
-    // ReleaseLast() for types that implement merge/copy behavior.
-    // First, release an element.
-    typename TypeHandler::Type* result = UnsafeArenaReleaseLast<TypeHandler>();
-    // Now perform a copy if we're on an arena.
-    Arena* arena = GetOwningArena();
-
-    typename TypeHandler::Type* new_result;
+                    {
+                        InternalSwap(other);
+                    }
+                    else
+                    {
+                        SwapFallback<TypeHandler>(other);
+                    }
+                }
+
+                void SwapElements(int index1, int index2)
+                {
+                    using std::swap;  // enable ADL with fallback
+                    swap(rep_->elements[index1], rep_->elements[index2]);
+                }
+
+                template<typename TypeHandler>
+                size_t SpaceUsedExcludingSelfLong() const
+                {
+                    size_t allocated_bytes = static_cast<size_t>(total_size_) * sizeof(void*);
+                    if (rep_ != nullptr)
+                    {
+                        for (int i = 0; i < rep_->allocated_size; ++i)
+                        {
+                            allocated_bytes +=
+                                TypeHandler::SpaceUsedLong(*cast<TypeHandler>(rep_->elements[i]));
+                        }
+                        allocated_bytes += kRepHeaderSize;
+                    }
+                    return allocated_bytes;
+                }
+
+                // Advanced memory management --------------------------------------
+
+                // Like Add(), but if there are no cleared objects to use, returns nullptr.
+                template<typename TypeHandler>
+                typename TypeHandler::Type* AddFromCleared()
+                {
+                    if (rep_ != nullptr && current_size_ < rep_->allocated_size)
+                    {
+                        return cast<TypeHandler>(rep_->elements[current_size_++]);
+                    }
+                    else
+                    {
+                        return nullptr;
+                    }
+                }
+
+                template<typename TypeHandler>
+                void AddAllocated(typename TypeHandler::Type* value)
+                {
+                    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
+                    AddAllocatedInternal<TypeHandler>(value, t);
+                }
+
+                template<typename TypeHandler>
+                void UnsafeArenaAddAllocated(typename TypeHandler::Type* value)
+                {
+                    // Make room for the new pointer.
+                    if (!rep_ || current_size_ == total_size_)
+                    {
+                        // The array is completely full with no cleared objects, so grow it.
+                        Reserve(total_size_ + 1);
+                        ++rep_->allocated_size;
+                    }
+                    else if (rep_->allocated_size == total_size_)
+                    {
+                        // There is no more space in the pointer array because it contains some
+                        // cleared objects awaiting reuse.  We don't want to grow the array in
+                        // this case because otherwise a loop calling AddAllocated() followed by
+                        // Clear() would leak memory.
+                        TypeHandler::Delete(cast<TypeHandler>(rep_->elements[current_size_]), arena_);
+                    }
+                    else if (current_size_ < rep_->allocated_size)
+                    {
+                        // We have some cleared objects.  We don't care about their order, so we
+                        // can just move the first one to the end to make space.
+                        rep_->elements[rep_->allocated_size] = rep_->elements[current_size_];
+                        ++rep_->allocated_size;
+                    }
+                    else
+                    {
+                        // There are no cleared objects.
+                        ++rep_->allocated_size;
+                    }
+
+                    rep_->elements[current_size_++] = value;
+                }
+
+                template<typename TypeHandler>
+                PROTOBUF_NODISCARD typename TypeHandler::Type* ReleaseLast()
+                {
+                    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
+                    return ReleaseLastInternal<TypeHandler>(t);
+                }
+
+                // Releases and returns the last element, but does not do out-of-arena copy.
+                // Instead, just returns the raw pointer to the contained element in the
+                // arena.
+                template<typename TypeHandler>
+                typename TypeHandler::Type* UnsafeArenaReleaseLast()
+                {
+                    GOOGLE_DCHECK_GT(current_size_, 0);
+                    typename TypeHandler::Type* result =
+                        cast<TypeHandler>(rep_->elements[--current_size_]);
+                    --rep_->allocated_size;
+                    if (current_size_ < rep_->allocated_size)
+                    {
+                        // There are cleared elements on the end; replace the removed element
+                        // with the last allocated element.
+                        rep_->elements[current_size_] = rep_->elements[rep_->allocated_size];
+                    }
+                    return result;
+                }
+
+                int ClearedCount() const
+                {
+                    return rep_ ? (rep_->allocated_size - current_size_) : 0;
+                }
+
+                template<typename TypeHandler>
+                void AddCleared(typename TypeHandler::Type* value)
+                {
+                    GOOGLE_DCHECK(GetOwningArena() == nullptr) << "AddCleared() can only be used on a "
+                                                                  "RepeatedPtrField not on an arena.";
+                    GOOGLE_DCHECK(TypeHandler::GetOwningArena(value) == nullptr)
+                        << "AddCleared() can only accept values not on an arena.";
+                    if (!rep_ || rep_->allocated_size == total_size_)
+                    {
+                        Reserve(total_size_ + 1);
+                    }
+                    rep_->elements[rep_->allocated_size++] = value;
+                }
+
+                template<typename TypeHandler>
+                PROTOBUF_NODISCARD typename TypeHandler::Type* ReleaseCleared()
+                {
+                    GOOGLE_DCHECK(GetOwningArena() == nullptr)
+                        << "ReleaseCleared() can only be used on a RepeatedPtrField not on "
+                        << "an arena.";
+                    GOOGLE_DCHECK(GetOwningArena() == nullptr);
+                    GOOGLE_DCHECK(rep_ != nullptr);
+                    GOOGLE_DCHECK_GT(rep_->allocated_size, current_size_);
+                    return cast<TypeHandler>(rep_->elements[--rep_->allocated_size]);
+                }
+
+                template<typename TypeHandler>
+                void AddAllocatedInternal(typename TypeHandler::Type* value, std::true_type)
+                {
+                    // AddAllocated version that implements arena-safe copying behavior.
+                    Arena* element_arena =
+                        reinterpret_cast<Arena*>(TypeHandler::GetOwningArena(value));
+                    Arena* arena = GetOwningArena();
+                    if (arena == element_arena && rep_ && rep_->allocated_size < total_size_)
+                    {
+                        // Fast path: underlying arena representation (tagged pointer) is equal to
+                        // our arena pointer, and we can add to array without resizing it (at
+                        // least one slot that is not allocated).
+                        void** elems = rep_->elements;
+                        if (current_size_ < rep_->allocated_size)
+                        {
+                            // Make space at [current] by moving first allocated element to end of
+                            // allocated list.
+                            elems[rep_->allocated_size] = elems[current_size_];
+                        }
+                        elems[current_size_] = value;
+                        current_size_ = current_size_ + 1;
+                        rep_->allocated_size = rep_->allocated_size + 1;
+                    }
+                    else
+                    {
+                        AddAllocatedSlowWithCopy<TypeHandler>(value, element_arena, arena);
+                    }
+                }
+
+                template<typename TypeHandler>
+                void AddAllocatedInternal(
+                    // AddAllocated version that does not implement arena-safe copying
+                    // behavior.
+                    typename TypeHandler::Type* value,
+                    std::false_type
+                )
+                {
+                    if (rep_ && rep_->allocated_size < total_size_)
+                    {
+                        // Fast path: underlying arena representation (tagged pointer) is equal to
+                        // our arena pointer, and we can add to array without resizing it (at
+                        // least one slot that is not allocated).
+                        void** elems = rep_->elements;
+                        if (current_size_ < rep_->allocated_size)
+                        {
+                            // Make space at [current] by moving first allocated element to end of
+                            // allocated list.
+                            elems[rep_->allocated_size] = elems[current_size_];
+                        }
+                        elems[current_size_] = value;
+                        current_size_ = current_size_ + 1;
+                        ++rep_->allocated_size;
+                    }
+                    else
+                    {
+                        UnsafeArenaAddAllocated<TypeHandler>(value);
+                    }
+                }
+
+                // Slowpath handles all cases, copying if necessary.
+                template<typename TypeHandler>
+                PROTOBUF_NOINLINE void AddAllocatedSlowWithCopy(
+                    // Pass value_arena and my_arena to avoid duplicate virtual call (value)
+                    // or load (mine).
+                    typename TypeHandler::Type* value,
+                    Arena* value_arena,
+                    Arena* my_arena
+                )
+                {
+                    // Ensure that either the value is in the same arena, or if not, we do the
+                    // appropriate thing: Own() it (if it's on heap and we're in an arena) or
+                    // copy it to our arena/heap (otherwise).
+                    if (my_arena != nullptr && value_arena == nullptr)
+                    {
+                        my_arena->Own(value);
+                    }
+                    else if (my_arena != value_arena)
+                    {
+                        typename TypeHandler::Type* new_value =
+                            TypeHandler::NewFromPrototype(value, my_arena);
+                        TypeHandler::Merge(*value, new_value);
+                        TypeHandler::Delete(value, value_arena);
+                        value = new_value;
+                    }
+
+                    UnsafeArenaAddAllocated<TypeHandler>(value);
+                }
+
+                template<typename TypeHandler>
+                typename TypeHandler::Type* ReleaseLastInternal(std::true_type)
+                {
+                    // ReleaseLast() for types that implement merge/copy behavior.
+                    // First, release an element.
+                    typename TypeHandler::Type* result = UnsafeArenaReleaseLast<TypeHandler>();
+                    // Now perform a copy if we're on an arena.
+                    Arena* arena = GetOwningArena();
+
+                    typename TypeHandler::Type* new_result;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-    new_result = copy<TypeHandler>(result);
-    if (arena == nullptr) delete result;
+                    new_result = copy<TypeHandler>(result);
+                    if (arena == nullptr)
+                        delete result;
 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
-    new_result = (arena == nullptr) ? result : copy<TypeHandler>(result);
+                    new_result = (arena == nullptr) ? result : copy<TypeHandler>(result);
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-    return new_result;
-  }
-
-  template <typename TypeHandler>
-  typename TypeHandler::Type* ReleaseLastInternal(std::false_type) {
-    // ReleaseLast() for types that *do not* implement merge/copy behavior --
-    // this is the same as UnsafeArenaReleaseLast(). Note that we GOOGLE_DCHECK-fail if
-    // we're on an arena, since the user really should implement the copy
-    // operation in this case.
-    GOOGLE_DCHECK(GetOwningArena() == nullptr)
-        << "ReleaseLast() called on a RepeatedPtrField that is on an arena, "
-        << "with a type that does not implement MergeFrom. This is unsafe; "
-        << "please implement MergeFrom for your type.";
-    return UnsafeArenaReleaseLast<TypeHandler>();
-  }
-
-  template <typename TypeHandler>
-  PROTOBUF_NOINLINE void SwapFallback(RepeatedPtrFieldBase* other) {
+                    return new_result;
+                }
+
+                template<typename TypeHandler>
+                typename TypeHandler::Type* ReleaseLastInternal(std::false_type)
+                {
+                    // ReleaseLast() for types that *do not* implement merge/copy behavior --
+                    // this is the same as UnsafeArenaReleaseLast(). Note that we GOOGLE_DCHECK-fail if
+                    // we're on an arena, since the user really should implement the copy
+                    // operation in this case.
+                    GOOGLE_DCHECK(GetOwningArena() == nullptr)
+                        << "ReleaseLast() called on a RepeatedPtrField that is on an arena, "
+                        << "with a type that does not implement MergeFrom. This is unsafe; "
+                        << "please implement MergeFrom for your type.";
+                    return UnsafeArenaReleaseLast<TypeHandler>();
+                }
+
+                template<typename TypeHandler>
+                PROTOBUF_NOINLINE void SwapFallback(RepeatedPtrFieldBase* other)
+                {
 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    GOOGLE_DCHECK(GetOwningArena() == nullptr ||
-           other->GetOwningArena() != GetOwningArena());
+                    GOOGLE_DCHECK(GetOwningArena() == nullptr || other->GetOwningArena() != GetOwningArena());
 #else   // PROTOBUF_FORCE_COPY_IN_SWAP
-    GOOGLE_DCHECK(other->GetOwningArena() != GetOwningArena());
+                    GOOGLE_DCHECK(other->GetOwningArena() != GetOwningArena());
 #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
 
-    // Copy semantics in this case. We try to improve efficiency by placing the
-    // temporary on |other|'s arena so that messages are copied twice rather
-    // than three times.
-    RepeatedPtrFieldBase temp(other->GetOwningArena());
-    temp.MergeFrom<TypeHandler>(*this);
-    this->Clear<TypeHandler>();
-    this->MergeFrom<TypeHandler>(*other);
-    other->InternalSwap(&temp);
-    temp.Destroy<TypeHandler>();  // Frees rep_ if `other` had no arena.
-  }
-
-  inline Arena* GetArena() const { return arena_; }
-
- protected:
-  inline Arena* GetOwningArena() const { return arena_; }
-
- private:
-  template <typename T> friend class Arena::InternalHelper;
-
-  static constexpr int kInitialSize = 0;
-  // A few notes on internal representation:
-  //
-  // We use an indirected approach, with struct Rep, to keep
-  // sizeof(RepeatedPtrFieldBase) equivalent to what it was before arena support
-  // was added; namely, 3 8-byte machine words on x86-64. An instance of Rep is
-  // allocated only when the repeated field is non-empty, and it is a
-  // dynamically-sized struct (the header is directly followed by elements[]).
-  // We place arena_ and current_size_ directly in the object to avoid cache
-  // misses due to the indirection, because these fields are checked frequently.
-  // Placing all fields directly in the RepeatedPtrFieldBase instance would cost
-  // significant performance for memory-sensitive workloads.
-  Arena* arena_;
-  int current_size_;
-  int total_size_;
-  struct Rep {
-    int allocated_size;
-    // Here we declare a huge array as a way of approximating C's "flexible
-    // array member" feature without relying on undefined behavior.
-    void* elements[(std::numeric_limits<int>::max() - 2 * sizeof(int)) /
-                   sizeof(void*)];
-  };
-  static constexpr size_t kRepHeaderSize = offsetof(Rep, elements);
-  Rep* rep_;
-
-  template <typename TypeHandler>
-  static inline typename TypeHandler::Type* cast(void* element) {
-    return reinterpret_cast<typename TypeHandler::Type*>(element);
-  }
-  template <typename TypeHandler>
-  static inline const typename TypeHandler::Type* cast(const void* element) {
-    return reinterpret_cast<const typename TypeHandler::Type*>(element);
-  }
-
-  // Non-templated inner function to avoid code duplication. Takes a function
-  // pointer to the type-specific (templated) inner allocate/merge loop.
-  void MergeFromInternal(const RepeatedPtrFieldBase& other,
-                         void (RepeatedPtrFieldBase::*inner_loop)(void**,
-                                                                  void**, int,
-                                                                  int)) {
-    // Note: wrapper has already guaranteed that other.rep_ != nullptr here.
-    int other_size = other.current_size_;
-    void** other_elements = other.rep_->elements;
-    void** new_elements = InternalExtend(other_size);
-    int allocated_elems = rep_->allocated_size - current_size_;
-    (this->*inner_loop)(new_elements, other_elements, other_size,
-                        allocated_elems);
-    current_size_ += other_size;
-    if (rep_->allocated_size < current_size_) {
-      rep_->allocated_size = current_size_;
-    }
-  }
-
-  // Merges other_elems to our_elems.
-  template <typename TypeHandler>
-  PROTOBUF_NOINLINE void MergeFromInnerLoop(void** our_elems,
-                                            void** other_elems, int length,
-                                            int already_allocated) {
-    if (already_allocated < length) {
-      Arena* arena = GetOwningArena();
-      typename TypeHandler::Type* elem_prototype =
-          reinterpret_cast<typename TypeHandler::Type*>(other_elems[0]);
-      for (int i = already_allocated; i < length; i++) {
-        // Allocate a new empty element that we'll merge into below
-        typename TypeHandler::Type* new_elem =
-            TypeHandler::NewFromPrototype(elem_prototype, arena);
-        our_elems[i] = new_elem;
-      }
-    }
-    // Main loop that does the actual merging
-    for (int i = 0; i < length; i++) {
-      // Already allocated: use existing element.
-      typename TypeHandler::Type* other_elem =
-          reinterpret_cast<typename TypeHandler::Type*>(other_elems[i]);
-      typename TypeHandler::Type* new_elem =
-          reinterpret_cast<typename TypeHandler::Type*>(our_elems[i]);
-      TypeHandler::Merge(*other_elem, new_elem);
-    }
-  }
-
-  // Internal helper: extends array space if necessary to contain
-  // |extend_amount| more elements, and returns a pointer to the element
-  // immediately following the old list of elements.  This interface factors out
-  // common behavior from Reserve() and MergeFrom() to reduce code size.
-  // |extend_amount| must be > 0.
-  void** InternalExtend(int extend_amount);
-
-  // Internal helper for Add: adds "obj" as the next element in the
-  // array, including potentially resizing the array with Reserve if
-  // needed
-  void* AddOutOfLineHelper(void* obj);
-
-  // The reflection implementation needs to call protected methods directly,
-  // reinterpreting pointers as being to Message instead of a specific Message
-  // subclass.
-  friend class ::PROTOBUF_NAMESPACE_ID::Reflection;
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::SwapFieldHelper;
-
-  // ExtensionSet stores repeated message extensions as
-  // RepeatedPtrField<MessageLite>, but non-lite ExtensionSets need to implement
-  // SpaceUsedLong(), and thus need to call SpaceUsedExcludingSelfLong()
-  // reinterpreting MessageLite as Message.  ExtensionSet also needs to make use
-  // of AddFromCleared(), which is not part of the public interface.
-  friend class ExtensionSet;
-
-  // The MapFieldBase implementation needs to call protected methods directly,
-  // reinterpreting pointers as being to Message instead of a specific Message
-  // subclass.
-  friend class MapFieldBase;
-  friend class MapFieldBaseStub;
-
-  // The table-driven MergePartialFromCodedStream implementation needs to
-  // operate on RepeatedPtrField<MessageLite>.
-  friend class MergePartialFromCodedStreamHelper;
-  friend class AccessorHelper;
-  template <typename T>
-  friend struct google::protobuf::WeakRepeatedPtrField;
-  friend class internal::TcParser;  // TODO(jorg): Remove this friend.
-};
-
-template <typename GenericType>
-class GenericTypeHandler {
- public:
-  typedef GenericType Type;
-  using Movable = IsMovable<GenericType>;
-
-  static inline GenericType* New(Arena* arena) {
-    return Arena::CreateMaybeMessage<Type>(arena);
-  }
-  static inline GenericType* New(Arena* arena, GenericType&& value) {
-    return Arena::Create<GenericType>(arena, std::move(value));
-  }
-  static inline GenericType* NewFromPrototype(const GenericType* /*prototype*/,
-                                              Arena* arena = nullptr) {
-    return New(arena);
-  }
-  static inline void Delete(GenericType* value, Arena* arena) {
-    if (arena == nullptr) {
-      delete value;
-    }
-  }
-  static inline Arena* GetOwningArena(GenericType* value) {
-    return Arena::GetOwningArena<Type>(value);
-  }
-
-  static inline void Clear(GenericType* value) { value->Clear(); }
-  static void Merge(const GenericType& from, GenericType* to);
-  static inline size_t SpaceUsedLong(const GenericType& value) {
-    return value.SpaceUsedLong();
-  }
-};
-
-// NewFromPrototypeHelper() is not defined inline here, as we will need to do a
-// virtual function dispatch anyways to go from Message* to call New/Merge. (The
-// additional helper is needed as a workaround for MSVC.)
-MessageLite* NewFromPrototypeHelper(const MessageLite* prototype, Arena* arena);
-
-template <>
-inline MessageLite* GenericTypeHandler<MessageLite>::NewFromPrototype(
-    const MessageLite* prototype, Arena* arena) {
-  return NewFromPrototypeHelper(prototype, arena);
-}
-template <>
-inline Arena* GenericTypeHandler<MessageLite>::GetOwningArena(
-    MessageLite* value) {
-  return value->GetOwningArena();
-}
-
-template <typename GenericType>
-PROTOBUF_NOINLINE inline void GenericTypeHandler<GenericType>::Merge(
-    const GenericType& from, GenericType* to) {
-  to->MergeFrom(from);
-}
-template <>
-void GenericTypeHandler<MessageLite>::Merge(const MessageLite& from,
-                                            MessageLite* to);
-
-template <>
-inline void GenericTypeHandler<std::string>::Clear(std::string* value) {
-  value->clear();
-}
-template <>
-void GenericTypeHandler<std::string>::Merge(const std::string& from,
-                                            std::string* to);
-
-// Message specialization bodies defined in message.cc. This split is necessary
-// to allow proto2-lite (which includes this header) to be independent of
-// Message.
-template <>
-PROTOBUF_EXPORT Message* GenericTypeHandler<Message>::NewFromPrototype(
-    const Message* prototype, Arena* arena);
-template <>
-PROTOBUF_EXPORT Arena* GenericTypeHandler<Message>::GetOwningArena(
-    Message* value);
-
-class StringTypeHandler {
- public:
-  typedef std::string Type;
-  using Movable = IsMovable<Type>;
-
-  static inline std::string* New(Arena* arena) {
-    return Arena::Create<std::string>(arena);
-  }
-  static inline std::string* New(Arena* arena, std::string&& value) {
-    return Arena::Create<std::string>(arena, std::move(value));
-  }
-  static inline std::string* NewFromPrototype(const std::string*,
-                                              Arena* arena) {
-    return New(arena);
-  }
-  static inline Arena* GetOwningArena(std::string*) { return nullptr; }
-  static inline void Delete(std::string* value, Arena* arena) {
-    if (arena == nullptr) {
-      delete value;
-    }
-  }
-  static inline void Clear(std::string* value) { value->clear(); }
-  static inline void Merge(const std::string& from, std::string* to) {
-    *to = from;
-  }
-  static size_t SpaceUsedLong(const std::string& value) {
-    return sizeof(value) + StringSpaceUsedExcludingSelfLong(value);
-  }
-};
-
-}  // namespace internal
-
-// RepeatedPtrField is like RepeatedField, but used for repeated strings or
-// Messages.
-template <typename Element>
-class RepeatedPtrField final : private internal::RepeatedPtrFieldBase {
-
- public:
-  constexpr RepeatedPtrField();
-  explicit RepeatedPtrField(Arena* arena);
-
-  RepeatedPtrField(const RepeatedPtrField& other);
-
-  template <typename Iter,
-            typename = typename std::enable_if<std::is_constructible<
-                Element, decltype(*std::declval<Iter>())>::value>::type>
-  RepeatedPtrField(Iter begin, Iter end);
-
-  ~RepeatedPtrField();
-
-  RepeatedPtrField& operator=(const RepeatedPtrField& other);
-
-  RepeatedPtrField(RepeatedPtrField&& other) noexcept;
-  RepeatedPtrField& operator=(RepeatedPtrField&& other) noexcept;
-
-  bool empty() const;
-  int size() const;
-
-  const Element& Get(int index) const;
-  Element* Mutable(int index);
-
-  // Unlike std::vector, adding an element to a RepeatedPtrField doesn't always
-  // make a new element; it might re-use an element left over from when the
-  // field was Clear()'d or reize()'d smaller.  For this reason, Add() is the
-  // fastest API for adding a new element.
-  Element* Add();
-
-  // `Add(std::move(value));` is equivalent to `*Add() = std::move(value);`
-  // It will either move-construct to the end of this field, or swap value
-  // with the new-or-recycled element at the end of this field.  Note that
-  // this operation is very slow if this RepeatedPtrField is not on the
-  // same Arena, if any, as `value`.
-  void Add(Element&& value);
-
-  // Copying to the end of this RepeatedPtrField is slowest of all; it can't
-  // reliably copy-construct to the last element of this RepeatedPtrField, for
-  // example (unlike std::vector).
-  // We currently block this API.  The right way to add to the end is to call
-  // Add() and modify the element it points to.
-  // If you must add an existing value, call `*Add() = value;`
-  void Add(const Element& value) = delete;
-
-  // Append elements in the range [begin, end) after reserving
-  // the appropriate number of elements.
-  template <typename Iter>
-  void Add(Iter begin, Iter end);
-
-  const Element& operator[](int index) const { return Get(index); }
-  Element& operator[](int index) { return *Mutable(index); }
-
-  const Element& at(int index) const;
-  Element& at(int index);
-
-  // Removes the last element in the array.
-  // Ownership of the element is retained by the array.
-  void RemoveLast();
-
-  // Deletes elements with indices in the range [start .. start+num-1].
-  // Caution: moves all elements with indices [start+num .. ].
-  // Calling this routine inside a loop can cause quadratic behavior.
-  void DeleteSubrange(int start, int num);
-
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear();
-  void MergeFrom(const RepeatedPtrField& other);
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void CopyFrom(const RepeatedPtrField& other);
-
-  // Replaces the contents with RepeatedPtrField(begin, end).
-  template <typename Iter>
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Assign(Iter begin, Iter end);
-
-  // Reserves space to expand the field to at least the given size.  This only
-  // resizes the pointer array; it doesn't allocate any objects.  If the
-  // array is grown, it will always be at least doubled in size.
-  void Reserve(int new_size);
-
-  int Capacity() const;
-
-  // Gets the underlying array.  This pointer is possibly invalidated by
-  // any add or remove operation.
-  //
-  // This API is deprecated. Instead of directly working with element array,
-  // use APIs in repeated_field_util.h; e.g. sorting, etc.
-  PROTOBUF_DEPRECATED_MSG("Use APIs in repeated_field_util.h")
-  Element** mutable_data();
-  const Element* const* data() const;
-
-  // Swaps entire contents with "other". If they are on separate arenas, then
-  // copies data.
-  void Swap(RepeatedPtrField* other);
-
-  // Swaps entire contents with "other". Caller should guarantee that either
-  // both fields are on the same arena or both are on the heap. Swapping between
-  // different arenas with this function is disallowed and is caught via
-  // GOOGLE_DCHECK.
-  void UnsafeArenaSwap(RepeatedPtrField* other);
-
-  // Swaps two elements.
-  void SwapElements(int index1, int index2);
-
-  // STL-like iterator support
-  typedef internal::RepeatedPtrIterator<Element> iterator;
-  typedef internal::RepeatedPtrIterator<const Element> const_iterator;
-  typedef Element value_type;
-  typedef value_type& reference;
-  typedef const value_type& const_reference;
-  typedef value_type* pointer;
-  typedef const value_type* const_pointer;
-  typedef int size_type;
-  typedef ptrdiff_t difference_type;
-
-  iterator begin();
-  const_iterator begin() const;
-  const_iterator cbegin() const;
-  iterator end();
-  const_iterator end() const;
-  const_iterator cend() const;
-
-  // Reverse iterator support
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef std::reverse_iterator<iterator> reverse_iterator;
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  // Custom STL-like iterator that iterates over and returns the underlying
-  // pointers to Element rather than Element itself.
-  typedef internal::RepeatedPtrOverPtrsIterator<Element*, void*>
-      pointer_iterator;
-  typedef internal::RepeatedPtrOverPtrsIterator<const Element* const,
-                                                const void* const>
-      const_pointer_iterator;
-  pointer_iterator pointer_begin();
-  const_pointer_iterator pointer_begin() const;
-  pointer_iterator pointer_end();
-  const_pointer_iterator pointer_end() const;
-
-  // Returns (an estimate of) the number of bytes used by the repeated field,
-  // excluding sizeof(*this).
-  size_t SpaceUsedExcludingSelfLong() const;
-
-  int SpaceUsedExcludingSelf() const {
-    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
-  }
-
-  // Advanced memory management --------------------------------------
-  // When hardcore memory management becomes necessary -- as it sometimes
-  // does here at Google -- the following methods may be useful.
-
-  // Adds an already-allocated object, passing ownership to the
-  // RepeatedPtrField.
-  //
-  // Note that some special behavior occurs with respect to arenas:
-  //
-  //   (i) if this field holds submessages, the new submessage will be copied if
-  //   the original is in an arena and this RepeatedPtrField is either in a
-  //   different arena, or on the heap.
-  //   (ii) if this field holds strings, the passed-in string *must* be
-  //   heap-allocated, not arena-allocated. There is no way to dynamically check
-  //   this at runtime, so User Beware.
-  void AddAllocated(Element* value);
-
-  // Removes and returns the last element, passing ownership to the caller.
-  // Requires:  size() > 0
-  //
-  // If this RepeatedPtrField is on an arena, an object copy is required to pass
-  // ownership back to the user (for compatible semantics). Use
-  // UnsafeArenaReleaseLast() if this behavior is undesired.
-  PROTOBUF_NODISCARD Element* ReleaseLast();
-
-  // Adds an already-allocated object, skipping arena-ownership checks. The user
-  // must guarantee that the given object is in the same arena as this
-  // RepeatedPtrField.
-  // It is also useful in legacy code that uses temporary ownership to avoid
-  // copies. Example:
-  //   RepeatedPtrField<T> temp_field;
-  //   temp_field.UnsafeArenaAddAllocated(new T);
-  //   ... // Do something with temp_field
-  //   temp_field.UnsafeArenaExtractSubrange(0, temp_field.size(), nullptr);
-  // If you put temp_field on the arena this fails, because the ownership
-  // transfers to the arena at the "AddAllocated" call and is not released
-  // anymore, causing a double delete. UnsafeArenaAddAllocated prevents this.
-  void UnsafeArenaAddAllocated(Element* value);
-
-  // Removes and returns the last element.  Unlike ReleaseLast, the returned
-  // pointer is always to the original object.  This may be in an arena, in
-  // which case it would have the arena's lifetime.
-  // Requires: current_size_ > 0
-  Element* UnsafeArenaReleaseLast();
-
-  // Extracts elements with indices in the range "[start .. start+num-1]".
-  // The caller assumes ownership of the extracted elements and is responsible
-  // for deleting them when they are no longer needed.
-  // If "elements" is non-nullptr, then pointers to the extracted elements
-  // are stored in "elements[0 .. num-1]" for the convenience of the caller.
-  // If "elements" is nullptr, then the caller must use some other mechanism
-  // to perform any further operations (like deletion) on these elements.
-  // Caution: implementation also moves elements with indices [start+num ..].
-  // Calling this routine inside a loop can cause quadratic behavior.
-  //
-  // Memory copying behavior is identical to ReleaseLast(), described above: if
-  // this RepeatedPtrField is on an arena, an object copy is performed for each
-  // returned element, so that all returned element pointers are to
-  // heap-allocated copies. If this copy is not desired, the user should call
-  // UnsafeArenaExtractSubrange().
-  void ExtractSubrange(int start, int num, Element** elements);
-
-  // Identical to ExtractSubrange() described above, except that no object
-  // copies are ever performed. Instead, the raw object pointers are returned.
-  // Thus, if on an arena, the returned objects must not be freed, because they
-  // will not be heap-allocated objects.
-  void UnsafeArenaExtractSubrange(int start, int num, Element** elements);
-
-  // When elements are removed by calls to RemoveLast() or Clear(), they
-  // are not actually freed.  Instead, they are cleared and kept so that
-  // they can be reused later.  This can save lots of CPU time when
-  // repeatedly reusing a protocol message for similar purposes.
-  //
-  // Hardcore programs may choose to manipulate these cleared objects
-  // to better optimize memory management using the following routines.
-
-  // Gets the number of cleared objects that are currently being kept
-  // around for reuse.
-  int ClearedCount() const;
+                    // Copy semantics in this case. We try to improve efficiency by placing the
+                    // temporary on |other|'s arena so that messages are copied twice rather
+                    // than three times.
+                    RepeatedPtrFieldBase temp(other->GetOwningArena());
+                    temp.MergeFrom<TypeHandler>(*this);
+                    this->Clear<TypeHandler>();
+                    this->MergeFrom<TypeHandler>(*other);
+                    other->InternalSwap(&temp);
+                    temp.Destroy<TypeHandler>();  // Frees rep_ if `other` had no arena.
+                }
+
+                inline Arena* GetArena() const
+                {
+                    return arena_;
+                }
+
+            protected:
+                inline Arena* GetOwningArena() const
+                {
+                    return arena_;
+                }
+
+            private:
+                template<typename T>
+                friend class Arena::InternalHelper;
+
+                static constexpr int kInitialSize = 0;
+                // A few notes on internal representation:
+                //
+                // We use an indirected approach, with struct Rep, to keep
+                // sizeof(RepeatedPtrFieldBase) equivalent to what it was before arena support
+                // was added; namely, 3 8-byte machine words on x86-64. An instance of Rep is
+                // allocated only when the repeated field is non-empty, and it is a
+                // dynamically-sized struct (the header is directly followed by elements[]).
+                // We place arena_ and current_size_ directly in the object to avoid cache
+                // misses due to the indirection, because these fields are checked frequently.
+                // Placing all fields directly in the RepeatedPtrFieldBase instance would cost
+                // significant performance for memory-sensitive workloads.
+                Arena* arena_;
+                int current_size_;
+                int total_size_;
+                struct Rep
+                {
+                    int allocated_size;
+                    // Here we declare a huge array as a way of approximating C's "flexible
+                    // array member" feature without relying on undefined behavior.
+                    void* elements[(std::numeric_limits<int>::max() - 2 * sizeof(int)) / sizeof(void*)];
+                };
+                static constexpr size_t kRepHeaderSize = offsetof(Rep, elements);
+                Rep* rep_;
+
+                template<typename TypeHandler>
+                static inline typename TypeHandler::Type* cast(void* element)
+                {
+                    return reinterpret_cast<typename TypeHandler::Type*>(element);
+                }
+                template<typename TypeHandler>
+                static inline const typename TypeHandler::Type* cast(const void* element)
+                {
+                    return reinterpret_cast<const typename TypeHandler::Type*>(element);
+                }
+
+                // Non-templated inner function to avoid code duplication. Takes a function
+                // pointer to the type-specific (templated) inner allocate/merge loop.
+                void MergeFromInternal(const RepeatedPtrFieldBase& other, void (RepeatedPtrFieldBase::*inner_loop)(void**, void**, int, int))
+                {
+                    // Note: wrapper has already guaranteed that other.rep_ != nullptr here.
+                    int other_size = other.current_size_;
+                    void** other_elements = other.rep_->elements;
+                    void** new_elements = InternalExtend(other_size);
+                    int allocated_elems = rep_->allocated_size - current_size_;
+                    (this->*inner_loop)(new_elements, other_elements, other_size, allocated_elems);
+                    current_size_ += other_size;
+                    if (rep_->allocated_size < current_size_)
+                    {
+                        rep_->allocated_size = current_size_;
+                    }
+                }
+
+                // Merges other_elems to our_elems.
+                template<typename TypeHandler>
+                PROTOBUF_NOINLINE void MergeFromInnerLoop(void** our_elems, void** other_elems, int length, int already_allocated)
+                {
+                    if (already_allocated < length)
+                    {
+                        Arena* arena = GetOwningArena();
+                        typename TypeHandler::Type* elem_prototype =
+                            reinterpret_cast<typename TypeHandler::Type*>(other_elems[0]);
+                        for (int i = already_allocated; i < length; i++)
+                        {
+                            // Allocate a new empty element that we'll merge into below
+                            typename TypeHandler::Type* new_elem =
+                                TypeHandler::NewFromPrototype(elem_prototype, arena);
+                            our_elems[i] = new_elem;
+                        }
+                    }
+                    // Main loop that does the actual merging
+                    for (int i = 0; i < length; i++)
+                    {
+                        // Already allocated: use existing element.
+                        typename TypeHandler::Type* other_elem =
+                            reinterpret_cast<typename TypeHandler::Type*>(other_elems[i]);
+                        typename TypeHandler::Type* new_elem =
+                            reinterpret_cast<typename TypeHandler::Type*>(our_elems[i]);
+                        TypeHandler::Merge(*other_elem, new_elem);
+                    }
+                }
+
+                // Internal helper: extends array space if necessary to contain
+                // |extend_amount| more elements, and returns a pointer to the element
+                // immediately following the old list of elements.  This interface factors out
+                // common behavior from Reserve() and MergeFrom() to reduce code size.
+                // |extend_amount| must be > 0.
+                void** InternalExtend(int extend_amount);
+
+                // Internal helper for Add: adds "obj" as the next element in the
+                // array, including potentially resizing the array with Reserve if
+                // needed
+                void* AddOutOfLineHelper(void* obj);
+
+                // The reflection implementation needs to call protected methods directly,
+                // reinterpreting pointers as being to Message instead of a specific Message
+                // subclass.
+                friend class ::PROTOBUF_NAMESPACE_ID::Reflection;
+                friend class ::PROTOBUF_NAMESPACE_ID::internal::SwapFieldHelper;
+
+                // ExtensionSet stores repeated message extensions as
+                // RepeatedPtrField<MessageLite>, but non-lite ExtensionSets need to implement
+                // SpaceUsedLong(), and thus need to call SpaceUsedExcludingSelfLong()
+                // reinterpreting MessageLite as Message.  ExtensionSet also needs to make use
+                // of AddFromCleared(), which is not part of the public interface.
+                friend class ExtensionSet;
+
+                // The MapFieldBase implementation needs to call protected methods directly,
+                // reinterpreting pointers as being to Message instead of a specific Message
+                // subclass.
+                friend class MapFieldBase;
+                friend class MapFieldBaseStub;
+
+                // The table-driven MergePartialFromCodedStream implementation needs to
+                // operate on RepeatedPtrField<MessageLite>.
+                friend class MergePartialFromCodedStreamHelper;
+                friend class AccessorHelper;
+                template<typename T>
+                friend struct google::protobuf::WeakRepeatedPtrField;
+                friend class internal::TcParser;  // TODO(jorg): Remove this friend.
+            };
+
+            template<typename GenericType>
+            class GenericTypeHandler
+            {
+            public:
+                typedef GenericType Type;
+                using Movable = IsMovable<GenericType>;
+
+                static inline GenericType* New(Arena* arena)
+                {
+                    return Arena::CreateMaybeMessage<Type>(arena);
+                }
+                static inline GenericType* New(Arena* arena, GenericType&& value)
+                {
+                    return Arena::Create<GenericType>(arena, std::move(value));
+                }
+                static inline GenericType* NewFromPrototype(const GenericType* /*prototype*/, Arena* arena = nullptr)
+                {
+                    return New(arena);
+                }
+                static inline void Delete(GenericType* value, Arena* arena)
+                {
+                    if (arena == nullptr)
+                    {
+                        delete value;
+                    }
+                }
+                static inline Arena* GetOwningArena(GenericType* value)
+                {
+                    return Arena::GetOwningArena<Type>(value);
+                }
+
+                static inline void Clear(GenericType* value)
+                {
+                    value->Clear();
+                }
+                static void Merge(const GenericType& from, GenericType* to);
+                static inline size_t SpaceUsedLong(const GenericType& value)
+                {
+                    return value.SpaceUsedLong();
+                }
+            };
+
+            // NewFromPrototypeHelper() is not defined inline here, as we will need to do a
+            // virtual function dispatch anyways to go from Message* to call New/Merge. (The
+            // additional helper is needed as a workaround for MSVC.)
+            MessageLite* NewFromPrototypeHelper(const MessageLite* prototype, Arena* arena);
+
+            template<>
+            inline MessageLite* GenericTypeHandler<MessageLite>::NewFromPrototype(
+                const MessageLite* prototype, Arena* arena
+            )
+            {
+                return NewFromPrototypeHelper(prototype, arena);
+            }
+            template<>
+            inline Arena* GenericTypeHandler<MessageLite>::GetOwningArena(
+                MessageLite* value
+            )
+            {
+                return value->GetOwningArena();
+            }
+
+            template<typename GenericType>
+            PROTOBUF_NOINLINE inline void GenericTypeHandler<GenericType>::Merge(
+                const GenericType& from, GenericType* to
+            )
+            {
+                to->MergeFrom(from);
+            }
+            template<>
+            void GenericTypeHandler<MessageLite>::Merge(const MessageLite& from, MessageLite* to);
+
+            template<>
+            inline void GenericTypeHandler<std::string>::Clear(std::string* value)
+            {
+                value->clear();
+            }
+            template<>
+            void GenericTypeHandler<std::string>::Merge(const std::string& from, std::string* to);
+
+            // Message specialization bodies defined in message.cc. This split is necessary
+            // to allow proto2-lite (which includes this header) to be independent of
+            // Message.
+            template<>
+            PROTOBUF_EXPORT Message* GenericTypeHandler<Message>::NewFromPrototype(
+                const Message* prototype, Arena* arena
+            );
+            template<>
+            PROTOBUF_EXPORT Arena* GenericTypeHandler<Message>::GetOwningArena(
+                Message* value
+            );
+
+            class StringTypeHandler
+            {
+            public:
+                typedef std::string Type;
+                using Movable = IsMovable<Type>;
+
+                static inline std::string* New(Arena* arena)
+                {
+                    return Arena::Create<std::string>(arena);
+                }
+                static inline std::string* New(Arena* arena, std::string&& value)
+                {
+                    return Arena::Create<std::string>(arena, std::move(value));
+                }
+                static inline std::string* NewFromPrototype(const std::string*, Arena* arena)
+                {
+                    return New(arena);
+                }
+                static inline Arena* GetOwningArena(std::string*)
+                {
+                    return nullptr;
+                }
+                static inline void Delete(std::string* value, Arena* arena)
+                {
+                    if (arena == nullptr)
+                    {
+                        delete value;
+                    }
+                }
+                static inline void Clear(std::string* value)
+                {
+                    value->clear();
+                }
+                static inline void Merge(const std::string& from, std::string* to)
+                {
+                    *to = from;
+                }
+                static size_t SpaceUsedLong(const std::string& value)
+                {
+                    return sizeof(value) + StringSpaceUsedExcludingSelfLong(value);
+                }
+            };
+
+        }  // namespace internal
+
+        // RepeatedPtrField is like RepeatedField, but used for repeated strings or
+        // Messages.
+        template<typename Element>
+        class RepeatedPtrField final : private internal::RepeatedPtrFieldBase
+        {
+        public:
+            constexpr RepeatedPtrField();
+            explicit RepeatedPtrField(Arena* arena);
+
+            RepeatedPtrField(const RepeatedPtrField& other);
+
+            template<typename Iter, typename = typename std::enable_if<std::is_constructible<Element, decltype(*std::declval<Iter>())>::value>::type>
+            RepeatedPtrField(Iter begin, Iter end);
+
+            ~RepeatedPtrField();
+
+            RepeatedPtrField& operator=(const RepeatedPtrField& other);
+
+            RepeatedPtrField(RepeatedPtrField&& other) noexcept;
+            RepeatedPtrField& operator=(RepeatedPtrField&& other) noexcept;
+
+            bool empty() const;
+            int size() const;
+
+            const Element& Get(int index) const;
+            Element* Mutable(int index);
+
+            // Unlike std::vector, adding an element to a RepeatedPtrField doesn't always
+            // make a new element; it might re-use an element left over from when the
+            // field was Clear()'d or reize()'d smaller.  For this reason, Add() is the
+            // fastest API for adding a new element.
+            Element* Add();
+
+            // `Add(std::move(value));` is equivalent to `*Add() = std::move(value);`
+            // It will either move-construct to the end of this field, or swap value
+            // with the new-or-recycled element at the end of this field.  Note that
+            // this operation is very slow if this RepeatedPtrField is not on the
+            // same Arena, if any, as `value`.
+            void Add(Element&& value);
+
+            // Copying to the end of this RepeatedPtrField is slowest of all; it can't
+            // reliably copy-construct to the last element of this RepeatedPtrField, for
+            // example (unlike std::vector).
+            // We currently block this API.  The right way to add to the end is to call
+            // Add() and modify the element it points to.
+            // If you must add an existing value, call `*Add() = value;`
+            void Add(const Element& value) = delete;
+
+            // Append elements in the range [begin, end) after reserving
+            // the appropriate number of elements.
+            template<typename Iter>
+            void Add(Iter begin, Iter end);
+
+            const Element& operator[](int index) const
+            {
+                return Get(index);
+            }
+            Element& operator[](int index)
+            {
+                return *Mutable(index);
+            }
+
+            const Element& at(int index) const;
+            Element& at(int index);
+
+            // Removes the last element in the array.
+            // Ownership of the element is retained by the array.
+            void RemoveLast();
+
+            // Deletes elements with indices in the range [start .. start+num-1].
+            // Caution: moves all elements with indices [start+num .. ].
+            // Calling this routine inside a loop can cause quadratic behavior.
+            void DeleteSubrange(int start, int num);
+
+            PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear();
+            void MergeFrom(const RepeatedPtrField& other);
+            PROTOBUF_ATTRIBUTE_REINITIALIZES void CopyFrom(const RepeatedPtrField& other);
+
+            // Replaces the contents with RepeatedPtrField(begin, end).
+            template<typename Iter>
+            PROTOBUF_ATTRIBUTE_REINITIALIZES void Assign(Iter begin, Iter end);
+
+            // Reserves space to expand the field to at least the given size.  This only
+            // resizes the pointer array; it doesn't allocate any objects.  If the
+            // array is grown, it will always be at least doubled in size.
+            void Reserve(int new_size);
+
+            int Capacity() const;
+
+            // Gets the underlying array.  This pointer is possibly invalidated by
+            // any add or remove operation.
+            //
+            // This API is deprecated. Instead of directly working with element array,
+            // use APIs in repeated_field_util.h; e.g. sorting, etc.
+            PROTOBUF_DEPRECATED_MSG("Use APIs in repeated_field_util.h")
+            Element** mutable_data();
+            const Element* const* data() const;
+
+            // Swaps entire contents with "other". If they are on separate arenas, then
+            // copies data.
+            void Swap(RepeatedPtrField* other);
+
+            // Swaps entire contents with "other". Caller should guarantee that either
+            // both fields are on the same arena or both are on the heap. Swapping between
+            // different arenas with this function is disallowed and is caught via
+            // GOOGLE_DCHECK.
+            void UnsafeArenaSwap(RepeatedPtrField* other);
+
+            // Swaps two elements.
+            void SwapElements(int index1, int index2);
+
+            // STL-like iterator support
+            typedef internal::RepeatedPtrIterator<Element> iterator;
+            typedef internal::RepeatedPtrIterator<const Element> const_iterator;
+            typedef Element value_type;
+            typedef value_type& reference;
+            typedef const value_type& const_reference;
+            typedef value_type* pointer;
+            typedef const value_type* const_pointer;
+            typedef int size_type;
+            typedef ptrdiff_t difference_type;
+
+            iterator begin();
+            const_iterator begin() const;
+            const_iterator cbegin() const;
+            iterator end();
+            const_iterator end() const;
+            const_iterator cend() const;
+
+            // Reverse iterator support
+            typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+            typedef std::reverse_iterator<iterator> reverse_iterator;
+            reverse_iterator rbegin()
+            {
+                return reverse_iterator(end());
+            }
+            const_reverse_iterator rbegin() const
+            {
+                return const_reverse_iterator(end());
+            }
+            reverse_iterator rend()
+            {
+                return reverse_iterator(begin());
+            }
+            const_reverse_iterator rend() const
+            {
+                return const_reverse_iterator(begin());
+            }
+
+            // Custom STL-like iterator that iterates over and returns the underlying
+            // pointers to Element rather than Element itself.
+            typedef internal::RepeatedPtrOverPtrsIterator<Element*, void*>
+                pointer_iterator;
+            typedef internal::RepeatedPtrOverPtrsIterator<const Element* const, const void* const>
+                const_pointer_iterator;
+            pointer_iterator pointer_begin();
+            const_pointer_iterator pointer_begin() const;
+            pointer_iterator pointer_end();
+            const_pointer_iterator pointer_end() const;
+
+            // Returns (an estimate of) the number of bytes used by the repeated field,
+            // excluding sizeof(*this).
+            size_t SpaceUsedExcludingSelfLong() const;
+
+            int SpaceUsedExcludingSelf() const
+            {
+                return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+            }
+
+            // Advanced memory management --------------------------------------
+            // When hardcore memory management becomes necessary -- as it sometimes
+            // does here at Google -- the following methods may be useful.
+
+            // Adds an already-allocated object, passing ownership to the
+            // RepeatedPtrField.
+            //
+            // Note that some special behavior occurs with respect to arenas:
+            //
+            //   (i) if this field holds submessages, the new submessage will be copied if
+            //   the original is in an arena and this RepeatedPtrField is either in a
+            //   different arena, or on the heap.
+            //   (ii) if this field holds strings, the passed-in string *must* be
+            //   heap-allocated, not arena-allocated. There is no way to dynamically check
+            //   this at runtime, so User Beware.
+            void AddAllocated(Element* value);
+
+            // Removes and returns the last element, passing ownership to the caller.
+            // Requires:  size() > 0
+            //
+            // If this RepeatedPtrField is on an arena, an object copy is required to pass
+            // ownership back to the user (for compatible semantics). Use
+            // UnsafeArenaReleaseLast() if this behavior is undesired.
+            PROTOBUF_NODISCARD Element* ReleaseLast();
+
+            // Adds an already-allocated object, skipping arena-ownership checks. The user
+            // must guarantee that the given object is in the same arena as this
+            // RepeatedPtrField.
+            // It is also useful in legacy code that uses temporary ownership to avoid
+            // copies. Example:
+            //   RepeatedPtrField<T> temp_field;
+            //   temp_field.UnsafeArenaAddAllocated(new T);
+            //   ... // Do something with temp_field
+            //   temp_field.UnsafeArenaExtractSubrange(0, temp_field.size(), nullptr);
+            // If you put temp_field on the arena this fails, because the ownership
+            // transfers to the arena at the "AddAllocated" call and is not released
+            // anymore, causing a double delete. UnsafeArenaAddAllocated prevents this.
+            void UnsafeArenaAddAllocated(Element* value);
+
+            // Removes and returns the last element.  Unlike ReleaseLast, the returned
+            // pointer is always to the original object.  This may be in an arena, in
+            // which case it would have the arena's lifetime.
+            // Requires: current_size_ > 0
+            Element* UnsafeArenaReleaseLast();
+
+            // Extracts elements with indices in the range "[start .. start+num-1]".
+            // The caller assumes ownership of the extracted elements and is responsible
+            // for deleting them when they are no longer needed.
+            // If "elements" is non-nullptr, then pointers to the extracted elements
+            // are stored in "elements[0 .. num-1]" for the convenience of the caller.
+            // If "elements" is nullptr, then the caller must use some other mechanism
+            // to perform any further operations (like deletion) on these elements.
+            // Caution: implementation also moves elements with indices [start+num ..].
+            // Calling this routine inside a loop can cause quadratic behavior.
+            //
+            // Memory copying behavior is identical to ReleaseLast(), described above: if
+            // this RepeatedPtrField is on an arena, an object copy is performed for each
+            // returned element, so that all returned element pointers are to
+            // heap-allocated copies. If this copy is not desired, the user should call
+            // UnsafeArenaExtractSubrange().
+            void ExtractSubrange(int start, int num, Element** elements);
+
+            // Identical to ExtractSubrange() described above, except that no object
+            // copies are ever performed. Instead, the raw object pointers are returned.
+            // Thus, if on an arena, the returned objects must not be freed, because they
+            // will not be heap-allocated objects.
+            void UnsafeArenaExtractSubrange(int start, int num, Element** elements);
+
+            // When elements are removed by calls to RemoveLast() or Clear(), they
+            // are not actually freed.  Instead, they are cleared and kept so that
+            // they can be reused later.  This can save lots of CPU time when
+            // repeatedly reusing a protocol message for similar purposes.
+            //
+            // Hardcore programs may choose to manipulate these cleared objects
+            // to better optimize memory management using the following routines.
+
+            // Gets the number of cleared objects that are currently being kept
+            // around for reuse.
+            int ClearedCount() const;
 #ifndef PROTOBUF_FUTURE_BREAKING_CHANGES
-  // Adds an element to the pool of cleared objects, passing ownership to
-  // the RepeatedPtrField.  The element must be cleared prior to calling
-  // this method.
-  //
-  // This method cannot be called when either the repeated field or |value| is
-  // on an arena; both cases will trigger a GOOGLE_DCHECK-failure.
-  void AddCleared(Element* value);
-  // Removes and returns a single element from the cleared pool, passing
-  // ownership to the caller.  The element is guaranteed to be cleared.
-  // Requires:  ClearedCount() > 0
-  //
-  // This method cannot be called when the repeated field is on an arena; doing
-  // so will trigger a GOOGLE_DCHECK-failure.
-  PROTOBUF_NODISCARD Element* ReleaseCleared();
+            // Adds an element to the pool of cleared objects, passing ownership to
+            // the RepeatedPtrField.  The element must be cleared prior to calling
+            // this method.
+            //
+            // This method cannot be called when either the repeated field or |value| is
+            // on an arena; both cases will trigger a GOOGLE_DCHECK-failure.
+            void AddCleared(Element* value);
+            // Removes and returns a single element from the cleared pool, passing
+            // ownership to the caller.  The element is guaranteed to be cleared.
+            // Requires:  ClearedCount() > 0
+            //
+            // This method cannot be called when the repeated field is on an arena; doing
+            // so will trigger a GOOGLE_DCHECK-failure.
+            PROTOBUF_NODISCARD Element* ReleaseCleared();
 #endif  // !PROTOBUF_FUTURE_BREAKING_CHANGES
 
-  // Removes the element referenced by position.
-  //
-  // Returns an iterator to the element immediately following the removed
-  // element.
-  //
-  // Invalidates all iterators at or after the removed element, including end().
-  iterator erase(const_iterator position);
-
-  // Removes the elements in the range [first, last).
-  //
-  // Returns an iterator to the element immediately following the removed range.
-  //
-  // Invalidates all iterators at or after the removed range, including end().
-  iterator erase(const_iterator first, const_iterator last);
-
-  // Gets the arena on which this RepeatedPtrField stores its elements.
-  inline Arena* GetArena() const;
-
-  // For internal use only.
-  //
-  // This is public due to it being called by generated code.
-  void InternalSwap(RepeatedPtrField* other) {
-    internal::RepeatedPtrFieldBase::InternalSwap(other);
-  }
-
- private:
-  // Note:  RepeatedPtrField SHOULD NOT be subclassed by users.
-  class TypeHandler;
-
-  // Internal version of GetArena().
-  inline Arena* GetOwningArena() const;
-
-  // Implementations for ExtractSubrange(). The copying behavior must be
-  // included only if the type supports the necessary operations (e.g.,
-  // MergeFrom()), so we must resolve this at compile time. ExtractSubrange()
-  // uses SFINAE to choose one of the below implementations.
-  void ExtractSubrangeInternal(int start, int num, Element** elements,
-                               std::true_type);
-  void ExtractSubrangeInternal(int start, int num, Element** elements,
-                               std::false_type);
-
-  friend class Arena;
-
-  template <typename T>
-  friend struct WeakRepeatedPtrField;
-
-  typedef void InternalArenaConstructable_;
-
-};
-
-// -------------------------------------------------------------------
-
-template <typename Element>
-class RepeatedPtrField<Element>::TypeHandler
-    : public internal::GenericTypeHandler<Element> {};
-
-template <>
-class RepeatedPtrField<std::string>::TypeHandler
-    : public internal::StringTypeHandler {};
-
-template <typename Element>
-constexpr RepeatedPtrField<Element>::RepeatedPtrField()
-    : RepeatedPtrFieldBase() {}
-
-template <typename Element>
-inline RepeatedPtrField<Element>::RepeatedPtrField(Arena* arena)
-    : RepeatedPtrFieldBase(arena) {}
-
-template <typename Element>
-inline RepeatedPtrField<Element>::RepeatedPtrField(
-    const RepeatedPtrField& other)
-    : RepeatedPtrFieldBase() {
-  MergeFrom(other);
-}
-
-template <typename Element>
-template <typename Iter, typename>
-inline RepeatedPtrField<Element>::RepeatedPtrField(Iter begin, Iter end) {
-  Add(begin, end);
-}
-
-template <typename Element>
-RepeatedPtrField<Element>::~RepeatedPtrField() {
+            // Removes the element referenced by position.
+            //
+            // Returns an iterator to the element immediately following the removed
+            // element.
+            //
+            // Invalidates all iterators at or after the removed element, including end().
+            iterator erase(const_iterator position);
+
+            // Removes the elements in the range [first, last).
+            //
+            // Returns an iterator to the element immediately following the removed range.
+            //
+            // Invalidates all iterators at or after the removed range, including end().
+            iterator erase(const_iterator first, const_iterator last);
+
+            // Gets the arena on which this RepeatedPtrField stores its elements.
+            inline Arena* GetArena() const;
+
+            // For internal use only.
+            //
+            // This is public due to it being called by generated code.
+            void InternalSwap(RepeatedPtrField* other)
+            {
+                internal::RepeatedPtrFieldBase::InternalSwap(other);
+            }
+
+        private:
+            // Note:  RepeatedPtrField SHOULD NOT be subclassed by users.
+            class TypeHandler;
+
+            // Internal version of GetArena().
+            inline Arena* GetOwningArena() const;
+
+            // Implementations for ExtractSubrange(). The copying behavior must be
+            // included only if the type supports the necessary operations (e.g.,
+            // MergeFrom()), so we must resolve this at compile time. ExtractSubrange()
+            // uses SFINAE to choose one of the below implementations.
+            void ExtractSubrangeInternal(int start, int num, Element** elements, std::true_type);
+            void ExtractSubrangeInternal(int start, int num, Element** elements, std::false_type);
+
+            friend class Arena;
+
+            template<typename T>
+            friend struct WeakRepeatedPtrField;
+
+            typedef void InternalArenaConstructable_;
+        };
+
+        // -------------------------------------------------------------------
+
+        template<typename Element>
+        class RepeatedPtrField<Element>::TypeHandler : public internal::GenericTypeHandler<Element>
+        {
+        };
+
+        template<>
+        class RepeatedPtrField<std::string>::TypeHandler : public internal::StringTypeHandler
+        {
+        };
+
+        template<typename Element>
+        constexpr RepeatedPtrField<Element>::RepeatedPtrField() :
+            RepeatedPtrFieldBase()
+        {
+        }
+
+        template<typename Element>
+        inline RepeatedPtrField<Element>::RepeatedPtrField(Arena* arena) :
+            RepeatedPtrFieldBase(arena)
+        {
+        }
+
+        template<typename Element>
+        inline RepeatedPtrField<Element>::RepeatedPtrField(
+            const RepeatedPtrField& other
+        ) :
+            RepeatedPtrFieldBase()
+        {
+            MergeFrom(other);
+        }
+
+        template<typename Element>
+        template<typename Iter, typename>
+        inline RepeatedPtrField<Element>::RepeatedPtrField(Iter begin, Iter end)
+        {
+            Add(begin, end);
+        }
+
+        template<typename Element>
+        RepeatedPtrField<Element>::~RepeatedPtrField()
+        {
 #ifdef __cpp_if_constexpr
-  if constexpr (std::is_base_of<MessageLite, Element>::value) {
+            if constexpr (std::is_base_of<MessageLite, Element>::value)
+            {
 #else
-  if (std::is_base_of<MessageLite, Element>::value) {
+            if (std::is_base_of<MessageLite, Element>::value)
+            {
 #endif
-    if (NeedsDestroy()) DestroyProtos();
-  } else {
-    Destroy<TypeHandler>();
-  }
-}
-
-template <typename Element>
-inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
-    const RepeatedPtrField& other) {
-  if (this != &other) CopyFrom(other);
-  return *this;
-}
-
-template <typename Element>
-inline RepeatedPtrField<Element>::RepeatedPtrField(
-    RepeatedPtrField&& other) noexcept
-    : RepeatedPtrField() {
+                if (NeedsDestroy())
+                    DestroyProtos();
+            }
+            else
+            {
+                Destroy<TypeHandler>();
+            }
+        }
+
+        template<typename Element>
+        inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
+            const RepeatedPtrField& other
+        )
+        {
+            if (this != &other)
+                CopyFrom(other);
+            return *this;
+        }
+
+        template<typename Element>
+        inline RepeatedPtrField<Element>::RepeatedPtrField(
+            RepeatedPtrField&& other
+        ) noexcept
+            :
+            RepeatedPtrField()
+        {
 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-  CopyFrom(other);
+            CopyFrom(other);
 #else   // PROTOBUF_FORCE_COPY_IN_MOVE
-  // We don't just call Swap(&other) here because it would perform 3 copies if
-  // other is on an arena. This field can't be on an arena because arena
-  // construction always uses the Arena* accepting constructor.
-  if (other.GetOwningArena()) {
-    CopyFrom(other);
-  } else {
-    InternalSwap(&other);
-  }
+        // We don't just call Swap(&other) here because it would perform 3 copies if
+        // other is on an arena. This field can't be on an arena because arena
+        // construction always uses the Arena* accepting constructor.
+            if (other.GetOwningArena())
+            {
+                CopyFrom(other);
+            }
+            else
+            {
+                InternalSwap(&other);
+            }
 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-}
-
-template <typename Element>
-inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
-    RepeatedPtrField&& other) noexcept {
-  // We don't just call Swap(&other) here because it would perform 3 copies if
-  // the two fields are on different arenas.
-  if (this != &other) {
-    if (GetOwningArena() != other.GetOwningArena()
+        }
+
+        template<typename Element>
+        inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
+            RepeatedPtrField&& other
+        ) noexcept
+        {
+            // We don't just call Swap(&other) here because it would perform 3 copies if
+            // the two fields are on different arenas.
+            if (this != &other)
+            {
+                if (GetOwningArena() != other.GetOwningArena()
 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        || GetOwningArena() == nullptr
+                    || GetOwningArena() == nullptr
 #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      CopyFrom(other);
-    } else {
-      InternalSwap(&other);
-    }
-  }
-  return *this;
-}
-
-template <typename Element>
-inline bool RepeatedPtrField<Element>::empty() const {
-  return RepeatedPtrFieldBase::empty();
-}
-
-template <typename Element>
-inline int RepeatedPtrField<Element>::size() const {
-  return RepeatedPtrFieldBase::size();
-}
-
-template <typename Element>
-inline const Element& RepeatedPtrField<Element>::Get(int index) const {
-  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
-}
-
-template <typename Element>
-inline const Element& RepeatedPtrField<Element>::at(int index) const {
-  return RepeatedPtrFieldBase::at<TypeHandler>(index);
-}
-
-template <typename Element>
-inline Element& RepeatedPtrField<Element>::at(int index) {
-  return RepeatedPtrFieldBase::at<TypeHandler>(index);
-}
-
-
-template <typename Element>
-inline Element* RepeatedPtrField<Element>::Mutable(int index) {
-  return RepeatedPtrFieldBase::Mutable<TypeHandler>(index);
-}
-
-template <typename Element>
-inline Element* RepeatedPtrField<Element>::Add() {
-  return RepeatedPtrFieldBase::Add<TypeHandler>();
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::Add(Element&& value) {
-  RepeatedPtrFieldBase::Add<TypeHandler>(std::move(value));
-}
-
-template <typename Element>
-template <typename Iter>
-inline void RepeatedPtrField<Element>::Add(Iter begin, Iter end) {
-  if (std::is_base_of<
-          std::forward_iterator_tag,
-          typename std::iterator_traits<Iter>::iterator_category>::value) {
-    int reserve = std::distance(begin, end);
-    Reserve(size() + reserve);
-  }
-  for (; begin != end; ++begin) {
-    *Add() = *begin;
-  }
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::RemoveLast() {
-  RepeatedPtrFieldBase::RemoveLast<TypeHandler>();
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::DeleteSubrange(int start, int num) {
-  GOOGLE_DCHECK_GE(start, 0);
-  GOOGLE_DCHECK_GE(num, 0);
-  GOOGLE_DCHECK_LE(start + num, size());
-  for (int i = 0; i < num; ++i) {
-    RepeatedPtrFieldBase::Delete<TypeHandler>(start + i);
-  }
-  UnsafeArenaExtractSubrange(start, num, nullptr);
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::ExtractSubrange(int start, int num,
-                                                       Element** elements) {
-  typename internal::TypeImplementsMergeBehavior<
-      typename TypeHandler::Type>::type t;
-  ExtractSubrangeInternal(start, num, elements, t);
-}
-
-// ExtractSubrange() implementation for types that implement merge/copy
-// behavior.
-template <typename Element>
-inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
-    int start, int num, Element** elements, std::true_type) {
-  GOOGLE_DCHECK_GE(start, 0);
-  GOOGLE_DCHECK_GE(num, 0);
-  GOOGLE_DCHECK_LE(start + num, size());
-
-  if (num == 0) return;
-
-  GOOGLE_DCHECK_NE(elements, nullptr)
-      << "Releasing elements without transferring ownership is an unsafe "
-         "operation.  Use UnsafeArenaExtractSubrange.";
-  if (elements == nullptr) {
-    CloseGap(start, num);
-    return;
-  }
-
-  Arena* arena = GetOwningArena();
+                )
+                {
+                    CopyFrom(other);
+                }
+                else
+                {
+                    InternalSwap(&other);
+                }
+            }
+            return *this;
+        }
+
+        template<typename Element>
+        inline bool RepeatedPtrField<Element>::empty() const
+        {
+            return RepeatedPtrFieldBase::empty();
+        }
+
+        template<typename Element>
+        inline int RepeatedPtrField<Element>::size() const
+        {
+            return RepeatedPtrFieldBase::size();
+        }
+
+        template<typename Element>
+        inline const Element& RepeatedPtrField<Element>::Get(int index) const
+        {
+            return RepeatedPtrFieldBase::Get<TypeHandler>(index);
+        }
+
+        template<typename Element>
+        inline const Element& RepeatedPtrField<Element>::at(int index) const
+        {
+            return RepeatedPtrFieldBase::at<TypeHandler>(index);
+        }
+
+        template<typename Element>
+        inline Element& RepeatedPtrField<Element>::at(int index)
+        {
+            return RepeatedPtrFieldBase::at<TypeHandler>(index);
+        }
+
+        template<typename Element>
+        inline Element* RepeatedPtrField<Element>::Mutable(int index)
+        {
+            return RepeatedPtrFieldBase::Mutable<TypeHandler>(index);
+        }
+
+        template<typename Element>
+        inline Element* RepeatedPtrField<Element>::Add()
+        {
+            return RepeatedPtrFieldBase::Add<TypeHandler>();
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::Add(Element&& value)
+        {
+            RepeatedPtrFieldBase::Add<TypeHandler>(std::move(value));
+        }
+
+        template<typename Element>
+        template<typename Iter>
+        inline void RepeatedPtrField<Element>::Add(Iter begin, Iter end)
+        {
+            if (std::is_base_of<
+                    std::forward_iterator_tag,
+                    typename std::iterator_traits<Iter>::iterator_category>::value)
+            {
+                int reserve = std::distance(begin, end);
+                Reserve(size() + reserve);
+            }
+            for (; begin != end; ++begin)
+            {
+                *Add() = *begin;
+            }
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::RemoveLast()
+        {
+            RepeatedPtrFieldBase::RemoveLast<TypeHandler>();
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::DeleteSubrange(int start, int num)
+        {
+            GOOGLE_DCHECK_GE(start, 0);
+            GOOGLE_DCHECK_GE(num, 0);
+            GOOGLE_DCHECK_LE(start + num, size());
+            for (int i = 0; i < num; ++i)
+            {
+                RepeatedPtrFieldBase::Delete<TypeHandler>(start + i);
+            }
+            UnsafeArenaExtractSubrange(start, num, nullptr);
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::ExtractSubrange(int start, int num, Element** elements)
+        {
+            typename internal::TypeImplementsMergeBehavior<
+                typename TypeHandler::Type>::type t;
+            ExtractSubrangeInternal(start, num, elements, t);
+        }
+
+        // ExtractSubrange() implementation for types that implement merge/copy
+        // behavior.
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
+            int start, int num, Element** elements, std::true_type
+        )
+        {
+            GOOGLE_DCHECK_GE(start, 0);
+            GOOGLE_DCHECK_GE(num, 0);
+            GOOGLE_DCHECK_LE(start + num, size());
+
+            if (num == 0)
+                return;
+
+            GOOGLE_DCHECK_NE(elements, nullptr)
+                << "Releasing elements without transferring ownership is an unsafe "
+                   "operation.  Use UnsafeArenaExtractSubrange.";
+            if (elements == nullptr)
+            {
+                CloseGap(start, num);
+                return;
+            }
+
+            Arena* arena = GetOwningArena();
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  // Always copy.
-  for (int i = 0; i < num; ++i) {
-    elements[i] = copy<TypeHandler>(
-        RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start));
-  }
-  if (arena == nullptr) {
-    for (int i = 0; i < num; ++i) {
-      delete RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
-    }
-  }
+            // Always copy.
+            for (int i = 0; i < num; ++i)
+            {
+                elements[i] = copy<TypeHandler>(
+                    RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start)
+                );
+            }
+            if (arena == nullptr)
+            {
+                for (int i = 0; i < num; ++i)
+                {
+                    delete RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
+                }
+            }
 #else   // PROTOBUF_FORCE_COPY_IN_RELEASE
-  // If we're on an arena, we perform a copy for each element so that the
-  // returned elements are heap-allocated. Otherwise, just forward it.
-  if (arena != nullptr) {
-    for (int i = 0; i < num; ++i) {
-      elements[i] = copy<TypeHandler>(
-          RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start));
-    }
-  } else {
-    for (int i = 0; i < num; ++i) {
-      elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
-    }
-  }
+        // If we're on an arena, we perform a copy for each element so that the
+        // returned elements are heap-allocated. Otherwise, just forward it.
+            if (arena != nullptr)
+            {
+                for (int i = 0; i < num; ++i)
+                {
+                    elements[i] = copy<TypeHandler>(
+                        RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start)
+                    );
+                }
+            }
+            else
+            {
+                for (int i = 0; i < num; ++i)
+                {
+                    elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
+                }
+            }
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  CloseGap(start, num);
-}
-
-// ExtractSubrange() implementation for types that do not implement merge/copy
-// behavior.
-template <typename Element>
-inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
-    int start, int num, Element** elements, std::false_type) {
-  // This case is identical to UnsafeArenaExtractSubrange(). However, since
-  // ExtractSubrange() must return heap-allocated objects by contract, and we
-  // cannot fulfill this contract if we are an on arena, we must GOOGLE_DCHECK() that
-  // we are not on an arena.
-  GOOGLE_DCHECK(GetOwningArena() == nullptr)
-      << "ExtractSubrange() when arena is non-nullptr is only supported when "
-      << "the Element type supplies a MergeFrom() operation to make copies.";
-  UnsafeArenaExtractSubrange(start, num, elements);
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::UnsafeArenaExtractSubrange(
-    int start, int num, Element** elements) {
-  GOOGLE_DCHECK_GE(start, 0);
-  GOOGLE_DCHECK_GE(num, 0);
-  GOOGLE_DCHECK_LE(start + num, size());
-
-  if (num > 0) {
-    // Save the values of the removed elements if requested.
-    if (elements != nullptr) {
-      for (int i = 0; i < num; ++i) {
-        elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
-      }
-    }
-    CloseGap(start, num);
-  }
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::Clear() {
-  RepeatedPtrFieldBase::Clear<TypeHandler>();
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::MergeFrom(
-    const RepeatedPtrField& other) {
-  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::CopyFrom(const RepeatedPtrField& other) {
-  RepeatedPtrFieldBase::CopyFrom<TypeHandler>(other);
-}
-
-template <typename Element>
-template <typename Iter>
-inline void RepeatedPtrField<Element>::Assign(Iter begin, Iter end) {
-  Clear();
-  Add(begin, end);
-}
-
-template <typename Element>
-inline typename RepeatedPtrField<Element>::iterator
-RepeatedPtrField<Element>::erase(const_iterator position) {
-  return erase(position, position + 1);
-}
-
-template <typename Element>
-inline typename RepeatedPtrField<Element>::iterator
-RepeatedPtrField<Element>::erase(const_iterator first, const_iterator last) {
-  size_type pos_offset = std::distance(cbegin(), first);
-  size_type last_offset = std::distance(cbegin(), last);
-  DeleteSubrange(pos_offset, last_offset - pos_offset);
-  return begin() + pos_offset;
-}
-
-template <typename Element>
-inline Element** RepeatedPtrField<Element>::mutable_data() {
-  return RepeatedPtrFieldBase::mutable_data<TypeHandler>();
-}
-
-template <typename Element>
-inline const Element* const* RepeatedPtrField<Element>::data() const {
-  return RepeatedPtrFieldBase::data<TypeHandler>();
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::Swap(RepeatedPtrField* other) {
-  if (this == other) return;
-  RepeatedPtrFieldBase::Swap<TypeHandler>(other);
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::UnsafeArenaSwap(
-    RepeatedPtrField* other) {
-  if (this == other) return;
-  GOOGLE_DCHECK_EQ(GetOwningArena(), other->GetOwningArena());
-  RepeatedPtrFieldBase::InternalSwap(other);
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::SwapElements(int index1, int index2) {
-  RepeatedPtrFieldBase::SwapElements(index1, index2);
-}
-
-template <typename Element>
-inline Arena* RepeatedPtrField<Element>::GetArena() const {
-  return RepeatedPtrFieldBase::GetArena();
-}
-
-template <typename Element>
-inline Arena* RepeatedPtrField<Element>::GetOwningArena() const {
-  return RepeatedPtrFieldBase::GetOwningArena();
-}
-
-template <typename Element>
-inline size_t RepeatedPtrField<Element>::SpaceUsedExcludingSelfLong() const {
-  return RepeatedPtrFieldBase::SpaceUsedExcludingSelfLong<TypeHandler>();
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::AddAllocated(Element* value) {
-  RepeatedPtrFieldBase::AddAllocated<TypeHandler>(value);
-}
-
-template <typename Element>
-inline void RepeatedPtrField<Element>::UnsafeArenaAddAllocated(Element* value) {
-  RepeatedPtrFieldBase::UnsafeArenaAddAllocated<TypeHandler>(value);
-}
-
-template <typename Element>
-inline Element* RepeatedPtrField<Element>::ReleaseLast() {
-  return RepeatedPtrFieldBase::ReleaseLast<TypeHandler>();
-}
-
-template <typename Element>
-inline Element* RepeatedPtrField<Element>::UnsafeArenaReleaseLast() {
-  return RepeatedPtrFieldBase::UnsafeArenaReleaseLast<TypeHandler>();
-}
-
-template <typename Element>
-inline int RepeatedPtrField<Element>::ClearedCount() const {
-  return RepeatedPtrFieldBase::ClearedCount();
-}
+            CloseGap(start, num);
+        }
+
+        // ExtractSubrange() implementation for types that do not implement merge/copy
+        // behavior.
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
+            int start, int num, Element** elements, std::false_type
+        )
+        {
+            // This case is identical to UnsafeArenaExtractSubrange(). However, since
+            // ExtractSubrange() must return heap-allocated objects by contract, and we
+            // cannot fulfill this contract if we are an on arena, we must GOOGLE_DCHECK() that
+            // we are not on an arena.
+            GOOGLE_DCHECK(GetOwningArena() == nullptr)
+                << "ExtractSubrange() when arena is non-nullptr is only supported when "
+                << "the Element type supplies a MergeFrom() operation to make copies.";
+            UnsafeArenaExtractSubrange(start, num, elements);
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::UnsafeArenaExtractSubrange(
+            int start, int num, Element** elements
+        )
+        {
+            GOOGLE_DCHECK_GE(start, 0);
+            GOOGLE_DCHECK_GE(num, 0);
+            GOOGLE_DCHECK_LE(start + num, size());
+
+            if (num > 0)
+            {
+                // Save the values of the removed elements if requested.
+                if (elements != nullptr)
+                {
+                    for (int i = 0; i < num; ++i)
+                    {
+                        elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
+                    }
+                }
+                CloseGap(start, num);
+            }
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::Clear()
+        {
+            RepeatedPtrFieldBase::Clear<TypeHandler>();
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::MergeFrom(
+            const RepeatedPtrField& other
+        )
+        {
+            RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::CopyFrom(const RepeatedPtrField& other)
+        {
+            RepeatedPtrFieldBase::CopyFrom<TypeHandler>(other);
+        }
+
+        template<typename Element>
+        template<typename Iter>
+        inline void RepeatedPtrField<Element>::Assign(Iter begin, Iter end)
+        {
+            Clear();
+            Add(begin, end);
+        }
+
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::iterator
+            RepeatedPtrField<Element>::erase(const_iterator position)
+        {
+            return erase(position, position + 1);
+        }
+
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::iterator
+            RepeatedPtrField<Element>::erase(const_iterator first, const_iterator last)
+        {
+            size_type pos_offset = std::distance(cbegin(), first);
+            size_type last_offset = std::distance(cbegin(), last);
+            DeleteSubrange(pos_offset, last_offset - pos_offset);
+            return begin() + pos_offset;
+        }
+
+        template<typename Element>
+        inline Element** RepeatedPtrField<Element>::mutable_data()
+        {
+            return RepeatedPtrFieldBase::mutable_data<TypeHandler>();
+        }
+
+        template<typename Element>
+        inline const Element* const* RepeatedPtrField<Element>::data() const
+        {
+            return RepeatedPtrFieldBase::data<TypeHandler>();
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::Swap(RepeatedPtrField* other)
+        {
+            if (this == other)
+                return;
+            RepeatedPtrFieldBase::Swap<TypeHandler>(other);
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::UnsafeArenaSwap(
+            RepeatedPtrField* other
+        )
+        {
+            if (this == other)
+                return;
+            GOOGLE_DCHECK_EQ(GetOwningArena(), other->GetOwningArena());
+            RepeatedPtrFieldBase::InternalSwap(other);
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::SwapElements(int index1, int index2)
+        {
+            RepeatedPtrFieldBase::SwapElements(index1, index2);
+        }
+
+        template<typename Element>
+        inline Arena* RepeatedPtrField<Element>::GetArena() const
+        {
+            return RepeatedPtrFieldBase::GetArena();
+        }
+
+        template<typename Element>
+        inline Arena* RepeatedPtrField<Element>::GetOwningArena() const
+        {
+            return RepeatedPtrFieldBase::GetOwningArena();
+        }
+
+        template<typename Element>
+        inline size_t RepeatedPtrField<Element>::SpaceUsedExcludingSelfLong() const
+        {
+            return RepeatedPtrFieldBase::SpaceUsedExcludingSelfLong<TypeHandler>();
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::AddAllocated(Element* value)
+        {
+            RepeatedPtrFieldBase::AddAllocated<TypeHandler>(value);
+        }
+
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::UnsafeArenaAddAllocated(Element* value)
+        {
+            RepeatedPtrFieldBase::UnsafeArenaAddAllocated<TypeHandler>(value);
+        }
+
+        template<typename Element>
+        inline Element* RepeatedPtrField<Element>::ReleaseLast()
+        {
+            return RepeatedPtrFieldBase::ReleaseLast<TypeHandler>();
+        }
+
+        template<typename Element>
+        inline Element* RepeatedPtrField<Element>::UnsafeArenaReleaseLast()
+        {
+            return RepeatedPtrFieldBase::UnsafeArenaReleaseLast<TypeHandler>();
+        }
+
+        template<typename Element>
+        inline int RepeatedPtrField<Element>::ClearedCount() const
+        {
+            return RepeatedPtrFieldBase::ClearedCount();
+        }
 
 #ifndef PROTOBUF_FUTURE_BREAKING_CHANGES
-template <typename Element>
-inline void RepeatedPtrField<Element>::AddCleared(Element* value) {
-  return RepeatedPtrFieldBase::AddCleared<TypeHandler>(value);
-}
-
-template <typename Element>
-inline Element* RepeatedPtrField<Element>::ReleaseCleared() {
-  return RepeatedPtrFieldBase::ReleaseCleared<TypeHandler>();
-}
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::AddCleared(Element* value)
+        {
+            return RepeatedPtrFieldBase::AddCleared<TypeHandler>(value);
+        }
+
+        template<typename Element>
+        inline Element* RepeatedPtrField<Element>::ReleaseCleared()
+        {
+            return RepeatedPtrFieldBase::ReleaseCleared<TypeHandler>();
+        }
 #endif  // !PROTOBUF_FUTURE_BREAKING_CHANGES
 
-template <typename Element>
-inline void RepeatedPtrField<Element>::Reserve(int new_size) {
-  return RepeatedPtrFieldBase::Reserve(new_size);
-}
-
-template <typename Element>
-inline int RepeatedPtrField<Element>::Capacity() const {
-  return RepeatedPtrFieldBase::Capacity();
-}
-
-// -------------------------------------------------------------------
-
-namespace internal {
-
-// STL-like iterator implementation for RepeatedPtrField.  You should not
-// refer to this class directly; use RepeatedPtrField<T>::iterator instead.
-//
-// The iterator for RepeatedPtrField<T>, RepeatedPtrIterator<T>, is
-// very similar to iterator_ptr<T**> in util/gtl/iterator_adaptors.h,
-// but adds random-access operators and is modified to wrap a void** base
-// iterator (since RepeatedPtrField stores its array as a void* array and
-// casting void** to T** would violate C++ aliasing rules).
-//
-// This code based on net/proto/proto-array-internal.h by Jeffrey Yasskin
-// (jyasskin@google.com).
-template <typename Element>
-class RepeatedPtrIterator {
- public:
-  using iterator = RepeatedPtrIterator<Element>;
-  using iterator_category = std::random_access_iterator_tag;
-  using value_type = typename std::remove_const<Element>::type;
-  using difference_type = std::ptrdiff_t;
-  using pointer = Element*;
-  using reference = Element&;
-
-  RepeatedPtrIterator() : it_(nullptr) {}
-  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
-
-  // Allows "upcasting" from RepeatedPtrIterator<T**> to
-  // RepeatedPtrIterator<const T*const*>.
-  template <typename OtherElement,
-            typename std::enable_if<std::is_convertible<
-                OtherElement*, pointer>::value>::type* = nullptr>
-  RepeatedPtrIterator(const RepeatedPtrIterator<OtherElement>& other)
-      : it_(other.it_) {}
-
-  // dereferenceable
-  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
-  pointer operator->() const { return &(operator*()); }
-
-  // {inc,dec}rementable
-  iterator& operator++() {
-    ++it_;
-    return *this;
-  }
-  iterator operator++(int) { return iterator(it_++); }
-  iterator& operator--() {
-    --it_;
-    return *this;
-  }
-  iterator operator--(int) { return iterator(it_--); }
-
-  // equality_comparable
-  friend bool operator==(const iterator& x, const iterator& y) {
-    return x.it_ == y.it_;
-  }
-  friend bool operator!=(const iterator& x, const iterator& y) {
-    return x.it_ != y.it_;
-  }
-
-  // less_than_comparable
-  friend bool operator<(const iterator& x, const iterator& y) {
-    return x.it_ < y.it_;
-  }
-  friend bool operator<=(const iterator& x, const iterator& y) {
-    return x.it_ <= y.it_;
-  }
-  friend bool operator>(const iterator& x, const iterator& y) {
-    return x.it_ > y.it_;
-  }
-  friend bool operator>=(const iterator& x, const iterator& y) {
-    return x.it_ >= y.it_;
-  }
-
-  // addable, subtractable
-  iterator& operator+=(difference_type d) {
-    it_ += d;
-    return *this;
-  }
-  friend iterator operator+(iterator it, const difference_type d) {
-    it += d;
-    return it;
-  }
-  friend iterator operator+(const difference_type d, iterator it) {
-    it += d;
-    return it;
-  }
-  iterator& operator-=(difference_type d) {
-    it_ -= d;
-    return *this;
-  }
-  friend iterator operator-(iterator it, difference_type d) {
-    it -= d;
-    return it;
-  }
-
-  // indexable
-  reference operator[](difference_type d) const { return *(*this + d); }
-
-  // random access iterator
-  friend difference_type operator-(iterator it1, iterator it2) {
-    return it1.it_ - it2.it_;
-  }
-
- private:
-  template <typename OtherElement>
-  friend class RepeatedPtrIterator;
-
-  // The internal iterator.
-  void* const* it_;
-};
-
-// Provides an iterator that operates on pointers to the underlying objects
-// rather than the objects themselves as RepeatedPtrIterator does.
-// Consider using this when working with stl algorithms that change
-// the array.
-// The VoidPtr template parameter holds the type-agnostic pointer value
-// referenced by the iterator.  It should either be "void *" for a mutable
-// iterator, or "const void* const" for a constant iterator.
-template <typename Element, typename VoidPtr>
-class RepeatedPtrOverPtrsIterator {
- public:
-  using iterator = RepeatedPtrOverPtrsIterator<Element, VoidPtr>;
-  using iterator_category = std::random_access_iterator_tag;
-  using value_type = typename std::remove_const<Element>::type;
-  using difference_type = std::ptrdiff_t;
-  using pointer = Element*;
-  using reference = Element&;
-
-  RepeatedPtrOverPtrsIterator() : it_(nullptr) {}
-  explicit RepeatedPtrOverPtrsIterator(VoidPtr* it) : it_(it) {}
-
-  // Allows "upcasting" from RepeatedPtrOverPtrsIterator<T**> to
-  // RepeatedPtrOverPtrsIterator<const T*const*>.
-  template <
-      typename OtherElement, typename OtherVoidPtr,
-      typename std::enable_if<
-          std::is_convertible<OtherElement*, pointer>::value &&
-          std::is_convertible<OtherVoidPtr*, VoidPtr>::value>::type* = nullptr>
-  RepeatedPtrOverPtrsIterator(
-      const RepeatedPtrOverPtrsIterator<OtherElement, OtherVoidPtr>& other)
-      : it_(other.it_) {}
-
-  // dereferenceable
-  reference operator*() const { return *reinterpret_cast<Element*>(it_); }
-  pointer operator->() const { return &(operator*()); }
-
-  // {inc,dec}rementable
-  iterator& operator++() {
-    ++it_;
-    return *this;
-  }
-  iterator operator++(int) { return iterator(it_++); }
-  iterator& operator--() {
-    --it_;
-    return *this;
-  }
-  iterator operator--(int) { return iterator(it_--); }
-
-  // equality_comparable
-  friend bool operator==(const iterator& x, const iterator& y) {
-    return x.it_ == y.it_;
-  }
-  friend bool operator!=(const iterator& x, const iterator& y) {
-    return x.it_ != y.it_;
-  }
-
-  // less_than_comparable
-  friend bool operator<(const iterator& x, const iterator& y) {
-    return x.it_ < y.it_;
-  }
-  friend bool operator<=(const iterator& x, const iterator& y) {
-    return x.it_ <= y.it_;
-  }
-  friend bool operator>(const iterator& x, const iterator& y) {
-    return x.it_ > y.it_;
-  }
-  friend bool operator>=(const iterator& x, const iterator& y) {
-    return x.it_ >= y.it_;
-  }
-
-  // addable, subtractable
-  iterator& operator+=(difference_type d) {
-    it_ += d;
-    return *this;
-  }
-  friend iterator operator+(iterator it, difference_type d) {
-    it += d;
-    return it;
-  }
-  friend iterator operator+(difference_type d, iterator it) {
-    it += d;
-    return it;
-  }
-  iterator& operator-=(difference_type d) {
-    it_ -= d;
-    return *this;
-  }
-  friend iterator operator-(iterator it, difference_type d) {
-    it -= d;
-    return it;
-  }
-
-  // indexable
-  reference operator[](difference_type d) const { return *(*this + d); }
-
-  // random access iterator
-  friend difference_type operator-(iterator it1, iterator it2) {
-    return it1.it_ - it2.it_;
-  }
-
- private:
-  template <typename OtherElement, typename OtherVoidPtr>
-  friend class RepeatedPtrOverPtrsIterator;
-
-  // The internal iterator.
-  VoidPtr* it_;
-};
-
-}  // namespace internal
-
-template <typename Element>
-inline typename RepeatedPtrField<Element>::iterator
-RepeatedPtrField<Element>::begin() {
-  return iterator(raw_data());
-}
-template <typename Element>
-inline typename RepeatedPtrField<Element>::const_iterator
-RepeatedPtrField<Element>::begin() const {
-  return iterator(raw_data());
-}
-template <typename Element>
-inline typename RepeatedPtrField<Element>::const_iterator
-RepeatedPtrField<Element>::cbegin() const {
-  return begin();
-}
-template <typename Element>
-inline typename RepeatedPtrField<Element>::iterator
-RepeatedPtrField<Element>::end() {
-  return iterator(raw_data() + size());
-}
-template <typename Element>
-inline typename RepeatedPtrField<Element>::const_iterator
-RepeatedPtrField<Element>::end() const {
-  return iterator(raw_data() + size());
-}
-template <typename Element>
-inline typename RepeatedPtrField<Element>::const_iterator
-RepeatedPtrField<Element>::cend() const {
-  return end();
-}
-
-template <typename Element>
-inline typename RepeatedPtrField<Element>::pointer_iterator
-RepeatedPtrField<Element>::pointer_begin() {
-  return pointer_iterator(raw_mutable_data());
-}
-template <typename Element>
-inline typename RepeatedPtrField<Element>::const_pointer_iterator
-RepeatedPtrField<Element>::pointer_begin() const {
-  return const_pointer_iterator(const_cast<const void* const*>(raw_data()));
-}
-template <typename Element>
-inline typename RepeatedPtrField<Element>::pointer_iterator
-RepeatedPtrField<Element>::pointer_end() {
-  return pointer_iterator(raw_mutable_data() + size());
-}
-template <typename Element>
-inline typename RepeatedPtrField<Element>::const_pointer_iterator
-RepeatedPtrField<Element>::pointer_end() const {
-  return const_pointer_iterator(
-      const_cast<const void* const*>(raw_data() + size()));
-}
-
-// Iterators and helper functions that follow the spirit of the STL
-// std::back_insert_iterator and std::back_inserter but are tailor-made
-// for RepeatedField and RepeatedPtrField. Typical usage would be:
-//
-//   std::copy(some_sequence.begin(), some_sequence.end(),
-//             RepeatedFieldBackInserter(proto.mutable_sequence()));
-//
-// Ported by johannes from util/gtl/proto-array-iterators.h
-
-namespace internal {
-
-// A back inserter for RepeatedPtrField objects.
-template <typename T>
-class RepeatedPtrFieldBackInsertIterator {
- public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = T;
-  using pointer = void;
-  using reference = void;
-  using difference_type = std::ptrdiff_t;
-
-  RepeatedPtrFieldBackInsertIterator(RepeatedPtrField<T>* const mutable_field)
-      : field_(mutable_field) {}
-  RepeatedPtrFieldBackInsertIterator<T>& operator=(const T& value) {
-    *field_->Add() = value;
-    return *this;
-  }
-  RepeatedPtrFieldBackInsertIterator<T>& operator=(
-      const T* const ptr_to_value) {
-    *field_->Add() = *ptr_to_value;
-    return *this;
-  }
-  RepeatedPtrFieldBackInsertIterator<T>& operator=(T&& value) {
-    *field_->Add() = std::move(value);
-    return *this;
-  }
-  RepeatedPtrFieldBackInsertIterator<T>& operator*() { return *this; }
-  RepeatedPtrFieldBackInsertIterator<T>& operator++() { return *this; }
-  RepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */) {
-    return *this;
-  }
-
- private:
-  RepeatedPtrField<T>* field_;
-};
-
-// A back inserter for RepeatedPtrFields that inserts by transferring ownership
-// of a pointer.
-template <typename T>
-class AllocatedRepeatedPtrFieldBackInsertIterator {
- public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = T;
-  using pointer = void;
-  using reference = void;
-  using difference_type = std::ptrdiff_t;
-
-  explicit AllocatedRepeatedPtrFieldBackInsertIterator(
-      RepeatedPtrField<T>* const mutable_field)
-      : field_(mutable_field) {}
-  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
-      T* const ptr_to_value) {
-    field_->AddAllocated(ptr_to_value);
-    return *this;
-  }
-  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() { return *this; }
-  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() { return *this; }
-  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */) {
-    return *this;
-  }
-
- private:
-  RepeatedPtrField<T>* field_;
-};
-
-// Almost identical to AllocatedRepeatedPtrFieldBackInsertIterator. This one
-// uses the UnsafeArenaAddAllocated instead.
-template <typename T>
-class UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator {
- public:
-  using iterator_category = std::output_iterator_tag;
-  using value_type = T;
-  using pointer = void;
-  using reference = void;
-  using difference_type = std::ptrdiff_t;
-
-  explicit UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator(
-      RepeatedPtrField<T>* const mutable_field)
-      : field_(mutable_field) {}
-  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
-      T const* const ptr_to_value) {
-    field_->UnsafeArenaAddAllocated(const_cast<T*>(ptr_to_value));
-    return *this;
-  }
-  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() {
-    return *this;
-  }
-  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() {
-    return *this;
-  }
-  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(
-      int /* unused */) {
-    return *this;
-  }
-
- private:
-  RepeatedPtrField<T>* field_;
-};
-
-}  // namespace internal
-
-// Provides a back insert iterator for RepeatedPtrField instances,
-// similar to std::back_inserter().
-template <typename T>
-internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedPtrFieldBackInserter(
-    RepeatedPtrField<T>* const mutable_field) {
-  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
-}
-
-// Special back insert iterator for RepeatedPtrField instances, just in
-// case someone wants to write generic template code that can access both
-// RepeatedFields and RepeatedPtrFields using a common name.
-template <typename T>
-internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedFieldBackInserter(
-    RepeatedPtrField<T>* const mutable_field) {
-  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
-}
-
-// Provides a back insert iterator for RepeatedPtrField instances
-// similar to std::back_inserter() which transfers the ownership while
-// copying elements.
-template <typename T>
-internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>
-AllocatedRepeatedPtrFieldBackInserter(
-    RepeatedPtrField<T>* const mutable_field) {
-  return internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>(
-      mutable_field);
-}
-
-// Similar to AllocatedRepeatedPtrFieldBackInserter, using
-// UnsafeArenaAddAllocated instead of AddAllocated.
-// This is slightly faster if that matters. It is also useful in legacy code
-// that uses temporary ownership to avoid copies. Example:
-//   RepeatedPtrField<T> temp_field;
-//   temp_field.UnsafeArenaAddAllocated(new T);
-//   ... // Do something with temp_field
-//   temp_field.UnsafeArenaExtractSubrange(0, temp_field.size(), nullptr);
-// Putting temp_field on the arena fails because the ownership transfers to the
-// arena at the "AddAllocated" call and is not released anymore causing a
-// double delete. This function uses UnsafeArenaAddAllocated to prevent this.
-template <typename T>
-internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>
-UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
-    RepeatedPtrField<T>* const mutable_field) {
-  return internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>(
-      mutable_field);
-}
-
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
-    RepeatedPtrField<std::string>;
-
-}  // namespace protobuf
+        template<typename Element>
+        inline void RepeatedPtrField<Element>::Reserve(int new_size)
+        {
+            return RepeatedPtrFieldBase::Reserve(new_size);
+        }
+
+        template<typename Element>
+        inline int RepeatedPtrField<Element>::Capacity() const
+        {
+            return RepeatedPtrFieldBase::Capacity();
+        }
+
+        // -------------------------------------------------------------------
+
+        namespace internal
+        {
+
+            // STL-like iterator implementation for RepeatedPtrField.  You should not
+            // refer to this class directly; use RepeatedPtrField<T>::iterator instead.
+            //
+            // The iterator for RepeatedPtrField<T>, RepeatedPtrIterator<T>, is
+            // very similar to iterator_ptr<T**> in util/gtl/iterator_adaptors.h,
+            // but adds random-access operators and is modified to wrap a void** base
+            // iterator (since RepeatedPtrField stores its array as a void* array and
+            // casting void** to T** would violate C++ aliasing rules).
+            //
+            // This code based on net/proto/proto-array-internal.h by Jeffrey Yasskin
+            // (jyasskin@google.com).
+            template<typename Element>
+            class RepeatedPtrIterator
+            {
+            public:
+                using iterator = RepeatedPtrIterator<Element>;
+                using iterator_category = std::random_access_iterator_tag;
+                using value_type = typename std::remove_const<Element>::type;
+                using difference_type = std::ptrdiff_t;
+                using pointer = Element*;
+                using reference = Element&;
+
+                RepeatedPtrIterator() :
+                    it_(nullptr)
+                {
+                }
+                explicit RepeatedPtrIterator(void* const* it) :
+                    it_(it)
+                {
+                }
+
+                // Allows "upcasting" from RepeatedPtrIterator<T**> to
+                // RepeatedPtrIterator<const T*const*>.
+                template<typename OtherElement, typename std::enable_if<std::is_convertible<OtherElement*, pointer>::value>::type* = nullptr>
+                RepeatedPtrIterator(const RepeatedPtrIterator<OtherElement>& other) :
+                    it_(other.it_)
+                {
+                }
+
+                // dereferenceable
+                reference operator*() const
+                {
+                    return *reinterpret_cast<Element*>(*it_);
+                }
+                pointer operator->() const
+                {
+                    return &(operator*());
+                }
+
+                // {inc,dec}rementable
+                iterator& operator++()
+                {
+                    ++it_;
+                    return *this;
+                }
+                iterator operator++(int)
+                {
+                    return iterator(it_++);
+                }
+                iterator& operator--()
+                {
+                    --it_;
+                    return *this;
+                }
+                iterator operator--(int)
+                {
+                    return iterator(it_--);
+                }
+
+                // equality_comparable
+                friend bool operator==(const iterator& x, const iterator& y)
+                {
+                    return x.it_ == y.it_;
+                }
+                friend bool operator!=(const iterator& x, const iterator& y)
+                {
+                    return x.it_ != y.it_;
+                }
+
+                // less_than_comparable
+                friend bool operator<(const iterator& x, const iterator& y)
+                {
+                    return x.it_ < y.it_;
+                }
+                friend bool operator<=(const iterator& x, const iterator& y)
+                {
+                    return x.it_ <= y.it_;
+                }
+                friend bool operator>(const iterator& x, const iterator& y)
+                {
+                    return x.it_ > y.it_;
+                }
+                friend bool operator>=(const iterator& x, const iterator& y)
+                {
+                    return x.it_ >= y.it_;
+                }
+
+                // addable, subtractable
+                iterator& operator+=(difference_type d)
+                {
+                    it_ += d;
+                    return *this;
+                }
+                friend iterator operator+(iterator it, const difference_type d)
+                {
+                    it += d;
+                    return it;
+                }
+                friend iterator operator+(const difference_type d, iterator it)
+                {
+                    it += d;
+                    return it;
+                }
+                iterator& operator-=(difference_type d)
+                {
+                    it_ -= d;
+                    return *this;
+                }
+                friend iterator operator-(iterator it, difference_type d)
+                {
+                    it -= d;
+                    return it;
+                }
+
+                // indexable
+                reference operator[](difference_type d) const
+                {
+                    return *(*this + d);
+                }
+
+                // random access iterator
+                friend difference_type operator-(iterator it1, iterator it2)
+                {
+                    return it1.it_ - it2.it_;
+                }
+
+            private:
+                template<typename OtherElement>
+                friend class RepeatedPtrIterator;
+
+                // The internal iterator.
+                void* const* it_;
+            };
+
+            // Provides an iterator that operates on pointers to the underlying objects
+            // rather than the objects themselves as RepeatedPtrIterator does.
+            // Consider using this when working with stl algorithms that change
+            // the array.
+            // The VoidPtr template parameter holds the type-agnostic pointer value
+            // referenced by the iterator.  It should either be "void *" for a mutable
+            // iterator, or "const void* const" for a constant iterator.
+            template<typename Element, typename VoidPtr>
+            class RepeatedPtrOverPtrsIterator
+            {
+            public:
+                using iterator = RepeatedPtrOverPtrsIterator<Element, VoidPtr>;
+                using iterator_category = std::random_access_iterator_tag;
+                using value_type = typename std::remove_const<Element>::type;
+                using difference_type = std::ptrdiff_t;
+                using pointer = Element*;
+                using reference = Element&;
+
+                RepeatedPtrOverPtrsIterator() :
+                    it_(nullptr)
+                {
+                }
+                explicit RepeatedPtrOverPtrsIterator(VoidPtr* it) :
+                    it_(it)
+                {
+                }
+
+                // Allows "upcasting" from RepeatedPtrOverPtrsIterator<T**> to
+                // RepeatedPtrOverPtrsIterator<const T*const*>.
+                template<
+                    typename OtherElement,
+                    typename OtherVoidPtr,
+                    typename std::enable_if<
+                        std::is_convertible<OtherElement*, pointer>::value &&
+                        std::is_convertible<OtherVoidPtr*, VoidPtr>::value>::type* = nullptr>
+                RepeatedPtrOverPtrsIterator(
+                    const RepeatedPtrOverPtrsIterator<OtherElement, OtherVoidPtr>& other
+                ) :
+                    it_(other.it_)
+                {
+                }
+
+                // dereferenceable
+                reference operator*() const
+                {
+                    return *reinterpret_cast<Element*>(it_);
+                }
+                pointer operator->() const
+                {
+                    return &(operator*());
+                }
+
+                // {inc,dec}rementable
+                iterator& operator++()
+                {
+                    ++it_;
+                    return *this;
+                }
+                iterator operator++(int)
+                {
+                    return iterator(it_++);
+                }
+                iterator& operator--()
+                {
+                    --it_;
+                    return *this;
+                }
+                iterator operator--(int)
+                {
+                    return iterator(it_--);
+                }
+
+                // equality_comparable
+                friend bool operator==(const iterator& x, const iterator& y)
+                {
+                    return x.it_ == y.it_;
+                }
+                friend bool operator!=(const iterator& x, const iterator& y)
+                {
+                    return x.it_ != y.it_;
+                }
+
+                // less_than_comparable
+                friend bool operator<(const iterator& x, const iterator& y)
+                {
+                    return x.it_ < y.it_;
+                }
+                friend bool operator<=(const iterator& x, const iterator& y)
+                {
+                    return x.it_ <= y.it_;
+                }
+                friend bool operator>(const iterator& x, const iterator& y)
+                {
+                    return x.it_ > y.it_;
+                }
+                friend bool operator>=(const iterator& x, const iterator& y)
+                {
+                    return x.it_ >= y.it_;
+                }
+
+                // addable, subtractable
+                iterator& operator+=(difference_type d)
+                {
+                    it_ += d;
+                    return *this;
+                }
+                friend iterator operator+(iterator it, difference_type d)
+                {
+                    it += d;
+                    return it;
+                }
+                friend iterator operator+(difference_type d, iterator it)
+                {
+                    it += d;
+                    return it;
+                }
+                iterator& operator-=(difference_type d)
+                {
+                    it_ -= d;
+                    return *this;
+                }
+                friend iterator operator-(iterator it, difference_type d)
+                {
+                    it -= d;
+                    return it;
+                }
+
+                // indexable
+                reference operator[](difference_type d) const
+                {
+                    return *(*this + d);
+                }
+
+                // random access iterator
+                friend difference_type operator-(iterator it1, iterator it2)
+                {
+                    return it1.it_ - it2.it_;
+                }
+
+            private:
+                template<typename OtherElement, typename OtherVoidPtr>
+                friend class RepeatedPtrOverPtrsIterator;
+
+                // The internal iterator.
+                VoidPtr* it_;
+            };
+
+        }  // namespace internal
+
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::iterator
+            RepeatedPtrField<Element>::begin()
+        {
+            return iterator(raw_data());
+        }
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::const_iterator
+            RepeatedPtrField<Element>::begin() const
+        {
+            return iterator(raw_data());
+        }
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::const_iterator
+            RepeatedPtrField<Element>::cbegin() const
+        {
+            return begin();
+        }
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::iterator
+            RepeatedPtrField<Element>::end()
+        {
+            return iterator(raw_data() + size());
+        }
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::const_iterator
+            RepeatedPtrField<Element>::end() const
+        {
+            return iterator(raw_data() + size());
+        }
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::const_iterator
+            RepeatedPtrField<Element>::cend() const
+        {
+            return end();
+        }
+
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::pointer_iterator
+            RepeatedPtrField<Element>::pointer_begin()
+        {
+            return pointer_iterator(raw_mutable_data());
+        }
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::const_pointer_iterator
+            RepeatedPtrField<Element>::pointer_begin() const
+        {
+            return const_pointer_iterator(const_cast<const void* const*>(raw_data()));
+        }
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::pointer_iterator
+            RepeatedPtrField<Element>::pointer_end()
+        {
+            return pointer_iterator(raw_mutable_data() + size());
+        }
+        template<typename Element>
+        inline typename RepeatedPtrField<Element>::const_pointer_iterator
+            RepeatedPtrField<Element>::pointer_end() const
+        {
+            return const_pointer_iterator(
+                const_cast<const void* const*>(raw_data() + size())
+            );
+        }
+
+        // Iterators and helper functions that follow the spirit of the STL
+        // std::back_insert_iterator and std::back_inserter but are tailor-made
+        // for RepeatedField and RepeatedPtrField. Typical usage would be:
+        //
+        //   std::copy(some_sequence.begin(), some_sequence.end(),
+        //             RepeatedFieldBackInserter(proto.mutable_sequence()));
+        //
+        // Ported by johannes from util/gtl/proto-array-iterators.h
+
+        namespace internal
+        {
+
+            // A back inserter for RepeatedPtrField objects.
+            template<typename T>
+            class RepeatedPtrFieldBackInsertIterator
+            {
+            public:
+                using iterator_category = std::output_iterator_tag;
+                using value_type = T;
+                using pointer = void;
+                using reference = void;
+                using difference_type = std::ptrdiff_t;
+
+                RepeatedPtrFieldBackInsertIterator(RepeatedPtrField<T>* const mutable_field) :
+                    field_(mutable_field)
+                {
+                }
+                RepeatedPtrFieldBackInsertIterator<T>& operator=(const T& value)
+                {
+                    *field_->Add() = value;
+                    return *this;
+                }
+                RepeatedPtrFieldBackInsertIterator<T>& operator=(
+                    const T* const ptr_to_value
+                )
+                {
+                    *field_->Add() = *ptr_to_value;
+                    return *this;
+                }
+                RepeatedPtrFieldBackInsertIterator<T>& operator=(T&& value)
+                {
+                    *field_->Add() = std::move(value);
+                    return *this;
+                }
+                RepeatedPtrFieldBackInsertIterator<T>& operator*()
+                {
+                    return *this;
+                }
+                RepeatedPtrFieldBackInsertIterator<T>& operator++()
+                {
+                    return *this;
+                }
+                RepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */)
+                {
+                    return *this;
+                }
+
+            private:
+                RepeatedPtrField<T>* field_;
+            };
+
+            // A back inserter for RepeatedPtrFields that inserts by transferring ownership
+            // of a pointer.
+            template<typename T>
+            class AllocatedRepeatedPtrFieldBackInsertIterator
+            {
+            public:
+                using iterator_category = std::output_iterator_tag;
+                using value_type = T;
+                using pointer = void;
+                using reference = void;
+                using difference_type = std::ptrdiff_t;
+
+                explicit AllocatedRepeatedPtrFieldBackInsertIterator(
+                    RepeatedPtrField<T>* const mutable_field
+                ) :
+                    field_(mutable_field)
+                {
+                }
+                AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
+                    T* const ptr_to_value
+                )
+                {
+                    field_->AddAllocated(ptr_to_value);
+                    return *this;
+                }
+                AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*()
+                {
+                    return *this;
+                }
+                AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++()
+                {
+                    return *this;
+                }
+                AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */)
+                {
+                    return *this;
+                }
+
+            private:
+                RepeatedPtrField<T>* field_;
+            };
+
+            // Almost identical to AllocatedRepeatedPtrFieldBackInsertIterator. This one
+            // uses the UnsafeArenaAddAllocated instead.
+            template<typename T>
+            class UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator
+            {
+            public:
+                using iterator_category = std::output_iterator_tag;
+                using value_type = T;
+                using pointer = void;
+                using reference = void;
+                using difference_type = std::ptrdiff_t;
+
+                explicit UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator(
+                    RepeatedPtrField<T>* const mutable_field
+                ) :
+                    field_(mutable_field)
+                {
+                }
+                UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
+                    T const* const ptr_to_value
+                )
+                {
+                    field_->UnsafeArenaAddAllocated(const_cast<T*>(ptr_to_value));
+                    return *this;
+                }
+                UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*()
+                {
+                    return *this;
+                }
+                UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++()
+                {
+                    return *this;
+                }
+                UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(
+                    int /* unused */
+                )
+                {
+                    return *this;
+                }
+
+            private:
+                RepeatedPtrField<T>* field_;
+            };
+
+        }  // namespace internal
+
+        // Provides a back insert iterator for RepeatedPtrField instances,
+        // similar to std::back_inserter().
+        template<typename T>
+        internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedPtrFieldBackInserter(
+            RepeatedPtrField<T>* const mutable_field
+        )
+        {
+            return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
+        }
+
+        // Special back insert iterator for RepeatedPtrField instances, just in
+        // case someone wants to write generic template code that can access both
+        // RepeatedFields and RepeatedPtrFields using a common name.
+        template<typename T>
+        internal::RepeatedPtrFieldBackInsertIterator<T> RepeatedFieldBackInserter(
+            RepeatedPtrField<T>* const mutable_field
+        )
+        {
+            return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
+        }
+
+        // Provides a back insert iterator for RepeatedPtrField instances
+        // similar to std::back_inserter() which transfers the ownership while
+        // copying elements.
+        template<typename T>
+        internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>
+            AllocatedRepeatedPtrFieldBackInserter(
+                RepeatedPtrField<T>* const mutable_field
+            )
+        {
+            return internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>(
+                mutable_field
+            );
+        }
+
+        // Similar to AllocatedRepeatedPtrFieldBackInserter, using
+        // UnsafeArenaAddAllocated instead of AddAllocated.
+        // This is slightly faster if that matters. It is also useful in legacy code
+        // that uses temporary ownership to avoid copies. Example:
+        //   RepeatedPtrField<T> temp_field;
+        //   temp_field.UnsafeArenaAddAllocated(new T);
+        //   ... // Do something with temp_field
+        //   temp_field.UnsafeArenaExtractSubrange(0, temp_field.size(), nullptr);
+        // Putting temp_field on the arena fails because the ownership transfers to the
+        // arena at the "AddAllocated" call and is not released anymore causing a
+        // double delete. This function uses UnsafeArenaAddAllocated to prevent this.
+        template<typename T>
+        internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>
+            UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
+                RepeatedPtrField<T>* const mutable_field
+            )
+        {
+            return internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>(
+                mutable_field
+            );
+        }
+
+        extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
+            RepeatedPtrField<std::string>;
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/service.h b/CAPI/cpp/grpc/include/google/protobuf/service.h
index d288eb5..53ab309 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/service.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/service.h
@@ -100,7 +100,6 @@
 #ifndef GOOGLE_PROTOBUF_SERVICE_H__
 #define GOOGLE_PROTOBUF_SERVICE_H__
 
-
 #include <string>
 #include <google/protobuf/stubs/callback.h>
 #include <google/protobuf/stubs/common.h>
@@ -112,182 +111,195 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-// Defined in this file.
-class Service;
-class RpcController;
-class RpcChannel;
-
-// Defined in other files.
-class Descriptor;         // descriptor.h
-class ServiceDescriptor;  // descriptor.h
-class MethodDescriptor;   // descriptor.h
-class Message;            // message.h
-
-// Abstract base interface for protocol-buffer-based RPC services.  Services
-// themselves are abstract interfaces (implemented either by servers or as
-// stubs), but they subclass this base interface.  The methods of this
-// interface can be used to call the methods of the Service without knowing
-// its exact type at compile time (analogous to Reflection).
-class PROTOBUF_EXPORT Service {
- public:
-  inline Service() {}
-  virtual ~Service();
-
-  // When constructing a stub, you may pass STUB_OWNS_CHANNEL as the second
-  // parameter to the constructor to tell it to delete its RpcChannel when
-  // destroyed.
-  enum ChannelOwnership { STUB_OWNS_CHANNEL, STUB_DOESNT_OWN_CHANNEL };
-
-  // Get the ServiceDescriptor describing this service and its methods.
-  virtual const ServiceDescriptor* GetDescriptor() = 0;
-
-  // Call a method of the service specified by MethodDescriptor.  This is
-  // normally implemented as a simple switch() that calls the standard
-  // definitions of the service's methods.
-  //
-  // Preconditions:
-  // * method->service() == GetDescriptor()
-  // * request and response are of the exact same classes as the objects
-  //   returned by GetRequestPrototype(method) and
-  //   GetResponsePrototype(method).
-  // * After the call has started, the request must not be modified and the
-  //   response must not be accessed at all until "done" is called.
-  // * "controller" is of the correct type for the RPC implementation being
-  //   used by this Service.  For stubs, the "correct type" depends on the
-  //   RpcChannel which the stub is using.  Server-side Service
-  //   implementations are expected to accept whatever type of RpcController
-  //   the server-side RPC implementation uses.
-  //
-  // Postconditions:
-  // * "done" will be called when the method is complete.  This may be
-  //   before CallMethod() returns or it may be at some point in the future.
-  // * If the RPC succeeded, "response" contains the response returned by
-  //   the server.
-  // * If the RPC failed, "response"'s contents are undefined.  The
-  //   RpcController can be queried to determine if an error occurred and
-  //   possibly to get more information about the error.
-  virtual void CallMethod(const MethodDescriptor* method,
-                          RpcController* controller, const Message* request,
-                          Message* response, Closure* done) = 0;
-
-  // CallMethod() requires that the request and response passed in are of a
-  // particular subclass of Message.  GetRequestPrototype() and
-  // GetResponsePrototype() get the default instances of these required types.
-  // You can then call Message::New() on these instances to construct mutable
-  // objects which you can then pass to CallMethod().
-  //
-  // Example:
-  //   const MethodDescriptor* method =
-  //     service->GetDescriptor()->FindMethodByName("Foo");
-  //   Message* request  = stub->GetRequestPrototype (method)->New();
-  //   Message* response = stub->GetResponsePrototype(method)->New();
-  //   request->ParseFromString(input);
-  //   service->CallMethod(method, *request, response, callback);
-  virtual const Message& GetRequestPrototype(
-      const MethodDescriptor* method) const = 0;
-  virtual const Message& GetResponsePrototype(
-      const MethodDescriptor* method) const = 0;
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Service);
-};
-
-// An RpcController mediates a single method call.  The primary purpose of
-// the controller is to provide a way to manipulate settings specific to the
-// RPC implementation and to find out about RPC-level errors.
-//
-// The methods provided by the RpcController interface are intended to be a
-// "least common denominator" set of features which we expect all
-// implementations to support.  Specific implementations may provide more
-// advanced features (e.g. deadline propagation).
-class PROTOBUF_EXPORT RpcController {
- public:
-  inline RpcController() {}
-  virtual ~RpcController();
-
-  // Client-side methods ---------------------------------------------
-  // These calls may be made from the client side only.  Their results
-  // are undefined on the server side (may crash).
-
-  // Resets the RpcController to its initial state so that it may be reused in
-  // a new call.  Must not be called while an RPC is in progress.
-  virtual void Reset() = 0;
-
-  // After a call has finished, returns true if the call failed.  The possible
-  // reasons for failure depend on the RPC implementation.  Failed() must not
-  // be called before a call has finished.  If Failed() returns true, the
-  // contents of the response message are undefined.
-  virtual bool Failed() const = 0;
-
-  // If Failed() is true, returns a human-readable description of the error.
-  virtual std::string ErrorText() const = 0;
-
-  // Advises the RPC system that the caller desires that the RPC call be
-  // canceled.  The RPC system may cancel it immediately, may wait awhile and
-  // then cancel it, or may not even cancel the call at all.  If the call is
-  // canceled, the "done" callback will still be called and the RpcController
-  // will indicate that the call failed at that time.
-  virtual void StartCancel() = 0;
-
-  // Server-side methods ---------------------------------------------
-  // These calls may be made from the server side only.  Their results
-  // are undefined on the client side (may crash).
-
-  // Causes Failed() to return true on the client side.  "reason" will be
-  // incorporated into the message returned by ErrorText().  If you find
-  // you need to return machine-readable information about failures, you
-  // should incorporate it into your response protocol buffer and should
-  // NOT call SetFailed().
-  virtual void SetFailed(const std::string& reason) = 0;
-
-  // If true, indicates that the client canceled the RPC, so the server may
-  // as well give up on replying to it.  The server should still call the
-  // final "done" callback.
-  virtual bool IsCanceled() const = 0;
-
-  // Asks that the given callback be called when the RPC is canceled.  The
-  // callback will always be called exactly once.  If the RPC completes without
-  // being canceled, the callback will be called after completion.  If the RPC
-  // has already been canceled when NotifyOnCancel() is called, the callback
-  // will be called immediately.
-  //
-  // NotifyOnCancel() must be called no more than once per request.
-  virtual void NotifyOnCancel(Closure* callback) = 0;
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcController);
-};
-
-// Abstract interface for an RPC channel.  An RpcChannel represents a
-// communication line to a Service which can be used to call that Service's
-// methods.  The Service may be running on another machine.  Normally, you
-// should not call an RpcChannel directly, but instead construct a stub Service
-// wrapping it.  Example:
-//   RpcChannel* channel = new MyRpcChannel("remotehost.example.com:1234");
-//   MyService* service = new MyService::Stub(channel);
-//   service->MyMethod(request, &response, callback);
-class PROTOBUF_EXPORT RpcChannel {
- public:
-  inline RpcChannel() {}
-  virtual ~RpcChannel();
-
-  // Call the given method of the remote service.  The signature of this
-  // procedure looks the same as Service::CallMethod(), but the requirements
-  // are less strict in one important way:  the request and response objects
-  // need not be of any specific class as long as their descriptors are
-  // method->input_type() and method->output_type().
-  virtual void CallMethod(const MethodDescriptor* method,
-                          RpcController* controller, const Message* request,
-                          Message* response, Closure* done) = 0;
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcChannel);
-};
-
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        // Defined in this file.
+        class Service;
+        class RpcController;
+        class RpcChannel;
+
+        // Defined in other files.
+        class Descriptor;         // descriptor.h
+        class ServiceDescriptor;  // descriptor.h
+        class MethodDescriptor;   // descriptor.h
+        class Message;            // message.h
+
+        // Abstract base interface for protocol-buffer-based RPC services.  Services
+        // themselves are abstract interfaces (implemented either by servers or as
+        // stubs), but they subclass this base interface.  The methods of this
+        // interface can be used to call the methods of the Service without knowing
+        // its exact type at compile time (analogous to Reflection).
+        class PROTOBUF_EXPORT Service
+        {
+        public:
+            inline Service()
+            {
+            }
+            virtual ~Service();
+
+            // When constructing a stub, you may pass STUB_OWNS_CHANNEL as the second
+            // parameter to the constructor to tell it to delete its RpcChannel when
+            // destroyed.
+            enum ChannelOwnership
+            {
+                STUB_OWNS_CHANNEL,
+                STUB_DOESNT_OWN_CHANNEL
+            };
+
+            // Get the ServiceDescriptor describing this service and its methods.
+            virtual const ServiceDescriptor* GetDescriptor() = 0;
+
+            // Call a method of the service specified by MethodDescriptor.  This is
+            // normally implemented as a simple switch() that calls the standard
+            // definitions of the service's methods.
+            //
+            // Preconditions:
+            // * method->service() == GetDescriptor()
+            // * request and response are of the exact same classes as the objects
+            //   returned by GetRequestPrototype(method) and
+            //   GetResponsePrototype(method).
+            // * After the call has started, the request must not be modified and the
+            //   response must not be accessed at all until "done" is called.
+            // * "controller" is of the correct type for the RPC implementation being
+            //   used by this Service.  For stubs, the "correct type" depends on the
+            //   RpcChannel which the stub is using.  Server-side Service
+            //   implementations are expected to accept whatever type of RpcController
+            //   the server-side RPC implementation uses.
+            //
+            // Postconditions:
+            // * "done" will be called when the method is complete.  This may be
+            //   before CallMethod() returns or it may be at some point in the future.
+            // * If the RPC succeeded, "response" contains the response returned by
+            //   the server.
+            // * If the RPC failed, "response"'s contents are undefined.  The
+            //   RpcController can be queried to determine if an error occurred and
+            //   possibly to get more information about the error.
+            virtual void CallMethod(const MethodDescriptor* method, RpcController* controller, const Message* request, Message* response, Closure* done) = 0;
+
+            // CallMethod() requires that the request and response passed in are of a
+            // particular subclass of Message.  GetRequestPrototype() and
+            // GetResponsePrototype() get the default instances of these required types.
+            // You can then call Message::New() on these instances to construct mutable
+            // objects which you can then pass to CallMethod().
+            //
+            // Example:
+            //   const MethodDescriptor* method =
+            //     service->GetDescriptor()->FindMethodByName("Foo");
+            //   Message* request  = stub->GetRequestPrototype (method)->New();
+            //   Message* response = stub->GetResponsePrototype(method)->New();
+            //   request->ParseFromString(input);
+            //   service->CallMethod(method, *request, response, callback);
+            virtual const Message& GetRequestPrototype(
+                const MethodDescriptor* method
+            ) const = 0;
+            virtual const Message& GetResponsePrototype(
+                const MethodDescriptor* method
+            ) const = 0;
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Service);
+        };
+
+        // An RpcController mediates a single method call.  The primary purpose of
+        // the controller is to provide a way to manipulate settings specific to the
+        // RPC implementation and to find out about RPC-level errors.
+        //
+        // The methods provided by the RpcController interface are intended to be a
+        // "least common denominator" set of features which we expect all
+        // implementations to support.  Specific implementations may provide more
+        // advanced features (e.g. deadline propagation).
+        class PROTOBUF_EXPORT RpcController
+        {
+        public:
+            inline RpcController()
+            {
+            }
+            virtual ~RpcController();
+
+            // Client-side methods ---------------------------------------------
+            // These calls may be made from the client side only.  Their results
+            // are undefined on the server side (may crash).
+
+            // Resets the RpcController to its initial state so that it may be reused in
+            // a new call.  Must not be called while an RPC is in progress.
+            virtual void Reset() = 0;
+
+            // After a call has finished, returns true if the call failed.  The possible
+            // reasons for failure depend on the RPC implementation.  Failed() must not
+            // be called before a call has finished.  If Failed() returns true, the
+            // contents of the response message are undefined.
+            virtual bool Failed() const = 0;
+
+            // If Failed() is true, returns a human-readable description of the error.
+            virtual std::string ErrorText() const = 0;
+
+            // Advises the RPC system that the caller desires that the RPC call be
+            // canceled.  The RPC system may cancel it immediately, may wait awhile and
+            // then cancel it, or may not even cancel the call at all.  If the call is
+            // canceled, the "done" callback will still be called and the RpcController
+            // will indicate that the call failed at that time.
+            virtual void StartCancel() = 0;
+
+            // Server-side methods ---------------------------------------------
+            // These calls may be made from the server side only.  Their results
+            // are undefined on the client side (may crash).
+
+            // Causes Failed() to return true on the client side.  "reason" will be
+            // incorporated into the message returned by ErrorText().  If you find
+            // you need to return machine-readable information about failures, you
+            // should incorporate it into your response protocol buffer and should
+            // NOT call SetFailed().
+            virtual void SetFailed(const std::string& reason) = 0;
+
+            // If true, indicates that the client canceled the RPC, so the server may
+            // as well give up on replying to it.  The server should still call the
+            // final "done" callback.
+            virtual bool IsCanceled() const = 0;
+
+            // Asks that the given callback be called when the RPC is canceled.  The
+            // callback will always be called exactly once.  If the RPC completes without
+            // being canceled, the callback will be called after completion.  If the RPC
+            // has already been canceled when NotifyOnCancel() is called, the callback
+            // will be called immediately.
+            //
+            // NotifyOnCancel() must be called no more than once per request.
+            virtual void NotifyOnCancel(Closure* callback) = 0;
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcController);
+        };
+
+        // Abstract interface for an RPC channel.  An RpcChannel represents a
+        // communication line to a Service which can be used to call that Service's
+        // methods.  The Service may be running on another machine.  Normally, you
+        // should not call an RpcChannel directly, but instead construct a stub Service
+        // wrapping it.  Example:
+        //   RpcChannel* channel = new MyRpcChannel("remotehost.example.com:1234");
+        //   MyService* service = new MyService::Stub(channel);
+        //   service->MyMethod(request, &response, callback);
+        class PROTOBUF_EXPORT RpcChannel
+        {
+        public:
+            inline RpcChannel()
+            {
+            }
+            virtual ~RpcChannel();
+
+            // Call the given method of the remote service.  The signature of this
+            // procedure looks the same as Service::CallMethod(), but the requirements
+            // are less strict in one important way:  the request and response objects
+            // need not be of any specific class as long as their descriptors are
+            // method->input_type() and method->output_type().
+            virtual void CallMethod(const MethodDescriptor* method, RpcController* controller, const Message* request, Message* response, Closure* done) = 0;
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcChannel);
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/source_context.pb.h b/CAPI/cpp/grpc/include/google/protobuf/source_context.pb.h
index e9c41bd..8381155 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/source_context.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/source_context.pb.h
@@ -28,20 +28,22 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fsource_5fcontext_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fsource_5fcontext_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -50,226 +52,277 @@ struct SourceContextDefaultTypeInternal;
 PROTOBUF_EXPORT extern SourceContextDefaultTypeInternal _SourceContext_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceContext* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::SourceContext* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
 // ===================================================================
 
 class PROTOBUF_EXPORT SourceContext final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceContext) */ {
- public:
-  inline SourceContext() : SourceContext(nullptr) {}
-  ~SourceContext() override;
-  explicit PROTOBUF_CONSTEXPR SourceContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  SourceContext(const SourceContext& from);
-  SourceContext(SourceContext&& from) noexcept
-    : SourceContext() {
-    *this = ::std::move(from);
-  }
-
-  inline SourceContext& operator=(const SourceContext& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline SourceContext& operator=(SourceContext&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceContext) */
+{
+public:
+    inline SourceContext() :
+        SourceContext(nullptr)
+    {
     }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const SourceContext& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const SourceContext* internal_default_instance() {
-    return reinterpret_cast<const SourceContext*>(
-               &_SourceContext_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(SourceContext& a, SourceContext& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(SourceContext* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    ~SourceContext() override;
+    explicit PROTOBUF_CONSTEXPR SourceContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    SourceContext(const SourceContext& from);
+    SourceContext(SourceContext&& from) noexcept
+        :
+        SourceContext()
+    {
+        *this = ::std::move(from);
     }
-  }
-  void UnsafeArenaSwap(SourceContext* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  SourceContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<SourceContext>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const SourceContext& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const SourceContext& from) {
-    SourceContext::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(SourceContext* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.SourceContext";
-  }
-  protected:
-  explicit SourceContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFileNameFieldNumber = 1,
-  };
-  // string file_name = 1;
-  void clear_file_name();
-  const std::string& file_name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_file_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_file_name();
-  PROTOBUF_NODISCARD std::string* release_file_name();
-  void set_allocated_file_name(std::string* file_name);
-  private:
-  const std::string& _internal_file_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value);
-  std::string* _internal_mutable_file_name();
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.SourceContext)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto;
+
+    inline SourceContext& operator=(const SourceContext& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline SourceContext& operator=(SourceContext&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const SourceContext& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const SourceContext* internal_default_instance()
+    {
+        return reinterpret_cast<const SourceContext*>(
+            &_SourceContext_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(SourceContext& a, SourceContext& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(SourceContext* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(SourceContext* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    SourceContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<SourceContext>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const SourceContext& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const SourceContext& from)
+    {
+        SourceContext::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(SourceContext* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.SourceContext";
+    }
+
+protected:
+    explicit SourceContext(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kFileNameFieldNumber = 1,
+    };
+    // string file_name = 1;
+    void clear_file_name();
+    const std::string& file_name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_file_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_file_name();
+    PROTOBUF_NODISCARD std::string* release_file_name();
+    void set_allocated_file_name(std::string* file_name);
+
+private:
+    const std::string& _internal_file_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value);
+    std::string* _internal_mutable_file_name();
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.SourceContext)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fsource_5fcontext_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // SourceContext
 
 // string file_name = 1;
-inline void SourceContext::clear_file_name() {
-  _impl_.file_name_.ClearToEmpty();
+inline void SourceContext::clear_file_name()
+{
+    _impl_.file_name_.ClearToEmpty();
 }
-inline const std::string& SourceContext::file_name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.SourceContext.file_name)
-  return _internal_file_name();
+inline const std::string& SourceContext::file_name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.SourceContext.file_name)
+    return _internal_file_name();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void SourceContext::set_file_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.file_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.SourceContext.file_name)
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void SourceContext::set_file_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.file_name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.SourceContext.file_name)
 }
-inline std::string* SourceContext::mutable_file_name() {
-  std::string* _s = _internal_mutable_file_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceContext.file_name)
-  return _s;
+inline std::string* SourceContext::mutable_file_name()
+{
+    std::string* _s = _internal_mutable_file_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.SourceContext.file_name)
+    return _s;
 }
-inline const std::string& SourceContext::_internal_file_name() const {
-  return _impl_.file_name_.Get();
+inline const std::string& SourceContext::_internal_file_name() const
+{
+    return _impl_.file_name_.Get();
 }
-inline void SourceContext::_internal_set_file_name(const std::string& value) {
-  
-  _impl_.file_name_.Set(value, GetArenaForAllocation());
+inline void SourceContext::_internal_set_file_name(const std::string& value)
+{
+    _impl_.file_name_.Set(value, GetArenaForAllocation());
 }
-inline std::string* SourceContext::_internal_mutable_file_name() {
-  
-  return _impl_.file_name_.Mutable(GetArenaForAllocation());
+inline std::string* SourceContext::_internal_mutable_file_name()
+{
+    return _impl_.file_name_.Mutable(GetArenaForAllocation());
 }
-inline std::string* SourceContext::release_file_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.SourceContext.file_name)
-  return _impl_.file_name_.Release();
+inline std::string* SourceContext::release_file_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.SourceContext.file_name)
+    return _impl_.file_name_.Release();
 }
-inline void SourceContext::set_allocated_file_name(std::string* file_name) {
-  if (file_name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.file_name_.SetAllocated(file_name, GetArenaForAllocation());
+inline void SourceContext::set_allocated_file_name(std::string* file_name)
+{
+    if (file_name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.file_name_.SetAllocated(file_name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.file_name_.IsDefault()) {
-    _impl_.file_name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceContext.file_name)
+    if (_impl_.file_name_.IsDefault())
+    {
+        _impl_.file_name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceContext.file_name)
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 
 // @@protoc_insertion_point(namespace_scope)
diff --git a/CAPI/cpp/grpc/include/google/protobuf/struct.pb.h b/CAPI/cpp/grpc/include/google/protobuf/struct.pb.h
index ac2d971..1f3ebaa 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/struct.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/struct.pb.h
@@ -28,8 +28,8 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
-#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
+#include <google/protobuf/map.h>             // IWYU pragma: export
 #include <google/protobuf/map_entry.h>
 #include <google/protobuf/map_field_inl.h>
 #include <google/protobuf/generated_enum_reflection.h>
@@ -38,14 +38,16 @@
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fstruct_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fstruct_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fstruct_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fstruct_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -63,17 +65,22 @@ struct ValueDefaultTypeInternal;
 PROTOBUF_EXPORT extern ValueDefaultTypeInternal _Value_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ListValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ListValue>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Struct* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Struct>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Struct_FieldsEntry_DoNotUse* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Struct_FieldsEntry_DoNotUse>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Value>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::ListValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ListValue>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Struct* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Struct>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Struct_FieldsEntry_DoNotUse* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Struct_FieldsEntry_DoNotUse>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Value>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
-enum NullValue : int {
-  NULL_VALUE = 0,
-  NullValue_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-  NullValue_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+enum NullValue : int
+{
+    NULL_VALUE = 0,
+    NullValue_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+    NullValue_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
 };
 PROTOBUF_EXPORT bool NullValue_IsValid(int value);
 constexpr NullValue NullValue_MIN = NULL_VALUE;
@@ -82,673 +89,850 @@ constexpr int NullValue_ARRAYSIZE = NullValue_MAX + 1;
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NullValue_descriptor();
 template<typename T>
-inline const std::string& NullValue_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, NullValue>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function NullValue_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    NullValue_descriptor(), enum_t_value);
+inline const std::string& NullValue_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, NullValue>::value || ::std::is_integral<T>::value, "Incorrect type passed to function NullValue_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        NullValue_descriptor(), enum_t_value
+    );
 }
 inline bool NullValue_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NullValue* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NullValue>(
-    NullValue_descriptor(), name, value);
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NullValue* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NullValue>(
+        NullValue_descriptor(), name, value
+    );
 }
 // ===================================================================
 
-class Struct_FieldsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Struct_FieldsEntry_DoNotUse, 
-    std::string, ::PROTOBUF_NAMESPACE_ID::Value,
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+class Struct_FieldsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Struct_FieldsEntry_DoNotUse, std::string, ::PROTOBUF_NAMESPACE_ID::Value, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE>
+{
 public:
-  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Struct_FieldsEntry_DoNotUse, 
-    std::string, ::PROTOBUF_NAMESPACE_ID::Value,
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
-    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
-  Struct_FieldsEntry_DoNotUse();
-  explicit PROTOBUF_CONSTEXPR Struct_FieldsEntry_DoNotUse(
-      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-  explicit Struct_FieldsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
-  void MergeFrom(const Struct_FieldsEntry_DoNotUse& other);
-  static const Struct_FieldsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Struct_FieldsEntry_DoNotUse*>(&_Struct_FieldsEntry_DoNotUse_default_instance_); }
-  static bool ValidateKey(std::string* s) {
-    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.protobuf.Struct.FieldsEntry.key");
- }
-  static bool ValidateValue(void*) { return true; }
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-  friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
+    typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Struct_FieldsEntry_DoNotUse, std::string, ::PROTOBUF_NAMESPACE_ID::Value, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+    Struct_FieldsEntry_DoNotUse();
+    explicit PROTOBUF_CONSTEXPR Struct_FieldsEntry_DoNotUse(
+        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized
+    );
+    explicit Struct_FieldsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+    void MergeFrom(const Struct_FieldsEntry_DoNotUse& other);
+    static const Struct_FieldsEntry_DoNotUse* internal_default_instance()
+    {
+        return reinterpret_cast<const Struct_FieldsEntry_DoNotUse*>(&_Struct_FieldsEntry_DoNotUse_default_instance_);
+    }
+    static bool ValidateKey(std::string* s)
+    {
+        return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.protobuf.Struct.FieldsEntry.key");
+    }
+    static bool ValidateValue(void*)
+    {
+        return true;
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+    friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
 };
 
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Struct final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Struct) */ {
- public:
-  inline Struct() : Struct(nullptr) {}
-  ~Struct() override;
-  explicit PROTOBUF_CONSTEXPR Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Struct(const Struct& from);
-  Struct(Struct&& from) noexcept
-    : Struct() {
-    *this = ::std::move(from);
-  }
-
-  inline Struct& operator=(const Struct& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Struct& operator=(Struct&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Struct& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Struct* internal_default_instance() {
-    return reinterpret_cast<const Struct*>(
-               &_Struct_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(Struct& a, Struct& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Struct* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Struct* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Struct>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Struct& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Struct& from) {
-    Struct::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Struct* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Struct";
-  }
-  protected:
-  explicit Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  private:
-  static void ArenaDtor(void* object);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFieldsFieldNumber = 1,
-  };
-  // map<string, .google.protobuf.Value> fields = 1;
-  int fields_size() const;
-  private:
-  int _internal_fields_size() const;
-  public:
-  void clear_fields();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >&
-      _internal_fields() const;
-  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >*
-      _internal_mutable_fields();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >&
-      fields() const;
-  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >*
-      mutable_fields();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Struct)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::MapField<
-        Struct_FieldsEntry_DoNotUse,
-        std::string, ::PROTOBUF_NAMESPACE_ID::Value,
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
-        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> fields_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Struct) */
+{
+public:
+    inline Struct() :
+        Struct(nullptr)
+    {
+    }
+    ~Struct() override;
+    explicit PROTOBUF_CONSTEXPR Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Struct(const Struct& from);
+    Struct(Struct&& from) noexcept
+        :
+        Struct()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Struct& operator=(const Struct& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Struct& operator=(Struct&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Struct& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Struct* internal_default_instance()
+    {
+        return reinterpret_cast<const Struct*>(
+            &_Struct_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        1;
+
+    friend void swap(Struct& a, Struct& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Struct* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Struct* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Struct>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Struct& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Struct& from)
+    {
+        Struct::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Struct* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Struct";
+    }
+
+protected:
+    explicit Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+private:
+    static void ArenaDtor(void* object);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kFieldsFieldNumber = 1,
+    };
+    // map<string, .google.protobuf.Value> fields = 1;
+    int fields_size() const;
+
+private:
+    int _internal_fields_size() const;
+
+public:
+    void clear_fields();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Map<std::string, ::PROTOBUF_NAMESPACE_ID::Value>&
+        _internal_fields() const;
+    ::PROTOBUF_NAMESPACE_ID::Map<std::string, ::PROTOBUF_NAMESPACE_ID::Value>*
+        _internal_mutable_fields();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Map<std::string, ::PROTOBUF_NAMESPACE_ID::Value>&
+        fields() const;
+    ::PROTOBUF_NAMESPACE_ID::Map<std::string, ::PROTOBUF_NAMESPACE_ID::Value>*
+        mutable_fields();
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.Struct)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::MapField<
+            Struct_FieldsEntry_DoNotUse,
+            std::string,
+            ::PROTOBUF_NAMESPACE_ID::Value,
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE>
+            fields_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Value final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Value) */ {
- public:
-  inline Value() : Value(nullptr) {}
-  ~Value() override;
-  explicit PROTOBUF_CONSTEXPR Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Value(const Value& from);
-  Value(Value&& from) noexcept
-    : Value() {
-    *this = ::std::move(from);
-  }
-
-  inline Value& operator=(const Value& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Value& operator=(Value&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Value& default_instance() {
-    return *internal_default_instance();
-  }
-  enum KindCase {
-    kNullValue = 1,
-    kNumberValue = 2,
-    kStringValue = 3,
-    kBoolValue = 4,
-    kStructValue = 5,
-    kListValue = 6,
-    KIND_NOT_SET = 0,
-  };
-
-  static inline const Value* internal_default_instance() {
-    return reinterpret_cast<const Value*>(
-               &_Value_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(Value& a, Value& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Value* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Value* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Value>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Value& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Value& from) {
-    Value::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Value* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Value";
-  }
-  protected:
-  explicit Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNullValueFieldNumber = 1,
-    kNumberValueFieldNumber = 2,
-    kStringValueFieldNumber = 3,
-    kBoolValueFieldNumber = 4,
-    kStructValueFieldNumber = 5,
-    kListValueFieldNumber = 6,
-  };
-  // .google.protobuf.NullValue null_value = 1;
-  bool has_null_value() const;
-  private:
-  bool _internal_has_null_value() const;
-  public:
-  void clear_null_value();
-  ::PROTOBUF_NAMESPACE_ID::NullValue null_value() const;
-  void set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::NullValue _internal_null_value() const;
-  void _internal_set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value);
-  public:
-
-  // double number_value = 2;
-  bool has_number_value() const;
-  private:
-  bool _internal_has_number_value() const;
-  public:
-  void clear_number_value();
-  double number_value() const;
-  void set_number_value(double value);
-  private:
-  double _internal_number_value() const;
-  void _internal_set_number_value(double value);
-  public:
-
-  // string string_value = 3;
-  bool has_string_value() const;
-  private:
-  bool _internal_has_string_value() const;
-  public:
-  void clear_string_value();
-  const std::string& string_value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_string_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_string_value();
-  PROTOBUF_NODISCARD std::string* release_string_value();
-  void set_allocated_string_value(std::string* string_value);
-  private:
-  const std::string& _internal_string_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
-  std::string* _internal_mutable_string_value();
-  public:
-
-  // bool bool_value = 4;
-  bool has_bool_value() const;
-  private:
-  bool _internal_has_bool_value() const;
-  public:
-  void clear_bool_value();
-  bool bool_value() const;
-  void set_bool_value(bool value);
-  private:
-  bool _internal_bool_value() const;
-  void _internal_set_bool_value(bool value);
-  public:
-
-  // .google.protobuf.Struct struct_value = 5;
-  bool has_struct_value() const;
-  private:
-  bool _internal_has_struct_value() const;
-  public:
-  void clear_struct_value();
-  const ::PROTOBUF_NAMESPACE_ID::Struct& struct_value() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Struct* release_struct_value();
-  ::PROTOBUF_NAMESPACE_ID::Struct* mutable_struct_value();
-  void set_allocated_struct_value(::PROTOBUF_NAMESPACE_ID::Struct* struct_value);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Struct& _internal_struct_value() const;
-  ::PROTOBUF_NAMESPACE_ID::Struct* _internal_mutable_struct_value();
-  public:
-  void unsafe_arena_set_allocated_struct_value(
-      ::PROTOBUF_NAMESPACE_ID::Struct* struct_value);
-  ::PROTOBUF_NAMESPACE_ID::Struct* unsafe_arena_release_struct_value();
-
-  // .google.protobuf.ListValue list_value = 6;
-  bool has_list_value() const;
-  private:
-  bool _internal_has_list_value() const;
-  public:
-  void clear_list_value();
-  const ::PROTOBUF_NAMESPACE_ID::ListValue& list_value() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ListValue* release_list_value();
-  ::PROTOBUF_NAMESPACE_ID::ListValue* mutable_list_value();
-  void set_allocated_list_value(::PROTOBUF_NAMESPACE_ID::ListValue* list_value);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::ListValue& _internal_list_value() const;
-  ::PROTOBUF_NAMESPACE_ID::ListValue* _internal_mutable_list_value();
-  public:
-  void unsafe_arena_set_allocated_list_value(
-      ::PROTOBUF_NAMESPACE_ID::ListValue* list_value);
-  ::PROTOBUF_NAMESPACE_ID::ListValue* unsafe_arena_release_list_value();
-
-  void clear_kind();
-  KindCase kind_case() const;
-  // @@protoc_insertion_point(class_scope:google.protobuf.Value)
- private:
-  class _Internal;
-  void set_has_null_value();
-  void set_has_number_value();
-  void set_has_string_value();
-  void set_has_bool_value();
-  void set_has_struct_value();
-  void set_has_list_value();
-
-  inline bool has_kind() const;
-  inline void clear_has_kind();
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    union KindUnion {
-      constexpr KindUnion() : _constinit_{} {}
-        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
-      int null_value_;
-      double number_value_;
-      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
-      bool bool_value_;
-      ::PROTOBUF_NAMESPACE_ID::Struct* struct_value_;
-      ::PROTOBUF_NAMESPACE_ID::ListValue* list_value_;
-    } kind_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-    uint32_t _oneof_case_[1];
-
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Value) */
+{
+public:
+    inline Value() :
+        Value(nullptr)
+    {
+    }
+    ~Value() override;
+    explicit PROTOBUF_CONSTEXPR Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Value(const Value& from);
+    Value(Value&& from) noexcept
+        :
+        Value()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Value& operator=(const Value& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Value& operator=(Value&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Value& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    enum KindCase
+    {
+        kNullValue = 1,
+        kNumberValue = 2,
+        kStringValue = 3,
+        kBoolValue = 4,
+        kStructValue = 5,
+        kListValue = 6,
+        KIND_NOT_SET = 0,
+    };
+
+    static inline const Value* internal_default_instance()
+    {
+        return reinterpret_cast<const Value*>(
+            &_Value_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        2;
+
+    friend void swap(Value& a, Value& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Value* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Value* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Value>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Value& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Value& from)
+    {
+        Value::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Value* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Value";
+    }
+
+protected:
+    explicit Value(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNullValueFieldNumber = 1,
+        kNumberValueFieldNumber = 2,
+        kStringValueFieldNumber = 3,
+        kBoolValueFieldNumber = 4,
+        kStructValueFieldNumber = 5,
+        kListValueFieldNumber = 6,
+    };
+    // .google.protobuf.NullValue null_value = 1;
+    bool has_null_value() const;
+
+private:
+    bool _internal_has_null_value() const;
+
+public:
+    void clear_null_value();
+    ::PROTOBUF_NAMESPACE_ID::NullValue null_value() const;
+    void set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::NullValue _internal_null_value() const;
+    void _internal_set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value);
+
+public:
+    // double number_value = 2;
+    bool has_number_value() const;
+
+private:
+    bool _internal_has_number_value() const;
+
+public:
+    void clear_number_value();
+    double number_value() const;
+    void set_number_value(double value);
+
+private:
+    double _internal_number_value() const;
+    void _internal_set_number_value(double value);
+
+public:
+    // string string_value = 3;
+    bool has_string_value() const;
+
+private:
+    bool _internal_has_string_value() const;
+
+public:
+    void clear_string_value();
+    const std::string& string_value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_string_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_string_value();
+    PROTOBUF_NODISCARD std::string* release_string_value();
+    void set_allocated_string_value(std::string* string_value);
+
+private:
+    const std::string& _internal_string_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
+    std::string* _internal_mutable_string_value();
+
+public:
+    // bool bool_value = 4;
+    bool has_bool_value() const;
+
+private:
+    bool _internal_has_bool_value() const;
+
+public:
+    void clear_bool_value();
+    bool bool_value() const;
+    void set_bool_value(bool value);
+
+private:
+    bool _internal_bool_value() const;
+    void _internal_set_bool_value(bool value);
+
+public:
+    // .google.protobuf.Struct struct_value = 5;
+    bool has_struct_value() const;
+
+private:
+    bool _internal_has_struct_value() const;
+
+public:
+    void clear_struct_value();
+    const ::PROTOBUF_NAMESPACE_ID::Struct& struct_value() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Struct* release_struct_value();
+    ::PROTOBUF_NAMESPACE_ID::Struct* mutable_struct_value();
+    void set_allocated_struct_value(::PROTOBUF_NAMESPACE_ID::Struct* struct_value);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Struct& _internal_struct_value() const;
+    ::PROTOBUF_NAMESPACE_ID::Struct* _internal_mutable_struct_value();
+
+public:
+    void unsafe_arena_set_allocated_struct_value(
+        ::PROTOBUF_NAMESPACE_ID::Struct* struct_value
+    );
+    ::PROTOBUF_NAMESPACE_ID::Struct* unsafe_arena_release_struct_value();
+
+    // .google.protobuf.ListValue list_value = 6;
+    bool has_list_value() const;
+
+private:
+    bool _internal_has_list_value() const;
+
+public:
+    void clear_list_value();
+    const ::PROTOBUF_NAMESPACE_ID::ListValue& list_value() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::ListValue* release_list_value();
+    ::PROTOBUF_NAMESPACE_ID::ListValue* mutable_list_value();
+    void set_allocated_list_value(::PROTOBUF_NAMESPACE_ID::ListValue* list_value);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::ListValue& _internal_list_value() const;
+    ::PROTOBUF_NAMESPACE_ID::ListValue* _internal_mutable_list_value();
+
+public:
+    void unsafe_arena_set_allocated_list_value(
+        ::PROTOBUF_NAMESPACE_ID::ListValue* list_value
+    );
+    ::PROTOBUF_NAMESPACE_ID::ListValue* unsafe_arena_release_list_value();
+
+    void clear_kind();
+    KindCase kind_case() const;
+    // @@protoc_insertion_point(class_scope:google.protobuf.Value)
+
+private:
+    class _Internal;
+    void set_has_null_value();
+    void set_has_number_value();
+    void set_has_string_value();
+    void set_has_bool_value();
+    void set_has_struct_value();
+    void set_has_list_value();
+
+    inline bool has_kind() const;
+    inline void clear_has_kind();
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        union KindUnion
+        {
+            constexpr KindUnion() :
+                _constinit_{}
+            {
+            }
+            ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+            int null_value_;
+            double number_value_;
+            ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
+            bool bool_value_;
+            ::PROTOBUF_NAMESPACE_ID::Struct* struct_value_;
+            ::PROTOBUF_NAMESPACE_ID::ListValue* list_value_;
+        } kind_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+        uint32_t _oneof_case_[1];
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT ListValue final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ListValue) */ {
- public:
-  inline ListValue() : ListValue(nullptr) {}
-  ~ListValue() override;
-  explicit PROTOBUF_CONSTEXPR ListValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  ListValue(const ListValue& from);
-  ListValue(ListValue&& from) noexcept
-    : ListValue() {
-    *this = ::std::move(from);
-  }
-
-  inline ListValue& operator=(const ListValue& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline ListValue& operator=(ListValue&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const ListValue& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const ListValue* internal_default_instance() {
-    return reinterpret_cast<const ListValue*>(
-               &_ListValue_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    3;
-
-  friend void swap(ListValue& a, ListValue& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(ListValue* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(ListValue* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  ListValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<ListValue>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const ListValue& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const ListValue& from) {
-    ListValue::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(ListValue* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.ListValue";
-  }
-  protected:
-  explicit ListValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValuesFieldNumber = 1,
-  };
-  // repeated .google.protobuf.Value values = 1;
-  int values_size() const;
-  private:
-  int _internal_values_size() const;
-  public:
-  void clear_values();
-  ::PROTOBUF_NAMESPACE_ID::Value* mutable_values(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value >*
-      mutable_values();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Value& _internal_values(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Value* _internal_add_values();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Value& values(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Value* add_values();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value >&
-      values() const;
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.ListValue)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value > values_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ListValue) */
+{
+public:
+    inline ListValue() :
+        ListValue(nullptr)
+    {
+    }
+    ~ListValue() override;
+    explicit PROTOBUF_CONSTEXPR ListValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    ListValue(const ListValue& from);
+    ListValue(ListValue&& from) noexcept
+        :
+        ListValue()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline ListValue& operator=(const ListValue& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline ListValue& operator=(ListValue&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const ListValue& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const ListValue* internal_default_instance()
+    {
+        return reinterpret_cast<const ListValue*>(
+            &_ListValue_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        3;
+
+    friend void swap(ListValue& a, ListValue& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(ListValue* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(ListValue* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    ListValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<ListValue>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const ListValue& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const ListValue& from)
+    {
+        ListValue::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(ListValue* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.ListValue";
+    }
+
+protected:
+    explicit ListValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValuesFieldNumber = 1,
+    };
+    // repeated .google.protobuf.Value values = 1;
+    int values_size() const;
+
+private:
+    int _internal_values_size() const;
+
+public:
+    void clear_values();
+    ::PROTOBUF_NAMESPACE_ID::Value* mutable_values(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Value>*
+        mutable_values();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Value& _internal_values(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Value* _internal_add_values();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Value& values(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Value* add_values();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Value>&
+        values() const;
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.ListValue)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Value> values_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fstruct_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // -------------------------------------------------------------------
 
 // Struct
 
 // map<string, .google.protobuf.Value> fields = 1;
-inline int Struct::_internal_fields_size() const {
-  return _impl_.fields_.size();
+inline int Struct::_internal_fields_size() const
+{
+    return _impl_.fields_.size();
 }
-inline int Struct::fields_size() const {
-  return _internal_fields_size();
+inline int Struct::fields_size() const
+{
+    return _internal_fields_size();
 }
-inline void Struct::clear_fields() {
-  _impl_.fields_.Clear();
+inline void Struct::clear_fields()
+{
+    _impl_.fields_.Clear();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >&
-Struct::_internal_fields() const {
-  return _impl_.fields_.GetMap();
+inline const ::PROTOBUF_NAMESPACE_ID::Map<std::string, ::PROTOBUF_NAMESPACE_ID::Value>&
+    Struct::_internal_fields() const
+{
+    return _impl_.fields_.GetMap();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >&
-Struct::fields() const {
-  // @@protoc_insertion_point(field_map:google.protobuf.Struct.fields)
-  return _internal_fields();
+inline const ::PROTOBUF_NAMESPACE_ID::Map<std::string, ::PROTOBUF_NAMESPACE_ID::Value>&
+    Struct::fields() const
+{
+    // @@protoc_insertion_point(field_map:google.protobuf.Struct.fields)
+    return _internal_fields();
 }
-inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >*
-Struct::_internal_mutable_fields() {
-  return _impl_.fields_.MutableMap();
+inline ::PROTOBUF_NAMESPACE_ID::Map<std::string, ::PROTOBUF_NAMESPACE_ID::Value>*
+    Struct::_internal_mutable_fields()
+{
+    return _impl_.fields_.MutableMap();
 }
-inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::Value >*
-Struct::mutable_fields() {
-  // @@protoc_insertion_point(field_mutable_map:google.protobuf.Struct.fields)
-  return _internal_mutable_fields();
+inline ::PROTOBUF_NAMESPACE_ID::Map<std::string, ::PROTOBUF_NAMESPACE_ID::Value>*
+    Struct::mutable_fields()
+{
+    // @@protoc_insertion_point(field_mutable_map:google.protobuf.Struct.fields)
+    return _internal_mutable_fields();
 }
 
 // -------------------------------------------------------------------
@@ -756,399 +940,507 @@ Struct::mutable_fields() {
 // Value
 
 // .google.protobuf.NullValue null_value = 1;
-inline bool Value::_internal_has_null_value() const {
-  return kind_case() == kNullValue;
-}
-inline bool Value::has_null_value() const {
-  return _internal_has_null_value();
-}
-inline void Value::set_has_null_value() {
-  _impl_._oneof_case_[0] = kNullValue;
-}
-inline void Value::clear_null_value() {
-  if (_internal_has_null_value()) {
-    _impl_.kind_.null_value_ = 0;
-    clear_has_kind();
-  }
-}
-inline ::PROTOBUF_NAMESPACE_ID::NullValue Value::_internal_null_value() const {
-  if (_internal_has_null_value()) {
-    return static_cast< ::PROTOBUF_NAMESPACE_ID::NullValue >(_impl_.kind_.null_value_);
-  }
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::NullValue >(0);
-}
-inline ::PROTOBUF_NAMESPACE_ID::NullValue Value::null_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Value.null_value)
-  return _internal_null_value();
+inline bool Value::_internal_has_null_value() const
+{
+    return kind_case() == kNullValue;
+}
+inline bool Value::has_null_value() const
+{
+    return _internal_has_null_value();
+}
+inline void Value::set_has_null_value()
+{
+    _impl_._oneof_case_[0] = kNullValue;
+}
+inline void Value::clear_null_value()
+{
+    if (_internal_has_null_value())
+    {
+        _impl_.kind_.null_value_ = 0;
+        clear_has_kind();
+    }
 }
-inline void Value::_internal_set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value) {
-  if (!_internal_has_null_value()) {
-    clear_kind();
-    set_has_null_value();
-  }
-  _impl_.kind_.null_value_ = value;
+inline ::PROTOBUF_NAMESPACE_ID::NullValue Value::_internal_null_value() const
+{
+    if (_internal_has_null_value())
+    {
+        return static_cast<::PROTOBUF_NAMESPACE_ID::NullValue>(_impl_.kind_.null_value_);
+    }
+    return static_cast<::PROTOBUF_NAMESPACE_ID::NullValue>(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::NullValue Value::null_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Value.null_value)
+    return _internal_null_value();
+}
+inline void Value::_internal_set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value)
+{
+    if (!_internal_has_null_value())
+    {
+        clear_kind();
+        set_has_null_value();
+    }
+    _impl_.kind_.null_value_ = value;
 }
-inline void Value::set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value) {
-  _internal_set_null_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Value.null_value)
+inline void Value::set_null_value(::PROTOBUF_NAMESPACE_ID::NullValue value)
+{
+    _internal_set_null_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Value.null_value)
 }
 
 // double number_value = 2;
-inline bool Value::_internal_has_number_value() const {
-  return kind_case() == kNumberValue;
-}
-inline bool Value::has_number_value() const {
-  return _internal_has_number_value();
-}
-inline void Value::set_has_number_value() {
-  _impl_._oneof_case_[0] = kNumberValue;
-}
-inline void Value::clear_number_value() {
-  if (_internal_has_number_value()) {
-    _impl_.kind_.number_value_ = 0;
-    clear_has_kind();
-  }
-}
-inline double Value::_internal_number_value() const {
-  if (_internal_has_number_value()) {
-    return _impl_.kind_.number_value_;
-  }
-  return 0;
+inline bool Value::_internal_has_number_value() const
+{
+    return kind_case() == kNumberValue;
+}
+inline bool Value::has_number_value() const
+{
+    return _internal_has_number_value();
+}
+inline void Value::set_has_number_value()
+{
+    _impl_._oneof_case_[0] = kNumberValue;
+}
+inline void Value::clear_number_value()
+{
+    if (_internal_has_number_value())
+    {
+        _impl_.kind_.number_value_ = 0;
+        clear_has_kind();
+    }
 }
-inline void Value::_internal_set_number_value(double value) {
-  if (!_internal_has_number_value()) {
-    clear_kind();
-    set_has_number_value();
-  }
-  _impl_.kind_.number_value_ = value;
+inline double Value::_internal_number_value() const
+{
+    if (_internal_has_number_value())
+    {
+        return _impl_.kind_.number_value_;
+    }
+    return 0;
+}
+inline void Value::_internal_set_number_value(double value)
+{
+    if (!_internal_has_number_value())
+    {
+        clear_kind();
+        set_has_number_value();
+    }
+    _impl_.kind_.number_value_ = value;
 }
-inline double Value::number_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Value.number_value)
-  return _internal_number_value();
+inline double Value::number_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Value.number_value)
+    return _internal_number_value();
 }
-inline void Value::set_number_value(double value) {
-  _internal_set_number_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Value.number_value)
+inline void Value::set_number_value(double value)
+{
+    _internal_set_number_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Value.number_value)
 }
 
 // string string_value = 3;
-inline bool Value::_internal_has_string_value() const {
-  return kind_case() == kStringValue;
-}
-inline bool Value::has_string_value() const {
-  return _internal_has_string_value();
-}
-inline void Value::set_has_string_value() {
-  _impl_._oneof_case_[0] = kStringValue;
-}
-inline void Value::clear_string_value() {
-  if (_internal_has_string_value()) {
-    _impl_.kind_.string_value_.Destroy();
-    clear_has_kind();
-  }
-}
-inline const std::string& Value::string_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Value.string_value)
-  return _internal_string_value();
+inline bool Value::_internal_has_string_value() const
+{
+    return kind_case() == kStringValue;
+}
+inline bool Value::has_string_value() const
+{
+    return _internal_has_string_value();
+}
+inline void Value::set_has_string_value()
+{
+    _impl_._oneof_case_[0] = kStringValue;
+}
+inline void Value::clear_string_value()
+{
+    if (_internal_has_string_value())
+    {
+        _impl_.kind_.string_value_.Destroy();
+        clear_has_kind();
+    }
 }
-template <typename ArgT0, typename... ArgT>
-inline void Value::set_string_value(ArgT0&& arg0, ArgT... args) {
-  if (!_internal_has_string_value()) {
-    clear_kind();
-    set_has_string_value();
-    _impl_.kind_.string_value_.InitDefault();
-  }
-  _impl_.kind_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Value.string_value)
-}
-inline std::string* Value::mutable_string_value() {
-  std::string* _s = _internal_mutable_string_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.string_value)
-  return _s;
-}
-inline const std::string& Value::_internal_string_value() const {
-  if (_internal_has_string_value()) {
-    return _impl_.kind_.string_value_.Get();
-  }
-  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void Value::_internal_set_string_value(const std::string& value) {
-  if (!_internal_has_string_value()) {
-    clear_kind();
-    set_has_string_value();
-    _impl_.kind_.string_value_.InitDefault();
-  }
-  _impl_.kind_.string_value_.Set(value, GetArenaForAllocation());
+inline const std::string& Value::string_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Value.string_value)
+    return _internal_string_value();
+}
+template<typename ArgT0, typename... ArgT>
+inline void Value::set_string_value(ArgT0&& arg0, ArgT... args)
+{
+    if (!_internal_has_string_value())
+    {
+        clear_kind();
+        set_has_string_value();
+        _impl_.kind_.string_value_.InitDefault();
+    }
+    _impl_.kind_.string_value_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Value.string_value)
+}
+inline std::string* Value::mutable_string_value()
+{
+    std::string* _s = _internal_mutable_string_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Value.string_value)
+    return _s;
+}
+inline const std::string& Value::_internal_string_value() const
+{
+    if (_internal_has_string_value())
+    {
+        return _impl_.kind_.string_value_.Get();
+    }
+    return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Value::_internal_set_string_value(const std::string& value)
+{
+    if (!_internal_has_string_value())
+    {
+        clear_kind();
+        set_has_string_value();
+        _impl_.kind_.string_value_.InitDefault();
+    }
+    _impl_.kind_.string_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Value::_internal_mutable_string_value()
+{
+    if (!_internal_has_string_value())
+    {
+        clear_kind();
+        set_has_string_value();
+        _impl_.kind_.string_value_.InitDefault();
+    }
+    return _impl_.kind_.string_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Value::release_string_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Value.string_value)
+    if (_internal_has_string_value())
+    {
+        clear_has_kind();
+        return _impl_.kind_.string_value_.Release();
+    }
+    else
+    {
+        return nullptr;
+    }
 }
-inline std::string* Value::_internal_mutable_string_value() {
-  if (!_internal_has_string_value()) {
-    clear_kind();
-    set_has_string_value();
-    _impl_.kind_.string_value_.InitDefault();
-  }
-  return _impl_.kind_.string_value_.Mutable(      GetArenaForAllocation());
-}
-inline std::string* Value::release_string_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Value.string_value)
-  if (_internal_has_string_value()) {
-    clear_has_kind();
-    return _impl_.kind_.string_value_.Release();
-  } else {
-    return nullptr;
-  }
-}
-inline void Value::set_allocated_string_value(std::string* string_value) {
-  if (has_kind()) {
-    clear_kind();
-  }
-  if (string_value != nullptr) {
-    set_has_string_value();
-    _impl_.kind_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
-  }
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Value.string_value)
+inline void Value::set_allocated_string_value(std::string* string_value)
+{
+    if (has_kind())
+    {
+        clear_kind();
+    }
+    if (string_value != nullptr)
+    {
+        set_has_string_value();
+        _impl_.kind_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
+    }
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.Value.string_value)
 }
 
 // bool bool_value = 4;
-inline bool Value::_internal_has_bool_value() const {
-  return kind_case() == kBoolValue;
-}
-inline bool Value::has_bool_value() const {
-  return _internal_has_bool_value();
+inline bool Value::_internal_has_bool_value() const
+{
+    return kind_case() == kBoolValue;
+}
+inline bool Value::has_bool_value() const
+{
+    return _internal_has_bool_value();
+}
+inline void Value::set_has_bool_value()
+{
+    _impl_._oneof_case_[0] = kBoolValue;
+}
+inline void Value::clear_bool_value()
+{
+    if (_internal_has_bool_value())
+    {
+        _impl_.kind_.bool_value_ = false;
+        clear_has_kind();
+    }
 }
-inline void Value::set_has_bool_value() {
-  _impl_._oneof_case_[0] = kBoolValue;
+inline bool Value::_internal_bool_value() const
+{
+    if (_internal_has_bool_value())
+    {
+        return _impl_.kind_.bool_value_;
+    }
+    return false;
+}
+inline void Value::_internal_set_bool_value(bool value)
+{
+    if (!_internal_has_bool_value())
+    {
+        clear_kind();
+        set_has_bool_value();
+    }
+    _impl_.kind_.bool_value_ = value;
 }
-inline void Value::clear_bool_value() {
-  if (_internal_has_bool_value()) {
-    _impl_.kind_.bool_value_ = false;
-    clear_has_kind();
-  }
+inline bool Value::bool_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Value.bool_value)
+    return _internal_bool_value();
 }
-inline bool Value::_internal_bool_value() const {
-  if (_internal_has_bool_value()) {
-    return _impl_.kind_.bool_value_;
-  }
-  return false;
+inline void Value::set_bool_value(bool value)
+{
+    _internal_set_bool_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Value.bool_value)
 }
-inline void Value::_internal_set_bool_value(bool value) {
-  if (!_internal_has_bool_value()) {
-    clear_kind();
-    set_has_bool_value();
-  }
-  _impl_.kind_.bool_value_ = value;
+
+// .google.protobuf.Struct struct_value = 5;
+inline bool Value::_internal_has_struct_value() const
+{
+    return kind_case() == kStructValue;
+}
+inline bool Value::has_struct_value() const
+{
+    return _internal_has_struct_value();
+}
+inline void Value::set_has_struct_value()
+{
+    _impl_._oneof_case_[0] = kStructValue;
+}
+inline void Value::clear_struct_value()
+{
+    if (_internal_has_struct_value())
+    {
+        if (GetArenaForAllocation() == nullptr)
+        {
+            delete _impl_.kind_.struct_value_;
+        }
+        clear_has_kind();
+    }
 }
-inline bool Value::bool_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Value.bool_value)
-  return _internal_bool_value();
+inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::release_struct_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Value.struct_value)
+    if (_internal_has_struct_value())
+    {
+        clear_has_kind();
+        ::PROTOBUF_NAMESPACE_ID::Struct* temp = _impl_.kind_.struct_value_;
+        if (GetArenaForAllocation() != nullptr)
+        {
+            temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+        }
+        _impl_.kind_.struct_value_ = nullptr;
+        return temp;
+    }
+    else
+    {
+        return nullptr;
+    }
 }
-inline void Value::set_bool_value(bool value) {
-  _internal_set_bool_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Value.bool_value)
+inline const ::PROTOBUF_NAMESPACE_ID::Struct& Value::_internal_struct_value() const
+{
+    return _internal_has_struct_value() ? *_impl_.kind_.struct_value_ : reinterpret_cast<::PROTOBUF_NAMESPACE_ID::Struct&>(::PROTOBUF_NAMESPACE_ID::_Struct_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Struct& Value::struct_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Value.struct_value)
+    return _internal_struct_value();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::unsafe_arena_release_struct_value()
+{
+    // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.struct_value)
+    if (_internal_has_struct_value())
+    {
+        clear_has_kind();
+        ::PROTOBUF_NAMESPACE_ID::Struct* temp = _impl_.kind_.struct_value_;
+        _impl_.kind_.struct_value_ = nullptr;
+        return temp;
+    }
+    else
+    {
+        return nullptr;
+    }
 }
-
-// .google.protobuf.Struct struct_value = 5;
-inline bool Value::_internal_has_struct_value() const {
-  return kind_case() == kStructValue;
-}
-inline bool Value::has_struct_value() const {
-  return _internal_has_struct_value();
-}
-inline void Value::set_has_struct_value() {
-  _impl_._oneof_case_[0] = kStructValue;
-}
-inline void Value::clear_struct_value() {
-  if (_internal_has_struct_value()) {
-    if (GetArenaForAllocation() == nullptr) {
-      delete _impl_.kind_.struct_value_;
-    }
-    clear_has_kind();
-  }
-}
-inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::release_struct_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Value.struct_value)
-  if (_internal_has_struct_value()) {
-    clear_has_kind();
-    ::PROTOBUF_NAMESPACE_ID::Struct* temp = _impl_.kind_.struct_value_;
-    if (GetArenaForAllocation() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    _impl_.kind_.struct_value_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Struct& Value::_internal_struct_value() const {
-  return _internal_has_struct_value()
-      ? *_impl_.kind_.struct_value_
-      : reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::Struct&>(::PROTOBUF_NAMESPACE_ID::_Struct_default_instance_);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Struct& Value::struct_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Value.struct_value)
-  return _internal_struct_value();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::unsafe_arena_release_struct_value() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.struct_value)
-  if (_internal_has_struct_value()) {
-    clear_has_kind();
-    ::PROTOBUF_NAMESPACE_ID::Struct* temp = _impl_.kind_.struct_value_;
-    _impl_.kind_.struct_value_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void Value::unsafe_arena_set_allocated_struct_value(::PROTOBUF_NAMESPACE_ID::Struct* struct_value) {
-  clear_kind();
-  if (struct_value) {
-    set_has_struct_value();
-    _impl_.kind_.struct_value_ = struct_value;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.struct_value)
-}
-inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::_internal_mutable_struct_value() {
-  if (!_internal_has_struct_value()) {
+inline void Value::unsafe_arena_set_allocated_struct_value(::PROTOBUF_NAMESPACE_ID::Struct* struct_value)
+{
     clear_kind();
-    set_has_struct_value();
-    _impl_.kind_.struct_value_ = CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::Struct >(GetArenaForAllocation());
-  }
-  return _impl_.kind_.struct_value_;
+    if (struct_value)
+    {
+        set_has_struct_value();
+        _impl_.kind_.struct_value_ = struct_value;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.struct_value)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::_internal_mutable_struct_value()
+{
+    if (!_internal_has_struct_value())
+    {
+        clear_kind();
+        set_has_struct_value();
+        _impl_.kind_.struct_value_ = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Struct>(GetArenaForAllocation());
+    }
+    return _impl_.kind_.struct_value_;
 }
-inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::mutable_struct_value() {
-  ::PROTOBUF_NAMESPACE_ID::Struct* _msg = _internal_mutable_struct_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.struct_value)
-  return _msg;
+inline ::PROTOBUF_NAMESPACE_ID::Struct* Value::mutable_struct_value()
+{
+    ::PROTOBUF_NAMESPACE_ID::Struct* _msg = _internal_mutable_struct_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Value.struct_value)
+    return _msg;
 }
 
 // .google.protobuf.ListValue list_value = 6;
-inline bool Value::_internal_has_list_value() const {
-  return kind_case() == kListValue;
-}
-inline bool Value::has_list_value() const {
-  return _internal_has_list_value();
-}
-inline void Value::set_has_list_value() {
-  _impl_._oneof_case_[0] = kListValue;
-}
-inline void Value::clear_list_value() {
-  if (_internal_has_list_value()) {
-    if (GetArenaForAllocation() == nullptr) {
-      delete _impl_.kind_.list_value_;
-    }
-    clear_has_kind();
-  }
-}
-inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::release_list_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Value.list_value)
-  if (_internal_has_list_value()) {
-    clear_has_kind();
-    ::PROTOBUF_NAMESPACE_ID::ListValue* temp = _impl_.kind_.list_value_;
-    if (GetArenaForAllocation() != nullptr) {
-      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-    }
-    _impl_.kind_.list_value_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline const ::PROTOBUF_NAMESPACE_ID::ListValue& Value::_internal_list_value() const {
-  return _internal_has_list_value()
-      ? *_impl_.kind_.list_value_
-      : reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::ListValue&>(::PROTOBUF_NAMESPACE_ID::_ListValue_default_instance_);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::ListValue& Value::list_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Value.list_value)
-  return _internal_list_value();
-}
-inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::unsafe_arena_release_list_value() {
-  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.list_value)
-  if (_internal_has_list_value()) {
-    clear_has_kind();
-    ::PROTOBUF_NAMESPACE_ID::ListValue* temp = _impl_.kind_.list_value_;
-    _impl_.kind_.list_value_ = nullptr;
-    return temp;
-  } else {
-    return nullptr;
-  }
-}
-inline void Value::unsafe_arena_set_allocated_list_value(::PROTOBUF_NAMESPACE_ID::ListValue* list_value) {
-  clear_kind();
-  if (list_value) {
-    set_has_list_value();
-    _impl_.kind_.list_value_ = list_value;
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.list_value)
-}
-inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::_internal_mutable_list_value() {
-  if (!_internal_has_list_value()) {
+inline bool Value::_internal_has_list_value() const
+{
+    return kind_case() == kListValue;
+}
+inline bool Value::has_list_value() const
+{
+    return _internal_has_list_value();
+}
+inline void Value::set_has_list_value()
+{
+    _impl_._oneof_case_[0] = kListValue;
+}
+inline void Value::clear_list_value()
+{
+    if (_internal_has_list_value())
+    {
+        if (GetArenaForAllocation() == nullptr)
+        {
+            delete _impl_.kind_.list_value_;
+        }
+        clear_has_kind();
+    }
+}
+inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::release_list_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Value.list_value)
+    if (_internal_has_list_value())
+    {
+        clear_has_kind();
+        ::PROTOBUF_NAMESPACE_ID::ListValue* temp = _impl_.kind_.list_value_;
+        if (GetArenaForAllocation() != nullptr)
+        {
+            temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+        }
+        _impl_.kind_.list_value_ = nullptr;
+        return temp;
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ListValue& Value::_internal_list_value() const
+{
+    return _internal_has_list_value() ? *_impl_.kind_.list_value_ : reinterpret_cast<::PROTOBUF_NAMESPACE_ID::ListValue&>(::PROTOBUF_NAMESPACE_ID::_ListValue_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::ListValue& Value::list_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Value.list_value)
+    return _internal_list_value();
+}
+inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::unsafe_arena_release_list_value()
+{
+    // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.list_value)
+    if (_internal_has_list_value())
+    {
+        clear_has_kind();
+        ::PROTOBUF_NAMESPACE_ID::ListValue* temp = _impl_.kind_.list_value_;
+        _impl_.kind_.list_value_ = nullptr;
+        return temp;
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+inline void Value::unsafe_arena_set_allocated_list_value(::PROTOBUF_NAMESPACE_ID::ListValue* list_value)
+{
     clear_kind();
-    set_has_list_value();
-    _impl_.kind_.list_value_ = CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::ListValue >(GetArenaForAllocation());
-  }
-  return _impl_.kind_.list_value_;
+    if (list_value)
+    {
+        set_has_list_value();
+        _impl_.kind_.list_value_ = list_value;
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.list_value)
+}
+inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::_internal_mutable_list_value()
+{
+    if (!_internal_has_list_value())
+    {
+        clear_kind();
+        set_has_list_value();
+        _impl_.kind_.list_value_ = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::ListValue>(GetArenaForAllocation());
+    }
+    return _impl_.kind_.list_value_;
 }
-inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::mutable_list_value() {
-  ::PROTOBUF_NAMESPACE_ID::ListValue* _msg = _internal_mutable_list_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.list_value)
-  return _msg;
+inline ::PROTOBUF_NAMESPACE_ID::ListValue* Value::mutable_list_value()
+{
+    ::PROTOBUF_NAMESPACE_ID::ListValue* _msg = _internal_mutable_list_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Value.list_value)
+    return _msg;
 }
 
-inline bool Value::has_kind() const {
-  return kind_case() != KIND_NOT_SET;
+inline bool Value::has_kind() const
+{
+    return kind_case() != KIND_NOT_SET;
 }
-inline void Value::clear_has_kind() {
-  _impl_._oneof_case_[0] = KIND_NOT_SET;
+inline void Value::clear_has_kind()
+{
+    _impl_._oneof_case_[0] = KIND_NOT_SET;
 }
-inline Value::KindCase Value::kind_case() const {
-  return Value::KindCase(_impl_._oneof_case_[0]);
+inline Value::KindCase Value::kind_case() const
+{
+    return Value::KindCase(_impl_._oneof_case_[0]);
 }
 // -------------------------------------------------------------------
 
 // ListValue
 
 // repeated .google.protobuf.Value values = 1;
-inline int ListValue::_internal_values_size() const {
-  return _impl_.values_.size();
-}
-inline int ListValue::values_size() const {
-  return _internal_values_size();
-}
-inline void ListValue::clear_values() {
-  _impl_.values_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::mutable_values(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.ListValue.values)
-  return _impl_.values_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value >*
-ListValue::mutable_values() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ListValue.values)
-  return &_impl_.values_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Value& ListValue::_internal_values(int index) const {
-  return _impl_.values_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Value& ListValue::values(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.ListValue.values)
-  return _internal_values(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::_internal_add_values() {
-  return _impl_.values_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::add_values() {
-  ::PROTOBUF_NAMESPACE_ID::Value* _add = _internal_add_values();
-  // @@protoc_insertion_point(field_add:google.protobuf.ListValue.values)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Value >&
-ListValue::values() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.ListValue.values)
-  return _impl_.values_;
+inline int ListValue::_internal_values_size() const
+{
+    return _impl_.values_.size();
+}
+inline int ListValue::values_size() const
+{
+    return _internal_values_size();
+}
+inline void ListValue::clear_values()
+{
+    _impl_.values_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::mutable_values(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.ListValue.values)
+    return _impl_.values_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Value>*
+    ListValue::mutable_values()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.ListValue.values)
+    return &_impl_.values_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Value& ListValue::_internal_values(int index) const
+{
+    return _impl_.values_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Value& ListValue::values(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.ListValue.values)
+    return _internal_values(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::_internal_add_values()
+{
+    return _impl_.values_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Value* ListValue::add_values()
+{
+    ::PROTOBUF_NAMESPACE_ID::Value* _add = _internal_add_values();
+    // @@protoc_insertion_point(field_add:google.protobuf.ListValue.values)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Value>&
+    ListValue::values() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.ListValue.values)
+    return _impl_.values_;
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 // -------------------------------------------------------------------
 
@@ -1156,17 +1448,20 @@ ListValue::values() const {
 
 // -------------------------------------------------------------------
 
-
 // @@protoc_insertion_point(namespace_scope)
 
 PROTOBUF_NAMESPACE_CLOSE
 
 PROTOBUF_NAMESPACE_OPEN
 
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::NullValue> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::NullValue>() {
-  return ::PROTOBUF_NAMESPACE_ID::NullValue_descriptor();
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::NullValue> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::NullValue>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::NullValue_descriptor();
 }
 
 PROTOBUF_NAMESPACE_CLOSE
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/bytestream.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/bytestream.h
index c7a48de..7d87088 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/bytestream.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/bytestream.h
@@ -60,290 +60,332 @@
 
 class CordByteSink;
 
-namespace google {
-namespace protobuf {
-namespace strings {
-
-// An abstract interface for an object that consumes a sequence of bytes. This
-// interface offers a way to append data as well as a Flush() function.
-//
-// Example:
-//
-//   string my_data;
-//   ...
-//   ByteSink* sink = ...
-//   sink->Append(my_data.data(), my_data.size());
-//   sink->Flush();
-//
-class PROTOBUF_EXPORT ByteSink {
- public:
-  ByteSink() {}
-  virtual ~ByteSink() {}
-
-  // Appends the "n" bytes starting at "bytes".
-  virtual void Append(const char* bytes, size_t n) = 0;
-
-  // Flushes internal buffers. The default implementation does nothing. ByteSink
-  // subclasses may use internal buffers that require calling Flush() at the end
-  // of the stream.
-  virtual void Flush();
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ByteSink);
-};
-
-// An abstract interface for an object that produces a fixed-size sequence of
-// bytes.
-//
-// Example:
-//
-//   ByteSource* source = ...
-//   while (source->Available() > 0) {
-//     StringPiece data = source->Peek();
-//     ... do something with "data" ...
-//     source->Skip(data.length());
-//   }
-//
-class PROTOBUF_EXPORT ByteSource {
- public:
-  ByteSource() {}
-  virtual ~ByteSource() {}
-
-  // Returns the number of bytes left to read from the source. Available()
-  // should decrease by N each time Skip(N) is called. Available() may not
-  // increase. Available() returning 0 indicates that the ByteSource is
-  // exhausted.
-  //
-  // Note: Size() may have been a more appropriate name as it's more
-  //       indicative of the fixed-size nature of a ByteSource.
-  virtual size_t Available() const = 0;
-
-  // Returns a StringPiece of the next contiguous region of the source. Does not
-  // reposition the source. The returned region is empty iff Available() == 0.
-  //
-  // The returned region is valid until the next call to Skip() or until this
-  // object is destroyed, whichever occurs first.
-  //
-  // The length of the returned StringPiece will be <= Available().
-  virtual StringPiece Peek() = 0;
-
-  // Skips the next n bytes. Invalidates any StringPiece returned by a previous
-  // call to Peek().
-  //
-  // REQUIRES: Available() >= n
-  virtual void Skip(size_t n) = 0;
-
-  // Writes the next n bytes in this ByteSource to the given ByteSink, and
-  // advances this ByteSource past the copied bytes. The default implementation
-  // of this method just copies the bytes normally, but subclasses might
-  // override CopyTo to optimize certain cases.
-  //
-  // REQUIRES: Available() >= n
-  virtual void CopyTo(ByteSink* sink, size_t n);
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ByteSource);
-};
-
-//
-// Some commonly used implementations of ByteSink
-//
-
-// Implementation of ByteSink that writes to an unsized byte array. No
-// bounds-checking is performed--it is the caller's responsibility to ensure
-// that the destination array is large enough.
-//
-// Example:
-//
-//   char buf[10];
-//   UncheckedArrayByteSink sink(buf);
-//   sink.Append("hi", 2);    // OK
-//   sink.Append(data, 100);  // WOOPS! Overflows buf[10].
-//
-class PROTOBUF_EXPORT UncheckedArrayByteSink : public ByteSink {
- public:
-  explicit UncheckedArrayByteSink(char* dest) : dest_(dest) {}
-  virtual void Append(const char* data, size_t n) override;
-
-  // Returns the current output pointer so that a caller can see how many bytes
-  // were produced.
-  //
-  // Note: this method is not part of the ByteSink interface.
-  char* CurrentDestination() const { return dest_; }
-
- private:
-  char* dest_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UncheckedArrayByteSink);
-};
-
-// Implementation of ByteSink that writes to a sized byte array. This sink will
-// not write more than "capacity" bytes to outbuf. Once "capacity" bytes are
-// appended, subsequent bytes will be ignored and Overflowed() will return true.
-// Overflowed() does not cause a runtime error (i.e., it does not CHECK fail).
-//
-// Example:
-//
-//   char buf[10];
-//   CheckedArrayByteSink sink(buf, 10);
-//   sink.Append("hi", 2);    // OK
-//   sink.Append(data, 100);  // Will only write 8 more bytes
-//
-class PROTOBUF_EXPORT CheckedArrayByteSink : public ByteSink {
- public:
-  CheckedArrayByteSink(char* outbuf, size_t capacity);
-  virtual void Append(const char* bytes, size_t n) override;
-
-  // Returns the number of bytes actually written to the sink.
-  size_t NumberOfBytesWritten() const { return size_; }
-
-  // Returns true if any bytes were discarded, i.e., if there was an
-  // attempt to write more than 'capacity' bytes.
-  bool Overflowed() const { return overflowed_; }
-
- private:
-  char* outbuf_;
-  const size_t capacity_;
-  size_t size_;
-  bool overflowed_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CheckedArrayByteSink);
-};
-
-// Implementation of ByteSink that allocates an internal buffer (a char array)
-// and expands it as needed to accommodate appended data (similar to a string),
-// and allows the caller to take ownership of the internal buffer via the
-// GetBuffer() method. The buffer returned from GetBuffer() must be deleted by
-// the caller with delete[]. GetBuffer() also sets the internal buffer to be
-// empty, and subsequent appends to the sink will create a new buffer. The
-// destructor will free the internal buffer if GetBuffer() was not called.
-//
-// Example:
-//
-//   GrowingArrayByteSink sink(10);
-//   sink.Append("hi", 2);
-//   sink.Append(data, n);
-//   const char* buf = sink.GetBuffer();  // Ownership transferred
-//   delete[] buf;
-//
-class PROTOBUF_EXPORT GrowingArrayByteSink : public strings::ByteSink {
- public:
-  explicit GrowingArrayByteSink(size_t estimated_size);
-  virtual ~GrowingArrayByteSink();
-  virtual void Append(const char* bytes, size_t n) override;
-
-  // Returns the allocated buffer, and sets nbytes to its size. The caller takes
-  // ownership of the buffer and must delete it with delete[].
-  char* GetBuffer(size_t* nbytes);
-
- private:
-  void Expand(size_t amount);
-  void ShrinkToFit();
-
-  size_t capacity_;
-  char* buf_;
-  size_t size_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GrowingArrayByteSink);
-};
-
-// Implementation of ByteSink that appends to the given string.
-// Existing contents of "dest" are not modified; new data is appended.
-//
-// Example:
-//
-//   string dest = "Hello ";
-//   StringByteSink sink(&dest);
-//   sink.Append("World", 5);
-//   assert(dest == "Hello World");
-//
-class PROTOBUF_EXPORT StringByteSink : public ByteSink {
- public:
-  explicit StringByteSink(std::string* dest) : dest_(dest) {}
-  virtual void Append(const char* data, size_t n) override;
-
- private:
-  std::string* dest_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringByteSink);
-};
-
-// Implementation of ByteSink that discards all data.
-//
-// Example:
-//
-//   NullByteSink sink;
-//   sink.Append(data, data.size());  // All data ignored.
-//
-class PROTOBUF_EXPORT NullByteSink : public ByteSink {
- public:
-  NullByteSink() {}
-  void Append(const char* /*data*/, size_t /*n*/) override {}
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(NullByteSink);
-};
-
-//
-// Some commonly used implementations of ByteSource
-//
-
-// Implementation of ByteSource that reads from a StringPiece.
-//
-// Example:
-//
-//   string data = "Hello";
-//   ArrayByteSource source(data);
-//   assert(source.Available() == 5);
-//   assert(source.Peek() == "Hello");
-//
-class PROTOBUF_EXPORT ArrayByteSource : public ByteSource {
- public:
-  explicit ArrayByteSource(StringPiece s) : input_(s) {}
-
-  virtual size_t Available() const override;
-  virtual StringPiece Peek() override;
-  virtual void Skip(size_t n) override;
-
- private:
-  StringPiece   input_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayByteSource);
-};
-
-// Implementation of ByteSource that wraps another ByteSource, limiting the
-// number of bytes returned.
-//
-// The caller maintains ownership of the underlying source, and may not use the
-// underlying source while using the LimitByteSource object.  The underlying
-// source's pointer is advanced by n bytes every time this LimitByteSource
-// object is advanced by n.
-//
-// Example:
-//
-//   string data = "Hello World";
-//   ArrayByteSource abs(data);
-//   assert(abs.Available() == data.size());
-//
-//   LimitByteSource limit(abs, 5);
-//   assert(limit.Available() == 5);
-//   assert(limit.Peek() == "Hello");
-//
-class PROTOBUF_EXPORT LimitByteSource : public ByteSource {
- public:
-  // Returns at most "limit" bytes from "source".
-  LimitByteSource(ByteSource* source, size_t limit);
-
-  virtual size_t Available() const override;
-  virtual StringPiece Peek() override;
-  virtual void Skip(size_t n) override;
-
-  // We override CopyTo so that we can forward to the underlying source, in
-  // case it has an efficient implementation of CopyTo.
-  virtual void CopyTo(ByteSink* sink, size_t n) override;
-
- private:
-  ByteSource* source_;
-  size_t limit_;
-};
-
-}  // namespace strings
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace strings
+        {
+
+            // An abstract interface for an object that consumes a sequence of bytes. This
+            // interface offers a way to append data as well as a Flush() function.
+            //
+            // Example:
+            //
+            //   string my_data;
+            //   ...
+            //   ByteSink* sink = ...
+            //   sink->Append(my_data.data(), my_data.size());
+            //   sink->Flush();
+            //
+            class PROTOBUF_EXPORT ByteSink
+            {
+            public:
+                ByteSink()
+                {
+                }
+                virtual ~ByteSink()
+                {
+                }
+
+                // Appends the "n" bytes starting at "bytes".
+                virtual void Append(const char* bytes, size_t n) = 0;
+
+                // Flushes internal buffers. The default implementation does nothing. ByteSink
+                // subclasses may use internal buffers that require calling Flush() at the end
+                // of the stream.
+                virtual void Flush();
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ByteSink);
+            };
+
+            // An abstract interface for an object that produces a fixed-size sequence of
+            // bytes.
+            //
+            // Example:
+            //
+            //   ByteSource* source = ...
+            //   while (source->Available() > 0) {
+            //     StringPiece data = source->Peek();
+            //     ... do something with "data" ...
+            //     source->Skip(data.length());
+            //   }
+            //
+            class PROTOBUF_EXPORT ByteSource
+            {
+            public:
+                ByteSource()
+                {
+                }
+                virtual ~ByteSource()
+                {
+                }
+
+                // Returns the number of bytes left to read from the source. Available()
+                // should decrease by N each time Skip(N) is called. Available() may not
+                // increase. Available() returning 0 indicates that the ByteSource is
+                // exhausted.
+                //
+                // Note: Size() may have been a more appropriate name as it's more
+                //       indicative of the fixed-size nature of a ByteSource.
+                virtual size_t Available() const = 0;
+
+                // Returns a StringPiece of the next contiguous region of the source. Does not
+                // reposition the source. The returned region is empty iff Available() == 0.
+                //
+                // The returned region is valid until the next call to Skip() or until this
+                // object is destroyed, whichever occurs first.
+                //
+                // The length of the returned StringPiece will be <= Available().
+                virtual StringPiece Peek() = 0;
+
+                // Skips the next n bytes. Invalidates any StringPiece returned by a previous
+                // call to Peek().
+                //
+                // REQUIRES: Available() >= n
+                virtual void Skip(size_t n) = 0;
+
+                // Writes the next n bytes in this ByteSource to the given ByteSink, and
+                // advances this ByteSource past the copied bytes. The default implementation
+                // of this method just copies the bytes normally, but subclasses might
+                // override CopyTo to optimize certain cases.
+                //
+                // REQUIRES: Available() >= n
+                virtual void CopyTo(ByteSink* sink, size_t n);
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ByteSource);
+            };
+
+            //
+            // Some commonly used implementations of ByteSink
+            //
+
+            // Implementation of ByteSink that writes to an unsized byte array. No
+            // bounds-checking is performed--it is the caller's responsibility to ensure
+            // that the destination array is large enough.
+            //
+            // Example:
+            //
+            //   char buf[10];
+            //   UncheckedArrayByteSink sink(buf);
+            //   sink.Append("hi", 2);    // OK
+            //   sink.Append(data, 100);  // WOOPS! Overflows buf[10].
+            //
+            class PROTOBUF_EXPORT UncheckedArrayByteSink : public ByteSink
+            {
+            public:
+                explicit UncheckedArrayByteSink(char* dest) :
+                    dest_(dest)
+                {
+                }
+                virtual void Append(const char* data, size_t n) override;
+
+                // Returns the current output pointer so that a caller can see how many bytes
+                // were produced.
+                //
+                // Note: this method is not part of the ByteSink interface.
+                char* CurrentDestination() const
+                {
+                    return dest_;
+                }
+
+            private:
+                char* dest_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UncheckedArrayByteSink);
+            };
+
+            // Implementation of ByteSink that writes to a sized byte array. This sink will
+            // not write more than "capacity" bytes to outbuf. Once "capacity" bytes are
+            // appended, subsequent bytes will be ignored and Overflowed() will return true.
+            // Overflowed() does not cause a runtime error (i.e., it does not CHECK fail).
+            //
+            // Example:
+            //
+            //   char buf[10];
+            //   CheckedArrayByteSink sink(buf, 10);
+            //   sink.Append("hi", 2);    // OK
+            //   sink.Append(data, 100);  // Will only write 8 more bytes
+            //
+            class PROTOBUF_EXPORT CheckedArrayByteSink : public ByteSink
+            {
+            public:
+                CheckedArrayByteSink(char* outbuf, size_t capacity);
+                virtual void Append(const char* bytes, size_t n) override;
+
+                // Returns the number of bytes actually written to the sink.
+                size_t NumberOfBytesWritten() const
+                {
+                    return size_;
+                }
+
+                // Returns true if any bytes were discarded, i.e., if there was an
+                // attempt to write more than 'capacity' bytes.
+                bool Overflowed() const
+                {
+                    return overflowed_;
+                }
+
+            private:
+                char* outbuf_;
+                const size_t capacity_;
+                size_t size_;
+                bool overflowed_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CheckedArrayByteSink);
+            };
+
+            // Implementation of ByteSink that allocates an internal buffer (a char array)
+            // and expands it as needed to accommodate appended data (similar to a string),
+            // and allows the caller to take ownership of the internal buffer via the
+            // GetBuffer() method. The buffer returned from GetBuffer() must be deleted by
+            // the caller with delete[]. GetBuffer() also sets the internal buffer to be
+            // empty, and subsequent appends to the sink will create a new buffer. The
+            // destructor will free the internal buffer if GetBuffer() was not called.
+            //
+            // Example:
+            //
+            //   GrowingArrayByteSink sink(10);
+            //   sink.Append("hi", 2);
+            //   sink.Append(data, n);
+            //   const char* buf = sink.GetBuffer();  // Ownership transferred
+            //   delete[] buf;
+            //
+            class PROTOBUF_EXPORT GrowingArrayByteSink : public strings::ByteSink
+            {
+            public:
+                explicit GrowingArrayByteSink(size_t estimated_size);
+                virtual ~GrowingArrayByteSink();
+                virtual void Append(const char* bytes, size_t n) override;
+
+                // Returns the allocated buffer, and sets nbytes to its size. The caller takes
+                // ownership of the buffer and must delete it with delete[].
+                char* GetBuffer(size_t* nbytes);
+
+            private:
+                void Expand(size_t amount);
+                void ShrinkToFit();
+
+                size_t capacity_;
+                char* buf_;
+                size_t size_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GrowingArrayByteSink);
+            };
+
+            // Implementation of ByteSink that appends to the given string.
+            // Existing contents of "dest" are not modified; new data is appended.
+            //
+            // Example:
+            //
+            //   string dest = "Hello ";
+            //   StringByteSink sink(&dest);
+            //   sink.Append("World", 5);
+            //   assert(dest == "Hello World");
+            //
+            class PROTOBUF_EXPORT StringByteSink : public ByteSink
+            {
+            public:
+                explicit StringByteSink(std::string* dest) :
+                    dest_(dest)
+                {
+                }
+                virtual void Append(const char* data, size_t n) override;
+
+            private:
+                std::string* dest_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringByteSink);
+            };
+
+            // Implementation of ByteSink that discards all data.
+            //
+            // Example:
+            //
+            //   NullByteSink sink;
+            //   sink.Append(data, data.size());  // All data ignored.
+            //
+            class PROTOBUF_EXPORT NullByteSink : public ByteSink
+            {
+            public:
+                NullByteSink()
+                {
+                }
+                void Append(const char* /*data*/, size_t /*n*/) override
+                {
+                }
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(NullByteSink);
+            };
+
+            //
+            // Some commonly used implementations of ByteSource
+            //
+
+            // Implementation of ByteSource that reads from a StringPiece.
+            //
+            // Example:
+            //
+            //   string data = "Hello";
+            //   ArrayByteSource source(data);
+            //   assert(source.Available() == 5);
+            //   assert(source.Peek() == "Hello");
+            //
+            class PROTOBUF_EXPORT ArrayByteSource : public ByteSource
+            {
+            public:
+                explicit ArrayByteSource(StringPiece s) :
+                    input_(s)
+                {
+                }
+
+                virtual size_t Available() const override;
+                virtual StringPiece Peek() override;
+                virtual void Skip(size_t n) override;
+
+            private:
+                StringPiece input_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayByteSource);
+            };
+
+            // Implementation of ByteSource that wraps another ByteSource, limiting the
+            // number of bytes returned.
+            //
+            // The caller maintains ownership of the underlying source, and may not use the
+            // underlying source while using the LimitByteSource object.  The underlying
+            // source's pointer is advanced by n bytes every time this LimitByteSource
+            // object is advanced by n.
+            //
+            // Example:
+            //
+            //   string data = "Hello World";
+            //   ArrayByteSource abs(data);
+            //   assert(abs.Available() == data.size());
+            //
+            //   LimitByteSource limit(abs, 5);
+            //   assert(limit.Available() == 5);
+            //   assert(limit.Peek() == "Hello");
+            //
+            class PROTOBUF_EXPORT LimitByteSource : public ByteSource
+            {
+            public:
+                // Returns at most "limit" bytes from "source".
+                LimitByteSource(ByteSource* source, size_t limit);
+
+                virtual size_t Available() const override;
+                virtual StringPiece Peek() override;
+                virtual void Skip(size_t n) override;
+
+                // We override CopyTo so that we can forward to the underlying source, in
+                // case it has an efficient implementation of CopyTo.
+                virtual void CopyTo(ByteSink* sink, size_t n) override;
+
+            private:
+                ByteSource* source_;
+                size_t limit_;
+            };
+
+        }  // namespace strings
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/callback.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/callback.h
index 43d546d..498ca48 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/callback.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/callback.h
@@ -10,572 +10,703 @@
 // ===================================================================
 // emulates google3/base/callback.h
 
-namespace google {
-namespace protobuf {
-
-// Abstract interface for a callback.  When calling an RPC, you must provide
-// a Closure to call when the procedure completes.  See the Service interface
-// in service.h.
-//
-// To automatically construct a Closure which calls a particular function or
-// method with a particular set of parameters, use the NewCallback() function.
-// Example:
-//   void FooDone(const FooResponse* response) {
-//     ...
-//   }
-//
-//   void CallFoo() {
-//     ...
-//     // When done, call FooDone() and pass it a pointer to the response.
-//     Closure* callback = NewCallback(&FooDone, response);
-//     // Make the call.
-//     service->Foo(controller, request, response, callback);
-//   }
-//
-// Example that calls a method:
-//   class Handler {
-//    public:
-//     ...
-//
-//     void FooDone(const FooResponse* response) {
-//       ...
-//     }
-//
-//     void CallFoo() {
-//       ...
-//       // When done, call FooDone() and pass it a pointer to the response.
-//       Closure* callback = NewCallback(this, &Handler::FooDone, response);
-//       // Make the call.
-//       service->Foo(controller, request, response, callback);
-//     }
-//   };
-//
-// Currently NewCallback() supports binding zero, one, or two arguments.
-//
-// Callbacks created with NewCallback() automatically delete themselves when
-// executed.  They should be used when a callback is to be called exactly
-// once (usually the case with RPC callbacks).  If a callback may be called
-// a different number of times (including zero), create it with
-// NewPermanentCallback() instead.  You are then responsible for deleting the
-// callback (using the "delete" keyword as normal).
-//
-// Note that NewCallback() is a bit touchy regarding argument types.  Generally,
-// the values you provide for the parameter bindings must exactly match the
-// types accepted by the callback function.  For example:
-//   void Foo(std::string s);
-//   NewCallback(&Foo, "foo");          // WON'T WORK:  const char* != string
-//   NewCallback(&Foo, std::string("foo"));  // WORKS
-// Also note that the arguments cannot be references:
-//   void Foo(const std::string& s);
-//   std::string my_str;
-//   NewCallback(&Foo, my_str);  // WON'T WORK:  Can't use references.
-// However, correctly-typed pointers will work just fine.
-class PROTOBUF_EXPORT Closure {
- public:
-  Closure() {}
-  virtual ~Closure();
-
-  virtual void Run() = 0;
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Closure);
-};
-
-template<typename R>
-class ResultCallback {
- public:
-  ResultCallback() {}
-  virtual ~ResultCallback() {}
-
-  virtual R Run() = 0;
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback);
-};
-
-template <typename R, typename A1>
-class PROTOBUF_EXPORT ResultCallback1 {
- public:
-  ResultCallback1() {}
-  virtual ~ResultCallback1() {}
-
-  virtual R Run(A1) = 0;
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback1);
-};
-
-template <typename R, typename A1, typename A2>
-class PROTOBUF_EXPORT ResultCallback2 {
- public:
-  ResultCallback2() {}
-  virtual ~ResultCallback2() {}
-
-  virtual R Run(A1,A2) = 0;
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback2);
-};
-
-namespace internal {
-
-class PROTOBUF_EXPORT FunctionClosure0 : public Closure {
- public:
-  typedef void (*FunctionType)();
-
-  FunctionClosure0(FunctionType function, bool self_deleting)
-    : function_(function), self_deleting_(self_deleting) {}
-  ~FunctionClosure0();
-
-  void Run() override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    function_();
-    if (needs_delete) delete this;
-  }
-
- private:
-  FunctionType function_;
-  bool self_deleting_;
-};
-
-template <typename Class>
-class MethodClosure0 : public Closure {
- public:
-  typedef void (Class::*MethodType)();
-
-  MethodClosure0(Class* object, MethodType method, bool self_deleting)
-    : object_(object), method_(method), self_deleting_(self_deleting) {}
-  ~MethodClosure0() {}
-
-  void Run() override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    (object_->*method_)();
-    if (needs_delete) delete this;
-  }
-
- private:
-  Class* object_;
-  MethodType method_;
-  bool self_deleting_;
-};
-
-template <typename Arg1>
-class FunctionClosure1 : public Closure {
- public:
-  typedef void (*FunctionType)(Arg1 arg1);
-
-  FunctionClosure1(FunctionType function, bool self_deleting,
-                   Arg1 arg1)
-    : function_(function), self_deleting_(self_deleting),
-      arg1_(arg1) {}
-  ~FunctionClosure1() {}
-
-  void Run() override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    function_(arg1_);
-    if (needs_delete) delete this;
-  }
-
- private:
-  FunctionType function_;
-  bool self_deleting_;
-  Arg1 arg1_;
-};
-
-template <typename Class, typename Arg1>
-class MethodClosure1 : public Closure {
- public:
-  typedef void (Class::*MethodType)(Arg1 arg1);
-
-  MethodClosure1(Class* object, MethodType method, bool self_deleting,
-                 Arg1 arg1)
-    : object_(object), method_(method), self_deleting_(self_deleting),
-      arg1_(arg1) {}
-  ~MethodClosure1() {}
-
-  void Run() override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    (object_->*method_)(arg1_);
-    if (needs_delete) delete this;
-  }
-
- private:
-  Class* object_;
-  MethodType method_;
-  bool self_deleting_;
-  Arg1 arg1_;
-};
-
-template <typename Arg1, typename Arg2>
-class FunctionClosure2 : public Closure {
- public:
-  typedef void (*FunctionType)(Arg1 arg1, Arg2 arg2);
-
-  FunctionClosure2(FunctionType function, bool self_deleting,
-                   Arg1 arg1, Arg2 arg2)
-    : function_(function), self_deleting_(self_deleting),
-      arg1_(arg1), arg2_(arg2) {}
-  ~FunctionClosure2() {}
-
-  void Run() override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    function_(arg1_, arg2_);
-    if (needs_delete) delete this;
-  }
-
- private:
-  FunctionType function_;
-  bool self_deleting_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-};
-
-template <typename Class, typename Arg1, typename Arg2>
-class MethodClosure2 : public Closure {
- public:
-  typedef void (Class::*MethodType)(Arg1 arg1, Arg2 arg2);
-
-  MethodClosure2(Class* object, MethodType method, bool self_deleting,
-                 Arg1 arg1, Arg2 arg2)
-    : object_(object), method_(method), self_deleting_(self_deleting),
-      arg1_(arg1), arg2_(arg2) {}
-  ~MethodClosure2() {}
-
-  void Run() override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    (object_->*method_)(arg1_, arg2_);
-    if (needs_delete) delete this;
-  }
-
- private:
-  Class* object_;
-  MethodType method_;
-  bool self_deleting_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-};
-
-template<typename R>
-class FunctionResultCallback_0_0 : public ResultCallback<R> {
- public:
-  typedef R (*FunctionType)();
-
-  FunctionResultCallback_0_0(FunctionType function, bool self_deleting)
-      : function_(function), self_deleting_(self_deleting) {}
-  ~FunctionResultCallback_0_0() {}
-
-  R Run() override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    R result = function_();
-    if (needs_delete) delete this;
-    return result;
-  }
-
- private:
-  FunctionType function_;
-  bool self_deleting_;
-};
-
-template<typename R, typename P1>
-class FunctionResultCallback_1_0 : public ResultCallback<R> {
- public:
-  typedef R (*FunctionType)(P1);
-
-  FunctionResultCallback_1_0(FunctionType function, bool self_deleting,
-                             P1 p1)
-      : function_(function), self_deleting_(self_deleting), p1_(p1) {}
-  ~FunctionResultCallback_1_0() {}
-
-  R Run() override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    R result = function_(p1_);
-    if (needs_delete) delete this;
-    return result;
-  }
-
- private:
-  FunctionType function_;
-  bool self_deleting_;
-  P1 p1_;
-};
-
-template<typename R, typename Arg1>
-class FunctionResultCallback_0_1 : public ResultCallback1<R, Arg1> {
- public:
-  typedef R (*FunctionType)(Arg1 arg1);
-
-  FunctionResultCallback_0_1(FunctionType function, bool self_deleting)
-      : function_(function), self_deleting_(self_deleting) {}
-  ~FunctionResultCallback_0_1() {}
-
-  R Run(Arg1 a1) override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    R result = function_(a1);
-    if (needs_delete) delete this;
-    return result;
-  }
-
- private:
-  FunctionType function_;
-  bool self_deleting_;
-};
-
-template<typename R, typename P1, typename A1>
-class FunctionResultCallback_1_1 : public ResultCallback1<R, A1> {
- public:
-  typedef R (*FunctionType)(P1, A1);
-
-  FunctionResultCallback_1_1(FunctionType function, bool self_deleting,
-                             P1 p1)
-      : function_(function), self_deleting_(self_deleting), p1_(p1) {}
-  ~FunctionResultCallback_1_1() {}
-
-  R Run(A1 a1) override {
-    bool needs_delete = self_deleting_;  // read in case callback deletes
-    R result = function_(p1_, a1);
-    if (needs_delete) delete this;
-    return result;
-  }
-
- private:
-  FunctionType function_;
-  bool self_deleting_;
-  P1 p1_;
-};
-
-template <typename T>
-struct InternalConstRef {
-  typedef typename std::remove_reference<T>::type base_type;
-  typedef const base_type& type;
-};
-
-template<typename R, typename T>
-class MethodResultCallback_0_0 : public ResultCallback<R> {
- public:
-  typedef R (T::*MethodType)();
-  MethodResultCallback_0_0(T* object, MethodType method, bool self_deleting)
-      : object_(object),
-        method_(method),
-        self_deleting_(self_deleting) {}
-  ~MethodResultCallback_0_0() {}
-
-  R Run() {
-    bool needs_delete = self_deleting_;
-    R result = (object_->*method_)();
-    if (needs_delete) delete this;
-    return result;
-  }
-
- private:
-  T* object_;
-  MethodType method_;
-  bool self_deleting_;
-};
-
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename P4, typename P5, typename P6, typename A1, typename A2>
-class MethodResultCallback_6_2 : public ResultCallback2<R, A1, A2> {
- public:
-  typedef R (T::*MethodType)(P1, P2, P3, P4, P5, P6, A1, A2);
-  MethodResultCallback_6_2(T* object, MethodType method, bool self_deleting,
-                           P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-      : object_(object),
-        method_(method),
-        self_deleting_(self_deleting),
-        p1_(p1),
-        p2_(p2),
-        p3_(p3),
-        p4_(p4),
-        p5_(p5),
-        p6_(p6) {}
-  ~MethodResultCallback_6_2() {}
-
-  R Run(A1 a1, A2 a2) override {
-    bool needs_delete = self_deleting_;
-    R result = (object_->*method_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2);
-    if (needs_delete) delete this;
-    return result;
-  }
-
- private:
-  T* object_;
-  MethodType method_;
-  bool self_deleting_;
-  typename std::remove_reference<P1>::type p1_;
-  typename std::remove_reference<P2>::type p2_;
-  typename std::remove_reference<P3>::type p3_;
-  typename std::remove_reference<P4>::type p4_;
-  typename std::remove_reference<P5>::type p5_;
-  typename std::remove_reference<P6>::type p6_;
-};
-
-}  // namespace internal
-
-// See Closure.
-inline Closure* NewCallback(void (*function)()) {
-  return new internal::FunctionClosure0(function, true);
-}
-
-// See Closure.
-inline Closure* NewPermanentCallback(void (*function)()) {
-  return new internal::FunctionClosure0(function, false);
-}
-
-// See Closure.
-template <typename Class>
-inline Closure* NewCallback(Class* object, void (Class::*method)()) {
-  return new internal::MethodClosure0<Class>(object, method, true);
-}
-
-// See Closure.
-template <typename Class>
-inline Closure* NewPermanentCallback(Class* object, void (Class::*method)()) {
-  return new internal::MethodClosure0<Class>(object, method, false);
-}
-
-// See Closure.
-template <typename Arg1>
-inline Closure* NewCallback(void (*function)(Arg1),
-                            Arg1 arg1) {
-  return new internal::FunctionClosure1<Arg1>(function, true, arg1);
-}
-
-// See Closure.
-template <typename Arg1>
-inline Closure* NewPermanentCallback(void (*function)(Arg1),
-                                     Arg1 arg1) {
-  return new internal::FunctionClosure1<Arg1>(function, false, arg1);
-}
-
-// See Closure.
-template <typename Class, typename Arg1>
-inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1),
-                            Arg1 arg1) {
-  return new internal::MethodClosure1<Class, Arg1>(object, method, true, arg1);
-}
-
-// See Closure.
-template <typename Class, typename Arg1>
-inline Closure* NewPermanentCallback(Class* object, void (Class::*method)(Arg1),
-                                     Arg1 arg1) {
-  return new internal::MethodClosure1<Class, Arg1>(object, method, false, arg1);
-}
-
-// See Closure.
-template <typename Arg1, typename Arg2>
-inline Closure* NewCallback(void (*function)(Arg1, Arg2),
-                            Arg1 arg1, Arg2 arg2) {
-  return new internal::FunctionClosure2<Arg1, Arg2>(
-    function, true, arg1, arg2);
-}
-
-// See Closure.
-template <typename Arg1, typename Arg2>
-inline Closure* NewPermanentCallback(void (*function)(Arg1, Arg2),
-                                     Arg1 arg1, Arg2 arg2) {
-  return new internal::FunctionClosure2<Arg1, Arg2>(
-    function, false, arg1, arg2);
-}
-
-// See Closure.
-template <typename Class, typename Arg1, typename Arg2>
-inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1, Arg2),
-                            Arg1 arg1, Arg2 arg2) {
-  return new internal::MethodClosure2<Class, Arg1, Arg2>(
-    object, method, true, arg1, arg2);
-}
-
-// See Closure.
-template <typename Class, typename Arg1, typename Arg2>
-inline Closure* NewPermanentCallback(
-    Class* object, void (Class::*method)(Arg1, Arg2),
-    Arg1 arg1, Arg2 arg2) {
-  return new internal::MethodClosure2<Class, Arg1, Arg2>(
-    object, method, false, arg1, arg2);
-}
-
-// See ResultCallback
-template<typename R>
-inline ResultCallback<R>* NewCallback(R (*function)()) {
-  return new internal::FunctionResultCallback_0_0<R>(function, true);
-}
-
-// See ResultCallback
-template<typename R>
-inline ResultCallback<R>* NewPermanentCallback(R (*function)()) {
-  return new internal::FunctionResultCallback_0_0<R>(function, false);
-}
-
-// See ResultCallback
-template<typename R, typename P1>
-inline ResultCallback<R>* NewCallback(R (*function)(P1), P1 p1) {
-  return new internal::FunctionResultCallback_1_0<R, P1>(
-      function, true, p1);
-}
-
-// See ResultCallback
-template<typename R, typename P1>
-inline ResultCallback<R>* NewPermanentCallback(
-    R (*function)(P1), P1 p1) {
-  return new internal::FunctionResultCallback_1_0<R, P1>(
-      function, false, p1);
-}
-
-// See ResultCallback1
-template<typename R, typename A1>
-inline ResultCallback1<R, A1>* NewCallback(R (*function)(A1)) {
-  return new internal::FunctionResultCallback_0_1<R, A1>(function, true);
-}
-
-// See ResultCallback1
-template<typename R, typename A1>
-inline ResultCallback1<R, A1>* NewPermanentCallback(R (*function)(A1)) {
-  return new internal::FunctionResultCallback_0_1<R, A1>(function, false);
-}
-
-// See ResultCallback1
-template<typename R, typename P1, typename A1>
-inline ResultCallback1<R, A1>* NewCallback(R (*function)(P1, A1), P1 p1) {
-  return new internal::FunctionResultCallback_1_1<R, P1, A1>(
-      function, true, p1);
-}
-
-// See ResultCallback1
-template<typename R, typename P1, typename A1>
-inline ResultCallback1<R, A1>* NewPermanentCallback(
-    R (*function)(P1, A1), P1 p1) {
-  return new internal::FunctionResultCallback_1_1<R, P1, A1>(
-      function, false, p1);
-}
-
-// See MethodResultCallback_0_0
-template <typename R, typename T1, typename T2>
-inline ResultCallback<R>* NewPermanentCallback(
-    T1* object, R (T2::*function)()) {
-  return new internal::MethodResultCallback_0_0<R, T1>(object, function, false);
-}
-
-// See MethodResultCallback_6_2
-template <typename R, typename T, typename P1, typename P2, typename P3,
-          typename P4, typename P5, typename P6, typename A1, typename A2>
-inline ResultCallback2<R, A1, A2>* NewPermanentCallback(
-    T* object, R (T::*function)(P1, P2, P3, P4, P5, P6, A1, A2),
-    typename internal::InternalConstRef<P1>::type p1,
-    typename internal::InternalConstRef<P2>::type p2,
-    typename internal::InternalConstRef<P3>::type p3,
-    typename internal::InternalConstRef<P4>::type p4,
-    typename internal::InternalConstRef<P5>::type p5,
-    typename internal::InternalConstRef<P6>::type p6) {
-  return new internal::MethodResultCallback_6_2<R, T, P1, P2, P3, P4, P5, P6,
-                                                A1, A2>(object, function, false,
-                                                        p1, p2, p3, p4, p5, p6);
-}
-
-// A function which does nothing.  Useful for creating no-op callbacks, e.g.:
-//   Closure* nothing = NewCallback(&DoNothing);
-void PROTOBUF_EXPORT DoNothing();
-
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        // Abstract interface for a callback.  When calling an RPC, you must provide
+        // a Closure to call when the procedure completes.  See the Service interface
+        // in service.h.
+        //
+        // To automatically construct a Closure which calls a particular function or
+        // method with a particular set of parameters, use the NewCallback() function.
+        // Example:
+        //   void FooDone(const FooResponse* response) {
+        //     ...
+        //   }
+        //
+        //   void CallFoo() {
+        //     ...
+        //     // When done, call FooDone() and pass it a pointer to the response.
+        //     Closure* callback = NewCallback(&FooDone, response);
+        //     // Make the call.
+        //     service->Foo(controller, request, response, callback);
+        //   }
+        //
+        // Example that calls a method:
+        //   class Handler {
+        //    public:
+        //     ...
+        //
+        //     void FooDone(const FooResponse* response) {
+        //       ...
+        //     }
+        //
+        //     void CallFoo() {
+        //       ...
+        //       // When done, call FooDone() and pass it a pointer to the response.
+        //       Closure* callback = NewCallback(this, &Handler::FooDone, response);
+        //       // Make the call.
+        //       service->Foo(controller, request, response, callback);
+        //     }
+        //   };
+        //
+        // Currently NewCallback() supports binding zero, one, or two arguments.
+        //
+        // Callbacks created with NewCallback() automatically delete themselves when
+        // executed.  They should be used when a callback is to be called exactly
+        // once (usually the case with RPC callbacks).  If a callback may be called
+        // a different number of times (including zero), create it with
+        // NewPermanentCallback() instead.  You are then responsible for deleting the
+        // callback (using the "delete" keyword as normal).
+        //
+        // Note that NewCallback() is a bit touchy regarding argument types.  Generally,
+        // the values you provide for the parameter bindings must exactly match the
+        // types accepted by the callback function.  For example:
+        //   void Foo(std::string s);
+        //   NewCallback(&Foo, "foo");          // WON'T WORK:  const char* != string
+        //   NewCallback(&Foo, std::string("foo"));  // WORKS
+        // Also note that the arguments cannot be references:
+        //   void Foo(const std::string& s);
+        //   std::string my_str;
+        //   NewCallback(&Foo, my_str);  // WON'T WORK:  Can't use references.
+        // However, correctly-typed pointers will work just fine.
+        class PROTOBUF_EXPORT Closure
+        {
+        public:
+            Closure()
+            {
+            }
+            virtual ~Closure();
+
+            virtual void Run() = 0;
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Closure);
+        };
+
+        template<typename R>
+        class ResultCallback
+        {
+        public:
+            ResultCallback()
+            {
+            }
+            virtual ~ResultCallback()
+            {
+            }
+
+            virtual R Run() = 0;
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback);
+        };
+
+        template<typename R, typename A1>
+        class PROTOBUF_EXPORT ResultCallback1
+        {
+        public:
+            ResultCallback1()
+            {
+            }
+            virtual ~ResultCallback1()
+            {
+            }
+
+            virtual R Run(A1) = 0;
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback1);
+        };
+
+        template<typename R, typename A1, typename A2>
+        class PROTOBUF_EXPORT ResultCallback2
+        {
+        public:
+            ResultCallback2()
+            {
+            }
+            virtual ~ResultCallback2()
+            {
+            }
+
+            virtual R Run(A1, A2) = 0;
+
+        private:
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback2);
+        };
+
+        namespace internal
+        {
+
+            class PROTOBUF_EXPORT FunctionClosure0 : public Closure
+            {
+            public:
+                typedef void (*FunctionType)();
+
+                FunctionClosure0(FunctionType function, bool self_deleting) :
+                    function_(function),
+                    self_deleting_(self_deleting)
+                {
+                }
+                ~FunctionClosure0();
+
+                void Run() override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    function_();
+                    if (needs_delete)
+                        delete this;
+                }
+
+            private:
+                FunctionType function_;
+                bool self_deleting_;
+            };
+
+            template<typename Class>
+            class MethodClosure0 : public Closure
+            {
+            public:
+                typedef void (Class::*MethodType)();
+
+                MethodClosure0(Class* object, MethodType method, bool self_deleting) :
+                    object_(object),
+                    method_(method),
+                    self_deleting_(self_deleting)
+                {
+                }
+                ~MethodClosure0()
+                {
+                }
+
+                void Run() override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    (object_->*method_)();
+                    if (needs_delete)
+                        delete this;
+                }
+
+            private:
+                Class* object_;
+                MethodType method_;
+                bool self_deleting_;
+            };
+
+            template<typename Arg1>
+            class FunctionClosure1 : public Closure
+            {
+            public:
+                typedef void (*FunctionType)(Arg1 arg1);
+
+                FunctionClosure1(FunctionType function, bool self_deleting, Arg1 arg1) :
+                    function_(function),
+                    self_deleting_(self_deleting),
+                    arg1_(arg1)
+                {
+                }
+                ~FunctionClosure1()
+                {
+                }
+
+                void Run() override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    function_(arg1_);
+                    if (needs_delete)
+                        delete this;
+                }
+
+            private:
+                FunctionType function_;
+                bool self_deleting_;
+                Arg1 arg1_;
+            };
+
+            template<typename Class, typename Arg1>
+            class MethodClosure1 : public Closure
+            {
+            public:
+                typedef void (Class::*MethodType)(Arg1 arg1);
+
+                MethodClosure1(Class* object, MethodType method, bool self_deleting, Arg1 arg1) :
+                    object_(object),
+                    method_(method),
+                    self_deleting_(self_deleting),
+                    arg1_(arg1)
+                {
+                }
+                ~MethodClosure1()
+                {
+                }
+
+                void Run() override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    (object_->*method_)(arg1_);
+                    if (needs_delete)
+                        delete this;
+                }
+
+            private:
+                Class* object_;
+                MethodType method_;
+                bool self_deleting_;
+                Arg1 arg1_;
+            };
+
+            template<typename Arg1, typename Arg2>
+            class FunctionClosure2 : public Closure
+            {
+            public:
+                typedef void (*FunctionType)(Arg1 arg1, Arg2 arg2);
+
+                FunctionClosure2(FunctionType function, bool self_deleting, Arg1 arg1, Arg2 arg2) :
+                    function_(function),
+                    self_deleting_(self_deleting),
+                    arg1_(arg1),
+                    arg2_(arg2)
+                {
+                }
+                ~FunctionClosure2()
+                {
+                }
+
+                void Run() override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    function_(arg1_, arg2_);
+                    if (needs_delete)
+                        delete this;
+                }
+
+            private:
+                FunctionType function_;
+                bool self_deleting_;
+                Arg1 arg1_;
+                Arg2 arg2_;
+            };
+
+            template<typename Class, typename Arg1, typename Arg2>
+            class MethodClosure2 : public Closure
+            {
+            public:
+                typedef void (Class::*MethodType)(Arg1 arg1, Arg2 arg2);
+
+                MethodClosure2(Class* object, MethodType method, bool self_deleting, Arg1 arg1, Arg2 arg2) :
+                    object_(object),
+                    method_(method),
+                    self_deleting_(self_deleting),
+                    arg1_(arg1),
+                    arg2_(arg2)
+                {
+                }
+                ~MethodClosure2()
+                {
+                }
+
+                void Run() override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    (object_->*method_)(arg1_, arg2_);
+                    if (needs_delete)
+                        delete this;
+                }
+
+            private:
+                Class* object_;
+                MethodType method_;
+                bool self_deleting_;
+                Arg1 arg1_;
+                Arg2 arg2_;
+            };
+
+            template<typename R>
+            class FunctionResultCallback_0_0 : public ResultCallback<R>
+            {
+            public:
+                typedef R (*FunctionType)();
+
+                FunctionResultCallback_0_0(FunctionType function, bool self_deleting) :
+                    function_(function),
+                    self_deleting_(self_deleting)
+                {
+                }
+                ~FunctionResultCallback_0_0()
+                {
+                }
+
+                R Run() override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    R result = function_();
+                    if (needs_delete)
+                        delete this;
+                    return result;
+                }
+
+            private:
+                FunctionType function_;
+                bool self_deleting_;
+            };
+
+            template<typename R, typename P1>
+            class FunctionResultCallback_1_0 : public ResultCallback<R>
+            {
+            public:
+                typedef R (*FunctionType)(P1);
+
+                FunctionResultCallback_1_0(FunctionType function, bool self_deleting, P1 p1) :
+                    function_(function),
+                    self_deleting_(self_deleting),
+                    p1_(p1)
+                {
+                }
+                ~FunctionResultCallback_1_0()
+                {
+                }
+
+                R Run() override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    R result = function_(p1_);
+                    if (needs_delete)
+                        delete this;
+                    return result;
+                }
+
+            private:
+                FunctionType function_;
+                bool self_deleting_;
+                P1 p1_;
+            };
+
+            template<typename R, typename Arg1>
+            class FunctionResultCallback_0_1 : public ResultCallback1<R, Arg1>
+            {
+            public:
+                typedef R (*FunctionType)(Arg1 arg1);
+
+                FunctionResultCallback_0_1(FunctionType function, bool self_deleting) :
+                    function_(function),
+                    self_deleting_(self_deleting)
+                {
+                }
+                ~FunctionResultCallback_0_1()
+                {
+                }
+
+                R Run(Arg1 a1) override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    R result = function_(a1);
+                    if (needs_delete)
+                        delete this;
+                    return result;
+                }
+
+            private:
+                FunctionType function_;
+                bool self_deleting_;
+            };
+
+            template<typename R, typename P1, typename A1>
+            class FunctionResultCallback_1_1 : public ResultCallback1<R, A1>
+            {
+            public:
+                typedef R (*FunctionType)(P1, A1);
+
+                FunctionResultCallback_1_1(FunctionType function, bool self_deleting, P1 p1) :
+                    function_(function),
+                    self_deleting_(self_deleting),
+                    p1_(p1)
+                {
+                }
+                ~FunctionResultCallback_1_1()
+                {
+                }
+
+                R Run(A1 a1) override
+                {
+                    bool needs_delete = self_deleting_;  // read in case callback deletes
+                    R result = function_(p1_, a1);
+                    if (needs_delete)
+                        delete this;
+                    return result;
+                }
+
+            private:
+                FunctionType function_;
+                bool self_deleting_;
+                P1 p1_;
+            };
+
+            template<typename T>
+            struct InternalConstRef
+            {
+                typedef typename std::remove_reference<T>::type base_type;
+                typedef const base_type& type;
+            };
+
+            template<typename R, typename T>
+            class MethodResultCallback_0_0 : public ResultCallback<R>
+            {
+            public:
+                typedef R (T::*MethodType)();
+                MethodResultCallback_0_0(T* object, MethodType method, bool self_deleting) :
+                    object_(object),
+                    method_(method),
+                    self_deleting_(self_deleting)
+                {
+                }
+                ~MethodResultCallback_0_0()
+                {
+                }
+
+                R Run()
+                {
+                    bool needs_delete = self_deleting_;
+                    R result = (object_->*method_)();
+                    if (needs_delete)
+                        delete this;
+                    return result;
+                }
+
+            private:
+                T* object_;
+                MethodType method_;
+                bool self_deleting_;
+            };
+
+            template<typename R, typename T, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename A1, typename A2>
+            class MethodResultCallback_6_2 : public ResultCallback2<R, A1, A2>
+            {
+            public:
+                typedef R (T::*MethodType)(P1, P2, P3, P4, P5, P6, A1, A2);
+                MethodResultCallback_6_2(T* object, MethodType method, bool self_deleting, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) :
+                    object_(object),
+                    method_(method),
+                    self_deleting_(self_deleting),
+                    p1_(p1),
+                    p2_(p2),
+                    p3_(p3),
+                    p4_(p4),
+                    p5_(p5),
+                    p6_(p6)
+                {
+                }
+                ~MethodResultCallback_6_2()
+                {
+                }
+
+                R Run(A1 a1, A2 a2) override
+                {
+                    bool needs_delete = self_deleting_;
+                    R result = (object_->*method_)(p1_, p2_, p3_, p4_, p5_, p6_, a1, a2);
+                    if (needs_delete)
+                        delete this;
+                    return result;
+                }
+
+            private:
+                T* object_;
+                MethodType method_;
+                bool self_deleting_;
+                typename std::remove_reference<P1>::type p1_;
+                typename std::remove_reference<P2>::type p2_;
+                typename std::remove_reference<P3>::type p3_;
+                typename std::remove_reference<P4>::type p4_;
+                typename std::remove_reference<P5>::type p5_;
+                typename std::remove_reference<P6>::type p6_;
+            };
+
+        }  // namespace internal
+
+        // See Closure.
+        inline Closure* NewCallback(void (*function)())
+        {
+            return new internal::FunctionClosure0(function, true);
+        }
+
+        // See Closure.
+        inline Closure* NewPermanentCallback(void (*function)())
+        {
+            return new internal::FunctionClosure0(function, false);
+        }
+
+        // See Closure.
+        template<typename Class>
+        inline Closure* NewCallback(Class* object, void (Class::*method)())
+        {
+            return new internal::MethodClosure0<Class>(object, method, true);
+        }
+
+        // See Closure.
+        template<typename Class>
+        inline Closure* NewPermanentCallback(Class* object, void (Class::*method)())
+        {
+            return new internal::MethodClosure0<Class>(object, method, false);
+        }
+
+        // See Closure.
+        template<typename Arg1>
+        inline Closure* NewCallback(void (*function)(Arg1), Arg1 arg1)
+        {
+            return new internal::FunctionClosure1<Arg1>(function, true, arg1);
+        }
+
+        // See Closure.
+        template<typename Arg1>
+        inline Closure* NewPermanentCallback(void (*function)(Arg1), Arg1 arg1)
+        {
+            return new internal::FunctionClosure1<Arg1>(function, false, arg1);
+        }
+
+        // See Closure.
+        template<typename Class, typename Arg1>
+        inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1), Arg1 arg1)
+        {
+            return new internal::MethodClosure1<Class, Arg1>(object, method, true, arg1);
+        }
+
+        // See Closure.
+        template<typename Class, typename Arg1>
+        inline Closure* NewPermanentCallback(Class* object, void (Class::*method)(Arg1), Arg1 arg1)
+        {
+            return new internal::MethodClosure1<Class, Arg1>(object, method, false, arg1);
+        }
+
+        // See Closure.
+        template<typename Arg1, typename Arg2>
+        inline Closure* NewCallback(void (*function)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
+        {
+            return new internal::FunctionClosure2<Arg1, Arg2>(
+                function, true, arg1, arg2
+            );
+        }
+
+        // See Closure.
+        template<typename Arg1, typename Arg2>
+        inline Closure* NewPermanentCallback(void (*function)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
+        {
+            return new internal::FunctionClosure2<Arg1, Arg2>(
+                function, false, arg1, arg2
+            );
+        }
+
+        // See Closure.
+        template<typename Class, typename Arg1, typename Arg2>
+        inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
+        {
+            return new internal::MethodClosure2<Class, Arg1, Arg2>(
+                object, method, true, arg1, arg2
+            );
+        }
+
+        // See Closure.
+        template<typename Class, typename Arg1, typename Arg2>
+        inline Closure* NewPermanentCallback(
+            Class* object, void (Class::*method)(Arg1, Arg2), Arg1 arg1, Arg2 arg2
+        )
+        {
+            return new internal::MethodClosure2<Class, Arg1, Arg2>(
+                object, method, false, arg1, arg2
+            );
+        }
+
+        // See ResultCallback
+        template<typename R>
+        inline ResultCallback<R>* NewCallback(R (*function)())
+        {
+            return new internal::FunctionResultCallback_0_0<R>(function, true);
+        }
+
+        // See ResultCallback
+        template<typename R>
+        inline ResultCallback<R>* NewPermanentCallback(R (*function)())
+        {
+            return new internal::FunctionResultCallback_0_0<R>(function, false);
+        }
+
+        // See ResultCallback
+        template<typename R, typename P1>
+        inline ResultCallback<R>* NewCallback(R (*function)(P1), P1 p1)
+        {
+            return new internal::FunctionResultCallback_1_0<R, P1>(
+                function, true, p1
+            );
+        }
+
+        // See ResultCallback
+        template<typename R, typename P1>
+        inline ResultCallback<R>* NewPermanentCallback(
+            R (*function)(P1), P1 p1
+        )
+        {
+            return new internal::FunctionResultCallback_1_0<R, P1>(
+                function, false, p1
+            );
+        }
+
+        // See ResultCallback1
+        template<typename R, typename A1>
+        inline ResultCallback1<R, A1>* NewCallback(R (*function)(A1))
+        {
+            return new internal::FunctionResultCallback_0_1<R, A1>(function, true);
+        }
+
+        // See ResultCallback1
+        template<typename R, typename A1>
+        inline ResultCallback1<R, A1>* NewPermanentCallback(R (*function)(A1))
+        {
+            return new internal::FunctionResultCallback_0_1<R, A1>(function, false);
+        }
+
+        // See ResultCallback1
+        template<typename R, typename P1, typename A1>
+        inline ResultCallback1<R, A1>* NewCallback(R (*function)(P1, A1), P1 p1)
+        {
+            return new internal::FunctionResultCallback_1_1<R, P1, A1>(
+                function, true, p1
+            );
+        }
+
+        // See ResultCallback1
+        template<typename R, typename P1, typename A1>
+        inline ResultCallback1<R, A1>* NewPermanentCallback(
+            R (*function)(P1, A1), P1 p1
+        )
+        {
+            return new internal::FunctionResultCallback_1_1<R, P1, A1>(
+                function, false, p1
+            );
+        }
+
+        // See MethodResultCallback_0_0
+        template<typename R, typename T1, typename T2>
+        inline ResultCallback<R>* NewPermanentCallback(
+            T1* object, R (T2::*function)()
+        )
+        {
+            return new internal::MethodResultCallback_0_0<R, T1>(object, function, false);
+        }
+
+        // See MethodResultCallback_6_2
+        template<typename R, typename T, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename A1, typename A2>
+        inline ResultCallback2<R, A1, A2>* NewPermanentCallback(
+            T* object, R (T::*function)(P1, P2, P3, P4, P5, P6, A1, A2), typename internal::InternalConstRef<P1>::type p1, typename internal::InternalConstRef<P2>::type p2, typename internal::InternalConstRef<P3>::type p3, typename internal::InternalConstRef<P4>::type p4, typename internal::InternalConstRef<P5>::type p5, typename internal::InternalConstRef<P6>::type p6
+        )
+        {
+            return new internal::MethodResultCallback_6_2<R, T, P1, P2, P3, P4, P5, P6, A1, A2>(object, function, false, p1, p2, p3, p4, p5, p6);
+        }
+
+        // A function which does nothing.  Useful for creating no-op callbacks, e.g.:
+        //   Closure* nothing = NewCallback(&DoNothing);
+        void PROTOBUF_EXPORT DoNothing();
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/casts.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/casts.h
index ad29dac..a6c1107 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/casts.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/casts.h
@@ -36,101 +36,110 @@
 #include <google/protobuf/port_def.inc>
 #include <type_traits>
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// Use implicit_cast as a safe version of static_cast or const_cast
-// for upcasting in the type hierarchy (i.e. casting a pointer to Foo
-// to a pointer to SuperclassOfFoo or casting a pointer to Foo to
-// a const pointer to Foo).
-// When you use implicit_cast, the compiler checks that the cast is safe.
-// Such explicit implicit_casts are necessary in surprisingly many
-// situations where C++ demands an exact type match instead of an
-// argument type convertible to a target type.
-//
-// The From type can be inferred, so the preferred syntax for using
-// implicit_cast is the same as for static_cast etc.:
-//
-//   implicit_cast<ToType>(expr)
-//
-// implicit_cast would have been part of the C++ standard library,
-// but the proposal was submitted too late.  It will probably make
-// its way into the language in the future.
-template<typename To, typename From>
-inline To implicit_cast(From const &f) {
-  return f;
-}
-
-// When you upcast (that is, cast a pointer from type Foo to type
-// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts
-// always succeed.  When you downcast (that is, cast a pointer from
-// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
-// how do you know the pointer is really of type SubclassOfFoo?  It
-// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
-// when you downcast, you should use this macro.  In debug mode, we
-// use dynamic_cast<> to double-check the downcast is legal (we die
-// if it's not).  In normal mode, we do the efficient static_cast<>
-// instead.  Thus, it's important to test in debug mode to make sure
-// the cast is legal!
-//    This is the only place in the code we should use dynamic_cast<>.
-// In particular, you SHOULDN'T be using dynamic_cast<> in order to
-// do RTTI (eg code like this:
-//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
-//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
-// You should design the code some other way not to need this.
-
-template<typename To, typename From>     // use like this: down_cast<T*>(foo);
-inline To down_cast(From* f) {                   // so we only accept pointers
-  // Ensures that To is a sub-type of From *.  This test is here only
-  // for compile-time type checking, and has no overhead in an
-  // optimized build at run-time, as it will be optimized away
-  // completely.
-  if (false) {
-    implicit_cast<From*, To>(0);
-  }
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // Use implicit_cast as a safe version of static_cast or const_cast
+            // for upcasting in the type hierarchy (i.e. casting a pointer to Foo
+            // to a pointer to SuperclassOfFoo or casting a pointer to Foo to
+            // a const pointer to Foo).
+            // When you use implicit_cast, the compiler checks that the cast is safe.
+            // Such explicit implicit_casts are necessary in surprisingly many
+            // situations where C++ demands an exact type match instead of an
+            // argument type convertible to a target type.
+            //
+            // The From type can be inferred, so the preferred syntax for using
+            // implicit_cast is the same as for static_cast etc.:
+            //
+            //   implicit_cast<ToType>(expr)
+            //
+            // implicit_cast would have been part of the C++ standard library,
+            // but the proposal was submitted too late.  It will probably make
+            // its way into the language in the future.
+            template<typename To, typename From>
+            inline To implicit_cast(From const& f)
+            {
+                return f;
+            }
+
+            // When you upcast (that is, cast a pointer from type Foo to type
+            // SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts
+            // always succeed.  When you downcast (that is, cast a pointer from
+            // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
+            // how do you know the pointer is really of type SubclassOfFoo?  It
+            // could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
+            // when you downcast, you should use this macro.  In debug mode, we
+            // use dynamic_cast<> to double-check the downcast is legal (we die
+            // if it's not).  In normal mode, we do the efficient static_cast<>
+            // instead.  Thus, it's important to test in debug mode to make sure
+            // the cast is legal!
+            //    This is the only place in the code we should use dynamic_cast<>.
+            // In particular, you SHOULDN'T be using dynamic_cast<> in order to
+            // do RTTI (eg code like this:
+            //    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
+            //    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
+            // You should design the code some other way not to need this.
+
+            template<typename To, typename From>  // use like this: down_cast<T*>(foo);
+            inline To down_cast(From* f)
+            {  // so we only accept pointers
+                // Ensures that To is a sub-type of From *.  This test is here only
+                // for compile-time type checking, and has no overhead in an
+                // optimized build at run-time, as it will be optimized away
+                // completely.
+                if (false)
+                {
+                    implicit_cast<From*, To>(0);
+                }
 
 #if !defined(NDEBUG) && PROTOBUF_RTTI
-  assert(f == nullptr || dynamic_cast<To>(f) != nullptr);  // RTTI: debug mode only!
+                assert(f == nullptr || dynamic_cast<To>(f) != nullptr);  // RTTI: debug mode only!
 #endif
-  return static_cast<To>(f);
-}
-
-template<typename To, typename From>    // use like this: down_cast<T&>(foo);
-inline To down_cast(From& f) {
-  typedef typename std::remove_reference<To>::type* ToAsPointer;
-  // Ensures that To is a sub-type of From *.  This test is here only
-  // for compile-time type checking, and has no overhead in an
-  // optimized build at run-time, as it will be optimized away
-  // completely.
-  if (false) {
-    implicit_cast<From*, ToAsPointer>(0);
-  }
+                return static_cast<To>(f);
+            }
+
+            template<typename To, typename From>  // use like this: down_cast<T&>(foo);
+            inline To down_cast(From& f)
+            {
+                typedef typename std::remove_reference<To>::type* ToAsPointer;
+                // Ensures that To is a sub-type of From *.  This test is here only
+                // for compile-time type checking, and has no overhead in an
+                // optimized build at run-time, as it will be optimized away
+                // completely.
+                if (false)
+                {
+                    implicit_cast<From*, ToAsPointer>(0);
+                }
 
 #if !defined(NDEBUG) && PROTOBUF_RTTI
-  // RTTI: debug mode only!
-  assert(dynamic_cast<ToAsPointer>(&f) != nullptr);
+                // RTTI: debug mode only!
+                assert(dynamic_cast<ToAsPointer>(&f) != nullptr);
 #endif
-  return *static_cast<ToAsPointer>(&f);
-}
-
-template<typename To, typename From>
-inline To bit_cast(const From& from) {
-  static_assert(sizeof(From) == sizeof(To), "bit_cast_with_different_sizes");
-  To dest;
-  memcpy(&dest, &from, sizeof(dest));
-  return dest;
-}
-
-}  // namespace internal
-
-// We made these internal so that they would show up as such in the docs,
-// but we don't want to stick "internal::" in front of them everywhere.
-using internal::implicit_cast;
-using internal::down_cast;
-using internal::bit_cast;
-
-}  // namespace protobuf
+                return *static_cast<ToAsPointer>(&f);
+            }
+
+            template<typename To, typename From>
+            inline To bit_cast(const From& from)
+            {
+                static_assert(sizeof(From) == sizeof(To), "bit_cast_with_different_sizes");
+                To dest;
+                memcpy(&dest, &from, sizeof(dest));
+                return dest;
+            }
+
+        }  // namespace internal
+
+        // We made these internal so that they would show up as such in the docs,
+        // but we don't want to stick "internal::" in front of them everywhere.
+        using internal::bit_cast;
+        using internal::down_cast;
+        using internal::implicit_cast;
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/common.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/common.h
index ebb1ca0..83693f3 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/common.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/common.h
@@ -50,11 +50,11 @@
 
 #ifndef PROTOBUF_USE_EXCEPTIONS
 #if defined(_MSC_VER) && defined(_CPPUNWIND)
-  #define PROTOBUF_USE_EXCEPTIONS 1
+#define PROTOBUF_USE_EXCEPTIONS 1
 #elif defined(__EXCEPTIONS)
-  #define PROTOBUF_USE_EXCEPTIONS 1
+#define PROTOBUF_USE_EXCEPTIONS 1
 #else
-  #define PROTOBUF_USE_EXCEPTIONS 0
+#define PROTOBUF_USE_EXCEPTIONS 0
 #endif
 #endif
 
@@ -71,11 +71,16 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace std {}
+namespace std
+{
+}
 
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
 // Some of these constants are macros rather than const ints so that they can
 // be used in #if directives.
@@ -87,109 +92,124 @@ namespace internal {
 // A suffix string for alpha, beta or rc releases. Empty for stable releases.
 #define GOOGLE_PROTOBUF_VERSION_SUFFIX ""
 
-// The minimum header version which works with the current version of
-// the library.  This constant should only be used by protoc's C++ code
-// generator.
-static const int kMinHeaderVersionForLibrary = 3021000;
+            // The minimum header version which works with the current version of
+            // the library.  This constant should only be used by protoc's C++ code
+            // generator.
+            static const int kMinHeaderVersionForLibrary = 3021000;
 
 // The minimum protoc version which works with the current version of the
 // headers.
 #define GOOGLE_PROTOBUF_MIN_PROTOC_VERSION 3021000
 
-// The minimum header version which works with the current version of
-// protoc.  This constant should only be used in VerifyVersion().
-static const int kMinHeaderVersionForProtoc = 3021000;
+            // The minimum header version which works with the current version of
+            // protoc.  This constant should only be used in VerifyVersion().
+            static const int kMinHeaderVersionForProtoc = 3021000;
 
-// Verifies that the headers and libraries are compatible.  Use the macro
-// below to call this.
-void PROTOBUF_EXPORT VerifyVersion(int headerVersion, int minLibraryVersion,
-                                   const char* filename);
+            // Verifies that the headers and libraries are compatible.  Use the macro
+            // below to call this.
+            void PROTOBUF_EXPORT VerifyVersion(int headerVersion, int minLibraryVersion, const char* filename);
 
-// Converts a numeric version number to a string.
-std::string PROTOBUF_EXPORT VersionString(int version);
+            // Converts a numeric version number to a string.
+            std::string PROTOBUF_EXPORT VersionString(int version);
 
-}  // namespace internal
+        }  // namespace internal
 
 // Place this macro in your main() function (or somewhere before you attempt
 // to use the protobuf library) to verify that the version you link against
 // matches the headers you compiled against.  If a version mismatch is
 // detected, the process will abort.
-#define GOOGLE_PROTOBUF_VERIFY_VERSION                                    \
-  ::google::protobuf::internal::VerifyVersion(                            \
-    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
-    __FILE__)
-
-
-// ===================================================================
-// from google3/util/utf8/public/unilib.h
-
-namespace internal {
-
-// Checks if the buffer contains structurally-valid UTF-8.  Implemented in
-// structurally_valid.cc.
-PROTOBUF_EXPORT bool IsStructurallyValidUTF8(const char* buf, int len);
-
-inline bool IsStructurallyValidUTF8(StringPiece str) {
-  return IsStructurallyValidUTF8(str.data(), static_cast<int>(str.length()));
-}
-
-// Returns initial number of bytes of structurally valid UTF-8.
-PROTOBUF_EXPORT int UTF8SpnStructurallyValid(StringPiece str);
-
-// Coerce UTF-8 byte string in src_str to be
-// a structurally-valid equal-length string by selectively
-// overwriting illegal bytes with replace_char (typically ' ' or '?').
-// replace_char must be legal printable 7-bit Ascii 0x20..0x7e.
-// src_str is read-only.
-//
-// Returns pointer to output buffer, src_str.data() if no changes were made,
-//  or idst if some bytes were changed. idst is allocated by the caller
-//  and must be at least as big as src_str
-//
-// Optimized for: all structurally valid and no byte copying is done.
-//
-PROTOBUF_EXPORT char* UTF8CoerceToStructurallyValid(StringPiece str, char* dst,
-                                                    char replace_char);
-
-}  // namespace internal
-
-// This lives in message_lite.h now, but we leave this here for any users that
-// #include common.h and not message_lite.h.
-PROTOBUF_EXPORT void ShutdownProtobufLibrary();
-
-namespace internal {
-
-// Strongly references the given variable such that the linker will be forced
-// to pull in this variable's translation unit.
-template <typename T>
-void StrongReference(const T& var) {
-  auto volatile unused = &var;
-  (void)&unused;  // Use address to avoid an extra load of "unused".
-}
-
-}  // namespace internal
+#define GOOGLE_PROTOBUF_VERIFY_VERSION                                         \
+    ::google::protobuf::internal::VerifyVersion(                               \
+        GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION, __FILE__ \
+    )
+
+        // ===================================================================
+        // from google3/util/utf8/public/unilib.h
+
+        namespace internal
+        {
+
+            // Checks if the buffer contains structurally-valid UTF-8.  Implemented in
+            // structurally_valid.cc.
+            PROTOBUF_EXPORT bool IsStructurallyValidUTF8(const char* buf, int len);
+
+            inline bool IsStructurallyValidUTF8(StringPiece str)
+            {
+                return IsStructurallyValidUTF8(str.data(), static_cast<int>(str.length()));
+            }
+
+            // Returns initial number of bytes of structurally valid UTF-8.
+            PROTOBUF_EXPORT int UTF8SpnStructurallyValid(StringPiece str);
+
+            // Coerce UTF-8 byte string in src_str to be
+            // a structurally-valid equal-length string by selectively
+            // overwriting illegal bytes with replace_char (typically ' ' or '?').
+            // replace_char must be legal printable 7-bit Ascii 0x20..0x7e.
+            // src_str is read-only.
+            //
+            // Returns pointer to output buffer, src_str.data() if no changes were made,
+            //  or idst if some bytes were changed. idst is allocated by the caller
+            //  and must be at least as big as src_str
+            //
+            // Optimized for: all structurally valid and no byte copying is done.
+            //
+            PROTOBUF_EXPORT char* UTF8CoerceToStructurallyValid(StringPiece str, char* dst, char replace_char);
+
+        }  // namespace internal
+
+        // This lives in message_lite.h now, but we leave this here for any users that
+        // #include common.h and not message_lite.h.
+        PROTOBUF_EXPORT void ShutdownProtobufLibrary();
+
+        namespace internal
+        {
+
+            // Strongly references the given variable such that the linker will be forced
+            // to pull in this variable's translation unit.
+            template<typename T>
+            void StrongReference(const T& var)
+            {
+                auto volatile unused = &var;
+                (void)&unused;  // Use address to avoid an extra load of "unused".
+            }
+
+        }  // namespace internal
 
 #if PROTOBUF_USE_EXCEPTIONS
-class FatalException : public std::exception {
- public:
-  FatalException(const char* filename, int line, const std::string& message)
-      : filename_(filename), line_(line), message_(message) {}
-  virtual ~FatalException() throw();
-
-  const char* what() const throw() override;
-
-  const char* filename() const { return filename_; }
-  int line() const { return line_; }
-  const std::string& message() const { return message_; }
-
- private:
-  const char* filename_;
-  const int line_;
-  const std::string message_;
-};
+        class FatalException : public std::exception
+        {
+        public:
+            FatalException(const char* filename, int line, const std::string& message) :
+                filename_(filename),
+                line_(line),
+                message_(message)
+            {
+            }
+            virtual ~FatalException() throw();
+
+            const char* what() const throw() override;
+
+            const char* filename() const
+            {
+                return filename_;
+            }
+            int line() const
+            {
+                return line_;
+            }
+            const std::string& message() const
+            {
+                return message_;
+            }
+
+        private:
+            const char* filename_;
+            const int line_;
+            const std::string message_;
+        };
 #endif
 
-}  // namespace protobuf
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/hash.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/hash.h
index a7ec068..885bae9 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/hash.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/hash.h
@@ -38,77 +38,97 @@
 #include <unordered_map>
 #include <unordered_set>
 
-# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START \
-  namespace google {                                      \
-  namespace protobuf {
-# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END }}
-
-namespace google {
-namespace protobuf {
-
-template <typename Key>
-struct hash : public std::hash<Key> {};
-
-template <typename Key>
-struct hash<const Key*> {
-  inline size_t operator()(const Key* key) const {
-    return reinterpret_cast<size_t>(key);
-  }
-};
-
-// Unlike the old SGI version, the TR1 "hash" does not special-case char*.  So,
-// we go ahead and provide our own implementation.
-template <>
-struct hash<const char*> {
-  inline size_t operator()(const char* str) const {
-    size_t result = 0;
-    for (; *str != '\0'; str++) {
-      result = 5 * result + static_cast<size_t>(*str);
+#define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START \
+    namespace google                                     \
+    {                                                    \
+        namespace protobuf                               \
+        {
+#define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END \
+    }                                                  \
     }
-    return result;
-  }
-};
-
-template<>
-struct hash<bool> {
-  size_t operator()(bool x) const {
-    return static_cast<size_t>(x);
-  }
-};
-
-template <>
-struct hash<std::string> {
-  inline size_t operator()(const std::string& key) const {
-    return hash<const char*>()(key.c_str());
-  }
-
-  static const size_t bucket_size = 4;
-  static const size_t min_buckets = 8;
-  inline bool operator()(const std::string& a, const std::string& b) const {
-    return a < b;
-  }
-};
-
-template <typename First, typename Second>
-struct hash<std::pair<First, Second> > {
-  inline size_t operator()(const std::pair<First, Second>& key) const {
-    size_t first_hash = hash<First>()(key.first);
-    size_t second_hash = hash<Second>()(key.second);
-
-    // FIXME(kenton):  What is the best way to compute this hash?  I have
-    // no idea!  This seems a bit better than an XOR.
-    return first_hash * ((1 << 16) - 1) + second_hash;
-  }
-
-  static const size_t bucket_size = 4;
-  static const size_t min_buckets = 8;
-  inline bool operator()(const std::pair<First, Second>& a,
-                           const std::pair<First, Second>& b) const {
-    return a < b;
-  }
-};
-
-}  // namespace protobuf
+
+namespace google
+{
+    namespace protobuf
+    {
+
+        template<typename Key>
+        struct hash : public std::hash<Key>
+        {
+        };
+
+        template<typename Key>
+        struct hash<const Key*>
+        {
+            inline size_t operator()(const Key* key) const
+            {
+                return reinterpret_cast<size_t>(key);
+            }
+        };
+
+        // Unlike the old SGI version, the TR1 "hash" does not special-case char*.  So,
+        // we go ahead and provide our own implementation.
+        template<>
+        struct hash<const char*>
+        {
+            inline size_t operator()(const char* str) const
+            {
+                size_t result = 0;
+                for (; *str != '\0'; str++)
+                {
+                    result = 5 * result + static_cast<size_t>(*str);
+                }
+                return result;
+            }
+        };
+
+        template<>
+        struct hash<bool>
+        {
+            size_t operator()(bool x) const
+            {
+                return static_cast<size_t>(x);
+            }
+        };
+
+        template<>
+        struct hash<std::string>
+        {
+            inline size_t operator()(const std::string& key) const
+            {
+                return hash<const char*>()(key.c_str());
+            }
+
+            static const size_t bucket_size = 4;
+            static const size_t min_buckets = 8;
+            inline bool operator()(const std::string& a, const std::string& b) const
+            {
+                return a < b;
+            }
+        };
+
+        template<typename First, typename Second>
+        struct hash<std::pair<First, Second>>
+        {
+            inline size_t operator()(const std::pair<First, Second>& key) const
+            {
+                size_t first_hash = hash<First>()(key.first);
+                size_t second_hash = hash<Second>()(key.second);
+
+                // FIXME(kenton):  What is the best way to compute this hash?  I have
+                // no idea!  This seems a bit better than an XOR.
+                return first_hash * ((1 << 16) - 1) + second_hash;
+            }
+
+            static const size_t bucket_size = 4;
+            static const size_t min_buckets = 8;
+            inline bool operator()(const std::pair<First, Second>& a, const std::pair<First, Second>& b) const
+            {
+                return a < b;
+            }
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_STUBS_HASH_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/logging.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/logging.h
index 8ecc2fa..11819df 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/logging.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/logging.h
@@ -41,78 +41,90 @@
 // ===================================================================
 // emulates google3/base/logging.h
 
-namespace google {
-namespace protobuf {
-
-enum LogLevel {
-  LOGLEVEL_INFO,     // Informational.  This is never actually used by
-                     // libprotobuf.
-  LOGLEVEL_WARNING,  // Warns about issues that, although not technically a
-                     // problem now, could cause problems in the future.  For
-                     // example, a // warning will be printed when parsing a
-                     // message that is near the message size limit.
-  LOGLEVEL_ERROR,    // An error occurred which should never happen during
-                     // normal use.
-  LOGLEVEL_FATAL,    // An error occurred from which the library cannot
-                     // recover.  This usually indicates a programming error
-                     // in the code which calls the library, especially when
-                     // compiled in debug mode.
+namespace google
+{
+    namespace protobuf
+    {
+
+        enum LogLevel
+        {
+            LOGLEVEL_INFO,     // Informational.  This is never actually used by
+                               // libprotobuf.
+            LOGLEVEL_WARNING,  // Warns about issues that, although not technically a
+                               // problem now, could cause problems in the future.  For
+                               // example, a // warning will be printed when parsing a
+                               // message that is near the message size limit.
+            LOGLEVEL_ERROR,    // An error occurred which should never happen during
+                               // normal use.
+            LOGLEVEL_FATAL,    // An error occurred from which the library cannot
+                               // recover.  This usually indicates a programming error
+                               // in the code which calls the library, especially when
+                               // compiled in debug mode.
 
 #ifdef NDEBUG
-  LOGLEVEL_DFATAL = LOGLEVEL_ERROR
+            LOGLEVEL_DFATAL = LOGLEVEL_ERROR
 #else
-  LOGLEVEL_DFATAL = LOGLEVEL_FATAL
+            LOGLEVEL_DFATAL = LOGLEVEL_FATAL
 #endif
-};
-
-class uint128;
-namespace internal {
-
-class LogFinisher;
-
-class PROTOBUF_EXPORT LogMessage {
- public:
-  LogMessage(LogLevel level, const char* filename, int line);
-  ~LogMessage();
-
-  LogMessage& operator<<(const std::string& value);
-  LogMessage& operator<<(const char* value);
-  LogMessage& operator<<(char value);
-  LogMessage& operator<<(int value);
-  LogMessage& operator<<(uint value);
-  LogMessage& operator<<(long value);
-  LogMessage& operator<<(unsigned long value);
-  LogMessage& operator<<(long long value);
-  LogMessage& operator<<(unsigned long long value);
-  LogMessage& operator<<(double value);
-  LogMessage& operator<<(void* value);
-  LogMessage& operator<<(const StringPiece& value);
-  LogMessage& operator<<(const util::Status& status);
-  LogMessage& operator<<(const uint128& value);
-
- private:
-  friend class LogFinisher;
-  void Finish();
-
-  LogLevel level_;
-  const char* filename_;
-  int line_;
-  std::string message_;
-};
-
-// Used to make the entire "LOG(BLAH) << etc." expression have a void return
-// type and print a newline after each message.
-class PROTOBUF_EXPORT LogFinisher {
- public:
-  void operator=(LogMessage& other);
-};
-
-template<typename T>
-bool IsOk(T status) { return status.ok(); }
-template<>
-inline bool IsOk(bool status) { return status; }
-
-}  // namespace internal
+        };
+
+        class uint128;
+        namespace internal
+        {
+
+            class LogFinisher;
+
+            class PROTOBUF_EXPORT LogMessage
+            {
+            public:
+                LogMessage(LogLevel level, const char* filename, int line);
+                ~LogMessage();
+
+                LogMessage& operator<<(const std::string& value);
+                LogMessage& operator<<(const char* value);
+                LogMessage& operator<<(char value);
+                LogMessage& operator<<(int value);
+                LogMessage& operator<<(uint value);
+                LogMessage& operator<<(long value);
+                LogMessage& operator<<(unsigned long value);
+                LogMessage& operator<<(long long value);
+                LogMessage& operator<<(unsigned long long value);
+                LogMessage& operator<<(double value);
+                LogMessage& operator<<(void* value);
+                LogMessage& operator<<(const StringPiece& value);
+                LogMessage& operator<<(const util::Status& status);
+                LogMessage& operator<<(const uint128& value);
+
+            private:
+                friend class LogFinisher;
+                void Finish();
+
+                LogLevel level_;
+                const char* filename_;
+                int line_;
+                std::string message_;
+            };
+
+            // Used to make the entire "LOG(BLAH) << etc." expression have a void return
+            // type and print a newline after each message.
+            class PROTOBUF_EXPORT LogFinisher
+            {
+            public:
+                void operator=(LogMessage& other);
+            };
+
+            template<typename T>
+            bool IsOk(T status)
+            {
+                return status.ok();
+            }
+            template<>
+            inline bool IsOk(bool status)
+            {
+                return status;
+            }
+
+        }  // namespace internal
 
 // Undef everything in case we're being mixed with some other Google library
 // which already defined them itself.  Presumably all Google libraries will
@@ -141,55 +153,61 @@ inline bool IsOk(bool status) { return status; }
 #undef GOOGLE_DCHECK_GT
 #undef GOOGLE_DCHECK_GE
 
-#define GOOGLE_LOG(LEVEL)                          \
-  ::google::protobuf::internal::LogFinisher() = \
-      ::google::protobuf::internal::LogMessage( \
-          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
+#define GOOGLE_LOG(LEVEL)                                            \
+    ::google::protobuf::internal::LogFinisher() =                    \
+        ::google::protobuf::internal::LogMessage(                    \
+            ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__ \
+        )
 #define GOOGLE_LOG_IF(LEVEL, CONDITION) \
-  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
+    !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
 
 #define GOOGLE_CHECK(EXPRESSION) \
-  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
+    GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
 #define GOOGLE_CHECK_OK(A) GOOGLE_CHECK(::google::protobuf::internal::IsOk(A))
 #define GOOGLE_CHECK_EQ(A, B) GOOGLE_CHECK((A) == (B))
 #define GOOGLE_CHECK_NE(A, B) GOOGLE_CHECK((A) != (B))
-#define GOOGLE_CHECK_LT(A, B) GOOGLE_CHECK((A) <  (B))
+#define GOOGLE_CHECK_LT(A, B) GOOGLE_CHECK((A) < (B))
 #define GOOGLE_CHECK_LE(A, B) GOOGLE_CHECK((A) <= (B))
-#define GOOGLE_CHECK_GT(A, B) GOOGLE_CHECK((A) >  (B))
+#define GOOGLE_CHECK_GT(A, B) GOOGLE_CHECK((A) > (B))
 #define GOOGLE_CHECK_GE(A, B) GOOGLE_CHECK((A) >= (B))
 
-namespace internal {
-template<typename T>
-T* CheckNotNull(const char* /* file */, int /* line */,
-                const char* name, T* val) {
-  if (val == nullptr) {
-    GOOGLE_LOG(FATAL) << name;
-  }
-  return val;
-}
-}  // namespace internal
-#define GOOGLE_CHECK_NOTNULL(A)               \
-  ::google::protobuf::internal::CheckNotNull( \
-      __FILE__, __LINE__, "'" #A "' must not be nullptr", (A))
+        namespace internal
+        {
+            template<typename T>
+            T* CheckNotNull(const char* /* file */, int /* line */, const char* name, T* val)
+            {
+                if (val == nullptr)
+                {
+                    GOOGLE_LOG(FATAL) << name;
+                }
+                return val;
+            }
+        }  // namespace internal
+#define GOOGLE_CHECK_NOTNULL(A)                                 \
+    ::google::protobuf::internal::CheckNotNull(                 \
+        __FILE__, __LINE__, "'" #A "' must not be nullptr", (A) \
+    )
 
 #ifdef NDEBUG
 
 #define GOOGLE_DLOG(LEVEL) GOOGLE_LOG_IF(LEVEL, false)
 
-#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
+#define GOOGLE_DCHECK(EXPRESSION) \
+    while (false)                 \
+    GOOGLE_CHECK(EXPRESSION)
 #define GOOGLE_DCHECK_OK(E) GOOGLE_DCHECK(::google::protobuf::internal::IsOk(E))
 #define GOOGLE_DCHECK_EQ(A, B) GOOGLE_DCHECK((A) == (B))
 #define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
-#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
+#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) < (B))
 #define GOOGLE_DCHECK_LE(A, B) GOOGLE_DCHECK((A) <= (B))
-#define GOOGLE_DCHECK_GT(A, B) GOOGLE_DCHECK((A) >  (B))
+#define GOOGLE_DCHECK_GT(A, B) GOOGLE_DCHECK((A) > (B))
 #define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
 
 #else  // NDEBUG
 
 #define GOOGLE_DLOG GOOGLE_LOG
 
-#define GOOGLE_DCHECK    GOOGLE_CHECK
+#define GOOGLE_DCHECK GOOGLE_CHECK
 #define GOOGLE_DCHECK_OK GOOGLE_CHECK_OK
 #define GOOGLE_DCHECK_EQ GOOGLE_CHECK_EQ
 #define GOOGLE_DCHECK_NE GOOGLE_CHECK_NE
@@ -200,38 +218,38 @@ T* CheckNotNull(const char* /* file */, int /* line */,
 
 #endif  // !NDEBUG
 
-typedef void LogHandler(LogLevel level, const char* filename, int line,
-                        const std::string& message);
-
-// The protobuf library sometimes writes warning and error messages to
-// stderr.  These messages are primarily useful for developers, but may
-// also help end users figure out a problem.  If you would prefer that
-// these messages be sent somewhere other than stderr, call SetLogHandler()
-// to set your own handler.  This returns the old handler.  Set the handler
-// to nullptr to ignore log messages (but see also LogSilencer, below).
-//
-// Obviously, SetLogHandler is not thread-safe.  You should only call it
-// at initialization time, and probably not from library code.  If you
-// simply want to suppress log messages temporarily (e.g. because you
-// have some code that tends to trigger them frequently and you know
-// the warnings are not important to you), use the LogSilencer class
-// below.
-PROTOBUF_EXPORT LogHandler* SetLogHandler(LogHandler* new_func);
-
-// Create a LogSilencer if you want to temporarily suppress all log
-// messages.  As long as any LogSilencer objects exist, non-fatal
-// log messages will be discarded (the current LogHandler will *not*
-// be called).  Constructing a LogSilencer is thread-safe.  You may
-// accidentally suppress log messages occurring in another thread, but
-// since messages are generally for debugging purposes only, this isn't
-// a big deal.  If you want to intercept log messages, use SetLogHandler().
-class PROTOBUF_EXPORT LogSilencer {
- public:
-  LogSilencer();
-  ~LogSilencer();
-};
-
-}  // namespace protobuf
+        typedef void LogHandler(LogLevel level, const char* filename, int line, const std::string& message);
+
+        // The protobuf library sometimes writes warning and error messages to
+        // stderr.  These messages are primarily useful for developers, but may
+        // also help end users figure out a problem.  If you would prefer that
+        // these messages be sent somewhere other than stderr, call SetLogHandler()
+        // to set your own handler.  This returns the old handler.  Set the handler
+        // to nullptr to ignore log messages (but see also LogSilencer, below).
+        //
+        // Obviously, SetLogHandler is not thread-safe.  You should only call it
+        // at initialization time, and probably not from library code.  If you
+        // simply want to suppress log messages temporarily (e.g. because you
+        // have some code that tends to trigger them frequently and you know
+        // the warnings are not important to you), use the LogSilencer class
+        // below.
+        PROTOBUF_EXPORT LogHandler* SetLogHandler(LogHandler* new_func);
+
+        // Create a LogSilencer if you want to temporarily suppress all log
+        // messages.  As long as any LogSilencer objects exist, non-fatal
+        // log messages will be discarded (the current LogHandler will *not*
+        // be called).  Constructing a LogSilencer is thread-safe.  You may
+        // accidentally suppress log messages occurring in another thread, but
+        // since messages are generally for debugging purposes only, this isn't
+        // a big deal.  If you want to intercept log messages, use SetLogHandler().
+        class PROTOBUF_EXPORT LogSilencer
+        {
+        public:
+            LogSilencer();
+            ~LogSilencer();
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/macros.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/macros.h
index ae9a8b9..9550458 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/macros.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/macros.h
@@ -31,63 +31,65 @@
 #ifndef GOOGLE_PROTOBUF_MACROS_H__
 #define GOOGLE_PROTOBUF_MACROS_H__
 
-namespace google {
-namespace protobuf {
+namespace google
+{
+    namespace protobuf
+    {
 
 #undef GOOGLE_DISALLOW_EVIL_CONSTRUCTORS
 #define GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeName) \
-  TypeName(const TypeName&) = delete;               \
-  void operator=(const TypeName&) = delete
+    TypeName(const TypeName&) = delete;             \
+    void operator=(const TypeName&) = delete
 
 #undef GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS
 #define GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
-  TypeName() = delete;                                  \
-  TypeName(const TypeName&) = delete;                   \
-  void operator=(const TypeName&) = delete
+    TypeName() = delete;                                \
+    TypeName(const TypeName&) = delete;                 \
+    void operator=(const TypeName&) = delete
 
-// ===================================================================
-// from google3/base/basictypes.h
+        // ===================================================================
+        // from google3/base/basictypes.h
 
-// The GOOGLE_ARRAYSIZE(arr) macro returns the # of elements in an array arr.
-// The expression is a compile-time constant, and therefore can be
-// used in defining new arrays, for example.
-//
-// GOOGLE_ARRAYSIZE catches a few type errors.  If you see a compiler error
-//
-//   "warning: division by zero in ..."
-//
-// when using GOOGLE_ARRAYSIZE, you are (wrongfully) giving it a pointer.
-// You should only use GOOGLE_ARRAYSIZE on statically allocated arrays.
-//
-// The following comments are on the implementation details, and can
-// be ignored by the users.
-//
-// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
-// the array) and sizeof(*(arr)) (the # of bytes in one array
-// element).  If the former is divisible by the latter, perhaps arr is
-// indeed an array, in which case the division result is the # of
-// elements in the array.  Otherwise, arr cannot possibly be an array,
-// and we generate a compiler error to prevent the code from
-// compiling.
-//
-// Since the size of bool is implementation-defined, we need to cast
-// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
-// result has type size_t.
-//
-// This macro is not perfect as it wrongfully accepts certain
-// pointers, namely where the pointer size is divisible by the pointee
-// size.  Since all our code has to go through a 32-bit compiler,
-// where a pointer is 4 bytes, this means all pointers to a type whose
-// size is 3 or greater than 4 will be (righteously) rejected.
-//
-// Kudos to Jorg Brown for this simple and elegant implementation.
+        // The GOOGLE_ARRAYSIZE(arr) macro returns the # of elements in an array arr.
+        // The expression is a compile-time constant, and therefore can be
+        // used in defining new arrays, for example.
+        //
+        // GOOGLE_ARRAYSIZE catches a few type errors.  If you see a compiler error
+        //
+        //   "warning: division by zero in ..."
+        //
+        // when using GOOGLE_ARRAYSIZE, you are (wrongfully) giving it a pointer.
+        // You should only use GOOGLE_ARRAYSIZE on statically allocated arrays.
+        //
+        // The following comments are on the implementation details, and can
+        // be ignored by the users.
+        //
+        // ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
+        // the array) and sizeof(*(arr)) (the # of bytes in one array
+        // element).  If the former is divisible by the latter, perhaps arr is
+        // indeed an array, in which case the division result is the # of
+        // elements in the array.  Otherwise, arr cannot possibly be an array,
+        // and we generate a compiler error to prevent the code from
+        // compiling.
+        //
+        // Since the size of bool is implementation-defined, we need to cast
+        // !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
+        // result has type size_t.
+        //
+        // This macro is not perfect as it wrongfully accepts certain
+        // pointers, namely where the pointer size is divisible by the pointee
+        // size.  Since all our code has to go through a 32-bit compiler,
+        // where a pointer is 4 bytes, this means all pointers to a type whose
+        // size is 3 or greater than 4 will be (righteously) rejected.
+        //
+        // Kudos to Jorg Brown for this simple and elegant implementation.
 
 #undef GOOGLE_ARRAYSIZE
-#define GOOGLE_ARRAYSIZE(a) \
-  ((sizeof(a) / sizeof(*(a))) / \
-   static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
+#define GOOGLE_ARRAYSIZE(a)       \
+    ((sizeof(a) / sizeof(*(a))) / \
+     static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
 
-}  // namespace protobuf
+    }  // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_MACROS_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h
index 24e098a..6d5cd80 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h
@@ -42,728 +42,801 @@
 
 #include <google/protobuf/stubs/common.h>
 
-namespace google {
-namespace protobuf {
-namespace internal {
-// Local implementation of RemoveConst to avoid including base/type_traits.h.
-template <class T> struct RemoveConst { typedef T type; };
-template <class T> struct RemoveConst<const T> : RemoveConst<T> {};
-}  // namespace internal
-
-//
-// Find*()
-//
-
-// Returns a const reference to the value associated with the given key if it
-// exists. Crashes otherwise.
-//
-// This is intended as a replacement for operator[] as an rvalue (for reading)
-// when the key is guaranteed to exist.
-//
-// operator[] for lookup is discouraged for several reasons:
-//  * It has a side-effect of inserting missing keys
-//  * It is not thread-safe (even when it is not inserting, it can still
-//      choose to resize the underlying storage)
-//  * It invalidates iterators (when it chooses to resize)
-//  * It default constructs a value object even if it doesn't need to
-//
-// This version assumes the key is printable, and includes it in the fatal log
-// message.
-template <class Collection>
-const typename Collection::value_type::second_type&
-FindOrDie(const Collection& collection,
-          const typename Collection::value_type::first_type& key) {
-  typename Collection::const_iterator it = collection.find(key);
-  GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
-  return it->second;
-}
-
-// Same as above, but returns a non-const reference.
-template <class Collection>
-typename Collection::value_type::second_type&
-FindOrDie(Collection& collection,  // NOLINT
-          const typename Collection::value_type::first_type& key) {
-  typename Collection::iterator it = collection.find(key);
-  GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
-  return it->second;
-}
-
-// Same as FindOrDie above, but doesn't log the key on failure.
-template <class Collection>
-const typename Collection::value_type::second_type&
-FindOrDieNoPrint(const Collection& collection,
-                 const typename Collection::value_type::first_type& key) {
-  typename Collection::const_iterator it = collection.find(key);
-  GOOGLE_CHECK(it != collection.end()) << "Map key not found";
-  return it->second;
-}
-
-// Same as above, but returns a non-const reference.
-template <class Collection>
-typename Collection::value_type::second_type&
-FindOrDieNoPrint(Collection& collection,  // NOLINT
-                 const typename Collection::value_type::first_type& key) {
-  typename Collection::iterator it = collection.find(key);
-  GOOGLE_CHECK(it != collection.end()) << "Map key not found";
-  return it->second;
-}
-
-// Returns a const reference to the value associated with the given key if it
-// exists, otherwise returns a const reference to the provided default value.
-//
-// WARNING: If a temporary object is passed as the default "value,"
-// this function will return a reference to that temporary object,
-// which will be destroyed at the end of the statement. A common
-// example: if you have a map with string values, and you pass a char*
-// as the default "value," either use the returned value immediately
-// or store it in a string (not string&).
-// Details: http://go/findwithdefault
-template <class Collection>
-const typename Collection::value_type::second_type&
-FindWithDefault(const Collection& collection,
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+            // Local implementation of RemoveConst to avoid including base/type_traits.h.
+            template<class T>
+            struct RemoveConst
+            {
+                typedef T type;
+            };
+            template<class T>
+            struct RemoveConst<const T> : RemoveConst<T>
+            {
+            };
+        }  // namespace internal
+
+        //
+        // Find*()
+        //
+
+        // Returns a const reference to the value associated with the given key if it
+        // exists. Crashes otherwise.
+        //
+        // This is intended as a replacement for operator[] as an rvalue (for reading)
+        // when the key is guaranteed to exist.
+        //
+        // operator[] for lookup is discouraged for several reasons:
+        //  * It has a side-effect of inserting missing keys
+        //  * It is not thread-safe (even when it is not inserting, it can still
+        //      choose to resize the underlying storage)
+        //  * It invalidates iterators (when it chooses to resize)
+        //  * It default constructs a value object even if it doesn't need to
+        //
+        // This version assumes the key is printable, and includes it in the fatal log
+        // message.
+        template<class Collection>
+        const typename Collection::value_type::second_type&
+            FindOrDie(const Collection& collection, const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::const_iterator it = collection.find(key);
+            GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
+            return it->second;
+        }
+
+        // Same as above, but returns a non-const reference.
+        template<class Collection>
+        typename Collection::value_type::second_type&
+            FindOrDie(Collection& collection,  // NOLINT
+                      const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::iterator it = collection.find(key);
+            GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
+            return it->second;
+        }
+
+        // Same as FindOrDie above, but doesn't log the key on failure.
+        template<class Collection>
+        const typename Collection::value_type::second_type&
+            FindOrDieNoPrint(const Collection& collection, const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::const_iterator it = collection.find(key);
+            GOOGLE_CHECK(it != collection.end()) << "Map key not found";
+            return it->second;
+        }
+
+        // Same as above, but returns a non-const reference.
+        template<class Collection>
+        typename Collection::value_type::second_type&
+            FindOrDieNoPrint(Collection& collection,  // NOLINT
+                             const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::iterator it = collection.find(key);
+            GOOGLE_CHECK(it != collection.end()) << "Map key not found";
+            return it->second;
+        }
+
+        // Returns a const reference to the value associated with the given key if it
+        // exists, otherwise returns a const reference to the provided default value.
+        //
+        // WARNING: If a temporary object is passed as the default "value,"
+        // this function will return a reference to that temporary object,
+        // which will be destroyed at the end of the statement. A common
+        // example: if you have a map with string values, and you pass a char*
+        // as the default "value," either use the returned value immediately
+        // or store it in a string (not string&).
+        // Details: http://go/findwithdefault
+        template<class Collection>
+        const typename Collection::value_type::second_type&
+            FindWithDefault(const Collection& collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value)
+        {
+            typename Collection::const_iterator it = collection.find(key);
+            if (it == collection.end())
+            {
+                return value;
+            }
+            return it->second;
+        }
+
+        // Returns a pointer to the const value associated with the given key if it
+        // exists, or nullptr otherwise.
+        template<class Collection>
+        const typename Collection::value_type::second_type*
+            FindOrNull(const Collection& collection, const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::const_iterator it = collection.find(key);
+            if (it == collection.end())
+            {
+                return 0;
+            }
+            return &it->second;
+        }
+
+        // Same as above but returns a pointer to the non-const value.
+        template<class Collection>
+        typename Collection::value_type::second_type*
+            FindOrNull(Collection& collection,  // NOLINT
+                       const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::iterator it = collection.find(key);
+            if (it == collection.end())
+            {
+                return 0;
+            }
+            return &it->second;
+        }
+
+        // Returns the pointer value associated with the given key. If none is found,
+        // nullptr is returned. The function is designed to be used with a map of keys to
+        // pointers.
+        //
+        // This function does not distinguish between a missing key and a key mapped
+        // to nullptr.
+        template<class Collection>
+        typename Collection::value_type::second_type
+            FindPtrOrNull(const Collection& collection, const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::const_iterator it = collection.find(key);
+            if (it == collection.end())
+            {
+                return typename Collection::value_type::second_type();
+            }
+            return it->second;
+        }
+
+        // Same as above, except takes non-const reference to collection.
+        //
+        // This function is needed for containers that propagate constness to the
+        // pointee, such as boost::ptr_map.
+        template<class Collection>
+        typename Collection::value_type::second_type
+            FindPtrOrNull(Collection& collection,  // NOLINT
+                          const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::iterator it = collection.find(key);
+            if (it == collection.end())
+            {
+                return typename Collection::value_type::second_type();
+            }
+            return it->second;
+        }
+
+        // Finds the pointer value associated with the given key in a map whose values
+        // are linked_ptrs. Returns nullptr if key is not found.
+        template<class Collection>
+        typename Collection::value_type::second_type::element_type*
+            FindLinkedPtrOrNull(const Collection& collection, const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::const_iterator it = collection.find(key);
+            if (it == collection.end())
+            {
+                return 0;
+            }
+            // Since linked_ptr::get() is a const member returning a non const,
+            // we do not need a version of this function taking a non const collection.
+            return it->second.get();
+        }
+
+        // Same as above, but dies if the key is not found.
+        template<class Collection>
+        typename Collection::value_type::second_type::element_type&
+            FindLinkedPtrOrDie(const Collection& collection, const typename Collection::value_type::first_type& key)
+        {
+            typename Collection::const_iterator it = collection.find(key);
+            GOOGLE_CHECK(it != collection.end()) << "key not found: " << key;
+            // Since linked_ptr::operator*() is a const member returning a non const,
+            // we do not need a version of this function taking a non const collection.
+            return *it->second;
+        }
+
+        // Finds the value associated with the given key and copies it to *value (if not
+        // nullptr). Returns false if the key was not found, true otherwise.
+        template<class Collection, class Key, class Value>
+        bool FindCopy(const Collection& collection, const Key& key, Value* const value)
+        {
+            typename Collection::const_iterator it = collection.find(key);
+            if (it == collection.end())
+            {
+                return false;
+            }
+            if (value)
+            {
+                *value = it->second;
+            }
+            return true;
+        }
+
+        //
+        // Contains*()
+        //
+
+        // Returns true if and only if the given collection contains the given key.
+        template<class Collection, class Key>
+        bool ContainsKey(const Collection& collection, const Key& key)
+        {
+            return collection.find(key) != collection.end();
+        }
+
+        // Returns true if and only if the given collection contains the given key-value
+        // pair.
+        template<class Collection, class Key, class Value>
+        bool ContainsKeyValuePair(const Collection& collection, const Key& key, const Value& value)
+        {
+            typedef typename Collection::const_iterator const_iterator;
+            std::pair<const_iterator, const_iterator> range = collection.equal_range(key);
+            for (const_iterator it = range.first; it != range.second; ++it)
+            {
+                if (it->second == value)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        //
+        // Insert*()
+        //
+
+        // Inserts the given key-value pair into the collection. Returns true if and
+        // only if the key from the given pair didn't previously exist. Otherwise, the
+        // value in the map is replaced with the value from the given pair.
+        template<class Collection>
+        bool InsertOrUpdate(Collection* const collection, const typename Collection::value_type& vt)
+        {
+            std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
+            if (!ret.second)
+            {
+                // update
+                ret.first->second = vt.second;
+                return false;
+            }
+            return true;
+        }
+
+        // Same as above, except that the key and value are passed separately.
+        template<class Collection>
+        bool InsertOrUpdate(Collection* const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value)
+        {
+            return InsertOrUpdate(
+                collection, typename Collection::value_type(key, value)
+            );
+        }
+
+        // Inserts/updates all the key-value pairs from the range defined by the
+        // iterators "first" and "last" into the given collection.
+        template<class Collection, class InputIterator>
+        void InsertOrUpdateMany(Collection* const collection, InputIterator first, InputIterator last)
+        {
+            for (; first != last; ++first)
+            {
+                InsertOrUpdate(collection, *first);
+            }
+        }
+
+        // Change the value associated with a particular key in a map or hash_map
+        // of the form map<Key, Value*> which owns the objects pointed to by the
+        // value pointers.  If there was an existing value for the key, it is deleted.
+        // True indicates an insert took place, false indicates an update + delete.
+        template<class Collection>
+        bool InsertAndDeleteExisting(
+            Collection* const collection,
+            const typename Collection::value_type::first_type& key,
+            const typename Collection::value_type::second_type& value
+        )
+        {
+            std::pair<typename Collection::iterator, bool> ret =
+                collection->insert(typename Collection::value_type(key, value));
+            if (!ret.second)
+            {
+                delete ret.first->second;
+                ret.first->second = value;
+                return false;
+            }
+            return true;
+        }
+
+        // Inserts the given key and value into the given collection if and only if the
+        // given key did NOT already exist in the collection. If the key previously
+        // existed in the collection, the value is not changed. Returns true if the
+        // key-value pair was inserted; returns false if the key was already present.
+        template<class Collection>
+        bool InsertIfNotPresent(Collection* const collection, const typename Collection::value_type& vt)
+        {
+            return collection->insert(vt).second;
+        }
+
+        // Same as above except the key and value are passed separately.
+        template<class Collection>
+        bool InsertIfNotPresent(
+            Collection* const collection,
+            const typename Collection::value_type::first_type& key,
+            const typename Collection::value_type::second_type& value
+        )
+        {
+            return InsertIfNotPresent(
+                collection, typename Collection::value_type(key, value)
+            );
+        }
+
+        // Same as above except dies if the key already exists in the collection.
+        template<class Collection>
+        void InsertOrDie(Collection* const collection, const typename Collection::value_type& value)
+        {
+            GOOGLE_CHECK(InsertIfNotPresent(collection, value))
+                << "duplicate value: " << value;
+        }
+
+        // Same as above except doesn't log the value on error.
+        template<class Collection>
+        void InsertOrDieNoPrint(Collection* const collection, const typename Collection::value_type& value)
+        {
+            GOOGLE_CHECK(InsertIfNotPresent(collection, value)) << "duplicate value.";
+        }
+
+        // Inserts the key-value pair into the collection. Dies if key was already
+        // present.
+        template<class Collection>
+        void InsertOrDie(Collection* const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& data)
+        {
+            GOOGLE_CHECK(InsertIfNotPresent(collection, key, data))
+                << "duplicate key: " << key;
+        }
+
+        // Same as above except doesn't log the key on error.
+        template<class Collection>
+        void InsertOrDieNoPrint(
+            Collection* const collection,
+            const typename Collection::value_type::first_type& key,
+            const typename Collection::value_type::second_type& data
+        )
+        {
+            GOOGLE_CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key.";
+        }
+
+        // Inserts a new key and default-initialized value. Dies if the key was already
+        // present. Returns a reference to the value. Example usage:
+        //
+        // map<int, SomeProto> m;
+        // SomeProto& proto = InsertKeyOrDie(&m, 3);
+        // proto.set_field("foo");
+        template<class Collection>
+        typename Collection::value_type::second_type& InsertKeyOrDie(
+            Collection* const collection,
+            const typename Collection::value_type::first_type& key
+        )
+        {
+            typedef typename Collection::value_type value_type;
+            std::pair<typename Collection::iterator, bool> res =
+                collection->insert(value_type(key, typename value_type::second_type()));
+            GOOGLE_CHECK(res.second) << "duplicate key: " << key;
+            return res.first->second;
+        }
+
+        //
+        // Lookup*()
+        //
+
+        // Looks up a given key and value pair in a collection and inserts the key-value
+        // pair if it's not already present. Returns a reference to the value associated
+        // with the key.
+        template<class Collection>
+        typename Collection::value_type::second_type&
+            LookupOrInsert(Collection* const collection, const typename Collection::value_type& vt)
+        {
+            return collection->insert(vt).first->second;
+        }
+
+        // Same as above except the key-value are passed separately.
+        template<class Collection>
+        typename Collection::value_type::second_type&
+            LookupOrInsert(Collection* const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value)
+        {
+            return LookupOrInsert(
+                collection, typename Collection::value_type(key, value)
+            );
+        }
+
+        // Counts the number of equivalent elements in the given "sequence", and stores
+        // the results in "count_map" with element as the key and count as the value.
+        //
+        // Example:
+        //   vector<string> v = {"a", "b", "c", "a", "b"};
+        //   map<string, int> m;
+        //   AddTokenCounts(v, 1, &m);
+        //   assert(m["a"] == 2);
+        //   assert(m["b"] == 2);
+        //   assert(m["c"] == 1);
+        template<typename Sequence, typename Collection>
+        void AddTokenCounts(
+            const Sequence& sequence,
+            const typename Collection::value_type::second_type& increment,
+            Collection* const count_map
+        )
+        {
+            for (typename Sequence::const_iterator it = sequence.begin();
+                 it != sequence.end();
+                 ++it)
+            {
+                typename Collection::value_type::second_type& value =
+                    LookupOrInsert(count_map, *it, typename Collection::value_type::second_type());
+                value += increment;
+            }
+        }
+
+        // Returns a reference to the value associated with key. If not found, a value
+        // is default constructed on the heap and added to the map.
+        //
+        // This function is useful for containers of the form map<Key, Value*>, where
+        // inserting a new key, value pair involves constructing a new heap-allocated
+        // Value, and storing a pointer to that in the collection.
+        template<class Collection>
+        typename Collection::value_type::second_type&
+            LookupOrInsertNew(Collection* const collection, const typename Collection::value_type::first_type& key)
+        {
+            typedef typename std::iterator_traits<
+                typename Collection::value_type::second_type>::value_type Element;
+            std::pair<typename Collection::iterator, bool> ret =
+                collection->insert(typename Collection::value_type(
+                    key,
+                    static_cast<typename Collection::value_type::second_type>(nullptr)
+                ));
+            if (ret.second)
+            {
+                ret.first->second = new Element();
+            }
+            return ret.first->second;
+        }
+
+        // Same as above but constructs the value using the single-argument constructor
+        // and the given "arg".
+        template<class Collection, class Arg>
+        typename Collection::value_type::second_type&
+            LookupOrInsertNew(Collection* const collection, const typename Collection::value_type::first_type& key, const Arg& arg)
+        {
+            typedef typename std::iterator_traits<
+                typename Collection::value_type::second_type>::value_type Element;
+            std::pair<typename Collection::iterator, bool> ret =
+                collection->insert(typename Collection::value_type(
+                    key,
+                    static_cast<typename Collection::value_type::second_type>(nullptr)
+                ));
+            if (ret.second)
+            {
+                ret.first->second = new Element(arg);
+            }
+            return ret.first->second;
+        }
+
+        // Lookup of linked/shared pointers is used in two scenarios:
+        //
+        // Use LookupOrInsertNewLinkedPtr if the container owns the elements.
+        // In this case it is fine working with the raw pointer as long as it is
+        // guaranteed that no other thread can delete/update an accessed element.
+        // A mutex will need to lock the container operation as well as the use
+        // of the returned elements. Finding an element may be performed using
+        // FindLinkedPtr*().
+        //
+        // Use LookupOrInsertNewSharedPtr if the container does not own the elements
+        // for their whole lifetime. This is typically the case when a reader allows
+        // parallel updates to the container. In this case a Mutex only needs to lock
+        // container operations, but all element operations must be performed on the
+        // shared pointer. Finding an element must be performed using FindPtr*() and
+        // cannot be done with FindLinkedPtr*() even though it compiles.
+
+        // Lookup a key in a map or hash_map whose values are linked_ptrs.  If it is
+        // missing, set collection[key].reset(new Value::element_type) and return that.
+        // Value::element_type must be default constructable.
+        template<class Collection>
+        typename Collection::value_type::second_type::element_type*
+            LookupOrInsertNewLinkedPtr(
+                Collection* const collection,
+                const typename Collection::value_type::first_type& key
+            )
+        {
+            typedef typename Collection::value_type::second_type Value;
+            std::pair<typename Collection::iterator, bool> ret =
+                collection->insert(typename Collection::value_type(key, Value()));
+            if (ret.second)
+            {
+                ret.first->second.reset(new typename Value::element_type);
+            }
+            return ret.first->second.get();
+        }
+
+        // A variant of LookupOrInsertNewLinkedPtr where the value is constructed using
+        // a single-parameter constructor.  Note: the constructor argument is computed
+        // even if it will not be used, so only values cheap to compute should be passed
+        // here.  On the other hand it does not matter how expensive the construction of
+        // the actual stored value is, as that only occurs if necessary.
+        template<class Collection, class Arg>
+        typename Collection::value_type::second_type::element_type*
+            LookupOrInsertNewLinkedPtr(
+                Collection* const collection,
                 const typename Collection::value_type::first_type& key,
-                const typename Collection::value_type::second_type& value) {
-  typename Collection::const_iterator it = collection.find(key);
-  if (it == collection.end()) {
-    return value;
-  }
-  return it->second;
-}
-
-// Returns a pointer to the const value associated with the given key if it
-// exists, or nullptr otherwise.
-template <class Collection>
-const typename Collection::value_type::second_type*
-FindOrNull(const Collection& collection,
-           const typename Collection::value_type::first_type& key) {
-  typename Collection::const_iterator it = collection.find(key);
-  if (it == collection.end()) {
-    return 0;
-  }
-  return &it->second;
-}
-
-// Same as above but returns a pointer to the non-const value.
-template <class Collection>
-typename Collection::value_type::second_type*
-FindOrNull(Collection& collection,  // NOLINT
-           const typename Collection::value_type::first_type& key) {
-  typename Collection::iterator it = collection.find(key);
-  if (it == collection.end()) {
-    return 0;
-  }
-  return &it->second;
-}
-
-// Returns the pointer value associated with the given key. If none is found,
-// nullptr is returned. The function is designed to be used with a map of keys to
-// pointers.
-//
-// This function does not distinguish between a missing key and a key mapped
-// to nullptr.
-template <class Collection>
-typename Collection::value_type::second_type
-FindPtrOrNull(const Collection& collection,
-              const typename Collection::value_type::first_type& key) {
-  typename Collection::const_iterator it = collection.find(key);
-  if (it == collection.end()) {
-    return typename Collection::value_type::second_type();
-  }
-  return it->second;
-}
-
-// Same as above, except takes non-const reference to collection.
-//
-// This function is needed for containers that propagate constness to the
-// pointee, such as boost::ptr_map.
-template <class Collection>
-typename Collection::value_type::second_type
-FindPtrOrNull(Collection& collection,  // NOLINT
-              const typename Collection::value_type::first_type& key) {
-  typename Collection::iterator it = collection.find(key);
-  if (it == collection.end()) {
-    return typename Collection::value_type::second_type();
-  }
-  return it->second;
-}
-
-// Finds the pointer value associated with the given key in a map whose values
-// are linked_ptrs. Returns nullptr if key is not found.
-template <class Collection>
-typename Collection::value_type::second_type::element_type*
-FindLinkedPtrOrNull(const Collection& collection,
-                    const typename Collection::value_type::first_type& key) {
-  typename Collection::const_iterator it = collection.find(key);
-  if (it == collection.end()) {
-    return 0;
-  }
-  // Since linked_ptr::get() is a const member returning a non const,
-  // we do not need a version of this function taking a non const collection.
-  return it->second.get();
-}
-
-// Same as above, but dies if the key is not found.
-template <class Collection>
-typename Collection::value_type::second_type::element_type&
-FindLinkedPtrOrDie(const Collection& collection,
-                   const typename Collection::value_type::first_type& key) {
-  typename Collection::const_iterator it = collection.find(key);
-  GOOGLE_CHECK(it != collection.end()) <<  "key not found: " << key;
-  // Since linked_ptr::operator*() is a const member returning a non const,
-  // we do not need a version of this function taking a non const collection.
-  return *it->second;
-}
-
-// Finds the value associated with the given key and copies it to *value (if not
-// nullptr). Returns false if the key was not found, true otherwise.
-template <class Collection, class Key, class Value>
-bool FindCopy(const Collection& collection,
-              const Key& key,
-              Value* const value) {
-  typename Collection::const_iterator it = collection.find(key);
-  if (it == collection.end()) {
-    return false;
-  }
-  if (value) {
-    *value = it->second;
-  }
-  return true;
-}
-
-//
-// Contains*()
-//
-
-// Returns true if and only if the given collection contains the given key.
-template <class Collection, class Key>
-bool ContainsKey(const Collection& collection, const Key& key) {
-  return collection.find(key) != collection.end();
-}
-
-// Returns true if and only if the given collection contains the given key-value
-// pair.
-template <class Collection, class Key, class Value>
-bool ContainsKeyValuePair(const Collection& collection,
-                          const Key& key,
-                          const Value& value) {
-  typedef typename Collection::const_iterator const_iterator;
-  std::pair<const_iterator, const_iterator> range = collection.equal_range(key);
-  for (const_iterator it = range.first; it != range.second; ++it) {
-    if (it->second == value) {
-      return true;
-    }
-  }
-  return false;
-}
-
-//
-// Insert*()
-//
-
-// Inserts the given key-value pair into the collection. Returns true if and
-// only if the key from the given pair didn't previously exist. Otherwise, the
-// value in the map is replaced with the value from the given pair.
-template <class Collection>
-bool InsertOrUpdate(Collection* const collection,
-                    const typename Collection::value_type& vt) {
-  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
-  if (!ret.second) {
-    // update
-    ret.first->second = vt.second;
-    return false;
-  }
-  return true;
-}
-
-// Same as above, except that the key and value are passed separately.
-template <class Collection>
-bool InsertOrUpdate(Collection* const collection,
-                    const typename Collection::value_type::first_type& key,
-                    const typename Collection::value_type::second_type& value) {
-  return InsertOrUpdate(
-      collection, typename Collection::value_type(key, value));
-}
-
-// Inserts/updates all the key-value pairs from the range defined by the
-// iterators "first" and "last" into the given collection.
-template <class Collection, class InputIterator>
-void InsertOrUpdateMany(Collection* const collection,
-                        InputIterator first, InputIterator last) {
-  for (; first != last; ++first) {
-    InsertOrUpdate(collection, *first);
-  }
-}
-
-// Change the value associated with a particular key in a map or hash_map
-// of the form map<Key, Value*> which owns the objects pointed to by the
-// value pointers.  If there was an existing value for the key, it is deleted.
-// True indicates an insert took place, false indicates an update + delete.
-template <class Collection>
-bool InsertAndDeleteExisting(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key,
-    const typename Collection::value_type::second_type& value) {
-  std::pair<typename Collection::iterator, bool> ret =
-      collection->insert(typename Collection::value_type(key, value));
-  if (!ret.second) {
-    delete ret.first->second;
-    ret.first->second = value;
-    return false;
-  }
-  return true;
-}
-
-// Inserts the given key and value into the given collection if and only if the
-// given key did NOT already exist in the collection. If the key previously
-// existed in the collection, the value is not changed. Returns true if the
-// key-value pair was inserted; returns false if the key was already present.
-template <class Collection>
-bool InsertIfNotPresent(Collection* const collection,
-                        const typename Collection::value_type& vt) {
-  return collection->insert(vt).second;
-}
-
-// Same as above except the key and value are passed separately.
-template <class Collection>
-bool InsertIfNotPresent(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key,
-    const typename Collection::value_type::second_type& value) {
-  return InsertIfNotPresent(
-      collection, typename Collection::value_type(key, value));
-}
-
-// Same as above except dies if the key already exists in the collection.
-template <class Collection>
-void InsertOrDie(Collection* const collection,
-                 const typename Collection::value_type& value) {
-  GOOGLE_CHECK(InsertIfNotPresent(collection, value))
-      << "duplicate value: " << value;
-}
-
-// Same as above except doesn't log the value on error.
-template <class Collection>
-void InsertOrDieNoPrint(Collection* const collection,
-                        const typename Collection::value_type& value) {
-  GOOGLE_CHECK(InsertIfNotPresent(collection, value)) << "duplicate value.";
-}
-
-// Inserts the key-value pair into the collection. Dies if key was already
-// present.
-template <class Collection>
-void InsertOrDie(Collection* const collection,
-                 const typename Collection::value_type::first_type& key,
-                 const typename Collection::value_type::second_type& data) {
-  GOOGLE_CHECK(InsertIfNotPresent(collection, key, data))
-      << "duplicate key: " << key;
-}
-
-// Same as above except doesn't log the key on error.
-template <class Collection>
-void InsertOrDieNoPrint(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key,
-    const typename Collection::value_type::second_type& data) {
-  GOOGLE_CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key.";
-}
-
-// Inserts a new key and default-initialized value. Dies if the key was already
-// present. Returns a reference to the value. Example usage:
-//
-// map<int, SomeProto> m;
-// SomeProto& proto = InsertKeyOrDie(&m, 3);
-// proto.set_field("foo");
-template <class Collection>
-typename Collection::value_type::second_type& InsertKeyOrDie(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key) {
-  typedef typename Collection::value_type value_type;
-  std::pair<typename Collection::iterator, bool> res =
-      collection->insert(value_type(key, typename value_type::second_type()));
-  GOOGLE_CHECK(res.second) << "duplicate key: " << key;
-  return res.first->second;
-}
-
-//
-// Lookup*()
-//
-
-// Looks up a given key and value pair in a collection and inserts the key-value
-// pair if it's not already present. Returns a reference to the value associated
-// with the key.
-template <class Collection>
-typename Collection::value_type::second_type&
-LookupOrInsert(Collection* const collection,
-               const typename Collection::value_type& vt) {
-  return collection->insert(vt).first->second;
-}
-
-// Same as above except the key-value are passed separately.
-template <class Collection>
-typename Collection::value_type::second_type&
-LookupOrInsert(Collection* const collection,
-               const typename Collection::value_type::first_type& key,
-               const typename Collection::value_type::second_type& value) {
-  return LookupOrInsert(
-      collection, typename Collection::value_type(key, value));
-}
-
-// Counts the number of equivalent elements in the given "sequence", and stores
-// the results in "count_map" with element as the key and count as the value.
-//
-// Example:
-//   vector<string> v = {"a", "b", "c", "a", "b"};
-//   map<string, int> m;
-//   AddTokenCounts(v, 1, &m);
-//   assert(m["a"] == 2);
-//   assert(m["b"] == 2);
-//   assert(m["c"] == 1);
-template <typename Sequence, typename Collection>
-void AddTokenCounts(
-    const Sequence& sequence,
-    const typename Collection::value_type::second_type& increment,
-    Collection* const count_map) {
-  for (typename Sequence::const_iterator it = sequence.begin();
-       it != sequence.end(); ++it) {
-    typename Collection::value_type::second_type& value =
-        LookupOrInsert(count_map, *it,
-                       typename Collection::value_type::second_type());
-    value += increment;
-  }
-}
-
-// Returns a reference to the value associated with key. If not found, a value
-// is default constructed on the heap and added to the map.
-//
-// This function is useful for containers of the form map<Key, Value*>, where
-// inserting a new key, value pair involves constructing a new heap-allocated
-// Value, and storing a pointer to that in the collection.
-template <class Collection>
-typename Collection::value_type::second_type&
-LookupOrInsertNew(Collection* const collection,
-                  const typename Collection::value_type::first_type& key) {
-  typedef typename std::iterator_traits<
-    typename Collection::value_type::second_type>::value_type Element;
-  std::pair<typename Collection::iterator, bool> ret =
-      collection->insert(typename Collection::value_type(
-          key,
-          static_cast<typename Collection::value_type::second_type>(nullptr)));
-  if (ret.second) {
-    ret.first->second = new Element();
-  }
-  return ret.first->second;
-}
-
-// Same as above but constructs the value using the single-argument constructor
-// and the given "arg".
-template <class Collection, class Arg>
-typename Collection::value_type::second_type&
-LookupOrInsertNew(Collection* const collection,
-                  const typename Collection::value_type::first_type& key,
-                  const Arg& arg) {
-  typedef typename std::iterator_traits<
-    typename Collection::value_type::second_type>::value_type Element;
-  std::pair<typename Collection::iterator, bool> ret =
-      collection->insert(typename Collection::value_type(
-          key,
-          static_cast<typename Collection::value_type::second_type>(nullptr)));
-  if (ret.second) {
-    ret.first->second = new Element(arg);
-  }
-  return ret.first->second;
-}
-
-// Lookup of linked/shared pointers is used in two scenarios:
-//
-// Use LookupOrInsertNewLinkedPtr if the container owns the elements.
-// In this case it is fine working with the raw pointer as long as it is
-// guaranteed that no other thread can delete/update an accessed element.
-// A mutex will need to lock the container operation as well as the use
-// of the returned elements. Finding an element may be performed using
-// FindLinkedPtr*().
-//
-// Use LookupOrInsertNewSharedPtr if the container does not own the elements
-// for their whole lifetime. This is typically the case when a reader allows
-// parallel updates to the container. In this case a Mutex only needs to lock
-// container operations, but all element operations must be performed on the
-// shared pointer. Finding an element must be performed using FindPtr*() and
-// cannot be done with FindLinkedPtr*() even though it compiles.
-
-// Lookup a key in a map or hash_map whose values are linked_ptrs.  If it is
-// missing, set collection[key].reset(new Value::element_type) and return that.
-// Value::element_type must be default constructable.
-template <class Collection>
-typename Collection::value_type::second_type::element_type*
-LookupOrInsertNewLinkedPtr(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key) {
-  typedef typename Collection::value_type::second_type Value;
-  std::pair<typename Collection::iterator, bool> ret =
-      collection->insert(typename Collection::value_type(key, Value()));
-  if (ret.second) {
-    ret.first->second.reset(new typename Value::element_type);
-  }
-  return ret.first->second.get();
-}
-
-// A variant of LookupOrInsertNewLinkedPtr where the value is constructed using
-// a single-parameter constructor.  Note: the constructor argument is computed
-// even if it will not be used, so only values cheap to compute should be passed
-// here.  On the other hand it does not matter how expensive the construction of
-// the actual stored value is, as that only occurs if necessary.
-template <class Collection, class Arg>
-typename Collection::value_type::second_type::element_type*
-LookupOrInsertNewLinkedPtr(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key,
-    const Arg& arg) {
-  typedef typename Collection::value_type::second_type Value;
-  std::pair<typename Collection::iterator, bool> ret =
-      collection->insert(typename Collection::value_type(key, Value()));
-  if (ret.second) {
-    ret.first->second.reset(new typename Value::element_type(arg));
-  }
-  return ret.first->second.get();
-}
-
-// Lookup a key in a map or hash_map whose values are shared_ptrs.  If it is
-// missing, set collection[key].reset(new Value::element_type). Unlike
-// LookupOrInsertNewLinkedPtr, this function returns the shared_ptr instead of
-// the raw pointer. Value::element_type must be default constructable.
-template <class Collection>
-typename Collection::value_type::second_type&
-LookupOrInsertNewSharedPtr(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key) {
-  typedef typename Collection::value_type::second_type SharedPtr;
-  typedef typename Collection::value_type::second_type::element_type Element;
-  std::pair<typename Collection::iterator, bool> ret =
-      collection->insert(typename Collection::value_type(key, SharedPtr()));
-  if (ret.second) {
-    ret.first->second.reset(new Element());
-  }
-  return ret.first->second;
-}
-
-// A variant of LookupOrInsertNewSharedPtr where the value is constructed using
-// a single-parameter constructor.  Note: the constructor argument is computed
-// even if it will not be used, so only values cheap to compute should be passed
-// here.  On the other hand it does not matter how expensive the construction of
-// the actual stored value is, as that only occurs if necessary.
-template <class Collection, class Arg>
-typename Collection::value_type::second_type&
-LookupOrInsertNewSharedPtr(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key,
-    const Arg& arg) {
-  typedef typename Collection::value_type::second_type SharedPtr;
-  typedef typename Collection::value_type::second_type::element_type Element;
-  std::pair<typename Collection::iterator, bool> ret =
-      collection->insert(typename Collection::value_type(key, SharedPtr()));
-  if (ret.second) {
-    ret.first->second.reset(new Element(arg));
-  }
-  return ret.first->second;
-}
-
-//
-// Misc Utility Functions
-//
-
-// Updates the value associated with the given key. If the key was not already
-// present, then the key-value pair are inserted and "previous" is unchanged. If
-// the key was already present, the value is updated and "*previous" will
-// contain a copy of the old value.
-//
-// InsertOrReturnExisting has complementary behavior that returns the
-// address of an already existing value, rather than updating it.
-template <class Collection>
-bool UpdateReturnCopy(Collection* const collection,
-                      const typename Collection::value_type::first_type& key,
-                      const typename Collection::value_type::second_type& value,
-                      typename Collection::value_type::second_type* previous) {
-  std::pair<typename Collection::iterator, bool> ret =
-      collection->insert(typename Collection::value_type(key, value));
-  if (!ret.second) {
-    // update
-    if (previous) {
-      *previous = ret.first->second;
-    }
-    ret.first->second = value;
-    return true;
-  }
-  return false;
-}
-
-// Same as above except that the key and value are passed as a pair.
-template <class Collection>
-bool UpdateReturnCopy(Collection* const collection,
-                      const typename Collection::value_type& vt,
-                      typename Collection::value_type::second_type* previous) {
-  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
-  if (!ret.second) {
-    // update
-    if (previous) {
-      *previous = ret.first->second;
-    }
-    ret.first->second = vt.second;
-    return true;
-  }
-  return false;
-}
-
-// Tries to insert the given key-value pair into the collection. Returns nullptr if
-// the insert succeeds. Otherwise, returns a pointer to the existing value.
-//
-// This complements UpdateReturnCopy in that it allows to update only after
-// verifying the old value and still insert quickly without having to look up
-// twice. Unlike UpdateReturnCopy this also does not come with the issue of an
-// undefined previous* in case new data was inserted.
-template <class Collection>
-typename Collection::value_type::second_type* InsertOrReturnExisting(
-    Collection* const collection, const typename Collection::value_type& vt) {
-  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
-  if (ret.second) {
-    return nullptr;  // Inserted, no existing previous value.
-  } else {
-    return &ret.first->second;  // Return address of already existing value.
-  }
-}
-
-// Same as above, except for explicit key and data.
-template <class Collection>
-typename Collection::value_type::second_type* InsertOrReturnExisting(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key,
-    const typename Collection::value_type::second_type& data) {
-  return InsertOrReturnExisting(collection,
-                                typename Collection::value_type(key, data));
-}
-
-// Erases the collection item identified by the given key, and returns the value
-// associated with that key. It is assumed that the value (i.e., the
-// mapped_type) is a pointer. Returns nullptr if the key was not found in the
-// collection.
-//
-// Examples:
-//   map<string, MyType*> my_map;
-//
-// One line cleanup:
-//     delete EraseKeyReturnValuePtr(&my_map, "abc");
-//
-// Use returned value:
-//     std::unique_ptr<MyType> value_ptr(
-//         EraseKeyReturnValuePtr(&my_map, "abc"));
-//     if (value_ptr.get())
-//       value_ptr->DoSomething();
-//
-template <class Collection>
-typename Collection::value_type::second_type EraseKeyReturnValuePtr(
-    Collection* const collection,
-    const typename Collection::value_type::first_type& key) {
-  typename Collection::iterator it = collection->find(key);
-  if (it == collection->end()) {
-    return nullptr;
-  }
-  typename Collection::value_type::second_type v = it->second;
-  collection->erase(it);
-  return v;
-}
-
-// Inserts all the keys from map_container into key_container, which must
-// support insert(MapContainer::key_type).
-//
-// Note: any initial contents of the key_container are not cleared.
-template <class MapContainer, class KeyContainer>
-void InsertKeysFromMap(const MapContainer& map_container,
-                       KeyContainer* key_container) {
-  GOOGLE_CHECK(key_container != nullptr);
-  for (typename MapContainer::const_iterator it = map_container.begin();
-       it != map_container.end(); ++it) {
-    key_container->insert(it->first);
-  }
-}
-
-// Appends all the keys from map_container into key_container, which must
-// support push_back(MapContainer::key_type).
-//
-// Note: any initial contents of the key_container are not cleared.
-template <class MapContainer, class KeyContainer>
-void AppendKeysFromMap(const MapContainer& map_container,
-                       KeyContainer* key_container) {
-  GOOGLE_CHECK(key_container != nullptr);
-  for (typename MapContainer::const_iterator it = map_container.begin();
-       it != map_container.end(); ++it) {
-    key_container->push_back(it->first);
-  }
-}
-
-// A more specialized overload of AppendKeysFromMap to optimize reallocations
-// for the common case in which we're appending keys to a vector and hence can
-// (and sometimes should) call reserve() first.
-//
-// (It would be possible to play SFINAE games to call reserve() for any
-// container that supports it, but this seems to get us 99% of what we need
-// without the complexity of a SFINAE-based solution.)
-template <class MapContainer, class KeyType>
-void AppendKeysFromMap(const MapContainer& map_container,
-                       std::vector<KeyType>* key_container) {
-  GOOGLE_CHECK(key_container != nullptr);
-  // We now have the opportunity to call reserve(). Calling reserve() every
-  // time is a bad idea for some use cases: libstdc++'s implementation of
-  // vector<>::reserve() resizes the vector's backing store to exactly the
-  // given size (unless it's already at least that big). Because of this,
-  // the use case that involves appending a lot of small maps (total size
-  // N) one by one to a vector would be O(N^2). But never calling reserve()
-  // loses the opportunity to improve the use case of adding from a large
-  // map to an empty vector (this improves performance by up to 33%). A
-  // number of heuristics are possible; see the discussion in
-  // cl/34081696. Here we use the simplest one.
-  if (key_container->empty()) {
-    key_container->reserve(map_container.size());
-  }
-  for (typename MapContainer::const_iterator it = map_container.begin();
-       it != map_container.end(); ++it) {
-    key_container->push_back(it->first);
-  }
-}
-
-// Inserts all the values from map_container into value_container, which must
-// support push_back(MapContainer::mapped_type).
-//
-// Note: any initial contents of the value_container are not cleared.
-template <class MapContainer, class ValueContainer>
-void AppendValuesFromMap(const MapContainer& map_container,
-                         ValueContainer* value_container) {
-  GOOGLE_CHECK(value_container != nullptr);
-  for (typename MapContainer::const_iterator it = map_container.begin();
-       it != map_container.end(); ++it) {
-    value_container->push_back(it->second);
-  }
-}
-
-// A more specialized overload of AppendValuesFromMap to optimize reallocations
-// for the common case in which we're appending values to a vector and hence
-// can (and sometimes should) call reserve() first.
-//
-// (It would be possible to play SFINAE games to call reserve() for any
-// container that supports it, but this seems to get us 99% of what we need
-// without the complexity of a SFINAE-based solution.)
-template <class MapContainer, class ValueType>
-void AppendValuesFromMap(const MapContainer& map_container,
-                         std::vector<ValueType>* value_container) {
-  GOOGLE_CHECK(value_container != nullptr);
-  // See AppendKeysFromMap for why this is done.
-  if (value_container->empty()) {
-    value_container->reserve(map_container.size());
-  }
-  for (typename MapContainer::const_iterator it = map_container.begin();
-       it != map_container.end(); ++it) {
-    value_container->push_back(it->second);
-  }
-}
-
-}  // namespace protobuf
+                const Arg& arg
+            )
+        {
+            typedef typename Collection::value_type::second_type Value;
+            std::pair<typename Collection::iterator, bool> ret =
+                collection->insert(typename Collection::value_type(key, Value()));
+            if (ret.second)
+            {
+                ret.first->second.reset(new typename Value::element_type(arg));
+            }
+            return ret.first->second.get();
+        }
+
+        // Lookup a key in a map or hash_map whose values are shared_ptrs.  If it is
+        // missing, set collection[key].reset(new Value::element_type). Unlike
+        // LookupOrInsertNewLinkedPtr, this function returns the shared_ptr instead of
+        // the raw pointer. Value::element_type must be default constructable.
+        template<class Collection>
+        typename Collection::value_type::second_type&
+            LookupOrInsertNewSharedPtr(
+                Collection* const collection,
+                const typename Collection::value_type::first_type& key
+            )
+        {
+            typedef typename Collection::value_type::second_type SharedPtr;
+            typedef typename Collection::value_type::second_type::element_type Element;
+            std::pair<typename Collection::iterator, bool> ret =
+                collection->insert(typename Collection::value_type(key, SharedPtr()));
+            if (ret.second)
+            {
+                ret.first->second.reset(new Element());
+            }
+            return ret.first->second;
+        }
+
+        // A variant of LookupOrInsertNewSharedPtr where the value is constructed using
+        // a single-parameter constructor.  Note: the constructor argument is computed
+        // even if it will not be used, so only values cheap to compute should be passed
+        // here.  On the other hand it does not matter how expensive the construction of
+        // the actual stored value is, as that only occurs if necessary.
+        template<class Collection, class Arg>
+        typename Collection::value_type::second_type&
+            LookupOrInsertNewSharedPtr(
+                Collection* const collection,
+                const typename Collection::value_type::first_type& key,
+                const Arg& arg
+            )
+        {
+            typedef typename Collection::value_type::second_type SharedPtr;
+            typedef typename Collection::value_type::second_type::element_type Element;
+            std::pair<typename Collection::iterator, bool> ret =
+                collection->insert(typename Collection::value_type(key, SharedPtr()));
+            if (ret.second)
+            {
+                ret.first->second.reset(new Element(arg));
+            }
+            return ret.first->second;
+        }
+
+        //
+        // Misc Utility Functions
+        //
+
+        // Updates the value associated with the given key. If the key was not already
+        // present, then the key-value pair are inserted and "previous" is unchanged. If
+        // the key was already present, the value is updated and "*previous" will
+        // contain a copy of the old value.
+        //
+        // InsertOrReturnExisting has complementary behavior that returns the
+        // address of an already existing value, rather than updating it.
+        template<class Collection>
+        bool UpdateReturnCopy(Collection* const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value, typename Collection::value_type::second_type* previous)
+        {
+            std::pair<typename Collection::iterator, bool> ret =
+                collection->insert(typename Collection::value_type(key, value));
+            if (!ret.second)
+            {
+                // update
+                if (previous)
+                {
+                    *previous = ret.first->second;
+                }
+                ret.first->second = value;
+                return true;
+            }
+            return false;
+        }
+
+        // Same as above except that the key and value are passed as a pair.
+        template<class Collection>
+        bool UpdateReturnCopy(Collection* const collection, const typename Collection::value_type& vt, typename Collection::value_type::second_type* previous)
+        {
+            std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
+            if (!ret.second)
+            {
+                // update
+                if (previous)
+                {
+                    *previous = ret.first->second;
+                }
+                ret.first->second = vt.second;
+                return true;
+            }
+            return false;
+        }
+
+        // Tries to insert the given key-value pair into the collection. Returns nullptr if
+        // the insert succeeds. Otherwise, returns a pointer to the existing value.
+        //
+        // This complements UpdateReturnCopy in that it allows to update only after
+        // verifying the old value and still insert quickly without having to look up
+        // twice. Unlike UpdateReturnCopy this also does not come with the issue of an
+        // undefined previous* in case new data was inserted.
+        template<class Collection>
+        typename Collection::value_type::second_type* InsertOrReturnExisting(
+            Collection* const collection, const typename Collection::value_type& vt
+        )
+        {
+            std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
+            if (ret.second)
+            {
+                return nullptr;  // Inserted, no existing previous value.
+            }
+            else
+            {
+                return &ret.first->second;  // Return address of already existing value.
+            }
+        }
+
+        // Same as above, except for explicit key and data.
+        template<class Collection>
+        typename Collection::value_type::second_type* InsertOrReturnExisting(
+            Collection* const collection,
+            const typename Collection::value_type::first_type& key,
+            const typename Collection::value_type::second_type& data
+        )
+        {
+            return InsertOrReturnExisting(collection, typename Collection::value_type(key, data));
+        }
+
+        // Erases the collection item identified by the given key, and returns the value
+        // associated with that key. It is assumed that the value (i.e., the
+        // mapped_type) is a pointer. Returns nullptr if the key was not found in the
+        // collection.
+        //
+        // Examples:
+        //   map<string, MyType*> my_map;
+        //
+        // One line cleanup:
+        //     delete EraseKeyReturnValuePtr(&my_map, "abc");
+        //
+        // Use returned value:
+        //     std::unique_ptr<MyType> value_ptr(
+        //         EraseKeyReturnValuePtr(&my_map, "abc"));
+        //     if (value_ptr.get())
+        //       value_ptr->DoSomething();
+        //
+        template<class Collection>
+        typename Collection::value_type::second_type EraseKeyReturnValuePtr(
+            Collection* const collection,
+            const typename Collection::value_type::first_type& key
+        )
+        {
+            typename Collection::iterator it = collection->find(key);
+            if (it == collection->end())
+            {
+                return nullptr;
+            }
+            typename Collection::value_type::second_type v = it->second;
+            collection->erase(it);
+            return v;
+        }
+
+        // Inserts all the keys from map_container into key_container, which must
+        // support insert(MapContainer::key_type).
+        //
+        // Note: any initial contents of the key_container are not cleared.
+        template<class MapContainer, class KeyContainer>
+        void InsertKeysFromMap(const MapContainer& map_container, KeyContainer* key_container)
+        {
+            GOOGLE_CHECK(key_container != nullptr);
+            for (typename MapContainer::const_iterator it = map_container.begin();
+                 it != map_container.end();
+                 ++it)
+            {
+                key_container->insert(it->first);
+            }
+        }
+
+        // Appends all the keys from map_container into key_container, which must
+        // support push_back(MapContainer::key_type).
+        //
+        // Note: any initial contents of the key_container are not cleared.
+        template<class MapContainer, class KeyContainer>
+        void AppendKeysFromMap(const MapContainer& map_container, KeyContainer* key_container)
+        {
+            GOOGLE_CHECK(key_container != nullptr);
+            for (typename MapContainer::const_iterator it = map_container.begin();
+                 it != map_container.end();
+                 ++it)
+            {
+                key_container->push_back(it->first);
+            }
+        }
+
+        // A more specialized overload of AppendKeysFromMap to optimize reallocations
+        // for the common case in which we're appending keys to a vector and hence can
+        // (and sometimes should) call reserve() first.
+        //
+        // (It would be possible to play SFINAE games to call reserve() for any
+        // container that supports it, but this seems to get us 99% of what we need
+        // without the complexity of a SFINAE-based solution.)
+        template<class MapContainer, class KeyType>
+        void AppendKeysFromMap(const MapContainer& map_container, std::vector<KeyType>* key_container)
+        {
+            GOOGLE_CHECK(key_container != nullptr);
+            // We now have the opportunity to call reserve(). Calling reserve() every
+            // time is a bad idea for some use cases: libstdc++'s implementation of
+            // vector<>::reserve() resizes the vector's backing store to exactly the
+            // given size (unless it's already at least that big). Because of this,
+            // the use case that involves appending a lot of small maps (total size
+            // N) one by one to a vector would be O(N^2). But never calling reserve()
+            // loses the opportunity to improve the use case of adding from a large
+            // map to an empty vector (this improves performance by up to 33%). A
+            // number of heuristics are possible; see the discussion in
+            // cl/34081696. Here we use the simplest one.
+            if (key_container->empty())
+            {
+                key_container->reserve(map_container.size());
+            }
+            for (typename MapContainer::const_iterator it = map_container.begin();
+                 it != map_container.end();
+                 ++it)
+            {
+                key_container->push_back(it->first);
+            }
+        }
+
+        // Inserts all the values from map_container into value_container, which must
+        // support push_back(MapContainer::mapped_type).
+        //
+        // Note: any initial contents of the value_container are not cleared.
+        template<class MapContainer, class ValueContainer>
+        void AppendValuesFromMap(const MapContainer& map_container, ValueContainer* value_container)
+        {
+            GOOGLE_CHECK(value_container != nullptr);
+            for (typename MapContainer::const_iterator it = map_container.begin();
+                 it != map_container.end();
+                 ++it)
+            {
+                value_container->push_back(it->second);
+            }
+        }
+
+        // A more specialized overload of AppendValuesFromMap to optimize reallocations
+        // for the common case in which we're appending values to a vector and hence
+        // can (and sometimes should) call reserve() first.
+        //
+        // (It would be possible to play SFINAE games to call reserve() for any
+        // container that supports it, but this seems to get us 99% of what we need
+        // without the complexity of a SFINAE-based solution.)
+        template<class MapContainer, class ValueType>
+        void AppendValuesFromMap(const MapContainer& map_container, std::vector<ValueType>* value_container)
+        {
+            GOOGLE_CHECK(value_container != nullptr);
+            // See AppendKeysFromMap for why this is done.
+            if (value_container->empty())
+            {
+                value_container->reserve(map_container.size());
+            }
+            for (typename MapContainer::const_iterator it = map_container.begin();
+                 it != map_container.end();
+                 ++it)
+            {
+                value_container->push_back(it->second);
+            }
+        }
+
+    }  // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/mutex.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/mutex.h
index c459991..bc6c6c7 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/mutex.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/mutex.h
@@ -49,9 +49,9 @@
 // Clang.
 #if defined(__clang__) && !defined(SWIG)
 #define GOOGLE_PROTOBUF_ACQUIRE(...) \
-  __attribute__((acquire_capability(__VA_ARGS__)))
+    __attribute__((acquire_capability(__VA_ARGS__)))
 #define GOOGLE_PROTOBUF_RELEASE(...) \
-  __attribute__((release_capability(__VA_ARGS__)))
+    __attribute__((release_capability(__VA_ARGS__)))
 #define GOOGLE_PROTOBUF_SCOPED_CAPABILITY __attribute__((scoped_lockable))
 #define GOOGLE_PROTOBUF_CAPABILITY(x) __attribute__((capability(x)))
 #else
@@ -65,149 +65,219 @@
 
 // ===================================================================
 // emulates google3/base/mutex.h
-namespace google {
-namespace protobuf {
-namespace internal {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
 
 #define GOOGLE_PROTOBUF_LINKER_INITIALIZED
 
 #ifdef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
 
-// This class is a lightweight replacement for std::mutex on Windows platforms.
-// std::mutex does not work on Windows XP SP2 with the latest VC++ libraries,
-// because it utilizes the Concurrency Runtime that is only supported on Windows
-// XP SP3 and above.
-class PROTOBUF_EXPORT CriticalSectionLock {
- public:
-  CriticalSectionLock() { InitializeCriticalSection(&critical_section_); }
-  ~CriticalSectionLock() { DeleteCriticalSection(&critical_section_); }
-  void lock() { EnterCriticalSection(&critical_section_); }
-  void unlock() { LeaveCriticalSection(&critical_section_); }
-
- private:
-  CRITICAL_SECTION critical_section_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CriticalSectionLock);
-};
+            // This class is a lightweight replacement for std::mutex on Windows platforms.
+            // std::mutex does not work on Windows XP SP2 with the latest VC++ libraries,
+            // because it utilizes the Concurrency Runtime that is only supported on Windows
+            // XP SP3 and above.
+            class PROTOBUF_EXPORT CriticalSectionLock
+            {
+            public:
+                CriticalSectionLock()
+                {
+                    InitializeCriticalSection(&critical_section_);
+                }
+                ~CriticalSectionLock()
+                {
+                    DeleteCriticalSection(&critical_section_);
+                }
+                void lock()
+                {
+                    EnterCriticalSection(&critical_section_);
+                }
+                void unlock()
+                {
+                    LeaveCriticalSection(&critical_section_);
+                }
+
+            private:
+                CRITICAL_SECTION critical_section_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CriticalSectionLock);
+            };
 
 #endif
 
-// In MSVC std::mutex does not have a constexpr constructor.
-// This wrapper makes the constructor constexpr.
-template <typename T>
-class CallOnceInitializedMutex {
- public:
-  constexpr CallOnceInitializedMutex() : flag_{}, buf_{} {}
-  ~CallOnceInitializedMutex() { get().~T(); }
-
-  void lock() { get().lock(); }
-  void unlock() { get().unlock(); }
-
- private:
-  T& get() {
-    std::call_once(flag_, [&] { ::new (static_cast<void*>(&buf_)) T(); });
-    return reinterpret_cast<T&>(buf_);
-  }
-
-  std::once_flag flag_;
-  alignas(T) char buf_[sizeof(T)];
-};
-
-// Mutex is a natural type to wrap. As both google and other organization have
-// specialized mutexes. gRPC also provides an injection mechanism for custom
-// mutexes.
-class GOOGLE_PROTOBUF_CAPABILITY("mutex") PROTOBUF_EXPORT WrappedMutex {
- public:
+            // In MSVC std::mutex does not have a constexpr constructor.
+            // This wrapper makes the constructor constexpr.
+            template<typename T>
+            class CallOnceInitializedMutex
+            {
+            public:
+                constexpr CallOnceInitializedMutex() :
+                    flag_{},
+                    buf_{}
+                {
+                }
+                ~CallOnceInitializedMutex()
+                {
+                    get().~T();
+                }
+
+                void lock()
+                {
+                    get().lock();
+                }
+                void unlock()
+                {
+                    get().unlock();
+                }
+
+            private:
+                T& get()
+                {
+                    std::call_once(flag_, [&]
+                                   { ::new (static_cast<void*>(&buf_)) T(); });
+                    return reinterpret_cast<T&>(buf_);
+                }
+
+                std::once_flag flag_;
+                alignas(T) char buf_[sizeof(T)];
+            };
+
+            // Mutex is a natural type to wrap. As both google and other organization have
+            // specialized mutexes. gRPC also provides an injection mechanism for custom
+            // mutexes.
+            class GOOGLE_PROTOBUF_CAPABILITY("mutex") PROTOBUF_EXPORT WrappedMutex
+            {
+            public:
 #if defined(__QNX__)
-  constexpr WrappedMutex() = default;
+                constexpr WrappedMutex() = default;
 #else
-  constexpr WrappedMutex() {}
+                constexpr WrappedMutex()
+                {
+                }
 #endif
-  void Lock() GOOGLE_PROTOBUF_ACQUIRE() { mu_.lock(); }
-  void Unlock() GOOGLE_PROTOBUF_RELEASE() { mu_.unlock(); }
-  // Crash if this Mutex is not held exclusively by this thread.
-  // May fail to crash when it should; will never crash when it should not.
-  void AssertHeld() const {}
-
- private:
+                void Lock() GOOGLE_PROTOBUF_ACQUIRE()
+                {
+                    mu_.lock();
+                }
+                void Unlock() GOOGLE_PROTOBUF_RELEASE()
+                {
+                    mu_.unlock();
+                }
+                // Crash if this Mutex is not held exclusively by this thread.
+                // May fail to crash when it should; will never crash when it should not.
+                void AssertHeld() const
+                {
+                }
+
+            private:
 #if defined(GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP)
-  CallOnceInitializedMutex<CriticalSectionLock> mu_{};
+                CallOnceInitializedMutex<CriticalSectionLock> mu_{};
 #elif defined(_WIN32)
-  CallOnceInitializedMutex<std::mutex> mu_{};
+                CallOnceInitializedMutex<std::mutex> mu_{};
 #else
-  std::mutex mu_{};
+                std::mutex mu_{};
 #endif
-};
-
-using Mutex = WrappedMutex;
-
-// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
-class GOOGLE_PROTOBUF_SCOPED_CAPABILITY PROTOBUF_EXPORT MutexLock {
- public:
-  explicit MutexLock(Mutex* mu) GOOGLE_PROTOBUF_ACQUIRE(mu) : mu_(mu) {
-    this->mu_->Lock();
-  }
-  ~MutexLock() GOOGLE_PROTOBUF_RELEASE() { this->mu_->Unlock(); }
-
- private:
-  Mutex *const mu_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLock);
-};
-
-// TODO(kenton):  Implement these?  Hard to implement portably.
-typedef MutexLock ReaderMutexLock;
-typedef MutexLock WriterMutexLock;
-
-// MutexLockMaybe is like MutexLock, but is a no-op when mu is nullptr.
-class PROTOBUF_EXPORT MutexLockMaybe {
- public:
-  explicit MutexLockMaybe(Mutex *mu) :
-    mu_(mu) { if (this->mu_ != nullptr) { this->mu_->Lock(); } }
-  ~MutexLockMaybe() { if (this->mu_ != nullptr) { this->mu_->Unlock(); } }
- private:
-  Mutex *const mu_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLockMaybe);
-};
+            };
+
+            using Mutex = WrappedMutex;
+
+            // MutexLock(mu) acquires mu when constructed and releases it when destroyed.
+            class GOOGLE_PROTOBUF_SCOPED_CAPABILITY PROTOBUF_EXPORT MutexLock
+            {
+            public:
+                explicit MutexLock(Mutex* mu) GOOGLE_PROTOBUF_ACQUIRE(mu) :
+                    mu_(mu)
+                {
+                    this->mu_->Lock();
+                }
+                ~MutexLock() GOOGLE_PROTOBUF_RELEASE()
+                {
+                    this->mu_->Unlock();
+                }
+
+            private:
+                Mutex* const mu_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLock);
+            };
+
+            // TODO(kenton):  Implement these?  Hard to implement portably.
+            typedef MutexLock ReaderMutexLock;
+            typedef MutexLock WriterMutexLock;
+
+            // MutexLockMaybe is like MutexLock, but is a no-op when mu is nullptr.
+            class PROTOBUF_EXPORT MutexLockMaybe
+            {
+            public:
+                explicit MutexLockMaybe(Mutex* mu) :
+                    mu_(mu)
+                {
+                    if (this->mu_ != nullptr)
+                    {
+                        this->mu_->Lock();
+                    }
+                }
+                ~MutexLockMaybe()
+                {
+                    if (this->mu_ != nullptr)
+                    {
+                        this->mu_->Unlock();
+                    }
+                }
+
+            private:
+                Mutex* const mu_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLockMaybe);
+            };
 
 #if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
-template<typename T>
-class ThreadLocalStorage {
- public:
-  ThreadLocalStorage() {
-    pthread_key_create(&key_, &ThreadLocalStorage::Delete);
-  }
-  ~ThreadLocalStorage() {
-    pthread_key_delete(key_);
-  }
-  T* Get() {
-    T* result = static_cast<T*>(pthread_getspecific(key_));
-    if (result == nullptr) {
-      result = new T();
-      pthread_setspecific(key_, result);
-    }
-    return result;
-  }
- private:
-  static void Delete(void* value) {
-    delete static_cast<T*>(value);
-  }
-  pthread_key_t key_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadLocalStorage);
-};
+            template<typename T>
+            class ThreadLocalStorage
+            {
+            public:
+                ThreadLocalStorage()
+                {
+                    pthread_key_create(&key_, &ThreadLocalStorage::Delete);
+                }
+                ~ThreadLocalStorage()
+                {
+                    pthread_key_delete(key_);
+                }
+                T* Get()
+                {
+                    T* result = static_cast<T*>(pthread_getspecific(key_));
+                    if (result == nullptr)
+                    {
+                        result = new T();
+                        pthread_setspecific(key_, result);
+                    }
+                    return result;
+                }
+
+            private:
+                static void Delete(void* value)
+                {
+                    delete static_cast<T*>(value);
+                }
+                pthread_key_t key_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadLocalStorage);
+            };
 #endif
 
-}  // namespace internal
+        }  // namespace internal
 
-// We made these internal so that they would show up as such in the docs,
-// but we don't want to stick "internal::" in front of them everywhere.
-using internal::Mutex;
-using internal::MutexLock;
-using internal::ReaderMutexLock;
-using internal::WriterMutexLock;
-using internal::MutexLockMaybe;
+        // We made these internal so that they would show up as such in the docs,
+        // but we don't want to stick "internal::" in front of them everywhere.
+        using internal::Mutex;
+        using internal::MutexLock;
+        using internal::MutexLockMaybe;
+        using internal::ReaderMutexLock;
+        using internal::WriterMutexLock;
 
-}  // namespace protobuf
+    }  // namespace protobuf
 }  // namespace google
 
 #undef GOOGLE_PROTOBUF_ACQUIRE
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/once.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/once.h
index 070d36d..9638803 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/once.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/once.h
@@ -36,18 +36,22 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-using once_flag = std::once_flag;
-template <typename... Args>
-void call_once(Args&&... args ) {
-  std::call_once(std::forward<Args>(args)...);
-}
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            using once_flag = std::once_flag;
+            template<typename... Args>
+            void call_once(Args&&... args)
+            {
+                std::call_once(std::forward<Args>(args)...);
+            }
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/platform_macros.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/platform_macros.h
index 2479960..3686ac9 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/platform_macros.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/platform_macros.h
@@ -84,19 +84,19 @@
 #define GOOGLE_PROTOBUF_ARCH_PPC 1
 #define GOOGLE_PROTOBUF_ARCH_32_BIT 1
 #elif defined(__GNUC__)
-# if (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))
+#if (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))
 // We fallback to the generic Clang/GCC >= 4.7 implementation in atomicops.h
-# elif defined(__clang__)
-#  if !__has_extension(c_atomic)
+#elif defined(__clang__)
+#if !__has_extension(c_atomic)
 GOOGLE_PROTOBUF_PLATFORM_ERROR
-#  endif
+#endif
 // We fallback to the generic Clang/GCC >= 4.7 implementation in atomicops.h
-# endif
-# if __LP64__
-#  define GOOGLE_PROTOBUF_ARCH_64_BIT 1
-# else
-#  define GOOGLE_PROTOBUF_ARCH_32_BIT 1
-# endif
+#endif
+#if __LP64__
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#else
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#endif
 #else
 GOOGLE_PROTOBUF_PLATFORM_ERROR
 #endif
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/port.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/port.h
index b074cb1..3045d0c 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/port.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/port.h
@@ -44,13 +44,13 @@
 
 #undef PROTOBUF_LITTLE_ENDIAN
 #ifdef _WIN32
-  // Assuming windows is always little-endian.
-  // TODO(xiaofeng): The PROTOBUF_LITTLE_ENDIAN is not only used for
-  // optimization but also for correctness. We should define an
-  // different macro to test the big-endian code path in coded_stream.
-  #if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
-    #define PROTOBUF_LITTLE_ENDIAN 1
-  #endif
+// Assuming windows is always little-endian.
+// TODO(xiaofeng): The PROTOBUF_LITTLE_ENDIAN is not only used for
+// optimization but also for correctness. We should define an
+// different macro to test the big-endian code path in coded_stream.
+#if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+#define PROTOBUF_LITTLE_ENDIAN 1
+#endif
 #if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
 // If MSVC has "/RTCc" set, it will complain about truncating casts at
 // runtime.  This file contains some intentional truncating casts.
@@ -70,9 +70,7 @@
 #include <endian.h>  // __BYTE_ORDER
 #endif
 #endif
-#if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) ||   \
-     (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN) || \
-     (defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN)) &&      \
+#if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN) || (defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN)) && \
     !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
 #define PROTOBUF_LITTLE_ENDIAN 1
 #endif
@@ -91,30 +89,29 @@
 // Legacy: some users reference these (internal-only) macros even though we
 // don't need them any more.
 #if defined(_MSC_VER) && defined(PROTOBUF_USE_DLLS)
-  #ifdef LIBPROTOBUF_EXPORTS
-    #define LIBPROTOBUF_EXPORT __declspec(dllexport)
-  #else
-    #define LIBPROTOBUF_EXPORT __declspec(dllimport)
-  #endif
-  #ifdef LIBPROTOC_EXPORTS
-    #define LIBPROTOC_EXPORT   __declspec(dllexport)
-  #else
-    #define LIBPROTOC_EXPORT   __declspec(dllimport)
-  #endif
+#ifdef LIBPROTOBUF_EXPORTS
+#define LIBPROTOBUF_EXPORT __declspec(dllexport)
+#else
+#define LIBPROTOBUF_EXPORT __declspec(dllimport)
+#endif
+#ifdef LIBPROTOC_EXPORTS
+#define LIBPROTOC_EXPORT __declspec(dllexport)
 #else
-  #define LIBPROTOBUF_EXPORT
-  #define LIBPROTOC_EXPORT
+#define LIBPROTOC_EXPORT __declspec(dllimport)
+#endif
+#else
+#define LIBPROTOBUF_EXPORT
+#define LIBPROTOC_EXPORT
 #endif
 
 #define PROTOBUF_RUNTIME_DEPRECATED(message) PROTOBUF_DEPRECATED_MSG(message)
 #define GOOGLE_PROTOBUF_RUNTIME_DEPRECATED(message) \
-  PROTOBUF_DEPRECATED_MSG(message)
+    PROTOBUF_DEPRECATED_MSG(message)
 
 // ===================================================================
 // from google3/base/port.h
 
-#if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L || \
-     (defined(_MSC_VER) && _MSC_VER >= 1900))
+#if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900))
 // Define this to 1 if the code is compiled in C++11 mode; leave it
 // undefined otherwise.  Do NOT define it to 0 -- that causes
 // '#ifdef LANG_CXX11' to behave differently from '#if LANG_CXX11'.
@@ -123,117 +120,129 @@
 #error "Protobuf requires at least C++11."
 #endif
 
-namespace google {
-namespace protobuf {
+namespace google
+{
+    namespace protobuf
+    {
 
-using ConstStringParam = const std::string &;
+        using ConstStringParam = const std::string&;
 
-typedef unsigned int uint;
+        typedef unsigned int uint;
 
-typedef int8_t int8;
-typedef int16_t int16;
-typedef int32_t int32;
-typedef int64_t int64;
+        typedef int8_t int8;
+        typedef int16_t int16;
+        typedef int32_t int32;
+        typedef int64_t int64;
 
-typedef uint8_t uint8;
-typedef uint16_t uint16;
-typedef uint32_t uint32;
-typedef uint64_t uint64;
+        typedef uint8_t uint8;
+        typedef uint16_t uint16;
+        typedef uint32_t uint32;
+        typedef uint64_t uint64;
 
-static const int32 kint32max = 0x7FFFFFFF;
-static const int32 kint32min = -kint32max - 1;
-static const int64 kint64max = int64_t{0x7FFFFFFFFFFFFFFF};
-static const int64 kint64min = -kint64max - 1;
-static const uint32 kuint32max = 0xFFFFFFFFu;
-static const uint64 kuint64max = uint64_t{0xFFFFFFFFFFFFFFFFu};
+        static const int32 kint32max = 0x7FFFFFFF;
+        static const int32 kint32min = -kint32max - 1;
+        static const int64 kint64max = int64_t{0x7FFFFFFFFFFFFFFF};
+        static const int64 kint64min = -kint64max - 1;
+        static const uint32 kuint32max = 0xFFFFFFFFu;
+        static const uint64 kuint64max = uint64_t{0xFFFFFFFFFFFFFFFFu};
 
-#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) ||\
+#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) || \
     defined(MEMORY_SANITIZER)
 
 #ifdef __cplusplus
-extern "C" {
+        extern "C"
+        {
 #endif  // __cplusplus
-uint16_t __sanitizer_unaligned_load16(const void *p);
-uint32_t __sanitizer_unaligned_load32(const void *p);
-uint64_t __sanitizer_unaligned_load64(const void *p);
-void __sanitizer_unaligned_store16(void *p, uint16_t v);
-void __sanitizer_unaligned_store32(void *p, uint32_t v);
-void __sanitizer_unaligned_store64(void *p, uint64_t v);
+            uint16_t __sanitizer_unaligned_load16(const void* p);
+            uint32_t __sanitizer_unaligned_load32(const void* p);
+            uint64_t __sanitizer_unaligned_load64(const void* p);
+            void __sanitizer_unaligned_store16(void* p, uint16_t v);
+            void __sanitizer_unaligned_store32(void* p, uint32_t v);
+            void __sanitizer_unaligned_store64(void* p, uint64_t v);
 #ifdef __cplusplus
-}  // extern "C"
-#endif  // __cplusplus
-
-inline uint16_t GOOGLE_UNALIGNED_LOAD16(const void *p) {
-  return __sanitizer_unaligned_load16(p);
-}
-
-inline uint32_t GOOGLE_UNALIGNED_LOAD32(const void *p) {
-  return __sanitizer_unaligned_load32(p);
-}
-
-inline uint64_t GOOGLE_UNALIGNED_LOAD64(const void *p) {
-  return __sanitizer_unaligned_load64(p);
-}
-
-inline void GOOGLE_UNALIGNED_STORE16(void *p, uint16_t v) {
-  __sanitizer_unaligned_store16(p, v);
-}
-
-inline void GOOGLE_UNALIGNED_STORE32(void *p, uint32_t v) {
-  __sanitizer_unaligned_store32(p, v);
-}
-
-inline void GOOGLE_UNALIGNED_STORE64(void *p, uint64_t v) {
-  __sanitizer_unaligned_store64(p, v);
-}
+        }  // extern "C"
+#endif     // __cplusplus
+
+        inline uint16_t GOOGLE_UNALIGNED_LOAD16(const void* p)
+        {
+            return __sanitizer_unaligned_load16(p);
+        }
+
+        inline uint32_t GOOGLE_UNALIGNED_LOAD32(const void* p)
+        {
+            return __sanitizer_unaligned_load32(p);
+        }
+
+        inline uint64_t GOOGLE_UNALIGNED_LOAD64(const void* p)
+        {
+            return __sanitizer_unaligned_load64(p);
+        }
+
+        inline void GOOGLE_UNALIGNED_STORE16(void* p, uint16_t v)
+        {
+            __sanitizer_unaligned_store16(p, v);
+        }
+
+        inline void GOOGLE_UNALIGNED_STORE32(void* p, uint32_t v)
+        {
+            __sanitizer_unaligned_store32(p, v);
+        }
+
+        inline void GOOGLE_UNALIGNED_STORE64(void* p, uint64_t v)
+        {
+            __sanitizer_unaligned_store64(p, v);
+        }
 
 #elif defined(GOOGLE_PROTOBUF_USE_UNALIGNED) && GOOGLE_PROTOBUF_USE_UNALIGNED
 
-#define GOOGLE_UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16_t *>(_p))
-#define GOOGLE_UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32_t *>(_p))
-#define GOOGLE_UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64_t *>(_p))
+#define GOOGLE_UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16_t*>(_p))
+#define GOOGLE_UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32_t*>(_p))
+#define GOOGLE_UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64_t*>(_p))
 
-#define GOOGLE_UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16_t *>(_p) = (_val))
-#define GOOGLE_UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32_t *>(_p) = (_val))
-#define GOOGLE_UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64_t *>(_p) = (_val))
+#define GOOGLE_UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16_t*>(_p) = (_val))
+#define GOOGLE_UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32_t*>(_p) = (_val))
+#define GOOGLE_UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64_t*>(_p) = (_val))
 
 #else
-inline uint16_t GOOGLE_UNALIGNED_LOAD16(const void *p) {
-  uint16_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline uint32_t GOOGLE_UNALIGNED_LOAD32(const void *p) {
-  uint32_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline uint64_t GOOGLE_UNALIGNED_LOAD64(const void *p) {
-  uint64_t t;
-  memcpy(&t, p, sizeof t);
-  return t;
-}
-
-inline void GOOGLE_UNALIGNED_STORE16(void *p, uint16_t v) {
-  memcpy(p, &v, sizeof v);
-}
-
-inline void GOOGLE_UNALIGNED_STORE32(void *p, uint32_t v) {
-  memcpy(p, &v, sizeof v);
-}
-
-inline void GOOGLE_UNALIGNED_STORE64(void *p, uint64_t v) {
-  memcpy(p, &v, sizeof v);
-}
+        inline uint16_t GOOGLE_UNALIGNED_LOAD16(const void* p)
+        {
+            uint16_t t;
+            memcpy(&t, p, sizeof t);
+            return t;
+        }
+
+        inline uint32_t GOOGLE_UNALIGNED_LOAD32(const void* p)
+        {
+            uint32_t t;
+            memcpy(&t, p, sizeof t);
+            return t;
+        }
+
+        inline uint64_t GOOGLE_UNALIGNED_LOAD64(const void* p)
+        {
+            uint64_t t;
+            memcpy(&t, p, sizeof t);
+            return t;
+        }
+
+        inline void GOOGLE_UNALIGNED_STORE16(void* p, uint16_t v)
+        {
+            memcpy(p, &v, sizeof v);
+        }
+
+        inline void GOOGLE_UNALIGNED_STORE32(void* p, uint32_t v)
+        {
+            memcpy(p, &v, sizeof v);
+        }
+
+        inline void GOOGLE_UNALIGNED_STORE64(void* p, uint64_t v)
+        {
+            memcpy(p, &v, sizeof v);
+        }
 #endif
 
-#if defined(GOOGLE_PROTOBUF_OS_NACL) \
-    || (defined(__ANDROID__) && defined(__clang__) \
-        && (__clang_major__ == 3 && __clang_minor__ == 8) \
-        && (__clang_patchlevel__ < 275480))
-# define GOOGLE_PROTOBUF_USE_PORTABLE_LOG2
+#if defined(GOOGLE_PROTOBUF_OS_NACL) || (defined(__ANDROID__) && defined(__clang__) && (__clang_major__ == 3 && __clang_minor__ == 8) && (__clang_patchlevel__ < 275480))
+#define GOOGLE_PROTOBUF_USE_PORTABLE_LOG2
 #endif
 
 // The following guarantees declaration of the byte swap functions.
@@ -251,161 +260,215 @@ inline void GOOGLE_UNALIGNED_STORE64(void *p, uint64_t v) {
 #elif !defined(__linux__) && !defined(__ANDROID__) && !defined(__CYGWIN__)
 
 #ifndef bswap_16
-static inline uint16_t bswap_16(uint16_t x) {
-  return static_cast<uint16_t>(((x & 0xFF) << 8) | ((x & 0xFF00) >> 8));
-}
+        static inline uint16_t bswap_16(uint16_t x)
+        {
+            return static_cast<uint16_t>(((x & 0xFF) << 8) | ((x & 0xFF00) >> 8));
+        }
 #define bswap_16(x) bswap_16(x)
 #endif
 
 #ifndef bswap_32
-static inline uint32_t bswap_32(uint32_t x) {
-  return (((x & 0xFF) << 24) |
-          ((x & 0xFF00) << 8) |
-          ((x & 0xFF0000) >> 8) |
-          ((x & 0xFF000000) >> 24));
-}
+        static inline uint32_t bswap_32(uint32_t x)
+        {
+            return (((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) | ((x & 0xFF000000) >> 24));
+        }
 #define bswap_32(x) bswap_32(x)
 #endif
 
 #ifndef bswap_64
-static inline uint64_t bswap_64(uint64_t x) {
-  return (((x & uint64_t{0xFFu}) << 56) | ((x & uint64_t{0xFF00u}) << 40) |
-          ((x & uint64_t{0xFF0000u}) << 24) |
-          ((x & uint64_t{0xFF000000u}) << 8) |
-          ((x & uint64_t{0xFF00000000u}) >> 8) |
-          ((x & uint64_t{0xFF0000000000u}) >> 24) |
-          ((x & uint64_t{0xFF000000000000u}) >> 40) |
-          ((x & uint64_t{0xFF00000000000000u}) >> 56));
-}
+        static inline uint64_t bswap_64(uint64_t x)
+        {
+            return (((x & uint64_t{0xFFu}) << 56) | ((x & uint64_t{0xFF00u}) << 40) | ((x & uint64_t{0xFF0000u}) << 24) | ((x & uint64_t{0xFF000000u}) << 8) | ((x & uint64_t{0xFF00000000u}) >> 8) | ((x & uint64_t{0xFF0000000000u}) >> 24) | ((x & uint64_t{0xFF000000000000u}) >> 40) | ((x & uint64_t{0xFF00000000000000u}) >> 56));
+        }
 #define bswap_64(x) bswap_64(x)
 #endif
 
 #endif
 
-// ===================================================================
-// from google3/util/bits/bits.h
+        // ===================================================================
+        // from google3/util/bits/bits.h
 
-class Bits {
- public:
-  static uint32_t Log2FloorNonZero(uint32_t n) {
+        class Bits
+        {
+        public:
+            static uint32_t Log2FloorNonZero(uint32_t n)
+            {
 #if defined(__GNUC__)
-  return 31 ^ static_cast<uint32_t>(__builtin_clz(n));
+                return 31 ^ static_cast<uint32_t>(__builtin_clz(n));
 #elif defined(_MSC_VER)
-  unsigned long where;
-  _BitScanReverse(&where, n);
-  return where;
+                unsigned long where;
+                _BitScanReverse(&where, n);
+                return where;
 #else
-  return Log2FloorNonZero_Portable(n);
+                return Log2FloorNonZero_Portable(n);
 #endif
-  }
-
-  static uint32_t Log2FloorNonZero64(uint64_t n) {
-    // Older versions of clang run into an instruction-selection failure when
-    // it encounters __builtin_clzll:
-    // https://bugs.chromium.org/p/nativeclient/issues/detail?id=4395
-    // This includes arm-nacl-clang and clang in older Android NDK versions.
-    // To work around this, when we build with those we use the portable
-    // implementation instead.
+            }
+
+            static uint32_t Log2FloorNonZero64(uint64_t n)
+            {
+                // Older versions of clang run into an instruction-selection failure when
+                // it encounters __builtin_clzll:
+                // https://bugs.chromium.org/p/nativeclient/issues/detail?id=4395
+                // This includes arm-nacl-clang and clang in older Android NDK versions.
+                // To work around this, when we build with those we use the portable
+                // implementation instead.
 #if defined(__GNUC__) && !defined(GOOGLE_PROTOBUF_USE_PORTABLE_LOG2)
-  return 63 ^ static_cast<uint32_t>(__builtin_clzll(n));
+                return 63 ^ static_cast<uint32_t>(__builtin_clzll(n));
 #elif defined(_MSC_VER) && defined(_M_X64)
-  unsigned long where;
-  _BitScanReverse64(&where, n);
-  return where;
+                unsigned long where;
+                _BitScanReverse64(&where, n);
+                return where;
 #else
-  return Log2FloorNonZero64_Portable(n);
+                return Log2FloorNonZero64_Portable(n);
 #endif
-  }
- private:
-  static int Log2FloorNonZero_Portable(uint32_t n) {
-    if (n == 0)
-      return -1;
-    int log = 0;
-    uint32_t value = n;
-    for (int i = 4; i >= 0; --i) {
-      int shift = (1 << i);
-      uint32_t x = value >> shift;
-      if (x != 0) {
-        value = x;
-        log += shift;
-      }
-    }
-    assert(value == 1);
-    return log;
-  }
-
-  static int Log2FloorNonZero64_Portable(uint64_t n) {
-    const uint32_t topbits = static_cast<uint32_t>(n >> 32);
-    if (topbits == 0) {
-      // Top bits are zero, so scan in bottom bits
-      return static_cast<int>(Log2FloorNonZero(static_cast<uint32_t>(n)));
-    } else {
-      return 32 + static_cast<int>(Log2FloorNonZero(topbits));
-    }
-  }
-};
-
-// ===================================================================
-// from google3/util/endian/endian.h
-PROTOBUF_EXPORT uint32_t ghtonl(uint32_t x);
-
-class BigEndian {
- public:
+            }
+
+        private:
+            static int Log2FloorNonZero_Portable(uint32_t n)
+            {
+                if (n == 0)
+                    return -1;
+                int log = 0;
+                uint32_t value = n;
+                for (int i = 4; i >= 0; --i)
+                {
+                    int shift = (1 << i);
+                    uint32_t x = value >> shift;
+                    if (x != 0)
+                    {
+                        value = x;
+                        log += shift;
+                    }
+                }
+                assert(value == 1);
+                return log;
+            }
+
+            static int Log2FloorNonZero64_Portable(uint64_t n)
+            {
+                const uint32_t topbits = static_cast<uint32_t>(n >> 32);
+                if (topbits == 0)
+                {
+                    // Top bits are zero, so scan in bottom bits
+                    return static_cast<int>(Log2FloorNonZero(static_cast<uint32_t>(n)));
+                }
+                else
+                {
+                    return 32 + static_cast<int>(Log2FloorNonZero(topbits));
+                }
+            }
+        };
+
+        // ===================================================================
+        // from google3/util/endian/endian.h
+        PROTOBUF_EXPORT uint32_t ghtonl(uint32_t x);
+
+        class BigEndian
+        {
+        public:
 #ifdef PROTOBUF_LITTLE_ENDIAN
 
-  static uint16_t FromHost16(uint16_t x) { return bswap_16(x); }
-  static uint16_t ToHost16(uint16_t x) { return bswap_16(x); }
-
-  static uint32_t FromHost32(uint32_t x) { return bswap_32(x); }
-  static uint32_t ToHost32(uint32_t x) { return bswap_32(x); }
-
-  static uint64_t FromHost64(uint64_t x) { return bswap_64(x); }
-  static uint64_t ToHost64(uint64_t x) { return bswap_64(x); }
-
-  static bool IsLittleEndian() { return true; }
+            static uint16_t FromHost16(uint16_t x)
+            {
+                return bswap_16(x);
+            }
+            static uint16_t ToHost16(uint16_t x)
+            {
+                return bswap_16(x);
+            }
+
+            static uint32_t FromHost32(uint32_t x)
+            {
+                return bswap_32(x);
+            }
+            static uint32_t ToHost32(uint32_t x)
+            {
+                return bswap_32(x);
+            }
+
+            static uint64_t FromHost64(uint64_t x)
+            {
+                return bswap_64(x);
+            }
+            static uint64_t ToHost64(uint64_t x)
+            {
+                return bswap_64(x);
+            }
+
+            static bool IsLittleEndian()
+            {
+                return true;
+            }
 
 #else
 
-  static uint16_t FromHost16(uint16_t x) { return x; }
-  static uint16_t ToHost16(uint16_t x) { return x; }
-
-  static uint32_t FromHost32(uint32_t x) { return x; }
-  static uint32_t ToHost32(uint32_t x) { return x; }
-
-  static uint64_t FromHost64(uint64_t x) { return x; }
-  static uint64_t ToHost64(uint64_t x) { return x; }
-
-  static bool IsLittleEndian() { return false; }
+            static uint16_t FromHost16(uint16_t x)
+            {
+                return x;
+            }
+            static uint16_t ToHost16(uint16_t x)
+            {
+                return x;
+            }
+
+            static uint32_t FromHost32(uint32_t x)
+            {
+                return x;
+            }
+            static uint32_t ToHost32(uint32_t x)
+            {
+                return x;
+            }
+
+            static uint64_t FromHost64(uint64_t x)
+            {
+                return x;
+            }
+            static uint64_t ToHost64(uint64_t x)
+            {
+                return x;
+            }
+
+            static bool IsLittleEndian()
+            {
+                return false;
+            }
 
 #endif /* ENDIAN */
 
-  // Functions to do unaligned loads and stores in big-endian order.
-  static uint16_t Load16(const void *p) {
-    return ToHost16(GOOGLE_UNALIGNED_LOAD16(p));
-  }
-
-  static void Store16(void *p, uint16_t v) {
-    GOOGLE_UNALIGNED_STORE16(p, FromHost16(v));
-  }
-
-  static uint32_t Load32(const void *p) {
-    return ToHost32(GOOGLE_UNALIGNED_LOAD32(p));
-  }
-
-  static void Store32(void *p, uint32_t v) {
-    GOOGLE_UNALIGNED_STORE32(p, FromHost32(v));
-  }
-
-  static uint64_t Load64(const void *p) {
-    return ToHost64(GOOGLE_UNALIGNED_LOAD64(p));
-  }
-
-  static void Store64(void *p, uint64_t v) {
-    GOOGLE_UNALIGNED_STORE64(p, FromHost64(v));
-  }
-};
-
-}  // namespace protobuf
+            // Functions to do unaligned loads and stores in big-endian order.
+            static uint16_t Load16(const void* p)
+            {
+                return ToHost16(GOOGLE_UNALIGNED_LOAD16(p));
+            }
+
+            static void Store16(void* p, uint16_t v)
+            {
+                GOOGLE_UNALIGNED_STORE16(p, FromHost16(v));
+            }
+
+            static uint32_t Load32(const void* p)
+            {
+                return ToHost32(GOOGLE_UNALIGNED_LOAD32(p));
+            }
+
+            static void Store32(void* p, uint32_t v)
+            {
+                GOOGLE_UNALIGNED_STORE32(p, FromHost32(v));
+            }
+
+            static uint64_t Load64(const void* p)
+            {
+                return ToHost64(GOOGLE_UNALIGNED_LOAD64(p));
+            }
+
+            static void Store64(void* p, uint64_t v)
+            {
+                GOOGLE_UNALIGNED_STORE64(p, FromHost64(v));
+            }
+        };
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/status.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/status.h
index c858cf6..7911d7a 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/status.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/status.h
@@ -37,158 +37,174 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace util {
-namespace status_internal {
-
-// These values must match error codes defined in google/rpc/code.proto.
-enum class StatusCode : int {
-  kOk = 0,
-  kCancelled = 1,
-  kUnknown = 2,
-  kInvalidArgument = 3,
-  kDeadlineExceeded = 4,
-  kNotFound = 5,
-  kAlreadyExists = 6,
-  kPermissionDenied = 7,
-  kUnauthenticated = 16,
-  kResourceExhausted = 8,
-  kFailedPrecondition = 9,
-  kAborted = 10,
-  kOutOfRange = 11,
-  kUnimplemented = 12,
-  kInternal = 13,
-  kUnavailable = 14,
-  kDataLoss = 15,
-};
-
-class PROTOBUF_EXPORT Status {
- public:
-  // Creates a "successful" status.
-  Status();
-
-  // Create a status in the canonical error space with the specified
-  // code, and error message.  If "code == 0", error_message is
-  // ignored and a Status object identical to Status::kOk is
-  // constructed.
-  Status(StatusCode error_code, StringPiece error_message);
-  Status(const Status&);
-  Status& operator=(const Status& x);
-  ~Status() {}
-
-  // Accessor
-  bool ok() const { return error_code_ == StatusCode::kOk; }
-  StatusCode code() const { return error_code_; }
-  StringPiece message() const {
-    return error_message_;
-  }
-
-  bool operator==(const Status& x) const;
-  bool operator!=(const Status& x) const {
-    return !operator==(x);
-  }
-
-  // Return a combination of the error code name and message.
-  std::string ToString() const;
-
- private:
-  StatusCode error_code_;
-  std::string error_message_;
-};
-
-// Returns an OK status, equivalent to a default constructed instance. Prefer
-// usage of `OkStatus()` when constructing such an OK status.
-PROTOBUF_EXPORT Status OkStatus();
-
-// Prints a human-readable representation of 'x' to 'os'.
-PROTOBUF_EXPORT std::ostream& operator<<(std::ostream& os, const Status& x);
-
-// These convenience functions return `true` if a given status matches the
-// `StatusCode` error code of its associated function.
-PROTOBUF_EXPORT bool IsAborted(const Status& status);
-PROTOBUF_EXPORT bool IsAlreadyExists(const Status& status);
-PROTOBUF_EXPORT bool IsCancelled(const Status& status);
-PROTOBUF_EXPORT bool IsDataLoss(const Status& status);
-PROTOBUF_EXPORT bool IsDeadlineExceeded(const Status& status);
-PROTOBUF_EXPORT bool IsFailedPrecondition(const Status& status);
-PROTOBUF_EXPORT bool IsInternal(const Status& status);
-PROTOBUF_EXPORT bool IsInvalidArgument(const Status& status);
-PROTOBUF_EXPORT bool IsNotFound(const Status& status);
-PROTOBUF_EXPORT bool IsOutOfRange(const Status& status);
-PROTOBUF_EXPORT bool IsPermissionDenied(const Status& status);
-PROTOBUF_EXPORT bool IsResourceExhausted(const Status& status);
-PROTOBUF_EXPORT bool IsUnauthenticated(const Status& status);
-PROTOBUF_EXPORT bool IsUnavailable(const Status& status);
-PROTOBUF_EXPORT bool IsUnimplemented(const Status& status);
-PROTOBUF_EXPORT bool IsUnknown(const Status& status);
-
-// These convenience functions create an `Status` object with an error code as
-// indicated by the associated function name, using the error message passed in
-// `message`.
-//
-// These functions are intentionally named `*Error` rather than `*Status` to
-// match the names from Abseil:
-// https://github.com/abseil/abseil-cpp/blob/2e9532cc6c701a8323d0cffb468999ab804095ab/absl/status/status.h#L716
-PROTOBUF_EXPORT Status AbortedError(StringPiece message);
-PROTOBUF_EXPORT Status AlreadyExistsError(StringPiece message);
-PROTOBUF_EXPORT Status CancelledError(StringPiece message);
-PROTOBUF_EXPORT Status DataLossError(StringPiece message);
-PROTOBUF_EXPORT Status DeadlineExceededError(StringPiece message);
-PROTOBUF_EXPORT Status FailedPreconditionError(StringPiece message);
-PROTOBUF_EXPORT Status InternalError(StringPiece message);
-PROTOBUF_EXPORT Status InvalidArgumentError(StringPiece message);
-PROTOBUF_EXPORT Status NotFoundError(StringPiece message);
-PROTOBUF_EXPORT Status OutOfRangeError(StringPiece message);
-PROTOBUF_EXPORT Status PermissionDeniedError(StringPiece message);
-PROTOBUF_EXPORT Status ResourceExhaustedError(StringPiece message);
-PROTOBUF_EXPORT Status UnauthenticatedError(StringPiece message);
-PROTOBUF_EXPORT Status UnavailableError(StringPiece message);
-PROTOBUF_EXPORT Status UnimplementedError(StringPiece message);
-PROTOBUF_EXPORT Status UnknownError(StringPiece message);
-
-}  // namespace status_internal
-
-using ::google::protobuf::util::status_internal::Status;
-using ::google::protobuf::util::status_internal::StatusCode;
-
-using ::google::protobuf::util::status_internal::IsAborted;
-using ::google::protobuf::util::status_internal::IsAlreadyExists;
-using ::google::protobuf::util::status_internal::IsCancelled;
-using ::google::protobuf::util::status_internal::IsDataLoss;
-using ::google::protobuf::util::status_internal::IsDeadlineExceeded;
-using ::google::protobuf::util::status_internal::IsFailedPrecondition;
-using ::google::protobuf::util::status_internal::IsInternal;
-using ::google::protobuf::util::status_internal::IsInvalidArgument;
-using ::google::protobuf::util::status_internal::IsNotFound;
-using ::google::protobuf::util::status_internal::IsOutOfRange;
-using ::google::protobuf::util::status_internal::IsPermissionDenied;
-using ::google::protobuf::util::status_internal::IsResourceExhausted;
-using ::google::protobuf::util::status_internal::IsUnauthenticated;
-using ::google::protobuf::util::status_internal::IsUnavailable;
-using ::google::protobuf::util::status_internal::IsUnimplemented;
-using ::google::protobuf::util::status_internal::IsUnknown;
-
-using ::google::protobuf::util::status_internal::AbortedError;
-using ::google::protobuf::util::status_internal::AlreadyExistsError;
-using ::google::protobuf::util::status_internal::CancelledError;
-using ::google::protobuf::util::status_internal::DataLossError;
-using ::google::protobuf::util::status_internal::DeadlineExceededError;
-using ::google::protobuf::util::status_internal::FailedPreconditionError;
-using ::google::protobuf::util::status_internal::InternalError;
-using ::google::protobuf::util::status_internal::InvalidArgumentError;
-using ::google::protobuf::util::status_internal::NotFoundError;
-using ::google::protobuf::util::status_internal::OkStatus;
-using ::google::protobuf::util::status_internal::OutOfRangeError;
-using ::google::protobuf::util::status_internal::PermissionDeniedError;
-using ::google::protobuf::util::status_internal::ResourceExhaustedError;
-using ::google::protobuf::util::status_internal::UnauthenticatedError;
-using ::google::protobuf::util::status_internal::UnavailableError;
-using ::google::protobuf::util::status_internal::UnimplementedError;
-using ::google::protobuf::util::status_internal::UnknownError;
-
-}  // namespace util
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace util
+        {
+            namespace status_internal
+            {
+
+                // These values must match error codes defined in google/rpc/code.proto.
+                enum class StatusCode : int
+                {
+                    kOk = 0,
+                    kCancelled = 1,
+                    kUnknown = 2,
+                    kInvalidArgument = 3,
+                    kDeadlineExceeded = 4,
+                    kNotFound = 5,
+                    kAlreadyExists = 6,
+                    kPermissionDenied = 7,
+                    kUnauthenticated = 16,
+                    kResourceExhausted = 8,
+                    kFailedPrecondition = 9,
+                    kAborted = 10,
+                    kOutOfRange = 11,
+                    kUnimplemented = 12,
+                    kInternal = 13,
+                    kUnavailable = 14,
+                    kDataLoss = 15,
+                };
+
+                class PROTOBUF_EXPORT Status
+                {
+                public:
+                    // Creates a "successful" status.
+                    Status();
+
+                    // Create a status in the canonical error space with the specified
+                    // code, and error message.  If "code == 0", error_message is
+                    // ignored and a Status object identical to Status::kOk is
+                    // constructed.
+                    Status(StatusCode error_code, StringPiece error_message);
+                    Status(const Status&);
+                    Status& operator=(const Status& x);
+                    ~Status()
+                    {
+                    }
+
+                    // Accessor
+                    bool ok() const
+                    {
+                        return error_code_ == StatusCode::kOk;
+                    }
+                    StatusCode code() const
+                    {
+                        return error_code_;
+                    }
+                    StringPiece message() const
+                    {
+                        return error_message_;
+                    }
+
+                    bool operator==(const Status& x) const;
+                    bool operator!=(const Status& x) const
+                    {
+                        return !operator==(x);
+                    }
+
+                    // Return a combination of the error code name and message.
+                    std::string ToString() const;
+
+                private:
+                    StatusCode error_code_;
+                    std::string error_message_;
+                };
+
+                // Returns an OK status, equivalent to a default constructed instance. Prefer
+                // usage of `OkStatus()` when constructing such an OK status.
+                PROTOBUF_EXPORT Status OkStatus();
+
+                // Prints a human-readable representation of 'x' to 'os'.
+                PROTOBUF_EXPORT std::ostream& operator<<(std::ostream& os, const Status& x);
+
+                // These convenience functions return `true` if a given status matches the
+                // `StatusCode` error code of its associated function.
+                PROTOBUF_EXPORT bool IsAborted(const Status& status);
+                PROTOBUF_EXPORT bool IsAlreadyExists(const Status& status);
+                PROTOBUF_EXPORT bool IsCancelled(const Status& status);
+                PROTOBUF_EXPORT bool IsDataLoss(const Status& status);
+                PROTOBUF_EXPORT bool IsDeadlineExceeded(const Status& status);
+                PROTOBUF_EXPORT bool IsFailedPrecondition(const Status& status);
+                PROTOBUF_EXPORT bool IsInternal(const Status& status);
+                PROTOBUF_EXPORT bool IsInvalidArgument(const Status& status);
+                PROTOBUF_EXPORT bool IsNotFound(const Status& status);
+                PROTOBUF_EXPORT bool IsOutOfRange(const Status& status);
+                PROTOBUF_EXPORT bool IsPermissionDenied(const Status& status);
+                PROTOBUF_EXPORT bool IsResourceExhausted(const Status& status);
+                PROTOBUF_EXPORT bool IsUnauthenticated(const Status& status);
+                PROTOBUF_EXPORT bool IsUnavailable(const Status& status);
+                PROTOBUF_EXPORT bool IsUnimplemented(const Status& status);
+                PROTOBUF_EXPORT bool IsUnknown(const Status& status);
+
+                // These convenience functions create an `Status` object with an error code as
+                // indicated by the associated function name, using the error message passed in
+                // `message`.
+                //
+                // These functions are intentionally named `*Error` rather than `*Status` to
+                // match the names from Abseil:
+                // https://github.com/abseil/abseil-cpp/blob/2e9532cc6c701a8323d0cffb468999ab804095ab/absl/status/status.h#L716
+                PROTOBUF_EXPORT Status AbortedError(StringPiece message);
+                PROTOBUF_EXPORT Status AlreadyExistsError(StringPiece message);
+                PROTOBUF_EXPORT Status CancelledError(StringPiece message);
+                PROTOBUF_EXPORT Status DataLossError(StringPiece message);
+                PROTOBUF_EXPORT Status DeadlineExceededError(StringPiece message);
+                PROTOBUF_EXPORT Status FailedPreconditionError(StringPiece message);
+                PROTOBUF_EXPORT Status InternalError(StringPiece message);
+                PROTOBUF_EXPORT Status InvalidArgumentError(StringPiece message);
+                PROTOBUF_EXPORT Status NotFoundError(StringPiece message);
+                PROTOBUF_EXPORT Status OutOfRangeError(StringPiece message);
+                PROTOBUF_EXPORT Status PermissionDeniedError(StringPiece message);
+                PROTOBUF_EXPORT Status ResourceExhaustedError(StringPiece message);
+                PROTOBUF_EXPORT Status UnauthenticatedError(StringPiece message);
+                PROTOBUF_EXPORT Status UnavailableError(StringPiece message);
+                PROTOBUF_EXPORT Status UnimplementedError(StringPiece message);
+                PROTOBUF_EXPORT Status UnknownError(StringPiece message);
+
+            }  // namespace status_internal
+
+            using ::google::protobuf::util::status_internal::Status;
+            using ::google::protobuf::util::status_internal::StatusCode;
+
+            using ::google::protobuf::util::status_internal::IsAborted;
+            using ::google::protobuf::util::status_internal::IsAlreadyExists;
+            using ::google::protobuf::util::status_internal::IsCancelled;
+            using ::google::protobuf::util::status_internal::IsDataLoss;
+            using ::google::protobuf::util::status_internal::IsDeadlineExceeded;
+            using ::google::protobuf::util::status_internal::IsFailedPrecondition;
+            using ::google::protobuf::util::status_internal::IsInternal;
+            using ::google::protobuf::util::status_internal::IsInvalidArgument;
+            using ::google::protobuf::util::status_internal::IsNotFound;
+            using ::google::protobuf::util::status_internal::IsOutOfRange;
+            using ::google::protobuf::util::status_internal::IsPermissionDenied;
+            using ::google::protobuf::util::status_internal::IsResourceExhausted;
+            using ::google::protobuf::util::status_internal::IsUnauthenticated;
+            using ::google::protobuf::util::status_internal::IsUnavailable;
+            using ::google::protobuf::util::status_internal::IsUnimplemented;
+            using ::google::protobuf::util::status_internal::IsUnknown;
+
+            using ::google::protobuf::util::status_internal::AbortedError;
+            using ::google::protobuf::util::status_internal::AlreadyExistsError;
+            using ::google::protobuf::util::status_internal::CancelledError;
+            using ::google::protobuf::util::status_internal::DataLossError;
+            using ::google::protobuf::util::status_internal::DeadlineExceededError;
+            using ::google::protobuf::util::status_internal::FailedPreconditionError;
+            using ::google::protobuf::util::status_internal::InternalError;
+            using ::google::protobuf::util::status_internal::InvalidArgumentError;
+            using ::google::protobuf::util::status_internal::NotFoundError;
+            using ::google::protobuf::util::status_internal::OkStatus;
+            using ::google::protobuf::util::status_internal::OutOfRangeError;
+            using ::google::protobuf::util::status_internal::PermissionDeniedError;
+            using ::google::protobuf::util::status_internal::ResourceExhaustedError;
+            using ::google::protobuf::util::status_internal::UnauthenticatedError;
+            using ::google::protobuf::util::status_internal::UnavailableError;
+            using ::google::protobuf::util::status_internal::UnimplementedError;
+            using ::google::protobuf::util::status_internal::UnknownError;
+
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/stl_util.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/stl_util.h
index e6260d0..2ae2596 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/stl_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/stl_util.h
@@ -40,49 +40,54 @@
 // Must be last.
 #include <google/protobuf/port_def.inc>  // NOLINT
 
-namespace google {
-namespace protobuf {
+namespace google
+{
+    namespace protobuf
+    {
 
-// Inside Google, this function implements a horrible, disgusting hack in which
-// we reach into the string's private implementation and resize it without
-// initializing the new bytes.  In some cases doing this can significantly
-// improve performance.  However, since it's totally non-portable it has no
-// place in open source code.  Feel free to fill this function in with your
-// own disgusting hack if you want the perf boost.
-inline void STLStringResizeUninitialized(std::string* s, size_t new_size) {
-  s->resize(new_size);
-}
+        // Inside Google, this function implements a horrible, disgusting hack in which
+        // we reach into the string's private implementation and resize it without
+        // initializing the new bytes.  In some cases doing this can significantly
+        // improve performance.  However, since it's totally non-portable it has no
+        // place in open source code.  Feel free to fill this function in with your
+        // own disgusting hack if you want the perf boost.
+        inline void STLStringResizeUninitialized(std::string* s, size_t new_size)
+        {
+            s->resize(new_size);
+        }
 
-// As above, but we make sure to follow amortized growth in which we always
-// increase the capacity by at least a constant factor >1.
-inline void STLStringResizeUninitializedAmortized(std::string* s,
-                                                  size_t new_size) {
-  const size_t cap = s->capacity();
-  if (new_size > cap) {
-    // Make sure to always grow by at least a factor of 2x.
-    s->reserve(std::max<size_t>(new_size, 2 * cap));
-  }
-  STLStringResizeUninitialized(s, new_size);
-}
+        // As above, but we make sure to follow amortized growth in which we always
+        // increase the capacity by at least a constant factor >1.
+        inline void STLStringResizeUninitializedAmortized(std::string* s, size_t new_size)
+        {
+            const size_t cap = s->capacity();
+            if (new_size > cap)
+            {
+                // Make sure to always grow by at least a factor of 2x.
+                s->reserve(std::max<size_t>(new_size, 2 * cap));
+            }
+            STLStringResizeUninitialized(s, new_size);
+        }
 
-// Return a mutable char* pointing to a string's internal buffer,
-// which may not be null-terminated. Writing through this pointer will
-// modify the string.
-//
-// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
-// next call to a string method that invalidates iterators.
-//
-// As of 2006-04, there is no standard-blessed way of getting a
-// mutable reference to a string's internal buffer. However, issue 530
-// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#530)
-// proposes this as the method. According to Matt Austern, this should
-// already work on all current implementations.
-inline char* string_as_array(std::string* str) {
-  // DO NOT USE const_cast<char*>(str->data())! See the unittest for why.
-  return str->empty() ? nullptr : &*str->begin();
-}
+        // Return a mutable char* pointing to a string's internal buffer,
+        // which may not be null-terminated. Writing through this pointer will
+        // modify the string.
+        //
+        // string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
+        // next call to a string method that invalidates iterators.
+        //
+        // As of 2006-04, there is no standard-blessed way of getting a
+        // mutable reference to a string's internal buffer. However, issue 530
+        // (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#530)
+        // proposes this as the method. According to Matt Austern, this should
+        // already work on all current implementations.
+        inline char* string_as_array(std::string* str)
+        {
+            // DO NOT USE const_cast<char*>(str->data())! See the unittest for why.
+            return str->empty() ? nullptr : &*str->begin();
+        }
 
-}  // namespace protobuf
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>  // NOLINT
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/stringpiece.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/stringpiece.h
index c63e25b..0e705de 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/stringpiece.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/stringpiece.h
@@ -156,244 +156,322 @@
 
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace stringpiece_internal {
-
-class PROTOBUF_EXPORT StringPiece {
- public:
-  using traits_type = std::char_traits<char>;
-  using value_type = char;
-  using pointer = char*;
-  using const_pointer = const char*;
-  using reference = char&;
-  using const_reference = const char&;
-  using const_iterator = const char*;
-  using iterator = const_iterator;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using reverse_iterator = const_reverse_iterator;
-  using size_type = size_t;
-  using difference_type = std::ptrdiff_t;
-
- private:
-  const char* ptr_;
-  size_type length_;
-
-  static constexpr size_type kMaxSize =
-      (std::numeric_limits<difference_type>::max)();
-
-  static size_type CheckSize(size_type size) {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace stringpiece_internal
+        {
+
+            class PROTOBUF_EXPORT StringPiece
+            {
+            public:
+                using traits_type = std::char_traits<char>;
+                using value_type = char;
+                using pointer = char*;
+                using const_pointer = const char*;
+                using reference = char&;
+                using const_reference = const char&;
+                using const_iterator = const char*;
+                using iterator = const_iterator;
+                using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+                using reverse_iterator = const_reverse_iterator;
+                using size_type = size_t;
+                using difference_type = std::ptrdiff_t;
+
+            private:
+                const char* ptr_;
+                size_type length_;
+
+                static constexpr size_type kMaxSize =
+                    (std::numeric_limits<difference_type>::max)();
+
+                static size_type CheckSize(size_type size)
+                {
 #if !defined(NDEBUG) || defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0
-    if (PROTOBUF_PREDICT_FALSE(size > kMaxSize)) {
-      // Some people grep for this message in logs
-      // so take care if you ever change it.
-      LogFatalSizeTooBig(size, "string length exceeds max size");
-    }
+                    if (PROTOBUF_PREDICT_FALSE(size > kMaxSize))
+                    {
+                        // Some people grep for this message in logs
+                        // so take care if you ever change it.
+                        LogFatalSizeTooBig(size, "string length exceeds max size");
+                    }
 #endif
-    return size;
-  }
-
-  // Out-of-line error path.
-  static void LogFatalSizeTooBig(size_type size, const char* details);
-
- public:
-  // We provide non-explicit singleton constructors so users can pass
-  // in a "const char*" or a "string" wherever a "StringPiece" is
-  // expected.
-  //
-  // Style guide exception granted:
-  // http://goto/style-guide-exception-20978288
-  StringPiece() : ptr_(nullptr), length_(0) {}
-
-  StringPiece(const char* str)  // NOLINT(runtime/explicit)
-      : ptr_(str), length_(0) {
-    if (str != nullptr) {
-      length_ = CheckSize(strlen(str));
-    }
-  }
-
-  template <class Allocator>
-  StringPiece(  // NOLINT(runtime/explicit)
-      const std::basic_string<char, std::char_traits<char>, Allocator>& str)
-      : ptr_(str.data()), length_(0) {
-    length_ = CheckSize(str.size());
-  }
+                    return size;
+                }
+
+                // Out-of-line error path.
+                static void LogFatalSizeTooBig(size_type size, const char* details);
+
+            public:
+                // We provide non-explicit singleton constructors so users can pass
+                // in a "const char*" or a "string" wherever a "StringPiece" is
+                // expected.
+                //
+                // Style guide exception granted:
+                // http://goto/style-guide-exception-20978288
+                StringPiece() :
+                    ptr_(nullptr),
+                    length_(0)
+                {
+                }
+
+                StringPiece(const char* str)  // NOLINT(runtime/explicit)
+                    :
+                    ptr_(str),
+                    length_(0)
+                {
+                    if (str != nullptr)
+                    {
+                        length_ = CheckSize(strlen(str));
+                    }
+                }
+
+                template<class Allocator>
+                StringPiece(  // NOLINT(runtime/explicit)
+                    const std::basic_string<char, std::char_traits<char>, Allocator>& str
+                ) :
+                    ptr_(str.data()),
+                    length_(0)
+                {
+                    length_ = CheckSize(str.size());
+                }
 
 #if defined(__cpp_lib_string_view)
-  StringPiece(  // NOLINT(runtime/explicit)
-      std::string_view str)
-      : ptr_(str.data()), length_(0) {
-    length_ = CheckSize(str.size());
-  }
+                StringPiece(  // NOLINT(runtime/explicit)
+                    std::string_view str
+                ) :
+                    ptr_(str.data()),
+                    length_(0)
+                {
+                    length_ = CheckSize(str.size());
+                }
 #endif
 
-  StringPiece(const char* offset, size_type len)
-      : ptr_(offset), length_(CheckSize(len)) {}
-
-  // data() may return a pointer to a buffer with embedded NULs, and the
-  // returned buffer may or may not be null terminated.  Therefore it is
-  // typically a mistake to pass data() to a routine that expects a NUL
-  // terminated string.
-  const_pointer data() const { return ptr_; }
-  size_type size() const { return length_; }
-  size_type length() const { return length_; }
-  bool empty() const { return length_ == 0; }
-
-  char operator[](size_type i) const {
-    assert(i < length_);
-    return ptr_[i];
-  }
-
-  void remove_prefix(size_type n) {
-    assert(length_ >= n);
-    ptr_ += n;
-    length_ -= n;
-  }
-
-  void remove_suffix(size_type n) {
-    assert(length_ >= n);
-    length_ -= n;
-  }
-
-  // returns {-1, 0, 1}
-  int compare(StringPiece x) const {
-    size_type min_size = length_ < x.length_ ? length_ : x.length_;
-    int r = memcmp(ptr_, x.ptr_, static_cast<size_t>(min_size));
-    if (r < 0) return -1;
-    if (r > 0) return 1;
-    if (length_ < x.length_) return -1;
-    if (length_ > x.length_) return 1;
-    return 0;
-  }
-
-  std::string as_string() const { return ToString(); }
-  // We also define ToString() here, since many other string-like
-  // interfaces name the routine that converts to a C++ string
-  // "ToString", and it's confusing to have the method that does that
-  // for a StringPiece be called "as_string()".  We also leave the
-  // "as_string()" method defined here for existing code.
-  std::string ToString() const {
-    if (ptr_ == nullptr) return "";
-    return std::string(data(), static_cast<size_type>(size()));
-  }
-
-  explicit operator std::string() const { return ToString(); }
-
-  void CopyToString(std::string* target) const;
-  void AppendToString(std::string* target) const;
-
-  bool starts_with(StringPiece x) const {
-    return (length_ >= x.length_) &&
-           (memcmp(ptr_, x.ptr_, static_cast<size_t>(x.length_)) == 0);
-  }
-
-  bool ends_with(StringPiece x) const {
-    return ((length_ >= x.length_) &&
-            (memcmp(ptr_ + (length_-x.length_), x.ptr_,
-                 static_cast<size_t>(x.length_)) == 0));
-  }
-
-  // Checks whether StringPiece starts with x and if so advances the beginning
-  // of it to past the match.  It's basically a shortcut for starts_with
-  // followed by remove_prefix.
-  bool Consume(StringPiece x);
-  // Like above but for the end of the string.
-  bool ConsumeFromEnd(StringPiece x);
-
-  // standard STL container boilerplate
-  static const size_type npos;
-  const_iterator begin() const { return ptr_; }
-  const_iterator end() const { return ptr_ + length_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(ptr_ + length_);
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(ptr_);
-  }
-  size_type max_size() const { return length_; }
-  size_type capacity() const { return length_; }
-
-  // cpplint.py emits a false positive [build/include_what_you_use]
-  size_type copy(char* buf, size_type n, size_type pos = 0) const;  // NOLINT
-
-  bool contains(StringPiece s) const;
-
-  size_type find(StringPiece s, size_type pos = 0) const;
-  size_type find(char c, size_type pos = 0) const;
-  size_type rfind(StringPiece s, size_type pos = npos) const;
-  size_type rfind(char c, size_type pos = npos) const;
-
-  size_type find_first_of(StringPiece s, size_type pos = 0) const;
-  size_type find_first_of(char c, size_type pos = 0) const {
-    return find(c, pos);
-  }
-  size_type find_first_not_of(StringPiece s, size_type pos = 0) const;
-  size_type find_first_not_of(char c, size_type pos = 0) const;
-  size_type find_last_of(StringPiece s, size_type pos = npos) const;
-  size_type find_last_of(char c, size_type pos = npos) const {
-    return rfind(c, pos);
-  }
-  size_type find_last_not_of(StringPiece s, size_type pos = npos) const;
-  size_type find_last_not_of(char c, size_type pos = npos) const;
-
-  StringPiece substr(size_type pos, size_type n = npos) const;
-};
-
-// This large function is defined inline so that in a fairly common case where
-// one of the arguments is a literal, the compiler can elide a lot of the
-// following comparisons.
-inline bool operator==(StringPiece x, StringPiece y) {
-  StringPiece::size_type len = x.size();
-  if (len != y.size()) {
-    return false;
-  }
-
-  return x.data() == y.data() || len <= 0 ||
-      memcmp(x.data(), y.data(), static_cast<size_t>(len)) == 0;
-}
-
-inline bool operator!=(StringPiece x, StringPiece y) {
-  return !(x == y);
-}
-
-inline bool operator<(StringPiece x, StringPiece y) {
-  const StringPiece::size_type min_size =
-      x.size() < y.size() ? x.size() : y.size();
-  const int r = memcmp(x.data(), y.data(), static_cast<size_t>(min_size));
-  return (r < 0) || (r == 0 && x.size() < y.size());
-}
-
-inline bool operator>(StringPiece x, StringPiece y) {
-  return y < x;
-}
-
-inline bool operator<=(StringPiece x, StringPiece y) {
-  return !(x > y);
-}
-
-inline bool operator>=(StringPiece x, StringPiece y) {
-  return !(x < y);
-}
-
-// allow StringPiece to be logged
-extern std::ostream& operator<<(std::ostream& o, StringPiece piece);
-
-}  // namespace stringpiece_internal
-
-using ::google::protobuf::stringpiece_internal::StringPiece;
-
-}  // namespace protobuf
+                StringPiece(const char* offset, size_type len) :
+                    ptr_(offset),
+                    length_(CheckSize(len))
+                {
+                }
+
+                // data() may return a pointer to a buffer with embedded NULs, and the
+                // returned buffer may or may not be null terminated.  Therefore it is
+                // typically a mistake to pass data() to a routine that expects a NUL
+                // terminated string.
+                const_pointer data() const
+                {
+                    return ptr_;
+                }
+                size_type size() const
+                {
+                    return length_;
+                }
+                size_type length() const
+                {
+                    return length_;
+                }
+                bool empty() const
+                {
+                    return length_ == 0;
+                }
+
+                char operator[](size_type i) const
+                {
+                    assert(i < length_);
+                    return ptr_[i];
+                }
+
+                void remove_prefix(size_type n)
+                {
+                    assert(length_ >= n);
+                    ptr_ += n;
+                    length_ -= n;
+                }
+
+                void remove_suffix(size_type n)
+                {
+                    assert(length_ >= n);
+                    length_ -= n;
+                }
+
+                // returns {-1, 0, 1}
+                int compare(StringPiece x) const
+                {
+                    size_type min_size = length_ < x.length_ ? length_ : x.length_;
+                    int r = memcmp(ptr_, x.ptr_, static_cast<size_t>(min_size));
+                    if (r < 0)
+                        return -1;
+                    if (r > 0)
+                        return 1;
+                    if (length_ < x.length_)
+                        return -1;
+                    if (length_ > x.length_)
+                        return 1;
+                    return 0;
+                }
+
+                std::string as_string() const
+                {
+                    return ToString();
+                }
+                // We also define ToString() here, since many other string-like
+                // interfaces name the routine that converts to a C++ string
+                // "ToString", and it's confusing to have the method that does that
+                // for a StringPiece be called "as_string()".  We also leave the
+                // "as_string()" method defined here for existing code.
+                std::string ToString() const
+                {
+                    if (ptr_ == nullptr)
+                        return "";
+                    return std::string(data(), static_cast<size_type>(size()));
+                }
+
+                explicit operator std::string() const
+                {
+                    return ToString();
+                }
+
+                void CopyToString(std::string* target) const;
+                void AppendToString(std::string* target) const;
+
+                bool starts_with(StringPiece x) const
+                {
+                    return (length_ >= x.length_) &&
+                           (memcmp(ptr_, x.ptr_, static_cast<size_t>(x.length_)) == 0);
+                }
+
+                bool ends_with(StringPiece x) const
+                {
+                    return ((length_ >= x.length_) && (memcmp(ptr_ + (length_ - x.length_), x.ptr_, static_cast<size_t>(x.length_)) == 0));
+                }
+
+                // Checks whether StringPiece starts with x and if so advances the beginning
+                // of it to past the match.  It's basically a shortcut for starts_with
+                // followed by remove_prefix.
+                bool Consume(StringPiece x);
+                // Like above but for the end of the string.
+                bool ConsumeFromEnd(StringPiece x);
+
+                // standard STL container boilerplate
+                static const size_type npos;
+                const_iterator begin() const
+                {
+                    return ptr_;
+                }
+                const_iterator end() const
+                {
+                    return ptr_ + length_;
+                }
+                const_reverse_iterator rbegin() const
+                {
+                    return const_reverse_iterator(ptr_ + length_);
+                }
+                const_reverse_iterator rend() const
+                {
+                    return const_reverse_iterator(ptr_);
+                }
+                size_type max_size() const
+                {
+                    return length_;
+                }
+                size_type capacity() const
+                {
+                    return length_;
+                }
+
+                // cpplint.py emits a false positive [build/include_what_you_use]
+                size_type copy(char* buf, size_type n, size_type pos = 0) const;  // NOLINT
+
+                bool contains(StringPiece s) const;
+
+                size_type find(StringPiece s, size_type pos = 0) const;
+                size_type find(char c, size_type pos = 0) const;
+                size_type rfind(StringPiece s, size_type pos = npos) const;
+                size_type rfind(char c, size_type pos = npos) const;
+
+                size_type find_first_of(StringPiece s, size_type pos = 0) const;
+                size_type find_first_of(char c, size_type pos = 0) const
+                {
+                    return find(c, pos);
+                }
+                size_type find_first_not_of(StringPiece s, size_type pos = 0) const;
+                size_type find_first_not_of(char c, size_type pos = 0) const;
+                size_type find_last_of(StringPiece s, size_type pos = npos) const;
+                size_type find_last_of(char c, size_type pos = npos) const
+                {
+                    return rfind(c, pos);
+                }
+                size_type find_last_not_of(StringPiece s, size_type pos = npos) const;
+                size_type find_last_not_of(char c, size_type pos = npos) const;
+
+                StringPiece substr(size_type pos, size_type n = npos) const;
+            };
+
+            // This large function is defined inline so that in a fairly common case where
+            // one of the arguments is a literal, the compiler can elide a lot of the
+            // following comparisons.
+            inline bool operator==(StringPiece x, StringPiece y)
+            {
+                StringPiece::size_type len = x.size();
+                if (len != y.size())
+                {
+                    return false;
+                }
+
+                return x.data() == y.data() || len <= 0 ||
+                       memcmp(x.data(), y.data(), static_cast<size_t>(len)) == 0;
+            }
+
+            inline bool operator!=(StringPiece x, StringPiece y)
+            {
+                return !(x == y);
+            }
+
+            inline bool operator<(StringPiece x, StringPiece y)
+            {
+                const StringPiece::size_type min_size =
+                    x.size() < y.size() ? x.size() : y.size();
+                const int r = memcmp(x.data(), y.data(), static_cast<size_t>(min_size));
+                return (r < 0) || (r == 0 && x.size() < y.size());
+            }
+
+            inline bool operator>(StringPiece x, StringPiece y)
+            {
+                return y < x;
+            }
+
+            inline bool operator<=(StringPiece x, StringPiece y)
+            {
+                return !(x > y);
+            }
+
+            inline bool operator>=(StringPiece x, StringPiece y)
+            {
+                return !(x < y);
+            }
+
+            // allow StringPiece to be logged
+            extern std::ostream& operator<<(std::ostream& o, StringPiece piece);
+
+        }  // namespace stringpiece_internal
+
+        using ::google::protobuf::stringpiece_internal::StringPiece;
+
+    }  // namespace protobuf
 }  // namespace google
 
 GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START
-template<> struct hash<StringPiece> {
-  size_t operator()(const StringPiece& s) const {
-    size_t result = 0;
-    for (const char *str = s.data(), *end = str + s.size(); str < end; str++) {
-      result = 5 * result + static_cast<size_t>(*str);
+template<>
+struct hash<StringPiece>
+{
+    size_t operator()(const StringPiece& s) const
+    {
+        size_t result = 0;
+        for (const char *str = s.data(), *end = str + s.size(); str < end; str++)
+        {
+            result = 5 * result + static_cast<size_t>(*str);
+        }
+        return result;
     }
-    return result;
-  }
 };
 GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END
 
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/strutil.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/strutil.h
index 9658abf..a1ce274 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/strutil.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/strutil.h
@@ -41,11 +41,13 @@
 #include <google/protobuf/port_def.inc>
 #include <vector>
 
-namespace google {
-namespace protobuf {
+namespace google
+{
+    namespace protobuf
+    {
 
 #if defined(_MSC_VER) && _MSC_VER < 1800
-#define strtoll  _strtoi64
+#define strtoll _strtoi64
 #define strtoull _strtoui64
 #elif defined(__DECCXX) && defined(__osf__)
 // HP C++ on Tru64 does not have strtoll, but strtol is already 64-bit.
@@ -53,896 +55,945 @@ namespace protobuf {
 #define strtoull strtoul
 #endif
 
-// ----------------------------------------------------------------------
-// ascii_isalnum()
-//    Check if an ASCII character is alphanumeric.  We can't use ctype's
-//    isalnum() because it is affected by locale.  This function is applied
-//    to identifiers in the protocol buffer language, not to natural-language
-//    strings, so locale should not be taken into account.
-// ascii_isdigit()
-//    Like above, but only accepts digits.
-// ascii_isspace()
-//    Check if the character is a space character.
-// ----------------------------------------------------------------------
-
-inline bool ascii_isalnum(char c) {
-  return ('a' <= c && c <= 'z') ||
-         ('A' <= c && c <= 'Z') ||
-         ('0' <= c && c <= '9');
-}
-
-inline bool ascii_isdigit(char c) {
-  return ('0' <= c && c <= '9');
-}
-
-inline bool ascii_isspace(char c) {
-  return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' ||
-      c == '\r';
-}
-
-inline bool ascii_isupper(char c) {
-  return c >= 'A' && c <= 'Z';
-}
-
-inline bool ascii_islower(char c) {
-  return c >= 'a' && c <= 'z';
-}
-
-inline char ascii_toupper(char c) {
-  return ascii_islower(c) ? c - ('a' - 'A') : c;
-}
-
-inline char ascii_tolower(char c) {
-  return ascii_isupper(c) ? c + ('a' - 'A') : c;
-}
-
-inline int hex_digit_to_int(char c) {
-  /* Assume ASCII. */
-  int x = static_cast<unsigned char>(c);
-  if (x > '9') {
-    x += 9;
-  }
-  return x & 0xf;
-}
-
-// ----------------------------------------------------------------------
-// HasPrefixString()
-//    Check if a string begins with a given prefix.
-// StripPrefixString()
-//    Given a string and a putative prefix, returns the string minus the
-//    prefix string if the prefix matches, otherwise the original
-//    string.
-// ----------------------------------------------------------------------
-inline bool HasPrefixString(StringPiece str, StringPiece prefix) {
-  return str.size() >= prefix.size() &&
-         memcmp(str.data(), prefix.data(), prefix.size()) == 0;
-}
-
-inline std::string StripPrefixString(const std::string& str,
-                                     const std::string& prefix) {
-  if (HasPrefixString(str, prefix)) {
-    return str.substr(prefix.size());
-  } else {
-    return str;
-  }
-}
-
-// ----------------------------------------------------------------------
-// HasSuffixString()
-//    Return true if str ends in suffix.
-// StripSuffixString()
-//    Given a string and a putative suffix, returns the string minus the
-//    suffix string if the suffix matches, otherwise the original
-//    string.
-// ----------------------------------------------------------------------
-inline bool HasSuffixString(StringPiece str, StringPiece suffix) {
-  return str.size() >= suffix.size() &&
-         memcmp(str.data() + str.size() - suffix.size(), suffix.data(),
-                suffix.size()) == 0;
-}
-
-inline std::string StripSuffixString(const std::string& str,
-                                     const std::string& suffix) {
-  if (HasSuffixString(str, suffix)) {
-    return str.substr(0, str.size() - suffix.size());
-  } else {
-    return str;
-  }
-}
-
-// ----------------------------------------------------------------------
-// ReplaceCharacters
-//    Replaces any occurrence of the character 'remove' (or the characters
-//    in 'remove') with the character 'replacewith'.
-//    Good for keeping html characters or protocol characters (\t) out
-//    of places where they might cause a problem.
-// StripWhitespace
-//    Removes whitespaces from both ends of the given string.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT void ReplaceCharacters(std::string* s, const char* remove,
-                                       char replacewith);
-
-PROTOBUF_EXPORT void StripWhitespace(std::string* s);
-
-// ----------------------------------------------------------------------
-// LowerString()
-// UpperString()
-// ToUpper()
-//    Convert the characters in "s" to lowercase or uppercase.  ASCII-only:
-//    these functions intentionally ignore locale because they are applied to
-//    identifiers used in the Protocol Buffer language, not to natural-language
-//    strings.
-// ----------------------------------------------------------------------
-
-inline void LowerString(std::string* s) {
-  std::string::iterator end = s->end();
-  for (std::string::iterator i = s->begin(); i != end; ++i) {
-    // tolower() changes based on locale.  We don't want this!
-    if ('A' <= *i && *i <= 'Z') *i += 'a' - 'A';
-  }
-}
-
-inline void UpperString(std::string* s) {
-  std::string::iterator end = s->end();
-  for (std::string::iterator i = s->begin(); i != end; ++i) {
-    // toupper() changes based on locale.  We don't want this!
-    if ('a' <= *i && *i <= 'z') *i += 'A' - 'a';
-  }
-}
-
-inline void ToUpper(std::string* s) { UpperString(s); }
-
-inline std::string ToUpper(const std::string& s) {
-  std::string out = s;
-  UpperString(&out);
-  return out;
-}
-
-// ----------------------------------------------------------------------
-// StringReplace()
-//    Give me a string and two patterns "old" and "new", and I replace
-//    the first instance of "old" in the string with "new", if it
-//    exists.  RETURN a new string, regardless of whether the replacement
-//    happened or not.
-// ----------------------------------------------------------------------
-
-PROTOBUF_EXPORT std::string StringReplace(const std::string& s,
-                                          const std::string& oldsub,
-                                          const std::string& newsub,
-                                          bool replace_all);
-
-// ----------------------------------------------------------------------
-// SplitStringUsing()
-//    Split a string using a character delimiter. Append the components
-//    to 'result'.  If there are consecutive delimiters, this function skips
-//    over all of them.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT void SplitStringUsing(StringPiece full, const char* delim,
-                                      std::vector<std::string>* res);
-
-// Split a string using one or more byte delimiters, presented
-// as a nul-terminated c string. Append the components to 'result'.
-// If there are consecutive delimiters, this function will return
-// corresponding empty strings.  If you want to drop the empty
-// strings, try SplitStringUsing().
-//
-// If "full" is the empty string, yields an empty string as the only value.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT void SplitStringAllowEmpty(StringPiece full, const char* delim,
-                                           std::vector<std::string>* result);
-
-// ----------------------------------------------------------------------
-// Split()
-//    Split a string using a character delimiter.
-// ----------------------------------------------------------------------
-inline std::vector<std::string> Split(StringPiece full, const char* delim,
-                                      bool skip_empty = true) {
-  std::vector<std::string> result;
-  if (skip_empty) {
-    SplitStringUsing(full, delim, &result);
-  } else {
-    SplitStringAllowEmpty(full, delim, &result);
-  }
-  return result;
-}
-
-// ----------------------------------------------------------------------
-// JoinStrings()
-//    These methods concatenate a vector of strings into a C++ string, using
-//    the C-string "delim" as a separator between components. There are two
-//    flavors of the function, one flavor returns the concatenated string,
-//    another takes a pointer to the target string. In the latter case the
-//    target string is cleared and overwritten.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT void JoinStrings(const std::vector<std::string>& components,
-                                 const char* delim, std::string* result);
-
-inline std::string JoinStrings(const std::vector<std::string>& components,
-                               const char* delim) {
-  std::string result;
-  JoinStrings(components, delim, &result);
-  return result;
-}
-
-// ----------------------------------------------------------------------
-// UnescapeCEscapeSequences()
-//    Copies "source" to "dest", rewriting C-style escape sequences
-//    -- '\n', '\r', '\\', '\ooo', etc -- to their ASCII
-//    equivalents.  "dest" must be sufficiently large to hold all
-//    the characters in the rewritten string (i.e. at least as large
-//    as strlen(source) + 1 should be safe, since the replacements
-//    are always shorter than the original escaped sequences).  It's
-//    safe for source and dest to be the same.  RETURNS the length
-//    of dest.
-//
-//    It allows hex sequences \xhh, or generally \xhhhhh with an
-//    arbitrary number of hex digits, but all of them together must
-//    specify a value of a single byte (e.g. \x0045 is equivalent
-//    to \x45, and \x1234 is erroneous).
-//
-//    It also allows escape sequences of the form \uhhhh (exactly four
-//    hex digits, upper or lower case) or \Uhhhhhhhh (exactly eight
-//    hex digits, upper or lower case) to specify a Unicode code
-//    point. The dest array will contain the UTF8-encoded version of
-//    that code-point (e.g., if source contains \u2019, then dest will
-//    contain the three bytes 0xE2, 0x80, and 0x99).
-//
-//    Errors: In the first form of the call, errors are reported with
-//    LOG(ERROR). The same is true for the second form of the call if
-//    the pointer to the string std::vector is nullptr; otherwise, error
-//    messages are stored in the std::vector. In either case, the effect on
-//    the dest array is not defined, but rest of the source will be
-//    processed.
-//    ----------------------------------------------------------------------
-
-PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest);
-PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest,
-                                             std::vector<std::string>* errors);
-
-// ----------------------------------------------------------------------
-// UnescapeCEscapeString()
-//    This does the same thing as UnescapeCEscapeSequences, but creates
-//    a new string. The caller does not need to worry about allocating
-//    a dest buffer. This should be used for non performance critical
-//    tasks such as printing debug messages. It is safe for src and dest
-//    to be the same.
-//
-//    The second call stores its errors in a supplied string vector.
-//    If the string vector pointer is nullptr, it reports the errors with LOG().
-//
-//    In the first and second calls, the length of dest is returned. In the
-//    the third call, the new string is returned.
-// ----------------------------------------------------------------------
-
-PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src,
-                                          std::string* dest);
-PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src,
-                                          std::string* dest,
-                                          std::vector<std::string>* errors);
-PROTOBUF_EXPORT std::string UnescapeCEscapeString(const std::string& src);
-
-// ----------------------------------------------------------------------
-// CEscape()
-//    Escapes 'src' using C-style escape sequences and returns the resulting
-//    string.
-//
-//    Escaped chars: \n, \r, \t, ", ', \, and !isprint().
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT std::string CEscape(const std::string& src);
-
-// ----------------------------------------------------------------------
-// CEscapeAndAppend()
-//    Escapes 'src' using C-style escape sequences, and appends the escaped
-//    string to 'dest'.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT void CEscapeAndAppend(StringPiece src, std::string* dest);
-
-namespace strings {
-// Like CEscape() but does not escape bytes with the upper bit set.
-PROTOBUF_EXPORT std::string Utf8SafeCEscape(const std::string& src);
-
-// Like CEscape() but uses hex (\x) escapes instead of octals.
-PROTOBUF_EXPORT std::string CHexEscape(const std::string& src);
-}  // namespace strings
-
-// ----------------------------------------------------------------------
-// strto32()
-// strtou32()
-// strto64()
-// strtou64()
-//    Architecture-neutral plug compatible replacements for strtol() and
-//    strtoul().  Long's have different lengths on ILP-32 and LP-64
-//    platforms, so using these is safer, from the point of view of
-//    overflow behavior, than using the standard libc functions.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT int32_t strto32_adaptor(const char* nptr, char** endptr,
-                                        int base);
-PROTOBUF_EXPORT uint32_t strtou32_adaptor(const char* nptr, char** endptr,
-                                          int base);
-
-inline int32_t strto32(const char *nptr, char **endptr, int base) {
-  if (sizeof(int32_t) == sizeof(long))
-    return strtol(nptr, endptr, base);
-  else
-    return strto32_adaptor(nptr, endptr, base);
-}
-
-inline uint32_t strtou32(const char *nptr, char **endptr, int base) {
-  if (sizeof(uint32_t) == sizeof(unsigned long))
-    return strtoul(nptr, endptr, base);
-  else
-    return strtou32_adaptor(nptr, endptr, base);
-}
-
-// For now, long long is 64-bit on all the platforms we care about, so these
-// functions can simply pass the call to strto[u]ll.
-inline int64_t strto64(const char *nptr, char **endptr, int base) {
-  static_assert(sizeof(int64_t) == sizeof(long long),
-                "sizeof int64_t is not sizeof long long");
-  return strtoll(nptr, endptr, base);
-}
-
-inline uint64_t strtou64(const char *nptr, char **endptr, int base) {
-  static_assert(sizeof(uint64_t) == sizeof(unsigned long long),
-                "sizeof uint64_t is not sizeof unsigned long long");
-  return strtoull(nptr, endptr, base);
-}
-
-// ----------------------------------------------------------------------
-// safe_strtob()
-// safe_strto32()
-// safe_strtou32()
-// safe_strto64()
-// safe_strtou64()
-// safe_strtof()
-// safe_strtod()
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT bool safe_strtob(StringPiece str, bool* value);
-
-PROTOBUF_EXPORT bool safe_strto32(const std::string& str, int32_t* value);
-PROTOBUF_EXPORT bool safe_strtou32(const std::string& str, uint32_t* value);
-inline bool safe_strto32(const char* str, int32_t* value) {
-  return safe_strto32(std::string(str), value);
-}
-inline bool safe_strto32(StringPiece str, int32_t* value) {
-  return safe_strto32(str.ToString(), value);
-}
-inline bool safe_strtou32(const char* str, uint32_t* value) {
-  return safe_strtou32(std::string(str), value);
-}
-inline bool safe_strtou32(StringPiece str, uint32_t* value) {
-  return safe_strtou32(str.ToString(), value);
-}
-
-PROTOBUF_EXPORT bool safe_strto64(const std::string& str, int64_t* value);
-PROTOBUF_EXPORT bool safe_strtou64(const std::string& str, uint64_t* value);
-inline bool safe_strto64(const char* str, int64_t* value) {
-  return safe_strto64(std::string(str), value);
-}
-inline bool safe_strto64(StringPiece str, int64_t* value) {
-  return safe_strto64(str.ToString(), value);
-}
-inline bool safe_strtou64(const char* str, uint64_t* value) {
-  return safe_strtou64(std::string(str), value);
-}
-inline bool safe_strtou64(StringPiece str, uint64_t* value) {
-  return safe_strtou64(str.ToString(), value);
-}
-
-PROTOBUF_EXPORT bool safe_strtof(const char* str, float* value);
-PROTOBUF_EXPORT bool safe_strtod(const char* str, double* value);
-inline bool safe_strtof(const std::string& str, float* value) {
-  return safe_strtof(str.c_str(), value);
-}
-inline bool safe_strtod(const std::string& str, double* value) {
-  return safe_strtod(str.c_str(), value);
-}
-inline bool safe_strtof(StringPiece str, float* value) {
-  return safe_strtof(str.ToString(), value);
-}
-inline bool safe_strtod(StringPiece str, double* value) {
-  return safe_strtod(str.ToString(), value);
-}
-
-// ----------------------------------------------------------------------
-// FastIntToBuffer()
-// FastHexToBuffer()
-// FastHex64ToBuffer()
-// FastHex32ToBuffer()
-// FastTimeToBuffer()
-//    These are intended for speed.  FastIntToBuffer() assumes the
-//    integer is non-negative.  FastHexToBuffer() puts output in
-//    hex rather than decimal.  FastTimeToBuffer() puts the output
-//    into RFC822 format.
-//
-//    FastHex64ToBuffer() puts a 64-bit unsigned value in hex-format,
-//    padded to exactly 16 bytes (plus one byte for '\0')
-//
-//    FastHex32ToBuffer() puts a 32-bit unsigned value in hex-format,
-//    padded to exactly 8 bytes (plus one byte for '\0')
-//
-//       All functions take the output buffer as an arg.
-//    They all return a pointer to the beginning of the output,
-//    which may not be the beginning of the input buffer.
-// ----------------------------------------------------------------------
-
-// Suggested buffer size for FastToBuffer functions.  Also works with
-// DoubleToBuffer() and FloatToBuffer().
-static const int kFastToBufferSize = 32;
-
-PROTOBUF_EXPORT char* FastInt32ToBuffer(int32_t i, char* buffer);
-PROTOBUF_EXPORT char* FastInt64ToBuffer(int64_t i, char* buffer);
-char* FastUInt32ToBuffer(uint32_t i, char* buffer);  // inline below
-char* FastUInt64ToBuffer(uint64_t i, char* buffer);  // inline below
-PROTOBUF_EXPORT char* FastHexToBuffer(int i, char* buffer);
-PROTOBUF_EXPORT char* FastHex64ToBuffer(uint64_t i, char* buffer);
-PROTOBUF_EXPORT char* FastHex32ToBuffer(uint32_t i, char* buffer);
-
-// at least 22 bytes long
-inline char* FastIntToBuffer(int i, char* buffer) {
-  return (sizeof(i) == 4 ?
-          FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
-}
-inline char* FastUIntToBuffer(unsigned int i, char* buffer) {
-  return (sizeof(i) == 4 ?
-          FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
-}
-inline char* FastLongToBuffer(long i, char* buffer) {
-  return (sizeof(i) == 4 ?
-          FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
-}
-inline char* FastULongToBuffer(unsigned long i, char* buffer) {
-  return (sizeof(i) == 4 ?
-          FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
-}
-
-// ----------------------------------------------------------------------
-// FastInt32ToBufferLeft()
-// FastUInt32ToBufferLeft()
-// FastInt64ToBufferLeft()
-// FastUInt64ToBufferLeft()
-//
-// Like the Fast*ToBuffer() functions above, these are intended for speed.
-// Unlike the Fast*ToBuffer() functions, however, these functions write
-// their output to the beginning of the buffer (hence the name, as the
-// output is left-aligned).  The caller is responsible for ensuring that
-// the buffer has enough space to hold the output.
-//
-// Returns a pointer to the end of the string (i.e. the null character
-// terminating the string).
-// ----------------------------------------------------------------------
-
-PROTOBUF_EXPORT char* FastInt32ToBufferLeft(int32_t i, char* buffer);
-PROTOBUF_EXPORT char* FastUInt32ToBufferLeft(uint32_t i, char* buffer);
-PROTOBUF_EXPORT char* FastInt64ToBufferLeft(int64_t i, char* buffer);
-PROTOBUF_EXPORT char* FastUInt64ToBufferLeft(uint64_t i, char* buffer);
-
-// Just define these in terms of the above.
-inline char* FastUInt32ToBuffer(uint32_t i, char* buffer) {
-  FastUInt32ToBufferLeft(i, buffer);
-  return buffer;
-}
-inline char* FastUInt64ToBuffer(uint64_t i, char* buffer) {
-  FastUInt64ToBufferLeft(i, buffer);
-  return buffer;
-}
-
-inline std::string SimpleBtoa(bool value) { return value ? "true" : "false"; }
-
-// ----------------------------------------------------------------------
-// SimpleItoa()
-//    Description: converts an integer to a string.
-//
-//    Return value: string
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT std::string SimpleItoa(int i);
-PROTOBUF_EXPORT std::string SimpleItoa(unsigned int i);
-PROTOBUF_EXPORT std::string SimpleItoa(long i);
-PROTOBUF_EXPORT std::string SimpleItoa(unsigned long i);
-PROTOBUF_EXPORT std::string SimpleItoa(long long i);
-PROTOBUF_EXPORT std::string SimpleItoa(unsigned long long i);
-
-// ----------------------------------------------------------------------
-// SimpleDtoa()
-// SimpleFtoa()
-// DoubleToBuffer()
-// FloatToBuffer()
-//    Description: converts a double or float to a string which, if
-//    passed to NoLocaleStrtod(), will produce the exact same original double
-//    (except in case of NaN; all NaNs are considered the same value).
-//    We try to keep the string short but it's not guaranteed to be as
-//    short as possible.
-//
-//    DoubleToBuffer() and FloatToBuffer() write the text to the given
-//    buffer and return it.  The buffer must be at least
-//    kDoubleToBufferSize bytes for doubles and kFloatToBufferSize
-//    bytes for floats.  kFastToBufferSize is also guaranteed to be large
-//    enough to hold either.
-//
-//    Return value: string
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT std::string SimpleDtoa(double value);
-PROTOBUF_EXPORT std::string SimpleFtoa(float value);
-
-PROTOBUF_EXPORT char* DoubleToBuffer(double i, char* buffer);
-PROTOBUF_EXPORT char* FloatToBuffer(float i, char* buffer);
-
-// In practice, doubles should never need more than 24 bytes and floats
-// should never need more than 14 (including null terminators), but we
-// overestimate to be safe.
-static const int kDoubleToBufferSize = 32;
-static const int kFloatToBufferSize = 24;
-
-namespace strings {
-
-enum PadSpec {
-  NO_PAD = 1,
-  ZERO_PAD_2,
-  ZERO_PAD_3,
-  ZERO_PAD_4,
-  ZERO_PAD_5,
-  ZERO_PAD_6,
-  ZERO_PAD_7,
-  ZERO_PAD_8,
-  ZERO_PAD_9,
-  ZERO_PAD_10,
-  ZERO_PAD_11,
-  ZERO_PAD_12,
-  ZERO_PAD_13,
-  ZERO_PAD_14,
-  ZERO_PAD_15,
-  ZERO_PAD_16,
-};
-
-struct Hex {
-  uint64_t value;
-  enum PadSpec spec;
-  template <class Int>
-  explicit Hex(Int v, PadSpec s = NO_PAD)
-      : spec(s) {
-    // Prevent sign-extension by casting integers to
-    // their unsigned counterparts.
+        // ----------------------------------------------------------------------
+        // ascii_isalnum()
+        //    Check if an ASCII character is alphanumeric.  We can't use ctype's
+        //    isalnum() because it is affected by locale.  This function is applied
+        //    to identifiers in the protocol buffer language, not to natural-language
+        //    strings, so locale should not be taken into account.
+        // ascii_isdigit()
+        //    Like above, but only accepts digits.
+        // ascii_isspace()
+        //    Check if the character is a space character.
+        // ----------------------------------------------------------------------
+
+        inline bool ascii_isalnum(char c)
+        {
+            return ('a' <= c && c <= 'z') ||
+                   ('A' <= c && c <= 'Z') ||
+                   ('0' <= c && c <= '9');
+        }
+
+        inline bool ascii_isdigit(char c)
+        {
+            return ('0' <= c && c <= '9');
+        }
+
+        inline bool ascii_isspace(char c)
+        {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' ||
+                   c == '\r';
+        }
+
+        inline bool ascii_isupper(char c)
+        {
+            return c >= 'A' && c <= 'Z';
+        }
+
+        inline bool ascii_islower(char c)
+        {
+            return c >= 'a' && c <= 'z';
+        }
+
+        inline char ascii_toupper(char c)
+        {
+            return ascii_islower(c) ? c - ('a' - 'A') : c;
+        }
+
+        inline char ascii_tolower(char c)
+        {
+            return ascii_isupper(c) ? c + ('a' - 'A') : c;
+        }
+
+        inline int hex_digit_to_int(char c)
+        {
+            /* Assume ASCII. */
+            int x = static_cast<unsigned char>(c);
+            if (x > '9')
+            {
+                x += 9;
+            }
+            return x & 0xf;
+        }
+
+        // ----------------------------------------------------------------------
+        // HasPrefixString()
+        //    Check if a string begins with a given prefix.
+        // StripPrefixString()
+        //    Given a string and a putative prefix, returns the string minus the
+        //    prefix string if the prefix matches, otherwise the original
+        //    string.
+        // ----------------------------------------------------------------------
+        inline bool HasPrefixString(StringPiece str, StringPiece prefix)
+        {
+            return str.size() >= prefix.size() &&
+                   memcmp(str.data(), prefix.data(), prefix.size()) == 0;
+        }
+
+        inline std::string StripPrefixString(const std::string& str, const std::string& prefix)
+        {
+            if (HasPrefixString(str, prefix))
+            {
+                return str.substr(prefix.size());
+            }
+            else
+            {
+                return str;
+            }
+        }
+
+        // ----------------------------------------------------------------------
+        // HasSuffixString()
+        //    Return true if str ends in suffix.
+        // StripSuffixString()
+        //    Given a string and a putative suffix, returns the string minus the
+        //    suffix string if the suffix matches, otherwise the original
+        //    string.
+        // ----------------------------------------------------------------------
+        inline bool HasSuffixString(StringPiece str, StringPiece suffix)
+        {
+            return str.size() >= suffix.size() &&
+                   memcmp(str.data() + str.size() - suffix.size(), suffix.data(), suffix.size()) == 0;
+        }
+
+        inline std::string StripSuffixString(const std::string& str, const std::string& suffix)
+        {
+            if (HasSuffixString(str, suffix))
+            {
+                return str.substr(0, str.size() - suffix.size());
+            }
+            else
+            {
+                return str;
+            }
+        }
+
+        // ----------------------------------------------------------------------
+        // ReplaceCharacters
+        //    Replaces any occurrence of the character 'remove' (or the characters
+        //    in 'remove') with the character 'replacewith'.
+        //    Good for keeping html characters or protocol characters (\t) out
+        //    of places where they might cause a problem.
+        // StripWhitespace
+        //    Removes whitespaces from both ends of the given string.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT void ReplaceCharacters(std::string* s, const char* remove, char replacewith);
+
+        PROTOBUF_EXPORT void StripWhitespace(std::string* s);
+
+        // ----------------------------------------------------------------------
+        // LowerString()
+        // UpperString()
+        // ToUpper()
+        //    Convert the characters in "s" to lowercase or uppercase.  ASCII-only:
+        //    these functions intentionally ignore locale because they are applied to
+        //    identifiers used in the Protocol Buffer language, not to natural-language
+        //    strings.
+        // ----------------------------------------------------------------------
+
+        inline void LowerString(std::string* s)
+        {
+            std::string::iterator end = s->end();
+            for (std::string::iterator i = s->begin(); i != end; ++i)
+            {
+                // tolower() changes based on locale.  We don't want this!
+                if ('A' <= *i && *i <= 'Z')
+                    *i += 'a' - 'A';
+            }
+        }
+
+        inline void UpperString(std::string* s)
+        {
+            std::string::iterator end = s->end();
+            for (std::string::iterator i = s->begin(); i != end; ++i)
+            {
+                // toupper() changes based on locale.  We don't want this!
+                if ('a' <= *i && *i <= 'z')
+                    *i += 'A' - 'a';
+            }
+        }
+
+        inline void ToUpper(std::string* s)
+        {
+            UpperString(s);
+        }
+
+        inline std::string ToUpper(const std::string& s)
+        {
+            std::string out = s;
+            UpperString(&out);
+            return out;
+        }
+
+        // ----------------------------------------------------------------------
+        // StringReplace()
+        //    Give me a string and two patterns "old" and "new", and I replace
+        //    the first instance of "old" in the string with "new", if it
+        //    exists.  RETURN a new string, regardless of whether the replacement
+        //    happened or not.
+        // ----------------------------------------------------------------------
+
+        PROTOBUF_EXPORT std::string StringReplace(const std::string& s, const std::string& oldsub, const std::string& newsub, bool replace_all);
+
+        // ----------------------------------------------------------------------
+        // SplitStringUsing()
+        //    Split a string using a character delimiter. Append the components
+        //    to 'result'.  If there are consecutive delimiters, this function skips
+        //    over all of them.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT void SplitStringUsing(StringPiece full, const char* delim, std::vector<std::string>* res);
+
+        // Split a string using one or more byte delimiters, presented
+        // as a nul-terminated c string. Append the components to 'result'.
+        // If there are consecutive delimiters, this function will return
+        // corresponding empty strings.  If you want to drop the empty
+        // strings, try SplitStringUsing().
+        //
+        // If "full" is the empty string, yields an empty string as the only value.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT void SplitStringAllowEmpty(StringPiece full, const char* delim, std::vector<std::string>* result);
+
+        // ----------------------------------------------------------------------
+        // Split()
+        //    Split a string using a character delimiter.
+        // ----------------------------------------------------------------------
+        inline std::vector<std::string> Split(StringPiece full, const char* delim, bool skip_empty = true)
+        {
+            std::vector<std::string> result;
+            if (skip_empty)
+            {
+                SplitStringUsing(full, delim, &result);
+            }
+            else
+            {
+                SplitStringAllowEmpty(full, delim, &result);
+            }
+            return result;
+        }
+
+        // ----------------------------------------------------------------------
+        // JoinStrings()
+        //    These methods concatenate a vector of strings into a C++ string, using
+        //    the C-string "delim" as a separator between components. There are two
+        //    flavors of the function, one flavor returns the concatenated string,
+        //    another takes a pointer to the target string. In the latter case the
+        //    target string is cleared and overwritten.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT void JoinStrings(const std::vector<std::string>& components, const char* delim, std::string* result);
+
+        inline std::string JoinStrings(const std::vector<std::string>& components, const char* delim)
+        {
+            std::string result;
+            JoinStrings(components, delim, &result);
+            return result;
+        }
+
+        // ----------------------------------------------------------------------
+        // UnescapeCEscapeSequences()
+        //    Copies "source" to "dest", rewriting C-style escape sequences
+        //    -- '\n', '\r', '\\', '\ooo', etc -- to their ASCII
+        //    equivalents.  "dest" must be sufficiently large to hold all
+        //    the characters in the rewritten string (i.e. at least as large
+        //    as strlen(source) + 1 should be safe, since the replacements
+        //    are always shorter than the original escaped sequences).  It's
+        //    safe for source and dest to be the same.  RETURNS the length
+        //    of dest.
+        //
+        //    It allows hex sequences \xhh, or generally \xhhhhh with an
+        //    arbitrary number of hex digits, but all of them together must
+        //    specify a value of a single byte (e.g. \x0045 is equivalent
+        //    to \x45, and \x1234 is erroneous).
+        //
+        //    It also allows escape sequences of the form \uhhhh (exactly four
+        //    hex digits, upper or lower case) or \Uhhhhhhhh (exactly eight
+        //    hex digits, upper or lower case) to specify a Unicode code
+        //    point. The dest array will contain the UTF8-encoded version of
+        //    that code-point (e.g., if source contains \u2019, then dest will
+        //    contain the three bytes 0xE2, 0x80, and 0x99).
+        //
+        //    Errors: In the first form of the call, errors are reported with
+        //    LOG(ERROR). The same is true for the second form of the call if
+        //    the pointer to the string std::vector is nullptr; otherwise, error
+        //    messages are stored in the std::vector. In either case, the effect on
+        //    the dest array is not defined, but rest of the source will be
+        //    processed.
+        //    ----------------------------------------------------------------------
+
+        PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest);
+        PROTOBUF_EXPORT int UnescapeCEscapeSequences(const char* source, char* dest, std::vector<std::string>* errors);
+
+        // ----------------------------------------------------------------------
+        // UnescapeCEscapeString()
+        //    This does the same thing as UnescapeCEscapeSequences, but creates
+        //    a new string. The caller does not need to worry about allocating
+        //    a dest buffer. This should be used for non performance critical
+        //    tasks such as printing debug messages. It is safe for src and dest
+        //    to be the same.
+        //
+        //    The second call stores its errors in a supplied string vector.
+        //    If the string vector pointer is nullptr, it reports the errors with LOG().
+        //
+        //    In the first and second calls, the length of dest is returned. In the
+        //    the third call, the new string is returned.
+        // ----------------------------------------------------------------------
+
+        PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src, std::string* dest);
+        PROTOBUF_EXPORT int UnescapeCEscapeString(const std::string& src, std::string* dest, std::vector<std::string>* errors);
+        PROTOBUF_EXPORT std::string UnescapeCEscapeString(const std::string& src);
+
+        // ----------------------------------------------------------------------
+        // CEscape()
+        //    Escapes 'src' using C-style escape sequences and returns the resulting
+        //    string.
+        //
+        //    Escaped chars: \n, \r, \t, ", ', \, and !isprint().
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT std::string CEscape(const std::string& src);
+
+        // ----------------------------------------------------------------------
+        // CEscapeAndAppend()
+        //    Escapes 'src' using C-style escape sequences, and appends the escaped
+        //    string to 'dest'.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT void CEscapeAndAppend(StringPiece src, std::string* dest);
+
+        namespace strings
+        {
+            // Like CEscape() but does not escape bytes with the upper bit set.
+            PROTOBUF_EXPORT std::string Utf8SafeCEscape(const std::string& src);
+
+            // Like CEscape() but uses hex (\x) escapes instead of octals.
+            PROTOBUF_EXPORT std::string CHexEscape(const std::string& src);
+        }  // namespace strings
+
+        // ----------------------------------------------------------------------
+        // strto32()
+        // strtou32()
+        // strto64()
+        // strtou64()
+        //    Architecture-neutral plug compatible replacements for strtol() and
+        //    strtoul().  Long's have different lengths on ILP-32 and LP-64
+        //    platforms, so using these is safer, from the point of view of
+        //    overflow behavior, than using the standard libc functions.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT int32_t strto32_adaptor(const char* nptr, char** endptr, int base);
+        PROTOBUF_EXPORT uint32_t strtou32_adaptor(const char* nptr, char** endptr, int base);
+
+        inline int32_t strto32(const char* nptr, char** endptr, int base)
+        {
+            if (sizeof(int32_t) == sizeof(long))
+                return strtol(nptr, endptr, base);
+            else
+                return strto32_adaptor(nptr, endptr, base);
+        }
+
+        inline uint32_t strtou32(const char* nptr, char** endptr, int base)
+        {
+            if (sizeof(uint32_t) == sizeof(unsigned long))
+                return strtoul(nptr, endptr, base);
+            else
+                return strtou32_adaptor(nptr, endptr, base);
+        }
+
+        // For now, long long is 64-bit on all the platforms we care about, so these
+        // functions can simply pass the call to strto[u]ll.
+        inline int64_t strto64(const char* nptr, char** endptr, int base)
+        {
+            static_assert(sizeof(int64_t) == sizeof(long long), "sizeof int64_t is not sizeof long long");
+            return strtoll(nptr, endptr, base);
+        }
+
+        inline uint64_t strtou64(const char* nptr, char** endptr, int base)
+        {
+            static_assert(sizeof(uint64_t) == sizeof(unsigned long long), "sizeof uint64_t is not sizeof unsigned long long");
+            return strtoull(nptr, endptr, base);
+        }
+
+        // ----------------------------------------------------------------------
+        // safe_strtob()
+        // safe_strto32()
+        // safe_strtou32()
+        // safe_strto64()
+        // safe_strtou64()
+        // safe_strtof()
+        // safe_strtod()
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT bool safe_strtob(StringPiece str, bool* value);
+
+        PROTOBUF_EXPORT bool safe_strto32(const std::string& str, int32_t* value);
+        PROTOBUF_EXPORT bool safe_strtou32(const std::string& str, uint32_t* value);
+        inline bool safe_strto32(const char* str, int32_t* value)
+        {
+            return safe_strto32(std::string(str), value);
+        }
+        inline bool safe_strto32(StringPiece str, int32_t* value)
+        {
+            return safe_strto32(str.ToString(), value);
+        }
+        inline bool safe_strtou32(const char* str, uint32_t* value)
+        {
+            return safe_strtou32(std::string(str), value);
+        }
+        inline bool safe_strtou32(StringPiece str, uint32_t* value)
+        {
+            return safe_strtou32(str.ToString(), value);
+        }
+
+        PROTOBUF_EXPORT bool safe_strto64(const std::string& str, int64_t* value);
+        PROTOBUF_EXPORT bool safe_strtou64(const std::string& str, uint64_t* value);
+        inline bool safe_strto64(const char* str, int64_t* value)
+        {
+            return safe_strto64(std::string(str), value);
+        }
+        inline bool safe_strto64(StringPiece str, int64_t* value)
+        {
+            return safe_strto64(str.ToString(), value);
+        }
+        inline bool safe_strtou64(const char* str, uint64_t* value)
+        {
+            return safe_strtou64(std::string(str), value);
+        }
+        inline bool safe_strtou64(StringPiece str, uint64_t* value)
+        {
+            return safe_strtou64(str.ToString(), value);
+        }
+
+        PROTOBUF_EXPORT bool safe_strtof(const char* str, float* value);
+        PROTOBUF_EXPORT bool safe_strtod(const char* str, double* value);
+        inline bool safe_strtof(const std::string& str, float* value)
+        {
+            return safe_strtof(str.c_str(), value);
+        }
+        inline bool safe_strtod(const std::string& str, double* value)
+        {
+            return safe_strtod(str.c_str(), value);
+        }
+        inline bool safe_strtof(StringPiece str, float* value)
+        {
+            return safe_strtof(str.ToString(), value);
+        }
+        inline bool safe_strtod(StringPiece str, double* value)
+        {
+            return safe_strtod(str.ToString(), value);
+        }
+
+        // ----------------------------------------------------------------------
+        // FastIntToBuffer()
+        // FastHexToBuffer()
+        // FastHex64ToBuffer()
+        // FastHex32ToBuffer()
+        // FastTimeToBuffer()
+        //    These are intended for speed.  FastIntToBuffer() assumes the
+        //    integer is non-negative.  FastHexToBuffer() puts output in
+        //    hex rather than decimal.  FastTimeToBuffer() puts the output
+        //    into RFC822 format.
+        //
+        //    FastHex64ToBuffer() puts a 64-bit unsigned value in hex-format,
+        //    padded to exactly 16 bytes (plus one byte for '\0')
+        //
+        //    FastHex32ToBuffer() puts a 32-bit unsigned value in hex-format,
+        //    padded to exactly 8 bytes (plus one byte for '\0')
+        //
+        //       All functions take the output buffer as an arg.
+        //    They all return a pointer to the beginning of the output,
+        //    which may not be the beginning of the input buffer.
+        // ----------------------------------------------------------------------
+
+        // Suggested buffer size for FastToBuffer functions.  Also works with
+        // DoubleToBuffer() and FloatToBuffer().
+        static const int kFastToBufferSize = 32;
+
+        PROTOBUF_EXPORT char* FastInt32ToBuffer(int32_t i, char* buffer);
+        PROTOBUF_EXPORT char* FastInt64ToBuffer(int64_t i, char* buffer);
+        char* FastUInt32ToBuffer(uint32_t i, char* buffer);  // inline below
+        char* FastUInt64ToBuffer(uint64_t i, char* buffer);  // inline below
+        PROTOBUF_EXPORT char* FastHexToBuffer(int i, char* buffer);
+        PROTOBUF_EXPORT char* FastHex64ToBuffer(uint64_t i, char* buffer);
+        PROTOBUF_EXPORT char* FastHex32ToBuffer(uint32_t i, char* buffer);
+
+        // at least 22 bytes long
+        inline char* FastIntToBuffer(int i, char* buffer)
+        {
+            return (sizeof(i) == 4 ? FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
+        }
+        inline char* FastUIntToBuffer(unsigned int i, char* buffer)
+        {
+            return (sizeof(i) == 4 ? FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
+        }
+        inline char* FastLongToBuffer(long i, char* buffer)
+        {
+            return (sizeof(i) == 4 ? FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
+        }
+        inline char* FastULongToBuffer(unsigned long i, char* buffer)
+        {
+            return (sizeof(i) == 4 ? FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
+        }
+
+        // ----------------------------------------------------------------------
+        // FastInt32ToBufferLeft()
+        // FastUInt32ToBufferLeft()
+        // FastInt64ToBufferLeft()
+        // FastUInt64ToBufferLeft()
+        //
+        // Like the Fast*ToBuffer() functions above, these are intended for speed.
+        // Unlike the Fast*ToBuffer() functions, however, these functions write
+        // their output to the beginning of the buffer (hence the name, as the
+        // output is left-aligned).  The caller is responsible for ensuring that
+        // the buffer has enough space to hold the output.
+        //
+        // Returns a pointer to the end of the string (i.e. the null character
+        // terminating the string).
+        // ----------------------------------------------------------------------
+
+        PROTOBUF_EXPORT char* FastInt32ToBufferLeft(int32_t i, char* buffer);
+        PROTOBUF_EXPORT char* FastUInt32ToBufferLeft(uint32_t i, char* buffer);
+        PROTOBUF_EXPORT char* FastInt64ToBufferLeft(int64_t i, char* buffer);
+        PROTOBUF_EXPORT char* FastUInt64ToBufferLeft(uint64_t i, char* buffer);
+
+        // Just define these in terms of the above.
+        inline char* FastUInt32ToBuffer(uint32_t i, char* buffer)
+        {
+            FastUInt32ToBufferLeft(i, buffer);
+            return buffer;
+        }
+        inline char* FastUInt64ToBuffer(uint64_t i, char* buffer)
+        {
+            FastUInt64ToBufferLeft(i, buffer);
+            return buffer;
+        }
+
+        inline std::string SimpleBtoa(bool value)
+        {
+            return value ? "true" : "false";
+        }
+
+        // ----------------------------------------------------------------------
+        // SimpleItoa()
+        //    Description: converts an integer to a string.
+        //
+        //    Return value: string
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT std::string SimpleItoa(int i);
+        PROTOBUF_EXPORT std::string SimpleItoa(unsigned int i);
+        PROTOBUF_EXPORT std::string SimpleItoa(long i);
+        PROTOBUF_EXPORT std::string SimpleItoa(unsigned long i);
+        PROTOBUF_EXPORT std::string SimpleItoa(long long i);
+        PROTOBUF_EXPORT std::string SimpleItoa(unsigned long long i);
+
+        // ----------------------------------------------------------------------
+        // SimpleDtoa()
+        // SimpleFtoa()
+        // DoubleToBuffer()
+        // FloatToBuffer()
+        //    Description: converts a double or float to a string which, if
+        //    passed to NoLocaleStrtod(), will produce the exact same original double
+        //    (except in case of NaN; all NaNs are considered the same value).
+        //    We try to keep the string short but it's not guaranteed to be as
+        //    short as possible.
+        //
+        //    DoubleToBuffer() and FloatToBuffer() write the text to the given
+        //    buffer and return it.  The buffer must be at least
+        //    kDoubleToBufferSize bytes for doubles and kFloatToBufferSize
+        //    bytes for floats.  kFastToBufferSize is also guaranteed to be large
+        //    enough to hold either.
+        //
+        //    Return value: string
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT std::string SimpleDtoa(double value);
+        PROTOBUF_EXPORT std::string SimpleFtoa(float value);
+
+        PROTOBUF_EXPORT char* DoubleToBuffer(double i, char* buffer);
+        PROTOBUF_EXPORT char* FloatToBuffer(float i, char* buffer);
+
+        // In practice, doubles should never need more than 24 bytes and floats
+        // should never need more than 14 (including null terminators), but we
+        // overestimate to be safe.
+        static const int kDoubleToBufferSize = 32;
+        static const int kFloatToBufferSize = 24;
+
+        namespace strings
+        {
+
+            enum PadSpec
+            {
+                NO_PAD = 1,
+                ZERO_PAD_2,
+                ZERO_PAD_3,
+                ZERO_PAD_4,
+                ZERO_PAD_5,
+                ZERO_PAD_6,
+                ZERO_PAD_7,
+                ZERO_PAD_8,
+                ZERO_PAD_9,
+                ZERO_PAD_10,
+                ZERO_PAD_11,
+                ZERO_PAD_12,
+                ZERO_PAD_13,
+                ZERO_PAD_14,
+                ZERO_PAD_15,
+                ZERO_PAD_16,
+            };
+
+            struct Hex
+            {
+                uint64_t value;
+                enum PadSpec spec;
+                template<class Int>
+                explicit Hex(Int v, PadSpec s = NO_PAD) :
+                    spec(s)
+                {
+                    // Prevent sign-extension by casting integers to
+                    // their unsigned counterparts.
 #ifdef LANG_CXX11
-    static_assert(
-        sizeof(v) == 1 || sizeof(v) == 2 || sizeof(v) == 4 || sizeof(v) == 8,
-        "Unknown integer type");
+                    static_assert(
+                        sizeof(v) == 1 || sizeof(v) == 2 || sizeof(v) == 4 || sizeof(v) == 8,
+                        "Unknown integer type"
+                    );
 #endif
-    value = sizeof(v) == 1 ? static_cast<uint8_t>(v)
-          : sizeof(v) == 2 ? static_cast<uint16_t>(v)
-          : sizeof(v) == 4 ? static_cast<uint32_t>(v)
-          : static_cast<uint64_t>(v);
-  }
-};
-
-struct PROTOBUF_EXPORT AlphaNum {
-  const char *piece_data_;  // move these to string_ref eventually
-  size_t piece_size_;       // move these to string_ref eventually
-
-  char digits[kFastToBufferSize];
-
-  // No bool ctor -- bools convert to an integral type.
-  // A bool ctor would also convert incoming pointers (bletch).
-
-  AlphaNum(int i32)
-      : piece_data_(digits),
-        piece_size_(FastInt32ToBufferLeft(i32, digits) - &digits[0]) {}
-  AlphaNum(unsigned int u32)
-      : piece_data_(digits),
-        piece_size_(FastUInt32ToBufferLeft(u32, digits) - &digits[0]) {}
-  AlphaNum(long long i64)
-      : piece_data_(digits),
-        piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {}
-  AlphaNum(unsigned long long u64)
-      : piece_data_(digits),
-        piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0]) {}
-
-  // Note: on some architectures, "long" is only 32 bits, not 64, but the
-  // performance hit of using FastInt64ToBufferLeft to handle 32-bit values
-  // is quite minor.
-  AlphaNum(long i64)
-      : piece_data_(digits),
-        piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0]) {}
-  AlphaNum(unsigned long u64)
-      : piece_data_(digits),
-        piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0]) {}
-
-  AlphaNum(float f)
-    : piece_data_(digits), piece_size_(strlen(FloatToBuffer(f, digits))) {}
-  AlphaNum(double f)
-    : piece_data_(digits), piece_size_(strlen(DoubleToBuffer(f, digits))) {}
-
-  AlphaNum(Hex hex);
-
-  AlphaNum(const char* c_str)
-      : piece_data_(c_str), piece_size_(strlen(c_str)) {}
-  // TODO: Add a string_ref constructor, eventually
-  // AlphaNum(const StringPiece &pc) : piece(pc) {}
-
-  AlphaNum(const std::string& str)
-      : piece_data_(str.data()), piece_size_(str.size()) {}
-
-  AlphaNum(StringPiece str)
-      : piece_data_(str.data()), piece_size_(str.size()) {}
-
-  size_t size() const { return piece_size_; }
-  const char *data() const { return piece_data_; }
-
- private:
-  // Use ":" not ':'
-  AlphaNum(char c);  // NOLINT(runtime/explicit)
-
-  // Disallow copy and assign.
-  AlphaNum(const AlphaNum&);
-  void operator=(const AlphaNum&);
-};
-
-}  // namespace strings
-
-using strings::AlphaNum;
-
-// ----------------------------------------------------------------------
-// StrCat()
-//    This merges the given strings or numbers, with no delimiter.  This
-//    is designed to be the fastest possible way to construct a string out
-//    of a mix of raw C strings, strings, bool values,
-//    and numeric values.
-//
-//    Don't use this for user-visible strings.  The localization process
-//    works poorly on strings built up out of fragments.
-//
-//    For clarity and performance, don't use StrCat when appending to a
-//    string.  In particular, avoid using any of these (anti-)patterns:
-//      str.append(StrCat(...)
-//      str += StrCat(...)
-//      str = StrCat(str, ...)
-//    where the last is the worse, with the potential to change a loop
-//    from a linear time operation with O(1) dynamic allocations into a
-//    quadratic time operation with O(n) dynamic allocations.  StrAppend
-//    is a better choice than any of the above, subject to the restriction
-//    of StrAppend(&str, a, b, c, ...) that none of the a, b, c, ... may
-//    be a reference into str.
-// ----------------------------------------------------------------------
-
-PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b);
-PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                   const AlphaNum& c);
-PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                   const AlphaNum& c, const AlphaNum& d);
-PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                   const AlphaNum& c, const AlphaNum& d,
-                                   const AlphaNum& e);
-PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                   const AlphaNum& c, const AlphaNum& d,
-                                   const AlphaNum& e, const AlphaNum& f);
-PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                   const AlphaNum& c, const AlphaNum& d,
-                                   const AlphaNum& e, const AlphaNum& f,
-                                   const AlphaNum& g);
-PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                   const AlphaNum& c, const AlphaNum& d,
-                                   const AlphaNum& e, const AlphaNum& f,
-                                   const AlphaNum& g, const AlphaNum& h);
-PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
-                                   const AlphaNum& c, const AlphaNum& d,
-                                   const AlphaNum& e, const AlphaNum& f,
-                                   const AlphaNum& g, const AlphaNum& h,
-                                   const AlphaNum& i);
-
-inline std::string StrCat(const AlphaNum& a) {
-  return std::string(a.data(), a.size());
-}
-
-// ----------------------------------------------------------------------
-// StrAppend()
-//    Same as above, but adds the output to the given string.
-//    WARNING: For speed, StrAppend does not try to check each of its input
-//    arguments to be sure that they are not a subset of the string being
-//    appended to.  That is, while this will work:
-//
-//    string s = "foo";
-//    s += s;
-//
-//    This will not (necessarily) work:
-//
-//    string s = "foo";
-//    StrAppend(&s, s);
-//
-//    Note: while StrCat supports appending up to 9 arguments, StrAppend
-//    is currently limited to 4.  That's rarely an issue except when
-//    automatically transforming StrCat to StrAppend, and can easily be
-//    worked around as consecutive calls to StrAppend are quite efficient.
-// ----------------------------------------------------------------------
-
-PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a);
-PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a,
-                               const AlphaNum& b);
-PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a,
-                               const AlphaNum& b, const AlphaNum& c);
-PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a,
-                               const AlphaNum& b, const AlphaNum& c,
-                               const AlphaNum& d);
-
-// ----------------------------------------------------------------------
-// Join()
-//    These methods concatenate a range of components into a C++ string, using
-//    the C-string "delim" as a separator between components.
-// ----------------------------------------------------------------------
-template <typename Iterator>
-void Join(Iterator start, Iterator end, const char* delim,
-          std::string* result) {
-  for (Iterator it = start; it != end; ++it) {
-    if (it != start) {
-      result->append(delim);
-    }
-    StrAppend(result, *it);
-  }
-}
-
-template <typename Range>
-std::string Join(const Range& components, const char* delim) {
-  std::string result;
-  Join(components.begin(), components.end(), delim, &result);
-  return result;
-}
-
-// ----------------------------------------------------------------------
-// ToHex()
-//    Return a lower-case hex string representation of the given integer.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT std::string ToHex(uint64_t num);
-
-// ----------------------------------------------------------------------
-// GlobalReplaceSubstring()
-//    Replaces all instances of a substring in a string.  Does nothing
-//    if 'substring' is empty.  Returns the number of replacements.
-//
-//    NOTE: The string pieces must not overlap s.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT int GlobalReplaceSubstring(const std::string& substring,
-                                           const std::string& replacement,
-                                           std::string* s);
-
-// ----------------------------------------------------------------------
-// Base64Unescape()
-//    Converts "src" which is encoded in Base64 to its binary equivalent and
-//    writes it to "dest". If src contains invalid characters, dest is cleared
-//    and the function returns false. Returns true on success.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT bool Base64Unescape(StringPiece src, std::string* dest);
-
-// ----------------------------------------------------------------------
-// WebSafeBase64Unescape()
-//    This is a variation of Base64Unescape which uses '-' instead of '+', and
-//    '_' instead of '/'. src is not null terminated, instead specify len. I
-//    recommend that slen<szdest, but we honor szdest anyway.
-//    RETURNS the length of dest, or -1 if src contains invalid chars.
-
-//    The variation that stores into a string clears the string first, and
-//    returns false (with dest empty) if src contains invalid chars; for
-//    this version src and dest must be different strings.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT int WebSafeBase64Unescape(const char* src, int slen, char* dest,
-                                          int szdest);
-PROTOBUF_EXPORT bool WebSafeBase64Unescape(StringPiece src, std::string* dest);
-
-// Return the length to use for the output buffer given to the base64 escape
-// routines. Make sure to use the same value for do_padding in both.
-// This function may return incorrect results if given input_len values that
-// are extremely high, which should happen rarely.
-PROTOBUF_EXPORT int CalculateBase64EscapedLen(int input_len, bool do_padding);
-// Use this version when calling Base64Escape without a do_padding arg.
-PROTOBUF_EXPORT int CalculateBase64EscapedLen(int input_len);
-
-// ----------------------------------------------------------------------
-// Base64Escape()
-// WebSafeBase64Escape()
-//    Encode "src" to "dest" using base64 encoding.
-//    src is not null terminated, instead specify len.
-//    'dest' should have at least CalculateBase64EscapedLen() length.
-//    RETURNS the length of dest.
-//    The WebSafe variation use '-' instead of '+' and '_' instead of '/'
-//    so that we can place the out in the URL or cookies without having
-//    to escape them.  It also has an extra parameter "do_padding",
-//    which when set to false will prevent padding with "=".
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT int Base64Escape(const unsigned char* src, int slen, char* dest,
-                                 int szdest);
-PROTOBUF_EXPORT int WebSafeBase64Escape(const unsigned char* src, int slen,
-                                        char* dest, int szdest,
-                                        bool do_padding);
-// Encode src into dest with padding.
-PROTOBUF_EXPORT void Base64Escape(StringPiece src, std::string* dest);
-// Encode src into dest web-safely without padding.
-PROTOBUF_EXPORT void WebSafeBase64Escape(StringPiece src, std::string* dest);
-// Encode src into dest web-safely with padding.
-PROTOBUF_EXPORT void WebSafeBase64EscapeWithPadding(StringPiece src,
-                                                    std::string* dest);
-
-PROTOBUF_EXPORT void Base64Escape(const unsigned char* src, int szsrc,
-                                  std::string* dest, bool do_padding);
-PROTOBUF_EXPORT void WebSafeBase64Escape(const unsigned char* src, int szsrc,
-                                         std::string* dest, bool do_padding);
-
-inline bool IsValidCodePoint(uint32_t code_point) {
-  return code_point < 0xD800 ||
-         (code_point >= 0xE000 && code_point <= 0x10FFFF);
-}
-
-static const int UTFmax = 4;
-// ----------------------------------------------------------------------
-// EncodeAsUTF8Char()
-//  Helper to append a Unicode code point to a string as UTF8, without bringing
-//  in any external dependencies. The output buffer must be as least 4 bytes
-//  large.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT int EncodeAsUTF8Char(uint32_t code_point, char* output);
-
-// ----------------------------------------------------------------------
-// UTF8FirstLetterNumBytes()
-//   Length of the first UTF-8 character.
-// ----------------------------------------------------------------------
-PROTOBUF_EXPORT int UTF8FirstLetterNumBytes(const char* src, int len);
-
-// From google3/third_party/absl/strings/escaping.h
-
-// ----------------------------------------------------------------------
-// CleanStringLineEndings()
-//   Clean up a multi-line string to conform to Unix line endings.
-//   Reads from src and appends to dst, so usually dst should be empty.
-//
-//   If there is no line ending at the end of a non-empty string, it can
-//   be added automatically.
-//
-//   Four different types of input are correctly handled:
-//
-//     - Unix/Linux files: line ending is LF: pass through unchanged
-//
-//     - DOS/Windows files: line ending is CRLF: convert to LF
-//
-//     - Legacy Mac files: line ending is CR: convert to LF
-//
-//     - Garbled files: random line endings: convert gracefully
-//                      lonely CR, lonely LF, CRLF: convert to LF
-//
-//   @param src The multi-line string to convert
-//   @param dst The converted string is appended to this string
-//   @param auto_end_last_line Automatically terminate the last line
-//
-//   Limitations:
-//
-//     This does not do the right thing for CRCRLF files created by
-//     broken programs that do another Unix->DOS conversion on files
-//     that are already in CRLF format.  For this, a two-pass approach
-//     brute-force would be needed that
-//
-//       (1) determines the presence of LF (first one is ok)
-//       (2) if yes, removes any CR, else convert every CR to LF
-PROTOBUF_EXPORT void CleanStringLineEndings(const std::string& src,
-                                            std::string* dst,
-                                            bool auto_end_last_line);
-
-// Same as above, but transforms the argument in place.
-PROTOBUF_EXPORT void CleanStringLineEndings(std::string* str,
-                                            bool auto_end_last_line);
-
-namespace strings {
-inline bool EndsWith(StringPiece text, StringPiece suffix) {
-  return suffix.empty() ||
-      (text.size() >= suffix.size() &&
-       memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
-              suffix.size()) == 0);
-}
-}  // namespace strings
-
-namespace internal {
-
-// A locale-independent version of the standard strtod(), which always
-// uses a dot as the decimal separator.
-double NoLocaleStrtod(const char* str, char** endptr);
-
-}  // namespace internal
-
-}  // namespace protobuf
+                    value = sizeof(v) == 1 ? static_cast<uint8_t>(v) : sizeof(v) == 2 ? static_cast<uint16_t>(v) :
+                                                                   sizeof(v) == 4     ? static_cast<uint32_t>(v) :
+                                                                                        static_cast<uint64_t>(v);
+                }
+            };
+
+            struct PROTOBUF_EXPORT AlphaNum
+            {
+                const char* piece_data_;  // move these to string_ref eventually
+                size_t piece_size_;       // move these to string_ref eventually
+
+                char digits[kFastToBufferSize];
+
+                // No bool ctor -- bools convert to an integral type.
+                // A bool ctor would also convert incoming pointers (bletch).
+
+                AlphaNum(int i32) :
+                    piece_data_(digits),
+                    piece_size_(FastInt32ToBufferLeft(i32, digits) - &digits[0])
+                {
+                }
+                AlphaNum(unsigned int u32) :
+                    piece_data_(digits),
+                    piece_size_(FastUInt32ToBufferLeft(u32, digits) - &digits[0])
+                {
+                }
+                AlphaNum(long long i64) :
+                    piece_data_(digits),
+                    piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0])
+                {
+                }
+                AlphaNum(unsigned long long u64) :
+                    piece_data_(digits),
+                    piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0])
+                {
+                }
+
+                // Note: on some architectures, "long" is only 32 bits, not 64, but the
+                // performance hit of using FastInt64ToBufferLeft to handle 32-bit values
+                // is quite minor.
+                AlphaNum(long i64) :
+                    piece_data_(digits),
+                    piece_size_(FastInt64ToBufferLeft(i64, digits) - &digits[0])
+                {
+                }
+                AlphaNum(unsigned long u64) :
+                    piece_data_(digits),
+                    piece_size_(FastUInt64ToBufferLeft(u64, digits) - &digits[0])
+                {
+                }
+
+                AlphaNum(float f) :
+                    piece_data_(digits),
+                    piece_size_(strlen(FloatToBuffer(f, digits)))
+                {
+                }
+                AlphaNum(double f) :
+                    piece_data_(digits),
+                    piece_size_(strlen(DoubleToBuffer(f, digits)))
+                {
+                }
+
+                AlphaNum(Hex hex);
+
+                AlphaNum(const char* c_str) :
+                    piece_data_(c_str),
+                    piece_size_(strlen(c_str))
+                {
+                }
+                // TODO: Add a string_ref constructor, eventually
+                // AlphaNum(const StringPiece &pc) : piece(pc) {}
+
+                AlphaNum(const std::string& str) :
+                    piece_data_(str.data()),
+                    piece_size_(str.size())
+                {
+                }
+
+                AlphaNum(StringPiece str) :
+                    piece_data_(str.data()),
+                    piece_size_(str.size())
+                {
+                }
+
+                size_t size() const
+                {
+                    return piece_size_;
+                }
+                const char* data() const
+                {
+                    return piece_data_;
+                }
+
+            private:
+                // Use ":" not ':'
+                AlphaNum(char c);  // NOLINT(runtime/explicit)
+
+                // Disallow copy and assign.
+                AlphaNum(const AlphaNum&);
+                void operator=(const AlphaNum&);
+            };
+
+        }  // namespace strings
+
+        using strings::AlphaNum;
+
+        // ----------------------------------------------------------------------
+        // StrCat()
+        //    This merges the given strings or numbers, with no delimiter.  This
+        //    is designed to be the fastest possible way to construct a string out
+        //    of a mix of raw C strings, strings, bool values,
+        //    and numeric values.
+        //
+        //    Don't use this for user-visible strings.  The localization process
+        //    works poorly on strings built up out of fragments.
+        //
+        //    For clarity and performance, don't use StrCat when appending to a
+        //    string.  In particular, avoid using any of these (anti-)patterns:
+        //      str.append(StrCat(...)
+        //      str += StrCat(...)
+        //      str = StrCat(str, ...)
+        //    where the last is the worse, with the potential to change a loop
+        //    from a linear time operation with O(1) dynamic allocations into a
+        //    quadratic time operation with O(n) dynamic allocations.  StrAppend
+        //    is a better choice than any of the above, subject to the restriction
+        //    of StrAppend(&str, a, b, c, ...) that none of the a, b, c, ... may
+        //    be a reference into str.
+        // ----------------------------------------------------------------------
+
+        PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b);
+        PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c);
+        PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d);
+        PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e);
+        PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e, const AlphaNum& f);
+        PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e, const AlphaNum& f, const AlphaNum& g);
+        PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e, const AlphaNum& f, const AlphaNum& g, const AlphaNum& h);
+        PROTOBUF_EXPORT std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d, const AlphaNum& e, const AlphaNum& f, const AlphaNum& g, const AlphaNum& h, const AlphaNum& i);
+
+        inline std::string StrCat(const AlphaNum& a)
+        {
+            return std::string(a.data(), a.size());
+        }
+
+        // ----------------------------------------------------------------------
+        // StrAppend()
+        //    Same as above, but adds the output to the given string.
+        //    WARNING: For speed, StrAppend does not try to check each of its input
+        //    arguments to be sure that they are not a subset of the string being
+        //    appended to.  That is, while this will work:
+        //
+        //    string s = "foo";
+        //    s += s;
+        //
+        //    This will not (necessarily) work:
+        //
+        //    string s = "foo";
+        //    StrAppend(&s, s);
+        //
+        //    Note: while StrCat supports appending up to 9 arguments, StrAppend
+        //    is currently limited to 4.  That's rarely an issue except when
+        //    automatically transforming StrCat to StrAppend, and can easily be
+        //    worked around as consecutive calls to StrAppend are quite efficient.
+        // ----------------------------------------------------------------------
+
+        PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a);
+        PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b);
+        PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c);
+        PROTOBUF_EXPORT void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d);
+
+        // ----------------------------------------------------------------------
+        // Join()
+        //    These methods concatenate a range of components into a C++ string, using
+        //    the C-string "delim" as a separator between components.
+        // ----------------------------------------------------------------------
+        template<typename Iterator>
+        void Join(Iterator start, Iterator end, const char* delim, std::string* result)
+        {
+            for (Iterator it = start; it != end; ++it)
+            {
+                if (it != start)
+                {
+                    result->append(delim);
+                }
+                StrAppend(result, *it);
+            }
+        }
+
+        template<typename Range>
+        std::string Join(const Range& components, const char* delim)
+        {
+            std::string result;
+            Join(components.begin(), components.end(), delim, &result);
+            return result;
+        }
+
+        // ----------------------------------------------------------------------
+        // ToHex()
+        //    Return a lower-case hex string representation of the given integer.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT std::string ToHex(uint64_t num);
+
+        // ----------------------------------------------------------------------
+        // GlobalReplaceSubstring()
+        //    Replaces all instances of a substring in a string.  Does nothing
+        //    if 'substring' is empty.  Returns the number of replacements.
+        //
+        //    NOTE: The string pieces must not overlap s.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT int GlobalReplaceSubstring(const std::string& substring, const std::string& replacement, std::string* s);
+
+        // ----------------------------------------------------------------------
+        // Base64Unescape()
+        //    Converts "src" which is encoded in Base64 to its binary equivalent and
+        //    writes it to "dest". If src contains invalid characters, dest is cleared
+        //    and the function returns false. Returns true on success.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT bool Base64Unescape(StringPiece src, std::string* dest);
+
+        // ----------------------------------------------------------------------
+        // WebSafeBase64Unescape()
+        //    This is a variation of Base64Unescape which uses '-' instead of '+', and
+        //    '_' instead of '/'. src is not null terminated, instead specify len. I
+        //    recommend that slen<szdest, but we honor szdest anyway.
+        //    RETURNS the length of dest, or -1 if src contains invalid chars.
+
+        //    The variation that stores into a string clears the string first, and
+        //    returns false (with dest empty) if src contains invalid chars; for
+        //    this version src and dest must be different strings.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT int WebSafeBase64Unescape(const char* src, int slen, char* dest, int szdest);
+        PROTOBUF_EXPORT bool WebSafeBase64Unescape(StringPiece src, std::string* dest);
+
+        // Return the length to use for the output buffer given to the base64 escape
+        // routines. Make sure to use the same value for do_padding in both.
+        // This function may return incorrect results if given input_len values that
+        // are extremely high, which should happen rarely.
+        PROTOBUF_EXPORT int CalculateBase64EscapedLen(int input_len, bool do_padding);
+        // Use this version when calling Base64Escape without a do_padding arg.
+        PROTOBUF_EXPORT int CalculateBase64EscapedLen(int input_len);
+
+        // ----------------------------------------------------------------------
+        // Base64Escape()
+        // WebSafeBase64Escape()
+        //    Encode "src" to "dest" using base64 encoding.
+        //    src is not null terminated, instead specify len.
+        //    'dest' should have at least CalculateBase64EscapedLen() length.
+        //    RETURNS the length of dest.
+        //    The WebSafe variation use '-' instead of '+' and '_' instead of '/'
+        //    so that we can place the out in the URL or cookies without having
+        //    to escape them.  It also has an extra parameter "do_padding",
+        //    which when set to false will prevent padding with "=".
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT int Base64Escape(const unsigned char* src, int slen, char* dest, int szdest);
+        PROTOBUF_EXPORT int WebSafeBase64Escape(const unsigned char* src, int slen, char* dest, int szdest, bool do_padding);
+        // Encode src into dest with padding.
+        PROTOBUF_EXPORT void Base64Escape(StringPiece src, std::string* dest);
+        // Encode src into dest web-safely without padding.
+        PROTOBUF_EXPORT void WebSafeBase64Escape(StringPiece src, std::string* dest);
+        // Encode src into dest web-safely with padding.
+        PROTOBUF_EXPORT void WebSafeBase64EscapeWithPadding(StringPiece src, std::string* dest);
+
+        PROTOBUF_EXPORT void Base64Escape(const unsigned char* src, int szsrc, std::string* dest, bool do_padding);
+        PROTOBUF_EXPORT void WebSafeBase64Escape(const unsigned char* src, int szsrc, std::string* dest, bool do_padding);
+
+        inline bool IsValidCodePoint(uint32_t code_point)
+        {
+            return code_point < 0xD800 ||
+                   (code_point >= 0xE000 && code_point <= 0x10FFFF);
+        }
+
+        static const int UTFmax = 4;
+        // ----------------------------------------------------------------------
+        // EncodeAsUTF8Char()
+        //  Helper to append a Unicode code point to a string as UTF8, without bringing
+        //  in any external dependencies. The output buffer must be as least 4 bytes
+        //  large.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT int EncodeAsUTF8Char(uint32_t code_point, char* output);
+
+        // ----------------------------------------------------------------------
+        // UTF8FirstLetterNumBytes()
+        //   Length of the first UTF-8 character.
+        // ----------------------------------------------------------------------
+        PROTOBUF_EXPORT int UTF8FirstLetterNumBytes(const char* src, int len);
+
+        // From google3/third_party/absl/strings/escaping.h
+
+        // ----------------------------------------------------------------------
+        // CleanStringLineEndings()
+        //   Clean up a multi-line string to conform to Unix line endings.
+        //   Reads from src and appends to dst, so usually dst should be empty.
+        //
+        //   If there is no line ending at the end of a non-empty string, it can
+        //   be added automatically.
+        //
+        //   Four different types of input are correctly handled:
+        //
+        //     - Unix/Linux files: line ending is LF: pass through unchanged
+        //
+        //     - DOS/Windows files: line ending is CRLF: convert to LF
+        //
+        //     - Legacy Mac files: line ending is CR: convert to LF
+        //
+        //     - Garbled files: random line endings: convert gracefully
+        //                      lonely CR, lonely LF, CRLF: convert to LF
+        //
+        //   @param src The multi-line string to convert
+        //   @param dst The converted string is appended to this string
+        //   @param auto_end_last_line Automatically terminate the last line
+        //
+        //   Limitations:
+        //
+        //     This does not do the right thing for CRCRLF files created by
+        //     broken programs that do another Unix->DOS conversion on files
+        //     that are already in CRLF format.  For this, a two-pass approach
+        //     brute-force would be needed that
+        //
+        //       (1) determines the presence of LF (first one is ok)
+        //       (2) if yes, removes any CR, else convert every CR to LF
+        PROTOBUF_EXPORT void CleanStringLineEndings(const std::string& src, std::string* dst, bool auto_end_last_line);
+
+        // Same as above, but transforms the argument in place.
+        PROTOBUF_EXPORT void CleanStringLineEndings(std::string* str, bool auto_end_last_line);
+
+        namespace strings
+        {
+            inline bool EndsWith(StringPiece text, StringPiece suffix)
+            {
+                return suffix.empty() ||
+                       (text.size() >= suffix.size() &&
+                        memcmp(text.data() + (text.size() - suffix.size()), suffix.data(), suffix.size()) == 0);
+            }
+        }  // namespace strings
+
+        namespace internal
+        {
+
+            // A locale-independent version of the standard strtod(), which always
+            // uses a dot as the decimal separator.
+            double NoLocaleStrtod(const char* str, char** endptr);
+
+        }  // namespace internal
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h b/CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h
index feef904..44d24df 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h
@@ -50,89 +50,99 @@
 #ifndef GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
 #define GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// Types small_ and big_ are guaranteed such that sizeof(small_) <
-// sizeof(big_)
-typedef char small_;
-
-struct big_ {
-  char dummy[2];
-};
-
-// Identity metafunction.
-template <class T>
-struct identity_ {
-  typedef T type;
-};
-
-// integral_constant, defined in tr1, is a wrapper for an integer
-// value. We don't really need this generality; we could get away
-// with hardcoding the integer type to bool. We use the fully
-// general integer_constant for compatibility with tr1.
-
-template<class T, T v>
-struct integral_constant {
-  static const T value = v;
-  typedef T value_type;
-  typedef integral_constant<T, v> type;
-};
-
-template <class T, T v> const T integral_constant<T, v>::value;
-
-
-// Abbreviations: true_type and false_type are structs that represent boolean
-// true and false values. Also define the boost::mpl versions of those names,
-// true_ and false_.
-typedef integral_constant<bool, true>  true_type;
-typedef integral_constant<bool, false> false_type;
-typedef true_type  true_;
-typedef false_type false_;
-
-// if_ is a templatized conditional statement.
-// if_<cond, A, B> is a compile time evaluation of cond.
-// if_<>::type contains A if cond is true, B otherwise.
-template<bool cond, typename A, typename B>
-struct if_{
-  typedef A type;
-};
-
-template<typename A, typename B>
-struct if_<false, A, B> {
-  typedef B type;
-};
-
-
-// type_equals_ is a template type comparator, similar to Loki IsSameType.
-// type_equals_<A, B>::value is true iff "A" is the same type as "B".
-//
-// New code should prefer base::is_same, defined in base/type_traits.h.
-// It is functionally identical, but is_same is the standard spelling.
-template<typename A, typename B>
-struct type_equals_ : public false_ {
-};
-
-template<typename A>
-struct type_equals_<A, A> : public true_ {
-};
-
-// and_ is a template && operator.
-// and_<A, B>::value evaluates "A::value && B::value".
-template<typename A, typename B>
-struct and_ : public integral_constant<bool, (A::value && B::value)> {
-};
-
-// or_ is a template || operator.
-// or_<A, B>::value evaluates "A::value || B::value".
-template<typename A, typename B>
-struct or_ : public integral_constant<bool, (A::value || B::value)> {
-};
-
-
-}  // namespace internal
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // Types small_ and big_ are guaranteed such that sizeof(small_) <
+            // sizeof(big_)
+            typedef char small_;
+
+            struct big_
+            {
+                char dummy[2];
+            };
+
+            // Identity metafunction.
+            template<class T>
+            struct identity_
+            {
+                typedef T type;
+            };
+
+            // integral_constant, defined in tr1, is a wrapper for an integer
+            // value. We don't really need this generality; we could get away
+            // with hardcoding the integer type to bool. We use the fully
+            // general integer_constant for compatibility with tr1.
+
+            template<class T, T v>
+            struct integral_constant
+            {
+                static const T value = v;
+                typedef T value_type;
+                typedef integral_constant<T, v> type;
+            };
+
+            template<class T, T v>
+            const T integral_constant<T, v>::value;
+
+            // Abbreviations: true_type and false_type are structs that represent boolean
+            // true and false values. Also define the boost::mpl versions of those names,
+            // true_ and false_.
+            typedef integral_constant<bool, true> true_type;
+            typedef integral_constant<bool, false> false_type;
+            typedef true_type true_;
+            typedef false_type false_;
+
+            // if_ is a templatized conditional statement.
+            // if_<cond, A, B> is a compile time evaluation of cond.
+            // if_<>::type contains A if cond is true, B otherwise.
+            template<bool cond, typename A, typename B>
+            struct if_
+            {
+                typedef A type;
+            };
+
+            template<typename A, typename B>
+            struct if_<false, A, B>
+            {
+                typedef B type;
+            };
+
+            // type_equals_ is a template type comparator, similar to Loki IsSameType.
+            // type_equals_<A, B>::value is true iff "A" is the same type as "B".
+            //
+            // New code should prefer base::is_same, defined in base/type_traits.h.
+            // It is functionally identical, but is_same is the standard spelling.
+            template<typename A, typename B>
+            struct type_equals_ : public false_
+            {
+            };
+
+            template<typename A>
+            struct type_equals_<A, A> : public true_
+            {
+            };
+
+            // and_ is a template && operator.
+            // and_<A, B>::value evaluates "A::value && B::value".
+            template<typename A, typename B>
+            struct and_ : public integral_constant<bool, (A::value && B::value)>
+            {
+            };
+
+            // or_ is a template || operator.
+            // or_<A, B>::value evaluates "A::value || B::value".
+            template<typename A, typename B>
+            struct or_ : public integral_constant<bool, (A::value || B::value)>
+            {
+            };
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
diff --git a/CAPI/cpp/grpc/include/google/protobuf/text_format.h b/CAPI/cpp/grpc/include/google/protobuf/text_format.h
index e10bef7..2a9487f 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/text_format.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/text_format.h
@@ -38,7 +38,6 @@
 #ifndef GOOGLE_PROTOBUF_TEXT_FORMAT_H__
 #define GOOGLE_PROTOBUF_TEXT_FORMAT_H__
 
-
 #include <map>
 #include <memory>
 #include <string>
@@ -57,635 +56,668 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-
-namespace internal {
-PROTOBUF_EXPORT extern const char kDebugStringSilentMarker[1];
-PROTOBUF_EXPORT extern const char kDebugStringSilentMarkerForDetection[3];
-}  // namespace internal
-
-namespace io {
-class ErrorCollector;  // tokenizer.h
-}
-
-// This class implements protocol buffer text format, colloquially known as text
-// proto.  Printing and parsing protocol messages in text format is useful for
-// debugging and human editing of messages.
-//
-// This class is really a namespace that contains only static methods.
-class PROTOBUF_EXPORT TextFormat {
- public:
-  // Outputs a textual representation of the given message to the given
-  // output stream. Returns false if printing fails.
-  static bool Print(const Message& message, io::ZeroCopyOutputStream* output);
-
-  // Print the fields in an UnknownFieldSet.  They are printed by tag number
-  // only.  Embedded messages are heuristically identified by attempting to
-  // parse them. Returns false if printing fails.
-  static bool PrintUnknownFields(const UnknownFieldSet& unknown_fields,
-                                 io::ZeroCopyOutputStream* output);
-
-  // Like Print(), but outputs directly to a string.
-  // Note: output will be cleared prior to printing, and will be left empty
-  // even if printing fails. Returns false if printing fails.
-  static bool PrintToString(const Message& message, std::string* output);
-
-  // Like PrintUnknownFields(), but outputs directly to a string. Returns
-  // false if printing fails.
-  static bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields,
-                                         std::string* output);
-
-  // Outputs a textual representation of the value of the field supplied on
-  // the message supplied. For non-repeated fields, an index of -1 must
-  // be supplied. Note that this method will print the default value for a
-  // field if it is not set.
-  static void PrintFieldValueToString(const Message& message,
-                                      const FieldDescriptor* field, int index,
-                                      std::string* output);
-
-  class PROTOBUF_EXPORT BaseTextGenerator {
-   public:
-    virtual ~BaseTextGenerator();
-
-    virtual void Indent() {}
-    virtual void Outdent() {}
-    // Returns the current indentation size in characters.
-    virtual size_t GetCurrentIndentationSize() const { return 0; }
-
-    // Print text to the output stream.
-    virtual void Print(const char* text, size_t size) = 0;
-
-    void PrintString(const std::string& str) { Print(str.data(), str.size()); }
-
-    template <size_t n>
-    void PrintLiteral(const char (&text)[n]) {
-      Print(text, n - 1);  // n includes the terminating zero character.
-    }
-  };
-
-  // The default printer that converts scalar values from fields into their
-  // string representation.
-  // You can derive from this FastFieldValuePrinter if you want to have fields
-  // to be printed in a different way and register it at the Printer.
-  class PROTOBUF_EXPORT FastFieldValuePrinter {
-   public:
-    FastFieldValuePrinter();
-    virtual ~FastFieldValuePrinter();
-    virtual void PrintBool(bool val, BaseTextGenerator* generator) const;
-    virtual void PrintInt32(int32_t val, BaseTextGenerator* generator) const;
-    virtual void PrintUInt32(uint32_t val, BaseTextGenerator* generator) const;
-    virtual void PrintInt64(int64_t val, BaseTextGenerator* generator) const;
-    virtual void PrintUInt64(uint64_t val, BaseTextGenerator* generator) const;
-    virtual void PrintFloat(float val, BaseTextGenerator* generator) const;
-    virtual void PrintDouble(double val, BaseTextGenerator* generator) const;
-    virtual void PrintString(const std::string& val,
-                             BaseTextGenerator* generator) const;
-    virtual void PrintBytes(const std::string& val,
-                            BaseTextGenerator* generator) const;
-    virtual void PrintEnum(int32_t val, const std::string& name,
-                           BaseTextGenerator* generator) const;
-    virtual void PrintFieldName(const Message& message, int field_index,
-                                int field_count, const Reflection* reflection,
-                                const FieldDescriptor* field,
-                                BaseTextGenerator* generator) const;
-    virtual void PrintFieldName(const Message& message,
-                                const Reflection* reflection,
-                                const FieldDescriptor* field,
-                                BaseTextGenerator* generator) const;
-    virtual void PrintMessageStart(const Message& message, int field_index,
-                                   int field_count, bool single_line_mode,
-                                   BaseTextGenerator* generator) const;
-    // Allows to override the logic on how to print the content of a message.
-    // Return false to use the default printing logic. Note that it is legal for
-    // this function to print something and then return false to use the default
-    // content printing (although at that point it would behave similarly to
-    // PrintMessageStart).
-    virtual bool PrintMessageContent(const Message& message, int field_index,
-                                     int field_count, bool single_line_mode,
-                                     BaseTextGenerator* generator) const;
-    virtual void PrintMessageEnd(const Message& message, int field_index,
-                                 int field_count, bool single_line_mode,
-                                 BaseTextGenerator* generator) const;
-
-   private:
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastFieldValuePrinter);
-  };
-
-  // Deprecated: please use FastFieldValuePrinter instead.
-  class PROTOBUF_EXPORT FieldValuePrinter {
-   public:
-    FieldValuePrinter();
-    virtual ~FieldValuePrinter();
-    virtual std::string PrintBool(bool val) const;
-    virtual std::string PrintInt32(int32_t val) const;
-    virtual std::string PrintUInt32(uint32_t val) const;
-    virtual std::string PrintInt64(int64_t val) const;
-    virtual std::string PrintUInt64(uint64_t val) const;
-    virtual std::string PrintFloat(float val) const;
-    virtual std::string PrintDouble(double val) const;
-    virtual std::string PrintString(const std::string& val) const;
-    virtual std::string PrintBytes(const std::string& val) const;
-    virtual std::string PrintEnum(int32_t val, const std::string& name) const;
-    virtual std::string PrintFieldName(const Message& message,
-                                       const Reflection* reflection,
-                                       const FieldDescriptor* field) const;
-    virtual std::string PrintMessageStart(const Message& message,
-                                          int field_index, int field_count,
-                                          bool single_line_mode) const;
-    virtual std::string PrintMessageEnd(const Message& message, int field_index,
-                                        int field_count,
-                                        bool single_line_mode) const;
-
-   private:
-    FastFieldValuePrinter delegate_;
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldValuePrinter);
-  };
-
-  class PROTOBUF_EXPORT MessagePrinter {
-   public:
-    MessagePrinter() {}
-    virtual ~MessagePrinter() {}
-    virtual void Print(const Message& message, bool single_line_mode,
-                       BaseTextGenerator* generator) const = 0;
-
-   private:
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessagePrinter);
-  };
-
-  // Interface that Printers or Parsers can use to find extensions, or types
-  // referenced in Any messages.
-  class PROTOBUF_EXPORT Finder {
-   public:
-    virtual ~Finder();
-
-    // Try to find an extension of *message by fully-qualified field
-    // name.  Returns nullptr if no extension is known for this name or number.
-    // The base implementation uses the extensions already known by the message.
-    virtual const FieldDescriptor* FindExtension(Message* message,
-                                                 const std::string& name) const;
-
-    // Similar to FindExtension, but uses a Descriptor and the extension number
-    // instead of using a Message and the name when doing the look up.
-    virtual const FieldDescriptor* FindExtensionByNumber(
-        const Descriptor* descriptor, int number) const;
-
-    // Find the message type for an Any proto.
-    // Returns nullptr if no message is known for this name.
-    // The base implementation only accepts prefixes of type.googleprod.com/ or
-    // type.googleapis.com/, and searches the DescriptorPool of the parent
-    // message.
-    virtual const Descriptor* FindAnyType(const Message& message,
-                                          const std::string& prefix,
-                                          const std::string& name) const;
-
-    // Find the message factory for the given extension field. This can be used
-    // to generalize the Parser to add extension fields to a message in the same
-    // way as the "input" message for the Parser.
-    virtual MessageFactory* FindExtensionFactory(
-        const FieldDescriptor* field) const;
-  };
-
-  // Class for those users which require more fine-grained control over how
-  // a protobuffer message is printed out.
-  class PROTOBUF_EXPORT Printer {
-   public:
-    Printer();
-
-    // Like TextFormat::Print
-    bool Print(const Message& message, io::ZeroCopyOutputStream* output) const;
-    // Like TextFormat::PrintUnknownFields
-    bool PrintUnknownFields(const UnknownFieldSet& unknown_fields,
-                            io::ZeroCopyOutputStream* output) const;
-    // Like TextFormat::PrintToString
-    bool PrintToString(const Message& message, std::string* output) const;
-    // Like TextFormat::PrintUnknownFieldsToString
-    bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields,
-                                    std::string* output) const;
-    // Like TextFormat::PrintFieldValueToString
-    void PrintFieldValueToString(const Message& message,
-                                 const FieldDescriptor* field, int index,
-                                 std::string* output) const;
-
-    // Adjust the initial indent level of all output.  Each indent level is
-    // equal to two spaces.
-    void SetInitialIndentLevel(int indent_level) {
-      initial_indent_level_ = indent_level;
-    }
-
-    // If printing in single line mode, then the entire message will be output
-    // on a single line with no line breaks.
-    void SetSingleLineMode(bool single_line_mode) {
-      single_line_mode_ = single_line_mode;
-    }
-
-    bool IsInSingleLineMode() const { return single_line_mode_; }
-
-    // If use_field_number is true, uses field number instead of field name.
-    void SetUseFieldNumber(bool use_field_number) {
-      use_field_number_ = use_field_number;
-    }
-
-    // Set true to print repeated primitives in a format like:
-    //   field_name: [1, 2, 3, 4]
-    // instead of printing each value on its own line.  Short format applies
-    // only to primitive values -- i.e. everything except strings and
-    // sub-messages/groups.
-    void SetUseShortRepeatedPrimitives(bool use_short_repeated_primitives) {
-      use_short_repeated_primitives_ = use_short_repeated_primitives;
-    }
-
-    // Set true to output UTF-8 instead of ASCII.  The only difference
-    // is that bytes >= 0x80 in string fields will not be escaped,
-    // because they are assumed to be part of UTF-8 multi-byte
-    // sequences. This will change the default FastFieldValuePrinter.
-    void SetUseUtf8StringEscaping(bool as_utf8);
-
-    // Set the default FastFieldValuePrinter that is used for all fields that
-    // don't have a field-specific printer registered.
-    // Takes ownership of the printer.
-    void SetDefaultFieldValuePrinter(const FastFieldValuePrinter* printer);
-
-    PROTOBUF_DEPRECATED_MSG("Please use FastFieldValuePrinter")
-    void SetDefaultFieldValuePrinter(const FieldValuePrinter* printer);
-
-    // Sets whether we want to hide unknown fields or not.
-    // Usually unknown fields are printed in a generic way that includes the
-    // tag number of the field instead of field name. However, sometimes it
-    // is useful to be able to print the message without unknown fields (e.g.
-    // for the python protobuf version to maintain consistency between its pure
-    // python and c++ implementations).
-    void SetHideUnknownFields(bool hide) { hide_unknown_fields_ = hide; }
-
-    // If print_message_fields_in_index_order is true, fields of a proto message
-    // will be printed using the order defined in source code instead of the
-    // field number, extensions will be printed at the end of the message
-    // and their relative order is determined by the extension number.
-    // By default, use the field number order.
-    void SetPrintMessageFieldsInIndexOrder(
-        bool print_message_fields_in_index_order) {
-      print_message_fields_in_index_order_ =
-          print_message_fields_in_index_order;
-    }
-
-    // If expand==true, expand google.protobuf.Any payloads. The output
-    // will be of form
-    //    [type_url] { <value_printed_in_text> }
-    //
-    // If expand==false, print Any using the default printer. The output will
-    // look like
-    //    type_url: "<type_url>"  value: "serialized_content"
-    void SetExpandAny(bool expand) { expand_any_ = expand; }
-
-    // Set how parser finds message for Any payloads.
-    void SetFinder(const Finder* finder) { finder_ = finder; }
-
-    // If non-zero, we truncate all string fields that are  longer than
-    // this threshold.  This is useful when the proto message has very long
-    // strings, e.g., dump of encoded image file.
-    //
-    // NOTE(hfgong):  Setting a non-zero value breaks round-trip safe
-    // property of TextFormat::Printer.  That is, from the printed message, we
-    // cannot fully recover the original string field any more.
-    void SetTruncateStringFieldLongerThan(
-        const int64_t truncate_string_field_longer_than) {
-      truncate_string_field_longer_than_ = truncate_string_field_longer_than;
-    }
-
-    // Register a custom field-specific FastFieldValuePrinter for fields
-    // with a particular FieldDescriptor.
-    // Returns "true" if the registration succeeded, or "false", if there is
-    // already a printer for that FieldDescriptor.
-    // Takes ownership of the printer on successful registration.
-    bool RegisterFieldValuePrinter(const FieldDescriptor* field,
-                                   const FastFieldValuePrinter* printer);
-
-    PROTOBUF_DEPRECATED_MSG("Please use FastFieldValuePrinter")
-    bool RegisterFieldValuePrinter(const FieldDescriptor* field,
-                                   const FieldValuePrinter* printer);
-
-    // Register a custom message-specific MessagePrinter for messages with a
-    // particular Descriptor.
-    // Returns "true" if the registration succeeded, or "false" if there is
-    // already a printer for that Descriptor.
-    bool RegisterMessagePrinter(const Descriptor* descriptor,
-                                const MessagePrinter* printer);
-
-   private:
-    friend std::string Message::DebugString() const;
-    friend std::string Message::ShortDebugString() const;
-    friend std::string Message::Utf8DebugString() const;
-
-    // Sets whether *DebugString should insert a silent marker.
-    void SetInsertSilentMarker(bool v) { insert_silent_marker_ = v; }
-
-    // Forward declaration of an internal class used to print the text
-    // output to the OutputStream (see text_format.cc for implementation).
-    class TextGenerator;
-
-    // Forward declaration of an internal class used to print field values for
-    // DebugString APIs (see text_format.cc for implementation).
-    class DebugStringFieldValuePrinter;
-
-    // Forward declaration of an internal class used to print UTF-8 escaped
-    // strings (see text_format.cc for implementation).
-    class FastFieldValuePrinterUtf8Escaping;
-
-    static const char* const kDoNotParse;
-
-    // Internal Print method, used for writing to the OutputStream via
-    // the TextGenerator class.
-    void Print(const Message& message, TextGenerator* generator) const;
-
-    // Print a single field.
-    void PrintField(const Message& message, const Reflection* reflection,
-                    const FieldDescriptor* field,
-                    TextGenerator* generator) const;
-
-    // Print a repeated primitive field in short form.
-    void PrintShortRepeatedField(const Message& message,
-                                 const Reflection* reflection,
-                                 const FieldDescriptor* field,
-                                 TextGenerator* generator) const;
-
-    // Print the name of a field -- i.e. everything that comes before the
-    // ':' for a single name/value pair.
-    void PrintFieldName(const Message& message, int field_index,
-                        int field_count, const Reflection* reflection,
-                        const FieldDescriptor* field,
-                        TextGenerator* generator) const;
-
-    // Outputs a textual representation of the value of the field supplied on
-    // the message supplied or the default value if not set.
-    void PrintFieldValue(const Message& message, const Reflection* reflection,
-                         const FieldDescriptor* field, int index,
-                         TextGenerator* generator) const;
-
-    // Print the fields in an UnknownFieldSet.  They are printed by tag number
-    // only.  Embedded messages are heuristically identified by attempting to
-    // parse them (subject to the recursion budget).
-    void PrintUnknownFields(const UnknownFieldSet& unknown_fields,
-                            TextGenerator* generator,
-                            int recursion_budget) const;
-
-    bool PrintAny(const Message& message, TextGenerator* generator) const;
-
-    const FastFieldValuePrinter* GetFieldPrinter(
-        const FieldDescriptor* field) const {
-      auto it = custom_printers_.find(field);
-      return it == custom_printers_.end() ? default_field_value_printer_.get()
-                                          : it->second.get();
-    }
-
-    int initial_indent_level_;
-    bool single_line_mode_;
-    bool use_field_number_;
-    bool use_short_repeated_primitives_;
-    bool insert_silent_marker_;
-    bool hide_unknown_fields_;
-    bool print_message_fields_in_index_order_;
-    bool expand_any_;
-    int64_t truncate_string_field_longer_than_;
-
-    std::unique_ptr<const FastFieldValuePrinter> default_field_value_printer_;
-    typedef std::map<const FieldDescriptor*,
-                     std::unique_ptr<const FastFieldValuePrinter>>
-        CustomPrinterMap;
-    CustomPrinterMap custom_printers_;
-
-    typedef std::map<const Descriptor*, std::unique_ptr<const MessagePrinter>>
-        CustomMessagePrinterMap;
-    CustomMessagePrinterMap custom_message_printers_;
-
-    const Finder* finder_;
-  };
-
-  // Parses a text-format protocol message from the given input stream to
-  // the given message object. This function parses the human-readable
-  // serialization format written by Print(). Returns true on success. The
-  // message is cleared first, even if the function fails -- See Merge() to
-  // avoid this behavior.
-  //
-  // Example input: "user {\n id: 123 extra { gender: MALE language: 'en' }\n}"
-  //
-  // One common use for this function is parsing handwritten strings in test
-  // code.
-  //
-  // If you would like to read a protocol buffer serialized in the
-  // (non-human-readable) binary wire format, see
-  // google::protobuf::MessageLite::ParseFromString().
-  static bool Parse(io::ZeroCopyInputStream* input, Message* output);
-  // Like Parse(), but reads directly from a string.
-  static bool ParseFromString(ConstStringParam input, Message* output);
-
-  // Like Parse(), but the data is merged into the given message, as if
-  // using Message::MergeFrom().
-  static bool Merge(io::ZeroCopyInputStream* input, Message* output);
-  // Like Merge(), but reads directly from a string.
-  static bool MergeFromString(ConstStringParam input, Message* output);
-
-  // Parse the given text as a single field value and store it into the
-  // given field of the given message. If the field is a repeated field,
-  // the new value will be added to the end
-  static bool ParseFieldValueFromString(const std::string& input,
-                                        const FieldDescriptor* field,
-                                        Message* message);
-
-  // A location in the parsed text.
-  struct ParseLocation {
-    int line;
-    int column;
-
-    ParseLocation() : line(-1), column(-1) {}
-    ParseLocation(int line_param, int column_param)
-        : line(line_param), column(column_param) {}
-  };
-
-  // A range of locations in the parsed text, including `start` and excluding
-  // `end`.
-  struct ParseLocationRange {
-    ParseLocation start;
-    ParseLocation end;
-    ParseLocationRange() : start(), end() {}
-    ParseLocationRange(ParseLocation start_param, ParseLocation end_param)
-        : start(start_param), end(end_param) {}
-  };
-
-  // Data structure which is populated with the locations of each field
-  // value parsed from the text.
-  class PROTOBUF_EXPORT ParseInfoTree {
-   public:
-    ParseInfoTree() = default;
-    ParseInfoTree(const ParseInfoTree&) = delete;
-    ParseInfoTree& operator=(const ParseInfoTree&) = delete;
-
-    // Returns the parse location range for index-th value of the field in
-    // the parsed text. If none exists, returns a location with start and end
-    // line -1. Index should be -1 for not-repeated fields.
-    ParseLocationRange GetLocationRange(const FieldDescriptor* field,
-                                        int index) const;
-
-    // Returns the starting parse location for index-th value of the field in
-    // the parsed text. If none exists, returns a location with line = -1. Index
-    // should be -1 for not-repeated fields.
-    ParseLocation GetLocation(const FieldDescriptor* field, int index) const {
-      return GetLocationRange(field, index).start;
-    }
-
-    // Returns the parse info tree for the given field, which must be a message
-    // type. The nested information tree is owned by the root tree and will be
-    // deleted when it is deleted.
-    ParseInfoTree* GetTreeForNested(const FieldDescriptor* field,
-                                    int index) const;
-
-   private:
-    // Allow the text format parser to record information into the tree.
-    friend class TextFormat;
-
-    // Records the starting and ending locations of a single value for a field.
-    void RecordLocation(const FieldDescriptor* field, ParseLocationRange range);
-
-    // Create and records a nested tree for a nested message field.
-    ParseInfoTree* CreateNested(const FieldDescriptor* field);
-
-    // Defines the map from the index-th field descriptor to its parse location.
-    typedef std::map<const FieldDescriptor*, std::vector<ParseLocationRange>>
-        LocationMap;
-
-    // Defines the map from the index-th field descriptor to the nested parse
-    // info tree.
-    typedef std::map<const FieldDescriptor*,
-                     std::vector<std::unique_ptr<ParseInfoTree>>>
-        NestedMap;
-
-    LocationMap locations_;
-    NestedMap nested_;
-  };
-
-  // For more control over parsing, use this class.
-  class PROTOBUF_EXPORT Parser {
-   public:
-    Parser();
-    ~Parser();
-
-    // Like TextFormat::Parse().
-    bool Parse(io::ZeroCopyInputStream* input, Message* output);
-    // Like TextFormat::ParseFromString().
-    bool ParseFromString(ConstStringParam input, Message* output);
-    // Like TextFormat::Merge().
-    bool Merge(io::ZeroCopyInputStream* input, Message* output);
-    // Like TextFormat::MergeFromString().
-    bool MergeFromString(ConstStringParam input, Message* output);
-
-    // Set where to report parse errors.  If nullptr (the default), errors will
-    // be printed to stderr.
-    void RecordErrorsTo(io::ErrorCollector* error_collector) {
-      error_collector_ = error_collector;
-    }
-
-    // Set how parser finds extensions.  If nullptr (the default), the
-    // parser will use the standard Reflection object associated with
-    // the message being parsed.
-    void SetFinder(const Finder* finder) { finder_ = finder; }
-
-    // Sets where location information about the parse will be written. If
-    // nullptr
-    // (the default), then no location will be written.
-    void WriteLocationsTo(ParseInfoTree* tree) { parse_info_tree_ = tree; }
-
-    // Normally parsing fails if, after parsing, output->IsInitialized()
-    // returns false.  Call AllowPartialMessage(true) to skip this check.
-    void AllowPartialMessage(bool allow) { allow_partial_ = allow; }
-
-    // Allow field names to be matched case-insensitively.
-    // This is not advisable if there are fields that only differ in case, or
-    // if you want to enforce writing in the canonical form.
-    // This is 'false' by default.
-    void AllowCaseInsensitiveField(bool allow) {
-      allow_case_insensitive_field_ = allow;
-    }
-
-    // Like TextFormat::ParseFieldValueFromString
-    bool ParseFieldValueFromString(const std::string& input,
-                                   const FieldDescriptor* field,
-                                   Message* output);
-
-    // When an unknown extension is met, parsing will fail if this option is
-    // set to false (the default). If true, unknown extensions will be ignored
-    // and a warning message will be generated.
-    // Beware! Setting this option true may hide some errors (e.g. spelling
-    // error on extension name).  This allows data loss; unlike binary format,
-    // text format cannot preserve unknown extensions.  Avoid using this option
-    // if possible.
-    void AllowUnknownExtension(bool allow) { allow_unknown_extension_ = allow; }
-
-    // When an unknown field is met, parsing will fail if this option is set
-    // to false (the default). If true, unknown fields will be ignored and
-    // a warning message will be generated.
-    // Beware! Setting this option true may hide some errors (e.g. spelling
-    // error on field name). This allows data loss; unlike binary format, text
-    // format cannot preserve unknown fields.  Avoid using this option
-    // if possible.
-    void AllowUnknownField(bool allow) { allow_unknown_field_ = allow; }
-
-
-    void AllowFieldNumber(bool allow) { allow_field_number_ = allow; }
-
-    // Sets maximum recursion depth which parser can use. This is effectively
-    // the maximum allowed nesting of proto messages.
-    void SetRecursionLimit(int limit) { recursion_limit_ = limit; }
-
-   private:
-    // Forward declaration of an internal class used to parse text
-    // representations (see text_format.cc for implementation).
-    class ParserImpl;
-
-    // Like TextFormat::Merge().  The provided implementation is used
-    // to do the parsing.
-    bool MergeUsingImpl(io::ZeroCopyInputStream* input, Message* output,
-                        ParserImpl* parser_impl);
-
-    io::ErrorCollector* error_collector_;
-    const Finder* finder_;
-    ParseInfoTree* parse_info_tree_;
-    bool allow_partial_;
-    bool allow_case_insensitive_field_;
-    bool allow_unknown_field_;
-    bool allow_unknown_extension_;
-    bool allow_unknown_enum_;
-    bool allow_field_number_;
-    bool allow_relaxed_whitespace_;
-    bool allow_singular_overwrites_;
-    int recursion_limit_;
-  };
-
-
- private:
-  // Hack: ParseInfoTree declares TextFormat as a friend which should extend
-  // the friendship to TextFormat::Parser::ParserImpl, but unfortunately some
-  // old compilers (e.g. GCC 3.4.6) don't implement this correctly. We provide
-  // helpers for ParserImpl to call methods of ParseInfoTree.
-  static inline void RecordLocation(ParseInfoTree* info_tree,
-                                    const FieldDescriptor* field,
-                                    ParseLocationRange location);
-  static inline ParseInfoTree* CreateNested(ParseInfoTree* info_tree,
-                                            const FieldDescriptor* field);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TextFormat);
-};
-
-inline void TextFormat::RecordLocation(ParseInfoTree* info_tree,
-                                       const FieldDescriptor* field,
-                                       ParseLocationRange location) {
-  info_tree->RecordLocation(field, location);
-}
-
-inline TextFormat::ParseInfoTree* TextFormat::CreateNested(
-    ParseInfoTree* info_tree, const FieldDescriptor* field) {
-  return info_tree->CreateNested(field);
-}
-
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+
+        namespace internal
+        {
+            PROTOBUF_EXPORT extern const char kDebugStringSilentMarker[1];
+            PROTOBUF_EXPORT extern const char kDebugStringSilentMarkerForDetection[3];
+        }  // namespace internal
+
+        namespace io
+        {
+            class ErrorCollector;  // tokenizer.h
+        }
+
+        // This class implements protocol buffer text format, colloquially known as text
+        // proto.  Printing and parsing protocol messages in text format is useful for
+        // debugging and human editing of messages.
+        //
+        // This class is really a namespace that contains only static methods.
+        class PROTOBUF_EXPORT TextFormat
+        {
+        public:
+            // Outputs a textual representation of the given message to the given
+            // output stream. Returns false if printing fails.
+            static bool Print(const Message& message, io::ZeroCopyOutputStream* output);
+
+            // Print the fields in an UnknownFieldSet.  They are printed by tag number
+            // only.  Embedded messages are heuristically identified by attempting to
+            // parse them. Returns false if printing fails.
+            static bool PrintUnknownFields(const UnknownFieldSet& unknown_fields, io::ZeroCopyOutputStream* output);
+
+            // Like Print(), but outputs directly to a string.
+            // Note: output will be cleared prior to printing, and will be left empty
+            // even if printing fails. Returns false if printing fails.
+            static bool PrintToString(const Message& message, std::string* output);
+
+            // Like PrintUnknownFields(), but outputs directly to a string. Returns
+            // false if printing fails.
+            static bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields, std::string* output);
+
+            // Outputs a textual representation of the value of the field supplied on
+            // the message supplied. For non-repeated fields, an index of -1 must
+            // be supplied. Note that this method will print the default value for a
+            // field if it is not set.
+            static void PrintFieldValueToString(const Message& message, const FieldDescriptor* field, int index, std::string* output);
+
+            class PROTOBUF_EXPORT BaseTextGenerator
+            {
+            public:
+                virtual ~BaseTextGenerator();
+
+                virtual void Indent()
+                {
+                }
+                virtual void Outdent()
+                {
+                }
+                // Returns the current indentation size in characters.
+                virtual size_t GetCurrentIndentationSize() const
+                {
+                    return 0;
+                }
+
+                // Print text to the output stream.
+                virtual void Print(const char* text, size_t size) = 0;
+
+                void PrintString(const std::string& str)
+                {
+                    Print(str.data(), str.size());
+                }
+
+                template<size_t n>
+                void PrintLiteral(const char (&text)[n])
+                {
+                    Print(text, n - 1);  // n includes the terminating zero character.
+                }
+            };
+
+            // The default printer that converts scalar values from fields into their
+            // string representation.
+            // You can derive from this FastFieldValuePrinter if you want to have fields
+            // to be printed in a different way and register it at the Printer.
+            class PROTOBUF_EXPORT FastFieldValuePrinter
+            {
+            public:
+                FastFieldValuePrinter();
+                virtual ~FastFieldValuePrinter();
+                virtual void PrintBool(bool val, BaseTextGenerator* generator) const;
+                virtual void PrintInt32(int32_t val, BaseTextGenerator* generator) const;
+                virtual void PrintUInt32(uint32_t val, BaseTextGenerator* generator) const;
+                virtual void PrintInt64(int64_t val, BaseTextGenerator* generator) const;
+                virtual void PrintUInt64(uint64_t val, BaseTextGenerator* generator) const;
+                virtual void PrintFloat(float val, BaseTextGenerator* generator) const;
+                virtual void PrintDouble(double val, BaseTextGenerator* generator) const;
+                virtual void PrintString(const std::string& val, BaseTextGenerator* generator) const;
+                virtual void PrintBytes(const std::string& val, BaseTextGenerator* generator) const;
+                virtual void PrintEnum(int32_t val, const std::string& name, BaseTextGenerator* generator) const;
+                virtual void PrintFieldName(const Message& message, int field_index, int field_count, const Reflection* reflection, const FieldDescriptor* field, BaseTextGenerator* generator) const;
+                virtual void PrintFieldName(const Message& message, const Reflection* reflection, const FieldDescriptor* field, BaseTextGenerator* generator) const;
+                virtual void PrintMessageStart(const Message& message, int field_index, int field_count, bool single_line_mode, BaseTextGenerator* generator) const;
+                // Allows to override the logic on how to print the content of a message.
+                // Return false to use the default printing logic. Note that it is legal for
+                // this function to print something and then return false to use the default
+                // content printing (although at that point it would behave similarly to
+                // PrintMessageStart).
+                virtual bool PrintMessageContent(const Message& message, int field_index, int field_count, bool single_line_mode, BaseTextGenerator* generator) const;
+                virtual void PrintMessageEnd(const Message& message, int field_index, int field_count, bool single_line_mode, BaseTextGenerator* generator) const;
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastFieldValuePrinter);
+            };
+
+            // Deprecated: please use FastFieldValuePrinter instead.
+            class PROTOBUF_EXPORT FieldValuePrinter
+            {
+            public:
+                FieldValuePrinter();
+                virtual ~FieldValuePrinter();
+                virtual std::string PrintBool(bool val) const;
+                virtual std::string PrintInt32(int32_t val) const;
+                virtual std::string PrintUInt32(uint32_t val) const;
+                virtual std::string PrintInt64(int64_t val) const;
+                virtual std::string PrintUInt64(uint64_t val) const;
+                virtual std::string PrintFloat(float val) const;
+                virtual std::string PrintDouble(double val) const;
+                virtual std::string PrintString(const std::string& val) const;
+                virtual std::string PrintBytes(const std::string& val) const;
+                virtual std::string PrintEnum(int32_t val, const std::string& name) const;
+                virtual std::string PrintFieldName(const Message& message, const Reflection* reflection, const FieldDescriptor* field) const;
+                virtual std::string PrintMessageStart(const Message& message, int field_index, int field_count, bool single_line_mode) const;
+                virtual std::string PrintMessageEnd(const Message& message, int field_index, int field_count, bool single_line_mode) const;
+
+            private:
+                FastFieldValuePrinter delegate_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldValuePrinter);
+            };
+
+            class PROTOBUF_EXPORT MessagePrinter
+            {
+            public:
+                MessagePrinter()
+                {
+                }
+                virtual ~MessagePrinter()
+                {
+                }
+                virtual void Print(const Message& message, bool single_line_mode, BaseTextGenerator* generator) const = 0;
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessagePrinter);
+            };
+
+            // Interface that Printers or Parsers can use to find extensions, or types
+            // referenced in Any messages.
+            class PROTOBUF_EXPORT Finder
+            {
+            public:
+                virtual ~Finder();
+
+                // Try to find an extension of *message by fully-qualified field
+                // name.  Returns nullptr if no extension is known for this name or number.
+                // The base implementation uses the extensions already known by the message.
+                virtual const FieldDescriptor* FindExtension(Message* message, const std::string& name) const;
+
+                // Similar to FindExtension, but uses a Descriptor and the extension number
+                // instead of using a Message and the name when doing the look up.
+                virtual const FieldDescriptor* FindExtensionByNumber(
+                    const Descriptor* descriptor, int number
+                ) const;
+
+                // Find the message type for an Any proto.
+                // Returns nullptr if no message is known for this name.
+                // The base implementation only accepts prefixes of type.googleprod.com/ or
+                // type.googleapis.com/, and searches the DescriptorPool of the parent
+                // message.
+                virtual const Descriptor* FindAnyType(const Message& message, const std::string& prefix, const std::string& name) const;
+
+                // Find the message factory for the given extension field. This can be used
+                // to generalize the Parser to add extension fields to a message in the same
+                // way as the "input" message for the Parser.
+                virtual MessageFactory* FindExtensionFactory(
+                    const FieldDescriptor* field
+                ) const;
+            };
+
+            // Class for those users which require more fine-grained control over how
+            // a protobuffer message is printed out.
+            class PROTOBUF_EXPORT Printer
+            {
+            public:
+                Printer();
+
+                // Like TextFormat::Print
+                bool Print(const Message& message, io::ZeroCopyOutputStream* output) const;
+                // Like TextFormat::PrintUnknownFields
+                bool PrintUnknownFields(const UnknownFieldSet& unknown_fields, io::ZeroCopyOutputStream* output) const;
+                // Like TextFormat::PrintToString
+                bool PrintToString(const Message& message, std::string* output) const;
+                // Like TextFormat::PrintUnknownFieldsToString
+                bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields, std::string* output) const;
+                // Like TextFormat::PrintFieldValueToString
+                void PrintFieldValueToString(const Message& message, const FieldDescriptor* field, int index, std::string* output) const;
+
+                // Adjust the initial indent level of all output.  Each indent level is
+                // equal to two spaces.
+                void SetInitialIndentLevel(int indent_level)
+                {
+                    initial_indent_level_ = indent_level;
+                }
+
+                // If printing in single line mode, then the entire message will be output
+                // on a single line with no line breaks.
+                void SetSingleLineMode(bool single_line_mode)
+                {
+                    single_line_mode_ = single_line_mode;
+                }
+
+                bool IsInSingleLineMode() const
+                {
+                    return single_line_mode_;
+                }
+
+                // If use_field_number is true, uses field number instead of field name.
+                void SetUseFieldNumber(bool use_field_number)
+                {
+                    use_field_number_ = use_field_number;
+                }
+
+                // Set true to print repeated primitives in a format like:
+                //   field_name: [1, 2, 3, 4]
+                // instead of printing each value on its own line.  Short format applies
+                // only to primitive values -- i.e. everything except strings and
+                // sub-messages/groups.
+                void SetUseShortRepeatedPrimitives(bool use_short_repeated_primitives)
+                {
+                    use_short_repeated_primitives_ = use_short_repeated_primitives;
+                }
+
+                // Set true to output UTF-8 instead of ASCII.  The only difference
+                // is that bytes >= 0x80 in string fields will not be escaped,
+                // because they are assumed to be part of UTF-8 multi-byte
+                // sequences. This will change the default FastFieldValuePrinter.
+                void SetUseUtf8StringEscaping(bool as_utf8);
+
+                // Set the default FastFieldValuePrinter that is used for all fields that
+                // don't have a field-specific printer registered.
+                // Takes ownership of the printer.
+                void SetDefaultFieldValuePrinter(const FastFieldValuePrinter* printer);
+
+                PROTOBUF_DEPRECATED_MSG("Please use FastFieldValuePrinter")
+                void SetDefaultFieldValuePrinter(const FieldValuePrinter* printer);
+
+                // Sets whether we want to hide unknown fields or not.
+                // Usually unknown fields are printed in a generic way that includes the
+                // tag number of the field instead of field name. However, sometimes it
+                // is useful to be able to print the message without unknown fields (e.g.
+                // for the python protobuf version to maintain consistency between its pure
+                // python and c++ implementations).
+                void SetHideUnknownFields(bool hide)
+                {
+                    hide_unknown_fields_ = hide;
+                }
+
+                // If print_message_fields_in_index_order is true, fields of a proto message
+                // will be printed using the order defined in source code instead of the
+                // field number, extensions will be printed at the end of the message
+                // and their relative order is determined by the extension number.
+                // By default, use the field number order.
+                void SetPrintMessageFieldsInIndexOrder(
+                    bool print_message_fields_in_index_order
+                )
+                {
+                    print_message_fields_in_index_order_ =
+                        print_message_fields_in_index_order;
+                }
+
+                // If expand==true, expand google.protobuf.Any payloads. The output
+                // will be of form
+                //    [type_url] { <value_printed_in_text> }
+                //
+                // If expand==false, print Any using the default printer. The output will
+                // look like
+                //    type_url: "<type_url>"  value: "serialized_content"
+                void SetExpandAny(bool expand)
+                {
+                    expand_any_ = expand;
+                }
+
+                // Set how parser finds message for Any payloads.
+                void SetFinder(const Finder* finder)
+                {
+                    finder_ = finder;
+                }
+
+                // If non-zero, we truncate all string fields that are  longer than
+                // this threshold.  This is useful when the proto message has very long
+                // strings, e.g., dump of encoded image file.
+                //
+                // NOTE(hfgong):  Setting a non-zero value breaks round-trip safe
+                // property of TextFormat::Printer.  That is, from the printed message, we
+                // cannot fully recover the original string field any more.
+                void SetTruncateStringFieldLongerThan(
+                    const int64_t truncate_string_field_longer_than
+                )
+                {
+                    truncate_string_field_longer_than_ = truncate_string_field_longer_than;
+                }
+
+                // Register a custom field-specific FastFieldValuePrinter for fields
+                // with a particular FieldDescriptor.
+                // Returns "true" if the registration succeeded, or "false", if there is
+                // already a printer for that FieldDescriptor.
+                // Takes ownership of the printer on successful registration.
+                bool RegisterFieldValuePrinter(const FieldDescriptor* field, const FastFieldValuePrinter* printer);
+
+                PROTOBUF_DEPRECATED_MSG("Please use FastFieldValuePrinter")
+                bool RegisterFieldValuePrinter(const FieldDescriptor* field, const FieldValuePrinter* printer);
+
+                // Register a custom message-specific MessagePrinter for messages with a
+                // particular Descriptor.
+                // Returns "true" if the registration succeeded, or "false" if there is
+                // already a printer for that Descriptor.
+                bool RegisterMessagePrinter(const Descriptor* descriptor, const MessagePrinter* printer);
+
+            private:
+                friend std::string Message::DebugString() const;
+                friend std::string Message::ShortDebugString() const;
+                friend std::string Message::Utf8DebugString() const;
+
+                // Sets whether *DebugString should insert a silent marker.
+                void SetInsertSilentMarker(bool v)
+                {
+                    insert_silent_marker_ = v;
+                }
+
+                // Forward declaration of an internal class used to print the text
+                // output to the OutputStream (see text_format.cc for implementation).
+                class TextGenerator;
+
+                // Forward declaration of an internal class used to print field values for
+                // DebugString APIs (see text_format.cc for implementation).
+                class DebugStringFieldValuePrinter;
+
+                // Forward declaration of an internal class used to print UTF-8 escaped
+                // strings (see text_format.cc for implementation).
+                class FastFieldValuePrinterUtf8Escaping;
+
+                static const char* const kDoNotParse;
+
+                // Internal Print method, used for writing to the OutputStream via
+                // the TextGenerator class.
+                void Print(const Message& message, TextGenerator* generator) const;
+
+                // Print a single field.
+                void PrintField(const Message& message, const Reflection* reflection, const FieldDescriptor* field, TextGenerator* generator) const;
+
+                // Print a repeated primitive field in short form.
+                void PrintShortRepeatedField(const Message& message, const Reflection* reflection, const FieldDescriptor* field, TextGenerator* generator) const;
+
+                // Print the name of a field -- i.e. everything that comes before the
+                // ':' for a single name/value pair.
+                void PrintFieldName(const Message& message, int field_index, int field_count, const Reflection* reflection, const FieldDescriptor* field, TextGenerator* generator) const;
+
+                // Outputs a textual representation of the value of the field supplied on
+                // the message supplied or the default value if not set.
+                void PrintFieldValue(const Message& message, const Reflection* reflection, const FieldDescriptor* field, int index, TextGenerator* generator) const;
+
+                // Print the fields in an UnknownFieldSet.  They are printed by tag number
+                // only.  Embedded messages are heuristically identified by attempting to
+                // parse them (subject to the recursion budget).
+                void PrintUnknownFields(const UnknownFieldSet& unknown_fields, TextGenerator* generator, int recursion_budget) const;
+
+                bool PrintAny(const Message& message, TextGenerator* generator) const;
+
+                const FastFieldValuePrinter* GetFieldPrinter(
+                    const FieldDescriptor* field
+                ) const
+                {
+                    auto it = custom_printers_.find(field);
+                    return it == custom_printers_.end() ? default_field_value_printer_.get() : it->second.get();
+                }
+
+                int initial_indent_level_;
+                bool single_line_mode_;
+                bool use_field_number_;
+                bool use_short_repeated_primitives_;
+                bool insert_silent_marker_;
+                bool hide_unknown_fields_;
+                bool print_message_fields_in_index_order_;
+                bool expand_any_;
+                int64_t truncate_string_field_longer_than_;
+
+                std::unique_ptr<const FastFieldValuePrinter> default_field_value_printer_;
+                typedef std::map<const FieldDescriptor*, std::unique_ptr<const FastFieldValuePrinter>>
+                    CustomPrinterMap;
+                CustomPrinterMap custom_printers_;
+
+                typedef std::map<const Descriptor*, std::unique_ptr<const MessagePrinter>>
+                    CustomMessagePrinterMap;
+                CustomMessagePrinterMap custom_message_printers_;
+
+                const Finder* finder_;
+            };
+
+            // Parses a text-format protocol message from the given input stream to
+            // the given message object. This function parses the human-readable
+            // serialization format written by Print(). Returns true on success. The
+            // message is cleared first, even if the function fails -- See Merge() to
+            // avoid this behavior.
+            //
+            // Example input: "user {\n id: 123 extra { gender: MALE language: 'en' }\n}"
+            //
+            // One common use for this function is parsing handwritten strings in test
+            // code.
+            //
+            // If you would like to read a protocol buffer serialized in the
+            // (non-human-readable) binary wire format, see
+            // google::protobuf::MessageLite::ParseFromString().
+            static bool Parse(io::ZeroCopyInputStream* input, Message* output);
+            // Like Parse(), but reads directly from a string.
+            static bool ParseFromString(ConstStringParam input, Message* output);
+
+            // Like Parse(), but the data is merged into the given message, as if
+            // using Message::MergeFrom().
+            static bool Merge(io::ZeroCopyInputStream* input, Message* output);
+            // Like Merge(), but reads directly from a string.
+            static bool MergeFromString(ConstStringParam input, Message* output);
+
+            // Parse the given text as a single field value and store it into the
+            // given field of the given message. If the field is a repeated field,
+            // the new value will be added to the end
+            static bool ParseFieldValueFromString(const std::string& input, const FieldDescriptor* field, Message* message);
+
+            // A location in the parsed text.
+            struct ParseLocation
+            {
+                int line;
+                int column;
+
+                ParseLocation() :
+                    line(-1),
+                    column(-1)
+                {
+                }
+                ParseLocation(int line_param, int column_param) :
+                    line(line_param),
+                    column(column_param)
+                {
+                }
+            };
+
+            // A range of locations in the parsed text, including `start` and excluding
+            // `end`.
+            struct ParseLocationRange
+            {
+                ParseLocation start;
+                ParseLocation end;
+                ParseLocationRange() :
+                    start(),
+                    end()
+                {
+                }
+                ParseLocationRange(ParseLocation start_param, ParseLocation end_param) :
+                    start(start_param),
+                    end(end_param)
+                {
+                }
+            };
+
+            // Data structure which is populated with the locations of each field
+            // value parsed from the text.
+            class PROTOBUF_EXPORT ParseInfoTree
+            {
+            public:
+                ParseInfoTree() = default;
+                ParseInfoTree(const ParseInfoTree&) = delete;
+                ParseInfoTree& operator=(const ParseInfoTree&) = delete;
+
+                // Returns the parse location range for index-th value of the field in
+                // the parsed text. If none exists, returns a location with start and end
+                // line -1. Index should be -1 for not-repeated fields.
+                ParseLocationRange GetLocationRange(const FieldDescriptor* field, int index) const;
+
+                // Returns the starting parse location for index-th value of the field in
+                // the parsed text. If none exists, returns a location with line = -1. Index
+                // should be -1 for not-repeated fields.
+                ParseLocation GetLocation(const FieldDescriptor* field, int index) const
+                {
+                    return GetLocationRange(field, index).start;
+                }
+
+                // Returns the parse info tree for the given field, which must be a message
+                // type. The nested information tree is owned by the root tree and will be
+                // deleted when it is deleted.
+                ParseInfoTree* GetTreeForNested(const FieldDescriptor* field, int index) const;
+
+            private:
+                // Allow the text format parser to record information into the tree.
+                friend class TextFormat;
+
+                // Records the starting and ending locations of a single value for a field.
+                void RecordLocation(const FieldDescriptor* field, ParseLocationRange range);
+
+                // Create and records a nested tree for a nested message field.
+                ParseInfoTree* CreateNested(const FieldDescriptor* field);
+
+                // Defines the map from the index-th field descriptor to its parse location.
+                typedef std::map<const FieldDescriptor*, std::vector<ParseLocationRange>>
+                    LocationMap;
+
+                // Defines the map from the index-th field descriptor to the nested parse
+                // info tree.
+                typedef std::map<const FieldDescriptor*, std::vector<std::unique_ptr<ParseInfoTree>>>
+                    NestedMap;
+
+                LocationMap locations_;
+                NestedMap nested_;
+            };
+
+            // For more control over parsing, use this class.
+            class PROTOBUF_EXPORT Parser
+            {
+            public:
+                Parser();
+                ~Parser();
+
+                // Like TextFormat::Parse().
+                bool Parse(io::ZeroCopyInputStream* input, Message* output);
+                // Like TextFormat::ParseFromString().
+                bool ParseFromString(ConstStringParam input, Message* output);
+                // Like TextFormat::Merge().
+                bool Merge(io::ZeroCopyInputStream* input, Message* output);
+                // Like TextFormat::MergeFromString().
+                bool MergeFromString(ConstStringParam input, Message* output);
+
+                // Set where to report parse errors.  If nullptr (the default), errors will
+                // be printed to stderr.
+                void RecordErrorsTo(io::ErrorCollector* error_collector)
+                {
+                    error_collector_ = error_collector;
+                }
+
+                // Set how parser finds extensions.  If nullptr (the default), the
+                // parser will use the standard Reflection object associated with
+                // the message being parsed.
+                void SetFinder(const Finder* finder)
+                {
+                    finder_ = finder;
+                }
+
+                // Sets where location information about the parse will be written. If
+                // nullptr
+                // (the default), then no location will be written.
+                void WriteLocationsTo(ParseInfoTree* tree)
+                {
+                    parse_info_tree_ = tree;
+                }
+
+                // Normally parsing fails if, after parsing, output->IsInitialized()
+                // returns false.  Call AllowPartialMessage(true) to skip this check.
+                void AllowPartialMessage(bool allow)
+                {
+                    allow_partial_ = allow;
+                }
+
+                // Allow field names to be matched case-insensitively.
+                // This is not advisable if there are fields that only differ in case, or
+                // if you want to enforce writing in the canonical form.
+                // This is 'false' by default.
+                void AllowCaseInsensitiveField(bool allow)
+                {
+                    allow_case_insensitive_field_ = allow;
+                }
+
+                // Like TextFormat::ParseFieldValueFromString
+                bool ParseFieldValueFromString(const std::string& input, const FieldDescriptor* field, Message* output);
+
+                // When an unknown extension is met, parsing will fail if this option is
+                // set to false (the default). If true, unknown extensions will be ignored
+                // and a warning message will be generated.
+                // Beware! Setting this option true may hide some errors (e.g. spelling
+                // error on extension name).  This allows data loss; unlike binary format,
+                // text format cannot preserve unknown extensions.  Avoid using this option
+                // if possible.
+                void AllowUnknownExtension(bool allow)
+                {
+                    allow_unknown_extension_ = allow;
+                }
+
+                // When an unknown field is met, parsing will fail if this option is set
+                // to false (the default). If true, unknown fields will be ignored and
+                // a warning message will be generated.
+                // Beware! Setting this option true may hide some errors (e.g. spelling
+                // error on field name). This allows data loss; unlike binary format, text
+                // format cannot preserve unknown fields.  Avoid using this option
+                // if possible.
+                void AllowUnknownField(bool allow)
+                {
+                    allow_unknown_field_ = allow;
+                }
+
+                void AllowFieldNumber(bool allow)
+                {
+                    allow_field_number_ = allow;
+                }
+
+                // Sets maximum recursion depth which parser can use. This is effectively
+                // the maximum allowed nesting of proto messages.
+                void SetRecursionLimit(int limit)
+                {
+                    recursion_limit_ = limit;
+                }
+
+            private:
+                // Forward declaration of an internal class used to parse text
+                // representations (see text_format.cc for implementation).
+                class ParserImpl;
+
+                // Like TextFormat::Merge().  The provided implementation is used
+                // to do the parsing.
+                bool MergeUsingImpl(io::ZeroCopyInputStream* input, Message* output, ParserImpl* parser_impl);
+
+                io::ErrorCollector* error_collector_;
+                const Finder* finder_;
+                ParseInfoTree* parse_info_tree_;
+                bool allow_partial_;
+                bool allow_case_insensitive_field_;
+                bool allow_unknown_field_;
+                bool allow_unknown_extension_;
+                bool allow_unknown_enum_;
+                bool allow_field_number_;
+                bool allow_relaxed_whitespace_;
+                bool allow_singular_overwrites_;
+                int recursion_limit_;
+            };
+
+        private:
+            // Hack: ParseInfoTree declares TextFormat as a friend which should extend
+            // the friendship to TextFormat::Parser::ParserImpl, but unfortunately some
+            // old compilers (e.g. GCC 3.4.6) don't implement this correctly. We provide
+            // helpers for ParserImpl to call methods of ParseInfoTree.
+            static inline void RecordLocation(ParseInfoTree* info_tree, const FieldDescriptor* field, ParseLocationRange location);
+            static inline ParseInfoTree* CreateNested(ParseInfoTree* info_tree, const FieldDescriptor* field);
+
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TextFormat);
+        };
+
+        inline void TextFormat::RecordLocation(ParseInfoTree* info_tree, const FieldDescriptor* field, ParseLocationRange location)
+        {
+            info_tree->RecordLocation(field, location);
+        }
+
+        inline TextFormat::ParseInfoTree* TextFormat::CreateNested(
+            ParseInfoTree* info_tree, const FieldDescriptor* field
+        )
+        {
+            return info_tree->CreateNested(field);
+        }
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/timestamp.pb.h b/CAPI/cpp/grpc/include/google/protobuf/timestamp.pb.h
index 6633822..14e9e36 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/timestamp.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/timestamp.pb.h
@@ -28,20 +28,22 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2ftimestamp_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ftimestamp_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ftimestamp_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ftimestamp_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -50,222 +52,275 @@ struct TimestampDefaultTypeInternal;
 PROTOBUF_EXPORT extern TimestampDefaultTypeInternal _Timestamp_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Timestamp* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Timestamp* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Timestamp>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
 // ===================================================================
 
 class PROTOBUF_EXPORT Timestamp final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Timestamp) */ {
- public:
-  inline Timestamp() : Timestamp(nullptr) {}
-  ~Timestamp() override;
-  explicit PROTOBUF_CONSTEXPR Timestamp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Timestamp(const Timestamp& from);
-  Timestamp(Timestamp&& from) noexcept
-    : Timestamp() {
-    *this = ::std::move(from);
-  }
-
-  inline Timestamp& operator=(const Timestamp& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Timestamp& operator=(Timestamp&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Timestamp) */
+{
+public:
+    inline Timestamp() :
+        Timestamp(nullptr)
+    {
     }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Timestamp& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Timestamp* internal_default_instance() {
-    return reinterpret_cast<const Timestamp*>(
-               &_Timestamp_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(Timestamp& a, Timestamp& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Timestamp* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    ~Timestamp() override;
+    explicit PROTOBUF_CONSTEXPR Timestamp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Timestamp(const Timestamp& from);
+    Timestamp(Timestamp&& from) noexcept
+        :
+        Timestamp()
+    {
+        *this = ::std::move(from);
     }
-  }
-  void UnsafeArenaSwap(Timestamp* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Timestamp>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Timestamp& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Timestamp& from) {
-    Timestamp::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Timestamp* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Timestamp";
-  }
-  protected:
-  explicit Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kSecondsFieldNumber = 1,
-    kNanosFieldNumber = 2,
-  };
-  // int64 seconds = 1;
-  void clear_seconds();
-  int64_t seconds() const;
-  void set_seconds(int64_t value);
-  private:
-  int64_t _internal_seconds() const;
-  void _internal_set_seconds(int64_t value);
-  public:
-
-  // int32 nanos = 2;
-  void clear_nanos();
-  int32_t nanos() const;
-  void set_nanos(int32_t value);
-  private:
-  int32_t _internal_nanos() const;
-  void _internal_set_nanos(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Timestamp)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    int64_t seconds_;
-    int32_t nanos_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2ftimestamp_2eproto;
+
+    inline Timestamp& operator=(const Timestamp& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Timestamp& operator=(Timestamp&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Timestamp& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Timestamp* internal_default_instance()
+    {
+        return reinterpret_cast<const Timestamp*>(
+            &_Timestamp_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(Timestamp& a, Timestamp& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Timestamp* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Timestamp* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Timestamp>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Timestamp& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Timestamp& from)
+    {
+        Timestamp::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Timestamp* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Timestamp";
+    }
+
+protected:
+    explicit Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kSecondsFieldNumber = 1,
+        kNanosFieldNumber = 2,
+    };
+    // int64 seconds = 1;
+    void clear_seconds();
+    int64_t seconds() const;
+    void set_seconds(int64_t value);
+
+private:
+    int64_t _internal_seconds() const;
+    void _internal_set_seconds(int64_t value);
+
+public:
+    // int32 nanos = 2;
+    void clear_nanos();
+    int32_t nanos() const;
+    void set_nanos(int32_t value);
+
+private:
+    int32_t _internal_nanos() const;
+    void _internal_set_nanos(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Timestamp)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        int64_t seconds_;
+        int32_t nanos_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2ftimestamp_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // Timestamp
 
 // int64 seconds = 1;
-inline void Timestamp::clear_seconds() {
-  _impl_.seconds_ = int64_t{0};
+inline void Timestamp::clear_seconds()
+{
+    _impl_.seconds_ = int64_t{0};
 }
-inline int64_t Timestamp::_internal_seconds() const {
-  return _impl_.seconds_;
+inline int64_t Timestamp::_internal_seconds() const
+{
+    return _impl_.seconds_;
 }
-inline int64_t Timestamp::seconds() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.seconds)
-  return _internal_seconds();
+inline int64_t Timestamp::seconds() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.seconds)
+    return _internal_seconds();
 }
-inline void Timestamp::_internal_set_seconds(int64_t value) {
-  
-  _impl_.seconds_ = value;
+inline void Timestamp::_internal_set_seconds(int64_t value)
+{
+    _impl_.seconds_ = value;
 }
-inline void Timestamp::set_seconds(int64_t value) {
-  _internal_set_seconds(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.seconds)
+inline void Timestamp::set_seconds(int64_t value)
+{
+    _internal_set_seconds(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.seconds)
 }
 
 // int32 nanos = 2;
-inline void Timestamp::clear_nanos() {
-  _impl_.nanos_ = 0;
+inline void Timestamp::clear_nanos()
+{
+    _impl_.nanos_ = 0;
 }
-inline int32_t Timestamp::_internal_nanos() const {
-  return _impl_.nanos_;
+inline int32_t Timestamp::_internal_nanos() const
+{
+    return _impl_.nanos_;
 }
-inline int32_t Timestamp::nanos() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.nanos)
-  return _internal_nanos();
+inline int32_t Timestamp::nanos() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.nanos)
+    return _internal_nanos();
 }
-inline void Timestamp::_internal_set_nanos(int32_t value) {
-  
-  _impl_.nanos_ = value;
+inline void Timestamp::_internal_set_nanos(int32_t value)
+{
+    _impl_.nanos_ = value;
 }
-inline void Timestamp::set_nanos(int32_t value) {
-  _internal_set_nanos(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.nanos)
+inline void Timestamp::set_nanos(int32_t value)
+{
+    _internal_set_nanos(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.nanos)
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 
 // @@protoc_insertion_point(namespace_scope)
diff --git a/CAPI/cpp/grpc/include/google/protobuf/type.pb.h b/CAPI/cpp/grpc/include/google/protobuf/type.pb.h
index 0f11e6c..a888b2c 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/type.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/type.pb.h
@@ -28,7 +28,7 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
 #include <google/protobuf/any.pb.h>
@@ -37,14 +37,16 @@
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2ftype_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ftype_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2ftype_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2ftype_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -65,36 +67,42 @@ struct TypeDefaultTypeInternal;
 PROTOBUF_EXPORT extern TypeDefaultTypeInternal _Type_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Enum* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Enum>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValue>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Field* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Field>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Option* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Option>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Type* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Type>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Enum* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Enum>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::EnumValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumValue>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Field* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Field>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Option* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Option>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Type* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Type>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
-enum Field_Kind : int {
-  Field_Kind_TYPE_UNKNOWN = 0,
-  Field_Kind_TYPE_DOUBLE = 1,
-  Field_Kind_TYPE_FLOAT = 2,
-  Field_Kind_TYPE_INT64 = 3,
-  Field_Kind_TYPE_UINT64 = 4,
-  Field_Kind_TYPE_INT32 = 5,
-  Field_Kind_TYPE_FIXED64 = 6,
-  Field_Kind_TYPE_FIXED32 = 7,
-  Field_Kind_TYPE_BOOL = 8,
-  Field_Kind_TYPE_STRING = 9,
-  Field_Kind_TYPE_GROUP = 10,
-  Field_Kind_TYPE_MESSAGE = 11,
-  Field_Kind_TYPE_BYTES = 12,
-  Field_Kind_TYPE_UINT32 = 13,
-  Field_Kind_TYPE_ENUM = 14,
-  Field_Kind_TYPE_SFIXED32 = 15,
-  Field_Kind_TYPE_SFIXED64 = 16,
-  Field_Kind_TYPE_SINT32 = 17,
-  Field_Kind_TYPE_SINT64 = 18,
-  Field_Kind_Field_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-  Field_Kind_Field_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+enum Field_Kind : int
+{
+    Field_Kind_TYPE_UNKNOWN = 0,
+    Field_Kind_TYPE_DOUBLE = 1,
+    Field_Kind_TYPE_FLOAT = 2,
+    Field_Kind_TYPE_INT64 = 3,
+    Field_Kind_TYPE_UINT64 = 4,
+    Field_Kind_TYPE_INT32 = 5,
+    Field_Kind_TYPE_FIXED64 = 6,
+    Field_Kind_TYPE_FIXED32 = 7,
+    Field_Kind_TYPE_BOOL = 8,
+    Field_Kind_TYPE_STRING = 9,
+    Field_Kind_TYPE_GROUP = 10,
+    Field_Kind_TYPE_MESSAGE = 11,
+    Field_Kind_TYPE_BYTES = 12,
+    Field_Kind_TYPE_UINT32 = 13,
+    Field_Kind_TYPE_ENUM = 14,
+    Field_Kind_TYPE_SFIXED32 = 15,
+    Field_Kind_TYPE_SFIXED64 = 16,
+    Field_Kind_TYPE_SINT32 = 17,
+    Field_Kind_TYPE_SINT64 = 18,
+    Field_Kind_Field_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+    Field_Kind_Field_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
 };
 PROTOBUF_EXPORT bool Field_Kind_IsValid(int value);
 constexpr Field_Kind Field_Kind_Kind_MIN = Field_Kind_TYPE_UNKNOWN;
@@ -103,25 +111,29 @@ constexpr int Field_Kind_Kind_ARRAYSIZE = Field_Kind_Kind_MAX + 1;
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Field_Kind_descriptor();
 template<typename T>
-inline const std::string& Field_Kind_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, Field_Kind>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function Field_Kind_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    Field_Kind_descriptor(), enum_t_value);
+inline const std::string& Field_Kind_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, Field_Kind>::value || ::std::is_integral<T>::value, "Incorrect type passed to function Field_Kind_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        Field_Kind_descriptor(), enum_t_value
+    );
 }
 inline bool Field_Kind_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Field_Kind* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Field_Kind>(
-    Field_Kind_descriptor(), name, value);
-}
-enum Field_Cardinality : int {
-  Field_Cardinality_CARDINALITY_UNKNOWN = 0,
-  Field_Cardinality_CARDINALITY_OPTIONAL = 1,
-  Field_Cardinality_CARDINALITY_REQUIRED = 2,
-  Field_Cardinality_CARDINALITY_REPEATED = 3,
-  Field_Cardinality_Field_Cardinality_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-  Field_Cardinality_Field_Cardinality_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Field_Kind* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Field_Kind>(
+        Field_Kind_descriptor(), name, value
+    );
+}
+enum Field_Cardinality : int
+{
+    Field_Cardinality_CARDINALITY_UNKNOWN = 0,
+    Field_Cardinality_CARDINALITY_OPTIONAL = 1,
+    Field_Cardinality_CARDINALITY_REQUIRED = 2,
+    Field_Cardinality_CARDINALITY_REPEATED = 3,
+    Field_Cardinality_Field_Cardinality_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+    Field_Cardinality_Field_Cardinality_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
 };
 PROTOBUF_EXPORT bool Field_Cardinality_IsValid(int value);
 constexpr Field_Cardinality Field_Cardinality_Cardinality_MIN = Field_Cardinality_CARDINALITY_UNKNOWN;
@@ -130,23 +142,27 @@ constexpr int Field_Cardinality_Cardinality_ARRAYSIZE = Field_Cardinality_Cardin
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Field_Cardinality_descriptor();
 template<typename T>
-inline const std::string& Field_Cardinality_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, Field_Cardinality>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function Field_Cardinality_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    Field_Cardinality_descriptor(), enum_t_value);
+inline const std::string& Field_Cardinality_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, Field_Cardinality>::value || ::std::is_integral<T>::value, "Incorrect type passed to function Field_Cardinality_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        Field_Cardinality_descriptor(), enum_t_value
+    );
 }
 inline bool Field_Cardinality_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Field_Cardinality* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Field_Cardinality>(
-    Field_Cardinality_descriptor(), name, value);
-}
-enum Syntax : int {
-  SYNTAX_PROTO2 = 0,
-  SYNTAX_PROTO3 = 1,
-  Syntax_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
-  Syntax_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Field_Cardinality* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Field_Cardinality>(
+        Field_Cardinality_descriptor(), name, value
+    );
+}
+enum Syntax : int
+{
+    SYNTAX_PROTO2 = 0,
+    SYNTAX_PROTO3 = 1,
+    Syntax_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+    Syntax_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
 };
 PROTOBUF_EXPORT bool Syntax_IsValid(int value);
 constexpr Syntax Syntax_MIN = SYNTAX_PROTO2;
@@ -155,1542 +171,1889 @@ constexpr int Syntax_ARRAYSIZE = Syntax_MAX + 1;
 
 PROTOBUF_EXPORT const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Syntax_descriptor();
 template<typename T>
-inline const std::string& Syntax_Name(T enum_t_value) {
-  static_assert(::std::is_same<T, Syntax>::value ||
-    ::std::is_integral<T>::value,
-    "Incorrect type passed to function Syntax_Name.");
-  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
-    Syntax_descriptor(), enum_t_value);
+inline const std::string& Syntax_Name(T enum_t_value)
+{
+    static_assert(::std::is_same<T, Syntax>::value || ::std::is_integral<T>::value, "Incorrect type passed to function Syntax_Name.");
+    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+        Syntax_descriptor(), enum_t_value
+    );
 }
 inline bool Syntax_Parse(
-    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Syntax* value) {
-  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Syntax>(
-    Syntax_descriptor(), name, value);
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Syntax* value
+)
+{
+    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Syntax>(
+        Syntax_descriptor(), name, value
+    );
 }
 // ===================================================================
 
 class PROTOBUF_EXPORT Type final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Type) */ {
- public:
-  inline Type() : Type(nullptr) {}
-  ~Type() override;
-  explicit PROTOBUF_CONSTEXPR Type(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Type(const Type& from);
-  Type(Type&& from) noexcept
-    : Type() {
-    *this = ::std::move(from);
-  }
-
-  inline Type& operator=(const Type& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Type& operator=(Type&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Type& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Type* internal_default_instance() {
-    return reinterpret_cast<const Type*>(
-               &_Type_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(Type& a, Type& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Type* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Type* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Type* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Type>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Type& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Type& from) {
-    Type::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Type* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Type";
-  }
-  protected:
-  explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kFieldsFieldNumber = 2,
-    kOneofsFieldNumber = 3,
-    kOptionsFieldNumber = 4,
-    kNameFieldNumber = 1,
-    kSourceContextFieldNumber = 5,
-    kSyntaxFieldNumber = 6,
-  };
-  // repeated .google.protobuf.Field fields = 2;
-  int fields_size() const;
-  private:
-  int _internal_fields_size() const;
-  public:
-  void clear_fields();
-  ::PROTOBUF_NAMESPACE_ID::Field* mutable_fields(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field >*
-      mutable_fields();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Field& _internal_fields(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Field* _internal_add_fields();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Field& fields(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Field* add_fields();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field >&
-      fields() const;
-
-  // repeated string oneofs = 3;
-  int oneofs_size() const;
-  private:
-  int _internal_oneofs_size() const;
-  public:
-  void clear_oneofs();
-  const std::string& oneofs(int index) const;
-  std::string* mutable_oneofs(int index);
-  void set_oneofs(int index, const std::string& value);
-  void set_oneofs(int index, std::string&& value);
-  void set_oneofs(int index, const char* value);
-  void set_oneofs(int index, const char* value, size_t size);
-  std::string* add_oneofs();
-  void add_oneofs(const std::string& value);
-  void add_oneofs(std::string&& value);
-  void add_oneofs(const char* value);
-  void add_oneofs(const char* value, size_t size);
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& oneofs() const;
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_oneofs();
-  private:
-  const std::string& _internal_oneofs(int index) const;
-  std::string* _internal_add_oneofs();
-  public:
-
-  // repeated .google.protobuf.Option options = 4;
-  int options_size() const;
-  private:
-  int _internal_options_size() const;
-  public:
-  void clear_options();
-  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-      mutable_options();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-      options() const;
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // .google.protobuf.SourceContext source_context = 5;
-  bool has_source_context() const;
-  private:
-  bool _internal_has_source_context() const;
-  public:
-  void clear_source_context();
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
-  void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
-  public:
-  void unsafe_arena_set_allocated_source_context(
-      ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
-
-  // .google.protobuf.Syntax syntax = 6;
-  void clear_syntax();
-  ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
-  void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
-  void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Type)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field > fields_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> oneofs_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
-    int syntax_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Type) */
+{
+public:
+    inline Type() :
+        Type(nullptr)
+    {
+    }
+    ~Type() override;
+    explicit PROTOBUF_CONSTEXPR Type(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Type(const Type& from);
+    Type(Type&& from) noexcept
+        :
+        Type()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Type& operator=(const Type& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Type& operator=(Type&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Type& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Type* internal_default_instance()
+    {
+        return reinterpret_cast<const Type*>(
+            &_Type_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(Type& a, Type& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Type* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Type* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Type* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Type>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Type& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Type& from)
+    {
+        Type::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Type* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Type";
+    }
+
+protected:
+    explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kFieldsFieldNumber = 2,
+        kOneofsFieldNumber = 3,
+        kOptionsFieldNumber = 4,
+        kNameFieldNumber = 1,
+        kSourceContextFieldNumber = 5,
+        kSyntaxFieldNumber = 6,
+    };
+    // repeated .google.protobuf.Field fields = 2;
+    int fields_size() const;
+
+private:
+    int _internal_fields_size() const;
+
+public:
+    void clear_fields();
+    ::PROTOBUF_NAMESPACE_ID::Field* mutable_fields(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Field>*
+        mutable_fields();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Field& _internal_fields(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Field* _internal_add_fields();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Field& fields(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Field* add_fields();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Field>&
+        fields() const;
+
+    // repeated string oneofs = 3;
+    int oneofs_size() const;
+
+private:
+    int _internal_oneofs_size() const;
+
+public:
+    void clear_oneofs();
+    const std::string& oneofs(int index) const;
+    std::string* mutable_oneofs(int index);
+    void set_oneofs(int index, const std::string& value);
+    void set_oneofs(int index, std::string&& value);
+    void set_oneofs(int index, const char* value);
+    void set_oneofs(int index, const char* value, size_t size);
+    std::string* add_oneofs();
+    void add_oneofs(const std::string& value);
+    void add_oneofs(std::string&& value);
+    void add_oneofs(const char* value);
+    void add_oneofs(const char* value, size_t size);
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& oneofs() const;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_oneofs();
+
+private:
+    const std::string& _internal_oneofs(int index) const;
+    std::string* _internal_add_oneofs();
+
+public:
+    // repeated .google.protobuf.Option options = 4;
+    int options_size() const;
+
+private:
+    int _internal_options_size() const;
+
+public:
+    void clear_options();
+    ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+        mutable_options();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+        options() const;
+
+    // string name = 1;
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // .google.protobuf.SourceContext source_context = 5;
+    bool has_source_context() const;
+
+private:
+    bool _internal_has_source_context() const;
+
+public:
+    void clear_source_context();
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
+    void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
+
+public:
+    void unsafe_arena_set_allocated_source_context(
+        ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context
+    );
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
+
+    // .google.protobuf.Syntax syntax = 6;
+    void clear_syntax();
+    ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
+    void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
+    void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Type)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Field> fields_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> oneofs_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option> options_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
+        int syntax_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Field final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Field) */ {
- public:
-  inline Field() : Field(nullptr) {}
-  ~Field() override;
-  explicit PROTOBUF_CONSTEXPR Field(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Field(const Field& from);
-  Field(Field&& from) noexcept
-    : Field() {
-    *this = ::std::move(from);
-  }
-
-  inline Field& operator=(const Field& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Field& operator=(Field&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Field& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Field* internal_default_instance() {
-    return reinterpret_cast<const Field*>(
-               &_Field_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(Field& a, Field& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Field* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Field* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Field* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Field>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Field& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Field& from) {
-    Field::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Field* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Field";
-  }
-  protected:
-  explicit Field(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  typedef Field_Kind Kind;
-  static constexpr Kind TYPE_UNKNOWN =
-    Field_Kind_TYPE_UNKNOWN;
-  static constexpr Kind TYPE_DOUBLE =
-    Field_Kind_TYPE_DOUBLE;
-  static constexpr Kind TYPE_FLOAT =
-    Field_Kind_TYPE_FLOAT;
-  static constexpr Kind TYPE_INT64 =
-    Field_Kind_TYPE_INT64;
-  static constexpr Kind TYPE_UINT64 =
-    Field_Kind_TYPE_UINT64;
-  static constexpr Kind TYPE_INT32 =
-    Field_Kind_TYPE_INT32;
-  static constexpr Kind TYPE_FIXED64 =
-    Field_Kind_TYPE_FIXED64;
-  static constexpr Kind TYPE_FIXED32 =
-    Field_Kind_TYPE_FIXED32;
-  static constexpr Kind TYPE_BOOL =
-    Field_Kind_TYPE_BOOL;
-  static constexpr Kind TYPE_STRING =
-    Field_Kind_TYPE_STRING;
-  static constexpr Kind TYPE_GROUP =
-    Field_Kind_TYPE_GROUP;
-  static constexpr Kind TYPE_MESSAGE =
-    Field_Kind_TYPE_MESSAGE;
-  static constexpr Kind TYPE_BYTES =
-    Field_Kind_TYPE_BYTES;
-  static constexpr Kind TYPE_UINT32 =
-    Field_Kind_TYPE_UINT32;
-  static constexpr Kind TYPE_ENUM =
-    Field_Kind_TYPE_ENUM;
-  static constexpr Kind TYPE_SFIXED32 =
-    Field_Kind_TYPE_SFIXED32;
-  static constexpr Kind TYPE_SFIXED64 =
-    Field_Kind_TYPE_SFIXED64;
-  static constexpr Kind TYPE_SINT32 =
-    Field_Kind_TYPE_SINT32;
-  static constexpr Kind TYPE_SINT64 =
-    Field_Kind_TYPE_SINT64;
-  static inline bool Kind_IsValid(int value) {
-    return Field_Kind_IsValid(value);
-  }
-  static constexpr Kind Kind_MIN =
-    Field_Kind_Kind_MIN;
-  static constexpr Kind Kind_MAX =
-    Field_Kind_Kind_MAX;
-  static constexpr int Kind_ARRAYSIZE =
-    Field_Kind_Kind_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  Kind_descriptor() {
-    return Field_Kind_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& Kind_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, Kind>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function Kind_Name.");
-    return Field_Kind_Name(enum_t_value);
-  }
-  static inline bool Kind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      Kind* value) {
-    return Field_Kind_Parse(name, value);
-  }
-
-  typedef Field_Cardinality Cardinality;
-  static constexpr Cardinality CARDINALITY_UNKNOWN =
-    Field_Cardinality_CARDINALITY_UNKNOWN;
-  static constexpr Cardinality CARDINALITY_OPTIONAL =
-    Field_Cardinality_CARDINALITY_OPTIONAL;
-  static constexpr Cardinality CARDINALITY_REQUIRED =
-    Field_Cardinality_CARDINALITY_REQUIRED;
-  static constexpr Cardinality CARDINALITY_REPEATED =
-    Field_Cardinality_CARDINALITY_REPEATED;
-  static inline bool Cardinality_IsValid(int value) {
-    return Field_Cardinality_IsValid(value);
-  }
-  static constexpr Cardinality Cardinality_MIN =
-    Field_Cardinality_Cardinality_MIN;
-  static constexpr Cardinality Cardinality_MAX =
-    Field_Cardinality_Cardinality_MAX;
-  static constexpr int Cardinality_ARRAYSIZE =
-    Field_Cardinality_Cardinality_ARRAYSIZE;
-  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
-  Cardinality_descriptor() {
-    return Field_Cardinality_descriptor();
-  }
-  template<typename T>
-  static inline const std::string& Cardinality_Name(T enum_t_value) {
-    static_assert(::std::is_same<T, Cardinality>::value ||
-      ::std::is_integral<T>::value,
-      "Incorrect type passed to function Cardinality_Name.");
-    return Field_Cardinality_Name(enum_t_value);
-  }
-  static inline bool Cardinality_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
-      Cardinality* value) {
-    return Field_Cardinality_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kOptionsFieldNumber = 9,
-    kNameFieldNumber = 4,
-    kTypeUrlFieldNumber = 6,
-    kJsonNameFieldNumber = 10,
-    kDefaultValueFieldNumber = 11,
-    kKindFieldNumber = 1,
-    kCardinalityFieldNumber = 2,
-    kNumberFieldNumber = 3,
-    kOneofIndexFieldNumber = 7,
-    kPackedFieldNumber = 8,
-  };
-  // repeated .google.protobuf.Option options = 9;
-  int options_size() const;
-  private:
-  int _internal_options_size() const;
-  public:
-  void clear_options();
-  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-      mutable_options();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-      options() const;
-
-  // string name = 4;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // string type_url = 6;
-  void clear_type_url();
-  const std::string& type_url() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_type_url(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_type_url();
-  PROTOBUF_NODISCARD std::string* release_type_url();
-  void set_allocated_type_url(std::string* type_url);
-  private:
-  const std::string& _internal_type_url() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_url(const std::string& value);
-  std::string* _internal_mutable_type_url();
-  public:
-
-  // string json_name = 10;
-  void clear_json_name();
-  const std::string& json_name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_json_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_json_name();
-  PROTOBUF_NODISCARD std::string* release_json_name();
-  void set_allocated_json_name(std::string* json_name);
-  private:
-  const std::string& _internal_json_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_name(const std::string& value);
-  std::string* _internal_mutable_json_name();
-  public:
-
-  // string default_value = 11;
-  void clear_default_value();
-  const std::string& default_value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_default_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_default_value();
-  PROTOBUF_NODISCARD std::string* release_default_value();
-  void set_allocated_default_value(std::string* default_value);
-  private:
-  const std::string& _internal_default_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_value(const std::string& value);
-  std::string* _internal_mutable_default_value();
-  public:
-
-  // .google.protobuf.Field.Kind kind = 1;
-  void clear_kind();
-  ::PROTOBUF_NAMESPACE_ID::Field_Kind kind() const;
-  void set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::Field_Kind _internal_kind() const;
-  void _internal_set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value);
-  public:
-
-  // .google.protobuf.Field.Cardinality cardinality = 2;
-  void clear_cardinality();
-  ::PROTOBUF_NAMESPACE_ID::Field_Cardinality cardinality() const;
-  void set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::Field_Cardinality _internal_cardinality() const;
-  void _internal_set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value);
-  public:
-
-  // int32 number = 3;
-  void clear_number();
-  int32_t number() const;
-  void set_number(int32_t value);
-  private:
-  int32_t _internal_number() const;
-  void _internal_set_number(int32_t value);
-  public:
-
-  // int32 oneof_index = 7;
-  void clear_oneof_index();
-  int32_t oneof_index() const;
-  void set_oneof_index(int32_t value);
-  private:
-  int32_t _internal_oneof_index() const;
-  void _internal_set_oneof_index(int32_t value);
-  public:
-
-  // bool packed = 8;
-  void clear_packed();
-  bool packed() const;
-  void set_packed(bool value);
-  private:
-  bool _internal_packed() const;
-  void _internal_set_packed(bool value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Field)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_name_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_;
-    int kind_;
-    int cardinality_;
-    int32_t number_;
-    int32_t oneof_index_;
-    bool packed_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Field) */
+{
+public:
+    inline Field() :
+        Field(nullptr)
+    {
+    }
+    ~Field() override;
+    explicit PROTOBUF_CONSTEXPR Field(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Field(const Field& from);
+    Field(Field&& from) noexcept
+        :
+        Field()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Field& operator=(const Field& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Field& operator=(Field&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Field& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Field* internal_default_instance()
+    {
+        return reinterpret_cast<const Field*>(
+            &_Field_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        1;
+
+    friend void swap(Field& a, Field& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Field* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Field* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Field* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Field>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Field& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Field& from)
+    {
+        Field::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Field* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Field";
+    }
+
+protected:
+    explicit Field(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    typedef Field_Kind Kind;
+    static constexpr Kind TYPE_UNKNOWN =
+        Field_Kind_TYPE_UNKNOWN;
+    static constexpr Kind TYPE_DOUBLE =
+        Field_Kind_TYPE_DOUBLE;
+    static constexpr Kind TYPE_FLOAT =
+        Field_Kind_TYPE_FLOAT;
+    static constexpr Kind TYPE_INT64 =
+        Field_Kind_TYPE_INT64;
+    static constexpr Kind TYPE_UINT64 =
+        Field_Kind_TYPE_UINT64;
+    static constexpr Kind TYPE_INT32 =
+        Field_Kind_TYPE_INT32;
+    static constexpr Kind TYPE_FIXED64 =
+        Field_Kind_TYPE_FIXED64;
+    static constexpr Kind TYPE_FIXED32 =
+        Field_Kind_TYPE_FIXED32;
+    static constexpr Kind TYPE_BOOL =
+        Field_Kind_TYPE_BOOL;
+    static constexpr Kind TYPE_STRING =
+        Field_Kind_TYPE_STRING;
+    static constexpr Kind TYPE_GROUP =
+        Field_Kind_TYPE_GROUP;
+    static constexpr Kind TYPE_MESSAGE =
+        Field_Kind_TYPE_MESSAGE;
+    static constexpr Kind TYPE_BYTES =
+        Field_Kind_TYPE_BYTES;
+    static constexpr Kind TYPE_UINT32 =
+        Field_Kind_TYPE_UINT32;
+    static constexpr Kind TYPE_ENUM =
+        Field_Kind_TYPE_ENUM;
+    static constexpr Kind TYPE_SFIXED32 =
+        Field_Kind_TYPE_SFIXED32;
+    static constexpr Kind TYPE_SFIXED64 =
+        Field_Kind_TYPE_SFIXED64;
+    static constexpr Kind TYPE_SINT32 =
+        Field_Kind_TYPE_SINT32;
+    static constexpr Kind TYPE_SINT64 =
+        Field_Kind_TYPE_SINT64;
+    static inline bool Kind_IsValid(int value)
+    {
+        return Field_Kind_IsValid(value);
+    }
+    static constexpr Kind Kind_MIN =
+        Field_Kind_Kind_MIN;
+    static constexpr Kind Kind_MAX =
+        Field_Kind_Kind_MAX;
+    static constexpr int Kind_ARRAYSIZE =
+        Field_Kind_Kind_ARRAYSIZE;
+    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+        Kind_descriptor()
+    {
+        return Field_Kind_descriptor();
+    }
+    template<typename T>
+    static inline const std::string& Kind_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, Kind>::value || ::std::is_integral<T>::value, "Incorrect type passed to function Kind_Name.");
+        return Field_Kind_Name(enum_t_value);
+    }
+    static inline bool Kind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Kind* value)
+    {
+        return Field_Kind_Parse(name, value);
+    }
+
+    typedef Field_Cardinality Cardinality;
+    static constexpr Cardinality CARDINALITY_UNKNOWN =
+        Field_Cardinality_CARDINALITY_UNKNOWN;
+    static constexpr Cardinality CARDINALITY_OPTIONAL =
+        Field_Cardinality_CARDINALITY_OPTIONAL;
+    static constexpr Cardinality CARDINALITY_REQUIRED =
+        Field_Cardinality_CARDINALITY_REQUIRED;
+    static constexpr Cardinality CARDINALITY_REPEATED =
+        Field_Cardinality_CARDINALITY_REPEATED;
+    static inline bool Cardinality_IsValid(int value)
+    {
+        return Field_Cardinality_IsValid(value);
+    }
+    static constexpr Cardinality Cardinality_MIN =
+        Field_Cardinality_Cardinality_MIN;
+    static constexpr Cardinality Cardinality_MAX =
+        Field_Cardinality_Cardinality_MAX;
+    static constexpr int Cardinality_ARRAYSIZE =
+        Field_Cardinality_Cardinality_ARRAYSIZE;
+    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+        Cardinality_descriptor()
+    {
+        return Field_Cardinality_descriptor();
+    }
+    template<typename T>
+    static inline const std::string& Cardinality_Name(T enum_t_value)
+    {
+        static_assert(::std::is_same<T, Cardinality>::value || ::std::is_integral<T>::value, "Incorrect type passed to function Cardinality_Name.");
+        return Field_Cardinality_Name(enum_t_value);
+    }
+    static inline bool Cardinality_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Cardinality* value)
+    {
+        return Field_Cardinality_Parse(name, value);
+    }
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kOptionsFieldNumber = 9,
+        kNameFieldNumber = 4,
+        kTypeUrlFieldNumber = 6,
+        kJsonNameFieldNumber = 10,
+        kDefaultValueFieldNumber = 11,
+        kKindFieldNumber = 1,
+        kCardinalityFieldNumber = 2,
+        kNumberFieldNumber = 3,
+        kOneofIndexFieldNumber = 7,
+        kPackedFieldNumber = 8,
+    };
+    // repeated .google.protobuf.Option options = 9;
+    int options_size() const;
+
+private:
+    int _internal_options_size() const;
+
+public:
+    void clear_options();
+    ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+        mutable_options();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+        options() const;
+
+    // string name = 4;
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // string type_url = 6;
+    void clear_type_url();
+    const std::string& type_url() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_type_url(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_type_url();
+    PROTOBUF_NODISCARD std::string* release_type_url();
+    void set_allocated_type_url(std::string* type_url);
+
+private:
+    const std::string& _internal_type_url() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_url(const std::string& value);
+    std::string* _internal_mutable_type_url();
+
+public:
+    // string json_name = 10;
+    void clear_json_name();
+    const std::string& json_name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_json_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_json_name();
+    PROTOBUF_NODISCARD std::string* release_json_name();
+    void set_allocated_json_name(std::string* json_name);
+
+private:
+    const std::string& _internal_json_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_name(const std::string& value);
+    std::string* _internal_mutable_json_name();
+
+public:
+    // string default_value = 11;
+    void clear_default_value();
+    const std::string& default_value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_default_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_default_value();
+    PROTOBUF_NODISCARD std::string* release_default_value();
+    void set_allocated_default_value(std::string* default_value);
+
+private:
+    const std::string& _internal_default_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_value(const std::string& value);
+    std::string* _internal_mutable_default_value();
+
+public:
+    // .google.protobuf.Field.Kind kind = 1;
+    void clear_kind();
+    ::PROTOBUF_NAMESPACE_ID::Field_Kind kind() const;
+    void set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::Field_Kind _internal_kind() const;
+    void _internal_set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value);
+
+public:
+    // .google.protobuf.Field.Cardinality cardinality = 2;
+    void clear_cardinality();
+    ::PROTOBUF_NAMESPACE_ID::Field_Cardinality cardinality() const;
+    void set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::Field_Cardinality _internal_cardinality() const;
+    void _internal_set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value);
+
+public:
+    // int32 number = 3;
+    void clear_number();
+    int32_t number() const;
+    void set_number(int32_t value);
+
+private:
+    int32_t _internal_number() const;
+    void _internal_set_number(int32_t value);
+
+public:
+    // int32 oneof_index = 7;
+    void clear_oneof_index();
+    int32_t oneof_index() const;
+    void set_oneof_index(int32_t value);
+
+private:
+    int32_t _internal_oneof_index() const;
+    void _internal_set_oneof_index(int32_t value);
+
+public:
+    // bool packed = 8;
+    void clear_packed();
+    bool packed() const;
+    void set_packed(bool value);
+
+private:
+    bool _internal_packed() const;
+    void _internal_set_packed(bool value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Field)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option> options_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_url_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_name_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_;
+        int kind_;
+        int cardinality_;
+        int32_t number_;
+        int32_t oneof_index_;
+        bool packed_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Enum final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Enum) */ {
- public:
-  inline Enum() : Enum(nullptr) {}
-  ~Enum() override;
-  explicit PROTOBUF_CONSTEXPR Enum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Enum(const Enum& from);
-  Enum(Enum&& from) noexcept
-    : Enum() {
-    *this = ::std::move(from);
-  }
-
-  inline Enum& operator=(const Enum& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Enum& operator=(Enum&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Enum& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Enum* internal_default_instance() {
-    return reinterpret_cast<const Enum*>(
-               &_Enum_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(Enum& a, Enum& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Enum* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Enum* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Enum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Enum>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Enum& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Enum& from) {
-    Enum::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Enum* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Enum";
-  }
-  protected:
-  explicit Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kEnumvalueFieldNumber = 2,
-    kOptionsFieldNumber = 3,
-    kNameFieldNumber = 1,
-    kSourceContextFieldNumber = 4,
-    kSyntaxFieldNumber = 5,
-  };
-  // repeated .google.protobuf.EnumValue enumvalue = 2;
-  int enumvalue_size() const;
-  private:
-  int _internal_enumvalue_size() const;
-  public:
-  void clear_enumvalue();
-  ::PROTOBUF_NAMESPACE_ID::EnumValue* mutable_enumvalue(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue >*
-      mutable_enumvalue();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::EnumValue& _internal_enumvalue(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumValue* _internal_add_enumvalue();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::EnumValue& enumvalue(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::EnumValue* add_enumvalue();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue >&
-      enumvalue() const;
-
-  // repeated .google.protobuf.Option options = 3;
-  int options_size() const;
-  private:
-  int _internal_options_size() const;
-  public:
-  void clear_options();
-  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-      mutable_options();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-      options() const;
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // .google.protobuf.SourceContext source_context = 4;
-  bool has_source_context() const;
-  private:
-  bool _internal_has_source_context() const;
-  public:
-  void clear_source_context();
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
-  void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
-  public:
-  void unsafe_arena_set_allocated_source_context(
-      ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
-
-  // .google.protobuf.Syntax syntax = 5;
-  void clear_syntax();
-  ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
-  void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
-  private:
-  ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
-  void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Enum)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue > enumvalue_;
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
-    int syntax_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Enum) */
+{
+public:
+    inline Enum() :
+        Enum(nullptr)
+    {
+    }
+    ~Enum() override;
+    explicit PROTOBUF_CONSTEXPR Enum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Enum(const Enum& from);
+    Enum(Enum&& from) noexcept
+        :
+        Enum()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Enum& operator=(const Enum& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Enum& operator=(Enum&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Enum& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Enum* internal_default_instance()
+    {
+        return reinterpret_cast<const Enum*>(
+            &_Enum_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        2;
+
+    friend void swap(Enum& a, Enum& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Enum* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Enum* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Enum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Enum>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Enum& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Enum& from)
+    {
+        Enum::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Enum* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Enum";
+    }
+
+protected:
+    explicit Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kEnumvalueFieldNumber = 2,
+        kOptionsFieldNumber = 3,
+        kNameFieldNumber = 1,
+        kSourceContextFieldNumber = 4,
+        kSyntaxFieldNumber = 5,
+    };
+    // repeated .google.protobuf.EnumValue enumvalue = 2;
+    int enumvalue_size() const;
+
+private:
+    int _internal_enumvalue_size() const;
+
+public:
+    void clear_enumvalue();
+    ::PROTOBUF_NAMESPACE_ID::EnumValue* mutable_enumvalue(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValue>*
+        mutable_enumvalue();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::EnumValue& _internal_enumvalue(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumValue* _internal_add_enumvalue();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::EnumValue& enumvalue(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::EnumValue* add_enumvalue();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValue>&
+        enumvalue() const;
+
+    // repeated .google.protobuf.Option options = 3;
+    int options_size() const;
+
+private:
+    int _internal_options_size() const;
+
+public:
+    void clear_options();
+    ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+        mutable_options();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+        options() const;
+
+    // string name = 1;
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // .google.protobuf.SourceContext source_context = 4;
+    bool has_source_context() const;
+
+private:
+    bool _internal_has_source_context() const;
+
+public:
+    void clear_source_context();
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext& source_context() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::SourceContext* release_source_context();
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* mutable_source_context();
+    void set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext& _internal_source_context() const;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* _internal_mutable_source_context();
+
+public:
+    void unsafe_arena_set_allocated_source_context(
+        ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context
+    );
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* unsafe_arena_release_source_context();
+
+    // .google.protobuf.Syntax syntax = 5;
+    void clear_syntax();
+    ::PROTOBUF_NAMESPACE_ID::Syntax syntax() const;
+    void set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+
+private:
+    ::PROTOBUF_NAMESPACE_ID::Syntax _internal_syntax() const;
+    void _internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Enum)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValue> enumvalue_;
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option> options_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context_;
+        int syntax_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT EnumValue final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValue) */ {
- public:
-  inline EnumValue() : EnumValue(nullptr) {}
-  ~EnumValue() override;
-  explicit PROTOBUF_CONSTEXPR EnumValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  EnumValue(const EnumValue& from);
-  EnumValue(EnumValue&& from) noexcept
-    : EnumValue() {
-    *this = ::std::move(from);
-  }
-
-  inline EnumValue& operator=(const EnumValue& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline EnumValue& operator=(EnumValue&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const EnumValue& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const EnumValue* internal_default_instance() {
-    return reinterpret_cast<const EnumValue*>(
-               &_EnumValue_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    3;
-
-  friend void swap(EnumValue& a, EnumValue& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(EnumValue* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(EnumValue* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  EnumValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<EnumValue>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const EnumValue& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const EnumValue& from) {
-    EnumValue::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(EnumValue* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.EnumValue";
-  }
-  protected:
-  explicit EnumValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kOptionsFieldNumber = 3,
-    kNameFieldNumber = 1,
-    kNumberFieldNumber = 2,
-  };
-  // repeated .google.protobuf.Option options = 3;
-  int options_size() const;
-  private:
-  int _internal_options_size() const;
-  public:
-  void clear_options();
-  ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
-  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-      mutable_options();
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
-  public:
-  const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
-  ::PROTOBUF_NAMESPACE_ID::Option* add_options();
-  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-      options() const;
-
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // int32 number = 2;
-  void clear_number();
-  int32_t number() const;
-  void set_number(int32_t value);
-  private:
-  int32_t _internal_number() const;
-  void _internal_set_number(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValue)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option > options_;
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    int32_t number_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValue) */
+{
+public:
+    inline EnumValue() :
+        EnumValue(nullptr)
+    {
+    }
+    ~EnumValue() override;
+    explicit PROTOBUF_CONSTEXPR EnumValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    EnumValue(const EnumValue& from);
+    EnumValue(EnumValue&& from) noexcept
+        :
+        EnumValue()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline EnumValue& operator=(const EnumValue& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline EnumValue& operator=(EnumValue&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const EnumValue& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const EnumValue* internal_default_instance()
+    {
+        return reinterpret_cast<const EnumValue*>(
+            &_EnumValue_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        3;
+
+    friend void swap(EnumValue& a, EnumValue& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(EnumValue* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(EnumValue* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    EnumValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<EnumValue>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const EnumValue& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const EnumValue& from)
+    {
+        EnumValue::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(EnumValue* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.EnumValue";
+    }
+
+protected:
+    explicit EnumValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kOptionsFieldNumber = 3,
+        kNameFieldNumber = 1,
+        kNumberFieldNumber = 2,
+    };
+    // repeated .google.protobuf.Option options = 3;
+    int options_size() const;
+
+private:
+    int _internal_options_size() const;
+
+public:
+    void clear_options();
+    ::PROTOBUF_NAMESPACE_ID::Option* mutable_options(int index);
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+        mutable_options();
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Option& _internal_options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* _internal_add_options();
+
+public:
+    const ::PROTOBUF_NAMESPACE_ID::Option& options(int index) const;
+    ::PROTOBUF_NAMESPACE_ID::Option* add_options();
+    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+        options() const;
+
+    // string name = 1;
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // int32 number = 2;
+    void clear_number();
+    int32_t number() const;
+    void set_number(int32_t value);
+
+private:
+    int32_t _internal_number() const;
+    void _internal_set_number(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.EnumValue)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option> options_;
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        int32_t number_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Option final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Option) */ {
- public:
-  inline Option() : Option(nullptr) {}
-  ~Option() override;
-  explicit PROTOBUF_CONSTEXPR Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Option(const Option& from);
-  Option(Option&& from) noexcept
-    : Option() {
-    *this = ::std::move(from);
-  }
-
-  inline Option& operator=(const Option& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Option& operator=(Option&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Option& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Option* internal_default_instance() {
-    return reinterpret_cast<const Option*>(
-               &_Option_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    4;
-
-  friend void swap(Option& a, Option& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Option* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Option* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Option>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Option& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Option& from) {
-    Option::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Option* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Option";
-  }
-  protected:
-  explicit Option(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kNameFieldNumber = 1,
-    kValueFieldNumber = 2,
-  };
-  // string name = 1;
-  void clear_name();
-  const std::string& name() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_name(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_name();
-  PROTOBUF_NODISCARD std::string* release_name();
-  void set_allocated_name(std::string* name);
-  private:
-  const std::string& _internal_name() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
-  std::string* _internal_mutable_name();
-  public:
-
-  // .google.protobuf.Any value = 2;
-  bool has_value() const;
-  private:
-  bool _internal_has_value() const;
-  public:
-  void clear_value();
-  const ::PROTOBUF_NAMESPACE_ID::Any& value() const;
-  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_value();
-  ::PROTOBUF_NAMESPACE_ID::Any* mutable_value();
-  void set_allocated_value(::PROTOBUF_NAMESPACE_ID::Any* value);
-  private:
-  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_value() const;
-  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_value();
-  public:
-  void unsafe_arena_set_allocated_value(
-      ::PROTOBUF_NAMESPACE_ID::Any* value);
-  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_value();
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Option)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
-    ::PROTOBUF_NAMESPACE_ID::Any* value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Option) */
+{
+public:
+    inline Option() :
+        Option(nullptr)
+    {
+    }
+    ~Option() override;
+    explicit PROTOBUF_CONSTEXPR Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Option(const Option& from);
+    Option(Option&& from) noexcept
+        :
+        Option()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Option& operator=(const Option& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Option& operator=(Option&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Option& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Option* internal_default_instance()
+    {
+        return reinterpret_cast<const Option*>(
+            &_Option_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        4;
+
+    friend void swap(Option& a, Option& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Option* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Option* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Option>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Option& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Option& from)
+    {
+        Option::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Option* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Option";
+    }
+
+protected:
+    explicit Option(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kNameFieldNumber = 1,
+        kValueFieldNumber = 2,
+    };
+    // string name = 1;
+    void clear_name();
+    const std::string& name() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_name(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_name();
+    PROTOBUF_NODISCARD std::string* release_name();
+    void set_allocated_name(std::string* name);
+
+private:
+    const std::string& _internal_name() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+    std::string* _internal_mutable_name();
+
+public:
+    // .google.protobuf.Any value = 2;
+    bool has_value() const;
+
+private:
+    bool _internal_has_value() const;
+
+public:
+    void clear_value();
+    const ::PROTOBUF_NAMESPACE_ID::Any& value() const;
+    PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_value();
+    ::PROTOBUF_NAMESPACE_ID::Any* mutable_value();
+    void set_allocated_value(::PROTOBUF_NAMESPACE_ID::Any* value);
+
+private:
+    const ::PROTOBUF_NAMESPACE_ID::Any& _internal_value() const;
+    ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_value();
+
+public:
+    void unsafe_arena_set_allocated_value(
+        ::PROTOBUF_NAMESPACE_ID::Any* value
+    );
+    ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_value();
+
+    // @@protoc_insertion_point(class_scope:google.protobuf.Option)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+        ::PROTOBUF_NAMESPACE_ID::Any* value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2ftype_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // Type
 
 // string name = 1;
-inline void Type::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& Type::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Type.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Type::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Type.name)
-}
-inline std::string* Type::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.name)
-  return _s;
-}
-inline const std::string& Type::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void Type::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Type::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Type::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Type.name)
-  return _impl_.name_.Release();
-}
-inline void Type::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+inline void Type::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Type::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Type.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Type::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Type.name)
+}
+inline std::string* Type::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Type.name)
+    return _s;
+}
+inline const std::string& Type::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void Type::_internal_set_name(const std::string& value)
+{
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Type::_internal_mutable_name()
+{
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Type::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Type.name)
+    return _impl_.name_.Release();
+}
+inline void Type::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Type.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Type.name)
 }
 
 // repeated .google.protobuf.Field fields = 2;
-inline int Type::_internal_fields_size() const {
-  return _impl_.fields_.size();
-}
-inline int Type::fields_size() const {
-  return _internal_fields_size();
-}
-inline void Type::clear_fields() {
-  _impl_.fields_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Field* Type::mutable_fields(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.fields)
-  return _impl_.fields_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field >*
-Type::mutable_fields() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.fields)
-  return &_impl_.fields_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Field& Type::_internal_fields(int index) const {
-  return _impl_.fields_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Field& Type::fields(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Type.fields)
-  return _internal_fields(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Field* Type::_internal_add_fields() {
-  return _impl_.fields_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Field* Type::add_fields() {
-  ::PROTOBUF_NAMESPACE_ID::Field* _add = _internal_add_fields();
-  // @@protoc_insertion_point(field_add:google.protobuf.Type.fields)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Field >&
-Type::fields() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Type.fields)
-  return _impl_.fields_;
+inline int Type::_internal_fields_size() const
+{
+    return _impl_.fields_.size();
+}
+inline int Type::fields_size() const
+{
+    return _internal_fields_size();
+}
+inline void Type::clear_fields()
+{
+    _impl_.fields_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field* Type::mutable_fields(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Type.fields)
+    return _impl_.fields_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Field>*
+    Type::mutable_fields()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.fields)
+    return &_impl_.fields_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Field& Type::_internal_fields(int index) const
+{
+    return _impl_.fields_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Field& Type::fields(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Type.fields)
+    return _internal_fields(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field* Type::_internal_add_fields()
+{
+    return _impl_.fields_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Field* Type::add_fields()
+{
+    ::PROTOBUF_NAMESPACE_ID::Field* _add = _internal_add_fields();
+    // @@protoc_insertion_point(field_add:google.protobuf.Type.fields)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Field>&
+    Type::fields() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Type.fields)
+    return _impl_.fields_;
 }
 
 // repeated string oneofs = 3;
-inline int Type::_internal_oneofs_size() const {
-  return _impl_.oneofs_.size();
-}
-inline int Type::oneofs_size() const {
-  return _internal_oneofs_size();
-}
-inline void Type::clear_oneofs() {
-  _impl_.oneofs_.Clear();
-}
-inline std::string* Type::add_oneofs() {
-  std::string* _s = _internal_add_oneofs();
-  // @@protoc_insertion_point(field_add_mutable:google.protobuf.Type.oneofs)
-  return _s;
-}
-inline const std::string& Type::_internal_oneofs(int index) const {
-  return _impl_.oneofs_.Get(index);
-}
-inline const std::string& Type::oneofs(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Type.oneofs)
-  return _internal_oneofs(index);
-}
-inline std::string* Type::mutable_oneofs(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.oneofs)
-  return _impl_.oneofs_.Mutable(index);
-}
-inline void Type::set_oneofs(int index, const std::string& value) {
-  _impl_.oneofs_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Type.oneofs)
-}
-inline void Type::set_oneofs(int index, std::string&& value) {
-  _impl_.oneofs_.Mutable(index)->assign(std::move(value));
-  // @@protoc_insertion_point(field_set:google.protobuf.Type.oneofs)
-}
-inline void Type::set_oneofs(int index, const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.oneofs_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:google.protobuf.Type.oneofs)
-}
-inline void Type::set_oneofs(int index, const char* value, size_t size) {
-  _impl_.oneofs_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Type.oneofs)
-}
-inline std::string* Type::_internal_add_oneofs() {
-  return _impl_.oneofs_.Add();
-}
-inline void Type::add_oneofs(const std::string& value) {
-  _impl_.oneofs_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:google.protobuf.Type.oneofs)
-}
-inline void Type::add_oneofs(std::string&& value) {
-  _impl_.oneofs_.Add(std::move(value));
-  // @@protoc_insertion_point(field_add:google.protobuf.Type.oneofs)
-}
-inline void Type::add_oneofs(const char* value) {
-  GOOGLE_DCHECK(value != nullptr);
-  _impl_.oneofs_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:google.protobuf.Type.oneofs)
-}
-inline void Type::add_oneofs(const char* value, size_t size) {
-  _impl_.oneofs_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:google.protobuf.Type.oneofs)
+inline int Type::_internal_oneofs_size() const
+{
+    return _impl_.oneofs_.size();
+}
+inline int Type::oneofs_size() const
+{
+    return _internal_oneofs_size();
+}
+inline void Type::clear_oneofs()
+{
+    _impl_.oneofs_.Clear();
+}
+inline std::string* Type::add_oneofs()
+{
+    std::string* _s = _internal_add_oneofs();
+    // @@protoc_insertion_point(field_add_mutable:google.protobuf.Type.oneofs)
+    return _s;
+}
+inline const std::string& Type::_internal_oneofs(int index) const
+{
+    return _impl_.oneofs_.Get(index);
+}
+inline const std::string& Type::oneofs(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Type.oneofs)
+    return _internal_oneofs(index);
+}
+inline std::string* Type::mutable_oneofs(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Type.oneofs)
+    return _impl_.oneofs_.Mutable(index);
+}
+inline void Type::set_oneofs(int index, const std::string& value)
+{
+    _impl_.oneofs_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Type.oneofs)
+}
+inline void Type::set_oneofs(int index, std::string&& value)
+{
+    _impl_.oneofs_.Mutable(index)->assign(std::move(value));
+    // @@protoc_insertion_point(field_set:google.protobuf.Type.oneofs)
+}
+inline void Type::set_oneofs(int index, const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.oneofs_.Mutable(index)->assign(value);
+    // @@protoc_insertion_point(field_set_char:google.protobuf.Type.oneofs)
+}
+inline void Type::set_oneofs(int index, const char* value, size_t size)
+{
+    _impl_.oneofs_.Mutable(index)->assign(
+        reinterpret_cast<const char*>(value), size
+    );
+    // @@protoc_insertion_point(field_set_pointer:google.protobuf.Type.oneofs)
+}
+inline std::string* Type::_internal_add_oneofs()
+{
+    return _impl_.oneofs_.Add();
+}
+inline void Type::add_oneofs(const std::string& value)
+{
+    _impl_.oneofs_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add:google.protobuf.Type.oneofs)
+}
+inline void Type::add_oneofs(std::string&& value)
+{
+    _impl_.oneofs_.Add(std::move(value));
+    // @@protoc_insertion_point(field_add:google.protobuf.Type.oneofs)
+}
+inline void Type::add_oneofs(const char* value)
+{
+    GOOGLE_DCHECK(value != nullptr);
+    _impl_.oneofs_.Add()->assign(value);
+    // @@protoc_insertion_point(field_add_char:google.protobuf.Type.oneofs)
+}
+inline void Type::add_oneofs(const char* value, size_t size)
+{
+    _impl_.oneofs_.Add()->assign(reinterpret_cast<const char*>(value), size);
+    // @@protoc_insertion_point(field_add_pointer:google.protobuf.Type.oneofs)
 }
 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-Type::oneofs() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Type.oneofs)
-  return _impl_.oneofs_;
+    Type::oneofs() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Type.oneofs)
+    return _impl_.oneofs_;
 }
 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-Type::mutable_oneofs() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.oneofs)
-  return &_impl_.oneofs_;
+    Type::mutable_oneofs()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.oneofs)
+    return &_impl_.oneofs_;
 }
 
 // repeated .google.protobuf.Option options = 4;
-inline int Type::_internal_options_size() const {
-  return _impl_.options_.size();
-}
-inline int Type::options_size() const {
-  return _internal_options_size();
-}
-inline void Type::clear_options() {
-  _impl_.options_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Type::mutable_options(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.options)
-  return _impl_.options_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-Type::mutable_options() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.options)
-  return &_impl_.options_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Type::_internal_options(int index) const {
-  return _impl_.options_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Type::options(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Type.options)
-  return _internal_options(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Type::_internal_add_options() {
-  return _impl_.options_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Type::add_options() {
-  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
-  // @@protoc_insertion_point(field_add:google.protobuf.Type.options)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-Type::options() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Type.options)
-  return _impl_.options_;
+inline int Type::_internal_options_size() const
+{
+    return _impl_.options_.size();
+}
+inline int Type::options_size() const
+{
+    return _internal_options_size();
+}
+inline void Type::clear_options()
+{
+    _impl_.options_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Type::mutable_options(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Type.options)
+    return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+    Type::mutable_options()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.options)
+    return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Type::_internal_options(int index) const
+{
+    return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Type::options(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Type.options)
+    return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Type::_internal_add_options()
+{
+    return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Type::add_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+    // @@protoc_insertion_point(field_add:google.protobuf.Type.options)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+    Type::options() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Type.options)
+    return _impl_.options_;
 }
 
 // .google.protobuf.SourceContext source_context = 5;
-inline bool Type::_internal_has_source_context() const {
-  return this != internal_default_instance() && _impl_.source_context_ != nullptr;
+inline bool Type::_internal_has_source_context() const
+{
+    return this != internal_default_instance() && _impl_.source_context_ != nullptr;
 }
-inline bool Type::has_source_context() const {
-  return _internal_has_source_context();
+inline bool Type::has_source_context() const
+{
+    return _internal_has_source_context();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Type::_internal_source_context() const {
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(
-      ::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Type::_internal_source_context() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Type::source_context() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Type.source_context)
-  return _internal_source_context();
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Type::source_context() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Type.source_context)
+    return _internal_source_context();
 }
 inline void Type::unsafe_arena_set_allocated_source_context(
-    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
-  }
-  _impl_.source_context_ = source_context;
-  if (source_context) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Type.source_context)
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::release_source_context() {
-  
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
-  _impl_.source_context_ = nullptr;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+    }
+    _impl_.source_context_ = source_context;
+    if (source_context)
+    {
+    }
+    else
+    {
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Type.source_context)
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::release_source_context()
+{
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+    _impl_.source_context_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
+    }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::unsafe_arena_release_source_context() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Type.source_context)
-  
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
-  _impl_.source_context_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::_internal_mutable_source_context() {
-  
-  if (_impl_.source_context_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
-    _impl_.source_context_ = p;
-  }
-  return _impl_.source_context_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::mutable_source_context() {
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.source_context)
-  return _msg;
-}
-inline void Type::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
-  }
-  if (source_context) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
-                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context));
-    if (message_arena != submessage_arena) {
-      source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, source_context, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  _impl_.source_context_ = source_context;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Type.source_context)
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::unsafe_arena_release_source_context()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Type.source_context)
+
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+    _impl_.source_context_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::_internal_mutable_source_context()
+{
+    if (_impl_.source_context_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
+        _impl_.source_context_ = p;
+    }
+    return _impl_.source_context_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Type::mutable_source_context()
+{
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Type.source_context)
+    return _msg;
+}
+inline void Type::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+    }
+    if (source_context)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context)
+            );
+        if (message_arena != submessage_arena)
+        {
+            source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, source_context, submessage_arena
+            );
+        }
+    }
+    else
+    {
+    }
+    _impl_.source_context_ = source_context;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.Type.source_context)
 }
 
 // .google.protobuf.Syntax syntax = 6;
-inline void Type::clear_syntax() {
-  _impl_.syntax_ = 0;
+inline void Type::clear_syntax()
+{
+    _impl_.syntax_ = 0;
 }
-inline ::PROTOBUF_NAMESPACE_ID::Syntax Type::_internal_syntax() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Type::_internal_syntax() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::Syntax>(_impl_.syntax_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::Syntax Type::syntax() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Type.syntax)
-  return _internal_syntax();
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Type::syntax() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Type.syntax)
+    return _internal_syntax();
 }
-inline void Type::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
-  
-  _impl_.syntax_ = value;
+inline void Type::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value)
+{
+    _impl_.syntax_ = value;
 }
-inline void Type::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
-  _internal_set_syntax(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Type.syntax)
+inline void Type::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value)
+{
+    _internal_set_syntax(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Type.syntax)
 }
 
 // -------------------------------------------------------------------
@@ -1698,343 +2061,401 @@ inline void Type::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
 // Field
 
 // .google.protobuf.Field.Kind kind = 1;
-inline void Field::clear_kind() {
-  _impl_.kind_ = 0;
+inline void Field::clear_kind()
+{
+    _impl_.kind_ = 0;
 }
-inline ::PROTOBUF_NAMESPACE_ID::Field_Kind Field::_internal_kind() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::Field_Kind >(_impl_.kind_);
+inline ::PROTOBUF_NAMESPACE_ID::Field_Kind Field::_internal_kind() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::Field_Kind>(_impl_.kind_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::Field_Kind Field::kind() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.kind)
-  return _internal_kind();
+inline ::PROTOBUF_NAMESPACE_ID::Field_Kind Field::kind() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.kind)
+    return _internal_kind();
 }
-inline void Field::_internal_set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value) {
-  
-  _impl_.kind_ = value;
+inline void Field::_internal_set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value)
+{
+    _impl_.kind_ = value;
 }
-inline void Field::set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value) {
-  _internal_set_kind(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.kind)
+inline void Field::set_kind(::PROTOBUF_NAMESPACE_ID::Field_Kind value)
+{
+    _internal_set_kind(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.kind)
 }
 
 // .google.protobuf.Field.Cardinality cardinality = 2;
-inline void Field::clear_cardinality() {
-  _impl_.cardinality_ = 0;
+inline void Field::clear_cardinality()
+{
+    _impl_.cardinality_ = 0;
 }
-inline ::PROTOBUF_NAMESPACE_ID::Field_Cardinality Field::_internal_cardinality() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::Field_Cardinality >(_impl_.cardinality_);
+inline ::PROTOBUF_NAMESPACE_ID::Field_Cardinality Field::_internal_cardinality() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::Field_Cardinality>(_impl_.cardinality_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::Field_Cardinality Field::cardinality() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.cardinality)
-  return _internal_cardinality();
+inline ::PROTOBUF_NAMESPACE_ID::Field_Cardinality Field::cardinality() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.cardinality)
+    return _internal_cardinality();
 }
-inline void Field::_internal_set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value) {
-  
-  _impl_.cardinality_ = value;
+inline void Field::_internal_set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value)
+{
+    _impl_.cardinality_ = value;
 }
-inline void Field::set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value) {
-  _internal_set_cardinality(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.cardinality)
+inline void Field::set_cardinality(::PROTOBUF_NAMESPACE_ID::Field_Cardinality value)
+{
+    _internal_set_cardinality(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.cardinality)
 }
 
 // int32 number = 3;
-inline void Field::clear_number() {
-  _impl_.number_ = 0;
+inline void Field::clear_number()
+{
+    _impl_.number_ = 0;
 }
-inline int32_t Field::_internal_number() const {
-  return _impl_.number_;
+inline int32_t Field::_internal_number() const
+{
+    return _impl_.number_;
 }
-inline int32_t Field::number() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.number)
-  return _internal_number();
+inline int32_t Field::number() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.number)
+    return _internal_number();
 }
-inline void Field::_internal_set_number(int32_t value) {
-  
-  _impl_.number_ = value;
+inline void Field::_internal_set_number(int32_t value)
+{
+    _impl_.number_ = value;
 }
-inline void Field::set_number(int32_t value) {
-  _internal_set_number(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.number)
+inline void Field::set_number(int32_t value)
+{
+    _internal_set_number(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.number)
 }
 
 // string name = 4;
-inline void Field::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& Field::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Field::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.name)
-}
-inline std::string* Field::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.name)
-  return _s;
-}
-inline const std::string& Field::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void Field::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Field::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Field::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Field.name)
-  return _impl_.name_.Release();
-}
-inline void Field::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+inline void Field::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Field::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Field::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.name)
+}
+inline std::string* Field::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Field.name)
+    return _s;
+}
+inline const std::string& Field::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void Field::_internal_set_name(const std::string& value)
+{
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Field::_internal_mutable_name()
+{
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Field::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Field.name)
+    return _impl_.name_.Release();
+}
+inline void Field::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.name)
 }
 
 // string type_url = 6;
-inline void Field::clear_type_url() {
-  _impl_.type_url_.ClearToEmpty();
-}
-inline const std::string& Field::type_url() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.type_url)
-  return _internal_type_url();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Field::set_type_url(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.type_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.type_url)
-}
-inline std::string* Field::mutable_type_url() {
-  std::string* _s = _internal_mutable_type_url();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.type_url)
-  return _s;
-}
-inline const std::string& Field::_internal_type_url() const {
-  return _impl_.type_url_.Get();
-}
-inline void Field::_internal_set_type_url(const std::string& value) {
-  
-  _impl_.type_url_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Field::_internal_mutable_type_url() {
-  
-  return _impl_.type_url_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Field::release_type_url() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Field.type_url)
-  return _impl_.type_url_.Release();
-}
-inline void Field::set_allocated_type_url(std::string* type_url) {
-  if (type_url != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.type_url_.SetAllocated(type_url, GetArenaForAllocation());
+inline void Field::clear_type_url()
+{
+    _impl_.type_url_.ClearToEmpty();
+}
+inline const std::string& Field::type_url() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.type_url)
+    return _internal_type_url();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Field::set_type_url(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.type_url_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.type_url)
+}
+inline std::string* Field::mutable_type_url()
+{
+    std::string* _s = _internal_mutable_type_url();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Field.type_url)
+    return _s;
+}
+inline const std::string& Field::_internal_type_url() const
+{
+    return _impl_.type_url_.Get();
+}
+inline void Field::_internal_set_type_url(const std::string& value)
+{
+    _impl_.type_url_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Field::_internal_mutable_type_url()
+{
+    return _impl_.type_url_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Field::release_type_url()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Field.type_url)
+    return _impl_.type_url_.Release();
+}
+inline void Field::set_allocated_type_url(std::string* type_url)
+{
+    if (type_url != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.type_url_.SetAllocated(type_url, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.type_url_.IsDefault()) {
-    _impl_.type_url_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.type_url)
+    if (_impl_.type_url_.IsDefault())
+    {
+        _impl_.type_url_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.type_url)
 }
 
 // int32 oneof_index = 7;
-inline void Field::clear_oneof_index() {
-  _impl_.oneof_index_ = 0;
+inline void Field::clear_oneof_index()
+{
+    _impl_.oneof_index_ = 0;
 }
-inline int32_t Field::_internal_oneof_index() const {
-  return _impl_.oneof_index_;
+inline int32_t Field::_internal_oneof_index() const
+{
+    return _impl_.oneof_index_;
 }
-inline int32_t Field::oneof_index() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.oneof_index)
-  return _internal_oneof_index();
+inline int32_t Field::oneof_index() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.oneof_index)
+    return _internal_oneof_index();
 }
-inline void Field::_internal_set_oneof_index(int32_t value) {
-  
-  _impl_.oneof_index_ = value;
+inline void Field::_internal_set_oneof_index(int32_t value)
+{
+    _impl_.oneof_index_ = value;
 }
-inline void Field::set_oneof_index(int32_t value) {
-  _internal_set_oneof_index(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.oneof_index)
+inline void Field::set_oneof_index(int32_t value)
+{
+    _internal_set_oneof_index(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.oneof_index)
 }
 
 // bool packed = 8;
-inline void Field::clear_packed() {
-  _impl_.packed_ = false;
+inline void Field::clear_packed()
+{
+    _impl_.packed_ = false;
 }
-inline bool Field::_internal_packed() const {
-  return _impl_.packed_;
+inline bool Field::_internal_packed() const
+{
+    return _impl_.packed_;
 }
-inline bool Field::packed() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.packed)
-  return _internal_packed();
+inline bool Field::packed() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.packed)
+    return _internal_packed();
 }
-inline void Field::_internal_set_packed(bool value) {
-  
-  _impl_.packed_ = value;
+inline void Field::_internal_set_packed(bool value)
+{
+    _impl_.packed_ = value;
 }
-inline void Field::set_packed(bool value) {
-  _internal_set_packed(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.packed)
+inline void Field::set_packed(bool value)
+{
+    _internal_set_packed(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.packed)
 }
 
 // repeated .google.protobuf.Option options = 9;
-inline int Field::_internal_options_size() const {
-  return _impl_.options_.size();
-}
-inline int Field::options_size() const {
-  return _internal_options_size();
-}
-inline void Field::clear_options() {
-  _impl_.options_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Field::mutable_options(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.options)
-  return _impl_.options_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-Field::mutable_options() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Field.options)
-  return &_impl_.options_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Field::_internal_options(int index) const {
-  return _impl_.options_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Field::options(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.options)
-  return _internal_options(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Field::_internal_add_options() {
-  return _impl_.options_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Field::add_options() {
-  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
-  // @@protoc_insertion_point(field_add:google.protobuf.Field.options)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-Field::options() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Field.options)
-  return _impl_.options_;
+inline int Field::_internal_options_size() const
+{
+    return _impl_.options_.size();
+}
+inline int Field::options_size() const
+{
+    return _internal_options_size();
+}
+inline void Field::clear_options()
+{
+    _impl_.options_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Field::mutable_options(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Field.options)
+    return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+    Field::mutable_options()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Field.options)
+    return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Field::_internal_options(int index) const
+{
+    return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Field::options(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.options)
+    return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Field::_internal_add_options()
+{
+    return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Field::add_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+    // @@protoc_insertion_point(field_add:google.protobuf.Field.options)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+    Field::options() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Field.options)
+    return _impl_.options_;
 }
 
 // string json_name = 10;
-inline void Field::clear_json_name() {
-  _impl_.json_name_.ClearToEmpty();
-}
-inline const std::string& Field::json_name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.json_name)
-  return _internal_json_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Field::set_json_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.json_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.json_name)
-}
-inline std::string* Field::mutable_json_name() {
-  std::string* _s = _internal_mutable_json_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.json_name)
-  return _s;
-}
-inline const std::string& Field::_internal_json_name() const {
-  return _impl_.json_name_.Get();
-}
-inline void Field::_internal_set_json_name(const std::string& value) {
-  
-  _impl_.json_name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Field::_internal_mutable_json_name() {
-  
-  return _impl_.json_name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Field::release_json_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Field.json_name)
-  return _impl_.json_name_.Release();
-}
-inline void Field::set_allocated_json_name(std::string* json_name) {
-  if (json_name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.json_name_.SetAllocated(json_name, GetArenaForAllocation());
+inline void Field::clear_json_name()
+{
+    _impl_.json_name_.ClearToEmpty();
+}
+inline const std::string& Field::json_name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.json_name)
+    return _internal_json_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Field::set_json_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.json_name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.json_name)
+}
+inline std::string* Field::mutable_json_name()
+{
+    std::string* _s = _internal_mutable_json_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Field.json_name)
+    return _s;
+}
+inline const std::string& Field::_internal_json_name() const
+{
+    return _impl_.json_name_.Get();
+}
+inline void Field::_internal_set_json_name(const std::string& value)
+{
+    _impl_.json_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Field::_internal_mutable_json_name()
+{
+    return _impl_.json_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Field::release_json_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Field.json_name)
+    return _impl_.json_name_.Release();
+}
+inline void Field::set_allocated_json_name(std::string* json_name)
+{
+    if (json_name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.json_name_.SetAllocated(json_name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.json_name_.IsDefault()) {
-    _impl_.json_name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.json_name)
+    if (_impl_.json_name_.IsDefault())
+    {
+        _impl_.json_name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.json_name)
 }
 
 // string default_value = 11;
-inline void Field::clear_default_value() {
-  _impl_.default_value_.ClearToEmpty();
-}
-inline const std::string& Field::default_value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Field.default_value)
-  return _internal_default_value();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Field::set_default_value(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.default_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Field.default_value)
-}
-inline std::string* Field::mutable_default_value() {
-  std::string* _s = _internal_mutable_default_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.default_value)
-  return _s;
-}
-inline const std::string& Field::_internal_default_value() const {
-  return _impl_.default_value_.Get();
-}
-inline void Field::_internal_set_default_value(const std::string& value) {
-  
-  _impl_.default_value_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Field::_internal_mutable_default_value() {
-  
-  return _impl_.default_value_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Field::release_default_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Field.default_value)
-  return _impl_.default_value_.Release();
-}
-inline void Field::set_allocated_default_value(std::string* default_value) {
-  if (default_value != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.default_value_.SetAllocated(default_value, GetArenaForAllocation());
+inline void Field::clear_default_value()
+{
+    _impl_.default_value_.ClearToEmpty();
+}
+inline const std::string& Field::default_value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Field.default_value)
+    return _internal_default_value();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Field::set_default_value(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.default_value_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Field.default_value)
+}
+inline std::string* Field::mutable_default_value()
+{
+    std::string* _s = _internal_mutable_default_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Field.default_value)
+    return _s;
+}
+inline const std::string& Field::_internal_default_value() const
+{
+    return _impl_.default_value_.Get();
+}
+inline void Field::_internal_set_default_value(const std::string& value)
+{
+    _impl_.default_value_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Field::_internal_mutable_default_value()
+{
+    return _impl_.default_value_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Field::release_default_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Field.default_value)
+    return _impl_.default_value_.Release();
+}
+inline void Field::set_allocated_default_value(std::string* default_value)
+{
+    if (default_value != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.default_value_.SetAllocated(default_value, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.default_value_.IsDefault()) {
-    _impl_.default_value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.default_value)
+    if (_impl_.default_value_.IsDefault())
+    {
+        _impl_.default_value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.default_value)
 }
 
 // -------------------------------------------------------------------
@@ -2042,238 +2463,289 @@ inline void Field::set_allocated_default_value(std::string* default_value) {
 // Enum
 
 // string name = 1;
-inline void Enum::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& Enum::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Enum.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Enum::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Enum.name)
-}
-inline std::string* Enum::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.name)
-  return _s;
-}
-inline const std::string& Enum::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void Enum::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Enum::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Enum::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Enum.name)
-  return _impl_.name_.Release();
-}
-inline void Enum::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+inline void Enum::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Enum::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Enum.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Enum::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Enum.name)
+}
+inline std::string* Enum::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.name)
+    return _s;
+}
+inline const std::string& Enum::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void Enum::_internal_set_name(const std::string& value)
+{
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Enum::_internal_mutable_name()
+{
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Enum::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Enum.name)
+    return _impl_.name_.Release();
+}
+inline void Enum::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Enum.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Enum.name)
 }
 
 // repeated .google.protobuf.EnumValue enumvalue = 2;
-inline int Enum::_internal_enumvalue_size() const {
-  return _impl_.enumvalue_.size();
-}
-inline int Enum::enumvalue_size() const {
-  return _internal_enumvalue_size();
-}
-inline void Enum::clear_enumvalue() {
-  _impl_.enumvalue_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::mutable_enumvalue(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.enumvalue)
-  return _impl_.enumvalue_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue >*
-Enum::mutable_enumvalue() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Enum.enumvalue)
-  return &_impl_.enumvalue_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::EnumValue& Enum::_internal_enumvalue(int index) const {
-  return _impl_.enumvalue_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::EnumValue& Enum::enumvalue(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Enum.enumvalue)
-  return _internal_enumvalue(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::_internal_add_enumvalue() {
-  return _impl_.enumvalue_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::add_enumvalue() {
-  ::PROTOBUF_NAMESPACE_ID::EnumValue* _add = _internal_add_enumvalue();
-  // @@protoc_insertion_point(field_add:google.protobuf.Enum.enumvalue)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::EnumValue >&
-Enum::enumvalue() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Enum.enumvalue)
-  return _impl_.enumvalue_;
+inline int Enum::_internal_enumvalue_size() const
+{
+    return _impl_.enumvalue_.size();
+}
+inline int Enum::enumvalue_size() const
+{
+    return _internal_enumvalue_size();
+}
+inline void Enum::clear_enumvalue()
+{
+    _impl_.enumvalue_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::mutable_enumvalue(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.enumvalue)
+    return _impl_.enumvalue_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValue>*
+    Enum::mutable_enumvalue()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Enum.enumvalue)
+    return &_impl_.enumvalue_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValue& Enum::_internal_enumvalue(int index) const
+{
+    return _impl_.enumvalue_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::EnumValue& Enum::enumvalue(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Enum.enumvalue)
+    return _internal_enumvalue(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::_internal_add_enumvalue()
+{
+    return _impl_.enumvalue_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::EnumValue* Enum::add_enumvalue()
+{
+    ::PROTOBUF_NAMESPACE_ID::EnumValue* _add = _internal_add_enumvalue();
+    // @@protoc_insertion_point(field_add:google.protobuf.Enum.enumvalue)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::EnumValue>&
+    Enum::enumvalue() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Enum.enumvalue)
+    return _impl_.enumvalue_;
 }
 
 // repeated .google.protobuf.Option options = 3;
-inline int Enum::_internal_options_size() const {
-  return _impl_.options_.size();
-}
-inline int Enum::options_size() const {
-  return _internal_options_size();
-}
-inline void Enum::clear_options() {
-  _impl_.options_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::mutable_options(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.options)
-  return _impl_.options_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-Enum::mutable_options() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Enum.options)
-  return &_impl_.options_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Enum::_internal_options(int index) const {
-  return _impl_.options_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& Enum::options(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Enum.options)
-  return _internal_options(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::_internal_add_options() {
-  return _impl_.options_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::add_options() {
-  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
-  // @@protoc_insertion_point(field_add:google.protobuf.Enum.options)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-Enum::options() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.Enum.options)
-  return _impl_.options_;
+inline int Enum::_internal_options_size() const
+{
+    return _impl_.options_.size();
+}
+inline int Enum::options_size() const
+{
+    return _internal_options_size();
+}
+inline void Enum::clear_options()
+{
+    _impl_.options_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::mutable_options(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.options)
+    return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+    Enum::mutable_options()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.Enum.options)
+    return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Enum::_internal_options(int index) const
+{
+    return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& Enum::options(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Enum.options)
+    return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::_internal_add_options()
+{
+    return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* Enum::add_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+    // @@protoc_insertion_point(field_add:google.protobuf.Enum.options)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+    Enum::options() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.Enum.options)
+    return _impl_.options_;
 }
 
 // .google.protobuf.SourceContext source_context = 4;
-inline bool Enum::_internal_has_source_context() const {
-  return this != internal_default_instance() && _impl_.source_context_ != nullptr;
+inline bool Enum::_internal_has_source_context() const
+{
+    return this != internal_default_instance() && _impl_.source_context_ != nullptr;
 }
-inline bool Enum::has_source_context() const {
-  return _internal_has_source_context();
+inline bool Enum::has_source_context() const
+{
+    return _internal_has_source_context();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Enum::_internal_source_context() const {
-  const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(
-      ::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Enum::_internal_source_context() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::SourceContext* p = _impl_.source_context_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::SourceContext&>(::PROTOBUF_NAMESPACE_ID::_SourceContext_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Enum::source_context() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Enum.source_context)
-  return _internal_source_context();
+inline const ::PROTOBUF_NAMESPACE_ID::SourceContext& Enum::source_context() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Enum.source_context)
+    return _internal_source_context();
 }
 inline void Enum::unsafe_arena_set_allocated_source_context(
-    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
-  }
-  _impl_.source_context_ = source_context;
-  if (source_context) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Enum.source_context)
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::release_source_context() {
-  
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
-  _impl_.source_context_ = nullptr;
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* source_context
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+    }
+    _impl_.source_context_ = source_context;
+    if (source_context)
+    {
+    }
+    else
+    {
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Enum.source_context)
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::release_source_context()
+{
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+    _impl_.source_context_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
+    }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::unsafe_arena_release_source_context() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Enum.source_context)
-  
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
-  _impl_.source_context_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::_internal_mutable_source_context() {
-  
-  if (_impl_.source_context_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
-    _impl_.source_context_ = p;
-  }
-  return _impl_.source_context_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::mutable_source_context() {
-  ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.source_context)
-  return _msg;
-}
-inline void Enum::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
-  }
-  if (source_context) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
-                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context));
-    if (message_arena != submessage_arena) {
-      source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, source_context, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  _impl_.source_context_ = source_context;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Enum.source_context)
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::unsafe_arena_release_source_context()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Enum.source_context)
+
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* temp = _impl_.source_context_;
+    _impl_.source_context_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::_internal_mutable_source_context()
+{
+    if (_impl_.source_context_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::SourceContext>(GetArenaForAllocation());
+        _impl_.source_context_ = p;
+    }
+    return _impl_.source_context_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::SourceContext* Enum::mutable_source_context()
+{
+    ::PROTOBUF_NAMESPACE_ID::SourceContext* _msg = _internal_mutable_source_context();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.source_context)
+    return _msg;
+}
+inline void Enum::set_allocated_source_context(::PROTOBUF_NAMESPACE_ID::SourceContext* source_context)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_context_);
+    }
+    if (source_context)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_context)
+            );
+        if (message_arena != submessage_arena)
+        {
+            source_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, source_context, submessage_arena
+            );
+        }
+    }
+    else
+    {
+    }
+    _impl_.source_context_ = source_context;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.Enum.source_context)
 }
 
 // .google.protobuf.Syntax syntax = 5;
-inline void Enum::clear_syntax() {
-  _impl_.syntax_ = 0;
+inline void Enum::clear_syntax()
+{
+    _impl_.syntax_ = 0;
 }
-inline ::PROTOBUF_NAMESPACE_ID::Syntax Enum::_internal_syntax() const {
-  return static_cast< ::PROTOBUF_NAMESPACE_ID::Syntax >(_impl_.syntax_);
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Enum::_internal_syntax() const
+{
+    return static_cast<::PROTOBUF_NAMESPACE_ID::Syntax>(_impl_.syntax_);
 }
-inline ::PROTOBUF_NAMESPACE_ID::Syntax Enum::syntax() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Enum.syntax)
-  return _internal_syntax();
+inline ::PROTOBUF_NAMESPACE_ID::Syntax Enum::syntax() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Enum.syntax)
+    return _internal_syntax();
 }
-inline void Enum::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
-  
-  _impl_.syntax_ = value;
+inline void Enum::_internal_set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value)
+{
+    _impl_.syntax_ = value;
 }
-inline void Enum::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
-  _internal_set_syntax(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Enum.syntax)
+inline void Enum::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value)
+{
+    _internal_set_syntax(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Enum.syntax)
 }
 
 // -------------------------------------------------------------------
@@ -2281,113 +2753,134 @@ inline void Enum::set_syntax(::PROTOBUF_NAMESPACE_ID::Syntax value) {
 // EnumValue
 
 // string name = 1;
-inline void EnumValue::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& EnumValue::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void EnumValue::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.name)
-}
-inline std::string* EnumValue::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValue.name)
-  return _s;
-}
-inline const std::string& EnumValue::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void EnumValue::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* EnumValue::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* EnumValue::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.EnumValue.name)
-  return _impl_.name_.Release();
-}
-inline void EnumValue::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+inline void EnumValue::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+}
+inline const std::string& EnumValue::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void EnumValue::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.name)
+}
+inline std::string* EnumValue::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValue.name)
+    return _s;
+}
+inline const std::string& EnumValue::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void EnumValue::_internal_set_name(const std::string& value)
+{
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* EnumValue::_internal_mutable_name()
+{
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* EnumValue::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.EnumValue.name)
+    return _impl_.name_.Release();
+}
+inline void EnumValue::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValue.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValue.name)
 }
 
 // int32 number = 2;
-inline void EnumValue::clear_number() {
-  _impl_.number_ = 0;
+inline void EnumValue::clear_number()
+{
+    _impl_.number_ = 0;
 }
-inline int32_t EnumValue::_internal_number() const {
-  return _impl_.number_;
+inline int32_t EnumValue::_internal_number() const
+{
+    return _impl_.number_;
 }
-inline int32_t EnumValue::number() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.number)
-  return _internal_number();
+inline int32_t EnumValue::number() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.number)
+    return _internal_number();
 }
-inline void EnumValue::_internal_set_number(int32_t value) {
-  
-  _impl_.number_ = value;
+inline void EnumValue::_internal_set_number(int32_t value)
+{
+    _impl_.number_ = value;
 }
-inline void EnumValue::set_number(int32_t value) {
-  _internal_set_number(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.number)
+inline void EnumValue::set_number(int32_t value)
+{
+    _internal_set_number(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.number)
 }
 
 // repeated .google.protobuf.Option options = 3;
-inline int EnumValue::_internal_options_size() const {
-  return _impl_.options_.size();
-}
-inline int EnumValue::options_size() const {
-  return _internal_options_size();
-}
-inline void EnumValue::clear_options() {
-  _impl_.options_.Clear();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::mutable_options(int index) {
-  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValue.options)
-  return _impl_.options_.Mutable(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >*
-EnumValue::mutable_options() {
-  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValue.options)
-  return &_impl_.options_;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& EnumValue::_internal_options(int index) const {
-  return _impl_.options_.Get(index);
-}
-inline const ::PROTOBUF_NAMESPACE_ID::Option& EnumValue::options(int index) const {
-  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.options)
-  return _internal_options(index);
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::_internal_add_options() {
-  return _impl_.options_.Add();
-}
-inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::add_options() {
-  ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
-  // @@protoc_insertion_point(field_add:google.protobuf.EnumValue.options)
-  return _add;
-}
-inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Option >&
-EnumValue::options() const {
-  // @@protoc_insertion_point(field_list:google.protobuf.EnumValue.options)
-  return _impl_.options_;
+inline int EnumValue::_internal_options_size() const
+{
+    return _impl_.options_.size();
+}
+inline int EnumValue::options_size() const
+{
+    return _internal_options_size();
+}
+inline void EnumValue::clear_options()
+{
+    _impl_.options_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::mutable_options(int index)
+{
+    // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValue.options)
+    return _impl_.options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>*
+    EnumValue::mutable_options()
+{
+    // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValue.options)
+    return &_impl_.options_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& EnumValue::_internal_options(int index) const
+{
+    return _impl_.options_.Get(index);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Option& EnumValue::options(int index) const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.options)
+    return _internal_options(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::_internal_add_options()
+{
+    return _impl_.options_.Add();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Option* EnumValue::add_options()
+{
+    ::PROTOBUF_NAMESPACE_ID::Option* _add = _internal_add_options();
+    // @@protoc_insertion_point(field_add:google.protobuf.EnumValue.options)
+    return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::PROTOBUF_NAMESPACE_ID::Option>&
+    EnumValue::options() const
+{
+    // @@protoc_insertion_point(field_list:google.protobuf.EnumValue.options)
+    return _impl_.options_;
 }
 
 // -------------------------------------------------------------------
@@ -2395,142 +2888,169 @@ EnumValue::options() const {
 // Option
 
 // string name = 1;
-inline void Option::clear_name() {
-  _impl_.name_.ClearToEmpty();
-}
-inline const std::string& Option::name() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Option.name)
-  return _internal_name();
-}
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void Option::set_name(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.Option.name)
-}
-inline std::string* Option::mutable_name() {
-  std::string* _s = _internal_mutable_name();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Option.name)
-  return _s;
-}
-inline const std::string& Option::_internal_name() const {
-  return _impl_.name_.Get();
-}
-inline void Option::_internal_set_name(const std::string& value) {
-  
-  _impl_.name_.Set(value, GetArenaForAllocation());
-}
-inline std::string* Option::_internal_mutable_name() {
-  
-  return _impl_.name_.Mutable(GetArenaForAllocation());
-}
-inline std::string* Option::release_name() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Option.name)
-  return _impl_.name_.Release();
-}
-inline void Option::set_allocated_name(std::string* name) {
-  if (name != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
+inline void Option::clear_name()
+{
+    _impl_.name_.ClearToEmpty();
+}
+inline const std::string& Option::name() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Option.name)
+    return _internal_name();
+}
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void Option::set_name(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.name_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.Option.name)
+}
+inline std::string* Option::mutable_name()
+{
+    std::string* _s = _internal_mutable_name();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Option.name)
+    return _s;
+}
+inline const std::string& Option::_internal_name() const
+{
+    return _impl_.name_.Get();
+}
+inline void Option::_internal_set_name(const std::string& value)
+{
+    _impl_.name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* Option::_internal_mutable_name()
+{
+    return _impl_.name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* Option::release_name()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Option.name)
+    return _impl_.name_.Release();
+}
+inline void Option::set_allocated_name(std::string* name)
+{
+    if (name != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.name_.SetAllocated(name, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.name_.IsDefault()) {
-    _impl_.name_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Option.name)
+    if (_impl_.name_.IsDefault())
+    {
+        _impl_.name_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.Option.name)
 }
 
 // .google.protobuf.Any value = 2;
-inline bool Option::_internal_has_value() const {
-  return this != internal_default_instance() && _impl_.value_ != nullptr;
+inline bool Option::_internal_has_value() const
+{
+    return this != internal_default_instance() && _impl_.value_ != nullptr;
 }
-inline bool Option::has_value() const {
-  return _internal_has_value();
+inline bool Option::has_value() const
+{
+    return _internal_has_value();
 }
-inline const ::PROTOBUF_NAMESPACE_ID::Any& Option::_internal_value() const {
-  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.value_;
-  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
-      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
+inline const ::PROTOBUF_NAMESPACE_ID::Any& Option::_internal_value() const
+{
+    const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.value_;
+    return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
 }
-inline const ::PROTOBUF_NAMESPACE_ID::Any& Option::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Option.value)
-  return _internal_value();
+inline const ::PROTOBUF_NAMESPACE_ID::Any& Option::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Option.value)
+    return _internal_value();
 }
 inline void Option::unsafe_arena_set_allocated_value(
-    ::PROTOBUF_NAMESPACE_ID::Any* value) {
-  if (GetArenaForAllocation() == nullptr) {
-    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
-  }
-  _impl_.value_ = value;
-  if (value) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Option.value)
-}
-inline ::PROTOBUF_NAMESPACE_ID::Any* Option::release_value() {
-  
-  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.value_;
-  _impl_.value_ = nullptr;
+    ::PROTOBUF_NAMESPACE_ID::Any* value
+)
+{
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
+    }
+    _impl_.value_ = value;
+    if (value)
+    {
+    }
+    else
+    {
+    }
+    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Option.value)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* Option::release_value()
+{
+    ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.value_;
+    _impl_.value_ = nullptr;
 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
-  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
-  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  if (GetArenaForAllocation() == nullptr) { delete old; }
-#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
-  if (GetArenaForAllocation() != nullptr) {
+    auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
-  }
+    if (GetArenaForAllocation() == nullptr)
+    {
+        delete old;
+    }
+#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
+    if (GetArenaForAllocation() != nullptr)
+    {
+        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::Any* Option::unsafe_arena_release_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.Option.value)
-  
-  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.value_;
-  _impl_.value_ = nullptr;
-  return temp;
-}
-inline ::PROTOBUF_NAMESPACE_ID::Any* Option::_internal_mutable_value() {
-  
-  if (_impl_.value_ == nullptr) {
-    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
-    _impl_.value_ = p;
-  }
-  return _impl_.value_;
-}
-inline ::PROTOBUF_NAMESPACE_ID::Any* Option::mutable_value() {
-  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.Option.value)
-  return _msg;
-}
-inline void Option::set_allocated_value(::PROTOBUF_NAMESPACE_ID::Any* value) {
-  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
-  if (message_arena == nullptr) {
-    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
-  }
-  if (value) {
-    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
-        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
-                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value));
-    if (message_arena != submessage_arena) {
-      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
-          message_arena, value, submessage_arena);
-    }
-    
-  } else {
-    
-  }
-  _impl_.value_ = value;
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Option.value)
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* Option::unsafe_arena_release_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.Option.value)
+
+    ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.value_;
+    _impl_.value_ = nullptr;
+    return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* Option::_internal_mutable_value()
+{
+    if (_impl_.value_ == nullptr)
+    {
+        auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
+        _impl_.value_ = p;
+    }
+    return _impl_.value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* Option::mutable_value()
+{
+    ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.Option.value)
+    return _msg;
+}
+inline void Option::set_allocated_value(::PROTOBUF_NAMESPACE_ID::Any* value)
+{
+    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+    if (message_arena == nullptr)
+    {
+        delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
+    }
+    if (value)
+    {
+        ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+            ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value)
+            );
+        if (message_arena != submessage_arena)
+        {
+            value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+                message_arena, value, submessage_arena
+            );
+        }
+    }
+    else
+    {
+    }
+    _impl_.value_ = value;
+    // @@protoc_insertion_point(field_set_allocated:google.protobuf.Option.value)
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 // -------------------------------------------------------------------
 
@@ -2540,27 +3060,38 @@ inline void Option::set_allocated_value(::PROTOBUF_NAMESPACE_ID::Any* value) {
 
 // -------------------------------------------------------------------
 
-
 // @@protoc_insertion_point(namespace_scope)
 
 PROTOBUF_NAMESPACE_CLOSE
 
 PROTOBUF_NAMESPACE_OPEN
 
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::Field_Kind> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::Field_Kind>() {
-  return ::PROTOBUF_NAMESPACE_ID::Field_Kind_descriptor();
-}
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::Field_Cardinality> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::Field_Cardinality>() {
-  return ::PROTOBUF_NAMESPACE_ID::Field_Cardinality_descriptor();
-}
-template <> struct is_proto_enum< ::PROTOBUF_NAMESPACE_ID::Syntax> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::PROTOBUF_NAMESPACE_ID::Syntax>() {
-  return ::PROTOBUF_NAMESPACE_ID::Syntax_descriptor();
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::Field_Kind> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::Field_Kind>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::Field_Kind_descriptor();
+}
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::Field_Cardinality> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::Field_Cardinality>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::Field_Cardinality_descriptor();
+}
+template<>
+struct is_proto_enum<::PROTOBUF_NAMESPACE_ID::Syntax> : ::std::true_type
+{
+};
+template<>
+inline const EnumDescriptor* GetEnumDescriptor<::PROTOBUF_NAMESPACE_ID::Syntax>()
+{
+    return ::PROTOBUF_NAMESPACE_ID::Syntax_descriptor();
 }
 
 PROTOBUF_NAMESPACE_CLOSE
diff --git a/CAPI/cpp/grpc/include/google/protobuf/unknown_field_set.h b/CAPI/cpp/grpc/include/google/protobuf/unknown_field_set.h
index 9aa2cbb..dd35994 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/unknown_field_set.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/unknown_field_set.h
@@ -38,7 +38,6 @@
 #ifndef GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
 #define GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
 
-
 #include <assert.h>
 
 #include <string>
@@ -59,348 +58,385 @@
 #error "You cannot SWIG proto headers"
 #endif
 
-namespace google {
-namespace protobuf {
-namespace internal {
-class InternalMetadata;           // metadata_lite.h
-class WireFormat;                 // wire_format.h
-class MessageSetFieldSkipperUsingCord;
-// extension_set_heavy.cc
-}  // namespace internal
-
-class Message;       // message.h
-class UnknownField;  // below
-
-// An UnknownFieldSet contains fields that were encountered while parsing a
-// message but were not defined by its type.  Keeping track of these can be
-// useful, especially in that they may be written if the message is serialized
-// again without being cleared in between.  This means that software which
-// simply receives messages and forwards them to other servers does not need
-// to be updated every time a new field is added to the message definition.
-//
-// To get the UnknownFieldSet attached to any message, call
-// Reflection::GetUnknownFields().
-//
-// This class is necessarily tied to the protocol buffer wire format, unlike
-// the Reflection interface which is independent of any serialization scheme.
-class PROTOBUF_EXPORT UnknownFieldSet {
- public:
-  UnknownFieldSet();
-  ~UnknownFieldSet();
-
-  // Remove all fields.
-  inline void Clear();
-
-  // Remove all fields and deallocate internal data objects
-  void ClearAndFreeMemory();
-
-  // Is this set empty?
-  inline bool empty() const;
-
-  // Merge the contents of some other UnknownFieldSet with this one.
-  void MergeFrom(const UnknownFieldSet& other);
-
-  // Similar to above, but this function will destroy the contents of other.
-  void MergeFromAndDestroy(UnknownFieldSet* other);
-
-  // Merge the contents an UnknownFieldSet with the UnknownFieldSet in
-  // *metadata, if there is one.  If *metadata doesn't have an UnknownFieldSet
-  // then add one to it and make it be a copy of the first arg.
-  static void MergeToInternalMetadata(const UnknownFieldSet& other,
-                                      internal::InternalMetadata* metadata);
-
-  // Swaps the contents of some other UnknownFieldSet with this one.
-  inline void Swap(UnknownFieldSet* x);
-
-  // Computes (an estimate of) the total number of bytes currently used for
-  // storing the unknown fields in memory. Does NOT include
-  // sizeof(*this) in the calculation.
-  size_t SpaceUsedExcludingSelfLong() const;
-
-  int SpaceUsedExcludingSelf() const {
-    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
-  }
-
-  // Version of SpaceUsed() including sizeof(*this).
-  size_t SpaceUsedLong() const;
-
-  int SpaceUsed() const { return internal::ToIntSize(SpaceUsedLong()); }
-
-  // Returns the number of fields present in the UnknownFieldSet.
-  inline int field_count() const;
-  // Get a field in the set, where 0 <= index < field_count().  The fields
-  // appear in the order in which they were added.
-  inline const UnknownField& field(int index) const;
-  // Get a mutable pointer to a field in the set, where
-  // 0 <= index < field_count().  The fields appear in the order in which
-  // they were added.
-  inline UnknownField* mutable_field(int index);
-
-  // Adding fields ---------------------------------------------------
-
-  void AddVarint(int number, uint64_t value);
-  void AddFixed32(int number, uint32_t value);
-  void AddFixed64(int number, uint64_t value);
-  void AddLengthDelimited(int number, const std::string& value);
-  std::string* AddLengthDelimited(int number);
-  UnknownFieldSet* AddGroup(int number);
-
-  // Adds an unknown field from another set.
-  void AddField(const UnknownField& field);
-
-  // Delete fields with indices in the range [start .. start+num-1].
-  // Caution: implementation moves all fields with indices [start+num .. ].
-  void DeleteSubrange(int start, int num);
-
-  // Delete all fields with a specific field number. The order of left fields
-  // is preserved.
-  // Caution: implementation moves all fields after the first deleted field.
-  void DeleteByNumber(int number);
-
-  // Parsing helpers -------------------------------------------------
-  // These work exactly like the similarly-named methods of Message.
-
-  bool MergeFromCodedStream(io::CodedInputStream* input);
-  bool ParseFromCodedStream(io::CodedInputStream* input);
-  bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
-  bool ParseFromArray(const void* data, int size);
-  inline bool ParseFromString(const std::string& data) {
-    return ParseFromArray(data.data(), static_cast<int>(data.size()));
-  }
-
-  // Merges this message's unknown field data (if any).  This works whether
-  // the message is a lite or full proto (for legacy reasons, lite and full
-  // return different types for MessageType::unknown_fields()).
-  template <typename MessageType>
-  bool MergeFromMessage(const MessageType& message);
-
-  // Serialization.
-  bool SerializeToString(std::string* output) const;
-  bool SerializeToCodedStream(io::CodedOutputStream* output) const;
-  static const UnknownFieldSet& default_instance();
-
- private:
-  // For InternalMergeFrom
-  friend class UnknownField;
-  // Merges from other UnknownFieldSet. This method assumes, that this object
-  // is newly created and has no fields.
-  void InternalMergeFrom(const UnknownFieldSet& other);
-  void ClearFallback();
-
-  template <typename MessageType,
-            typename std::enable_if<
-                std::is_base_of<Message, MessageType>::value, int>::type = 0>
-  bool InternalMergeFromMessage(const MessageType& message) {
-    MergeFrom(message.GetReflection()->GetUnknownFields(message));
-    return true;
-  }
-
-  template <typename MessageType,
-            typename std::enable_if<
-                std::is_base_of<MessageLite, MessageType>::value &&
-                    !std::is_base_of<Message, MessageType>::value,
-                int>::type = 0>
-  bool InternalMergeFromMessage(const MessageType& message) {
-    const auto& unknown_fields = message.unknown_fields();
-    io::ArrayInputStream array_stream(unknown_fields.data(),
-                                      unknown_fields.size());
-    io::CodedInputStream coded_stream(&array_stream);
-    return MergeFromCodedStream(&coded_stream);
-  }
-
-  std::vector<UnknownField> fields_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UnknownFieldSet);
-};
-
-namespace internal {
-
-inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* unknown) {
-  unknown->AddVarint(num, val);
-}
-inline void WriteLengthDelimited(uint32_t num, StringPiece val,
-                                 UnknownFieldSet* unknown) {
-  unknown->AddLengthDelimited(num)->assign(val.data(), val.size());
-}
-
-PROTOBUF_EXPORT
-const char* UnknownGroupParse(UnknownFieldSet* unknown, const char* ptr,
-                              ParseContext* ctx);
-PROTOBUF_EXPORT
-const char* UnknownFieldParse(uint64_t tag, UnknownFieldSet* unknown,
-                              const char* ptr, ParseContext* ctx);
-
-}  // namespace internal
-
-// Represents one field in an UnknownFieldSet.
-class PROTOBUF_EXPORT UnknownField {
- public:
-  enum Type {
-    TYPE_VARINT,
-    TYPE_FIXED32,
-    TYPE_FIXED64,
-    TYPE_LENGTH_DELIMITED,
-    TYPE_GROUP
-  };
-
-  // The field's field number, as seen on the wire.
-  inline int number() const;
-
-  // The field type.
-  inline Type type() const;
-
-  // Accessors -------------------------------------------------------
-  // Each method works only for UnknownFields of the corresponding type.
-
-  inline uint64_t varint() const;
-  inline uint32_t fixed32() const;
-  inline uint64_t fixed64() const;
-  inline const std::string& length_delimited() const;
-  inline const UnknownFieldSet& group() const;
-
-  inline void set_varint(uint64_t value);
-  inline void set_fixed32(uint32_t value);
-  inline void set_fixed64(uint64_t value);
-  inline void set_length_delimited(const std::string& value);
-  inline std::string* mutable_length_delimited();
-  inline UnknownFieldSet* mutable_group();
-
-  inline size_t GetLengthDelimitedSize() const;
-  uint8_t* InternalSerializeLengthDelimitedNoTag(
-      uint8_t* target, io::EpsCopyOutputStream* stream) const;
-
-
-  // If this UnknownField contains a pointer, delete it.
-  void Delete();
-
-  // Make a deep copy of any pointers in this UnknownField.
-  void DeepCopy(const UnknownField& other);
-
-  // Set the wire type of this UnknownField. Should only be used when this
-  // UnknownField is being created.
-  inline void SetType(Type type);
-
-  union LengthDelimited {
-    std::string* string_value;
-  };
-
-  uint32_t number_;
-  uint32_t type_;
-  union {
-    uint64_t varint_;
-    uint32_t fixed32_;
-    uint64_t fixed64_;
-    mutable union LengthDelimited length_delimited_;
-    UnknownFieldSet* group_;
-  } data_;
-};
-
-// ===================================================================
-// inline implementations
-
-inline UnknownFieldSet::UnknownFieldSet() {}
-
-inline UnknownFieldSet::~UnknownFieldSet() { Clear(); }
-
-inline void UnknownFieldSet::ClearAndFreeMemory() { Clear(); }
-
-inline void UnknownFieldSet::Clear() {
-  if (!fields_.empty()) {
-    ClearFallback();
-  }
-}
-
-inline bool UnknownFieldSet::empty() const { return fields_.empty(); }
-
-inline void UnknownFieldSet::Swap(UnknownFieldSet* x) {
-  fields_.swap(x->fields_);
-}
-
-inline int UnknownFieldSet::field_count() const {
-  return static_cast<int>(fields_.size());
-}
-inline const UnknownField& UnknownFieldSet::field(int index) const {
-  return (fields_)[static_cast<size_t>(index)];
-}
-inline UnknownField* UnknownFieldSet::mutable_field(int index) {
-  return &(fields_)[static_cast<size_t>(index)];
-}
-
-inline void UnknownFieldSet::AddLengthDelimited(int number,
-                                                const std::string& value) {
-  AddLengthDelimited(number)->assign(value);
-}
-
-
-
-
-inline int UnknownField::number() const { return static_cast<int>(number_); }
-inline UnknownField::Type UnknownField::type() const {
-  return static_cast<Type>(type_);
-}
-
-inline uint64_t UnknownField::varint() const {
-  assert(type() == TYPE_VARINT);
-  return data_.varint_;
-}
-inline uint32_t UnknownField::fixed32() const {
-  assert(type() == TYPE_FIXED32);
-  return data_.fixed32_;
-}
-inline uint64_t UnknownField::fixed64() const {
-  assert(type() == TYPE_FIXED64);
-  return data_.fixed64_;
-}
-inline const std::string& UnknownField::length_delimited() const {
-  assert(type() == TYPE_LENGTH_DELIMITED);
-  return *data_.length_delimited_.string_value;
-}
-inline const UnknownFieldSet& UnknownField::group() const {
-  assert(type() == TYPE_GROUP);
-  return *data_.group_;
-}
-
-inline void UnknownField::set_varint(uint64_t value) {
-  assert(type() == TYPE_VARINT);
-  data_.varint_ = value;
-}
-inline void UnknownField::set_fixed32(uint32_t value) {
-  assert(type() == TYPE_FIXED32);
-  data_.fixed32_ = value;
-}
-inline void UnknownField::set_fixed64(uint64_t value) {
-  assert(type() == TYPE_FIXED64);
-  data_.fixed64_ = value;
-}
-inline void UnknownField::set_length_delimited(const std::string& value) {
-  assert(type() == TYPE_LENGTH_DELIMITED);
-  data_.length_delimited_.string_value->assign(value);
-}
-inline std::string* UnknownField::mutable_length_delimited() {
-  assert(type() == TYPE_LENGTH_DELIMITED);
-  return data_.length_delimited_.string_value;
-}
-inline UnknownFieldSet* UnknownField::mutable_group() {
-  assert(type() == TYPE_GROUP);
-  return data_.group_;
-}
-template <typename MessageType>
-bool UnknownFieldSet::MergeFromMessage(const MessageType& message) {
-  // SFINAE will route to the right version.
-  return InternalMergeFromMessage(message);
-}
-
-
-inline size_t UnknownField::GetLengthDelimitedSize() const {
-  GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type());
-  return data_.length_delimited_.string_value->size();
-}
-
-inline void UnknownField::SetType(Type type) {
-  type_ = type;
-}
-
-
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+            class InternalMetadata;  // metadata_lite.h
+            class WireFormat;        // wire_format.h
+            class MessageSetFieldSkipperUsingCord;
+            // extension_set_heavy.cc
+        }  // namespace internal
+
+        class Message;       // message.h
+        class UnknownField;  // below
+
+        // An UnknownFieldSet contains fields that were encountered while parsing a
+        // message but were not defined by its type.  Keeping track of these can be
+        // useful, especially in that they may be written if the message is serialized
+        // again without being cleared in between.  This means that software which
+        // simply receives messages and forwards them to other servers does not need
+        // to be updated every time a new field is added to the message definition.
+        //
+        // To get the UnknownFieldSet attached to any message, call
+        // Reflection::GetUnknownFields().
+        //
+        // This class is necessarily tied to the protocol buffer wire format, unlike
+        // the Reflection interface which is independent of any serialization scheme.
+        class PROTOBUF_EXPORT UnknownFieldSet
+        {
+        public:
+            UnknownFieldSet();
+            ~UnknownFieldSet();
+
+            // Remove all fields.
+            inline void Clear();
+
+            // Remove all fields and deallocate internal data objects
+            void ClearAndFreeMemory();
+
+            // Is this set empty?
+            inline bool empty() const;
+
+            // Merge the contents of some other UnknownFieldSet with this one.
+            void MergeFrom(const UnknownFieldSet& other);
+
+            // Similar to above, but this function will destroy the contents of other.
+            void MergeFromAndDestroy(UnknownFieldSet* other);
+
+            // Merge the contents an UnknownFieldSet with the UnknownFieldSet in
+            // *metadata, if there is one.  If *metadata doesn't have an UnknownFieldSet
+            // then add one to it and make it be a copy of the first arg.
+            static void MergeToInternalMetadata(const UnknownFieldSet& other, internal::InternalMetadata* metadata);
+
+            // Swaps the contents of some other UnknownFieldSet with this one.
+            inline void Swap(UnknownFieldSet* x);
+
+            // Computes (an estimate of) the total number of bytes currently used for
+            // storing the unknown fields in memory. Does NOT include
+            // sizeof(*this) in the calculation.
+            size_t SpaceUsedExcludingSelfLong() const;
+
+            int SpaceUsedExcludingSelf() const
+            {
+                return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+            }
+
+            // Version of SpaceUsed() including sizeof(*this).
+            size_t SpaceUsedLong() const;
+
+            int SpaceUsed() const
+            {
+                return internal::ToIntSize(SpaceUsedLong());
+            }
+
+            // Returns the number of fields present in the UnknownFieldSet.
+            inline int field_count() const;
+            // Get a field in the set, where 0 <= index < field_count().  The fields
+            // appear in the order in which they were added.
+            inline const UnknownField& field(int index) const;
+            // Get a mutable pointer to a field in the set, where
+            // 0 <= index < field_count().  The fields appear in the order in which
+            // they were added.
+            inline UnknownField* mutable_field(int index);
+
+            // Adding fields ---------------------------------------------------
+
+            void AddVarint(int number, uint64_t value);
+            void AddFixed32(int number, uint32_t value);
+            void AddFixed64(int number, uint64_t value);
+            void AddLengthDelimited(int number, const std::string& value);
+            std::string* AddLengthDelimited(int number);
+            UnknownFieldSet* AddGroup(int number);
+
+            // Adds an unknown field from another set.
+            void AddField(const UnknownField& field);
+
+            // Delete fields with indices in the range [start .. start+num-1].
+            // Caution: implementation moves all fields with indices [start+num .. ].
+            void DeleteSubrange(int start, int num);
+
+            // Delete all fields with a specific field number. The order of left fields
+            // is preserved.
+            // Caution: implementation moves all fields after the first deleted field.
+            void DeleteByNumber(int number);
+
+            // Parsing helpers -------------------------------------------------
+            // These work exactly like the similarly-named methods of Message.
+
+            bool MergeFromCodedStream(io::CodedInputStream* input);
+            bool ParseFromCodedStream(io::CodedInputStream* input);
+            bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
+            bool ParseFromArray(const void* data, int size);
+            inline bool ParseFromString(const std::string& data)
+            {
+                return ParseFromArray(data.data(), static_cast<int>(data.size()));
+            }
+
+            // Merges this message's unknown field data (if any).  This works whether
+            // the message is a lite or full proto (for legacy reasons, lite and full
+            // return different types for MessageType::unknown_fields()).
+            template<typename MessageType>
+            bool MergeFromMessage(const MessageType& message);
+
+            // Serialization.
+            bool SerializeToString(std::string* output) const;
+            bool SerializeToCodedStream(io::CodedOutputStream* output) const;
+            static const UnknownFieldSet& default_instance();
+
+        private:
+            // For InternalMergeFrom
+            friend class UnknownField;
+            // Merges from other UnknownFieldSet. This method assumes, that this object
+            // is newly created and has no fields.
+            void InternalMergeFrom(const UnknownFieldSet& other);
+            void ClearFallback();
+
+            template<typename MessageType, typename std::enable_if<std::is_base_of<Message, MessageType>::value, int>::type = 0>
+            bool InternalMergeFromMessage(const MessageType& message)
+            {
+                MergeFrom(message.GetReflection()->GetUnknownFields(message));
+                return true;
+            }
+
+            template<typename MessageType, typename std::enable_if<std::is_base_of<MessageLite, MessageType>::value && !std::is_base_of<Message, MessageType>::value, int>::type = 0>
+            bool InternalMergeFromMessage(const MessageType& message)
+            {
+                const auto& unknown_fields = message.unknown_fields();
+                io::ArrayInputStream array_stream(unknown_fields.data(), unknown_fields.size());
+                io::CodedInputStream coded_stream(&array_stream);
+                return MergeFromCodedStream(&coded_stream);
+            }
+
+            std::vector<UnknownField> fields_;
+            GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UnknownFieldSet);
+        };
+
+        namespace internal
+        {
+
+            inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* unknown)
+            {
+                unknown->AddVarint(num, val);
+            }
+            inline void WriteLengthDelimited(uint32_t num, StringPiece val, UnknownFieldSet* unknown)
+            {
+                unknown->AddLengthDelimited(num)->assign(val.data(), val.size());
+            }
+
+            PROTOBUF_EXPORT
+            const char* UnknownGroupParse(UnknownFieldSet* unknown, const char* ptr, ParseContext* ctx);
+            PROTOBUF_EXPORT
+            const char* UnknownFieldParse(uint64_t tag, UnknownFieldSet* unknown, const char* ptr, ParseContext* ctx);
+
+        }  // namespace internal
+
+        // Represents one field in an UnknownFieldSet.
+        class PROTOBUF_EXPORT UnknownField
+        {
+        public:
+            enum Type
+            {
+                TYPE_VARINT,
+                TYPE_FIXED32,
+                TYPE_FIXED64,
+                TYPE_LENGTH_DELIMITED,
+                TYPE_GROUP
+            };
+
+            // The field's field number, as seen on the wire.
+            inline int number() const;
+
+            // The field type.
+            inline Type type() const;
+
+            // Accessors -------------------------------------------------------
+            // Each method works only for UnknownFields of the corresponding type.
+
+            inline uint64_t varint() const;
+            inline uint32_t fixed32() const;
+            inline uint64_t fixed64() const;
+            inline const std::string& length_delimited() const;
+            inline const UnknownFieldSet& group() const;
+
+            inline void set_varint(uint64_t value);
+            inline void set_fixed32(uint32_t value);
+            inline void set_fixed64(uint64_t value);
+            inline void set_length_delimited(const std::string& value);
+            inline std::string* mutable_length_delimited();
+            inline UnknownFieldSet* mutable_group();
+
+            inline size_t GetLengthDelimitedSize() const;
+            uint8_t* InternalSerializeLengthDelimitedNoTag(
+                uint8_t* target, io::EpsCopyOutputStream* stream
+            ) const;
+
+            // If this UnknownField contains a pointer, delete it.
+            void Delete();
+
+            // Make a deep copy of any pointers in this UnknownField.
+            void DeepCopy(const UnknownField& other);
+
+            // Set the wire type of this UnknownField. Should only be used when this
+            // UnknownField is being created.
+            inline void SetType(Type type);
+
+            union LengthDelimited
+            {
+                std::string* string_value;
+            };
+
+            uint32_t number_;
+            uint32_t type_;
+            union
+            {
+                uint64_t varint_;
+                uint32_t fixed32_;
+                uint64_t fixed64_;
+                mutable union LengthDelimited length_delimited_;
+                UnknownFieldSet* group_;
+            } data_;
+        };
+
+        // ===================================================================
+        // inline implementations
+
+        inline UnknownFieldSet::UnknownFieldSet()
+        {
+        }
+
+        inline UnknownFieldSet::~UnknownFieldSet()
+        {
+            Clear();
+        }
+
+        inline void UnknownFieldSet::ClearAndFreeMemory()
+        {
+            Clear();
+        }
+
+        inline void UnknownFieldSet::Clear()
+        {
+            if (!fields_.empty())
+            {
+                ClearFallback();
+            }
+        }
+
+        inline bool UnknownFieldSet::empty() const
+        {
+            return fields_.empty();
+        }
+
+        inline void UnknownFieldSet::Swap(UnknownFieldSet* x)
+        {
+            fields_.swap(x->fields_);
+        }
+
+        inline int UnknownFieldSet::field_count() const
+        {
+            return static_cast<int>(fields_.size());
+        }
+        inline const UnknownField& UnknownFieldSet::field(int index) const
+        {
+            return (fields_)[static_cast<size_t>(index)];
+        }
+        inline UnknownField* UnknownFieldSet::mutable_field(int index)
+        {
+            return &(fields_)[static_cast<size_t>(index)];
+        }
+
+        inline void UnknownFieldSet::AddLengthDelimited(int number, const std::string& value)
+        {
+            AddLengthDelimited(number)->assign(value);
+        }
+
+        inline int UnknownField::number() const
+        {
+            return static_cast<int>(number_);
+        }
+        inline UnknownField::Type UnknownField::type() const
+        {
+            return static_cast<Type>(type_);
+        }
+
+        inline uint64_t UnknownField::varint() const
+        {
+            assert(type() == TYPE_VARINT);
+            return data_.varint_;
+        }
+        inline uint32_t UnknownField::fixed32() const
+        {
+            assert(type() == TYPE_FIXED32);
+            return data_.fixed32_;
+        }
+        inline uint64_t UnknownField::fixed64() const
+        {
+            assert(type() == TYPE_FIXED64);
+            return data_.fixed64_;
+        }
+        inline const std::string& UnknownField::length_delimited() const
+        {
+            assert(type() == TYPE_LENGTH_DELIMITED);
+            return *data_.length_delimited_.string_value;
+        }
+        inline const UnknownFieldSet& UnknownField::group() const
+        {
+            assert(type() == TYPE_GROUP);
+            return *data_.group_;
+        }
+
+        inline void UnknownField::set_varint(uint64_t value)
+        {
+            assert(type() == TYPE_VARINT);
+            data_.varint_ = value;
+        }
+        inline void UnknownField::set_fixed32(uint32_t value)
+        {
+            assert(type() == TYPE_FIXED32);
+            data_.fixed32_ = value;
+        }
+        inline void UnknownField::set_fixed64(uint64_t value)
+        {
+            assert(type() == TYPE_FIXED64);
+            data_.fixed64_ = value;
+        }
+        inline void UnknownField::set_length_delimited(const std::string& value)
+        {
+            assert(type() == TYPE_LENGTH_DELIMITED);
+            data_.length_delimited_.string_value->assign(value);
+        }
+        inline std::string* UnknownField::mutable_length_delimited()
+        {
+            assert(type() == TYPE_LENGTH_DELIMITED);
+            return data_.length_delimited_.string_value;
+        }
+        inline UnknownFieldSet* UnknownField::mutable_group()
+        {
+            assert(type() == TYPE_GROUP);
+            return data_.group_;
+        }
+        template<typename MessageType>
+        bool UnknownFieldSet::MergeFromMessage(const MessageType& message)
+        {
+            // SFINAE will route to the right version.
+            return InternalMergeFromMessage(message);
+        }
+
+        inline size_t UnknownField::GetLengthDelimitedSize() const
+        {
+            GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type());
+            return data_.length_delimited_.string_value->size();
+        }
+
+        inline void UnknownField::SetType(Type type)
+        {
+            type_ = type;
+        }
+
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/delimited_message_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/delimited_message_util.h
index 78625cf..054f17a 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/util/delimited_message_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/delimited_message_util.h
@@ -34,7 +34,6 @@
 #ifndef GOOGLE_PROTOBUF_UTIL_DELIMITED_MESSAGE_UTIL_H__
 #define GOOGLE_PROTOBUF_UTIL_DELIMITED_MESSAGE_UTIL_H__
 
-
 #include <ostream>
 
 #include <google/protobuf/message_lite.h>
@@ -44,64 +43,68 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace util {
-
-// Write a single size-delimited message from the given stream. Delimited
-// format allows a single file or stream to contain multiple messages,
-// whereas normally writing multiple non-delimited messages to the same
-// stream would cause them to be merged. A delimited message is a varint
-// encoding the message size followed by a message of exactly that size.
-//
-// Note that if you want to *read* a delimited message from a file descriptor
-// or istream, you will need to construct an io::FileInputStream or
-// io::OstreamInputStream (implementations of io::ZeroCopyStream) and use the
-// utility function ParseDelimitedFromZeroCopyStream(). You must then
-// continue to use the same ZeroCopyInputStream to read all further data from
-// the stream until EOF. This is because these ZeroCopyInputStream
-// implementations are buffered: they read a big chunk of data at a time,
-// then parse it. As a result, they may read past the end of the delimited
-// message. There is no way for them to push the extra data back into the
-// underlying source, so instead you must keep using the same stream object.
-bool PROTOBUF_EXPORT SerializeDelimitedToFileDescriptor(
-    const MessageLite& message, int file_descriptor);
-
-bool PROTOBUF_EXPORT SerializeDelimitedToOstream(const MessageLite& message,
-                                                 std::ostream* output);
-
-// Read a single size-delimited message from the given stream. Delimited
-// format allows a single file or stream to contain multiple messages,
-// whereas normally parsing consumes the entire input. A delimited message
-// is a varint encoding the message size followed by a message of exactly
-// that size.
-//
-// If |clean_eof| is not NULL, then it will be set to indicate whether the
-// stream ended cleanly. That is, if the stream ends without this method
-// having read any data at all from it, then *clean_eof will be set true,
-// otherwise it will be set false. Note that these methods return false
-// on EOF, but they also return false on other errors, so |clean_eof| is
-// needed to distinguish a clean end from errors.
-bool PROTOBUF_EXPORT ParseDelimitedFromZeroCopyStream(
-    MessageLite* message, io::ZeroCopyInputStream* input, bool* clean_eof);
-
-bool PROTOBUF_EXPORT ParseDelimitedFromCodedStream(MessageLite* message,
-                                                   io::CodedInputStream* input,
-                                                   bool* clean_eof);
-
-// Write a single size-delimited message from the given stream. Delimited
-// format allows a single file or stream to contain multiple messages,
-// whereas normally writing multiple non-delimited messages to the same
-// stream would cause them to be merged. A delimited message is a varint
-// encoding the message size followed by a message of exactly that size.
-bool PROTOBUF_EXPORT SerializeDelimitedToZeroCopyStream(
-    const MessageLite& message, io::ZeroCopyOutputStream* output);
-
-bool PROTOBUF_EXPORT SerializeDelimitedToCodedStream(
-    const MessageLite& message, io::CodedOutputStream* output);
-
-}  // namespace util
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace util
+        {
+
+            // Write a single size-delimited message from the given stream. Delimited
+            // format allows a single file or stream to contain multiple messages,
+            // whereas normally writing multiple non-delimited messages to the same
+            // stream would cause them to be merged. A delimited message is a varint
+            // encoding the message size followed by a message of exactly that size.
+            //
+            // Note that if you want to *read* a delimited message from a file descriptor
+            // or istream, you will need to construct an io::FileInputStream or
+            // io::OstreamInputStream (implementations of io::ZeroCopyStream) and use the
+            // utility function ParseDelimitedFromZeroCopyStream(). You must then
+            // continue to use the same ZeroCopyInputStream to read all further data from
+            // the stream until EOF. This is because these ZeroCopyInputStream
+            // implementations are buffered: they read a big chunk of data at a time,
+            // then parse it. As a result, they may read past the end of the delimited
+            // message. There is no way for them to push the extra data back into the
+            // underlying source, so instead you must keep using the same stream object.
+            bool PROTOBUF_EXPORT SerializeDelimitedToFileDescriptor(
+                const MessageLite& message, int file_descriptor
+            );
+
+            bool PROTOBUF_EXPORT SerializeDelimitedToOstream(const MessageLite& message, std::ostream* output);
+
+            // Read a single size-delimited message from the given stream. Delimited
+            // format allows a single file or stream to contain multiple messages,
+            // whereas normally parsing consumes the entire input. A delimited message
+            // is a varint encoding the message size followed by a message of exactly
+            // that size.
+            //
+            // If |clean_eof| is not NULL, then it will be set to indicate whether the
+            // stream ended cleanly. That is, if the stream ends without this method
+            // having read any data at all from it, then *clean_eof will be set true,
+            // otherwise it will be set false. Note that these methods return false
+            // on EOF, but they also return false on other errors, so |clean_eof| is
+            // needed to distinguish a clean end from errors.
+            bool PROTOBUF_EXPORT ParseDelimitedFromZeroCopyStream(
+                MessageLite* message, io::ZeroCopyInputStream* input, bool* clean_eof
+            );
+
+            bool PROTOBUF_EXPORT ParseDelimitedFromCodedStream(MessageLite* message, io::CodedInputStream* input, bool* clean_eof);
+
+            // Write a single size-delimited message from the given stream. Delimited
+            // format allows a single file or stream to contain multiple messages,
+            // whereas normally writing multiple non-delimited messages to the same
+            // stream would cause them to be merged. A delimited message is a varint
+            // encoding the message size followed by a message of exactly that size.
+            bool PROTOBUF_EXPORT SerializeDelimitedToZeroCopyStream(
+                const MessageLite& message, io::ZeroCopyOutputStream* output
+            );
+
+            bool PROTOBUF_EXPORT SerializeDelimitedToCodedStream(
+                const MessageLite& message, io::CodedOutputStream* output
+            );
+
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/field_comparator.h b/CAPI/cpp/grpc/include/google/protobuf/util/field_comparator.h
index 5706da3..3d54ea6 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/util/field_comparator.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/field_comparator.h
@@ -33,7 +33,6 @@
 #ifndef GOOGLE_PROTOBUF_UTIL_FIELD_COMPARATOR_H__
 #define GOOGLE_PROTOBUF_UTIL_FIELD_COMPARATOR_H__
 
-
 #include <cstdint>
 #include <map>
 #include <string>
@@ -44,243 +43,249 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-class Message;
-class EnumValueDescriptor;
-class FieldDescriptor;
-
-namespace util {
-
-class FieldContext;
-class MessageDifferencer;
-
-// Base class specifying the interface for comparing protocol buffer fields.
-// Regular users should consider using or subclassing DefaultFieldComparator
-// rather than this interface.
-// Currently, this does not support comparing unknown fields.
-class PROTOBUF_EXPORT FieldComparator {
- public:
-  FieldComparator();
-  virtual ~FieldComparator();
-
-  enum ComparisonResult {
-    SAME,       // Compared fields are equal. In case of comparing submessages,
-                // user should not recursively compare their contents.
-    DIFFERENT,  // Compared fields are different. In case of comparing
-                // submessages, user should not recursively compare their
-                // contents.
-    RECURSE,    // Compared submessages need to be compared recursively.
-                // FieldComparator does not specify the semantics of recursive
-                // comparison. This value should not be returned for simple
-                // values.
-  };
-
-  // Compares the values of a field in two protocol buffer messages.
-  // Returns SAME or DIFFERENT for simple values, and SAME, DIFFERENT or RECURSE
-  // for submessages. Returning RECURSE for fields not being submessages is
-  // illegal.
-  // In case the given FieldDescriptor points to a repeated field, the indices
-  // need to be valid. Otherwise they should be ignored.
-  //
-  // FieldContext contains information about the specific instances of the
-  // fields being compared, versus FieldDescriptor which only contains general
-  // type information about the fields.
-  virtual ComparisonResult Compare(const Message& message_1,
-                                   const Message& message_2,
-                                   const FieldDescriptor* field, int index_1,
-                                   int index_2,
-                                   const util::FieldContext* field_context) = 0;
-
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldComparator);
-};
-
-// Basic implementation of FieldComparator.  Supports three modes of floating
-// point value comparison: exact, approximate using MathUtil::AlmostEqual
-// method, and arbitrarily precise using MathUtil::WithinFractionOrMargin.
-class PROTOBUF_EXPORT SimpleFieldComparator : public FieldComparator {
- public:
-  enum FloatComparison {
-    EXACT,        // Floats and doubles are compared exactly.
-    APPROXIMATE,  // Floats and doubles are compared using the
-                  // MathUtil::AlmostEqual method or
-                  // MathUtil::WithinFractionOrMargin method.
-    // TODO(ksroka): Introduce third value to differentiate uses of AlmostEqual
-    //               and WithinFractionOrMargin.
-  };
-
-  // Creates new comparator with float comparison set to EXACT.
-  SimpleFieldComparator();
-
-  ~SimpleFieldComparator() override;
-
-  void set_float_comparison(FloatComparison float_comparison) {
-    float_comparison_ = float_comparison;
-  }
-
-  FloatComparison float_comparison() const { return float_comparison_; }
-
-  // Set whether the FieldComparator shall treat floats or doubles that are both
-  // NaN as equal (treat_nan_as_equal = true) or as different
-  // (treat_nan_as_equal = false). Default is treating NaNs always as different.
-  void set_treat_nan_as_equal(bool treat_nan_as_equal) {
-    treat_nan_as_equal_ = treat_nan_as_equal;
-  }
-
-  bool treat_nan_as_equal() const { return treat_nan_as_equal_; }
-
-  // Sets the fraction and margin for the float comparison of a given field.
-  // Uses MathUtil::WithinFractionOrMargin to compare the values.
-  //
-  // REQUIRES: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE or
-  //           field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT
-  // REQUIRES: float_comparison_ == APPROXIMATE
-  void SetFractionAndMargin(const FieldDescriptor* field, double fraction,
-                            double margin);
-
-  // Sets the fraction and margin for the float comparison of all float and
-  // double fields, unless a field has been given a specific setting via
-  // SetFractionAndMargin() above.
-  // Uses MathUtil::WithinFractionOrMargin to compare the values.
-  //
-  // REQUIRES: float_comparison_ == APPROXIMATE
-  void SetDefaultFractionAndMargin(double fraction, double margin);
-
- protected:
-  // Returns the comparison result for the given field in two messages.
-  //
-  // This function is called directly by DefaultFieldComparator::Compare.
-  // Subclasses can call this function to compare fields they do not need to
-  // handle specially.
-  ComparisonResult SimpleCompare(const Message& message_1,
-                                 const Message& message_2,
-                                 const FieldDescriptor* field, int index_1,
-                                 int index_2,
-                                 const util::FieldContext* field_context);
-
-  // Compare using the provided message_differencer. For example, a subclass can
-  // use this method to compare some field in a certain way using the same
-  // message_differencer instance and the field context.
-  bool CompareWithDifferencer(MessageDifferencer* differencer,
-                              const Message& message1, const Message& message2,
-                              const util::FieldContext* field_context);
-
-  // Returns FieldComparator::SAME if boolean_result is true and
-  // FieldComparator::DIFFERENT otherwise.
-  ComparisonResult ResultFromBoolean(bool boolean_result) const;
-
- private:
-  // Defines the tolerance for floating point comparison (fraction and margin).
-  struct Tolerance {
-    double fraction;
-    double margin;
-    Tolerance() : fraction(0.0), margin(0.0) {}
-    Tolerance(double f, double m) : fraction(f), margin(m) {}
-  };
-
-  // Defines the map to store the tolerances for floating point comparison.
-  typedef std::map<const FieldDescriptor*, Tolerance> ToleranceMap;
-
-  friend class MessageDifferencer;
-  // The following methods get executed when CompareFields is called for the
-  // basic types (instead of submessages). They return true on success. One
-  // can use ResultFromBoolean() to convert that boolean to a ComparisonResult
-  // value.
-  bool CompareBool(const FieldDescriptor& /* unused */, bool value_1,
-                   bool value_2) {
-    return value_1 == value_2;
-  }
-
-  // Uses CompareDoubleOrFloat, a helper function used by both CompareDouble and
-  // CompareFloat.
-  bool CompareDouble(const FieldDescriptor& field, double value_1,
-                     double value_2);
-
-  bool CompareEnum(const FieldDescriptor& field,
-                   const EnumValueDescriptor* value_1,
-                   const EnumValueDescriptor* value_2);
-
-  // Uses CompareDoubleOrFloat, a helper function used by both CompareDouble and
-  // CompareFloat.
-  bool CompareFloat(const FieldDescriptor& field, float value_1, float value_2);
-
-  bool CompareInt32(const FieldDescriptor& /* unused */, int32_t value_1,
-                    int32_t value_2) {
-    return value_1 == value_2;
-  }
-
-  bool CompareInt64(const FieldDescriptor& /* unused */, int64_t value_1,
-                    int64_t value_2) {
-    return value_1 == value_2;
-  }
-
-  bool CompareString(const FieldDescriptor& /* unused */,
-                     const std::string& value_1, const std::string& value_2) {
-    return value_1 == value_2;
-  }
-
-  bool CompareUInt32(const FieldDescriptor& /* unused */, uint32_t value_1,
-                     uint32_t value_2) {
-    return value_1 == value_2;
-  }
-
-  bool CompareUInt64(const FieldDescriptor& /* unused */, uint64_t value_1,
-                     uint64_t value_2) {
-    return value_1 == value_2;
-  }
-
-  // This function is used by CompareDouble and CompareFloat to avoid code
-  // duplication. There are no checks done against types of the values passed,
-  // but it's likely to fail if passed non-numeric arguments.
-  template <typename T>
-  bool CompareDoubleOrFloat(const FieldDescriptor& field, T value_1, T value_2);
-
-  FloatComparison float_comparison_;
-
-  // If true, floats and doubles that are both NaN are considered to be
-  // equal. Otherwise, two floats or doubles that are NaN are considered to be
-  // different.
-  bool treat_nan_as_equal_;
-
-  // True iff default_tolerance_ has been explicitly set.
-  //
-  // If false, then the default tolerance for floats and doubles is that which
-  // is used by MathUtil::AlmostEquals().
-  bool has_default_tolerance_;
-
-  // Default float/double tolerance. Only meaningful if
-  // has_default_tolerance_ == true.
-  Tolerance default_tolerance_;
-
-  // Field-specific float/double tolerances, which override any default for
-  // those particular fields.
-  ToleranceMap map_tolerance_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleFieldComparator);
-};
+namespace google
+{
+    namespace protobuf
+    {
+
+        class Message;
+        class EnumValueDescriptor;
+        class FieldDescriptor;
+
+        namespace util
+        {
+
+            class FieldContext;
+            class MessageDifferencer;
+
+            // Base class specifying the interface for comparing protocol buffer fields.
+            // Regular users should consider using or subclassing DefaultFieldComparator
+            // rather than this interface.
+            // Currently, this does not support comparing unknown fields.
+            class PROTOBUF_EXPORT FieldComparator
+            {
+            public:
+                FieldComparator();
+                virtual ~FieldComparator();
+
+                enum ComparisonResult
+                {
+                    SAME,       // Compared fields are equal. In case of comparing submessages,
+                                // user should not recursively compare their contents.
+                    DIFFERENT,  // Compared fields are different. In case of comparing
+                                // submessages, user should not recursively compare their
+                                // contents.
+                    RECURSE,    // Compared submessages need to be compared recursively.
+                                // FieldComparator does not specify the semantics of recursive
+                                // comparison. This value should not be returned for simple
+                                // values.
+                };
+
+                // Compares the values of a field in two protocol buffer messages.
+                // Returns SAME or DIFFERENT for simple values, and SAME, DIFFERENT or RECURSE
+                // for submessages. Returning RECURSE for fields not being submessages is
+                // illegal.
+                // In case the given FieldDescriptor points to a repeated field, the indices
+                // need to be valid. Otherwise they should be ignored.
+                //
+                // FieldContext contains information about the specific instances of the
+                // fields being compared, versus FieldDescriptor which only contains general
+                // type information about the fields.
+                virtual ComparisonResult Compare(const Message& message_1, const Message& message_2, const FieldDescriptor* field, int index_1, int index_2, const util::FieldContext* field_context) = 0;
+
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldComparator);
+            };
+
+            // Basic implementation of FieldComparator.  Supports three modes of floating
+            // point value comparison: exact, approximate using MathUtil::AlmostEqual
+            // method, and arbitrarily precise using MathUtil::WithinFractionOrMargin.
+            class PROTOBUF_EXPORT SimpleFieldComparator : public FieldComparator
+            {
+            public:
+                enum FloatComparison
+                {
+                    EXACT,        // Floats and doubles are compared exactly.
+                    APPROXIMATE,  // Floats and doubles are compared using the
+                                  // MathUtil::AlmostEqual method or
+                                  // MathUtil::WithinFractionOrMargin method.
+                                  // TODO(ksroka): Introduce third value to differentiate uses of AlmostEqual
+                                  //               and WithinFractionOrMargin.
+                };
+
+                // Creates new comparator with float comparison set to EXACT.
+                SimpleFieldComparator();
+
+                ~SimpleFieldComparator() override;
+
+                void set_float_comparison(FloatComparison float_comparison)
+                {
+                    float_comparison_ = float_comparison;
+                }
+
+                FloatComparison float_comparison() const
+                {
+                    return float_comparison_;
+                }
+
+                // Set whether the FieldComparator shall treat floats or doubles that are both
+                // NaN as equal (treat_nan_as_equal = true) or as different
+                // (treat_nan_as_equal = false). Default is treating NaNs always as different.
+                void set_treat_nan_as_equal(bool treat_nan_as_equal)
+                {
+                    treat_nan_as_equal_ = treat_nan_as_equal;
+                }
+
+                bool treat_nan_as_equal() const
+                {
+                    return treat_nan_as_equal_;
+                }
+
+                // Sets the fraction and margin for the float comparison of a given field.
+                // Uses MathUtil::WithinFractionOrMargin to compare the values.
+                //
+                // REQUIRES: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE or
+                //           field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT
+                // REQUIRES: float_comparison_ == APPROXIMATE
+                void SetFractionAndMargin(const FieldDescriptor* field, double fraction, double margin);
+
+                // Sets the fraction and margin for the float comparison of all float and
+                // double fields, unless a field has been given a specific setting via
+                // SetFractionAndMargin() above.
+                // Uses MathUtil::WithinFractionOrMargin to compare the values.
+                //
+                // REQUIRES: float_comparison_ == APPROXIMATE
+                void SetDefaultFractionAndMargin(double fraction, double margin);
+
+            protected:
+                // Returns the comparison result for the given field in two messages.
+                //
+                // This function is called directly by DefaultFieldComparator::Compare.
+                // Subclasses can call this function to compare fields they do not need to
+                // handle specially.
+                ComparisonResult SimpleCompare(const Message& message_1, const Message& message_2, const FieldDescriptor* field, int index_1, int index_2, const util::FieldContext* field_context);
+
+                // Compare using the provided message_differencer. For example, a subclass can
+                // use this method to compare some field in a certain way using the same
+                // message_differencer instance and the field context.
+                bool CompareWithDifferencer(MessageDifferencer* differencer, const Message& message1, const Message& message2, const util::FieldContext* field_context);
+
+                // Returns FieldComparator::SAME if boolean_result is true and
+                // FieldComparator::DIFFERENT otherwise.
+                ComparisonResult ResultFromBoolean(bool boolean_result) const;
+
+            private:
+                // Defines the tolerance for floating point comparison (fraction and margin).
+                struct Tolerance
+                {
+                    double fraction;
+                    double margin;
+                    Tolerance() :
+                        fraction(0.0),
+                        margin(0.0)
+                    {
+                    }
+                    Tolerance(double f, double m) :
+                        fraction(f),
+                        margin(m)
+                    {
+                    }
+                };
+
+                // Defines the map to store the tolerances for floating point comparison.
+                typedef std::map<const FieldDescriptor*, Tolerance> ToleranceMap;
+
+                friend class MessageDifferencer;
+                // The following methods get executed when CompareFields is called for the
+                // basic types (instead of submessages). They return true on success. One
+                // can use ResultFromBoolean() to convert that boolean to a ComparisonResult
+                // value.
+                bool CompareBool(const FieldDescriptor& /* unused */, bool value_1, bool value_2)
+                {
+                    return value_1 == value_2;
+                }
+
+                // Uses CompareDoubleOrFloat, a helper function used by both CompareDouble and
+                // CompareFloat.
+                bool CompareDouble(const FieldDescriptor& field, double value_1, double value_2);
+
+                bool CompareEnum(const FieldDescriptor& field, const EnumValueDescriptor* value_1, const EnumValueDescriptor* value_2);
+
+                // Uses CompareDoubleOrFloat, a helper function used by both CompareDouble and
+                // CompareFloat.
+                bool CompareFloat(const FieldDescriptor& field, float value_1, float value_2);
+
+                bool CompareInt32(const FieldDescriptor& /* unused */, int32_t value_1, int32_t value_2)
+                {
+                    return value_1 == value_2;
+                }
+
+                bool CompareInt64(const FieldDescriptor& /* unused */, int64_t value_1, int64_t value_2)
+                {
+                    return value_1 == value_2;
+                }
+
+                bool CompareString(const FieldDescriptor& /* unused */, const std::string& value_1, const std::string& value_2)
+                {
+                    return value_1 == value_2;
+                }
+
+                bool CompareUInt32(const FieldDescriptor& /* unused */, uint32_t value_1, uint32_t value_2)
+                {
+                    return value_1 == value_2;
+                }
+
+                bool CompareUInt64(const FieldDescriptor& /* unused */, uint64_t value_1, uint64_t value_2)
+                {
+                    return value_1 == value_2;
+                }
+
+                // This function is used by CompareDouble and CompareFloat to avoid code
+                // duplication. There are no checks done against types of the values passed,
+                // but it's likely to fail if passed non-numeric arguments.
+                template<typename T>
+                bool CompareDoubleOrFloat(const FieldDescriptor& field, T value_1, T value_2);
+
+                FloatComparison float_comparison_;
+
+                // If true, floats and doubles that are both NaN are considered to be
+                // equal. Otherwise, two floats or doubles that are NaN are considered to be
+                // different.
+                bool treat_nan_as_equal_;
+
+                // True iff default_tolerance_ has been explicitly set.
+                //
+                // If false, then the default tolerance for floats and doubles is that which
+                // is used by MathUtil::AlmostEquals().
+                bool has_default_tolerance_;
+
+                // Default float/double tolerance. Only meaningful if
+                // has_default_tolerance_ == true.
+                Tolerance default_tolerance_;
+
+                // Field-specific float/double tolerances, which override any default for
+                // those particular fields.
+                ToleranceMap map_tolerance_;
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleFieldComparator);
+            };
 
 // Default field comparison: use the basic implementation of FieldComparator.
 #ifdef PROTOBUF_FUTURE_BREAKING_CHANGES
-class PROTOBUF_EXPORT DefaultFieldComparator final
-    : public SimpleFieldComparator
+            class PROTOBUF_EXPORT DefaultFieldComparator final : public SimpleFieldComparator
 #else   // PROTOBUF_FUTURE_BREAKING_CHANGES
-class PROTOBUF_EXPORT DefaultFieldComparator : public SimpleFieldComparator
+            class PROTOBUF_EXPORT DefaultFieldComparator : public SimpleFieldComparator
 #endif  // PROTOBUF_FUTURE_BREAKING_CHANGES
-{
- public:
-  ComparisonResult Compare(const Message& message_1, const Message& message_2,
-                           const FieldDescriptor* field, int index_1,
-                           int index_2,
-                           const util::FieldContext* field_context) override {
-    return SimpleCompare(message_1, message_2, field, index_1, index_2,
-                         field_context);
-  }
-};
-
-}  // namespace util
-}  // namespace protobuf
+            {
+            public:
+                ComparisonResult Compare(const Message& message_1, const Message& message_2, const FieldDescriptor* field, int index_1, int index_2, const util::FieldContext* field_context) override
+                {
+                    return SimpleCompare(message_1, message_2, field, index_1, index_2, field_context);
+                }
+            };
+
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/field_mask_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/field_mask_util.h
index d51a332..3e7d02e 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/util/field_mask_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/field_mask_util.h
@@ -43,219 +43,245 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace util {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace util
+        {
 
-class PROTOBUF_EXPORT FieldMaskUtil {
-  typedef google::protobuf::FieldMask FieldMask;
+            class PROTOBUF_EXPORT FieldMaskUtil
+            {
+                typedef google::protobuf::FieldMask FieldMask;
 
- public:
-  // Converts FieldMask to/from string, formatted by separating each path
-  // with a comma (e.g., "foo_bar,baz.quz").
-  static std::string ToString(const FieldMask& mask);
-  static void FromString(StringPiece str, FieldMask* out);
+            public:
+                // Converts FieldMask to/from string, formatted by separating each path
+                // with a comma (e.g., "foo_bar,baz.quz").
+                static std::string ToString(const FieldMask& mask);
+                static void FromString(StringPiece str, FieldMask* out);
 
-  // Populates the FieldMask with the paths corresponding to the fields with the
-  // given numbers, after checking that all field numbers are valid.
-  template <typename T>
-  static void FromFieldNumbers(const std::vector<int64_t>& field_numbers,
-                               FieldMask* out) {
-    for (const auto field_number : field_numbers) {
-      const FieldDescriptor* field_desc =
-          T::descriptor()->FindFieldByNumber(field_number);
-      GOOGLE_CHECK(field_desc != nullptr)
-          << "Invalid field number for " << T::descriptor()->full_name() << ": "
-          << field_number;
-      AddPathToFieldMask<T>(field_desc->lowercase_name(), out);
-    }
-  }
+                // Populates the FieldMask with the paths corresponding to the fields with the
+                // given numbers, after checking that all field numbers are valid.
+                template<typename T>
+                static void FromFieldNumbers(const std::vector<int64_t>& field_numbers, FieldMask* out)
+                {
+                    for (const auto field_number : field_numbers)
+                    {
+                        const FieldDescriptor* field_desc =
+                            T::descriptor()->FindFieldByNumber(field_number);
+                        GOOGLE_CHECK(field_desc != nullptr)
+                            << "Invalid field number for " << T::descriptor()->full_name() << ": "
+                            << field_number;
+                        AddPathToFieldMask<T>(field_desc->lowercase_name(), out);
+                    }
+                }
 
-  // Converts FieldMask to/from string, formatted according to proto3 JSON
-  // spec for FieldMask (e.g., "fooBar,baz.quz"). If the field name is not
-  // style conforming (i.e., not snake_case when converted to string, or not
-  // camelCase when converted from string), the conversion will fail.
-  static bool ToJsonString(const FieldMask& mask, std::string* out);
-  static bool FromJsonString(StringPiece str, FieldMask* out);
+                // Converts FieldMask to/from string, formatted according to proto3 JSON
+                // spec for FieldMask (e.g., "fooBar,baz.quz"). If the field name is not
+                // style conforming (i.e., not snake_case when converted to string, or not
+                // camelCase when converted from string), the conversion will fail.
+                static bool ToJsonString(const FieldMask& mask, std::string* out);
+                static bool FromJsonString(StringPiece str, FieldMask* out);
 
-  // Get the descriptors of the fields which the given path from the message
-  // descriptor traverses, if field_descriptors is not null.
-  // Return false if the path is not valid, and the content of field_descriptors
-  // is unspecified.
-  static bool GetFieldDescriptors(
-      const Descriptor* descriptor, StringPiece path,
-      std::vector<const FieldDescriptor*>* field_descriptors);
+                // Get the descriptors of the fields which the given path from the message
+                // descriptor traverses, if field_descriptors is not null.
+                // Return false if the path is not valid, and the content of field_descriptors
+                // is unspecified.
+                static bool GetFieldDescriptors(
+                    const Descriptor* descriptor, StringPiece path, std::vector<const FieldDescriptor*>* field_descriptors
+                );
 
-  // Checks whether the given path is valid for type T.
-  template <typename T>
-  static bool IsValidPath(StringPiece path) {
-    return GetFieldDescriptors(T::descriptor(), path, nullptr);
-  }
+                // Checks whether the given path is valid for type T.
+                template<typename T>
+                static bool IsValidPath(StringPiece path)
+                {
+                    return GetFieldDescriptors(T::descriptor(), path, nullptr);
+                }
 
-  // Checks whether the given FieldMask is valid for type T.
-  template <typename T>
-  static bool IsValidFieldMask(const FieldMask& mask) {
-    for (int i = 0; i < mask.paths_size(); ++i) {
-      if (!GetFieldDescriptors(T::descriptor(), mask.paths(i), nullptr)) {
-        return false;
-      }
-    }
-    return true;
-  }
+                // Checks whether the given FieldMask is valid for type T.
+                template<typename T>
+                static bool IsValidFieldMask(const FieldMask& mask)
+                {
+                    for (int i = 0; i < mask.paths_size(); ++i)
+                    {
+                        if (!GetFieldDescriptors(T::descriptor(), mask.paths(i), nullptr))
+                        {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
 
-  // Adds a path to FieldMask after checking whether the given path is valid.
-  // This method check-fails if the path is not a valid path for type T.
-  template <typename T>
-  static void AddPathToFieldMask(StringPiece path, FieldMask* mask) {
-    GOOGLE_CHECK(IsValidPath<T>(path)) << path;
-    mask->add_paths(std::string(path));
-  }
+                // Adds a path to FieldMask after checking whether the given path is valid.
+                // This method check-fails if the path is not a valid path for type T.
+                template<typename T>
+                static void AddPathToFieldMask(StringPiece path, FieldMask* mask)
+                {
+                    GOOGLE_CHECK(IsValidPath<T>(path)) << path;
+                    mask->add_paths(std::string(path));
+                }
 
-  // Creates a FieldMask with all fields of type T. This FieldMask only
-  // contains fields of T but not any sub-message fields.
-  template <typename T>
-  static FieldMask GetFieldMaskForAllFields() {
-    FieldMask out;
-    GetFieldMaskForAllFields(T::descriptor(), &out);
-    return out;
-  }
-  template <typename T>
-  PROTOBUF_DEPRECATED_MSG("Use *out = GetFieldMaskForAllFields() instead")
-  static void GetFieldMaskForAllFields(FieldMask* out) {
-    GetFieldMaskForAllFields(T::descriptor(), out);
-  }
-  // This flavor takes the protobuf type descriptor as an argument.
-  // Useful when the type is not known at compile time.
-  static void GetFieldMaskForAllFields(const Descriptor* descriptor,
-                                       FieldMask* out);
+                // Creates a FieldMask with all fields of type T. This FieldMask only
+                // contains fields of T but not any sub-message fields.
+                template<typename T>
+                static FieldMask GetFieldMaskForAllFields()
+                {
+                    FieldMask out;
+                    GetFieldMaskForAllFields(T::descriptor(), &out);
+                    return out;
+                }
+                template<typename T>
+                PROTOBUF_DEPRECATED_MSG("Use *out = GetFieldMaskForAllFields() instead")
+                static void GetFieldMaskForAllFields(FieldMask* out)
+                {
+                    GetFieldMaskForAllFields(T::descriptor(), out);
+                }
+                // This flavor takes the protobuf type descriptor as an argument.
+                // Useful when the type is not known at compile time.
+                static void GetFieldMaskForAllFields(const Descriptor* descriptor, FieldMask* out);
 
-  // Converts a FieldMask to the canonical form. It will:
-  //   1. Remove paths that are covered by another path. For example,
-  //      "foo.bar" is covered by "foo" and will be removed if "foo"
-  //      is also in the FieldMask.
-  //   2. Sort all paths in alphabetical order.
-  static void ToCanonicalForm(const FieldMask& mask, FieldMask* out);
+                // Converts a FieldMask to the canonical form. It will:
+                //   1. Remove paths that are covered by another path. For example,
+                //      "foo.bar" is covered by "foo" and will be removed if "foo"
+                //      is also in the FieldMask.
+                //   2. Sort all paths in alphabetical order.
+                static void ToCanonicalForm(const FieldMask& mask, FieldMask* out);
 
-  // Creates an union of two FieldMasks.
-  static void Union(const FieldMask& mask1, const FieldMask& mask2,
-                    FieldMask* out);
+                // Creates an union of two FieldMasks.
+                static void Union(const FieldMask& mask1, const FieldMask& mask2, FieldMask* out);
 
-  // Creates an intersection of two FieldMasks.
-  static void Intersect(const FieldMask& mask1, const FieldMask& mask2,
-                        FieldMask* out);
+                // Creates an intersection of two FieldMasks.
+                static void Intersect(const FieldMask& mask1, const FieldMask& mask2, FieldMask* out);
 
-  // Subtracts mask2 from mask1 base of type T.
-  template <typename T>
-  static void Subtract(const FieldMask& mask1, const FieldMask& mask2,
-                       FieldMask* out) {
-    Subtract(T::descriptor(), mask1, mask2, out);
-  }
-  // This flavor takes the protobuf type descriptor as an argument.
-  // Useful when the type is not known at compile time.
-  static void Subtract(const Descriptor* descriptor, const FieldMask& mask1,
-                       const FieldMask& mask2, FieldMask* out);
+                // Subtracts mask2 from mask1 base of type T.
+                template<typename T>
+                static void Subtract(const FieldMask& mask1, const FieldMask& mask2, FieldMask* out)
+                {
+                    Subtract(T::descriptor(), mask1, mask2, out);
+                }
+                // This flavor takes the protobuf type descriptor as an argument.
+                // Useful when the type is not known at compile time.
+                static void Subtract(const Descriptor* descriptor, const FieldMask& mask1, const FieldMask& mask2, FieldMask* out);
 
-  // Returns true if path is covered by the given FieldMask. Note that path
-  // "foo.bar" covers all paths like "foo.bar.baz", "foo.bar.quz.x", etc.
-  // Also note that parent paths are not covered by explicit child path, i.e.
-  // "foo.bar" does NOT cover "foo", even if "bar" is the only child.
-  static bool IsPathInFieldMask(StringPiece path, const FieldMask& mask);
+                // Returns true if path is covered by the given FieldMask. Note that path
+                // "foo.bar" covers all paths like "foo.bar.baz", "foo.bar.quz.x", etc.
+                // Also note that parent paths are not covered by explicit child path, i.e.
+                // "foo.bar" does NOT cover "foo", even if "bar" is the only child.
+                static bool IsPathInFieldMask(StringPiece path, const FieldMask& mask);
 
-  class MergeOptions;
-  // Merges fields specified in a FieldMask into another message.
-  static void MergeMessageTo(const Message& source, const FieldMask& mask,
-                             const MergeOptions& options, Message* destination);
+                class MergeOptions;
+                // Merges fields specified in a FieldMask into another message.
+                static void MergeMessageTo(const Message& source, const FieldMask& mask, const MergeOptions& options, Message* destination);
 
-  class TrimOptions;
-  // Removes from 'message' any field that is not represented in the given
-  // FieldMask. If the FieldMask is empty, does nothing.
-  // Returns true if the message is modified.
-  static bool TrimMessage(const FieldMask& mask, Message* message);
+                class TrimOptions;
+                // Removes from 'message' any field that is not represented in the given
+                // FieldMask. If the FieldMask is empty, does nothing.
+                // Returns true if the message is modified.
+                static bool TrimMessage(const FieldMask& mask, Message* message);
 
-  // Removes from 'message' any field that is not represented in the given
-  // FieldMask with customized TrimOptions.
-  // If the FieldMask is empty, does nothing.
-  // Returns true if the message is modified.
-  static bool TrimMessage(const FieldMask& mask, Message* message,
-                          const TrimOptions& options);
+                // Removes from 'message' any field that is not represented in the given
+                // FieldMask with customized TrimOptions.
+                // If the FieldMask is empty, does nothing.
+                // Returns true if the message is modified.
+                static bool TrimMessage(const FieldMask& mask, Message* message, const TrimOptions& options);
 
- private:
-  friend class SnakeCaseCamelCaseTest;
-  // Converts a field name from snake_case to camelCase:
-  //   1. Every character after "_" will be converted to uppercase.
-  //   2. All "_"s are removed.
-  // The conversion will fail if:
-  //   1. The field name contains uppercase letters.
-  //   2. Any character after a "_" is not a lowercase letter.
-  // If the conversion succeeds, it's guaranteed that the resulted
-  // camelCase name will yield the original snake_case name when
-  // converted using CamelCaseToSnakeCase().
-  //
-  // Note that the input can contain characters not allowed in C identifiers.
-  // For example, "foo_bar,baz_quz" will be converted to "fooBar,bazQuz"
-  // successfully.
-  static bool SnakeCaseToCamelCase(StringPiece input,
-                                   std::string* output);
-  // Converts a field name from camelCase to snake_case:
-  //   1. Every uppercase letter is converted to lowercase with an additional
-  //      preceding "_".
-  // The conversion will fail if:
-  //   1. The field name contains "_"s.
-  // If the conversion succeeds, it's guaranteed that the resulted
-  // snake_case name will yield the original camelCase name when
-  // converted using SnakeCaseToCamelCase().
-  //
-  // Note that the input can contain characters not allowed in C identifiers.
-  // For example, "fooBar,bazQuz" will be converted to "foo_bar,baz_quz"
-  // successfully.
-  static bool CamelCaseToSnakeCase(StringPiece input,
-                                   std::string* output);
-};
+            private:
+                friend class SnakeCaseCamelCaseTest;
+                // Converts a field name from snake_case to camelCase:
+                //   1. Every character after "_" will be converted to uppercase.
+                //   2. All "_"s are removed.
+                // The conversion will fail if:
+                //   1. The field name contains uppercase letters.
+                //   2. Any character after a "_" is not a lowercase letter.
+                // If the conversion succeeds, it's guaranteed that the resulted
+                // camelCase name will yield the original snake_case name when
+                // converted using CamelCaseToSnakeCase().
+                //
+                // Note that the input can contain characters not allowed in C identifiers.
+                // For example, "foo_bar,baz_quz" will be converted to "fooBar,bazQuz"
+                // successfully.
+                static bool SnakeCaseToCamelCase(StringPiece input, std::string* output);
+                // Converts a field name from camelCase to snake_case:
+                //   1. Every uppercase letter is converted to lowercase with an additional
+                //      preceding "_".
+                // The conversion will fail if:
+                //   1. The field name contains "_"s.
+                // If the conversion succeeds, it's guaranteed that the resulted
+                // snake_case name will yield the original camelCase name when
+                // converted using SnakeCaseToCamelCase().
+                //
+                // Note that the input can contain characters not allowed in C identifiers.
+                // For example, "fooBar,bazQuz" will be converted to "foo_bar,baz_quz"
+                // successfully.
+                static bool CamelCaseToSnakeCase(StringPiece input, std::string* output);
+            };
 
-class PROTOBUF_EXPORT FieldMaskUtil::MergeOptions {
- public:
-  MergeOptions()
-      : replace_message_fields_(false), replace_repeated_fields_(false) {}
-  // When merging message fields, the default behavior is to merge the
-  // content of two message fields together. If you instead want to use
-  // the field from the source message to replace the corresponding field
-  // in the destination message, set this flag to true. When this flag is set,
-  // specified submessage fields that are missing in source will be cleared in
-  // destination.
-  void set_replace_message_fields(bool value) {
-    replace_message_fields_ = value;
-  }
-  bool replace_message_fields() const { return replace_message_fields_; }
-  // The default merging behavior will append entries from the source
-  // repeated field to the destination repeated field. If you only want
-  // to keep the entries from the source repeated field, set this flag
-  // to true.
-  void set_replace_repeated_fields(bool value) {
-    replace_repeated_fields_ = value;
-  }
-  bool replace_repeated_fields() const { return replace_repeated_fields_; }
+            class PROTOBUF_EXPORT FieldMaskUtil::MergeOptions
+            {
+            public:
+                MergeOptions() :
+                    replace_message_fields_(false),
+                    replace_repeated_fields_(false)
+                {
+                }
+                // When merging message fields, the default behavior is to merge the
+                // content of two message fields together. If you instead want to use
+                // the field from the source message to replace the corresponding field
+                // in the destination message, set this flag to true. When this flag is set,
+                // specified submessage fields that are missing in source will be cleared in
+                // destination.
+                void set_replace_message_fields(bool value)
+                {
+                    replace_message_fields_ = value;
+                }
+                bool replace_message_fields() const
+                {
+                    return replace_message_fields_;
+                }
+                // The default merging behavior will append entries from the source
+                // repeated field to the destination repeated field. If you only want
+                // to keep the entries from the source repeated field, set this flag
+                // to true.
+                void set_replace_repeated_fields(bool value)
+                {
+                    replace_repeated_fields_ = value;
+                }
+                bool replace_repeated_fields() const
+                {
+                    return replace_repeated_fields_;
+                }
 
- private:
-  bool replace_message_fields_;
-  bool replace_repeated_fields_;
-};
+            private:
+                bool replace_message_fields_;
+                bool replace_repeated_fields_;
+            };
 
-class PROTOBUF_EXPORT FieldMaskUtil::TrimOptions {
- public:
-  TrimOptions() : keep_required_fields_(false) {}
-  // When trimming message fields, the default behavior is to trim required
-  // fields of the present message if they are not specified in the field mask.
-  // If you instead want to keep required fields of the present message even
-  // when they are not specified in the field mask, set this flag to true.
-  void set_keep_required_fields(bool value) { keep_required_fields_ = value; }
-  bool keep_required_fields() const { return keep_required_fields_; }
+            class PROTOBUF_EXPORT FieldMaskUtil::TrimOptions
+            {
+            public:
+                TrimOptions() :
+                    keep_required_fields_(false)
+                {
+                }
+                // When trimming message fields, the default behavior is to trim required
+                // fields of the present message if they are not specified in the field mask.
+                // If you instead want to keep required fields of the present message even
+                // when they are not specified in the field mask, set this flag to true.
+                void set_keep_required_fields(bool value)
+                {
+                    keep_required_fields_ = value;
+                }
+                bool keep_required_fields() const
+                {
+                    return keep_required_fields_;
+                }
 
- private:
-  bool keep_required_fields_;
-};
+            private:
+                bool keep_required_fields_;
+            };
 
-}  // namespace util
-}  // namespace protobuf
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/json_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/json_util.h
index 0f1c4d8..2f37e52 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/util/json_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/json_util.h
@@ -42,161 +42,163 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace io {
-class ZeroCopyInputStream;
-class ZeroCopyOutputStream;
-}  // namespace io
-namespace util {
-
-struct JsonParseOptions {
-  // Whether to ignore unknown JSON fields during parsing
-  bool ignore_unknown_fields;
-
-  // If true, when a lowercase enum value fails to parse, try convert it to
-  // UPPER_CASE and see if it matches a valid enum.
-  // WARNING: This option exists only to preserve legacy behavior. Avoid using
-  // this option. If your enum needs to support different casing, consider using
-  // allow_alias instead.
-  bool case_insensitive_enum_parsing;
-
-  JsonParseOptions()
-      : ignore_unknown_fields(false), case_insensitive_enum_parsing(false) {}
-};
-
-struct JsonPrintOptions {
-  // Whether to add spaces, line breaks and indentation to make the JSON output
-  // easy to read.
-  bool add_whitespace;
-  // Whether to always print primitive fields. By default proto3 primitive
-  // fields with default values will be omitted in JSON output. For example, an
-  // int32 field set to 0 will be omitted. Set this flag to true will override
-  // the default behavior and print primitive fields regardless of their values.
-  bool always_print_primitive_fields;
-  // Whether to always print enums as ints. By default they are rendered as
-  // strings.
-  bool always_print_enums_as_ints;
-  // Whether to preserve proto field names
-  bool preserve_proto_field_names;
-
-  JsonPrintOptions()
-      : add_whitespace(false),
-        always_print_primitive_fields(false),
-        always_print_enums_as_ints(false),
-        preserve_proto_field_names(false) {}
-};
-
-// DEPRECATED. Use JsonPrintOptions instead.
-typedef JsonPrintOptions JsonOptions;
-
-// Converts from protobuf message to JSON and appends it to |output|. This is a
-// simple wrapper of BinaryToJsonString(). It will use the DescriptorPool of the
-// passed-in message to resolve Any types.
-PROTOBUF_EXPORT util::Status MessageToJsonString(const Message& message,
-                                                 std::string* output,
-                                                 const JsonOptions& options);
-
-inline util::Status MessageToJsonString(const Message& message,
-                                        std::string* output) {
-  return MessageToJsonString(message, output, JsonOptions());
-}
-
-// Converts from JSON to protobuf message. This is a simple wrapper of
-// JsonStringToBinary(). It will use the DescriptorPool of the passed-in
-// message to resolve Any types.
-PROTOBUF_EXPORT util::Status JsonStringToMessage(
-    StringPiece input, Message* message, const JsonParseOptions& options);
-
-inline util::Status JsonStringToMessage(StringPiece input,
-                                        Message* message) {
-  return JsonStringToMessage(input, message, JsonParseOptions());
-}
-
-// Converts protobuf binary data to JSON.
-// The conversion will fail if:
-//   1. TypeResolver fails to resolve a type.
-//   2. input is not valid protobuf wire format, or conflicts with the type
-//      information returned by TypeResolver.
-// Note that unknown fields will be discarded silently.
-PROTOBUF_EXPORT util::Status BinaryToJsonStream(
-    TypeResolver* resolver, const std::string& type_url,
-    io::ZeroCopyInputStream* binary_input,
-    io::ZeroCopyOutputStream* json_output, const JsonPrintOptions& options);
-
-inline util::Status BinaryToJsonStream(TypeResolver* resolver,
-                                       const std::string& type_url,
-                                       io::ZeroCopyInputStream* binary_input,
-                                       io::ZeroCopyOutputStream* json_output) {
-  return BinaryToJsonStream(resolver, type_url, binary_input, json_output,
-                            JsonPrintOptions());
-}
-
-PROTOBUF_EXPORT util::Status BinaryToJsonString(
-    TypeResolver* resolver, const std::string& type_url,
-    const std::string& binary_input, std::string* json_output,
-    const JsonPrintOptions& options);
-
-inline util::Status BinaryToJsonString(TypeResolver* resolver,
-                                       const std::string& type_url,
-                                       const std::string& binary_input,
-                                       std::string* json_output) {
-  return BinaryToJsonString(resolver, type_url, binary_input, json_output,
-                            JsonPrintOptions());
-}
-
-// Converts JSON data to protobuf binary format.
-// The conversion will fail if:
-//   1. TypeResolver fails to resolve a type.
-//   2. input is not valid JSON format, or conflicts with the type
-//      information returned by TypeResolver.
-PROTOBUF_EXPORT util::Status JsonToBinaryStream(
-    TypeResolver* resolver, const std::string& type_url,
-    io::ZeroCopyInputStream* json_input,
-    io::ZeroCopyOutputStream* binary_output, const JsonParseOptions& options);
-
-inline util::Status JsonToBinaryStream(
-    TypeResolver* resolver, const std::string& type_url,
-    io::ZeroCopyInputStream* json_input,
-    io::ZeroCopyOutputStream* binary_output) {
-  return JsonToBinaryStream(resolver, type_url, json_input, binary_output,
-                            JsonParseOptions());
-}
-
-PROTOBUF_EXPORT util::Status JsonToBinaryString(
-    TypeResolver* resolver, const std::string& type_url,
-    StringPiece json_input, std::string* binary_output,
-    const JsonParseOptions& options);
-
-inline util::Status JsonToBinaryString(TypeResolver* resolver,
-                                       const std::string& type_url,
-                                       StringPiece json_input,
-                                       std::string* binary_output) {
-  return JsonToBinaryString(resolver, type_url, json_input, binary_output,
-                            JsonParseOptions());
-}
-
-namespace internal {
-// Internal helper class. Put in the header so we can write unit-tests for it.
-class PROTOBUF_EXPORT ZeroCopyStreamByteSink : public strings::ByteSink {
- public:
-  explicit ZeroCopyStreamByteSink(io::ZeroCopyOutputStream* stream)
-      : stream_(stream), buffer_(nullptr), buffer_size_(0) {}
-  ~ZeroCopyStreamByteSink() override;
-
-  void Append(const char* bytes, size_t len) override;
-
- private:
-  io::ZeroCopyOutputStream* stream_;
-  void* buffer_;
-  int buffer_size_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyStreamByteSink);
-};
-}  // namespace internal
-
-}  // namespace util
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        namespace io
+        {
+            class ZeroCopyInputStream;
+            class ZeroCopyOutputStream;
+        }  // namespace io
+        namespace util
+        {
+
+            struct JsonParseOptions
+            {
+                // Whether to ignore unknown JSON fields during parsing
+                bool ignore_unknown_fields;
+
+                // If true, when a lowercase enum value fails to parse, try convert it to
+                // UPPER_CASE and see if it matches a valid enum.
+                // WARNING: This option exists only to preserve legacy behavior. Avoid using
+                // this option. If your enum needs to support different casing, consider using
+                // allow_alias instead.
+                bool case_insensitive_enum_parsing;
+
+                JsonParseOptions() :
+                    ignore_unknown_fields(false),
+                    case_insensitive_enum_parsing(false)
+                {
+                }
+            };
+
+            struct JsonPrintOptions
+            {
+                // Whether to add spaces, line breaks and indentation to make the JSON output
+                // easy to read.
+                bool add_whitespace;
+                // Whether to always print primitive fields. By default proto3 primitive
+                // fields with default values will be omitted in JSON output. For example, an
+                // int32 field set to 0 will be omitted. Set this flag to true will override
+                // the default behavior and print primitive fields regardless of their values.
+                bool always_print_primitive_fields;
+                // Whether to always print enums as ints. By default they are rendered as
+                // strings.
+                bool always_print_enums_as_ints;
+                // Whether to preserve proto field names
+                bool preserve_proto_field_names;
+
+                JsonPrintOptions() :
+                    add_whitespace(false),
+                    always_print_primitive_fields(false),
+                    always_print_enums_as_ints(false),
+                    preserve_proto_field_names(false)
+                {
+                }
+            };
+
+            // DEPRECATED. Use JsonPrintOptions instead.
+            typedef JsonPrintOptions JsonOptions;
+
+            // Converts from protobuf message to JSON and appends it to |output|. This is a
+            // simple wrapper of BinaryToJsonString(). It will use the DescriptorPool of the
+            // passed-in message to resolve Any types.
+            PROTOBUF_EXPORT util::Status MessageToJsonString(const Message& message, std::string* output, const JsonOptions& options);
+
+            inline util::Status MessageToJsonString(const Message& message, std::string* output)
+            {
+                return MessageToJsonString(message, output, JsonOptions());
+            }
+
+            // Converts from JSON to protobuf message. This is a simple wrapper of
+            // JsonStringToBinary(). It will use the DescriptorPool of the passed-in
+            // message to resolve Any types.
+            PROTOBUF_EXPORT util::Status JsonStringToMessage(
+                StringPiece input, Message* message, const JsonParseOptions& options
+            );
+
+            inline util::Status JsonStringToMessage(StringPiece input, Message* message)
+            {
+                return JsonStringToMessage(input, message, JsonParseOptions());
+            }
+
+            // Converts protobuf binary data to JSON.
+            // The conversion will fail if:
+            //   1. TypeResolver fails to resolve a type.
+            //   2. input is not valid protobuf wire format, or conflicts with the type
+            //      information returned by TypeResolver.
+            // Note that unknown fields will be discarded silently.
+            PROTOBUF_EXPORT util::Status BinaryToJsonStream(
+                TypeResolver* resolver, const std::string& type_url, io::ZeroCopyInputStream* binary_input, io::ZeroCopyOutputStream* json_output, const JsonPrintOptions& options
+            );
+
+            inline util::Status BinaryToJsonStream(TypeResolver* resolver, const std::string& type_url, io::ZeroCopyInputStream* binary_input, io::ZeroCopyOutputStream* json_output)
+            {
+                return BinaryToJsonStream(resolver, type_url, binary_input, json_output, JsonPrintOptions());
+            }
+
+            PROTOBUF_EXPORT util::Status BinaryToJsonString(
+                TypeResolver* resolver, const std::string& type_url, const std::string& binary_input, std::string* json_output, const JsonPrintOptions& options
+            );
+
+            inline util::Status BinaryToJsonString(TypeResolver* resolver, const std::string& type_url, const std::string& binary_input, std::string* json_output)
+            {
+                return BinaryToJsonString(resolver, type_url, binary_input, json_output, JsonPrintOptions());
+            }
+
+            // Converts JSON data to protobuf binary format.
+            // The conversion will fail if:
+            //   1. TypeResolver fails to resolve a type.
+            //   2. input is not valid JSON format, or conflicts with the type
+            //      information returned by TypeResolver.
+            PROTOBUF_EXPORT util::Status JsonToBinaryStream(
+                TypeResolver* resolver, const std::string& type_url, io::ZeroCopyInputStream* json_input, io::ZeroCopyOutputStream* binary_output, const JsonParseOptions& options
+            );
+
+            inline util::Status JsonToBinaryStream(
+                TypeResolver* resolver, const std::string& type_url, io::ZeroCopyInputStream* json_input, io::ZeroCopyOutputStream* binary_output
+            )
+            {
+                return JsonToBinaryStream(resolver, type_url, json_input, binary_output, JsonParseOptions());
+            }
+
+            PROTOBUF_EXPORT util::Status JsonToBinaryString(
+                TypeResolver* resolver, const std::string& type_url, StringPiece json_input, std::string* binary_output, const JsonParseOptions& options
+            );
+
+            inline util::Status JsonToBinaryString(TypeResolver* resolver, const std::string& type_url, StringPiece json_input, std::string* binary_output)
+            {
+                return JsonToBinaryString(resolver, type_url, json_input, binary_output, JsonParseOptions());
+            }
+
+            namespace internal
+            {
+                // Internal helper class. Put in the header so we can write unit-tests for it.
+                class PROTOBUF_EXPORT ZeroCopyStreamByteSink : public strings::ByteSink
+                {
+                public:
+                    explicit ZeroCopyStreamByteSink(io::ZeroCopyOutputStream* stream) :
+                        stream_(stream),
+                        buffer_(nullptr),
+                        buffer_size_(0)
+                    {
+                    }
+                    ~ZeroCopyStreamByteSink() override;
+
+                    void Append(const char* bytes, size_t len) override;
+
+                private:
+                    io::ZeroCopyOutputStream* stream_;
+                    void* buffer_;
+                    int buffer_size_;
+
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyStreamByteSink);
+                };
+            }  // namespace internal
+
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/message_differencer.h b/CAPI/cpp/grpc/include/google/protobuf/util/message_differencer.h
index f63cd54..943818f 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/util/message_differencer.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/message_differencer.h
@@ -43,7 +43,6 @@
 #ifndef GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__
 #define GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__
 
-
 #include <functional>
 #include <map>
 #include <memory>
@@ -59,920 +58,913 @@
 // Always include as last one, otherwise it can break compilation
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-
-class DynamicMessageFactory;
-class FieldDescriptor;
-
-namespace io {
-class ZeroCopyOutputStream;
-class Printer;
-}  // namespace io
-
-namespace util {
-
-class DefaultFieldComparator;
-class FieldContext;  // declared below MessageDifferencer
-
-// Defines a collection of field descriptors.
-// In case of internal google codebase we are using absl::FixedArray instead
-// of vector. It significantly speeds up proto comparison (by ~30%) by
-// reducing the number of malloc/free operations
-typedef std::vector<const FieldDescriptor*> FieldDescriptorArray;
-
-// A basic differencer that can be used to determine
-// the differences between two specified Protocol Messages. If any differences
-// are found, the Compare method will return false, and any differencer reporter
-// specified via ReportDifferencesTo will have its reporting methods called (see
-// below for implementation of the report). Based off of the original
-// ProtocolDifferencer implementation in //net/proto/protocol-differencer.h
-// (Thanks Todd!).
-//
-// MessageDifferencer REQUIRES that compared messages be the same type, defined
-// as messages that share the same descriptor.  If not, the behavior of this
-// class is undefined.
-//
-// People disagree on what MessageDifferencer should do when asked to compare
-// messages with different descriptors.  Some people think it should always
-// return false.  Others expect it to try to look for similar fields and
-// compare them anyway -- especially if the descriptors happen to be identical.
-// If we chose either of these behaviors, some set of people would find it
-// surprising, and could end up writing code expecting the other behavior
-// without realizing their error.  Therefore, we forbid that usage.
-//
-// This class is implemented based on the proto2 reflection. The performance
-// should be good enough for normal usages. However, for places where the
-// performance is extremely sensitive, there are several alternatives:
-// - Comparing serialized string
-// Downside: false negatives (there are messages that are the same but their
-// serialized strings are different).
-// - Equals code generator by compiler plugin (net/proto2/contrib/equals_plugin)
-// Downside: more generated code; maintenance overhead for the additional rule
-// (must be in sync with the original proto_library).
-//
-// Note on handling of google.protobuf.Any: MessageDifferencer automatically
-// unpacks Any::value into a Message and compares its individual fields.
-// Messages encoded in a repeated Any cannot be compared using TreatAsMap.
-//
-// Note on thread-safety: MessageDifferencer is *not* thread-safe. You need to
-// guard it with a lock to use the same MessageDifferencer instance from
-// multiple threads. Note that it's fine to call static comparison methods
-// (like MessageDifferencer::Equals) concurrently, but it's not recommended for
-// performance critical code as it leads to extra allocations.
-class PROTOBUF_EXPORT MessageDifferencer {
- public:
-  // Determines whether the supplied messages are equal. Equality is defined as
-  // all fields within the two messages being set to the same value. Primitive
-  // fields and strings are compared by value while embedded messages/groups
-  // are compared as if via a recursive call. Use Compare() with IgnoreField()
-  // if some fields should be ignored in the comparison. Use Compare() with
-  // TreatAsSet() if there are repeated fields where ordering does not matter.
-  //
-  // This method REQUIRES that the two messages have the same
-  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
-  static bool Equals(const Message& message1, const Message& message2);
-
-  // Determines whether the supplied messages are equivalent. Equivalency is
-  // defined as all fields within the two messages having the same value. This
-  // differs from the Equals method above in that fields with default values
-  // are considered set to said value automatically. For details on how default
-  // values are defined for each field type, see:
-  // https://developers.google.com/protocol-buffers/docs/proto?csw=1#optional.
-  // Also, Equivalent() ignores unknown fields. Use IgnoreField() and Compare()
-  // if some fields should be ignored in the comparison.
-  //
-  // This method REQUIRES that the two messages have the same
-  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
-  static bool Equivalent(const Message& message1, const Message& message2);
-
-  // Determines whether the supplied messages are approximately equal.
-  // Approximate equality is defined as all fields within the two messages
-  // being approximately equal.  Primitive (non-float) fields and strings are
-  // compared by value, floats are compared using MathUtil::AlmostEquals() and
-  // embedded messages/groups are compared as if via a recursive call. Use
-  // IgnoreField() and Compare() if some fields should be ignored in the
-  // comparison.
-  //
-  // This method REQUIRES that the two messages have the same
-  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
-  static bool ApproximatelyEquals(const Message& message1,
-                                  const Message& message2);
-
-  // Determines whether the supplied messages are approximately equivalent.
-  // Approximate equivalency is defined as all fields within the two messages
-  // being approximately equivalent. As in
-  // MessageDifferencer::ApproximatelyEquals, primitive (non-float) fields and
-  // strings are compared by value, floats are compared using
-  // MathUtil::AlmostEquals() and embedded messages/groups are compared as if
-  // via a recursive call. However, fields with default values are considered
-  // set to said value, as per MessageDiffencer::Equivalent. Use IgnoreField()
-  // and Compare() if some fields should be ignored in the comparison.
-  //
-  // This method REQUIRES that the two messages have the same
-  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
-  static bool ApproximatelyEquivalent(const Message& message1,
-                                      const Message& message2);
-
-  // Identifies an individual field in a message instance.  Used for field_path,
-  // below.
-  struct SpecificField {
-    // For known fields, "field" is filled in and "unknown_field_number" is -1.
-    // For unknown fields, "field" is NULL, "unknown_field_number" is the field
-    // number, and "unknown_field_type" is its type.
-    const FieldDescriptor* field = nullptr;
-    int unknown_field_number = -1;
-    UnknownField::Type unknown_field_type = UnknownField::Type::TYPE_VARINT;
-
-    // If this a repeated field, "index" is the index within it.  For unknown
-    // fields, this is the index of the field among all unknown fields of the
-    // same field number and type.
-    int index = -1;
-
-    // If "field" is a repeated field which is being treated as a map or
-    // a set (see TreatAsMap() and TreatAsSet(), below), new_index indicates
-    // the index the position to which the element has moved.  If the element
-    // has not moved, "new_index" will have the same value as "index".
-    int new_index = -1;
-
-    // If "field" is a map field, point to the map entry.
-    const Message* map_entry1 = nullptr;
-    const Message* map_entry2 = nullptr;
-
-    // For unknown fields, these are the pointers to the UnknownFieldSet
-    // containing the unknown fields. In certain cases (e.g. proto1's
-    // MessageSet, or nested groups of unknown fields), these may differ from
-    // the messages' internal UnknownFieldSets.
-    const UnknownFieldSet* unknown_field_set1 = nullptr;
-    const UnknownFieldSet* unknown_field_set2 = nullptr;
-
-    // For unknown fields, these are the index of the field within the
-    // UnknownFieldSets. One or the other will be -1 when
-    // reporting an addition or deletion.
-    int unknown_field_index1 = -1;
-    int unknown_field_index2 = -1;
-  };
-
-  // Abstract base class from which all MessageDifferencer
-  // reporters derive. The five Report* methods below will be called when
-  // a field has been added, deleted, modified, moved, or matched. The third
-  // argument is a vector of FieldDescriptor pointers which describes the chain
-  // of fields that was taken to find the current field. For example, for a
-  // field found in an embedded message, the vector will contain two
-  // FieldDescriptors. The first will be the field of the embedded message
-  // itself and the second will be the actual field in the embedded message
-  // that was added/deleted/modified.
-  // Fields will be reported in PostTraversalOrder.
-  // For example, given following proto, if both baz and mooo are changed.
-  // foo {
-  //   bar {
-  //     baz: 1
-  //     mooo: 2
-  //   }
-  // }
-  // ReportModified will be invoked with following order:
-  // 1. foo.bar.baz or foo.bar.mooo
-  // 2. foo.bar.mooo or foo.bar.baz
-  // 2. foo.bar
-  // 3. foo
-  class PROTOBUF_EXPORT Reporter {
-   public:
-    Reporter();
-    virtual ~Reporter();
-
-    // Reports that a field has been added into Message2.
-    virtual void ReportAdded(const Message& message1, const Message& message2,
-                             const std::vector<SpecificField>& field_path) = 0;
-
-    // Reports that a field has been deleted from Message1.
-    virtual void ReportDeleted(
-        const Message& message1, const Message& message2,
-        const std::vector<SpecificField>& field_path) = 0;
-
-    // Reports that the value of a field has been modified.
-    virtual void ReportModified(
-        const Message& message1, const Message& message2,
-        const std::vector<SpecificField>& field_path) = 0;
-
-    // Reports that a repeated field has been moved to another location.  This
-    // only applies when using TreatAsSet or TreatAsMap()  -- see below. Also
-    // note that for any given field, ReportModified and ReportMoved are
-    // mutually exclusive. If a field has been both moved and modified, then
-    // only ReportModified will be called.
-    virtual void ReportMoved(
-        const Message& /* message1 */, const Message& /* message2 */,
-        const std::vector<SpecificField>& /* field_path */) {}
-
-    // Reports that two fields match. Useful for doing side-by-side diffs.
-    // This function is mutually exclusive with ReportModified and ReportMoved.
-    // Note that you must call set_report_matches(true) before calling Compare
-    // to make use of this function.
-    virtual void ReportMatched(
-        const Message& /* message1 */, const Message& /* message2 */,
-        const std::vector<SpecificField>& /* field_path */) {}
-
-    // Reports that two fields would have been compared, but the
-    // comparison has been skipped because the field was marked as
-    // 'ignored' using IgnoreField().  This function is mutually
-    // exclusive with all the other Report() functions.
-    //
-    // The contract of ReportIgnored is slightly different than the
-    // other Report() functions, in that |field_path.back().index| is
-    // always equal to -1, even if the last field is repeated. This is
-    // because while the other Report() functions indicate where in a
-    // repeated field the action (Addition, Deletion, etc...)
-    // happened, when a repeated field is 'ignored', the differencer
-    // simply calls ReportIgnored on the repeated field as a whole and
-    // moves on without looking at its individual elements.
-    //
-    // Furthermore, ReportIgnored() does not indicate whether the
-    // fields were in fact equal or not, as Compare() does not inspect
-    // these fields at all. It is up to the Reporter to decide whether
-    // the fields are equal or not (perhaps with a second call to
-    // Compare()), if it cares.
-    virtual void ReportIgnored(
-        const Message& /* message1 */, const Message& /* message2 */,
-        const std::vector<SpecificField>& /* field_path */) {}
-
-    // Report that an unknown field is ignored. (see comment above).
-    // Note this is a different function since the last SpecificField in field
-    // path has a null field.  This could break existing Reporter.
-    virtual void ReportUnknownFieldIgnored(
-        const Message& /* message1 */, const Message& /* message2 */,
-        const std::vector<SpecificField>& /* field_path */) {}
-
-   private:
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reporter);
-  };
-
-  // MapKeyComparator is used to determine if two elements have the same key
-  // when comparing elements of a repeated field as a map.
-  class PROTOBUF_EXPORT MapKeyComparator {
-   public:
-    MapKeyComparator();
-    virtual ~MapKeyComparator();
-
-    virtual bool IsMatch(
-        const Message& /* message1 */, const Message& /* message2 */,
-        const std::vector<SpecificField>& /* parent_fields */) const {
-      GOOGLE_CHECK(false) << "IsMatch() is not implemented.";
-      return false;
-    }
-
-   private:
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapKeyComparator);
-  };
-
-  // Abstract base class from which all IgnoreCriteria derive.
-  // By adding IgnoreCriteria more complex ignore logic can be implemented.
-  // IgnoreCriteria are registered with AddIgnoreCriteria. For each compared
-  // field IsIgnored is called on each added IgnoreCriteria until one returns
-  // true or all return false.
-  // IsIgnored is called for fields where at least one side has a value.
-  class PROTOBUF_EXPORT IgnoreCriteria {
-   public:
-    IgnoreCriteria();
-    virtual ~IgnoreCriteria();
-
-    // Returns true if the field should be ignored.
-    virtual bool IsIgnored(
-        const Message& /* message1 */, const Message& /* message2 */,
-        const FieldDescriptor* /* field */,
-        const std::vector<SpecificField>& /* parent_fields */) = 0;
-
-    // Returns true if the unknown field should be ignored.
-    // Note: This will be called for unknown fields as well in which case
-    //       field.field will be null.
-    virtual bool IsUnknownFieldIgnored(
-        const Message& /* message1 */, const Message& /* message2 */,
-        const SpecificField& /* field */,
-        const std::vector<SpecificField>& /* parent_fields */) {
-      return false;
-    }
-  };
-
-  // To add a Reporter, construct default here, then use ReportDifferencesTo or
-  // ReportDifferencesToString.
-  explicit MessageDifferencer();
-
-  ~MessageDifferencer();
-
-  enum MessageFieldComparison {
-    EQUAL,       // Fields must be present in both messages
-                 // for the messages to be considered the same.
-    EQUIVALENT,  // Fields with default values are considered set
-                 // for comparison purposes even if not explicitly
-                 // set in the messages themselves.  Unknown fields
-                 // are ignored.
-  };
-
-  enum Scope {
-    FULL,    // All fields of both messages are considered in the comparison.
-    PARTIAL  // Only fields present in the first message are considered; fields
-             // set only in the second message will be skipped during
-             // comparison.
-  };
-
-  // DEPRECATED. Use FieldComparator::FloatComparison instead.
-  enum FloatComparison {
-    EXACT,       // Floats and doubles are compared exactly.
-    APPROXIMATE  // Floats and doubles are compared using the
-                 // MathUtil::AlmostEquals method.
-  };
-
-  enum RepeatedFieldComparison {
-    AS_LIST,  // Repeated fields are compared in order.  Differing values at
-              // the same index are reported using ReportModified().  If the
-              // repeated fields have different numbers of elements, the
-              // unpaired elements are reported using ReportAdded() or
-              // ReportDeleted().
-    AS_SET,   // Treat all the repeated fields as sets.
-              // See TreatAsSet(), as below.
-    AS_SMART_LIST,  // Similar to AS_SET, but preserve the order and find the
-                    // longest matching sequence from the first matching
-                    // element. To use an optimal solution, call
-                    // SetMatchIndicesForSmartListCallback() to pass it in.
-    AS_SMART_SET,   // Similar to AS_SET, but match elements with fewest diffs.
-  };
-
-  // The elements of the given repeated field will be treated as a set for
-  // diffing purposes, so different orderings of the same elements will be
-  // considered equal.  Elements which are present on both sides of the
-  // comparison but which have changed position will be reported with
-  // ReportMoved().  Elements which only exist on one side or the other are
-  // reported with ReportAdded() and ReportDeleted() regardless of their
-  // positions.  ReportModified() is never used for this repeated field.  If
-  // the only differences between the compared messages is that some fields
-  // have been moved, then the comparison returns true.
-  //
-  // Note that despite the name of this method, this is really
-  // comparison as multisets: if one side of the comparison has a duplicate
-  // in the repeated field but the other side doesn't, this will count as
-  // a mismatch.
-  //
-  // If the scope of comparison is set to PARTIAL, then in addition to what's
-  // above, extra values added to repeated fields of the second message will
-  // not cause the comparison to fail.
-  //
-  // Note that set comparison is currently O(k * n^2) (where n is the total
-  // number of elements, and k is the average size of each element). In theory
-  // it could be made O(n * k) with a more complex hashing implementation. Feel
-  // free to contribute one if the current implementation is too slow for you.
-  // If partial matching is also enabled, the time complexity will be O(k * n^2
-  // + n^3) in which n^3 is the time complexity of the maximum matching
-  // algorithm.
-  //
-  // REQUIRES: field->is_repeated() and field not registered with TreatAsMap*
-  void TreatAsSet(const FieldDescriptor* field);
-  void TreatAsSmartSet(const FieldDescriptor* field);
-
-  // The elements of the given repeated field will be treated as a list for
-  // diffing purposes, so different orderings of the same elements will NOT be
-  // considered equal.
-  //
-  // REQUIRES: field->is_repeated() and field not registered with TreatAsMap*
-  void TreatAsList(const FieldDescriptor* field);
-  // Note that the complexity is similar to treating as SET.
-  void TreatAsSmartList(const FieldDescriptor* field);
-
-  // The elements of the given repeated field will be treated as a map for
-  // diffing purposes, with |key| being the map key.  Thus, elements with the
-  // same key will be compared even if they do not appear at the same index.
-  // Differences are reported similarly to TreatAsSet(), except that
-  // ReportModified() is used to report elements with the same key but
-  // different values.  Note that if an element is both moved and modified,
-  // only ReportModified() will be called.  As with TreatAsSet, if the only
-  // differences between the compared messages is that some fields have been
-  // moved, then the comparison returns true. See TreatAsSet for notes on
-  // performance.
-  //
-  // REQUIRES:  field->is_repeated()
-  // REQUIRES:  field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
-  // REQUIRES:  key->containing_type() == field->message_type()
-  void TreatAsMap(const FieldDescriptor* field, const FieldDescriptor* key);
-  // Same as TreatAsMap except that this method will use multiple fields as
-  // the key in comparison. All specified fields in 'key_fields' should be
-  // present in the compared elements. Two elements will be treated as having
-  // the same key iff they have the same value for every specified field. There
-  // are two steps in the comparison process. The first one is key matching.
-  // Every element from one message will be compared to every element from
-  // the other message. Only fields in 'key_fields' are compared in this step
-  // to decide if two elements have the same key. The second step is value
-  // comparison. Those pairs of elements with the same key (with equal value
-  // for every field in 'key_fields') will be compared in this step.
-  // Time complexity of the first step is O(s * m * n ^ 2) where s is the
-  // average size of the fields specified in 'key_fields', m is the number of
-  // fields in 'key_fields' and n is the number of elements. If partial
-  // matching is enabled, an extra O(n^3) will be incured by the maximum
-  // matching algorithm. The second step is O(k * n) where k is the average
-  // size of each element.
-  void TreatAsMapWithMultipleFieldsAsKey(
-      const FieldDescriptor* field,
-      const std::vector<const FieldDescriptor*>& key_fields);
-  // Same as TreatAsMapWithMultipleFieldsAsKey, except that each of the field
-  // do not necessarily need to be a direct subfield. Each element in
-  // key_field_paths indicate a path from the message being compared, listing
-  // successive subfield to reach the key field.
-  //
-  // REQUIRES:
-  //   for key_field_path in key_field_paths:
-  //     key_field_path[0]->containing_type() == field->message_type()
-  //     for i in [0, key_field_path.size() - 1):
-  //       key_field_path[i+1]->containing_type() ==
-  //           key_field_path[i]->message_type()
-  //       key_field_path[i]->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
-  //       !key_field_path[i]->is_repeated()
-  void TreatAsMapWithMultipleFieldPathsAsKey(
-      const FieldDescriptor* field,
-      const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths);
-
-  // Uses a custom MapKeyComparator to determine if two elements have the same
-  // key when comparing a repeated field as a map.
-  // The caller is responsible to delete the key_comparator.
-  // This method varies from TreatAsMapWithMultipleFieldsAsKey only in the
-  // first key matching step. Rather than comparing some specified fields, it
-  // will invoke the IsMatch method of the given 'key_comparator' to decide if
-  // two elements have the same key.
-  void TreatAsMapUsingKeyComparator(const FieldDescriptor* field,
-                                    const MapKeyComparator* key_comparator);
-
-  // Initiates and returns a new instance of MultipleFieldsMapKeyComparator.
-  MapKeyComparator* CreateMultipleFieldsMapKeyComparator(
-      const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths);
-
-  // Add a custom ignore criteria that is evaluated in addition to the
-  // ignored fields added with IgnoreField.
-  // Takes ownership of ignore_criteria.
-  void AddIgnoreCriteria(IgnoreCriteria* ignore_criteria);
-
-  // Indicates that any field with the given descriptor should be
-  // ignored for the purposes of comparing two messages. This applies
-  // to fields nested in the message structure as well as top level
-  // ones. When the MessageDifferencer encounters an ignored field,
-  // ReportIgnored is called on the reporter, if one is specified.
-  //
-  // The only place where the field's 'ignored' status is not applied is when
-  // it is being used as a key in a field passed to TreatAsMap or is one of
-  // the fields passed to TreatAsMapWithMultipleFieldsAsKey.
-  // In this case it is compared in key matching but after that it's ignored
-  // in value comparison.
-  void IgnoreField(const FieldDescriptor* field);
-
-  // Sets the field comparator used to determine differences between protocol
-  // buffer fields. By default it's set to a DefaultFieldComparator instance.
-  // MessageDifferencer doesn't take ownership over the passed object.
-  // Note that this method must be called before Compare for the comparator to
-  // be used.
-  void set_field_comparator(FieldComparator* comparator);
+namespace google
+{
+    namespace protobuf
+    {
+
+        class DynamicMessageFactory;
+        class FieldDescriptor;
+
+        namespace io
+        {
+            class ZeroCopyOutputStream;
+            class Printer;
+        }  // namespace io
+
+        namespace util
+        {
+
+            class DefaultFieldComparator;
+            class FieldContext;  // declared below MessageDifferencer
+
+            // Defines a collection of field descriptors.
+            // In case of internal google codebase we are using absl::FixedArray instead
+            // of vector. It significantly speeds up proto comparison (by ~30%) by
+            // reducing the number of malloc/free operations
+            typedef std::vector<const FieldDescriptor*> FieldDescriptorArray;
+
+            // A basic differencer that can be used to determine
+            // the differences between two specified Protocol Messages. If any differences
+            // are found, the Compare method will return false, and any differencer reporter
+            // specified via ReportDifferencesTo will have its reporting methods called (see
+            // below for implementation of the report). Based off of the original
+            // ProtocolDifferencer implementation in //net/proto/protocol-differencer.h
+            // (Thanks Todd!).
+            //
+            // MessageDifferencer REQUIRES that compared messages be the same type, defined
+            // as messages that share the same descriptor.  If not, the behavior of this
+            // class is undefined.
+            //
+            // People disagree on what MessageDifferencer should do when asked to compare
+            // messages with different descriptors.  Some people think it should always
+            // return false.  Others expect it to try to look for similar fields and
+            // compare them anyway -- especially if the descriptors happen to be identical.
+            // If we chose either of these behaviors, some set of people would find it
+            // surprising, and could end up writing code expecting the other behavior
+            // without realizing their error.  Therefore, we forbid that usage.
+            //
+            // This class is implemented based on the proto2 reflection. The performance
+            // should be good enough for normal usages. However, for places where the
+            // performance is extremely sensitive, there are several alternatives:
+            // - Comparing serialized string
+            // Downside: false negatives (there are messages that are the same but their
+            // serialized strings are different).
+            // - Equals code generator by compiler plugin (net/proto2/contrib/equals_plugin)
+            // Downside: more generated code; maintenance overhead for the additional rule
+            // (must be in sync with the original proto_library).
+            //
+            // Note on handling of google.protobuf.Any: MessageDifferencer automatically
+            // unpacks Any::value into a Message and compares its individual fields.
+            // Messages encoded in a repeated Any cannot be compared using TreatAsMap.
+            //
+            // Note on thread-safety: MessageDifferencer is *not* thread-safe. You need to
+            // guard it with a lock to use the same MessageDifferencer instance from
+            // multiple threads. Note that it's fine to call static comparison methods
+            // (like MessageDifferencer::Equals) concurrently, but it's not recommended for
+            // performance critical code as it leads to extra allocations.
+            class PROTOBUF_EXPORT MessageDifferencer
+            {
+            public:
+                // Determines whether the supplied messages are equal. Equality is defined as
+                // all fields within the two messages being set to the same value. Primitive
+                // fields and strings are compared by value while embedded messages/groups
+                // are compared as if via a recursive call. Use Compare() with IgnoreField()
+                // if some fields should be ignored in the comparison. Use Compare() with
+                // TreatAsSet() if there are repeated fields where ordering does not matter.
+                //
+                // This method REQUIRES that the two messages have the same
+                // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+                static bool Equals(const Message& message1, const Message& message2);
+
+                // Determines whether the supplied messages are equivalent. Equivalency is
+                // defined as all fields within the two messages having the same value. This
+                // differs from the Equals method above in that fields with default values
+                // are considered set to said value automatically. For details on how default
+                // values are defined for each field type, see:
+                // https://developers.google.com/protocol-buffers/docs/proto?csw=1#optional.
+                // Also, Equivalent() ignores unknown fields. Use IgnoreField() and Compare()
+                // if some fields should be ignored in the comparison.
+                //
+                // This method REQUIRES that the two messages have the same
+                // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+                static bool Equivalent(const Message& message1, const Message& message2);
+
+                // Determines whether the supplied messages are approximately equal.
+                // Approximate equality is defined as all fields within the two messages
+                // being approximately equal.  Primitive (non-float) fields and strings are
+                // compared by value, floats are compared using MathUtil::AlmostEquals() and
+                // embedded messages/groups are compared as if via a recursive call. Use
+                // IgnoreField() and Compare() if some fields should be ignored in the
+                // comparison.
+                //
+                // This method REQUIRES that the two messages have the same
+                // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+                static bool ApproximatelyEquals(const Message& message1, const Message& message2);
+
+                // Determines whether the supplied messages are approximately equivalent.
+                // Approximate equivalency is defined as all fields within the two messages
+                // being approximately equivalent. As in
+                // MessageDifferencer::ApproximatelyEquals, primitive (non-float) fields and
+                // strings are compared by value, floats are compared using
+                // MathUtil::AlmostEquals() and embedded messages/groups are compared as if
+                // via a recursive call. However, fields with default values are considered
+                // set to said value, as per MessageDiffencer::Equivalent. Use IgnoreField()
+                // and Compare() if some fields should be ignored in the comparison.
+                //
+                // This method REQUIRES that the two messages have the same
+                // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+                static bool ApproximatelyEquivalent(const Message& message1, const Message& message2);
+
+                // Identifies an individual field in a message instance.  Used for field_path,
+                // below.
+                struct SpecificField
+                {
+                    // For known fields, "field" is filled in and "unknown_field_number" is -1.
+                    // For unknown fields, "field" is NULL, "unknown_field_number" is the field
+                    // number, and "unknown_field_type" is its type.
+                    const FieldDescriptor* field = nullptr;
+                    int unknown_field_number = -1;
+                    UnknownField::Type unknown_field_type = UnknownField::Type::TYPE_VARINT;
+
+                    // If this a repeated field, "index" is the index within it.  For unknown
+                    // fields, this is the index of the field among all unknown fields of the
+                    // same field number and type.
+                    int index = -1;
+
+                    // If "field" is a repeated field which is being treated as a map or
+                    // a set (see TreatAsMap() and TreatAsSet(), below), new_index indicates
+                    // the index the position to which the element has moved.  If the element
+                    // has not moved, "new_index" will have the same value as "index".
+                    int new_index = -1;
+
+                    // If "field" is a map field, point to the map entry.
+                    const Message* map_entry1 = nullptr;
+                    const Message* map_entry2 = nullptr;
+
+                    // For unknown fields, these are the pointers to the UnknownFieldSet
+                    // containing the unknown fields. In certain cases (e.g. proto1's
+                    // MessageSet, or nested groups of unknown fields), these may differ from
+                    // the messages' internal UnknownFieldSets.
+                    const UnknownFieldSet* unknown_field_set1 = nullptr;
+                    const UnknownFieldSet* unknown_field_set2 = nullptr;
+
+                    // For unknown fields, these are the index of the field within the
+                    // UnknownFieldSets. One or the other will be -1 when
+                    // reporting an addition or deletion.
+                    int unknown_field_index1 = -1;
+                    int unknown_field_index2 = -1;
+                };
+
+                // Abstract base class from which all MessageDifferencer
+                // reporters derive. The five Report* methods below will be called when
+                // a field has been added, deleted, modified, moved, or matched. The third
+                // argument is a vector of FieldDescriptor pointers which describes the chain
+                // of fields that was taken to find the current field. For example, for a
+                // field found in an embedded message, the vector will contain two
+                // FieldDescriptors. The first will be the field of the embedded message
+                // itself and the second will be the actual field in the embedded message
+                // that was added/deleted/modified.
+                // Fields will be reported in PostTraversalOrder.
+                // For example, given following proto, if both baz and mooo are changed.
+                // foo {
+                //   bar {
+                //     baz: 1
+                //     mooo: 2
+                //   }
+                // }
+                // ReportModified will be invoked with following order:
+                // 1. foo.bar.baz or foo.bar.mooo
+                // 2. foo.bar.mooo or foo.bar.baz
+                // 2. foo.bar
+                // 3. foo
+                class PROTOBUF_EXPORT Reporter
+                {
+                public:
+                    Reporter();
+                    virtual ~Reporter();
+
+                    // Reports that a field has been added into Message2.
+                    virtual void ReportAdded(const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path) = 0;
+
+                    // Reports that a field has been deleted from Message1.
+                    virtual void ReportDeleted(
+                        const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path
+                    ) = 0;
+
+                    // Reports that the value of a field has been modified.
+                    virtual void ReportModified(
+                        const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path
+                    ) = 0;
+
+                    // Reports that a repeated field has been moved to another location.  This
+                    // only applies when using TreatAsSet or TreatAsMap()  -- see below. Also
+                    // note that for any given field, ReportModified and ReportMoved are
+                    // mutually exclusive. If a field has been both moved and modified, then
+                    // only ReportModified will be called.
+                    virtual void ReportMoved(
+                        const Message& /* message1 */, const Message& /* message2 */, const std::vector<SpecificField>& /* field_path */
+                    )
+                    {
+                    }
+
+                    // Reports that two fields match. Useful for doing side-by-side diffs.
+                    // This function is mutually exclusive with ReportModified and ReportMoved.
+                    // Note that you must call set_report_matches(true) before calling Compare
+                    // to make use of this function.
+                    virtual void ReportMatched(
+                        const Message& /* message1 */, const Message& /* message2 */, const std::vector<SpecificField>& /* field_path */
+                    )
+                    {
+                    }
+
+                    // Reports that two fields would have been compared, but the
+                    // comparison has been skipped because the field was marked as
+                    // 'ignored' using IgnoreField().  This function is mutually
+                    // exclusive with all the other Report() functions.
+                    //
+                    // The contract of ReportIgnored is slightly different than the
+                    // other Report() functions, in that |field_path.back().index| is
+                    // always equal to -1, even if the last field is repeated. This is
+                    // because while the other Report() functions indicate where in a
+                    // repeated field the action (Addition, Deletion, etc...)
+                    // happened, when a repeated field is 'ignored', the differencer
+                    // simply calls ReportIgnored on the repeated field as a whole and
+                    // moves on without looking at its individual elements.
+                    //
+                    // Furthermore, ReportIgnored() does not indicate whether the
+                    // fields were in fact equal or not, as Compare() does not inspect
+                    // these fields at all. It is up to the Reporter to decide whether
+                    // the fields are equal or not (perhaps with a second call to
+                    // Compare()), if it cares.
+                    virtual void ReportIgnored(
+                        const Message& /* message1 */, const Message& /* message2 */, const std::vector<SpecificField>& /* field_path */
+                    )
+                    {
+                    }
+
+                    // Report that an unknown field is ignored. (see comment above).
+                    // Note this is a different function since the last SpecificField in field
+                    // path has a null field.  This could break existing Reporter.
+                    virtual void ReportUnknownFieldIgnored(
+                        const Message& /* message1 */, const Message& /* message2 */, const std::vector<SpecificField>& /* field_path */
+                    )
+                    {
+                    }
+
+                private:
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reporter);
+                };
+
+                // MapKeyComparator is used to determine if two elements have the same key
+                // when comparing elements of a repeated field as a map.
+                class PROTOBUF_EXPORT MapKeyComparator
+                {
+                public:
+                    MapKeyComparator();
+                    virtual ~MapKeyComparator();
+
+                    virtual bool IsMatch(
+                        const Message& /* message1 */, const Message& /* message2 */, const std::vector<SpecificField>& /* parent_fields */
+                    ) const
+                    {
+                        GOOGLE_CHECK(false) << "IsMatch() is not implemented.";
+                        return false;
+                    }
+
+                private:
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapKeyComparator);
+                };
+
+                // Abstract base class from which all IgnoreCriteria derive.
+                // By adding IgnoreCriteria more complex ignore logic can be implemented.
+                // IgnoreCriteria are registered with AddIgnoreCriteria. For each compared
+                // field IsIgnored is called on each added IgnoreCriteria until one returns
+                // true or all return false.
+                // IsIgnored is called for fields where at least one side has a value.
+                class PROTOBUF_EXPORT IgnoreCriteria
+                {
+                public:
+                    IgnoreCriteria();
+                    virtual ~IgnoreCriteria();
+
+                    // Returns true if the field should be ignored.
+                    virtual bool IsIgnored(
+                        const Message& /* message1 */, const Message& /* message2 */, const FieldDescriptor* /* field */, const std::vector<SpecificField>& /* parent_fields */
+                    ) = 0;
+
+                    // Returns true if the unknown field should be ignored.
+                    // Note: This will be called for unknown fields as well in which case
+                    //       field.field will be null.
+                    virtual bool IsUnknownFieldIgnored(
+                        const Message& /* message1 */, const Message& /* message2 */, const SpecificField& /* field */, const std::vector<SpecificField>& /* parent_fields */
+                    )
+                    {
+                        return false;
+                    }
+                };
+
+                // To add a Reporter, construct default here, then use ReportDifferencesTo or
+                // ReportDifferencesToString.
+                explicit MessageDifferencer();
+
+                ~MessageDifferencer();
+
+                enum MessageFieldComparison
+                {
+                    EQUAL,       // Fields must be present in both messages
+                                 // for the messages to be considered the same.
+                    EQUIVALENT,  // Fields with default values are considered set
+                                 // for comparison purposes even if not explicitly
+                                 // set in the messages themselves.  Unknown fields
+                                 // are ignored.
+                };
+
+                enum Scope
+                {
+                    FULL,    // All fields of both messages are considered in the comparison.
+                    PARTIAL  // Only fields present in the first message are considered; fields
+                             // set only in the second message will be skipped during
+                             // comparison.
+                };
+
+                // DEPRECATED. Use FieldComparator::FloatComparison instead.
+                enum FloatComparison
+                {
+                    EXACT,       // Floats and doubles are compared exactly.
+                    APPROXIMATE  // Floats and doubles are compared using the
+                                 // MathUtil::AlmostEquals method.
+                };
+
+                enum RepeatedFieldComparison
+                {
+                    AS_LIST,        // Repeated fields are compared in order.  Differing values at
+                                    // the same index are reported using ReportModified().  If the
+                                    // repeated fields have different numbers of elements, the
+                                    // unpaired elements are reported using ReportAdded() or
+                                    // ReportDeleted().
+                    AS_SET,         // Treat all the repeated fields as sets.
+                                    // See TreatAsSet(), as below.
+                    AS_SMART_LIST,  // Similar to AS_SET, but preserve the order and find the
+                                    // longest matching sequence from the first matching
+                                    // element. To use an optimal solution, call
+                                    // SetMatchIndicesForSmartListCallback() to pass it in.
+                    AS_SMART_SET,   // Similar to AS_SET, but match elements with fewest diffs.
+                };
+
+                // The elements of the given repeated field will be treated as a set for
+                // diffing purposes, so different orderings of the same elements will be
+                // considered equal.  Elements which are present on both sides of the
+                // comparison but which have changed position will be reported with
+                // ReportMoved().  Elements which only exist on one side or the other are
+                // reported with ReportAdded() and ReportDeleted() regardless of their
+                // positions.  ReportModified() is never used for this repeated field.  If
+                // the only differences between the compared messages is that some fields
+                // have been moved, then the comparison returns true.
+                //
+                // Note that despite the name of this method, this is really
+                // comparison as multisets: if one side of the comparison has a duplicate
+                // in the repeated field but the other side doesn't, this will count as
+                // a mismatch.
+                //
+                // If the scope of comparison is set to PARTIAL, then in addition to what's
+                // above, extra values added to repeated fields of the second message will
+                // not cause the comparison to fail.
+                //
+                // Note that set comparison is currently O(k * n^2) (where n is the total
+                // number of elements, and k is the average size of each element). In theory
+                // it could be made O(n * k) with a more complex hashing implementation. Feel
+                // free to contribute one if the current implementation is too slow for you.
+                // If partial matching is also enabled, the time complexity will be O(k * n^2
+                // + n^3) in which n^3 is the time complexity of the maximum matching
+                // algorithm.
+                //
+                // REQUIRES: field->is_repeated() and field not registered with TreatAsMap*
+                void TreatAsSet(const FieldDescriptor* field);
+                void TreatAsSmartSet(const FieldDescriptor* field);
+
+                // The elements of the given repeated field will be treated as a list for
+                // diffing purposes, so different orderings of the same elements will NOT be
+                // considered equal.
+                //
+                // REQUIRES: field->is_repeated() and field not registered with TreatAsMap*
+                void TreatAsList(const FieldDescriptor* field);
+                // Note that the complexity is similar to treating as SET.
+                void TreatAsSmartList(const FieldDescriptor* field);
+
+                // The elements of the given repeated field will be treated as a map for
+                // diffing purposes, with |key| being the map key.  Thus, elements with the
+                // same key will be compared even if they do not appear at the same index.
+                // Differences are reported similarly to TreatAsSet(), except that
+                // ReportModified() is used to report elements with the same key but
+                // different values.  Note that if an element is both moved and modified,
+                // only ReportModified() will be called.  As with TreatAsSet, if the only
+                // differences between the compared messages is that some fields have been
+                // moved, then the comparison returns true. See TreatAsSet for notes on
+                // performance.
+                //
+                // REQUIRES:  field->is_repeated()
+                // REQUIRES:  field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
+                // REQUIRES:  key->containing_type() == field->message_type()
+                void TreatAsMap(const FieldDescriptor* field, const FieldDescriptor* key);
+                // Same as TreatAsMap except that this method will use multiple fields as
+                // the key in comparison. All specified fields in 'key_fields' should be
+                // present in the compared elements. Two elements will be treated as having
+                // the same key iff they have the same value for every specified field. There
+                // are two steps in the comparison process. The first one is key matching.
+                // Every element from one message will be compared to every element from
+                // the other message. Only fields in 'key_fields' are compared in this step
+                // to decide if two elements have the same key. The second step is value
+                // comparison. Those pairs of elements with the same key (with equal value
+                // for every field in 'key_fields') will be compared in this step.
+                // Time complexity of the first step is O(s * m * n ^ 2) where s is the
+                // average size of the fields specified in 'key_fields', m is the number of
+                // fields in 'key_fields' and n is the number of elements. If partial
+                // matching is enabled, an extra O(n^3) will be incured by the maximum
+                // matching algorithm. The second step is O(k * n) where k is the average
+                // size of each element.
+                void TreatAsMapWithMultipleFieldsAsKey(
+                    const FieldDescriptor* field,
+                    const std::vector<const FieldDescriptor*>& key_fields
+                );
+                // Same as TreatAsMapWithMultipleFieldsAsKey, except that each of the field
+                // do not necessarily need to be a direct subfield. Each element in
+                // key_field_paths indicate a path from the message being compared, listing
+                // successive subfield to reach the key field.
+                //
+                // REQUIRES:
+                //   for key_field_path in key_field_paths:
+                //     key_field_path[0]->containing_type() == field->message_type()
+                //     for i in [0, key_field_path.size() - 1):
+                //       key_field_path[i+1]->containing_type() ==
+                //           key_field_path[i]->message_type()
+                //       key_field_path[i]->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
+                //       !key_field_path[i]->is_repeated()
+                void TreatAsMapWithMultipleFieldPathsAsKey(
+                    const FieldDescriptor* field,
+                    const std::vector<std::vector<const FieldDescriptor*>>& key_field_paths
+                );
+
+                // Uses a custom MapKeyComparator to determine if two elements have the same
+                // key when comparing a repeated field as a map.
+                // The caller is responsible to delete the key_comparator.
+                // This method varies from TreatAsMapWithMultipleFieldsAsKey only in the
+                // first key matching step. Rather than comparing some specified fields, it
+                // will invoke the IsMatch method of the given 'key_comparator' to decide if
+                // two elements have the same key.
+                void TreatAsMapUsingKeyComparator(const FieldDescriptor* field, const MapKeyComparator* key_comparator);
+
+                // Initiates and returns a new instance of MultipleFieldsMapKeyComparator.
+                MapKeyComparator* CreateMultipleFieldsMapKeyComparator(
+                    const std::vector<std::vector<const FieldDescriptor*>>& key_field_paths
+                );
+
+                // Add a custom ignore criteria that is evaluated in addition to the
+                // ignored fields added with IgnoreField.
+                // Takes ownership of ignore_criteria.
+                void AddIgnoreCriteria(IgnoreCriteria* ignore_criteria);
+
+                // Indicates that any field with the given descriptor should be
+                // ignored for the purposes of comparing two messages. This applies
+                // to fields nested in the message structure as well as top level
+                // ones. When the MessageDifferencer encounters an ignored field,
+                // ReportIgnored is called on the reporter, if one is specified.
+                //
+                // The only place where the field's 'ignored' status is not applied is when
+                // it is being used as a key in a field passed to TreatAsMap or is one of
+                // the fields passed to TreatAsMapWithMultipleFieldsAsKey.
+                // In this case it is compared in key matching but after that it's ignored
+                // in value comparison.
+                void IgnoreField(const FieldDescriptor* field);
+
+                // Sets the field comparator used to determine differences between protocol
+                // buffer fields. By default it's set to a DefaultFieldComparator instance.
+                // MessageDifferencer doesn't take ownership over the passed object.
+                // Note that this method must be called before Compare for the comparator to
+                // be used.
+                void set_field_comparator(FieldComparator* comparator);
 #ifdef PROTOBUF_FUTURE_BREAKING_CHANGES
-  void set_field_comparator(DefaultFieldComparator* comparator);
+                void set_field_comparator(DefaultFieldComparator* comparator);
 #endif  // PROTOBUF_FUTURE_BREAKING_CHANGES
 
-  // DEPRECATED. Pass a DefaultFieldComparator instance instead.
-  // Sets the fraction and margin for the float comparison of a given field.
-  // Uses MathUtil::WithinFractionOrMargin to compare the values.
-  // NOTE: this method does nothing if differencer's field comparator has been
-  //       set to a custom object.
-  //
-  // REQUIRES: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE or
-  //           field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT
-  // REQUIRES: float_comparison_ == APPROXIMATE
-  void SetFractionAndMargin(const FieldDescriptor* field, double fraction,
-                            double margin);
-
-  // Sets the type of comparison (as defined in the MessageFieldComparison
-  // enumeration above) that is used by this differencer when determining how
-  // to compare fields in messages.
-  void set_message_field_comparison(MessageFieldComparison comparison);
-
-  // Returns the current message field comparison used in this differencer.
-  MessageFieldComparison message_field_comparison() const;
-
-  // Tells the differencer whether or not to report matches. This method must
-  // be called before Compare. The default for a new differencer is false.
-  void set_report_matches(bool report_matches) {
-    report_matches_ = report_matches;
-  }
-
-  // Tells the differencer whether or not to report moves (in a set or map
-  // repeated field). This method must be called before Compare. The default for
-  // a new differencer is true.
-  void set_report_moves(bool report_moves) { report_moves_ = report_moves; }
-
-  // Tells the differencer whether or not to report ignored values. This method
-  // must be called before Compare. The default for a new differencer is true.
-  void set_report_ignores(bool report_ignores) {
-    report_ignores_ = report_ignores;
-  }
-
-  // Sets the scope of the comparison (as defined in the Scope enumeration
-  // above) that is used by this differencer when determining which fields to
-  // compare between the messages.
-  void set_scope(Scope scope);
-
-  // Returns the current scope used by this differencer.
-  Scope scope() const;
-
-  // DEPRECATED. Pass a DefaultFieldComparator instance instead.
-  // Sets the type of comparison (as defined in the FloatComparison enumeration
-  // above) that is used by this differencer when comparing float (and double)
-  // fields in messages.
-  // NOTE: this method does nothing if differencer's field comparator has been
-  //       set to a custom object.
-  void set_float_comparison(FloatComparison comparison);
-
-  // Sets the type of comparison for repeated field (as defined in the
-  // RepeatedFieldComparison enumeration above) that is used by this
-  // differencer when compare repeated fields in messages.
-  void set_repeated_field_comparison(RepeatedFieldComparison comparison);
-
-  // Returns the current repeated field comparison used by this differencer.
-  RepeatedFieldComparison repeated_field_comparison() const;
-
-  // Compares the two specified messages, returning true if they are the same,
-  // false otherwise. If this method returns false, any changes between the
-  // two messages will be reported if a Reporter was specified via
-  // ReportDifferencesTo (see also ReportDifferencesToString).
-  //
-  // This method REQUIRES that the two messages have the same
-  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
-  bool Compare(const Message& message1, const Message& message2);
-
-  // Same as above, except comparing only the list of fields specified by the
-  // two vectors of FieldDescriptors.
-  bool CompareWithFields(
-      const Message& message1, const Message& message2,
-      const std::vector<const FieldDescriptor*>& message1_fields,
-      const std::vector<const FieldDescriptor*>& message2_fields);
-
-  // Automatically creates a reporter that will output the differences
-  // found (if any) to the specified output string pointer. Note that this
-  // method must be called before Compare.
-  void ReportDifferencesToString(std::string* output);
-
-  // Tells the MessageDifferencer to report differences via the specified
-  // reporter. Note that this method must be called before Compare for
-  // the reporter to be used. It is the responsibility of the caller to delete
-  // this object.
-  // If the provided pointer equals NULL, the MessageDifferencer stops reporting
-  // differences to any previously set reporters or output strings.
-  void ReportDifferencesTo(Reporter* reporter);
-
- private:
-  // Class for processing Any deserialization.  This logic is used by both the
-  // MessageDifferencer and StreamReporter classes.
-  class UnpackAnyField {
-   private:
-    std::unique_ptr<DynamicMessageFactory> dynamic_message_factory_;
-
-   public:
-    UnpackAnyField() = default;
-    ~UnpackAnyField() = default;
-    // If "any" is of type google.protobuf.Any, extract its payload using
-    // DynamicMessageFactory and store in "data".
-    bool UnpackAny(const Message& any, std::unique_ptr<Message>* data);
-  };
-
- public:
-  // An implementation of the MessageDifferencer Reporter that outputs
-  // any differences found in human-readable form to the supplied
-  // ZeroCopyOutputStream or Printer. If a printer is used, the delimiter
-  // *must* be '$'.
-  //
-  // WARNING: this reporter does not necessarily flush its output until it is
-  // destroyed. As a result, it is not safe to assume the output is valid or
-  // complete until after you destroy the reporter. For example, if you use a
-  // StreamReporter to write to a StringOutputStream, the target string may
-  // contain uninitialized data until the reporter is destroyed.
-  class PROTOBUF_EXPORT StreamReporter : public Reporter {
-   public:
-    explicit StreamReporter(io::ZeroCopyOutputStream* output);
-    explicit StreamReporter(io::Printer* printer);  // delimiter '$'
-    ~StreamReporter() override;
-
-    // When set to true, the stream reporter will also output aggregates nodes
-    // (i.e. messages and groups) whose subfields have been modified. When
-    // false, will only report the individual subfields. Defaults to false.
-    void set_report_modified_aggregates(bool report) {
-      report_modified_aggregates_ = report;
-    }
-
-    // The following are implementations of the methods described above.
-
-    void ReportAdded(const Message& message1, const Message& message2,
-                     const std::vector<SpecificField>& field_path) override;
-
-    void ReportDeleted(const Message& message1, const Message& message2,
-                       const std::vector<SpecificField>& field_path) override;
-
-    void ReportModified(const Message& message1, const Message& message2,
-                        const std::vector<SpecificField>& field_path) override;
-
-    void ReportMoved(const Message& message1, const Message& message2,
-                     const std::vector<SpecificField>& field_path) override;
-
-    void ReportMatched(const Message& message1, const Message& message2,
-                       const std::vector<SpecificField>& field_path) override;
-
-    void ReportIgnored(const Message& message1, const Message& message2,
-                       const std::vector<SpecificField>& field_path) override;
-
-    void ReportUnknownFieldIgnored(
-        const Message& message1, const Message& message2,
-        const std::vector<SpecificField>& field_path) override;
-
-    // Messages that are being compared must be provided to StreamReporter prior
-    // to processing
-    void SetMessages(const Message& message1, const Message& message2);
-
-   protected:
-    // Prints the specified path of fields to the buffer.
-    virtual void PrintPath(const std::vector<SpecificField>& field_path,
-                           bool left_side);
-
-    // Prints the value of fields to the buffer.  left_side is true if the
-    // given message is from the left side of the comparison, false if it
-    // was the right.  This is relevant only to decide whether to follow
-    // unknown_field_index1 or unknown_field_index2 when an unknown field
-    // is encountered in field_path.
-    virtual void PrintValue(const Message& message,
-                            const std::vector<SpecificField>& field_path,
-                            bool left_side);
-
-    // Prints the specified path of unknown fields to the buffer.
-    virtual void PrintUnknownFieldValue(const UnknownField* unknown_field);
-
-    // Just print a string
-    void Print(const std::string& str);
-
-   private:
-    // helper function for PrintPath that contains logic for printing maps
-    void PrintMapKey(bool left_side, const SpecificField& specific_field);
-
-    io::Printer* printer_;
-    bool delete_printer_;
-    bool report_modified_aggregates_;
-    const Message* message1_;
-    const Message* message2_;
-    MessageDifferencer::UnpackAnyField unpack_any_field_;
-    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StreamReporter);
-  };
-
- private:
-  friend class SimpleFieldComparator;
-
-  // A MapKeyComparator to be used in TreatAsMapUsingKeyComparator.
-  // Implementation of this class needs to do field value comparison which
-  // relies on some private methods of MessageDifferencer. That's why this
-  // class is declared as a nested class of MessageDifferencer.
-  class MultipleFieldsMapKeyComparator;
-
-  // A MapKeyComparator for use with map_entries.
-  class PROTOBUF_EXPORT MapEntryKeyComparator : public MapKeyComparator {
-   public:
-    explicit MapEntryKeyComparator(MessageDifferencer* message_differencer);
-    bool IsMatch(
-        const Message& message1, const Message& message2,
-        const std::vector<SpecificField>& parent_fields) const override;
-
-   private:
-    MessageDifferencer* message_differencer_;
-  };
-
-  // Returns true if field1's number() is less than field2's.
-  static bool FieldBefore(const FieldDescriptor* field1,
-                          const FieldDescriptor* field2);
-
-  // Retrieve all the set fields, including extensions.
-  FieldDescriptorArray RetrieveFields(const Message& message,
-                                      bool base_message);
-
-  // Combine the two lists of fields into the combined_fields output vector.
-  // All fields present in both lists will always be included in the combined
-  // list.  Fields only present in one of the lists will only appear in the
-  // combined list if the corresponding fields_scope option is set to FULL.
-  FieldDescriptorArray CombineFields(const FieldDescriptorArray& fields1,
-                                     Scope fields1_scope,
-                                     const FieldDescriptorArray& fields2,
-                                     Scope fields2_scope);
-
-  // Internal version of the Compare method which performs the actual
-  // comparison. The parent_fields vector is a vector containing field
-  // descriptors of all fields accessed to get to this comparison operation
-  // (i.e. if the current message is an embedded message, the parent_fields
-  // vector will contain the field that has this embedded message).
-  bool Compare(const Message& message1, const Message& message2,
-               std::vector<SpecificField>* parent_fields);
-
-  // Compares all the unknown fields in two messages.
-  bool CompareUnknownFields(const Message& message1, const Message& message2,
-                            const UnknownFieldSet&, const UnknownFieldSet&,
-                            std::vector<SpecificField>* parent_fields);
-
-  // Compares the specified messages for the requested field lists. The field
-  // lists are modified depending on comparison settings, and then passed to
-  // CompareWithFieldsInternal.
-  bool CompareRequestedFieldsUsingSettings(
-      const Message& message1, const Message& message2,
-      const FieldDescriptorArray& message1_fields,
-      const FieldDescriptorArray& message2_fields,
-      std::vector<SpecificField>* parent_fields);
-
-  // Compares the specified messages with the specified field lists.
-  bool CompareWithFieldsInternal(const Message& message1,
-                                 const Message& message2,
-                                 const FieldDescriptorArray& message1_fields,
-                                 const FieldDescriptorArray& message2_fields,
-                                 std::vector<SpecificField>* parent_fields);
-
-  // Compares the repeated fields, and report the error.
-  bool CompareRepeatedField(const Message& message1, const Message& message2,
-                            const FieldDescriptor* field,
-                            std::vector<SpecificField>* parent_fields);
-
-  // Compares map fields, and report the error.
-  bool CompareMapField(const Message& message1, const Message& message2,
-                       const FieldDescriptor* field,
-                       std::vector<SpecificField>* parent_fields);
-
-  // Helper for CompareRepeatedField and CompareMapField: compares and reports
-  // differences element-wise. This is the implementation for non-map fields,
-  // and can also compare map fields by using the underlying representation.
-  bool CompareRepeatedRep(const Message& message1, const Message& message2,
-                          const FieldDescriptor* field,
-                          std::vector<SpecificField>* parent_fields);
-
-  // Helper for CompareMapField: compare the map fields using map reflection
-  // instead of sync to repeated.
-  bool CompareMapFieldByMapReflection(const Message& message1,
-                                      const Message& message2,
-                                      const FieldDescriptor* field,
-                                      std::vector<SpecificField>* parent_fields,
-                                      DefaultFieldComparator* comparator);
-
-  // Shorthand for CompareFieldValueUsingParentFields with NULL parent_fields.
-  bool CompareFieldValue(const Message& message1, const Message& message2,
-                         const FieldDescriptor* field, int index1, int index2);
-
-  // Compares the specified field on the two messages, returning
-  // true if they are the same, false otherwise. For repeated fields,
-  // this method only compares the value in the specified index. This method
-  // uses Compare functions to recurse into submessages.
-  // The parent_fields vector is used in calls to a Reporter instance calls.
-  // It can be NULL, in which case the MessageDifferencer will create new
-  // list of parent messages if it needs to recursively compare the given field.
-  // To avoid confusing users you should not set it to NULL unless you modified
-  // Reporter to handle the change of parent_fields correctly.
-  bool CompareFieldValueUsingParentFields(
-      const Message& message1, const Message& message2,
-      const FieldDescriptor* field, int index1, int index2,
-      std::vector<SpecificField>* parent_fields);
-
-  // Compares the specified field on the two messages, returning comparison
-  // result, as returned by appropriate FieldComparator.
-  FieldComparator::ComparisonResult GetFieldComparisonResult(
-      const Message& message1, const Message& message2,
-      const FieldDescriptor* field, int index1, int index2,
-      const FieldContext* field_context);
-
-  // Check if the two elements in the repeated field are match to each other.
-  // if the key_comprator is NULL, this function returns true when the two
-  // elements are equal.
-  bool IsMatch(const FieldDescriptor* repeated_field,
-               const MapKeyComparator* key_comparator, const Message* message1,
-               const Message* message2,
-               const std::vector<SpecificField>& parent_fields,
-               Reporter* reporter, int index1, int index2);
-
-  // Returns true when this repeated field has been configured to be treated
-  // as a Set / SmartSet / SmartList.
-  bool IsTreatedAsSet(const FieldDescriptor* field);
-  bool IsTreatedAsSmartSet(const FieldDescriptor* field);
-
-  bool IsTreatedAsSmartList(const FieldDescriptor* field);
-  // When treating as SMART_LIST, it uses MatchIndicesPostProcessorForSmartList
-  // by default to find the longest matching sequence from the first matching
-  // element. The callback takes two vectors showing the matching indices from
-  // the other vector, where -1 means an unmatch.
-  void SetMatchIndicesForSmartListCallback(
-      std::function<void(std::vector<int>*, std::vector<int>*)> callback);
-
-  // Returns true when this repeated field is to be compared as a subset, ie.
-  // has been configured to be treated as a set or map and scope is set to
-  // PARTIAL.
-  bool IsTreatedAsSubset(const FieldDescriptor* field);
-
-  // Returns true if this field is to be ignored when this
-  // MessageDifferencer compares messages.
-  bool IsIgnored(const Message& message1, const Message& message2,
-                 const FieldDescriptor* field,
-                 const std::vector<SpecificField>& parent_fields);
-
-  // Returns true if this unknown field is to be ignored when this
-  // MessageDifferencer compares messages.
-  bool IsUnknownFieldIgnored(const Message& message1, const Message& message2,
-                             const SpecificField& field,
-                             const std::vector<SpecificField>& parent_fields);
-
-  // Returns MapKeyComparator* when this field has been configured to be treated
-  // as a map or its is_map() return true.  If not, returns NULL.
-  const MapKeyComparator* GetMapKeyComparator(
-      const FieldDescriptor* field) const;
-
-  // Attempts to match indices of a repeated field, so that the contained values
-  // match. Clears output vectors and sets their values to indices of paired
-  // messages, ie. if message1[0] matches message2[1], then match_list1[0] == 1
-  // and match_list2[1] == 0. The unmatched indices are indicated by -1.
-  // Assumes the repeated field is not treated as a simple list.
-  // This method returns false if the match failed. However, it doesn't mean
-  // that the comparison succeeds when this method returns true (you need to
-  // double-check in this case).
-  bool MatchRepeatedFieldIndices(
-      const Message& message1, const Message& message2,
-      const FieldDescriptor* repeated_field,
-      const MapKeyComparator* key_comparator,
-      const std::vector<SpecificField>& parent_fields,
-      std::vector<int>* match_list1, std::vector<int>* match_list2);
-
-  // Checks if index is equal to new_index in all the specific fields.
-  static bool CheckPathChanged(const std::vector<SpecificField>& parent_fields);
-
-  // CHECKs that the given repeated field can be compared according to
-  // new_comparison.
-  void CheckRepeatedFieldComparisons(
-      const FieldDescriptor* field,
-      const RepeatedFieldComparison& new_comparison);
-
-  // Defines a map between field descriptors and their MapKeyComparators.
-  // Used for repeated fields when they are configured as TreatAsMap.
-  typedef std::map<const FieldDescriptor*, const MapKeyComparator*>
-      FieldKeyComparatorMap;
-
-  // Defines a set to store field descriptors.  Used for repeated fields when
-  // they are configured as TreatAsSet.
-  typedef std::set<const FieldDescriptor*> FieldSet;
-  typedef std::map<const FieldDescriptor*, RepeatedFieldComparison> FieldMap;
-
-  Reporter* reporter_;
-  DefaultFieldComparator default_field_comparator_;
-  MessageFieldComparison message_field_comparison_;
-  Scope scope_;
-  RepeatedFieldComparison repeated_field_comparison_;
-
-  FieldMap repeated_field_comparisons_;
-  // Keeps track of MapKeyComparators that are created within
-  // MessageDifferencer. These MapKeyComparators should be deleted
-  // before MessageDifferencer is destroyed.
-  // When TreatAsMap or TreatAsMapWithMultipleFieldsAsKey is called, we don't
-  // store the supplied FieldDescriptors directly. Instead, a new
-  // MapKeyComparator is created for comparison purpose.
-  std::vector<MapKeyComparator*> owned_key_comparators_;
-  FieldKeyComparatorMap map_field_key_comparator_;
-  MapEntryKeyComparator map_entry_key_comparator_;
-  std::vector<IgnoreCriteria*> ignore_criteria_;
-  // Reused multiple times in RetrieveFields to avoid extra allocations
-  std::vector<const FieldDescriptor*> tmp_message_fields_;
-
-  FieldSet ignored_fields_;
-
-  union {
-    DefaultFieldComparator* default_impl;
-    FieldComparator* base;
-  } field_comparator_ = {&default_field_comparator_};
-  enum { kFCDefault, kFCBase } field_comparator_kind_ = kFCDefault;
-
-  bool report_matches_;
-  bool report_moves_;
-  bool report_ignores_;
-
-  std::string* output_string_;
-
-  // Callback to post-process the matched indices to support SMART_LIST.
-  std::function<void(std::vector<int>*, std::vector<int>*)>
-      match_indices_for_smart_list_callback_;
-
-  MessageDifferencer::UnpackAnyField unpack_any_field_;
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageDifferencer);
-};
-
-// This class provides extra information to the FieldComparator::Compare
-// function.
-class PROTOBUF_EXPORT FieldContext {
- public:
-  explicit FieldContext(
-      std::vector<MessageDifferencer::SpecificField>* parent_fields)
-      : parent_fields_(parent_fields) {}
-
-  std::vector<MessageDifferencer::SpecificField>* parent_fields() const {
-    return parent_fields_;
-  }
-
- private:
-  std::vector<MessageDifferencer::SpecificField>* parent_fields_;
-};
-
-}  // namespace util
-}  // namespace protobuf
+                // DEPRECATED. Pass a DefaultFieldComparator instance instead.
+                // Sets the fraction and margin for the float comparison of a given field.
+                // Uses MathUtil::WithinFractionOrMargin to compare the values.
+                // NOTE: this method does nothing if differencer's field comparator has been
+                //       set to a custom object.
+                //
+                // REQUIRES: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE or
+                //           field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT
+                // REQUIRES: float_comparison_ == APPROXIMATE
+                void SetFractionAndMargin(const FieldDescriptor* field, double fraction, double margin);
+
+                // Sets the type of comparison (as defined in the MessageFieldComparison
+                // enumeration above) that is used by this differencer when determining how
+                // to compare fields in messages.
+                void set_message_field_comparison(MessageFieldComparison comparison);
+
+                // Returns the current message field comparison used in this differencer.
+                MessageFieldComparison message_field_comparison() const;
+
+                // Tells the differencer whether or not to report matches. This method must
+                // be called before Compare. The default for a new differencer is false.
+                void set_report_matches(bool report_matches)
+                {
+                    report_matches_ = report_matches;
+                }
+
+                // Tells the differencer whether or not to report moves (in a set or map
+                // repeated field). This method must be called before Compare. The default for
+                // a new differencer is true.
+                void set_report_moves(bool report_moves)
+                {
+                    report_moves_ = report_moves;
+                }
+
+                // Tells the differencer whether or not to report ignored values. This method
+                // must be called before Compare. The default for a new differencer is true.
+                void set_report_ignores(bool report_ignores)
+                {
+                    report_ignores_ = report_ignores;
+                }
+
+                // Sets the scope of the comparison (as defined in the Scope enumeration
+                // above) that is used by this differencer when determining which fields to
+                // compare between the messages.
+                void set_scope(Scope scope);
+
+                // Returns the current scope used by this differencer.
+                Scope scope() const;
+
+                // DEPRECATED. Pass a DefaultFieldComparator instance instead.
+                // Sets the type of comparison (as defined in the FloatComparison enumeration
+                // above) that is used by this differencer when comparing float (and double)
+                // fields in messages.
+                // NOTE: this method does nothing if differencer's field comparator has been
+                //       set to a custom object.
+                void set_float_comparison(FloatComparison comparison);
+
+                // Sets the type of comparison for repeated field (as defined in the
+                // RepeatedFieldComparison enumeration above) that is used by this
+                // differencer when compare repeated fields in messages.
+                void set_repeated_field_comparison(RepeatedFieldComparison comparison);
+
+                // Returns the current repeated field comparison used by this differencer.
+                RepeatedFieldComparison repeated_field_comparison() const;
+
+                // Compares the two specified messages, returning true if they are the same,
+                // false otherwise. If this method returns false, any changes between the
+                // two messages will be reported if a Reporter was specified via
+                // ReportDifferencesTo (see also ReportDifferencesToString).
+                //
+                // This method REQUIRES that the two messages have the same
+                // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+                bool Compare(const Message& message1, const Message& message2);
+
+                // Same as above, except comparing only the list of fields specified by the
+                // two vectors of FieldDescriptors.
+                bool CompareWithFields(
+                    const Message& message1, const Message& message2, const std::vector<const FieldDescriptor*>& message1_fields, const std::vector<const FieldDescriptor*>& message2_fields
+                );
+
+                // Automatically creates a reporter that will output the differences
+                // found (if any) to the specified output string pointer. Note that this
+                // method must be called before Compare.
+                void ReportDifferencesToString(std::string* output);
+
+                // Tells the MessageDifferencer to report differences via the specified
+                // reporter. Note that this method must be called before Compare for
+                // the reporter to be used. It is the responsibility of the caller to delete
+                // this object.
+                // If the provided pointer equals NULL, the MessageDifferencer stops reporting
+                // differences to any previously set reporters or output strings.
+                void ReportDifferencesTo(Reporter* reporter);
+
+            private:
+                // Class for processing Any deserialization.  This logic is used by both the
+                // MessageDifferencer and StreamReporter classes.
+                class UnpackAnyField
+                {
+                private:
+                    std::unique_ptr<DynamicMessageFactory> dynamic_message_factory_;
+
+                public:
+                    UnpackAnyField() = default;
+                    ~UnpackAnyField() = default;
+                    // If "any" is of type google.protobuf.Any, extract its payload using
+                    // DynamicMessageFactory and store in "data".
+                    bool UnpackAny(const Message& any, std::unique_ptr<Message>* data);
+                };
+
+            public:
+                // An implementation of the MessageDifferencer Reporter that outputs
+                // any differences found in human-readable form to the supplied
+                // ZeroCopyOutputStream or Printer. If a printer is used, the delimiter
+                // *must* be '$'.
+                //
+                // WARNING: this reporter does not necessarily flush its output until it is
+                // destroyed. As a result, it is not safe to assume the output is valid or
+                // complete until after you destroy the reporter. For example, if you use a
+                // StreamReporter to write to a StringOutputStream, the target string may
+                // contain uninitialized data until the reporter is destroyed.
+                class PROTOBUF_EXPORT StreamReporter : public Reporter
+                {
+                public:
+                    explicit StreamReporter(io::ZeroCopyOutputStream* output);
+                    explicit StreamReporter(io::Printer* printer);  // delimiter '$'
+                    ~StreamReporter() override;
+
+                    // When set to true, the stream reporter will also output aggregates nodes
+                    // (i.e. messages and groups) whose subfields have been modified. When
+                    // false, will only report the individual subfields. Defaults to false.
+                    void set_report_modified_aggregates(bool report)
+                    {
+                        report_modified_aggregates_ = report;
+                    }
+
+                    // The following are implementations of the methods described above.
+
+                    void ReportAdded(const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path) override;
+
+                    void ReportDeleted(const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path) override;
+
+                    void ReportModified(const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path) override;
+
+                    void ReportMoved(const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path) override;
+
+                    void ReportMatched(const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path) override;
+
+                    void ReportIgnored(const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path) override;
+
+                    void ReportUnknownFieldIgnored(
+                        const Message& message1, const Message& message2, const std::vector<SpecificField>& field_path
+                    ) override;
+
+                    // Messages that are being compared must be provided to StreamReporter prior
+                    // to processing
+                    void SetMessages(const Message& message1, const Message& message2);
+
+                protected:
+                    // Prints the specified path of fields to the buffer.
+                    virtual void PrintPath(const std::vector<SpecificField>& field_path, bool left_side);
+
+                    // Prints the value of fields to the buffer.  left_side is true if the
+                    // given message is from the left side of the comparison, false if it
+                    // was the right.  This is relevant only to decide whether to follow
+                    // unknown_field_index1 or unknown_field_index2 when an unknown field
+                    // is encountered in field_path.
+                    virtual void PrintValue(const Message& message, const std::vector<SpecificField>& field_path, bool left_side);
+
+                    // Prints the specified path of unknown fields to the buffer.
+                    virtual void PrintUnknownFieldValue(const UnknownField* unknown_field);
+
+                    // Just print a string
+                    void Print(const std::string& str);
+
+                private:
+                    // helper function for PrintPath that contains logic for printing maps
+                    void PrintMapKey(bool left_side, const SpecificField& specific_field);
+
+                    io::Printer* printer_;
+                    bool delete_printer_;
+                    bool report_modified_aggregates_;
+                    const Message* message1_;
+                    const Message* message2_;
+                    MessageDifferencer::UnpackAnyField unpack_any_field_;
+                    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StreamReporter);
+                };
+
+            private:
+                friend class SimpleFieldComparator;
+
+                // A MapKeyComparator to be used in TreatAsMapUsingKeyComparator.
+                // Implementation of this class needs to do field value comparison which
+                // relies on some private methods of MessageDifferencer. That's why this
+                // class is declared as a nested class of MessageDifferencer.
+                class MultipleFieldsMapKeyComparator;
+
+                // A MapKeyComparator for use with map_entries.
+                class PROTOBUF_EXPORT MapEntryKeyComparator : public MapKeyComparator
+                {
+                public:
+                    explicit MapEntryKeyComparator(MessageDifferencer* message_differencer);
+                    bool IsMatch(
+                        const Message& message1, const Message& message2, const std::vector<SpecificField>& parent_fields
+                    ) const override;
+
+                private:
+                    MessageDifferencer* message_differencer_;
+                };
+
+                // Returns true if field1's number() is less than field2's.
+                static bool FieldBefore(const FieldDescriptor* field1, const FieldDescriptor* field2);
+
+                // Retrieve all the set fields, including extensions.
+                FieldDescriptorArray RetrieveFields(const Message& message, bool base_message);
+
+                // Combine the two lists of fields into the combined_fields output vector.
+                // All fields present in both lists will always be included in the combined
+                // list.  Fields only present in one of the lists will only appear in the
+                // combined list if the corresponding fields_scope option is set to FULL.
+                FieldDescriptorArray CombineFields(const FieldDescriptorArray& fields1, Scope fields1_scope, const FieldDescriptorArray& fields2, Scope fields2_scope);
+
+                // Internal version of the Compare method which performs the actual
+                // comparison. The parent_fields vector is a vector containing field
+                // descriptors of all fields accessed to get to this comparison operation
+                // (i.e. if the current message is an embedded message, the parent_fields
+                // vector will contain the field that has this embedded message).
+                bool Compare(const Message& message1, const Message& message2, std::vector<SpecificField>* parent_fields);
+
+                // Compares all the unknown fields in two messages.
+                bool CompareUnknownFields(const Message& message1, const Message& message2, const UnknownFieldSet&, const UnknownFieldSet&, std::vector<SpecificField>* parent_fields);
+
+                // Compares the specified messages for the requested field lists. The field
+                // lists are modified depending on comparison settings, and then passed to
+                // CompareWithFieldsInternal.
+                bool CompareRequestedFieldsUsingSettings(
+                    const Message& message1, const Message& message2, const FieldDescriptorArray& message1_fields, const FieldDescriptorArray& message2_fields, std::vector<SpecificField>* parent_fields
+                );
+
+                // Compares the specified messages with the specified field lists.
+                bool CompareWithFieldsInternal(const Message& message1, const Message& message2, const FieldDescriptorArray& message1_fields, const FieldDescriptorArray& message2_fields, std::vector<SpecificField>* parent_fields);
+
+                // Compares the repeated fields, and report the error.
+                bool CompareRepeatedField(const Message& message1, const Message& message2, const FieldDescriptor* field, std::vector<SpecificField>* parent_fields);
+
+                // Compares map fields, and report the error.
+                bool CompareMapField(const Message& message1, const Message& message2, const FieldDescriptor* field, std::vector<SpecificField>* parent_fields);
+
+                // Helper for CompareRepeatedField and CompareMapField: compares and reports
+                // differences element-wise. This is the implementation for non-map fields,
+                // and can also compare map fields by using the underlying representation.
+                bool CompareRepeatedRep(const Message& message1, const Message& message2, const FieldDescriptor* field, std::vector<SpecificField>* parent_fields);
+
+                // Helper for CompareMapField: compare the map fields using map reflection
+                // instead of sync to repeated.
+                bool CompareMapFieldByMapReflection(const Message& message1, const Message& message2, const FieldDescriptor* field, std::vector<SpecificField>* parent_fields, DefaultFieldComparator* comparator);
+
+                // Shorthand for CompareFieldValueUsingParentFields with NULL parent_fields.
+                bool CompareFieldValue(const Message& message1, const Message& message2, const FieldDescriptor* field, int index1, int index2);
+
+                // Compares the specified field on the two messages, returning
+                // true if they are the same, false otherwise. For repeated fields,
+                // this method only compares the value in the specified index. This method
+                // uses Compare functions to recurse into submessages.
+                // The parent_fields vector is used in calls to a Reporter instance calls.
+                // It can be NULL, in which case the MessageDifferencer will create new
+                // list of parent messages if it needs to recursively compare the given field.
+                // To avoid confusing users you should not set it to NULL unless you modified
+                // Reporter to handle the change of parent_fields correctly.
+                bool CompareFieldValueUsingParentFields(
+                    const Message& message1, const Message& message2, const FieldDescriptor* field, int index1, int index2, std::vector<SpecificField>* parent_fields
+                );
+
+                // Compares the specified field on the two messages, returning comparison
+                // result, as returned by appropriate FieldComparator.
+                FieldComparator::ComparisonResult GetFieldComparisonResult(
+                    const Message& message1, const Message& message2, const FieldDescriptor* field, int index1, int index2, const FieldContext* field_context
+                );
+
+                // Check if the two elements in the repeated field are match to each other.
+                // if the key_comprator is NULL, this function returns true when the two
+                // elements are equal.
+                bool IsMatch(const FieldDescriptor* repeated_field, const MapKeyComparator* key_comparator, const Message* message1, const Message* message2, const std::vector<SpecificField>& parent_fields, Reporter* reporter, int index1, int index2);
+
+                // Returns true when this repeated field has been configured to be treated
+                // as a Set / SmartSet / SmartList.
+                bool IsTreatedAsSet(const FieldDescriptor* field);
+                bool IsTreatedAsSmartSet(const FieldDescriptor* field);
+
+                bool IsTreatedAsSmartList(const FieldDescriptor* field);
+                // When treating as SMART_LIST, it uses MatchIndicesPostProcessorForSmartList
+                // by default to find the longest matching sequence from the first matching
+                // element. The callback takes two vectors showing the matching indices from
+                // the other vector, where -1 means an unmatch.
+                void SetMatchIndicesForSmartListCallback(
+                    std::function<void(std::vector<int>*, std::vector<int>*)> callback
+                );
+
+                // Returns true when this repeated field is to be compared as a subset, ie.
+                // has been configured to be treated as a set or map and scope is set to
+                // PARTIAL.
+                bool IsTreatedAsSubset(const FieldDescriptor* field);
+
+                // Returns true if this field is to be ignored when this
+                // MessageDifferencer compares messages.
+                bool IsIgnored(const Message& message1, const Message& message2, const FieldDescriptor* field, const std::vector<SpecificField>& parent_fields);
+
+                // Returns true if this unknown field is to be ignored when this
+                // MessageDifferencer compares messages.
+                bool IsUnknownFieldIgnored(const Message& message1, const Message& message2, const SpecificField& field, const std::vector<SpecificField>& parent_fields);
+
+                // Returns MapKeyComparator* when this field has been configured to be treated
+                // as a map or its is_map() return true.  If not, returns NULL.
+                const MapKeyComparator* GetMapKeyComparator(
+                    const FieldDescriptor* field
+                ) const;
+
+                // Attempts to match indices of a repeated field, so that the contained values
+                // match. Clears output vectors and sets their values to indices of paired
+                // messages, ie. if message1[0] matches message2[1], then match_list1[0] == 1
+                // and match_list2[1] == 0. The unmatched indices are indicated by -1.
+                // Assumes the repeated field is not treated as a simple list.
+                // This method returns false if the match failed. However, it doesn't mean
+                // that the comparison succeeds when this method returns true (you need to
+                // double-check in this case).
+                bool MatchRepeatedFieldIndices(
+                    const Message& message1, const Message& message2, const FieldDescriptor* repeated_field, const MapKeyComparator* key_comparator, const std::vector<SpecificField>& parent_fields, std::vector<int>* match_list1, std::vector<int>* match_list2
+                );
+
+                // Checks if index is equal to new_index in all the specific fields.
+                static bool CheckPathChanged(const std::vector<SpecificField>& parent_fields);
+
+                // CHECKs that the given repeated field can be compared according to
+                // new_comparison.
+                void CheckRepeatedFieldComparisons(
+                    const FieldDescriptor* field,
+                    const RepeatedFieldComparison& new_comparison
+                );
+
+                // Defines a map between field descriptors and their MapKeyComparators.
+                // Used for repeated fields when they are configured as TreatAsMap.
+                typedef std::map<const FieldDescriptor*, const MapKeyComparator*>
+                    FieldKeyComparatorMap;
+
+                // Defines a set to store field descriptors.  Used for repeated fields when
+                // they are configured as TreatAsSet.
+                typedef std::set<const FieldDescriptor*> FieldSet;
+                typedef std::map<const FieldDescriptor*, RepeatedFieldComparison> FieldMap;
+
+                Reporter* reporter_;
+                DefaultFieldComparator default_field_comparator_;
+                MessageFieldComparison message_field_comparison_;
+                Scope scope_;
+                RepeatedFieldComparison repeated_field_comparison_;
+
+                FieldMap repeated_field_comparisons_;
+                // Keeps track of MapKeyComparators that are created within
+                // MessageDifferencer. These MapKeyComparators should be deleted
+                // before MessageDifferencer is destroyed.
+                // When TreatAsMap or TreatAsMapWithMultipleFieldsAsKey is called, we don't
+                // store the supplied FieldDescriptors directly. Instead, a new
+                // MapKeyComparator is created for comparison purpose.
+                std::vector<MapKeyComparator*> owned_key_comparators_;
+                FieldKeyComparatorMap map_field_key_comparator_;
+                MapEntryKeyComparator map_entry_key_comparator_;
+                std::vector<IgnoreCriteria*> ignore_criteria_;
+                // Reused multiple times in RetrieveFields to avoid extra allocations
+                std::vector<const FieldDescriptor*> tmp_message_fields_;
+
+                FieldSet ignored_fields_;
+
+                union
+                {
+                    DefaultFieldComparator* default_impl;
+                    FieldComparator* base;
+                } field_comparator_ = {&default_field_comparator_};
+                enum
+                {
+                    kFCDefault,
+                    kFCBase
+                } field_comparator_kind_ = kFCDefault;
+
+                bool report_matches_;
+                bool report_moves_;
+                bool report_ignores_;
+
+                std::string* output_string_;
+
+                // Callback to post-process the matched indices to support SMART_LIST.
+                std::function<void(std::vector<int>*, std::vector<int>*)>
+                    match_indices_for_smart_list_callback_;
+
+                MessageDifferencer::UnpackAnyField unpack_any_field_;
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageDifferencer);
+            };
+
+            // This class provides extra information to the FieldComparator::Compare
+            // function.
+            class PROTOBUF_EXPORT FieldContext
+            {
+            public:
+                explicit FieldContext(
+                    std::vector<MessageDifferencer::SpecificField>* parent_fields
+                ) :
+                    parent_fields_(parent_fields)
+                {
+                }
+
+                std::vector<MessageDifferencer::SpecificField>* parent_fields() const
+                {
+                    return parent_fields_;
+                }
+
+            private:
+                std::vector<MessageDifferencer::SpecificField>* parent_fields_;
+            };
+
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/time_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/time_util.h
index 709527e..0d4b993 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/util/time_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/time_util.h
@@ -39,9 +39,10 @@
 #include <string>
 #ifdef _MSC_VER
 #ifdef _XBOX_ONE
-struct timeval {
-  int64_t tv_sec;  /* seconds */
-  int64_t tv_usec; /* and microseconds */
+struct timeval
+{
+    int64_t tv_sec;  /* seconds */
+    int64_t tv_usec; /* and microseconds */
 };
 #else
 #include <winsock2.h>
@@ -56,257 +57,291 @@ struct timeval {
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace util {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace util
+        {
 
-// Utility functions for Timestamp and Duration.
-class PROTOBUF_EXPORT TimeUtil {
-  typedef google::protobuf::Timestamp Timestamp;
-  typedef google::protobuf::Duration Duration;
+            // Utility functions for Timestamp and Duration.
+            class PROTOBUF_EXPORT TimeUtil
+            {
+                typedef google::protobuf::Timestamp Timestamp;
+                typedef google::protobuf::Duration Duration;
 
- public:
-  // The min/max Timestamp/Duration values we support.
-  //
-  // For "0001-01-01T00:00:00Z".
-  static const int64_t kTimestampMinSeconds = -62135596800LL;
-  // For "9999-12-31T23:59:59.999999999Z".
-  static const int64_t kTimestampMaxSeconds = 253402300799LL;
-  static const int64_t kDurationMinSeconds = -315576000000LL;
-  static const int64_t kDurationMaxSeconds = 315576000000LL;
+            public:
+                // The min/max Timestamp/Duration values we support.
+                //
+                // For "0001-01-01T00:00:00Z".
+                static const int64_t kTimestampMinSeconds = -62135596800LL;
+                // For "9999-12-31T23:59:59.999999999Z".
+                static const int64_t kTimestampMaxSeconds = 253402300799LL;
+                static const int64_t kDurationMinSeconds = -315576000000LL;
+                static const int64_t kDurationMaxSeconds = 315576000000LL;
 
-  // Converts Timestamp to/from RFC 3339 date string format.
-  // Generated output will always be Z-normalized and uses 3, 6 or 9
-  // fractional digits as required to represent the exact time. When
-  // parsing, any fractional digits (or none) and any offset are
-  // accepted as long as they fit into nano-seconds precision.
-  // Note that Timestamp can only represent time from
-  // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. Converting
-  // a Timestamp outside of this range is undefined behavior.
-  // See https://www.ietf.org/rfc/rfc3339.txt
-  //
-  // Example of generated format:
-  //   "1972-01-01T10:00:20.021Z"
-  //
-  // Example of accepted format:
-  //   "1972-01-01T10:00:20.021-05:00"
-  static std::string ToString(const Timestamp& timestamp);
-  static bool FromString(const std::string& value, Timestamp* timestamp);
+                // Converts Timestamp to/from RFC 3339 date string format.
+                // Generated output will always be Z-normalized and uses 3, 6 or 9
+                // fractional digits as required to represent the exact time. When
+                // parsing, any fractional digits (or none) and any offset are
+                // accepted as long as they fit into nano-seconds precision.
+                // Note that Timestamp can only represent time from
+                // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. Converting
+                // a Timestamp outside of this range is undefined behavior.
+                // See https://www.ietf.org/rfc/rfc3339.txt
+                //
+                // Example of generated format:
+                //   "1972-01-01T10:00:20.021Z"
+                //
+                // Example of accepted format:
+                //   "1972-01-01T10:00:20.021-05:00"
+                static std::string ToString(const Timestamp& timestamp);
+                static bool FromString(const std::string& value, Timestamp* timestamp);
 
-  // Converts Duration to/from string format. The string format will contains
-  // 3, 6, or 9 fractional digits depending on the precision required to
-  // represent the exact Duration value. For example:
-  //   "1s", "1.010s", "1.000000100s", "-3.100s"
-  // The range that can be represented by Duration is from -315,576,000,000
-  // to +315,576,000,000 inclusive (in seconds).
-  static std::string ToString(const Duration& duration);
-  static bool FromString(const std::string& value, Duration* timestamp);
+                // Converts Duration to/from string format. The string format will contains
+                // 3, 6, or 9 fractional digits depending on the precision required to
+                // represent the exact Duration value. For example:
+                //   "1s", "1.010s", "1.000000100s", "-3.100s"
+                // The range that can be represented by Duration is from -315,576,000,000
+                // to +315,576,000,000 inclusive (in seconds).
+                static std::string ToString(const Duration& duration);
+                static bool FromString(const std::string& value, Duration* timestamp);
 
 #ifdef GetCurrentTime
 #undef GetCurrentTime  // Visual Studio has macro GetCurrentTime
 #endif
-  // Gets the current UTC time.
-  static Timestamp GetCurrentTime();
-  // Returns the Time representing "1970-01-01 00:00:00".
-  static Timestamp GetEpoch();
+                // Gets the current UTC time.
+                static Timestamp GetCurrentTime();
+                // Returns the Time representing "1970-01-01 00:00:00".
+                static Timestamp GetEpoch();
 
-  // Converts between Duration and integer types. The behavior is undefined if
-  // the input value is not in the valid range of Duration.
-  static Duration NanosecondsToDuration(int64_t nanos);
-  static Duration MicrosecondsToDuration(int64_t micros);
-  static Duration MillisecondsToDuration(int64_t millis);
-  static Duration SecondsToDuration(int64_t seconds);
-  static Duration MinutesToDuration(int64_t minutes);
-  static Duration HoursToDuration(int64_t hours);
-  // Result will be truncated towards zero. For example, "-1.5s" will be
-  // truncated to "-1s", and "1.5s" to "1s" when converting to seconds.
-  // It's undefined behavior if the input duration is not valid or the result
-  // exceeds the range of int64. A duration is not valid if it's not in the
-  // valid range of Duration, or have an invalid nanos value (i.e., larger
-  // than 999999999, less than -999999999, or have a different sign from the
-  // seconds part).
-  static int64_t DurationToNanoseconds(const Duration& duration);
-  static int64_t DurationToMicroseconds(const Duration& duration);
-  static int64_t DurationToMilliseconds(const Duration& duration);
-  static int64_t DurationToSeconds(const Duration& duration);
-  static int64_t DurationToMinutes(const Duration& duration);
-  static int64_t DurationToHours(const Duration& duration);
-  // Creates Timestamp from integer types. The integer value indicates the
-  // time elapsed from Epoch time. The behavior is undefined if the input
-  // value is not in the valid range of Timestamp.
-  static Timestamp NanosecondsToTimestamp(int64_t nanos);
-  static Timestamp MicrosecondsToTimestamp(int64_t micros);
-  static Timestamp MillisecondsToTimestamp(int64_t millis);
-  static Timestamp SecondsToTimestamp(int64_t seconds);
-  // Result will be truncated down to the nearest integer value. For example,
-  // with "1969-12-31T23:59:59.9Z", TimestampToMilliseconds() returns -100
-  // and TimestampToSeconds() returns -1. It's undefined behavior if the input
-  // Timestamp is not valid (i.e., its seconds part or nanos part does not fall
-  // in the valid range) or the return value doesn't fit into int64.
-  static int64_t TimestampToNanoseconds(const Timestamp& timestamp);
-  static int64_t TimestampToMicroseconds(const Timestamp& timestamp);
-  static int64_t TimestampToMilliseconds(const Timestamp& timestamp);
-  static int64_t TimestampToSeconds(const Timestamp& timestamp);
+                // Converts between Duration and integer types. The behavior is undefined if
+                // the input value is not in the valid range of Duration.
+                static Duration NanosecondsToDuration(int64_t nanos);
+                static Duration MicrosecondsToDuration(int64_t micros);
+                static Duration MillisecondsToDuration(int64_t millis);
+                static Duration SecondsToDuration(int64_t seconds);
+                static Duration MinutesToDuration(int64_t minutes);
+                static Duration HoursToDuration(int64_t hours);
+                // Result will be truncated towards zero. For example, "-1.5s" will be
+                // truncated to "-1s", and "1.5s" to "1s" when converting to seconds.
+                // It's undefined behavior if the input duration is not valid or the result
+                // exceeds the range of int64. A duration is not valid if it's not in the
+                // valid range of Duration, or have an invalid nanos value (i.e., larger
+                // than 999999999, less than -999999999, or have a different sign from the
+                // seconds part).
+                static int64_t DurationToNanoseconds(const Duration& duration);
+                static int64_t DurationToMicroseconds(const Duration& duration);
+                static int64_t DurationToMilliseconds(const Duration& duration);
+                static int64_t DurationToSeconds(const Duration& duration);
+                static int64_t DurationToMinutes(const Duration& duration);
+                static int64_t DurationToHours(const Duration& duration);
+                // Creates Timestamp from integer types. The integer value indicates the
+                // time elapsed from Epoch time. The behavior is undefined if the input
+                // value is not in the valid range of Timestamp.
+                static Timestamp NanosecondsToTimestamp(int64_t nanos);
+                static Timestamp MicrosecondsToTimestamp(int64_t micros);
+                static Timestamp MillisecondsToTimestamp(int64_t millis);
+                static Timestamp SecondsToTimestamp(int64_t seconds);
+                // Result will be truncated down to the nearest integer value. For example,
+                // with "1969-12-31T23:59:59.9Z", TimestampToMilliseconds() returns -100
+                // and TimestampToSeconds() returns -1. It's undefined behavior if the input
+                // Timestamp is not valid (i.e., its seconds part or nanos part does not fall
+                // in the valid range) or the return value doesn't fit into int64.
+                static int64_t TimestampToNanoseconds(const Timestamp& timestamp);
+                static int64_t TimestampToMicroseconds(const Timestamp& timestamp);
+                static int64_t TimestampToMilliseconds(const Timestamp& timestamp);
+                static int64_t TimestampToSeconds(const Timestamp& timestamp);
 
-  // Conversion to/from other time/date types. Note that these types may
-  // have a different precision and time range from Timestamp/Duration.
-  // When converting to a lower precision type, the value will be truncated
-  // to the nearest value that can be represented. If the value is
-  // out of the range of the result type, the return value is undefined.
-  //
-  // Conversion to/from time_t
-  static Timestamp TimeTToTimestamp(time_t value);
-  static time_t TimestampToTimeT(const Timestamp& value);
+                // Conversion to/from other time/date types. Note that these types may
+                // have a different precision and time range from Timestamp/Duration.
+                // When converting to a lower precision type, the value will be truncated
+                // to the nearest value that can be represented. If the value is
+                // out of the range of the result type, the return value is undefined.
+                //
+                // Conversion to/from time_t
+                static Timestamp TimeTToTimestamp(time_t value);
+                static time_t TimestampToTimeT(const Timestamp& value);
 
-  // Conversion to/from timeval
-  static Timestamp TimevalToTimestamp(const timeval& value);
-  static timeval TimestampToTimeval(const Timestamp& value);
-  static Duration TimevalToDuration(const timeval& value);
-  static timeval DurationToTimeval(const Duration& value);
-};
+                // Conversion to/from timeval
+                static Timestamp TimevalToTimestamp(const timeval& value);
+                static timeval TimestampToTimeval(const Timestamp& value);
+                static Duration TimevalToDuration(const timeval& value);
+                static timeval DurationToTimeval(const Duration& value);
+            };
 
-}  // namespace util
-}  // namespace protobuf
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
-namespace google {
-namespace protobuf {
-// Overloaded operators for Duration.
-//
-// Assignment operators.
-PROTOBUF_EXPORT Duration& operator+=(Duration& d1,
-                                     const Duration& d2);  // NOLINT
-PROTOBUF_EXPORT Duration& operator-=(Duration& d1,
-                                     const Duration& d2);     // NOLINT
-PROTOBUF_EXPORT Duration& operator*=(Duration& d, int64_t r);  // NOLINT
-PROTOBUF_EXPORT Duration& operator*=(Duration& d, double r);  // NOLINT
-PROTOBUF_EXPORT Duration& operator/=(Duration& d, int64_t r);  // NOLINT
-PROTOBUF_EXPORT Duration& operator/=(Duration& d, double r);  // NOLINT
-// Overload for other integer types.
-template <typename T>
-Duration& operator*=(Duration& d, T r) {  // NOLINT
-  int64_t x = r;
-  return d *= x;
-}
-template <typename T>
-Duration& operator/=(Duration& d, T r) {  // NOLINT
-  int64_t x = r;
-  return d /= x;
-}
-PROTOBUF_EXPORT Duration& operator%=(Duration& d1,
-                                     const Duration& d2);  // NOLINT
-// Relational operators.
-inline bool operator<(const Duration& d1, const Duration& d2) {
-  if (d1.seconds() == d2.seconds()) {
-    return d1.nanos() < d2.nanos();
-  }
-  return d1.seconds() < d2.seconds();
-}
-inline bool operator>(const Duration& d1, const Duration& d2) {
-  return d2 < d1;
-}
-inline bool operator>=(const Duration& d1, const Duration& d2) {
-  return !(d1 < d2);
-}
-inline bool operator<=(const Duration& d1, const Duration& d2) {
-  return !(d2 < d1);
-}
-inline bool operator==(const Duration& d1, const Duration& d2) {
-  return d1.seconds() == d2.seconds() && d1.nanos() == d2.nanos();
-}
-inline bool operator!=(const Duration& d1, const Duration& d2) {
-  return !(d1 == d2);
-}
-// Additive operators
-inline Duration operator-(const Duration& d) {
-  Duration result;
-  result.set_seconds(-d.seconds());
-  result.set_nanos(-d.nanos());
-  return result;
-}
-inline Duration operator+(const Duration& d1, const Duration& d2) {
-  Duration result = d1;
-  return result += d2;
-}
-inline Duration operator-(const Duration& d1, const Duration& d2) {
-  Duration result = d1;
-  return result -= d2;
-}
-// Multiplicative operators
-template <typename T>
-inline Duration operator*(Duration d, T r) {
-  return d *= r;
-}
-template <typename T>
-inline Duration operator*(T r, Duration d) {
-  return d *= r;
-}
-template <typename T>
-inline Duration operator/(Duration d, T r) {
-  return d /= r;
-}
-PROTOBUF_EXPORT int64_t operator/(const Duration& d1, const Duration& d2);
+namespace google
+{
+    namespace protobuf
+    {
+        // Overloaded operators for Duration.
+        //
+        // Assignment operators.
+        PROTOBUF_EXPORT Duration& operator+=(Duration& d1,
+                                             const Duration& d2);  // NOLINT
+        PROTOBUF_EXPORT Duration& operator-=(Duration& d1,
+                                             const Duration& d2);      // NOLINT
+        PROTOBUF_EXPORT Duration& operator*=(Duration& d, int64_t r);  // NOLINT
+        PROTOBUF_EXPORT Duration& operator*=(Duration& d, double r);   // NOLINT
+        PROTOBUF_EXPORT Duration& operator/=(Duration& d, int64_t r);  // NOLINT
+        PROTOBUF_EXPORT Duration& operator/=(Duration& d, double r);   // NOLINT
+        // Overload for other integer types.
+        template<typename T>
+        Duration& operator*=(Duration& d, T r)
+        {  // NOLINT
+            int64_t x = r;
+            return d *= x;
+        }
+        template<typename T>
+        Duration& operator/=(Duration& d, T r)
+        {  // NOLINT
+            int64_t x = r;
+            return d /= x;
+        }
+        PROTOBUF_EXPORT Duration& operator%=(Duration& d1,
+                                             const Duration& d2);  // NOLINT
+        // Relational operators.
+        inline bool operator<(const Duration& d1, const Duration& d2)
+        {
+            if (d1.seconds() == d2.seconds())
+            {
+                return d1.nanos() < d2.nanos();
+            }
+            return d1.seconds() < d2.seconds();
+        }
+        inline bool operator>(const Duration& d1, const Duration& d2)
+        {
+            return d2 < d1;
+        }
+        inline bool operator>=(const Duration& d1, const Duration& d2)
+        {
+            return !(d1 < d2);
+        }
+        inline bool operator<=(const Duration& d1, const Duration& d2)
+        {
+            return !(d2 < d1);
+        }
+        inline bool operator==(const Duration& d1, const Duration& d2)
+        {
+            return d1.seconds() == d2.seconds() && d1.nanos() == d2.nanos();
+        }
+        inline bool operator!=(const Duration& d1, const Duration& d2)
+        {
+            return !(d1 == d2);
+        }
+        // Additive operators
+        inline Duration operator-(const Duration& d)
+        {
+            Duration result;
+            result.set_seconds(-d.seconds());
+            result.set_nanos(-d.nanos());
+            return result;
+        }
+        inline Duration operator+(const Duration& d1, const Duration& d2)
+        {
+            Duration result = d1;
+            return result += d2;
+        }
+        inline Duration operator-(const Duration& d1, const Duration& d2)
+        {
+            Duration result = d1;
+            return result -= d2;
+        }
+        // Multiplicative operators
+        template<typename T>
+        inline Duration operator*(Duration d, T r)
+        {
+            return d *= r;
+        }
+        template<typename T>
+        inline Duration operator*(T r, Duration d)
+        {
+            return d *= r;
+        }
+        template<typename T>
+        inline Duration operator/(Duration d, T r)
+        {
+            return d /= r;
+        }
+        PROTOBUF_EXPORT int64_t operator/(const Duration& d1, const Duration& d2);
 
-inline Duration operator%(const Duration& d1, const Duration& d2) {
-  Duration result = d1;
-  return result %= d2;
-}
+        inline Duration operator%(const Duration& d1, const Duration& d2)
+        {
+            Duration result = d1;
+            return result %= d2;
+        }
 
-inline std::ostream& operator<<(std::ostream& out, const Duration& d) {
-  out << ::PROTOBUF_NAMESPACE_ID::util::TimeUtil::ToString(d);
-  return out;
-}
+        inline std::ostream& operator<<(std::ostream& out, const Duration& d)
+        {
+            out << ::PROTOBUF_NAMESPACE_ID::util::TimeUtil::ToString(d);
+            return out;
+        }
 
-// Overloaded operators for Timestamp
-//
-// Assignment operators.
-PROTOBUF_EXPORT Timestamp& operator+=(Timestamp& t,
-                                      const Duration& d);  // NOLINT
-PROTOBUF_EXPORT Timestamp& operator-=(Timestamp& t,
-                                      const Duration& d);  // NOLINT
-// Relational operators.
-inline bool operator<(const Timestamp& t1, const Timestamp& t2) {
-  if (t1.seconds() == t2.seconds()) {
-    return t1.nanos() < t2.nanos();
-  }
-  return t1.seconds() < t2.seconds();
-}
-inline bool operator>(const Timestamp& t1, const Timestamp& t2) {
-  return t2 < t1;
-}
-inline bool operator>=(const Timestamp& t1, const Timestamp& t2) {
-  return !(t1 < t2);
-}
-inline bool operator<=(const Timestamp& t1, const Timestamp& t2) {
-  return !(t2 < t1);
-}
-inline bool operator==(const Timestamp& t1, const Timestamp& t2) {
-  return t1.seconds() == t2.seconds() && t1.nanos() == t2.nanos();
-}
-inline bool operator!=(const Timestamp& t1, const Timestamp& t2) {
-  return !(t1 == t2);
-}
-// Additive operators.
-inline Timestamp operator+(const Timestamp& t, const Duration& d) {
-  Timestamp result = t;
-  return result += d;
-}
-inline Timestamp operator+(const Duration& d, const Timestamp& t) {
-  Timestamp result = t;
-  return result += d;
-}
-inline Timestamp operator-(const Timestamp& t, const Duration& d) {
-  Timestamp result = t;
-  return result -= d;
-}
-PROTOBUF_EXPORT Duration operator-(const Timestamp& t1, const Timestamp& t2);
+        // Overloaded operators for Timestamp
+        //
+        // Assignment operators.
+        PROTOBUF_EXPORT Timestamp& operator+=(Timestamp& t,
+                                              const Duration& d);  // NOLINT
+        PROTOBUF_EXPORT Timestamp& operator-=(Timestamp& t,
+                                              const Duration& d);  // NOLINT
+        // Relational operators.
+        inline bool operator<(const Timestamp& t1, const Timestamp& t2)
+        {
+            if (t1.seconds() == t2.seconds())
+            {
+                return t1.nanos() < t2.nanos();
+            }
+            return t1.seconds() < t2.seconds();
+        }
+        inline bool operator>(const Timestamp& t1, const Timestamp& t2)
+        {
+            return t2 < t1;
+        }
+        inline bool operator>=(const Timestamp& t1, const Timestamp& t2)
+        {
+            return !(t1 < t2);
+        }
+        inline bool operator<=(const Timestamp& t1, const Timestamp& t2)
+        {
+            return !(t2 < t1);
+        }
+        inline bool operator==(const Timestamp& t1, const Timestamp& t2)
+        {
+            return t1.seconds() == t2.seconds() && t1.nanos() == t2.nanos();
+        }
+        inline bool operator!=(const Timestamp& t1, const Timestamp& t2)
+        {
+            return !(t1 == t2);
+        }
+        // Additive operators.
+        inline Timestamp operator+(const Timestamp& t, const Duration& d)
+        {
+            Timestamp result = t;
+            return result += d;
+        }
+        inline Timestamp operator+(const Duration& d, const Timestamp& t)
+        {
+            Timestamp result = t;
+            return result += d;
+        }
+        inline Timestamp operator-(const Timestamp& t, const Duration& d)
+        {
+            Timestamp result = t;
+            return result -= d;
+        }
+        PROTOBUF_EXPORT Duration operator-(const Timestamp& t1, const Timestamp& t2);
 
-inline std::ostream& operator<<(std::ostream& out, const Timestamp& t) {
-  out << ::PROTOBUF_NAMESPACE_ID::util::TimeUtil::ToString(t);
-  return out;
-}
+        inline std::ostream& operator<<(std::ostream& out, const Timestamp& t)
+        {
+            out << ::PROTOBUF_NAMESPACE_ID::util::TimeUtil::ToString(t);
+            return out;
+        }
 
-}  // namespace protobuf
+    }  // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver.h b/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver.h
index b2e7b43..d9fe037 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver.h
@@ -43,33 +43,41 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-class DescriptorPool;
-namespace util {
+namespace google
+{
+    namespace protobuf
+    {
+        class DescriptorPool;
+        namespace util
+        {
 
-// Abstract interface for a type resolver.
-//
-// Implementations of this interface must be thread-safe.
-class PROTOBUF_EXPORT TypeResolver {
- public:
-  TypeResolver() {}
-  virtual ~TypeResolver() {}
+            // Abstract interface for a type resolver.
+            //
+            // Implementations of this interface must be thread-safe.
+            class PROTOBUF_EXPORT TypeResolver
+            {
+            public:
+                TypeResolver()
+                {
+                }
+                virtual ~TypeResolver()
+                {
+                }
 
-  // Resolves a type url for a message type.
-  virtual util::Status ResolveMessageType(
-      const std::string& type_url, google::protobuf::Type* message_type) = 0;
+                // Resolves a type url for a message type.
+                virtual util::Status ResolveMessageType(
+                    const std::string& type_url, google::protobuf::Type* message_type
+                ) = 0;
 
-  // Resolves a type url for an enum type.
-  virtual util::Status ResolveEnumType(const std::string& type_url,
-                                       google::protobuf::Enum* enum_type) = 0;
+                // Resolves a type url for an enum type.
+                virtual util::Status ResolveEnumType(const std::string& type_url, google::protobuf::Enum* enum_type) = 0;
 
- private:
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeResolver);
-};
+            private:
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeResolver);
+            };
 
-}  // namespace util
-}  // namespace protobuf
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver_util.h b/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver_util.h
index 7f6a4b9..001c747 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver_util.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/util/type_resolver_util.h
@@ -35,22 +35,26 @@
 
 #include <string>
 
-namespace google {
-namespace protobuf {
-class DescriptorPool;
-namespace util {
-class TypeResolver;
+namespace google
+{
+    namespace protobuf
+    {
+        class DescriptorPool;
+        namespace util
+        {
+            class TypeResolver;
 
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-// Creates a TypeResolver that serves type information in the given descriptor
-// pool. Caller takes ownership of the returned TypeResolver.
-PROTOBUF_EXPORT TypeResolver* NewTypeResolverForDescriptorPool(
-    const std::string& url_prefix, const DescriptorPool* pool);
+            // Creates a TypeResolver that serves type information in the given descriptor
+            // pool. Caller takes ownership of the returned TypeResolver.
+            PROTOBUF_EXPORT TypeResolver* NewTypeResolverForDescriptorPool(
+                const std::string& url_prefix, const DescriptorPool* pool
+            );
 
-}  // namespace util
-}  // namespace protobuf
+        }  // namespace util
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/wire_format.h b/CAPI/cpp/grpc/include/google/protobuf/wire_format.h
index 1acbf9e..65f1303 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/wire_format.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/wire_format.h
@@ -39,7 +39,6 @@
 #ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_H__
 #define GOOGLE_PROTOBUF_WIRE_FORMAT_H__
 
-
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/stubs/casts.h>
@@ -57,356 +56,377 @@
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-class MapKey;           // map_field.h
-class UnknownFieldSet;  // unknown_field_set.h
-}  // namespace protobuf
+namespace google
+{
+    namespace protobuf
+    {
+        class MapKey;           // map_field.h
+        class UnknownFieldSet;  // unknown_field_set.h
+    }                           // namespace protobuf
 }  // namespace google
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// This class is for internal use by the protocol buffer library and by
-// protocol-compiler-generated message classes.  It must not be called
-// directly by clients.
-//
-// This class contains code for implementing the binary protocol buffer
-// wire format via reflection.  The WireFormatLite class implements the
-// non-reflection based routines.
-//
-// This class is really a namespace that contains only static methods
-class PROTOBUF_EXPORT WireFormat {
- public:
-  // Given a field return its WireType
-  static inline WireFormatLite::WireType WireTypeForField(
-      const FieldDescriptor* field);
-
-  // Given a FieldDescriptor::Type return its WireType
-  static inline WireFormatLite::WireType WireTypeForFieldType(
-      FieldDescriptor::Type type);
-
-  // Compute the byte size of a tag.  For groups, this includes both the start
-  // and end tags.
-  static inline size_t TagSize(int field_number, FieldDescriptor::Type type);
-
-  // These procedures can be used to implement the methods of Message which
-  // handle parsing and serialization of the protocol buffer wire format
-  // using only the Reflection interface.  When you ask the protocol
-  // compiler to optimize for code size rather than speed, it will implement
-  // those methods in terms of these procedures.  Of course, these are much
-  // slower than the specialized implementations which the protocol compiler
-  // generates when told to optimize for speed.
-
-  // Read a message in protocol buffer wire format.
-  //
-  // This procedure reads either to the end of the input stream or through
-  // a WIRETYPE_END_GROUP tag ending the message, whichever comes first.
-  // It returns false if the input is invalid.
-  //
-  // Required fields are NOT checked by this method.  You must call
-  // IsInitialized() on the resulting message yourself.
-  static bool ParseAndMergePartial(io::CodedInputStream* input,
-                                   Message* message);
-
-  // This is meant for internal protobuf use (WireFormat is an internal class).
-  // This is the reflective implementation of the _InternalParse functionality.
-  static const char* _InternalParse(Message* msg, const char* ptr,
-                                    internal::ParseContext* ctx);
-
-  // Serialize a message in protocol buffer wire format.
-  //
-  // Any embedded messages within the message must have their correct sizes
-  // cached.  However, the top-level message need not; its size is passed as
-  // a parameter to this procedure.
-  //
-  // These return false iff the underlying stream returns a write error.
-  static void SerializeWithCachedSizes(const Message& message, int size,
-                                       io::CodedOutputStream* output) {
-    int expected_endpoint = output->ByteCount() + size;
-    output->SetCur(
-        _InternalSerialize(message, output->Cur(), output->EpsCopy()));
-    GOOGLE_CHECK_EQ(output->ByteCount(), expected_endpoint)
-        << ": Protocol message serialized to a size different from what was "
-           "originally expected.  Perhaps it was modified by another thread "
-           "during serialization?";
-  }
-  static uint8_t* _InternalSerialize(const Message& message, uint8_t* target,
-                                     io::EpsCopyOutputStream* stream);
-
-  // Implements Message::ByteSize() via reflection.  WARNING:  The result
-  // of this method is *not* cached anywhere.  However, all embedded messages
-  // will have their ByteSize() methods called, so their sizes will be cached.
-  // Therefore, calling this method is sufficient to allow you to call
-  // WireFormat::SerializeWithCachedSizes() on the same object.
-  static size_t ByteSize(const Message& message);
-
-  // -----------------------------------------------------------------
-  // Helpers for dealing with unknown fields
-
-  // Skips a field value of the given WireType.  The input should start
-  // positioned immediately after the tag.  If unknown_fields is non-nullptr,
-  // the contents of the field will be added to it.
-  static bool SkipField(io::CodedInputStream* input, uint32_t tag,
-                        UnknownFieldSet* unknown_fields);
-
-  // Reads and ignores a message from the input.  If unknown_fields is
-  // non-nullptr, the contents will be added to it.
-  static bool SkipMessage(io::CodedInputStream* input,
-                          UnknownFieldSet* unknown_fields);
-
-  // Read a packed enum field. If the is_valid function is not nullptr, values
-  // for which is_valid(value) returns false are appended to
-  // unknown_fields_stream.
-  static bool ReadPackedEnumPreserveUnknowns(io::CodedInputStream* input,
-                                             uint32_t field_number,
-                                             bool (*is_valid)(int),
-                                             UnknownFieldSet* unknown_fields,
-                                             RepeatedField<int>* values);
-
-  // Write the contents of an UnknownFieldSet to the output.
-  static void SerializeUnknownFields(const UnknownFieldSet& unknown_fields,
-                                     io::CodedOutputStream* output) {
-    output->SetCur(InternalSerializeUnknownFieldsToArray(
-        unknown_fields, output->Cur(), output->EpsCopy()));
-  }
-  // Same as above, except writing directly to the provided buffer.
-  // Requires that the buffer have sufficient capacity for
-  // ComputeUnknownFieldsSize(unknown_fields).
-  //
-  // Returns a pointer past the last written byte.
-  static uint8_t* SerializeUnknownFieldsToArray(
-      const UnknownFieldSet& unknown_fields, uint8_t* target) {
-    io::EpsCopyOutputStream stream(
-        target, static_cast<int>(ComputeUnknownFieldsSize(unknown_fields)),
-        io::CodedOutputStream::IsDefaultSerializationDeterministic());
-    return InternalSerializeUnknownFieldsToArray(unknown_fields, target,
-                                                 &stream);
-  }
-  static uint8_t* InternalSerializeUnknownFieldsToArray(
-      const UnknownFieldSet& unknown_fields, uint8_t* target,
-      io::EpsCopyOutputStream* stream);
-
-  // Same thing except for messages that have the message_set_wire_format
-  // option.
-  static void SerializeUnknownMessageSetItems(
-      const UnknownFieldSet& unknown_fields, io::CodedOutputStream* output) {
-    output->SetCur(InternalSerializeUnknownMessageSetItemsToArray(
-        unknown_fields, output->Cur(), output->EpsCopy()));
-  }
-  // Same as above, except writing directly to the provided buffer.
-  // Requires that the buffer have sufficient capacity for
-  // ComputeUnknownMessageSetItemsSize(unknown_fields).
-  //
-  // Returns a pointer past the last written byte.
-  static uint8_t* SerializeUnknownMessageSetItemsToArray(
-      const UnknownFieldSet& unknown_fields, uint8_t* target);
-  static uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
-      const UnknownFieldSet& unknown_fields, uint8_t* target,
-      io::EpsCopyOutputStream* stream);
-
-  // Compute the size of the UnknownFieldSet on the wire.
-  static size_t ComputeUnknownFieldsSize(const UnknownFieldSet& unknown_fields);
-
-  // Same thing except for messages that have the message_set_wire_format
-  // option.
-  static size_t ComputeUnknownMessageSetItemsSize(
-      const UnknownFieldSet& unknown_fields);
-
-  // Helper functions for encoding and decoding tags.  (Inlined below and in
-  // _inl.h)
-  //
-  // This is different from MakeTag(field->number(), field->type()) in the
-  // case of packed repeated fields.
-  static uint32_t MakeTag(const FieldDescriptor* field);
-
-  // Parse a single field.  The input should start out positioned immediately
-  // after the tag.
-  static bool ParseAndMergeField(
-      uint32_t tag,
-      const FieldDescriptor* field,  // May be nullptr for unknown
-      Message* message, io::CodedInputStream* input);
-
-  // Serialize a single field.
-  static void SerializeFieldWithCachedSizes(
-      const FieldDescriptor* field,  // Cannot be nullptr
-      const Message& message, io::CodedOutputStream* output) {
-    output->SetCur(InternalSerializeField(field, message, output->Cur(),
-                                          output->EpsCopy()));
-  }
-  static uint8_t* InternalSerializeField(
-      const FieldDescriptor* field,  // Cannot be nullptr
-      const Message& message, uint8_t* target, io::EpsCopyOutputStream* stream);
-
-  // Compute size of a single field.  If the field is a message type, this
-  // will call ByteSize() for the embedded message, insuring that it caches
-  // its size.
-  static size_t FieldByteSize(const FieldDescriptor* field,  // Can't be nullptr
-                              const Message& message);
-
-  // Parse/serialize a MessageSet::Item group.  Used with messages that use
-  // option message_set_wire_format = true.
-  static bool ParseAndMergeMessageSetItem(io::CodedInputStream* input,
-                                          Message* message);
-  static void SerializeMessageSetItemWithCachedSizes(
-      const FieldDescriptor* field, const Message& message,
-      io::CodedOutputStream* output) {
-    output->SetCur(InternalSerializeMessageSetItem(
-        field, message, output->Cur(), output->EpsCopy()));
-  }
-  static uint8_t* InternalSerializeMessageSetItem(
-      const FieldDescriptor* field, const Message& message, uint8_t* target,
-      io::EpsCopyOutputStream* stream);
-  static size_t MessageSetItemByteSize(const FieldDescriptor* field,
-                                       const Message& message);
-
-  // Computes the byte size of a field, excluding tags. For packed fields, it
-  // only includes the size of the raw data, and not the size of the total
-  // length, but for other length-delimited types, the size of the length is
-  // included.
-  static size_t FieldDataOnlyByteSize(
-      const FieldDescriptor* field,  // Cannot be nullptr
-      const Message& message);
-
-  enum Operation {
-    PARSE = 0,
-    SERIALIZE = 1,
-  };
-
-  // Verifies that a string field is valid UTF8, logging an error if not.
-  // This function will not be called by newly generated protobuf code
-  // but remains present to support existing code.
-  static void VerifyUTF8String(const char* data, int size, Operation op);
-  // The NamedField variant takes a field name in order to produce an
-  // informative error message if verification fails.
-  static void VerifyUTF8StringNamedField(const char* data, int size,
-                                         Operation op, const char* field_name);
-
- private:
-  struct MessageSetParser;
-  // Skip a MessageSet field.
-  static bool SkipMessageSetField(io::CodedInputStream* input,
-                                  uint32_t field_number,
-                                  UnknownFieldSet* unknown_fields);
-
-  // Parse a MessageSet field.
-  static bool ParseAndMergeMessageSetField(uint32_t field_number,
-                                           const FieldDescriptor* field,
-                                           Message* message,
-                                           io::CodedInputStream* input);
-  // Parses the value from the wire that belongs to tag.
-  static const char* _InternalParseAndMergeField(Message* msg, const char* ptr,
-                                                 internal::ParseContext* ctx,
-                                                 uint64_t tag,
-                                                 const Reflection* reflection,
-                                                 const FieldDescriptor* field);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormat);
-};
-
-// Subclass of FieldSkipper which saves skipped fields to an UnknownFieldSet.
-class PROTOBUF_EXPORT UnknownFieldSetFieldSkipper : public FieldSkipper {
- public:
-  UnknownFieldSetFieldSkipper(UnknownFieldSet* unknown_fields)
-      : unknown_fields_(unknown_fields) {}
-  ~UnknownFieldSetFieldSkipper() override {}
-
-  // implements FieldSkipper -----------------------------------------
-  bool SkipField(io::CodedInputStream* input, uint32_t tag) override;
-  bool SkipMessage(io::CodedInputStream* input) override;
-  void SkipUnknownEnum(int field_number, int value) override;
-
- protected:
-  UnknownFieldSet* unknown_fields_;
-};
-
-// inline methods ====================================================
-
-inline WireFormatLite::WireType WireFormat::WireTypeForField(
-    const FieldDescriptor* field) {
-  if (field->is_packed()) {
-    return WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
-  } else {
-    return WireTypeForFieldType(field->type());
-  }
-}
-
-inline WireFormatLite::WireType WireFormat::WireTypeForFieldType(
-    FieldDescriptor::Type type) {
-  // Some compilers don't like enum -> enum casts, so we implicit_cast to
-  // int first.
-  return WireFormatLite::WireTypeForFieldType(
-      static_cast<WireFormatLite::FieldType>(implicit_cast<int>(type)));
-}
-
-inline uint32_t WireFormat::MakeTag(const FieldDescriptor* field) {
-  return WireFormatLite::MakeTag(field->number(), WireTypeForField(field));
-}
-
-inline size_t WireFormat::TagSize(int field_number,
-                                  FieldDescriptor::Type type) {
-  // Some compilers don't like enum -> enum casts, so we implicit_cast to
-  // int first.
-  return WireFormatLite::TagSize(
-      field_number,
-      static_cast<WireFormatLite::FieldType>(implicit_cast<int>(type)));
-}
-
-inline void WireFormat::VerifyUTF8String(const char* data, int size,
-                                         WireFormat::Operation op) {
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // This class is for internal use by the protocol buffer library and by
+            // protocol-compiler-generated message classes.  It must not be called
+            // directly by clients.
+            //
+            // This class contains code for implementing the binary protocol buffer
+            // wire format via reflection.  The WireFormatLite class implements the
+            // non-reflection based routines.
+            //
+            // This class is really a namespace that contains only static methods
+            class PROTOBUF_EXPORT WireFormat
+            {
+            public:
+                // Given a field return its WireType
+                static inline WireFormatLite::WireType WireTypeForField(
+                    const FieldDescriptor* field
+                );
+
+                // Given a FieldDescriptor::Type return its WireType
+                static inline WireFormatLite::WireType WireTypeForFieldType(
+                    FieldDescriptor::Type type
+                );
+
+                // Compute the byte size of a tag.  For groups, this includes both the start
+                // and end tags.
+                static inline size_t TagSize(int field_number, FieldDescriptor::Type type);
+
+                // These procedures can be used to implement the methods of Message which
+                // handle parsing and serialization of the protocol buffer wire format
+                // using only the Reflection interface.  When you ask the protocol
+                // compiler to optimize for code size rather than speed, it will implement
+                // those methods in terms of these procedures.  Of course, these are much
+                // slower than the specialized implementations which the protocol compiler
+                // generates when told to optimize for speed.
+
+                // Read a message in protocol buffer wire format.
+                //
+                // This procedure reads either to the end of the input stream or through
+                // a WIRETYPE_END_GROUP tag ending the message, whichever comes first.
+                // It returns false if the input is invalid.
+                //
+                // Required fields are NOT checked by this method.  You must call
+                // IsInitialized() on the resulting message yourself.
+                static bool ParseAndMergePartial(io::CodedInputStream* input, Message* message);
+
+                // This is meant for internal protobuf use (WireFormat is an internal class).
+                // This is the reflective implementation of the _InternalParse functionality.
+                static const char* _InternalParse(Message* msg, const char* ptr, internal::ParseContext* ctx);
+
+                // Serialize a message in protocol buffer wire format.
+                //
+                // Any embedded messages within the message must have their correct sizes
+                // cached.  However, the top-level message need not; its size is passed as
+                // a parameter to this procedure.
+                //
+                // These return false iff the underlying stream returns a write error.
+                static void SerializeWithCachedSizes(const Message& message, int size, io::CodedOutputStream* output)
+                {
+                    int expected_endpoint = output->ByteCount() + size;
+                    output->SetCur(
+                        _InternalSerialize(message, output->Cur(), output->EpsCopy())
+                    );
+                    GOOGLE_CHECK_EQ(output->ByteCount(), expected_endpoint)
+                        << ": Protocol message serialized to a size different from what was "
+                           "originally expected.  Perhaps it was modified by another thread "
+                           "during serialization?";
+                }
+                static uint8_t* _InternalSerialize(const Message& message, uint8_t* target, io::EpsCopyOutputStream* stream);
+
+                // Implements Message::ByteSize() via reflection.  WARNING:  The result
+                // of this method is *not* cached anywhere.  However, all embedded messages
+                // will have their ByteSize() methods called, so their sizes will be cached.
+                // Therefore, calling this method is sufficient to allow you to call
+                // WireFormat::SerializeWithCachedSizes() on the same object.
+                static size_t ByteSize(const Message& message);
+
+                // -----------------------------------------------------------------
+                // Helpers for dealing with unknown fields
+
+                // Skips a field value of the given WireType.  The input should start
+                // positioned immediately after the tag.  If unknown_fields is non-nullptr,
+                // the contents of the field will be added to it.
+                static bool SkipField(io::CodedInputStream* input, uint32_t tag, UnknownFieldSet* unknown_fields);
+
+                // Reads and ignores a message from the input.  If unknown_fields is
+                // non-nullptr, the contents will be added to it.
+                static bool SkipMessage(io::CodedInputStream* input, UnknownFieldSet* unknown_fields);
+
+                // Read a packed enum field. If the is_valid function is not nullptr, values
+                // for which is_valid(value) returns false are appended to
+                // unknown_fields_stream.
+                static bool ReadPackedEnumPreserveUnknowns(io::CodedInputStream* input, uint32_t field_number, bool (*is_valid)(int), UnknownFieldSet* unknown_fields, RepeatedField<int>* values);
+
+                // Write the contents of an UnknownFieldSet to the output.
+                static void SerializeUnknownFields(const UnknownFieldSet& unknown_fields, io::CodedOutputStream* output)
+                {
+                    output->SetCur(InternalSerializeUnknownFieldsToArray(
+                        unknown_fields, output->Cur(), output->EpsCopy()
+                    ));
+                }
+                // Same as above, except writing directly to the provided buffer.
+                // Requires that the buffer have sufficient capacity for
+                // ComputeUnknownFieldsSize(unknown_fields).
+                //
+                // Returns a pointer past the last written byte.
+                static uint8_t* SerializeUnknownFieldsToArray(
+                    const UnknownFieldSet& unknown_fields, uint8_t* target
+                )
+                {
+                    io::EpsCopyOutputStream stream(
+                        target, static_cast<int>(ComputeUnknownFieldsSize(unknown_fields)), io::CodedOutputStream::IsDefaultSerializationDeterministic()
+                    );
+                    return InternalSerializeUnknownFieldsToArray(unknown_fields, target, &stream);
+                }
+                static uint8_t* InternalSerializeUnknownFieldsToArray(
+                    const UnknownFieldSet& unknown_fields, uint8_t* target, io::EpsCopyOutputStream* stream
+                );
+
+                // Same thing except for messages that have the message_set_wire_format
+                // option.
+                static void SerializeUnknownMessageSetItems(
+                    const UnknownFieldSet& unknown_fields, io::CodedOutputStream* output
+                )
+                {
+                    output->SetCur(InternalSerializeUnknownMessageSetItemsToArray(
+                        unknown_fields, output->Cur(), output->EpsCopy()
+                    ));
+                }
+                // Same as above, except writing directly to the provided buffer.
+                // Requires that the buffer have sufficient capacity for
+                // ComputeUnknownMessageSetItemsSize(unknown_fields).
+                //
+                // Returns a pointer past the last written byte.
+                static uint8_t* SerializeUnknownMessageSetItemsToArray(
+                    const UnknownFieldSet& unknown_fields, uint8_t* target
+                );
+                static uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
+                    const UnknownFieldSet& unknown_fields, uint8_t* target, io::EpsCopyOutputStream* stream
+                );
+
+                // Compute the size of the UnknownFieldSet on the wire.
+                static size_t ComputeUnknownFieldsSize(const UnknownFieldSet& unknown_fields);
+
+                // Same thing except for messages that have the message_set_wire_format
+                // option.
+                static size_t ComputeUnknownMessageSetItemsSize(
+                    const UnknownFieldSet& unknown_fields
+                );
+
+                // Helper functions for encoding and decoding tags.  (Inlined below and in
+                // _inl.h)
+                //
+                // This is different from MakeTag(field->number(), field->type()) in the
+                // case of packed repeated fields.
+                static uint32_t MakeTag(const FieldDescriptor* field);
+
+                // Parse a single field.  The input should start out positioned immediately
+                // after the tag.
+                static bool ParseAndMergeField(
+                    uint32_t tag,
+                    const FieldDescriptor* field,  // May be nullptr for unknown
+                    Message* message,
+                    io::CodedInputStream* input
+                );
+
+                // Serialize a single field.
+                static void SerializeFieldWithCachedSizes(
+                    const FieldDescriptor* field,  // Cannot be nullptr
+                    const Message& message,
+                    io::CodedOutputStream* output
+                )
+                {
+                    output->SetCur(InternalSerializeField(field, message, output->Cur(), output->EpsCopy()));
+                }
+                static uint8_t* InternalSerializeField(
+                    const FieldDescriptor* field,  // Cannot be nullptr
+                    const Message& message,
+                    uint8_t* target,
+                    io::EpsCopyOutputStream* stream
+                );
+
+                // Compute size of a single field.  If the field is a message type, this
+                // will call ByteSize() for the embedded message, insuring that it caches
+                // its size.
+                static size_t FieldByteSize(const FieldDescriptor* field,  // Can't be nullptr
+                                            const Message& message);
+
+                // Parse/serialize a MessageSet::Item group.  Used with messages that use
+                // option message_set_wire_format = true.
+                static bool ParseAndMergeMessageSetItem(io::CodedInputStream* input, Message* message);
+                static void SerializeMessageSetItemWithCachedSizes(
+                    const FieldDescriptor* field, const Message& message, io::CodedOutputStream* output
+                )
+                {
+                    output->SetCur(InternalSerializeMessageSetItem(
+                        field, message, output->Cur(), output->EpsCopy()
+                    ));
+                }
+                static uint8_t* InternalSerializeMessageSetItem(
+                    const FieldDescriptor* field, const Message& message, uint8_t* target, io::EpsCopyOutputStream* stream
+                );
+                static size_t MessageSetItemByteSize(const FieldDescriptor* field, const Message& message);
+
+                // Computes the byte size of a field, excluding tags. For packed fields, it
+                // only includes the size of the raw data, and not the size of the total
+                // length, but for other length-delimited types, the size of the length is
+                // included.
+                static size_t FieldDataOnlyByteSize(
+                    const FieldDescriptor* field,  // Cannot be nullptr
+                    const Message& message
+                );
+
+                enum Operation
+                {
+                    PARSE = 0,
+                    SERIALIZE = 1,
+                };
+
+                // Verifies that a string field is valid UTF8, logging an error if not.
+                // This function will not be called by newly generated protobuf code
+                // but remains present to support existing code.
+                static void VerifyUTF8String(const char* data, int size, Operation op);
+                // The NamedField variant takes a field name in order to produce an
+                // informative error message if verification fails.
+                static void VerifyUTF8StringNamedField(const char* data, int size, Operation op, const char* field_name);
+
+            private:
+                struct MessageSetParser;
+                // Skip a MessageSet field.
+                static bool SkipMessageSetField(io::CodedInputStream* input, uint32_t field_number, UnknownFieldSet* unknown_fields);
+
+                // Parse a MessageSet field.
+                static bool ParseAndMergeMessageSetField(uint32_t field_number, const FieldDescriptor* field, Message* message, io::CodedInputStream* input);
+                // Parses the value from the wire that belongs to tag.
+                static const char* _InternalParseAndMergeField(Message* msg, const char* ptr, internal::ParseContext* ctx, uint64_t tag, const Reflection* reflection, const FieldDescriptor* field);
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormat);
+            };
+
+            // Subclass of FieldSkipper which saves skipped fields to an UnknownFieldSet.
+            class PROTOBUF_EXPORT UnknownFieldSetFieldSkipper : public FieldSkipper
+            {
+            public:
+                UnknownFieldSetFieldSkipper(UnknownFieldSet* unknown_fields) :
+                    unknown_fields_(unknown_fields)
+                {
+                }
+                ~UnknownFieldSetFieldSkipper() override
+                {
+                }
+
+                // implements FieldSkipper -----------------------------------------
+                bool SkipField(io::CodedInputStream* input, uint32_t tag) override;
+                bool SkipMessage(io::CodedInputStream* input) override;
+                void SkipUnknownEnum(int field_number, int value) override;
+
+            protected:
+                UnknownFieldSet* unknown_fields_;
+            };
+
+            // inline methods ====================================================
+
+            inline WireFormatLite::WireType WireFormat::WireTypeForField(
+                const FieldDescriptor* field
+            )
+            {
+                if (field->is_packed())
+                {
+                    return WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
+                }
+                else
+                {
+                    return WireTypeForFieldType(field->type());
+                }
+            }
+
+            inline WireFormatLite::WireType WireFormat::WireTypeForFieldType(
+                FieldDescriptor::Type type
+            )
+            {
+                // Some compilers don't like enum -> enum casts, so we implicit_cast to
+                // int first.
+                return WireFormatLite::WireTypeForFieldType(
+                    static_cast<WireFormatLite::FieldType>(implicit_cast<int>(type))
+                );
+            }
+
+            inline uint32_t WireFormat::MakeTag(const FieldDescriptor* field)
+            {
+                return WireFormatLite::MakeTag(field->number(), WireTypeForField(field));
+            }
+
+            inline size_t WireFormat::TagSize(int field_number, FieldDescriptor::Type type)
+            {
+                // Some compilers don't like enum -> enum casts, so we implicit_cast to
+                // int first.
+                return WireFormatLite::TagSize(
+                    field_number,
+                    static_cast<WireFormatLite::FieldType>(implicit_cast<int>(type))
+                );
+            }
+
+            inline void WireFormat::VerifyUTF8String(const char* data, int size, WireFormat::Operation op)
+            {
 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
-  WireFormatLite::VerifyUtf8String(
-      data, size, static_cast<WireFormatLite::Operation>(op), nullptr);
+                WireFormatLite::VerifyUtf8String(
+                    data, size, static_cast<WireFormatLite::Operation>(op), nullptr
+                );
 #else
-  // Avoid the compiler warning about unused variables.
-  (void)data;
-  (void)size;
-  (void)op;
+                // Avoid the compiler warning about unused variables.
+                (void)data;
+                (void)size;
+                (void)op;
 #endif
-}
+            }
 
-inline void WireFormat::VerifyUTF8StringNamedField(const char* data, int size,
-                                                   WireFormat::Operation op,
-                                                   const char* field_name) {
+            inline void WireFormat::VerifyUTF8StringNamedField(const char* data, int size, WireFormat::Operation op, const char* field_name)
+            {
 #ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
-  WireFormatLite::VerifyUtf8String(
-      data, size, static_cast<WireFormatLite::Operation>(op), field_name);
+                WireFormatLite::VerifyUtf8String(
+                    data, size, static_cast<WireFormatLite::Operation>(op), field_name
+                );
 #else
-  // Avoid the compiler warning about unused variables.
-  (void)data;
-  (void)size;
-  (void)op;
-  (void)field_name;
+                // Avoid the compiler warning about unused variables.
+                (void)data;
+                (void)size;
+                (void)op;
+                (void)field_name;
 #endif
-}
-
-
-inline uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
-    const UnknownFieldSet& unknown_fields, uint8_t* target,
-    io::EpsCopyOutputStream* stream) {
-  return WireFormat::InternalSerializeUnknownMessageSetItemsToArray(
-      unknown_fields, target, stream);
-}
-
-inline size_t ComputeUnknownMessageSetItemsSize(
-    const UnknownFieldSet& unknown_fields) {
-  return WireFormat::ComputeUnknownMessageSetItemsSize(unknown_fields);
-}
-
-// Compute the size of the UnknownFieldSet on the wire.
-PROTOBUF_EXPORT
-size_t ComputeUnknownFieldsSize(const InternalMetadata& metadata, size_t size,
-                                CachedSize* cached_size);
-
-size_t MapKeyDataOnlyByteSize(const FieldDescriptor* field,
-                              const MapKey& value);
-
-uint8_t* SerializeMapKeyWithCachedSizes(const FieldDescriptor* field,
-                                        const MapKey& value, uint8_t* target,
-                                        io::EpsCopyOutputStream* stream);
-}  // namespace internal
-}  // namespace protobuf
+            }
+
+            inline uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
+                const UnknownFieldSet& unknown_fields, uint8_t* target, io::EpsCopyOutputStream* stream
+            )
+            {
+                return WireFormat::InternalSerializeUnknownMessageSetItemsToArray(
+                    unknown_fields, target, stream
+                );
+            }
+
+            inline size_t ComputeUnknownMessageSetItemsSize(
+                const UnknownFieldSet& unknown_fields
+            )
+            {
+                return WireFormat::ComputeUnknownMessageSetItemsSize(unknown_fields);
+            }
+
+            // Compute the size of the UnknownFieldSet on the wire.
+            PROTOBUF_EXPORT
+            size_t ComputeUnknownFieldsSize(const InternalMetadata& metadata, size_t size, CachedSize* cached_size);
+
+            size_t MapKeyDataOnlyByteSize(const FieldDescriptor* field, const MapKey& value);
+
+            uint8_t* SerializeMapKeyWithCachedSizes(const FieldDescriptor* field, const MapKey& value, uint8_t* target, io::EpsCopyOutputStream* stream);
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/wire_format_lite.h b/CAPI/cpp/grpc/include/google/protobuf/wire_format_lite.h
index 80d3961..92ece29 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/wire_format_lite.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/wire_format_lite.h
@@ -40,7 +40,6 @@
 #ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
 #define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
 
-
 #include <limits>
 #include <string>
 
@@ -68,1839 +67,2049 @@
 // #pragma pop_macro("TYPE_BOOL")
 #undef TYPE_BOOL
 
-
 // Must be included last.
 #include <google/protobuf/port_def.inc>
 
-namespace google {
-namespace protobuf {
-namespace internal {
-
-// This class is for internal use by the protocol buffer library and by
-// protocol-compiler-generated message classes.  It must not be called
-// directly by clients.
-//
-// This class contains helpers for implementing the binary protocol buffer
-// wire format without the need for reflection. Use WireFormat when using
-// reflection.
-//
-// This class is really a namespace that contains only static methods.
-class PROTOBUF_EXPORT WireFormatLite {
- public:
-  // -----------------------------------------------------------------
-  // Helper constants and functions related to the format.  These are
-  // mostly meant for internal and generated code to use.
-
-  // The wire format is composed of a sequence of tag/value pairs, each
-  // of which contains the value of one field (or one element of a repeated
-  // field).  Each tag is encoded as a varint.  The lower bits of the tag
-  // identify its wire type, which specifies the format of the data to follow.
-  // The rest of the bits contain the field number.  Each type of field (as
-  // declared by FieldDescriptor::Type, in descriptor.h) maps to one of
-  // these wire types.  Immediately following each tag is the field's value,
-  // encoded in the format specified by the wire type.  Because the tag
-  // identifies the encoding of this data, it is possible to skip
-  // unrecognized fields for forwards compatibility.
-
-  enum WireType {
-    WIRETYPE_VARINT = 0,
-    WIRETYPE_FIXED64 = 1,
-    WIRETYPE_LENGTH_DELIMITED = 2,
-    WIRETYPE_START_GROUP = 3,
-    WIRETYPE_END_GROUP = 4,
-    WIRETYPE_FIXED32 = 5,
-  };
-
-  // Lite alternative to FieldDescriptor::Type.  Must be kept in sync.
-  enum FieldType {
-    TYPE_DOUBLE = 1,
-    TYPE_FLOAT = 2,
-    TYPE_INT64 = 3,
-    TYPE_UINT64 = 4,
-    TYPE_INT32 = 5,
-    TYPE_FIXED64 = 6,
-    TYPE_FIXED32 = 7,
-    TYPE_BOOL = 8,
-    TYPE_STRING = 9,
-    TYPE_GROUP = 10,
-    TYPE_MESSAGE = 11,
-    TYPE_BYTES = 12,
-    TYPE_UINT32 = 13,
-    TYPE_ENUM = 14,
-    TYPE_SFIXED32 = 15,
-    TYPE_SFIXED64 = 16,
-    TYPE_SINT32 = 17,
-    TYPE_SINT64 = 18,
-    MAX_FIELD_TYPE = 18,
-  };
-
-  // Lite alternative to FieldDescriptor::CppType.  Must be kept in sync.
-  enum CppType {
-    CPPTYPE_INT32 = 1,
-    CPPTYPE_INT64 = 2,
-    CPPTYPE_UINT32 = 3,
-    CPPTYPE_UINT64 = 4,
-    CPPTYPE_DOUBLE = 5,
-    CPPTYPE_FLOAT = 6,
-    CPPTYPE_BOOL = 7,
-    CPPTYPE_ENUM = 8,
-    CPPTYPE_STRING = 9,
-    CPPTYPE_MESSAGE = 10,
-    MAX_CPPTYPE = 10,
-  };
-
-  // Helper method to get the CppType for a particular Type.
-  static CppType FieldTypeToCppType(FieldType type);
-
-  // Given a FieldDescriptor::Type return its WireType
-  static inline WireFormatLite::WireType WireTypeForFieldType(
-      WireFormatLite::FieldType type) {
-    return kWireTypeForFieldType[type];
-  }
-
-  // Number of bits in a tag which identify the wire type.
-  static constexpr int kTagTypeBits = 3;
-  // Mask for those bits.
-  static constexpr uint32_t kTagTypeMask = (1 << kTagTypeBits) - 1;
-
-  // Helper functions for encoding and decoding tags.  (Inlined below and in
-  // _inl.h)
-  //
-  // This is different from MakeTag(field->number(), field->type()) in the
-  // case of packed repeated fields.
-  constexpr static uint32_t MakeTag(int field_number, WireType type);
-  static WireType GetTagWireType(uint32_t tag);
-  static int GetTagFieldNumber(uint32_t tag);
-
-  // Compute the byte size of a tag.  For groups, this includes both the start
-  // and end tags.
-  static inline size_t TagSize(int field_number,
-                               WireFormatLite::FieldType type);
-
-  // Skips a field value with the given tag.  The input should start
-  // positioned immediately after the tag.  Skipped values are simply
-  // discarded, not recorded anywhere.  See WireFormat::SkipField() for a
-  // version that records to an UnknownFieldSet.
-  static bool SkipField(io::CodedInputStream* input, uint32_t tag);
-
-  // Skips a field value with the given tag.  The input should start
-  // positioned immediately after the tag. Skipped values are recorded to a
-  // CodedOutputStream.
-  static bool SkipField(io::CodedInputStream* input, uint32_t tag,
-                        io::CodedOutputStream* output);
-
-  // Reads and ignores a message from the input.  Skipped values are simply
-  // discarded, not recorded anywhere.  See WireFormat::SkipMessage() for a
-  // version that records to an UnknownFieldSet.
-  static bool SkipMessage(io::CodedInputStream* input);
-
-  // Reads and ignores a message from the input.  Skipped values are recorded
-  // to a CodedOutputStream.
-  static bool SkipMessage(io::CodedInputStream* input,
-                          io::CodedOutputStream* output);
-
-  // This macro does the same thing as WireFormatLite::MakeTag(), but the
-  // result is usable as a compile-time constant, which makes it usable
-  // as a switch case or a template input.  WireFormatLite::MakeTag() is more
-  // type-safe, though, so prefer it if possible.
+namespace google
+{
+    namespace protobuf
+    {
+        namespace internal
+        {
+
+            // This class is for internal use by the protocol buffer library and by
+            // protocol-compiler-generated message classes.  It must not be called
+            // directly by clients.
+            //
+            // This class contains helpers for implementing the binary protocol buffer
+            // wire format without the need for reflection. Use WireFormat when using
+            // reflection.
+            //
+            // This class is really a namespace that contains only static methods.
+            class PROTOBUF_EXPORT WireFormatLite
+            {
+            public:
+                // -----------------------------------------------------------------
+                // Helper constants and functions related to the format.  These are
+                // mostly meant for internal and generated code to use.
+
+                // The wire format is composed of a sequence of tag/value pairs, each
+                // of which contains the value of one field (or one element of a repeated
+                // field).  Each tag is encoded as a varint.  The lower bits of the tag
+                // identify its wire type, which specifies the format of the data to follow.
+                // The rest of the bits contain the field number.  Each type of field (as
+                // declared by FieldDescriptor::Type, in descriptor.h) maps to one of
+                // these wire types.  Immediately following each tag is the field's value,
+                // encoded in the format specified by the wire type.  Because the tag
+                // identifies the encoding of this data, it is possible to skip
+                // unrecognized fields for forwards compatibility.
+
+                enum WireType
+                {
+                    WIRETYPE_VARINT = 0,
+                    WIRETYPE_FIXED64 = 1,
+                    WIRETYPE_LENGTH_DELIMITED = 2,
+                    WIRETYPE_START_GROUP = 3,
+                    WIRETYPE_END_GROUP = 4,
+                    WIRETYPE_FIXED32 = 5,
+                };
+
+                // Lite alternative to FieldDescriptor::Type.  Must be kept in sync.
+                enum FieldType
+                {
+                    TYPE_DOUBLE = 1,
+                    TYPE_FLOAT = 2,
+                    TYPE_INT64 = 3,
+                    TYPE_UINT64 = 4,
+                    TYPE_INT32 = 5,
+                    TYPE_FIXED64 = 6,
+                    TYPE_FIXED32 = 7,
+                    TYPE_BOOL = 8,
+                    TYPE_STRING = 9,
+                    TYPE_GROUP = 10,
+                    TYPE_MESSAGE = 11,
+                    TYPE_BYTES = 12,
+                    TYPE_UINT32 = 13,
+                    TYPE_ENUM = 14,
+                    TYPE_SFIXED32 = 15,
+                    TYPE_SFIXED64 = 16,
+                    TYPE_SINT32 = 17,
+                    TYPE_SINT64 = 18,
+                    MAX_FIELD_TYPE = 18,
+                };
+
+                // Lite alternative to FieldDescriptor::CppType.  Must be kept in sync.
+                enum CppType
+                {
+                    CPPTYPE_INT32 = 1,
+                    CPPTYPE_INT64 = 2,
+                    CPPTYPE_UINT32 = 3,
+                    CPPTYPE_UINT64 = 4,
+                    CPPTYPE_DOUBLE = 5,
+                    CPPTYPE_FLOAT = 6,
+                    CPPTYPE_BOOL = 7,
+                    CPPTYPE_ENUM = 8,
+                    CPPTYPE_STRING = 9,
+                    CPPTYPE_MESSAGE = 10,
+                    MAX_CPPTYPE = 10,
+                };
+
+                // Helper method to get the CppType for a particular Type.
+                static CppType FieldTypeToCppType(FieldType type);
+
+                // Given a FieldDescriptor::Type return its WireType
+                static inline WireFormatLite::WireType WireTypeForFieldType(
+                    WireFormatLite::FieldType type
+                )
+                {
+                    return kWireTypeForFieldType[type];
+                }
+
+                // Number of bits in a tag which identify the wire type.
+                static constexpr int kTagTypeBits = 3;
+                // Mask for those bits.
+                static constexpr uint32_t kTagTypeMask = (1 << kTagTypeBits) - 1;
+
+                // Helper functions for encoding and decoding tags.  (Inlined below and in
+                // _inl.h)
+                //
+                // This is different from MakeTag(field->number(), field->type()) in the
+                // case of packed repeated fields.
+                constexpr static uint32_t MakeTag(int field_number, WireType type);
+                static WireType GetTagWireType(uint32_t tag);
+                static int GetTagFieldNumber(uint32_t tag);
+
+                // Compute the byte size of a tag.  For groups, this includes both the start
+                // and end tags.
+                static inline size_t TagSize(int field_number, WireFormatLite::FieldType type);
+
+                // Skips a field value with the given tag.  The input should start
+                // positioned immediately after the tag.  Skipped values are simply
+                // discarded, not recorded anywhere.  See WireFormat::SkipField() for a
+                // version that records to an UnknownFieldSet.
+                static bool SkipField(io::CodedInputStream* input, uint32_t tag);
+
+                // Skips a field value with the given tag.  The input should start
+                // positioned immediately after the tag. Skipped values are recorded to a
+                // CodedOutputStream.
+                static bool SkipField(io::CodedInputStream* input, uint32_t tag, io::CodedOutputStream* output);
+
+                // Reads and ignores a message from the input.  Skipped values are simply
+                // discarded, not recorded anywhere.  See WireFormat::SkipMessage() for a
+                // version that records to an UnknownFieldSet.
+                static bool SkipMessage(io::CodedInputStream* input);
+
+                // Reads and ignores a message from the input.  Skipped values are recorded
+                // to a CodedOutputStream.
+                static bool SkipMessage(io::CodedInputStream* input, io::CodedOutputStream* output);
+
+                // This macro does the same thing as WireFormatLite::MakeTag(), but the
+                // result is usable as a compile-time constant, which makes it usable
+                // as a switch case or a template input.  WireFormatLite::MakeTag() is more
+                // type-safe, though, so prefer it if possible.
 #define GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(FIELD_NUMBER, TYPE) \
-  static_cast<uint32_t>((static_cast<uint32_t>(FIELD_NUMBER) << 3) | (TYPE))
-
-  // These are the tags for the old MessageSet format, which was defined as:
-  //   message MessageSet {
-  //     repeated group Item = 1 {
-  //       required int32 type_id = 2;
-  //       required string message = 3;
-  //     }
-  //   }
-  static constexpr int kMessageSetItemNumber = 1;
-  static constexpr int kMessageSetTypeIdNumber = 2;
-  static constexpr int kMessageSetMessageNumber = 3;
-  static const int kMessageSetItemStartTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
-      kMessageSetItemNumber, WireFormatLite::WIRETYPE_START_GROUP);
-  static const int kMessageSetItemEndTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
-      kMessageSetItemNumber, WireFormatLite::WIRETYPE_END_GROUP);
-  static const int kMessageSetTypeIdTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
-      kMessageSetTypeIdNumber, WireFormatLite::WIRETYPE_VARINT);
-  static const int kMessageSetMessageTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
-      kMessageSetMessageNumber, WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
-
-  // Byte size of all tags of a MessageSet::Item combined.
-  static const size_t kMessageSetItemTagsSize;
-
-  // Helper functions for converting between floats/doubles and IEEE-754
-  // uint32s/uint64s so that they can be written.  (Assumes your platform
-  // uses IEEE-754 floats.)
-  static uint32_t EncodeFloat(float value);
-  static float DecodeFloat(uint32_t value);
-  static uint64_t EncodeDouble(double value);
-  static double DecodeDouble(uint64_t value);
-
-  // Helper functions for mapping signed integers to unsigned integers in
-  // such a way that numbers with small magnitudes will encode to smaller
-  // varints.  If you simply static_cast a negative number to an unsigned
-  // number and varint-encode it, it will always take 10 bytes, defeating
-  // the purpose of varint.  So, for the "sint32" and "sint64" field types,
-  // we ZigZag-encode the values.
-  static uint32_t ZigZagEncode32(int32_t n);
-  static int32_t ZigZagDecode32(uint32_t n);
-  static uint64_t ZigZagEncode64(int64_t n);
-  static int64_t ZigZagDecode64(uint64_t n);
-
-  // =================================================================
-  // Methods for reading/writing individual field.
-
-  // Read fields, not including tags.  The assumption is that you already
-  // read the tag to determine what field to read.
-
-  // For primitive fields, we just use a templatized routine parameterized by
-  // the represented type and the FieldType. These are specialized with the
-  // appropriate definition for each declared type.
-  template <typename CType, enum FieldType DeclaredType>
-  PROTOBUF_NDEBUG_INLINE static bool ReadPrimitive(io::CodedInputStream* input,
-                                                   CType* value);
-
-  // Reads repeated primitive values, with optimizations for repeats.
-  // tag_size and tag should both be compile-time constants provided by the
-  // protocol compiler.
-  template <typename CType, enum FieldType DeclaredType>
-  PROTOBUF_NDEBUG_INLINE static bool ReadRepeatedPrimitive(
-      int tag_size, uint32_t tag, io::CodedInputStream* input,
-      RepeatedField<CType>* value);
-
-  // Identical to ReadRepeatedPrimitive, except will not inline the
-  // implementation.
-  template <typename CType, enum FieldType DeclaredType>
-  static bool ReadRepeatedPrimitiveNoInline(int tag_size, uint32_t tag,
-                                            io::CodedInputStream* input,
-                                            RepeatedField<CType>* value);
-
-  // Reads a primitive value directly from the provided buffer. It returns a
-  // pointer past the segment of data that was read.
-  //
-  // This is only implemented for the types with fixed wire size, e.g.
-  // float, double, and the (s)fixed* types.
-  template <typename CType, enum FieldType DeclaredType>
-  PROTOBUF_NDEBUG_INLINE static const uint8_t* ReadPrimitiveFromArray(
-      const uint8_t* buffer, CType* value);
-
-  // Reads a primitive packed field.
-  //
-  // This is only implemented for packable types.
-  template <typename CType, enum FieldType DeclaredType>
-  PROTOBUF_NDEBUG_INLINE static bool ReadPackedPrimitive(
-      io::CodedInputStream* input, RepeatedField<CType>* value);
-
-  // Identical to ReadPackedPrimitive, except will not inline the
-  // implementation.
-  template <typename CType, enum FieldType DeclaredType>
-  static bool ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
-                                          RepeatedField<CType>* value);
-
-  // Read a packed enum field. If the is_valid function is not nullptr, values
-  // for which is_valid(value) returns false are silently dropped.
-  static bool ReadPackedEnumNoInline(io::CodedInputStream* input,
-                                     bool (*is_valid)(int),
-                                     RepeatedField<int>* values);
-
-  // Read a packed enum field. If the is_valid function is not nullptr, values
-  // for which is_valid(value) returns false are appended to
-  // unknown_fields_stream.
-  static bool ReadPackedEnumPreserveUnknowns(
-      io::CodedInputStream* input, int field_number, bool (*is_valid)(int),
-      io::CodedOutputStream* unknown_fields_stream, RepeatedField<int>* values);
-
-  // Read a string.  ReadString(..., std::string* value) requires an
-  // existing std::string.
-  static inline bool ReadString(io::CodedInputStream* input,
-                                std::string* value);
-  // ReadString(..., std::string** p) is internal-only, and should only be
-  // called from generated code. It starts by setting *p to "new std::string" if
-  // *p == &GetEmptyStringAlreadyInited().  It then invokes
-  // ReadString(io::CodedInputStream* input, *p).  This is useful for reducing
-  // code size.
-  static inline bool ReadString(io::CodedInputStream* input, std::string** p);
-  // Analogous to ReadString().
-  static bool ReadBytes(io::CodedInputStream* input, std::string* value);
-  static bool ReadBytes(io::CodedInputStream* input, std::string** p);
-
-  enum Operation {
-    PARSE = 0,
-    SERIALIZE = 1,
-  };
-
-  // Returns true if the data is valid UTF-8.
-  static bool VerifyUtf8String(const char* data, int size, Operation op,
-                               const char* field_name);
-
-  template <typename MessageType>
-  static inline bool ReadGroup(int field_number, io::CodedInputStream* input,
-                               MessageType* value);
-
-  template <typename MessageType>
-  static inline bool ReadMessage(io::CodedInputStream* input,
-                                 MessageType* value);
-
-  template <typename MessageType>
-  static inline bool ReadMessageNoVirtual(io::CodedInputStream* input,
-                                          MessageType* value) {
-    return ReadMessage(input, value);
-  }
-
-  // Write a tag.  The Write*() functions typically include the tag, so
-  // normally there's no need to call this unless using the Write*NoTag()
-  // variants.
-  PROTOBUF_NDEBUG_INLINE static void WriteTag(int field_number, WireType type,
-                                              io::CodedOutputStream* output);
-
-  // Write fields, without tags.
-  PROTOBUF_NDEBUG_INLINE static void WriteInt32NoTag(
-      int32_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteInt64NoTag(
-      int64_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteUInt32NoTag(
-      uint32_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteUInt64NoTag(
-      uint64_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteSInt32NoTag(
-      int32_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteSInt64NoTag(
-      int64_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteFixed32NoTag(
-      uint32_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteFixed64NoTag(
-      uint64_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteSFixed32NoTag(
-      int32_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteSFixed64NoTag(
-      int64_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteFloatNoTag(
-      float value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteDoubleNoTag(
-      double value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteBoolNoTag(
-      bool value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteEnumNoTag(
-      int value, io::CodedOutputStream* output);
-
-  // Write array of primitive fields, without tags
-  static void WriteFloatArray(const float* a, int n,
-                              io::CodedOutputStream* output);
-  static void WriteDoubleArray(const double* a, int n,
-                               io::CodedOutputStream* output);
-  static void WriteFixed32Array(const uint32_t* a, int n,
-                                io::CodedOutputStream* output);
-  static void WriteFixed64Array(const uint64_t* a, int n,
-                                io::CodedOutputStream* output);
-  static void WriteSFixed32Array(const int32_t* a, int n,
-                                 io::CodedOutputStream* output);
-  static void WriteSFixed64Array(const int64_t* a, int n,
-                                 io::CodedOutputStream* output);
-  static void WriteBoolArray(const bool* a, int n,
-                             io::CodedOutputStream* output);
-
-  // Write fields, including tags.
-  static void WriteInt32(int field_number, int32_t value,
-                         io::CodedOutputStream* output);
-  static void WriteInt64(int field_number, int64_t value,
-                         io::CodedOutputStream* output);
-  static void WriteUInt32(int field_number, uint32_t value,
-                          io::CodedOutputStream* output);
-  static void WriteUInt64(int field_number, uint64_t value,
-                          io::CodedOutputStream* output);
-  static void WriteSInt32(int field_number, int32_t value,
-                          io::CodedOutputStream* output);
-  static void WriteSInt64(int field_number, int64_t value,
-                          io::CodedOutputStream* output);
-  static void WriteFixed32(int field_number, uint32_t value,
-                           io::CodedOutputStream* output);
-  static void WriteFixed64(int field_number, uint64_t value,
-                           io::CodedOutputStream* output);
-  static void WriteSFixed32(int field_number, int32_t value,
-                            io::CodedOutputStream* output);
-  static void WriteSFixed64(int field_number, int64_t value,
-                            io::CodedOutputStream* output);
-  static void WriteFloat(int field_number, float value,
-                         io::CodedOutputStream* output);
-  static void WriteDouble(int field_number, double value,
-                          io::CodedOutputStream* output);
-  static void WriteBool(int field_number, bool value,
-                        io::CodedOutputStream* output);
-  static void WriteEnum(int field_number, int value,
-                        io::CodedOutputStream* output);
-
-  static void WriteString(int field_number, const std::string& value,
-                          io::CodedOutputStream* output);
-  static void WriteBytes(int field_number, const std::string& value,
-                         io::CodedOutputStream* output);
-  static void WriteStringMaybeAliased(int field_number,
-                                      const std::string& value,
-                                      io::CodedOutputStream* output);
-  static void WriteBytesMaybeAliased(int field_number, const std::string& value,
-                                     io::CodedOutputStream* output);
-
-  static void WriteGroup(int field_number, const MessageLite& value,
-                         io::CodedOutputStream* output);
-  static void WriteMessage(int field_number, const MessageLite& value,
-                           io::CodedOutputStream* output);
-  // Like above, but these will check if the output stream has enough
-  // space to write directly to a flat array.
-  static void WriteGroupMaybeToArray(int field_number, const MessageLite& value,
-                                     io::CodedOutputStream* output);
-  static void WriteMessageMaybeToArray(int field_number,
-                                       const MessageLite& value,
-                                       io::CodedOutputStream* output);
-
-  // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
-  // pointer must point at an instance of MessageType, *not* a subclass (or
-  // the subclass must not override SerializeWithCachedSizes()).
-  template <typename MessageType>
-  static inline void WriteGroupNoVirtual(int field_number,
-                                         const MessageType& value,
-                                         io::CodedOutputStream* output);
-  template <typename MessageType>
-  static inline void WriteMessageNoVirtual(int field_number,
-                                           const MessageType& value,
-                                           io::CodedOutputStream* output);
-
-  // Like above, but use only *ToArray methods of CodedOutputStream.
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteTagToArray(int field_number,
-                                                         WireType type,
-                                                         uint8_t* target);
-
-  // Write fields, without tags.
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32NoTagToArray(
-      int32_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
-      int64_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32NoTagToArray(
-      uint32_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
-      uint64_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32NoTagToArray(
-      int32_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
-      int64_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32NoTagToArray(
-      uint32_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
-      uint64_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32NoTagToArray(
-      int32_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
-      int64_t value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatNoTagToArray(
-      float value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleNoTagToArray(
-      double value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolNoTagToArray(bool value,
-                                                               uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumNoTagToArray(int value,
-                                                               uint8_t* target);
-
-  // Write fields, without tags.  These require that value.size() > 0.
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WritePrimitiveNoTagToArray(
-      const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*),
-      uint8_t* target);
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixedNoTagToArray(
-      const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*),
-      uint8_t* target);
-
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32NoTagToArray(
-      const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
-      const RepeatedField<int64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32NoTagToArray(
-      const RepeatedField<uint32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
-      const RepeatedField<uint64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32NoTagToArray(
-      const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
-      const RepeatedField<int64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32NoTagToArray(
-      const RepeatedField<uint32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
-      const RepeatedField<uint64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32NoTagToArray(
-      const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
-      const RepeatedField<int64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatNoTagToArray(
-      const RepeatedField<float>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleNoTagToArray(
-      const RepeatedField<double>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolNoTagToArray(
-      const RepeatedField<bool>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumNoTagToArray(
-      const RepeatedField<int>& value, uint8_t* output);
-
-  // Write fields, including tags.
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32ToArray(int field_number,
-                                                           int32_t value,
-                                                           uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64ToArray(int field_number,
-                                                           int64_t value,
-                                                           uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32ToArray(int field_number,
-                                                            uint32_t value,
-                                                            uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64ToArray(int field_number,
-                                                            uint64_t value,
-                                                            uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32ToArray(int field_number,
-                                                            int32_t value,
-                                                            uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64ToArray(int field_number,
-                                                            int64_t value,
-                                                            uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32ToArray(int field_number,
-                                                             uint32_t value,
-                                                             uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64ToArray(int field_number,
-                                                             uint64_t value,
-                                                             uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32ToArray(int field_number,
-                                                              int32_t value,
-                                                              uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64ToArray(int field_number,
-                                                              int64_t value,
-                                                              uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatToArray(int field_number,
-                                                           float value,
-                                                           uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleToArray(int field_number,
-                                                            double value,
-                                                            uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolToArray(int field_number,
-                                                          bool value,
-                                                          uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumToArray(int field_number,
-                                                          int value,
-                                                          uint8_t* target);
-
-  template <typename T>
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WritePrimitiveToArray(
-      int field_number, const RepeatedField<T>& value,
-      uint8_t* (*Writer)(int, T, uint8_t*), uint8_t* target);
-
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32ToArray(
-      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64ToArray(
-      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32ToArray(
-      int field_number, const RepeatedField<uint32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64ToArray(
-      int field_number, const RepeatedField<uint64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32ToArray(
-      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64ToArray(
-      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32ToArray(
-      int field_number, const RepeatedField<uint32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64ToArray(
-      int field_number, const RepeatedField<uint64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32ToArray(
-      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64ToArray(
-      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatToArray(
-      int field_number, const RepeatedField<float>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleToArray(
-      int field_number, const RepeatedField<double>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolToArray(
-      int field_number, const RepeatedField<bool>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumToArray(
-      int field_number, const RepeatedField<int>& value, uint8_t* output);
-
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteStringToArray(
-      int field_number, const std::string& value, uint8_t* target);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBytesToArray(
-      int field_number, const std::string& value, uint8_t* target);
-
-  // Whether to serialize deterministically (e.g., map keys are
-  // sorted) is a property of a CodedOutputStream, and in the process
-  // of serialization, the "ToArray" variants may be invoked.  But they don't
-  // have a CodedOutputStream available, so they get an additional parameter
-  // telling them whether to serialize deterministically.
-  static uint8_t* InternalWriteGroup(int field_number, const MessageLite& value,
-                                     uint8_t* target,
-                                     io::EpsCopyOutputStream* stream);
-  static uint8_t* InternalWriteMessage(int field_number,
-                                       const MessageLite& value,
-                                       int cached_size, uint8_t* target,
-                                       io::EpsCopyOutputStream* stream);
-
-  // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
-  // pointer must point at an instance of MessageType, *not* a subclass (or
-  // the subclass must not override SerializeWithCachedSizes()).
-  template <typename MessageType>
-  PROTOBUF_NDEBUG_INLINE static uint8_t* InternalWriteGroupNoVirtualToArray(
-      int field_number, const MessageType& value, uint8_t* target);
-  template <typename MessageType>
-  PROTOBUF_NDEBUG_INLINE static uint8_t* InternalWriteMessageNoVirtualToArray(
-      int field_number, const MessageType& value, uint8_t* target);
-
-  // For backward-compatibility, the last four methods also have versions
-  // that are non-deterministic always.
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteGroupToArray(
-      int field_number, const MessageLite& value, uint8_t* target) {
-    io::EpsCopyOutputStream stream(
-        target,
-        value.GetCachedSize() +
-            static_cast<int>(2 * io::CodedOutputStream::VarintSize32(
-                                     static_cast<uint32_t>(field_number) << 3)),
-        io::CodedOutputStream::IsDefaultSerializationDeterministic());
-    return InternalWriteGroup(field_number, value, target, &stream);
-  }
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteMessageToArray(
-      int field_number, const MessageLite& value, uint8_t* target) {
-    int size = value.GetCachedSize();
-    io::EpsCopyOutputStream stream(
-        target,
-        size + static_cast<int>(io::CodedOutputStream::VarintSize32(
-                                    static_cast<uint32_t>(field_number) << 3) +
-                                io::CodedOutputStream::VarintSize32(size)),
-        io::CodedOutputStream::IsDefaultSerializationDeterministic());
-    return InternalWriteMessage(field_number, value, value.GetCachedSize(),
-                                target, &stream);
-  }
-
-  // Compute the byte size of a field.  The XxSize() functions do NOT include
-  // the tag, so you must also call TagSize().  (This is because, for repeated
-  // fields, you should only call TagSize() once and multiply it by the element
-  // count, but you may have to call XxSize() for each individual element.)
-  static inline size_t Int32Size(int32_t value);
-  static inline size_t Int64Size(int64_t value);
-  static inline size_t UInt32Size(uint32_t value);
-  static inline size_t UInt64Size(uint64_t value);
-  static inline size_t SInt32Size(int32_t value);
-  static inline size_t SInt64Size(int64_t value);
-  static inline size_t EnumSize(int value);
-  static inline size_t Int32SizePlusOne(int32_t value);
-  static inline size_t Int64SizePlusOne(int64_t value);
-  static inline size_t UInt32SizePlusOne(uint32_t value);
-  static inline size_t UInt64SizePlusOne(uint64_t value);
-  static inline size_t SInt32SizePlusOne(int32_t value);
-  static inline size_t SInt64SizePlusOne(int64_t value);
-  static inline size_t EnumSizePlusOne(int value);
-
-  static size_t Int32Size(const RepeatedField<int32_t>& value);
-  static size_t Int64Size(const RepeatedField<int64_t>& value);
-  static size_t UInt32Size(const RepeatedField<uint32_t>& value);
-  static size_t UInt64Size(const RepeatedField<uint64_t>& value);
-  static size_t SInt32Size(const RepeatedField<int32_t>& value);
-  static size_t SInt64Size(const RepeatedField<int64_t>& value);
-  static size_t EnumSize(const RepeatedField<int>& value);
-
-  // These types always have the same size.
-  static constexpr size_t kFixed32Size = 4;
-  static constexpr size_t kFixed64Size = 8;
-  static constexpr size_t kSFixed32Size = 4;
-  static constexpr size_t kSFixed64Size = 8;
-  static constexpr size_t kFloatSize = 4;
-  static constexpr size_t kDoubleSize = 8;
-  static constexpr size_t kBoolSize = 1;
-
-  static inline size_t StringSize(const std::string& value);
-  static inline size_t BytesSize(const std::string& value);
-
-  template <typename MessageType>
-  static inline size_t GroupSize(const MessageType& value);
-  template <typename MessageType>
-  static inline size_t MessageSize(const MessageType& value);
-
-  // Like above, but de-virtualize the call to ByteSize().  The
-  // pointer must point at an instance of MessageType, *not* a subclass (or
-  // the subclass must not override ByteSize()).
-  template <typename MessageType>
-  static inline size_t GroupSizeNoVirtual(const MessageType& value);
-  template <typename MessageType>
-  static inline size_t MessageSizeNoVirtual(const MessageType& value);
-
-  // Given the length of data, calculate the byte size of the data on the
-  // wire if we encode the data as a length delimited field.
-  static inline size_t LengthDelimitedSize(size_t length);
-
- private:
-  // A helper method for the repeated primitive reader. This method has
-  // optimizations for primitive types that have fixed size on the wire, and
-  // can be read using potentially faster paths.
-  template <typename CType, enum FieldType DeclaredType>
-  PROTOBUF_NDEBUG_INLINE static bool ReadRepeatedFixedSizePrimitive(
-      int tag_size, uint32_t tag, io::CodedInputStream* input,
-      RepeatedField<CType>* value);
-
-  // Like ReadRepeatedFixedSizePrimitive but for packed primitive fields.
-  template <typename CType, enum FieldType DeclaredType>
-  PROTOBUF_NDEBUG_INLINE static bool ReadPackedFixedSizePrimitive(
-      io::CodedInputStream* input, RepeatedField<CType>* value);
-
-  static const CppType kFieldTypeToCppTypeMap[];
-  static const WireFormatLite::WireType kWireTypeForFieldType[];
-  static void WriteSubMessageMaybeToArray(int size, const MessageLite& value,
-                                          io::CodedOutputStream* output);
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite);
-};
-
-// A class which deals with unknown values.  The default implementation just
-// discards them.  WireFormat defines a subclass which writes to an
-// UnknownFieldSet.  This class is used by ExtensionSet::ParseField(), since
-// ExtensionSet is part of the lite library but UnknownFieldSet is not.
-class PROTOBUF_EXPORT FieldSkipper {
- public:
-  FieldSkipper() {}
-  virtual ~FieldSkipper() {}
-
-  // Skip a field whose tag has already been consumed.
-  virtual bool SkipField(io::CodedInputStream* input, uint32_t tag);
-
-  // Skip an entire message or group, up to an end-group tag (which is consumed)
-  // or end-of-stream.
-  virtual bool SkipMessage(io::CodedInputStream* input);
-
-  // Deal with an already-parsed unrecognized enum value.  The default
-  // implementation does nothing, but the UnknownFieldSet-based implementation
-  // saves it as an unknown varint.
-  virtual void SkipUnknownEnum(int field_number, int value);
-};
-
-// Subclass of FieldSkipper which saves skipped fields to a CodedOutputStream.
-
-class PROTOBUF_EXPORT CodedOutputStreamFieldSkipper : public FieldSkipper {
- public:
-  explicit CodedOutputStreamFieldSkipper(io::CodedOutputStream* unknown_fields)
-      : unknown_fields_(unknown_fields) {}
-  ~CodedOutputStreamFieldSkipper() override {}
-
-  // implements FieldSkipper -----------------------------------------
-  bool SkipField(io::CodedInputStream* input, uint32_t tag) override;
-  bool SkipMessage(io::CodedInputStream* input) override;
-  void SkipUnknownEnum(int field_number, int value) override;
-
- protected:
-  io::CodedOutputStream* unknown_fields_;
-};
-
-// inline methods ====================================================
-
-inline WireFormatLite::CppType WireFormatLite::FieldTypeToCppType(
-    FieldType type) {
-  return kFieldTypeToCppTypeMap[type];
-}
-
-constexpr inline uint32_t WireFormatLite::MakeTag(int field_number,
-                                                  WireType type) {
-  return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
-}
-
-inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32_t tag) {
-  return static_cast<WireType>(tag & kTagTypeMask);
-}
-
-inline int WireFormatLite::GetTagFieldNumber(uint32_t tag) {
-  return static_cast<int>(tag >> kTagTypeBits);
-}
-
-inline size_t WireFormatLite::TagSize(int field_number,
-                                      WireFormatLite::FieldType type) {
-  size_t result = io::CodedOutputStream::VarintSize32(
-      static_cast<uint32_t>(field_number << kTagTypeBits));
-  if (type == TYPE_GROUP) {
-    // Groups have both a start and an end tag.
-    return result * 2;
-  } else {
-    return result;
-  }
-}
-
-inline uint32_t WireFormatLite::EncodeFloat(float value) {
-  return bit_cast<uint32_t>(value);
-}
-
-inline float WireFormatLite::DecodeFloat(uint32_t value) {
-  return bit_cast<float>(value);
-}
-
-inline uint64_t WireFormatLite::EncodeDouble(double value) {
-  return bit_cast<uint64_t>(value);
-}
-
-inline double WireFormatLite::DecodeDouble(uint64_t value) {
-  return bit_cast<double>(value);
-}
-
-// ZigZag Transform:  Encodes signed integers so that they can be
-// effectively used with varint encoding.
-//
-// varint operates on unsigned integers, encoding smaller numbers into
-// fewer bytes.  If you try to use it on a signed integer, it will treat
-// this number as a very large unsigned integer, which means that even
-// small signed numbers like -1 will take the maximum number of bytes
-// (10) to encode.  ZigZagEncode() maps signed integers to unsigned
-// in such a way that those with a small absolute value will have smaller
-// encoded values, making them appropriate for encoding using varint.
-//
-//       int32_t ->     uint32_t
-// -------------------------
-//           0 ->          0
-//          -1 ->          1
-//           1 ->          2
-//          -2 ->          3
-//         ... ->        ...
-//  2147483647 -> 4294967294
-// -2147483648 -> 4294967295
-//
-//        >> encode >>
-//        << decode <<
-
-inline uint32_t WireFormatLite::ZigZagEncode32(int32_t n) {
-  // Note:  the right-shift must be arithmetic
-  // Note:  left shift must be unsigned because of overflow
-  return (static_cast<uint32_t>(n) << 1) ^ static_cast<uint32_t>(n >> 31);
-}
-
-inline int32_t WireFormatLite::ZigZagDecode32(uint32_t n) {
-  // Note:  Using unsigned types prevent undefined behavior
-  return static_cast<int32_t>((n >> 1) ^ (~(n & 1) + 1));
-}
-
-inline uint64_t WireFormatLite::ZigZagEncode64(int64_t n) {
-  // Note:  the right-shift must be arithmetic
-  // Note:  left shift must be unsigned because of overflow
-  return (static_cast<uint64_t>(n) << 1) ^ static_cast<uint64_t>(n >> 63);
-}
-
-inline int64_t WireFormatLite::ZigZagDecode64(uint64_t n) {
-  // Note:  Using unsigned types prevent undefined behavior
-  return static_cast<int64_t>((n >> 1) ^ (~(n & 1) + 1));
-}
-
-// String is for UTF-8 text only, but, even so, ReadString() can simply
-// call ReadBytes().
-
-inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
-                                       std::string* value) {
-  return ReadBytes(input, value);
-}
-
-inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
-                                       std::string** p) {
-  return ReadBytes(input, p);
-}
-
-inline uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
-    const std::string& unknown_fields, uint8_t* target,
-    io::EpsCopyOutputStream* stream) {
-  return stream->WriteRaw(unknown_fields.data(),
-                          static_cast<int>(unknown_fields.size()), target);
-}
-
-inline size_t ComputeUnknownMessageSetItemsSize(
-    const std::string& unknown_fields) {
-  return unknown_fields.size();
-}
-
-// Implementation details of ReadPrimitive.
-
-template <>
-inline bool WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_INT32>(
-    io::CodedInputStream* input, int32_t* value) {
-  uint32_t temp;
-  if (!input->ReadVarint32(&temp)) return false;
-  *value = static_cast<int32_t>(temp);
-  return true;
-}
-template <>
-inline bool WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_INT64>(
-    io::CodedInputStream* input, int64_t* value) {
-  uint64_t temp;
-  if (!input->ReadVarint64(&temp)) return false;
-  *value = static_cast<int64_t>(temp);
-  return true;
-}
-template <>
-inline bool
-WireFormatLite::ReadPrimitive<uint32_t, WireFormatLite::TYPE_UINT32>(
-    io::CodedInputStream* input, uint32_t* value) {
-  return input->ReadVarint32(value);
-}
-template <>
-inline bool
-WireFormatLite::ReadPrimitive<uint64_t, WireFormatLite::TYPE_UINT64>(
-    io::CodedInputStream* input, uint64_t* value) {
-  return input->ReadVarint64(value);
-}
-template <>
-inline bool WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_SINT32>(
-    io::CodedInputStream* input, int32_t* value) {
-  uint32_t temp;
-  if (!input->ReadVarint32(&temp)) return false;
-  *value = ZigZagDecode32(temp);
-  return true;
-}
-template <>
-inline bool WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_SINT64>(
-    io::CodedInputStream* input, int64_t* value) {
-  uint64_t temp;
-  if (!input->ReadVarint64(&temp)) return false;
-  *value = ZigZagDecode64(temp);
-  return true;
-}
-template <>
-inline bool
-WireFormatLite::ReadPrimitive<uint32_t, WireFormatLite::TYPE_FIXED32>(
-    io::CodedInputStream* input, uint32_t* value) {
-  return input->ReadLittleEndian32(value);
-}
-template <>
-inline bool
-WireFormatLite::ReadPrimitive<uint64_t, WireFormatLite::TYPE_FIXED64>(
-    io::CodedInputStream* input, uint64_t* value) {
-  return input->ReadLittleEndian64(value);
-}
-template <>
-inline bool
-WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_SFIXED32>(
-    io::CodedInputStream* input, int32_t* value) {
-  uint32_t temp;
-  if (!input->ReadLittleEndian32(&temp)) return false;
-  *value = static_cast<int32_t>(temp);
-  return true;
-}
-template <>
-inline bool
-WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_SFIXED64>(
-    io::CodedInputStream* input, int64_t* value) {
-  uint64_t temp;
-  if (!input->ReadLittleEndian64(&temp)) return false;
-  *value = static_cast<int64_t>(temp);
-  return true;
-}
-template <>
-inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
-    io::CodedInputStream* input, float* value) {
-  uint32_t temp;
-  if (!input->ReadLittleEndian32(&temp)) return false;
-  *value = DecodeFloat(temp);
-  return true;
-}
-template <>
-inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
-    io::CodedInputStream* input, double* value) {
-  uint64_t temp;
-  if (!input->ReadLittleEndian64(&temp)) return false;
-  *value = DecodeDouble(temp);
-  return true;
-}
-template <>
-inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
-    io::CodedInputStream* input, bool* value) {
-  uint64_t temp;
-  if (!input->ReadVarint64(&temp)) return false;
-  *value = temp != 0;
-  return true;
-}
-template <>
-inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
-    io::CodedInputStream* input, int* value) {
-  uint32_t temp;
-  if (!input->ReadVarint32(&temp)) return false;
-  *value = static_cast<int>(temp);
-  return true;
-}
-
-template <>
-inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<uint32_t, WireFormatLite::TYPE_FIXED32>(
-    const uint8_t* buffer, uint32_t* value) {
-  return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
-}
-template <>
-inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<uint64_t, WireFormatLite::TYPE_FIXED64>(
-    const uint8_t* buffer, uint64_t* value) {
-  return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
-}
-template <>
-inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<int32_t, WireFormatLite::TYPE_SFIXED32>(
-    const uint8_t* buffer, int32_t* value) {
-  uint32_t temp;
-  buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
-  *value = static_cast<int32_t>(temp);
-  return buffer;
-}
-template <>
-inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<int64_t, WireFormatLite::TYPE_SFIXED64>(
-    const uint8_t* buffer, int64_t* value) {
-  uint64_t temp;
-  buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
-  *value = static_cast<int64_t>(temp);
-  return buffer;
-}
-template <>
-inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<float, WireFormatLite::TYPE_FLOAT>(
-    const uint8_t* buffer, float* value) {
-  uint32_t temp;
-  buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
-  *value = DecodeFloat(temp);
-  return buffer;
-}
-template <>
-inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<double, WireFormatLite::TYPE_DOUBLE>(
-    const uint8_t* buffer, double* value) {
-  uint64_t temp;
-  buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
-  *value = DecodeDouble(temp);
-  return buffer;
-}
-
-template <typename CType, enum WireFormatLite::FieldType DeclaredType>
-inline bool WireFormatLite::ReadRepeatedPrimitive(
-    int,  // tag_size, unused.
-    uint32_t tag, io::CodedInputStream* input, RepeatedField<CType>* values) {
-  CType value;
-  if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
-  values->Add(value);
-  int elements_already_reserved = values->Capacity() - values->size();
-  while (elements_already_reserved > 0 && input->ExpectTag(tag)) {
-    if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
-    values->AddAlreadyReserved(value);
-    elements_already_reserved--;
-  }
-  return true;
-}
-
-template <typename CType, enum WireFormatLite::FieldType DeclaredType>
-inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
-    int tag_size, uint32_t tag, io::CodedInputStream* input,
-    RepeatedField<CType>* values) {
-  GOOGLE_DCHECK_EQ(UInt32Size(tag), static_cast<size_t>(tag_size));
-  CType value;
-  if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
-  values->Add(value);
-
-  // For fixed size values, repeated values can be read more quickly by
-  // reading directly from a raw array.
-  //
-  // We can get a tight loop by only reading as many elements as can be
-  // added to the RepeatedField without having to do any resizing. Additionally,
-  // we only try to read as many elements as are available from the current
-  // buffer space. Doing so avoids having to perform boundary checks when
-  // reading the value: the maximum number of elements that can be read is
-  // known outside of the loop.
-  const void* void_pointer;
-  int size;
-  input->GetDirectBufferPointerInline(&void_pointer, &size);
-  if (size > 0) {
-    const uint8_t* buffer = reinterpret_cast<const uint8_t*>(void_pointer);
-    // The number of bytes each type occupies on the wire.
-    const int per_value_size = tag_size + static_cast<int>(sizeof(value));
-
-    // parentheses around (std::min) prevents macro expansion of min(...)
-    int elements_available =
-        (std::min)(values->Capacity() - values->size(), size / per_value_size);
-    int num_read = 0;
-    while (num_read < elements_available &&
-           (buffer = io::CodedInputStream::ExpectTagFromArray(buffer, tag)) !=
-               nullptr) {
-      buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
-      values->AddAlreadyReserved(value);
-      ++num_read;
-    }
-    const int read_bytes = num_read * per_value_size;
-    if (read_bytes > 0) {
-      input->Skip(read_bytes);
-    }
-  }
-  return true;
-}
+    static_cast<uint32_t>((static_cast<uint32_t>(FIELD_NUMBER) << 3) | (TYPE))
+
+                // These are the tags for the old MessageSet format, which was defined as:
+                //   message MessageSet {
+                //     repeated group Item = 1 {
+                //       required int32 type_id = 2;
+                //       required string message = 3;
+                //     }
+                //   }
+                static constexpr int kMessageSetItemNumber = 1;
+                static constexpr int kMessageSetTypeIdNumber = 2;
+                static constexpr int kMessageSetMessageNumber = 3;
+                static const int kMessageSetItemStartTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+                    kMessageSetItemNumber, WireFormatLite::WIRETYPE_START_GROUP
+                );
+                static const int kMessageSetItemEndTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+                    kMessageSetItemNumber, WireFormatLite::WIRETYPE_END_GROUP
+                );
+                static const int kMessageSetTypeIdTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+                    kMessageSetTypeIdNumber, WireFormatLite::WIRETYPE_VARINT
+                );
+                static const int kMessageSetMessageTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+                    kMessageSetMessageNumber, WireFormatLite::WIRETYPE_LENGTH_DELIMITED
+                );
+
+                // Byte size of all tags of a MessageSet::Item combined.
+                static const size_t kMessageSetItemTagsSize;
+
+                // Helper functions for converting between floats/doubles and IEEE-754
+                // uint32s/uint64s so that they can be written.  (Assumes your platform
+                // uses IEEE-754 floats.)
+                static uint32_t EncodeFloat(float value);
+                static float DecodeFloat(uint32_t value);
+                static uint64_t EncodeDouble(double value);
+                static double DecodeDouble(uint64_t value);
+
+                // Helper functions for mapping signed integers to unsigned integers in
+                // such a way that numbers with small magnitudes will encode to smaller
+                // varints.  If you simply static_cast a negative number to an unsigned
+                // number and varint-encode it, it will always take 10 bytes, defeating
+                // the purpose of varint.  So, for the "sint32" and "sint64" field types,
+                // we ZigZag-encode the values.
+                static uint32_t ZigZagEncode32(int32_t n);
+                static int32_t ZigZagDecode32(uint32_t n);
+                static uint64_t ZigZagEncode64(int64_t n);
+                static int64_t ZigZagDecode64(uint64_t n);
+
+                // =================================================================
+                // Methods for reading/writing individual field.
+
+                // Read fields, not including tags.  The assumption is that you already
+                // read the tag to determine what field to read.
+
+                // For primitive fields, we just use a templatized routine parameterized by
+                // the represented type and the FieldType. These are specialized with the
+                // appropriate definition for each declared type.
+                template<typename CType, enum FieldType DeclaredType>
+                PROTOBUF_NDEBUG_INLINE static bool ReadPrimitive(io::CodedInputStream* input, CType* value);
+
+                // Reads repeated primitive values, with optimizations for repeats.
+                // tag_size and tag should both be compile-time constants provided by the
+                // protocol compiler.
+                template<typename CType, enum FieldType DeclaredType>
+                PROTOBUF_NDEBUG_INLINE static bool ReadRepeatedPrimitive(
+                    int tag_size, uint32_t tag, io::CodedInputStream* input, RepeatedField<CType>* value
+                );
+
+                // Identical to ReadRepeatedPrimitive, except will not inline the
+                // implementation.
+                template<typename CType, enum FieldType DeclaredType>
+                static bool ReadRepeatedPrimitiveNoInline(int tag_size, uint32_t tag, io::CodedInputStream* input, RepeatedField<CType>* value);
+
+                // Reads a primitive value directly from the provided buffer. It returns a
+                // pointer past the segment of data that was read.
+                //
+                // This is only implemented for the types with fixed wire size, e.g.
+                // float, double, and the (s)fixed* types.
+                template<typename CType, enum FieldType DeclaredType>
+                PROTOBUF_NDEBUG_INLINE static const uint8_t* ReadPrimitiveFromArray(
+                    const uint8_t* buffer, CType* value
+                );
+
+                // Reads a primitive packed field.
+                //
+                // This is only implemented for packable types.
+                template<typename CType, enum FieldType DeclaredType>
+                PROTOBUF_NDEBUG_INLINE static bool ReadPackedPrimitive(
+                    io::CodedInputStream* input, RepeatedField<CType>* value
+                );
+
+                // Identical to ReadPackedPrimitive, except will not inline the
+                // implementation.
+                template<typename CType, enum FieldType DeclaredType>
+                static bool ReadPackedPrimitiveNoInline(io::CodedInputStream* input, RepeatedField<CType>* value);
+
+                // Read a packed enum field. If the is_valid function is not nullptr, values
+                // for which is_valid(value) returns false are silently dropped.
+                static bool ReadPackedEnumNoInline(io::CodedInputStream* input, bool (*is_valid)(int), RepeatedField<int>* values);
+
+                // Read a packed enum field. If the is_valid function is not nullptr, values
+                // for which is_valid(value) returns false are appended to
+                // unknown_fields_stream.
+                static bool ReadPackedEnumPreserveUnknowns(
+                    io::CodedInputStream* input, int field_number, bool (*is_valid)(int), io::CodedOutputStream* unknown_fields_stream, RepeatedField<int>* values
+                );
+
+                // Read a string.  ReadString(..., std::string* value) requires an
+                // existing std::string.
+                static inline bool ReadString(io::CodedInputStream* input, std::string* value);
+                // ReadString(..., std::string** p) is internal-only, and should only be
+                // called from generated code. It starts by setting *p to "new std::string" if
+                // *p == &GetEmptyStringAlreadyInited().  It then invokes
+                // ReadString(io::CodedInputStream* input, *p).  This is useful for reducing
+                // code size.
+                static inline bool ReadString(io::CodedInputStream* input, std::string** p);
+                // Analogous to ReadString().
+                static bool ReadBytes(io::CodedInputStream* input, std::string* value);
+                static bool ReadBytes(io::CodedInputStream* input, std::string** p);
+
+                enum Operation
+                {
+                    PARSE = 0,
+                    SERIALIZE = 1,
+                };
+
+                // Returns true if the data is valid UTF-8.
+                static bool VerifyUtf8String(const char* data, int size, Operation op, const char* field_name);
+
+                template<typename MessageType>
+                static inline bool ReadGroup(int field_number, io::CodedInputStream* input, MessageType* value);
+
+                template<typename MessageType>
+                static inline bool ReadMessage(io::CodedInputStream* input, MessageType* value);
+
+                template<typename MessageType>
+                static inline bool ReadMessageNoVirtual(io::CodedInputStream* input, MessageType* value)
+                {
+                    return ReadMessage(input, value);
+                }
+
+                // Write a tag.  The Write*() functions typically include the tag, so
+                // normally there's no need to call this unless using the Write*NoTag()
+                // variants.
+                PROTOBUF_NDEBUG_INLINE static void WriteTag(int field_number, WireType type, io::CodedOutputStream* output);
+
+                // Write fields, without tags.
+                PROTOBUF_NDEBUG_INLINE static void WriteInt32NoTag(
+                    int32_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteInt64NoTag(
+                    int64_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteUInt32NoTag(
+                    uint32_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteUInt64NoTag(
+                    uint64_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteSInt32NoTag(
+                    int32_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteSInt64NoTag(
+                    int64_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteFixed32NoTag(
+                    uint32_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteFixed64NoTag(
+                    uint64_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteSFixed32NoTag(
+                    int32_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteSFixed64NoTag(
+                    int64_t value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteFloatNoTag(
+                    float value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteDoubleNoTag(
+                    double value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteBoolNoTag(
+                    bool value, io::CodedOutputStream* output
+                );
+                PROTOBUF_NDEBUG_INLINE static void WriteEnumNoTag(
+                    int value, io::CodedOutputStream* output
+                );
+
+                // Write array of primitive fields, without tags
+                static void WriteFloatArray(const float* a, int n, io::CodedOutputStream* output);
+                static void WriteDoubleArray(const double* a, int n, io::CodedOutputStream* output);
+                static void WriteFixed32Array(const uint32_t* a, int n, io::CodedOutputStream* output);
+                static void WriteFixed64Array(const uint64_t* a, int n, io::CodedOutputStream* output);
+                static void WriteSFixed32Array(const int32_t* a, int n, io::CodedOutputStream* output);
+                static void WriteSFixed64Array(const int64_t* a, int n, io::CodedOutputStream* output);
+                static void WriteBoolArray(const bool* a, int n, io::CodedOutputStream* output);
+
+                // Write fields, including tags.
+                static void WriteInt32(int field_number, int32_t value, io::CodedOutputStream* output);
+                static void WriteInt64(int field_number, int64_t value, io::CodedOutputStream* output);
+                static void WriteUInt32(int field_number, uint32_t value, io::CodedOutputStream* output);
+                static void WriteUInt64(int field_number, uint64_t value, io::CodedOutputStream* output);
+                static void WriteSInt32(int field_number, int32_t value, io::CodedOutputStream* output);
+                static void WriteSInt64(int field_number, int64_t value, io::CodedOutputStream* output);
+                static void WriteFixed32(int field_number, uint32_t value, io::CodedOutputStream* output);
+                static void WriteFixed64(int field_number, uint64_t value, io::CodedOutputStream* output);
+                static void WriteSFixed32(int field_number, int32_t value, io::CodedOutputStream* output);
+                static void WriteSFixed64(int field_number, int64_t value, io::CodedOutputStream* output);
+                static void WriteFloat(int field_number, float value, io::CodedOutputStream* output);
+                static void WriteDouble(int field_number, double value, io::CodedOutputStream* output);
+                static void WriteBool(int field_number, bool value, io::CodedOutputStream* output);
+                static void WriteEnum(int field_number, int value, io::CodedOutputStream* output);
+
+                static void WriteString(int field_number, const std::string& value, io::CodedOutputStream* output);
+                static void WriteBytes(int field_number, const std::string& value, io::CodedOutputStream* output);
+                static void WriteStringMaybeAliased(int field_number, const std::string& value, io::CodedOutputStream* output);
+                static void WriteBytesMaybeAliased(int field_number, const std::string& value, io::CodedOutputStream* output);
+
+                static void WriteGroup(int field_number, const MessageLite& value, io::CodedOutputStream* output);
+                static void WriteMessage(int field_number, const MessageLite& value, io::CodedOutputStream* output);
+                // Like above, but these will check if the output stream has enough
+                // space to write directly to a flat array.
+                static void WriteGroupMaybeToArray(int field_number, const MessageLite& value, io::CodedOutputStream* output);
+                static void WriteMessageMaybeToArray(int field_number, const MessageLite& value, io::CodedOutputStream* output);
+
+                // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
+                // pointer must point at an instance of MessageType, *not* a subclass (or
+                // the subclass must not override SerializeWithCachedSizes()).
+                template<typename MessageType>
+                static inline void WriteGroupNoVirtual(int field_number, const MessageType& value, io::CodedOutputStream* output);
+                template<typename MessageType>
+                static inline void WriteMessageNoVirtual(int field_number, const MessageType& value, io::CodedOutputStream* output);
+
+                // Like above, but use only *ToArray methods of CodedOutputStream.
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteTagToArray(int field_number, WireType type, uint8_t* target);
+
+                // Write fields, without tags.
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32NoTagToArray(
+                    int32_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
+                    int64_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32NoTagToArray(
+                    uint32_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
+                    uint64_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32NoTagToArray(
+                    int32_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
+                    int64_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32NoTagToArray(
+                    uint32_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
+                    uint64_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32NoTagToArray(
+                    int32_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
+                    int64_t value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatNoTagToArray(
+                    float value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleNoTagToArray(
+                    double value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolNoTagToArray(bool value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumNoTagToArray(int value, uint8_t* target);
+
+                // Write fields, without tags.  These require that value.size() > 0.
+                template<typename T>
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WritePrimitiveNoTagToArray(
+                    const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*), uint8_t* target
+                );
+                template<typename T>
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixedNoTagToArray(
+                    const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*), uint8_t* target
+                );
+
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32NoTagToArray(
+                    const RepeatedField<int32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
+                    const RepeatedField<int64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32NoTagToArray(
+                    const RepeatedField<uint32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
+                    const RepeatedField<uint64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32NoTagToArray(
+                    const RepeatedField<int32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
+                    const RepeatedField<int64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32NoTagToArray(
+                    const RepeatedField<uint32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
+                    const RepeatedField<uint64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32NoTagToArray(
+                    const RepeatedField<int32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
+                    const RepeatedField<int64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatNoTagToArray(
+                    const RepeatedField<float>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleNoTagToArray(
+                    const RepeatedField<double>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolNoTagToArray(
+                    const RepeatedField<bool>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumNoTagToArray(
+                    const RepeatedField<int>& value, uint8_t* output
+                );
+
+                // Write fields, including tags.
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32ToArray(int field_number, int32_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64ToArray(int field_number, int64_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32ToArray(int field_number, uint32_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64ToArray(int field_number, uint64_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32ToArray(int field_number, int32_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64ToArray(int field_number, int64_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32ToArray(int field_number, uint32_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64ToArray(int field_number, uint64_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32ToArray(int field_number, int32_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64ToArray(int field_number, int64_t value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatToArray(int field_number, float value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleToArray(int field_number, double value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolToArray(int field_number, bool value, uint8_t* target);
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumToArray(int field_number, int value, uint8_t* target);
+
+                template<typename T>
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WritePrimitiveToArray(
+                    int field_number, const RepeatedField<T>& value, uint8_t* (*Writer)(int, T, uint8_t*), uint8_t* target
+                );
+
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32ToArray(
+                    int field_number, const RepeatedField<int32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64ToArray(
+                    int field_number, const RepeatedField<int64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32ToArray(
+                    int field_number, const RepeatedField<uint32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64ToArray(
+                    int field_number, const RepeatedField<uint64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32ToArray(
+                    int field_number, const RepeatedField<int32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64ToArray(
+                    int field_number, const RepeatedField<int64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32ToArray(
+                    int field_number, const RepeatedField<uint32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64ToArray(
+                    int field_number, const RepeatedField<uint64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32ToArray(
+                    int field_number, const RepeatedField<int32_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64ToArray(
+                    int field_number, const RepeatedField<int64_t>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatToArray(
+                    int field_number, const RepeatedField<float>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleToArray(
+                    int field_number, const RepeatedField<double>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBoolToArray(
+                    int field_number, const RepeatedField<bool>& value, uint8_t* output
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteEnumToArray(
+                    int field_number, const RepeatedField<int>& value, uint8_t* output
+                );
+
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteStringToArray(
+                    int field_number, const std::string& value, uint8_t* target
+                );
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteBytesToArray(
+                    int field_number, const std::string& value, uint8_t* target
+                );
+
+                // Whether to serialize deterministically (e.g., map keys are
+                // sorted) is a property of a CodedOutputStream, and in the process
+                // of serialization, the "ToArray" variants may be invoked.  But they don't
+                // have a CodedOutputStream available, so they get an additional parameter
+                // telling them whether to serialize deterministically.
+                static uint8_t* InternalWriteGroup(int field_number, const MessageLite& value, uint8_t* target, io::EpsCopyOutputStream* stream);
+                static uint8_t* InternalWriteMessage(int field_number, const MessageLite& value, int cached_size, uint8_t* target, io::EpsCopyOutputStream* stream);
+
+                // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
+                // pointer must point at an instance of MessageType, *not* a subclass (or
+                // the subclass must not override SerializeWithCachedSizes()).
+                template<typename MessageType>
+                PROTOBUF_NDEBUG_INLINE static uint8_t* InternalWriteGroupNoVirtualToArray(
+                    int field_number, const MessageType& value, uint8_t* target
+                );
+                template<typename MessageType>
+                PROTOBUF_NDEBUG_INLINE static uint8_t* InternalWriteMessageNoVirtualToArray(
+                    int field_number, const MessageType& value, uint8_t* target
+                );
+
+                // For backward-compatibility, the last four methods also have versions
+                // that are non-deterministic always.
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteGroupToArray(
+                    int field_number, const MessageLite& value, uint8_t* target
+                )
+                {
+                    io::EpsCopyOutputStream stream(
+                        target,
+                        value.GetCachedSize() +
+                            static_cast<int>(2 * io::CodedOutputStream::VarintSize32(static_cast<uint32_t>(field_number) << 3)),
+                        io::CodedOutputStream::IsDefaultSerializationDeterministic()
+                    );
+                    return InternalWriteGroup(field_number, value, target, &stream);
+                }
+                PROTOBUF_NDEBUG_INLINE static uint8_t* WriteMessageToArray(
+                    int field_number, const MessageLite& value, uint8_t* target
+                )
+                {
+                    int size = value.GetCachedSize();
+                    io::EpsCopyOutputStream stream(
+                        target,
+                        size + static_cast<int>(io::CodedOutputStream::VarintSize32(static_cast<uint32_t>(field_number) << 3) + io::CodedOutputStream::VarintSize32(size)),
+                        io::CodedOutputStream::IsDefaultSerializationDeterministic()
+                    );
+                    return InternalWriteMessage(field_number, value, value.GetCachedSize(), target, &stream);
+                }
+
+                // Compute the byte size of a field.  The XxSize() functions do NOT include
+                // the tag, so you must also call TagSize().  (This is because, for repeated
+                // fields, you should only call TagSize() once and multiply it by the element
+                // count, but you may have to call XxSize() for each individual element.)
+                static inline size_t Int32Size(int32_t value);
+                static inline size_t Int64Size(int64_t value);
+                static inline size_t UInt32Size(uint32_t value);
+                static inline size_t UInt64Size(uint64_t value);
+                static inline size_t SInt32Size(int32_t value);
+                static inline size_t SInt64Size(int64_t value);
+                static inline size_t EnumSize(int value);
+                static inline size_t Int32SizePlusOne(int32_t value);
+                static inline size_t Int64SizePlusOne(int64_t value);
+                static inline size_t UInt32SizePlusOne(uint32_t value);
+                static inline size_t UInt64SizePlusOne(uint64_t value);
+                static inline size_t SInt32SizePlusOne(int32_t value);
+                static inline size_t SInt64SizePlusOne(int64_t value);
+                static inline size_t EnumSizePlusOne(int value);
+
+                static size_t Int32Size(const RepeatedField<int32_t>& value);
+                static size_t Int64Size(const RepeatedField<int64_t>& value);
+                static size_t UInt32Size(const RepeatedField<uint32_t>& value);
+                static size_t UInt64Size(const RepeatedField<uint64_t>& value);
+                static size_t SInt32Size(const RepeatedField<int32_t>& value);
+                static size_t SInt64Size(const RepeatedField<int64_t>& value);
+                static size_t EnumSize(const RepeatedField<int>& value);
+
+                // These types always have the same size.
+                static constexpr size_t kFixed32Size = 4;
+                static constexpr size_t kFixed64Size = 8;
+                static constexpr size_t kSFixed32Size = 4;
+                static constexpr size_t kSFixed64Size = 8;
+                static constexpr size_t kFloatSize = 4;
+                static constexpr size_t kDoubleSize = 8;
+                static constexpr size_t kBoolSize = 1;
+
+                static inline size_t StringSize(const std::string& value);
+                static inline size_t BytesSize(const std::string& value);
+
+                template<typename MessageType>
+                static inline size_t GroupSize(const MessageType& value);
+                template<typename MessageType>
+                static inline size_t MessageSize(const MessageType& value);
+
+                // Like above, but de-virtualize the call to ByteSize().  The
+                // pointer must point at an instance of MessageType, *not* a subclass (or
+                // the subclass must not override ByteSize()).
+                template<typename MessageType>
+                static inline size_t GroupSizeNoVirtual(const MessageType& value);
+                template<typename MessageType>
+                static inline size_t MessageSizeNoVirtual(const MessageType& value);
+
+                // Given the length of data, calculate the byte size of the data on the
+                // wire if we encode the data as a length delimited field.
+                static inline size_t LengthDelimitedSize(size_t length);
+
+            private:
+                // A helper method for the repeated primitive reader. This method has
+                // optimizations for primitive types that have fixed size on the wire, and
+                // can be read using potentially faster paths.
+                template<typename CType, enum FieldType DeclaredType>
+                PROTOBUF_NDEBUG_INLINE static bool ReadRepeatedFixedSizePrimitive(
+                    int tag_size, uint32_t tag, io::CodedInputStream* input, RepeatedField<CType>* value
+                );
+
+                // Like ReadRepeatedFixedSizePrimitive but for packed primitive fields.
+                template<typename CType, enum FieldType DeclaredType>
+                PROTOBUF_NDEBUG_INLINE static bool ReadPackedFixedSizePrimitive(
+                    io::CodedInputStream* input, RepeatedField<CType>* value
+                );
+
+                static const CppType kFieldTypeToCppTypeMap[];
+                static const WireFormatLite::WireType kWireTypeForFieldType[];
+                static void WriteSubMessageMaybeToArray(int size, const MessageLite& value, io::CodedOutputStream* output);
+
+                GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite);
+            };
+
+            // A class which deals with unknown values.  The default implementation just
+            // discards them.  WireFormat defines a subclass which writes to an
+            // UnknownFieldSet.  This class is used by ExtensionSet::ParseField(), since
+            // ExtensionSet is part of the lite library but UnknownFieldSet is not.
+            class PROTOBUF_EXPORT FieldSkipper
+            {
+            public:
+                FieldSkipper()
+                {
+                }
+                virtual ~FieldSkipper()
+                {
+                }
+
+                // Skip a field whose tag has already been consumed.
+                virtual bool SkipField(io::CodedInputStream* input, uint32_t tag);
+
+                // Skip an entire message or group, up to an end-group tag (which is consumed)
+                // or end-of-stream.
+                virtual bool SkipMessage(io::CodedInputStream* input);
+
+                // Deal with an already-parsed unrecognized enum value.  The default
+                // implementation does nothing, but the UnknownFieldSet-based implementation
+                // saves it as an unknown varint.
+                virtual void SkipUnknownEnum(int field_number, int value);
+            };
+
+            // Subclass of FieldSkipper which saves skipped fields to a CodedOutputStream.
+
+            class PROTOBUF_EXPORT CodedOutputStreamFieldSkipper : public FieldSkipper
+            {
+            public:
+                explicit CodedOutputStreamFieldSkipper(io::CodedOutputStream* unknown_fields) :
+                    unknown_fields_(unknown_fields)
+                {
+                }
+                ~CodedOutputStreamFieldSkipper() override
+                {
+                }
+
+                // implements FieldSkipper -----------------------------------------
+                bool SkipField(io::CodedInputStream* input, uint32_t tag) override;
+                bool SkipMessage(io::CodedInputStream* input) override;
+                void SkipUnknownEnum(int field_number, int value) override;
+
+            protected:
+                io::CodedOutputStream* unknown_fields_;
+            };
+
+            // inline methods ====================================================
+
+            inline WireFormatLite::CppType WireFormatLite::FieldTypeToCppType(
+                FieldType type
+            )
+            {
+                return kFieldTypeToCppTypeMap[type];
+            }
+
+            constexpr inline uint32_t WireFormatLite::MakeTag(int field_number, WireType type)
+            {
+                return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
+            }
+
+            inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32_t tag)
+            {
+                return static_cast<WireType>(tag & kTagTypeMask);
+            }
+
+            inline int WireFormatLite::GetTagFieldNumber(uint32_t tag)
+            {
+                return static_cast<int>(tag >> kTagTypeBits);
+            }
+
+            inline size_t WireFormatLite::TagSize(int field_number, WireFormatLite::FieldType type)
+            {
+                size_t result = io::CodedOutputStream::VarintSize32(
+                    static_cast<uint32_t>(field_number << kTagTypeBits)
+                );
+                if (type == TYPE_GROUP)
+                {
+                    // Groups have both a start and an end tag.
+                    return result * 2;
+                }
+                else
+                {
+                    return result;
+                }
+            }
+
+            inline uint32_t WireFormatLite::EncodeFloat(float value)
+            {
+                return bit_cast<uint32_t>(value);
+            }
+
+            inline float WireFormatLite::DecodeFloat(uint32_t value)
+            {
+                return bit_cast<float>(value);
+            }
+
+            inline uint64_t WireFormatLite::EncodeDouble(double value)
+            {
+                return bit_cast<uint64_t>(value);
+            }
+
+            inline double WireFormatLite::DecodeDouble(uint64_t value)
+            {
+                return bit_cast<double>(value);
+            }
+
+            // ZigZag Transform:  Encodes signed integers so that they can be
+            // effectively used with varint encoding.
+            //
+            // varint operates on unsigned integers, encoding smaller numbers into
+            // fewer bytes.  If you try to use it on a signed integer, it will treat
+            // this number as a very large unsigned integer, which means that even
+            // small signed numbers like -1 will take the maximum number of bytes
+            // (10) to encode.  ZigZagEncode() maps signed integers to unsigned
+            // in such a way that those with a small absolute value will have smaller
+            // encoded values, making them appropriate for encoding using varint.
+            //
+            //       int32_t ->     uint32_t
+            // -------------------------
+            //           0 ->          0
+            //          -1 ->          1
+            //           1 ->          2
+            //          -2 ->          3
+            //         ... ->        ...
+            //  2147483647 -> 4294967294
+            // -2147483648 -> 4294967295
+            //
+            //        >> encode >>
+            //        << decode <<
+
+            inline uint32_t WireFormatLite::ZigZagEncode32(int32_t n)
+            {
+                // Note:  the right-shift must be arithmetic
+                // Note:  left shift must be unsigned because of overflow
+                return (static_cast<uint32_t>(n) << 1) ^ static_cast<uint32_t>(n >> 31);
+            }
+
+            inline int32_t WireFormatLite::ZigZagDecode32(uint32_t n)
+            {
+                // Note:  Using unsigned types prevent undefined behavior
+                return static_cast<int32_t>((n >> 1) ^ (~(n & 1) + 1));
+            }
+
+            inline uint64_t WireFormatLite::ZigZagEncode64(int64_t n)
+            {
+                // Note:  the right-shift must be arithmetic
+                // Note:  left shift must be unsigned because of overflow
+                return (static_cast<uint64_t>(n) << 1) ^ static_cast<uint64_t>(n >> 63);
+            }
+
+            inline int64_t WireFormatLite::ZigZagDecode64(uint64_t n)
+            {
+                // Note:  Using unsigned types prevent undefined behavior
+                return static_cast<int64_t>((n >> 1) ^ (~(n & 1) + 1));
+            }
+
+            // String is for UTF-8 text only, but, even so, ReadString() can simply
+            // call ReadBytes().
+
+            inline bool WireFormatLite::ReadString(io::CodedInputStream* input, std::string* value)
+            {
+                return ReadBytes(input, value);
+            }
+
+            inline bool WireFormatLite::ReadString(io::CodedInputStream* input, std::string** p)
+            {
+                return ReadBytes(input, p);
+            }
+
+            inline uint8_t* InternalSerializeUnknownMessageSetItemsToArray(
+                const std::string& unknown_fields, uint8_t* target, io::EpsCopyOutputStream* stream
+            )
+            {
+                return stream->WriteRaw(unknown_fields.data(), static_cast<int>(unknown_fields.size()), target);
+            }
+
+            inline size_t ComputeUnknownMessageSetItemsSize(
+                const std::string& unknown_fields
+            )
+            {
+                return unknown_fields.size();
+            }
+
+            // Implementation details of ReadPrimitive.
+
+            template<>
+            inline bool WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_INT32>(
+                io::CodedInputStream* input, int32_t* value
+            )
+            {
+                uint32_t temp;
+                if (!input->ReadVarint32(&temp))
+                    return false;
+                *value = static_cast<int32_t>(temp);
+                return true;
+            }
+            template<>
+            inline bool WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_INT64>(
+                io::CodedInputStream* input, int64_t* value
+            )
+            {
+                uint64_t temp;
+                if (!input->ReadVarint64(&temp))
+                    return false;
+                *value = static_cast<int64_t>(temp);
+                return true;
+            }
+            template<>
+            inline bool
+                WireFormatLite::ReadPrimitive<uint32_t, WireFormatLite::TYPE_UINT32>(
+                    io::CodedInputStream* input, uint32_t* value
+                )
+            {
+                return input->ReadVarint32(value);
+            }
+            template<>
+            inline bool
+                WireFormatLite::ReadPrimitive<uint64_t, WireFormatLite::TYPE_UINT64>(
+                    io::CodedInputStream* input, uint64_t* value
+                )
+            {
+                return input->ReadVarint64(value);
+            }
+            template<>
+            inline bool WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_SINT32>(
+                io::CodedInputStream* input, int32_t* value
+            )
+            {
+                uint32_t temp;
+                if (!input->ReadVarint32(&temp))
+                    return false;
+                *value = ZigZagDecode32(temp);
+                return true;
+            }
+            template<>
+            inline bool WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_SINT64>(
+                io::CodedInputStream* input, int64_t* value
+            )
+            {
+                uint64_t temp;
+                if (!input->ReadVarint64(&temp))
+                    return false;
+                *value = ZigZagDecode64(temp);
+                return true;
+            }
+            template<>
+            inline bool
+                WireFormatLite::ReadPrimitive<uint32_t, WireFormatLite::TYPE_FIXED32>(
+                    io::CodedInputStream* input, uint32_t* value
+                )
+            {
+                return input->ReadLittleEndian32(value);
+            }
+            template<>
+            inline bool
+                WireFormatLite::ReadPrimitive<uint64_t, WireFormatLite::TYPE_FIXED64>(
+                    io::CodedInputStream* input, uint64_t* value
+                )
+            {
+                return input->ReadLittleEndian64(value);
+            }
+            template<>
+            inline bool
+                WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_SFIXED32>(
+                    io::CodedInputStream* input, int32_t* value
+                )
+            {
+                uint32_t temp;
+                if (!input->ReadLittleEndian32(&temp))
+                    return false;
+                *value = static_cast<int32_t>(temp);
+                return true;
+            }
+            template<>
+            inline bool
+                WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_SFIXED64>(
+                    io::CodedInputStream* input, int64_t* value
+                )
+            {
+                uint64_t temp;
+                if (!input->ReadLittleEndian64(&temp))
+                    return false;
+                *value = static_cast<int64_t>(temp);
+                return true;
+            }
+            template<>
+            inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
+                io::CodedInputStream* input, float* value
+            )
+            {
+                uint32_t temp;
+                if (!input->ReadLittleEndian32(&temp))
+                    return false;
+                *value = DecodeFloat(temp);
+                return true;
+            }
+            template<>
+            inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
+                io::CodedInputStream* input, double* value
+            )
+            {
+                uint64_t temp;
+                if (!input->ReadLittleEndian64(&temp))
+                    return false;
+                *value = DecodeDouble(temp);
+                return true;
+            }
+            template<>
+            inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
+                io::CodedInputStream* input, bool* value
+            )
+            {
+                uint64_t temp;
+                if (!input->ReadVarint64(&temp))
+                    return false;
+                *value = temp != 0;
+                return true;
+            }
+            template<>
+            inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
+                io::CodedInputStream* input, int* value
+            )
+            {
+                uint32_t temp;
+                if (!input->ReadVarint32(&temp))
+                    return false;
+                *value = static_cast<int>(temp);
+                return true;
+            }
+
+            template<>
+            inline const uint8_t*
+                WireFormatLite::ReadPrimitiveFromArray<uint32_t, WireFormatLite::TYPE_FIXED32>(
+                    const uint8_t* buffer, uint32_t* value
+                )
+            {
+                return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
+            }
+            template<>
+            inline const uint8_t*
+                WireFormatLite::ReadPrimitiveFromArray<uint64_t, WireFormatLite::TYPE_FIXED64>(
+                    const uint8_t* buffer, uint64_t* value
+                )
+            {
+                return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
+            }
+            template<>
+            inline const uint8_t*
+                WireFormatLite::ReadPrimitiveFromArray<int32_t, WireFormatLite::TYPE_SFIXED32>(
+                    const uint8_t* buffer, int32_t* value
+                )
+            {
+                uint32_t temp;
+                buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
+                *value = static_cast<int32_t>(temp);
+                return buffer;
+            }
+            template<>
+            inline const uint8_t*
+                WireFormatLite::ReadPrimitiveFromArray<int64_t, WireFormatLite::TYPE_SFIXED64>(
+                    const uint8_t* buffer, int64_t* value
+                )
+            {
+                uint64_t temp;
+                buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
+                *value = static_cast<int64_t>(temp);
+                return buffer;
+            }
+            template<>
+            inline const uint8_t*
+                WireFormatLite::ReadPrimitiveFromArray<float, WireFormatLite::TYPE_FLOAT>(
+                    const uint8_t* buffer, float* value
+                )
+            {
+                uint32_t temp;
+                buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
+                *value = DecodeFloat(temp);
+                return buffer;
+            }
+            template<>
+            inline const uint8_t*
+                WireFormatLite::ReadPrimitiveFromArray<double, WireFormatLite::TYPE_DOUBLE>(
+                    const uint8_t* buffer, double* value
+                )
+            {
+                uint64_t temp;
+                buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
+                *value = DecodeDouble(temp);
+                return buffer;
+            }
+
+            template<typename CType, enum WireFormatLite::FieldType DeclaredType>
+            inline bool WireFormatLite::ReadRepeatedPrimitive(
+                int,  // tag_size, unused.
+                uint32_t tag,
+                io::CodedInputStream* input,
+                RepeatedField<CType>* values
+            )
+            {
+                CType value;
+                if (!ReadPrimitive<CType, DeclaredType>(input, &value))
+                    return false;
+                values->Add(value);
+                int elements_already_reserved = values->Capacity() - values->size();
+                while (elements_already_reserved > 0 && input->ExpectTag(tag))
+                {
+                    if (!ReadPrimitive<CType, DeclaredType>(input, &value))
+                        return false;
+                    values->AddAlreadyReserved(value);
+                    elements_already_reserved--;
+                }
+                return true;
+            }
+
+            template<typename CType, enum WireFormatLite::FieldType DeclaredType>
+            inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
+                int tag_size, uint32_t tag, io::CodedInputStream* input, RepeatedField<CType>* values
+            )
+            {
+                GOOGLE_DCHECK_EQ(UInt32Size(tag), static_cast<size_t>(tag_size));
+                CType value;
+                if (!ReadPrimitive<CType, DeclaredType>(input, &value))
+                    return false;
+                values->Add(value);
+
+                // For fixed size values, repeated values can be read more quickly by
+                // reading directly from a raw array.
+                //
+                // We can get a tight loop by only reading as many elements as can be
+                // added to the RepeatedField without having to do any resizing. Additionally,
+                // we only try to read as many elements as are available from the current
+                // buffer space. Doing so avoids having to perform boundary checks when
+                // reading the value: the maximum number of elements that can be read is
+                // known outside of the loop.
+                const void* void_pointer;
+                int size;
+                input->GetDirectBufferPointerInline(&void_pointer, &size);
+                if (size > 0)
+                {
+                    const uint8_t* buffer = reinterpret_cast<const uint8_t*>(void_pointer);
+                    // The number of bytes each type occupies on the wire.
+                    const int per_value_size = tag_size + static_cast<int>(sizeof(value));
+
+                    // parentheses around (std::min) prevents macro expansion of min(...)
+                    int elements_available =
+                        (std::min)(values->Capacity() - values->size(), size / per_value_size);
+                    int num_read = 0;
+                    while (num_read < elements_available &&
+                           (buffer = io::CodedInputStream::ExpectTagFromArray(buffer, tag)) !=
+                               nullptr)
+                    {
+                        buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
+                        values->AddAlreadyReserved(value);
+                        ++num_read;
+                    }
+                    const int read_bytes = num_read * per_value_size;
+                    if (read_bytes > 0)
+                    {
+                        input->Skip(read_bytes);
+                    }
+                }
+                return true;
+            }
 
 // Specializations of ReadRepeatedPrimitive for the fixed size types, which use
 // the optimized code path.
-#define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)        \
-  template <>                                                             \
-  inline bool WireFormatLite::ReadRepeatedPrimitive<                      \
-      CPPTYPE, WireFormatLite::DECLARED_TYPE>(                            \
-      int tag_size, uint32_t tag, io::CodedInputStream* input,            \
-      RepeatedField<CPPTYPE>* values) {                                   \
-    return ReadRepeatedFixedSizePrimitive<CPPTYPE,                        \
-                                          WireFormatLite::DECLARED_TYPE>( \
-        tag_size, tag, input, values);                                    \
-  }
-
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32_t, TYPE_FIXED32)
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64_t, TYPE_FIXED64)
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32_t, TYPE_SFIXED32)
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64_t, TYPE_SFIXED64)
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
+#define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)                              \
+    template<>                                                                                  \
+    inline bool WireFormatLite::ReadRepeatedPrimitive<                                          \
+        CPPTYPE,                                                                                \
+        WireFormatLite::DECLARED_TYPE>(                                                         \
+        int tag_size, uint32_t tag, io::CodedInputStream* input, RepeatedField<CPPTYPE>* values \
+    )                                                                                           \
+    {                                                                                           \
+        return ReadRepeatedFixedSizePrimitive<CPPTYPE, WireFormatLite::DECLARED_TYPE>(          \
+            tag_size, tag, input, values                                                        \
+        );                                                                                      \
+    }
+
+            READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32_t, TYPE_FIXED32)
+            READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64_t, TYPE_FIXED64)
+            READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32_t, TYPE_SFIXED32)
+            READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64_t, TYPE_SFIXED64)
+            READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
+            READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
 
 #undef READ_REPEATED_FIXED_SIZE_PRIMITIVE
 
-template <typename CType, enum WireFormatLite::FieldType DeclaredType>
-bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
-    int tag_size, uint32_t tag, io::CodedInputStream* input,
-    RepeatedField<CType>* value) {
-  return ReadRepeatedPrimitive<CType, DeclaredType>(tag_size, tag, input,
-                                                    value);
-}
-
-template <typename CType, enum WireFormatLite::FieldType DeclaredType>
-inline bool WireFormatLite::ReadPackedPrimitive(io::CodedInputStream* input,
-                                                RepeatedField<CType>* values) {
-  int length;
-  if (!input->ReadVarintSizeAsInt(&length)) return false;
-  io::CodedInputStream::Limit limit = input->PushLimit(length);
-  while (input->BytesUntilLimit() > 0) {
-    CType value;
-    if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
-    values->Add(value);
-  }
-  input->PopLimit(limit);
-  return true;
-}
-
-template <typename CType, enum WireFormatLite::FieldType DeclaredType>
-inline bool WireFormatLite::ReadPackedFixedSizePrimitive(
-    io::CodedInputStream* input, RepeatedField<CType>* values) {
-  int length;
-  if (!input->ReadVarintSizeAsInt(&length)) return false;
-  const int old_entries = values->size();
-  const int new_entries = length / static_cast<int>(sizeof(CType));
-  const int new_bytes = new_entries * static_cast<int>(sizeof(CType));
-  if (new_bytes != length) return false;
-  // We would *like* to pre-allocate the buffer to write into (for
-  // speed), but *must* avoid performing a very large allocation due
-  // to a malicious user-supplied "length" above.  So we have a fast
-  // path that pre-allocates when the "length" is less than a bound.
-  // We determine the bound by calling BytesUntilTotalBytesLimit() and
-  // BytesUntilLimit().  These return -1 to mean "no limit set".
-  // There are four cases:
-  // TotalBytesLimit  Limit
-  // -1               -1     Use slow path.
-  // -1               >= 0   Use fast path if length <= Limit.
-  // >= 0             -1     Use slow path.
-  // >= 0             >= 0   Use fast path if length <= min(both limits).
-  int64_t bytes_limit = input->BytesUntilTotalBytesLimit();
-  if (bytes_limit == -1) {
-    bytes_limit = input->BytesUntilLimit();
-  } else {
-    // parentheses around (std::min) prevents macro expansion of min(...)
-    bytes_limit =
-        (std::min)(bytes_limit, static_cast<int64_t>(input->BytesUntilLimit()));
-  }
-  if (bytes_limit >= new_bytes) {
-    // Fast-path that pre-allocates *values to the final size.
+            template<typename CType, enum WireFormatLite::FieldType DeclaredType>
+            bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
+                int tag_size, uint32_t tag, io::CodedInputStream* input, RepeatedField<CType>* value
+            )
+            {
+                return ReadRepeatedPrimitive<CType, DeclaredType>(tag_size, tag, input, value);
+            }
+
+            template<typename CType, enum WireFormatLite::FieldType DeclaredType>
+            inline bool WireFormatLite::ReadPackedPrimitive(io::CodedInputStream* input, RepeatedField<CType>* values)
+            {
+                int length;
+                if (!input->ReadVarintSizeAsInt(&length))
+                    return false;
+                io::CodedInputStream::Limit limit = input->PushLimit(length);
+                while (input->BytesUntilLimit() > 0)
+                {
+                    CType value;
+                    if (!ReadPrimitive<CType, DeclaredType>(input, &value))
+                        return false;
+                    values->Add(value);
+                }
+                input->PopLimit(limit);
+                return true;
+            }
+
+            template<typename CType, enum WireFormatLite::FieldType DeclaredType>
+            inline bool WireFormatLite::ReadPackedFixedSizePrimitive(
+                io::CodedInputStream* input, RepeatedField<CType>* values
+            )
+            {
+                int length;
+                if (!input->ReadVarintSizeAsInt(&length))
+                    return false;
+                const int old_entries = values->size();
+                const int new_entries = length / static_cast<int>(sizeof(CType));
+                const int new_bytes = new_entries * static_cast<int>(sizeof(CType));
+                if (new_bytes != length)
+                    return false;
+                // We would *like* to pre-allocate the buffer to write into (for
+                // speed), but *must* avoid performing a very large allocation due
+                // to a malicious user-supplied "length" above.  So we have a fast
+                // path that pre-allocates when the "length" is less than a bound.
+                // We determine the bound by calling BytesUntilTotalBytesLimit() and
+                // BytesUntilLimit().  These return -1 to mean "no limit set".
+                // There are four cases:
+                // TotalBytesLimit  Limit
+                // -1               -1     Use slow path.
+                // -1               >= 0   Use fast path if length <= Limit.
+                // >= 0             -1     Use slow path.
+                // >= 0             >= 0   Use fast path if length <= min(both limits).
+                int64_t bytes_limit = input->BytesUntilTotalBytesLimit();
+                if (bytes_limit == -1)
+                {
+                    bytes_limit = input->BytesUntilLimit();
+                }
+                else
+                {
+                    // parentheses around (std::min) prevents macro expansion of min(...)
+                    bytes_limit =
+                        (std::min)(bytes_limit, static_cast<int64_t>(input->BytesUntilLimit()));
+                }
+                if (bytes_limit >= new_bytes)
+                {
+                    // Fast-path that pre-allocates *values to the final size.
 #if defined(PROTOBUF_LITTLE_ENDIAN)
-    values->Resize(old_entries + new_entries, 0);
-    // values->mutable_data() may change after Resize(), so do this after:
-    void* dest = reinterpret_cast<void*>(values->mutable_data() + old_entries);
-    if (!input->ReadRaw(dest, new_bytes)) {
-      values->Truncate(old_entries);
-      return false;
-    }
+                    values->Resize(old_entries + new_entries, 0);
+                    // values->mutable_data() may change after Resize(), so do this after:
+                    void* dest = reinterpret_cast<void*>(values->mutable_data() + old_entries);
+                    if (!input->ReadRaw(dest, new_bytes))
+                    {
+                        values->Truncate(old_entries);
+                        return false;
+                    }
 #else
-    values->Reserve(old_entries + new_entries);
-    CType value;
-    for (int i = 0; i < new_entries; ++i) {
-      if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
-      values->AddAlreadyReserved(value);
-    }
+                    values->Reserve(old_entries + new_entries);
+                    CType value;
+                    for (int i = 0; i < new_entries; ++i)
+                    {
+                        if (!ReadPrimitive<CType, DeclaredType>(input, &value))
+                            return false;
+                        values->AddAlreadyReserved(value);
+                    }
 #endif
-  } else {
-    // This is the slow-path case where "length" may be too large to
-    // safely allocate.  We read as much as we can into *values
-    // without pre-allocating "length" bytes.
-    CType value;
-    for (int i = 0; i < new_entries; ++i) {
-      if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
-      values->Add(value);
-    }
-  }
-  return true;
-}
+                }
+                else
+                {
+                    // This is the slow-path case where "length" may be too large to
+                    // safely allocate.  We read as much as we can into *values
+                    // without pre-allocating "length" bytes.
+                    CType value;
+                    for (int i = 0; i < new_entries; ++i)
+                    {
+                        if (!ReadPrimitive<CType, DeclaredType>(input, &value))
+                            return false;
+                        values->Add(value);
+                    }
+                }
+                return true;
+            }
 
 // Specializations of ReadPackedPrimitive for the fixed size types, which use
 // an optimized code path.
-#define READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)      \
-  template <>                                                                  \
-  inline bool                                                                  \
-  WireFormatLite::ReadPackedPrimitive<CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
-      io::CodedInputStream * input, RepeatedField<CPPTYPE> * values) {         \
-    return ReadPackedFixedSizePrimitive<CPPTYPE,                               \
-                                        WireFormatLite::DECLARED_TYPE>(        \
-        input, values);                                                        \
-  }
-
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint32_t, TYPE_FIXED32)
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint64_t, TYPE_FIXED64)
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int32_t, TYPE_SFIXED32)
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int64_t, TYPE_SFIXED64)
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
+#define READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)            \
+    template<>                                                                       \
+    inline bool                                                                      \
+        WireFormatLite::ReadPackedPrimitive<CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
+            io::CodedInputStream * input, RepeatedField<CPPTYPE> * values            \
+        )                                                                            \
+    {                                                                                \
+        return ReadPackedFixedSizePrimitive<CPPTYPE, WireFormatLite::DECLARED_TYPE>( \
+            input, values                                                            \
+        );                                                                           \
+    }
+
+            READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint32_t, TYPE_FIXED32)
+            READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint64_t, TYPE_FIXED64)
+            READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int32_t, TYPE_SFIXED32)
+            READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int64_t, TYPE_SFIXED64)
+            READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
+            READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
 
 #undef READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE
 
-template <typename CType, enum WireFormatLite::FieldType DeclaredType>
-bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
-                                                 RepeatedField<CType>* values) {
-  return ReadPackedPrimitive<CType, DeclaredType>(input, values);
-}
-
-
-template <typename MessageType>
-inline bool WireFormatLite::ReadGroup(int field_number,
-                                      io::CodedInputStream* input,
-                                      MessageType* value) {
-  if (!input->IncrementRecursionDepth()) return false;
-  if (!value->MergePartialFromCodedStream(input)) return false;
-  input->UnsafeDecrementRecursionDepth();
-  // Make sure the last thing read was an end tag for this group.
-  if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
-    return false;
-  }
-  return true;
-}
-template <typename MessageType>
-inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input,
-                                        MessageType* value) {
-  int length;
-  if (!input->ReadVarintSizeAsInt(&length)) return false;
-  std::pair<io::CodedInputStream::Limit, int> p =
-      input->IncrementRecursionDepthAndPushLimit(length);
-  if (p.second < 0 || !value->MergePartialFromCodedStream(input)) return false;
-  // Make sure that parsing stopped when the limit was hit, not at an endgroup
-  // tag.
-  return input->DecrementRecursionDepthAndPopLimit(p.first);
-}
-
-// ===================================================================
-
-inline void WireFormatLite::WriteTag(int field_number, WireType type,
-                                     io::CodedOutputStream* output) {
-  output->WriteTag(MakeTag(field_number, type));
-}
-
-inline void WireFormatLite::WriteInt32NoTag(int32_t value,
-                                            io::CodedOutputStream* output) {
-  output->WriteVarint32SignExtended(value);
-}
-inline void WireFormatLite::WriteInt64NoTag(int64_t value,
-                                            io::CodedOutputStream* output) {
-  output->WriteVarint64(static_cast<uint64_t>(value));
-}
-inline void WireFormatLite::WriteUInt32NoTag(uint32_t value,
-                                             io::CodedOutputStream* output) {
-  output->WriteVarint32(value);
-}
-inline void WireFormatLite::WriteUInt64NoTag(uint64_t value,
-                                             io::CodedOutputStream* output) {
-  output->WriteVarint64(value);
-}
-inline void WireFormatLite::WriteSInt32NoTag(int32_t value,
-                                             io::CodedOutputStream* output) {
-  output->WriteVarint32(ZigZagEncode32(value));
-}
-inline void WireFormatLite::WriteSInt64NoTag(int64_t value,
-                                             io::CodedOutputStream* output) {
-  output->WriteVarint64(ZigZagEncode64(value));
-}
-inline void WireFormatLite::WriteFixed32NoTag(uint32_t value,
-                                              io::CodedOutputStream* output) {
-  output->WriteLittleEndian32(value);
-}
-inline void WireFormatLite::WriteFixed64NoTag(uint64_t value,
-                                              io::CodedOutputStream* output) {
-  output->WriteLittleEndian64(value);
-}
-inline void WireFormatLite::WriteSFixed32NoTag(int32_t value,
-                                               io::CodedOutputStream* output) {
-  output->WriteLittleEndian32(static_cast<uint32_t>(value));
-}
-inline void WireFormatLite::WriteSFixed64NoTag(int64_t value,
-                                               io::CodedOutputStream* output) {
-  output->WriteLittleEndian64(static_cast<uint64_t>(value));
-}
-inline void WireFormatLite::WriteFloatNoTag(float value,
-                                            io::CodedOutputStream* output) {
-  output->WriteLittleEndian32(EncodeFloat(value));
-}
-inline void WireFormatLite::WriteDoubleNoTag(double value,
-                                             io::CodedOutputStream* output) {
-  output->WriteLittleEndian64(EncodeDouble(value));
-}
-inline void WireFormatLite::WriteBoolNoTag(bool value,
-                                           io::CodedOutputStream* output) {
-  output->WriteVarint32(value ? 1 : 0);
-}
-inline void WireFormatLite::WriteEnumNoTag(int value,
-                                           io::CodedOutputStream* output) {
-  output->WriteVarint32SignExtended(value);
-}
-
-// See comment on ReadGroupNoVirtual to understand the need for this template
-// parameter name.
-template <typename MessageType_WorkAroundCppLookupDefect>
-inline void WireFormatLite::WriteGroupNoVirtual(
-    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
-    io::CodedOutputStream* output) {
-  WriteTag(field_number, WIRETYPE_START_GROUP, output);
-  value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
-  WriteTag(field_number, WIRETYPE_END_GROUP, output);
-}
-template <typename MessageType_WorkAroundCppLookupDefect>
-inline void WireFormatLite::WriteMessageNoVirtual(
-    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
-    io::CodedOutputStream* output) {
-  WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
-  output->WriteVarint32(
-      value.MessageType_WorkAroundCppLookupDefect::GetCachedSize());
-  value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
-}
-
-// ===================================================================
-
-inline uint8_t* WireFormatLite::WriteTagToArray(int field_number, WireType type,
-                                                uint8_t* target) {
-  return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
-                                                target);
-}
-
-inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(int32_t value,
-                                                       uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(int64_t value,
-                                                       uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint64ToArray(
-      static_cast<uint64_t>(value), target);
-}
-inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(uint32_t value,
-                                                        uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint32ToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(uint64_t value,
-                                                        uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint64ToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(int32_t value,
-                                                        uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value),
-                                                     target);
-}
-inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(int64_t value,
-                                                        uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
-                                                     target);
-}
-inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(uint32_t value,
-                                                         uint8_t* target) {
-  return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(uint64_t value,
-                                                         uint8_t* target) {
-  return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(int32_t value,
-                                                          uint8_t* target) {
-  return io::CodedOutputStream::WriteLittleEndian32ToArray(
-      static_cast<uint32_t>(value), target);
-}
-inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(int64_t value,
-                                                          uint8_t* target) {
-  return io::CodedOutputStream::WriteLittleEndian64ToArray(
-      static_cast<uint64_t>(value), target);
-}
-inline uint8_t* WireFormatLite::WriteFloatNoTagToArray(float value,
-                                                       uint8_t* target) {
-  return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
-                                                           target);
-}
-inline uint8_t* WireFormatLite::WriteDoubleNoTagToArray(double value,
-                                                        uint8_t* target) {
-  return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value),
-                                                           target);
-}
-inline uint8_t* WireFormatLite::WriteBoolNoTagToArray(bool value,
-                                                      uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
-}
-inline uint8_t* WireFormatLite::WriteEnumNoTagToArray(int value,
-                                                      uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
-}
-
-template <typename T>
-inline uint8_t* WireFormatLite::WritePrimitiveNoTagToArray(
-    const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*),
-    uint8_t* target) {
-  const int n = value.size();
-  GOOGLE_DCHECK_GT(n, 0);
-
-  const T* ii = value.data();
-  int i = 0;
-  do {
-    target = Writer(ii[i], target);
-  } while (++i < n);
-
-  return target;
-}
-
-template <typename T>
-inline uint8_t* WireFormatLite::WriteFixedNoTagToArray(
-    const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*),
-    uint8_t* target) {
+            template<typename CType, enum WireFormatLite::FieldType DeclaredType>
+            bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input, RepeatedField<CType>* values)
+            {
+                return ReadPackedPrimitive<CType, DeclaredType>(input, values);
+            }
+
+            template<typename MessageType>
+            inline bool WireFormatLite::ReadGroup(int field_number, io::CodedInputStream* input, MessageType* value)
+            {
+                if (!input->IncrementRecursionDepth())
+                    return false;
+                if (!value->MergePartialFromCodedStream(input))
+                    return false;
+                input->UnsafeDecrementRecursionDepth();
+                // Make sure the last thing read was an end tag for this group.
+                if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP)))
+                {
+                    return false;
+                }
+                return true;
+            }
+            template<typename MessageType>
+            inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input, MessageType* value)
+            {
+                int length;
+                if (!input->ReadVarintSizeAsInt(&length))
+                    return false;
+                std::pair<io::CodedInputStream::Limit, int> p =
+                    input->IncrementRecursionDepthAndPushLimit(length);
+                if (p.second < 0 || !value->MergePartialFromCodedStream(input))
+                    return false;
+                // Make sure that parsing stopped when the limit was hit, not at an endgroup
+                // tag.
+                return input->DecrementRecursionDepthAndPopLimit(p.first);
+            }
+
+            // ===================================================================
+
+            inline void WireFormatLite::WriteTag(int field_number, WireType type, io::CodedOutputStream* output)
+            {
+                output->WriteTag(MakeTag(field_number, type));
+            }
+
+            inline void WireFormatLite::WriteInt32NoTag(int32_t value, io::CodedOutputStream* output)
+            {
+                output->WriteVarint32SignExtended(value);
+            }
+            inline void WireFormatLite::WriteInt64NoTag(int64_t value, io::CodedOutputStream* output)
+            {
+                output->WriteVarint64(static_cast<uint64_t>(value));
+            }
+            inline void WireFormatLite::WriteUInt32NoTag(uint32_t value, io::CodedOutputStream* output)
+            {
+                output->WriteVarint32(value);
+            }
+            inline void WireFormatLite::WriteUInt64NoTag(uint64_t value, io::CodedOutputStream* output)
+            {
+                output->WriteVarint64(value);
+            }
+            inline void WireFormatLite::WriteSInt32NoTag(int32_t value, io::CodedOutputStream* output)
+            {
+                output->WriteVarint32(ZigZagEncode32(value));
+            }
+            inline void WireFormatLite::WriteSInt64NoTag(int64_t value, io::CodedOutputStream* output)
+            {
+                output->WriteVarint64(ZigZagEncode64(value));
+            }
+            inline void WireFormatLite::WriteFixed32NoTag(uint32_t value, io::CodedOutputStream* output)
+            {
+                output->WriteLittleEndian32(value);
+            }
+            inline void WireFormatLite::WriteFixed64NoTag(uint64_t value, io::CodedOutputStream* output)
+            {
+                output->WriteLittleEndian64(value);
+            }
+            inline void WireFormatLite::WriteSFixed32NoTag(int32_t value, io::CodedOutputStream* output)
+            {
+                output->WriteLittleEndian32(static_cast<uint32_t>(value));
+            }
+            inline void WireFormatLite::WriteSFixed64NoTag(int64_t value, io::CodedOutputStream* output)
+            {
+                output->WriteLittleEndian64(static_cast<uint64_t>(value));
+            }
+            inline void WireFormatLite::WriteFloatNoTag(float value, io::CodedOutputStream* output)
+            {
+                output->WriteLittleEndian32(EncodeFloat(value));
+            }
+            inline void WireFormatLite::WriteDoubleNoTag(double value, io::CodedOutputStream* output)
+            {
+                output->WriteLittleEndian64(EncodeDouble(value));
+            }
+            inline void WireFormatLite::WriteBoolNoTag(bool value, io::CodedOutputStream* output)
+            {
+                output->WriteVarint32(value ? 1 : 0);
+            }
+            inline void WireFormatLite::WriteEnumNoTag(int value, io::CodedOutputStream* output)
+            {
+                output->WriteVarint32SignExtended(value);
+            }
+
+            // See comment on ReadGroupNoVirtual to understand the need for this template
+            // parameter name.
+            template<typename MessageType_WorkAroundCppLookupDefect>
+            inline void WireFormatLite::WriteGroupNoVirtual(
+                int field_number, const MessageType_WorkAroundCppLookupDefect& value, io::CodedOutputStream* output
+            )
+            {
+                WriteTag(field_number, WIRETYPE_START_GROUP, output);
+                value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
+                WriteTag(field_number, WIRETYPE_END_GROUP, output);
+            }
+            template<typename MessageType_WorkAroundCppLookupDefect>
+            inline void WireFormatLite::WriteMessageNoVirtual(
+                int field_number, const MessageType_WorkAroundCppLookupDefect& value, io::CodedOutputStream* output
+            )
+            {
+                WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
+                output->WriteVarint32(
+                    value.MessageType_WorkAroundCppLookupDefect::GetCachedSize()
+                );
+                value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
+            }
+
+            // ===================================================================
+
+            inline uint8_t* WireFormatLite::WriteTagToArray(int field_number, WireType type, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type), target);
+            }
+
+            inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(int32_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(int64_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteVarint64ToArray(
+                    static_cast<uint64_t>(value), target
+                );
+            }
+            inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(uint32_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteVarint32ToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(uint64_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteVarint64ToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(int32_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value), target);
+            }
+            inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(int64_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value), target);
+            }
+            inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(uint32_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(uint64_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(int32_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteLittleEndian32ToArray(
+                    static_cast<uint32_t>(value), target
+                );
+            }
+            inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(int64_t value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteLittleEndian64ToArray(
+                    static_cast<uint64_t>(value), target
+                );
+            }
+            inline uint8_t* WireFormatLite::WriteFloatNoTagToArray(float value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value), target);
+            }
+            inline uint8_t* WireFormatLite::WriteDoubleNoTagToArray(double value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value), target);
+            }
+            inline uint8_t* WireFormatLite::WriteBoolNoTagToArray(bool value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
+            }
+            inline uint8_t* WireFormatLite::WriteEnumNoTagToArray(int value, uint8_t* target)
+            {
+                return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
+            }
+
+            template<typename T>
+            inline uint8_t* WireFormatLite::WritePrimitiveNoTagToArray(
+                const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*), uint8_t* target
+            )
+            {
+                const int n = value.size();
+                GOOGLE_DCHECK_GT(n, 0);
+
+                const T* ii = value.data();
+                int i = 0;
+                do
+                {
+                    target = Writer(ii[i], target);
+                } while (++i < n);
+
+                return target;
+            }
+
+            template<typename T>
+            inline uint8_t* WireFormatLite::WriteFixedNoTagToArray(
+                const RepeatedField<T>& value, uint8_t* (*Writer)(T, uint8_t*), uint8_t* target
+            )
+            {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
-  (void)Writer;
+                (void)Writer;
 
-  const int n = value.size();
-  GOOGLE_DCHECK_GT(n, 0);
+                const int n = value.size();
+                GOOGLE_DCHECK_GT(n, 0);
 
-  const T* ii = value.data();
-  const int bytes = n * static_cast<int>(sizeof(ii[0]));
-  memcpy(target, ii, static_cast<size_t>(bytes));
-  return target + bytes;
+                const T* ii = value.data();
+                const int bytes = n * static_cast<int>(sizeof(ii[0]));
+                memcpy(target, ii, static_cast<size_t>(bytes));
+                return target + bytes;
 #else
-  return WritePrimitiveNoTagToArray(value, Writer, target);
+                return WritePrimitiveNoTagToArray(value, Writer, target);
 #endif
-}
-
-inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(
-    const RepeatedField<int32_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteInt32NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(
-    const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteInt64NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(
-    const RepeatedField<uint32_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteUInt32NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(
-    const RepeatedField<uint64_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteUInt64NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(
-    const RepeatedField<int32_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteSInt32NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(
-    const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteSInt64NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(
-    const RepeatedField<uint32_t>& value, uint8_t* target) {
-  return WriteFixedNoTagToArray(value, WriteFixed32NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(
-    const RepeatedField<uint64_t>& value, uint8_t* target) {
-  return WriteFixedNoTagToArray(value, WriteFixed64NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(
-    const RepeatedField<int32_t>& value, uint8_t* target) {
-  return WriteFixedNoTagToArray(value, WriteSFixed32NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(
-    const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WriteFixedNoTagToArray(value, WriteSFixed64NoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteFloatNoTagToArray(
-    const RepeatedField<float>& value, uint8_t* target) {
-  return WriteFixedNoTagToArray(value, WriteFloatNoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteDoubleNoTagToArray(
-    const RepeatedField<double>& value, uint8_t* target) {
-  return WriteFixedNoTagToArray(value, WriteDoubleNoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteBoolNoTagToArray(
-    const RepeatedField<bool>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteBoolNoTagToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteEnumNoTagToArray(
-    const RepeatedField<int>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteEnumNoTagToArray, target);
-}
-
-inline uint8_t* WireFormatLite::WriteInt32ToArray(int field_number,
-                                                  int32_t value,
-                                                  uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
-  return WriteInt32NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteInt64ToArray(int field_number,
-                                                  int64_t value,
-                                                  uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
-  return WriteInt64NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteUInt32ToArray(int field_number,
-                                                   uint32_t value,
-                                                   uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
-  return WriteUInt32NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteUInt64ToArray(int field_number,
-                                                   uint64_t value,
-                                                   uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
-  return WriteUInt64NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteSInt32ToArray(int field_number,
-                                                   int32_t value,
-                                                   uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
-  return WriteSInt32NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteSInt64ToArray(int field_number,
-                                                   int64_t value,
-                                                   uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
-  return WriteSInt64NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteFixed32ToArray(int field_number,
-                                                    uint32_t value,
-                                                    uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
-  return WriteFixed32NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteFixed64ToArray(int field_number,
-                                                    uint64_t value,
-                                                    uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
-  return WriteFixed64NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteSFixed32ToArray(int field_number,
-                                                     int32_t value,
-                                                     uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
-  return WriteSFixed32NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteSFixed64ToArray(int field_number,
-                                                     int64_t value,
-                                                     uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
-  return WriteSFixed64NoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteFloatToArray(int field_number, float value,
-                                                  uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
-  return WriteFloatNoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteDoubleToArray(int field_number,
-                                                   double value,
-                                                   uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
-  return WriteDoubleNoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteBoolToArray(int field_number, bool value,
-                                                 uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
-  return WriteBoolNoTagToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteEnumToArray(int field_number, int value,
-                                                 uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
-  return WriteEnumNoTagToArray(value, target);
-}
-
-template <typename T>
-inline uint8_t* WireFormatLite::WritePrimitiveToArray(
-    int field_number, const RepeatedField<T>& value,
-    uint8_t* (*Writer)(int, T, uint8_t*), uint8_t* target) {
-  const int n = value.size();
-  if (n == 0) {
-    return target;
-  }
-
-  const T* ii = value.data();
-  int i = 0;
-  do {
-    target = Writer(field_number, ii[i], target);
-  } while (++i < n);
-
-  return target;
-}
-
-inline uint8_t* WireFormatLite::WriteInt32ToArray(
-    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteInt32ToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteInt64ToArray(
-    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteInt64ToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteUInt32ToArray(
-    int field_number, const RepeatedField<uint32_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteUInt32ToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteUInt64ToArray(
-    int field_number, const RepeatedField<uint64_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteUInt64ToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteSInt32ToArray(
-    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteSInt32ToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteSInt64ToArray(
-    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteSInt64ToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteFixed32ToArray(
-    int field_number, const RepeatedField<uint32_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteFixed32ToArray,
-                               target);
-}
-inline uint8_t* WireFormatLite::WriteFixed64ToArray(
-    int field_number, const RepeatedField<uint64_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteFixed64ToArray,
-                               target);
-}
-inline uint8_t* WireFormatLite::WriteSFixed32ToArray(
-    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteSFixed32ToArray,
-                               target);
-}
-inline uint8_t* WireFormatLite::WriteSFixed64ToArray(
-    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteSFixed64ToArray,
-                               target);
-}
-inline uint8_t* WireFormatLite::WriteFloatToArray(
-    int field_number, const RepeatedField<float>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteFloatToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteDoubleToArray(
-    int field_number, const RepeatedField<double>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteDoubleToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteBoolToArray(
-    int field_number, const RepeatedField<bool>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteBoolToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteEnumToArray(
-    int field_number, const RepeatedField<int>& value, uint8_t* target) {
-  return WritePrimitiveToArray(field_number, value, WriteEnumToArray, target);
-}
-inline uint8_t* WireFormatLite::WriteStringToArray(int field_number,
-                                                   const std::string& value,
-                                                   uint8_t* target) {
-  // String is for UTF-8 text only
-  // WARNING:  In wire_format.cc, both strings and bytes are handled by
-  //   WriteString() to avoid code duplication.  If the implementations become
-  //   different, you will need to update that usage.
-  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
-  return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
-}
-inline uint8_t* WireFormatLite::WriteBytesToArray(int field_number,
-                                                  const std::string& value,
-                                                  uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
-  return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
-}
-
-
-// See comment on ReadGroupNoVirtual to understand the need for this template
-// parameter name.
-template <typename MessageType_WorkAroundCppLookupDefect>
-inline uint8_t* WireFormatLite::InternalWriteGroupNoVirtualToArray(
-    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
-    uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
-  target = value.MessageType_WorkAroundCppLookupDefect::
-               SerializeWithCachedSizesToArray(target);
-  return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
-}
-template <typename MessageType_WorkAroundCppLookupDefect>
-inline uint8_t* WireFormatLite::InternalWriteMessageNoVirtualToArray(
-    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
-    uint8_t* target) {
-  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
-  target = io::CodedOutputStream::WriteVarint32ToArray(
-      static_cast<uint32_t>(
-          value.MessageType_WorkAroundCppLookupDefect::GetCachedSize()),
-      target);
-  return value
-      .MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizesToArray(
-          target);
-}
-
-// ===================================================================
-
-inline size_t WireFormatLite::Int32Size(int32_t value) {
-  return io::CodedOutputStream::VarintSize32SignExtended(value);
-}
-inline size_t WireFormatLite::Int64Size(int64_t value) {
-  return io::CodedOutputStream::VarintSize64(static_cast<uint64_t>(value));
-}
-inline size_t WireFormatLite::UInt32Size(uint32_t value) {
-  return io::CodedOutputStream::VarintSize32(value);
-}
-inline size_t WireFormatLite::UInt64Size(uint64_t value) {
-  return io::CodedOutputStream::VarintSize64(value);
-}
-inline size_t WireFormatLite::SInt32Size(int32_t value) {
-  return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
-}
-inline size_t WireFormatLite::SInt64Size(int64_t value) {
-  return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
-}
-inline size_t WireFormatLite::EnumSize(int value) {
-  return io::CodedOutputStream::VarintSize32SignExtended(value);
-}
-inline size_t WireFormatLite::Int32SizePlusOne(int32_t value) {
-  return io::CodedOutputStream::VarintSize32SignExtendedPlusOne(value);
-}
-inline size_t WireFormatLite::Int64SizePlusOne(int64_t value) {
-  return io::CodedOutputStream::VarintSize64PlusOne(
-      static_cast<uint64_t>(value));
-}
-inline size_t WireFormatLite::UInt32SizePlusOne(uint32_t value) {
-  return io::CodedOutputStream::VarintSize32PlusOne(value);
-}
-inline size_t WireFormatLite::UInt64SizePlusOne(uint64_t value) {
-  return io::CodedOutputStream::VarintSize64PlusOne(value);
-}
-inline size_t WireFormatLite::SInt32SizePlusOne(int32_t value) {
-  return io::CodedOutputStream::VarintSize32PlusOne(ZigZagEncode32(value));
-}
-inline size_t WireFormatLite::SInt64SizePlusOne(int64_t value) {
-  return io::CodedOutputStream::VarintSize64PlusOne(ZigZagEncode64(value));
-}
-inline size_t WireFormatLite::EnumSizePlusOne(int value) {
-  return io::CodedOutputStream::VarintSize32SignExtendedPlusOne(value);
-}
-
-inline size_t WireFormatLite::StringSize(const std::string& value) {
-  return LengthDelimitedSize(value.size());
-}
-inline size_t WireFormatLite::BytesSize(const std::string& value) {
-  return LengthDelimitedSize(value.size());
-}
-
-
-template <typename MessageType>
-inline size_t WireFormatLite::GroupSize(const MessageType& value) {
-  return value.ByteSizeLong();
-}
-template <typename MessageType>
-inline size_t WireFormatLite::MessageSize(const MessageType& value) {
-  return LengthDelimitedSize(value.ByteSizeLong());
-}
-
-// See comment on ReadGroupNoVirtual to understand the need for this template
-// parameter name.
-template <typename MessageType_WorkAroundCppLookupDefect>
-inline size_t WireFormatLite::GroupSizeNoVirtual(
-    const MessageType_WorkAroundCppLookupDefect& value) {
-  return value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong();
-}
-template <typename MessageType_WorkAroundCppLookupDefect>
-inline size_t WireFormatLite::MessageSizeNoVirtual(
-    const MessageType_WorkAroundCppLookupDefect& value) {
-  return LengthDelimitedSize(
-      value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong());
-}
-
-inline size_t WireFormatLite::LengthDelimitedSize(size_t length) {
-  // The static_cast here prevents an error in certain compiler configurations
-  // but is not technically correct--if length is too large to fit in a uint32_t
-  // then it will be silently truncated. We will need to fix this if we ever
-  // decide to start supporting serialized messages greater than 2 GiB in size.
-  return length +
-         io::CodedOutputStream::VarintSize32(static_cast<uint32_t>(length));
-}
-
-template <typename MS>
-bool ParseMessageSetItemImpl(io::CodedInputStream* input, MS ms) {
-  // This method parses a group which should contain two fields:
-  //   required int32 type_id = 2;
-  //   required data message = 3;
-
-  uint32_t last_type_id = 0;
-
-  // If we see message data before the type_id, we'll append it to this so
-  // we can parse it later.
-  std::string message_data;
-
-  enum class State { kNoTag, kHasType, kHasPayload, kDone };
-  State state = State::kNoTag;
-
-  while (true) {
-    const uint32_t tag = input->ReadTagNoLastTag();
-    if (tag == 0) return false;
-
-    switch (tag) {
-      case WireFormatLite::kMessageSetTypeIdTag: {
-        uint32_t type_id;
-        if (!input->ReadVarint32(&type_id)) return false;
-        if (state == State::kNoTag) {
-          last_type_id = type_id;
-          state = State::kHasType;
-        } else if (state == State::kHasPayload) {
-          // We saw some message data before the type_id.  Have to parse it
-          // now.
-          io::CodedInputStream sub_input(
-              reinterpret_cast<const uint8_t*>(message_data.data()),
-              static_cast<int>(message_data.size()));
-          sub_input.SetRecursionLimit(input->RecursionBudget());
-          if (!ms.ParseField(type_id, &sub_input)) {
-            return false;
-          }
-          message_data.clear();
-          state = State::kDone;
-        }
-
-        break;
-      }
-
-      case WireFormatLite::kMessageSetMessageTag: {
-        if (state == State::kHasType) {
-          // Already saw type_id, so we can parse this directly.
-          if (!ms.ParseField(last_type_id, input)) {
-            return false;
-          }
-          state = State::kDone;
-        } else if (state == State::kNoTag) {
-          // We haven't seen a type_id yet.  Append this data to message_data.
-          uint32_t length;
-          if (!input->ReadVarint32(&length)) return false;
-          if (static_cast<int32_t>(length) < 0) return false;
-          uint32_t size = static_cast<uint32_t>(
-              length + io::CodedOutputStream::VarintSize32(length));
-          message_data.resize(size);
-          auto ptr = reinterpret_cast<uint8_t*>(&message_data[0]);
-          ptr = io::CodedOutputStream::WriteVarint32ToArray(length, ptr);
-          if (!input->ReadRaw(ptr, length)) return false;
-          state = State::kHasPayload;
-        } else {
-          if (!ms.SkipField(tag, input)) return false;
-        }
-
-        break;
-      }
-
-      case WireFormatLite::kMessageSetItemEndTag: {
-        return true;
-      }
-
-      default: {
-        if (!ms.SkipField(tag, input)) return false;
-      }
-    }
-  }
-}
-
-}  // namespace internal
-}  // namespace protobuf
+            }
+
+            inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(
+                const RepeatedField<int32_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveNoTagToArray(value, WriteInt32NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(
+                const RepeatedField<int64_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveNoTagToArray(value, WriteInt64NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(
+                const RepeatedField<uint32_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveNoTagToArray(value, WriteUInt32NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(
+                const RepeatedField<uint64_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveNoTagToArray(value, WriteUInt64NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(
+                const RepeatedField<int32_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveNoTagToArray(value, WriteSInt32NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(
+                const RepeatedField<int64_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveNoTagToArray(value, WriteSInt64NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(
+                const RepeatedField<uint32_t>& value, uint8_t* target
+            )
+            {
+                return WriteFixedNoTagToArray(value, WriteFixed32NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(
+                const RepeatedField<uint64_t>& value, uint8_t* target
+            )
+            {
+                return WriteFixedNoTagToArray(value, WriteFixed64NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(
+                const RepeatedField<int32_t>& value, uint8_t* target
+            )
+            {
+                return WriteFixedNoTagToArray(value, WriteSFixed32NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(
+                const RepeatedField<int64_t>& value, uint8_t* target
+            )
+            {
+                return WriteFixedNoTagToArray(value, WriteSFixed64NoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFloatNoTagToArray(
+                const RepeatedField<float>& value, uint8_t* target
+            )
+            {
+                return WriteFixedNoTagToArray(value, WriteFloatNoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteDoubleNoTagToArray(
+                const RepeatedField<double>& value, uint8_t* target
+            )
+            {
+                return WriteFixedNoTagToArray(value, WriteDoubleNoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteBoolNoTagToArray(
+                const RepeatedField<bool>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveNoTagToArray(value, WriteBoolNoTagToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteEnumNoTagToArray(
+                const RepeatedField<int>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveNoTagToArray(value, WriteEnumNoTagToArray, target);
+            }
+
+            inline uint8_t* WireFormatLite::WriteInt32ToArray(int field_number, int32_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+                return WriteInt32NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteInt64ToArray(int field_number, int64_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+                return WriteInt64NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteUInt32ToArray(int field_number, uint32_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+                return WriteUInt32NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteUInt64ToArray(int field_number, uint64_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+                return WriteUInt64NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSInt32ToArray(int field_number, int32_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+                return WriteSInt32NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSInt64ToArray(int field_number, int64_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+                return WriteSInt64NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFixed32ToArray(int field_number, uint32_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+                return WriteFixed32NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFixed64ToArray(int field_number, uint64_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+                return WriteFixed64NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSFixed32ToArray(int field_number, int32_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+                return WriteSFixed32NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSFixed64ToArray(int field_number, int64_t value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+                return WriteSFixed64NoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFloatToArray(int field_number, float value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+                return WriteFloatNoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteDoubleToArray(int field_number, double value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+                return WriteDoubleNoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteBoolToArray(int field_number, bool value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+                return WriteBoolNoTagToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteEnumToArray(int field_number, int value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+                return WriteEnumNoTagToArray(value, target);
+            }
+
+            template<typename T>
+            inline uint8_t* WireFormatLite::WritePrimitiveToArray(
+                int field_number, const RepeatedField<T>& value, uint8_t* (*Writer)(int, T, uint8_t*), uint8_t* target
+            )
+            {
+                const int n = value.size();
+                if (n == 0)
+                {
+                    return target;
+                }
+
+                const T* ii = value.data();
+                int i = 0;
+                do
+                {
+                    target = Writer(field_number, ii[i], target);
+                } while (++i < n);
+
+                return target;
+            }
+
+            inline uint8_t* WireFormatLite::WriteInt32ToArray(
+                int field_number, const RepeatedField<int32_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteInt32ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteInt64ToArray(
+                int field_number, const RepeatedField<int64_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteInt64ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteUInt32ToArray(
+                int field_number, const RepeatedField<uint32_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteUInt32ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteUInt64ToArray(
+                int field_number, const RepeatedField<uint64_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteUInt64ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSInt32ToArray(
+                int field_number, const RepeatedField<int32_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteSInt32ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSInt64ToArray(
+                int field_number, const RepeatedField<int64_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteSInt64ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFixed32ToArray(
+                int field_number, const RepeatedField<uint32_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteFixed32ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFixed64ToArray(
+                int field_number, const RepeatedField<uint64_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteFixed64ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSFixed32ToArray(
+                int field_number, const RepeatedField<int32_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteSFixed32ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteSFixed64ToArray(
+                int field_number, const RepeatedField<int64_t>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteSFixed64ToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteFloatToArray(
+                int field_number, const RepeatedField<float>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteFloatToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteDoubleToArray(
+                int field_number, const RepeatedField<double>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteDoubleToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteBoolToArray(
+                int field_number, const RepeatedField<bool>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteBoolToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteEnumToArray(
+                int field_number, const RepeatedField<int>& value, uint8_t* target
+            )
+            {
+                return WritePrimitiveToArray(field_number, value, WriteEnumToArray, target);
+            }
+            inline uint8_t* WireFormatLite::WriteStringToArray(int field_number, const std::string& value, uint8_t* target)
+            {
+                // String is for UTF-8 text only
+                // WARNING:  In wire_format.cc, both strings and bytes are handled by
+                //   WriteString() to avoid code duplication.  If the implementations become
+                //   different, you will need to update that usage.
+                target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+                return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
+            }
+            inline uint8_t* WireFormatLite::WriteBytesToArray(int field_number, const std::string& value, uint8_t* target)
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+                return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
+            }
+
+            // See comment on ReadGroupNoVirtual to understand the need for this template
+            // parameter name.
+            template<typename MessageType_WorkAroundCppLookupDefect>
+            inline uint8_t* WireFormatLite::InternalWriteGroupNoVirtualToArray(
+                int field_number, const MessageType_WorkAroundCppLookupDefect& value, uint8_t* target
+            )
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
+                target = value.MessageType_WorkAroundCppLookupDefect::
+                             SerializeWithCachedSizesToArray(target);
+                return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
+            }
+            template<typename MessageType_WorkAroundCppLookupDefect>
+            inline uint8_t* WireFormatLite::InternalWriteMessageNoVirtualToArray(
+                int field_number, const MessageType_WorkAroundCppLookupDefect& value, uint8_t* target
+            )
+            {
+                target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+                target = io::CodedOutputStream::WriteVarint32ToArray(
+                    static_cast<uint32_t>(
+                        value.MessageType_WorkAroundCppLookupDefect::GetCachedSize()
+                    ),
+                    target
+                );
+                return value
+                    .MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizesToArray(
+                        target
+                    );
+            }
+
+            // ===================================================================
+
+            inline size_t WireFormatLite::Int32Size(int32_t value)
+            {
+                return io::CodedOutputStream::VarintSize32SignExtended(value);
+            }
+            inline size_t WireFormatLite::Int64Size(int64_t value)
+            {
+                return io::CodedOutputStream::VarintSize64(static_cast<uint64_t>(value));
+            }
+            inline size_t WireFormatLite::UInt32Size(uint32_t value)
+            {
+                return io::CodedOutputStream::VarintSize32(value);
+            }
+            inline size_t WireFormatLite::UInt64Size(uint64_t value)
+            {
+                return io::CodedOutputStream::VarintSize64(value);
+            }
+            inline size_t WireFormatLite::SInt32Size(int32_t value)
+            {
+                return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
+            }
+            inline size_t WireFormatLite::SInt64Size(int64_t value)
+            {
+                return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
+            }
+            inline size_t WireFormatLite::EnumSize(int value)
+            {
+                return io::CodedOutputStream::VarintSize32SignExtended(value);
+            }
+            inline size_t WireFormatLite::Int32SizePlusOne(int32_t value)
+            {
+                return io::CodedOutputStream::VarintSize32SignExtendedPlusOne(value);
+            }
+            inline size_t WireFormatLite::Int64SizePlusOne(int64_t value)
+            {
+                return io::CodedOutputStream::VarintSize64PlusOne(
+                    static_cast<uint64_t>(value)
+                );
+            }
+            inline size_t WireFormatLite::UInt32SizePlusOne(uint32_t value)
+            {
+                return io::CodedOutputStream::VarintSize32PlusOne(value);
+            }
+            inline size_t WireFormatLite::UInt64SizePlusOne(uint64_t value)
+            {
+                return io::CodedOutputStream::VarintSize64PlusOne(value);
+            }
+            inline size_t WireFormatLite::SInt32SizePlusOne(int32_t value)
+            {
+                return io::CodedOutputStream::VarintSize32PlusOne(ZigZagEncode32(value));
+            }
+            inline size_t WireFormatLite::SInt64SizePlusOne(int64_t value)
+            {
+                return io::CodedOutputStream::VarintSize64PlusOne(ZigZagEncode64(value));
+            }
+            inline size_t WireFormatLite::EnumSizePlusOne(int value)
+            {
+                return io::CodedOutputStream::VarintSize32SignExtendedPlusOne(value);
+            }
+
+            inline size_t WireFormatLite::StringSize(const std::string& value)
+            {
+                return LengthDelimitedSize(value.size());
+            }
+            inline size_t WireFormatLite::BytesSize(const std::string& value)
+            {
+                return LengthDelimitedSize(value.size());
+            }
+
+            template<typename MessageType>
+            inline size_t WireFormatLite::GroupSize(const MessageType& value)
+            {
+                return value.ByteSizeLong();
+            }
+            template<typename MessageType>
+            inline size_t WireFormatLite::MessageSize(const MessageType& value)
+            {
+                return LengthDelimitedSize(value.ByteSizeLong());
+            }
+
+            // See comment on ReadGroupNoVirtual to understand the need for this template
+            // parameter name.
+            template<typename MessageType_WorkAroundCppLookupDefect>
+            inline size_t WireFormatLite::GroupSizeNoVirtual(
+                const MessageType_WorkAroundCppLookupDefect& value
+            )
+            {
+                return value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong();
+            }
+            template<typename MessageType_WorkAroundCppLookupDefect>
+            inline size_t WireFormatLite::MessageSizeNoVirtual(
+                const MessageType_WorkAroundCppLookupDefect& value
+            )
+            {
+                return LengthDelimitedSize(
+                    value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong()
+                );
+            }
+
+            inline size_t WireFormatLite::LengthDelimitedSize(size_t length)
+            {
+                // The static_cast here prevents an error in certain compiler configurations
+                // but is not technically correct--if length is too large to fit in a uint32_t
+                // then it will be silently truncated. We will need to fix this if we ever
+                // decide to start supporting serialized messages greater than 2 GiB in size.
+                return length +
+                       io::CodedOutputStream::VarintSize32(static_cast<uint32_t>(length));
+            }
+
+            template<typename MS>
+            bool ParseMessageSetItemImpl(io::CodedInputStream* input, MS ms)
+            {
+                // This method parses a group which should contain two fields:
+                //   required int32 type_id = 2;
+                //   required data message = 3;
+
+                uint32_t last_type_id = 0;
+
+                // If we see message data before the type_id, we'll append it to this so
+                // we can parse it later.
+                std::string message_data;
+
+                enum class State
+                {
+                    kNoTag,
+                    kHasType,
+                    kHasPayload,
+                    kDone
+                };
+                State state = State::kNoTag;
+
+                while (true)
+                {
+                    const uint32_t tag = input->ReadTagNoLastTag();
+                    if (tag == 0)
+                        return false;
+
+                    switch (tag)
+                    {
+                        case WireFormatLite::kMessageSetTypeIdTag:
+                            {
+                                uint32_t type_id;
+                                if (!input->ReadVarint32(&type_id))
+                                    return false;
+                                if (state == State::kNoTag)
+                                {
+                                    last_type_id = type_id;
+                                    state = State::kHasType;
+                                }
+                                else if (state == State::kHasPayload)
+                                {
+                                    // We saw some message data before the type_id.  Have to parse it
+                                    // now.
+                                    io::CodedInputStream sub_input(
+                                        reinterpret_cast<const uint8_t*>(message_data.data()),
+                                        static_cast<int>(message_data.size())
+                                    );
+                                    sub_input.SetRecursionLimit(input->RecursionBudget());
+                                    if (!ms.ParseField(type_id, &sub_input))
+                                    {
+                                        return false;
+                                    }
+                                    message_data.clear();
+                                    state = State::kDone;
+                                }
+
+                                break;
+                            }
+
+                        case WireFormatLite::kMessageSetMessageTag:
+                            {
+                                if (state == State::kHasType)
+                                {
+                                    // Already saw type_id, so we can parse this directly.
+                                    if (!ms.ParseField(last_type_id, input))
+                                    {
+                                        return false;
+                                    }
+                                    state = State::kDone;
+                                }
+                                else if (state == State::kNoTag)
+                                {
+                                    // We haven't seen a type_id yet.  Append this data to message_data.
+                                    uint32_t length;
+                                    if (!input->ReadVarint32(&length))
+                                        return false;
+                                    if (static_cast<int32_t>(length) < 0)
+                                        return false;
+                                    uint32_t size = static_cast<uint32_t>(
+                                        length + io::CodedOutputStream::VarintSize32(length)
+                                    );
+                                    message_data.resize(size);
+                                    auto ptr = reinterpret_cast<uint8_t*>(&message_data[0]);
+                                    ptr = io::CodedOutputStream::WriteVarint32ToArray(length, ptr);
+                                    if (!input->ReadRaw(ptr, length))
+                                        return false;
+                                    state = State::kHasPayload;
+                                }
+                                else
+                                {
+                                    if (!ms.SkipField(tag, input))
+                                        return false;
+                                }
+
+                                break;
+                            }
+
+                        case WireFormatLite::kMessageSetItemEndTag:
+                            {
+                                return true;
+                            }
+
+                        default:
+                            {
+                                if (!ms.SkipField(tag, input))
+                                    return false;
+                            }
+                    }
+                }
+            }
+
+        }  // namespace internal
+    }      // namespace protobuf
 }  // namespace google
 
 #include <google/protobuf/port_undef.inc>
diff --git a/CAPI/cpp/grpc/include/google/protobuf/wrappers.pb.h b/CAPI/cpp/grpc/include/google/protobuf/wrappers.pb.h
index cc42a8b..9a882c7 100644
--- a/CAPI/cpp/grpc/include/google/protobuf/wrappers.pb.h
+++ b/CAPI/cpp/grpc/include/google/protobuf/wrappers.pb.h
@@ -28,20 +28,22 @@
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
-#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>   // IWYU pragma: export
 #include <google/protobuf/unknown_field_set.h>
 // @@protoc_insertion_point(includes)
 #include <google/protobuf/port_def.inc>
 #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2fwrappers_2eproto PROTOBUF_EXPORT
 PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
+namespace internal
+{
+    class AnyMetadata;
 }  // namespace internal
 PROTOBUF_NAMESPACE_CLOSE
 
 // Internal implementation detail -- do not use these members.
-struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fwrappers_2eproto {
-  static const uint32_t offsets[];
+struct PROTOBUF_EXPORT TableStruct_google_2fprotobuf_2fwrappers_2eproto
+{
+    static const uint32_t offsets[];
 };
 PROTOBUF_EXPORT extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2fwrappers_2eproto;
 PROTOBUF_NAMESPACE_OPEN
@@ -74,1389 +76,1797 @@ struct UInt64ValueDefaultTypeInternal;
 PROTOBUF_EXPORT extern UInt64ValueDefaultTypeInternal _UInt64Value_default_instance_;
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::BoolValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::BytesValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BytesValue>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DoubleValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DoubleValue>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FloatValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FloatValue>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Int32Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Int32Value>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Int64Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Int64Value>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::StringValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::StringValue>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UInt32Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt32Value>(Arena*);
-template<> PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UInt64Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt64Value>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::BoolValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BoolValue>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::BytesValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::BytesValue>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::DoubleValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::DoubleValue>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::FloatValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::FloatValue>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Int32Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Int32Value>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::Int64Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Int64Value>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::StringValue* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::StringValue>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UInt32Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt32Value>(Arena*);
+template<>
+PROTOBUF_EXPORT ::PROTOBUF_NAMESPACE_ID::UInt64Value* Arena::CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::UInt64Value>(Arena*);
 PROTOBUF_NAMESPACE_CLOSE
 PROTOBUF_NAMESPACE_OPEN
 
 // ===================================================================
 
 class PROTOBUF_EXPORT DoubleValue final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DoubleValue) */ {
- public:
-  inline DoubleValue() : DoubleValue(nullptr) {}
-  ~DoubleValue() override;
-  explicit PROTOBUF_CONSTEXPR DoubleValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  DoubleValue(const DoubleValue& from);
-  DoubleValue(DoubleValue&& from) noexcept
-    : DoubleValue() {
-    *this = ::std::move(from);
-  }
-
-  inline DoubleValue& operator=(const DoubleValue& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline DoubleValue& operator=(DoubleValue&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const DoubleValue& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const DoubleValue* internal_default_instance() {
-    return reinterpret_cast<const DoubleValue*>(
-               &_DoubleValue_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    0;
-
-  friend void swap(DoubleValue& a, DoubleValue& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(DoubleValue* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(DoubleValue* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  DoubleValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<DoubleValue>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const DoubleValue& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const DoubleValue& from) {
-    DoubleValue::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(DoubleValue* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.DoubleValue";
-  }
-  protected:
-  explicit DoubleValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // double value = 1;
-  void clear_value();
-  double value() const;
-  void set_value(double value);
-  private:
-  double _internal_value() const;
-  void _internal_set_value(double value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.DoubleValue)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    double value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DoubleValue) */
+{
+public:
+    inline DoubleValue() :
+        DoubleValue(nullptr)
+    {
+    }
+    ~DoubleValue() override;
+    explicit PROTOBUF_CONSTEXPR DoubleValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    DoubleValue(const DoubleValue& from);
+    DoubleValue(DoubleValue&& from) noexcept
+        :
+        DoubleValue()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline DoubleValue& operator=(const DoubleValue& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline DoubleValue& operator=(DoubleValue&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const DoubleValue& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const DoubleValue* internal_default_instance()
+    {
+        return reinterpret_cast<const DoubleValue*>(
+            &_DoubleValue_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        0;
+
+    friend void swap(DoubleValue& a, DoubleValue& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(DoubleValue* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(DoubleValue* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    DoubleValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<DoubleValue>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const DoubleValue& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const DoubleValue& from)
+    {
+        DoubleValue::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(DoubleValue* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.DoubleValue";
+    }
+
+protected:
+    explicit DoubleValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // double value = 1;
+    void clear_value();
+    double value() const;
+    void set_value(double value);
+
+private:
+    double _internal_value() const;
+    void _internal_set_value(double value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.DoubleValue)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        double value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT FloatValue final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FloatValue) */ {
- public:
-  inline FloatValue() : FloatValue(nullptr) {}
-  ~FloatValue() override;
-  explicit PROTOBUF_CONSTEXPR FloatValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  FloatValue(const FloatValue& from);
-  FloatValue(FloatValue&& from) noexcept
-    : FloatValue() {
-    *this = ::std::move(from);
-  }
-
-  inline FloatValue& operator=(const FloatValue& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline FloatValue& operator=(FloatValue&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const FloatValue& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const FloatValue* internal_default_instance() {
-    return reinterpret_cast<const FloatValue*>(
-               &_FloatValue_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    1;
-
-  friend void swap(FloatValue& a, FloatValue& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(FloatValue* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(FloatValue* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  FloatValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<FloatValue>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const FloatValue& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const FloatValue& from) {
-    FloatValue::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(FloatValue* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.FloatValue";
-  }
-  protected:
-  explicit FloatValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // float value = 1;
-  void clear_value();
-  float value() const;
-  void set_value(float value);
-  private:
-  float _internal_value() const;
-  void _internal_set_value(float value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.FloatValue)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    float value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FloatValue) */
+{
+public:
+    inline FloatValue() :
+        FloatValue(nullptr)
+    {
+    }
+    ~FloatValue() override;
+    explicit PROTOBUF_CONSTEXPR FloatValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    FloatValue(const FloatValue& from);
+    FloatValue(FloatValue&& from) noexcept
+        :
+        FloatValue()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline FloatValue& operator=(const FloatValue& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline FloatValue& operator=(FloatValue&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const FloatValue& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const FloatValue* internal_default_instance()
+    {
+        return reinterpret_cast<const FloatValue*>(
+            &_FloatValue_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        1;
+
+    friend void swap(FloatValue& a, FloatValue& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(FloatValue* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(FloatValue* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    FloatValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<FloatValue>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const FloatValue& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const FloatValue& from)
+    {
+        FloatValue::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(FloatValue* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.FloatValue";
+    }
+
+protected:
+    explicit FloatValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // float value = 1;
+    void clear_value();
+    float value() const;
+    void set_value(float value);
+
+private:
+    float _internal_value() const;
+    void _internal_set_value(float value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.FloatValue)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        float value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Int64Value final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int64Value) */ {
- public:
-  inline Int64Value() : Int64Value(nullptr) {}
-  ~Int64Value() override;
-  explicit PROTOBUF_CONSTEXPR Int64Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Int64Value(const Int64Value& from);
-  Int64Value(Int64Value&& from) noexcept
-    : Int64Value() {
-    *this = ::std::move(from);
-  }
-
-  inline Int64Value& operator=(const Int64Value& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Int64Value& operator=(Int64Value&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Int64Value& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Int64Value* internal_default_instance() {
-    return reinterpret_cast<const Int64Value*>(
-               &_Int64Value_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    2;
-
-  friend void swap(Int64Value& a, Int64Value& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Int64Value* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Int64Value* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Int64Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Int64Value>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Int64Value& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Int64Value& from) {
-    Int64Value::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Int64Value* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Int64Value";
-  }
-  protected:
-  explicit Int64Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // int64 value = 1;
-  void clear_value();
-  int64_t value() const;
-  void set_value(int64_t value);
-  private:
-  int64_t _internal_value() const;
-  void _internal_set_value(int64_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Int64Value)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    int64_t value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int64Value) */
+{
+public:
+    inline Int64Value() :
+        Int64Value(nullptr)
+    {
+    }
+    ~Int64Value() override;
+    explicit PROTOBUF_CONSTEXPR Int64Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Int64Value(const Int64Value& from);
+    Int64Value(Int64Value&& from) noexcept
+        :
+        Int64Value()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Int64Value& operator=(const Int64Value& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Int64Value& operator=(Int64Value&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Int64Value& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Int64Value* internal_default_instance()
+    {
+        return reinterpret_cast<const Int64Value*>(
+            &_Int64Value_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        2;
+
+    friend void swap(Int64Value& a, Int64Value& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Int64Value* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Int64Value* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Int64Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Int64Value>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Int64Value& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Int64Value& from)
+    {
+        Int64Value::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Int64Value* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Int64Value";
+    }
+
+protected:
+    explicit Int64Value(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // int64 value = 1;
+    void clear_value();
+    int64_t value() const;
+    void set_value(int64_t value);
+
+private:
+    int64_t _internal_value() const;
+    void _internal_set_value(int64_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Int64Value)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        int64_t value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT UInt64Value final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt64Value) */ {
- public:
-  inline UInt64Value() : UInt64Value(nullptr) {}
-  ~UInt64Value() override;
-  explicit PROTOBUF_CONSTEXPR UInt64Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  UInt64Value(const UInt64Value& from);
-  UInt64Value(UInt64Value&& from) noexcept
-    : UInt64Value() {
-    *this = ::std::move(from);
-  }
-
-  inline UInt64Value& operator=(const UInt64Value& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline UInt64Value& operator=(UInt64Value&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const UInt64Value& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const UInt64Value* internal_default_instance() {
-    return reinterpret_cast<const UInt64Value*>(
-               &_UInt64Value_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    3;
-
-  friend void swap(UInt64Value& a, UInt64Value& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(UInt64Value* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(UInt64Value* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  UInt64Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<UInt64Value>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const UInt64Value& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const UInt64Value& from) {
-    UInt64Value::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(UInt64Value* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.UInt64Value";
-  }
-  protected:
-  explicit UInt64Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // uint64 value = 1;
-  void clear_value();
-  uint64_t value() const;
-  void set_value(uint64_t value);
-  private:
-  uint64_t _internal_value() const;
-  void _internal_set_value(uint64_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.UInt64Value)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    uint64_t value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt64Value) */
+{
+public:
+    inline UInt64Value() :
+        UInt64Value(nullptr)
+    {
+    }
+    ~UInt64Value() override;
+    explicit PROTOBUF_CONSTEXPR UInt64Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    UInt64Value(const UInt64Value& from);
+    UInt64Value(UInt64Value&& from) noexcept
+        :
+        UInt64Value()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline UInt64Value& operator=(const UInt64Value& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline UInt64Value& operator=(UInt64Value&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const UInt64Value& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const UInt64Value* internal_default_instance()
+    {
+        return reinterpret_cast<const UInt64Value*>(
+            &_UInt64Value_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        3;
+
+    friend void swap(UInt64Value& a, UInt64Value& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(UInt64Value* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(UInt64Value* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    UInt64Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<UInt64Value>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const UInt64Value& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const UInt64Value& from)
+    {
+        UInt64Value::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(UInt64Value* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.UInt64Value";
+    }
+
+protected:
+    explicit UInt64Value(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // uint64 value = 1;
+    void clear_value();
+    uint64_t value() const;
+    void set_value(uint64_t value);
+
+private:
+    uint64_t _internal_value() const;
+    void _internal_set_value(uint64_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.UInt64Value)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        uint64_t value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT Int32Value final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int32Value) */ {
- public:
-  inline Int32Value() : Int32Value(nullptr) {}
-  ~Int32Value() override;
-  explicit PROTOBUF_CONSTEXPR Int32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  Int32Value(const Int32Value& from);
-  Int32Value(Int32Value&& from) noexcept
-    : Int32Value() {
-    *this = ::std::move(from);
-  }
-
-  inline Int32Value& operator=(const Int32Value& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline Int32Value& operator=(Int32Value&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const Int32Value& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const Int32Value* internal_default_instance() {
-    return reinterpret_cast<const Int32Value*>(
-               &_Int32Value_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    4;
-
-  friend void swap(Int32Value& a, Int32Value& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(Int32Value* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(Int32Value* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  Int32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<Int32Value>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const Int32Value& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const Int32Value& from) {
-    Int32Value::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(Int32Value* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.Int32Value";
-  }
-  protected:
-  explicit Int32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // int32 value = 1;
-  void clear_value();
-  int32_t value() const;
-  void set_value(int32_t value);
-  private:
-  int32_t _internal_value() const;
-  void _internal_set_value(int32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.Int32Value)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    int32_t value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int32Value) */
+{
+public:
+    inline Int32Value() :
+        Int32Value(nullptr)
+    {
+    }
+    ~Int32Value() override;
+    explicit PROTOBUF_CONSTEXPR Int32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    Int32Value(const Int32Value& from);
+    Int32Value(Int32Value&& from) noexcept
+        :
+        Int32Value()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline Int32Value& operator=(const Int32Value& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline Int32Value& operator=(Int32Value&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const Int32Value& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const Int32Value* internal_default_instance()
+    {
+        return reinterpret_cast<const Int32Value*>(
+            &_Int32Value_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        4;
+
+    friend void swap(Int32Value& a, Int32Value& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(Int32Value* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(Int32Value* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    Int32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<Int32Value>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const Int32Value& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const Int32Value& from)
+    {
+        Int32Value::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(Int32Value* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.Int32Value";
+    }
+
+protected:
+    explicit Int32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // int32 value = 1;
+    void clear_value();
+    int32_t value() const;
+    void set_value(int32_t value);
+
+private:
+    int32_t _internal_value() const;
+    void _internal_set_value(int32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.Int32Value)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        int32_t value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT UInt32Value final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt32Value) */ {
- public:
-  inline UInt32Value() : UInt32Value(nullptr) {}
-  ~UInt32Value() override;
-  explicit PROTOBUF_CONSTEXPR UInt32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  UInt32Value(const UInt32Value& from);
-  UInt32Value(UInt32Value&& from) noexcept
-    : UInt32Value() {
-    *this = ::std::move(from);
-  }
-
-  inline UInt32Value& operator=(const UInt32Value& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline UInt32Value& operator=(UInt32Value&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const UInt32Value& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const UInt32Value* internal_default_instance() {
-    return reinterpret_cast<const UInt32Value*>(
-               &_UInt32Value_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    5;
-
-  friend void swap(UInt32Value& a, UInt32Value& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(UInt32Value* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(UInt32Value* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  UInt32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<UInt32Value>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const UInt32Value& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const UInt32Value& from) {
-    UInt32Value::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(UInt32Value* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.UInt32Value";
-  }
-  protected:
-  explicit UInt32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // uint32 value = 1;
-  void clear_value();
-  uint32_t value() const;
-  void set_value(uint32_t value);
-  private:
-  uint32_t _internal_value() const;
-  void _internal_set_value(uint32_t value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.UInt32Value)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    uint32_t value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt32Value) */
+{
+public:
+    inline UInt32Value() :
+        UInt32Value(nullptr)
+    {
+    }
+    ~UInt32Value() override;
+    explicit PROTOBUF_CONSTEXPR UInt32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    UInt32Value(const UInt32Value& from);
+    UInt32Value(UInt32Value&& from) noexcept
+        :
+        UInt32Value()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline UInt32Value& operator=(const UInt32Value& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline UInt32Value& operator=(UInt32Value&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const UInt32Value& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const UInt32Value* internal_default_instance()
+    {
+        return reinterpret_cast<const UInt32Value*>(
+            &_UInt32Value_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        5;
+
+    friend void swap(UInt32Value& a, UInt32Value& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(UInt32Value* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(UInt32Value* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    UInt32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<UInt32Value>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const UInt32Value& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const UInt32Value& from)
+    {
+        UInt32Value::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(UInt32Value* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.UInt32Value";
+    }
+
+protected:
+    explicit UInt32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // uint32 value = 1;
+    void clear_value();
+    uint32_t value() const;
+    void set_value(uint32_t value);
+
+private:
+    uint32_t _internal_value() const;
+    void _internal_set_value(uint32_t value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.UInt32Value)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        uint32_t value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT BoolValue final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BoolValue) */ {
- public:
-  inline BoolValue() : BoolValue(nullptr) {}
-  ~BoolValue() override;
-  explicit PROTOBUF_CONSTEXPR BoolValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  BoolValue(const BoolValue& from);
-  BoolValue(BoolValue&& from) noexcept
-    : BoolValue() {
-    *this = ::std::move(from);
-  }
-
-  inline BoolValue& operator=(const BoolValue& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline BoolValue& operator=(BoolValue&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const BoolValue& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const BoolValue* internal_default_instance() {
-    return reinterpret_cast<const BoolValue*>(
-               &_BoolValue_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    6;
-
-  friend void swap(BoolValue& a, BoolValue& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(BoolValue* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(BoolValue* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  BoolValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<BoolValue>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const BoolValue& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const BoolValue& from) {
-    BoolValue::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(BoolValue* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.BoolValue";
-  }
-  protected:
-  explicit BoolValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // bool value = 1;
-  void clear_value();
-  bool value() const;
-  void set_value(bool value);
-  private:
-  bool _internal_value() const;
-  void _internal_set_value(bool value);
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.BoolValue)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    bool value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BoolValue) */
+{
+public:
+    inline BoolValue() :
+        BoolValue(nullptr)
+    {
+    }
+    ~BoolValue() override;
+    explicit PROTOBUF_CONSTEXPR BoolValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    BoolValue(const BoolValue& from);
+    BoolValue(BoolValue&& from) noexcept
+        :
+        BoolValue()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline BoolValue& operator=(const BoolValue& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline BoolValue& operator=(BoolValue&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const BoolValue& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const BoolValue* internal_default_instance()
+    {
+        return reinterpret_cast<const BoolValue*>(
+            &_BoolValue_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        6;
+
+    friend void swap(BoolValue& a, BoolValue& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(BoolValue* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(BoolValue* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    BoolValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<BoolValue>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const BoolValue& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const BoolValue& from)
+    {
+        BoolValue::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(BoolValue* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.BoolValue";
+    }
+
+protected:
+    explicit BoolValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // bool value = 1;
+    void clear_value();
+    bool value() const;
+    void set_value(bool value);
+
+private:
+    bool _internal_value() const;
+    void _internal_set_value(bool value);
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.BoolValue)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        bool value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT StringValue final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.StringValue) */ {
- public:
-  inline StringValue() : StringValue(nullptr) {}
-  ~StringValue() override;
-  explicit PROTOBUF_CONSTEXPR StringValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  StringValue(const StringValue& from);
-  StringValue(StringValue&& from) noexcept
-    : StringValue() {
-    *this = ::std::move(from);
-  }
-
-  inline StringValue& operator=(const StringValue& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline StringValue& operator=(StringValue&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const StringValue& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const StringValue* internal_default_instance() {
-    return reinterpret_cast<const StringValue*>(
-               &_StringValue_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    7;
-
-  friend void swap(StringValue& a, StringValue& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(StringValue* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(StringValue* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  StringValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<StringValue>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const StringValue& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const StringValue& from) {
-    StringValue::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(StringValue* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.StringValue";
-  }
-  protected:
-  explicit StringValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // string value = 1;
-  void clear_value();
-  const std::string& value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_value();
-  PROTOBUF_NODISCARD std::string* release_value();
-  void set_allocated_value(std::string* value);
-  private:
-  const std::string& _internal_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
-  std::string* _internal_mutable_value();
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.StringValue)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.StringValue) */
+{
+public:
+    inline StringValue() :
+        StringValue(nullptr)
+    {
+    }
+    ~StringValue() override;
+    explicit PROTOBUF_CONSTEXPR StringValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    StringValue(const StringValue& from);
+    StringValue(StringValue&& from) noexcept
+        :
+        StringValue()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline StringValue& operator=(const StringValue& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline StringValue& operator=(StringValue&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const StringValue& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const StringValue* internal_default_instance()
+    {
+        return reinterpret_cast<const StringValue*>(
+            &_StringValue_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        7;
+
+    friend void swap(StringValue& a, StringValue& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(StringValue* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(StringValue* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    StringValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<StringValue>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const StringValue& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const StringValue& from)
+    {
+        StringValue::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(StringValue* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.StringValue";
+    }
+
+protected:
+    explicit StringValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // string value = 1;
+    void clear_value();
+    const std::string& value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_value();
+    PROTOBUF_NODISCARD std::string* release_value();
+    void set_allocated_value(std::string* value);
+
+private:
+    const std::string& _internal_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+    std::string* _internal_mutable_value();
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.StringValue)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // -------------------------------------------------------------------
 
 class PROTOBUF_EXPORT BytesValue final :
-    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BytesValue) */ {
- public:
-  inline BytesValue() : BytesValue(nullptr) {}
-  ~BytesValue() override;
-  explicit PROTOBUF_CONSTEXPR BytesValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
-  BytesValue(const BytesValue& from);
-  BytesValue(BytesValue&& from) noexcept
-    : BytesValue() {
-    *this = ::std::move(from);
-  }
-
-  inline BytesValue& operator=(const BytesValue& from) {
-    CopyFrom(from);
-    return *this;
-  }
-  inline BytesValue& operator=(BytesValue&& from) noexcept {
-    if (this == &from) return *this;
-    if (GetOwningArena() == from.GetOwningArena()
-  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
-        && GetOwningArena() != nullptr
-  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
-    ) {
-      InternalSwap(&from);
-    } else {
-      CopyFrom(from);
-    }
-    return *this;
-  }
-
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
-    return GetDescriptor();
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
-    return default_instance().GetMetadata().descriptor;
-  }
-  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
-    return default_instance().GetMetadata().reflection;
-  }
-  static const BytesValue& default_instance() {
-    return *internal_default_instance();
-  }
-  static inline const BytesValue* internal_default_instance() {
-    return reinterpret_cast<const BytesValue*>(
-               &_BytesValue_default_instance_);
-  }
-  static constexpr int kIndexInFileMessages =
-    8;
-
-  friend void swap(BytesValue& a, BytesValue& b) {
-    a.Swap(&b);
-  }
-  inline void Swap(BytesValue* other) {
-    if (other == this) return;
-  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() != nullptr &&
-        GetOwningArena() == other->GetOwningArena()) {
-   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
-    if (GetOwningArena() == other->GetOwningArena()) {
-  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
-      InternalSwap(other);
-    } else {
-      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
-    }
-  }
-  void UnsafeArenaSwap(BytesValue* other) {
-    if (other == this) return;
-    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
-    InternalSwap(other);
-  }
-
-  // implements Message ----------------------------------------------
-
-  BytesValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
-    return CreateMaybeMessage<BytesValue>(arena);
-  }
-  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
-  void CopyFrom(const BytesValue& from);
-  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
-  void MergeFrom( const BytesValue& from) {
-    BytesValue::MergeImpl(*this, from);
-  }
-  private:
-  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
-  public:
-  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
-  bool IsInitialized() const final;
-
-  size_t ByteSizeLong() const final;
-  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
-  uint8_t* _InternalSerialize(
-      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
-  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
-
-  private:
-  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
-  void SharedDtor();
-  void SetCachedSize(int size) const final;
-  void InternalSwap(BytesValue* other);
-
-  private:
-  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
-  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
-    return "google.protobuf.BytesValue";
-  }
-  protected:
-  explicit BytesValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
-                       bool is_message_owned = false);
-  public:
-
-  static const ClassData _class_data_;
-  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
-
-  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  enum : int {
-    kValueFieldNumber = 1,
-  };
-  // bytes value = 1;
-  void clear_value();
-  const std::string& value() const;
-  template <typename ArgT0 = const std::string&, typename... ArgT>
-  void set_value(ArgT0&& arg0, ArgT... args);
-  std::string* mutable_value();
-  PROTOBUF_NODISCARD std::string* release_value();
-  void set_allocated_value(std::string* value);
-  private:
-  const std::string& _internal_value() const;
-  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
-  std::string* _internal_mutable_value();
-  public:
-
-  // @@protoc_insertion_point(class_scope:google.protobuf.BytesValue)
- private:
-  class _Internal;
-
-  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
-  typedef void InternalArenaConstructable_;
-  typedef void DestructorSkippable_;
-  struct Impl_ {
-    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
-    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
-  };
-  union { Impl_ _impl_; };
-  friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BytesValue) */
+{
+public:
+    inline BytesValue() :
+        BytesValue(nullptr)
+    {
+    }
+    ~BytesValue() override;
+    explicit PROTOBUF_CONSTEXPR BytesValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+    BytesValue(const BytesValue& from);
+    BytesValue(BytesValue&& from) noexcept
+        :
+        BytesValue()
+    {
+        *this = ::std::move(from);
+    }
+
+    inline BytesValue& operator=(const BytesValue& from)
+    {
+        CopyFrom(from);
+        return *this;
+    }
+    inline BytesValue& operator=(BytesValue&& from) noexcept
+    {
+        if (this == &from)
+            return *this;
+        if (GetOwningArena() == from.GetOwningArena()
+#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+            && GetOwningArena() != nullptr
+#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+        )
+        {
+            InternalSwap(&from);
+        }
+        else
+        {
+            CopyFrom(from);
+        }
+        return *this;
+    }
+
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor()
+    {
+        return GetDescriptor();
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor()
+    {
+        return default_instance().GetMetadata().descriptor;
+    }
+    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection()
+    {
+        return default_instance().GetMetadata().reflection;
+    }
+    static const BytesValue& default_instance()
+    {
+        return *internal_default_instance();
+    }
+    static inline const BytesValue* internal_default_instance()
+    {
+        return reinterpret_cast<const BytesValue*>(
+            &_BytesValue_default_instance_
+        );
+    }
+    static constexpr int kIndexInFileMessages =
+        8;
+
+    friend void swap(BytesValue& a, BytesValue& b)
+    {
+        a.Swap(&b);
+    }
+    inline void Swap(BytesValue* other)
+    {
+        if (other == this)
+            return;
+#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() != nullptr &&
+            GetOwningArena() == other->GetOwningArena())
+        {
+#else   // PROTOBUF_FORCE_COPY_IN_SWAP
+        if (GetOwningArena() == other->GetOwningArena())
+        {
+#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+            InternalSwap(other);
+        }
+        else
+        {
+            ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+        }
+    }
+    void UnsafeArenaSwap(BytesValue* other)
+    {
+        if (other == this)
+            return;
+        GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+        InternalSwap(other);
+    }
+
+    // implements Message ----------------------------------------------
+
+    BytesValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final
+    {
+        return CreateMaybeMessage<BytesValue>(arena);
+    }
+    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+    void CopyFrom(const BytesValue& from);
+    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+    void MergeFrom(const BytesValue& from)
+    {
+        BytesValue::MergeImpl(*this, from);
+    }
+
+private:
+    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
+
+public:
+    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+    bool IsInitialized() const final;
+
+    size_t ByteSizeLong() const final;
+    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+    uint8_t* _InternalSerialize(
+        uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream
+    ) const final;
+    int GetCachedSize() const final
+    {
+        return _impl_._cached_size_.Get();
+    }
+
+private:
+    void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
+    void SharedDtor();
+    void SetCachedSize(int size) const final;
+    void InternalSwap(BytesValue* other);
+
+private:
+    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName()
+    {
+        return "google.protobuf.BytesValue";
+    }
+
+protected:
+    explicit BytesValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false);
+
+public:
+    static const ClassData _class_data_;
+    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData* GetClassData() const final;
+
+    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+    // nested types ----------------------------------------------------
+
+    // accessors -------------------------------------------------------
+
+    enum : int
+    {
+        kValueFieldNumber = 1,
+    };
+    // bytes value = 1;
+    void clear_value();
+    const std::string& value() const;
+    template<typename ArgT0 = const std::string&, typename... ArgT>
+    void set_value(ArgT0&& arg0, ArgT... args);
+    std::string* mutable_value();
+    PROTOBUF_NODISCARD std::string* release_value();
+    void set_allocated_value(std::string* value);
+
+private:
+    const std::string& _internal_value() const;
+    inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+    std::string* _internal_mutable_value();
+
+public:
+    // @@protoc_insertion_point(class_scope:google.protobuf.BytesValue)
+
+private:
+    class _Internal;
+
+    template<typename T>
+    friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+    struct Impl_
+    {
+        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+        mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+    };
+    union
+    {
+        Impl_ _impl_;
+    };
+    friend struct ::TableStruct_google_2fprotobuf_2fwrappers_2eproto;
 };
 // ===================================================================
 
-
 // ===================================================================
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic push
-  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
 // DoubleValue
 
 // double value = 1;
-inline void DoubleValue::clear_value() {
-  _impl_.value_ = 0;
+inline void DoubleValue::clear_value()
+{
+    _impl_.value_ = 0;
 }
-inline double DoubleValue::_internal_value() const {
-  return _impl_.value_;
+inline double DoubleValue::_internal_value() const
+{
+    return _impl_.value_;
 }
-inline double DoubleValue::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.DoubleValue.value)
-  return _internal_value();
+inline double DoubleValue::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.DoubleValue.value)
+    return _internal_value();
 }
-inline void DoubleValue::_internal_set_value(double value) {
-  
-  _impl_.value_ = value;
+inline void DoubleValue::_internal_set_value(double value)
+{
+    _impl_.value_ = value;
 }
-inline void DoubleValue::set_value(double value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.DoubleValue.value)
+inline void DoubleValue::set_value(double value)
+{
+    _internal_set_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.DoubleValue.value)
 }
 
 // -------------------------------------------------------------------
@@ -1464,23 +1874,27 @@ inline void DoubleValue::set_value(double value) {
 // FloatValue
 
 // float value = 1;
-inline void FloatValue::clear_value() {
-  _impl_.value_ = 0;
+inline void FloatValue::clear_value()
+{
+    _impl_.value_ = 0;
 }
-inline float FloatValue::_internal_value() const {
-  return _impl_.value_;
+inline float FloatValue::_internal_value() const
+{
+    return _impl_.value_;
 }
-inline float FloatValue::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.FloatValue.value)
-  return _internal_value();
+inline float FloatValue::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.FloatValue.value)
+    return _internal_value();
 }
-inline void FloatValue::_internal_set_value(float value) {
-  
-  _impl_.value_ = value;
+inline void FloatValue::_internal_set_value(float value)
+{
+    _impl_.value_ = value;
 }
-inline void FloatValue::set_value(float value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.FloatValue.value)
+inline void FloatValue::set_value(float value)
+{
+    _internal_set_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.FloatValue.value)
 }
 
 // -------------------------------------------------------------------
@@ -1488,23 +1902,27 @@ inline void FloatValue::set_value(float value) {
 // Int64Value
 
 // int64 value = 1;
-inline void Int64Value::clear_value() {
-  _impl_.value_ = int64_t{0};
+inline void Int64Value::clear_value()
+{
+    _impl_.value_ = int64_t{0};
 }
-inline int64_t Int64Value::_internal_value() const {
-  return _impl_.value_;
+inline int64_t Int64Value::_internal_value() const
+{
+    return _impl_.value_;
 }
-inline int64_t Int64Value::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Int64Value.value)
-  return _internal_value();
+inline int64_t Int64Value::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Int64Value.value)
+    return _internal_value();
 }
-inline void Int64Value::_internal_set_value(int64_t value) {
-  
-  _impl_.value_ = value;
+inline void Int64Value::_internal_set_value(int64_t value)
+{
+    _impl_.value_ = value;
 }
-inline void Int64Value::set_value(int64_t value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Int64Value.value)
+inline void Int64Value::set_value(int64_t value)
+{
+    _internal_set_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Int64Value.value)
 }
 
 // -------------------------------------------------------------------
@@ -1512,23 +1930,27 @@ inline void Int64Value::set_value(int64_t value) {
 // UInt64Value
 
 // uint64 value = 1;
-inline void UInt64Value::clear_value() {
-  _impl_.value_ = uint64_t{0u};
+inline void UInt64Value::clear_value()
+{
+    _impl_.value_ = uint64_t{0u};
 }
-inline uint64_t UInt64Value::_internal_value() const {
-  return _impl_.value_;
+inline uint64_t UInt64Value::_internal_value() const
+{
+    return _impl_.value_;
 }
-inline uint64_t UInt64Value::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UInt64Value.value)
-  return _internal_value();
+inline uint64_t UInt64Value::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UInt64Value.value)
+    return _internal_value();
 }
-inline void UInt64Value::_internal_set_value(uint64_t value) {
-  
-  _impl_.value_ = value;
+inline void UInt64Value::_internal_set_value(uint64_t value)
+{
+    _impl_.value_ = value;
 }
-inline void UInt64Value::set_value(uint64_t value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.UInt64Value.value)
+inline void UInt64Value::set_value(uint64_t value)
+{
+    _internal_set_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.UInt64Value.value)
 }
 
 // -------------------------------------------------------------------
@@ -1536,23 +1958,27 @@ inline void UInt64Value::set_value(uint64_t value) {
 // Int32Value
 
 // int32 value = 1;
-inline void Int32Value::clear_value() {
-  _impl_.value_ = 0;
+inline void Int32Value::clear_value()
+{
+    _impl_.value_ = 0;
 }
-inline int32_t Int32Value::_internal_value() const {
-  return _impl_.value_;
+inline int32_t Int32Value::_internal_value() const
+{
+    return _impl_.value_;
 }
-inline int32_t Int32Value::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.Int32Value.value)
-  return _internal_value();
+inline int32_t Int32Value::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.Int32Value.value)
+    return _internal_value();
 }
-inline void Int32Value::_internal_set_value(int32_t value) {
-  
-  _impl_.value_ = value;
+inline void Int32Value::_internal_set_value(int32_t value)
+{
+    _impl_.value_ = value;
 }
-inline void Int32Value::set_value(int32_t value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.Int32Value.value)
+inline void Int32Value::set_value(int32_t value)
+{
+    _internal_set_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.Int32Value.value)
 }
 
 // -------------------------------------------------------------------
@@ -1560,23 +1986,27 @@ inline void Int32Value::set_value(int32_t value) {
 // UInt32Value
 
 // uint32 value = 1;
-inline void UInt32Value::clear_value() {
-  _impl_.value_ = 0u;
+inline void UInt32Value::clear_value()
+{
+    _impl_.value_ = 0u;
 }
-inline uint32_t UInt32Value::_internal_value() const {
-  return _impl_.value_;
+inline uint32_t UInt32Value::_internal_value() const
+{
+    return _impl_.value_;
 }
-inline uint32_t UInt32Value::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.UInt32Value.value)
-  return _internal_value();
+inline uint32_t UInt32Value::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.UInt32Value.value)
+    return _internal_value();
 }
-inline void UInt32Value::_internal_set_value(uint32_t value) {
-  
-  _impl_.value_ = value;
+inline void UInt32Value::_internal_set_value(uint32_t value)
+{
+    _impl_.value_ = value;
 }
-inline void UInt32Value::set_value(uint32_t value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.UInt32Value.value)
+inline void UInt32Value::set_value(uint32_t value)
+{
+    _internal_set_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.UInt32Value.value)
 }
 
 // -------------------------------------------------------------------
@@ -1584,23 +2014,27 @@ inline void UInt32Value::set_value(uint32_t value) {
 // BoolValue
 
 // bool value = 1;
-inline void BoolValue::clear_value() {
-  _impl_.value_ = false;
+inline void BoolValue::clear_value()
+{
+    _impl_.value_ = false;
 }
-inline bool BoolValue::_internal_value() const {
-  return _impl_.value_;
+inline bool BoolValue::_internal_value() const
+{
+    return _impl_.value_;
 }
-inline bool BoolValue::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.BoolValue.value)
-  return _internal_value();
+inline bool BoolValue::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.BoolValue.value)
+    return _internal_value();
 }
-inline void BoolValue::_internal_set_value(bool value) {
-  
-  _impl_.value_ = value;
+inline void BoolValue::_internal_set_value(bool value)
+{
+    _impl_.value_ = value;
 }
-inline void BoolValue::set_value(bool value) {
-  _internal_set_value(value);
-  // @@protoc_insertion_point(field_set:google.protobuf.BoolValue.value)
+inline void BoolValue::set_value(bool value)
+{
+    _internal_set_value(value);
+    // @@protoc_insertion_point(field_set:google.protobuf.BoolValue.value)
 }
 
 // -------------------------------------------------------------------
@@ -1608,53 +2042,60 @@ inline void BoolValue::set_value(bool value) {
 // StringValue
 
 // string value = 1;
-inline void StringValue::clear_value() {
-  _impl_.value_.ClearToEmpty();
+inline void StringValue::clear_value()
+{
+    _impl_.value_.ClearToEmpty();
 }
-inline const std::string& StringValue::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.StringValue.value)
-  return _internal_value();
+inline const std::string& StringValue::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.StringValue.value)
+    return _internal_value();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void StringValue::set_value(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.StringValue.value)
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void StringValue::set_value(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.value_.Set(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.StringValue.value)
 }
-inline std::string* StringValue::mutable_value() {
-  std::string* _s = _internal_mutable_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.StringValue.value)
-  return _s;
+inline std::string* StringValue::mutable_value()
+{
+    std::string* _s = _internal_mutable_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.StringValue.value)
+    return _s;
 }
-inline const std::string& StringValue::_internal_value() const {
-  return _impl_.value_.Get();
+inline const std::string& StringValue::_internal_value() const
+{
+    return _impl_.value_.Get();
 }
-inline void StringValue::_internal_set_value(const std::string& value) {
-  
-  _impl_.value_.Set(value, GetArenaForAllocation());
+inline void StringValue::_internal_set_value(const std::string& value)
+{
+    _impl_.value_.Set(value, GetArenaForAllocation());
 }
-inline std::string* StringValue::_internal_mutable_value() {
-  
-  return _impl_.value_.Mutable(GetArenaForAllocation());
+inline std::string* StringValue::_internal_mutable_value()
+{
+    return _impl_.value_.Mutable(GetArenaForAllocation());
 }
-inline std::string* StringValue::release_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.StringValue.value)
-  return _impl_.value_.Release();
+inline std::string* StringValue::release_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.StringValue.value)
+    return _impl_.value_.Release();
 }
-inline void StringValue::set_allocated_value(std::string* value) {
-  if (value != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+inline void StringValue::set_allocated_value(std::string* value)
+{
+    if (value != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.value_.SetAllocated(value, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.value_.IsDefault()) {
-    _impl_.value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.StringValue.value)
+    if (_impl_.value_.IsDefault())
+    {
+        _impl_.value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.StringValue.value)
 }
 
 // -------------------------------------------------------------------
@@ -1662,57 +2103,64 @@ inline void StringValue::set_allocated_value(std::string* value) {
 // BytesValue
 
 // bytes value = 1;
-inline void BytesValue::clear_value() {
-  _impl_.value_.ClearToEmpty();
+inline void BytesValue::clear_value()
+{
+    _impl_.value_.ClearToEmpty();
 }
-inline const std::string& BytesValue::value() const {
-  // @@protoc_insertion_point(field_get:google.protobuf.BytesValue.value)
-  return _internal_value();
+inline const std::string& BytesValue::value() const
+{
+    // @@protoc_insertion_point(field_get:google.protobuf.BytesValue.value)
+    return _internal_value();
 }
-template <typename ArgT0, typename... ArgT>
-inline PROTOBUF_ALWAYS_INLINE
-void BytesValue::set_value(ArgT0&& arg0, ArgT... args) {
- 
- _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
-  // @@protoc_insertion_point(field_set:google.protobuf.BytesValue.value)
+template<typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE void BytesValue::set_value(ArgT0&& arg0, ArgT... args)
+{
+    _impl_.value_.SetBytes(static_cast<ArgT0&&>(arg0), args..., GetArenaForAllocation());
+    // @@protoc_insertion_point(field_set:google.protobuf.BytesValue.value)
 }
-inline std::string* BytesValue::mutable_value() {
-  std::string* _s = _internal_mutable_value();
-  // @@protoc_insertion_point(field_mutable:google.protobuf.BytesValue.value)
-  return _s;
+inline std::string* BytesValue::mutable_value()
+{
+    std::string* _s = _internal_mutable_value();
+    // @@protoc_insertion_point(field_mutable:google.protobuf.BytesValue.value)
+    return _s;
 }
-inline const std::string& BytesValue::_internal_value() const {
-  return _impl_.value_.Get();
+inline const std::string& BytesValue::_internal_value() const
+{
+    return _impl_.value_.Get();
 }
-inline void BytesValue::_internal_set_value(const std::string& value) {
-  
-  _impl_.value_.Set(value, GetArenaForAllocation());
+inline void BytesValue::_internal_set_value(const std::string& value)
+{
+    _impl_.value_.Set(value, GetArenaForAllocation());
 }
-inline std::string* BytesValue::_internal_mutable_value() {
-  
-  return _impl_.value_.Mutable(GetArenaForAllocation());
+inline std::string* BytesValue::_internal_mutable_value()
+{
+    return _impl_.value_.Mutable(GetArenaForAllocation());
 }
-inline std::string* BytesValue::release_value() {
-  // @@protoc_insertion_point(field_release:google.protobuf.BytesValue.value)
-  return _impl_.value_.Release();
+inline std::string* BytesValue::release_value()
+{
+    // @@protoc_insertion_point(field_release:google.protobuf.BytesValue.value)
+    return _impl_.value_.Release();
 }
-inline void BytesValue::set_allocated_value(std::string* value) {
-  if (value != nullptr) {
-    
-  } else {
-    
-  }
-  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
+inline void BytesValue::set_allocated_value(std::string* value)
+{
+    if (value != nullptr)
+    {
+    }
+    else
+    {
+    }
+    _impl_.value_.SetAllocated(value, GetArenaForAllocation());
 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  if (_impl_.value_.IsDefault()) {
-    _impl_.value_.Set("", GetArenaForAllocation());
-  }
-#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
-  // @@protoc_insertion_point(field_set_allocated:google.protobuf.BytesValue.value)
+    if (_impl_.value_.IsDefault())
+    {
+        _impl_.value_.Set("", GetArenaForAllocation());
+    }
+#endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+        // @@protoc_insertion_point(field_set_allocated:google.protobuf.BytesValue.value)
 }
 
 #ifdef __GNUC__
-  #pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif  // __GNUC__
 // -------------------------------------------------------------------
 
@@ -1730,7 +2178,6 @@ inline void BytesValue::set_allocated_value(std::string* value) {
 
 // -------------------------------------------------------------------
 
-
 // @@protoc_insertion_point(namespace_scope)
 
 PROTOBUF_NAMESPACE_CLOSE
diff --git a/CAPI/cpp/grpc/include/grpc/census.h b/CAPI/cpp/grpc/include/grpc/census.h
index 4894f1c..15f10be 100644
--- a/CAPI/cpp/grpc/include/grpc/census.h
+++ b/CAPI/cpp/grpc/include/grpc/census.h
@@ -24,14 +24,15 @@
 #include <grpc/grpc.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/**
-  A Census Context is a handle used by Census to represent the current tracing
-  and stats collection information. Contexts should be propagated across RPC's
-  (this is the responsibility of the local RPC system). */
-typedef struct census_context census_context;
+    /**
+      A Census Context is a handle used by Census to represent the current tracing
+      and stats collection information. Contexts should be propagated across RPC's
+      (this is the responsibility of the local RPC system). */
+    typedef struct census_context census_context;
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/compression.h b/CAPI/cpp/grpc/include/grpc/compression.h
index 2c39c6b..4868f25 100644
--- a/CAPI/cpp/grpc/include/grpc/compression.h
+++ b/CAPI/cpp/grpc/include/grpc/compression.h
@@ -27,46 +27,55 @@
 #include <grpc/slice.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** Return if an algorithm is message compression algorithm. */
-GRPCAPI int grpc_compression_algorithm_is_message(
-    grpc_compression_algorithm algorithm);
-
-/** Return if an algorithm is stream compression algorithm. */
-GRPCAPI int grpc_compression_algorithm_is_stream(
-    grpc_compression_algorithm algorithm);
-
-/** Parses the \a slice as a grpc_compression_algorithm instance and updating \a
- * algorithm. Returns 1 upon success, 0 otherwise. */
-GRPCAPI int grpc_compression_algorithm_parse(
-    grpc_slice name, grpc_compression_algorithm* algorithm);
-
-/** Updates \a name with the encoding name corresponding to a valid \a
- * algorithm. Note that \a name is statically allocated and must *not* be freed.
- * Returns 1 upon success, 0 otherwise. */
-GRPCAPI int grpc_compression_algorithm_name(
-    grpc_compression_algorithm algorithm, const char** name);
-
-/** Returns the compression algorithm corresponding to \a level for the
- * compression algorithms encoded in the \a accepted_encodings bitset.*/
-GRPCAPI grpc_compression_algorithm grpc_compression_algorithm_for_level(
-    grpc_compression_level level, uint32_t accepted_encodings);
-
-GRPCAPI void grpc_compression_options_init(grpc_compression_options* opts);
-
-/** Mark \a algorithm as enabled in \a opts. */
-GRPCAPI void grpc_compression_options_enable_algorithm(
-    grpc_compression_options* opts, grpc_compression_algorithm algorithm);
-
-/** Mark \a algorithm as disabled in \a opts. */
-GRPCAPI void grpc_compression_options_disable_algorithm(
-    grpc_compression_options* opts, grpc_compression_algorithm algorithm);
-
-/** Returns true if \a algorithm is marked as enabled in \a opts. */
-GRPCAPI int grpc_compression_options_is_algorithm_enabled(
-    const grpc_compression_options* opts, grpc_compression_algorithm algorithm);
+    /** Return if an algorithm is message compression algorithm. */
+    GRPCAPI int grpc_compression_algorithm_is_message(
+        grpc_compression_algorithm algorithm
+    );
+
+    /** Return if an algorithm is stream compression algorithm. */
+    GRPCAPI int grpc_compression_algorithm_is_stream(
+        grpc_compression_algorithm algorithm
+    );
+
+    /** Parses the \a slice as a grpc_compression_algorithm instance and updating \a
+     * algorithm. Returns 1 upon success, 0 otherwise. */
+    GRPCAPI int grpc_compression_algorithm_parse(
+        grpc_slice name, grpc_compression_algorithm* algorithm
+    );
+
+    /** Updates \a name with the encoding name corresponding to a valid \a
+     * algorithm. Note that \a name is statically allocated and must *not* be freed.
+     * Returns 1 upon success, 0 otherwise. */
+    GRPCAPI int grpc_compression_algorithm_name(
+        grpc_compression_algorithm algorithm, const char** name
+    );
+
+    /** Returns the compression algorithm corresponding to \a level for the
+     * compression algorithms encoded in the \a accepted_encodings bitset.*/
+    GRPCAPI grpc_compression_algorithm grpc_compression_algorithm_for_level(
+        grpc_compression_level level, uint32_t accepted_encodings
+    );
+
+    GRPCAPI void grpc_compression_options_init(grpc_compression_options* opts);
+
+    /** Mark \a algorithm as enabled in \a opts. */
+    GRPCAPI void grpc_compression_options_enable_algorithm(
+        grpc_compression_options* opts, grpc_compression_algorithm algorithm
+    );
+
+    /** Mark \a algorithm as disabled in \a opts. */
+    GRPCAPI void grpc_compression_options_disable_algorithm(
+        grpc_compression_options* opts, grpc_compression_algorithm algorithm
+    );
+
+    /** Returns true if \a algorithm is marked as enabled in \a opts. */
+    GRPCAPI int grpc_compression_options_is_algorithm_enabled(
+        const grpc_compression_options* opts, grpc_compression_algorithm algorithm
+    );
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/endpoint_config.h b/CAPI/cpp/grpc/include/grpc/event_engine/endpoint_config.h
index 6ca4b4f..75ce857 100644
--- a/CAPI/cpp/grpc/include/grpc/event_engine/endpoint_config.h
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/endpoint_config.h
@@ -21,23 +21,26 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine
+{
+    namespace experimental
+    {
 
-/// Collection of parameters used to configure client and server endpoints. The
-/// \a EndpointConfig maps string-valued keys to values of type int,
-/// string_view, or void pointer. Each EventEngine implementation should
-/// document its set of supported configuration options.
-class EndpointConfig {
- public:
-  virtual ~EndpointConfig() = default;
-  using Setting = absl::variant<absl::monostate, int, absl::string_view, void*>;
-  /// Returns the Setting for a specified key, or \a absl::monostate if there is
-  /// no such entry. Caller does not take ownership of the resulting value.
-  virtual Setting Get(absl::string_view key) const = 0;
-};
+        /// Collection of parameters used to configure client and server endpoints. The
+        /// \a EndpointConfig maps string-valued keys to values of type int,
+        /// string_view, or void pointer. Each EventEngine implementation should
+        /// document its set of supported configuration options.
+        class EndpointConfig
+        {
+        public:
+            virtual ~EndpointConfig() = default;
+            using Setting = absl::variant<absl::monostate, int, absl::string_view, void*>;
+            /// Returns the Setting for a specified key, or \a absl::monostate if there is
+            /// no such entry. Caller does not take ownership of the resulting value.
+            virtual Setting Get(absl::string_view key) const = 0;
+        };
 
-}  // namespace experimental
+    }  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_EVENT_ENGINE_ENDPOINT_CONFIG_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/event_engine.h b/CAPI/cpp/grpc/include/grpc/event_engine/event_engine.h
index 52edb5a..bc96b66 100644
--- a/CAPI/cpp/grpc/include/grpc/event_engine/event_engine.h
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/event_engine.h
@@ -29,418 +29,423 @@
 #include <grpc/event_engine/slice_buffer.h>
 
 // TODO(vigneshbabu): Define the Endpoint::Write metrics collection system
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine
+{
+    namespace experimental
+    {
 
-////////////////////////////////////////////////////////////////////////////////
-/// The EventEngine encapsulates all platform-specific behaviors related to low
-/// level network I/O, timers, asynchronous execution, and DNS resolution.
-///
-/// This interface allows developers to provide their own event management and
-/// network stacks. Motivating uses cases for supporting custom EventEngines
-/// include the ability to hook into external event loops, and using different
-/// EventEngine instances for each channel to better insulate network I/O and
-/// callback processing from other channels.
-///
-/// A default cross-platform EventEngine instance is provided by gRPC.
-///
-/// LIFESPAN AND OWNERSHIP
-///
-/// gRPC takes shared ownership of EventEngines via std::shared_ptrs to ensure
-/// that the engines remain available until they are no longer needed. Depending
-/// on the use case, engines may live until gRPC is shut down.
-///
-/// EXAMPLE USAGE (Not yet implemented)
-///
-/// Custom EventEngines can be specified per channel, and allow configuration
-/// for both clients and servers. To set a custom EventEngine for a client
-/// channel, you can do something like the following:
-///
-///    ChannelArguments args;
-///    std::shared_ptr<EventEngine> engine = std::make_shared<MyEngine>(...);
-///    args.SetEventEngine(engine);
-///    MyAppClient client(grpc::CreateCustomChannel(
-///        "localhost:50051", grpc::InsecureChannelCredentials(), args));
-///
-/// A gRPC server can use a custom EventEngine by calling the
-/// ServerBuilder::SetEventEngine method:
-///
-///    ServerBuilder builder;
-///    std::shared_ptr<EventEngine> engine = std::make_shared<MyEngine>(...);
-///    builder.SetEventEngine(engine);
-///    std::unique_ptr<Server> server(builder.BuildAndStart());
-///    server->Wait();
-///
-////////////////////////////////////////////////////////////////////////////////
-class EventEngine {
- public:
-  /// A duration between two events.
-  ///
-  /// Throughout the EventEngine API durations are used to express how long
-  /// until an action should be performed.
-  using Duration = std::chrono::duration<int64_t, std::nano>;
-  /// A custom closure type for EventEngine task execution.
-  ///
-  /// Throughout the EventEngine API, \a Closure ownership is retained by the
-  /// caller - the EventEngine will never delete a Closure, and upon
-  /// cancellation, the EventEngine will simply forget the Closure exists. The
-  /// caller is responsible for all necessary cleanup.
-  class Closure {
-   public:
-    Closure() = default;
-    // Closure's are an interface, and thus non-copyable.
-    Closure(const Closure&) = delete;
-    Closure& operator=(const Closure&) = delete;
-    // Polymorphic type => virtual destructor
-    virtual ~Closure() = default;
-    // Run the contained code.
-    virtual void Run() = 0;
-  };
-  /// Represents a scheduled task.
-  ///
-  /// \a TaskHandles are returned by \a Run* methods, and can be given to the
-  /// \a Cancel method.
-  struct TaskHandle {
-    intptr_t keys[2];
-  };
-  /// A handle to a cancellable connection attempt.
-  ///
-  /// Returned by \a Connect, and can be passed to \a CancelConnect.
-  struct ConnectionHandle {
-    intptr_t keys[2];
-  };
-  /// Thin wrapper around a platform-specific sockaddr type. A sockaddr struct
-  /// exists on all platforms that gRPC supports.
-  ///
-  /// Platforms are expected to provide definitions for:
-  /// * sockaddr
-  /// * sockaddr_in
-  /// * sockaddr_in6
-  class ResolvedAddress {
-   public:
-    static constexpr socklen_t MAX_SIZE_BYTES = 128;
+        ////////////////////////////////////////////////////////////////////////////////
+        /// The EventEngine encapsulates all platform-specific behaviors related to low
+        /// level network I/O, timers, asynchronous execution, and DNS resolution.
+        ///
+        /// This interface allows developers to provide their own event management and
+        /// network stacks. Motivating uses cases for supporting custom EventEngines
+        /// include the ability to hook into external event loops, and using different
+        /// EventEngine instances for each channel to better insulate network I/O and
+        /// callback processing from other channels.
+        ///
+        /// A default cross-platform EventEngine instance is provided by gRPC.
+        ///
+        /// LIFESPAN AND OWNERSHIP
+        ///
+        /// gRPC takes shared ownership of EventEngines via std::shared_ptrs to ensure
+        /// that the engines remain available until they are no longer needed. Depending
+        /// on the use case, engines may live until gRPC is shut down.
+        ///
+        /// EXAMPLE USAGE (Not yet implemented)
+        ///
+        /// Custom EventEngines can be specified per channel, and allow configuration
+        /// for both clients and servers. To set a custom EventEngine for a client
+        /// channel, you can do something like the following:
+        ///
+        ///    ChannelArguments args;
+        ///    std::shared_ptr<EventEngine> engine = std::make_shared<MyEngine>(...);
+        ///    args.SetEventEngine(engine);
+        ///    MyAppClient client(grpc::CreateCustomChannel(
+        ///        "localhost:50051", grpc::InsecureChannelCredentials(), args));
+        ///
+        /// A gRPC server can use a custom EventEngine by calling the
+        /// ServerBuilder::SetEventEngine method:
+        ///
+        ///    ServerBuilder builder;
+        ///    std::shared_ptr<EventEngine> engine = std::make_shared<MyEngine>(...);
+        ///    builder.SetEventEngine(engine);
+        ///    std::unique_ptr<Server> server(builder.BuildAndStart());
+        ///    server->Wait();
+        ///
+        ////////////////////////////////////////////////////////////////////////////////
+        class EventEngine
+        {
+        public:
+            /// A duration between two events.
+            ///
+            /// Throughout the EventEngine API durations are used to express how long
+            /// until an action should be performed.
+            using Duration = std::chrono::duration<int64_t, std::nano>;
+            /// A custom closure type for EventEngine task execution.
+            ///
+            /// Throughout the EventEngine API, \a Closure ownership is retained by the
+            /// caller - the EventEngine will never delete a Closure, and upon
+            /// cancellation, the EventEngine will simply forget the Closure exists. The
+            /// caller is responsible for all necessary cleanup.
+            class Closure
+            {
+            public:
+                Closure() = default;
+                // Closure's are an interface, and thus non-copyable.
+                Closure(const Closure&) = delete;
+                Closure& operator=(const Closure&) = delete;
+                // Polymorphic type => virtual destructor
+                virtual ~Closure() = default;
+                // Run the contained code.
+                virtual void Run() = 0;
+            };
+            /// Represents a scheduled task.
+            ///
+            /// \a TaskHandles are returned by \a Run* methods, and can be given to the
+            /// \a Cancel method.
+            struct TaskHandle
+            {
+                intptr_t keys[2];
+            };
+            /// A handle to a cancellable connection attempt.
+            ///
+            /// Returned by \a Connect, and can be passed to \a CancelConnect.
+            struct ConnectionHandle
+            {
+                intptr_t keys[2];
+            };
+            /// Thin wrapper around a platform-specific sockaddr type. A sockaddr struct
+            /// exists on all platforms that gRPC supports.
+            ///
+            /// Platforms are expected to provide definitions for:
+            /// * sockaddr
+            /// * sockaddr_in
+            /// * sockaddr_in6
+            class ResolvedAddress
+            {
+            public:
+                static constexpr socklen_t MAX_SIZE_BYTES = 128;
 
-    ResolvedAddress(const sockaddr* address, socklen_t size);
-    ResolvedAddress() = default;
-    ResolvedAddress(const ResolvedAddress&) = default;
-    const struct sockaddr* address() const;
-    socklen_t size() const;
+                ResolvedAddress(const sockaddr* address, socklen_t size);
+                ResolvedAddress() = default;
+                ResolvedAddress(const ResolvedAddress&) = default;
+                const struct sockaddr* address() const;
+                socklen_t size() const;
 
-   private:
-    char address_[MAX_SIZE_BYTES];
-    socklen_t size_ = 0;
-  };
+            private:
+                char address_[MAX_SIZE_BYTES];
+                socklen_t size_ = 0;
+            };
 
-  /// One end of a connection between a gRPC client and server. Endpoints are
-  /// created when connections are established, and Endpoint operations are
-  /// gRPC's primary means of communication.
-  ///
-  /// Endpoints must use the provided MemoryAllocator for all data buffer memory
-  /// allocations. gRPC allows applications to set memory constraints per
-  /// Channel or Server, and the implementation depends on all dynamic memory
-  /// allocation being handled by the quota system.
-  class Endpoint {
-   public:
-    /// Shuts down all connections and invokes all pending read or write
-    /// callbacks with an error status.
-    virtual ~Endpoint() = default;
-    /// A struct representing optional arguments that may be provided to an
-    /// EventEngine Endpoint Read API  call.
-    ///
-    /// Passed as argument to an Endpoint \a Read
-    struct ReadArgs {
-      // A suggestion to the endpoint implementation to read at-least the
-      // specified number of bytes over the network connection before marking
-      // the endpoint read operation as complete. gRPC may use this argument
-      // to minimize the number of endpoint read API calls over the lifetime
-      // of a connection.
-      int64_t read_hint_bytes;
-    };
-    /// Reads data from the Endpoint.
-    ///
-    /// When data is available on the connection, that data is moved into the
-    /// \a buffer, and the \a on_read callback is called. The caller must ensure
-    /// that the callback has access to the buffer when executed later.
-    /// Ownership of the buffer is not transferred. Valid slices *may* be placed
-    /// into the buffer even if the callback is invoked with a non-OK Status.
-    ///
-    /// There can be at most one outstanding read per Endpoint at any given
-    /// time. An outstanding read is one in which the \a on_read callback has
-    /// not yet been executed for some previous call to \a Read.  If an attempt
-    /// is made to call \a Read while a previous read is still outstanding, the
-    /// \a EventEngine must abort.
-    ///
-    /// For failed read operations, implementations should pass the appropriate
-    /// statuses to \a on_read. For example, callbacks might expect to receive
-    /// CANCELLED on endpoint shutdown.
-    virtual void Read(absl::AnyInvocable<void(absl::Status)> on_read,
-                      SliceBuffer* buffer, const ReadArgs* args) = 0;
-    /// A struct representing optional arguments that may be provided to an
-    /// EventEngine Endpoint Write API call.
-    ///
-    /// Passed as argument to an Endpoint \a Write
-    struct WriteArgs {
-      // Represents private information that may be passed by gRPC for
-      // select endpoints expected to be used only within google.
-      void* google_specific = nullptr;
-      // A suggestion to the endpoint implementation to group data to be written
-      // into frames of the specified max_frame_size. gRPC may use this
-      // argument to dynamically control the max sizes of frames sent to a
-      // receiver in response to high receiver memory pressure.
-      int64_t max_frame_size;
-    };
-    /// Writes data out on the connection.
-    ///
-    /// \a on_writable is called when the connection is ready for more data. The
-    /// Slices within the \a data buffer may be mutated at will by the Endpoint
-    /// until \a on_writable is called. The \a data SliceBuffer will remain
-    /// valid after calling \a Write, but its state is otherwise undefined.  All
-    /// bytes in \a data must have been written before calling \a on_writable
-    /// unless an error has occurred.
-    ///
-    /// There can be at most one outstanding write per Endpoint at any given
-    /// time. An outstanding write is one in which the \a on_writable callback
-    /// has not yet been executed for some previous call to \a Write.  If an
-    /// attempt is made to call \a Write while a previous write is still
-    /// outstanding, the \a EventEngine must abort.
-    ///
-    /// For failed write operations, implementations should pass the appropriate
-    /// statuses to \a on_writable. For example, callbacks might expect to
-    /// receive CANCELLED on endpoint shutdown.
-    virtual void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
-                       SliceBuffer* data, const WriteArgs* args) = 0;
-    /// Returns an address in the format described in DNSResolver. The returned
-    /// values are expected to remain valid for the life of the Endpoint.
-    virtual const ResolvedAddress& GetPeerAddress() const = 0;
-    virtual const ResolvedAddress& GetLocalAddress() const = 0;
-  };
+            /// One end of a connection between a gRPC client and server. Endpoints are
+            /// created when connections are established, and Endpoint operations are
+            /// gRPC's primary means of communication.
+            ///
+            /// Endpoints must use the provided MemoryAllocator for all data buffer memory
+            /// allocations. gRPC allows applications to set memory constraints per
+            /// Channel or Server, and the implementation depends on all dynamic memory
+            /// allocation being handled by the quota system.
+            class Endpoint
+            {
+            public:
+                /// Shuts down all connections and invokes all pending read or write
+                /// callbacks with an error status.
+                virtual ~Endpoint() = default;
+                /// A struct representing optional arguments that may be provided to an
+                /// EventEngine Endpoint Read API  call.
+                ///
+                /// Passed as argument to an Endpoint \a Read
+                struct ReadArgs
+                {
+                    // A suggestion to the endpoint implementation to read at-least the
+                    // specified number of bytes over the network connection before marking
+                    // the endpoint read operation as complete. gRPC may use this argument
+                    // to minimize the number of endpoint read API calls over the lifetime
+                    // of a connection.
+                    int64_t read_hint_bytes;
+                };
+                /// Reads data from the Endpoint.
+                ///
+                /// When data is available on the connection, that data is moved into the
+                /// \a buffer, and the \a on_read callback is called. The caller must ensure
+                /// that the callback has access to the buffer when executed later.
+                /// Ownership of the buffer is not transferred. Valid slices *may* be placed
+                /// into the buffer even if the callback is invoked with a non-OK Status.
+                ///
+                /// There can be at most one outstanding read per Endpoint at any given
+                /// time. An outstanding read is one in which the \a on_read callback has
+                /// not yet been executed for some previous call to \a Read.  If an attempt
+                /// is made to call \a Read while a previous read is still outstanding, the
+                /// \a EventEngine must abort.
+                ///
+                /// For failed read operations, implementations should pass the appropriate
+                /// statuses to \a on_read. For example, callbacks might expect to receive
+                /// CANCELLED on endpoint shutdown.
+                virtual void Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer, const ReadArgs* args) = 0;
+                /// A struct representing optional arguments that may be provided to an
+                /// EventEngine Endpoint Write API call.
+                ///
+                /// Passed as argument to an Endpoint \a Write
+                struct WriteArgs
+                {
+                    // Represents private information that may be passed by gRPC for
+                    // select endpoints expected to be used only within google.
+                    void* google_specific = nullptr;
+                    // A suggestion to the endpoint implementation to group data to be written
+                    // into frames of the specified max_frame_size. gRPC may use this
+                    // argument to dynamically control the max sizes of frames sent to a
+                    // receiver in response to high receiver memory pressure.
+                    int64_t max_frame_size;
+                };
+                /// Writes data out on the connection.
+                ///
+                /// \a on_writable is called when the connection is ready for more data. The
+                /// Slices within the \a data buffer may be mutated at will by the Endpoint
+                /// until \a on_writable is called. The \a data SliceBuffer will remain
+                /// valid after calling \a Write, but its state is otherwise undefined.  All
+                /// bytes in \a data must have been written before calling \a on_writable
+                /// unless an error has occurred.
+                ///
+                /// There can be at most one outstanding write per Endpoint at any given
+                /// time. An outstanding write is one in which the \a on_writable callback
+                /// has not yet been executed for some previous call to \a Write.  If an
+                /// attempt is made to call \a Write while a previous write is still
+                /// outstanding, the \a EventEngine must abort.
+                ///
+                /// For failed write operations, implementations should pass the appropriate
+                /// statuses to \a on_writable. For example, callbacks might expect to
+                /// receive CANCELLED on endpoint shutdown.
+                virtual void Write(absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data, const WriteArgs* args) = 0;
+                /// Returns an address in the format described in DNSResolver. The returned
+                /// values are expected to remain valid for the life of the Endpoint.
+                virtual const ResolvedAddress& GetPeerAddress() const = 0;
+                virtual const ResolvedAddress& GetLocalAddress() const = 0;
+            };
 
-  /// Called when a new connection is established.
-  ///
-  /// If the connection attempt was not successful, implementations should pass
-  /// the appropriate statuses to this callback. For example, callbacks might
-  /// expect to receive DEADLINE_EXCEEDED statuses when appropriate, or
-  /// CANCELLED statuses on EventEngine shutdown.
-  using OnConnectCallback =
-      absl::AnyInvocable<void(absl::StatusOr<std::unique_ptr<Endpoint>>)>;
+            /// Called when a new connection is established.
+            ///
+            /// If the connection attempt was not successful, implementations should pass
+            /// the appropriate statuses to this callback. For example, callbacks might
+            /// expect to receive DEADLINE_EXCEEDED statuses when appropriate, or
+            /// CANCELLED statuses on EventEngine shutdown.
+            using OnConnectCallback =
+                absl::AnyInvocable<void(absl::StatusOr<std::unique_ptr<Endpoint>>)>;
 
-  /// Listens for incoming connection requests from gRPC clients and initiates
-  /// request processing once connections are established.
-  class Listener {
-   public:
-    /// Called when the listener has accepted a new client connection.
-    using AcceptCallback = absl::AnyInvocable<void(
-        std::unique_ptr<Endpoint>, MemoryAllocator memory_allocator)>;
-    virtual ~Listener() = default;
-    /// Bind an address/port to this Listener.
-    ///
-    /// It is expected that multiple addresses/ports can be bound to this
-    /// Listener before Listener::Start has been called. Returns either the
-    /// bound port or an appropriate error status.
-    virtual absl::StatusOr<int> Bind(const ResolvedAddress& addr) = 0;
-    virtual absl::Status Start() = 0;
-  };
+            /// Listens for incoming connection requests from gRPC clients and initiates
+            /// request processing once connections are established.
+            class Listener
+            {
+            public:
+                /// Called when the listener has accepted a new client connection.
+                using AcceptCallback = absl::AnyInvocable<void(
+                    std::unique_ptr<Endpoint>, MemoryAllocator memory_allocator
+                )>;
+                virtual ~Listener() = default;
+                /// Bind an address/port to this Listener.
+                ///
+                /// It is expected that multiple addresses/ports can be bound to this
+                /// Listener before Listener::Start has been called. Returns either the
+                /// bound port or an appropriate error status.
+                virtual absl::StatusOr<int> Bind(const ResolvedAddress& addr) = 0;
+                virtual absl::Status Start() = 0;
+            };
 
-  /// Factory method to create a network listener / server.
-  ///
-  /// Once a \a Listener is created and started, the \a on_accept callback will
-  /// be called once asynchronously for each established connection. This method
-  /// may return a non-OK status immediately if an error was encountered in any
-  /// synchronous steps required to create the Listener. In this case,
-  /// \a on_shutdown will never be called.
-  ///
-  /// If this method returns a Listener, then \a on_shutdown will be invoked
-  /// exactly once, when the Listener is shut down. The status passed to it will
-  /// indicate if there was a problem during shutdown.
-  ///
-  /// The provided \a MemoryAllocatorFactory is used to create \a
-  /// MemoryAllocators for Endpoint construction.
-  virtual absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
-      Listener::AcceptCallback on_accept,
-      absl::AnyInvocable<void(absl::Status)> on_shutdown,
-      const EndpointConfig& config,
-      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) = 0;
-  /// Creates a client network connection to a remote network listener.
-  ///
-  /// Even in the event of an error, it is expected that the \a on_connect
-  /// callback will be asynchronously executed exactly once by the EventEngine.
-  /// A connection attempt can be cancelled using the \a CancelConnect method.
-  ///
-  /// Implementation Note: it is important that the \a memory_allocator be used
-  /// for all read/write buffer allocations in the EventEngine implementation.
-  /// This allows gRPC's \a ResourceQuota system to monitor and control memory
-  /// usage with graceful degradation mechanisms. Please see the \a
-  /// MemoryAllocator API for more information.
-  virtual ConnectionHandle Connect(OnConnectCallback on_connect,
-                                   const ResolvedAddress& addr,
-                                   const EndpointConfig& args,
-                                   MemoryAllocator memory_allocator,
-                                   Duration timeout) = 0;
+            /// Factory method to create a network listener / server.
+            ///
+            /// Once a \a Listener is created and started, the \a on_accept callback will
+            /// be called once asynchronously for each established connection. This method
+            /// may return a non-OK status immediately if an error was encountered in any
+            /// synchronous steps required to create the Listener. In this case,
+            /// \a on_shutdown will never be called.
+            ///
+            /// If this method returns a Listener, then \a on_shutdown will be invoked
+            /// exactly once, when the Listener is shut down. The status passed to it will
+            /// indicate if there was a problem during shutdown.
+            ///
+            /// The provided \a MemoryAllocatorFactory is used to create \a
+            /// MemoryAllocators for Endpoint construction.
+            virtual absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+                Listener::AcceptCallback on_accept,
+                absl::AnyInvocable<void(absl::Status)> on_shutdown,
+                const EndpointConfig& config,
+                std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory
+            ) = 0;
+            /// Creates a client network connection to a remote network listener.
+            ///
+            /// Even in the event of an error, it is expected that the \a on_connect
+            /// callback will be asynchronously executed exactly once by the EventEngine.
+            /// A connection attempt can be cancelled using the \a CancelConnect method.
+            ///
+            /// Implementation Note: it is important that the \a memory_allocator be used
+            /// for all read/write buffer allocations in the EventEngine implementation.
+            /// This allows gRPC's \a ResourceQuota system to monitor and control memory
+            /// usage with graceful degradation mechanisms. Please see the \a
+            /// MemoryAllocator API for more information.
+            virtual ConnectionHandle Connect(OnConnectCallback on_connect, const ResolvedAddress& addr, const EndpointConfig& args, MemoryAllocator memory_allocator, Duration timeout) = 0;
 
-  /// Request cancellation of a connection attempt.
-  ///
-  /// If the associated connection has already been completed, it will not be
-  /// cancelled, and this method will return false.
-  ///
-  /// If the associated connection has not been completed, it will be cancelled,
-  /// and this method will return true. The \a OnConnectCallback will not be
-  /// called.
-  virtual bool CancelConnect(ConnectionHandle handle) = 0;
-  /// Provides asynchronous resolution.
-  class DNSResolver {
-   public:
-    /// Task handle for DNS Resolution requests.
-    struct LookupTaskHandle {
-      intptr_t keys[2];
-    };
-    /// Optional configuration for DNSResolvers.
-    struct ResolverOptions {
-      /// If empty, default DNS servers will be used.
-      /// Must be in the "IP:port" format as described in naming.md.
-      std::string dns_server;
-    };
-    /// DNS SRV record type.
-    struct SRVRecord {
-      std::string host;
-      int port = 0;
-      int priority = 0;
-      int weight = 0;
-    };
-    /// Called with the collection of sockaddrs that were resolved from a given
-    /// target address.
-    using LookupHostnameCallback =
-        absl::AnyInvocable<void(absl::StatusOr<std::vector<ResolvedAddress>>)>;
-    /// Called with a collection of SRV records.
-    using LookupSRVCallback =
-        absl::AnyInvocable<void(absl::StatusOr<std::vector<SRVRecord>>)>;
-    /// Called with the result of a TXT record lookup
-    using LookupTXTCallback =
-        absl::AnyInvocable<void(absl::StatusOr<std::string>)>;
+            /// Request cancellation of a connection attempt.
+            ///
+            /// If the associated connection has already been completed, it will not be
+            /// cancelled, and this method will return false.
+            ///
+            /// If the associated connection has not been completed, it will be cancelled,
+            /// and this method will return true. The \a OnConnectCallback will not be
+            /// called.
+            virtual bool CancelConnect(ConnectionHandle handle) = 0;
+            /// Provides asynchronous resolution.
+            class DNSResolver
+            {
+            public:
+                /// Task handle for DNS Resolution requests.
+                struct LookupTaskHandle
+                {
+                    intptr_t keys[2];
+                };
+                /// Optional configuration for DNSResolvers.
+                struct ResolverOptions
+                {
+                    /// If empty, default DNS servers will be used.
+                    /// Must be in the "IP:port" format as described in naming.md.
+                    std::string dns_server;
+                };
+                /// DNS SRV record type.
+                struct SRVRecord
+                {
+                    std::string host;
+                    int port = 0;
+                    int priority = 0;
+                    int weight = 0;
+                };
+                /// Called with the collection of sockaddrs that were resolved from a given
+                /// target address.
+                using LookupHostnameCallback =
+                    absl::AnyInvocable<void(absl::StatusOr<std::vector<ResolvedAddress>>)>;
+                /// Called with a collection of SRV records.
+                using LookupSRVCallback =
+                    absl::AnyInvocable<void(absl::StatusOr<std::vector<SRVRecord>>)>;
+                /// Called with the result of a TXT record lookup
+                using LookupTXTCallback =
+                    absl::AnyInvocable<void(absl::StatusOr<std::string>)>;
 
-    virtual ~DNSResolver() = default;
+                virtual ~DNSResolver() = default;
 
-    /// Asynchronously resolve an address.
-    ///
-    /// \a default_port may be a non-numeric named service port, and will only
-    /// be used if \a address does not already contain a port component.
-    ///
-    /// When the lookup is complete, the \a on_resolve callback will be invoked
-    /// with a status indicating the success or failure of the lookup.
-    /// Implementations should pass the appropriate statuses to the callback.
-    /// For example, callbacks might expect to receive DEADLINE_EXCEEDED or
-    /// NOT_FOUND.
-    ///
-    /// If cancelled, \a on_resolve will not be executed.
-    virtual LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
-                                            absl::string_view name,
-                                            absl::string_view default_port,
-                                            Duration timeout) = 0;
-    /// Asynchronously perform an SRV record lookup.
-    ///
-    /// \a on_resolve has the same meaning and expectations as \a
-    /// LookupHostname's \a on_resolve callback.
-    virtual LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
-                                       absl::string_view name,
-                                       Duration timeout) = 0;
-    /// Asynchronously perform a TXT record lookup.
-    ///
-    /// \a on_resolve has the same meaning and expectations as \a
-    /// LookupHostname's \a on_resolve callback.
-    virtual LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
-                                       absl::string_view name,
-                                       Duration timeout) = 0;
-    /// Cancel an asynchronous lookup operation.
-    ///
-    /// This shares the same semantics with \a EventEngine::Cancel: successfully
-    /// cancelled lookups will not have their callbacks executed, and this
-    /// method returns true.
-    virtual bool CancelLookup(LookupTaskHandle handle) = 0;
-  };
+                /// Asynchronously resolve an address.
+                ///
+                /// \a default_port may be a non-numeric named service port, and will only
+                /// be used if \a address does not already contain a port component.
+                ///
+                /// When the lookup is complete, the \a on_resolve callback will be invoked
+                /// with a status indicating the success or failure of the lookup.
+                /// Implementations should pass the appropriate statuses to the callback.
+                /// For example, callbacks might expect to receive DEADLINE_EXCEEDED or
+                /// NOT_FOUND.
+                ///
+                /// If cancelled, \a on_resolve will not be executed.
+                virtual LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve, absl::string_view name, absl::string_view default_port, Duration timeout) = 0;
+                /// Asynchronously perform an SRV record lookup.
+                ///
+                /// \a on_resolve has the same meaning and expectations as \a
+                /// LookupHostname's \a on_resolve callback.
+                virtual LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve, absl::string_view name, Duration timeout) = 0;
+                /// Asynchronously perform a TXT record lookup.
+                ///
+                /// \a on_resolve has the same meaning and expectations as \a
+                /// LookupHostname's \a on_resolve callback.
+                virtual LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve, absl::string_view name, Duration timeout) = 0;
+                /// Cancel an asynchronous lookup operation.
+                ///
+                /// This shares the same semantics with \a EventEngine::Cancel: successfully
+                /// cancelled lookups will not have their callbacks executed, and this
+                /// method returns true.
+                virtual bool CancelLookup(LookupTaskHandle handle) = 0;
+            };
 
-  /// At time of destruction, the EventEngine must have no active
-  /// responsibilities. EventEngine users (applications) are responsible for
-  /// cancelling all tasks and DNS lookups, shutting down listeners and
-  /// endpoints, prior to EventEngine destruction. If there are any outstanding
-  /// tasks, any running listeners, etc. at time of EventEngine destruction,
-  /// that is an invalid use of the API, and it will result in undefined
-  /// behavior.
-  virtual ~EventEngine() = default;
+            /// At time of destruction, the EventEngine must have no active
+            /// responsibilities. EventEngine users (applications) are responsible for
+            /// cancelling all tasks and DNS lookups, shutting down listeners and
+            /// endpoints, prior to EventEngine destruction. If there are any outstanding
+            /// tasks, any running listeners, etc. at time of EventEngine destruction,
+            /// that is an invalid use of the API, and it will result in undefined
+            /// behavior.
+            virtual ~EventEngine() = default;
 
-  // TODO(nnoble): consider whether we can remove this method before we
-  // de-experimentalize this API.
-  virtual bool IsWorkerThread() = 0;
+            // TODO(nnoble): consider whether we can remove this method before we
+            // de-experimentalize this API.
+            virtual bool IsWorkerThread() = 0;
 
-  /// Creates and returns an instance of a DNSResolver, optionally configured by
-  /// the \a options struct.
-  virtual std::unique_ptr<DNSResolver> GetDNSResolver(
-      const DNSResolver::ResolverOptions& options) = 0;
+            /// Creates and returns an instance of a DNSResolver, optionally configured by
+            /// the \a options struct.
+            virtual std::unique_ptr<DNSResolver> GetDNSResolver(
+                const DNSResolver::ResolverOptions& options
+            ) = 0;
 
-  /// Asynchronously executes a task as soon as possible.
-  ///
-  /// \a Closures scheduled with \a Run cannot be cancelled. The \a closure will
-  /// not be deleted after it has been run, ownership remains with the caller.
-  virtual void Run(Closure* closure) = 0;
-  /// Asynchronously executes a task as soon as possible.
-  ///
-  /// \a Closures scheduled with \a Run cannot be cancelled. Unlike the
-  /// overloaded \a Closure alternative, the absl::AnyInvocable version's \a
-  /// closure will be deleted by the EventEngine after the closure has been run.
-  ///
-  /// This version of \a Run may be less performant than the \a Closure version
-  /// in some scenarios. This overload is useful in situations where performance
-  /// is not a critical concern.
-  virtual void Run(absl::AnyInvocable<void()> closure) = 0;
-  /// Synonymous with scheduling an alarm to run after duration \a when.
-  ///
-  /// The \a closure will execute when time \a when arrives unless it has been
-  /// cancelled via the \a Cancel method. If cancelled, the closure will not be
-  /// run, nor will it be deleted. Ownership remains with the caller.
-  virtual TaskHandle RunAfter(Duration when, Closure* closure) = 0;
-  /// Synonymous with scheduling an alarm to run after duration \a when.
-  ///
-  /// The \a closure will execute when time \a when arrives unless it has been
-  /// cancelled via the \a Cancel method. If cancelled, the closure will not be
-  /// run. Unilke the overloaded \a Closure alternative, the absl::AnyInvocable
-  /// version's \a closure will be deleted by the EventEngine after the closure
-  /// has been run, or upon cancellation.
-  ///
-  /// This version of \a RunAfter may be less performant than the \a Closure
-  /// version in some scenarios. This overload is useful in situations where
-  /// performance is not a critical concern.
-  virtual TaskHandle RunAfter(Duration when,
-                              absl::AnyInvocable<void()> closure) = 0;
-  /// Request cancellation of a task.
-  ///
-  /// If the associated closure has already been scheduled to run, it will not
-  /// be cancelled, and this function will return false.
-  ///
-  /// If the associated callback has not been scheduled to run, it will be
-  /// cancelled, and the associated absl::AnyInvocable or \a Closure* will not
-  /// be executed. In this case, Cancel will return true.
-  ///
-  /// Implementation note: closures should be destroyed in a timely manner after
-  /// execution or cancelliation (milliseconds), since any state bound to the
-  /// closure may need to be destroyed for things to progress (e.g., if a
-  /// closure holds a ref to some ref-counted object).
-  virtual bool Cancel(TaskHandle handle) = 0;
-};
+            /// Asynchronously executes a task as soon as possible.
+            ///
+            /// \a Closures scheduled with \a Run cannot be cancelled. The \a closure will
+            /// not be deleted after it has been run, ownership remains with the caller.
+            virtual void Run(Closure* closure) = 0;
+            /// Asynchronously executes a task as soon as possible.
+            ///
+            /// \a Closures scheduled with \a Run cannot be cancelled. Unlike the
+            /// overloaded \a Closure alternative, the absl::AnyInvocable version's \a
+            /// closure will be deleted by the EventEngine after the closure has been run.
+            ///
+            /// This version of \a Run may be less performant than the \a Closure version
+            /// in some scenarios. This overload is useful in situations where performance
+            /// is not a critical concern.
+            virtual void Run(absl::AnyInvocable<void()> closure) = 0;
+            /// Synonymous with scheduling an alarm to run after duration \a when.
+            ///
+            /// The \a closure will execute when time \a when arrives unless it has been
+            /// cancelled via the \a Cancel method. If cancelled, the closure will not be
+            /// run, nor will it be deleted. Ownership remains with the caller.
+            virtual TaskHandle RunAfter(Duration when, Closure* closure) = 0;
+            /// Synonymous with scheduling an alarm to run after duration \a when.
+            ///
+            /// The \a closure will execute when time \a when arrives unless it has been
+            /// cancelled via the \a Cancel method. If cancelled, the closure will not be
+            /// run. Unilke the overloaded \a Closure alternative, the absl::AnyInvocable
+            /// version's \a closure will be deleted by the EventEngine after the closure
+            /// has been run, or upon cancellation.
+            ///
+            /// This version of \a RunAfter may be less performant than the \a Closure
+            /// version in some scenarios. This overload is useful in situations where
+            /// performance is not a critical concern.
+            virtual TaskHandle RunAfter(Duration when, absl::AnyInvocable<void()> closure) = 0;
+            /// Request cancellation of a task.
+            ///
+            /// If the associated closure has already been scheduled to run, it will not
+            /// be cancelled, and this function will return false.
+            ///
+            /// If the associated callback has not been scheduled to run, it will be
+            /// cancelled, and the associated absl::AnyInvocable or \a Closure* will not
+            /// be executed. In this case, Cancel will return true.
+            ///
+            /// Implementation note: closures should be destroyed in a timely manner after
+            /// execution or cancelliation (milliseconds), since any state bound to the
+            /// closure may need to be destroyed for things to progress (e.g., if a
+            /// closure holds a ref to some ref-counted object).
+            virtual bool Cancel(TaskHandle handle) = 0;
+        };
 
-/// Replace gRPC's default EventEngine factory.
-///
-/// Applications may call \a SetDefaultEventEngineFactory at any time to replace
-/// the default factory used within gRPC. EventEngines will be created when
-/// necessary, when they are otherwise not provided by the application.
-///
-/// To be certain that none of the gRPC-provided built-in EventEngines are
-/// created, applications must set a custom EventEngine factory method *before*
-/// grpc is initialized.
-void SetDefaultEventEngineFactory(
-    absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory);
+        /// Replace gRPC's default EventEngine factory.
+        ///
+        /// Applications may call \a SetDefaultEventEngineFactory at any time to replace
+        /// the default factory used within gRPC. EventEngines will be created when
+        /// necessary, when they are otherwise not provided by the application.
+        ///
+        /// To be certain that none of the gRPC-provided built-in EventEngines are
+        /// created, applications must set a custom EventEngine factory method *before*
+        /// grpc is initialized.
+        void SetDefaultEventEngineFactory(
+            absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory
+        );
 
-/// Create an EventEngine using the default factory.
-std::unique_ptr<EventEngine> CreateEventEngine();
+        /// Create an EventEngine using the default factory.
+        std::unique_ptr<EventEngine> CreateEventEngine();
 
-}  // namespace experimental
+    }  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_EVENT_ENGINE_EVENT_ENGINE_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/internal/memory_allocator_impl.h b/CAPI/cpp/grpc/include/grpc/event_engine/internal/memory_allocator_impl.h
index e0ca2f5..5dbb766 100644
--- a/CAPI/cpp/grpc/include/grpc/event_engine/internal/memory_allocator_impl.h
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/internal/memory_allocator_impl.h
@@ -24,45 +24,52 @@
 #include <grpc/event_engine/memory_request.h>
 #include <grpc/slice.h>
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine
+{
+    namespace experimental
+    {
 
-namespace internal {
+        namespace internal
+        {
 
-/// Underlying memory allocation interface.
-/// This is an internal interface, not intended to be used by users.
-/// Its interface is subject to change at any time.
-class MemoryAllocatorImpl
-    : public std::enable_shared_from_this<MemoryAllocatorImpl> {
- public:
-  MemoryAllocatorImpl() {}
-  virtual ~MemoryAllocatorImpl() {}
+            /// Underlying memory allocation interface.
+            /// This is an internal interface, not intended to be used by users.
+            /// Its interface is subject to change at any time.
+            class MemoryAllocatorImpl : public std::enable_shared_from_this<MemoryAllocatorImpl>
+            {
+            public:
+                MemoryAllocatorImpl()
+                {
+                }
+                virtual ~MemoryAllocatorImpl()
+                {
+                }
 
-  MemoryAllocatorImpl(const MemoryAllocatorImpl&) = delete;
-  MemoryAllocatorImpl& operator=(const MemoryAllocatorImpl&) = delete;
+                MemoryAllocatorImpl(const MemoryAllocatorImpl&) = delete;
+                MemoryAllocatorImpl& operator=(const MemoryAllocatorImpl&) = delete;
 
-  /// Reserve bytes from the quota.
-  /// If we enter overcommit, reclamation will begin concurrently.
-  /// Returns the number of bytes reserved.
-  /// If MemoryRequest is invalid, this function will abort.
-  /// If MemoryRequest is valid, this function is infallible, and will always
-  /// succeed at reserving the some number of bytes between request.min() and
-  /// request.max() inclusively.
-  virtual size_t Reserve(MemoryRequest request) = 0;
+                /// Reserve bytes from the quota.
+                /// If we enter overcommit, reclamation will begin concurrently.
+                /// Returns the number of bytes reserved.
+                /// If MemoryRequest is invalid, this function will abort.
+                /// If MemoryRequest is valid, this function is infallible, and will always
+                /// succeed at reserving the some number of bytes between request.min() and
+                /// request.max() inclusively.
+                virtual size_t Reserve(MemoryRequest request) = 0;
 
-  /// Release some bytes that were previously reserved.
-  /// If more bytes are released than were reserved, we will have undefined
-  /// behavior.
-  virtual void Release(size_t n) = 0;
+                /// Release some bytes that were previously reserved.
+                /// If more bytes are released than were reserved, we will have undefined
+                /// behavior.
+                virtual void Release(size_t n) = 0;
 
-  /// Shutdown this allocator.
-  /// Further usage of Reserve() is undefined behavior.
-  virtual void Shutdown() = 0;
-};
+                /// Shutdown this allocator.
+                /// Further usage of Reserve() is undefined behavior.
+                virtual void Shutdown() = 0;
+            };
 
-}  // namespace internal
+        }  // namespace internal
 
-}  // namespace experimental
+    }  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_EVENT_ENGINE_INTERNAL_MEMORY_ALLOCATOR_IMPL_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/memory_allocator.h b/CAPI/cpp/grpc/include/grpc/event_engine/memory_allocator.h
index ec10674..272fcd0 100644
--- a/CAPI/cpp/grpc/include/grpc/event_engine/memory_allocator.h
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/memory_allocator.h
@@ -26,186 +26,235 @@
 #include <grpc/event_engine/internal/memory_allocator_impl.h>
 #include <grpc/slice.h>
 
-namespace grpc_event_engine {
-namespace experimental {
-
-// Tracks memory allocated by one system.
-// Is effectively a thin wrapper/smart pointer for a MemoryAllocatorImpl,
-// providing a convenient and stable API.
-class MemoryAllocator {
- public:
-  /// Construct a MemoryAllocator given an internal::MemoryAllocatorImpl
-  /// implementation. The constructed MemoryAllocator will call
-  /// MemoryAllocatorImpl::Shutdown() upon destruction.
-  explicit MemoryAllocator(
-      std::shared_ptr<internal::MemoryAllocatorImpl> allocator)
-      : allocator_(std::move(allocator)) {}
-  // Construct an invalid MemoryAllocator.
-  MemoryAllocator() : allocator_(nullptr) {}
-  ~MemoryAllocator() {
-    if (allocator_ != nullptr) allocator_->Shutdown();
-  }
-
-  MemoryAllocator(const MemoryAllocator&) = delete;
-  MemoryAllocator& operator=(const MemoryAllocator&) = delete;
-
-  MemoryAllocator(MemoryAllocator&&) = default;
-  MemoryAllocator& operator=(MemoryAllocator&&) = default;
-
-  /// Drop the underlying allocator and make this an empty object.
-  /// The object will not be usable after this call unless it's a valid
-  /// allocator is moved into it.
-  void Reset() {
-    if (allocator_ != nullptr) allocator_->Shutdown();
-    allocator_.reset();
-  }
-
-  /// Reserve bytes from the quota.
-  /// If we enter overcommit, reclamation will begin concurrently.
-  /// Returns the number of bytes reserved.
-  size_t Reserve(MemoryRequest request) { return allocator_->Reserve(request); }
-
-  /// Release some bytes that were previously reserved.
-  void Release(size_t n) { return allocator_->Release(n); }
-
-  //
-  // The remainder of this type are helper functions implemented in terms of
-  // Reserve/Release.
-  //
-
-  /// An automatic releasing reservation of memory.
-  class Reservation {
-   public:
-    Reservation() = default;
-    Reservation(const Reservation&) = delete;
-    Reservation& operator=(const Reservation&) = delete;
-    Reservation(Reservation&&) = default;
-    Reservation& operator=(Reservation&&) = default;
-    ~Reservation() {
-      if (allocator_ != nullptr) allocator_->Release(size_);
-    }
-
-   private:
-    friend class MemoryAllocator;
-    Reservation(std::shared_ptr<internal::MemoryAllocatorImpl> allocator,
-                size_t size)
-        : allocator_(std::move(allocator)), size_(size) {}
-
-    std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
-    size_t size_ = 0;
-  };
-
-  /// Reserve bytes from the quota and automatically release them when
-  /// Reservation is destroyed.
-  Reservation MakeReservation(MemoryRequest request) {
-    return Reservation(allocator_, Reserve(request));
-  }
-
-  /// Allocate a new object of type T, with constructor arguments.
-  /// The returned type is wrapped, and upon destruction the reserved memory
-  /// will be released to the allocator automatically. As such, T must have a
-  /// virtual destructor so we can insert the necessary hook.
-  template <typename T, typename... Args>
-  typename std::enable_if<std::has_virtual_destructor<T>::value, T*>::type New(
-      Args&&... args) {
-    // Wrap T such that when it's destroyed, we can release memory back to the
-    // allocator.
-    class Wrapper final : public T {
-     public:
-      explicit Wrapper(std::shared_ptr<internal::MemoryAllocatorImpl> allocator,
-                       Args&&... args)
-          : T(std::forward<Args>(args)...), allocator_(std::move(allocator)) {}
-      ~Wrapper() override { allocator_->Release(sizeof(*this)); }
-
-     private:
-      const std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
-    };
-    Reserve(sizeof(Wrapper));
-    return new Wrapper(allocator_, std::forward<Args>(args)...);
-  }
-
-  /// Construct a unique_ptr immediately.
-  template <typename T, typename... Args>
-  std::unique_ptr<T> MakeUnique(Args&&... args) {
-    return std::unique_ptr<T>(New<T>(std::forward<Args>(args)...));
-  }
-
-  /// Allocate a slice, using MemoryRequest to size the number of returned
-  /// bytes. For a variable length request, check the returned slice length to
-  /// verify how much memory was allocated. Takes care of reserving memory for
-  /// any relevant control structures also.
-  grpc_slice MakeSlice(MemoryRequest request);
-
-  /// A C++ allocator for containers of T.
-  template <typename T>
-  class Container {
-   public:
-    using value_type = T;
-
-    /// Construct the allocator: \a underlying_allocator is borrowed, and must
-    /// outlive this object.
-    explicit Container(MemoryAllocator* underlying_allocator)
-        : underlying_allocator_(underlying_allocator) {}
-    template <typename U>
-    explicit Container(const Container<U>& other)
-        : underlying_allocator_(other.underlying_allocator()) {}
-
-    MemoryAllocator* underlying_allocator() const {
-      return underlying_allocator_;
-    }
-
-    T* allocate(size_t n) {
-      underlying_allocator_->Reserve(n * sizeof(T));
-      return static_cast<T*>(::operator new(n * sizeof(T)));
-    }
-    void deallocate(T* p, size_t n) {
-      ::operator delete(p);
-      underlying_allocator_->Release(n * sizeof(T));
-    }
-
-   private:
-    MemoryAllocator* underlying_allocator_;
-  };
-
- protected:
-  /// Return a pointer to the underlying implementation.
-  /// Note that the interface of said implementation is unstable and likely to
-  /// change at any time.
-  internal::MemoryAllocatorImpl* get_internal_impl_ptr() {
-    return allocator_.get();
-  }
-
-  const internal::MemoryAllocatorImpl* get_internal_impl_ptr() const {
-    return allocator_.get();
-  }
-
- private:
-  std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
-};
-
-// Wrapper type around std::vector to make initialization against a
-// MemoryAllocator based container allocator easy.
-template <typename T>
-class Vector : public std::vector<T, MemoryAllocator::Container<T>> {
- public:
-  explicit Vector(MemoryAllocator* allocator)
-      : std::vector<T, MemoryAllocator::Container<T>>(
-            MemoryAllocator::Container<T>(allocator)) {}
-};
-
-class MemoryAllocatorFactory {
- public:
-  virtual ~MemoryAllocatorFactory() = default;
-  /// On Endpoint creation, call \a CreateMemoryAllocator to create a new
-  /// allocator for the endpoint.
-  /// \a name is used to label the memory allocator in debug logs.
-  /// Typically we'll want to:
-  ///    auto allocator = factory->CreateMemoryAllocator(peer_address_string);
-  ///    auto* endpoint = allocator->New<MyEndpoint>(std::move(allocator), ...);
-  virtual MemoryAllocator CreateMemoryAllocator(absl::string_view name) = 0;
-};
-
-}  // namespace experimental
+namespace grpc_event_engine
+{
+    namespace experimental
+    {
+
+        // Tracks memory allocated by one system.
+        // Is effectively a thin wrapper/smart pointer for a MemoryAllocatorImpl,
+        // providing a convenient and stable API.
+        class MemoryAllocator
+        {
+        public:
+            /// Construct a MemoryAllocator given an internal::MemoryAllocatorImpl
+            /// implementation. The constructed MemoryAllocator will call
+            /// MemoryAllocatorImpl::Shutdown() upon destruction.
+            explicit MemoryAllocator(
+                std::shared_ptr<internal::MemoryAllocatorImpl> allocator
+            ) :
+                allocator_(std::move(allocator))
+            {
+            }
+            // Construct an invalid MemoryAllocator.
+            MemoryAllocator() :
+                allocator_(nullptr)
+            {
+            }
+            ~MemoryAllocator()
+            {
+                if (allocator_ != nullptr)
+                    allocator_->Shutdown();
+            }
+
+            MemoryAllocator(const MemoryAllocator&) = delete;
+            MemoryAllocator& operator=(const MemoryAllocator&) = delete;
+
+            MemoryAllocator(MemoryAllocator&&) = default;
+            MemoryAllocator& operator=(MemoryAllocator&&) = default;
+
+            /// Drop the underlying allocator and make this an empty object.
+            /// The object will not be usable after this call unless it's a valid
+            /// allocator is moved into it.
+            void Reset()
+            {
+                if (allocator_ != nullptr)
+                    allocator_->Shutdown();
+                allocator_.reset();
+            }
+
+            /// Reserve bytes from the quota.
+            /// If we enter overcommit, reclamation will begin concurrently.
+            /// Returns the number of bytes reserved.
+            size_t Reserve(MemoryRequest request)
+            {
+                return allocator_->Reserve(request);
+            }
+
+            /// Release some bytes that were previously reserved.
+            void Release(size_t n)
+            {
+                return allocator_->Release(n);
+            }
+
+            //
+            // The remainder of this type are helper functions implemented in terms of
+            // Reserve/Release.
+            //
+
+            /// An automatic releasing reservation of memory.
+            class Reservation
+            {
+            public:
+                Reservation() = default;
+                Reservation(const Reservation&) = delete;
+                Reservation& operator=(const Reservation&) = delete;
+                Reservation(Reservation&&) = default;
+                Reservation& operator=(Reservation&&) = default;
+                ~Reservation()
+                {
+                    if (allocator_ != nullptr)
+                        allocator_->Release(size_);
+                }
+
+            private:
+                friend class MemoryAllocator;
+                Reservation(std::shared_ptr<internal::MemoryAllocatorImpl> allocator, size_t size) :
+                    allocator_(std::move(allocator)),
+                    size_(size)
+                {
+                }
+
+                std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
+                size_t size_ = 0;
+            };
+
+            /// Reserve bytes from the quota and automatically release them when
+            /// Reservation is destroyed.
+            Reservation MakeReservation(MemoryRequest request)
+            {
+                return Reservation(allocator_, Reserve(request));
+            }
+
+            /// Allocate a new object of type T, with constructor arguments.
+            /// The returned type is wrapped, and upon destruction the reserved memory
+            /// will be released to the allocator automatically. As such, T must have a
+            /// virtual destructor so we can insert the necessary hook.
+            template<typename T, typename... Args>
+            typename std::enable_if<std::has_virtual_destructor<T>::value, T*>::type New(
+                Args&&... args
+            )
+            {
+                // Wrap T such that when it's destroyed, we can release memory back to the
+                // allocator.
+                class Wrapper final : public T
+                {
+                public:
+                    explicit Wrapper(std::shared_ptr<internal::MemoryAllocatorImpl> allocator, Args&&... args) :
+                        T(std::forward<Args>(args)...),
+                        allocator_(std::move(allocator))
+                    {
+                    }
+                    ~Wrapper() override
+                    {
+                        allocator_->Release(sizeof(*this));
+                    }
+
+                private:
+                    const std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
+                };
+                Reserve(sizeof(Wrapper));
+                return new Wrapper(allocator_, std::forward<Args>(args)...);
+            }
+
+            /// Construct a unique_ptr immediately.
+            template<typename T, typename... Args>
+            std::unique_ptr<T> MakeUnique(Args&&... args)
+            {
+                return std::unique_ptr<T>(New<T>(std::forward<Args>(args)...));
+            }
+
+            /// Allocate a slice, using MemoryRequest to size the number of returned
+            /// bytes. For a variable length request, check the returned slice length to
+            /// verify how much memory was allocated. Takes care of reserving memory for
+            /// any relevant control structures also.
+            grpc_slice MakeSlice(MemoryRequest request);
+
+            /// A C++ allocator for containers of T.
+            template<typename T>
+            class Container
+            {
+            public:
+                using value_type = T;
+
+                /// Construct the allocator: \a underlying_allocator is borrowed, and must
+                /// outlive this object.
+                explicit Container(MemoryAllocator* underlying_allocator) :
+                    underlying_allocator_(underlying_allocator)
+                {
+                }
+                template<typename U>
+                explicit Container(const Container<U>& other) :
+                    underlying_allocator_(other.underlying_allocator())
+                {
+                }
+
+                MemoryAllocator* underlying_allocator() const
+                {
+                    return underlying_allocator_;
+                }
+
+                T* allocate(size_t n)
+                {
+                    underlying_allocator_->Reserve(n * sizeof(T));
+                    return static_cast<T*>(::operator new(n * sizeof(T)));
+                }
+                void deallocate(T* p, size_t n)
+                {
+                    ::operator delete(p);
+                    underlying_allocator_->Release(n * sizeof(T));
+                }
+
+            private:
+                MemoryAllocator* underlying_allocator_;
+            };
+
+        protected:
+            /// Return a pointer to the underlying implementation.
+            /// Note that the interface of said implementation is unstable and likely to
+            /// change at any time.
+            internal::MemoryAllocatorImpl* get_internal_impl_ptr()
+            {
+                return allocator_.get();
+            }
+
+            const internal::MemoryAllocatorImpl* get_internal_impl_ptr() const
+            {
+                return allocator_.get();
+            }
+
+        private:
+            std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
+        };
+
+        // Wrapper type around std::vector to make initialization against a
+        // MemoryAllocator based container allocator easy.
+        template<typename T>
+        class Vector : public std::vector<T, MemoryAllocator::Container<T>>
+        {
+        public:
+            explicit Vector(MemoryAllocator* allocator) :
+                std::vector<T, MemoryAllocator::Container<T>>(
+                    MemoryAllocator::Container<T>(allocator)
+                )
+            {
+            }
+        };
+
+        class MemoryAllocatorFactory
+        {
+        public:
+            virtual ~MemoryAllocatorFactory() = default;
+            /// On Endpoint creation, call \a CreateMemoryAllocator to create a new
+            /// allocator for the endpoint.
+            /// \a name is used to label the memory allocator in debug logs.
+            /// Typically we'll want to:
+            ///    auto allocator = factory->CreateMemoryAllocator(peer_address_string);
+            ///    auto* endpoint = allocator->New<MyEndpoint>(std::move(allocator), ...);
+            virtual MemoryAllocator CreateMemoryAllocator(absl::string_view name) = 0;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_EVENT_ENGINE_MEMORY_ALLOCATOR_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/memory_request.h b/CAPI/cpp/grpc/include/grpc/event_engine/memory_request.h
index fa15e26..ad890fe 100644
--- a/CAPI/cpp/grpc/include/grpc/event_engine/memory_request.h
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/memory_request.h
@@ -20,38 +20,59 @@
 
 #include "absl/strings/string_view.h"
 
-namespace grpc_event_engine {
-namespace experimental {
-
-/// Reservation request - how much memory do we want to allocate?
-class MemoryRequest {
- public:
-  /// Request a fixed amount of memory.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  MemoryRequest(size_t n) : min_(n), max_(n) {}
-  /// Request a range of memory.
-  /// Requires: \a min <= \a max.
-  /// Requires: \a max <= max_size()
-  MemoryRequest(size_t min, size_t max) : min_(min), max_(max) {}
-
-  /// Maximum allowable request size - hard coded to 1GB.
-  static constexpr size_t max_allowed_size() { return 1024 * 1024 * 1024; }
-
-  /// Increase the size by \a amount.
-  /// Undefined behavior if min() + amount or max() + amount overflows.
-  MemoryRequest Increase(size_t amount) const {
-    return MemoryRequest(min_ + amount, max_ + amount);
-  }
-
-  size_t min() const { return min_; }
-  size_t max() const { return max_; }
-
- private:
-  size_t min_;
-  size_t max_;
-};
-
-}  // namespace experimental
+namespace grpc_event_engine
+{
+    namespace experimental
+    {
+
+        /// Reservation request - how much memory do we want to allocate?
+        class MemoryRequest
+        {
+        public:
+            /// Request a fixed amount of memory.
+            // NOLINTNEXTLINE(google-explicit-constructor)
+            MemoryRequest(size_t n) :
+                min_(n),
+                max_(n)
+            {
+            }
+            /// Request a range of memory.
+            /// Requires: \a min <= \a max.
+            /// Requires: \a max <= max_size()
+            MemoryRequest(size_t min, size_t max) :
+                min_(min),
+                max_(max)
+            {
+            }
+
+            /// Maximum allowable request size - hard coded to 1GB.
+            static constexpr size_t max_allowed_size()
+            {
+                return 1024 * 1024 * 1024;
+            }
+
+            /// Increase the size by \a amount.
+            /// Undefined behavior if min() + amount or max() + amount overflows.
+            MemoryRequest Increase(size_t amount) const
+            {
+                return MemoryRequest(min_ + amount, max_ + amount);
+            }
+
+            size_t min() const
+            {
+                return min_;
+            }
+            size_t max() const
+            {
+                return max_;
+            }
+
+        private:
+            size_t min_;
+            size_t max_;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_EVENT_ENGINE_MEMORY_REQUEST_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/slice.h b/CAPI/cpp/grpc/include/grpc/event_engine/slice.h
index 515cdfd..3039c45 100644
--- a/CAPI/cpp/grpc/include/grpc/event_engine/slice.h
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/slice.h
@@ -32,255 +32,357 @@
 // implementation. Changes to this implementation might warrant changes to the
 // internal grpc_core::Slice type as well.
 
-namespace grpc_event_engine {
-namespace experimental {
-
-// Forward declarations
-class Slice;
-class MutableSlice;
-
-namespace slice_detail {
-
-// Returns an empty slice.
-static constexpr grpc_slice EmptySlice() { return {nullptr, {}}; }
-
-// BaseSlice holds the grpc_slice object, but does not apply refcounting policy.
-// It does export immutable access into the slice, such that this can be shared
-// by all storage policies.
-class BaseSlice {
- public:
-  BaseSlice(const BaseSlice&) = delete;
-  BaseSlice& operator=(const BaseSlice&) = delete;
-  BaseSlice(BaseSlice&& other) = delete;
-  BaseSlice& operator=(BaseSlice&& other) = delete;
-
-  // Iterator access to the underlying bytes
-  const uint8_t* begin() const { return GRPC_SLICE_START_PTR(c_slice()); }
-  const uint8_t* end() const { return GRPC_SLICE_END_PTR(c_slice()); }
-  const uint8_t* cbegin() const { return GRPC_SLICE_START_PTR(c_slice()); }
-  const uint8_t* cend() const { return GRPC_SLICE_END_PTR(c_slice()); }
-
-  // Retrieve a borrowed reference to the underlying grpc_slice.
-  const grpc_slice& c_slice() const { return slice_; }
-
-  // Retrieve the underlying grpc_slice, and replace the one in this object with
-  // EmptySlice().
-  grpc_slice TakeCSlice() {
-    grpc_slice out = slice_;
-    slice_ = EmptySlice();
-    return out;
-  }
-
-  // As other things... borrowed references.
-  absl::string_view as_string_view() const {
-    return absl::string_view(reinterpret_cast<const char*>(data()), size());
-  }
-
-  // Array access
-  uint8_t operator[](size_t i) const {
-    return GRPC_SLICE_START_PTR(c_slice())[i];
-  }
-
-  // Access underlying data
-  const uint8_t* data() const { return GRPC_SLICE_START_PTR(c_slice()); }
-
-  // Size of the slice
-  size_t size() const { return GRPC_SLICE_LENGTH(c_slice()); }
-  size_t length() const { return size(); }
-  bool empty() const { return size() == 0; }
-
-  // For inlined slices - are these two slices equal?
-  // For non-inlined slices - do these two slices refer to the same block of
-  // memory?
-  bool is_equivalent(const BaseSlice& other) const {
-    return grpc_slice_is_equivalent(slice_, other.slice_);
-  }
-
-  uint32_t Hash() const;
-
- protected:
-  BaseSlice() : slice_(EmptySlice()) {}
-  explicit BaseSlice(const grpc_slice& slice) : slice_(slice) {}
-  ~BaseSlice() = default;
-
-  void Swap(BaseSlice* other) { std::swap(slice_, other->slice_); }
-  void SetCSlice(const grpc_slice& slice) { slice_ = slice; }
-
-  uint8_t* mutable_data() { return GRPC_SLICE_START_PTR(slice_); }
-
-  grpc_slice* c_slice_ptr() { return &slice_; }
-
- private:
-  grpc_slice slice_;
-};
-
-inline bool operator==(const BaseSlice& a, const BaseSlice& b) {
-  return grpc_slice_eq(a.c_slice(), b.c_slice()) != 0;
-}
-
-inline bool operator!=(const BaseSlice& a, const BaseSlice& b) {
-  return grpc_slice_eq(a.c_slice(), b.c_slice()) == 0;
-}
-
-inline bool operator==(const BaseSlice& a, absl::string_view b) {
-  return a.as_string_view() == b;
-}
-
-inline bool operator!=(const BaseSlice& a, absl::string_view b) {
-  return a.as_string_view() != b;
-}
-
-inline bool operator==(absl::string_view a, const BaseSlice& b) {
-  return a == b.as_string_view();
-}
-
-inline bool operator!=(absl::string_view a, const BaseSlice& b) {
-  return a != b.as_string_view();
-}
-
-inline bool operator==(const BaseSlice& a, const grpc_slice& b) {
-  return grpc_slice_eq(a.c_slice(), b) != 0;
-}
-
-inline bool operator!=(const BaseSlice& a, const grpc_slice& b) {
-  return grpc_slice_eq(a.c_slice(), b) == 0;
-}
-
-inline bool operator==(const grpc_slice& a, const BaseSlice& b) {
-  return grpc_slice_eq(a, b.c_slice()) != 0;
-}
-
-inline bool operator!=(const grpc_slice& a, const BaseSlice& b) {
-  return grpc_slice_eq(a, b.c_slice()) == 0;
-}
-
-template <typename Out>
-struct CopyConstructors {
-  static Out FromCopiedString(const char* s) {
-    return FromCopiedBuffer(s, strlen(s));
-  }
-  static Out FromCopiedString(absl::string_view s) {
-    return FromCopiedBuffer(s.data(), s.size());
-  }
-  static Out FromCopiedString(std::string s);
-
-  static Out FromCopiedBuffer(const char* p, size_t len) {
-    return Out(grpc_slice_from_copied_buffer(p, len));
-  }
-
-  template <typename Buffer>
-  static Out FromCopiedBuffer(const Buffer& buffer) {
-    return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()),
-                            buffer.size());
-  }
-};
-
-}  // namespace slice_detail
-
-class MutableSlice : public slice_detail::BaseSlice,
-                     public slice_detail::CopyConstructors<MutableSlice> {
- public:
-  MutableSlice() = default;
-  explicit MutableSlice(const grpc_slice& slice);
-  ~MutableSlice();
-
-  MutableSlice(const MutableSlice&) = delete;
-  MutableSlice& operator=(const MutableSlice&) = delete;
-  MutableSlice(MutableSlice&& other) noexcept
-      : slice_detail::BaseSlice(other.TakeCSlice()) {}
-  MutableSlice& operator=(MutableSlice&& other) noexcept {
-    Swap(&other);
-    return *this;
-  }
-
-  static MutableSlice CreateUninitialized(size_t length) {
-    return MutableSlice(grpc_slice_malloc(length));
-  }
-
-  // Return a sub slice of this one. Leaves this slice in an indeterminate but
-  // valid state.
-  MutableSlice TakeSubSlice(size_t pos, size_t n) {
-    return MutableSlice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
-  }
-
-  // Iterator access to the underlying bytes
-  uint8_t* begin() { return mutable_data(); }
-  uint8_t* end() { return mutable_data() + size(); }
-  uint8_t* data() { return mutable_data(); }
-
-  // Array access
-  uint8_t& operator[](size_t i) { return mutable_data()[i]; }
-};
-
-class Slice : public slice_detail::BaseSlice,
-              public slice_detail::CopyConstructors<Slice> {
- public:
-  Slice() = default;
-  ~Slice();
-  explicit Slice(const grpc_slice& slice) : slice_detail::BaseSlice(slice) {}
-  explicit Slice(slice_detail::BaseSlice&& other)
-      : slice_detail::BaseSlice(other.TakeCSlice()) {}
-
-  Slice(const Slice&) = delete;
-  Slice& operator=(const Slice&) = delete;
-  Slice(Slice&& other) noexcept : slice_detail::BaseSlice(other.TakeCSlice()) {}
-  Slice& operator=(Slice&& other) noexcept {
-    Swap(&other);
-    return *this;
-  }
-
-  // A slice might refer to some memory that we keep a refcount to (this is
-  // owned), or some memory that's inlined into the slice (also owned), or some
-  // other block of memory that we know will be available for the lifetime of
-  // some operation in the common case (not owned). In the *less common* case
-  // that we need to keep that slice text for longer than our API's guarantee us
-  // access, we need to take a copy and turn this into something that we do own.
-
-  // TakeOwned returns an owned slice regardless of current ownership, and
-  // leaves the current slice in a valid but externally unpredictable state - in
-  // doing so it can avoid adding a ref to the underlying slice.
-  Slice TakeOwned();
-
-  // AsOwned returns an owned slice but does not mutate the current slice,
-  // meaning that it may add a reference to the underlying slice.
-  Slice AsOwned() const;
-
-  // TakeMutable returns a MutableSlice, and leaves the current slice in an
-  // indeterminate but valid state.
-  // A mutable slice requires only one reference to the bytes of the slice -
-  // this can be achieved either with inlined storage or with a single
-  // reference.
-  // If the current slice is refcounted and there are more than one references
-  // to that slice, then the slice is copied in order to achieve a mutable
-  // version.
-  MutableSlice TakeMutable();
-
-  // Return a sub slice of this one. Leaves this slice in an indeterminate but
-  // valid state.
-  Slice TakeSubSlice(size_t pos, size_t n) {
-    return Slice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
-  }
-
-  // Return a sub slice of this one. Adds a reference to the underlying slice.
-  Slice RefSubSlice(size_t pos, size_t n) const {
-    return Slice(grpc_slice_sub(c_slice(), pos, pos + n));
-  }
-
-  // Split this slice, returning a new slice containing (split:end] and
-  // leaving this slice with [begin:split).
-  Slice Split(size_t split) {
-    return Slice(grpc_slice_split_tail(c_slice_ptr(), split));
-  }
-
-  Slice Ref() const;
-
-  Slice Copy() const { return Slice(grpc_slice_copy(c_slice())); }
-
-  static Slice FromRefcountAndBytes(grpc_slice_refcount* r,
-                                    const uint8_t* begin, const uint8_t* end);
-};
-
-}  // namespace experimental
+namespace grpc_event_engine
+{
+    namespace experimental
+    {
+
+        // Forward declarations
+        class Slice;
+        class MutableSlice;
+
+        namespace slice_detail
+        {
+
+            // Returns an empty slice.
+            static constexpr grpc_slice EmptySlice()
+            {
+                return {nullptr, {}};
+            }
+
+            // BaseSlice holds the grpc_slice object, but does not apply refcounting policy.
+            // It does export immutable access into the slice, such that this can be shared
+            // by all storage policies.
+            class BaseSlice
+            {
+            public:
+                BaseSlice(const BaseSlice&) = delete;
+                BaseSlice& operator=(const BaseSlice&) = delete;
+                BaseSlice(BaseSlice&& other) = delete;
+                BaseSlice& operator=(BaseSlice&& other) = delete;
+
+                // Iterator access to the underlying bytes
+                const uint8_t* begin() const
+                {
+                    return GRPC_SLICE_START_PTR(c_slice());
+                }
+                const uint8_t* end() const
+                {
+                    return GRPC_SLICE_END_PTR(c_slice());
+                }
+                const uint8_t* cbegin() const
+                {
+                    return GRPC_SLICE_START_PTR(c_slice());
+                }
+                const uint8_t* cend() const
+                {
+                    return GRPC_SLICE_END_PTR(c_slice());
+                }
+
+                // Retrieve a borrowed reference to the underlying grpc_slice.
+                const grpc_slice& c_slice() const
+                {
+                    return slice_;
+                }
+
+                // Retrieve the underlying grpc_slice, and replace the one in this object with
+                // EmptySlice().
+                grpc_slice TakeCSlice()
+                {
+                    grpc_slice out = slice_;
+                    slice_ = EmptySlice();
+                    return out;
+                }
+
+                // As other things... borrowed references.
+                absl::string_view as_string_view() const
+                {
+                    return absl::string_view(reinterpret_cast<const char*>(data()), size());
+                }
+
+                // Array access
+                uint8_t operator[](size_t i) const
+                {
+                    return GRPC_SLICE_START_PTR(c_slice())[i];
+                }
+
+                // Access underlying data
+                const uint8_t* data() const
+                {
+                    return GRPC_SLICE_START_PTR(c_slice());
+                }
+
+                // Size of the slice
+                size_t size() const
+                {
+                    return GRPC_SLICE_LENGTH(c_slice());
+                }
+                size_t length() const
+                {
+                    return size();
+                }
+                bool empty() const
+                {
+                    return size() == 0;
+                }
+
+                // For inlined slices - are these two slices equal?
+                // For non-inlined slices - do these two slices refer to the same block of
+                // memory?
+                bool is_equivalent(const BaseSlice& other) const
+                {
+                    return grpc_slice_is_equivalent(slice_, other.slice_);
+                }
+
+                uint32_t Hash() const;
+
+            protected:
+                BaseSlice() :
+                    slice_(EmptySlice())
+                {
+                }
+                explicit BaseSlice(const grpc_slice& slice) :
+                    slice_(slice)
+                {
+                }
+                ~BaseSlice() = default;
+
+                void Swap(BaseSlice* other)
+                {
+                    std::swap(slice_, other->slice_);
+                }
+                void SetCSlice(const grpc_slice& slice)
+                {
+                    slice_ = slice;
+                }
+
+                uint8_t* mutable_data()
+                {
+                    return GRPC_SLICE_START_PTR(slice_);
+                }
+
+                grpc_slice* c_slice_ptr()
+                {
+                    return &slice_;
+                }
+
+            private:
+                grpc_slice slice_;
+            };
+
+            inline bool operator==(const BaseSlice& a, const BaseSlice& b)
+            {
+                return grpc_slice_eq(a.c_slice(), b.c_slice()) != 0;
+            }
+
+            inline bool operator!=(const BaseSlice& a, const BaseSlice& b)
+            {
+                return grpc_slice_eq(a.c_slice(), b.c_slice()) == 0;
+            }
+
+            inline bool operator==(const BaseSlice& a, absl::string_view b)
+            {
+                return a.as_string_view() == b;
+            }
+
+            inline bool operator!=(const BaseSlice& a, absl::string_view b)
+            {
+                return a.as_string_view() != b;
+            }
+
+            inline bool operator==(absl::string_view a, const BaseSlice& b)
+            {
+                return a == b.as_string_view();
+            }
+
+            inline bool operator!=(absl::string_view a, const BaseSlice& b)
+            {
+                return a != b.as_string_view();
+            }
+
+            inline bool operator==(const BaseSlice& a, const grpc_slice& b)
+            {
+                return grpc_slice_eq(a.c_slice(), b) != 0;
+            }
+
+            inline bool operator!=(const BaseSlice& a, const grpc_slice& b)
+            {
+                return grpc_slice_eq(a.c_slice(), b) == 0;
+            }
+
+            inline bool operator==(const grpc_slice& a, const BaseSlice& b)
+            {
+                return grpc_slice_eq(a, b.c_slice()) != 0;
+            }
+
+            inline bool operator!=(const grpc_slice& a, const BaseSlice& b)
+            {
+                return grpc_slice_eq(a, b.c_slice()) == 0;
+            }
+
+            template<typename Out>
+            struct CopyConstructors
+            {
+                static Out FromCopiedString(const char* s)
+                {
+                    return FromCopiedBuffer(s, strlen(s));
+                }
+                static Out FromCopiedString(absl::string_view s)
+                {
+                    return FromCopiedBuffer(s.data(), s.size());
+                }
+                static Out FromCopiedString(std::string s);
+
+                static Out FromCopiedBuffer(const char* p, size_t len)
+                {
+                    return Out(grpc_slice_from_copied_buffer(p, len));
+                }
+
+                template<typename Buffer>
+                static Out FromCopiedBuffer(const Buffer& buffer)
+                {
+                    return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()), buffer.size());
+                }
+            };
+
+        }  // namespace slice_detail
+
+        class MutableSlice : public slice_detail::BaseSlice, public slice_detail::CopyConstructors<MutableSlice>
+        {
+        public:
+            MutableSlice() = default;
+            explicit MutableSlice(const grpc_slice& slice);
+            ~MutableSlice();
+
+            MutableSlice(const MutableSlice&) = delete;
+            MutableSlice& operator=(const MutableSlice&) = delete;
+            MutableSlice(MutableSlice&& other) noexcept
+                :
+                slice_detail::BaseSlice(other.TakeCSlice())
+            {
+            }
+            MutableSlice& operator=(MutableSlice&& other) noexcept
+            {
+                Swap(&other);
+                return *this;
+            }
+
+            static MutableSlice CreateUninitialized(size_t length)
+            {
+                return MutableSlice(grpc_slice_malloc(length));
+            }
+
+            // Return a sub slice of this one. Leaves this slice in an indeterminate but
+            // valid state.
+            MutableSlice TakeSubSlice(size_t pos, size_t n)
+            {
+                return MutableSlice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
+            }
+
+            // Iterator access to the underlying bytes
+            uint8_t* begin()
+            {
+                return mutable_data();
+            }
+            uint8_t* end()
+            {
+                return mutable_data() + size();
+            }
+            uint8_t* data()
+            {
+                return mutable_data();
+            }
+
+            // Array access
+            uint8_t& operator[](size_t i)
+            {
+                return mutable_data()[i];
+            }
+        };
+
+        class Slice : public slice_detail::BaseSlice, public slice_detail::CopyConstructors<Slice>
+        {
+        public:
+            Slice() = default;
+            ~Slice();
+            explicit Slice(const grpc_slice& slice) :
+                slice_detail::BaseSlice(slice)
+            {
+            }
+            explicit Slice(slice_detail::BaseSlice&& other) :
+                slice_detail::BaseSlice(other.TakeCSlice())
+            {
+            }
+
+            Slice(const Slice&) = delete;
+            Slice& operator=(const Slice&) = delete;
+            Slice(Slice&& other) noexcept :
+                slice_detail::BaseSlice(other.TakeCSlice())
+            {
+            }
+            Slice& operator=(Slice&& other) noexcept
+            {
+                Swap(&other);
+                return *this;
+            }
+
+            // A slice might refer to some memory that we keep a refcount to (this is
+            // owned), or some memory that's inlined into the slice (also owned), or some
+            // other block of memory that we know will be available for the lifetime of
+            // some operation in the common case (not owned). In the *less common* case
+            // that we need to keep that slice text for longer than our API's guarantee us
+            // access, we need to take a copy and turn this into something that we do own.
+
+            // TakeOwned returns an owned slice regardless of current ownership, and
+            // leaves the current slice in a valid but externally unpredictable state - in
+            // doing so it can avoid adding a ref to the underlying slice.
+            Slice TakeOwned();
+
+            // AsOwned returns an owned slice but does not mutate the current slice,
+            // meaning that it may add a reference to the underlying slice.
+            Slice AsOwned() const;
+
+            // TakeMutable returns a MutableSlice, and leaves the current slice in an
+            // indeterminate but valid state.
+            // A mutable slice requires only one reference to the bytes of the slice -
+            // this can be achieved either with inlined storage or with a single
+            // reference.
+            // If the current slice is refcounted and there are more than one references
+            // to that slice, then the slice is copied in order to achieve a mutable
+            // version.
+            MutableSlice TakeMutable();
+
+            // Return a sub slice of this one. Leaves this slice in an indeterminate but
+            // valid state.
+            Slice TakeSubSlice(size_t pos, size_t n)
+            {
+                return Slice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
+            }
+
+            // Return a sub slice of this one. Adds a reference to the underlying slice.
+            Slice RefSubSlice(size_t pos, size_t n) const
+            {
+                return Slice(grpc_slice_sub(c_slice(), pos, pos + n));
+            }
+
+            // Split this slice, returning a new slice containing (split:end] and
+            // leaving this slice with [begin:split).
+            Slice Split(size_t split)
+            {
+                return Slice(grpc_slice_split_tail(c_slice_ptr(), split));
+            }
+
+            Slice Ref() const;
+
+            Slice Copy() const
+            {
+                return Slice(grpc_slice_copy(c_slice()));
+            }
+
+            static Slice FromRefcountAndBytes(grpc_slice_refcount* r, const uint8_t* begin, const uint8_t* end);
+        };
+
+    }  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_EVENT_ENGINE_SLICE_H
diff --git a/CAPI/cpp/grpc/include/grpc/event_engine/slice_buffer.h b/CAPI/cpp/grpc/include/grpc/event_engine/slice_buffer.h
index 3861717..eb0e3bb 100644
--- a/CAPI/cpp/grpc/include/grpc/event_engine/slice_buffer.h
+++ b/CAPI/cpp/grpc/include/grpc/event_engine/slice_buffer.h
@@ -30,89 +30,115 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
-namespace grpc_event_engine {
-namespace experimental {
-
-/// A Wrapper around \a grpc_slice_buffer pointer.
-///
-/// A slice buffer holds the memory for a collection of slices.
-/// The SliceBuffer object itself is meant to only hide the C-style API,
-/// and won't hold the data itself. In terms of lifespan, the
-/// grpc_slice_buffer ought to be kept somewhere inside the caller's objects,
-/// like a transport or an endpoint.
-///
-/// This lifespan rule is likely to change in the future, as we may
-/// collapse the grpc_slice_buffer structure straight into this class.
-///
-/// The SliceBuffer API is basically a replica of the grpc_slice_buffer's,
-/// and its documentation will move here once we remove the C structure,
-/// which should happen before the Event Engine's API is no longer
-/// an experimental API.
-class SliceBuffer {
- public:
-  explicit SliceBuffer() { grpc_slice_buffer_init(&slice_buffer_); }
-  SliceBuffer(const SliceBuffer& other) = delete;
-  SliceBuffer(SliceBuffer&& other) noexcept
-      : slice_buffer_(other.slice_buffer_) {
-    grpc_slice_buffer_init(&slice_buffer_);
-    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
-  }
-  /// Upon destruction, the underlying raw slice buffer is cleaned out and all
-  /// slices are unreffed.
-  ~SliceBuffer() { grpc_slice_buffer_destroy(&slice_buffer_); }
-
-  SliceBuffer& operator=(const SliceBuffer&) = delete;
-  SliceBuffer& operator=(SliceBuffer&& other) noexcept {
-    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
-    return *this;
-  }
-
-  /// Appends a new slice into the SliceBuffer and makes an attempt to merge
-  /// this slice with the last slice in the SliceBuffer.
-  void Append(Slice slice);
-
-  /// Adds a new slice into the SliceBuffer at the next available index.
-  /// Returns the index at which the new slice is added.
-  size_t AppendIndexed(Slice slice);
-
-  /// Returns the number of slices held by the SliceBuffer.
-  size_t Count() { return slice_buffer_.count; }
-
-  /// Removes/deletes the last n bytes in the SliceBuffer.
-  void RemoveLastNBytes(size_t n) {
-    grpc_slice_buffer_trim_end(&slice_buffer_, n, nullptr);
-  }
-
-  /// Move the first n bytes of the SliceBuffer into a memory pointed to by dst.
-  void MoveFirstNBytesIntoBuffer(size_t n, void* dst) {
-    grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
-  }
-
-  /// Removes and unrefs all slices in the SliceBuffer.
-  void Clear() { grpc_slice_buffer_reset_and_unref(&slice_buffer_); }
-
-  /// Removes the first slice in the SliceBuffer and returns it.
-  Slice TakeFirst();
-
-  /// Prepends the slice to the the front of the SliceBuffer.
-  void Prepend(Slice slice);
-
-  /// Increased the ref-count of slice at the specified index and returns the
-  /// associated slice.
-  Slice RefSlice(size_t index);
-
-  /// The total number of bytes held by the SliceBuffer
-  size_t Length() { return slice_buffer_.length; }
-
-  /// Return a pointer to the back raw grpc_slice_buffer
-  grpc_slice_buffer* c_slice_buffer() { return &slice_buffer_; }
-
- private:
-  /// The backing raw slice buffer.
-  grpc_slice_buffer slice_buffer_;
-};
-
-}  // namespace experimental
+namespace grpc_event_engine
+{
+    namespace experimental
+    {
+
+        /// A Wrapper around \a grpc_slice_buffer pointer.
+        ///
+        /// A slice buffer holds the memory for a collection of slices.
+        /// The SliceBuffer object itself is meant to only hide the C-style API,
+        /// and won't hold the data itself. In terms of lifespan, the
+        /// grpc_slice_buffer ought to be kept somewhere inside the caller's objects,
+        /// like a transport or an endpoint.
+        ///
+        /// This lifespan rule is likely to change in the future, as we may
+        /// collapse the grpc_slice_buffer structure straight into this class.
+        ///
+        /// The SliceBuffer API is basically a replica of the grpc_slice_buffer's,
+        /// and its documentation will move here once we remove the C structure,
+        /// which should happen before the Event Engine's API is no longer
+        /// an experimental API.
+        class SliceBuffer
+        {
+        public:
+            explicit SliceBuffer()
+            {
+                grpc_slice_buffer_init(&slice_buffer_);
+            }
+            SliceBuffer(const SliceBuffer& other) = delete;
+            SliceBuffer(SliceBuffer&& other) noexcept
+                :
+                slice_buffer_(other.slice_buffer_)
+            {
+                grpc_slice_buffer_init(&slice_buffer_);
+                grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
+            }
+            /// Upon destruction, the underlying raw slice buffer is cleaned out and all
+            /// slices are unreffed.
+            ~SliceBuffer()
+            {
+                grpc_slice_buffer_destroy(&slice_buffer_);
+            }
+
+            SliceBuffer& operator=(const SliceBuffer&) = delete;
+            SliceBuffer& operator=(SliceBuffer&& other) noexcept
+            {
+                grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
+                return *this;
+            }
+
+            /// Appends a new slice into the SliceBuffer and makes an attempt to merge
+            /// this slice with the last slice in the SliceBuffer.
+            void Append(Slice slice);
+
+            /// Adds a new slice into the SliceBuffer at the next available index.
+            /// Returns the index at which the new slice is added.
+            size_t AppendIndexed(Slice slice);
+
+            /// Returns the number of slices held by the SliceBuffer.
+            size_t Count()
+            {
+                return slice_buffer_.count;
+            }
+
+            /// Removes/deletes the last n bytes in the SliceBuffer.
+            void RemoveLastNBytes(size_t n)
+            {
+                grpc_slice_buffer_trim_end(&slice_buffer_, n, nullptr);
+            }
+
+            /// Move the first n bytes of the SliceBuffer into a memory pointed to by dst.
+            void MoveFirstNBytesIntoBuffer(size_t n, void* dst)
+            {
+                grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
+            }
+
+            /// Removes and unrefs all slices in the SliceBuffer.
+            void Clear()
+            {
+                grpc_slice_buffer_reset_and_unref(&slice_buffer_);
+            }
+
+            /// Removes the first slice in the SliceBuffer and returns it.
+            Slice TakeFirst();
+
+            /// Prepends the slice to the the front of the SliceBuffer.
+            void Prepend(Slice slice);
+
+            /// Increased the ref-count of slice at the specified index and returns the
+            /// associated slice.
+            Slice RefSlice(size_t index);
+
+            /// The total number of bytes held by the SliceBuffer
+            size_t Length()
+            {
+                return slice_buffer_.length;
+            }
+
+            /// Return a pointer to the back raw grpc_slice_buffer
+            grpc_slice_buffer* c_slice_buffer()
+            {
+                return &slice_buffer_;
+            }
+
+        private:
+            /// The backing raw slice buffer.
+            grpc_slice_buffer slice_buffer_;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_EVENT_ENGINE_SLICE_BUFFER_H
diff --git a/CAPI/cpp/grpc/include/grpc/grpc.h b/CAPI/cpp/grpc/include/grpc/grpc.h
index de40299..e6b8566 100644
--- a/CAPI/cpp/grpc/include/grpc/grpc.h
+++ b/CAPI/cpp/grpc/include/grpc/grpc.h
@@ -32,571 +32,557 @@
 #include <grpc/support/time.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/*! \mainpage GRPC Core
- *
- * The GRPC Core library is a low-level library designed to be wrapped by higher
- * level libraries. The top-level API is provided in grpc.h. Security related
- * functionality lives in grpc_security.h.
- */
-
-GRPCAPI void grpc_metadata_array_init(grpc_metadata_array* array);
-GRPCAPI void grpc_metadata_array_destroy(grpc_metadata_array* array);
-
-GRPCAPI void grpc_call_details_init(grpc_call_details* details);
-GRPCAPI void grpc_call_details_destroy(grpc_call_details* details);
-
-/** Registers a plugin to be initialized and destroyed with the library.
-
-    The \a init and \a destroy functions will be invoked as part of
-    \a grpc_init() and \a grpc_shutdown(), respectively.
-    Note that these functions can be invoked an arbitrary number of times
-    (and hence so will \a init and \a destroy).
-    It is safe to pass NULL to either argument. Plugins are destroyed in
-    the reverse order they were initialized. */
-GRPCAPI void grpc_register_plugin(void (*init)(void), void (*destroy)(void));
-
-/** Initialize the grpc library.
-
-    After it's called, a matching invocation to grpc_shutdown() is expected.
-
-    It is not safe to call any other grpc functions before calling this.
-    (To avoid overhead, little checking is done, and some things may work. We
-    do not warrant that they will continue to do so in future revisions of this
-    library). */
-GRPCAPI void grpc_init(void);
-
-/** Shut down the grpc library.
-
-    Before it's called, there should haven been a matching invocation to
-    grpc_init().
-
-    The last call to grpc_shutdown will initiate cleaning up of grpc library
-    internals, which can happen in another thread. Once the clean-up is done,
-    no memory is used by grpc, nor are any instructions executing within the
-    grpc library.  Prior to calling, all application owned grpc objects must
-    have been destroyed. */
-GRPCAPI void grpc_shutdown(void);
-
-/** EXPERIMENTAL. Returns 1 if the grpc library has been initialized.
-    TODO(ericgribkoff) Decide if this should be promoted to non-experimental as
-    part of stabilizing the fork support API, as tracked in
-    https://github.com/grpc/grpc/issues/15334 */
-GRPCAPI int grpc_is_initialized(void);
-
-/** DEPRECATED. Recommend to use grpc_shutdown only */
-GRPCAPI void grpc_shutdown_blocking(void);
-
-/** Return a string representing the current version of grpc */
-GRPCAPI const char* grpc_version_string(void);
-
-/** Return a string specifying what the 'g' in gRPC stands for */
-GRPCAPI const char* grpc_g_stands_for(void);
+    /*! \mainpage GRPC Core
+     *
+     * The GRPC Core library is a low-level library designed to be wrapped by higher
+     * level libraries. The top-level API is provided in grpc.h. Security related
+     * functionality lives in grpc_security.h.
+     */
+
+    GRPCAPI void grpc_metadata_array_init(grpc_metadata_array* array);
+    GRPCAPI void grpc_metadata_array_destroy(grpc_metadata_array* array);
+
+    GRPCAPI void grpc_call_details_init(grpc_call_details* details);
+    GRPCAPI void grpc_call_details_destroy(grpc_call_details* details);
+
+    /** Registers a plugin to be initialized and destroyed with the library.
+
+        The \a init and \a destroy functions will be invoked as part of
+        \a grpc_init() and \a grpc_shutdown(), respectively.
+        Note that these functions can be invoked an arbitrary number of times
+        (and hence so will \a init and \a destroy).
+        It is safe to pass NULL to either argument. Plugins are destroyed in
+        the reverse order they were initialized. */
+    GRPCAPI void grpc_register_plugin(void (*init)(void), void (*destroy)(void));
+
+    /** Initialize the grpc library.
+
+        After it's called, a matching invocation to grpc_shutdown() is expected.
+
+        It is not safe to call any other grpc functions before calling this.
+        (To avoid overhead, little checking is done, and some things may work. We
+        do not warrant that they will continue to do so in future revisions of this
+        library). */
+    GRPCAPI void grpc_init(void);
+
+    /** Shut down the grpc library.
+
+        Before it's called, there should haven been a matching invocation to
+        grpc_init().
+
+        The last call to grpc_shutdown will initiate cleaning up of grpc library
+        internals, which can happen in another thread. Once the clean-up is done,
+        no memory is used by grpc, nor are any instructions executing within the
+        grpc library.  Prior to calling, all application owned grpc objects must
+        have been destroyed. */
+    GRPCAPI void grpc_shutdown(void);
+
+    /** EXPERIMENTAL. Returns 1 if the grpc library has been initialized.
+        TODO(ericgribkoff) Decide if this should be promoted to non-experimental as
+        part of stabilizing the fork support API, as tracked in
+        https://github.com/grpc/grpc/issues/15334 */
+    GRPCAPI int grpc_is_initialized(void);
+
+    /** DEPRECATED. Recommend to use grpc_shutdown only */
+    GRPCAPI void grpc_shutdown_blocking(void);
+
+    /** Return a string representing the current version of grpc */
+    GRPCAPI const char* grpc_version_string(void);
+
+    /** Return a string specifying what the 'g' in gRPC stands for */
+    GRPCAPI const char* grpc_g_stands_for(void);
+
+    /** Returns the completion queue factory based on the attributes. MAY return a
+        NULL if no factory can be found */
+    GRPCAPI const grpc_completion_queue_factory*
+        grpc_completion_queue_factory_lookup(
+            const grpc_completion_queue_attributes* attributes
+        );
+
+    /** Helper function to create a completion queue with grpc_cq_completion_type
+        of GRPC_CQ_NEXT and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING */
+    GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_next(
+        void* reserved
+    );
+
+    /** Helper function to create a completion queue with grpc_cq_completion_type
+        of GRPC_CQ_PLUCK and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING */
+    GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_pluck(
+        void* reserved
+    );
+
+    /** Helper function to create a completion queue with grpc_cq_completion_type
+        of GRPC_CQ_CALLBACK and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING.
+        This function is experimental. */
+    GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_callback(
+        grpc_completion_queue_functor* shutdown_callback, void* reserved
+    );
+
+    /** Create a completion queue */
+    GRPCAPI grpc_completion_queue* grpc_completion_queue_create(
+        const grpc_completion_queue_factory* factory,
+        const grpc_completion_queue_attributes* attributes,
+        void* reserved
+    );
+
+    /** Blocks until an event is available, the completion queue is being shut down,
+        or deadline is reached.
+
+        Returns a grpc_event with type GRPC_QUEUE_TIMEOUT on timeout,
+        otherwise a grpc_event describing the event that occurred.
+
+        Callers must not call grpc_completion_queue_next and
+        grpc_completion_queue_pluck simultaneously on the same completion queue. */
+    GRPCAPI grpc_event grpc_completion_queue_next(grpc_completion_queue* cq, gpr_timespec deadline, void* reserved);
+
+    /** Blocks until an event with tag 'tag' is available, the completion queue is
+        being shutdown or deadline is reached.
 
-/** Returns the completion queue factory based on the attributes. MAY return a
-    NULL if no factory can be found */
-GRPCAPI const grpc_completion_queue_factory*
-grpc_completion_queue_factory_lookup(
-    const grpc_completion_queue_attributes* attributes);
-
-/** Helper function to create a completion queue with grpc_cq_completion_type
-    of GRPC_CQ_NEXT and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING */
-GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_next(
-    void* reserved);
-
-/** Helper function to create a completion queue with grpc_cq_completion_type
-    of GRPC_CQ_PLUCK and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING */
-GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_pluck(
-    void* reserved);
-
-/** Helper function to create a completion queue with grpc_cq_completion_type
-    of GRPC_CQ_CALLBACK and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING.
-    This function is experimental. */
-GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_callback(
-    grpc_completion_queue_functor* shutdown_callback, void* reserved);
-
-/** Create a completion queue */
-GRPCAPI grpc_completion_queue* grpc_completion_queue_create(
-    const grpc_completion_queue_factory* factory,
-    const grpc_completion_queue_attributes* attributes, void* reserved);
-
-/** Blocks until an event is available, the completion queue is being shut down,
-    or deadline is reached.
-
-    Returns a grpc_event with type GRPC_QUEUE_TIMEOUT on timeout,
-    otherwise a grpc_event describing the event that occurred.
-
-    Callers must not call grpc_completion_queue_next and
-    grpc_completion_queue_pluck simultaneously on the same completion queue. */
-GRPCAPI grpc_event grpc_completion_queue_next(grpc_completion_queue* cq,
-                                              gpr_timespec deadline,
-                                              void* reserved);
-
-/** Blocks until an event with tag 'tag' is available, the completion queue is
-    being shutdown or deadline is reached.
-
-    Returns a grpc_event with type GRPC_QUEUE_TIMEOUT on timeout,
-    otherwise a grpc_event describing the event that occurred.
-
-    Callers must not call grpc_completion_queue_next and
-    grpc_completion_queue_pluck simultaneously on the same completion queue.
-
-    Completion queues support a maximum of GRPC_MAX_COMPLETION_QUEUE_PLUCKERS
-    concurrently executing plucks at any time. */
-GRPCAPI grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq,
-                                               void* tag, gpr_timespec deadline,
-                                               void* reserved);
+        Returns a grpc_event with type GRPC_QUEUE_TIMEOUT on timeout,
+        otherwise a grpc_event describing the event that occurred.
+
+        Callers must not call grpc_completion_queue_next and
+        grpc_completion_queue_pluck simultaneously on the same completion queue.
+
+        Completion queues support a maximum of GRPC_MAX_COMPLETION_QUEUE_PLUCKERS
+        concurrently executing plucks at any time. */
+    GRPCAPI grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag, gpr_timespec deadline, void* reserved);
 
 /** Maximum number of outstanding grpc_completion_queue_pluck executions per
     completion queue */
 #define GRPC_MAX_COMPLETION_QUEUE_PLUCKERS 6
 
-/** Begin destruction of a completion queue. Once all possible events are
-    drained then grpc_completion_queue_next will start to produce
-    GRPC_QUEUE_SHUTDOWN events only. At that point it's safe to call
-    grpc_completion_queue_destroy.
-
-    After calling this function applications should ensure that no
-    NEW work is added to be published on this completion queue. */
-GRPCAPI void grpc_completion_queue_shutdown(grpc_completion_queue* cq);
+    /** Begin destruction of a completion queue. Once all possible events are
+        drained then grpc_completion_queue_next will start to produce
+        GRPC_QUEUE_SHUTDOWN events only. At that point it's safe to call
+        grpc_completion_queue_destroy.
+
+        After calling this function applications should ensure that no
+        NEW work is added to be published on this completion queue. */
+    GRPCAPI void grpc_completion_queue_shutdown(grpc_completion_queue* cq);
+
+    /** Destroy a completion queue. The caller must ensure that the queue is
+        drained and no threads are executing grpc_completion_queue_next */
+    GRPCAPI void grpc_completion_queue_destroy(grpc_completion_queue* cq);
+
+    /*********** EXPERIMENTAL API ************/
+    /** Initializes a thread local cache for \a cq.
+     * grpc_flush_cq_tls_cache() MUST be called on the same thread,
+     * with the same cq.
+     */
+    GRPCAPI void grpc_completion_queue_thread_local_cache_init(
+        grpc_completion_queue* cq
+    );
+
+    /*********** EXPERIMENTAL API ************/
+    /** Flushes the thread local cache for \a cq.
+     * Returns 1 if there was contents in the cache.  If there was an event
+     * in \a cq tls cache, its tag is placed in tag, and ok is set to the
+     * event success.
+     */
+    GRPCAPI int grpc_completion_queue_thread_local_cache_flush(
+        grpc_completion_queue* cq, void** tag, int* ok
+    );
+
+    /** Check the connectivity state of a channel. */
+    GRPCAPI grpc_connectivity_state grpc_channel_check_connectivity_state(
+        grpc_channel* channel, int try_to_connect
+    );
+
+    /** Number of active "external connectivity state watchers" attached to a
+     * channel.
+     * Useful for testing. **/
+    GRPCAPI int grpc_channel_num_external_connectivity_watchers(
+        grpc_channel* channel
+    );
+
+    /** Watch for a change in connectivity state.
+        Once the channel connectivity state is different from last_observed_state,
+        tag will be enqueued on cq with success=1.
+        If deadline expires BEFORE the state is changed, tag will be enqueued on cq
+        with success=0. */
+    GRPCAPI void grpc_channel_watch_connectivity_state(
+        grpc_channel* channel, grpc_connectivity_state last_observed_state, gpr_timespec deadline, grpc_completion_queue* cq, void* tag
+    );
+
+    /** Check whether a grpc channel supports connectivity watcher */
+    GRPCAPI int grpc_channel_support_connectivity_watcher(grpc_channel* channel);
+
+    /** Create a call given a grpc_channel, in order to call 'method'. All
+        completions are sent to 'completion_queue'. 'method' and 'host' need only
+        live through the invocation of this function.
+        If parent_call is non-NULL, it must be a server-side call. It will be used
+        to propagate properties from the server call to this new client call,
+        depending on the value of \a propagation_mask (see propagation_bits.h for
+        possible values). */
+    GRPCAPI grpc_call* grpc_channel_create_call(
+        grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask, grpc_completion_queue* completion_queue, grpc_slice method, const grpc_slice* host, gpr_timespec deadline, void* reserved
+    );
+
+    /** Pre-register a method/host pair on a channel.
+        method and host are not owned and must remain alive while the channel is
+        alive. */
+    GRPCAPI void* grpc_channel_register_call(grpc_channel* channel, const char* method, const char* host, void* reserved);
+
+    /** Create a call given a handle returned from grpc_channel_register_call.
+        \sa grpc_channel_create_call. */
+    GRPCAPI grpc_call* grpc_channel_create_registered_call(
+        grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask, grpc_completion_queue* completion_queue, void* registered_call_handle, gpr_timespec deadline, void* reserved
+    );
+
+    /** Allocate memory in the grpc_call arena: this memory is automatically
+        discarded at call completion */
+    GRPCAPI void* grpc_call_arena_alloc(grpc_call* call, size_t size);
+
+    /** Start a batch of operations defined in the array ops; when complete, post a
+        completion of type 'tag' to the completion queue bound to the call.
+        The order of ops specified in the batch has no significance.
+        Only one operation of each type can be active at once in any given
+        batch.
+        If a call to grpc_call_start_batch returns GRPC_CALL_OK you must call
+        grpc_completion_queue_next or grpc_completion_queue_pluck on the completion
+        queue associated with 'call' for work to be performed. If a call to
+        grpc_call_start_batch returns any value other than GRPC_CALL_OK it is
+        guaranteed that no state associated with 'call' is changed and it is not
+        appropriate to call grpc_completion_queue_next or
+        grpc_completion_queue_pluck consequent to the failed grpc_call_start_batch
+        call.
+        If a call to grpc_call_start_batch with an empty batch returns
+        GRPC_CALL_OK, the tag is put in the completion queue immediately.
+        THREAD SAFETY: access to grpc_call_start_batch in multi-threaded environment
+        needs to be synchronized. As an optimization, you may synchronize batches
+        containing just send operations independently from batches containing just
+        receive operations. Access to grpc_call_start_batch with an empty batch is
+        thread-compatible. */
+    GRPCAPI grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops, size_t nops, void* tag, void* reserved);
+
+    /** Returns a newly allocated string representing the endpoint to which this
+        call is communicating with. The string is in the uri format accepted by
+        grpc_channel_create.
+        The returned string should be disposed of with gpr_free().
+
+        WARNING: this value is never authenticated or subject to any security
+        related code. It must not be used for any authentication related
+        functionality. Instead, use grpc_auth_context. */
+    GRPCAPI char* grpc_call_get_peer(grpc_call* call);
+
+    struct census_context;
+
+    /** Set census context for a call; Must be called before first call to
+       grpc_call_start_batch(). */
+    GRPCAPI void grpc_census_call_set_context(grpc_call* call, struct census_context* context);
+
+    /** Retrieve the calls current census context. */
+    GRPCAPI struct census_context* grpc_census_call_get_context(grpc_call* call);
+
+    /** Return a newly allocated string representing the target a channel was
+        created for. */
+    GRPCAPI char* grpc_channel_get_target(grpc_channel* channel);
+
+    /** Request info about the channel.
+        \a channel_info indicates what information is being requested and
+        how that information will be returned.
+        \a channel_info is owned by the caller. */
+    GRPCAPI void grpc_channel_get_info(grpc_channel* channel, const grpc_channel_info* channel_info);
+
+    /** EXPERIMENTAL.  Resets the channel's connect backoff.
+        TODO(roth): When we see whether this proves useful, either promote
+        to non-experimental or remove it. */
+    GRPCAPI void grpc_channel_reset_connect_backoff(grpc_channel* channel);
+
+    /** --- grpc_channel_credentials object. ---
+
+       A channel credentials object represents a way to authenticate a client on a
+       channel. Different types of channel credentials are declared in
+       grpc_security.h. */
+
+    typedef struct grpc_channel_credentials grpc_channel_credentials;
+
+    /** Releases a channel credentials object.
+       The creator of the credentials object is responsible for its release. */
+
+    GRPCAPI void grpc_channel_credentials_release(grpc_channel_credentials* creds);
+
+    /** --- grpc_server_credentials object. ---
+
+       A server credentials object represents a way to authenticate a server.
+       Different types of server credentials are declared in grpc_security.h. */
+
+    typedef struct grpc_server_credentials grpc_server_credentials;
+
+    /** Releases a server_credentials object.
+       The creator of the server_credentials object is responsible for its release.
+       */
+    GRPCAPI void grpc_server_credentials_release(grpc_server_credentials* creds);
+
+    /** Creates a secure channel using the passed-in credentials. Additional
+        channel level configuration MAY be provided by grpc_channel_args, though
+        the expectation is that most clients will want to simply pass NULL. The
+        user data in 'args' need only live through the invocation of this function.
+        However, if any args of the 'pointer' type are passed, then the referenced
+        vtable must be maintained by the caller until grpc_channel_destroy
+        terminates. See grpc_channel_args definition for more on this. */
+    GRPCAPI grpc_channel* grpc_channel_create(const char* target, grpc_channel_credentials* creds, const grpc_channel_args* args);
+
+    /** Create a lame client: this client fails every operation attempted on it. */
+    GRPCAPI grpc_channel* grpc_lame_client_channel_create(
+        const char* target, grpc_status_code error_code, const char* error_message
+    );
+
+    /** Close and destroy a grpc channel */
+    GRPCAPI void grpc_channel_destroy(grpc_channel* channel);
+
+    /** Error handling for grpc_call
+       Most grpc_call functions return a grpc_error. If the error is not GRPC_OK
+       then the operation failed due to some unsatisfied precondition.
+       If a grpc_call fails, it's guaranteed that no change to the call state
+       has been made. */
+
+    /** Cancel an RPC.
+        Can be called multiple times, from any thread.
+        THREAD-SAFETY grpc_call_cancel and grpc_call_cancel_with_status
+        are thread-safe, and can be called at any point before grpc_call_unref
+        is called.*/
+    GRPCAPI grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved);
+
+    /** Cancel an RPC.
+        Can be called multiple times, from any thread.
+        If a status has not been received for the call, set it to the status code
+        and description passed in.
+        Importantly, this function does not send status nor description to the
+        remote endpoint.
+        Note that \a description doesn't need be a static string.
+        It doesn't need to be alive after the call to
+        grpc_call_cancel_with_status completes.
+        */
+    GRPCAPI grpc_call_error grpc_call_cancel_with_status(grpc_call* call, grpc_status_code status, const char* description, void* reserved);
+
+    /* Returns whether or not the call's receive message operation failed because of
+     * an error (as opposed to a graceful end-of-stream) */
+    GRPCAPI int grpc_call_failed_before_recv_message(const grpc_call* c);
+
+    /** Ref a call.
+        THREAD SAFETY: grpc_call_ref is thread-compatible */
+    GRPCAPI void grpc_call_ref(grpc_call* call);
+
+    /** Unref a call.
+        THREAD SAFETY: grpc_call_unref is thread-compatible */
+    GRPCAPI void grpc_call_unref(grpc_call* call);
+
+    /** Request notification of a new call.
+        Once a call is received, a notification tagged with \a tag_new is added to
+        \a cq_for_notification. \a call, \a details and \a request_metadata are
+        updated with the appropriate call information. \a cq_bound_to_call is bound
+        to \a call, and batch operation notifications for that call will be posted
+        to \a cq_bound_to_call.
+        Note that \a cq_for_notification must have been registered to the server via
+        \a grpc_server_register_completion_queue. */
+    GRPCAPI grpc_call_error grpc_server_request_call(
+        grpc_server* server, grpc_call** call, grpc_call_details* details, grpc_metadata_array* request_metadata, grpc_completion_queue* cq_bound_to_call, grpc_completion_queue* cq_for_notification, void* tag_new
+    );
+
+    /** How to handle payloads for a registered method */
+    typedef enum
+    {
+        /** Don't try to read the payload */
+        GRPC_SRM_PAYLOAD_NONE,
+        /** Read the initial payload as a byte buffer */
+        GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER
+    } grpc_server_register_method_payload_handling;
+
+    /** Registers a method in the server.
+        Methods to this (host, method) pair will not be reported by
+        grpc_server_request_call, but instead be reported by
+        grpc_server_request_registered_call when passed the appropriate
+        registered_method (as returned by this function).
+        Must be called before grpc_server_start.
+        Returns NULL on failure. */
+    GRPCAPI void* grpc_server_register_method(
+        grpc_server* server, const char* method, const char* host, grpc_server_register_method_payload_handling payload_handling, uint32_t flags
+    );
+
+    /** Request notification of a new pre-registered call. 'cq_for_notification'
+        must have been registered to the server via
+        grpc_server_register_completion_queue. */
+    GRPCAPI grpc_call_error grpc_server_request_registered_call(
+        grpc_server* server, void* registered_method, grpc_call** call, gpr_timespec* deadline, grpc_metadata_array* request_metadata, grpc_byte_buffer** optional_payload, grpc_completion_queue* cq_bound_to_call, grpc_completion_queue* cq_for_notification, void* tag_new
+    );
+
+    /** Create a server. Additional configuration for each incoming channel can
+        be specified with args. If no additional configuration is needed, args can
+        be NULL. The user data in 'args' need only live through the invocation of
+        this function. However, if any args of the 'pointer' type are passed, then
+        the referenced vtable must be maintained by the caller until
+        grpc_server_destroy terminates. See grpc_channel_args definition for more
+        on this. */
+    GRPCAPI grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved);
+
+    /** Register a completion queue with the server. Must be done for any
+        notification completion queue that is passed to grpc_server_request_*_call
+        and to grpc_server_shutdown_and_notify. Must be performed prior to
+        grpc_server_start. */
+    GRPCAPI void grpc_server_register_completion_queue(grpc_server* server, grpc_completion_queue* cq, void* reserved);
+
+    // More members might be added in later, so users should take care to memset
+    // this to 0 before using it.
+    typedef struct
+    {
+        grpc_status_code code;
+        const char* error_message;
+    } grpc_serving_status_update;
+
+    // There might be more methods added later, so users should take care to memset
+    // this to 0 before using it.
+    typedef struct
+    {
+        void (*on_serving_status_update)(void* user_data, const char* uri, grpc_serving_status_update update);
+        void* user_data;
+    } grpc_server_xds_status_notifier;
+
+    typedef struct grpc_server_config_fetcher grpc_server_config_fetcher;
+
+    /** EXPERIMENTAL.  Creates an xDS config fetcher. */
+    GRPCAPI grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
+        grpc_server_xds_status_notifier notifier, const grpc_channel_args* args
+    );
+
+    /** EXPERIMENTAL.  Destroys a config fetcher. */
+    GRPCAPI void grpc_server_config_fetcher_destroy(
+        grpc_server_config_fetcher* config_fetcher
+    );
+
+    /** EXPERIMENTAL.  Sets the server's config fetcher.  Takes ownership.
+        Must be called before adding ports */
+    GRPCAPI void grpc_server_set_config_fetcher(
+        grpc_server* server, grpc_server_config_fetcher* config_fetcher
+    );
+
+    /** Add a HTTP2 over an encrypted link over tcp listener.
+       Returns bound port number on success, 0 on failure.
+       REQUIRES: server not started */
+    GRPCAPI int grpc_server_add_http2_port(grpc_server* server, const char* addr, grpc_server_credentials* creds);
+
+    /** Start a server - tells all listeners to start listening */
+    GRPCAPI void grpc_server_start(grpc_server* server);
+
+    /** Begin shutting down a server.
+        After completion, no new calls or connections will be admitted.
+        Existing calls will be allowed to complete.
+        Send a GRPC_OP_COMPLETE event when there are no more calls being serviced.
+        Shutdown is idempotent, and all tags will be notified at once if multiple
+        grpc_server_shutdown_and_notify calls are made. 'cq' must have been
+        registered to this server via grpc_server_register_completion_queue. */
+    GRPCAPI void grpc_server_shutdown_and_notify(grpc_server* server, grpc_completion_queue* cq, void* tag);
+
+    /** Cancel all in-progress calls.
+        Only usable after shutdown. */
+    GRPCAPI void grpc_server_cancel_all_calls(grpc_server* server);
+
+    /** Destroy a server.
+        Shutdown must have completed beforehand (i.e. all tags generated by
+        grpc_server_shutdown_and_notify must have been received, and at least
+        one call to grpc_server_shutdown_and_notify must have been made). */
+    GRPCAPI void grpc_server_destroy(grpc_server* server);
+
+    /** Enable or disable a tracer.
+
+        Tracers (usually controlled by the environment variable GRPC_TRACE)
+        allow printf-style debugging on GRPC internals, and are useful for
+        tracking down problems in the field.
+
+        Use of this function is not strictly thread-safe, but the
+        thread-safety issues raised by it should not be of concern. */
+    GRPCAPI int grpc_tracer_set_enabled(const char* name, int enabled);
+
+    /** Check whether a metadata key is legal (will be accepted by core) */
+    GRPCAPI int grpc_header_key_is_legal(grpc_slice slice);
+
+    /** Check whether a non-binary metadata value is legal (will be accepted by
+        core) */
+    GRPCAPI int grpc_header_nonbin_value_is_legal(grpc_slice slice);
+
+    /** Check whether a metadata key corresponds to a binary value */
+    GRPCAPI int grpc_is_binary_header(grpc_slice slice);
+
+    /** Convert grpc_call_error values to a string */
+    GRPCAPI const char* grpc_call_error_to_string(grpc_call_error error);
+
+    /** Create a buffer pool */
+    GRPCAPI grpc_resource_quota* grpc_resource_quota_create(const char* trace_name);
+
+    /** Add a reference to a buffer pool */
+    GRPCAPI void grpc_resource_quota_ref(grpc_resource_quota* resource_quota);
+
+    /** Drop a reference to a buffer pool */
+    GRPCAPI void grpc_resource_quota_unref(grpc_resource_quota* resource_quota);
+
+    /** Update the size of a buffer pool */
+    GRPCAPI void grpc_resource_quota_resize(grpc_resource_quota* resource_quota, size_t new_size);
+
+    /** Update the size of the maximum number of threads allowed */
+    GRPCAPI void grpc_resource_quota_set_max_threads(
+        grpc_resource_quota* resource_quota, int new_max_threads
+    );
+
+    /** EXPERIMENTAL.  Dumps xDS configs as a serialized ClientConfig proto.
+        The full name of the proto is envoy.service.status.v3.ClientConfig. */
+    GRPCAPI grpc_slice grpc_dump_xds_configs(void);
+
+    /** Fetch a vtable for a grpc_channel_arg that points to a grpc_resource_quota
+     */
+    GRPCAPI const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void);
+
+    /************* CHANNELZ API *************/
+    /** Channelz is under active development. The following APIs will see some
+        churn as the feature is implemented. This comment will be removed once
+        channelz is officially supported, and these APIs become stable. For now
+        you may track the progress by following this github issue:
+        https://github.com/grpc/grpc/issues/15340
+
+        the following APIs return allocated JSON strings that match the response
+        objects from the channelz proto, found here:
+        https://github.com/grpc/grpc/blob/master/src/proto/grpc/channelz/channelz.proto.
+
+        For easy conversion to protobuf, The JSON is formatted according to:
+        https://developers.google.com/protocol-buffers/docs/proto3#json. */
+
+    /* Gets all root channels (i.e. channels the application has directly
+       created). This does not include subchannels nor non-top level channels.
+       The returned string is allocated and must be freed by the application. */
+    GRPCAPI char* grpc_channelz_get_top_channels(intptr_t start_channel_id);
+
+    /* Gets all servers that exist in the process. */
+    GRPCAPI char* grpc_channelz_get_servers(intptr_t start_server_id);
+
+    /* Returns a single Server, or else a NOT_FOUND code. */
+    GRPCAPI char* grpc_channelz_get_server(intptr_t server_id);
 
-/** Destroy a completion queue. The caller must ensure that the queue is
-    drained and no threads are executing grpc_completion_queue_next */
-GRPCAPI void grpc_completion_queue_destroy(grpc_completion_queue* cq);
+    /* Gets all server sockets that exist in the server. */
+    GRPCAPI char* grpc_channelz_get_server_sockets(intptr_t server_id, intptr_t start_socket_id, intptr_t max_results);
+
+    /* Returns a single Channel, or else a NOT_FOUND code. The returned string
+       is allocated and must be freed by the application. */
+    GRPCAPI char* grpc_channelz_get_channel(intptr_t channel_id);
+
+    /* Returns a single Subchannel, or else a NOT_FOUND code. The returned string
+       is allocated and must be freed by the application. */
+    GRPCAPI char* grpc_channelz_get_subchannel(intptr_t subchannel_id);
+
+    /* Returns a single Socket, or else a NOT_FOUND code. The returned string
+       is allocated and must be freed by the application. */
+    GRPCAPI char* grpc_channelz_get_socket(intptr_t socket_id);
 
-/*********** EXPERIMENTAL API ************/
-/** Initializes a thread local cache for \a cq.
- * grpc_flush_cq_tls_cache() MUST be called on the same thread,
- * with the same cq.
- */
-GRPCAPI void grpc_completion_queue_thread_local_cache_init(
-    grpc_completion_queue* cq);
-
-/*********** EXPERIMENTAL API ************/
-/** Flushes the thread local cache for \a cq.
- * Returns 1 if there was contents in the cache.  If there was an event
- * in \a cq tls cache, its tag is placed in tag, and ok is set to the
- * event success.
- */
-GRPCAPI int grpc_completion_queue_thread_local_cache_flush(
-    grpc_completion_queue* cq, void** tag, int* ok);
-
-/** Check the connectivity state of a channel. */
-GRPCAPI grpc_connectivity_state grpc_channel_check_connectivity_state(
-    grpc_channel* channel, int try_to_connect);
-
-/** Number of active "external connectivity state watchers" attached to a
- * channel.
- * Useful for testing. **/
-GRPCAPI int grpc_channel_num_external_connectivity_watchers(
-    grpc_channel* channel);
-
-/** Watch for a change in connectivity state.
-    Once the channel connectivity state is different from last_observed_state,
-    tag will be enqueued on cq with success=1.
-    If deadline expires BEFORE the state is changed, tag will be enqueued on cq
-    with success=0. */
-GRPCAPI void grpc_channel_watch_connectivity_state(
-    grpc_channel* channel, grpc_connectivity_state last_observed_state,
-    gpr_timespec deadline, grpc_completion_queue* cq, void* tag);
-
-/** Check whether a grpc channel supports connectivity watcher */
-GRPCAPI int grpc_channel_support_connectivity_watcher(grpc_channel* channel);
-
-/** Create a call given a grpc_channel, in order to call 'method'. All
-    completions are sent to 'completion_queue'. 'method' and 'host' need only
-    live through the invocation of this function.
-    If parent_call is non-NULL, it must be a server-side call. It will be used
-    to propagate properties from the server call to this new client call,
-    depending on the value of \a propagation_mask (see propagation_bits.h for
-    possible values). */
-GRPCAPI grpc_call* grpc_channel_create_call(
-    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
-    grpc_completion_queue* completion_queue, grpc_slice method,
-    const grpc_slice* host, gpr_timespec deadline, void* reserved);
-
-/** Pre-register a method/host pair on a channel.
-    method and host are not owned and must remain alive while the channel is
-    alive. */
-GRPCAPI void* grpc_channel_register_call(grpc_channel* channel,
-                                         const char* method, const char* host,
-                                         void* reserved);
-
-/** Create a call given a handle returned from grpc_channel_register_call.
-    \sa grpc_channel_create_call. */
-GRPCAPI grpc_call* grpc_channel_create_registered_call(
-    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
-    grpc_completion_queue* completion_queue, void* registered_call_handle,
-    gpr_timespec deadline, void* reserved);
-
-/** Allocate memory in the grpc_call arena: this memory is automatically
-    discarded at call completion */
-GRPCAPI void* grpc_call_arena_alloc(grpc_call* call, size_t size);
-
-/** Start a batch of operations defined in the array ops; when complete, post a
-    completion of type 'tag' to the completion queue bound to the call.
-    The order of ops specified in the batch has no significance.
-    Only one operation of each type can be active at once in any given
-    batch.
-    If a call to grpc_call_start_batch returns GRPC_CALL_OK you must call
-    grpc_completion_queue_next or grpc_completion_queue_pluck on the completion
-    queue associated with 'call' for work to be performed. If a call to
-    grpc_call_start_batch returns any value other than GRPC_CALL_OK it is
-    guaranteed that no state associated with 'call' is changed and it is not
-    appropriate to call grpc_completion_queue_next or
-    grpc_completion_queue_pluck consequent to the failed grpc_call_start_batch
-    call.
-    If a call to grpc_call_start_batch with an empty batch returns
-    GRPC_CALL_OK, the tag is put in the completion queue immediately.
-    THREAD SAFETY: access to grpc_call_start_batch in multi-threaded environment
-    needs to be synchronized. As an optimization, you may synchronize batches
-    containing just send operations independently from batches containing just
-    receive operations. Access to grpc_call_start_batch with an empty batch is
-    thread-compatible. */
-GRPCAPI grpc_call_error grpc_call_start_batch(grpc_call* call,
-                                              const grpc_op* ops, size_t nops,
-                                              void* tag, void* reserved);
-
-/** Returns a newly allocated string representing the endpoint to which this
-    call is communicating with. The string is in the uri format accepted by
-    grpc_channel_create.
-    The returned string should be disposed of with gpr_free().
-
-    WARNING: this value is never authenticated or subject to any security
-    related code. It must not be used for any authentication related
-    functionality. Instead, use grpc_auth_context. */
-GRPCAPI char* grpc_call_get_peer(grpc_call* call);
-
-struct census_context;
-
-/** Set census context for a call; Must be called before first call to
-   grpc_call_start_batch(). */
-GRPCAPI void grpc_census_call_set_context(grpc_call* call,
-                                          struct census_context* context);
-
-/** Retrieve the calls current census context. */
-GRPCAPI struct census_context* grpc_census_call_get_context(grpc_call* call);
-
-/** Return a newly allocated string representing the target a channel was
-    created for. */
-GRPCAPI char* grpc_channel_get_target(grpc_channel* channel);
-
-/** Request info about the channel.
-    \a channel_info indicates what information is being requested and
-    how that information will be returned.
-    \a channel_info is owned by the caller. */
-GRPCAPI void grpc_channel_get_info(grpc_channel* channel,
-                                   const grpc_channel_info* channel_info);
-
-/** EXPERIMENTAL.  Resets the channel's connect backoff.
-    TODO(roth): When we see whether this proves useful, either promote
-    to non-experimental or remove it. */
-GRPCAPI void grpc_channel_reset_connect_backoff(grpc_channel* channel);
-
-/** --- grpc_channel_credentials object. ---
-
-   A channel credentials object represents a way to authenticate a client on a
-   channel. Different types of channel credentials are declared in
-   grpc_security.h. */
-
-typedef struct grpc_channel_credentials grpc_channel_credentials;
-
-/** Releases a channel credentials object.
-   The creator of the credentials object is responsible for its release. */
-
-GRPCAPI void grpc_channel_credentials_release(grpc_channel_credentials* creds);
-
-/** --- grpc_server_credentials object. ---
-
-   A server credentials object represents a way to authenticate a server.
-   Different types of server credentials are declared in grpc_security.h. */
-
-typedef struct grpc_server_credentials grpc_server_credentials;
-
-/** Releases a server_credentials object.
-   The creator of the server_credentials object is responsible for its release.
-   */
-GRPCAPI void grpc_server_credentials_release(grpc_server_credentials* creds);
-
-/** Creates a secure channel using the passed-in credentials. Additional
-    channel level configuration MAY be provided by grpc_channel_args, though
-    the expectation is that most clients will want to simply pass NULL. The
-    user data in 'args' need only live through the invocation of this function.
-    However, if any args of the 'pointer' type are passed, then the referenced
-    vtable must be maintained by the caller until grpc_channel_destroy
-    terminates. See grpc_channel_args definition for more on this. */
-GRPCAPI grpc_channel* grpc_channel_create(const char* target,
-                                          grpc_channel_credentials* creds,
-                                          const grpc_channel_args* args);
-
-/** Create a lame client: this client fails every operation attempted on it. */
-GRPCAPI grpc_channel* grpc_lame_client_channel_create(
-    const char* target, grpc_status_code error_code, const char* error_message);
-
-/** Close and destroy a grpc channel */
-GRPCAPI void grpc_channel_destroy(grpc_channel* channel);
-
-/** Error handling for grpc_call
-   Most grpc_call functions return a grpc_error. If the error is not GRPC_OK
-   then the operation failed due to some unsatisfied precondition.
-   If a grpc_call fails, it's guaranteed that no change to the call state
-   has been made. */
-
-/** Cancel an RPC.
-    Can be called multiple times, from any thread.
-    THREAD-SAFETY grpc_call_cancel and grpc_call_cancel_with_status
-    are thread-safe, and can be called at any point before grpc_call_unref
-    is called.*/
-GRPCAPI grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved);
-
-/** Cancel an RPC.
-    Can be called multiple times, from any thread.
-    If a status has not been received for the call, set it to the status code
-    and description passed in.
-    Importantly, this function does not send status nor description to the
-    remote endpoint.
-    Note that \a description doesn't need be a static string.
-    It doesn't need to be alive after the call to
-    grpc_call_cancel_with_status completes.
-    */
-GRPCAPI grpc_call_error grpc_call_cancel_with_status(grpc_call* call,
-                                                     grpc_status_code status,
-                                                     const char* description,
-                                                     void* reserved);
-
-/* Returns whether or not the call's receive message operation failed because of
- * an error (as opposed to a graceful end-of-stream) */
-GRPCAPI int grpc_call_failed_before_recv_message(const grpc_call* c);
-
-/** Ref a call.
-    THREAD SAFETY: grpc_call_ref is thread-compatible */
-GRPCAPI void grpc_call_ref(grpc_call* call);
-
-/** Unref a call.
-    THREAD SAFETY: grpc_call_unref is thread-compatible */
-GRPCAPI void grpc_call_unref(grpc_call* call);
-
-/** Request notification of a new call.
-    Once a call is received, a notification tagged with \a tag_new is added to
-    \a cq_for_notification. \a call, \a details and \a request_metadata are
-    updated with the appropriate call information. \a cq_bound_to_call is bound
-    to \a call, and batch operation notifications for that call will be posted
-    to \a cq_bound_to_call.
-    Note that \a cq_for_notification must have been registered to the server via
-    \a grpc_server_register_completion_queue. */
-GRPCAPI grpc_call_error grpc_server_request_call(
-    grpc_server* server, grpc_call** call, grpc_call_details* details,
-    grpc_metadata_array* request_metadata,
-    grpc_completion_queue* cq_bound_to_call,
-    grpc_completion_queue* cq_for_notification, void* tag_new);
-
-/** How to handle payloads for a registered method */
-typedef enum {
-  /** Don't try to read the payload */
-  GRPC_SRM_PAYLOAD_NONE,
-  /** Read the initial payload as a byte buffer */
-  GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER
-} grpc_server_register_method_payload_handling;
-
-/** Registers a method in the server.
-    Methods to this (host, method) pair will not be reported by
-    grpc_server_request_call, but instead be reported by
-    grpc_server_request_registered_call when passed the appropriate
-    registered_method (as returned by this function).
-    Must be called before grpc_server_start.
-    Returns NULL on failure. */
-GRPCAPI void* grpc_server_register_method(
-    grpc_server* server, const char* method, const char* host,
-    grpc_server_register_method_payload_handling payload_handling,
-    uint32_t flags);
-
-/** Request notification of a new pre-registered call. 'cq_for_notification'
-    must have been registered to the server via
-    grpc_server_register_completion_queue. */
-GRPCAPI grpc_call_error grpc_server_request_registered_call(
-    grpc_server* server, void* registered_method, grpc_call** call,
-    gpr_timespec* deadline, grpc_metadata_array* request_metadata,
-    grpc_byte_buffer** optional_payload,
-    grpc_completion_queue* cq_bound_to_call,
-    grpc_completion_queue* cq_for_notification, void* tag_new);
-
-/** Create a server. Additional configuration for each incoming channel can
-    be specified with args. If no additional configuration is needed, args can
-    be NULL. The user data in 'args' need only live through the invocation of
-    this function. However, if any args of the 'pointer' type are passed, then
-    the referenced vtable must be maintained by the caller until
-    grpc_server_destroy terminates. See grpc_channel_args definition for more
-    on this. */
-GRPCAPI grpc_server* grpc_server_create(const grpc_channel_args* args,
-                                        void* reserved);
-
-/** Register a completion queue with the server. Must be done for any
-    notification completion queue that is passed to grpc_server_request_*_call
-    and to grpc_server_shutdown_and_notify. Must be performed prior to
-    grpc_server_start. */
-GRPCAPI void grpc_server_register_completion_queue(grpc_server* server,
-                                                   grpc_completion_queue* cq,
-                                                   void* reserved);
-
-// More members might be added in later, so users should take care to memset
-// this to 0 before using it.
-typedef struct {
-  grpc_status_code code;
-  const char* error_message;
-} grpc_serving_status_update;
-
-// There might be more methods added later, so users should take care to memset
-// this to 0 before using it.
-typedef struct {
-  void (*on_serving_status_update)(void* user_data, const char* uri,
-                                   grpc_serving_status_update update);
-  void* user_data;
-} grpc_server_xds_status_notifier;
-
-typedef struct grpc_server_config_fetcher grpc_server_config_fetcher;
-
-/** EXPERIMENTAL.  Creates an xDS config fetcher. */
-GRPCAPI grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
-    grpc_server_xds_status_notifier notifier, const grpc_channel_args* args);
-
-/** EXPERIMENTAL.  Destroys a config fetcher. */
-GRPCAPI void grpc_server_config_fetcher_destroy(
-    grpc_server_config_fetcher* config_fetcher);
-
-/** EXPERIMENTAL.  Sets the server's config fetcher.  Takes ownership.
-    Must be called before adding ports */
-GRPCAPI void grpc_server_set_config_fetcher(
-    grpc_server* server, grpc_server_config_fetcher* config_fetcher);
-
-/** Add a HTTP2 over an encrypted link over tcp listener.
-   Returns bound port number on success, 0 on failure.
-   REQUIRES: server not started */
-GRPCAPI int grpc_server_add_http2_port(grpc_server* server, const char* addr,
-                                       grpc_server_credentials* creds);
-
-/** Start a server - tells all listeners to start listening */
-GRPCAPI void grpc_server_start(grpc_server* server);
-
-/** Begin shutting down a server.
-    After completion, no new calls or connections will be admitted.
-    Existing calls will be allowed to complete.
-    Send a GRPC_OP_COMPLETE event when there are no more calls being serviced.
-    Shutdown is idempotent, and all tags will be notified at once if multiple
-    grpc_server_shutdown_and_notify calls are made. 'cq' must have been
-    registered to this server via grpc_server_register_completion_queue. */
-GRPCAPI void grpc_server_shutdown_and_notify(grpc_server* server,
-                                             grpc_completion_queue* cq,
-                                             void* tag);
-
-/** Cancel all in-progress calls.
-    Only usable after shutdown. */
-GRPCAPI void grpc_server_cancel_all_calls(grpc_server* server);
-
-/** Destroy a server.
-    Shutdown must have completed beforehand (i.e. all tags generated by
-    grpc_server_shutdown_and_notify must have been received, and at least
-    one call to grpc_server_shutdown_and_notify must have been made). */
-GRPCAPI void grpc_server_destroy(grpc_server* server);
-
-/** Enable or disable a tracer.
-
-    Tracers (usually controlled by the environment variable GRPC_TRACE)
-    allow printf-style debugging on GRPC internals, and are useful for
-    tracking down problems in the field.
-
-    Use of this function is not strictly thread-safe, but the
-    thread-safety issues raised by it should not be of concern. */
-GRPCAPI int grpc_tracer_set_enabled(const char* name, int enabled);
-
-/** Check whether a metadata key is legal (will be accepted by core) */
-GRPCAPI int grpc_header_key_is_legal(grpc_slice slice);
-
-/** Check whether a non-binary metadata value is legal (will be accepted by
-    core) */
-GRPCAPI int grpc_header_nonbin_value_is_legal(grpc_slice slice);
-
-/** Check whether a metadata key corresponds to a binary value */
-GRPCAPI int grpc_is_binary_header(grpc_slice slice);
-
-/** Convert grpc_call_error values to a string */
-GRPCAPI const char* grpc_call_error_to_string(grpc_call_error error);
-
-/** Create a buffer pool */
-GRPCAPI grpc_resource_quota* grpc_resource_quota_create(const char* trace_name);
-
-/** Add a reference to a buffer pool */
-GRPCAPI void grpc_resource_quota_ref(grpc_resource_quota* resource_quota);
-
-/** Drop a reference to a buffer pool */
-GRPCAPI void grpc_resource_quota_unref(grpc_resource_quota* resource_quota);
-
-/** Update the size of a buffer pool */
-GRPCAPI void grpc_resource_quota_resize(grpc_resource_quota* resource_quota,
-                                        size_t new_size);
-
-/** Update the size of the maximum number of threads allowed */
-GRPCAPI void grpc_resource_quota_set_max_threads(
-    grpc_resource_quota* resource_quota, int new_max_threads);
-
-/** EXPERIMENTAL.  Dumps xDS configs as a serialized ClientConfig proto.
-    The full name of the proto is envoy.service.status.v3.ClientConfig. */
-GRPCAPI grpc_slice grpc_dump_xds_configs(void);
-
-/** Fetch a vtable for a grpc_channel_arg that points to a grpc_resource_quota
- */
-GRPCAPI const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void);
-
-/************* CHANNELZ API *************/
-/** Channelz is under active development. The following APIs will see some
-    churn as the feature is implemented. This comment will be removed once
-    channelz is officially supported, and these APIs become stable. For now
-    you may track the progress by following this github issue:
-    https://github.com/grpc/grpc/issues/15340
-
-    the following APIs return allocated JSON strings that match the response
-    objects from the channelz proto, found here:
-    https://github.com/grpc/grpc/blob/master/src/proto/grpc/channelz/channelz.proto.
-
-    For easy conversion to protobuf, The JSON is formatted according to:
-    https://developers.google.com/protocol-buffers/docs/proto3#json. */
-
-/* Gets all root channels (i.e. channels the application has directly
-   created). This does not include subchannels nor non-top level channels.
-   The returned string is allocated and must be freed by the application. */
-GRPCAPI char* grpc_channelz_get_top_channels(intptr_t start_channel_id);
-
-/* Gets all servers that exist in the process. */
-GRPCAPI char* grpc_channelz_get_servers(intptr_t start_server_id);
-
-/* Returns a single Server, or else a NOT_FOUND code. */
-GRPCAPI char* grpc_channelz_get_server(intptr_t server_id);
-
-/* Gets all server sockets that exist in the server. */
-GRPCAPI char* grpc_channelz_get_server_sockets(intptr_t server_id,
-                                               intptr_t start_socket_id,
-                                               intptr_t max_results);
-
-/* Returns a single Channel, or else a NOT_FOUND code. The returned string
-   is allocated and must be freed by the application. */
-GRPCAPI char* grpc_channelz_get_channel(intptr_t channel_id);
-
-/* Returns a single Subchannel, or else a NOT_FOUND code. The returned string
-   is allocated and must be freed by the application. */
-GRPCAPI char* grpc_channelz_get_subchannel(intptr_t subchannel_id);
-
-/* Returns a single Socket, or else a NOT_FOUND code. The returned string
-   is allocated and must be freed by the application. */
-GRPCAPI char* grpc_channelz_get_socket(intptr_t socket_id);
-
-/**
- * EXPERIMENTAL - Subject to change.
- * Fetch a vtable for grpc_channel_arg that points to
- * grpc_authorization_policy_provider.
- */
-GRPCAPI const grpc_arg_pointer_vtable*
-grpc_authorization_policy_provider_arg_vtable(void);
+    /**
+     * EXPERIMENTAL - Subject to change.
+     * Fetch a vtable for grpc_channel_arg that points to
+     * grpc_authorization_policy_provider.
+     */
+    GRPCAPI const grpc_arg_pointer_vtable*
+        grpc_authorization_policy_provider_arg_vtable(void);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/grpc_posix.h b/CAPI/cpp/grpc/include/grpc/grpc_posix.h
index 797e3c5..3bae172 100644
--- a/CAPI/cpp/grpc/include/grpc/grpc_posix.h
+++ b/CAPI/cpp/grpc/include/grpc/grpc_posix.h
@@ -27,34 +27,34 @@
 #include <grpc/impl/codegen/grpc_types.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/*! \mainpage GRPC Core POSIX
- *
- * The GRPC Core POSIX library provides some POSIX-specific low-level
- * functionality on top of GRPC Core.
- */
-
-/** Create a secure channel to 'target' using file descriptor 'fd' and passed-in
-    credentials. The 'target' argument will be used to indicate the name for
-    this channel. Note that this API currently only supports insecure channel
-    credentials. Using other types of credentials will result in a failure. */
-GRPCAPI grpc_channel* grpc_channel_create_from_fd(
-    const char* target, int fd, grpc_channel_credentials* creds,
-    const grpc_channel_args* args);
-
-/** Add the connected secure communication channel based on file descriptor 'fd'
-   to the 'server' and server credentials 'creds'. The 'fd' must be an open file
-   descriptor corresponding to a connected socket. Events from the file
-   descriptor may come on any of the server completion queues (i.e completion
-   queues registered via the grpc_server_register_completion_queue API).
-   Note that this API currently only supports inseure server credentials
-   Using other types of credentials will result in a failure.
-   TODO(hork): add channel_args to this API to allow endpoints and transports
-   created in this function to participate in the resource quota feature. */
-GRPCAPI void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
-                                             grpc_server_credentials* creds);
+    /*! \mainpage GRPC Core POSIX
+     *
+     * The GRPC Core POSIX library provides some POSIX-specific low-level
+     * functionality on top of GRPC Core.
+     */
+
+    /** Create a secure channel to 'target' using file descriptor 'fd' and passed-in
+        credentials. The 'target' argument will be used to indicate the name for
+        this channel. Note that this API currently only supports insecure channel
+        credentials. Using other types of credentials will result in a failure. */
+    GRPCAPI grpc_channel* grpc_channel_create_from_fd(
+        const char* target, int fd, grpc_channel_credentials* creds, const grpc_channel_args* args
+    );
+
+    /** Add the connected secure communication channel based on file descriptor 'fd'
+       to the 'server' and server credentials 'creds'. The 'fd' must be an open file
+       descriptor corresponding to a connected socket. Events from the file
+       descriptor may come on any of the server completion queues (i.e completion
+       queues registered via the grpc_server_register_completion_queue API).
+       Note that this API currently only supports inseure server credentials
+       Using other types of credentials will result in a failure.
+       TODO(hork): add channel_args to this API to allow endpoints and transports
+       created in this function to participate in the resource quota feature. */
+    GRPCAPI void grpc_server_add_channel_from_fd(grpc_server* server, int fd, grpc_server_credentials* creds);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/grpc_security.h b/CAPI/cpp/grpc/include/grpc/grpc_security.h
index 63810f6..121b7fb 100644
--- a/CAPI/cpp/grpc/include/grpc/grpc_security.h
+++ b/CAPI/cpp/grpc/include/grpc/grpc_security.h
@@ -26,1242 +26,1288 @@
 #include <grpc/status.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** --- Authentication Context. --- */
+    /** --- Authentication Context. --- */
 
-typedef struct grpc_auth_context grpc_auth_context;
+    typedef struct grpc_auth_context grpc_auth_context;
 
-typedef struct grpc_auth_property_iterator {
-  const grpc_auth_context* ctx;
-  size_t index;
-  const char* name;
-} grpc_auth_property_iterator;
+    typedef struct grpc_auth_property_iterator
+    {
+        const grpc_auth_context* ctx;
+        size_t index;
+        const char* name;
+    } grpc_auth_property_iterator;
 
-/** value, if not NULL, is guaranteed to be NULL terminated. */
-typedef struct grpc_auth_property {
-  char* name;
-  char* value;
-  size_t value_length;
-} grpc_auth_property;
-
-/** Returns NULL when the iterator is at the end. */
-GRPCAPI const grpc_auth_property* grpc_auth_property_iterator_next(
-    grpc_auth_property_iterator* it);
-
-/** Iterates over the auth context. */
-GRPCAPI grpc_auth_property_iterator
-grpc_auth_context_property_iterator(const grpc_auth_context* ctx);
-
-/** Gets the peer identity. Returns an empty iterator (first _next will return
-   NULL) if the peer is not authenticated. */
-GRPCAPI grpc_auth_property_iterator
-grpc_auth_context_peer_identity(const grpc_auth_context* ctx);
-
-/** Finds a property in the context. May return an empty iterator (first _next
-   will return NULL) if no property with this name was found in the context. */
-GRPCAPI grpc_auth_property_iterator grpc_auth_context_find_properties_by_name(
-    const grpc_auth_context* ctx, const char* name);
-
-/** Gets the name of the property that indicates the peer identity. Will return
-   NULL if the peer is not authenticated. */
-GRPCAPI const char* grpc_auth_context_peer_identity_property_name(
-    const grpc_auth_context* ctx);
-
-/** Returns 1 if the peer is authenticated, 0 otherwise. */
-GRPCAPI int grpc_auth_context_peer_is_authenticated(
-    const grpc_auth_context* ctx);
-
-/** Gets the auth context from the call. Caller needs to call
-   grpc_auth_context_release on the returned context. */
-GRPCAPI grpc_auth_context* grpc_call_auth_context(grpc_call* call);
-
-/** Releases the auth context returned from grpc_call_auth_context. */
-GRPCAPI void grpc_auth_context_release(grpc_auth_context* context);
-
-/** --
-   The following auth context methods should only be called by a server metadata
-   processor to set properties extracted from auth metadata.
-   -- */
-
-/** Add a property. */
-GRPCAPI void grpc_auth_context_add_property(grpc_auth_context* ctx,
-                                            const char* name, const char* value,
-                                            size_t value_length);
-
-/** Add a C string property. */
-GRPCAPI void grpc_auth_context_add_cstring_property(grpc_auth_context* ctx,
-                                                    const char* name,
-                                                    const char* value);
-
-/** Sets the property name. Returns 1 if successful or 0 in case of failure
-   (which means that no property with this name exists). */
-GRPCAPI int grpc_auth_context_set_peer_identity_property_name(
-    grpc_auth_context* ctx, const char* name);
-
-/** --- SSL Session Cache. ---
-
-    A SSL session cache object represents a way to cache client sessions
-    between connections. Only ticket-based resumption is supported. */
-
-typedef struct grpc_ssl_session_cache grpc_ssl_session_cache;
-
-/** Create LRU cache for client-side SSL sessions with the given capacity.
-    If capacity is < 1, a default capacity is used instead. */
-GRPCAPI grpc_ssl_session_cache* grpc_ssl_session_cache_create_lru(
-    size_t capacity);
-
-/** Destroy SSL session cache. */
-GRPCAPI void grpc_ssl_session_cache_destroy(grpc_ssl_session_cache* cache);
-
-/** Create a channel arg with the given cache object. */
-GRPCAPI grpc_arg
-grpc_ssl_session_cache_create_channel_arg(grpc_ssl_session_cache* cache);
-
-/** --- grpc_call_credentials object.
-
-   A call credentials object represents a way to authenticate on a particular
-   call. These credentials can be composed with a channel credentials object
-   so that they are sent with every call on this channel.  */
-
-typedef struct grpc_call_credentials grpc_call_credentials;
-
-/** Releases a call credentials object.
-   The creator of the credentials object is responsible for its release. */
-GRPCAPI void grpc_call_credentials_release(grpc_call_credentials* creds);
-
-/** Creates default credentials to connect to a google gRPC service.
-   WARNING: Do NOT use this credentials to connect to a non-google service as
-   this could result in an oauth2 token leak. The security level of the
-   resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
-
-   If specified, the supplied call credentials object will be attached to the
-   returned channel credentials object. The call_credentials object must remain
-   valid throughout the lifetime of the returned grpc_channel_credentials
-   object. It is expected that the call credentials object was generated
-   according to the Application Default Credentials mechanism and asserts the
-   identity of the default service account of the machine. Supplying any other
-   sort of call credential will result in undefined behavior, up to and
-   including the sudden and unexpected failure of RPCs.
-
-   If nullptr is supplied, the returned channel credentials object will use a
-   call credentials object based on the Application Default Credentials
-   mechanism.
-*/
-GRPCAPI grpc_channel_credentials* grpc_google_default_credentials_create(
-    grpc_call_credentials* call_credentials);
-
-/** Callback for getting the SSL roots override from the application.
-   In case of success, *pem_roots_certs must be set to a NULL terminated string
-   containing the list of PEM encoded root certificates. The ownership is passed
-   to the core and freed (laster by the core) with gpr_free.
-   If this function fails and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is
-   set to a valid path, it will override the roots specified this func */
-typedef grpc_ssl_roots_override_result (*grpc_ssl_roots_override_callback)(
-    char** pem_root_certs);
-
-/** Setup a callback to override the default TLS/SSL roots.
-   This function is not thread-safe and must be called at initialization time
-   before any ssl credentials are created to have the desired side effect.
-   If GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is set to a valid path, the
-   callback will not be called. */
-GRPCAPI void grpc_set_ssl_roots_override_callback(
-    grpc_ssl_roots_override_callback cb);
-
-/** Object that holds a private key / certificate chain pair in PEM format. */
-typedef struct {
-  /** private_key is the NULL-terminated string containing the PEM encoding of
-     the client's private key. */
-  const char* private_key;
-
-  /** cert_chain is the NULL-terminated string containing the PEM encoding of
-     the client's certificate chain. */
-  const char* cert_chain;
-} grpc_ssl_pem_key_cert_pair;
-
-/** Deprecated in favor of grpc_ssl_verify_peer_options. It will be removed
-  after all of its call sites are migrated to grpc_ssl_verify_peer_options.
-  Object that holds additional peer-verification options on a secure
-  channel. */
-typedef struct {
-  /** If non-NULL this callback will be invoked with the expected
-     target_name, the peer's certificate (in PEM format), and whatever
-     userdata pointer is set below. If a non-zero value is returned by this
-     callback then it is treated as a verification failure. Invocation of
-     the callback is blocking, so any implementation should be light-weight.
-     */
-  int (*verify_peer_callback)(const char* target_name, const char* peer_pem,
-                              void* userdata);
-  /** Arbitrary userdata that will be passed as the last argument to
-     verify_peer_callback. */
-  void* verify_peer_callback_userdata;
-  /** A destruct callback that will be invoked when the channel is being
-     cleaned up. The userdata argument will be passed to it. The intent is
-     to perform any cleanup associated with that userdata. */
-  void (*verify_peer_destruct)(void* userdata);
-} verify_peer_options;
-
-/** Object that holds additional peer-verification options on a secure
-   channel. */
-typedef struct {
-  /** If non-NULL this callback will be invoked with the expected
-     target_name, the peer's certificate (in PEM format), and whatever
-     userdata pointer is set below. If a non-zero value is returned by this
-     callback then it is treated as a verification failure. Invocation of
-     the callback is blocking, so any implementation should be light-weight.
-     */
-  int (*verify_peer_callback)(const char* target_name, const char* peer_pem,
-                              void* userdata);
-  /** Arbitrary userdata that will be passed as the last argument to
-     verify_peer_callback. */
-  void* verify_peer_callback_userdata;
-  /** A destruct callback that will be invoked when the channel is being
-     cleaned up. The userdata argument will be passed to it. The intent is
-     to perform any cleanup associated with that userdata. */
-  void (*verify_peer_destruct)(void* userdata);
-} grpc_ssl_verify_peer_options;
-
-/** Deprecated in favor of grpc_ssl_server_credentials_create_ex. It will be
-   removed after all of its call sites are migrated to
-   grpc_ssl_server_credentials_create_ex. Creates an SSL credentials object.
-   The security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
-   - pem_root_certs is the NULL-terminated string containing the PEM encoding
-     of the server root certificates. If this parameter is NULL, the
-     implementation will first try to dereference the file pointed by the
-     GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment variable, and if that fails,
-     try to get the roots set by grpc_override_ssl_default_roots. Eventually,
-     if all these fail, it will try to get the roots from a well-known place on
-     disk (in the grpc install directory).
-
-     gRPC has implemented root cache if the underlying OpenSSL library supports
-     it. The gRPC root certificates cache is only applicable on the default
-     root certificates, which is used when this parameter is nullptr. If user
-     provides their own pem_root_certs, when creating an SSL credential object,
-     gRPC would not be able to cache it, and each subchannel will generate a
-     copy of the root store. So it is recommended to avoid providing large room
-     pem with pem_root_certs parameter to avoid excessive memory consumption,
-     particularly on mobile platforms such as iOS.
-   - pem_key_cert_pair is a pointer on the object containing client's private
-     key and certificate chain. This parameter can be NULL if the client does
-     not have such a key/cert pair.
-   - verify_options is an optional verify_peer_options object which holds
-     additional options controlling how peer certificates are verified. For
-     example, you can supply a callback which receives the peer's certificate
-     with which you can do additional verification. Can be NULL, in which
-     case verification will retain default behavior. Any settings in
-     verify_options are copied during this call, so the verify_options
-     object can be released afterwards. */
-GRPCAPI grpc_channel_credentials* grpc_ssl_credentials_create(
-    const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair,
-    const verify_peer_options* verify_options, void* reserved);
-
-/* Creates an SSL credentials object.
-   The security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
-   - pem_root_certs is the NULL-terminated string containing the PEM encoding
-     of the server root certificates. If this parameter is NULL, the
-     implementation will first try to dereference the file pointed by the
-     GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment variable, and if that fails,
-     try to get the roots set by grpc_override_ssl_default_roots. Eventually,
-     if all these fail, it will try to get the roots from a well-known place on
-     disk (in the grpc install directory).
-
-     gRPC has implemented root cache if the underlying OpenSSL library supports
-     it. The gRPC root certificates cache is only applicable on the default
-     root certificates, which is used when this parameter is nullptr. If user
-     provides their own pem_root_certs, when creating an SSL credential object,
-     gRPC would not be able to cache it, and each subchannel will generate a
-     copy of the root store. So it is recommended to avoid providing large room
-     pem with pem_root_certs parameter to avoid excessive memory consumption,
-     particularly on mobile platforms such as iOS.
-   - pem_key_cert_pair is a pointer on the object containing client's private
-     key and certificate chain. This parameter can be NULL if the client does
-     not have such a key/cert pair.
-   - verify_options is an optional verify_peer_options object which holds
-     additional options controlling how peer certificates are verified. For
-     example, you can supply a callback which receives the peer's certificate
-     with which you can do additional verification. Can be NULL, in which
-     case verification will retain default behavior. Any settings in
-     verify_options are copied during this call, so the verify_options
-     object can be released afterwards. */
-GRPCAPI grpc_channel_credentials* grpc_ssl_credentials_create_ex(
-    const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair,
-    const grpc_ssl_verify_peer_options* verify_options, void* reserved);
-
-/** Creates a composite channel credentials object. The security level of
- * resulting connection is determined by channel_creds. */
-GRPCAPI grpc_channel_credentials* grpc_composite_channel_credentials_create(
-    grpc_channel_credentials* channel_creds, grpc_call_credentials* call_creds,
-    void* reserved);
-
-/** --- composite credentials. */
-
-/** Creates a composite call credentials object. */
-GRPCAPI grpc_call_credentials* grpc_composite_call_credentials_create(
-    grpc_call_credentials* creds1, grpc_call_credentials* creds2,
-    void* reserved);
-
-/** Creates a compute engine credentials object for connecting to Google.
-   WARNING: Do NOT use this credentials to connect to a non-google service as
-   this could result in an oauth2 token leak. */
-GRPCAPI grpc_call_credentials* grpc_google_compute_engine_credentials_create(
-    void* reserved);
-
-GRPCAPI gpr_timespec grpc_max_auth_token_lifetime(void);
-
-/** Creates a JWT credentials object. May return NULL if the input is invalid.
-   - json_key is the JSON key string containing the client's private key.
-   - token_lifetime is the lifetime of each Json Web Token (JWT) created with
-     this credentials.  It should not exceed grpc_max_auth_token_lifetime or
-     will be cropped to this value.  */
-GRPCAPI grpc_call_credentials*
-grpc_service_account_jwt_access_credentials_create(const char* json_key,
-                                                   gpr_timespec token_lifetime,
-                                                   void* reserved);
-
-/** Builds External Account credentials.
- - json_string is the JSON string containing the credentials options.
- - scopes_string contains the scopes to be binded with the credentials.
-   This API is used for experimental purposes for now and may change in the
- future. */
-GRPCAPI grpc_call_credentials* grpc_external_account_credentials_create(
-    const char* json_string, const char* scopes_string);
-
-/** Creates an Oauth2 Refresh Token credentials object for connecting to Google.
-   May return NULL if the input is invalid.
-   WARNING: Do NOT use this credentials to connect to a non-google service as
-   this could result in an oauth2 token leak.
-   - json_refresh_token is the JSON string containing the refresh token itself
-     along with a client_id and client_secret. */
-GRPCAPI grpc_call_credentials* grpc_google_refresh_token_credentials_create(
-    const char* json_refresh_token, void* reserved);
-
-/** Creates an Oauth2 Access Token credentials with an access token that was
-   acquired by an out of band mechanism. */
-GRPCAPI grpc_call_credentials* grpc_access_token_credentials_create(
-    const char* access_token, void* reserved);
-
-/** Creates an IAM credentials object for connecting to Google. */
-GRPCAPI grpc_call_credentials* grpc_google_iam_credentials_create(
-    const char* authorization_token, const char* authority_selector,
-    void* reserved);
-
-/** Options for creating STS Oauth Token Exchange credentials following the IETF
-   draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
-   Optional fields may be set to NULL or empty string. It is the responsibility
-   of the caller to ensure that the subject and actor tokens are refreshed on
-   disk at the specified paths. This API is used for experimental purposes for
-   now and may change in the future. */
-typedef struct {
-  const char* token_exchange_service_uri; /* Required. */
-  const char* resource;                   /* Optional. */
-  const char* audience;                   /* Optional. */
-  const char* scope;                      /* Optional. */
-  const char* requested_token_type;       /* Optional. */
-  const char* subject_token_path;         /* Required. */
-  const char* subject_token_type;         /* Required. */
-  const char* actor_token_path;           /* Optional. */
-  const char* actor_token_type;           /* Optional. */
-} grpc_sts_credentials_options;
-
-/** Creates an STS credentials following the STS Token Exchanged specifed in the
-   IETF draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
-   This API is used for experimental purposes for now and may change in the
-   future. */
-GRPCAPI grpc_call_credentials* grpc_sts_credentials_create(
-    const grpc_sts_credentials_options* options, void* reserved);
-
-/** Callback function to be called by the metadata credentials plugin
-   implementation when the metadata is ready.
-   - user_data is the opaque pointer that was passed in the get_metadata method
-     of the grpc_metadata_credentials_plugin (see below).
-   - creds_md is an array of credentials metadata produced by the plugin. It
-     may be set to NULL in case of an error.
-   - num_creds_md is the number of items in the creds_md array.
-   - status must be GRPC_STATUS_OK in case of success or another specific error
-     code otherwise.
-   - error_details contains details about the error if any. In case of success
-     it should be NULL and will be otherwise ignored. */
-typedef void (*grpc_credentials_plugin_metadata_cb)(
-    void* user_data, const grpc_metadata* creds_md, size_t num_creds_md,
-    grpc_status_code status, const char* error_details);
-
-/** Context that can be used by metadata credentials plugin in order to create
-   auth related metadata. */
-typedef struct {
-  /** The fully qualifed service url. */
-  const char* service_url;
-
-  /** The method name of the RPC being called (not fully qualified).
-     The fully qualified method name can be built from the service_url:
-     full_qualified_method_name = ctx->service_url + '/' + ctx->method_name. */
-  const char* method_name;
-
-  /** The auth_context of the channel which gives the server's identity. */
-  const grpc_auth_context* channel_auth_context;
-
-  /** Reserved for future use. */
-  void* reserved;
-} grpc_auth_metadata_context;
-
-/** Performs a deep copy from \a from to \a to. **/
-GRPCAPI void grpc_auth_metadata_context_copy(grpc_auth_metadata_context* from,
-                                             grpc_auth_metadata_context* to);
-
-/** Releases internal resources held by \a context. **/
-GRPCAPI void grpc_auth_metadata_context_reset(
-    grpc_auth_metadata_context* context);
+    /** value, if not NULL, is guaranteed to be NULL terminated. */
+    typedef struct grpc_auth_property
+    {
+        char* name;
+        char* value;
+        size_t value_length;
+    } grpc_auth_property;
+
+    /** Returns NULL when the iterator is at the end. */
+    GRPCAPI const grpc_auth_property* grpc_auth_property_iterator_next(
+        grpc_auth_property_iterator* it
+    );
+
+    /** Iterates over the auth context. */
+    GRPCAPI grpc_auth_property_iterator
+        grpc_auth_context_property_iterator(const grpc_auth_context* ctx);
+
+    /** Gets the peer identity. Returns an empty iterator (first _next will return
+       NULL) if the peer is not authenticated. */
+    GRPCAPI grpc_auth_property_iterator
+        grpc_auth_context_peer_identity(const grpc_auth_context* ctx);
+
+    /** Finds a property in the context. May return an empty iterator (first _next
+       will return NULL) if no property with this name was found in the context. */
+    GRPCAPI grpc_auth_property_iterator grpc_auth_context_find_properties_by_name(
+        const grpc_auth_context* ctx, const char* name
+    );
+
+    /** Gets the name of the property that indicates the peer identity. Will return
+       NULL if the peer is not authenticated. */
+    GRPCAPI const char* grpc_auth_context_peer_identity_property_name(
+        const grpc_auth_context* ctx
+    );
+
+    /** Returns 1 if the peer is authenticated, 0 otherwise. */
+    GRPCAPI int grpc_auth_context_peer_is_authenticated(
+        const grpc_auth_context* ctx
+    );
+
+    /** Gets the auth context from the call. Caller needs to call
+       grpc_auth_context_release on the returned context. */
+    GRPCAPI grpc_auth_context* grpc_call_auth_context(grpc_call* call);
+
+    /** Releases the auth context returned from grpc_call_auth_context. */
+    GRPCAPI void grpc_auth_context_release(grpc_auth_context* context);
+
+    /** --
+       The following auth context methods should only be called by a server metadata
+       processor to set properties extracted from auth metadata.
+       -- */
+
+    /** Add a property. */
+    GRPCAPI void grpc_auth_context_add_property(grpc_auth_context* ctx, const char* name, const char* value, size_t value_length);
+
+    /** Add a C string property. */
+    GRPCAPI void grpc_auth_context_add_cstring_property(grpc_auth_context* ctx, const char* name, const char* value);
+
+    /** Sets the property name. Returns 1 if successful or 0 in case of failure
+       (which means that no property with this name exists). */
+    GRPCAPI int grpc_auth_context_set_peer_identity_property_name(
+        grpc_auth_context* ctx, const char* name
+    );
+
+    /** --- SSL Session Cache. ---
+
+        A SSL session cache object represents a way to cache client sessions
+        between connections. Only ticket-based resumption is supported. */
+
+    typedef struct grpc_ssl_session_cache grpc_ssl_session_cache;
+
+    /** Create LRU cache for client-side SSL sessions with the given capacity.
+        If capacity is < 1, a default capacity is used instead. */
+    GRPCAPI grpc_ssl_session_cache* grpc_ssl_session_cache_create_lru(
+        size_t capacity
+    );
+
+    /** Destroy SSL session cache. */
+    GRPCAPI void grpc_ssl_session_cache_destroy(grpc_ssl_session_cache* cache);
+
+    /** Create a channel arg with the given cache object. */
+    GRPCAPI grpc_arg
+        grpc_ssl_session_cache_create_channel_arg(grpc_ssl_session_cache* cache);
+
+    /** --- grpc_call_credentials object.
+
+       A call credentials object represents a way to authenticate on a particular
+       call. These credentials can be composed with a channel credentials object
+       so that they are sent with every call on this channel.  */
+
+    typedef struct grpc_call_credentials grpc_call_credentials;
+
+    /** Releases a call credentials object.
+       The creator of the credentials object is responsible for its release. */
+    GRPCAPI void grpc_call_credentials_release(grpc_call_credentials* creds);
+
+    /** Creates default credentials to connect to a google gRPC service.
+       WARNING: Do NOT use this credentials to connect to a non-google service as
+       this could result in an oauth2 token leak. The security level of the
+       resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+
+       If specified, the supplied call credentials object will be attached to the
+       returned channel credentials object. The call_credentials object must remain
+       valid throughout the lifetime of the returned grpc_channel_credentials
+       object. It is expected that the call credentials object was generated
+       according to the Application Default Credentials mechanism and asserts the
+       identity of the default service account of the machine. Supplying any other
+       sort of call credential will result in undefined behavior, up to and
+       including the sudden and unexpected failure of RPCs.
+
+       If nullptr is supplied, the returned channel credentials object will use a
+       call credentials object based on the Application Default Credentials
+       mechanism.
+    */
+    GRPCAPI grpc_channel_credentials* grpc_google_default_credentials_create(
+        grpc_call_credentials* call_credentials
+    );
+
+    /** Callback for getting the SSL roots override from the application.
+       In case of success, *pem_roots_certs must be set to a NULL terminated string
+       containing the list of PEM encoded root certificates. The ownership is passed
+       to the core and freed (laster by the core) with gpr_free.
+       If this function fails and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is
+       set to a valid path, it will override the roots specified this func */
+    typedef grpc_ssl_roots_override_result (*grpc_ssl_roots_override_callback)(
+        char** pem_root_certs
+    );
+
+    /** Setup a callback to override the default TLS/SSL roots.
+       This function is not thread-safe and must be called at initialization time
+       before any ssl credentials are created to have the desired side effect.
+       If GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is set to a valid path, the
+       callback will not be called. */
+    GRPCAPI void grpc_set_ssl_roots_override_callback(
+        grpc_ssl_roots_override_callback cb
+    );
+
+    /** Object that holds a private key / certificate chain pair in PEM format. */
+    typedef struct
+    {
+        /** private_key is the NULL-terminated string containing the PEM encoding of
+           the client's private key. */
+        const char* private_key;
+
+        /** cert_chain is the NULL-terminated string containing the PEM encoding of
+           the client's certificate chain. */
+        const char* cert_chain;
+    } grpc_ssl_pem_key_cert_pair;
+
+    /** Deprecated in favor of grpc_ssl_verify_peer_options. It will be removed
+      after all of its call sites are migrated to grpc_ssl_verify_peer_options.
+      Object that holds additional peer-verification options on a secure
+      channel. */
+    typedef struct
+    {
+        /** If non-NULL this callback will be invoked with the expected
+           target_name, the peer's certificate (in PEM format), and whatever
+           userdata pointer is set below. If a non-zero value is returned by this
+           callback then it is treated as a verification failure. Invocation of
+           the callback is blocking, so any implementation should be light-weight.
+           */
+        int (*verify_peer_callback)(const char* target_name, const char* peer_pem, void* userdata);
+        /** Arbitrary userdata that will be passed as the last argument to
+           verify_peer_callback. */
+        void* verify_peer_callback_userdata;
+        /** A destruct callback that will be invoked when the channel is being
+           cleaned up. The userdata argument will be passed to it. The intent is
+           to perform any cleanup associated with that userdata. */
+        void (*verify_peer_destruct)(void* userdata);
+    } verify_peer_options;
+
+    /** Object that holds additional peer-verification options on a secure
+       channel. */
+    typedef struct
+    {
+        /** If non-NULL this callback will be invoked with the expected
+           target_name, the peer's certificate (in PEM format), and whatever
+           userdata pointer is set below. If a non-zero value is returned by this
+           callback then it is treated as a verification failure. Invocation of
+           the callback is blocking, so any implementation should be light-weight.
+           */
+        int (*verify_peer_callback)(const char* target_name, const char* peer_pem, void* userdata);
+        /** Arbitrary userdata that will be passed as the last argument to
+           verify_peer_callback. */
+        void* verify_peer_callback_userdata;
+        /** A destruct callback that will be invoked when the channel is being
+           cleaned up. The userdata argument will be passed to it. The intent is
+           to perform any cleanup associated with that userdata. */
+        void (*verify_peer_destruct)(void* userdata);
+    } grpc_ssl_verify_peer_options;
+
+    /** Deprecated in favor of grpc_ssl_server_credentials_create_ex. It will be
+       removed after all of its call sites are migrated to
+       grpc_ssl_server_credentials_create_ex. Creates an SSL credentials object.
+       The security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+       - pem_root_certs is the NULL-terminated string containing the PEM encoding
+         of the server root certificates. If this parameter is NULL, the
+         implementation will first try to dereference the file pointed by the
+         GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment variable, and if that fails,
+         try to get the roots set by grpc_override_ssl_default_roots. Eventually,
+         if all these fail, it will try to get the roots from a well-known place on
+         disk (in the grpc install directory).
+
+         gRPC has implemented root cache if the underlying OpenSSL library supports
+         it. The gRPC root certificates cache is only applicable on the default
+         root certificates, which is used when this parameter is nullptr. If user
+         provides their own pem_root_certs, when creating an SSL credential object,
+         gRPC would not be able to cache it, and each subchannel will generate a
+         copy of the root store. So it is recommended to avoid providing large room
+         pem with pem_root_certs parameter to avoid excessive memory consumption,
+         particularly on mobile platforms such as iOS.
+       - pem_key_cert_pair is a pointer on the object containing client's private
+         key and certificate chain. This parameter can be NULL if the client does
+         not have such a key/cert pair.
+       - verify_options is an optional verify_peer_options object which holds
+         additional options controlling how peer certificates are verified. For
+         example, you can supply a callback which receives the peer's certificate
+         with which you can do additional verification. Can be NULL, in which
+         case verification will retain default behavior. Any settings in
+         verify_options are copied during this call, so the verify_options
+         object can be released afterwards. */
+    GRPCAPI grpc_channel_credentials* grpc_ssl_credentials_create(
+        const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair, const verify_peer_options* verify_options, void* reserved
+    );
+
+    /* Creates an SSL credentials object.
+       The security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+       - pem_root_certs is the NULL-terminated string containing the PEM encoding
+         of the server root certificates. If this parameter is NULL, the
+         implementation will first try to dereference the file pointed by the
+         GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment variable, and if that fails,
+         try to get the roots set by grpc_override_ssl_default_roots. Eventually,
+         if all these fail, it will try to get the roots from a well-known place on
+         disk (in the grpc install directory).
+
+         gRPC has implemented root cache if the underlying OpenSSL library supports
+         it. The gRPC root certificates cache is only applicable on the default
+         root certificates, which is used when this parameter is nullptr. If user
+         provides their own pem_root_certs, when creating an SSL credential object,
+         gRPC would not be able to cache it, and each subchannel will generate a
+         copy of the root store. So it is recommended to avoid providing large room
+         pem with pem_root_certs parameter to avoid excessive memory consumption,
+         particularly on mobile platforms such as iOS.
+       - pem_key_cert_pair is a pointer on the object containing client's private
+         key and certificate chain. This parameter can be NULL if the client does
+         not have such a key/cert pair.
+       - verify_options is an optional verify_peer_options object which holds
+         additional options controlling how peer certificates are verified. For
+         example, you can supply a callback which receives the peer's certificate
+         with which you can do additional verification. Can be NULL, in which
+         case verification will retain default behavior. Any settings in
+         verify_options are copied during this call, so the verify_options
+         object can be released afterwards. */
+    GRPCAPI grpc_channel_credentials* grpc_ssl_credentials_create_ex(
+        const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair, const grpc_ssl_verify_peer_options* verify_options, void* reserved
+    );
+
+    /** Creates a composite channel credentials object. The security level of
+     * resulting connection is determined by channel_creds. */
+    GRPCAPI grpc_channel_credentials* grpc_composite_channel_credentials_create(
+        grpc_channel_credentials* channel_creds, grpc_call_credentials* call_creds, void* reserved
+    );
+
+    /** --- composite credentials. */
+
+    /** Creates a composite call credentials object. */
+    GRPCAPI grpc_call_credentials* grpc_composite_call_credentials_create(
+        grpc_call_credentials* creds1, grpc_call_credentials* creds2, void* reserved
+    );
+
+    /** Creates a compute engine credentials object for connecting to Google.
+       WARNING: Do NOT use this credentials to connect to a non-google service as
+       this could result in an oauth2 token leak. */
+    GRPCAPI grpc_call_credentials* grpc_google_compute_engine_credentials_create(
+        void* reserved
+    );
+
+    GRPCAPI gpr_timespec grpc_max_auth_token_lifetime(void);
+
+    /** Creates a JWT credentials object. May return NULL if the input is invalid.
+       - json_key is the JSON key string containing the client's private key.
+       - token_lifetime is the lifetime of each Json Web Token (JWT) created with
+         this credentials.  It should not exceed grpc_max_auth_token_lifetime or
+         will be cropped to this value.  */
+    GRPCAPI grpc_call_credentials*
+        grpc_service_account_jwt_access_credentials_create(const char* json_key, gpr_timespec token_lifetime, void* reserved);
+
+    /** Builds External Account credentials.
+     - json_string is the JSON string containing the credentials options.
+     - scopes_string contains the scopes to be binded with the credentials.
+       This API is used for experimental purposes for now and may change in the
+     future. */
+    GRPCAPI grpc_call_credentials* grpc_external_account_credentials_create(
+        const char* json_string, const char* scopes_string
+    );
+
+    /** Creates an Oauth2 Refresh Token credentials object for connecting to Google.
+       May return NULL if the input is invalid.
+       WARNING: Do NOT use this credentials to connect to a non-google service as
+       this could result in an oauth2 token leak.
+       - json_refresh_token is the JSON string containing the refresh token itself
+         along with a client_id and client_secret. */
+    GRPCAPI grpc_call_credentials* grpc_google_refresh_token_credentials_create(
+        const char* json_refresh_token, void* reserved
+    );
+
+    /** Creates an Oauth2 Access Token credentials with an access token that was
+       acquired by an out of band mechanism. */
+    GRPCAPI grpc_call_credentials* grpc_access_token_credentials_create(
+        const char* access_token, void* reserved
+    );
+
+    /** Creates an IAM credentials object for connecting to Google. */
+    GRPCAPI grpc_call_credentials* grpc_google_iam_credentials_create(
+        const char* authorization_token, const char* authority_selector, void* reserved
+    );
+
+    /** Options for creating STS Oauth Token Exchange credentials following the IETF
+       draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
+       Optional fields may be set to NULL or empty string. It is the responsibility
+       of the caller to ensure that the subject and actor tokens are refreshed on
+       disk at the specified paths. This API is used for experimental purposes for
+       now and may change in the future. */
+    typedef struct
+    {
+        const char* token_exchange_service_uri; /* Required. */
+        const char* resource;                   /* Optional. */
+        const char* audience;                   /* Optional. */
+        const char* scope;                      /* Optional. */
+        const char* requested_token_type;       /* Optional. */
+        const char* subject_token_path;         /* Required. */
+        const char* subject_token_type;         /* Required. */
+        const char* actor_token_path;           /* Optional. */
+        const char* actor_token_type;           /* Optional. */
+    } grpc_sts_credentials_options;
+
+    /** Creates an STS credentials following the STS Token Exchanged specifed in the
+       IETF draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
+       This API is used for experimental purposes for now and may change in the
+       future. */
+    GRPCAPI grpc_call_credentials* grpc_sts_credentials_create(
+        const grpc_sts_credentials_options* options, void* reserved
+    );
+
+    /** Callback function to be called by the metadata credentials plugin
+       implementation when the metadata is ready.
+       - user_data is the opaque pointer that was passed in the get_metadata method
+         of the grpc_metadata_credentials_plugin (see below).
+       - creds_md is an array of credentials metadata produced by the plugin. It
+         may be set to NULL in case of an error.
+       - num_creds_md is the number of items in the creds_md array.
+       - status must be GRPC_STATUS_OK in case of success or another specific error
+         code otherwise.
+       - error_details contains details about the error if any. In case of success
+         it should be NULL and will be otherwise ignored. */
+    typedef void (*grpc_credentials_plugin_metadata_cb)(
+        void* user_data, const grpc_metadata* creds_md, size_t num_creds_md, grpc_status_code status, const char* error_details
+    );
+
+    /** Context that can be used by metadata credentials plugin in order to create
+       auth related metadata. */
+    typedef struct
+    {
+        /** The fully qualifed service url. */
+        const char* service_url;
+
+        /** The method name of the RPC being called (not fully qualified).
+           The fully qualified method name can be built from the service_url:
+           full_qualified_method_name = ctx->service_url + '/' + ctx->method_name. */
+        const char* method_name;
+
+        /** The auth_context of the channel which gives the server's identity. */
+        const grpc_auth_context* channel_auth_context;
+
+        /** Reserved for future use. */
+        void* reserved;
+    } grpc_auth_metadata_context;
+
+    /** Performs a deep copy from \a from to \a to. **/
+    GRPCAPI void grpc_auth_metadata_context_copy(grpc_auth_metadata_context* from, grpc_auth_metadata_context* to);
+
+    /** Releases internal resources held by \a context. **/
+    GRPCAPI void grpc_auth_metadata_context_reset(
+        grpc_auth_metadata_context* context
+    );
 
 /** Maximum number of metadata entries returnable by a credentials plugin via
     a synchronous return. */
 #define GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX 4
 
-/** grpc_metadata_credentials plugin is an API user provided structure used to
-   create grpc_credentials objects that can be set on a channel (composed) or
-   a call. See grpc_credentials_metadata_create_from_plugin below.
-   The grpc client stack will call the get_metadata method of the plugin for
-   every call in scope for the credentials created from it. */
-typedef struct {
-  /** The implementation of this method has to be non-blocking, but can
-     be performed synchronously or asynchronously.
-
-     If processing occurs synchronously, returns non-zero and populates
-     creds_md, num_creds_md, status, and error_details.  In this case,
-     the caller takes ownership of the entries in creds_md and of
-     error_details.  Note that if the plugin needs to return more than
-     GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX entries in creds_md, it must
-     return asynchronously.
-
-     If processing occurs asynchronously, returns zero and invokes \a cb
-     when processing is completed.  \a user_data will be passed as the
-     first parameter of the callback.  NOTE: \a cb MUST be invoked in a
-     different thread, not from the thread in which \a get_metadata() is
-     invoked.
-
-     \a context is the information that can be used by the plugin to create
-     auth metadata. */
-  int (*get_metadata)(
-      void* state, grpc_auth_metadata_context context,
-      grpc_credentials_plugin_metadata_cb cb, void* user_data,
-      grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
-      size_t* num_creds_md, grpc_status_code* status,
-      const char** error_details);
-
-  /** Implements debug string of the given plugin. This method returns an
-   * allocated string that the caller needs to free using gpr_free() */
-  char* (*debug_string)(void* state);
-
-  /** Destroys the plugin state. */
-  void (*destroy)(void* state);
-
-  /** State that will be set as the first parameter of the methods above. */
-  void* state;
-
-  /** Type of credentials that this plugin is implementing. */
-  const char* type;
-} grpc_metadata_credentials_plugin;
-
-/** Creates a credentials object from a plugin with a specified minimum security
- * level. */
-GRPCAPI grpc_call_credentials* grpc_metadata_credentials_create_from_plugin(
-    grpc_metadata_credentials_plugin plugin,
-    grpc_security_level min_security_level, void* reserved);
-
-/** Server certificate config object holds the server's public certificates and
-   associated private keys, as well as any CA certificates needed for client
-   certificate validation (if applicable). Create using
-   grpc_ssl_server_certificate_config_create(). */
-typedef struct grpc_ssl_server_certificate_config
-    grpc_ssl_server_certificate_config;
-
-/** Creates a grpc_ssl_server_certificate_config object.
-   - pem_roots_cert is the NULL-terminated string containing the PEM encoding of
-     the client root certificates. This parameter may be NULL if the server does
-     not want the client to be authenticated with SSL.
-   - pem_key_cert_pairs is an array private key / certificate chains of the
-     server. This parameter cannot be NULL.
-   - num_key_cert_pairs indicates the number of items in the private_key_files
-     and cert_chain_files parameters. It must be at least 1.
-   - It is the caller's responsibility to free this object via
-     grpc_ssl_server_certificate_config_destroy(). */
-GRPCAPI grpc_ssl_server_certificate_config*
-grpc_ssl_server_certificate_config_create(
-    const char* pem_root_certs,
-    const grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs,
-    size_t num_key_cert_pairs);
-
-/** Destroys a grpc_ssl_server_certificate_config object. */
-GRPCAPI void grpc_ssl_server_certificate_config_destroy(
-    grpc_ssl_server_certificate_config* config);
-
-/** Callback to retrieve updated SSL server certificates, private keys, and
-   trusted CAs (for client authentication).
-    - user_data parameter, if not NULL, contains opaque data to be used by the
-      callback.
-    - Use grpc_ssl_server_certificate_config_create to create the config.
-    - The caller assumes ownership of the config. */
-typedef grpc_ssl_certificate_config_reload_status (
-    *grpc_ssl_server_certificate_config_callback)(
-    void* user_data, grpc_ssl_server_certificate_config** config);
-
-/** Deprecated in favor of grpc_ssl_server_credentials_create_ex.
-   Creates an SSL server_credentials object.
-   - pem_roots_cert is the NULL-terminated string containing the PEM encoding of
-     the client root certificates. This parameter may be NULL if the server does
-     not want the client to be authenticated with SSL.
-   - pem_key_cert_pairs is an array private key / certificate chains of the
-     server. This parameter cannot be NULL.
-   - num_key_cert_pairs indicates the number of items in the private_key_files
-     and cert_chain_files parameters. It should be at least 1.
-   - force_client_auth, if set to non-zero will force the client to authenticate
-     with an SSL cert. Note that this option is ignored if pem_root_certs is
-     NULL. */
-GRPCAPI grpc_server_credentials* grpc_ssl_server_credentials_create(
-    const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs,
-    size_t num_key_cert_pairs, int force_client_auth, void* reserved);
-
-/** Deprecated in favor of grpc_ssl_server_credentials_create_with_options.
-   Same as grpc_ssl_server_credentials_create method except uses
-   grpc_ssl_client_certificate_request_type enum to support more ways to
-   authenticate client certificates.*/
-GRPCAPI grpc_server_credentials* grpc_ssl_server_credentials_create_ex(
-    const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs,
-    size_t num_key_cert_pairs,
-    grpc_ssl_client_certificate_request_type client_certificate_request,
-    void* reserved);
-
-typedef struct grpc_ssl_server_credentials_options
-    grpc_ssl_server_credentials_options;
-
-/** Creates an options object using a certificate config. Use this method when
-   the certificates and keys of the SSL server will not change during the
-   server's lifetime.
-   - Takes ownership of the certificate_config parameter. */
-GRPCAPI grpc_ssl_server_credentials_options*
-grpc_ssl_server_credentials_create_options_using_config(
-    grpc_ssl_client_certificate_request_type client_certificate_request,
-    grpc_ssl_server_certificate_config* certificate_config);
-
-/** Creates an options object using a certificate config fetcher. Use this
-   method to reload the certificates and keys of the SSL server without
-   interrupting the operation of the server. Initial certificate config will be
-   fetched during server initialization.
-   - user_data parameter, if not NULL, contains opaque data which will be passed
-     to the fetcher (see definition of
-     grpc_ssl_server_certificate_config_callback). */
-GRPCAPI grpc_ssl_server_credentials_options*
-grpc_ssl_server_credentials_create_options_using_config_fetcher(
-    grpc_ssl_client_certificate_request_type client_certificate_request,
-    grpc_ssl_server_certificate_config_callback cb, void* user_data);
-
-/** Destroys a grpc_ssl_server_credentials_options object. */
-GRPCAPI void grpc_ssl_server_credentials_options_destroy(
-    grpc_ssl_server_credentials_options* options);
-
-/** Creates an SSL server_credentials object using the provided options struct.
-    - Takes ownership of the options parameter. */
-GRPCAPI grpc_server_credentials*
-grpc_ssl_server_credentials_create_with_options(
-    grpc_ssl_server_credentials_options* options);
-
-/** --- Call specific credentials. --- */
-
-/** Sets a credentials to a call. Can only be called on the client side before
-   grpc_call_start_batch. */
-GRPCAPI grpc_call_error grpc_call_set_credentials(grpc_call* call,
-                                                  grpc_call_credentials* creds);
-
-/** --- Auth Metadata Processing --- */
-
-/** Callback function that is called when the metadata processing is done.
-   - Consumed metadata will be removed from the set of metadata available on the
-     call. consumed_md may be NULL if no metadata has been consumed.
-   - Response metadata will be set on the response. response_md may be NULL.
-   - status is GRPC_STATUS_OK for success or a specific status for an error.
-     Common error status for auth metadata processing is either
-     GRPC_STATUS_UNAUTHENTICATED in case of an authentication failure or
-     GRPC_STATUS PERMISSION_DENIED in case of an authorization failure.
-   - error_details gives details about the error. May be NULL. */
-typedef void (*grpc_process_auth_metadata_done_cb)(
-    void* user_data, const grpc_metadata* consumed_md, size_t num_consumed_md,
-    const grpc_metadata* response_md, size_t num_response_md,
-    grpc_status_code status, const char* error_details);
-
-/** Pluggable server-side metadata processor object. */
-typedef struct {
-  /** The context object is read/write: it contains the properties of the
-     channel peer and it is the job of the process function to augment it with
-     properties derived from the passed-in metadata.
-     The lifetime of these objects is guaranteed until cb is invoked. */
-  void (*process)(void* state, grpc_auth_context* context,
-                  const grpc_metadata* md, size_t num_md,
-                  grpc_process_auth_metadata_done_cb cb, void* user_data);
-  void (*destroy)(void* state);
-  void* state;
-} grpc_auth_metadata_processor;
-
-GRPCAPI void grpc_server_credentials_set_auth_metadata_processor(
-    grpc_server_credentials* creds, grpc_auth_metadata_processor processor);
-
-/** --- ALTS channel/server credentials --- **/
-
-/**
- * Main interface for ALTS credentials options. The options will contain
- * information that will be passed from grpc to TSI layer such as RPC protocol
- * versions. ALTS client (channel) and server credentials will have their own
- * implementation of this interface. The APIs listed in this header are
- * thread-compatible. It is used for experimental purpose for now and subject
- * to change.
- */
-typedef struct grpc_alts_credentials_options grpc_alts_credentials_options;
-
-/**
- * This method creates a grpc ALTS credentials client options instance.
- * It is used for experimental purpose for now and subject to change.
- */
-GRPCAPI grpc_alts_credentials_options*
-grpc_alts_credentials_client_options_create(void);
-
-/**
- * This method creates a grpc ALTS credentials server options instance.
- * It is used for experimental purpose for now and subject to change.
- */
-GRPCAPI grpc_alts_credentials_options*
-grpc_alts_credentials_server_options_create(void);
-
-/**
- * This method adds a target service account to grpc client's ALTS credentials
- * options instance. It is used for experimental purpose for now and subject
- * to change.
- *
- * - options: grpc ALTS credentials options instance.
- * - service_account: service account of target endpoint.
- */
-GRPCAPI void grpc_alts_credentials_client_options_add_target_service_account(
-    grpc_alts_credentials_options* options, const char* service_account);
-
-/**
- * This method destroys a grpc_alts_credentials_options instance by
- * de-allocating all of its occupied memory. It is used for experimental purpose
- * for now and subject to change.
- *
- * - options: a grpc_alts_credentials_options instance that needs to be
- *   destroyed.
- */
-GRPCAPI void grpc_alts_credentials_options_destroy(
-    grpc_alts_credentials_options* options);
-
-/**
- * This method creates an ALTS channel credential object. The security
- * level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
- * It is used for experimental purpose for now and subject to change.
- *
- * - options: grpc ALTS credentials options instance for client.
- *
- * It returns the created ALTS channel credential object.
- */
-GRPCAPI grpc_channel_credentials* grpc_alts_credentials_create(
-    const grpc_alts_credentials_options* options);
-
-/**
- * This method creates an ALTS server credential object. It is used for
- * experimental purpose for now and subject to change.
- *
- * - options: grpc ALTS credentials options instance for server.
- *
- * It returns the created ALTS server credential object.
- */
-GRPCAPI grpc_server_credentials* grpc_alts_server_credentials_create(
-    const grpc_alts_credentials_options* options);
-
-/** --- Local channel/server credentials --- **/
-
-/**
- * This method creates a local channel credential object. The security level
- * of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY for UDS and
- * GRPC_SECURITY_NONE for LOCAL_TCP. It is used for experimental purpose
- * for now and subject to change.
- *
- * - type: local connection type
- *
- * It returns the created local channel credential object.
- */
-GRPCAPI grpc_channel_credentials* grpc_local_credentials_create(
-    grpc_local_connect_type type);
-
-/**
- * This method creates a local server credential object. It is used for
- * experimental purpose for now and subject to change.
- *
- * - type: local connection type
- *
- * It returns the created local server credential object.
- */
-GRPCAPI grpc_server_credentials* grpc_local_server_credentials_create(
-    grpc_local_connect_type type);
-
-/** --- TLS channel/server credentials ---
- * It is used for experimental purpose for now and subject to change. */
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * A struct that can be specified by callers to configure underlying TLS
- * behaviors.
- */
-typedef struct grpc_tls_credentials_options grpc_tls_credentials_options;
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * A struct provides ways to gain credential data that will be used in the TLS
- * handshake.
- */
-typedef struct grpc_tls_certificate_provider grpc_tls_certificate_provider;
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * A struct that stores the credential data presented to the peer in handshake
- * to show local identity.
- */
-typedef struct grpc_tls_identity_pairs grpc_tls_identity_pairs;
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Creates a grpc_tls_identity_pairs that stores a list of identity credential
- * data, including identity private key and identity certificate chain.
- */
-GRPCAPI grpc_tls_identity_pairs* grpc_tls_identity_pairs_create();
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Adds a identity private key and a identity certificate chain to
- * grpc_tls_identity_pairs. This function will make an internal copy of
- * |private_key| and |cert_chain|.
- */
-GRPCAPI void grpc_tls_identity_pairs_add_pair(grpc_tls_identity_pairs* pairs,
-                                              const char* private_key,
-                                              const char* cert_chain);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Destroys a grpc_tls_identity_pairs object. If this object is passed to a
- * provider initiation function, the ownership is transferred so this function
- * doesn't need to be called. Otherwise the creator of the
- * grpc_tls_identity_pairs object is responsible for its destruction.
- */
-GRPCAPI void grpc_tls_identity_pairs_destroy(grpc_tls_identity_pairs* pairs);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Creates a grpc_tls_certificate_provider that will load credential data from
- * static string during initialization. This provider will always return the
- * same cert data for all cert names.
- * root_certificate and pem_key_cert_pairs can be nullptr, indicating the
- * corresponding credential data is not needed.
- * This function will make a copy of |root_certificate|.
- * The ownership of |pem_key_cert_pairs| is transferred.
- */
-GRPCAPI grpc_tls_certificate_provider*
-grpc_tls_certificate_provider_static_data_create(
-    const char* root_certificate, grpc_tls_identity_pairs* pem_key_cert_pairs);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Creates a grpc_tls_certificate_provider that will watch the credential
- * changes on the file system. This provider will always return the up-to-date
- * cert data for all the cert names callers set through
- * |grpc_tls_credentials_options|. Note that this API only supports one key-cert
- * file and hence one set of identity key-cert pair, so SNI(Server Name
- * Indication) is not supported.
- * - private_key_path is the file path of the private key. This must be set if
- *   |identity_certificate_path| is set. Otherwise, it could be null if no
- *   identity credentials are needed.
- * - identity_certificate_path is the file path of the identity certificate
- *   chain. This must be set if |private_key_path| is set. Otherwise, it could
- *   be null if no identity credentials are needed.
- * - root_cert_path is the file path to the root certificate bundle. This
- *   may be null if no root certs are needed.
- * - refresh_interval_sec is the refreshing interval that we will check the
- *   files for updates.
- * It does not take ownership of parameters.
- */
-GRPCAPI grpc_tls_certificate_provider*
-grpc_tls_certificate_provider_file_watcher_create(
-    const char* private_key_path, const char* identity_certificate_path,
-    const char* root_cert_path, unsigned int refresh_interval_sec);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Releases a grpc_tls_certificate_provider object. The creator of the
- * grpc_tls_certificate_provider object is responsible for its release.
- */
-GRPCAPI void grpc_tls_certificate_provider_release(
-    grpc_tls_certificate_provider* provider);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Creates an grpc_tls_credentials_options.
- */
-GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_create(void);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Sets the credential provider in the options.
- * The |options| will implicitly take a new ref to the |provider|.
- */
-GRPCAPI void grpc_tls_credentials_options_set_certificate_provider(
-    grpc_tls_credentials_options* options,
-    grpc_tls_certificate_provider* provider);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * If set, gRPC stack will keep watching the root certificates with
- * name |root_cert_name|.
- * If this is not set on the client side, we will use the root certificates
- * stored in the default system location, since client side must provide root
- * certificates in TLS.
- * If this is not set on the server side, we will not watch any root certificate
- * updates, and assume no root certificates needed for the server(single-side
- * TLS). Default root certs on the server side is not supported.
- */
-GRPCAPI void grpc_tls_credentials_options_watch_root_certs(
-    grpc_tls_credentials_options* options);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Sets the name of the root certificates being watched.
- * If not set, We will use a default empty string as the root certificate name.
- */
-GRPCAPI void grpc_tls_credentials_options_set_root_cert_name(
-    grpc_tls_credentials_options* options, const char* root_cert_name);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * If set, gRPC stack will keep watching the identity key-cert pairs
- * with name |identity_cert_name|.
- * This is required on the server side, and optional on the client side.
- */
-GRPCAPI void grpc_tls_credentials_options_watch_identity_key_cert_pairs(
-    grpc_tls_credentials_options* options);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Sets the name of the identity certificates being watched.
- * If not set, We will use a default empty string as the identity certificate
- * name.
- */
-GRPCAPI void grpc_tls_credentials_options_set_identity_cert_name(
-    grpc_tls_credentials_options* options, const char* identity_cert_name);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Sets the options of whether to request and/or verify client certs. This shall
- * only be called on the server side.
- */
-GRPCAPI void grpc_tls_credentials_options_set_cert_request_type(
-    grpc_tls_credentials_options* options,
-    grpc_ssl_client_certificate_request_type type);
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * If set, gRPC will read all hashed x.509 CRL files in the directory and
- * enforce the CRL files on all TLS handshakes. Only supported for OpenSSL
- * version > 1.1.
- * It is used for experimental purpose for now and subject to change.
- */
-GRPCAPI void grpc_tls_credentials_options_set_crl_directory(
-    grpc_tls_credentials_options* options, const char* crl_directory);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Sets the options of whether to verify server certs on the client side.
- * Passing in a non-zero value indicates verifying the certs.
- */
-GRPCAPI void grpc_tls_credentials_options_set_verify_server_cert(
-    grpc_tls_credentials_options* options, int verify_server_cert);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * The read-only request information exposed in a verification call.
- * Callers should not directly manage the ownership of it. We will make sure it
- * is always available inside verify() or cancel() call, and will destroy the
- * object at the end of custom verification.
- */
-typedef struct grpc_tls_custom_verification_check_request {
-  /* The target name of the server when the client initiates the connection. */
-  /* This field will be nullptr if on the server side. */
-  const char* target_name;
-  /* The information contained in the certificate chain sent from the peer. */
-  struct peer_info {
-    /* The Common Name field on the peer leaf certificate. */
-    const char* common_name;
-    /* The list of Subject Alternative Names on the peer leaf certificate. */
-    struct san_names {
-      char** uri_names;
-      size_t uri_names_size;
-      char** dns_names;
-      size_t dns_names_size;
-      char** email_names;
-      size_t email_names_size;
-      char** ip_names;
-      size_t ip_names_size;
-    } san_names;
-    /* The raw peer leaf certificate. */
-    const char* peer_cert;
-    /* The raw peer certificate chain. Note that it is not always guaranteed to
-     * get the peer full chain. For more, please refer to
-     * GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME defined in file
-     * grpc_security_constants.h.
-     * TODO(ZhenLian): Consider fixing this in the future. */
-    const char* peer_cert_full_chain;
-  } peer_info;
-} grpc_tls_custom_verification_check_request;
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * A callback function provided by gRPC as a parameter of the |verify| function
- * in grpc_tls_certificate_verifier_external. If |verify| is expected to be run
- * asynchronously, the implementer of |verify| will need to invoke this callback
- * with |callback_arg| and proper verification status at the end to bring the
- * control back to gRPC C core.
- */
-typedef void (*grpc_tls_on_custom_verification_check_done_cb)(
-    grpc_tls_custom_verification_check_request* request, void* callback_arg,
-    grpc_status_code status, const char* error_details);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * The internal verifier type that will be used inside core.
- */
-typedef struct grpc_tls_certificate_verifier grpc_tls_certificate_verifier;
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * A struct containing all the necessary functions a custom external verifier
- * needs to implement to be able to be converted to an internal verifier.
- */
-typedef struct grpc_tls_certificate_verifier_external {
-  void* user_data;
-  /**
-   * A function pointer containing the verification logic that will be
-   * performed after the TLS handshake is done. It could be processed
-   * synchronously or asynchronously.
-   * - If expected to be processed synchronously, the implementer should
-   *   populate the verification result through |sync_status| and
-   *   |sync_error_details|, and then return true.
-   * - If expected to be processed asynchronously, the implementer should return
-   *   false immediately, and then in the asynchronous thread invoke |callback|
-   *   with the verification result. The implementer MUST NOT invoke the async
-   *   |callback| in the same thread before |verify| returns, otherwise it can
-   *   lead to deadlocks.
-   *
-   * user_data: any argument that is passed in the user_data of
-   *            grpc_tls_certificate_verifier_external during construction time
-   *            can be retrieved later here.
-   * request: request information exposed to the function implementer.
-   * callback: the callback that the function implementer needs to invoke, if
-   *           return a non-zero value. It is usually invoked when the
-   *           asynchronous verification is done, and serves to bring the
-   *           control back to gRPC.
-   * callback_arg: A pointer to the internal ExternalVerifier instance. This is
-   *               mainly used as an argument in |callback|, if want to invoke
-   *               |callback| in async mode.
-   * sync_status: indicates if a connection should be allowed. This should only
-   *              be used if the verification check is done synchronously.
-   * sync_error_details: the error generated while verifying a connection. This
-   *                     should only be used if the verification check is done
-   *                     synchronously. the implementation must allocate the
-   *                     error string via gpr_malloc() or gpr_strdup().
-   * return: return 0 if |verify| is expected to be executed asynchronously,
-   *         otherwise return a non-zero value.
-   */
-  int (*verify)(void* user_data,
-                grpc_tls_custom_verification_check_request* request,
-                grpc_tls_on_custom_verification_check_done_cb callback,
-                void* callback_arg, grpc_status_code* sync_status,
-                char** sync_error_details);
-  /**
-   * A function pointer that cleans up the caller-specified resources when the
-   * verifier is still running but the whole connection got cancelled. This
-   * could happen when the verifier is doing some async operations, and the
-   * whole handshaker object got destroyed because of connection time limit is
-   * reached, or any other reasons. In such cases, function implementers might
-   * want to be notified, and properly clean up some resources.
-   *
-   * user_data: any argument that is passed in the user_data of
-   *            grpc_tls_certificate_verifier_external during construction time
-   *            can be retrieved later here.
-   * request: request information exposed to the function implementer. It will
-   *          be the same request object that was passed to verify(), and it
-   *          tells the cancel() which request to cancel.
-   */
-  void (*cancel)(void* user_data,
-                 grpc_tls_custom_verification_check_request* request);
-  /**
-   * A function pointer that does some additional destruction work when the
-   * verifier is destroyed. This is used when the caller wants to associate some
-   * objects to the lifetime of external_verifier, and destroy them when
-   * external_verifier got destructed. For example, in C++, the class containing
-   * user-specified callback functions should not be destroyed before
-   * external_verifier, since external_verifier will invoke them while being
-   * used.
-   * Note that the caller MUST delete the grpc_tls_certificate_verifier_external
-   * object itself in this function, otherwise it will cause memory leaks. That
-   * also means the user_data has to carries at least a self pointer, for the
-   * callers to later delete it in destruct().
-   *
-   * user_data: any argument that is passed in the user_data of
-   *            grpc_tls_certificate_verifier_external during construction time
-   *            can be retrieved later here.
-   */
-  void (*destruct)(void* user_data);
-} grpc_tls_certificate_verifier_external;
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Converts an external verifier to an internal verifier.
- * Note that we will not take the ownership of the external_verifier. Callers
- * will need to delete external_verifier in its own destruct function.
- */
-grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_external_create(
-    grpc_tls_certificate_verifier_external* external_verifier);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Factory function for an internal verifier that won't perform any
- * post-handshake verification. Note: using this solely without any other
- * authentication mechanisms on the peer identity will leave your applications
- * to the MITM(Man-In-The-Middle) attacks. Users should avoid doing so in
- * production environments.
- */
-grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_no_op_create();
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Factory function for an internal verifier that will do the default hostname
- * check.
- */
-grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_host_name_create();
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Releases a grpc_tls_certificate_verifier object. The creator of the
- * grpc_tls_certificate_verifier object is responsible for its release.
- */
-void grpc_tls_certificate_verifier_release(
-    grpc_tls_certificate_verifier* verifier);
+    /** grpc_metadata_credentials plugin is an API user provided structure used to
+       create grpc_credentials objects that can be set on a channel (composed) or
+       a call. See grpc_credentials_metadata_create_from_plugin below.
+       The grpc client stack will call the get_metadata method of the plugin for
+       every call in scope for the credentials created from it. */
+    typedef struct
+    {
+        /** The implementation of this method has to be non-blocking, but can
+           be performed synchronously or asynchronously.
+
+           If processing occurs synchronously, returns non-zero and populates
+           creds_md, num_creds_md, status, and error_details.  In this case,
+           the caller takes ownership of the entries in creds_md and of
+           error_details.  Note that if the plugin needs to return more than
+           GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX entries in creds_md, it must
+           return asynchronously.
+
+           If processing occurs asynchronously, returns zero and invokes \a cb
+           when processing is completed.  \a user_data will be passed as the
+           first parameter of the callback.  NOTE: \a cb MUST be invoked in a
+           different thread, not from the thread in which \a get_metadata() is
+           invoked.
+
+           \a context is the information that can be used by the plugin to create
+           auth metadata. */
+        int (*get_metadata)(
+            void* state, grpc_auth_metadata_context context, grpc_credentials_plugin_metadata_cb cb, void* user_data, grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX], size_t* num_creds_md, grpc_status_code* status, const char** error_details
+        );
+
+        /** Implements debug string of the given plugin. This method returns an
+         * allocated string that the caller needs to free using gpr_free() */
+        char* (*debug_string)(void* state);
+
+        /** Destroys the plugin state. */
+        void (*destroy)(void* state);
+
+        /** State that will be set as the first parameter of the methods above. */
+        void* state;
+
+        /** Type of credentials that this plugin is implementing. */
+        const char* type;
+    } grpc_metadata_credentials_plugin;
+
+    /** Creates a credentials object from a plugin with a specified minimum security
+     * level. */
+    GRPCAPI grpc_call_credentials* grpc_metadata_credentials_create_from_plugin(
+        grpc_metadata_credentials_plugin plugin,
+        grpc_security_level min_security_level,
+        void* reserved
+    );
+
+    /** Server certificate config object holds the server's public certificates and
+       associated private keys, as well as any CA certificates needed for client
+       certificate validation (if applicable). Create using
+       grpc_ssl_server_certificate_config_create(). */
+    typedef struct grpc_ssl_server_certificate_config
+        grpc_ssl_server_certificate_config;
+
+    /** Creates a grpc_ssl_server_certificate_config object.
+       - pem_roots_cert is the NULL-terminated string containing the PEM encoding of
+         the client root certificates. This parameter may be NULL if the server does
+         not want the client to be authenticated with SSL.
+       - pem_key_cert_pairs is an array private key / certificate chains of the
+         server. This parameter cannot be NULL.
+       - num_key_cert_pairs indicates the number of items in the private_key_files
+         and cert_chain_files parameters. It must be at least 1.
+       - It is the caller's responsibility to free this object via
+         grpc_ssl_server_certificate_config_destroy(). */
+    GRPCAPI grpc_ssl_server_certificate_config*
+        grpc_ssl_server_certificate_config_create(
+            const char* pem_root_certs,
+            const grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs,
+            size_t num_key_cert_pairs
+        );
+
+    /** Destroys a grpc_ssl_server_certificate_config object. */
+    GRPCAPI void grpc_ssl_server_certificate_config_destroy(
+        grpc_ssl_server_certificate_config* config
+    );
+
+    /** Callback to retrieve updated SSL server certificates, private keys, and
+       trusted CAs (for client authentication).
+        - user_data parameter, if not NULL, contains opaque data to be used by the
+          callback.
+        - Use grpc_ssl_server_certificate_config_create to create the config.
+        - The caller assumes ownership of the config. */
+    typedef grpc_ssl_certificate_config_reload_status (
+        *grpc_ssl_server_certificate_config_callback
+    )(
+        void* user_data, grpc_ssl_server_certificate_config** config
+    );
+
+    /** Deprecated in favor of grpc_ssl_server_credentials_create_ex.
+       Creates an SSL server_credentials object.
+       - pem_roots_cert is the NULL-terminated string containing the PEM encoding of
+         the client root certificates. This parameter may be NULL if the server does
+         not want the client to be authenticated with SSL.
+       - pem_key_cert_pairs is an array private key / certificate chains of the
+         server. This parameter cannot be NULL.
+       - num_key_cert_pairs indicates the number of items in the private_key_files
+         and cert_chain_files parameters. It should be at least 1.
+       - force_client_auth, if set to non-zero will force the client to authenticate
+         with an SSL cert. Note that this option is ignored if pem_root_certs is
+         NULL. */
+    GRPCAPI grpc_server_credentials* grpc_ssl_server_credentials_create(
+        const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs, int force_client_auth, void* reserved
+    );
+
+    /** Deprecated in favor of grpc_ssl_server_credentials_create_with_options.
+       Same as grpc_ssl_server_credentials_create method except uses
+       grpc_ssl_client_certificate_request_type enum to support more ways to
+       authenticate client certificates.*/
+    GRPCAPI grpc_server_credentials* grpc_ssl_server_credentials_create_ex(
+        const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs, grpc_ssl_client_certificate_request_type client_certificate_request, void* reserved
+    );
+
+    typedef struct grpc_ssl_server_credentials_options
+        grpc_ssl_server_credentials_options;
+
+    /** Creates an options object using a certificate config. Use this method when
+       the certificates and keys of the SSL server will not change during the
+       server's lifetime.
+       - Takes ownership of the certificate_config parameter. */
+    GRPCAPI grpc_ssl_server_credentials_options*
+        grpc_ssl_server_credentials_create_options_using_config(
+            grpc_ssl_client_certificate_request_type client_certificate_request,
+            grpc_ssl_server_certificate_config* certificate_config
+        );
+
+    /** Creates an options object using a certificate config fetcher. Use this
+       method to reload the certificates and keys of the SSL server without
+       interrupting the operation of the server. Initial certificate config will be
+       fetched during server initialization.
+       - user_data parameter, if not NULL, contains opaque data which will be passed
+         to the fetcher (see definition of
+         grpc_ssl_server_certificate_config_callback). */
+    GRPCAPI grpc_ssl_server_credentials_options*
+        grpc_ssl_server_credentials_create_options_using_config_fetcher(
+            grpc_ssl_client_certificate_request_type client_certificate_request,
+            grpc_ssl_server_certificate_config_callback cb,
+            void* user_data
+        );
+
+    /** Destroys a grpc_ssl_server_credentials_options object. */
+    GRPCAPI void grpc_ssl_server_credentials_options_destroy(
+        grpc_ssl_server_credentials_options* options
+    );
+
+    /** Creates an SSL server_credentials object using the provided options struct.
+        - Takes ownership of the options parameter. */
+    GRPCAPI grpc_server_credentials*
+        grpc_ssl_server_credentials_create_with_options(
+            grpc_ssl_server_credentials_options* options
+        );
+
+    /** --- Call specific credentials. --- */
+
+    /** Sets a credentials to a call. Can only be called on the client side before
+       grpc_call_start_batch. */
+    GRPCAPI grpc_call_error grpc_call_set_credentials(grpc_call* call, grpc_call_credentials* creds);
+
+    /** --- Auth Metadata Processing --- */
+
+    /** Callback function that is called when the metadata processing is done.
+       - Consumed metadata will be removed from the set of metadata available on the
+         call. consumed_md may be NULL if no metadata has been consumed.
+       - Response metadata will be set on the response. response_md may be NULL.
+       - status is GRPC_STATUS_OK for success or a specific status for an error.
+         Common error status for auth metadata processing is either
+         GRPC_STATUS_UNAUTHENTICATED in case of an authentication failure or
+         GRPC_STATUS PERMISSION_DENIED in case of an authorization failure.
+       - error_details gives details about the error. May be NULL. */
+    typedef void (*grpc_process_auth_metadata_done_cb)(
+        void* user_data, const grpc_metadata* consumed_md, size_t num_consumed_md, const grpc_metadata* response_md, size_t num_response_md, grpc_status_code status, const char* error_details
+    );
+
+    /** Pluggable server-side metadata processor object. */
+    typedef struct
+    {
+        /** The context object is read/write: it contains the properties of the
+           channel peer and it is the job of the process function to augment it with
+           properties derived from the passed-in metadata.
+           The lifetime of these objects is guaranteed until cb is invoked. */
+        void (*process)(void* state, grpc_auth_context* context, const grpc_metadata* md, size_t num_md, grpc_process_auth_metadata_done_cb cb, void* user_data);
+        void (*destroy)(void* state);
+        void* state;
+    } grpc_auth_metadata_processor;
+
+    GRPCAPI void grpc_server_credentials_set_auth_metadata_processor(
+        grpc_server_credentials* creds, grpc_auth_metadata_processor processor
+    );
+
+    /** --- ALTS channel/server credentials --- **/
+
+    /**
+     * Main interface for ALTS credentials options. The options will contain
+     * information that will be passed from grpc to TSI layer such as RPC protocol
+     * versions. ALTS client (channel) and server credentials will have their own
+     * implementation of this interface. The APIs listed in this header are
+     * thread-compatible. It is used for experimental purpose for now and subject
+     * to change.
+     */
+    typedef struct grpc_alts_credentials_options grpc_alts_credentials_options;
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Sets the verifier in options. The |options| will implicitly take a new ref to
- * the |verifier|. If not set on the client side, we will verify server's
- * certificates, and check the default hostname. If not set on the server side,
- * we will verify client's certificates.
- */
-void grpc_tls_credentials_options_set_certificate_verifier(
-    grpc_tls_credentials_options* options,
-    grpc_tls_certificate_verifier* verifier);
+    /**
+     * This method creates a grpc ALTS credentials client options instance.
+     * It is used for experimental purpose for now and subject to change.
+     */
+    GRPCAPI grpc_alts_credentials_options*
+        grpc_alts_credentials_client_options_create(void);
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Sets the options of whether to check the hostname of the peer on a per-call
- * basis. This is usually used in a combination with virtual hosting at the
- * client side, where each individual call on a channel can have a different
- * host associated with it.
- * This check is intended to verify that the host specified for the individual
- * call is covered by the cert that the peer presented.
- * The default is a non-zero value, which indicates performing such checks.
- */
-GRPCAPI void grpc_tls_credentials_options_set_check_call_host(
-    grpc_tls_credentials_options* options, int check_call_host);
+    /**
+     * This method creates a grpc ALTS credentials server options instance.
+     * It is used for experimental purpose for now and subject to change.
+     */
+    GRPCAPI grpc_alts_credentials_options*
+        grpc_alts_credentials_server_options_create(void);
+
+    /**
+     * This method adds a target service account to grpc client's ALTS credentials
+     * options instance. It is used for experimental purpose for now and subject
+     * to change.
+     *
+     * - options: grpc ALTS credentials options instance.
+     * - service_account: service account of target endpoint.
+     */
+    GRPCAPI void grpc_alts_credentials_client_options_add_target_service_account(
+        grpc_alts_credentials_options* options, const char* service_account
+    );
+
+    /**
+     * This method destroys a grpc_alts_credentials_options instance by
+     * de-allocating all of its occupied memory. It is used for experimental purpose
+     * for now and subject to change.
+     *
+     * - options: a grpc_alts_credentials_options instance that needs to be
+     *   destroyed.
+     */
+    GRPCAPI void grpc_alts_credentials_options_destroy(
+        grpc_alts_credentials_options* options
+    );
+
+    /**
+     * This method creates an ALTS channel credential object. The security
+     * level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+     * It is used for experimental purpose for now and subject to change.
+     *
+     * - options: grpc ALTS credentials options instance for client.
+     *
+     * It returns the created ALTS channel credential object.
+     */
+    GRPCAPI grpc_channel_credentials* grpc_alts_credentials_create(
+        const grpc_alts_credentials_options* options
+    );
+
+    /**
+     * This method creates an ALTS server credential object. It is used for
+     * experimental purpose for now and subject to change.
+     *
+     * - options: grpc ALTS credentials options instance for server.
+     *
+     * It returns the created ALTS server credential object.
+     */
+    GRPCAPI grpc_server_credentials* grpc_alts_server_credentials_create(
+        const grpc_alts_credentials_options* options
+    );
+
+    /** --- Local channel/server credentials --- **/
+
+    /**
+     * This method creates a local channel credential object. The security level
+     * of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY for UDS and
+     * GRPC_SECURITY_NONE for LOCAL_TCP. It is used for experimental purpose
+     * for now and subject to change.
+     *
+     * - type: local connection type
+     *
+     * It returns the created local channel credential object.
+     */
+    GRPCAPI grpc_channel_credentials* grpc_local_credentials_create(
+        grpc_local_connect_type type
+    );
+
+    /**
+     * This method creates a local server credential object. It is used for
+     * experimental purpose for now and subject to change.
+     *
+     * - type: local connection type
+     *
+     * It returns the created local server credential object.
+     */
+    GRPCAPI grpc_server_credentials* grpc_local_server_credentials_create(
+        grpc_local_connect_type type
+    );
+
+    /** --- TLS channel/server credentials ---
+     * It is used for experimental purpose for now and subject to change. */
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * A struct that can be specified by callers to configure underlying TLS
+     * behaviors.
+     */
+    typedef struct grpc_tls_credentials_options grpc_tls_credentials_options;
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Performs the verification logic of an internal verifier.
- * This is typically used when composing the internal verifiers as part of the
- * custom verification.
- * If |grpc_tls_certificate_verifier_verify| returns true, inspect the
- * verification result through request->status and request->error_details.
- * Otherwise, inspect through the parameter of |callback|.
- */
-int grpc_tls_certificate_verifier_verify(
-    grpc_tls_certificate_verifier* verifier,
-    grpc_tls_custom_verification_check_request* request,
-    grpc_tls_on_custom_verification_check_done_cb callback, void* callback_arg,
-    grpc_status_code* sync_status, char** sync_error_details);
-
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Performs the cancellation logic of an internal verifier.
- * This is typically used when composing the internal verifiers as part of the
- * custom verification.
- */
-void grpc_tls_certificate_verifier_cancel(
-    grpc_tls_certificate_verifier* verifier,
-    grpc_tls_custom_verification_check_request* request);
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * A struct provides ways to gain credential data that will be used in the TLS
+     * handshake.
+     */
+    typedef struct grpc_tls_certificate_provider grpc_tls_certificate_provider;
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Creates a TLS channel credential object based on the
- * grpc_tls_credentials_options specified by callers. The
- * grpc_channel_credentials will take the ownership of the |options|. The
- * security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
- */
-grpc_channel_credentials* grpc_tls_credentials_create(
-    grpc_tls_credentials_options* options);
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * A struct that stores the credential data presented to the peer in handshake
+     * to show local identity.
+     */
+    typedef struct grpc_tls_identity_pairs grpc_tls_identity_pairs;
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * Creates a TLS server credential object based on the
- * grpc_tls_credentials_options specified by callers. The
- * grpc_server_credentials will take the ownership of the |options|.
- */
-grpc_server_credentials* grpc_tls_server_credentials_create(
-    grpc_tls_credentials_options* options);
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Creates a grpc_tls_identity_pairs that stores a list of identity credential
+     * data, including identity private key and identity certificate chain.
+     */
+    GRPCAPI grpc_tls_identity_pairs* grpc_tls_identity_pairs_create();
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Adds a identity private key and a identity certificate chain to
+     * grpc_tls_identity_pairs. This function will make an internal copy of
+     * |private_key| and |cert_chain|.
+     */
+    GRPCAPI void grpc_tls_identity_pairs_add_pair(grpc_tls_identity_pairs* pairs, const char* private_key, const char* cert_chain);
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Destroys a grpc_tls_identity_pairs object. If this object is passed to a
+     * provider initiation function, the ownership is transferred so this function
+     * doesn't need to be called. Otherwise the creator of the
+     * grpc_tls_identity_pairs object is responsible for its destruction.
+     */
+    GRPCAPI void grpc_tls_identity_pairs_destroy(grpc_tls_identity_pairs* pairs);
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Creates a grpc_tls_certificate_provider that will load credential data from
+     * static string during initialization. This provider will always return the
+     * same cert data for all cert names.
+     * root_certificate and pem_key_cert_pairs can be nullptr, indicating the
+     * corresponding credential data is not needed.
+     * This function will make a copy of |root_certificate|.
+     * The ownership of |pem_key_cert_pairs| is transferred.
+     */
+    GRPCAPI grpc_tls_certificate_provider*
+        grpc_tls_certificate_provider_static_data_create(
+            const char* root_certificate, grpc_tls_identity_pairs* pem_key_cert_pairs
+        );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Creates a grpc_tls_certificate_provider that will watch the credential
+     * changes on the file system. This provider will always return the up-to-date
+     * cert data for all the cert names callers set through
+     * |grpc_tls_credentials_options|. Note that this API only supports one key-cert
+     * file and hence one set of identity key-cert pair, so SNI(Server Name
+     * Indication) is not supported.
+     * - private_key_path is the file path of the private key. This must be set if
+     *   |identity_certificate_path| is set. Otherwise, it could be null if no
+     *   identity credentials are needed.
+     * - identity_certificate_path is the file path of the identity certificate
+     *   chain. This must be set if |private_key_path| is set. Otherwise, it could
+     *   be null if no identity credentials are needed.
+     * - root_cert_path is the file path to the root certificate bundle. This
+     *   may be null if no root certs are needed.
+     * - refresh_interval_sec is the refreshing interval that we will check the
+     *   files for updates.
+     * It does not take ownership of parameters.
+     */
+    GRPCAPI grpc_tls_certificate_provider*
+        grpc_tls_certificate_provider_file_watcher_create(
+            const char* private_key_path, const char* identity_certificate_path, const char* root_cert_path, unsigned int refresh_interval_sec
+        );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Releases a grpc_tls_certificate_provider object. The creator of the
+     * grpc_tls_certificate_provider object is responsible for its release.
+     */
+    GRPCAPI void grpc_tls_certificate_provider_release(
+        grpc_tls_certificate_provider* provider
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Creates an grpc_tls_credentials_options.
+     */
+    GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_create(void);
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * This method creates an insecure channel credentials object.
- */
-GRPCAPI grpc_channel_credentials* grpc_insecure_credentials_create();
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Sets the credential provider in the options.
+     * The |options| will implicitly take a new ref to the |provider|.
+     */
+    GRPCAPI void grpc_tls_credentials_options_set_certificate_provider(
+        grpc_tls_credentials_options* options,
+        grpc_tls_certificate_provider* provider
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * If set, gRPC stack will keep watching the root certificates with
+     * name |root_cert_name|.
+     * If this is not set on the client side, we will use the root certificates
+     * stored in the default system location, since client side must provide root
+     * certificates in TLS.
+     * If this is not set on the server side, we will not watch any root certificate
+     * updates, and assume no root certificates needed for the server(single-side
+     * TLS). Default root certs on the server side is not supported.
+     */
+    GRPCAPI void grpc_tls_credentials_options_watch_root_certs(
+        grpc_tls_credentials_options* options
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Sets the name of the root certificates being watched.
+     * If not set, We will use a default empty string as the root certificate name.
+     */
+    GRPCAPI void grpc_tls_credentials_options_set_root_cert_name(
+        grpc_tls_credentials_options* options, const char* root_cert_name
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * If set, gRPC stack will keep watching the identity key-cert pairs
+     * with name |identity_cert_name|.
+     * This is required on the server side, and optional on the client side.
+     */
+    GRPCAPI void grpc_tls_credentials_options_watch_identity_key_cert_pairs(
+        grpc_tls_credentials_options* options
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Sets the name of the identity certificates being watched.
+     * If not set, We will use a default empty string as the identity certificate
+     * name.
+     */
+    GRPCAPI void grpc_tls_credentials_options_set_identity_cert_name(
+        grpc_tls_credentials_options* options, const char* identity_cert_name
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Sets the options of whether to request and/or verify client certs. This shall
+     * only be called on the server side.
+     */
+    GRPCAPI void grpc_tls_credentials_options_set_cert_request_type(
+        grpc_tls_credentials_options* options,
+        grpc_ssl_client_certificate_request_type type
+    );
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * If set, gRPC will read all hashed x.509 CRL files in the directory and
+     * enforce the CRL files on all TLS handshakes. Only supported for OpenSSL
+     * version > 1.1.
+     * It is used for experimental purpose for now and subject to change.
+     */
+    GRPCAPI void grpc_tls_credentials_options_set_crl_directory(
+        grpc_tls_credentials_options* options, const char* crl_directory
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Sets the options of whether to verify server certs on the client side.
+     * Passing in a non-zero value indicates verifying the certs.
+     */
+    GRPCAPI void grpc_tls_credentials_options_set_verify_server_cert(
+        grpc_tls_credentials_options* options, int verify_server_cert
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * The read-only request information exposed in a verification call.
+     * Callers should not directly manage the ownership of it. We will make sure it
+     * is always available inside verify() or cancel() call, and will destroy the
+     * object at the end of custom verification.
+     */
+    typedef struct grpc_tls_custom_verification_check_request
+    {
+        /* The target name of the server when the client initiates the connection. */
+        /* This field will be nullptr if on the server side. */
+        const char* target_name;
+        /* The information contained in the certificate chain sent from the peer. */
+        struct peer_info
+        {
+            /* The Common Name field on the peer leaf certificate. */
+            const char* common_name;
+            /* The list of Subject Alternative Names on the peer leaf certificate. */
+            struct san_names
+            {
+                char** uri_names;
+                size_t uri_names_size;
+                char** dns_names;
+                size_t dns_names_size;
+                char** email_names;
+                size_t email_names_size;
+                char** ip_names;
+                size_t ip_names_size;
+            } san_names;
+            /* The raw peer leaf certificate. */
+            const char* peer_cert;
+            /* The raw peer certificate chain. Note that it is not always guaranteed to
+             * get the peer full chain. For more, please refer to
+             * GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME defined in file
+             * grpc_security_constants.h.
+             * TODO(ZhenLian): Consider fixing this in the future. */
+            const char* peer_cert_full_chain;
+        } peer_info;
+    } grpc_tls_custom_verification_check_request;
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * A callback function provided by gRPC as a parameter of the |verify| function
+     * in grpc_tls_certificate_verifier_external. If |verify| is expected to be run
+     * asynchronously, the implementer of |verify| will need to invoke this callback
+     * with |callback_arg| and proper verification status at the end to bring the
+     * control back to gRPC C core.
+     */
+    typedef void (*grpc_tls_on_custom_verification_check_done_cb)(
+        grpc_tls_custom_verification_check_request* request, void* callback_arg, grpc_status_code status, const char* error_details
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * The internal verifier type that will be used inside core.
+     */
+    typedef struct grpc_tls_certificate_verifier grpc_tls_certificate_verifier;
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * This method creates an insecure server credentials object.
- */
-GRPCAPI grpc_server_credentials* grpc_insecure_server_credentials_create();
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * A struct containing all the necessary functions a custom external verifier
+     * needs to implement to be able to be converted to an internal verifier.
+     */
+    typedef struct grpc_tls_certificate_verifier_external
+    {
+        void* user_data;
+        /**
+         * A function pointer containing the verification logic that will be
+         * performed after the TLS handshake is done. It could be processed
+         * synchronously or asynchronously.
+         * - If expected to be processed synchronously, the implementer should
+         *   populate the verification result through |sync_status| and
+         *   |sync_error_details|, and then return true.
+         * - If expected to be processed asynchronously, the implementer should return
+         *   false immediately, and then in the asynchronous thread invoke |callback|
+         *   with the verification result. The implementer MUST NOT invoke the async
+         *   |callback| in the same thread before |verify| returns, otherwise it can
+         *   lead to deadlocks.
+         *
+         * user_data: any argument that is passed in the user_data of
+         *            grpc_tls_certificate_verifier_external during construction time
+         *            can be retrieved later here.
+         * request: request information exposed to the function implementer.
+         * callback: the callback that the function implementer needs to invoke, if
+         *           return a non-zero value. It is usually invoked when the
+         *           asynchronous verification is done, and serves to bring the
+         *           control back to gRPC.
+         * callback_arg: A pointer to the internal ExternalVerifier instance. This is
+         *               mainly used as an argument in |callback|, if want to invoke
+         *               |callback| in async mode.
+         * sync_status: indicates if a connection should be allowed. This should only
+         *              be used if the verification check is done synchronously.
+         * sync_error_details: the error generated while verifying a connection. This
+         *                     should only be used if the verification check is done
+         *                     synchronously. the implementation must allocate the
+         *                     error string via gpr_malloc() or gpr_strdup().
+         * return: return 0 if |verify| is expected to be executed asynchronously,
+         *         otherwise return a non-zero value.
+         */
+        int (*verify)(void* user_data, grpc_tls_custom_verification_check_request* request, grpc_tls_on_custom_verification_check_done_cb callback, void* callback_arg, grpc_status_code* sync_status, char** sync_error_details);
+        /**
+         * A function pointer that cleans up the caller-specified resources when the
+         * verifier is still running but the whole connection got cancelled. This
+         * could happen when the verifier is doing some async operations, and the
+         * whole handshaker object got destroyed because of connection time limit is
+         * reached, or any other reasons. In such cases, function implementers might
+         * want to be notified, and properly clean up some resources.
+         *
+         * user_data: any argument that is passed in the user_data of
+         *            grpc_tls_certificate_verifier_external during construction time
+         *            can be retrieved later here.
+         * request: request information exposed to the function implementer. It will
+         *          be the same request object that was passed to verify(), and it
+         *          tells the cancel() which request to cancel.
+         */
+        void (*cancel)(void* user_data, grpc_tls_custom_verification_check_request* request);
+        /**
+         * A function pointer that does some additional destruction work when the
+         * verifier is destroyed. This is used when the caller wants to associate some
+         * objects to the lifetime of external_verifier, and destroy them when
+         * external_verifier got destructed. For example, in C++, the class containing
+         * user-specified callback functions should not be destroyed before
+         * external_verifier, since external_verifier will invoke them while being
+         * used.
+         * Note that the caller MUST delete the grpc_tls_certificate_verifier_external
+         * object itself in this function, otherwise it will cause memory leaks. That
+         * also means the user_data has to carries at least a self pointer, for the
+         * callers to later delete it in destruct().
+         *
+         * user_data: any argument that is passed in the user_data of
+         *            grpc_tls_certificate_verifier_external during construction time
+         *            can be retrieved later here.
+         */
+        void (*destruct)(void* user_data);
+    } grpc_tls_certificate_verifier_external;
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Converts an external verifier to an internal verifier.
+     * Note that we will not take the ownership of the external_verifier. Callers
+     * will need to delete external_verifier in its own destruct function.
+     */
+    grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_external_create(
+        grpc_tls_certificate_verifier_external* external_verifier
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Factory function for an internal verifier that won't perform any
+     * post-handshake verification. Note: using this solely without any other
+     * authentication mechanisms on the peer identity will leave your applications
+     * to the MITM(Man-In-The-Middle) attacks. Users should avoid doing so in
+     * production environments.
+     */
+    grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_no_op_create();
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * This method creates an xDS channel credentials object.
- *
- * Creating a channel with credentials of this type indicates that the channel
- * should get credentials configuration from the xDS control plane.
- *
- * \a fallback_credentials are used if the channel target does not have the
- * 'xds:///' scheme or if the xDS control plane does not provide information on
- * how to fetch credentials dynamically. Does NOT take ownership of the \a
- * fallback_credentials. (Internally takes a ref to the object.)
- */
-GRPCAPI grpc_channel_credentials* grpc_xds_credentials_create(
-    grpc_channel_credentials* fallback_credentials);
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Factory function for an internal verifier that will do the default hostname
+     * check.
+     */
+    grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_host_name_create();
 
-/**
- * EXPERIMENTAL API - Subject to change
- *
- * This method creates an xDS server credentials object.
- *
- * \a fallback_credentials are used if the xDS control plane does not provide
- * information on how to fetch credentials dynamically.
- *
- * Does NOT take ownership of the \a fallback_credentials. (Internally takes
- * a ref to the object.)
- */
-GRPCAPI grpc_server_credentials* grpc_xds_server_credentials_create(
-    grpc_server_credentials* fallback_credentials);
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Releases a grpc_tls_certificate_verifier object. The creator of the
+     * grpc_tls_certificate_verifier object is responsible for its release.
+     */
+    void grpc_tls_certificate_verifier_release(
+        grpc_tls_certificate_verifier* verifier
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Sets the verifier in options. The |options| will implicitly take a new ref to
+     * the |verifier|. If not set on the client side, we will verify server's
+     * certificates, and check the default hostname. If not set on the server side,
+     * we will verify client's certificates.
+     */
+    void grpc_tls_credentials_options_set_certificate_verifier(
+        grpc_tls_credentials_options* options,
+        grpc_tls_certificate_verifier* verifier
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Sets the options of whether to check the hostname of the peer on a per-call
+     * basis. This is usually used in a combination with virtual hosting at the
+     * client side, where each individual call on a channel can have a different
+     * host associated with it.
+     * This check is intended to verify that the host specified for the individual
+     * call is covered by the cert that the peer presented.
+     * The default is a non-zero value, which indicates performing such checks.
+     */
+    GRPCAPI void grpc_tls_credentials_options_set_check_call_host(
+        grpc_tls_credentials_options* options, int check_call_host
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Performs the verification logic of an internal verifier.
+     * This is typically used when composing the internal verifiers as part of the
+     * custom verification.
+     * If |grpc_tls_certificate_verifier_verify| returns true, inspect the
+     * verification result through request->status and request->error_details.
+     * Otherwise, inspect through the parameter of |callback|.
+     */
+    int grpc_tls_certificate_verifier_verify(
+        grpc_tls_certificate_verifier* verifier,
+        grpc_tls_custom_verification_check_request* request,
+        grpc_tls_on_custom_verification_check_done_cb callback,
+        void* callback_arg,
+        grpc_status_code* sync_status,
+        char** sync_error_details
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Performs the cancellation logic of an internal verifier.
+     * This is typically used when composing the internal verifiers as part of the
+     * custom verification.
+     */
+    void grpc_tls_certificate_verifier_cancel(
+        grpc_tls_certificate_verifier* verifier,
+        grpc_tls_custom_verification_check_request* request
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Creates a TLS channel credential object based on the
+     * grpc_tls_credentials_options specified by callers. The
+     * grpc_channel_credentials will take the ownership of the |options|. The
+     * security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
+     */
+    grpc_channel_credentials* grpc_tls_credentials_create(
+        grpc_tls_credentials_options* options
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * Creates a TLS server credential object based on the
+     * grpc_tls_credentials_options specified by callers. The
+     * grpc_server_credentials will take the ownership of the |options|.
+     */
+    grpc_server_credentials* grpc_tls_server_credentials_create(
+        grpc_tls_credentials_options* options
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * This method creates an insecure channel credentials object.
+     */
+    GRPCAPI grpc_channel_credentials* grpc_insecure_credentials_create();
 
-/**
- * EXPERIMENTAL - Subject to change.
- * An opaque type that is responsible for providing authorization policies to
- * gRPC.
- */
-typedef struct grpc_authorization_policy_provider
-    grpc_authorization_policy_provider;
-
-/**
- * EXPERIMENTAL - Subject to change.
- * Creates a grpc_authorization_policy_provider using gRPC authorization policy
- * from static string.
- * - authz_policy is the input gRPC authorization policy.
- * - code is the error status code on failure. On success, it equals
- *   GRPC_STATUS_OK.
- * - error_details contains details about the error if any. If the
- *   initialization is successful, it will be null. Caller must use gpr_free to
- *   destroy this string.
- */
-GRPCAPI grpc_authorization_policy_provider*
-grpc_authorization_policy_provider_static_data_create(
-    const char* authz_policy, grpc_status_code* code,
-    const char** error_details);
-
-/**
- * EXPERIMENTAL - Subject to change.
- * Creates a grpc_authorization_policy_provider by watching for gRPC
- * authorization policy changes in filesystem.
- * - authz_policy is the file path of gRPC authorization policy.
- * - refresh_interval_sec is the amount of time the internal thread would wait
- *   before checking for file updates.
- * - code is the error status code on failure. On success, it equals
- *   GRPC_STATUS_OK.
- * - error_details contains details about the error if any. If the
- *   initialization is successful, it will be null. Caller must use gpr_free to
- *   destroy this string.
- */
-GRPCAPI grpc_authorization_policy_provider*
-grpc_authorization_policy_provider_file_watcher_create(
-    const char* authz_policy_path, unsigned int refresh_interval_sec,
-    grpc_status_code* code, const char** error_details);
-
-/**
- * EXPERIMENTAL - Subject to change.
- * Releases grpc_authorization_policy_provider object. The creator of
- * grpc_authorization_policy_provider is responsible for its release.
- */
-GRPCAPI void grpc_authorization_policy_provider_release(
-    grpc_authorization_policy_provider* provider);
-
-/** --- TLS session key logging. ---
- * Experimental API to control tls session key logging. Tls session key logging
- * is expected to be used only for debugging purposes and never in production.
- * Tls session key logging is only enabled when:
- *  At least one grpc_tls_credentials_options object is assigned a tls session
- *  key logging file path using the API specified below.
- */
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * This method creates an insecure server credentials object.
+     */
+    GRPCAPI grpc_server_credentials* grpc_insecure_server_credentials_create();
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * This method creates an xDS channel credentials object.
+     *
+     * Creating a channel with credentials of this type indicates that the channel
+     * should get credentials configuration from the xDS control plane.
+     *
+     * \a fallback_credentials are used if the channel target does not have the
+     * 'xds:///' scheme or if the xDS control plane does not provide information on
+     * how to fetch credentials dynamically. Does NOT take ownership of the \a
+     * fallback_credentials. (Internally takes a ref to the object.)
+     */
+    GRPCAPI grpc_channel_credentials* grpc_xds_credentials_create(
+        grpc_channel_credentials* fallback_credentials
+    );
+
+    /**
+     * EXPERIMENTAL API - Subject to change
+     *
+     * This method creates an xDS server credentials object.
+     *
+     * \a fallback_credentials are used if the xDS control plane does not provide
+     * information on how to fetch credentials dynamically.
+     *
+     * Does NOT take ownership of the \a fallback_credentials. (Internally takes
+     * a ref to the object.)
+     */
+    GRPCAPI grpc_server_credentials* grpc_xds_server_credentials_create(
+        grpc_server_credentials* fallback_credentials
+    );
+
+    /**
+     * EXPERIMENTAL - Subject to change.
+     * An opaque type that is responsible for providing authorization policies to
+     * gRPC.
+     */
+    typedef struct grpc_authorization_policy_provider
+        grpc_authorization_policy_provider;
+
+    /**
+     * EXPERIMENTAL - Subject to change.
+     * Creates a grpc_authorization_policy_provider using gRPC authorization policy
+     * from static string.
+     * - authz_policy is the input gRPC authorization policy.
+     * - code is the error status code on failure. On success, it equals
+     *   GRPC_STATUS_OK.
+     * - error_details contains details about the error if any. If the
+     *   initialization is successful, it will be null. Caller must use gpr_free to
+     *   destroy this string.
+     */
+    GRPCAPI grpc_authorization_policy_provider*
+        grpc_authorization_policy_provider_static_data_create(
+            const char* authz_policy, grpc_status_code* code, const char** error_details
+        );
+
+    /**
+     * EXPERIMENTAL - Subject to change.
+     * Creates a grpc_authorization_policy_provider by watching for gRPC
+     * authorization policy changes in filesystem.
+     * - authz_policy is the file path of gRPC authorization policy.
+     * - refresh_interval_sec is the amount of time the internal thread would wait
+     *   before checking for file updates.
+     * - code is the error status code on failure. On success, it equals
+     *   GRPC_STATUS_OK.
+     * - error_details contains details about the error if any. If the
+     *   initialization is successful, it will be null. Caller must use gpr_free to
+     *   destroy this string.
+     */
+    GRPCAPI grpc_authorization_policy_provider*
+        grpc_authorization_policy_provider_file_watcher_create(
+            const char* authz_policy_path, unsigned int refresh_interval_sec, grpc_status_code* code, const char** error_details
+        );
+
+    /**
+     * EXPERIMENTAL - Subject to change.
+     * Releases grpc_authorization_policy_provider object. The creator of
+     * grpc_authorization_policy_provider is responsible for its release.
+     */
+    GRPCAPI void grpc_authorization_policy_provider_release(
+        grpc_authorization_policy_provider* provider
+    );
+
+    /** --- TLS session key logging. ---
+     * Experimental API to control tls session key logging. Tls session key logging
+     * is expected to be used only for debugging purposes and never in production.
+     * Tls session key logging is only enabled when:
+     *  At least one grpc_tls_credentials_options object is assigned a tls session
+     *  key logging file path using the API specified below.
+     */
 
-/**
- * EXPERIMENTAL API - Subject to change.
- * Configures a grpc_tls_credentials_options object with tls session key
- * logging capability. TLS channels using these credentials have tls session
- * key logging enabled.
- * - options is the grpc_tls_credentials_options object
- * - path is a string pointing to the location where TLS session keys would be
- *   stored.
- */
-GRPCAPI void grpc_tls_credentials_options_set_tls_session_key_log_file_path(
-    grpc_tls_credentials_options* options, const char* path);
+    /**
+     * EXPERIMENTAL API - Subject to change.
+     * Configures a grpc_tls_credentials_options object with tls session key
+     * logging capability. TLS channels using these credentials have tls session
+     * key logging enabled.
+     * - options is the grpc_tls_credentials_options object
+     * - path is a string pointing to the location where TLS session keys would be
+     *   stored.
+     */
+    GRPCAPI void grpc_tls_credentials_options_set_tls_session_key_log_file_path(
+        grpc_tls_credentials_options* options, const char* path
+    );
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/grpc_security_constants.h b/CAPI/cpp/grpc/include/grpc/grpc_security_constants.h
index 505037e..b2b15de 100644
--- a/CAPI/cpp/grpc/include/grpc/grpc_security_constants.h
+++ b/CAPI/cpp/grpc/include/grpc/grpc_security_constants.h
@@ -20,7 +20,8 @@
 #define GRPC_GRPC_SECURITY_CONSTANTS_H
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #define GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME "transport_security_type"
@@ -55,95 +56,107 @@ extern "C" {
    must be a PEM encoded file with all the roots such as the one that can be
    downloaded from https://pki.google.com/roots.pem.  */
 #define GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR \
-  "GRPC_DEFAULT_SSL_ROOTS_FILE_PATH"
+    "GRPC_DEFAULT_SSL_ROOTS_FILE_PATH"
 
 /** Environment variable that points to the google default application
    credentials json key or refresh token. Used in the
    grpc_google_default_credentials_create function. */
 #define GRPC_GOOGLE_CREDENTIALS_ENV_VAR "GOOGLE_APPLICATION_CREDENTIALS"
 
-/** Results for the SSL roots override callback. */
-typedef enum {
-  GRPC_SSL_ROOTS_OVERRIDE_OK,
-  GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY, /** Do not try fallback options. */
-  GRPC_SSL_ROOTS_OVERRIDE_FAIL
-} grpc_ssl_roots_override_result;
-
-/** Callback results for dynamically loading a SSL certificate config. */
-typedef enum {
-  GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED,
-  GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW,
-  GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL
-} grpc_ssl_certificate_config_reload_status;
-
-typedef enum {
-  /** Server does not request client certificate.
-     The certificate presented by the client is not checked by the server at
-     all. (A client may present a self signed or signed certificate or not
-     present a certificate at all and any of those option would be accepted) */
-  GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE,
-  /** Server requests client certificate but does not enforce that the client
-     presents a certificate.
-
-     If the client presents a certificate, the client authentication is left to
-     the application (the necessary metadata will be available to the
-     application via authentication context properties, see grpc_auth_context).
-
-     The client's key certificate pair must be valid for the SSL connection to
-     be established. */
-  GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY,
-  /** Server requests client certificate but does not enforce that the client
-     presents a certificate.
-
-     If the client presents a certificate, the client authentication is done by
-     the gRPC framework. (For a successful connection the client needs to either
-     present a certificate that can be verified against the root certificate
-     configured by the server or not present a certificate at all)
-
-     The client's key certificate pair must be valid for the SSL connection to
-     be established. */
-  GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY,
-  /** Server requests client certificate and enforces that the client presents a
-     certificate.
-
-     If the client presents a certificate, the client authentication is left to
-     the application (the necessary metadata will be available to the
-     application via authentication context properties, see grpc_auth_context).
-
-     The client's key certificate pair must be valid for the SSL connection to
-     be established. */
-  GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY,
-  /** Server requests client certificate and enforces that the client presents a
-     certificate.
-
-     The certificate presented by the client is verified by the gRPC framework.
-     (For a successful connection the client needs to present a certificate that
-     can be verified against the root certificate configured by the server)
-
-     The client's key certificate pair must be valid for the SSL connection to
-     be established. */
-  GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY
-} grpc_ssl_client_certificate_request_type;
-
-/* Security levels of grpc transport security. It represents an inherent
- * property of a backend connection and is determined by a channel credential
- * used to create the connection. */
-typedef enum {
-  GRPC_SECURITY_MIN,
-  GRPC_SECURITY_NONE = GRPC_SECURITY_MIN,
-  GRPC_INTEGRITY_ONLY,
-  GRPC_PRIVACY_AND_INTEGRITY,
-  GRPC_SECURITY_MAX = GRPC_PRIVACY_AND_INTEGRITY,
-} grpc_security_level;
-
-/**
- * Type of local connections for which local channel/server credentials will be
- * applied. It supports UDS and local TCP connections.
- */
-typedef enum { UDS = 0, LOCAL_TCP } grpc_local_connect_type;
-
-/** The TLS versions that are supported by the SSL stack. **/
-typedef enum { TLS1_2, TLS1_3 } grpc_tls_version;
+    /** Results for the SSL roots override callback. */
+    typedef enum
+    {
+        GRPC_SSL_ROOTS_OVERRIDE_OK,
+        GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY, /** Do not try fallback options. */
+        GRPC_SSL_ROOTS_OVERRIDE_FAIL
+    } grpc_ssl_roots_override_result;
+
+    /** Callback results for dynamically loading a SSL certificate config. */
+    typedef enum
+    {
+        GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED,
+        GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW,
+        GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL
+    } grpc_ssl_certificate_config_reload_status;
+
+    typedef enum
+    {
+        /** Server does not request client certificate.
+           The certificate presented by the client is not checked by the server at
+           all. (A client may present a self signed or signed certificate or not
+           present a certificate at all and any of those option would be accepted) */
+        GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE,
+        /** Server requests client certificate but does not enforce that the client
+           presents a certificate.
+
+           If the client presents a certificate, the client authentication is left to
+           the application (the necessary metadata will be available to the
+           application via authentication context properties, see grpc_auth_context).
+
+           The client's key certificate pair must be valid for the SSL connection to
+           be established. */
+        GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY,
+        /** Server requests client certificate but does not enforce that the client
+           presents a certificate.
+
+           If the client presents a certificate, the client authentication is done by
+           the gRPC framework. (For a successful connection the client needs to either
+           present a certificate that can be verified against the root certificate
+           configured by the server or not present a certificate at all)
+
+           The client's key certificate pair must be valid for the SSL connection to
+           be established. */
+        GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY,
+        /** Server requests client certificate and enforces that the client presents a
+           certificate.
+
+           If the client presents a certificate, the client authentication is left to
+           the application (the necessary metadata will be available to the
+           application via authentication context properties, see grpc_auth_context).
+
+           The client's key certificate pair must be valid for the SSL connection to
+           be established. */
+        GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY,
+        /** Server requests client certificate and enforces that the client presents a
+           certificate.
+
+           The certificate presented by the client is verified by the gRPC framework.
+           (For a successful connection the client needs to present a certificate that
+           can be verified against the root certificate configured by the server)
+
+           The client's key certificate pair must be valid for the SSL connection to
+           be established. */
+        GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY
+    } grpc_ssl_client_certificate_request_type;
+
+    /* Security levels of grpc transport security. It represents an inherent
+     * property of a backend connection and is determined by a channel credential
+     * used to create the connection. */
+    typedef enum
+    {
+        GRPC_SECURITY_MIN,
+        GRPC_SECURITY_NONE = GRPC_SECURITY_MIN,
+        GRPC_INTEGRITY_ONLY,
+        GRPC_PRIVACY_AND_INTEGRITY,
+        GRPC_SECURITY_MAX = GRPC_PRIVACY_AND_INTEGRITY,
+    } grpc_security_level;
+
+    /**
+     * Type of local connections for which local channel/server credentials will be
+     * applied. It supports UDS and local TCP connections.
+     */
+    typedef enum
+    {
+        UDS = 0,
+        LOCAL_TCP
+    } grpc_local_connect_type;
+
+    /** The TLS versions that are supported by the SSL stack. **/
+    typedef enum
+    {
+        TLS1_2,
+        TLS1_3
+    } grpc_tls_version;
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h
index 606369a..f6651e4 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm.h
@@ -82,13 +82,13 @@
 #endif
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** Adds \a delta to \a *value, clamping the result to the range specified
-    by \a min and \a max.  Returns the new value. */
-gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta,
-                                       gpr_atm min, gpr_atm max);
+    /** Adds \a delta to \a *value, clamping the result to the range specified
+        by \a min and \a max.  Returns the new value. */
+    gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta, gpr_atm min, gpr_atm max);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_atomic.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_atomic.h
index 05d6e42..23cefe5 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_atomic.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_atomic.h
@@ -26,22 +26,23 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-typedef intptr_t gpr_atm;
+    typedef intptr_t gpr_atm;
 #define GPR_ATM_MAX INTPTR_MAX
 #define GPR_ATM_MIN INTPTR_MIN
 
 #ifdef GPR_LOW_LEVEL_COUNTERS
-extern gpr_atm gpr_counter_atm_cas;
-extern gpr_atm gpr_counter_atm_add;
+    extern gpr_atm gpr_counter_atm_cas;
+    extern gpr_atm gpr_counter_atm_add;
 #define GPR_ATM_INC_COUNTER(counter) \
-  __atomic_fetch_add(&counter, 1, __ATOMIC_RELAXED)
+    __atomic_fetch_add(&counter, 1, __ATOMIC_RELAXED)
 #define GPR_ATM_INC_CAS_THEN(blah) \
-  (GPR_ATM_INC_COUNTER(gpr_counter_atm_cas), blah)
+    (GPR_ATM_INC_COUNTER(gpr_counter_atm_cas), blah)
 #define GPR_ATM_INC_ADD_THEN(blah) \
-  (GPR_ATM_INC_COUNTER(gpr_counter_atm_add), blah)
+    (GPR_ATM_INC_COUNTER(gpr_counter_atm_add), blah)
 #else
 #define GPR_ATM_INC_CAS_THEN(blah) blah
 #define GPR_ATM_INC_ADD_THEN(blah) blah
@@ -52,39 +53,49 @@ extern gpr_atm gpr_counter_atm_add;
 #define gpr_atm_acq_load(p) (__atomic_load_n((p), __ATOMIC_ACQUIRE))
 #define gpr_atm_no_barrier_load(p) (__atomic_load_n((p), __ATOMIC_RELAXED))
 #define gpr_atm_rel_store(p, value) \
-  (__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELEASE))
+    (__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELEASE))
 #define gpr_atm_no_barrier_store(p, value) \
-  (__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELAXED))
-
-#define gpr_atm_no_barrier_fetch_add(p, delta) \
-  GPR_ATM_INC_ADD_THEN(                        \
-      __atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_RELAXED))
-#define gpr_atm_full_fetch_add(p, delta) \
-  GPR_ATM_INC_ADD_THEN(                  \
-      __atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_ACQ_REL))
-
-static __inline int gpr_atm_no_barrier_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
-  return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
-      p, &o, n, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED));
-}
-
-static __inline int gpr_atm_acq_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
-  return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
-      p, &o, n, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED));
-}
-
-static __inline int gpr_atm_rel_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
-  return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
-      p, &o, n, 0, __ATOMIC_RELEASE, __ATOMIC_RELAXED));
-}
-
-static __inline int gpr_atm_full_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
-  return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
-      p, &o, n, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED));
-}
+    (__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELAXED))
+
+#define gpr_atm_no_barrier_fetch_add(p, delta)                       \
+    GPR_ATM_INC_ADD_THEN(                                            \
+        __atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_RELAXED) \
+    )
+#define gpr_atm_full_fetch_add(p, delta)                             \
+    GPR_ATM_INC_ADD_THEN(                                            \
+        __atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_ACQ_REL) \
+    )
+
+    static __inline int gpr_atm_no_barrier_cas(gpr_atm* p, gpr_atm o, gpr_atm n)
+    {
+        return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
+            p, &o, n, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED
+        ));
+    }
+
+    static __inline int gpr_atm_acq_cas(gpr_atm* p, gpr_atm o, gpr_atm n)
+    {
+        return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
+            p, &o, n, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED
+        ));
+    }
+
+    static __inline int gpr_atm_rel_cas(gpr_atm* p, gpr_atm o, gpr_atm n)
+    {
+        return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
+            p, &o, n, 0, __ATOMIC_RELEASE, __ATOMIC_RELAXED
+        ));
+    }
+
+    static __inline int gpr_atm_full_cas(gpr_atm* p, gpr_atm o, gpr_atm n)
+    {
+        return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n(
+            p, &o, n, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED
+        ));
+    }
 
 #define gpr_atm_full_xchg(p, n) \
-  GPR_ATM_INC_CAS_THEN(__atomic_exchange_n((p), (n), __ATOMIC_ACQ_REL))
+    GPR_ATM_INC_CAS_THEN(__atomic_exchange_n((p), (n), __ATOMIC_ACQ_REL))
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_sync.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_sync.h
index bdc7a17..8eea19a 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_sync.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_gcc_sync.h
@@ -31,7 +31,10 @@ typedef intptr_t gpr_atm;
 #define GPR_ATM_INC_CAS_THEN(blah) blah
 #define GPR_ATM_INC_ADD_THEN(blah) blah
 
-#define GPR_ATM_COMPILE_BARRIER_() __asm__ __volatile__("" : : : "memory")
+#define GPR_ATM_COMPILE_BARRIER_() __asm__ __volatile__("" \
+                                                        :  \
+                                                        :  \
+                                                        : "memory")
 
 #if defined(__i386) || defined(__x86_64__)
 /* All loads are acquire loads and all stores are release stores.  */
@@ -42,33 +45,37 @@ typedef intptr_t gpr_atm;
 
 #define gpr_atm_full_barrier() (__sync_synchronize())
 
-static __inline gpr_atm gpr_atm_acq_load(const gpr_atm* p) {
-  gpr_atm value = *p;
-  GPR_ATM_LS_BARRIER_();
-  return value;
+static __inline gpr_atm gpr_atm_acq_load(const gpr_atm* p)
+{
+    gpr_atm value = *p;
+    GPR_ATM_LS_BARRIER_();
+    return value;
 }
 
-static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm* p) {
-  gpr_atm value = *p;
-  GPR_ATM_COMPILE_BARRIER_();
-  return value;
+static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm* p)
+{
+    gpr_atm value = *p;
+    GPR_ATM_COMPILE_BARRIER_();
+    return value;
 }
 
-static __inline void gpr_atm_rel_store(gpr_atm* p, gpr_atm value) {
-  GPR_ATM_LS_BARRIER_();
-  *p = value;
+static __inline void gpr_atm_rel_store(gpr_atm* p, gpr_atm value)
+{
+    GPR_ATM_LS_BARRIER_();
+    *p = value;
 }
 
-static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value) {
-  GPR_ATM_COMPILE_BARRIER_();
-  *p = value;
+static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value)
+{
+    GPR_ATM_COMPILE_BARRIER_();
+    *p = value;
 }
 
 #undef GPR_ATM_LS_BARRIER_
 #undef GPR_ATM_COMPILE_BARRIER_
 
 #define gpr_atm_no_barrier_fetch_add(p, delta) \
-  gpr_atm_full_fetch_add((p), (delta))
+    gpr_atm_full_fetch_add((p), (delta))
 #define gpr_atm_full_fetch_add(p, delta) (__sync_fetch_and_add((p), (delta)))
 
 #define gpr_atm_no_barrier_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n))
@@ -76,12 +83,14 @@ static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value) {
 #define gpr_atm_rel_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n))
 #define gpr_atm_full_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n))
 
-static __inline gpr_atm gpr_atm_full_xchg(gpr_atm* p, gpr_atm n) {
-  gpr_atm cur;
-  do {
-    cur = gpr_atm_acq_load(p);
-  } while (!gpr_atm_rel_cas(p, cur, n));
-  return cur;
+static __inline gpr_atm gpr_atm_full_xchg(gpr_atm* p, gpr_atm n)
+{
+    gpr_atm cur;
+    do
+    {
+        cur = gpr_atm_acq_load(p);
+    } while (!gpr_atm_rel_cas(p, cur, n));
+    return cur;
 }
 
 #endif /* GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_windows.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_windows.h
index 816c9a9..a69b3d2 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_windows.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/atm_windows.h
@@ -34,99 +34,109 @@ typedef intptr_t gpr_atm;
 
 #define gpr_atm_full_barrier MemoryBarrier
 
-static __inline gpr_atm gpr_atm_acq_load(const gpr_atm* p) {
-  gpr_atm result = *p;
-  gpr_atm_full_barrier();
-  return result;
+static __inline gpr_atm gpr_atm_acq_load(const gpr_atm* p)
+{
+    gpr_atm result = *p;
+    gpr_atm_full_barrier();
+    return result;
 }
 
-static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm* p) {
-  /* TODO(dklempner): Can we implement something better here? */
-  return gpr_atm_acq_load(p);
+static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm* p)
+{
+    /* TODO(dklempner): Can we implement something better here? */
+    return gpr_atm_acq_load(p);
 }
 
-static __inline void gpr_atm_rel_store(gpr_atm* p, gpr_atm value) {
-  gpr_atm_full_barrier();
-  *p = value;
+static __inline void gpr_atm_rel_store(gpr_atm* p, gpr_atm value)
+{
+    gpr_atm_full_barrier();
+    *p = value;
 }
 
-static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value) {
-  /* TODO(ctiller): Can we implement something better here? */
-  gpr_atm_rel_store(p, value);
+static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value)
+{
+    /* TODO(ctiller): Can we implement something better here? */
+    gpr_atm_rel_store(p, value);
 }
 
-static __inline int gpr_atm_no_barrier_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+static __inline int gpr_atm_no_barrier_cas(gpr_atm* p, gpr_atm o, gpr_atm n)
+{
 /** InterlockedCompareExchangePointerNoFence() not available on vista or
    windows7 */
 #ifdef GPR_ARCH_64
-  return o == (gpr_atm)InterlockedCompareExchangeAcquire64(
-                  (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o);
+    return o == (gpr_atm)InterlockedCompareExchangeAcquire64(
+                    (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o
+                );
 #else
-  return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG*)p,
-                                                         (LONG)n, (LONG)o);
+    return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG*)p, (LONG)n, (LONG)o);
 #endif
 }
 
-static __inline int gpr_atm_acq_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+static __inline int gpr_atm_acq_cas(gpr_atm* p, gpr_atm o, gpr_atm n)
+{
 #ifdef GPR_ARCH_64
-  return o == (gpr_atm)InterlockedCompareExchangeAcquire64(
-                  (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o);
+    return o == (gpr_atm)InterlockedCompareExchangeAcquire64(
+                    (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o
+                );
 #else
-  return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG*)p,
-                                                         (LONG)n, (LONG)o);
+    return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG*)p, (LONG)n, (LONG)o);
 #endif
 }
 
-static __inline int gpr_atm_rel_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+static __inline int gpr_atm_rel_cas(gpr_atm* p, gpr_atm o, gpr_atm n)
+{
 #ifdef GPR_ARCH_64
-  return o == (gpr_atm)InterlockedCompareExchangeRelease64(
-                  (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o);
+    return o == (gpr_atm)InterlockedCompareExchangeRelease64(
+                    (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o
+                );
 #else
-  return o == (gpr_atm)InterlockedCompareExchangeRelease((volatile LONG*)p,
-                                                         (LONG)n, (LONG)o);
+    return o == (gpr_atm)InterlockedCompareExchangeRelease((volatile LONG*)p, (LONG)n, (LONG)o);
 #endif
 }
 
-static __inline int gpr_atm_full_cas(gpr_atm* p, gpr_atm o, gpr_atm n) {
+static __inline int gpr_atm_full_cas(gpr_atm* p, gpr_atm o, gpr_atm n)
+{
 #ifdef GPR_ARCH_64
-  return o == (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG*)p,
-                                                    (LONGLONG)n, (LONGLONG)o);
+    return o == (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o);
 #else
-  return o == (gpr_atm)InterlockedCompareExchange((volatile LONG*)p, (LONG)n,
-                                                  (LONG)o);
+    return o == (gpr_atm)InterlockedCompareExchange((volatile LONG*)p, (LONG)n, (LONG)o);
 #endif
 }
 
-static __inline gpr_atm gpr_atm_no_barrier_fetch_add(gpr_atm* p,
-                                                     gpr_atm delta) {
-  /** Use the CAS operation to get pointer-sized fetch and add */
-  gpr_atm old;
-  do {
-    old = *p;
-  } while (!gpr_atm_no_barrier_cas(p, old, old + delta));
-  return old;
+static __inline gpr_atm gpr_atm_no_barrier_fetch_add(gpr_atm* p, gpr_atm delta)
+{
+    /** Use the CAS operation to get pointer-sized fetch and add */
+    gpr_atm old;
+    do
+    {
+        old = *p;
+    } while (!gpr_atm_no_barrier_cas(p, old, old + delta));
+    return old;
 }
 
-static __inline gpr_atm gpr_atm_full_fetch_add(gpr_atm* p, gpr_atm delta) {
-  /** Use a CAS operation to get pointer-sized fetch and add */
-  gpr_atm old;
+static __inline gpr_atm gpr_atm_full_fetch_add(gpr_atm* p, gpr_atm delta)
+{
+    /** Use a CAS operation to get pointer-sized fetch and add */
+    gpr_atm old;
 #ifdef GPR_ARCH_64
-  do {
-    old = *p;
-  } while (old != (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG*)p,
-                                                        (LONGLONG)old + delta,
-                                                        (LONGLONG)old));
+    do
+    {
+        old = *p;
+    } while (old != (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG*)p, (LONGLONG)old + delta, (LONGLONG)old));
 #else
-  do {
-    old = *p;
-  } while (old != (gpr_atm)InterlockedCompareExchange(
-                      (volatile LONG*)p, (LONG)old + delta, (LONG)old));
+    do
+    {
+        old = *p;
+    } while (old != (gpr_atm)InterlockedCompareExchange(
+                        (volatile LONG*)p, (LONG)old + delta, (LONG)old
+                    ));
 #endif
-  return old;
+    return old;
 }
 
-static __inline gpr_atm gpr_atm_full_xchg(gpr_atm* p, gpr_atm n) {
-  return (gpr_atm)InterlockedExchangePointer((PVOID*)p, (PVOID)n);
+static __inline gpr_atm gpr_atm_full_xchg(gpr_atm* p, gpr_atm n)
+{
+    return (gpr_atm)InterlockedExchangePointer((PVOID*)p, (PVOID)n);
 }
 
 #endif /* GPR_WINDOWS */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer.h
index eeec56c..bc06f6e 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer.h
@@ -26,75 +26,74 @@
 #include <grpc/impl/codegen/grpc_types.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** Returns a RAW byte buffer instance over the given slices (up to \a nslices).
- *
- * Increases the reference count for all \a slices processed. The user is
- * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/
-GRPCAPI grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slices,
-                                                      size_t nslices);
-
-/** Returns a *compressed* RAW byte buffer instance over the given slices (up to
- * \a nslices). The \a compression argument defines the compression algorithm
- * used to generate the data in \a slices.
- *
- * Increases the reference count for all \a slices processed. The user is
- * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/
-GRPCAPI grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(
-    grpc_slice* slices, size_t nslices, grpc_compression_algorithm compression);
-
-/** Copies input byte buffer \a bb.
- *
- * Increases the reference count of all the source slices. The user is
- * responsible for calling grpc_byte_buffer_destroy over the returned copy. */
-GRPCAPI grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb);
-
-/** Returns the size of the given byte buffer, in bytes. */
-GRPCAPI size_t grpc_byte_buffer_length(grpc_byte_buffer* bb);
-
-/** Destroys \a byte_buffer deallocating all its memory. */
-GRPCAPI void grpc_byte_buffer_destroy(grpc_byte_buffer* bb);
-
-/** Reader for byte buffers. Iterates over slices in the byte buffer */
-struct grpc_byte_buffer_reader;
-typedef struct grpc_byte_buffer_reader grpc_byte_buffer_reader;
-
-/** Initialize \a reader to read over \a buffer.
- * Returns 1 upon success, 0 otherwise. */
-GRPCAPI int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
-                                         grpc_byte_buffer* buffer);
-
-/** Cleanup and destroy \a reader */
-GRPCAPI void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader);
-
-/** Updates \a slice with the next piece of data from from \a reader and returns
- * 1. Returns 0 at the end of the stream. Caller is responsible for calling
- * grpc_slice_unref on the result. */
-GRPCAPI int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
-                                         grpc_slice* slice);
-
-/** EXPERIMENTAL API - This function may be removed and changed, in the future.
- *
- * Updates \a slice with the next piece of data from from \a reader and returns
- * 1. Returns 0 at the end of the stream. Caller is responsible for making sure
- * the slice pointer remains valid when accessed.
- *
- * NOTE: Do not use this function unless the caller can guarantee that the
- *       underlying grpc_byte_buffer outlasts the use of the slice. This is only
- *       safe when the underlying grpc_byte_buffer remains immutable while slice
- *       is being accessed. */
-GRPCAPI int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader,
-                                         grpc_slice** slice);
-
-/** Merge all data from \a reader into single slice */
-GRPCAPI grpc_slice
-grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader* reader);
-
-/** Returns a RAW byte buffer instance from the output of \a reader. */
-GRPCAPI grpc_byte_buffer* grpc_raw_byte_buffer_from_reader(
-    grpc_byte_buffer_reader* reader);
+    /** Returns a RAW byte buffer instance over the given slices (up to \a nslices).
+     *
+     * Increases the reference count for all \a slices processed. The user is
+     * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/
+    GRPCAPI grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slices, size_t nslices);
+
+    /** Returns a *compressed* RAW byte buffer instance over the given slices (up to
+     * \a nslices). The \a compression argument defines the compression algorithm
+     * used to generate the data in \a slices.
+     *
+     * Increases the reference count for all \a slices processed. The user is
+     * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/
+    GRPCAPI grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(
+        grpc_slice* slices, size_t nslices, grpc_compression_algorithm compression
+    );
+
+    /** Copies input byte buffer \a bb.
+     *
+     * Increases the reference count of all the source slices. The user is
+     * responsible for calling grpc_byte_buffer_destroy over the returned copy. */
+    GRPCAPI grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb);
+
+    /** Returns the size of the given byte buffer, in bytes. */
+    GRPCAPI size_t grpc_byte_buffer_length(grpc_byte_buffer* bb);
+
+    /** Destroys \a byte_buffer deallocating all its memory. */
+    GRPCAPI void grpc_byte_buffer_destroy(grpc_byte_buffer* bb);
+
+    /** Reader for byte buffers. Iterates over slices in the byte buffer */
+    struct grpc_byte_buffer_reader;
+    typedef struct grpc_byte_buffer_reader grpc_byte_buffer_reader;
+
+    /** Initialize \a reader to read over \a buffer.
+     * Returns 1 upon success, 0 otherwise. */
+    GRPCAPI int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader, grpc_byte_buffer* buffer);
+
+    /** Cleanup and destroy \a reader */
+    GRPCAPI void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader);
+
+    /** Updates \a slice with the next piece of data from from \a reader and returns
+     * 1. Returns 0 at the end of the stream. Caller is responsible for calling
+     * grpc_slice_unref on the result. */
+    GRPCAPI int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader, grpc_slice* slice);
+
+    /** EXPERIMENTAL API - This function may be removed and changed, in the future.
+     *
+     * Updates \a slice with the next piece of data from from \a reader and returns
+     * 1. Returns 0 at the end of the stream. Caller is responsible for making sure
+     * the slice pointer remains valid when accessed.
+     *
+     * NOTE: Do not use this function unless the caller can guarantee that the
+     *       underlying grpc_byte_buffer outlasts the use of the slice. This is only
+     *       safe when the underlying grpc_byte_buffer remains immutable while slice
+     *       is being accessed. */
+    GRPCAPI int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader, grpc_slice** slice);
+
+    /** Merge all data from \a reader into single slice */
+    GRPCAPI grpc_slice
+        grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader* reader);
+
+    /** Returns a RAW byte buffer instance from the output of \a reader. */
+    GRPCAPI grpc_byte_buffer* grpc_raw_byte_buffer_from_reader(
+        grpc_byte_buffer_reader* reader
+    );
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer_reader.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer_reader.h
index 35b8ee7..ec6691c 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer_reader.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/byte_buffer_reader.h
@@ -22,20 +22,23 @@
 // IWYU pragma: private, include <grpc/byte_buffer_reader.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-struct grpc_byte_buffer;
+    struct grpc_byte_buffer;
 
-struct grpc_byte_buffer_reader {
-  struct grpc_byte_buffer* buffer_in;
-  struct grpc_byte_buffer* buffer_out;
-  /** Different current objects correspond to different types of byte buffers */
-  union grpc_byte_buffer_reader_current {
-    /** Index into a slice buffer's array of slices */
-    unsigned index;
-  } current;
-};
+    struct grpc_byte_buffer_reader
+    {
+        struct grpc_byte_buffer* buffer_in;
+        struct grpc_byte_buffer* buffer_out;
+        /** Different current objects correspond to different types of byte buffers */
+        union grpc_byte_buffer_reader_current
+        {
+            /** Index into a slice buffer's array of slices */
+            unsigned index;
+        } current;
+    };
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/compression_types.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/compression_types.h
index c187030..4a035e6 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/compression_types.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/compression_types.h
@@ -25,13 +25,14 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 /** To be used as initial metadata key for the request of a concrete compression
  * algorithm */
 #define GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY \
-  "grpc-internal-encoding-request"
+    "grpc-internal-encoding-request"
 
 /** To be used in channel arguments.
  *
@@ -40,7 +41,7 @@ extern "C" {
 /** Default compression algorithm for the channel.
  * Its value is an int from the \a grpc_compression_algorithm enum. */
 #define GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM \
-  "grpc.default_compression_algorithm"
+    "grpc.default_compression_algorithm"
 /** Default compression level for the channel.
  * Its value is an int from the \a grpc_compression_level enum. */
 #define GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL "grpc.default_compression_level"
@@ -52,55 +53,60 @@ extern "C" {
  * supported. It's not possible to disable GRPC_COMPRESS_NONE (the attempt will
  * be ignored). */
 #define GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET \
-  "grpc.compression_enabled_algorithms_bitset"
-/** \} */
+    "grpc.compression_enabled_algorithms_bitset"
+    /** \} */
 
-/** The various compression algorithms supported by gRPC (not sorted by
- * compression level) */
-typedef enum {
-  GRPC_COMPRESS_NONE = 0,
-  GRPC_COMPRESS_DEFLATE,
-  GRPC_COMPRESS_GZIP,
-  /* TODO(ctiller): snappy */
-  GRPC_COMPRESS_ALGORITHMS_COUNT
-} grpc_compression_algorithm;
+    /** The various compression algorithms supported by gRPC (not sorted by
+     * compression level) */
+    typedef enum
+    {
+        GRPC_COMPRESS_NONE = 0,
+        GRPC_COMPRESS_DEFLATE,
+        GRPC_COMPRESS_GZIP,
+        /* TODO(ctiller): snappy */
+        GRPC_COMPRESS_ALGORITHMS_COUNT
+    } grpc_compression_algorithm;
 
-/** Compression levels allow a party with knowledge of its peer's accepted
- * encodings to request compression in an abstract way. The level-algorithm
- * mapping is performed internally and depends on the peer's supported
- * compression algorithms. */
-typedef enum {
-  GRPC_COMPRESS_LEVEL_NONE = 0,
-  GRPC_COMPRESS_LEVEL_LOW,
-  GRPC_COMPRESS_LEVEL_MED,
-  GRPC_COMPRESS_LEVEL_HIGH,
-  GRPC_COMPRESS_LEVEL_COUNT
-} grpc_compression_level;
+    /** Compression levels allow a party with knowledge of its peer's accepted
+     * encodings to request compression in an abstract way. The level-algorithm
+     * mapping is performed internally and depends on the peer's supported
+     * compression algorithms. */
+    typedef enum
+    {
+        GRPC_COMPRESS_LEVEL_NONE = 0,
+        GRPC_COMPRESS_LEVEL_LOW,
+        GRPC_COMPRESS_LEVEL_MED,
+        GRPC_COMPRESS_LEVEL_HIGH,
+        GRPC_COMPRESS_LEVEL_COUNT
+    } grpc_compression_level;
 
-typedef struct grpc_compression_options {
-  /** All algs are enabled by default. This option corresponds to the channel
-   * argument key behind \a GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET
-   */
-  uint32_t enabled_algorithms_bitset;
+    typedef struct grpc_compression_options
+    {
+        /** All algs are enabled by default. This option corresponds to the channel
+         * argument key behind \a GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET
+         */
+        uint32_t enabled_algorithms_bitset;
 
-  /** The default compression level. It'll be used in the absence of call
-   * specific settings. This option corresponds to the channel
-   * argument key behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL. If present,
-   * takes precedence over \a default_algorithm.
-   * TODO(dgq): currently only available for server channels. */
-  struct grpc_compression_options_default_level {
-    int is_set;
-    grpc_compression_level level;
-  } default_level;
+        /** The default compression level. It'll be used in the absence of call
+         * specific settings. This option corresponds to the channel
+         * argument key behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL. If present,
+         * takes precedence over \a default_algorithm.
+         * TODO(dgq): currently only available for server channels. */
+        struct grpc_compression_options_default_level
+        {
+            int is_set;
+            grpc_compression_level level;
+        } default_level;
 
-  /** The default message compression algorithm. It'll be used in the absence of
-   * call specific settings. This option corresponds to the channel argument key
-   * behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM. */
-  struct grpc_compression_options_default_algorithm {
-    int is_set;
-    grpc_compression_algorithm algorithm;
-  } default_algorithm;
-} grpc_compression_options;
+        /** The default message compression algorithm. It'll be used in the absence of
+         * call specific settings. This option corresponds to the channel argument key
+         * behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM. */
+        struct grpc_compression_options_default_algorithm
+        {
+            int is_set;
+            grpc_compression_algorithm algorithm;
+        } default_algorithm;
+    } grpc_compression_options;
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/connectivity_state.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/connectivity_state.h
index 218afd7..6e9b0c5 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/connectivity_state.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/connectivity_state.h
@@ -23,22 +23,24 @@
 // IWYU pragma: friend "src/.*"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** Connectivity state of a channel. */
-typedef enum {
-  /** channel is idle */
-  GRPC_CHANNEL_IDLE,
-  /** channel is connecting */
-  GRPC_CHANNEL_CONNECTING,
-  /** channel is ready for work */
-  GRPC_CHANNEL_READY,
-  /** channel has seen a failure but expects to recover */
-  GRPC_CHANNEL_TRANSIENT_FAILURE,
-  /** channel has seen a failure that it cannot recover from */
-  GRPC_CHANNEL_SHUTDOWN
-} grpc_connectivity_state;
+    /** Connectivity state of a channel. */
+    typedef enum
+    {
+        /** channel is idle */
+        GRPC_CHANNEL_IDLE,
+        /** channel is connecting */
+        GRPC_CHANNEL_CONNECTING,
+        /** channel is ready for work */
+        GRPC_CHANNEL_READY,
+        /** channel has seen a failure but expects to recover */
+        GRPC_CHANNEL_TRANSIENT_FAILURE,
+        /** channel has seen a failure that it cannot recover from */
+        GRPC_CHANNEL_SHUTDOWN
+    } grpc_connectivity_state;
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_types.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_types.h
index 253ff3a..2307756 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_types.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/gpr_types.h
@@ -27,33 +27,36 @@
 #include <stddef.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** The clocks we support. */
-typedef enum {
-  /** Monotonic clock. Epoch undefined. Always moves forwards. */
-  GPR_CLOCK_MONOTONIC = 0,
-  /** Realtime clock. May jump forwards or backwards. Settable by
-     the system administrator. Has its epoch at 0:00:00 UTC 1 Jan 1970. */
-  GPR_CLOCK_REALTIME,
-  /** CPU cycle time obtained by rdtsc instruction on x86 platforms. Epoch
-     undefined. Degrades to GPR_CLOCK_REALTIME on other platforms. */
-  GPR_CLOCK_PRECISE,
-  /** Unmeasurable clock type: no base, created by taking the difference
-     between two times */
-  GPR_TIMESPAN
-} gpr_clock_type;
-
-/** Analogous to struct timespec. On some machines, absolute times may be in
- * local time. */
-typedef struct gpr_timespec {
-  int64_t tv_sec;
-  int32_t tv_nsec;
-  /** Against which clock was this time measured? (or GPR_TIMESPAN if
-      this is a relative time measure) */
-  gpr_clock_type clock_type;
-} gpr_timespec;
+    /** The clocks we support. */
+    typedef enum
+    {
+        /** Monotonic clock. Epoch undefined. Always moves forwards. */
+        GPR_CLOCK_MONOTONIC = 0,
+        /** Realtime clock. May jump forwards or backwards. Settable by
+           the system administrator. Has its epoch at 0:00:00 UTC 1 Jan 1970. */
+        GPR_CLOCK_REALTIME,
+        /** CPU cycle time obtained by rdtsc instruction on x86 platforms. Epoch
+           undefined. Degrades to GPR_CLOCK_REALTIME on other platforms. */
+        GPR_CLOCK_PRECISE,
+        /** Unmeasurable clock type: no base, created by taking the difference
+           between two times */
+        GPR_TIMESPAN
+    } gpr_clock_type;
+
+    /** Analogous to struct timespec. On some machines, absolute times may be in
+     * local time. */
+    typedef struct gpr_timespec
+    {
+        int64_t tv_sec;
+        int32_t tv_nsec;
+        /** Against which clock was this time measured? (or GPR_TIMESPAN if
+            this is a relative time measure) */
+        gpr_clock_type clock_type;
+    } gpr_timespec;
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/grpc_types.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/grpc_types.h
index 2dfdbf3..855eedc 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/grpc_types.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/grpc_types.h
@@ -32,107 +32,119 @@
 #include <grpc/impl/codegen/status.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-typedef enum {
-  GRPC_BB_RAW
-  /** Future types may include GRPC_BB_PROTOBUF, etc. */
-} grpc_byte_buffer_type;
-
-typedef struct grpc_byte_buffer {
-  void* reserved;
-  grpc_byte_buffer_type type;
-  union grpc_byte_buffer_data {
-    struct /* internal */ {
-      void* reserved[8];
-    } reserved;
-    struct grpc_compressed_buffer {
-      grpc_compression_algorithm compression;
-      grpc_slice_buffer slice_buffer;
-    } raw;
-  } data;
-} grpc_byte_buffer;
-
-/** Completion Queues enable notification of the completion of
- * asynchronous actions. */
-typedef struct grpc_completion_queue grpc_completion_queue;
-
-/** The Channel interface allows creation of Call objects. */
-typedef struct grpc_channel grpc_channel;
-
-/** A server listens to some port and responds to request calls */
-typedef struct grpc_server grpc_server;
-
-/** A Call represents an RPC. When created, it is in a configuration state
-    allowing properties to be set until it is invoked. After invoke, the Call
-    can have messages written to it and read from it. */
-typedef struct grpc_call grpc_call;
-
-/** The Socket Mutator interface allows changes on socket options */
-typedef struct grpc_socket_mutator grpc_socket_mutator;
-
-/** The Socket Factory interface creates and binds sockets */
-typedef struct grpc_socket_factory grpc_socket_factory;
-
-/** Type specifier for grpc_arg */
-typedef enum {
-  GRPC_ARG_STRING,
-  GRPC_ARG_INTEGER,
-  GRPC_ARG_POINTER
-} grpc_arg_type;
-
-typedef struct grpc_arg_pointer_vtable {
-  void* (*copy)(void* p);
-  void (*destroy)(void* p);
-  int (*cmp)(void* p, void* q);
-} grpc_arg_pointer_vtable;
-
-/** A single argument... each argument has a key and a value
-
-    A note on naming keys:
-      Keys are namespaced into groups, usually grouped by library, and are
-      keys for module XYZ are named XYZ.key1, XYZ.key2, etc. Module names must
-      be restricted to the regex [A-Za-z][_A-Za-z0-9]{,15}.
-      Key names must be restricted to the regex [A-Za-z][_A-Za-z0-9]{,47}.
-
-    GRPC core library keys are prefixed by grpc.
-
-    Library authors are strongly encouraged to \#define symbolic constants for
-    their keys so that it's possible to change them in the future. */
-typedef struct {
-  grpc_arg_type type;
-  char* key;
-  union grpc_arg_value {
-    char* string;
-    int integer;
-    struct grpc_arg_pointer {
-      void* p;
-      const grpc_arg_pointer_vtable* vtable;
-    } pointer;
-  } value;
-} grpc_arg;
-
-/** An array of arguments that can be passed around.
-
-    Used to set optional channel-level configuration.
-    These configuration options are modelled as key-value pairs as defined
-    by grpc_arg; keys are strings to allow easy backwards-compatible extension
-    by arbitrary parties. All evaluation is performed at channel creation
-    time (i.e. the keys and values in this structure need only live through the
-    creation invocation).
-
-    However, if one of the args has grpc_arg_type==GRPC_ARG_POINTER, then the
-    grpc_arg_pointer_vtable must live until the channel args are done being
-    used by core (i.e. when the object for use with which they were passed
-    is destroyed).
-
-    See the description of the \ref grpc_arg_keys "available args" for more
-    details. */
-typedef struct {
-  size_t num_args;
-  grpc_arg* args;
-} grpc_channel_args;
+    typedef enum
+    {
+        GRPC_BB_RAW
+        /** Future types may include GRPC_BB_PROTOBUF, etc. */
+    } grpc_byte_buffer_type;
+
+    typedef struct grpc_byte_buffer
+    {
+        void* reserved;
+        grpc_byte_buffer_type type;
+        union grpc_byte_buffer_data
+        {
+            struct /* internal */
+            {
+                void* reserved[8];
+            } reserved;
+            struct grpc_compressed_buffer
+            {
+                grpc_compression_algorithm compression;
+                grpc_slice_buffer slice_buffer;
+            } raw;
+        } data;
+    } grpc_byte_buffer;
+
+    /** Completion Queues enable notification of the completion of
+     * asynchronous actions. */
+    typedef struct grpc_completion_queue grpc_completion_queue;
+
+    /** The Channel interface allows creation of Call objects. */
+    typedef struct grpc_channel grpc_channel;
+
+    /** A server listens to some port and responds to request calls */
+    typedef struct grpc_server grpc_server;
+
+    /** A Call represents an RPC. When created, it is in a configuration state
+        allowing properties to be set until it is invoked. After invoke, the Call
+        can have messages written to it and read from it. */
+    typedef struct grpc_call grpc_call;
+
+    /** The Socket Mutator interface allows changes on socket options */
+    typedef struct grpc_socket_mutator grpc_socket_mutator;
+
+    /** The Socket Factory interface creates and binds sockets */
+    typedef struct grpc_socket_factory grpc_socket_factory;
+
+    /** Type specifier for grpc_arg */
+    typedef enum
+    {
+        GRPC_ARG_STRING,
+        GRPC_ARG_INTEGER,
+        GRPC_ARG_POINTER
+    } grpc_arg_type;
+
+    typedef struct grpc_arg_pointer_vtable
+    {
+        void* (*copy)(void* p);
+        void (*destroy)(void* p);
+        int (*cmp)(void* p, void* q);
+    } grpc_arg_pointer_vtable;
+
+    /** A single argument... each argument has a key and a value
+
+        A note on naming keys:
+          Keys are namespaced into groups, usually grouped by library, and are
+          keys for module XYZ are named XYZ.key1, XYZ.key2, etc. Module names must
+          be restricted to the regex [A-Za-z][_A-Za-z0-9]{,15}.
+          Key names must be restricted to the regex [A-Za-z][_A-Za-z0-9]{,47}.
+
+        GRPC core library keys are prefixed by grpc.
+
+        Library authors are strongly encouraged to \#define symbolic constants for
+        their keys so that it's possible to change them in the future. */
+    typedef struct
+    {
+        grpc_arg_type type;
+        char* key;
+        union grpc_arg_value
+        {
+            char* string;
+            int integer;
+            struct grpc_arg_pointer
+            {
+                void* p;
+                const grpc_arg_pointer_vtable* vtable;
+            } pointer;
+        } value;
+    } grpc_arg;
+
+    /** An array of arguments that can be passed around.
+
+        Used to set optional channel-level configuration.
+        These configuration options are modelled as key-value pairs as defined
+        by grpc_arg; keys are strings to allow easy backwards-compatible extension
+        by arbitrary parties. All evaluation is performed at channel creation
+        time (i.e. the keys and values in this structure need only live through the
+        creation invocation).
+
+        However, if one of the args has grpc_arg_type==GRPC_ARG_POINTER, then the
+        grpc_arg_pointer_vtable must live until the channel args are done being
+        used by core (i.e. when the object for use with which they were passed
+        is destroyed).
+
+        See the description of the \ref grpc_arg_keys "available args" for more
+        details. */
+    typedef struct
+    {
+        size_t num_args;
+        grpc_arg* args;
+    } grpc_channel_args;
 
 /** \defgroup grpc_arg_keys
  * Channel argument keys.
@@ -178,13 +190,13 @@ typedef struct {
    Defaults to 1. If disabled, decompression will not be performed and the
    application will see the compressed message in the byte buffer. */
 #define GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION \
-  "grpc.per_message_decompression"
+    "grpc.per_message_decompression"
 /** Enable/disable support for deadline checking. Defaults to 1, unless
     GRPC_ARG_MINIMAL_STACK is enabled, in which case it defaults to 0 */
 #define GRPC_ARG_ENABLE_DEADLINE_CHECKS "grpc.enable_deadline_checking"
 /** Initial stream ID for http2 transports. Int valued. */
 #define GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER \
-  "grpc.http2.initial_sequence_number"
+    "grpc.http2.initial_sequence_number"
 /** Amount to read ahead on individual streams. Defaults to 64kb, larger
     values can help throughput on high-latency connections.
     NOTE: at some point we'd like to auto-tune this, and this parameter
@@ -192,10 +204,10 @@ typedef struct {
 #define GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES "grpc.http2.lookahead_bytes"
 /** How much memory to use for hpack decoding. Int valued, bytes. */
 #define GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER \
-  "grpc.http2.hpack_table_size.decoder"
+    "grpc.http2.hpack_table_size.decoder"
 /** How much memory to use for hpack encoding. Int valued, bytes. */
 #define GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER \
-  "grpc.http2.hpack_table_size.encoder"
+    "grpc.http2.hpack_table_size.encoder"
 /** How big a frame are we willing to receive via HTTP2.
     Min 16384, max 16777215. Larger values give lower CPU usage for large
     messages, but more head of line blocking for small messages. */
@@ -212,19 +224,19 @@ typedef struct {
     there is receive-side data activity, making this arg unuseful for BDP pings
     too.  */
 #define GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS \
-  "grpc.http2.min_time_between_pings_ms"
+    "grpc.http2.min_time_between_pings_ms"
 /** Minimum allowed time between a server receiving successive ping frames
    without sending any data/header frame. Int valued, milliseconds
  */
 #define GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS \
-  "grpc.http2.min_ping_interval_without_data_ms"
+    "grpc.http2.min_ping_interval_without_data_ms"
 /** Channel arg to override the http2 :scheme header */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a
    data/header frame? (0 indicates that an infinite number of
    pings can be sent without sending a data frame or header frame) */
 #define GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA \
-  "grpc.http2.max_pings_without_data"
+    "grpc.http2.max_pings_without_data"
 /** How many misbehaving pings the server can bear before sending goaway and
     closing the transport? (0 indicates that the server can bear an infinite
     number of misbehaving pings) */
@@ -245,7 +257,7 @@ typedef struct {
 /** Is it permissible to send keepalive pings from the client without any
    outstanding streams. Int valued, 0(false)/1(true). */
 #define GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS \
-  "grpc.keepalive_permit_without_calls"
+    "grpc.keepalive_permit_without_calls"
 /** Default authority to pass if none specified on call construction. A string.
  * */
 #define GRPC_ARG_DEFAULT_AUTHORITY "grpc.default_authority"
@@ -261,10 +273,10 @@ typedef struct {
 #define GRPC_ARG_MAX_RECONNECT_BACKOFF_MS "grpc.max_reconnect_backoff_ms"
 /** The time between the first and second connection attempts, in ms */
 #define GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS \
-  "grpc.initial_reconnect_backoff_ms"
+    "grpc.initial_reconnect_backoff_ms"
 /** Minimum amount of time between DNS resolutions, in ms */
 #define GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS \
-  "grpc.dns_min_time_between_resolutions_ms"
+    "grpc.dns_min_time_between_resolutions_ms"
 /** The timeout used on servers for finishing handshaking on an incoming
     connection.  Defaults to 120 seconds. */
 #define GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS "grpc.server_handshake_timeout_ms"
@@ -304,7 +316,7 @@ typedef struct {
 #define GRPC_ARG_SERVICE_CONFIG "grpc.service_config"
 /** Disable looking up the service config via the name resolver. */
 #define GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION \
-  "grpc.service_config_disable_resolution"
+    "grpc.service_config_disable_resolution"
 /** LB policy name. */
 #define GRPC_ARG_LB_POLICY_NAME "grpc.lb_policy_name"
 /** The grpc_socket_mutator instance that set the socket options. A pointer. */
@@ -316,7 +328,7 @@ typedef struct {
  * from the buffer. The unit for this knob is bytes. Setting it to zero causes
  * channel tracing to be disabled. */
 #define GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE \
-  "grpc.max_channel_trace_event_memory_per_node"
+    "grpc.max_channel_trace_event_memory_per_node"
 /** If non-zero, gRPC library will track stats and information at at per channel
  * level. Disabling channelz naturally disables channel tracing. The default
  * is for channelz to be enabled. */
@@ -324,7 +336,7 @@ typedef struct {
 /** If non-zero, Cronet transport will coalesce packets to fewer frames
  * when possible. */
 #define GRPC_ARG_USE_CRONET_PACKET_COALESCING \
-  "grpc.use_cronet_packet_coalescing"
+    "grpc.use_cronet_packet_coalescing"
 /** Channel arg (integer) setting how large a slice to try and read from the
    wire each time recvmsg (or equivalent) is called **/
 #define GRPC_ARG_TCP_READ_CHUNK_SIZE "grpc.experimental.tcp_read_chunk_size"
@@ -333,23 +345,23 @@ typedef struct {
  * channel arg is unspecified. */
 #define GRPC_TCP_DEFAULT_READ_SLICE_SIZE 8192
 #define GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE \
-  "grpc.experimental.tcp_min_read_chunk_size"
+    "grpc.experimental.tcp_min_read_chunk_size"
 #define GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE \
-  "grpc.experimental.tcp_max_read_chunk_size"
+    "grpc.experimental.tcp_max_read_chunk_size"
 /* TCP TX Zerocopy enable state: zero is disabled, non-zero is enabled. By
    default, it is disabled. */
 #define GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED \
-  "grpc.experimental.tcp_tx_zerocopy_enabled"
+    "grpc.experimental.tcp_tx_zerocopy_enabled"
 /* TCP TX Zerocopy send threshold: only zerocopy if >= this many bytes sent. By
    default, this is set to 16KB. */
 #define GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD \
-  "grpc.experimental.tcp_tx_zerocopy_send_bytes_threshold"
+    "grpc.experimental.tcp_tx_zerocopy_send_bytes_threshold"
 /* TCP TX Zerocopy max simultaneous sends: limit for maximum number of pending
    calls to tcp_write() using zerocopy. A tcp_write() is considered pending
    until the kernel performs the zerocopy-done callback for all sendmsg() calls
    issued by the tcp_write(). By default, this is set to 4. */
 #define GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS \
-  "grpc.experimental.tcp_tx_zerocopy_max_simultaneous_sends"
+    "grpc.experimental.tcp_tx_zerocopy_max_simultaneous_sends"
 /* Timeout in milliseconds to use for calls to the grpclb load balancer.
    If 0 or unset, the balancer calls will have no deadline. */
 #define GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS "grpc.grpclb_call_timeout_ms"
@@ -363,7 +375,7 @@ typedef struct {
    (b) break use of CSDS, and there may be additional side effects in
    the future. */
 #define GRPC_ARG_TEST_ONLY_DO_NOT_USE_IN_PROD_XDS_BOOTSTRAP_CONFIG \
-  "grpc.TEST_ONLY_DO_NOT_USE_IN_PROD.xds_bootstrap_config"
+    "grpc.TEST_ONLY_DO_NOT_USE_IN_PROD.xds_bootstrap_config"
 /* Timeout in milliseconds to wait for the serverlist from the grpclb load
    balancer before using fallback backend addresses from the resolver.
    If 0, enter fallback mode immediately. Default value is 10000. */
@@ -372,10 +384,10 @@ typedef struct {
    complete its initial connection attempt before the priority LB policy fails
    over to the next priority. Default value is 10 seconds. */
 #define GRPC_ARG_PRIORITY_FAILOVER_TIMEOUT_MS \
-  "grpc.priority_failover_timeout_ms"
+    "grpc.priority_failover_timeout_ms"
 /** If non-zero, grpc server's cronet compression workaround will be enabled */
 #define GRPC_ARG_WORKAROUND_CRONET_COMPRESSION \
-  "grpc.workaround.cronet_compression"
+    "grpc.workaround.cronet_compression"
 /** String defining the optimization target for a channel.
     Can be: "latency"    - attempt to minimize latency at the cost of throughput
             "blend"      - try to balance latency and throughput
@@ -410,7 +422,7 @@ typedef struct {
 #define GRPC_ARG_MOBILE_LOG_CONTEXT "grpc.mobile_log_context"
 /** If non-zero, client authority filter is disabled for the channel */
 #define GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER \
-  "grpc.disable_client_authority_filter"
+    "grpc.disable_client_authority_filter"
 /** If set to zero, disables use of http proxies. Enabled by default. */
 #define GRPC_ARG_ENABLE_HTTP_PROXY "grpc.enable_http_proxy"
 /** Channel arg to set http proxy per channel. If set, the channel arg
@@ -448,55 +460,56 @@ typedef struct {
 /** Channel argument for grpc_authorization_policy_provider. If present, enables
     gRPC authorization check. */
 #define GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER \
-  "grpc.authorization_policy_provider"
+    "grpc.authorization_policy_provider"
 /** EXPERIMENTAL. Updates to a server's configuration from a config fetcher (for
  * example, listener updates from xDS) cause all older connections to be
  * gracefully shut down (i.e., "drained") with a grace period configured by this
  * channel arg. Int valued, milliseconds. Defaults to 10 minutes.*/
 #define GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS \
-  "grpc.experimental.server_config_change_drain_grace_time_ms"
-/** \} */
-
-/** Result of a grpc call. If the caller satisfies the prerequisites of a
-    particular operation, the grpc_call_error returned will be GRPC_CALL_OK.
-    Receiving any other value listed here is an indication of a bug in the
-    caller. */
-typedef enum grpc_call_error {
-  /** everything went ok */
-  GRPC_CALL_OK = 0,
-  /** something failed, we don't know what */
-  GRPC_CALL_ERROR,
-  /** this method is not available on the server */
-  GRPC_CALL_ERROR_NOT_ON_SERVER,
-  /** this method is not available on the client */
-  GRPC_CALL_ERROR_NOT_ON_CLIENT,
-  /** this method must be called before server_accept */
-  GRPC_CALL_ERROR_ALREADY_ACCEPTED,
-  /** this method must be called before invoke */
-  GRPC_CALL_ERROR_ALREADY_INVOKED,
-  /** this method must be called after invoke */
-  GRPC_CALL_ERROR_NOT_INVOKED,
-  /** this call is already finished
-      (writes_done or write_status has already been called) */
-  GRPC_CALL_ERROR_ALREADY_FINISHED,
-  /** there is already an outstanding read/write operation on the call */
-  GRPC_CALL_ERROR_TOO_MANY_OPERATIONS,
-  /** the flags value was illegal for this call */
-  GRPC_CALL_ERROR_INVALID_FLAGS,
-  /** invalid metadata was passed to this call */
-  GRPC_CALL_ERROR_INVALID_METADATA,
-  /** invalid message was passed to this call */
-  GRPC_CALL_ERROR_INVALID_MESSAGE,
-  /** completion queue for notification has not been registered
-   * with the server */
-  GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE,
-  /** this batch of operations leads to more operations than allowed */
-  GRPC_CALL_ERROR_BATCH_TOO_BIG,
-  /** payload type requested is not the type registered */
-  GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH,
-  /** completion queue has been shutdown */
-  GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN
-} grpc_call_error;
+    "grpc.experimental.server_config_change_drain_grace_time_ms"
+    /** \} */
+
+    /** Result of a grpc call. If the caller satisfies the prerequisites of a
+        particular operation, the grpc_call_error returned will be GRPC_CALL_OK.
+        Receiving any other value listed here is an indication of a bug in the
+        caller. */
+    typedef enum grpc_call_error
+    {
+        /** everything went ok */
+        GRPC_CALL_OK = 0,
+        /** something failed, we don't know what */
+        GRPC_CALL_ERROR,
+        /** this method is not available on the server */
+        GRPC_CALL_ERROR_NOT_ON_SERVER,
+        /** this method is not available on the client */
+        GRPC_CALL_ERROR_NOT_ON_CLIENT,
+        /** this method must be called before server_accept */
+        GRPC_CALL_ERROR_ALREADY_ACCEPTED,
+        /** this method must be called before invoke */
+        GRPC_CALL_ERROR_ALREADY_INVOKED,
+        /** this method must be called after invoke */
+        GRPC_CALL_ERROR_NOT_INVOKED,
+        /** this call is already finished
+            (writes_done or write_status has already been called) */
+        GRPC_CALL_ERROR_ALREADY_FINISHED,
+        /** there is already an outstanding read/write operation on the call */
+        GRPC_CALL_ERROR_TOO_MANY_OPERATIONS,
+        /** the flags value was illegal for this call */
+        GRPC_CALL_ERROR_INVALID_FLAGS,
+        /** invalid metadata was passed to this call */
+        GRPC_CALL_ERROR_INVALID_METADATA,
+        /** invalid message was passed to this call */
+        GRPC_CALL_ERROR_INVALID_MESSAGE,
+        /** completion queue for notification has not been registered
+         * with the server */
+        GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE,
+        /** this batch of operations leads to more operations than allowed */
+        GRPC_CALL_ERROR_BATCH_TOO_BIG,
+        /** payload type requested is not the type registered */
+        GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH,
+        /** completion queue has been shutdown */
+        GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN
+    } grpc_call_error;
 
 /** Default send/receive message size limits in bytes. -1 for unlimited. */
 /** TODO(roth) Make this match the default receive limit after next release */
@@ -515,7 +528,7 @@ typedef enum grpc_call_error {
 #define GRPC_WRITE_THROUGH (0x00000004u)
 /** Mask of all valid flags. */
 #define GRPC_WRITE_USED_MASK \
-  (GRPC_WRITE_BUFFER_HINT | GRPC_WRITE_NO_COMPRESS | GRPC_WRITE_THROUGH)
+    (GRPC_WRITE_BUFFER_HINT | GRPC_WRITE_NO_COMPRESS | GRPC_WRITE_THROUGH)
 
 /** Initial metadata flags */
 /** These flags are to be passed to the `grpc_op::flags` field */
@@ -526,284 +539,307 @@ typedef enum grpc_call_error {
 #define GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET (0x00000080u)
 
 /** Mask of all valid flags */
-#define GRPC_INITIAL_METADATA_USED_MASK                  \
-  (GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET | \
-   GRPC_INITIAL_METADATA_WAIT_FOR_READY | GRPC_WRITE_THROUGH)
-
-/** A single metadata element */
-typedef struct grpc_metadata {
-  /** the key, value values are expected to line up with grpc_mdelem: if
-     changing them, update metadata.h at the same time. */
-  grpc_slice key;
-  grpc_slice value;
-
-  /** The following fields are reserved for grpc internal use.
-      There is no need to initialize them, and they will be set to garbage
-      during calls to grpc. */
-  struct /* internal */ {
-    void* obfuscated[4];
-  } internal_data;
-} grpc_metadata;
-
-/** The type of completion (for grpc_event) */
-typedef enum grpc_completion_type {
-  /** Shutting down */
-  GRPC_QUEUE_SHUTDOWN,
-  /** No event before timeout */
-  GRPC_QUEUE_TIMEOUT,
-  /** Operation completion */
-  GRPC_OP_COMPLETE
-} grpc_completion_type;
-
-/** The result of an operation.
-
-    Returned by a completion queue when the operation started with tag. */
-typedef struct grpc_event {
-  /** The type of the completion. */
-  grpc_completion_type type;
-  /** If the grpc_completion_type is GRPC_OP_COMPLETE, this field indicates
-      whether the operation was successful or not; 0 in case of failure and
-      non-zero in case of success.
-      If grpc_completion_type is GRPC_QUEUE_SHUTDOWN or GRPC_QUEUE_TIMEOUT, this
-      field is guaranteed to be 0 */
-  int success;
-  /** The tag passed to grpc_call_start_batch etc to start this operation.
-      *Only* GRPC_OP_COMPLETE has a tag. For all other grpc_completion_type
-      values, tag is uninitialized. */
-  void* tag;
-} grpc_event;
-
-typedef struct {
-  size_t count;
-  size_t capacity;
-  grpc_metadata* metadata;
-} grpc_metadata_array;
-
-typedef struct {
-  grpc_slice method;
-  grpc_slice host;
-  gpr_timespec deadline;
-} grpc_call_details;
-
-typedef enum {
-  /** Send initial metadata: one and only one instance MUST be sent for each
-      call, unless the call was cancelled - in which case this can be skipped.
-      This op completes after all bytes of metadata have been accepted by
-      outgoing flow control. */
-  GRPC_OP_SEND_INITIAL_METADATA = 0,
-  /** Send a message: 0 or more of these operations can occur for each call.
-      This op completes after all bytes for the message have been accepted by
-      outgoing flow control. */
-  GRPC_OP_SEND_MESSAGE,
-  /** Send a close from the client: one and only one instance MUST be sent from
-      the client, unless the call was cancelled - in which case this can be
-      skipped. This op completes after all bytes for the call
-      (including the close) have passed outgoing flow control. */
-  GRPC_OP_SEND_CLOSE_FROM_CLIENT,
-  /** Send status from the server: one and only one instance MUST be sent from
-      the server unless the call was cancelled - in which case this can be
-      skipped. This op completes after all bytes for the call
-      (including the status) have passed outgoing flow control. */
-  GRPC_OP_SEND_STATUS_FROM_SERVER,
-  /** Receive initial metadata: one and only one MUST be made on the client,
-      must not be made on the server.
-      This op completes after all initial metadata has been read from the
-      peer. */
-  GRPC_OP_RECV_INITIAL_METADATA,
-  /** Receive a message: 0 or more of these operations can occur for each call.
-      This op completes after all bytes of the received message have been
-      read, or after a half-close has been received on this call. */
-  GRPC_OP_RECV_MESSAGE,
-  /** Receive status on the client: one and only one must be made on the client.
-      This operation always succeeds, meaning ops paired with this operation
-      will also appear to succeed, even though they may not have. In that case
-      the status will indicate some failure.
-      This op completes after all activity on the call has completed. */
-  GRPC_OP_RECV_STATUS_ON_CLIENT,
-  /** Receive close on the server: one and only one must be made on the
-      server. This op completes after the close has been received by the
-      server. This operation always succeeds, meaning ops paired with
-      this operation will also appear to succeed, even though they may not
-      have. */
-  GRPC_OP_RECV_CLOSE_ON_SERVER
-} grpc_op_type;
-
-struct grpc_byte_buffer;
-
-/** Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT
-   which has no arguments) */
-typedef struct grpc_op {
-  /** Operation type, as defined by grpc_op_type */
-  grpc_op_type op;
-  /** Write flags bitset for grpc_begin_messages */
-  uint32_t flags;
-  /** Reserved for future usage */
-  void* reserved;
-  union grpc_op_data {
-    /** Reserved for future usage */
-    struct /* internal */ {
-      void* reserved[8];
-    } reserved;
-    struct grpc_op_send_initial_metadata {
-      size_t count;
-      grpc_metadata* metadata;
-      /** If \a is_set, \a compression_level will be used for the call.
-       * Otherwise, \a compression_level won't be considered */
-      struct grpc_op_send_initial_metadata_maybe_compression_level {
-        uint8_t is_set;
-        grpc_compression_level level;
-      } maybe_compression_level;
-    } send_initial_metadata;
-    struct grpc_op_send_message {
-      /** This op takes ownership of the slices in send_message.  After
-       * a call completes, the contents of send_message are not guaranteed
-       * and likely empty.  The original owner should still call
-       * grpc_byte_buffer_destroy() on this object however.
-       */
-      struct grpc_byte_buffer* send_message;
-    } send_message;
-    struct grpc_op_send_status_from_server {
-      size_t trailing_metadata_count;
-      grpc_metadata* trailing_metadata;
-      grpc_status_code status;
-      /** optional: set to NULL if no details need sending, non-NULL if they do
-       * pointer will not be retained past the start_batch call
-       */
-      grpc_slice* status_details;
-    } send_status_from_server;
-    /** ownership of the array is with the caller, but ownership of the elements
-        stays with the call object (ie key, value members are owned by the call
-        object, recv_initial_metadata->array is owned by the caller).
-        After the operation completes, call grpc_metadata_array_destroy on this
-        value, or reuse it in a future op. */
-    struct grpc_op_recv_initial_metadata {
-      grpc_metadata_array* recv_initial_metadata;
-    } recv_initial_metadata;
-    /** ownership of the byte buffer is moved to the caller; the caller must
-        call grpc_byte_buffer_destroy on this value, or reuse it in a future op.
-        The returned byte buffer will be NULL if trailing metadata was
-        received instead of a message.
-       */
-    struct grpc_op_recv_message {
-      struct grpc_byte_buffer** recv_message;
-    } recv_message;
-    struct grpc_op_recv_status_on_client {
-      /** ownership of the array is with the caller, but ownership of the
-          elements stays with the call object (ie key, value members are owned
-          by the call object, trailing_metadata->array is owned by the caller).
-          After the operation completes, call grpc_metadata_array_destroy on
-          this value, or reuse it in a future op. */
-      grpc_metadata_array* trailing_metadata;
-      grpc_status_code* status;
-      grpc_slice* status_details;
-      /** If this is not nullptr, it will be populated with the full fidelity
-       * error string for debugging purposes. The application is responsible
-       * for freeing the data by using gpr_free(). */
-      const char** error_string;
-    } recv_status_on_client;
-    struct grpc_op_recv_close_on_server {
-      /** out argument, set to 1 if the call failed at the server for
-          a reason other than a non-OK status (cancel, deadline
-          exceeded, network failure, etc.), 0 otherwise (RPC processing ran to
-          completion and was able to provide any status from the server) */
-      int* cancelled;
-    } recv_close_on_server;
-  } data;
-} grpc_op;
-
-/** Information requested from the channel. */
-typedef struct {
-  /** If non-NULL, will be set to point to a string indicating the LB
-   * policy name.  Caller takes ownership. */
-  char** lb_policy_name;
-  /** If non-NULL, will be set to point to a string containing the
-   * service config used by the channel in JSON form. */
-  char** service_config_json;
-} grpc_channel_info;
-
-typedef struct grpc_resource_quota grpc_resource_quota;
-
-/** Completion queues internally MAY maintain a set of file descriptors in a
-    structure called 'pollset'. This enum specifies if a completion queue has an
-    associated pollset and any restrictions on the type of file descriptors that
-    can be present in the pollset.
-
-    I/O progress can only be made when grpc_completion_queue_next() or
-    grpc_completion_queue_pluck() are called on the completion queue (unless the
-    grpc_cq_polling_type is GRPC_CQ_NON_POLLING) and hence it is very important
-    to actively call these APIs */
-typedef enum {
-  /** The completion queue will have an associated pollset and there is no
-      restriction on the type of file descriptors the pollset may contain */
-  GRPC_CQ_DEFAULT_POLLING,
-
-  /** Similar to GRPC_CQ_DEFAULT_POLLING except that the completion queues will
-      not contain any 'listening file descriptors' (i.e file descriptors used to
-      listen to incoming channels) */
-  GRPC_CQ_NON_LISTENING,
-
-  /** The completion queue will not have an associated pollset. Note that
-      grpc_completion_queue_next() or grpc_completion_queue_pluck() MUST still
-      be called to pop events from the completion queue; it is not required to
-      call them actively to make I/O progress */
-  GRPC_CQ_NON_POLLING
-} grpc_cq_polling_type;
-
-/** Specifies the type of APIs to use to pop events from the completion queue */
-typedef enum {
-  /** Events are popped out by calling grpc_completion_queue_next() API ONLY */
-  GRPC_CQ_NEXT,
-
-  /** Events are popped out by calling grpc_completion_queue_pluck() API ONLY*/
-  GRPC_CQ_PLUCK,
-
-  /** Events trigger a callback specified as the tag */
-  GRPC_CQ_CALLBACK
-} grpc_cq_completion_type;
-
-/** Specifies an interface class to be used as a tag for callback-based
- * completion queues. This can be used directly, as the first element of a
- * struct in C, or as a base class in C++. Its "run" value should be assigned to
- * some non-member function, such as a static method. */
-typedef struct grpc_completion_queue_functor {
-  /** The run member specifies a function that will be called when this
-      tag is extracted from the completion queue. Its arguments will be a
-      pointer to this functor and a boolean that indicates whether the
-      operation succeeded (non-zero) or failed (zero) */
-  void (*functor_run)(struct grpc_completion_queue_functor*, int);
-
-  /** The inlineable member specifies whether this functor can be run inline.
-      This should only be used for trivial internally-defined functors. */
-  int inlineable;
-
-  /** The following fields are not API. They are meant for internal use. */
-  int internal_success;
-  struct grpc_completion_queue_functor* internal_next;
-} grpc_completion_queue_functor;
+#define GRPC_INITIAL_METADATA_USED_MASK                    \
+    (GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET | \
+     GRPC_INITIAL_METADATA_WAIT_FOR_READY | GRPC_WRITE_THROUGH)
+
+    /** A single metadata element */
+    typedef struct grpc_metadata
+    {
+        /** the key, value values are expected to line up with grpc_mdelem: if
+           changing them, update metadata.h at the same time. */
+        grpc_slice key;
+        grpc_slice value;
+
+        /** The following fields are reserved for grpc internal use.
+            There is no need to initialize them, and they will be set to garbage
+            during calls to grpc. */
+        struct /* internal */
+        {
+            void* obfuscated[4];
+        } internal_data;
+    } grpc_metadata;
+
+    /** The type of completion (for grpc_event) */
+    typedef enum grpc_completion_type
+    {
+        /** Shutting down */
+        GRPC_QUEUE_SHUTDOWN,
+        /** No event before timeout */
+        GRPC_QUEUE_TIMEOUT,
+        /** Operation completion */
+        GRPC_OP_COMPLETE
+    } grpc_completion_type;
+
+    /** The result of an operation.
+
+        Returned by a completion queue when the operation started with tag. */
+    typedef struct grpc_event
+    {
+        /** The type of the completion. */
+        grpc_completion_type type;
+        /** If the grpc_completion_type is GRPC_OP_COMPLETE, this field indicates
+            whether the operation was successful or not; 0 in case of failure and
+            non-zero in case of success.
+            If grpc_completion_type is GRPC_QUEUE_SHUTDOWN or GRPC_QUEUE_TIMEOUT, this
+            field is guaranteed to be 0 */
+        int success;
+        /** The tag passed to grpc_call_start_batch etc to start this operation.
+            *Only* GRPC_OP_COMPLETE has a tag. For all other grpc_completion_type
+            values, tag is uninitialized. */
+        void* tag;
+    } grpc_event;
+
+    typedef struct
+    {
+        size_t count;
+        size_t capacity;
+        grpc_metadata* metadata;
+    } grpc_metadata_array;
+
+    typedef struct
+    {
+        grpc_slice method;
+        grpc_slice host;
+        gpr_timespec deadline;
+    } grpc_call_details;
+
+    typedef enum
+    {
+        /** Send initial metadata: one and only one instance MUST be sent for each
+            call, unless the call was cancelled - in which case this can be skipped.
+            This op completes after all bytes of metadata have been accepted by
+            outgoing flow control. */
+        GRPC_OP_SEND_INITIAL_METADATA = 0,
+        /** Send a message: 0 or more of these operations can occur for each call.
+            This op completes after all bytes for the message have been accepted by
+            outgoing flow control. */
+        GRPC_OP_SEND_MESSAGE,
+        /** Send a close from the client: one and only one instance MUST be sent from
+            the client, unless the call was cancelled - in which case this can be
+            skipped. This op completes after all bytes for the call
+            (including the close) have passed outgoing flow control. */
+        GRPC_OP_SEND_CLOSE_FROM_CLIENT,
+        /** Send status from the server: one and only one instance MUST be sent from
+            the server unless the call was cancelled - in which case this can be
+            skipped. This op completes after all bytes for the call
+            (including the status) have passed outgoing flow control. */
+        GRPC_OP_SEND_STATUS_FROM_SERVER,
+        /** Receive initial metadata: one and only one MUST be made on the client,
+            must not be made on the server.
+            This op completes after all initial metadata has been read from the
+            peer. */
+        GRPC_OP_RECV_INITIAL_METADATA,
+        /** Receive a message: 0 or more of these operations can occur for each call.
+            This op completes after all bytes of the received message have been
+            read, or after a half-close has been received on this call. */
+        GRPC_OP_RECV_MESSAGE,
+        /** Receive status on the client: one and only one must be made on the client.
+            This operation always succeeds, meaning ops paired with this operation
+            will also appear to succeed, even though they may not have. In that case
+            the status will indicate some failure.
+            This op completes after all activity on the call has completed. */
+        GRPC_OP_RECV_STATUS_ON_CLIENT,
+        /** Receive close on the server: one and only one must be made on the
+            server. This op completes after the close has been received by the
+            server. This operation always succeeds, meaning ops paired with
+            this operation will also appear to succeed, even though they may not
+            have. */
+        GRPC_OP_RECV_CLOSE_ON_SERVER
+    } grpc_op_type;
+
+    struct grpc_byte_buffer;
+
+    /** Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT
+       which has no arguments) */
+    typedef struct grpc_op
+    {
+        /** Operation type, as defined by grpc_op_type */
+        grpc_op_type op;
+        /** Write flags bitset for grpc_begin_messages */
+        uint32_t flags;
+        /** Reserved for future usage */
+        void* reserved;
+        union grpc_op_data
+        {
+            /** Reserved for future usage */
+            struct /* internal */
+            {
+                void* reserved[8];
+            } reserved;
+            struct grpc_op_send_initial_metadata
+            {
+                size_t count;
+                grpc_metadata* metadata;
+                /** If \a is_set, \a compression_level will be used for the call.
+                 * Otherwise, \a compression_level won't be considered */
+                struct grpc_op_send_initial_metadata_maybe_compression_level
+                {
+                    uint8_t is_set;
+                    grpc_compression_level level;
+                } maybe_compression_level;
+            } send_initial_metadata;
+            struct grpc_op_send_message
+            {
+                /** This op takes ownership of the slices in send_message.  After
+                 * a call completes, the contents of send_message are not guaranteed
+                 * and likely empty.  The original owner should still call
+                 * grpc_byte_buffer_destroy() on this object however.
+                 */
+                struct grpc_byte_buffer* send_message;
+            } send_message;
+            struct grpc_op_send_status_from_server
+            {
+                size_t trailing_metadata_count;
+                grpc_metadata* trailing_metadata;
+                grpc_status_code status;
+                /** optional: set to NULL if no details need sending, non-NULL if they do
+                 * pointer will not be retained past the start_batch call
+                 */
+                grpc_slice* status_details;
+            } send_status_from_server;
+            /** ownership of the array is with the caller, but ownership of the elements
+                stays with the call object (ie key, value members are owned by the call
+                object, recv_initial_metadata->array is owned by the caller).
+                After the operation completes, call grpc_metadata_array_destroy on this
+                value, or reuse it in a future op. */
+            struct grpc_op_recv_initial_metadata
+            {
+                grpc_metadata_array* recv_initial_metadata;
+            } recv_initial_metadata;
+            /** ownership of the byte buffer is moved to the caller; the caller must
+                call grpc_byte_buffer_destroy on this value, or reuse it in a future op.
+                The returned byte buffer will be NULL if trailing metadata was
+                received instead of a message.
+               */
+            struct grpc_op_recv_message
+            {
+                struct grpc_byte_buffer** recv_message;
+            } recv_message;
+            struct grpc_op_recv_status_on_client
+            {
+                /** ownership of the array is with the caller, but ownership of the
+                    elements stays with the call object (ie key, value members are owned
+                    by the call object, trailing_metadata->array is owned by the caller).
+                    After the operation completes, call grpc_metadata_array_destroy on
+                    this value, or reuse it in a future op. */
+                grpc_metadata_array* trailing_metadata;
+                grpc_status_code* status;
+                grpc_slice* status_details;
+                /** If this is not nullptr, it will be populated with the full fidelity
+                 * error string for debugging purposes. The application is responsible
+                 * for freeing the data by using gpr_free(). */
+                const char** error_string;
+            } recv_status_on_client;
+            struct grpc_op_recv_close_on_server
+            {
+                /** out argument, set to 1 if the call failed at the server for
+                    a reason other than a non-OK status (cancel, deadline
+                    exceeded, network failure, etc.), 0 otherwise (RPC processing ran to
+                    completion and was able to provide any status from the server) */
+                int* cancelled;
+            } recv_close_on_server;
+        } data;
+    } grpc_op;
+
+    /** Information requested from the channel. */
+    typedef struct
+    {
+        /** If non-NULL, will be set to point to a string indicating the LB
+         * policy name.  Caller takes ownership. */
+        char** lb_policy_name;
+        /** If non-NULL, will be set to point to a string containing the
+         * service config used by the channel in JSON form. */
+        char** service_config_json;
+    } grpc_channel_info;
+
+    typedef struct grpc_resource_quota grpc_resource_quota;
+
+    /** Completion queues internally MAY maintain a set of file descriptors in a
+        structure called 'pollset'. This enum specifies if a completion queue has an
+        associated pollset and any restrictions on the type of file descriptors that
+        can be present in the pollset.
+
+        I/O progress can only be made when grpc_completion_queue_next() or
+        grpc_completion_queue_pluck() are called on the completion queue (unless the
+        grpc_cq_polling_type is GRPC_CQ_NON_POLLING) and hence it is very important
+        to actively call these APIs */
+    typedef enum
+    {
+        /** The completion queue will have an associated pollset and there is no
+            restriction on the type of file descriptors the pollset may contain */
+        GRPC_CQ_DEFAULT_POLLING,
+
+        /** Similar to GRPC_CQ_DEFAULT_POLLING except that the completion queues will
+            not contain any 'listening file descriptors' (i.e file descriptors used to
+            listen to incoming channels) */
+        GRPC_CQ_NON_LISTENING,
+
+        /** The completion queue will not have an associated pollset. Note that
+            grpc_completion_queue_next() or grpc_completion_queue_pluck() MUST still
+            be called to pop events from the completion queue; it is not required to
+            call them actively to make I/O progress */
+        GRPC_CQ_NON_POLLING
+    } grpc_cq_polling_type;
+
+    /** Specifies the type of APIs to use to pop events from the completion queue */
+    typedef enum
+    {
+        /** Events are popped out by calling grpc_completion_queue_next() API ONLY */
+        GRPC_CQ_NEXT,
+
+        /** Events are popped out by calling grpc_completion_queue_pluck() API ONLY*/
+        GRPC_CQ_PLUCK,
+
+        /** Events trigger a callback specified as the tag */
+        GRPC_CQ_CALLBACK
+    } grpc_cq_completion_type;
+
+    /** Specifies an interface class to be used as a tag for callback-based
+     * completion queues. This can be used directly, as the first element of a
+     * struct in C, or as a base class in C++. Its "run" value should be assigned to
+     * some non-member function, such as a static method. */
+    typedef struct grpc_completion_queue_functor
+    {
+        /** The run member specifies a function that will be called when this
+            tag is extracted from the completion queue. Its arguments will be a
+            pointer to this functor and a boolean that indicates whether the
+            operation succeeded (non-zero) or failed (zero) */
+        void (*functor_run)(struct grpc_completion_queue_functor*, int);
+
+        /** The inlineable member specifies whether this functor can be run inline.
+            This should only be used for trivial internally-defined functors. */
+        int inlineable;
+
+        /** The following fields are not API. They are meant for internal use. */
+        int internal_success;
+        struct grpc_completion_queue_functor* internal_next;
+    } grpc_completion_queue_functor;
 
 #define GRPC_CQ_CURRENT_VERSION 2
 #define GRPC_CQ_VERSION_MINIMUM_FOR_CALLBACKABLE 2
-typedef struct grpc_completion_queue_attributes {
-  /** The version number of this structure. More fields might be added to this
-     structure in future. */
-  int version; /** Set to GRPC_CQ_CURRENT_VERSION */
+    typedef struct grpc_completion_queue_attributes
+    {
+        /** The version number of this structure. More fields might be added to this
+           structure in future. */
+        int version; /** Set to GRPC_CQ_CURRENT_VERSION */
 
-  grpc_cq_completion_type cq_completion_type;
+        grpc_cq_completion_type cq_completion_type;
 
-  grpc_cq_polling_type cq_polling_type;
+        grpc_cq_polling_type cq_polling_type;
 
-  /* END OF VERSION 1 CQ ATTRIBUTES */
+        /* END OF VERSION 1 CQ ATTRIBUTES */
 
-  /* START OF VERSION 2 CQ ATTRIBUTES */
-  /** When creating a callbackable CQ, pass in a functor to get invoked when
-   * shutdown is complete */
-  grpc_completion_queue_functor* cq_shutdown_cb;
+        /* START OF VERSION 2 CQ ATTRIBUTES */
+        /** When creating a callbackable CQ, pass in a functor to get invoked when
+         * shutdown is complete */
+        grpc_completion_queue_functor* cq_shutdown_cb;
 
-  /* END OF VERSION 2 CQ ATTRIBUTES */
-} grpc_completion_queue_attributes;
+        /* END OF VERSION 2 CQ ATTRIBUTES */
+    } grpc_completion_queue_attributes;
 
-/** The completion queue factory structure is opaque to the callers of grpc */
-typedef struct grpc_completion_queue_factory grpc_completion_queue_factory;
+    /** The completion queue factory structure is opaque to the callers of grpc */
+    typedef struct grpc_completion_queue_factory grpc_completion_queue_factory;
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/log.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/log.h
index 1d5d2da..94ac76c 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/log.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/log.h
@@ -27,77 +27,80 @@
 #include <stdlib.h> /* for abort() */
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** GPR log API.
+    /** GPR log API.
 
-   Usage (within grpc):
+       Usage (within grpc):
 
-   int argument1 = 3;
-   char* argument2 = "hello";
-   gpr_log(GPR_DEBUG, "format string %d", argument1);
-   gpr_log(GPR_INFO, "hello world");
-   gpr_log(GPR_ERROR, "%d %s!!", argument1, argument2); */
+       int argument1 = 3;
+       char* argument2 = "hello";
+       gpr_log(GPR_DEBUG, "format string %d", argument1);
+       gpr_log(GPR_INFO, "hello world");
+       gpr_log(GPR_ERROR, "%d %s!!", argument1, argument2); */
 
-/** The severity of a log message - use the #defines below when calling into
-   gpr_log to additionally supply file and line data */
-typedef enum gpr_log_severity {
-  GPR_LOG_SEVERITY_DEBUG,
-  GPR_LOG_SEVERITY_INFO,
-  GPR_LOG_SEVERITY_ERROR
-} gpr_log_severity;
+    /** The severity of a log message - use the #defines below when calling into
+       gpr_log to additionally supply file and line data */
+    typedef enum gpr_log_severity
+    {
+        GPR_LOG_SEVERITY_DEBUG,
+        GPR_LOG_SEVERITY_INFO,
+        GPR_LOG_SEVERITY_ERROR
+    } gpr_log_severity;
 
-/** Returns a string representation of the log severity */
-GPRAPI const char* gpr_log_severity_string(gpr_log_severity severity);
+    /** Returns a string representation of the log severity */
+    GPRAPI const char* gpr_log_severity_string(gpr_log_severity severity);
 
 /** Macros to build log contexts at various severity levels */
 #define GPR_DEBUG __FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG
 #define GPR_INFO __FILE__, __LINE__, GPR_LOG_SEVERITY_INFO
 #define GPR_ERROR __FILE__, __LINE__, GPR_LOG_SEVERITY_ERROR
 
-/** Log a message. It's advised to use GPR_xxx above to generate the context
- * for each message */
-GPRAPI void gpr_log(const char* file, int line, gpr_log_severity severity,
-                    const char* format, ...) GPR_PRINT_FORMAT_CHECK(4, 5);
+    /** Log a message. It's advised to use GPR_xxx above to generate the context
+     * for each message */
+    GPRAPI void gpr_log(const char* file, int line, gpr_log_severity severity, const char* format, ...) GPR_PRINT_FORMAT_CHECK(4, 5);
 
-GPRAPI int gpr_should_log(gpr_log_severity severity);
+    GPRAPI int gpr_should_log(gpr_log_severity severity);
 
-GPRAPI void gpr_log_message(const char* file, int line,
-                            gpr_log_severity severity, const char* message);
+    GPRAPI void gpr_log_message(const char* file, int line, gpr_log_severity severity, const char* message);
 
-/** Set global log verbosity */
-GPRAPI void gpr_set_log_verbosity(gpr_log_severity min_severity_to_print);
+    /** Set global log verbosity */
+    GPRAPI void gpr_set_log_verbosity(gpr_log_severity min_severity_to_print);
 
-GPRAPI void gpr_log_verbosity_init(void);
+    GPRAPI void gpr_log_verbosity_init(void);
 
-/** Log overrides: applications can use this API to intercept logging calls
-   and use their own implementations */
+    /** Log overrides: applications can use this API to intercept logging calls
+       and use their own implementations */
 
-struct gpr_log_func_args {
-  const char* file;
-  int line;
-  gpr_log_severity severity;
-  const char* message;
-};
+    struct gpr_log_func_args
+    {
+        const char* file;
+        int line;
+        gpr_log_severity severity;
+        const char* message;
+    };
 
-typedef struct gpr_log_func_args gpr_log_func_args;
+    typedef struct gpr_log_func_args gpr_log_func_args;
 
-typedef void (*gpr_log_func)(gpr_log_func_args* args);
-GPRAPI void gpr_set_log_function(gpr_log_func func);
+    typedef void (*gpr_log_func)(gpr_log_func_args* args);
+    GPRAPI void gpr_set_log_function(gpr_log_func func);
 
 /** abort() the process if x is zero, having written a line to the log.
 
    Intended for internal invariants.  If the error can be recovered from,
    without the possibility of corruption, or might best be reflected via
    an exception in a higher-level language, consider returning error code.  */
-#define GPR_ASSERT(x)                                 \
-  do {                                                \
-    if (GPR_UNLIKELY(!(x))) {                         \
-      gpr_log(GPR_ERROR, "assertion failed: %s", #x); \
-      abort();                                        \
-    }                                                 \
-  } while (0)
+#define GPR_ASSERT(x)                                       \
+    do                                                      \
+    {                                                       \
+        if (GPR_UNLIKELY(!(x)))                             \
+        {                                                   \
+            gpr_log(GPR_ERROR, "assertion failed: %s", #x); \
+            abort();                                        \
+        }                                                   \
+    } while (0)
 
 #ifndef NDEBUG
 #define GPR_DEBUG_ASSERT(x) GPR_ASSERT(x)
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/port_platform.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/port_platform.h
index ec8217a..c27f7a5 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/port_platform.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/port_platform.h
@@ -602,7 +602,7 @@ typedef unsigned __int64 uint64_t;
 #ifndef GPR_PRINT_FORMAT_CHECK
 #ifdef __GNUC__
 #define GPR_PRINT_FORMAT_CHECK(FORMAT_STR, ARGS) \
-  __attribute__((format(printf, FORMAT_STR, ARGS)))
+    __attribute__((format(printf, FORMAT_STR, ARGS)))
 #else
 #define GPR_PRINT_FORMAT_CHECK(FORMAT_STR, ARGS)
 #endif
@@ -634,18 +634,19 @@ typedef unsigned __int64 uint64_t;
 #define GPR_UNREACHABLE_CODE(STATEMENT)
 #else
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
-extern void gpr_unreachable_code(const char* reason, const char* file,
-                                 int line) GPR_ATTRIBUTE_NORETURN;
+    extern void gpr_unreachable_code(const char* reason, const char* file, int line) GPR_ATTRIBUTE_NORETURN;
 #ifdef __cplusplus
 }
 #endif
-#define GPR_UNREACHABLE_CODE(STATEMENT)                   \
-  do {                                                    \
-    gpr_unreachable_code(#STATEMENT, __FILE__, __LINE__); \
-    STATEMENT;                                            \
-  } while (0)
+#define GPR_UNREACHABLE_CODE(STATEMENT)                       \
+    do                                                        \
+    {                                                         \
+        gpr_unreachable_code(#STATEMENT, __FILE__, __LINE__); \
+        STATEMENT;                                            \
+    } while (0)
 #endif /* GPR_FORBID_UNREACHABLE_CODE */
 
 #ifndef GPRAPI
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/propagation_bits.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/propagation_bits.h
index d702099..027143c 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/propagation_bits.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/propagation_bits.h
@@ -24,7 +24,8 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 /** Propagation bits: this can be bitwise or-ed to form propagation_mask for
@@ -42,10 +43,11 @@ extern "C" {
    GRPC_PROPAGATE_DEFAULTS & ~GRPC_PROPAGATE_DEADLINE to disable deadline
    propagation. Doing so gives flexibility in the future to define new
    propagation types that are default inherited or not. */
-#define GRPC_PROPAGATE_DEFAULTS                                                \
-  ((uint32_t)((                                                                \
-      0xffff | GRPC_PROPAGATE_DEADLINE | GRPC_PROPAGATE_CENSUS_STATS_CONTEXT | \
-      GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT | GRPC_PROPAGATE_CANCELLATION)))
+#define GRPC_PROPAGATE_DEFAULTS                                                  \
+    ((uint32_t)((                                                                \
+        0xffff | GRPC_PROPAGATE_DEADLINE | GRPC_PROPAGATE_CENSUS_STATS_CONTEXT | \
+        GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT | GRPC_PROPAGATE_CANCELLATION      \
+    )))
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/slice.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/slice.h
index 33c1f1b..539ea1c 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/slice.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/slice.h
@@ -47,7 +47,7 @@ typedef struct grpc_slice grpc_slice;
 #define GRPC_SLICE_INLINE_EXTRA_SIZE sizeof(void*)
 
 #define GRPC_SLICE_INLINED_SIZE \
-  (sizeof(size_t) + sizeof(uint8_t*) - 1 + GRPC_SLICE_INLINE_EXTRA_SIZE)
+    (sizeof(size_t) + sizeof(uint8_t*) - 1 + GRPC_SLICE_INLINE_EXTRA_SIZE)
 
 struct grpc_slice_refcount;
 /** A grpc_slice s, if initialized, represents the byte range
@@ -62,69 +62,68 @@ struct grpc_slice_refcount;
 
    As a special case, a slice can be given refcount == uintptr_t(1), meaning
    that the slice represents external data that is not refcounted. */
-struct grpc_slice {
-  struct grpc_slice_refcount* refcount;
-  union grpc_slice_data {
-    struct grpc_slice_refcounted {
-      size_t length;
-      uint8_t* bytes;
-    } refcounted;
-    struct grpc_slice_inlined {
-      uint8_t length;
-      uint8_t bytes[GRPC_SLICE_INLINED_SIZE];
-    } inlined;
-  } data;
+struct grpc_slice
+{
+    struct grpc_slice_refcount* refcount;
+    union grpc_slice_data
+    {
+        struct grpc_slice_refcounted
+        {
+            size_t length;
+            uint8_t* bytes;
+        } refcounted;
+        struct grpc_slice_inlined
+        {
+            uint8_t length;
+            uint8_t bytes[GRPC_SLICE_INLINED_SIZE];
+        } inlined;
+    } data;
 };
 
 #define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 8
 
 /** Represents an expandable array of slices, to be interpreted as a
    single item. */
-typedef struct grpc_slice_buffer {
-  /** This is for internal use only. External users (i.e any code outside grpc
-   * core) MUST NOT use this field */
-  grpc_slice* base_slices;
-
-  /** slices in the array (Points to the first valid grpc_slice in the array) */
-  grpc_slice* slices;
-  /** the number of slices in the array */
-  size_t count;
-  /** the number of slices allocated in the array. External users (i.e any code
-   * outside grpc core) MUST NOT use this field */
-  size_t capacity;
-  /** the combined length of all slices in the array */
-  size_t length;
-  /** inlined elements to avoid allocations */
-  grpc_slice inlined[GRPC_SLICE_BUFFER_INLINE_ELEMENTS];
+typedef struct grpc_slice_buffer
+{
+    /** This is for internal use only. External users (i.e any code outside grpc
+     * core) MUST NOT use this field */
+    grpc_slice* base_slices;
+
+    /** slices in the array (Points to the first valid grpc_slice in the array) */
+    grpc_slice* slices;
+    /** the number of slices in the array */
+    size_t count;
+    /** the number of slices allocated in the array. External users (i.e any code
+     * outside grpc core) MUST NOT use this field */
+    size_t capacity;
+    /** the combined length of all slices in the array */
+    size_t length;
+    /** inlined elements to avoid allocations */
+    grpc_slice inlined[GRPC_SLICE_BUFFER_INLINE_ELEMENTS];
 } grpc_slice_buffer;
 
-#define GRPC_SLICE_START_PTR(slice)                 \
-  ((slice).refcount ? (slice).data.refcounted.bytes \
-                    : (slice).data.inlined.bytes)
-#define GRPC_SLICE_LENGTH(slice)                     \
-  ((slice).refcount ? (slice).data.refcounted.length \
-                    : (slice).data.inlined.length)
-#define GRPC_SLICE_SET_LENGTH(slice, newlen)                              \
-  ((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) \
-                    : ((slice).data.inlined.length = (uint8_t)(newlen)))
+#define GRPC_SLICE_START_PTR(slice) \
+    ((slice).refcount ? (slice).data.refcounted.bytes : (slice).data.inlined.bytes)
+#define GRPC_SLICE_LENGTH(slice) \
+    ((slice).refcount ? (slice).data.refcounted.length : (slice).data.inlined.length)
+#define GRPC_SLICE_SET_LENGTH(slice, newlen) \
+    ((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) : ((slice).data.inlined.length = (uint8_t)(newlen)))
 #define GRPC_SLICE_END_PTR(slice) \
-  GRPC_SLICE_START_PTR(slice) + GRPC_SLICE_LENGTH(slice)
+    GRPC_SLICE_START_PTR(slice) + GRPC_SLICE_LENGTH(slice)
 #define GRPC_SLICE_IS_EMPTY(slice) (GRPC_SLICE_LENGTH(slice) == 0)
 
 #ifdef GRPC_ALLOW_GPR_SLICE_FUNCTIONS
 
 /* Duplicate GPR_* definitions */
-#define GPR_SLICE_START_PTR(slice)                  \
-  ((slice).refcount ? (slice).data.refcounted.bytes \
-                    : (slice).data.inlined.bytes)
-#define GPR_SLICE_LENGTH(slice)                      \
-  ((slice).refcount ? (slice).data.refcounted.length \
-                    : (slice).data.inlined.length)
-#define GPR_SLICE_SET_LENGTH(slice, newlen)                               \
-  ((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) \
-                    : ((slice).data.inlined.length = (uint8_t)(newlen)))
+#define GPR_SLICE_START_PTR(slice) \
+    ((slice).refcount ? (slice).data.refcounted.bytes : (slice).data.inlined.bytes)
+#define GPR_SLICE_LENGTH(slice) \
+    ((slice).refcount ? (slice).data.refcounted.length : (slice).data.inlined.length)
+#define GPR_SLICE_SET_LENGTH(slice, newlen) \
+    ((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) : ((slice).data.inlined.length = (uint8_t)(newlen)))
 #define GPR_SLICE_END_PTR(slice) \
-  GRPC_SLICE_START_PTR(slice) + GRPC_SLICE_LENGTH(slice)
+    GRPC_SLICE_START_PTR(slice) + GRPC_SLICE_LENGTH(slice)
 #define GPR_SLICE_IS_EMPTY(slice) (GRPC_SLICE_LENGTH(slice) == 0)
 
 #endif /* GRPC_ALLOW_GPR_SLICE_FUNCTIONS */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/status.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/status.h
index 2b18f6d..0c3e167 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/status.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/status.h
@@ -22,132 +22,134 @@
 // IWYU pragma: private, include <grpc/status.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-typedef enum {
-  /** Not an error; returned on success */
-  GRPC_STATUS_OK = 0,
-
-  /** The operation was cancelled (typically by the caller). */
-  GRPC_STATUS_CANCELLED = 1,
-
-  /** Unknown error.  An example of where this error may be returned is
-     if a Status value received from another address space belongs to
-     an error-space that is not known in this address space.  Also
-     errors raised by APIs that do not return enough error information
-     may be converted to this error. */
-  GRPC_STATUS_UNKNOWN = 2,
-
-  /** Client specified an invalid argument.  Note that this differs
-     from FAILED_PRECONDITION.  INVALID_ARGUMENT indicates arguments
-     that are problematic regardless of the state of the system
-     (e.g., a malformed file name). */
-  GRPC_STATUS_INVALID_ARGUMENT = 3,
-
-  /** Deadline expired before operation could complete.  For operations
-     that change the state of the system, this error may be returned
-     even if the operation has completed successfully.  For example, a
-     successful response from a server could have been delayed long
-     enough for the deadline to expire. */
-  GRPC_STATUS_DEADLINE_EXCEEDED = 4,
-
-  /** Some requested entity (e.g., file or directory) was not found. */
-  GRPC_STATUS_NOT_FOUND = 5,
-
-  /** Some entity that we attempted to create (e.g., file or directory)
-     already exists. */
-  GRPC_STATUS_ALREADY_EXISTS = 6,
-
-  /** The caller does not have permission to execute the specified
-     operation.  PERMISSION_DENIED must not be used for rejections
-     caused by exhausting some resource (use RESOURCE_EXHAUSTED
-     instead for those errors).  PERMISSION_DENIED must not be
-     used if the caller can not be identified (use UNAUTHENTICATED
-     instead for those errors). */
-  GRPC_STATUS_PERMISSION_DENIED = 7,
-
-  /** The request does not have valid authentication credentials for the
-     operation. */
-  GRPC_STATUS_UNAUTHENTICATED = 16,
-
-  /** Some resource has been exhausted, perhaps a per-user quota, or
-     perhaps the entire file system is out of space. */
-  GRPC_STATUS_RESOURCE_EXHAUSTED = 8,
-
-  /** Operation was rejected because the system is not in a state
-     required for the operation's execution.  For example, directory
-     to be deleted may be non-empty, an rmdir operation is applied to
-     a non-directory, etc.
-
-     A litmus test that may help a service implementor in deciding
-     between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
-      (a) Use UNAVAILABLE if the client can retry just the failing call.
-      (b) Use ABORTED if the client should retry at a higher-level
-          (e.g., restarting a read-modify-write sequence).
-      (c) Use FAILED_PRECONDITION if the client should not retry until
-          the system state has been explicitly fixed.  E.g., if an "rmdir"
-          fails because the directory is non-empty, FAILED_PRECONDITION
-          should be returned since the client should not retry unless
-          they have first fixed up the directory by deleting files from it.
-      (d) Use FAILED_PRECONDITION if the client performs conditional
-          REST Get/Update/Delete on a resource and the resource on the
-          server does not match the condition. E.g., conflicting
-          read-modify-write on the same resource. */
-  GRPC_STATUS_FAILED_PRECONDITION = 9,
-
-  /** The operation was aborted, typically due to a concurrency issue
-     like sequencer check failures, transaction aborts, etc.
-
-     See litmus test above for deciding between FAILED_PRECONDITION,
-     ABORTED, and UNAVAILABLE. */
-  GRPC_STATUS_ABORTED = 10,
-
-  /** Operation was attempted past the valid range.  E.g., seeking or
-     reading past end of file.
-
-     Unlike INVALID_ARGUMENT, this error indicates a problem that may
-     be fixed if the system state changes. For example, a 32-bit file
-     system will generate INVALID_ARGUMENT if asked to read at an
-     offset that is not in the range [0,2^32-1], but it will generate
-     OUT_OF_RANGE if asked to read from an offset past the current
-     file size.
-
-     There is a fair bit of overlap between FAILED_PRECONDITION and
-     OUT_OF_RANGE.  We recommend using OUT_OF_RANGE (the more specific
-     error) when it applies so that callers who are iterating through
-     a space can easily look for an OUT_OF_RANGE error to detect when
-     they are done. */
-  GRPC_STATUS_OUT_OF_RANGE = 11,
-
-  /** Operation is not implemented or not supported/enabled in this service. */
-  GRPC_STATUS_UNIMPLEMENTED = 12,
-
-  /** Internal errors.  Means some invariants expected by underlying
-     system has been broken.  If you see one of these errors,
-     something is very broken. */
-  GRPC_STATUS_INTERNAL = 13,
-
-  /** The service is currently unavailable.  This is a most likely a
-     transient condition and may be corrected by retrying with
-     a backoff. Note that it is not always safe to retry non-idempotent
-     operations.
-
-     WARNING: Although data MIGHT not have been transmitted when this
-     status occurs, there is NOT A GUARANTEE that the server has not seen
-     anything. So in general it is unsafe to retry on this status code
-     if the call is non-idempotent.
-
-     See litmus test above for deciding between FAILED_PRECONDITION,
-     ABORTED, and UNAVAILABLE. */
-  GRPC_STATUS_UNAVAILABLE = 14,
-
-  /** Unrecoverable data loss or corruption. */
-  GRPC_STATUS_DATA_LOSS = 15,
-
-  /** Force users to include a default branch: */
-  GRPC_STATUS__DO_NOT_USE = -1
-} grpc_status_code;
+    typedef enum
+    {
+        /** Not an error; returned on success */
+        GRPC_STATUS_OK = 0,
+
+        /** The operation was cancelled (typically by the caller). */
+        GRPC_STATUS_CANCELLED = 1,
+
+        /** Unknown error.  An example of where this error may be returned is
+           if a Status value received from another address space belongs to
+           an error-space that is not known in this address space.  Also
+           errors raised by APIs that do not return enough error information
+           may be converted to this error. */
+        GRPC_STATUS_UNKNOWN = 2,
+
+        /** Client specified an invalid argument.  Note that this differs
+           from FAILED_PRECONDITION.  INVALID_ARGUMENT indicates arguments
+           that are problematic regardless of the state of the system
+           (e.g., a malformed file name). */
+        GRPC_STATUS_INVALID_ARGUMENT = 3,
+
+        /** Deadline expired before operation could complete.  For operations
+           that change the state of the system, this error may be returned
+           even if the operation has completed successfully.  For example, a
+           successful response from a server could have been delayed long
+           enough for the deadline to expire. */
+        GRPC_STATUS_DEADLINE_EXCEEDED = 4,
+
+        /** Some requested entity (e.g., file or directory) was not found. */
+        GRPC_STATUS_NOT_FOUND = 5,
+
+        /** Some entity that we attempted to create (e.g., file or directory)
+           already exists. */
+        GRPC_STATUS_ALREADY_EXISTS = 6,
+
+        /** The caller does not have permission to execute the specified
+           operation.  PERMISSION_DENIED must not be used for rejections
+           caused by exhausting some resource (use RESOURCE_EXHAUSTED
+           instead for those errors).  PERMISSION_DENIED must not be
+           used if the caller can not be identified (use UNAUTHENTICATED
+           instead for those errors). */
+        GRPC_STATUS_PERMISSION_DENIED = 7,
+
+        /** The request does not have valid authentication credentials for the
+           operation. */
+        GRPC_STATUS_UNAUTHENTICATED = 16,
+
+        /** Some resource has been exhausted, perhaps a per-user quota, or
+           perhaps the entire file system is out of space. */
+        GRPC_STATUS_RESOURCE_EXHAUSTED = 8,
+
+        /** Operation was rejected because the system is not in a state
+           required for the operation's execution.  For example, directory
+           to be deleted may be non-empty, an rmdir operation is applied to
+           a non-directory, etc.
+
+           A litmus test that may help a service implementor in deciding
+           between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
+            (a) Use UNAVAILABLE if the client can retry just the failing call.
+            (b) Use ABORTED if the client should retry at a higher-level
+                (e.g., restarting a read-modify-write sequence).
+            (c) Use FAILED_PRECONDITION if the client should not retry until
+                the system state has been explicitly fixed.  E.g., if an "rmdir"
+                fails because the directory is non-empty, FAILED_PRECONDITION
+                should be returned since the client should not retry unless
+                they have first fixed up the directory by deleting files from it.
+            (d) Use FAILED_PRECONDITION if the client performs conditional
+                REST Get/Update/Delete on a resource and the resource on the
+                server does not match the condition. E.g., conflicting
+                read-modify-write on the same resource. */
+        GRPC_STATUS_FAILED_PRECONDITION = 9,
+
+        /** The operation was aborted, typically due to a concurrency issue
+           like sequencer check failures, transaction aborts, etc.
+
+           See litmus test above for deciding between FAILED_PRECONDITION,
+           ABORTED, and UNAVAILABLE. */
+        GRPC_STATUS_ABORTED = 10,
+
+        /** Operation was attempted past the valid range.  E.g., seeking or
+           reading past end of file.
+
+           Unlike INVALID_ARGUMENT, this error indicates a problem that may
+           be fixed if the system state changes. For example, a 32-bit file
+           system will generate INVALID_ARGUMENT if asked to read at an
+           offset that is not in the range [0,2^32-1], but it will generate
+           OUT_OF_RANGE if asked to read from an offset past the current
+           file size.
+
+           There is a fair bit of overlap between FAILED_PRECONDITION and
+           OUT_OF_RANGE.  We recommend using OUT_OF_RANGE (the more specific
+           error) when it applies so that callers who are iterating through
+           a space can easily look for an OUT_OF_RANGE error to detect when
+           they are done. */
+        GRPC_STATUS_OUT_OF_RANGE = 11,
+
+        /** Operation is not implemented or not supported/enabled in this service. */
+        GRPC_STATUS_UNIMPLEMENTED = 12,
+
+        /** Internal errors.  Means some invariants expected by underlying
+           system has been broken.  If you see one of these errors,
+           something is very broken. */
+        GRPC_STATUS_INTERNAL = 13,
+
+        /** The service is currently unavailable.  This is a most likely a
+           transient condition and may be corrected by retrying with
+           a backoff. Note that it is not always safe to retry non-idempotent
+           operations.
+
+           WARNING: Although data MIGHT not have been transmitted when this
+           status occurs, there is NOT A GUARANTEE that the server has not seen
+           anything. So in general it is unsafe to retry on this status code
+           if the call is non-idempotent.
+
+           See litmus test above for deciding between FAILED_PRECONDITION,
+           ABORTED, and UNAVAILABLE. */
+        GRPC_STATUS_UNAVAILABLE = 14,
+
+        /** Unrecoverable data loss or corruption. */
+        GRPC_STATUS_DATA_LOSS = 15,
+
+        /** Force users to include a default branch: */
+        GRPC_STATUS__DO_NOT_USE = -1
+    } grpc_status_code;
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync.h
index 1b30ea7..51030c7 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync.h
@@ -41,7 +41,8 @@
  */
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 /* Platform-specific type declarations of gpr_mu and gpr_cv.   */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_generic.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_generic.h
index a79b9c6..1b17c1b 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_generic.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_generic.h
@@ -28,24 +28,31 @@
 #include <grpc/impl/codegen/atm.h>
 
 /* gpr_event */
-typedef struct {
-  gpr_atm state;
+typedef struct
+{
+    gpr_atm state;
 } gpr_event;
 
 #define GPR_EVENT_INIT \
-  { 0 }
+    {                  \
+        0              \
+    }
 
 /* gpr_refcount */
-typedef struct {
-  gpr_atm count;
+typedef struct
+{
+    gpr_atm count;
 } gpr_refcount;
 
 /* gpr_stats_counter */
-typedef struct {
-  gpr_atm value;
+typedef struct
+{
+    gpr_atm value;
 } gpr_stats_counter;
 
 #define GPR_STATS_INIT \
-  { 0 }
+    {                  \
+        0              \
+    }
 
 #endif /* GRPC_IMPL_CODEGEN_SYNC_GENERIC_H */
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_posix.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_posix.h
index f5cf482..c38d3ba 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_posix.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_posix.h
@@ -34,14 +34,16 @@
  * This issue was reported at https://github.com/grpc/grpc/issues/17563
  * and discussed at https://github.com/grpc/grpc/pull/17586
  */
-typedef struct {
-  pthread_mutex_t mutex;
-  int* leak_checker;
+typedef struct
+{
+    pthread_mutex_t mutex;
+    int* leak_checker;
 } gpr_mu;
 
-typedef struct {
-  pthread_cond_t cond_var;
-  int* leak_checker;
+typedef struct
+{
+    pthread_cond_t cond_var;
+    int* leak_checker;
 } gpr_cv;
 #else
 typedef pthread_mutex_t gpr_mu;
diff --git a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_windows.h b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_windows.h
index 2bee03b..cb04b4c 100644
--- a/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_windows.h
+++ b/CAPI/cpp/grpc/include/grpc/impl/codegen/sync_windows.h
@@ -27,9 +27,10 @@
 
 #include <grpc/impl/codegen/sync_generic.h>
 
-typedef struct {
-  CRITICAL_SECTION cs; /* Not an SRWLock until Vista is unsupported */
-  int locked;
+typedef struct
+{
+    CRITICAL_SECTION cs; /* Not an SRWLock until Vista is unsupported */
+    int locked;
 } gpr_mu;
 
 typedef CONDITION_VARIABLE gpr_cv;
diff --git a/CAPI/cpp/grpc/include/grpc/load_reporting.h b/CAPI/cpp/grpc/include/grpc/load_reporting.h
index 55f50ea..e7691fe 100644
--- a/CAPI/cpp/grpc/include/grpc/load_reporting.h
+++ b/CAPI/cpp/grpc/include/grpc/load_reporting.h
@@ -22,7 +22,8 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 /** Metadata key for the gRPC LB load balancer token.
diff --git a/CAPI/cpp/grpc/include/grpc/slice.h b/CAPI/cpp/grpc/include/grpc/slice.h
index 15978fe..d13f7e3 100644
--- a/CAPI/cpp/grpc/include/grpc/slice.h
+++ b/CAPI/cpp/grpc/include/grpc/slice.h
@@ -25,134 +25,132 @@
 #include <grpc/support/sync.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** Increment the refcount of s. Requires slice is initialized.
-   Returns s. */
-GPRAPI grpc_slice grpc_slice_ref(grpc_slice s);
-
-/** Decrement the ref count of s.  If the ref count of s reaches zero, all
-   slices sharing the ref count are destroyed, and considered no longer
-   initialized.  If s is ultimately derived from a call to grpc_slice_new(start,
-   len, dest) where dest!=NULL , then (*dest)(start) is called, else if s is
-   ultimately derived from a call to grpc_slice_new_with_len(start, len, dest)
-   where dest!=NULL , then (*dest)(start, len).  Requires s initialized.  */
-GPRAPI void grpc_slice_unref(grpc_slice s);
-
-/** Copy slice - create a new slice that contains the same data as s */
-GPRAPI grpc_slice grpc_slice_copy(grpc_slice s);
-
-/** Create a slice pointing at some data. Calls malloc to allocate a refcount
-   for the object, and arranges that destroy will be called with the pointer
-   passed in at destruction. */
-GPRAPI grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*));
-
-/** Equivalent to grpc_slice_new, but with a separate pointer that is
-   passed to the destroy function.  This function can be useful when
-   the data is part of a larger structure that must be destroyed when
-   the data is no longer needed. */
-GPRAPI grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
-                                                void (*destroy)(void*),
-                                                void* user_data);
-
-/** Equivalent to grpc_slice_new, but with a two argument destroy function that
-   also takes the slice length. */
-GPRAPI grpc_slice grpc_slice_new_with_len(void* p, size_t len,
-                                          void (*destroy)(void*, size_t));
-
-/** Equivalent to grpc_slice_new(malloc(len), len, free), but saves one malloc()
-   call.
-   Aborts if malloc() fails. */
-GPRAPI grpc_slice grpc_slice_malloc(size_t length);
-GPRAPI grpc_slice grpc_slice_malloc_large(size_t length);
+    /** Increment the refcount of s. Requires slice is initialized.
+       Returns s. */
+    GPRAPI grpc_slice grpc_slice_ref(grpc_slice s);
+
+    /** Decrement the ref count of s.  If the ref count of s reaches zero, all
+       slices sharing the ref count are destroyed, and considered no longer
+       initialized.  If s is ultimately derived from a call to grpc_slice_new(start,
+       len, dest) where dest!=NULL , then (*dest)(start) is called, else if s is
+       ultimately derived from a call to grpc_slice_new_with_len(start, len, dest)
+       where dest!=NULL , then (*dest)(start, len).  Requires s initialized.  */
+    GPRAPI void grpc_slice_unref(grpc_slice s);
+
+    /** Copy slice - create a new slice that contains the same data as s */
+    GPRAPI grpc_slice grpc_slice_copy(grpc_slice s);
+
+    /** Create a slice pointing at some data. Calls malloc to allocate a refcount
+       for the object, and arranges that destroy will be called with the pointer
+       passed in at destruction. */
+    GPRAPI grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*));
+
+    /** Equivalent to grpc_slice_new, but with a separate pointer that is
+       passed to the destroy function.  This function can be useful when
+       the data is part of a larger structure that must be destroyed when
+       the data is no longer needed. */
+    GPRAPI grpc_slice grpc_slice_new_with_user_data(void* p, size_t len, void (*destroy)(void*), void* user_data);
+
+    /** Equivalent to grpc_slice_new, but with a two argument destroy function that
+       also takes the slice length. */
+    GPRAPI grpc_slice grpc_slice_new_with_len(void* p, size_t len, void (*destroy)(void*, size_t));
+
+    /** Equivalent to grpc_slice_new(malloc(len), len, free), but saves one malloc()
+       call.
+       Aborts if malloc() fails. */
+    GPRAPI grpc_slice grpc_slice_malloc(size_t length);
+    GPRAPI grpc_slice grpc_slice_malloc_large(size_t length);
 
 #define GRPC_SLICE_MALLOC(len) grpc_slice_malloc(len)
 
-/** Create a slice by copying a string.
-   Does not preserve null terminators.
-   Equivalent to:
-     size_t len = strlen(source);
-     grpc_slice slice = grpc_slice_malloc(len);
-     memcpy(slice->data, source, len); */
-GPRAPI grpc_slice grpc_slice_from_copied_string(const char* source);
-
-/** Create a slice by copying a buffer.
-   Equivalent to:
-     grpc_slice slice = grpc_slice_malloc(len);
-     memcpy(slice->data, source, len); */
-GPRAPI grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t len);
-
-/** Create a slice pointing to constant memory */
-GPRAPI grpc_slice grpc_slice_from_static_string(const char* source);
-
-/** Create a slice pointing to constant memory */
-GPRAPI grpc_slice grpc_slice_from_static_buffer(const void* source, size_t len);
-
-/** Return a result slice derived from s, which shares a ref count with \a s,
-   where result.data==s.data+begin, and result.length==end-begin. The ref count
-   of \a s is increased by one. Do not assign result back to \a s.
-   Requires s initialized, begin <= end, begin <= s.length, and
-   end <= source->length. */
-GPRAPI grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end);
-
-/** The same as grpc_slice_sub, but without altering the ref count */
-GPRAPI grpc_slice grpc_slice_sub_no_ref(grpc_slice s, size_t begin, size_t end);
-
-/** Splits s into two: modifies s to be s[0:split], and returns a new slice,
-   sharing a refcount with s, that contains s[split:s.length].
-   Requires s initialized, split <= s.length */
-GPRAPI grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split);
-
-typedef enum {
-  GRPC_SLICE_REF_TAIL = 1,
-  GRPC_SLICE_REF_HEAD = 2,
-  GRPC_SLICE_REF_BOTH = 1 + 2
-} grpc_slice_ref_whom;
-
-/** The same as grpc_slice_split_tail, but with an option to skip altering
- * refcounts (grpc_slice_split_tail_maybe_ref(..., true) is equivalent to
- * grpc_slice_split_tail(...)) */
-GPRAPI grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* s, size_t split,
-                                                  grpc_slice_ref_whom ref_whom);
-
-/** Splits s into two: modifies s to be s[split:s.length], and returns a new
-   slice, sharing a refcount with s, that contains s[0:split].
-   Requires s initialized, split <= s.length */
-GPRAPI grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split);
-
-GPRAPI grpc_slice grpc_empty_slice(void);
-
-GPRAPI int grpc_slice_eq(grpc_slice a, grpc_slice b);
-
-/** Returns <0 if a < b, ==0 if a == b, >0 if a > b
-   The order is arbitrary, and is not guaranteed to be stable across different
-   versions of the API. */
-GPRAPI int grpc_slice_cmp(grpc_slice a, grpc_slice b);
-GPRAPI int grpc_slice_str_cmp(grpc_slice a, const char* b);
-
-/** return non-zero if the first blen bytes of a are equal to b */
-GPRAPI int grpc_slice_buf_start_eq(grpc_slice a, const void* b, size_t blen);
-
-/** return the index of the last instance of \a c in \a s, or -1 if not found */
-GPRAPI int grpc_slice_rchr(grpc_slice s, char c);
-GPRAPI int grpc_slice_chr(grpc_slice s, char c);
-
-/** return the index of the first occurrence of \a needle in \a haystack, or -1
-   if it's not found */
-GPRAPI int grpc_slice_slice(grpc_slice haystack, grpc_slice needle);
-
-/** Do two slices point at the same memory, with the same length
-   If a or b is inlined, actually compares data */
-GPRAPI int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b);
-
-/** Return a slice pointing to newly allocated memory that has the same contents
- * as \a s */
-GPRAPI grpc_slice grpc_slice_dup(grpc_slice a);
-
-/** Return a copy of slice as a C string. Offers no protection against embedded
-   NULL's. Returned string must be freed with gpr_free. */
-GPRAPI char* grpc_slice_to_c_string(grpc_slice s);
+    /** Create a slice by copying a string.
+       Does not preserve null terminators.
+       Equivalent to:
+         size_t len = strlen(source);
+         grpc_slice slice = grpc_slice_malloc(len);
+         memcpy(slice->data, source, len); */
+    GPRAPI grpc_slice grpc_slice_from_copied_string(const char* source);
+
+    /** Create a slice by copying a buffer.
+       Equivalent to:
+         grpc_slice slice = grpc_slice_malloc(len);
+         memcpy(slice->data, source, len); */
+    GPRAPI grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t len);
+
+    /** Create a slice pointing to constant memory */
+    GPRAPI grpc_slice grpc_slice_from_static_string(const char* source);
+
+    /** Create a slice pointing to constant memory */
+    GPRAPI grpc_slice grpc_slice_from_static_buffer(const void* source, size_t len);
+
+    /** Return a result slice derived from s, which shares a ref count with \a s,
+       where result.data==s.data+begin, and result.length==end-begin. The ref count
+       of \a s is increased by one. Do not assign result back to \a s.
+       Requires s initialized, begin <= end, begin <= s.length, and
+       end <= source->length. */
+    GPRAPI grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end);
+
+    /** The same as grpc_slice_sub, but without altering the ref count */
+    GPRAPI grpc_slice grpc_slice_sub_no_ref(grpc_slice s, size_t begin, size_t end);
+
+    /** Splits s into two: modifies s to be s[0:split], and returns a new slice,
+       sharing a refcount with s, that contains s[split:s.length].
+       Requires s initialized, split <= s.length */
+    GPRAPI grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split);
+
+    typedef enum
+    {
+        GRPC_SLICE_REF_TAIL = 1,
+        GRPC_SLICE_REF_HEAD = 2,
+        GRPC_SLICE_REF_BOTH = 1 + 2
+    } grpc_slice_ref_whom;
+
+    /** The same as grpc_slice_split_tail, but with an option to skip altering
+     * refcounts (grpc_slice_split_tail_maybe_ref(..., true) is equivalent to
+     * grpc_slice_split_tail(...)) */
+    GPRAPI grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* s, size_t split, grpc_slice_ref_whom ref_whom);
+
+    /** Splits s into two: modifies s to be s[split:s.length], and returns a new
+       slice, sharing a refcount with s, that contains s[0:split].
+       Requires s initialized, split <= s.length */
+    GPRAPI grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split);
+
+    GPRAPI grpc_slice grpc_empty_slice(void);
+
+    GPRAPI int grpc_slice_eq(grpc_slice a, grpc_slice b);
+
+    /** Returns <0 if a < b, ==0 if a == b, >0 if a > b
+       The order is arbitrary, and is not guaranteed to be stable across different
+       versions of the API. */
+    GPRAPI int grpc_slice_cmp(grpc_slice a, grpc_slice b);
+    GPRAPI int grpc_slice_str_cmp(grpc_slice a, const char* b);
+
+    /** return non-zero if the first blen bytes of a are equal to b */
+    GPRAPI int grpc_slice_buf_start_eq(grpc_slice a, const void* b, size_t blen);
+
+    /** return the index of the last instance of \a c in \a s, or -1 if not found */
+    GPRAPI int grpc_slice_rchr(grpc_slice s, char c);
+    GPRAPI int grpc_slice_chr(grpc_slice s, char c);
+
+    /** return the index of the first occurrence of \a needle in \a haystack, or -1
+       if it's not found */
+    GPRAPI int grpc_slice_slice(grpc_slice haystack, grpc_slice needle);
+
+    /** Do two slices point at the same memory, with the same length
+       If a or b is inlined, actually compares data */
+    GPRAPI int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b);
+
+    /** Return a slice pointing to newly allocated memory that has the same contents
+     * as \a s */
+    GPRAPI grpc_slice grpc_slice_dup(grpc_slice a);
+
+    /** Return a copy of slice as a C string. Offers no protection against embedded
+       NULL's. Returned string must be freed with gpr_free. */
+    GPRAPI char* grpc_slice_to_c_string(grpc_slice s);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/slice_buffer.h b/CAPI/cpp/grpc/include/grpc/slice_buffer.h
index d8c6b91..1c14759 100644
--- a/CAPI/cpp/grpc/include/grpc/slice_buffer.h
+++ b/CAPI/cpp/grpc/include/grpc/slice_buffer.h
@@ -24,58 +24,50 @@
 #include <grpc/slice.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** initialize a slice buffer */
-GPRAPI void grpc_slice_buffer_init(grpc_slice_buffer* sb);
-/** destroy a slice buffer - unrefs any held elements */
-GPRAPI void grpc_slice_buffer_destroy(grpc_slice_buffer* sb);
-/** Add an element to a slice buffer - takes ownership of the slice.
-   This function is allowed to concatenate the passed in slice to the end of
-   some other slice if desired by the slice buffer. */
-GPRAPI void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice);
-/** add an element to a slice buffer - takes ownership of the slice and returns
-   the index of the slice.
-   Guarantees that the slice will not be concatenated at the end of another
-   slice (i.e. the data for this slice will begin at the first byte of the
-   slice at the returned index in sb->slices)
-   The implementation MAY decide to concatenate data at the end of a small
-   slice added in this fashion. */
-GPRAPI size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb,
-                                            grpc_slice slice);
-GPRAPI void grpc_slice_buffer_addn(grpc_slice_buffer* sb, grpc_slice* slices,
-                                   size_t n);
-/** add a very small (less than 8 bytes) amount of data to the end of a slice
-   buffer: returns a pointer into which to add the data */
-GPRAPI uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t len);
-/** pop the last buffer, but don't unref it */
-GPRAPI void grpc_slice_buffer_pop(grpc_slice_buffer* sb);
-/** clear a slice buffer, unref all elements */
-GPRAPI void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb);
-/** swap the contents of two slice buffers */
-GPRAPI void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b);
-/** move all of the elements of src into dst */
-GPRAPI void grpc_slice_buffer_move_into(grpc_slice_buffer* src,
-                                        grpc_slice_buffer* dst);
-/** remove n bytes from the end of a slice buffer */
-GPRAPI void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
-                                       grpc_slice_buffer* garbage);
-/** move the first n bytes of src into dst */
-GPRAPI void grpc_slice_buffer_move_first(grpc_slice_buffer* src, size_t n,
-                                         grpc_slice_buffer* dst);
-/** move the first n bytes of src into dst without adding references */
-GPRAPI void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src,
-                                                size_t n,
-                                                grpc_slice_buffer* dst);
-/** move the first n bytes of src into dst (copying them) */
-GPRAPI void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src,
-                                                     size_t n, void* dst);
-/** take the first slice in the slice buffer */
-GPRAPI grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb);
-/** undo the above with (a possibly different) \a slice */
-GPRAPI void grpc_slice_buffer_undo_take_first(grpc_slice_buffer* sb,
-                                              grpc_slice slice);
+    /** initialize a slice buffer */
+    GPRAPI void grpc_slice_buffer_init(grpc_slice_buffer* sb);
+    /** destroy a slice buffer - unrefs any held elements */
+    GPRAPI void grpc_slice_buffer_destroy(grpc_slice_buffer* sb);
+    /** Add an element to a slice buffer - takes ownership of the slice.
+       This function is allowed to concatenate the passed in slice to the end of
+       some other slice if desired by the slice buffer. */
+    GPRAPI void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice);
+    /** add an element to a slice buffer - takes ownership of the slice and returns
+       the index of the slice.
+       Guarantees that the slice will not be concatenated at the end of another
+       slice (i.e. the data for this slice will begin at the first byte of the
+       slice at the returned index in sb->slices)
+       The implementation MAY decide to concatenate data at the end of a small
+       slice added in this fashion. */
+    GPRAPI size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, grpc_slice slice);
+    GPRAPI void grpc_slice_buffer_addn(grpc_slice_buffer* sb, grpc_slice* slices, size_t n);
+    /** add a very small (less than 8 bytes) amount of data to the end of a slice
+       buffer: returns a pointer into which to add the data */
+    GPRAPI uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t len);
+    /** pop the last buffer, but don't unref it */
+    GPRAPI void grpc_slice_buffer_pop(grpc_slice_buffer* sb);
+    /** clear a slice buffer, unref all elements */
+    GPRAPI void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb);
+    /** swap the contents of two slice buffers */
+    GPRAPI void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b);
+    /** move all of the elements of src into dst */
+    GPRAPI void grpc_slice_buffer_move_into(grpc_slice_buffer* src, grpc_slice_buffer* dst);
+    /** remove n bytes from the end of a slice buffer */
+    GPRAPI void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n, grpc_slice_buffer* garbage);
+    /** move the first n bytes of src into dst */
+    GPRAPI void grpc_slice_buffer_move_first(grpc_slice_buffer* src, size_t n, grpc_slice_buffer* dst);
+    /** move the first n bytes of src into dst without adding references */
+    GPRAPI void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src, size_t n, grpc_slice_buffer* dst);
+    /** move the first n bytes of src into dst (copying them) */
+    GPRAPI void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n, void* dst);
+    /** take the first slice in the slice buffer */
+    GPRAPI grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb);
+    /** undo the above with (a possibly different) \a slice */
+    GPRAPI void grpc_slice_buffer_undo_take_first(grpc_slice_buffer* sb, grpc_slice slice);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/support/alloc.h b/CAPI/cpp/grpc/include/grpc/support/alloc.h
index d440e4b..d3799b0 100644
--- a/CAPI/cpp/grpc/include/grpc/support/alloc.h
+++ b/CAPI/cpp/grpc/include/grpc/support/alloc.h
@@ -24,26 +24,27 @@
 #include <stddef.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** malloc.
- * If size==0, always returns NULL. Otherwise this function never returns NULL.
- * The pointer returned is suitably aligned for any kind of variable it could
- * contain.
- */
-GPRAPI void* gpr_malloc(size_t size);
-/** like malloc, but zero all bytes before returning them */
-GPRAPI void* gpr_zalloc(size_t size);
-/** free */
-GPRAPI void gpr_free(void* ptr);
-/** realloc, never returns NULL */
-GPRAPI void* gpr_realloc(void* p, size_t size);
-/** aligned malloc, never returns NULL, will align to alignment, which
- * must be a power of 2. */
-GPRAPI void* gpr_malloc_aligned(size_t size, size_t alignment);
-/** free memory allocated by gpr_malloc_aligned */
-GPRAPI void gpr_free_aligned(void* ptr);
+    /** malloc.
+     * If size==0, always returns NULL. Otherwise this function never returns NULL.
+     * The pointer returned is suitably aligned for any kind of variable it could
+     * contain.
+     */
+    GPRAPI void* gpr_malloc(size_t size);
+    /** like malloc, but zero all bytes before returning them */
+    GPRAPI void* gpr_zalloc(size_t size);
+    /** free */
+    GPRAPI void gpr_free(void* ptr);
+    /** realloc, never returns NULL */
+    GPRAPI void* gpr_realloc(void* p, size_t size);
+    /** aligned malloc, never returns NULL, will align to alignment, which
+     * must be a power of 2. */
+    GPRAPI void* gpr_malloc_aligned(size_t size, size_t alignment);
+    /** free memory allocated by gpr_malloc_aligned */
+    GPRAPI void gpr_free_aligned(void* ptr);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/support/cpu.h b/CAPI/cpp/grpc/include/grpc/support/cpu.h
index f0e898e..f30f8ad 100644
--- a/CAPI/cpp/grpc/include/grpc/support/cpu.h
+++ b/CAPI/cpp/grpc/include/grpc/support/cpu.h
@@ -22,20 +22,21 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** Interface providing CPU information for currently running system */
+    /** Interface providing CPU information for currently running system */
 
-/** Return the number of CPU cores on the current system. Will return 0 if
-   the information is not available. */
-GPRAPI unsigned gpr_cpu_num_cores(void);
+    /** Return the number of CPU cores on the current system. Will return 0 if
+       the information is not available. */
+    GPRAPI unsigned gpr_cpu_num_cores(void);
 
-/** Return the CPU on which the current thread is executing; N.B. This should
-   be considered advisory only - it is possible that the thread is switched
-   to a different CPU at any time. Returns a value in range
-   [0, gpr_cpu_num_cores() - 1] */
-GPRAPI unsigned gpr_cpu_current_cpu(void);
+    /** Return the CPU on which the current thread is executing; N.B. This should
+       be considered advisory only - it is possible that the thread is switched
+       to a different CPU at any time. Returns a value in range
+       [0, gpr_cpu_num_cores() - 1] */
+    GPRAPI unsigned gpr_cpu_current_cpu(void);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/CAPI/cpp/grpc/include/grpc/support/log_windows.h b/CAPI/cpp/grpc/include/grpc/support/log_windows.h
index e833f9d..8ed3937 100644
--- a/CAPI/cpp/grpc/include/grpc/support/log_windows.h
+++ b/CAPI/cpp/grpc/include/grpc/support/log_windows.h
@@ -22,14 +22,15 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** Returns a string allocated with gpr_malloc that contains a UTF-8
- * formatted error message, corresponding to the error messageid.
- * Use in conjunction with GetLastError() et al.
- */
-GPRAPI char* gpr_format_message(int messageid);
+    /** Returns a string allocated with gpr_malloc that contains a UTF-8
+     * formatted error message, corresponding to the error messageid.
+     * Use in conjunction with GetLastError() et al.
+     */
+    GPRAPI char* gpr_format_message(int messageid);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/support/string_util.h b/CAPI/cpp/grpc/include/grpc/support/string_util.h
index 2679160..1e9f90c 100644
--- a/CAPI/cpp/grpc/include/grpc/support/string_util.h
+++ b/CAPI/cpp/grpc/include/grpc/support/string_util.h
@@ -24,25 +24,26 @@
 #include <grpc/impl/codegen/gpr_types.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** String utility functions */
+    /** String utility functions */
 
-/** Returns a copy of src that can be passed to gpr_free().
-   If allocation fails or if src is NULL, returns NULL. */
-GPRAPI char* gpr_strdup(const char* src);
+    /** Returns a copy of src that can be passed to gpr_free().
+       If allocation fails or if src is NULL, returns NULL. */
+    GPRAPI char* gpr_strdup(const char* src);
 
-/** printf to a newly-allocated string.  The set of supported formats may vary
-   between platforms.
+    /** printf to a newly-allocated string.  The set of supported formats may vary
+       between platforms.
 
-   On success, returns the number of bytes printed (excluding the final '\0'),
-   and *strp points to a string which must later be destroyed with gpr_free().
+       On success, returns the number of bytes printed (excluding the final '\0'),
+       and *strp points to a string which must later be destroyed with gpr_free().
 
-   On error, returns -1 and sets *strp to NULL. If the format string is bad,
-   the result is undefined. */
-GPRAPI int gpr_asprintf(char** strp, const char* format, ...)
-    GPR_PRINT_FORMAT_CHECK(2, 3);
+       On error, returns -1 and sets *strp to NULL. If the format string is bad,
+       the result is undefined. */
+    GPRAPI int gpr_asprintf(char** strp, const char* format, ...)
+        GPR_PRINT_FORMAT_CHECK(2, 3);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/support/sync.h b/CAPI/cpp/grpc/include/grpc/support/sync.h
index b1f5b78..34b9e5e 100644
--- a/CAPI/cpp/grpc/include/grpc/support/sync.h
+++ b/CAPI/cpp/grpc/include/grpc/support/sync.h
@@ -25,152 +25,153 @@
 #include <grpc/impl/codegen/sync.h>      // IWYU pragma: export
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** --- Mutex interface ---
-
-   At most one thread may hold an exclusive lock on a mutex at any given time.
-   Actions taken by a thread that holds a mutex exclusively happen after
-   actions taken by all previous holders of the mutex.  Variables of type
-   gpr_mu are uninitialized when first declared.  */
-
-/** Initialize *mu.  Requires:  *mu uninitialized.  */
-GPRAPI void gpr_mu_init(gpr_mu* mu);
+    /** --- Mutex interface ---
+
+       At most one thread may hold an exclusive lock on a mutex at any given time.
+       Actions taken by a thread that holds a mutex exclusively happen after
+       actions taken by all previous holders of the mutex.  Variables of type
+       gpr_mu are uninitialized when first declared.  */
+
+    /** Initialize *mu.  Requires:  *mu uninitialized.  */
+    GPRAPI void gpr_mu_init(gpr_mu* mu);
 
-/** Cause *mu no longer to be initialized, freeing any memory in use.  Requires:
- *mu initialized; no other concurrent operation on *mu.  */
-GPRAPI void gpr_mu_destroy(gpr_mu* mu);
+    /** Cause *mu no longer to be initialized, freeing any memory in use.  Requires:
+     *mu initialized; no other concurrent operation on *mu.  */
+    GPRAPI void gpr_mu_destroy(gpr_mu* mu);
 
-/** Wait until no thread has a lock on *mu, cause the calling thread to own an
-   exclusive lock on *mu, then return.  May block indefinitely or crash if the
-   calling thread has a lock on *mu.  Requires:  *mu initialized.  */
-GPRAPI void gpr_mu_lock(gpr_mu* mu);
+    /** Wait until no thread has a lock on *mu, cause the calling thread to own an
+       exclusive lock on *mu, then return.  May block indefinitely or crash if the
+       calling thread has a lock on *mu.  Requires:  *mu initialized.  */
+    GPRAPI void gpr_mu_lock(gpr_mu* mu);
 
-/** Release an exclusive lock on *mu held by the calling thread.  Requires:  *mu
-   initialized; the calling thread holds an exclusive lock on *mu.  */
-GPRAPI void gpr_mu_unlock(gpr_mu* mu);
+    /** Release an exclusive lock on *mu held by the calling thread.  Requires:  *mu
+       initialized; the calling thread holds an exclusive lock on *mu.  */
+    GPRAPI void gpr_mu_unlock(gpr_mu* mu);
 
-/** Without blocking, attempt to acquire an exclusive lock on *mu for the
-   calling thread, then return non-zero iff success.  Fail, if any thread holds
-   the lock; succeeds with high probability if no thread holds the lock.
-   Requires:  *mu initialized.  */
-GPRAPI int gpr_mu_trylock(gpr_mu* mu);
+    /** Without blocking, attempt to acquire an exclusive lock on *mu for the
+       calling thread, then return non-zero iff success.  Fail, if any thread holds
+       the lock; succeeds with high probability if no thread holds the lock.
+       Requires:  *mu initialized.  */
+    GPRAPI int gpr_mu_trylock(gpr_mu* mu);
 
-/** --- Condition variable interface ---
+    /** --- Condition variable interface ---
 
-   A while-loop should be used with gpr_cv_wait() when waiting for conditions
-   to become true.  See the example below.  Variables of type gpr_cv are
-   uninitialized when first declared.  */
+       A while-loop should be used with gpr_cv_wait() when waiting for conditions
+       to become true.  See the example below.  Variables of type gpr_cv are
+       uninitialized when first declared.  */
 
-/** Initialize *cv.  Requires:  *cv uninitialized.  */
-GPRAPI void gpr_cv_init(gpr_cv* cv);
+    /** Initialize *cv.  Requires:  *cv uninitialized.  */
+    GPRAPI void gpr_cv_init(gpr_cv* cv);
 
-/** Cause *cv no longer to be initialized, freeing any memory in use.  Requires:
- *cv initialized; no other concurrent operation on *cv.*/
-GPRAPI void gpr_cv_destroy(gpr_cv* cv);
+    /** Cause *cv no longer to be initialized, freeing any memory in use.  Requires:
+     *cv initialized; no other concurrent operation on *cv.*/
+    GPRAPI void gpr_cv_destroy(gpr_cv* cv);
 
-/** Atomically release *mu and wait on *cv.  When the calling thread is woken
-   from *cv or the deadline abs_deadline is exceeded, execute gpr_mu_lock(mu)
-   and return whether the deadline was exceeded.  Use
-   abs_deadline==gpr_inf_future for no deadline.  abs_deadline can be either
-   an absolute deadline, or a GPR_TIMESPAN.  May return even when not
-   woken explicitly.  Requires:  *mu and *cv initialized; the calling thread
-   holds an exclusive lock on *mu.  */
-GPRAPI int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline);
+    /** Atomically release *mu and wait on *cv.  When the calling thread is woken
+       from *cv or the deadline abs_deadline is exceeded, execute gpr_mu_lock(mu)
+       and return whether the deadline was exceeded.  Use
+       abs_deadline==gpr_inf_future for no deadline.  abs_deadline can be either
+       an absolute deadline, or a GPR_TIMESPAN.  May return even when not
+       woken explicitly.  Requires:  *mu and *cv initialized; the calling thread
+       holds an exclusive lock on *mu.  */
+    GPRAPI int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline);
 
-/** If any threads are waiting on *cv, wake at least one.
-   Clients may treat this as an optimization of gpr_cv_broadcast()
-   for use in the case where waking more than one waiter is not useful.
-   Requires:  *cv initialized.  */
-GPRAPI void gpr_cv_signal(gpr_cv* cv);
+    /** If any threads are waiting on *cv, wake at least one.
+       Clients may treat this as an optimization of gpr_cv_broadcast()
+       for use in the case where waking more than one waiter is not useful.
+       Requires:  *cv initialized.  */
+    GPRAPI void gpr_cv_signal(gpr_cv* cv);
 
-/** Wake all threads waiting on *cv.  Requires:  *cv initialized.  */
-GPRAPI void gpr_cv_broadcast(gpr_cv* cv);
+    /** Wake all threads waiting on *cv.  Requires:  *cv initialized.  */
+    GPRAPI void gpr_cv_broadcast(gpr_cv* cv);
 
-/** --- One-time initialization ---
+    /** --- One-time initialization ---
 
-   gpr_once must be declared with static storage class, and initialized with
-   GPR_ONCE_INIT.  e.g.,
-     static gpr_once once_var = GPR_ONCE_INIT;     */
+       gpr_once must be declared with static storage class, and initialized with
+       GPR_ONCE_INIT.  e.g.,
+         static gpr_once once_var = GPR_ONCE_INIT;     */
 
-/** Ensure that (*init_function)() has been called exactly once (for the
-   specified gpr_once instance) and then return.
-   If multiple threads call gpr_once() on the same gpr_once instance, one of
-   them will call (*init_function)(), and the others will block until that call
-   finishes.*/
-GPRAPI void gpr_once_init(gpr_once* once, void (*init_function)(void));
+    /** Ensure that (*init_function)() has been called exactly once (for the
+       specified gpr_once instance) and then return.
+       If multiple threads call gpr_once() on the same gpr_once instance, one of
+       them will call (*init_function)(), and the others will block until that call
+       finishes.*/
+    GPRAPI void gpr_once_init(gpr_once* once, void (*init_function)(void));
 
-/** --- One-time event notification ---
+    /** --- One-time event notification ---
 
-  These operations act on a gpr_event, which should be initialized with
-  gpr_ev_init(), or with GPR_EVENT_INIT if static, e.g.,
-       static gpr_event event_var = GPR_EVENT_INIT;
-  It requires no destruction.  */
+      These operations act on a gpr_event, which should be initialized with
+      gpr_ev_init(), or with GPR_EVENT_INIT if static, e.g.,
+           static gpr_event event_var = GPR_EVENT_INIT;
+      It requires no destruction.  */
 
-/** Initialize *ev. */
-GPRAPI void gpr_event_init(gpr_event* ev);
+    /** Initialize *ev. */
+    GPRAPI void gpr_event_init(gpr_event* ev);
 
-/** Set *ev so that gpr_event_get() and gpr_event_wait() will return value.
-   Requires:  *ev initialized; value != NULL; no prior or concurrent calls to
-   gpr_event_set(ev, ...) since initialization.  */
-GPRAPI void gpr_event_set(gpr_event* ev, void* value);
+    /** Set *ev so that gpr_event_get() and gpr_event_wait() will return value.
+       Requires:  *ev initialized; value != NULL; no prior or concurrent calls to
+       gpr_event_set(ev, ...) since initialization.  */
+    GPRAPI void gpr_event_set(gpr_event* ev, void* value);
 
-/** Return the value set by gpr_event_set(ev, ...), or NULL if no such call has
-   completed.  If the result is non-NULL, all operations that occurred prior to
-   the gpr_event_set(ev, ...) set will be visible after this call returns.
-   Requires:  *ev initialized.  This operation is faster than acquiring a mutex
-   on most platforms.  */
-GPRAPI void* gpr_event_get(gpr_event* ev);
+    /** Return the value set by gpr_event_set(ev, ...), or NULL if no such call has
+       completed.  If the result is non-NULL, all operations that occurred prior to
+       the gpr_event_set(ev, ...) set will be visible after this call returns.
+       Requires:  *ev initialized.  This operation is faster than acquiring a mutex
+       on most platforms.  */
+    GPRAPI void* gpr_event_get(gpr_event* ev);
 
-/** Wait until *ev is set by gpr_event_set(ev, ...), or abs_deadline is
-   exceeded, then return gpr_event_get(ev).  Requires:  *ev initialized.  Use
-   abs_deadline==gpr_inf_future for no deadline.  When the event has been
-   signalled before the call, this operation is faster than acquiring a mutex
-   on most platforms.  */
-GPRAPI void* gpr_event_wait(gpr_event* ev, gpr_timespec abs_deadline);
+    /** Wait until *ev is set by gpr_event_set(ev, ...), or abs_deadline is
+       exceeded, then return gpr_event_get(ev).  Requires:  *ev initialized.  Use
+       abs_deadline==gpr_inf_future for no deadline.  When the event has been
+       signalled before the call, this operation is faster than acquiring a mutex
+       on most platforms.  */
+    GPRAPI void* gpr_event_wait(gpr_event* ev, gpr_timespec abs_deadline);
 
-/** --- Reference counting ---
-
-   These calls act on the type gpr_refcount.  It requires no destruction.  */
+    /** --- Reference counting ---
+
+       These calls act on the type gpr_refcount.  It requires no destruction.  */
 
-/** Initialize *r to value n.  */
-GPRAPI void gpr_ref_init(gpr_refcount* r, int n);
+    /** Initialize *r to value n.  */
+    GPRAPI void gpr_ref_init(gpr_refcount* r, int n);
 
-/** Increment the reference count *r.  Requires *r initialized. */
-GPRAPI void gpr_ref(gpr_refcount* r);
-
-/** Increment the reference count *r.  Requires *r initialized.
-   Crashes if refcount is zero */
-GPRAPI void gpr_ref_non_zero(gpr_refcount* r);
-
-/** Increment the reference count *r by n.  Requires *r initialized, n > 0. */
-GPRAPI void gpr_refn(gpr_refcount* r, int n);
+    /** Increment the reference count *r.  Requires *r initialized. */
+    GPRAPI void gpr_ref(gpr_refcount* r);
+
+    /** Increment the reference count *r.  Requires *r initialized.
+       Crashes if refcount is zero */
+    GPRAPI void gpr_ref_non_zero(gpr_refcount* r);
+
+    /** Increment the reference count *r by n.  Requires *r initialized, n > 0. */
+    GPRAPI void gpr_refn(gpr_refcount* r, int n);
 
-/** Decrement the reference count *r and return non-zero iff it has reached
-   zero. .  Requires *r initialized. */
-GPRAPI int gpr_unref(gpr_refcount* r);
+    /** Decrement the reference count *r and return non-zero iff it has reached
+       zero. .  Requires *r initialized. */
+    GPRAPI int gpr_unref(gpr_refcount* r);
 
-/** Return non-zero iff the reference count of *r is one, and thus is owned
-   by exactly one object. */
-GPRAPI int gpr_ref_is_unique(gpr_refcount* r);
+    /** Return non-zero iff the reference count of *r is one, and thus is owned
+       by exactly one object. */
+    GPRAPI int gpr_ref_is_unique(gpr_refcount* r);
 
-/** --- Stats counters ---
+    /** --- Stats counters ---
 
-   These calls act on the integral type gpr_stats_counter.  It requires no
-   destruction.  Static instances may be initialized with
-       gpr_stats_counter c = GPR_STATS_INIT;
-   Beware:  These operations do not imply memory barriers.  Do not use them to
-   synchronize other events.  */
+       These calls act on the integral type gpr_stats_counter.  It requires no
+       destruction.  Static instances may be initialized with
+           gpr_stats_counter c = GPR_STATS_INIT;
+       Beware:  These operations do not imply memory barriers.  Do not use them to
+       synchronize other events.  */
 
-/** Initialize *c to the value n. */
-GPRAPI void gpr_stats_init(gpr_stats_counter* c, intptr_t n);
+    /** Initialize *c to the value n. */
+    GPRAPI void gpr_stats_init(gpr_stats_counter* c, intptr_t n);
 
-/** *c += inc.  Requires: *c initialized. */
-GPRAPI void gpr_stats_inc(gpr_stats_counter* c, intptr_t inc);
+    /** *c += inc.  Requires: *c initialized. */
+    GPRAPI void gpr_stats_inc(gpr_stats_counter* c, intptr_t inc);
 
-/** Return *c.  Requires: *c initialized. */
-GPRAPI intptr_t gpr_stats_read(const gpr_stats_counter* c);
+    /** Return *c.  Requires: *c initialized. */
+    GPRAPI intptr_t gpr_stats_read(const gpr_stats_counter* c);
 
 /** ==================Example use of interface===================
    A producer-consumer queue of up to N integers,
diff --git a/CAPI/cpp/grpc/include/grpc/support/thd_id.h b/CAPI/cpp/grpc/include/grpc/support/thd_id.h
index e9b2b7e..191131c 100644
--- a/CAPI/cpp/grpc/include/grpc/support/thd_id.h
+++ b/CAPI/cpp/grpc/include/grpc/support/thd_id.h
@@ -29,13 +29,14 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-typedef uintptr_t gpr_thd_id;
+    typedef uintptr_t gpr_thd_id;
 
-/** Returns the identifier of the current thread. */
-GPRAPI gpr_thd_id gpr_thd_currentid(void);
+    /** Returns the identifier of the current thread. */
+    GPRAPI gpr_thd_id gpr_thd_currentid(void);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/support/time.h b/CAPI/cpp/grpc/include/grpc/support/time.h
index a193dbc..b350da6 100644
--- a/CAPI/cpp/grpc/include/grpc/support/time.h
+++ b/CAPI/cpp/grpc/include/grpc/support/time.h
@@ -27,14 +27,15 @@
 #include <grpc/impl/codegen/gpr_types.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** Time constants. */
-GPRAPI gpr_timespec
-gpr_time_0(gpr_clock_type type); /** The zero time interval. */
-GPRAPI gpr_timespec gpr_inf_future(gpr_clock_type type); /** The far future */
-GPRAPI gpr_timespec gpr_inf_past(gpr_clock_type type);   /** The far past. */
+    /** Time constants. */
+    GPRAPI gpr_timespec
+        gpr_time_0(gpr_clock_type type);                     /** The zero time interval. */
+    GPRAPI gpr_timespec gpr_inf_future(gpr_clock_type type); /** The far future */
+    GPRAPI gpr_timespec gpr_inf_past(gpr_clock_type type);   /** The far past. */
 
 #define GPR_MS_PER_SEC 1000
 #define GPR_US_PER_SEC 1000000
@@ -43,47 +44,45 @@ GPRAPI gpr_timespec gpr_inf_past(gpr_clock_type type);   /** The far past. */
 #define GPR_NS_PER_US 1000
 #define GPR_US_PER_MS 1000
 
-/** initialize time subsystem */
-GPRAPI void gpr_time_init(void);
+    /** initialize time subsystem */
+    GPRAPI void gpr_time_init(void);
 
-/** Return the current time measured from the given clocks epoch. */
-GPRAPI gpr_timespec gpr_now(gpr_clock_type clock);
+    /** Return the current time measured from the given clocks epoch. */
+    GPRAPI gpr_timespec gpr_now(gpr_clock_type clock);
 
-/** Convert a timespec from one clock to another */
-GPRAPI gpr_timespec gpr_convert_clock_type(gpr_timespec t,
-                                           gpr_clock_type clock_type);
+    /** Convert a timespec from one clock to another */
+    GPRAPI gpr_timespec gpr_convert_clock_type(gpr_timespec t, gpr_clock_type clock_type);
 
-/** Return -ve, 0, or +ve according to whether a < b, a == b, or a > b
-   respectively.  */
-GPRAPI int gpr_time_cmp(gpr_timespec a, gpr_timespec b);
+    /** Return -ve, 0, or +ve according to whether a < b, a == b, or a > b
+       respectively.  */
+    GPRAPI int gpr_time_cmp(gpr_timespec a, gpr_timespec b);
 
-GPRAPI gpr_timespec gpr_time_max(gpr_timespec a, gpr_timespec b);
-GPRAPI gpr_timespec gpr_time_min(gpr_timespec a, gpr_timespec b);
+    GPRAPI gpr_timespec gpr_time_max(gpr_timespec a, gpr_timespec b);
+    GPRAPI gpr_timespec gpr_time_min(gpr_timespec a, gpr_timespec b);
 
-/** Add and subtract times.  Calculations saturate at infinities. */
-GPRAPI gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b);
-GPRAPI gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b);
+    /** Add and subtract times.  Calculations saturate at infinities. */
+    GPRAPI gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b);
+    GPRAPI gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b);
 
-/** Return a timespec representing a given number of time units. INT64_MIN is
-   interpreted as gpr_inf_past, and INT64_MAX as gpr_inf_future.  */
-GPRAPI gpr_timespec gpr_time_from_micros(int64_t us, gpr_clock_type clock_type);
-GPRAPI gpr_timespec gpr_time_from_nanos(int64_t ns, gpr_clock_type clock_type);
-GPRAPI gpr_timespec gpr_time_from_millis(int64_t ms, gpr_clock_type clock_type);
-GPRAPI gpr_timespec gpr_time_from_seconds(int64_t s, gpr_clock_type clock_type);
-GPRAPI gpr_timespec gpr_time_from_minutes(int64_t m, gpr_clock_type clock_type);
-GPRAPI gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type clock_type);
+    /** Return a timespec representing a given number of time units. INT64_MIN is
+       interpreted as gpr_inf_past, and INT64_MAX as gpr_inf_future.  */
+    GPRAPI gpr_timespec gpr_time_from_micros(int64_t us, gpr_clock_type clock_type);
+    GPRAPI gpr_timespec gpr_time_from_nanos(int64_t ns, gpr_clock_type clock_type);
+    GPRAPI gpr_timespec gpr_time_from_millis(int64_t ms, gpr_clock_type clock_type);
+    GPRAPI gpr_timespec gpr_time_from_seconds(int64_t s, gpr_clock_type clock_type);
+    GPRAPI gpr_timespec gpr_time_from_minutes(int64_t m, gpr_clock_type clock_type);
+    GPRAPI gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type clock_type);
 
-GPRAPI int32_t gpr_time_to_millis(gpr_timespec timespec);
+    GPRAPI int32_t gpr_time_to_millis(gpr_timespec timespec);
 
-/** Return 1 if two times are equal or within threshold of each other,
-   0 otherwise */
-GPRAPI int gpr_time_similar(gpr_timespec a, gpr_timespec b,
-                            gpr_timespec threshold);
+    /** Return 1 if two times are equal or within threshold of each other,
+       0 otherwise */
+    GPRAPI int gpr_time_similar(gpr_timespec a, gpr_timespec b, gpr_timespec threshold);
 
-/** Sleep until at least 'until' - an absolute timeout */
-GPRAPI void gpr_sleep_until(gpr_timespec until);
+    /** Sleep until at least 'until' - an absolute timeout */
+    GPRAPI void gpr_sleep_until(gpr_timespec until);
 
-GPRAPI double gpr_timespec_to_micros(gpr_timespec t);
+    GPRAPI double gpr_timespec_to_micros(gpr_timespec t);
 
 #ifdef __cplusplus
 }
diff --git a/CAPI/cpp/grpc/include/grpc/support/workaround_list.h b/CAPI/cpp/grpc/include/grpc/support/workaround_list.h
index e28dfa1..e071307 100644
--- a/CAPI/cpp/grpc/include/grpc/support/workaround_list.h
+++ b/CAPI/cpp/grpc/include/grpc/support/workaround_list.h
@@ -23,9 +23,10 @@
  * explanation and detailed descriptions of workarounds, see
  * /doc/workarounds.md
  */
-typedef enum {
-  GRPC_WORKAROUND_ID_CRONET_COMPRESSION = 0,
-  GRPC_MAX_WORKAROUND_ID
+typedef enum
+{
+    GRPC_WORKAROUND_ID_CRONET_COMPRESSION = 0,
+    GRPC_MAX_WORKAROUND_ID
 } grpc_workaround_list;
 
 #endif /* GRPC_SUPPORT_WORKAROUND_LIST_H */
diff --git a/CAPI/cpp/grpc/include/grpcpp/alarm.h b/CAPI/cpp/grpc/include/grpcpp/alarm.h
index 1b5ddfe..527624e 100644
--- a/CAPI/cpp/grpc/include/grpcpp/alarm.h
+++ b/CAPI/cpp/grpc/include/grpcpp/alarm.h
@@ -30,71 +30,82 @@
 #include <grpcpp/impl/codegen/time.h>
 #include <grpcpp/impl/grpc_library.h>
 
-namespace grpc {
-
-class Alarm : private grpc::GrpcLibraryCodegen {
- public:
-  /// Create an unset completion queue alarm
-  Alarm();
-
-  /// Destroy the given completion queue alarm, cancelling it in the process.
-  ~Alarm() override;
-
-  /// DEPRECATED: Create and set a completion queue alarm instance associated to
-  /// \a cq.
-  /// This form is deprecated because it is inherently racy.
-  /// \internal We rely on the presence of \a cq for grpc initialization. If \a
-  /// cq were ever to be removed, a reference to a static
-  /// internal::GrpcLibraryInitializer instance would need to be introduced
-  /// here. \endinternal.
-  template <typename T>
-  Alarm(grpc::CompletionQueue* cq, const T& deadline, void* tag) : Alarm() {
-    SetInternal(cq, grpc::TimePoint<T>(deadline).raw_time(), tag);
-  }
-
-  /// Trigger an alarm instance on completion queue \a cq at the specified time.
-  /// Once the alarm expires (at \a deadline) or it's cancelled (see \a Cancel),
-  /// an event with tag \a tag will be added to \a cq. If the alarm expired, the
-  /// event's success bit will be true, false otherwise (ie, upon cancellation).
-  //
-  // USAGE NOTE: This is frequently used to inject arbitrary tags into \a cq by
-  // setting an immediate deadline. Such usage allows synchronizing an external
-  // event with an application's \a grpc::CompletionQueue::Next loop.
-  template <typename T>
-  void Set(grpc::CompletionQueue* cq, const T& deadline, void* tag) {
-    SetInternal(cq, grpc::TimePoint<T>(deadline).raw_time(), tag);
-  }
-
-  /// Alarms aren't copyable.
-  Alarm(const Alarm&) = delete;
-  Alarm& operator=(const Alarm&) = delete;
-
-  /// Alarms are movable.
-  Alarm(Alarm&& rhs) noexcept : alarm_(rhs.alarm_) { rhs.alarm_ = nullptr; }
-  Alarm& operator=(Alarm&& rhs) noexcept {
-    alarm_ = rhs.alarm_;
-    rhs.alarm_ = nullptr;
-    return *this;
-  }
-
-  /// Cancel a completion queue alarm. Calling this function over an alarm that
-  /// has already fired has no effect.
-  void Cancel();
-
-  /// Set an alarm to invoke callback \a f. The argument to the callback
-  /// states whether the alarm expired at \a deadline (true) or was cancelled
-  /// (false)
-  template <typename T>
-  void Set(const T& deadline, std::function<void(bool)> f) {
-    SetInternal(grpc::TimePoint<T>(deadline).raw_time(), std::move(f));
-  }
-
- private:
-  void SetInternal(grpc::CompletionQueue* cq, gpr_timespec deadline, void* tag);
-  void SetInternal(gpr_timespec deadline, std::function<void(bool)> f);
-
-  grpc::internal::CompletionQueueTag* alarm_;
-};
+namespace grpc
+{
+
+    class Alarm : private grpc::GrpcLibraryCodegen
+    {
+    public:
+        /// Create an unset completion queue alarm
+        Alarm();
+
+        /// Destroy the given completion queue alarm, cancelling it in the process.
+        ~Alarm() override;
+
+        /// DEPRECATED: Create and set a completion queue alarm instance associated to
+        /// \a cq.
+        /// This form is deprecated because it is inherently racy.
+        /// \internal We rely on the presence of \a cq for grpc initialization. If \a
+        /// cq were ever to be removed, a reference to a static
+        /// internal::GrpcLibraryInitializer instance would need to be introduced
+        /// here. \endinternal.
+        template<typename T>
+        Alarm(grpc::CompletionQueue* cq, const T& deadline, void* tag) :
+            Alarm()
+        {
+            SetInternal(cq, grpc::TimePoint<T>(deadline).raw_time(), tag);
+        }
+
+        /// Trigger an alarm instance on completion queue \a cq at the specified time.
+        /// Once the alarm expires (at \a deadline) or it's cancelled (see \a Cancel),
+        /// an event with tag \a tag will be added to \a cq. If the alarm expired, the
+        /// event's success bit will be true, false otherwise (ie, upon cancellation).
+        //
+        // USAGE NOTE: This is frequently used to inject arbitrary tags into \a cq by
+        // setting an immediate deadline. Such usage allows synchronizing an external
+        // event with an application's \a grpc::CompletionQueue::Next loop.
+        template<typename T>
+        void Set(grpc::CompletionQueue* cq, const T& deadline, void* tag)
+        {
+            SetInternal(cq, grpc::TimePoint<T>(deadline).raw_time(), tag);
+        }
+
+        /// Alarms aren't copyable.
+        Alarm(const Alarm&) = delete;
+        Alarm& operator=(const Alarm&) = delete;
+
+        /// Alarms are movable.
+        Alarm(Alarm&& rhs) noexcept :
+            alarm_(rhs.alarm_)
+        {
+            rhs.alarm_ = nullptr;
+        }
+        Alarm& operator=(Alarm&& rhs) noexcept
+        {
+            alarm_ = rhs.alarm_;
+            rhs.alarm_ = nullptr;
+            return *this;
+        }
+
+        /// Cancel a completion queue alarm. Calling this function over an alarm that
+        /// has already fired has no effect.
+        void Cancel();
+
+        /// Set an alarm to invoke callback \a f. The argument to the callback
+        /// states whether the alarm expired at \a deadline (true) or was cancelled
+        /// (false)
+        template<typename T>
+        void Set(const T& deadline, std::function<void(bool)> f)
+        {
+            SetInternal(grpc::TimePoint<T>(deadline).raw_time(), std::move(f));
+        }
+
+    private:
+        void SetInternal(grpc::CompletionQueue* cq, gpr_timespec deadline, void* tag);
+        void SetInternal(gpr_timespec deadline, std::function<void(bool)> f);
+
+        grpc::internal::CompletionQueueTag* alarm_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/channel.h b/CAPI/cpp/grpc/include/grpcpp/channel.h
index ec8702e..a68b067 100644
--- a/CAPI/cpp/grpc/include/grpcpp/channel.h
+++ b/CAPI/cpp/grpc/include/grpcpp/channel.h
@@ -32,94 +32,82 @@
 
 struct grpc_channel;
 
-namespace grpc {
-namespace testing {
-class ChannelTestPeer;
-}  // namespace testing
-
-std::shared_ptr<Channel> CreateChannelInternal(
-    const std::string& host, grpc_channel* c_channel,
-    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-        interceptor_creators);
-
-namespace experimental {
-/// Resets the channel's connection backoff.
-/// TODO(roth): Once we see whether this proves useful, either create a gRFC
-/// and change this to be a method of the Channel class, or remove it.
-void ChannelResetConnectionBackoff(Channel* channel);
-}  // namespace experimental
-
-/// Channels represent a connection to an endpoint. Created by \a CreateChannel.
-class Channel final : public grpc::ChannelInterface,
-                      public grpc::internal::CallHook,
-                      public std::enable_shared_from_this<Channel>,
-                      private grpc::GrpcLibraryCodegen {
- public:
-  ~Channel() override;
-
-  /// Get the current channel state. If the channel is in IDLE and
-  /// \a try_to_connect is set to true, try to connect.
-  grpc_connectivity_state GetState(bool try_to_connect) override;
-
-  /// Returns the LB policy name, or the empty string if not yet available.
-  std::string GetLoadBalancingPolicyName() const;
-
-  /// Returns the service config in JSON form, or the empty string if
-  /// not available.
-  std::string GetServiceConfigJSON() const;
-
- private:
-  template <class InputMessage, class OutputMessage>
-  friend class grpc::internal::BlockingUnaryCallImpl;
-  friend class grpc::testing::ChannelTestPeer;
-  friend void experimental::ChannelResetConnectionBackoff(Channel* channel);
-  friend std::shared_ptr<Channel> grpc::CreateChannelInternal(
-      const std::string& host, grpc_channel* c_channel,
-      std::vector<std::unique_ptr<
-          grpc::experimental::ClientInterceptorFactoryInterface>>
-          interceptor_creators);
-  friend class grpc::internal::InterceptedChannel;
-  Channel(const std::string& host, grpc_channel* c_channel,
-          std::vector<std::unique_ptr<
-              grpc::experimental::ClientInterceptorFactoryInterface>>
-              interceptor_creators);
-
-  grpc::internal::Call CreateCall(const grpc::internal::RpcMethod& method,
-                                  grpc::ClientContext* context,
-                                  grpc::CompletionQueue* cq) override;
-  void PerformOpsOnCall(grpc::internal::CallOpSetInterface* ops,
-                        grpc::internal::Call* call) override;
-  void* RegisterMethod(const char* method) override;
-
-  void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
-                               gpr_timespec deadline, grpc::CompletionQueue* cq,
-                               void* tag) override;
-  bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
-                              gpr_timespec deadline) override;
-
-  grpc::CompletionQueue* CallbackCQ() override;
-
-  grpc::internal::Call CreateCallInternal(
-      const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
-      grpc::CompletionQueue* cq, size_t interceptor_pos) override;
-
-  const std::string host_;
-  grpc_channel* const c_channel_;  // owned
-
-  // mu_ protects callback_cq_ (the per-channel callbackable completion queue)
-  grpc::internal::Mutex mu_;
-
-  // callback_cq_ references the callbackable completion queue associated
-  // with this channel (if any). It is set on the first call to CallbackCQ().
-  // It is _not owned_ by the channel; ownership belongs with its internal
-  // shutdown callback tag (invoked when the CQ is fully shutdown).
-  std::atomic<CompletionQueue*> callback_cq_{nullptr};
-
-  std::vector<
-      std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
-      interceptor_creators_;
-};
+namespace grpc
+{
+    namespace testing
+    {
+        class ChannelTestPeer;
+    }  // namespace testing
+
+    std::shared_ptr<Channel> CreateChannelInternal(
+        const std::string& host, grpc_channel* c_channel, std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>> interceptor_creators
+    );
+
+    namespace experimental
+    {
+        /// Resets the channel's connection backoff.
+        /// TODO(roth): Once we see whether this proves useful, either create a gRFC
+        /// and change this to be a method of the Channel class, or remove it.
+        void ChannelResetConnectionBackoff(Channel* channel);
+    }  // namespace experimental
+
+    /// Channels represent a connection to an endpoint. Created by \a CreateChannel.
+    class Channel final : public grpc::ChannelInterface, public grpc::internal::CallHook, public std::enable_shared_from_this<Channel>, private grpc::GrpcLibraryCodegen
+    {
+    public:
+        ~Channel() override;
+
+        /// Get the current channel state. If the channel is in IDLE and
+        /// \a try_to_connect is set to true, try to connect.
+        grpc_connectivity_state GetState(bool try_to_connect) override;
+
+        /// Returns the LB policy name, or the empty string if not yet available.
+        std::string GetLoadBalancingPolicyName() const;
+
+        /// Returns the service config in JSON form, or the empty string if
+        /// not available.
+        std::string GetServiceConfigJSON() const;
+
+    private:
+        template<class InputMessage, class OutputMessage>
+        friend class grpc::internal::BlockingUnaryCallImpl;
+        friend class grpc::testing::ChannelTestPeer;
+        friend void experimental::ChannelResetConnectionBackoff(Channel* channel);
+        friend std::shared_ptr<Channel> grpc::CreateChannelInternal(
+            const std::string& host, grpc_channel* c_channel, std::vector<std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> interceptor_creators
+        );
+        friend class grpc::internal::InterceptedChannel;
+        Channel(const std::string& host, grpc_channel* c_channel, std::vector<std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> interceptor_creators);
+
+        grpc::internal::Call CreateCall(const grpc::internal::RpcMethod& method, grpc::ClientContext* context, grpc::CompletionQueue* cq) override;
+        void PerformOpsOnCall(grpc::internal::CallOpSetInterface* ops, grpc::internal::Call* call) override;
+        void* RegisterMethod(const char* method) override;
+
+        void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, gpr_timespec deadline, grpc::CompletionQueue* cq, void* tag) override;
+        bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, gpr_timespec deadline) override;
+
+        grpc::CompletionQueue* CallbackCQ() override;
+
+        grpc::internal::Call CreateCallInternal(
+            const grpc::internal::RpcMethod& method, grpc::ClientContext* context, grpc::CompletionQueue* cq, size_t interceptor_pos
+        ) override;
+
+        const std::string host_;
+        grpc_channel* const c_channel_;  // owned
+
+        // mu_ protects callback_cq_ (the per-channel callbackable completion queue)
+        grpc::internal::Mutex mu_;
+
+        // callback_cq_ references the callbackable completion queue associated
+        // with this channel (if any). It is set on the first call to CallbackCQ().
+        // It is _not owned_ by the channel; ownership belongs with its internal
+        // shutdown callback tag (invoked when the CQ is fully shutdown).
+        std::atomic<CompletionQueue*> callback_cq_{nullptr};
+
+        std::vector<
+            std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+            interceptor_creators_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/create_channel.h b/CAPI/cpp/grpc/include/grpcpp/create_channel.h
index 4b94a08..479a670 100644
--- a/CAPI/cpp/grpc/include/grpcpp/create_channel.h
+++ b/CAPI/cpp/grpc/include/grpcpp/create_channel.h
@@ -27,52 +27,57 @@
 #include <grpcpp/support/channel_arguments.h>
 #include <grpcpp/support/config.h>
 
-namespace grpc {
-/// Create a new \a Channel pointing to \a target.
-///
-/// \param target The URI of the endpoint to connect to.
-/// \param creds Credentials to use for the created channel. If it does not
-/// hold an object or is invalid, a lame channel (one on which all operations
-/// fail) is returned.
-std::shared_ptr<Channel> CreateChannel(
-    const grpc::string& target,
-    const std::shared_ptr<ChannelCredentials>& creds);
+namespace grpc
+{
+    /// Create a new \a Channel pointing to \a target.
+    ///
+    /// \param target The URI of the endpoint to connect to.
+    /// \param creds Credentials to use for the created channel. If it does not
+    /// hold an object or is invalid, a lame channel (one on which all operations
+    /// fail) is returned.
+    std::shared_ptr<Channel> CreateChannel(
+        const grpc::string& target,
+        const std::shared_ptr<ChannelCredentials>& creds
+    );
 
-/// Create a new \em custom \a Channel pointing to \a target.
-///
-/// \warning For advanced use and testing ONLY. Override default channel
-/// arguments only if necessary.
-///
-/// \param target The URI of the endpoint to connect to.
-/// \param creds Credentials to use for the created channel. If it does not
-/// hold an object or is invalid, a lame channel (one on which all operations
-/// fail) is returned.
-/// \param args Options for channel creation.
-std::shared_ptr<Channel> CreateCustomChannel(
-    const grpc::string& target,
-    const std::shared_ptr<ChannelCredentials>& creds,
-    const ChannelArguments& args);
+    /// Create a new \em custom \a Channel pointing to \a target.
+    ///
+    /// \warning For advanced use and testing ONLY. Override default channel
+    /// arguments only if necessary.
+    ///
+    /// \param target The URI of the endpoint to connect to.
+    /// \param creds Credentials to use for the created channel. If it does not
+    /// hold an object or is invalid, a lame channel (one on which all operations
+    /// fail) is returned.
+    /// \param args Options for channel creation.
+    std::shared_ptr<Channel> CreateCustomChannel(
+        const grpc::string& target,
+        const std::shared_ptr<ChannelCredentials>& creds,
+        const ChannelArguments& args
+    );
 
-namespace experimental {
-/// Create a new \em custom \a Channel pointing to \a target with \a
-/// interceptors being invoked per call.
-///
-/// \warning For advanced use and testing ONLY. Override default channel
-/// arguments only if necessary.
-///
-/// \param target The URI of the endpoint to connect to.
-/// \param creds Credentials to use for the created channel. If it does not
-/// hold an object or is invalid, a lame channel (one on which all operations
-/// fail) is returned.
-/// \param args Options for channel creation.
-std::shared_ptr<Channel> CreateCustomChannelWithInterceptors(
-    const grpc::string& target,
-    const std::shared_ptr<ChannelCredentials>& creds,
-    const ChannelArguments& args,
-    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-        interceptor_creators);
-}  // namespace experimental
+    namespace experimental
+    {
+        /// Create a new \em custom \a Channel pointing to \a target with \a
+        /// interceptors being invoked per call.
+        ///
+        /// \warning For advanced use and testing ONLY. Override default channel
+        /// arguments only if necessary.
+        ///
+        /// \param target The URI of the endpoint to connect to.
+        /// \param creds Credentials to use for the created channel. If it does not
+        /// hold an object or is invalid, a lame channel (one on which all operations
+        /// fail) is returned.
+        /// \param args Options for channel creation.
+        std::shared_ptr<Channel> CreateCustomChannelWithInterceptors(
+            const grpc::string& target,
+            const std::shared_ptr<ChannelCredentials>& creds,
+            const ChannelArguments& args,
+            std::vector<
+                std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
+                interceptor_creators
+        );
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_CREATE_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/create_channel_binder.h b/CAPI/cpp/grpc/include/grpcpp/create_channel_binder.h
index 4bfe952..9178761 100644
--- a/CAPI/cpp/grpc/include/grpcpp/create_channel_binder.h
+++ b/CAPI/cpp/grpc/include/grpcpp/create_channel_binder.h
@@ -29,96 +29,93 @@
 #include <grpcpp/security/binder_security_policy.h>
 #include <grpcpp/support/channel_arguments.h>
 
-namespace grpc {
-namespace experimental {
-
-/// EXPERIMENTAL Create a new \a Channel based on binder transport. The package
-/// name and class name will be used identify the specific application component
-/// to connect to.
-///
-/// \param jni_env Pointer to a JNIEnv structure
-/// \param context The context that we will use to invoke \a bindService See
-/// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
-/// for detail.
-/// \param package_name Package name of the component to be connected to
-/// \param class_name Class name of the component to be connected to
-/// \param security_policy Used for checking if remote component is allowed to
-/// connect
-std::shared_ptr<grpc::Channel> CreateBinderChannel(
-    void* jni_env, jobject context, absl::string_view package_name,
-    absl::string_view class_name,
-    std::shared_ptr<grpc::experimental::binder::SecurityPolicy>
-        security_policy);
-
-/// EXPERIMENTAL Create a new \a Channel based on binder transport. The package
-/// name and class name will be used identify the specific application component
-/// to connect to.
-///
-/// \param jni_env Pointer to a JNIEnv structure
-/// \param context The context that we will use to invoke \a bindService See
-/// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
-/// for detail.
-/// \param package_name Package name of the component to be connected to
-/// \param class_name Class name of the component to be connected to
-/// \param security_policy Used for checking if remote component is allowed to
-/// connect
-/// \param args Options for channel creation.
-std::shared_ptr<grpc::Channel> CreateCustomBinderChannel(
-    void* jni_env_void, jobject application, absl::string_view package_name,
-    absl::string_view class_name,
-    std::shared_ptr<grpc::experimental::binder::SecurityPolicy> security_policy,
-    const ChannelArguments& args);
-
-/// EXPERIMENTAL Create a new \a Channel based on binder transport.
-///
-/// \param jni_env Pointer to a JNIEnv structure
-/// \param context The context that we will use to invoke \a bindService See
-/// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
-/// for detail.
-/// \param uri An URI that can be parsed as an `Intent` with
-/// https://developer.android.com/reference/android/content/Intent#parseUri(java.lang.String,%20int)
-/// \param security_policy Used for checking if remote component is allowed to
-/// connect
-std::shared_ptr<grpc::Channel> CreateBinderChannel(
-    void* jni_env, jobject context, absl::string_view uri,
-    std::shared_ptr<grpc::experimental::binder::SecurityPolicy>
-        security_policy);
-
-/// EXPERIMENTAL Create a new \a Channel based on binder transport.
-///
-/// \param jni_env Pointer to a JNIEnv structure
-/// \param context The context that we will use to invoke \a bindService See
-/// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
-/// for detail.
-/// \param uri An URI that can be parsed as an `Intent` with
-/// https://developer.android.com/reference/android/content/Intent#parseUri(java.lang.String,%20int)
-/// \param security_policy Used for checking if remote component is allowed to
-/// connect
-/// \param args Options for channel creation.
-std::shared_ptr<grpc::Channel> CreateCustomBinderChannel(
-    void* jni_env, jobject context, absl::string_view uri,
-    std::shared_ptr<grpc::experimental::binder::SecurityPolicy> security_policy,
-    const ChannelArguments& args);
-
-/// EXPERIMENTAL Finds internal binder transport Java code. To create channels
-/// in threads created in native code, it is required to call this function
-/// once beforehand in a thread that is not created in native code.
-/// See
-/// https://developer.android.com/training/articles/perf-jni#faq:-why-didnt-findclass-find-my-class
-/// for details of this limitation.
-/// Returns true when the initialization is successful.
-bool InitializeBinderChannelJavaClass(void* jni_env_void);
-
-/// EXPERIMENTAL Alternative version of `InitializeBinderChannelJavaClass(void*
-/// jni_env_void)`. This version used a user-specified function to find the
-/// required internal Java class. When a class is found, the `class_finder`
-/// function should return a local reference to the class (jclass type). The
-/// returned jclass will then be used to create global reference for gRPC to use
-/// it later. After that, gRPC will DeleteLocalRef the returned local reference.
-bool InitializeBinderChannelJavaClass(
-    void* jni_env_void, std::function<void*(std::string)> class_finder);
-
-}  // namespace experimental
+namespace grpc
+{
+    namespace experimental
+    {
+
+        /// EXPERIMENTAL Create a new \a Channel based on binder transport. The package
+        /// name and class name will be used identify the specific application component
+        /// to connect to.
+        ///
+        /// \param jni_env Pointer to a JNIEnv structure
+        /// \param context The context that we will use to invoke \a bindService See
+        /// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
+        /// for detail.
+        /// \param package_name Package name of the component to be connected to
+        /// \param class_name Class name of the component to be connected to
+        /// \param security_policy Used for checking if remote component is allowed to
+        /// connect
+        std::shared_ptr<grpc::Channel> CreateBinderChannel(
+            void* jni_env, jobject context, absl::string_view package_name, absl::string_view class_name, std::shared_ptr<grpc::experimental::binder::SecurityPolicy> security_policy
+        );
+
+        /// EXPERIMENTAL Create a new \a Channel based on binder transport. The package
+        /// name and class name will be used identify the specific application component
+        /// to connect to.
+        ///
+        /// \param jni_env Pointer to a JNIEnv structure
+        /// \param context The context that we will use to invoke \a bindService See
+        /// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
+        /// for detail.
+        /// \param package_name Package name of the component to be connected to
+        /// \param class_name Class name of the component to be connected to
+        /// \param security_policy Used for checking if remote component is allowed to
+        /// connect
+        /// \param args Options for channel creation.
+        std::shared_ptr<grpc::Channel> CreateCustomBinderChannel(
+            void* jni_env_void, jobject application, absl::string_view package_name, absl::string_view class_name, std::shared_ptr<grpc::experimental::binder::SecurityPolicy> security_policy, const ChannelArguments& args
+        );
+
+        /// EXPERIMENTAL Create a new \a Channel based on binder transport.
+        ///
+        /// \param jni_env Pointer to a JNIEnv structure
+        /// \param context The context that we will use to invoke \a bindService See
+        /// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
+        /// for detail.
+        /// \param uri An URI that can be parsed as an `Intent` with
+        /// https://developer.android.com/reference/android/content/Intent#parseUri(java.lang.String,%20int)
+        /// \param security_policy Used for checking if remote component is allowed to
+        /// connect
+        std::shared_ptr<grpc::Channel> CreateBinderChannel(
+            void* jni_env, jobject context, absl::string_view uri, std::shared_ptr<grpc::experimental::binder::SecurityPolicy> security_policy
+        );
+
+        /// EXPERIMENTAL Create a new \a Channel based on binder transport.
+        ///
+        /// \param jni_env Pointer to a JNIEnv structure
+        /// \param context The context that we will use to invoke \a bindService See
+        /// https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)
+        /// for detail.
+        /// \param uri An URI that can be parsed as an `Intent` with
+        /// https://developer.android.com/reference/android/content/Intent#parseUri(java.lang.String,%20int)
+        /// \param security_policy Used for checking if remote component is allowed to
+        /// connect
+        /// \param args Options for channel creation.
+        std::shared_ptr<grpc::Channel> CreateCustomBinderChannel(
+            void* jni_env, jobject context, absl::string_view uri, std::shared_ptr<grpc::experimental::binder::SecurityPolicy> security_policy, const ChannelArguments& args
+        );
+
+        /// EXPERIMENTAL Finds internal binder transport Java code. To create channels
+        /// in threads created in native code, it is required to call this function
+        /// once beforehand in a thread that is not created in native code.
+        /// See
+        /// https://developer.android.com/training/articles/perf-jni#faq:-why-didnt-findclass-find-my-class
+        /// for details of this limitation.
+        /// Returns true when the initialization is successful.
+        bool InitializeBinderChannelJavaClass(void* jni_env_void);
+
+        /// EXPERIMENTAL Alternative version of `InitializeBinderChannelJavaClass(void*
+        /// jni_env_void)`. This version used a user-specified function to find the
+        /// required internal Java class. When a class is found, the `class_finder`
+        /// function should return a local reference to the class (jclass type). The
+        /// returned jclass will then be used to create global reference for gRPC to use
+        /// it later. After that, gRPC will DeleteLocalRef the returned local reference.
+        bool InitializeBinderChannelJavaClass(
+            void* jni_env_void, std::function<void*(std::string)> class_finder
+        );
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif
diff --git a/CAPI/cpp/grpc/include/grpcpp/create_channel_posix.h b/CAPI/cpp/grpc/include/grpcpp/create_channel_posix.h
index e6019d2..c1fa3fd 100644
--- a/CAPI/cpp/grpc/include/grpcpp/create_channel_posix.h
+++ b/CAPI/cpp/grpc/include/grpcpp/create_channel_posix.h
@@ -26,43 +26,45 @@
 #include <grpcpp/channel.h>
 #include <grpcpp/support/channel_arguments.h>
 
-namespace grpc {
+namespace grpc
+{
 
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
 
-/// Create a new \a Channel communicating over the given file descriptor.
-///
-/// \param target The name of the target.
-/// \param fd The file descriptor representing a socket.
-std::shared_ptr<grpc::Channel> CreateInsecureChannelFromFd(
-    const std::string& target, int fd);
+    /// Create a new \a Channel communicating over the given file descriptor.
+    ///
+    /// \param target The name of the target.
+    /// \param fd The file descriptor representing a socket.
+    std::shared_ptr<grpc::Channel> CreateInsecureChannelFromFd(
+        const std::string& target, int fd
+    );
 
-/// Create a new \a Channel communicating over given file descriptor with custom
-/// channel arguments.
-///
-/// \param target The name of the target.
-/// \param fd The file descriptor representing a socket.
-/// \param args Options for channel creation.
-std::shared_ptr<grpc::Channel> CreateCustomInsecureChannelFromFd(
-    const std::string& target, int fd, const grpc::ChannelArguments& args);
+    /// Create a new \a Channel communicating over given file descriptor with custom
+    /// channel arguments.
+    ///
+    /// \param target The name of the target.
+    /// \param fd The file descriptor representing a socket.
+    /// \param args Options for channel creation.
+    std::shared_ptr<grpc::Channel> CreateCustomInsecureChannelFromFd(
+        const std::string& target, int fd, const grpc::ChannelArguments& args
+    );
 
-namespace experimental {
+    namespace experimental
+    {
 
-/// Create a new \a Channel communicating over given file descriptor with custom
-/// channel arguments.
-///
-/// \param target The name of the target.
-/// \param fd The file descriptor representing a socket.
-/// \param args Options for channel creation.
-/// \param interceptor_creators Vector of interceptor factory objects.
-std::shared_ptr<grpc::Channel>
-CreateCustomInsecureChannelWithInterceptorsFromFd(
-    const std::string& target, int fd, const grpc::ChannelArguments& args,
-    std::vector<
-        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
-        interceptor_creators);
+        /// Create a new \a Channel communicating over given file descriptor with custom
+        /// channel arguments.
+        ///
+        /// \param target The name of the target.
+        /// \param fd The file descriptor representing a socket.
+        /// \param args Options for channel creation.
+        /// \param interceptor_creators Vector of interceptor factory objects.
+        std::shared_ptr<grpc::Channel>
+            CreateCustomInsecureChannelWithInterceptorsFromFd(
+                const std::string& target, int fd, const grpc::ChannelArguments& args, std::vector<std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> interceptor_creators
+            );
 
-}  // namespace experimental
+    }  // namespace experimental
 
 #endif  // GPR_SUPPORT_CHANNELS_FROM_FD
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/ext/call_metric_recorder.h b/CAPI/cpp/grpc/include/grpcpp/ext/call_metric_recorder.h
index 9c52622..0f4f39e 100644
--- a/CAPI/cpp/grpc/include/grpcpp/ext/call_metric_recorder.h
+++ b/CAPI/cpp/grpc/include/grpcpp/ext/call_metric_recorder.h
@@ -28,67 +28,71 @@
 #include <grpcpp/impl/codegen/slice.h>
 #include <grpcpp/impl/codegen/sync.h>
 
-namespace grpc_core {
-class Arena;
-struct BackendMetricData;
+namespace grpc_core
+{
+    class Arena;
+    struct BackendMetricData;
 }  // namespace grpc_core
 
-namespace grpc {
-class ServerBuilder;
-
-namespace experimental {
-class OrcaServerInterceptor;
-
-// Registers the per-rpc orca load reporter into the \a ServerBuilder.
-// Once this is done, the server will automatically send the load metrics
-// after each RPC as they were reported. In order to report load metrics,
-// call the \a ServerContext::ExperimentalGetCallMetricRecorder() method to
-// retrieve the recorder for the current call.
-void EnableCallMetricRecording(ServerBuilder*);
-
-/// Records call metrics for the purpose of load balancing.
-/// During an RPC, call \a ServerContext::ExperimentalGetCallMetricRecorder()
-/// method to retrive the recorder for the current call.
-class CallMetricRecorder {
- public:
-  explicit CallMetricRecorder(grpc_core::Arena* arena);
-  ~CallMetricRecorder();
-
-  /// Records a call metric measurement for CPU utilization.
-  /// Multiple calls to this method will override the stored value.
-  CallMetricRecorder& RecordCpuUtilizationMetric(double value);
-
-  /// Records a call metric measurement for memory utilization.
-  /// Multiple calls to this method will override the stored value.
-  CallMetricRecorder& RecordMemoryUtilizationMetric(double value);
-
-  /// Records a call metric measurement for utilization.
-  /// Multiple calls to this method with the same name will
-  /// override the corresponding stored value. The lifetime of the
-  /// name string needs to be longer than the lifetime of the RPC
-  /// itself, since it's going to be sent as trailers after the RPC
-  /// finishes. It is assumed the strings are common names that
-  /// are global constants.
-  CallMetricRecorder& RecordUtilizationMetric(string_ref name, double value);
-
-  /// Records a call metric measurement for request cost.
-  /// Multiple calls to this method with the same name will
-  /// override the corresponding stored value. The lifetime of the
-  /// name string needs to be longer than the lifetime of the RPC
-  /// itself, since it's going to be sent as trailers after the RPC
-  /// finishes. It is assumed the strings are common names that
-  /// are global constants.
-  CallMetricRecorder& RecordRequestCostMetric(string_ref name, double value);
-
- private:
-  absl::optional<std::string> CreateSerializedReport();
-
-  internal::Mutex mu_;
-  grpc_core::BackendMetricData* backend_metric_data_ ABSL_GUARDED_BY(&mu_);
-  friend class experimental::OrcaServerInterceptor;
-};
-
-}  // namespace experimental
+namespace grpc
+{
+    class ServerBuilder;
+
+    namespace experimental
+    {
+        class OrcaServerInterceptor;
+
+        // Registers the per-rpc orca load reporter into the \a ServerBuilder.
+        // Once this is done, the server will automatically send the load metrics
+        // after each RPC as they were reported. In order to report load metrics,
+        // call the \a ServerContext::ExperimentalGetCallMetricRecorder() method to
+        // retrieve the recorder for the current call.
+        void EnableCallMetricRecording(ServerBuilder*);
+
+        /// Records call metrics for the purpose of load balancing.
+        /// During an RPC, call \a ServerContext::ExperimentalGetCallMetricRecorder()
+        /// method to retrive the recorder for the current call.
+        class CallMetricRecorder
+        {
+        public:
+            explicit CallMetricRecorder(grpc_core::Arena* arena);
+            ~CallMetricRecorder();
+
+            /// Records a call metric measurement for CPU utilization.
+            /// Multiple calls to this method will override the stored value.
+            CallMetricRecorder& RecordCpuUtilizationMetric(double value);
+
+            /// Records a call metric measurement for memory utilization.
+            /// Multiple calls to this method will override the stored value.
+            CallMetricRecorder& RecordMemoryUtilizationMetric(double value);
+
+            /// Records a call metric measurement for utilization.
+            /// Multiple calls to this method with the same name will
+            /// override the corresponding stored value. The lifetime of the
+            /// name string needs to be longer than the lifetime of the RPC
+            /// itself, since it's going to be sent as trailers after the RPC
+            /// finishes. It is assumed the strings are common names that
+            /// are global constants.
+            CallMetricRecorder& RecordUtilizationMetric(string_ref name, double value);
+
+            /// Records a call metric measurement for request cost.
+            /// Multiple calls to this method with the same name will
+            /// override the corresponding stored value. The lifetime of the
+            /// name string needs to be longer than the lifetime of the RPC
+            /// itself, since it's going to be sent as trailers after the RPC
+            /// finishes. It is assumed the strings are common names that
+            /// are global constants.
+            CallMetricRecorder& RecordRequestCostMetric(string_ref name, double value);
+
+        private:
+            absl::optional<std::string> CreateSerializedReport();
+
+            internal::Mutex mu_;
+            grpc_core::BackendMetricData* backend_metric_data_ ABSL_GUARDED_BY(&mu_);
+            friend class experimental::OrcaServerInterceptor;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_EXT_CALL_METRIC_RECORDER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/ext/health_check_service_server_builder_option.h b/CAPI/cpp/grpc/include/grpcpp/ext/health_check_service_server_builder_option.h
index dd43b05..db55469 100644
--- a/CAPI/cpp/grpc/include/grpcpp/ext/health_check_service_server_builder_option.h
+++ b/CAPI/cpp/grpc/include/grpcpp/ext/health_check_service_server_builder_option.h
@@ -25,22 +25,28 @@
 #include <grpcpp/impl/server_builder_option.h>
 #include <grpcpp/support/config.h>
 
-namespace grpc {
-
-class HealthCheckServiceServerBuilderOption : public ServerBuilderOption {
- public:
-  /// The ownership of \a hc will be taken and transferred to the grpc server.
-  /// To explicitly disable default service, pass in a nullptr.
-  explicit HealthCheckServiceServerBuilderOption(
-      std::unique_ptr<HealthCheckServiceInterface> hc);
-  ~HealthCheckServiceServerBuilderOption() override {}
-  void UpdateArguments(ChannelArguments* args) override;
-  void UpdatePlugins(
-      std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins) override;
-
- private:
-  std::unique_ptr<HealthCheckServiceInterface> hc_;
-};
+namespace grpc
+{
+
+    class HealthCheckServiceServerBuilderOption : public ServerBuilderOption
+    {
+    public:
+        /// The ownership of \a hc will be taken and transferred to the grpc server.
+        /// To explicitly disable default service, pass in a nullptr.
+        explicit HealthCheckServiceServerBuilderOption(
+            std::unique_ptr<HealthCheckServiceInterface> hc
+        );
+        ~HealthCheckServiceServerBuilderOption() override
+        {
+        }
+        void UpdateArguments(ChannelArguments* args) override;
+        void UpdatePlugins(
+            std::vector<std::unique_ptr<ServerBuilderPlugin>>* plugins
+        ) override;
+
+    private:
+        std::unique_ptr<HealthCheckServiceInterface> hc_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/generic/generic_stub.h b/CAPI/cpp/grpc/include/grpcpp/generic/generic_stub.h
index 6ae6c99..389809b 100644
--- a/CAPI/cpp/grpc/include/grpcpp/generic/generic_stub.h
+++ b/CAPI/cpp/grpc/include/grpcpp/generic/generic_stub.h
@@ -30,145 +30,141 @@
 #include <grpcpp/support/client_callback.h>
 #include <grpcpp/support/status.h>
 
-namespace grpc {
-
-class CompletionQueue;
-
-typedef ClientAsyncReaderWriter<ByteBuffer, ByteBuffer>
-    GenericClientAsyncReaderWriter;
-typedef ClientAsyncResponseReader<ByteBuffer> GenericClientAsyncResponseReader;
-
-/// Generic stubs provide a type-unaware interface to call gRPC methods
-/// by name. In practice, the Request and Response types should be basic
-/// types like grpc::ByteBuffer or proto::MessageLite (the base protobuf).
-template <class RequestType, class ResponseType>
-class TemplatedGenericStub final {
- public:
-  explicit TemplatedGenericStub(std::shared_ptr<grpc::ChannelInterface> channel)
-      : channel_(channel) {}
-
-  /// Setup a call to a named method \a method using \a context, but don't
-  /// start it. Let it be started explicitly with StartCall and a tag.
-  /// The return value only indicates whether or not registration of the call
-  /// succeeded (i.e. the call won't proceed if the return value is nullptr).
-  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>
-  PrepareCall(ClientContext* context, const std::string& method,
-              grpc::CompletionQueue* cq) {
-    return CallInternal(channel_.get(), context, method, /*options=*/{}, cq,
-                        false, nullptr);
-  }
-
-  /// Setup a unary call to a named method \a method using \a context, and don't
-  /// start it. Let it be started explicitly with StartCall.
-  /// The return value only indicates whether or not registration of the call
-  /// succeeded (i.e. the call won't proceed if the return value is nullptr).
-  std::unique_ptr<ClientAsyncResponseReader<ResponseType>> PrepareUnaryCall(
-      ClientContext* context, const std::string& method,
-      const RequestType& request, grpc::CompletionQueue* cq) {
-    return std::unique_ptr<ClientAsyncResponseReader<ResponseType>>(
-        internal::ClientAsyncResponseReaderHelper::Create<ResponseType>(
-            channel_.get(), cq,
-            grpc::internal::RpcMethod(method.c_str(),
-                                      /*suffix_for_stats=*/nullptr,
-                                      grpc::internal::RpcMethod::NORMAL_RPC),
-            context, request));
-  }
-
-  /// DEPRECATED for multi-threaded use
-  /// Begin a call to a named method \a method using \a context.
-  /// A tag \a tag will be delivered to \a cq when the call has been started
-  /// (i.e, initial metadata has been sent).
-  /// The return value only indicates whether or not registration of the call
-  /// succeeded (i.e. the call won't proceed if the return value is nullptr).
-  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>> Call(
-      ClientContext* context, const std::string& method,
-      grpc::CompletionQueue* cq, void* tag) {
-    return CallInternal(channel_.get(), context, method, /*options=*/{}, cq,
-                        true, tag);
-  }
-
-  /// Setup and start a unary call to a named method \a method using
-  /// \a context and specifying the \a request and \a response buffers.
-  void UnaryCall(ClientContext* context, const std::string& method,
-                 StubOptions options, const RequestType* request,
-                 ResponseType* response,
-                 std::function<void(grpc::Status)> on_completion) {
-    UnaryCallInternal(context, method, options, request, response,
-                      std::move(on_completion));
-  }
-
-  /// Setup a unary call to a named method \a method using
-  /// \a context and specifying the \a request and \a response buffers.
-  /// Like any other reactor-based RPC, it will not be activated until
-  /// StartCall is invoked on its reactor.
-  void PrepareUnaryCall(ClientContext* context, const std::string& method,
-                        StubOptions options, const RequestType* request,
-                        ResponseType* response, ClientUnaryReactor* reactor) {
-    PrepareUnaryCallInternal(context, method, options, request, response,
-                             reactor);
-  }
-
-  /// Setup a call to a named method \a method using \a context and tied to
-  /// \a reactor . Like any other bidi streaming RPC, it will not be activated
-  /// until StartCall is invoked on its reactor.
-  void PrepareBidiStreamingCall(
-      ClientContext* context, const std::string& method, StubOptions options,
-      ClientBidiReactor<RequestType, ResponseType>* reactor) {
-    PrepareBidiStreamingCallInternal(context, method, options, reactor);
-  }
-
- private:
-  std::shared_ptr<grpc::ChannelInterface> channel_;
-
-  void UnaryCallInternal(ClientContext* context, const std::string& method,
-                         StubOptions options, const RequestType* request,
-                         ResponseType* response,
-                         std::function<void(grpc::Status)> on_completion) {
-    internal::CallbackUnaryCall(
-        channel_.get(),
-        grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(),
-                                  grpc::internal::RpcMethod::NORMAL_RPC),
-        context, request, response, std::move(on_completion));
-  }
-
-  void PrepareUnaryCallInternal(ClientContext* context,
-                                const std::string& method, StubOptions options,
-                                const RequestType* request,
-                                ResponseType* response,
-                                ClientUnaryReactor* reactor) {
-    internal::ClientCallbackUnaryFactory::Create<RequestType, ResponseType>(
-        channel_.get(),
-        grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(),
-                                  grpc::internal::RpcMethod::NORMAL_RPC),
-        context, request, response, reactor);
-  }
-
-  void PrepareBidiStreamingCallInternal(
-      ClientContext* context, const std::string& method, StubOptions options,
-      ClientBidiReactor<RequestType, ResponseType>* reactor) {
-    internal::ClientCallbackReaderWriterFactory<RequestType, ResponseType>::
-        Create(channel_.get(),
-               grpc::internal::RpcMethod(
-                   method.c_str(), options.suffix_for_stats(),
-                   grpc::internal::RpcMethod::BIDI_STREAMING),
-               context, reactor);
-  }
-
-  std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>
-  CallInternal(grpc::ChannelInterface* channel, ClientContext* context,
-               const std::string& method, StubOptions options,
-               grpc::CompletionQueue* cq, bool start, void* tag) {
-    return std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>(
-        internal::ClientAsyncReaderWriterFactory<RequestType, ResponseType>::
-            Create(channel, cq,
-                   grpc::internal::RpcMethod(
-                       method.c_str(), options.suffix_for_stats(),
-                       grpc::internal::RpcMethod::BIDI_STREAMING),
-                   context, start, tag));
-  }
-};
-
-typedef TemplatedGenericStub<grpc::ByteBuffer, grpc::ByteBuffer> GenericStub;
+namespace grpc
+{
+
+    class CompletionQueue;
+
+    typedef ClientAsyncReaderWriter<ByteBuffer, ByteBuffer>
+        GenericClientAsyncReaderWriter;
+    typedef ClientAsyncResponseReader<ByteBuffer> GenericClientAsyncResponseReader;
+
+    /// Generic stubs provide a type-unaware interface to call gRPC methods
+    /// by name. In practice, the Request and Response types should be basic
+    /// types like grpc::ByteBuffer or proto::MessageLite (the base protobuf).
+    template<class RequestType, class ResponseType>
+    class TemplatedGenericStub final
+    {
+    public:
+        explicit TemplatedGenericStub(std::shared_ptr<grpc::ChannelInterface> channel) :
+            channel_(channel)
+        {
+        }
+
+        /// Setup a call to a named method \a method using \a context, but don't
+        /// start it. Let it be started explicitly with StartCall and a tag.
+        /// The return value only indicates whether or not registration of the call
+        /// succeeded (i.e. the call won't proceed if the return value is nullptr).
+        std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>
+            PrepareCall(ClientContext* context, const std::string& method, grpc::CompletionQueue* cq)
+        {
+            return CallInternal(channel_.get(), context, method, /*options=*/{}, cq, false, nullptr);
+        }
+
+        /// Setup a unary call to a named method \a method using \a context, and don't
+        /// start it. Let it be started explicitly with StartCall.
+        /// The return value only indicates whether or not registration of the call
+        /// succeeded (i.e. the call won't proceed if the return value is nullptr).
+        std::unique_ptr<ClientAsyncResponseReader<ResponseType>> PrepareUnaryCall(
+            ClientContext* context, const std::string& method, const RequestType& request, grpc::CompletionQueue* cq
+        )
+        {
+            return std::unique_ptr<ClientAsyncResponseReader<ResponseType>>(
+                internal::ClientAsyncResponseReaderHelper::Create<ResponseType>(
+                    channel_.get(), cq, grpc::internal::RpcMethod(method.c_str(),
+                                                                  /*suffix_for_stats=*/nullptr,
+                                                                  grpc::internal::RpcMethod::NORMAL_RPC),
+                    context,
+                    request
+                )
+            );
+        }
+
+        /// DEPRECATED for multi-threaded use
+        /// Begin a call to a named method \a method using \a context.
+        /// A tag \a tag will be delivered to \a cq when the call has been started
+        /// (i.e, initial metadata has been sent).
+        /// The return value only indicates whether or not registration of the call
+        /// succeeded (i.e. the call won't proceed if the return value is nullptr).
+        std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>> Call(
+            ClientContext* context, const std::string& method, grpc::CompletionQueue* cq, void* tag
+        )
+        {
+            return CallInternal(channel_.get(), context, method, /*options=*/{}, cq, true, tag);
+        }
+
+        /// Setup and start a unary call to a named method \a method using
+        /// \a context and specifying the \a request and \a response buffers.
+        void UnaryCall(ClientContext* context, const std::string& method, StubOptions options, const RequestType* request, ResponseType* response, std::function<void(grpc::Status)> on_completion)
+        {
+            UnaryCallInternal(context, method, options, request, response, std::move(on_completion));
+        }
+
+        /// Setup a unary call to a named method \a method using
+        /// \a context and specifying the \a request and \a response buffers.
+        /// Like any other reactor-based RPC, it will not be activated until
+        /// StartCall is invoked on its reactor.
+        void PrepareUnaryCall(ClientContext* context, const std::string& method, StubOptions options, const RequestType* request, ResponseType* response, ClientUnaryReactor* reactor)
+        {
+            PrepareUnaryCallInternal(context, method, options, request, response, reactor);
+        }
+
+        /// Setup a call to a named method \a method using \a context and tied to
+        /// \a reactor . Like any other bidi streaming RPC, it will not be activated
+        /// until StartCall is invoked on its reactor.
+        void PrepareBidiStreamingCall(
+            ClientContext* context, const std::string& method, StubOptions options, ClientBidiReactor<RequestType, ResponseType>* reactor
+        )
+        {
+            PrepareBidiStreamingCallInternal(context, method, options, reactor);
+        }
+
+    private:
+        std::shared_ptr<grpc::ChannelInterface> channel_;
+
+        void UnaryCallInternal(ClientContext* context, const std::string& method, StubOptions options, const RequestType* request, ResponseType* response, std::function<void(grpc::Status)> on_completion)
+        {
+            internal::CallbackUnaryCall(
+                channel_.get(),
+                grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(), grpc::internal::RpcMethod::NORMAL_RPC),
+                context,
+                request,
+                response,
+                std::move(on_completion)
+            );
+        }
+
+        void PrepareUnaryCallInternal(ClientContext* context, const std::string& method, StubOptions options, const RequestType* request, ResponseType* response, ClientUnaryReactor* reactor)
+        {
+            internal::ClientCallbackUnaryFactory::Create<RequestType, ResponseType>(
+                channel_.get(),
+                grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(), grpc::internal::RpcMethod::NORMAL_RPC),
+                context,
+                request,
+                response,
+                reactor
+            );
+        }
+
+        void PrepareBidiStreamingCallInternal(
+            ClientContext* context, const std::string& method, StubOptions options, ClientBidiReactor<RequestType, ResponseType>* reactor
+        )
+        {
+            internal::ClientCallbackReaderWriterFactory<RequestType, ResponseType>::
+                Create(channel_.get(), grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(), grpc::internal::RpcMethod::BIDI_STREAMING), context, reactor);
+        }
+
+        std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>
+            CallInternal(grpc::ChannelInterface* channel, ClientContext* context, const std::string& method, StubOptions options, grpc::CompletionQueue* cq, bool start, void* tag)
+        {
+            return std::unique_ptr<ClientAsyncReaderWriter<RequestType, ResponseType>>(
+                internal::ClientAsyncReaderWriterFactory<RequestType, ResponseType>::
+                    Create(channel, cq, grpc::internal::RpcMethod(method.c_str(), options.suffix_for_stats(), grpc::internal::RpcMethod::BIDI_STREAMING), context, start, tag)
+            );
+        }
+    };
+
+    typedef TemplatedGenericStub<grpc::ByteBuffer, grpc::ByteBuffer> GenericStub;
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/grpcpp.h b/CAPI/cpp/grpc/include/grpcpp/grpcpp.h
index 9d707e2..8ea29ec 100644
--- a/CAPI/cpp/grpc/include/grpcpp/grpcpp.h
+++ b/CAPI/cpp/grpc/include/grpcpp/grpcpp.h
@@ -60,9 +60,10 @@
 #include <grpcpp/server_posix.h>
 // IWYU pragma: end_exports
 
-namespace grpc {
-/// Return gRPC library version.
-std::string Version();
+namespace grpc
+{
+    /// Return gRPC library version.
+    std::string Version();
 }  // namespace grpc
 
 #endif  // GRPCPP_GRPCPP_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/health_check_service_interface.h b/CAPI/cpp/grpc/include/grpcpp/health_check_service_interface.h
index 9eab8fc..954e42e 100644
--- a/CAPI/cpp/grpc/include/grpcpp/health_check_service_interface.h
+++ b/CAPI/cpp/grpc/include/grpcpp/health_check_service_interface.h
@@ -21,37 +21,42 @@
 
 #include <grpcpp/support/config.h>
 
-namespace grpc {
-
-const char kHealthCheckServiceInterfaceArg[] =
-    "grpc.health_check_service_interface";
-
-/// The gRPC server uses this interface to expose the health checking service
-/// without depending on protobuf.
-class HealthCheckServiceInterface {
- public:
-  virtual ~HealthCheckServiceInterface() {}
-
-  /// Set or change the serving status of the given \a service_name.
-  virtual void SetServingStatus(const std::string& service_name,
-                                bool serving) = 0;
-  /// Apply to all registered service names.
-  virtual void SetServingStatus(bool serving) = 0;
-
-  /// Set all registered service names to not serving and prevent future
-  /// state changes.
-  virtual void Shutdown() {}
-};
-
-/// Enable/disable the default health checking service. This applies to all C++
-/// servers created afterwards. For each server, user can override the default
-/// with a HealthCheckServiceServerBuilderOption.
-/// NOT thread safe.
-void EnableDefaultHealthCheckService(bool enable);
-
-/// Returns whether the default health checking service is enabled.
-/// NOT thread safe.
-bool DefaultHealthCheckServiceEnabled();
+namespace grpc
+{
+
+    const char kHealthCheckServiceInterfaceArg[] =
+        "grpc.health_check_service_interface";
+
+    /// The gRPC server uses this interface to expose the health checking service
+    /// without depending on protobuf.
+    class HealthCheckServiceInterface
+    {
+    public:
+        virtual ~HealthCheckServiceInterface()
+        {
+        }
+
+        /// Set or change the serving status of the given \a service_name.
+        virtual void SetServingStatus(const std::string& service_name, bool serving) = 0;
+        /// Apply to all registered service names.
+        virtual void SetServingStatus(bool serving) = 0;
+
+        /// Set all registered service names to not serving and prevent future
+        /// state changes.
+        virtual void Shutdown()
+        {
+        }
+    };
+
+    /// Enable/disable the default health checking service. This applies to all C++
+    /// servers created afterwards. For each server, user can override the default
+    /// with a HealthCheckServiceServerBuilderOption.
+    /// NOT thread safe.
+    void EnableDefaultHealthCheckService(bool enable);
+
+    /// Returns whether the default health checking service is enabled.
+    /// NOT thread safe.
+    bool DefaultHealthCheckServiceEnabled();
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/channel_argument_option.h b/CAPI/cpp/grpc/include/grpcpp/impl/channel_argument_option.h
index 335072a..4750e86 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/channel_argument_option.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/channel_argument_option.h
@@ -25,12 +25,15 @@
 #include <grpcpp/impl/server_builder_option.h>
 #include <grpcpp/support/channel_arguments.h>
 
-namespace grpc {
+namespace grpc
+{
 
-std::unique_ptr<ServerBuilderOption> MakeChannelArgumentOption(
-    const std::string& name, const std::string& value);
-std::unique_ptr<ServerBuilderOption> MakeChannelArgumentOption(
-    const std::string& name, int value);
+    std::unique_ptr<ServerBuilderOption> MakeChannelArgumentOption(
+        const std::string& name, const std::string& value
+    );
+    std::unique_ptr<ServerBuilderOption> MakeChannelArgumentOption(
+        const std::string& name, int value
+    );
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_generic_service.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_generic_service.h
index 2a00066..65b8ec7 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_generic_service.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_generic_service.h
@@ -30,107 +30,140 @@
 
 struct grpc_server;
 
-namespace grpc {
-
-typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer>
-    GenericServerAsyncReaderWriter;
-typedef ServerAsyncResponseWriter<ByteBuffer> GenericServerAsyncResponseWriter;
-typedef ServerAsyncReader<ByteBuffer, ByteBuffer> GenericServerAsyncReader;
-typedef ServerAsyncWriter<ByteBuffer> GenericServerAsyncWriter;
-
-class GenericServerContext final : public ServerContext {
- public:
-  const std::string& method() const { return method_; }
-  const std::string& host() const { return host_; }
-
- private:
-  friend class ServerInterface;
-
-  std::string method_;
-  std::string host_;
-};
-
-// A generic service at the server side accepts all RPC methods and hosts. It is
-// typically used in proxies. The generic service can be registered to a server
-// which also has other services.
-// Sample usage:
-//   ServerBuilder builder;
-//   auto cq = builder.AddCompletionQueue();
-//   AsyncGenericService generic_service;
-//   builder.RegisterAsyncGenericService(&generic_service);
-//   auto server = builder.BuildAndStart();
-//
-//   // request a new call
-//   GenericServerContext context;
-//   GenericServerAsyncReaderWriter stream;
-//   generic_service.RequestCall(&context, &stream, cq.get(), cq.get(), tag);
-//
-// When tag is retrieved from cq->Next(), context.method() can be used to look
-// at the method and the RPC can be handled accordingly.
-class AsyncGenericService final {
- public:
-  AsyncGenericService() : server_(nullptr) {}
-
-  void RequestCall(GenericServerContext* ctx,
-                   GenericServerAsyncReaderWriter* reader_writer,
-                   grpc::CompletionQueue* call_cq,
-                   grpc::ServerCompletionQueue* notification_cq, void* tag);
-
- private:
-  friend class grpc::Server;
-  grpc::Server* server_;
-};
-
-/// \a ServerGenericBidiReactor is the reactor class for bidi streaming RPCs
-/// invoked on a CallbackGenericService. It is just a ServerBidi reactor with
-/// ByteBuffer arguments.
-using ServerGenericBidiReactor = ServerBidiReactor<ByteBuffer, ByteBuffer>;
-
-class GenericCallbackServerContext final : public grpc::CallbackServerContext {
- public:
-  const std::string& method() const { return method_; }
-  const std::string& host() const { return host_; }
-
- private:
-  friend class grpc::Server;
-
-  std::string method_;
-  std::string host_;
-};
-
-/// \a CallbackGenericService is the base class for generic services implemented
-/// using the callback API and registered through the ServerBuilder using
-/// RegisterCallbackGenericService.
-class CallbackGenericService {
- public:
-  CallbackGenericService() {}
-  virtual ~CallbackGenericService() {}
-
-  /// The "method handler" for the generic API. This function should be
-  /// overridden to provide a ServerGenericBidiReactor that implements the
-  /// application-level interface for this RPC. Unimplemented by default.
-  virtual ServerGenericBidiReactor* CreateReactor(
-      GenericCallbackServerContext* /*ctx*/) {
-    class Reactor : public ServerGenericBidiReactor {
-     public:
-      Reactor() { this->Finish(Status(StatusCode::UNIMPLEMENTED, "")); }
-      void OnDone() override { delete this; }
+namespace grpc
+{
+
+    typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer>
+        GenericServerAsyncReaderWriter;
+    typedef ServerAsyncResponseWriter<ByteBuffer> GenericServerAsyncResponseWriter;
+    typedef ServerAsyncReader<ByteBuffer, ByteBuffer> GenericServerAsyncReader;
+    typedef ServerAsyncWriter<ByteBuffer> GenericServerAsyncWriter;
+
+    class GenericServerContext final : public ServerContext
+    {
+    public:
+        const std::string& method() const
+        {
+            return method_;
+        }
+        const std::string& host() const
+        {
+            return host_;
+        }
+
+    private:
+        friend class ServerInterface;
+
+        std::string method_;
+        std::string host_;
     };
-    return new Reactor;
-  }
 
- private:
-  friend class grpc::Server;
+    // A generic service at the server side accepts all RPC methods and hosts. It is
+    // typically used in proxies. The generic service can be registered to a server
+    // which also has other services.
+    // Sample usage:
+    //   ServerBuilder builder;
+    //   auto cq = builder.AddCompletionQueue();
+    //   AsyncGenericService generic_service;
+    //   builder.RegisterAsyncGenericService(&generic_service);
+    //   auto server = builder.BuildAndStart();
+    //
+    //   // request a new call
+    //   GenericServerContext context;
+    //   GenericServerAsyncReaderWriter stream;
+    //   generic_service.RequestCall(&context, &stream, cq.get(), cq.get(), tag);
+    //
+    // When tag is retrieved from cq->Next(), context.method() can be used to look
+    // at the method and the RPC can be handled accordingly.
+    class AsyncGenericService final
+    {
+    public:
+        AsyncGenericService() :
+            server_(nullptr)
+        {
+        }
+
+        void RequestCall(GenericServerContext* ctx, GenericServerAsyncReaderWriter* reader_writer, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag);
+
+    private:
+        friend class grpc::Server;
+        grpc::Server* server_;
+    };
 
-  internal::CallbackBidiHandler<ByteBuffer, ByteBuffer>* Handler() {
-    return new internal::CallbackBidiHandler<ByteBuffer, ByteBuffer>(
-        [this](grpc::CallbackServerContext* ctx) {
-          return CreateReactor(static_cast<GenericCallbackServerContext*>(ctx));
-        });
-  }
+    /// \a ServerGenericBidiReactor is the reactor class for bidi streaming RPCs
+    /// invoked on a CallbackGenericService. It is just a ServerBidi reactor with
+    /// ByteBuffer arguments.
+    using ServerGenericBidiReactor = ServerBidiReactor<ByteBuffer, ByteBuffer>;
+
+    class GenericCallbackServerContext final : public grpc::CallbackServerContext
+    {
+    public:
+        const std::string& method() const
+        {
+            return method_;
+        }
+        const std::string& host() const
+        {
+            return host_;
+        }
+
+    private:
+        friend class grpc::Server;
+
+        std::string method_;
+        std::string host_;
+    };
 
-  grpc::Server* server_{nullptr};
-};
+    /// \a CallbackGenericService is the base class for generic services implemented
+    /// using the callback API and registered through the ServerBuilder using
+    /// RegisterCallbackGenericService.
+    class CallbackGenericService
+    {
+    public:
+        CallbackGenericService()
+        {
+        }
+        virtual ~CallbackGenericService()
+        {
+        }
+
+        /// The "method handler" for the generic API. This function should be
+        /// overridden to provide a ServerGenericBidiReactor that implements the
+        /// application-level interface for this RPC. Unimplemented by default.
+        virtual ServerGenericBidiReactor* CreateReactor(
+            GenericCallbackServerContext* /*ctx*/
+        )
+        {
+            class Reactor : public ServerGenericBidiReactor
+            {
+            public:
+                Reactor()
+                {
+                    this->Finish(Status(StatusCode::UNIMPLEMENTED, ""));
+                }
+                void OnDone() override
+                {
+                    delete this;
+                }
+            };
+            return new Reactor;
+        }
+
+    private:
+        friend class grpc::Server;
+
+        internal::CallbackBidiHandler<ByteBuffer, ByteBuffer>* Handler()
+        {
+            return new internal::CallbackBidiHandler<ByteBuffer, ByteBuffer>(
+                [this](grpc::CallbackServerContext* ctx)
+                {
+                    return CreateReactor(static_cast<GenericCallbackServerContext*>(ctx));
+                }
+            );
+        }
+
+        grpc::Server* server_{nullptr};
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_stream.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_stream.h
index 5b63c30..e250dc1 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_stream.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_stream.h
@@ -27,1106 +27,1190 @@
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-
-namespace internal {
-/// Common interface for all client side asynchronous streaming.
-class ClientAsyncStreamingInterface {
- public:
-  virtual ~ClientAsyncStreamingInterface() {}
-
-  /// Start the call that was set up by the constructor, but only if the
-  /// constructor was invoked through the "Prepare" API which doesn't actually
-  /// start the call
-  virtual void StartCall(void* tag) = 0;
-
-  /// Request notification of the reading of the initial metadata. Completion
-  /// will be notified by \a tag on the associated completion queue.
-  /// This call is optional, but if it is used, it cannot be used concurrently
-  /// with or after the \a AsyncReaderInterface::Read method.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  virtual void ReadInitialMetadata(void* tag) = 0;
-
-  /// Indicate that the stream is to be finished and request notification for
-  /// when the call has been ended.
-  /// Should not be used concurrently with other operations.
-  ///
-  /// It is appropriate to call this method exactly once when both:
-  ///   * the client side has no more message to send
-  ///     (this can be declared implicitly by calling this method, or
-  ///     explicitly through an earlier call to the <i>WritesDone</i> method
-  ///     of the class in use, e.g. \a ClientAsyncWriterInterface::WritesDone or
-  ///     \a ClientAsyncReaderWriterInterface::WritesDone).
-  ///   * there are no more messages to be received from the server (this can
-  ///     be known implicitly by the calling code, or explicitly from an
-  ///     earlier call to \a AsyncReaderInterface::Read that yielded a failed
-  ///     result, e.g. cq->Next(&read_tag, &ok) filled in 'ok' with 'false').
-  ///
-  /// The tag will be returned when either:
-  /// - all incoming messages have been read and the server has returned
-  ///   a status.
-  /// - the server has returned a non-OK status.
-  /// - the call failed for some reason and the library generated a
-  ///   status.
-  ///
-  /// Note that implementations of this method attempt to receive initial
-  /// metadata from the server if initial metadata hasn't yet been received.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  /// \param[out] status To be updated with the operation status.
-  virtual void Finish(grpc::Status* status, void* tag) = 0;
-};
-
-/// An interface that yields a sequence of messages of type \a R.
-template <class R>
-class AsyncReaderInterface {
- public:
-  virtual ~AsyncReaderInterface() {}
-
-  /// Read a message of type \a R into \a msg. Completion will be notified by \a
-  /// tag on the associated completion queue.
-  /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
-  /// should not be called concurrently with other streaming APIs
-  /// on the same stream. It is not meaningful to call it concurrently
-  /// with another \a AsyncReaderInterface::Read on the same stream since reads
-  /// on the same stream are delivered in order.
-  ///
-  /// \param[out] msg Where to eventually store the read message.
-  /// \param[in] tag The tag identifying the operation.
-  ///
-  /// Side effect: note that this method attempt to receive initial metadata for
-  /// a stream if it hasn't yet been received.
-  virtual void Read(R* msg, void* tag) = 0;
-};
-
-/// An interface that can be fed a sequence of messages of type \a W.
-template <class W>
-class AsyncWriterInterface {
- public:
-  virtual ~AsyncWriterInterface() {}
-
-  /// Request the writing of \a msg with identifying tag \a tag.
-  ///
-  /// Only one write may be outstanding at any given time. This means that
-  /// after calling Write, one must wait to receive \a tag from the completion
-  /// queue BEFORE calling Write again.
-  /// This is thread-safe with respect to \a AsyncReaderInterface::Read
-  ///
-  /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
-  /// to deallocate once Write returns.
-  ///
-  /// \param[in] msg The message to be written.
-  /// \param[in] tag The tag identifying the operation.
-  virtual void Write(const W& msg, void* tag) = 0;
-
-  /// Request the writing of \a msg using WriteOptions \a options with
-  /// identifying tag \a tag.
-  ///
-  /// Only one write may be outstanding at any given time. This means that
-  /// after calling Write, one must wait to receive \a tag from the completion
-  /// queue BEFORE calling Write again.
-  /// WriteOptions \a options is used to set the write options of this message.
-  /// This is thread-safe with respect to \a AsyncReaderInterface::Read
-  ///
-  /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
-  /// to deallocate once Write returns.
-  ///
-  /// \param[in] msg The message to be written.
-  /// \param[in] options The WriteOptions to be used to write this message.
-  /// \param[in] tag The tag identifying the operation.
-  virtual void Write(const W& msg, grpc::WriteOptions options, void* tag) = 0;
-
-  /// Request the writing of \a msg and coalesce it with the writing
-  /// of trailing metadata, using WriteOptions \a options with
-  /// identifying tag \a tag.
-  ///
-  /// For client, WriteLast is equivalent of performing Write and
-  /// WritesDone in a single step.
-  /// For server, WriteLast buffers the \a msg. The writing of \a msg is held
-  /// until Finish is called, where \a msg and trailing metadata are coalesced
-  /// and write is initiated. Note that WriteLast can only buffer \a msg up to
-  /// the flow control window size. If \a msg size is larger than the window
-  /// size, it will be sent on wire without buffering.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
-  /// to deallocate once Write returns.
-  ///
-  /// \param[in] msg The message to be written.
-  /// \param[in] options The WriteOptions to be used to write this message.
-  /// \param[in] tag The tag identifying the operation.
-  void WriteLast(const W& msg, grpc::WriteOptions options, void* tag) {
-    Write(msg, options.set_last_message(), tag);
-  }
-};
-
-}  // namespace internal
-
-template <class R>
-class ClientAsyncReaderInterface
-    : public internal::ClientAsyncStreamingInterface,
-      public internal::AsyncReaderInterface<R> {};
-
-namespace internal {
-template <class R>
-class ClientAsyncReaderFactory {
- public:
-  /// Create a stream object.
-  /// Write the first request out if \a start is set.
-  /// \a tag will be notified on \a cq when the call has been started and
-  /// \a request has been written out. If \a start is not set, \a tag must be
-  /// nullptr and the actual call must be initiated by StartCall
-  /// Note that \a context will be used to fill in custom initial metadata
-  /// used to send to the server when starting the call.
-  template <class W>
-  static ClientAsyncReader<R>* Create(grpc::ChannelInterface* channel,
-                                      grpc::CompletionQueue* cq,
-                                      const grpc::internal::RpcMethod& method,
-                                      grpc::ClientContext* context,
-                                      const W& request, bool start, void* tag) {
-    grpc::internal::Call call = channel->CreateCall(method, context, cq);
-    return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call.call(), sizeof(ClientAsyncReader<R>)))
-        ClientAsyncReader<R>(call, context, request, start, tag);
-  }
-};
-}  // namespace internal
-
-/// Async client-side API for doing server-streaming RPCs,
-/// where the incoming message stream coming from the server has
-/// messages of type \a R.
-template <class R>
-class ClientAsyncReader final : public ClientAsyncReaderInterface<R> {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncReader));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  void StartCall(void* tag) override {
-    GPR_CODEGEN_ASSERT(!started_);
-    started_ = true;
-    StartCallInternal(tag);
-  }
-
-  /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata
-  /// method for semantics.
-  ///
-  /// Side effect:
-  ///   - upon receiving initial metadata from the server,
-  ///     the \a ClientContext associated with this call is updated, and the
-  ///     calling code can access the received metadata through the
-  ///     \a ClientContext.
-  void ReadInitialMetadata(void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
-
-    meta_ops_.set_output_tag(tag);
-    meta_ops_.RecvInitialMetadata(context_);
-    call_.PerformOps(&meta_ops_);
-  }
-
-  void Read(R* msg, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    read_ops_.set_output_tag(tag);
-    if (!context_->initial_metadata_received_) {
-      read_ops_.RecvInitialMetadata(context_);
-    }
-    read_ops_.RecvMessage(msg);
-    call_.PerformOps(&read_ops_);
-  }
-
-  /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
-  ///
-  /// Side effect:
-  ///   - the \a ClientContext associated with this call is updated with
-  ///     possible initial and trailing metadata received from the server.
-  void Finish(grpc::Status* status, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    finish_ops_.set_output_tag(tag);
-    if (!context_->initial_metadata_received_) {
-      finish_ops_.RecvInitialMetadata(context_);
-    }
-    finish_ops_.ClientRecvStatus(context_, status);
-    call_.PerformOps(&finish_ops_);
-  }
-
- private:
-  friend class internal::ClientAsyncReaderFactory<R>;
-  template <class W>
-  ClientAsyncReader(grpc::internal::Call call, grpc::ClientContext* context,
-                    const W& request, bool start, void* tag)
-      : context_(context), call_(call), started_(start) {
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(init_ops_.SendMessage(request).ok());
-    init_ops_.ClientSendClose();
-    if (start) {
-      StartCallInternal(tag);
-    } else {
-      GPR_CODEGEN_ASSERT(tag == nullptr);
-    }
-  }
-
-  void StartCallInternal(void* tag) {
-    init_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                  context_->initial_metadata_flags());
-    init_ops_.set_output_tag(tag);
-    call_.PerformOps(&init_ops_);
-  }
-
-  grpc::ClientContext* context_;
-  grpc::internal::Call call_;
-  bool started_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpClientSendClose>
-      init_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
-      meta_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                            grpc::internal::CallOpRecvMessage<R>>
-      read_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                            grpc::internal::CallOpClientRecvStatus>
-      finish_ops_;
-};
-
-/// Common interface for client side asynchronous writing.
-template <class W>
-class ClientAsyncWriterInterface
-    : public internal::ClientAsyncStreamingInterface,
-      public internal::AsyncWriterInterface<W> {
- public:
-  /// Signal the client is done with the writes (half-close the client stream).
-  /// Thread-safe with respect to \a AsyncReaderInterface::Read
-  ///
-  /// \param[in] tag The tag identifying the operation.
-  virtual void WritesDone(void* tag) = 0;
-};
-
-namespace internal {
-template <class W>
-class ClientAsyncWriterFactory {
- public:
-  /// Create a stream object.
-  /// Start the RPC if \a start is set
-  /// \a tag will be notified on \a cq when the call has been started (i.e.
-  /// intitial metadata sent) and \a request has been written out.
-  /// If \a start is not set, \a tag must be nullptr and the actual call
-  /// must be initiated by StartCall
-  /// Note that \a context will be used to fill in custom initial metadata
-  /// used to send to the server when starting the call.
-  /// \a response will be filled in with the single expected response
-  /// message from the server upon a successful call to the \a Finish
-  /// method of this instance.
-  template <class R>
-  static ClientAsyncWriter<W>* Create(grpc::ChannelInterface* channel,
-                                      grpc::CompletionQueue* cq,
-                                      const grpc::internal::RpcMethod& method,
-                                      grpc::ClientContext* context, R* response,
-                                      bool start, void* tag) {
-    grpc::internal::Call call = channel->CreateCall(method, context, cq);
-    return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call.call(), sizeof(ClientAsyncWriter<W>)))
-        ClientAsyncWriter<W>(call, context, response, start, tag);
-  }
-};
-}  // namespace internal
-
-/// Async API on the client side for doing client-streaming RPCs,
-/// where the outgoing message stream going to the server contains
-/// messages of type \a W.
-template <class W>
-class ClientAsyncWriter final : public ClientAsyncWriterInterface<W> {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncWriter));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  void StartCall(void* tag) override {
-    GPR_CODEGEN_ASSERT(!started_);
-    started_ = true;
-    StartCallInternal(tag);
-  }
-
-  /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata method for
-  /// semantics.
-  ///
-  /// Side effect:
-  ///   - upon receiving initial metadata from the server, the \a ClientContext
-  ///     associated with this call is updated, and the calling code can access
-  ///     the received metadata through the \a ClientContext.
-  void ReadInitialMetadata(void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
-
-    meta_ops_.set_output_tag(tag);
-    meta_ops_.RecvInitialMetadata(context_);
-    call_.PerformOps(&meta_ops_);
-  }
-
-  void Write(const W& msg, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    write_ops_.set_output_tag(tag);
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
-    call_.PerformOps(&write_ops_);
-  }
-
-  void Write(const W& msg, grpc::WriteOptions options, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    write_ops_.set_output_tag(tag);
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-      write_ops_.ClientSendClose();
-    }
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
-    call_.PerformOps(&write_ops_);
-  }
-
-  void WritesDone(void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    write_ops_.set_output_tag(tag);
-    write_ops_.ClientSendClose();
-    call_.PerformOps(&write_ops_);
-  }
-
-  /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
-  ///
-  /// Side effect:
-  ///   - the \a ClientContext associated with this call is updated with
-  ///     possible initial and trailing metadata received from the server.
-  ///   - attempts to fill in the \a response parameter passed to this class's
-  ///     constructor with the server's response message.
-  void Finish(grpc::Status* status, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    finish_ops_.set_output_tag(tag);
-    if (!context_->initial_metadata_received_) {
-      finish_ops_.RecvInitialMetadata(context_);
-    }
-    finish_ops_.ClientRecvStatus(context_, status);
-    call_.PerformOps(&finish_ops_);
-  }
-
- private:
-  friend class internal::ClientAsyncWriterFactory<W>;
-  template <class R>
-  ClientAsyncWriter(grpc::internal::Call call, grpc::ClientContext* context,
-                    R* response, bool start, void* tag)
-      : context_(context), call_(call), started_(start) {
-    finish_ops_.RecvMessage(response);
-    finish_ops_.AllowNoMessage();
-    if (start) {
-      StartCallInternal(tag);
-    } else {
-      GPR_CODEGEN_ASSERT(tag == nullptr);
-    }
-  }
-
-  void StartCallInternal(void* tag) {
-    write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                   context_->initial_metadata_flags());
-    // if corked bit is set in context, we just keep the initial metadata
-    // buffered up to coalesce with later message send. No op is performed.
-    if (!context_->initial_metadata_corked_) {
-      write_ops_.set_output_tag(tag);
-      call_.PerformOps(&write_ops_);
-    }
-  }
-
-  grpc::ClientContext* context_;
-  grpc::internal::Call call_;
-  bool started_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
-      meta_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpClientSendClose>
-      write_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                            grpc::internal::CallOpGenericRecvMessage,
-                            grpc::internal::CallOpClientRecvStatus>
-      finish_ops_;
-};
-
-/// Async client-side interface for bi-directional streaming,
-/// where the client-to-server message stream has messages of type \a W,
-/// and the server-to-client message stream has messages of type \a R.
-template <class W, class R>
-class ClientAsyncReaderWriterInterface
-    : public internal::ClientAsyncStreamingInterface,
-      public internal::AsyncWriterInterface<W>,
-      public internal::AsyncReaderInterface<R> {
- public:
-  /// Signal the client is done with the writes (half-close the client stream).
-  /// Thread-safe with respect to \a AsyncReaderInterface::Read
-  ///
-  /// \param[in] tag The tag identifying the operation.
-  virtual void WritesDone(void* tag) = 0;
-};
-
-namespace internal {
-template <class W, class R>
-class ClientAsyncReaderWriterFactory {
- public:
-  /// Create a stream object.
-  /// Start the RPC request if \a start is set.
-  /// \a tag will be notified on \a cq when the call has been started (i.e.
-  /// intitial metadata sent). If \a start is not set, \a tag must be
-  /// nullptr and the actual call must be initiated by StartCall
-  /// Note that \a context will be used to fill in custom initial metadata
-  /// used to send to the server when starting the call.
-  static ClientAsyncReaderWriter<W, R>* Create(
-      grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
-      const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
-      bool start, void* tag) {
-    grpc::internal::Call call = channel->CreateCall(method, context, cq);
-
-    return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call.call(), sizeof(ClientAsyncReaderWriter<W, R>)))
-        ClientAsyncReaderWriter<W, R>(call, context, start, tag);
-  }
-};
-}  // namespace internal
-
-/// Async client-side interface for bi-directional streaming,
-/// where the outgoing message stream going to the server
-/// has messages of type \a W,  and the incoming message stream coming
-/// from the server has messages of type \a R.
-template <class W, class R>
-class ClientAsyncReaderWriter final
-    : public ClientAsyncReaderWriterInterface<W, R> {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncReaderWriter));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  void StartCall(void* tag) override {
-    GPR_CODEGEN_ASSERT(!started_);
-    started_ = true;
-    StartCallInternal(tag);
-  }
-
-  /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata method
-  /// for semantics of this method.
-  ///
-  /// Side effect:
-  ///   - upon receiving initial metadata from the server, the \a ClientContext
-  ///     is updated with it, and then the receiving initial metadata can
-  ///     be accessed through this \a ClientContext.
-  void ReadInitialMetadata(void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
-
-    meta_ops_.set_output_tag(tag);
-    meta_ops_.RecvInitialMetadata(context_);
-    call_.PerformOps(&meta_ops_);
-  }
-
-  void Read(R* msg, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    read_ops_.set_output_tag(tag);
-    if (!context_->initial_metadata_received_) {
-      read_ops_.RecvInitialMetadata(context_);
-    }
-    read_ops_.RecvMessage(msg);
-    call_.PerformOps(&read_ops_);
-  }
-
-  void Write(const W& msg, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    write_ops_.set_output_tag(tag);
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
-    call_.PerformOps(&write_ops_);
-  }
-
-  void Write(const W& msg, grpc::WriteOptions options, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    write_ops_.set_output_tag(tag);
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-      write_ops_.ClientSendClose();
-    }
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
-    call_.PerformOps(&write_ops_);
-  }
-
-  void WritesDone(void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    write_ops_.set_output_tag(tag);
-    write_ops_.ClientSendClose();
-    call_.PerformOps(&write_ops_);
-  }
-
-  /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
-  /// Side effect
-  ///   - the \a ClientContext associated with this call is updated with
-  ///     possible initial and trailing metadata sent from the server.
-  void Finish(grpc::Status* status, void* tag) override {
-    GPR_CODEGEN_ASSERT(started_);
-    finish_ops_.set_output_tag(tag);
-    if (!context_->initial_metadata_received_) {
-      finish_ops_.RecvInitialMetadata(context_);
-    }
-    finish_ops_.ClientRecvStatus(context_, status);
-    call_.PerformOps(&finish_ops_);
-  }
-
- private:
-  friend class internal::ClientAsyncReaderWriterFactory<W, R>;
-  ClientAsyncReaderWriter(grpc::internal::Call call,
-                          grpc::ClientContext* context, bool start, void* tag)
-      : context_(context), call_(call), started_(start) {
-    if (start) {
-      StartCallInternal(tag);
-    } else {
-      GPR_CODEGEN_ASSERT(tag == nullptr);
-    }
-  }
-
-  void StartCallInternal(void* tag) {
-    write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                   context_->initial_metadata_flags());
-    // if corked bit is set in context, we just keep the initial metadata
-    // buffered up to coalesce with later message send. No op is performed.
-    if (!context_->initial_metadata_corked_) {
-      write_ops_.set_output_tag(tag);
-      call_.PerformOps(&write_ops_);
-    }
-  }
-
-  grpc::ClientContext* context_;
-  grpc::internal::Call call_;
-  bool started_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
-      meta_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                            grpc::internal::CallOpRecvMessage<R>>
-      read_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpClientSendClose>
-      write_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                            grpc::internal::CallOpClientRecvStatus>
-      finish_ops_;
-};
-
-template <class W, class R>
-class ServerAsyncReaderInterface
-    : public grpc::internal::ServerAsyncStreamingInterface,
-      public internal::AsyncReaderInterface<R> {
- public:
-  /// Indicate that the stream is to be finished with a certain status code
-  /// and also send out \a msg response to the client.
-  /// Request notification for when the server has sent the response and the
-  /// appropriate signals to the client to end the call.
-  /// Should not be used concurrently with other operations.
-  ///
-  /// It is appropriate to call this method when:
-  ///   * all messages from the client have been received (either known
-  ///     implictly, or explicitly because a previous
-  ///     \a AsyncReaderInterface::Read operation with a non-ok result,
-  ///     e.g., cq->Next(&read_tag, &ok) filled in 'ok' with 'false').
-  ///
-  /// This operation will end when the server has finished sending out initial
-  /// metadata (if not sent already), response message, and status, or if
-  /// some failure occurred when trying to do so.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a msg or \a status, so it
-  /// is safe to deallocate once Finish returns.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  /// \param[in] status To be sent to the client as the result of this call.
-  /// \param[in] msg To be sent to the client as the response for this call.
-  virtual void Finish(const W& msg, const grpc::Status& status, void* tag) = 0;
-
-  /// Indicate that the stream is to be finished with a certain
-  /// non-OK status code.
-  /// Request notification for when the server has sent the appropriate
-  /// signals to the client to end the call.
-  /// Should not be used concurrently with other operations.
-  ///
-  /// This call is meant to end the call with some error, and can be called at
-  /// any point that the server would like to "fail" the call (though note
-  /// this shouldn't be called concurrently with any other "sending" call, like
-  /// \a AsyncWriterInterface::Write).
-  ///
-  /// This operation will end when the server has finished sending out initial
-  /// metadata (if not sent already), and status, or if some failure occurred
-  /// when trying to do so.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
-  /// to deallocate once FinishWithError returns.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  /// \param[in] status To be sent to the client as the result of this call.
-  ///     - Note: \a status must have a non-OK code.
-  virtual void FinishWithError(const grpc::Status& status, void* tag) = 0;
-};
-
-/// Async server-side API for doing client-streaming RPCs,
-/// where the incoming message stream from the client has messages of type \a R,
-/// and the single response message sent from the server is type \a W.
-template <class W, class R>
-class ServerAsyncReader final : public ServerAsyncReaderInterface<W, R> {
- public:
-  explicit ServerAsyncReader(grpc::ServerContext* ctx)
-      : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
-
-  /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
-  ///
-  /// Implicit input parameter:
-  ///   - The initial metadata that will be sent to the client from this op will
-  ///     be taken from the \a ServerContext associated with the call.
-  void SendInitialMetadata(void* tag) override {
-    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-
-    meta_ops_.set_output_tag(tag);
-    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                  ctx_->initial_metadata_flags());
-    if (ctx_->compression_level_set()) {
-      meta_ops_.set_compression_level(ctx_->compression_level());
-    }
-    ctx_->sent_initial_metadata_ = true;
-    call_.PerformOps(&meta_ops_);
-  }
-
-  void Read(R* msg, void* tag) override {
-    read_ops_.set_output_tag(tag);
-    read_ops_.RecvMessage(msg);
-    call_.PerformOps(&read_ops_);
-  }
-
-  /// See the \a ServerAsyncReaderInterface.Read method for semantics
-  ///
-  /// Side effect:
-  ///   - also sends initial metadata if not alreay sent.
-  ///   - uses the \a ServerContext associated with this call to send possible
-  ///     initial and trailing metadata.
-  ///
-  /// Note: \a msg is not sent if \a status has a non-OK code.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
-  /// is safe to deallocate once Finish returns.
-  void Finish(const W& msg, const grpc::Status& status, void* tag) override {
-    finish_ops_.set_output_tag(tag);
-    if (!ctx_->sent_initial_metadata_) {
-      finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                      ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        finish_ops_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-    }
-    // The response is dropped if the status is not OK.
-    if (status.ok()) {
-      finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_,
-                                   finish_ops_.SendMessage(msg));
-    } else {
-      finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
-    }
-    call_.PerformOps(&finish_ops_);
-  }
-
-  /// See the \a ServerAsyncReaderInterface.Read method for semantics
-  ///
-  /// Side effect:
-  ///   - also sends initial metadata if not alreay sent.
-  ///   - uses the \a ServerContext associated with this call to send possible
-  ///     initial and trailing metadata.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
-  /// to deallocate once FinishWithError returns.
-  void FinishWithError(const grpc::Status& status, void* tag) override {
-    GPR_CODEGEN_ASSERT(!status.ok());
-    finish_ops_.set_output_tag(tag);
-    if (!ctx_->sent_initial_metadata_) {
-      finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                      ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        finish_ops_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-    }
-    finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
-    call_.PerformOps(&finish_ops_);
-  }
-
- private:
-  void BindCall(grpc::internal::Call* call) override { call_ = *call; }
-
-  grpc::internal::Call call_;
-  grpc::ServerContext* ctx_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
-      meta_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> read_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpServerSendStatus>
-      finish_ops_;
-};
-
-template <class W>
-class ServerAsyncWriterInterface
-    : public grpc::internal::ServerAsyncStreamingInterface,
-      public internal::AsyncWriterInterface<W> {
- public:
-  /// Indicate that the stream is to be finished with a certain status code.
-  /// Request notification for when the server has sent the appropriate
-  /// signals to the client to end the call.
-  /// Should not be used concurrently with other operations.
-  ///
-  /// It is appropriate to call this method when either:
-  ///   * all messages from the client have been received (either known
-  ///     implictly, or explicitly because a previous \a
-  ///     AsyncReaderInterface::Read operation with a non-ok
-  ///     result (e.g., cq->Next(&read_tag, &ok) filled in 'ok' with 'false'.
-  ///   * it is desired to end the call early with some non-OK status code.
-  ///
-  /// This operation will end when the server has finished sending out initial
-  /// metadata (if not sent already), response message, and status, or if
-  /// some failure occurred when trying to do so.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
-  /// to deallocate once Finish returns.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  /// \param[in] status To be sent to the client as the result of this call.
-  virtual void Finish(const grpc::Status& status, void* tag) = 0;
-
-  /// Request the writing of \a msg and coalesce it with trailing metadata which
-  /// contains \a status, using WriteOptions options with
-  /// identifying tag \a tag.
-  ///
-  /// WriteAndFinish is equivalent of performing WriteLast and Finish
-  /// in a single step.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
-  /// is safe to deallocate once WriteAndFinish returns.
-  ///
-  /// \param[in] msg The message to be written.
-  /// \param[in] options The WriteOptions to be used to write this message.
-  /// \param[in] status The Status that server returns to client.
-  /// \param[in] tag The tag identifying the operation.
-  virtual void WriteAndFinish(const W& msg, grpc::WriteOptions options,
-                              const grpc::Status& status, void* tag) = 0;
-};
-
-/// Async server-side API for doing server streaming RPCs,
-/// where the outgoing message stream from the server has messages of type \a W.
-template <class W>
-class ServerAsyncWriter final : public ServerAsyncWriterInterface<W> {
- public:
-  explicit ServerAsyncWriter(grpc::ServerContext* ctx)
-      : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
-
-  /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
-  ///
-  /// Implicit input parameter:
-  ///   - The initial metadata that will be sent to the client from this op will
-  ///     be taken from the \a ServerContext associated with the call.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  void SendInitialMetadata(void* tag) override {
-    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-
-    meta_ops_.set_output_tag(tag);
-    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                  ctx_->initial_metadata_flags());
-    if (ctx_->compression_level_set()) {
-      meta_ops_.set_compression_level(ctx_->compression_level());
-    }
-    ctx_->sent_initial_metadata_ = true;
-    call_.PerformOps(&meta_ops_);
-  }
-
-  void Write(const W& msg, void* tag) override {
-    write_ops_.set_output_tag(tag);
-    EnsureInitialMetadataSent(&write_ops_);
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
-    call_.PerformOps(&write_ops_);
-  }
-
-  void Write(const W& msg, grpc::WriteOptions options, void* tag) override {
-    write_ops_.set_output_tag(tag);
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-    }
-
-    EnsureInitialMetadataSent(&write_ops_);
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
-    call_.PerformOps(&write_ops_);
-  }
-
-  /// See the \a ServerAsyncWriterInterface.WriteAndFinish method for semantics.
-  ///
-  /// Implicit input parameter:
-  ///   - the \a ServerContext associated with this call is used
-  ///     for sending trailing (and initial) metadata to the client.
-  ///
-  /// Note: \a status must have an OK code.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
-  /// is safe to deallocate once WriteAndFinish returns.
-  void WriteAndFinish(const W& msg, grpc::WriteOptions options,
-                      const grpc::Status& status, void* tag) override {
-    write_ops_.set_output_tag(tag);
-    EnsureInitialMetadataSent(&write_ops_);
-    options.set_buffer_hint();
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
-    write_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
-    call_.PerformOps(&write_ops_);
-  }
-
-  /// See the \a ServerAsyncWriterInterface.Finish method for semantics.
-  ///
-  /// Implicit input parameter:
-  ///   - the \a ServerContext associated with this call is used for sending
-  ///     trailing (and initial if not already sent) metadata to the client.
-  ///
-  /// Note: there are no restrictions are the code of
-  /// \a status,it may be non-OK
-  ///
-  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
-  /// to deallocate once Finish returns.
-  void Finish(const grpc::Status& status, void* tag) override {
-    finish_ops_.set_output_tag(tag);
-    EnsureInitialMetadataSent(&finish_ops_);
-    finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
-    call_.PerformOps(&finish_ops_);
-  }
-
- private:
-  void BindCall(grpc::internal::Call* call) override { call_ = *call; }
-
-  template <class T>
-  void EnsureInitialMetadataSent(T* ops) {
-    if (!ctx_->sent_initial_metadata_) {
-      ops->SendInitialMetadata(&ctx_->initial_metadata_,
-                               ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        ops->set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-    }
-  }
-
-  grpc::internal::Call call_;
-  grpc::ServerContext* ctx_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
-      meta_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpServerSendStatus>
-      write_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpServerSendStatus>
-      finish_ops_;
-};
-
-/// Server-side interface for asynchronous bi-directional streaming.
-template <class W, class R>
-class ServerAsyncReaderWriterInterface
-    : public grpc::internal::ServerAsyncStreamingInterface,
-      public internal::AsyncWriterInterface<W>,
-      public internal::AsyncReaderInterface<R> {
- public:
-  /// Indicate that the stream is to be finished with a certain status code.
-  /// Request notification for when the server has sent the appropriate
-  /// signals to the client to end the call.
-  /// Should not be used concurrently with other operations.
-  ///
-  /// It is appropriate to call this method when either:
-  ///   * all messages from the client have been received (either known
-  ///     implictly, or explicitly because a previous \a
-  ///     AsyncReaderInterface::Read operation
-  ///     with a non-ok result (e.g., cq->Next(&read_tag, &ok) filled in 'ok'
-  ///     with 'false'.
-  ///   * it is desired to end the call early with some non-OK status code.
-  ///
-  /// This operation will end when the server has finished sending out initial
-  /// metadata (if not sent already), response message, and status, or if some
-  /// failure occurred when trying to do so.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
-  /// to deallocate once Finish returns.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  /// \param[in] status To be sent to the client as the result of this call.
-  virtual void Finish(const grpc::Status& status, void* tag) = 0;
-
-  /// Request the writing of \a msg and coalesce it with trailing metadata which
-  /// contains \a status, using WriteOptions options with
-  /// identifying tag \a tag.
-  ///
-  /// WriteAndFinish is equivalent of performing WriteLast and Finish in a
-  /// single step.
-  ///
-  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
-  /// is safe to deallocate once WriteAndFinish returns.
-  ///
-  /// \param[in] msg The message to be written.
-  /// \param[in] options The WriteOptions to be used to write this message.
-  /// \param[in] status The Status that server returns to client.
-  /// \param[in] tag The tag identifying the operation.
-  virtual void WriteAndFinish(const W& msg, grpc::WriteOptions options,
-                              const grpc::Status& status, void* tag) = 0;
-};
-
-/// Async server-side API for doing bidirectional streaming RPCs,
-/// where the incoming message stream coming from the client has messages of
-/// type \a R, and the outgoing message stream coming from the server has
-/// messages of type \a W.
-template <class W, class R>
-class ServerAsyncReaderWriter final
-    : public ServerAsyncReaderWriterInterface<W, R> {
- public:
-  explicit ServerAsyncReaderWriter(grpc::ServerContext* ctx)
-      : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
-
-  /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
-  ///
-  /// Implicit input parameter:
-  ///   - The initial metadata that will be sent to the client from this op will
-  ///     be taken from the \a ServerContext associated with the call.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  void SendInitialMetadata(void* tag) override {
-    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-
-    meta_ops_.set_output_tag(tag);
-    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                  ctx_->initial_metadata_flags());
-    if (ctx_->compression_level_set()) {
-      meta_ops_.set_compression_level(ctx_->compression_level());
-    }
-    ctx_->sent_initial_metadata_ = true;
-    call_.PerformOps(&meta_ops_);
-  }
-
-  void Read(R* msg, void* tag) override {
-    read_ops_.set_output_tag(tag);
-    read_ops_.RecvMessage(msg);
-    call_.PerformOps(&read_ops_);
-  }
-
-  void Write(const W& msg, void* tag) override {
-    write_ops_.set_output_tag(tag);
-    EnsureInitialMetadataSent(&write_ops_);
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
-    call_.PerformOps(&write_ops_);
-  }
-
-  void Write(const W& msg, grpc::WriteOptions options, void* tag) override {
-    write_ops_.set_output_tag(tag);
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-    }
-    EnsureInitialMetadataSent(&write_ops_);
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
-    call_.PerformOps(&write_ops_);
-  }
-
-  /// See the \a ServerAsyncReaderWriterInterface.WriteAndFinish
-  /// method for semantics.
-  ///
-  /// Implicit input parameter:
-  ///   - the \a ServerContext associated with this call is used
-  ///     for sending trailing (and initial) metadata to the client.
-  ///
-  /// Note: \a status must have an OK code.
-  //
-  /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
-  /// is safe to deallocate once WriteAndFinish returns.
-  void WriteAndFinish(const W& msg, grpc::WriteOptions options,
-                      const grpc::Status& status, void* tag) override {
-    write_ops_.set_output_tag(tag);
-    EnsureInitialMetadataSent(&write_ops_);
-    options.set_buffer_hint();
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
-    write_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
-    call_.PerformOps(&write_ops_);
-  }
-
-  /// See the \a ServerAsyncReaderWriterInterface.Finish method for semantics.
-  ///
-  /// Implicit input parameter:
-  ///   - the \a ServerContext associated with this call is used for sending
-  ///     trailing (and initial if not already sent) metadata to the client.
-  ///
-  /// Note: there are no restrictions are the code of \a status,
-  /// it may be non-OK
-  //
-  /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
-  /// to deallocate once Finish returns.
-  void Finish(const grpc::Status& status, void* tag) override {
-    finish_ops_.set_output_tag(tag);
-    EnsureInitialMetadataSent(&finish_ops_);
-
-    finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
-    call_.PerformOps(&finish_ops_);
-  }
-
- private:
-  friend class grpc::Server;
-
-  void BindCall(grpc::internal::Call* call) override { call_ = *call; }
-
-  template <class T>
-  void EnsureInitialMetadataSent(T* ops) {
-    if (!ctx_->sent_initial_metadata_) {
-      ops->SendInitialMetadata(&ctx_->initial_metadata_,
-                               ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        ops->set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-    }
-  }
-
-  grpc::internal::Call call_;
-  grpc::ServerContext* ctx_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
-      meta_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> read_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpServerSendStatus>
-      write_ops_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpServerSendStatus>
-      finish_ops_;
-};
+namespace grpc
+{
+
+    namespace internal
+    {
+        /// Common interface for all client side asynchronous streaming.
+        class ClientAsyncStreamingInterface
+        {
+        public:
+            virtual ~ClientAsyncStreamingInterface()
+            {
+            }
+
+            /// Start the call that was set up by the constructor, but only if the
+            /// constructor was invoked through the "Prepare" API which doesn't actually
+            /// start the call
+            virtual void StartCall(void* tag) = 0;
+
+            /// Request notification of the reading of the initial metadata. Completion
+            /// will be notified by \a tag on the associated completion queue.
+            /// This call is optional, but if it is used, it cannot be used concurrently
+            /// with or after the \a AsyncReaderInterface::Read method.
+            ///
+            /// \param[in] tag Tag identifying this request.
+            virtual void ReadInitialMetadata(void* tag) = 0;
+
+            /// Indicate that the stream is to be finished and request notification for
+            /// when the call has been ended.
+            /// Should not be used concurrently with other operations.
+            ///
+            /// It is appropriate to call this method exactly once when both:
+            ///   * the client side has no more message to send
+            ///     (this can be declared implicitly by calling this method, or
+            ///     explicitly through an earlier call to the <i>WritesDone</i> method
+            ///     of the class in use, e.g. \a ClientAsyncWriterInterface::WritesDone or
+            ///     \a ClientAsyncReaderWriterInterface::WritesDone).
+            ///   * there are no more messages to be received from the server (this can
+            ///     be known implicitly by the calling code, or explicitly from an
+            ///     earlier call to \a AsyncReaderInterface::Read that yielded a failed
+            ///     result, e.g. cq->Next(&read_tag, &ok) filled in 'ok' with 'false').
+            ///
+            /// The tag will be returned when either:
+            /// - all incoming messages have been read and the server has returned
+            ///   a status.
+            /// - the server has returned a non-OK status.
+            /// - the call failed for some reason and the library generated a
+            ///   status.
+            ///
+            /// Note that implementations of this method attempt to receive initial
+            /// metadata from the server if initial metadata hasn't yet been received.
+            ///
+            /// \param[in] tag Tag identifying this request.
+            /// \param[out] status To be updated with the operation status.
+            virtual void Finish(grpc::Status* status, void* tag) = 0;
+        };
+
+        /// An interface that yields a sequence of messages of type \a R.
+        template<class R>
+        class AsyncReaderInterface
+        {
+        public:
+            virtual ~AsyncReaderInterface()
+            {
+            }
+
+            /// Read a message of type \a R into \a msg. Completion will be notified by \a
+            /// tag on the associated completion queue.
+            /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
+            /// should not be called concurrently with other streaming APIs
+            /// on the same stream. It is not meaningful to call it concurrently
+            /// with another \a AsyncReaderInterface::Read on the same stream since reads
+            /// on the same stream are delivered in order.
+            ///
+            /// \param[out] msg Where to eventually store the read message.
+            /// \param[in] tag The tag identifying the operation.
+            ///
+            /// Side effect: note that this method attempt to receive initial metadata for
+            /// a stream if it hasn't yet been received.
+            virtual void Read(R* msg, void* tag) = 0;
+        };
+
+        /// An interface that can be fed a sequence of messages of type \a W.
+        template<class W>
+        class AsyncWriterInterface
+        {
+        public:
+            virtual ~AsyncWriterInterface()
+            {
+            }
+
+            /// Request the writing of \a msg with identifying tag \a tag.
+            ///
+            /// Only one write may be outstanding at any given time. This means that
+            /// after calling Write, one must wait to receive \a tag from the completion
+            /// queue BEFORE calling Write again.
+            /// This is thread-safe with respect to \a AsyncReaderInterface::Read
+            ///
+            /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
+            /// to deallocate once Write returns.
+            ///
+            /// \param[in] msg The message to be written.
+            /// \param[in] tag The tag identifying the operation.
+            virtual void Write(const W& msg, void* tag) = 0;
+
+            /// Request the writing of \a msg using WriteOptions \a options with
+            /// identifying tag \a tag.
+            ///
+            /// Only one write may be outstanding at any given time. This means that
+            /// after calling Write, one must wait to receive \a tag from the completion
+            /// queue BEFORE calling Write again.
+            /// WriteOptions \a options is used to set the write options of this message.
+            /// This is thread-safe with respect to \a AsyncReaderInterface::Read
+            ///
+            /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
+            /// to deallocate once Write returns.
+            ///
+            /// \param[in] msg The message to be written.
+            /// \param[in] options The WriteOptions to be used to write this message.
+            /// \param[in] tag The tag identifying the operation.
+            virtual void Write(const W& msg, grpc::WriteOptions options, void* tag) = 0;
+
+            /// Request the writing of \a msg and coalesce it with the writing
+            /// of trailing metadata, using WriteOptions \a options with
+            /// identifying tag \a tag.
+            ///
+            /// For client, WriteLast is equivalent of performing Write and
+            /// WritesDone in a single step.
+            /// For server, WriteLast buffers the \a msg. The writing of \a msg is held
+            /// until Finish is called, where \a msg and trailing metadata are coalesced
+            /// and write is initiated. Note that WriteLast can only buffer \a msg up to
+            /// the flow control window size. If \a msg size is larger than the window
+            /// size, it will be sent on wire without buffering.
+            ///
+            /// gRPC doesn't take ownership or a reference to \a msg, so it is safe to
+            /// to deallocate once Write returns.
+            ///
+            /// \param[in] msg The message to be written.
+            /// \param[in] options The WriteOptions to be used to write this message.
+            /// \param[in] tag The tag identifying the operation.
+            void WriteLast(const W& msg, grpc::WriteOptions options, void* tag)
+            {
+                Write(msg, options.set_last_message(), tag);
+            }
+        };
+
+    }  // namespace internal
+
+    template<class R>
+    class ClientAsyncReaderInterface : public internal::ClientAsyncStreamingInterface, public internal::AsyncReaderInterface<R>
+    {
+    };
+
+    namespace internal
+    {
+        template<class R>
+        class ClientAsyncReaderFactory
+        {
+        public:
+            /// Create a stream object.
+            /// Write the first request out if \a start is set.
+            /// \a tag will be notified on \a cq when the call has been started and
+            /// \a request has been written out. If \a start is not set, \a tag must be
+            /// nullptr and the actual call must be initiated by StartCall
+            /// Note that \a context will be used to fill in custom initial metadata
+            /// used to send to the server when starting the call.
+            template<class W>
+            static ClientAsyncReader<R>* Create(grpc::ChannelInterface* channel, grpc::CompletionQueue* cq, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const W& request, bool start, void* tag)
+            {
+                grpc::internal::Call call = channel->CreateCall(method, context, cq);
+                return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call.call(), sizeof(ClientAsyncReader<R>)
+                ))
+                    ClientAsyncReader<R>(call, context, request, start, tag);
+            }
+        };
+    }  // namespace internal
+
+    /// Async client-side API for doing server-streaming RPCs,
+    /// where the incoming message stream coming from the server has
+    /// messages of type \a R.
+    template<class R>
+    class ClientAsyncReader final : public ClientAsyncReaderInterface<R>
+    {
+    public:
+        // always allocated against a call arena, no memory free required
+        static void operator delete(void* /*ptr*/, std::size_t size)
+        {
+            GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncReader));
+        }
+
+        // This operator should never be called as the memory should be freed as part
+        // of the arena destruction. It only exists to provide a matching operator
+        // delete to the operator new so that some compilers will not complain (see
+        // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+        // there are no tests catching the compiler warning.
+        static void operator delete(void*, void*)
+        {
+            GPR_CODEGEN_ASSERT(false);
+        }
+
+        void StartCall(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(!started_);
+            started_ = true;
+            StartCallInternal(tag);
+        }
+
+        /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata
+        /// method for semantics.
+        ///
+        /// Side effect:
+        ///   - upon receiving initial metadata from the server,
+        ///     the \a ClientContext associated with this call is updated, and the
+        ///     calling code can access the received metadata through the
+        ///     \a ClientContext.
+        void ReadInitialMetadata(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+            meta_ops_.set_output_tag(tag);
+            meta_ops_.RecvInitialMetadata(context_);
+            call_.PerformOps(&meta_ops_);
+        }
+
+        void Read(R* msg, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            read_ops_.set_output_tag(tag);
+            if (!context_->initial_metadata_received_)
+            {
+                read_ops_.RecvInitialMetadata(context_);
+            }
+            read_ops_.RecvMessage(msg);
+            call_.PerformOps(&read_ops_);
+        }
+
+        /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
+        ///
+        /// Side effect:
+        ///   - the \a ClientContext associated with this call is updated with
+        ///     possible initial and trailing metadata received from the server.
+        void Finish(grpc::Status* status, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            finish_ops_.set_output_tag(tag);
+            if (!context_->initial_metadata_received_)
+            {
+                finish_ops_.RecvInitialMetadata(context_);
+            }
+            finish_ops_.ClientRecvStatus(context_, status);
+            call_.PerformOps(&finish_ops_);
+        }
+
+    private:
+        friend class internal::ClientAsyncReaderFactory<R>;
+        template<class W>
+        ClientAsyncReader(grpc::internal::Call call, grpc::ClientContext* context, const W& request, bool start, void* tag) :
+            context_(context),
+            call_(call),
+            started_(start)
+        {
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(init_ops_.SendMessage(request).ok());
+            init_ops_.ClientSendClose();
+            if (start)
+            {
+                StartCallInternal(tag);
+            }
+            else
+            {
+                GPR_CODEGEN_ASSERT(tag == nullptr);
+            }
+        }
+
+        void StartCallInternal(void* tag)
+        {
+            init_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+            init_ops_.set_output_tag(tag);
+            call_.PerformOps(&init_ops_);
+        }
+
+        grpc::ClientContext* context_;
+        grpc::internal::Call call_;
+        bool started_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose>
+            init_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
+            meta_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpRecvMessage<R>>
+            read_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpClientRecvStatus>
+            finish_ops_;
+    };
+
+    /// Common interface for client side asynchronous writing.
+    template<class W>
+    class ClientAsyncWriterInterface : public internal::ClientAsyncStreamingInterface, public internal::AsyncWriterInterface<W>
+    {
+    public:
+        /// Signal the client is done with the writes (half-close the client stream).
+        /// Thread-safe with respect to \a AsyncReaderInterface::Read
+        ///
+        /// \param[in] tag The tag identifying the operation.
+        virtual void WritesDone(void* tag) = 0;
+    };
+
+    namespace internal
+    {
+        template<class W>
+        class ClientAsyncWriterFactory
+        {
+        public:
+            /// Create a stream object.
+            /// Start the RPC if \a start is set
+            /// \a tag will be notified on \a cq when the call has been started (i.e.
+            /// intitial metadata sent) and \a request has been written out.
+            /// If \a start is not set, \a tag must be nullptr and the actual call
+            /// must be initiated by StartCall
+            /// Note that \a context will be used to fill in custom initial metadata
+            /// used to send to the server when starting the call.
+            /// \a response will be filled in with the single expected response
+            /// message from the server upon a successful call to the \a Finish
+            /// method of this instance.
+            template<class R>
+            static ClientAsyncWriter<W>* Create(grpc::ChannelInterface* channel, grpc::CompletionQueue* cq, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, R* response, bool start, void* tag)
+            {
+                grpc::internal::Call call = channel->CreateCall(method, context, cq);
+                return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call.call(), sizeof(ClientAsyncWriter<W>)
+                ))
+                    ClientAsyncWriter<W>(call, context, response, start, tag);
+            }
+        };
+    }  // namespace internal
+
+    /// Async API on the client side for doing client-streaming RPCs,
+    /// where the outgoing message stream going to the server contains
+    /// messages of type \a W.
+    template<class W>
+    class ClientAsyncWriter final : public ClientAsyncWriterInterface<W>
+    {
+    public:
+        // always allocated against a call arena, no memory free required
+        static void operator delete(void* /*ptr*/, std::size_t size)
+        {
+            GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncWriter));
+        }
+
+        // This operator should never be called as the memory should be freed as part
+        // of the arena destruction. It only exists to provide a matching operator
+        // delete to the operator new so that some compilers will not complain (see
+        // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+        // there are no tests catching the compiler warning.
+        static void operator delete(void*, void*)
+        {
+            GPR_CODEGEN_ASSERT(false);
+        }
+
+        void StartCall(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(!started_);
+            started_ = true;
+            StartCallInternal(tag);
+        }
+
+        /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata method for
+        /// semantics.
+        ///
+        /// Side effect:
+        ///   - upon receiving initial metadata from the server, the \a ClientContext
+        ///     associated with this call is updated, and the calling code can access
+        ///     the received metadata through the \a ClientContext.
+        void ReadInitialMetadata(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+            meta_ops_.set_output_tag(tag);
+            meta_ops_.RecvInitialMetadata(context_);
+            call_.PerformOps(&meta_ops_);
+        }
+
+        void Write(const W& msg, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            write_ops_.set_output_tag(tag);
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
+            call_.PerformOps(&write_ops_);
+        }
+
+        void Write(const W& msg, grpc::WriteOptions options, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            write_ops_.set_output_tag(tag);
+            if (options.is_last_message())
+            {
+                options.set_buffer_hint();
+                write_ops_.ClientSendClose();
+            }
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+            call_.PerformOps(&write_ops_);
+        }
+
+        void WritesDone(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            write_ops_.set_output_tag(tag);
+            write_ops_.ClientSendClose();
+            call_.PerformOps(&write_ops_);
+        }
+
+        /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
+        ///
+        /// Side effect:
+        ///   - the \a ClientContext associated with this call is updated with
+        ///     possible initial and trailing metadata received from the server.
+        ///   - attempts to fill in the \a response parameter passed to this class's
+        ///     constructor with the server's response message.
+        void Finish(grpc::Status* status, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            finish_ops_.set_output_tag(tag);
+            if (!context_->initial_metadata_received_)
+            {
+                finish_ops_.RecvInitialMetadata(context_);
+            }
+            finish_ops_.ClientRecvStatus(context_, status);
+            call_.PerformOps(&finish_ops_);
+        }
+
+    private:
+        friend class internal::ClientAsyncWriterFactory<W>;
+        template<class R>
+        ClientAsyncWriter(grpc::internal::Call call, grpc::ClientContext* context, R* response, bool start, void* tag) :
+            context_(context),
+            call_(call),
+            started_(start)
+        {
+            finish_ops_.RecvMessage(response);
+            finish_ops_.AllowNoMessage();
+            if (start)
+            {
+                StartCallInternal(tag);
+            }
+            else
+            {
+                GPR_CODEGEN_ASSERT(tag == nullptr);
+            }
+        }
+
+        void StartCallInternal(void* tag)
+        {
+            write_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+            // if corked bit is set in context, we just keep the initial metadata
+            // buffered up to coalesce with later message send. No op is performed.
+            if (!context_->initial_metadata_corked_)
+            {
+                write_ops_.set_output_tag(tag);
+                call_.PerformOps(&write_ops_);
+            }
+        }
+
+        grpc::ClientContext* context_;
+        grpc::internal::Call call_;
+        bool started_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
+            meta_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose>
+            write_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpGenericRecvMessage, grpc::internal::CallOpClientRecvStatus>
+            finish_ops_;
+    };
+
+    /// Async client-side interface for bi-directional streaming,
+    /// where the client-to-server message stream has messages of type \a W,
+    /// and the server-to-client message stream has messages of type \a R.
+    template<class W, class R>
+    class ClientAsyncReaderWriterInterface : public internal::ClientAsyncStreamingInterface, public internal::AsyncWriterInterface<W>, public internal::AsyncReaderInterface<R>
+    {
+    public:
+        /// Signal the client is done with the writes (half-close the client stream).
+        /// Thread-safe with respect to \a AsyncReaderInterface::Read
+        ///
+        /// \param[in] tag The tag identifying the operation.
+        virtual void WritesDone(void* tag) = 0;
+    };
+
+    namespace internal
+    {
+        template<class W, class R>
+        class ClientAsyncReaderWriterFactory
+        {
+        public:
+            /// Create a stream object.
+            /// Start the RPC request if \a start is set.
+            /// \a tag will be notified on \a cq when the call has been started (i.e.
+            /// intitial metadata sent). If \a start is not set, \a tag must be
+            /// nullptr and the actual call must be initiated by StartCall
+            /// Note that \a context will be used to fill in custom initial metadata
+            /// used to send to the server when starting the call.
+            static ClientAsyncReaderWriter<W, R>* Create(
+                grpc::ChannelInterface* channel, grpc::CompletionQueue* cq, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, bool start, void* tag
+            )
+            {
+                grpc::internal::Call call = channel->CreateCall(method, context, cq);
+
+                return new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call.call(), sizeof(ClientAsyncReaderWriter<W, R>)
+                ))
+                    ClientAsyncReaderWriter<W, R>(call, context, start, tag);
+            }
+        };
+    }  // namespace internal
+
+    /// Async client-side interface for bi-directional streaming,
+    /// where the outgoing message stream going to the server
+    /// has messages of type \a W,  and the incoming message stream coming
+    /// from the server has messages of type \a R.
+    template<class W, class R>
+    class ClientAsyncReaderWriter final : public ClientAsyncReaderWriterInterface<W, R>
+    {
+    public:
+        // always allocated against a call arena, no memory free required
+        static void operator delete(void* /*ptr*/, std::size_t size)
+        {
+            GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncReaderWriter));
+        }
+
+        // This operator should never be called as the memory should be freed as part
+        // of the arena destruction. It only exists to provide a matching operator
+        // delete to the operator new so that some compilers will not complain (see
+        // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+        // there are no tests catching the compiler warning.
+        static void operator delete(void*, void*)
+        {
+            GPR_CODEGEN_ASSERT(false);
+        }
+
+        void StartCall(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(!started_);
+            started_ = true;
+            StartCallInternal(tag);
+        }
+
+        /// See the \a ClientAsyncStreamingInterface.ReadInitialMetadata method
+        /// for semantics of this method.
+        ///
+        /// Side effect:
+        ///   - upon receiving initial metadata from the server, the \a ClientContext
+        ///     is updated with it, and then the receiving initial metadata can
+        ///     be accessed through this \a ClientContext.
+        void ReadInitialMetadata(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+            meta_ops_.set_output_tag(tag);
+            meta_ops_.RecvInitialMetadata(context_);
+            call_.PerformOps(&meta_ops_);
+        }
+
+        void Read(R* msg, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            read_ops_.set_output_tag(tag);
+            if (!context_->initial_metadata_received_)
+            {
+                read_ops_.RecvInitialMetadata(context_);
+            }
+            read_ops_.RecvMessage(msg);
+            call_.PerformOps(&read_ops_);
+        }
+
+        void Write(const W& msg, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            write_ops_.set_output_tag(tag);
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
+            call_.PerformOps(&write_ops_);
+        }
+
+        void Write(const W& msg, grpc::WriteOptions options, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            write_ops_.set_output_tag(tag);
+            if (options.is_last_message())
+            {
+                options.set_buffer_hint();
+                write_ops_.ClientSendClose();
+            }
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+            call_.PerformOps(&write_ops_);
+        }
+
+        void WritesDone(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            write_ops_.set_output_tag(tag);
+            write_ops_.ClientSendClose();
+            call_.PerformOps(&write_ops_);
+        }
+
+        /// See the \a ClientAsyncStreamingInterface.Finish method for semantics.
+        /// Side effect
+        ///   - the \a ClientContext associated with this call is updated with
+        ///     possible initial and trailing metadata sent from the server.
+        void Finish(grpc::Status* status, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(started_);
+            finish_ops_.set_output_tag(tag);
+            if (!context_->initial_metadata_received_)
+            {
+                finish_ops_.RecvInitialMetadata(context_);
+            }
+            finish_ops_.ClientRecvStatus(context_, status);
+            call_.PerformOps(&finish_ops_);
+        }
+
+    private:
+        friend class internal::ClientAsyncReaderWriterFactory<W, R>;
+        ClientAsyncReaderWriter(grpc::internal::Call call, grpc::ClientContext* context, bool start, void* tag) :
+            context_(context),
+            call_(call),
+            started_(start)
+        {
+            if (start)
+            {
+                StartCallInternal(tag);
+            }
+            else
+            {
+                GPR_CODEGEN_ASSERT(tag == nullptr);
+            }
+        }
+
+        void StartCallInternal(void* tag)
+        {
+            write_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+            // if corked bit is set in context, we just keep the initial metadata
+            // buffered up to coalesce with later message send. No op is performed.
+            if (!context_->initial_metadata_corked_)
+            {
+                write_ops_.set_output_tag(tag);
+                call_.PerformOps(&write_ops_);
+            }
+        }
+
+        grpc::ClientContext* context_;
+        grpc::internal::Call call_;
+        bool started_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata>
+            meta_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpRecvMessage<R>>
+            read_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose>
+            write_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpClientRecvStatus>
+            finish_ops_;
+    };
+
+    template<class W, class R>
+    class ServerAsyncReaderInterface : public grpc::internal::ServerAsyncStreamingInterface, public internal::AsyncReaderInterface<R>
+    {
+    public:
+        /// Indicate that the stream is to be finished with a certain status code
+        /// and also send out \a msg response to the client.
+        /// Request notification for when the server has sent the response and the
+        /// appropriate signals to the client to end the call.
+        /// Should not be used concurrently with other operations.
+        ///
+        /// It is appropriate to call this method when:
+        ///   * all messages from the client have been received (either known
+        ///     implictly, or explicitly because a previous
+        ///     \a AsyncReaderInterface::Read operation with a non-ok result,
+        ///     e.g., cq->Next(&read_tag, &ok) filled in 'ok' with 'false').
+        ///
+        /// This operation will end when the server has finished sending out initial
+        /// metadata (if not sent already), response message, and status, or if
+        /// some failure occurred when trying to do so.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a msg or \a status, so it
+        /// is safe to deallocate once Finish returns.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        /// \param[in] status To be sent to the client as the result of this call.
+        /// \param[in] msg To be sent to the client as the response for this call.
+        virtual void Finish(const W& msg, const grpc::Status& status, void* tag) = 0;
+
+        /// Indicate that the stream is to be finished with a certain
+        /// non-OK status code.
+        /// Request notification for when the server has sent the appropriate
+        /// signals to the client to end the call.
+        /// Should not be used concurrently with other operations.
+        ///
+        /// This call is meant to end the call with some error, and can be called at
+        /// any point that the server would like to "fail" the call (though note
+        /// this shouldn't be called concurrently with any other "sending" call, like
+        /// \a AsyncWriterInterface::Write).
+        ///
+        /// This operation will end when the server has finished sending out initial
+        /// metadata (if not sent already), and status, or if some failure occurred
+        /// when trying to do so.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+        /// to deallocate once FinishWithError returns.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        /// \param[in] status To be sent to the client as the result of this call.
+        ///     - Note: \a status must have a non-OK code.
+        virtual void FinishWithError(const grpc::Status& status, void* tag) = 0;
+    };
+
+    /// Async server-side API for doing client-streaming RPCs,
+    /// where the incoming message stream from the client has messages of type \a R,
+    /// and the single response message sent from the server is type \a W.
+    template<class W, class R>
+    class ServerAsyncReader final : public ServerAsyncReaderInterface<W, R>
+    {
+    public:
+        explicit ServerAsyncReader(grpc::ServerContext* ctx) :
+            call_(nullptr, nullptr, nullptr),
+            ctx_(ctx)
+        {
+        }
+
+        /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
+        ///
+        /// Implicit input parameter:
+        ///   - The initial metadata that will be sent to the client from this op will
+        ///     be taken from the \a ServerContext associated with the call.
+        void SendInitialMetadata(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+            meta_ops_.set_output_tag(tag);
+            meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+            if (ctx_->compression_level_set())
+            {
+                meta_ops_.set_compression_level(ctx_->compression_level());
+            }
+            ctx_->sent_initial_metadata_ = true;
+            call_.PerformOps(&meta_ops_);
+        }
+
+        void Read(R* msg, void* tag) override
+        {
+            read_ops_.set_output_tag(tag);
+            read_ops_.RecvMessage(msg);
+            call_.PerformOps(&read_ops_);
+        }
+
+        /// See the \a ServerAsyncReaderInterface.Read method for semantics
+        ///
+        /// Side effect:
+        ///   - also sends initial metadata if not alreay sent.
+        ///   - uses the \a ServerContext associated with this call to send possible
+        ///     initial and trailing metadata.
+        ///
+        /// Note: \a msg is not sent if \a status has a non-OK code.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+        /// is safe to deallocate once Finish returns.
+        void Finish(const W& msg, const grpc::Status& status, void* tag) override
+        {
+            finish_ops_.set_output_tag(tag);
+            if (!ctx_->sent_initial_metadata_)
+            {
+                finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                if (ctx_->compression_level_set())
+                {
+                    finish_ops_.set_compression_level(ctx_->compression_level());
+                }
+                ctx_->sent_initial_metadata_ = true;
+            }
+            // The response is dropped if the status is not OK.
+            if (status.ok())
+            {
+                finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, finish_ops_.SendMessage(msg));
+            }
+            else
+            {
+                finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+            }
+            call_.PerformOps(&finish_ops_);
+        }
+
+        /// See the \a ServerAsyncReaderInterface.Read method for semantics
+        ///
+        /// Side effect:
+        ///   - also sends initial metadata if not alreay sent.
+        ///   - uses the \a ServerContext associated with this call to send possible
+        ///     initial and trailing metadata.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+        /// to deallocate once FinishWithError returns.
+        void FinishWithError(const grpc::Status& status, void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(!status.ok());
+            finish_ops_.set_output_tag(tag);
+            if (!ctx_->sent_initial_metadata_)
+            {
+                finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                if (ctx_->compression_level_set())
+                {
+                    finish_ops_.set_compression_level(ctx_->compression_level());
+                }
+                ctx_->sent_initial_metadata_ = true;
+            }
+            finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+            call_.PerformOps(&finish_ops_);
+        }
+
+    private:
+        void BindCall(grpc::internal::Call* call) override
+        {
+            call_ = *call;
+        }
+
+        grpc::internal::Call call_;
+        grpc::ServerContext* ctx_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+            meta_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> read_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+            finish_ops_;
+    };
+
+    template<class W>
+    class ServerAsyncWriterInterface : public grpc::internal::ServerAsyncStreamingInterface, public internal::AsyncWriterInterface<W>
+    {
+    public:
+        /// Indicate that the stream is to be finished with a certain status code.
+        /// Request notification for when the server has sent the appropriate
+        /// signals to the client to end the call.
+        /// Should not be used concurrently with other operations.
+        ///
+        /// It is appropriate to call this method when either:
+        ///   * all messages from the client have been received (either known
+        ///     implictly, or explicitly because a previous \a
+        ///     AsyncReaderInterface::Read operation with a non-ok
+        ///     result (e.g., cq->Next(&read_tag, &ok) filled in 'ok' with 'false'.
+        ///   * it is desired to end the call early with some non-OK status code.
+        ///
+        /// This operation will end when the server has finished sending out initial
+        /// metadata (if not sent already), response message, and status, or if
+        /// some failure occurred when trying to do so.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+        /// to deallocate once Finish returns.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        /// \param[in] status To be sent to the client as the result of this call.
+        virtual void Finish(const grpc::Status& status, void* tag) = 0;
+
+        /// Request the writing of \a msg and coalesce it with trailing metadata which
+        /// contains \a status, using WriteOptions options with
+        /// identifying tag \a tag.
+        ///
+        /// WriteAndFinish is equivalent of performing WriteLast and Finish
+        /// in a single step.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+        /// is safe to deallocate once WriteAndFinish returns.
+        ///
+        /// \param[in] msg The message to be written.
+        /// \param[in] options The WriteOptions to be used to write this message.
+        /// \param[in] status The Status that server returns to client.
+        /// \param[in] tag The tag identifying the operation.
+        virtual void WriteAndFinish(const W& msg, grpc::WriteOptions options, const grpc::Status& status, void* tag) = 0;
+    };
+
+    /// Async server-side API for doing server streaming RPCs,
+    /// where the outgoing message stream from the server has messages of type \a W.
+    template<class W>
+    class ServerAsyncWriter final : public ServerAsyncWriterInterface<W>
+    {
+    public:
+        explicit ServerAsyncWriter(grpc::ServerContext* ctx) :
+            call_(nullptr, nullptr, nullptr),
+            ctx_(ctx)
+        {
+        }
+
+        /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
+        ///
+        /// Implicit input parameter:
+        ///   - The initial metadata that will be sent to the client from this op will
+        ///     be taken from the \a ServerContext associated with the call.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        void SendInitialMetadata(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+            meta_ops_.set_output_tag(tag);
+            meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+            if (ctx_->compression_level_set())
+            {
+                meta_ops_.set_compression_level(ctx_->compression_level());
+            }
+            ctx_->sent_initial_metadata_ = true;
+            call_.PerformOps(&meta_ops_);
+        }
+
+        void Write(const W& msg, void* tag) override
+        {
+            write_ops_.set_output_tag(tag);
+            EnsureInitialMetadataSent(&write_ops_);
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
+            call_.PerformOps(&write_ops_);
+        }
+
+        void Write(const W& msg, grpc::WriteOptions options, void* tag) override
+        {
+            write_ops_.set_output_tag(tag);
+            if (options.is_last_message())
+            {
+                options.set_buffer_hint();
+            }
+
+            EnsureInitialMetadataSent(&write_ops_);
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+            call_.PerformOps(&write_ops_);
+        }
+
+        /// See the \a ServerAsyncWriterInterface.WriteAndFinish method for semantics.
+        ///
+        /// Implicit input parameter:
+        ///   - the \a ServerContext associated with this call is used
+        ///     for sending trailing (and initial) metadata to the client.
+        ///
+        /// Note: \a status must have an OK code.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+        /// is safe to deallocate once WriteAndFinish returns.
+        void WriteAndFinish(const W& msg, grpc::WriteOptions options, const grpc::Status& status, void* tag) override
+        {
+            write_ops_.set_output_tag(tag);
+            EnsureInitialMetadataSent(&write_ops_);
+            options.set_buffer_hint();
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+            write_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+            call_.PerformOps(&write_ops_);
+        }
+
+        /// See the \a ServerAsyncWriterInterface.Finish method for semantics.
+        ///
+        /// Implicit input parameter:
+        ///   - the \a ServerContext associated with this call is used for sending
+        ///     trailing (and initial if not already sent) metadata to the client.
+        ///
+        /// Note: there are no restrictions are the code of
+        /// \a status,it may be non-OK
+        ///
+        /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+        /// to deallocate once Finish returns.
+        void Finish(const grpc::Status& status, void* tag) override
+        {
+            finish_ops_.set_output_tag(tag);
+            EnsureInitialMetadataSent(&finish_ops_);
+            finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+            call_.PerformOps(&finish_ops_);
+        }
+
+    private:
+        void BindCall(grpc::internal::Call* call) override
+        {
+            call_ = *call;
+        }
+
+        template<class T>
+        void EnsureInitialMetadataSent(T* ops)
+        {
+            if (!ctx_->sent_initial_metadata_)
+            {
+                ops->SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                if (ctx_->compression_level_set())
+                {
+                    ops->set_compression_level(ctx_->compression_level());
+                }
+                ctx_->sent_initial_metadata_ = true;
+            }
+        }
+
+        grpc::internal::Call call_;
+        grpc::ServerContext* ctx_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+            meta_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+            write_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpServerSendStatus>
+            finish_ops_;
+    };
+
+    /// Server-side interface for asynchronous bi-directional streaming.
+    template<class W, class R>
+    class ServerAsyncReaderWriterInterface : public grpc::internal::ServerAsyncStreamingInterface, public internal::AsyncWriterInterface<W>, public internal::AsyncReaderInterface<R>
+    {
+    public:
+        /// Indicate that the stream is to be finished with a certain status code.
+        /// Request notification for when the server has sent the appropriate
+        /// signals to the client to end the call.
+        /// Should not be used concurrently with other operations.
+        ///
+        /// It is appropriate to call this method when either:
+        ///   * all messages from the client have been received (either known
+        ///     implictly, or explicitly because a previous \a
+        ///     AsyncReaderInterface::Read operation
+        ///     with a non-ok result (e.g., cq->Next(&read_tag, &ok) filled in 'ok'
+        ///     with 'false'.
+        ///   * it is desired to end the call early with some non-OK status code.
+        ///
+        /// This operation will end when the server has finished sending out initial
+        /// metadata (if not sent already), response message, and status, or if some
+        /// failure occurred when trying to do so.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+        /// to deallocate once Finish returns.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        /// \param[in] status To be sent to the client as the result of this call.
+        virtual void Finish(const grpc::Status& status, void* tag) = 0;
+
+        /// Request the writing of \a msg and coalesce it with trailing metadata which
+        /// contains \a status, using WriteOptions options with
+        /// identifying tag \a tag.
+        ///
+        /// WriteAndFinish is equivalent of performing WriteLast and Finish in a
+        /// single step.
+        ///
+        /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+        /// is safe to deallocate once WriteAndFinish returns.
+        ///
+        /// \param[in] msg The message to be written.
+        /// \param[in] options The WriteOptions to be used to write this message.
+        /// \param[in] status The Status that server returns to client.
+        /// \param[in] tag The tag identifying the operation.
+        virtual void WriteAndFinish(const W& msg, grpc::WriteOptions options, const grpc::Status& status, void* tag) = 0;
+    };
+
+    /// Async server-side API for doing bidirectional streaming RPCs,
+    /// where the incoming message stream coming from the client has messages of
+    /// type \a R, and the outgoing message stream coming from the server has
+    /// messages of type \a W.
+    template<class W, class R>
+    class ServerAsyncReaderWriter final : public ServerAsyncReaderWriterInterface<W, R>
+    {
+    public:
+        explicit ServerAsyncReaderWriter(grpc::ServerContext* ctx) :
+            call_(nullptr, nullptr, nullptr),
+            ctx_(ctx)
+        {
+        }
+
+        /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
+        ///
+        /// Implicit input parameter:
+        ///   - The initial metadata that will be sent to the client from this op will
+        ///     be taken from the \a ServerContext associated with the call.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        void SendInitialMetadata(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+            meta_ops_.set_output_tag(tag);
+            meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+            if (ctx_->compression_level_set())
+            {
+                meta_ops_.set_compression_level(ctx_->compression_level());
+            }
+            ctx_->sent_initial_metadata_ = true;
+            call_.PerformOps(&meta_ops_);
+        }
+
+        void Read(R* msg, void* tag) override
+        {
+            read_ops_.set_output_tag(tag);
+            read_ops_.RecvMessage(msg);
+            call_.PerformOps(&read_ops_);
+        }
+
+        void Write(const W& msg, void* tag) override
+        {
+            write_ops_.set_output_tag(tag);
+            EnsureInitialMetadataSent(&write_ops_);
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg).ok());
+            call_.PerformOps(&write_ops_);
+        }
+
+        void Write(const W& msg, grpc::WriteOptions options, void* tag) override
+        {
+            write_ops_.set_output_tag(tag);
+            if (options.is_last_message())
+            {
+                options.set_buffer_hint();
+            }
+            EnsureInitialMetadataSent(&write_ops_);
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+            call_.PerformOps(&write_ops_);
+        }
+
+        /// See the \a ServerAsyncReaderWriterInterface.WriteAndFinish
+        /// method for semantics.
+        ///
+        /// Implicit input parameter:
+        ///   - the \a ServerContext associated with this call is used
+        ///     for sending trailing (and initial) metadata to the client.
+        ///
+        /// Note: \a status must have an OK code.
+        //
+        /// gRPC doesn't take ownership or a reference to \a msg and \a status, so it
+        /// is safe to deallocate once WriteAndFinish returns.
+        void WriteAndFinish(const W& msg, grpc::WriteOptions options, const grpc::Status& status, void* tag) override
+        {
+            write_ops_.set_output_tag(tag);
+            EnsureInitialMetadataSent(&write_ops_);
+            options.set_buffer_hint();
+            GPR_CODEGEN_ASSERT(write_ops_.SendMessage(msg, options).ok());
+            write_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+            call_.PerformOps(&write_ops_);
+        }
+
+        /// See the \a ServerAsyncReaderWriterInterface.Finish method for semantics.
+        ///
+        /// Implicit input parameter:
+        ///   - the \a ServerContext associated with this call is used for sending
+        ///     trailing (and initial if not already sent) metadata to the client.
+        ///
+        /// Note: there are no restrictions are the code of \a status,
+        /// it may be non-OK
+        //
+        /// gRPC doesn't take ownership or a reference to \a status, so it is safe to
+        /// to deallocate once Finish returns.
+        void Finish(const grpc::Status& status, void* tag) override
+        {
+            finish_ops_.set_output_tag(tag);
+            EnsureInitialMetadataSent(&finish_ops_);
+
+            finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+            call_.PerformOps(&finish_ops_);
+        }
+
+    private:
+        friend class grpc::Server;
+
+        void BindCall(grpc::internal::Call* call) override
+        {
+            call_ = *call;
+        }
+
+        template<class T>
+        void EnsureInitialMetadataSent(T* ops)
+        {
+            if (!ctx_->sent_initial_metadata_)
+            {
+                ops->SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                if (ctx_->compression_level_set())
+                {
+                    ops->set_compression_level(ctx_->compression_level());
+                }
+                ctx_->sent_initial_metadata_ = true;
+            }
+        }
+
+        grpc::internal::Call call_;
+        grpc::ServerContext* ctx_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+            meta_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> read_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+            write_ops_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpServerSendStatus>
+            finish_ops_;
+    };
 
 }  // namespace grpc
 #endif  // GRPCPP_IMPL_CODEGEN_ASYNC_STREAM_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_unary_call.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_unary_call.h
index 0034d21..c58cab4 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_unary_call.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/async_unary_call.h
@@ -30,391 +30,420 @@
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-
-// Forward declaration for use in Helper class
-template <class R>
-class ClientAsyncResponseReader;
-
-/// An interface relevant for async client side unary RPCs (which send
-/// one request message to a server and receive one response message).
-template <class R>
-class ClientAsyncResponseReaderInterface {
- public:
-  virtual ~ClientAsyncResponseReaderInterface() {}
-
-  /// Start the call that was set up by the constructor, but only if the
-  /// constructor was invoked through the "Prepare" API which doesn't actually
-  /// start the call
-  virtual void StartCall() = 0;
-
-  /// Request notification of the reading of initial metadata. Completion
-  /// will be notified by \a tag on the associated completion queue.
-  /// This call is optional, but if it is used, it cannot be used concurrently
-  /// with or after the \a Finish method.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  virtual void ReadInitialMetadata(void* tag) = 0;
-
-  /// Request to receive the server's response \a msg and final \a status for
-  /// the call, and to notify \a tag on this call's completion queue when
-  /// finished.
-  ///
-  /// This function will return when either:
-  /// - when the server's response message and status have been received.
-  /// - when the server has returned a non-OK status (no message expected in
-  ///   this case).
-  /// - when the call failed for some reason and the library generated a
-  ///   non-OK status.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  /// \param[out] status To be updated with the operation status.
-  /// \param[out] msg To be filled in with the server's response message.
-  virtual void Finish(R* msg, grpc::Status* status, void* tag) = 0;
-};
-
-namespace internal {
-
-class ClientAsyncResponseReaderHelper {
- public:
-  /// Start a call and write the request out if \a start is set.
-  /// \a tag will be notified on \a cq when the call has been started (i.e.
-  /// intitial metadata sent) and \a request has been written out.
-  /// If \a start is not set, the actual call must be initiated by StartCall
-  /// Note that \a context will be used to fill in custom initial metadata
-  /// used to send to the server when starting the call.
-  ///
-  /// Optionally pass in a base class for request and response types so that the
-  /// internal functions and structs can be templated based on that, allowing
-  /// reuse across RPCs (e.g., MessageLite for protobuf). Since constructors
-  /// can't have an explicit template parameter, the last argument is an
-  /// extraneous parameter just to provide the needed type information.
-  template <class R, class W, class BaseR = R, class BaseW = W>
-  static ClientAsyncResponseReader<R>* Create(
-      grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
-      const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
-      const W& request) /* __attribute__((noinline)) */ {
-    grpc::internal::Call call = channel->CreateCall(method, context, cq);
-    ClientAsyncResponseReader<R>* result =
-        new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-            call.call(), sizeof(ClientAsyncResponseReader<R>)))
-            ClientAsyncResponseReader<R>(call, context);
-    SetupRequest<BaseR, BaseW>(
-        call.call(), &result->single_buf_, &result->read_initial_metadata_,
-        &result->finish_, static_cast<const BaseW&>(request));
-
-    return result;
-  }
-
-  // Various helper functions to reduce templating use
-
-  template <class R, class W>
-  static void SetupRequest(
-      grpc_call* call,
-      grpc::internal::CallOpSendInitialMetadata** single_buf_ptr,
-      std::function<void(ClientContext*, internal::Call*,
-                         internal::CallOpSendInitialMetadata*, void*)>*
-          read_initial_metadata,
-      std::function<
-          void(ClientContext*, internal::Call*, bool initial_metadata_read,
-               internal::CallOpSendInitialMetadata*,
-               internal::CallOpSetInterface**, void*, Status*, void*)>* finish,
-      const W& request) {
-    using SingleBufType =
-        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                                  grpc::internal::CallOpSendMessage,
-                                  grpc::internal::CallOpClientSendClose,
-                                  grpc::internal::CallOpRecvInitialMetadata,
-                                  grpc::internal::CallOpRecvMessage<R>,
-                                  grpc::internal::CallOpClientRecvStatus>;
-    SingleBufType* single_buf =
-        new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-            call, sizeof(SingleBufType))) SingleBufType;
-    *single_buf_ptr = single_buf;
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(single_buf->SendMessage(request).ok());
-    single_buf->ClientSendClose();
-
-    // The purpose of the following functions is to type-erase the actual
-    // templated type of the CallOpSet being used by hiding that type inside the
-    // function definition rather than specifying it as an argument of the
-    // function or a member of the class. The type-erased CallOpSet will get
-    // static_cast'ed back to the real type so that it can be used properly.
-    *read_initial_metadata =
-        [](ClientContext* context, internal::Call* call,
-           internal::CallOpSendInitialMetadata* single_buf_view, void* tag) {
-          auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
-          single_buf->set_output_tag(tag);
-          single_buf->RecvInitialMetadata(context);
-          call->PerformOps(single_buf);
+namespace grpc
+{
+
+    // Forward declaration for use in Helper class
+    template<class R>
+    class ClientAsyncResponseReader;
+
+    /// An interface relevant for async client side unary RPCs (which send
+    /// one request message to a server and receive one response message).
+    template<class R>
+    class ClientAsyncResponseReaderInterface
+    {
+    public:
+        virtual ~ClientAsyncResponseReaderInterface()
+        {
+        }
+
+        /// Start the call that was set up by the constructor, but only if the
+        /// constructor was invoked through the "Prepare" API which doesn't actually
+        /// start the call
+        virtual void StartCall() = 0;
+
+        /// Request notification of the reading of initial metadata. Completion
+        /// will be notified by \a tag on the associated completion queue.
+        /// This call is optional, but if it is used, it cannot be used concurrently
+        /// with or after the \a Finish method.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        virtual void ReadInitialMetadata(void* tag) = 0;
+
+        /// Request to receive the server's response \a msg and final \a status for
+        /// the call, and to notify \a tag on this call's completion queue when
+        /// finished.
+        ///
+        /// This function will return when either:
+        /// - when the server's response message and status have been received.
+        /// - when the server has returned a non-OK status (no message expected in
+        ///   this case).
+        /// - when the call failed for some reason and the library generated a
+        ///   non-OK status.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        /// \param[out] status To be updated with the operation status.
+        /// \param[out] msg To be filled in with the server's response message.
+        virtual void Finish(R* msg, grpc::Status* status, void* tag) = 0;
+    };
+
+    namespace internal
+    {
+
+        class ClientAsyncResponseReaderHelper
+        {
+        public:
+            /// Start a call and write the request out if \a start is set.
+            /// \a tag will be notified on \a cq when the call has been started (i.e.
+            /// intitial metadata sent) and \a request has been written out.
+            /// If \a start is not set, the actual call must be initiated by StartCall
+            /// Note that \a context will be used to fill in custom initial metadata
+            /// used to send to the server when starting the call.
+            ///
+            /// Optionally pass in a base class for request and response types so that the
+            /// internal functions and structs can be templated based on that, allowing
+            /// reuse across RPCs (e.g., MessageLite for protobuf). Since constructors
+            /// can't have an explicit template parameter, the last argument is an
+            /// extraneous parameter just to provide the needed type information.
+            template<class R, class W, class BaseR = R, class BaseW = W>
+            static ClientAsyncResponseReader<R>* Create(
+                grpc::ChannelInterface* channel, grpc::CompletionQueue* cq, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const W& request
+            ) /* __attribute__((noinline)) */
+            {
+                grpc::internal::Call call = channel->CreateCall(method, context, cq);
+                ClientAsyncResponseReader<R>* result =
+                    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                        call.call(), sizeof(ClientAsyncResponseReader<R>)
+                    ))
+                        ClientAsyncResponseReader<R>(call, context);
+                SetupRequest<BaseR, BaseW>(
+                    call.call(), &result->single_buf_, &result->read_initial_metadata_, &result->finish_, static_cast<const BaseW&>(request)
+                );
+
+                return result;
+            }
+
+            // Various helper functions to reduce templating use
+
+            template<class R, class W>
+            static void SetupRequest(
+                grpc_call* call,
+                grpc::internal::CallOpSendInitialMetadata** single_buf_ptr,
+                std::function<void(ClientContext*, internal::Call*, internal::CallOpSendInitialMetadata*, void*)>*
+                    read_initial_metadata,
+                std::function<
+                    void(ClientContext*, internal::Call*, bool initial_metadata_read, internal::CallOpSendInitialMetadata*, internal::CallOpSetInterface**, void*, Status*, void*)>* finish,
+                const W& request
+            )
+            {
+                using SingleBufType =
+                    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose, grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpRecvMessage<R>, grpc::internal::CallOpClientRecvStatus>;
+                SingleBufType* single_buf =
+                    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                        call, sizeof(SingleBufType)
+                    )) SingleBufType;
+                *single_buf_ptr = single_buf;
+                // TODO(ctiller): don't assert
+                GPR_CODEGEN_ASSERT(single_buf->SendMessage(request).ok());
+                single_buf->ClientSendClose();
+
+                // The purpose of the following functions is to type-erase the actual
+                // templated type of the CallOpSet being used by hiding that type inside the
+                // function definition rather than specifying it as an argument of the
+                // function or a member of the class. The type-erased CallOpSet will get
+                // static_cast'ed back to the real type so that it can be used properly.
+                *read_initial_metadata =
+                    [](ClientContext* context, internal::Call* call, internal::CallOpSendInitialMetadata* single_buf_view, void* tag)
+                {
+                    auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
+                    single_buf->set_output_tag(tag);
+                    single_buf->RecvInitialMetadata(context);
+                    call->PerformOps(single_buf);
+                };
+
+                // Note that this function goes one step further than the previous one
+                // because it type-erases the message being written down to a void*. This
+                // will be static-cast'ed back to the class specified here by hiding that
+                // class information inside the function definition. Note that this feature
+                // expects the class being specified here for R to be a base-class of the
+                // "real" R without any multiple-inheritance (as applies in protbuf wrt
+                // MessageLite)
+                *finish = [](ClientContext* context, internal::Call* call, bool initial_metadata_read, internal::CallOpSendInitialMetadata* single_buf_view, internal::CallOpSetInterface** finish_buf_ptr, void* msg, Status* status, void* tag)
+                {
+                    if (initial_metadata_read)
+                    {
+                        using FinishBufType =
+                            grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>, grpc::internal::CallOpClientRecvStatus>;
+                        FinishBufType* finish_buf =
+                            new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                                call->call(), sizeof(FinishBufType)
+                            )) FinishBufType;
+                        *finish_buf_ptr = finish_buf;
+                        finish_buf->set_output_tag(tag);
+                        finish_buf->RecvMessage(static_cast<R*>(msg));
+                        finish_buf->AllowNoMessage();
+                        finish_buf->ClientRecvStatus(context, status);
+                        call->PerformOps(finish_buf);
+                    }
+                    else
+                    {
+                        auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
+                        single_buf->set_output_tag(tag);
+                        single_buf->RecvInitialMetadata(context);
+                        single_buf->RecvMessage(static_cast<R*>(msg));
+                        single_buf->AllowNoMessage();
+                        single_buf->ClientRecvStatus(context, status);
+                        call->PerformOps(single_buf);
+                    }
+                };
+            }
+
+            static void StartCall(grpc::ClientContext* context, grpc::internal::CallOpSendInitialMetadata* single_buf)
+            {
+                single_buf->SendInitialMetadata(&context->send_initial_metadata_, context->initial_metadata_flags());
+            }
+        };
+
+        // TODO(vjpai): This templated factory is deprecated and will be replaced by
+        //.             the non-templated helper as soon as possible.
+        template<class R>
+        class ClientAsyncResponseReaderFactory
+        {
+        public:
+            template<class W>
+            static ClientAsyncResponseReader<R>* Create(
+                grpc::ChannelInterface* channel, grpc::CompletionQueue* cq, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const W& request, bool start
+            )
+            {
+                auto* result = ClientAsyncResponseReaderHelper::Create<R>(
+                    channel, cq, method, context, request
+                );
+                if (start)
+                {
+                    result->StartCall();
+                }
+                return result;
+            }
         };
 
-    // Note that this function goes one step further than the previous one
-    // because it type-erases the message being written down to a void*. This
-    // will be static-cast'ed back to the class specified here by hiding that
-    // class information inside the function definition. Note that this feature
-    // expects the class being specified here for R to be a base-class of the
-    // "real" R without any multiple-inheritance (as applies in protbuf wrt
-    // MessageLite)
-    *finish = [](ClientContext* context, internal::Call* call,
-                 bool initial_metadata_read,
-                 internal::CallOpSendInitialMetadata* single_buf_view,
-                 internal::CallOpSetInterface** finish_buf_ptr, void* msg,
-                 Status* status, void* tag) {
-      if (initial_metadata_read) {
-        using FinishBufType =
-            grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>,
-                                      grpc::internal::CallOpClientRecvStatus>;
-        FinishBufType* finish_buf =
-            new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-                call->call(), sizeof(FinishBufType))) FinishBufType;
-        *finish_buf_ptr = finish_buf;
-        finish_buf->set_output_tag(tag);
-        finish_buf->RecvMessage(static_cast<R*>(msg));
-        finish_buf->AllowNoMessage();
-        finish_buf->ClientRecvStatus(context, status);
-        call->PerformOps(finish_buf);
-      } else {
-        auto* single_buf = static_cast<SingleBufType*>(single_buf_view);
-        single_buf->set_output_tag(tag);
-        single_buf->RecvInitialMetadata(context);
-        single_buf->RecvMessage(static_cast<R*>(msg));
-        single_buf->AllowNoMessage();
-        single_buf->ClientRecvStatus(context, status);
-        call->PerformOps(single_buf);
-      }
+    }  // namespace internal
+
+    /// Async API for client-side unary RPCs, where the message response
+    /// received from the server is of type \a R.
+    template<class R>
+    class ClientAsyncResponseReader final : public ClientAsyncResponseReaderInterface<R>
+    {
+    public:
+        // always allocated against a call arena, no memory free required
+        static void operator delete(void* /*ptr*/, std::size_t size)
+        {
+            GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncResponseReader));
+        }
+
+        // This operator should never be called as the memory should be freed as part
+        // of the arena destruction. It only exists to provide a matching operator
+        // delete to the operator new so that some compilers will not complain (see
+        // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+        // there are no tests catching the compiler warning.
+        static void operator delete(void*, void*)
+        {
+            GPR_CODEGEN_ASSERT(false);
+        }
+
+        void StartCall() override
+        {
+            GPR_CODEGEN_DEBUG_ASSERT(!started_);
+            started_ = true;
+            internal::ClientAsyncResponseReaderHelper::StartCall(context_, single_buf_);
+        }
+
+        /// See \a ClientAsyncResponseReaderInterface::ReadInitialMetadata for
+        /// semantics.
+        ///
+        /// Side effect:
+        ///   - the \a ClientContext associated with this call is updated with
+        ///     possible initial and trailing metadata sent from the server.
+        void ReadInitialMetadata(void* tag) override
+        {
+            GPR_CODEGEN_DEBUG_ASSERT(started_);
+            GPR_CODEGEN_DEBUG_ASSERT(!context_->initial_metadata_received_);
+            read_initial_metadata_(context_, &call_, single_buf_, tag);
+            initial_metadata_read_ = true;
+        }
+
+        /// See \a ClientAsyncResponseReaderInterface::Finish for semantics.
+        ///
+        /// Side effect:
+        ///   - the \a ClientContext associated with this call is updated with
+        ///     possible initial and trailing metadata sent from the server.
+        void Finish(R* msg, grpc::Status* status, void* tag) override
+        {
+            GPR_CODEGEN_DEBUG_ASSERT(started_);
+            finish_(context_, &call_, initial_metadata_read_, single_buf_, &finish_buf_, static_cast<void*>(msg), status, tag);
+        }
+
+    private:
+        friend class internal::ClientAsyncResponseReaderHelper;
+        grpc::ClientContext* const context_;
+        grpc::internal::Call call_;
+        bool started_ = false;
+        bool initial_metadata_read_ = false;
+
+        ClientAsyncResponseReader(grpc::internal::Call call, grpc::ClientContext* context) :
+            context_(context),
+            call_(call)
+        {
+        }
+
+        // disable operator new
+        static void* operator new(std::size_t size);
+        static void* operator new(std::size_t /*size*/, void* p)
+        {
+            return p;
+        }
+
+        internal::CallOpSendInitialMetadata* single_buf_;
+        internal::CallOpSetInterface* finish_buf_ = nullptr;
+        std::function<void(ClientContext*, internal::Call*, internal::CallOpSendInitialMetadata*, void*)>
+            read_initial_metadata_;
+        std::function<void(ClientContext*, internal::Call*, bool initial_metadata_read, internal::CallOpSendInitialMetadata*, internal::CallOpSetInterface**, void*, Status*, void*)>
+            finish_;
+    };
+
+    /// Async server-side API for handling unary calls, where the single
+    /// response message sent to the client is of type \a W.
+    template<class W>
+    class ServerAsyncResponseWriter final : public grpc::internal::ServerAsyncStreamingInterface
+    {
+    public:
+        explicit ServerAsyncResponseWriter(grpc::ServerContext* ctx) :
+            call_(nullptr, nullptr, nullptr),
+            ctx_(ctx)
+        {
+        }
+
+        /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
+        ///
+        /// Side effect:
+        ///   The initial metadata that will be sent to the client from this op will
+        ///   be taken from the \a ServerContext associated with the call.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        void SendInitialMetadata(void* tag) override
+        {
+            GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+            meta_buf_.set_output_tag(tag);
+            meta_buf_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+            if (ctx_->compression_level_set())
+            {
+                meta_buf_.set_compression_level(ctx_->compression_level());
+            }
+            ctx_->sent_initial_metadata_ = true;
+            call_.PerformOps(&meta_buf_);
+        }
+
+        /// Indicate that the stream is to be finished and request notification
+        /// when the server has sent the appropriate signals to the client to
+        /// end the call. Should not be used concurrently with other operations.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        /// \param[in] status To be sent to the client as the result of the call.
+        /// \param[in] msg Message to be sent to the client.
+        ///
+        /// Side effect:
+        ///   - also sends initial metadata if not already sent (using the
+        ///     \a ServerContext associated with this call).
+        ///
+        /// Note: if \a status has a non-OK code, then \a msg will not be sent,
+        /// and the client will receive only the status with possible trailing
+        /// metadata.
+        ///
+        /// gRPC doesn't take ownership or a reference to msg and status, so it is
+        /// safe to deallocate them once the Finish operation is complete (i.e. a
+        /// result arrives in the completion queue).
+        void Finish(const W& msg, const grpc::Status& status, void* tag)
+        {
+            finish_buf_.set_output_tag(tag);
+            finish_buf_.set_core_cq_tag(&finish_buf_);
+            if (!ctx_->sent_initial_metadata_)
+            {
+                finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                if (ctx_->compression_level_set())
+                {
+                    finish_buf_.set_compression_level(ctx_->compression_level());
+                }
+                ctx_->sent_initial_metadata_ = true;
+            }
+            // The response is dropped if the status is not OK.
+            if (status.ok())
+            {
+                finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, finish_buf_.SendMessage(msg));
+            }
+            else
+            {
+                finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+            }
+            call_.PerformOps(&finish_buf_);
+        }
+
+        /// Indicate that the stream is to be finished with a non-OK status,
+        /// and request notification for when the server has finished sending the
+        /// appropriate signals to the client to end the call.
+        /// Should not be used concurrently with other operations.
+        ///
+        /// \param[in] tag Tag identifying this request.
+        /// \param[in] status To be sent to the client as the result of the call.
+        ///   - Note: \a status must have a non-OK code.
+        ///
+        /// Side effect:
+        ///   - also sends initial metadata if not already sent (using the
+        ///     \a ServerContext associated with this call).
+        ///
+        /// gRPC doesn't take ownership or a reference to status, so it is safe to
+        /// deallocate them once the Finish operation is complete (i.e. a result
+        /// arrives in the completion queue).
+        void FinishWithError(const grpc::Status& status, void* tag)
+        {
+            GPR_CODEGEN_ASSERT(!status.ok());
+            finish_buf_.set_output_tag(tag);
+            if (!ctx_->sent_initial_metadata_)
+            {
+                finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                if (ctx_->compression_level_set())
+                {
+                    finish_buf_.set_compression_level(ctx_->compression_level());
+                }
+                ctx_->sent_initial_metadata_ = true;
+            }
+            finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
+            call_.PerformOps(&finish_buf_);
+        }
+
+    private:
+        void BindCall(grpc::internal::Call* call) override
+        {
+            call_ = *call;
+        }
+
+        grpc::internal::Call call_;
+        grpc::ServerContext* ctx_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+            meta_buf_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+            finish_buf_;
     };
-  }
-
-  static void StartCall(grpc::ClientContext* context,
-                        grpc::internal::CallOpSendInitialMetadata* single_buf) {
-    single_buf->SendInitialMetadata(&context->send_initial_metadata_,
-                                    context->initial_metadata_flags());
-  }
-};
-
-// TODO(vjpai): This templated factory is deprecated and will be replaced by
-//.             the non-templated helper as soon as possible.
-template <class R>
-class ClientAsyncResponseReaderFactory {
- public:
-  template <class W>
-  static ClientAsyncResponseReader<R>* Create(
-      grpc::ChannelInterface* channel, grpc::CompletionQueue* cq,
-      const grpc::internal::RpcMethod& method, grpc::ClientContext* context,
-      const W& request, bool start) {
-    auto* result = ClientAsyncResponseReaderHelper::Create<R>(
-        channel, cq, method, context, request);
-    if (start) {
-      result->StartCall();
-    }
-    return result;
-  }
-};
-
-}  // namespace internal
-
-/// Async API for client-side unary RPCs, where the message response
-/// received from the server is of type \a R.
-template <class R>
-class ClientAsyncResponseReader final
-    : public ClientAsyncResponseReaderInterface<R> {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(ClientAsyncResponseReader));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  void StartCall() override {
-    GPR_CODEGEN_DEBUG_ASSERT(!started_);
-    started_ = true;
-    internal::ClientAsyncResponseReaderHelper::StartCall(context_, single_buf_);
-  }
-
-  /// See \a ClientAsyncResponseReaderInterface::ReadInitialMetadata for
-  /// semantics.
-  ///
-  /// Side effect:
-  ///   - the \a ClientContext associated with this call is updated with
-  ///     possible initial and trailing metadata sent from the server.
-  void ReadInitialMetadata(void* tag) override {
-    GPR_CODEGEN_DEBUG_ASSERT(started_);
-    GPR_CODEGEN_DEBUG_ASSERT(!context_->initial_metadata_received_);
-    read_initial_metadata_(context_, &call_, single_buf_, tag);
-    initial_metadata_read_ = true;
-  }
-
-  /// See \a ClientAsyncResponseReaderInterface::Finish for semantics.
-  ///
-  /// Side effect:
-  ///   - the \a ClientContext associated with this call is updated with
-  ///     possible initial and trailing metadata sent from the server.
-  void Finish(R* msg, grpc::Status* status, void* tag) override {
-    GPR_CODEGEN_DEBUG_ASSERT(started_);
-    finish_(context_, &call_, initial_metadata_read_, single_buf_, &finish_buf_,
-            static_cast<void*>(msg), status, tag);
-  }
-
- private:
-  friend class internal::ClientAsyncResponseReaderHelper;
-  grpc::ClientContext* const context_;
-  grpc::internal::Call call_;
-  bool started_ = false;
-  bool initial_metadata_read_ = false;
-
-  ClientAsyncResponseReader(grpc::internal::Call call,
-                            grpc::ClientContext* context)
-      : context_(context), call_(call) {}
-
-  // disable operator new
-  static void* operator new(std::size_t size);
-  static void* operator new(std::size_t /*size*/, void* p) { return p; }
-
-  internal::CallOpSendInitialMetadata* single_buf_;
-  internal::CallOpSetInterface* finish_buf_ = nullptr;
-  std::function<void(ClientContext*, internal::Call*,
-                     internal::CallOpSendInitialMetadata*, void*)>
-      read_initial_metadata_;
-  std::function<void(ClientContext*, internal::Call*,
-                     bool initial_metadata_read,
-                     internal::CallOpSendInitialMetadata*,
-                     internal::CallOpSetInterface**, void*, Status*, void*)>
-      finish_;
-};
-
-/// Async server-side API for handling unary calls, where the single
-/// response message sent to the client is of type \a W.
-template <class W>
-class ServerAsyncResponseWriter final
-    : public grpc::internal::ServerAsyncStreamingInterface {
- public:
-  explicit ServerAsyncResponseWriter(grpc::ServerContext* ctx)
-      : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
-
-  /// See \a ServerAsyncStreamingInterface::SendInitialMetadata for semantics.
-  ///
-  /// Side effect:
-  ///   The initial metadata that will be sent to the client from this op will
-  ///   be taken from the \a ServerContext associated with the call.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  void SendInitialMetadata(void* tag) override {
-    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-
-    meta_buf_.set_output_tag(tag);
-    meta_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                  ctx_->initial_metadata_flags());
-    if (ctx_->compression_level_set()) {
-      meta_buf_.set_compression_level(ctx_->compression_level());
-    }
-    ctx_->sent_initial_metadata_ = true;
-    call_.PerformOps(&meta_buf_);
-  }
-
-  /// Indicate that the stream is to be finished and request notification
-  /// when the server has sent the appropriate signals to the client to
-  /// end the call. Should not be used concurrently with other operations.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  /// \param[in] status To be sent to the client as the result of the call.
-  /// \param[in] msg Message to be sent to the client.
-  ///
-  /// Side effect:
-  ///   - also sends initial metadata if not already sent (using the
-  ///     \a ServerContext associated with this call).
-  ///
-  /// Note: if \a status has a non-OK code, then \a msg will not be sent,
-  /// and the client will receive only the status with possible trailing
-  /// metadata.
-  ///
-  /// gRPC doesn't take ownership or a reference to msg and status, so it is
-  /// safe to deallocate them once the Finish operation is complete (i.e. a
-  /// result arrives in the completion queue).
-  void Finish(const W& msg, const grpc::Status& status, void* tag) {
-    finish_buf_.set_output_tag(tag);
-    finish_buf_.set_core_cq_tag(&finish_buf_);
-    if (!ctx_->sent_initial_metadata_) {
-      finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                      ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        finish_buf_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-    }
-    // The response is dropped if the status is not OK.
-    if (status.ok()) {
-      finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_,
-                                   finish_buf_.SendMessage(msg));
-    } else {
-      finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
-    }
-    call_.PerformOps(&finish_buf_);
-  }
-
-  /// Indicate that the stream is to be finished with a non-OK status,
-  /// and request notification for when the server has finished sending the
-  /// appropriate signals to the client to end the call.
-  /// Should not be used concurrently with other operations.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  /// \param[in] status To be sent to the client as the result of the call.
-  ///   - Note: \a status must have a non-OK code.
-  ///
-  /// Side effect:
-  ///   - also sends initial metadata if not already sent (using the
-  ///     \a ServerContext associated with this call).
-  ///
-  /// gRPC doesn't take ownership or a reference to status, so it is safe to
-  /// deallocate them once the Finish operation is complete (i.e. a result
-  /// arrives in the completion queue).
-  void FinishWithError(const grpc::Status& status, void* tag) {
-    GPR_CODEGEN_ASSERT(!status.ok());
-    finish_buf_.set_output_tag(tag);
-    if (!ctx_->sent_initial_metadata_) {
-      finish_buf_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                      ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        finish_buf_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-    }
-    finish_buf_.ServerSendStatus(&ctx_->trailing_metadata_, status);
-    call_.PerformOps(&finish_buf_);
-  }
-
- private:
-  void BindCall(grpc::internal::Call* call) override { call_ = *call; }
-
-  grpc::internal::Call call_;
-  grpc::ServerContext* ctx_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
-      meta_buf_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpServerSendStatus>
-      finish_buf_;
-};
 
 }  // namespace grpc
 
-namespace std {
-template <class R>
-class default_delete<grpc::ClientAsyncResponseReader<R>> {
- public:
-  void operator()(void* /*p*/) {}
-};
-template <class R>
-class default_delete<grpc::ClientAsyncResponseReaderInterface<R>> {
- public:
-  void operator()(void* /*p*/) {}
-};
+namespace std
+{
+    template<class R>
+    class default_delete<grpc::ClientAsyncResponseReader<R>>
+    {
+    public:
+        void operator()(void* /*p*/)
+        {
+        }
+    };
+    template<class R>
+    class default_delete<grpc::ClientAsyncResponseReaderInterface<R>>
+    {
+    public:
+        void operator()(void* /*p*/)
+        {
+        }
+    };
 }  // namespace std
 
 #endif  // GRPCPP_IMPL_CODEGEN_ASYNC_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/byte_buffer.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/byte_buffer.h
index a9ba7d1..1076670 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/byte_buffer.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/byte_buffer.h
@@ -30,209 +30,255 @@
 #include <grpcpp/impl/codegen/slice.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-
-class ServerInterface;
-class ByteBuffer;
-class ServerInterface;
-
-namespace internal {
-template <class RequestType, class ResponseType>
-class CallbackUnaryHandler;
-template <class RequestType, class ResponseType>
-class CallbackServerStreamingHandler;
-template <class RequestType>
-void* UnaryDeserializeHelper(grpc_byte_buffer*, grpc::Status*, RequestType*);
-template <class ServiceType, class RequestType, class ResponseType>
-class ServerStreamingHandler;
-template <grpc::StatusCode code>
-class ErrorMethodHandler;
-class CallOpSendMessage;
-template <class R>
-class CallOpRecvMessage;
-class CallOpGenericRecvMessage;
-class ExternalConnectionAcceptorImpl;
-template <class R>
-class DeserializeFuncType;
-class GrpcByteBufferPeer;
-
-}  // namespace internal
-/// A sequence of bytes.
-class ByteBuffer final {
- public:
-  /// Constuct an empty buffer.
-  ByteBuffer() : buffer_(nullptr) {}
-
-  /// Construct buffer from \a slices, of which there are \a nslices.
-  ByteBuffer(const Slice* slices, size_t nslices) {
-    // The following assertions check that the representation of a grpc::Slice
-    // is identical to that of a grpc_slice:  it has a grpc_slice field, and
-    // nothing else.
-    static_assert(std::is_same<decltype(slices[0].slice_), grpc_slice>::value,
-                  "Slice must have same representation as grpc_slice");
-    static_assert(sizeof(Slice) == sizeof(grpc_slice),
-                  "Slice must have same representation as grpc_slice");
-    // The following assertions check that the representation of a ByteBuffer is
-    // identical to grpc_byte_buffer*:  it has a grpc_byte_buffer* field,
-    // and nothing else.
-    static_assert(std::is_same<decltype(buffer_), grpc_byte_buffer*>::value,
-                  "ByteBuffer must have same representation as "
-                  "grpc_byte_buffer*");
-    static_assert(sizeof(ByteBuffer) == sizeof(grpc_byte_buffer*),
-                  "ByteBuffer must have same representation as "
-                  "grpc_byte_buffer*");
-    // The const_cast is legal if grpc_raw_byte_buffer_create() does no more
-    // than its advertised side effect of increasing the reference count of the
-    // slices it processes, and such an increase does not affect the semantics
-    // seen by the caller of this constructor.
-    buffer_ = g_core_codegen_interface->grpc_raw_byte_buffer_create(
-        reinterpret_cast<grpc_slice*>(const_cast<Slice*>(slices)), nslices);
-  }
-
-  /// Constuct a byte buffer by referencing elements of existing buffer
-  /// \a buf. Wrapper of core function grpc_byte_buffer_copy . This is not
-  /// a deep copy; it is just a referencing. As a result, its performance is
-  /// size-independent.
-  ByteBuffer(const ByteBuffer& buf) : buffer_(nullptr) { operator=(buf); }
-
-  ~ByteBuffer() {
-    if (buffer_) {
-      g_core_codegen_interface->grpc_byte_buffer_destroy(buffer_);
-    }
-  }
-
-  /// Wrapper of core function grpc_byte_buffer_copy . This is not
-  /// a deep copy; it is just a referencing. As a result, its performance is
-  /// size-independent.
-  ByteBuffer& operator=(const ByteBuffer& buf) {
-    if (this != &buf) {
-      Clear();  // first remove existing data
-    }
-    if (buf.buffer_) {
-      // then copy
-      buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buf.buffer_);
-    }
-    return *this;
-  }
-
-  // If this ByteBuffer's representation is a single flat slice, returns a
-  // slice referencing that array.
-  Status TrySingleSlice(Slice* slice) const;
-
-  /// Dump (read) the buffer contents into \a slics.
-  Status DumpToSingleSlice(Slice* slice) const;
-
-  /// Dump (read) the buffer contents into \a slices.
-  Status Dump(std::vector<Slice>* slices) const;
-
-  /// Remove all data.
-  void Clear() {
-    if (buffer_) {
-      g_core_codegen_interface->grpc_byte_buffer_destroy(buffer_);
-      buffer_ = nullptr;
-    }
-  }
-
-  /// Make a duplicate copy of the internals of this byte
-  /// buffer so that we have our own owned version of it.
-  /// bbuf.Duplicate(); is equivalent to bbuf=bbuf; but is actually readable.
-  /// This is not a deep copy; it is a referencing and its performance
-  /// is size-independent.
-  void Duplicate() {
-    buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buffer_);
-  }
-
-  /// Forget underlying byte buffer without destroying
-  /// Use this only for un-owned byte buffers
-  void Release() { buffer_ = nullptr; }
-
-  /// Buffer size in bytes.
-  size_t Length() const {
-    return buffer_ == nullptr
-               ? 0
-               : g_core_codegen_interface->grpc_byte_buffer_length(buffer_);
-  }
-
-  /// Swap the state of *this and *other.
-  void Swap(ByteBuffer* other) {
-    grpc_byte_buffer* tmp = other->buffer_;
-    other->buffer_ = buffer_;
-    buffer_ = tmp;
-  }
-
-  /// Is this ByteBuffer valid?
-  bool Valid() const { return (buffer_ != nullptr); }
-
- private:
-  friend class SerializationTraits<ByteBuffer, void>;
-  friend class ServerInterface;
-  friend class internal::CallOpSendMessage;
-  template <class R>
-  friend class internal::CallOpRecvMessage;
-  friend class internal::CallOpGenericRecvMessage;
-  template <class RequestType>
-  friend void* internal::UnaryDeserializeHelper(grpc_byte_buffer*,
-                                                grpc::Status*, RequestType*);
-  template <class ServiceType, class RequestType, class ResponseType>
-  friend class internal::ServerStreamingHandler;
-  template <class RequestType, class ResponseType>
-  friend class internal::CallbackUnaryHandler;
-  template <class RequestType, class ResponseType>
-  friend class internal::CallbackServerStreamingHandler;
-  template <StatusCode code>
-  friend class internal::ErrorMethodHandler;
-  template <class R>
-  friend class internal::DeserializeFuncType;
-  friend class ProtoBufferReader;
-  friend class ProtoBufferWriter;
-  friend class internal::GrpcByteBufferPeer;
-  friend class internal::ExternalConnectionAcceptorImpl;
-
-  grpc_byte_buffer* buffer_;
-
-  // takes ownership
-  void set_buffer(grpc_byte_buffer* buf) {
-    if (buffer_) {
-      Clear();
-    }
-    buffer_ = buf;
-  }
-
-  grpc_byte_buffer* c_buffer() { return buffer_; }
-  grpc_byte_buffer** c_buffer_ptr() { return &buffer_; }
-
-  class ByteBufferPointer {
-   public:
-    /* NOLINTNEXTLINE(google-explicit-constructor) */
-    ByteBufferPointer(const ByteBuffer* b)
-        : bbuf_(const_cast<ByteBuffer*>(b)) {}
-    /* NOLINTNEXTLINE(google-explicit-constructor) */
-    operator ByteBuffer*() { return bbuf_; }
-    /* NOLINTNEXTLINE(google-explicit-constructor) */
-    operator grpc_byte_buffer*() { return bbuf_->buffer_; }
-    /* NOLINTNEXTLINE(google-explicit-constructor) */
-    operator grpc_byte_buffer**() { return &bbuf_->buffer_; }
-
-   private:
-    ByteBuffer* bbuf_;
-  };
-  ByteBufferPointer bbuf_ptr() const { return ByteBufferPointer(this); }
-};
-
-template <>
-class SerializationTraits<ByteBuffer, void> {
- public:
-  static Status Deserialize(ByteBuffer* byte_buffer, ByteBuffer* dest) {
-    dest->set_buffer(byte_buffer->buffer_);
-    return Status::OK;
-  }
-  static Status Serialize(const ByteBuffer& source, ByteBuffer* buffer,
-                          bool* own_buffer) {
-    *buffer = source;
-    *own_buffer = true;
-    return g_core_codegen_interface->ok();
-  }
-};
+namespace grpc
+{
+
+    class ServerInterface;
+    class ByteBuffer;
+    class ServerInterface;
+
+    namespace internal
+    {
+        template<class RequestType, class ResponseType>
+        class CallbackUnaryHandler;
+        template<class RequestType, class ResponseType>
+        class CallbackServerStreamingHandler;
+        template<class RequestType>
+        void* UnaryDeserializeHelper(grpc_byte_buffer*, grpc::Status*, RequestType*);
+        template<class ServiceType, class RequestType, class ResponseType>
+        class ServerStreamingHandler;
+        template<grpc::StatusCode code>
+        class ErrorMethodHandler;
+        class CallOpSendMessage;
+        template<class R>
+        class CallOpRecvMessage;
+        class CallOpGenericRecvMessage;
+        class ExternalConnectionAcceptorImpl;
+        template<class R>
+        class DeserializeFuncType;
+        class GrpcByteBufferPeer;
+
+    }  // namespace internal
+    /// A sequence of bytes.
+    class ByteBuffer final
+    {
+    public:
+        /// Constuct an empty buffer.
+        ByteBuffer() :
+            buffer_(nullptr)
+        {
+        }
+
+        /// Construct buffer from \a slices, of which there are \a nslices.
+        ByteBuffer(const Slice* slices, size_t nslices)
+        {
+            // The following assertions check that the representation of a grpc::Slice
+            // is identical to that of a grpc_slice:  it has a grpc_slice field, and
+            // nothing else.
+            static_assert(std::is_same<decltype(slices[0].slice_), grpc_slice>::value, "Slice must have same representation as grpc_slice");
+            static_assert(sizeof(Slice) == sizeof(grpc_slice), "Slice must have same representation as grpc_slice");
+            // The following assertions check that the representation of a ByteBuffer is
+            // identical to grpc_byte_buffer*:  it has a grpc_byte_buffer* field,
+            // and nothing else.
+            static_assert(std::is_same<decltype(buffer_), grpc_byte_buffer*>::value, "ByteBuffer must have same representation as "
+                                                                                     "grpc_byte_buffer*");
+            static_assert(sizeof(ByteBuffer) == sizeof(grpc_byte_buffer*), "ByteBuffer must have same representation as "
+                                                                           "grpc_byte_buffer*");
+            // The const_cast is legal if grpc_raw_byte_buffer_create() does no more
+            // than its advertised side effect of increasing the reference count of the
+            // slices it processes, and such an increase does not affect the semantics
+            // seen by the caller of this constructor.
+            buffer_ = g_core_codegen_interface->grpc_raw_byte_buffer_create(
+                reinterpret_cast<grpc_slice*>(const_cast<Slice*>(slices)), nslices
+            );
+        }
+
+        /// Constuct a byte buffer by referencing elements of existing buffer
+        /// \a buf. Wrapper of core function grpc_byte_buffer_copy . This is not
+        /// a deep copy; it is just a referencing. As a result, its performance is
+        /// size-independent.
+        ByteBuffer(const ByteBuffer& buf) :
+            buffer_(nullptr)
+        {
+            operator=(buf);
+        }
+
+        ~ByteBuffer()
+        {
+            if (buffer_)
+            {
+                g_core_codegen_interface->grpc_byte_buffer_destroy(buffer_);
+            }
+        }
+
+        /// Wrapper of core function grpc_byte_buffer_copy . This is not
+        /// a deep copy; it is just a referencing. As a result, its performance is
+        /// size-independent.
+        ByteBuffer& operator=(const ByteBuffer& buf)
+        {
+            if (this != &buf)
+            {
+                Clear();  // first remove existing data
+            }
+            if (buf.buffer_)
+            {
+                // then copy
+                buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buf.buffer_);
+            }
+            return *this;
+        }
+
+        // If this ByteBuffer's representation is a single flat slice, returns a
+        // slice referencing that array.
+        Status TrySingleSlice(Slice* slice) const;
+
+        /// Dump (read) the buffer contents into \a slics.
+        Status DumpToSingleSlice(Slice* slice) const;
+
+        /// Dump (read) the buffer contents into \a slices.
+        Status Dump(std::vector<Slice>* slices) const;
+
+        /// Remove all data.
+        void Clear()
+        {
+            if (buffer_)
+            {
+                g_core_codegen_interface->grpc_byte_buffer_destroy(buffer_);
+                buffer_ = nullptr;
+            }
+        }
+
+        /// Make a duplicate copy of the internals of this byte
+        /// buffer so that we have our own owned version of it.
+        /// bbuf.Duplicate(); is equivalent to bbuf=bbuf; but is actually readable.
+        /// This is not a deep copy; it is a referencing and its performance
+        /// is size-independent.
+        void Duplicate()
+        {
+            buffer_ = g_core_codegen_interface->grpc_byte_buffer_copy(buffer_);
+        }
+
+        /// Forget underlying byte buffer without destroying
+        /// Use this only for un-owned byte buffers
+        void Release()
+        {
+            buffer_ = nullptr;
+        }
+
+        /// Buffer size in bytes.
+        size_t Length() const
+        {
+            return buffer_ == nullptr ? 0 : g_core_codegen_interface->grpc_byte_buffer_length(buffer_);
+        }
+
+        /// Swap the state of *this and *other.
+        void Swap(ByteBuffer* other)
+        {
+            grpc_byte_buffer* tmp = other->buffer_;
+            other->buffer_ = buffer_;
+            buffer_ = tmp;
+        }
+
+        /// Is this ByteBuffer valid?
+        bool Valid() const
+        {
+            return (buffer_ != nullptr);
+        }
+
+    private:
+        friend class SerializationTraits<ByteBuffer, void>;
+        friend class ServerInterface;
+        friend class internal::CallOpSendMessage;
+        template<class R>
+        friend class internal::CallOpRecvMessage;
+        friend class internal::CallOpGenericRecvMessage;
+        template<class RequestType>
+        friend void* internal::UnaryDeserializeHelper(grpc_byte_buffer*, grpc::Status*, RequestType*);
+        template<class ServiceType, class RequestType, class ResponseType>
+        friend class internal::ServerStreamingHandler;
+        template<class RequestType, class ResponseType>
+        friend class internal::CallbackUnaryHandler;
+        template<class RequestType, class ResponseType>
+        friend class internal::CallbackServerStreamingHandler;
+        template<StatusCode code>
+        friend class internal::ErrorMethodHandler;
+        template<class R>
+        friend class internal::DeserializeFuncType;
+        friend class ProtoBufferReader;
+        friend class ProtoBufferWriter;
+        friend class internal::GrpcByteBufferPeer;
+        friend class internal::ExternalConnectionAcceptorImpl;
+
+        grpc_byte_buffer* buffer_;
+
+        // takes ownership
+        void set_buffer(grpc_byte_buffer* buf)
+        {
+            if (buffer_)
+            {
+                Clear();
+            }
+            buffer_ = buf;
+        }
+
+        grpc_byte_buffer* c_buffer()
+        {
+            return buffer_;
+        }
+        grpc_byte_buffer** c_buffer_ptr()
+        {
+            return &buffer_;
+        }
+
+        class ByteBufferPointer
+        {
+        public:
+            /* NOLINTNEXTLINE(google-explicit-constructor) */
+            ByteBufferPointer(const ByteBuffer* b) :
+                bbuf_(const_cast<ByteBuffer*>(b))
+            {
+            }
+            /* NOLINTNEXTLINE(google-explicit-constructor) */
+            operator ByteBuffer*()
+            {
+                return bbuf_;
+            }
+            /* NOLINTNEXTLINE(google-explicit-constructor) */
+            operator grpc_byte_buffer*()
+            {
+                return bbuf_->buffer_;
+            }
+            /* NOLINTNEXTLINE(google-explicit-constructor) */
+            operator grpc_byte_buffer**()
+            {
+                return &bbuf_->buffer_;
+            }
+
+        private:
+            ByteBuffer* bbuf_;
+        };
+        ByteBufferPointer bbuf_ptr() const
+        {
+            return ByteBufferPointer(this);
+        }
+    };
+
+    template<>
+    class SerializationTraits<ByteBuffer, void>
+    {
+    public:
+        static Status Deserialize(ByteBuffer* byte_buffer, ByteBuffer* dest)
+        {
+            dest->set_buffer(byte_buffer->buffer_);
+            return Status::OK;
+        }
+        static Status Serialize(const ByteBuffer& source, ByteBuffer* buffer, bool* own_buffer)
+        {
+            *buffer = source;
+            *own_buffer = true;
+            return g_core_codegen_interface->ok();
+        }
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call.h
index 90d54bc..176c8628 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call.h
@@ -23,73 +23,95 @@
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpcpp/impl/codegen/call_hook.h>
 
-namespace grpc {
-class CompletionQueue;
-namespace experimental {
-class ClientRpcInfo;
-class ServerRpcInfo;
-}  // namespace experimental
-namespace internal {
-class CallHook;
-class CallOpSetInterface;
+namespace grpc
+{
+    class CompletionQueue;
+    namespace experimental
+    {
+        class ClientRpcInfo;
+        class ServerRpcInfo;
+    }  // namespace experimental
+    namespace internal
+    {
+        class CallHook;
+        class CallOpSetInterface;
 
-/// Straightforward wrapping of the C call object
-class Call final {
- public:
-  Call()
-      : call_hook_(nullptr),
-        cq_(nullptr),
-        call_(nullptr),
-        max_receive_message_size_(-1) {}
-  /** call is owned by the caller */
-  Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq)
-      : call_hook_(call_hook),
-        cq_(cq),
-        call_(call),
-        max_receive_message_size_(-1) {}
+        /// Straightforward wrapping of the C call object
+        class Call final
+        {
+        public:
+            Call() :
+                call_hook_(nullptr),
+                cq_(nullptr),
+                call_(nullptr),
+                max_receive_message_size_(-1)
+            {
+            }
+            /** call is owned by the caller */
+            Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq) :
+                call_hook_(call_hook),
+                cq_(cq),
+                call_(call),
+                max_receive_message_size_(-1)
+            {
+            }
 
-  Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq,
-       experimental::ClientRpcInfo* rpc_info)
-      : call_hook_(call_hook),
-        cq_(cq),
-        call_(call),
-        max_receive_message_size_(-1),
-        client_rpc_info_(rpc_info) {}
+            Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq, experimental::ClientRpcInfo* rpc_info) :
+                call_hook_(call_hook),
+                cq_(cq),
+                call_(call),
+                max_receive_message_size_(-1),
+                client_rpc_info_(rpc_info)
+            {
+            }
 
-  Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq,
-       int max_receive_message_size, experimental::ServerRpcInfo* rpc_info)
-      : call_hook_(call_hook),
-        cq_(cq),
-        call_(call),
-        max_receive_message_size_(max_receive_message_size),
-        server_rpc_info_(rpc_info) {}
+            Call(grpc_call* call, CallHook* call_hook, grpc::CompletionQueue* cq, int max_receive_message_size, experimental::ServerRpcInfo* rpc_info) :
+                call_hook_(call_hook),
+                cq_(cq),
+                call_(call),
+                max_receive_message_size_(max_receive_message_size),
+                server_rpc_info_(rpc_info)
+            {
+            }
 
-  void PerformOps(CallOpSetInterface* ops) {
-    call_hook_->PerformOpsOnCall(ops, this);
-  }
+            void PerformOps(CallOpSetInterface* ops)
+            {
+                call_hook_->PerformOpsOnCall(ops, this);
+            }
 
-  grpc_call* call() const { return call_; }
-  grpc::CompletionQueue* cq() const { return cq_; }
+            grpc_call* call() const
+            {
+                return call_;
+            }
+            grpc::CompletionQueue* cq() const
+            {
+                return cq_;
+            }
 
-  int max_receive_message_size() const { return max_receive_message_size_; }
+            int max_receive_message_size() const
+            {
+                return max_receive_message_size_;
+            }
 
-  experimental::ClientRpcInfo* client_rpc_info() const {
-    return client_rpc_info_;
-  }
+            experimental::ClientRpcInfo* client_rpc_info() const
+            {
+                return client_rpc_info_;
+            }
 
-  experimental::ServerRpcInfo* server_rpc_info() const {
-    return server_rpc_info_;
-  }
+            experimental::ServerRpcInfo* server_rpc_info() const
+            {
+                return server_rpc_info_;
+            }
 
- private:
-  CallHook* call_hook_;
-  grpc::CompletionQueue* cq_;
-  grpc_call* call_;
-  int max_receive_message_size_;
-  experimental::ClientRpcInfo* client_rpc_info_ = nullptr;
-  experimental::ServerRpcInfo* server_rpc_info_ = nullptr;
-};
-}  // namespace internal
+        private:
+            CallHook* call_hook_;
+            grpc::CompletionQueue* cq_;
+            grpc_call* call_;
+            int max_receive_message_size_;
+            experimental::ClientRpcInfo* client_rpc_info_ = nullptr;
+            experimental::ServerRpcInfo* server_rpc_info_ = nullptr;
+        };
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_hook.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_hook.h
index 8c4278e..f0f73f4 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_hook.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_hook.h
@@ -21,20 +21,25 @@
 
 // IWYU pragma: private
 
-namespace grpc {
+namespace grpc
+{
 
-namespace internal {
-class CallOpSetInterface;
-class Call;
+    namespace internal
+    {
+        class CallOpSetInterface;
+        class Call;
 
-/// This is an interface that Channel and Server implement to allow them to hook
-/// performing ops.
-class CallHook {
- public:
-  virtual ~CallHook() {}
-  virtual void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) = 0;
-};
-}  // namespace internal
+        /// This is an interface that Channel and Server implement to allow them to hook
+        /// performing ops.
+        class CallHook
+        {
+        public:
+            virtual ~CallHook()
+            {
+            }
+            virtual void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) = 0;
+        };
+    }  // namespace internal
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set.h
index 5b1d440..c8dfe85 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set.h
@@ -42,1004 +42,1288 @@
 #include <grpcpp/impl/codegen/slice.h>
 #include <grpcpp/impl/codegen/string_ref.h>
 
-namespace grpc {
-
-extern CoreCodegenInterface* g_core_codegen_interface;
-
-namespace internal {
-class Call;
-class CallHook;
-
-// TODO(yangg) if the map is changed before we send, the pointers will be a
-// mess. Make sure it does not happen.
-inline grpc_metadata* FillMetadataArray(
-    const std::multimap<std::string, std::string>& metadata,
-    size_t* metadata_count, const std::string& optional_error_details) {
-  *metadata_count = metadata.size() + (optional_error_details.empty() ? 0 : 1);
-  if (*metadata_count == 0) {
-    return nullptr;
-  }
-  grpc_metadata* metadata_array =
-      static_cast<grpc_metadata*>(g_core_codegen_interface->gpr_malloc(
-          (*metadata_count) * sizeof(grpc_metadata)));
-  size_t i = 0;
-  for (auto iter = metadata.cbegin(); iter != metadata.cend(); ++iter, ++i) {
-    metadata_array[i].key = SliceReferencingString(iter->first);
-    metadata_array[i].value = SliceReferencingString(iter->second);
-  }
-  if (!optional_error_details.empty()) {
-    metadata_array[i].key =
-        g_core_codegen_interface->grpc_slice_from_static_buffer(
-            kBinaryErrorDetailsKey, sizeof(kBinaryErrorDetailsKey) - 1);
-    metadata_array[i].value = SliceReferencingString(optional_error_details);
-  }
-  return metadata_array;
-}
-}  // namespace internal
-
-/// Per-message write options.
-class WriteOptions {
- public:
-  WriteOptions() : flags_(0), last_message_(false) {}
-
-  /// Clear all flags.
-  inline void Clear() { flags_ = 0; }
-
-  /// Returns raw flags bitset.
-  inline uint32_t flags() const { return flags_; }
-
-  /// Sets flag for the disabling of compression for the next message write.
-  ///
-  /// \sa GRPC_WRITE_NO_COMPRESS
-  inline WriteOptions& set_no_compression() {
-    SetBit(GRPC_WRITE_NO_COMPRESS);
-    return *this;
-  }
-
-  /// Clears flag for the disabling of compression for the next message write.
-  ///
-  /// \sa GRPC_WRITE_NO_COMPRESS
-  inline WriteOptions& clear_no_compression() {
-    ClearBit(GRPC_WRITE_NO_COMPRESS);
-    return *this;
-  }
-
-  /// Get value for the flag indicating whether compression for the next
-  /// message write is forcefully disabled.
-  ///
-  /// \sa GRPC_WRITE_NO_COMPRESS
-  inline bool get_no_compression() const {
-    return GetBit(GRPC_WRITE_NO_COMPRESS);
-  }
-
-  /// Sets flag indicating that the write may be buffered and need not go out on
-  /// the wire immediately.
-  ///
-  /// \sa GRPC_WRITE_BUFFER_HINT
-  inline WriteOptions& set_buffer_hint() {
-    SetBit(GRPC_WRITE_BUFFER_HINT);
-    return *this;
-  }
-
-  /// Clears flag indicating that the write may be buffered and need not go out
-  /// on the wire immediately.
-  ///
-  /// \sa GRPC_WRITE_BUFFER_HINT
-  inline WriteOptions& clear_buffer_hint() {
-    ClearBit(GRPC_WRITE_BUFFER_HINT);
-    return *this;
-  }
-
-  /// Get value for the flag indicating that the write may be buffered and need
-  /// not go out on the wire immediately.
-  ///
-  /// \sa GRPC_WRITE_BUFFER_HINT
-  inline bool get_buffer_hint() const { return GetBit(GRPC_WRITE_BUFFER_HINT); }
-
-  /// corked bit: aliases set_buffer_hint currently, with the intent that
-  /// set_buffer_hint will be removed in the future
-  inline WriteOptions& set_corked() {
-    SetBit(GRPC_WRITE_BUFFER_HINT);
-    return *this;
-  }
-
-  inline WriteOptions& clear_corked() {
-    ClearBit(GRPC_WRITE_BUFFER_HINT);
-    return *this;
-  }
-
-  inline bool is_corked() const { return GetBit(GRPC_WRITE_BUFFER_HINT); }
-
-  /// last-message bit: indicates this is the last message in a stream
-  /// client-side:  makes Write the equivalent of performing Write, WritesDone
-  /// in a single step
-  /// server-side:  hold the Write until the service handler returns (sync api)
-  /// or until Finish is called (async api)
-  inline WriteOptions& set_last_message() {
-    last_message_ = true;
-    return *this;
-  }
-
-  /// Clears flag indicating that this is the last message in a stream,
-  /// disabling coalescing.
-  inline WriteOptions& clear_last_message() {
-    last_message_ = false;
-    return *this;
-  }
-
-  /// Get value for the flag indicating that this is the last message, and
-  /// should be coalesced with trailing metadata.
-  ///
-  /// \sa GRPC_WRITE_LAST_MESSAGE
-  bool is_last_message() const { return last_message_; }
-
-  /// Guarantee that all bytes have been written to the socket before completing
-  /// this write (usually writes are completed when they pass flow control).
-  inline WriteOptions& set_write_through() {
-    SetBit(GRPC_WRITE_THROUGH);
-    return *this;
-  }
-
-  inline WriteOptions& clear_write_through() {
-    ClearBit(GRPC_WRITE_THROUGH);
-    return *this;
-  }
-
-  inline bool is_write_through() const { return GetBit(GRPC_WRITE_THROUGH); }
-
- private:
-  void SetBit(const uint32_t mask) { flags_ |= mask; }
-
-  void ClearBit(const uint32_t mask) { flags_ &= ~mask; }
-
-  bool GetBit(const uint32_t mask) const { return (flags_ & mask) != 0; }
-
-  uint32_t flags_;
-  bool last_message_;
-};
-
-namespace internal {
-
-/// Default argument for CallOpSet. The Unused parameter is unused by
-/// the class, but can be used for generating multiple names for the
-/// same thing.
-template <int Unused>
-class CallNoOp {
- protected:
-  void AddOp(grpc_op* /*ops*/, size_t* /*nops*/) {}
-  void FinishOp(bool* /*status*/) {}
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
-  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
-  }
-};
-
-class CallOpSendInitialMetadata {
- public:
-  CallOpSendInitialMetadata() : send_(false) {
-    maybe_compression_level_.is_set = false;
-  }
-
-  void SendInitialMetadata(std::multimap<std::string, std::string>* metadata,
-                           uint32_t flags) {
-    maybe_compression_level_.is_set = false;
-    send_ = true;
-    flags_ = flags;
-    metadata_map_ = metadata;
-  }
-
-  void set_compression_level(grpc_compression_level level) {
-    maybe_compression_level_.is_set = true;
-    maybe_compression_level_.level = level;
-  }
-
- protected:
-  void AddOp(grpc_op* ops, size_t* nops) {
-    if (!send_ || hijacked_) return;
-    grpc_op* op = &ops[(*nops)++];
-    op->op = GRPC_OP_SEND_INITIAL_METADATA;
-    op->flags = flags_;
-    op->reserved = nullptr;
-    initial_metadata_ =
-        FillMetadataArray(*metadata_map_, &initial_metadata_count_, "");
-    op->data.send_initial_metadata.count = initial_metadata_count_;
-    op->data.send_initial_metadata.metadata = initial_metadata_;
-    op->data.send_initial_metadata.maybe_compression_level.is_set =
-        maybe_compression_level_.is_set;
-    if (maybe_compression_level_.is_set) {
-      op->data.send_initial_metadata.maybe_compression_level.level =
-          maybe_compression_level_.level;
-    }
-  }
-  void FinishOp(bool* /*status*/) {
-    if (!send_ || hijacked_) return;
-    g_core_codegen_interface->gpr_free(initial_metadata_);
-    send_ = false;
-  }
-
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (!send_) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::PRE_SEND_INITIAL_METADATA);
-    interceptor_methods->SetSendInitialMetadata(metadata_map_);
-  }
-
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
-
-  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
-    hijacked_ = true;
-  }
-
-  bool hijacked_ = false;
-  bool send_;
-  uint32_t flags_;
-  size_t initial_metadata_count_;
-  std::multimap<std::string, std::string>* metadata_map_;
-  grpc_metadata* initial_metadata_;
-  struct {
-    bool is_set;
-    grpc_compression_level level;
-  } maybe_compression_level_;
-};
-
-class CallOpSendMessage {
- public:
-  CallOpSendMessage() : send_buf_() {}
-
-  /// Send \a message using \a options for the write. The \a options are cleared
-  /// after use.
-  template <class M>
-  Status SendMessage(const M& message,
-                     WriteOptions options) GRPC_MUST_USE_RESULT;
-
-  template <class M>
-  Status SendMessage(const M& message) GRPC_MUST_USE_RESULT;
-
-  /// Send \a message using \a options for the write. The \a options are cleared
-  /// after use. This form of SendMessage allows gRPC to reference \a message
-  /// beyond the lifetime of SendMessage.
-  template <class M>
-  Status SendMessagePtr(const M* message,
-                        WriteOptions options) GRPC_MUST_USE_RESULT;
-
-  /// This form of SendMessage allows gRPC to reference \a message beyond the
-  /// lifetime of SendMessage.
-  template <class M>
-  Status SendMessagePtr(const M* message) GRPC_MUST_USE_RESULT;
-
- protected:
-  void AddOp(grpc_op* ops, size_t* nops) {
-    if (msg_ == nullptr && !send_buf_.Valid()) return;
-    if (hijacked_) {
-      serializer_ = nullptr;
-      return;
-    }
-    if (msg_ != nullptr) {
-      GPR_CODEGEN_ASSERT(serializer_(msg_).ok());
-    }
-    serializer_ = nullptr;
-    grpc_op* op = &ops[(*nops)++];
-    op->op = GRPC_OP_SEND_MESSAGE;
-    op->flags = write_options_.flags();
-    op->reserved = nullptr;
-    op->data.send_message.send_message = send_buf_.c_buffer();
-    // Flags are per-message: clear them after use.
-    write_options_.Clear();
-  }
-  void FinishOp(bool* status) {
-    if (msg_ == nullptr && !send_buf_.Valid()) return;
-    send_buf_.Clear();
-    if (hijacked_ && failed_send_) {
-      // Hijacking interceptor failed this Op
-      *status = false;
-    } else if (!*status) {
-      // This Op was passed down to core and the Op failed
-      failed_send_ = true;
-    }
-  }
-
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (msg_ == nullptr && !send_buf_.Valid()) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::PRE_SEND_MESSAGE);
-    interceptor_methods->SetSendMessage(&send_buf_, &msg_, &failed_send_,
-                                        serializer_);
-  }
-
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (msg_ != nullptr || send_buf_.Valid()) {
-      interceptor_methods->AddInterceptionHookPoint(
-          experimental::InterceptionHookPoints::POST_SEND_MESSAGE);
-    }
-    send_buf_.Clear();
-    msg_ = nullptr;
-    // The contents of the SendMessage value that was previously set
-    // has had its references stolen by core's operations
-    interceptor_methods->SetSendMessage(nullptr, nullptr, &failed_send_,
-                                        nullptr);
-  }
-
-  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
-    hijacked_ = true;
-  }
-
- private:
-  const void* msg_ = nullptr;  // The original non-serialized message
-  bool hijacked_ = false;
-  bool failed_send_ = false;
-  ByteBuffer send_buf_;
-  WriteOptions write_options_;
-  std::function<Status(const void*)> serializer_;
-};
-
-template <class M>
-Status CallOpSendMessage::SendMessage(const M& message, WriteOptions options) {
-  write_options_ = options;
-  // Serialize immediately since we do not have access to the message pointer
-  bool own_buf;
-  // TODO(vjpai): Remove the void below when possible
-  // The void in the template parameter below should not be needed
-  // (since it should be implicit) but is needed due to an observed
-  // difference in behavior between clang and gcc for certain internal users
-  Status result = SerializationTraits<M, void>::Serialize(
-      message, send_buf_.bbuf_ptr(), &own_buf);
-  if (!own_buf) {
-    send_buf_.Duplicate();
-  }
-  return result;
-}
-
-template <class M>
-Status CallOpSendMessage::SendMessage(const M& message) {
-  return SendMessage(message, WriteOptions());
-}
-
-template <class M>
-Status CallOpSendMessage::SendMessagePtr(const M* message,
-                                         WriteOptions options) {
-  msg_ = message;
-  write_options_ = options;
-  // Store the serializer for later since we have access to the message
-  serializer_ = [this](const void* message) {
-    bool own_buf;
-    // TODO(vjpai): Remove the void below when possible
-    // The void in the template parameter below should not be needed
-    // (since it should be implicit) but is needed due to an observed
-    // difference in behavior between clang and gcc for certain internal users
-    Status result = SerializationTraits<M, void>::Serialize(
-        *static_cast<const M*>(message), send_buf_.bbuf_ptr(), &own_buf);
-    if (!own_buf) {
-      send_buf_.Duplicate();
-    }
-    return result;
-  };
-  return Status();
-}
-
-template <class M>
-Status CallOpSendMessage::SendMessagePtr(const M* message) {
-  return SendMessagePtr(message, WriteOptions());
-}
-
-template <class R>
-class CallOpRecvMessage {
- public:
-  void RecvMessage(R* message) { message_ = message; }
-
-  // Do not change status if no message is received.
-  void AllowNoMessage() { allow_not_getting_message_ = true; }
-
-  bool got_message = false;
-
- protected:
-  void AddOp(grpc_op* ops, size_t* nops) {
-    if (message_ == nullptr || hijacked_) return;
-    grpc_op* op = &ops[(*nops)++];
-    op->op = GRPC_OP_RECV_MESSAGE;
-    op->flags = 0;
-    op->reserved = nullptr;
-    op->data.recv_message.recv_message = recv_buf_.c_buffer_ptr();
-  }
-
-  void FinishOp(bool* status) {
-    if (message_ == nullptr) return;
-    if (recv_buf_.Valid()) {
-      if (*status) {
-        got_message = *status =
-            SerializationTraits<R>::Deserialize(recv_buf_.bbuf_ptr(), message_)
-                .ok();
-        recv_buf_.Release();
-      } else {
-        got_message = false;
-        recv_buf_.Clear();
-      }
-    } else if (hijacked_) {
-      if (hijacked_recv_message_failed_) {
-        FinishOpRecvMessageFailureHandler(status);
-      } else {
-        // The op was hijacked and it was successful. There is no further action
-        // to be performed since the message is already in its non-serialized
-        // form.
-      }
-    } else {
-      FinishOpRecvMessageFailureHandler(status);
-    }
-  }
-
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (message_ == nullptr) return;
-    interceptor_methods->SetRecvMessage(message_,
-                                        &hijacked_recv_message_failed_);
-  }
-
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (message_ == nullptr) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::POST_RECV_MESSAGE);
-    if (!got_message) interceptor_methods->SetRecvMessage(nullptr, nullptr);
-  }
-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
-    hijacked_ = true;
-    if (message_ == nullptr) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::PRE_RECV_MESSAGE);
-    got_message = true;
-  }
-
- private:
-  // Sets got_message and \a status for a failed recv message op
-  void FinishOpRecvMessageFailureHandler(bool* status) {
-    got_message = false;
-    if (!allow_not_getting_message_) {
-      *status = false;
-    }
-  }
-
-  R* message_ = nullptr;
-  ByteBuffer recv_buf_;
-  bool allow_not_getting_message_ = false;
-  bool hijacked_ = false;
-  bool hijacked_recv_message_failed_ = false;
-};
-
-class DeserializeFunc {
- public:
-  virtual Status Deserialize(ByteBuffer* buf) = 0;
-  virtual ~DeserializeFunc() {}
-};
-
-template <class R>
-class DeserializeFuncType final : public DeserializeFunc {
- public:
-  explicit DeserializeFuncType(R* message) : message_(message) {}
-  Status Deserialize(ByteBuffer* buf) override {
-    return SerializationTraits<R>::Deserialize(buf->bbuf_ptr(), message_);
-  }
-
-  ~DeserializeFuncType() override {}
-
- private:
-  R* message_;  // Not a managed pointer because management is external to this
-};
-
-class CallOpGenericRecvMessage {
- public:
-  template <class R>
-  void RecvMessage(R* message) {
-    // Use an explicit base class pointer to avoid resolution error in the
-    // following unique_ptr::reset for some old implementations.
-    DeserializeFunc* func = new DeserializeFuncType<R>(message);
-    deserialize_.reset(func);
-    message_ = message;
-  }
-
-  // Do not change status if no message is received.
-  void AllowNoMessage() { allow_not_getting_message_ = true; }
-
-  bool got_message = false;
-
- protected:
-  void AddOp(grpc_op* ops, size_t* nops) {
-    if (!deserialize_ || hijacked_) return;
-    grpc_op* op = &ops[(*nops)++];
-    op->op = GRPC_OP_RECV_MESSAGE;
-    op->flags = 0;
-    op->reserved = nullptr;
-    op->data.recv_message.recv_message = recv_buf_.c_buffer_ptr();
-  }
-
-  void FinishOp(bool* status) {
-    if (!deserialize_) return;
-    if (recv_buf_.Valid()) {
-      if (*status) {
-        got_message = true;
-        *status = deserialize_->Deserialize(&recv_buf_).ok();
-        recv_buf_.Release();
-      } else {
-        got_message = false;
-        recv_buf_.Clear();
-      }
-    } else if (hijacked_) {
-      if (hijacked_recv_message_failed_) {
-        FinishOpRecvMessageFailureHandler(status);
-      } else {
-        // The op was hijacked and it was successful. There is no further action
-        // to be performed since the message is already in its non-serialized
-        // form.
-      }
-    } else {
-      got_message = false;
-      if (!allow_not_getting_message_) {
-        *status = false;
-      }
-    }
-  }
-
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (!deserialize_) return;
-    interceptor_methods->SetRecvMessage(message_,
-                                        &hijacked_recv_message_failed_);
-  }
-
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (!deserialize_) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::POST_RECV_MESSAGE);
-    if (!got_message) interceptor_methods->SetRecvMessage(nullptr, nullptr);
-    deserialize_.reset();
-  }
-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
-    hijacked_ = true;
-    if (!deserialize_) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::PRE_RECV_MESSAGE);
-    got_message = true;
-  }
-
- private:
-  // Sets got_message and \a status for a failed recv message op
-  void FinishOpRecvMessageFailureHandler(bool* status) {
-    got_message = false;
-    if (!allow_not_getting_message_) {
-      *status = false;
-    }
-  }
-
-  void* message_ = nullptr;
-  std::unique_ptr<DeserializeFunc> deserialize_;
-  ByteBuffer recv_buf_;
-  bool allow_not_getting_message_ = false;
-  bool hijacked_ = false;
-  bool hijacked_recv_message_failed_ = false;
-};
-
-class CallOpClientSendClose {
- public:
-  CallOpClientSendClose() : send_(false) {}
-
-  void ClientSendClose() { send_ = true; }
-
- protected:
-  void AddOp(grpc_op* ops, size_t* nops) {
-    if (!send_ || hijacked_) return;
-    grpc_op* op = &ops[(*nops)++];
-    op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
-    op->flags = 0;
-    op->reserved = nullptr;
-  }
-  void FinishOp(bool* /*status*/) { send_ = false; }
-
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (!send_) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::PRE_SEND_CLOSE);
-  }
-
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
-
-  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
-    hijacked_ = true;
-  }
-
- private:
-  bool hijacked_ = false;
-  bool send_;
-};
-
-class CallOpServerSendStatus {
- public:
-  CallOpServerSendStatus() : send_status_available_(false) {}
-
-  void ServerSendStatus(
-      std::multimap<std::string, std::string>* trailing_metadata,
-      const Status& status) {
-    send_error_details_ = status.error_details();
-    metadata_map_ = trailing_metadata;
-    send_status_available_ = true;
-    send_status_code_ = static_cast<grpc_status_code>(status.error_code());
-    send_error_message_ = status.error_message();
-  }
-
- protected:
-  void AddOp(grpc_op* ops, size_t* nops) {
-    if (!send_status_available_ || hijacked_) return;
-    trailing_metadata_ = FillMetadataArray(
-        *metadata_map_, &trailing_metadata_count_, send_error_details_);
-    grpc_op* op = &ops[(*nops)++];
-    op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
-    op->data.send_status_from_server.trailing_metadata_count =
-        trailing_metadata_count_;
-    op->data.send_status_from_server.trailing_metadata = trailing_metadata_;
-    op->data.send_status_from_server.status = send_status_code_;
-    error_message_slice_ = SliceReferencingString(send_error_message_);
-    op->data.send_status_from_server.status_details =
-        send_error_message_.empty() ? nullptr : &error_message_slice_;
-    op->flags = 0;
-    op->reserved = nullptr;
-  }
-
-  void FinishOp(bool* /*status*/) {
-    if (!send_status_available_ || hijacked_) return;
-    g_core_codegen_interface->gpr_free(trailing_metadata_);
-    send_status_available_ = false;
-  }
-
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (!send_status_available_) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::PRE_SEND_STATUS);
-    interceptor_methods->SetSendTrailingMetadata(metadata_map_);
-    interceptor_methods->SetSendStatus(&send_status_code_, &send_error_details_,
-                                       &send_error_message_);
-  }
-
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* /*interceptor_methods*/) {}
-
-  void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/) {
-    hijacked_ = true;
-  }
-
- private:
-  bool hijacked_ = false;
-  bool send_status_available_;
-  grpc_status_code send_status_code_;
-  std::string send_error_details_;
-  std::string send_error_message_;
-  size_t trailing_metadata_count_;
-  std::multimap<std::string, std::string>* metadata_map_;
-  grpc_metadata* trailing_metadata_;
-  grpc_slice error_message_slice_;
-};
-
-class CallOpRecvInitialMetadata {
- public:
-  CallOpRecvInitialMetadata() : metadata_map_(nullptr) {}
-
-  void RecvInitialMetadata(grpc::ClientContext* context) {
-    context->initial_metadata_received_ = true;
-    metadata_map_ = &context->recv_initial_metadata_;
-  }
-
- protected:
-  void AddOp(grpc_op* ops, size_t* nops) {
-    if (metadata_map_ == nullptr || hijacked_) return;
-    grpc_op* op = &ops[(*nops)++];
-    op->op = GRPC_OP_RECV_INITIAL_METADATA;
-    op->data.recv_initial_metadata.recv_initial_metadata = metadata_map_->arr();
-    op->flags = 0;
-    op->reserved = nullptr;
-  }
-
-  void FinishOp(bool* /*status*/) {
-    if (metadata_map_ == nullptr || hijacked_) return;
-  }
-
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    interceptor_methods->SetRecvInitialMetadata(metadata_map_);
-  }
-
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (metadata_map_ == nullptr) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::POST_RECV_INITIAL_METADATA);
-    metadata_map_ = nullptr;
-  }
-
-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
-    hijacked_ = true;
-    if (metadata_map_ == nullptr) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::PRE_RECV_INITIAL_METADATA);
-  }
-
- private:
-  bool hijacked_ = false;
-  MetadataMap* metadata_map_;
-};
-
-class CallOpClientRecvStatus {
- public:
-  CallOpClientRecvStatus()
-      : recv_status_(nullptr), debug_error_string_(nullptr) {}
-
-  void ClientRecvStatus(grpc::ClientContext* context, Status* status) {
-    client_context_ = context;
-    metadata_map_ = &client_context_->trailing_metadata_;
-    recv_status_ = status;
-    error_message_ = g_core_codegen_interface->grpc_empty_slice();
-  }
-
- protected:
-  void AddOp(grpc_op* ops, size_t* nops) {
-    if (recv_status_ == nullptr || hijacked_) return;
-    grpc_op* op = &ops[(*nops)++];
-    op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
-    op->data.recv_status_on_client.trailing_metadata = metadata_map_->arr();
-    op->data.recv_status_on_client.status = &status_code_;
-    op->data.recv_status_on_client.status_details = &error_message_;
-    op->data.recv_status_on_client.error_string = &debug_error_string_;
-    op->flags = 0;
-    op->reserved = nullptr;
-  }
-
-  void FinishOp(bool* /*status*/) {
-    if (recv_status_ == nullptr || hijacked_) return;
-    if (static_cast<StatusCode>(status_code_) == StatusCode::OK) {
-      *recv_status_ = Status();
-      GPR_CODEGEN_DEBUG_ASSERT(debug_error_string_ == nullptr);
-    } else {
-      *recv_status_ =
-          Status(static_cast<StatusCode>(status_code_),
-                 GRPC_SLICE_IS_EMPTY(error_message_)
-                     ? std::string()
-                     : std::string(GRPC_SLICE_START_PTR(error_message_),
-                                   GRPC_SLICE_END_PTR(error_message_)),
-                 metadata_map_->GetBinaryErrorDetails());
-      if (debug_error_string_ != nullptr) {
-        client_context_->set_debug_error_string(debug_error_string_);
-        g_core_codegen_interface->gpr_free(
-            const_cast<char*>(debug_error_string_));
-      }
-    }
-    // TODO(soheil): Find callers that set debug string even for status OK,
-    //               and fix them.
-    g_core_codegen_interface->grpc_slice_unref(error_message_);
-  }
-
-  void SetInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    interceptor_methods->SetRecvStatus(recv_status_);
-    interceptor_methods->SetRecvTrailingMetadata(metadata_map_);
-  }
-
-  void SetFinishInterceptionHookPoint(
-      InterceptorBatchMethodsImpl* interceptor_methods) {
-    if (recv_status_ == nullptr) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::POST_RECV_STATUS);
-    recv_status_ = nullptr;
-  }
-
-  void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods) {
-    hijacked_ = true;
-    if (recv_status_ == nullptr) return;
-    interceptor_methods->AddInterceptionHookPoint(
-        experimental::InterceptionHookPoints::PRE_RECV_STATUS);
-  }
-
- private:
-  bool hijacked_ = false;
-  grpc::ClientContext* client_context_;
-  MetadataMap* metadata_map_;
-  Status* recv_status_;
-  const char* debug_error_string_;
-  grpc_status_code status_code_;
-  grpc_slice error_message_;
-};
-
-template <class Op1 = CallNoOp<1>, class Op2 = CallNoOp<2>,
-          class Op3 = CallNoOp<3>, class Op4 = CallNoOp<4>,
-          class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>>
-class CallOpSet;
-
-/// Primary implementation of CallOpSetInterface.
-/// Since we cannot use variadic templates, we declare slots up to
-/// the maximum count of ops we'll need in a set. We leverage the
-/// empty base class optimization to slim this class (especially
-/// when there are many unused slots used). To avoid duplicate base classes,
-/// the template parameter for CallNoOp is varied by argument position.
-template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
-class CallOpSet : public CallOpSetInterface,
-                  public Op1,
-                  public Op2,
-                  public Op3,
-                  public Op4,
-                  public Op5,
-                  public Op6 {
- public:
-  CallOpSet() : core_cq_tag_(this), return_tag_(this) {}
-  // The copy constructor and assignment operator reset the value of
-  // core_cq_tag_, return_tag_, done_intercepting_ and interceptor_methods_
-  // since those are only meaningful on a specific object, not across objects.
-  CallOpSet(const CallOpSet& other)
-      : core_cq_tag_(this),
-        return_tag_(this),
-        call_(other.call_),
-        done_intercepting_(false),
-        interceptor_methods_(InterceptorBatchMethodsImpl()) {}
-
-  CallOpSet& operator=(const CallOpSet& other) {
-    if (&other == this) {
-      return *this;
-    }
-    core_cq_tag_ = this;
-    return_tag_ = this;
-    call_ = other.call_;
-    done_intercepting_ = false;
-    interceptor_methods_ = InterceptorBatchMethodsImpl();
-    return *this;
-  }
-
-  void FillOps(Call* call) override {
-    done_intercepting_ = false;
-    g_core_codegen_interface->grpc_call_ref(call->call());
-    call_ =
-        *call;  // It's fine to create a copy of call since it's just pointers
-
-    if (RunInterceptors()) {
-      ContinueFillOpsAfterInterception();
-    } else {
-      // After the interceptors are run, ContinueFillOpsAfterInterception will
-      // be run
-    }
-  }
-
-  bool FinalizeResult(void** tag, bool* status) override {
-    if (done_intercepting_) {
-      // Complete the avalanching since we are done with this batch of ops
-      call_.cq()->CompleteAvalanching();
-      // We have already finished intercepting and filling in the results. This
-      // round trip from the core needed to be made because interceptors were
-      // run
-      *tag = return_tag_;
-      *status = saved_status_;
-      g_core_codegen_interface->grpc_call_unref(call_.call());
-      return true;
-    }
-
-    this->Op1::FinishOp(status);
-    this->Op2::FinishOp(status);
-    this->Op3::FinishOp(status);
-    this->Op4::FinishOp(status);
-    this->Op5::FinishOp(status);
-    this->Op6::FinishOp(status);
-    saved_status_ = *status;
-    if (RunInterceptorsPostRecv()) {
-      *tag = return_tag_;
-      g_core_codegen_interface->grpc_call_unref(call_.call());
-      return true;
-    }
-    // Interceptors are going to be run, so we can't return the tag just yet.
-    // After the interceptors are run, ContinueFinalizeResultAfterInterception
-    return false;
-  }
-
-  void set_output_tag(void* return_tag) { return_tag_ = return_tag; }
-
-  void* core_cq_tag() override { return core_cq_tag_; }
-
-  /// set_core_cq_tag is used to provide a different core CQ tag than "this".
-  /// This is used for callback-based tags, where the core tag is the core
-  /// callback function. It does not change the use or behavior of any other
-  /// function (such as FinalizeResult)
-  void set_core_cq_tag(void* core_cq_tag) { core_cq_tag_ = core_cq_tag; }
-
-  // This will be called while interceptors are run if the RPC is a hijacked
-  // RPC. This should set hijacking state for each of the ops.
-  void SetHijackingState() override {
-    this->Op1::SetHijackingState(&interceptor_methods_);
-    this->Op2::SetHijackingState(&interceptor_methods_);
-    this->Op3::SetHijackingState(&interceptor_methods_);
-    this->Op4::SetHijackingState(&interceptor_methods_);
-    this->Op5::SetHijackingState(&interceptor_methods_);
-    this->Op6::SetHijackingState(&interceptor_methods_);
-  }
-
-  // Should be called after interceptors are done running
-  void ContinueFillOpsAfterInterception() override {
-    static const size_t MAX_OPS = 6;
-    grpc_op ops[MAX_OPS];
-    size_t nops = 0;
-    this->Op1::AddOp(ops, &nops);
-    this->Op2::AddOp(ops, &nops);
-    this->Op3::AddOp(ops, &nops);
-    this->Op4::AddOp(ops, &nops);
-    this->Op5::AddOp(ops, &nops);
-    this->Op6::AddOp(ops, &nops);
-
-    grpc_call_error err = g_core_codegen_interface->grpc_call_start_batch(
-        call_.call(), ops, nops, core_cq_tag(), nullptr);
-
-    if (err != GRPC_CALL_OK) {
-      // A failure here indicates an API misuse; for example, doing a Write
-      // while another Write is already pending on the same RPC or invoking
-      // WritesDone multiple times
-      // gpr_log(GPR_ERROR, "API misuse of type %s observed",
-      //        g_core_codegen_interface->grpc_call_error_to_string(err));
-      GPR_CODEGEN_ASSERT(false);
-    }
-  }
-
-  // Should be called after interceptors are done running on the finalize result
-  // path
-  void ContinueFinalizeResultAfterInterception() override {
-    done_intercepting_ = true;
-    // The following call_start_batch is internally-generated so no need for an
-    // explanatory log on failure.
-    GPR_CODEGEN_ASSERT(g_core_codegen_interface->grpc_call_start_batch(
-                           call_.call(), nullptr, 0, core_cq_tag(), nullptr) ==
-                       GRPC_CALL_OK);
-  }
-
- private:
-  // Returns true if no interceptors need to be run
-  bool RunInterceptors() {
-    interceptor_methods_.ClearState();
-    interceptor_methods_.SetCallOpSetInterface(this);
-    interceptor_methods_.SetCall(&call_);
-    this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
-    this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
-    this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
-    this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
-    this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
-    this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
-    if (interceptor_methods_.InterceptorsListEmpty()) {
-      return true;
-    }
-    // This call will go through interceptors and would need to
-    // schedule new batches, so delay completion queue shutdown
-    call_.cq()->RegisterAvalanching();
-    return interceptor_methods_.RunInterceptors();
-  }
-  // Returns true if no interceptors need to be run
-  bool RunInterceptorsPostRecv() {
-    // Call and OpSet had already been set on the set state.
-    // SetReverse also clears previously set hook points
-    interceptor_methods_.SetReverse();
-    this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
-    this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
-    this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
-    this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
-    this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
-    this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
-    return interceptor_methods_.RunInterceptors();
-  }
-
-  void* core_cq_tag_;
-  void* return_tag_;
-  Call call_;
-  bool done_intercepting_ = false;
-  InterceptorBatchMethodsImpl interceptor_methods_;
-  bool saved_status_;
-};
-
-}  // namespace internal
+namespace grpc
+{
+
+    extern CoreCodegenInterface* g_core_codegen_interface;
+
+    namespace internal
+    {
+        class Call;
+        class CallHook;
+
+        // TODO(yangg) if the map is changed before we send, the pointers will be a
+        // mess. Make sure it does not happen.
+        inline grpc_metadata* FillMetadataArray(
+            const std::multimap<std::string, std::string>& metadata,
+            size_t* metadata_count,
+            const std::string& optional_error_details
+        )
+        {
+            *metadata_count = metadata.size() + (optional_error_details.empty() ? 0 : 1);
+            if (*metadata_count == 0)
+            {
+                return nullptr;
+            }
+            grpc_metadata* metadata_array =
+                static_cast<grpc_metadata*>(g_core_codegen_interface->gpr_malloc(
+                    (*metadata_count) * sizeof(grpc_metadata)
+                ));
+            size_t i = 0;
+            for (auto iter = metadata.cbegin(); iter != metadata.cend(); ++iter, ++i)
+            {
+                metadata_array[i].key = SliceReferencingString(iter->first);
+                metadata_array[i].value = SliceReferencingString(iter->second);
+            }
+            if (!optional_error_details.empty())
+            {
+                metadata_array[i].key =
+                    g_core_codegen_interface->grpc_slice_from_static_buffer(
+                        kBinaryErrorDetailsKey, sizeof(kBinaryErrorDetailsKey) - 1
+                    );
+                metadata_array[i].value = SliceReferencingString(optional_error_details);
+            }
+            return metadata_array;
+        }
+    }  // namespace internal
+
+    /// Per-message write options.
+    class WriteOptions
+    {
+    public:
+        WriteOptions() :
+            flags_(0),
+            last_message_(false)
+        {
+        }
+
+        /// Clear all flags.
+        inline void Clear()
+        {
+            flags_ = 0;
+        }
+
+        /// Returns raw flags bitset.
+        inline uint32_t flags() const
+        {
+            return flags_;
+        }
+
+        /// Sets flag for the disabling of compression for the next message write.
+        ///
+        /// \sa GRPC_WRITE_NO_COMPRESS
+        inline WriteOptions& set_no_compression()
+        {
+            SetBit(GRPC_WRITE_NO_COMPRESS);
+            return *this;
+        }
+
+        /// Clears flag for the disabling of compression for the next message write.
+        ///
+        /// \sa GRPC_WRITE_NO_COMPRESS
+        inline WriteOptions& clear_no_compression()
+        {
+            ClearBit(GRPC_WRITE_NO_COMPRESS);
+            return *this;
+        }
+
+        /// Get value for the flag indicating whether compression for the next
+        /// message write is forcefully disabled.
+        ///
+        /// \sa GRPC_WRITE_NO_COMPRESS
+        inline bool get_no_compression() const
+        {
+            return GetBit(GRPC_WRITE_NO_COMPRESS);
+        }
+
+        /// Sets flag indicating that the write may be buffered and need not go out on
+        /// the wire immediately.
+        ///
+        /// \sa GRPC_WRITE_BUFFER_HINT
+        inline WriteOptions& set_buffer_hint()
+        {
+            SetBit(GRPC_WRITE_BUFFER_HINT);
+            return *this;
+        }
+
+        /// Clears flag indicating that the write may be buffered and need not go out
+        /// on the wire immediately.
+        ///
+        /// \sa GRPC_WRITE_BUFFER_HINT
+        inline WriteOptions& clear_buffer_hint()
+        {
+            ClearBit(GRPC_WRITE_BUFFER_HINT);
+            return *this;
+        }
+
+        /// Get value for the flag indicating that the write may be buffered and need
+        /// not go out on the wire immediately.
+        ///
+        /// \sa GRPC_WRITE_BUFFER_HINT
+        inline bool get_buffer_hint() const
+        {
+            return GetBit(GRPC_WRITE_BUFFER_HINT);
+        }
+
+        /// corked bit: aliases set_buffer_hint currently, with the intent that
+        /// set_buffer_hint will be removed in the future
+        inline WriteOptions& set_corked()
+        {
+            SetBit(GRPC_WRITE_BUFFER_HINT);
+            return *this;
+        }
+
+        inline WriteOptions& clear_corked()
+        {
+            ClearBit(GRPC_WRITE_BUFFER_HINT);
+            return *this;
+        }
+
+        inline bool is_corked() const
+        {
+            return GetBit(GRPC_WRITE_BUFFER_HINT);
+        }
+
+        /// last-message bit: indicates this is the last message in a stream
+        /// client-side:  makes Write the equivalent of performing Write, WritesDone
+        /// in a single step
+        /// server-side:  hold the Write until the service handler returns (sync api)
+        /// or until Finish is called (async api)
+        inline WriteOptions& set_last_message()
+        {
+            last_message_ = true;
+            return *this;
+        }
+
+        /// Clears flag indicating that this is the last message in a stream,
+        /// disabling coalescing.
+        inline WriteOptions& clear_last_message()
+        {
+            last_message_ = false;
+            return *this;
+        }
+
+        /// Get value for the flag indicating that this is the last message, and
+        /// should be coalesced with trailing metadata.
+        ///
+        /// \sa GRPC_WRITE_LAST_MESSAGE
+        bool is_last_message() const
+        {
+            return last_message_;
+        }
+
+        /// Guarantee that all bytes have been written to the socket before completing
+        /// this write (usually writes are completed when they pass flow control).
+        inline WriteOptions& set_write_through()
+        {
+            SetBit(GRPC_WRITE_THROUGH);
+            return *this;
+        }
+
+        inline WriteOptions& clear_write_through()
+        {
+            ClearBit(GRPC_WRITE_THROUGH);
+            return *this;
+        }
+
+        inline bool is_write_through() const
+        {
+            return GetBit(GRPC_WRITE_THROUGH);
+        }
+
+    private:
+        void SetBit(const uint32_t mask)
+        {
+            flags_ |= mask;
+        }
+
+        void ClearBit(const uint32_t mask)
+        {
+            flags_ &= ~mask;
+        }
+
+        bool GetBit(const uint32_t mask) const
+        {
+            return (flags_ & mask) != 0;
+        }
+
+        uint32_t flags_;
+        bool last_message_;
+    };
+
+    namespace internal
+    {
+
+        /// Default argument for CallOpSet. The Unused parameter is unused by
+        /// the class, but can be used for generating multiple names for the
+        /// same thing.
+        template<int Unused>
+        class CallNoOp
+        {
+        protected:
+            void AddOp(grpc_op* /*ops*/, size_t* /*nops*/)
+            {
+            }
+            void FinishOp(bool* /*status*/)
+            {
+            }
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* /*interceptor_methods*/
+            )
+            {
+            }
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* /*interceptor_methods*/
+            )
+            {
+            }
+            void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/)
+            {
+            }
+        };
+
+        class CallOpSendInitialMetadata
+        {
+        public:
+            CallOpSendInitialMetadata() :
+                send_(false)
+            {
+                maybe_compression_level_.is_set = false;
+            }
+
+            void SendInitialMetadata(std::multimap<std::string, std::string>* metadata, uint32_t flags)
+            {
+                maybe_compression_level_.is_set = false;
+                send_ = true;
+                flags_ = flags;
+                metadata_map_ = metadata;
+            }
+
+            void set_compression_level(grpc_compression_level level)
+            {
+                maybe_compression_level_.is_set = true;
+                maybe_compression_level_.level = level;
+            }
+
+        protected:
+            void AddOp(grpc_op* ops, size_t* nops)
+            {
+                if (!send_ || hijacked_)
+                    return;
+                grpc_op* op = &ops[(*nops)++];
+                op->op = GRPC_OP_SEND_INITIAL_METADATA;
+                op->flags = flags_;
+                op->reserved = nullptr;
+                initial_metadata_ =
+                    FillMetadataArray(*metadata_map_, &initial_metadata_count_, "");
+                op->data.send_initial_metadata.count = initial_metadata_count_;
+                op->data.send_initial_metadata.metadata = initial_metadata_;
+                op->data.send_initial_metadata.maybe_compression_level.is_set =
+                    maybe_compression_level_.is_set;
+                if (maybe_compression_level_.is_set)
+                {
+                    op->data.send_initial_metadata.maybe_compression_level.level =
+                        maybe_compression_level_.level;
+                }
+            }
+            void FinishOp(bool* /*status*/)
+            {
+                if (!send_ || hijacked_)
+                    return;
+                g_core_codegen_interface->gpr_free(initial_metadata_);
+                send_ = false;
+            }
+
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (!send_)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::PRE_SEND_INITIAL_METADATA
+                );
+                interceptor_methods->SetSendInitialMetadata(metadata_map_);
+            }
+
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* /*interceptor_methods*/
+            )
+            {
+            }
+
+            void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/)
+            {
+                hijacked_ = true;
+            }
+
+            bool hijacked_ = false;
+            bool send_;
+            uint32_t flags_;
+            size_t initial_metadata_count_;
+            std::multimap<std::string, std::string>* metadata_map_;
+            grpc_metadata* initial_metadata_;
+            struct
+            {
+                bool is_set;
+                grpc_compression_level level;
+            } maybe_compression_level_;
+        };
+
+        class CallOpSendMessage
+        {
+        public:
+            CallOpSendMessage() :
+                send_buf_()
+            {
+            }
+
+            /// Send \a message using \a options for the write. The \a options are cleared
+            /// after use.
+            template<class M>
+            Status SendMessage(const M& message, WriteOptions options) GRPC_MUST_USE_RESULT;
+
+            template<class M>
+            Status SendMessage(const M& message) GRPC_MUST_USE_RESULT;
+
+            /// Send \a message using \a options for the write. The \a options are cleared
+            /// after use. This form of SendMessage allows gRPC to reference \a message
+            /// beyond the lifetime of SendMessage.
+            template<class M>
+            Status SendMessagePtr(const M* message, WriteOptions options) GRPC_MUST_USE_RESULT;
+
+            /// This form of SendMessage allows gRPC to reference \a message beyond the
+            /// lifetime of SendMessage.
+            template<class M>
+            Status SendMessagePtr(const M* message) GRPC_MUST_USE_RESULT;
+
+        protected:
+            void AddOp(grpc_op* ops, size_t* nops)
+            {
+                if (msg_ == nullptr && !send_buf_.Valid())
+                    return;
+                if (hijacked_)
+                {
+                    serializer_ = nullptr;
+                    return;
+                }
+                if (msg_ != nullptr)
+                {
+                    GPR_CODEGEN_ASSERT(serializer_(msg_).ok());
+                }
+                serializer_ = nullptr;
+                grpc_op* op = &ops[(*nops)++];
+                op->op = GRPC_OP_SEND_MESSAGE;
+                op->flags = write_options_.flags();
+                op->reserved = nullptr;
+                op->data.send_message.send_message = send_buf_.c_buffer();
+                // Flags are per-message: clear them after use.
+                write_options_.Clear();
+            }
+            void FinishOp(bool* status)
+            {
+                if (msg_ == nullptr && !send_buf_.Valid())
+                    return;
+                send_buf_.Clear();
+                if (hijacked_ && failed_send_)
+                {
+                    // Hijacking interceptor failed this Op
+                    *status = false;
+                }
+                else if (!*status)
+                {
+                    // This Op was passed down to core and the Op failed
+                    failed_send_ = true;
+                }
+            }
+
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (msg_ == nullptr && !send_buf_.Valid())
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::PRE_SEND_MESSAGE
+                );
+                interceptor_methods->SetSendMessage(&send_buf_, &msg_, &failed_send_, serializer_);
+            }
+
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (msg_ != nullptr || send_buf_.Valid())
+                {
+                    interceptor_methods->AddInterceptionHookPoint(
+                        experimental::InterceptionHookPoints::POST_SEND_MESSAGE
+                    );
+                }
+                send_buf_.Clear();
+                msg_ = nullptr;
+                // The contents of the SendMessage value that was previously set
+                // has had its references stolen by core's operations
+                interceptor_methods->SetSendMessage(nullptr, nullptr, &failed_send_, nullptr);
+            }
+
+            void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/)
+            {
+                hijacked_ = true;
+            }
+
+        private:
+            const void* msg_ = nullptr;  // The original non-serialized message
+            bool hijacked_ = false;
+            bool failed_send_ = false;
+            ByteBuffer send_buf_;
+            WriteOptions write_options_;
+            std::function<Status(const void*)> serializer_;
+        };
+
+        template<class M>
+        Status CallOpSendMessage::SendMessage(const M& message, WriteOptions options)
+        {
+            write_options_ = options;
+            // Serialize immediately since we do not have access to the message pointer
+            bool own_buf;
+            // TODO(vjpai): Remove the void below when possible
+            // The void in the template parameter below should not be needed
+            // (since it should be implicit) but is needed due to an observed
+            // difference in behavior between clang and gcc for certain internal users
+            Status result = SerializationTraits<M, void>::Serialize(
+                message, send_buf_.bbuf_ptr(), &own_buf
+            );
+            if (!own_buf)
+            {
+                send_buf_.Duplicate();
+            }
+            return result;
+        }
+
+        template<class M>
+        Status CallOpSendMessage::SendMessage(const M& message)
+        {
+            return SendMessage(message, WriteOptions());
+        }
+
+        template<class M>
+        Status CallOpSendMessage::SendMessagePtr(const M* message, WriteOptions options)
+        {
+            msg_ = message;
+            write_options_ = options;
+            // Store the serializer for later since we have access to the message
+            serializer_ = [this](const void* message)
+            {
+                bool own_buf;
+                // TODO(vjpai): Remove the void below when possible
+                // The void in the template parameter below should not be needed
+                // (since it should be implicit) but is needed due to an observed
+                // difference in behavior between clang and gcc for certain internal users
+                Status result = SerializationTraits<M, void>::Serialize(
+                    *static_cast<const M*>(message), send_buf_.bbuf_ptr(), &own_buf
+                );
+                if (!own_buf)
+                {
+                    send_buf_.Duplicate();
+                }
+                return result;
+            };
+            return Status();
+        }
+
+        template<class M>
+        Status CallOpSendMessage::SendMessagePtr(const M* message)
+        {
+            return SendMessagePtr(message, WriteOptions());
+        }
+
+        template<class R>
+        class CallOpRecvMessage
+        {
+        public:
+            void RecvMessage(R* message)
+            {
+                message_ = message;
+            }
+
+            // Do not change status if no message is received.
+            void AllowNoMessage()
+            {
+                allow_not_getting_message_ = true;
+            }
+
+            bool got_message = false;
+
+        protected:
+            void AddOp(grpc_op* ops, size_t* nops)
+            {
+                if (message_ == nullptr || hijacked_)
+                    return;
+                grpc_op* op = &ops[(*nops)++];
+                op->op = GRPC_OP_RECV_MESSAGE;
+                op->flags = 0;
+                op->reserved = nullptr;
+                op->data.recv_message.recv_message = recv_buf_.c_buffer_ptr();
+            }
+
+            void FinishOp(bool* status)
+            {
+                if (message_ == nullptr)
+                    return;
+                if (recv_buf_.Valid())
+                {
+                    if (*status)
+                    {
+                        got_message = *status =
+                            SerializationTraits<R>::Deserialize(recv_buf_.bbuf_ptr(), message_)
+                                .ok();
+                        recv_buf_.Release();
+                    }
+                    else
+                    {
+                        got_message = false;
+                        recv_buf_.Clear();
+                    }
+                }
+                else if (hijacked_)
+                {
+                    if (hijacked_recv_message_failed_)
+                    {
+                        FinishOpRecvMessageFailureHandler(status);
+                    }
+                    else
+                    {
+                        // The op was hijacked and it was successful. There is no further action
+                        // to be performed since the message is already in its non-serialized
+                        // form.
+                    }
+                }
+                else
+                {
+                    FinishOpRecvMessageFailureHandler(status);
+                }
+            }
+
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (message_ == nullptr)
+                    return;
+                interceptor_methods->SetRecvMessage(message_, &hijacked_recv_message_failed_);
+            }
+
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (message_ == nullptr)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::POST_RECV_MESSAGE
+                );
+                if (!got_message)
+                    interceptor_methods->SetRecvMessage(nullptr, nullptr);
+            }
+            void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods)
+            {
+                hijacked_ = true;
+                if (message_ == nullptr)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::PRE_RECV_MESSAGE
+                );
+                got_message = true;
+            }
+
+        private:
+            // Sets got_message and \a status for a failed recv message op
+            void FinishOpRecvMessageFailureHandler(bool* status)
+            {
+                got_message = false;
+                if (!allow_not_getting_message_)
+                {
+                    *status = false;
+                }
+            }
+
+            R* message_ = nullptr;
+            ByteBuffer recv_buf_;
+            bool allow_not_getting_message_ = false;
+            bool hijacked_ = false;
+            bool hijacked_recv_message_failed_ = false;
+        };
+
+        class DeserializeFunc
+        {
+        public:
+            virtual Status Deserialize(ByteBuffer* buf) = 0;
+            virtual ~DeserializeFunc()
+            {
+            }
+        };
+
+        template<class R>
+        class DeserializeFuncType final : public DeserializeFunc
+        {
+        public:
+            explicit DeserializeFuncType(R* message) :
+                message_(message)
+            {
+            }
+            Status Deserialize(ByteBuffer* buf) override
+            {
+                return SerializationTraits<R>::Deserialize(buf->bbuf_ptr(), message_);
+            }
+
+            ~DeserializeFuncType() override
+            {
+            }
+
+        private:
+            R* message_;  // Not a managed pointer because management is external to this
+        };
+
+        class CallOpGenericRecvMessage
+        {
+        public:
+            template<class R>
+            void RecvMessage(R* message)
+            {
+                // Use an explicit base class pointer to avoid resolution error in the
+                // following unique_ptr::reset for some old implementations.
+                DeserializeFunc* func = new DeserializeFuncType<R>(message);
+                deserialize_.reset(func);
+                message_ = message;
+            }
+
+            // Do not change status if no message is received.
+            void AllowNoMessage()
+            {
+                allow_not_getting_message_ = true;
+            }
+
+            bool got_message = false;
+
+        protected:
+            void AddOp(grpc_op* ops, size_t* nops)
+            {
+                if (!deserialize_ || hijacked_)
+                    return;
+                grpc_op* op = &ops[(*nops)++];
+                op->op = GRPC_OP_RECV_MESSAGE;
+                op->flags = 0;
+                op->reserved = nullptr;
+                op->data.recv_message.recv_message = recv_buf_.c_buffer_ptr();
+            }
+
+            void FinishOp(bool* status)
+            {
+                if (!deserialize_)
+                    return;
+                if (recv_buf_.Valid())
+                {
+                    if (*status)
+                    {
+                        got_message = true;
+                        *status = deserialize_->Deserialize(&recv_buf_).ok();
+                        recv_buf_.Release();
+                    }
+                    else
+                    {
+                        got_message = false;
+                        recv_buf_.Clear();
+                    }
+                }
+                else if (hijacked_)
+                {
+                    if (hijacked_recv_message_failed_)
+                    {
+                        FinishOpRecvMessageFailureHandler(status);
+                    }
+                    else
+                    {
+                        // The op was hijacked and it was successful. There is no further action
+                        // to be performed since the message is already in its non-serialized
+                        // form.
+                    }
+                }
+                else
+                {
+                    got_message = false;
+                    if (!allow_not_getting_message_)
+                    {
+                        *status = false;
+                    }
+                }
+            }
+
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (!deserialize_)
+                    return;
+                interceptor_methods->SetRecvMessage(message_, &hijacked_recv_message_failed_);
+            }
+
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (!deserialize_)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::POST_RECV_MESSAGE
+                );
+                if (!got_message)
+                    interceptor_methods->SetRecvMessage(nullptr, nullptr);
+                deserialize_.reset();
+            }
+            void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods)
+            {
+                hijacked_ = true;
+                if (!deserialize_)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::PRE_RECV_MESSAGE
+                );
+                got_message = true;
+            }
+
+        private:
+            // Sets got_message and \a status for a failed recv message op
+            void FinishOpRecvMessageFailureHandler(bool* status)
+            {
+                got_message = false;
+                if (!allow_not_getting_message_)
+                {
+                    *status = false;
+                }
+            }
+
+            void* message_ = nullptr;
+            std::unique_ptr<DeserializeFunc> deserialize_;
+            ByteBuffer recv_buf_;
+            bool allow_not_getting_message_ = false;
+            bool hijacked_ = false;
+            bool hijacked_recv_message_failed_ = false;
+        };
+
+        class CallOpClientSendClose
+        {
+        public:
+            CallOpClientSendClose() :
+                send_(false)
+            {
+            }
+
+            void ClientSendClose()
+            {
+                send_ = true;
+            }
+
+        protected:
+            void AddOp(grpc_op* ops, size_t* nops)
+            {
+                if (!send_ || hijacked_)
+                    return;
+                grpc_op* op = &ops[(*nops)++];
+                op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
+                op->flags = 0;
+                op->reserved = nullptr;
+            }
+            void FinishOp(bool* /*status*/)
+            {
+                send_ = false;
+            }
+
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (!send_)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::PRE_SEND_CLOSE
+                );
+            }
+
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* /*interceptor_methods*/
+            )
+            {
+            }
+
+            void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/)
+            {
+                hijacked_ = true;
+            }
+
+        private:
+            bool hijacked_ = false;
+            bool send_;
+        };
+
+        class CallOpServerSendStatus
+        {
+        public:
+            CallOpServerSendStatus() :
+                send_status_available_(false)
+            {
+            }
+
+            void ServerSendStatus(
+                std::multimap<std::string, std::string>* trailing_metadata,
+                const Status& status
+            )
+            {
+                send_error_details_ = status.error_details();
+                metadata_map_ = trailing_metadata;
+                send_status_available_ = true;
+                send_status_code_ = static_cast<grpc_status_code>(status.error_code());
+                send_error_message_ = status.error_message();
+            }
+
+        protected:
+            void AddOp(grpc_op* ops, size_t* nops)
+            {
+                if (!send_status_available_ || hijacked_)
+                    return;
+                trailing_metadata_ = FillMetadataArray(
+                    *metadata_map_, &trailing_metadata_count_, send_error_details_
+                );
+                grpc_op* op = &ops[(*nops)++];
+                op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
+                op->data.send_status_from_server.trailing_metadata_count =
+                    trailing_metadata_count_;
+                op->data.send_status_from_server.trailing_metadata = trailing_metadata_;
+                op->data.send_status_from_server.status = send_status_code_;
+                error_message_slice_ = SliceReferencingString(send_error_message_);
+                op->data.send_status_from_server.status_details =
+                    send_error_message_.empty() ? nullptr : &error_message_slice_;
+                op->flags = 0;
+                op->reserved = nullptr;
+            }
+
+            void FinishOp(bool* /*status*/)
+            {
+                if (!send_status_available_ || hijacked_)
+                    return;
+                g_core_codegen_interface->gpr_free(trailing_metadata_);
+                send_status_available_ = false;
+            }
+
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (!send_status_available_)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::PRE_SEND_STATUS
+                );
+                interceptor_methods->SetSendTrailingMetadata(metadata_map_);
+                interceptor_methods->SetSendStatus(&send_status_code_, &send_error_details_, &send_error_message_);
+            }
+
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* /*interceptor_methods*/
+            )
+            {
+            }
+
+            void SetHijackingState(InterceptorBatchMethodsImpl* /*interceptor_methods*/)
+            {
+                hijacked_ = true;
+            }
+
+        private:
+            bool hijacked_ = false;
+            bool send_status_available_;
+            grpc_status_code send_status_code_;
+            std::string send_error_details_;
+            std::string send_error_message_;
+            size_t trailing_metadata_count_;
+            std::multimap<std::string, std::string>* metadata_map_;
+            grpc_metadata* trailing_metadata_;
+            grpc_slice error_message_slice_;
+        };
+
+        class CallOpRecvInitialMetadata
+        {
+        public:
+            CallOpRecvInitialMetadata() :
+                metadata_map_(nullptr)
+            {
+            }
+
+            void RecvInitialMetadata(grpc::ClientContext* context)
+            {
+                context->initial_metadata_received_ = true;
+                metadata_map_ = &context->recv_initial_metadata_;
+            }
+
+        protected:
+            void AddOp(grpc_op* ops, size_t* nops)
+            {
+                if (metadata_map_ == nullptr || hijacked_)
+                    return;
+                grpc_op* op = &ops[(*nops)++];
+                op->op = GRPC_OP_RECV_INITIAL_METADATA;
+                op->data.recv_initial_metadata.recv_initial_metadata = metadata_map_->arr();
+                op->flags = 0;
+                op->reserved = nullptr;
+            }
+
+            void FinishOp(bool* /*status*/)
+            {
+                if (metadata_map_ == nullptr || hijacked_)
+                    return;
+            }
+
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                interceptor_methods->SetRecvInitialMetadata(metadata_map_);
+            }
+
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (metadata_map_ == nullptr)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::POST_RECV_INITIAL_METADATA
+                );
+                metadata_map_ = nullptr;
+            }
+
+            void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods)
+            {
+                hijacked_ = true;
+                if (metadata_map_ == nullptr)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::PRE_RECV_INITIAL_METADATA
+                );
+            }
+
+        private:
+            bool hijacked_ = false;
+            MetadataMap* metadata_map_;
+        };
+
+        class CallOpClientRecvStatus
+        {
+        public:
+            CallOpClientRecvStatus() :
+                recv_status_(nullptr),
+                debug_error_string_(nullptr)
+            {
+            }
+
+            void ClientRecvStatus(grpc::ClientContext* context, Status* status)
+            {
+                client_context_ = context;
+                metadata_map_ = &client_context_->trailing_metadata_;
+                recv_status_ = status;
+                error_message_ = g_core_codegen_interface->grpc_empty_slice();
+            }
+
+        protected:
+            void AddOp(grpc_op* ops, size_t* nops)
+            {
+                if (recv_status_ == nullptr || hijacked_)
+                    return;
+                grpc_op* op = &ops[(*nops)++];
+                op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
+                op->data.recv_status_on_client.trailing_metadata = metadata_map_->arr();
+                op->data.recv_status_on_client.status = &status_code_;
+                op->data.recv_status_on_client.status_details = &error_message_;
+                op->data.recv_status_on_client.error_string = &debug_error_string_;
+                op->flags = 0;
+                op->reserved = nullptr;
+            }
+
+            void FinishOp(bool* /*status*/)
+            {
+                if (recv_status_ == nullptr || hijacked_)
+                    return;
+                if (static_cast<StatusCode>(status_code_) == StatusCode::OK)
+                {
+                    *recv_status_ = Status();
+                    GPR_CODEGEN_DEBUG_ASSERT(debug_error_string_ == nullptr);
+                }
+                else
+                {
+                    *recv_status_ =
+                        Status(static_cast<StatusCode>(status_code_), GRPC_SLICE_IS_EMPTY(error_message_) ? std::string() : std::string(GRPC_SLICE_START_PTR(error_message_), GRPC_SLICE_END_PTR(error_message_)), metadata_map_->GetBinaryErrorDetails());
+                    if (debug_error_string_ != nullptr)
+                    {
+                        client_context_->set_debug_error_string(debug_error_string_);
+                        g_core_codegen_interface->gpr_free(
+                            const_cast<char*>(debug_error_string_)
+                        );
+                    }
+                }
+                // TODO(soheil): Find callers that set debug string even for status OK,
+                //               and fix them.
+                g_core_codegen_interface->grpc_slice_unref(error_message_);
+            }
+
+            void SetInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                interceptor_methods->SetRecvStatus(recv_status_);
+                interceptor_methods->SetRecvTrailingMetadata(metadata_map_);
+            }
+
+            void SetFinishInterceptionHookPoint(
+                InterceptorBatchMethodsImpl* interceptor_methods
+            )
+            {
+                if (recv_status_ == nullptr)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::POST_RECV_STATUS
+                );
+                recv_status_ = nullptr;
+            }
+
+            void SetHijackingState(InterceptorBatchMethodsImpl* interceptor_methods)
+            {
+                hijacked_ = true;
+                if (recv_status_ == nullptr)
+                    return;
+                interceptor_methods->AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::PRE_RECV_STATUS
+                );
+            }
+
+        private:
+            bool hijacked_ = false;
+            grpc::ClientContext* client_context_;
+            MetadataMap* metadata_map_;
+            Status* recv_status_;
+            const char* debug_error_string_;
+            grpc_status_code status_code_;
+            grpc_slice error_message_;
+        };
+
+        template<class Op1 = CallNoOp<1>, class Op2 = CallNoOp<2>, class Op3 = CallNoOp<3>, class Op4 = CallNoOp<4>, class Op5 = CallNoOp<5>, class Op6 = CallNoOp<6>>
+        class CallOpSet;
+
+        /// Primary implementation of CallOpSetInterface.
+        /// Since we cannot use variadic templates, we declare slots up to
+        /// the maximum count of ops we'll need in a set. We leverage the
+        /// empty base class optimization to slim this class (especially
+        /// when there are many unused slots used). To avoid duplicate base classes,
+        /// the template parameter for CallNoOp is varied by argument position.
+        template<class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
+        class CallOpSet : public CallOpSetInterface, public Op1, public Op2, public Op3, public Op4, public Op5, public Op6
+        {
+        public:
+            CallOpSet() :
+                core_cq_tag_(this),
+                return_tag_(this)
+            {
+            }
+            // The copy constructor and assignment operator reset the value of
+            // core_cq_tag_, return_tag_, done_intercepting_ and interceptor_methods_
+            // since those are only meaningful on a specific object, not across objects.
+            CallOpSet(const CallOpSet& other) :
+                core_cq_tag_(this),
+                return_tag_(this),
+                call_(other.call_),
+                done_intercepting_(false),
+                interceptor_methods_(InterceptorBatchMethodsImpl())
+            {
+            }
+
+            CallOpSet& operator=(const CallOpSet& other)
+            {
+                if (&other == this)
+                {
+                    return *this;
+                }
+                core_cq_tag_ = this;
+                return_tag_ = this;
+                call_ = other.call_;
+                done_intercepting_ = false;
+                interceptor_methods_ = InterceptorBatchMethodsImpl();
+                return *this;
+            }
+
+            void FillOps(Call* call) override
+            {
+                done_intercepting_ = false;
+                g_core_codegen_interface->grpc_call_ref(call->call());
+                call_ =
+                    *call;  // It's fine to create a copy of call since it's just pointers
+
+                if (RunInterceptors())
+                {
+                    ContinueFillOpsAfterInterception();
+                }
+                else
+                {
+                    // After the interceptors are run, ContinueFillOpsAfterInterception will
+                    // be run
+                }
+            }
+
+            bool FinalizeResult(void** tag, bool* status) override
+            {
+                if (done_intercepting_)
+                {
+                    // Complete the avalanching since we are done with this batch of ops
+                    call_.cq()->CompleteAvalanching();
+                    // We have already finished intercepting and filling in the results. This
+                    // round trip from the core needed to be made because interceptors were
+                    // run
+                    *tag = return_tag_;
+                    *status = saved_status_;
+                    g_core_codegen_interface->grpc_call_unref(call_.call());
+                    return true;
+                }
+
+                this->Op1::FinishOp(status);
+                this->Op2::FinishOp(status);
+                this->Op3::FinishOp(status);
+                this->Op4::FinishOp(status);
+                this->Op5::FinishOp(status);
+                this->Op6::FinishOp(status);
+                saved_status_ = *status;
+                if (RunInterceptorsPostRecv())
+                {
+                    *tag = return_tag_;
+                    g_core_codegen_interface->grpc_call_unref(call_.call());
+                    return true;
+                }
+                // Interceptors are going to be run, so we can't return the tag just yet.
+                // After the interceptors are run, ContinueFinalizeResultAfterInterception
+                return false;
+            }
+
+            void set_output_tag(void* return_tag)
+            {
+                return_tag_ = return_tag;
+            }
+
+            void* core_cq_tag() override
+            {
+                return core_cq_tag_;
+            }
+
+            /// set_core_cq_tag is used to provide a different core CQ tag than "this".
+            /// This is used for callback-based tags, where the core tag is the core
+            /// callback function. It does not change the use or behavior of any other
+            /// function (such as FinalizeResult)
+            void set_core_cq_tag(void* core_cq_tag)
+            {
+                core_cq_tag_ = core_cq_tag;
+            }
+
+            // This will be called while interceptors are run if the RPC is a hijacked
+            // RPC. This should set hijacking state for each of the ops.
+            void SetHijackingState() override
+            {
+                this->Op1::SetHijackingState(&interceptor_methods_);
+                this->Op2::SetHijackingState(&interceptor_methods_);
+                this->Op3::SetHijackingState(&interceptor_methods_);
+                this->Op4::SetHijackingState(&interceptor_methods_);
+                this->Op5::SetHijackingState(&interceptor_methods_);
+                this->Op6::SetHijackingState(&interceptor_methods_);
+            }
+
+            // Should be called after interceptors are done running
+            void ContinueFillOpsAfterInterception() override
+            {
+                static const size_t MAX_OPS = 6;
+                grpc_op ops[MAX_OPS];
+                size_t nops = 0;
+                this->Op1::AddOp(ops, &nops);
+                this->Op2::AddOp(ops, &nops);
+                this->Op3::AddOp(ops, &nops);
+                this->Op4::AddOp(ops, &nops);
+                this->Op5::AddOp(ops, &nops);
+                this->Op6::AddOp(ops, &nops);
+
+                grpc_call_error err = g_core_codegen_interface->grpc_call_start_batch(
+                    call_.call(), ops, nops, core_cq_tag(), nullptr
+                );
+
+                if (err != GRPC_CALL_OK)
+                {
+                    // A failure here indicates an API misuse; for example, doing a Write
+                    // while another Write is already pending on the same RPC or invoking
+                    // WritesDone multiple times
+                    // gpr_log(GPR_ERROR, "API misuse of type %s observed",
+                    //        g_core_codegen_interface->grpc_call_error_to_string(err));
+                    GPR_CODEGEN_ASSERT(false);
+                }
+            }
+
+            // Should be called after interceptors are done running on the finalize result
+            // path
+            void ContinueFinalizeResultAfterInterception() override
+            {
+                done_intercepting_ = true;
+                // The following call_start_batch is internally-generated so no need for an
+                // explanatory log on failure.
+                GPR_CODEGEN_ASSERT(g_core_codegen_interface->grpc_call_start_batch(call_.call(), nullptr, 0, core_cq_tag(), nullptr) == GRPC_CALL_OK);
+            }
+
+        private:
+            // Returns true if no interceptors need to be run
+            bool RunInterceptors()
+            {
+                interceptor_methods_.ClearState();
+                interceptor_methods_.SetCallOpSetInterface(this);
+                interceptor_methods_.SetCall(&call_);
+                this->Op1::SetInterceptionHookPoint(&interceptor_methods_);
+                this->Op2::SetInterceptionHookPoint(&interceptor_methods_);
+                this->Op3::SetInterceptionHookPoint(&interceptor_methods_);
+                this->Op4::SetInterceptionHookPoint(&interceptor_methods_);
+                this->Op5::SetInterceptionHookPoint(&interceptor_methods_);
+                this->Op6::SetInterceptionHookPoint(&interceptor_methods_);
+                if (interceptor_methods_.InterceptorsListEmpty())
+                {
+                    return true;
+                }
+                // This call will go through interceptors and would need to
+                // schedule new batches, so delay completion queue shutdown
+                call_.cq()->RegisterAvalanching();
+                return interceptor_methods_.RunInterceptors();
+            }
+            // Returns true if no interceptors need to be run
+            bool RunInterceptorsPostRecv()
+            {
+                // Call and OpSet had already been set on the set state.
+                // SetReverse also clears previously set hook points
+                interceptor_methods_.SetReverse();
+                this->Op1::SetFinishInterceptionHookPoint(&interceptor_methods_);
+                this->Op2::SetFinishInterceptionHookPoint(&interceptor_methods_);
+                this->Op3::SetFinishInterceptionHookPoint(&interceptor_methods_);
+                this->Op4::SetFinishInterceptionHookPoint(&interceptor_methods_);
+                this->Op5::SetFinishInterceptionHookPoint(&interceptor_methods_);
+                this->Op6::SetFinishInterceptionHookPoint(&interceptor_methods_);
+                return interceptor_methods_.RunInterceptors();
+            }
+
+            void* core_cq_tag_;
+            void* return_tag_;
+            Call call_;
+            bool done_intercepting_ = false;
+            InterceptorBatchMethodsImpl interceptor_methods_;
+            bool saved_status_;
+        };
+
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_CALL_OP_SET_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set_interface.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set_interface.h
index a8eed9f..187d048 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set_interface.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/call_op_set_interface.h
@@ -23,39 +23,42 @@
 
 #include <grpcpp/impl/codegen/completion_queue_tag.h>
 
-namespace grpc {
-namespace internal {
-
-class Call;
-
-/// An abstract collection of call ops, used to generate the
-/// grpc_call_op structure to pass down to the lower layers,
-/// and as it is-a CompletionQueueTag, also massages the final
-/// completion into the correct form for consumption in the C++
-/// API.
-class CallOpSetInterface : public CompletionQueueTag {
- public:
-  /// Fills in grpc_op, starting from ops[*nops] and moving
-  /// upwards.
-  virtual void FillOps(internal::Call* call) = 0;
-
-  /// Get the tag to be used at the core completion queue. Generally, the
-  /// value of core_cq_tag will be "this". However, it can be overridden if we
-  /// want core to process the tag differently (e.g., as a core callback)
-  virtual void* core_cq_tag() = 0;
-
-  // This will be called while interceptors are run if the RPC is a hijacked
-  // RPC. This should set hijacking state for each of the ops.
-  virtual void SetHijackingState() = 0;
-
-  // Should be called after interceptors are done running
-  virtual void ContinueFillOpsAfterInterception() = 0;
-
-  // Should be called after interceptors are done running on the finalize result
-  // path
-  virtual void ContinueFinalizeResultAfterInterception() = 0;
-};
-}  // namespace internal
+namespace grpc
+{
+    namespace internal
+    {
+
+        class Call;
+
+        /// An abstract collection of call ops, used to generate the
+        /// grpc_call_op structure to pass down to the lower layers,
+        /// and as it is-a CompletionQueueTag, also massages the final
+        /// completion into the correct form for consumption in the C++
+        /// API.
+        class CallOpSetInterface : public CompletionQueueTag
+        {
+        public:
+            /// Fills in grpc_op, starting from ops[*nops] and moving
+            /// upwards.
+            virtual void FillOps(internal::Call* call) = 0;
+
+            /// Get the tag to be used at the core completion queue. Generally, the
+            /// value of core_cq_tag will be "this". However, it can be overridden if we
+            /// want core to process the tag differently (e.g., as a core callback)
+            virtual void* core_cq_tag() = 0;
+
+            // This will be called while interceptors are run if the RPC is a hijacked
+            // RPC. This should set hijacking state for each of the ops.
+            virtual void SetHijackingState() = 0;
+
+            // Should be called after interceptors are done running
+            virtual void ContinueFillOpsAfterInterception() = 0;
+
+            // Should be called after interceptors are done running on the finalize result
+            // path
+            virtual void ContinueFinalizeResultAfterInterception() = 0;
+        };
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_CALL_OP_SET_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/callback_common.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/callback_common.h
index 7c67c92..bd082f1 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/callback_common.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/callback_common.h
@@ -31,192 +31,243 @@
 #include <grpcpp/impl/codegen/core_codegen_interface.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-namespace internal {
-
-/// An exception-safe way of invoking a user-specified callback function
-// TODO(vjpai): decide whether it is better for this to take a const lvalue
-//              parameter or an rvalue parameter, or if it even matters
-template <class Func, class... Args>
-void CatchingCallback(Func&& func, Args&&... args) {
+namespace grpc
+{
+    namespace internal
+    {
+
+        /// An exception-safe way of invoking a user-specified callback function
+        // TODO(vjpai): decide whether it is better for this to take a const lvalue
+        //              parameter or an rvalue parameter, or if it even matters
+        template<class Func, class... Args>
+        void CatchingCallback(Func&& func, Args&&... args)
+        {
 #if GRPC_ALLOW_EXCEPTIONS
-  try {
-    func(std::forward<Args>(args)...);
-  } catch (...) {
-    // nothing to return or change here, just don't crash the library
-  }
+            try
+            {
+                func(std::forward<Args>(args)...);
+            }
+            catch (...)
+            {
+                // nothing to return or change here, just don't crash the library
+            }
 #else   // GRPC_ALLOW_EXCEPTIONS
-  func(std::forward<Args>(args)...);
+            func(std::forward<Args>(args)...);
 #endif  // GRPC_ALLOW_EXCEPTIONS
-}
+        }
 
-template <class Reactor, class Func, class... Args>
-Reactor* CatchingReactorGetter(Func&& func, Args&&... args) {
+        template<class Reactor, class Func, class... Args>
+        Reactor* CatchingReactorGetter(Func&& func, Args&&... args)
+        {
 #if GRPC_ALLOW_EXCEPTIONS
-  try {
-    return func(std::forward<Args>(args)...);
-  } catch (...) {
-    // fail the RPC, don't crash the library
-    return nullptr;
-  }
+            try
+            {
+                return func(std::forward<Args>(args)...);
+            }
+            catch (...)
+            {
+                // fail the RPC, don't crash the library
+                return nullptr;
+            }
 #else   // GRPC_ALLOW_EXCEPTIONS
-  return func(std::forward<Args>(args)...);
+            return func(std::forward<Args>(args)...);
 #endif  // GRPC_ALLOW_EXCEPTIONS
-}
-
-// The contract on these tags is that they are single-shot. They must be
-// constructed and then fired at exactly one point. There is no expectation
-// that they can be reused without reconstruction.
-
-class CallbackWithStatusTag : public grpc_completion_queue_functor {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(CallbackWithStatusTag));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  CallbackWithStatusTag(grpc_call* call, std::function<void(Status)> f,
-                        CompletionQueueTag* ops)
-      : call_(call), func_(std::move(f)), ops_(ops) {
-    g_core_codegen_interface->grpc_call_ref(call);
-    functor_run = &CallbackWithStatusTag::StaticRun;
-    // A client-side callback should never be run inline since they will always
-    // have work to do from the user application. So, set the parent's
-    // inlineable field to false
-    inlineable = false;
-  }
-  ~CallbackWithStatusTag() {}
-  Status* status_ptr() { return &status_; }
-
-  // force_run can not be performed on a tag if operations using this tag
-  // have been sent to PerformOpsOnCall. It is intended for error conditions
-  // that are detected before the operations are internally processed.
-  void force_run(Status s) {
-    status_ = std::move(s);
-    Run(true);
-  }
-
- private:
-  grpc_call* call_;
-  std::function<void(Status)> func_;
-  CompletionQueueTag* ops_;
-  Status status_;
-
-  static void StaticRun(grpc_completion_queue_functor* cb, int ok) {
-    static_cast<CallbackWithStatusTag*>(cb)->Run(static_cast<bool>(ok));
-  }
-  void Run(bool ok) {
-    void* ignored = ops_;
-
-    if (!ops_->FinalizeResult(&ignored, &ok)) {
-      // The tag was swallowed
-      return;
-    }
-    GPR_CODEGEN_ASSERT(ignored == ops_);
-
-    // Last use of func_ or status_, so ok to move them out
-    auto func = std::move(func_);
-    auto status = std::move(status_);
-    func_ = nullptr;     // reset to clear this out for sure
-    status_ = Status();  // reset to clear this out for sure
-    CatchingCallback(std::move(func), std::move(status));
-    g_core_codegen_interface->grpc_call_unref(call_);
-  }
-};
-
-/// CallbackWithSuccessTag can be reused multiple times, and will be used in
-/// this fashion for streaming operations. As a result, it shouldn't clear
-/// anything up until its destructor
-class CallbackWithSuccessTag : public grpc_completion_queue_functor {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(CallbackWithSuccessTag));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  CallbackWithSuccessTag() : call_(nullptr) {}
-
-  CallbackWithSuccessTag(const CallbackWithSuccessTag&) = delete;
-  CallbackWithSuccessTag& operator=(const CallbackWithSuccessTag&) = delete;
-
-  ~CallbackWithSuccessTag() { Clear(); }
-
-  // Set can only be called on a default-constructed or Clear'ed tag.
-  // It should never be called on a tag that was constructed with arguments
-  // or on a tag that has been Set before unless the tag has been cleared.
-  // can_inline indicates that this particular callback can be executed inline
-  // (without needing a thread hop) and is only used for library-provided server
-  // callbacks.
-  void Set(grpc_call* call, std::function<void(bool)> f,
-           CompletionQueueTag* ops, bool can_inline) {
-    GPR_CODEGEN_ASSERT(call_ == nullptr);
-    g_core_codegen_interface->grpc_call_ref(call);
-    call_ = call;
-    func_ = std::move(f);
-    ops_ = ops;
-    functor_run = &CallbackWithSuccessTag::StaticRun;
-    inlineable = can_inline;
-  }
-
-  void Clear() {
-    if (call_ != nullptr) {
-      grpc_call* call = call_;
-      call_ = nullptr;
-      func_ = nullptr;
-      g_core_codegen_interface->grpc_call_unref(call);
-    }
-  }
-
-  CompletionQueueTag* ops() { return ops_; }
-
-  // force_run can not be performed on a tag if operations using this tag
-  // have been sent to PerformOpsOnCall. It is intended for error conditions
-  // that are detected before the operations are internally processed.
-  void force_run(bool ok) { Run(ok); }
-
-  /// check if this tag is currently set
-  /* NOLINTNEXTLINE(google-explicit-constructor) */
-  operator bool() const { return call_ != nullptr; }
-
- private:
-  grpc_call* call_;
-  std::function<void(bool)> func_;
-  CompletionQueueTag* ops_;
-
-  static void StaticRun(grpc_completion_queue_functor* cb, int ok) {
-    static_cast<CallbackWithSuccessTag*>(cb)->Run(static_cast<bool>(ok));
-  }
-  void Run(bool ok) {
-    void* ignored = ops_;
-    // Allow a "false" return value from FinalizeResult to silence the
-    // callback, just as it silences a CQ tag in the async cases
+        }
+
+        // The contract on these tags is that they are single-shot. They must be
+        // constructed and then fired at exactly one point. There is no expectation
+        // that they can be reused without reconstruction.
+
+        class CallbackWithStatusTag : public grpc_completion_queue_functor
+        {
+        public:
+            // always allocated against a call arena, no memory free required
+            static void operator delete(void* /*ptr*/, std::size_t size)
+            {
+                GPR_CODEGEN_ASSERT(size == sizeof(CallbackWithStatusTag));
+            }
+
+            // This operator should never be called as the memory should be freed as part
+            // of the arena destruction. It only exists to provide a matching operator
+            // delete to the operator new so that some compilers will not complain (see
+            // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+            // there are no tests catching the compiler warning.
+            static void operator delete(void*, void*)
+            {
+                GPR_CODEGEN_ASSERT(false);
+            }
+
+            CallbackWithStatusTag(grpc_call* call, std::function<void(Status)> f, CompletionQueueTag* ops) :
+                call_(call),
+                func_(std::move(f)),
+                ops_(ops)
+            {
+                g_core_codegen_interface->grpc_call_ref(call);
+                functor_run = &CallbackWithStatusTag::StaticRun;
+                // A client-side callback should never be run inline since they will always
+                // have work to do from the user application. So, set the parent's
+                // inlineable field to false
+                inlineable = false;
+            }
+            ~CallbackWithStatusTag()
+            {
+            }
+            Status* status_ptr()
+            {
+                return &status_;
+            }
+
+            // force_run can not be performed on a tag if operations using this tag
+            // have been sent to PerformOpsOnCall. It is intended for error conditions
+            // that are detected before the operations are internally processed.
+            void force_run(Status s)
+            {
+                status_ = std::move(s);
+                Run(true);
+            }
+
+        private:
+            grpc_call* call_;
+            std::function<void(Status)> func_;
+            CompletionQueueTag* ops_;
+            Status status_;
+
+            static void StaticRun(grpc_completion_queue_functor* cb, int ok)
+            {
+                static_cast<CallbackWithStatusTag*>(cb)->Run(static_cast<bool>(ok));
+            }
+            void Run(bool ok)
+            {
+                void* ignored = ops_;
+
+                if (!ops_->FinalizeResult(&ignored, &ok))
+                {
+                    // The tag was swallowed
+                    return;
+                }
+                GPR_CODEGEN_ASSERT(ignored == ops_);
+
+                // Last use of func_ or status_, so ok to move them out
+                auto func = std::move(func_);
+                auto status = std::move(status_);
+                func_ = nullptr;     // reset to clear this out for sure
+                status_ = Status();  // reset to clear this out for sure
+                CatchingCallback(std::move(func), std::move(status));
+                g_core_codegen_interface->grpc_call_unref(call_);
+            }
+        };
+
+        /// CallbackWithSuccessTag can be reused multiple times, and will be used in
+        /// this fashion for streaming operations. As a result, it shouldn't clear
+        /// anything up until its destructor
+        class CallbackWithSuccessTag : public grpc_completion_queue_functor
+        {
+        public:
+            // always allocated against a call arena, no memory free required
+            static void operator delete(void* /*ptr*/, std::size_t size)
+            {
+                GPR_CODEGEN_ASSERT(size == sizeof(CallbackWithSuccessTag));
+            }
+
+            // This operator should never be called as the memory should be freed as part
+            // of the arena destruction. It only exists to provide a matching operator
+            // delete to the operator new so that some compilers will not complain (see
+            // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+            // there are no tests catching the compiler warning.
+            static void operator delete(void*, void*)
+            {
+                GPR_CODEGEN_ASSERT(false);
+            }
+
+            CallbackWithSuccessTag() :
+                call_(nullptr)
+            {
+            }
+
+            CallbackWithSuccessTag(const CallbackWithSuccessTag&) = delete;
+            CallbackWithSuccessTag& operator=(const CallbackWithSuccessTag&) = delete;
+
+            ~CallbackWithSuccessTag()
+            {
+                Clear();
+            }
+
+            // Set can only be called on a default-constructed or Clear'ed tag.
+            // It should never be called on a tag that was constructed with arguments
+            // or on a tag that has been Set before unless the tag has been cleared.
+            // can_inline indicates that this particular callback can be executed inline
+            // (without needing a thread hop) and is only used for library-provided server
+            // callbacks.
+            void Set(grpc_call* call, std::function<void(bool)> f, CompletionQueueTag* ops, bool can_inline)
+            {
+                GPR_CODEGEN_ASSERT(call_ == nullptr);
+                g_core_codegen_interface->grpc_call_ref(call);
+                call_ = call;
+                func_ = std::move(f);
+                ops_ = ops;
+                functor_run = &CallbackWithSuccessTag::StaticRun;
+                inlineable = can_inline;
+            }
+
+            void Clear()
+            {
+                if (call_ != nullptr)
+                {
+                    grpc_call* call = call_;
+                    call_ = nullptr;
+                    func_ = nullptr;
+                    g_core_codegen_interface->grpc_call_unref(call);
+                }
+            }
+
+            CompletionQueueTag* ops()
+            {
+                return ops_;
+            }
+
+            // force_run can not be performed on a tag if operations using this tag
+            // have been sent to PerformOpsOnCall. It is intended for error conditions
+            // that are detected before the operations are internally processed.
+            void force_run(bool ok)
+            {
+                Run(ok);
+            }
+
+            /// check if this tag is currently set
+            /* NOLINTNEXTLINE(google-explicit-constructor) */
+            operator bool() const
+            {
+                return call_ != nullptr;
+            }
+
+        private:
+            grpc_call* call_;
+            std::function<void(bool)> func_;
+            CompletionQueueTag* ops_;
+
+            static void StaticRun(grpc_completion_queue_functor* cb, int ok)
+            {
+                static_cast<CallbackWithSuccessTag*>(cb)->Run(static_cast<bool>(ok));
+            }
+            void Run(bool ok)
+            {
+                void* ignored = ops_;
+                // Allow a "false" return value from FinalizeResult to silence the
+                // callback, just as it silences a CQ tag in the async cases
 #ifndef NDEBUG
-    auto* ops = ops_;
+                auto* ops = ops_;
 #endif
-    bool do_callback = ops_->FinalizeResult(&ignored, &ok);
-    GPR_CODEGEN_DEBUG_ASSERT(ignored == ops);
+                bool do_callback = ops_->FinalizeResult(&ignored, &ok);
+                GPR_CODEGEN_DEBUG_ASSERT(ignored == ops);
 
-    if (do_callback) {
-      CatchingCallback(func_, ok);
-    }
-  }
-};
+                if (do_callback)
+                {
+                    CatchingCallback(func_, ok);
+                }
+            }
+        };
 
-}  // namespace internal
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_CALLBACK_COMMON_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/channel_interface.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/channel_interface.h
index 19fef7e..bcc9db0 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/channel_interface.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/channel_interface.h
@@ -26,147 +26,155 @@
 #include <grpcpp/impl/codegen/status.h>
 #include <grpcpp/impl/codegen/time.h>
 
-namespace grpc {
-template <class R>
-class ClientReader;
-template <class W>
-class ClientWriter;
-template <class W, class R>
-class ClientReaderWriter;
-namespace internal {
-template <class InputMessage, class OutputMessage>
-class CallbackUnaryCallImpl;
-template <class R>
-class ClientAsyncReaderFactory;
-template <class W>
-class ClientAsyncWriterFactory;
-template <class W, class R>
-class ClientAsyncReaderWriterFactory;
-class ClientAsyncResponseReaderHelper;
-template <class W, class R>
-class ClientCallbackReaderWriterFactory;
-template <class R>
-class ClientCallbackReaderFactory;
-template <class W>
-class ClientCallbackWriterFactory;
-class ClientCallbackUnaryFactory;
-}  // namespace internal
+namespace grpc
+{
+    template<class R>
+    class ClientReader;
+    template<class W>
+    class ClientWriter;
+    template<class W, class R>
+    class ClientReaderWriter;
+    namespace internal
+    {
+        template<class InputMessage, class OutputMessage>
+        class CallbackUnaryCallImpl;
+        template<class R>
+        class ClientAsyncReaderFactory;
+        template<class W>
+        class ClientAsyncWriterFactory;
+        template<class W, class R>
+        class ClientAsyncReaderWriterFactory;
+        class ClientAsyncResponseReaderHelper;
+        template<class W, class R>
+        class ClientCallbackReaderWriterFactory;
+        template<class R>
+        class ClientCallbackReaderFactory;
+        template<class W>
+        class ClientCallbackWriterFactory;
+        class ClientCallbackUnaryFactory;
+    }  // namespace internal
 
-class ChannelInterface;
-class ClientContext;
-class CompletionQueue;
+    class ChannelInterface;
+    class ClientContext;
+    class CompletionQueue;
 
-namespace experimental {
-class DelegatingChannel;
-}
+    namespace experimental
+    {
+        class DelegatingChannel;
+    }
 
-namespace internal {
-class Call;
-class CallOpSetInterface;
-class RpcMethod;
-class InterceptedChannel;
-template <class InputMessage, class OutputMessage>
-class BlockingUnaryCallImpl;
-}  // namespace internal
+    namespace internal
+    {
+        class Call;
+        class CallOpSetInterface;
+        class RpcMethod;
+        class InterceptedChannel;
+        template<class InputMessage, class OutputMessage>
+        class BlockingUnaryCallImpl;
+    }  // namespace internal
 
-/// Codegen interface for \a grpc::Channel.
-class ChannelInterface {
- public:
-  virtual ~ChannelInterface() {}
-  /// Get the current channel state. If the channel is in IDLE and
-  /// \a try_to_connect is set to true, try to connect.
-  virtual grpc_connectivity_state GetState(bool try_to_connect) = 0;
+    /// Codegen interface for \a grpc::Channel.
+    class ChannelInterface
+    {
+    public:
+        virtual ~ChannelInterface()
+        {
+        }
+        /// Get the current channel state. If the channel is in IDLE and
+        /// \a try_to_connect is set to true, try to connect.
+        virtual grpc_connectivity_state GetState(bool try_to_connect) = 0;
 
-  /// Return the \a tag on \a cq when the channel state is changed or \a
-  /// deadline expires. \a GetState needs to called to get the current state.
-  template <typename T>
-  void NotifyOnStateChange(grpc_connectivity_state last_observed, T deadline,
-                           grpc::CompletionQueue* cq, void* tag) {
-    TimePoint<T> deadline_tp(deadline);
-    NotifyOnStateChangeImpl(last_observed, deadline_tp.raw_time(), cq, tag);
-  }
+        /// Return the \a tag on \a cq when the channel state is changed or \a
+        /// deadline expires. \a GetState needs to called to get the current state.
+        template<typename T>
+        void NotifyOnStateChange(grpc_connectivity_state last_observed, T deadline, grpc::CompletionQueue* cq, void* tag)
+        {
+            TimePoint<T> deadline_tp(deadline);
+            NotifyOnStateChangeImpl(last_observed, deadline_tp.raw_time(), cq, tag);
+        }
 
-  /// Blocking wait for channel state change or \a deadline expiration.
-  /// \a GetState needs to called to get the current state.
-  template <typename T>
-  bool WaitForStateChange(grpc_connectivity_state last_observed, T deadline) {
-    TimePoint<T> deadline_tp(deadline);
-    return WaitForStateChangeImpl(last_observed, deadline_tp.raw_time());
-  }
+        /// Blocking wait for channel state change or \a deadline expiration.
+        /// \a GetState needs to called to get the current state.
+        template<typename T>
+        bool WaitForStateChange(grpc_connectivity_state last_observed, T deadline)
+        {
+            TimePoint<T> deadline_tp(deadline);
+            return WaitForStateChangeImpl(last_observed, deadline_tp.raw_time());
+        }
 
-  /// Wait for this channel to be connected
-  template <typename T>
-  bool WaitForConnected(T deadline) {
-    grpc_connectivity_state state;
-    while ((state = GetState(true)) != GRPC_CHANNEL_READY) {
-      if (!WaitForStateChange(state, deadline)) return false;
-    }
-    return true;
-  }
+        /// Wait for this channel to be connected
+        template<typename T>
+        bool WaitForConnected(T deadline)
+        {
+            grpc_connectivity_state state;
+            while ((state = GetState(true)) != GRPC_CHANNEL_READY)
+            {
+                if (!WaitForStateChange(state, deadline))
+                    return false;
+            }
+            return true;
+        }
 
- private:
-  template <class R>
-  friend class grpc::ClientReader;
-  template <class W>
-  friend class grpc::ClientWriter;
-  template <class W, class R>
-  friend class grpc::ClientReaderWriter;
-  template <class R>
-  friend class grpc::internal::ClientAsyncReaderFactory;
-  template <class W>
-  friend class grpc::internal::ClientAsyncWriterFactory;
-  template <class W, class R>
-  friend class grpc::internal::ClientAsyncReaderWriterFactory;
-  friend class grpc::internal::ClientAsyncResponseReaderHelper;
-  template <class W, class R>
-  friend class grpc::internal::ClientCallbackReaderWriterFactory;
-  template <class R>
-  friend class grpc::internal::ClientCallbackReaderFactory;
-  template <class W>
-  friend class grpc::internal::ClientCallbackWriterFactory;
-  friend class grpc::internal::ClientCallbackUnaryFactory;
-  template <class InputMessage, class OutputMessage>
-  friend class grpc::internal::BlockingUnaryCallImpl;
-  template <class InputMessage, class OutputMessage>
-  friend class grpc::internal::CallbackUnaryCallImpl;
-  friend class grpc::internal::RpcMethod;
-  friend class grpc::experimental::DelegatingChannel;
-  friend class grpc::internal::InterceptedChannel;
-  virtual internal::Call CreateCall(const internal::RpcMethod& method,
-                                    grpc::ClientContext* context,
-                                    grpc::CompletionQueue* cq) = 0;
-  virtual void PerformOpsOnCall(internal::CallOpSetInterface* ops,
-                                internal::Call* call) = 0;
-  virtual void* RegisterMethod(const char* method) = 0;
-  virtual void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
-                                       gpr_timespec deadline,
-                                       grpc::CompletionQueue* cq,
-                                       void* tag) = 0;
-  virtual bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
-                                      gpr_timespec deadline) = 0;
+    private:
+        template<class R>
+        friend class grpc::ClientReader;
+        template<class W>
+        friend class grpc::ClientWriter;
+        template<class W, class R>
+        friend class grpc::ClientReaderWriter;
+        template<class R>
+        friend class grpc::internal::ClientAsyncReaderFactory;
+        template<class W>
+        friend class grpc::internal::ClientAsyncWriterFactory;
+        template<class W, class R>
+        friend class grpc::internal::ClientAsyncReaderWriterFactory;
+        friend class grpc::internal::ClientAsyncResponseReaderHelper;
+        template<class W, class R>
+        friend class grpc::internal::ClientCallbackReaderWriterFactory;
+        template<class R>
+        friend class grpc::internal::ClientCallbackReaderFactory;
+        template<class W>
+        friend class grpc::internal::ClientCallbackWriterFactory;
+        friend class grpc::internal::ClientCallbackUnaryFactory;
+        template<class InputMessage, class OutputMessage>
+        friend class grpc::internal::BlockingUnaryCallImpl;
+        template<class InputMessage, class OutputMessage>
+        friend class grpc::internal::CallbackUnaryCallImpl;
+        friend class grpc::internal::RpcMethod;
+        friend class grpc::experimental::DelegatingChannel;
+        friend class grpc::internal::InterceptedChannel;
+        virtual internal::Call CreateCall(const internal::RpcMethod& method, grpc::ClientContext* context, grpc::CompletionQueue* cq) = 0;
+        virtual void PerformOpsOnCall(internal::CallOpSetInterface* ops, internal::Call* call) = 0;
+        virtual void* RegisterMethod(const char* method) = 0;
+        virtual void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, gpr_timespec deadline, grpc::CompletionQueue* cq, void* tag) = 0;
+        virtual bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, gpr_timespec deadline) = 0;
 
-  // EXPERIMENTAL
-  // This is needed to keep codegen_test_minimal happy. InterceptedChannel needs
-  // to make use of this but can't directly call Channel's implementation
-  // because of the test.
-  // Returns an empty Call object (rather than being pure) since this is a new
-  // method and adding a new pure method to an interface would be a breaking
-  // change (even though this is private and non-API)
-  virtual internal::Call CreateCallInternal(
-      const internal::RpcMethod& /*method*/, grpc::ClientContext* /*context*/,
-      grpc::CompletionQueue* /*cq*/, size_t /*interceptor_pos*/) {
-    return internal::Call();
-  }
+        // EXPERIMENTAL
+        // This is needed to keep codegen_test_minimal happy. InterceptedChannel needs
+        // to make use of this but can't directly call Channel's implementation
+        // because of the test.
+        // Returns an empty Call object (rather than being pure) since this is a new
+        // method and adding a new pure method to an interface would be a breaking
+        // change (even though this is private and non-API)
+        virtual internal::Call CreateCallInternal(
+            const internal::RpcMethod& /*method*/, grpc::ClientContext* /*context*/, grpc::CompletionQueue* /*cq*/, size_t /*interceptor_pos*/
+        )
+        {
+            return internal::Call();
+        }
 
-  // A method to get the callbackable completion queue associated with this
-  // channel. If the return value is nullptr, this channel doesn't support
-  // callback operations.
-  // TODO(vjpai): Consider a better default like using a global CQ
-  // Returns nullptr (rather than being pure) since this is a post-1.0 method
-  // and adding a new pure method to an interface would be a breaking change
-  // (even though this is private and non-API)
-  virtual grpc::CompletionQueue* CallbackCQ() { return nullptr; }
-};
+        // A method to get the callbackable completion queue associated with this
+        // channel. If the return value is nullptr, this channel doesn't support
+        // callback operations.
+        // TODO(vjpai): Consider a better default like using a global CQ
+        // Returns nullptr (rather than being pure) since this is a post-1.0 method
+        // and adding a new pure method to an interface would be a breaking change
+        // (even though this is private and non-API)
+        virtual grpc::CompletionQueue* CallbackCQ()
+        {
+            return nullptr;
+        }
+    };
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_CHANNEL_INTERFACE_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_callback.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_callback.h
index 04ab4aa..1216081 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_callback.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_callback.h
@@ -32,1198 +32,1411 @@
 #include <grpcpp/impl/codegen/status.h>
 #include <grpcpp/impl/codegen/sync.h>
 
-namespace grpc {
-class Channel;
-class ClientContext;
-
-namespace internal {
-class RpcMethod;
-
-/// Perform a callback-based unary call.  May optionally specify the base
-/// class of the Request and Response so that the internal calls and structures
-/// below this may be based on those base classes and thus achieve code reuse
-/// across different RPCs (e.g., for protobuf, MessageLite would be a base
-/// class).
-/// TODO(vjpai): Combine as much as possible with the blocking unary call code
-template <class InputMessage, class OutputMessage,
-          class BaseInputMessage = InputMessage,
-          class BaseOutputMessage = OutputMessage>
-void CallbackUnaryCall(grpc::ChannelInterface* channel,
-                       const grpc::internal::RpcMethod& method,
-                       grpc::ClientContext* context,
-                       const InputMessage* request, OutputMessage* result,
-                       std::function<void(grpc::Status)> on_completion) {
-  static_assert(std::is_base_of<BaseInputMessage, InputMessage>::value,
-                "Invalid input message specification");
-  static_assert(std::is_base_of<BaseOutputMessage, OutputMessage>::value,
-                "Invalid output message specification");
-  CallbackUnaryCallImpl<BaseInputMessage, BaseOutputMessage> x(
-      channel, method, context, request, result, on_completion);
-}
-
-template <class InputMessage, class OutputMessage>
-class CallbackUnaryCallImpl {
- public:
-  CallbackUnaryCallImpl(grpc::ChannelInterface* channel,
-                        const grpc::internal::RpcMethod& method,
-                        grpc::ClientContext* context,
-                        const InputMessage* request, OutputMessage* result,
-                        std::function<void(grpc::Status)> on_completion) {
-    grpc::CompletionQueue* cq = channel->CallbackCQ();
-    GPR_CODEGEN_ASSERT(cq != nullptr);
-    grpc::internal::Call call(channel->CreateCall(method, context, cq));
-
-    using FullCallOpSet = grpc::internal::CallOpSet<
-        grpc::internal::CallOpSendInitialMetadata,
-        grpc::internal::CallOpSendMessage,
-        grpc::internal::CallOpRecvInitialMetadata,
-        grpc::internal::CallOpRecvMessage<OutputMessage>,
-        grpc::internal::CallOpClientSendClose,
-        grpc::internal::CallOpClientRecvStatus>;
-
-    struct OpSetAndTag {
-      FullCallOpSet opset;
-      grpc::internal::CallbackWithStatusTag tag;
+namespace grpc
+{
+    class Channel;
+    class ClientContext;
+
+    namespace internal
+    {
+        class RpcMethod;
+
+        /// Perform a callback-based unary call.  May optionally specify the base
+        /// class of the Request and Response so that the internal calls and structures
+        /// below this may be based on those base classes and thus achieve code reuse
+        /// across different RPCs (e.g., for protobuf, MessageLite would be a base
+        /// class).
+        /// TODO(vjpai): Combine as much as possible with the blocking unary call code
+        template<class InputMessage, class OutputMessage, class BaseInputMessage = InputMessage, class BaseOutputMessage = OutputMessage>
+        void CallbackUnaryCall(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const InputMessage* request, OutputMessage* result, std::function<void(grpc::Status)> on_completion)
+        {
+            static_assert(std::is_base_of<BaseInputMessage, InputMessage>::value, "Invalid input message specification");
+            static_assert(std::is_base_of<BaseOutputMessage, OutputMessage>::value, "Invalid output message specification");
+            CallbackUnaryCallImpl<BaseInputMessage, BaseOutputMessage> x(
+                channel, method, context, request, result, on_completion
+            );
+        }
+
+        template<class InputMessage, class OutputMessage>
+        class CallbackUnaryCallImpl
+        {
+        public:
+            CallbackUnaryCallImpl(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const InputMessage* request, OutputMessage* result, std::function<void(grpc::Status)> on_completion)
+            {
+                grpc::CompletionQueue* cq = channel->CallbackCQ();
+                GPR_CODEGEN_ASSERT(cq != nullptr);
+                grpc::internal::Call call(channel->CreateCall(method, context, cq));
+
+                using FullCallOpSet = grpc::internal::CallOpSet<
+                    grpc::internal::CallOpSendInitialMetadata,
+                    grpc::internal::CallOpSendMessage,
+                    grpc::internal::CallOpRecvInitialMetadata,
+                    grpc::internal::CallOpRecvMessage<OutputMessage>,
+                    grpc::internal::CallOpClientSendClose,
+                    grpc::internal::CallOpClientRecvStatus>;
+
+                struct OpSetAndTag
+                {
+                    FullCallOpSet opset;
+                    grpc::internal::CallbackWithStatusTag tag;
+                };
+                const size_t alloc_sz = sizeof(OpSetAndTag);
+                auto* const alloced = static_cast<OpSetAndTag*>(
+                    grpc::g_core_codegen_interface->grpc_call_arena_alloc(call.call(), alloc_sz)
+                );
+                auto* ops = new (&alloced->opset) FullCallOpSet;
+                auto* tag = new (&alloced->tag)
+                    grpc::internal::CallbackWithStatusTag(call.call(), on_completion, ops);
+
+                // TODO(vjpai): Unify code with sync API as much as possible
+                grpc::Status s = ops->SendMessagePtr(request);
+                if (!s.ok())
+                {
+                    tag->force_run(s);
+                    return;
+                }
+                ops->SendInitialMetadata(&context->send_initial_metadata_, context->initial_metadata_flags());
+                ops->RecvInitialMetadata(context);
+                ops->RecvMessage(result);
+                ops->AllowNoMessage();
+                ops->ClientSendClose();
+                ops->ClientRecvStatus(context, tag->status_ptr());
+                ops->set_core_cq_tag(tag);
+                call.PerformOps(ops);
+            }
+        };
+
+        // Base class for public API classes.
+        class ClientReactor
+        {
+        public:
+            virtual ~ClientReactor() = default;
+
+            /// Called by the library when all operations associated with this RPC have
+            /// completed and all Holds have been removed. OnDone provides the RPC status
+            /// outcome for both successful and failed RPCs. If it is never called on an
+            /// RPC, it indicates an application-level problem (like failure to remove a
+            /// hold).
+            ///
+            /// \param[in] s The status outcome of this RPC
+            virtual void OnDone(const grpc::Status& /*s*/) = 0;
+
+            /// InternalScheduleOnDone is not part of the API and is not meant to be
+            /// overridden. It is virtual to allow successful builds for certain bazel
+            /// build users that only want to depend on gRPC codegen headers and not the
+            /// full library (although this is not a generally-supported option). Although
+            /// the virtual call is slower than a direct call, this function is
+            /// heavyweight and the cost of the virtual call is not much in comparison.
+            /// This function may be removed or devirtualized in the future.
+            virtual void InternalScheduleOnDone(grpc::Status s);
+
+            /// InternalTrailersOnly is not part of the API and is not meant to be
+            /// overridden. It is virtual to allow successful builds for certain bazel
+            /// build users that only want to depend on gRPC codegen headers and not the
+            /// full library (although this is not a generally-supported option). Although
+            /// the virtual call is slower than a direct call, this function is
+            /// heavyweight and the cost of the virtual call is not much in comparison.
+            /// This function may be removed or devirtualized in the future.
+            virtual bool InternalTrailersOnly(const grpc_call* call) const;
+        };
+
+    }  // namespace internal
+
+    // Forward declarations
+    template<class Request, class Response>
+    class ClientBidiReactor;
+    template<class Response>
+    class ClientReadReactor;
+    template<class Request>
+    class ClientWriteReactor;
+    class ClientUnaryReactor;
+
+    // NOTE: The streaming objects are not actually implemented in the public API.
+    //       These interfaces are provided for mocking only. Typical applications
+    //       will interact exclusively with the reactors that they define.
+    template<class Request, class Response>
+    class ClientCallbackReaderWriter
+    {
+    public:
+        virtual ~ClientCallbackReaderWriter()
+        {
+        }
+        virtual void StartCall() = 0;
+        virtual void Write(const Request* req, grpc::WriteOptions options) = 0;
+        virtual void WritesDone() = 0;
+        virtual void Read(Response* resp) = 0;
+        virtual void AddHold(int holds) = 0;
+        virtual void RemoveHold() = 0;
+
+    protected:
+        void BindReactor(ClientBidiReactor<Request, Response>* reactor)
+        {
+            reactor->BindStream(this);
+        }
     };
-    const size_t alloc_sz = sizeof(OpSetAndTag);
-    auto* const alloced = static_cast<OpSetAndTag*>(
-        grpc::g_core_codegen_interface->grpc_call_arena_alloc(call.call(),
-                                                              alloc_sz));
-    auto* ops = new (&alloced->opset) FullCallOpSet;
-    auto* tag = new (&alloced->tag)
-        grpc::internal::CallbackWithStatusTag(call.call(), on_completion, ops);
-
-    // TODO(vjpai): Unify code with sync API as much as possible
-    grpc::Status s = ops->SendMessagePtr(request);
-    if (!s.ok()) {
-      tag->force_run(s);
-      return;
-    }
-    ops->SendInitialMetadata(&context->send_initial_metadata_,
-                             context->initial_metadata_flags());
-    ops->RecvInitialMetadata(context);
-    ops->RecvMessage(result);
-    ops->AllowNoMessage();
-    ops->ClientSendClose();
-    ops->ClientRecvStatus(context, tag->status_ptr());
-    ops->set_core_cq_tag(tag);
-    call.PerformOps(ops);
-  }
-};
-
-// Base class for public API classes.
-class ClientReactor {
- public:
-  virtual ~ClientReactor() = default;
-
-  /// Called by the library when all operations associated with this RPC have
-  /// completed and all Holds have been removed. OnDone provides the RPC status
-  /// outcome for both successful and failed RPCs. If it is never called on an
-  /// RPC, it indicates an application-level problem (like failure to remove a
-  /// hold).
-  ///
-  /// \param[in] s The status outcome of this RPC
-  virtual void OnDone(const grpc::Status& /*s*/) = 0;
-
-  /// InternalScheduleOnDone is not part of the API and is not meant to be
-  /// overridden. It is virtual to allow successful builds for certain bazel
-  /// build users that only want to depend on gRPC codegen headers and not the
-  /// full library (although this is not a generally-supported option). Although
-  /// the virtual call is slower than a direct call, this function is
-  /// heavyweight and the cost of the virtual call is not much in comparison.
-  /// This function may be removed or devirtualized in the future.
-  virtual void InternalScheduleOnDone(grpc::Status s);
-
-  /// InternalTrailersOnly is not part of the API and is not meant to be
-  /// overridden. It is virtual to allow successful builds for certain bazel
-  /// build users that only want to depend on gRPC codegen headers and not the
-  /// full library (although this is not a generally-supported option). Although
-  /// the virtual call is slower than a direct call, this function is
-  /// heavyweight and the cost of the virtual call is not much in comparison.
-  /// This function may be removed or devirtualized in the future.
-  virtual bool InternalTrailersOnly(const grpc_call* call) const;
-};
-
-}  // namespace internal
-
-// Forward declarations
-template <class Request, class Response>
-class ClientBidiReactor;
-template <class Response>
-class ClientReadReactor;
-template <class Request>
-class ClientWriteReactor;
-class ClientUnaryReactor;
-
-// NOTE: The streaming objects are not actually implemented in the public API.
-//       These interfaces are provided for mocking only. Typical applications
-//       will interact exclusively with the reactors that they define.
-template <class Request, class Response>
-class ClientCallbackReaderWriter {
- public:
-  virtual ~ClientCallbackReaderWriter() {}
-  virtual void StartCall() = 0;
-  virtual void Write(const Request* req, grpc::WriteOptions options) = 0;
-  virtual void WritesDone() = 0;
-  virtual void Read(Response* resp) = 0;
-  virtual void AddHold(int holds) = 0;
-  virtual void RemoveHold() = 0;
-
- protected:
-  void BindReactor(ClientBidiReactor<Request, Response>* reactor) {
-    reactor->BindStream(this);
-  }
-};
-
-template <class Response>
-class ClientCallbackReader {
- public:
-  virtual ~ClientCallbackReader() {}
-  virtual void StartCall() = 0;
-  virtual void Read(Response* resp) = 0;
-  virtual void AddHold(int holds) = 0;
-  virtual void RemoveHold() = 0;
-
- protected:
-  void BindReactor(ClientReadReactor<Response>* reactor) {
-    reactor->BindReader(this);
-  }
-};
-
-template <class Request>
-class ClientCallbackWriter {
- public:
-  virtual ~ClientCallbackWriter() {}
-  virtual void StartCall() = 0;
-  void Write(const Request* req) { Write(req, grpc::WriteOptions()); }
-  virtual void Write(const Request* req, grpc::WriteOptions options) = 0;
-  void WriteLast(const Request* req, grpc::WriteOptions options) {
-    Write(req, options.set_last_message());
-  }
-  virtual void WritesDone() = 0;
-
-  virtual void AddHold(int holds) = 0;
-  virtual void RemoveHold() = 0;
-
- protected:
-  void BindReactor(ClientWriteReactor<Request>* reactor) {
-    reactor->BindWriter(this);
-  }
-};
-
-class ClientCallbackUnary {
- public:
-  virtual ~ClientCallbackUnary() {}
-  virtual void StartCall() = 0;
-
- protected:
-  void BindReactor(ClientUnaryReactor* reactor);
-};
-
-// The following classes are the reactor interfaces that are to be implemented
-// by the user. They are passed in to the library as an argument to a call on a
-// stub (either a codegen-ed call or a generic call). The streaming RPC is
-// activated by calling StartCall, possibly after initiating StartRead,
-// StartWrite, or AddHold operations on the streaming object. Note that none of
-// the classes are pure; all reactions have a default empty reaction so that the
-// user class only needs to override those reactions that it cares about.
-// The reactor must be passed to the stub invocation before any of the below
-// operations can be called and its reactions will be invoked by the library in
-// response to the completion of various operations. Reactions must not include
-// blocking operations (such as blocking I/O, starting synchronous RPCs, or
-// waiting on condition variables). Reactions may be invoked concurrently,
-// except that OnDone is called after all others (assuming proper API usage).
-// The reactor may not be deleted until OnDone is called.
-
-/// \a ClientBidiReactor is the interface for a bidirectional streaming RPC.
-template <class Request, class Response>
-class ClientBidiReactor : public internal::ClientReactor {
- public:
-  /// Activate the RPC and initiate any reads or writes that have been Start'ed
-  /// before this call. All streaming RPCs issued by the client MUST have
-  /// StartCall invoked on them (even if they are canceled) as this call is the
-  /// activation of their lifecycle.
-  void StartCall() { stream_->StartCall(); }
-
-  /// Initiate a read operation (or post it for later initiation if StartCall
-  /// has not yet been invoked).
-  ///
-  /// \param[out] resp Where to eventually store the read message. Valid when
-  ///                  the library calls OnReadDone
-  void StartRead(Response* resp) { stream_->Read(resp); }
-
-  /// Initiate a write operation (or post it for later initiation if StartCall
-  /// has not yet been invoked).
-  ///
-  /// \param[in] req The message to be written. The library does not take
-  ///                ownership but the caller must ensure that the message is
-  ///                not deleted or modified until OnWriteDone is called.
-  void StartWrite(const Request* req) { StartWrite(req, grpc::WriteOptions()); }
-
-  /// Initiate/post a write operation with specified options.
-  ///
-  /// \param[in] req The message to be written. The library does not take
-  ///                ownership but the caller must ensure that the message is
-  ///                not deleted or modified until OnWriteDone is called.
-  /// \param[in] options The WriteOptions to use for writing this message
-  void StartWrite(const Request* req, grpc::WriteOptions options) {
-    stream_->Write(req, options);
-  }
-
-  /// Initiate/post a write operation with specified options and an indication
-  /// that this is the last write (like StartWrite and StartWritesDone, merged).
-  /// Note that calling this means that no more calls to StartWrite,
-  /// StartWriteLast, or StartWritesDone are allowed.
-  ///
-  /// \param[in] req The message to be written. The library does not take
-  ///                ownership but the caller must ensure that the message is
-  ///                not deleted or modified until OnWriteDone is called.
-  /// \param[in] options The WriteOptions to use for writing this message
-  void StartWriteLast(const Request* req, grpc::WriteOptions options) {
-    StartWrite(req, options.set_last_message());
-  }
-
-  /// Indicate that the RPC will have no more write operations. This can only be
-  /// issued once for a given RPC. This is not required or allowed if
-  /// StartWriteLast is used since that already has the same implication.
-  /// Note that calling this means that no more calls to StartWrite,
-  /// StartWriteLast, or StartWritesDone are allowed.
-  void StartWritesDone() { stream_->WritesDone(); }
-
-  /// Holds are needed if (and only if) this stream has operations that take
-  /// place on it after StartCall but from outside one of the reactions
-  /// (OnReadDone, etc). This is _not_ a common use of the streaming API.
-  ///
-  /// Holds must be added before calling StartCall. If a stream still has a hold
-  /// in place, its resources will not be destroyed even if the status has
-  /// already come in from the wire and there are currently no active callbacks
-  /// outstanding. Similarly, the stream will not call OnDone if there are still
-  /// holds on it.
-  ///
-  /// For example, if a StartRead or StartWrite operation is going to be
-  /// initiated from elsewhere in the application, the application should call
-  /// AddHold or AddMultipleHolds before StartCall.  If there is going to be,
-  /// for example, a read-flow and a write-flow taking place outside the
-  /// reactions, then call AddMultipleHolds(2) before StartCall. When the
-  /// application knows that it won't issue any more read operations (such as
-  /// when a read comes back as not ok), it should issue a RemoveHold(). It
-  /// should also call RemoveHold() again after it does StartWriteLast or
-  /// StartWritesDone that indicates that there will be no more write ops.
-  /// The number of RemoveHold calls must match the total number of AddHold
-  /// calls plus the number of holds added by AddMultipleHolds.
-  /// The argument to AddMultipleHolds must be positive.
-  void AddHold() { AddMultipleHolds(1); }
-  void AddMultipleHolds(int holds) {
-    GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
-    stream_->AddHold(holds);
-  }
-  void RemoveHold() { stream_->RemoveHold(); }
-
-  /// Notifies the application that all operations associated with this RPC
-  /// have completed and all Holds have been removed. OnDone provides the RPC
-  /// status outcome for both successful and failed RPCs and will be called in
-  /// all cases. If it is not called, it indicates an application-level problem
-  /// (like failure to remove a hold).
-  ///
-  /// \param[in] s The status outcome of this RPC
-  void OnDone(const grpc::Status& /*s*/) override {}
-
-  /// Notifies the application that a read of initial metadata from the
-  /// server is done. If the application chooses not to implement this method,
-  /// it can assume that the initial metadata has been read before the first
-  /// call of OnReadDone or OnDone.
-  ///
-  /// \param[in] ok Was the initial metadata read successfully? If false, no
-  ///               new read/write operation will succeed, and any further
-  ///               Start* operations should not be called.
-  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
-
-  /// Notifies the application that a StartRead operation completed.
-  ///
-  /// \param[in] ok Was it successful? If false, no new read/write operation
-  ///               will succeed, and any further Start* should not be called.
-  virtual void OnReadDone(bool /*ok*/) {}
-
-  /// Notifies the application that a StartWrite or StartWriteLast operation
-  /// completed.
-  ///
-  /// \param[in] ok Was it successful? If false, no new read/write operation
-  ///               will succeed, and any further Start* should not be called.
-  virtual void OnWriteDone(bool /*ok*/) {}
-
-  /// Notifies the application that a StartWritesDone operation completed. Note
-  /// that this is only used on explicit StartWritesDone operations and not for
-  /// those that are implicitly invoked as part of a StartWriteLast.
-  ///
-  /// \param[in] ok Was it successful? If false, the application will later see
-  ///               the failure reflected as a bad status in OnDone and no
-  ///               further Start* should be called.
-  virtual void OnWritesDoneDone(bool /*ok*/) {}
-
- private:
-  friend class ClientCallbackReaderWriter<Request, Response>;
-  void BindStream(ClientCallbackReaderWriter<Request, Response>* stream) {
-    stream_ = stream;
-  }
-  ClientCallbackReaderWriter<Request, Response>* stream_;
-};
-
-/// \a ClientReadReactor is the interface for a server-streaming RPC.
-/// All public methods behave as in ClientBidiReactor.
-template <class Response>
-class ClientReadReactor : public internal::ClientReactor {
- public:
-  void StartCall() { reader_->StartCall(); }
-  void StartRead(Response* resp) { reader_->Read(resp); }
-
-  void AddHold() { AddMultipleHolds(1); }
-  void AddMultipleHolds(int holds) {
-    GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
-    reader_->AddHold(holds);
-  }
-  void RemoveHold() { reader_->RemoveHold(); }
-
-  void OnDone(const grpc::Status& /*s*/) override {}
-  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
-  virtual void OnReadDone(bool /*ok*/) {}
-
- private:
-  friend class ClientCallbackReader<Response>;
-  void BindReader(ClientCallbackReader<Response>* reader) { reader_ = reader; }
-  ClientCallbackReader<Response>* reader_;
-};
-
-/// \a ClientWriteReactor is the interface for a client-streaming RPC.
-/// All public methods behave as in ClientBidiReactor.
-template <class Request>
-class ClientWriteReactor : public internal::ClientReactor {
- public:
-  void StartCall() { writer_->StartCall(); }
-  void StartWrite(const Request* req) { StartWrite(req, grpc::WriteOptions()); }
-  void StartWrite(const Request* req, grpc::WriteOptions options) {
-    writer_->Write(req, options);
-  }
-  void StartWriteLast(const Request* req, grpc::WriteOptions options) {
-    StartWrite(req, options.set_last_message());
-  }
-  void StartWritesDone() { writer_->WritesDone(); }
-
-  void AddHold() { AddMultipleHolds(1); }
-  void AddMultipleHolds(int holds) {
-    GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
-    writer_->AddHold(holds);
-  }
-  void RemoveHold() { writer_->RemoveHold(); }
-
-  void OnDone(const grpc::Status& /*s*/) override {}
-  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
-  virtual void OnWriteDone(bool /*ok*/) {}
-  virtual void OnWritesDoneDone(bool /*ok*/) {}
-
- private:
-  friend class ClientCallbackWriter<Request>;
-  void BindWriter(ClientCallbackWriter<Request>* writer) { writer_ = writer; }
-
-  ClientCallbackWriter<Request>* writer_;
-};
-
-/// \a ClientUnaryReactor is a reactor-style interface for a unary RPC.
-/// This is _not_ a common way of invoking a unary RPC. In practice, this
-/// option should be used only if the unary RPC wants to receive initial
-/// metadata without waiting for the response to complete. Most deployments of
-/// RPC systems do not use this option, but it is needed for generality.
-/// All public methods behave as in ClientBidiReactor.
-/// StartCall is included for consistency with the other reactor flavors: even
-/// though there are no StartRead or StartWrite operations to queue before the
-/// call (that is part of the unary call itself) and there is no reactor object
-/// being created as a result of this call, we keep a consistent 2-phase
-/// initiation API among all the reactor flavors.
-class ClientUnaryReactor : public internal::ClientReactor {
- public:
-  void StartCall() { call_->StartCall(); }
-  void OnDone(const grpc::Status& /*s*/) override {}
-  virtual void OnReadInitialMetadataDone(bool /*ok*/) {}
-
- private:
-  friend class ClientCallbackUnary;
-  void BindCall(ClientCallbackUnary* call) { call_ = call; }
-  ClientCallbackUnary* call_;
-};
-
-// Define function out-of-line from class to avoid forward declaration issue
-inline void ClientCallbackUnary::BindReactor(ClientUnaryReactor* reactor) {
-  reactor->BindCall(this);
-}
-
-namespace internal {
-
-// Forward declare factory classes for friendship
-template <class Request, class Response>
-class ClientCallbackReaderWriterFactory;
-template <class Response>
-class ClientCallbackReaderFactory;
-template <class Request>
-class ClientCallbackWriterFactory;
-
-template <class Request, class Response>
-class ClientCallbackReaderWriterImpl
-    : public ClientCallbackReaderWriter<Request, Response> {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackReaderWriterImpl));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_) override {
-    // This call initiates two batches, plus any backlog, each with a callback
-    // 1. Send initial metadata (unless corked) + recv initial metadata
-    // 2. Any read backlog
-    // 3. Any write backlog
-    // 4. Recv trailing metadata (unless corked)
-    if (!start_corked_) {
-      start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                     context_->initial_metadata_flags());
-    }
 
-    call_.PerformOps(&start_ops_);
+    template<class Response>
+    class ClientCallbackReader
+    {
+    public:
+        virtual ~ClientCallbackReader()
+        {
+        }
+        virtual void StartCall() = 0;
+        virtual void Read(Response* resp) = 0;
+        virtual void AddHold(int holds) = 0;
+        virtual void RemoveHold() = 0;
+
+    protected:
+        void BindReactor(ClientReadReactor<Response>* reactor)
+        {
+            reactor->BindReader(this);
+        }
+    };
 
+    template<class Request>
+    class ClientCallbackWriter
     {
-      grpc::internal::MutexLock lock(&start_mu_);
-
-      if (backlog_.read_ops) {
-        call_.PerformOps(&read_ops_);
-      }
-      if (backlog_.write_ops) {
-        call_.PerformOps(&write_ops_);
-      }
-      if (backlog_.writes_done_ops) {
-        call_.PerformOps(&writes_done_ops_);
-      }
-      call_.PerformOps(&finish_ops_);
-      // The last thing in this critical section is to set started_ so that it
-      // can be used lock-free as well.
-      started_.store(true, std::memory_order_release);
-    }
-    // MaybeFinish outside the lock to make sure that destruction of this object
-    // doesn't take place while holding the lock (which would cause the lock to
-    // be released after destruction)
-    this->MaybeFinish(/*from_reaction=*/false);
-  }
-
-  void Read(Response* msg) override {
-    read_ops_.RecvMessage(msg);
-    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
-    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
-      grpc::internal::MutexLock lock(&start_mu_);
-      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
-        backlog_.read_ops = true;
-        return;
-      }
-    }
-    call_.PerformOps(&read_ops_);
-  }
-
-  void Write(const Request* msg, grpc::WriteOptions options)
-      ABSL_LOCKS_EXCLUDED(start_mu_) override {
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-      write_ops_.ClientSendClose();
-    }
-    // TODO(vjpai): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(msg, options).ok());
-    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
-    if (GPR_UNLIKELY(corked_write_needed_)) {
-      write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                     context_->initial_metadata_flags());
-      corked_write_needed_ = false;
-    }
+    public:
+        virtual ~ClientCallbackWriter()
+        {
+        }
+        virtual void StartCall() = 0;
+        void Write(const Request* req)
+        {
+            Write(req, grpc::WriteOptions());
+        }
+        virtual void Write(const Request* req, grpc::WriteOptions options) = 0;
+        void WriteLast(const Request* req, grpc::WriteOptions options)
+        {
+            Write(req, options.set_last_message());
+        }
+        virtual void WritesDone() = 0;
+
+        virtual void AddHold(int holds) = 0;
+        virtual void RemoveHold() = 0;
+
+    protected:
+        void BindReactor(ClientWriteReactor<Request>* reactor)
+        {
+            reactor->BindWriter(this);
+        }
+    };
 
-    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
-      grpc::internal::MutexLock lock(&start_mu_);
-      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
-        backlog_.write_ops = true;
-        return;
-      }
-    }
-    call_.PerformOps(&write_ops_);
-  }
-  void WritesDone() ABSL_LOCKS_EXCLUDED(start_mu_) override {
-    writes_done_ops_.ClientSendClose();
-    writes_done_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnWritesDoneDone(ok);
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &writes_done_ops_, /*can_inline=*/false);
-    writes_done_ops_.set_core_cq_tag(&writes_done_tag_);
-    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
-    if (GPR_UNLIKELY(corked_write_needed_)) {
-      writes_done_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                           context_->initial_metadata_flags());
-      corked_write_needed_ = false;
-    }
-    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
-      grpc::internal::MutexLock lock(&start_mu_);
-      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
-        backlog_.writes_done_ops = true;
-        return;
-      }
-    }
-    call_.PerformOps(&writes_done_ops_);
-  }
-
-  void AddHold(int holds) override {
-    callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
-  }
-  void RemoveHold() override { MaybeFinish(/*from_reaction=*/false); }
-
- private:
-  friend class ClientCallbackReaderWriterFactory<Request, Response>;
-
-  ClientCallbackReaderWriterImpl(grpc::internal::Call call,
-                                 grpc::ClientContext* context,
-                                 ClientBidiReactor<Request, Response>* reactor)
-      : context_(context),
-        call_(call),
-        reactor_(reactor),
-        start_corked_(context_->initial_metadata_corked_),
-        corked_write_needed_(start_corked_) {
-    this->BindReactor(reactor);
-
-    // Set up the unchanging parts of the start, read, and write tags and ops.
-    start_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnReadInitialMetadataDone(
-              ok && !reactor_->InternalTrailersOnly(call_.call()));
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &start_ops_, /*can_inline=*/false);
-    start_ops_.RecvInitialMetadata(context_);
-    start_ops_.set_core_cq_tag(&start_tag_);
-
-    write_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnWriteDone(ok);
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &write_ops_, /*can_inline=*/false);
-    write_ops_.set_core_cq_tag(&write_tag_);
-
-    read_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnReadDone(ok);
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &read_ops_, /*can_inline=*/false);
-    read_ops_.set_core_cq_tag(&read_tag_);
-
-    // Also set up the Finish tag and op set.
-    finish_tag_.Set(
-        call_.call(),
-        [this](bool /*ok*/) { MaybeFinish(/*from_reaction=*/true); },
-        &finish_ops_,
-        /*can_inline=*/false);
-    finish_ops_.ClientRecvStatus(context_, &finish_status_);
-    finish_ops_.set_core_cq_tag(&finish_tag_);
-  }
-
-  // MaybeFinish can be called from reactions or from user-initiated operations
-  // like StartCall or RemoveHold. If this is the last operation or hold on this
-  // object, it will invoke the OnDone reaction. If MaybeFinish was called from
-  // a reaction, it can call OnDone directly. If not, it would need to schedule
-  // OnDone onto an executor thread to avoid the possibility of deadlocking with
-  // any locks in the user code that invoked it.
-  void MaybeFinish(bool from_reaction) {
-    if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(
-                         1, std::memory_order_acq_rel) == 1)) {
-      grpc::Status s = std::move(finish_status_);
-      auto* reactor = reactor_;
-      auto* call = call_.call();
-      this->~ClientCallbackReaderWriterImpl();
-      grpc::g_core_codegen_interface->grpc_call_unref(call);
-      if (GPR_LIKELY(from_reaction)) {
-        reactor->OnDone(s);
-      } else {
-        reactor->InternalScheduleOnDone(std::move(s));
-      }
-    }
-  }
-
-  grpc::ClientContext* const context_;
-  grpc::internal::Call call_;
-  ClientBidiReactor<Request, Response>* const reactor_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpRecvInitialMetadata>
-      start_ops_;
-  grpc::internal::CallbackWithSuccessTag start_tag_;
-  const bool start_corked_;
-  bool corked_write_needed_;  // no lock needed since only accessed in
-                              // Write/WritesDone which cannot be concurrent
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpClientRecvStatus> finish_ops_;
-  grpc::internal::CallbackWithSuccessTag finish_tag_;
-  grpc::Status finish_status_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpClientSendClose>
-      write_ops_;
-  grpc::internal::CallbackWithSuccessTag write_tag_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpClientSendClose>
-      writes_done_ops_;
-  grpc::internal::CallbackWithSuccessTag writes_done_tag_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<Response>>
-      read_ops_;
-  grpc::internal::CallbackWithSuccessTag read_tag_;
-
-  struct StartCallBacklog {
-    bool write_ops = false;
-    bool writes_done_ops = false;
-    bool read_ops = false;
-  };
-  StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
-
-  // Minimum of 3 callbacks to pre-register for start ops, StartCall, and finish
-  std::atomic<intptr_t> callbacks_outstanding_{3};
-  std::atomic_bool started_{false};
-  grpc::internal::Mutex start_mu_;
-};
-
-template <class Request, class Response>
-class ClientCallbackReaderWriterFactory {
- public:
-  static void Create(grpc::ChannelInterface* channel,
-                     const grpc::internal::RpcMethod& method,
-                     grpc::ClientContext* context,
-                     ClientBidiReactor<Request, Response>* reactor) {
-    grpc::internal::Call call =
-        channel->CreateCall(method, context, channel->CallbackCQ());
-
-    grpc::g_core_codegen_interface->grpc_call_ref(call.call());
-    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call.call(), sizeof(ClientCallbackReaderWriterImpl<Request, Response>)))
-        ClientCallbackReaderWriterImpl<Request, Response>(call, context,
-                                                          reactor);
-  }
-};
-
-template <class Response>
-class ClientCallbackReaderImpl : public ClientCallbackReader<Response> {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackReaderImpl));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  void StartCall() override {
-    // This call initiates two batches, plus any backlog, each with a callback
-    // 1. Send initial metadata (unless corked) + recv initial metadata
-    // 2. Any backlog
-    // 3. Recv trailing metadata
-
-    start_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnReadInitialMetadataDone(
-              ok && !reactor_->InternalTrailersOnly(call_.call()));
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &start_ops_, /*can_inline=*/false);
-    start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                   context_->initial_metadata_flags());
-    start_ops_.RecvInitialMetadata(context_);
-    start_ops_.set_core_cq_tag(&start_tag_);
-    call_.PerformOps(&start_ops_);
-
-    // Also set up the read tag so it doesn't have to be set up each time
-    read_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnReadDone(ok);
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &read_ops_, /*can_inline=*/false);
-    read_ops_.set_core_cq_tag(&read_tag_);
+    class ClientCallbackUnary
+    {
+    public:
+        virtual ~ClientCallbackUnary()
+        {
+        }
+        virtual void StartCall() = 0;
+
+    protected:
+        void BindReactor(ClientUnaryReactor* reactor);
+    };
 
+    // The following classes are the reactor interfaces that are to be implemented
+    // by the user. They are passed in to the library as an argument to a call on a
+    // stub (either a codegen-ed call or a generic call). The streaming RPC is
+    // activated by calling StartCall, possibly after initiating StartRead,
+    // StartWrite, or AddHold operations on the streaming object. Note that none of
+    // the classes are pure; all reactions have a default empty reaction so that the
+    // user class only needs to override those reactions that it cares about.
+    // The reactor must be passed to the stub invocation before any of the below
+    // operations can be called and its reactions will be invoked by the library in
+    // response to the completion of various operations. Reactions must not include
+    // blocking operations (such as blocking I/O, starting synchronous RPCs, or
+    // waiting on condition variables). Reactions may be invoked concurrently,
+    // except that OnDone is called after all others (assuming proper API usage).
+    // The reactor may not be deleted until OnDone is called.
+
+    /// \a ClientBidiReactor is the interface for a bidirectional streaming RPC.
+    template<class Request, class Response>
+    class ClientBidiReactor : public internal::ClientReactor
     {
-      grpc::internal::MutexLock lock(&start_mu_);
-      if (backlog_.read_ops) {
-        call_.PerformOps(&read_ops_);
-      }
-      started_.store(true, std::memory_order_release);
-    }
+    public:
+        /// Activate the RPC and initiate any reads or writes that have been Start'ed
+        /// before this call. All streaming RPCs issued by the client MUST have
+        /// StartCall invoked on them (even if they are canceled) as this call is the
+        /// activation of their lifecycle.
+        void StartCall()
+        {
+            stream_->StartCall();
+        }
+
+        /// Initiate a read operation (or post it for later initiation if StartCall
+        /// has not yet been invoked).
+        ///
+        /// \param[out] resp Where to eventually store the read message. Valid when
+        ///                  the library calls OnReadDone
+        void StartRead(Response* resp)
+        {
+            stream_->Read(resp);
+        }
+
+        /// Initiate a write operation (or post it for later initiation if StartCall
+        /// has not yet been invoked).
+        ///
+        /// \param[in] req The message to be written. The library does not take
+        ///                ownership but the caller must ensure that the message is
+        ///                not deleted or modified until OnWriteDone is called.
+        void StartWrite(const Request* req)
+        {
+            StartWrite(req, grpc::WriteOptions());
+        }
+
+        /// Initiate/post a write operation with specified options.
+        ///
+        /// \param[in] req The message to be written. The library does not take
+        ///                ownership but the caller must ensure that the message is
+        ///                not deleted or modified until OnWriteDone is called.
+        /// \param[in] options The WriteOptions to use for writing this message
+        void StartWrite(const Request* req, grpc::WriteOptions options)
+        {
+            stream_->Write(req, options);
+        }
+
+        /// Initiate/post a write operation with specified options and an indication
+        /// that this is the last write (like StartWrite and StartWritesDone, merged).
+        /// Note that calling this means that no more calls to StartWrite,
+        /// StartWriteLast, or StartWritesDone are allowed.
+        ///
+        /// \param[in] req The message to be written. The library does not take
+        ///                ownership but the caller must ensure that the message is
+        ///                not deleted or modified until OnWriteDone is called.
+        /// \param[in] options The WriteOptions to use for writing this message
+        void StartWriteLast(const Request* req, grpc::WriteOptions options)
+        {
+            StartWrite(req, options.set_last_message());
+        }
+
+        /// Indicate that the RPC will have no more write operations. This can only be
+        /// issued once for a given RPC. This is not required or allowed if
+        /// StartWriteLast is used since that already has the same implication.
+        /// Note that calling this means that no more calls to StartWrite,
+        /// StartWriteLast, or StartWritesDone are allowed.
+        void StartWritesDone()
+        {
+            stream_->WritesDone();
+        }
+
+        /// Holds are needed if (and only if) this stream has operations that take
+        /// place on it after StartCall but from outside one of the reactions
+        /// (OnReadDone, etc). This is _not_ a common use of the streaming API.
+        ///
+        /// Holds must be added before calling StartCall. If a stream still has a hold
+        /// in place, its resources will not be destroyed even if the status has
+        /// already come in from the wire and there are currently no active callbacks
+        /// outstanding. Similarly, the stream will not call OnDone if there are still
+        /// holds on it.
+        ///
+        /// For example, if a StartRead or StartWrite operation is going to be
+        /// initiated from elsewhere in the application, the application should call
+        /// AddHold or AddMultipleHolds before StartCall.  If there is going to be,
+        /// for example, a read-flow and a write-flow taking place outside the
+        /// reactions, then call AddMultipleHolds(2) before StartCall. When the
+        /// application knows that it won't issue any more read operations (such as
+        /// when a read comes back as not ok), it should issue a RemoveHold(). It
+        /// should also call RemoveHold() again after it does StartWriteLast or
+        /// StartWritesDone that indicates that there will be no more write ops.
+        /// The number of RemoveHold calls must match the total number of AddHold
+        /// calls plus the number of holds added by AddMultipleHolds.
+        /// The argument to AddMultipleHolds must be positive.
+        void AddHold()
+        {
+            AddMultipleHolds(1);
+        }
+        void AddMultipleHolds(int holds)
+        {
+            GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
+            stream_->AddHold(holds);
+        }
+        void RemoveHold()
+        {
+            stream_->RemoveHold();
+        }
+
+        /// Notifies the application that all operations associated with this RPC
+        /// have completed and all Holds have been removed. OnDone provides the RPC
+        /// status outcome for both successful and failed RPCs and will be called in
+        /// all cases. If it is not called, it indicates an application-level problem
+        /// (like failure to remove a hold).
+        ///
+        /// \param[in] s The status outcome of this RPC
+        void OnDone(const grpc::Status& /*s*/) override
+        {
+        }
+
+        /// Notifies the application that a read of initial metadata from the
+        /// server is done. If the application chooses not to implement this method,
+        /// it can assume that the initial metadata has been read before the first
+        /// call of OnReadDone or OnDone.
+        ///
+        /// \param[in] ok Was the initial metadata read successfully? If false, no
+        ///               new read/write operation will succeed, and any further
+        ///               Start* operations should not be called.
+        virtual void OnReadInitialMetadataDone(bool /*ok*/)
+        {
+        }
+
+        /// Notifies the application that a StartRead operation completed.
+        ///
+        /// \param[in] ok Was it successful? If false, no new read/write operation
+        ///               will succeed, and any further Start* should not be called.
+        virtual void OnReadDone(bool /*ok*/)
+        {
+        }
+
+        /// Notifies the application that a StartWrite or StartWriteLast operation
+        /// completed.
+        ///
+        /// \param[in] ok Was it successful? If false, no new read/write operation
+        ///               will succeed, and any further Start* should not be called.
+        virtual void OnWriteDone(bool /*ok*/)
+        {
+        }
+
+        /// Notifies the application that a StartWritesDone operation completed. Note
+        /// that this is only used on explicit StartWritesDone operations and not for
+        /// those that are implicitly invoked as part of a StartWriteLast.
+        ///
+        /// \param[in] ok Was it successful? If false, the application will later see
+        ///               the failure reflected as a bad status in OnDone and no
+        ///               further Start* should be called.
+        virtual void OnWritesDoneDone(bool /*ok*/)
+        {
+        }
+
+    private:
+        friend class ClientCallbackReaderWriter<Request, Response>;
+        void BindStream(ClientCallbackReaderWriter<Request, Response>* stream)
+        {
+            stream_ = stream;
+        }
+        ClientCallbackReaderWriter<Request, Response>* stream_;
+    };
 
-    finish_tag_.Set(
-        call_.call(),
-        [this](bool /*ok*/) { MaybeFinish(/*from_reaction=*/true); },
-        &finish_ops_, /*can_inline=*/false);
-    finish_ops_.ClientRecvStatus(context_, &finish_status_);
-    finish_ops_.set_core_cq_tag(&finish_tag_);
-    call_.PerformOps(&finish_ops_);
-  }
-
-  void Read(Response* msg) override {
-    read_ops_.RecvMessage(msg);
-    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
-    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
-      grpc::internal::MutexLock lock(&start_mu_);
-      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
-        backlog_.read_ops = true;
-        return;
-      }
-    }
-    call_.PerformOps(&read_ops_);
-  }
-
-  void AddHold(int holds) override {
-    callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
-  }
-  void RemoveHold() override { MaybeFinish(/*from_reaction=*/false); }
-
- private:
-  friend class ClientCallbackReaderFactory<Response>;
-
-  template <class Request>
-  ClientCallbackReaderImpl(grpc::internal::Call call,
-                           grpc::ClientContext* context, Request* request,
-                           ClientReadReactor<Response>* reactor)
-      : context_(context), call_(call), reactor_(reactor) {
-    this->BindReactor(reactor);
-    // TODO(vjpai): don't assert
-    GPR_CODEGEN_ASSERT(start_ops_.SendMessagePtr(request).ok());
-    start_ops_.ClientSendClose();
-  }
-
-  // MaybeFinish behaves as in ClientCallbackReaderWriterImpl.
-  void MaybeFinish(bool from_reaction) {
-    if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(
-                         1, std::memory_order_acq_rel) == 1)) {
-      grpc::Status s = std::move(finish_status_);
-      auto* reactor = reactor_;
-      auto* call = call_.call();
-      this->~ClientCallbackReaderImpl();
-      grpc::g_core_codegen_interface->grpc_call_unref(call);
-      if (GPR_LIKELY(from_reaction)) {
-        reactor->OnDone(s);
-      } else {
-        reactor->InternalScheduleOnDone(std::move(s));
-      }
-    }
-  }
-
-  grpc::ClientContext* const context_;
-  grpc::internal::Call call_;
-  ClientReadReactor<Response>* const reactor_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpClientSendClose,
-                            grpc::internal::CallOpRecvInitialMetadata>
-      start_ops_;
-  grpc::internal::CallbackWithSuccessTag start_tag_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpClientRecvStatus> finish_ops_;
-  grpc::internal::CallbackWithSuccessTag finish_tag_;
-  grpc::Status finish_status_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<Response>>
-      read_ops_;
-  grpc::internal::CallbackWithSuccessTag read_tag_;
-
-  struct StartCallBacklog {
-    bool read_ops = false;
-  };
-  StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
-
-  // Minimum of 2 callbacks to pre-register for start and finish
-  std::atomic<intptr_t> callbacks_outstanding_{2};
-  std::atomic_bool started_{false};
-  grpc::internal::Mutex start_mu_;
-};
-
-template <class Response>
-class ClientCallbackReaderFactory {
- public:
-  template <class Request>
-  static void Create(grpc::ChannelInterface* channel,
-                     const grpc::internal::RpcMethod& method,
-                     grpc::ClientContext* context, const Request* request,
-                     ClientReadReactor<Response>* reactor) {
-    grpc::internal::Call call =
-        channel->CreateCall(method, context, channel->CallbackCQ());
-
-    grpc::g_core_codegen_interface->grpc_call_ref(call.call());
-    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call.call(), sizeof(ClientCallbackReaderImpl<Response>)))
-        ClientCallbackReaderImpl<Response>(call, context, request, reactor);
-  }
-};
-
-template <class Request>
-class ClientCallbackWriterImpl : public ClientCallbackWriter<Request> {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackWriterImpl));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_) override {
-    // This call initiates two batches, plus any backlog, each with a callback
-    // 1. Send initial metadata (unless corked) + recv initial metadata
-    // 2. Any backlog
-    // 3. Recv trailing metadata
-
-    if (!start_corked_) {
-      start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                     context_->initial_metadata_flags());
-    }
-    call_.PerformOps(&start_ops_);
+    /// \a ClientReadReactor is the interface for a server-streaming RPC.
+    /// All public methods behave as in ClientBidiReactor.
+    template<class Response>
+    class ClientReadReactor : public internal::ClientReactor
+    {
+    public:
+        void StartCall()
+        {
+            reader_->StartCall();
+        }
+        void StartRead(Response* resp)
+        {
+            reader_->Read(resp);
+        }
+
+        void AddHold()
+        {
+            AddMultipleHolds(1);
+        }
+        void AddMultipleHolds(int holds)
+        {
+            GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
+            reader_->AddHold(holds);
+        }
+        void RemoveHold()
+        {
+            reader_->RemoveHold();
+        }
+
+        void OnDone(const grpc::Status& /*s*/) override
+        {
+        }
+        virtual void OnReadInitialMetadataDone(bool /*ok*/)
+        {
+        }
+        virtual void OnReadDone(bool /*ok*/)
+        {
+        }
+
+    private:
+        friend class ClientCallbackReader<Response>;
+        void BindReader(ClientCallbackReader<Response>* reader)
+        {
+            reader_ = reader;
+        }
+        ClientCallbackReader<Response>* reader_;
+    };
 
+    /// \a ClientWriteReactor is the interface for a client-streaming RPC.
+    /// All public methods behave as in ClientBidiReactor.
+    template<class Request>
+    class ClientWriteReactor : public internal::ClientReactor
     {
-      grpc::internal::MutexLock lock(&start_mu_);
-
-      if (backlog_.write_ops) {
-        call_.PerformOps(&write_ops_);
-      }
-      if (backlog_.writes_done_ops) {
-        call_.PerformOps(&writes_done_ops_);
-      }
-      call_.PerformOps(&finish_ops_);
-      // The last thing in this critical section is to set started_ so that it
-      // can be used lock-free as well.
-      started_.store(true, std::memory_order_release);
-    }
-    // MaybeFinish outside the lock to make sure that destruction of this object
-    // doesn't take place while holding the lock (which would cause the lock to
-    // be released after destruction)
-    this->MaybeFinish(/*from_reaction=*/false);
-  }
-
-  void Write(const Request* msg, grpc::WriteOptions options)
-      ABSL_LOCKS_EXCLUDED(start_mu_) override {
-    if (GPR_UNLIKELY(options.is_last_message())) {
-      options.set_buffer_hint();
-      write_ops_.ClientSendClose();
-    }
-    // TODO(vjpai): don't assert
-    GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(msg, options).ok());
-    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
-
-    if (GPR_UNLIKELY(corked_write_needed_)) {
-      write_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                     context_->initial_metadata_flags());
-      corked_write_needed_ = false;
-    }
+    public:
+        void StartCall()
+        {
+            writer_->StartCall();
+        }
+        void StartWrite(const Request* req)
+        {
+            StartWrite(req, grpc::WriteOptions());
+        }
+        void StartWrite(const Request* req, grpc::WriteOptions options)
+        {
+            writer_->Write(req, options);
+        }
+        void StartWriteLast(const Request* req, grpc::WriteOptions options)
+        {
+            StartWrite(req, options.set_last_message());
+        }
+        void StartWritesDone()
+        {
+            writer_->WritesDone();
+        }
+
+        void AddHold()
+        {
+            AddMultipleHolds(1);
+        }
+        void AddMultipleHolds(int holds)
+        {
+            GPR_CODEGEN_DEBUG_ASSERT(holds > 0);
+            writer_->AddHold(holds);
+        }
+        void RemoveHold()
+        {
+            writer_->RemoveHold();
+        }
+
+        void OnDone(const grpc::Status& /*s*/) override
+        {
+        }
+        virtual void OnReadInitialMetadataDone(bool /*ok*/)
+        {
+        }
+        virtual void OnWriteDone(bool /*ok*/)
+        {
+        }
+        virtual void OnWritesDoneDone(bool /*ok*/)
+        {
+        }
+
+    private:
+        friend class ClientCallbackWriter<Request>;
+        void BindWriter(ClientCallbackWriter<Request>* writer)
+        {
+            writer_ = writer;
+        }
+
+        ClientCallbackWriter<Request>* writer_;
+    };
 
-    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
-      grpc::internal::MutexLock lock(&start_mu_);
-      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
-        backlog_.write_ops = true;
-        return;
-      }
-    }
-    call_.PerformOps(&write_ops_);
-  }
-
-  void WritesDone() ABSL_LOCKS_EXCLUDED(start_mu_) override {
-    writes_done_ops_.ClientSendClose();
-    writes_done_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnWritesDoneDone(ok);
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &writes_done_ops_, /*can_inline=*/false);
-    writes_done_ops_.set_core_cq_tag(&writes_done_tag_);
-    callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
-
-    if (GPR_UNLIKELY(corked_write_needed_)) {
-      writes_done_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                           context_->initial_metadata_flags());
-      corked_write_needed_ = false;
-    }
+    /// \a ClientUnaryReactor is a reactor-style interface for a unary RPC.
+    /// This is _not_ a common way of invoking a unary RPC. In practice, this
+    /// option should be used only if the unary RPC wants to receive initial
+    /// metadata without waiting for the response to complete. Most deployments of
+    /// RPC systems do not use this option, but it is needed for generality.
+    /// All public methods behave as in ClientBidiReactor.
+    /// StartCall is included for consistency with the other reactor flavors: even
+    /// though there are no StartRead or StartWrite operations to queue before the
+    /// call (that is part of the unary call itself) and there is no reactor object
+    /// being created as a result of this call, we keep a consistent 2-phase
+    /// initiation API among all the reactor flavors.
+    class ClientUnaryReactor : public internal::ClientReactor
+    {
+    public:
+        void StartCall()
+        {
+            call_->StartCall();
+        }
+        void OnDone(const grpc::Status& /*s*/) override
+        {
+        }
+        virtual void OnReadInitialMetadataDone(bool /*ok*/)
+        {
+        }
+
+    private:
+        friend class ClientCallbackUnary;
+        void BindCall(ClientCallbackUnary* call)
+        {
+            call_ = call;
+        }
+        ClientCallbackUnary* call_;
+    };
 
-    if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire))) {
-      grpc::internal::MutexLock lock(&start_mu_);
-      if (GPR_LIKELY(!started_.load(std::memory_order_relaxed))) {
-        backlog_.writes_done_ops = true;
-        return;
-      }
-    }
-    call_.PerformOps(&writes_done_ops_);
-  }
-
-  void AddHold(int holds) override {
-    callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
-  }
-  void RemoveHold() override { MaybeFinish(/*from_reaction=*/false); }
-
- private:
-  friend class ClientCallbackWriterFactory<Request>;
-
-  template <class Response>
-  ClientCallbackWriterImpl(grpc::internal::Call call,
-                           grpc::ClientContext* context, Response* response,
-                           ClientWriteReactor<Request>* reactor)
-      : context_(context),
-        call_(call),
-        reactor_(reactor),
-        start_corked_(context_->initial_metadata_corked_),
-        corked_write_needed_(start_corked_) {
-    this->BindReactor(reactor);
-
-    // Set up the unchanging parts of the start and write tags and ops.
-    start_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnReadInitialMetadataDone(
-              ok && !reactor_->InternalTrailersOnly(call_.call()));
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &start_ops_, /*can_inline=*/false);
-    start_ops_.RecvInitialMetadata(context_);
-    start_ops_.set_core_cq_tag(&start_tag_);
-
-    write_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnWriteDone(ok);
-          MaybeFinish(/*from_reaction=*/true);
-        },
-        &write_ops_, /*can_inline=*/false);
-    write_ops_.set_core_cq_tag(&write_tag_);
-
-    // Also set up the Finish tag and op set.
-    finish_ops_.RecvMessage(response);
-    finish_ops_.AllowNoMessage();
-    finish_tag_.Set(
-        call_.call(),
-        [this](bool /*ok*/) { MaybeFinish(/*from_reaction=*/true); },
-        &finish_ops_,
-        /*can_inline=*/false);
-    finish_ops_.ClientRecvStatus(context_, &finish_status_);
-    finish_ops_.set_core_cq_tag(&finish_tag_);
-  }
-
-  // MaybeFinish behaves as in ClientCallbackReaderWriterImpl.
-  void MaybeFinish(bool from_reaction) {
-    if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(
-                         1, std::memory_order_acq_rel) == 1)) {
-      grpc::Status s = std::move(finish_status_);
-      auto* reactor = reactor_;
-      auto* call = call_.call();
-      this->~ClientCallbackWriterImpl();
-      grpc::g_core_codegen_interface->grpc_call_unref(call);
-      if (GPR_LIKELY(from_reaction)) {
-        reactor->OnDone(s);
-      } else {
-        reactor->InternalScheduleOnDone(std::move(s));
-      }
-    }
-  }
-
-  grpc::ClientContext* const context_;
-  grpc::internal::Call call_;
-  ClientWriteReactor<Request>* const reactor_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpRecvInitialMetadata>
-      start_ops_;
-  grpc::internal::CallbackWithSuccessTag start_tag_;
-  const bool start_corked_;
-  bool corked_write_needed_;  // no lock needed since only accessed in
-                              // Write/WritesDone which cannot be concurrent
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpGenericRecvMessage,
-                            grpc::internal::CallOpClientRecvStatus>
-      finish_ops_;
-  grpc::internal::CallbackWithSuccessTag finish_tag_;
-  grpc::Status finish_status_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpClientSendClose>
-      write_ops_;
-  grpc::internal::CallbackWithSuccessTag write_tag_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpClientSendClose>
-      writes_done_ops_;
-  grpc::internal::CallbackWithSuccessTag writes_done_tag_;
-
-  struct StartCallBacklog {
-    bool write_ops = false;
-    bool writes_done_ops = false;
-  };
-  StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
-
-  // Minimum of 3 callbacks to pre-register for start ops, StartCall, and finish
-  std::atomic<intptr_t> callbacks_outstanding_{3};
-  std::atomic_bool started_{false};
-  grpc::internal::Mutex start_mu_;
-};
-
-template <class Request>
-class ClientCallbackWriterFactory {
- public:
-  template <class Response>
-  static void Create(grpc::ChannelInterface* channel,
-                     const grpc::internal::RpcMethod& method,
-                     grpc::ClientContext* context, Response* response,
-                     ClientWriteReactor<Request>* reactor) {
-    grpc::internal::Call call =
-        channel->CreateCall(method, context, channel->CallbackCQ());
-
-    grpc::g_core_codegen_interface->grpc_call_ref(call.call());
-    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call.call(), sizeof(ClientCallbackWriterImpl<Request>)))
-        ClientCallbackWriterImpl<Request>(call, context, response, reactor);
-  }
-};
-
-class ClientCallbackUnaryImpl final : public ClientCallbackUnary {
- public:
-  // always allocated against a call arena, no memory free required
-  static void operator delete(void* /*ptr*/, std::size_t size) {
-    GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackUnaryImpl));
-  }
-
-  // This operator should never be called as the memory should be freed as part
-  // of the arena destruction. It only exists to provide a matching operator
-  // delete to the operator new so that some compilers will not complain (see
-  // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
-  // there are no tests catching the compiler warning.
-  static void operator delete(void*, void*) { GPR_CODEGEN_ASSERT(false); }
-
-  void StartCall() override {
-    // This call initiates two batches, each with a callback
-    // 1. Send initial metadata + write + writes done + recv initial metadata
-    // 2. Read message, recv trailing metadata
-
-    start_tag_.Set(
-        call_.call(),
-        [this](bool ok) {
-          reactor_->OnReadInitialMetadataDone(
-              ok && !reactor_->InternalTrailersOnly(call_.call()));
-          MaybeFinish();
-        },
-        &start_ops_, /*can_inline=*/false);
-    start_ops_.SendInitialMetadata(&context_->send_initial_metadata_,
-                                   context_->initial_metadata_flags());
-    start_ops_.RecvInitialMetadata(context_);
-    start_ops_.set_core_cq_tag(&start_tag_);
-    call_.PerformOps(&start_ops_);
-
-    finish_tag_.Set(
-        call_.call(), [this](bool /*ok*/) { MaybeFinish(); }, &finish_ops_,
-        /*can_inline=*/false);
-    finish_ops_.ClientRecvStatus(context_, &finish_status_);
-    finish_ops_.set_core_cq_tag(&finish_tag_);
-    call_.PerformOps(&finish_ops_);
-  }
-
- private:
-  friend class ClientCallbackUnaryFactory;
-
-  template <class Request, class Response>
-  ClientCallbackUnaryImpl(grpc::internal::Call call,
-                          grpc::ClientContext* context, Request* request,
-                          Response* response, ClientUnaryReactor* reactor)
-      : context_(context), call_(call), reactor_(reactor) {
-    this->BindReactor(reactor);
-    // TODO(vjpai): don't assert
-    GPR_CODEGEN_ASSERT(start_ops_.SendMessagePtr(request).ok());
-    start_ops_.ClientSendClose();
-    finish_ops_.RecvMessage(response);
-    finish_ops_.AllowNoMessage();
-  }
-
-  // In the unary case, MaybeFinish is only ever invoked from a
-  // library-initiated reaction, so it will just directly call OnDone if this is
-  // the last reaction for this RPC.
-  void MaybeFinish() {
-    if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(
-                         1, std::memory_order_acq_rel) == 1)) {
-      grpc::Status s = std::move(finish_status_);
-      auto* reactor = reactor_;
-      auto* call = call_.call();
-      this->~ClientCallbackUnaryImpl();
-      grpc::g_core_codegen_interface->grpc_call_unref(call);
-      reactor->OnDone(s);
+    // Define function out-of-line from class to avoid forward declaration issue
+    inline void ClientCallbackUnary::BindReactor(ClientUnaryReactor* reactor)
+    {
+        reactor->BindCall(this);
     }
-  }
-
-  grpc::ClientContext* const context_;
-  grpc::internal::Call call_;
-  ClientUnaryReactor* const reactor_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpClientSendClose,
-                            grpc::internal::CallOpRecvInitialMetadata>
-      start_ops_;
-  grpc::internal::CallbackWithSuccessTag start_tag_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpGenericRecvMessage,
-                            grpc::internal::CallOpClientRecvStatus>
-      finish_ops_;
-  grpc::internal::CallbackWithSuccessTag finish_tag_;
-  grpc::Status finish_status_;
-
-  // This call will have 2 callbacks: start and finish
-  std::atomic<intptr_t> callbacks_outstanding_{2};
-};
-
-class ClientCallbackUnaryFactory {
- public:
-  template <class Request, class Response, class BaseRequest = Request,
-            class BaseResponse = Response>
-  static void Create(grpc::ChannelInterface* channel,
-                     const grpc::internal::RpcMethod& method,
-                     grpc::ClientContext* context, const Request* request,
-                     Response* response, ClientUnaryReactor* reactor) {
-    grpc::internal::Call call =
-        channel->CreateCall(method, context, channel->CallbackCQ());
-
-    grpc::g_core_codegen_interface->grpc_call_ref(call.call());
-
-    new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call.call(), sizeof(ClientCallbackUnaryImpl)))
-        ClientCallbackUnaryImpl(call, context,
-                                static_cast<const BaseRequest*>(request),
-                                static_cast<BaseResponse*>(response), reactor);
-  }
-};
-
-}  // namespace internal
+
+    namespace internal
+    {
+
+        // Forward declare factory classes for friendship
+        template<class Request, class Response>
+        class ClientCallbackReaderWriterFactory;
+        template<class Response>
+        class ClientCallbackReaderFactory;
+        template<class Request>
+        class ClientCallbackWriterFactory;
+
+        template<class Request, class Response>
+        class ClientCallbackReaderWriterImpl : public ClientCallbackReaderWriter<Request, Response>
+        {
+        public:
+            // always allocated against a call arena, no memory free required
+            static void operator delete(void* /*ptr*/, std::size_t size)
+            {
+                GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackReaderWriterImpl));
+            }
+
+            // This operator should never be called as the memory should be freed as part
+            // of the arena destruction. It only exists to provide a matching operator
+            // delete to the operator new so that some compilers will not complain (see
+            // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+            // there are no tests catching the compiler warning.
+            static void operator delete(void*, void*)
+            {
+                GPR_CODEGEN_ASSERT(false);
+            }
+
+            void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_) override
+            {
+                // This call initiates two batches, plus any backlog, each with a callback
+                // 1. Send initial metadata (unless corked) + recv initial metadata
+                // 2. Any read backlog
+                // 3. Any write backlog
+                // 4. Recv trailing metadata (unless corked)
+                if (!start_corked_)
+                {
+                    start_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                }
+
+                call_.PerformOps(&start_ops_);
+
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+
+                    if (backlog_.read_ops)
+                    {
+                        call_.PerformOps(&read_ops_);
+                    }
+                    if (backlog_.write_ops)
+                    {
+                        call_.PerformOps(&write_ops_);
+                    }
+                    if (backlog_.writes_done_ops)
+                    {
+                        call_.PerformOps(&writes_done_ops_);
+                    }
+                    call_.PerformOps(&finish_ops_);
+                    // The last thing in this critical section is to set started_ so that it
+                    // can be used lock-free as well.
+                    started_.store(true, std::memory_order_release);
+                }
+                // MaybeFinish outside the lock to make sure that destruction of this object
+                // doesn't take place while holding the lock (which would cause the lock to
+                // be released after destruction)
+                this->MaybeFinish(/*from_reaction=*/false);
+            }
+
+            void Read(Response* msg) override
+            {
+                read_ops_.RecvMessage(msg);
+                callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+                if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire)))
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+                    if (GPR_LIKELY(!started_.load(std::memory_order_relaxed)))
+                    {
+                        backlog_.read_ops = true;
+                        return;
+                    }
+                }
+                call_.PerformOps(&read_ops_);
+            }
+
+            void Write(const Request* msg, grpc::WriteOptions options)
+                ABSL_LOCKS_EXCLUDED(start_mu_) override
+            {
+                if (options.is_last_message())
+                {
+                    options.set_buffer_hint();
+                    write_ops_.ClientSendClose();
+                }
+                // TODO(vjpai): don't assert
+                GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(msg, options).ok());
+                callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+                if (GPR_UNLIKELY(corked_write_needed_))
+                {
+                    write_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                    corked_write_needed_ = false;
+                }
+
+                if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire)))
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+                    if (GPR_LIKELY(!started_.load(std::memory_order_relaxed)))
+                    {
+                        backlog_.write_ops = true;
+                        return;
+                    }
+                }
+                call_.PerformOps(&write_ops_);
+            }
+            void WritesDone() ABSL_LOCKS_EXCLUDED(start_mu_) override
+            {
+                writes_done_ops_.ClientSendClose();
+                writes_done_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnWritesDoneDone(ok);
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &writes_done_ops_,
+                    /*can_inline=*/false
+                );
+                writes_done_ops_.set_core_cq_tag(&writes_done_tag_);
+                callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+                if (GPR_UNLIKELY(corked_write_needed_))
+                {
+                    writes_done_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                    corked_write_needed_ = false;
+                }
+                if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire)))
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+                    if (GPR_LIKELY(!started_.load(std::memory_order_relaxed)))
+                    {
+                        backlog_.writes_done_ops = true;
+                        return;
+                    }
+                }
+                call_.PerformOps(&writes_done_ops_);
+            }
+
+            void AddHold(int holds) override
+            {
+                callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
+            }
+            void RemoveHold() override
+            {
+                MaybeFinish(/*from_reaction=*/false);
+            }
+
+        private:
+            friend class ClientCallbackReaderWriterFactory<Request, Response>;
+
+            ClientCallbackReaderWriterImpl(grpc::internal::Call call, grpc::ClientContext* context, ClientBidiReactor<Request, Response>* reactor) :
+                context_(context),
+                call_(call),
+                reactor_(reactor),
+                start_corked_(context_->initial_metadata_corked_),
+                corked_write_needed_(start_corked_)
+            {
+                this->BindReactor(reactor);
+
+                // Set up the unchanging parts of the start, read, and write tags and ops.
+                start_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnReadInitialMetadataDone(
+                            ok && !reactor_->InternalTrailersOnly(call_.call())
+                        );
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &start_ops_,
+                    /*can_inline=*/false
+                );
+                start_ops_.RecvInitialMetadata(context_);
+                start_ops_.set_core_cq_tag(&start_tag_);
+
+                write_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnWriteDone(ok);
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &write_ops_,
+                    /*can_inline=*/false
+                );
+                write_ops_.set_core_cq_tag(&write_tag_);
+
+                read_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnReadDone(ok);
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &read_ops_,
+                    /*can_inline=*/false
+                );
+                read_ops_.set_core_cq_tag(&read_tag_);
+
+                // Also set up the Finish tag and op set.
+                finish_tag_.Set(
+                    call_.call(),
+                    [this](bool /*ok*/)
+                    { MaybeFinish(/*from_reaction=*/true); },
+                    &finish_ops_,
+                    /*can_inline=*/false
+                );
+                finish_ops_.ClientRecvStatus(context_, &finish_status_);
+                finish_ops_.set_core_cq_tag(&finish_tag_);
+            }
+
+            // MaybeFinish can be called from reactions or from user-initiated operations
+            // like StartCall or RemoveHold. If this is the last operation or hold on this
+            // object, it will invoke the OnDone reaction. If MaybeFinish was called from
+            // a reaction, it can call OnDone directly. If not, it would need to schedule
+            // OnDone onto an executor thread to avoid the possibility of deadlocking with
+            // any locks in the user code that invoked it.
+            void MaybeFinish(bool from_reaction)
+            {
+                if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel) == 1))
+                {
+                    grpc::Status s = std::move(finish_status_);
+                    auto* reactor = reactor_;
+                    auto* call = call_.call();
+                    this->~ClientCallbackReaderWriterImpl();
+                    grpc::g_core_codegen_interface->grpc_call_unref(call);
+                    if (GPR_LIKELY(from_reaction))
+                    {
+                        reactor->OnDone(s);
+                    }
+                    else
+                    {
+                        reactor->InternalScheduleOnDone(std::move(s));
+                    }
+                }
+            }
+
+            grpc::ClientContext* const context_;
+            grpc::internal::Call call_;
+            ClientBidiReactor<Request, Response>* const reactor_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpRecvInitialMetadata>
+                start_ops_;
+            grpc::internal::CallbackWithSuccessTag start_tag_;
+            const bool start_corked_;
+            bool corked_write_needed_;  // no lock needed since only accessed in
+                                        // Write/WritesDone which cannot be concurrent
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpClientRecvStatus> finish_ops_;
+            grpc::internal::CallbackWithSuccessTag finish_tag_;
+            grpc::Status finish_status_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose>
+                write_ops_;
+            grpc::internal::CallbackWithSuccessTag write_tag_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpClientSendClose>
+                writes_done_ops_;
+            grpc::internal::CallbackWithSuccessTag writes_done_tag_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<Response>>
+                read_ops_;
+            grpc::internal::CallbackWithSuccessTag read_tag_;
+
+            struct StartCallBacklog
+            {
+                bool write_ops = false;
+                bool writes_done_ops = false;
+                bool read_ops = false;
+            };
+            StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
+
+            // Minimum of 3 callbacks to pre-register for start ops, StartCall, and finish
+            std::atomic<intptr_t> callbacks_outstanding_{3};
+            std::atomic_bool started_{false};
+            grpc::internal::Mutex start_mu_;
+        };
+
+        template<class Request, class Response>
+        class ClientCallbackReaderWriterFactory
+        {
+        public:
+            static void Create(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, ClientBidiReactor<Request, Response>* reactor)
+            {
+                grpc::internal::Call call =
+                    channel->CreateCall(method, context, channel->CallbackCQ());
+
+                grpc::g_core_codegen_interface->grpc_call_ref(call.call());
+                new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call.call(), sizeof(ClientCallbackReaderWriterImpl<Request, Response>)
+                ))
+                    ClientCallbackReaderWriterImpl<Request, Response>(call, context, reactor);
+            }
+        };
+
+        template<class Response>
+        class ClientCallbackReaderImpl : public ClientCallbackReader<Response>
+        {
+        public:
+            // always allocated against a call arena, no memory free required
+            static void operator delete(void* /*ptr*/, std::size_t size)
+            {
+                GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackReaderImpl));
+            }
+
+            // This operator should never be called as the memory should be freed as part
+            // of the arena destruction. It only exists to provide a matching operator
+            // delete to the operator new so that some compilers will not complain (see
+            // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+            // there are no tests catching the compiler warning.
+            static void operator delete(void*, void*)
+            {
+                GPR_CODEGEN_ASSERT(false);
+            }
+
+            void StartCall() override
+            {
+                // This call initiates two batches, plus any backlog, each with a callback
+                // 1. Send initial metadata (unless corked) + recv initial metadata
+                // 2. Any backlog
+                // 3. Recv trailing metadata
+
+                start_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnReadInitialMetadataDone(
+                            ok && !reactor_->InternalTrailersOnly(call_.call())
+                        );
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &start_ops_,
+                    /*can_inline=*/false
+                );
+                start_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                start_ops_.RecvInitialMetadata(context_);
+                start_ops_.set_core_cq_tag(&start_tag_);
+                call_.PerformOps(&start_ops_);
+
+                // Also set up the read tag so it doesn't have to be set up each time
+                read_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnReadDone(ok);
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &read_ops_,
+                    /*can_inline=*/false
+                );
+                read_ops_.set_core_cq_tag(&read_tag_);
+
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+                    if (backlog_.read_ops)
+                    {
+                        call_.PerformOps(&read_ops_);
+                    }
+                    started_.store(true, std::memory_order_release);
+                }
+
+                finish_tag_.Set(
+                    call_.call(),
+                    [this](bool /*ok*/)
+                    { MaybeFinish(/*from_reaction=*/true); },
+                    &finish_ops_,
+                    /*can_inline=*/false
+                );
+                finish_ops_.ClientRecvStatus(context_, &finish_status_);
+                finish_ops_.set_core_cq_tag(&finish_tag_);
+                call_.PerformOps(&finish_ops_);
+            }
+
+            void Read(Response* msg) override
+            {
+                read_ops_.RecvMessage(msg);
+                callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+                if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire)))
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+                    if (GPR_LIKELY(!started_.load(std::memory_order_relaxed)))
+                    {
+                        backlog_.read_ops = true;
+                        return;
+                    }
+                }
+                call_.PerformOps(&read_ops_);
+            }
+
+            void AddHold(int holds) override
+            {
+                callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
+            }
+            void RemoveHold() override
+            {
+                MaybeFinish(/*from_reaction=*/false);
+            }
+
+        private:
+            friend class ClientCallbackReaderFactory<Response>;
+
+            template<class Request>
+            ClientCallbackReaderImpl(grpc::internal::Call call, grpc::ClientContext* context, Request* request, ClientReadReactor<Response>* reactor) :
+                context_(context),
+                call_(call),
+                reactor_(reactor)
+            {
+                this->BindReactor(reactor);
+                // TODO(vjpai): don't assert
+                GPR_CODEGEN_ASSERT(start_ops_.SendMessagePtr(request).ok());
+                start_ops_.ClientSendClose();
+            }
+
+            // MaybeFinish behaves as in ClientCallbackReaderWriterImpl.
+            void MaybeFinish(bool from_reaction)
+            {
+                if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel) == 1))
+                {
+                    grpc::Status s = std::move(finish_status_);
+                    auto* reactor = reactor_;
+                    auto* call = call_.call();
+                    this->~ClientCallbackReaderImpl();
+                    grpc::g_core_codegen_interface->grpc_call_unref(call);
+                    if (GPR_LIKELY(from_reaction))
+                    {
+                        reactor->OnDone(s);
+                    }
+                    else
+                    {
+                        reactor->InternalScheduleOnDone(std::move(s));
+                    }
+                }
+            }
+
+            grpc::ClientContext* const context_;
+            grpc::internal::Call call_;
+            ClientReadReactor<Response>* const reactor_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose, grpc::internal::CallOpRecvInitialMetadata>
+                start_ops_;
+            grpc::internal::CallbackWithSuccessTag start_tag_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpClientRecvStatus> finish_ops_;
+            grpc::internal::CallbackWithSuccessTag finish_tag_;
+            grpc::Status finish_status_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<Response>>
+                read_ops_;
+            grpc::internal::CallbackWithSuccessTag read_tag_;
+
+            struct StartCallBacklog
+            {
+                bool read_ops = false;
+            };
+            StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
+
+            // Minimum of 2 callbacks to pre-register for start and finish
+            std::atomic<intptr_t> callbacks_outstanding_{2};
+            std::atomic_bool started_{false};
+            grpc::internal::Mutex start_mu_;
+        };
+
+        template<class Response>
+        class ClientCallbackReaderFactory
+        {
+        public:
+            template<class Request>
+            static void Create(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const Request* request, ClientReadReactor<Response>* reactor)
+            {
+                grpc::internal::Call call =
+                    channel->CreateCall(method, context, channel->CallbackCQ());
+
+                grpc::g_core_codegen_interface->grpc_call_ref(call.call());
+                new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call.call(), sizeof(ClientCallbackReaderImpl<Response>)
+                ))
+                    ClientCallbackReaderImpl<Response>(call, context, request, reactor);
+            }
+        };
+
+        template<class Request>
+        class ClientCallbackWriterImpl : public ClientCallbackWriter<Request>
+        {
+        public:
+            // always allocated against a call arena, no memory free required
+            static void operator delete(void* /*ptr*/, std::size_t size)
+            {
+                GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackWriterImpl));
+            }
+
+            // This operator should never be called as the memory should be freed as part
+            // of the arena destruction. It only exists to provide a matching operator
+            // delete to the operator new so that some compilers will not complain (see
+            // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+            // there are no tests catching the compiler warning.
+            static void operator delete(void*, void*)
+            {
+                GPR_CODEGEN_ASSERT(false);
+            }
+
+            void StartCall() ABSL_LOCKS_EXCLUDED(start_mu_) override
+            {
+                // This call initiates two batches, plus any backlog, each with a callback
+                // 1. Send initial metadata (unless corked) + recv initial metadata
+                // 2. Any backlog
+                // 3. Recv trailing metadata
+
+                if (!start_corked_)
+                {
+                    start_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                }
+                call_.PerformOps(&start_ops_);
+
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+
+                    if (backlog_.write_ops)
+                    {
+                        call_.PerformOps(&write_ops_);
+                    }
+                    if (backlog_.writes_done_ops)
+                    {
+                        call_.PerformOps(&writes_done_ops_);
+                    }
+                    call_.PerformOps(&finish_ops_);
+                    // The last thing in this critical section is to set started_ so that it
+                    // can be used lock-free as well.
+                    started_.store(true, std::memory_order_release);
+                }
+                // MaybeFinish outside the lock to make sure that destruction of this object
+                // doesn't take place while holding the lock (which would cause the lock to
+                // be released after destruction)
+                this->MaybeFinish(/*from_reaction=*/false);
+            }
+
+            void Write(const Request* msg, grpc::WriteOptions options)
+                ABSL_LOCKS_EXCLUDED(start_mu_) override
+            {
+                if (GPR_UNLIKELY(options.is_last_message()))
+                {
+                    options.set_buffer_hint();
+                    write_ops_.ClientSendClose();
+                }
+                // TODO(vjpai): don't assert
+                GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(msg, options).ok());
+                callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+
+                if (GPR_UNLIKELY(corked_write_needed_))
+                {
+                    write_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                    corked_write_needed_ = false;
+                }
+
+                if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire)))
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+                    if (GPR_LIKELY(!started_.load(std::memory_order_relaxed)))
+                    {
+                        backlog_.write_ops = true;
+                        return;
+                    }
+                }
+                call_.PerformOps(&write_ops_);
+            }
+
+            void WritesDone() ABSL_LOCKS_EXCLUDED(start_mu_) override
+            {
+                writes_done_ops_.ClientSendClose();
+                writes_done_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnWritesDoneDone(ok);
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &writes_done_ops_,
+                    /*can_inline=*/false
+                );
+                writes_done_ops_.set_core_cq_tag(&writes_done_tag_);
+                callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+
+                if (GPR_UNLIKELY(corked_write_needed_))
+                {
+                    writes_done_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                    corked_write_needed_ = false;
+                }
+
+                if (GPR_UNLIKELY(!started_.load(std::memory_order_acquire)))
+                {
+                    grpc::internal::MutexLock lock(&start_mu_);
+                    if (GPR_LIKELY(!started_.load(std::memory_order_relaxed)))
+                    {
+                        backlog_.writes_done_ops = true;
+                        return;
+                    }
+                }
+                call_.PerformOps(&writes_done_ops_);
+            }
+
+            void AddHold(int holds) override
+            {
+                callbacks_outstanding_.fetch_add(holds, std::memory_order_relaxed);
+            }
+            void RemoveHold() override
+            {
+                MaybeFinish(/*from_reaction=*/false);
+            }
+
+        private:
+            friend class ClientCallbackWriterFactory<Request>;
+
+            template<class Response>
+            ClientCallbackWriterImpl(grpc::internal::Call call, grpc::ClientContext* context, Response* response, ClientWriteReactor<Request>* reactor) :
+                context_(context),
+                call_(call),
+                reactor_(reactor),
+                start_corked_(context_->initial_metadata_corked_),
+                corked_write_needed_(start_corked_)
+            {
+                this->BindReactor(reactor);
+
+                // Set up the unchanging parts of the start and write tags and ops.
+                start_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnReadInitialMetadataDone(
+                            ok && !reactor_->InternalTrailersOnly(call_.call())
+                        );
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &start_ops_,
+                    /*can_inline=*/false
+                );
+                start_ops_.RecvInitialMetadata(context_);
+                start_ops_.set_core_cq_tag(&start_tag_);
+
+                write_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnWriteDone(ok);
+                        MaybeFinish(/*from_reaction=*/true);
+                    },
+                    &write_ops_,
+                    /*can_inline=*/false
+                );
+                write_ops_.set_core_cq_tag(&write_tag_);
+
+                // Also set up the Finish tag and op set.
+                finish_ops_.RecvMessage(response);
+                finish_ops_.AllowNoMessage();
+                finish_tag_.Set(
+                    call_.call(),
+                    [this](bool /*ok*/)
+                    { MaybeFinish(/*from_reaction=*/true); },
+                    &finish_ops_,
+                    /*can_inline=*/false
+                );
+                finish_ops_.ClientRecvStatus(context_, &finish_status_);
+                finish_ops_.set_core_cq_tag(&finish_tag_);
+            }
+
+            // MaybeFinish behaves as in ClientCallbackReaderWriterImpl.
+            void MaybeFinish(bool from_reaction)
+            {
+                if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel) == 1))
+                {
+                    grpc::Status s = std::move(finish_status_);
+                    auto* reactor = reactor_;
+                    auto* call = call_.call();
+                    this->~ClientCallbackWriterImpl();
+                    grpc::g_core_codegen_interface->grpc_call_unref(call);
+                    if (GPR_LIKELY(from_reaction))
+                    {
+                        reactor->OnDone(s);
+                    }
+                    else
+                    {
+                        reactor->InternalScheduleOnDone(std::move(s));
+                    }
+                }
+            }
+
+            grpc::ClientContext* const context_;
+            grpc::internal::Call call_;
+            ClientWriteReactor<Request>* const reactor_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpRecvInitialMetadata>
+                start_ops_;
+            grpc::internal::CallbackWithSuccessTag start_tag_;
+            const bool start_corked_;
+            bool corked_write_needed_;  // no lock needed since only accessed in
+                                        // Write/WritesDone which cannot be concurrent
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpGenericRecvMessage, grpc::internal::CallOpClientRecvStatus>
+                finish_ops_;
+            grpc::internal::CallbackWithSuccessTag finish_tag_;
+            grpc::Status finish_status_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose>
+                write_ops_;
+            grpc::internal::CallbackWithSuccessTag write_tag_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpClientSendClose>
+                writes_done_ops_;
+            grpc::internal::CallbackWithSuccessTag writes_done_tag_;
+
+            struct StartCallBacklog
+            {
+                bool write_ops = false;
+                bool writes_done_ops = false;
+            };
+            StartCallBacklog backlog_ ABSL_GUARDED_BY(start_mu_);
+
+            // Minimum of 3 callbacks to pre-register for start ops, StartCall, and finish
+            std::atomic<intptr_t> callbacks_outstanding_{3};
+            std::atomic_bool started_{false};
+            grpc::internal::Mutex start_mu_;
+        };
+
+        template<class Request>
+        class ClientCallbackWriterFactory
+        {
+        public:
+            template<class Response>
+            static void Create(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, Response* response, ClientWriteReactor<Request>* reactor)
+            {
+                grpc::internal::Call call =
+                    channel->CreateCall(method, context, channel->CallbackCQ());
+
+                grpc::g_core_codegen_interface->grpc_call_ref(call.call());
+                new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call.call(), sizeof(ClientCallbackWriterImpl<Request>)
+                ))
+                    ClientCallbackWriterImpl<Request>(call, context, response, reactor);
+            }
+        };
+
+        class ClientCallbackUnaryImpl final : public ClientCallbackUnary
+        {
+        public:
+            // always allocated against a call arena, no memory free required
+            static void operator delete(void* /*ptr*/, std::size_t size)
+            {
+                GPR_CODEGEN_ASSERT(size == sizeof(ClientCallbackUnaryImpl));
+            }
+
+            // This operator should never be called as the memory should be freed as part
+            // of the arena destruction. It only exists to provide a matching operator
+            // delete to the operator new so that some compilers will not complain (see
+            // https://github.com/grpc/grpc/issues/11301) Note at the time of adding this
+            // there are no tests catching the compiler warning.
+            static void operator delete(void*, void*)
+            {
+                GPR_CODEGEN_ASSERT(false);
+            }
+
+            void StartCall() override
+            {
+                // This call initiates two batches, each with a callback
+                // 1. Send initial metadata + write + writes done + recv initial metadata
+                // 2. Read message, recv trailing metadata
+
+                start_tag_.Set(
+                    call_.call(),
+                    [this](bool ok)
+                    {
+                        reactor_->OnReadInitialMetadataDone(
+                            ok && !reactor_->InternalTrailersOnly(call_.call())
+                        );
+                        MaybeFinish();
+                    },
+                    &start_ops_,
+                    /*can_inline=*/false
+                );
+                start_ops_.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                start_ops_.RecvInitialMetadata(context_);
+                start_ops_.set_core_cq_tag(&start_tag_);
+                call_.PerformOps(&start_ops_);
+
+                finish_tag_.Set(
+                    call_.call(), [this](bool /*ok*/)
+                    { MaybeFinish(); },
+                    &finish_ops_,
+                    /*can_inline=*/false
+                );
+                finish_ops_.ClientRecvStatus(context_, &finish_status_);
+                finish_ops_.set_core_cq_tag(&finish_tag_);
+                call_.PerformOps(&finish_ops_);
+            }
+
+        private:
+            friend class ClientCallbackUnaryFactory;
+
+            template<class Request, class Response>
+            ClientCallbackUnaryImpl(grpc::internal::Call call, grpc::ClientContext* context, Request* request, Response* response, ClientUnaryReactor* reactor) :
+                context_(context),
+                call_(call),
+                reactor_(reactor)
+            {
+                this->BindReactor(reactor);
+                // TODO(vjpai): don't assert
+                GPR_CODEGEN_ASSERT(start_ops_.SendMessagePtr(request).ok());
+                start_ops_.ClientSendClose();
+                finish_ops_.RecvMessage(response);
+                finish_ops_.AllowNoMessage();
+            }
+
+            // In the unary case, MaybeFinish is only ever invoked from a
+            // library-initiated reaction, so it will just directly call OnDone if this is
+            // the last reaction for this RPC.
+            void MaybeFinish()
+            {
+                if (GPR_UNLIKELY(callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel) == 1))
+                {
+                    grpc::Status s = std::move(finish_status_);
+                    auto* reactor = reactor_;
+                    auto* call = call_.call();
+                    this->~ClientCallbackUnaryImpl();
+                    grpc::g_core_codegen_interface->grpc_call_unref(call);
+                    reactor->OnDone(s);
+                }
+            }
+
+            grpc::ClientContext* const context_;
+            grpc::internal::Call call_;
+            ClientUnaryReactor* const reactor_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose, grpc::internal::CallOpRecvInitialMetadata>
+                start_ops_;
+            grpc::internal::CallbackWithSuccessTag start_tag_;
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpGenericRecvMessage, grpc::internal::CallOpClientRecvStatus>
+                finish_ops_;
+            grpc::internal::CallbackWithSuccessTag finish_tag_;
+            grpc::Status finish_status_;
+
+            // This call will have 2 callbacks: start and finish
+            std::atomic<intptr_t> callbacks_outstanding_{2};
+        };
+
+        class ClientCallbackUnaryFactory
+        {
+        public:
+            template<class Request, class Response, class BaseRequest = Request, class BaseResponse = Response>
+            static void Create(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const Request* request, Response* response, ClientUnaryReactor* reactor)
+            {
+                grpc::internal::Call call =
+                    channel->CreateCall(method, context, channel->CallbackCQ());
+
+                grpc::g_core_codegen_interface->grpc_call_ref(call.call());
+
+                new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call.call(), sizeof(ClientCallbackUnaryImpl)
+                ))
+                    ClientCallbackUnaryImpl(call, context, static_cast<const BaseRequest*>(request), static_cast<BaseResponse*>(response), reactor);
+            }
+        };
+
+    }  // namespace internal
 }  // namespace grpc
 #endif  // GRPCPP_IMPL_CODEGEN_CLIENT_CALLBACK_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_context.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_context.h
index 172546c..bb866d1 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_context.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_context.h
@@ -58,460 +58,520 @@
 struct census_context;
 struct grpc_call;
 
-namespace grpc {
-class ServerContext;
-class ServerContextBase;
-class CallbackServerContext;
-
-namespace internal {
-template <class InputMessage, class OutputMessage>
-class CallbackUnaryCallImpl;
-template <class Request, class Response>
-class ClientCallbackReaderWriterImpl;
-template <class Response>
-class ClientCallbackReaderImpl;
-template <class Request>
-class ClientCallbackWriterImpl;
-class ClientCallbackUnaryImpl;
-class ClientContextAccessor;
-class ClientAsyncResponseReaderHelper;
-}  // namespace internal
-
-template <class R>
-class ClientReader;
-template <class W>
-class ClientWriter;
-template <class W, class R>
-class ClientReaderWriter;
-template <class R>
-class ClientAsyncReader;
-template <class W>
-class ClientAsyncWriter;
-template <class W, class R>
-class ClientAsyncReaderWriter;
-template <class R>
-class ClientAsyncResponseReader;
-
-namespace testing {
-class InteropClientContextInspector;
-class ClientContextTestPeer;
-}  // namespace testing
-
-namespace internal {
-class RpcMethod;
-template <class InputMessage, class OutputMessage>
-class BlockingUnaryCallImpl;
-class CallOpClientRecvStatus;
-class CallOpRecvInitialMetadata;
-class ServerContextImpl;
-template <class InputMessage, class OutputMessage>
-class CallbackUnaryCallImpl;
-template <class Request, class Response>
-class ClientCallbackReaderWriterImpl;
-template <class Response>
-class ClientCallbackReaderImpl;
-template <class Request>
-class ClientCallbackWriterImpl;
-class ClientCallbackUnaryImpl;
-class ClientContextAccessor;
-}  // namespace internal
-
-class CallCredentials;
-class Channel;
-class ChannelInterface;
-class CompletionQueue;
-
-/// Options for \a ClientContext::FromServerContext specifying which traits from
-/// the \a ServerContext to propagate (copy) from it into a new \a
-/// ClientContext.
-///
-/// \see ClientContext::FromServerContext
-class PropagationOptions {
- public:
-  PropagationOptions() : propagate_(GRPC_PROPAGATE_DEFAULTS) {}
-
-  PropagationOptions& enable_deadline_propagation() {
-    propagate_ |= GRPC_PROPAGATE_DEADLINE;
-    return *this;
-  }
-
-  PropagationOptions& disable_deadline_propagation() {
-    propagate_ &= ~GRPC_PROPAGATE_DEADLINE;
-    return *this;
-  }
-
-  PropagationOptions& enable_census_stats_propagation() {
-    propagate_ |= GRPC_PROPAGATE_CENSUS_STATS_CONTEXT;
-    return *this;
-  }
-
-  PropagationOptions& disable_census_stats_propagation() {
-    propagate_ &= ~GRPC_PROPAGATE_CENSUS_STATS_CONTEXT;
-    return *this;
-  }
-
-  PropagationOptions& enable_census_tracing_propagation() {
-    propagate_ |= GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT;
-    return *this;
-  }
-
-  PropagationOptions& disable_census_tracing_propagation() {
-    propagate_ &= ~GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT;
-    return *this;
-  }
-
-  PropagationOptions& enable_cancellation_propagation() {
-    propagate_ |= GRPC_PROPAGATE_CANCELLATION;
-    return *this;
-  }
-
-  PropagationOptions& disable_cancellation_propagation() {
-    propagate_ &= ~GRPC_PROPAGATE_CANCELLATION;
-    return *this;
-  }
-
-  uint32_t c_bitmask() const { return propagate_; }
-
- private:
-  uint32_t propagate_;
-};
-
-/// A ClientContext allows the person implementing a service client to:
-///
-/// - Add custom metadata key-value pairs that will propagated to the server
-///   side.
-/// - Control call settings such as compression and authentication.
-/// - Initial and trailing metadata coming from the server.
-/// - Get performance metrics (ie, census).
-///
-/// Context settings are only relevant to the call they are invoked with, that
-/// is to say, they aren't sticky. Some of these settings, such as the
-/// compression options, can be made persistent at channel construction time
-/// (see \a grpc::CreateCustomChannel).
-///
-/// \warning ClientContext instances should \em not be reused across rpcs.
-/// \warning The ClientContext instance used for creating an rpc must remain
-///          alive and valid for the lifetime of the rpc.
-class ClientContext {
- public:
-  ClientContext();
-  ~ClientContext();
-
-  /// Create a new \a ClientContext as a child of an incoming server call,
-  /// according to \a options (\see PropagationOptions).
-  ///
-  /// \param server_context The source server context to use as the basis for
-  /// constructing the client context.
-  /// \param options The options controlling what to copy from the \a
-  /// server_context.
-  ///
-  /// \return A newly constructed \a ClientContext instance based on \a
-  /// server_context, with traits propagated (copied) according to \a options.
-  static std::unique_ptr<ClientContext> FromServerContext(
-      const grpc::ServerContextBase& server_context,
-      PropagationOptions options = PropagationOptions());
-  static std::unique_ptr<ClientContext> FromCallbackServerContext(
-      const grpc::CallbackServerContext& server_context,
-      PropagationOptions options = PropagationOptions());
-
-  /// Add the (\a meta_key, \a meta_value) pair to the metadata associated with
-  /// a client call. These are made available at the server side by the \a
-  /// grpc::ServerContext::client_metadata() method.
-  ///
-  /// \warning This method should only be called before invoking the rpc.
-  ///
-  /// \param meta_key The metadata key. If \a meta_value is binary data, it must
-  /// end in "-bin".
-  /// \param meta_value The metadata value. If its value is binary, the key name
-  /// must end in "-bin".
-  ///
-  /// Metadata must conform to the following format:
-  /**
-  \verbatim
-  Custom-Metadata -> Binary-Header / ASCII-Header
-  Binary-Header -> {Header-Name "-bin" } {binary value}
-  ASCII-Header -> Header-Name ASCII-Value
-  Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
-  ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
-  Custom-Metadata -> Binary-Header / ASCII-Header
-  \endverbatim
-  **/
-  void AddMetadata(const std::string& meta_key, const std::string& meta_value);
-
-  /// Return a collection of initial metadata key-value pairs. Note that keys
-  /// may happen more than once (ie, a \a std::multimap is returned).
-  ///
-  /// \warning This method should only be called after initial metadata has been
-  /// received. For streaming calls, see \a
-  /// ClientReaderInterface::WaitForInitialMetadata().
-  ///
-  /// \return A multimap of initial metadata key-value pairs from the server.
-  const std::multimap<grpc::string_ref, grpc::string_ref>&
-  GetServerInitialMetadata() const {
-    GPR_CODEGEN_ASSERT(initial_metadata_received_);
-    return *recv_initial_metadata_.map();
-  }
-
-  /// Return a collection of trailing metadata key-value pairs. Note that keys
-  /// may happen more than once (ie, a \a std::multimap is returned).
-  ///
-  /// \warning This method is only callable once the stream has finished.
-  ///
-  /// \return A multimap of metadata trailing key-value pairs from the server.
-  const std::multimap<grpc::string_ref, grpc::string_ref>&
-  GetServerTrailingMetadata() const {
-    // TODO(yangg) check finished
-    return *trailing_metadata_.map();
-  }
-
-  /// Set the deadline for the client call.
-  ///
-  /// \warning This method should only be called before invoking the rpc.
-  ///
-  /// \param deadline the deadline for the client call. Units are determined by
-  /// the type used. The deadline is an absolute (not relative) time.
-  template <typename T>
-  void set_deadline(const T& deadline) {
-    grpc::TimePoint<T> deadline_tp(deadline);
-    deadline_ = deadline_tp.raw_time();
-  }
-
-  /// Trigger wait-for-ready or not on this request.
-  /// See https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md.
-  /// If set, if an RPC is made when a channel's connectivity state is
-  /// TRANSIENT_FAILURE or CONNECTING, the call will not "fail fast",
-  /// and the channel will wait until the channel is READY before making the
-  /// call.
-  void set_wait_for_ready(bool wait_for_ready) {
-    wait_for_ready_ = wait_for_ready;
-    wait_for_ready_explicitly_set_ = true;
-  }
-
-  /// DEPRECATED: Use set_wait_for_ready() instead.
-  void set_fail_fast(bool fail_fast) { set_wait_for_ready(!fail_fast); }
-
-  /// Return the deadline for the client call.
-  std::chrono::system_clock::time_point deadline() const {
-    return grpc::Timespec2Timepoint(deadline_);
-  }
-
-  /// Return a \a gpr_timespec representation of the client call's deadline.
-  gpr_timespec raw_deadline() const { return deadline_; }
-
-  /// Set the per call authority header (see
-  /// https://tools.ietf.org/html/rfc7540#section-8.1.2.3).
-  void set_authority(const std::string& authority) { authority_ = authority; }
-
-  /// Return the authentication context for the associated client call.
-  /// It is only valid to call this during the lifetime of the client call.
-  ///
-  /// \see grpc::AuthContext.
-  std::shared_ptr<const grpc::AuthContext> auth_context() const {
-    if (auth_context_ == nullptr) {
-      auth_context_ = grpc::CreateAuthContext(call_);
-    }
-    return auth_context_;
-  }
-
-  /// Set credentials for the client call.
-  ///
-  /// A credentials object encapsulates all the state needed by a client to
-  /// authenticate with a server and make various assertions, e.g., about the
-  /// client’s identity, role, or whether it is authorized to make a particular
-  /// call.
-  ///
-  /// It is legal to call this only before initial metadata is sent.
-  ///
-  /// \see  https://grpc.io/docs/guides/auth.html
-  void set_credentials(const std::shared_ptr<grpc::CallCredentials>& creds);
-
-  /// EXPERIMENTAL debugging API
-  ///
-  /// Returns the credentials for the client call. This should be used only in
-  /// tests and for diagnostic purposes, and should not be used by application
-  /// logic.
-  std::shared_ptr<grpc::CallCredentials> credentials() { return creds_; }
-
-  /// Return the compression algorithm the client call will request be used.
-  /// Note that the gRPC runtime may decide to ignore this request, for example,
-  /// due to resource constraints.
-  grpc_compression_algorithm compression_algorithm() const {
-    return compression_algorithm_;
-  }
-
-  /// Set \a algorithm to be the compression algorithm used for the client call.
-  ///
-  /// \param algorithm The compression algorithm used for the client call.
-  void set_compression_algorithm(grpc_compression_algorithm algorithm);
-
-  /// Flag whether the initial metadata should be \a corked
-  ///
-  /// If \a corked is true, then the initial metadata will be coalesced with the
-  /// write of first message in the stream. As a result, any tag set for the
-  /// initial metadata operation (starting a client-streaming or bidi-streaming
-  /// RPC) will not actually be sent to the completion queue or delivered
-  /// via Next.
-  ///
-  /// \param corked The flag indicating whether the initial metadata is to be
-  /// corked or not.
-  void set_initial_metadata_corked(bool corked) {
-    initial_metadata_corked_ = corked;
-  }
-
-  /// Return the peer uri in a string.
-  /// It is only valid to call this during the lifetime of the client call.
-  ///
-  /// \warning This value is never authenticated or subject to any security
-  /// related code. It must not be used for any authentication related
-  /// functionality. Instead, use auth_context.
-  ///
-  /// \return The call's peer URI.
-  std::string peer() const;
-
-  /// Sets the census context.
-  /// It is only valid to call this before the client call is created. A common
-  /// place of setting census context is from within the DefaultConstructor
-  /// method of GlobalCallbacks.
-  void set_census_context(struct census_context* ccp) { census_context_ = ccp; }
-
-  /// Returns the census context that has been set, or nullptr if not set.
-  struct census_context* census_context() const {
-    return census_context_;
-  }
-
-  /// Send a best-effort out-of-band cancel on the call associated with
-  /// this client context.  The call could be in any stage; e.g., if it is
-  /// already finished, it may still return success.
-  ///
-  /// There is no guarantee the call will be cancelled.
-  ///
-  /// Note that TryCancel() does not change any of the tags that are pending
-  /// on the completion queue. All pending tags will still be delivered
-  /// (though their ok result may reflect the effect of cancellation).
-  void TryCancel();
-
-  /// Global Callbacks
-  ///
-  /// Can be set exactly once per application to install hooks whenever
-  /// a client context is constructed and destructed.
-  class GlobalCallbacks {
-   public:
-    virtual ~GlobalCallbacks() {}
-    virtual void DefaultConstructor(ClientContext* context) = 0;
-    virtual void Destructor(ClientContext* context) = 0;
-  };
-  static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
-
-  /// Should be used for framework-level extensions only.
-  /// Applications never need to call this method.
-  grpc_call* c_call() { return call_; }
-
-  /// EXPERIMENTAL debugging API
-  ///
-  /// if status is not ok() for an RPC, this will return a detailed string
-  /// of the gRPC Core error that led to the failure. It should not be relied
-  /// upon for anything other than gaining more debug data in failure cases.
-  std::string debug_error_string() const { return debug_error_string_; }
-
- private:
-  // Disallow copy and assign.
-  ClientContext(const ClientContext&);
-  ClientContext& operator=(const ClientContext&);
-
-  friend class grpc::testing::InteropClientContextInspector;
-  friend class grpc::testing::ClientContextTestPeer;
-  friend class grpc::internal::CallOpClientRecvStatus;
-  friend class grpc::internal::CallOpRecvInitialMetadata;
-  friend class grpc::Channel;
-  template <class R>
-  friend class grpc::ClientReader;
-  template <class W>
-  friend class grpc::ClientWriter;
-  template <class W, class R>
-  friend class grpc::ClientReaderWriter;
-  template <class R>
-  friend class grpc::ClientAsyncReader;
-  template <class W>
-  friend class grpc::ClientAsyncWriter;
-  template <class W, class R>
-  friend class grpc::ClientAsyncReaderWriter;
-  template <class R>
-  friend class grpc::ClientAsyncResponseReader;
-  friend class grpc::internal::ClientAsyncResponseReaderHelper;
-  template <class InputMessage, class OutputMessage>
-  friend class grpc::internal::BlockingUnaryCallImpl;
-  template <class InputMessage, class OutputMessage>
-  friend class grpc::internal::CallbackUnaryCallImpl;
-  template <class Request, class Response>
-  friend class grpc::internal::ClientCallbackReaderWriterImpl;
-  template <class Response>
-  friend class grpc::internal::ClientCallbackReaderImpl;
-  template <class Request>
-  friend class grpc::internal::ClientCallbackWriterImpl;
-  friend class grpc::internal::ClientCallbackUnaryImpl;
-  friend class grpc::internal::ClientContextAccessor;
-
-  // Used by friend class CallOpClientRecvStatus
-  void set_debug_error_string(const std::string& debug_error_string) {
-    debug_error_string_ = debug_error_string;
-  }
-
-  grpc_call* call() const { return call_; }
-  void set_call(grpc_call* call, const std::shared_ptr<grpc::Channel>& channel);
-
-  grpc::experimental::ClientRpcInfo* set_client_rpc_info(
-      const char* method, const char* suffix_for_stats,
-      grpc::internal::RpcMethod::RpcType type, grpc::ChannelInterface* channel,
-      const std::vector<std::unique_ptr<
-          grpc::experimental::ClientInterceptorFactoryInterface>>& creators,
-      size_t interceptor_pos) {
-    rpc_info_ = grpc::experimental::ClientRpcInfo(this, type, method,
-                                                  suffix_for_stats, channel);
-    rpc_info_.RegisterInterceptors(creators, interceptor_pos);
-    return &rpc_info_;
-  }
-
-  uint32_t initial_metadata_flags() const {
-    return (wait_for_ready_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0) |
-           (wait_for_ready_explicitly_set_
-                ? GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET
-                : 0);
-  }
-
-  std::string authority() { return authority_; }
-
-  void SendCancelToInterceptors();
-
-  static std::unique_ptr<ClientContext> FromInternalServerContext(
-      const grpc::ServerContextBase& server_context,
-      PropagationOptions options);
-
-  bool initial_metadata_received_;
-  bool wait_for_ready_;
-  bool wait_for_ready_explicitly_set_;
-  std::shared_ptr<grpc::Channel> channel_;
-  grpc::internal::Mutex mu_;
-  grpc_call* call_;
-  bool call_canceled_;
-  gpr_timespec deadline_;
-  grpc::string authority_;
-  std::shared_ptr<grpc::CallCredentials> creds_;
-  mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
-  struct census_context* census_context_;
-  std::multimap<std::string, std::string> send_initial_metadata_;
-  mutable grpc::internal::MetadataMap recv_initial_metadata_;
-  mutable grpc::internal::MetadataMap trailing_metadata_;
-
-  grpc_call* propagate_from_call_;
-  PropagationOptions propagation_options_;
-
-  grpc_compression_algorithm compression_algorithm_;
-  bool initial_metadata_corked_;
-
-  std::string debug_error_string_;
-
-  grpc::experimental::ClientRpcInfo rpc_info_;
-};
+namespace grpc
+{
+    class ServerContext;
+    class ServerContextBase;
+    class CallbackServerContext;
+
+    namespace internal
+    {
+        template<class InputMessage, class OutputMessage>
+        class CallbackUnaryCallImpl;
+        template<class Request, class Response>
+        class ClientCallbackReaderWriterImpl;
+        template<class Response>
+        class ClientCallbackReaderImpl;
+        template<class Request>
+        class ClientCallbackWriterImpl;
+        class ClientCallbackUnaryImpl;
+        class ClientContextAccessor;
+        class ClientAsyncResponseReaderHelper;
+    }  // namespace internal
+
+    template<class R>
+    class ClientReader;
+    template<class W>
+    class ClientWriter;
+    template<class W, class R>
+    class ClientReaderWriter;
+    template<class R>
+    class ClientAsyncReader;
+    template<class W>
+    class ClientAsyncWriter;
+    template<class W, class R>
+    class ClientAsyncReaderWriter;
+    template<class R>
+    class ClientAsyncResponseReader;
+
+    namespace testing
+    {
+        class InteropClientContextInspector;
+        class ClientContextTestPeer;
+    }  // namespace testing
+
+    namespace internal
+    {
+        class RpcMethod;
+        template<class InputMessage, class OutputMessage>
+        class BlockingUnaryCallImpl;
+        class CallOpClientRecvStatus;
+        class CallOpRecvInitialMetadata;
+        class ServerContextImpl;
+        template<class InputMessage, class OutputMessage>
+        class CallbackUnaryCallImpl;
+        template<class Request, class Response>
+        class ClientCallbackReaderWriterImpl;
+        template<class Response>
+        class ClientCallbackReaderImpl;
+        template<class Request>
+        class ClientCallbackWriterImpl;
+        class ClientCallbackUnaryImpl;
+        class ClientContextAccessor;
+    }  // namespace internal
+
+    class CallCredentials;
+    class Channel;
+    class ChannelInterface;
+    class CompletionQueue;
+
+    /// Options for \a ClientContext::FromServerContext specifying which traits from
+    /// the \a ServerContext to propagate (copy) from it into a new \a
+    /// ClientContext.
+    ///
+    /// \see ClientContext::FromServerContext
+    class PropagationOptions
+    {
+    public:
+        PropagationOptions() :
+            propagate_(GRPC_PROPAGATE_DEFAULTS)
+        {
+        }
+
+        PropagationOptions& enable_deadline_propagation()
+        {
+            propagate_ |= GRPC_PROPAGATE_DEADLINE;
+            return *this;
+        }
+
+        PropagationOptions& disable_deadline_propagation()
+        {
+            propagate_ &= ~GRPC_PROPAGATE_DEADLINE;
+            return *this;
+        }
+
+        PropagationOptions& enable_census_stats_propagation()
+        {
+            propagate_ |= GRPC_PROPAGATE_CENSUS_STATS_CONTEXT;
+            return *this;
+        }
+
+        PropagationOptions& disable_census_stats_propagation()
+        {
+            propagate_ &= ~GRPC_PROPAGATE_CENSUS_STATS_CONTEXT;
+            return *this;
+        }
+
+        PropagationOptions& enable_census_tracing_propagation()
+        {
+            propagate_ |= GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT;
+            return *this;
+        }
+
+        PropagationOptions& disable_census_tracing_propagation()
+        {
+            propagate_ &= ~GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT;
+            return *this;
+        }
+
+        PropagationOptions& enable_cancellation_propagation()
+        {
+            propagate_ |= GRPC_PROPAGATE_CANCELLATION;
+            return *this;
+        }
+
+        PropagationOptions& disable_cancellation_propagation()
+        {
+            propagate_ &= ~GRPC_PROPAGATE_CANCELLATION;
+            return *this;
+        }
+
+        uint32_t c_bitmask() const
+        {
+            return propagate_;
+        }
+
+    private:
+        uint32_t propagate_;
+    };
+
+    /// A ClientContext allows the person implementing a service client to:
+    ///
+    /// - Add custom metadata key-value pairs that will propagated to the server
+    ///   side.
+    /// - Control call settings such as compression and authentication.
+    /// - Initial and trailing metadata coming from the server.
+    /// - Get performance metrics (ie, census).
+    ///
+    /// Context settings are only relevant to the call they are invoked with, that
+    /// is to say, they aren't sticky. Some of these settings, such as the
+    /// compression options, can be made persistent at channel construction time
+    /// (see \a grpc::CreateCustomChannel).
+    ///
+    /// \warning ClientContext instances should \em not be reused across rpcs.
+    /// \warning The ClientContext instance used for creating an rpc must remain
+    ///          alive and valid for the lifetime of the rpc.
+    class ClientContext
+    {
+    public:
+        ClientContext();
+        ~ClientContext();
+
+        /// Create a new \a ClientContext as a child of an incoming server call,
+        /// according to \a options (\see PropagationOptions).
+        ///
+        /// \param server_context The source server context to use as the basis for
+        /// constructing the client context.
+        /// \param options The options controlling what to copy from the \a
+        /// server_context.
+        ///
+        /// \return A newly constructed \a ClientContext instance based on \a
+        /// server_context, with traits propagated (copied) according to \a options.
+        static std::unique_ptr<ClientContext> FromServerContext(
+            const grpc::ServerContextBase& server_context,
+            PropagationOptions options = PropagationOptions()
+        );
+        static std::unique_ptr<ClientContext> FromCallbackServerContext(
+            const grpc::CallbackServerContext& server_context,
+            PropagationOptions options = PropagationOptions()
+        );
+
+        /// Add the (\a meta_key, \a meta_value) pair to the metadata associated with
+        /// a client call. These are made available at the server side by the \a
+        /// grpc::ServerContext::client_metadata() method.
+        ///
+        /// \warning This method should only be called before invoking the rpc.
+        ///
+        /// \param meta_key The metadata key. If \a meta_value is binary data, it must
+        /// end in "-bin".
+        /// \param meta_value The metadata value. If its value is binary, the key name
+        /// must end in "-bin".
+        ///
+        /// Metadata must conform to the following format:
+        /**
+        \verbatim
+        Custom-Metadata -> Binary-Header / ASCII-Header
+        Binary-Header -> {Header-Name "-bin" } {binary value}
+        ASCII-Header -> Header-Name ASCII-Value
+        Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
+        ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
+        Custom-Metadata -> Binary-Header / ASCII-Header
+        \endverbatim
+        **/
+        void AddMetadata(const std::string& meta_key, const std::string& meta_value);
+
+        /// Return a collection of initial metadata key-value pairs. Note that keys
+        /// may happen more than once (ie, a \a std::multimap is returned).
+        ///
+        /// \warning This method should only be called after initial metadata has been
+        /// received. For streaming calls, see \a
+        /// ClientReaderInterface::WaitForInitialMetadata().
+        ///
+        /// \return A multimap of initial metadata key-value pairs from the server.
+        const std::multimap<grpc::string_ref, grpc::string_ref>&
+            GetServerInitialMetadata() const
+        {
+            GPR_CODEGEN_ASSERT(initial_metadata_received_);
+            return *recv_initial_metadata_.map();
+        }
+
+        /// Return a collection of trailing metadata key-value pairs. Note that keys
+        /// may happen more than once (ie, a \a std::multimap is returned).
+        ///
+        /// \warning This method is only callable once the stream has finished.
+        ///
+        /// \return A multimap of metadata trailing key-value pairs from the server.
+        const std::multimap<grpc::string_ref, grpc::string_ref>&
+            GetServerTrailingMetadata() const
+        {
+            // TODO(yangg) check finished
+            return *trailing_metadata_.map();
+        }
+
+        /// Set the deadline for the client call.
+        ///
+        /// \warning This method should only be called before invoking the rpc.
+        ///
+        /// \param deadline the deadline for the client call. Units are determined by
+        /// the type used. The deadline is an absolute (not relative) time.
+        template<typename T>
+        void set_deadline(const T& deadline)
+        {
+            grpc::TimePoint<T> deadline_tp(deadline);
+            deadline_ = deadline_tp.raw_time();
+        }
+
+        /// Trigger wait-for-ready or not on this request.
+        /// See https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md.
+        /// If set, if an RPC is made when a channel's connectivity state is
+        /// TRANSIENT_FAILURE or CONNECTING, the call will not "fail fast",
+        /// and the channel will wait until the channel is READY before making the
+        /// call.
+        void set_wait_for_ready(bool wait_for_ready)
+        {
+            wait_for_ready_ = wait_for_ready;
+            wait_for_ready_explicitly_set_ = true;
+        }
+
+        /// DEPRECATED: Use set_wait_for_ready() instead.
+        void set_fail_fast(bool fail_fast)
+        {
+            set_wait_for_ready(!fail_fast);
+        }
+
+        /// Return the deadline for the client call.
+        std::chrono::system_clock::time_point deadline() const
+        {
+            return grpc::Timespec2Timepoint(deadline_);
+        }
+
+        /// Return a \a gpr_timespec representation of the client call's deadline.
+        gpr_timespec raw_deadline() const
+        {
+            return deadline_;
+        }
+
+        /// Set the per call authority header (see
+        /// https://tools.ietf.org/html/rfc7540#section-8.1.2.3).
+        void set_authority(const std::string& authority)
+        {
+            authority_ = authority;
+        }
+
+        /// Return the authentication context for the associated client call.
+        /// It is only valid to call this during the lifetime of the client call.
+        ///
+        /// \see grpc::AuthContext.
+        std::shared_ptr<const grpc::AuthContext> auth_context() const
+        {
+            if (auth_context_ == nullptr)
+            {
+                auth_context_ = grpc::CreateAuthContext(call_);
+            }
+            return auth_context_;
+        }
+
+        /// Set credentials for the client call.
+        ///
+        /// A credentials object encapsulates all the state needed by a client to
+        /// authenticate with a server and make various assertions, e.g., about the
+        /// client’s identity, role, or whether it is authorized to make a particular
+        /// call.
+        ///
+        /// It is legal to call this only before initial metadata is sent.
+        ///
+        /// \see  https://grpc.io/docs/guides/auth.html
+        void set_credentials(const std::shared_ptr<grpc::CallCredentials>& creds);
+
+        /// EXPERIMENTAL debugging API
+        ///
+        /// Returns the credentials for the client call. This should be used only in
+        /// tests and for diagnostic purposes, and should not be used by application
+        /// logic.
+        std::shared_ptr<grpc::CallCredentials> credentials()
+        {
+            return creds_;
+        }
+
+        /// Return the compression algorithm the client call will request be used.
+        /// Note that the gRPC runtime may decide to ignore this request, for example,
+        /// due to resource constraints.
+        grpc_compression_algorithm compression_algorithm() const
+        {
+            return compression_algorithm_;
+        }
+
+        /// Set \a algorithm to be the compression algorithm used for the client call.
+        ///
+        /// \param algorithm The compression algorithm used for the client call.
+        void set_compression_algorithm(grpc_compression_algorithm algorithm);
+
+        /// Flag whether the initial metadata should be \a corked
+        ///
+        /// If \a corked is true, then the initial metadata will be coalesced with the
+        /// write of first message in the stream. As a result, any tag set for the
+        /// initial metadata operation (starting a client-streaming or bidi-streaming
+        /// RPC) will not actually be sent to the completion queue or delivered
+        /// via Next.
+        ///
+        /// \param corked The flag indicating whether the initial metadata is to be
+        /// corked or not.
+        void set_initial_metadata_corked(bool corked)
+        {
+            initial_metadata_corked_ = corked;
+        }
+
+        /// Return the peer uri in a string.
+        /// It is only valid to call this during the lifetime of the client call.
+        ///
+        /// \warning This value is never authenticated or subject to any security
+        /// related code. It must not be used for any authentication related
+        /// functionality. Instead, use auth_context.
+        ///
+        /// \return The call's peer URI.
+        std::string peer() const;
+
+        /// Sets the census context.
+        /// It is only valid to call this before the client call is created. A common
+        /// place of setting census context is from within the DefaultConstructor
+        /// method of GlobalCallbacks.
+        void set_census_context(struct census_context* ccp)
+        {
+            census_context_ = ccp;
+        }
+
+        /// Returns the census context that has been set, or nullptr if not set.
+        struct census_context* census_context() const
+        {
+            return census_context_;
+        }
+
+        /// Send a best-effort out-of-band cancel on the call associated with
+        /// this client context.  The call could be in any stage; e.g., if it is
+        /// already finished, it may still return success.
+        ///
+        /// There is no guarantee the call will be cancelled.
+        ///
+        /// Note that TryCancel() does not change any of the tags that are pending
+        /// on the completion queue. All pending tags will still be delivered
+        /// (though their ok result may reflect the effect of cancellation).
+        void TryCancel();
+
+        /// Global Callbacks
+        ///
+        /// Can be set exactly once per application to install hooks whenever
+        /// a client context is constructed and destructed.
+        class GlobalCallbacks
+        {
+        public:
+            virtual ~GlobalCallbacks()
+            {
+            }
+            virtual void DefaultConstructor(ClientContext* context) = 0;
+            virtual void Destructor(ClientContext* context) = 0;
+        };
+        static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
+
+        /// Should be used for framework-level extensions only.
+        /// Applications never need to call this method.
+        grpc_call* c_call()
+        {
+            return call_;
+        }
+
+        /// EXPERIMENTAL debugging API
+        ///
+        /// if status is not ok() for an RPC, this will return a detailed string
+        /// of the gRPC Core error that led to the failure. It should not be relied
+        /// upon for anything other than gaining more debug data in failure cases.
+        std::string debug_error_string() const
+        {
+            return debug_error_string_;
+        }
+
+    private:
+        // Disallow copy and assign.
+        ClientContext(const ClientContext&);
+        ClientContext& operator=(const ClientContext&);
+
+        friend class grpc::testing::InteropClientContextInspector;
+        friend class grpc::testing::ClientContextTestPeer;
+        friend class grpc::internal::CallOpClientRecvStatus;
+        friend class grpc::internal::CallOpRecvInitialMetadata;
+        friend class grpc::Channel;
+        template<class R>
+        friend class grpc::ClientReader;
+        template<class W>
+        friend class grpc::ClientWriter;
+        template<class W, class R>
+        friend class grpc::ClientReaderWriter;
+        template<class R>
+        friend class grpc::ClientAsyncReader;
+        template<class W>
+        friend class grpc::ClientAsyncWriter;
+        template<class W, class R>
+        friend class grpc::ClientAsyncReaderWriter;
+        template<class R>
+        friend class grpc::ClientAsyncResponseReader;
+        friend class grpc::internal::ClientAsyncResponseReaderHelper;
+        template<class InputMessage, class OutputMessage>
+        friend class grpc::internal::BlockingUnaryCallImpl;
+        template<class InputMessage, class OutputMessage>
+        friend class grpc::internal::CallbackUnaryCallImpl;
+        template<class Request, class Response>
+        friend class grpc::internal::ClientCallbackReaderWriterImpl;
+        template<class Response>
+        friend class grpc::internal::ClientCallbackReaderImpl;
+        template<class Request>
+        friend class grpc::internal::ClientCallbackWriterImpl;
+        friend class grpc::internal::ClientCallbackUnaryImpl;
+        friend class grpc::internal::ClientContextAccessor;
+
+        // Used by friend class CallOpClientRecvStatus
+        void set_debug_error_string(const std::string& debug_error_string)
+        {
+            debug_error_string_ = debug_error_string;
+        }
+
+        grpc_call* call() const
+        {
+            return call_;
+        }
+        void set_call(grpc_call* call, const std::shared_ptr<grpc::Channel>& channel);
+
+        grpc::experimental::ClientRpcInfo* set_client_rpc_info(
+            const char* method, const char* suffix_for_stats, grpc::internal::RpcMethod::RpcType type, grpc::ChannelInterface* channel, const std::vector<std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>& creators, size_t interceptor_pos
+        )
+        {
+            rpc_info_ = grpc::experimental::ClientRpcInfo(this, type, method, suffix_for_stats, channel);
+            rpc_info_.RegisterInterceptors(creators, interceptor_pos);
+            return &rpc_info_;
+        }
+
+        uint32_t initial_metadata_flags() const
+        {
+            return (wait_for_ready_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY : 0) |
+                   (wait_for_ready_explicitly_set_ ? GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET : 0);
+        }
+
+        std::string authority()
+        {
+            return authority_;
+        }
+
+        void SendCancelToInterceptors();
+
+        static std::unique_ptr<ClientContext> FromInternalServerContext(
+            const grpc::ServerContextBase& server_context,
+            PropagationOptions options
+        );
+
+        bool initial_metadata_received_;
+        bool wait_for_ready_;
+        bool wait_for_ready_explicitly_set_;
+        std::shared_ptr<grpc::Channel> channel_;
+        grpc::internal::Mutex mu_;
+        grpc_call* call_;
+        bool call_canceled_;
+        gpr_timespec deadline_;
+        grpc::string authority_;
+        std::shared_ptr<grpc::CallCredentials> creds_;
+        mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
+        struct census_context* census_context_;
+        std::multimap<std::string, std::string> send_initial_metadata_;
+        mutable grpc::internal::MetadataMap recv_initial_metadata_;
+        mutable grpc::internal::MetadataMap trailing_metadata_;
+
+        grpc_call* propagate_from_call_;
+        PropagationOptions propagation_options_;
+
+        grpc_compression_algorithm compression_algorithm_;
+        bool initial_metadata_corked_;
+
+        std::string debug_error_string_;
+
+        grpc::experimental::ClientRpcInfo rpc_info_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_interceptor.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_interceptor.h
index f3560b5..194f396 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_interceptor.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_interceptor.h
@@ -28,172 +28,202 @@
 #include <grpcpp/impl/codegen/rpc_method.h>
 #include <grpcpp/impl/codegen/string_ref.h>
 
-namespace grpc {
-
-class Channel;
-class ClientContext;
-
-namespace internal {
-class InterceptorBatchMethodsImpl;
-}
-
-namespace experimental {
-class ClientRpcInfo;
-
-// A factory interface for creation of client interceptors. A vector of
-// factories can be provided at channel creation which will be used to create a
-// new vector of client interceptors per RPC. Client interceptor authors should
-// create a subclass of ClientInterceptorFactorInterface which creates objects
-// of their interceptors.
-class ClientInterceptorFactoryInterface {
- public:
-  virtual ~ClientInterceptorFactoryInterface() {}
-  // Returns a pointer to an Interceptor object on successful creation, nullptr
-  // otherwise. If nullptr is returned, this server interceptor factory is
-  // ignored for the purposes of that RPC.
-  virtual Interceptor* CreateClientInterceptor(ClientRpcInfo* info) = 0;
-};
-}  // namespace experimental
-
-namespace internal {
-extern experimental::ClientInterceptorFactoryInterface*
-    g_global_client_interceptor_factory;
-}
-
-/// ClientRpcInfo represents the state of a particular RPC as it
-/// appears to an interceptor. It is created and owned by the library and
-/// passed to the CreateClientInterceptor method of the application's
-/// ClientInterceptorFactoryInterface implementation
-namespace experimental {
-class ClientRpcInfo {
- public:
-  // TODO(yashykt): Stop default-constructing ClientRpcInfo and remove UNKNOWN
-  //                from the list of possible Types.
-  /// Type categorizes RPCs by unary or streaming type
-  enum class Type {
-    UNARY,
-    CLIENT_STREAMING,
-    SERVER_STREAMING,
-    BIDI_STREAMING,
-    UNKNOWN  // UNKNOWN is not API and will be removed later
-  };
-
-  ~ClientRpcInfo() {}
-
-  // Delete copy constructor but allow default move constructor
-  ClientRpcInfo(const ClientRpcInfo&) = delete;
-  ClientRpcInfo(ClientRpcInfo&&) = default;
-
-  // Getter methods
-
-  /// Return the fully-specified method name
-  const char* method() const { return method_; }
-
-  /// Return an identifying suffix for the client stub, or nullptr if one wasn't
-  /// specified.
-  const char* suffix_for_stats() const { return suffix_for_stats_; }
-
-  /// Return a pointer to the channel on which the RPC is being sent
-  ChannelInterface* channel() { return channel_; }
-
-  /// Return a pointer to the underlying ClientContext structure associated
-  /// with the RPC to support features that apply to it
-  grpc::ClientContext* client_context() { return ctx_; }
-
-  /// Return the type of the RPC (unary or a streaming flavor)
-  Type type() const { return type_; }
-
- private:
-  static_assert(Type::UNARY ==
-                    static_cast<Type>(internal::RpcMethod::NORMAL_RPC),
-                "violated expectation about Type enum");
-  static_assert(Type::CLIENT_STREAMING ==
-                    static_cast<Type>(internal::RpcMethod::CLIENT_STREAMING),
-                "violated expectation about Type enum");
-  static_assert(Type::SERVER_STREAMING ==
-                    static_cast<Type>(internal::RpcMethod::SERVER_STREAMING),
-                "violated expectation about Type enum");
-  static_assert(Type::BIDI_STREAMING ==
-                    static_cast<Type>(internal::RpcMethod::BIDI_STREAMING),
-                "violated expectation about Type enum");
-
-  // Default constructor should only be used by ClientContext
-  ClientRpcInfo() = default;
-
-  // Constructor will only be called from ClientContext
-  ClientRpcInfo(grpc::ClientContext* ctx, internal::RpcMethod::RpcType type,
-                const char* method, const char* suffix_for_stats,
-                grpc::ChannelInterface* channel)
-      : ctx_(ctx),
-        type_(static_cast<Type>(type)),
-        method_(method),
-        suffix_for_stats_(suffix_for_stats),
-        channel_(channel) {}
-
-  // Move assignment should only be used by ClientContext
-  // TODO(yashykt): Delete move assignment
-  ClientRpcInfo& operator=(ClientRpcInfo&&) = default;
-
-  // Runs interceptor at pos \a pos.
-  void RunInterceptor(
-      experimental::InterceptorBatchMethods* interceptor_methods, size_t pos) {
-    GPR_CODEGEN_ASSERT(pos < interceptors_.size());
-    interceptors_[pos]->Intercept(interceptor_methods);
-  }
-
-  void RegisterInterceptors(
-      const std::vector<std::unique_ptr<
-          experimental::ClientInterceptorFactoryInterface>>& creators,
-      size_t interceptor_pos) {
-    if (interceptor_pos > creators.size()) {
-      // No interceptors to register
-      return;
-    }
-    // NOTE: The following is not a range-based for loop because it will only
-    //       iterate over a portion of the creators vector.
-    for (auto it = creators.begin() + interceptor_pos; it != creators.end();
-         ++it) {
-      auto* interceptor = (*it)->CreateClientInterceptor(this);
-      if (interceptor != nullptr) {
-        interceptors_.push_back(
-            std::unique_ptr<experimental::Interceptor>(interceptor));
-      }
+namespace grpc
+{
+
+    class Channel;
+    class ClientContext;
+
+    namespace internal
+    {
+        class InterceptorBatchMethodsImpl;
     }
-    if (internal::g_global_client_interceptor_factory != nullptr) {
-      interceptors_.push_back(std::unique_ptr<experimental::Interceptor>(
-          internal::g_global_client_interceptor_factory
-              ->CreateClientInterceptor(this)));
+
+    namespace experimental
+    {
+        class ClientRpcInfo;
+
+        // A factory interface for creation of client interceptors. A vector of
+        // factories can be provided at channel creation which will be used to create a
+        // new vector of client interceptors per RPC. Client interceptor authors should
+        // create a subclass of ClientInterceptorFactorInterface which creates objects
+        // of their interceptors.
+        class ClientInterceptorFactoryInterface
+        {
+        public:
+            virtual ~ClientInterceptorFactoryInterface()
+            {
+            }
+            // Returns a pointer to an Interceptor object on successful creation, nullptr
+            // otherwise. If nullptr is returned, this server interceptor factory is
+            // ignored for the purposes of that RPC.
+            virtual Interceptor* CreateClientInterceptor(ClientRpcInfo* info) = 0;
+        };
+    }  // namespace experimental
+
+    namespace internal
+    {
+        extern experimental::ClientInterceptorFactoryInterface*
+            g_global_client_interceptor_factory;
     }
-  }
-
-  grpc::ClientContext* ctx_ = nullptr;
-  // TODO(yashykt): make type_ const once move-assignment is deleted
-  Type type_{Type::UNKNOWN};
-  const char* method_ = nullptr;
-  const char* suffix_for_stats_ = nullptr;
-  grpc::ChannelInterface* channel_ = nullptr;
-  std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_;
-  bool hijacked_ = false;
-  size_t hijacked_interceptor_ = 0;
-
-  friend class internal::InterceptorBatchMethodsImpl;
-  friend class grpc::ClientContext;
-};
-
-// PLEASE DO NOT USE THIS. ALWAYS PREFER PER CHANNEL INTERCEPTORS OVER A GLOBAL
-// INTERCEPTOR. IF USAGE IS ABSOLUTELY NECESSARY, PLEASE READ THE SAFETY NOTES.
-// Registers a global client interceptor factory object, which is used for all
-// RPCs made in this process. The application is responsible for maintaining the
-// life of the object while gRPC operations are in progress. The global
-// interceptor factory should only be registered once at the start of the
-// process before any gRPC operations have begun.
-void RegisterGlobalClientInterceptorFactory(
-    ClientInterceptorFactoryInterface* factory);
-
-// For testing purposes only
-void TestOnlyResetGlobalClientInterceptorFactory();
-
-}  // namespace experimental
+
+    /// ClientRpcInfo represents the state of a particular RPC as it
+    /// appears to an interceptor. It is created and owned by the library and
+    /// passed to the CreateClientInterceptor method of the application's
+    /// ClientInterceptorFactoryInterface implementation
+    namespace experimental
+    {
+        class ClientRpcInfo
+        {
+        public:
+            // TODO(yashykt): Stop default-constructing ClientRpcInfo and remove UNKNOWN
+            //                from the list of possible Types.
+            /// Type categorizes RPCs by unary or streaming type
+            enum class Type
+            {
+                UNARY,
+                CLIENT_STREAMING,
+                SERVER_STREAMING,
+                BIDI_STREAMING,
+                UNKNOWN  // UNKNOWN is not API and will be removed later
+            };
+
+            ~ClientRpcInfo()
+            {
+            }
+
+            // Delete copy constructor but allow default move constructor
+            ClientRpcInfo(const ClientRpcInfo&) = delete;
+            ClientRpcInfo(ClientRpcInfo&&) = default;
+
+            // Getter methods
+
+            /// Return the fully-specified method name
+            const char* method() const
+            {
+                return method_;
+            }
+
+            /// Return an identifying suffix for the client stub, or nullptr if one wasn't
+            /// specified.
+            const char* suffix_for_stats() const
+            {
+                return suffix_for_stats_;
+            }
+
+            /// Return a pointer to the channel on which the RPC is being sent
+            ChannelInterface* channel()
+            {
+                return channel_;
+            }
+
+            /// Return a pointer to the underlying ClientContext structure associated
+            /// with the RPC to support features that apply to it
+            grpc::ClientContext* client_context()
+            {
+                return ctx_;
+            }
+
+            /// Return the type of the RPC (unary or a streaming flavor)
+            Type type() const
+            {
+                return type_;
+            }
+
+        private:
+            static_assert(Type::UNARY == static_cast<Type>(internal::RpcMethod::NORMAL_RPC), "violated expectation about Type enum");
+            static_assert(Type::CLIENT_STREAMING == static_cast<Type>(internal::RpcMethod::CLIENT_STREAMING), "violated expectation about Type enum");
+            static_assert(Type::SERVER_STREAMING == static_cast<Type>(internal::RpcMethod::SERVER_STREAMING), "violated expectation about Type enum");
+            static_assert(Type::BIDI_STREAMING == static_cast<Type>(internal::RpcMethod::BIDI_STREAMING), "violated expectation about Type enum");
+
+            // Default constructor should only be used by ClientContext
+            ClientRpcInfo() = default;
+
+            // Constructor will only be called from ClientContext
+            ClientRpcInfo(grpc::ClientContext* ctx, internal::RpcMethod::RpcType type, const char* method, const char* suffix_for_stats, grpc::ChannelInterface* channel) :
+                ctx_(ctx),
+                type_(static_cast<Type>(type)),
+                method_(method),
+                suffix_for_stats_(suffix_for_stats),
+                channel_(channel)
+            {
+            }
+
+            // Move assignment should only be used by ClientContext
+            // TODO(yashykt): Delete move assignment
+            ClientRpcInfo& operator=(ClientRpcInfo&&) = default;
+
+            // Runs interceptor at pos \a pos.
+            void RunInterceptor(
+                experimental::InterceptorBatchMethods* interceptor_methods, size_t pos
+            )
+            {
+                GPR_CODEGEN_ASSERT(pos < interceptors_.size());
+                interceptors_[pos]->Intercept(interceptor_methods);
+            }
+
+            void RegisterInterceptors(
+                const std::vector<std::unique_ptr<
+                    experimental::ClientInterceptorFactoryInterface>>& creators,
+                size_t interceptor_pos
+            )
+            {
+                if (interceptor_pos > creators.size())
+                {
+                    // No interceptors to register
+                    return;
+                }
+                // NOTE: The following is not a range-based for loop because it will only
+                //       iterate over a portion of the creators vector.
+                for (auto it = creators.begin() + interceptor_pos; it != creators.end();
+                     ++it)
+                {
+                    auto* interceptor = (*it)->CreateClientInterceptor(this);
+                    if (interceptor != nullptr)
+                    {
+                        interceptors_.push_back(
+                            std::unique_ptr<experimental::Interceptor>(interceptor)
+                        );
+                    }
+                }
+                if (internal::g_global_client_interceptor_factory != nullptr)
+                {
+                    interceptors_.push_back(std::unique_ptr<experimental::Interceptor>(
+                        internal::g_global_client_interceptor_factory
+                            ->CreateClientInterceptor(this)
+                    ));
+                }
+            }
+
+            grpc::ClientContext* ctx_ = nullptr;
+            // TODO(yashykt): make type_ const once move-assignment is deleted
+            Type type_{Type::UNKNOWN};
+            const char* method_ = nullptr;
+            const char* suffix_for_stats_ = nullptr;
+            grpc::ChannelInterface* channel_ = nullptr;
+            std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_;
+            bool hijacked_ = false;
+            size_t hijacked_interceptor_ = 0;
+
+            friend class internal::InterceptorBatchMethodsImpl;
+            friend class grpc::ClientContext;
+        };
+
+        // PLEASE DO NOT USE THIS. ALWAYS PREFER PER CHANNEL INTERCEPTORS OVER A GLOBAL
+        // INTERCEPTOR. IF USAGE IS ABSOLUTELY NECESSARY, PLEASE READ THE SAFETY NOTES.
+        // Registers a global client interceptor factory object, which is used for all
+        // RPCs made in this process. The application is responsible for maintaining the
+        // life of the object while gRPC operations are in progress. The global
+        // interceptor factory should only be registered once at the start of the
+        // process before any gRPC operations have begun.
+        void RegisterGlobalClientInterceptorFactory(
+            ClientInterceptorFactoryInterface* factory
+        );
+
+        // For testing purposes only
+        void TestOnlyResetGlobalClientInterceptorFactory();
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_CLIENT_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_unary_call.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_unary_call.h
index 86adb3e..eabca8d 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_unary_call.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/client_unary_call.h
@@ -28,78 +28,76 @@
 #include <grpcpp/impl/codegen/core_codegen_interface.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
+namespace grpc
+{
 
-class ClientContext;
-namespace internal {
-class RpcMethod;
+    class ClientContext;
+    namespace internal
+    {
+        class RpcMethod;
 
-/// Wrapper that performs a blocking unary call. May optionally specify the base
-/// class of the Request and Response so that the internal calls and structures
-/// below this may be based on those base classes and thus achieve code reuse
-/// across different RPCs (e.g., for protobuf, MessageLite would be a base
-/// class).
-template <class InputMessage, class OutputMessage,
-          class BaseInputMessage = InputMessage,
-          class BaseOutputMessage = OutputMessage>
-Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method,
-                         grpc::ClientContext* context,
-                         const InputMessage& request, OutputMessage* result) {
-  static_assert(std::is_base_of<BaseInputMessage, InputMessage>::value,
-                "Invalid input message specification");
-  static_assert(std::is_base_of<BaseOutputMessage, OutputMessage>::value,
-                "Invalid output message specification");
-  return BlockingUnaryCallImpl<BaseInputMessage, BaseOutputMessage>(
-             channel, method, context, request, result)
-      .status();
-}
+        /// Wrapper that performs a blocking unary call. May optionally specify the base
+        /// class of the Request and Response so that the internal calls and structures
+        /// below this may be based on those base classes and thus achieve code reuse
+        /// across different RPCs (e.g., for protobuf, MessageLite would be a base
+        /// class).
+        template<class InputMessage, class OutputMessage, class BaseInputMessage = InputMessage, class BaseOutputMessage = OutputMessage>
+        Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method, grpc::ClientContext* context, const InputMessage& request, OutputMessage* result)
+        {
+            static_assert(std::is_base_of<BaseInputMessage, InputMessage>::value, "Invalid input message specification");
+            static_assert(std::is_base_of<BaseOutputMessage, OutputMessage>::value, "Invalid output message specification");
+            return BlockingUnaryCallImpl<BaseInputMessage, BaseOutputMessage>(
+                       channel, method, context, request, result
+            )
+                .status();
+        }
 
-template <class InputMessage, class OutputMessage>
-class BlockingUnaryCallImpl {
- public:
-  BlockingUnaryCallImpl(ChannelInterface* channel, const RpcMethod& method,
-                        grpc::ClientContext* context,
-                        const InputMessage& request, OutputMessage* result) {
-    grpc::CompletionQueue cq(grpc_completion_queue_attributes{
-        GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
-        nullptr});  // Pluckable completion queue
-    grpc::internal::Call call(channel->CreateCall(method, context, &cq));
-    CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage,
-              CallOpRecvInitialMetadata, CallOpRecvMessage<OutputMessage>,
-              CallOpClientSendClose, CallOpClientRecvStatus>
-        ops;
-    status_ = ops.SendMessagePtr(&request);
-    if (!status_.ok()) {
-      return;
-    }
-    ops.SendInitialMetadata(&context->send_initial_metadata_,
-                            context->initial_metadata_flags());
-    ops.RecvInitialMetadata(context);
-    ops.RecvMessage(result);
-    ops.AllowNoMessage();
-    ops.ClientSendClose();
-    ops.ClientRecvStatus(context, &status_);
-    call.PerformOps(&ops);
-    cq.Pluck(&ops);
-    // Some of the ops might fail. If the ops fail in the core layer, status
-    // would reflect the error. But, if the ops fail in the C++ layer, the
-    // status would still be the same as the one returned by gRPC Core. This can
-    // happen if deserialization of the message fails.
-    // TODO(yashykt): If deserialization fails, but the status received is OK,
-    // then it might be a good idea to change the status to something better
-    // than StatusCode::UNIMPLEMENTED to reflect this.
-    if (!ops.got_message && status_.ok()) {
-      status_ = Status(StatusCode::UNIMPLEMENTED,
-                       "No message returned for unary request");
-    }
-  }
-  Status status() { return status_; }
+        template<class InputMessage, class OutputMessage>
+        class BlockingUnaryCallImpl
+        {
+        public:
+            BlockingUnaryCallImpl(ChannelInterface* channel, const RpcMethod& method, grpc::ClientContext* context, const InputMessage& request, OutputMessage* result)
+            {
+                grpc::CompletionQueue cq(grpc_completion_queue_attributes{
+                    GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING, nullptr});  // Pluckable completion queue
+                grpc::internal::Call call(channel->CreateCall(method, context, &cq));
+                CallOpSet<CallOpSendInitialMetadata, CallOpSendMessage, CallOpRecvInitialMetadata, CallOpRecvMessage<OutputMessage>, CallOpClientSendClose, CallOpClientRecvStatus>
+                    ops;
+                status_ = ops.SendMessagePtr(&request);
+                if (!status_.ok())
+                {
+                    return;
+                }
+                ops.SendInitialMetadata(&context->send_initial_metadata_, context->initial_metadata_flags());
+                ops.RecvInitialMetadata(context);
+                ops.RecvMessage(result);
+                ops.AllowNoMessage();
+                ops.ClientSendClose();
+                ops.ClientRecvStatus(context, &status_);
+                call.PerformOps(&ops);
+                cq.Pluck(&ops);
+                // Some of the ops might fail. If the ops fail in the core layer, status
+                // would reflect the error. But, if the ops fail in the C++ layer, the
+                // status would still be the same as the one returned by gRPC Core. This can
+                // happen if deserialization of the message fails.
+                // TODO(yashykt): If deserialization fails, but the status received is OK,
+                // then it might be a good idea to change the status to something better
+                // than StatusCode::UNIMPLEMENTED to reflect this.
+                if (!ops.got_message && status_.ok())
+                {
+                    status_ = Status(StatusCode::UNIMPLEMENTED, "No message returned for unary request");
+                }
+            }
+            Status status()
+            {
+                return status_;
+            }
 
- private:
-  Status status_;
-};
+        private:
+            Status status_;
+        };
 
-}  // namespace internal
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_CLIENT_UNARY_CALL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue.h
index 33786f6..761ab80 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue.h
@@ -47,419 +47,457 @@
 
 struct grpc_completion_queue;
 
-namespace grpc {
-template <class R>
-class ClientReader;
-template <class W>
-class ClientWriter;
-template <class W, class R>
-class ClientReaderWriter;
-template <class R>
-class ServerReader;
-template <class W>
-class ServerWriter;
-namespace internal {
-template <class W, class R>
-class ServerReaderWriterBody;
-
-template <class ResponseType>
-void UnaryRunHandlerHelper(
-    const grpc::internal::MethodHandler::HandlerParameter&, ResponseType*,
-    grpc::Status&);
-template <class ServiceType, class RequestType, class ResponseType,
-          class BaseRequestType, class BaseResponseType>
-class RpcMethodHandler;
-template <class ServiceType, class RequestType, class ResponseType>
-class ClientStreamingHandler;
-template <class ServiceType, class RequestType, class ResponseType>
-class ServerStreamingHandler;
-template <class Streamer, bool WriteNeeded>
-class TemplatedBidiStreamingHandler;
-template <grpc::StatusCode code>
-class ErrorMethodHandler;
-}  // namespace internal
-
-class Channel;
-class ChannelInterface;
-class Server;
-class ServerBuilder;
-class ServerContextBase;
-class ServerInterface;
-
-namespace internal {
-class CompletionQueueTag;
-class RpcMethod;
-template <class InputMessage, class OutputMessage>
-class BlockingUnaryCallImpl;
-template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
-class CallOpSet;
-}  // namespace internal
-
-extern CoreCodegenInterface* g_core_codegen_interface;
-
-/// A thin wrapper around \ref grpc_completion_queue (see \ref
-/// src/core/lib/surface/completion_queue.h).
-/// See \ref doc/cpp/perf_notes.md for notes on best practices for high
-/// performance servers.
-class CompletionQueue : private grpc::GrpcLibraryCodegen {
- public:
-  /// Default constructor. Implicitly creates a \a grpc_completion_queue
-  /// instance.
-  CompletionQueue()
-      : CompletionQueue(grpc_completion_queue_attributes{
-            GRPC_CQ_CURRENT_VERSION, GRPC_CQ_NEXT, GRPC_CQ_DEFAULT_POLLING,
-            nullptr}) {}
-
-  /// Wrap \a take, taking ownership of the instance.
-  ///
-  /// \param take The completion queue instance to wrap. Ownership is taken.
-  explicit CompletionQueue(grpc_completion_queue* take);
-
-  /// Destructor. Destroys the owned wrapped completion queue / instance.
-  ~CompletionQueue() override {
-    grpc::g_core_codegen_interface->grpc_completion_queue_destroy(cq_);
-  }
-
-  /// Tri-state return for AsyncNext: SHUTDOWN, GOT_EVENT, TIMEOUT.
-  enum NextStatus {
-    SHUTDOWN,   ///< The completion queue has been shutdown and fully-drained
-    GOT_EVENT,  ///< Got a new event; \a tag will be filled in with its
-                ///< associated value; \a ok indicating its success.
-    TIMEOUT     ///< deadline was reached.
-  };
-
-  /// Read from the queue, blocking until an event is available or the queue is
-  /// shutting down.
-  ///
-  /// \param[out] tag Updated to point to the read event's tag.
-  /// \param[out] ok true if read a successful event, false otherwise.
-  ///
-  /// Note that each tag sent to the completion queue (through RPC operations
-  /// or alarms) will be delivered out of the completion queue by a call to
-  /// Next (or a related method), regardless of whether the operation succeeded
-  /// or not. Success here means that this operation completed in the normal
-  /// valid manner.
-  ///
-  /// Server-side RPC request: \a ok indicates that the RPC has indeed
-  /// been started. If it is false, the server has been Shutdown
-  /// before this particular call got matched to an incoming RPC.
-  ///
-  /// Client-side StartCall/RPC invocation: \a ok indicates that the RPC is
-  /// going to go to the wire. If it is false, it not going to the wire. This
-  /// would happen if the channel is either permanently broken or
-  /// transiently broken but with the fail-fast option. (Note that async unary
-  /// RPCs don't post a CQ tag at this point, nor do client-streaming
-  /// or bidi-streaming RPCs that have the initial metadata corked option set.)
-  ///
-  /// Client-side Write, Client-side WritesDone, Server-side Write,
-  /// Server-side Finish, Server-side SendInitialMetadata (which is
-  /// typically included in Write or Finish when not done explicitly):
-  /// \a ok means that the data/metadata/status/etc is going to go to the
-  /// wire. If it is false, it not going to the wire because the call
-  /// is already dead (i.e., canceled, deadline expired, other side
-  /// dropped the channel, etc).
-  ///
-  /// Client-side Read, Server-side Read, Client-side
-  /// RecvInitialMetadata (which is typically included in Read if not
-  /// done explicitly): \a ok indicates whether there is a valid message
-  /// that got read. If not, you know that there are certainly no more
-  /// messages that can ever be read from this stream. For the client-side
-  /// operations, this only happens because the call is dead. For the
-  /// server-sider operation, though, this could happen because the client
-  /// has done a WritesDone already.
-  ///
-  /// Client-side Finish: \a ok should always be true
-  ///
-  /// Server-side AsyncNotifyWhenDone: \a ok should always be true
-  ///
-  /// Alarm: \a ok is true if it expired, false if it was canceled
-  ///
-  /// \return true if got an event, false if the queue is fully drained and
-  ///         shut down.
-  bool Next(void** tag, bool* ok) {
-    // Check return type == GOT_EVENT... cases:
-    // SHUTDOWN  - queue has been shutdown, return false.
-    // TIMEOUT   - we passed infinity time => queue has been shutdown, return
-    //             false.
-    // GOT_EVENT - we actually got an event, return true.
-    return (AsyncNextInternal(tag, ok,
-                              grpc::g_core_codegen_interface->gpr_inf_future(
-                                  GPR_CLOCK_REALTIME)) == GOT_EVENT);
-  }
-
-  /// Read from the queue, blocking up to \a deadline (or the queue's shutdown).
-  /// Both \a tag and \a ok are updated upon success (if an event is available
-  /// within the \a deadline).  A \a tag points to an arbitrary location usually
-  /// employed to uniquely identify an event.
-  ///
-  /// \param[out] tag Upon success, updated to point to the event's tag.
-  /// \param[out] ok Upon success, true if a successful event, false otherwise
-  ///        See documentation for CompletionQueue::Next for explanation of ok
-  /// \param[in] deadline How long to block in wait for an event.
-  ///
-  /// \return The type of event read.
-  template <typename T>
-  NextStatus AsyncNext(void** tag, bool* ok, const T& deadline) {
-    grpc::TimePoint<T> deadline_tp(deadline);
-    return AsyncNextInternal(tag, ok, deadline_tp.raw_time());
-  }
-
-  /// EXPERIMENTAL
-  /// First executes \a F, then reads from the queue, blocking up to
-  /// \a deadline (or the queue's shutdown).
-  /// Both \a tag and \a ok are updated upon success (if an event is available
-  /// within the \a deadline).  A \a tag points to an arbitrary location usually
-  /// employed to uniquely identify an event.
-  ///
-  /// \param[in] f Function to execute before calling AsyncNext on this queue.
-  /// \param[out] tag Upon success, updated to point to the event's tag.
-  /// \param[out] ok Upon success, true if read a regular event, false
-  /// otherwise.
-  /// \param[in] deadline How long to block in wait for an event.
-  ///
-  /// \return The type of event read.
-  template <typename T, typename F>
-  NextStatus DoThenAsyncNext(F&& f, void** tag, bool* ok, const T& deadline) {
-    CompletionQueueTLSCache cache = CompletionQueueTLSCache(this);
-    f();
-    if (cache.Flush(tag, ok)) {
-      return GOT_EVENT;
-    } else {
-      return AsyncNext(tag, ok, deadline);
-    }
-  }
-
-  /// Request the shutdown of the queue.
-  ///
-  /// \warning This method must be called at some point if this completion queue
-  /// is accessed with Next or AsyncNext. \a Next will not return false
-  /// until this method has been called and all pending tags have been drained.
-  /// (Likewise for \a AsyncNext returning \a NextStatus::SHUTDOWN .)
-  /// Only once either one of these methods does that (that is, once the queue
-  /// has been \em drained) can an instance of this class be destroyed.
-  /// Also note that applications must ensure that no work is enqueued on this
-  /// completion queue after this method is called.
-  void Shutdown();
-
-  /// Returns a \em raw pointer to the underlying \a grpc_completion_queue
-  /// instance.
-  ///
-  /// \warning Remember that the returned instance is owned. No transfer of
-  /// owership is performed.
-  grpc_completion_queue* cq() { return cq_; }
-
- protected:
-  /// Private constructor of CompletionQueue only visible to friend classes
-  explicit CompletionQueue(const grpc_completion_queue_attributes& attributes) {
-    cq_ = grpc::g_core_codegen_interface->grpc_completion_queue_create(
-        grpc::g_core_codegen_interface->grpc_completion_queue_factory_lookup(
-            &attributes),
-        &attributes, nullptr);
-    InitialAvalanching();  // reserve this for the future shutdown
-  }
-
- private:
-  // Friends for access to server registration lists that enable checking and
-  // logging on shutdown
-  friend class grpc::ServerBuilder;
-  friend class grpc::Server;
-
-  // Friend synchronous wrappers so that they can access Pluck(), which is
-  // a semi-private API geared towards the synchronous implementation.
-  template <class R>
-  friend class grpc::ClientReader;
-  template <class W>
-  friend class grpc::ClientWriter;
-  template <class W, class R>
-  friend class grpc::ClientReaderWriter;
-  template <class R>
-  friend class grpc::ServerReader;
-  template <class W>
-  friend class grpc::ServerWriter;
-  template <class W, class R>
-  friend class grpc::internal::ServerReaderWriterBody;
-  template <class ResponseType>
-  friend void grpc::internal::UnaryRunHandlerHelper(
-      const grpc::internal::MethodHandler::HandlerParameter&, ResponseType*,
-      grpc::Status&);
-  template <class ServiceType, class RequestType, class ResponseType>
-  friend class grpc::internal::ClientStreamingHandler;
-  template <class ServiceType, class RequestType, class ResponseType>
-  friend class grpc::internal::ServerStreamingHandler;
-  template <class Streamer, bool WriteNeeded>
-  friend class grpc::internal::TemplatedBidiStreamingHandler;
-  template <grpc::StatusCode code>
-  friend class grpc::internal::ErrorMethodHandler;
-  friend class grpc::ServerContextBase;
-  friend class grpc::ServerInterface;
-  template <class InputMessage, class OutputMessage>
-  friend class grpc::internal::BlockingUnaryCallImpl;
-
-  // Friends that need access to constructor for callback CQ
-  friend class grpc::Channel;
-
-  // For access to Register/CompleteAvalanching
-  template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
-  friend class grpc::internal::CallOpSet;
-
-  /// EXPERIMENTAL
-  /// Creates a Thread Local cache to store the first event
-  /// On this completion queue queued from this thread.  Once
-  /// initialized, it must be flushed on the same thread.
-  class CompletionQueueTLSCache {
-   public:
-    explicit CompletionQueueTLSCache(CompletionQueue* cq);
-    ~CompletionQueueTLSCache();
-    bool Flush(void** tag, bool* ok);
-
-   private:
-    CompletionQueue* cq_;
-    bool flushed_;
-  };
-
-  NextStatus AsyncNextInternal(void** tag, bool* ok, gpr_timespec deadline);
-
-  /// Wraps \a grpc_completion_queue_pluck.
-  /// \warning Must not be mixed with calls to \a Next.
-  bool Pluck(grpc::internal::CompletionQueueTag* tag) {
-    auto deadline =
-        grpc::g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME);
-    while (true) {
-      auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
-          cq_, tag, deadline, nullptr);
-      bool ok = ev.success != 0;
-      void* ignored = tag;
-      if (tag->FinalizeResult(&ignored, &ok)) {
-        GPR_CODEGEN_ASSERT(ignored == tag);
-        return ok;
-      }
-    }
-  }
-
-  /// Performs a single polling pluck on \a tag.
-  /// \warning Must not be mixed with calls to \a Next.
-  ///
-  /// TODO: sreek - This calls tag->FinalizeResult() even if the cq_ is already
-  /// shutdown. This is most likely a bug and if it is a bug, then change this
-  /// implementation to simple call the other TryPluck function with a zero
-  /// timeout. i.e:
-  ///      TryPluck(tag, gpr_time_0(GPR_CLOCK_REALTIME))
-  void TryPluck(grpc::internal::CompletionQueueTag* tag) {
-    auto deadline =
-        grpc::g_core_codegen_interface->gpr_time_0(GPR_CLOCK_REALTIME);
-    auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
-        cq_, tag, deadline, nullptr);
-    if (ev.type == GRPC_QUEUE_TIMEOUT) return;
-    bool ok = ev.success != 0;
-    void* ignored = tag;
-    // the tag must be swallowed if using TryPluck
-    GPR_CODEGEN_ASSERT(!tag->FinalizeResult(&ignored, &ok));
-  }
-
-  /// Performs a single polling pluck on \a tag. Calls tag->FinalizeResult if
-  /// the pluck() was successful and returned the tag.
-  ///
-  /// This exects tag->FinalizeResult (if called) to return 'false' i.e expects
-  /// that the tag is internal not something that is returned to the user.
-  void TryPluck(grpc::internal::CompletionQueueTag* tag,
-                gpr_timespec deadline) {
-    auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
-        cq_, tag, deadline, nullptr);
-    if (ev.type == GRPC_QUEUE_TIMEOUT || ev.type == GRPC_QUEUE_SHUTDOWN) {
-      return;
-    }
-
-    bool ok = ev.success != 0;
-    void* ignored = tag;
-    GPR_CODEGEN_ASSERT(!tag->FinalizeResult(&ignored, &ok));
-  }
-
-  /// Manage state of avalanching operations : completion queue tags that
-  /// trigger other completion queue operations. The underlying core completion
-  /// queue should not really shutdown until all avalanching operations have
-  /// been finalized. Note that we maintain the requirement that an avalanche
-  /// registration must take place before CQ shutdown (which must be maintained
-  /// elsehwere)
-  void InitialAvalanching() {
-    gpr_atm_rel_store(&avalanches_in_flight_, static_cast<gpr_atm>(1));
-  }
-  void RegisterAvalanching() {
-    gpr_atm_no_barrier_fetch_add(&avalanches_in_flight_,
-                                 static_cast<gpr_atm>(1));
-  }
-  void CompleteAvalanching() {
-    if (gpr_atm_no_barrier_fetch_add(&avalanches_in_flight_,
-                                     static_cast<gpr_atm>(-1)) == 1) {
-      grpc::g_core_codegen_interface->grpc_completion_queue_shutdown(cq_);
-    }
-  }
-
-  void RegisterServer(const grpc::Server* server) {
-    (void)server;
+namespace grpc
+{
+    template<class R>
+    class ClientReader;
+    template<class W>
+    class ClientWriter;
+    template<class W, class R>
+    class ClientReaderWriter;
+    template<class R>
+    class ServerReader;
+    template<class W>
+    class ServerWriter;
+    namespace internal
+    {
+        template<class W, class R>
+        class ServerReaderWriterBody;
+
+        template<class ResponseType>
+        void UnaryRunHandlerHelper(
+            const grpc::internal::MethodHandler::HandlerParameter&, ResponseType*, grpc::Status&
+        );
+        template<class ServiceType, class RequestType, class ResponseType, class BaseRequestType, class BaseResponseType>
+        class RpcMethodHandler;
+        template<class ServiceType, class RequestType, class ResponseType>
+        class ClientStreamingHandler;
+        template<class ServiceType, class RequestType, class ResponseType>
+        class ServerStreamingHandler;
+        template<class Streamer, bool WriteNeeded>
+        class TemplatedBidiStreamingHandler;
+        template<grpc::StatusCode code>
+        class ErrorMethodHandler;
+    }  // namespace internal
+
+    class Channel;
+    class ChannelInterface;
+    class Server;
+    class ServerBuilder;
+    class ServerContextBase;
+    class ServerInterface;
+
+    namespace internal
+    {
+        class CompletionQueueTag;
+        class RpcMethod;
+        template<class InputMessage, class OutputMessage>
+        class BlockingUnaryCallImpl;
+        template<class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
+        class CallOpSet;
+    }  // namespace internal
+
+    extern CoreCodegenInterface* g_core_codegen_interface;
+
+    /// A thin wrapper around \ref grpc_completion_queue (see \ref
+    /// src/core/lib/surface/completion_queue.h).
+    /// See \ref doc/cpp/perf_notes.md for notes on best practices for high
+    /// performance servers.
+    class CompletionQueue : private grpc::GrpcLibraryCodegen
+    {
+    public:
+        /// Default constructor. Implicitly creates a \a grpc_completion_queue
+        /// instance.
+        CompletionQueue() :
+            CompletionQueue(grpc_completion_queue_attributes{
+                GRPC_CQ_CURRENT_VERSION, GRPC_CQ_NEXT, GRPC_CQ_DEFAULT_POLLING, nullptr})
+        {
+        }
+
+        /// Wrap \a take, taking ownership of the instance.
+        ///
+        /// \param take The completion queue instance to wrap. Ownership is taken.
+        explicit CompletionQueue(grpc_completion_queue* take);
+
+        /// Destructor. Destroys the owned wrapped completion queue / instance.
+        ~CompletionQueue() override
+        {
+            grpc::g_core_codegen_interface->grpc_completion_queue_destroy(cq_);
+        }
+
+        /// Tri-state return for AsyncNext: SHUTDOWN, GOT_EVENT, TIMEOUT.
+        enum NextStatus
+        {
+            SHUTDOWN,   ///< The completion queue has been shutdown and fully-drained
+            GOT_EVENT,  ///< Got a new event; \a tag will be filled in with its
+                        ///< associated value; \a ok indicating its success.
+            TIMEOUT     ///< deadline was reached.
+        };
+
+        /// Read from the queue, blocking until an event is available or the queue is
+        /// shutting down.
+        ///
+        /// \param[out] tag Updated to point to the read event's tag.
+        /// \param[out] ok true if read a successful event, false otherwise.
+        ///
+        /// Note that each tag sent to the completion queue (through RPC operations
+        /// or alarms) will be delivered out of the completion queue by a call to
+        /// Next (or a related method), regardless of whether the operation succeeded
+        /// or not. Success here means that this operation completed in the normal
+        /// valid manner.
+        ///
+        /// Server-side RPC request: \a ok indicates that the RPC has indeed
+        /// been started. If it is false, the server has been Shutdown
+        /// before this particular call got matched to an incoming RPC.
+        ///
+        /// Client-side StartCall/RPC invocation: \a ok indicates that the RPC is
+        /// going to go to the wire. If it is false, it not going to the wire. This
+        /// would happen if the channel is either permanently broken or
+        /// transiently broken but with the fail-fast option. (Note that async unary
+        /// RPCs don't post a CQ tag at this point, nor do client-streaming
+        /// or bidi-streaming RPCs that have the initial metadata corked option set.)
+        ///
+        /// Client-side Write, Client-side WritesDone, Server-side Write,
+        /// Server-side Finish, Server-side SendInitialMetadata (which is
+        /// typically included in Write or Finish when not done explicitly):
+        /// \a ok means that the data/metadata/status/etc is going to go to the
+        /// wire. If it is false, it not going to the wire because the call
+        /// is already dead (i.e., canceled, deadline expired, other side
+        /// dropped the channel, etc).
+        ///
+        /// Client-side Read, Server-side Read, Client-side
+        /// RecvInitialMetadata (which is typically included in Read if not
+        /// done explicitly): \a ok indicates whether there is a valid message
+        /// that got read. If not, you know that there are certainly no more
+        /// messages that can ever be read from this stream. For the client-side
+        /// operations, this only happens because the call is dead. For the
+        /// server-sider operation, though, this could happen because the client
+        /// has done a WritesDone already.
+        ///
+        /// Client-side Finish: \a ok should always be true
+        ///
+        /// Server-side AsyncNotifyWhenDone: \a ok should always be true
+        ///
+        /// Alarm: \a ok is true if it expired, false if it was canceled
+        ///
+        /// \return true if got an event, false if the queue is fully drained and
+        ///         shut down.
+        bool Next(void** tag, bool* ok)
+        {
+            // Check return type == GOT_EVENT... cases:
+            // SHUTDOWN  - queue has been shutdown, return false.
+            // TIMEOUT   - we passed infinity time => queue has been shutdown, return
+            //             false.
+            // GOT_EVENT - we actually got an event, return true.
+            return (AsyncNextInternal(tag, ok, grpc::g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME)) == GOT_EVENT);
+        }
+
+        /// Read from the queue, blocking up to \a deadline (or the queue's shutdown).
+        /// Both \a tag and \a ok are updated upon success (if an event is available
+        /// within the \a deadline).  A \a tag points to an arbitrary location usually
+        /// employed to uniquely identify an event.
+        ///
+        /// \param[out] tag Upon success, updated to point to the event's tag.
+        /// \param[out] ok Upon success, true if a successful event, false otherwise
+        ///        See documentation for CompletionQueue::Next for explanation of ok
+        /// \param[in] deadline How long to block in wait for an event.
+        ///
+        /// \return The type of event read.
+        template<typename T>
+        NextStatus AsyncNext(void** tag, bool* ok, const T& deadline)
+        {
+            grpc::TimePoint<T> deadline_tp(deadline);
+            return AsyncNextInternal(tag, ok, deadline_tp.raw_time());
+        }
+
+        /// EXPERIMENTAL
+        /// First executes \a F, then reads from the queue, blocking up to
+        /// \a deadline (or the queue's shutdown).
+        /// Both \a tag and \a ok are updated upon success (if an event is available
+        /// within the \a deadline).  A \a tag points to an arbitrary location usually
+        /// employed to uniquely identify an event.
+        ///
+        /// \param[in] f Function to execute before calling AsyncNext on this queue.
+        /// \param[out] tag Upon success, updated to point to the event's tag.
+        /// \param[out] ok Upon success, true if read a regular event, false
+        /// otherwise.
+        /// \param[in] deadline How long to block in wait for an event.
+        ///
+        /// \return The type of event read.
+        template<typename T, typename F>
+        NextStatus DoThenAsyncNext(F&& f, void** tag, bool* ok, const T& deadline)
+        {
+            CompletionQueueTLSCache cache = CompletionQueueTLSCache(this);
+            f();
+            if (cache.Flush(tag, ok))
+            {
+                return GOT_EVENT;
+            }
+            else
+            {
+                return AsyncNext(tag, ok, deadline);
+            }
+        }
+
+        /// Request the shutdown of the queue.
+        ///
+        /// \warning This method must be called at some point if this completion queue
+        /// is accessed with Next or AsyncNext. \a Next will not return false
+        /// until this method has been called and all pending tags have been drained.
+        /// (Likewise for \a AsyncNext returning \a NextStatus::SHUTDOWN .)
+        /// Only once either one of these methods does that (that is, once the queue
+        /// has been \em drained) can an instance of this class be destroyed.
+        /// Also note that applications must ensure that no work is enqueued on this
+        /// completion queue after this method is called.
+        void Shutdown();
+
+        /// Returns a \em raw pointer to the underlying \a grpc_completion_queue
+        /// instance.
+        ///
+        /// \warning Remember that the returned instance is owned. No transfer of
+        /// owership is performed.
+        grpc_completion_queue* cq()
+        {
+            return cq_;
+        }
+
+    protected:
+        /// Private constructor of CompletionQueue only visible to friend classes
+        explicit CompletionQueue(const grpc_completion_queue_attributes& attributes)
+        {
+            cq_ = grpc::g_core_codegen_interface->grpc_completion_queue_create(
+                grpc::g_core_codegen_interface->grpc_completion_queue_factory_lookup(
+                    &attributes
+                ),
+                &attributes,
+                nullptr
+            );
+            InitialAvalanching();  // reserve this for the future shutdown
+        }
+
+    private:
+        // Friends for access to server registration lists that enable checking and
+        // logging on shutdown
+        friend class grpc::ServerBuilder;
+        friend class grpc::Server;
+
+        // Friend synchronous wrappers so that they can access Pluck(), which is
+        // a semi-private API geared towards the synchronous implementation.
+        template<class R>
+        friend class grpc::ClientReader;
+        template<class W>
+        friend class grpc::ClientWriter;
+        template<class W, class R>
+        friend class grpc::ClientReaderWriter;
+        template<class R>
+        friend class grpc::ServerReader;
+        template<class W>
+        friend class grpc::ServerWriter;
+        template<class W, class R>
+        friend class grpc::internal::ServerReaderWriterBody;
+        template<class ResponseType>
+        friend void grpc::internal::UnaryRunHandlerHelper(
+            const grpc::internal::MethodHandler::HandlerParameter&, ResponseType*, grpc::Status&
+        );
+        template<class ServiceType, class RequestType, class ResponseType>
+        friend class grpc::internal::ClientStreamingHandler;
+        template<class ServiceType, class RequestType, class ResponseType>
+        friend class grpc::internal::ServerStreamingHandler;
+        template<class Streamer, bool WriteNeeded>
+        friend class grpc::internal::TemplatedBidiStreamingHandler;
+        template<grpc::StatusCode code>
+        friend class grpc::internal::ErrorMethodHandler;
+        friend class grpc::ServerContextBase;
+        friend class grpc::ServerInterface;
+        template<class InputMessage, class OutputMessage>
+        friend class grpc::internal::BlockingUnaryCallImpl;
+
+        // Friends that need access to constructor for callback CQ
+        friend class grpc::Channel;
+
+        // For access to Register/CompleteAvalanching
+        template<class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>
+        friend class grpc::internal::CallOpSet;
+
+        /// EXPERIMENTAL
+        /// Creates a Thread Local cache to store the first event
+        /// On this completion queue queued from this thread.  Once
+        /// initialized, it must be flushed on the same thread.
+        class CompletionQueueTLSCache
+        {
+        public:
+            explicit CompletionQueueTLSCache(CompletionQueue* cq);
+            ~CompletionQueueTLSCache();
+            bool Flush(void** tag, bool* ok);
+
+        private:
+            CompletionQueue* cq_;
+            bool flushed_;
+        };
+
+        NextStatus AsyncNextInternal(void** tag, bool* ok, gpr_timespec deadline);
+
+        /// Wraps \a grpc_completion_queue_pluck.
+        /// \warning Must not be mixed with calls to \a Next.
+        bool Pluck(grpc::internal::CompletionQueueTag* tag)
+        {
+            auto deadline =
+                grpc::g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME);
+            while (true)
+            {
+                auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
+                    cq_, tag, deadline, nullptr
+                );
+                bool ok = ev.success != 0;
+                void* ignored = tag;
+                if (tag->FinalizeResult(&ignored, &ok))
+                {
+                    GPR_CODEGEN_ASSERT(ignored == tag);
+                    return ok;
+                }
+            }
+        }
+
+        /// Performs a single polling pluck on \a tag.
+        /// \warning Must not be mixed with calls to \a Next.
+        ///
+        /// TODO: sreek - This calls tag->FinalizeResult() even if the cq_ is already
+        /// shutdown. This is most likely a bug and if it is a bug, then change this
+        /// implementation to simple call the other TryPluck function with a zero
+        /// timeout. i.e:
+        ///      TryPluck(tag, gpr_time_0(GPR_CLOCK_REALTIME))
+        void TryPluck(grpc::internal::CompletionQueueTag* tag)
+        {
+            auto deadline =
+                grpc::g_core_codegen_interface->gpr_time_0(GPR_CLOCK_REALTIME);
+            auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
+                cq_, tag, deadline, nullptr
+            );
+            if (ev.type == GRPC_QUEUE_TIMEOUT)
+                return;
+            bool ok = ev.success != 0;
+            void* ignored = tag;
+            // the tag must be swallowed if using TryPluck
+            GPR_CODEGEN_ASSERT(!tag->FinalizeResult(&ignored, &ok));
+        }
+
+        /// Performs a single polling pluck on \a tag. Calls tag->FinalizeResult if
+        /// the pluck() was successful and returned the tag.
+        ///
+        /// This exects tag->FinalizeResult (if called) to return 'false' i.e expects
+        /// that the tag is internal not something that is returned to the user.
+        void TryPluck(grpc::internal::CompletionQueueTag* tag, gpr_timespec deadline)
+        {
+            auto ev = grpc::g_core_codegen_interface->grpc_completion_queue_pluck(
+                cq_, tag, deadline, nullptr
+            );
+            if (ev.type == GRPC_QUEUE_TIMEOUT || ev.type == GRPC_QUEUE_SHUTDOWN)
+            {
+                return;
+            }
+
+            bool ok = ev.success != 0;
+            void* ignored = tag;
+            GPR_CODEGEN_ASSERT(!tag->FinalizeResult(&ignored, &ok));
+        }
+
+        /// Manage state of avalanching operations : completion queue tags that
+        /// trigger other completion queue operations. The underlying core completion
+        /// queue should not really shutdown until all avalanching operations have
+        /// been finalized. Note that we maintain the requirement that an avalanche
+        /// registration must take place before CQ shutdown (which must be maintained
+        /// elsehwere)
+        void InitialAvalanching()
+        {
+            gpr_atm_rel_store(&avalanches_in_flight_, static_cast<gpr_atm>(1));
+        }
+        void RegisterAvalanching()
+        {
+            gpr_atm_no_barrier_fetch_add(&avalanches_in_flight_, static_cast<gpr_atm>(1));
+        }
+        void CompleteAvalanching()
+        {
+            if (gpr_atm_no_barrier_fetch_add(&avalanches_in_flight_, static_cast<gpr_atm>(-1)) == 1)
+            {
+                grpc::g_core_codegen_interface->grpc_completion_queue_shutdown(cq_);
+            }
+        }
+
+        void RegisterServer(const grpc::Server* server)
+        {
+            (void)server;
 #ifndef NDEBUG
-    grpc::internal::MutexLock l(&server_list_mutex_);
-    server_list_.push_back(server);
+            grpc::internal::MutexLock l(&server_list_mutex_);
+            server_list_.push_back(server);
 #endif
-  }
-  void UnregisterServer(const grpc::Server* server) {
-    (void)server;
+        }
+        void UnregisterServer(const grpc::Server* server)
+        {
+            (void)server;
 #ifndef NDEBUG
-    grpc::internal::MutexLock l(&server_list_mutex_);
-    server_list_.remove(server);
+            grpc::internal::MutexLock l(&server_list_mutex_);
+            server_list_.remove(server);
 #endif
-  }
-  bool ServerListEmpty() const {
+        }
+        bool ServerListEmpty() const
+        {
 #ifndef NDEBUG
-    grpc::internal::MutexLock l(&server_list_mutex_);
-    return server_list_.empty();
+            grpc::internal::MutexLock l(&server_list_mutex_);
+            return server_list_.empty();
 #endif
-    return true;
-  }
-
-  static CompletionQueue* CallbackAlternativeCQ();
-  static void ReleaseCallbackAlternativeCQ(CompletionQueue* cq);
-
-  grpc_completion_queue* cq_;  // owned
-
-  gpr_atm avalanches_in_flight_;
-
-  // List of servers associated with this CQ. Even though this is only used with
-  // NDEBUG, instantiate it in all cases since otherwise the size will be
-  // inconsistent.
-  mutable grpc::internal::Mutex server_list_mutex_;
-  std::list<const grpc::Server*>
-      server_list_ /* GUARDED_BY(server_list_mutex_) */;
-};
-
-/// A specific type of completion queue used by the processing of notifications
-/// by servers. Instantiated by \a ServerBuilder or Server (for health checker).
-class ServerCompletionQueue : public CompletionQueue {
- public:
-  bool IsFrequentlyPolled() { return polling_type_ != GRPC_CQ_NON_LISTENING; }
-
- protected:
-  /// Default constructor
-  ServerCompletionQueue() : polling_type_(GRPC_CQ_DEFAULT_POLLING) {}
-
- private:
-  /// \param completion_type indicates whether this is a NEXT or CALLBACK
-  /// completion queue.
-  /// \param polling_type Informs the GRPC library about the type of polling
-  /// allowed on this completion queue. See grpc_cq_polling_type's description
-  /// in grpc_types.h for more details.
-  /// \param shutdown_cb is the shutdown callback used for CALLBACK api queues
-  ServerCompletionQueue(grpc_cq_completion_type completion_type,
-                        grpc_cq_polling_type polling_type,
-                        grpc_completion_queue_functor* shutdown_cb)
-      : CompletionQueue(grpc_completion_queue_attributes{
-            GRPC_CQ_CURRENT_VERSION, completion_type, polling_type,
-            shutdown_cb}),
-        polling_type_(polling_type) {}
-
-  grpc_cq_polling_type polling_type_;
-  friend class grpc::ServerBuilder;
-  friend class grpc::Server;
-};
+            return true;
+        }
+
+        static CompletionQueue* CallbackAlternativeCQ();
+        static void ReleaseCallbackAlternativeCQ(CompletionQueue* cq);
+
+        grpc_completion_queue* cq_;  // owned
+
+        gpr_atm avalanches_in_flight_;
+
+        // List of servers associated with this CQ. Even though this is only used with
+        // NDEBUG, instantiate it in all cases since otherwise the size will be
+        // inconsistent.
+        mutable grpc::internal::Mutex server_list_mutex_;
+        std::list<const grpc::Server*>
+            server_list_ /* GUARDED_BY(server_list_mutex_) */;
+    };
+
+    /// A specific type of completion queue used by the processing of notifications
+    /// by servers. Instantiated by \a ServerBuilder or Server (for health checker).
+    class ServerCompletionQueue : public CompletionQueue
+    {
+    public:
+        bool IsFrequentlyPolled()
+        {
+            return polling_type_ != GRPC_CQ_NON_LISTENING;
+        }
+
+    protected:
+        /// Default constructor
+        ServerCompletionQueue() :
+            polling_type_(GRPC_CQ_DEFAULT_POLLING)
+        {
+        }
+
+    private:
+        /// \param completion_type indicates whether this is a NEXT or CALLBACK
+        /// completion queue.
+        /// \param polling_type Informs the GRPC library about the type of polling
+        /// allowed on this completion queue. See grpc_cq_polling_type's description
+        /// in grpc_types.h for more details.
+        /// \param shutdown_cb is the shutdown callback used for CALLBACK api queues
+        ServerCompletionQueue(grpc_cq_completion_type completion_type, grpc_cq_polling_type polling_type, grpc_completion_queue_functor* shutdown_cb) :
+            CompletionQueue(grpc_completion_queue_attributes{
+                GRPC_CQ_CURRENT_VERSION, completion_type, polling_type, shutdown_cb}),
+            polling_type_(polling_type)
+        {
+        }
+
+        grpc_cq_polling_type polling_type_;
+        friend class grpc::ServerBuilder;
+        friend class grpc::Server;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue_tag.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue_tag.h
index 9af470b..5489b2b 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue_tag.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/completion_queue_tag.h
@@ -21,35 +21,40 @@
 
 // IWYU pragma: private
 
-namespace grpc {
+namespace grpc
+{
 
-namespace internal {
-/// An interface allowing implementors to process and filter event tags.
-class CompletionQueueTag {
- public:
-  virtual ~CompletionQueueTag() {}
+    namespace internal
+    {
+        /// An interface allowing implementors to process and filter event tags.
+        class CompletionQueueTag
+        {
+        public:
+            virtual ~CompletionQueueTag()
+            {
+            }
 
-  /// FinalizeResult must be called before informing user code that the
-  /// operation bound to the underlying core completion queue tag has
-  /// completed. In practice, this means:
-  ///
-  ///   1. For the sync API - before returning from Pluck
-  ///   2. For the CQ-based async API - before returning from Next
-  ///   3. For the callback-based API - before invoking the user callback
-  ///
-  /// This is the method that translates from core-side tag/status to
-  /// C++ API-observable tag/status.
-  ///
-  /// The return value is the status of the operation (returning status is the
-  /// general behavior of this function). If this function returns false, the
-  /// tag is dropped and not returned from the completion queue: this concept is
-  /// for events that are observed at core but not requested by the user
-  /// application (e.g., server shutdown, for server unimplemented method
-  /// responses, or for cases where a server-side RPC doesn't have a completion
-  /// notification registered using AsyncNotifyWhenDone)
-  virtual bool FinalizeResult(void** tag, bool* status) = 0;
-};
-}  // namespace internal
+            /// FinalizeResult must be called before informing user code that the
+            /// operation bound to the underlying core completion queue tag has
+            /// completed. In practice, this means:
+            ///
+            ///   1. For the sync API - before returning from Pluck
+            ///   2. For the CQ-based async API - before returning from Next
+            ///   3. For the callback-based API - before invoking the user callback
+            ///
+            /// This is the method that translates from core-side tag/status to
+            /// C++ API-observable tag/status.
+            ///
+            /// The return value is the status of the operation (returning status is the
+            /// general behavior of this function). If this function returns false, the
+            /// tag is dropped and not returned from the completion queue: this concept is
+            /// for events that are observed at core but not requested by the user
+            /// application (e.g., server shutdown, for server unimplemented method
+            /// responses, or for cases where a server-side RPC doesn't have a completion
+            /// notification registered using AsyncNotifyWhenDone)
+            virtual bool FinalizeResult(void** tag, bool* status) = 0;
+        };
+    }  // namespace internal
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config.h
index d810cfa..3a4c2f2 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config.h
@@ -33,13 +33,14 @@
 #warning GRPC_CUSTOM_STRING is no longer supported. Please use std::string.
 #endif
 
-namespace grpc {
-
-// Using grpc::string and grpc::to_string is discouraged in favor of
-// std::string and std::to_string. This is only for legacy code using
-// them explictly.
-using std::string;     // deprecated // NOLINT(misc-unused-using-decls)
-using std::to_string;  // deprecated // NOLINT(misc-unused-using-decls)
+namespace grpc
+{
+
+    // Using grpc::string and grpc::to_string is discouraged in favor of
+    // std::string and std::to_string. This is only for legacy code using
+    // them explictly.
+    using std::string;     // deprecated // NOLINT(misc-unused-using-decls)
+    using std::to_string;  // deprecated // NOLINT(misc-unused-using-decls)
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config_protobuf.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config_protobuf.h
index da874c5..568c0cf 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config_protobuf.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/config_protobuf.h
@@ -52,16 +52,16 @@
 #include <google/protobuf/descriptor_database.h>
 #define GRPC_CUSTOM_DESCRIPTORDATABASE ::google::protobuf::DescriptorDatabase
 #define GRPC_CUSTOM_SIMPLEDESCRIPTORDATABASE \
-  ::google::protobuf::SimpleDescriptorDatabase
+    ::google::protobuf::SimpleDescriptorDatabase
 #endif
 
 #ifndef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/io/zero_copy_stream.h>
 #define GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM \
-  ::google::protobuf::io::ZeroCopyOutputStream
+    ::google::protobuf::io::ZeroCopyOutputStream
 #define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM \
-  ::google::protobuf::io::ZeroCopyInputStream
+    ::google::protobuf::io::ZeroCopyInputStream
 #define GRPC_CUSTOM_CODEDINPUTSTREAM ::google::protobuf::io::CodedInputStream
 #endif
 
@@ -72,37 +72,41 @@
 #define GRPC_CUSTOM_UTIL_STATUS ::google::protobuf::util::Status
 #endif
 
-namespace grpc {
-namespace protobuf {
-
-typedef GRPC_CUSTOM_MESSAGE Message;
-typedef GRPC_CUSTOM_MESSAGELITE MessageLite;
-
-typedef GRPC_CUSTOM_DESCRIPTOR Descriptor;
-typedef GRPC_CUSTOM_DESCRIPTORPOOL DescriptorPool;
-typedef GRPC_CUSTOM_DESCRIPTORDATABASE DescriptorDatabase;
-typedef GRPC_CUSTOM_FIELDDESCRIPTOR FieldDescriptor;
-typedef GRPC_CUSTOM_FILEDESCRIPTOR FileDescriptor;
-typedef GRPC_CUSTOM_FILEDESCRIPTORPROTO FileDescriptorProto;
-typedef GRPC_CUSTOM_METHODDESCRIPTOR MethodDescriptor;
-typedef GRPC_CUSTOM_SERVICEDESCRIPTOR ServiceDescriptor;
-typedef GRPC_CUSTOM_SIMPLEDESCRIPTORDATABASE SimpleDescriptorDatabase;
-typedef GRPC_CUSTOM_SOURCELOCATION SourceLocation;
-
-namespace util {
-typedef GRPC_CUSTOM_UTIL_STATUS Status;
-}  // namespace util
-
-// NOLINTNEXTLINE(misc-unused-alias-decls)
-namespace json = GRPC_CUSTOM_JSONUTIL;
-
-namespace io {
-typedef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM ZeroCopyOutputStream;
-typedef GRPC_CUSTOM_ZEROCOPYINPUTSTREAM ZeroCopyInputStream;
-typedef GRPC_CUSTOM_CODEDINPUTSTREAM CodedInputStream;
-}  // namespace io
-
-}  // namespace protobuf
+namespace grpc
+{
+    namespace protobuf
+    {
+
+        typedef GRPC_CUSTOM_MESSAGE Message;
+        typedef GRPC_CUSTOM_MESSAGELITE MessageLite;
+
+        typedef GRPC_CUSTOM_DESCRIPTOR Descriptor;
+        typedef GRPC_CUSTOM_DESCRIPTORPOOL DescriptorPool;
+        typedef GRPC_CUSTOM_DESCRIPTORDATABASE DescriptorDatabase;
+        typedef GRPC_CUSTOM_FIELDDESCRIPTOR FieldDescriptor;
+        typedef GRPC_CUSTOM_FILEDESCRIPTOR FileDescriptor;
+        typedef GRPC_CUSTOM_FILEDESCRIPTORPROTO FileDescriptorProto;
+        typedef GRPC_CUSTOM_METHODDESCRIPTOR MethodDescriptor;
+        typedef GRPC_CUSTOM_SERVICEDESCRIPTOR ServiceDescriptor;
+        typedef GRPC_CUSTOM_SIMPLEDESCRIPTORDATABASE SimpleDescriptorDatabase;
+        typedef GRPC_CUSTOM_SOURCELOCATION SourceLocation;
+
+        namespace util
+        {
+            typedef GRPC_CUSTOM_UTIL_STATUS Status;
+        }  // namespace util
+
+        // NOLINTNEXTLINE(misc-unused-alias-decls)
+        namespace json = GRPC_CUSTOM_JSONUTIL;
+
+        namespace io
+        {
+            typedef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM ZeroCopyOutputStream;
+            typedef GRPC_CUSTOM_ZEROCOPYINPUTSTREAM ZeroCopyInputStream;
+            typedef GRPC_CUSTOM_CODEDINPUTSTREAM CodedInputStream;
+        }  // namespace io
+
+    }  // namespace protobuf
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_CONFIG_PROTOBUF_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen.h
index 340dc47..2db0693 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen.h
@@ -28,103 +28,92 @@
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpcpp/impl/codegen/core_codegen_interface.h>
 
-namespace grpc {
-
-/// Implementation of the core codegen interface.
-class CoreCodegen final : public CoreCodegenInterface {
- private:
-  const grpc_completion_queue_factory* grpc_completion_queue_factory_lookup(
-      const grpc_completion_queue_attributes* attributes) override;
-  grpc_completion_queue* grpc_completion_queue_create(
-      const grpc_completion_queue_factory* factory,
-      const grpc_completion_queue_attributes* attributes,
-      void* reserved) override;
-  grpc_completion_queue* grpc_completion_queue_create_for_next(
-      void* reserved) override;
-  grpc_completion_queue* grpc_completion_queue_create_for_pluck(
-      void* reserved) override;
-  void grpc_completion_queue_shutdown(grpc_completion_queue* cq) override;
-  void grpc_completion_queue_destroy(grpc_completion_queue* cq) override;
-  grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
-                                         gpr_timespec deadline,
-                                         void* reserved) override;
-
-  void* gpr_malloc(size_t size) override;
-  void gpr_free(void* p) override;
-
-  void grpc_init() override;
-  void grpc_shutdown() override;
-
-  void gpr_mu_init(gpr_mu* mu) override;
-  void gpr_mu_destroy(gpr_mu* mu) override;
-  void gpr_mu_lock(gpr_mu* mu) override;
-  void gpr_mu_unlock(gpr_mu* mu) override;
-  void gpr_cv_init(gpr_cv* cv) override;
-  void gpr_cv_destroy(gpr_cv* cv) override;
-  int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) override;
-  void gpr_cv_signal(gpr_cv* cv) override;
-  void gpr_cv_broadcast(gpr_cv* cv) override;
-
-  grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops,
-                                        size_t nops, void* tag,
-                                        void* reserved) override;
-  grpc_call_error grpc_call_cancel_with_status(grpc_call* call,
-                                               grpc_status_code status,
-                                               const char* description,
-                                               void* reserved) override;
-  int grpc_call_failed_before_recv_message(const grpc_call* c) override;
-  void grpc_call_ref(grpc_call* call) override;
-  void grpc_call_unref(grpc_call* call) override;
-  void* grpc_call_arena_alloc(grpc_call* call, size_t length) override;
-  const char* grpc_call_error_to_string(grpc_call_error error) override;
-
-  grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb) override;
-  void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) override;
-  size_t grpc_byte_buffer_length(grpc_byte_buffer* bb) override;
-
-  int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
-                                   grpc_byte_buffer* buffer) override;
-  void grpc_byte_buffer_reader_destroy(
-      grpc_byte_buffer_reader* reader) override;
-  int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
-                                   grpc_slice* slice) override;
-  int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader,
-                                   grpc_slice** slice) override;
-
-  grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slice,
-                                                size_t nslices) override;
-  grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
-                                           void (*destroy)(void*),
-                                           void* user_data) override;
-  grpc_slice grpc_slice_new_with_len(void* p, size_t len,
-                                     void (*destroy)(void*, size_t)) override;
-  grpc_slice grpc_empty_slice() override;
-  grpc_slice grpc_slice_malloc(size_t length) override;
-  void grpc_slice_unref(grpc_slice slice) override;
-  grpc_slice grpc_slice_ref(grpc_slice slice) override;
-  grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split) override;
-  grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split) override;
-  grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end) override;
-  void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice) override;
-  void grpc_slice_buffer_pop(grpc_slice_buffer* sb) override;
-  void grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb,
-                                     grpc_slice slice) override;
-  grpc_slice grpc_slice_from_static_buffer(const void* buffer,
-                                           size_t length) override;
-  grpc_slice grpc_slice_from_copied_buffer(const void* buffer,
-                                           size_t length) override;
-  void grpc_metadata_array_init(grpc_metadata_array* array) override;
-  void grpc_metadata_array_destroy(grpc_metadata_array* array) override;
-
-  gpr_timespec gpr_inf_future(gpr_clock_type type) override;
-  gpr_timespec gpr_time_0(gpr_clock_type type) override;
-
-  const Status& ok() override;
-  const Status& cancelled() override;
-
-  void assert_fail(const char* failed_assertion, const char* file,
-                   int line) override;
-};
+namespace grpc
+{
+
+    /// Implementation of the core codegen interface.
+    class CoreCodegen final : public CoreCodegenInterface
+    {
+    private:
+        const grpc_completion_queue_factory* grpc_completion_queue_factory_lookup(
+            const grpc_completion_queue_attributes* attributes
+        ) override;
+        grpc_completion_queue* grpc_completion_queue_create(
+            const grpc_completion_queue_factory* factory,
+            const grpc_completion_queue_attributes* attributes,
+            void* reserved
+        ) override;
+        grpc_completion_queue* grpc_completion_queue_create_for_next(
+            void* reserved
+        ) override;
+        grpc_completion_queue* grpc_completion_queue_create_for_pluck(
+            void* reserved
+        ) override;
+        void grpc_completion_queue_shutdown(grpc_completion_queue* cq) override;
+        void grpc_completion_queue_destroy(grpc_completion_queue* cq) override;
+        grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag, gpr_timespec deadline, void* reserved) override;
+
+        void* gpr_malloc(size_t size) override;
+        void gpr_free(void* p) override;
+
+        void grpc_init() override;
+        void grpc_shutdown() override;
+
+        void gpr_mu_init(gpr_mu* mu) override;
+        void gpr_mu_destroy(gpr_mu* mu) override;
+        void gpr_mu_lock(gpr_mu* mu) override;
+        void gpr_mu_unlock(gpr_mu* mu) override;
+        void gpr_cv_init(gpr_cv* cv) override;
+        void gpr_cv_destroy(gpr_cv* cv) override;
+        int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) override;
+        void gpr_cv_signal(gpr_cv* cv) override;
+        void gpr_cv_broadcast(gpr_cv* cv) override;
+
+        grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops, size_t nops, void* tag, void* reserved) override;
+        grpc_call_error grpc_call_cancel_with_status(grpc_call* call, grpc_status_code status, const char* description, void* reserved) override;
+        int grpc_call_failed_before_recv_message(const grpc_call* c) override;
+        void grpc_call_ref(grpc_call* call) override;
+        void grpc_call_unref(grpc_call* call) override;
+        void* grpc_call_arena_alloc(grpc_call* call, size_t length) override;
+        const char* grpc_call_error_to_string(grpc_call_error error) override;
+
+        grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb) override;
+        void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) override;
+        size_t grpc_byte_buffer_length(grpc_byte_buffer* bb) override;
+
+        int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader, grpc_byte_buffer* buffer) override;
+        void grpc_byte_buffer_reader_destroy(
+            grpc_byte_buffer_reader* reader
+        ) override;
+        int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader, grpc_slice* slice) override;
+        int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader, grpc_slice** slice) override;
+
+        grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slice, size_t nslices) override;
+        grpc_slice grpc_slice_new_with_user_data(void* p, size_t len, void (*destroy)(void*), void* user_data) override;
+        grpc_slice grpc_slice_new_with_len(void* p, size_t len, void (*destroy)(void*, size_t)) override;
+        grpc_slice grpc_empty_slice() override;
+        grpc_slice grpc_slice_malloc(size_t length) override;
+        void grpc_slice_unref(grpc_slice slice) override;
+        grpc_slice grpc_slice_ref(grpc_slice slice) override;
+        grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split) override;
+        grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split) override;
+        grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end) override;
+        void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice) override;
+        void grpc_slice_buffer_pop(grpc_slice_buffer* sb) override;
+        void grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, grpc_slice slice) override;
+        grpc_slice grpc_slice_from_static_buffer(const void* buffer, size_t length) override;
+        grpc_slice grpc_slice_from_copied_buffer(const void* buffer, size_t length) override;
+        void grpc_metadata_array_init(grpc_metadata_array* array) override;
+        void grpc_metadata_array_destroy(grpc_metadata_array* array) override;
+
+        gpr_timespec gpr_inf_future(gpr_clock_type type) override;
+        gpr_timespec gpr_time_0(gpr_clock_type type) override;
+
+        const Status& ok() override;
+        const Status& cancelled() override;
+
+        void assert_fail(const char* failed_assertion, const char* file, int line) override;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen_interface.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen_interface.h
index 5ca1fef..789b09d 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen_interface.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/core_codegen_interface.h
@@ -28,140 +28,129 @@
 #include <grpcpp/impl/codegen/config.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-
-/// Interface between the codegen library and the minimal subset of core
-/// features required by the generated code.
-///
-/// All undocumented methods are simply forwarding the call to their namesakes.
-/// Please refer to their corresponding documentation for details.
-///
-/// \warning This interface should be considered internal and private.
-class CoreCodegenInterface {
- public:
-  virtual ~CoreCodegenInterface() = default;
-
-  /// Upon a failed assertion, log the error.
-  virtual void assert_fail(const char* failed_assertion, const char* file,
-                           int line) = 0;
-
-  virtual const grpc_completion_queue_factory*
-  grpc_completion_queue_factory_lookup(
-      const grpc_completion_queue_attributes* attributes) = 0;
-  virtual grpc_completion_queue* grpc_completion_queue_create(
-      const grpc_completion_queue_factory* factory,
-      const grpc_completion_queue_attributes* attributes, void* reserved) = 0;
-  virtual grpc_completion_queue* grpc_completion_queue_create_for_next(
-      void* reserved) = 0;
-  virtual grpc_completion_queue* grpc_completion_queue_create_for_pluck(
-      void* reserved) = 0;
-  virtual void grpc_completion_queue_shutdown(grpc_completion_queue* cq) = 0;
-  virtual void grpc_completion_queue_destroy(grpc_completion_queue* cq) = 0;
-  virtual grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq,
-                                                 void* tag,
-                                                 gpr_timespec deadline,
-                                                 void* reserved) = 0;
-
-  virtual void* gpr_malloc(size_t size) = 0;
-  virtual void gpr_free(void* p) = 0;
-
-  // These are only to be used to fix edge cases involving grpc_init and
-  // grpc_shutdown. Calling grpc_init from the codegen interface before
-  // the real grpc_init is called will cause a crash, so if you use this
-  // function, ensure that it is not the first call to grpc_init.
-  virtual void grpc_init() = 0;
-  virtual void grpc_shutdown() = 0;
-
-  virtual void gpr_mu_init(gpr_mu* mu) = 0;
-  virtual void gpr_mu_destroy(gpr_mu* mu) = 0;
-  virtual void gpr_mu_lock(gpr_mu* mu) = 0;
-  virtual void gpr_mu_unlock(gpr_mu* mu) = 0;
-  virtual void gpr_cv_init(gpr_cv* cv) = 0;
-  virtual void gpr_cv_destroy(gpr_cv* cv) = 0;
-  virtual int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu,
-                          gpr_timespec abs_deadline) = 0;
-  virtual void gpr_cv_signal(gpr_cv* cv) = 0;
-  virtual void gpr_cv_broadcast(gpr_cv* cv) = 0;
-
-  virtual grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb) = 0;
-  virtual void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) = 0;
-  virtual size_t grpc_byte_buffer_length(grpc_byte_buffer* bb)
-      GRPC_MUST_USE_RESULT = 0;
-
-  virtual int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
-                                           grpc_byte_buffer* buffer)
-      GRPC_MUST_USE_RESULT = 0;
-  virtual void grpc_byte_buffer_reader_destroy(
-      grpc_byte_buffer_reader* reader) = 0;
-  virtual int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
-                                           grpc_slice* slice) = 0;
-  virtual int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader,
-                                           grpc_slice** slice) = 0;
-
-  virtual grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slice,
-                                                        size_t nslices) = 0;
-  virtual grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
-                                                   void (*destroy)(void*),
-                                                   void* user_data) = 0;
-  virtual grpc_slice grpc_slice_new_with_len(void* p, size_t len,
-                                             void (*destroy)(void*,
-                                                             size_t)) = 0;
-  virtual grpc_call_error grpc_call_start_batch(grpc_call* call,
-                                                const grpc_op* ops, size_t nops,
-                                                void* tag, void* reserved) = 0;
-  virtual grpc_call_error grpc_call_cancel_with_status(grpc_call* call,
-                                                       grpc_status_code status,
-                                                       const char* description,
-                                                       void* reserved) = 0;
-  virtual int grpc_call_failed_before_recv_message(const grpc_call* c) = 0;
-  virtual void grpc_call_ref(grpc_call* call) = 0;
-  virtual void grpc_call_unref(grpc_call* call) = 0;
-  virtual void* grpc_call_arena_alloc(grpc_call* call, size_t length) = 0;
-  virtual const char* grpc_call_error_to_string(grpc_call_error error) = 0;
-  virtual grpc_slice grpc_empty_slice() = 0;
-  virtual grpc_slice grpc_slice_malloc(size_t length) = 0;
-  virtual void grpc_slice_unref(grpc_slice slice) = 0;
-  virtual grpc_slice grpc_slice_ref(grpc_slice slice) = 0;
-  virtual grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split) = 0;
-  virtual grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split) = 0;
-  virtual grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end) = 0;
-  virtual void grpc_slice_buffer_add(grpc_slice_buffer* sb,
-                                     grpc_slice slice) = 0;
-  virtual void grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb,
-                                             grpc_slice slice) = 0;
-  virtual void grpc_slice_buffer_pop(grpc_slice_buffer* sb) = 0;
-  virtual grpc_slice grpc_slice_from_static_buffer(const void* buffer,
-                                                   size_t length) = 0;
-  virtual grpc_slice grpc_slice_from_copied_buffer(const void* buffer,
-                                                   size_t length) = 0;
-
-  virtual void grpc_metadata_array_init(grpc_metadata_array* array) = 0;
-  virtual void grpc_metadata_array_destroy(grpc_metadata_array* array) = 0;
-
-  virtual const Status& ok() = 0;
-  virtual const Status& cancelled() = 0;
-
-  virtual gpr_timespec gpr_inf_future(gpr_clock_type type) = 0;
-  virtual gpr_timespec gpr_time_0(gpr_clock_type type) = 0;
-};
-
-extern CoreCodegenInterface* g_core_codegen_interface;
+namespace grpc
+{
+
+    /// Interface between the codegen library and the minimal subset of core
+    /// features required by the generated code.
+    ///
+    /// All undocumented methods are simply forwarding the call to their namesakes.
+    /// Please refer to their corresponding documentation for details.
+    ///
+    /// \warning This interface should be considered internal and private.
+    class CoreCodegenInterface
+    {
+    public:
+        virtual ~CoreCodegenInterface() = default;
+
+        /// Upon a failed assertion, log the error.
+        virtual void assert_fail(const char* failed_assertion, const char* file, int line) = 0;
+
+        virtual const grpc_completion_queue_factory*
+            grpc_completion_queue_factory_lookup(
+                const grpc_completion_queue_attributes* attributes
+            ) = 0;
+        virtual grpc_completion_queue* grpc_completion_queue_create(
+            const grpc_completion_queue_factory* factory,
+            const grpc_completion_queue_attributes* attributes,
+            void* reserved
+        ) = 0;
+        virtual grpc_completion_queue* grpc_completion_queue_create_for_next(
+            void* reserved
+        ) = 0;
+        virtual grpc_completion_queue* grpc_completion_queue_create_for_pluck(
+            void* reserved
+        ) = 0;
+        virtual void grpc_completion_queue_shutdown(grpc_completion_queue* cq) = 0;
+        virtual void grpc_completion_queue_destroy(grpc_completion_queue* cq) = 0;
+        virtual grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag, gpr_timespec deadline, void* reserved) = 0;
+
+        virtual void* gpr_malloc(size_t size) = 0;
+        virtual void gpr_free(void* p) = 0;
+
+        // These are only to be used to fix edge cases involving grpc_init and
+        // grpc_shutdown. Calling grpc_init from the codegen interface before
+        // the real grpc_init is called will cause a crash, so if you use this
+        // function, ensure that it is not the first call to grpc_init.
+        virtual void grpc_init() = 0;
+        virtual void grpc_shutdown() = 0;
+
+        virtual void gpr_mu_init(gpr_mu* mu) = 0;
+        virtual void gpr_mu_destroy(gpr_mu* mu) = 0;
+        virtual void gpr_mu_lock(gpr_mu* mu) = 0;
+        virtual void gpr_mu_unlock(gpr_mu* mu) = 0;
+        virtual void gpr_cv_init(gpr_cv* cv) = 0;
+        virtual void gpr_cv_destroy(gpr_cv* cv) = 0;
+        virtual int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) = 0;
+        virtual void gpr_cv_signal(gpr_cv* cv) = 0;
+        virtual void gpr_cv_broadcast(gpr_cv* cv) = 0;
+
+        virtual grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb) = 0;
+        virtual void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) = 0;
+        virtual size_t grpc_byte_buffer_length(grpc_byte_buffer* bb)
+            GRPC_MUST_USE_RESULT = 0;
+
+        virtual int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader, grpc_byte_buffer* buffer)
+            GRPC_MUST_USE_RESULT = 0;
+        virtual void grpc_byte_buffer_reader_destroy(
+            grpc_byte_buffer_reader* reader
+        ) = 0;
+        virtual int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader, grpc_slice* slice) = 0;
+        virtual int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader, grpc_slice** slice) = 0;
+
+        virtual grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slice, size_t nslices) = 0;
+        virtual grpc_slice grpc_slice_new_with_user_data(void* p, size_t len, void (*destroy)(void*), void* user_data) = 0;
+        virtual grpc_slice grpc_slice_new_with_len(void* p, size_t len, void (*destroy)(void*, size_t)) = 0;
+        virtual grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops, size_t nops, void* tag, void* reserved) = 0;
+        virtual grpc_call_error grpc_call_cancel_with_status(grpc_call* call, grpc_status_code status, const char* description, void* reserved) = 0;
+        virtual int grpc_call_failed_before_recv_message(const grpc_call* c) = 0;
+        virtual void grpc_call_ref(grpc_call* call) = 0;
+        virtual void grpc_call_unref(grpc_call* call) = 0;
+        virtual void* grpc_call_arena_alloc(grpc_call* call, size_t length) = 0;
+        virtual const char* grpc_call_error_to_string(grpc_call_error error) = 0;
+        virtual grpc_slice grpc_empty_slice() = 0;
+        virtual grpc_slice grpc_slice_malloc(size_t length) = 0;
+        virtual void grpc_slice_unref(grpc_slice slice) = 0;
+        virtual grpc_slice grpc_slice_ref(grpc_slice slice) = 0;
+        virtual grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split) = 0;
+        virtual grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split) = 0;
+        virtual grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end) = 0;
+        virtual void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice) = 0;
+        virtual void grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, grpc_slice slice) = 0;
+        virtual void grpc_slice_buffer_pop(grpc_slice_buffer* sb) = 0;
+        virtual grpc_slice grpc_slice_from_static_buffer(const void* buffer, size_t length) = 0;
+        virtual grpc_slice grpc_slice_from_copied_buffer(const void* buffer, size_t length) = 0;
+
+        virtual void grpc_metadata_array_init(grpc_metadata_array* array) = 0;
+        virtual void grpc_metadata_array_destroy(grpc_metadata_array* array) = 0;
+
+        virtual const Status& ok() = 0;
+        virtual const Status& cancelled() = 0;
+
+        virtual gpr_timespec gpr_inf_future(gpr_clock_type type) = 0;
+        virtual gpr_timespec gpr_time_0(gpr_clock_type type) = 0;
+    };
+
+    extern CoreCodegenInterface* g_core_codegen_interface;
 
 /// Codegen specific version of \a GPR_ASSERT.
-#define GPR_CODEGEN_ASSERT(x)                                              \
-  do {                                                                     \
-    if (GPR_UNLIKELY(!(x))) {                                              \
-      grpc::g_core_codegen_interface->assert_fail(#x, __FILE__, __LINE__); \
-    }                                                                      \
-  } while (0)
+#define GPR_CODEGEN_ASSERT(x)                                                    \
+    do                                                                           \
+    {                                                                            \
+        if (GPR_UNLIKELY(!(x)))                                                  \
+        {                                                                        \
+            grpc::g_core_codegen_interface->assert_fail(#x, __FILE__, __LINE__); \
+        }                                                                        \
+    } while (0)
 
 /// Codegen specific version of \a GPR_DEBUG_ASSERT.
 #ifndef NDEBUG
 #define GPR_CODEGEN_DEBUG_ASSERT(x) GPR_CODEGEN_ASSERT(x)
 #else
 #define GPR_CODEGEN_DEBUG_ASSERT(x) \
-  do {                              \
-  } while (0)
+    do                              \
+    {                               \
+    } while (0)
 #endif
 
 }  // namespace grpc
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/create_auth_context.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/create_auth_context.h
index 817988f..01a013f 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/create_auth_context.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/create_auth_context.h
@@ -26,9 +26,10 @@
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpcpp/impl/codegen/security/auth_context.h>
 
-namespace grpc {
+namespace grpc
+{
 
-std::shared_ptr<const AuthContext> CreateAuthContext(grpc_call* call);
+    std::shared_ptr<const AuthContext> CreateAuthContext(grpc_call* call);
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/delegating_channel.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/delegating_channel.h
index 5e63d54..3fb5f99 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/delegating_channel.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/delegating_channel.h
@@ -25,69 +25,75 @@
 
 #include <grpcpp/impl/codegen/channel_interface.h>
 
-namespace grpc {
-namespace experimental {
-
-class DelegatingChannel : public grpc::ChannelInterface {
- public:
-  ~DelegatingChannel() override {}
-
-  explicit DelegatingChannel(
-      std::shared_ptr<grpc::ChannelInterface> delegate_channel)
-      : delegate_channel_(delegate_channel) {}
-
-  grpc_connectivity_state GetState(bool try_to_connect) override {
-    return delegate_channel()->GetState(try_to_connect);
-  }
-
-  std::shared_ptr<grpc::ChannelInterface> delegate_channel() {
-    return delegate_channel_;
-  }
-
- private:
-  internal::Call CreateCall(const internal::RpcMethod& method,
-                            ClientContext* context,
-                            grpc::CompletionQueue* cq) final {
-    return delegate_channel()->CreateCall(method, context, cq);
-  }
-
-  void PerformOpsOnCall(internal::CallOpSetInterface* ops,
-                        internal::Call* call) final {
-    delegate_channel()->PerformOpsOnCall(ops, call);
-  }
-
-  void* RegisterMethod(const char* method) final {
-    return delegate_channel()->RegisterMethod(method);
-  }
-
-  void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
-                               gpr_timespec deadline, grpc::CompletionQueue* cq,
-                               void* tag) override {
-    delegate_channel()->NotifyOnStateChangeImpl(last_observed, deadline, cq,
-                                                tag);
-  }
-
-  bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
-                              gpr_timespec deadline) override {
-    return delegate_channel()->WaitForStateChangeImpl(last_observed, deadline);
-  }
-
-  internal::Call CreateCallInternal(const internal::RpcMethod& method,
-                                    ClientContext* context,
-                                    grpc::CompletionQueue* cq,
-                                    size_t interceptor_pos) final {
-    return delegate_channel()->CreateCallInternal(method, context, cq,
-                                                  interceptor_pos);
-  }
-
-  grpc::CompletionQueue* CallbackCQ() final {
-    return delegate_channel()->CallbackCQ();
-  }
-
-  std::shared_ptr<grpc::ChannelInterface> delegate_channel_;
-};
-
-}  // namespace experimental
+namespace grpc
+{
+    namespace experimental
+    {
+
+        class DelegatingChannel : public grpc::ChannelInterface
+        {
+        public:
+            ~DelegatingChannel() override
+            {
+            }
+
+            explicit DelegatingChannel(
+                std::shared_ptr<grpc::ChannelInterface> delegate_channel
+            ) :
+                delegate_channel_(delegate_channel)
+            {
+            }
+
+            grpc_connectivity_state GetState(bool try_to_connect) override
+            {
+                return delegate_channel()->GetState(try_to_connect);
+            }
+
+            std::shared_ptr<grpc::ChannelInterface> delegate_channel()
+            {
+                return delegate_channel_;
+            }
+
+        private:
+            internal::Call CreateCall(const internal::RpcMethod& method, ClientContext* context, grpc::CompletionQueue* cq) final
+            {
+                return delegate_channel()->CreateCall(method, context, cq);
+            }
+
+            void PerformOpsOnCall(internal::CallOpSetInterface* ops, internal::Call* call) final
+            {
+                delegate_channel()->PerformOpsOnCall(ops, call);
+            }
+
+            void* RegisterMethod(const char* method) final
+            {
+                return delegate_channel()->RegisterMethod(method);
+            }
+
+            void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, gpr_timespec deadline, grpc::CompletionQueue* cq, void* tag) override
+            {
+                delegate_channel()->NotifyOnStateChangeImpl(last_observed, deadline, cq, tag);
+            }
+
+            bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, gpr_timespec deadline) override
+            {
+                return delegate_channel()->WaitForStateChangeImpl(last_observed, deadline);
+            }
+
+            internal::Call CreateCallInternal(const internal::RpcMethod& method, ClientContext* context, grpc::CompletionQueue* cq, size_t interceptor_pos) final
+            {
+                return delegate_channel()->CreateCallInternal(method, context, cq, interceptor_pos);
+            }
+
+            grpc::CompletionQueue* CallbackCQ() final
+            {
+                return delegate_channel()->CallbackCQ();
+            }
+
+            std::shared_ptr<grpc::ChannelInterface> delegate_channel_;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_DELEGATING_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/grpc_library.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/grpc_library.h
index 9f83a7f..e915c25 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/grpc_library.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/grpc_library.h
@@ -23,44 +23,49 @@
 
 #include <grpcpp/impl/codegen/core_codegen_interface.h>
 
-namespace grpc {
+namespace grpc
+{
 
-class GrpcLibraryInterface {
- public:
-  virtual ~GrpcLibraryInterface() = default;
-  virtual void init() = 0;
-  virtual void shutdown() = 0;
-};
+    class GrpcLibraryInterface
+    {
+    public:
+        virtual ~GrpcLibraryInterface() = default;
+        virtual void init() = 0;
+        virtual void shutdown() = 0;
+    };
 
-/// Initialized by \a grpc::GrpcLibraryInitializer from
-/// <grpcpp/impl/grpc_library.h>
-extern GrpcLibraryInterface* g_glip;
+    /// Initialized by \a grpc::GrpcLibraryInitializer from
+    /// <grpcpp/impl/grpc_library.h>
+    extern GrpcLibraryInterface* g_glip;
 
-/// Classes that require gRPC to be initialized should inherit from this class.
-class GrpcLibraryCodegen {
- public:
-  explicit GrpcLibraryCodegen(bool call_grpc_init = true)
-      : grpc_init_called_(false) {
-    if (call_grpc_init) {
-      GPR_CODEGEN_ASSERT(g_glip &&
-                         "gRPC library not initialized. See "
-                         "grpc::internal::GrpcLibraryInitializer.");
-      g_glip->init();
-      grpc_init_called_ = true;
-    }
-  }
-  virtual ~GrpcLibraryCodegen() {
-    if (grpc_init_called_) {
-      GPR_CODEGEN_ASSERT(g_glip &&
-                         "gRPC library not initialized. See "
-                         "grpc::internal::GrpcLibraryInitializer.");
-      g_glip->shutdown();
-    }
-  }
+    /// Classes that require gRPC to be initialized should inherit from this class.
+    class GrpcLibraryCodegen
+    {
+    public:
+        explicit GrpcLibraryCodegen(bool call_grpc_init = true) :
+            grpc_init_called_(false)
+        {
+            if (call_grpc_init)
+            {
+                GPR_CODEGEN_ASSERT(g_glip && "gRPC library not initialized. See "
+                                             "grpc::internal::GrpcLibraryInitializer.");
+                g_glip->init();
+                grpc_init_called_ = true;
+            }
+        }
+        virtual ~GrpcLibraryCodegen()
+        {
+            if (grpc_init_called_)
+            {
+                GPR_CODEGEN_ASSERT(g_glip && "gRPC library not initialized. See "
+                                             "grpc::internal::GrpcLibraryInitializer.");
+                g_glip->shutdown();
+            }
+        }
 
- private:
-  bool grpc_init_called_;
-};
+    private:
+        bool grpc_init_called_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/intercepted_channel.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/intercepted_channel.h
index 57c97dd..204d797 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/intercepted_channel.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/intercepted_channel.h
@@ -23,63 +23,75 @@
 
 #include <grpcpp/impl/codegen/channel_interface.h>
 
-namespace grpc {
-class CompletionQueue;
-
-namespace internal {
-
-class InterceptorBatchMethodsImpl;
-
-/// An InterceptedChannel is available to client Interceptors. An
-/// InterceptedChannel is unique to an interceptor, and when an RPC is started
-/// on this channel, only those interceptors that come after this interceptor
-/// see the RPC.
-class InterceptedChannel : public ChannelInterface {
- public:
-  ~InterceptedChannel() override { channel_ = nullptr; }
-
-  /// Get the current channel state. If the channel is in IDLE and
-  /// \a try_to_connect is set to true, try to connect.
-  grpc_connectivity_state GetState(bool try_to_connect) override {
-    return channel_->GetState(try_to_connect);
-  }
-
- private:
-  InterceptedChannel(ChannelInterface* channel, size_t pos)
-      : channel_(channel), interceptor_pos_(pos) {}
-
-  Call CreateCall(const RpcMethod& method, grpc::ClientContext* context,
-                  grpc::CompletionQueue* cq) override {
-    return channel_->CreateCallInternal(method, context, cq, interceptor_pos_);
-  }
-
-  void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) override {
-    return channel_->PerformOpsOnCall(ops, call);
-  }
-  void* RegisterMethod(const char* method) override {
-    return channel_->RegisterMethod(method);
-  }
-
-  void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
-                               gpr_timespec deadline, grpc::CompletionQueue* cq,
-                               void* tag) override {
-    return channel_->NotifyOnStateChangeImpl(last_observed, deadline, cq, tag);
-  }
-  bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
-                              gpr_timespec deadline) override {
-    return channel_->WaitForStateChangeImpl(last_observed, deadline);
-  }
-
-  grpc::CompletionQueue* CallbackCQ() override {
-    return channel_->CallbackCQ();
-  }
-
-  ChannelInterface* channel_;
-  size_t interceptor_pos_;
-
-  friend class InterceptorBatchMethodsImpl;
-};
-}  // namespace internal
+namespace grpc
+{
+    class CompletionQueue;
+
+    namespace internal
+    {
+
+        class InterceptorBatchMethodsImpl;
+
+        /// An InterceptedChannel is available to client Interceptors. An
+        /// InterceptedChannel is unique to an interceptor, and when an RPC is started
+        /// on this channel, only those interceptors that come after this interceptor
+        /// see the RPC.
+        class InterceptedChannel : public ChannelInterface
+        {
+        public:
+            ~InterceptedChannel() override
+            {
+                channel_ = nullptr;
+            }
+
+            /// Get the current channel state. If the channel is in IDLE and
+            /// \a try_to_connect is set to true, try to connect.
+            grpc_connectivity_state GetState(bool try_to_connect) override
+            {
+                return channel_->GetState(try_to_connect);
+            }
+
+        private:
+            InterceptedChannel(ChannelInterface* channel, size_t pos) :
+                channel_(channel),
+                interceptor_pos_(pos)
+            {
+            }
+
+            Call CreateCall(const RpcMethod& method, grpc::ClientContext* context, grpc::CompletionQueue* cq) override
+            {
+                return channel_->CreateCallInternal(method, context, cq, interceptor_pos_);
+            }
+
+            void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) override
+            {
+                return channel_->PerformOpsOnCall(ops, call);
+            }
+            void* RegisterMethod(const char* method) override
+            {
+                return channel_->RegisterMethod(method);
+            }
+
+            void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, gpr_timespec deadline, grpc::CompletionQueue* cq, void* tag) override
+            {
+                return channel_->NotifyOnStateChangeImpl(last_observed, deadline, cq, tag);
+            }
+            bool WaitForStateChangeImpl(grpc_connectivity_state last_observed, gpr_timespec deadline) override
+            {
+                return channel_->WaitForStateChangeImpl(last_observed, deadline);
+            }
+
+            grpc::CompletionQueue* CallbackCQ() override
+            {
+                return channel_->CallbackCQ();
+            }
+
+            ChannelInterface* channel_;
+            size_t interceptor_pos_;
+
+            friend class InterceptorBatchMethodsImpl;
+        };
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_INTERCEPTED_CHANNEL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor.h
index 1445053..790edad 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor.h
@@ -32,202 +32,211 @@
 #include <grpcpp/impl/codegen/metadata_map.h>
 #include <grpcpp/impl/codegen/string_ref.h>
 
-namespace grpc {
-
-class ChannelInterface;
-class Status;
-
-namespace experimental {
-
-/// An enumeration of different possible points at which the \a Intercept
-/// method of the \a Interceptor interface may be called. Any given call
-/// to \a Intercept will include one or more of these hook points, and
-/// each hook point makes certain types of information available to the
-/// interceptor.
-/// In these enumeration names, PRE_SEND means that an interception has taken
-/// place between the time the application provided a certain type of data
-/// (e.g., initial metadata, status) and the time that that data goes to the
-/// other side. POST_SEND means that the data has been committed for going to
-/// the other side (even if it has not yet been received at the other side).
-/// PRE_RECV means an interception between the time that a certain
-/// operation has been requested and it is available. POST_RECV means that a
-/// result is available but has not yet been passed back to the application.
-/// A batch of interception points will only contain either PRE or POST hooks
-/// but not both types. For example, a batch with PRE_SEND hook points will not
-/// contain POST_RECV or POST_SEND ops. Likewise, a batch with POST_* ops can
-/// not contain PRE_* ops.
-enum class InterceptionHookPoints {
-  /// The first three in this list are for clients and servers
-  PRE_SEND_INITIAL_METADATA,
-  PRE_SEND_MESSAGE,
-  POST_SEND_MESSAGE,
-  PRE_SEND_STATUS,  // server only
-  PRE_SEND_CLOSE,   // client only: WritesDone for stream; after write in unary
-  /// The following three are for hijacked clients only. A batch with PRE_RECV_*
-  /// hook points will never contain hook points of other types.
-  PRE_RECV_INITIAL_METADATA,
-  PRE_RECV_MESSAGE,
-  PRE_RECV_STATUS,
-  /// The following two are for all clients and servers
-  POST_RECV_INITIAL_METADATA,
-  POST_RECV_MESSAGE,
-  POST_RECV_STATUS,  // client only
-  POST_RECV_CLOSE,   // server only
-  /// This is a special hook point available to both clients and servers when
-  /// TryCancel() is performed.
-  ///  - No other hook points will be present along with this.
-  ///  - It is illegal for an interceptor to block/delay this operation.
-  ///  - ALL interceptors see this hook point irrespective of whether the
-  ///    RPC was hijacked or not.
-  PRE_SEND_CANCEL,
-  NUM_INTERCEPTION_HOOKS
-};
-
-/// Class that is passed as an argument to the \a Intercept method
-/// of the application's \a Interceptor interface implementation. It has five
-/// purposes:
-///   1. Indicate which hook points are present at a specific interception
-///   2. Allow an interceptor to inform the library that an RPC should
-///      continue to the next stage of its processing (which may be another
-///      interceptor or the main path of the library)
-///   3. Allow an interceptor to hijack the processing of the RPC (only for
-///      client-side RPCs with PRE_SEND_INITIAL_METADATA) so that it does not
-///      proceed with normal processing beyond that stage
-///   4. Access the relevant fields of an RPC at each interception point
-///   5. Set some fields of an RPC at each interception point, when possible
-class InterceptorBatchMethods {
- public:
-  virtual ~InterceptorBatchMethods() {}
-  /// Determine whether the current batch has an interception hook point
-  /// of type \a type
-  virtual bool QueryInterceptionHookPoint(InterceptionHookPoints type) = 0;
-  /// Signal that the interceptor is done intercepting the current batch of the
-  /// RPC. Every interceptor must either call Proceed or Hijack on each
-  /// interception. In most cases, only Proceed will be used. Explicit use of
-  /// Proceed is what enables interceptors to delay the processing of RPCs
-  /// while they perform other work.
-  /// Proceed is a no-op if the batch contains PRE_SEND_CANCEL. Simply returning
-  /// from the Intercept method does the job of continuing the RPC in this case.
-  /// This is because PRE_SEND_CANCEL is always in a separate batch and is not
-  /// allowed to be delayed.
-  virtual void Proceed() = 0;
-  /// Indicate that the interceptor has hijacked the RPC (only valid if the
-  /// batch contains send_initial_metadata on the client side). Later
-  /// interceptors in the interceptor list will not be called. Later batches
-  /// on the same RPC will go through interception, but only up to the point
-  /// of the hijacking interceptor.
-  virtual void Hijack() = 0;
-
-  /// Send Message Methods
-  /// GetSerializedSendMessage and GetSendMessage/ModifySendMessage are the
-  /// available methods to view and modify the request payload. An interceptor
-  /// can access the payload in either serialized form or non-serialized form
-  /// but not both at the same time.
-  /// gRPC performs serialization in a lazy manner, which means
-  /// that a call to GetSerializedSendMessage will result in a serialization
-  /// operation if the payload stored is not in the serialized form already; the
-  /// non-serialized form will be lost and GetSendMessage will no longer return
-  /// a valid pointer, and this will remain true for later interceptors too.
-  /// This can change however if ModifySendMessage is used to replace the
-  /// current payload. Note that ModifySendMessage requires a new payload
-  /// message in the non-serialized form. This will overwrite the existing
-  /// payload irrespective of whether it had been serialized earlier. Also note
-  /// that gRPC Async API requires early serialization of the payload which
-  /// means that the payload would be available in the serialized form only
-  /// unless an interceptor replaces the payload with ModifySendMessage.
-
-  /// Returns a modifable ByteBuffer holding the serialized form of the message
-  /// that is going to be sent. Valid for PRE_SEND_MESSAGE interceptions.
-  /// A return value of nullptr indicates that this ByteBuffer is not valid.
-  virtual ByteBuffer* GetSerializedSendMessage() = 0;
-
-  /// Returns a non-modifiable pointer to the non-serialized form of the message
-  /// to be sent. Valid for PRE_SEND_MESSAGE interceptions. A return value of
-  /// nullptr indicates that this field is not valid.
-  virtual const void* GetSendMessage() = 0;
-
-  /// Overwrites the message to be sent with \a message. \a message should be in
-  /// the non-serialized form expected by the method. Valid for PRE_SEND_MESSAGE
-  /// interceptions. Note that the interceptor is responsible for maintaining
-  /// the life of the message till it is serialized or it receives the
-  /// POST_SEND_MESSAGE interception point, whichever happens earlier. The
-  /// modifying interceptor may itself force early serialization by calling
-  /// GetSerializedSendMessage.
-  virtual void ModifySendMessage(const void* message) = 0;
-
-  /// Checks whether the SEND MESSAGE op succeeded. Valid for POST_SEND_MESSAGE
-  /// interceptions.
-  virtual bool GetSendMessageStatus() = 0;
-
-  /// Returns a modifiable multimap of the initial metadata to be sent. Valid
-  /// for PRE_SEND_INITIAL_METADATA interceptions. A value of nullptr indicates
-  /// that this field is not valid.
-  virtual std::multimap<std::string, std::string>* GetSendInitialMetadata() = 0;
-
-  /// Returns the status to be sent. Valid for PRE_SEND_STATUS interceptions.
-  virtual Status GetSendStatus() = 0;
-
-  /// Overwrites the status with \a status. Valid for PRE_SEND_STATUS
-  /// interceptions.
-  virtual void ModifySendStatus(const Status& status) = 0;
-
-  /// Returns a modifiable multimap of the trailing metadata to be sent. Valid
-  /// for PRE_SEND_STATUS interceptions. A value of nullptr indicates
-  /// that this field is not valid.
-  virtual std::multimap<std::string, std::string>*
-  GetSendTrailingMetadata() = 0;
-
-  /// Returns a pointer to the modifiable received message. Note that the
-  /// message is already deserialized but the type is not set; the interceptor
-  /// should static_cast to the appropriate type before using it. This is valid
-  /// for PRE_RECV_MESSAGE and POST_RECV_MESSAGE interceptions; nullptr for not
-  /// valid
-  virtual void* GetRecvMessage() = 0;
-
-  /// Returns a modifiable multimap of the received initial metadata.
-  /// Valid for PRE_RECV_INITIAL_METADATA and POST_RECV_INITIAL_METADATA
-  /// interceptions; nullptr if not valid
-  virtual std::multimap<grpc::string_ref, grpc::string_ref>*
-  GetRecvInitialMetadata() = 0;
-
-  /// Returns a modifiable view of the received status on PRE_RECV_STATUS and
-  /// POST_RECV_STATUS interceptions; nullptr if not valid.
-  virtual Status* GetRecvStatus() = 0;
-
-  /// Returns a modifiable multimap of the received trailing metadata on
-  /// PRE_RECV_STATUS and POST_RECV_STATUS interceptions; nullptr if not valid
-  virtual std::multimap<grpc::string_ref, grpc::string_ref>*
-  GetRecvTrailingMetadata() = 0;
-
-  /// Gets an intercepted channel. When a call is started on this interceptor,
-  /// only interceptors after the current interceptor are created from the
-  /// factory objects registered with the channel. This allows calls to be
-  /// started from interceptors without infinite regress through the interceptor
-  /// list.
-  virtual std::unique_ptr<ChannelInterface> GetInterceptedChannel() = 0;
-
-  /// On a hijacked RPC, an interceptor can decide to fail a PRE_RECV_MESSAGE
-  /// op. This would be a signal to the reader that there will be no more
-  /// messages, or the stream has failed or been cancelled.
-  virtual void FailHijackedRecvMessage() = 0;
-
-  /// On a hijacked RPC/ to-be hijacked RPC, this can be called to fail a SEND
-  /// MESSAGE op
-  virtual void FailHijackedSendMessage() = 0;
-};
-
-/// Interface for an interceptor. Interceptor authors must create a class
-/// that derives from this parent class.
-class Interceptor {
- public:
-  virtual ~Interceptor() {}
-
-  /// The one public method of an Interceptor interface. Override this to
-  /// trigger the desired actions at the hook points described above.
-  virtual void Intercept(InterceptorBatchMethods* methods) = 0;
-};
-
-}  // namespace experimental
+namespace grpc
+{
+
+    class ChannelInterface;
+    class Status;
+
+    namespace experimental
+    {
+
+        /// An enumeration of different possible points at which the \a Intercept
+        /// method of the \a Interceptor interface may be called. Any given call
+        /// to \a Intercept will include one or more of these hook points, and
+        /// each hook point makes certain types of information available to the
+        /// interceptor.
+        /// In these enumeration names, PRE_SEND means that an interception has taken
+        /// place between the time the application provided a certain type of data
+        /// (e.g., initial metadata, status) and the time that that data goes to the
+        /// other side. POST_SEND means that the data has been committed for going to
+        /// the other side (even if it has not yet been received at the other side).
+        /// PRE_RECV means an interception between the time that a certain
+        /// operation has been requested and it is available. POST_RECV means that a
+        /// result is available but has not yet been passed back to the application.
+        /// A batch of interception points will only contain either PRE or POST hooks
+        /// but not both types. For example, a batch with PRE_SEND hook points will not
+        /// contain POST_RECV or POST_SEND ops. Likewise, a batch with POST_* ops can
+        /// not contain PRE_* ops.
+        enum class InterceptionHookPoints
+        {
+            /// The first three in this list are for clients and servers
+            PRE_SEND_INITIAL_METADATA,
+            PRE_SEND_MESSAGE,
+            POST_SEND_MESSAGE,
+            PRE_SEND_STATUS,  // server only
+            PRE_SEND_CLOSE,   // client only: WritesDone for stream; after write in unary
+            /// The following three are for hijacked clients only. A batch with PRE_RECV_*
+            /// hook points will never contain hook points of other types.
+            PRE_RECV_INITIAL_METADATA,
+            PRE_RECV_MESSAGE,
+            PRE_RECV_STATUS,
+            /// The following two are for all clients and servers
+            POST_RECV_INITIAL_METADATA,
+            POST_RECV_MESSAGE,
+            POST_RECV_STATUS,  // client only
+            POST_RECV_CLOSE,   // server only
+            /// This is a special hook point available to both clients and servers when
+            /// TryCancel() is performed.
+            ///  - No other hook points will be present along with this.
+            ///  - It is illegal for an interceptor to block/delay this operation.
+            ///  - ALL interceptors see this hook point irrespective of whether the
+            ///    RPC was hijacked or not.
+            PRE_SEND_CANCEL,
+            NUM_INTERCEPTION_HOOKS
+        };
+
+        /// Class that is passed as an argument to the \a Intercept method
+        /// of the application's \a Interceptor interface implementation. It has five
+        /// purposes:
+        ///   1. Indicate which hook points are present at a specific interception
+        ///   2. Allow an interceptor to inform the library that an RPC should
+        ///      continue to the next stage of its processing (which may be another
+        ///      interceptor or the main path of the library)
+        ///   3. Allow an interceptor to hijack the processing of the RPC (only for
+        ///      client-side RPCs with PRE_SEND_INITIAL_METADATA) so that it does not
+        ///      proceed with normal processing beyond that stage
+        ///   4. Access the relevant fields of an RPC at each interception point
+        ///   5. Set some fields of an RPC at each interception point, when possible
+        class InterceptorBatchMethods
+        {
+        public:
+            virtual ~InterceptorBatchMethods()
+            {
+            }
+            /// Determine whether the current batch has an interception hook point
+            /// of type \a type
+            virtual bool QueryInterceptionHookPoint(InterceptionHookPoints type) = 0;
+            /// Signal that the interceptor is done intercepting the current batch of the
+            /// RPC. Every interceptor must either call Proceed or Hijack on each
+            /// interception. In most cases, only Proceed will be used. Explicit use of
+            /// Proceed is what enables interceptors to delay the processing of RPCs
+            /// while they perform other work.
+            /// Proceed is a no-op if the batch contains PRE_SEND_CANCEL. Simply returning
+            /// from the Intercept method does the job of continuing the RPC in this case.
+            /// This is because PRE_SEND_CANCEL is always in a separate batch and is not
+            /// allowed to be delayed.
+            virtual void Proceed() = 0;
+            /// Indicate that the interceptor has hijacked the RPC (only valid if the
+            /// batch contains send_initial_metadata on the client side). Later
+            /// interceptors in the interceptor list will not be called. Later batches
+            /// on the same RPC will go through interception, but only up to the point
+            /// of the hijacking interceptor.
+            virtual void Hijack() = 0;
+
+            /// Send Message Methods
+            /// GetSerializedSendMessage and GetSendMessage/ModifySendMessage are the
+            /// available methods to view and modify the request payload. An interceptor
+            /// can access the payload in either serialized form or non-serialized form
+            /// but not both at the same time.
+            /// gRPC performs serialization in a lazy manner, which means
+            /// that a call to GetSerializedSendMessage will result in a serialization
+            /// operation if the payload stored is not in the serialized form already; the
+            /// non-serialized form will be lost and GetSendMessage will no longer return
+            /// a valid pointer, and this will remain true for later interceptors too.
+            /// This can change however if ModifySendMessage is used to replace the
+            /// current payload. Note that ModifySendMessage requires a new payload
+            /// message in the non-serialized form. This will overwrite the existing
+            /// payload irrespective of whether it had been serialized earlier. Also note
+            /// that gRPC Async API requires early serialization of the payload which
+            /// means that the payload would be available in the serialized form only
+            /// unless an interceptor replaces the payload with ModifySendMessage.
+
+            /// Returns a modifable ByteBuffer holding the serialized form of the message
+            /// that is going to be sent. Valid for PRE_SEND_MESSAGE interceptions.
+            /// A return value of nullptr indicates that this ByteBuffer is not valid.
+            virtual ByteBuffer* GetSerializedSendMessage() = 0;
+
+            /// Returns a non-modifiable pointer to the non-serialized form of the message
+            /// to be sent. Valid for PRE_SEND_MESSAGE interceptions. A return value of
+            /// nullptr indicates that this field is not valid.
+            virtual const void* GetSendMessage() = 0;
+
+            /// Overwrites the message to be sent with \a message. \a message should be in
+            /// the non-serialized form expected by the method. Valid for PRE_SEND_MESSAGE
+            /// interceptions. Note that the interceptor is responsible for maintaining
+            /// the life of the message till it is serialized or it receives the
+            /// POST_SEND_MESSAGE interception point, whichever happens earlier. The
+            /// modifying interceptor may itself force early serialization by calling
+            /// GetSerializedSendMessage.
+            virtual void ModifySendMessage(const void* message) = 0;
+
+            /// Checks whether the SEND MESSAGE op succeeded. Valid for POST_SEND_MESSAGE
+            /// interceptions.
+            virtual bool GetSendMessageStatus() = 0;
+
+            /// Returns a modifiable multimap of the initial metadata to be sent. Valid
+            /// for PRE_SEND_INITIAL_METADATA interceptions. A value of nullptr indicates
+            /// that this field is not valid.
+            virtual std::multimap<std::string, std::string>* GetSendInitialMetadata() = 0;
+
+            /// Returns the status to be sent. Valid for PRE_SEND_STATUS interceptions.
+            virtual Status GetSendStatus() = 0;
+
+            /// Overwrites the status with \a status. Valid for PRE_SEND_STATUS
+            /// interceptions.
+            virtual void ModifySendStatus(const Status& status) = 0;
+
+            /// Returns a modifiable multimap of the trailing metadata to be sent. Valid
+            /// for PRE_SEND_STATUS interceptions. A value of nullptr indicates
+            /// that this field is not valid.
+            virtual std::multimap<std::string, std::string>*
+                GetSendTrailingMetadata() = 0;
+
+            /// Returns a pointer to the modifiable received message. Note that the
+            /// message is already deserialized but the type is not set; the interceptor
+            /// should static_cast to the appropriate type before using it. This is valid
+            /// for PRE_RECV_MESSAGE and POST_RECV_MESSAGE interceptions; nullptr for not
+            /// valid
+            virtual void* GetRecvMessage() = 0;
+
+            /// Returns a modifiable multimap of the received initial metadata.
+            /// Valid for PRE_RECV_INITIAL_METADATA and POST_RECV_INITIAL_METADATA
+            /// interceptions; nullptr if not valid
+            virtual std::multimap<grpc::string_ref, grpc::string_ref>*
+                GetRecvInitialMetadata() = 0;
+
+            /// Returns a modifiable view of the received status on PRE_RECV_STATUS and
+            /// POST_RECV_STATUS interceptions; nullptr if not valid.
+            virtual Status* GetRecvStatus() = 0;
+
+            /// Returns a modifiable multimap of the received trailing metadata on
+            /// PRE_RECV_STATUS and POST_RECV_STATUS interceptions; nullptr if not valid
+            virtual std::multimap<grpc::string_ref, grpc::string_ref>*
+                GetRecvTrailingMetadata() = 0;
+
+            /// Gets an intercepted channel. When a call is started on this interceptor,
+            /// only interceptors after the current interceptor are created from the
+            /// factory objects registered with the channel. This allows calls to be
+            /// started from interceptors without infinite regress through the interceptor
+            /// list.
+            virtual std::unique_ptr<ChannelInterface> GetInterceptedChannel() = 0;
+
+            /// On a hijacked RPC, an interceptor can decide to fail a PRE_RECV_MESSAGE
+            /// op. This would be a signal to the reader that there will be no more
+            /// messages, or the stream has failed or been cancelled.
+            virtual void FailHijackedRecvMessage() = 0;
+
+            /// On a hijacked RPC/ to-be hijacked RPC, this can be called to fail a SEND
+            /// MESSAGE op
+            virtual void FailHijackedSendMessage() = 0;
+        };
+
+        /// Interface for an interceptor. Interceptor authors must create a class
+        /// that derives from this parent class.
+        class Interceptor
+        {
+        public:
+            virtual ~Interceptor()
+            {
+            }
+
+            /// The one public method of an Interceptor interface. Override this to
+            /// trigger the desired actions at the hook points described above.
+            virtual void Intercept(InterceptorBatchMethods* methods) = 0;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor_common.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor_common.h
index b084b7c..3632259 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor_common.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/interceptor_common.h
@@ -31,510 +31,619 @@
 #include <grpcpp/impl/codegen/intercepted_channel.h>
 #include <grpcpp/impl/codegen/server_interceptor.h>
 
-namespace grpc {
-namespace internal {
-
-class InterceptorBatchMethodsImpl
-    : public experimental::InterceptorBatchMethods {
- public:
-  InterceptorBatchMethodsImpl() {
-    for (auto i = static_cast<experimental::InterceptionHookPoints>(0);
-         i < experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS;
-         i = static_cast<experimental::InterceptionHookPoints>(
-             static_cast<size_t>(i) + 1)) {
-      hooks_[static_cast<size_t>(i)] = false;
-    }
-  }
-
-  ~InterceptorBatchMethodsImpl() override {}
-
-  bool QueryInterceptionHookPoint(
-      experimental::InterceptionHookPoints type) override {
-    return hooks_[static_cast<size_t>(type)];
-  }
-
-  void Proceed() override {
-    if (call_->client_rpc_info() != nullptr) {
-      return ProceedClient();
-    }
-    GPR_CODEGEN_ASSERT(call_->server_rpc_info() != nullptr);
-    ProceedServer();
-  }
-
-  void Hijack() override {
-    // Only the client can hijack when sending down initial metadata
-    GPR_CODEGEN_ASSERT(!reverse_ && ops_ != nullptr &&
-                       call_->client_rpc_info() != nullptr);
-    // It is illegal to call Hijack twice
-    GPR_CODEGEN_ASSERT(!ran_hijacking_interceptor_);
-    auto* rpc_info = call_->client_rpc_info();
-    rpc_info->hijacked_ = true;
-    rpc_info->hijacked_interceptor_ = current_interceptor_index_;
-    ClearHookPoints();
-    ops_->SetHijackingState();
-    ran_hijacking_interceptor_ = true;
-    rpc_info->RunInterceptor(this, current_interceptor_index_);
-  }
-
-  void AddInterceptionHookPoint(experimental::InterceptionHookPoints type) {
-    hooks_[static_cast<size_t>(type)] = true;
-  }
-
-  ByteBuffer* GetSerializedSendMessage() override {
-    GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
-    if (*orig_send_message_ != nullptr) {
-      GPR_CODEGEN_ASSERT(serializer_(*orig_send_message_).ok());
-      *orig_send_message_ = nullptr;
-    }
-    return send_message_;
-  }
-
-  const void* GetSendMessage() override {
-    GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
-    return *orig_send_message_;
-  }
-
-  void ModifySendMessage(const void* message) override {
-    GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
-    *orig_send_message_ = message;
-  }
-
-  bool GetSendMessageStatus() override { return !*fail_send_message_; }
-
-  std::multimap<std::string, std::string>* GetSendInitialMetadata() override {
-    return send_initial_metadata_;
-  }
-
-  Status GetSendStatus() override {
-    return Status(static_cast<StatusCode>(*code_), *error_message_,
-                  *error_details_);
-  }
-
-  void ModifySendStatus(const Status& status) override {
-    *code_ = static_cast<grpc_status_code>(status.error_code());
-    *error_details_ = status.error_details();
-    *error_message_ = status.error_message();
-  }
-
-  std::multimap<std::string, std::string>* GetSendTrailingMetadata() override {
-    return send_trailing_metadata_;
-  }
-
-  void* GetRecvMessage() override { return recv_message_; }
-
-  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvInitialMetadata()
-      override {
-    return recv_initial_metadata_->map();
-  }
-
-  Status* GetRecvStatus() override { return recv_status_; }
-
-  void FailHijackedSendMessage() override {
-    GPR_CODEGEN_ASSERT(hooks_[static_cast<size_t>(
-        experimental::InterceptionHookPoints::PRE_SEND_MESSAGE)]);
-    *fail_send_message_ = true;
-  }
-
-  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvTrailingMetadata()
-      override {
-    return recv_trailing_metadata_->map();
-  }
-
-  void SetSendMessage(ByteBuffer* buf, const void** msg,
-                      bool* fail_send_message,
-                      std::function<Status(const void*)> serializer) {
-    send_message_ = buf;
-    orig_send_message_ = msg;
-    fail_send_message_ = fail_send_message;
-    serializer_ = serializer;
-  }
-
-  void SetSendInitialMetadata(
-      std::multimap<std::string, std::string>* metadata) {
-    send_initial_metadata_ = metadata;
-  }
-
-  void SetSendStatus(grpc_status_code* code, std::string* error_details,
-                     std::string* error_message) {
-    code_ = code;
-    error_details_ = error_details;
-    error_message_ = error_message;
-  }
-
-  void SetSendTrailingMetadata(
-      std::multimap<std::string, std::string>* metadata) {
-    send_trailing_metadata_ = metadata;
-  }
-
-  void SetRecvMessage(void* message, bool* hijacked_recv_message_failed) {
-    recv_message_ = message;
-    hijacked_recv_message_failed_ = hijacked_recv_message_failed;
-  }
-
-  void SetRecvInitialMetadata(MetadataMap* map) {
-    recv_initial_metadata_ = map;
-  }
-
-  void SetRecvStatus(Status* status) { recv_status_ = status; }
-
-  void SetRecvTrailingMetadata(MetadataMap* map) {
-    recv_trailing_metadata_ = map;
-  }
-
-  std::unique_ptr<ChannelInterface> GetInterceptedChannel() override {
-    auto* info = call_->client_rpc_info();
-    if (info == nullptr) {
-      return std::unique_ptr<ChannelInterface>(nullptr);
-    }
-    // The intercepted channel starts from the interceptor just after the
-    // current interceptor
-    return std::unique_ptr<ChannelInterface>(new InterceptedChannel(
-        info->channel(), current_interceptor_index_ + 1));
-  }
-
-  void FailHijackedRecvMessage() override {
-    GPR_CODEGEN_ASSERT(hooks_[static_cast<size_t>(
-        experimental::InterceptionHookPoints::PRE_RECV_MESSAGE)]);
-    *hijacked_recv_message_failed_ = true;
-  }
-
-  // Clears all state
-  void ClearState() {
-    reverse_ = false;
-    ran_hijacking_interceptor_ = false;
-    ClearHookPoints();
-  }
-
-  // Prepares for Post_recv operations
-  void SetReverse() {
-    reverse_ = true;
-    ran_hijacking_interceptor_ = false;
-    ClearHookPoints();
-  }
-
-  // This needs to be set before interceptors are run
-  void SetCall(Call* call) { call_ = call; }
-
-  // This needs to be set before interceptors are run using RunInterceptors().
-  // Alternatively, RunInterceptors(std::function<void(void)> f) can be used.
-  void SetCallOpSetInterface(CallOpSetInterface* ops) { ops_ = ops; }
-
-  // SetCall should have been called before this.
-  // Returns true if the interceptors list is empty
-  bool InterceptorsListEmpty() {
-    auto* client_rpc_info = call_->client_rpc_info();
-    if (client_rpc_info != nullptr) {
-      return client_rpc_info->interceptors_.empty();
-    }
-
-    auto* server_rpc_info = call_->server_rpc_info();
-    return server_rpc_info == nullptr || server_rpc_info->interceptors_.empty();
-  }
-
-  // This should be used only by subclasses of CallOpSetInterface. SetCall and
-  // SetCallOpSetInterface should have been called before this. After all the
-  // interceptors are done running, either ContinueFillOpsAfterInterception or
-  // ContinueFinalizeOpsAfterInterception will be called. Note that neither of
-  // them is invoked if there were no interceptors registered.
-  bool RunInterceptors() {
-    GPR_CODEGEN_ASSERT(ops_);
-    auto* client_rpc_info = call_->client_rpc_info();
-    if (client_rpc_info != nullptr) {
-      if (client_rpc_info->interceptors_.empty()) {
-        return true;
-      } else {
-        RunClientInterceptors();
-        return false;
-      }
-    }
-
-    auto* server_rpc_info = call_->server_rpc_info();
-    if (server_rpc_info == nullptr || server_rpc_info->interceptors_.empty()) {
-      return true;
-    }
-    RunServerInterceptors();
-    return false;
-  }
-
-  // Returns true if no interceptors are run. Returns false otherwise if there
-  // are interceptors registered. After the interceptors are done running \a f
-  // will be invoked. This is to be used only by BaseAsyncRequest and
-  // SyncRequest.
-  bool RunInterceptors(std::function<void(void)> f) {
-    // This is used only by the server for initial call request
-    GPR_CODEGEN_ASSERT(reverse_ == true);
-    GPR_CODEGEN_ASSERT(call_->client_rpc_info() == nullptr);
-    auto* server_rpc_info = call_->server_rpc_info();
-    if (server_rpc_info == nullptr || server_rpc_info->interceptors_.empty()) {
-      return true;
-    }
-    callback_ = std::move(f);
-    RunServerInterceptors();
-    return false;
-  }
-
- private:
-  void RunClientInterceptors() {
-    auto* rpc_info = call_->client_rpc_info();
-    if (!reverse_) {
-      current_interceptor_index_ = 0;
-    } else {
-      if (rpc_info->hijacked_) {
-        current_interceptor_index_ = rpc_info->hijacked_interceptor_;
-      } else {
-        current_interceptor_index_ = rpc_info->interceptors_.size() - 1;
-      }
-    }
-    rpc_info->RunInterceptor(this, current_interceptor_index_);
-  }
-
-  void RunServerInterceptors() {
-    auto* rpc_info = call_->server_rpc_info();
-    if (!reverse_) {
-      current_interceptor_index_ = 0;
-    } else {
-      current_interceptor_index_ = rpc_info->interceptors_.size() - 1;
-    }
-    rpc_info->RunInterceptor(this, current_interceptor_index_);
-  }
-
-  void ProceedClient() {
-    auto* rpc_info = call_->client_rpc_info();
-    if (rpc_info->hijacked_ && !reverse_ &&
-        current_interceptor_index_ == rpc_info->hijacked_interceptor_ &&
-        !ran_hijacking_interceptor_) {
-      // We now need to provide hijacked recv ops to this interceptor
-      ClearHookPoints();
-      ops_->SetHijackingState();
-      ran_hijacking_interceptor_ = true;
-      rpc_info->RunInterceptor(this, current_interceptor_index_);
-      return;
-    }
-    if (!reverse_) {
-      current_interceptor_index_++;
-      // We are going down the stack of interceptors
-      if (current_interceptor_index_ < rpc_info->interceptors_.size()) {
-        if (rpc_info->hijacked_ &&
-            current_interceptor_index_ > rpc_info->hijacked_interceptor_) {
-          // This is a hijacked RPC and we are done with hijacking
-          ops_->ContinueFillOpsAfterInterception();
-        } else {
-          rpc_info->RunInterceptor(this, current_interceptor_index_);
-        }
-      } else {
-        // we are done running all the interceptors without any hijacking
-        ops_->ContinueFillOpsAfterInterception();
-      }
-    } else {
-      // We are going up the stack of interceptors
-      if (current_interceptor_index_ > 0) {
-        // Continue running interceptors
-        current_interceptor_index_--;
-        rpc_info->RunInterceptor(this, current_interceptor_index_);
-      } else {
-        // we are done running all the interceptors without any hijacking
-        ops_->ContinueFinalizeResultAfterInterception();
-      }
-    }
-  }
-
-  void ProceedServer() {
-    auto* rpc_info = call_->server_rpc_info();
-    if (!reverse_) {
-      current_interceptor_index_++;
-      if (current_interceptor_index_ < rpc_info->interceptors_.size()) {
-        return rpc_info->RunInterceptor(this, current_interceptor_index_);
-      } else if (ops_) {
-        return ops_->ContinueFillOpsAfterInterception();
-      }
-    } else {
-      // We are going up the stack of interceptors
-      if (current_interceptor_index_ > 0) {
-        // Continue running interceptors
-        current_interceptor_index_--;
-        return rpc_info->RunInterceptor(this, current_interceptor_index_);
-      } else if (ops_) {
-        return ops_->ContinueFinalizeResultAfterInterception();
-      }
-    }
-    GPR_CODEGEN_ASSERT(callback_);
-    callback_();
-  }
-
-  void ClearHookPoints() {
-    for (auto i = static_cast<experimental::InterceptionHookPoints>(0);
-         i < experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS;
-         i = static_cast<experimental::InterceptionHookPoints>(
-             static_cast<size_t>(i) + 1)) {
-      hooks_[static_cast<size_t>(i)] = false;
-    }
-  }
-
-  std::array<bool,
-             static_cast<size_t>(
-                 experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS)>
-      hooks_;
-
-  size_t current_interceptor_index_ = 0;  // Current iterator
-  bool reverse_ = false;
-  bool ran_hijacking_interceptor_ = false;
-  Call* call_ = nullptr;  // The Call object is present along with CallOpSet
-                          // object/callback
-  CallOpSetInterface* ops_ = nullptr;
-  std::function<void(void)> callback_;
-
-  ByteBuffer* send_message_ = nullptr;
-  bool* fail_send_message_ = nullptr;
-  const void** orig_send_message_ = nullptr;
-  std::function<Status(const void*)> serializer_;
-
-  std::multimap<std::string, std::string>* send_initial_metadata_;
-
-  grpc_status_code* code_ = nullptr;
-  std::string* error_details_ = nullptr;
-  std::string* error_message_ = nullptr;
-
-  std::multimap<std::string, std::string>* send_trailing_metadata_ = nullptr;
-
-  void* recv_message_ = nullptr;
-  bool* hijacked_recv_message_failed_ = nullptr;
-
-  MetadataMap* recv_initial_metadata_ = nullptr;
-
-  Status* recv_status_ = nullptr;
-
-  MetadataMap* recv_trailing_metadata_ = nullptr;
-};
-
-// A special implementation of InterceptorBatchMethods to send a Cancel
-// notification down the interceptor stack
-class CancelInterceptorBatchMethods
-    : public experimental::InterceptorBatchMethods {
- public:
-  bool QueryInterceptionHookPoint(
-      experimental::InterceptionHookPoints type) override {
-    return type == experimental::InterceptionHookPoints::PRE_SEND_CANCEL;
-  }
-
-  void Proceed() override {
-    // This is a no-op. For actual continuation of the RPC simply needs to
-    // return from the Intercept method
-  }
-
-  void Hijack() override {
-    // Only the client can hijack when sending down initial metadata
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call Hijack on a method which has a "
-                       "Cancel notification");
-  }
-
-  ByteBuffer* GetSerializedSendMessage() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetSendMessage on a method which "
-                       "has a Cancel notification");
-    return nullptr;
-  }
-
-  bool GetSendMessageStatus() override {
-    GPR_CODEGEN_ASSERT(
-        false &&
-        "It is illegal to call GetSendMessageStatus on a method which "
-        "has a Cancel notification");
-    return false;
-  }
-
-  const void* GetSendMessage() override {
-    GPR_CODEGEN_ASSERT(
-        false &&
-        "It is illegal to call GetOriginalSendMessage on a method which "
-        "has a Cancel notification");
-    return nullptr;
-  }
-
-  void ModifySendMessage(const void* /*message*/) override {
-    GPR_CODEGEN_ASSERT(
-        false &&
-        "It is illegal to call ModifySendMessage on a method which "
-        "has a Cancel notification");
-  }
-
-  std::multimap<std::string, std::string>* GetSendInitialMetadata() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetSendInitialMetadata on a "
-                       "method which has a Cancel notification");
-    return nullptr;
-  }
-
-  Status GetSendStatus() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetSendStatus on a method which "
-                       "has a Cancel notification");
-    return Status();
-  }
-
-  void ModifySendStatus(const Status& /*status*/) override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call ModifySendStatus on a method "
-                       "which has a Cancel notification");
-  }
-
-  std::multimap<std::string, std::string>* GetSendTrailingMetadata() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetSendTrailingMetadata on a "
-                       "method which has a Cancel notification");
-    return nullptr;
-  }
-
-  void* GetRecvMessage() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetRecvMessage on a method which "
-                       "has a Cancel notification");
-    return nullptr;
-  }
-
-  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvInitialMetadata()
-      override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetRecvInitialMetadata on a "
-                       "method which has a Cancel notification");
-    return nullptr;
-  }
-
-  Status* GetRecvStatus() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetRecvStatus on a method which "
-                       "has a Cancel notification");
-    return nullptr;
-  }
-
-  std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvTrailingMetadata()
-      override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetRecvTrailingMetadata on a "
-                       "method which has a Cancel notification");
-    return nullptr;
-  }
-
-  std::unique_ptr<ChannelInterface> GetInterceptedChannel() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call GetInterceptedChannel on a "
-                       "method which has a Cancel notification");
-    return std::unique_ptr<ChannelInterface>(nullptr);
-  }
-
-  void FailHijackedRecvMessage() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call FailHijackedRecvMessage on a "
-                       "method which has a Cancel notification");
-  }
-
-  void FailHijackedSendMessage() override {
-    GPR_CODEGEN_ASSERT(false &&
-                       "It is illegal to call FailHijackedSendMessage on a "
-                       "method which has a Cancel notification");
-  }
-};
-}  // namespace internal
+namespace grpc
+{
+    namespace internal
+    {
+
+        class InterceptorBatchMethodsImpl : public experimental::InterceptorBatchMethods
+        {
+        public:
+            InterceptorBatchMethodsImpl()
+            {
+                for (auto i = static_cast<experimental::InterceptionHookPoints>(0);
+                     i < experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS;
+                     i = static_cast<experimental::InterceptionHookPoints>(
+                         static_cast<size_t>(i) + 1
+                     ))
+                {
+                    hooks_[static_cast<size_t>(i)] = false;
+                }
+            }
+
+            ~InterceptorBatchMethodsImpl() override
+            {
+            }
+
+            bool QueryInterceptionHookPoint(
+                experimental::InterceptionHookPoints type
+            ) override
+            {
+                return hooks_[static_cast<size_t>(type)];
+            }
+
+            void Proceed() override
+            {
+                if (call_->client_rpc_info() != nullptr)
+                {
+                    return ProceedClient();
+                }
+                GPR_CODEGEN_ASSERT(call_->server_rpc_info() != nullptr);
+                ProceedServer();
+            }
+
+            void Hijack() override
+            {
+                // Only the client can hijack when sending down initial metadata
+                GPR_CODEGEN_ASSERT(!reverse_ && ops_ != nullptr && call_->client_rpc_info() != nullptr);
+                // It is illegal to call Hijack twice
+                GPR_CODEGEN_ASSERT(!ran_hijacking_interceptor_);
+                auto* rpc_info = call_->client_rpc_info();
+                rpc_info->hijacked_ = true;
+                rpc_info->hijacked_interceptor_ = current_interceptor_index_;
+                ClearHookPoints();
+                ops_->SetHijackingState();
+                ran_hijacking_interceptor_ = true;
+                rpc_info->RunInterceptor(this, current_interceptor_index_);
+            }
+
+            void AddInterceptionHookPoint(experimental::InterceptionHookPoints type)
+            {
+                hooks_[static_cast<size_t>(type)] = true;
+            }
+
+            ByteBuffer* GetSerializedSendMessage() override
+            {
+                GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
+                if (*orig_send_message_ != nullptr)
+                {
+                    GPR_CODEGEN_ASSERT(serializer_(*orig_send_message_).ok());
+                    *orig_send_message_ = nullptr;
+                }
+                return send_message_;
+            }
+
+            const void* GetSendMessage() override
+            {
+                GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
+                return *orig_send_message_;
+            }
+
+            void ModifySendMessage(const void* message) override
+            {
+                GPR_CODEGEN_ASSERT(orig_send_message_ != nullptr);
+                *orig_send_message_ = message;
+            }
+
+            bool GetSendMessageStatus() override
+            {
+                return !*fail_send_message_;
+            }
+
+            std::multimap<std::string, std::string>* GetSendInitialMetadata() override
+            {
+                return send_initial_metadata_;
+            }
+
+            Status GetSendStatus() override
+            {
+                return Status(static_cast<StatusCode>(*code_), *error_message_, *error_details_);
+            }
+
+            void ModifySendStatus(const Status& status) override
+            {
+                *code_ = static_cast<grpc_status_code>(status.error_code());
+                *error_details_ = status.error_details();
+                *error_message_ = status.error_message();
+            }
+
+            std::multimap<std::string, std::string>* GetSendTrailingMetadata() override
+            {
+                return send_trailing_metadata_;
+            }
+
+            void* GetRecvMessage() override
+            {
+                return recv_message_;
+            }
+
+            std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvInitialMetadata()
+                override
+            {
+                return recv_initial_metadata_->map();
+            }
+
+            Status* GetRecvStatus() override
+            {
+                return recv_status_;
+            }
+
+            void FailHijackedSendMessage() override
+            {
+                GPR_CODEGEN_ASSERT(hooks_[static_cast<size_t>(
+                    experimental::InterceptionHookPoints::PRE_SEND_MESSAGE
+                )]);
+                *fail_send_message_ = true;
+            }
+
+            std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvTrailingMetadata()
+                override
+            {
+                return recv_trailing_metadata_->map();
+            }
+
+            void SetSendMessage(ByteBuffer* buf, const void** msg, bool* fail_send_message, std::function<Status(const void*)> serializer)
+            {
+                send_message_ = buf;
+                orig_send_message_ = msg;
+                fail_send_message_ = fail_send_message;
+                serializer_ = serializer;
+            }
+
+            void SetSendInitialMetadata(
+                std::multimap<std::string, std::string>* metadata
+            )
+            {
+                send_initial_metadata_ = metadata;
+            }
+
+            void SetSendStatus(grpc_status_code* code, std::string* error_details, std::string* error_message)
+            {
+                code_ = code;
+                error_details_ = error_details;
+                error_message_ = error_message;
+            }
+
+            void SetSendTrailingMetadata(
+                std::multimap<std::string, std::string>* metadata
+            )
+            {
+                send_trailing_metadata_ = metadata;
+            }
+
+            void SetRecvMessage(void* message, bool* hijacked_recv_message_failed)
+            {
+                recv_message_ = message;
+                hijacked_recv_message_failed_ = hijacked_recv_message_failed;
+            }
+
+            void SetRecvInitialMetadata(MetadataMap* map)
+            {
+                recv_initial_metadata_ = map;
+            }
+
+            void SetRecvStatus(Status* status)
+            {
+                recv_status_ = status;
+            }
+
+            void SetRecvTrailingMetadata(MetadataMap* map)
+            {
+                recv_trailing_metadata_ = map;
+            }
+
+            std::unique_ptr<ChannelInterface> GetInterceptedChannel() override
+            {
+                auto* info = call_->client_rpc_info();
+                if (info == nullptr)
+                {
+                    return std::unique_ptr<ChannelInterface>(nullptr);
+                }
+                // The intercepted channel starts from the interceptor just after the
+                // current interceptor
+                return std::unique_ptr<ChannelInterface>(new InterceptedChannel(
+                    info->channel(), current_interceptor_index_ + 1
+                ));
+            }
+
+            void FailHijackedRecvMessage() override
+            {
+                GPR_CODEGEN_ASSERT(hooks_[static_cast<size_t>(
+                    experimental::InterceptionHookPoints::PRE_RECV_MESSAGE
+                )]);
+                *hijacked_recv_message_failed_ = true;
+            }
+
+            // Clears all state
+            void ClearState()
+            {
+                reverse_ = false;
+                ran_hijacking_interceptor_ = false;
+                ClearHookPoints();
+            }
+
+            // Prepares for Post_recv operations
+            void SetReverse()
+            {
+                reverse_ = true;
+                ran_hijacking_interceptor_ = false;
+                ClearHookPoints();
+            }
+
+            // This needs to be set before interceptors are run
+            void SetCall(Call* call)
+            {
+                call_ = call;
+            }
+
+            // This needs to be set before interceptors are run using RunInterceptors().
+            // Alternatively, RunInterceptors(std::function<void(void)> f) can be used.
+            void SetCallOpSetInterface(CallOpSetInterface* ops)
+            {
+                ops_ = ops;
+            }
+
+            // SetCall should have been called before this.
+            // Returns true if the interceptors list is empty
+            bool InterceptorsListEmpty()
+            {
+                auto* client_rpc_info = call_->client_rpc_info();
+                if (client_rpc_info != nullptr)
+                {
+                    return client_rpc_info->interceptors_.empty();
+                }
+
+                auto* server_rpc_info = call_->server_rpc_info();
+                return server_rpc_info == nullptr || server_rpc_info->interceptors_.empty();
+            }
+
+            // This should be used only by subclasses of CallOpSetInterface. SetCall and
+            // SetCallOpSetInterface should have been called before this. After all the
+            // interceptors are done running, either ContinueFillOpsAfterInterception or
+            // ContinueFinalizeOpsAfterInterception will be called. Note that neither of
+            // them is invoked if there were no interceptors registered.
+            bool RunInterceptors()
+            {
+                GPR_CODEGEN_ASSERT(ops_);
+                auto* client_rpc_info = call_->client_rpc_info();
+                if (client_rpc_info != nullptr)
+                {
+                    if (client_rpc_info->interceptors_.empty())
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        RunClientInterceptors();
+                        return false;
+                    }
+                }
+
+                auto* server_rpc_info = call_->server_rpc_info();
+                if (server_rpc_info == nullptr || server_rpc_info->interceptors_.empty())
+                {
+                    return true;
+                }
+                RunServerInterceptors();
+                return false;
+            }
+
+            // Returns true if no interceptors are run. Returns false otherwise if there
+            // are interceptors registered. After the interceptors are done running \a f
+            // will be invoked. This is to be used only by BaseAsyncRequest and
+            // SyncRequest.
+            bool RunInterceptors(std::function<void(void)> f)
+            {
+                // This is used only by the server for initial call request
+                GPR_CODEGEN_ASSERT(reverse_ == true);
+                GPR_CODEGEN_ASSERT(call_->client_rpc_info() == nullptr);
+                auto* server_rpc_info = call_->server_rpc_info();
+                if (server_rpc_info == nullptr || server_rpc_info->interceptors_.empty())
+                {
+                    return true;
+                }
+                callback_ = std::move(f);
+                RunServerInterceptors();
+                return false;
+            }
+
+        private:
+            void RunClientInterceptors()
+            {
+                auto* rpc_info = call_->client_rpc_info();
+                if (!reverse_)
+                {
+                    current_interceptor_index_ = 0;
+                }
+                else
+                {
+                    if (rpc_info->hijacked_)
+                    {
+                        current_interceptor_index_ = rpc_info->hijacked_interceptor_;
+                    }
+                    else
+                    {
+                        current_interceptor_index_ = rpc_info->interceptors_.size() - 1;
+                    }
+                }
+                rpc_info->RunInterceptor(this, current_interceptor_index_);
+            }
+
+            void RunServerInterceptors()
+            {
+                auto* rpc_info = call_->server_rpc_info();
+                if (!reverse_)
+                {
+                    current_interceptor_index_ = 0;
+                }
+                else
+                {
+                    current_interceptor_index_ = rpc_info->interceptors_.size() - 1;
+                }
+                rpc_info->RunInterceptor(this, current_interceptor_index_);
+            }
+
+            void ProceedClient()
+            {
+                auto* rpc_info = call_->client_rpc_info();
+                if (rpc_info->hijacked_ && !reverse_ &&
+                    current_interceptor_index_ == rpc_info->hijacked_interceptor_ &&
+                    !ran_hijacking_interceptor_)
+                {
+                    // We now need to provide hijacked recv ops to this interceptor
+                    ClearHookPoints();
+                    ops_->SetHijackingState();
+                    ran_hijacking_interceptor_ = true;
+                    rpc_info->RunInterceptor(this, current_interceptor_index_);
+                    return;
+                }
+                if (!reverse_)
+                {
+                    current_interceptor_index_++;
+                    // We are going down the stack of interceptors
+                    if (current_interceptor_index_ < rpc_info->interceptors_.size())
+                    {
+                        if (rpc_info->hijacked_ &&
+                            current_interceptor_index_ > rpc_info->hijacked_interceptor_)
+                        {
+                            // This is a hijacked RPC and we are done with hijacking
+                            ops_->ContinueFillOpsAfterInterception();
+                        }
+                        else
+                        {
+                            rpc_info->RunInterceptor(this, current_interceptor_index_);
+                        }
+                    }
+                    else
+                    {
+                        // we are done running all the interceptors without any hijacking
+                        ops_->ContinueFillOpsAfterInterception();
+                    }
+                }
+                else
+                {
+                    // We are going up the stack of interceptors
+                    if (current_interceptor_index_ > 0)
+                    {
+                        // Continue running interceptors
+                        current_interceptor_index_--;
+                        rpc_info->RunInterceptor(this, current_interceptor_index_);
+                    }
+                    else
+                    {
+                        // we are done running all the interceptors without any hijacking
+                        ops_->ContinueFinalizeResultAfterInterception();
+                    }
+                }
+            }
+
+            void ProceedServer()
+            {
+                auto* rpc_info = call_->server_rpc_info();
+                if (!reverse_)
+                {
+                    current_interceptor_index_++;
+                    if (current_interceptor_index_ < rpc_info->interceptors_.size())
+                    {
+                        return rpc_info->RunInterceptor(this, current_interceptor_index_);
+                    }
+                    else if (ops_)
+                    {
+                        return ops_->ContinueFillOpsAfterInterception();
+                    }
+                }
+                else
+                {
+                    // We are going up the stack of interceptors
+                    if (current_interceptor_index_ > 0)
+                    {
+                        // Continue running interceptors
+                        current_interceptor_index_--;
+                        return rpc_info->RunInterceptor(this, current_interceptor_index_);
+                    }
+                    else if (ops_)
+                    {
+                        return ops_->ContinueFinalizeResultAfterInterception();
+                    }
+                }
+                GPR_CODEGEN_ASSERT(callback_);
+                callback_();
+            }
+
+            void ClearHookPoints()
+            {
+                for (auto i = static_cast<experimental::InterceptionHookPoints>(0);
+                     i < experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS;
+                     i = static_cast<experimental::InterceptionHookPoints>(
+                         static_cast<size_t>(i) + 1
+                     ))
+                {
+                    hooks_[static_cast<size_t>(i)] = false;
+                }
+            }
+
+            std::array<bool, static_cast<size_t>(experimental::InterceptionHookPoints::NUM_INTERCEPTION_HOOKS)>
+                hooks_;
+
+            size_t current_interceptor_index_ = 0;  // Current iterator
+            bool reverse_ = false;
+            bool ran_hijacking_interceptor_ = false;
+            Call* call_ = nullptr;  // The Call object is present along with CallOpSet
+                                    // object/callback
+            CallOpSetInterface* ops_ = nullptr;
+            std::function<void(void)> callback_;
+
+            ByteBuffer* send_message_ = nullptr;
+            bool* fail_send_message_ = nullptr;
+            const void** orig_send_message_ = nullptr;
+            std::function<Status(const void*)> serializer_;
+
+            std::multimap<std::string, std::string>* send_initial_metadata_;
+
+            grpc_status_code* code_ = nullptr;
+            std::string* error_details_ = nullptr;
+            std::string* error_message_ = nullptr;
+
+            std::multimap<std::string, std::string>* send_trailing_metadata_ = nullptr;
+
+            void* recv_message_ = nullptr;
+            bool* hijacked_recv_message_failed_ = nullptr;
+
+            MetadataMap* recv_initial_metadata_ = nullptr;
+
+            Status* recv_status_ = nullptr;
+
+            MetadataMap* recv_trailing_metadata_ = nullptr;
+        };
+
+        // A special implementation of InterceptorBatchMethods to send a Cancel
+        // notification down the interceptor stack
+        class CancelInterceptorBatchMethods : public experimental::InterceptorBatchMethods
+        {
+        public:
+            bool QueryInterceptionHookPoint(
+                experimental::InterceptionHookPoints type
+            ) override
+            {
+                return type == experimental::InterceptionHookPoints::PRE_SEND_CANCEL;
+            }
+
+            void Proceed() override
+            {
+                // This is a no-op. For actual continuation of the RPC simply needs to
+                // return from the Intercept method
+            }
+
+            void Hijack() override
+            {
+                // Only the client can hijack when sending down initial metadata
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call Hijack on a method which has a "
+                                            "Cancel notification");
+            }
+
+            ByteBuffer* GetSerializedSendMessage() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetSendMessage on a method which "
+                                            "has a Cancel notification");
+                return nullptr;
+            }
+
+            bool GetSendMessageStatus() override
+            {
+                GPR_CODEGEN_ASSERT(
+                    false &&
+                    "It is illegal to call GetSendMessageStatus on a method which "
+                    "has a Cancel notification"
+                );
+                return false;
+            }
+
+            const void* GetSendMessage() override
+            {
+                GPR_CODEGEN_ASSERT(
+                    false &&
+                    "It is illegal to call GetOriginalSendMessage on a method which "
+                    "has a Cancel notification"
+                );
+                return nullptr;
+            }
+
+            void ModifySendMessage(const void* /*message*/) override
+            {
+                GPR_CODEGEN_ASSERT(
+                    false &&
+                    "It is illegal to call ModifySendMessage on a method which "
+                    "has a Cancel notification"
+                );
+            }
+
+            std::multimap<std::string, std::string>* GetSendInitialMetadata() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetSendInitialMetadata on a "
+                                            "method which has a Cancel notification");
+                return nullptr;
+            }
+
+            Status GetSendStatus() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetSendStatus on a method which "
+                                            "has a Cancel notification");
+                return Status();
+            }
+
+            void ModifySendStatus(const Status& /*status*/) override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call ModifySendStatus on a method "
+                                            "which has a Cancel notification");
+            }
+
+            std::multimap<std::string, std::string>* GetSendTrailingMetadata() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetSendTrailingMetadata on a "
+                                            "method which has a Cancel notification");
+                return nullptr;
+            }
+
+            void* GetRecvMessage() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetRecvMessage on a method which "
+                                            "has a Cancel notification");
+                return nullptr;
+            }
+
+            std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvInitialMetadata()
+                override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetRecvInitialMetadata on a "
+                                            "method which has a Cancel notification");
+                return nullptr;
+            }
+
+            Status* GetRecvStatus() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetRecvStatus on a method which "
+                                            "has a Cancel notification");
+                return nullptr;
+            }
+
+            std::multimap<grpc::string_ref, grpc::string_ref>* GetRecvTrailingMetadata()
+                override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetRecvTrailingMetadata on a "
+                                            "method which has a Cancel notification");
+                return nullptr;
+            }
+
+            std::unique_ptr<ChannelInterface> GetInterceptedChannel() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call GetInterceptedChannel on a "
+                                            "method which has a Cancel notification");
+                return std::unique_ptr<ChannelInterface>(nullptr);
+            }
+
+            void FailHijackedRecvMessage() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call FailHijackedRecvMessage on a "
+                                            "method which has a Cancel notification");
+            }
+
+            void FailHijackedSendMessage() override
+            {
+                GPR_CODEGEN_ASSERT(false && "It is illegal to call FailHijackedSendMessage on a "
+                                            "method which has a Cancel notification");
+            }
+        };
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_INTERCEPTOR_COMMON_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/message_allocator.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/message_allocator.h
index 440c7f1..9445b3b 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/message_allocator.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/message_allocator.h
@@ -21,52 +21,70 @@
 
 // IWYU pragma: private, include <grpcpp/support/message_allocator.h>
 
-namespace grpc {
+namespace grpc
+{
 
-// NOTE: This is an API for advanced users who need custom allocators.
-// Per rpc struct for the allocator. This is the interface to return to user.
-class RpcAllocatorState {
- public:
-  virtual ~RpcAllocatorState() = default;
-  // Optionally deallocate request early to reduce the size of working set.
-  // A custom MessageAllocator needs to be registered to make use of this.
-  // This is not abstract because implementing it is optional.
-  virtual void FreeRequest() {}
-};
+    // NOTE: This is an API for advanced users who need custom allocators.
+    // Per rpc struct for the allocator. This is the interface to return to user.
+    class RpcAllocatorState
+    {
+    public:
+        virtual ~RpcAllocatorState() = default;
+        // Optionally deallocate request early to reduce the size of working set.
+        // A custom MessageAllocator needs to be registered to make use of this.
+        // This is not abstract because implementing it is optional.
+        virtual void FreeRequest()
+        {
+        }
+    };
 
-// This is the interface returned by the allocator.
-// grpc library will call the methods to get request/response pointers and to
-// release the object when it is done.
-template <typename RequestT, typename ResponseT>
-class MessageHolder : public RpcAllocatorState {
- public:
-  // Release this object. For example, if the custom allocator's
-  // AllocateMessasge creates an instance of a subclass with new, the Release()
-  // should do a "delete this;".
-  virtual void Release() = 0;
-  RequestT* request() { return request_; }
-  ResponseT* response() { return response_; }
+    // This is the interface returned by the allocator.
+    // grpc library will call the methods to get request/response pointers and to
+    // release the object when it is done.
+    template<typename RequestT, typename ResponseT>
+    class MessageHolder : public RpcAllocatorState
+    {
+    public:
+        // Release this object. For example, if the custom allocator's
+        // AllocateMessasge creates an instance of a subclass with new, the Release()
+        // should do a "delete this;".
+        virtual void Release() = 0;
+        RequestT* request()
+        {
+            return request_;
+        }
+        ResponseT* response()
+        {
+            return response_;
+        }
 
- protected:
-  void set_request(RequestT* request) { request_ = request; }
-  void set_response(ResponseT* response) { response_ = response; }
+    protected:
+        void set_request(RequestT* request)
+        {
+            request_ = request;
+        }
+        void set_response(ResponseT* response)
+        {
+            response_ = response;
+        }
 
- private:
-  // NOTE: subclasses should set these pointers.
-  RequestT* request_;
-  ResponseT* response_;
-};
+    private:
+        // NOTE: subclasses should set these pointers.
+        RequestT* request_;
+        ResponseT* response_;
+    };
 
-// A custom allocator can be set via the generated code to a callback unary
-// method, such as SetMessageAllocatorFor_Echo(custom_allocator). The allocator
-// needs to be alive for the lifetime of the server.
-// Implementations need to be thread-safe.
-template <typename RequestT, typename ResponseT>
-class MessageAllocator {
- public:
-  virtual ~MessageAllocator() = default;
-  virtual MessageHolder<RequestT, ResponseT>* AllocateMessages() = 0;
-};
+    // A custom allocator can be set via the generated code to a callback unary
+    // method, such as SetMessageAllocatorFor_Echo(custom_allocator). The allocator
+    // needs to be alive for the lifetime of the server.
+    // Implementations need to be thread-safe.
+    template<typename RequestT, typename ResponseT>
+    class MessageAllocator
+    {
+    public:
+        virtual ~MessageAllocator() = default;
+        virtual MessageHolder<RequestT, ResponseT>* AllocateMessages() = 0;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/metadata_map.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/metadata_map.h
index 931d682..bf2f890 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/metadata_map.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/metadata_map.h
@@ -26,81 +26,104 @@
 #include <grpc/impl/codegen/log.h>
 #include <grpcpp/impl/codegen/slice.h>
 
-namespace grpc {
-
-namespace internal {
-
-const char kBinaryErrorDetailsKey[] = "grpc-status-details-bin";
-
-class MetadataMap {
- public:
-  MetadataMap() { Setup(); }
-
-  ~MetadataMap() { Destroy(); }
-
-  std::string GetBinaryErrorDetails() {
-    // if filled_, extract from the multimap for O(log(n))
-    if (filled_) {
-      auto iter = map_.find(kBinaryErrorDetailsKey);
-      if (iter != map_.end()) {
-        return std::string(iter->second.begin(), iter->second.length());
-      }
-    }
-    // if not yet filled, take the O(n) lookup to avoid allocating the
-    // multimap until it is requested.
-    // TODO(ncteisen): plumb this through core as a first class object, just
-    // like code and message.
-    else {
-      for (size_t i = 0; i < arr_.count; i++) {
-        if (strncmp(reinterpret_cast<const char*>(
-                        GRPC_SLICE_START_PTR(arr_.metadata[i].key)),
-                    kBinaryErrorDetailsKey,
-                    GRPC_SLICE_LENGTH(arr_.metadata[i].key)) == 0) {
-          return std::string(reinterpret_cast<const char*>(
-                                 GRPC_SLICE_START_PTR(arr_.metadata[i].value)),
-                             GRPC_SLICE_LENGTH(arr_.metadata[i].value));
-        }
-      }
-    }
-    return std::string();
-  }
-
-  std::multimap<grpc::string_ref, grpc::string_ref>* map() {
-    FillMap();
-    return &map_;
-  }
-  grpc_metadata_array* arr() { return &arr_; }
-
-  void Reset() {
-    filled_ = false;
-    map_.clear();
-    Destroy();
-    Setup();
-  }
-
- private:
-  bool filled_ = false;
-  grpc_metadata_array arr_;
-  std::multimap<grpc::string_ref, grpc::string_ref> map_;
-
-  void Destroy() {
-    g_core_codegen_interface->grpc_metadata_array_destroy(&arr_);
-  }
-
-  void Setup() { memset(&arr_, 0, sizeof(arr_)); }
-
-  void FillMap() {
-    if (filled_) return;
-    filled_ = true;
-    for (size_t i = 0; i < arr_.count; i++) {
-      // TODO(yangg) handle duplicates?
-      map_.insert(std::pair<grpc::string_ref, grpc::string_ref>(
-          StringRefFromSlice(&arr_.metadata[i].key),
-          StringRefFromSlice(&arr_.metadata[i].value)));
-    }
-  }
-};
-}  // namespace internal
+namespace grpc
+{
+
+    namespace internal
+    {
+
+        const char kBinaryErrorDetailsKey[] = "grpc-status-details-bin";
+
+        class MetadataMap
+        {
+        public:
+            MetadataMap()
+            {
+                Setup();
+            }
+
+            ~MetadataMap()
+            {
+                Destroy();
+            }
+
+            std::string GetBinaryErrorDetails()
+            {
+                // if filled_, extract from the multimap for O(log(n))
+                if (filled_)
+                {
+                    auto iter = map_.find(kBinaryErrorDetailsKey);
+                    if (iter != map_.end())
+                    {
+                        return std::string(iter->second.begin(), iter->second.length());
+                    }
+                }
+                // if not yet filled, take the O(n) lookup to avoid allocating the
+                // multimap until it is requested.
+                // TODO(ncteisen): plumb this through core as a first class object, just
+                // like code and message.
+                else
+                {
+                    for (size_t i = 0; i < arr_.count; i++)
+                    {
+                        if (strncmp(reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(arr_.metadata[i].key)), kBinaryErrorDetailsKey, GRPC_SLICE_LENGTH(arr_.metadata[i].key)) == 0)
+                        {
+                            return std::string(reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(arr_.metadata[i].value)), GRPC_SLICE_LENGTH(arr_.metadata[i].value));
+                        }
+                    }
+                }
+                return std::string();
+            }
+
+            std::multimap<grpc::string_ref, grpc::string_ref>* map()
+            {
+                FillMap();
+                return &map_;
+            }
+            grpc_metadata_array* arr()
+            {
+                return &arr_;
+            }
+
+            void Reset()
+            {
+                filled_ = false;
+                map_.clear();
+                Destroy();
+                Setup();
+            }
+
+        private:
+            bool filled_ = false;
+            grpc_metadata_array arr_;
+            std::multimap<grpc::string_ref, grpc::string_ref> map_;
+
+            void Destroy()
+            {
+                g_core_codegen_interface->grpc_metadata_array_destroy(&arr_);
+            }
+
+            void Setup()
+            {
+                memset(&arr_, 0, sizeof(arr_));
+            }
+
+            void FillMap()
+            {
+                if (filled_)
+                    return;
+                filled_ = true;
+                for (size_t i = 0; i < arr_.count; i++)
+                {
+                    // TODO(yangg) handle duplicates?
+                    map_.insert(std::pair<grpc::string_ref, grpc::string_ref>(
+                        StringRefFromSlice(&arr_.metadata[i].key),
+                        StringRefFromSlice(&arr_.metadata[i].value)
+                    ));
+                }
+            }
+        };
+    }  // namespace internal
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler.h
index 5805631..e47e5af 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/method_handler.h
@@ -26,381 +26,409 @@
 #include <grpcpp/impl/codegen/rpc_service_method.h>
 #include <grpcpp/impl/codegen/sync_stream.h>
 
-namespace grpc {
-
-namespace internal {
-
-// Invoke the method handler, fill in the status, and
-// return whether or not we finished safely (without an exception).
-// Note that exception handling is 0-cost in most compiler/library
-// implementations (except when an exception is actually thrown),
-// so this process doesn't require additional overhead in the common case.
-// Additionally, we don't need to return if we caught an exception or not;
-// the handling is the same in either case.
-template <class Callable>
-::grpc::Status CatchingFunctionHandler(Callable&& handler) {
+namespace grpc
+{
+
+    namespace internal
+    {
+
+        // Invoke the method handler, fill in the status, and
+        // return whether or not we finished safely (without an exception).
+        // Note that exception handling is 0-cost in most compiler/library
+        // implementations (except when an exception is actually thrown),
+        // so this process doesn't require additional overhead in the common case.
+        // Additionally, we don't need to return if we caught an exception or not;
+        // the handling is the same in either case.
+        template<class Callable>
+        ::grpc::Status CatchingFunctionHandler(Callable&& handler)
+        {
 #if GRPC_ALLOW_EXCEPTIONS
-  try {
-    return handler();
-  } catch (...) {
-    return grpc::Status(grpc::StatusCode::UNKNOWN,
-                        "Unexpected error in RPC handling");
-  }
+            try
+            {
+                return handler();
+            }
+            catch (...)
+            {
+                return grpc::Status(grpc::StatusCode::UNKNOWN, "Unexpected error in RPC handling");
+            }
 #else   // GRPC_ALLOW_EXCEPTIONS
-  return handler();
+            return handler();
 #endif  // GRPC_ALLOW_EXCEPTIONS
-}
-
-/// A helper function with reduced templating to do the common work needed to
-/// actually send the server response. Uses non-const parameter for Status since
-/// this should only ever be called from the end of the RunHandler method.
-
-template <class ResponseType>
-void UnaryRunHandlerHelper(const MethodHandler::HandlerParameter& param,
-                           ResponseType* rsp, grpc::Status& status) {
-  GPR_CODEGEN_ASSERT(!param.server_context->sent_initial_metadata_);
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage,
-                            grpc::internal::CallOpServerSendStatus>
-      ops;
-  ops.SendInitialMetadata(&param.server_context->initial_metadata_,
-                          param.server_context->initial_metadata_flags());
-  if (param.server_context->compression_level_set()) {
-    ops.set_compression_level(param.server_context->compression_level());
-  }
-  if (status.ok()) {
-    status = ops.SendMessagePtr(rsp);
-  }
-  ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
-  param.call->PerformOps(&ops);
-  param.call->cq()->Pluck(&ops);
-}
-
-/// A helper function with reduced templating to do deserializing.
-
-template <class RequestType>
-void* UnaryDeserializeHelper(grpc_byte_buffer* req, grpc::Status* status,
-                             RequestType* request) {
-  grpc::ByteBuffer buf;
-  buf.set_buffer(req);
-  *status = grpc::SerializationTraits<RequestType>::Deserialize(
-      &buf, static_cast<RequestType*>(request));
-  buf.Release();
-  if (status->ok()) {
-    return request;
-  }
-  request->~RequestType();
-  return nullptr;
-}
-
-/// A wrapper class of an application provided rpc method handler.
-template <class ServiceType, class RequestType, class ResponseType,
-          class BaseRequestType = RequestType,
-          class BaseResponseType = ResponseType>
-class RpcMethodHandler : public grpc::internal::MethodHandler {
- public:
-  RpcMethodHandler(
-      std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
-                                 const RequestType*, ResponseType*)>
-          func,
-      ServiceType* service)
-      : func_(func), service_(service) {}
-
-  void RunHandler(const HandlerParameter& param) final {
-    ResponseType rsp;
-    grpc::Status status = param.status;
-    if (status.ok()) {
-      status = CatchingFunctionHandler([this, &param, &rsp] {
-        return func_(service_,
-                     static_cast<grpc::ServerContext*>(param.server_context),
-                     static_cast<RequestType*>(param.request), &rsp);
-      });
-      static_cast<RequestType*>(param.request)->~RequestType();
-    }
-    UnaryRunHandlerHelper(param, static_cast<BaseResponseType*>(&rsp), status);
-  }
-
-  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
-                    grpc::Status* status, void** /*handler_data*/) final {
-    auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call, sizeof(RequestType))) RequestType;
-    return UnaryDeserializeHelper(req, status,
-                                  static_cast<BaseRequestType*>(request));
-  }
-
- private:
-  /// Application provided rpc handler function.
-  std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
-                             const RequestType*, ResponseType*)>
-      func_;
-  // The class the above handler function lives in.
-  ServiceType* service_;
-};
-
-/// A wrapper class of an application provided client streaming handler.
-template <class ServiceType, class RequestType, class ResponseType>
-class ClientStreamingHandler : public grpc::internal::MethodHandler {
- public:
-  ClientStreamingHandler(
-      std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
-                                 ServerReader<RequestType>*, ResponseType*)>
-          func,
-      ServiceType* service)
-      : func_(func), service_(service) {}
-
-  void RunHandler(const HandlerParameter& param) final {
-    ServerReader<RequestType> reader(
-        param.call, static_cast<grpc::ServerContext*>(param.server_context));
-    ResponseType rsp;
-    grpc::Status status =
-        CatchingFunctionHandler([this, &param, &reader, &rsp] {
-          return func_(service_,
-                       static_cast<grpc::ServerContext*>(param.server_context),
-                       &reader, &rsp);
-        });
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage,
-                              grpc::internal::CallOpServerSendStatus>
-        ops;
-    if (!param.server_context->sent_initial_metadata_) {
-      ops.SendInitialMetadata(&param.server_context->initial_metadata_,
-                              param.server_context->initial_metadata_flags());
-      if (param.server_context->compression_level_set()) {
-        ops.set_compression_level(param.server_context->compression_level());
-      }
-    }
-    if (status.ok()) {
-      status = ops.SendMessagePtr(&rsp);
-    }
-    ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
-    param.call->PerformOps(&ops);
-    param.call->cq()->Pluck(&ops);
-  }
-
- private:
-  std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
-                             ServerReader<RequestType>*, ResponseType*)>
-      func_;
-  ServiceType* service_;
-};
-
-/// A wrapper class of an application provided server streaming handler.
-template <class ServiceType, class RequestType, class ResponseType>
-class ServerStreamingHandler : public grpc::internal::MethodHandler {
- public:
-  ServerStreamingHandler(std::function<grpc::Status(
-                             ServiceType*, grpc::ServerContext*,
-                             const RequestType*, ServerWriter<ResponseType>*)>
-                             func,
-                         ServiceType* service)
-      : func_(func), service_(service) {}
-
-  void RunHandler(const HandlerParameter& param) final {
-    grpc::Status status = param.status;
-    if (status.ok()) {
-      ServerWriter<ResponseType> writer(
-          param.call, static_cast<grpc::ServerContext*>(param.server_context));
-      status = CatchingFunctionHandler([this, &param, &writer] {
-        return func_(service_,
-                     static_cast<grpc::ServerContext*>(param.server_context),
-                     static_cast<RequestType*>(param.request), &writer);
-      });
-      static_cast<RequestType*>(param.request)->~RequestType();
-    }
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpServerSendStatus>
-        ops;
-    if (!param.server_context->sent_initial_metadata_) {
-      ops.SendInitialMetadata(&param.server_context->initial_metadata_,
-                              param.server_context->initial_metadata_flags());
-      if (param.server_context->compression_level_set()) {
-        ops.set_compression_level(param.server_context->compression_level());
-      }
-    }
-    ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
-    param.call->PerformOps(&ops);
-    if (param.server_context->has_pending_ops_) {
-      param.call->cq()->Pluck(&param.server_context->pending_ops_);
-    }
-    param.call->cq()->Pluck(&ops);
-  }
-
-  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
-                    grpc::Status* status, void** /*handler_data*/) final {
-    grpc::ByteBuffer buf;
-    buf.set_buffer(req);
-    auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call, sizeof(RequestType))) RequestType();
-    *status =
-        grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
-    buf.Release();
-    if (status->ok()) {
-      return request;
-    }
-    request->~RequestType();
-    return nullptr;
-  }
-
- private:
-  std::function<grpc::Status(ServiceType*, grpc::ServerContext*,
-                             const RequestType*, ServerWriter<ResponseType>*)>
-      func_;
-  ServiceType* service_;
-};
-
-/// A wrapper class of an application provided bidi-streaming handler.
-/// This also applies to server-streamed implementation of a unary method
-/// with the additional requirement that such methods must have done a
-/// write for status to be ok
-/// Since this is used by more than 1 class, the service is not passed in.
-/// Instead, it is expected to be an implicitly-captured argument of func
-/// (through bind or something along those lines)
-template <class Streamer, bool WriteNeeded>
-class TemplatedBidiStreamingHandler : public grpc::internal::MethodHandler {
- public:
-  explicit TemplatedBidiStreamingHandler(
-      std::function<grpc::Status(grpc::ServerContext*, Streamer*)> func)
-      : func_(func), write_needed_(WriteNeeded) {}
-
-  void RunHandler(const HandlerParameter& param) final {
-    Streamer stream(param.call,
-                    static_cast<grpc::ServerContext*>(param.server_context));
-    grpc::Status status = CatchingFunctionHandler([this, &param, &stream] {
-      return func_(static_cast<grpc::ServerContext*>(param.server_context),
-                   &stream);
-    });
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpServerSendStatus>
-        ops;
-    if (!param.server_context->sent_initial_metadata_) {
-      ops.SendInitialMetadata(&param.server_context->initial_metadata_,
-                              param.server_context->initial_metadata_flags());
-      if (param.server_context->compression_level_set()) {
-        ops.set_compression_level(param.server_context->compression_level());
-      }
-      if (write_needed_ && status.ok()) {
-        // If we needed a write but never did one, we need to mark the
-        // status as a fail
-        status = grpc::Status(grpc::StatusCode::INTERNAL,
-                              "Service did not provide response message");
-      }
-    }
-    ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
-    param.call->PerformOps(&ops);
-    if (param.server_context->has_pending_ops_) {
-      param.call->cq()->Pluck(&param.server_context->pending_ops_);
-    }
-    param.call->cq()->Pluck(&ops);
-  }
-
- private:
-  std::function<grpc::Status(grpc::ServerContext*, Streamer*)> func_;
-  const bool write_needed_;
-};
-
-template <class ServiceType, class RequestType, class ResponseType>
-class BidiStreamingHandler
-    : public TemplatedBidiStreamingHandler<
-          ServerReaderWriter<ResponseType, RequestType>, false> {
- public:
-  BidiStreamingHandler(std::function<grpc::Status(
-                           ServiceType*, grpc::ServerContext*,
-                           ServerReaderWriter<ResponseType, RequestType>*)>
-                           func,
-                       ServiceType* service)
-      // TODO(vjpai): When gRPC supports C++14, move-capture func in the below
-      : TemplatedBidiStreamingHandler<
-            ServerReaderWriter<ResponseType, RequestType>, false>(
-            [func, service](
-                grpc::ServerContext* ctx,
-                ServerReaderWriter<ResponseType, RequestType>* streamer) {
-              return func(service, ctx, streamer);
-            }) {}
-};
-
-template <class RequestType, class ResponseType>
-class StreamedUnaryHandler
-    : public TemplatedBidiStreamingHandler<
-          ServerUnaryStreamer<RequestType, ResponseType>, true> {
- public:
-  explicit StreamedUnaryHandler(
-      std::function<
-          grpc::Status(grpc::ServerContext*,
-                       ServerUnaryStreamer<RequestType, ResponseType>*)>
-          func)
-      : TemplatedBidiStreamingHandler<
-            ServerUnaryStreamer<RequestType, ResponseType>, true>(
-            std::move(func)) {}
-};
-
-template <class RequestType, class ResponseType>
-class SplitServerStreamingHandler
-    : public TemplatedBidiStreamingHandler<
-          ServerSplitStreamer<RequestType, ResponseType>, false> {
- public:
-  explicit SplitServerStreamingHandler(
-      std::function<
-          grpc::Status(grpc::ServerContext*,
-                       ServerSplitStreamer<RequestType, ResponseType>*)>
-          func)
-      : TemplatedBidiStreamingHandler<
-            ServerSplitStreamer<RequestType, ResponseType>, false>(
-            std::move(func)) {}
-};
-
-/// General method handler class for errors that prevent real method use
-/// e.g., handle unknown method by returning UNIMPLEMENTED error.
-template <grpc::StatusCode code>
-class ErrorMethodHandler : public grpc::internal::MethodHandler {
- public:
-  explicit ErrorMethodHandler(const std::string& message) : message_(message) {}
-
-  template <class T>
-  static void FillOps(grpc::ServerContextBase* context,
-                      const std::string& message, T* ops) {
-    grpc::Status status(code, message);
-    if (!context->sent_initial_metadata_) {
-      ops->SendInitialMetadata(&context->initial_metadata_,
-                               context->initial_metadata_flags());
-      if (context->compression_level_set()) {
-        ops->set_compression_level(context->compression_level());
-      }
-      context->sent_initial_metadata_ = true;
-    }
-    ops->ServerSendStatus(&context->trailing_metadata_, status);
-  }
-
-  void RunHandler(const HandlerParameter& param) final {
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpServerSendStatus>
-        ops;
-    FillOps(param.server_context, message_, &ops);
-    param.call->PerformOps(&ops);
-    param.call->cq()->Pluck(&ops);
-  }
-
-  void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req,
-                    grpc::Status* /*status*/, void** /*handler_data*/) final {
-    // We have to destroy any request payload
-    if (req != nullptr) {
-      grpc::g_core_codegen_interface->grpc_byte_buffer_destroy(req);
-    }
-    return nullptr;
-  }
-
- private:
-  const std::string message_;
-};
-
-typedef ErrorMethodHandler<grpc::StatusCode::UNIMPLEMENTED>
-    UnknownMethodHandler;
-typedef ErrorMethodHandler<grpc::StatusCode::RESOURCE_EXHAUSTED>
-    ResourceExhaustedHandler;
-
-}  // namespace internal
+        }
+
+        /// A helper function with reduced templating to do the common work needed to
+        /// actually send the server response. Uses non-const parameter for Status since
+        /// this should only ever be called from the end of the RunHandler method.
+
+        template<class ResponseType>
+        void UnaryRunHandlerHelper(const MethodHandler::HandlerParameter& param, ResponseType* rsp, grpc::Status& status)
+        {
+            GPR_CODEGEN_ASSERT(!param.server_context->sent_initial_metadata_);
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+                ops;
+            ops.SendInitialMetadata(&param.server_context->initial_metadata_, param.server_context->initial_metadata_flags());
+            if (param.server_context->compression_level_set())
+            {
+                ops.set_compression_level(param.server_context->compression_level());
+            }
+            if (status.ok())
+            {
+                status = ops.SendMessagePtr(rsp);
+            }
+            ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
+            param.call->PerformOps(&ops);
+            param.call->cq()->Pluck(&ops);
+        }
+
+        /// A helper function with reduced templating to do deserializing.
+
+        template<class RequestType>
+        void* UnaryDeserializeHelper(grpc_byte_buffer* req, grpc::Status* status, RequestType* request)
+        {
+            grpc::ByteBuffer buf;
+            buf.set_buffer(req);
+            *status = grpc::SerializationTraits<RequestType>::Deserialize(
+                &buf, static_cast<RequestType*>(request)
+            );
+            buf.Release();
+            if (status->ok())
+            {
+                return request;
+            }
+            request->~RequestType();
+            return nullptr;
+        }
+
+        /// A wrapper class of an application provided rpc method handler.
+        template<class ServiceType, class RequestType, class ResponseType, class BaseRequestType = RequestType, class BaseResponseType = ResponseType>
+        class RpcMethodHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            RpcMethodHandler(
+                std::function<grpc::Status(ServiceType*, grpc::ServerContext*, const RequestType*, ResponseType*)>
+                    func,
+                ServiceType* service
+            ) :
+                func_(func),
+                service_(service)
+            {
+            }
+
+            void RunHandler(const HandlerParameter& param) final
+            {
+                ResponseType rsp;
+                grpc::Status status = param.status;
+                if (status.ok())
+                {
+                    status = CatchingFunctionHandler([this, &param, &rsp]
+                                                     { return func_(service_, static_cast<grpc::ServerContext*>(param.server_context), static_cast<RequestType*>(param.request), &rsp); });
+                    static_cast<RequestType*>(param.request)->~RequestType();
+                }
+                UnaryRunHandlerHelper(param, static_cast<BaseResponseType*>(&rsp), status);
+            }
+
+            void* Deserialize(grpc_call* call, grpc_byte_buffer* req, grpc::Status* status, void** /*handler_data*/) final
+            {
+                auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call, sizeof(RequestType)
+                )) RequestType;
+                return UnaryDeserializeHelper(req, status, static_cast<BaseRequestType*>(request));
+            }
+
+        private:
+            /// Application provided rpc handler function.
+            std::function<grpc::Status(ServiceType*, grpc::ServerContext*, const RequestType*, ResponseType*)>
+                func_;
+            // The class the above handler function lives in.
+            ServiceType* service_;
+        };
+
+        /// A wrapper class of an application provided client streaming handler.
+        template<class ServiceType, class RequestType, class ResponseType>
+        class ClientStreamingHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            ClientStreamingHandler(
+                std::function<grpc::Status(ServiceType*, grpc::ServerContext*, ServerReader<RequestType>*, ResponseType*)>
+                    func,
+                ServiceType* service
+            ) :
+                func_(func),
+                service_(service)
+            {
+            }
+
+            void RunHandler(const HandlerParameter& param) final
+            {
+                ServerReader<RequestType> reader(
+                    param.call, static_cast<grpc::ServerContext*>(param.server_context)
+                );
+                ResponseType rsp;
+                grpc::Status status =
+                    CatchingFunctionHandler([this, &param, &reader, &rsp]
+                                            { return func_(service_, static_cast<grpc::ServerContext*>(param.server_context), &reader, &rsp); });
+
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+                    ops;
+                if (!param.server_context->sent_initial_metadata_)
+                {
+                    ops.SendInitialMetadata(&param.server_context->initial_metadata_, param.server_context->initial_metadata_flags());
+                    if (param.server_context->compression_level_set())
+                    {
+                        ops.set_compression_level(param.server_context->compression_level());
+                    }
+                }
+                if (status.ok())
+                {
+                    status = ops.SendMessagePtr(&rsp);
+                }
+                ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
+                param.call->PerformOps(&ops);
+                param.call->cq()->Pluck(&ops);
+            }
+
+        private:
+            std::function<grpc::Status(ServiceType*, grpc::ServerContext*, ServerReader<RequestType>*, ResponseType*)>
+                func_;
+            ServiceType* service_;
+        };
+
+        /// A wrapper class of an application provided server streaming handler.
+        template<class ServiceType, class RequestType, class ResponseType>
+        class ServerStreamingHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            ServerStreamingHandler(std::function<grpc::Status(ServiceType*, grpc::ServerContext*, const RequestType*, ServerWriter<ResponseType>*)> func, ServiceType* service) :
+                func_(func),
+                service_(service)
+            {
+            }
+
+            void RunHandler(const HandlerParameter& param) final
+            {
+                grpc::Status status = param.status;
+                if (status.ok())
+                {
+                    ServerWriter<ResponseType> writer(
+                        param.call, static_cast<grpc::ServerContext*>(param.server_context)
+                    );
+                    status = CatchingFunctionHandler([this, &param, &writer]
+                                                     { return func_(service_, static_cast<grpc::ServerContext*>(param.server_context), static_cast<RequestType*>(param.request), &writer); });
+                    static_cast<RequestType*>(param.request)->~RequestType();
+                }
+
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpServerSendStatus>
+                    ops;
+                if (!param.server_context->sent_initial_metadata_)
+                {
+                    ops.SendInitialMetadata(&param.server_context->initial_metadata_, param.server_context->initial_metadata_flags());
+                    if (param.server_context->compression_level_set())
+                    {
+                        ops.set_compression_level(param.server_context->compression_level());
+                    }
+                }
+                ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
+                param.call->PerformOps(&ops);
+                if (param.server_context->has_pending_ops_)
+                {
+                    param.call->cq()->Pluck(&param.server_context->pending_ops_);
+                }
+                param.call->cq()->Pluck(&ops);
+            }
+
+            void* Deserialize(grpc_call* call, grpc_byte_buffer* req, grpc::Status* status, void** /*handler_data*/) final
+            {
+                grpc::ByteBuffer buf;
+                buf.set_buffer(req);
+                auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call, sizeof(RequestType)
+                )) RequestType();
+                *status =
+                    grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
+                buf.Release();
+                if (status->ok())
+                {
+                    return request;
+                }
+                request->~RequestType();
+                return nullptr;
+            }
+
+        private:
+            std::function<grpc::Status(ServiceType*, grpc::ServerContext*, const RequestType*, ServerWriter<ResponseType>*)>
+                func_;
+            ServiceType* service_;
+        };
+
+        /// A wrapper class of an application provided bidi-streaming handler.
+        /// This also applies to server-streamed implementation of a unary method
+        /// with the additional requirement that such methods must have done a
+        /// write for status to be ok
+        /// Since this is used by more than 1 class, the service is not passed in.
+        /// Instead, it is expected to be an implicitly-captured argument of func
+        /// (through bind or something along those lines)
+        template<class Streamer, bool WriteNeeded>
+        class TemplatedBidiStreamingHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            explicit TemplatedBidiStreamingHandler(
+                std::function<grpc::Status(grpc::ServerContext*, Streamer*)> func
+            ) :
+                func_(func),
+                write_needed_(WriteNeeded)
+            {
+            }
+
+            void RunHandler(const HandlerParameter& param) final
+            {
+                Streamer stream(param.call, static_cast<grpc::ServerContext*>(param.server_context));
+                grpc::Status status = CatchingFunctionHandler([this, &param, &stream]
+                                                              { return func_(static_cast<grpc::ServerContext*>(param.server_context), &stream); });
+
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpServerSendStatus>
+                    ops;
+                if (!param.server_context->sent_initial_metadata_)
+                {
+                    ops.SendInitialMetadata(&param.server_context->initial_metadata_, param.server_context->initial_metadata_flags());
+                    if (param.server_context->compression_level_set())
+                    {
+                        ops.set_compression_level(param.server_context->compression_level());
+                    }
+                    if (write_needed_ && status.ok())
+                    {
+                        // If we needed a write but never did one, we need to mark the
+                        // status as a fail
+                        status = grpc::Status(grpc::StatusCode::INTERNAL, "Service did not provide response message");
+                    }
+                }
+                ops.ServerSendStatus(&param.server_context->trailing_metadata_, status);
+                param.call->PerformOps(&ops);
+                if (param.server_context->has_pending_ops_)
+                {
+                    param.call->cq()->Pluck(&param.server_context->pending_ops_);
+                }
+                param.call->cq()->Pluck(&ops);
+            }
+
+        private:
+            std::function<grpc::Status(grpc::ServerContext*, Streamer*)> func_;
+            const bool write_needed_;
+        };
+
+        template<class ServiceType, class RequestType, class ResponseType>
+        class BidiStreamingHandler : public TemplatedBidiStreamingHandler<ServerReaderWriter<ResponseType, RequestType>, false>
+        {
+        public:
+            BidiStreamingHandler(std::function<grpc::Status(ServiceType*, grpc::ServerContext*, ServerReaderWriter<ResponseType, RequestType>*)> func, ServiceType* service)
+                // TODO(vjpai): When gRPC supports C++14, move-capture func in the below
+                :
+                TemplatedBidiStreamingHandler<
+                    ServerReaderWriter<ResponseType, RequestType>,
+                    false>(
+                    [func, service](
+                        grpc::ServerContext* ctx,
+                        ServerReaderWriter<ResponseType, RequestType>* streamer
+                    )
+                    {
+                        return func(service, ctx, streamer);
+                    }
+                )
+            {
+            }
+        };
+
+        template<class RequestType, class ResponseType>
+        class StreamedUnaryHandler : public TemplatedBidiStreamingHandler<ServerUnaryStreamer<RequestType, ResponseType>, true>
+        {
+        public:
+            explicit StreamedUnaryHandler(
+                std::function<
+                    grpc::Status(grpc::ServerContext*, ServerUnaryStreamer<RequestType, ResponseType>*)>
+                    func
+            ) :
+                TemplatedBidiStreamingHandler<
+                    ServerUnaryStreamer<RequestType, ResponseType>,
+                    true>(
+                    std::move(func)
+                )
+            {
+            }
+        };
+
+        template<class RequestType, class ResponseType>
+        class SplitServerStreamingHandler : public TemplatedBidiStreamingHandler<ServerSplitStreamer<RequestType, ResponseType>, false>
+        {
+        public:
+            explicit SplitServerStreamingHandler(
+                std::function<
+                    grpc::Status(grpc::ServerContext*, ServerSplitStreamer<RequestType, ResponseType>*)>
+                    func
+            ) :
+                TemplatedBidiStreamingHandler<
+                    ServerSplitStreamer<RequestType, ResponseType>,
+                    false>(
+                    std::move(func)
+                )
+            {
+            }
+        };
+
+        /// General method handler class for errors that prevent real method use
+        /// e.g., handle unknown method by returning UNIMPLEMENTED error.
+        template<grpc::StatusCode code>
+        class ErrorMethodHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            explicit ErrorMethodHandler(const std::string& message) :
+                message_(message)
+            {
+            }
+
+            template<class T>
+            static void FillOps(grpc::ServerContextBase* context, const std::string& message, T* ops)
+            {
+                grpc::Status status(code, message);
+                if (!context->sent_initial_metadata_)
+                {
+                    ops->SendInitialMetadata(&context->initial_metadata_, context->initial_metadata_flags());
+                    if (context->compression_level_set())
+                    {
+                        ops->set_compression_level(context->compression_level());
+                    }
+                    context->sent_initial_metadata_ = true;
+                }
+                ops->ServerSendStatus(&context->trailing_metadata_, status);
+            }
+
+            void RunHandler(const HandlerParameter& param) final
+            {
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpServerSendStatus>
+                    ops;
+                FillOps(param.server_context, message_, &ops);
+                param.call->PerformOps(&ops);
+                param.call->cq()->Pluck(&ops);
+            }
+
+            void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req, grpc::Status* /*status*/, void** /*handler_data*/) final
+            {
+                // We have to destroy any request payload
+                if (req != nullptr)
+                {
+                    grpc::g_core_codegen_interface->grpc_byte_buffer_destroy(req);
+                }
+                return nullptr;
+            }
+
+        private:
+            const std::string message_;
+        };
+
+        typedef ErrorMethodHandler<grpc::StatusCode::UNIMPLEMENTED>
+            UnknownMethodHandler;
+        typedef ErrorMethodHandler<grpc::StatusCode::RESOURCE_EXHAUSTED>
+            ResourceExhaustedHandler;
+
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_METHOD_HANDLER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_reader.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_reader.h
index ecc0e30..7e4f91a 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_reader.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_reader.h
@@ -35,116 +35,156 @@
 /// This header provides an object that reads bytes directly from a
 /// grpc::ByteBuffer, via the ZeroCopyInputStream interface
 
-namespace grpc {
-
-extern CoreCodegenInterface* g_core_codegen_interface;
-
-/// This is a specialization of the protobuf class ZeroCopyInputStream
-/// The principle is to get one chunk of data at a time from the proto layer,
-/// with options to backup (re-see some bytes) or skip (forward past some bytes)
-///
-/// Read more about ZeroCopyInputStream interface here:
-/// https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.io.zero_copy_stream#ZeroCopyInputStream
-class ProtoBufferReader : public grpc::protobuf::io::ZeroCopyInputStream {
- public:
-  /// Constructs buffer reader from \a buffer. Will set \a status() to non ok
-  /// if \a buffer is invalid (the internal buffer has not been initialized).
-  explicit ProtoBufferReader(ByteBuffer* buffer)
-      : byte_count_(0), backup_count_(0), status_() {
-    /// Implemented through a grpc_byte_buffer_reader which iterates
-    /// over the slices that make up a byte buffer
-    if (!buffer->Valid() ||
-        !g_core_codegen_interface->grpc_byte_buffer_reader_init(
-            &reader_, buffer->c_buffer())) {
-      status_ = Status(StatusCode::INTERNAL,
-                       "Couldn't initialize byte buffer reader");
-    }
-  }
-
-  ~ProtoBufferReader() override {
-    if (status_.ok()) {
-      g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_);
-    }
-  }
-
-  /// Give the proto library a chunk of data from the stream. The caller
-  /// may safely read from data[0, size - 1].
-  bool Next(const void** data, int* size) override {
-    if (!status_.ok()) {
-      return false;
-    }
-    /// If we have backed up previously, we need to return the backed-up slice
-    if (backup_count_ > 0) {
-      *data = GRPC_SLICE_START_PTR(*slice_) + GRPC_SLICE_LENGTH(*slice_) -
-              backup_count_;
-      GPR_CODEGEN_ASSERT(backup_count_ <= INT_MAX);
-      *size = static_cast<int>(backup_count_);
-      backup_count_ = 0;
-      return true;
-    }
-    /// Otherwise get the next slice from the byte buffer reader
-    if (!g_core_codegen_interface->grpc_byte_buffer_reader_peek(&reader_,
-                                                                &slice_)) {
-      return false;
-    }
-    *data = GRPC_SLICE_START_PTR(*slice_);
-    // On win x64, int is only 32bit
-    GPR_CODEGEN_ASSERT(GRPC_SLICE_LENGTH(*slice_) <= INT_MAX);
-    byte_count_ += * size = static_cast<int>(GRPC_SLICE_LENGTH(*slice_));
-    return true;
-  }
-
-  /// Returns the status of the buffer reader.
-  Status status() const { return status_; }
-
-  /// The proto library calls this to indicate that we should back up \a count
-  /// bytes that have already been returned by the last call of Next.
-  /// So do the backup and have that ready for a later Next.
-  void BackUp(int count) override {
-    GPR_CODEGEN_ASSERT(count <= static_cast<int>(GRPC_SLICE_LENGTH(*slice_)));
-    backup_count_ = count;
-  }
-
-  /// The proto library calls this to skip over \a count bytes. Implement this
-  /// using Next and BackUp combined.
-  bool Skip(int count) override {
-    const void* data;
-    int size;
-    while (Next(&data, &size)) {
-      if (size >= count) {
-        BackUp(size - count);
-        return true;
-      }
-      // size < count;
-      count -= size;
-    }
-    // error or we have too large count;
-    return false;
-  }
-
-  /// Returns the total number of bytes read since this object was created.
-  int64_t ByteCount() const override { return byte_count_ - backup_count_; }
-
-  // These protected members are needed to support internal optimizations.
-  // they expose internal bits of grpc core that are NOT stable. If you have
-  // a use case needs to use one of these functions, please send an email to
-  // https://groups.google.com/forum/#!forum/grpc-io.
- protected:
-  void set_byte_count(int64_t byte_count) { byte_count_ = byte_count; }
-  int64_t backup_count() { return backup_count_; }
-  void set_backup_count(int64_t backup_count) { backup_count_ = backup_count; }
-  grpc_byte_buffer_reader* reader() { return &reader_; }
-  grpc_slice* slice() { return slice_; }
-  grpc_slice** mutable_slice_ptr() { return &slice_; }
-
- private:
-  int64_t byte_count_;              ///< total bytes read since object creation
-  int64_t backup_count_;            ///< how far backed up in the stream we are
-  grpc_byte_buffer_reader reader_;  ///< internal object to read \a grpc_slice
-                                    ///< from the \a grpc_byte_buffer
-  grpc_slice* slice_;               ///< current slice passed back to the caller
-  Status status_;                   ///< status of the entire object
-};
+namespace grpc
+{
+
+    extern CoreCodegenInterface* g_core_codegen_interface;
+
+    /// This is a specialization of the protobuf class ZeroCopyInputStream
+    /// The principle is to get one chunk of data at a time from the proto layer,
+    /// with options to backup (re-see some bytes) or skip (forward past some bytes)
+    ///
+    /// Read more about ZeroCopyInputStream interface here:
+    /// https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.io.zero_copy_stream#ZeroCopyInputStream
+    class ProtoBufferReader : public grpc::protobuf::io::ZeroCopyInputStream
+    {
+    public:
+        /// Constructs buffer reader from \a buffer. Will set \a status() to non ok
+        /// if \a buffer is invalid (the internal buffer has not been initialized).
+        explicit ProtoBufferReader(ByteBuffer* buffer) :
+            byte_count_(0),
+            backup_count_(0),
+            status_()
+        {
+            /// Implemented through a grpc_byte_buffer_reader which iterates
+            /// over the slices that make up a byte buffer
+            if (!buffer->Valid() ||
+                !g_core_codegen_interface->grpc_byte_buffer_reader_init(
+                    &reader_, buffer->c_buffer()
+                ))
+            {
+                status_ = Status(StatusCode::INTERNAL, "Couldn't initialize byte buffer reader");
+            }
+        }
+
+        ~ProtoBufferReader() override
+        {
+            if (status_.ok())
+            {
+                g_core_codegen_interface->grpc_byte_buffer_reader_destroy(&reader_);
+            }
+        }
+
+        /// Give the proto library a chunk of data from the stream. The caller
+        /// may safely read from data[0, size - 1].
+        bool Next(const void** data, int* size) override
+        {
+            if (!status_.ok())
+            {
+                return false;
+            }
+            /// If we have backed up previously, we need to return the backed-up slice
+            if (backup_count_ > 0)
+            {
+                *data = GRPC_SLICE_START_PTR(*slice_) + GRPC_SLICE_LENGTH(*slice_) -
+                        backup_count_;
+                GPR_CODEGEN_ASSERT(backup_count_ <= INT_MAX);
+                *size = static_cast<int>(backup_count_);
+                backup_count_ = 0;
+                return true;
+            }
+            /// Otherwise get the next slice from the byte buffer reader
+            if (!g_core_codegen_interface->grpc_byte_buffer_reader_peek(&reader_, &slice_))
+            {
+                return false;
+            }
+            *data = GRPC_SLICE_START_PTR(*slice_);
+            // On win x64, int is only 32bit
+            GPR_CODEGEN_ASSERT(GRPC_SLICE_LENGTH(*slice_) <= INT_MAX);
+            byte_count_ += * size = static_cast<int>(GRPC_SLICE_LENGTH(*slice_));
+            return true;
+        }
+
+        /// Returns the status of the buffer reader.
+        Status status() const
+        {
+            return status_;
+        }
+
+        /// The proto library calls this to indicate that we should back up \a count
+        /// bytes that have already been returned by the last call of Next.
+        /// So do the backup and have that ready for a later Next.
+        void BackUp(int count) override
+        {
+            GPR_CODEGEN_ASSERT(count <= static_cast<int>(GRPC_SLICE_LENGTH(*slice_)));
+            backup_count_ = count;
+        }
+
+        /// The proto library calls this to skip over \a count bytes. Implement this
+        /// using Next and BackUp combined.
+        bool Skip(int count) override
+        {
+            const void* data;
+            int size;
+            while (Next(&data, &size))
+            {
+                if (size >= count)
+                {
+                    BackUp(size - count);
+                    return true;
+                }
+                // size < count;
+                count -= size;
+            }
+            // error or we have too large count;
+            return false;
+        }
+
+        /// Returns the total number of bytes read since this object was created.
+        int64_t ByteCount() const override
+        {
+            return byte_count_ - backup_count_;
+        }
+
+        // These protected members are needed to support internal optimizations.
+        // they expose internal bits of grpc core that are NOT stable. If you have
+        // a use case needs to use one of these functions, please send an email to
+        // https://groups.google.com/forum/#!forum/grpc-io.
+
+    protected:
+        void set_byte_count(int64_t byte_count)
+        {
+            byte_count_ = byte_count;
+        }
+        int64_t backup_count()
+        {
+            return backup_count_;
+        }
+        void set_backup_count(int64_t backup_count)
+        {
+            backup_count_ = backup_count;
+        }
+        grpc_byte_buffer_reader* reader()
+        {
+            return &reader_;
+        }
+        grpc_slice* slice()
+        {
+            return slice_;
+        }
+        grpc_slice** mutable_slice_ptr()
+        {
+            return &slice_;
+        }
+
+    private:
+        int64_t byte_count_;              ///< total bytes read since object creation
+        int64_t backup_count_;            ///< how far backed up in the stream we are
+        grpc_byte_buffer_reader reader_;  ///< internal object to read \a grpc_slice
+                                          ///< from the \a grpc_byte_buffer
+        grpc_slice* slice_;               ///< current slice passed back to the caller
+        Status status_;                   ///< status of the entire object
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_writer.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_writer.h
index efb6dd0..792fd85 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_writer.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_buffer_writer.h
@@ -34,147 +34,172 @@
 /// This header provides an object that writes bytes directly into a
 /// grpc::ByteBuffer, via the ZeroCopyOutputStream interface
 
-namespace grpc {
-
-extern CoreCodegenInterface* g_core_codegen_interface;
-
-// Forward declaration for testing use only
-namespace internal {
-class ProtoBufferWriterPeer;
-}  // namespace internal
-
-const int kProtoBufferWriterMaxBufferLength = 1024 * 1024;
-
-/// This is a specialization of the protobuf class ZeroCopyOutputStream.
-/// The principle is to give the proto layer one buffer of bytes at a time
-/// that it can use to serialize the next portion of the message, with the
-/// option to "backup" if more buffer is given than required at the last buffer.
-///
-/// Read more about ZeroCopyOutputStream interface here:
-/// https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.io.zero_copy_stream#ZeroCopyOutputStream
-class ProtoBufferWriter : public grpc::protobuf::io::ZeroCopyOutputStream {
- public:
-  /// Constructor for this derived class
-  ///
-  /// \param[out] byte_buffer A pointer to the grpc::ByteBuffer created
-  /// \param block_size How big are the chunks to allocate at a time
-  /// \param total_size How many total bytes are required for this proto
-  ProtoBufferWriter(ByteBuffer* byte_buffer, int block_size, int total_size)
-      : block_size_(block_size),
-        total_size_(total_size),
-        byte_count_(0),
-        have_backup_(false) {
-    GPR_CODEGEN_ASSERT(!byte_buffer->Valid());
-    /// Create an empty raw byte buffer and look at its underlying slice buffer
-    grpc_byte_buffer* bp =
-        g_core_codegen_interface->grpc_raw_byte_buffer_create(nullptr, 0);
-    byte_buffer->set_buffer(bp);
-    slice_buffer_ = &bp->data.raw.slice_buffer;
-  }
-
-  ~ProtoBufferWriter() override {
-    if (have_backup_) {
-      g_core_codegen_interface->grpc_slice_unref(backup_slice_);
-    }
-  }
-
-  /// Give the proto library the next buffer of bytes and its size. It is
-  /// safe for the caller to write from data[0, size - 1].
-  bool Next(void** data, int* size) override {
-    // Protobuf should not ask for more memory than total_size_.
-    GPR_CODEGEN_ASSERT(byte_count_ < total_size_);
-    // 1. Use the remaining backup slice if we have one
-    // 2. Otherwise allocate a slice, up to the remaining length needed
-    //    or our maximum allocation size
-    // 3. Provide the slice start and size available
-    // 4. Add the slice being returned to the slice buffer
-    size_t remain = static_cast<size_t>(total_size_ - byte_count_);
-    if (have_backup_) {
-      /// If we have a backup slice, we should use it first
-      slice_ = backup_slice_;
-      have_backup_ = false;
-      if (GRPC_SLICE_LENGTH(slice_) > remain) {
-        GRPC_SLICE_SET_LENGTH(slice_, remain);
-      }
-    } else {
-      // When less than a whole block is needed, only allocate that much.
-      // But make sure the allocated slice is not inlined.
-      size_t allocate_length =
-          remain > static_cast<size_t>(block_size_) ? block_size_ : remain;
-      slice_ = g_core_codegen_interface->grpc_slice_malloc(
-          allocate_length > GRPC_SLICE_INLINED_SIZE
-              ? allocate_length
-              : GRPC_SLICE_INLINED_SIZE + 1);
-    }
-    *data = GRPC_SLICE_START_PTR(slice_);
-    // On win x64, int is only 32bit
-    GPR_CODEGEN_ASSERT(GRPC_SLICE_LENGTH(slice_) <= INT_MAX);
-    byte_count_ += * size = static_cast<int>(GRPC_SLICE_LENGTH(slice_));
-    // Using grpc_slice_buffer_add could modify slice_ and merge it with the
-    // previous slice. Therefore, use grpc_slice_buffer_add_indexed method to
-    // ensure the slice gets added at a separate index. It can then be kept
-    // around and popped later in the BackUp function.
-    g_core_codegen_interface->grpc_slice_buffer_add_indexed(slice_buffer_,
-                                                            slice_);
-    return true;
-  }
-
-  /// Backup by \a count bytes because Next returned more bytes than needed
-  /// (only used in the last buffer). \a count must be less than or equal too
-  /// the last buffer returned from next.
-  void BackUp(int count) override {
-    // count == 0 is invoked by ZeroCopyOutputStream users indicating that any
-    // potential buffer obtained through a previous call to Next() is final.
-    // ZeroCopyOutputStream implementations such as streaming output can use
-    // these calls to flush any temporary buffer and flush the output. The logic
-    // below is not robust against count == 0 invocations, so directly return.
-    if (count == 0) return;
-
-    /// 1. Remove the partially-used last slice from the slice buffer
-    /// 2. Split it into the needed (if any) and unneeded part
-    /// 3. Add the needed part back to the slice buffer
-    /// 4. Mark that we still have the remaining part (for later use/unref)
-    GPR_CODEGEN_ASSERT(count <= static_cast<int>(GRPC_SLICE_LENGTH(slice_)));
-    g_core_codegen_interface->grpc_slice_buffer_pop(slice_buffer_);
-    if (static_cast<size_t>(count) == GRPC_SLICE_LENGTH(slice_)) {
-      backup_slice_ = slice_;
-    } else {
-      backup_slice_ = g_core_codegen_interface->grpc_slice_split_tail(
-          &slice_, GRPC_SLICE_LENGTH(slice_) - count);
-      g_core_codegen_interface->grpc_slice_buffer_add(slice_buffer_, slice_);
-    }
-    // It's dangerous to keep an inlined grpc_slice as the backup slice, since
-    // on a following Next() call, a reference will be returned to this slice
-    // via GRPC_SLICE_START_PTR, which will not be an address held by
-    // slice_buffer_.
-    have_backup_ = backup_slice_.refcount != nullptr;
-    byte_count_ -= count;
-  }
-
-  /// Returns the total number of bytes written since this object was created.
-  int64_t ByteCount() const override { return byte_count_; }
-
-  // These protected members are needed to support internal optimizations.
-  // they expose internal bits of grpc core that are NOT stable. If you have
-  // a use case needs to use one of these functions, please send an email to
-  // https://groups.google.com/forum/#!forum/grpc-io.
- protected:
-  grpc_slice_buffer* slice_buffer() { return slice_buffer_; }
-  void set_byte_count(int64_t byte_count) { byte_count_ = byte_count; }
-
- private:
-  // friend for testing purposes only
-  friend class internal::ProtoBufferWriterPeer;
-  const int block_size_;  ///< size to alloc for each new \a grpc_slice needed
-  const int total_size_;  ///< byte size of proto being serialized
-  int64_t byte_count_;    ///< bytes written since this object was created
-  grpc_slice_buffer*
-      slice_buffer_;  ///< internal buffer of slices holding the serialized data
-  bool have_backup_;  ///< if we are holding a backup slice or not
-  grpc_slice backup_slice_;  ///< holds space we can still write to, if the
-                             ///< caller has called BackUp
-  grpc_slice slice_;         ///< current slice passed back to the caller
-};
+namespace grpc
+{
+
+    extern CoreCodegenInterface* g_core_codegen_interface;
+
+    // Forward declaration for testing use only
+    namespace internal
+    {
+        class ProtoBufferWriterPeer;
+    }  // namespace internal
+
+    const int kProtoBufferWriterMaxBufferLength = 1024 * 1024;
+
+    /// This is a specialization of the protobuf class ZeroCopyOutputStream.
+    /// The principle is to give the proto layer one buffer of bytes at a time
+    /// that it can use to serialize the next portion of the message, with the
+    /// option to "backup" if more buffer is given than required at the last buffer.
+    ///
+    /// Read more about ZeroCopyOutputStream interface here:
+    /// https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.io.zero_copy_stream#ZeroCopyOutputStream
+    class ProtoBufferWriter : public grpc::protobuf::io::ZeroCopyOutputStream
+    {
+    public:
+        /// Constructor for this derived class
+        ///
+        /// \param[out] byte_buffer A pointer to the grpc::ByteBuffer created
+        /// \param block_size How big are the chunks to allocate at a time
+        /// \param total_size How many total bytes are required for this proto
+        ProtoBufferWriter(ByteBuffer* byte_buffer, int block_size, int total_size) :
+            block_size_(block_size),
+            total_size_(total_size),
+            byte_count_(0),
+            have_backup_(false)
+        {
+            GPR_CODEGEN_ASSERT(!byte_buffer->Valid());
+            /// Create an empty raw byte buffer and look at its underlying slice buffer
+            grpc_byte_buffer* bp =
+                g_core_codegen_interface->grpc_raw_byte_buffer_create(nullptr, 0);
+            byte_buffer->set_buffer(bp);
+            slice_buffer_ = &bp->data.raw.slice_buffer;
+        }
+
+        ~ProtoBufferWriter() override
+        {
+            if (have_backup_)
+            {
+                g_core_codegen_interface->grpc_slice_unref(backup_slice_);
+            }
+        }
+
+        /// Give the proto library the next buffer of bytes and its size. It is
+        /// safe for the caller to write from data[0, size - 1].
+        bool Next(void** data, int* size) override
+        {
+            // Protobuf should not ask for more memory than total_size_.
+            GPR_CODEGEN_ASSERT(byte_count_ < total_size_);
+            // 1. Use the remaining backup slice if we have one
+            // 2. Otherwise allocate a slice, up to the remaining length needed
+            //    or our maximum allocation size
+            // 3. Provide the slice start and size available
+            // 4. Add the slice being returned to the slice buffer
+            size_t remain = static_cast<size_t>(total_size_ - byte_count_);
+            if (have_backup_)
+            {
+                /// If we have a backup slice, we should use it first
+                slice_ = backup_slice_;
+                have_backup_ = false;
+                if (GRPC_SLICE_LENGTH(slice_) > remain)
+                {
+                    GRPC_SLICE_SET_LENGTH(slice_, remain);
+                }
+            }
+            else
+            {
+                // When less than a whole block is needed, only allocate that much.
+                // But make sure the allocated slice is not inlined.
+                size_t allocate_length =
+                    remain > static_cast<size_t>(block_size_) ? block_size_ : remain;
+                slice_ = g_core_codegen_interface->grpc_slice_malloc(
+                    allocate_length > GRPC_SLICE_INLINED_SIZE ? allocate_length : GRPC_SLICE_INLINED_SIZE + 1
+                );
+            }
+            *data = GRPC_SLICE_START_PTR(slice_);
+            // On win x64, int is only 32bit
+            GPR_CODEGEN_ASSERT(GRPC_SLICE_LENGTH(slice_) <= INT_MAX);
+            byte_count_ += * size = static_cast<int>(GRPC_SLICE_LENGTH(slice_));
+            // Using grpc_slice_buffer_add could modify slice_ and merge it with the
+            // previous slice. Therefore, use grpc_slice_buffer_add_indexed method to
+            // ensure the slice gets added at a separate index. It can then be kept
+            // around and popped later in the BackUp function.
+            g_core_codegen_interface->grpc_slice_buffer_add_indexed(slice_buffer_, slice_);
+            return true;
+        }
+
+        /// Backup by \a count bytes because Next returned more bytes than needed
+        /// (only used in the last buffer). \a count must be less than or equal too
+        /// the last buffer returned from next.
+        void BackUp(int count) override
+        {
+            // count == 0 is invoked by ZeroCopyOutputStream users indicating that any
+            // potential buffer obtained through a previous call to Next() is final.
+            // ZeroCopyOutputStream implementations such as streaming output can use
+            // these calls to flush any temporary buffer and flush the output. The logic
+            // below is not robust against count == 0 invocations, so directly return.
+            if (count == 0)
+                return;
+
+            /// 1. Remove the partially-used last slice from the slice buffer
+            /// 2. Split it into the needed (if any) and unneeded part
+            /// 3. Add the needed part back to the slice buffer
+            /// 4. Mark that we still have the remaining part (for later use/unref)
+            GPR_CODEGEN_ASSERT(count <= static_cast<int>(GRPC_SLICE_LENGTH(slice_)));
+            g_core_codegen_interface->grpc_slice_buffer_pop(slice_buffer_);
+            if (static_cast<size_t>(count) == GRPC_SLICE_LENGTH(slice_))
+            {
+                backup_slice_ = slice_;
+            }
+            else
+            {
+                backup_slice_ = g_core_codegen_interface->grpc_slice_split_tail(
+                    &slice_, GRPC_SLICE_LENGTH(slice_) - count
+                );
+                g_core_codegen_interface->grpc_slice_buffer_add(slice_buffer_, slice_);
+            }
+            // It's dangerous to keep an inlined grpc_slice as the backup slice, since
+            // on a following Next() call, a reference will be returned to this slice
+            // via GRPC_SLICE_START_PTR, which will not be an address held by
+            // slice_buffer_.
+            have_backup_ = backup_slice_.refcount != nullptr;
+            byte_count_ -= count;
+        }
+
+        /// Returns the total number of bytes written since this object was created.
+        int64_t ByteCount() const override
+        {
+            return byte_count_;
+        }
+
+        // These protected members are needed to support internal optimizations.
+        // they expose internal bits of grpc core that are NOT stable. If you have
+        // a use case needs to use one of these functions, please send an email to
+        // https://groups.google.com/forum/#!forum/grpc-io.
+
+    protected:
+        grpc_slice_buffer* slice_buffer()
+        {
+            return slice_buffer_;
+        }
+        void set_byte_count(int64_t byte_count)
+        {
+            byte_count_ = byte_count;
+        }
+
+    private:
+        // friend for testing purposes only
+        friend class internal::ProtoBufferWriterPeer;
+        const int block_size_;  ///< size to alloc for each new \a grpc_slice needed
+        const int total_size_;  ///< byte size of proto being serialized
+        int64_t byte_count_;    ///< bytes written since this object was created
+        grpc_slice_buffer*
+            slice_buffer_;         ///< internal buffer of slices holding the serialized data
+        bool have_backup_;         ///< if we are holding a backup slice or not
+        grpc_slice backup_slice_;  ///< holds space we can still write to, if the
+                                   ///< caller has called BackUp
+        grpc_slice slice_;         ///< current slice passed back to the caller
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_utils.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_utils.h
index 4f6d874..8f88261 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_utils.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/proto_utils.h
@@ -38,82 +38,82 @@
 /// This header provides serialization and deserialization between gRPC
 /// messages serialized using protobuf and the C++ objects they represent.
 
-namespace grpc {
+namespace grpc
+{
 
-extern CoreCodegenInterface* g_core_codegen_interface;
+    extern CoreCodegenInterface* g_core_codegen_interface;
 
-// ProtoBufferWriter must be a subclass of ::protobuf::io::ZeroCopyOutputStream.
-template <class ProtoBufferWriter, class T>
-Status GenericSerialize(const grpc::protobuf::MessageLite& msg, ByteBuffer* bb,
-                        bool* own_buffer) {
-  static_assert(std::is_base_of<protobuf::io::ZeroCopyOutputStream,
-                                ProtoBufferWriter>::value,
-                "ProtoBufferWriter must be a subclass of "
-                "::protobuf::io::ZeroCopyOutputStream");
-  *own_buffer = true;
-  int byte_size = static_cast<int>(msg.ByteSizeLong());
-  if (static_cast<size_t>(byte_size) <= GRPC_SLICE_INLINED_SIZE) {
-    Slice slice(byte_size);
-    // We serialize directly into the allocated slices memory
-    GPR_CODEGEN_ASSERT(slice.end() == msg.SerializeWithCachedSizesToArray(
-                                          const_cast<uint8_t*>(slice.begin())));
-    ByteBuffer tmp(&slice, 1);
-    bb->Swap(&tmp);
+    // ProtoBufferWriter must be a subclass of ::protobuf::io::ZeroCopyOutputStream.
+    template<class ProtoBufferWriter, class T>
+    Status GenericSerialize(const grpc::protobuf::MessageLite& msg, ByteBuffer* bb, bool* own_buffer)
+    {
+        static_assert(std::is_base_of<protobuf::io::ZeroCopyOutputStream, ProtoBufferWriter>::value, "ProtoBufferWriter must be a subclass of "
+                                                                                                     "::protobuf::io::ZeroCopyOutputStream");
+        *own_buffer = true;
+        int byte_size = static_cast<int>(msg.ByteSizeLong());
+        if (static_cast<size_t>(byte_size) <= GRPC_SLICE_INLINED_SIZE)
+        {
+            Slice slice(byte_size);
+            // We serialize directly into the allocated slices memory
+            GPR_CODEGEN_ASSERT(slice.end() == msg.SerializeWithCachedSizesToArray(const_cast<uint8_t*>(slice.begin())));
+            ByteBuffer tmp(&slice, 1);
+            bb->Swap(&tmp);
 
-    return g_core_codegen_interface->ok();
-  }
-  ProtoBufferWriter writer(bb, kProtoBufferWriterMaxBufferLength, byte_size);
-  return msg.SerializeToZeroCopyStream(&writer)
-             ? g_core_codegen_interface->ok()
-             : Status(StatusCode::INTERNAL, "Failed to serialize message");
-}
-
-// BufferReader must be a subclass of ::protobuf::io::ZeroCopyInputStream.
-template <class ProtoBufferReader, class T>
-Status GenericDeserialize(ByteBuffer* buffer,
-                          grpc::protobuf::MessageLite* msg) {
-  static_assert(std::is_base_of<protobuf::io::ZeroCopyInputStream,
-                                ProtoBufferReader>::value,
-                "ProtoBufferReader must be a subclass of "
-                "::protobuf::io::ZeroCopyInputStream");
-  if (buffer == nullptr) {
-    return Status(StatusCode::INTERNAL, "No payload");
-  }
-  Status result = g_core_codegen_interface->ok();
-  {
-    ProtoBufferReader reader(buffer);
-    if (!reader.status().ok()) {
-      return reader.status();
+            return g_core_codegen_interface->ok();
+        }
+        ProtoBufferWriter writer(bb, kProtoBufferWriterMaxBufferLength, byte_size);
+        return msg.SerializeToZeroCopyStream(&writer) ? g_core_codegen_interface->ok() : Status(StatusCode::INTERNAL, "Failed to serialize message");
     }
-    if (!msg->ParseFromZeroCopyStream(&reader)) {
-      result = Status(StatusCode::INTERNAL, msg->InitializationErrorString());
+
+    // BufferReader must be a subclass of ::protobuf::io::ZeroCopyInputStream.
+    template<class ProtoBufferReader, class T>
+    Status GenericDeserialize(ByteBuffer* buffer, grpc::protobuf::MessageLite* msg)
+    {
+        static_assert(std::is_base_of<protobuf::io::ZeroCopyInputStream, ProtoBufferReader>::value, "ProtoBufferReader must be a subclass of "
+                                                                                                    "::protobuf::io::ZeroCopyInputStream");
+        if (buffer == nullptr)
+        {
+            return Status(StatusCode::INTERNAL, "No payload");
+        }
+        Status result = g_core_codegen_interface->ok();
+        {
+            ProtoBufferReader reader(buffer);
+            if (!reader.status().ok())
+            {
+                return reader.status();
+            }
+            if (!msg->ParseFromZeroCopyStream(&reader))
+            {
+                result = Status(StatusCode::INTERNAL, msg->InitializationErrorString());
+            }
+        }
+        buffer->Clear();
+        return result;
     }
-  }
-  buffer->Clear();
-  return result;
-}
 
 // this is needed so the following class does not conflict with protobuf
 // serializers that utilize internal-only tools.
 #ifdef GRPC_OPEN_SOURCE_PROTO
-// This class provides a protobuf serializer. It translates between protobuf
-// objects and grpc_byte_buffers. More information about SerializationTraits can
-// be found in include/grpcpp/impl/codegen/serialization_traits.h.
-template <class T>
-class SerializationTraits<
-    T, typename std::enable_if<
-           std::is_base_of<grpc::protobuf::MessageLite, T>::value>::type> {
- public:
-  static Status Serialize(const grpc::protobuf::MessageLite& msg,
-                          ByteBuffer* bb, bool* own_buffer) {
-    return GenericSerialize<ProtoBufferWriter, T>(msg, bb, own_buffer);
-  }
+    // This class provides a protobuf serializer. It translates between protobuf
+    // objects and grpc_byte_buffers. More information about SerializationTraits can
+    // be found in include/grpcpp/impl/codegen/serialization_traits.h.
+    template<class T>
+    class SerializationTraits<
+        T,
+        typename std::enable_if<
+            std::is_base_of<grpc::protobuf::MessageLite, T>::value>::type>
+    {
+    public:
+        static Status Serialize(const grpc::protobuf::MessageLite& msg, ByteBuffer* bb, bool* own_buffer)
+        {
+            return GenericSerialize<ProtoBufferWriter, T>(msg, bb, own_buffer);
+        }
 
-  static Status Deserialize(ByteBuffer* buffer,
-                            grpc::protobuf::MessageLite* msg) {
-    return GenericDeserialize<ProtoBufferReader, T>(buffer, msg);
-  }
-};
+        static Status Deserialize(ByteBuffer* buffer, grpc::protobuf::MessageLite* msg)
+        {
+            return GenericDeserialize<ProtoBufferReader, T>(buffer, msg);
+        }
+    };
 #endif
 
 }  // namespace grpc
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_method.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_method.h
index 83dedda..99a7d73 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_method.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_method.h
@@ -25,58 +25,83 @@
 
 #include <grpcpp/impl/codegen/channel_interface.h>
 
-namespace grpc {
-namespace internal {
-/// Descriptor of an RPC method
-class RpcMethod {
- public:
-  enum RpcType {
-    NORMAL_RPC = 0,
-    CLIENT_STREAMING,  // request streaming
-    SERVER_STREAMING,  // response streaming
-    BIDI_STREAMING
-  };
+namespace grpc
+{
+    namespace internal
+    {
+        /// Descriptor of an RPC method
+        class RpcMethod
+        {
+        public:
+            enum RpcType
+            {
+                NORMAL_RPC = 0,
+                CLIENT_STREAMING,  // request streaming
+                SERVER_STREAMING,  // response streaming
+                BIDI_STREAMING
+            };
 
-  RpcMethod(const char* name, RpcType type)
-      : name_(name),
-        suffix_for_stats_(nullptr),
-        method_type_(type),
-        channel_tag_(nullptr) {}
+            RpcMethod(const char* name, RpcType type) :
+                name_(name),
+                suffix_for_stats_(nullptr),
+                method_type_(type),
+                channel_tag_(nullptr)
+            {
+            }
 
-  RpcMethod(const char* name, const char* suffix_for_stats, RpcType type)
-      : name_(name),
-        suffix_for_stats_(suffix_for_stats),
-        method_type_(type),
-        channel_tag_(nullptr) {}
+            RpcMethod(const char* name, const char* suffix_for_stats, RpcType type) :
+                name_(name),
+                suffix_for_stats_(suffix_for_stats),
+                method_type_(type),
+                channel_tag_(nullptr)
+            {
+            }
 
-  RpcMethod(const char* name, RpcType type,
-            const std::shared_ptr<ChannelInterface>& channel)
-      : name_(name),
-        suffix_for_stats_(nullptr),
-        method_type_(type),
-        channel_tag_(channel->RegisterMethod(name)) {}
+            RpcMethod(const char* name, RpcType type, const std::shared_ptr<ChannelInterface>& channel) :
+                name_(name),
+                suffix_for_stats_(nullptr),
+                method_type_(type),
+                channel_tag_(channel->RegisterMethod(name))
+            {
+            }
 
-  RpcMethod(const char* name, const char* suffix_for_stats, RpcType type,
-            const std::shared_ptr<ChannelInterface>& channel)
-      : name_(name),
-        suffix_for_stats_(suffix_for_stats),
-        method_type_(type),
-        channel_tag_(channel->RegisterMethod(name)) {}
+            RpcMethod(const char* name, const char* suffix_for_stats, RpcType type, const std::shared_ptr<ChannelInterface>& channel) :
+                name_(name),
+                suffix_for_stats_(suffix_for_stats),
+                method_type_(type),
+                channel_tag_(channel->RegisterMethod(name))
+            {
+            }
 
-  const char* name() const { return name_; }
-  const char* suffix_for_stats() const { return suffix_for_stats_; }
-  RpcType method_type() const { return method_type_; }
-  void SetMethodType(RpcType type) { method_type_ = type; }
-  void* channel_tag() const { return channel_tag_; }
+            const char* name() const
+            {
+                return name_;
+            }
+            const char* suffix_for_stats() const
+            {
+                return suffix_for_stats_;
+            }
+            RpcType method_type() const
+            {
+                return method_type_;
+            }
+            void SetMethodType(RpcType type)
+            {
+                method_type_ = type;
+            }
+            void* channel_tag() const
+            {
+                return channel_tag_;
+            }
 
- private:
-  const char* const name_;
-  const char* const suffix_for_stats_;
-  RpcType method_type_;
-  void* const channel_tag_;
-};
+        private:
+            const char* const name_;
+            const char* const suffix_for_stats_;
+            RpcType method_type_;
+            void* const channel_tag_;
+        };
 
-}  // namespace internal
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_RPC_METHOD_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_service_method.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_service_method.h
index 6f6730a..3d507c6 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_service_method.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/rpc_service_method.h
@@ -33,122 +33,157 @@
 #include <grpcpp/impl/codegen/rpc_method.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-class ServerContextBase;
-namespace internal {
-/// Base class for running an RPC handler.
-class MethodHandler {
- public:
-  virtual ~MethodHandler() {}
-  struct HandlerParameter {
-    /// Constructor for HandlerParameter
-    ///
-    /// \param c : the gRPC Call structure for this server call
-    /// \param context : the ServerContext structure for this server call
-    /// \param req : the request payload, if appropriate for this RPC
-    /// \param req_status : the request status after any interceptors have run
-    /// \param handler_data: internal data for the handler.
-    /// \param requester : used only by the callback API. It is a function
-    ///        called by the RPC Controller to request another RPC (and also
-    ///        to set up the state required to make that request possible)
-    HandlerParameter(Call* c, grpc::ServerContextBase* context, void* req,
-                     Status req_status, void* handler_data,
-                     std::function<void()> requester)
-        : call(c),
-          server_context(context),
-          request(req),
-          status(req_status),
-          internal_data(handler_data),
-          call_requester(std::move(requester)) {}
-    ~HandlerParameter() {}
-    Call* const call;
-    grpc::ServerContextBase* const server_context;
-    void* const request;
-    const Status status;
-    void* const internal_data;
-    const std::function<void()> call_requester;
-  };
-  virtual void RunHandler(const HandlerParameter& param) = 0;
+namespace grpc
+{
+    class ServerContextBase;
+    namespace internal
+    {
+        /// Base class for running an RPC handler.
+        class MethodHandler
+        {
+        public:
+            virtual ~MethodHandler()
+            {
+            }
+            struct HandlerParameter
+            {
+                /// Constructor for HandlerParameter
+                ///
+                /// \param c : the gRPC Call structure for this server call
+                /// \param context : the ServerContext structure for this server call
+                /// \param req : the request payload, if appropriate for this RPC
+                /// \param req_status : the request status after any interceptors have run
+                /// \param handler_data: internal data for the handler.
+                /// \param requester : used only by the callback API. It is a function
+                ///        called by the RPC Controller to request another RPC (and also
+                ///        to set up the state required to make that request possible)
+                HandlerParameter(Call* c, grpc::ServerContextBase* context, void* req, Status req_status, void* handler_data, std::function<void()> requester) :
+                    call(c),
+                    server_context(context),
+                    request(req),
+                    status(req_status),
+                    internal_data(handler_data),
+                    call_requester(std::move(requester))
+                {
+                }
+                ~HandlerParameter()
+                {
+                }
+                Call* const call;
+                grpc::ServerContextBase* const server_context;
+                void* const request;
+                const Status status;
+                void* const internal_data;
+                const std::function<void()> call_requester;
+            };
+            virtual void RunHandler(const HandlerParameter& param) = 0;
 
-  /* Returns a pointer to the deserialized request. \a status reflects the
-     result of deserialization. This pointer and the status should be filled in
-     a HandlerParameter and passed to RunHandler. It is illegal to access the
-     pointer after calling RunHandler. Ownership of the deserialized request is
-     retained by the handler. Returns nullptr if deserialization failed. */
-  virtual void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req,
-                            Status* /*status*/, void** /*handler_data*/) {
-    GPR_CODEGEN_ASSERT(req == nullptr);
-    return nullptr;
-  }
-};
+            /* Returns a pointer to the deserialized request. \a status reflects the
+               result of deserialization. This pointer and the status should be filled in
+               a HandlerParameter and passed to RunHandler. It is illegal to access the
+               pointer after calling RunHandler. Ownership of the deserialized request is
+               retained by the handler. Returns nullptr if deserialization failed. */
+            virtual void* Deserialize(grpc_call* /*call*/, grpc_byte_buffer* req, Status* /*status*/, void** /*handler_data*/)
+            {
+                GPR_CODEGEN_ASSERT(req == nullptr);
+                return nullptr;
+            }
+        };
 
-/// Server side rpc method class
-class RpcServiceMethod : public RpcMethod {
- public:
-  /// Takes ownership of the handler
-  RpcServiceMethod(const char* name, RpcMethod::RpcType type,
-                   MethodHandler* handler)
-      : RpcMethod(name, type),
-        server_tag_(nullptr),
-        api_type_(ApiType::SYNC),
-        handler_(handler) {}
+        /// Server side rpc method class
+        class RpcServiceMethod : public RpcMethod
+        {
+        public:
+            /// Takes ownership of the handler
+            RpcServiceMethod(const char* name, RpcMethod::RpcType type, MethodHandler* handler) :
+                RpcMethod(name, type),
+                server_tag_(nullptr),
+                api_type_(ApiType::SYNC),
+                handler_(handler)
+            {
+            }
 
-  enum class ApiType {
-    SYNC,
-    ASYNC,
-    RAW,
-    CALL_BACK,  // not CALLBACK because that is reserved in Windows
-    RAW_CALL_BACK,
-  };
+            enum class ApiType
+            {
+                SYNC,
+                ASYNC,
+                RAW,
+                CALL_BACK,  // not CALLBACK because that is reserved in Windows
+                RAW_CALL_BACK,
+            };
 
-  void set_server_tag(void* tag) { server_tag_ = tag; }
-  void* server_tag() const { return server_tag_; }
-  /// if MethodHandler is nullptr, then this is an async method
-  MethodHandler* handler() const { return handler_.get(); }
-  ApiType api_type() const { return api_type_; }
-  void SetHandler(MethodHandler* handler) { handler_.reset(handler); }
-  void SetServerApiType(RpcServiceMethod::ApiType type) {
-    if ((api_type_ == ApiType::SYNC) &&
-        (type == ApiType::ASYNC || type == ApiType::RAW)) {
-      // this marks this method as async
-      handler_.reset();
-    } else if (api_type_ != ApiType::SYNC) {
-      // this is not an error condition, as it allows users to declare a server
-      // like WithRawMethod_foo<AsyncService>. However since it
-      // overwrites behavior, it should be logged.
-      gpr_log(
-          GPR_INFO,
-          "You are marking method %s as '%s', even though it was "
-          "previously marked '%s'. This behavior will overwrite the original "
-          "behavior. If you expected this then ignore this message.",
-          name(), TypeToString(api_type_), TypeToString(type));
-    }
-    api_type_ = type;
-  }
+            void set_server_tag(void* tag)
+            {
+                server_tag_ = tag;
+            }
+            void* server_tag() const
+            {
+                return server_tag_;
+            }
+            /// if MethodHandler is nullptr, then this is an async method
+            MethodHandler* handler() const
+            {
+                return handler_.get();
+            }
+            ApiType api_type() const
+            {
+                return api_type_;
+            }
+            void SetHandler(MethodHandler* handler)
+            {
+                handler_.reset(handler);
+            }
+            void SetServerApiType(RpcServiceMethod::ApiType type)
+            {
+                if ((api_type_ == ApiType::SYNC) &&
+                    (type == ApiType::ASYNC || type == ApiType::RAW))
+                {
+                    // this marks this method as async
+                    handler_.reset();
+                }
+                else if (api_type_ != ApiType::SYNC)
+                {
+                    // this is not an error condition, as it allows users to declare a server
+                    // like WithRawMethod_foo<AsyncService>. However since it
+                    // overwrites behavior, it should be logged.
+                    gpr_log(
+                        GPR_INFO,
+                        "You are marking method %s as '%s', even though it was "
+                        "previously marked '%s'. This behavior will overwrite the original "
+                        "behavior. If you expected this then ignore this message.",
+                        name(),
+                        TypeToString(api_type_),
+                        TypeToString(type)
+                    );
+                }
+                api_type_ = type;
+            }
 
- private:
-  void* server_tag_;
-  ApiType api_type_;
-  std::unique_ptr<MethodHandler> handler_;
+        private:
+            void* server_tag_;
+            ApiType api_type_;
+            std::unique_ptr<MethodHandler> handler_;
 
-  const char* TypeToString(RpcServiceMethod::ApiType type) {
-    switch (type) {
-      case ApiType::SYNC:
-        return "sync";
-      case ApiType::ASYNC:
-        return "async";
-      case ApiType::RAW:
-        return "raw";
-      case ApiType::CALL_BACK:
-        return "callback";
-      case ApiType::RAW_CALL_BACK:
-        return "raw_callback";
-      default:
-        GPR_UNREACHABLE_CODE(return "unknown");
-    }
-  }
-};
-}  // namespace internal
+            const char* TypeToString(RpcServiceMethod::ApiType type)
+            {
+                switch (type)
+                {
+                    case ApiType::SYNC:
+                        return "sync";
+                    case ApiType::ASYNC:
+                        return "async";
+                    case ApiType::RAW:
+                        return "raw";
+                    case ApiType::CALL_BACK:
+                        return "callback";
+                    case ApiType::RAW_CALL_BACK:
+                        return "raw_callback";
+                    default:
+                        GPR_UNREACHABLE_CODE(return "unknown");
+                }
+            }
+        };
+    }  // namespace internal
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/security/auth_context.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/security/auth_context.h
index c67e1cf..32fe5cc 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/security/auth_context.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/security/auth_context.h
@@ -31,70 +31,75 @@ struct grpc_auth_context;
 struct grpc_auth_property;
 struct grpc_auth_property_iterator;
 
-namespace grpc {
-class SecureAuthContext;
-
-typedef std::pair<string_ref, string_ref> AuthProperty;
-
-class AuthPropertyIterator {
- public:
-  using iterator_category = std::forward_iterator_tag;
-  using value_type = const AuthProperty;
-  using pointer = void;
-  using reference = void;
-  using difference_type = std::ptrdiff_t;
-
-  ~AuthPropertyIterator();
-  AuthPropertyIterator& operator++();
-  AuthPropertyIterator operator++(int);
-  bool operator==(const AuthPropertyIterator& rhs) const;
-  bool operator!=(const AuthPropertyIterator& rhs) const;
-  AuthProperty operator*();
-
- protected:
-  AuthPropertyIterator();
-  AuthPropertyIterator(const grpc_auth_property* property,
-                       const grpc_auth_property_iterator* iter);
-
- private:
-  friend class SecureAuthContext;
-  const grpc_auth_property* property_;
-  // The following items form a grpc_auth_property_iterator.
-  const grpc_auth_context* ctx_;
-  size_t index_;
-  const char* name_;
-};
-
-/// Class encapsulating the Authentication Information.
-///
-/// It includes the secure identity of the peer, the type of secure transport
-/// used as well as any other properties required by the authorization layer.
-class AuthContext {
- public:
-  virtual ~AuthContext() {}
-
-  /// Returns true if the peer is authenticated.
-  virtual bool IsPeerAuthenticated() const = 0;
-
-  /// A peer identity.
-  ///
-  /// It is, in general, comprised of one or more properties (in which case they
-  /// have the same name).
-  virtual std::vector<grpc::string_ref> GetPeerIdentity() const = 0;
-  virtual std::string GetPeerIdentityPropertyName() const = 0;
-
-  /// Returns all the property values with the given name.
-  virtual std::vector<grpc::string_ref> FindPropertyValues(
-      const std::string& name) const = 0;
-
-  /// Iteration over all the properties.
-  virtual AuthPropertyIterator begin() const = 0;
-  virtual AuthPropertyIterator end() const = 0;
-
-  /// Mutation functions: should only be used by an AuthMetadataProcessor.
-  virtual void AddProperty(const std::string& key, const string_ref& value) = 0;
-  virtual bool SetPeerIdentityPropertyName(const std::string& name) = 0;
-};
+namespace grpc
+{
+    class SecureAuthContext;
+
+    typedef std::pair<string_ref, string_ref> AuthProperty;
+
+    class AuthPropertyIterator
+    {
+    public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = const AuthProperty;
+        using pointer = void;
+        using reference = void;
+        using difference_type = std::ptrdiff_t;
+
+        ~AuthPropertyIterator();
+        AuthPropertyIterator& operator++();
+        AuthPropertyIterator operator++(int);
+        bool operator==(const AuthPropertyIterator& rhs) const;
+        bool operator!=(const AuthPropertyIterator& rhs) const;
+        AuthProperty operator*();
+
+    protected:
+        AuthPropertyIterator();
+        AuthPropertyIterator(const grpc_auth_property* property, const grpc_auth_property_iterator* iter);
+
+    private:
+        friend class SecureAuthContext;
+        const grpc_auth_property* property_;
+        // The following items form a grpc_auth_property_iterator.
+        const grpc_auth_context* ctx_;
+        size_t index_;
+        const char* name_;
+    };
+
+    /// Class encapsulating the Authentication Information.
+    ///
+    /// It includes the secure identity of the peer, the type of secure transport
+    /// used as well as any other properties required by the authorization layer.
+    class AuthContext
+    {
+    public:
+        virtual ~AuthContext()
+        {
+        }
+
+        /// Returns true if the peer is authenticated.
+        virtual bool IsPeerAuthenticated() const = 0;
+
+        /// A peer identity.
+        ///
+        /// It is, in general, comprised of one or more properties (in which case they
+        /// have the same name).
+        virtual std::vector<grpc::string_ref> GetPeerIdentity() const = 0;
+        virtual std::string GetPeerIdentityPropertyName() const = 0;
+
+        /// Returns all the property values with the given name.
+        virtual std::vector<grpc::string_ref> FindPropertyValues(
+            const std::string& name
+        ) const = 0;
+
+        /// Iteration over all the properties.
+        virtual AuthPropertyIterator begin() const = 0;
+        virtual AuthPropertyIterator end() const = 0;
+
+        /// Mutation functions: should only be used by an AuthMetadataProcessor.
+        virtual void AddProperty(const std::string& key, const string_ref& value) = 0;
+        virtual bool SetPeerIdentityPropertyName(const std::string& name) = 0;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/serialization_traits.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/serialization_traits.h
index 3148dff..5e89232 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/serialization_traits.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/serialization_traits.h
@@ -21,43 +21,43 @@
 
 // IWYU pragma: private, include <grpcpp/impl/serialization_traits.h>
 
-namespace grpc {
+namespace grpc
+{
 
-/// Defines how to serialize and deserialize some type.
-///
-/// Used for hooking different message serialization API's into GRPC.
-/// Each SerializationTraits<Message> implementation must provide the
-/// following functions:
-/// 1.  static Status Serialize(const Message& msg,
-///                             ByteBuffer* buffer,
-///                             bool* own_buffer);
-///     OR
-///     static Status Serialize(const Message& msg,
-///                             grpc_byte_buffer** buffer,
-///                             bool* own_buffer);
-///     The former is preferred; the latter is deprecated
-///
-/// 2.  static Status Deserialize(ByteBuffer* buffer,
-///                               Message* msg);
-///     OR
-///     static Status Deserialize(grpc_byte_buffer* buffer,
-///                               Message* msg);
-///     The former is preferred; the latter is deprecated
-///
-/// Serialize is required to convert message to a ByteBuffer, and
-/// return that byte buffer through *buffer. *own_buffer should
-/// be set to true if the caller owns said byte buffer, or false if
-/// ownership is retained elsewhere.
-///
-/// Deserialize is required to convert buffer into the message stored at
-/// msg. max_receive_message_size is passed in as a bound on the maximum
-/// number of message bytes Deserialize should accept.
-///
-/// Both functions return a Status, allowing them to explain what went
-/// wrong if required.
-template <class Message,
-          class UnusedButHereForPartialTemplateSpecialization = void>
-class SerializationTraits;
+    /// Defines how to serialize and deserialize some type.
+    ///
+    /// Used for hooking different message serialization API's into GRPC.
+    /// Each SerializationTraits<Message> implementation must provide the
+    /// following functions:
+    /// 1.  static Status Serialize(const Message& msg,
+    ///                             ByteBuffer* buffer,
+    ///                             bool* own_buffer);
+    ///     OR
+    ///     static Status Serialize(const Message& msg,
+    ///                             grpc_byte_buffer** buffer,
+    ///                             bool* own_buffer);
+    ///     The former is preferred; the latter is deprecated
+    ///
+    /// 2.  static Status Deserialize(ByteBuffer* buffer,
+    ///                               Message* msg);
+    ///     OR
+    ///     static Status Deserialize(grpc_byte_buffer* buffer,
+    ///                               Message* msg);
+    ///     The former is preferred; the latter is deprecated
+    ///
+    /// Serialize is required to convert message to a ByteBuffer, and
+    /// return that byte buffer through *buffer. *own_buffer should
+    /// be set to true if the caller owns said byte buffer, or false if
+    /// ownership is retained elsewhere.
+    ///
+    /// Deserialize is required to convert buffer into the message stored at
+    /// msg. max_receive_message_size is passed in as a bound on the maximum
+    /// number of message bytes Deserialize should accept.
+    ///
+    /// Both functions return a Status, allowing them to explain what went
+    /// wrong if required.
+    template<class Message, class UnusedButHereForPartialTemplateSpecialization = void>
+    class SerializationTraits;
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback.h
index d292e7b..e1871c4 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback.h
@@ -33,766 +33,920 @@
 #include <grpcpp/impl/codegen/status.h>
 #include <grpcpp/impl/codegen/sync.h>
 
-namespace grpc {
-
-// Declare base class of all reactors as internal
-namespace internal {
-
-// Forward declarations
-template <class Request, class Response>
-class CallbackUnaryHandler;
-template <class Request, class Response>
-class CallbackClientStreamingHandler;
-template <class Request, class Response>
-class CallbackServerStreamingHandler;
-template <class Request, class Response>
-class CallbackBidiHandler;
-
-class ServerReactor {
- public:
-  virtual ~ServerReactor() = default;
-  virtual void OnDone() = 0;
-  virtual void OnCancel() = 0;
-
-  // The following is not API. It is for internal use only and specifies whether
-  // all reactions of this Reactor can be run without an extra executor
-  // scheduling. This should only be used for internally-defined reactors with
-  // trivial reactions.
-  virtual bool InternalInlineable() { return false; }
-
- private:
-  template <class Request, class Response>
-  friend class CallbackUnaryHandler;
-  template <class Request, class Response>
-  friend class CallbackClientStreamingHandler;
-  template <class Request, class Response>
-  friend class CallbackServerStreamingHandler;
-  template <class Request, class Response>
-  friend class CallbackBidiHandler;
-};
-
-/// The base class of ServerCallbackUnary etc.
-class ServerCallbackCall {
- public:
-  virtual ~ServerCallbackCall() {}
-
-  // This object is responsible for tracking when it is safe to call OnDone and
-  // OnCancel. OnDone should not be called until the method handler is complete,
-  // Finish has been called, the ServerContext CompletionOp (which tracks
-  // cancellation or successful completion) has completed, and all outstanding
-  // Read/Write actions have seen their reactions. OnCancel should not be called
-  // until after the method handler is done and the RPC has completed with a
-  // cancellation. This is tracked by counting how many of these conditions have
-  // been met and calling OnCancel when none remain unmet.
-
-  // Public versions of MaybeDone: one where we don't know the reactor in
-  // advance (used for the ServerContext CompletionOp), and one for where we
-  // know the inlineability of the OnDone reaction. You should set the inline
-  // flag to true if either the Reactor is InternalInlineable() or if this
-  // callback is already being forced to run dispatched to an executor
-  // (typically because it contains additional work than just the MaybeDone).
-
-  void MaybeDone() {
-    if (GPR_UNLIKELY(Unref() == 1)) {
-      ScheduleOnDone(reactor()->InternalInlineable());
-    }
-  }
-
-  void MaybeDone(bool inline_ondone) {
-    if (GPR_UNLIKELY(Unref() == 1)) {
-      ScheduleOnDone(inline_ondone);
-    }
-  }
-
-  // Fast version called with known reactor passed in, used from derived
-  // classes, typically in non-cancel case
-  void MaybeCallOnCancel(ServerReactor* reactor) {
-    if (GPR_UNLIKELY(UnblockCancellation())) {
-      CallOnCancel(reactor);
-    }
-  }
-
-  // Slower version called from object that doesn't know the reactor a priori
-  // (such as the ServerContext CompletionOp which is formed before the
-  // reactor). This is used in cancel cases only, so it's ok to be slower and
-  // invoke a virtual function.
-  void MaybeCallOnCancel() {
-    if (GPR_UNLIKELY(UnblockCancellation())) {
-      CallOnCancel(reactor());
-    }
-  }
-
- protected:
-  /// Increases the reference count
-  void Ref() { callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed); }
-
- private:
-  virtual ServerReactor* reactor() = 0;
-
-  // CallOnDone performs the work required at completion of the RPC: invoking
-  // the OnDone function and doing all necessary cleanup. This function is only
-  // ever invoked on a fully-Unref'fed ServerCallbackCall.
-  virtual void CallOnDone() = 0;
-
-  // If the OnDone reaction is inlineable, execute it inline. Otherwise send it
-  // to an executor.
-  void ScheduleOnDone(bool inline_ondone);
-
-  // If the OnCancel reaction is inlineable, execute it inline. Otherwise send
-  // it to an executor.
-  void CallOnCancel(ServerReactor* reactor);
-
-  // Implement the cancellation constraint counter. Return true if OnCancel
-  // should be called, false otherwise.
-  bool UnblockCancellation() {
-    return on_cancel_conditions_remaining_.fetch_sub(
-               1, std::memory_order_acq_rel) == 1;
-  }
-
-  /// Decreases the reference count and returns the previous value
-  int Unref() {
-    return callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel);
-  }
-
-  std::atomic_int on_cancel_conditions_remaining_{2};
-  std::atomic_int callbacks_outstanding_{
-      3};  // reserve for start, Finish, and CompletionOp
-};
-
-template <class Request, class Response>
-class DefaultMessageHolder : public MessageHolder<Request, Response> {
- public:
-  DefaultMessageHolder() {
-    this->set_request(&request_obj_);
-    this->set_response(&response_obj_);
-  }
-  void Release() override {
-    // the object is allocated in the call arena.
-    this->~DefaultMessageHolder<Request, Response>();
-  }
-
- private:
-  Request request_obj_;
-  Response response_obj_;
-};
-
-}  // namespace internal
-
-// Forward declarations
-class ServerUnaryReactor;
-template <class Request>
-class ServerReadReactor;
-template <class Response>
-class ServerWriteReactor;
-template <class Request, class Response>
-class ServerBidiReactor;
-
-// NOTE: The actual call/stream object classes are provided as API only to
-// support mocking. There are no implementations of these class interfaces in
-// the API.
-class ServerCallbackUnary : public internal::ServerCallbackCall {
- public:
-  ~ServerCallbackUnary() override {}
-  virtual void Finish(grpc::Status s) = 0;
-  virtual void SendInitialMetadata() = 0;
-
- protected:
-  // Use a template rather than explicitly specifying ServerUnaryReactor to
-  // delay binding and avoid a circular forward declaration issue
-  template <class Reactor>
-  void BindReactor(Reactor* reactor) {
-    reactor->InternalBindCall(this);
-  }
-};
-
-template <class Request>
-class ServerCallbackReader : public internal::ServerCallbackCall {
- public:
-  ~ServerCallbackReader() override {}
-  virtual void Finish(grpc::Status s) = 0;
-  virtual void SendInitialMetadata() = 0;
-  virtual void Read(Request* msg) = 0;
-
- protected:
-  void BindReactor(ServerReadReactor<Request>* reactor) {
-    reactor->InternalBindReader(this);
-  }
-};
-
-template <class Response>
-class ServerCallbackWriter : public internal::ServerCallbackCall {
- public:
-  ~ServerCallbackWriter() override {}
-
-  virtual void Finish(grpc::Status s) = 0;
-  virtual void SendInitialMetadata() = 0;
-  virtual void Write(const Response* msg, grpc::WriteOptions options) = 0;
-  virtual void WriteAndFinish(const Response* msg, grpc::WriteOptions options,
-                              grpc::Status s) = 0;
-
- protected:
-  void BindReactor(ServerWriteReactor<Response>* reactor) {
-    reactor->InternalBindWriter(this);
-  }
-};
-
-template <class Request, class Response>
-class ServerCallbackReaderWriter : public internal::ServerCallbackCall {
- public:
-  ~ServerCallbackReaderWriter() override {}
-
-  virtual void Finish(grpc::Status s) = 0;
-  virtual void SendInitialMetadata() = 0;
-  virtual void Read(Request* msg) = 0;
-  virtual void Write(const Response* msg, grpc::WriteOptions options) = 0;
-  virtual void WriteAndFinish(const Response* msg, grpc::WriteOptions options,
-                              grpc::Status s) = 0;
-
- protected:
-  void BindReactor(ServerBidiReactor<Request, Response>* reactor) {
-    reactor->InternalBindStream(this);
-  }
-};
-
-// The following classes are the reactor interfaces that are to be implemented
-// by the user, returned as the output parameter of the method handler for a
-// callback method. Note that none of the classes are pure; all reactions have a
-// default empty reaction so that the user class only needs to override those
-// reactions that it cares about. The reaction methods will be invoked by the
-// library in response to the completion of various operations. Reactions must
-// not include blocking operations (such as blocking I/O, starting synchronous
-// RPCs, or waiting on condition variables). Reactions may be invoked
-// concurrently, except that OnDone is called after all others (assuming proper
-// API usage). The reactor may not be deleted until OnDone is called.
-
-/// \a ServerBidiReactor is the interface for a bidirectional streaming RPC.
-template <class Request, class Response>
-class ServerBidiReactor : public internal::ServerReactor {
- public:
-  // NOTE: Initializing stream_ as a constructor initializer rather than a
-  //       default initializer because gcc-4.x requires a copy constructor for
-  //       default initializing a templated member, which isn't ok for atomic.
-  // TODO(vjpai): Switch to default constructor and default initializer when
-  //              gcc-4.x is no longer supported
-  ServerBidiReactor() : stream_(nullptr) {}
-  ~ServerBidiReactor() override = default;
-
-  /// Send any initial metadata stored in the RPC context. If not invoked,
-  /// any initial metadata will be passed along with the first Write or the
-  /// Finish (if there are no writes).
-  void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(stream_mu_) {
-    ServerCallbackReaderWriter<Request, Response>* stream =
-        stream_.load(std::memory_order_acquire);
-    if (stream == nullptr) {
-      grpc::internal::MutexLock l(&stream_mu_);
-      stream = stream_.load(std::memory_order_relaxed);
-      if (stream == nullptr) {
-        backlog_.send_initial_metadata_wanted = true;
-        return;
-      }
-    }
-    stream->SendInitialMetadata();
-  }
-
-  /// Initiate a read operation.
-  ///
-  /// \param[out] req Where to eventually store the read message. Valid when
-  ///                 the library calls OnReadDone
-  void StartRead(Request* req) ABSL_LOCKS_EXCLUDED(stream_mu_) {
-    ServerCallbackReaderWriter<Request, Response>* stream =
-        stream_.load(std::memory_order_acquire);
-    if (stream == nullptr) {
-      grpc::internal::MutexLock l(&stream_mu_);
-      stream = stream_.load(std::memory_order_relaxed);
-      if (stream == nullptr) {
-        backlog_.read_wanted = req;
-        return;
-      }
-    }
-    stream->Read(req);
-  }
-
-  /// Initiate a write operation.
-  ///
-  /// \param[in] resp The message to be written. The library does not take
-  ///                 ownership but the caller must ensure that the message is
-  ///                 not deleted or modified until OnWriteDone is called.
-  void StartWrite(const Response* resp) {
-    StartWrite(resp, grpc::WriteOptions());
-  }
-
-  /// Initiate a write operation with specified options.
-  ///
-  /// \param[in] resp The message to be written. The library does not take
-  ///                 ownership but the caller must ensure that the message is
-  ///                 not deleted or modified until OnWriteDone is called.
-  /// \param[in] options The WriteOptions to use for writing this message
-  void StartWrite(const Response* resp, grpc::WriteOptions options)
-      ABSL_LOCKS_EXCLUDED(stream_mu_) {
-    ServerCallbackReaderWriter<Request, Response>* stream =
-        stream_.load(std::memory_order_acquire);
-    if (stream == nullptr) {
-      grpc::internal::MutexLock l(&stream_mu_);
-      stream = stream_.load(std::memory_order_relaxed);
-      if (stream == nullptr) {
-        backlog_.write_wanted = resp;
-        backlog_.write_options_wanted = options;
-        return;
-      }
-    }
-    stream->Write(resp, options);
-  }
-
-  /// Initiate a write operation with specified options and final RPC Status,
-  /// which also causes any trailing metadata for this RPC to be sent out.
-  /// StartWriteAndFinish is like merging StartWriteLast and Finish into a
-  /// single step. A key difference, though, is that this operation doesn't have
-  /// an OnWriteDone reaction - it is considered complete only when OnDone is
-  /// available. An RPC can either have StartWriteAndFinish or Finish, but not
-  /// both.
-  ///
-  /// \param[in] resp The message to be written. The library does not take
-  ///                 ownership but the caller must ensure that the message is
-  ///                 not deleted or modified until OnDone is called.
-  /// \param[in] options The WriteOptions to use for writing this message
-  /// \param[in] s The status outcome of this RPC
-  void StartWriteAndFinish(const Response* resp, grpc::WriteOptions options,
-                           grpc::Status s) ABSL_LOCKS_EXCLUDED(stream_mu_) {
-    ServerCallbackReaderWriter<Request, Response>* stream =
-        stream_.load(std::memory_order_acquire);
-    if (stream == nullptr) {
-      grpc::internal::MutexLock l(&stream_mu_);
-      stream = stream_.load(std::memory_order_relaxed);
-      if (stream == nullptr) {
-        backlog_.write_and_finish_wanted = true;
-        backlog_.write_wanted = resp;
-        backlog_.write_options_wanted = options;
-        backlog_.status_wanted = std::move(s);
-        return;
-      }
-    }
-    stream->WriteAndFinish(resp, options, std::move(s));
-  }
-
-  /// Inform system of a planned write operation with specified options, but
-  /// allow the library to schedule the actual write coalesced with the writing
-  /// of trailing metadata (which takes place on a Finish call).
-  ///
-  /// \param[in] resp The message to be written. The library does not take
-  ///                 ownership but the caller must ensure that the message is
-  ///                 not deleted or modified until OnWriteDone is called.
-  /// \param[in] options The WriteOptions to use for writing this message
-  void StartWriteLast(const Response* resp, grpc::WriteOptions options) {
-    StartWrite(resp, options.set_last_message());
-  }
-
-  /// Indicate that the stream is to be finished and the trailing metadata and
-  /// RPC status are to be sent. Every RPC MUST be finished using either Finish
-  /// or StartWriteAndFinish (but not both), even if the RPC is already
-  /// cancelled.
-  ///
-  /// \param[in] s The status outcome of this RPC
-  void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(stream_mu_) {
-    ServerCallbackReaderWriter<Request, Response>* stream =
-        stream_.load(std::memory_order_acquire);
-    if (stream == nullptr) {
-      grpc::internal::MutexLock l(&stream_mu_);
-      stream = stream_.load(std::memory_order_relaxed);
-      if (stream == nullptr) {
-        backlog_.finish_wanted = true;
-        backlog_.status_wanted = std::move(s);
-        return;
-      }
-    }
-    stream->Finish(std::move(s));
-  }
-
-  /// Notifies the application that an explicit StartSendInitialMetadata
-  /// operation completed. Not used when the sending of initial metadata
-  /// piggybacks onto the first write.
-  ///
-  /// \param[in] ok Was it successful? If false, no further write-side operation
-  ///               will succeed.
-  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
-
-  /// Notifies the application that a StartRead operation completed.
-  ///
-  /// \param[in] ok Was it successful? If false, no further read-side operation
-  ///               will succeed.
-  virtual void OnReadDone(bool /*ok*/) {}
-
-  /// Notifies the application that a StartWrite (or StartWriteLast) operation
-  /// completed.
-  ///
-  /// \param[in] ok Was it successful? If false, no further write-side operation
-  ///               will succeed.
-  virtual void OnWriteDone(bool /*ok*/) {}
-
-  /// Notifies the application that all operations associated with this RPC
-  /// have completed. This is an override (from the internal base class) but
-  /// still abstract, so derived classes MUST override it to be instantiated.
-  void OnDone() override = 0;
-
-  /// Notifies the application that this RPC has been cancelled. This is an
-  /// override (from the internal base class) but not final, so derived classes
-  /// should override it if they want to take action.
-  void OnCancel() override {}
-
- private:
-  friend class ServerCallbackReaderWriter<Request, Response>;
-  // May be overridden by internal implementation details. This is not a public
-  // customization point.
-  virtual void InternalBindStream(
-      ServerCallbackReaderWriter<Request, Response>* stream) {
-    grpc::internal::MutexLock l(&stream_mu_);
-
-    if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted)) {
-      stream->SendInitialMetadata();
-    }
-    if (GPR_UNLIKELY(backlog_.read_wanted != nullptr)) {
-      stream->Read(backlog_.read_wanted);
-    }
-    if (GPR_UNLIKELY(backlog_.write_and_finish_wanted)) {
-      stream->WriteAndFinish(backlog_.write_wanted,
-                             std::move(backlog_.write_options_wanted),
-                             std::move(backlog_.status_wanted));
-    } else {
-      if (GPR_UNLIKELY(backlog_.write_wanted != nullptr)) {
-        stream->Write(backlog_.write_wanted,
-                      std::move(backlog_.write_options_wanted));
-      }
-      if (GPR_UNLIKELY(backlog_.finish_wanted)) {
-        stream->Finish(std::move(backlog_.status_wanted));
-      }
-    }
-    // Set stream_ last so that other functions can use it lock-free
-    stream_.store(stream, std::memory_order_release);
-  }
-
-  grpc::internal::Mutex stream_mu_;
-  // TODO(vjpai): Make stream_or_backlog_ into a std::variant or absl::variant
-  //              once C++17 or ABSL is supported since stream and backlog are
-  //              mutually exclusive in this class. Do likewise with the
-  //              remaining reactor classes and their backlogs as well.
-  std::atomic<ServerCallbackReaderWriter<Request, Response>*> stream_{nullptr};
-  struct PreBindBacklog {
-    bool send_initial_metadata_wanted = false;
-    bool write_and_finish_wanted = false;
-    bool finish_wanted = false;
-    Request* read_wanted = nullptr;
-    const Response* write_wanted = nullptr;
-    grpc::WriteOptions write_options_wanted;
-    grpc::Status status_wanted;
-  };
-  PreBindBacklog backlog_ ABSL_GUARDED_BY(stream_mu_);
-};
-
-/// \a ServerReadReactor is the interface for a client-streaming RPC.
-template <class Request>
-class ServerReadReactor : public internal::ServerReactor {
- public:
-  ServerReadReactor() : reader_(nullptr) {}
-  ~ServerReadReactor() override = default;
-
-  /// The following operation initiations are exactly like ServerBidiReactor.
-  void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(reader_mu_) {
-    ServerCallbackReader<Request>* reader =
-        reader_.load(std::memory_order_acquire);
-    if (reader == nullptr) {
-      grpc::internal::MutexLock l(&reader_mu_);
-      reader = reader_.load(std::memory_order_relaxed);
-      if (reader == nullptr) {
-        backlog_.send_initial_metadata_wanted = true;
-        return;
-      }
-    }
-    reader->SendInitialMetadata();
-  }
-  void StartRead(Request* req) ABSL_LOCKS_EXCLUDED(reader_mu_) {
-    ServerCallbackReader<Request>* reader =
-        reader_.load(std::memory_order_acquire);
-    if (reader == nullptr) {
-      grpc::internal::MutexLock l(&reader_mu_);
-      reader = reader_.load(std::memory_order_relaxed);
-      if (reader == nullptr) {
-        backlog_.read_wanted = req;
-        return;
-      }
-    }
-    reader->Read(req);
-  }
-  void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(reader_mu_) {
-    ServerCallbackReader<Request>* reader =
-        reader_.load(std::memory_order_acquire);
-    if (reader == nullptr) {
-      grpc::internal::MutexLock l(&reader_mu_);
-      reader = reader_.load(std::memory_order_relaxed);
-      if (reader == nullptr) {
-        backlog_.finish_wanted = true;
-        backlog_.status_wanted = std::move(s);
-        return;
-      }
-    }
-    reader->Finish(std::move(s));
-  }
-
-  /// The following notifications are exactly like ServerBidiReactor.
-  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
-  virtual void OnReadDone(bool /*ok*/) {}
-  void OnDone() override = 0;
-  void OnCancel() override {}
-
- private:
-  friend class ServerCallbackReader<Request>;
-
-  // May be overridden by internal implementation details. This is not a public
-  // customization point.
-  virtual void InternalBindReader(ServerCallbackReader<Request>* reader)
-      ABSL_LOCKS_EXCLUDED(reader_mu_) {
-    grpc::internal::MutexLock l(&reader_mu_);
-
-    if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted)) {
-      reader->SendInitialMetadata();
-    }
-    if (GPR_UNLIKELY(backlog_.read_wanted != nullptr)) {
-      reader->Read(backlog_.read_wanted);
-    }
-    if (GPR_UNLIKELY(backlog_.finish_wanted)) {
-      reader->Finish(std::move(backlog_.status_wanted));
-    }
-    // Set reader_ last so that other functions can use it lock-free
-    reader_.store(reader, std::memory_order_release);
-  }
-
-  grpc::internal::Mutex reader_mu_;
-  std::atomic<ServerCallbackReader<Request>*> reader_{nullptr};
-  struct PreBindBacklog {
-    bool send_initial_metadata_wanted = false;
-    bool finish_wanted = false;
-    Request* read_wanted = nullptr;
-    grpc::Status status_wanted;
-  };
-  PreBindBacklog backlog_ ABSL_GUARDED_BY(reader_mu_);
-};
-
-/// \a ServerWriteReactor is the interface for a server-streaming RPC.
-template <class Response>
-class ServerWriteReactor : public internal::ServerReactor {
- public:
-  ServerWriteReactor() : writer_(nullptr) {}
-  ~ServerWriteReactor() override = default;
-
-  /// The following operation initiations are exactly like ServerBidiReactor.
-  void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(writer_mu_) {
-    ServerCallbackWriter<Response>* writer =
-        writer_.load(std::memory_order_acquire);
-    if (writer == nullptr) {
-      grpc::internal::MutexLock l(&writer_mu_);
-      writer = writer_.load(std::memory_order_relaxed);
-      if (writer == nullptr) {
-        backlog_.send_initial_metadata_wanted = true;
-        return;
-      }
-    }
-    writer->SendInitialMetadata();
-  }
-  void StartWrite(const Response* resp) {
-    StartWrite(resp, grpc::WriteOptions());
-  }
-  void StartWrite(const Response* resp, grpc::WriteOptions options)
-      ABSL_LOCKS_EXCLUDED(writer_mu_) {
-    ServerCallbackWriter<Response>* writer =
-        writer_.load(std::memory_order_acquire);
-    if (writer == nullptr) {
-      grpc::internal::MutexLock l(&writer_mu_);
-      writer = writer_.load(std::memory_order_relaxed);
-      if (writer == nullptr) {
-        backlog_.write_wanted = resp;
-        backlog_.write_options_wanted = options;
-        return;
-      }
-    }
-    writer->Write(resp, options);
-  }
-  void StartWriteAndFinish(const Response* resp, grpc::WriteOptions options,
-                           grpc::Status s) ABSL_LOCKS_EXCLUDED(writer_mu_) {
-    ServerCallbackWriter<Response>* writer =
-        writer_.load(std::memory_order_acquire);
-    if (writer == nullptr) {
-      grpc::internal::MutexLock l(&writer_mu_);
-      writer = writer_.load(std::memory_order_relaxed);
-      if (writer == nullptr) {
-        backlog_.write_and_finish_wanted = true;
-        backlog_.write_wanted = resp;
-        backlog_.write_options_wanted = options;
-        backlog_.status_wanted = std::move(s);
-        return;
-      }
-    }
-    writer->WriteAndFinish(resp, options, std::move(s));
-  }
-  void StartWriteLast(const Response* resp, grpc::WriteOptions options) {
-    StartWrite(resp, options.set_last_message());
-  }
-  void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(writer_mu_) {
-    ServerCallbackWriter<Response>* writer =
-        writer_.load(std::memory_order_acquire);
-    if (writer == nullptr) {
-      grpc::internal::MutexLock l(&writer_mu_);
-      writer = writer_.load(std::memory_order_relaxed);
-      if (writer == nullptr) {
-        backlog_.finish_wanted = true;
-        backlog_.status_wanted = std::move(s);
-        return;
-      }
-    }
-    writer->Finish(std::move(s));
-  }
-
-  /// The following notifications are exactly like ServerBidiReactor.
-  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
-  virtual void OnWriteDone(bool /*ok*/) {}
-  void OnDone() override = 0;
-  void OnCancel() override {}
-
- private:
-  friend class ServerCallbackWriter<Response>;
-  // May be overridden by internal implementation details. This is not a public
-  // customization point.
-  virtual void InternalBindWriter(ServerCallbackWriter<Response>* writer)
-      ABSL_LOCKS_EXCLUDED(writer_mu_) {
-    grpc::internal::MutexLock l(&writer_mu_);
-
-    if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted)) {
-      writer->SendInitialMetadata();
-    }
-    if (GPR_UNLIKELY(backlog_.write_and_finish_wanted)) {
-      writer->WriteAndFinish(backlog_.write_wanted,
-                             std::move(backlog_.write_options_wanted),
-                             std::move(backlog_.status_wanted));
-    } else {
-      if (GPR_UNLIKELY(backlog_.write_wanted != nullptr)) {
-        writer->Write(backlog_.write_wanted,
-                      std::move(backlog_.write_options_wanted));
-      }
-      if (GPR_UNLIKELY(backlog_.finish_wanted)) {
-        writer->Finish(std::move(backlog_.status_wanted));
-      }
-    }
-    // Set writer_ last so that other functions can use it lock-free
-    writer_.store(writer, std::memory_order_release);
-  }
-
-  grpc::internal::Mutex writer_mu_;
-  std::atomic<ServerCallbackWriter<Response>*> writer_{nullptr};
-  struct PreBindBacklog {
-    bool send_initial_metadata_wanted = false;
-    bool write_and_finish_wanted = false;
-    bool finish_wanted = false;
-    const Response* write_wanted = nullptr;
-    grpc::WriteOptions write_options_wanted;
-    grpc::Status status_wanted;
-  };
-  PreBindBacklog backlog_ ABSL_GUARDED_BY(writer_mu_);
-};
-
-class ServerUnaryReactor : public internal::ServerReactor {
- public:
-  ServerUnaryReactor() : call_(nullptr) {}
-  ~ServerUnaryReactor() override = default;
-
-  /// StartSendInitialMetadata is exactly like ServerBidiReactor.
-  void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(call_mu_) {
-    ServerCallbackUnary* call = call_.load(std::memory_order_acquire);
-    if (call == nullptr) {
-      grpc::internal::MutexLock l(&call_mu_);
-      call = call_.load(std::memory_order_relaxed);
-      if (call == nullptr) {
-        backlog_.send_initial_metadata_wanted = true;
-        return;
-      }
-    }
-    call->SendInitialMetadata();
-  }
-  /// Finish is similar to ServerBidiReactor except for one detail.
-  /// If the status is non-OK, any message will not be sent. Instead,
-  /// the client will only receive the status and any trailing metadata.
-  void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(call_mu_) {
-    ServerCallbackUnary* call = call_.load(std::memory_order_acquire);
-    if (call == nullptr) {
-      grpc::internal::MutexLock l(&call_mu_);
-      call = call_.load(std::memory_order_relaxed);
-      if (call == nullptr) {
-        backlog_.finish_wanted = true;
-        backlog_.status_wanted = std::move(s);
-        return;
-      }
-    }
-    call->Finish(std::move(s));
-  }
-
-  /// The following notifications are exactly like ServerBidiReactor.
-  virtual void OnSendInitialMetadataDone(bool /*ok*/) {}
-  void OnDone() override = 0;
-  void OnCancel() override {}
-
- private:
-  friend class ServerCallbackUnary;
-  // May be overridden by internal implementation details. This is not a public
-  // customization point.
-  virtual void InternalBindCall(ServerCallbackUnary* call)
-      ABSL_LOCKS_EXCLUDED(call_mu_) {
-    grpc::internal::MutexLock l(&call_mu_);
-
-    if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted)) {
-      call->SendInitialMetadata();
-    }
-    if (GPR_UNLIKELY(backlog_.finish_wanted)) {
-      call->Finish(std::move(backlog_.status_wanted));
-    }
-    // Set call_ last so that other functions can use it lock-free
-    call_.store(call, std::memory_order_release);
-  }
-
-  grpc::internal::Mutex call_mu_;
-  std::atomic<ServerCallbackUnary*> call_{nullptr};
-  struct PreBindBacklog {
-    bool send_initial_metadata_wanted = false;
-    bool finish_wanted = false;
-    grpc::Status status_wanted;
-  };
-  PreBindBacklog backlog_ ABSL_GUARDED_BY(call_mu_);
-};
-
-namespace internal {
-
-template <class Base>
-class FinishOnlyReactor : public Base {
- public:
-  explicit FinishOnlyReactor(grpc::Status s) { this->Finish(std::move(s)); }
-  void OnDone() override { this->~FinishOnlyReactor(); }
-};
-
-using UnimplementedUnaryReactor = FinishOnlyReactor<ServerUnaryReactor>;
-template <class Request>
-using UnimplementedReadReactor = FinishOnlyReactor<ServerReadReactor<Request>>;
-template <class Response>
-using UnimplementedWriteReactor =
-    FinishOnlyReactor<ServerWriteReactor<Response>>;
-template <class Request, class Response>
-using UnimplementedBidiReactor =
-    FinishOnlyReactor<ServerBidiReactor<Request, Response>>;
-
-}  // namespace internal
-
-// TODO(vjpai): Remove namespace experimental when last known users are migrated
-// off.
-namespace experimental {
-
-template <class Request, class Response>
-using ServerBidiReactor = ::grpc::ServerBidiReactor<Request, Response>;
-
-}  // namespace experimental
+namespace grpc
+{
+
+    // Declare base class of all reactors as internal
+    namespace internal
+    {
+
+        // Forward declarations
+        template<class Request, class Response>
+        class CallbackUnaryHandler;
+        template<class Request, class Response>
+        class CallbackClientStreamingHandler;
+        template<class Request, class Response>
+        class CallbackServerStreamingHandler;
+        template<class Request, class Response>
+        class CallbackBidiHandler;
+
+        class ServerReactor
+        {
+        public:
+            virtual ~ServerReactor() = default;
+            virtual void OnDone() = 0;
+            virtual void OnCancel() = 0;
+
+            // The following is not API. It is for internal use only and specifies whether
+            // all reactions of this Reactor can be run without an extra executor
+            // scheduling. This should only be used for internally-defined reactors with
+            // trivial reactions.
+            virtual bool InternalInlineable()
+            {
+                return false;
+            }
+
+        private:
+            template<class Request, class Response>
+            friend class CallbackUnaryHandler;
+            template<class Request, class Response>
+            friend class CallbackClientStreamingHandler;
+            template<class Request, class Response>
+            friend class CallbackServerStreamingHandler;
+            template<class Request, class Response>
+            friend class CallbackBidiHandler;
+        };
+
+        /// The base class of ServerCallbackUnary etc.
+        class ServerCallbackCall
+        {
+        public:
+            virtual ~ServerCallbackCall()
+            {
+            }
+
+            // This object is responsible for tracking when it is safe to call OnDone and
+            // OnCancel. OnDone should not be called until the method handler is complete,
+            // Finish has been called, the ServerContext CompletionOp (which tracks
+            // cancellation or successful completion) has completed, and all outstanding
+            // Read/Write actions have seen their reactions. OnCancel should not be called
+            // until after the method handler is done and the RPC has completed with a
+            // cancellation. This is tracked by counting how many of these conditions have
+            // been met and calling OnCancel when none remain unmet.
+
+            // Public versions of MaybeDone: one where we don't know the reactor in
+            // advance (used for the ServerContext CompletionOp), and one for where we
+            // know the inlineability of the OnDone reaction. You should set the inline
+            // flag to true if either the Reactor is InternalInlineable() or if this
+            // callback is already being forced to run dispatched to an executor
+            // (typically because it contains additional work than just the MaybeDone).
+
+            void MaybeDone()
+            {
+                if (GPR_UNLIKELY(Unref() == 1))
+                {
+                    ScheduleOnDone(reactor()->InternalInlineable());
+                }
+            }
+
+            void MaybeDone(bool inline_ondone)
+            {
+                if (GPR_UNLIKELY(Unref() == 1))
+                {
+                    ScheduleOnDone(inline_ondone);
+                }
+            }
+
+            // Fast version called with known reactor passed in, used from derived
+            // classes, typically in non-cancel case
+            void MaybeCallOnCancel(ServerReactor* reactor)
+            {
+                if (GPR_UNLIKELY(UnblockCancellation()))
+                {
+                    CallOnCancel(reactor);
+                }
+            }
+
+            // Slower version called from object that doesn't know the reactor a priori
+            // (such as the ServerContext CompletionOp which is formed before the
+            // reactor). This is used in cancel cases only, so it's ok to be slower and
+            // invoke a virtual function.
+            void MaybeCallOnCancel()
+            {
+                if (GPR_UNLIKELY(UnblockCancellation()))
+                {
+                    CallOnCancel(reactor());
+                }
+            }
+
+        protected:
+            /// Increases the reference count
+            void Ref()
+            {
+                callbacks_outstanding_.fetch_add(1, std::memory_order_relaxed);
+            }
+
+        private:
+            virtual ServerReactor* reactor() = 0;
+
+            // CallOnDone performs the work required at completion of the RPC: invoking
+            // the OnDone function and doing all necessary cleanup. This function is only
+            // ever invoked on a fully-Unref'fed ServerCallbackCall.
+            virtual void CallOnDone() = 0;
+
+            // If the OnDone reaction is inlineable, execute it inline. Otherwise send it
+            // to an executor.
+            void ScheduleOnDone(bool inline_ondone);
+
+            // If the OnCancel reaction is inlineable, execute it inline. Otherwise send
+            // it to an executor.
+            void CallOnCancel(ServerReactor* reactor);
+
+            // Implement the cancellation constraint counter. Return true if OnCancel
+            // should be called, false otherwise.
+            bool UnblockCancellation()
+            {
+                return on_cancel_conditions_remaining_.fetch_sub(
+                           1, std::memory_order_acq_rel
+                       ) == 1;
+            }
+
+            /// Decreases the reference count and returns the previous value
+            int Unref()
+            {
+                return callbacks_outstanding_.fetch_sub(1, std::memory_order_acq_rel);
+            }
+
+            std::atomic_int on_cancel_conditions_remaining_{2};
+            std::atomic_int callbacks_outstanding_{
+                3};  // reserve for start, Finish, and CompletionOp
+        };
+
+        template<class Request, class Response>
+        class DefaultMessageHolder : public MessageHolder<Request, Response>
+        {
+        public:
+            DefaultMessageHolder()
+            {
+                this->set_request(&request_obj_);
+                this->set_response(&response_obj_);
+            }
+            void Release() override
+            {
+                // the object is allocated in the call arena.
+                this->~DefaultMessageHolder<Request, Response>();
+            }
+
+        private:
+            Request request_obj_;
+            Response response_obj_;
+        };
+
+    }  // namespace internal
+
+    // Forward declarations
+    class ServerUnaryReactor;
+    template<class Request>
+    class ServerReadReactor;
+    template<class Response>
+    class ServerWriteReactor;
+    template<class Request, class Response>
+    class ServerBidiReactor;
+
+    // NOTE: The actual call/stream object classes are provided as API only to
+    // support mocking. There are no implementations of these class interfaces in
+    // the API.
+    class ServerCallbackUnary : public internal::ServerCallbackCall
+    {
+    public:
+        ~ServerCallbackUnary() override
+        {
+        }
+        virtual void Finish(grpc::Status s) = 0;
+        virtual void SendInitialMetadata() = 0;
+
+    protected:
+        // Use a template rather than explicitly specifying ServerUnaryReactor to
+        // delay binding and avoid a circular forward declaration issue
+        template<class Reactor>
+        void BindReactor(Reactor* reactor)
+        {
+            reactor->InternalBindCall(this);
+        }
+    };
+
+    template<class Request>
+    class ServerCallbackReader : public internal::ServerCallbackCall
+    {
+    public:
+        ~ServerCallbackReader() override
+        {
+        }
+        virtual void Finish(grpc::Status s) = 0;
+        virtual void SendInitialMetadata() = 0;
+        virtual void Read(Request* msg) = 0;
+
+    protected:
+        void BindReactor(ServerReadReactor<Request>* reactor)
+        {
+            reactor->InternalBindReader(this);
+        }
+    };
+
+    template<class Response>
+    class ServerCallbackWriter : public internal::ServerCallbackCall
+    {
+    public:
+        ~ServerCallbackWriter() override
+        {
+        }
+
+        virtual void Finish(grpc::Status s) = 0;
+        virtual void SendInitialMetadata() = 0;
+        virtual void Write(const Response* msg, grpc::WriteOptions options) = 0;
+        virtual void WriteAndFinish(const Response* msg, grpc::WriteOptions options, grpc::Status s) = 0;
+
+    protected:
+        void BindReactor(ServerWriteReactor<Response>* reactor)
+        {
+            reactor->InternalBindWriter(this);
+        }
+    };
+
+    template<class Request, class Response>
+    class ServerCallbackReaderWriter : public internal::ServerCallbackCall
+    {
+    public:
+        ~ServerCallbackReaderWriter() override
+        {
+        }
+
+        virtual void Finish(grpc::Status s) = 0;
+        virtual void SendInitialMetadata() = 0;
+        virtual void Read(Request* msg) = 0;
+        virtual void Write(const Response* msg, grpc::WriteOptions options) = 0;
+        virtual void WriteAndFinish(const Response* msg, grpc::WriteOptions options, grpc::Status s) = 0;
+
+    protected:
+        void BindReactor(ServerBidiReactor<Request, Response>* reactor)
+        {
+            reactor->InternalBindStream(this);
+        }
+    };
+
+    // The following classes are the reactor interfaces that are to be implemented
+    // by the user, returned as the output parameter of the method handler for a
+    // callback method. Note that none of the classes are pure; all reactions have a
+    // default empty reaction so that the user class only needs to override those
+    // reactions that it cares about. The reaction methods will be invoked by the
+    // library in response to the completion of various operations. Reactions must
+    // not include blocking operations (such as blocking I/O, starting synchronous
+    // RPCs, or waiting on condition variables). Reactions may be invoked
+    // concurrently, except that OnDone is called after all others (assuming proper
+    // API usage). The reactor may not be deleted until OnDone is called.
+
+    /// \a ServerBidiReactor is the interface for a bidirectional streaming RPC.
+    template<class Request, class Response>
+    class ServerBidiReactor : public internal::ServerReactor
+    {
+    public:
+        // NOTE: Initializing stream_ as a constructor initializer rather than a
+        //       default initializer because gcc-4.x requires a copy constructor for
+        //       default initializing a templated member, which isn't ok for atomic.
+        // TODO(vjpai): Switch to default constructor and default initializer when
+        //              gcc-4.x is no longer supported
+        ServerBidiReactor() :
+            stream_(nullptr)
+        {
+        }
+        ~ServerBidiReactor() override = default;
+
+        /// Send any initial metadata stored in the RPC context. If not invoked,
+        /// any initial metadata will be passed along with the first Write or the
+        /// Finish (if there are no writes).
+        void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(stream_mu_)
+        {
+            ServerCallbackReaderWriter<Request, Response>* stream =
+                stream_.load(std::memory_order_acquire);
+            if (stream == nullptr)
+            {
+                grpc::internal::MutexLock l(&stream_mu_);
+                stream = stream_.load(std::memory_order_relaxed);
+                if (stream == nullptr)
+                {
+                    backlog_.send_initial_metadata_wanted = true;
+                    return;
+                }
+            }
+            stream->SendInitialMetadata();
+        }
+
+        /// Initiate a read operation.
+        ///
+        /// \param[out] req Where to eventually store the read message. Valid when
+        ///                 the library calls OnReadDone
+        void StartRead(Request* req) ABSL_LOCKS_EXCLUDED(stream_mu_)
+        {
+            ServerCallbackReaderWriter<Request, Response>* stream =
+                stream_.load(std::memory_order_acquire);
+            if (stream == nullptr)
+            {
+                grpc::internal::MutexLock l(&stream_mu_);
+                stream = stream_.load(std::memory_order_relaxed);
+                if (stream == nullptr)
+                {
+                    backlog_.read_wanted = req;
+                    return;
+                }
+            }
+            stream->Read(req);
+        }
+
+        /// Initiate a write operation.
+        ///
+        /// \param[in] resp The message to be written. The library does not take
+        ///                 ownership but the caller must ensure that the message is
+        ///                 not deleted or modified until OnWriteDone is called.
+        void StartWrite(const Response* resp)
+        {
+            StartWrite(resp, grpc::WriteOptions());
+        }
+
+        /// Initiate a write operation with specified options.
+        ///
+        /// \param[in] resp The message to be written. The library does not take
+        ///                 ownership but the caller must ensure that the message is
+        ///                 not deleted or modified until OnWriteDone is called.
+        /// \param[in] options The WriteOptions to use for writing this message
+        void StartWrite(const Response* resp, grpc::WriteOptions options)
+            ABSL_LOCKS_EXCLUDED(stream_mu_)
+        {
+            ServerCallbackReaderWriter<Request, Response>* stream =
+                stream_.load(std::memory_order_acquire);
+            if (stream == nullptr)
+            {
+                grpc::internal::MutexLock l(&stream_mu_);
+                stream = stream_.load(std::memory_order_relaxed);
+                if (stream == nullptr)
+                {
+                    backlog_.write_wanted = resp;
+                    backlog_.write_options_wanted = options;
+                    return;
+                }
+            }
+            stream->Write(resp, options);
+        }
+
+        /// Initiate a write operation with specified options and final RPC Status,
+        /// which also causes any trailing metadata for this RPC to be sent out.
+        /// StartWriteAndFinish is like merging StartWriteLast and Finish into a
+        /// single step. A key difference, though, is that this operation doesn't have
+        /// an OnWriteDone reaction - it is considered complete only when OnDone is
+        /// available. An RPC can either have StartWriteAndFinish or Finish, but not
+        /// both.
+        ///
+        /// \param[in] resp The message to be written. The library does not take
+        ///                 ownership but the caller must ensure that the message is
+        ///                 not deleted or modified until OnDone is called.
+        /// \param[in] options The WriteOptions to use for writing this message
+        /// \param[in] s The status outcome of this RPC
+        void StartWriteAndFinish(const Response* resp, grpc::WriteOptions options, grpc::Status s) ABSL_LOCKS_EXCLUDED(stream_mu_)
+        {
+            ServerCallbackReaderWriter<Request, Response>* stream =
+                stream_.load(std::memory_order_acquire);
+            if (stream == nullptr)
+            {
+                grpc::internal::MutexLock l(&stream_mu_);
+                stream = stream_.load(std::memory_order_relaxed);
+                if (stream == nullptr)
+                {
+                    backlog_.write_and_finish_wanted = true;
+                    backlog_.write_wanted = resp;
+                    backlog_.write_options_wanted = options;
+                    backlog_.status_wanted = std::move(s);
+                    return;
+                }
+            }
+            stream->WriteAndFinish(resp, options, std::move(s));
+        }
+
+        /// Inform system of a planned write operation with specified options, but
+        /// allow the library to schedule the actual write coalesced with the writing
+        /// of trailing metadata (which takes place on a Finish call).
+        ///
+        /// \param[in] resp The message to be written. The library does not take
+        ///                 ownership but the caller must ensure that the message is
+        ///                 not deleted or modified until OnWriteDone is called.
+        /// \param[in] options The WriteOptions to use for writing this message
+        void StartWriteLast(const Response* resp, grpc::WriteOptions options)
+        {
+            StartWrite(resp, options.set_last_message());
+        }
+
+        /// Indicate that the stream is to be finished and the trailing metadata and
+        /// RPC status are to be sent. Every RPC MUST be finished using either Finish
+        /// or StartWriteAndFinish (but not both), even if the RPC is already
+        /// cancelled.
+        ///
+        /// \param[in] s The status outcome of this RPC
+        void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(stream_mu_)
+        {
+            ServerCallbackReaderWriter<Request, Response>* stream =
+                stream_.load(std::memory_order_acquire);
+            if (stream == nullptr)
+            {
+                grpc::internal::MutexLock l(&stream_mu_);
+                stream = stream_.load(std::memory_order_relaxed);
+                if (stream == nullptr)
+                {
+                    backlog_.finish_wanted = true;
+                    backlog_.status_wanted = std::move(s);
+                    return;
+                }
+            }
+            stream->Finish(std::move(s));
+        }
+
+        /// Notifies the application that an explicit StartSendInitialMetadata
+        /// operation completed. Not used when the sending of initial metadata
+        /// piggybacks onto the first write.
+        ///
+        /// \param[in] ok Was it successful? If false, no further write-side operation
+        ///               will succeed.
+        virtual void OnSendInitialMetadataDone(bool /*ok*/)
+        {
+        }
+
+        /// Notifies the application that a StartRead operation completed.
+        ///
+        /// \param[in] ok Was it successful? If false, no further read-side operation
+        ///               will succeed.
+        virtual void OnReadDone(bool /*ok*/)
+        {
+        }
+
+        /// Notifies the application that a StartWrite (or StartWriteLast) operation
+        /// completed.
+        ///
+        /// \param[in] ok Was it successful? If false, no further write-side operation
+        ///               will succeed.
+        virtual void OnWriteDone(bool /*ok*/)
+        {
+        }
+
+        /// Notifies the application that all operations associated with this RPC
+        /// have completed. This is an override (from the internal base class) but
+        /// still abstract, so derived classes MUST override it to be instantiated.
+        void OnDone() override = 0;
+
+        /// Notifies the application that this RPC has been cancelled. This is an
+        /// override (from the internal base class) but not final, so derived classes
+        /// should override it if they want to take action.
+        void OnCancel() override
+        {
+        }
+
+    private:
+        friend class ServerCallbackReaderWriter<Request, Response>;
+        // May be overridden by internal implementation details. This is not a public
+        // customization point.
+        virtual void InternalBindStream(
+            ServerCallbackReaderWriter<Request, Response>* stream
+        )
+        {
+            grpc::internal::MutexLock l(&stream_mu_);
+
+            if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted))
+            {
+                stream->SendInitialMetadata();
+            }
+            if (GPR_UNLIKELY(backlog_.read_wanted != nullptr))
+            {
+                stream->Read(backlog_.read_wanted);
+            }
+            if (GPR_UNLIKELY(backlog_.write_and_finish_wanted))
+            {
+                stream->WriteAndFinish(backlog_.write_wanted, std::move(backlog_.write_options_wanted), std::move(backlog_.status_wanted));
+            }
+            else
+            {
+                if (GPR_UNLIKELY(backlog_.write_wanted != nullptr))
+                {
+                    stream->Write(backlog_.write_wanted, std::move(backlog_.write_options_wanted));
+                }
+                if (GPR_UNLIKELY(backlog_.finish_wanted))
+                {
+                    stream->Finish(std::move(backlog_.status_wanted));
+                }
+            }
+            // Set stream_ last so that other functions can use it lock-free
+            stream_.store(stream, std::memory_order_release);
+        }
+
+        grpc::internal::Mutex stream_mu_;
+        // TODO(vjpai): Make stream_or_backlog_ into a std::variant or absl::variant
+        //              once C++17 or ABSL is supported since stream and backlog are
+        //              mutually exclusive in this class. Do likewise with the
+        //              remaining reactor classes and their backlogs as well.
+        std::atomic<ServerCallbackReaderWriter<Request, Response>*> stream_{nullptr};
+        struct PreBindBacklog
+        {
+            bool send_initial_metadata_wanted = false;
+            bool write_and_finish_wanted = false;
+            bool finish_wanted = false;
+            Request* read_wanted = nullptr;
+            const Response* write_wanted = nullptr;
+            grpc::WriteOptions write_options_wanted;
+            grpc::Status status_wanted;
+        };
+        PreBindBacklog backlog_ ABSL_GUARDED_BY(stream_mu_);
+    };
+
+    /// \a ServerReadReactor is the interface for a client-streaming RPC.
+    template<class Request>
+    class ServerReadReactor : public internal::ServerReactor
+    {
+    public:
+        ServerReadReactor() :
+            reader_(nullptr)
+        {
+        }
+        ~ServerReadReactor() override = default;
+
+        /// The following operation initiations are exactly like ServerBidiReactor.
+        void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(reader_mu_)
+        {
+            ServerCallbackReader<Request>* reader =
+                reader_.load(std::memory_order_acquire);
+            if (reader == nullptr)
+            {
+                grpc::internal::MutexLock l(&reader_mu_);
+                reader = reader_.load(std::memory_order_relaxed);
+                if (reader == nullptr)
+                {
+                    backlog_.send_initial_metadata_wanted = true;
+                    return;
+                }
+            }
+            reader->SendInitialMetadata();
+        }
+        void StartRead(Request* req) ABSL_LOCKS_EXCLUDED(reader_mu_)
+        {
+            ServerCallbackReader<Request>* reader =
+                reader_.load(std::memory_order_acquire);
+            if (reader == nullptr)
+            {
+                grpc::internal::MutexLock l(&reader_mu_);
+                reader = reader_.load(std::memory_order_relaxed);
+                if (reader == nullptr)
+                {
+                    backlog_.read_wanted = req;
+                    return;
+                }
+            }
+            reader->Read(req);
+        }
+        void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(reader_mu_)
+        {
+            ServerCallbackReader<Request>* reader =
+                reader_.load(std::memory_order_acquire);
+            if (reader == nullptr)
+            {
+                grpc::internal::MutexLock l(&reader_mu_);
+                reader = reader_.load(std::memory_order_relaxed);
+                if (reader == nullptr)
+                {
+                    backlog_.finish_wanted = true;
+                    backlog_.status_wanted = std::move(s);
+                    return;
+                }
+            }
+            reader->Finish(std::move(s));
+        }
+
+        /// The following notifications are exactly like ServerBidiReactor.
+        virtual void OnSendInitialMetadataDone(bool /*ok*/)
+        {
+        }
+        virtual void OnReadDone(bool /*ok*/)
+        {
+        }
+        void OnDone() override = 0;
+        void OnCancel() override
+        {
+        }
+
+    private:
+        friend class ServerCallbackReader<Request>;
+
+        // May be overridden by internal implementation details. This is not a public
+        // customization point.
+        virtual void InternalBindReader(ServerCallbackReader<Request>* reader)
+            ABSL_LOCKS_EXCLUDED(reader_mu_)
+        {
+            grpc::internal::MutexLock l(&reader_mu_);
+
+            if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted))
+            {
+                reader->SendInitialMetadata();
+            }
+            if (GPR_UNLIKELY(backlog_.read_wanted != nullptr))
+            {
+                reader->Read(backlog_.read_wanted);
+            }
+            if (GPR_UNLIKELY(backlog_.finish_wanted))
+            {
+                reader->Finish(std::move(backlog_.status_wanted));
+            }
+            // Set reader_ last so that other functions can use it lock-free
+            reader_.store(reader, std::memory_order_release);
+        }
+
+        grpc::internal::Mutex reader_mu_;
+        std::atomic<ServerCallbackReader<Request>*> reader_{nullptr};
+        struct PreBindBacklog
+        {
+            bool send_initial_metadata_wanted = false;
+            bool finish_wanted = false;
+            Request* read_wanted = nullptr;
+            grpc::Status status_wanted;
+        };
+        PreBindBacklog backlog_ ABSL_GUARDED_BY(reader_mu_);
+    };
+
+    /// \a ServerWriteReactor is the interface for a server-streaming RPC.
+    template<class Response>
+    class ServerWriteReactor : public internal::ServerReactor
+    {
+    public:
+        ServerWriteReactor() :
+            writer_(nullptr)
+        {
+        }
+        ~ServerWriteReactor() override = default;
+
+        /// The following operation initiations are exactly like ServerBidiReactor.
+        void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(writer_mu_)
+        {
+            ServerCallbackWriter<Response>* writer =
+                writer_.load(std::memory_order_acquire);
+            if (writer == nullptr)
+            {
+                grpc::internal::MutexLock l(&writer_mu_);
+                writer = writer_.load(std::memory_order_relaxed);
+                if (writer == nullptr)
+                {
+                    backlog_.send_initial_metadata_wanted = true;
+                    return;
+                }
+            }
+            writer->SendInitialMetadata();
+        }
+        void StartWrite(const Response* resp)
+        {
+            StartWrite(resp, grpc::WriteOptions());
+        }
+        void StartWrite(const Response* resp, grpc::WriteOptions options)
+            ABSL_LOCKS_EXCLUDED(writer_mu_)
+        {
+            ServerCallbackWriter<Response>* writer =
+                writer_.load(std::memory_order_acquire);
+            if (writer == nullptr)
+            {
+                grpc::internal::MutexLock l(&writer_mu_);
+                writer = writer_.load(std::memory_order_relaxed);
+                if (writer == nullptr)
+                {
+                    backlog_.write_wanted = resp;
+                    backlog_.write_options_wanted = options;
+                    return;
+                }
+            }
+            writer->Write(resp, options);
+        }
+        void StartWriteAndFinish(const Response* resp, grpc::WriteOptions options, grpc::Status s) ABSL_LOCKS_EXCLUDED(writer_mu_)
+        {
+            ServerCallbackWriter<Response>* writer =
+                writer_.load(std::memory_order_acquire);
+            if (writer == nullptr)
+            {
+                grpc::internal::MutexLock l(&writer_mu_);
+                writer = writer_.load(std::memory_order_relaxed);
+                if (writer == nullptr)
+                {
+                    backlog_.write_and_finish_wanted = true;
+                    backlog_.write_wanted = resp;
+                    backlog_.write_options_wanted = options;
+                    backlog_.status_wanted = std::move(s);
+                    return;
+                }
+            }
+            writer->WriteAndFinish(resp, options, std::move(s));
+        }
+        void StartWriteLast(const Response* resp, grpc::WriteOptions options)
+        {
+            StartWrite(resp, options.set_last_message());
+        }
+        void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(writer_mu_)
+        {
+            ServerCallbackWriter<Response>* writer =
+                writer_.load(std::memory_order_acquire);
+            if (writer == nullptr)
+            {
+                grpc::internal::MutexLock l(&writer_mu_);
+                writer = writer_.load(std::memory_order_relaxed);
+                if (writer == nullptr)
+                {
+                    backlog_.finish_wanted = true;
+                    backlog_.status_wanted = std::move(s);
+                    return;
+                }
+            }
+            writer->Finish(std::move(s));
+        }
+
+        /// The following notifications are exactly like ServerBidiReactor.
+        virtual void OnSendInitialMetadataDone(bool /*ok*/)
+        {
+        }
+        virtual void OnWriteDone(bool /*ok*/)
+        {
+        }
+        void OnDone() override = 0;
+        void OnCancel() override
+        {
+        }
+
+    private:
+        friend class ServerCallbackWriter<Response>;
+        // May be overridden by internal implementation details. This is not a public
+        // customization point.
+        virtual void InternalBindWriter(ServerCallbackWriter<Response>* writer)
+            ABSL_LOCKS_EXCLUDED(writer_mu_)
+        {
+            grpc::internal::MutexLock l(&writer_mu_);
+
+            if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted))
+            {
+                writer->SendInitialMetadata();
+            }
+            if (GPR_UNLIKELY(backlog_.write_and_finish_wanted))
+            {
+                writer->WriteAndFinish(backlog_.write_wanted, std::move(backlog_.write_options_wanted), std::move(backlog_.status_wanted));
+            }
+            else
+            {
+                if (GPR_UNLIKELY(backlog_.write_wanted != nullptr))
+                {
+                    writer->Write(backlog_.write_wanted, std::move(backlog_.write_options_wanted));
+                }
+                if (GPR_UNLIKELY(backlog_.finish_wanted))
+                {
+                    writer->Finish(std::move(backlog_.status_wanted));
+                }
+            }
+            // Set writer_ last so that other functions can use it lock-free
+            writer_.store(writer, std::memory_order_release);
+        }
+
+        grpc::internal::Mutex writer_mu_;
+        std::atomic<ServerCallbackWriter<Response>*> writer_{nullptr};
+        struct PreBindBacklog
+        {
+            bool send_initial_metadata_wanted = false;
+            bool write_and_finish_wanted = false;
+            bool finish_wanted = false;
+            const Response* write_wanted = nullptr;
+            grpc::WriteOptions write_options_wanted;
+            grpc::Status status_wanted;
+        };
+        PreBindBacklog backlog_ ABSL_GUARDED_BY(writer_mu_);
+    };
+
+    class ServerUnaryReactor : public internal::ServerReactor
+    {
+    public:
+        ServerUnaryReactor() :
+            call_(nullptr)
+        {
+        }
+        ~ServerUnaryReactor() override = default;
+
+        /// StartSendInitialMetadata is exactly like ServerBidiReactor.
+        void StartSendInitialMetadata() ABSL_LOCKS_EXCLUDED(call_mu_)
+        {
+            ServerCallbackUnary* call = call_.load(std::memory_order_acquire);
+            if (call == nullptr)
+            {
+                grpc::internal::MutexLock l(&call_mu_);
+                call = call_.load(std::memory_order_relaxed);
+                if (call == nullptr)
+                {
+                    backlog_.send_initial_metadata_wanted = true;
+                    return;
+                }
+            }
+            call->SendInitialMetadata();
+        }
+        /// Finish is similar to ServerBidiReactor except for one detail.
+        /// If the status is non-OK, any message will not be sent. Instead,
+        /// the client will only receive the status and any trailing metadata.
+        void Finish(grpc::Status s) ABSL_LOCKS_EXCLUDED(call_mu_)
+        {
+            ServerCallbackUnary* call = call_.load(std::memory_order_acquire);
+            if (call == nullptr)
+            {
+                grpc::internal::MutexLock l(&call_mu_);
+                call = call_.load(std::memory_order_relaxed);
+                if (call == nullptr)
+                {
+                    backlog_.finish_wanted = true;
+                    backlog_.status_wanted = std::move(s);
+                    return;
+                }
+            }
+            call->Finish(std::move(s));
+        }
+
+        /// The following notifications are exactly like ServerBidiReactor.
+        virtual void OnSendInitialMetadataDone(bool /*ok*/)
+        {
+        }
+        void OnDone() override = 0;
+        void OnCancel() override
+        {
+        }
+
+    private:
+        friend class ServerCallbackUnary;
+        // May be overridden by internal implementation details. This is not a public
+        // customization point.
+        virtual void InternalBindCall(ServerCallbackUnary* call)
+            ABSL_LOCKS_EXCLUDED(call_mu_)
+        {
+            grpc::internal::MutexLock l(&call_mu_);
+
+            if (GPR_UNLIKELY(backlog_.send_initial_metadata_wanted))
+            {
+                call->SendInitialMetadata();
+            }
+            if (GPR_UNLIKELY(backlog_.finish_wanted))
+            {
+                call->Finish(std::move(backlog_.status_wanted));
+            }
+            // Set call_ last so that other functions can use it lock-free
+            call_.store(call, std::memory_order_release);
+        }
+
+        grpc::internal::Mutex call_mu_;
+        std::atomic<ServerCallbackUnary*> call_{nullptr};
+        struct PreBindBacklog
+        {
+            bool send_initial_metadata_wanted = false;
+            bool finish_wanted = false;
+            grpc::Status status_wanted;
+        };
+        PreBindBacklog backlog_ ABSL_GUARDED_BY(call_mu_);
+    };
+
+    namespace internal
+    {
+
+        template<class Base>
+        class FinishOnlyReactor : public Base
+        {
+        public:
+            explicit FinishOnlyReactor(grpc::Status s)
+            {
+                this->Finish(std::move(s));
+            }
+            void OnDone() override
+            {
+                this->~FinishOnlyReactor();
+            }
+        };
+
+        using UnimplementedUnaryReactor = FinishOnlyReactor<ServerUnaryReactor>;
+        template<class Request>
+        using UnimplementedReadReactor = FinishOnlyReactor<ServerReadReactor<Request>>;
+        template<class Response>
+        using UnimplementedWriteReactor =
+            FinishOnlyReactor<ServerWriteReactor<Response>>;
+        template<class Request, class Response>
+        using UnimplementedBidiReactor =
+            FinishOnlyReactor<ServerBidiReactor<Request, Response>>;
+
+    }  // namespace internal
+
+    // TODO(vjpai): Remove namespace experimental when last known users are migrated
+    // off.
+    namespace experimental
+    {
+
+        template<class Request, class Response>
+        using ServerBidiReactor = ::grpc::ServerBidiReactor<Request, Response>;
+
+    }  // namespace experimental
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback_handlers.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback_handlers.h
index eac524f..b9207aa 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback_handlers.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_callback_handlers.h
@@ -26,864 +26,1031 @@
 #include <grpcpp/impl/codegen/server_context.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-namespace internal {
-
-template <class RequestType, class ResponseType>
-class CallbackUnaryHandler : public grpc::internal::MethodHandler {
- public:
-  explicit CallbackUnaryHandler(
-      std::function<ServerUnaryReactor*(grpc::CallbackServerContext*,
-                                        const RequestType*, ResponseType*)>
-          get_reactor)
-      : get_reactor_(std::move(get_reactor)) {}
-
-  void SetMessageAllocator(
-      MessageAllocator<RequestType, ResponseType>* allocator) {
-    allocator_ = allocator;
-  }
-
-  void RunHandler(const HandlerParameter& param) final {
-    // Arena allocate a controller structure (that includes request/response)
-    grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
-    auto* allocator_state =
-        static_cast<MessageHolder<RequestType, ResponseType>*>(
-            param.internal_data);
-
-    auto* call = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        param.call->call(), sizeof(ServerCallbackUnaryImpl)))
-        ServerCallbackUnaryImpl(
-            static_cast<grpc::CallbackServerContext*>(param.server_context),
-            param.call, allocator_state, param.call_requester);
-    param.server_context->BeginCompletionOp(
-        param.call, [call](bool) { call->MaybeDone(); }, call);
-
-    ServerUnaryReactor* reactor = nullptr;
-    if (param.status.ok()) {
-      reactor = grpc::internal::CatchingReactorGetter<ServerUnaryReactor>(
-          get_reactor_,
-          static_cast<grpc::CallbackServerContext*>(param.server_context),
-          call->request(), call->response());
-    }
-
-    if (reactor == nullptr) {
-      // if deserialization or reactor creator failed, we need to fail the call
-      reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-          param.call->call(), sizeof(UnimplementedUnaryReactor)))
-          UnimplementedUnaryReactor(
-              grpc::Status(grpc::StatusCode::UNIMPLEMENTED, ""));
-    }
-
-    /// Invoke SetupReactor as the last part of the handler
-    call->SetupReactor(reactor);
-  }
-
-  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
-                    grpc::Status* status, void** handler_data) final {
-    grpc::ByteBuffer buf;
-    buf.set_buffer(req);
-    RequestType* request = nullptr;
-    MessageHolder<RequestType, ResponseType>* allocator_state;
-    if (allocator_ != nullptr) {
-      allocator_state = allocator_->AllocateMessages();
-    } else {
-      allocator_state =
-          new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-              call, sizeof(DefaultMessageHolder<RequestType, ResponseType>)))
-              DefaultMessageHolder<RequestType, ResponseType>();
-    }
-    *handler_data = allocator_state;
-    request = allocator_state->request();
-    *status =
-        grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
-    buf.Release();
-    if (status->ok()) {
-      return request;
-    }
-    return nullptr;
-  }
-
- private:
-  std::function<ServerUnaryReactor*(grpc::CallbackServerContext*,
-                                    const RequestType*, ResponseType*)>
-      get_reactor_;
-  MessageAllocator<RequestType, ResponseType>* allocator_ = nullptr;
-
-  class ServerCallbackUnaryImpl : public ServerCallbackUnary {
-   public:
-    void Finish(grpc::Status s) override {
-      // A callback that only contains a call to MaybeDone can be run as an
-      // inline callback regardless of whether or not OnDone is inlineable
-      // because if the actual OnDone callback needs to be scheduled, MaybeDone
-      // is responsible for dispatching to an executor thread if needed. Thus,
-      // when setting up the finish_tag_, we can set its own callback to
-      // inlineable.
-      finish_tag_.Set(
-          call_.call(),
-          [this](bool) {
-            this->MaybeDone(
-                reactor_.load(std::memory_order_relaxed)->InternalInlineable());
-          },
-          &finish_ops_, /*can_inline=*/true);
-      finish_ops_.set_core_cq_tag(&finish_tag_);
-
-      if (!ctx_->sent_initial_metadata_) {
-        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                        ctx_->initial_metadata_flags());
-        if (ctx_->compression_level_set()) {
-          finish_ops_.set_compression_level(ctx_->compression_level());
-        }
-        ctx_->sent_initial_metadata_ = true;
-      }
-      // The response is dropped if the status is not OK.
-      if (s.ok()) {
-        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_,
-                                     finish_ops_.SendMessagePtr(response()));
-      } else {
-        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
-      }
-      finish_ops_.set_core_cq_tag(&finish_tag_);
-      call_.PerformOps(&finish_ops_);
-    }
-
-    void SendInitialMetadata() override {
-      GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-      this->Ref();
-      // The callback for this function should not be marked inline because it
-      // is directly invoking a user-controlled reaction
-      // (OnSendInitialMetadataDone). Thus it must be dispatched to an executor
-      // thread. However, any OnDone needed after that can be inlined because it
-      // is already running on an executor thread.
-      meta_tag_.Set(
-          call_.call(),
-          [this](bool ok) {
-            ServerUnaryReactor* reactor =
-                reactor_.load(std::memory_order_relaxed);
-            reactor->OnSendInitialMetadataDone(ok);
-            this->MaybeDone(/*inlineable_ondone=*/true);
-          },
-          &meta_ops_, /*can_inline=*/false);
-      meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                    ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        meta_ops_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-      meta_ops_.set_core_cq_tag(&meta_tag_);
-      call_.PerformOps(&meta_ops_);
-    }
-
-   private:
-    friend class CallbackUnaryHandler<RequestType, ResponseType>;
-
-    ServerCallbackUnaryImpl(
-        grpc::CallbackServerContext* ctx, grpc::internal::Call* call,
-        MessageHolder<RequestType, ResponseType>* allocator_state,
-        std::function<void()> call_requester)
-        : ctx_(ctx),
-          call_(*call),
-          allocator_state_(allocator_state),
-          call_requester_(std::move(call_requester)) {
-      ctx_->set_message_allocator_state(allocator_state);
-    }
-
-    /// SetupReactor binds the reactor (which also releases any queued
-    /// operations), maybe calls OnCancel if possible/needed, and maybe marks
-    /// the completion of the RPC. This should be the last component of the
-    /// handler.
-    void SetupReactor(ServerUnaryReactor* reactor) {
-      reactor_.store(reactor, std::memory_order_relaxed);
-      this->BindReactor(reactor);
-      this->MaybeCallOnCancel(reactor);
-      this->MaybeDone(reactor->InternalInlineable());
-    }
-
-    const RequestType* request() { return allocator_state_->request(); }
-    ResponseType* response() { return allocator_state_->response(); }
-
-    void CallOnDone() override {
-      reactor_.load(std::memory_order_relaxed)->OnDone();
-      grpc_call* call = call_.call();
-      auto call_requester = std::move(call_requester_);
-      allocator_state_->Release();
-      if (ctx_->context_allocator() != nullptr) {
-        ctx_->context_allocator()->Release(ctx_);
-      }
-      this->~ServerCallbackUnaryImpl();  // explicitly call destructor
-      grpc::g_core_codegen_interface->grpc_call_unref(call);
-      call_requester();
-    }
-
-    ServerReactor* reactor() override {
-      return reactor_.load(std::memory_order_relaxed);
-    }
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
-        meta_ops_;
-    grpc::internal::CallbackWithSuccessTag meta_tag_;
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage,
-                              grpc::internal::CallOpServerSendStatus>
-        finish_ops_;
-    grpc::internal::CallbackWithSuccessTag finish_tag_;
-
-    grpc::CallbackServerContext* const ctx_;
-    grpc::internal::Call call_;
-    MessageHolder<RequestType, ResponseType>* const allocator_state_;
-    std::function<void()> call_requester_;
-    // reactor_ can always be loaded/stored with relaxed memory ordering because
-    // its value is only set once, independently of other data in the object,
-    // and the loads that use it will always actually come provably later even
-    // though they are from different threads since they are triggered by
-    // actions initiated only by the setting up of the reactor_ variable. In
-    // a sense, it's a delayed "const": it gets its value from the SetupReactor
-    // method (not the constructor, so it's not a true const), but it doesn't
-    // change after that and it only gets used by actions caused, directly or
-    // indirectly, by that setup. This comment also applies to the reactor_
-    // variables of the other streaming objects in this file.
-    std::atomic<ServerUnaryReactor*> reactor_;
-    // callbacks_outstanding_ follows a refcount pattern
-    std::atomic<intptr_t> callbacks_outstanding_{
-        3};  // reserve for start, Finish, and CompletionOp
-  };
-};
-
-template <class RequestType, class ResponseType>
-class CallbackClientStreamingHandler : public grpc::internal::MethodHandler {
- public:
-  explicit CallbackClientStreamingHandler(
-      std::function<ServerReadReactor<RequestType>*(
-          grpc::CallbackServerContext*, ResponseType*)>
-          get_reactor)
-      : get_reactor_(std::move(get_reactor)) {}
-  void RunHandler(const HandlerParameter& param) final {
-    // Arena allocate a reader structure (that includes response)
-    grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
-
-    auto* reader = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        param.call->call(), sizeof(ServerCallbackReaderImpl)))
-        ServerCallbackReaderImpl(
-            static_cast<grpc::CallbackServerContext*>(param.server_context),
-            param.call, param.call_requester);
-    // Inlineable OnDone can be false in the CompletionOp callback because there
-    // is no read reactor that has an inlineable OnDone; this only applies to
-    // the DefaultReactor (which is unary).
-    param.server_context->BeginCompletionOp(
-        param.call,
-        [reader](bool) { reader->MaybeDone(/*inlineable_ondone=*/false); },
-        reader);
-
-    ServerReadReactor<RequestType>* reactor = nullptr;
-    if (param.status.ok()) {
-      reactor =
-          grpc::internal::CatchingReactorGetter<ServerReadReactor<RequestType>>(
-              get_reactor_,
-              static_cast<grpc::CallbackServerContext*>(param.server_context),
-              reader->response());
-    }
-
-    if (reactor == nullptr) {
-      // if deserialization or reactor creator failed, we need to fail the call
-      reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-          param.call->call(), sizeof(UnimplementedReadReactor<RequestType>)))
-          UnimplementedReadReactor<RequestType>(
-              grpc::Status(grpc::StatusCode::UNIMPLEMENTED, ""));
-    }
-
-    reader->SetupReactor(reactor);
-  }
-
- private:
-  std::function<ServerReadReactor<RequestType>*(grpc::CallbackServerContext*,
-                                                ResponseType*)>
-      get_reactor_;
-
-  class ServerCallbackReaderImpl : public ServerCallbackReader<RequestType> {
-   public:
-    void Finish(grpc::Status s) override {
-      // A finish tag with only MaybeDone can have its callback inlined
-      // regardless even if OnDone is not inlineable because this callback just
-      // checks a ref and then decides whether or not to dispatch OnDone.
-      finish_tag_.Set(
-          call_.call(),
-          [this](bool) {
-            // Inlineable OnDone can be false here because there is
-            // no read reactor that has an inlineable OnDone; this
-            // only applies to the DefaultReactor (which is unary).
-            this->MaybeDone(/*inlineable_ondone=*/false);
-          },
-          &finish_ops_, /*can_inline=*/true);
-      if (!ctx_->sent_initial_metadata_) {
-        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                        ctx_->initial_metadata_flags());
-        if (ctx_->compression_level_set()) {
-          finish_ops_.set_compression_level(ctx_->compression_level());
-        }
-        ctx_->sent_initial_metadata_ = true;
-      }
-      // The response is dropped if the status is not OK.
-      if (s.ok()) {
-        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_,
-                                     finish_ops_.SendMessagePtr(&resp_));
-      } else {
-        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
-      }
-      finish_ops_.set_core_cq_tag(&finish_tag_);
-      call_.PerformOps(&finish_ops_);
-    }
-
-    void SendInitialMetadata() override {
-      GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-      this->Ref();
-      // The callback for this function should not be inlined because it invokes
-      // a user-controlled reaction, but any resulting OnDone can be inlined in
-      // the executor to which this callback is dispatched.
-      meta_tag_.Set(
-          call_.call(),
-          [this](bool ok) {
-            ServerReadReactor<RequestType>* reactor =
-                reactor_.load(std::memory_order_relaxed);
-            reactor->OnSendInitialMetadataDone(ok);
-            this->MaybeDone(/*inlineable_ondone=*/true);
-          },
-          &meta_ops_, /*can_inline=*/false);
-      meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                    ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        meta_ops_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-      meta_ops_.set_core_cq_tag(&meta_tag_);
-      call_.PerformOps(&meta_ops_);
-    }
-
-    void Read(RequestType* req) override {
-      this->Ref();
-      read_ops_.RecvMessage(req);
-      call_.PerformOps(&read_ops_);
-    }
-
-   private:
-    friend class CallbackClientStreamingHandler<RequestType, ResponseType>;
-
-    ServerCallbackReaderImpl(grpc::CallbackServerContext* ctx,
-                             grpc::internal::Call* call,
-                             std::function<void()> call_requester)
-        : ctx_(ctx), call_(*call), call_requester_(std::move(call_requester)) {}
-
-    void SetupReactor(ServerReadReactor<RequestType>* reactor) {
-      reactor_.store(reactor, std::memory_order_relaxed);
-      // The callback for this function should not be inlined because it invokes
-      // a user-controlled reaction, but any resulting OnDone can be inlined in
-      // the executor to which this callback is dispatched.
-      read_tag_.Set(
-          call_.call(),
-          [this, reactor](bool ok) {
-            if (GPR_UNLIKELY(!ok)) {
-              ctx_->MaybeMarkCancelledOnRead();
+namespace grpc
+{
+    namespace internal
+    {
+
+        template<class RequestType, class ResponseType>
+        class CallbackUnaryHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            explicit CallbackUnaryHandler(
+                std::function<ServerUnaryReactor*(grpc::CallbackServerContext*, const RequestType*, ResponseType*)>
+                    get_reactor
+            ) :
+                get_reactor_(std::move(get_reactor))
+            {
             }
-            reactor->OnReadDone(ok);
-            this->MaybeDone(/*inlineable_ondone=*/true);
-          },
-          &read_ops_, /*can_inline=*/false);
-      read_ops_.set_core_cq_tag(&read_tag_);
-      this->BindReactor(reactor);
-      this->MaybeCallOnCancel(reactor);
-      // Inlineable OnDone can be false here because there is no read
-      // reactor that has an inlineable OnDone; this only applies to the
-      // DefaultReactor (which is unary).
-      this->MaybeDone(/*inlineable_ondone=*/false);
-    }
-
-    ~ServerCallbackReaderImpl() {}
-
-    ResponseType* response() { return &resp_; }
-
-    void CallOnDone() override {
-      reactor_.load(std::memory_order_relaxed)->OnDone();
-      grpc_call* call = call_.call();
-      auto call_requester = std::move(call_requester_);
-      if (ctx_->context_allocator() != nullptr) {
-        ctx_->context_allocator()->Release(ctx_);
-      }
-      this->~ServerCallbackReaderImpl();  // explicitly call destructor
-      grpc::g_core_codegen_interface->grpc_call_unref(call);
-      call_requester();
-    }
-
-    ServerReactor* reactor() override {
-      return reactor_.load(std::memory_order_relaxed);
-    }
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
-        meta_ops_;
-    grpc::internal::CallbackWithSuccessTag meta_tag_;
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage,
-                              grpc::internal::CallOpServerSendStatus>
-        finish_ops_;
-    grpc::internal::CallbackWithSuccessTag finish_tag_;
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<RequestType>>
-        read_ops_;
-    grpc::internal::CallbackWithSuccessTag read_tag_;
-
-    grpc::CallbackServerContext* const ctx_;
-    grpc::internal::Call call_;
-    ResponseType resp_;
-    std::function<void()> call_requester_;
-    // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
-    std::atomic<ServerReadReactor<RequestType>*> reactor_;
-    // callbacks_outstanding_ follows a refcount pattern
-    std::atomic<intptr_t> callbacks_outstanding_{
-        3};  // reserve for OnStarted, Finish, and CompletionOp
-  };
-};
-
-template <class RequestType, class ResponseType>
-class CallbackServerStreamingHandler : public grpc::internal::MethodHandler {
- public:
-  explicit CallbackServerStreamingHandler(
-      std::function<ServerWriteReactor<ResponseType>*(
-          grpc::CallbackServerContext*, const RequestType*)>
-          get_reactor)
-      : get_reactor_(std::move(get_reactor)) {}
-  void RunHandler(const HandlerParameter& param) final {
-    // Arena allocate a writer structure
-    grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
-
-    auto* writer = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        param.call->call(), sizeof(ServerCallbackWriterImpl)))
-        ServerCallbackWriterImpl(
-            static_cast<grpc::CallbackServerContext*>(param.server_context),
-            param.call, static_cast<RequestType*>(param.request),
-            param.call_requester);
-    // Inlineable OnDone can be false in the CompletionOp callback because there
-    // is no write reactor that has an inlineable OnDone; this only applies to
-    // the DefaultReactor (which is unary).
-    param.server_context->BeginCompletionOp(
-        param.call,
-        [writer](bool) { writer->MaybeDone(/*inlineable_ondone=*/false); },
-        writer);
-
-    ServerWriteReactor<ResponseType>* reactor = nullptr;
-    if (param.status.ok()) {
-      reactor = grpc::internal::CatchingReactorGetter<
-          ServerWriteReactor<ResponseType>>(
-          get_reactor_,
-          static_cast<grpc::CallbackServerContext*>(param.server_context),
-          writer->request());
-    }
-    if (reactor == nullptr) {
-      // if deserialization or reactor creator failed, we need to fail the call
-      reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-          param.call->call(), sizeof(UnimplementedWriteReactor<ResponseType>)))
-          UnimplementedWriteReactor<ResponseType>(
-              grpc::Status(grpc::StatusCode::UNIMPLEMENTED, ""));
-    }
-
-    writer->SetupReactor(reactor);
-  }
-
-  void* Deserialize(grpc_call* call, grpc_byte_buffer* req,
-                    grpc::Status* status, void** /*handler_data*/) final {
-    grpc::ByteBuffer buf;
-    buf.set_buffer(req);
-    auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        call, sizeof(RequestType))) RequestType();
-    *status =
-        grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
-    buf.Release();
-    if (status->ok()) {
-      return request;
-    }
-    request->~RequestType();
-    return nullptr;
-  }
-
- private:
-  std::function<ServerWriteReactor<ResponseType>*(grpc::CallbackServerContext*,
-                                                  const RequestType*)>
-      get_reactor_;
-
-  class ServerCallbackWriterImpl : public ServerCallbackWriter<ResponseType> {
-   public:
-    void Finish(grpc::Status s) override {
-      // A finish tag with only MaybeDone can have its callback inlined
-      // regardless even if OnDone is not inlineable because this callback just
-      // checks a ref and then decides whether or not to dispatch OnDone.
-      finish_tag_.Set(
-          call_.call(),
-          [this](bool) {
-            // Inlineable OnDone can be false here because there is
-            // no write reactor that has an inlineable OnDone; this
-            // only applies to the DefaultReactor (which is unary).
-            this->MaybeDone(/*inlineable_ondone=*/false);
-          },
-          &finish_ops_, /*can_inline=*/true);
-      finish_ops_.set_core_cq_tag(&finish_tag_);
-
-      if (!ctx_->sent_initial_metadata_) {
-        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                        ctx_->initial_metadata_flags());
-        if (ctx_->compression_level_set()) {
-          finish_ops_.set_compression_level(ctx_->compression_level());
-        }
-        ctx_->sent_initial_metadata_ = true;
-      }
-      finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
-      call_.PerformOps(&finish_ops_);
-    }
-
-    void SendInitialMetadata() override {
-      GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-      this->Ref();
-      // The callback for this function should not be inlined because it invokes
-      // a user-controlled reaction, but any resulting OnDone can be inlined in
-      // the executor to which this callback is dispatched.
-      meta_tag_.Set(
-          call_.call(),
-          [this](bool ok) {
-            ServerWriteReactor<ResponseType>* reactor =
-                reactor_.load(std::memory_order_relaxed);
-            reactor->OnSendInitialMetadataDone(ok);
-            this->MaybeDone(/*inlineable_ondone=*/true);
-          },
-          &meta_ops_, /*can_inline=*/false);
-      meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                    ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        meta_ops_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-      meta_ops_.set_core_cq_tag(&meta_tag_);
-      call_.PerformOps(&meta_ops_);
-    }
-
-    void Write(const ResponseType* resp, grpc::WriteOptions options) override {
-      this->Ref();
-      if (options.is_last_message()) {
-        options.set_buffer_hint();
-      }
-      if (!ctx_->sent_initial_metadata_) {
-        write_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                       ctx_->initial_metadata_flags());
-        if (ctx_->compression_level_set()) {
-          write_ops_.set_compression_level(ctx_->compression_level());
-        }
-        ctx_->sent_initial_metadata_ = true;
-      }
-      // TODO(vjpai): don't assert
-      GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(resp, options).ok());
-      call_.PerformOps(&write_ops_);
-    }
-
-    void WriteAndFinish(const ResponseType* resp, grpc::WriteOptions options,
-                        grpc::Status s) override {
-      // This combines the write into the finish callback
-      // TODO(vjpai): don't assert
-      GPR_CODEGEN_ASSERT(finish_ops_.SendMessagePtr(resp, options).ok());
-      Finish(std::move(s));
-    }
-
-   private:
-    friend class CallbackServerStreamingHandler<RequestType, ResponseType>;
-
-    ServerCallbackWriterImpl(grpc::CallbackServerContext* ctx,
-                             grpc::internal::Call* call, const RequestType* req,
-                             std::function<void()> call_requester)
-        : ctx_(ctx),
-          call_(*call),
-          req_(req),
-          call_requester_(std::move(call_requester)) {}
-
-    void SetupReactor(ServerWriteReactor<ResponseType>* reactor) {
-      reactor_.store(reactor, std::memory_order_relaxed);
-      // The callback for this function should not be inlined because it invokes
-      // a user-controlled reaction, but any resulting OnDone can be inlined in
-      // the executor to which this callback is dispatched.
-      write_tag_.Set(
-          call_.call(),
-          [this, reactor](bool ok) {
-            reactor->OnWriteDone(ok);
-            this->MaybeDone(/*inlineable_ondone=*/true);
-          },
-          &write_ops_, /*can_inline=*/false);
-      write_ops_.set_core_cq_tag(&write_tag_);
-      this->BindReactor(reactor);
-      this->MaybeCallOnCancel(reactor);
-      // Inlineable OnDone can be false here because there is no write
-      // reactor that has an inlineable OnDone; this only applies to the
-      // DefaultReactor (which is unary).
-      this->MaybeDone(/*inlineable_ondone=*/false);
-    }
-    ~ServerCallbackWriterImpl() {
-      if (req_ != nullptr) {
-        req_->~RequestType();
-      }
-    }
-
-    const RequestType* request() { return req_; }
-
-    void CallOnDone() override {
-      reactor_.load(std::memory_order_relaxed)->OnDone();
-      grpc_call* call = call_.call();
-      auto call_requester = std::move(call_requester_);
-      if (ctx_->context_allocator() != nullptr) {
-        ctx_->context_allocator()->Release(ctx_);
-      }
-      this->~ServerCallbackWriterImpl();  // explicitly call destructor
-      grpc::g_core_codegen_interface->grpc_call_unref(call);
-      call_requester();
-    }
-
-    ServerReactor* reactor() override {
-      return reactor_.load(std::memory_order_relaxed);
-    }
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
-        meta_ops_;
-    grpc::internal::CallbackWithSuccessTag meta_tag_;
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage,
-                              grpc::internal::CallOpServerSendStatus>
-        finish_ops_;
-    grpc::internal::CallbackWithSuccessTag finish_tag_;
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage>
-        write_ops_;
-    grpc::internal::CallbackWithSuccessTag write_tag_;
-
-    grpc::CallbackServerContext* const ctx_;
-    grpc::internal::Call call_;
-    const RequestType* req_;
-    std::function<void()> call_requester_;
-    // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
-    std::atomic<ServerWriteReactor<ResponseType>*> reactor_;
-    // callbacks_outstanding_ follows a refcount pattern
-    std::atomic<intptr_t> callbacks_outstanding_{
-        3};  // reserve for OnStarted, Finish, and CompletionOp
-  };
-};
-
-template <class RequestType, class ResponseType>
-class CallbackBidiHandler : public grpc::internal::MethodHandler {
- public:
-  explicit CallbackBidiHandler(
-      std::function<ServerBidiReactor<RequestType, ResponseType>*(
-          grpc::CallbackServerContext*)>
-          get_reactor)
-      : get_reactor_(std::move(get_reactor)) {}
-  void RunHandler(const HandlerParameter& param) final {
-    grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
-
-    auto* stream = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-        param.call->call(), sizeof(ServerCallbackReaderWriterImpl)))
-        ServerCallbackReaderWriterImpl(
-            static_cast<grpc::CallbackServerContext*>(param.server_context),
-            param.call, param.call_requester);
-    // Inlineable OnDone can be false in the CompletionOp callback because there
-    // is no bidi reactor that has an inlineable OnDone; this only applies to
-    // the DefaultReactor (which is unary).
-    param.server_context->BeginCompletionOp(
-        param.call,
-        [stream](bool) { stream->MaybeDone(/*inlineable_ondone=*/false); },
-        stream);
-
-    ServerBidiReactor<RequestType, ResponseType>* reactor = nullptr;
-    if (param.status.ok()) {
-      reactor = grpc::internal::CatchingReactorGetter<
-          ServerBidiReactor<RequestType, ResponseType>>(
-          get_reactor_,
-          static_cast<grpc::CallbackServerContext*>(param.server_context));
-    }
-
-    if (reactor == nullptr) {
-      // if deserialization or reactor creator failed, we need to fail the call
-      reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
-          param.call->call(),
-          sizeof(UnimplementedBidiReactor<RequestType, ResponseType>)))
-          UnimplementedBidiReactor<RequestType, ResponseType>(
-              grpc::Status(grpc::StatusCode::UNIMPLEMENTED, ""));
-    }
-
-    stream->SetupReactor(reactor);
-  }
-
- private:
-  std::function<ServerBidiReactor<RequestType, ResponseType>*(
-      grpc::CallbackServerContext*)>
-      get_reactor_;
-
-  class ServerCallbackReaderWriterImpl
-      : public ServerCallbackReaderWriter<RequestType, ResponseType> {
-   public:
-    void Finish(grpc::Status s) override {
-      // A finish tag with only MaybeDone can have its callback inlined
-      // regardless even if OnDone is not inlineable because this callback just
-      // checks a ref and then decides whether or not to dispatch OnDone.
-      finish_tag_.Set(
-          call_.call(),
-          [this](bool) {
-            // Inlineable OnDone can be false here because there is
-            // no bidi reactor that has an inlineable OnDone; this
-            // only applies to the DefaultReactor (which is unary).
-            this->MaybeDone(/*inlineable_ondone=*/false);
-          },
-          &finish_ops_, /*can_inline=*/true);
-      finish_ops_.set_core_cq_tag(&finish_tag_);
-
-      if (!ctx_->sent_initial_metadata_) {
-        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                        ctx_->initial_metadata_flags());
-        if (ctx_->compression_level_set()) {
-          finish_ops_.set_compression_level(ctx_->compression_level());
-        }
-        ctx_->sent_initial_metadata_ = true;
-      }
-      finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
-      call_.PerformOps(&finish_ops_);
-    }
-
-    void SendInitialMetadata() override {
-      GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-      this->Ref();
-      // The callback for this function should not be inlined because it invokes
-      // a user-controlled reaction, but any resulting OnDone can be inlined in
-      // the executor to which this callback is dispatched.
-      meta_tag_.Set(
-          call_.call(),
-          [this](bool ok) {
-            ServerBidiReactor<RequestType, ResponseType>* reactor =
-                reactor_.load(std::memory_order_relaxed);
-            reactor->OnSendInitialMetadataDone(ok);
-            this->MaybeDone(/*inlineable_ondone=*/true);
-          },
-          &meta_ops_, /*can_inline=*/false);
-      meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                    ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        meta_ops_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-      meta_ops_.set_core_cq_tag(&meta_tag_);
-      call_.PerformOps(&meta_ops_);
-    }
-
-    void Write(const ResponseType* resp, grpc::WriteOptions options) override {
-      this->Ref();
-      if (options.is_last_message()) {
-        options.set_buffer_hint();
-      }
-      if (!ctx_->sent_initial_metadata_) {
-        write_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                       ctx_->initial_metadata_flags());
-        if (ctx_->compression_level_set()) {
-          write_ops_.set_compression_level(ctx_->compression_level());
-        }
-        ctx_->sent_initial_metadata_ = true;
-      }
-      // TODO(vjpai): don't assert
-      GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(resp, options).ok());
-      call_.PerformOps(&write_ops_);
-    }
-
-    void WriteAndFinish(const ResponseType* resp, grpc::WriteOptions options,
-                        grpc::Status s) override {
-      // TODO(vjpai): don't assert
-      GPR_CODEGEN_ASSERT(finish_ops_.SendMessagePtr(resp, options).ok());
-      Finish(std::move(s));
-    }
-
-    void Read(RequestType* req) override {
-      this->Ref();
-      read_ops_.RecvMessage(req);
-      call_.PerformOps(&read_ops_);
-    }
-
-   private:
-    friend class CallbackBidiHandler<RequestType, ResponseType>;
-
-    ServerCallbackReaderWriterImpl(grpc::CallbackServerContext* ctx,
-                                   grpc::internal::Call* call,
-                                   std::function<void()> call_requester)
-        : ctx_(ctx), call_(*call), call_requester_(std::move(call_requester)) {}
-
-    void SetupReactor(ServerBidiReactor<RequestType, ResponseType>* reactor) {
-      reactor_.store(reactor, std::memory_order_relaxed);
-      // The callbacks for these functions should not be inlined because they
-      // invoke user-controlled reactions, but any resulting OnDones can be
-      // inlined in the executor to which a callback is dispatched.
-      write_tag_.Set(
-          call_.call(),
-          [this, reactor](bool ok) {
-            reactor->OnWriteDone(ok);
-            this->MaybeDone(/*inlineable_ondone=*/true);
-          },
-          &write_ops_, /*can_inline=*/false);
-      write_ops_.set_core_cq_tag(&write_tag_);
-      read_tag_.Set(
-          call_.call(),
-          [this, reactor](bool ok) {
-            if (GPR_UNLIKELY(!ok)) {
-              ctx_->MaybeMarkCancelledOnRead();
+
+            void SetMessageAllocator(
+                MessageAllocator<RequestType, ResponseType>* allocator
+            )
+            {
+                allocator_ = allocator;
+            }
+
+            void RunHandler(const HandlerParameter& param) final
+            {
+                // Arena allocate a controller structure (that includes request/response)
+                grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
+                auto* allocator_state =
+                    static_cast<MessageHolder<RequestType, ResponseType>*>(
+                        param.internal_data
+                    );
+
+                auto* call = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    param.call->call(), sizeof(ServerCallbackUnaryImpl)
+                ))
+                    ServerCallbackUnaryImpl(
+                        static_cast<grpc::CallbackServerContext*>(param.server_context),
+                        param.call,
+                        allocator_state,
+                        param.call_requester
+                    );
+                param.server_context->BeginCompletionOp(
+                    param.call, [call](bool)
+                    { call->MaybeDone(); },
+                    call
+                );
+
+                ServerUnaryReactor* reactor = nullptr;
+                if (param.status.ok())
+                {
+                    reactor = grpc::internal::CatchingReactorGetter<ServerUnaryReactor>(
+                        get_reactor_,
+                        static_cast<grpc::CallbackServerContext*>(param.server_context),
+                        call->request(),
+                        call->response()
+                    );
+                }
+
+                if (reactor == nullptr)
+                {
+                    // if deserialization or reactor creator failed, we need to fail the call
+                    reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                        param.call->call(), sizeof(UnimplementedUnaryReactor)
+                    ))
+                        UnimplementedUnaryReactor(
+                            grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "")
+                        );
+                }
+
+                /// Invoke SetupReactor as the last part of the handler
+                call->SetupReactor(reactor);
+            }
+
+            void* Deserialize(grpc_call* call, grpc_byte_buffer* req, grpc::Status* status, void** handler_data) final
+            {
+                grpc::ByteBuffer buf;
+                buf.set_buffer(req);
+                RequestType* request = nullptr;
+                MessageHolder<RequestType, ResponseType>* allocator_state;
+                if (allocator_ != nullptr)
+                {
+                    allocator_state = allocator_->AllocateMessages();
+                }
+                else
+                {
+                    allocator_state =
+                        new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                            call, sizeof(DefaultMessageHolder<RequestType, ResponseType>)
+                        ))
+                            DefaultMessageHolder<RequestType, ResponseType>();
+                }
+                *handler_data = allocator_state;
+                request = allocator_state->request();
+                *status =
+                    grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
+                buf.Release();
+                if (status->ok())
+                {
+                    return request;
+                }
+                return nullptr;
             }
-            reactor->OnReadDone(ok);
-            this->MaybeDone(/*inlineable_ondone=*/true);
-          },
-          &read_ops_, /*can_inline=*/false);
-      read_ops_.set_core_cq_tag(&read_tag_);
-      this->BindReactor(reactor);
-      this->MaybeCallOnCancel(reactor);
-      // Inlineable OnDone can be false here because there is no bidi
-      // reactor that has an inlineable OnDone; this only applies to the
-      // DefaultReactor (which is unary).
-      this->MaybeDone(/*inlineable_ondone=*/false);
-    }
-
-    void CallOnDone() override {
-      reactor_.load(std::memory_order_relaxed)->OnDone();
-      grpc_call* call = call_.call();
-      auto call_requester = std::move(call_requester_);
-      if (ctx_->context_allocator() != nullptr) {
-        ctx_->context_allocator()->Release(ctx_);
-      }
-      this->~ServerCallbackReaderWriterImpl();  // explicitly call destructor
-      grpc::g_core_codegen_interface->grpc_call_unref(call);
-      call_requester();
-    }
-
-    ServerReactor* reactor() override {
-      return reactor_.load(std::memory_order_relaxed);
-    }
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
-        meta_ops_;
-    grpc::internal::CallbackWithSuccessTag meta_tag_;
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage,
-                              grpc::internal::CallOpServerSendStatus>
-        finish_ops_;
-    grpc::internal::CallbackWithSuccessTag finish_tag_;
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage>
-        write_ops_;
-    grpc::internal::CallbackWithSuccessTag write_tag_;
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<RequestType>>
-        read_ops_;
-    grpc::internal::CallbackWithSuccessTag read_tag_;
-
-    grpc::CallbackServerContext* const ctx_;
-    grpc::internal::Call call_;
-    std::function<void()> call_requester_;
-    // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
-    std::atomic<ServerBidiReactor<RequestType, ResponseType>*> reactor_;
-    // callbacks_outstanding_ follows a refcount pattern
-    std::atomic<intptr_t> callbacks_outstanding_{
-        3};  // reserve for OnStarted, Finish, and CompletionOp
-  };
-};
-
-}  // namespace internal
+
+        private:
+            std::function<ServerUnaryReactor*(grpc::CallbackServerContext*, const RequestType*, ResponseType*)>
+                get_reactor_;
+            MessageAllocator<RequestType, ResponseType>* allocator_ = nullptr;
+
+            class ServerCallbackUnaryImpl : public ServerCallbackUnary
+            {
+            public:
+                void Finish(grpc::Status s) override
+                {
+                    // A callback that only contains a call to MaybeDone can be run as an
+                    // inline callback regardless of whether or not OnDone is inlineable
+                    // because if the actual OnDone callback needs to be scheduled, MaybeDone
+                    // is responsible for dispatching to an executor thread if needed. Thus,
+                    // when setting up the finish_tag_, we can set its own callback to
+                    // inlineable.
+                    finish_tag_.Set(
+                        call_.call(),
+                        [this](bool)
+                        {
+                            this->MaybeDone(
+                                reactor_.load(std::memory_order_relaxed)->InternalInlineable()
+                            );
+                        },
+                        &finish_ops_,
+                        /*can_inline=*/true
+                    );
+                    finish_ops_.set_core_cq_tag(&finish_tag_);
+
+                    if (!ctx_->sent_initial_metadata_)
+                    {
+                        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                        if (ctx_->compression_level_set())
+                        {
+                            finish_ops_.set_compression_level(ctx_->compression_level());
+                        }
+                        ctx_->sent_initial_metadata_ = true;
+                    }
+                    // The response is dropped if the status is not OK.
+                    if (s.ok())
+                    {
+                        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, finish_ops_.SendMessagePtr(response()));
+                    }
+                    else
+                    {
+                        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
+                    }
+                    finish_ops_.set_core_cq_tag(&finish_tag_);
+                    call_.PerformOps(&finish_ops_);
+                }
+
+                void SendInitialMetadata() override
+                {
+                    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+                    this->Ref();
+                    // The callback for this function should not be marked inline because it
+                    // is directly invoking a user-controlled reaction
+                    // (OnSendInitialMetadataDone). Thus it must be dispatched to an executor
+                    // thread. However, any OnDone needed after that can be inlined because it
+                    // is already running on an executor thread.
+                    meta_tag_.Set(
+                        call_.call(),
+                        [this](bool ok)
+                        {
+                            ServerUnaryReactor* reactor =
+                                reactor_.load(std::memory_order_relaxed);
+                            reactor->OnSendInitialMetadataDone(ok);
+                            this->MaybeDone(/*inlineable_ondone=*/true);
+                        },
+                        &meta_ops_,
+                        /*can_inline=*/false
+                    );
+                    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                    if (ctx_->compression_level_set())
+                    {
+                        meta_ops_.set_compression_level(ctx_->compression_level());
+                    }
+                    ctx_->sent_initial_metadata_ = true;
+                    meta_ops_.set_core_cq_tag(&meta_tag_);
+                    call_.PerformOps(&meta_ops_);
+                }
+
+            private:
+                friend class CallbackUnaryHandler<RequestType, ResponseType>;
+
+                ServerCallbackUnaryImpl(
+                    grpc::CallbackServerContext* ctx, grpc::internal::Call* call, MessageHolder<RequestType, ResponseType>* allocator_state, std::function<void()> call_requester
+                ) :
+                    ctx_(ctx),
+                    call_(*call),
+                    allocator_state_(allocator_state),
+                    call_requester_(std::move(call_requester))
+                {
+                    ctx_->set_message_allocator_state(allocator_state);
+                }
+
+                /// SetupReactor binds the reactor (which also releases any queued
+                /// operations), maybe calls OnCancel if possible/needed, and maybe marks
+                /// the completion of the RPC. This should be the last component of the
+                /// handler.
+                void SetupReactor(ServerUnaryReactor* reactor)
+                {
+                    reactor_.store(reactor, std::memory_order_relaxed);
+                    this->BindReactor(reactor);
+                    this->MaybeCallOnCancel(reactor);
+                    this->MaybeDone(reactor->InternalInlineable());
+                }
+
+                const RequestType* request()
+                {
+                    return allocator_state_->request();
+                }
+                ResponseType* response()
+                {
+                    return allocator_state_->response();
+                }
+
+                void CallOnDone() override
+                {
+                    reactor_.load(std::memory_order_relaxed)->OnDone();
+                    grpc_call* call = call_.call();
+                    auto call_requester = std::move(call_requester_);
+                    allocator_state_->Release();
+                    if (ctx_->context_allocator() != nullptr)
+                    {
+                        ctx_->context_allocator()->Release(ctx_);
+                    }
+                    this->~ServerCallbackUnaryImpl();  // explicitly call destructor
+                    grpc::g_core_codegen_interface->grpc_call_unref(call);
+                    call_requester();
+                }
+
+                ServerReactor* reactor() override
+                {
+                    return reactor_.load(std::memory_order_relaxed);
+                }
+
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+                    meta_ops_;
+                grpc::internal::CallbackWithSuccessTag meta_tag_;
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+                    finish_ops_;
+                grpc::internal::CallbackWithSuccessTag finish_tag_;
+
+                grpc::CallbackServerContext* const ctx_;
+                grpc::internal::Call call_;
+                MessageHolder<RequestType, ResponseType>* const allocator_state_;
+                std::function<void()> call_requester_;
+                // reactor_ can always be loaded/stored with relaxed memory ordering because
+                // its value is only set once, independently of other data in the object,
+                // and the loads that use it will always actually come provably later even
+                // though they are from different threads since they are triggered by
+                // actions initiated only by the setting up of the reactor_ variable. In
+                // a sense, it's a delayed "const": it gets its value from the SetupReactor
+                // method (not the constructor, so it's not a true const), but it doesn't
+                // change after that and it only gets used by actions caused, directly or
+                // indirectly, by that setup. This comment also applies to the reactor_
+                // variables of the other streaming objects in this file.
+                std::atomic<ServerUnaryReactor*> reactor_;
+                // callbacks_outstanding_ follows a refcount pattern
+                std::atomic<intptr_t> callbacks_outstanding_{
+                    3};  // reserve for start, Finish, and CompletionOp
+            };
+        };
+
+        template<class RequestType, class ResponseType>
+        class CallbackClientStreamingHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            explicit CallbackClientStreamingHandler(
+                std::function<ServerReadReactor<RequestType>*(
+                    grpc::CallbackServerContext*, ResponseType*
+                )>
+                    get_reactor
+            ) :
+                get_reactor_(std::move(get_reactor))
+            {
+            }
+            void RunHandler(const HandlerParameter& param) final
+            {
+                // Arena allocate a reader structure (that includes response)
+                grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
+
+                auto* reader = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    param.call->call(), sizeof(ServerCallbackReaderImpl)
+                ))
+                    ServerCallbackReaderImpl(
+                        static_cast<grpc::CallbackServerContext*>(param.server_context),
+                        param.call,
+                        param.call_requester
+                    );
+                // Inlineable OnDone can be false in the CompletionOp callback because there
+                // is no read reactor that has an inlineable OnDone; this only applies to
+                // the DefaultReactor (which is unary).
+                param.server_context->BeginCompletionOp(
+                    param.call,
+                    [reader](bool)
+                    { reader->MaybeDone(/*inlineable_ondone=*/false); },
+                    reader
+                );
+
+                ServerReadReactor<RequestType>* reactor = nullptr;
+                if (param.status.ok())
+                {
+                    reactor =
+                        grpc::internal::CatchingReactorGetter<ServerReadReactor<RequestType>>(
+                            get_reactor_,
+                            static_cast<grpc::CallbackServerContext*>(param.server_context),
+                            reader->response()
+                        );
+                }
+
+                if (reactor == nullptr)
+                {
+                    // if deserialization or reactor creator failed, we need to fail the call
+                    reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                        param.call->call(), sizeof(UnimplementedReadReactor<RequestType>)
+                    ))
+                        UnimplementedReadReactor<RequestType>(
+                            grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "")
+                        );
+                }
+
+                reader->SetupReactor(reactor);
+            }
+
+        private:
+            std::function<ServerReadReactor<RequestType>*(grpc::CallbackServerContext*, ResponseType*)>
+                get_reactor_;
+
+            class ServerCallbackReaderImpl : public ServerCallbackReader<RequestType>
+            {
+            public:
+                void Finish(grpc::Status s) override
+                {
+                    // A finish tag with only MaybeDone can have its callback inlined
+                    // regardless even if OnDone is not inlineable because this callback just
+                    // checks a ref and then decides whether or not to dispatch OnDone.
+                    finish_tag_.Set(
+                        call_.call(),
+                        [this](bool)
+                        {
+                            // Inlineable OnDone can be false here because there is
+                            // no read reactor that has an inlineable OnDone; this
+                            // only applies to the DefaultReactor (which is unary).
+                            this->MaybeDone(/*inlineable_ondone=*/false);
+                        },
+                        &finish_ops_,
+                        /*can_inline=*/true
+                    );
+                    if (!ctx_->sent_initial_metadata_)
+                    {
+                        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                        if (ctx_->compression_level_set())
+                        {
+                            finish_ops_.set_compression_level(ctx_->compression_level());
+                        }
+                        ctx_->sent_initial_metadata_ = true;
+                    }
+                    // The response is dropped if the status is not OK.
+                    if (s.ok())
+                    {
+                        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, finish_ops_.SendMessagePtr(&resp_));
+                    }
+                    else
+                    {
+                        finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
+                    }
+                    finish_ops_.set_core_cq_tag(&finish_tag_);
+                    call_.PerformOps(&finish_ops_);
+                }
+
+                void SendInitialMetadata() override
+                {
+                    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+                    this->Ref();
+                    // The callback for this function should not be inlined because it invokes
+                    // a user-controlled reaction, but any resulting OnDone can be inlined in
+                    // the executor to which this callback is dispatched.
+                    meta_tag_.Set(
+                        call_.call(),
+                        [this](bool ok)
+                        {
+                            ServerReadReactor<RequestType>* reactor =
+                                reactor_.load(std::memory_order_relaxed);
+                            reactor->OnSendInitialMetadataDone(ok);
+                            this->MaybeDone(/*inlineable_ondone=*/true);
+                        },
+                        &meta_ops_,
+                        /*can_inline=*/false
+                    );
+                    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                    if (ctx_->compression_level_set())
+                    {
+                        meta_ops_.set_compression_level(ctx_->compression_level());
+                    }
+                    ctx_->sent_initial_metadata_ = true;
+                    meta_ops_.set_core_cq_tag(&meta_tag_);
+                    call_.PerformOps(&meta_ops_);
+                }
+
+                void Read(RequestType* req) override
+                {
+                    this->Ref();
+                    read_ops_.RecvMessage(req);
+                    call_.PerformOps(&read_ops_);
+                }
+
+            private:
+                friend class CallbackClientStreamingHandler<RequestType, ResponseType>;
+
+                ServerCallbackReaderImpl(grpc::CallbackServerContext* ctx, grpc::internal::Call* call, std::function<void()> call_requester) :
+                    ctx_(ctx),
+                    call_(*call),
+                    call_requester_(std::move(call_requester))
+                {
+                }
+
+                void SetupReactor(ServerReadReactor<RequestType>* reactor)
+                {
+                    reactor_.store(reactor, std::memory_order_relaxed);
+                    // The callback for this function should not be inlined because it invokes
+                    // a user-controlled reaction, but any resulting OnDone can be inlined in
+                    // the executor to which this callback is dispatched.
+                    read_tag_.Set(
+                        call_.call(),
+                        [this, reactor](bool ok)
+                        {
+                            if (GPR_UNLIKELY(!ok))
+                            {
+                                ctx_->MaybeMarkCancelledOnRead();
+                            }
+                            reactor->OnReadDone(ok);
+                            this->MaybeDone(/*inlineable_ondone=*/true);
+                        },
+                        &read_ops_,
+                        /*can_inline=*/false
+                    );
+                    read_ops_.set_core_cq_tag(&read_tag_);
+                    this->BindReactor(reactor);
+                    this->MaybeCallOnCancel(reactor);
+                    // Inlineable OnDone can be false here because there is no read
+                    // reactor that has an inlineable OnDone; this only applies to the
+                    // DefaultReactor (which is unary).
+                    this->MaybeDone(/*inlineable_ondone=*/false);
+                }
+
+                ~ServerCallbackReaderImpl()
+                {
+                }
+
+                ResponseType* response()
+                {
+                    return &resp_;
+                }
+
+                void CallOnDone() override
+                {
+                    reactor_.load(std::memory_order_relaxed)->OnDone();
+                    grpc_call* call = call_.call();
+                    auto call_requester = std::move(call_requester_);
+                    if (ctx_->context_allocator() != nullptr)
+                    {
+                        ctx_->context_allocator()->Release(ctx_);
+                    }
+                    this->~ServerCallbackReaderImpl();  // explicitly call destructor
+                    grpc::g_core_codegen_interface->grpc_call_unref(call);
+                    call_requester();
+                }
+
+                ServerReactor* reactor() override
+                {
+                    return reactor_.load(std::memory_order_relaxed);
+                }
+
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+                    meta_ops_;
+                grpc::internal::CallbackWithSuccessTag meta_tag_;
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+                    finish_ops_;
+                grpc::internal::CallbackWithSuccessTag finish_tag_;
+                grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<RequestType>>
+                    read_ops_;
+                grpc::internal::CallbackWithSuccessTag read_tag_;
+
+                grpc::CallbackServerContext* const ctx_;
+                grpc::internal::Call call_;
+                ResponseType resp_;
+                std::function<void()> call_requester_;
+                // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
+                std::atomic<ServerReadReactor<RequestType>*> reactor_;
+                // callbacks_outstanding_ follows a refcount pattern
+                std::atomic<intptr_t> callbacks_outstanding_{
+                    3};  // reserve for OnStarted, Finish, and CompletionOp
+            };
+        };
+
+        template<class RequestType, class ResponseType>
+        class CallbackServerStreamingHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            explicit CallbackServerStreamingHandler(
+                std::function<ServerWriteReactor<ResponseType>*(
+                    grpc::CallbackServerContext*, const RequestType*
+                )>
+                    get_reactor
+            ) :
+                get_reactor_(std::move(get_reactor))
+            {
+            }
+            void RunHandler(const HandlerParameter& param) final
+            {
+                // Arena allocate a writer structure
+                grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
+
+                auto* writer = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    param.call->call(), sizeof(ServerCallbackWriterImpl)
+                ))
+                    ServerCallbackWriterImpl(
+                        static_cast<grpc::CallbackServerContext*>(param.server_context),
+                        param.call,
+                        static_cast<RequestType*>(param.request),
+                        param.call_requester
+                    );
+                // Inlineable OnDone can be false in the CompletionOp callback because there
+                // is no write reactor that has an inlineable OnDone; this only applies to
+                // the DefaultReactor (which is unary).
+                param.server_context->BeginCompletionOp(
+                    param.call,
+                    [writer](bool)
+                    { writer->MaybeDone(/*inlineable_ondone=*/false); },
+                    writer
+                );
+
+                ServerWriteReactor<ResponseType>* reactor = nullptr;
+                if (param.status.ok())
+                {
+                    reactor = grpc::internal::CatchingReactorGetter<
+                        ServerWriteReactor<ResponseType>>(
+                        get_reactor_,
+                        static_cast<grpc::CallbackServerContext*>(param.server_context),
+                        writer->request()
+                    );
+                }
+                if (reactor == nullptr)
+                {
+                    // if deserialization or reactor creator failed, we need to fail the call
+                    reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                        param.call->call(), sizeof(UnimplementedWriteReactor<ResponseType>)
+                    ))
+                        UnimplementedWriteReactor<ResponseType>(
+                            grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "")
+                        );
+                }
+
+                writer->SetupReactor(reactor);
+            }
+
+            void* Deserialize(grpc_call* call, grpc_byte_buffer* req, grpc::Status* status, void** /*handler_data*/) final
+            {
+                grpc::ByteBuffer buf;
+                buf.set_buffer(req);
+                auto* request = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    call, sizeof(RequestType)
+                )) RequestType();
+                *status =
+                    grpc::SerializationTraits<RequestType>::Deserialize(&buf, request);
+                buf.Release();
+                if (status->ok())
+                {
+                    return request;
+                }
+                request->~RequestType();
+                return nullptr;
+            }
+
+        private:
+            std::function<ServerWriteReactor<ResponseType>*(grpc::CallbackServerContext*, const RequestType*)>
+                get_reactor_;
+
+            class ServerCallbackWriterImpl : public ServerCallbackWriter<ResponseType>
+            {
+            public:
+                void Finish(grpc::Status s) override
+                {
+                    // A finish tag with only MaybeDone can have its callback inlined
+                    // regardless even if OnDone is not inlineable because this callback just
+                    // checks a ref and then decides whether or not to dispatch OnDone.
+                    finish_tag_.Set(
+                        call_.call(),
+                        [this](bool)
+                        {
+                            // Inlineable OnDone can be false here because there is
+                            // no write reactor that has an inlineable OnDone; this
+                            // only applies to the DefaultReactor (which is unary).
+                            this->MaybeDone(/*inlineable_ondone=*/false);
+                        },
+                        &finish_ops_,
+                        /*can_inline=*/true
+                    );
+                    finish_ops_.set_core_cq_tag(&finish_tag_);
+
+                    if (!ctx_->sent_initial_metadata_)
+                    {
+                        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                        if (ctx_->compression_level_set())
+                        {
+                            finish_ops_.set_compression_level(ctx_->compression_level());
+                        }
+                        ctx_->sent_initial_metadata_ = true;
+                    }
+                    finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
+                    call_.PerformOps(&finish_ops_);
+                }
+
+                void SendInitialMetadata() override
+                {
+                    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+                    this->Ref();
+                    // The callback for this function should not be inlined because it invokes
+                    // a user-controlled reaction, but any resulting OnDone can be inlined in
+                    // the executor to which this callback is dispatched.
+                    meta_tag_.Set(
+                        call_.call(),
+                        [this](bool ok)
+                        {
+                            ServerWriteReactor<ResponseType>* reactor =
+                                reactor_.load(std::memory_order_relaxed);
+                            reactor->OnSendInitialMetadataDone(ok);
+                            this->MaybeDone(/*inlineable_ondone=*/true);
+                        },
+                        &meta_ops_,
+                        /*can_inline=*/false
+                    );
+                    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                    if (ctx_->compression_level_set())
+                    {
+                        meta_ops_.set_compression_level(ctx_->compression_level());
+                    }
+                    ctx_->sent_initial_metadata_ = true;
+                    meta_ops_.set_core_cq_tag(&meta_tag_);
+                    call_.PerformOps(&meta_ops_);
+                }
+
+                void Write(const ResponseType* resp, grpc::WriteOptions options) override
+                {
+                    this->Ref();
+                    if (options.is_last_message())
+                    {
+                        options.set_buffer_hint();
+                    }
+                    if (!ctx_->sent_initial_metadata_)
+                    {
+                        write_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                        if (ctx_->compression_level_set())
+                        {
+                            write_ops_.set_compression_level(ctx_->compression_level());
+                        }
+                        ctx_->sent_initial_metadata_ = true;
+                    }
+                    // TODO(vjpai): don't assert
+                    GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(resp, options).ok());
+                    call_.PerformOps(&write_ops_);
+                }
+
+                void WriteAndFinish(const ResponseType* resp, grpc::WriteOptions options, grpc::Status s) override
+                {
+                    // This combines the write into the finish callback
+                    // TODO(vjpai): don't assert
+                    GPR_CODEGEN_ASSERT(finish_ops_.SendMessagePtr(resp, options).ok());
+                    Finish(std::move(s));
+                }
+
+            private:
+                friend class CallbackServerStreamingHandler<RequestType, ResponseType>;
+
+                ServerCallbackWriterImpl(grpc::CallbackServerContext* ctx, grpc::internal::Call* call, const RequestType* req, std::function<void()> call_requester) :
+                    ctx_(ctx),
+                    call_(*call),
+                    req_(req),
+                    call_requester_(std::move(call_requester))
+                {
+                }
+
+                void SetupReactor(ServerWriteReactor<ResponseType>* reactor)
+                {
+                    reactor_.store(reactor, std::memory_order_relaxed);
+                    // The callback for this function should not be inlined because it invokes
+                    // a user-controlled reaction, but any resulting OnDone can be inlined in
+                    // the executor to which this callback is dispatched.
+                    write_tag_.Set(
+                        call_.call(),
+                        [this, reactor](bool ok)
+                        {
+                            reactor->OnWriteDone(ok);
+                            this->MaybeDone(/*inlineable_ondone=*/true);
+                        },
+                        &write_ops_,
+                        /*can_inline=*/false
+                    );
+                    write_ops_.set_core_cq_tag(&write_tag_);
+                    this->BindReactor(reactor);
+                    this->MaybeCallOnCancel(reactor);
+                    // Inlineable OnDone can be false here because there is no write
+                    // reactor that has an inlineable OnDone; this only applies to the
+                    // DefaultReactor (which is unary).
+                    this->MaybeDone(/*inlineable_ondone=*/false);
+                }
+                ~ServerCallbackWriterImpl()
+                {
+                    if (req_ != nullptr)
+                    {
+                        req_->~RequestType();
+                    }
+                }
+
+                const RequestType* request()
+                {
+                    return req_;
+                }
+
+                void CallOnDone() override
+                {
+                    reactor_.load(std::memory_order_relaxed)->OnDone();
+                    grpc_call* call = call_.call();
+                    auto call_requester = std::move(call_requester_);
+                    if (ctx_->context_allocator() != nullptr)
+                    {
+                        ctx_->context_allocator()->Release(ctx_);
+                    }
+                    this->~ServerCallbackWriterImpl();  // explicitly call destructor
+                    grpc::g_core_codegen_interface->grpc_call_unref(call);
+                    call_requester();
+                }
+
+                ServerReactor* reactor() override
+                {
+                    return reactor_.load(std::memory_order_relaxed);
+                }
+
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+                    meta_ops_;
+                grpc::internal::CallbackWithSuccessTag meta_tag_;
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+                    finish_ops_;
+                grpc::internal::CallbackWithSuccessTag finish_tag_;
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage>
+                    write_ops_;
+                grpc::internal::CallbackWithSuccessTag write_tag_;
+
+                grpc::CallbackServerContext* const ctx_;
+                grpc::internal::Call call_;
+                const RequestType* req_;
+                std::function<void()> call_requester_;
+                // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
+                std::atomic<ServerWriteReactor<ResponseType>*> reactor_;
+                // callbacks_outstanding_ follows a refcount pattern
+                std::atomic<intptr_t> callbacks_outstanding_{
+                    3};  // reserve for OnStarted, Finish, and CompletionOp
+            };
+        };
+
+        template<class RequestType, class ResponseType>
+        class CallbackBidiHandler : public grpc::internal::MethodHandler
+        {
+        public:
+            explicit CallbackBidiHandler(
+                std::function<ServerBidiReactor<RequestType, ResponseType>*(
+                    grpc::CallbackServerContext*
+                )>
+                    get_reactor
+            ) :
+                get_reactor_(std::move(get_reactor))
+            {
+            }
+            void RunHandler(const HandlerParameter& param) final
+            {
+                grpc::g_core_codegen_interface->grpc_call_ref(param.call->call());
+
+                auto* stream = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                    param.call->call(), sizeof(ServerCallbackReaderWriterImpl)
+                ))
+                    ServerCallbackReaderWriterImpl(
+                        static_cast<grpc::CallbackServerContext*>(param.server_context),
+                        param.call,
+                        param.call_requester
+                    );
+                // Inlineable OnDone can be false in the CompletionOp callback because there
+                // is no bidi reactor that has an inlineable OnDone; this only applies to
+                // the DefaultReactor (which is unary).
+                param.server_context->BeginCompletionOp(
+                    param.call,
+                    [stream](bool)
+                    { stream->MaybeDone(/*inlineable_ondone=*/false); },
+                    stream
+                );
+
+                ServerBidiReactor<RequestType, ResponseType>* reactor = nullptr;
+                if (param.status.ok())
+                {
+                    reactor = grpc::internal::CatchingReactorGetter<
+                        ServerBidiReactor<RequestType, ResponseType>>(
+                        get_reactor_,
+                        static_cast<grpc::CallbackServerContext*>(param.server_context)
+                    );
+                }
+
+                if (reactor == nullptr)
+                {
+                    // if deserialization or reactor creator failed, we need to fail the call
+                    reactor = new (grpc::g_core_codegen_interface->grpc_call_arena_alloc(
+                        param.call->call(),
+                        sizeof(UnimplementedBidiReactor<RequestType, ResponseType>)
+                    ))
+                        UnimplementedBidiReactor<RequestType, ResponseType>(
+                            grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "")
+                        );
+                }
+
+                stream->SetupReactor(reactor);
+            }
+
+        private:
+            std::function<ServerBidiReactor<RequestType, ResponseType>*(
+                grpc::CallbackServerContext*
+            )>
+                get_reactor_;
+
+            class ServerCallbackReaderWriterImpl : public ServerCallbackReaderWriter<RequestType, ResponseType>
+            {
+            public:
+                void Finish(grpc::Status s) override
+                {
+                    // A finish tag with only MaybeDone can have its callback inlined
+                    // regardless even if OnDone is not inlineable because this callback just
+                    // checks a ref and then decides whether or not to dispatch OnDone.
+                    finish_tag_.Set(
+                        call_.call(),
+                        [this](bool)
+                        {
+                            // Inlineable OnDone can be false here because there is
+                            // no bidi reactor that has an inlineable OnDone; this
+                            // only applies to the DefaultReactor (which is unary).
+                            this->MaybeDone(/*inlineable_ondone=*/false);
+                        },
+                        &finish_ops_,
+                        /*can_inline=*/true
+                    );
+                    finish_ops_.set_core_cq_tag(&finish_tag_);
+
+                    if (!ctx_->sent_initial_metadata_)
+                    {
+                        finish_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                        if (ctx_->compression_level_set())
+                        {
+                            finish_ops_.set_compression_level(ctx_->compression_level());
+                        }
+                        ctx_->sent_initial_metadata_ = true;
+                    }
+                    finish_ops_.ServerSendStatus(&ctx_->trailing_metadata_, s);
+                    call_.PerformOps(&finish_ops_);
+                }
+
+                void SendInitialMetadata() override
+                {
+                    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+                    this->Ref();
+                    // The callback for this function should not be inlined because it invokes
+                    // a user-controlled reaction, but any resulting OnDone can be inlined in
+                    // the executor to which this callback is dispatched.
+                    meta_tag_.Set(
+                        call_.call(),
+                        [this](bool ok)
+                        {
+                            ServerBidiReactor<RequestType, ResponseType>* reactor =
+                                reactor_.load(std::memory_order_relaxed);
+                            reactor->OnSendInitialMetadataDone(ok);
+                            this->MaybeDone(/*inlineable_ondone=*/true);
+                        },
+                        &meta_ops_,
+                        /*can_inline=*/false
+                    );
+                    meta_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                    if (ctx_->compression_level_set())
+                    {
+                        meta_ops_.set_compression_level(ctx_->compression_level());
+                    }
+                    ctx_->sent_initial_metadata_ = true;
+                    meta_ops_.set_core_cq_tag(&meta_tag_);
+                    call_.PerformOps(&meta_ops_);
+                }
+
+                void Write(const ResponseType* resp, grpc::WriteOptions options) override
+                {
+                    this->Ref();
+                    if (options.is_last_message())
+                    {
+                        options.set_buffer_hint();
+                    }
+                    if (!ctx_->sent_initial_metadata_)
+                    {
+                        write_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                        if (ctx_->compression_level_set())
+                        {
+                            write_ops_.set_compression_level(ctx_->compression_level());
+                        }
+                        ctx_->sent_initial_metadata_ = true;
+                    }
+                    // TODO(vjpai): don't assert
+                    GPR_CODEGEN_ASSERT(write_ops_.SendMessagePtr(resp, options).ok());
+                    call_.PerformOps(&write_ops_);
+                }
+
+                void WriteAndFinish(const ResponseType* resp, grpc::WriteOptions options, grpc::Status s) override
+                {
+                    // TODO(vjpai): don't assert
+                    GPR_CODEGEN_ASSERT(finish_ops_.SendMessagePtr(resp, options).ok());
+                    Finish(std::move(s));
+                }
+
+                void Read(RequestType* req) override
+                {
+                    this->Ref();
+                    read_ops_.RecvMessage(req);
+                    call_.PerformOps(&read_ops_);
+                }
+
+            private:
+                friend class CallbackBidiHandler<RequestType, ResponseType>;
+
+                ServerCallbackReaderWriterImpl(grpc::CallbackServerContext* ctx, grpc::internal::Call* call, std::function<void()> call_requester) :
+                    ctx_(ctx),
+                    call_(*call),
+                    call_requester_(std::move(call_requester))
+                {
+                }
+
+                void SetupReactor(ServerBidiReactor<RequestType, ResponseType>* reactor)
+                {
+                    reactor_.store(reactor, std::memory_order_relaxed);
+                    // The callbacks for these functions should not be inlined because they
+                    // invoke user-controlled reactions, but any resulting OnDones can be
+                    // inlined in the executor to which a callback is dispatched.
+                    write_tag_.Set(
+                        call_.call(),
+                        [this, reactor](bool ok)
+                        {
+                            reactor->OnWriteDone(ok);
+                            this->MaybeDone(/*inlineable_ondone=*/true);
+                        },
+                        &write_ops_,
+                        /*can_inline=*/false
+                    );
+                    write_ops_.set_core_cq_tag(&write_tag_);
+                    read_tag_.Set(
+                        call_.call(),
+                        [this, reactor](bool ok)
+                        {
+                            if (GPR_UNLIKELY(!ok))
+                            {
+                                ctx_->MaybeMarkCancelledOnRead();
+                            }
+                            reactor->OnReadDone(ok);
+                            this->MaybeDone(/*inlineable_ondone=*/true);
+                        },
+                        &read_ops_,
+                        /*can_inline=*/false
+                    );
+                    read_ops_.set_core_cq_tag(&read_tag_);
+                    this->BindReactor(reactor);
+                    this->MaybeCallOnCancel(reactor);
+                    // Inlineable OnDone can be false here because there is no bidi
+                    // reactor that has an inlineable OnDone; this only applies to the
+                    // DefaultReactor (which is unary).
+                    this->MaybeDone(/*inlineable_ondone=*/false);
+                }
+
+                void CallOnDone() override
+                {
+                    reactor_.load(std::memory_order_relaxed)->OnDone();
+                    grpc_call* call = call_.call();
+                    auto call_requester = std::move(call_requester_);
+                    if (ctx_->context_allocator() != nullptr)
+                    {
+                        ctx_->context_allocator()->Release(ctx_);
+                    }
+                    this->~ServerCallbackReaderWriterImpl();  // explicitly call destructor
+                    grpc::g_core_codegen_interface->grpc_call_unref(call);
+                    call_requester();
+                }
+
+                ServerReactor* reactor() override
+                {
+                    return reactor_.load(std::memory_order_relaxed);
+                }
+
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata>
+                    meta_ops_;
+                grpc::internal::CallbackWithSuccessTag meta_tag_;
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus>
+                    finish_ops_;
+                grpc::internal::CallbackWithSuccessTag finish_tag_;
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage>
+                    write_ops_;
+                grpc::internal::CallbackWithSuccessTag write_tag_;
+                grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<RequestType>>
+                    read_ops_;
+                grpc::internal::CallbackWithSuccessTag read_tag_;
+
+                grpc::CallbackServerContext* const ctx_;
+                grpc::internal::Call call_;
+                std::function<void()> call_requester_;
+                // The memory ordering of reactor_ follows ServerCallbackUnaryImpl.
+                std::atomic<ServerBidiReactor<RequestType, ResponseType>*> reactor_;
+                // callbacks_outstanding_ follows a refcount pattern
+                std::atomic<intptr_t> callbacks_outstanding_{
+                    3};  // reserve for OnStarted, Finish, and CompletionOp
+            };
+        };
+
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_SERVER_CALLBACK_HANDLERS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_context.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_context.h
index 05d8d63..4347ce9 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_context.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_context.h
@@ -51,629 +51,713 @@ struct grpc_metadata;
 struct grpc_call;
 struct census_context;
 
-namespace grpc {
-template <class W, class R>
-class ServerAsyncReader;
-template <class W>
-class ServerAsyncWriter;
-template <class W>
-class ServerAsyncResponseWriter;
-template <class W, class R>
-class ServerAsyncReaderWriter;
-template <class R>
-class ServerReader;
-template <class W>
-class ServerWriter;
-
-extern CoreCodegenInterface* g_core_codegen_interface;
-
-namespace internal {
-template <class ServiceType, class RequestType, class ResponseType>
-class BidiStreamingHandler;
-template <class RequestType, class ResponseType>
-class CallbackUnaryHandler;
-template <class RequestType, class ResponseType>
-class CallbackClientStreamingHandler;
-template <class RequestType, class ResponseType>
-class CallbackServerStreamingHandler;
-template <class RequestType, class ResponseType>
-class CallbackBidiHandler;
-template <class ServiceType, class RequestType, class ResponseType>
-class ClientStreamingHandler;
-template <class ResponseType>
-void UnaryRunHandlerHelper(const MethodHandler::HandlerParameter&,
-                           ResponseType*, Status&);
-template <class ServiceType, class RequestType, class ResponseType,
-          class BaseRequestType, class BaseResponseType>
-class RpcMethodHandler;
-template <class Base>
-class FinishOnlyReactor;
-template <class W, class R>
-class ServerReaderWriterBody;
-template <class ServiceType, class RequestType, class ResponseType>
-class ServerStreamingHandler;
-class ServerReactor;
-template <class Streamer, bool WriteNeeded>
-class TemplatedBidiStreamingHandler;
-template <grpc::StatusCode code>
-class ErrorMethodHandler;
-}  // namespace internal
-
-class ClientContext;
-class CompletionQueue;
-class GenericServerContext;
-class Server;
-class ServerInterface;
-class ContextAllocator;
-class GenericCallbackServerContext;
-
-namespace internal {
-class Call;
-}  // namespace internal
-
-namespace testing {
-class InteropServerContextInspector;
-class ServerContextTestSpouse;
-class DefaultReactorTestPeer;
-}  // namespace testing
-
-namespace experimental {
-class OrcaServerInterceptor;
-class CallMetricRecorder;
-}  // namespace experimental
-
-/// Base class of ServerContext.
-class ServerContextBase {
- public:
-  virtual ~ServerContextBase();
-
-  /// Return the deadline for the server call.
-  std::chrono::system_clock::time_point deadline() const {
-    return grpc::Timespec2Timepoint(deadline_);
-  }
-
-  /// Return a \a gpr_timespec representation of the server call's deadline.
-  gpr_timespec raw_deadline() const { return deadline_; }
-
-  /// Add the (\a key, \a value) pair to the initial metadata
-  /// associated with a server call. These are made available at the client side
-  /// by the \a grpc::ClientContext::GetServerInitialMetadata() method.
-  ///
-  /// \warning This method should only be called before sending initial metadata
-  /// to the client (which can happen explicitly, or implicitly when sending a
-  /// a response message or status to the client).
-  ///
-  /// \param key The metadata key. If \a value is binary data, it must
-  /// end in "-bin".
-  /// \param value The metadata value. If its value is binary, the key name
-  /// must end in "-bin".
-  ///
-  /// Metadata must conform to the following format:
-  /**
-  \verbatim
-  Custom-Metadata -> Binary-Header / ASCII-Header
-  Binary-Header -> {Header-Name "-bin" } {binary value}
-  ASCII-Header -> Header-Name ASCII-Value
-  Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
-  ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
-  \endverbatim
-  **/
-  void AddInitialMetadata(const std::string& key, const std::string& value);
-
-  /// Add the (\a key, \a value) pair to the initial metadata
-  /// associated with a server call. These are made available at the client
-  /// side by the \a grpc::ClientContext::GetServerTrailingMetadata() method.
-  ///
-  /// \warning This method should only be called before sending trailing
-  /// metadata to the client (which happens when the call is finished and a
-  /// status is sent to the client).
-  ///
-  /// \param key The metadata key. If \a value is binary data,
-  /// it must end in "-bin".
-  /// \param value The metadata value. If its value is binary, the key name
-  /// must end in "-bin".
-  ///
-  /// Metadata must conform to the following format:
-  /**
-  \verbatim
-  Custom-Metadata -> Binary-Header / ASCII-Header
-  Binary-Header -> {Header-Name "-bin" } {binary value}
-  ASCII-Header -> Header-Name ASCII-Value
-  Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
-  ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
-  \endverbatim
-  **/
-  void AddTrailingMetadata(const std::string& key, const std::string& value);
-
-  /// Return whether this RPC failed before the server could provide its status
-  /// back to the client. This could be because of explicit API cancellation
-  /// from the client-side or server-side, because of deadline exceeded, network
-  /// connection reset, HTTP/2 parameter configuration (e.g., max message size,
-  /// max connection age), etc. It does NOT include failure due to a non-OK
-  /// status return from the server application's request handler, including
-  /// Status::CANCELLED.
-  ///
-  /// IsCancelled is always safe to call when using sync or callback API.
-  /// When using async API, it is only safe to call IsCancelled after
-  /// the AsyncNotifyWhenDone tag has been delivered. Thread-safe.
-  bool IsCancelled() const;
-
-  /// Cancel the Call from the server. This is a best-effort API and
-  /// depending on when it is called, the RPC may still appear successful to
-  /// the client. For example, if TryCancel() is called on a separate thread, it
-  /// might race with the server handler which might return success to the
-  /// client before TryCancel() was even started by the thread.
-  ///
-  /// It is the caller's responsibility to prevent such races and ensure that if
-  /// TryCancel() is called, the serverhandler must return Status::CANCELLED.
-  /// The only exception is that if the serverhandler is already returning an
-  /// error status code, it is ok to not return Status::CANCELLED even if
-  /// TryCancel() was called.
-  ///
-  /// For reasons such as the above, it is generally preferred to explicitly
-  /// finish an RPC by returning Status::CANCELLED rather than using TryCancel.
-  ///
-  /// Note that TryCancel() does not change any of the tags that are pending
-  /// on the completion queue. All pending tags will still be delivered
-  /// (though their ok result may reflect the effect of cancellation).
-  void TryCancel() const;
-
-  /// Return a collection of initial metadata key-value pairs sent from the
-  /// client. Note that keys may happen more than
-  /// once (ie, a \a std::multimap is returned).
-  ///
-  /// It is safe to use this method after initial metadata has been received,
-  /// Calls always begin with the client sending initial metadata, so this is
-  /// safe to access as soon as the call has begun on the server side.
-  ///
-  /// \return A multimap of initial metadata key-value pairs from the server.
-  const std::multimap<grpc::string_ref, grpc::string_ref>& client_metadata()
-      const {
-    return *client_metadata_.map();
-  }
-
-  /// Return the compression algorithm to be used by the server call.
-  grpc_compression_level compression_level() const {
-    return compression_level_;
-  }
-
-  /// Set \a level to be the compression level used for the server call.
-  ///
-  /// \param level The compression level used for the server call.
-  void set_compression_level(grpc_compression_level level) {
-    compression_level_set_ = true;
-    compression_level_ = level;
-  }
-
-  /// Return a bool indicating whether the compression level for this call
-  /// has been set (either implicitly or through a previous call to
-  /// \a set_compression_level.
-  bool compression_level_set() const { return compression_level_set_; }
-
-  /// Return the compression algorithm the server call will request be used.
-  /// Note that the gRPC runtime may decide to ignore this request, for example,
-  /// due to resource constraints, or if the server is aware the client doesn't
-  /// support the requested algorithm.
-  grpc_compression_algorithm compression_algorithm() const {
-    return compression_algorithm_;
-  }
-  /// Set \a algorithm to be the compression algorithm used for the server call.
-  ///
-  /// \param algorithm The compression algorithm used for the server call.
-  void set_compression_algorithm(grpc_compression_algorithm algorithm);
-
-  /// Set the serialized load reporting costs in \a cost_data for the call.
-  void SetLoadReportingCosts(const std::vector<std::string>& cost_data);
-
-  /// Return the authentication context for this server call.
-  ///
-  /// \see grpc::AuthContext.
-  std::shared_ptr<const grpc::AuthContext> auth_context() const {
-    if (auth_context_ == nullptr) {
-      auth_context_ = grpc::CreateAuthContext(call_.call);
-    }
-    return auth_context_;
-  }
-
-  /// Return the peer uri in a string.
-  /// WARNING: this value is never authenticated or subject to any security
-  /// related code. It must not be used for any authentication related
-  /// functionality. Instead, use auth_context.
-  std::string peer() const;
-
-  /// Get the census context associated with this server call.
-  const struct census_context* census_context() const;
-
-  /// Should be used for framework-level extensions only.
-  /// Applications never need to call this method.
-  grpc_call* c_call() { return call_.call; }
-
-  /// Get the \a CallMetricRecorder object for the current RPC.
-  /// Use it to record metrics during your RPC to send back to the
-  /// client in order to make load balancing decisions. This will
-  /// return nullptr if the feature hasn't been enabled using
-  /// \a EnableCallMetricRecording.
-  experimental::CallMetricRecorder* ExperimentalGetCallMetricRecorder() {
-    return call_metric_recorder_;
-  }
-
-  /// EXPERIMENTAL API
-  /// Returns the call's authority.
-  grpc::string_ref ExperimentalGetAuthority() const;
-
- protected:
-  /// Async only. Has to be called before the rpc starts.
-  /// Returns the tag in completion queue when the rpc finishes.
-  /// IsCancelled() can then be called to check whether the rpc was cancelled.
-  /// TODO(vjpai): Fix this so that the tag is returned even if the call never
-  /// starts (https://github.com/grpc/grpc/issues/10136).
-  void AsyncNotifyWhenDone(void* tag) {
-    has_notify_when_done_tag_ = true;
-    async_notify_when_done_tag_ = tag;
-  }
-
-  /// NOTE: This is an API for advanced users who need custom allocators.
-  /// Get and maybe mutate the allocator state associated with the current RPC.
-  /// Currently only applicable for callback unary RPC methods.
-  RpcAllocatorState* GetRpcAllocatorState() { return message_allocator_state_; }
-
-  /// Get a library-owned default unary reactor for use in minimal reaction
-  /// cases. This supports typical unary RPC usage of providing a response and
-  /// status. It supports immediate Finish (finish from within the method
-  /// handler) or delayed Finish (finish called after the method handler
-  /// invocation). It does not support reacting to cancellation or completion,
-  /// or early sending of initial metadata. Since this is a library-owned
-  /// reactor, it should not be delete'd or freed in any way. This is more
-  /// efficient than creating a user-owned reactor both because of avoiding an
-  /// allocation and because its minimal reactions are optimized using a core
-  /// surface flag that allows their reactions to run inline without any
-  /// thread-hop.
-  ///
-  /// This method should not be called more than once or called after return
-  /// from the method handler.
-  grpc::ServerUnaryReactor* DefaultReactor() {
-    // Short-circuit the case where a default reactor was already set up by
-    // the TestPeer.
-    if (test_unary_ != nullptr) {
-      return reinterpret_cast<Reactor*>(&default_reactor_);
-    }
-    new (&default_reactor_) Reactor;
+namespace grpc
+{
+    template<class W, class R>
+    class ServerAsyncReader;
+    template<class W>
+    class ServerAsyncWriter;
+    template<class W>
+    class ServerAsyncResponseWriter;
+    template<class W, class R>
+    class ServerAsyncReaderWriter;
+    template<class R>
+    class ServerReader;
+    template<class W>
+    class ServerWriter;
+
+    extern CoreCodegenInterface* g_core_codegen_interface;
+
+    namespace internal
+    {
+        template<class ServiceType, class RequestType, class ResponseType>
+        class BidiStreamingHandler;
+        template<class RequestType, class ResponseType>
+        class CallbackUnaryHandler;
+        template<class RequestType, class ResponseType>
+        class CallbackClientStreamingHandler;
+        template<class RequestType, class ResponseType>
+        class CallbackServerStreamingHandler;
+        template<class RequestType, class ResponseType>
+        class CallbackBidiHandler;
+        template<class ServiceType, class RequestType, class ResponseType>
+        class ClientStreamingHandler;
+        template<class ResponseType>
+        void UnaryRunHandlerHelper(const MethodHandler::HandlerParameter&, ResponseType*, Status&);
+        template<class ServiceType, class RequestType, class ResponseType, class BaseRequestType, class BaseResponseType>
+        class RpcMethodHandler;
+        template<class Base>
+        class FinishOnlyReactor;
+        template<class W, class R>
+        class ServerReaderWriterBody;
+        template<class ServiceType, class RequestType, class ResponseType>
+        class ServerStreamingHandler;
+        class ServerReactor;
+        template<class Streamer, bool WriteNeeded>
+        class TemplatedBidiStreamingHandler;
+        template<grpc::StatusCode code>
+        class ErrorMethodHandler;
+    }  // namespace internal
+
+    class ClientContext;
+    class CompletionQueue;
+    class GenericServerContext;
+    class Server;
+    class ServerInterface;
+    class ContextAllocator;
+    class GenericCallbackServerContext;
+
+    namespace internal
+    {
+        class Call;
+    }  // namespace internal
+
+    namespace testing
+    {
+        class InteropServerContextInspector;
+        class ServerContextTestSpouse;
+        class DefaultReactorTestPeer;
+    }  // namespace testing
+
+    namespace experimental
+    {
+        class OrcaServerInterceptor;
+        class CallMetricRecorder;
+    }  // namespace experimental
+
+    /// Base class of ServerContext.
+    class ServerContextBase
+    {
+    public:
+        virtual ~ServerContextBase();
+
+        /// Return the deadline for the server call.
+        std::chrono::system_clock::time_point deadline() const
+        {
+            return grpc::Timespec2Timepoint(deadline_);
+        }
+
+        /// Return a \a gpr_timespec representation of the server call's deadline.
+        gpr_timespec raw_deadline() const
+        {
+            return deadline_;
+        }
+
+        /// Add the (\a key, \a value) pair to the initial metadata
+        /// associated with a server call. These are made available at the client side
+        /// by the \a grpc::ClientContext::GetServerInitialMetadata() method.
+        ///
+        /// \warning This method should only be called before sending initial metadata
+        /// to the client (which can happen explicitly, or implicitly when sending a
+        /// a response message or status to the client).
+        ///
+        /// \param key The metadata key. If \a value is binary data, it must
+        /// end in "-bin".
+        /// \param value The metadata value. If its value is binary, the key name
+        /// must end in "-bin".
+        ///
+        /// Metadata must conform to the following format:
+        /**
+        \verbatim
+        Custom-Metadata -> Binary-Header / ASCII-Header
+        Binary-Header -> {Header-Name "-bin" } {binary value}
+        ASCII-Header -> Header-Name ASCII-Value
+        Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
+        ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
+        \endverbatim
+        **/
+        void AddInitialMetadata(const std::string& key, const std::string& value);
+
+        /// Add the (\a key, \a value) pair to the initial metadata
+        /// associated with a server call. These are made available at the client
+        /// side by the \a grpc::ClientContext::GetServerTrailingMetadata() method.
+        ///
+        /// \warning This method should only be called before sending trailing
+        /// metadata to the client (which happens when the call is finished and a
+        /// status is sent to the client).
+        ///
+        /// \param key The metadata key. If \a value is binary data,
+        /// it must end in "-bin".
+        /// \param value The metadata value. If its value is binary, the key name
+        /// must end in "-bin".
+        ///
+        /// Metadata must conform to the following format:
+        /**
+        \verbatim
+        Custom-Metadata -> Binary-Header / ASCII-Header
+        Binary-Header -> {Header-Name "-bin" } {binary value}
+        ASCII-Header -> Header-Name ASCII-Value
+        Header-Name -> 1*( %x30-39 / %x61-7A / "_" / "-" / ".") ; 0-9 a-z _ - .
+        ASCII-Value -> 1*( %x20-%x7E ) ; space and printable ASCII
+        \endverbatim
+        **/
+        void AddTrailingMetadata(const std::string& key, const std::string& value);
+
+        /// Return whether this RPC failed before the server could provide its status
+        /// back to the client. This could be because of explicit API cancellation
+        /// from the client-side or server-side, because of deadline exceeded, network
+        /// connection reset, HTTP/2 parameter configuration (e.g., max message size,
+        /// max connection age), etc. It does NOT include failure due to a non-OK
+        /// status return from the server application's request handler, including
+        /// Status::CANCELLED.
+        ///
+        /// IsCancelled is always safe to call when using sync or callback API.
+        /// When using async API, it is only safe to call IsCancelled after
+        /// the AsyncNotifyWhenDone tag has been delivered. Thread-safe.
+        bool IsCancelled() const;
+
+        /// Cancel the Call from the server. This is a best-effort API and
+        /// depending on when it is called, the RPC may still appear successful to
+        /// the client. For example, if TryCancel() is called on a separate thread, it
+        /// might race with the server handler which might return success to the
+        /// client before TryCancel() was even started by the thread.
+        ///
+        /// It is the caller's responsibility to prevent such races and ensure that if
+        /// TryCancel() is called, the serverhandler must return Status::CANCELLED.
+        /// The only exception is that if the serverhandler is already returning an
+        /// error status code, it is ok to not return Status::CANCELLED even if
+        /// TryCancel() was called.
+        ///
+        /// For reasons such as the above, it is generally preferred to explicitly
+        /// finish an RPC by returning Status::CANCELLED rather than using TryCancel.
+        ///
+        /// Note that TryCancel() does not change any of the tags that are pending
+        /// on the completion queue. All pending tags will still be delivered
+        /// (though their ok result may reflect the effect of cancellation).
+        void TryCancel() const;
+
+        /// Return a collection of initial metadata key-value pairs sent from the
+        /// client. Note that keys may happen more than
+        /// once (ie, a \a std::multimap is returned).
+        ///
+        /// It is safe to use this method after initial metadata has been received,
+        /// Calls always begin with the client sending initial metadata, so this is
+        /// safe to access as soon as the call has begun on the server side.
+        ///
+        /// \return A multimap of initial metadata key-value pairs from the server.
+        const std::multimap<grpc::string_ref, grpc::string_ref>& client_metadata()
+            const
+        {
+            return *client_metadata_.map();
+        }
+
+        /// Return the compression algorithm to be used by the server call.
+        grpc_compression_level compression_level() const
+        {
+            return compression_level_;
+        }
+
+        /// Set \a level to be the compression level used for the server call.
+        ///
+        /// \param level The compression level used for the server call.
+        void set_compression_level(grpc_compression_level level)
+        {
+            compression_level_set_ = true;
+            compression_level_ = level;
+        }
+
+        /// Return a bool indicating whether the compression level for this call
+        /// has been set (either implicitly or through a previous call to
+        /// \a set_compression_level.
+        bool compression_level_set() const
+        {
+            return compression_level_set_;
+        }
+
+        /// Return the compression algorithm the server call will request be used.
+        /// Note that the gRPC runtime may decide to ignore this request, for example,
+        /// due to resource constraints, or if the server is aware the client doesn't
+        /// support the requested algorithm.
+        grpc_compression_algorithm compression_algorithm() const
+        {
+            return compression_algorithm_;
+        }
+        /// Set \a algorithm to be the compression algorithm used for the server call.
+        ///
+        /// \param algorithm The compression algorithm used for the server call.
+        void set_compression_algorithm(grpc_compression_algorithm algorithm);
+
+        /// Set the serialized load reporting costs in \a cost_data for the call.
+        void SetLoadReportingCosts(const std::vector<std::string>& cost_data);
+
+        /// Return the authentication context for this server call.
+        ///
+        /// \see grpc::AuthContext.
+        std::shared_ptr<const grpc::AuthContext> auth_context() const
+        {
+            if (auth_context_ == nullptr)
+            {
+                auth_context_ = grpc::CreateAuthContext(call_.call);
+            }
+            return auth_context_;
+        }
+
+        /// Return the peer uri in a string.
+        /// WARNING: this value is never authenticated or subject to any security
+        /// related code. It must not be used for any authentication related
+        /// functionality. Instead, use auth_context.
+        std::string peer() const;
+
+        /// Get the census context associated with this server call.
+        const struct census_context* census_context() const;
+
+        /// Should be used for framework-level extensions only.
+        /// Applications never need to call this method.
+        grpc_call* c_call()
+        {
+            return call_.call;
+        }
+
+        /// Get the \a CallMetricRecorder object for the current RPC.
+        /// Use it to record metrics during your RPC to send back to the
+        /// client in order to make load balancing decisions. This will
+        /// return nullptr if the feature hasn't been enabled using
+        /// \a EnableCallMetricRecording.
+        experimental::CallMetricRecorder* ExperimentalGetCallMetricRecorder()
+        {
+            return call_metric_recorder_;
+        }
+
+        /// EXPERIMENTAL API
+        /// Returns the call's authority.
+        grpc::string_ref ExperimentalGetAuthority() const;
+
+    protected:
+        /// Async only. Has to be called before the rpc starts.
+        /// Returns the tag in completion queue when the rpc finishes.
+        /// IsCancelled() can then be called to check whether the rpc was cancelled.
+        /// TODO(vjpai): Fix this so that the tag is returned even if the call never
+        /// starts (https://github.com/grpc/grpc/issues/10136).
+        void AsyncNotifyWhenDone(void* tag)
+        {
+            has_notify_when_done_tag_ = true;
+            async_notify_when_done_tag_ = tag;
+        }
+
+        /// NOTE: This is an API for advanced users who need custom allocators.
+        /// Get and maybe mutate the allocator state associated with the current RPC.
+        /// Currently only applicable for callback unary RPC methods.
+        RpcAllocatorState* GetRpcAllocatorState()
+        {
+            return message_allocator_state_;
+        }
+
+        /// Get a library-owned default unary reactor for use in minimal reaction
+        /// cases. This supports typical unary RPC usage of providing a response and
+        /// status. It supports immediate Finish (finish from within the method
+        /// handler) or delayed Finish (finish called after the method handler
+        /// invocation). It does not support reacting to cancellation or completion,
+        /// or early sending of initial metadata. Since this is a library-owned
+        /// reactor, it should not be delete'd or freed in any way. This is more
+        /// efficient than creating a user-owned reactor both because of avoiding an
+        /// allocation and because its minimal reactions are optimized using a core
+        /// surface flag that allows their reactions to run inline without any
+        /// thread-hop.
+        ///
+        /// This method should not be called more than once or called after return
+        /// from the method handler.
+        grpc::ServerUnaryReactor* DefaultReactor()
+        {
+            // Short-circuit the case where a default reactor was already set up by
+            // the TestPeer.
+            if (test_unary_ != nullptr)
+            {
+                return reinterpret_cast<Reactor*>(&default_reactor_);
+            }
+            new (&default_reactor_) Reactor;
 #ifndef NDEBUG
-    bool old = false;
-    assert(default_reactor_used_.compare_exchange_strong(
-        old, true, std::memory_order_relaxed));
+            bool old = false;
+            assert(default_reactor_used_.compare_exchange_strong(
+                old, true, std::memory_order_relaxed
+            ));
 #else
-    default_reactor_used_.store(true, std::memory_order_relaxed);
+            default_reactor_used_.store(true, std::memory_order_relaxed);
 #endif
-    return reinterpret_cast<Reactor*>(&default_reactor_);
-  }
-
-  /// Constructors for use by derived classes
-  ServerContextBase();
-  ServerContextBase(gpr_timespec deadline, grpc_metadata_array* arr);
-
-  void set_context_allocator(ContextAllocator* context_allocator) {
-    context_allocator_ = context_allocator;
-  }
-
-  ContextAllocator* context_allocator() const { return context_allocator_; }
-
- private:
-  friend class grpc::testing::InteropServerContextInspector;
-  friend class grpc::testing::ServerContextTestSpouse;
-  friend class grpc::testing::DefaultReactorTestPeer;
-  friend class grpc::ServerInterface;
-  friend class grpc::Server;
-  template <class W, class R>
-  friend class grpc::ServerAsyncReader;
-  template <class W>
-  friend class grpc::ServerAsyncWriter;
-  template <class W>
-  friend class grpc::ServerAsyncResponseWriter;
-  template <class W, class R>
-  friend class grpc::ServerAsyncReaderWriter;
-  template <class R>
-  friend class grpc::ServerReader;
-  template <class W>
-  friend class grpc::ServerWriter;
-  template <class W, class R>
-  friend class grpc::internal::ServerReaderWriterBody;
-  template <class ResponseType>
-  friend void grpc::internal::UnaryRunHandlerHelper(
-      const internal::MethodHandler::HandlerParameter& param, ResponseType* rsp,
-      Status& status);
-  template <class ServiceType, class RequestType, class ResponseType,
-            class BaseRequestType, class BaseResponseType>
-  friend class grpc::internal::RpcMethodHandler;
-  template <class ServiceType, class RequestType, class ResponseType>
-  friend class grpc::internal::ClientStreamingHandler;
-  template <class ServiceType, class RequestType, class ResponseType>
-  friend class grpc::internal::ServerStreamingHandler;
-  template <class Streamer, bool WriteNeeded>
-  friend class grpc::internal::TemplatedBidiStreamingHandler;
-  template <class RequestType, class ResponseType>
-  friend class grpc::internal::CallbackUnaryHandler;
-  template <class RequestType, class ResponseType>
-  friend class grpc::internal::CallbackClientStreamingHandler;
-  template <class RequestType, class ResponseType>
-  friend class grpc::internal::CallbackServerStreamingHandler;
-  template <class RequestType, class ResponseType>
-  friend class grpc::internal::CallbackBidiHandler;
-  template <grpc::StatusCode code>
-  friend class grpc::internal::ErrorMethodHandler;
-  template <class Base>
-  friend class grpc::internal::FinishOnlyReactor;
-  friend class grpc::ClientContext;
-  friend class grpc::GenericServerContext;
-  friend class grpc::GenericCallbackServerContext;
-  friend class grpc::experimental::OrcaServerInterceptor;
-
-  /// Prevent copying.
-  ServerContextBase(const ServerContextBase&);
-  ServerContextBase& operator=(const ServerContextBase&);
-
-  class CompletionOp;
-
-  void BeginCompletionOp(
-      grpc::internal::Call* call, std::function<void(bool)> callback,
-      grpc::internal::ServerCallbackCall* callback_controller);
-  /// Return the tag queued by BeginCompletionOp()
-  grpc::internal::CompletionQueueTag* GetCompletionOpTag();
-
-  void set_call(grpc_call* call) { call_.call = call; }
-
-  void BindDeadlineAndMetadata(gpr_timespec deadline, grpc_metadata_array* arr);
-
-  uint32_t initial_metadata_flags() const { return 0; }
-
-  grpc::experimental::ServerRpcInfo* set_server_rpc_info(
-      const char* method, grpc::internal::RpcMethod::RpcType type,
-      const std::vector<std::unique_ptr<
-          grpc::experimental::ServerInterceptorFactoryInterface>>& creators) {
-    if (!creators.empty()) {
-      rpc_info_ = new grpc::experimental::ServerRpcInfo(this, method, type);
-      rpc_info_->RegisterInterceptors(creators);
-    }
-    return rpc_info_;
-  }
-
-  void set_message_allocator_state(RpcAllocatorState* allocator_state) {
-    message_allocator_state_ = allocator_state;
-  }
-
-  void MaybeMarkCancelledOnRead() {
-    if (g_core_codegen_interface->grpc_call_failed_before_recv_message(
-            call_.call)) {
-      marked_cancelled_.store(true, std::memory_order_release);
-    }
-  }
-
-  void CreateCallMetricRecorder();
-
-  struct CallWrapper {
-    ~CallWrapper();
-
-    grpc_call* call = nullptr;
-  };
-
-  // NOTE: call_ must be the first data member of this object so that its
-  //       destructor is the last to be called, since its destructor may unref
-  //       the underlying core call which holds the arena that may be used to
-  //       hold this object.
-  CallWrapper call_;
-
-  CompletionOp* completion_op_ = nullptr;
-  bool has_notify_when_done_tag_ = false;
-  void* async_notify_when_done_tag_ = nullptr;
-  grpc::internal::CallbackWithSuccessTag completion_tag_;
-
-  gpr_timespec deadline_;
-  grpc::CompletionQueue* cq_ = nullptr;
-  bool sent_initial_metadata_ = false;
-  mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
-  mutable grpc::internal::MetadataMap client_metadata_;
-  std::multimap<std::string, std::string> initial_metadata_;
-  std::multimap<std::string, std::string> trailing_metadata_;
-
-  bool compression_level_set_ = false;
-  grpc_compression_level compression_level_;
-  grpc_compression_algorithm compression_algorithm_;
-
-  grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                            grpc::internal::CallOpSendMessage>
-      pending_ops_;
-  bool has_pending_ops_ = false;
-
-  grpc::experimental::ServerRpcInfo* rpc_info_ = nullptr;
-  RpcAllocatorState* message_allocator_state_ = nullptr;
-  ContextAllocator* context_allocator_ = nullptr;
-  experimental::CallMetricRecorder* call_metric_recorder_ = nullptr;
-
-  class Reactor : public grpc::ServerUnaryReactor {
-   public:
-    void OnCancel() override {}
-    void OnDone() override {}
-    // Override InternalInlineable for this class since its reactions are
-    // trivial and thus do not need to be run from the executor (triggering a
-    // thread hop). This should only be used by internal reactors (thus the
-    // name) and not by user application code.
-    bool InternalInlineable() override { return true; }
-  };
-
-  void SetupTestDefaultReactor(std::function<void(grpc::Status)> func) {
-    // NOLINTNEXTLINE(modernize-make-unique)
-    test_unary_.reset(new TestServerCallbackUnary(this, std::move(func)));
-  }
-  bool test_status_set() const {
-    return (test_unary_ != nullptr) && test_unary_->status_set();
-  }
-  grpc::Status test_status() const { return test_unary_->status(); }
-
-  class TestServerCallbackUnary : public grpc::ServerCallbackUnary {
-   public:
-    TestServerCallbackUnary(ServerContextBase* ctx,
-                            std::function<void(grpc::Status)> func)
-        : reactor_(ctx->DefaultReactor()), func_(std::move(func)) {
-      this->BindReactor(reactor_);
-    }
-    void Finish(grpc::Status s) override {
-      status_ = s;
-      func_(std::move(s));
-      status_set_.store(true, std::memory_order_release);
-    }
-    void SendInitialMetadata() override {}
-
-    bool status_set() const {
-      return status_set_.load(std::memory_order_acquire);
-    }
-    grpc::Status status() const { return status_; }
-
-   private:
-    void CallOnDone() override {}
-    grpc::internal::ServerReactor* reactor() override { return reactor_; }
-
-    grpc::ServerUnaryReactor* const reactor_;
-    std::atomic_bool status_set_{false};
-    grpc::Status status_;
-    const std::function<void(grpc::Status s)> func_;
-  };
-
-  typename std::aligned_storage<sizeof(Reactor), alignof(Reactor)>::type
-      default_reactor_;
-  std::atomic_bool default_reactor_used_{false};
-
-  std::atomic_bool marked_cancelled_{false};
-
-  std::unique_ptr<TestServerCallbackUnary> test_unary_;
-};
-
-/// A ServerContext or CallbackServerContext allows the code implementing a
-/// service handler to:
-///
-/// - Add custom initial and trailing metadata key-value pairs that will
-///   propagated to the client side.
-/// - Control call settings such as compression and authentication.
-/// - Access metadata coming from the client.
-/// - Get performance metrics (ie, census).
-///
-/// Context settings are only relevant to the call handler they are supplied to,
-/// that is to say, they aren't sticky across multiple calls. Some of these
-/// settings, such as the compression options, can be made persistent at server
-/// construction time by specifying the appropriate \a ChannelArguments
-/// to a \a grpc::ServerBuilder, via \a ServerBuilder::AddChannelArgument.
-///
-/// \warning ServerContext instances should \em not be reused across rpcs.
-class ServerContext : public ServerContextBase {
- public:
-  ServerContext() {}  // for async calls
-
-  using ServerContextBase::AddInitialMetadata;
-  using ServerContextBase::AddTrailingMetadata;
-  using ServerContextBase::auth_context;
-  using ServerContextBase::c_call;
-  using ServerContextBase::census_context;
-  using ServerContextBase::client_metadata;
-  using ServerContextBase::compression_algorithm;
-  using ServerContextBase::compression_level;
-  using ServerContextBase::compression_level_set;
-  using ServerContextBase::deadline;
-  using ServerContextBase::IsCancelled;
-  using ServerContextBase::peer;
-  using ServerContextBase::raw_deadline;
-  using ServerContextBase::set_compression_algorithm;
-  using ServerContextBase::set_compression_level;
-  using ServerContextBase::SetLoadReportingCosts;
-  using ServerContextBase::TryCancel;
-
-  // Sync/CQ-based Async ServerContext only
-  using ServerContextBase::AsyncNotifyWhenDone;
-
- private:
-  // Constructor for internal use by server only
-  friend class grpc::Server;
-  ServerContext(gpr_timespec deadline, grpc_metadata_array* arr)
-      : ServerContextBase(deadline, arr) {}
-
-  // CallbackServerContext only
-  using ServerContextBase::DefaultReactor;
-  using ServerContextBase::GetRpcAllocatorState;
-
-  /// Prevent copying.
-  ServerContext(const ServerContext&) = delete;
-  ServerContext& operator=(const ServerContext&) = delete;
-};
-
-class CallbackServerContext : public ServerContextBase {
- public:
-  /// Public constructors are for direct use only by mocking tests. In practice,
-  /// these objects will be owned by the library.
-  CallbackServerContext() {}
-
-  using ServerContextBase::AddInitialMetadata;
-  using ServerContextBase::AddTrailingMetadata;
-  using ServerContextBase::auth_context;
-  using ServerContextBase::c_call;
-  using ServerContextBase::census_context;
-  using ServerContextBase::client_metadata;
-  using ServerContextBase::compression_algorithm;
-  using ServerContextBase::compression_level;
-  using ServerContextBase::compression_level_set;
-  using ServerContextBase::context_allocator;
-  using ServerContextBase::deadline;
-  using ServerContextBase::IsCancelled;
-  using ServerContextBase::peer;
-  using ServerContextBase::raw_deadline;
-  using ServerContextBase::set_compression_algorithm;
-  using ServerContextBase::set_compression_level;
-  using ServerContextBase::set_context_allocator;
-  using ServerContextBase::SetLoadReportingCosts;
-  using ServerContextBase::TryCancel;
-
-  // CallbackServerContext only
-  using ServerContextBase::DefaultReactor;
-  using ServerContextBase::GetRpcAllocatorState;
-
- private:
-  // Sync/CQ-based Async ServerContext only
-  using ServerContextBase::AsyncNotifyWhenDone;
-
-  /// Prevent copying.
-  CallbackServerContext(const CallbackServerContext&) = delete;
-  CallbackServerContext& operator=(const CallbackServerContext&) = delete;
-};
-
-/// A CallbackServerContext allows users to use the contents of the
-/// CallbackServerContext or GenericCallbackServerContext structure for the
-/// callback API.
-/// The library will invoke the allocator any time a new call is initiated.
-/// and call the Release method after the server OnDone.
-class ContextAllocator {
- public:
-  virtual ~ContextAllocator() {}
-
-  virtual CallbackServerContext* NewCallbackServerContext() { return nullptr; }
-
-  virtual GenericCallbackServerContext* NewGenericCallbackServerContext() {
-    return nullptr;
-  }
-
-  virtual void Release(CallbackServerContext*) {}
-
-  virtual void Release(GenericCallbackServerContext*) {}
-};
+            return reinterpret_cast<Reactor*>(&default_reactor_);
+        }
+
+        /// Constructors for use by derived classes
+        ServerContextBase();
+        ServerContextBase(gpr_timespec deadline, grpc_metadata_array* arr);
+
+        void set_context_allocator(ContextAllocator* context_allocator)
+        {
+            context_allocator_ = context_allocator;
+        }
+
+        ContextAllocator* context_allocator() const
+        {
+            return context_allocator_;
+        }
+
+    private:
+        friend class grpc::testing::InteropServerContextInspector;
+        friend class grpc::testing::ServerContextTestSpouse;
+        friend class grpc::testing::DefaultReactorTestPeer;
+        friend class grpc::ServerInterface;
+        friend class grpc::Server;
+        template<class W, class R>
+        friend class grpc::ServerAsyncReader;
+        template<class W>
+        friend class grpc::ServerAsyncWriter;
+        template<class W>
+        friend class grpc::ServerAsyncResponseWriter;
+        template<class W, class R>
+        friend class grpc::ServerAsyncReaderWriter;
+        template<class R>
+        friend class grpc::ServerReader;
+        template<class W>
+        friend class grpc::ServerWriter;
+        template<class W, class R>
+        friend class grpc::internal::ServerReaderWriterBody;
+        template<class ResponseType>
+        friend void grpc::internal::UnaryRunHandlerHelper(
+            const internal::MethodHandler::HandlerParameter& param, ResponseType* rsp, Status& status
+        );
+        template<class ServiceType, class RequestType, class ResponseType, class BaseRequestType, class BaseResponseType>
+        friend class grpc::internal::RpcMethodHandler;
+        template<class ServiceType, class RequestType, class ResponseType>
+        friend class grpc::internal::ClientStreamingHandler;
+        template<class ServiceType, class RequestType, class ResponseType>
+        friend class grpc::internal::ServerStreamingHandler;
+        template<class Streamer, bool WriteNeeded>
+        friend class grpc::internal::TemplatedBidiStreamingHandler;
+        template<class RequestType, class ResponseType>
+        friend class grpc::internal::CallbackUnaryHandler;
+        template<class RequestType, class ResponseType>
+        friend class grpc::internal::CallbackClientStreamingHandler;
+        template<class RequestType, class ResponseType>
+        friend class grpc::internal::CallbackServerStreamingHandler;
+        template<class RequestType, class ResponseType>
+        friend class grpc::internal::CallbackBidiHandler;
+        template<grpc::StatusCode code>
+        friend class grpc::internal::ErrorMethodHandler;
+        template<class Base>
+        friend class grpc::internal::FinishOnlyReactor;
+        friend class grpc::ClientContext;
+        friend class grpc::GenericServerContext;
+        friend class grpc::GenericCallbackServerContext;
+        friend class grpc::experimental::OrcaServerInterceptor;
+
+        /// Prevent copying.
+        ServerContextBase(const ServerContextBase&);
+        ServerContextBase& operator=(const ServerContextBase&);
+
+        class CompletionOp;
+
+        void BeginCompletionOp(
+            grpc::internal::Call* call, std::function<void(bool)> callback, grpc::internal::ServerCallbackCall* callback_controller
+        );
+        /// Return the tag queued by BeginCompletionOp()
+        grpc::internal::CompletionQueueTag* GetCompletionOpTag();
+
+        void set_call(grpc_call* call)
+        {
+            call_.call = call;
+        }
+
+        void BindDeadlineAndMetadata(gpr_timespec deadline, grpc_metadata_array* arr);
+
+        uint32_t initial_metadata_flags() const
+        {
+            return 0;
+        }
+
+        grpc::experimental::ServerRpcInfo* set_server_rpc_info(
+            const char* method, grpc::internal::RpcMethod::RpcType type, const std::vector<std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>>& creators
+        )
+        {
+            if (!creators.empty())
+            {
+                rpc_info_ = new grpc::experimental::ServerRpcInfo(this, method, type);
+                rpc_info_->RegisterInterceptors(creators);
+            }
+            return rpc_info_;
+        }
+
+        void set_message_allocator_state(RpcAllocatorState* allocator_state)
+        {
+            message_allocator_state_ = allocator_state;
+        }
+
+        void MaybeMarkCancelledOnRead()
+        {
+            if (g_core_codegen_interface->grpc_call_failed_before_recv_message(
+                    call_.call
+                ))
+            {
+                marked_cancelled_.store(true, std::memory_order_release);
+            }
+        }
+
+        void CreateCallMetricRecorder();
+
+        struct CallWrapper
+        {
+            ~CallWrapper();
+
+            grpc_call* call = nullptr;
+        };
+
+        // NOTE: call_ must be the first data member of this object so that its
+        //       destructor is the last to be called, since its destructor may unref
+        //       the underlying core call which holds the arena that may be used to
+        //       hold this object.
+        CallWrapper call_;
+
+        CompletionOp* completion_op_ = nullptr;
+        bool has_notify_when_done_tag_ = false;
+        void* async_notify_when_done_tag_ = nullptr;
+        grpc::internal::CallbackWithSuccessTag completion_tag_;
+
+        gpr_timespec deadline_;
+        grpc::CompletionQueue* cq_ = nullptr;
+        bool sent_initial_metadata_ = false;
+        mutable std::shared_ptr<const grpc::AuthContext> auth_context_;
+        mutable grpc::internal::MetadataMap client_metadata_;
+        std::multimap<std::string, std::string> initial_metadata_;
+        std::multimap<std::string, std::string> trailing_metadata_;
+
+        bool compression_level_set_ = false;
+        grpc_compression_level compression_level_;
+        grpc_compression_algorithm compression_algorithm_;
+
+        grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage>
+            pending_ops_;
+        bool has_pending_ops_ = false;
+
+        grpc::experimental::ServerRpcInfo* rpc_info_ = nullptr;
+        RpcAllocatorState* message_allocator_state_ = nullptr;
+        ContextAllocator* context_allocator_ = nullptr;
+        experimental::CallMetricRecorder* call_metric_recorder_ = nullptr;
+
+        class Reactor : public grpc::ServerUnaryReactor
+        {
+        public:
+            void OnCancel() override
+            {
+            }
+            void OnDone() override
+            {
+            }
+            // Override InternalInlineable for this class since its reactions are
+            // trivial and thus do not need to be run from the executor (triggering a
+            // thread hop). This should only be used by internal reactors (thus the
+            // name) and not by user application code.
+            bool InternalInlineable() override
+            {
+                return true;
+            }
+        };
+
+        void SetupTestDefaultReactor(std::function<void(grpc::Status)> func)
+        {
+            // NOLINTNEXTLINE(modernize-make-unique)
+            test_unary_.reset(new TestServerCallbackUnary(this, std::move(func)));
+        }
+        bool test_status_set() const
+        {
+            return (test_unary_ != nullptr) && test_unary_->status_set();
+        }
+        grpc::Status test_status() const
+        {
+            return test_unary_->status();
+        }
+
+        class TestServerCallbackUnary : public grpc::ServerCallbackUnary
+        {
+        public:
+            TestServerCallbackUnary(ServerContextBase* ctx, std::function<void(grpc::Status)> func) :
+                reactor_(ctx->DefaultReactor()),
+                func_(std::move(func))
+            {
+                this->BindReactor(reactor_);
+            }
+            void Finish(grpc::Status s) override
+            {
+                status_ = s;
+                func_(std::move(s));
+                status_set_.store(true, std::memory_order_release);
+            }
+            void SendInitialMetadata() override
+            {
+            }
+
+            bool status_set() const
+            {
+                return status_set_.load(std::memory_order_acquire);
+            }
+            grpc::Status status() const
+            {
+                return status_;
+            }
+
+        private:
+            void CallOnDone() override
+            {
+            }
+            grpc::internal::ServerReactor* reactor() override
+            {
+                return reactor_;
+            }
+
+            grpc::ServerUnaryReactor* const reactor_;
+            std::atomic_bool status_set_{false};
+            grpc::Status status_;
+            const std::function<void(grpc::Status s)> func_;
+        };
+
+        typename std::aligned_storage<sizeof(Reactor), alignof(Reactor)>::type
+            default_reactor_;
+        std::atomic_bool default_reactor_used_{false};
+
+        std::atomic_bool marked_cancelled_{false};
+
+        std::unique_ptr<TestServerCallbackUnary> test_unary_;
+    };
+
+    /// A ServerContext or CallbackServerContext allows the code implementing a
+    /// service handler to:
+    ///
+    /// - Add custom initial and trailing metadata key-value pairs that will
+    ///   propagated to the client side.
+    /// - Control call settings such as compression and authentication.
+    /// - Access metadata coming from the client.
+    /// - Get performance metrics (ie, census).
+    ///
+    /// Context settings are only relevant to the call handler they are supplied to,
+    /// that is to say, they aren't sticky across multiple calls. Some of these
+    /// settings, such as the compression options, can be made persistent at server
+    /// construction time by specifying the appropriate \a ChannelArguments
+    /// to a \a grpc::ServerBuilder, via \a ServerBuilder::AddChannelArgument.
+    ///
+    /// \warning ServerContext instances should \em not be reused across rpcs.
+    class ServerContext : public ServerContextBase
+    {
+    public:
+        ServerContext()
+        {
+        }  // for async calls
+
+        using ServerContextBase::AddInitialMetadata;
+        using ServerContextBase::AddTrailingMetadata;
+        using ServerContextBase::auth_context;
+        using ServerContextBase::c_call;
+        using ServerContextBase::census_context;
+        using ServerContextBase::client_metadata;
+        using ServerContextBase::compression_algorithm;
+        using ServerContextBase::compression_level;
+        using ServerContextBase::compression_level_set;
+        using ServerContextBase::deadline;
+        using ServerContextBase::IsCancelled;
+        using ServerContextBase::peer;
+        using ServerContextBase::raw_deadline;
+        using ServerContextBase::set_compression_algorithm;
+        using ServerContextBase::set_compression_level;
+        using ServerContextBase::SetLoadReportingCosts;
+        using ServerContextBase::TryCancel;
+
+        // Sync/CQ-based Async ServerContext only
+        using ServerContextBase::AsyncNotifyWhenDone;
+
+    private:
+        // Constructor for internal use by server only
+        friend class grpc::Server;
+        ServerContext(gpr_timespec deadline, grpc_metadata_array* arr) :
+            ServerContextBase(deadline, arr)
+        {
+        }
+
+        // CallbackServerContext only
+        using ServerContextBase::DefaultReactor;
+        using ServerContextBase::GetRpcAllocatorState;
+
+        /// Prevent copying.
+        ServerContext(const ServerContext&) = delete;
+        ServerContext& operator=(const ServerContext&) = delete;
+    };
+
+    class CallbackServerContext : public ServerContextBase
+    {
+    public:
+        /// Public constructors are for direct use only by mocking tests. In practice,
+        /// these objects will be owned by the library.
+        CallbackServerContext()
+        {
+        }
+
+        using ServerContextBase::AddInitialMetadata;
+        using ServerContextBase::AddTrailingMetadata;
+        using ServerContextBase::auth_context;
+        using ServerContextBase::c_call;
+        using ServerContextBase::census_context;
+        using ServerContextBase::client_metadata;
+        using ServerContextBase::compression_algorithm;
+        using ServerContextBase::compression_level;
+        using ServerContextBase::compression_level_set;
+        using ServerContextBase::context_allocator;
+        using ServerContextBase::deadline;
+        using ServerContextBase::IsCancelled;
+        using ServerContextBase::peer;
+        using ServerContextBase::raw_deadline;
+        using ServerContextBase::set_compression_algorithm;
+        using ServerContextBase::set_compression_level;
+        using ServerContextBase::set_context_allocator;
+        using ServerContextBase::SetLoadReportingCosts;
+        using ServerContextBase::TryCancel;
+
+        // CallbackServerContext only
+        using ServerContextBase::DefaultReactor;
+        using ServerContextBase::GetRpcAllocatorState;
+
+    private:
+        // Sync/CQ-based Async ServerContext only
+        using ServerContextBase::AsyncNotifyWhenDone;
+
+        /// Prevent copying.
+        CallbackServerContext(const CallbackServerContext&) = delete;
+        CallbackServerContext& operator=(const CallbackServerContext&) = delete;
+    };
+
+    /// A CallbackServerContext allows users to use the contents of the
+    /// CallbackServerContext or GenericCallbackServerContext structure for the
+    /// callback API.
+    /// The library will invoke the allocator any time a new call is initiated.
+    /// and call the Release method after the server OnDone.
+    class ContextAllocator
+    {
+    public:
+        virtual ~ContextAllocator()
+        {
+        }
+
+        virtual CallbackServerContext* NewCallbackServerContext()
+        {
+            return nullptr;
+        }
+
+        virtual GenericCallbackServerContext* NewGenericCallbackServerContext()
+        {
+            return nullptr;
+        }
+
+        virtual void Release(CallbackServerContext*)
+        {
+        }
+
+        virtual void Release(GenericCallbackServerContext*)
+        {
+        }
+    };
 
 }  // namespace grpc
 
 static_assert(
     std::is_base_of<grpc::ServerContextBase, grpc::ServerContext>::value,
-    "improper base class");
-static_assert(std::is_base_of<grpc::ServerContextBase,
-                              grpc::CallbackServerContext>::value,
-              "improper base class");
-static_assert(sizeof(grpc::ServerContextBase) == sizeof(grpc::ServerContext),
-              "wrong size");
-static_assert(sizeof(grpc::ServerContextBase) ==
-                  sizeof(grpc::CallbackServerContext),
-              "wrong size");
+    "improper base class"
+);
+static_assert(std::is_base_of<grpc::ServerContextBase, grpc::CallbackServerContext>::value, "improper base class");
+static_assert(sizeof(grpc::ServerContextBase) == sizeof(grpc::ServerContext), "wrong size");
+static_assert(sizeof(grpc::ServerContextBase) == sizeof(grpc::CallbackServerContext), "wrong size");
 
 #endif  // GRPCPP_IMPL_CODEGEN_SERVER_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interceptor.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interceptor.h
index 3a8fd52..fb93177 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interceptor.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interceptor.h
@@ -28,114 +28,145 @@
 #include <grpcpp/impl/codegen/rpc_method.h>
 #include <grpcpp/impl/codegen/string_ref.h>
 
-namespace grpc {
-class ServerContextBase;
-namespace internal {
-class InterceptorBatchMethodsImpl;
-}
-
-namespace experimental {
-class ServerRpcInfo;
-
-// A factory interface for creation of server interceptors. A vector of
-// factories can be provided to ServerBuilder which will be used to create a new
-// vector of server interceptors per RPC. Server interceptor authors should
-// create a subclass of ServerInterceptorFactorInterface which creates objects
-// of their interceptors.
-class ServerInterceptorFactoryInterface {
- public:
-  virtual ~ServerInterceptorFactoryInterface() {}
-  // Returns a pointer to an Interceptor object on successful creation, nullptr
-  // otherwise. If nullptr is returned, this server interceptor factory is
-  // ignored for the purposes of that RPC.
-  virtual Interceptor* CreateServerInterceptor(ServerRpcInfo* info) = 0;
-};
-
-/// ServerRpcInfo represents the state of a particular RPC as it
-/// appears to an interceptor. It is created and owned by the library and
-/// passed to the CreateServerInterceptor method of the application's
-/// ServerInterceptorFactoryInterface implementation
-class ServerRpcInfo {
- public:
-  /// Type categorizes RPCs by unary or streaming type
-  enum class Type { UNARY, CLIENT_STREAMING, SERVER_STREAMING, BIDI_STREAMING };
-
-  ~ServerRpcInfo() {}
-
-  // Delete all copy and move constructors and assignments
-  ServerRpcInfo(const ServerRpcInfo&) = delete;
-  ServerRpcInfo& operator=(const ServerRpcInfo&) = delete;
-  ServerRpcInfo(ServerRpcInfo&&) = delete;
-  ServerRpcInfo& operator=(ServerRpcInfo&&) = delete;
-
-  // Getter methods
-
-  /// Return the fully-specified method name
-  const char* method() const { return method_; }
-
-  /// Return the type of the RPC (unary or a streaming flavor)
-  Type type() const { return type_; }
-
-  /// Return a pointer to the underlying ServerContext structure associated
-  /// with the RPC to support features that apply to it
-  ServerContextBase* server_context() { return ctx_; }
-
- private:
-  static_assert(Type::UNARY ==
-                    static_cast<Type>(internal::RpcMethod::NORMAL_RPC),
-                "violated expectation about Type enum");
-  static_assert(Type::CLIENT_STREAMING ==
-                    static_cast<Type>(internal::RpcMethod::CLIENT_STREAMING),
-                "violated expectation about Type enum");
-  static_assert(Type::SERVER_STREAMING ==
-                    static_cast<Type>(internal::RpcMethod::SERVER_STREAMING),
-                "violated expectation about Type enum");
-  static_assert(Type::BIDI_STREAMING ==
-                    static_cast<Type>(internal::RpcMethod::BIDI_STREAMING),
-                "violated expectation about Type enum");
-
-  ServerRpcInfo(ServerContextBase* ctx, const char* method,
-                internal::RpcMethod::RpcType type)
-      : ctx_(ctx), method_(method), type_(static_cast<Type>(type)) {}
-
-  // Runs interceptor at pos \a pos.
-  void RunInterceptor(
-      experimental::InterceptorBatchMethods* interceptor_methods, size_t pos) {
-    GPR_CODEGEN_ASSERT(pos < interceptors_.size());
-    interceptors_[pos]->Intercept(interceptor_methods);
-  }
-
-  void RegisterInterceptors(
-      const std::vector<
-          std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>&
-          creators) {
-    for (const auto& creator : creators) {
-      auto* interceptor = creator->CreateServerInterceptor(this);
-      if (interceptor != nullptr) {
-        interceptors_.push_back(
-            std::unique_ptr<experimental::Interceptor>(interceptor));
-      }
+namespace grpc
+{
+    class ServerContextBase;
+    namespace internal
+    {
+        class InterceptorBatchMethodsImpl;
     }
-  }
 
-  void Ref() { ref_.fetch_add(1, std::memory_order_relaxed); }
-  void Unref() {
-    if (GPR_UNLIKELY(ref_.fetch_sub(1, std::memory_order_acq_rel) == 1)) {
-      delete this;
-    }
-  }
-
-  ServerContextBase* ctx_ = nullptr;
-  const char* method_ = nullptr;
-  const Type type_;
-  std::atomic<intptr_t> ref_{1};
-  std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_;
-
-  friend class internal::InterceptorBatchMethodsImpl;
-  friend class grpc::ServerContextBase;
-};
-
-}  // namespace experimental
+    namespace experimental
+    {
+        class ServerRpcInfo;
+
+        // A factory interface for creation of server interceptors. A vector of
+        // factories can be provided to ServerBuilder which will be used to create a new
+        // vector of server interceptors per RPC. Server interceptor authors should
+        // create a subclass of ServerInterceptorFactorInterface which creates objects
+        // of their interceptors.
+        class ServerInterceptorFactoryInterface
+        {
+        public:
+            virtual ~ServerInterceptorFactoryInterface()
+            {
+            }
+            // Returns a pointer to an Interceptor object on successful creation, nullptr
+            // otherwise. If nullptr is returned, this server interceptor factory is
+            // ignored for the purposes of that RPC.
+            virtual Interceptor* CreateServerInterceptor(ServerRpcInfo* info) = 0;
+        };
+
+        /// ServerRpcInfo represents the state of a particular RPC as it
+        /// appears to an interceptor. It is created and owned by the library and
+        /// passed to the CreateServerInterceptor method of the application's
+        /// ServerInterceptorFactoryInterface implementation
+        class ServerRpcInfo
+        {
+        public:
+            /// Type categorizes RPCs by unary or streaming type
+            enum class Type
+            {
+                UNARY,
+                CLIENT_STREAMING,
+                SERVER_STREAMING,
+                BIDI_STREAMING
+            };
+
+            ~ServerRpcInfo()
+            {
+            }
+
+            // Delete all copy and move constructors and assignments
+            ServerRpcInfo(const ServerRpcInfo&) = delete;
+            ServerRpcInfo& operator=(const ServerRpcInfo&) = delete;
+            ServerRpcInfo(ServerRpcInfo&&) = delete;
+            ServerRpcInfo& operator=(ServerRpcInfo&&) = delete;
+
+            // Getter methods
+
+            /// Return the fully-specified method name
+            const char* method() const
+            {
+                return method_;
+            }
+
+            /// Return the type of the RPC (unary or a streaming flavor)
+            Type type() const
+            {
+                return type_;
+            }
+
+            /// Return a pointer to the underlying ServerContext structure associated
+            /// with the RPC to support features that apply to it
+            ServerContextBase* server_context()
+            {
+                return ctx_;
+            }
+
+        private:
+            static_assert(Type::UNARY == static_cast<Type>(internal::RpcMethod::NORMAL_RPC), "violated expectation about Type enum");
+            static_assert(Type::CLIENT_STREAMING == static_cast<Type>(internal::RpcMethod::CLIENT_STREAMING), "violated expectation about Type enum");
+            static_assert(Type::SERVER_STREAMING == static_cast<Type>(internal::RpcMethod::SERVER_STREAMING), "violated expectation about Type enum");
+            static_assert(Type::BIDI_STREAMING == static_cast<Type>(internal::RpcMethod::BIDI_STREAMING), "violated expectation about Type enum");
+
+            ServerRpcInfo(ServerContextBase* ctx, const char* method, internal::RpcMethod::RpcType type) :
+                ctx_(ctx),
+                method_(method),
+                type_(static_cast<Type>(type))
+            {
+            }
+
+            // Runs interceptor at pos \a pos.
+            void RunInterceptor(
+                experimental::InterceptorBatchMethods* interceptor_methods, size_t pos
+            )
+            {
+                GPR_CODEGEN_ASSERT(pos < interceptors_.size());
+                interceptors_[pos]->Intercept(interceptor_methods);
+            }
+
+            void RegisterInterceptors(
+                const std::vector<
+                    std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>&
+                    creators
+            )
+            {
+                for (const auto& creator : creators)
+                {
+                    auto* interceptor = creator->CreateServerInterceptor(this);
+                    if (interceptor != nullptr)
+                    {
+                        interceptors_.push_back(
+                            std::unique_ptr<experimental::Interceptor>(interceptor)
+                        );
+                    }
+                }
+            }
+
+            void Ref()
+            {
+                ref_.fetch_add(1, std::memory_order_relaxed);
+            }
+            void Unref()
+            {
+                if (GPR_UNLIKELY(ref_.fetch_sub(1, std::memory_order_acq_rel) == 1))
+                {
+                    delete this;
+                }
+            }
+
+            ServerContextBase* ctx_ = nullptr;
+            const char* method_ = nullptr;
+            const Type type_;
+            std::atomic<intptr_t> ref_{1};
+            std::vector<std::unique_ptr<experimental::Interceptor>> interceptors_;
+
+            friend class internal::InterceptorBatchMethodsImpl;
+            friend class grpc::ServerContextBase;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_SERVER_INTERCEPTOR_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interface.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interface.h
index 0deac82..4186a7f 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interface.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/server_interface.h
@@ -33,337 +33,324 @@
 #include <grpcpp/impl/codegen/rpc_service_method.h>
 #include <grpcpp/impl/codegen/server_context.h>
 
-namespace grpc {
-
-class AsyncGenericService;
-class Channel;
-class CompletionQueue;
-class GenericServerContext;
-class ServerCompletionQueue;
-class ServerCredentials;
-class Service;
-
-extern CoreCodegenInterface* g_core_codegen_interface;
-
-/// Models a gRPC server.
-///
-/// Servers are configured and started via \a grpc::ServerBuilder.
-namespace internal {
-class ServerAsyncStreamingInterface;
-}  // namespace internal
-
-class CallbackGenericService;
-
-namespace experimental {
-class ServerInterceptorFactoryInterface;
-}  // namespace experimental
-
-class ServerInterface : public internal::CallHook {
- public:
-  ~ServerInterface() override {}
-
-  /// \a Shutdown does the following things:
-  ///
-  /// 1. Shutdown the server: deactivate all listening ports, mark it in
-  ///    "shutdown mode" so that further call Request's or incoming RPC matches
-  ///    are no longer allowed. Also return all Request'ed-but-not-yet-active
-  ///    calls as failed (!ok). This refers to calls that have been requested
-  ///    at the server by the server-side library or application code but that
-  ///    have not yet been matched to incoming RPCs from the client. Note that
-  ///    this would even include default calls added automatically by the gRPC
-  ///    C++ API without the user's input (e.g., "Unimplemented RPC method")
-  ///
-  /// 2. Block until all rpc method handlers invoked automatically by the sync
-  ///    API finish.
-  ///
-  /// 3. If all pending calls complete (and all their operations are
-  ///    retrieved by Next) before \a deadline expires, this finishes
-  ///    gracefully. Otherwise, forcefully cancel all pending calls associated
-  ///    with the server after \a deadline expires. In the case of the sync API,
-  ///    if the RPC function for a streaming call has already been started and
-  ///    takes a week to complete, the RPC function won't be forcefully
-  ///    terminated (since that would leave state corrupt and incomplete) and
-  ///    the method handler will just keep running (which will prevent the
-  ///    server from completing the "join" operation that it needs to do at
-  ///    shutdown time).
-  ///
-  /// All completion queue associated with the server (for example, for async
-  /// serving) must be shutdown *after* this method has returned:
-  /// See \a ServerBuilder::AddCompletionQueue for details.
-  /// They must also be drained (by repeated Next) after being shutdown.
-  ///
-  /// \param deadline How long to wait until pending rpcs are forcefully
-  /// terminated.
-  template <class T>
-  void Shutdown(const T& deadline) {
-    ShutdownInternal(TimePoint<T>(deadline).raw_time());
-  }
-
-  /// Shutdown the server without a deadline and forced cancellation.
-  ///
-  /// All completion queue associated with the server (for example, for async
-  /// serving) must be shutdown *after* this method has returned:
-  /// See \a ServerBuilder::AddCompletionQueue for details.
-  void Shutdown() {
-    ShutdownInternal(
-        g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_MONOTONIC));
-  }
-
-  /// Block waiting for all work to complete.
-  ///
-  /// \warning The server must be either shutting down or some other thread must
-  /// call \a Shutdown for this function to ever return.
-  virtual void Wait() = 0;
-
- protected:
-  friend class grpc::Service;
-
-  /// Register a service. This call does not take ownership of the service.
-  /// The service must exist for the lifetime of the Server instance.
-  virtual bool RegisterService(const std::string* host, Service* service) = 0;
-
-  /// Register a generic service. This call does not take ownership of the
-  /// service. The service must exist for the lifetime of the Server instance.
-  virtual void RegisterAsyncGenericService(AsyncGenericService* service) = 0;
-
-  /// Register a callback generic service. This call does not take ownership of
-  /// the  service. The service must exist for the lifetime of the Server
-  /// instance. May not be abstract since this is a post-1.0 API addition.
-
-  virtual void RegisterCallbackGenericService(CallbackGenericService*
-                                              /*service*/) {}
-
-  /// Tries to bind \a server to the given \a addr.
-  ///
-  /// It can be invoked multiple times.
-  ///
-  /// \param addr The address to try to bind to the server (eg, localhost:1234,
-  /// 192.168.1.1:31416, [::1]:27182, etc.).
-  /// \params creds The credentials associated with the server.
-  ///
-  /// \return bound port number on success, 0 on failure.
-  ///
-  /// \warning It's an error to call this method on an already started server.
-  virtual int AddListeningPort(const std::string& addr,
-                               ServerCredentials* creds) = 0;
-
-  /// Start the server.
-  ///
-  /// \param cqs Completion queues for handling asynchronous services. The
-  /// caller is required to keep all completion queues live until the server is
-  /// destroyed.
-  /// \param num_cqs How many completion queues does \a cqs hold.
-  virtual void Start(grpc::ServerCompletionQueue** cqs, size_t num_cqs) = 0;
-
-  virtual void ShutdownInternal(gpr_timespec deadline) = 0;
-
-  virtual int max_receive_message_size() const = 0;
-
-  virtual grpc_server* server() = 0;
-
-  void PerformOpsOnCall(internal::CallOpSetInterface* ops,
-                        internal::Call* call) override = 0;
-
-  class BaseAsyncRequest : public internal::CompletionQueueTag {
-   public:
-    BaseAsyncRequest(ServerInterface* server, grpc::ServerContext* context,
-                     internal::ServerAsyncStreamingInterface* stream,
-                     grpc::CompletionQueue* call_cq,
-                     grpc::ServerCompletionQueue* notification_cq, void* tag,
-                     bool delete_on_finalize);
-    ~BaseAsyncRequest() override;
-
-    bool FinalizeResult(void** tag, bool* status) override;
-
-   private:
-    void ContinueFinalizeResultAfterInterception();
-
-   protected:
-    ServerInterface* const server_;
-    grpc::ServerContext* const context_;
-    internal::ServerAsyncStreamingInterface* const stream_;
-    grpc::CompletionQueue* const call_cq_;
-    grpc::ServerCompletionQueue* const notification_cq_;
-    void* const tag_;
-    const bool delete_on_finalize_;
-    grpc_call* call_;
-    internal::Call call_wrapper_;
-    internal::InterceptorBatchMethodsImpl interceptor_methods_;
-    bool done_intercepting_;
-  };
-
-  /// RegisteredAsyncRequest is not part of the C++ API
-  class RegisteredAsyncRequest : public BaseAsyncRequest {
-   public:
-    RegisteredAsyncRequest(ServerInterface* server,
-                           grpc::ServerContext* context,
-                           internal::ServerAsyncStreamingInterface* stream,
-                           grpc::CompletionQueue* call_cq,
-                           grpc::ServerCompletionQueue* notification_cq,
-                           void* tag, const char* name,
-                           internal::RpcMethod::RpcType type);
-
-    bool FinalizeResult(void** tag, bool* status) override {
-      /* If we are done intercepting, then there is nothing more for us to do */
-      if (done_intercepting_) {
-        return BaseAsyncRequest::FinalizeResult(tag, status);
-      }
-      call_wrapper_ = grpc::internal::Call(
-          call_, server_, call_cq_, server_->max_receive_message_size(),
-          context_->set_server_rpc_info(name_, type_,
-                                        *server_->interceptor_creators()));
-      return BaseAsyncRequest::FinalizeResult(tag, status);
-    }
-
-   protected:
-    void IssueRequest(void* registered_method, grpc_byte_buffer** payload,
-                      grpc::ServerCompletionQueue* notification_cq);
-    const char* name_;
-    const internal::RpcMethod::RpcType type_;
-  };
-
-  class NoPayloadAsyncRequest final : public RegisteredAsyncRequest {
-   public:
-    NoPayloadAsyncRequest(internal::RpcServiceMethod* registered_method,
-                          ServerInterface* server, grpc::ServerContext* context,
-                          internal::ServerAsyncStreamingInterface* stream,
-                          grpc::CompletionQueue* call_cq,
-                          grpc::ServerCompletionQueue* notification_cq,
-                          void* tag)
-        : RegisteredAsyncRequest(
-              server, context, stream, call_cq, notification_cq, tag,
-              registered_method->name(), registered_method->method_type()) {
-      IssueRequest(registered_method->server_tag(), nullptr, notification_cq);
-    }
-
-    // uses RegisteredAsyncRequest::FinalizeResult
-  };
-
-  template <class Message>
-  class PayloadAsyncRequest final : public RegisteredAsyncRequest {
-   public:
-    PayloadAsyncRequest(internal::RpcServiceMethod* registered_method,
-                        ServerInterface* server, grpc::ServerContext* context,
-                        internal::ServerAsyncStreamingInterface* stream,
-                        grpc::CompletionQueue* call_cq,
-                        grpc::ServerCompletionQueue* notification_cq, void* tag,
-                        Message* request)
-        : RegisteredAsyncRequest(
-              server, context, stream, call_cq, notification_cq, tag,
-              registered_method->name(), registered_method->method_type()),
-          registered_method_(registered_method),
-          request_(request) {
-      IssueRequest(registered_method->server_tag(), payload_.bbuf_ptr(),
-                   notification_cq);
-    }
-
-    ~PayloadAsyncRequest() override {
-      payload_.Release();  // We do not own the payload_
-    }
-
-    bool FinalizeResult(void** tag, bool* status) override {
-      /* If we are done intercepting, then there is nothing more for us to do */
-      if (done_intercepting_) {
-        return RegisteredAsyncRequest::FinalizeResult(tag, status);
-      }
-      if (*status) {
-        if (!payload_.Valid() || !SerializationTraits<Message>::Deserialize(
-                                      payload_.bbuf_ptr(), request_)
-                                      .ok()) {
-          // If deserialization fails, we cancel the call and instantiate
-          // a new instance of ourselves to request another call.  We then
-          // return false, which prevents the call from being returned to
-          // the application.
-          g_core_codegen_interface->grpc_call_cancel_with_status(
-              call_, GRPC_STATUS_INTERNAL, "Unable to parse request", nullptr);
-          g_core_codegen_interface->grpc_call_unref(call_);
-          new PayloadAsyncRequest(registered_method_, server_, context_,
-                                  stream_, call_cq_, notification_cq_, tag_,
-                                  request_);
-          delete this;
-          return false;
+namespace grpc
+{
+
+    class AsyncGenericService;
+    class Channel;
+    class CompletionQueue;
+    class GenericServerContext;
+    class ServerCompletionQueue;
+    class ServerCredentials;
+    class Service;
+
+    extern CoreCodegenInterface* g_core_codegen_interface;
+
+    /// Models a gRPC server.
+    ///
+    /// Servers are configured and started via \a grpc::ServerBuilder.
+    namespace internal
+    {
+        class ServerAsyncStreamingInterface;
+    }  // namespace internal
+
+    class CallbackGenericService;
+
+    namespace experimental
+    {
+        class ServerInterceptorFactoryInterface;
+    }  // namespace experimental
+
+    class ServerInterface : public internal::CallHook
+    {
+    public:
+        ~ServerInterface() override
+        {
         }
-      }
-      /* Set interception point for recv message */
-      interceptor_methods_.AddInterceptionHookPoint(
-          experimental::InterceptionHookPoints::POST_RECV_MESSAGE);
-      interceptor_methods_.SetRecvMessage(request_, nullptr);
-      return RegisteredAsyncRequest::FinalizeResult(tag, status);
-    }
-
-   private:
-    internal::RpcServiceMethod* const registered_method_;
-    Message* const request_;
-    ByteBuffer payload_;
-  };
-
-  class GenericAsyncRequest : public BaseAsyncRequest {
-   public:
-    GenericAsyncRequest(ServerInterface* server, GenericServerContext* context,
-                        internal::ServerAsyncStreamingInterface* stream,
-                        grpc::CompletionQueue* call_cq,
-                        grpc::ServerCompletionQueue* notification_cq, void* tag,
-                        bool delete_on_finalize);
-
-    bool FinalizeResult(void** tag, bool* status) override;
-
-   private:
-    grpc_call_details call_details_;
-  };
-
-  template <class Message>
-  void RequestAsyncCall(internal::RpcServiceMethod* method,
-                        grpc::ServerContext* context,
-                        internal::ServerAsyncStreamingInterface* stream,
-                        grpc::CompletionQueue* call_cq,
-                        grpc::ServerCompletionQueue* notification_cq, void* tag,
-                        Message* message) {
-    GPR_CODEGEN_ASSERT(method);
-    new PayloadAsyncRequest<Message>(method, this, context, stream, call_cq,
-                                     notification_cq, tag, message);
-  }
-
-  void RequestAsyncCall(internal::RpcServiceMethod* method,
-                        grpc::ServerContext* context,
-                        internal::ServerAsyncStreamingInterface* stream,
-                        grpc::CompletionQueue* call_cq,
-                        grpc::ServerCompletionQueue* notification_cq,
-                        void* tag) {
-    GPR_CODEGEN_ASSERT(method);
-    new NoPayloadAsyncRequest(method, this, context, stream, call_cq,
-                              notification_cq, tag);
-  }
-
-  void RequestAsyncGenericCall(GenericServerContext* context,
-                               internal::ServerAsyncStreamingInterface* stream,
-                               grpc::CompletionQueue* call_cq,
-                               grpc::ServerCompletionQueue* notification_cq,
-                               void* tag) {
-    new GenericAsyncRequest(this, context, stream, call_cq, notification_cq,
-                            tag, true);
-  }
-
- private:
-  // EXPERIMENTAL
-  // Getter method for the vector of interceptor factory objects.
-  // Returns a nullptr (rather than being pure) since this is a post-1.0 method
-  // and adding a new pure method to an interface would be a breaking change
-  // (even though this is private and non-API)
-  virtual std::vector<
-      std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>*
-  interceptor_creators() {
-    return nullptr;
-  }
-
-  // A method to get the callbackable completion queue associated with this
-  // server. If the return value is nullptr, this server doesn't support
-  // callback operations.
-  // TODO(vjpai): Consider a better default like using a global CQ
-  // Returns nullptr (rather than being pure) since this is a post-1.0 method
-  // and adding a new pure method to an interface would be a breaking change
-  // (even though this is private and non-API)
-  virtual grpc::CompletionQueue* CallbackCQ() { return nullptr; }
-};
+
+        /// \a Shutdown does the following things:
+        ///
+        /// 1. Shutdown the server: deactivate all listening ports, mark it in
+        ///    "shutdown mode" so that further call Request's or incoming RPC matches
+        ///    are no longer allowed. Also return all Request'ed-but-not-yet-active
+        ///    calls as failed (!ok). This refers to calls that have been requested
+        ///    at the server by the server-side library or application code but that
+        ///    have not yet been matched to incoming RPCs from the client. Note that
+        ///    this would even include default calls added automatically by the gRPC
+        ///    C++ API without the user's input (e.g., "Unimplemented RPC method")
+        ///
+        /// 2. Block until all rpc method handlers invoked automatically by the sync
+        ///    API finish.
+        ///
+        /// 3. If all pending calls complete (and all their operations are
+        ///    retrieved by Next) before \a deadline expires, this finishes
+        ///    gracefully. Otherwise, forcefully cancel all pending calls associated
+        ///    with the server after \a deadline expires. In the case of the sync API,
+        ///    if the RPC function for a streaming call has already been started and
+        ///    takes a week to complete, the RPC function won't be forcefully
+        ///    terminated (since that would leave state corrupt and incomplete) and
+        ///    the method handler will just keep running (which will prevent the
+        ///    server from completing the "join" operation that it needs to do at
+        ///    shutdown time).
+        ///
+        /// All completion queue associated with the server (for example, for async
+        /// serving) must be shutdown *after* this method has returned:
+        /// See \a ServerBuilder::AddCompletionQueue for details.
+        /// They must also be drained (by repeated Next) after being shutdown.
+        ///
+        /// \param deadline How long to wait until pending rpcs are forcefully
+        /// terminated.
+        template<class T>
+        void Shutdown(const T& deadline)
+        {
+            ShutdownInternal(TimePoint<T>(deadline).raw_time());
+        }
+
+        /// Shutdown the server without a deadline and forced cancellation.
+        ///
+        /// All completion queue associated with the server (for example, for async
+        /// serving) must be shutdown *after* this method has returned:
+        /// See \a ServerBuilder::AddCompletionQueue for details.
+        void Shutdown()
+        {
+            ShutdownInternal(
+                g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_MONOTONIC)
+            );
+        }
+
+        /// Block waiting for all work to complete.
+        ///
+        /// \warning The server must be either shutting down or some other thread must
+        /// call \a Shutdown for this function to ever return.
+        virtual void Wait() = 0;
+
+    protected:
+        friend class grpc::Service;
+
+        /// Register a service. This call does not take ownership of the service.
+        /// The service must exist for the lifetime of the Server instance.
+        virtual bool RegisterService(const std::string* host, Service* service) = 0;
+
+        /// Register a generic service. This call does not take ownership of the
+        /// service. The service must exist for the lifetime of the Server instance.
+        virtual void RegisterAsyncGenericService(AsyncGenericService* service) = 0;
+
+        /// Register a callback generic service. This call does not take ownership of
+        /// the  service. The service must exist for the lifetime of the Server
+        /// instance. May not be abstract since this is a post-1.0 API addition.
+
+        virtual void RegisterCallbackGenericService(CallbackGenericService*
+                                                    /*service*/)
+        {
+        }
+
+        /// Tries to bind \a server to the given \a addr.
+        ///
+        /// It can be invoked multiple times.
+        ///
+        /// \param addr The address to try to bind to the server (eg, localhost:1234,
+        /// 192.168.1.1:31416, [::1]:27182, etc.).
+        /// \params creds The credentials associated with the server.
+        ///
+        /// \return bound port number on success, 0 on failure.
+        ///
+        /// \warning It's an error to call this method on an already started server.
+        virtual int AddListeningPort(const std::string& addr, ServerCredentials* creds) = 0;
+
+        /// Start the server.
+        ///
+        /// \param cqs Completion queues for handling asynchronous services. The
+        /// caller is required to keep all completion queues live until the server is
+        /// destroyed.
+        /// \param num_cqs How many completion queues does \a cqs hold.
+        virtual void Start(grpc::ServerCompletionQueue** cqs, size_t num_cqs) = 0;
+
+        virtual void ShutdownInternal(gpr_timespec deadline) = 0;
+
+        virtual int max_receive_message_size() const = 0;
+
+        virtual grpc_server* server() = 0;
+
+        void PerformOpsOnCall(internal::CallOpSetInterface* ops, internal::Call* call) override = 0;
+
+        class BaseAsyncRequest : public internal::CompletionQueueTag
+        {
+        public:
+            BaseAsyncRequest(ServerInterface* server, grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag, bool delete_on_finalize);
+            ~BaseAsyncRequest() override;
+
+            bool FinalizeResult(void** tag, bool* status) override;
+
+        private:
+            void ContinueFinalizeResultAfterInterception();
+
+        protected:
+            ServerInterface* const server_;
+            grpc::ServerContext* const context_;
+            internal::ServerAsyncStreamingInterface* const stream_;
+            grpc::CompletionQueue* const call_cq_;
+            grpc::ServerCompletionQueue* const notification_cq_;
+            void* const tag_;
+            const bool delete_on_finalize_;
+            grpc_call* call_;
+            internal::Call call_wrapper_;
+            internal::InterceptorBatchMethodsImpl interceptor_methods_;
+            bool done_intercepting_;
+        };
+
+        /// RegisteredAsyncRequest is not part of the C++ API
+        class RegisteredAsyncRequest : public BaseAsyncRequest
+        {
+        public:
+            RegisteredAsyncRequest(ServerInterface* server, grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag, const char* name, internal::RpcMethod::RpcType type);
+
+            bool FinalizeResult(void** tag, bool* status) override
+            {
+                /* If we are done intercepting, then there is nothing more for us to do */
+                if (done_intercepting_)
+                {
+                    return BaseAsyncRequest::FinalizeResult(tag, status);
+                }
+                call_wrapper_ = grpc::internal::Call(
+                    call_, server_, call_cq_, server_->max_receive_message_size(), context_->set_server_rpc_info(name_, type_, *server_->interceptor_creators())
+                );
+                return BaseAsyncRequest::FinalizeResult(tag, status);
+            }
+
+        protected:
+            void IssueRequest(void* registered_method, grpc_byte_buffer** payload, grpc::ServerCompletionQueue* notification_cq);
+            const char* name_;
+            const internal::RpcMethod::RpcType type_;
+        };
+
+        class NoPayloadAsyncRequest final : public RegisteredAsyncRequest
+        {
+        public:
+            NoPayloadAsyncRequest(internal::RpcServiceMethod* registered_method, ServerInterface* server, grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag) :
+                RegisteredAsyncRequest(
+                    server, context, stream, call_cq, notification_cq, tag, registered_method->name(), registered_method->method_type()
+                )
+            {
+                IssueRequest(registered_method->server_tag(), nullptr, notification_cq);
+            }
+
+            // uses RegisteredAsyncRequest::FinalizeResult
+        };
+
+        template<class Message>
+        class PayloadAsyncRequest final : public RegisteredAsyncRequest
+        {
+        public:
+            PayloadAsyncRequest(internal::RpcServiceMethod* registered_method, ServerInterface* server, grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag, Message* request) :
+                RegisteredAsyncRequest(
+                    server, context, stream, call_cq, notification_cq, tag, registered_method->name(), registered_method->method_type()
+                ),
+                registered_method_(registered_method),
+                request_(request)
+            {
+                IssueRequest(registered_method->server_tag(), payload_.bbuf_ptr(), notification_cq);
+            }
+
+            ~PayloadAsyncRequest() override
+            {
+                payload_.Release();  // We do not own the payload_
+            }
+
+            bool FinalizeResult(void** tag, bool* status) override
+            {
+                /* If we are done intercepting, then there is nothing more for us to do */
+                if (done_intercepting_)
+                {
+                    return RegisteredAsyncRequest::FinalizeResult(tag, status);
+                }
+                if (*status)
+                {
+                    if (!payload_.Valid() || !SerializationTraits<Message>::Deserialize(
+                                                  payload_.bbuf_ptr(), request_
+                                             )
+                                                  .ok())
+                    {
+                        // If deserialization fails, we cancel the call and instantiate
+                        // a new instance of ourselves to request another call.  We then
+                        // return false, which prevents the call from being returned to
+                        // the application.
+                        g_core_codegen_interface->grpc_call_cancel_with_status(
+                            call_, GRPC_STATUS_INTERNAL, "Unable to parse request", nullptr
+                        );
+                        g_core_codegen_interface->grpc_call_unref(call_);
+                        new PayloadAsyncRequest(registered_method_, server_, context_, stream_, call_cq_, notification_cq_, tag_, request_);
+                        delete this;
+                        return false;
+                    }
+                }
+                /* Set interception point for recv message */
+                interceptor_methods_.AddInterceptionHookPoint(
+                    experimental::InterceptionHookPoints::POST_RECV_MESSAGE
+                );
+                interceptor_methods_.SetRecvMessage(request_, nullptr);
+                return RegisteredAsyncRequest::FinalizeResult(tag, status);
+            }
+
+        private:
+            internal::RpcServiceMethod* const registered_method_;
+            Message* const request_;
+            ByteBuffer payload_;
+        };
+
+        class GenericAsyncRequest : public BaseAsyncRequest
+        {
+        public:
+            GenericAsyncRequest(ServerInterface* server, GenericServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag, bool delete_on_finalize);
+
+            bool FinalizeResult(void** tag, bool* status) override;
+
+        private:
+            grpc_call_details call_details_;
+        };
+
+        template<class Message>
+        void RequestAsyncCall(internal::RpcServiceMethod* method, grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag, Message* message)
+        {
+            GPR_CODEGEN_ASSERT(method);
+            new PayloadAsyncRequest<Message>(method, this, context, stream, call_cq, notification_cq, tag, message);
+        }
+
+        void RequestAsyncCall(internal::RpcServiceMethod* method, grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag)
+        {
+            GPR_CODEGEN_ASSERT(method);
+            new NoPayloadAsyncRequest(method, this, context, stream, call_cq, notification_cq, tag);
+        }
+
+        void RequestAsyncGenericCall(GenericServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag)
+        {
+            new GenericAsyncRequest(this, context, stream, call_cq, notification_cq, tag, true);
+        }
+
+    private:
+        // EXPERIMENTAL
+        // Getter method for the vector of interceptor factory objects.
+        // Returns a nullptr (rather than being pure) since this is a post-1.0 method
+        // and adding a new pure method to an interface would be a breaking change
+        // (even though this is private and non-API)
+        virtual std::vector<
+            std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>*
+            interceptor_creators()
+        {
+            return nullptr;
+        }
+
+        // A method to get the callbackable completion queue associated with this
+        // server. If the return value is nullptr, this server doesn't support
+        // callback operations.
+        // TODO(vjpai): Consider a better default like using a global CQ
+        // Returns nullptr (rather than being pure) since this is a post-1.0 method
+        // and adding a new pure method to an interface would be a breaking change
+        // (even though this is private and non-API)
+        virtual grpc::CompletionQueue* CallbackCQ()
+        {
+            return nullptr;
+        }
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/service_type.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/service_type.h
index 88bcb4a..3c24f27 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/service_type.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/service_type.h
@@ -28,210 +28,234 @@
 #include <grpcpp/impl/codegen/server_interface.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-
-class CompletionQueue;
-class ServerContext;
-class ServerInterface;
-
-namespace internal {
-class Call;
-class ServerAsyncStreamingInterface {
- public:
-  virtual ~ServerAsyncStreamingInterface() {}
-
-  /// Request notification of the sending of initial metadata to the client.
-  /// Completion will be notified by \a tag on the associated completion
-  /// queue. This call is optional, but if it is used, it cannot be used
-  /// concurrently with or after the \a Finish method.
-  ///
-  /// \param[in] tag Tag identifying this request.
-  virtual void SendInitialMetadata(void* tag) = 0;
-
- private:
-  friend class grpc::ServerInterface;
-  virtual void BindCall(Call* call) = 0;
-};
-}  // namespace internal
-
-/// Desriptor of an RPC service and its various RPC methods
-class Service {
- public:
-  Service() : server_(nullptr) {}
-  virtual ~Service() {}
-
-  bool has_async_methods() const {
-    for (const auto& method : methods_) {
-      if (method && method->handler() == nullptr) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool has_synchronous_methods() const {
-    for (const auto& method : methods_) {
-      if (method &&
-          method->api_type() == internal::RpcServiceMethod::ApiType::SYNC) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool has_callback_methods() const {
-    for (const auto& method : methods_) {
-      if (method && (method->api_type() ==
-                         internal::RpcServiceMethod::ApiType::CALL_BACK ||
-                     method->api_type() ==
-                         internal::RpcServiceMethod::ApiType::RAW_CALL_BACK)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool has_generic_methods() const {
-    for (const auto& method : methods_) {
-      if (method == nullptr) {
-        return true;
-      }
-    }
-    return false;
-  }
-
- protected:
-  template <class Message>
-  void RequestAsyncUnary(int index, grpc::ServerContext* context,
-                         Message* request,
-                         internal::ServerAsyncStreamingInterface* stream,
-                         grpc::CompletionQueue* call_cq,
-                         grpc::ServerCompletionQueue* notification_cq,
-                         void* tag) {
-    // Typecast the index to size_t for indexing into a vector
-    // while preserving the API that existed before a compiler
-    // warning was first seen (grpc/grpc#11664)
-    size_t idx = static_cast<size_t>(index);
-    server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq,
-                              notification_cq, tag, request);
-  }
-  void RequestAsyncClientStreaming(
-      int index, grpc::ServerContext* context,
-      internal::ServerAsyncStreamingInterface* stream,
-      grpc::CompletionQueue* call_cq,
-      grpc::ServerCompletionQueue* notification_cq, void* tag) {
-    size_t idx = static_cast<size_t>(index);
-    server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq,
-                              notification_cq, tag);
-  }
-  template <class Message>
-  void RequestAsyncServerStreaming(
-      int index, grpc::ServerContext* context, Message* request,
-      internal::ServerAsyncStreamingInterface* stream,
-      grpc::CompletionQueue* call_cq,
-      grpc::ServerCompletionQueue* notification_cq, void* tag) {
-    size_t idx = static_cast<size_t>(index);
-    server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq,
-                              notification_cq, tag, request);
-  }
-  void RequestAsyncBidiStreaming(
-      int index, grpc::ServerContext* context,
-      internal::ServerAsyncStreamingInterface* stream,
-      grpc::CompletionQueue* call_cq,
-      grpc::ServerCompletionQueue* notification_cq, void* tag) {
-    size_t idx = static_cast<size_t>(index);
-    server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq,
-                              notification_cq, tag);
-  }
-
-  void AddMethod(internal::RpcServiceMethod* method) {
-    methods_.emplace_back(method);
-  }
-
-  void MarkMethodAsync(int index) {
-    // This does not have to be a hard error, however no one has approached us
-    // with a use case yet. Please file an issue if you believe you have one.
-    size_t idx = static_cast<size_t>(index);
-    GPR_CODEGEN_ASSERT(
-        methods_[idx].get() != nullptr &&
-        "Cannot mark the method as 'async' because it has already been "
-        "marked as 'generic'.");
-    methods_[idx]->SetServerApiType(internal::RpcServiceMethod::ApiType::ASYNC);
-  }
-
-  void MarkMethodRaw(int index) {
-    // This does not have to be a hard error, however no one has approached us
-    // with a use case yet. Please file an issue if you believe you have one.
-    size_t idx = static_cast<size_t>(index);
-    GPR_CODEGEN_ASSERT(methods_[idx].get() != nullptr &&
-                       "Cannot mark the method as 'raw' because it has already "
-                       "been marked as 'generic'.");
-    methods_[idx]->SetServerApiType(internal::RpcServiceMethod::ApiType::RAW);
-  }
-
-  void MarkMethodGeneric(int index) {
-    // This does not have to be a hard error, however no one has approached us
-    // with a use case yet. Please file an issue if you believe you have one.
-    size_t idx = static_cast<size_t>(index);
-    GPR_CODEGEN_ASSERT(
-        methods_[idx]->handler() != nullptr &&
-        "Cannot mark the method as 'generic' because it has already been "
-        "marked as 'async' or 'raw'.");
-    methods_[idx].reset();
-  }
-
-  void MarkMethodStreamed(int index, internal::MethodHandler* streamed_method) {
-    // This does not have to be a hard error, however no one has approached us
-    // with a use case yet. Please file an issue if you believe you have one.
-    size_t idx = static_cast<size_t>(index);
-    GPR_CODEGEN_ASSERT(methods_[idx] && methods_[idx]->handler() &&
-                       "Cannot mark an async or generic method Streamed");
-    methods_[idx]->SetHandler(streamed_method);
-
-    // From the server's point of view, streamed unary is a special
-    // case of BIDI_STREAMING that has 1 read and 1 write, in that order,
-    // and split server-side streaming is BIDI_STREAMING with 1 read and
-    // any number of writes, in that order.
-    methods_[idx]->SetMethodType(internal::RpcMethod::BIDI_STREAMING);
-  }
-
-  void MarkMethodCallback(int index, internal::MethodHandler* handler) {
-    // This does not have to be a hard error, however no one has approached us
-    // with a use case yet. Please file an issue if you believe you have one.
-    size_t idx = static_cast<size_t>(index);
-    GPR_CODEGEN_ASSERT(
-        methods_[idx].get() != nullptr &&
-        "Cannot mark the method as 'callback' because it has already been "
-        "marked as 'generic'.");
-    methods_[idx]->SetHandler(handler);
-    methods_[idx]->SetServerApiType(
-        internal::RpcServiceMethod::ApiType::CALL_BACK);
-  }
-
-  void MarkMethodRawCallback(int index, internal::MethodHandler* handler) {
-    // This does not have to be a hard error, however no one has approached us
-    // with a use case yet. Please file an issue if you believe you have one.
-    size_t idx = static_cast<size_t>(index);
-    GPR_CODEGEN_ASSERT(
-        methods_[idx].get() != nullptr &&
-        "Cannot mark the method as 'raw callback' because it has already "
-        "been marked as 'generic'.");
-    methods_[idx]->SetHandler(handler);
-    methods_[idx]->SetServerApiType(
-        internal::RpcServiceMethod::ApiType::RAW_CALL_BACK);
-  }
-
-  internal::MethodHandler* GetHandler(int index) {
-    size_t idx = static_cast<size_t>(index);
-    return methods_[idx]->handler();
-  }
-
- private:
-  friend class Server;
-  friend class ServerInterface;
-  ServerInterface* server_;
-  std::vector<std::unique_ptr<internal::RpcServiceMethod>> methods_;
-};
+namespace grpc
+{
+
+    class CompletionQueue;
+    class ServerContext;
+    class ServerInterface;
+
+    namespace internal
+    {
+        class Call;
+        class ServerAsyncStreamingInterface
+        {
+        public:
+            virtual ~ServerAsyncStreamingInterface()
+            {
+            }
+
+            /// Request notification of the sending of initial metadata to the client.
+            /// Completion will be notified by \a tag on the associated completion
+            /// queue. This call is optional, but if it is used, it cannot be used
+            /// concurrently with or after the \a Finish method.
+            ///
+            /// \param[in] tag Tag identifying this request.
+            virtual void SendInitialMetadata(void* tag) = 0;
+
+        private:
+            friend class grpc::ServerInterface;
+            virtual void BindCall(Call* call) = 0;
+        };
+    }  // namespace internal
+
+    /// Desriptor of an RPC service and its various RPC methods
+    class Service
+    {
+    public:
+        Service() :
+            server_(nullptr)
+        {
+        }
+        virtual ~Service()
+        {
+        }
+
+        bool has_async_methods() const
+        {
+            for (const auto& method : methods_)
+            {
+                if (method && method->handler() == nullptr)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        bool has_synchronous_methods() const
+        {
+            for (const auto& method : methods_)
+            {
+                if (method &&
+                    method->api_type() == internal::RpcServiceMethod::ApiType::SYNC)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        bool has_callback_methods() const
+        {
+            for (const auto& method : methods_)
+            {
+                if (method && (method->api_type() ==
+                                   internal::RpcServiceMethod::ApiType::CALL_BACK ||
+                               method->api_type() ==
+                                   internal::RpcServiceMethod::ApiType::RAW_CALL_BACK))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        bool has_generic_methods() const
+        {
+            for (const auto& method : methods_)
+            {
+                if (method == nullptr)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+    protected:
+        template<class Message>
+        void RequestAsyncUnary(int index, grpc::ServerContext* context, Message* request, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag)
+        {
+            // Typecast the index to size_t for indexing into a vector
+            // while preserving the API that existed before a compiler
+            // warning was first seen (grpc/grpc#11664)
+            size_t idx = static_cast<size_t>(index);
+            server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq, notification_cq, tag, request);
+        }
+        void RequestAsyncClientStreaming(
+            int index, grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag
+        )
+        {
+            size_t idx = static_cast<size_t>(index);
+            server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq, notification_cq, tag);
+        }
+        template<class Message>
+        void RequestAsyncServerStreaming(
+            int index, grpc::ServerContext* context, Message* request, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag
+        )
+        {
+            size_t idx = static_cast<size_t>(index);
+            server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq, notification_cq, tag, request);
+        }
+        void RequestAsyncBidiStreaming(
+            int index, grpc::ServerContext* context, internal::ServerAsyncStreamingInterface* stream, grpc::CompletionQueue* call_cq, grpc::ServerCompletionQueue* notification_cq, void* tag
+        )
+        {
+            size_t idx = static_cast<size_t>(index);
+            server_->RequestAsyncCall(methods_[idx].get(), context, stream, call_cq, notification_cq, tag);
+        }
+
+        void AddMethod(internal::RpcServiceMethod* method)
+        {
+            methods_.emplace_back(method);
+        }
+
+        void MarkMethodAsync(int index)
+        {
+            // This does not have to be a hard error, however no one has approached us
+            // with a use case yet. Please file an issue if you believe you have one.
+            size_t idx = static_cast<size_t>(index);
+            GPR_CODEGEN_ASSERT(
+                methods_[idx].get() != nullptr &&
+                "Cannot mark the method as 'async' because it has already been "
+                "marked as 'generic'."
+            );
+            methods_[idx]->SetServerApiType(internal::RpcServiceMethod::ApiType::ASYNC);
+        }
+
+        void MarkMethodRaw(int index)
+        {
+            // This does not have to be a hard error, however no one has approached us
+            // with a use case yet. Please file an issue if you believe you have one.
+            size_t idx = static_cast<size_t>(index);
+            GPR_CODEGEN_ASSERT(methods_[idx].get() != nullptr && "Cannot mark the method as 'raw' because it has already "
+                                                                 "been marked as 'generic'.");
+            methods_[idx]->SetServerApiType(internal::RpcServiceMethod::ApiType::RAW);
+        }
+
+        void MarkMethodGeneric(int index)
+        {
+            // This does not have to be a hard error, however no one has approached us
+            // with a use case yet. Please file an issue if you believe you have one.
+            size_t idx = static_cast<size_t>(index);
+            GPR_CODEGEN_ASSERT(
+                methods_[idx]->handler() != nullptr &&
+                "Cannot mark the method as 'generic' because it has already been "
+                "marked as 'async' or 'raw'."
+            );
+            methods_[idx].reset();
+        }
+
+        void MarkMethodStreamed(int index, internal::MethodHandler* streamed_method)
+        {
+            // This does not have to be a hard error, however no one has approached us
+            // with a use case yet. Please file an issue if you believe you have one.
+            size_t idx = static_cast<size_t>(index);
+            GPR_CODEGEN_ASSERT(methods_[idx] && methods_[idx]->handler() && "Cannot mark an async or generic method Streamed");
+            methods_[idx]->SetHandler(streamed_method);
+
+            // From the server's point of view, streamed unary is a special
+            // case of BIDI_STREAMING that has 1 read and 1 write, in that order,
+            // and split server-side streaming is BIDI_STREAMING with 1 read and
+            // any number of writes, in that order.
+            methods_[idx]->SetMethodType(internal::RpcMethod::BIDI_STREAMING);
+        }
+
+        void MarkMethodCallback(int index, internal::MethodHandler* handler)
+        {
+            // This does not have to be a hard error, however no one has approached us
+            // with a use case yet. Please file an issue if you believe you have one.
+            size_t idx = static_cast<size_t>(index);
+            GPR_CODEGEN_ASSERT(
+                methods_[idx].get() != nullptr &&
+                "Cannot mark the method as 'callback' because it has already been "
+                "marked as 'generic'."
+            );
+            methods_[idx]->SetHandler(handler);
+            methods_[idx]->SetServerApiType(
+                internal::RpcServiceMethod::ApiType::CALL_BACK
+            );
+        }
+
+        void MarkMethodRawCallback(int index, internal::MethodHandler* handler)
+        {
+            // This does not have to be a hard error, however no one has approached us
+            // with a use case yet. Please file an issue if you believe you have one.
+            size_t idx = static_cast<size_t>(index);
+            GPR_CODEGEN_ASSERT(
+                methods_[idx].get() != nullptr &&
+                "Cannot mark the method as 'raw callback' because it has already "
+                "been marked as 'generic'."
+            );
+            methods_[idx]->SetHandler(handler);
+            methods_[idx]->SetServerApiType(
+                internal::RpcServiceMethod::ApiType::RAW_CALL_BACK
+            );
+        }
+
+        internal::MethodHandler* GetHandler(int index)
+        {
+            size_t idx = static_cast<size_t>(index);
+            return methods_[idx]->handler();
+        }
+
+    private:
+        friend class Server;
+        friend class ServerInterface;
+        ServerInterface* server_;
+        std::vector<std::unique_ptr<internal::RpcServiceMethod>> methods_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/slice.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/slice.h
index 392986a..548fe2a 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/slice.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/slice.h
@@ -26,130 +26,186 @@
 #include <grpcpp/impl/codegen/core_codegen_interface.h>
 #include <grpcpp/impl/codegen/string_ref.h>
 
-namespace grpc {
-
-/// A wrapper around \a grpc_slice.
-///
-/// A slice represents a contiguous reference counted array of bytes.
-/// It is cheap to take references to a slice, and it is cheap to create a
-/// slice pointing to a subset of another slice.
-class Slice final {
- public:
-  /// Construct an empty slice.
-  Slice() : slice_(g_core_codegen_interface->grpc_empty_slice()) {}
-  /// Destructor - drops one reference.
-  ~Slice() { g_core_codegen_interface->grpc_slice_unref(slice_); }
-
-  enum AddRef { ADD_REF };
-  /// Construct a slice from \a slice, adding a reference.
-  Slice(grpc_slice slice, AddRef)
-      : slice_(g_core_codegen_interface->grpc_slice_ref(slice)) {}
-
-  enum StealRef { STEAL_REF };
-  /// Construct a slice from \a slice, stealing a reference.
-  Slice(grpc_slice slice, StealRef) : slice_(slice) {}
-
-  /// Allocate a slice of specified size
-  explicit Slice(size_t len)
-      : slice_(g_core_codegen_interface->grpc_slice_malloc(len)) {}
-
-  /// Construct a slice from a copied buffer
-  Slice(const void* buf, size_t len)
-      : slice_(g_core_codegen_interface->grpc_slice_from_copied_buffer(
-            reinterpret_cast<const char*>(buf), len)) {}
-
-  /// Construct a slice from a copied string
-  /* NOLINTNEXTLINE(google-explicit-constructor) */
-  Slice(const std::string& str)
-      : slice_(g_core_codegen_interface->grpc_slice_from_copied_buffer(
-            str.c_str(), str.length())) {}
-
-  enum StaticSlice { STATIC_SLICE };
-
-  /// Construct a slice from a static buffer
-  Slice(const void* buf, size_t len, StaticSlice)
-      : slice_(g_core_codegen_interface->grpc_slice_from_static_buffer(
-            reinterpret_cast<const char*>(buf), len)) {}
-
-  /// Copy constructor, adds a reference.
-  Slice(const Slice& other)
-      : slice_(g_core_codegen_interface->grpc_slice_ref(other.slice_)) {}
-
-  /// Move constructor, steals a reference.
-  Slice(Slice&& other) noexcept : slice_(other.slice_) {
-    other.slice_ = g_core_codegen_interface->grpc_empty_slice();
-  }
-
-  /// Assignment, reference count is unchanged.
-  Slice& operator=(Slice other) {
-    std::swap(slice_, other.slice_);
-    return *this;
-  }
-
-  /// Create a slice pointing at some data. Calls malloc to allocate a refcount
-  /// for the object, and arranges that destroy will be called with the
-  /// user data pointer passed in at destruction. Can be the same as buf or
-  /// different (e.g., if data is part of a larger structure that must be
-  /// destroyed when the data is no longer needed)
-  Slice(void* buf, size_t len, void (*destroy)(void*), void* user_data)
-      : slice_(g_core_codegen_interface->grpc_slice_new_with_user_data(
-            buf, len, destroy, user_data)) {}
-
-  /// Specialization of above for common case where buf == user_data
-  Slice(void* buf, size_t len, void (*destroy)(void*))
-      : Slice(buf, len, destroy, buf) {}
-
-  /// Similar to the above but has a destroy that also takes slice length
-  Slice(void* buf, size_t len, void (*destroy)(void*, size_t))
-      : slice_(g_core_codegen_interface->grpc_slice_new_with_len(buf, len,
-                                                                 destroy)) {}
-
-  /// Byte size.
-  size_t size() const { return GRPC_SLICE_LENGTH(slice_); }
-
-  /// Raw pointer to the beginning (first element) of the slice.
-  const uint8_t* begin() const { return GRPC_SLICE_START_PTR(slice_); }
-
-  /// Raw pointer to the end (one byte \em past the last element) of the slice.
-  const uint8_t* end() const { return GRPC_SLICE_END_PTR(slice_); }
-
-  /// Returns a substring of the `slice` as another slice.
-  Slice sub(size_t begin, size_t end) const {
-    return Slice(g_core_codegen_interface->grpc_slice_sub(slice_, begin, end),
-                 STEAL_REF);
-  }
-
-  /// Raw C slice. Caller needs to call grpc_slice_unref when done.
-  grpc_slice c_slice() const {
-    return g_core_codegen_interface->grpc_slice_ref(slice_);
-  }
-
- private:
-  friend class ByteBuffer;
-
-  grpc_slice slice_;
-};
-
-inline grpc::string_ref StringRefFromSlice(const grpc_slice* slice) {
-  return grpc::string_ref(
-      reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(*slice)),
-      GRPC_SLICE_LENGTH(*slice));
-}
-
-inline std::string StringFromCopiedSlice(grpc_slice slice) {
-  return std::string(reinterpret_cast<char*>(GRPC_SLICE_START_PTR(slice)),
-                     GRPC_SLICE_LENGTH(slice));
-}
-
-inline grpc_slice SliceReferencingString(const std::string& str) {
-  return g_core_codegen_interface->grpc_slice_from_static_buffer(str.data(),
-                                                                 str.length());
-}
-
-inline grpc_slice SliceFromCopiedString(const std::string& str) {
-  return g_core_codegen_interface->grpc_slice_from_copied_buffer(str.data(),
-                                                                 str.length());
-}
+namespace grpc
+{
+
+    /// A wrapper around \a grpc_slice.
+    ///
+    /// A slice represents a contiguous reference counted array of bytes.
+    /// It is cheap to take references to a slice, and it is cheap to create a
+    /// slice pointing to a subset of another slice.
+    class Slice final
+    {
+    public:
+        /// Construct an empty slice.
+        Slice() :
+            slice_(g_core_codegen_interface->grpc_empty_slice())
+        {
+        }
+        /// Destructor - drops one reference.
+        ~Slice()
+        {
+            g_core_codegen_interface->grpc_slice_unref(slice_);
+        }
+
+        enum AddRef
+        {
+            ADD_REF
+        };
+        /// Construct a slice from \a slice, adding a reference.
+        Slice(grpc_slice slice, AddRef) :
+            slice_(g_core_codegen_interface->grpc_slice_ref(slice))
+        {
+        }
+
+        enum StealRef
+        {
+            STEAL_REF
+        };
+        /// Construct a slice from \a slice, stealing a reference.
+        Slice(grpc_slice slice, StealRef) :
+            slice_(slice)
+        {
+        }
+
+        /// Allocate a slice of specified size
+        explicit Slice(size_t len) :
+            slice_(g_core_codegen_interface->grpc_slice_malloc(len))
+        {
+        }
+
+        /// Construct a slice from a copied buffer
+        Slice(const void* buf, size_t len) :
+            slice_(g_core_codegen_interface->grpc_slice_from_copied_buffer(
+                reinterpret_cast<const char*>(buf), len
+            ))
+        {
+        }
+
+        /// Construct a slice from a copied string
+        /* NOLINTNEXTLINE(google-explicit-constructor) */
+        Slice(const std::string& str) :
+            slice_(g_core_codegen_interface->grpc_slice_from_copied_buffer(
+                str.c_str(), str.length()
+            ))
+        {
+        }
+
+        enum StaticSlice
+        {
+            STATIC_SLICE
+        };
+
+        /// Construct a slice from a static buffer
+        Slice(const void* buf, size_t len, StaticSlice) :
+            slice_(g_core_codegen_interface->grpc_slice_from_static_buffer(
+                reinterpret_cast<const char*>(buf), len
+            ))
+        {
+        }
+
+        /// Copy constructor, adds a reference.
+        Slice(const Slice& other) :
+            slice_(g_core_codegen_interface->grpc_slice_ref(other.slice_))
+        {
+        }
+
+        /// Move constructor, steals a reference.
+        Slice(Slice&& other) noexcept :
+            slice_(other.slice_)
+        {
+            other.slice_ = g_core_codegen_interface->grpc_empty_slice();
+        }
+
+        /// Assignment, reference count is unchanged.
+        Slice& operator=(Slice other)
+        {
+            std::swap(slice_, other.slice_);
+            return *this;
+        }
+
+        /// Create a slice pointing at some data. Calls malloc to allocate a refcount
+        /// for the object, and arranges that destroy will be called with the
+        /// user data pointer passed in at destruction. Can be the same as buf or
+        /// different (e.g., if data is part of a larger structure that must be
+        /// destroyed when the data is no longer needed)
+        Slice(void* buf, size_t len, void (*destroy)(void*), void* user_data) :
+            slice_(g_core_codegen_interface->grpc_slice_new_with_user_data(
+                buf, len, destroy, user_data
+            ))
+        {
+        }
+
+        /// Specialization of above for common case where buf == user_data
+        Slice(void* buf, size_t len, void (*destroy)(void*)) :
+            Slice(buf, len, destroy, buf)
+        {
+        }
+
+        /// Similar to the above but has a destroy that also takes slice length
+        Slice(void* buf, size_t len, void (*destroy)(void*, size_t)) :
+            slice_(g_core_codegen_interface->grpc_slice_new_with_len(buf, len, destroy))
+        {
+        }
+
+        /// Byte size.
+        size_t size() const
+        {
+            return GRPC_SLICE_LENGTH(slice_);
+        }
+
+        /// Raw pointer to the beginning (first element) of the slice.
+        const uint8_t* begin() const
+        {
+            return GRPC_SLICE_START_PTR(slice_);
+        }
+
+        /// Raw pointer to the end (one byte \em past the last element) of the slice.
+        const uint8_t* end() const
+        {
+            return GRPC_SLICE_END_PTR(slice_);
+        }
+
+        /// Returns a substring of the `slice` as another slice.
+        Slice sub(size_t begin, size_t end) const
+        {
+            return Slice(g_core_codegen_interface->grpc_slice_sub(slice_, begin, end), STEAL_REF);
+        }
+
+        /// Raw C slice. Caller needs to call grpc_slice_unref when done.
+        grpc_slice c_slice() const
+        {
+            return g_core_codegen_interface->grpc_slice_ref(slice_);
+        }
+
+    private:
+        friend class ByteBuffer;
+
+        grpc_slice slice_;
+    };
+
+    inline grpc::string_ref StringRefFromSlice(const grpc_slice* slice)
+    {
+        return grpc::string_ref(
+            reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(*slice)),
+            GRPC_SLICE_LENGTH(*slice)
+        );
+    }
+
+    inline std::string StringFromCopiedSlice(grpc_slice slice)
+    {
+        return std::string(reinterpret_cast<char*>(GRPC_SLICE_START_PTR(slice)), GRPC_SLICE_LENGTH(slice));
+    }
+
+    inline grpc_slice SliceReferencingString(const std::string& str)
+    {
+        return g_core_codegen_interface->grpc_slice_from_static_buffer(str.data(), str.length());
+    }
+
+    inline grpc_slice SliceFromCopiedString(const std::string& str)
+    {
+        return g_core_codegen_interface->grpc_slice_from_copied_buffer(str.data(), str.length());
+    }
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status.h
index cc8d3cd..e44e0d6 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status.h
@@ -27,114 +27,121 @@
 #include <grpcpp/impl/codegen/config.h>
 #include <grpcpp/impl/codegen/status_code_enum.h>
 
-namespace grpc {
+namespace grpc
+{
 
-/// Did it work? If it didn't, why?
-///
-/// See \a grpc::StatusCode for details on the available code and their meaning.
-class GRPC_MUST_USE_RESULT_WHEN_USE_STRICT_WARNING Status {
- public:
-  /// Construct an OK instance.
-  Status() : code_(StatusCode::OK) {
-    // Static assertions to make sure that the C++ API value correctly
-    // maps to the core surface API value
-    static_assert(StatusCode::OK == static_cast<StatusCode>(GRPC_STATUS_OK),
-                  "Mismatched status code");
-    static_assert(
-        StatusCode::CANCELLED == static_cast<StatusCode>(GRPC_STATUS_CANCELLED),
-        "Mismatched status code");
-    static_assert(
-        StatusCode::UNKNOWN == static_cast<StatusCode>(GRPC_STATUS_UNKNOWN),
-        "Mismatched status code");
-    static_assert(StatusCode::INVALID_ARGUMENT ==
-                      static_cast<StatusCode>(GRPC_STATUS_INVALID_ARGUMENT),
-                  "Mismatched status code");
-    static_assert(StatusCode::DEADLINE_EXCEEDED ==
-                      static_cast<StatusCode>(GRPC_STATUS_DEADLINE_EXCEEDED),
-                  "Mismatched status code");
-    static_assert(
-        StatusCode::NOT_FOUND == static_cast<StatusCode>(GRPC_STATUS_NOT_FOUND),
-        "Mismatched status code");
-    static_assert(StatusCode::ALREADY_EXISTS ==
-                      static_cast<StatusCode>(GRPC_STATUS_ALREADY_EXISTS),
-                  "Mismatched status code");
-    static_assert(StatusCode::PERMISSION_DENIED ==
-                      static_cast<StatusCode>(GRPC_STATUS_PERMISSION_DENIED),
-                  "Mismatched status code");
-    static_assert(StatusCode::UNAUTHENTICATED ==
-                      static_cast<StatusCode>(GRPC_STATUS_UNAUTHENTICATED),
-                  "Mismatched status code");
-    static_assert(StatusCode::RESOURCE_EXHAUSTED ==
-                      static_cast<StatusCode>(GRPC_STATUS_RESOURCE_EXHAUSTED),
-                  "Mismatched status code");
-    static_assert(StatusCode::FAILED_PRECONDITION ==
-                      static_cast<StatusCode>(GRPC_STATUS_FAILED_PRECONDITION),
-                  "Mismatched status code");
-    static_assert(
-        StatusCode::ABORTED == static_cast<StatusCode>(GRPC_STATUS_ABORTED),
-        "Mismatched status code");
-    static_assert(StatusCode::OUT_OF_RANGE ==
-                      static_cast<StatusCode>(GRPC_STATUS_OUT_OF_RANGE),
-                  "Mismatched status code");
-    static_assert(StatusCode::UNIMPLEMENTED ==
-                      static_cast<StatusCode>(GRPC_STATUS_UNIMPLEMENTED),
-                  "Mismatched status code");
-    static_assert(
-        StatusCode::INTERNAL == static_cast<StatusCode>(GRPC_STATUS_INTERNAL),
-        "Mismatched status code");
-    static_assert(StatusCode::UNAVAILABLE ==
-                      static_cast<StatusCode>(GRPC_STATUS_UNAVAILABLE),
-                  "Mismatched status code");
-    static_assert(
-        StatusCode::DATA_LOSS == static_cast<StatusCode>(GRPC_STATUS_DATA_LOSS),
-        "Mismatched status code");
-  }
+    /// Did it work? If it didn't, why?
+    ///
+    /// See \a grpc::StatusCode for details on the available code and their meaning.
+    class GRPC_MUST_USE_RESULT_WHEN_USE_STRICT_WARNING Status
+    {
+    public:
+        /// Construct an OK instance.
+        Status() :
+            code_(StatusCode::OK)
+        {
+            // Static assertions to make sure that the C++ API value correctly
+            // maps to the core surface API value
+            static_assert(StatusCode::OK == static_cast<StatusCode>(GRPC_STATUS_OK), "Mismatched status code");
+            static_assert(
+                StatusCode::CANCELLED == static_cast<StatusCode>(GRPC_STATUS_CANCELLED),
+                "Mismatched status code"
+            );
+            static_assert(
+                StatusCode::UNKNOWN == static_cast<StatusCode>(GRPC_STATUS_UNKNOWN),
+                "Mismatched status code"
+            );
+            static_assert(StatusCode::INVALID_ARGUMENT == static_cast<StatusCode>(GRPC_STATUS_INVALID_ARGUMENT), "Mismatched status code");
+            static_assert(StatusCode::DEADLINE_EXCEEDED == static_cast<StatusCode>(GRPC_STATUS_DEADLINE_EXCEEDED), "Mismatched status code");
+            static_assert(
+                StatusCode::NOT_FOUND == static_cast<StatusCode>(GRPC_STATUS_NOT_FOUND),
+                "Mismatched status code"
+            );
+            static_assert(StatusCode::ALREADY_EXISTS == static_cast<StatusCode>(GRPC_STATUS_ALREADY_EXISTS), "Mismatched status code");
+            static_assert(StatusCode::PERMISSION_DENIED == static_cast<StatusCode>(GRPC_STATUS_PERMISSION_DENIED), "Mismatched status code");
+            static_assert(StatusCode::UNAUTHENTICATED == static_cast<StatusCode>(GRPC_STATUS_UNAUTHENTICATED), "Mismatched status code");
+            static_assert(StatusCode::RESOURCE_EXHAUSTED == static_cast<StatusCode>(GRPC_STATUS_RESOURCE_EXHAUSTED), "Mismatched status code");
+            static_assert(StatusCode::FAILED_PRECONDITION == static_cast<StatusCode>(GRPC_STATUS_FAILED_PRECONDITION), "Mismatched status code");
+            static_assert(
+                StatusCode::ABORTED == static_cast<StatusCode>(GRPC_STATUS_ABORTED),
+                "Mismatched status code"
+            );
+            static_assert(StatusCode::OUT_OF_RANGE == static_cast<StatusCode>(GRPC_STATUS_OUT_OF_RANGE), "Mismatched status code");
+            static_assert(StatusCode::UNIMPLEMENTED == static_cast<StatusCode>(GRPC_STATUS_UNIMPLEMENTED), "Mismatched status code");
+            static_assert(
+                StatusCode::INTERNAL == static_cast<StatusCode>(GRPC_STATUS_INTERNAL),
+                "Mismatched status code"
+            );
+            static_assert(StatusCode::UNAVAILABLE == static_cast<StatusCode>(GRPC_STATUS_UNAVAILABLE), "Mismatched status code");
+            static_assert(
+                StatusCode::DATA_LOSS == static_cast<StatusCode>(GRPC_STATUS_DATA_LOSS),
+                "Mismatched status code"
+            );
+        }
 
-  /// Construct an instance with associated \a code and \a error_message.
-  /// It is an error to construct an OK status with non-empty \a error_message.
-  /// Note that \a message is intentionally accepted as a const reference
-  /// instead of a value (which results in a copy instead of a move) to allow
-  /// for easy transition to absl::Status in the future which accepts an
-  /// absl::string_view as a parameter.
-  Status(StatusCode code, const std::string& error_message)
-      : code_(code), error_message_(error_message) {}
+        /// Construct an instance with associated \a code and \a error_message.
+        /// It is an error to construct an OK status with non-empty \a error_message.
+        /// Note that \a message is intentionally accepted as a const reference
+        /// instead of a value (which results in a copy instead of a move) to allow
+        /// for easy transition to absl::Status in the future which accepts an
+        /// absl::string_view as a parameter.
+        Status(StatusCode code, const std::string& error_message) :
+            code_(code),
+            error_message_(error_message)
+        {
+        }
 
-  /// Construct an instance with \a code,  \a error_message and
-  /// \a error_details. It is an error to construct an OK status with non-empty
-  /// \a error_message and/or \a error_details.
-  Status(StatusCode code, const std::string& error_message,
-         const std::string& error_details)
-      : code_(code),
-        error_message_(error_message),
-        binary_error_details_(error_details) {}
+        /// Construct an instance with \a code,  \a error_message and
+        /// \a error_details. It is an error to construct an OK status with non-empty
+        /// \a error_message and/or \a error_details.
+        Status(StatusCode code, const std::string& error_message, const std::string& error_details) :
+            code_(code),
+            error_message_(error_message),
+            binary_error_details_(error_details)
+        {
+        }
 
-  // Pre-defined special status objects.
-  /// An OK pre-defined instance.
-  static const Status& OK;
-  /// A CANCELLED pre-defined instance.
-  static const Status& CANCELLED;
+        // Pre-defined special status objects.
+        /// An OK pre-defined instance.
+        static const Status& OK;
+        /// A CANCELLED pre-defined instance.
+        static const Status& CANCELLED;
 
-  /// Return the instance's error code.
-  StatusCode error_code() const { return code_; }
-  /// Return the instance's error message.
-  std::string error_message() const { return error_message_; }
-  /// Return the (binary) error details.
-  // Usually it contains a serialized google.rpc.Status proto.
-  std::string error_details() const { return binary_error_details_; }
+        /// Return the instance's error code.
+        StatusCode error_code() const
+        {
+            return code_;
+        }
+        /// Return the instance's error message.
+        std::string error_message() const
+        {
+            return error_message_;
+        }
+        /// Return the (binary) error details.
+        // Usually it contains a serialized google.rpc.Status proto.
+        std::string error_details() const
+        {
+            return binary_error_details_;
+        }
 
-  /// Is the status OK?
-  bool ok() const { return code_ == StatusCode::OK; }
+        /// Is the status OK?
+        bool ok() const
+        {
+            return code_ == StatusCode::OK;
+        }
 
-  // Ignores any errors. This method does nothing except potentially suppress
-  // complaints from any tools that are checking that errors are not dropped on
-  // the floor.
-  void IgnoreError() const {}
+        // Ignores any errors. This method does nothing except potentially suppress
+        // complaints from any tools that are checking that errors are not dropped on
+        // the floor.
+        void IgnoreError() const
+        {
+        }
 
- private:
-  StatusCode code_;
-  std::string error_message_;
-  std::string binary_error_details_;
-};
+    private:
+        StatusCode code_;
+        std::string error_message_;
+        std::string binary_error_details_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status_code_enum.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status_code_enum.h
index 6950eab..975f992 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status_code_enum.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/status_code_enum.h
@@ -21,124 +21,126 @@
 
 // IWYU pragma: private, include <grpcpp/support/status.h>
 
-namespace grpc {
-
-enum StatusCode {
-  /// Not an error; returned on success.
-  OK = 0,
-
-  /// The operation was cancelled (typically by the caller).
-  CANCELLED = 1,
-
-  /// Unknown error. An example of where this error may be returned is if a
-  /// Status value received from another address space belongs to an error-space
-  /// that is not known in this address space. Also errors raised by APIs that
-  /// do not return enough error information may be converted to this error.
-  UNKNOWN = 2,
-
-  /// Client specified an invalid argument. Note that this differs from
-  /// FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments that are
-  /// problematic regardless of the state of the system (e.g., a malformed file
-  /// name).
-  INVALID_ARGUMENT = 3,
-
-  /// Deadline expired before operation could complete. For operations that
-  /// change the state of the system, this error may be returned even if the
-  /// operation has completed successfully. For example, a successful response
-  /// from a server could have been delayed long enough for the deadline to
-  /// expire.
-  DEADLINE_EXCEEDED = 4,
-
-  /// Some requested entity (e.g., file or directory) was not found.
-  NOT_FOUND = 5,
-
-  /// Some entity that we attempted to create (e.g., file or directory) already
-  /// exists.
-  ALREADY_EXISTS = 6,
-
-  /// The caller does not have permission to execute the specified operation.
-  /// PERMISSION_DENIED must not be used for rejections caused by exhausting
-  /// some resource (use RESOURCE_EXHAUSTED instead for those errors).
-  /// PERMISSION_DENIED must not be used if the caller can not be identified
-  /// (use UNAUTHENTICATED instead for those errors).
-  PERMISSION_DENIED = 7,
-
-  /// The request does not have valid authentication credentials for the
-  /// operation.
-  UNAUTHENTICATED = 16,
-
-  /// Some resource has been exhausted, perhaps a per-user quota, or perhaps the
-  /// entire file system is out of space.
-  RESOURCE_EXHAUSTED = 8,
-
-  /// Operation was rejected because the system is not in a state required for
-  /// the operation's execution. For example, directory to be deleted may be
-  /// non-empty, an rmdir operation is applied to a non-directory, etc.
-  ///
-  /// A litmus test that may help a service implementor in deciding
-  /// between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
-  ///  (a) Use UNAVAILABLE if the client can retry just the failing call.
-  ///  (b) Use ABORTED if the client should retry at a higher-level
-  ///      (e.g., restarting a read-modify-write sequence).
-  ///  (c) Use FAILED_PRECONDITION if the client should not retry until
-  ///      the system state has been explicitly fixed. E.g., if an "rmdir"
-  ///      fails because the directory is non-empty, FAILED_PRECONDITION
-  ///      should be returned since the client should not retry unless
-  ///      they have first fixed up the directory by deleting files from it.
-  ///  (d) Use FAILED_PRECONDITION if the client performs conditional
-  ///      REST Get/Update/Delete on a resource and the resource on the
-  ///      server does not match the condition. E.g., conflicting
-  ///      read-modify-write on the same resource.
-  FAILED_PRECONDITION = 9,
-
-  /// The operation was aborted, typically due to a concurrency issue like
-  /// sequencer check failures, transaction aborts, etc.
-  ///
-  /// See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,
-  /// and UNAVAILABLE.
-  ABORTED = 10,
-
-  /// Operation was attempted past the valid range. E.g., seeking or reading
-  /// past end of file.
-  ///
-  /// Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed
-  /// if the system state changes. For example, a 32-bit file system will
-  /// generate INVALID_ARGUMENT if asked to read at an offset that is not in the
-  /// range [0,2^32-1], but it will generate OUT_OF_RANGE if asked to read from
-  /// an offset past the current file size.
-  ///
-  /// There is a fair bit of overlap between FAILED_PRECONDITION and
-  /// OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific error)
-  /// when it applies so that callers who are iterating through a space can
-  /// easily look for an OUT_OF_RANGE error to detect when they are done.
-  OUT_OF_RANGE = 11,
-
-  /// Operation is not implemented or not supported/enabled in this service.
-  UNIMPLEMENTED = 12,
-
-  /// Internal errors. Means some invariants expected by underlying System has
-  /// been broken. If you see one of these errors, Something is very broken.
-  INTERNAL = 13,
-
-  /// The service is currently unavailable. This is a most likely a transient
-  /// condition and may be corrected by retrying with a backoff. Note that it is
-  /// not always safe to retry non-idempotent operations.
-  ///
-  /// \warning Although data MIGHT not have been transmitted when this
-  /// status occurs, there is NOT A GUARANTEE that the server has not seen
-  /// anything. So in general it is unsafe to retry on this status code
-  /// if the call is non-idempotent.
-  ///
-  /// See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,
-  /// and UNAVAILABLE.
-  UNAVAILABLE = 14,
-
-  /// Unrecoverable data loss or corruption.
-  DATA_LOSS = 15,
-
-  /// Force users to include a default branch:
-  DO_NOT_USE = -1
-};
+namespace grpc
+{
+
+    enum StatusCode
+    {
+        /// Not an error; returned on success.
+        OK = 0,
+
+        /// The operation was cancelled (typically by the caller).
+        CANCELLED = 1,
+
+        /// Unknown error. An example of where this error may be returned is if a
+        /// Status value received from another address space belongs to an error-space
+        /// that is not known in this address space. Also errors raised by APIs that
+        /// do not return enough error information may be converted to this error.
+        UNKNOWN = 2,
+
+        /// Client specified an invalid argument. Note that this differs from
+        /// FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments that are
+        /// problematic regardless of the state of the system (e.g., a malformed file
+        /// name).
+        INVALID_ARGUMENT = 3,
+
+        /// Deadline expired before operation could complete. For operations that
+        /// change the state of the system, this error may be returned even if the
+        /// operation has completed successfully. For example, a successful response
+        /// from a server could have been delayed long enough for the deadline to
+        /// expire.
+        DEADLINE_EXCEEDED = 4,
+
+        /// Some requested entity (e.g., file or directory) was not found.
+        NOT_FOUND = 5,
+
+        /// Some entity that we attempted to create (e.g., file or directory) already
+        /// exists.
+        ALREADY_EXISTS = 6,
+
+        /// The caller does not have permission to execute the specified operation.
+        /// PERMISSION_DENIED must not be used for rejections caused by exhausting
+        /// some resource (use RESOURCE_EXHAUSTED instead for those errors).
+        /// PERMISSION_DENIED must not be used if the caller can not be identified
+        /// (use UNAUTHENTICATED instead for those errors).
+        PERMISSION_DENIED = 7,
+
+        /// The request does not have valid authentication credentials for the
+        /// operation.
+        UNAUTHENTICATED = 16,
+
+        /// Some resource has been exhausted, perhaps a per-user quota, or perhaps the
+        /// entire file system is out of space.
+        RESOURCE_EXHAUSTED = 8,
+
+        /// Operation was rejected because the system is not in a state required for
+        /// the operation's execution. For example, directory to be deleted may be
+        /// non-empty, an rmdir operation is applied to a non-directory, etc.
+        ///
+        /// A litmus test that may help a service implementor in deciding
+        /// between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
+        ///  (a) Use UNAVAILABLE if the client can retry just the failing call.
+        ///  (b) Use ABORTED if the client should retry at a higher-level
+        ///      (e.g., restarting a read-modify-write sequence).
+        ///  (c) Use FAILED_PRECONDITION if the client should not retry until
+        ///      the system state has been explicitly fixed. E.g., if an "rmdir"
+        ///      fails because the directory is non-empty, FAILED_PRECONDITION
+        ///      should be returned since the client should not retry unless
+        ///      they have first fixed up the directory by deleting files from it.
+        ///  (d) Use FAILED_PRECONDITION if the client performs conditional
+        ///      REST Get/Update/Delete on a resource and the resource on the
+        ///      server does not match the condition. E.g., conflicting
+        ///      read-modify-write on the same resource.
+        FAILED_PRECONDITION = 9,
+
+        /// The operation was aborted, typically due to a concurrency issue like
+        /// sequencer check failures, transaction aborts, etc.
+        ///
+        /// See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,
+        /// and UNAVAILABLE.
+        ABORTED = 10,
+
+        /// Operation was attempted past the valid range. E.g., seeking or reading
+        /// past end of file.
+        ///
+        /// Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed
+        /// if the system state changes. For example, a 32-bit file system will
+        /// generate INVALID_ARGUMENT if asked to read at an offset that is not in the
+        /// range [0,2^32-1], but it will generate OUT_OF_RANGE if asked to read from
+        /// an offset past the current file size.
+        ///
+        /// There is a fair bit of overlap between FAILED_PRECONDITION and
+        /// OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific error)
+        /// when it applies so that callers who are iterating through a space can
+        /// easily look for an OUT_OF_RANGE error to detect when they are done.
+        OUT_OF_RANGE = 11,
+
+        /// Operation is not implemented or not supported/enabled in this service.
+        UNIMPLEMENTED = 12,
+
+        /// Internal errors. Means some invariants expected by underlying System has
+        /// been broken. If you see one of these errors, Something is very broken.
+        INTERNAL = 13,
+
+        /// The service is currently unavailable. This is a most likely a transient
+        /// condition and may be corrected by retrying with a backoff. Note that it is
+        /// not always safe to retry non-idempotent operations.
+        ///
+        /// \warning Although data MIGHT not have been transmitted when this
+        /// status occurs, there is NOT A GUARANTEE that the server has not seen
+        /// anything. So in general it is unsafe to retry on this status code
+        /// if the call is non-idempotent.
+        ///
+        /// See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,
+        /// and UNAVAILABLE.
+        UNAVAILABLE = 14,
+
+        /// Unrecoverable data loss or corruption.
+        DATA_LOSS = 15,
+
+        /// Force users to include a default branch:
+        DO_NOT_USE = -1
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/string_ref.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/string_ref.h
index f71778b..9248059 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/string_ref.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/string_ref.h
@@ -30,121 +30,205 @@
 
 #include <grpcpp/impl/codegen/config.h>
 
-namespace grpc {
-
-/// This class is a non owning reference to a string.
-///
-/// It should be a strict subset of the upcoming std::string_ref.
-///
-/// \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
-///
-/// The constexpr is dropped or replaced with const for legacy compiler
-/// compatibility.
-class string_ref {
- public:
-  /// types
-  typedef const char* const_iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-  /// constants
-  const static size_t npos;
-
-  /// construct/copy.
-  string_ref() : data_(nullptr), length_(0) {}
-  string_ref(const string_ref& other)
-      : data_(other.data_), length_(other.length_) {}
-  // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
-  string_ref& operator=(const string_ref& rhs) {
-    data_ = rhs.data_;
-    length_ = rhs.length_;
-    return *this;
-  }
-
-  /* NOLINTNEXTLINE(google-explicit-constructor) */
-  string_ref(const char* s) : data_(s), length_(strlen(s)) {}
-  string_ref(const char* s, size_t l) : data_(s), length_(l) {}
-  /* NOLINTNEXTLINE(google-explicit-constructor) */
-  string_ref(const std::string& s) : data_(s.data()), length_(s.length()) {}
-
-  /// iterators
-  const_iterator begin() const { return data_; }
-  const_iterator end() const { return data_ + length_; }
-  const_iterator cbegin() const { return data_; }
-  const_iterator cend() const { return data_ + length_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-  const_reverse_iterator crbegin() const {
-    return const_reverse_iterator(end());
-  }
-  const_reverse_iterator crend() const {
-    return const_reverse_iterator(begin());
-  }
-
-  /// capacity
-  size_t size() const { return length_; }
-  size_t length() const { return length_; }
-  size_t max_size() const { return length_; }
-  bool empty() const { return length_ == 0; }
-
-  /// element access
-  const char* data() const { return data_; }
-
-  /// string operations
-  int compare(string_ref x) const {
-    size_t min_size = length_ < x.length_ ? length_ : x.length_;
-    int r = memcmp(data_, x.data_, min_size);
-    if (r < 0) return -1;
-    if (r > 0) return 1;
-    if (length_ < x.length_) return -1;
-    if (length_ > x.length_) return 1;
-    return 0;
-  }
-
-  bool starts_with(string_ref x) const {
-    return length_ >= x.length_ && (memcmp(data_, x.data_, x.length_) == 0);
-  }
-
-  bool ends_with(string_ref x) const {
-    return length_ >= x.length_ &&
-           (memcmp(data_ + (length_ - x.length_), x.data_, x.length_) == 0);
-  }
-
-  size_t find(string_ref s) const {
-    auto it = std::search(cbegin(), cend(), s.cbegin(), s.cend());
-    return it == cend() ? npos : std::distance(cbegin(), it);
-  }
-
-  size_t find(char c) const {
-    auto it = std::find(cbegin(), cend(), c);
-    return it == cend() ? npos : std::distance(cbegin(), it);
-  }
-
-  string_ref substr(size_t pos, size_t n = npos) const {
-    if (pos > length_) pos = length_;
-    if (n > (length_ - pos)) n = length_ - pos;
-    return string_ref(data_ + pos, n);
-  }
-
- private:
-  const char* data_;
-  size_t length_;
-};
-
-/// Comparison operators
-inline bool operator==(string_ref x, string_ref y) { return x.compare(y) == 0; }
-inline bool operator!=(string_ref x, string_ref y) { return x.compare(y) != 0; }
-inline bool operator<(string_ref x, string_ref y) { return x.compare(y) < 0; }
-inline bool operator<=(string_ref x, string_ref y) { return x.compare(y) <= 0; }
-inline bool operator>(string_ref x, string_ref y) { return x.compare(y) > 0; }
-inline bool operator>=(string_ref x, string_ref y) { return x.compare(y) >= 0; }
-
-inline std::ostream& operator<<(std::ostream& out, const string_ref& string) {
-  return out << std::string(string.begin(), string.end());
-}
+namespace grpc
+{
+
+    /// This class is a non owning reference to a string.
+    ///
+    /// It should be a strict subset of the upcoming std::string_ref.
+    ///
+    /// \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
+    ///
+    /// The constexpr is dropped or replaced with const for legacy compiler
+    /// compatibility.
+    class string_ref
+    {
+    public:
+        /// types
+        typedef const char* const_iterator;
+        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+        /// constants
+        const static size_t npos;
+
+        /// construct/copy.
+        string_ref() :
+            data_(nullptr),
+            length_(0)
+        {
+        }
+        string_ref(const string_ref& other) :
+            data_(other.data_),
+            length_(other.length_)
+        {
+        }
+        // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
+        string_ref& operator=(const string_ref& rhs)
+        {
+            data_ = rhs.data_;
+            length_ = rhs.length_;
+            return *this;
+        }
+
+        /* NOLINTNEXTLINE(google-explicit-constructor) */
+        string_ref(const char* s) :
+            data_(s),
+            length_(strlen(s))
+        {
+        }
+        string_ref(const char* s, size_t l) :
+            data_(s),
+            length_(l)
+        {
+        }
+        /* NOLINTNEXTLINE(google-explicit-constructor) */
+        string_ref(const std::string& s) :
+            data_(s.data()),
+            length_(s.length())
+        {
+        }
+
+        /// iterators
+        const_iterator begin() const
+        {
+            return data_;
+        }
+        const_iterator end() const
+        {
+            return data_ + length_;
+        }
+        const_iterator cbegin() const
+        {
+            return data_;
+        }
+        const_iterator cend() const
+        {
+            return data_ + length_;
+        }
+        const_reverse_iterator rbegin() const
+        {
+            return const_reverse_iterator(end());
+        }
+        const_reverse_iterator rend() const
+        {
+            return const_reverse_iterator(begin());
+        }
+        const_reverse_iterator crbegin() const
+        {
+            return const_reverse_iterator(end());
+        }
+        const_reverse_iterator crend() const
+        {
+            return const_reverse_iterator(begin());
+        }
+
+        /// capacity
+        size_t size() const
+        {
+            return length_;
+        }
+        size_t length() const
+        {
+            return length_;
+        }
+        size_t max_size() const
+        {
+            return length_;
+        }
+        bool empty() const
+        {
+            return length_ == 0;
+        }
+
+        /// element access
+        const char* data() const
+        {
+            return data_;
+        }
+
+        /// string operations
+        int compare(string_ref x) const
+        {
+            size_t min_size = length_ < x.length_ ? length_ : x.length_;
+            int r = memcmp(data_, x.data_, min_size);
+            if (r < 0)
+                return -1;
+            if (r > 0)
+                return 1;
+            if (length_ < x.length_)
+                return -1;
+            if (length_ > x.length_)
+                return 1;
+            return 0;
+        }
+
+        bool starts_with(string_ref x) const
+        {
+            return length_ >= x.length_ && (memcmp(data_, x.data_, x.length_) == 0);
+        }
+
+        bool ends_with(string_ref x) const
+        {
+            return length_ >= x.length_ &&
+                   (memcmp(data_ + (length_ - x.length_), x.data_, x.length_) == 0);
+        }
+
+        size_t find(string_ref s) const
+        {
+            auto it = std::search(cbegin(), cend(), s.cbegin(), s.cend());
+            return it == cend() ? npos : std::distance(cbegin(), it);
+        }
+
+        size_t find(char c) const
+        {
+            auto it = std::find(cbegin(), cend(), c);
+            return it == cend() ? npos : std::distance(cbegin(), it);
+        }
+
+        string_ref substr(size_t pos, size_t n = npos) const
+        {
+            if (pos > length_)
+                pos = length_;
+            if (n > (length_ - pos))
+                n = length_ - pos;
+            return string_ref(data_ + pos, n);
+        }
+
+    private:
+        const char* data_;
+        size_t length_;
+    };
+
+    /// Comparison operators
+    inline bool operator==(string_ref x, string_ref y)
+    {
+        return x.compare(y) == 0;
+    }
+    inline bool operator!=(string_ref x, string_ref y)
+    {
+        return x.compare(y) != 0;
+    }
+    inline bool operator<(string_ref x, string_ref y)
+    {
+        return x.compare(y) < 0;
+    }
+    inline bool operator<=(string_ref x, string_ref y)
+    {
+        return x.compare(y) <= 0;
+    }
+    inline bool operator>(string_ref x, string_ref y)
+    {
+        return x.compare(y) > 0;
+    }
+    inline bool operator>=(string_ref x, string_ref y)
+    {
+        return x.compare(y) >= 0;
+    }
+
+    inline std::ostream& operator<<(std::ostream& out, const string_ref& string)
+    {
+        return out << std::string(string.begin(), string.end());
+    }
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/stub_options.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/stub_options.h
index efa1e38..948ee3a 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/stub_options.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/stub_options.h
@@ -21,23 +21,31 @@
 
 // IWYU pragma: private, include <grpcpp/support/stub_options.h>
 
-namespace grpc {
-
-/// Useful interface for generated stubs
-class StubOptions {
- public:
-  StubOptions() = default;
-  explicit StubOptions(const char* suffix_for_stats)
-      : suffix_for_stats_(suffix_for_stats) {}
-
-  void set_suffix_for_stats(const char* suffix_for_stats) {
-    suffix_for_stats_ = suffix_for_stats;
-  }
-  const char* suffix_for_stats() const { return suffix_for_stats_; }
-
- private:
-  const char* suffix_for_stats_ = nullptr;
-};
+namespace grpc
+{
+
+    /// Useful interface for generated stubs
+    class StubOptions
+    {
+    public:
+        StubOptions() = default;
+        explicit StubOptions(const char* suffix_for_stats) :
+            suffix_for_stats_(suffix_for_stats)
+        {
+        }
+
+        void set_suffix_for_stats(const char* suffix_for_stats)
+        {
+            suffix_for_stats_ = suffix_for_stats;
+        }
+        const char* suffix_for_stats() const
+        {
+            return suffix_for_stats_;
+        }
+
+    private:
+        const char* suffix_for_stats_ = nullptr;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync.h
index 4cb8133..0ccf354 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync.h
@@ -44,115 +44,154 @@
 // since in core we do not rely on g_core_codegen_interface and hence do not
 // pay the costs of virtual function calls.
 
-namespace grpc {
-namespace internal {
+namespace grpc
+{
+    namespace internal
+    {
 
 #ifdef GPR_ABSEIL_SYNC
 
-using Mutex = absl::Mutex;
-using MutexLock = absl::MutexLock;
-using ReleasableMutexLock = absl::ReleasableMutexLock;
-using CondVar = absl::CondVar;
+        using Mutex = absl::Mutex;
+        using MutexLock = absl::MutexLock;
+        using ReleasableMutexLock = absl::ReleasableMutexLock;
+        using CondVar = absl::CondVar;
 
 #else
 
-class ABSL_LOCKABLE Mutex {
- public:
-  Mutex() { g_core_codegen_interface->gpr_mu_init(&mu_); }
-  ~Mutex() { g_core_codegen_interface->gpr_mu_destroy(&mu_); }
-
-  Mutex(const Mutex&) = delete;
-  Mutex& operator=(const Mutex&) = delete;
-
-  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
-    g_core_codegen_interface->gpr_mu_lock(&mu_);
-  }
-  void Unlock() ABSL_UNLOCK_FUNCTION() {
-    g_core_codegen_interface->gpr_mu_unlock(&mu_);
-  }
-
- private:
-  union {
-    gpr_mu mu_;
-    std::mutex do_not_use_sth_;
+        class ABSL_LOCKABLE Mutex
+        {
+        public:
+            Mutex()
+            {
+                g_core_codegen_interface->gpr_mu_init(&mu_);
+            }
+            ~Mutex()
+            {
+                g_core_codegen_interface->gpr_mu_destroy(&mu_);
+            }
+
+            Mutex(const Mutex&) = delete;
+            Mutex& operator=(const Mutex&) = delete;
+
+            void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION()
+            {
+                g_core_codegen_interface->gpr_mu_lock(&mu_);
+            }
+            void Unlock() ABSL_UNLOCK_FUNCTION()
+            {
+                g_core_codegen_interface->gpr_mu_unlock(&mu_);
+            }
+
+        private:
+            union
+            {
+                gpr_mu mu_;
+                std::mutex do_not_use_sth_;
 #ifdef GPR_HAS_PTHREAD_H
-    pthread_mutex_t do_not_use_pth_;
+                pthread_mutex_t do_not_use_pth_;
 #endif
-  };
-
-  friend class CondVar;
-};
-
-class ABSL_SCOPED_LOCKABLE MutexLock {
- public:
-  explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
-    mu_->Lock();
-  }
-  ~MutexLock() ABSL_UNLOCK_FUNCTION() { mu_->Unlock(); }
-
-  MutexLock(const MutexLock&) = delete;
-  MutexLock& operator=(const MutexLock&) = delete;
-
- private:
-  Mutex* const mu_;
-};
-
-class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
- public:
-  explicit ReleasableMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    mu_->Lock();
-  }
-  ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
-    if (!released_) mu_->Unlock();
-  }
-
-  ReleasableMutexLock(const ReleasableMutexLock&) = delete;
-  ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
-
-  void Release() ABSL_UNLOCK_FUNCTION() {
-    GPR_DEBUG_ASSERT(!released_);
-    released_ = true;
-    mu_->Unlock();
-  }
-
- private:
-  Mutex* const mu_;
-  bool released_ = false;
-};
-
-class CondVar {
- public:
-  CondVar() { g_core_codegen_interface->gpr_cv_init(&cv_); }
-  ~CondVar() { g_core_codegen_interface->gpr_cv_destroy(&cv_); }
-
-  CondVar(const CondVar&) = delete;
-  CondVar& operator=(const CondVar&) = delete;
-
-  void Signal() { g_core_codegen_interface->gpr_cv_signal(&cv_); }
-  void SignalAll() { g_core_codegen_interface->gpr_cv_broadcast(&cv_); }
-
-  void Wait(Mutex* mu) {
-    g_core_codegen_interface->gpr_cv_wait(
-        &cv_, &mu->mu_,
-        g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME));
-  }
-
- private:
-  gpr_cv cv_;
-};
+            };
+
+            friend class CondVar;
+        };
+
+        class ABSL_SCOPED_LOCKABLE MutexLock
+        {
+        public:
+            explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+                mu_(mu)
+            {
+                mu_->Lock();
+            }
+            ~MutexLock() ABSL_UNLOCK_FUNCTION()
+            {
+                mu_->Unlock();
+            }
+
+            MutexLock(const MutexLock&) = delete;
+            MutexLock& operator=(const MutexLock&) = delete;
+
+        private:
+            Mutex* const mu_;
+        };
+
+        class ABSL_SCOPED_LOCKABLE ReleasableMutexLock
+        {
+        public:
+            explicit ReleasableMutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) :
+                mu_(mu)
+            {
+                mu_->Lock();
+            }
+            ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION()
+            {
+                if (!released_)
+                    mu_->Unlock();
+            }
+
+            ReleasableMutexLock(const ReleasableMutexLock&) = delete;
+            ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
+
+            void Release() ABSL_UNLOCK_FUNCTION()
+            {
+                GPR_DEBUG_ASSERT(!released_);
+                released_ = true;
+                mu_->Unlock();
+            }
+
+        private:
+            Mutex* const mu_;
+            bool released_ = false;
+        };
+
+        class CondVar
+        {
+        public:
+            CondVar()
+            {
+                g_core_codegen_interface->gpr_cv_init(&cv_);
+            }
+            ~CondVar()
+            {
+                g_core_codegen_interface->gpr_cv_destroy(&cv_);
+            }
+
+            CondVar(const CondVar&) = delete;
+            CondVar& operator=(const CondVar&) = delete;
+
+            void Signal()
+            {
+                g_core_codegen_interface->gpr_cv_signal(&cv_);
+            }
+            void SignalAll()
+            {
+                g_core_codegen_interface->gpr_cv_broadcast(&cv_);
+            }
+
+            void Wait(Mutex* mu)
+            {
+                g_core_codegen_interface->gpr_cv_wait(
+                    &cv_, &mu->mu_, g_core_codegen_interface->gpr_inf_future(GPR_CLOCK_REALTIME)
+                );
+            }
+
+        private:
+            gpr_cv cv_;
+        };
 
 #endif  // GPR_ABSEIL_SYNC
 
-template <typename Predicate>
-GRPC_DEPRECATED("incompatible with thread safety analysis")
-static void WaitUntil(CondVar* cv, Mutex* mu, Predicate pred) {
-  while (!pred()) {
-    cv->Wait(mu);
-  }
-}
-
-}  // namespace internal
+        template<typename Predicate>
+        GRPC_DEPRECATED("incompatible with thread safety analysis")
+        static void WaitUntil(CondVar* cv, Mutex* mu, Predicate pred)
+        {
+            while (!pred())
+            {
+                cv->Wait(mu);
+            }
+        }
+
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_CODEGEN_SYNC_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync_stream.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync_stream.h
index aca6079..ab23759 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync_stream.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/sync_stream.h
@@ -29,921 +29,1015 @@
 #include <grpcpp/impl/codegen/service_type.h>
 #include <grpcpp/impl/codegen/status.h>
 
-namespace grpc {
-
-namespace internal {
-/// Common interface for all synchronous client side streaming.
-class ClientStreamingInterface {
- public:
-  virtual ~ClientStreamingInterface() {}
-
-  /// Block waiting until the stream finishes and a final status of the call is
-  /// available.
-  ///
-  /// It is appropriate to call this method exactly once when both:
-  ///   * the calling code (client-side) has no more message to send
-  ///     (this can be declared implicitly by calling this method, or
-  ///     explicitly through an earlier call to <i>WritesDone</i> method of the
-  ///     class in use, e.g. \a ClientWriterInterface::WritesDone or
-  ///     \a ClientReaderWriterInterface::WritesDone).
-  ///   * there are no more messages to be received from the server (which can
-  ///     be known implicitly, or explicitly from an earlier call to \a
-  ///     ReaderInterface::Read that returned "false").
-  ///
-  /// This function will return either:
-  /// - when all incoming messages have been read and the server has
-  ///   returned status.
-  /// - when the server has returned a non-OK status.
-  /// - OR when the call failed for some reason and the library generated a
-  ///   status.
-  ///
-  /// Return values:
-  ///   - \a Status contains the status code, message and details for the call
-  ///   - the \a ClientContext associated with this call is updated with
-  ///     possible trailing metadata sent from the server.
-  virtual grpc::Status Finish() = 0;
-};
-
-/// Common interface for all synchronous server side streaming.
-class ServerStreamingInterface {
- public:
-  virtual ~ServerStreamingInterface() {}
-
-  /// Block to send initial metadata to client.
-  /// This call is optional, but if it is used, it cannot be used concurrently
-  /// with or after the \a Finish method.
-  ///
-  /// The initial metadata that will be sent to the client will be
-  /// taken from the \a ServerContext associated with the call.
-  virtual void SendInitialMetadata() = 0;
-};
-
-/// An interface that yields a sequence of messages of type \a R.
-template <class R>
-class ReaderInterface {
- public:
-  virtual ~ReaderInterface() {}
-
-  /// Get an upper bound on the next message size available for reading on this
-  /// stream.
-  virtual bool NextMessageSize(uint32_t* sz) = 0;
-
-  /// Block to read a message and parse to \a msg. Returns \a true on success.
-  /// This is thread-safe with respect to \a Write or \WritesDone methods on
-  /// the same stream. It should not be called concurrently with another \a
-  /// Read on the same stream as the order of delivery will not be defined.
-  ///
-  /// \param[out] msg The read message.
-  ///
-  /// \return \a false when there will be no more incoming messages, either
-  /// because the other side has called \a WritesDone() or the stream has failed
-  /// (or been cancelled).
-  virtual bool Read(R* msg) = 0;
-};
-
-/// An interface that can be fed a sequence of messages of type \a W.
-template <class W>
-class WriterInterface {
- public:
-  virtual ~WriterInterface() {}
-
-  /// Block to write \a msg to the stream with WriteOptions \a options.
-  /// This is thread-safe with respect to \a ReaderInterface::Read
-  ///
-  /// \param msg The message to be written to the stream.
-  /// \param options The WriteOptions affecting the write operation.
-  ///
-  /// \return \a true on success, \a false when the stream has been closed.
-  virtual bool Write(const W& msg, grpc::WriteOptions options) = 0;
-
-  /// Block to write \a msg to the stream with default write options.
-  /// This is thread-safe with respect to \a ReaderInterface::Read
-  ///
-  /// \param msg The message to be written to the stream.
-  ///
-  /// \return \a true on success, \a false when the stream has been closed.
-  inline bool Write(const W& msg) { return Write(msg, grpc::WriteOptions()); }
-
-  /// Write \a msg and coalesce it with the writing of trailing metadata, using
-  /// WriteOptions \a options.
-  ///
-  /// For client, WriteLast is equivalent of performing Write and WritesDone in
-  /// a single step. \a msg and trailing metadata are coalesced and sent on wire
-  /// by calling this function. For server, WriteLast buffers the \a msg.
-  /// The writing of \a msg is held until the service handler returns,
-  /// where \a msg and trailing metadata are coalesced and sent on wire.
-  /// Note that WriteLast can only buffer \a msg up to the flow control window
-  /// size. If \a msg size is larger than the window size, it will be sent on
-  /// wire without buffering.
-  ///
-  /// \param[in] msg The message to be written to the stream.
-  /// \param[in] options The WriteOptions to be used to write this message.
-  void WriteLast(const W& msg, grpc::WriteOptions options) {
-    Write(msg, options.set_last_message());
-  }
-};
-
-}  // namespace internal
-
-/// Client-side interface for streaming reads of message of type \a R.
-template <class R>
-class ClientReaderInterface : public internal::ClientStreamingInterface,
-                              public internal::ReaderInterface<R> {
- public:
-  /// Block to wait for initial metadata from server. The received metadata
-  /// can only be accessed after this call returns. Should only be called before
-  /// the first read. Calling this method is optional, and if it is not called
-  /// the metadata will be available in ClientContext after the first read.
-  virtual void WaitForInitialMetadata() = 0;
-};
-
-namespace internal {
-template <class R>
-class ClientReaderFactory {
- public:
-  template <class W>
-  static ClientReader<R>* Create(grpc::ChannelInterface* channel,
-                                 const grpc::internal::RpcMethod& method,
-                                 grpc::ClientContext* context,
-                                 const W& request) {
-    return new ClientReader<R>(channel, method, context, request);
-  }
-};
-}  // namespace internal
-
-/// Synchronous (blocking) client-side API for doing server-streaming RPCs,
-/// where the stream of messages coming from the server has messages
-/// of type \a R.
-template <class R>
-class ClientReader final : public ClientReaderInterface<R> {
- public:
-  /// See the \a ClientStreamingInterface.WaitForInitialMetadata method for
-  /// semantics.
-  ///
-  //  Side effect:
-  ///   Once complete, the initial metadata read from
-  ///   the server will be accessible through the \a ClientContext used to
-  ///   construct this object.
-  void WaitForInitialMetadata() override {
-    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
-    ops.RecvInitialMetadata(context_);
-    call_.PerformOps(&ops);
-    cq_.Pluck(&ops);  /// status ignored
-  }
-
-  bool NextMessageSize(uint32_t* sz) override {
-    int result = call_.max_receive_message_size();
-    *sz = (result > 0) ? result : UINT32_MAX;
-    return true;
-  }
-
-  /// See the \a ReaderInterface.Read method for semantics.
-  /// Side effect:
-  ///   This also receives initial metadata from the server, if not
-  ///   already received (if initial metadata is received, it can be then
-  ///   accessed through the \a ClientContext associated with this call).
-  bool Read(R* msg) override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                              grpc::internal::CallOpRecvMessage<R>>
-        ops;
-    if (!context_->initial_metadata_received_) {
-      ops.RecvInitialMetadata(context_);
-    }
-    ops.RecvMessage(msg);
-    call_.PerformOps(&ops);
-    return cq_.Pluck(&ops) && ops.got_message;
-  }
-
-  /// See the \a ClientStreamingInterface.Finish method for semantics.
-  ///
-  /// Side effect:
-  ///   The \a ClientContext associated with this call is updated with
-  ///   possible metadata received from the server.
-  grpc::Status Finish() override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                              grpc::internal::CallOpClientRecvStatus>
-        ops;
-    if (!context_->initial_metadata_received_) {
-      ops.RecvInitialMetadata(context_);
-    }
-    grpc::Status status;
-    ops.ClientRecvStatus(context_, &status);
-    call_.PerformOps(&ops);
-    GPR_CODEGEN_ASSERT(cq_.Pluck(&ops));
-    return status;
-  }
-
- private:
-  friend class internal::ClientReaderFactory<R>;
-  grpc::ClientContext* context_;
-  grpc::CompletionQueue cq_;
-  grpc::internal::Call call_;
-
-  /// Block to create a stream and write the initial metadata and \a request
-  /// out. Note that \a context will be used to fill in custom initial
-  /// metadata used to send to the server when starting the call.
-  template <class W>
-  ClientReader(grpc::ChannelInterface* channel,
-               const grpc::internal::RpcMethod& method,
-               grpc::ClientContext* context, const W& request)
-      : context_(context),
-        cq_(grpc_completion_queue_attributes{
-            GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
-            nullptr}),  // Pluckable cq
-        call_(channel->CreateCall(method, context, &cq_)) {
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage,
-                              grpc::internal::CallOpClientSendClose>
-        ops;
-    ops.SendInitialMetadata(&context->send_initial_metadata_,
-                            context->initial_metadata_flags());
-    // TODO(ctiller): don't assert
-    GPR_CODEGEN_ASSERT(ops.SendMessagePtr(&request).ok());
-    ops.ClientSendClose();
-    call_.PerformOps(&ops);
-    cq_.Pluck(&ops);
-  }
-};
-
-/// Client-side interface for streaming writes of message type \a W.
-template <class W>
-class ClientWriterInterface : public internal::ClientStreamingInterface,
-                              public internal::WriterInterface<W> {
- public:
-  /// Half close writing from the client. (signal that the stream of messages
-  /// coming from the client is complete).
-  /// Blocks until currently-pending writes are completed.
-  /// Thread safe with respect to \a ReaderInterface::Read operations only
-  ///
-  /// \return Whether the writes were successful.
-  virtual bool WritesDone() = 0;
-};
-
-namespace internal {
-template <class W>
-class ClientWriterFactory {
- public:
-  template <class R>
-  static ClientWriter<W>* Create(grpc::ChannelInterface* channel,
-                                 const grpc::internal::RpcMethod& method,
-                                 grpc::ClientContext* context, R* response) {
-    return new ClientWriter<W>(channel, method, context, response);
-  }
-};
-}  // namespace internal
-
-/// Synchronous (blocking) client-side API for doing client-streaming RPCs,
-/// where the outgoing message stream coming from the client has messages of
-/// type \a W.
-template <class W>
-class ClientWriter : public ClientWriterInterface<W> {
- public:
-  /// See the \a ClientStreamingInterface.WaitForInitialMetadata method for
-  /// semantics.
-  ///
-  //  Side effect:
-  ///   Once complete, the initial metadata read from the server will be
-  ///   accessible through the \a ClientContext used to construct this object.
-  void WaitForInitialMetadata() {
-    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
-    ops.RecvInitialMetadata(context_);
-    call_.PerformOps(&ops);
-    cq_.Pluck(&ops);  // status ignored
-  }
-
-  /// See the WriterInterface.Write(const W& msg, WriteOptions options) method
-  /// for semantics.
-  ///
-  /// Side effect:
-  ///   Also sends initial metadata if not already sent (using the
-  ///   \a ClientContext associated with this call).
-  using internal::WriterInterface<W>::Write;
-  bool Write(const W& msg, grpc::WriteOptions options) override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage,
-                              grpc::internal::CallOpClientSendClose>
-        ops;
-
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-      ops.ClientSendClose();
-    }
-    if (context_->initial_metadata_corked_) {
-      ops.SendInitialMetadata(&context_->send_initial_metadata_,
-                              context_->initial_metadata_flags());
-      context_->set_initial_metadata_corked(false);
-    }
-    if (!ops.SendMessagePtr(&msg, options).ok()) {
-      return false;
-    }
-
-    call_.PerformOps(&ops);
-    return cq_.Pluck(&ops);
-  }
-
-  bool WritesDone() override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpClientSendClose> ops;
-    ops.ClientSendClose();
-    call_.PerformOps(&ops);
-    return cq_.Pluck(&ops);
-  }
-
-  /// See the ClientStreamingInterface.Finish method for semantics.
-  /// Side effects:
-  ///   - Also receives initial metadata if not already received.
-  ///   - Attempts to fill in the \a response parameter passed
-  ///     to the constructor of this instance with the response
-  ///     message from the server.
-  grpc::Status Finish() override {
-    grpc::Status status;
-    if (!context_->initial_metadata_received_) {
-      finish_ops_.RecvInitialMetadata(context_);
-    }
-    finish_ops_.ClientRecvStatus(context_, &status);
-    call_.PerformOps(&finish_ops_);
-    GPR_CODEGEN_ASSERT(cq_.Pluck(&finish_ops_));
-    return status;
-  }
-
- private:
-  friend class internal::ClientWriterFactory<W>;
-
-  /// Block to create a stream (i.e. send request headers and other initial
-  /// metadata to the server). Note that \a context will be used to fill
-  /// in custom initial metadata. \a response will be filled in with the
-  /// single expected response message from the server upon a successful
-  /// call to the \a Finish method of this instance.
-  template <class R>
-  ClientWriter(grpc::ChannelInterface* channel,
-               const grpc::internal::RpcMethod& method,
-               grpc::ClientContext* context, R* response)
-      : context_(context),
-        cq_(grpc_completion_queue_attributes{
-            GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
-            nullptr}),  // Pluckable cq
-        call_(channel->CreateCall(method, context, &cq_)) {
-    finish_ops_.RecvMessage(response);
-    finish_ops_.AllowNoMessage();
-
-    if (!context_->initial_metadata_corked_) {
-      grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
-      ops.SendInitialMetadata(&context->send_initial_metadata_,
-                              context->initial_metadata_flags());
-      call_.PerformOps(&ops);
-      cq_.Pluck(&ops);
-    }
-  }
-
-  grpc::ClientContext* context_;
-  grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                            grpc::internal::CallOpGenericRecvMessage,
-                            grpc::internal::CallOpClientRecvStatus>
-      finish_ops_;
-  grpc::CompletionQueue cq_;
-  grpc::internal::Call call_;
-};
-
-/// Client-side interface for bi-directional streaming with
-/// client-to-server stream messages of type \a W and
-/// server-to-client stream messages of type \a R.
-template <class W, class R>
-class ClientReaderWriterInterface : public internal::ClientStreamingInterface,
-                                    public internal::WriterInterface<W>,
-                                    public internal::ReaderInterface<R> {
- public:
-  /// Block to wait for initial metadata from server. The received metadata
-  /// can only be accessed after this call returns. Should only be called before
-  /// the first read. Calling this method is optional, and if it is not called
-  /// the metadata will be available in ClientContext after the first read.
-  virtual void WaitForInitialMetadata() = 0;
-
-  /// Half close writing from the client. (signal that the stream of messages
-  /// coming from the client is complete).
-  /// Blocks until currently-pending writes are completed.
-  /// Thread-safe with respect to \a ReaderInterface::Read
-  ///
-  /// \return Whether the writes were successful.
-  virtual bool WritesDone() = 0;
-};
-
-namespace internal {
-template <class W, class R>
-class ClientReaderWriterFactory {
- public:
-  static ClientReaderWriter<W, R>* Create(
-      grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method,
-      grpc::ClientContext* context) {
-    return new ClientReaderWriter<W, R>(channel, method, context);
-  }
-};
-}  // namespace internal
-
-/// Synchronous (blocking) client-side API for bi-directional streaming RPCs,
-/// where the outgoing message stream coming from the client has messages of
-/// type \a W, and the incoming messages stream coming from the server has
-/// messages of type \a R.
-template <class W, class R>
-class ClientReaderWriter final : public ClientReaderWriterInterface<W, R> {
- public:
-  /// Block waiting to read initial metadata from the server.
-  /// This call is optional, but if it is used, it cannot be used concurrently
-  /// with or after the \a Finish method.
-  ///
-  /// Once complete, the initial metadata read from the server will be
-  /// accessible through the \a ClientContext used to construct this object.
-  void WaitForInitialMetadata() override {
-    GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
-    ops.RecvInitialMetadata(context_);
-    call_.PerformOps(&ops);
-    cq_.Pluck(&ops);  // status ignored
-  }
-
-  bool NextMessageSize(uint32_t* sz) override {
-    int result = call_.max_receive_message_size();
-    *sz = (result > 0) ? result : UINT32_MAX;
-    return true;
-  }
-
-  /// See the \a ReaderInterface.Read method for semantics.
-  /// Side effect:
-  ///   Also receives initial metadata if not already received (updates the \a
-  ///   ClientContext associated with this call in that case).
-  bool Read(R* msg) override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                              grpc::internal::CallOpRecvMessage<R>>
-        ops;
-    if (!context_->initial_metadata_received_) {
-      ops.RecvInitialMetadata(context_);
-    }
-    ops.RecvMessage(msg);
-    call_.PerformOps(&ops);
-    return cq_.Pluck(&ops) && ops.got_message;
-  }
-
-  /// See the \a WriterInterface.Write method for semantics.
-  ///
-  /// Side effect:
-  ///   Also sends initial metadata if not already sent (using the
-  ///   \a ClientContext associated with this call to fill in values).
-  using internal::WriterInterface<W>::Write;
-  bool Write(const W& msg, grpc::WriteOptions options) override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata,
-                              grpc::internal::CallOpSendMessage,
-                              grpc::internal::CallOpClientSendClose>
-        ops;
-
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-      ops.ClientSendClose();
-    }
-    if (context_->initial_metadata_corked_) {
-      ops.SendInitialMetadata(&context_->send_initial_metadata_,
-                              context_->initial_metadata_flags());
-      context_->set_initial_metadata_corked(false);
-    }
-    if (!ops.SendMessagePtr(&msg, options).ok()) {
-      return false;
-    }
-
-    call_.PerformOps(&ops);
-    return cq_.Pluck(&ops);
-  }
-
-  bool WritesDone() override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpClientSendClose> ops;
-    ops.ClientSendClose();
-    call_.PerformOps(&ops);
-    return cq_.Pluck(&ops);
-  }
-
-  /// See the ClientStreamingInterface.Finish method for semantics.
-  ///
-  /// Side effect:
-  ///   - the \a ClientContext associated with this call is updated with
-  ///     possible trailing metadata sent from the server.
-  grpc::Status Finish() override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata,
-                              grpc::internal::CallOpClientRecvStatus>
-        ops;
-    if (!context_->initial_metadata_received_) {
-      ops.RecvInitialMetadata(context_);
-    }
-    grpc::Status status;
-    ops.ClientRecvStatus(context_, &status);
-    call_.PerformOps(&ops);
-    GPR_CODEGEN_ASSERT(cq_.Pluck(&ops));
-    return status;
-  }
-
- private:
-  friend class internal::ClientReaderWriterFactory<W, R>;
-
-  grpc::ClientContext* context_;
-  grpc::CompletionQueue cq_;
-  grpc::internal::Call call_;
-
-  /// Block to create a stream and write the initial metadata and \a request
-  /// out. Note that \a context will be used to fill in custom initial metadata
-  /// used to send to the server when starting the call.
-  ClientReaderWriter(grpc::ChannelInterface* channel,
-                     const grpc::internal::RpcMethod& method,
-                     grpc::ClientContext* context)
-      : context_(context),
-        cq_(grpc_completion_queue_attributes{
-            GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING,
-            nullptr}),  // Pluckable cq
-        call_(channel->CreateCall(method, context, &cq_)) {
-    if (!context_->initial_metadata_corked_) {
-      grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
-      ops.SendInitialMetadata(&context->send_initial_metadata_,
-                              context->initial_metadata_flags());
-      call_.PerformOps(&ops);
-      cq_.Pluck(&ops);
-    }
-  }
-};
-
-/// Server-side interface for streaming reads of message of type \a R.
-template <class R>
-class ServerReaderInterface : public internal::ServerStreamingInterface,
-                              public internal::ReaderInterface<R> {};
-
-/// Synchronous (blocking) server-side API for doing client-streaming RPCs,
-/// where the incoming message stream coming from the client has messages of
-/// type \a R.
-template <class R>
-class ServerReader final : public ServerReaderInterface<R> {
- public:
-  /// See the \a ServerStreamingInterface.SendInitialMetadata method
-  /// for semantics. Note that initial metadata will be affected by the
-  /// \a ServerContext associated with this call.
-  void SendInitialMetadata() override {
-    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
-    ops.SendInitialMetadata(&ctx_->initial_metadata_,
-                            ctx_->initial_metadata_flags());
-    if (ctx_->compression_level_set()) {
-      ops.set_compression_level(ctx_->compression_level());
-    }
-    ctx_->sent_initial_metadata_ = true;
-    call_->PerformOps(&ops);
-    call_->cq()->Pluck(&ops);
-  }
-
-  bool NextMessageSize(uint32_t* sz) override {
-    int result = call_->max_receive_message_size();
-    *sz = (result > 0) ? result : UINT32_MAX;
-    return true;
-  }
-
-  bool Read(R* msg) override {
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> ops;
-    ops.RecvMessage(msg);
-    call_->PerformOps(&ops);
-    bool ok = call_->cq()->Pluck(&ops) && ops.got_message;
-    if (!ok) {
-      ctx_->MaybeMarkCancelledOnRead();
-    }
-    return ok;
-  }
-
- private:
-  grpc::internal::Call* const call_;
-  ServerContext* const ctx_;
-
-  template <class ServiceType, class RequestType, class ResponseType>
-  friend class internal::ClientStreamingHandler;
-
-  ServerReader(grpc::internal::Call* call, grpc::ServerContext* ctx)
-      : call_(call), ctx_(ctx) {}
-};
-
-/// Server-side interface for streaming writes of message of type \a W.
-template <class W>
-class ServerWriterInterface : public internal::ServerStreamingInterface,
-                              public internal::WriterInterface<W> {};
-
-/// Synchronous (blocking) server-side API for doing for doing a
-/// server-streaming RPCs, where the outgoing message stream coming from the
-/// server has messages of type \a W.
-template <class W>
-class ServerWriter final : public ServerWriterInterface<W> {
- public:
-  /// See the \a ServerStreamingInterface.SendInitialMetadata method
-  /// for semantics.
-  /// Note that initial metadata will be affected by the
-  /// \a ServerContext associated with this call.
-  void SendInitialMetadata() override {
-    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
-    ops.SendInitialMetadata(&ctx_->initial_metadata_,
-                            ctx_->initial_metadata_flags());
-    if (ctx_->compression_level_set()) {
-      ops.set_compression_level(ctx_->compression_level());
-    }
-    ctx_->sent_initial_metadata_ = true;
-    call_->PerformOps(&ops);
-    call_->cq()->Pluck(&ops);
-  }
-
-  /// See the \a WriterInterface.Write method for semantics.
-  ///
-  /// Side effect:
-  ///   Also sends initial metadata if not already sent (using the
-  ///   \a ClientContext associated with this call to fill in values).
-  using internal::WriterInterface<W>::Write;
-  bool Write(const W& msg, grpc::WriteOptions options) override {
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-    }
-
-    if (!ctx_->pending_ops_.SendMessagePtr(&msg, options).ok()) {
-      return false;
-    }
-    if (!ctx_->sent_initial_metadata_) {
-      ctx_->pending_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                             ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        ctx_->pending_ops_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-    }
-    call_->PerformOps(&ctx_->pending_ops_);
-    // if this is the last message we defer the pluck until AFTER we start
-    // the trailing md op. This prevents hangs. See
-    // https://github.com/grpc/grpc/issues/11546
-    if (options.is_last_message()) {
-      ctx_->has_pending_ops_ = true;
-      return true;
-    }
-    ctx_->has_pending_ops_ = false;
-    return call_->cq()->Pluck(&ctx_->pending_ops_);
-  }
-
- private:
-  grpc::internal::Call* const call_;
-  grpc::ServerContext* const ctx_;
-
-  template <class ServiceType, class RequestType, class ResponseType>
-  friend class internal::ServerStreamingHandler;
-
-  ServerWriter(grpc::internal::Call* call, grpc::ServerContext* ctx)
-      : call_(call), ctx_(ctx) {}
-};
-
-/// Server-side interface for bi-directional streaming.
-template <class W, class R>
-class ServerReaderWriterInterface : public internal::ServerStreamingInterface,
-                                    public internal::WriterInterface<W>,
-                                    public internal::ReaderInterface<R> {};
-
-/// Actual implementation of bi-directional streaming
-namespace internal {
-template <class W, class R>
-class ServerReaderWriterBody final {
- public:
-  ServerReaderWriterBody(grpc::internal::Call* call, grpc::ServerContext* ctx)
-      : call_(call), ctx_(ctx) {}
-
-  void SendInitialMetadata() {
-    GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
-
-    grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
-    ops.SendInitialMetadata(&ctx_->initial_metadata_,
-                            ctx_->initial_metadata_flags());
-    if (ctx_->compression_level_set()) {
-      ops.set_compression_level(ctx_->compression_level());
-    }
-    ctx_->sent_initial_metadata_ = true;
-    call_->PerformOps(&ops);
-    call_->cq()->Pluck(&ops);
-  }
-
-  bool NextMessageSize(uint32_t* sz) {
-    int result = call_->max_receive_message_size();
-    *sz = (result > 0) ? result : UINT32_MAX;
-    return true;
-  }
-
-  bool Read(R* msg) {
-    grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> ops;
-    ops.RecvMessage(msg);
-    call_->PerformOps(&ops);
-    bool ok = call_->cq()->Pluck(&ops) && ops.got_message;
-    if (!ok) {
-      ctx_->MaybeMarkCancelledOnRead();
-    }
-    return ok;
-  }
-
-  bool Write(const W& msg, grpc::WriteOptions options) {
-    if (options.is_last_message()) {
-      options.set_buffer_hint();
-    }
-    if (!ctx_->pending_ops_.SendMessagePtr(&msg, options).ok()) {
-      return false;
-    }
-    if (!ctx_->sent_initial_metadata_) {
-      ctx_->pending_ops_.SendInitialMetadata(&ctx_->initial_metadata_,
-                                             ctx_->initial_metadata_flags());
-      if (ctx_->compression_level_set()) {
-        ctx_->pending_ops_.set_compression_level(ctx_->compression_level());
-      }
-      ctx_->sent_initial_metadata_ = true;
-    }
-    call_->PerformOps(&ctx_->pending_ops_);
-    // if this is the last message we defer the pluck until AFTER we start
-    // the trailing md op. This prevents hangs. See
-    // https://github.com/grpc/grpc/issues/11546
-    if (options.is_last_message()) {
-      ctx_->has_pending_ops_ = true;
-      return true;
-    }
-    ctx_->has_pending_ops_ = false;
-    return call_->cq()->Pluck(&ctx_->pending_ops_);
-  }
-
- private:
-  grpc::internal::Call* const call_;
-  grpc::ServerContext* const ctx_;
-};
-
-}  // namespace internal
-
-/// Synchronous (blocking) server-side API for a bidirectional
-/// streaming call, where the incoming message stream coming from the client has
-/// messages of type \a R, and the outgoing message streaming coming from
-/// the server has messages of type \a W.
-template <class W, class R>
-class ServerReaderWriter final : public ServerReaderWriterInterface<W, R> {
- public:
-  /// See the \a ServerStreamingInterface.SendInitialMetadata method
-  /// for semantics. Note that initial metadata will be affected by the
-  /// \a ServerContext associated with this call.
-  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
-
-  bool NextMessageSize(uint32_t* sz) override {
-    return body_.NextMessageSize(sz);
-  }
-
-  bool Read(R* msg) override { return body_.Read(msg); }
-
-  /// See the \a WriterInterface.Write(const W& msg, WriteOptions options)
-  /// method for semantics.
-  /// Side effect:
-  ///   Also sends initial metadata if not already sent (using the \a
-  ///   ServerContext associated with this call).
-  using internal::WriterInterface<W>::Write;
-  bool Write(const W& msg, grpc::WriteOptions options) override {
-    return body_.Write(msg, options);
-  }
-
- private:
-  internal::ServerReaderWriterBody<W, R> body_;
-
-  friend class internal::TemplatedBidiStreamingHandler<ServerReaderWriter<W, R>,
-                                                       false>;
-  ServerReaderWriter(grpc::internal::Call* call, grpc::ServerContext* ctx)
-      : body_(call, ctx) {}
-};
-
-/// A class to represent a flow-controlled unary call. This is something
-/// of a hybrid between conventional unary and streaming. This is invoked
-/// through a unary call on the client side, but the server responds to it
-/// as though it were a single-ping-pong streaming call. The server can use
-/// the \a NextMessageSize method to determine an upper-bound on the size of
-/// the message. A key difference relative to streaming: ServerUnaryStreamer
-/// must have exactly 1 Read and exactly 1 Write, in that order, to function
-/// correctly. Otherwise, the RPC is in error.
-template <class RequestType, class ResponseType>
-class ServerUnaryStreamer final
-    : public ServerReaderWriterInterface<ResponseType, RequestType> {
- public:
-  /// Block to send initial metadata to client.
-  /// Implicit input parameter:
-  ///    - the \a ServerContext associated with this call will be used for
-  ///      sending initial metadata.
-  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
-
-  /// Get an upper bound on the request message size from the client.
-  bool NextMessageSize(uint32_t* sz) override {
-    return body_.NextMessageSize(sz);
-  }
-
-  /// Read a message of type \a R into \a msg. Completion will be notified by \a
-  /// tag on the associated completion queue.
-  /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
-  /// should not be called concurrently with other streaming APIs
-  /// on the same stream. It is not meaningful to call it concurrently
-  /// with another \a ReaderInterface::Read on the same stream since reads on
-  /// the same stream are delivered in order.
-  ///
-  /// \param[out] msg Where to eventually store the read message.
-  /// \param[in] tag The tag identifying the operation.
-  bool Read(RequestType* request) override {
-    if (read_done_) {
-      return false;
-    }
-    read_done_ = true;
-    return body_.Read(request);
-  }
-
-  /// Block to write \a msg to the stream with WriteOptions \a options.
-  /// This is thread-safe with respect to \a ReaderInterface::Read
-  ///
-  /// \param msg The message to be written to the stream.
-  /// \param options The WriteOptions affecting the write operation.
-  ///
-  /// \return \a true on success, \a false when the stream has been closed.
-  using internal::WriterInterface<ResponseType>::Write;
-  bool Write(const ResponseType& response,
-             grpc::WriteOptions options) override {
-    if (write_done_ || !read_done_) {
-      return false;
-    }
-    write_done_ = true;
-    return body_.Write(response, options);
-  }
-
- private:
-  internal::ServerReaderWriterBody<ResponseType, RequestType> body_;
-  bool read_done_;
-  bool write_done_;
-
-  friend class internal::TemplatedBidiStreamingHandler<
-      ServerUnaryStreamer<RequestType, ResponseType>, true>;
-  ServerUnaryStreamer(grpc::internal::Call* call, grpc::ServerContext* ctx)
-      : body_(call, ctx), read_done_(false), write_done_(false) {}
-};
-
-/// A class to represent a flow-controlled server-side streaming call.
-/// This is something of a hybrid between server-side and bidi streaming.
-/// This is invoked through a server-side streaming call on the client side,
-/// but the server responds to it as though it were a bidi streaming call that
-/// must first have exactly 1 Read and then any number of Writes.
-template <class RequestType, class ResponseType>
-class ServerSplitStreamer final
-    : public ServerReaderWriterInterface<ResponseType, RequestType> {
- public:
-  /// Block to send initial metadata to client.
-  /// Implicit input parameter:
-  ///    - the \a ServerContext associated with this call will be used for
-  ///      sending initial metadata.
-  void SendInitialMetadata() override { body_.SendInitialMetadata(); }
-
-  /// Get an upper bound on the request message size from the client.
-  bool NextMessageSize(uint32_t* sz) override {
-    return body_.NextMessageSize(sz);
-  }
-
-  /// Read a message of type \a R into \a msg. Completion will be notified by \a
-  /// tag on the associated completion queue.
-  /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
-  /// should not be called concurrently with other streaming APIs
-  /// on the same stream. It is not meaningful to call it concurrently
-  /// with another \a ReaderInterface::Read on the same stream since reads on
-  /// the same stream are delivered in order.
-  ///
-  /// \param[out] msg Where to eventually store the read message.
-  /// \param[in] tag The tag identifying the operation.
-  bool Read(RequestType* request) override {
-    if (read_done_) {
-      return false;
-    }
-    read_done_ = true;
-    return body_.Read(request);
-  }
-
-  /// Block to write \a msg to the stream with WriteOptions \a options.
-  /// This is thread-safe with respect to \a ReaderInterface::Read
-  ///
-  /// \param msg The message to be written to the stream.
-  /// \param options The WriteOptions affecting the write operation.
-  ///
-  /// \return \a true on success, \a false when the stream has been closed.
-  using internal::WriterInterface<ResponseType>::Write;
-  bool Write(const ResponseType& response,
-             grpc::WriteOptions options) override {
-    return read_done_ && body_.Write(response, options);
-  }
-
- private:
-  internal::ServerReaderWriterBody<ResponseType, RequestType> body_;
-  bool read_done_;
-
-  friend class internal::TemplatedBidiStreamingHandler<
-      ServerSplitStreamer<RequestType, ResponseType>, false>;
-  ServerSplitStreamer(grpc::internal::Call* call, grpc::ServerContext* ctx)
-      : body_(call, ctx), read_done_(false) {}
-};
+namespace grpc
+{
+
+    namespace internal
+    {
+        /// Common interface for all synchronous client side streaming.
+        class ClientStreamingInterface
+        {
+        public:
+            virtual ~ClientStreamingInterface()
+            {
+            }
+
+            /// Block waiting until the stream finishes and a final status of the call is
+            /// available.
+            ///
+            /// It is appropriate to call this method exactly once when both:
+            ///   * the calling code (client-side) has no more message to send
+            ///     (this can be declared implicitly by calling this method, or
+            ///     explicitly through an earlier call to <i>WritesDone</i> method of the
+            ///     class in use, e.g. \a ClientWriterInterface::WritesDone or
+            ///     \a ClientReaderWriterInterface::WritesDone).
+            ///   * there are no more messages to be received from the server (which can
+            ///     be known implicitly, or explicitly from an earlier call to \a
+            ///     ReaderInterface::Read that returned "false").
+            ///
+            /// This function will return either:
+            /// - when all incoming messages have been read and the server has
+            ///   returned status.
+            /// - when the server has returned a non-OK status.
+            /// - OR when the call failed for some reason and the library generated a
+            ///   status.
+            ///
+            /// Return values:
+            ///   - \a Status contains the status code, message and details for the call
+            ///   - the \a ClientContext associated with this call is updated with
+            ///     possible trailing metadata sent from the server.
+            virtual grpc::Status Finish() = 0;
+        };
+
+        /// Common interface for all synchronous server side streaming.
+        class ServerStreamingInterface
+        {
+        public:
+            virtual ~ServerStreamingInterface()
+            {
+            }
+
+            /// Block to send initial metadata to client.
+            /// This call is optional, but if it is used, it cannot be used concurrently
+            /// with or after the \a Finish method.
+            ///
+            /// The initial metadata that will be sent to the client will be
+            /// taken from the \a ServerContext associated with the call.
+            virtual void SendInitialMetadata() = 0;
+        };
+
+        /// An interface that yields a sequence of messages of type \a R.
+        template<class R>
+        class ReaderInterface
+        {
+        public:
+            virtual ~ReaderInterface()
+            {
+            }
+
+            /// Get an upper bound on the next message size available for reading on this
+            /// stream.
+            virtual bool NextMessageSize(uint32_t* sz) = 0;
+
+            /// Block to read a message and parse to \a msg. Returns \a true on success.
+            /// This is thread-safe with respect to \a Write or \WritesDone methods on
+            /// the same stream. It should not be called concurrently with another \a
+            /// Read on the same stream as the order of delivery will not be defined.
+            ///
+            /// \param[out] msg The read message.
+            ///
+            /// \return \a false when there will be no more incoming messages, either
+            /// because the other side has called \a WritesDone() or the stream has failed
+            /// (or been cancelled).
+            virtual bool Read(R* msg) = 0;
+        };
+
+        /// An interface that can be fed a sequence of messages of type \a W.
+        template<class W>
+        class WriterInterface
+        {
+        public:
+            virtual ~WriterInterface()
+            {
+            }
+
+            /// Block to write \a msg to the stream with WriteOptions \a options.
+            /// This is thread-safe with respect to \a ReaderInterface::Read
+            ///
+            /// \param msg The message to be written to the stream.
+            /// \param options The WriteOptions affecting the write operation.
+            ///
+            /// \return \a true on success, \a false when the stream has been closed.
+            virtual bool Write(const W& msg, grpc::WriteOptions options) = 0;
+
+            /// Block to write \a msg to the stream with default write options.
+            /// This is thread-safe with respect to \a ReaderInterface::Read
+            ///
+            /// \param msg The message to be written to the stream.
+            ///
+            /// \return \a true on success, \a false when the stream has been closed.
+            inline bool Write(const W& msg)
+            {
+                return Write(msg, grpc::WriteOptions());
+            }
+
+            /// Write \a msg and coalesce it with the writing of trailing metadata, using
+            /// WriteOptions \a options.
+            ///
+            /// For client, WriteLast is equivalent of performing Write and WritesDone in
+            /// a single step. \a msg and trailing metadata are coalesced and sent on wire
+            /// by calling this function. For server, WriteLast buffers the \a msg.
+            /// The writing of \a msg is held until the service handler returns,
+            /// where \a msg and trailing metadata are coalesced and sent on wire.
+            /// Note that WriteLast can only buffer \a msg up to the flow control window
+            /// size. If \a msg size is larger than the window size, it will be sent on
+            /// wire without buffering.
+            ///
+            /// \param[in] msg The message to be written to the stream.
+            /// \param[in] options The WriteOptions to be used to write this message.
+            void WriteLast(const W& msg, grpc::WriteOptions options)
+            {
+                Write(msg, options.set_last_message());
+            }
+        };
+
+    }  // namespace internal
+
+    /// Client-side interface for streaming reads of message of type \a R.
+    template<class R>
+    class ClientReaderInterface : public internal::ClientStreamingInterface, public internal::ReaderInterface<R>
+    {
+    public:
+        /// Block to wait for initial metadata from server. The received metadata
+        /// can only be accessed after this call returns. Should only be called before
+        /// the first read. Calling this method is optional, and if it is not called
+        /// the metadata will be available in ClientContext after the first read.
+        virtual void WaitForInitialMetadata() = 0;
+    };
+
+    namespace internal
+    {
+        template<class R>
+        class ClientReaderFactory
+        {
+        public:
+            template<class W>
+            static ClientReader<R>* Create(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const W& request)
+            {
+                return new ClientReader<R>(channel, method, context, request);
+            }
+        };
+    }  // namespace internal
+
+    /// Synchronous (blocking) client-side API for doing server-streaming RPCs,
+    /// where the stream of messages coming from the server has messages
+    /// of type \a R.
+    template<class R>
+    class ClientReader final : public ClientReaderInterface<R>
+    {
+    public:
+        /// See the \a ClientStreamingInterface.WaitForInitialMetadata method for
+        /// semantics.
+        ///
+        //  Side effect:
+        ///   Once complete, the initial metadata read from
+        ///   the server will be accessible through the \a ClientContext used to
+        ///   construct this object.
+        void WaitForInitialMetadata() override
+        {
+            GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
+            ops.RecvInitialMetadata(context_);
+            call_.PerformOps(&ops);
+            cq_.Pluck(&ops);  /// status ignored
+        }
+
+        bool NextMessageSize(uint32_t* sz) override
+        {
+            int result = call_.max_receive_message_size();
+            *sz = (result > 0) ? result : UINT32_MAX;
+            return true;
+        }
+
+        /// See the \a ReaderInterface.Read method for semantics.
+        /// Side effect:
+        ///   This also receives initial metadata from the server, if not
+        ///   already received (if initial metadata is received, it can be then
+        ///   accessed through the \a ClientContext associated with this call).
+        bool Read(R* msg) override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpRecvMessage<R>>
+                ops;
+            if (!context_->initial_metadata_received_)
+            {
+                ops.RecvInitialMetadata(context_);
+            }
+            ops.RecvMessage(msg);
+            call_.PerformOps(&ops);
+            return cq_.Pluck(&ops) && ops.got_message;
+        }
+
+        /// See the \a ClientStreamingInterface.Finish method for semantics.
+        ///
+        /// Side effect:
+        ///   The \a ClientContext associated with this call is updated with
+        ///   possible metadata received from the server.
+        grpc::Status Finish() override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpClientRecvStatus>
+                ops;
+            if (!context_->initial_metadata_received_)
+            {
+                ops.RecvInitialMetadata(context_);
+            }
+            grpc::Status status;
+            ops.ClientRecvStatus(context_, &status);
+            call_.PerformOps(&ops);
+            GPR_CODEGEN_ASSERT(cq_.Pluck(&ops));
+            return status;
+        }
+
+    private:
+        friend class internal::ClientReaderFactory<R>;
+        grpc::ClientContext* context_;
+        grpc::CompletionQueue cq_;
+        grpc::internal::Call call_;
+
+        /// Block to create a stream and write the initial metadata and \a request
+        /// out. Note that \a context will be used to fill in custom initial
+        /// metadata used to send to the server when starting the call.
+        template<class W>
+        ClientReader(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, const W& request) :
+            context_(context),
+            cq_(grpc_completion_queue_attributes{
+                GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING, nullptr}),  // Pluckable cq
+            call_(channel->CreateCall(method, context, &cq_))
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose>
+                ops;
+            ops.SendInitialMetadata(&context->send_initial_metadata_, context->initial_metadata_flags());
+            // TODO(ctiller): don't assert
+            GPR_CODEGEN_ASSERT(ops.SendMessagePtr(&request).ok());
+            ops.ClientSendClose();
+            call_.PerformOps(&ops);
+            cq_.Pluck(&ops);
+        }
+    };
+
+    /// Client-side interface for streaming writes of message type \a W.
+    template<class W>
+    class ClientWriterInterface : public internal::ClientStreamingInterface, public internal::WriterInterface<W>
+    {
+    public:
+        /// Half close writing from the client. (signal that the stream of messages
+        /// coming from the client is complete).
+        /// Blocks until currently-pending writes are completed.
+        /// Thread safe with respect to \a ReaderInterface::Read operations only
+        ///
+        /// \return Whether the writes were successful.
+        virtual bool WritesDone() = 0;
+    };
+
+    namespace internal
+    {
+        template<class W>
+        class ClientWriterFactory
+        {
+        public:
+            template<class R>
+            static ClientWriter<W>* Create(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, R* response)
+            {
+                return new ClientWriter<W>(channel, method, context, response);
+            }
+        };
+    }  // namespace internal
+
+    /// Synchronous (blocking) client-side API for doing client-streaming RPCs,
+    /// where the outgoing message stream coming from the client has messages of
+    /// type \a W.
+    template<class W>
+    class ClientWriter : public ClientWriterInterface<W>
+    {
+    public:
+        /// See the \a ClientStreamingInterface.WaitForInitialMetadata method for
+        /// semantics.
+        ///
+        //  Side effect:
+        ///   Once complete, the initial metadata read from the server will be
+        ///   accessible through the \a ClientContext used to construct this object.
+        void WaitForInitialMetadata()
+        {
+            GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
+            ops.RecvInitialMetadata(context_);
+            call_.PerformOps(&ops);
+            cq_.Pluck(&ops);  // status ignored
+        }
+
+        /// See the WriterInterface.Write(const W& msg, WriteOptions options) method
+        /// for semantics.
+        ///
+        /// Side effect:
+        ///   Also sends initial metadata if not already sent (using the
+        ///   \a ClientContext associated with this call).
+        using internal::WriterInterface<W>::Write;
+        bool Write(const W& msg, grpc::WriteOptions options) override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose>
+                ops;
+
+            if (options.is_last_message())
+            {
+                options.set_buffer_hint();
+                ops.ClientSendClose();
+            }
+            if (context_->initial_metadata_corked_)
+            {
+                ops.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                context_->set_initial_metadata_corked(false);
+            }
+            if (!ops.SendMessagePtr(&msg, options).ok())
+            {
+                return false;
+            }
+
+            call_.PerformOps(&ops);
+            return cq_.Pluck(&ops);
+        }
+
+        bool WritesDone() override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpClientSendClose> ops;
+            ops.ClientSendClose();
+            call_.PerformOps(&ops);
+            return cq_.Pluck(&ops);
+        }
+
+        /// See the ClientStreamingInterface.Finish method for semantics.
+        /// Side effects:
+        ///   - Also receives initial metadata if not already received.
+        ///   - Attempts to fill in the \a response parameter passed
+        ///     to the constructor of this instance with the response
+        ///     message from the server.
+        grpc::Status Finish() override
+        {
+            grpc::Status status;
+            if (!context_->initial_metadata_received_)
+            {
+                finish_ops_.RecvInitialMetadata(context_);
+            }
+            finish_ops_.ClientRecvStatus(context_, &status);
+            call_.PerformOps(&finish_ops_);
+            GPR_CODEGEN_ASSERT(cq_.Pluck(&finish_ops_));
+            return status;
+        }
+
+    private:
+        friend class internal::ClientWriterFactory<W>;
+
+        /// Block to create a stream (i.e. send request headers and other initial
+        /// metadata to the server). Note that \a context will be used to fill
+        /// in custom initial metadata. \a response will be filled in with the
+        /// single expected response message from the server upon a successful
+        /// call to the \a Finish method of this instance.
+        template<class R>
+        ClientWriter(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context, R* response) :
+            context_(context),
+            cq_(grpc_completion_queue_attributes{
+                GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING, nullptr}),  // Pluckable cq
+            call_(channel->CreateCall(method, context, &cq_))
+        {
+            finish_ops_.RecvMessage(response);
+            finish_ops_.AllowNoMessage();
+
+            if (!context_->initial_metadata_corked_)
+            {
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+                ops.SendInitialMetadata(&context->send_initial_metadata_, context->initial_metadata_flags());
+                call_.PerformOps(&ops);
+                cq_.Pluck(&ops);
+            }
+        }
+
+        grpc::ClientContext* context_;
+        grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpGenericRecvMessage, grpc::internal::CallOpClientRecvStatus>
+            finish_ops_;
+        grpc::CompletionQueue cq_;
+        grpc::internal::Call call_;
+    };
+
+    /// Client-side interface for bi-directional streaming with
+    /// client-to-server stream messages of type \a W and
+    /// server-to-client stream messages of type \a R.
+    template<class W, class R>
+    class ClientReaderWriterInterface : public internal::ClientStreamingInterface, public internal::WriterInterface<W>, public internal::ReaderInterface<R>
+    {
+    public:
+        /// Block to wait for initial metadata from server. The received metadata
+        /// can only be accessed after this call returns. Should only be called before
+        /// the first read. Calling this method is optional, and if it is not called
+        /// the metadata will be available in ClientContext after the first read.
+        virtual void WaitForInitialMetadata() = 0;
+
+        /// Half close writing from the client. (signal that the stream of messages
+        /// coming from the client is complete).
+        /// Blocks until currently-pending writes are completed.
+        /// Thread-safe with respect to \a ReaderInterface::Read
+        ///
+        /// \return Whether the writes were successful.
+        virtual bool WritesDone() = 0;
+    };
+
+    namespace internal
+    {
+        template<class W, class R>
+        class ClientReaderWriterFactory
+        {
+        public:
+            static ClientReaderWriter<W, R>* Create(
+                grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context
+            )
+            {
+                return new ClientReaderWriter<W, R>(channel, method, context);
+            }
+        };
+    }  // namespace internal
+
+    /// Synchronous (blocking) client-side API for bi-directional streaming RPCs,
+    /// where the outgoing message stream coming from the client has messages of
+    /// type \a W, and the incoming messages stream coming from the server has
+    /// messages of type \a R.
+    template<class W, class R>
+    class ClientReaderWriter final : public ClientReaderWriterInterface<W, R>
+    {
+    public:
+        /// Block waiting to read initial metadata from the server.
+        /// This call is optional, but if it is used, it cannot be used concurrently
+        /// with or after the \a Finish method.
+        ///
+        /// Once complete, the initial metadata read from the server will be
+        /// accessible through the \a ClientContext used to construct this object.
+        void WaitForInitialMetadata() override
+        {
+            GPR_CODEGEN_ASSERT(!context_->initial_metadata_received_);
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata> ops;
+            ops.RecvInitialMetadata(context_);
+            call_.PerformOps(&ops);
+            cq_.Pluck(&ops);  // status ignored
+        }
+
+        bool NextMessageSize(uint32_t* sz) override
+        {
+            int result = call_.max_receive_message_size();
+            *sz = (result > 0) ? result : UINT32_MAX;
+            return true;
+        }
+
+        /// See the \a ReaderInterface.Read method for semantics.
+        /// Side effect:
+        ///   Also receives initial metadata if not already received (updates the \a
+        ///   ClientContext associated with this call in that case).
+        bool Read(R* msg) override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpRecvMessage<R>>
+                ops;
+            if (!context_->initial_metadata_received_)
+            {
+                ops.RecvInitialMetadata(context_);
+            }
+            ops.RecvMessage(msg);
+            call_.PerformOps(&ops);
+            return cq_.Pluck(&ops) && ops.got_message;
+        }
+
+        /// See the \a WriterInterface.Write method for semantics.
+        ///
+        /// Side effect:
+        ///   Also sends initial metadata if not already sent (using the
+        ///   \a ClientContext associated with this call to fill in values).
+        using internal::WriterInterface<W>::Write;
+        bool Write(const W& msg, grpc::WriteOptions options) override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpClientSendClose>
+                ops;
+
+            if (options.is_last_message())
+            {
+                options.set_buffer_hint();
+                ops.ClientSendClose();
+            }
+            if (context_->initial_metadata_corked_)
+            {
+                ops.SendInitialMetadata(&context_->send_initial_metadata_, context_->initial_metadata_flags());
+                context_->set_initial_metadata_corked(false);
+            }
+            if (!ops.SendMessagePtr(&msg, options).ok())
+            {
+                return false;
+            }
+
+            call_.PerformOps(&ops);
+            return cq_.Pluck(&ops);
+        }
+
+        bool WritesDone() override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpClientSendClose> ops;
+            ops.ClientSendClose();
+            call_.PerformOps(&ops);
+            return cq_.Pluck(&ops);
+        }
+
+        /// See the ClientStreamingInterface.Finish method for semantics.
+        ///
+        /// Side effect:
+        ///   - the \a ClientContext associated with this call is updated with
+        ///     possible trailing metadata sent from the server.
+        grpc::Status Finish() override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvInitialMetadata, grpc::internal::CallOpClientRecvStatus>
+                ops;
+            if (!context_->initial_metadata_received_)
+            {
+                ops.RecvInitialMetadata(context_);
+            }
+            grpc::Status status;
+            ops.ClientRecvStatus(context_, &status);
+            call_.PerformOps(&ops);
+            GPR_CODEGEN_ASSERT(cq_.Pluck(&ops));
+            return status;
+        }
+
+    private:
+        friend class internal::ClientReaderWriterFactory<W, R>;
+
+        grpc::ClientContext* context_;
+        grpc::CompletionQueue cq_;
+        grpc::internal::Call call_;
+
+        /// Block to create a stream and write the initial metadata and \a request
+        /// out. Note that \a context will be used to fill in custom initial metadata
+        /// used to send to the server when starting the call.
+        ClientReaderWriter(grpc::ChannelInterface* channel, const grpc::internal::RpcMethod& method, grpc::ClientContext* context) :
+            context_(context),
+            cq_(grpc_completion_queue_attributes{
+                GRPC_CQ_CURRENT_VERSION, GRPC_CQ_PLUCK, GRPC_CQ_DEFAULT_POLLING, nullptr}),  // Pluckable cq
+            call_(channel->CreateCall(method, context, &cq_))
+        {
+            if (!context_->initial_metadata_corked_)
+            {
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+                ops.SendInitialMetadata(&context->send_initial_metadata_, context->initial_metadata_flags());
+                call_.PerformOps(&ops);
+                cq_.Pluck(&ops);
+            }
+        }
+    };
+
+    /// Server-side interface for streaming reads of message of type \a R.
+    template<class R>
+    class ServerReaderInterface : public internal::ServerStreamingInterface, public internal::ReaderInterface<R>
+    {
+    };
+
+    /// Synchronous (blocking) server-side API for doing client-streaming RPCs,
+    /// where the incoming message stream coming from the client has messages of
+    /// type \a R.
+    template<class R>
+    class ServerReader final : public ServerReaderInterface<R>
+    {
+    public:
+        /// See the \a ServerStreamingInterface.SendInitialMetadata method
+        /// for semantics. Note that initial metadata will be affected by the
+        /// \a ServerContext associated with this call.
+        void SendInitialMetadata() override
+        {
+            GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+            ops.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+            if (ctx_->compression_level_set())
+            {
+                ops.set_compression_level(ctx_->compression_level());
+            }
+            ctx_->sent_initial_metadata_ = true;
+            call_->PerformOps(&ops);
+            call_->cq()->Pluck(&ops);
+        }
+
+        bool NextMessageSize(uint32_t* sz) override
+        {
+            int result = call_->max_receive_message_size();
+            *sz = (result > 0) ? result : UINT32_MAX;
+            return true;
+        }
+
+        bool Read(R* msg) override
+        {
+            grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> ops;
+            ops.RecvMessage(msg);
+            call_->PerformOps(&ops);
+            bool ok = call_->cq()->Pluck(&ops) && ops.got_message;
+            if (!ok)
+            {
+                ctx_->MaybeMarkCancelledOnRead();
+            }
+            return ok;
+        }
+
+    private:
+        grpc::internal::Call* const call_;
+        ServerContext* const ctx_;
+
+        template<class ServiceType, class RequestType, class ResponseType>
+        friend class internal::ClientStreamingHandler;
+
+        ServerReader(grpc::internal::Call* call, grpc::ServerContext* ctx) :
+            call_(call),
+            ctx_(ctx)
+        {
+        }
+    };
+
+    /// Server-side interface for streaming writes of message of type \a W.
+    template<class W>
+    class ServerWriterInterface : public internal::ServerStreamingInterface, public internal::WriterInterface<W>
+    {
+    };
+
+    /// Synchronous (blocking) server-side API for doing for doing a
+    /// server-streaming RPCs, where the outgoing message stream coming from the
+    /// server has messages of type \a W.
+    template<class W>
+    class ServerWriter final : public ServerWriterInterface<W>
+    {
+    public:
+        /// See the \a ServerStreamingInterface.SendInitialMetadata method
+        /// for semantics.
+        /// Note that initial metadata will be affected by the
+        /// \a ServerContext associated with this call.
+        void SendInitialMetadata() override
+        {
+            GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+            grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+            ops.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+            if (ctx_->compression_level_set())
+            {
+                ops.set_compression_level(ctx_->compression_level());
+            }
+            ctx_->sent_initial_metadata_ = true;
+            call_->PerformOps(&ops);
+            call_->cq()->Pluck(&ops);
+        }
+
+        /// See the \a WriterInterface.Write method for semantics.
+        ///
+        /// Side effect:
+        ///   Also sends initial metadata if not already sent (using the
+        ///   \a ClientContext associated with this call to fill in values).
+        using internal::WriterInterface<W>::Write;
+        bool Write(const W& msg, grpc::WriteOptions options) override
+        {
+            if (options.is_last_message())
+            {
+                options.set_buffer_hint();
+            }
+
+            if (!ctx_->pending_ops_.SendMessagePtr(&msg, options).ok())
+            {
+                return false;
+            }
+            if (!ctx_->sent_initial_metadata_)
+            {
+                ctx_->pending_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                if (ctx_->compression_level_set())
+                {
+                    ctx_->pending_ops_.set_compression_level(ctx_->compression_level());
+                }
+                ctx_->sent_initial_metadata_ = true;
+            }
+            call_->PerformOps(&ctx_->pending_ops_);
+            // if this is the last message we defer the pluck until AFTER we start
+            // the trailing md op. This prevents hangs. See
+            // https://github.com/grpc/grpc/issues/11546
+            if (options.is_last_message())
+            {
+                ctx_->has_pending_ops_ = true;
+                return true;
+            }
+            ctx_->has_pending_ops_ = false;
+            return call_->cq()->Pluck(&ctx_->pending_ops_);
+        }
+
+    private:
+        grpc::internal::Call* const call_;
+        grpc::ServerContext* const ctx_;
+
+        template<class ServiceType, class RequestType, class ResponseType>
+        friend class internal::ServerStreamingHandler;
+
+        ServerWriter(grpc::internal::Call* call, grpc::ServerContext* ctx) :
+            call_(call),
+            ctx_(ctx)
+        {
+        }
+    };
+
+    /// Server-side interface for bi-directional streaming.
+    template<class W, class R>
+    class ServerReaderWriterInterface : public internal::ServerStreamingInterface, public internal::WriterInterface<W>, public internal::ReaderInterface<R>
+    {
+    };
+
+    /// Actual implementation of bi-directional streaming
+    namespace internal
+    {
+        template<class W, class R>
+        class ServerReaderWriterBody final
+        {
+        public:
+            ServerReaderWriterBody(grpc::internal::Call* call, grpc::ServerContext* ctx) :
+                call_(call),
+                ctx_(ctx)
+            {
+            }
+
+            void SendInitialMetadata()
+            {
+                GPR_CODEGEN_ASSERT(!ctx_->sent_initial_metadata_);
+
+                grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata> ops;
+                ops.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                if (ctx_->compression_level_set())
+                {
+                    ops.set_compression_level(ctx_->compression_level());
+                }
+                ctx_->sent_initial_metadata_ = true;
+                call_->PerformOps(&ops);
+                call_->cq()->Pluck(&ops);
+            }
+
+            bool NextMessageSize(uint32_t* sz)
+            {
+                int result = call_->max_receive_message_size();
+                *sz = (result > 0) ? result : UINT32_MAX;
+                return true;
+            }
+
+            bool Read(R* msg)
+            {
+                grpc::internal::CallOpSet<grpc::internal::CallOpRecvMessage<R>> ops;
+                ops.RecvMessage(msg);
+                call_->PerformOps(&ops);
+                bool ok = call_->cq()->Pluck(&ops) && ops.got_message;
+                if (!ok)
+                {
+                    ctx_->MaybeMarkCancelledOnRead();
+                }
+                return ok;
+            }
+
+            bool Write(const W& msg, grpc::WriteOptions options)
+            {
+                if (options.is_last_message())
+                {
+                    options.set_buffer_hint();
+                }
+                if (!ctx_->pending_ops_.SendMessagePtr(&msg, options).ok())
+                {
+                    return false;
+                }
+                if (!ctx_->sent_initial_metadata_)
+                {
+                    ctx_->pending_ops_.SendInitialMetadata(&ctx_->initial_metadata_, ctx_->initial_metadata_flags());
+                    if (ctx_->compression_level_set())
+                    {
+                        ctx_->pending_ops_.set_compression_level(ctx_->compression_level());
+                    }
+                    ctx_->sent_initial_metadata_ = true;
+                }
+                call_->PerformOps(&ctx_->pending_ops_);
+                // if this is the last message we defer the pluck until AFTER we start
+                // the trailing md op. This prevents hangs. See
+                // https://github.com/grpc/grpc/issues/11546
+                if (options.is_last_message())
+                {
+                    ctx_->has_pending_ops_ = true;
+                    return true;
+                }
+                ctx_->has_pending_ops_ = false;
+                return call_->cq()->Pluck(&ctx_->pending_ops_);
+            }
+
+        private:
+            grpc::internal::Call* const call_;
+            grpc::ServerContext* const ctx_;
+        };
+
+    }  // namespace internal
+
+    /// Synchronous (blocking) server-side API for a bidirectional
+    /// streaming call, where the incoming message stream coming from the client has
+    /// messages of type \a R, and the outgoing message streaming coming from
+    /// the server has messages of type \a W.
+    template<class W, class R>
+    class ServerReaderWriter final : public ServerReaderWriterInterface<W, R>
+    {
+    public:
+        /// See the \a ServerStreamingInterface.SendInitialMetadata method
+        /// for semantics. Note that initial metadata will be affected by the
+        /// \a ServerContext associated with this call.
+        void SendInitialMetadata() override
+        {
+            body_.SendInitialMetadata();
+        }
+
+        bool NextMessageSize(uint32_t* sz) override
+        {
+            return body_.NextMessageSize(sz);
+        }
+
+        bool Read(R* msg) override
+        {
+            return body_.Read(msg);
+        }
+
+        /// See the \a WriterInterface.Write(const W& msg, WriteOptions options)
+        /// method for semantics.
+        /// Side effect:
+        ///   Also sends initial metadata if not already sent (using the \a
+        ///   ServerContext associated with this call).
+        using internal::WriterInterface<W>::Write;
+        bool Write(const W& msg, grpc::WriteOptions options) override
+        {
+            return body_.Write(msg, options);
+        }
+
+    private:
+        internal::ServerReaderWriterBody<W, R> body_;
+
+        friend class internal::TemplatedBidiStreamingHandler<ServerReaderWriter<W, R>, false>;
+        ServerReaderWriter(grpc::internal::Call* call, grpc::ServerContext* ctx) :
+            body_(call, ctx)
+        {
+        }
+    };
+
+    /// A class to represent a flow-controlled unary call. This is something
+    /// of a hybrid between conventional unary and streaming. This is invoked
+    /// through a unary call on the client side, but the server responds to it
+    /// as though it were a single-ping-pong streaming call. The server can use
+    /// the \a NextMessageSize method to determine an upper-bound on the size of
+    /// the message. A key difference relative to streaming: ServerUnaryStreamer
+    /// must have exactly 1 Read and exactly 1 Write, in that order, to function
+    /// correctly. Otherwise, the RPC is in error.
+    template<class RequestType, class ResponseType>
+    class ServerUnaryStreamer final : public ServerReaderWriterInterface<ResponseType, RequestType>
+    {
+    public:
+        /// Block to send initial metadata to client.
+        /// Implicit input parameter:
+        ///    - the \a ServerContext associated with this call will be used for
+        ///      sending initial metadata.
+        void SendInitialMetadata() override
+        {
+            body_.SendInitialMetadata();
+        }
+
+        /// Get an upper bound on the request message size from the client.
+        bool NextMessageSize(uint32_t* sz) override
+        {
+            return body_.NextMessageSize(sz);
+        }
+
+        /// Read a message of type \a R into \a msg. Completion will be notified by \a
+        /// tag on the associated completion queue.
+        /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
+        /// should not be called concurrently with other streaming APIs
+        /// on the same stream. It is not meaningful to call it concurrently
+        /// with another \a ReaderInterface::Read on the same stream since reads on
+        /// the same stream are delivered in order.
+        ///
+        /// \param[out] msg Where to eventually store the read message.
+        /// \param[in] tag The tag identifying the operation.
+        bool Read(RequestType* request) override
+        {
+            if (read_done_)
+            {
+                return false;
+            }
+            read_done_ = true;
+            return body_.Read(request);
+        }
+
+        /// Block to write \a msg to the stream with WriteOptions \a options.
+        /// This is thread-safe with respect to \a ReaderInterface::Read
+        ///
+        /// \param msg The message to be written to the stream.
+        /// \param options The WriteOptions affecting the write operation.
+        ///
+        /// \return \a true on success, \a false when the stream has been closed.
+        using internal::WriterInterface<ResponseType>::Write;
+        bool Write(const ResponseType& response, grpc::WriteOptions options) override
+        {
+            if (write_done_ || !read_done_)
+            {
+                return false;
+            }
+            write_done_ = true;
+            return body_.Write(response, options);
+        }
+
+    private:
+        internal::ServerReaderWriterBody<ResponseType, RequestType> body_;
+        bool read_done_;
+        bool write_done_;
+
+        friend class internal::TemplatedBidiStreamingHandler<
+            ServerUnaryStreamer<RequestType, ResponseType>,
+            true>;
+        ServerUnaryStreamer(grpc::internal::Call* call, grpc::ServerContext* ctx) :
+            body_(call, ctx),
+            read_done_(false),
+            write_done_(false)
+        {
+        }
+    };
+
+    /// A class to represent a flow-controlled server-side streaming call.
+    /// This is something of a hybrid between server-side and bidi streaming.
+    /// This is invoked through a server-side streaming call on the client side,
+    /// but the server responds to it as though it were a bidi streaming call that
+    /// must first have exactly 1 Read and then any number of Writes.
+    template<class RequestType, class ResponseType>
+    class ServerSplitStreamer final : public ServerReaderWriterInterface<ResponseType, RequestType>
+    {
+    public:
+        /// Block to send initial metadata to client.
+        /// Implicit input parameter:
+        ///    - the \a ServerContext associated with this call will be used for
+        ///      sending initial metadata.
+        void SendInitialMetadata() override
+        {
+            body_.SendInitialMetadata();
+        }
+
+        /// Get an upper bound on the request message size from the client.
+        bool NextMessageSize(uint32_t* sz) override
+        {
+            return body_.NextMessageSize(sz);
+        }
+
+        /// Read a message of type \a R into \a msg. Completion will be notified by \a
+        /// tag on the associated completion queue.
+        /// This is thread-safe with respect to \a Write or \a WritesDone methods. It
+        /// should not be called concurrently with other streaming APIs
+        /// on the same stream. It is not meaningful to call it concurrently
+        /// with another \a ReaderInterface::Read on the same stream since reads on
+        /// the same stream are delivered in order.
+        ///
+        /// \param[out] msg Where to eventually store the read message.
+        /// \param[in] tag The tag identifying the operation.
+        bool Read(RequestType* request) override
+        {
+            if (read_done_)
+            {
+                return false;
+            }
+            read_done_ = true;
+            return body_.Read(request);
+        }
+
+        /// Block to write \a msg to the stream with WriteOptions \a options.
+        /// This is thread-safe with respect to \a ReaderInterface::Read
+        ///
+        /// \param msg The message to be written to the stream.
+        /// \param options The WriteOptions affecting the write operation.
+        ///
+        /// \return \a true on success, \a false when the stream has been closed.
+        using internal::WriterInterface<ResponseType>::Write;
+        bool Write(const ResponseType& response, grpc::WriteOptions options) override
+        {
+            return read_done_ && body_.Write(response, options);
+        }
+
+    private:
+        internal::ServerReaderWriterBody<ResponseType, RequestType> body_;
+        bool read_done_;
+
+        friend class internal::TemplatedBidiStreamingHandler<
+            ServerSplitStreamer<RequestType, ResponseType>,
+            false>;
+        ServerSplitStreamer(grpc::internal::Call* call, grpc::ServerContext* ctx) :
+            body_(call, ctx),
+            read_done_(false)
+        {
+        }
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/time.h b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/time.h
index f2021f5..5fa898e 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/codegen/time.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/codegen/time.h
@@ -26,65 +26,80 @@
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpcpp/impl/codegen/config.h>
 
-namespace grpc {
-
-/** If you are trying to use CompletionQueue::AsyncNext with a time class that
-    isn't either gpr_timespec or std::chrono::system_clock::time_point, you
-    will most likely be looking at this comment as your compiler will have
-    fired an error below. In order to fix this issue, you have two potential
-    solutions:
-
-      1. Use gpr_timespec or std::chrono::system_clock::time_point instead
-      2. Specialize the TimePoint class with whichever time class that you
-         want to use here. See below for two examples of how to do this.
- */
-template <typename T>
-class TimePoint {
- public:
-  // If you see the error with methods below, you may need either
-  // i) using the existing types having a conversion class such as
-  // gpr_timespec and std::chrono::system_clock::time_point or
-  // ii) writing a new TimePoint<YourType> to address your case.
-  TimePoint(const T& /*time*/) = delete;
-  gpr_timespec raw_time() = delete;
-};
-
-template <>
-class TimePoint<gpr_timespec> {
- public:
-  /* NOLINTNEXTLINE(google-explicit-constructor) */
-  TimePoint(const gpr_timespec& time) : time_(time) {}
-  gpr_timespec raw_time() { return time_; }
-
- private:
-  gpr_timespec time_;
-};
+namespace grpc
+{
+
+    /** If you are trying to use CompletionQueue::AsyncNext with a time class that
+        isn't either gpr_timespec or std::chrono::system_clock::time_point, you
+        will most likely be looking at this comment as your compiler will have
+        fired an error below. In order to fix this issue, you have two potential
+        solutions:
+
+          1. Use gpr_timespec or std::chrono::system_clock::time_point instead
+          2. Specialize the TimePoint class with whichever time class that you
+             want to use here. See below for two examples of how to do this.
+     */
+    template<typename T>
+    class TimePoint
+    {
+    public:
+        // If you see the error with methods below, you may need either
+        // i) using the existing types having a conversion class such as
+        // gpr_timespec and std::chrono::system_clock::time_point or
+        // ii) writing a new TimePoint<YourType> to address your case.
+        TimePoint(const T& /*time*/) = delete;
+        gpr_timespec raw_time() = delete;
+    };
+
+    template<>
+    class TimePoint<gpr_timespec>
+    {
+    public:
+        /* NOLINTNEXTLINE(google-explicit-constructor) */
+        TimePoint(const gpr_timespec& time) :
+            time_(time)
+        {
+        }
+        gpr_timespec raw_time()
+        {
+            return time_;
+        }
+
+    private:
+        gpr_timespec time_;
+    };
 
 }  // namespace grpc
 
-namespace grpc {
-
-// from and to should be absolute time.
-void Timepoint2Timespec(const std::chrono::system_clock::time_point& from,
-                        gpr_timespec* to);
-void TimepointHR2Timespec(
-    const std::chrono::high_resolution_clock::time_point& from,
-    gpr_timespec* to);
-
-std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t);
-
-template <>
-class TimePoint<std::chrono::system_clock::time_point> {
- public:
-  /* NOLINTNEXTLINE(google-explicit-constructor) */
-  TimePoint(const std::chrono::system_clock::time_point& time) {
-    Timepoint2Timespec(time, &time_);
-  }
-  gpr_timespec raw_time() const { return time_; }
-
- private:
-  gpr_timespec time_;
-};
+namespace grpc
+{
+
+    // from and to should be absolute time.
+    void Timepoint2Timespec(const std::chrono::system_clock::time_point& from, gpr_timespec* to);
+    void TimepointHR2Timespec(
+        const std::chrono::high_resolution_clock::time_point& from,
+        gpr_timespec* to
+    );
+
+    std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t);
+
+    template<>
+    class TimePoint<std::chrono::system_clock::time_point>
+    {
+    public:
+        /* NOLINTNEXTLINE(google-explicit-constructor) */
+        TimePoint(const std::chrono::system_clock::time_point& time)
+        {
+            Timepoint2Timespec(time, &time_);
+        }
+        gpr_timespec raw_time() const
+        {
+            return time_;
+        }
+
+    private:
+        gpr_timespec time_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/grpc_library.h b/CAPI/cpp/grpc/include/grpcpp/impl/grpc_library.h
index 0afca8e..6c8bacf 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/grpc_library.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/grpc_library.h
@@ -26,35 +26,51 @@
 #include <grpcpp/impl/codegen/core_codegen.h>
 #include <grpcpp/impl/codegen/grpc_library.h>  // IWYU pragma: export
 
-namespace grpc {
-
-namespace internal {
-class GrpcLibrary final : public GrpcLibraryInterface {
- public:
-  void init() override { grpc_init(); }
-  void shutdown() override { grpc_shutdown(); }
-};
-
-/// Instantiating this class ensures the proper initialization of gRPC.
-class GrpcLibraryInitializer final {
- public:
-  GrpcLibraryInitializer() {
-    if (grpc::g_glip == nullptr) {
-      static auto* const g_gli = new GrpcLibrary();
-      grpc::g_glip = g_gli;
-    }
-    if (grpc::g_core_codegen_interface == nullptr) {
-      static auto* const g_core_codegen = new CoreCodegen();
-      grpc::g_core_codegen_interface = g_core_codegen;
-    }
-  }
-
-  /// A no-op method to force the linker to reference this class, which will
-  /// take care of initializing and shutting down the gRPC runtime.
-  int summon() { return 0; }
-};
-
-}  // namespace internal
+namespace grpc
+{
+
+    namespace internal
+    {
+        class GrpcLibrary final : public GrpcLibraryInterface
+        {
+        public:
+            void init() override
+            {
+                grpc_init();
+            }
+            void shutdown() override
+            {
+                grpc_shutdown();
+            }
+        };
+
+        /// Instantiating this class ensures the proper initialization of gRPC.
+        class GrpcLibraryInitializer final
+        {
+        public:
+            GrpcLibraryInitializer()
+            {
+                if (grpc::g_glip == nullptr)
+                {
+                    static auto* const g_gli = new GrpcLibrary();
+                    grpc::g_glip = g_gli;
+                }
+                if (grpc::g_core_codegen_interface == nullptr)
+                {
+                    static auto* const g_core_codegen = new CoreCodegen();
+                    grpc::g_core_codegen_interface = g_core_codegen;
+                }
+            }
+
+            /// A no-op method to force the linker to reference this class, which will
+            /// take care of initializing and shutting down the gRPC runtime.
+            int summon()
+            {
+                return 0;
+            }
+        };
+
+    }  // namespace internal
 }  // namespace grpc
 
 #endif  // GRPCPP_IMPL_GRPC_LIBRARY_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_option.h b/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_option.h
index c8f047b..8650f23 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_option.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_option.h
@@ -25,18 +25,23 @@
 #include <grpcpp/impl/server_builder_plugin.h>
 #include <grpcpp/support/channel_arguments.h>
 
-namespace grpc {
+namespace grpc
+{
 
-/// Interface to pass an option to a \a ServerBuilder.
-class ServerBuilderOption {
- public:
-  virtual ~ServerBuilderOption() {}
-  /// Alter the \a ChannelArguments used to create the gRPC server.
-  virtual void UpdateArguments(grpc::ChannelArguments* args) = 0;
-  /// Alter the ServerBuilderPlugin map that will be added into ServerBuilder.
-  virtual void UpdatePlugins(
-      std::vector<std::unique_ptr<grpc::ServerBuilderPlugin>>* plugins) = 0;
-};
+    /// Interface to pass an option to a \a ServerBuilder.
+    class ServerBuilderOption
+    {
+    public:
+        virtual ~ServerBuilderOption()
+        {
+        }
+        /// Alter the \a ChannelArguments used to create the gRPC server.
+        virtual void UpdateArguments(grpc::ChannelArguments* args) = 0;
+        /// Alter the ServerBuilderPlugin map that will be added into ServerBuilder.
+        virtual void UpdatePlugins(
+            std::vector<std::unique_ptr<grpc::ServerBuilderPlugin>>* plugins
+        ) = 0;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_plugin.h b/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_plugin.h
index e5bb058..045c53a 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_plugin.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/server_builder_plugin.h
@@ -24,42 +24,56 @@
 #include <grpcpp/support/channel_arguments.h>
 #include <grpcpp/support/config.h>
 
-namespace grpc {
+namespace grpc
+{
 
-class ServerBuilder;
-class ServerInitializer;
+    class ServerBuilder;
+    class ServerInitializer;
 
-/// This interface is meant for internal usage only. Implementations of this
-/// interface should add themselves to a \a ServerBuilder instance through the
-/// \a InternalAddPluginFactory method.
-class ServerBuilderPlugin {
- public:
-  virtual ~ServerBuilderPlugin() {}
-  virtual std::string name() = 0;
+    /// This interface is meant for internal usage only. Implementations of this
+    /// interface should add themselves to a \a ServerBuilder instance through the
+    /// \a InternalAddPluginFactory method.
+    class ServerBuilderPlugin
+    {
+    public:
+        virtual ~ServerBuilderPlugin()
+        {
+        }
+        virtual std::string name() = 0;
 
-  /// UpdateServerBuilder will be called at an early stage in
-  /// ServerBuilder::BuildAndStart(), right after the ServerBuilderOptions have
-  /// done their updates.
-  virtual void UpdateServerBuilder(ServerBuilder* /*builder*/) {}
+        /// UpdateServerBuilder will be called at an early stage in
+        /// ServerBuilder::BuildAndStart(), right after the ServerBuilderOptions have
+        /// done their updates.
+        virtual void UpdateServerBuilder(ServerBuilder* /*builder*/)
+        {
+        }
 
-  /// InitServer will be called in ServerBuilder::BuildAndStart(), after the
-  /// Server instance is created.
-  virtual void InitServer(ServerInitializer* si) = 0;
+        /// InitServer will be called in ServerBuilder::BuildAndStart(), after the
+        /// Server instance is created.
+        virtual void InitServer(ServerInitializer* si) = 0;
 
-  /// Finish will be called at the end of ServerBuilder::BuildAndStart().
-  virtual void Finish(ServerInitializer* si) = 0;
+        /// Finish will be called at the end of ServerBuilder::BuildAndStart().
+        virtual void Finish(ServerInitializer* si) = 0;
 
-  /// ChangeArguments is an interface that can be used in
-  /// ServerBuilderOption::UpdatePlugins
-  virtual void ChangeArguments(const std::string& name, void* value) = 0;
+        /// ChangeArguments is an interface that can be used in
+        /// ServerBuilderOption::UpdatePlugins
+        virtual void ChangeArguments(const std::string& name, void* value) = 0;
 
-  /// UpdateChannelArguments will be called in ServerBuilder::BuildAndStart(),
-  /// before the Server instance is created.
-  virtual void UpdateChannelArguments(ChannelArguments* /*args*/) {}
+        /// UpdateChannelArguments will be called in ServerBuilder::BuildAndStart(),
+        /// before the Server instance is created.
+        virtual void UpdateChannelArguments(ChannelArguments* /*args*/)
+        {
+        }
 
-  virtual bool has_sync_methods() const { return false; }
-  virtual bool has_async_methods() const { return false; }
-};
+        virtual bool has_sync_methods() const
+        {
+            return false;
+        }
+        virtual bool has_async_methods() const
+        {
+            return false;
+        }
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/impl/server_initializer.h b/CAPI/cpp/grpc/include/grpcpp/impl/server_initializer.h
index 610df80..26e1532 100644
--- a/CAPI/cpp/grpc/include/grpcpp/impl/server_initializer.h
+++ b/CAPI/cpp/grpc/include/grpcpp/impl/server_initializer.h
@@ -24,30 +24,38 @@
 
 #include <grpcpp/server.h>
 
-namespace grpc {
-class Server;
-class Service;
-
-class ServerInitializer {
- public:
-  explicit ServerInitializer(grpc::Server* server) : server_(server) {}
-
-  bool RegisterService(std::shared_ptr<grpc::Service> service) {
-    if (!server_->RegisterService(nullptr, service.get())) {
-      return false;
-    }
-    default_services_.push_back(service);
-    return true;
-  }
-
-  const std::vector<std::string>* GetServiceList() {
-    return &server_->services_;
-  }
-
- private:
-  grpc::Server* server_;
-  std::vector<std::shared_ptr<grpc::Service> > default_services_;
-};
+namespace grpc
+{
+    class Server;
+    class Service;
+
+    class ServerInitializer
+    {
+    public:
+        explicit ServerInitializer(grpc::Server* server) :
+            server_(server)
+        {
+        }
+
+        bool RegisterService(std::shared_ptr<grpc::Service> service)
+        {
+            if (!server_->RegisterService(nullptr, service.get()))
+            {
+                return false;
+            }
+            default_services_.push_back(service);
+            return true;
+        }
+
+        const std::vector<std::string>* GetServiceList()
+        {
+            return &server_->services_;
+        }
+
+    private:
+        grpc::Server* server_;
+        std::vector<std::shared_ptr<grpc::Service>> default_services_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/resource_quota.h b/CAPI/cpp/grpc/include/grpcpp/resource_quota.h
index bde32f9..c42311b 100644
--- a/CAPI/cpp/grpc/include/grpcpp/resource_quota.h
+++ b/CAPI/cpp/grpc/include/grpcpp/resource_quota.h
@@ -24,44 +24,49 @@ struct grpc_resource_quota;
 #include <grpcpp/impl/codegen/config.h>
 #include <grpcpp/impl/codegen/grpc_library.h>
 
-namespace grpc {
+namespace grpc
+{
 
-/// ResourceQuota represents a bound on memory and thread usage by the gRPC
-/// library. A ResourceQuota can be attached to a server (via \a ServerBuilder),
-/// or a client channel (via \a ChannelArguments).
-/// gRPC will attempt to keep memory and threads used by all attached entities
-/// below the ResourceQuota bound.
-class ResourceQuota final : private grpc::GrpcLibraryCodegen {
- public:
-  /// \param name - a unique name for this ResourceQuota.
-  explicit ResourceQuota(const std::string& name);
-  ResourceQuota();
-  ~ResourceQuota() override;
+    /// ResourceQuota represents a bound on memory and thread usage by the gRPC
+    /// library. A ResourceQuota can be attached to a server (via \a ServerBuilder),
+    /// or a client channel (via \a ChannelArguments).
+    /// gRPC will attempt to keep memory and threads used by all attached entities
+    /// below the ResourceQuota bound.
+    class ResourceQuota final : private grpc::GrpcLibraryCodegen
+    {
+    public:
+        /// \param name - a unique name for this ResourceQuota.
+        explicit ResourceQuota(const std::string& name);
+        ResourceQuota();
+        ~ResourceQuota() override;
 
-  /// Resize this \a ResourceQuota to a new size. If \a new_size is smaller
-  /// than the current size of the pool, memory usage will be monotonically
-  /// decreased until it falls under \a new_size.
-  /// No time bound is given for this to occur however.
-  ResourceQuota& Resize(size_t new_size);
+        /// Resize this \a ResourceQuota to a new size. If \a new_size is smaller
+        /// than the current size of the pool, memory usage will be monotonically
+        /// decreased until it falls under \a new_size.
+        /// No time bound is given for this to occur however.
+        ResourceQuota& Resize(size_t new_size);
 
-  /// Set the max number of threads that can be allocated from this
-  /// ResourceQuota object.
-  ///
-  /// If the new_max_threads value is smaller than the current value, no new
-  /// threads are allocated until the number of active threads fall below
-  /// new_max_threads. There is no time bound on when this may happen i.e none
-  /// of the current threads are forcefully destroyed and all threads run their
-  /// normal course.
-  ResourceQuota& SetMaxThreads(int new_max_threads);
+        /// Set the max number of threads that can be allocated from this
+        /// ResourceQuota object.
+        ///
+        /// If the new_max_threads value is smaller than the current value, no new
+        /// threads are allocated until the number of active threads fall below
+        /// new_max_threads. There is no time bound on when this may happen i.e none
+        /// of the current threads are forcefully destroyed and all threads run their
+        /// normal course.
+        ResourceQuota& SetMaxThreads(int new_max_threads);
 
-  grpc_resource_quota* c_resource_quota() const { return impl_; }
+        grpc_resource_quota* c_resource_quota() const
+        {
+            return impl_;
+        }
 
- private:
-  ResourceQuota(const ResourceQuota& rhs);
-  ResourceQuota& operator=(const ResourceQuota& rhs);
+    private:
+        ResourceQuota(const ResourceQuota& rhs);
+        ResourceQuota& operator=(const ResourceQuota& rhs);
 
-  grpc_resource_quota* const impl_;
-};
+        grpc_resource_quota* const impl_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/alts_context.h b/CAPI/cpp/grpc/include/grpcpp/security/alts_context.h
index 8d84257..3f5b182 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/alts_context.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/alts_context.h
@@ -27,43 +27,48 @@
 
 struct grpc_gcp_AltsContext;
 
-namespace grpc {
-namespace experimental {
+namespace grpc
+{
+    namespace experimental
+    {
 
-// AltsContext is a wrapper class for grpc_gcp_AltsContext.
-class AltsContext {
- public:
-  struct RpcProtocolVersions {
-    struct Version {
-      int major_version;
-      int minor_version;
-    };
-    Version max_rpc_version;
-    Version min_rpc_version;
-  };
-  explicit AltsContext(const grpc_gcp_AltsContext* ctx);
-  AltsContext& operator=(const AltsContext&) = default;
-  AltsContext(const AltsContext&) = default;
+        // AltsContext is a wrapper class for grpc_gcp_AltsContext.
+        class AltsContext
+        {
+        public:
+            struct RpcProtocolVersions
+            {
+                struct Version
+                {
+                    int major_version;
+                    int minor_version;
+                };
+                Version max_rpc_version;
+                Version min_rpc_version;
+            };
+            explicit AltsContext(const grpc_gcp_AltsContext* ctx);
+            AltsContext& operator=(const AltsContext&) = default;
+            AltsContext(const AltsContext&) = default;
 
-  std::string application_protocol() const;
-  std::string record_protocol() const;
-  std::string peer_service_account() const;
-  std::string local_service_account() const;
-  grpc_security_level security_level() const;
-  RpcProtocolVersions peer_rpc_versions() const;
-  const std::map<std::string, std::string>& peer_attributes() const;
+            std::string application_protocol() const;
+            std::string record_protocol() const;
+            std::string peer_service_account() const;
+            std::string local_service_account() const;
+            grpc_security_level security_level() const;
+            RpcProtocolVersions peer_rpc_versions() const;
+            const std::map<std::string, std::string>& peer_attributes() const;
 
- private:
-  std::string application_protocol_;
-  std::string record_protocol_;
-  std::string peer_service_account_;
-  std::string local_service_account_;
-  grpc_security_level security_level_ = GRPC_SECURITY_NONE;
-  RpcProtocolVersions peer_rpc_versions_ = {{0, 0}, {0, 0}};
-  std::map<std::string, std::string> peer_attributes_map_;
-};
+        private:
+            std::string application_protocol_;
+            std::string record_protocol_;
+            std::string peer_service_account_;
+            std::string local_service_account_;
+            grpc_security_level security_level_ = GRPC_SECURITY_NONE;
+            RpcProtocolVersions peer_rpc_versions_ = {{0, 0}, {0, 0}};
+            std::map<std::string, std::string> peer_attributes_map_;
+        };
 
-}  // namespace experimental
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_ALTS_CONTEXT_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/alts_util.h b/CAPI/cpp/grpc/include/grpcpp/security/alts_util.h
index b0ef4b4..d1d51fe 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/alts_util.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/alts_util.h
@@ -28,23 +28,27 @@
 
 struct grpc_gcp_AltsContext;
 
-namespace grpc {
-namespace experimental {
-
-// GetAltsContextFromAuthContext helps to get the AltsContext from AuthContext.
-// If ALTS is not the transport security protocol used to establish the
-// connection, this function will return nullptr.
-std::unique_ptr<AltsContext> GetAltsContextFromAuthContext(
-    const std::shared_ptr<const AuthContext>& auth_context);
-
-// This utility function performs ALTS client authorization check on server
-// side, i.e., checks if the client identity matches one of the expected service
-// accounts. It returns OK if client is authorized and an error otherwise.
-grpc::Status AltsClientAuthzCheck(
-    const std::shared_ptr<const AuthContext>& auth_context,
-    const std::vector<std::string>& expected_service_accounts);
-
-}  // namespace experimental
+namespace grpc
+{
+    namespace experimental
+    {
+
+        // GetAltsContextFromAuthContext helps to get the AltsContext from AuthContext.
+        // If ALTS is not the transport security protocol used to establish the
+        // connection, this function will return nullptr.
+        std::unique_ptr<AltsContext> GetAltsContextFromAuthContext(
+            const std::shared_ptr<const AuthContext>& auth_context
+        );
+
+        // This utility function performs ALTS client authorization check on server
+        // side, i.e., checks if the client identity matches one of the expected service
+        // accounts. It returns OK if client is authorized and an error otherwise.
+        grpc::Status AltsClientAuthzCheck(
+            const std::shared_ptr<const AuthContext>& auth_context,
+            const std::vector<std::string>& expected_service_accounts
+        );
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_ALTS_UTIL_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/auth_metadata_processor.h b/CAPI/cpp/grpc/include/grpcpp/security/auth_metadata_processor.h
index 545bdf1..f654674 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/auth_metadata_processor.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/auth_metadata_processor.h
@@ -25,48 +25,52 @@
 #include <grpcpp/support/status.h>
 #include <grpcpp/support/string_ref.h>
 
-namespace grpc {
+namespace grpc
+{
 
-/// Interface allowing custom server-side authorization based on credentials
-/// encoded in metadata.  Objects of this type can be passed to
-/// \a ServerCredentials::SetAuthMetadataProcessor().
-/// Please also check out \a grpc::experimental::Interceptor for another way to
-/// do customized operations on the information provided by a specific call.
-class AuthMetadataProcessor {
- public:
-  typedef std::multimap<grpc::string_ref, grpc::string_ref> InputMetadata;
-  typedef std::multimap<std::string, std::string> OutputMetadata;
+    /// Interface allowing custom server-side authorization based on credentials
+    /// encoded in metadata.  Objects of this type can be passed to
+    /// \a ServerCredentials::SetAuthMetadataProcessor().
+    /// Please also check out \a grpc::experimental::Interceptor for another way to
+    /// do customized operations on the information provided by a specific call.
+    class AuthMetadataProcessor
+    {
+    public:
+        typedef std::multimap<grpc::string_ref, grpc::string_ref> InputMetadata;
+        typedef std::multimap<std::string, std::string> OutputMetadata;
 
-  virtual ~AuthMetadataProcessor() {}
+        virtual ~AuthMetadataProcessor()
+        {
+        }
 
-  /// If this method returns true, the \a Process function will be scheduled in
-  /// a different thread from the one processing the call.
-  virtual bool IsBlocking() const { return true; }
+        /// If this method returns true, the \a Process function will be scheduled in
+        /// a different thread from the one processing the call.
+        virtual bool IsBlocking() const
+        {
+            return true;
+        }
 
-  /// Processes a Call associated with a connection.
-  /// auth_metadata: the authentication metadata associated with the particular
-  ///   call
-  /// context: contains the connection-level info, e.g. the peer identity. This
-  ///   parameter is readable and writable. Note that since the information is
-  ///   shared for all calls associated with the connection, if the
-  ///   implementation updates the info in a specific call, all the subsequent
-  ///   calls will see the updates. A typical usage of context is to use
-  ///   |auth_metadata| to infer the peer identity, and augment it with
-  ///   properties.
-  /// consumed_auth_metadata: contains the metadata that the implementation
-  ///   wants to remove from the current call, so that the server application is
-  ///   no longer able to see it anymore. A typical usage would be to do token
-  ///   authentication in the first call, and then remove the token information
-  ///   for all subsequent calls.
-  /// response_metadata(CURRENTLY NOT SUPPORTED): the metadata that will be sent
-  ///   as part of the response.
-  /// return: if the return value is not Status::OK, the rpc call will be
-  ///   aborted with the error code and error message sent back to the client.
-  virtual grpc::Status Process(const InputMetadata& auth_metadata,
-                               grpc::AuthContext* context,
-                               OutputMetadata* consumed_auth_metadata,
-                               OutputMetadata* response_metadata) = 0;
-};
+        /// Processes a Call associated with a connection.
+        /// auth_metadata: the authentication metadata associated with the particular
+        ///   call
+        /// context: contains the connection-level info, e.g. the peer identity. This
+        ///   parameter is readable and writable. Note that since the information is
+        ///   shared for all calls associated with the connection, if the
+        ///   implementation updates the info in a specific call, all the subsequent
+        ///   calls will see the updates. A typical usage of context is to use
+        ///   |auth_metadata| to infer the peer identity, and augment it with
+        ///   properties.
+        /// consumed_auth_metadata: contains the metadata that the implementation
+        ///   wants to remove from the current call, so that the server application is
+        ///   no longer able to see it anymore. A typical usage would be to do token
+        ///   authentication in the first call, and then remove the token information
+        ///   for all subsequent calls.
+        /// response_metadata(CURRENTLY NOT SUPPORTED): the metadata that will be sent
+        ///   as part of the response.
+        /// return: if the return value is not Status::OK, the rpc call will be
+        ///   aborted with the error code and error message sent back to the client.
+        virtual grpc::Status Process(const InputMetadata& auth_metadata, grpc::AuthContext* context, OutputMetadata* consumed_auth_metadata, OutputMetadata* response_metadata) = 0;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/authorization_policy_provider.h b/CAPI/cpp/grpc/include/grpcpp/security/authorization_policy_provider.h
index 1718db4..85c9da2 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/authorization_policy_provider.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/authorization_policy_provider.h
@@ -21,68 +21,80 @@
 #include <grpc/status.h>
 #include <grpcpp/impl/codegen/grpc_library.h>
 
-namespace grpc {
-namespace experimental {
-
-// Wrapper around C-core grpc_authorization_policy_provider. Internally, it
-// handles creating and updating authorization engine objects, using SDK
-// authorization policy.
-class AuthorizationPolicyProviderInterface {
- public:
-  virtual ~AuthorizationPolicyProviderInterface() = default;
-  virtual grpc_authorization_policy_provider* c_provider() = 0;
-};
-
-// Implementation obtains authorization policy from static string. This provider
-// will always return the same authorization engines.
-class StaticDataAuthorizationPolicyProvider
-    : public AuthorizationPolicyProviderInterface {
- public:
-  static std::shared_ptr<StaticDataAuthorizationPolicyProvider> Create(
-      const std::string& authz_policy, grpc::Status* status);
-
-  // Use factory method "Create" to create an instance of
-  // StaticDataAuthorizationPolicyProvider.
-  explicit StaticDataAuthorizationPolicyProvider(
-      grpc_authorization_policy_provider* provider)
-      : c_provider_(provider) {}
-
-  ~StaticDataAuthorizationPolicyProvider() override;
-
-  grpc_authorization_policy_provider* c_provider() override {
-    return c_provider_;
-  }
-
- private:
-  grpc_authorization_policy_provider* c_provider_ = nullptr;
-};
-
-// Implementation obtains authorization policy by watching for changes in
-// filesystem.
-class FileWatcherAuthorizationPolicyProvider
-    : public AuthorizationPolicyProviderInterface {
- public:
-  static std::shared_ptr<FileWatcherAuthorizationPolicyProvider> Create(
-      const std::string& authz_policy_path, unsigned int refresh_interval_sec,
-      grpc::Status* status);
-
-  // Use factory method "Create" to create an instance of
-  // FileWatcherAuthorizationPolicyProvider.
-  explicit FileWatcherAuthorizationPolicyProvider(
-      grpc_authorization_policy_provider* provider)
-      : c_provider_(provider) {}
-
-  ~FileWatcherAuthorizationPolicyProvider() override;
-
-  grpc_authorization_policy_provider* c_provider() override {
-    return c_provider_;
-  }
-
- private:
-  grpc_authorization_policy_provider* c_provider_ = nullptr;
-};
-
-}  // namespace experimental
+namespace grpc
+{
+    namespace experimental
+    {
+
+        // Wrapper around C-core grpc_authorization_policy_provider. Internally, it
+        // handles creating and updating authorization engine objects, using SDK
+        // authorization policy.
+        class AuthorizationPolicyProviderInterface
+        {
+        public:
+            virtual ~AuthorizationPolicyProviderInterface() = default;
+            virtual grpc_authorization_policy_provider* c_provider() = 0;
+        };
+
+        // Implementation obtains authorization policy from static string. This provider
+        // will always return the same authorization engines.
+        class StaticDataAuthorizationPolicyProvider : public AuthorizationPolicyProviderInterface
+        {
+        public:
+            static std::shared_ptr<StaticDataAuthorizationPolicyProvider> Create(
+                const std::string& authz_policy, grpc::Status* status
+            );
+
+            // Use factory method "Create" to create an instance of
+            // StaticDataAuthorizationPolicyProvider.
+            explicit StaticDataAuthorizationPolicyProvider(
+                grpc_authorization_policy_provider* provider
+            ) :
+                c_provider_(provider)
+            {
+            }
+
+            ~StaticDataAuthorizationPolicyProvider() override;
+
+            grpc_authorization_policy_provider* c_provider() override
+            {
+                return c_provider_;
+            }
+
+        private:
+            grpc_authorization_policy_provider* c_provider_ = nullptr;
+        };
+
+        // Implementation obtains authorization policy by watching for changes in
+        // filesystem.
+        class FileWatcherAuthorizationPolicyProvider : public AuthorizationPolicyProviderInterface
+        {
+        public:
+            static std::shared_ptr<FileWatcherAuthorizationPolicyProvider> Create(
+                const std::string& authz_policy_path, unsigned int refresh_interval_sec, grpc::Status* status
+            );
+
+            // Use factory method "Create" to create an instance of
+            // FileWatcherAuthorizationPolicyProvider.
+            explicit FileWatcherAuthorizationPolicyProvider(
+                grpc_authorization_policy_provider* provider
+            ) :
+                c_provider_(provider)
+            {
+            }
+
+            ~FileWatcherAuthorizationPolicyProvider() override;
+
+            grpc_authorization_policy_provider* c_provider() override
+            {
+                return c_provider_;
+            }
+
+        private:
+            grpc_authorization_policy_provider* c_provider_ = nullptr;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_AUTHORIZATION_POLICY_PROVIDER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/binder_credentials.h b/CAPI/cpp/grpc/include/grpcpp/security/binder_credentials.h
index f511837..74563bb 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/binder_credentials.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/binder_credentials.h
@@ -20,24 +20,27 @@
 #include <grpcpp/security/binder_security_policy.h>
 #include <grpcpp/security/server_credentials.h>
 
-namespace grpc {
-
-class ChannelCredentials;
-
-namespace experimental {
-
-/// EXPERIMENTAL Builds Binder ServerCredentials.
-///
-/// This should be used along with `binder:` URI scheme. The path in the URI can
-/// later be used to access the server's endpoint binder.
-/// Note that calling \a ServerBuilder::AddListeningPort() with Binder
-/// ServerCredentials in a non-supported environment will make the subsequent
-/// call to \a ServerBuilder::BuildAndStart() return a null pointer.
-std::shared_ptr<grpc::ServerCredentials> BinderServerCredentials(
-    std::shared_ptr<grpc::experimental::binder::SecurityPolicy>
-        security_policy);
-
-}  // namespace experimental
+namespace grpc
+{
+
+    class ChannelCredentials;
+
+    namespace experimental
+    {
+
+        /// EXPERIMENTAL Builds Binder ServerCredentials.
+        ///
+        /// This should be used along with `binder:` URI scheme. The path in the URI can
+        /// later be used to access the server's endpoint binder.
+        /// Note that calling \a ServerBuilder::AddListeningPort() with Binder
+        /// ServerCredentials in a non-supported environment will make the subsequent
+        /// call to \a ServerBuilder::BuildAndStart() return a null pointer.
+        std::shared_ptr<grpc::ServerCredentials> BinderServerCredentials(
+            std::shared_ptr<grpc::experimental::binder::SecurityPolicy>
+                security_policy
+        );
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_BINDER_CREDENTIALS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/binder_security_policy.h b/CAPI/cpp/grpc/include/grpcpp/security/binder_security_policy.h
index e1c951f..920b580 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/binder_security_policy.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/binder_security_policy.h
@@ -23,60 +23,67 @@
 
 #endif
 
-namespace grpc {
-namespace experimental {
-namespace binder {
+namespace grpc
+{
+    namespace experimental
+    {
+        namespace binder
+        {
 
-// EXPERIMENTAL Determinines if a connection is allowed to be
-// established on Android. See https://source.android.com/security/app-sandbox
-// for more info about UID.
-class SecurityPolicy {
- public:
-  virtual ~SecurityPolicy() = default;
-  // Returns true if the UID is authorized to connect.
-  // Must return the same value for the same inputs so callers can safely cache
-  // the result.
-  virtual bool IsAuthorized(int uid) = 0;
-};
+            // EXPERIMENTAL Determinines if a connection is allowed to be
+            // established on Android. See https://source.android.com/security/app-sandbox
+            // for more info about UID.
+            class SecurityPolicy
+            {
+            public:
+                virtual ~SecurityPolicy() = default;
+                // Returns true if the UID is authorized to connect.
+                // Must return the same value for the same inputs so callers can safely cache
+                // the result.
+                virtual bool IsAuthorized(int uid) = 0;
+            };
 
-// EXPERIMENTAL Allows all connection. Anything on the Android device will be
-// able to connect, use with caution!
-class UntrustedSecurityPolicy : public SecurityPolicy {
- public:
-  UntrustedSecurityPolicy();
-  ~UntrustedSecurityPolicy() override;
-  bool IsAuthorized(int uid) override;
-};
+            // EXPERIMENTAL Allows all connection. Anything on the Android device will be
+            // able to connect, use with caution!
+            class UntrustedSecurityPolicy : public SecurityPolicy
+            {
+            public:
+                UntrustedSecurityPolicy();
+                ~UntrustedSecurityPolicy() override;
+                bool IsAuthorized(int uid) override;
+            };
 
-// EXPERIMENTAL Only allows the connections from processes with the same UID. In
-// most cases this means "from the same APK".
-class InternalOnlySecurityPolicy : public SecurityPolicy {
- public:
-  InternalOnlySecurityPolicy();
-  ~InternalOnlySecurityPolicy() override;
-  bool IsAuthorized(int uid) override;
-};
+            // EXPERIMENTAL Only allows the connections from processes with the same UID. In
+            // most cases this means "from the same APK".
+            class InternalOnlySecurityPolicy : public SecurityPolicy
+            {
+            public:
+                InternalOnlySecurityPolicy();
+                ~InternalOnlySecurityPolicy() override;
+                bool IsAuthorized(int uid) override;
+            };
 
 #ifdef GPR_ANDROID
 
-// EXPERIMENTAL Only allows the connections from the APK that have the same
-// signature.
-class SameSignatureSecurityPolicy : public SecurityPolicy {
- public:
-  // `context` is required for getting PackageManager Java class
-  SameSignatureSecurityPolicy(JavaVM* jvm, jobject context);
-  ~SameSignatureSecurityPolicy() override;
-  bool IsAuthorized(int uid) override;
+            // EXPERIMENTAL Only allows the connections from the APK that have the same
+            // signature.
+            class SameSignatureSecurityPolicy : public SecurityPolicy
+            {
+            public:
+                // `context` is required for getting PackageManager Java class
+                SameSignatureSecurityPolicy(JavaVM* jvm, jobject context);
+                ~SameSignatureSecurityPolicy() override;
+                bool IsAuthorized(int uid) override;
 
- private:
-  JavaVM* jvm_;
-  jobject context_;
-};
+            private:
+                JavaVM* jvm_;
+                jobject context_;
+            };
 
 #endif
 
-}  // namespace binder
-}  // namespace experimental
+        }  // namespace binder
+    }      // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_BINDER_SECURITY_POLICY_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/credentials.h b/CAPI/cpp/grpc/include/grpcpp/security/credentials.h
index 18dce96..7e8ce40 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/credentials.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/credentials.h
@@ -35,315 +35,361 @@
 
 struct grpc_call;
 
-namespace grpc {
-class CallCredentials;
-class SecureCallCredentials;
-class SecureChannelCredentials;
-class ChannelCredentials;
-
-std::shared_ptr<Channel> CreateCustomChannel(
-    const grpc::string& target,
-    const std::shared_ptr<grpc::ChannelCredentials>& creds,
-    const grpc::ChannelArguments& args);
-
-namespace experimental {
-std::shared_ptr<grpc::Channel> CreateCustomChannelWithInterceptors(
-    const grpc::string& target,
-    const std::shared_ptr<grpc::ChannelCredentials>& creds,
-    const grpc::ChannelArguments& args,
-    std::vector<
-        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
-        interceptor_creators);
-
-GRPC_DEPRECATED(
-    "Use grpc::XdsCredentials instead. The experimental version will be "
-    "deleted after the 1.41 release.")
-std::shared_ptr<ChannelCredentials> XdsCredentials(
-    const std::shared_ptr<ChannelCredentials>& fallback_creds);
-}  // namespace experimental
-
-/// Builds XDS Credentials.
-std::shared_ptr<ChannelCredentials> XdsCredentials(
-    const std::shared_ptr<ChannelCredentials>& fallback_creds);
-
-/// A channel credentials object encapsulates all the state needed by a client
-/// to authenticate with a server for a given channel.
-/// It can make various assertions, e.g., about the client’s identity, role
-/// for all the calls on that channel.
-///
-/// \see https://grpc.io/docs/guides/auth.html
-class ChannelCredentials : private grpc::GrpcLibraryCodegen {
- public:
-  ChannelCredentials();
-  ~ChannelCredentials() override;
-
- protected:
-  friend std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
-      const std::shared_ptr<ChannelCredentials>& channel_creds,
-      const std::shared_ptr<CallCredentials>& call_creds);
-
-  // TODO(yashykt): We need this friend declaration mainly for access to
-  // AsSecureCredentials(). Once we are able to remove insecure builds from gRPC
-  // (and also internal dependencies on the indirect method of creating a
-  // channel through credentials), we would be able to remove this.
-  friend std::shared_ptr<ChannelCredentials> grpc::XdsCredentials(
-      const std::shared_ptr<ChannelCredentials>& fallback_creds);
-
-  virtual SecureChannelCredentials* AsSecureCredentials() = 0;
-
- private:
-  friend std::shared_ptr<grpc::Channel> CreateCustomChannel(
-      const grpc::string& target,
-      const std::shared_ptr<grpc::ChannelCredentials>& creds,
-      const grpc::ChannelArguments& args);
-
-  friend std::shared_ptr<grpc::Channel>
-  grpc::experimental::CreateCustomChannelWithInterceptors(
-      const grpc::string& target,
-      const std::shared_ptr<grpc::ChannelCredentials>& creds,
-      const grpc::ChannelArguments& args,
-      std::vector<std::unique_ptr<
-          grpc::experimental::ClientInterceptorFactoryInterface>>
-          interceptor_creators);
-
-  virtual std::shared_ptr<Channel> CreateChannelImpl(
-      const grpc::string& target, const ChannelArguments& args) = 0;
-
-  // This function should have been a pure virtual function, but it is
-  // implemented as a virtual function so that it does not break API.
-  virtual std::shared_ptr<Channel> CreateChannelWithInterceptors(
-      const grpc::string& /*target*/, const ChannelArguments& /*args*/,
-      std::vector<std::unique_ptr<
-          grpc::experimental::ClientInterceptorFactoryInterface>>
-      /*interceptor_creators*/) {
-    return nullptr;
-  }
-
-  // TODO(yashkt): This is a hack that is needed since InsecureCredentials can
-  // not use grpc_channel_credentials internally and should be removed after
-  // insecure builds are removed from gRPC.
-  virtual bool IsInsecure() const { return false; }
-};
-
-/// A call credentials object encapsulates the state needed by a client to
-/// authenticate with a server for a given call on a channel.
-///
-/// \see https://grpc.io/docs/guides/auth.html
-class CallCredentials : private grpc::GrpcLibraryCodegen {
- public:
-  CallCredentials();
-  ~CallCredentials() override;
-
-  /// Apply this instance's credentials to \a call.
-  virtual bool ApplyToCall(grpc_call* call) = 0;
-  virtual grpc::string DebugString() {
-    return "CallCredentials did not provide a debug string";
-  }
-
- protected:
-  friend std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
-      const std::shared_ptr<ChannelCredentials>& channel_creds,
-      const std::shared_ptr<CallCredentials>& call_creds);
-
-  friend std::shared_ptr<CallCredentials> CompositeCallCredentials(
-      const std::shared_ptr<CallCredentials>& creds1,
-      const std::shared_ptr<CallCredentials>& creds2);
-
-  virtual SecureCallCredentials* AsSecureCredentials() = 0;
-};
-
-/// Options used to build SslCredentials.
-struct SslCredentialsOptions {
-  /// The buffer containing the PEM encoding of the server root certificates. If
-  /// this parameter is empty, the default roots will be used.  The default
-  /// roots can be overridden using the \a GRPC_DEFAULT_SSL_ROOTS_FILE_PATH
-  /// environment variable pointing to a file on the file system containing the
-  /// roots.
-  grpc::string pem_root_certs;
-
-  /// The buffer containing the PEM encoding of the client's private key. This
-  /// parameter can be empty if the client does not have a private key.
-  grpc::string pem_private_key;
-
-  /// The buffer containing the PEM encoding of the client's certificate chain.
-  /// This parameter can be empty if the client does not have a certificate
-  /// chain.
-  grpc::string pem_cert_chain;
-};
-
-// Factories for building different types of Credentials The functions may
-// return empty shared_ptr when credentials cannot be created. If a
-// Credentials pointer is returned, it can still be invalid when used to create
-// a channel. A lame channel will be created then and all rpcs will fail on it.
-
-/// Builds credentials with reasonable defaults.
-///
-/// \warning Only use these credentials when connecting to a Google endpoint.
-/// Using these credentials to connect to any other service may result in this
-/// service being able to impersonate your client for requests to Google
-/// services.
-std::shared_ptr<ChannelCredentials> GoogleDefaultCredentials();
-
-/// Builds SSL Credentials given SSL specific options
-std::shared_ptr<ChannelCredentials> SslCredentials(
-    const SslCredentialsOptions& options);
-
-/// Builds credentials for use when running in GCE
-///
-/// \warning Only use these credentials when connecting to a Google endpoint.
-/// Using these credentials to connect to any other service may result in this
-/// service being able to impersonate your client for requests to Google
-/// services.
-std::shared_ptr<CallCredentials> GoogleComputeEngineCredentials();
-
-constexpr long kMaxAuthTokenLifetimeSecs = 3600;
-
-/// Builds Service Account JWT Access credentials.
-/// json_key is the JSON key string containing the client's private key.
-/// token_lifetime_seconds is the lifetime in seconds of each Json Web Token
-/// (JWT) created with this credentials. It should not exceed
-/// \a kMaxAuthTokenLifetimeSecs or will be cropped to this value.
-std::shared_ptr<CallCredentials> ServiceAccountJWTAccessCredentials(
-    const grpc::string& json_key,
-    long token_lifetime_seconds = kMaxAuthTokenLifetimeSecs);
-
-/// Builds refresh token credentials.
-/// json_refresh_token is the JSON string containing the refresh token along
-/// with a client_id and client_secret.
-///
-/// \warning Only use these credentials when connecting to a Google endpoint.
-/// Using these credentials to connect to any other service may result in this
-/// service being able to impersonate your client for requests to Google
-/// services.
-std::shared_ptr<CallCredentials> GoogleRefreshTokenCredentials(
-    const grpc::string& json_refresh_token);
-
-/// Builds access token credentials.
-/// access_token is an oauth2 access token that was fetched using an out of band
-/// mechanism.
-///
-/// \warning Only use these credentials when connecting to a Google endpoint.
-/// Using these credentials to connect to any other service may result in this
-/// service being able to impersonate your client for requests to Google
-/// services.
-std::shared_ptr<CallCredentials> AccessTokenCredentials(
-    const grpc::string& access_token);
-
-/// Builds IAM credentials.
-///
-/// \warning Only use these credentials when connecting to a Google endpoint.
-/// Using these credentials to connect to any other service may result in this
-/// service being able to impersonate your client for requests to Google
-/// services.
-std::shared_ptr<CallCredentials> GoogleIAMCredentials(
-    const grpc::string& authorization_token,
-    const grpc::string& authority_selector);
-
-/// Combines a channel credentials and a call credentials into a composite
-/// channel credentials.
-std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
-    const std::shared_ptr<ChannelCredentials>& channel_creds,
-    const std::shared_ptr<CallCredentials>& call_creds);
-
-/// Combines two call credentials objects into a composite call credentials.
-std::shared_ptr<CallCredentials> CompositeCallCredentials(
-    const std::shared_ptr<CallCredentials>& creds1,
-    const std::shared_ptr<CallCredentials>& creds2);
-
-/// Credentials for an unencrypted, unauthenticated channel
-std::shared_ptr<ChannelCredentials> InsecureChannelCredentials();
-
-/// User defined metadata credentials.
-class MetadataCredentialsPlugin {
- public:
-  virtual ~MetadataCredentialsPlugin() {}
-
-  /// If this method returns true, the Process function will be scheduled in
-  /// a different thread from the one processing the call.
-  virtual bool IsBlocking() const { return true; }
-
-  /// Type of credentials this plugin is implementing.
-  virtual const char* GetType() const { return ""; }
-
-  /// Gets the auth metatada produced by this plugin.
-  /// The fully qualified method name is:
-  /// service_url + "/" + method_name.
-  /// The channel_auth_context contains (among other things), the identity of
-  /// the server.
-  virtual grpc::Status GetMetadata(
-      grpc::string_ref service_url, grpc::string_ref method_name,
-      const grpc::AuthContext& channel_auth_context,
-      std::multimap<grpc::string, grpc::string>* metadata) = 0;
-
-  virtual grpc::string DebugString() {
-    return "MetadataCredentialsPlugin did not provide a debug string";
-  }
-};
-
-std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
-    std::unique_ptr<MetadataCredentialsPlugin> plugin);
-
-/// Builds External Account credentials.
-/// json_string is the JSON string containing the credentials options.
-/// scopes contains the scopes to be binded with the credentials.
-std::shared_ptr<CallCredentials> ExternalAccountCredentials(
-    const grpc::string& json_string, const std::vector<grpc::string>& scopes);
-
-namespace experimental {
-
-/// Options for creating STS Oauth Token Exchange credentials following the IETF
-/// draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
-/// Optional fields may be set to empty string. It is the responsibility of the
-/// caller to ensure that the subject and actor tokens are refreshed on disk at
-/// the specified paths.
-struct StsCredentialsOptions {
-  grpc::string token_exchange_service_uri;  // Required.
-  grpc::string resource;                    // Optional.
-  grpc::string audience;                    // Optional.
-  grpc::string scope;                       // Optional.
-  grpc::string requested_token_type;        // Optional.
-  grpc::string subject_token_path;          // Required.
-  grpc::string subject_token_type;          // Required.
-  grpc::string actor_token_path;            // Optional.
-  grpc::string actor_token_type;            // Optional.
-};
-
-grpc::Status StsCredentialsOptionsFromJson(const std::string& json_string,
-                                           StsCredentialsOptions* options);
-
-/// Creates STS credentials options from the $STS_CREDENTIALS environment
-/// variable. This environment variable points to the path of a JSON file
-/// comforming to the schema described above.
-grpc::Status StsCredentialsOptionsFromEnv(StsCredentialsOptions* options);
-
-std::shared_ptr<CallCredentials> StsCredentials(
-    const StsCredentialsOptions& options);
-
-std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
-    std::unique_ptr<MetadataCredentialsPlugin> plugin,
-    grpc_security_level min_security_level);
-
-/// Options used to build AltsCredentials.
-struct AltsCredentialsOptions {
-  /// service accounts of target endpoint that will be acceptable
-  /// by the client. If service accounts are provided and none of them matches
-  /// that of the server, authentication will fail.
-  std::vector<grpc::string> target_service_accounts;
-};
-
-/// Builds ALTS Credentials given ALTS specific options
-std::shared_ptr<ChannelCredentials> AltsCredentials(
-    const AltsCredentialsOptions& options);
-
-/// Builds Local Credentials.
-std::shared_ptr<ChannelCredentials> LocalCredentials(
-    grpc_local_connect_type type);
-
-/// Builds TLS Credentials given TLS options.
-std::shared_ptr<ChannelCredentials> TlsCredentials(
-    const TlsChannelCredentialsOptions& options);
-
-}  // namespace experimental
+namespace grpc
+{
+    class CallCredentials;
+    class SecureCallCredentials;
+    class SecureChannelCredentials;
+    class ChannelCredentials;
+
+    std::shared_ptr<Channel> CreateCustomChannel(
+        const grpc::string& target,
+        const std::shared_ptr<grpc::ChannelCredentials>& creds,
+        const grpc::ChannelArguments& args
+    );
+
+    namespace experimental
+    {
+        std::shared_ptr<grpc::Channel> CreateCustomChannelWithInterceptors(
+            const grpc::string& target,
+            const std::shared_ptr<grpc::ChannelCredentials>& creds,
+            const grpc::ChannelArguments& args,
+            std::vector<
+                std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+                interceptor_creators
+        );
+
+        GRPC_DEPRECATED(
+            "Use grpc::XdsCredentials instead. The experimental version will be "
+            "deleted after the 1.41 release."
+        )
+        std::shared_ptr<ChannelCredentials> XdsCredentials(
+            const std::shared_ptr<ChannelCredentials>& fallback_creds
+        );
+    }  // namespace experimental
+
+    /// Builds XDS Credentials.
+    std::shared_ptr<ChannelCredentials> XdsCredentials(
+        const std::shared_ptr<ChannelCredentials>& fallback_creds
+    );
+
+    /// A channel credentials object encapsulates all the state needed by a client
+    /// to authenticate with a server for a given channel.
+    /// It can make various assertions, e.g., about the client’s identity, role
+    /// for all the calls on that channel.
+    ///
+    /// \see https://grpc.io/docs/guides/auth.html
+    class ChannelCredentials : private grpc::GrpcLibraryCodegen
+    {
+    public:
+        ChannelCredentials();
+        ~ChannelCredentials() override;
+
+    protected:
+        friend std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
+            const std::shared_ptr<ChannelCredentials>& channel_creds,
+            const std::shared_ptr<CallCredentials>& call_creds
+        );
+
+        // TODO(yashykt): We need this friend declaration mainly for access to
+        // AsSecureCredentials(). Once we are able to remove insecure builds from gRPC
+        // (and also internal dependencies on the indirect method of creating a
+        // channel through credentials), we would be able to remove this.
+        friend std::shared_ptr<ChannelCredentials> grpc::XdsCredentials(
+            const std::shared_ptr<ChannelCredentials>& fallback_creds
+        );
+
+        virtual SecureChannelCredentials* AsSecureCredentials() = 0;
+
+    private:
+        friend std::shared_ptr<grpc::Channel> CreateCustomChannel(
+            const grpc::string& target,
+            const std::shared_ptr<grpc::ChannelCredentials>& creds,
+            const grpc::ChannelArguments& args
+        );
+
+        friend std::shared_ptr<grpc::Channel>
+            grpc::experimental::CreateCustomChannelWithInterceptors(
+                const grpc::string& target,
+                const std::shared_ptr<grpc::ChannelCredentials>& creds,
+                const grpc::ChannelArguments& args,
+                std::vector<std::unique_ptr<
+                    grpc::experimental::ClientInterceptorFactoryInterface>>
+                    interceptor_creators
+            );
+
+        virtual std::shared_ptr<Channel> CreateChannelImpl(
+            const grpc::string& target, const ChannelArguments& args
+        ) = 0;
+
+        // This function should have been a pure virtual function, but it is
+        // implemented as a virtual function so that it does not break API.
+        virtual std::shared_ptr<Channel> CreateChannelWithInterceptors(
+            const grpc::string& /*target*/, const ChannelArguments& /*args*/, std::vector<std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+            /*interceptor_creators*/
+        )
+        {
+            return nullptr;
+        }
+
+        // TODO(yashkt): This is a hack that is needed since InsecureCredentials can
+        // not use grpc_channel_credentials internally and should be removed after
+        // insecure builds are removed from gRPC.
+        virtual bool IsInsecure() const
+        {
+            return false;
+        }
+    };
+
+    /// A call credentials object encapsulates the state needed by a client to
+    /// authenticate with a server for a given call on a channel.
+    ///
+    /// \see https://grpc.io/docs/guides/auth.html
+    class CallCredentials : private grpc::GrpcLibraryCodegen
+    {
+    public:
+        CallCredentials();
+        ~CallCredentials() override;
+
+        /// Apply this instance's credentials to \a call.
+        virtual bool ApplyToCall(grpc_call* call) = 0;
+        virtual grpc::string DebugString()
+        {
+            return "CallCredentials did not provide a debug string";
+        }
+
+    protected:
+        friend std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
+            const std::shared_ptr<ChannelCredentials>& channel_creds,
+            const std::shared_ptr<CallCredentials>& call_creds
+        );
+
+        friend std::shared_ptr<CallCredentials> CompositeCallCredentials(
+            const std::shared_ptr<CallCredentials>& creds1,
+            const std::shared_ptr<CallCredentials>& creds2
+        );
+
+        virtual SecureCallCredentials* AsSecureCredentials() = 0;
+    };
+
+    /// Options used to build SslCredentials.
+    struct SslCredentialsOptions
+    {
+        /// The buffer containing the PEM encoding of the server root certificates. If
+        /// this parameter is empty, the default roots will be used.  The default
+        /// roots can be overridden using the \a GRPC_DEFAULT_SSL_ROOTS_FILE_PATH
+        /// environment variable pointing to a file on the file system containing the
+        /// roots.
+        grpc::string pem_root_certs;
+
+        /// The buffer containing the PEM encoding of the client's private key. This
+        /// parameter can be empty if the client does not have a private key.
+        grpc::string pem_private_key;
+
+        /// The buffer containing the PEM encoding of the client's certificate chain.
+        /// This parameter can be empty if the client does not have a certificate
+        /// chain.
+        grpc::string pem_cert_chain;
+    };
+
+    // Factories for building different types of Credentials The functions may
+    // return empty shared_ptr when credentials cannot be created. If a
+    // Credentials pointer is returned, it can still be invalid when used to create
+    // a channel. A lame channel will be created then and all rpcs will fail on it.
+
+    /// Builds credentials with reasonable defaults.
+    ///
+    /// \warning Only use these credentials when connecting to a Google endpoint.
+    /// Using these credentials to connect to any other service may result in this
+    /// service being able to impersonate your client for requests to Google
+    /// services.
+    std::shared_ptr<ChannelCredentials> GoogleDefaultCredentials();
+
+    /// Builds SSL Credentials given SSL specific options
+    std::shared_ptr<ChannelCredentials> SslCredentials(
+        const SslCredentialsOptions& options
+    );
+
+    /// Builds credentials for use when running in GCE
+    ///
+    /// \warning Only use these credentials when connecting to a Google endpoint.
+    /// Using these credentials to connect to any other service may result in this
+    /// service being able to impersonate your client for requests to Google
+    /// services.
+    std::shared_ptr<CallCredentials> GoogleComputeEngineCredentials();
+
+    constexpr long kMaxAuthTokenLifetimeSecs = 3600;
+
+    /// Builds Service Account JWT Access credentials.
+    /// json_key is the JSON key string containing the client's private key.
+    /// token_lifetime_seconds is the lifetime in seconds of each Json Web Token
+    /// (JWT) created with this credentials. It should not exceed
+    /// \a kMaxAuthTokenLifetimeSecs or will be cropped to this value.
+    std::shared_ptr<CallCredentials> ServiceAccountJWTAccessCredentials(
+        const grpc::string& json_key,
+        long token_lifetime_seconds = kMaxAuthTokenLifetimeSecs
+    );
+
+    /// Builds refresh token credentials.
+    /// json_refresh_token is the JSON string containing the refresh token along
+    /// with a client_id and client_secret.
+    ///
+    /// \warning Only use these credentials when connecting to a Google endpoint.
+    /// Using these credentials to connect to any other service may result in this
+    /// service being able to impersonate your client for requests to Google
+    /// services.
+    std::shared_ptr<CallCredentials> GoogleRefreshTokenCredentials(
+        const grpc::string& json_refresh_token
+    );
+
+    /// Builds access token credentials.
+    /// access_token is an oauth2 access token that was fetched using an out of band
+    /// mechanism.
+    ///
+    /// \warning Only use these credentials when connecting to a Google endpoint.
+    /// Using these credentials to connect to any other service may result in this
+    /// service being able to impersonate your client for requests to Google
+    /// services.
+    std::shared_ptr<CallCredentials> AccessTokenCredentials(
+        const grpc::string& access_token
+    );
+
+    /// Builds IAM credentials.
+    ///
+    /// \warning Only use these credentials when connecting to a Google endpoint.
+    /// Using these credentials to connect to any other service may result in this
+    /// service being able to impersonate your client for requests to Google
+    /// services.
+    std::shared_ptr<CallCredentials> GoogleIAMCredentials(
+        const grpc::string& authorization_token,
+        const grpc::string& authority_selector
+    );
+
+    /// Combines a channel credentials and a call credentials into a composite
+    /// channel credentials.
+    std::shared_ptr<ChannelCredentials> CompositeChannelCredentials(
+        const std::shared_ptr<ChannelCredentials>& channel_creds,
+        const std::shared_ptr<CallCredentials>& call_creds
+    );
+
+    /// Combines two call credentials objects into a composite call credentials.
+    std::shared_ptr<CallCredentials> CompositeCallCredentials(
+        const std::shared_ptr<CallCredentials>& creds1,
+        const std::shared_ptr<CallCredentials>& creds2
+    );
+
+    /// Credentials for an unencrypted, unauthenticated channel
+    std::shared_ptr<ChannelCredentials> InsecureChannelCredentials();
+
+    /// User defined metadata credentials.
+    class MetadataCredentialsPlugin
+    {
+    public:
+        virtual ~MetadataCredentialsPlugin()
+        {
+        }
+
+        /// If this method returns true, the Process function will be scheduled in
+        /// a different thread from the one processing the call.
+        virtual bool IsBlocking() const
+        {
+            return true;
+        }
+
+        /// Type of credentials this plugin is implementing.
+        virtual const char* GetType() const
+        {
+            return "";
+        }
+
+        /// Gets the auth metatada produced by this plugin.
+        /// The fully qualified method name is:
+        /// service_url + "/" + method_name.
+        /// The channel_auth_context contains (among other things), the identity of
+        /// the server.
+        virtual grpc::Status GetMetadata(
+            grpc::string_ref service_url, grpc::string_ref method_name, const grpc::AuthContext& channel_auth_context, std::multimap<grpc::string, grpc::string>* metadata
+        ) = 0;
+
+        virtual grpc::string DebugString()
+        {
+            return "MetadataCredentialsPlugin did not provide a debug string";
+        }
+    };
+
+    std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
+        std::unique_ptr<MetadataCredentialsPlugin> plugin
+    );
+
+    /// Builds External Account credentials.
+    /// json_string is the JSON string containing the credentials options.
+    /// scopes contains the scopes to be binded with the credentials.
+    std::shared_ptr<CallCredentials> ExternalAccountCredentials(
+        const grpc::string& json_string, const std::vector<grpc::string>& scopes
+    );
+
+    namespace experimental
+    {
+
+        /// Options for creating STS Oauth Token Exchange credentials following the IETF
+        /// draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16.
+        /// Optional fields may be set to empty string. It is the responsibility of the
+        /// caller to ensure that the subject and actor tokens are refreshed on disk at
+        /// the specified paths.
+        struct StsCredentialsOptions
+        {
+            grpc::string token_exchange_service_uri;  // Required.
+            grpc::string resource;                    // Optional.
+            grpc::string audience;                    // Optional.
+            grpc::string scope;                       // Optional.
+            grpc::string requested_token_type;        // Optional.
+            grpc::string subject_token_path;          // Required.
+            grpc::string subject_token_type;          // Required.
+            grpc::string actor_token_path;            // Optional.
+            grpc::string actor_token_type;            // Optional.
+        };
+
+        grpc::Status StsCredentialsOptionsFromJson(const std::string& json_string, StsCredentialsOptions* options);
+
+        /// Creates STS credentials options from the $STS_CREDENTIALS environment
+        /// variable. This environment variable points to the path of a JSON file
+        /// comforming to the schema described above.
+        grpc::Status StsCredentialsOptionsFromEnv(StsCredentialsOptions* options);
+
+        std::shared_ptr<CallCredentials> StsCredentials(
+            const StsCredentialsOptions& options
+        );
+
+        std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
+            std::unique_ptr<MetadataCredentialsPlugin> plugin,
+            grpc_security_level min_security_level
+        );
+
+        /// Options used to build AltsCredentials.
+        struct AltsCredentialsOptions
+        {
+            /// service accounts of target endpoint that will be acceptable
+            /// by the client. If service accounts are provided and none of them matches
+            /// that of the server, authentication will fail.
+            std::vector<grpc::string> target_service_accounts;
+        };
+
+        /// Builds ALTS Credentials given ALTS specific options
+        std::shared_ptr<ChannelCredentials> AltsCredentials(
+            const AltsCredentialsOptions& options
+        );
+
+        /// Builds Local Credentials.
+        std::shared_ptr<ChannelCredentials> LocalCredentials(
+            grpc_local_connect_type type
+        );
+
+        /// Builds TLS Credentials given TLS options.
+        std::shared_ptr<ChannelCredentials> TlsCredentials(
+            const TlsChannelCredentialsOptions& options
+        );
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_CREDENTIALS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/server_credentials.h b/CAPI/cpp/grpc/include/grpcpp/security/server_credentials.h
index 2d1bc07..5acdb51 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/server_credentials.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/server_credentials.h
@@ -29,117 +29,144 @@
 
 struct grpc_server;
 
-namespace grpc {
-
-class Server;
-class ServerCredentials;
-class SecureServerCredentials;
-/// Options to create ServerCredentials with SSL
-struct SslServerCredentialsOptions {
-  /// \warning Deprecated
-  SslServerCredentialsOptions()
-      : force_client_auth(false),
-        client_certificate_request(GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE) {}
-  explicit SslServerCredentialsOptions(
-      grpc_ssl_client_certificate_request_type request_type)
-      : force_client_auth(false), client_certificate_request(request_type) {}
-
-  struct PemKeyCertPair {
-    std::string private_key;
-    std::string cert_chain;
-  };
-  std::string pem_root_certs;
-  std::vector<PemKeyCertPair> pem_key_cert_pairs;
-  /// \warning Deprecated
-  bool force_client_auth;
-
-  /// If both \a force_client_auth and \a client_certificate_request
-  /// fields are set, \a force_client_auth takes effect, i.e.
-  /// \a REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY
-  /// will be enforced.
-  grpc_ssl_client_certificate_request_type client_certificate_request;
-};
-
-/// Builds Xds ServerCredentials given fallback credentials
-std::shared_ptr<ServerCredentials> XdsServerCredentials(
-    const std::shared_ptr<ServerCredentials>& fallback_credentials);
-
-namespace experimental {
-GRPC_DEPRECATED(
-    "Use grpc::XdsServerCredentials instead. The experimental version will be "
-    "deleted after the 1.41 release.")
-std::shared_ptr<ServerCredentials> XdsServerCredentials(
-    const std::shared_ptr<ServerCredentials>& fallback_credentials);
-}  // namespace experimental
-
-/// Wrapper around \a grpc_server_credentials, a way to authenticate a server.
-class ServerCredentials : private grpc::GrpcLibraryCodegen {
- public:
-  ServerCredentials();
-  ~ServerCredentials() override;
-
-  /// This method is not thread-safe and has to be called before the server is
-  /// started. The last call to this function wins.
-  virtual void SetAuthMetadataProcessor(
-      const std::shared_ptr<grpc::AuthMetadataProcessor>& processor) = 0;
-
- private:
-  friend class Server;
-
-  // We need this friend declaration for access to Insecure() and
-  // AsSecureServerCredentials(). When these two functions are no longer
-  // necessary, this friend declaration can be removed too.
-  friend std::shared_ptr<ServerCredentials> grpc::XdsServerCredentials(
-      const std::shared_ptr<ServerCredentials>& fallback_credentials);
-
-  /// Tries to bind \a server to the given \a addr (eg, localhost:1234,
-  /// 192.168.1.1:31416, [::1]:27182, etc.)
-  ///
-  /// \return bound port number on success, 0 on failure.
-  // TODO(dgq): the "port" part seems to be a misnomer.
-  virtual int AddPortToServer(const std::string& addr, grpc_server* server) = 0;
-
-  // TODO(yashykt): This is a hack since InsecureServerCredentials() cannot use
-  // grpc_insecure_server_credentials_create() and should be removed after
-  // insecure builds are removed from gRPC.
-  virtual bool IsInsecure() const { return false; }
-
-  // TODO(yashkt): This is a hack that should be removed once we remove insecure
-  // builds and the indirect method of adding ports to a server.
-  virtual SecureServerCredentials* AsSecureServerCredentials() {
-    return nullptr;
-  }
-};
-
-/// Builds SSL ServerCredentials given SSL specific options
-std::shared_ptr<ServerCredentials> SslServerCredentials(
-    const grpc::SslServerCredentialsOptions& options);
-
-std::shared_ptr<ServerCredentials> InsecureServerCredentials();
-
-namespace experimental {
-
-/// Options to create ServerCredentials with ALTS
-struct AltsServerCredentialsOptions {
-  /// Add fields if needed.
-};
-
-/// Builds ALTS ServerCredentials given ALTS specific options
-std::shared_ptr<ServerCredentials> AltsServerCredentials(
-    const AltsServerCredentialsOptions& options);
-
-/// Builds Local ServerCredentials.
-std::shared_ptr<ServerCredentials> AltsServerCredentials(
-    const AltsServerCredentialsOptions& options);
-
-std::shared_ptr<ServerCredentials> LocalServerCredentials(
-    grpc_local_connect_type type);
-
-/// Builds TLS ServerCredentials given TLS options.
-std::shared_ptr<ServerCredentials> TlsServerCredentials(
-    const experimental::TlsServerCredentialsOptions& options);
-
-}  // namespace experimental
+namespace grpc
+{
+
+    class Server;
+    class ServerCredentials;
+    class SecureServerCredentials;
+    /// Options to create ServerCredentials with SSL
+    struct SslServerCredentialsOptions
+    {
+        /// \warning Deprecated
+        SslServerCredentialsOptions() :
+            force_client_auth(false),
+            client_certificate_request(GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE)
+        {
+        }
+        explicit SslServerCredentialsOptions(
+            grpc_ssl_client_certificate_request_type request_type
+        ) :
+            force_client_auth(false),
+            client_certificate_request(request_type)
+        {
+        }
+
+        struct PemKeyCertPair
+        {
+            std::string private_key;
+            std::string cert_chain;
+        };
+        std::string pem_root_certs;
+        std::vector<PemKeyCertPair> pem_key_cert_pairs;
+        /// \warning Deprecated
+        bool force_client_auth;
+
+        /// If both \a force_client_auth and \a client_certificate_request
+        /// fields are set, \a force_client_auth takes effect, i.e.
+        /// \a REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY
+        /// will be enforced.
+        grpc_ssl_client_certificate_request_type client_certificate_request;
+    };
+
+    /// Builds Xds ServerCredentials given fallback credentials
+    std::shared_ptr<ServerCredentials> XdsServerCredentials(
+        const std::shared_ptr<ServerCredentials>& fallback_credentials
+    );
+
+    namespace experimental
+    {
+        GRPC_DEPRECATED(
+            "Use grpc::XdsServerCredentials instead. The experimental version will be "
+            "deleted after the 1.41 release."
+        )
+        std::shared_ptr<ServerCredentials> XdsServerCredentials(
+            const std::shared_ptr<ServerCredentials>& fallback_credentials
+        );
+    }  // namespace experimental
+
+    /// Wrapper around \a grpc_server_credentials, a way to authenticate a server.
+    class ServerCredentials : private grpc::GrpcLibraryCodegen
+    {
+    public:
+        ServerCredentials();
+        ~ServerCredentials() override;
+
+        /// This method is not thread-safe and has to be called before the server is
+        /// started. The last call to this function wins.
+        virtual void SetAuthMetadataProcessor(
+            const std::shared_ptr<grpc::AuthMetadataProcessor>& processor
+        ) = 0;
+
+    private:
+        friend class Server;
+
+        // We need this friend declaration for access to Insecure() and
+        // AsSecureServerCredentials(). When these two functions are no longer
+        // necessary, this friend declaration can be removed too.
+        friend std::shared_ptr<ServerCredentials> grpc::XdsServerCredentials(
+            const std::shared_ptr<ServerCredentials>& fallback_credentials
+        );
+
+        /// Tries to bind \a server to the given \a addr (eg, localhost:1234,
+        /// 192.168.1.1:31416, [::1]:27182, etc.)
+        ///
+        /// \return bound port number on success, 0 on failure.
+        // TODO(dgq): the "port" part seems to be a misnomer.
+        virtual int AddPortToServer(const std::string& addr, grpc_server* server) = 0;
+
+        // TODO(yashykt): This is a hack since InsecureServerCredentials() cannot use
+        // grpc_insecure_server_credentials_create() and should be removed after
+        // insecure builds are removed from gRPC.
+        virtual bool IsInsecure() const
+        {
+            return false;
+        }
+
+        // TODO(yashkt): This is a hack that should be removed once we remove insecure
+        // builds and the indirect method of adding ports to a server.
+        virtual SecureServerCredentials* AsSecureServerCredentials()
+        {
+            return nullptr;
+        }
+    };
+
+    /// Builds SSL ServerCredentials given SSL specific options
+    std::shared_ptr<ServerCredentials> SslServerCredentials(
+        const grpc::SslServerCredentialsOptions& options
+    );
+
+    std::shared_ptr<ServerCredentials> InsecureServerCredentials();
+
+    namespace experimental
+    {
+
+        /// Options to create ServerCredentials with ALTS
+        struct AltsServerCredentialsOptions
+        {
+            /// Add fields if needed.
+        };
+
+        /// Builds ALTS ServerCredentials given ALTS specific options
+        std::shared_ptr<ServerCredentials> AltsServerCredentials(
+            const AltsServerCredentialsOptions& options
+        );
+
+        /// Builds Local ServerCredentials.
+        std::shared_ptr<ServerCredentials> AltsServerCredentials(
+            const AltsServerCredentialsOptions& options
+        );
+
+        std::shared_ptr<ServerCredentials> LocalServerCredentials(
+            grpc_local_connect_type type
+        );
+
+        /// Builds TLS ServerCredentials given TLS options.
+        std::shared_ptr<ServerCredentials> TlsServerCredentials(
+            const experimental::TlsServerCredentialsOptions& options
+        );
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_SERVER_CREDENTIALS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_provider.h b/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_provider.h
index bbef455..e0fcec2 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_provider.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_provider.h
@@ -27,101 +27,113 @@
 #include <grpcpp/impl/codegen/grpc_library.h>
 #include <grpcpp/support/config.h>
 
-namespace grpc {
-namespace experimental {
-
-// Interface for a class that handles the process to fetch credential data.
-// Implementations should be a wrapper class of an internal provider
-// implementation.
-class CertificateProviderInterface {
- public:
-  virtual ~CertificateProviderInterface() = default;
-  virtual grpc_tls_certificate_provider* c_provider() = 0;
-};
-
-// A struct that stores the credential data presented to the peer in handshake
-// to show local identity. The private_key and certificate_chain should always
-// match.
-struct IdentityKeyCertPair {
-  std::string private_key;
-  std::string certificate_chain;
-};
-
-// A basic CertificateProviderInterface implementation that will load credential
-// data from static string during initialization. This provider will always
-// return the same cert data for all cert names, and reloading is not supported.
-class StaticDataCertificateProvider : public CertificateProviderInterface {
- public:
-  StaticDataCertificateProvider(
-      const std::string& root_certificate,
-      const std::vector<IdentityKeyCertPair>& identity_key_cert_pairs);
-
-  explicit StaticDataCertificateProvider(const std::string& root_certificate)
-      : StaticDataCertificateProvider(root_certificate, {}) {}
-
-  explicit StaticDataCertificateProvider(
-      const std::vector<IdentityKeyCertPair>& identity_key_cert_pairs)
-      : StaticDataCertificateProvider("", identity_key_cert_pairs) {}
-
-  ~StaticDataCertificateProvider() override;
-
-  grpc_tls_certificate_provider* c_provider() override { return c_provider_; }
-
- private:
-  grpc_tls_certificate_provider* c_provider_ = nullptr;
-};
-
-// A CertificateProviderInterface implementation that will watch the credential
-// changes on the file system. This provider will always return the up-to-date
-// cert data for all the cert names callers set through |TlsCredentialsOptions|.
-// Several things to note:
-// 1. This API only supports one key-cert file and hence one set of identity
-// key-cert pair, so SNI(Server Name Indication) is not supported.
-// 2. The private key and identity certificate should always match. This API
-// guarantees atomic read, and it is the callers' responsibility to do atomic
-// updates. There are many ways to atomically update the key and certs in the
-// file system. To name a few:
-//   1)  creating a new directory, renaming the old directory to a new name, and
-//   then renaming the new directory to the original name of the old directory.
-//   2)  using a symlink for the directory. When need to change, put new
-//   credential data in a new directory, and change symlink.
-class FileWatcherCertificateProvider final
-    : public CertificateProviderInterface {
- public:
-  // Constructor to get credential updates from root and identity file paths.
-  //
-  // @param private_key_path is the file path of the private key.
-  // @param identity_certificate_path is the file path of the identity
-  // certificate chain.
-  // @param root_cert_path is the file path to the root certificate bundle.
-  // @param refresh_interval_sec is the refreshing interval that we will check
-  // the files for updates.
-  FileWatcherCertificateProvider(const std::string& private_key_path,
-                                 const std::string& identity_certificate_path,
-                                 const std::string& root_cert_path,
-                                 unsigned int refresh_interval_sec);
-  // Constructor to get credential updates from identity file paths only.
-  FileWatcherCertificateProvider(const std::string& private_key_path,
-                                 const std::string& identity_certificate_path,
-                                 unsigned int refresh_interval_sec)
-      : FileWatcherCertificateProvider(private_key_path,
-                                       identity_certificate_path, "",
-                                       refresh_interval_sec) {}
-  // Constructor to get credential updates from root file path only.
-  FileWatcherCertificateProvider(const std::string& root_cert_path,
-                                 unsigned int refresh_interval_sec)
-      : FileWatcherCertificateProvider("", "", root_cert_path,
-                                       refresh_interval_sec) {}
-
-  ~FileWatcherCertificateProvider() override;
-
-  grpc_tls_certificate_provider* c_provider() override { return c_provider_; }
-
- private:
-  grpc_tls_certificate_provider* c_provider_ = nullptr;
-};
-
-}  // namespace experimental
+namespace grpc
+{
+    namespace experimental
+    {
+
+        // Interface for a class that handles the process to fetch credential data.
+        // Implementations should be a wrapper class of an internal provider
+        // implementation.
+        class CertificateProviderInterface
+        {
+        public:
+            virtual ~CertificateProviderInterface() = default;
+            virtual grpc_tls_certificate_provider* c_provider() = 0;
+        };
+
+        // A struct that stores the credential data presented to the peer in handshake
+        // to show local identity. The private_key and certificate_chain should always
+        // match.
+        struct IdentityKeyCertPair
+        {
+            std::string private_key;
+            std::string certificate_chain;
+        };
+
+        // A basic CertificateProviderInterface implementation that will load credential
+        // data from static string during initialization. This provider will always
+        // return the same cert data for all cert names, and reloading is not supported.
+        class StaticDataCertificateProvider : public CertificateProviderInterface
+        {
+        public:
+            StaticDataCertificateProvider(
+                const std::string& root_certificate,
+                const std::vector<IdentityKeyCertPair>& identity_key_cert_pairs
+            );
+
+            explicit StaticDataCertificateProvider(const std::string& root_certificate) :
+                StaticDataCertificateProvider(root_certificate, {})
+            {
+            }
+
+            explicit StaticDataCertificateProvider(
+                const std::vector<IdentityKeyCertPair>& identity_key_cert_pairs
+            ) :
+                StaticDataCertificateProvider("", identity_key_cert_pairs)
+            {
+            }
+
+            ~StaticDataCertificateProvider() override;
+
+            grpc_tls_certificate_provider* c_provider() override
+            {
+                return c_provider_;
+            }
+
+        private:
+            grpc_tls_certificate_provider* c_provider_ = nullptr;
+        };
+
+        // A CertificateProviderInterface implementation that will watch the credential
+        // changes on the file system. This provider will always return the up-to-date
+        // cert data for all the cert names callers set through |TlsCredentialsOptions|.
+        // Several things to note:
+        // 1. This API only supports one key-cert file and hence one set of identity
+        // key-cert pair, so SNI(Server Name Indication) is not supported.
+        // 2. The private key and identity certificate should always match. This API
+        // guarantees atomic read, and it is the callers' responsibility to do atomic
+        // updates. There are many ways to atomically update the key and certs in the
+        // file system. To name a few:
+        //   1)  creating a new directory, renaming the old directory to a new name, and
+        //   then renaming the new directory to the original name of the old directory.
+        //   2)  using a symlink for the directory. When need to change, put new
+        //   credential data in a new directory, and change symlink.
+        class FileWatcherCertificateProvider final : public CertificateProviderInterface
+        {
+        public:
+            // Constructor to get credential updates from root and identity file paths.
+            //
+            // @param private_key_path is the file path of the private key.
+            // @param identity_certificate_path is the file path of the identity
+            // certificate chain.
+            // @param root_cert_path is the file path to the root certificate bundle.
+            // @param refresh_interval_sec is the refreshing interval that we will check
+            // the files for updates.
+            FileWatcherCertificateProvider(const std::string& private_key_path, const std::string& identity_certificate_path, const std::string& root_cert_path, unsigned int refresh_interval_sec);
+            // Constructor to get credential updates from identity file paths only.
+            FileWatcherCertificateProvider(const std::string& private_key_path, const std::string& identity_certificate_path, unsigned int refresh_interval_sec) :
+                FileWatcherCertificateProvider(private_key_path, identity_certificate_path, "", refresh_interval_sec)
+            {
+            }
+            // Constructor to get credential updates from root file path only.
+            FileWatcherCertificateProvider(const std::string& root_cert_path, unsigned int refresh_interval_sec) :
+                FileWatcherCertificateProvider("", "", root_cert_path, refresh_interval_sec)
+            {
+            }
+
+            ~FileWatcherCertificateProvider() override;
+
+            grpc_tls_certificate_provider* c_provider() override
+            {
+                return c_provider_;
+            }
+
+        private:
+            grpc_tls_certificate_provider* c_provider_ = nullptr;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_TLS_CERTIFICATE_PROVIDER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_verifier.h b/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_verifier.h
index 881adf2..de78273 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_verifier.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/tls_certificate_verifier.h
@@ -40,199 +40,216 @@ typedef struct grpc_tls_certificate_verifier grpc_tls_certificate_verifier;
 typedef struct grpc_tls_certificate_verifier_external
     grpc_tls_certificate_verifier_external;
 typedef void (*grpc_tls_on_custom_verification_check_done_cb)(
-    grpc_tls_custom_verification_check_request* request, void* callback_arg,
-    grpc_status_code status, const char* error_details);
+    grpc_tls_custom_verification_check_request* request, void* callback_arg, grpc_status_code status, const char* error_details
+);
 extern "C" grpc_tls_certificate_verifier*
-grpc_tls_certificate_verifier_external_create(
-    grpc_tls_certificate_verifier_external* external_verifier);
-
-namespace grpc {
-namespace experimental {
-
-// Contains the verification-related information associated with a connection
-// request. Users should not directly create or destroy this request object, but
-// shall interact with it through CertificateVerifier's Verify() and Cancel().
-class TlsCustomVerificationCheckRequest {
- public:
-  explicit TlsCustomVerificationCheckRequest(
-      grpc_tls_custom_verification_check_request* request);
-  ~TlsCustomVerificationCheckRequest() {}
-
-  grpc::string_ref target_name() const;
-  grpc::string_ref peer_cert() const;
-  grpc::string_ref peer_cert_full_chain() const;
-  grpc::string_ref common_name() const;
-  std::vector<grpc::string_ref> uri_names() const;
-  std::vector<grpc::string_ref> dns_names() const;
-  std::vector<grpc::string_ref> email_names() const;
-  std::vector<grpc::string_ref> ip_names() const;
-
-  grpc_tls_custom_verification_check_request* c_request() { return c_request_; }
-
- private:
-  grpc_tls_custom_verification_check_request* c_request_ = nullptr;
-};
-
-// The base class of all internal verifier implementations, and the ultimate
-// class that all external verifiers will eventually be transformed into.
-// To implement a custom verifier, do not extend this class; instead,
-// implement a subclass of ExternalCertificateVerifier. Note that custom
-// verifier implementations can compose their functionality with existing
-// implementations of this interface, such as HostnameVerifier, by delegating
-// to an instance of that class.
-class CertificateVerifier {
- public:
-  explicit CertificateVerifier(grpc_tls_certificate_verifier* v);
-
-  ~CertificateVerifier();
-
-  // Verifies a connection request, based on the logic specified in an internal
-  // verifier. The check on each internal verifier could be either synchronous
-  // or asynchronous, and we will need to use return value to know.
-  //
-  // request: the verification information associated with this request
-  // callback: This will only take effect if the verifier is asynchronous.
-  //           The function that gRPC will invoke when the verifier has already
-  //           completed its asynchronous check. Callers can use this function
-  //           to perform any additional checks. The input parameter of the
-  //           std::function indicates the status of the verifier check.
-  // sync_status: This will only be useful if the verifier is synchronous.
-  //              The status of the verifier as it has already done it's
-  //              synchronous check.
-  // return: return true if executed synchronously, otherwise return false
-  bool Verify(TlsCustomVerificationCheckRequest* request,
-              std::function<void(grpc::Status)> callback,
-              grpc::Status* sync_status);
-
-  // Cancels a verification request previously started via Verify().
-  // Used when the connection attempt times out or is cancelled while an async
-  // verification request is pending.
-  //
-  // request: the verification information associated with this request
-  void Cancel(TlsCustomVerificationCheckRequest* request);
-
-  // Gets the core verifier used internally.
-  grpc_tls_certificate_verifier* c_verifier() { return verifier_; }
-
- private:
-  static void AsyncCheckDone(
-      grpc_tls_custom_verification_check_request* request, void* callback_arg,
-      grpc_status_code status, const char* error_details);
-
-  grpc_tls_certificate_verifier* verifier_ = nullptr;
-  grpc::internal::Mutex mu_;
-  std::map<grpc_tls_custom_verification_check_request*,
-           std::function<void(grpc::Status)>>
-      request_map_ ABSL_GUARDED_BY(mu_);
-};
-
-// The base class of all external, user-specified verifiers. Users should
-// inherit this class to implement a custom verifier.
-// Note that while implementing the custom verifier that extends this class, it
-// is possible to compose an existing ExternalCertificateVerifier or
-// CertificateVerifier, inside the Verify() and Cancel() function of the new
-// custom verifier.
-class ExternalCertificateVerifier {
- public:
-  // A factory method for creating a |CertificateVerifier| from this class. All
-  // the user-implemented verifiers should use this function to be converted to
-  // verifiers compatible with |TlsCredentialsOptions|.
-  // The resulting CertificateVerifier takes ownership of the newly instantiated
-  // Subclass.
-  template <typename Subclass, typename... Args>
-  static std::shared_ptr<CertificateVerifier> Create(Args&&... args) {
-    grpc::internal::GrpcLibraryInitializer g_gli_initializer;
-    g_gli_initializer.summon();
-    auto* external_verifier = new Subclass(std::forward<Args>(args)...);
-    return std::make_shared<CertificateVerifier>(
-        grpc_tls_certificate_verifier_external_create(
-            external_verifier->base_));
-  }
-
-  // The verification logic that will be performed after the TLS handshake
-  // completes. Implementers can choose to do their checks synchronously or
-  // asynchronously.
-  //
-  // request: the verification information associated with this request
-  // callback: This should only be used if your check is done asynchronously.
-  //           When the asynchronous work is done, invoke this callback function
-  //           with the proper status, indicating the success or the failure of
-  //           the check. The implementer MUST NOT invoke this |callback| in the
-  //           same thread before Verify() returns, otherwise it can lead to
-  //           deadlocks.
-  // sync_status: This should only be used if your check is done synchronously.
-  //              Modifies this value to indicate the success or the failure of
-  //              the check.
-  // return: return true if your check is done synchronously, otherwise return
-  //         false
-  virtual bool Verify(TlsCustomVerificationCheckRequest* request,
-                      std::function<void(grpc::Status)> callback,
-                      grpc::Status* sync_status) = 0;
-
-  // Cancels a verification request previously started via Verify().
-  // Used when the connection attempt times out or is cancelled while an async
-  // verification request is pending. The implementation should abort whatever
-  // async operation it is waiting for and quickly invoke the callback that was
-  // passed to Verify() with a status indicating the cancellation.
-  //
-  // request: the verification information associated with this request
-  virtual void Cancel(TlsCustomVerificationCheckRequest* request) = 0;
-
- protected:
-  ExternalCertificateVerifier();
-
-  virtual ~ExternalCertificateVerifier();
-
- private:
-  struct AsyncRequestState {
-    AsyncRequestState(grpc_tls_on_custom_verification_check_done_cb cb,
-                      void* arg,
-                      grpc_tls_custom_verification_check_request* request)
-        : callback(cb), callback_arg(arg), cpp_request(request) {}
-
-    grpc_tls_on_custom_verification_check_done_cb callback;
-    void* callback_arg;
-    TlsCustomVerificationCheckRequest cpp_request;
-  };
-
-  static int VerifyInCoreExternalVerifier(
-      void* user_data, grpc_tls_custom_verification_check_request* request,
-      grpc_tls_on_custom_verification_check_done_cb callback,
-      void* callback_arg, grpc_status_code* sync_status,
-      char** sync_error_details);
-
-  static void CancelInCoreExternalVerifier(
-      void* user_data, grpc_tls_custom_verification_check_request* request);
-
-  static void DestructInCoreExternalVerifier(void* user_data);
-
-  // TODO(yihuazhang): after the insecure build is removed, make this an object
-  // member instead of a pointer.
-  grpc_tls_certificate_verifier_external* base_ = nullptr;
-  grpc::internal::Mutex mu_;
-  std::map<grpc_tls_custom_verification_check_request*, AsyncRequestState>
-      request_map_ ABSL_GUARDED_BY(mu_);
-};
-
-// A CertificateVerifier that doesn't perform any additional checks other than
-// certificate verification, if specified.
-// Note: using this solely without any other authentication mechanisms on the
-// peer identity will leave your applications to the MITM(Man-In-The-Middle)
-// attacks. Users should avoid doing so in production environments.
-class NoOpCertificateVerifier : public CertificateVerifier {
- public:
-  NoOpCertificateVerifier();
-};
-
-// A CertificateVerifier that will perform hostname verification, to see if the
-// target name set from the client side matches the identity information
-// specified on the server's certificate.
-class HostNameCertificateVerifier : public CertificateVerifier {
- public:
-  HostNameCertificateVerifier();
-};
-
-}  // namespace experimental
+    grpc_tls_certificate_verifier_external_create(
+        grpc_tls_certificate_verifier_external* external_verifier
+    );
+
+namespace grpc
+{
+    namespace experimental
+    {
+
+        // Contains the verification-related information associated with a connection
+        // request. Users should not directly create or destroy this request object, but
+        // shall interact with it through CertificateVerifier's Verify() and Cancel().
+        class TlsCustomVerificationCheckRequest
+        {
+        public:
+            explicit TlsCustomVerificationCheckRequest(
+                grpc_tls_custom_verification_check_request* request
+            );
+            ~TlsCustomVerificationCheckRequest()
+            {
+            }
+
+            grpc::string_ref target_name() const;
+            grpc::string_ref peer_cert() const;
+            grpc::string_ref peer_cert_full_chain() const;
+            grpc::string_ref common_name() const;
+            std::vector<grpc::string_ref> uri_names() const;
+            std::vector<grpc::string_ref> dns_names() const;
+            std::vector<grpc::string_ref> email_names() const;
+            std::vector<grpc::string_ref> ip_names() const;
+
+            grpc_tls_custom_verification_check_request* c_request()
+            {
+                return c_request_;
+            }
+
+        private:
+            grpc_tls_custom_verification_check_request* c_request_ = nullptr;
+        };
+
+        // The base class of all internal verifier implementations, and the ultimate
+        // class that all external verifiers will eventually be transformed into.
+        // To implement a custom verifier, do not extend this class; instead,
+        // implement a subclass of ExternalCertificateVerifier. Note that custom
+        // verifier implementations can compose their functionality with existing
+        // implementations of this interface, such as HostnameVerifier, by delegating
+        // to an instance of that class.
+        class CertificateVerifier
+        {
+        public:
+            explicit CertificateVerifier(grpc_tls_certificate_verifier* v);
+
+            ~CertificateVerifier();
+
+            // Verifies a connection request, based on the logic specified in an internal
+            // verifier. The check on each internal verifier could be either synchronous
+            // or asynchronous, and we will need to use return value to know.
+            //
+            // request: the verification information associated with this request
+            // callback: This will only take effect if the verifier is asynchronous.
+            //           The function that gRPC will invoke when the verifier has already
+            //           completed its asynchronous check. Callers can use this function
+            //           to perform any additional checks. The input parameter of the
+            //           std::function indicates the status of the verifier check.
+            // sync_status: This will only be useful if the verifier is synchronous.
+            //              The status of the verifier as it has already done it's
+            //              synchronous check.
+            // return: return true if executed synchronously, otherwise return false
+            bool Verify(TlsCustomVerificationCheckRequest* request, std::function<void(grpc::Status)> callback, grpc::Status* sync_status);
+
+            // Cancels a verification request previously started via Verify().
+            // Used when the connection attempt times out or is cancelled while an async
+            // verification request is pending.
+            //
+            // request: the verification information associated with this request
+            void Cancel(TlsCustomVerificationCheckRequest* request);
+
+            // Gets the core verifier used internally.
+            grpc_tls_certificate_verifier* c_verifier()
+            {
+                return verifier_;
+            }
+
+        private:
+            static void AsyncCheckDone(
+                grpc_tls_custom_verification_check_request* request, void* callback_arg, grpc_status_code status, const char* error_details
+            );
+
+            grpc_tls_certificate_verifier* verifier_ = nullptr;
+            grpc::internal::Mutex mu_;
+            std::map<grpc_tls_custom_verification_check_request*, std::function<void(grpc::Status)>>
+                request_map_ ABSL_GUARDED_BY(mu_);
+        };
+
+        // The base class of all external, user-specified verifiers. Users should
+        // inherit this class to implement a custom verifier.
+        // Note that while implementing the custom verifier that extends this class, it
+        // is possible to compose an existing ExternalCertificateVerifier or
+        // CertificateVerifier, inside the Verify() and Cancel() function of the new
+        // custom verifier.
+        class ExternalCertificateVerifier
+        {
+        public:
+            // A factory method for creating a |CertificateVerifier| from this class. All
+            // the user-implemented verifiers should use this function to be converted to
+            // verifiers compatible with |TlsCredentialsOptions|.
+            // The resulting CertificateVerifier takes ownership of the newly instantiated
+            // Subclass.
+            template<typename Subclass, typename... Args>
+            static std::shared_ptr<CertificateVerifier> Create(Args&&... args)
+            {
+                grpc::internal::GrpcLibraryInitializer g_gli_initializer;
+                g_gli_initializer.summon();
+                auto* external_verifier = new Subclass(std::forward<Args>(args)...);
+                return std::make_shared<CertificateVerifier>(
+                    grpc_tls_certificate_verifier_external_create(
+                        external_verifier->base_
+                    )
+                );
+            }
+
+            // The verification logic that will be performed after the TLS handshake
+            // completes. Implementers can choose to do their checks synchronously or
+            // asynchronously.
+            //
+            // request: the verification information associated with this request
+            // callback: This should only be used if your check is done asynchronously.
+            //           When the asynchronous work is done, invoke this callback function
+            //           with the proper status, indicating the success or the failure of
+            //           the check. The implementer MUST NOT invoke this |callback| in the
+            //           same thread before Verify() returns, otherwise it can lead to
+            //           deadlocks.
+            // sync_status: This should only be used if your check is done synchronously.
+            //              Modifies this value to indicate the success or the failure of
+            //              the check.
+            // return: return true if your check is done synchronously, otherwise return
+            //         false
+            virtual bool Verify(TlsCustomVerificationCheckRequest* request, std::function<void(grpc::Status)> callback, grpc::Status* sync_status) = 0;
+
+            // Cancels a verification request previously started via Verify().
+            // Used when the connection attempt times out or is cancelled while an async
+            // verification request is pending. The implementation should abort whatever
+            // async operation it is waiting for and quickly invoke the callback that was
+            // passed to Verify() with a status indicating the cancellation.
+            //
+            // request: the verification information associated with this request
+            virtual void Cancel(TlsCustomVerificationCheckRequest* request) = 0;
+
+        protected:
+            ExternalCertificateVerifier();
+
+            virtual ~ExternalCertificateVerifier();
+
+        private:
+            struct AsyncRequestState
+            {
+                AsyncRequestState(grpc_tls_on_custom_verification_check_done_cb cb, void* arg, grpc_tls_custom_verification_check_request* request) :
+                    callback(cb),
+                    callback_arg(arg),
+                    cpp_request(request)
+                {
+                }
+
+                grpc_tls_on_custom_verification_check_done_cb callback;
+                void* callback_arg;
+                TlsCustomVerificationCheckRequest cpp_request;
+            };
+
+            static int VerifyInCoreExternalVerifier(
+                void* user_data, grpc_tls_custom_verification_check_request* request, grpc_tls_on_custom_verification_check_done_cb callback, void* callback_arg, grpc_status_code* sync_status, char** sync_error_details
+            );
+
+            static void CancelInCoreExternalVerifier(
+                void* user_data, grpc_tls_custom_verification_check_request* request
+            );
+
+            static void DestructInCoreExternalVerifier(void* user_data);
+
+            // TODO(yihuazhang): after the insecure build is removed, make this an object
+            // member instead of a pointer.
+            grpc_tls_certificate_verifier_external* base_ = nullptr;
+            grpc::internal::Mutex mu_;
+            std::map<grpc_tls_custom_verification_check_request*, AsyncRequestState>
+                request_map_ ABSL_GUARDED_BY(mu_);
+        };
+
+        // A CertificateVerifier that doesn't perform any additional checks other than
+        // certificate verification, if specified.
+        // Note: using this solely without any other authentication mechanisms on the
+        // peer identity will leave your applications to the MITM(Man-In-The-Middle)
+        // attacks. Users should avoid doing so in production environments.
+        class NoOpCertificateVerifier : public CertificateVerifier
+        {
+        public:
+            NoOpCertificateVerifier();
+        };
+
+        // A CertificateVerifier that will perform hostname verification, to see if the
+        // target name set from the client side matches the identity information
+        // specified on the server's certificate.
+        class HostNameCertificateVerifier : public CertificateVerifier
+        {
+        public:
+            HostNameCertificateVerifier();
+        };
+
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_TLS_CERTIFICATE_VERIFIER_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/security/tls_credentials_options.h b/CAPI/cpp/grpc/include/grpcpp/security/tls_credentials_options.h
index 220c953..ccac386 100644
--- a/CAPI/cpp/grpc/include/grpcpp/security/tls_credentials_options.h
+++ b/CAPI/cpp/grpc/include/grpcpp/security/tls_credentials_options.h
@@ -30,128 +30,140 @@
 #include <grpcpp/security/tls_certificate_verifier.h>
 #include <grpcpp/support/config.h>
 
-namespace grpc {
-namespace experimental {
+namespace grpc
+{
+    namespace experimental
+    {
 
-// Base class of configurable options specified by users to configure their
-// certain security features supported in TLS. It is used for experimental
-// purposes for now and it is subject to change.
-class TlsCredentialsOptions {
- public:
-  // Constructor for base class TlsCredentialsOptions.
-  //
-  // @param certificate_provider the provider which fetches TLS credentials that
-  // will be used in the TLS handshake
-  TlsCredentialsOptions();
-  // ---- Setters for member fields ----
-  // Sets the certificate provider used to store root certs and identity certs.
-  void set_certificate_provider(
-      std::shared_ptr<CertificateProviderInterface> certificate_provider);
-  // Watches the updates of root certificates with name |root_cert_name|.
-  // If used in TLS credentials, setting this field is optional for both the
-  // client side and the server side.
-  // If this is not set on the client side, we will use the root certificates
-  // stored in the default system location, since client side must provide root
-  // certificates in TLS(no matter single-side TLS or mutual TLS).
-  // If this is not set on the server side, we will not watch any root
-  // certificate updates, and assume no root certificates needed for the server
-  // (in the one-side TLS scenario, the server is not required to provide root
-  // certs). We don't support default root certs on server side.
-  void watch_root_certs();
-  // Sets the name of root certificates being watched, if |watch_root_certs| is
-  // called. If not set, an empty string will be used as the name.
-  //
-  // @param root_cert_name the name of root certs being set.
-  void set_root_cert_name(const std::string& root_cert_name);
-  // Watches the updates of identity key-cert pairs with name
-  // |identity_cert_name|. If used in TLS credentials, it is required to be set
-  // on the server side, and optional for the client side(in the one-side
-  // TLS scenario, the client is not required to provide identity certs).
-  void watch_identity_key_cert_pairs();
-  // Sets the name of identity key-cert pairs being watched, if
-  // |watch_identity_key_cert_pairs| is called. If not set, an empty string will
-  // be used as the name.
-  //
-  // @param identity_cert_name the name of identity key-cert pairs being set.
-  void set_identity_cert_name(const std::string& identity_cert_name);
-  // Sets the Tls session key logging configuration. If not set, tls
-  // session key logging is disabled. Note that this should be used only for
-  // debugging purposes. It should never be used in a production environment
-  // due to security concerns.
-  //
-  // @param tls_session_key_log_file_path: Path where tls session keys would
-  // be logged.
-  void set_tls_session_key_log_file_path(
-      const std::string& tls_session_key_log_file_path);
-  // Sets the certificate verifier used to perform post-handshake peer identity
-  // checks.
-  void set_certificate_verifier(
-      std::shared_ptr<CertificateVerifier> certificate_verifier);
-  // Sets the options of whether to check the hostname of the peer on a per-call
-  // basis. This is usually used in a combination with virtual hosting at the
-  // client side, where each individual call on a channel can have a different
-  // host associated with it.
-  // This check is intended to verify that the host specified for the individual
-  // call is covered by the cert that the peer presented.
-  // We will perform such checks by default. This should be disabled if
-  // verifiers other than the host name verifier is used.
-  void set_check_call_host(bool check_call_host);
+        // Base class of configurable options specified by users to configure their
+        // certain security features supported in TLS. It is used for experimental
+        // purposes for now and it is subject to change.
+        class TlsCredentialsOptions
+        {
+        public:
+            // Constructor for base class TlsCredentialsOptions.
+            //
+            // @param certificate_provider the provider which fetches TLS credentials that
+            // will be used in the TLS handshake
+            TlsCredentialsOptions();
+            // ---- Setters for member fields ----
+            // Sets the certificate provider used to store root certs and identity certs.
+            void set_certificate_provider(
+                std::shared_ptr<CertificateProviderInterface> certificate_provider
+            );
+            // Watches the updates of root certificates with name |root_cert_name|.
+            // If used in TLS credentials, setting this field is optional for both the
+            // client side and the server side.
+            // If this is not set on the client side, we will use the root certificates
+            // stored in the default system location, since client side must provide root
+            // certificates in TLS(no matter single-side TLS or mutual TLS).
+            // If this is not set on the server side, we will not watch any root
+            // certificate updates, and assume no root certificates needed for the server
+            // (in the one-side TLS scenario, the server is not required to provide root
+            // certs). We don't support default root certs on server side.
+            void watch_root_certs();
+            // Sets the name of root certificates being watched, if |watch_root_certs| is
+            // called. If not set, an empty string will be used as the name.
+            //
+            // @param root_cert_name the name of root certs being set.
+            void set_root_cert_name(const std::string& root_cert_name);
+            // Watches the updates of identity key-cert pairs with name
+            // |identity_cert_name|. If used in TLS credentials, it is required to be set
+            // on the server side, and optional for the client side(in the one-side
+            // TLS scenario, the client is not required to provide identity certs).
+            void watch_identity_key_cert_pairs();
+            // Sets the name of identity key-cert pairs being watched, if
+            // |watch_identity_key_cert_pairs| is called. If not set, an empty string will
+            // be used as the name.
+            //
+            // @param identity_cert_name the name of identity key-cert pairs being set.
+            void set_identity_cert_name(const std::string& identity_cert_name);
+            // Sets the Tls session key logging configuration. If not set, tls
+            // session key logging is disabled. Note that this should be used only for
+            // debugging purposes. It should never be used in a production environment
+            // due to security concerns.
+            //
+            // @param tls_session_key_log_file_path: Path where tls session keys would
+            // be logged.
+            void set_tls_session_key_log_file_path(
+                const std::string& tls_session_key_log_file_path
+            );
+            // Sets the certificate verifier used to perform post-handshake peer identity
+            // checks.
+            void set_certificate_verifier(
+                std::shared_ptr<CertificateVerifier> certificate_verifier
+            );
+            // Sets the options of whether to check the hostname of the peer on a per-call
+            // basis. This is usually used in a combination with virtual hosting at the
+            // client side, where each individual call on a channel can have a different
+            // host associated with it.
+            // This check is intended to verify that the host specified for the individual
+            // call is covered by the cert that the peer presented.
+            // We will perform such checks by default. This should be disabled if
+            // verifiers other than the host name verifier is used.
+            void set_check_call_host(bool check_call_host);
 
-  // TODO(zhenlian): This is an experimental API is likely to change in the
-  // future. Before de-experiementalizing, verify the API is up to date.
-  // If set, gRPC will read all hashed x.509 CRL files in the directory and
-  // enforce the CRL files on all TLS handshakes. Only supported for OpenSSL
-  // version > 1.1.
-  void set_crl_directory(const std::string& path);
+            // TODO(zhenlian): This is an experimental API is likely to change in the
+            // future. Before de-experiementalizing, verify the API is up to date.
+            // If set, gRPC will read all hashed x.509 CRL files in the directory and
+            // enforce the CRL files on all TLS handshakes. Only supported for OpenSSL
+            // version > 1.1.
+            void set_crl_directory(const std::string& path);
 
-  // ----- Getters for member fields ----
-  // Get the internal c options. This function shall be used only internally.
-  grpc_tls_credentials_options* c_credentials_options() const {
-    return c_credentials_options_;
-  }
+            // ----- Getters for member fields ----
+            // Get the internal c options. This function shall be used only internally.
+            grpc_tls_credentials_options* c_credentials_options() const
+            {
+                return c_credentials_options_;
+            }
 
- private:
-  std::shared_ptr<CertificateProviderInterface> certificate_provider_;
-  std::shared_ptr<CertificateVerifier> certificate_verifier_;
-  grpc_tls_credentials_options* c_credentials_options_ = nullptr;
-};
+        private:
+            std::shared_ptr<CertificateProviderInterface> certificate_provider_;
+            std::shared_ptr<CertificateVerifier> certificate_verifier_;
+            grpc_tls_credentials_options* c_credentials_options_ = nullptr;
+        };
 
-// Contains configurable options on the client side.
-// Client side doesn't need to always use certificate provider. When the
-// certificate provider is not set, we will use the root certificates stored
-// in the system default locations, and assume client won't provide any
-// identity certificates(single side TLS).
-// It is used for experimental purposes for now and it is subject to change.
-class TlsChannelCredentialsOptions final : public TlsCredentialsOptions {
- public:
-  // Sets the decision of whether to do a crypto check on the server certs.
-  // The default is true.
-  void set_verify_server_certs(bool verify_server_certs);
+        // Contains configurable options on the client side.
+        // Client side doesn't need to always use certificate provider. When the
+        // certificate provider is not set, we will use the root certificates stored
+        // in the system default locations, and assume client won't provide any
+        // identity certificates(single side TLS).
+        // It is used for experimental purposes for now and it is subject to change.
+        class TlsChannelCredentialsOptions final : public TlsCredentialsOptions
+        {
+        public:
+            // Sets the decision of whether to do a crypto check on the server certs.
+            // The default is true.
+            void set_verify_server_certs(bool verify_server_certs);
 
- private:
-};
+        private:
+        };
 
-// Contains configurable options on the server side.
-// It is used for experimental purposes for now and it is subject to change.
-class TlsServerCredentialsOptions final : public TlsCredentialsOptions {
- public:
-  // Server side is required to use a provider, because server always needs to
-  // use identity certs.
-  explicit TlsServerCredentialsOptions(
-      std::shared_ptr<CertificateProviderInterface> certificate_provider)
-      : TlsCredentialsOptions() {
-    set_certificate_provider(certificate_provider);
-  }
+        // Contains configurable options on the server side.
+        // It is used for experimental purposes for now and it is subject to change.
+        class TlsServerCredentialsOptions final : public TlsCredentialsOptions
+        {
+        public:
+            // Server side is required to use a provider, because server always needs to
+            // use identity certs.
+            explicit TlsServerCredentialsOptions(
+                std::shared_ptr<CertificateProviderInterface> certificate_provider
+            ) :
+                TlsCredentialsOptions()
+            {
+                set_certificate_provider(certificate_provider);
+            }
 
-  // Sets option to request the certificates from the client.
-  // The default is GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE.
-  void set_cert_request_type(
-      grpc_ssl_client_certificate_request_type cert_request_type);
+            // Sets option to request the certificates from the client.
+            // The default is GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE.
+            void set_cert_request_type(
+                grpc_ssl_client_certificate_request_type cert_request_type
+            );
 
- private:
-};
+        private:
+        };
 
-}  // namespace experimental
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif  // GRPCPP_SECURITY_TLS_CREDENTIALS_OPTIONS_H
diff --git a/CAPI/cpp/grpc/include/grpcpp/server.h b/CAPI/cpp/grpc/include/grpcpp/server.h
index dce8744..a5317ae 100644
--- a/CAPI/cpp/grpc/include/grpcpp/server.h
+++ b/CAPI/cpp/grpc/include/grpcpp/server.h
@@ -43,304 +43,324 @@
 
 struct grpc_server;
 
-namespace grpc {
-class AsyncGenericService;
-class ServerContext;
-class ServerInitializer;
-
-namespace internal {
-class ExternalConnectionAcceptorImpl;
-}  // namespace internal
-
-/// Represents a gRPC server.
-///
-/// Use a \a grpc::ServerBuilder to create, configure, and start
-/// \a Server instances.
-class Server : public ServerInterface, private GrpcLibraryCodegen {
- public:
-  ~Server() ABSL_LOCKS_EXCLUDED(mu_) override;
-
-  /// Block until the server shuts down.
-  ///
-  /// \warning The server must be either shutting down or some other thread must
-  /// call \a Shutdown for this function to ever return.
-  void Wait() ABSL_LOCKS_EXCLUDED(mu_) override;
-
-  /// Global callbacks are a set of hooks that are called when server
-  /// events occur.  \a SetGlobalCallbacks method is used to register
-  /// the hooks with gRPC.  Note that
-  /// the \a GlobalCallbacks instance will be shared among all
-  /// \a Server instances in an application and can be set exactly
-  /// once per application.
-  class GlobalCallbacks {
-   public:
-    virtual ~GlobalCallbacks() {}
-    /// Called before server is created.
-    virtual void UpdateArguments(ChannelArguments* /*args*/) {}
-    /// Called before application callback for each synchronous server request
-    virtual void PreSynchronousRequest(ServerContext* context) = 0;
-    /// Called after application callback for each synchronous server request
-    virtual void PostSynchronousRequest(ServerContext* context) = 0;
-    /// Called before server is started.
-    virtual void PreServerStart(Server* /*server*/) {}
-    /// Called after a server port is added.
-    virtual void AddPort(Server* /*server*/, const std::string& /*addr*/,
-                         ServerCredentials* /*creds*/, int /*port*/) {}
-  };
-  /// Set the global callback object. Can only be called once per application.
-  /// Does not take ownership of callbacks, and expects the pointed to object
-  /// to be alive until all server objects in the process have been destroyed.
-  /// The same \a GlobalCallbacks object will be used throughout the
-  /// application and is shared among all \a Server objects.
-  static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
-
-  /// Returns a \em raw pointer to the underlying \a grpc_server instance.
-  /// EXPERIMENTAL:  for internal/test use only
-  grpc_server* c_server();
-
-  /// Returns the health check service.
-  HealthCheckServiceInterface* GetHealthCheckService() const {
-    return health_check_service_.get();
-  }
-
-  /// Establish a channel for in-process communication
-  std::shared_ptr<Channel> InProcessChannel(const ChannelArguments& args);
-
-  /// NOTE: class experimental_type is not part of the public API of this class.
-  /// TODO(yashykt): Integrate into public API when this is no longer
-  /// experimental.
-  class experimental_type {
-   public:
-    explicit experimental_type(Server* server) : server_(server) {}
-
-    /// Establish a channel for in-process communication with client
-    /// interceptors
-    std::shared_ptr<Channel> InProcessChannelWithInterceptors(
-        const ChannelArguments& args,
-        std::vector<
-            std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-            interceptor_creators);
-
-   private:
-    Server* server_;
-  };
-
-  /// NOTE: The function experimental() is not stable public API. It is a view
-  /// to the experimental components of this class. It may be changed or removed
-  /// at any time.
-  experimental_type experimental() { return experimental_type(this); }
-
- protected:
-  /// Register a service. This call does not take ownership of the service.
-  /// The service must exist for the lifetime of the Server instance.
-  bool RegisterService(const std::string* addr, Service* service) override;
-
-  /// Try binding the server to the given \a addr endpoint
-  /// (port, and optionally including IP address to bind to).
-  ///
-  /// It can be invoked multiple times. Should be used before
-  /// starting the server.
-  ///
-  /// \param addr The address to try to bind to the server (eg, localhost:1234,
-  /// 192.168.1.1:31416, [::1]:27182, etc.).
-  /// \param creds The credentials associated with the server.
-  ///
-  /// \return bound port number on success, 0 on failure.
-  ///
-  /// \warning It is an error to call this method on an already started server.
-  int AddListeningPort(const std::string& addr,
-                       ServerCredentials* creds) override;
-
-  /// NOTE: This is *NOT* a public API. The server constructors are supposed to
-  /// be used by \a ServerBuilder class only. The constructor will be made
-  /// 'private' very soon.
-  ///
-  /// Server constructors. To be used by \a ServerBuilder only.
-  ///
-  /// \param args The channel args
-  ///
-  /// \param sync_server_cqs The completion queues to use if the server is a
-  /// synchronous server (or a hybrid server). The server polls for new RPCs on
-  /// these queues
-  ///
-  /// \param min_pollers The minimum number of polling threads per server
-  /// completion queue (in param sync_server_cqs) to use for listening to
-  /// incoming requests (used only in case of sync server)
-  ///
-  /// \param max_pollers The maximum number of polling threads per server
-  /// completion queue (in param sync_server_cqs) to use for listening to
-  /// incoming requests (used only in case of sync server)
-  ///
-  /// \param sync_cq_timeout_msec The timeout to use when calling AsyncNext() on
-  /// server completion queues passed via sync_server_cqs param.
-  Server(ChannelArguments* args,
-         std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
-             sync_server_cqs,
-         int min_pollers, int max_pollers, int sync_cq_timeout_msec,
-         std::vector<std::shared_ptr<internal::ExternalConnectionAcceptorImpl>>
-             acceptors,
-         grpc_server_config_fetcher* server_config_fetcher = nullptr,
-         grpc_resource_quota* server_rq = nullptr,
-         std::vector<
-             std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>
-             interceptor_creators = std::vector<std::unique_ptr<
-                 experimental::ServerInterceptorFactoryInterface>>());
-
-  /// Start the server.
-  ///
-  /// \param cqs Completion queues for handling asynchronous services. The
-  /// caller is required to keep all completion queues live until the server is
-  /// destroyed.
-  /// \param num_cqs How many completion queues does \a cqs hold.
-  void Start(ServerCompletionQueue** cqs, size_t num_cqs) override;
-
-  grpc_server* server() override { return server_; }
-
- protected:
-  /// NOTE: This method is not part of the public API for this class.
-  void set_health_check_service(
-      std::unique_ptr<HealthCheckServiceInterface> service) {
-    health_check_service_ = std::move(service);
-  }
-
-  ContextAllocator* context_allocator() { return context_allocator_.get(); }
-
-  /// NOTE: This method is not part of the public API for this class.
-  bool health_check_service_disabled() const {
-    return health_check_service_disabled_;
-  }
-
- private:
-  std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>*
-  interceptor_creators() override {
-    return &interceptor_creators_;
-  }
-
-  friend class AsyncGenericService;
-  friend class ServerBuilder;
-  friend class ServerInitializer;
-
-  class SyncRequest;
-  class CallbackRequestBase;
-  template <class ServerContextType>
-  class CallbackRequest;
-  class UnimplementedAsyncRequest;
-  class UnimplementedAsyncResponse;
-
-  /// SyncRequestThreadManager is an implementation of ThreadManager. This class
-  /// is responsible for polling for incoming RPCs and calling the RPC handlers.
-  /// This is only used in case of a Sync server (i.e a server exposing a sync
-  /// interface)
-  class SyncRequestThreadManager;
-
-  /// Register a generic service. This call does not take ownership of the
-  /// service. The service must exist for the lifetime of the Server instance.
-  void RegisterAsyncGenericService(AsyncGenericService* service) override;
-
-  /// Register a callback-based generic service. This call does not take
-  /// ownership of theservice. The service must exist for the lifetime of the
-  /// Server instance.
-  void RegisterCallbackGenericService(CallbackGenericService* service) override;
-
-  void RegisterContextAllocator(
-      std::unique_ptr<ContextAllocator> context_allocator) {
-    context_allocator_ = std::move(context_allocator);
-  }
-
-  void PerformOpsOnCall(internal::CallOpSetInterface* ops,
-                        internal::Call* call) override;
-
-  void ShutdownInternal(gpr_timespec deadline)
-      ABSL_LOCKS_EXCLUDED(mu_) override;
-
-  int max_receive_message_size() const override {
-    return max_receive_message_size_;
-  }
-
-  CompletionQueue* CallbackCQ() ABSL_LOCKS_EXCLUDED(mu_) override;
-
-  ServerInitializer* initializer();
-
-  // Functions to manage the server shutdown ref count. Things that increase
-  // the ref count are the running state of the server (take a ref at start and
-  // drop it at shutdown) and each running callback RPC.
-  void Ref();
-  void UnrefWithPossibleNotify() ABSL_LOCKS_EXCLUDED(mu_);
-  void UnrefAndWaitLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-
-  std::vector<std::shared_ptr<internal::ExternalConnectionAcceptorImpl>>
-      acceptors_;
-
-  // A vector of interceptor factory objects.
-  // This should be destroyed after health_check_service_ and this requirement
-  // is satisfied by declaring interceptor_creators_ before
-  // health_check_service_. (C++ mandates that member objects be destroyed in
-  // the reverse order of initialization.)
-  std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>
-      interceptor_creators_;
-
-  int max_receive_message_size_;
-
-  /// The following completion queues are ONLY used in case of Sync API
-  /// i.e. if the server has any services with sync methods. The server uses
-  /// these completion queues to poll for new RPCs
-  std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
-      sync_server_cqs_;
-
-  /// List of \a ThreadManager instances (one for each cq in
-  /// the \a sync_server_cqs)
-  std::vector<std::unique_ptr<SyncRequestThreadManager>> sync_req_mgrs_;
-
-  // Server status
-  internal::Mutex mu_;
-  bool started_;
-  bool shutdown_ ABSL_GUARDED_BY(mu_);
-  bool shutdown_notified_
-      ABSL_GUARDED_BY(mu_);  // Was notify called on the shutdown_cv_
-  internal::CondVar shutdown_done_cv_;
-  bool shutdown_done_ ABSL_GUARDED_BY(mu_) = false;
-  std::atomic_int shutdown_refs_outstanding_{1};
-
-  internal::CondVar shutdown_cv_;
-
-  std::shared_ptr<GlobalCallbacks> global_callbacks_;
-
-  std::vector<std::string> services_;
-  bool has_async_generic_service_ = false;
-  bool has_callback_generic_service_ = false;
-  bool has_callback_methods_ = false;
-
-  // Pointer to the wrapped grpc_server.
-  grpc_server* server_;
-
-  std::unique_ptr<ServerInitializer> server_initializer_;
-
-  std::unique_ptr<ContextAllocator> context_allocator_;
-
-  std::unique_ptr<HealthCheckServiceInterface> health_check_service_;
-  bool health_check_service_disabled_;
-
-  // When appropriate, use a default callback generic service to handle
-  // unimplemented methods
-  std::unique_ptr<CallbackGenericService> unimplemented_service_;
-
-  // A special handler for resource exhausted in sync case
-  std::unique_ptr<internal::MethodHandler> resource_exhausted_handler_;
-
-  // Handler for callback generic service, if any
-  std::unique_ptr<internal::MethodHandler> generic_handler_;
-
-  // callback_cq_ references the callbackable completion queue associated
-  // with this server (if any). It is set on the first call to CallbackCQ().
-  // It is _not owned_ by the server; ownership belongs with its internal
-  // shutdown callback tag (invoked when the CQ is fully shutdown).
-  std::atomic<CompletionQueue*> callback_cq_{nullptr};
-
-  // List of CQs passed in by user that must be Shutdown only after Server is
-  // Shutdown.  Even though this is only used with NDEBUG, instantiate it in all
-  // cases since otherwise the size will be inconsistent.
-  std::vector<CompletionQueue*> cq_list_;
-};
+namespace grpc
+{
+    class AsyncGenericService;
+    class ServerContext;
+    class ServerInitializer;
+
+    namespace internal
+    {
+        class ExternalConnectionAcceptorImpl;
+    }  // namespace internal
+
+    /// Represents a gRPC server.
+    ///
+    /// Use a \a grpc::ServerBuilder to create, configure, and start
+    /// \a Server instances.
+    class Server : public ServerInterface, private GrpcLibraryCodegen
+    {
+    public:
+        ~Server() ABSL_LOCKS_EXCLUDED(mu_) override;
+
+        /// Block until the server shuts down.
+        ///
+        /// \warning The server must be either shutting down or some other thread must
+        /// call \a Shutdown for this function to ever return.
+        void Wait() ABSL_LOCKS_EXCLUDED(mu_) override;
+
+        /// Global callbacks are a set of hooks that are called when server
+        /// events occur.  \a SetGlobalCallbacks method is used to register
+        /// the hooks with gRPC.  Note that
+        /// the \a GlobalCallbacks instance will be shared among all
+        /// \a Server instances in an application and can be set exactly
+        /// once per application.
+        class GlobalCallbacks
+        {
+        public:
+            virtual ~GlobalCallbacks()
+            {
+            }
+            /// Called before server is created.
+            virtual void UpdateArguments(ChannelArguments* /*args*/)
+            {
+            }
+            /// Called before application callback for each synchronous server request
+            virtual void PreSynchronousRequest(ServerContext* context) = 0;
+            /// Called after application callback for each synchronous server request
+            virtual void PostSynchronousRequest(ServerContext* context) = 0;
+            /// Called before server is started.
+            virtual void PreServerStart(Server* /*server*/)
+            {
+            }
+            /// Called after a server port is added.
+            virtual void AddPort(Server* /*server*/, const std::string& /*addr*/, ServerCredentials* /*creds*/, int /*port*/)
+            {
+            }
+        };
+        /// Set the global callback object. Can only be called once per application.
+        /// Does not take ownership of callbacks, and expects the pointed to object
+        /// to be alive until all server objects in the process have been destroyed.
+        /// The same \a GlobalCallbacks object will be used throughout the
+        /// application and is shared among all \a Server objects.
+        static void SetGlobalCallbacks(GlobalCallbacks* callbacks);
+
+        /// Returns a \em raw pointer to the underlying \a grpc_server instance.
+        /// EXPERIMENTAL:  for internal/test use only
+        grpc_server* c_server();
+
+        /// Returns the health check service.
+        HealthCheckServiceInterface* GetHealthCheckService() const
+        {
+            return health_check_service_.get();
+        }
+
+        /// Establish a channel for in-process communication
+        std::shared_ptr<Channel> InProcessChannel(const ChannelArguments& args);
+
+        /// NOTE: class experimental_type is not part of the public API of this class.
+        /// TODO(yashykt): Integrate into public API when this is no longer
+        /// experimental.
+        class experimental_type
+        {
+        public:
+            explicit experimental_type(Server* server) :
+                server_(server)
+            {
+            }
+
+            /// Establish a channel for in-process communication with client
+            /// interceptors
+            std::shared_ptr<Channel> InProcessChannelWithInterceptors(
+                const ChannelArguments& args,
+                std::vector<
+                    std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
+                    interceptor_creators
+            );
+
+        private:
+            Server* server_;
+        };
+
+        /// NOTE: The function experimental() is not stable public API. It is a view
+        /// to the experimental components of this class. It may be changed or removed
+        /// at any time.
+        experimental_type experimental()
+        {
+            return experimental_type(this);
+        }
+
+    protected:
+        /// Register a service. This call does not take ownership of the service.
+        /// The service must exist for the lifetime of the Server instance.
+        bool RegisterService(const std::string* addr, Service* service) override;
+
+        /// Try binding the server to the given \a addr endpoint
+        /// (port, and optionally including IP address to bind to).
+        ///
+        /// It can be invoked multiple times. Should be used before
+        /// starting the server.
+        ///
+        /// \param addr The address to try to bind to the server (eg, localhost:1234,
+        /// 192.168.1.1:31416, [::1]:27182, etc.).
+        /// \param creds The credentials associated with the server.
+        ///
+        /// \return bound port number on success, 0 on failure.
+        ///
+        /// \warning It is an error to call this method on an already started server.
+        int AddListeningPort(const std::string& addr, ServerCredentials* creds) override;
+
+        /// NOTE: This is *NOT* a public API. The server constructors are supposed to
+        /// be used by \a ServerBuilder class only. The constructor will be made
+        /// 'private' very soon.
+        ///
+        /// Server constructors. To be used by \a ServerBuilder only.
+        ///
+        /// \param args The channel args
+        ///
+        /// \param sync_server_cqs The completion queues to use if the server is a
+        /// synchronous server (or a hybrid server). The server polls for new RPCs on
+        /// these queues
+        ///
+        /// \param min_pollers The minimum number of polling threads per server
+        /// completion queue (in param sync_server_cqs) to use for listening to
+        /// incoming requests (used only in case of sync server)
+        ///
+        /// \param max_pollers The maximum number of polling threads per server
+        /// completion queue (in param sync_server_cqs) to use for listening to
+        /// incoming requests (used only in case of sync server)
+        ///
+        /// \param sync_cq_timeout_msec The timeout to use when calling AsyncNext() on
+        /// server completion queues passed via sync_server_cqs param.
+        Server(ChannelArguments* args, std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>> sync_server_cqs, int min_pollers, int max_pollers, int sync_cq_timeout_msec, std::vector<std::shared_ptr<internal::ExternalConnectionAcceptorImpl>> acceptors, grpc_server_config_fetcher* server_config_fetcher = nullptr, grpc_resource_quota* server_rq = nullptr, std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>> interceptor_creators = std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>());
+
+        /// Start the server.
+        ///
+        /// \param cqs Completion queues for handling asynchronous services. The
+        /// caller is required to keep all completion queues live until the server is
+        /// destroyed.
+        /// \param num_cqs How many completion queues does \a cqs hold.
+        void Start(ServerCompletionQueue** cqs, size_t num_cqs) override;
+
+        grpc_server* server() override
+        {
+            return server_;
+        }
+
+    protected:
+        /// NOTE: This method is not part of the public API for this class.
+        void set_health_check_service(
+            std::unique_ptr<HealthCheckServiceInterface> service
+        )
+        {
+            health_check_service_ = std::move(service);
+        }
+
+        ContextAllocator* context_allocator()
+        {
+            return context_allocator_.get();
+        }
+
+        /// NOTE: This method is not part of the public API for this class.
+        bool health_check_service_disabled() const
+        {
+            return health_check_service_disabled_;
+        }
+
+    private:
+        std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>*
+            interceptor_creators() override
+        {
+            return &interceptor_creators_;
+        }
+
+        friend class AsyncGenericService;
+        friend class ServerBuilder;
+        friend class ServerInitializer;
+
+        class SyncRequest;
+        class CallbackRequestBase;
+        template<class ServerContextType>
+        class CallbackRequest;
+        class UnimplementedAsyncRequest;
+        class UnimplementedAsyncResponse;
+
+        /// SyncRequestThreadManager is an implementation of ThreadManager. This class
+        /// is responsible for polling for incoming RPCs and calling the RPC handlers.
+        /// This is only used in case of a Sync server (i.e a server exposing a sync
+        /// interface)
+        class SyncRequestThreadManager;
+
+        /// Register a generic service. This call does not take ownership of the
+        /// service. The service must exist for the lifetime of the Server instance.
+        void RegisterAsyncGenericService(AsyncGenericService* service) override;
+
+        /// Register a callback-based generic service. This call does not take
+        /// ownership of theservice. The service must exist for the lifetime of the
+        /// Server instance.
+        void RegisterCallbackGenericService(CallbackGenericService* service) override;
+
+        void RegisterContextAllocator(
+            std::unique_ptr<ContextAllocator> context_allocator
+        )
+        {
+            context_allocator_ = std::move(context_allocator);
+        }
+
+        void PerformOpsOnCall(internal::CallOpSetInterface* ops, internal::Call* call) override;
+
+        void ShutdownInternal(gpr_timespec deadline)
+            ABSL_LOCKS_EXCLUDED(mu_) override;
+
+        int max_receive_message_size() const override
+        {
+            return max_receive_message_size_;
+        }
+
+        CompletionQueue* CallbackCQ() ABSL_LOCKS_EXCLUDED(mu_) override;
+
+        ServerInitializer* initializer();
+
+        // Functions to manage the server shutdown ref count. Things that increase
+        // the ref count are the running state of the server (take a ref at start and
+        // drop it at shutdown) and each running callback RPC.
+        void Ref();
+        void UnrefWithPossibleNotify() ABSL_LOCKS_EXCLUDED(mu_);
+        void UnrefAndWaitLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+        std::vector<std::shared_ptr<internal::ExternalConnectionAcceptorImpl>>
+            acceptors_;
+
+        // A vector of interceptor factory objects.
+        // This should be destroyed after health_check_service_ and this requirement
+        // is satisfied by declaring interceptor_creators_ before
+        // health_check_service_. (C++ mandates that member objects be destroyed in
+        // the reverse order of initialization.)
+        std::vector<std::unique_ptr<experimental::ServerInterceptorFactoryInterface>>
+            interceptor_creators_;
+
+        int max_receive_message_size_;
+
+        /// The following completion queues are ONLY used in case of Sync API
+        /// i.e. if the server has any services with sync methods. The server uses
+        /// these completion queues to poll for new RPCs
+        std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
+            sync_server_cqs_;
+
+        /// List of \a ThreadManager instances (one for each cq in
+        /// the \a sync_server_cqs)
+        std::vector<std::unique_ptr<SyncRequestThreadManager>> sync_req_mgrs_;
+
+        // Server status
+        internal::Mutex mu_;
+        bool started_;
+        bool shutdown_ ABSL_GUARDED_BY(mu_);
+        bool shutdown_notified_
+            ABSL_GUARDED_BY(mu_);  // Was notify called on the shutdown_cv_
+        internal::CondVar shutdown_done_cv_;
+        bool shutdown_done_ ABSL_GUARDED_BY(mu_) = false;
+        std::atomic_int shutdown_refs_outstanding_{1};
+
+        internal::CondVar shutdown_cv_;
+
+        std::shared_ptr<GlobalCallbacks> global_callbacks_;
+
+        std::vector<std::string> services_;
+        bool has_async_generic_service_ = false;
+        bool has_callback_generic_service_ = false;
+        bool has_callback_methods_ = false;
+
+        // Pointer to the wrapped grpc_server.
+        grpc_server* server_;
+
+        std::unique_ptr<ServerInitializer> server_initializer_;
+
+        std::unique_ptr<ContextAllocator> context_allocator_;
+
+        std::unique_ptr<HealthCheckServiceInterface> health_check_service_;
+        bool health_check_service_disabled_;
+
+        // When appropriate, use a default callback generic service to handle
+        // unimplemented methods
+        std::unique_ptr<CallbackGenericService> unimplemented_service_;
+
+        // A special handler for resource exhausted in sync case
+        std::unique_ptr<internal::MethodHandler> resource_exhausted_handler_;
+
+        // Handler for callback generic service, if any
+        std::unique_ptr<internal::MethodHandler> generic_handler_;
+
+        // callback_cq_ references the callbackable completion queue associated
+        // with this server (if any). It is set on the first call to CallbackCQ().
+        // It is _not owned_ by the server; ownership belongs with its internal
+        // shutdown callback tag (invoked when the CQ is fully shutdown).
+        std::atomic<CompletionQueue*> callback_cq_{nullptr};
+
+        // List of CQs passed in by user that must be Shutdown only after Server is
+        // Shutdown.  Even though this is only used with NDEBUG, instantiate it in all
+        // cases since otherwise the size will be inconsistent.
+        std::vector<CompletionQueue*> cq_list_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/server_builder.h b/CAPI/cpp/grpc/include/grpcpp/server_builder.h
index 2f72a87..0f6dc6f 100644
--- a/CAPI/cpp/grpc/include/grpcpp/server_builder.h
+++ b/CAPI/cpp/grpc/include/grpcpp/server_builder.h
@@ -39,380 +39,436 @@
 
 struct grpc_resource_quota;
 
-namespace grpc {
-
-class CompletionQueue;
-class Server;
-class ServerCompletionQueue;
-class AsyncGenericService;
-class ResourceQuota;
-class ServerCredentials;
-class Service;
-namespace testing {
-class ServerBuilderPluginTest;
-}  // namespace testing
-
-namespace internal {
-class ExternalConnectionAcceptorImpl;
-}  // namespace internal
-
-class CallbackGenericService;
-
-namespace experimental {
-class OrcaServerInterceptorFactory;
-// EXPERIMENTAL API:
-// Interface for a grpc server to build transports with connections created out
-// of band.
-// See ServerBuilder's AddExternalConnectionAcceptor API.
-class ExternalConnectionAcceptor {
- public:
-  struct NewConnectionParameters {
-    int listener_fd = -1;
-    int fd = -1;
-    ByteBuffer read_buffer;  // data intended for the grpc server
-  };
-  virtual ~ExternalConnectionAcceptor() {}
-  // If called before grpc::Server is started or after it is shut down, the new
-  // connection will be closed.
-  virtual void HandleNewConnection(NewConnectionParameters* p) = 0;
-};
-
-}  // namespace experimental
+namespace grpc
+{
+
+    class CompletionQueue;
+    class Server;
+    class ServerCompletionQueue;
+    class AsyncGenericService;
+    class ResourceQuota;
+    class ServerCredentials;
+    class Service;
+    namespace testing
+    {
+        class ServerBuilderPluginTest;
+    }  // namespace testing
+
+    namespace internal
+    {
+        class ExternalConnectionAcceptorImpl;
+    }  // namespace internal
+
+    class CallbackGenericService;
+
+    namespace experimental
+    {
+        class OrcaServerInterceptorFactory;
+        // EXPERIMENTAL API:
+        // Interface for a grpc server to build transports with connections created out
+        // of band.
+        // See ServerBuilder's AddExternalConnectionAcceptor API.
+        class ExternalConnectionAcceptor
+        {
+        public:
+            struct NewConnectionParameters
+            {
+                int listener_fd = -1;
+                int fd = -1;
+                ByteBuffer read_buffer;  // data intended for the grpc server
+            };
+            virtual ~ExternalConnectionAcceptor()
+            {
+            }
+            // If called before grpc::Server is started or after it is shut down, the new
+            // connection will be closed.
+            virtual void HandleNewConnection(NewConnectionParameters* p) = 0;
+        };
+
+    }  // namespace experimental
 }  // namespace grpc
 
-namespace grpc {
-
-/// A builder class for the creation and startup of \a grpc::Server instances.
-class ServerBuilder {
- public:
-  ServerBuilder();
-  virtual ~ServerBuilder();
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Primary API's
-
-  /// Return a running server which is ready for processing calls.
-  /// Before calling, one typically needs to ensure that:
-  ///  1. a service is registered - so that the server knows what to serve
-  ///     (via RegisterService, or RegisterAsyncGenericService)
-  ///  2. a listening port has been added - so the server knows where to receive
-  ///     traffic (via AddListeningPort)
-  ///  3. [for async api only] completion queues have been added via
-  ///     AddCompletionQueue
-  ///
-  ///  Will return a nullptr on errors.
-  virtual std::unique_ptr<grpc::Server> BuildAndStart();
-
-  /// Register a service. This call does not take ownership of the service.
-  /// The service must exist for the lifetime of the \a Server instance returned
-  /// by \a BuildAndStart().
-  /// Matches requests with any :authority
-  ServerBuilder& RegisterService(grpc::Service* service);
-
-  /// Enlists an endpoint \a addr (port with an optional IP address) to
-  /// bind the \a grpc::Server object to be created to.
-  ///
-  /// It can be invoked multiple times.
-  ///
-  /// \param addr_uri The address to try to bind to the server in URI form. If
-  /// the scheme name is omitted, "dns:///" is assumed. To bind to any address,
-  /// please use IPv6 any, i.e., [::]:<port>, which also accepts IPv4
-  /// connections.  Valid values include dns:///localhost:1234,
-  /// 192.168.1.1:31416, dns:///[::1]:27182, etc.
-  /// \param creds The credentials associated with the server.
-  /// \param[out] selected_port If not `nullptr`, gets populated with the port
-  /// number bound to the \a grpc::Server for the corresponding endpoint after
-  /// it is successfully bound by BuildAndStart(), 0 otherwise. AddListeningPort
-  /// does not modify this pointer.
-  ServerBuilder& AddListeningPort(
-      const std::string& addr_uri,
-      std::shared_ptr<grpc::ServerCredentials> creds,
-      int* selected_port = nullptr);
-
-  /// Add a completion queue for handling asynchronous services.
-  ///
-  /// Best performance is typically obtained by using one thread per polling
-  /// completion queue.
-  ///
-  /// Caller is required to shutdown the server prior to shutting down the
-  /// returned completion queue. Caller is also required to drain the
-  /// completion queue after shutting it down. A typical usage scenario:
-  ///
-  /// // While building the server:
-  /// ServerBuilder builder;
-  /// ...
-  /// cq_ = builder.AddCompletionQueue();
-  /// server_ = builder.BuildAndStart();
-  ///
-  /// // While shutting down the server;
-  /// server_->Shutdown();
-  /// cq_->Shutdown();  // Always *after* the associated server's Shutdown()!
-  /// // Drain the cq_ that was created
-  /// void* ignored_tag;
-  /// bool ignored_ok;
-  /// while (cq_->Next(&ignored_tag, &ignored_ok)) { }
-  ///
-  /// \param is_frequently_polled This is an optional parameter to inform gRPC
-  /// library about whether this completion queue would be frequently polled
-  /// (i.e. by calling \a Next() or \a AsyncNext()). The default value is
-  /// 'true' and is the recommended setting. Setting this to 'false' (i.e.
-  /// not polling the completion queue frequently) will have a significantly
-  /// negative performance impact and hence should not be used in production
-  /// use cases.
-  std::unique_ptr<grpc::ServerCompletionQueue> AddCompletionQueue(
-      bool is_frequently_polled = true);
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Less commonly used RegisterService variants
-
-  /// Register a service. This call does not take ownership of the service.
-  /// The service must exist for the lifetime of the \a Server instance
-  /// returned by \a BuildAndStart(). Only matches requests with :authority \a
-  /// host
-  ServerBuilder& RegisterService(const std::string& host,
-                                 grpc::Service* service);
-
-  /// Register a generic service.
-  /// Matches requests with any :authority
-  /// This is mostly useful for writing generic gRPC Proxies where the exact
-  /// serialization format is unknown
-  ServerBuilder& RegisterAsyncGenericService(
-      grpc::AsyncGenericService* service);
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Fine control knobs
-
-  /// Set max receive message size in bytes.
-  /// The default is GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH.
-  ServerBuilder& SetMaxReceiveMessageSize(int max_receive_message_size) {
-    max_receive_message_size_ = max_receive_message_size;
-    return *this;
-  }
-
-  /// Set max send message size in bytes.
-  /// The default is GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH.
-  ServerBuilder& SetMaxSendMessageSize(int max_send_message_size) {
-    max_send_message_size_ = max_send_message_size;
-    return *this;
-  }
-
-  /// \deprecated For backward compatibility.
-  ServerBuilder& SetMaxMessageSize(int max_message_size) {
-    return SetMaxReceiveMessageSize(max_message_size);
-  }
-
-  /// Set the support status for compression algorithms. All algorithms are
-  /// enabled by default.
-  ///
-  /// Incoming calls compressed with an unsupported algorithm will fail with
-  /// \a GRPC_STATUS_UNIMPLEMENTED.
-  ServerBuilder& SetCompressionAlgorithmSupportStatus(
-      grpc_compression_algorithm algorithm, bool enabled);
-
-  /// The default compression level to use for all channel calls in the
-  /// absence of a call-specific level.
-  ServerBuilder& SetDefaultCompressionLevel(grpc_compression_level level);
-
-  /// The default compression algorithm to use for all channel calls in the
-  /// absence of a call-specific level. Note that it overrides any compression
-  /// level set by \a SetDefaultCompressionLevel.
-  ServerBuilder& SetDefaultCompressionAlgorithm(
-      grpc_compression_algorithm algorithm);
-
-  /// Set the attached buffer pool for this server
-  ServerBuilder& SetResourceQuota(const grpc::ResourceQuota& resource_quota);
-
-  ServerBuilder& SetOption(std::unique_ptr<grpc::ServerBuilderOption> option);
-
-  /// Options for synchronous servers.
-  enum SyncServerOption {
-    NUM_CQS,         ///< Number of completion queues.
-    MIN_POLLERS,     ///< Minimum number of polling threads.
-    MAX_POLLERS,     ///< Maximum number of polling threads.
-    CQ_TIMEOUT_MSEC  ///< Completion queue timeout in milliseconds.
-  };
-
-  /// Only useful if this is a Synchronous server.
-  ServerBuilder& SetSyncServerOption(SyncServerOption option, int value);
-
-  /// Add a channel argument (an escape hatch to tuning core library parameters
-  /// directly)
-  template <class T>
-  ServerBuilder& AddChannelArgument(const std::string& arg, const T& value) {
-    return SetOption(grpc::MakeChannelArgumentOption(arg, value));
-  }
-
-  /// For internal use only: Register a ServerBuilderPlugin factory function.
-  static void InternalAddPluginFactory(
-      std::unique_ptr<grpc::ServerBuilderPlugin> (*CreatePlugin)());
-
-  /// Enable a server workaround. Do not use unless you know what the workaround
-  /// does. For explanation and detailed descriptions of workarounds, see
-  /// doc/workarounds.md.
-  ServerBuilder& EnableWorkaround(grpc_workaround_list id);
-
-  /// NOTE: class experimental_type is not part of the public API of this class.
-  /// TODO(yashykt): Integrate into public API when this is no longer
-  /// experimental.
-  class experimental_type {
-   public:
-    explicit experimental_type(ServerBuilder* builder) : builder_(builder) {}
-
-    void SetInterceptorCreators(
-        std::vector<std::unique_ptr<
-            grpc::experimental::ServerInterceptorFactoryInterface>>
-            interceptor_creators) {
-      builder_->interceptor_creators_ = std::move(interceptor_creators);
-    }
-
-    enum class ExternalConnectionType {
-      FROM_FD = 0  // in the form of a file descriptor
-    };
-
-    /// Register an acceptor to handle the externally accepted connection in
-    /// grpc server. The returned acceptor can be used to pass the connection
-    /// to grpc server, where a channel will be created with the provided
-    /// server credentials.
-    std::unique_ptr<grpc::experimental::ExternalConnectionAcceptor>
-    AddExternalConnectionAcceptor(ExternalConnectionType type,
-                                  std::shared_ptr<ServerCredentials> creds);
-
-    /// Sets server authorization policy provider in
-    /// GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER channel argument.
-    void SetAuthorizationPolicyProvider(
+namespace grpc
+{
+
+    /// A builder class for the creation and startup of \a grpc::Server instances.
+    class ServerBuilder
+    {
+    public:
+        ServerBuilder();
+        virtual ~ServerBuilder();
+
+        //////////////////////////////////////////////////////////////////////////////
+        // Primary API's
+
+        /// Return a running server which is ready for processing calls.
+        /// Before calling, one typically needs to ensure that:
+        ///  1. a service is registered - so that the server knows what to serve
+        ///     (via RegisterService, or RegisterAsyncGenericService)
+        ///  2. a listening port has been added - so the server knows where to receive
+        ///     traffic (via AddListeningPort)
+        ///  3. [for async api only] completion queues have been added via
+        ///     AddCompletionQueue
+        ///
+        ///  Will return a nullptr on errors.
+        virtual std::unique_ptr<grpc::Server> BuildAndStart();
+
+        /// Register a service. This call does not take ownership of the service.
+        /// The service must exist for the lifetime of the \a Server instance returned
+        /// by \a BuildAndStart().
+        /// Matches requests with any :authority
+        ServerBuilder& RegisterService(grpc::Service* service);
+
+        /// Enlists an endpoint \a addr (port with an optional IP address) to
+        /// bind the \a grpc::Server object to be created to.
+        ///
+        /// It can be invoked multiple times.
+        ///
+        /// \param addr_uri The address to try to bind to the server in URI form. If
+        /// the scheme name is omitted, "dns:///" is assumed. To bind to any address,
+        /// please use IPv6 any, i.e., [::]:<port>, which also accepts IPv4
+        /// connections.  Valid values include dns:///localhost:1234,
+        /// 192.168.1.1:31416, dns:///[::1]:27182, etc.
+        /// \param creds The credentials associated with the server.
+        /// \param[out] selected_port If not `nullptr`, gets populated with the port
+        /// number bound to the \a grpc::Server for the corresponding endpoint after
+        /// it is successfully bound by BuildAndStart(), 0 otherwise. AddListeningPort
+        /// does not modify this pointer.
+        ServerBuilder& AddListeningPort(
+            const std::string& addr_uri,
+            std::shared_ptr<grpc::ServerCredentials> creds,
+            int* selected_port = nullptr
+        );
+
+        /// Add a completion queue for handling asynchronous services.
+        ///
+        /// Best performance is typically obtained by using one thread per polling
+        /// completion queue.
+        ///
+        /// Caller is required to shutdown the server prior to shutting down the
+        /// returned completion queue. Caller is also required to drain the
+        /// completion queue after shutting it down. A typical usage scenario:
+        ///
+        /// // While building the server:
+        /// ServerBuilder builder;
+        /// ...
+        /// cq_ = builder.AddCompletionQueue();
+        /// server_ = builder.BuildAndStart();
+        ///
+        /// // While shutting down the server;
+        /// server_->Shutdown();
+        /// cq_->Shutdown();  // Always *after* the associated server's Shutdown()!
+        /// // Drain the cq_ that was created
+        /// void* ignored_tag;
+        /// bool ignored_ok;
+        /// while (cq_->Next(&ignored_tag, &ignored_ok)) { }
+        ///
+        /// \param is_frequently_polled This is an optional parameter to inform gRPC
+        /// library about whether this completion queue would be frequently polled
+        /// (i.e. by calling \a Next() or \a AsyncNext()). The default value is
+        /// 'true' and is the recommended setting. Setting this to 'false' (i.e.
+        /// not polling the completion queue frequently) will have a significantly
+        /// negative performance impact and hence should not be used in production
+        /// use cases.
+        std::unique_ptr<grpc::ServerCompletionQueue> AddCompletionQueue(
+            bool is_frequently_polled = true
+        );
+
+        //////////////////////////////////////////////////////////////////////////////
+        // Less commonly used RegisterService variants
+
+        /// Register a service. This call does not take ownership of the service.
+        /// The service must exist for the lifetime of the \a Server instance
+        /// returned by \a BuildAndStart(). Only matches requests with :authority \a
+        /// host
+        ServerBuilder& RegisterService(const std::string& host, grpc::Service* service);
+
+        /// Register a generic service.
+        /// Matches requests with any :authority
+        /// This is mostly useful for writing generic gRPC Proxies where the exact
+        /// serialization format is unknown
+        ServerBuilder& RegisterAsyncGenericService(
+            grpc::AsyncGenericService* service
+        );
+
+        //////////////////////////////////////////////////////////////////////////////
+        // Fine control knobs
+
+        /// Set max receive message size in bytes.
+        /// The default is GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH.
+        ServerBuilder& SetMaxReceiveMessageSize(int max_receive_message_size)
+        {
+            max_receive_message_size_ = max_receive_message_size;
+            return *this;
+        }
+
+        /// Set max send message size in bytes.
+        /// The default is GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH.
+        ServerBuilder& SetMaxSendMessageSize(int max_send_message_size)
+        {
+            max_send_message_size_ = max_send_message_size;
+            return *this;
+        }
+
+        /// \deprecated For backward compatibility.
+        ServerBuilder& SetMaxMessageSize(int max_message_size)
+        {
+            return SetMaxReceiveMessageSize(max_message_size);
+        }
+
+        /// Set the support status for compression algorithms. All algorithms are
+        /// enabled by default.
+        ///
+        /// Incoming calls compressed with an unsupported algorithm will fail with
+        /// \a GRPC_STATUS_UNIMPLEMENTED.
+        ServerBuilder& SetCompressionAlgorithmSupportStatus(
+            grpc_compression_algorithm algorithm, bool enabled
+        );
+
+        /// The default compression level to use for all channel calls in the
+        /// absence of a call-specific level.
+        ServerBuilder& SetDefaultCompressionLevel(grpc_compression_level level);
+
+        /// The default compression algorithm to use for all channel calls in the
+        /// absence of a call-specific level. Note that it overrides any compression
+        /// level set by \a SetDefaultCompressionLevel.
+        ServerBuilder& SetDefaultCompressionAlgorithm(
+            grpc_compression_algorithm algorithm
+        );
+
+        /// Set the attached buffer pool for this server
+        ServerBuilder& SetResourceQuota(const grpc::ResourceQuota& resource_quota);
+
+        ServerBuilder& SetOption(std::unique_ptr<grpc::ServerBuilderOption> option);
+
+        /// Options for synchronous servers.
+        enum SyncServerOption
+        {
+            NUM_CQS,         ///< Number of completion queues.
+            MIN_POLLERS,     ///< Minimum number of polling threads.
+            MAX_POLLERS,     ///< Maximum number of polling threads.
+            CQ_TIMEOUT_MSEC  ///< Completion queue timeout in milliseconds.
+        };
+
+        /// Only useful if this is a Synchronous server.
+        ServerBuilder& SetSyncServerOption(SyncServerOption option, int value);
+
+        /// Add a channel argument (an escape hatch to tuning core library parameters
+        /// directly)
+        template<class T>
+        ServerBuilder& AddChannelArgument(const std::string& arg, const T& value)
+        {
+            return SetOption(grpc::MakeChannelArgumentOption(arg, value));
+        }
+
+        /// For internal use only: Register a ServerBuilderPlugin factory function.
+        static void InternalAddPluginFactory(
+            std::unique_ptr<grpc::ServerBuilderPlugin> (*CreatePlugin)()
+        );
+
+        /// Enable a server workaround. Do not use unless you know what the workaround
+        /// does. For explanation and detailed descriptions of workarounds, see
+        /// doc/workarounds.md.
+        ServerBuilder& EnableWorkaround(grpc_workaround_list id);
+
+        /// NOTE: class experimental_type is not part of the public API of this class.
+        /// TODO(yashykt): Integrate into public API when this is no longer
+        /// experimental.
+        class experimental_type
+        {
+        public:
+            explicit experimental_type(ServerBuilder* builder) :
+                builder_(builder)
+            {
+            }
+
+            void SetInterceptorCreators(
+                std::vector<std::unique_ptr<
+                    grpc::experimental::ServerInterceptorFactoryInterface>>
+                    interceptor_creators
+            )
+            {
+                builder_->interceptor_creators_ = std::move(interceptor_creators);
+            }
+
+            enum class ExternalConnectionType
+            {
+                FROM_FD = 0  // in the form of a file descriptor
+            };
+
+            /// Register an acceptor to handle the externally accepted connection in
+            /// grpc server. The returned acceptor can be used to pass the connection
+            /// to grpc server, where a channel will be created with the provided
+            /// server credentials.
+            std::unique_ptr<grpc::experimental::ExternalConnectionAcceptor>
+                AddExternalConnectionAcceptor(ExternalConnectionType type, std::shared_ptr<ServerCredentials> creds);
+
+            /// Sets server authorization policy provider in
+            /// GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER channel argument.
+            void SetAuthorizationPolicyProvider(
+                std::shared_ptr<experimental::AuthorizationPolicyProviderInterface>
+                    provider
+            );
+
+        private:
+            ServerBuilder* builder_;
+        };
+
+        /// Set the allocator for creating and releasing callback server context.
+        /// Takes the owndership of the allocator.
+        ServerBuilder& SetContextAllocator(
+            std::unique_ptr<grpc::ContextAllocator> context_allocator
+        );
+
+        /// Register a generic service that uses the callback API.
+        /// Matches requests with any :authority
+        /// This is mostly useful for writing generic gRPC Proxies where the exact
+        /// serialization format is unknown
+        ServerBuilder& RegisterCallbackGenericService(
+            grpc::CallbackGenericService* service
+        );
+
+        /// NOTE: The function experimental() is not stable public API. It is a view
+        /// to the experimental components of this class. It may be changed or removed
+        /// at any time.
+        experimental_type experimental()
+        {
+            return experimental_type(this);
+        }
+
+    protected:
+        /// Experimental, to be deprecated
+        struct Port
+        {
+            std::string addr;
+            std::shared_ptr<ServerCredentials> creds;
+            int* selected_port;
+        };
+
+        /// Experimental, to be deprecated
+        typedef std::unique_ptr<std::string> HostString;
+        struct NamedService
+        {
+            explicit NamedService(grpc::Service* s) :
+                service(s)
+            {
+            }
+            NamedService(const std::string& h, grpc::Service* s) :
+                host(new std::string(h)),
+                service(s)
+            {
+            }
+            HostString host;
+            grpc::Service* service;
+        };
+
+        /// Experimental, to be deprecated
+        std::vector<Port> ports()
+        {
+            return ports_;
+        }
+
+        /// Experimental, to be deprecated
+        std::vector<NamedService*> services()
+        {
+            std::vector<NamedService*> service_refs;
+            for (auto& ptr : services_)
+            {
+                service_refs.push_back(ptr.get());
+            }
+            return service_refs;
+        }
+
+        /// Experimental, to be deprecated
+        std::vector<grpc::ServerBuilderOption*> options()
+        {
+            std::vector<grpc::ServerBuilderOption*> option_refs;
+            for (auto& ptr : options_)
+            {
+                option_refs.push_back(ptr.get());
+            }
+            return option_refs;
+        }
+
+        /// Experimental API, subject to change.
+        void set_fetcher(grpc_server_config_fetcher* server_config_fetcher)
+        {
+            server_config_fetcher_ = server_config_fetcher;
+        }
+
+        /// Experimental API, subject to change.
+        virtual ChannelArguments BuildChannelArgs();
+
+    private:
+        friend class grpc::testing::ServerBuilderPluginTest;
+        friend class grpc::experimental::OrcaServerInterceptorFactory;
+
+        struct SyncServerSettings
+        {
+            SyncServerSettings() :
+                num_cqs(1),
+                min_pollers(1),
+                max_pollers(2),
+                cq_timeout_msec(10000)
+            {
+            }
+
+            /// Number of server completion queues to create to listen to incoming RPCs.
+            int num_cqs;
+
+            /// Minimum number of threads per completion queue that should be listening
+            /// to incoming RPCs.
+            int min_pollers;
+
+            /// Maximum number of threads per completion queue that can be listening to
+            /// incoming RPCs.
+            int max_pollers;
+
+            /// The timeout for server completion queue's AsyncNext call.
+            int cq_timeout_msec;
+        };
+
+        int max_receive_message_size_;
+        int max_send_message_size_;
+        std::vector<std::unique_ptr<grpc::ServerBuilderOption>> options_;
+        std::vector<std::unique_ptr<NamedService>> services_;
+        std::vector<Port> ports_;
+
+        SyncServerSettings sync_server_settings_;
+
+        /// List of completion queues added via \a AddCompletionQueue method.
+        std::vector<grpc::ServerCompletionQueue*> cqs_;
+
+        std::shared_ptr<grpc::ServerCredentials> creds_;
+        std::vector<std::unique_ptr<grpc::ServerBuilderPlugin>> plugins_;
+        grpc_resource_quota* resource_quota_;
+        grpc::AsyncGenericService* generic_service_{nullptr};
+        std::unique_ptr<ContextAllocator> context_allocator_;
+        grpc::CallbackGenericService* callback_generic_service_{nullptr};
+
+        struct
+        {
+            bool is_set;
+            grpc_compression_level level;
+        } maybe_default_compression_level_;
+        struct
+        {
+            bool is_set;
+            grpc_compression_algorithm algorithm;
+        } maybe_default_compression_algorithm_;
+        uint32_t enabled_compression_algorithms_bitset_;
+        std::vector<
+            std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>>
+            interceptor_creators_;
+        std::vector<
+            std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>>
+            internal_interceptor_creators_;
+        std::vector<std::shared_ptr<grpc::internal::ExternalConnectionAcceptorImpl>>
+            acceptors_;
+        grpc_server_config_fetcher* server_config_fetcher_ = nullptr;
         std::shared_ptr<experimental::AuthorizationPolicyProviderInterface>
-            provider);
-
-   private:
-    ServerBuilder* builder_;
-  };
-
-  /// Set the allocator for creating and releasing callback server context.
-  /// Takes the owndership of the allocator.
-  ServerBuilder& SetContextAllocator(
-      std::unique_ptr<grpc::ContextAllocator> context_allocator);
-
-  /// Register a generic service that uses the callback API.
-  /// Matches requests with any :authority
-  /// This is mostly useful for writing generic gRPC Proxies where the exact
-  /// serialization format is unknown
-  ServerBuilder& RegisterCallbackGenericService(
-      grpc::CallbackGenericService* service);
-
-  /// NOTE: The function experimental() is not stable public API. It is a view
-  /// to the experimental components of this class. It may be changed or removed
-  /// at any time.
-  experimental_type experimental() { return experimental_type(this); }
-
- protected:
-  /// Experimental, to be deprecated
-  struct Port {
-    std::string addr;
-    std::shared_ptr<ServerCredentials> creds;
-    int* selected_port;
-  };
-
-  /// Experimental, to be deprecated
-  typedef std::unique_ptr<std::string> HostString;
-  struct NamedService {
-    explicit NamedService(grpc::Service* s) : service(s) {}
-    NamedService(const std::string& h, grpc::Service* s)
-        : host(new std::string(h)), service(s) {}
-    HostString host;
-    grpc::Service* service;
-  };
-
-  /// Experimental, to be deprecated
-  std::vector<Port> ports() { return ports_; }
-
-  /// Experimental, to be deprecated
-  std::vector<NamedService*> services() {
-    std::vector<NamedService*> service_refs;
-    for (auto& ptr : services_) {
-      service_refs.push_back(ptr.get());
-    }
-    return service_refs;
-  }
-
-  /// Experimental, to be deprecated
-  std::vector<grpc::ServerBuilderOption*> options() {
-    std::vector<grpc::ServerBuilderOption*> option_refs;
-    for (auto& ptr : options_) {
-      option_refs.push_back(ptr.get());
-    }
-    return option_refs;
-  }
-
-  /// Experimental API, subject to change.
-  void set_fetcher(grpc_server_config_fetcher* server_config_fetcher) {
-    server_config_fetcher_ = server_config_fetcher;
-  }
-
-  /// Experimental API, subject to change.
-  virtual ChannelArguments BuildChannelArgs();
-
- private:
-  friend class grpc::testing::ServerBuilderPluginTest;
-  friend class grpc::experimental::OrcaServerInterceptorFactory;
-
-  struct SyncServerSettings {
-    SyncServerSettings()
-        : num_cqs(1), min_pollers(1), max_pollers(2), cq_timeout_msec(10000) {}
-
-    /// Number of server completion queues to create to listen to incoming RPCs.
-    int num_cqs;
-
-    /// Minimum number of threads per completion queue that should be listening
-    /// to incoming RPCs.
-    int min_pollers;
-
-    /// Maximum number of threads per completion queue that can be listening to
-    /// incoming RPCs.
-    int max_pollers;
-
-    /// The timeout for server completion queue's AsyncNext call.
-    int cq_timeout_msec;
-  };
-
-  int max_receive_message_size_;
-  int max_send_message_size_;
-  std::vector<std::unique_ptr<grpc::ServerBuilderOption>> options_;
-  std::vector<std::unique_ptr<NamedService>> services_;
-  std::vector<Port> ports_;
-
-  SyncServerSettings sync_server_settings_;
-
-  /// List of completion queues added via \a AddCompletionQueue method.
-  std::vector<grpc::ServerCompletionQueue*> cqs_;
-
-  std::shared_ptr<grpc::ServerCredentials> creds_;
-  std::vector<std::unique_ptr<grpc::ServerBuilderPlugin>> plugins_;
-  grpc_resource_quota* resource_quota_;
-  grpc::AsyncGenericService* generic_service_{nullptr};
-  std::unique_ptr<ContextAllocator> context_allocator_;
-  grpc::CallbackGenericService* callback_generic_service_{nullptr};
-
-  struct {
-    bool is_set;
-    grpc_compression_level level;
-  } maybe_default_compression_level_;
-  struct {
-    bool is_set;
-    grpc_compression_algorithm algorithm;
-  } maybe_default_compression_algorithm_;
-  uint32_t enabled_compression_algorithms_bitset_;
-  std::vector<
-      std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>>
-      interceptor_creators_;
-  std::vector<
-      std::unique_ptr<grpc::experimental::ServerInterceptorFactoryInterface>>
-      internal_interceptor_creators_;
-  std::vector<std::shared_ptr<grpc::internal::ExternalConnectionAcceptorImpl>>
-      acceptors_;
-  grpc_server_config_fetcher* server_config_fetcher_ = nullptr;
-  std::shared_ptr<experimental::AuthorizationPolicyProviderInterface>
-      authorization_provider_;
-};
+            authorization_provider_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/server_posix.h b/CAPI/cpp/grpc/include/grpcpp/server_posix.h
index 2e93862..3e457bc 100644
--- a/CAPI/cpp/grpc/include/grpcpp/server_posix.h
+++ b/CAPI/cpp/grpc/include/grpcpp/server_posix.h
@@ -25,16 +25,17 @@
 
 #include <grpcpp/server.h>
 
-namespace grpc {
+namespace grpc
+{
 
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
 
-/// Add a new client to a \a Server communicating over the given
-/// file descriptor.
-///
-/// \param server The server to add the client to.
-/// \param fd The file descriptor representing a socket.
-void AddInsecureChannelFromFd(Server* server, int fd);
+    /// Add a new client to a \a Server communicating over the given
+    /// file descriptor.
+    ///
+    /// \param server The server to add the client to.
+    /// \param fd The file descriptor representing a socket.
+    void AddInsecureChannelFromFd(Server* server, int fd);
 
 #endif  // GPR_SUPPORT_CHANNELS_FROM_FD
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/channel_arguments.h b/CAPI/cpp/grpc/include/grpcpp/support/channel_arguments.h
index afee704..1885a8c 100644
--- a/CAPI/cpp/grpc/include/grpcpp/support/channel_arguments.h
+++ b/CAPI/cpp/grpc/include/grpcpp/support/channel_arguments.h
@@ -27,119 +27,132 @@
 #include <grpcpp/resource_quota.h>
 #include <grpcpp/support/config.h>
 
-namespace grpc {
-class SecureChannelCredentials;
-namespace testing {
-class ChannelArgumentsTest;
-}  // namespace testing
-
-/// Options for channel creation. The user can use generic setters to pass
-/// key value pairs down to C channel creation code. For gRPC related options,
-/// concrete setters are provided.
-class ChannelArguments {
- public:
-  ChannelArguments();
-  ~ChannelArguments();
-
-  ChannelArguments(const ChannelArguments& other);
-  ChannelArguments& operator=(ChannelArguments other) {
-    Swap(other);
-    return *this;
-  }
-
-  void Swap(ChannelArguments& other);
-
-  /// Dump arguments in this instance to \a channel_args. Does not take
-  /// ownership of \a channel_args.
-  ///
-  /// Note that the underlying arguments are shared. Changes made to either \a
-  /// channel_args or this instance would be reflected on both.
-  void SetChannelArgs(grpc_channel_args* channel_args) const;
-
-  // gRPC specific channel argument setters
-  /// Set target name override for SSL host name checking. This option should
-  /// be used with caution in production.
-  void SetSslTargetNameOverride(const std::string& name);
-  // TODO(yangg) add flow control options
-  /// Set the compression algorithm for the channel.
-  void SetCompressionAlgorithm(grpc_compression_algorithm algorithm);
-
-  /// Set the grpclb fallback timeout (in ms) for the channel. If this amount
-  /// of time has passed but we have not gotten any non-empty \a serverlist from
-  /// the balancer, we will fall back to use the backend address(es) returned by
-  /// the resolver.
-  void SetGrpclbFallbackTimeout(int fallback_timeout);
-
-  /// Set a mutator for the underlying socket.
-  void SetSocketMutator(grpc_socket_mutator* mutator);
-
-  /// Set the string to prepend to the user agent.
-  void SetUserAgentPrefix(const std::string& user_agent_prefix);
-
-  /// Set the buffer pool to be attached to the constructed channel.
-  void SetResourceQuota(const grpc::ResourceQuota& resource_quota);
-
-  /// Set the max receive and send message sizes.
-  void SetMaxReceiveMessageSize(int size);
-  void SetMaxSendMessageSize(int size);
-
-  /// Set LB policy name.
-  /// Note that if the name resolver returns only balancer addresses, the
-  /// grpclb LB policy will be used, regardless of what is specified here.
-  void SetLoadBalancingPolicyName(const std::string& lb_policy_name);
-
-  /// Set service config in JSON form.
-  /// Primarily meant for use in unit tests.
-  void SetServiceConfigJSON(const std::string& service_config_json);
-
-  // Generic channel argument setter. Only for advanced use cases.
-  /// Set an integer argument \a value under \a key.
-  void SetInt(const std::string& key, int value);
-
-  // Generic channel argument setter. Only for advanced use cases.
-  /// Set a pointer argument \a value under \a key. Ownership is not
-  /// transferred.
-  void SetPointer(const std::string& key, void* value);
-
-  /// Set a pointer argument \a value under \a key, transferring ownership of
-  /// \a value to the \a ChannelArguments object. The \a vtable::Delete function
-  /// is responsible for \a value cleanup/destruction when called.
-  void SetPointerWithVtable(const std::string& key, void* value,
-                            const grpc_arg_pointer_vtable* vtable);
-
-  /// Set a textual argument \a value under \a key.
-  void SetString(const std::string& key, const std::string& value);
-
-  /// Return (by value) a C \a grpc_channel_args structure which points to
-  /// arguments owned by this \a ChannelArguments instance
-  grpc_channel_args c_channel_args() const {
-    grpc_channel_args out;
-    out.num_args = args_.size();
-    out.args = args_.empty() ? nullptr : const_cast<grpc_arg*>(&args_[0]);
-    return out;
-  }
-
- private:
-  friend class grpc::SecureChannelCredentials;
-  friend class grpc::testing::ChannelArgumentsTest;
-
-  /// Default pointer argument operations.
-  struct PointerVtableMembers {
-    static void* Copy(void* in) { return in; }
-    static void Destroy(void* /*in*/) {}
-    static int Compare(void* a, void* b) {
-      if (a < b) return -1;
-      if (a > b) return 1;
-      return 0;
-    }
-  };
-
-  // Returns empty string when it is not set.
-  std::string GetSslTargetNameOverride() const;
-
-  std::vector<grpc_arg> args_;
-  std::list<std::string> strings_;
-};
+namespace grpc
+{
+    class SecureChannelCredentials;
+    namespace testing
+    {
+        class ChannelArgumentsTest;
+    }  // namespace testing
+
+    /// Options for channel creation. The user can use generic setters to pass
+    /// key value pairs down to C channel creation code. For gRPC related options,
+    /// concrete setters are provided.
+    class ChannelArguments
+    {
+    public:
+        ChannelArguments();
+        ~ChannelArguments();
+
+        ChannelArguments(const ChannelArguments& other);
+        ChannelArguments& operator=(ChannelArguments other)
+        {
+            Swap(other);
+            return *this;
+        }
+
+        void Swap(ChannelArguments& other);
+
+        /// Dump arguments in this instance to \a channel_args. Does not take
+        /// ownership of \a channel_args.
+        ///
+        /// Note that the underlying arguments are shared. Changes made to either \a
+        /// channel_args or this instance would be reflected on both.
+        void SetChannelArgs(grpc_channel_args* channel_args) const;
+
+        // gRPC specific channel argument setters
+        /// Set target name override for SSL host name checking. This option should
+        /// be used with caution in production.
+        void SetSslTargetNameOverride(const std::string& name);
+        // TODO(yangg) add flow control options
+        /// Set the compression algorithm for the channel.
+        void SetCompressionAlgorithm(grpc_compression_algorithm algorithm);
+
+        /// Set the grpclb fallback timeout (in ms) for the channel. If this amount
+        /// of time has passed but we have not gotten any non-empty \a serverlist from
+        /// the balancer, we will fall back to use the backend address(es) returned by
+        /// the resolver.
+        void SetGrpclbFallbackTimeout(int fallback_timeout);
+
+        /// Set a mutator for the underlying socket.
+        void SetSocketMutator(grpc_socket_mutator* mutator);
+
+        /// Set the string to prepend to the user agent.
+        void SetUserAgentPrefix(const std::string& user_agent_prefix);
+
+        /// Set the buffer pool to be attached to the constructed channel.
+        void SetResourceQuota(const grpc::ResourceQuota& resource_quota);
+
+        /// Set the max receive and send message sizes.
+        void SetMaxReceiveMessageSize(int size);
+        void SetMaxSendMessageSize(int size);
+
+        /// Set LB policy name.
+        /// Note that if the name resolver returns only balancer addresses, the
+        /// grpclb LB policy will be used, regardless of what is specified here.
+        void SetLoadBalancingPolicyName(const std::string& lb_policy_name);
+
+        /// Set service config in JSON form.
+        /// Primarily meant for use in unit tests.
+        void SetServiceConfigJSON(const std::string& service_config_json);
+
+        // Generic channel argument setter. Only for advanced use cases.
+        /// Set an integer argument \a value under \a key.
+        void SetInt(const std::string& key, int value);
+
+        // Generic channel argument setter. Only for advanced use cases.
+        /// Set a pointer argument \a value under \a key. Ownership is not
+        /// transferred.
+        void SetPointer(const std::string& key, void* value);
+
+        /// Set a pointer argument \a value under \a key, transferring ownership of
+        /// \a value to the \a ChannelArguments object. The \a vtable::Delete function
+        /// is responsible for \a value cleanup/destruction when called.
+        void SetPointerWithVtable(const std::string& key, void* value, const grpc_arg_pointer_vtable* vtable);
+
+        /// Set a textual argument \a value under \a key.
+        void SetString(const std::string& key, const std::string& value);
+
+        /// Return (by value) a C \a grpc_channel_args structure which points to
+        /// arguments owned by this \a ChannelArguments instance
+        grpc_channel_args c_channel_args() const
+        {
+            grpc_channel_args out;
+            out.num_args = args_.size();
+            out.args = args_.empty() ? nullptr : const_cast<grpc_arg*>(&args_[0]);
+            return out;
+        }
+
+    private:
+        friend class grpc::SecureChannelCredentials;
+        friend class grpc::testing::ChannelArgumentsTest;
+
+        /// Default pointer argument operations.
+        struct PointerVtableMembers
+        {
+            static void* Copy(void* in)
+            {
+                return in;
+            }
+            static void Destroy(void* /*in*/)
+            {
+            }
+            static int Compare(void* a, void* b)
+            {
+                if (a < b)
+                    return -1;
+                if (a > b)
+                    return 1;
+                return 0;
+            }
+        };
+
+        // Returns empty string when it is not set.
+        std::string GetSslTargetNameOverride() const;
+
+        std::vector<grpc_arg> args_;
+        std::list<std::string> strings_;
+    };
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/error_details.h b/CAPI/cpp/grpc/include/grpcpp/support/error_details.h
index 72305e8..56e38dd 100644
--- a/CAPI/cpp/grpc/include/grpcpp/support/error_details.h
+++ b/CAPI/cpp/grpc/include/grpcpp/support/error_details.h
@@ -21,55 +21,63 @@
 
 #include <grpcpp/support/status.h>
 
-namespace grpc {
+namespace grpc
+{
 
-/// Map a \a grpc::Status to a \a google::rpc::Status.
-/// The given \a to object will be cleared.
-/// On success, returns status with OK.
-/// Returns status with \a INVALID_ARGUMENT, if failed to deserialize.
-/// Returns status with \a FAILED_PRECONDITION, if \a to is nullptr.
-///
-/// \note
-/// This function is a template to avoid a build dep on \a status.proto.
-/// However, this function still requires that \tparam T is of type
-/// \a google::rpc::Status, which is defined at
-/// https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto
-template <typename T>
-grpc::Status ExtractErrorDetails(const grpc::Status& from, T* to) {
-  if (to == nullptr) {
-    return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
-  }
-  if (!to->ParseFromString(from.error_details())) {
-    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, "");
-  }
-  return grpc::Status::OK;
-}
-inline grpc::Status ExtractErrorDetails(const grpc::Status&, std::nullptr_t) {
-  return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
-}
+    /// Map a \a grpc::Status to a \a google::rpc::Status.
+    /// The given \a to object will be cleared.
+    /// On success, returns status with OK.
+    /// Returns status with \a INVALID_ARGUMENT, if failed to deserialize.
+    /// Returns status with \a FAILED_PRECONDITION, if \a to is nullptr.
+    ///
+    /// \note
+    /// This function is a template to avoid a build dep on \a status.proto.
+    /// However, this function still requires that \tparam T is of type
+    /// \a google::rpc::Status, which is defined at
+    /// https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto
+    template<typename T>
+    grpc::Status ExtractErrorDetails(const grpc::Status& from, T* to)
+    {
+        if (to == nullptr)
+        {
+            return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
+        }
+        if (!to->ParseFromString(from.error_details()))
+        {
+            return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, "");
+        }
+        return grpc::Status::OK;
+    }
+    inline grpc::Status ExtractErrorDetails(const grpc::Status&, std::nullptr_t)
+    {
+        return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
+    }
 
-/// Map \a google::rpc::Status to a \a grpc::Status.
-/// Returns OK on success.
-/// Returns status with \a FAILED_PRECONDITION if \a to is nullptr.
-///
-/// \note
-/// This function is a template to avoid a build dep on \a status.proto.
-/// However, this function still requires that \tparam T is of type
-/// \a google::rpc::Status, which is defined at
-/// https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto
-template <typename T>
-grpc::Status SetErrorDetails(const T& from, grpc::Status* to) {
-  if (to == nullptr) {
-    return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
-  }
-  grpc::StatusCode code = grpc::StatusCode::UNKNOWN;
-  if (from.code() >= grpc::StatusCode::OK &&
-      from.code() <= grpc::StatusCode::UNAUTHENTICATED) {
-    code = static_cast<grpc::StatusCode>(from.code());
-  }
-  *to = grpc::Status(code, from.message(), from.SerializeAsString());
-  return grpc::Status::OK;
-}
+    /// Map \a google::rpc::Status to a \a grpc::Status.
+    /// Returns OK on success.
+    /// Returns status with \a FAILED_PRECONDITION if \a to is nullptr.
+    ///
+    /// \note
+    /// This function is a template to avoid a build dep on \a status.proto.
+    /// However, this function still requires that \tparam T is of type
+    /// \a google::rpc::Status, which is defined at
+    /// https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto
+    template<typename T>
+    grpc::Status SetErrorDetails(const T& from, grpc::Status* to)
+    {
+        if (to == nullptr)
+        {
+            return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "");
+        }
+        grpc::StatusCode code = grpc::StatusCode::UNKNOWN;
+        if (from.code() >= grpc::StatusCode::OK &&
+            from.code() <= grpc::StatusCode::UNAUTHENTICATED)
+        {
+            code = static_cast<grpc::StatusCode>(from.code());
+        }
+        *to = grpc::Status(code, from.message(), from.SerializeAsString());
+        return grpc::Status::OK;
+    }
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/support/validate_service_config.h b/CAPI/cpp/grpc/include/grpcpp/support/validate_service_config.h
index 4306cb8..6d59208 100644
--- a/CAPI/cpp/grpc/include/grpcpp/support/validate_service_config.h
+++ b/CAPI/cpp/grpc/include/grpcpp/support/validate_service_config.h
@@ -21,15 +21,17 @@
 
 #include <grpcpp/support/config.h>
 
-namespace grpc {
+namespace grpc
+{
 
-namespace experimental {
-/// Validates \a service_config_json. If valid, returns an empty string.
-/// Otherwise, returns the validation error.
-/// TODO(yashykt): Promote it to out of experimental once it is proved useful
-/// and gRFC is accepted.
-std::string ValidateServiceConfigJSON(const std::string& service_config_json);
-}  // namespace experimental
+    namespace experimental
+    {
+        /// Validates \a service_config_json. If valid, returns an empty string.
+        /// Otherwise, returns the validation error.
+        /// TODO(yashykt): Promote it to out of experimental once it is proved useful
+        /// and gRFC is accepted.
+        std::string ValidateServiceConfigJSON(const std::string& service_config_json);
+    }  // namespace experimental
 
 }  // namespace grpc
 
diff --git a/CAPI/cpp/grpc/include/grpcpp/xds_server_builder.h b/CAPI/cpp/grpc/include/grpcpp/xds_server_builder.h
index e2fde72..818c49d 100644
--- a/CAPI/cpp/grpc/include/grpcpp/xds_server_builder.h
+++ b/CAPI/cpp/grpc/include/grpcpp/xds_server_builder.h
@@ -23,101 +23,120 @@
 
 #include <grpcpp/server_builder.h>
 
-namespace grpc {
-
-class XdsServerServingStatusNotifierInterface {
- public:
-  struct ServingStatusUpdate {
-    grpc::Status status;
-  };
-
-  virtual ~XdsServerServingStatusNotifierInterface() = default;
-
-  // \a uri contains the listening target associated with the notification. Note
-  // that a single target provided to XdsServerBuilder can get resolved to
-  // multiple listening addresses.
-  // The callback is invoked each time there is an update to the serving status.
-  // The API does not provide any guarantees around duplicate updates.
-  // Status::OK signifies that the server is serving, while a non-OK status
-  // signifies that the server is not serving.
-  virtual void OnServingStatusUpdate(std::string uri,
-                                     ServingStatusUpdate update) = 0;
-};
-
-class XdsServerBuilder : public grpc::ServerBuilder {
- public:
-  // NOTE: class experimental_type is not part of the public API of this class
-  // TODO(yashykt): Integrate into public API when this is no longer
-  // experimental.
-  class experimental_type : public grpc::ServerBuilder::experimental_type {
-   public:
-    explicit experimental_type(XdsServerBuilder* builder)
-        : ServerBuilder::experimental_type(builder), builder_(builder) {}
-
-    // EXPERIMENTAL: Sets the drain grace period in ms for older connections
-    // when updates to a Listener is received.
-    void set_drain_grace_time(int drain_grace_time_ms) {
-      builder_->drain_grace_time_ms_ = drain_grace_time_ms;
-    }
-
-   private:
-    XdsServerBuilder* builder_;
-  };
-
-  // It is the responsibility of the application to make sure that \a notifier
-  // outlasts the life of the server. Notifications will start being made
-  // asynchronously once `BuildAndStart()` has been called. Note that it is
-  // possible for notifications to be made before `BuildAndStart()` returns.
-  void set_status_notifier(XdsServerServingStatusNotifierInterface* notifier) {
-    notifier_ = notifier;
-  }
-
-  /// NOTE: The function experimental() is not stable public API. It is a view
-  /// to the experimental components of this class. It may be changed or removed
-  /// at any time.
-  experimental_type experimental() { return experimental_type(this); }
-
- private:
-  // Called at the beginning of BuildAndStart().
-  ChannelArguments BuildChannelArgs() override {
-    ChannelArguments args = ServerBuilder::BuildChannelArgs();
-    if (drain_grace_time_ms_ >= 0) {
-      args.SetInt(GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS,
-                  drain_grace_time_ms_);
-    }
-    grpc_channel_args c_channel_args = args.c_channel_args();
-    grpc_server_config_fetcher* fetcher = grpc_server_config_fetcher_xds_create(
-        {OnServingStatusUpdate, notifier_}, &c_channel_args);
-    if (fetcher != nullptr) set_fetcher(fetcher);
-    return args;
-  }
-
-  static void OnServingStatusUpdate(void* user_data, const char* uri,
-                                    grpc_serving_status_update update) {
-    if (user_data == nullptr) return;
-    XdsServerServingStatusNotifierInterface* notifier =
-        static_cast<XdsServerServingStatusNotifierInterface*>(user_data);
-    notifier->OnServingStatusUpdate(
-        uri, {grpc::Status(static_cast<StatusCode>(update.code),
-                           update.error_message)});
-  }
-
-  XdsServerServingStatusNotifierInterface* notifier_ = nullptr;
-  int drain_grace_time_ms_ = -1;
-};
-
-namespace experimental {
-// TODO(yashykt): Delete this after the 1.42 release.
-GRPC_DEPRECATED(
-    "Use grpc::XdsServerServingStatusNotifierInterface instead. The "
-    "experimental version will be deleted after the 1.42 release.")
-typedef grpc::XdsServerServingStatusNotifierInterface
-    XdsServerServingStatusNotifierInterface;
-GRPC_DEPRECATED(
-    "Use grpc::XdsServerBuilder instead. The experimental version will be "
-    "deleted after the 1.42 release.")
-typedef grpc::XdsServerBuilder XdsServerBuilder;
-}  // namespace experimental
+namespace grpc
+{
+
+    class XdsServerServingStatusNotifierInterface
+    {
+    public:
+        struct ServingStatusUpdate
+        {
+            grpc::Status status;
+        };
+
+        virtual ~XdsServerServingStatusNotifierInterface() = default;
+
+        // \a uri contains the listening target associated with the notification. Note
+        // that a single target provided to XdsServerBuilder can get resolved to
+        // multiple listening addresses.
+        // The callback is invoked each time there is an update to the serving status.
+        // The API does not provide any guarantees around duplicate updates.
+        // Status::OK signifies that the server is serving, while a non-OK status
+        // signifies that the server is not serving.
+        virtual void OnServingStatusUpdate(std::string uri, ServingStatusUpdate update) = 0;
+    };
+
+    class XdsServerBuilder : public grpc::ServerBuilder
+    {
+    public:
+        // NOTE: class experimental_type is not part of the public API of this class
+        // TODO(yashykt): Integrate into public API when this is no longer
+        // experimental.
+        class experimental_type : public grpc::ServerBuilder::experimental_type
+        {
+        public:
+            explicit experimental_type(XdsServerBuilder* builder) :
+                ServerBuilder::experimental_type(builder),
+                builder_(builder)
+            {
+            }
+
+            // EXPERIMENTAL: Sets the drain grace period in ms for older connections
+            // when updates to a Listener is received.
+            void set_drain_grace_time(int drain_grace_time_ms)
+            {
+                builder_->drain_grace_time_ms_ = drain_grace_time_ms;
+            }
+
+        private:
+            XdsServerBuilder* builder_;
+        };
+
+        // It is the responsibility of the application to make sure that \a notifier
+        // outlasts the life of the server. Notifications will start being made
+        // asynchronously once `BuildAndStart()` has been called. Note that it is
+        // possible for notifications to be made before `BuildAndStart()` returns.
+        void set_status_notifier(XdsServerServingStatusNotifierInterface* notifier)
+        {
+            notifier_ = notifier;
+        }
+
+        /// NOTE: The function experimental() is not stable public API. It is a view
+        /// to the experimental components of this class. It may be changed or removed
+        /// at any time.
+        experimental_type experimental()
+        {
+            return experimental_type(this);
+        }
+
+    private:
+        // Called at the beginning of BuildAndStart().
+        ChannelArguments BuildChannelArgs() override
+        {
+            ChannelArguments args = ServerBuilder::BuildChannelArgs();
+            if (drain_grace_time_ms_ >= 0)
+            {
+                args.SetInt(GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS, drain_grace_time_ms_);
+            }
+            grpc_channel_args c_channel_args = args.c_channel_args();
+            grpc_server_config_fetcher* fetcher = grpc_server_config_fetcher_xds_create(
+                {OnServingStatusUpdate, notifier_}, &c_channel_args
+            );
+            if (fetcher != nullptr)
+                set_fetcher(fetcher);
+            return args;
+        }
+
+        static void OnServingStatusUpdate(void* user_data, const char* uri, grpc_serving_status_update update)
+        {
+            if (user_data == nullptr)
+                return;
+            XdsServerServingStatusNotifierInterface* notifier =
+                static_cast<XdsServerServingStatusNotifierInterface*>(user_data);
+            notifier->OnServingStatusUpdate(
+                uri, {grpc::Status(static_cast<StatusCode>(update.code), update.error_message)}
+            );
+        }
+
+        XdsServerServingStatusNotifierInterface* notifier_ = nullptr;
+        int drain_grace_time_ms_ = -1;
+    };
+
+    namespace experimental
+    {
+        // TODO(yashykt): Delete this after the 1.42 release.
+        GRPC_DEPRECATED(
+            "Use grpc::XdsServerServingStatusNotifierInterface instead. The "
+            "experimental version will be deleted after the 1.42 release."
+        )
+        typedef grpc::XdsServerServingStatusNotifierInterface
+            XdsServerServingStatusNotifierInterface;
+        GRPC_DEPRECATED(
+            "Use grpc::XdsServerBuilder instead. The experimental version will be "
+            "deleted after the 1.42 release."
+        )
+        typedef grpc::XdsServerBuilder XdsServerBuilder;
+    }  // namespace experimental
 }  // namespace grpc
 
 #endif /* GRPCPP_XDS_SERVER_BUILDER_H */
diff --git a/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_EPILOGUE.H b/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_EPILOGUE.H
index d251d0a..ef0e9a2 100644
--- a/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_EPILOGUE.H
+++ b/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_EPILOGUE.H
@@ -18,5 +18,5 @@
  */
 #ifndef __cplusplus
 /* restore state.  Must correspond to the save in __decc_include_prologue.h */
-# pragma names restore
+#pragma names restore
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_PROLOGUE.H b/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_PROLOGUE.H
index 91ac6b3..0f7ebdb 100644
--- a/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_PROLOGUE.H
+++ b/CAPI/cpp/grpc/include/openssl/__DECC_INCLUDE_PROLOGUE.H
@@ -18,9 +18,9 @@
  */
 #ifndef __cplusplus
 /* save state */
-# pragma names save
+#pragma names save
 /* have the compiler shorten symbols larger than 31 chars to 23 chars
  * followed by a 8 hex char CRC
  */
-# pragma names as_is,shortened
+#pragma names as_is, shortened
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/aes.h b/CAPI/cpp/grpc/include/openssl/aes.h
index d0f9dfc..5c87a98 100644
--- a/CAPI/cpp/grpc/include/openssl/aes.h
+++ b/CAPI/cpp/grpc/include/openssl/aes.h
@@ -8,104 +8,81 @@
  */
 
 #ifndef OPENSSL_AES_H
-# define OPENSSL_AES_H
-# pragma once
+#define OPENSSL_AES_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_AES_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# include <stddef.h>
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_AES_H
+#endif
 
-# define AES_BLOCK_SIZE 16
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  define AES_ENCRYPT     1
-#  define AES_DECRYPT     0
+#define AES_BLOCK_SIZE 16
 
-#  define AES_MAXNR 14
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 
+#define AES_ENCRYPT 1
+#define AES_DECRYPT 0
 
-/* This should be a hidden type, but EVP requires that the size be known */
-struct aes_key_st {
-#  ifdef AES_LONG
-    unsigned long rd_key[4 * (AES_MAXNR + 1)];
-#  else
-    unsigned int rd_key[4 * (AES_MAXNR + 1)];
-#  endif
-    int rounds;
-};
-typedef struct aes_key_st AES_KEY;
+#define AES_MAXNR 14
 
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 const char *AES_options(void);
-OSSL_DEPRECATEDIN_3_0
-int AES_set_encrypt_key(const unsigned char *userKey, const int bits,
-                        AES_KEY *key);
-OSSL_DEPRECATEDIN_3_0
-int AES_set_decrypt_key(const unsigned char *userKey, const int bits,
-                        AES_KEY *key);
-OSSL_DEPRECATEDIN_3_0
-void AES_encrypt(const unsigned char *in, unsigned char *out,
-                 const AES_KEY *key);
-OSSL_DEPRECATEDIN_3_0
-void AES_decrypt(const unsigned char *in, unsigned char *out,
-                 const AES_KEY *key);
-OSSL_DEPRECATEDIN_3_0
-void AES_ecb_encrypt(const unsigned char *in, unsigned char *out,
-                     const AES_KEY *key, const int enc);
-OSSL_DEPRECATEDIN_3_0
-void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
-                     size_t length, const AES_KEY *key,
-                     unsigned char *ivec, const int enc);
-OSSL_DEPRECATEDIN_3_0
-void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out,
-                        size_t length, const AES_KEY *key,
-                        unsigned char *ivec, int *num, const int enc);
-OSSL_DEPRECATEDIN_3_0
-void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out,
-                      size_t length, const AES_KEY *key,
-                      unsigned char *ivec, int *num, const int enc);
-OSSL_DEPRECATEDIN_3_0
-void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out,
-                      size_t length, const AES_KEY *key,
-                      unsigned char *ivec, int *num, const int enc);
-OSSL_DEPRECATEDIN_3_0
-void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out,
-                        size_t length, const AES_KEY *key,
-                        unsigned char *ivec, int *num);
+    /* This should be a hidden type, but EVP requires that the size be known */
+    struct aes_key_st
+    {
+#ifdef AES_LONG
+        unsigned long rd_key[4 * (AES_MAXNR + 1)];
+#else
+        unsigned int rd_key[4 * (AES_MAXNR + 1)];
+#endif
+        int rounds;
+    };
+    typedef struct aes_key_st AES_KEY;
 
-/* NB: the IV is _two_ blocks long */
-OSSL_DEPRECATEDIN_3_0
-void AES_ige_encrypt(const unsigned char *in, unsigned char *out,
-                     size_t length, const AES_KEY *key,
-                     unsigned char *ivec, const int enc);
-/* NB: the IV is _four_ blocks long */
-OSSL_DEPRECATEDIN_3_0
-void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
-                        size_t length, const AES_KEY *key, const AES_KEY *key2,
-                        const unsigned char *ivec, const int enc);
-OSSL_DEPRECATEDIN_3_0
-int AES_wrap_key(AES_KEY *key, const unsigned char *iv,
-                 unsigned char *out, const unsigned char *in,
-                 unsigned int inlen);
-OSSL_DEPRECATEDIN_3_0
-int AES_unwrap_key(AES_KEY *key, const unsigned char *iv,
-                   unsigned char *out, const unsigned char *in,
-                   unsigned int inlen);
-# endif
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 const char* AES_options(void);
+    OSSL_DEPRECATEDIN_3_0
+    int AES_set_encrypt_key(const unsigned char* userKey, const int bits, AES_KEY* key);
+    OSSL_DEPRECATEDIN_3_0
+    int AES_set_decrypt_key(const unsigned char* userKey, const int bits, AES_KEY* key);
+    OSSL_DEPRECATEDIN_3_0
+    void AES_encrypt(const unsigned char* in, unsigned char* out, const AES_KEY* key);
+    OSSL_DEPRECATEDIN_3_0
+    void AES_decrypt(const unsigned char* in, unsigned char* out, const AES_KEY* key);
+    OSSL_DEPRECATEDIN_3_0
+    void AES_ecb_encrypt(const unsigned char* in, unsigned char* out, const AES_KEY* key, const int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void AES_cbc_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, unsigned char* ivec, const int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void AES_cfb128_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, unsigned char* ivec, int* num, const int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void AES_cfb1_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, unsigned char* ivec, int* num, const int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void AES_cfb8_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, unsigned char* ivec, int* num, const int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void AES_ofb128_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, unsigned char* ivec, int* num);
 
+    /* NB: the IV is _two_ blocks long */
+    OSSL_DEPRECATEDIN_3_0
+    void AES_ige_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, unsigned char* ivec, const int enc);
+    /* NB: the IV is _four_ blocks long */
+    OSSL_DEPRECATEDIN_3_0
+    void AES_bi_ige_encrypt(const unsigned char* in, unsigned char* out, size_t length, const AES_KEY* key, const AES_KEY* key2, const unsigned char* ivec, const int enc);
+    OSSL_DEPRECATEDIN_3_0
+    int AES_wrap_key(AES_KEY* key, const unsigned char* iv, unsigned char* out, const unsigned char* in, unsigned int inlen);
+    OSSL_DEPRECATEDIN_3_0
+    int AES_unwrap_key(AES_KEY* key, const unsigned char* iv, unsigned char* out, const unsigned char* in, unsigned int inlen);
+#endif
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/asn1.h b/CAPI/cpp/grpc/include/openssl/asn1.h
index aada23d..86b9d85 100644
--- a/CAPI/cpp/grpc/include/openssl/asn1.h
+++ b/CAPI/cpp/grpc/include/openssl/asn1.h
@@ -10,1119 +10,1046 @@
  * https://www.openssl.org/source/license.html
  */
 
+#ifndef OPENSSL_ASN1_H
+#define OPENSSL_ASN1_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ASN1_H
+#endif
 
+#include <time.h>
+#include <openssl/e_os2.h>
+#include <openssl/opensslconf.h>
+#include <openssl/bio.h>
+#include <openssl/safestack.h>
+#include <openssl/asn1err.h>
+#include <openssl/symhacks.h>
 
-#ifndef OPENSSL_ASN1_H
-# define OPENSSL_ASN1_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_ASN1_H
-# endif
-
-# include <time.h>
-# include <openssl/e_os2.h>
-# include <openssl/opensslconf.h>
-# include <openssl/bio.h>
-# include <openssl/safestack.h>
-# include <openssl/asn1err.h>
-# include <openssl/symhacks.h>
-
-# include <openssl/types.h>
-# include <openssl/bn.h>
-
-# ifdef OPENSSL_BUILD_SHLIBCRYPTO
-#  undef OPENSSL_EXTERN
-#  define OPENSSL_EXTERN OPENSSL_EXPORT
-# endif
-
-#ifdef  __cplusplus
-extern "C" {
+#include <openssl/types.h>
+#include <openssl/bn.h>
+
+#ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#undef OPENSSL_EXTERN
+#define OPENSSL_EXTERN OPENSSL_EXPORT
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-# define V_ASN1_UNIVERSAL                0x00
-# define V_ASN1_APPLICATION              0x40
-# define V_ASN1_CONTEXT_SPECIFIC         0x80
-# define V_ASN1_PRIVATE                  0xc0
+#define V_ASN1_UNIVERSAL 0x00
+#define V_ASN1_APPLICATION 0x40
+#define V_ASN1_CONTEXT_SPECIFIC 0x80
+#define V_ASN1_PRIVATE 0xc0
 
-# define V_ASN1_CONSTRUCTED              0x20
-# define V_ASN1_PRIMITIVE_TAG            0x1f
-# define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG
+#define V_ASN1_CONSTRUCTED 0x20
+#define V_ASN1_PRIMITIVE_TAG 0x1f
+#define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG
 
-# define V_ASN1_APP_CHOOSE               -2/* let the recipient choose */
-# define V_ASN1_OTHER                    -3/* used in ASN1_TYPE */
-# define V_ASN1_ANY                      -4/* used in ASN1 template code */
+#define V_ASN1_APP_CHOOSE -2 /* let the recipient choose */
+#define V_ASN1_OTHER -3      /* used in ASN1_TYPE */
+#define V_ASN1_ANY -4        /* used in ASN1 template code */
 
-# define V_ASN1_UNDEF                    -1
+#define V_ASN1_UNDEF -1
 /* ASN.1 tag values */
-# define V_ASN1_EOC                      0
-# define V_ASN1_BOOLEAN                  1 /**/
-# define V_ASN1_INTEGER                  2
-# define V_ASN1_BIT_STRING               3
-# define V_ASN1_OCTET_STRING             4
-# define V_ASN1_NULL                     5
-# define V_ASN1_OBJECT                   6
-# define V_ASN1_OBJECT_DESCRIPTOR        7
-# define V_ASN1_EXTERNAL                 8
-# define V_ASN1_REAL                     9
-# define V_ASN1_ENUMERATED               10
-# define V_ASN1_UTF8STRING               12
-# define V_ASN1_SEQUENCE                 16
-# define V_ASN1_SET                      17
-# define V_ASN1_NUMERICSTRING            18 /**/
-# define V_ASN1_PRINTABLESTRING          19
-# define V_ASN1_T61STRING                20
-# define V_ASN1_TELETEXSTRING            20/* alias */
-# define V_ASN1_VIDEOTEXSTRING           21 /**/
-# define V_ASN1_IA5STRING                22
-# define V_ASN1_UTCTIME                  23
-# define V_ASN1_GENERALIZEDTIME          24 /**/
-# define V_ASN1_GRAPHICSTRING            25 /**/
-# define V_ASN1_ISO64STRING              26 /**/
-# define V_ASN1_VISIBLESTRING            26/* alias */
-# define V_ASN1_GENERALSTRING            27 /**/
-# define V_ASN1_UNIVERSALSTRING          28 /**/
-# define V_ASN1_BMPSTRING                30
+#define V_ASN1_EOC 0
+#define V_ASN1_BOOLEAN 1 /**/
+#define V_ASN1_INTEGER 2
+#define V_ASN1_BIT_STRING 3
+#define V_ASN1_OCTET_STRING 4
+#define V_ASN1_NULL 5
+#define V_ASN1_OBJECT 6
+#define V_ASN1_OBJECT_DESCRIPTOR 7
+#define V_ASN1_EXTERNAL 8
+#define V_ASN1_REAL 9
+#define V_ASN1_ENUMERATED 10
+#define V_ASN1_UTF8STRING 12
+#define V_ASN1_SEQUENCE 16
+#define V_ASN1_SET 17
+#define V_ASN1_NUMERICSTRING 18 /**/
+#define V_ASN1_PRINTABLESTRING 19
+#define V_ASN1_T61STRING 20
+#define V_ASN1_TELETEXSTRING 20  /* alias */
+#define V_ASN1_VIDEOTEXSTRING 21 /**/
+#define V_ASN1_IA5STRING 22
+#define V_ASN1_UTCTIME 23
+#define V_ASN1_GENERALIZEDTIME 24 /**/
+#define V_ASN1_GRAPHICSTRING 25   /**/
+#define V_ASN1_ISO64STRING 26     /**/
+#define V_ASN1_VISIBLESTRING 26   /* alias */
+#define V_ASN1_GENERALSTRING 27   /**/
+#define V_ASN1_UNIVERSALSTRING 28 /**/
+#define V_ASN1_BMPSTRING 30
 
-/*
- * NB the constants below are used internally by ASN1_INTEGER
- * and ASN1_ENUMERATED to indicate the sign. They are *not* on
- * the wire tag values.
- */
+    /*
+     * NB the constants below are used internally by ASN1_INTEGER
+     * and ASN1_ENUMERATED to indicate the sign. They are *not* on
+     * the wire tag values.
+     */
 
-# define V_ASN1_NEG                      0x100
-# define V_ASN1_NEG_INTEGER              (2 | V_ASN1_NEG)
-# define V_ASN1_NEG_ENUMERATED           (10 | V_ASN1_NEG)
+#define V_ASN1_NEG 0x100
+#define V_ASN1_NEG_INTEGER (2 | V_ASN1_NEG)
+#define V_ASN1_NEG_ENUMERATED (10 | V_ASN1_NEG)
 
 /* For use with d2i_ASN1_type_bytes() */
-# define B_ASN1_NUMERICSTRING    0x0001
-# define B_ASN1_PRINTABLESTRING  0x0002
-# define B_ASN1_T61STRING        0x0004
-# define B_ASN1_TELETEXSTRING    0x0004
-# define B_ASN1_VIDEOTEXSTRING   0x0008
-# define B_ASN1_IA5STRING        0x0010
-# define B_ASN1_GRAPHICSTRING    0x0020
-# define B_ASN1_ISO64STRING      0x0040
-# define B_ASN1_VISIBLESTRING    0x0040
-# define B_ASN1_GENERALSTRING    0x0080
-# define B_ASN1_UNIVERSALSTRING  0x0100
-# define B_ASN1_OCTET_STRING     0x0200
-# define B_ASN1_BIT_STRING       0x0400
-# define B_ASN1_BMPSTRING        0x0800
-# define B_ASN1_UNKNOWN          0x1000
-# define B_ASN1_UTF8STRING       0x2000
-# define B_ASN1_UTCTIME          0x4000
-# define B_ASN1_GENERALIZEDTIME  0x8000
-# define B_ASN1_SEQUENCE         0x10000
+#define B_ASN1_NUMERICSTRING 0x0001
+#define B_ASN1_PRINTABLESTRING 0x0002
+#define B_ASN1_T61STRING 0x0004
+#define B_ASN1_TELETEXSTRING 0x0004
+#define B_ASN1_VIDEOTEXSTRING 0x0008
+#define B_ASN1_IA5STRING 0x0010
+#define B_ASN1_GRAPHICSTRING 0x0020
+#define B_ASN1_ISO64STRING 0x0040
+#define B_ASN1_VISIBLESTRING 0x0040
+#define B_ASN1_GENERALSTRING 0x0080
+#define B_ASN1_UNIVERSALSTRING 0x0100
+#define B_ASN1_OCTET_STRING 0x0200
+#define B_ASN1_BIT_STRING 0x0400
+#define B_ASN1_BMPSTRING 0x0800
+#define B_ASN1_UNKNOWN 0x1000
+#define B_ASN1_UTF8STRING 0x2000
+#define B_ASN1_UTCTIME 0x4000
+#define B_ASN1_GENERALIZEDTIME 0x8000
+#define B_ASN1_SEQUENCE 0x10000
 /* For use with ASN1_mbstring_copy() */
-# define MBSTRING_FLAG           0x1000
-# define MBSTRING_UTF8           (MBSTRING_FLAG)
-# define MBSTRING_ASC            (MBSTRING_FLAG|1)
-# define MBSTRING_BMP            (MBSTRING_FLAG|2)
-# define MBSTRING_UNIV           (MBSTRING_FLAG|4)
-# define SMIME_OLDMIME           0x400
-# define SMIME_CRLFEOL           0x800
-# define SMIME_STREAM            0x1000
-
-/* Stacks for types not otherwise defined in this header */
-SKM_DEFINE_STACK_OF_INTERNAL(X509_ALGOR, X509_ALGOR, X509_ALGOR)
+#define MBSTRING_FLAG 0x1000
+#define MBSTRING_UTF8 (MBSTRING_FLAG)
+#define MBSTRING_ASC (MBSTRING_FLAG | 1)
+#define MBSTRING_BMP (MBSTRING_FLAG | 2)
+#define MBSTRING_UNIV (MBSTRING_FLAG | 4)
+#define SMIME_OLDMIME 0x400
+#define SMIME_CRLFEOL 0x800
+#define SMIME_STREAM 0x1000
+
+    /* Stacks for types not otherwise defined in this header */
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_ALGOR, X509_ALGOR, X509_ALGOR)
 #define sk_X509_ALGOR_num(sk) OPENSSL_sk_num(ossl_check_const_X509_ALGOR_sk_type(sk))
-#define sk_X509_ALGOR_value(sk, idx) ((X509_ALGOR *)OPENSSL_sk_value(ossl_check_const_X509_ALGOR_sk_type(sk), (idx)))
-#define sk_X509_ALGOR_new(cmp) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new(ossl_check_X509_ALGOR_compfunc_type(cmp)))
-#define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_null())
-#define sk_X509_ALGOR_new_reserve(cmp, n) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_reserve(ossl_check_X509_ALGOR_compfunc_type(cmp), (n)))
+#define sk_X509_ALGOR_value(sk, idx) ((X509_ALGOR*)OPENSSL_sk_value(ossl_check_const_X509_ALGOR_sk_type(sk), (idx)))
+#define sk_X509_ALGOR_new(cmp) ((STACK_OF(X509_ALGOR)*)OPENSSL_sk_new(ossl_check_X509_ALGOR_compfunc_type(cmp)))
+#define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR)*)OPENSSL_sk_new_null())
+#define sk_X509_ALGOR_new_reserve(cmp, n) ((STACK_OF(X509_ALGOR)*)OPENSSL_sk_new_reserve(ossl_check_X509_ALGOR_compfunc_type(cmp), (n)))
 #define sk_X509_ALGOR_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_ALGOR_sk_type(sk), (n))
 #define sk_X509_ALGOR_free(sk) OPENSSL_sk_free(ossl_check_X509_ALGOR_sk_type(sk))
 #define sk_X509_ALGOR_zero(sk) OPENSSL_sk_zero(ossl_check_X509_ALGOR_sk_type(sk))
-#define sk_X509_ALGOR_delete(sk, i) ((X509_ALGOR *)OPENSSL_sk_delete(ossl_check_X509_ALGOR_sk_type(sk), (i)))
-#define sk_X509_ALGOR_delete_ptr(sk, ptr) ((X509_ALGOR *)OPENSSL_sk_delete_ptr(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr)))
+#define sk_X509_ALGOR_delete(sk, i) ((X509_ALGOR*)OPENSSL_sk_delete(ossl_check_X509_ALGOR_sk_type(sk), (i)))
+#define sk_X509_ALGOR_delete_ptr(sk, ptr) ((X509_ALGOR*)OPENSSL_sk_delete_ptr(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr)))
 #define sk_X509_ALGOR_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
 #define sk_X509_ALGOR_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
-#define sk_X509_ALGOR_pop(sk) ((X509_ALGOR *)OPENSSL_sk_pop(ossl_check_X509_ALGOR_sk_type(sk)))
-#define sk_X509_ALGOR_shift(sk) ((X509_ALGOR *)OPENSSL_sk_shift(ossl_check_X509_ALGOR_sk_type(sk)))
-#define sk_X509_ALGOR_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ALGOR_sk_type(sk),ossl_check_X509_ALGOR_freefunc_type(freefunc))
+#define sk_X509_ALGOR_pop(sk) ((X509_ALGOR*)OPENSSL_sk_pop(ossl_check_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_shift(sk) ((X509_ALGOR*)OPENSSL_sk_shift(ossl_check_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_freefunc_type(freefunc))
 #define sk_X509_ALGOR_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), (idx))
-#define sk_X509_ALGOR_set(sk, idx, ptr) ((X509_ALGOR *)OPENSSL_sk_set(ossl_check_X509_ALGOR_sk_type(sk), (idx), ossl_check_X509_ALGOR_type(ptr)))
+#define sk_X509_ALGOR_set(sk, idx, ptr) ((X509_ALGOR*)OPENSSL_sk_set(ossl_check_X509_ALGOR_sk_type(sk), (idx), ossl_check_X509_ALGOR_type(ptr)))
 #define sk_X509_ALGOR_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
 #define sk_X509_ALGOR_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))
 #define sk_X509_ALGOR_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), pnum)
 #define sk_X509_ALGOR_sort(sk) OPENSSL_sk_sort(ossl_check_X509_ALGOR_sk_type(sk))
 #define sk_X509_ALGOR_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_ALGOR_sk_type(sk))
-#define sk_X509_ALGOR_dup(sk) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_dup(ossl_check_const_X509_ALGOR_sk_type(sk)))
-#define sk_X509_ALGOR_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_copyfunc_type(copyfunc), ossl_check_X509_ALGOR_freefunc_type(freefunc)))
+#define sk_X509_ALGOR_dup(sk) ((STACK_OF(X509_ALGOR)*)OPENSSL_sk_dup(ossl_check_const_X509_ALGOR_sk_type(sk)))
+#define sk_X509_ALGOR_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ALGOR)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_copyfunc_type(copyfunc), ossl_check_X509_ALGOR_freefunc_type(freefunc)))
 #define sk_X509_ALGOR_set_cmp_func(sk, cmp) ((sk_X509_ALGOR_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_compfunc_type(cmp)))
 
-
-
-# define ASN1_STRING_FLAG_BITS_LEFT 0x08/* Set if 0x07 has bits left value */
+#define ASN1_STRING_FLAG_BITS_LEFT 0x08 /* Set if 0x07 has bits left value */
 /*
  * This indicates that the ASN1_STRING is not a real value but just a place
  * holder for the location where indefinite length constructed data should be
  * inserted in the memory buffer
  */
-# define ASN1_STRING_FLAG_NDEF 0x010
+#define ASN1_STRING_FLAG_NDEF 0x010
 
-/*
- * This flag is used by the CMS code to indicate that a string is not
- * complete and is a place holder for content when it had all been accessed.
- * The flag will be reset when content has been written to it.
- */
+    /*
+     * This flag is used by the CMS code to indicate that a string is not
+     * complete and is a place holder for content when it had all been accessed.
+     * The flag will be reset when content has been written to it.
+     */
 
-# define ASN1_STRING_FLAG_CONT 0x020
+#define ASN1_STRING_FLAG_CONT 0x020
 /*
  * This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING
  * type.
  */
-# define ASN1_STRING_FLAG_MSTRING 0x040
+#define ASN1_STRING_FLAG_MSTRING 0x040
 /* String is embedded and only content should be freed */
-# define ASN1_STRING_FLAG_EMBED 0x080
+#define ASN1_STRING_FLAG_EMBED 0x080
 /* String should be parsed in RFC 5280's time format */
-# define ASN1_STRING_FLAG_X509_TIME 0x100
-/* This is the base type that holds just about everything :-) */
-struct asn1_string_st {
-    int length;
-    int type;
-    unsigned char *data;
+#define ASN1_STRING_FLAG_X509_TIME 0x100
+    /* This is the base type that holds just about everything :-) */
+    struct asn1_string_st
+    {
+        int length;
+        int type;
+        unsigned char* data;
+        /*
+         * The value of the following field depends on the type being held.  It
+         * is mostly being used for BIT_STRING so if the input data has a
+         * non-zero 'unused bits' value, it will be handled correctly
+         */
+        long flags;
+    };
+
     /*
-     * The value of the following field depends on the type being held.  It
-     * is mostly being used for BIT_STRING so if the input data has a
-     * non-zero 'unused bits' value, it will be handled correctly
+     * ASN1_ENCODING structure: this is used to save the received encoding of an
+     * ASN1 type. This is useful to get round problems with invalid encodings
+     * which can break signatures.
      */
-    long flags;
-};
-
-/*
- * ASN1_ENCODING structure: this is used to save the received encoding of an
- * ASN1 type. This is useful to get round problems with invalid encodings
- * which can break signatures.
- */
 
-typedef struct ASN1_ENCODING_st {
-    unsigned char *enc;         /* DER encoding */
-    long len;                   /* Length of encoding */
-    int modified;               /* set to 1 if 'enc' is invalid */
-} ASN1_ENCODING;
+    typedef struct ASN1_ENCODING_st
+    {
+        unsigned char* enc; /* DER encoding */
+        long len;           /* Length of encoding */
+        int modified;       /* set to 1 if 'enc' is invalid */
+    } ASN1_ENCODING;
 
 /* Used with ASN1 LONG type: if a long is set to this it is omitted */
-# define ASN1_LONG_UNDEF 0x7fffffffL
+#define ASN1_LONG_UNDEF 0x7fffffffL
 
-# define STABLE_FLAGS_MALLOC     0x01
+#define STABLE_FLAGS_MALLOC 0x01
 /*
  * A zero passed to ASN1_STRING_TABLE_new_add for the flags is interpreted
  * as "don't change" and STABLE_FLAGS_MALLOC is always set. By setting
  * STABLE_FLAGS_MALLOC only we can clear the existing value. Use the alias
  * STABLE_FLAGS_CLEAR to reflect this.
  */
-# define STABLE_FLAGS_CLEAR      STABLE_FLAGS_MALLOC
-# define STABLE_NO_MASK          0x02
-# define DIRSTRING_TYPE  \
- (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING)
-# define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING)
-
-struct asn1_string_table_st {
-    int nid;
-    long minsize;
-    long maxsize;
-    unsigned long mask;
-    unsigned long flags;
-};
-
-SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING_TABLE, ASN1_STRING_TABLE, ASN1_STRING_TABLE)
+#define STABLE_FLAGS_CLEAR STABLE_FLAGS_MALLOC
+#define STABLE_NO_MASK 0x02
+#define DIRSTRING_TYPE \
+    (B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_BMPSTRING | B_ASN1_UTF8STRING)
+#define PKCS9STRING_TYPE (DIRSTRING_TYPE | B_ASN1_IA5STRING)
+
+    struct asn1_string_table_st
+    {
+        int nid;
+        long minsize;
+        long maxsize;
+        unsigned long mask;
+        unsigned long flags;
+    };
+
+    SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING_TABLE, ASN1_STRING_TABLE, ASN1_STRING_TABLE)
 #define sk_ASN1_STRING_TABLE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))
-#define sk_ASN1_STRING_TABLE_value(sk, idx) ((ASN1_STRING_TABLE *)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), (idx)))
-#define sk_ASN1_STRING_TABLE_new(cmp) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
-#define sk_ASN1_STRING_TABLE_new_null() ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_null())
-#define sk_ASN1_STRING_TABLE_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp), (n)))
+#define sk_ASN1_STRING_TABLE_value(sk, idx) ((ASN1_STRING_TABLE*)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), (idx)))
+#define sk_ASN1_STRING_TABLE_new(cmp) ((STACK_OF(ASN1_STRING_TABLE)*)OPENSSL_sk_new(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
+#define sk_ASN1_STRING_TABLE_new_null() ((STACK_OF(ASN1_STRING_TABLE)*)OPENSSL_sk_new_null())
+#define sk_ASN1_STRING_TABLE_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING_TABLE)*)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp), (n)))
 #define sk_ASN1_STRING_TABLE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (n))
 #define sk_ASN1_STRING_TABLE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
 #define sk_ASN1_STRING_TABLE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
-#define sk_ASN1_STRING_TABLE_delete(sk, i) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (i)))
-#define sk_ASN1_STRING_TABLE_delete_ptr(sk, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr)))
+#define sk_ASN1_STRING_TABLE_delete(sk, i) ((ASN1_STRING_TABLE*)OPENSSL_sk_delete(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (i)))
+#define sk_ASN1_STRING_TABLE_delete_ptr(sk, ptr) ((ASN1_STRING_TABLE*)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr)))
 #define sk_ASN1_STRING_TABLE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
 #define sk_ASN1_STRING_TABLE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
-#define sk_ASN1_STRING_TABLE_pop(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_pop(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
-#define sk_ASN1_STRING_TABLE_shift(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_shift(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
-#define sk_ASN1_STRING_TABLE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk),ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc))
+#define sk_ASN1_STRING_TABLE_pop(sk) ((ASN1_STRING_TABLE*)OPENSSL_sk_pop(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_shift(sk) ((ASN1_STRING_TABLE*)OPENSSL_sk_shift(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc))
 #define sk_ASN1_STRING_TABLE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), (idx))
-#define sk_ASN1_STRING_TABLE_set(sk, idx, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_set(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (idx), ossl_check_ASN1_STRING_TABLE_type(ptr)))
+#define sk_ASN1_STRING_TABLE_set(sk, idx, ptr) ((ASN1_STRING_TABLE*)OPENSSL_sk_set(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (idx), ossl_check_ASN1_STRING_TABLE_type(ptr)))
 #define sk_ASN1_STRING_TABLE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
 #define sk_ASN1_STRING_TABLE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))
 #define sk_ASN1_STRING_TABLE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), pnum)
 #define sk_ASN1_STRING_TABLE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_STRING_TABLE_sk_type(sk))
 #define sk_ASN1_STRING_TABLE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))
-#define sk_ASN1_STRING_TABLE_dup(sk) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk)))
-#define sk_ASN1_STRING_TABLE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc)))
+#define sk_ASN1_STRING_TABLE_dup(sk) ((STACK_OF(ASN1_STRING_TABLE)*)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk)))
+#define sk_ASN1_STRING_TABLE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING_TABLE)*)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc)))
 #define sk_ASN1_STRING_TABLE_set_cmp_func(sk, cmp) ((sk_ASN1_STRING_TABLE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))
 
+    /* size limits: this stuff is taken straight from RFC2459 */
 
-/* size limits: this stuff is taken straight from RFC2459 */
+#define ub_name 32768
+#define ub_common_name 64
+#define ub_locality_name 128
+#define ub_state_name 128
+#define ub_organization_name 64
+#define ub_organization_unit_name 64
+#define ub_title 64
+#define ub_email_address 128
 
-# define ub_name                         32768
-# define ub_common_name                  64
-# define ub_locality_name                128
-# define ub_state_name                   128
-# define ub_organization_name            64
-# define ub_organization_unit_name       64
-# define ub_title                        64
-# define ub_email_address                128
-
-/*
- * Declarations for template structures: for full definitions see asn1t.h
- */
-typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
-typedef struct ASN1_TLC_st ASN1_TLC;
-/* This is just an opaque pointer */
-typedef struct ASN1_VALUE_st ASN1_VALUE;
+    /*
+     * Declarations for template structures: for full definitions see asn1t.h
+     */
+    typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
+    typedef struct ASN1_TLC_st ASN1_TLC;
+    /* This is just an opaque pointer */
+    typedef struct ASN1_VALUE_st ASN1_VALUE;
 
-/* Declare ASN1 functions: the implement macro in in asn1t.h */
+    /* Declare ASN1 functions: the implement macro in in asn1t.h */
 
-/*
- * The mysterious 'extern' that's passed to some macros is innocuous,
- * and is there to quiet pre-C99 compilers that may complain about empty
- * arguments in macro calls.
- */
+    /*
+     * The mysterious 'extern' that's passed to some macros is innocuous,
+     * and is there to quiet pre-C99 compilers that may complain about empty
+     * arguments in macro calls.
+     */
 
-# define DECLARE_ASN1_FUNCTIONS_attr(attr, type)                            \
+#define DECLARE_ASN1_FUNCTIONS_attr(attr, type) \
     DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, type)
-# define DECLARE_ASN1_FUNCTIONS(type)                                       \
+#define DECLARE_ASN1_FUNCTIONS(type) \
     DECLARE_ASN1_FUNCTIONS_attr(extern, type)
 
-# define DECLARE_ASN1_ALLOC_FUNCTIONS_attr(attr, type)                      \
+#define DECLARE_ASN1_ALLOC_FUNCTIONS_attr(attr, type) \
     DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, type)
-# define DECLARE_ASN1_ALLOC_FUNCTIONS(type)                                 \
+#define DECLARE_ASN1_ALLOC_FUNCTIONS(type) \
     DECLARE_ASN1_ALLOC_FUNCTIONS_attr(extern, type)
 
-# define DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, name)                 \
-    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name)                \
-    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)
-# define DECLARE_ASN1_FUNCTIONS_name(type, name)                            \
+#define DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, name)   \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name) \
+        DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)
+#define DECLARE_ASN1_FUNCTIONS_name(type, name) \
     DECLARE_ASN1_FUNCTIONS_name_attr(extern, type, name)
 
-# define DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, itname, name)       \
-    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)               \
-    DECLARE_ASN1_ITEM_attr(attr, itname)
-# define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)                  \
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, itname, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)        \
+        DECLARE_ASN1_ITEM_attr(attr, itname)
+#define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \
     DECLARE_ASN1_ENCODE_FUNCTIONS_attr(extern, type, itname, name)
 
-# define DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)          \
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name) \
     DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, name, name)
-# define DECLARE_ASN1_ENCODE_FUNCTIONS_name(type, name) \
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_name(type, name) \
     DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(extern, type, name)
 
-# define DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)          \
-    attr type *d2i_##name(type **a, const unsigned char **in, long len);    \
-    attr int i2d_##name(const type *a, unsigned char **out);
-# define DECLARE_ASN1_ENCODE_FUNCTIONS_only(type, name)                     \
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)        \
+    attr type* d2i_##name(type** a, const unsigned char** in, long len); \
+    attr int i2d_##name(const type* a, unsigned char** out);
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_only(type, name) \
     DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(extern, type, name)
 
-# define DECLARE_ASN1_NDEF_FUNCTION_attr(attr, name)                        \
-    attr int i2d_##name##_NDEF(const name *a, unsigned char **out);
-# define DECLARE_ASN1_NDEF_FUNCTION(name)                                   \
+#define DECLARE_ASN1_NDEF_FUNCTION_attr(attr, name) \
+    attr int i2d_##name##_NDEF(const name* a, unsigned char** out);
+#define DECLARE_ASN1_NDEF_FUNCTION(name) \
     DECLARE_ASN1_NDEF_FUNCTION_attr(extern, name)
 
-# define DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name)           \
-    attr type *name##_new(void);                                            \
-    attr void name##_free(type *a);
-# define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name)                      \
+#define DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name) \
+    attr type* name##_new(void);                                 \
+    attr void name##_free(type* a);
+#define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \
     DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(extern, type, name)
 
-# define DECLARE_ASN1_DUP_FUNCTION_attr(attr, type)                         \
+#define DECLARE_ASN1_DUP_FUNCTION_attr(attr, type) \
     DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, type)
-# define DECLARE_ASN1_DUP_FUNCTION(type)                                    \
+#define DECLARE_ASN1_DUP_FUNCTION(type) \
     DECLARE_ASN1_DUP_FUNCTION_attr(extern, type)
 
-# define DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, name)              \
-    attr type *name##_dup(const type *a);
-# define DECLARE_ASN1_DUP_FUNCTION_name(type, name)                         \
+#define DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, name) \
+    attr type* name##_dup(const type* a);
+#define DECLARE_ASN1_DUP_FUNCTION_name(type, name) \
     DECLARE_ASN1_DUP_FUNCTION_name_attr(extern, type, name)
 
-# define DECLARE_ASN1_PRINT_FUNCTION_attr(attr, stname)                     \
+#define DECLARE_ASN1_PRINT_FUNCTION_attr(attr, stname) \
     DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, stname)
-# define DECLARE_ASN1_PRINT_FUNCTION(stname)                                \
+#define DECLARE_ASN1_PRINT_FUNCTION(stname) \
     DECLARE_ASN1_PRINT_FUNCTION_attr(extern, stname)
 
-# define DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, fname)        \
-    attr int fname##_print_ctx(BIO *out, const stname *x, int indent,       \
-                               const ASN1_PCTX *pctx);
-# define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname)                   \
+#define DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, fname) \
+    attr int fname##_print_ctx(BIO* out, const stname* x, int indent, const ASN1_PCTX* pctx);
+#define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \
     DECLARE_ASN1_PRINT_FUNCTION_fname_attr(extern, stname, fname)
 
-# define D2I_OF(type) type *(*)(type **,const unsigned char **,long)
-# define I2D_OF(type) int (*)(const type *,unsigned char **)
-
-# define CHECKED_D2I_OF(type, d2i) \
-    ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0)))
-# define CHECKED_I2D_OF(type, i2d) \
-    ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0)))
-# define CHECKED_NEW_OF(type, xnew) \
-    ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0)))
-# define CHECKED_PTR_OF(type, p) \
-    ((void*) (1 ? p : (type*)0))
-# define CHECKED_PPTR_OF(type, p) \
-    ((void**) (1 ? p : (type**)0))
-
-# define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long)
-# define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(const type *,unsigned char **)
-# define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type)
-
-typedef void *d2i_of_void(void **, const unsigned char **, long);
-typedef int i2d_of_void(const void *, unsigned char **);
-
-/*-
- * The following macros and typedefs allow an ASN1_ITEM
- * to be embedded in a structure and referenced. Since
- * the ASN1_ITEM pointers need to be globally accessible
- * (possibly from shared libraries) they may exist in
- * different forms. On platforms that support it the
- * ASN1_ITEM structure itself will be globally exported.
- * Other platforms will export a function that returns
- * an ASN1_ITEM pointer.
- *
- * To handle both cases transparently the macros below
- * should be used instead of hard coding an ASN1_ITEM
- * pointer in a structure.
- *
- * The structure will look like this:
- *
- * typedef struct SOMETHING_st {
- *      ...
- *      ASN1_ITEM_EXP *iptr;
- *      ...
- * } SOMETHING;
- *
- * It would be initialised as e.g.:
- *
- * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...};
- *
- * and the actual pointer extracted with:
- *
- * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr);
- *
- * Finally an ASN1_ITEM pointer can be extracted from an
- * appropriate reference with: ASN1_ITEM_rptr(X509). This
- * would be used when a function takes an ASN1_ITEM * argument.
- *
- */
-
+#define D2I_OF(type) type* (*)(type**, const unsigned char**, long)
+#define I2D_OF(type) int (*)(const type*, unsigned char**)
+
+#define CHECKED_D2I_OF(type, d2i) \
+    ((d2i_of_void*)(1 ? d2i : ((D2I_OF(type))0)))
+#define CHECKED_I2D_OF(type, i2d) \
+    ((i2d_of_void*)(1 ? i2d : ((I2D_OF(type))0)))
+#define CHECKED_NEW_OF(type, xnew) \
+    ((void* (*)(void))(1 ? xnew : ((type * (*)(void))0)))
+#define CHECKED_PTR_OF(type, p) \
+    ((void*)(1 ? p : (type*)0))
+#define CHECKED_PPTR_OF(type, p) \
+    ((void**)(1 ? p : (type**)0))
+
+#define TYPEDEF_D2I_OF(type) typedef type* d2i_of_##type(type**, const unsigned char**, long)
+#define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(const type*, unsigned char**)
+#define TYPEDEF_D2I2D_OF(type) \
+    TYPEDEF_D2I_OF(type);      \
+    TYPEDEF_I2D_OF(type)
+
+    typedef void* d2i_of_void(void**, const unsigned char**, long);
+    typedef int i2d_of_void(const void*, unsigned char**);
+
+    /*-
+     * The following macros and typedefs allow an ASN1_ITEM
+     * to be embedded in a structure and referenced. Since
+     * the ASN1_ITEM pointers need to be globally accessible
+     * (possibly from shared libraries) they may exist in
+     * different forms. On platforms that support it the
+     * ASN1_ITEM structure itself will be globally exported.
+     * Other platforms will export a function that returns
+     * an ASN1_ITEM pointer.
+     *
+     * To handle both cases transparently the macros below
+     * should be used instead of hard coding an ASN1_ITEM
+     * pointer in a structure.
+     *
+     * The structure will look like this:
+     *
+     * typedef struct SOMETHING_st {
+     *      ...
+     *      ASN1_ITEM_EXP *iptr;
+     *      ...
+     * } SOMETHING;
+     *
+     * It would be initialised as e.g.:
+     *
+     * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...};
+     *
+     * and the actual pointer extracted with:
+     *
+     * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr);
+     *
+     * Finally an ASN1_ITEM pointer can be extracted from an
+     * appropriate reference with: ASN1_ITEM_rptr(X509). This
+     * would be used when a function takes an ASN1_ITEM * argument.
+     *
+     */
 
-/*
- * Platforms that can't easily handle shared global variables are declared as
- * functions returning ASN1_ITEM pointers.
- */
+    /*
+     * Platforms that can't easily handle shared global variables are declared as
+     * functions returning ASN1_ITEM pointers.
+     */
 
-/* ASN1_ITEM pointer exported type */
-typedef const ASN1_ITEM *ASN1_ITEM_EXP (void);
+    /* ASN1_ITEM pointer exported type */
+    typedef const ASN1_ITEM* ASN1_ITEM_EXP(void);
 
 /* Macro to obtain ASN1_ITEM pointer from exported type */
-# define ASN1_ITEM_ptr(iptr) (iptr())
+#define ASN1_ITEM_ptr(iptr) (iptr())
 
 /* Macro to include ASN1_ITEM pointer from base type */
-# define ASN1_ITEM_ref(iptr) (iptr##_it)
+#define ASN1_ITEM_ref(iptr) (iptr##_it)
 
-# define ASN1_ITEM_rptr(ref) (ref##_it())
+#define ASN1_ITEM_rptr(ref) (ref##_it())
 
-# define DECLARE_ASN1_ITEM_attr(attr, name)                                 \
-    attr const ASN1_ITEM * name##_it(void);
-# define DECLARE_ASN1_ITEM(name)                                            \
+#define DECLARE_ASN1_ITEM_attr(attr, name) \
+    attr const ASN1_ITEM* name##_it(void);
+#define DECLARE_ASN1_ITEM(name) \
     DECLARE_ASN1_ITEM_attr(extern, name)
 
-/* Parameters used by ASN1_STRING_print_ex() */
+    /* Parameters used by ASN1_STRING_print_ex() */
 
-/*
- * These determine which characters to escape: RFC2253 special characters,
- * control characters and MSB set characters
- */
+    /*
+     * These determine which characters to escape: RFC2253 special characters,
+     * control characters and MSB set characters
+     */
 
-# define ASN1_STRFLGS_ESC_2253           1
-# define ASN1_STRFLGS_ESC_CTRL           2
-# define ASN1_STRFLGS_ESC_MSB            4
+#define ASN1_STRFLGS_ESC_2253 1
+#define ASN1_STRFLGS_ESC_CTRL 2
+#define ASN1_STRFLGS_ESC_MSB 4
 
 /* Lower 8 bits are reserved as an output type specifier */
-# define ASN1_DTFLGS_TYPE_MASK    0x0FUL
-# define ASN1_DTFLGS_RFC822       0x00UL
-# define ASN1_DTFLGS_ISO8601      0x01UL
+#define ASN1_DTFLGS_TYPE_MASK 0x0FUL
+#define ASN1_DTFLGS_RFC822 0x00UL
+#define ASN1_DTFLGS_ISO8601 0x01UL
 
-/*
- * This flag determines how we do escaping: normally RC2253 backslash only,
- * set this to use backslash and quote.
- */
+    /*
+     * This flag determines how we do escaping: normally RC2253 backslash only,
+     * set this to use backslash and quote.
+     */
 
-# define ASN1_STRFLGS_ESC_QUOTE          8
+#define ASN1_STRFLGS_ESC_QUOTE 8
 
 /* These three flags are internal use only. */
 
 /* Character is a valid PrintableString character */
-# define CHARTYPE_PRINTABLESTRING        0x10
+#define CHARTYPE_PRINTABLESTRING 0x10
 /* Character needs escaping if it is the first character */
-# define CHARTYPE_FIRST_ESC_2253         0x20
+#define CHARTYPE_FIRST_ESC_2253 0x20
 /* Character needs escaping if it is the last character */
-# define CHARTYPE_LAST_ESC_2253          0x40
+#define CHARTYPE_LAST_ESC_2253 0x40
 
-/*
- * NB the internal flags are safely reused below by flags handled at the top
- * level.
- */
+    /*
+     * NB the internal flags are safely reused below by flags handled at the top
+     * level.
+     */
 
-/*
- * If this is set we convert all character strings to UTF8 first
- */
+    /*
+     * If this is set we convert all character strings to UTF8 first
+     */
 
-# define ASN1_STRFLGS_UTF8_CONVERT       0x10
+#define ASN1_STRFLGS_UTF8_CONVERT 0x10
 
-/*
- * If this is set we don't attempt to interpret content: just assume all
- * strings are 1 byte per character. This will produce some pretty odd
- * looking output!
- */
+    /*
+     * If this is set we don't attempt to interpret content: just assume all
+     * strings are 1 byte per character. This will produce some pretty odd
+     * looking output!
+     */
 
-# define ASN1_STRFLGS_IGNORE_TYPE        0x20
+#define ASN1_STRFLGS_IGNORE_TYPE 0x20
 
 /* If this is set we include the string type in the output */
-# define ASN1_STRFLGS_SHOW_TYPE          0x40
+#define ASN1_STRFLGS_SHOW_TYPE 0x40
 
-/*
- * This determines which strings to display and which to 'dump' (hex dump of
- * content octets or DER encoding). We can only dump non character strings or
- * everything. If we don't dump 'unknown' they are interpreted as character
- * strings with 1 octet per character and are subject to the usual escaping
- * options.
- */
+    /*
+     * This determines which strings to display and which to 'dump' (hex dump of
+     * content octets or DER encoding). We can only dump non character strings or
+     * everything. If we don't dump 'unknown' they are interpreted as character
+     * strings with 1 octet per character and are subject to the usual escaping
+     * options.
+     */
 
-# define ASN1_STRFLGS_DUMP_ALL           0x80
-# define ASN1_STRFLGS_DUMP_UNKNOWN       0x100
+#define ASN1_STRFLGS_DUMP_ALL 0x80
+#define ASN1_STRFLGS_DUMP_UNKNOWN 0x100
 
-/*
- * These determine what 'dumping' does, we can dump the content octets or the
- * DER encoding: both use the RFC2253 #XXXXX notation.
- */
+    /*
+     * These determine what 'dumping' does, we can dump the content octets or the
+     * DER encoding: both use the RFC2253 #XXXXX notation.
+     */
 
-# define ASN1_STRFLGS_DUMP_DER           0x200
+#define ASN1_STRFLGS_DUMP_DER 0x200
 
 /*
  * This flag specifies that RC2254 escaping shall be performed.
  */
-#define ASN1_STRFLGS_ESC_2254           0x400
-
-/*
- * All the string flags consistent with RFC2253, escaping control characters
- * isn't essential in RFC2253 but it is advisable anyway.
- */
+#define ASN1_STRFLGS_ESC_2254 0x400
 
-# define ASN1_STRFLGS_RFC2253    (ASN1_STRFLGS_ESC_2253 | \
-                                ASN1_STRFLGS_ESC_CTRL | \
-                                ASN1_STRFLGS_ESC_MSB | \
-                                ASN1_STRFLGS_UTF8_CONVERT | \
-                                ASN1_STRFLGS_DUMP_UNKNOWN | \
-                                ASN1_STRFLGS_DUMP_DER)
-
-
-struct asn1_type_st {
-    int type;
-    union {
-        char *ptr;
-        ASN1_BOOLEAN boolean;
-        ASN1_STRING *asn1_string;
-        ASN1_OBJECT *object;
-        ASN1_INTEGER *integer;
-        ASN1_ENUMERATED *enumerated;
-        ASN1_BIT_STRING *bit_string;
-        ASN1_OCTET_STRING *octet_string;
-        ASN1_PRINTABLESTRING *printablestring;
-        ASN1_T61STRING *t61string;
-        ASN1_IA5STRING *ia5string;
-        ASN1_GENERALSTRING *generalstring;
-        ASN1_BMPSTRING *bmpstring;
-        ASN1_UNIVERSALSTRING *universalstring;
-        ASN1_UTCTIME *utctime;
-        ASN1_GENERALIZEDTIME *generalizedtime;
-        ASN1_VISIBLESTRING *visiblestring;
-        ASN1_UTF8STRING *utf8string;
-        /*
-         * set and sequence are left complete and still contain the set or
-         * sequence bytes
-         */
-        ASN1_STRING *set;
-        ASN1_STRING *sequence;
-        ASN1_VALUE *asn1_value;
-    } value;
-};
+    /*
+     * All the string flags consistent with RFC2253, escaping control characters
+     * isn't essential in RFC2253 but it is advisable anyway.
+     */
 
-SKM_DEFINE_STACK_OF_INTERNAL(ASN1_TYPE, ASN1_TYPE, ASN1_TYPE)
+#define ASN1_STRFLGS_RFC2253 (ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | ASN1_STRFLGS_UTF8_CONVERT | ASN1_STRFLGS_DUMP_UNKNOWN | ASN1_STRFLGS_DUMP_DER)
+
+    struct asn1_type_st
+    {
+        int type;
+        union
+        {
+            char* ptr;
+            ASN1_BOOLEAN boolean;
+            ASN1_STRING* asn1_string;
+            ASN1_OBJECT* object;
+            ASN1_INTEGER* integer;
+            ASN1_ENUMERATED* enumerated;
+            ASN1_BIT_STRING* bit_string;
+            ASN1_OCTET_STRING* octet_string;
+            ASN1_PRINTABLESTRING* printablestring;
+            ASN1_T61STRING* t61string;
+            ASN1_IA5STRING* ia5string;
+            ASN1_GENERALSTRING* generalstring;
+            ASN1_BMPSTRING* bmpstring;
+            ASN1_UNIVERSALSTRING* universalstring;
+            ASN1_UTCTIME* utctime;
+            ASN1_GENERALIZEDTIME* generalizedtime;
+            ASN1_VISIBLESTRING* visiblestring;
+            ASN1_UTF8STRING* utf8string;
+            /*
+             * set and sequence are left complete and still contain the set or
+             * sequence bytes
+             */
+            ASN1_STRING* set;
+            ASN1_STRING* sequence;
+            ASN1_VALUE* asn1_value;
+        } value;
+    };
+
+    SKM_DEFINE_STACK_OF_INTERNAL(ASN1_TYPE, ASN1_TYPE, ASN1_TYPE)
 #define sk_ASN1_TYPE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_TYPE_sk_type(sk))
-#define sk_ASN1_TYPE_value(sk, idx) ((ASN1_TYPE *)OPENSSL_sk_value(ossl_check_const_ASN1_TYPE_sk_type(sk), (idx)))
-#define sk_ASN1_TYPE_new(cmp) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new(ossl_check_ASN1_TYPE_compfunc_type(cmp)))
-#define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_null())
-#define sk_ASN1_TYPE_new_reserve(cmp, n) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_TYPE_compfunc_type(cmp), (n)))
+#define sk_ASN1_TYPE_value(sk, idx) ((ASN1_TYPE*)OPENSSL_sk_value(ossl_check_const_ASN1_TYPE_sk_type(sk), (idx)))
+#define sk_ASN1_TYPE_new(cmp) ((STACK_OF(ASN1_TYPE)*)OPENSSL_sk_new(ossl_check_ASN1_TYPE_compfunc_type(cmp)))
+#define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE)*)OPENSSL_sk_new_null())
+#define sk_ASN1_TYPE_new_reserve(cmp, n) ((STACK_OF(ASN1_TYPE)*)OPENSSL_sk_new_reserve(ossl_check_ASN1_TYPE_compfunc_type(cmp), (n)))
 #define sk_ASN1_TYPE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_TYPE_sk_type(sk), (n))
 #define sk_ASN1_TYPE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_TYPE_sk_type(sk))
 #define sk_ASN1_TYPE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_TYPE_sk_type(sk))
-#define sk_ASN1_TYPE_delete(sk, i) ((ASN1_TYPE *)OPENSSL_sk_delete(ossl_check_ASN1_TYPE_sk_type(sk), (i)))
-#define sk_ASN1_TYPE_delete_ptr(sk, ptr) ((ASN1_TYPE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr)))
+#define sk_ASN1_TYPE_delete(sk, i) ((ASN1_TYPE*)OPENSSL_sk_delete(ossl_check_ASN1_TYPE_sk_type(sk), (i)))
+#define sk_ASN1_TYPE_delete_ptr(sk, ptr) ((ASN1_TYPE*)OPENSSL_sk_delete_ptr(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr)))
 #define sk_ASN1_TYPE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
 #define sk_ASN1_TYPE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
-#define sk_ASN1_TYPE_pop(sk) ((ASN1_TYPE *)OPENSSL_sk_pop(ossl_check_ASN1_TYPE_sk_type(sk)))
-#define sk_ASN1_TYPE_shift(sk) ((ASN1_TYPE *)OPENSSL_sk_shift(ossl_check_ASN1_TYPE_sk_type(sk)))
-#define sk_ASN1_TYPE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_TYPE_sk_type(sk),ossl_check_ASN1_TYPE_freefunc_type(freefunc))
+#define sk_ASN1_TYPE_pop(sk) ((ASN1_TYPE*)OPENSSL_sk_pop(ossl_check_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_shift(sk) ((ASN1_TYPE*)OPENSSL_sk_shift(ossl_check_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_freefunc_type(freefunc))
 #define sk_ASN1_TYPE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), (idx))
-#define sk_ASN1_TYPE_set(sk, idx, ptr) ((ASN1_TYPE *)OPENSSL_sk_set(ossl_check_ASN1_TYPE_sk_type(sk), (idx), ossl_check_ASN1_TYPE_type(ptr)))
+#define sk_ASN1_TYPE_set(sk, idx, ptr) ((ASN1_TYPE*)OPENSSL_sk_set(ossl_check_ASN1_TYPE_sk_type(sk), (idx), ossl_check_ASN1_TYPE_type(ptr)))
 #define sk_ASN1_TYPE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
 #define sk_ASN1_TYPE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))
 #define sk_ASN1_TYPE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), pnum)
 #define sk_ASN1_TYPE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_TYPE_sk_type(sk))
 #define sk_ASN1_TYPE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_TYPE_sk_type(sk))
-#define sk_ASN1_TYPE_dup(sk) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_TYPE_sk_type(sk)))
-#define sk_ASN1_TYPE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_copyfunc_type(copyfunc), ossl_check_ASN1_TYPE_freefunc_type(freefunc)))
+#define sk_ASN1_TYPE_dup(sk) ((STACK_OF(ASN1_TYPE)*)OPENSSL_sk_dup(ossl_check_const_ASN1_TYPE_sk_type(sk)))
+#define sk_ASN1_TYPE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_TYPE)*)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_copyfunc_type(copyfunc), ossl_check_ASN1_TYPE_freefunc_type(freefunc)))
 #define sk_ASN1_TYPE_set_cmp_func(sk, cmp) ((sk_ASN1_TYPE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_compfunc_type(cmp)))
 
-
-typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY;
-
-DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY)
-DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SET_ANY)
-
-/* This is used to contain a list of bit names */
-typedef struct BIT_STRING_BITNAME_st {
-    int bitnum;
-    const char *lname;
-    const char *sname;
-} BIT_STRING_BITNAME;
-
-# define B_ASN1_TIME \
-                        B_ASN1_UTCTIME | \
-                        B_ASN1_GENERALIZEDTIME
-
-# define B_ASN1_PRINTABLE \
-                        B_ASN1_NUMERICSTRING| \
-                        B_ASN1_PRINTABLESTRING| \
-                        B_ASN1_T61STRING| \
-                        B_ASN1_IA5STRING| \
-                        B_ASN1_BIT_STRING| \
-                        B_ASN1_UNIVERSALSTRING|\
-                        B_ASN1_BMPSTRING|\
-                        B_ASN1_UTF8STRING|\
-                        B_ASN1_SEQUENCE|\
-                        B_ASN1_UNKNOWN
-
-# define B_ASN1_DIRECTORYSTRING \
-                        B_ASN1_PRINTABLESTRING| \
-                        B_ASN1_TELETEXSTRING|\
-                        B_ASN1_BMPSTRING|\
-                        B_ASN1_UNIVERSALSTRING|\
-                        B_ASN1_UTF8STRING
-
-# define B_ASN1_DISPLAYTEXT \
-                        B_ASN1_IA5STRING| \
-                        B_ASN1_VISIBLESTRING| \
-                        B_ASN1_BMPSTRING|\
-                        B_ASN1_UTF8STRING
-
-DECLARE_ASN1_ALLOC_FUNCTIONS_name(ASN1_TYPE, ASN1_TYPE)
-DECLARE_ASN1_ENCODE_FUNCTIONS(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)
-
-int ASN1_TYPE_get(const ASN1_TYPE *a);
-void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value);
-int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value);
-int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b);
-
-ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t);
-void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t);
-
-SKM_DEFINE_STACK_OF_INTERNAL(ASN1_OBJECT, ASN1_OBJECT, ASN1_OBJECT)
+    typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY;
+
+    DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY)
+        DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SET_ANY)
+
+        /* This is used to contain a list of bit names */
+        typedef struct BIT_STRING_BITNAME_st
+    {
+        int bitnum;
+        const char* lname;
+        const char* sname;
+    } BIT_STRING_BITNAME;
+
+#define B_ASN1_TIME  \
+    B_ASN1_UTCTIME | \
+        B_ASN1_GENERALIZEDTIME
+
+#define B_ASN1_PRINTABLE         \
+    B_ASN1_NUMERICSTRING |       \
+        B_ASN1_PRINTABLESTRING | \
+        B_ASN1_T61STRING |       \
+        B_ASN1_IA5STRING |       \
+        B_ASN1_BIT_STRING |      \
+        B_ASN1_UNIVERSALSTRING | \
+        B_ASN1_BMPSTRING |       \
+        B_ASN1_UTF8STRING |      \
+        B_ASN1_SEQUENCE |        \
+        B_ASN1_UNKNOWN
+
+#define B_ASN1_DIRECTORYSTRING   \
+    B_ASN1_PRINTABLESTRING |     \
+        B_ASN1_TELETEXSTRING |   \
+        B_ASN1_BMPSTRING |       \
+        B_ASN1_UNIVERSALSTRING | \
+        B_ASN1_UTF8STRING
+
+#define B_ASN1_DISPLAYTEXT     \
+    B_ASN1_IA5STRING |         \
+        B_ASN1_VISIBLESTRING | \
+        B_ASN1_BMPSTRING |     \
+        B_ASN1_UTF8STRING
+
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name(ASN1_TYPE, ASN1_TYPE)
+        DECLARE_ASN1_ENCODE_FUNCTIONS(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)
+
+            int ASN1_TYPE_get(const ASN1_TYPE* a);
+    void ASN1_TYPE_set(ASN1_TYPE* a, int type, void* value);
+    int ASN1_TYPE_set1(ASN1_TYPE* a, int type, const void* value);
+    int ASN1_TYPE_cmp(const ASN1_TYPE* a, const ASN1_TYPE* b);
+
+    ASN1_TYPE* ASN1_TYPE_pack_sequence(const ASN1_ITEM* it, void* s, ASN1_TYPE** t);
+    void* ASN1_TYPE_unpack_sequence(const ASN1_ITEM* it, const ASN1_TYPE* t);
+
+    SKM_DEFINE_STACK_OF_INTERNAL(ASN1_OBJECT, ASN1_OBJECT, ASN1_OBJECT)
 #define sk_ASN1_OBJECT_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_OBJECT_sk_type(sk))
-#define sk_ASN1_OBJECT_value(sk, idx) ((ASN1_OBJECT *)OPENSSL_sk_value(ossl_check_const_ASN1_OBJECT_sk_type(sk), (idx)))
-#define sk_ASN1_OBJECT_new(cmp) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new(ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
-#define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_null())
-#define sk_ASN1_OBJECT_new_reserve(cmp, n) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_OBJECT_compfunc_type(cmp), (n)))
+#define sk_ASN1_OBJECT_value(sk, idx) ((ASN1_OBJECT*)OPENSSL_sk_value(ossl_check_const_ASN1_OBJECT_sk_type(sk), (idx)))
+#define sk_ASN1_OBJECT_new(cmp) ((STACK_OF(ASN1_OBJECT)*)OPENSSL_sk_new(ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
+#define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT)*)OPENSSL_sk_new_null())
+#define sk_ASN1_OBJECT_new_reserve(cmp, n) ((STACK_OF(ASN1_OBJECT)*)OPENSSL_sk_new_reserve(ossl_check_ASN1_OBJECT_compfunc_type(cmp), (n)))
 #define sk_ASN1_OBJECT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_OBJECT_sk_type(sk), (n))
 #define sk_ASN1_OBJECT_free(sk) OPENSSL_sk_free(ossl_check_ASN1_OBJECT_sk_type(sk))
 #define sk_ASN1_OBJECT_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_OBJECT_sk_type(sk))
-#define sk_ASN1_OBJECT_delete(sk, i) ((ASN1_OBJECT *)OPENSSL_sk_delete(ossl_check_ASN1_OBJECT_sk_type(sk), (i)))
-#define sk_ASN1_OBJECT_delete_ptr(sk, ptr) ((ASN1_OBJECT *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr)))
+#define sk_ASN1_OBJECT_delete(sk, i) ((ASN1_OBJECT*)OPENSSL_sk_delete(ossl_check_ASN1_OBJECT_sk_type(sk), (i)))
+#define sk_ASN1_OBJECT_delete_ptr(sk, ptr) ((ASN1_OBJECT*)OPENSSL_sk_delete_ptr(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr)))
 #define sk_ASN1_OBJECT_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
 #define sk_ASN1_OBJECT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
-#define sk_ASN1_OBJECT_pop(sk) ((ASN1_OBJECT *)OPENSSL_sk_pop(ossl_check_ASN1_OBJECT_sk_type(sk)))
-#define sk_ASN1_OBJECT_shift(sk) ((ASN1_OBJECT *)OPENSSL_sk_shift(ossl_check_ASN1_OBJECT_sk_type(sk)))
-#define sk_ASN1_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_OBJECT_sk_type(sk),ossl_check_ASN1_OBJECT_freefunc_type(freefunc))
+#define sk_ASN1_OBJECT_pop(sk) ((ASN1_OBJECT*)OPENSSL_sk_pop(ossl_check_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_shift(sk) ((ASN1_OBJECT*)OPENSSL_sk_shift(ossl_check_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_freefunc_type(freefunc))
 #define sk_ASN1_OBJECT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), (idx))
-#define sk_ASN1_OBJECT_set(sk, idx, ptr) ((ASN1_OBJECT *)OPENSSL_sk_set(ossl_check_ASN1_OBJECT_sk_type(sk), (idx), ossl_check_ASN1_OBJECT_type(ptr)))
+#define sk_ASN1_OBJECT_set(sk, idx, ptr) ((ASN1_OBJECT*)OPENSSL_sk_set(ossl_check_ASN1_OBJECT_sk_type(sk), (idx), ossl_check_ASN1_OBJECT_type(ptr)))
 #define sk_ASN1_OBJECT_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
 #define sk_ASN1_OBJECT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))
 #define sk_ASN1_OBJECT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), pnum)
 #define sk_ASN1_OBJECT_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_OBJECT_sk_type(sk))
 #define sk_ASN1_OBJECT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_OBJECT_sk_type(sk))
-#define sk_ASN1_OBJECT_dup(sk) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_dup(ossl_check_const_ASN1_OBJECT_sk_type(sk)))
-#define sk_ASN1_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_copyfunc_type(copyfunc), ossl_check_ASN1_OBJECT_freefunc_type(freefunc)))
+#define sk_ASN1_OBJECT_dup(sk) ((STACK_OF(ASN1_OBJECT)*)OPENSSL_sk_dup(ossl_check_const_ASN1_OBJECT_sk_type(sk)))
+#define sk_ASN1_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_OBJECT)*)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_copyfunc_type(copyfunc), ossl_check_ASN1_OBJECT_freefunc_type(freefunc)))
 #define sk_ASN1_OBJECT_set_cmp_func(sk, cmp) ((sk_ASN1_OBJECT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_compfunc_type(cmp)))
 
+    DECLARE_ASN1_FUNCTIONS(ASN1_OBJECT)
 
-DECLARE_ASN1_FUNCTIONS(ASN1_OBJECT)
-
-ASN1_STRING *ASN1_STRING_new(void);
-void ASN1_STRING_free(ASN1_STRING *a);
-void ASN1_STRING_clear_free(ASN1_STRING *a);
-int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str);
-DECLARE_ASN1_DUP_FUNCTION(ASN1_STRING)
-ASN1_STRING *ASN1_STRING_type_new(int type);
-int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);
-  /*
-   * Since this is used to store all sorts of things, via macros, for now,
-   * make its data void *
-   */
-int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);
-void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len);
-int ASN1_STRING_length(const ASN1_STRING *x);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 void ASN1_STRING_length_set(ASN1_STRING *x, int n);
-# endif
-int ASN1_STRING_type(const ASN1_STRING *x);
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 unsigned char *ASN1_STRING_data(ASN1_STRING *x);
-# endif
-const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x);
-
-DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING)
-int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length);
-int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value);
-int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n);
-int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a,
-                          const unsigned char *flags, int flags_len);
-
-int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
-                               BIT_STRING_BITNAME *tbl, int indent);
-int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl);
-int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
-                            BIT_STRING_BITNAME *tbl);
-
-SKM_DEFINE_STACK_OF_INTERNAL(ASN1_INTEGER, ASN1_INTEGER, ASN1_INTEGER)
+    ASN1_STRING* ASN1_STRING_new(void);
+    void ASN1_STRING_free(ASN1_STRING* a);
+    void ASN1_STRING_clear_free(ASN1_STRING* a);
+    int ASN1_STRING_copy(ASN1_STRING* dst, const ASN1_STRING* str);
+    DECLARE_ASN1_DUP_FUNCTION(ASN1_STRING)
+    ASN1_STRING* ASN1_STRING_type_new(int type);
+    int ASN1_STRING_cmp(const ASN1_STRING* a, const ASN1_STRING* b);
+    /*
+     * Since this is used to store all sorts of things, via macros, for now,
+     * make its data void *
+     */
+    int ASN1_STRING_set(ASN1_STRING* str, const void* data, int len);
+    void ASN1_STRING_set0(ASN1_STRING* str, void* data, int len);
+    int ASN1_STRING_length(const ASN1_STRING* x);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 void ASN1_STRING_length_set(ASN1_STRING* x, int n);
+#endif
+    int ASN1_STRING_type(const ASN1_STRING* x);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 unsigned char* ASN1_STRING_data(ASN1_STRING* x);
+#endif
+    const unsigned char* ASN1_STRING_get0_data(const ASN1_STRING* x);
+
+    DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING)
+    int ASN1_BIT_STRING_set(ASN1_BIT_STRING* a, unsigned char* d, int length);
+    int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING* a, int n, int value);
+    int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING* a, int n);
+    int ASN1_BIT_STRING_check(const ASN1_BIT_STRING* a, const unsigned char* flags, int flags_len);
+
+    int ASN1_BIT_STRING_name_print(BIO* out, ASN1_BIT_STRING* bs, BIT_STRING_BITNAME* tbl, int indent);
+    int ASN1_BIT_STRING_num_asc(const char* name, BIT_STRING_BITNAME* tbl);
+    int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING* bs, const char* name, int value, BIT_STRING_BITNAME* tbl);
+
+    SKM_DEFINE_STACK_OF_INTERNAL(ASN1_INTEGER, ASN1_INTEGER, ASN1_INTEGER)
 #define sk_ASN1_INTEGER_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_INTEGER_sk_type(sk))
-#define sk_ASN1_INTEGER_value(sk, idx) ((ASN1_INTEGER *)OPENSSL_sk_value(ossl_check_const_ASN1_INTEGER_sk_type(sk), (idx)))
-#define sk_ASN1_INTEGER_new(cmp) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new(ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
-#define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_null())
-#define sk_ASN1_INTEGER_new_reserve(cmp, n) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_INTEGER_compfunc_type(cmp), (n)))
+#define sk_ASN1_INTEGER_value(sk, idx) ((ASN1_INTEGER*)OPENSSL_sk_value(ossl_check_const_ASN1_INTEGER_sk_type(sk), (idx)))
+#define sk_ASN1_INTEGER_new(cmp) ((STACK_OF(ASN1_INTEGER)*)OPENSSL_sk_new(ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
+#define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER)*)OPENSSL_sk_new_null())
+#define sk_ASN1_INTEGER_new_reserve(cmp, n) ((STACK_OF(ASN1_INTEGER)*)OPENSSL_sk_new_reserve(ossl_check_ASN1_INTEGER_compfunc_type(cmp), (n)))
 #define sk_ASN1_INTEGER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_INTEGER_sk_type(sk), (n))
 #define sk_ASN1_INTEGER_free(sk) OPENSSL_sk_free(ossl_check_ASN1_INTEGER_sk_type(sk))
 #define sk_ASN1_INTEGER_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_INTEGER_sk_type(sk))
-#define sk_ASN1_INTEGER_delete(sk, i) ((ASN1_INTEGER *)OPENSSL_sk_delete(ossl_check_ASN1_INTEGER_sk_type(sk), (i)))
-#define sk_ASN1_INTEGER_delete_ptr(sk, ptr) ((ASN1_INTEGER *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr)))
+#define sk_ASN1_INTEGER_delete(sk, i) ((ASN1_INTEGER*)OPENSSL_sk_delete(ossl_check_ASN1_INTEGER_sk_type(sk), (i)))
+#define sk_ASN1_INTEGER_delete_ptr(sk, ptr) ((ASN1_INTEGER*)OPENSSL_sk_delete_ptr(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr)))
 #define sk_ASN1_INTEGER_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
 #define sk_ASN1_INTEGER_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
-#define sk_ASN1_INTEGER_pop(sk) ((ASN1_INTEGER *)OPENSSL_sk_pop(ossl_check_ASN1_INTEGER_sk_type(sk)))
-#define sk_ASN1_INTEGER_shift(sk) ((ASN1_INTEGER *)OPENSSL_sk_shift(ossl_check_ASN1_INTEGER_sk_type(sk)))
-#define sk_ASN1_INTEGER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_INTEGER_sk_type(sk),ossl_check_ASN1_INTEGER_freefunc_type(freefunc))
+#define sk_ASN1_INTEGER_pop(sk) ((ASN1_INTEGER*)OPENSSL_sk_pop(ossl_check_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_shift(sk) ((ASN1_INTEGER*)OPENSSL_sk_shift(ossl_check_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_freefunc_type(freefunc))
 #define sk_ASN1_INTEGER_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), (idx))
-#define sk_ASN1_INTEGER_set(sk, idx, ptr) ((ASN1_INTEGER *)OPENSSL_sk_set(ossl_check_ASN1_INTEGER_sk_type(sk), (idx), ossl_check_ASN1_INTEGER_type(ptr)))
+#define sk_ASN1_INTEGER_set(sk, idx, ptr) ((ASN1_INTEGER*)OPENSSL_sk_set(ossl_check_ASN1_INTEGER_sk_type(sk), (idx), ossl_check_ASN1_INTEGER_type(ptr)))
 #define sk_ASN1_INTEGER_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
 #define sk_ASN1_INTEGER_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))
 #define sk_ASN1_INTEGER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), pnum)
 #define sk_ASN1_INTEGER_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_INTEGER_sk_type(sk))
 #define sk_ASN1_INTEGER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_INTEGER_sk_type(sk))
-#define sk_ASN1_INTEGER_dup(sk) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_dup(ossl_check_const_ASN1_INTEGER_sk_type(sk)))
-#define sk_ASN1_INTEGER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_copyfunc_type(copyfunc), ossl_check_ASN1_INTEGER_freefunc_type(freefunc)))
+#define sk_ASN1_INTEGER_dup(sk) ((STACK_OF(ASN1_INTEGER)*)OPENSSL_sk_dup(ossl_check_const_ASN1_INTEGER_sk_type(sk)))
+#define sk_ASN1_INTEGER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_INTEGER)*)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_copyfunc_type(copyfunc), ossl_check_ASN1_INTEGER_freefunc_type(freefunc)))
 #define sk_ASN1_INTEGER_set_cmp_func(sk, cmp) ((sk_ASN1_INTEGER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_compfunc_type(cmp)))
 
+    DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER)
+    ASN1_INTEGER* d2i_ASN1_UINTEGER(ASN1_INTEGER** a, const unsigned char** pp, long length);
+    DECLARE_ASN1_DUP_FUNCTION(ASN1_INTEGER)
+    int ASN1_INTEGER_cmp(const ASN1_INTEGER* x, const ASN1_INTEGER* y);
 
+    DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED)
 
-DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER)
-ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
-                                long length);
-DECLARE_ASN1_DUP_FUNCTION(ASN1_INTEGER)
-int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y);
+    int ASN1_UTCTIME_check(const ASN1_UTCTIME* a);
+    ASN1_UTCTIME* ASN1_UTCTIME_set(ASN1_UTCTIME* s, time_t t);
+    ASN1_UTCTIME* ASN1_UTCTIME_adj(ASN1_UTCTIME* s, time_t t, int offset_day, long offset_sec);
+    int ASN1_UTCTIME_set_string(ASN1_UTCTIME* s, const char* str);
+    int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME* s, time_t t);
 
-DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED)
+    int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME* a);
+    ASN1_GENERALIZEDTIME* ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME* s, time_t t);
+    ASN1_GENERALIZEDTIME* ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME* s, time_t t, int offset_day, long offset_sec);
+    int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME* s, const char* str);
 
-int ASN1_UTCTIME_check(const ASN1_UTCTIME *a);
-ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t);
-ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
-                               int offset_day, long offset_sec);
-int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str);
-int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t);
+    int ASN1_TIME_diff(int* pday, int* psec, const ASN1_TIME* from, const ASN1_TIME* to);
 
-int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a);
-ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
-                                               time_t t);
-ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
-                                               time_t t, int offset_day,
-                                               long offset_sec);
-int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str);
+    DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING)
+    DECLARE_ASN1_DUP_FUNCTION(ASN1_OCTET_STRING)
+    int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING* a, const ASN1_OCTET_STRING* b);
+    int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING* str, const unsigned char* data, int len);
 
-int ASN1_TIME_diff(int *pday, int *psec,
-                   const ASN1_TIME *from, const ASN1_TIME *to);
-
-DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING)
-DECLARE_ASN1_DUP_FUNCTION(ASN1_OCTET_STRING)
-int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a,
-                          const ASN1_OCTET_STRING *b);
-int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data,
-                          int len);
-
-SKM_DEFINE_STACK_OF_INTERNAL(ASN1_UTF8STRING, ASN1_UTF8STRING, ASN1_UTF8STRING)
+    SKM_DEFINE_STACK_OF_INTERNAL(ASN1_UTF8STRING, ASN1_UTF8STRING, ASN1_UTF8STRING)
 #define sk_ASN1_UTF8STRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))
-#define sk_ASN1_UTF8STRING_value(sk, idx) ((ASN1_UTF8STRING *)OPENSSL_sk_value(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), (idx)))
-#define sk_ASN1_UTF8STRING_new(cmp) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
-#define sk_ASN1_UTF8STRING_new_null() ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_null())
-#define sk_ASN1_UTF8STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_UTF8STRING_value(sk, idx) ((ASN1_UTF8STRING*)OPENSSL_sk_value(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), (idx)))
+#define sk_ASN1_UTF8STRING_new(cmp) ((STACK_OF(ASN1_UTF8STRING)*)OPENSSL_sk_new(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
+#define sk_ASN1_UTF8STRING_new_null() ((STACK_OF(ASN1_UTF8STRING)*)OPENSSL_sk_new_null())
+#define sk_ASN1_UTF8STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_UTF8STRING)*)OPENSSL_sk_new_reserve(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp), (n)))
 #define sk_ASN1_UTF8STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_UTF8STRING_sk_type(sk), (n))
 #define sk_ASN1_UTF8STRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_UTF8STRING_sk_type(sk))
 #define sk_ASN1_UTF8STRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_UTF8STRING_sk_type(sk))
-#define sk_ASN1_UTF8STRING_delete(sk, i) ((ASN1_UTF8STRING *)OPENSSL_sk_delete(ossl_check_ASN1_UTF8STRING_sk_type(sk), (i)))
-#define sk_ASN1_UTF8STRING_delete_ptr(sk, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr)))
+#define sk_ASN1_UTF8STRING_delete(sk, i) ((ASN1_UTF8STRING*)OPENSSL_sk_delete(ossl_check_ASN1_UTF8STRING_sk_type(sk), (i)))
+#define sk_ASN1_UTF8STRING_delete_ptr(sk, ptr) ((ASN1_UTF8STRING*)OPENSSL_sk_delete_ptr(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr)))
 #define sk_ASN1_UTF8STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
 #define sk_ASN1_UTF8STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
-#define sk_ASN1_UTF8STRING_pop(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_pop(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
-#define sk_ASN1_UTF8STRING_shift(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_shift(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
-#define sk_ASN1_UTF8STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_UTF8STRING_sk_type(sk),ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc))
+#define sk_ASN1_UTF8STRING_pop(sk) ((ASN1_UTF8STRING*)OPENSSL_sk_pop(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_shift(sk) ((ASN1_UTF8STRING*)OPENSSL_sk_shift(ossl_check_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc))
 #define sk_ASN1_UTF8STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), (idx))
-#define sk_ASN1_UTF8STRING_set(sk, idx, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_set(ossl_check_ASN1_UTF8STRING_sk_type(sk), (idx), ossl_check_ASN1_UTF8STRING_type(ptr)))
+#define sk_ASN1_UTF8STRING_set(sk, idx, ptr) ((ASN1_UTF8STRING*)OPENSSL_sk_set(ossl_check_ASN1_UTF8STRING_sk_type(sk), (idx), ossl_check_ASN1_UTF8STRING_type(ptr)))
 #define sk_ASN1_UTF8STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
 #define sk_ASN1_UTF8STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))
 #define sk_ASN1_UTF8STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), pnum)
 #define sk_ASN1_UTF8STRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_UTF8STRING_sk_type(sk))
 #define sk_ASN1_UTF8STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))
-#define sk_ASN1_UTF8STRING_dup(sk) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_UTF8STRING_sk_type(sk)))
-#define sk_ASN1_UTF8STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_copyfunc_type(copyfunc), ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc)))
+#define sk_ASN1_UTF8STRING_dup(sk) ((STACK_OF(ASN1_UTF8STRING)*)OPENSSL_sk_dup(ossl_check_const_ASN1_UTF8STRING_sk_type(sk)))
+#define sk_ASN1_UTF8STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_UTF8STRING)*)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_copyfunc_type(copyfunc), ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc)))
 #define sk_ASN1_UTF8STRING_set_cmp_func(sk, cmp) ((sk_ASN1_UTF8STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))
 
+    DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING)
+    DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING)
+    DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING)
+    DECLARE_ASN1_FUNCTIONS(ASN1_NULL)
+    DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING)
 
-DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING)
-DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING)
-DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING)
-DECLARE_ASN1_FUNCTIONS(ASN1_NULL)
-DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING)
+    int UTF8_getc(const unsigned char* str, int len, unsigned long* val);
+    int UTF8_putc(unsigned char* str, int len, unsigned long value);
 
-int UTF8_getc(const unsigned char *str, int len, unsigned long *val);
-int UTF8_putc(unsigned char *str, int len, unsigned long value);
-
-SKM_DEFINE_STACK_OF_INTERNAL(ASN1_GENERALSTRING, ASN1_GENERALSTRING, ASN1_GENERALSTRING)
+    SKM_DEFINE_STACK_OF_INTERNAL(ASN1_GENERALSTRING, ASN1_GENERALSTRING, ASN1_GENERALSTRING)
 #define sk_ASN1_GENERALSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))
-#define sk_ASN1_GENERALSTRING_value(sk, idx) ((ASN1_GENERALSTRING *)OPENSSL_sk_value(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), (idx)))
-#define sk_ASN1_GENERALSTRING_new(cmp) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
-#define sk_ASN1_GENERALSTRING_new_null() ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_null())
-#define sk_ASN1_GENERALSTRING_new_reserve(cmp, n) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_GENERALSTRING_value(sk, idx) ((ASN1_GENERALSTRING*)OPENSSL_sk_value(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), (idx)))
+#define sk_ASN1_GENERALSTRING_new(cmp) ((STACK_OF(ASN1_GENERALSTRING)*)OPENSSL_sk_new(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
+#define sk_ASN1_GENERALSTRING_new_null() ((STACK_OF(ASN1_GENERALSTRING)*)OPENSSL_sk_new_null())
+#define sk_ASN1_GENERALSTRING_new_reserve(cmp, n) ((STACK_OF(ASN1_GENERALSTRING)*)OPENSSL_sk_new_reserve(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp), (n)))
 #define sk_ASN1_GENERALSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (n))
 #define sk_ASN1_GENERALSTRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
 #define sk_ASN1_GENERALSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
-#define sk_ASN1_GENERALSTRING_delete(sk, i) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (i)))
-#define sk_ASN1_GENERALSTRING_delete_ptr(sk, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr)))
+#define sk_ASN1_GENERALSTRING_delete(sk, i) ((ASN1_GENERALSTRING*)OPENSSL_sk_delete(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (i)))
+#define sk_ASN1_GENERALSTRING_delete_ptr(sk, ptr) ((ASN1_GENERALSTRING*)OPENSSL_sk_delete_ptr(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr)))
 #define sk_ASN1_GENERALSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
 #define sk_ASN1_GENERALSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
-#define sk_ASN1_GENERALSTRING_pop(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_pop(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
-#define sk_ASN1_GENERALSTRING_shift(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_shift(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
-#define sk_ASN1_GENERALSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk),ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc))
+#define sk_ASN1_GENERALSTRING_pop(sk) ((ASN1_GENERALSTRING*)OPENSSL_sk_pop(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_shift(sk) ((ASN1_GENERALSTRING*)OPENSSL_sk_shift(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc))
 #define sk_ASN1_GENERALSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), (idx))
-#define sk_ASN1_GENERALSTRING_set(sk, idx, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_set(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (idx), ossl_check_ASN1_GENERALSTRING_type(ptr)))
+#define sk_ASN1_GENERALSTRING_set(sk, idx, ptr) ((ASN1_GENERALSTRING*)OPENSSL_sk_set(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (idx), ossl_check_ASN1_GENERALSTRING_type(ptr)))
 #define sk_ASN1_GENERALSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
 #define sk_ASN1_GENERALSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))
 #define sk_ASN1_GENERALSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), pnum)
 #define sk_ASN1_GENERALSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_GENERALSTRING_sk_type(sk))
 #define sk_ASN1_GENERALSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))
-#define sk_ASN1_GENERALSTRING_dup(sk) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk)))
-#define sk_ASN1_GENERALSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_copyfunc_type(copyfunc), ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc)))
+#define sk_ASN1_GENERALSTRING_dup(sk) ((STACK_OF(ASN1_GENERALSTRING)*)OPENSSL_sk_dup(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk)))
+#define sk_ASN1_GENERALSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_GENERALSTRING)*)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_copyfunc_type(copyfunc), ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc)))
 #define sk_ASN1_GENERALSTRING_set_cmp_func(sk, cmp) ((sk_ASN1_GENERALSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))
 
+    DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE)
+
+        DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING)
+            DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT)
+                DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING)
+                    DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING)
+                        DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING)
+                            DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING)
+                                DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME)
+                                    DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME)
+                                        DECLARE_ASN1_FUNCTIONS(ASN1_TIME)
+
+                                            DECLARE_ASN1_DUP_FUNCTION(ASN1_TIME)
+                                                DECLARE_ASN1_DUP_FUNCTION(ASN1_UTCTIME)
+                                                    DECLARE_ASN1_DUP_FUNCTION(ASN1_GENERALIZEDTIME)
+
+                                                        DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF)
+
+                                                            ASN1_TIME* ASN1_TIME_set(ASN1_TIME* s, time_t t);
+    ASN1_TIME* ASN1_TIME_adj(ASN1_TIME* s, time_t t, int offset_day, long offset_sec);
+    int ASN1_TIME_check(const ASN1_TIME* t);
+    ASN1_GENERALIZEDTIME* ASN1_TIME_to_generalizedtime(const ASN1_TIME* t, ASN1_GENERALIZEDTIME** out);
+    int ASN1_TIME_set_string(ASN1_TIME* s, const char* str);
+    int ASN1_TIME_set_string_X509(ASN1_TIME* s, const char* str);
+    int ASN1_TIME_to_tm(const ASN1_TIME* s, struct tm* tm);
+    int ASN1_TIME_normalize(ASN1_TIME* s);
+    int ASN1_TIME_cmp_time_t(const ASN1_TIME* s, time_t t);
+    int ASN1_TIME_compare(const ASN1_TIME* a, const ASN1_TIME* b);
+
+    int i2a_ASN1_INTEGER(BIO* bp, const ASN1_INTEGER* a);
+    int a2i_ASN1_INTEGER(BIO* bp, ASN1_INTEGER* bs, char* buf, int size);
+    int i2a_ASN1_ENUMERATED(BIO* bp, const ASN1_ENUMERATED* a);
+    int a2i_ASN1_ENUMERATED(BIO* bp, ASN1_ENUMERATED* bs, char* buf, int size);
+    int i2a_ASN1_OBJECT(BIO* bp, const ASN1_OBJECT* a);
+    int a2i_ASN1_STRING(BIO* bp, ASN1_STRING* bs, char* buf, int size);
+    int i2a_ASN1_STRING(BIO* bp, const ASN1_STRING* a, int type);
+    int i2t_ASN1_OBJECT(char* buf, int buf_len, const ASN1_OBJECT* a);
+
+    int a2d_ASN1_OBJECT(unsigned char* out, int olen, const char* buf, int num);
+    ASN1_OBJECT* ASN1_OBJECT_create(int nid, unsigned char* data, int len, const char* sn, const char* ln);
+
+    int ASN1_INTEGER_get_int64(int64_t* pr, const ASN1_INTEGER* a);
+    int ASN1_INTEGER_set_int64(ASN1_INTEGER* a, int64_t r);
+    int ASN1_INTEGER_get_uint64(uint64_t* pr, const ASN1_INTEGER* a);
+    int ASN1_INTEGER_set_uint64(ASN1_INTEGER* a, uint64_t r);
+
+    int ASN1_INTEGER_set(ASN1_INTEGER* a, long v);
+    long ASN1_INTEGER_get(const ASN1_INTEGER* a);
+    ASN1_INTEGER* BN_to_ASN1_INTEGER(const BIGNUM* bn, ASN1_INTEGER* ai);
+    BIGNUM* ASN1_INTEGER_to_BN(const ASN1_INTEGER* ai, BIGNUM* bn);
+
+    int ASN1_ENUMERATED_get_int64(int64_t* pr, const ASN1_ENUMERATED* a);
+    int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED* a, int64_t r);
+
+    int ASN1_ENUMERATED_set(ASN1_ENUMERATED* a, long v);
+    long ASN1_ENUMERATED_get(const ASN1_ENUMERATED* a);
+    ASN1_ENUMERATED* BN_to_ASN1_ENUMERATED(const BIGNUM* bn, ASN1_ENUMERATED* ai);
+    BIGNUM* ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED* ai, BIGNUM* bn);
+
+    /* General */
+    /* given a string, return the correct type, max is the maximum length */
+    int ASN1_PRINTABLE_type(const unsigned char* s, int max);
+
+    unsigned long ASN1_tag2bit(int tag);
+
+    /* SPECIALS */
+    int ASN1_get_object(const unsigned char** pp, long* plength, int* ptag, int* pclass, long omax);
+    int ASN1_check_infinite_end(unsigned char** p, long len);
+    int ASN1_const_check_infinite_end(const unsigned char** p, long len);
+    void ASN1_put_object(unsigned char** pp, int constructed, int length, int tag, int xclass);
+    int ASN1_put_eoc(unsigned char** pp);
+    int ASN1_object_size(int constructed, int length, int tag);
+
+    /* Used to implement other functions */
+    void* ASN1_dup(i2d_of_void* i2d, d2i_of_void* d2i, const void* x);
+
+#define ASN1_dup_of(type, i2d, d2i, x) \
+    ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), CHECKED_D2I_OF(type, d2i), CHECKED_PTR_OF(const type, x)))
+
+    void* ASN1_item_dup(const ASN1_ITEM* it, const void* x);
+    int ASN1_item_sign_ex(const ASN1_ITEM* it, X509_ALGOR* algor1, X509_ALGOR* algor2, ASN1_BIT_STRING* signature, const void* data, const ASN1_OCTET_STRING* id, EVP_PKEY* pkey, const EVP_MD* md, OSSL_LIB_CTX* libctx, const char* propq);
+    int ASN1_item_verify_ex(const ASN1_ITEM* it, const X509_ALGOR* alg, const ASN1_BIT_STRING* signature, const void* data, const ASN1_OCTET_STRING* id, EVP_PKEY* pkey, OSSL_LIB_CTX* libctx, const char* propq);
+
+    /* ASN1 alloc/free macros for when a type is only used internally */
+
+#define M_ASN1_new_of(type) (type*)ASN1_item_new(ASN1_ITEM_rptr(type))
+#define M_ASN1_free_of(x, type) \
+    ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type))
+
+#ifndef OPENSSL_NO_STDIO
+    void* ASN1_d2i_fp(void* (*xnew)(void), d2i_of_void* d2i, FILE* in, void** x);
+
+#define ASN1_d2i_fp_of(type, xnew, d2i, in, x) \
+    ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), CHECKED_D2I_OF(type, d2i), in, CHECKED_PPTR_OF(type, x)))
+
+    void* ASN1_item_d2i_fp_ex(const ASN1_ITEM* it, FILE* in, void* x, OSSL_LIB_CTX* libctx, const char* propq);
+    void* ASN1_item_d2i_fp(const ASN1_ITEM* it, FILE* in, void* x);
+    int ASN1_i2d_fp(i2d_of_void* i2d, FILE* out, const void* x);
+
+#define ASN1_i2d_fp_of(type, i2d, out, x) \
+    (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), out, CHECKED_PTR_OF(const type, x)))
+
+    int ASN1_item_i2d_fp(const ASN1_ITEM* it, FILE* out, const void* x);
+    int ASN1_STRING_print_ex_fp(FILE* fp, const ASN1_STRING* str, unsigned long flags);
+#endif
+
+    int ASN1_STRING_to_UTF8(unsigned char** out, const ASN1_STRING* in);
+
+    void* ASN1_d2i_bio(void* (*xnew)(void), d2i_of_void* d2i, BIO* in, void** x);
+
+#define ASN1_d2i_bio_of(type, xnew, d2i, in, x) \
+    ((type*)ASN1_d2i_bio(CHECKED_NEW_OF(type, xnew), CHECKED_D2I_OF(type, d2i), in, CHECKED_PPTR_OF(type, x)))
 
-DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE)
-
-DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING)
-DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT)
-DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING)
-DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING)
-DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING)
-DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING)
-DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME)
-DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME)
-DECLARE_ASN1_FUNCTIONS(ASN1_TIME)
-
-DECLARE_ASN1_DUP_FUNCTION(ASN1_TIME)
-DECLARE_ASN1_DUP_FUNCTION(ASN1_UTCTIME)
-DECLARE_ASN1_DUP_FUNCTION(ASN1_GENERALIZEDTIME)
-
-DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF)
-
-ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t);
-ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t,
-                         int offset_day, long offset_sec);
-int ASN1_TIME_check(const ASN1_TIME *t);
-ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t,
-                                                   ASN1_GENERALIZEDTIME **out);
-int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
-int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str);
-int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm);
-int ASN1_TIME_normalize(ASN1_TIME *s);
-int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t);
-int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b);
-
-int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a);
-int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size);
-int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a);
-int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size);
-int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a);
-int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size);
-int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type);
-int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a);
-
-int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num);
-ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
-                                const char *sn, const char *ln);
-
-int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a);
-int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r);
-int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a);
-int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r);
-
-int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
-long ASN1_INTEGER_get(const ASN1_INTEGER *a);
-ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai);
-BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn);
-
-int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a);
-int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r);
-
-
-int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v);
-long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a);
-ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai);
-BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn);
-
-/* General */
-/* given a string, return the correct type, max is the maximum length */
-int ASN1_PRINTABLE_type(const unsigned char *s, int max);
-
-unsigned long ASN1_tag2bit(int tag);
-
-/* SPECIALS */
-int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
-                    int *pclass, long omax);
-int ASN1_check_infinite_end(unsigned char **p, long len);
-int ASN1_const_check_infinite_end(const unsigned char **p, long len);
-void ASN1_put_object(unsigned char **pp, int constructed, int length,
-                     int tag, int xclass);
-int ASN1_put_eoc(unsigned char **pp);
-int ASN1_object_size(int constructed, int length, int tag);
-
-/* Used to implement other functions */
-void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, const void *x);
-
-# define ASN1_dup_of(type,i2d,d2i,x) \
-    ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \
-                     CHECKED_D2I_OF(type, d2i), \
-                     CHECKED_PTR_OF(const type, x)))
-
-void *ASN1_item_dup(const ASN1_ITEM *it, const void *x);
-int ASN1_item_sign_ex(const ASN1_ITEM *it, X509_ALGOR *algor1,
-                      X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
-                      const void *data, const ASN1_OCTET_STRING *id,
-                      EVP_PKEY *pkey, const EVP_MD *md, OSSL_LIB_CTX *libctx,
-                      const char *propq);
-int ASN1_item_verify_ex(const ASN1_ITEM *it, const X509_ALGOR *alg,
-                        const ASN1_BIT_STRING *signature, const void *data,
-                        const ASN1_OCTET_STRING *id, EVP_PKEY *pkey,
-                        OSSL_LIB_CTX *libctx, const char *propq);
-
-/* ASN1 alloc/free macros for when a type is only used internally */
-
-# define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type))
-# define M_ASN1_free_of(x, type) \
-                ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type))
-
-# ifndef OPENSSL_NO_STDIO
-void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x);
-
-#  define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \
-    ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \
-                        CHECKED_D2I_OF(type, d2i), \
-                        in, \
-                        CHECKED_PPTR_OF(type, x)))
-
-void *ASN1_item_d2i_fp_ex(const ASN1_ITEM *it, FILE *in, void *x,
-                          OSSL_LIB_CTX *libctx, const char *propq);
-void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
-int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, const void *x);
-
-#  define ASN1_i2d_fp_of(type,i2d,out,x) \
-    (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \
-                 out, \
-                 CHECKED_PTR_OF(const type, x)))
-
-int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, const void *x);
-int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags);
-# endif
-
-int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in);
-
-void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x);
-
-#  define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \
-    ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \
-                          CHECKED_D2I_OF(type, d2i), \
-                          in, \
-                          CHECKED_PPTR_OF(type, x)))
-
-void *ASN1_item_d2i_bio_ex(const ASN1_ITEM *it, BIO *in, void *pval,
-                           OSSL_LIB_CTX *libctx, const char *propq);
-void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *pval);
-int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, const void *x);
-
-#  define ASN1_i2d_bio_of(type,i2d,out,x) \
-    (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \
-                  out, \
-                  CHECKED_PTR_OF(const type, x)))
-
-int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, const void *x);
-BIO *ASN1_item_i2d_mem_bio(const ASN1_ITEM *it, const ASN1_VALUE *val);
-int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a);
-int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a);
-int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm);
-int ASN1_TIME_print_ex(BIO *bp, const ASN1_TIME *tm, unsigned long flags);
-int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v);
-int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags);
-int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off);
-int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num,
-                  unsigned char *buf, int off);
-int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent);
-int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent,
-                    int dump);
-const char *ASN1_tag2str(int tag);
-
-/* Used to load and write Netscape format cert */
-
-int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s);
-
-int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len);
-int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len);
-int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num,
-                                  unsigned char *data, int len);
-int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num,
-                                  unsigned char *data, int max_len);
-
-void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it);
-
-ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it,
-                            ASN1_OCTET_STRING **oct);
-
-void ASN1_STRING_set_default_mask(unsigned long mask);
-int ASN1_STRING_set_default_mask_asc(const char *p);
-unsigned long ASN1_STRING_get_default_mask(void);
-int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
-                       int inform, unsigned long mask);
-int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
-                        int inform, unsigned long mask,
-                        long minsize, long maxsize);
-
-ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out,
-                                    const unsigned char *in, int inlen,
-                                    int inform, int nid);
-ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid);
-int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long);
-void ASN1_STRING_TABLE_cleanup(void);
-
-/* ASN1 template functions */
-
-/* Old API compatible functions */
-ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);
-ASN1_VALUE *ASN1_item_new_ex(const ASN1_ITEM *it, OSSL_LIB_CTX *libctx,
-                             const char *propq);
-void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);
-ASN1_VALUE *ASN1_item_d2i_ex(ASN1_VALUE **val, const unsigned char **in,
-                             long len, const ASN1_ITEM *it,
-                             OSSL_LIB_CTX *libctx, const char *propq);
-ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in,
-                          long len, const ASN1_ITEM *it);
-int ASN1_item_i2d(const ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
-int ASN1_item_ndef_i2d(const ASN1_VALUE *val, unsigned char **out,
-                       const ASN1_ITEM *it);
-
-void ASN1_add_oid_module(void);
-void ASN1_add_stable_module(void);
-
-ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf);
-ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf);
-int ASN1_str2mask(const char *str, unsigned long *pmask);
+    void* ASN1_item_d2i_bio_ex(const ASN1_ITEM* it, BIO* in, void* pval, OSSL_LIB_CTX* libctx, const char* propq);
+    void* ASN1_item_d2i_bio(const ASN1_ITEM* it, BIO* in, void* pval);
+    int ASN1_i2d_bio(i2d_of_void* i2d, BIO* out, const void* x);
+
+#define ASN1_i2d_bio_of(type, i2d, out, x) \
+    (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), out, CHECKED_PTR_OF(const type, x)))
+
+    int ASN1_item_i2d_bio(const ASN1_ITEM* it, BIO* out, const void* x);
+    BIO* ASN1_item_i2d_mem_bio(const ASN1_ITEM* it, const ASN1_VALUE* val);
+    int ASN1_UTCTIME_print(BIO* fp, const ASN1_UTCTIME* a);
+    int ASN1_GENERALIZEDTIME_print(BIO* fp, const ASN1_GENERALIZEDTIME* a);
+    int ASN1_TIME_print(BIO* bp, const ASN1_TIME* tm);
+    int ASN1_TIME_print_ex(BIO* bp, const ASN1_TIME* tm, unsigned long flags);
+    int ASN1_STRING_print(BIO* bp, const ASN1_STRING* v);
+    int ASN1_STRING_print_ex(BIO* out, const ASN1_STRING* str, unsigned long flags);
+    int ASN1_buf_print(BIO* bp, const unsigned char* buf, size_t buflen, int off);
+    int ASN1_bn_print(BIO* bp, const char* number, const BIGNUM* num, unsigned char* buf, int off);
+    int ASN1_parse(BIO* bp, const unsigned char* pp, long len, int indent);
+    int ASN1_parse_dump(BIO* bp, const unsigned char* pp, long len, int indent, int dump);
+    const char* ASN1_tag2str(int tag);
+
+    /* Used to load and write Netscape format cert */
+
+    int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING* s);
+
+    int ASN1_TYPE_set_octetstring(ASN1_TYPE* a, unsigned char* data, int len);
+    int ASN1_TYPE_get_octetstring(const ASN1_TYPE* a, unsigned char* data, int max_len);
+    int ASN1_TYPE_set_int_octetstring(ASN1_TYPE* a, long num, unsigned char* data, int len);
+    int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE* a, long* num, unsigned char* data, int max_len);
+
+    void* ASN1_item_unpack(const ASN1_STRING* oct, const ASN1_ITEM* it);
+
+    ASN1_STRING* ASN1_item_pack(void* obj, const ASN1_ITEM* it, ASN1_OCTET_STRING** oct);
+
+    void ASN1_STRING_set_default_mask(unsigned long mask);
+    int ASN1_STRING_set_default_mask_asc(const char* p);
+    unsigned long ASN1_STRING_get_default_mask(void);
+    int ASN1_mbstring_copy(ASN1_STRING** out, const unsigned char* in, int len, int inform, unsigned long mask);
+    int ASN1_mbstring_ncopy(ASN1_STRING** out, const unsigned char* in, int len, int inform, unsigned long mask, long minsize, long maxsize);
+
+    ASN1_STRING* ASN1_STRING_set_by_NID(ASN1_STRING** out, const unsigned char* in, int inlen, int inform, int nid);
+    ASN1_STRING_TABLE* ASN1_STRING_TABLE_get(int nid);
+    int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long);
+    void ASN1_STRING_TABLE_cleanup(void);
+
+    /* ASN1 template functions */
+
+    /* Old API compatible functions */
+    ASN1_VALUE* ASN1_item_new(const ASN1_ITEM* it);
+    ASN1_VALUE* ASN1_item_new_ex(const ASN1_ITEM* it, OSSL_LIB_CTX* libctx, const char* propq);
+    void ASN1_item_free(ASN1_VALUE* val, const ASN1_ITEM* it);
+    ASN1_VALUE* ASN1_item_d2i_ex(ASN1_VALUE** val, const unsigned char** in, long len, const ASN1_ITEM* it, OSSL_LIB_CTX* libctx, const char* propq);
+    ASN1_VALUE* ASN1_item_d2i(ASN1_VALUE** val, const unsigned char** in, long len, const ASN1_ITEM* it);
+    int ASN1_item_i2d(const ASN1_VALUE* val, unsigned char** out, const ASN1_ITEM* it);
+    int ASN1_item_ndef_i2d(const ASN1_VALUE* val, unsigned char** out, const ASN1_ITEM* it);
+
+    void ASN1_add_oid_module(void);
+    void ASN1_add_stable_module(void);
+
+    ASN1_TYPE* ASN1_generate_nconf(const char* str, CONF* nconf);
+    ASN1_TYPE* ASN1_generate_v3(const char* str, X509V3_CTX* cnf);
+    int ASN1_str2mask(const char* str, unsigned long* pmask);
 
 /* ASN1 Print flags */
 
 /* Indicate missing OPTIONAL fields */
-# define ASN1_PCTX_FLAGS_SHOW_ABSENT             0x001
+#define ASN1_PCTX_FLAGS_SHOW_ABSENT 0x001
 /* Mark start and end of SEQUENCE */
-# define ASN1_PCTX_FLAGS_SHOW_SEQUENCE           0x002
+#define ASN1_PCTX_FLAGS_SHOW_SEQUENCE 0x002
 /* Mark start and end of SEQUENCE/SET OF */
-# define ASN1_PCTX_FLAGS_SHOW_SSOF               0x004
+#define ASN1_PCTX_FLAGS_SHOW_SSOF 0x004
 /* Show the ASN1 type of primitives */
-# define ASN1_PCTX_FLAGS_SHOW_TYPE               0x008
+#define ASN1_PCTX_FLAGS_SHOW_TYPE 0x008
 /* Don't show ASN1 type of ANY */
-# define ASN1_PCTX_FLAGS_NO_ANY_TYPE             0x010
+#define ASN1_PCTX_FLAGS_NO_ANY_TYPE 0x010
 /* Don't show ASN1 type of MSTRINGs */
-# define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE         0x020
+#define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE 0x020
 /* Don't show field names in SEQUENCE */
-# define ASN1_PCTX_FLAGS_NO_FIELD_NAME           0x040
+#define ASN1_PCTX_FLAGS_NO_FIELD_NAME 0x040
 /* Show structure names of each SEQUENCE field */
-# define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME  0x080
+#define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME 0x080
 /* Don't show structure name even at top level */
-# define ASN1_PCTX_FLAGS_NO_STRUCT_NAME          0x100
-
-int ASN1_item_print(BIO *out, const ASN1_VALUE *ifld, int indent,
-                    const ASN1_ITEM *it, const ASN1_PCTX *pctx);
-ASN1_PCTX *ASN1_PCTX_new(void);
-void ASN1_PCTX_free(ASN1_PCTX *p);
-unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p);
-void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags);
-unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p);
-void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags);
-unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p);
-void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags);
-unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p);
-void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags);
-unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p);
-void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags);
-
-ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx));
-void ASN1_SCTX_free(ASN1_SCTX *p);
-const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p);
-const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p);
-unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p);
-void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data);
-void *ASN1_SCTX_get_app_data(ASN1_SCTX *p);
-
-const BIO_METHOD *BIO_f_asn1(void);
-
-/* cannot constify val because of CMS_stream() */
-BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it);
-
-int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
-                        const ASN1_ITEM *it);
-int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
-                              const char *hdr, const ASN1_ITEM *it);
-/* cannot constify val because of CMS_dataFinal() */
-int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
-                     int ctype_nid, int econt_nid,
-                     STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it);
-int SMIME_write_ASN1_ex(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
-                        int ctype_nid, int econt_nid,
-                        STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it,
-                        OSSL_LIB_CTX *libctx, const char *propq);
-ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it);
-ASN1_VALUE *SMIME_read_ASN1_ex(BIO *bio, int flags, BIO **bcont,
-                               const ASN1_ITEM *it, ASN1_VALUE **x,
-                               OSSL_LIB_CTX *libctx, const char *propq);
-int SMIME_crlf_copy(BIO *in, BIO *out, int flags);
-int SMIME_text(BIO *in, BIO *out);
-
-const ASN1_ITEM *ASN1_ITEM_lookup(const char *name);
-const ASN1_ITEM *ASN1_ITEM_get(size_t i);
+#define ASN1_PCTX_FLAGS_NO_STRUCT_NAME 0x100
+
+    int ASN1_item_print(BIO* out, const ASN1_VALUE* ifld, int indent, const ASN1_ITEM* it, const ASN1_PCTX* pctx);
+    ASN1_PCTX* ASN1_PCTX_new(void);
+    void ASN1_PCTX_free(ASN1_PCTX* p);
+    unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX* p);
+    void ASN1_PCTX_set_flags(ASN1_PCTX* p, unsigned long flags);
+    unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX* p);
+    void ASN1_PCTX_set_nm_flags(ASN1_PCTX* p, unsigned long flags);
+    unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX* p);
+    void ASN1_PCTX_set_cert_flags(ASN1_PCTX* p, unsigned long flags);
+    unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX* p);
+    void ASN1_PCTX_set_oid_flags(ASN1_PCTX* p, unsigned long flags);
+    unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX* p);
+    void ASN1_PCTX_set_str_flags(ASN1_PCTX* p, unsigned long flags);
+
+    ASN1_SCTX* ASN1_SCTX_new(int (*scan_cb)(ASN1_SCTX* ctx));
+    void ASN1_SCTX_free(ASN1_SCTX* p);
+    const ASN1_ITEM* ASN1_SCTX_get_item(ASN1_SCTX* p);
+    const ASN1_TEMPLATE* ASN1_SCTX_get_template(ASN1_SCTX* p);
+    unsigned long ASN1_SCTX_get_flags(ASN1_SCTX* p);
+    void ASN1_SCTX_set_app_data(ASN1_SCTX* p, void* data);
+    void* ASN1_SCTX_get_app_data(ASN1_SCTX* p);
+
+    const BIO_METHOD* BIO_f_asn1(void);
+
+    /* cannot constify val because of CMS_stream() */
+    BIO* BIO_new_NDEF(BIO* out, ASN1_VALUE* val, const ASN1_ITEM* it);
+
+    int i2d_ASN1_bio_stream(BIO* out, ASN1_VALUE* val, BIO* in, int flags, const ASN1_ITEM* it);
+    int PEM_write_bio_ASN1_stream(BIO* out, ASN1_VALUE* val, BIO* in, int flags, const char* hdr, const ASN1_ITEM* it);
+    /* cannot constify val because of CMS_dataFinal() */
+    int SMIME_write_ASN1(BIO* bio, ASN1_VALUE* val, BIO* data, int flags, int ctype_nid, int econt_nid, STACK_OF(X509_ALGOR) * mdalgs, const ASN1_ITEM* it);
+    int SMIME_write_ASN1_ex(BIO* bio, ASN1_VALUE* val, BIO* data, int flags, int ctype_nid, int econt_nid, STACK_OF(X509_ALGOR) * mdalgs, const ASN1_ITEM* it, OSSL_LIB_CTX* libctx, const char* propq);
+    ASN1_VALUE* SMIME_read_ASN1(BIO* bio, BIO** bcont, const ASN1_ITEM* it);
+    ASN1_VALUE* SMIME_read_ASN1_ex(BIO* bio, int flags, BIO** bcont, const ASN1_ITEM* it, ASN1_VALUE** x, OSSL_LIB_CTX* libctx, const char* propq);
+    int SMIME_crlf_copy(BIO* in, BIO* out, int flags);
+    int SMIME_text(BIO* in, BIO* out);
+
+    const ASN1_ITEM* ASN1_ITEM_lookup(const char* name);
+    const ASN1_ITEM* ASN1_ITEM_get(size_t i);
 
 /* Legacy compatibility */
-# define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \
-         DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \
-         DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)
-# define DECLARE_ASN1_FUNCTIONS_const(type) DECLARE_ASN1_FUNCTIONS(type)
-# define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \
-         DECLARE_ASN1_ENCODE_FUNCTIONS(type, name)
-# define I2D_OF_const(type) I2D_OF(type)
-# define ASN1_dup_of_const(type,i2d,d2i,x) ASN1_dup_of(type,i2d,d2i,x)
-# define ASN1_i2d_fp_of_const(type,i2d,out,x) ASN1_i2d_fp_of(type,i2d,out,x)
-# define ASN1_i2d_bio_of_const(type,i2d,out,x) ASN1_i2d_bio_of(type,i2d,out,x)
-
-# ifdef  __cplusplus
+#define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \
+    DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name)        \
+        DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)
+#define DECLARE_ASN1_FUNCTIONS_const(type) DECLARE_ASN1_FUNCTIONS(type)
+#define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \
+    DECLARE_ASN1_ENCODE_FUNCTIONS(type, name)
+#define I2D_OF_const(type) I2D_OF(type)
+#define ASN1_dup_of_const(type, i2d, d2i, x) ASN1_dup_of(type, i2d, d2i, x)
+#define ASN1_i2d_fp_of_const(type, i2d, out, x) ASN1_i2d_fp_of(type, i2d, out, x)
+#define ASN1_i2d_bio_of_const(type, i2d, out, x) ASN1_i2d_bio_of(type, i2d, out, x)
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/asn1err.h b/CAPI/cpp/grpc/include/openssl/asn1err.h
index d427622..1c4f29a 100644
--- a/CAPI/cpp/grpc/include/openssl/asn1err.h
+++ b/CAPI/cpp/grpc/include/openssl/asn1err.h
@@ -9,132 +9,130 @@
  */
 
 #ifndef OPENSSL_ASN1ERR_H
-# define OPENSSL_ASN1ERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_ASN1ERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * ASN1 reason codes.
  */
-# define ASN1_R_ADDING_OBJECT                             171
-# define ASN1_R_ASN1_PARSE_ERROR                          203
-# define ASN1_R_ASN1_SIG_PARSE_ERROR                      204
-# define ASN1_R_AUX_ERROR                                 100
-# define ASN1_R_BAD_OBJECT_HEADER                         102
-# define ASN1_R_BAD_TEMPLATE                              230
-# define ASN1_R_BMPSTRING_IS_WRONG_LENGTH                 214
-# define ASN1_R_BN_LIB                                    105
-# define ASN1_R_BOOLEAN_IS_WRONG_LENGTH                   106
-# define ASN1_R_BUFFER_TOO_SMALL                          107
-# define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER           108
-# define ASN1_R_CONTEXT_NOT_INITIALISED                   217
-# define ASN1_R_DATA_IS_WRONG                             109
-# define ASN1_R_DECODE_ERROR                              110
-# define ASN1_R_DEPTH_EXCEEDED                            174
-# define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED         198
-# define ASN1_R_ENCODE_ERROR                              112
-# define ASN1_R_ERROR_GETTING_TIME                        173
-# define ASN1_R_ERROR_LOADING_SECTION                     172
-# define ASN1_R_ERROR_SETTING_CIPHER_PARAMS               114
-# define ASN1_R_EXPECTING_AN_INTEGER                      115
-# define ASN1_R_EXPECTING_AN_OBJECT                       116
-# define ASN1_R_EXPLICIT_LENGTH_MISMATCH                  119
-# define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED              120
-# define ASN1_R_FIELD_MISSING                             121
-# define ASN1_R_FIRST_NUM_TOO_LARGE                       122
-# define ASN1_R_HEADER_TOO_LONG                           123
-# define ASN1_R_ILLEGAL_BITSTRING_FORMAT                  175
-# define ASN1_R_ILLEGAL_BOOLEAN                           176
-# define ASN1_R_ILLEGAL_CHARACTERS                        124
-# define ASN1_R_ILLEGAL_FORMAT                            177
-# define ASN1_R_ILLEGAL_HEX                               178
-# define ASN1_R_ILLEGAL_IMPLICIT_TAG                      179
-# define ASN1_R_ILLEGAL_INTEGER                           180
-# define ASN1_R_ILLEGAL_NEGATIVE_VALUE                    226
-# define ASN1_R_ILLEGAL_NESTED_TAGGING                    181
-# define ASN1_R_ILLEGAL_NULL                              125
-# define ASN1_R_ILLEGAL_NULL_VALUE                        182
-# define ASN1_R_ILLEGAL_OBJECT                            183
-# define ASN1_R_ILLEGAL_OPTIONAL_ANY                      126
-# define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE          170
-# define ASN1_R_ILLEGAL_PADDING                           221
-# define ASN1_R_ILLEGAL_TAGGED_ANY                        127
-# define ASN1_R_ILLEGAL_TIME_VALUE                        184
-# define ASN1_R_ILLEGAL_ZERO_CONTENT                      222
-# define ASN1_R_INTEGER_NOT_ASCII_FORMAT                  185
-# define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG                128
-# define ASN1_R_INVALID_BIT_STRING_BITS_LEFT              220
-# define ASN1_R_INVALID_BMPSTRING_LENGTH                  129
-# define ASN1_R_INVALID_DIGIT                             130
-# define ASN1_R_INVALID_MIME_TYPE                         205
-# define ASN1_R_INVALID_MODIFIER                          186
-# define ASN1_R_INVALID_NUMBER                            187
-# define ASN1_R_INVALID_OBJECT_ENCODING                   216
-# define ASN1_R_INVALID_SCRYPT_PARAMETERS                 227
-# define ASN1_R_INVALID_SEPARATOR                         131
-# define ASN1_R_INVALID_STRING_TABLE_VALUE                218
-# define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH            133
-# define ASN1_R_INVALID_UTF8STRING                        134
-# define ASN1_R_INVALID_VALUE                             219
-# define ASN1_R_LENGTH_TOO_LONG                           231
-# define ASN1_R_LIST_ERROR                                188
-# define ASN1_R_MIME_NO_CONTENT_TYPE                      206
-# define ASN1_R_MIME_PARSE_ERROR                          207
-# define ASN1_R_MIME_SIG_PARSE_ERROR                      208
-# define ASN1_R_MISSING_EOC                               137
-# define ASN1_R_MISSING_SECOND_NUMBER                     138
-# define ASN1_R_MISSING_VALUE                             189
-# define ASN1_R_MSTRING_NOT_UNIVERSAL                     139
-# define ASN1_R_MSTRING_WRONG_TAG                         140
-# define ASN1_R_NESTED_ASN1_STRING                        197
-# define ASN1_R_NESTED_TOO_DEEP                           201
-# define ASN1_R_NON_HEX_CHARACTERS                        141
-# define ASN1_R_NOT_ASCII_FORMAT                          190
-# define ASN1_R_NOT_ENOUGH_DATA                           142
-# define ASN1_R_NO_CONTENT_TYPE                           209
-# define ASN1_R_NO_MATCHING_CHOICE_TYPE                   143
-# define ASN1_R_NO_MULTIPART_BODY_FAILURE                 210
-# define ASN1_R_NO_MULTIPART_BOUNDARY                     211
-# define ASN1_R_NO_SIG_CONTENT_TYPE                       212
-# define ASN1_R_NULL_IS_WRONG_LENGTH                      144
-# define ASN1_R_OBJECT_NOT_ASCII_FORMAT                   191
-# define ASN1_R_ODD_NUMBER_OF_CHARS                       145
-# define ASN1_R_SECOND_NUMBER_TOO_LARGE                   147
-# define ASN1_R_SEQUENCE_LENGTH_MISMATCH                  148
-# define ASN1_R_SEQUENCE_NOT_CONSTRUCTED                  149
-# define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG              192
-# define ASN1_R_SHORT_LINE                                150
-# define ASN1_R_SIG_INVALID_MIME_TYPE                     213
-# define ASN1_R_STREAMING_NOT_SUPPORTED                   202
-# define ASN1_R_STRING_TOO_LONG                           151
-# define ASN1_R_STRING_TOO_SHORT                          152
-# define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154
-# define ASN1_R_TIME_NOT_ASCII_FORMAT                     193
-# define ASN1_R_TOO_LARGE                                 223
-# define ASN1_R_TOO_LONG                                  155
-# define ASN1_R_TOO_SMALL                                 224
-# define ASN1_R_TYPE_NOT_CONSTRUCTED                      156
-# define ASN1_R_TYPE_NOT_PRIMITIVE                        195
-# define ASN1_R_UNEXPECTED_EOC                            159
-# define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH           215
-# define ASN1_R_UNKNOWN_DIGEST                            229
-# define ASN1_R_UNKNOWN_FORMAT                            160
-# define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM          161
-# define ASN1_R_UNKNOWN_OBJECT_TYPE                       162
-# define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE                   163
-# define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM               199
-# define ASN1_R_UNKNOWN_TAG                               194
-# define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE           164
-# define ASN1_R_UNSUPPORTED_CIPHER                        228
-# define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE               167
-# define ASN1_R_UNSUPPORTED_TYPE                          196
-# define ASN1_R_WRONG_INTEGER_TYPE                        225
-# define ASN1_R_WRONG_PUBLIC_KEY_TYPE                     200
-# define ASN1_R_WRONG_TAG                                 168
+#define ASN1_R_ADDING_OBJECT 171
+#define ASN1_R_ASN1_PARSE_ERROR 203
+#define ASN1_R_ASN1_SIG_PARSE_ERROR 204
+#define ASN1_R_AUX_ERROR 100
+#define ASN1_R_BAD_OBJECT_HEADER 102
+#define ASN1_R_BAD_TEMPLATE 230
+#define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214
+#define ASN1_R_BN_LIB 105
+#define ASN1_R_BOOLEAN_IS_WRONG_LENGTH 106
+#define ASN1_R_BUFFER_TOO_SMALL 107
+#define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 108
+#define ASN1_R_CONTEXT_NOT_INITIALISED 217
+#define ASN1_R_DATA_IS_WRONG 109
+#define ASN1_R_DECODE_ERROR 110
+#define ASN1_R_DEPTH_EXCEEDED 174
+#define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED 198
+#define ASN1_R_ENCODE_ERROR 112
+#define ASN1_R_ERROR_GETTING_TIME 173
+#define ASN1_R_ERROR_LOADING_SECTION 172
+#define ASN1_R_ERROR_SETTING_CIPHER_PARAMS 114
+#define ASN1_R_EXPECTING_AN_INTEGER 115
+#define ASN1_R_EXPECTING_AN_OBJECT 116
+#define ASN1_R_EXPLICIT_LENGTH_MISMATCH 119
+#define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED 120
+#define ASN1_R_FIELD_MISSING 121
+#define ASN1_R_FIRST_NUM_TOO_LARGE 122
+#define ASN1_R_HEADER_TOO_LONG 123
+#define ASN1_R_ILLEGAL_BITSTRING_FORMAT 175
+#define ASN1_R_ILLEGAL_BOOLEAN 176
+#define ASN1_R_ILLEGAL_CHARACTERS 124
+#define ASN1_R_ILLEGAL_FORMAT 177
+#define ASN1_R_ILLEGAL_HEX 178
+#define ASN1_R_ILLEGAL_IMPLICIT_TAG 179
+#define ASN1_R_ILLEGAL_INTEGER 180
+#define ASN1_R_ILLEGAL_NEGATIVE_VALUE 226
+#define ASN1_R_ILLEGAL_NESTED_TAGGING 181
+#define ASN1_R_ILLEGAL_NULL 125
+#define ASN1_R_ILLEGAL_NULL_VALUE 182
+#define ASN1_R_ILLEGAL_OBJECT 183
+#define ASN1_R_ILLEGAL_OPTIONAL_ANY 126
+#define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE 170
+#define ASN1_R_ILLEGAL_PADDING 221
+#define ASN1_R_ILLEGAL_TAGGED_ANY 127
+#define ASN1_R_ILLEGAL_TIME_VALUE 184
+#define ASN1_R_ILLEGAL_ZERO_CONTENT 222
+#define ASN1_R_INTEGER_NOT_ASCII_FORMAT 185
+#define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG 128
+#define ASN1_R_INVALID_BIT_STRING_BITS_LEFT 220
+#define ASN1_R_INVALID_BMPSTRING_LENGTH 129
+#define ASN1_R_INVALID_DIGIT 130
+#define ASN1_R_INVALID_MIME_TYPE 205
+#define ASN1_R_INVALID_MODIFIER 186
+#define ASN1_R_INVALID_NUMBER 187
+#define ASN1_R_INVALID_OBJECT_ENCODING 216
+#define ASN1_R_INVALID_SCRYPT_PARAMETERS 227
+#define ASN1_R_INVALID_SEPARATOR 131
+#define ASN1_R_INVALID_STRING_TABLE_VALUE 218
+#define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH 133
+#define ASN1_R_INVALID_UTF8STRING 134
+#define ASN1_R_INVALID_VALUE 219
+#define ASN1_R_LENGTH_TOO_LONG 231
+#define ASN1_R_LIST_ERROR 188
+#define ASN1_R_MIME_NO_CONTENT_TYPE 206
+#define ASN1_R_MIME_PARSE_ERROR 207
+#define ASN1_R_MIME_SIG_PARSE_ERROR 208
+#define ASN1_R_MISSING_EOC 137
+#define ASN1_R_MISSING_SECOND_NUMBER 138
+#define ASN1_R_MISSING_VALUE 189
+#define ASN1_R_MSTRING_NOT_UNIVERSAL 139
+#define ASN1_R_MSTRING_WRONG_TAG 140
+#define ASN1_R_NESTED_ASN1_STRING 197
+#define ASN1_R_NESTED_TOO_DEEP 201
+#define ASN1_R_NON_HEX_CHARACTERS 141
+#define ASN1_R_NOT_ASCII_FORMAT 190
+#define ASN1_R_NOT_ENOUGH_DATA 142
+#define ASN1_R_NO_CONTENT_TYPE 209
+#define ASN1_R_NO_MATCHING_CHOICE_TYPE 143
+#define ASN1_R_NO_MULTIPART_BODY_FAILURE 210
+#define ASN1_R_NO_MULTIPART_BOUNDARY 211
+#define ASN1_R_NO_SIG_CONTENT_TYPE 212
+#define ASN1_R_NULL_IS_WRONG_LENGTH 144
+#define ASN1_R_OBJECT_NOT_ASCII_FORMAT 191
+#define ASN1_R_ODD_NUMBER_OF_CHARS 145
+#define ASN1_R_SECOND_NUMBER_TOO_LARGE 147
+#define ASN1_R_SEQUENCE_LENGTH_MISMATCH 148
+#define ASN1_R_SEQUENCE_NOT_CONSTRUCTED 149
+#define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG 192
+#define ASN1_R_SHORT_LINE 150
+#define ASN1_R_SIG_INVALID_MIME_TYPE 213
+#define ASN1_R_STREAMING_NOT_SUPPORTED 202
+#define ASN1_R_STRING_TOO_LONG 151
+#define ASN1_R_STRING_TOO_SHORT 152
+#define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154
+#define ASN1_R_TIME_NOT_ASCII_FORMAT 193
+#define ASN1_R_TOO_LARGE 223
+#define ASN1_R_TOO_LONG 155
+#define ASN1_R_TOO_SMALL 224
+#define ASN1_R_TYPE_NOT_CONSTRUCTED 156
+#define ASN1_R_TYPE_NOT_PRIMITIVE 195
+#define ASN1_R_UNEXPECTED_EOC 159
+#define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH 215
+#define ASN1_R_UNKNOWN_DIGEST 229
+#define ASN1_R_UNKNOWN_FORMAT 160
+#define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM 161
+#define ASN1_R_UNKNOWN_OBJECT_TYPE 162
+#define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE 163
+#define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199
+#define ASN1_R_UNKNOWN_TAG 194
+#define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164
+#define ASN1_R_UNSUPPORTED_CIPHER 228
+#define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167
+#define ASN1_R_UNSUPPORTED_TYPE 196
+#define ASN1_R_WRONG_INTEGER_TYPE 225
+#define ASN1_R_WRONG_PUBLIC_KEY_TYPE 200
+#define ASN1_R_WRONG_TAG 168
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/asn1t.h b/CAPI/cpp/grpc/include/openssl/asn1t.h
index a725c53..570bab6 100644
--- a/CAPI/cpp/grpc/include/openssl/asn1t.h
+++ b/CAPI/cpp/grpc/include/openssl/asn1t.h
@@ -10,533 +10,534 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_ASN1T_H
-# define OPENSSL_ASN1T_H
-# pragma once
+#define OPENSSL_ASN1T_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_ASN1T_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ASN1T_H
+#endif
 
-# include <stddef.h>
-# include <openssl/e_os2.h>
-# include <openssl/asn1.h>
+#include <stddef.h>
+#include <openssl/e_os2.h>
+#include <openssl/asn1.h>
 
-# ifdef OPENSSL_BUILD_SHLIBCRYPTO
-#  undef OPENSSL_EXTERN
-#  define OPENSSL_EXTERN OPENSSL_EXPORT
-# endif
+#ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#undef OPENSSL_EXTERN
+#define OPENSSL_EXTERN OPENSSL_EXPORT
+#endif
 
 /* ASN1 template defines, structures and functions */
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-/*-
- * These are the possible values for the itype field of the
- * ASN1_ITEM structure and determine how it is interpreted.
- *
- * For PRIMITIVE types the underlying type
- * determines the behaviour if items is NULL.
- *
- * Otherwise templates must contain a single
- * template and the type is treated in the
- * same way as the type specified in the template.
- *
- * For SEQUENCE types the templates field points
- * to the members, the size field is the
- * structure size.
- *
- * For CHOICE types the templates field points
- * to each possible member (typically a union)
- * and the 'size' field is the offset of the
- * selector.
- *
- * The 'funcs' field is used for application-specific
- * data and functions.
- *
- * The EXTERN type uses a new style d2i/i2d.
- * The new style should be used where possible
- * because it avoids things like the d2i IMPLICIT
- * hack.
- *
- * MSTRING is a multiple string type, it is used
- * for a CHOICE of character strings where the
- * actual strings all occupy an ASN1_STRING
- * structure. In this case the 'utype' field
- * has a special meaning, it is used as a mask
- * of acceptable types using the B_ASN1 constants.
- *
- * NDEF_SEQUENCE is the same as SEQUENCE except
- * that it will use indefinite length constructed
- * encoding if requested.
- *
- */
-
-# define ASN1_ITYPE_PRIMITIVE            0x0
-# define ASN1_ITYPE_SEQUENCE             0x1
-# define ASN1_ITYPE_CHOICE               0x2
+    /*-
+     * These are the possible values for the itype field of the
+     * ASN1_ITEM structure and determine how it is interpreted.
+     *
+     * For PRIMITIVE types the underlying type
+     * determines the behaviour if items is NULL.
+     *
+     * Otherwise templates must contain a single
+     * template and the type is treated in the
+     * same way as the type specified in the template.
+     *
+     * For SEQUENCE types the templates field points
+     * to the members, the size field is the
+     * structure size.
+     *
+     * For CHOICE types the templates field points
+     * to each possible member (typically a union)
+     * and the 'size' field is the offset of the
+     * selector.
+     *
+     * The 'funcs' field is used for application-specific
+     * data and functions.
+     *
+     * The EXTERN type uses a new style d2i/i2d.
+     * The new style should be used where possible
+     * because it avoids things like the d2i IMPLICIT
+     * hack.
+     *
+     * MSTRING is a multiple string type, it is used
+     * for a CHOICE of character strings where the
+     * actual strings all occupy an ASN1_STRING
+     * structure. In this case the 'utype' field
+     * has a special meaning, it is used as a mask
+     * of acceptable types using the B_ASN1 constants.
+     *
+     * NDEF_SEQUENCE is the same as SEQUENCE except
+     * that it will use indefinite length constructed
+     * encoding if requested.
+     *
+     */
+
+#define ASN1_ITYPE_PRIMITIVE 0x0
+#define ASN1_ITYPE_SEQUENCE 0x1
+#define ASN1_ITYPE_CHOICE 0x2
 /* unused value                          0x3 */
-# define ASN1_ITYPE_EXTERN               0x4
-# define ASN1_ITYPE_MSTRING              0x5
-# define ASN1_ITYPE_NDEF_SEQUENCE        0x6
+#define ASN1_ITYPE_EXTERN 0x4
+#define ASN1_ITYPE_MSTRING 0x5
+#define ASN1_ITYPE_NDEF_SEQUENCE 0x6
 
 /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */
-# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)((iptr)()))
-
-/* Macros for start and end of ASN1_ITEM definition */
-
-# define ASN1_ITEM_start(itname) \
-        const ASN1_ITEM * itname##_it(void) \
-        { \
-                static const ASN1_ITEM local_it = {
-
-# define static_ASN1_ITEM_start(itname) \
-        static ASN1_ITEM_start(itname)
-
-# define ASN1_ITEM_end(itname) \
-                }; \
-        return &local_it; \
-        }
-
-/* Macros to aid ASN1 template writing */
-
-# define ASN1_ITEM_TEMPLATE(tname) \
-        static const ASN1_TEMPLATE tname##_item_tt
-
-# define ASN1_ITEM_TEMPLATE_END(tname) \
-        ;\
-        ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_PRIMITIVE,\
-                -1,\
-                &tname##_item_tt,\
-                0,\
-                NULL,\
-                0,\
-                #tname \
-        ASN1_ITEM_end(tname)
-# define static_ASN1_ITEM_TEMPLATE_END(tname) \
-        ;\
-        static_ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_PRIMITIVE,\
-                -1,\
-                &tname##_item_tt,\
-                0,\
-                NULL,\
-                0,\
-                #tname \
-        ASN1_ITEM_end(tname)
-
-/* This is a ASN1 type which just embeds a template */
-
-/*-
- * This pair helps declare a SEQUENCE. We can do:
- *
- *      ASN1_SEQUENCE(stname) = {
- *              ... SEQUENCE components ...
- *      } ASN1_SEQUENCE_END(stname)
- *
- *      This will produce an ASN1_ITEM called stname_it
- *      for a structure called stname.
- *
- *      If you want the same structure but a different
- *      name then use:
- *
- *      ASN1_SEQUENCE(itname) = {
- *              ... SEQUENCE components ...
- *      } ASN1_SEQUENCE_END_name(stname, itname)
- *
- *      This will create an item called itname_it using
- *      a structure called stname.
- */
-
-# define ASN1_SEQUENCE(tname) \
-        static const ASN1_TEMPLATE tname##_seq_tt[]
-
-# define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)
-
-# define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname)
-
-# define ASN1_SEQUENCE_END_name(stname, tname) \
-        ;\
-        ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_SEQUENCE,\
-                V_ASN1_SEQUENCE,\
-                tname##_seq_tt,\
-                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
-                NULL,\
-                sizeof(stname),\
-                #tname \
-        ASN1_ITEM_end(tname)
-
-# define static_ASN1_SEQUENCE_END_name(stname, tname) \
-        ;\
-        static_ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_SEQUENCE,\
-                V_ASN1_SEQUENCE,\
-                tname##_seq_tt,\
-                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
-                NULL,\
-                sizeof(stname),\
-                #stname \
-        ASN1_ITEM_end(tname)
-
-# define ASN1_NDEF_SEQUENCE(tname) \
-        ASN1_SEQUENCE(tname)
-
-# define ASN1_NDEF_SEQUENCE_cb(tname, cb) \
-        ASN1_SEQUENCE_cb(tname, cb)
-
-# define ASN1_SEQUENCE_cb(tname, cb) \
-        static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0, NULL}; \
-        ASN1_SEQUENCE(tname)
-
-# define ASN1_SEQUENCE_const_cb(tname, const_cb) \
-        static const ASN1_AUX tname##_aux = \
-            {NULL, ASN1_AFLG_CONST_CB, 0, 0, NULL, 0, const_cb}; \
-        ASN1_SEQUENCE(tname)
-
-# define ASN1_SEQUENCE_cb_const_cb(tname, cb, const_cb) \
-        static const ASN1_AUX tname##_aux = \
-            {NULL, ASN1_AFLG_CONST_CB, 0, 0, cb, 0, const_cb}; \
-        ASN1_SEQUENCE(tname)
-
-# define ASN1_SEQUENCE_ref(tname, cb) \
-        static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0, NULL}; \
-        ASN1_SEQUENCE(tname)
-
-# define ASN1_SEQUENCE_enc(tname, enc, cb) \
-        static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc), NULL}; \
-        ASN1_SEQUENCE(tname)
-
-# define ASN1_NDEF_SEQUENCE_END(tname) \
-        ;\
-        ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_NDEF_SEQUENCE,\
-                V_ASN1_SEQUENCE,\
-                tname##_seq_tt,\
-                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
-                NULL,\
-                sizeof(tname),\
-                #tname \
-        ASN1_ITEM_end(tname)
-# define static_ASN1_NDEF_SEQUENCE_END(tname) \
-        ;\
-        static_ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_NDEF_SEQUENCE,\
-                V_ASN1_SEQUENCE,\
-                tname##_seq_tt,\
-                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
-                NULL,\
-                sizeof(tname),\
-                #tname \
-        ASN1_ITEM_end(tname)
-
-
-# define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
-
-# define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
-# define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname)
-
-# define ASN1_SEQUENCE_END_ref(stname, tname) \
-        ;\
-        ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_SEQUENCE,\
-                V_ASN1_SEQUENCE,\
-                tname##_seq_tt,\
-                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
-                &tname##_aux,\
-                sizeof(stname),\
-                #tname \
-        ASN1_ITEM_end(tname)
-# define static_ASN1_SEQUENCE_END_ref(stname, tname) \
-        ;\
-        static_ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_SEQUENCE,\
-                V_ASN1_SEQUENCE,\
-                tname##_seq_tt,\
-                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
-                &tname##_aux,\
-                sizeof(stname),\
-                #stname \
-        ASN1_ITEM_end(tname)
-
-# define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \
-        ;\
-        ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_NDEF_SEQUENCE,\
-                V_ASN1_SEQUENCE,\
-                tname##_seq_tt,\
-                sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\
-                &tname##_aux,\
-                sizeof(stname),\
-                #stname \
-        ASN1_ITEM_end(tname)
-
-/*-
- * This pair helps declare a CHOICE type. We can do:
- *
- *      ASN1_CHOICE(chname) = {
- *              ... CHOICE options ...
- *      ASN1_CHOICE_END(chname)
- *
- *      This will produce an ASN1_ITEM called chname_it
- *      for a structure called chname. The structure
- *      definition must look like this:
- *      typedef struct {
- *              int type;
- *              union {
- *                      ASN1_SOMETHING *opt1;
- *                      ASN1_SOMEOTHER *opt2;
- *              } value;
- *      } chname;
- *
- *      the name of the selector must be 'type'.
- *      to use an alternative selector name use the
- *      ASN1_CHOICE_END_selector() version.
- */
-
-# define ASN1_CHOICE(tname) \
-        static const ASN1_TEMPLATE tname##_ch_tt[]
-
-# define ASN1_CHOICE_cb(tname, cb) \
-        static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0, NULL}; \
-        ASN1_CHOICE(tname)
-
-# define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
-
-# define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname)
-
-# define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
-
-# define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type)
-
-# define ASN1_CHOICE_END_selector(stname, tname, selname) \
-        ;\
-        ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_CHOICE,\
-                offsetof(stname,selname) ,\
-                tname##_ch_tt,\
-                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
-                NULL,\
-                sizeof(stname),\
-                #stname \
-        ASN1_ITEM_end(tname)
-
-# define static_ASN1_CHOICE_END_selector(stname, tname, selname) \
-        ;\
-        static_ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_CHOICE,\
-                offsetof(stname,selname) ,\
-                tname##_ch_tt,\
-                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
-                NULL,\
-                sizeof(stname),\
-                #stname \
-        ASN1_ITEM_end(tname)
-
-# define ASN1_CHOICE_END_cb(stname, tname, selname) \
-        ;\
-        ASN1_ITEM_start(tname) \
-                ASN1_ITYPE_CHOICE,\
-                offsetof(stname,selname) ,\
-                tname##_ch_tt,\
-                sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\
-                &tname##_aux,\
-                sizeof(stname),\
-                #stname \
-        ASN1_ITEM_end(tname)
-
-/* This helps with the template wrapper form of ASN1_ITEM */
-
-# define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \
-        (flags), (tag), 0,\
-        #name, ASN1_ITEM_ref(type) }
-
-/* These help with SEQUENCE or CHOICE components */
-
-/* used to declare other types */
-
-# define ASN1_EX_TYPE(flags, tag, stname, field, type) { \
-        (flags), (tag), offsetof(stname, field),\
-        #field, ASN1_ITEM_ref(type) }
-
-/* implicit and explicit helper macros */
-
-# define ASN1_IMP_EX(stname, field, type, tag, ex) \
-         ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type)
-
-# define ASN1_EXP_EX(stname, field, type, tag, ex) \
-         ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type)
-
-/* Any defined by macros: the field used is in the table itself */
-
-# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb }
-# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb }
+#define ASN1_ADB_ptr(iptr) ((const ASN1_ADB*)((iptr)()))
+
+    /* Macros for start and end of ASN1_ITEM definition */
+
+#define ASN1_ITEM_start(itname)        \
+    const ASN1_ITEM* itname##_it(void) \
+    {                                  \
+        static const ASN1_ITEM local_it = {
+#define static_ASN1_ITEM_start(itname) \
+    static ASN1_ITEM_start(itname)
+
+#define ASN1_ITEM_end(itname) \
+    }                         \
+    ;                         \
+    return &local_it;         \
+    }
+
+    /* Macros to aid ASN1 template writing */
+
+#define ASN1_ITEM_TEMPLATE(tname) \
+    static const ASN1_TEMPLATE tname##_item_tt
+
+#define ASN1_ITEM_TEMPLATE_END(tname) \
+    ;                                 \
+    ASN1_ITEM_start(tname)            \
+        ASN1_ITYPE_PRIMITIVE,         \
+        -1,                           \
+        &tname##_item_tt,             \
+        0,                            \
+        NULL,                         \
+        0,                            \
+        #tname ASN1_ITEM_end(tname)
+#define static_ASN1_ITEM_TEMPLATE_END(tname) \
+    ;                                        \
+    static_ASN1_ITEM_start(tname)            \
+        ASN1_ITYPE_PRIMITIVE,                \
+        -1,                                  \
+        &tname##_item_tt,                    \
+        0,                                   \
+        NULL,                                \
+        0,                                   \
+        #tname ASN1_ITEM_end(tname)
+
+    /* This is a ASN1 type which just embeds a template */
+
+    /*-
+     * This pair helps declare a SEQUENCE. We can do:
+     *
+     *      ASN1_SEQUENCE(stname) = {
+     *              ... SEQUENCE components ...
+     *      } ASN1_SEQUENCE_END(stname)
+     *
+     *      This will produce an ASN1_ITEM called stname_it
+     *      for a structure called stname.
+     *
+     *      If you want the same structure but a different
+     *      name then use:
+     *
+     *      ASN1_SEQUENCE(itname) = {
+     *              ... SEQUENCE components ...
+     *      } ASN1_SEQUENCE_END_name(stname, itname)
+     *
+     *      This will create an item called itname_it using
+     *      a structure called stname.
+     */
+
+#define ASN1_SEQUENCE(tname) \
+    static const ASN1_TEMPLATE tname##_seq_tt[]
+
+#define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname)
+
+#define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname)
+
+#define ASN1_SEQUENCE_END_name(stname, tname)           \
+    ;                                                   \
+    ASN1_ITEM_start(tname)                              \
+        ASN1_ITYPE_SEQUENCE,                            \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        NULL,                                           \
+        sizeof(stname),                                 \
+        #tname ASN1_ITEM_end(tname)
+
+#define static_ASN1_SEQUENCE_END_name(stname, tname)    \
+    ;                                                   \
+    static_ASN1_ITEM_start(tname)                       \
+        ASN1_ITYPE_SEQUENCE,                            \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        NULL,                                           \
+        sizeof(stname),                                 \
+        #stname ASN1_ITEM_end(tname)
+
+#define ASN1_NDEF_SEQUENCE(tname) \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_NDEF_SEQUENCE_cb(tname, cb) \
+    ASN1_SEQUENCE_cb(tname, cb)
+
+#define ASN1_SEQUENCE_cb(tname, cb)                                   \
+    static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0, NULL}; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_SEQUENCE_const_cb(tname, const_cb)              \
+    static const ASN1_AUX tname##_aux =                      \
+        {NULL, ASN1_AFLG_CONST_CB, 0, 0, NULL, 0, const_cb}; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_SEQUENCE_cb_const_cb(tname, cb, const_cb)     \
+    static const ASN1_AUX tname##_aux =                    \
+        {NULL, ASN1_AFLG_CONST_CB, 0, 0, cb, 0, const_cb}; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_SEQUENCE_ref(tname, cb)                                                                                                 \
+    static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0, NULL}; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_SEQUENCE_enc(tname, enc, cb)                                                                 \
+    static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc), NULL}; \
+    ASN1_SEQUENCE(tname)
+
+#define ASN1_NDEF_SEQUENCE_END(tname)                   \
+    ;                                                   \
+    ASN1_ITEM_start(tname)                              \
+        ASN1_ITYPE_NDEF_SEQUENCE,                       \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        NULL,                                           \
+        sizeof(tname),                                  \
+        #tname ASN1_ITEM_end(tname)
+#define static_ASN1_NDEF_SEQUENCE_END(tname)            \
+    ;                                                   \
+    static_ASN1_ITEM_start(tname)                       \
+        ASN1_ITYPE_NDEF_SEQUENCE,                       \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        NULL,                                           \
+        sizeof(tname),                                  \
+        #tname ASN1_ITEM_end(tname)
+
+#define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
+
+#define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname)
+#define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname)
+
+#define ASN1_SEQUENCE_END_ref(stname, tname)            \
+    ;                                                   \
+    ASN1_ITEM_start(tname)                              \
+        ASN1_ITYPE_SEQUENCE,                            \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        &tname##_aux,                                   \
+        sizeof(stname),                                 \
+        #tname ASN1_ITEM_end(tname)
+#define static_ASN1_SEQUENCE_END_ref(stname, tname)     \
+    ;                                                   \
+    static_ASN1_ITEM_start(tname)                       \
+        ASN1_ITYPE_SEQUENCE,                            \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        &tname##_aux,                                   \
+        sizeof(stname),                                 \
+        #stname ASN1_ITEM_end(tname)
+
+#define ASN1_NDEF_SEQUENCE_END_cb(stname, tname)        \
+    ;                                                   \
+    ASN1_ITEM_start(tname)                              \
+        ASN1_ITYPE_NDEF_SEQUENCE,                       \
+        V_ASN1_SEQUENCE,                                \
+        tname##_seq_tt,                                 \
+        sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE), \
+        &tname##_aux,                                   \
+        sizeof(stname),                                 \
+        #stname ASN1_ITEM_end(tname)
+
+    /*-
+     * This pair helps declare a CHOICE type. We can do:
+     *
+     *      ASN1_CHOICE(chname) = {
+     *              ... CHOICE options ...
+     *      ASN1_CHOICE_END(chname)
+     *
+     *      This will produce an ASN1_ITEM called chname_it
+     *      for a structure called chname. The structure
+     *      definition must look like this:
+     *      typedef struct {
+     *              int type;
+     *              union {
+     *                      ASN1_SOMETHING *opt1;
+     *                      ASN1_SOMEOTHER *opt2;
+     *              } value;
+     *      } chname;
+     *
+     *      the name of the selector must be 'type'.
+     *      to use an alternative selector name use the
+     *      ASN1_CHOICE_END_selector() version.
+     */
+
+#define ASN1_CHOICE(tname) \
+    static const ASN1_TEMPLATE tname##_ch_tt[]
+
+#define ASN1_CHOICE_cb(tname, cb)                                     \
+    static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0, NULL}; \
+    ASN1_CHOICE(tname)
+
+#define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname)
+
+#define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname)
+
+#define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type)
+
+#define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type)
+
+#define ASN1_CHOICE_END_selector(stname, tname, selname) \
+    ;                                                    \
+    ASN1_ITEM_start(tname)                               \
+        ASN1_ITYPE_CHOICE,                               \
+        offsetof(stname, selname),                       \
+        tname##_ch_tt,                                   \
+        sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),   \
+        NULL,                                            \
+        sizeof(stname),                                  \
+        #stname ASN1_ITEM_end(tname)
+
+#define static_ASN1_CHOICE_END_selector(stname, tname, selname) \
+    ;                                                           \
+    static_ASN1_ITEM_start(tname)                               \
+        ASN1_ITYPE_CHOICE,                                      \
+        offsetof(stname, selname),                              \
+        tname##_ch_tt,                                          \
+        sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),          \
+        NULL,                                                   \
+        sizeof(stname),                                         \
+        #stname ASN1_ITEM_end(tname)
+
+#define ASN1_CHOICE_END_cb(stname, tname, selname)     \
+    ;                                                  \
+    ASN1_ITEM_start(tname)                             \
+        ASN1_ITYPE_CHOICE,                             \
+        offsetof(stname, selname),                     \
+        tname##_ch_tt,                                 \
+        sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE), \
+        &tname##_aux,                                  \
+        sizeof(stname),                                \
+        #stname ASN1_ITEM_end(tname)
+
+    /* This helps with the template wrapper form of ASN1_ITEM */
+
+#define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) \
+    {                                                 \
+        (flags), (tag), 0,                            \
+            #name, ASN1_ITEM_ref(type)                \
+    }
+
+    /* These help with SEQUENCE or CHOICE components */
+
+    /* used to declare other types */
+
+#define ASN1_EX_TYPE(flags, tag, stname, field, type) \
+    {                                                 \
+        (flags), (tag), offsetof(stname, field),      \
+            #field, ASN1_ITEM_ref(type)               \
+    }
+
+    /* implicit and explicit helper macros */
+
+#define ASN1_IMP_EX(stname, field, type, tag, ex) \
+    ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type)
+
+#define ASN1_EXP_EX(stname, field, type, tag, ex) \
+    ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type)
+
+    /* Any defined by macros: the field used is in the table itself */
+
+#define ASN1_ADB_OBJECT(tblname)                          \
+    {                                                     \
+        ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb \
+    }
+#define ASN1_ADB_INTEGER(tblname)                         \
+    {                                                     \
+        ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb \
+    }
 
 /* Plain simple type */
-# define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type)
+#define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0, 0, stname, field, type)
 /* Embedded simple type */
-# define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED,0, stname, field, type)
+#define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED, 0, stname, field, type)
 
 /* OPTIONAL simple type */
-# define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type)
-# define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED, 0, stname, field, type)
+#define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+#define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL | ASN1_TFLG_EMBED, 0, stname, field, type)
 
 /* IMPLICIT tagged simple type */
-# define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0)
-# define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
+#define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0)
+#define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
 
 /* IMPLICIT tagged OPTIONAL simple type */
-# define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
-# define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED)
+#define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
+#define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL | ASN1_TFLG_EMBED)
 
-/* Same as above but EXPLICIT */
+    /* Same as above but EXPLICIT */
 
-# define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0)
-# define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
-# define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
-# define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED)
+#define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0)
+#define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED)
+#define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL)
+#define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL | ASN1_TFLG_EMBED)
 
 /* SEQUENCE OF type */
-# define ASN1_SEQUENCE_OF(stname, field, type) \
-                ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type)
+#define ASN1_SEQUENCE_OF(stname, field, type) \
+    ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type)
 
 /* OPTIONAL SEQUENCE OF */
-# define ASN1_SEQUENCE_OF_OPT(stname, field, type) \
-                ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+#define ASN1_SEQUENCE_OF_OPT(stname, field, type) \
+    ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL, 0, stname, field, type)
 
-/* Same as above but for SET OF */
+    /* Same as above but for SET OF */
 
-# define ASN1_SET_OF(stname, field, type) \
-                ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type)
+#define ASN1_SET_OF(stname, field, type) \
+    ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type)
 
-# define ASN1_SET_OF_OPT(stname, field, type) \
-                ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type)
+#define ASN1_SET_OF_OPT(stname, field, type) \
+    ASN1_EX_TYPE(ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL, 0, stname, field, type)
 
-/* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */
+    /* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */
 
-# define ASN1_IMP_SET_OF(stname, field, type, tag) \
-                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
+#define ASN1_IMP_SET_OF(stname, field, type, tag) \
+    ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
 
-# define ASN1_EXP_SET_OF(stname, field, type, tag) \
-                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
+#define ASN1_EXP_SET_OF(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF)
 
-# define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \
-                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
+#define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \
+    ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL)
 
-# define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \
-                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL)
+#define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL)
 
-# define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \
-                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
+#define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \
+    ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
 
-# define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \
-                        ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
+#define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \
+    ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL)
 
-# define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \
-                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
+#define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF)
 
-# define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \
-                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL)
+#define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL)
 
 /* EXPLICIT using indefinite length constructed form */
-# define ASN1_NDEF_EXP(stname, field, type, tag) \
-                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF)
+#define ASN1_NDEF_EXP(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF)
 
 /* EXPLICIT OPTIONAL using indefinite length constructed form */
-# define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \
-                        ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF)
-
-/* Macros for the ASN1_ADB structure */
-
-# define ASN1_ADB(name) \
-        static const ASN1_ADB_TABLE name##_adbtbl[]
-
-# define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \
-        ;\
-        static const ASN1_ITEM *name##_adb(void) \
-        { \
-        static const ASN1_ADB internal_adb = \
-                {\
-                flags,\
-                offsetof(name, field),\
-                adb_cb,\
-                name##_adbtbl,\
-                sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\
-                def,\
-                none\
-                }; \
-                return (const ASN1_ITEM *) &internal_adb; \
-        } \
-        void dummy_function(void)
-
-# define ADB_ENTRY(val, template) {val, template}
-
-# define ASN1_ADB_TEMPLATE(name) \
-        static const ASN1_TEMPLATE name##_tt
-
-/*
- * This is the ASN1 template structure that defines a wrapper round the
- * actual type. It determines the actual position of the field in the value
- * structure, various flags such as OPTIONAL and the field name.
- */
-
-struct ASN1_TEMPLATE_st {
-    unsigned long flags;        /* Various flags */
-    long tag;                   /* tag, not used if no tagging */
-    unsigned long offset;       /* Offset of this field in structure */
-    const char *field_name;     /* Field name */
-    ASN1_ITEM_EXP *item;        /* Relevant ASN1_ITEM or ASN1_ADB */
-};
-
-/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
-
-# define ASN1_TEMPLATE_item(t) (t->item_ptr)
-# define ASN1_TEMPLATE_adb(t) (t->item_ptr)
-
-typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
-typedef struct ASN1_ADB_st ASN1_ADB;
-
-struct ASN1_ADB_st {
-    unsigned long flags;        /* Various flags */
-    unsigned long offset;       /* Offset of selector field */
-    int (*adb_cb)(long *psel);  /* Application callback */
-    const ASN1_ADB_TABLE *tbl;  /* Table of possible types */
-    long tblcount;              /* Number of entries in tbl */
-    const ASN1_TEMPLATE *default_tt; /* Type to use if no match */
-    const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */
-};
-
-struct ASN1_ADB_TABLE_st {
-    long value;                 /* NID for an object or value for an int */
-    const ASN1_TEMPLATE tt;     /* item for this value */
-};
+#define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \
+    ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL | ASN1_TFLG_NDEF)
+
+    /* Macros for the ASN1_ADB structure */
+
+#define ASN1_ADB(name) \
+    static const ASN1_ADB_TABLE name##_adbtbl[]
+
+#define ASN1_ADB_END(name, flags, field, adb_cb, def, none)     \
+    ;                                                           \
+    static const ASN1_ITEM* name##_adb(void)                    \
+    {                                                           \
+        static const ASN1_ADB internal_adb =                    \
+            {                                                   \
+                flags,                                          \
+                offsetof(name, field),                          \
+                adb_cb,                                         \
+                name##_adbtbl,                                  \
+                sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE), \
+                def,                                            \
+                none};                                          \
+        return (const ASN1_ITEM*)&internal_adb;                 \
+    }                                                           \
+    void dummy_function(void)
+
+#define ADB_ENTRY(val, template) \
+    {                            \
+        val, template            \
+    }
+
+#define ASN1_ADB_TEMPLATE(name) \
+    static const ASN1_TEMPLATE name##_tt
+
+    /*
+     * This is the ASN1 template structure that defines a wrapper round the
+     * actual type. It determines the actual position of the field in the value
+     * structure, various flags such as OPTIONAL and the field name.
+     */
+
+    struct ASN1_TEMPLATE_st
+    {
+        unsigned long flags;    /* Various flags */
+        long tag;               /* tag, not used if no tagging */
+        unsigned long offset;   /* Offset of this field in structure */
+        const char* field_name; /* Field name */
+        ASN1_ITEM_EXP* item;    /* Relevant ASN1_ITEM or ASN1_ADB */
+    };
+
+    /* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */
+
+#define ASN1_TEMPLATE_item(t) (t->item_ptr)
+#define ASN1_TEMPLATE_adb(t) (t->item_ptr)
+
+    typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE;
+    typedef struct ASN1_ADB_st ASN1_ADB;
+
+    struct ASN1_ADB_st
+    {
+        unsigned long flags;             /* Various flags */
+        unsigned long offset;            /* Offset of selector field */
+        int (*adb_cb)(long* psel);       /* Application callback */
+        const ASN1_ADB_TABLE* tbl;       /* Table of possible types */
+        long tblcount;                   /* Number of entries in tbl */
+        const ASN1_TEMPLATE* default_tt; /* Type to use if no match */
+        const ASN1_TEMPLATE* null_tt;    /* Type to use if selector is NULL */
+    };
+
+    struct ASN1_ADB_TABLE_st
+    {
+        long value;             /* NID for an object or value for an int */
+        const ASN1_TEMPLATE tt; /* item for this value */
+    };
 
 /* template flags */
 
 /* Field is optional */
-# define ASN1_TFLG_OPTIONAL      (0x1)
+#define ASN1_TFLG_OPTIONAL (0x1)
 
 /* Field is a SET OF */
-# define ASN1_TFLG_SET_OF        (0x1 << 1)
+#define ASN1_TFLG_SET_OF (0x1 << 1)
 
 /* Field is a SEQUENCE OF */
-# define ASN1_TFLG_SEQUENCE_OF   (0x2 << 1)
+#define ASN1_TFLG_SEQUENCE_OF (0x2 << 1)
 
 /*
  * Special case: this refers to a SET OF that will be sorted into DER order
  * when encoded *and* the corresponding STACK will be modified to match the
  * new order.
  */
-# define ASN1_TFLG_SET_ORDER     (0x3 << 1)
+#define ASN1_TFLG_SET_ORDER (0x3 << 1)
 
 /* Mask for SET OF or SEQUENCE OF */
-# define ASN1_TFLG_SK_MASK       (0x3 << 1)
+#define ASN1_TFLG_SK_MASK (0x3 << 1)
 
 /*
  * These flags mean the tag should be taken from the tag field. If EXPLICIT
@@ -544,18 +545,18 @@ struct ASN1_ADB_TABLE_st {
  */
 
 /* IMPLICIT tagging */
-# define ASN1_TFLG_IMPTAG        (0x1 << 3)
+#define ASN1_TFLG_IMPTAG (0x1 << 3)
 
 /* EXPLICIT tagging, inner tag from underlying type */
-# define ASN1_TFLG_EXPTAG        (0x2 << 3)
+#define ASN1_TFLG_EXPTAG (0x2 << 3)
 
-# define ASN1_TFLG_TAG_MASK      (0x3 << 3)
+#define ASN1_TFLG_TAG_MASK (0x3 << 3)
 
 /* context specific IMPLICIT */
-# define ASN1_TFLG_IMPLICIT      (ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT)
+#define ASN1_TFLG_IMPLICIT (ASN1_TFLG_IMPTAG | ASN1_TFLG_CONTEXT)
 
 /* context specific EXPLICIT */
-# define ASN1_TFLG_EXPLICIT      (ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT)
+#define ASN1_TFLG_EXPLICIT (ASN1_TFLG_EXPTAG | ASN1_TFLG_CONTEXT)
 
 /*
  * If tagging is in force these determine the type of tag to use. Otherwise
@@ -564,383 +565,363 @@ struct ASN1_ADB_TABLE_st {
  */
 
 /* Universal tag */
-# define ASN1_TFLG_UNIVERSAL     (0x0<<6)
+#define ASN1_TFLG_UNIVERSAL (0x0 << 6)
 /* Application tag */
-# define ASN1_TFLG_APPLICATION   (0x1<<6)
+#define ASN1_TFLG_APPLICATION (0x1 << 6)
 /* Context specific tag */
-# define ASN1_TFLG_CONTEXT       (0x2<<6)
+#define ASN1_TFLG_CONTEXT (0x2 << 6)
 /* Private tag */
-# define ASN1_TFLG_PRIVATE       (0x3<<6)
+#define ASN1_TFLG_PRIVATE (0x3 << 6)
 
-# define ASN1_TFLG_TAG_CLASS     (0x3<<6)
+#define ASN1_TFLG_TAG_CLASS (0x3 << 6)
 
-/*
- * These are for ANY DEFINED BY type. In this case the 'item' field points to
- * an ASN1_ADB structure which contains a table of values to decode the
- * relevant type
- */
+    /*
+     * These are for ANY DEFINED BY type. In this case the 'item' field points to
+     * an ASN1_ADB structure which contains a table of values to decode the
+     * relevant type
+     */
 
-# define ASN1_TFLG_ADB_MASK      (0x3<<8)
+#define ASN1_TFLG_ADB_MASK (0x3 << 8)
 
-# define ASN1_TFLG_ADB_OID       (0x1<<8)
+#define ASN1_TFLG_ADB_OID (0x1 << 8)
 
-# define ASN1_TFLG_ADB_INT       (0x1<<9)
+#define ASN1_TFLG_ADB_INT (0x1 << 9)
 
-/*
- * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes
- * indefinite length constructed encoding to be used if required.
- */
+    /*
+     * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes
+     * indefinite length constructed encoding to be used if required.
+     */
 
-# define ASN1_TFLG_NDEF          (0x1<<11)
+#define ASN1_TFLG_NDEF (0x1 << 11)
 
 /* Field is embedded and not a pointer */
-# define ASN1_TFLG_EMBED         (0x1 << 12)
-
-/* This is the actual ASN1 item itself */
-
-struct ASN1_ITEM_st {
-    char itype;                 /* The item type, primitive, SEQUENCE, CHOICE
-                                 * or extern */
-    long utype;                 /* underlying type */
-    const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains
-                                     * the contents */
-    long tcount;                /* Number of templates if SEQUENCE or CHOICE */
-    const void *funcs;          /* further data and type-specific functions */
-    /* funcs can be ASN1_PRIMITIVE_FUNCS*, ASN1_EXTERN_FUNCS*, or ASN1_AUX* */
-    long size;                  /* Structure size (usually) */
-    const char *sname;          /* Structure name */
-};
-
-/*
- * Cache for ASN1 tag and length, so we don't keep re-reading it for things
- * like CHOICE
- */
-
-struct ASN1_TLC_st {
-    char valid;                 /* Values below are valid */
-    int ret;                    /* return value */
-    long plen;                  /* length */
-    int ptag;                   /* class value */
-    int pclass;                 /* class value */
-    int hdrlen;                 /* header length */
-};
-
-/* Typedefs for ASN1 function pointers */
-typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
-                        const ASN1_ITEM *it, int tag, int aclass, char opt,
-                        ASN1_TLC *ctx);
-
-typedef int ASN1_ex_d2i_ex(ASN1_VALUE **pval, const unsigned char **in, long len,
-                           const ASN1_ITEM *it, int tag, int aclass, char opt,
-                           ASN1_TLC *ctx, OSSL_LIB_CTX *libctx,
-                           const char *propq);
-typedef int ASN1_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
-                        const ASN1_ITEM *it, int tag, int aclass);
-typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
-typedef int ASN1_ex_new_ex_func(ASN1_VALUE **pval, const ASN1_ITEM *it,
-                                OSSL_LIB_CTX *libctx, const char *propq);
-typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it);
-
-typedef int ASN1_ex_print_func(BIO *out, const ASN1_VALUE **pval,
-                               int indent, const char *fname,
-                               const ASN1_PCTX *pctx);
-
-typedef int ASN1_primitive_i2c(const ASN1_VALUE **pval, unsigned char *cont,
-                               int *putype, const ASN1_ITEM *it);
-typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont,
-                               int len, int utype, char *free_cont,
-                               const ASN1_ITEM *it);
-typedef int ASN1_primitive_print(BIO *out, const ASN1_VALUE **pval,
-                                 const ASN1_ITEM *it, int indent,
-                                 const ASN1_PCTX *pctx);
-
-typedef struct ASN1_EXTERN_FUNCS_st {
-    void *app_data;
-    ASN1_ex_new_func *asn1_ex_new;
-    ASN1_ex_free_func *asn1_ex_free;
-    ASN1_ex_free_func *asn1_ex_clear;
-    ASN1_ex_d2i *asn1_ex_d2i;
-    ASN1_ex_i2d *asn1_ex_i2d;
-    ASN1_ex_print_func *asn1_ex_print;
-    ASN1_ex_new_ex_func *asn1_ex_new_ex;
-    ASN1_ex_d2i_ex *asn1_ex_d2i_ex;
-} ASN1_EXTERN_FUNCS;
-
-typedef struct ASN1_PRIMITIVE_FUNCS_st {
-    void *app_data;
-    unsigned long flags;
-    ASN1_ex_new_func *prim_new;
-    ASN1_ex_free_func *prim_free;
-    ASN1_ex_free_func *prim_clear;
-    ASN1_primitive_c2i *prim_c2i;
-    ASN1_primitive_i2c *prim_i2c;
-    ASN1_primitive_print *prim_print;
-} ASN1_PRIMITIVE_FUNCS;
-
-/*
- * This is the ASN1_AUX structure: it handles various miscellaneous
- * requirements. For example the use of reference counts and an informational
- * callback. The "informational callback" is called at various points during
- * the ASN1 encoding and decoding. It can be used to provide minor
- * customisation of the structures used. This is most useful where the
- * supplied routines *almost* do the right thing but need some extra help at
- * a few points. If the callback returns zero then it is assumed a fatal
- * error has occurred and the main operation should be abandoned. If major
- * changes in the default behaviour are required then an external type is
- * more appropriate.
- * For the operations ASN1_OP_I2D_PRE, ASN1_OP_I2D_POST, ASN1_OP_PRINT_PRE, and
- * ASN1_OP_PRINT_POST, meanwhile a variant of the callback with const parameter
- * 'in' is provided to make clear statically that its input is not modified. If
- * and only if this variant is in use the flag ASN1_AFLG_CONST_CB must be set.
- */
-
-typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it,
-                        void *exarg);
-typedef int ASN1_aux_const_cb(int operation, const ASN1_VALUE **in,
-                              const ASN1_ITEM *it, void *exarg);
-
-typedef struct ASN1_AUX_st {
-    void *app_data;
-    int flags;
-    int ref_offset;             /* Offset of reference value */
-    int ref_lock;               /* Offset of lock value */
-    ASN1_aux_cb *asn1_cb;
-    int enc_offset;             /* Offset of ASN1_ENCODING structure */
-    ASN1_aux_const_cb *asn1_const_cb; /* for ASN1_OP_I2D_ and ASN1_OP_PRINT_ */
-} ASN1_AUX;
-
-/* For print related callbacks exarg points to this structure */
-typedef struct ASN1_PRINT_ARG_st {
-    BIO *out;
-    int indent;
-    const ASN1_PCTX *pctx;
-} ASN1_PRINT_ARG;
-
-/* For streaming related callbacks exarg points to this structure */
-typedef struct ASN1_STREAM_ARG_st {
-    /* BIO to stream through */
-    BIO *out;
-    /* BIO with filters appended */
-    BIO *ndef_bio;
-    /* Streaming I/O boundary */
-    unsigned char **boundary;
-} ASN1_STREAM_ARG;
+#define ASN1_TFLG_EMBED (0x1 << 12)
+
+    /* This is the actual ASN1 item itself */
+
+    struct ASN1_ITEM_st
+    {
+        char itype;                     /* The item type, primitive, SEQUENCE, CHOICE
+                                         * or extern */
+        long utype;                     /* underlying type */
+        const ASN1_TEMPLATE* templates; /* If SEQUENCE or CHOICE this contains
+                                         * the contents */
+        long tcount;                    /* Number of templates if SEQUENCE or CHOICE */
+        const void* funcs;              /* further data and type-specific functions */
+        /* funcs can be ASN1_PRIMITIVE_FUNCS*, ASN1_EXTERN_FUNCS*, or ASN1_AUX* */
+        long size;         /* Structure size (usually) */
+        const char* sname; /* Structure name */
+    };
+
+    /*
+     * Cache for ASN1 tag and length, so we don't keep re-reading it for things
+     * like CHOICE
+     */
+
+    struct ASN1_TLC_st
+    {
+        char valid; /* Values below are valid */
+        int ret;    /* return value */
+        long plen;  /* length */
+        int ptag;   /* class value */
+        int pclass; /* class value */
+        int hdrlen; /* header length */
+    };
+
+    /* Typedefs for ASN1 function pointers */
+    typedef int ASN1_ex_d2i(ASN1_VALUE** pval, const unsigned char** in, long len, const ASN1_ITEM* it, int tag, int aclass, char opt, ASN1_TLC* ctx);
+
+    typedef int ASN1_ex_d2i_ex(ASN1_VALUE** pval, const unsigned char** in, long len, const ASN1_ITEM* it, int tag, int aclass, char opt, ASN1_TLC* ctx, OSSL_LIB_CTX* libctx, const char* propq);
+    typedef int ASN1_ex_i2d(const ASN1_VALUE** pval, unsigned char** out, const ASN1_ITEM* it, int tag, int aclass);
+    typedef int ASN1_ex_new_func(ASN1_VALUE** pval, const ASN1_ITEM* it);
+    typedef int ASN1_ex_new_ex_func(ASN1_VALUE** pval, const ASN1_ITEM* it, OSSL_LIB_CTX* libctx, const char* propq);
+    typedef void ASN1_ex_free_func(ASN1_VALUE** pval, const ASN1_ITEM* it);
+
+    typedef int ASN1_ex_print_func(BIO* out, const ASN1_VALUE** pval, int indent, const char* fname, const ASN1_PCTX* pctx);
+
+    typedef int ASN1_primitive_i2c(const ASN1_VALUE** pval, unsigned char* cont, int* putype, const ASN1_ITEM* it);
+    typedef int ASN1_primitive_c2i(ASN1_VALUE** pval, const unsigned char* cont, int len, int utype, char* free_cont, const ASN1_ITEM* it);
+    typedef int ASN1_primitive_print(BIO* out, const ASN1_VALUE** pval, const ASN1_ITEM* it, int indent, const ASN1_PCTX* pctx);
+
+    typedef struct ASN1_EXTERN_FUNCS_st
+    {
+        void* app_data;
+        ASN1_ex_new_func* asn1_ex_new;
+        ASN1_ex_free_func* asn1_ex_free;
+        ASN1_ex_free_func* asn1_ex_clear;
+        ASN1_ex_d2i* asn1_ex_d2i;
+        ASN1_ex_i2d* asn1_ex_i2d;
+        ASN1_ex_print_func* asn1_ex_print;
+        ASN1_ex_new_ex_func* asn1_ex_new_ex;
+        ASN1_ex_d2i_ex* asn1_ex_d2i_ex;
+    } ASN1_EXTERN_FUNCS;
+
+    typedef struct ASN1_PRIMITIVE_FUNCS_st
+    {
+        void* app_data;
+        unsigned long flags;
+        ASN1_ex_new_func* prim_new;
+        ASN1_ex_free_func* prim_free;
+        ASN1_ex_free_func* prim_clear;
+        ASN1_primitive_c2i* prim_c2i;
+        ASN1_primitive_i2c* prim_i2c;
+        ASN1_primitive_print* prim_print;
+    } ASN1_PRIMITIVE_FUNCS;
+
+    /*
+     * This is the ASN1_AUX structure: it handles various miscellaneous
+     * requirements. For example the use of reference counts and an informational
+     * callback. The "informational callback" is called at various points during
+     * the ASN1 encoding and decoding. It can be used to provide minor
+     * customisation of the structures used. This is most useful where the
+     * supplied routines *almost* do the right thing but need some extra help at
+     * a few points. If the callback returns zero then it is assumed a fatal
+     * error has occurred and the main operation should be abandoned. If major
+     * changes in the default behaviour are required then an external type is
+     * more appropriate.
+     * For the operations ASN1_OP_I2D_PRE, ASN1_OP_I2D_POST, ASN1_OP_PRINT_PRE, and
+     * ASN1_OP_PRINT_POST, meanwhile a variant of the callback with const parameter
+     * 'in' is provided to make clear statically that its input is not modified. If
+     * and only if this variant is in use the flag ASN1_AFLG_CONST_CB must be set.
+     */
+
+    typedef int ASN1_aux_cb(int operation, ASN1_VALUE** in, const ASN1_ITEM* it, void* exarg);
+    typedef int ASN1_aux_const_cb(int operation, const ASN1_VALUE** in, const ASN1_ITEM* it, void* exarg);
+
+    typedef struct ASN1_AUX_st
+    {
+        void* app_data;
+        int flags;
+        int ref_offset; /* Offset of reference value */
+        int ref_lock;   /* Offset of lock value */
+        ASN1_aux_cb* asn1_cb;
+        int enc_offset;                   /* Offset of ASN1_ENCODING structure */
+        ASN1_aux_const_cb* asn1_const_cb; /* for ASN1_OP_I2D_ and ASN1_OP_PRINT_ */
+    } ASN1_AUX;
+
+    /* For print related callbacks exarg points to this structure */
+    typedef struct ASN1_PRINT_ARG_st
+    {
+        BIO* out;
+        int indent;
+        const ASN1_PCTX* pctx;
+    } ASN1_PRINT_ARG;
+
+    /* For streaming related callbacks exarg points to this structure */
+    typedef struct ASN1_STREAM_ARG_st
+    {
+        /* BIO to stream through */
+        BIO* out;
+        /* BIO with filters appended */
+        BIO* ndef_bio;
+        /* Streaming I/O boundary */
+        unsigned char** boundary;
+    } ASN1_STREAM_ARG;
 
 /* Flags in ASN1_AUX */
 
 /* Use a reference count */
-# define ASN1_AFLG_REFCOUNT      1
+#define ASN1_AFLG_REFCOUNT 1
 /* Save the encoding of structure (useful for signatures) */
-# define ASN1_AFLG_ENCODING      2
+#define ASN1_AFLG_ENCODING 2
 /* The Sequence length is invalid */
-# define ASN1_AFLG_BROKEN        4
+#define ASN1_AFLG_BROKEN 4
 /* Use the new asn1_const_cb */
-# define ASN1_AFLG_CONST_CB      8
-
-/* operation values for asn1_cb */
-
-# define ASN1_OP_NEW_PRE         0
-# define ASN1_OP_NEW_POST        1
-# define ASN1_OP_FREE_PRE        2
-# define ASN1_OP_FREE_POST       3
-# define ASN1_OP_D2I_PRE         4
-# define ASN1_OP_D2I_POST        5
-# define ASN1_OP_I2D_PRE         6
-# define ASN1_OP_I2D_POST        7
-# define ASN1_OP_PRINT_PRE       8
-# define ASN1_OP_PRINT_POST      9
-# define ASN1_OP_STREAM_PRE      10
-# define ASN1_OP_STREAM_POST     11
-# define ASN1_OP_DETACHED_PRE    12
-# define ASN1_OP_DETACHED_POST   13
-# define ASN1_OP_DUP_PRE         14
-# define ASN1_OP_DUP_POST        15
-# define ASN1_OP_GET0_LIBCTX     16
-# define ASN1_OP_GET0_PROPQ      17
+#define ASN1_AFLG_CONST_CB 8
+
+    /* operation values for asn1_cb */
+
+#define ASN1_OP_NEW_PRE 0
+#define ASN1_OP_NEW_POST 1
+#define ASN1_OP_FREE_PRE 2
+#define ASN1_OP_FREE_POST 3
+#define ASN1_OP_D2I_PRE 4
+#define ASN1_OP_D2I_POST 5
+#define ASN1_OP_I2D_PRE 6
+#define ASN1_OP_I2D_POST 7
+#define ASN1_OP_PRINT_PRE 8
+#define ASN1_OP_PRINT_POST 9
+#define ASN1_OP_STREAM_PRE 10
+#define ASN1_OP_STREAM_POST 11
+#define ASN1_OP_DETACHED_PRE 12
+#define ASN1_OP_DETACHED_POST 13
+#define ASN1_OP_DUP_PRE 14
+#define ASN1_OP_DUP_POST 15
+#define ASN1_OP_GET0_LIBCTX 16
+#define ASN1_OP_GET0_PROPQ 17
 
 /* Macro to implement a primitive type */
-# define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
-# define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
-                                ASN1_ITEM_start(itname) \
-                                        ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \
-                                ASN1_ITEM_end(itname)
+#define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0)
+#define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \
+    ASN1_ITEM_start(itname)                       \
+        ASN1_ITYPE_PRIMITIVE,                     \
+        V_##vname, NULL, 0, NULL, ex, #itname ASN1_ITEM_end(itname)
 
 /* Macro to implement a multi string type */
-# define IMPLEMENT_ASN1_MSTRING(itname, mask) \
-                                ASN1_ITEM_start(itname) \
-                                        ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \
-                                ASN1_ITEM_end(itname)
-
-# define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
-        ASN1_ITEM_start(sname) \
-                ASN1_ITYPE_EXTERN, \
-                tag, \
-                NULL, \
-                0, \
-                &fptrs, \
-                0, \
-                #sname \
-        ASN1_ITEM_end(sname)
-
-/* Macro to implement standard functions in terms of ASN1_ITEM structures */
-
-# define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
-
-# define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
-
-# define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
-                        IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
-
-# define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \
-                IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname)
-
-# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \
-                IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname)
-
-# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \
-        pre stname *fname##_new(void) \
-        { \
-                return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
-        } \
-        pre void fname##_free(stname *a) \
-        { \
-                ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
-        }
-
-# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
-        stname *fname##_new(void) \
-        { \
-                return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \
-        } \
-        void fname##_free(stname *a) \
-        { \
-                ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \
-        }
-
-# define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \
-        IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
+#define IMPLEMENT_ASN1_MSTRING(itname, mask) \
+    ASN1_ITEM_start(itname)                  \
+        ASN1_ITYPE_MSTRING,                  \
+        mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname ASN1_ITEM_end(itname)
+
+#define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \
+    ASN1_ITEM_start(sname)                       \
+        ASN1_ITYPE_EXTERN,                       \
+        tag,                                     \
+        NULL,                                    \
+        0,                                       \
+        &fptrs,                                  \
+        0,                                       \
+        #sname ASN1_ITEM_end(sname)
+
+    /* Macro to implement standard functions in terms of ASN1_ITEM structures */
+
+#define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname)
+
+#define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname)
+
+#define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \
+    IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname)
+
+#define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \
+    IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname)
+
+#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \
+    IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname)
+
+#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \
+    pre stname* fname##_new(void)                                         \
+    {                                                                     \
+        return (stname*)ASN1_item_new(ASN1_ITEM_rptr(itname));            \
+    }                                                                     \
+    pre void fname##_free(stname* a)                                      \
+    {                                                                     \
+        ASN1_item_free((ASN1_VALUE*)a, ASN1_ITEM_rptr(itname));           \
+    }
+
+#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \
+    stname* fname##_new(void)                                       \
+    {                                                               \
+        return (stname*)ASN1_item_new(ASN1_ITEM_rptr(itname));      \
+    }                                                               \
+    void fname##_free(stname* a)                                    \
+    {                                                               \
+        ASN1_item_free((ASN1_VALUE*)a, ASN1_ITEM_rptr(itname));     \
+    }
+
+#define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname)    \
+    IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
         IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname)
 
-# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \
-        stname *d2i_##fname(stname **a, const unsigned char **in, long len) \
-        { \
-                return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\
-        } \
-        int i2d_##fname(const stname *a, unsigned char **out) \
-        { \
-                return ASN1_item_i2d((const ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\
-        }
-
-# define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \
-        int i2d_##stname##_NDEF(const stname *a, unsigned char **out) \
-        { \
-                return ASN1_item_ndef_i2d((const ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\
-        }
-
-# define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname) \
-        static stname *d2i_##stname(stname **a, \
-                                   const unsigned char **in, long len) \
-        { \
-                return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \
-                                               ASN1_ITEM_rptr(stname)); \
-        } \
-        static int i2d_##stname(const stname *a, unsigned char **out) \
-        { \
-                return ASN1_item_i2d((const ASN1_VALUE *)a, out, \
-                                     ASN1_ITEM_rptr(stname)); \
-        }
-
-# define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \
-        stname * stname##_dup(const stname *x) \
-        { \
+#define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname)                     \
+    stname* d2i_##fname(stname** a, const unsigned char** in, long len)                  \
+    {                                                                                    \
+        return (stname*)ASN1_item_d2i((ASN1_VALUE**)a, in, len, ASN1_ITEM_rptr(itname)); \
+    }                                                                                    \
+    int i2d_##fname(const stname* a, unsigned char** out)                                \
+    {                                                                                    \
+        return ASN1_item_i2d((const ASN1_VALUE*)a, out, ASN1_ITEM_rptr(itname));         \
+    }
+
+#define IMPLEMENT_ASN1_NDEF_FUNCTION(stname)                                          \
+    int i2d_##stname##_NDEF(const stname* a, unsigned char** out)                     \
+    {                                                                                 \
+        return ASN1_item_ndef_i2d((const ASN1_VALUE*)a, out, ASN1_ITEM_rptr(stname)); \
+    }
+
+#define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname)                                   \
+    static stname* d2i_##stname(stname** a, const unsigned char** in, long len)          \
+    {                                                                                    \
+        return (stname*)ASN1_item_d2i((ASN1_VALUE**)a, in, len, ASN1_ITEM_rptr(stname)); \
+    }                                                                                    \
+    static int i2d_##stname(const stname* a, unsigned char** out)                        \
+    {                                                                                    \
+        return ASN1_item_i2d((const ASN1_VALUE*)a, out, ASN1_ITEM_rptr(stname));         \
+    }
+
+#define IMPLEMENT_ASN1_DUP_FUNCTION(stname)              \
+    stname* stname##_dup(const stname* x)                \
+    {                                                    \
         return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \
-        }
-
-# define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \
-        IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname)
-
-# define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \
-        int fname##_print_ctx(BIO *out, const stname *x, int indent, \
-                                                const ASN1_PCTX *pctx) \
-        { \
-                return ASN1_item_print(out, (const ASN1_VALUE *)x, indent, \
-                        ASN1_ITEM_rptr(itname), pctx); \
-        }
-
-/* external definitions for primitive types */
-
-DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
-DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
-DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
-DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
-DECLARE_ASN1_ITEM(CBIGNUM)
-DECLARE_ASN1_ITEM(BIGNUM)
-DECLARE_ASN1_ITEM(INT32)
-DECLARE_ASN1_ITEM(ZINT32)
-DECLARE_ASN1_ITEM(UINT32)
-DECLARE_ASN1_ITEM(ZUINT32)
-DECLARE_ASN1_ITEM(INT64)
-DECLARE_ASN1_ITEM(ZINT64)
-DECLARE_ASN1_ITEM(UINT64)
-DECLARE_ASN1_ITEM(ZUINT64)
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-/*
- * LONG and ZLONG are strongly discouraged for use as stored data, as the
- * underlying C type (long) differs in size depending on the architecture.
- * They are designed with 32-bit longs in mind.
- */
-DECLARE_ASN1_ITEM(LONG)
-DECLARE_ASN1_ITEM(ZLONG)
-# endif
+    }
+
+#define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \
+    IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname)
+
+#define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname)                               \
+    int fname##_print_ctx(BIO* out, const stname* x, int indent, const ASN1_PCTX* pctx)          \
+    {                                                                                            \
+        return ASN1_item_print(out, (const ASN1_VALUE*)x, indent, ASN1_ITEM_rptr(itname), pctx); \
+    }
+
+    /* external definitions for primitive types */
+
+    DECLARE_ASN1_ITEM(ASN1_BOOLEAN)
+    DECLARE_ASN1_ITEM(ASN1_TBOOLEAN)
+    DECLARE_ASN1_ITEM(ASN1_FBOOLEAN)
+    DECLARE_ASN1_ITEM(ASN1_SEQUENCE)
+    DECLARE_ASN1_ITEM(CBIGNUM)
+    DECLARE_ASN1_ITEM(BIGNUM)
+    DECLARE_ASN1_ITEM(INT32)
+    DECLARE_ASN1_ITEM(ZINT32)
+    DECLARE_ASN1_ITEM(UINT32)
+    DECLARE_ASN1_ITEM(ZUINT32)
+    DECLARE_ASN1_ITEM(INT64)
+    DECLARE_ASN1_ITEM(ZINT64)
+    DECLARE_ASN1_ITEM(UINT64)
+    DECLARE_ASN1_ITEM(ZUINT64)
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /*
+     * LONG and ZLONG are strongly discouraged for use as stored data, as the
+     * underlying C type (long) differs in size depending on the architecture.
+     * They are designed with 32-bit longs in mind.
+     */
+    DECLARE_ASN1_ITEM(LONG)
+    DECLARE_ASN1_ITEM(ZLONG)
+#endif
 
-SKM_DEFINE_STACK_OF_INTERNAL(ASN1_VALUE, ASN1_VALUE, ASN1_VALUE)
+    SKM_DEFINE_STACK_OF_INTERNAL(ASN1_VALUE, ASN1_VALUE, ASN1_VALUE)
 #define sk_ASN1_VALUE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_VALUE_sk_type(sk))
-#define sk_ASN1_VALUE_value(sk, idx) ((ASN1_VALUE *)OPENSSL_sk_value(ossl_check_const_ASN1_VALUE_sk_type(sk), (idx)))
-#define sk_ASN1_VALUE_new(cmp) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new(ossl_check_ASN1_VALUE_compfunc_type(cmp)))
-#define sk_ASN1_VALUE_new_null() ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new_null())
-#define sk_ASN1_VALUE_new_reserve(cmp, n) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_VALUE_compfunc_type(cmp), (n)))
+#define sk_ASN1_VALUE_value(sk, idx) ((ASN1_VALUE*)OPENSSL_sk_value(ossl_check_const_ASN1_VALUE_sk_type(sk), (idx)))
+#define sk_ASN1_VALUE_new(cmp) ((STACK_OF(ASN1_VALUE)*)OPENSSL_sk_new(ossl_check_ASN1_VALUE_compfunc_type(cmp)))
+#define sk_ASN1_VALUE_new_null() ((STACK_OF(ASN1_VALUE)*)OPENSSL_sk_new_null())
+#define sk_ASN1_VALUE_new_reserve(cmp, n) ((STACK_OF(ASN1_VALUE)*)OPENSSL_sk_new_reserve(ossl_check_ASN1_VALUE_compfunc_type(cmp), (n)))
 #define sk_ASN1_VALUE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_VALUE_sk_type(sk), (n))
 #define sk_ASN1_VALUE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_VALUE_sk_type(sk))
 #define sk_ASN1_VALUE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_VALUE_sk_type(sk))
-#define sk_ASN1_VALUE_delete(sk, i) ((ASN1_VALUE *)OPENSSL_sk_delete(ossl_check_ASN1_VALUE_sk_type(sk), (i)))
-#define sk_ASN1_VALUE_delete_ptr(sk, ptr) ((ASN1_VALUE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr)))
+#define sk_ASN1_VALUE_delete(sk, i) ((ASN1_VALUE*)OPENSSL_sk_delete(ossl_check_ASN1_VALUE_sk_type(sk), (i)))
+#define sk_ASN1_VALUE_delete_ptr(sk, ptr) ((ASN1_VALUE*)OPENSSL_sk_delete_ptr(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr)))
 #define sk_ASN1_VALUE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
 #define sk_ASN1_VALUE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
-#define sk_ASN1_VALUE_pop(sk) ((ASN1_VALUE *)OPENSSL_sk_pop(ossl_check_ASN1_VALUE_sk_type(sk)))
-#define sk_ASN1_VALUE_shift(sk) ((ASN1_VALUE *)OPENSSL_sk_shift(ossl_check_ASN1_VALUE_sk_type(sk)))
-#define sk_ASN1_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_VALUE_sk_type(sk),ossl_check_ASN1_VALUE_freefunc_type(freefunc))
+#define sk_ASN1_VALUE_pop(sk) ((ASN1_VALUE*)OPENSSL_sk_pop(ossl_check_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_shift(sk) ((ASN1_VALUE*)OPENSSL_sk_shift(ossl_check_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_freefunc_type(freefunc))
 #define sk_ASN1_VALUE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr), (idx))
-#define sk_ASN1_VALUE_set(sk, idx, ptr) ((ASN1_VALUE *)OPENSSL_sk_set(ossl_check_ASN1_VALUE_sk_type(sk), (idx), ossl_check_ASN1_VALUE_type(ptr)))
+#define sk_ASN1_VALUE_set(sk, idx, ptr) ((ASN1_VALUE*)OPENSSL_sk_set(ossl_check_ASN1_VALUE_sk_type(sk), (idx), ossl_check_ASN1_VALUE_type(ptr)))
 #define sk_ASN1_VALUE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
 #define sk_ASN1_VALUE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr))
 #define sk_ASN1_VALUE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_type(ptr), pnum)
 #define sk_ASN1_VALUE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_VALUE_sk_type(sk))
 #define sk_ASN1_VALUE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_VALUE_sk_type(sk))
-#define sk_ASN1_VALUE_dup(sk) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_VALUE_sk_type(sk)))
-#define sk_ASN1_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_VALUE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_copyfunc_type(copyfunc), ossl_check_ASN1_VALUE_freefunc_type(freefunc)))
+#define sk_ASN1_VALUE_dup(sk) ((STACK_OF(ASN1_VALUE)*)OPENSSL_sk_dup(ossl_check_const_ASN1_VALUE_sk_type(sk)))
+#define sk_ASN1_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_VALUE)*)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_copyfunc_type(copyfunc), ossl_check_ASN1_VALUE_freefunc_type(freefunc)))
 #define sk_ASN1_VALUE_set_cmp_func(sk, cmp) ((sk_ASN1_VALUE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_VALUE_sk_type(sk), ossl_check_ASN1_VALUE_compfunc_type(cmp)))
 
+    /* Functions used internally by the ASN1 code */
 
+    int ASN1_item_ex_new(ASN1_VALUE** pval, const ASN1_ITEM* it);
+    void ASN1_item_ex_free(ASN1_VALUE** pval, const ASN1_ITEM* it);
 
-/* Functions used internally by the ASN1 code */
-
-int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
-void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it);
-
-int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len,
-                     const ASN1_ITEM *it, int tag, int aclass, char opt,
-                     ASN1_TLC *ctx);
+    int ASN1_item_ex_d2i(ASN1_VALUE** pval, const unsigned char** in, long len, const ASN1_ITEM* it, int tag, int aclass, char opt, ASN1_TLC* ctx);
 
-int ASN1_item_ex_i2d(const ASN1_VALUE **pval, unsigned char **out,
-                     const ASN1_ITEM *it, int tag, int aclass);
+    int ASN1_item_ex_i2d(const ASN1_VALUE** pval, unsigned char** out, const ASN1_ITEM* it, int tag, int aclass);
 
 /* Legacy compatibility */
-# define IMPLEMENT_ASN1_FUNCTIONS_const(name) IMPLEMENT_ASN1_FUNCTIONS(name)
-# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
-         IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname)
+#define IMPLEMENT_ASN1_FUNCTIONS_const(name) IMPLEMENT_ASN1_FUNCTIONS(name)
+#define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \
+    IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname)
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/async.h b/CAPI/cpp/grpc/include/openssl/async.h
index bc27d5d..9cdf69f 100644
--- a/CAPI/cpp/grpc/include/openssl/async.h
+++ b/CAPI/cpp/grpc/include/openssl/async.h
@@ -10,87 +10,73 @@
 #include <stdlib.h>
 
 #ifndef OPENSSL_ASYNC_H
-# define OPENSSL_ASYNC_H
-# pragma once
+#define OPENSSL_ASYNC_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_ASYNC_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ASYNC_H
+#endif
 
 #if defined(_WIN32)
-# if defined(BASETYPES) || defined(_WINDEF_H)
+#if defined(BASETYPES) || defined(_WINDEF_H)
 /* application has to include <windows.h> to use this */
-#define OSSL_ASYNC_FD       HANDLE
-#define OSSL_BAD_ASYNC_FD   INVALID_HANDLE_VALUE
-# endif
+#define OSSL_ASYNC_FD HANDLE
+#define OSSL_BAD_ASYNC_FD INVALID_HANDLE_VALUE
+#endif
 #else
-#define OSSL_ASYNC_FD       int
-#define OSSL_BAD_ASYNC_FD   -1
+#define OSSL_ASYNC_FD int
+#define OSSL_BAD_ASYNC_FD -1
 #endif
-# include <openssl/asyncerr.h>
-
+#include <openssl/asyncerr.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-typedef struct async_job_st ASYNC_JOB;
-typedef struct async_wait_ctx_st ASYNC_WAIT_CTX;
-typedef int (*ASYNC_callback_fn)(void *arg);
+    typedef struct async_job_st ASYNC_JOB;
+    typedef struct async_wait_ctx_st ASYNC_WAIT_CTX;
+    typedef int (*ASYNC_callback_fn)(void* arg);
 
-#define ASYNC_ERR      0
-#define ASYNC_NO_JOBS  1
-#define ASYNC_PAUSE    2
-#define ASYNC_FINISH   3
+#define ASYNC_ERR 0
+#define ASYNC_NO_JOBS 1
+#define ASYNC_PAUSE 2
+#define ASYNC_FINISH 3
 
-#define ASYNC_STATUS_UNSUPPORTED    0
-#define ASYNC_STATUS_ERR            1
-#define ASYNC_STATUS_OK             2
-#define ASYNC_STATUS_EAGAIN         3
+#define ASYNC_STATUS_UNSUPPORTED 0
+#define ASYNC_STATUS_ERR 1
+#define ASYNC_STATUS_OK 2
+#define ASYNC_STATUS_EAGAIN 3
 
-int ASYNC_init_thread(size_t max_size, size_t init_size);
-void ASYNC_cleanup_thread(void);
+    int ASYNC_init_thread(size_t max_size, size_t init_size);
+    void ASYNC_cleanup_thread(void);
 
 #ifdef OSSL_ASYNC_FD
-ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void);
-void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx);
-int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key,
-                               OSSL_ASYNC_FD fd,
-                               void *custom_data,
-                               void (*cleanup)(ASYNC_WAIT_CTX *, const void *,
-                                               OSSL_ASYNC_FD, void *));
-int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key,
-                        OSSL_ASYNC_FD *fd, void **custom_data);
-int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd,
-                               size_t *numfds);
-int ASYNC_WAIT_CTX_get_callback(ASYNC_WAIT_CTX *ctx,
-                                ASYNC_callback_fn *callback,
-                                void **callback_arg);
-int ASYNC_WAIT_CTX_set_callback(ASYNC_WAIT_CTX *ctx,
-                                ASYNC_callback_fn callback,
-                                void *callback_arg);
-int ASYNC_WAIT_CTX_set_status(ASYNC_WAIT_CTX *ctx, int status);
-int ASYNC_WAIT_CTX_get_status(ASYNC_WAIT_CTX *ctx);
-int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd,
-                                   size_t *numaddfds, OSSL_ASYNC_FD *delfd,
-                                   size_t *numdelfds);
-int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key);
+    ASYNC_WAIT_CTX* ASYNC_WAIT_CTX_new(void);
+    void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX* ctx);
+    int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX* ctx, const void* key, OSSL_ASYNC_FD fd, void* custom_data, void (*cleanup)(ASYNC_WAIT_CTX*, const void*, OSSL_ASYNC_FD, void*));
+    int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX* ctx, const void* key, OSSL_ASYNC_FD* fd, void** custom_data);
+    int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX* ctx, OSSL_ASYNC_FD* fd, size_t* numfds);
+    int ASYNC_WAIT_CTX_get_callback(ASYNC_WAIT_CTX* ctx, ASYNC_callback_fn* callback, void** callback_arg);
+    int ASYNC_WAIT_CTX_set_callback(ASYNC_WAIT_CTX* ctx, ASYNC_callback_fn callback, void* callback_arg);
+    int ASYNC_WAIT_CTX_set_status(ASYNC_WAIT_CTX* ctx, int status);
+    int ASYNC_WAIT_CTX_get_status(ASYNC_WAIT_CTX* ctx);
+    int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX* ctx, OSSL_ASYNC_FD* addfd, size_t* numaddfds, OSSL_ASYNC_FD* delfd, size_t* numdelfds);
+    int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX* ctx, const void* key);
 #endif
 
-int ASYNC_is_capable(void);
-
-int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret,
-                    int (*func)(void *), void *args, size_t size);
-int ASYNC_pause_job(void);
+    int ASYNC_is_capable(void);
 
-ASYNC_JOB *ASYNC_get_current_job(void);
-ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job);
-void ASYNC_block_pause(void);
-void ASYNC_unblock_pause(void);
+    int ASYNC_start_job(ASYNC_JOB** job, ASYNC_WAIT_CTX* ctx, int* ret, int (*func)(void*), void* args, size_t size);
+    int ASYNC_pause_job(void);
 
+    ASYNC_JOB* ASYNC_get_current_job(void);
+    ASYNC_WAIT_CTX* ASYNC_get_wait_ctx(ASYNC_JOB* job);
+    void ASYNC_block_pause(void);
+    void ASYNC_unblock_pause(void);
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/asyncerr.h b/CAPI/cpp/grpc/include/openssl/asyncerr.h
index c093f7b..41bd4a0 100644
--- a/CAPI/cpp/grpc/include/openssl/asyncerr.h
+++ b/CAPI/cpp/grpc/include/openssl/asyncerr.h
@@ -9,21 +9,19 @@
  */
 
 #ifndef OPENSSL_ASYNCERR_H
-# define OPENSSL_ASYNCERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_ASYNCERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * ASYNC reason codes.
  */
-# define ASYNC_R_FAILED_TO_SET_POOL                       101
-# define ASYNC_R_FAILED_TO_SWAP_CONTEXT                   102
-# define ASYNC_R_INIT_FAILED                              105
-# define ASYNC_R_INVALID_POOL_SIZE                        103
+#define ASYNC_R_FAILED_TO_SET_POOL 101
+#define ASYNC_R_FAILED_TO_SWAP_CONTEXT 102
+#define ASYNC_R_INIT_FAILED 105
+#define ASYNC_R_INVALID_POOL_SIZE 103
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/bio.h b/CAPI/cpp/grpc/include/openssl/bio.h
index 0c1077e..4e58452 100644
--- a/CAPI/cpp/grpc/include/openssl/bio.h
+++ b/CAPI/cpp/grpc/include/openssl/bio.h
@@ -10,234 +10,234 @@
  * https://www.openssl.org/source/license.html
  */
 
-
 #ifndef OPENSSL_BIO_H
-# define OPENSSL_BIO_H
-# pragma once
+#define OPENSSL_BIO_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_BIO_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_BIO_H
+#endif
 
-# include <openssl/e_os2.h>
+#include <openssl/e_os2.h>
 
-# ifndef OPENSSL_NO_STDIO
-#  include <stdio.h>
-# endif
-# include <stdarg.h>
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#endif
+#include <stdarg.h>
 
-# include <openssl/crypto.h>
-# include <openssl/bioerr.h>
-# include <openssl/core.h>
+#include <openssl/crypto.h>
+#include <openssl/bioerr.h>
+#include <openssl/core.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 /* There are the classes of BIOs */
-# define BIO_TYPE_DESCRIPTOR     0x0100 /* socket, fd, connect or accept */
-# define BIO_TYPE_FILTER         0x0200
-# define BIO_TYPE_SOURCE_SINK    0x0400
+#define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */
+#define BIO_TYPE_FILTER 0x0200
+#define BIO_TYPE_SOURCE_SINK 0x0400
 
 /* These are the 'types' of BIOs */
-# define BIO_TYPE_NONE             0
-# define BIO_TYPE_MEM            ( 1|BIO_TYPE_SOURCE_SINK)
-# define BIO_TYPE_FILE           ( 2|BIO_TYPE_SOURCE_SINK)
-
-# define BIO_TYPE_FD             ( 4|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
-# define BIO_TYPE_SOCKET         ( 5|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
-# define BIO_TYPE_NULL           ( 6|BIO_TYPE_SOURCE_SINK)
-# define BIO_TYPE_SSL            ( 7|BIO_TYPE_FILTER)
-# define BIO_TYPE_MD             ( 8|BIO_TYPE_FILTER)
-# define BIO_TYPE_BUFFER         ( 9|BIO_TYPE_FILTER)
-# define BIO_TYPE_CIPHER         (10|BIO_TYPE_FILTER)
-# define BIO_TYPE_BASE64         (11|BIO_TYPE_FILTER)
-# define BIO_TYPE_CONNECT        (12|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
-# define BIO_TYPE_ACCEPT         (13|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
-
-# define BIO_TYPE_NBIO_TEST      (16|BIO_TYPE_FILTER)/* server proxy BIO */
-# define BIO_TYPE_NULL_FILTER    (17|BIO_TYPE_FILTER)
-# define BIO_TYPE_BIO            (19|BIO_TYPE_SOURCE_SINK)/* half a BIO pair */
-# define BIO_TYPE_LINEBUFFER     (20|BIO_TYPE_FILTER)
-# define BIO_TYPE_DGRAM          (21|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
-# define BIO_TYPE_ASN1           (22|BIO_TYPE_FILTER)
-# define BIO_TYPE_COMP           (23|BIO_TYPE_FILTER)
-# ifndef OPENSSL_NO_SCTP
-#  define BIO_TYPE_DGRAM_SCTP    (24|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
-# endif
-# define BIO_TYPE_CORE_TO_PROV   (25|BIO_TYPE_SOURCE_SINK)
-
-#define BIO_TYPE_START           128
+#define BIO_TYPE_NONE 0
+#define BIO_TYPE_MEM (1 | BIO_TYPE_SOURCE_SINK)
+#define BIO_TYPE_FILE (2 | BIO_TYPE_SOURCE_SINK)
+
+#define BIO_TYPE_FD (4 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#define BIO_TYPE_SOCKET (5 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#define BIO_TYPE_NULL (6 | BIO_TYPE_SOURCE_SINK)
+#define BIO_TYPE_SSL (7 | BIO_TYPE_FILTER)
+#define BIO_TYPE_MD (8 | BIO_TYPE_FILTER)
+#define BIO_TYPE_BUFFER (9 | BIO_TYPE_FILTER)
+#define BIO_TYPE_CIPHER (10 | BIO_TYPE_FILTER)
+#define BIO_TYPE_BASE64 (11 | BIO_TYPE_FILTER)
+#define BIO_TYPE_CONNECT (12 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#define BIO_TYPE_ACCEPT (13 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+
+#define BIO_TYPE_NBIO_TEST (16 | BIO_TYPE_FILTER) /* server proxy BIO */
+#define BIO_TYPE_NULL_FILTER (17 | BIO_TYPE_FILTER)
+#define BIO_TYPE_BIO (19 | BIO_TYPE_SOURCE_SINK) /* half a BIO pair */
+#define BIO_TYPE_LINEBUFFER (20 | BIO_TYPE_FILTER)
+#define BIO_TYPE_DGRAM (21 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#define BIO_TYPE_ASN1 (22 | BIO_TYPE_FILTER)
+#define BIO_TYPE_COMP (23 | BIO_TYPE_FILTER)
+#ifndef OPENSSL_NO_SCTP
+#define BIO_TYPE_DGRAM_SCTP (24 | BIO_TYPE_SOURCE_SINK | BIO_TYPE_DESCRIPTOR)
+#endif
+#define BIO_TYPE_CORE_TO_PROV (25 | BIO_TYPE_SOURCE_SINK)
+
+#define BIO_TYPE_START 128
 
 /*
  * BIO_FILENAME_READ|BIO_CLOSE to open or close on free.
  * BIO_set_fp(in,stdin,BIO_NOCLOSE);
  */
-# define BIO_NOCLOSE             0x00
-# define BIO_CLOSE               0x01
+#define BIO_NOCLOSE 0x00
+#define BIO_CLOSE 0x01
 
 /*
  * These are used in the following macros and are passed to BIO_ctrl()
  */
-# define BIO_CTRL_RESET          1/* opt - rewind/zero etc */
-# define BIO_CTRL_EOF            2/* opt - are we at the eof */
-# define BIO_CTRL_INFO           3/* opt - extra tit-bits */
-# define BIO_CTRL_SET            4/* man - set the 'IO' type */
-# define BIO_CTRL_GET            5/* man - get the 'IO' type */
-# define BIO_CTRL_PUSH           6/* opt - internal, used to signify change */
-# define BIO_CTRL_POP            7/* opt - internal, used to signify change */
-# define BIO_CTRL_GET_CLOSE      8/* man - set the 'close' on free */
-# define BIO_CTRL_SET_CLOSE      9/* man - set the 'close' on free */
-# define BIO_CTRL_PENDING        10/* opt - is their more data buffered */
-# define BIO_CTRL_FLUSH          11/* opt - 'flush' buffered output */
-# define BIO_CTRL_DUP            12/* man - extra stuff for 'duped' BIO */
-# define BIO_CTRL_WPENDING       13/* opt - number of bytes still to write */
-# define BIO_CTRL_SET_CALLBACK   14/* opt - set callback function */
-# define BIO_CTRL_GET_CALLBACK   15/* opt - set callback function */
-
-# define BIO_CTRL_PEEK           29/* BIO_f_buffer special */
-# define BIO_CTRL_SET_FILENAME   30/* BIO_s_file special */
+#define BIO_CTRL_RESET 1         /* opt - rewind/zero etc */
+#define BIO_CTRL_EOF 2           /* opt - are we at the eof */
+#define BIO_CTRL_INFO 3          /* opt - extra tit-bits */
+#define BIO_CTRL_SET 4           /* man - set the 'IO' type */
+#define BIO_CTRL_GET 5           /* man - get the 'IO' type */
+#define BIO_CTRL_PUSH 6          /* opt - internal, used to signify change */
+#define BIO_CTRL_POP 7           /* opt - internal, used to signify change */
+#define BIO_CTRL_GET_CLOSE 8     /* man - set the 'close' on free */
+#define BIO_CTRL_SET_CLOSE 9     /* man - set the 'close' on free */
+#define BIO_CTRL_PENDING 10      /* opt - is their more data buffered */
+#define BIO_CTRL_FLUSH 11        /* opt - 'flush' buffered output */
+#define BIO_CTRL_DUP 12          /* man - extra stuff for 'duped' BIO */
+#define BIO_CTRL_WPENDING 13     /* opt - number of bytes still to write */
+#define BIO_CTRL_SET_CALLBACK 14 /* opt - set callback function */
+#define BIO_CTRL_GET_CALLBACK 15 /* opt - set callback function */
+
+#define BIO_CTRL_PEEK 29         /* BIO_f_buffer special */
+#define BIO_CTRL_SET_FILENAME 30 /* BIO_s_file special */
 
 /* dgram BIO stuff */
-# define BIO_CTRL_DGRAM_CONNECT       31/* BIO dgram special */
-# define BIO_CTRL_DGRAM_SET_CONNECTED 32/* allow for an externally connected
-                                         * socket to be passed in */
-# define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33/* setsockopt, essentially */
-# define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34/* getsockopt, essentially */
-# define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35/* setsockopt, essentially */
-# define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36/* getsockopt, essentially */
+#define BIO_CTRL_DGRAM_CONNECT 31          /* BIO dgram special */
+#define BIO_CTRL_DGRAM_SET_CONNECTED 32    /* allow for an externally connected \
+                                            * socket to be passed in */
+#define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33 /* setsockopt, essentially */
+#define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34 /* getsockopt, essentially */
+#define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35 /* setsockopt, essentially */
+#define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36 /* getsockopt, essentially */
 
-# define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37/* flag whether the last */
-# define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38/* I/O operation timed out */
+#define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37 /* flag whether the last */
+#define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38 /* I/O operation timed out */
 
 /* #ifdef IP_MTU_DISCOVER */
-# define BIO_CTRL_DGRAM_MTU_DISCOVER       39/* set DF bit on egress packets */
-/* #endif */
+#define BIO_CTRL_DGRAM_MTU_DISCOVER 39 /* set DF bit on egress packets */
+    /* #endif */
 
-# define BIO_CTRL_DGRAM_QUERY_MTU          40/* as kernel for current MTU */
-# define BIO_CTRL_DGRAM_GET_FALLBACK_MTU   47
-# define BIO_CTRL_DGRAM_GET_MTU            41/* get cached value for MTU */
-# define BIO_CTRL_DGRAM_SET_MTU            42/* set cached value for MTU.
-                                              * want to use this if asking
-                                              * the kernel fails */
+#define BIO_CTRL_DGRAM_QUERY_MTU 40 /* as kernel for current MTU */
+#define BIO_CTRL_DGRAM_GET_FALLBACK_MTU 47
+#define BIO_CTRL_DGRAM_GET_MTU 41 /* get cached value for MTU */
+#define BIO_CTRL_DGRAM_SET_MTU 42 /* set cached value for MTU.  \
+                                   * want to use this if asking \
+                                   * the kernel fails */
 
-# define BIO_CTRL_DGRAM_MTU_EXCEEDED       43/* check whether the MTU was
-                                              * exceed in the previous write
-                                              * operation */
+#define BIO_CTRL_DGRAM_MTU_EXCEEDED 43 /* check whether the MTU was    \
+                                        * exceed in the previous write \
+                                        * operation */
 
-# define BIO_CTRL_DGRAM_GET_PEER           46
-# define BIO_CTRL_DGRAM_SET_PEER           44/* Destination for the data */
+#define BIO_CTRL_DGRAM_GET_PEER 46
+#define BIO_CTRL_DGRAM_SET_PEER 44 /* Destination for the data */
 
-# define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT   45/* Next DTLS handshake timeout
-                                              * to adjust socket timeouts */
-# define BIO_CTRL_DGRAM_SET_DONT_FRAG      48
+#define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT 45 /* Next DTLS handshake timeout \
+                                            * to adjust socket timeouts */
+#define BIO_CTRL_DGRAM_SET_DONT_FRAG 48
 
-# define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD   49
+#define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD 49
 
 /* Deliberately outside of OPENSSL_NO_SCTP - used in bss_dgram.c */
-#  define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE    50
-# ifndef OPENSSL_NO_SCTP
+#define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE 50
+#ifndef OPENSSL_NO_SCTP
 /* SCTP stuff */
-#  define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY                51
-#  define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY               52
-#  define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD               53
-#  define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO         60
-#  define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO         61
-#  define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO         62
-#  define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO         63
-#  define BIO_CTRL_DGRAM_SCTP_GET_PRINFO                  64
-#  define BIO_CTRL_DGRAM_SCTP_SET_PRINFO                  65
-#  define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN               70
-# endif
-
-# define BIO_CTRL_DGRAM_SET_PEEK_MODE      71
+#define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY 51
+#define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY 52
+#define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD 53
+#define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO 60
+#define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO 61
+#define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO 62
+#define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO 63
+#define BIO_CTRL_DGRAM_SCTP_GET_PRINFO 64
+#define BIO_CTRL_DGRAM_SCTP_SET_PRINFO 65
+#define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN 70
+#endif
 
-/*
- * internal BIO:
- * # define BIO_CTRL_SET_KTLS_SEND                 72
- * # define BIO_CTRL_SET_KTLS_SEND_CTRL_MSG        74
- * # define BIO_CTRL_CLEAR_KTLS_CTRL_MSG           75
- */
+#define BIO_CTRL_DGRAM_SET_PEEK_MODE 71
+
+    /*
+     * internal BIO:
+     * # define BIO_CTRL_SET_KTLS_SEND                 72
+     * # define BIO_CTRL_SET_KTLS_SEND_CTRL_MSG        74
+     * # define BIO_CTRL_CLEAR_KTLS_CTRL_MSG           75
+     */
 
-# define BIO_CTRL_GET_KTLS_SEND                 73
-# define BIO_CTRL_GET_KTLS_RECV                 76
+#define BIO_CTRL_GET_KTLS_SEND 73
+#define BIO_CTRL_GET_KTLS_RECV 76
 
-# define BIO_CTRL_DGRAM_SCTP_WAIT_FOR_DRY       77
-# define BIO_CTRL_DGRAM_SCTP_MSG_WAITING        78
+#define BIO_CTRL_DGRAM_SCTP_WAIT_FOR_DRY 77
+#define BIO_CTRL_DGRAM_SCTP_MSG_WAITING 78
 
 /* BIO_f_prefix controls */
-# define BIO_CTRL_SET_PREFIX                    79
-# define BIO_CTRL_SET_INDENT                    80
-# define BIO_CTRL_GET_INDENT                    81
-
-# ifndef OPENSSL_NO_KTLS
-#  define BIO_get_ktls_send(b)         \
-     (BIO_ctrl(b, BIO_CTRL_GET_KTLS_SEND, 0, NULL) > 0)
-#  define BIO_get_ktls_recv(b)         \
-     (BIO_ctrl(b, BIO_CTRL_GET_KTLS_RECV, 0, NULL) > 0)
-# else
-#  define BIO_get_ktls_send(b)  (0)
-#  define BIO_get_ktls_recv(b)  (0)
-# endif
+#define BIO_CTRL_SET_PREFIX 79
+#define BIO_CTRL_SET_INDENT 80
+#define BIO_CTRL_GET_INDENT 81
+
+#ifndef OPENSSL_NO_KTLS
+#define BIO_get_ktls_send(b) \
+    (BIO_ctrl(b, BIO_CTRL_GET_KTLS_SEND, 0, NULL) > 0)
+#define BIO_get_ktls_recv(b) \
+    (BIO_ctrl(b, BIO_CTRL_GET_KTLS_RECV, 0, NULL) > 0)
+#else
+#define BIO_get_ktls_send(b) (0)
+#define BIO_get_ktls_recv(b) (0)
+#endif
 
 /* modifiers */
-# define BIO_FP_READ             0x02
-# define BIO_FP_WRITE            0x04
-# define BIO_FP_APPEND           0x08
-# define BIO_FP_TEXT             0x10
-
-# define BIO_FLAGS_READ          0x01
-# define BIO_FLAGS_WRITE         0x02
-# define BIO_FLAGS_IO_SPECIAL    0x04
-# define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL)
-# define BIO_FLAGS_SHOULD_RETRY  0x08
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#define BIO_FP_READ 0x02
+#define BIO_FP_WRITE 0x04
+#define BIO_FP_APPEND 0x08
+#define BIO_FP_TEXT 0x10
+
+#define BIO_FLAGS_READ 0x01
+#define BIO_FLAGS_WRITE 0x02
+#define BIO_FLAGS_IO_SPECIAL 0x04
+#define BIO_FLAGS_RWS (BIO_FLAGS_READ | BIO_FLAGS_WRITE | BIO_FLAGS_IO_SPECIAL)
+#define BIO_FLAGS_SHOULD_RETRY 0x08
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 /* This #define was replaced by an internal constant and should not be used. */
-#  define BIO_FLAGS_UPLINK       0
-# endif
+#define BIO_FLAGS_UPLINK 0
+#endif
 
-# define BIO_FLAGS_BASE64_NO_NL  0x100
+#define BIO_FLAGS_BASE64_NO_NL 0x100
 
 /*
  * This is used with memory BIOs:
  * BIO_FLAGS_MEM_RDONLY means we shouldn't free up or change the data in any way;
  * BIO_FLAGS_NONCLEAR_RST means we shouldn't clear data on reset.
  */
-# define BIO_FLAGS_MEM_RDONLY    0x200
-# define BIO_FLAGS_NONCLEAR_RST  0x400
-# define BIO_FLAGS_IN_EOF        0x800
+#define BIO_FLAGS_MEM_RDONLY 0x200
+#define BIO_FLAGS_NONCLEAR_RST 0x400
+#define BIO_FLAGS_IN_EOF 0x800
 
-/* the BIO FLAGS values 0x1000 to 0x4000 are reserved for internal KTLS flags */
+    /* the BIO FLAGS values 0x1000 to 0x4000 are reserved for internal KTLS flags */
 
-typedef union bio_addr_st BIO_ADDR;
-typedef struct bio_addrinfo_st BIO_ADDRINFO;
+    typedef union bio_addr_st BIO_ADDR;
+    typedef struct bio_addrinfo_st BIO_ADDRINFO;
 
-int BIO_get_new_index(void);
-void BIO_set_flags(BIO *b, int flags);
-int BIO_test_flags(const BIO *b, int flags);
-void BIO_clear_flags(BIO *b, int flags);
+    int BIO_get_new_index(void);
+    void BIO_set_flags(BIO* b, int flags);
+    int BIO_test_flags(const BIO* b, int flags);
+    void BIO_clear_flags(BIO* b, int flags);
 
-# define BIO_get_flags(b) BIO_test_flags(b, ~(0x0))
-# define BIO_set_retry_special(b) \
-                BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
-# define BIO_set_retry_read(b) \
-                BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
-# define BIO_set_retry_write(b) \
-                BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY))
+#define BIO_get_flags(b) BIO_test_flags(b, ~(0x0))
+#define BIO_set_retry_special(b) \
+    BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY))
+#define BIO_set_retry_read(b) \
+    BIO_set_flags(b, (BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY))
+#define BIO_set_retry_write(b) \
+    BIO_set_flags(b, (BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY))
 
 /* These are normally used internally in BIOs */
-# define BIO_clear_retry_flags(b) \
-                BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
-# define BIO_get_retry_flags(b) \
-                BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+#define BIO_clear_retry_flags(b) \
+    BIO_clear_flags(b, (BIO_FLAGS_RWS | BIO_FLAGS_SHOULD_RETRY))
+#define BIO_get_retry_flags(b) \
+    BIO_test_flags(b, (BIO_FLAGS_RWS | BIO_FLAGS_SHOULD_RETRY))
 
 /* These should be used by the application to tell why we should retry */
-# define BIO_should_read(a)              BIO_test_flags(a, BIO_FLAGS_READ)
-# define BIO_should_write(a)             BIO_test_flags(a, BIO_FLAGS_WRITE)
-# define BIO_should_io_special(a)        BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL)
-# define BIO_retry_type(a)               BIO_test_flags(a, BIO_FLAGS_RWS)
-# define BIO_should_retry(a)             BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY)
+#define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ)
+#define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE)
+#define BIO_should_io_special(a) BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL)
+#define BIO_retry_type(a) BIO_test_flags(a, BIO_FLAGS_RWS)
+#define BIO_should_retry(a) BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY)
 
 /*
  * The next three are used in conjunction with the BIO_should_io_special()
@@ -249,272 +249,254 @@ void BIO_clear_flags(BIO *b, int flags);
 /*
  * Returned from the SSL bio when the certificate retrieval code had an error
  */
-# define BIO_RR_SSL_X509_LOOKUP          0x01
+#define BIO_RR_SSL_X509_LOOKUP 0x01
 /* Returned from the connect BIO when a connect would have blocked */
-# define BIO_RR_CONNECT                  0x02
+#define BIO_RR_CONNECT 0x02
 /* Returned from the accept BIO when an accept would have blocked */
-# define BIO_RR_ACCEPT                   0x03
+#define BIO_RR_ACCEPT 0x03
 
 /* These are passed by the BIO callback */
-# define BIO_CB_FREE     0x01
-# define BIO_CB_READ     0x02
-# define BIO_CB_WRITE    0x03
-# define BIO_CB_PUTS     0x04
-# define BIO_CB_GETS     0x05
-# define BIO_CB_CTRL     0x06
+#define BIO_CB_FREE 0x01
+#define BIO_CB_READ 0x02
+#define BIO_CB_WRITE 0x03
+#define BIO_CB_PUTS 0x04
+#define BIO_CB_GETS 0x05
+#define BIO_CB_CTRL 0x06
 
 /*
  * The callback is called before and after the underling operation, The
  * BIO_CB_RETURN flag indicates if it is after the call
  */
-# define BIO_CB_RETURN   0x80
-# define BIO_CB_return(a) ((a)|BIO_CB_RETURN)
-# define BIO_cb_pre(a)   (!((a)&BIO_CB_RETURN))
-# define BIO_cb_post(a)  ((a)&BIO_CB_RETURN)
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi,
-                                long argl, long ret);
-OSSL_DEPRECATEDIN_3_0 BIO_callback_fn BIO_get_callback(const BIO *b);
-OSSL_DEPRECATEDIN_3_0 void BIO_set_callback(BIO *b, BIO_callback_fn callback);
-OSSL_DEPRECATEDIN_3_0 long BIO_debug_callback(BIO *bio, int cmd,
-                                               const char *argp, int argi,
-                                               long argl, long ret);
-# endif
-
-typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp,
-                                   size_t len, int argi,
-                                   long argl, int ret, size_t *processed);
-BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b);
-void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback);
-long BIO_debug_callback_ex(BIO *bio, int oper, const char *argp, size_t len,
-                           int argi, long argl, int ret, size_t *processed);
-
-char *BIO_get_callback_arg(const BIO *b);
-void BIO_set_callback_arg(BIO *b, char *arg);
-
-typedef struct bio_method_st BIO_METHOD;
-
-const char *BIO_method_name(const BIO *b);
-int BIO_method_type(const BIO *b);
-
-typedef int BIO_info_cb(BIO *, int, int);
-typedef BIO_info_cb bio_info_cb;  /* backward compatibility */
-
-SKM_DEFINE_STACK_OF_INTERNAL(BIO, BIO, BIO)
+#define BIO_CB_RETURN 0x80
+#define BIO_CB_return(a) ((a) | BIO_CB_RETURN)
+#define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN))
+#define BIO_cb_post(a) ((a)&BIO_CB_RETURN)
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef long (*BIO_callback_fn)(BIO* b, int oper, const char* argp, int argi, long argl, long ret);
+    OSSL_DEPRECATEDIN_3_0 BIO_callback_fn BIO_get_callback(const BIO* b);
+    OSSL_DEPRECATEDIN_3_0 void BIO_set_callback(BIO* b, BIO_callback_fn callback);
+    OSSL_DEPRECATEDIN_3_0 long BIO_debug_callback(BIO* bio, int cmd, const char* argp, int argi, long argl, long ret);
+#endif
+
+    typedef long (*BIO_callback_fn_ex)(BIO* b, int oper, const char* argp, size_t len, int argi, long argl, int ret, size_t* processed);
+    BIO_callback_fn_ex BIO_get_callback_ex(const BIO* b);
+    void BIO_set_callback_ex(BIO* b, BIO_callback_fn_ex callback);
+    long BIO_debug_callback_ex(BIO* bio, int oper, const char* argp, size_t len, int argi, long argl, int ret, size_t* processed);
+
+    char* BIO_get_callback_arg(const BIO* b);
+    void BIO_set_callback_arg(BIO* b, char* arg);
+
+    typedef struct bio_method_st BIO_METHOD;
+
+    const char* BIO_method_name(const BIO* b);
+    int BIO_method_type(const BIO* b);
+
+    typedef int BIO_info_cb(BIO*, int, int);
+    typedef BIO_info_cb bio_info_cb; /* backward compatibility */
+
+    SKM_DEFINE_STACK_OF_INTERNAL(BIO, BIO, BIO)
 #define sk_BIO_num(sk) OPENSSL_sk_num(ossl_check_const_BIO_sk_type(sk))
-#define sk_BIO_value(sk, idx) ((BIO *)OPENSSL_sk_value(ossl_check_const_BIO_sk_type(sk), (idx)))
-#define sk_BIO_new(cmp) ((STACK_OF(BIO) *)OPENSSL_sk_new(ossl_check_BIO_compfunc_type(cmp)))
-#define sk_BIO_new_null() ((STACK_OF(BIO) *)OPENSSL_sk_new_null())
-#define sk_BIO_new_reserve(cmp, n) ((STACK_OF(BIO) *)OPENSSL_sk_new_reserve(ossl_check_BIO_compfunc_type(cmp), (n)))
+#define sk_BIO_value(sk, idx) ((BIO*)OPENSSL_sk_value(ossl_check_const_BIO_sk_type(sk), (idx)))
+#define sk_BIO_new(cmp) ((STACK_OF(BIO)*)OPENSSL_sk_new(ossl_check_BIO_compfunc_type(cmp)))
+#define sk_BIO_new_null() ((STACK_OF(BIO)*)OPENSSL_sk_new_null())
+#define sk_BIO_new_reserve(cmp, n) ((STACK_OF(BIO)*)OPENSSL_sk_new_reserve(ossl_check_BIO_compfunc_type(cmp), (n)))
 #define sk_BIO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_BIO_sk_type(sk), (n))
 #define sk_BIO_free(sk) OPENSSL_sk_free(ossl_check_BIO_sk_type(sk))
 #define sk_BIO_zero(sk) OPENSSL_sk_zero(ossl_check_BIO_sk_type(sk))
-#define sk_BIO_delete(sk, i) ((BIO *)OPENSSL_sk_delete(ossl_check_BIO_sk_type(sk), (i)))
-#define sk_BIO_delete_ptr(sk, ptr) ((BIO *)OPENSSL_sk_delete_ptr(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr)))
+#define sk_BIO_delete(sk, i) ((BIO*)OPENSSL_sk_delete(ossl_check_BIO_sk_type(sk), (i)))
+#define sk_BIO_delete_ptr(sk, ptr) ((BIO*)OPENSSL_sk_delete_ptr(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr)))
 #define sk_BIO_push(sk, ptr) OPENSSL_sk_push(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
 #define sk_BIO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
-#define sk_BIO_pop(sk) ((BIO *)OPENSSL_sk_pop(ossl_check_BIO_sk_type(sk)))
-#define sk_BIO_shift(sk) ((BIO *)OPENSSL_sk_shift(ossl_check_BIO_sk_type(sk)))
-#define sk_BIO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_BIO_sk_type(sk),ossl_check_BIO_freefunc_type(freefunc))
+#define sk_BIO_pop(sk) ((BIO*)OPENSSL_sk_pop(ossl_check_BIO_sk_type(sk)))
+#define sk_BIO_shift(sk) ((BIO*)OPENSSL_sk_shift(ossl_check_BIO_sk_type(sk)))
+#define sk_BIO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_BIO_sk_type(sk), ossl_check_BIO_freefunc_type(freefunc))
 #define sk_BIO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr), (idx))
-#define sk_BIO_set(sk, idx, ptr) ((BIO *)OPENSSL_sk_set(ossl_check_BIO_sk_type(sk), (idx), ossl_check_BIO_type(ptr)))
+#define sk_BIO_set(sk, idx, ptr) ((BIO*)OPENSSL_sk_set(ossl_check_BIO_sk_type(sk), (idx), ossl_check_BIO_type(ptr)))
 #define sk_BIO_find(sk, ptr) OPENSSL_sk_find(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
 #define sk_BIO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr))
 #define sk_BIO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_BIO_sk_type(sk), ossl_check_BIO_type(ptr), pnum)
 #define sk_BIO_sort(sk) OPENSSL_sk_sort(ossl_check_BIO_sk_type(sk))
 #define sk_BIO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_BIO_sk_type(sk))
-#define sk_BIO_dup(sk) ((STACK_OF(BIO) *)OPENSSL_sk_dup(ossl_check_const_BIO_sk_type(sk)))
-#define sk_BIO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(BIO) *)OPENSSL_sk_deep_copy(ossl_check_const_BIO_sk_type(sk), ossl_check_BIO_copyfunc_type(copyfunc), ossl_check_BIO_freefunc_type(freefunc)))
+#define sk_BIO_dup(sk) ((STACK_OF(BIO)*)OPENSSL_sk_dup(ossl_check_const_BIO_sk_type(sk)))
+#define sk_BIO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(BIO)*)OPENSSL_sk_deep_copy(ossl_check_const_BIO_sk_type(sk), ossl_check_BIO_copyfunc_type(copyfunc), ossl_check_BIO_freefunc_type(freefunc)))
 #define sk_BIO_set_cmp_func(sk, cmp) ((sk_BIO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_BIO_sk_type(sk), ossl_check_BIO_compfunc_type(cmp)))
 
+    /* Prefix and suffix callback in ASN1 BIO */
+    typedef int asn1_ps_func(BIO* b, unsigned char** pbuf, int* plen, void* parg);
+
+    typedef void (*BIO_dgram_sctp_notification_handler_fn)(BIO* b, void* context, void* buf);
+#ifndef OPENSSL_NO_SCTP
+    /* SCTP parameter structs */
+    struct bio_dgram_sctp_sndinfo
+    {
+        uint16_t snd_sid;
+        uint16_t snd_flags;
+        uint32_t snd_ppid;
+        uint32_t snd_context;
+    };
+
+    struct bio_dgram_sctp_rcvinfo
+    {
+        uint16_t rcv_sid;
+        uint16_t rcv_ssn;
+        uint16_t rcv_flags;
+        uint32_t rcv_ppid;
+        uint32_t rcv_tsn;
+        uint32_t rcv_cumtsn;
+        uint32_t rcv_context;
+    };
+
+    struct bio_dgram_sctp_prinfo
+    {
+        uint16_t pr_policy;
+        uint32_t pr_value;
+    };
+#endif
 
+    /*
+     * #define BIO_CONN_get_param_hostname BIO_ctrl
+     */
 
-/* Prefix and suffix callback in ASN1 BIO */
-typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen,
-                          void *parg);
-
-typedef void (*BIO_dgram_sctp_notification_handler_fn) (BIO *b,
-                                                        void *context,
-                                                        void *buf);
-# ifndef OPENSSL_NO_SCTP
-/* SCTP parameter structs */
-struct bio_dgram_sctp_sndinfo {
-    uint16_t snd_sid;
-    uint16_t snd_flags;
-    uint32_t snd_ppid;
-    uint32_t snd_context;
-};
-
-struct bio_dgram_sctp_rcvinfo {
-    uint16_t rcv_sid;
-    uint16_t rcv_ssn;
-    uint16_t rcv_flags;
-    uint32_t rcv_ppid;
-    uint32_t rcv_tsn;
-    uint32_t rcv_cumtsn;
-    uint32_t rcv_context;
-};
-
-struct bio_dgram_sctp_prinfo {
-    uint16_t pr_policy;
-    uint32_t pr_value;
-};
-# endif
-
-/*
- * #define BIO_CONN_get_param_hostname BIO_ctrl
- */
-
-# define BIO_C_SET_CONNECT                       100
-# define BIO_C_DO_STATE_MACHINE                  101
-# define BIO_C_SET_NBIO                          102
+#define BIO_C_SET_CONNECT 100
+#define BIO_C_DO_STATE_MACHINE 101
+#define BIO_C_SET_NBIO 102
 /* # define BIO_C_SET_PROXY_PARAM                   103 */
-# define BIO_C_SET_FD                            104
-# define BIO_C_GET_FD                            105
-# define BIO_C_SET_FILE_PTR                      106
-# define BIO_C_GET_FILE_PTR                      107
-# define BIO_C_SET_FILENAME                      108
-# define BIO_C_SET_SSL                           109
-# define BIO_C_GET_SSL                           110
-# define BIO_C_SET_MD                            111
-# define BIO_C_GET_MD                            112
-# define BIO_C_GET_CIPHER_STATUS                 113
-# define BIO_C_SET_BUF_MEM                       114
-# define BIO_C_GET_BUF_MEM_PTR                   115
-# define BIO_C_GET_BUFF_NUM_LINES                116
-# define BIO_C_SET_BUFF_SIZE                     117
-# define BIO_C_SET_ACCEPT                        118
-# define BIO_C_SSL_MODE                          119
-# define BIO_C_GET_MD_CTX                        120
+#define BIO_C_SET_FD 104
+#define BIO_C_GET_FD 105
+#define BIO_C_SET_FILE_PTR 106
+#define BIO_C_GET_FILE_PTR 107
+#define BIO_C_SET_FILENAME 108
+#define BIO_C_SET_SSL 109
+#define BIO_C_GET_SSL 110
+#define BIO_C_SET_MD 111
+#define BIO_C_GET_MD 112
+#define BIO_C_GET_CIPHER_STATUS 113
+#define BIO_C_SET_BUF_MEM 114
+#define BIO_C_GET_BUF_MEM_PTR 115
+#define BIO_C_GET_BUFF_NUM_LINES 116
+#define BIO_C_SET_BUFF_SIZE 117
+#define BIO_C_SET_ACCEPT 118
+#define BIO_C_SSL_MODE 119
+#define BIO_C_GET_MD_CTX 120
 /* # define BIO_C_GET_PROXY_PARAM                   121 */
-# define BIO_C_SET_BUFF_READ_DATA                122/* data to read first */
-# define BIO_C_GET_CONNECT                       123
-# define BIO_C_GET_ACCEPT                        124
-# define BIO_C_SET_SSL_RENEGOTIATE_BYTES         125
-# define BIO_C_GET_SSL_NUM_RENEGOTIATES          126
-# define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT       127
-# define BIO_C_FILE_SEEK                         128
-# define BIO_C_GET_CIPHER_CTX                    129
-# define BIO_C_SET_BUF_MEM_EOF_RETURN            130/* return end of input
-                                                     * value */
-# define BIO_C_SET_BIND_MODE                     131
-# define BIO_C_GET_BIND_MODE                     132
-# define BIO_C_FILE_TELL                         133
-# define BIO_C_GET_SOCKS                         134
-# define BIO_C_SET_SOCKS                         135
-
-# define BIO_C_SET_WRITE_BUF_SIZE                136/* for BIO_s_bio */
-# define BIO_C_GET_WRITE_BUF_SIZE                137
-# define BIO_C_MAKE_BIO_PAIR                     138
-# define BIO_C_DESTROY_BIO_PAIR                  139
-# define BIO_C_GET_WRITE_GUARANTEE               140
-# define BIO_C_GET_READ_REQUEST                  141
-# define BIO_C_SHUTDOWN_WR                       142
-# define BIO_C_NREAD0                            143
-# define BIO_C_NREAD                             144
-# define BIO_C_NWRITE0                           145
-# define BIO_C_NWRITE                            146
-# define BIO_C_RESET_READ_REQUEST                147
-# define BIO_C_SET_MD_CTX                        148
-
-# define BIO_C_SET_PREFIX                        149
-# define BIO_C_GET_PREFIX                        150
-# define BIO_C_SET_SUFFIX                        151
-# define BIO_C_GET_SUFFIX                        152
-
-# define BIO_C_SET_EX_ARG                        153
-# define BIO_C_GET_EX_ARG                        154
-
-# define BIO_C_SET_CONNECT_MODE                  155
-
-# define BIO_set_app_data(s,arg)         BIO_set_ex_data(s,0,arg)
-# define BIO_get_app_data(s)             BIO_get_ex_data(s,0)
-
-# define BIO_set_nbio(b,n)             BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL)
-
-# ifndef OPENSSL_NO_SOCK
+#define BIO_C_SET_BUFF_READ_DATA 122 /* data to read first */
+#define BIO_C_GET_CONNECT 123
+#define BIO_C_GET_ACCEPT 124
+#define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125
+#define BIO_C_GET_SSL_NUM_RENEGOTIATES 126
+#define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127
+#define BIO_C_FILE_SEEK 128
+#define BIO_C_GET_CIPHER_CTX 129
+#define BIO_C_SET_BUF_MEM_EOF_RETURN 130 /* return end of input \
+                                          * value */
+#define BIO_C_SET_BIND_MODE 131
+#define BIO_C_GET_BIND_MODE 132
+#define BIO_C_FILE_TELL 133
+#define BIO_C_GET_SOCKS 134
+#define BIO_C_SET_SOCKS 135
+
+#define BIO_C_SET_WRITE_BUF_SIZE 136 /* for BIO_s_bio */
+#define BIO_C_GET_WRITE_BUF_SIZE 137
+#define BIO_C_MAKE_BIO_PAIR 138
+#define BIO_C_DESTROY_BIO_PAIR 139
+#define BIO_C_GET_WRITE_GUARANTEE 140
+#define BIO_C_GET_READ_REQUEST 141
+#define BIO_C_SHUTDOWN_WR 142
+#define BIO_C_NREAD0 143
+#define BIO_C_NREAD 144
+#define BIO_C_NWRITE0 145
+#define BIO_C_NWRITE 146
+#define BIO_C_RESET_READ_REQUEST 147
+#define BIO_C_SET_MD_CTX 148
+
+#define BIO_C_SET_PREFIX 149
+#define BIO_C_GET_PREFIX 150
+#define BIO_C_SET_SUFFIX 151
+#define BIO_C_GET_SUFFIX 152
+
+#define BIO_C_SET_EX_ARG 153
+#define BIO_C_GET_EX_ARG 154
+
+#define BIO_C_SET_CONNECT_MODE 155
+
+#define BIO_set_app_data(s, arg) BIO_set_ex_data(s, 0, arg)
+#define BIO_get_app_data(s) BIO_get_ex_data(s, 0)
+
+#define BIO_set_nbio(b, n) BIO_ctrl(b, BIO_C_SET_NBIO, (n), NULL)
+
+#ifndef OPENSSL_NO_SOCK
 /* IP families we support, for BIO_s_connect() and BIO_s_accept() */
 /* Note: the underlying operating system may not support some of them */
-#  define BIO_FAMILY_IPV4                         4
-#  define BIO_FAMILY_IPV6                         6
-#  define BIO_FAMILY_IPANY                        256
+#define BIO_FAMILY_IPV4 4
+#define BIO_FAMILY_IPV6 6
+#define BIO_FAMILY_IPANY 256
 
 /* BIO_s_connect() */
-#  define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0, \
-                                                 (char *)(name))
-#  define BIO_set_conn_port(b,port)     BIO_ctrl(b,BIO_C_SET_CONNECT,1, \
-                                                 (char *)(port))
-#  define BIO_set_conn_address(b,addr)  BIO_ctrl(b,BIO_C_SET_CONNECT,2, \
-                                                 (char *)(addr))
-#  define BIO_set_conn_ip_family(b,f)   BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,f)
-#  define BIO_get_conn_hostname(b)      ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0))
-#  define BIO_get_conn_port(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1))
-#  define BIO_get_conn_address(b)       ((const BIO_ADDR *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2))
-#  define BIO_get_conn_ip_family(b)     BIO_ctrl(b,BIO_C_GET_CONNECT,3,NULL)
-#  define BIO_set_conn_mode(b,n)        BIO_ctrl(b,BIO_C_SET_CONNECT_MODE,(n),NULL)
+#define BIO_set_conn_hostname(b, name) BIO_ctrl(b, BIO_C_SET_CONNECT, 0, (char*)(name))
+#define BIO_set_conn_port(b, port) BIO_ctrl(b, BIO_C_SET_CONNECT, 1, (char*)(port))
+#define BIO_set_conn_address(b, addr) BIO_ctrl(b, BIO_C_SET_CONNECT, 2, (char*)(addr))
+#define BIO_set_conn_ip_family(b, f) BIO_int_ctrl(b, BIO_C_SET_CONNECT, 3, f)
+#define BIO_get_conn_hostname(b) ((const char*)BIO_ptr_ctrl(b, BIO_C_GET_CONNECT, 0))
+#define BIO_get_conn_port(b) ((const char*)BIO_ptr_ctrl(b, BIO_C_GET_CONNECT, 1))
+#define BIO_get_conn_address(b) ((const BIO_ADDR*)BIO_ptr_ctrl(b, BIO_C_GET_CONNECT, 2))
+#define BIO_get_conn_ip_family(b) BIO_ctrl(b, BIO_C_GET_CONNECT, 3, NULL)
+#define BIO_set_conn_mode(b, n) BIO_ctrl(b, BIO_C_SET_CONNECT_MODE, (n), NULL)
 
 /* BIO_s_accept() */
-#  define BIO_set_accept_name(b,name)   BIO_ctrl(b,BIO_C_SET_ACCEPT,0, \
-                                                 (char *)(name))
-#  define BIO_set_accept_port(b,port)   BIO_ctrl(b,BIO_C_SET_ACCEPT,1, \
-                                                 (char *)(port))
-#  define BIO_get_accept_name(b)        ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0))
-#  define BIO_get_accept_port(b)        ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,1))
-#  define BIO_get_peer_name(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,2))
-#  define BIO_get_peer_port(b)          ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,3))
+#define BIO_set_accept_name(b, name) BIO_ctrl(b, BIO_C_SET_ACCEPT, 0, (char*)(name))
+#define BIO_set_accept_port(b, port) BIO_ctrl(b, BIO_C_SET_ACCEPT, 1, (char*)(port))
+#define BIO_get_accept_name(b) ((const char*)BIO_ptr_ctrl(b, BIO_C_GET_ACCEPT, 0))
+#define BIO_get_accept_port(b) ((const char*)BIO_ptr_ctrl(b, BIO_C_GET_ACCEPT, 1))
+#define BIO_get_peer_name(b) ((const char*)BIO_ptr_ctrl(b, BIO_C_GET_ACCEPT, 2))
+#define BIO_get_peer_port(b) ((const char*)BIO_ptr_ctrl(b, BIO_C_GET_ACCEPT, 3))
 /* #define BIO_set_nbio(b,n)    BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */
-#  define BIO_set_nbio_accept(b,n)      BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(n)?(void *)"a":NULL)
-#  define BIO_set_accept_bios(b,bio)    BIO_ctrl(b,BIO_C_SET_ACCEPT,3, \
-                                                 (char *)(bio))
-#  define BIO_set_accept_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_ACCEPT,4,f)
-#  define BIO_get_accept_ip_family(b)   BIO_ctrl(b,BIO_C_GET_ACCEPT,4,NULL)
+#define BIO_set_nbio_accept(b, n) BIO_ctrl(b, BIO_C_SET_ACCEPT, 2, (n) ? (void*)"a" : NULL)
+#define BIO_set_accept_bios(b, bio) BIO_ctrl(b, BIO_C_SET_ACCEPT, 3, (char*)(bio))
+#define BIO_set_accept_ip_family(b, f) BIO_int_ctrl(b, BIO_C_SET_ACCEPT, 4, f)
+#define BIO_get_accept_ip_family(b) BIO_ctrl(b, BIO_C_GET_ACCEPT, 4, NULL)
 
 /* Aliases kept for backward compatibility */
-#  define BIO_BIND_NORMAL                 0
-#  define BIO_BIND_REUSEADDR              BIO_SOCK_REUSEADDR
-#  define BIO_BIND_REUSEADDR_IF_UNUSED    BIO_SOCK_REUSEADDR
-#  define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL)
-#  define BIO_get_bind_mode(b)    BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL)
-# endif /* OPENSSL_NO_SOCK */
+#define BIO_BIND_NORMAL 0
+#define BIO_BIND_REUSEADDR BIO_SOCK_REUSEADDR
+#define BIO_BIND_REUSEADDR_IF_UNUSED BIO_SOCK_REUSEADDR
+#define BIO_set_bind_mode(b, mode) BIO_ctrl(b, BIO_C_SET_BIND_MODE, mode, NULL)
+#define BIO_get_bind_mode(b) BIO_ctrl(b, BIO_C_GET_BIND_MODE, 0, NULL)
+#endif /* OPENSSL_NO_SOCK */
 
-# define BIO_do_connect(b)       BIO_do_handshake(b)
-# define BIO_do_accept(b)        BIO_do_handshake(b)
+#define BIO_do_connect(b) BIO_do_handshake(b)
+#define BIO_do_accept(b) BIO_do_handshake(b)
 
-# define BIO_do_handshake(b)     BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL)
+#define BIO_do_handshake(b) BIO_ctrl(b, BIO_C_DO_STATE_MACHINE, 0, NULL)
 
 /* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */
-# define BIO_set_fd(b,fd,c)      BIO_int_ctrl(b,BIO_C_SET_FD,c,fd)
-# define BIO_get_fd(b,c)         BIO_ctrl(b,BIO_C_GET_FD,0,(char *)(c))
+#define BIO_set_fd(b, fd, c) BIO_int_ctrl(b, BIO_C_SET_FD, c, fd)
+#define BIO_get_fd(b, c) BIO_ctrl(b, BIO_C_GET_FD, 0, (char*)(c))
 
 /* BIO_s_file() */
-# define BIO_set_fp(b,fp,c)      BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)(fp))
-# define BIO_get_fp(b,fpp)       BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)(fpp))
+#define BIO_set_fp(b, fp, c) BIO_ctrl(b, BIO_C_SET_FILE_PTR, c, (char*)(fp))
+#define BIO_get_fp(b, fpp) BIO_ctrl(b, BIO_C_GET_FILE_PTR, 0, (char*)(fpp))
 
 /* BIO_s_fd() and BIO_s_file() */
-# define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL)
-# define BIO_tell(b)     (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL)
+#define BIO_seek(b, ofs) (int)BIO_ctrl(b, BIO_C_FILE_SEEK, ofs, NULL)
+#define BIO_tell(b) (int)BIO_ctrl(b, BIO_C_FILE_TELL, 0, NULL)
 
 /*
  * name is cast to lose const, but might be better to route through a
  * function so we can do it safely
  */
-# ifdef CONST_STRICT
-/*
- * If you are wondering why this isn't defined, its because CONST_STRICT is
- * purely a compile-time kludge to allow const to be checked.
- */
-int BIO_read_filename(BIO *b, const char *name);
-# else
-#  define BIO_read_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
-                BIO_CLOSE|BIO_FP_READ,(char *)(name))
-# endif
-# define BIO_write_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
-                BIO_CLOSE|BIO_FP_WRITE,name)
-# define BIO_append_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
-                BIO_CLOSE|BIO_FP_APPEND,name)
-# define BIO_rw_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
-                BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name)
+#ifdef CONST_STRICT
+    /*
+     * If you are wondering why this isn't defined, its because CONST_STRICT is
+     * purely a compile-time kludge to allow const to be checked.
+     */
+    int BIO_read_filename(BIO* b, const char* name);
+#else
+#define BIO_read_filename(b, name) (int)BIO_ctrl(b, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_READ, (char*)(name))
+#endif
+#define BIO_write_filename(b, name) (int)BIO_ctrl(b, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_WRITE, name)
+#define BIO_append_filename(b, name) (int)BIO_ctrl(b, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_APPEND, name)
+#define BIO_rw_filename(b, name) (int)BIO_ctrl(b, BIO_C_SET_FILENAME, BIO_CLOSE | BIO_FP_READ | BIO_FP_WRITE, name)
 
 /*
  * WARNING WARNING, this ups the reference count on the read bio of the SSL
@@ -522,365 +504,341 @@ int BIO_read_filename(BIO *b, const char *name);
  * next_bio field in the bio.  So when you free the BIO, make sure you are
  * doing a BIO_free_all() to catch the underlying BIO.
  */
-# define BIO_set_ssl(b,ssl,c)    BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)(ssl))
-# define BIO_get_ssl(b,sslp)     BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)(sslp))
-# define BIO_set_ssl_mode(b,client)      BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL)
-# define BIO_set_ssl_renegotiate_bytes(b,num) \
-        BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL)
-# define BIO_get_num_renegotiates(b) \
-        BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL)
-# define BIO_set_ssl_renegotiate_timeout(b,seconds) \
-        BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL)
-
-/* defined in evp.h */
-/* #define BIO_set_md(b,md)     BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */
-
-# define BIO_get_mem_data(b,pp)  BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)(pp))
-# define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)(bm))
-# define BIO_get_mem_ptr(b,pp)   BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0, \
-                                          (char *)(pp))
-# define BIO_set_mem_eof_return(b,v) \
-                                BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL)
+#define BIO_set_ssl(b, ssl, c) BIO_ctrl(b, BIO_C_SET_SSL, c, (char*)(ssl))
+#define BIO_get_ssl(b, sslp) BIO_ctrl(b, BIO_C_GET_SSL, 0, (char*)(sslp))
+#define BIO_set_ssl_mode(b, client) BIO_ctrl(b, BIO_C_SSL_MODE, client, NULL)
+#define BIO_set_ssl_renegotiate_bytes(b, num) \
+    BIO_ctrl(b, BIO_C_SET_SSL_RENEGOTIATE_BYTES, num, NULL)
+#define BIO_get_num_renegotiates(b) \
+    BIO_ctrl(b, BIO_C_GET_SSL_NUM_RENEGOTIATES, 0, NULL)
+#define BIO_set_ssl_renegotiate_timeout(b, seconds) \
+    BIO_ctrl(b, BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT, seconds, NULL)
+
+    /* defined in evp.h */
+    /* #define BIO_set_md(b,md)     BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */
+
+#define BIO_get_mem_data(b, pp) BIO_ctrl(b, BIO_CTRL_INFO, 0, (char*)(pp))
+#define BIO_set_mem_buf(b, bm, c) BIO_ctrl(b, BIO_C_SET_BUF_MEM, c, (char*)(bm))
+#define BIO_get_mem_ptr(b, pp) BIO_ctrl(b, BIO_C_GET_BUF_MEM_PTR, 0, (char*)(pp))
+#define BIO_set_mem_eof_return(b, v) \
+    BIO_ctrl(b, BIO_C_SET_BUF_MEM_EOF_RETURN, v, NULL)
 
 /* For the BIO_f_buffer() type */
-# define BIO_get_buffer_num_lines(b)     BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL)
-# define BIO_set_buffer_size(b,size)     BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL)
-# define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0)
-# define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1)
-# define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf)
+#define BIO_get_buffer_num_lines(b) BIO_ctrl(b, BIO_C_GET_BUFF_NUM_LINES, 0, NULL)
+#define BIO_set_buffer_size(b, size) BIO_ctrl(b, BIO_C_SET_BUFF_SIZE, size, NULL)
+#define BIO_set_read_buffer_size(b, size) BIO_int_ctrl(b, BIO_C_SET_BUFF_SIZE, size, 0)
+#define BIO_set_write_buffer_size(b, size) BIO_int_ctrl(b, BIO_C_SET_BUFF_SIZE, size, 1)
+#define BIO_set_buffer_read_data(b, buf, num) BIO_ctrl(b, BIO_C_SET_BUFF_READ_DATA, num, buf)
 
 /* Don't use the next one unless you know what you are doing :-) */
-# define BIO_dup_state(b,ret)    BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret))
-
-# define BIO_reset(b)            (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL)
-# define BIO_eof(b)              (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL)
-# define BIO_set_close(b,c)      (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL)
-# define BIO_get_close(b)        (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL)
-# define BIO_pending(b)          (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL)
-# define BIO_wpending(b)         (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL)
-/* ...pending macros have inappropriate return type */
-size_t BIO_ctrl_pending(BIO *b);
-size_t BIO_ctrl_wpending(BIO *b);
-# define BIO_flush(b)            (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL)
-# define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \
-                                                   cbp)
-# define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb)
+#define BIO_dup_state(b, ret) BIO_ctrl(b, BIO_CTRL_DUP, 0, (char*)(ret))
+
+#define BIO_reset(b) (int)BIO_ctrl(b, BIO_CTRL_RESET, 0, NULL)
+#define BIO_eof(b) (int)BIO_ctrl(b, BIO_CTRL_EOF, 0, NULL)
+#define BIO_set_close(b, c) (int)BIO_ctrl(b, BIO_CTRL_SET_CLOSE, (c), NULL)
+#define BIO_get_close(b) (int)BIO_ctrl(b, BIO_CTRL_GET_CLOSE, 0, NULL)
+#define BIO_pending(b) (int)BIO_ctrl(b, BIO_CTRL_PENDING, 0, NULL)
+#define BIO_wpending(b) (int)BIO_ctrl(b, BIO_CTRL_WPENDING, 0, NULL)
+    /* ...pending macros have inappropriate return type */
+    size_t BIO_ctrl_pending(BIO* b);
+    size_t BIO_ctrl_wpending(BIO* b);
+#define BIO_flush(b) (int)BIO_ctrl(b, BIO_CTRL_FLUSH, 0, NULL)
+#define BIO_get_info_callback(b, cbp) (int)BIO_ctrl(b, BIO_CTRL_GET_CALLBACK, 0, cbp)
+#define BIO_set_info_callback(b, cb) (int)BIO_callback_ctrl(b, BIO_CTRL_SET_CALLBACK, cb)
 
 /* For the BIO_f_buffer() type */
-# define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL)
-# define BIO_buffer_peek(b,s,l) BIO_ctrl(b,BIO_CTRL_PEEK,(l),(s))
+#define BIO_buffer_get_num_lines(b) BIO_ctrl(b, BIO_CTRL_GET, 0, NULL)
+#define BIO_buffer_peek(b, s, l) BIO_ctrl(b, BIO_CTRL_PEEK, (l), (s))
 
 /* For BIO_s_bio() */
-# define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL)
-# define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL)
-# define BIO_make_bio_pair(b1,b2)   (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2)
-# define BIO_destroy_bio_pair(b)    (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL)
-# define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL)
+#define BIO_set_write_buf_size(b, size) (int)BIO_ctrl(b, BIO_C_SET_WRITE_BUF_SIZE, size, NULL)
+#define BIO_get_write_buf_size(b, size) (size_t) BIO_ctrl(b, BIO_C_GET_WRITE_BUF_SIZE, size, NULL)
+#define BIO_make_bio_pair(b1, b2) (int)BIO_ctrl(b1, BIO_C_MAKE_BIO_PAIR, 0, b2)
+#define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b, BIO_C_DESTROY_BIO_PAIR, 0, NULL)
+#define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL)
 /* macros with inappropriate type -- but ...pending macros use int too: */
-# define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL)
-# define BIO_get_read_request(b)    (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL)
-size_t BIO_ctrl_get_write_guarantee(BIO *b);
-size_t BIO_ctrl_get_read_request(BIO *b);
-int BIO_ctrl_reset_read_request(BIO *b);
+#define BIO_get_write_guarantee(b) (int)BIO_ctrl(b, BIO_C_GET_WRITE_GUARANTEE, 0, NULL)
+#define BIO_get_read_request(b) (int)BIO_ctrl(b, BIO_C_GET_READ_REQUEST, 0, NULL)
+    size_t BIO_ctrl_get_write_guarantee(BIO* b);
+    size_t BIO_ctrl_get_read_request(BIO* b);
+    int BIO_ctrl_reset_read_request(BIO* b);
 
 /* ctrl macros for dgram */
-# define BIO_ctrl_dgram_connect(b,peer)  \
-                     (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)(peer))
-# define BIO_ctrl_set_connected(b,peer) \
-         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char *)(peer))
-# define BIO_dgram_recv_timedout(b) \
-         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL)
-# define BIO_dgram_send_timedout(b) \
-         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL)
-# define BIO_dgram_get_peer(b,peer) \
-         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)(peer))
-# define BIO_dgram_set_peer(b,peer) \
-         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)(peer))
-# define BIO_dgram_get_mtu_overhead(b) \
-         (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL)
+#define BIO_ctrl_dgram_connect(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_CONNECT, 0, (char*)(peer))
+#define BIO_ctrl_set_connected(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char*)(peer))
+#define BIO_dgram_recv_timedout(b) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL)
+#define BIO_dgram_send_timedout(b) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL)
+#define BIO_dgram_get_peer(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char*)(peer))
+#define BIO_dgram_set_peer(b, peer) \
+    (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char*)(peer))
+#define BIO_dgram_get_mtu_overhead(b) \
+    (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL)
 
 /* ctrl macros for BIO_f_prefix */
-# define BIO_set_prefix(b,p) BIO_ctrl((b), BIO_CTRL_SET_PREFIX, 0, (void *)(p))
-# define BIO_set_indent(b,i) BIO_ctrl((b), BIO_CTRL_SET_INDENT, (i), NULL)
-# define BIO_get_indent(b) BIO_ctrl((b), BIO_CTRL_GET_INDENT, 0, NULL)
+#define BIO_set_prefix(b, p) BIO_ctrl((b), BIO_CTRL_SET_PREFIX, 0, (void*)(p))
+#define BIO_set_indent(b, i) BIO_ctrl((b), BIO_CTRL_SET_INDENT, (i), NULL)
+#define BIO_get_indent(b) BIO_ctrl((b), BIO_CTRL_GET_INDENT, 0, NULL)
 
 #define BIO_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, l, p, newf, dupf, freef)
-int BIO_set_ex_data(BIO *bio, int idx, void *data);
-void *BIO_get_ex_data(const BIO *bio, int idx);
-uint64_t BIO_number_read(BIO *bio);
-uint64_t BIO_number_written(BIO *bio);
-
-/* For BIO_f_asn1() */
-int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
-                        asn1_ps_func *prefix_free);
-int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
-                        asn1_ps_func **pprefix_free);
-int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
-                        asn1_ps_func *suffix_free);
-int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
-                        asn1_ps_func **psuffix_free);
-
-const BIO_METHOD *BIO_s_file(void);
-BIO *BIO_new_file(const char *filename, const char *mode);
-BIO *BIO_new_from_core_bio(OSSL_LIB_CTX *libctx, OSSL_CORE_BIO *corebio);
-# ifndef OPENSSL_NO_STDIO
-BIO *BIO_new_fp(FILE *stream, int close_flag);
-# endif
-BIO *BIO_new_ex(OSSL_LIB_CTX *libctx, const BIO_METHOD *method);
-BIO *BIO_new(const BIO_METHOD *type);
-int BIO_free(BIO *a);
-void BIO_set_data(BIO *a, void *ptr);
-void *BIO_get_data(BIO *a);
-void BIO_set_init(BIO *a, int init);
-int BIO_get_init(BIO *a);
-void BIO_set_shutdown(BIO *a, int shut);
-int BIO_get_shutdown(BIO *a);
-void BIO_vfree(BIO *a);
-int BIO_up_ref(BIO *a);
-int BIO_read(BIO *b, void *data, int dlen);
-int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes);
-int BIO_gets(BIO *bp, char *buf, int size);
-int BIO_get_line(BIO *bio, char *buf, int size);
-int BIO_write(BIO *b, const void *data, int dlen);
-int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written);
-int BIO_puts(BIO *bp, const char *buf);
-int BIO_indent(BIO *b, int indent, int max);
-long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg);
-long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
-void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
-long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
-BIO *BIO_push(BIO *b, BIO *append);
-BIO *BIO_pop(BIO *b);
-void BIO_free_all(BIO *a);
-BIO *BIO_find_type(BIO *b, int bio_type);
-BIO *BIO_next(BIO *b);
-void BIO_set_next(BIO *b, BIO *next);
-BIO *BIO_get_retry_BIO(BIO *bio, int *reason);
-int BIO_get_retry_reason(BIO *bio);
-void BIO_set_retry_reason(BIO *bio, int reason);
-BIO *BIO_dup_chain(BIO *in);
-
-int BIO_nread0(BIO *bio, char **buf);
-int BIO_nread(BIO *bio, char **buf, int num);
-int BIO_nwrite0(BIO *bio, char **buf);
-int BIO_nwrite(BIO *bio, char **buf, int num);
-
-const BIO_METHOD *BIO_s_mem(void);
-const BIO_METHOD *BIO_s_secmem(void);
-BIO *BIO_new_mem_buf(const void *buf, int len);
-# ifndef OPENSSL_NO_SOCK
-const BIO_METHOD *BIO_s_socket(void);
-const BIO_METHOD *BIO_s_connect(void);
-const BIO_METHOD *BIO_s_accept(void);
-# endif
-const BIO_METHOD *BIO_s_fd(void);
-const BIO_METHOD *BIO_s_log(void);
-const BIO_METHOD *BIO_s_bio(void);
-const BIO_METHOD *BIO_s_null(void);
-const BIO_METHOD *BIO_f_null(void);
-const BIO_METHOD *BIO_f_buffer(void);
-const BIO_METHOD *BIO_f_readbuffer(void);
-const BIO_METHOD *BIO_f_linebuffer(void);
-const BIO_METHOD *BIO_f_nbio_test(void);
-const BIO_METHOD *BIO_f_prefix(void);
-const BIO_METHOD *BIO_s_core(void);
-# ifndef OPENSSL_NO_DGRAM
-const BIO_METHOD *BIO_s_datagram(void);
-int BIO_dgram_non_fatal_error(int error);
-BIO *BIO_new_dgram(int fd, int close_flag);
-#  ifndef OPENSSL_NO_SCTP
-const BIO_METHOD *BIO_s_datagram_sctp(void);
-BIO *BIO_new_dgram_sctp(int fd, int close_flag);
-int BIO_dgram_is_sctp(BIO *bio);
-int BIO_dgram_sctp_notification_cb(BIO *b,
-                BIO_dgram_sctp_notification_handler_fn handle_notifications,
-                void *context);
-int BIO_dgram_sctp_wait_for_dry(BIO *b);
-int BIO_dgram_sctp_msg_waiting(BIO *b);
-#  endif
-# endif
-
-# ifndef OPENSSL_NO_SOCK
-int BIO_sock_should_retry(int i);
-int BIO_sock_non_fatal_error(int error);
-int BIO_socket_wait(int fd, int for_read, time_t max_time);
-# endif
-int BIO_wait(BIO *bio, time_t max_time, unsigned int nap_milliseconds);
-int BIO_do_connect_retry(BIO *bio, int timeout, int nap_milliseconds);
-
-int BIO_fd_should_retry(int i);
-int BIO_fd_non_fatal_error(int error);
-int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u),
-                void *u, const void *s, int len);
-int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u),
-                       void *u, const void *s, int len, int indent);
-int BIO_dump(BIO *b, const void *bytes, int len);
-int BIO_dump_indent(BIO *b, const void *bytes, int len, int indent);
-# ifndef OPENSSL_NO_STDIO
-int BIO_dump_fp(FILE *fp, const void *s, int len);
-int BIO_dump_indent_fp(FILE *fp, const void *s, int len, int indent);
-# endif
-int BIO_hex_string(BIO *out, int indent, int width, const void *data,
-                   int datalen);
-
-# ifndef OPENSSL_NO_SOCK
-BIO_ADDR *BIO_ADDR_new(void);
-int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
-                     const void *where, size_t wherelen, unsigned short port);
-void BIO_ADDR_free(BIO_ADDR *);
-void BIO_ADDR_clear(BIO_ADDR *ap);
-int BIO_ADDR_family(const BIO_ADDR *ap);
-int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l);
-unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap);
-char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric);
-char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric);
-char *BIO_ADDR_path_string(const BIO_ADDR *ap);
-
-const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai);
-int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai);
-int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai);
-int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai);
-const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai);
-void BIO_ADDRINFO_free(BIO_ADDRINFO *bai);
-
-enum BIO_hostserv_priorities {
-    BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV
-};
-int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
-                       enum BIO_hostserv_priorities hostserv_prio);
-enum BIO_lookup_type {
-    BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER
-};
-int BIO_lookup(const char *host, const char *service,
-               enum BIO_lookup_type lookup_type,
-               int family, int socktype, BIO_ADDRINFO **res);
-int BIO_lookup_ex(const char *host, const char *service,
-                  int lookup_type, int family, int socktype, int protocol,
-                  BIO_ADDRINFO **res);
-int BIO_sock_error(int sock);
-int BIO_socket_ioctl(int fd, long type, void *arg);
-int BIO_socket_nbio(int fd, int mode);
-int BIO_sock_init(void);
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define BIO_sock_cleanup() while(0) continue
-# endif
-int BIO_set_tcp_ndelay(int sock, int turn_on);
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 struct hostent *BIO_gethostbyname(const char *name);
-OSSL_DEPRECATEDIN_1_1_0 int BIO_get_port(const char *str, unsigned short *port_ptr);
-OSSL_DEPRECATEDIN_1_1_0 int BIO_get_host_ip(const char *str, unsigned char *ip);
-OSSL_DEPRECATEDIN_1_1_0 int BIO_get_accept_socket(char *host_port, int mode);
-OSSL_DEPRECATEDIN_1_1_0 int BIO_accept(int sock, char **ip_port);
-# endif
-
-union BIO_sock_info_u {
-    BIO_ADDR *addr;
-};
-enum BIO_sock_info_type {
-    BIO_SOCK_INFO_ADDRESS
-};
-int BIO_sock_info(int sock,
-                  enum BIO_sock_info_type type, union BIO_sock_info_u *info);
-
-#  define BIO_SOCK_REUSEADDR    0x01
-#  define BIO_SOCK_V6_ONLY      0x02
-#  define BIO_SOCK_KEEPALIVE    0x04
-#  define BIO_SOCK_NONBLOCK     0x08
-#  define BIO_SOCK_NODELAY      0x10
-
-int BIO_socket(int domain, int socktype, int protocol, int options);
-int BIO_connect(int sock, const BIO_ADDR *addr, int options);
-int BIO_bind(int sock, const BIO_ADDR *addr, int options);
-int BIO_listen(int sock, const BIO_ADDR *addr, int options);
-int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options);
-int BIO_closesocket(int sock);
-
-BIO *BIO_new_socket(int sock, int close_flag);
-BIO *BIO_new_connect(const char *host_port);
-BIO *BIO_new_accept(const char *host_port);
-# endif /* OPENSSL_NO_SOCK*/
-
-BIO *BIO_new_fd(int fd, int close_flag);
-
-int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
-                     BIO **bio2, size_t writebuf2);
-/*
- * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints.
- * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default
- * value.
- */
+    int BIO_set_ex_data(BIO* bio, int idx, void* data);
+    void* BIO_get_ex_data(const BIO* bio, int idx);
+    uint64_t BIO_number_read(BIO* bio);
+    uint64_t BIO_number_written(BIO* bio);
+
+    /* For BIO_f_asn1() */
+    int BIO_asn1_set_prefix(BIO* b, asn1_ps_func* prefix, asn1_ps_func* prefix_free);
+    int BIO_asn1_get_prefix(BIO* b, asn1_ps_func** pprefix, asn1_ps_func** pprefix_free);
+    int BIO_asn1_set_suffix(BIO* b, asn1_ps_func* suffix, asn1_ps_func* suffix_free);
+    int BIO_asn1_get_suffix(BIO* b, asn1_ps_func** psuffix, asn1_ps_func** psuffix_free);
+
+    const BIO_METHOD* BIO_s_file(void);
+    BIO* BIO_new_file(const char* filename, const char* mode);
+    BIO* BIO_new_from_core_bio(OSSL_LIB_CTX* libctx, OSSL_CORE_BIO* corebio);
+#ifndef OPENSSL_NO_STDIO
+    BIO* BIO_new_fp(FILE* stream, int close_flag);
+#endif
+    BIO* BIO_new_ex(OSSL_LIB_CTX* libctx, const BIO_METHOD* method);
+    BIO* BIO_new(const BIO_METHOD* type);
+    int BIO_free(BIO* a);
+    void BIO_set_data(BIO* a, void* ptr);
+    void* BIO_get_data(BIO* a);
+    void BIO_set_init(BIO* a, int init);
+    int BIO_get_init(BIO* a);
+    void BIO_set_shutdown(BIO* a, int shut);
+    int BIO_get_shutdown(BIO* a);
+    void BIO_vfree(BIO* a);
+    int BIO_up_ref(BIO* a);
+    int BIO_read(BIO* b, void* data, int dlen);
+    int BIO_read_ex(BIO* b, void* data, size_t dlen, size_t* readbytes);
+    int BIO_gets(BIO* bp, char* buf, int size);
+    int BIO_get_line(BIO* bio, char* buf, int size);
+    int BIO_write(BIO* b, const void* data, int dlen);
+    int BIO_write_ex(BIO* b, const void* data, size_t dlen, size_t* written);
+    int BIO_puts(BIO* bp, const char* buf);
+    int BIO_indent(BIO* b, int indent, int max);
+    long BIO_ctrl(BIO* bp, int cmd, long larg, void* parg);
+    long BIO_callback_ctrl(BIO* b, int cmd, BIO_info_cb* fp);
+    void* BIO_ptr_ctrl(BIO* bp, int cmd, long larg);
+    long BIO_int_ctrl(BIO* bp, int cmd, long larg, int iarg);
+    BIO* BIO_push(BIO* b, BIO* append);
+    BIO* BIO_pop(BIO* b);
+    void BIO_free_all(BIO* a);
+    BIO* BIO_find_type(BIO* b, int bio_type);
+    BIO* BIO_next(BIO* b);
+    void BIO_set_next(BIO* b, BIO* next);
+    BIO* BIO_get_retry_BIO(BIO* bio, int* reason);
+    int BIO_get_retry_reason(BIO* bio);
+    void BIO_set_retry_reason(BIO* bio, int reason);
+    BIO* BIO_dup_chain(BIO* in);
+
+    int BIO_nread0(BIO* bio, char** buf);
+    int BIO_nread(BIO* bio, char** buf, int num);
+    int BIO_nwrite0(BIO* bio, char** buf);
+    int BIO_nwrite(BIO* bio, char** buf, int num);
+
+    const BIO_METHOD* BIO_s_mem(void);
+    const BIO_METHOD* BIO_s_secmem(void);
+    BIO* BIO_new_mem_buf(const void* buf, int len);
+#ifndef OPENSSL_NO_SOCK
+    const BIO_METHOD* BIO_s_socket(void);
+    const BIO_METHOD* BIO_s_connect(void);
+    const BIO_METHOD* BIO_s_accept(void);
+#endif
+    const BIO_METHOD* BIO_s_fd(void);
+    const BIO_METHOD* BIO_s_log(void);
+    const BIO_METHOD* BIO_s_bio(void);
+    const BIO_METHOD* BIO_s_null(void);
+    const BIO_METHOD* BIO_f_null(void);
+    const BIO_METHOD* BIO_f_buffer(void);
+    const BIO_METHOD* BIO_f_readbuffer(void);
+    const BIO_METHOD* BIO_f_linebuffer(void);
+    const BIO_METHOD* BIO_f_nbio_test(void);
+    const BIO_METHOD* BIO_f_prefix(void);
+    const BIO_METHOD* BIO_s_core(void);
+#ifndef OPENSSL_NO_DGRAM
+    const BIO_METHOD* BIO_s_datagram(void);
+    int BIO_dgram_non_fatal_error(int error);
+    BIO* BIO_new_dgram(int fd, int close_flag);
+#ifndef OPENSSL_NO_SCTP
+    const BIO_METHOD* BIO_s_datagram_sctp(void);
+    BIO* BIO_new_dgram_sctp(int fd, int close_flag);
+    int BIO_dgram_is_sctp(BIO* bio);
+    int BIO_dgram_sctp_notification_cb(BIO* b, BIO_dgram_sctp_notification_handler_fn handle_notifications, void* context);
+    int BIO_dgram_sctp_wait_for_dry(BIO* b);
+    int BIO_dgram_sctp_msg_waiting(BIO* b);
+#endif
+#endif
 
-void BIO_copy_next_retry(BIO *b);
+#ifndef OPENSSL_NO_SOCK
+    int BIO_sock_should_retry(int i);
+    int BIO_sock_non_fatal_error(int error);
+    int BIO_socket_wait(int fd, int for_read, time_t max_time);
+#endif
+    int BIO_wait(BIO* bio, time_t max_time, unsigned int nap_milliseconds);
+    int BIO_do_connect_retry(BIO* bio, int timeout, int nap_milliseconds);
+
+    int BIO_fd_should_retry(int i);
+    int BIO_fd_non_fatal_error(int error);
+    int BIO_dump_cb(int (*cb)(const void* data, size_t len, void* u), void* u, const void* s, int len);
+    int BIO_dump_indent_cb(int (*cb)(const void* data, size_t len, void* u), void* u, const void* s, int len, int indent);
+    int BIO_dump(BIO* b, const void* bytes, int len);
+    int BIO_dump_indent(BIO* b, const void* bytes, int len, int indent);
+#ifndef OPENSSL_NO_STDIO
+    int BIO_dump_fp(FILE* fp, const void* s, int len);
+    int BIO_dump_indent_fp(FILE* fp, const void* s, int len, int indent);
+#endif
+    int BIO_hex_string(BIO* out, int indent, int width, const void* data, int datalen);
+
+#ifndef OPENSSL_NO_SOCK
+    BIO_ADDR* BIO_ADDR_new(void);
+    int BIO_ADDR_rawmake(BIO_ADDR* ap, int family, const void* where, size_t wherelen, unsigned short port);
+    void BIO_ADDR_free(BIO_ADDR*);
+    void BIO_ADDR_clear(BIO_ADDR* ap);
+    int BIO_ADDR_family(const BIO_ADDR* ap);
+    int BIO_ADDR_rawaddress(const BIO_ADDR* ap, void* p, size_t* l);
+    unsigned short BIO_ADDR_rawport(const BIO_ADDR* ap);
+    char* BIO_ADDR_hostname_string(const BIO_ADDR* ap, int numeric);
+    char* BIO_ADDR_service_string(const BIO_ADDR* ap, int numeric);
+    char* BIO_ADDR_path_string(const BIO_ADDR* ap);
+
+    const BIO_ADDRINFO* BIO_ADDRINFO_next(const BIO_ADDRINFO* bai);
+    int BIO_ADDRINFO_family(const BIO_ADDRINFO* bai);
+    int BIO_ADDRINFO_socktype(const BIO_ADDRINFO* bai);
+    int BIO_ADDRINFO_protocol(const BIO_ADDRINFO* bai);
+    const BIO_ADDR* BIO_ADDRINFO_address(const BIO_ADDRINFO* bai);
+    void BIO_ADDRINFO_free(BIO_ADDRINFO* bai);
+
+    enum BIO_hostserv_priorities
+    {
+        BIO_PARSE_PRIO_HOST,
+        BIO_PARSE_PRIO_SERV
+    };
+    int BIO_parse_hostserv(const char* hostserv, char** host, char** service, enum BIO_hostserv_priorities hostserv_prio);
+    enum BIO_lookup_type
+    {
+        BIO_LOOKUP_CLIENT,
+        BIO_LOOKUP_SERVER
+    };
+    int BIO_lookup(const char* host, const char* service, enum BIO_lookup_type lookup_type, int family, int socktype, BIO_ADDRINFO** res);
+    int BIO_lookup_ex(const char* host, const char* service, int lookup_type, int family, int socktype, int protocol, BIO_ADDRINFO** res);
+    int BIO_sock_error(int sock);
+    int BIO_socket_ioctl(int fd, long type, void* arg);
+    int BIO_socket_nbio(int fd, int mode);
+    int BIO_sock_init(void);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define BIO_sock_cleanup() \
+    while (0)              \
+    continue
+#endif
+    int BIO_set_tcp_ndelay(int sock, int turn_on);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 struct hostent* BIO_gethostbyname(const char* name);
+    OSSL_DEPRECATEDIN_1_1_0 int BIO_get_port(const char* str, unsigned short* port_ptr);
+    OSSL_DEPRECATEDIN_1_1_0 int BIO_get_host_ip(const char* str, unsigned char* ip);
+    OSSL_DEPRECATEDIN_1_1_0 int BIO_get_accept_socket(char* host_port, int mode);
+    OSSL_DEPRECATEDIN_1_1_0 int BIO_accept(int sock, char** ip_port);
+#endif
 
-/*
- * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);
- */
+    union BIO_sock_info_u
+    {
+        BIO_ADDR* addr;
+    };
+    enum BIO_sock_info_type
+    {
+        BIO_SOCK_INFO_ADDRESS
+    };
+    int BIO_sock_info(int sock, enum BIO_sock_info_type type, union BIO_sock_info_u* info);
+
+#define BIO_SOCK_REUSEADDR 0x01
+#define BIO_SOCK_V6_ONLY 0x02
+#define BIO_SOCK_KEEPALIVE 0x04
+#define BIO_SOCK_NONBLOCK 0x08
+#define BIO_SOCK_NODELAY 0x10
+
+    int BIO_socket(int domain, int socktype, int protocol, int options);
+    int BIO_connect(int sock, const BIO_ADDR* addr, int options);
+    int BIO_bind(int sock, const BIO_ADDR* addr, int options);
+    int BIO_listen(int sock, const BIO_ADDR* addr, int options);
+    int BIO_accept_ex(int accept_sock, BIO_ADDR* addr, int options);
+    int BIO_closesocket(int sock);
+
+    BIO* BIO_new_socket(int sock, int close_flag);
+    BIO* BIO_new_connect(const char* host_port);
+    BIO* BIO_new_accept(const char* host_port);
+#endif /* OPENSSL_NO_SOCK*/
+
+    BIO* BIO_new_fd(int fd, int close_flag);
+
+    int BIO_new_bio_pair(BIO** bio1, size_t writebuf1, BIO** bio2, size_t writebuf2);
+    /*
+     * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints.
+     * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default
+     * value.
+     */
+
+    void BIO_copy_next_retry(BIO* b);
 
-# define ossl_bio__attr__(x)
-# if defined(__GNUC__) && defined(__STDC_VERSION__) \
-    && !defined(__APPLE__)
+    /*
+     * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);
+     */
+
+#define ossl_bio__attr__(x)
+#if defined(__GNUC__) && defined(__STDC_VERSION__) && !defined(__APPLE__)
     /*
      * Because we support the 'z' modifier, which made its appearance in C99,
      * we can't use __attribute__ with pre C99 dialects.
      */
-#  if __STDC_VERSION__ >= 199901L
-#   undef ossl_bio__attr__
-#   define ossl_bio__attr__ __attribute__
-#   if __GNUC__*10 + __GNUC_MINOR__ >= 44
-#    define ossl_bio__printf__ __gnu_printf__
-#   else
-#    define ossl_bio__printf__ __printf__
-#   endif
-#  endif
-# endif
-int BIO_printf(BIO *bio, const char *format, ...)
-ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3)));
-int BIO_vprintf(BIO *bio, const char *format, va_list args)
-ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0)));
-int BIO_snprintf(char *buf, size_t n, const char *format, ...)
-ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4)));
-int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
-ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0)));
-# undef ossl_bio__attr__
-# undef ossl_bio__printf__
-
-
-BIO_METHOD *BIO_meth_new(int type, const char *name);
-void BIO_meth_free(BIO_METHOD *biom);
-int (*BIO_meth_get_write(const BIO_METHOD *biom)) (BIO *, const char *, int);
-int (*BIO_meth_get_write_ex(const BIO_METHOD *biom)) (BIO *, const char *, size_t,
-                                                size_t *);
-int BIO_meth_set_write(BIO_METHOD *biom,
-                       int (*write) (BIO *, const char *, int));
-int BIO_meth_set_write_ex(BIO_METHOD *biom,
-                       int (*bwrite) (BIO *, const char *, size_t, size_t *));
-int (*BIO_meth_get_read(const BIO_METHOD *biom)) (BIO *, char *, int);
-int (*BIO_meth_get_read_ex(const BIO_METHOD *biom)) (BIO *, char *, size_t, size_t *);
-int BIO_meth_set_read(BIO_METHOD *biom,
-                      int (*read) (BIO *, char *, int));
-int BIO_meth_set_read_ex(BIO_METHOD *biom,
-                         int (*bread) (BIO *, char *, size_t, size_t *));
-int (*BIO_meth_get_puts(const BIO_METHOD *biom)) (BIO *, const char *);
-int BIO_meth_set_puts(BIO_METHOD *biom,
-                      int (*puts) (BIO *, const char *));
-int (*BIO_meth_get_gets(const BIO_METHOD *biom)) (BIO *, char *, int);
-int BIO_meth_set_gets(BIO_METHOD *biom,
-                      int (*gets) (BIO *, char *, int));
-long (*BIO_meth_get_ctrl(const BIO_METHOD *biom)) (BIO *, int, long, void *);
-int BIO_meth_set_ctrl(BIO_METHOD *biom,
-                      long (*ctrl) (BIO *, int, long, void *));
-int (*BIO_meth_get_create(const BIO_METHOD *bion)) (BIO *);
-int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *));
-int (*BIO_meth_get_destroy(const BIO_METHOD *biom)) (BIO *);
-int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *));
-long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom))
-                                 (BIO *, int, BIO_info_cb *);
-int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
-                               long (*callback_ctrl) (BIO *, int,
-                                                      BIO_info_cb *));
-
-# ifdef  __cplusplus
+#if __STDC_VERSION__ >= 199901L
+#undef ossl_bio__attr__
+#define ossl_bio__attr__ __attribute__
+#if __GNUC__ * 10 + __GNUC_MINOR__ >= 44
+#define ossl_bio__printf__ __gnu_printf__
+#else
+#define ossl_bio__printf__ __printf__
+#endif
+#endif
+#endif
+    int BIO_printf(BIO* bio, const char* format, ...)
+        ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3)));
+    int BIO_vprintf(BIO* bio, const char* format, va_list args)
+        ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0)));
+    int BIO_snprintf(char* buf, size_t n, const char* format, ...)
+        ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4)));
+    int BIO_vsnprintf(char* buf, size_t n, const char* format, va_list args)
+        ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0)));
+#undef ossl_bio__attr__
+#undef ossl_bio__printf__
+
+    BIO_METHOD* BIO_meth_new(int type, const char* name);
+    void BIO_meth_free(BIO_METHOD* biom);
+    int (*BIO_meth_get_write(const BIO_METHOD* biom))(BIO*, const char*, int);
+    int (*BIO_meth_get_write_ex(const BIO_METHOD* biom))(BIO*, const char*, size_t, size_t*);
+    int BIO_meth_set_write(BIO_METHOD* biom, int (*write)(BIO*, const char*, int));
+    int BIO_meth_set_write_ex(BIO_METHOD* biom, int (*bwrite)(BIO*, const char*, size_t, size_t*));
+    int (*BIO_meth_get_read(const BIO_METHOD* biom))(BIO*, char*, int);
+    int (*BIO_meth_get_read_ex(const BIO_METHOD* biom))(BIO*, char*, size_t, size_t*);
+    int BIO_meth_set_read(BIO_METHOD* biom, int (*read)(BIO*, char*, int));
+    int BIO_meth_set_read_ex(BIO_METHOD* biom, int (*bread)(BIO*, char*, size_t, size_t*));
+    int (*BIO_meth_get_puts(const BIO_METHOD* biom))(BIO*, const char*);
+    int BIO_meth_set_puts(BIO_METHOD* biom, int (*puts)(BIO*, const char*));
+    int (*BIO_meth_get_gets(const BIO_METHOD* biom))(BIO*, char*, int);
+    int BIO_meth_set_gets(BIO_METHOD* biom, int (*gets)(BIO*, char*, int));
+    long (*BIO_meth_get_ctrl(const BIO_METHOD* biom))(BIO*, int, long, void*);
+    int BIO_meth_set_ctrl(BIO_METHOD* biom, long (*ctrl)(BIO*, int, long, void*));
+    int (*BIO_meth_get_create(const BIO_METHOD* bion))(BIO*);
+    int BIO_meth_set_create(BIO_METHOD* biom, int (*create)(BIO*));
+    int (*BIO_meth_get_destroy(const BIO_METHOD* biom))(BIO*);
+    int BIO_meth_set_destroy(BIO_METHOD* biom, int (*destroy)(BIO*));
+    long (*BIO_meth_get_callback_ctrl(const BIO_METHOD* biom))(BIO*, int, BIO_info_cb*);
+    int BIO_meth_set_callback_ctrl(BIO_METHOD* biom, long (*callback_ctrl)(BIO*, int, BIO_info_cb*));
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/bioerr.h b/CAPI/cpp/grpc/include/openssl/bioerr.h
index 787b30a..9eadaf2 100644
--- a/CAPI/cpp/grpc/include/openssl/bioerr.h
+++ b/CAPI/cpp/grpc/include/openssl/bioerr.h
@@ -9,57 +9,55 @@
  */
 
 #ifndef OPENSSL_BIOERR_H
-# define OPENSSL_BIOERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_BIOERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * BIO reason codes.
  */
-# define BIO_R_ACCEPT_ERROR                               100
-# define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET               141
-# define BIO_R_AMBIGUOUS_HOST_OR_SERVICE                  129
-# define BIO_R_BAD_FOPEN_MODE                             101
-# define BIO_R_BROKEN_PIPE                                124
-# define BIO_R_CONNECT_ERROR                              103
-# define BIO_R_CONNECT_TIMEOUT                            147
-# define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET          107
-# define BIO_R_GETSOCKNAME_ERROR                          132
-# define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS              133
-# define BIO_R_GETTING_SOCKTYPE                           134
-# define BIO_R_INVALID_ARGUMENT                           125
-# define BIO_R_INVALID_SOCKET                             135
-# define BIO_R_IN_USE                                     123
-# define BIO_R_LENGTH_TOO_LONG                            102
-# define BIO_R_LISTEN_V6_ONLY                             136
-# define BIO_R_LOOKUP_RETURNED_NOTHING                    142
-# define BIO_R_MALFORMED_HOST_OR_SERVICE                  130
-# define BIO_R_NBIO_CONNECT_ERROR                         110
-# define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED        143
-# define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED           144
-# define BIO_R_NO_PORT_DEFINED                            113
-# define BIO_R_NO_SUCH_FILE                               128
-# define BIO_R_NULL_PARAMETER                             115 /* unused */
-# define BIO_R_TRANSFER_ERROR                             104
-# define BIO_R_TRANSFER_TIMEOUT                           105
-# define BIO_R_UNABLE_TO_BIND_SOCKET                      117
-# define BIO_R_UNABLE_TO_CREATE_SOCKET                    118
-# define BIO_R_UNABLE_TO_KEEPALIVE                        137
-# define BIO_R_UNABLE_TO_LISTEN_SOCKET                    119
-# define BIO_R_UNABLE_TO_NODELAY                          138
-# define BIO_R_UNABLE_TO_REUSEADDR                        139
-# define BIO_R_UNAVAILABLE_IP_FAMILY                      145
-# define BIO_R_UNINITIALIZED                              120
-# define BIO_R_UNKNOWN_INFO_TYPE                          140
-# define BIO_R_UNSUPPORTED_IP_FAMILY                      146
-# define BIO_R_UNSUPPORTED_METHOD                         121
-# define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY                131
-# define BIO_R_WRITE_TO_READ_ONLY_BIO                     126
-# define BIO_R_WSASTARTUP                                 122
+#define BIO_R_ACCEPT_ERROR 100
+#define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET 141
+#define BIO_R_AMBIGUOUS_HOST_OR_SERVICE 129
+#define BIO_R_BAD_FOPEN_MODE 101
+#define BIO_R_BROKEN_PIPE 124
+#define BIO_R_CONNECT_ERROR 103
+#define BIO_R_CONNECT_TIMEOUT 147
+#define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107
+#define BIO_R_GETSOCKNAME_ERROR 132
+#define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS 133
+#define BIO_R_GETTING_SOCKTYPE 134
+#define BIO_R_INVALID_ARGUMENT 125
+#define BIO_R_INVALID_SOCKET 135
+#define BIO_R_IN_USE 123
+#define BIO_R_LENGTH_TOO_LONG 102
+#define BIO_R_LISTEN_V6_ONLY 136
+#define BIO_R_LOOKUP_RETURNED_NOTHING 142
+#define BIO_R_MALFORMED_HOST_OR_SERVICE 130
+#define BIO_R_NBIO_CONNECT_ERROR 110
+#define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED 143
+#define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED 144
+#define BIO_R_NO_PORT_DEFINED 113
+#define BIO_R_NO_SUCH_FILE 128
+#define BIO_R_NULL_PARAMETER 115 /* unused */
+#define BIO_R_TRANSFER_ERROR 104
+#define BIO_R_TRANSFER_TIMEOUT 105
+#define BIO_R_UNABLE_TO_BIND_SOCKET 117
+#define BIO_R_UNABLE_TO_CREATE_SOCKET 118
+#define BIO_R_UNABLE_TO_KEEPALIVE 137
+#define BIO_R_UNABLE_TO_LISTEN_SOCKET 119
+#define BIO_R_UNABLE_TO_NODELAY 138
+#define BIO_R_UNABLE_TO_REUSEADDR 139
+#define BIO_R_UNAVAILABLE_IP_FAMILY 145
+#define BIO_R_UNINITIALIZED 120
+#define BIO_R_UNKNOWN_INFO_TYPE 140
+#define BIO_R_UNSUPPORTED_IP_FAMILY 146
+#define BIO_R_UNSUPPORTED_METHOD 121
+#define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY 131
+#define BIO_R_WRITE_TO_READ_ONLY_BIO 126
+#define BIO_R_WSASTARTUP 122
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/blowfish.h b/CAPI/cpp/grpc/include/openssl/blowfish.h
index 667d642..535c2db 100644
--- a/CAPI/cpp/grpc/include/openssl/blowfish.h
+++ b/CAPI/cpp/grpc/include/openssl/blowfish.h
@@ -8,71 +8,60 @@
  */
 
 #ifndef OPENSSL_BLOWFISH_H
-# define OPENSSL_BLOWFISH_H
-# pragma once
+#define OPENSSL_BLOWFISH_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_BLOWFISH_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_BLOWFISH_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_BF
-# include <openssl/e_os2.h>
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifndef OPENSSL_NO_BF
+#include <openssl/e_os2.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# define BF_BLOCK        8
+#define BF_BLOCK 8
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 
-#  define BF_ENCRYPT      1
-#  define BF_DECRYPT      0
+#define BF_ENCRYPT 1
+#define BF_DECRYPT 0
 
 /*-
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  * ! BF_LONG has to be at least 32 bits wide.                     !
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  */
-#  define BF_LONG unsigned int
+#define BF_LONG unsigned int
 
-#  define BF_ROUNDS       16
+#define BF_ROUNDS 16
 
-typedef struct bf_key_st {
-    BF_LONG P[BF_ROUNDS + 2];
-    BF_LONG S[4 * 256];
-} BF_KEY;
+    typedef struct bf_key_st
+    {
+        BF_LONG P[BF_ROUNDS + 2];
+        BF_LONG S[4 * 256];
+    } BF_KEY;
 
-# endif /* OPENSSL_NO_DEPRECATED_3_0 */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 void BF_set_key(BF_KEY *key, int len,
-                                      const unsigned char *data);
-OSSL_DEPRECATEDIN_3_0 void BF_encrypt(BF_LONG *data, const BF_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void BF_decrypt(BF_LONG *data, const BF_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void BF_ecb_encrypt(const unsigned char *in,
-                                          unsigned char *out, const BF_KEY *key,
-                                          int enc);
-OSSL_DEPRECATEDIN_3_0 void BF_cbc_encrypt(const unsigned char *in,
-                                          unsigned char *out, long length,
-                                          const BF_KEY *schedule,
-                                          unsigned char *ivec, int enc);
-OSSL_DEPRECATEDIN_3_0 void BF_cfb64_encrypt(const unsigned char *in,
-                                            unsigned char *out,
-                                            long length, const BF_KEY *schedule,
-                                            unsigned char *ivec, int *num,
-                                            int enc);
-OSSL_DEPRECATEDIN_3_0 void BF_ofb64_encrypt(const unsigned char *in,
-                                            unsigned char *out,
-                                            long length, const BF_KEY *schedule,
-                                            unsigned char *ivec, int *num);
-OSSL_DEPRECATEDIN_3_0 const char *BF_options(void);
-# endif
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 void BF_set_key(BF_KEY* key, int len, const unsigned char* data);
+    OSSL_DEPRECATEDIN_3_0 void BF_encrypt(BF_LONG* data, const BF_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void BF_decrypt(BF_LONG* data, const BF_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void BF_ecb_encrypt(const unsigned char* in, unsigned char* out, const BF_KEY* key, int enc);
+    OSSL_DEPRECATEDIN_3_0 void BF_cbc_encrypt(const unsigned char* in, unsigned char* out, long length, const BF_KEY* schedule, unsigned char* ivec, int enc);
+    OSSL_DEPRECATEDIN_3_0 void BF_cfb64_encrypt(const unsigned char* in, unsigned char* out, long length, const BF_KEY* schedule, unsigned char* ivec, int* num, int enc);
+    OSSL_DEPRECATEDIN_3_0 void BF_ofb64_encrypt(const unsigned char* in, unsigned char* out, long length, const BF_KEY* schedule, unsigned char* ivec, int* num);
+    OSSL_DEPRECATEDIN_3_0 const char* BF_options(void);
+#endif
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/bn.h b/CAPI/cpp/grpc/include/openssl/bn.h
index ecd7f01..4eeefac 100644
--- a/CAPI/cpp/grpc/include/openssl/bn.h
+++ b/CAPI/cpp/grpc/include/openssl/bn.h
@@ -9,54 +9,55 @@
  */
 
 #ifndef OPENSSL_BN_H
-# define OPENSSL_BN_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_BN_H
-# endif
-
-# include <openssl/e_os2.h>
-# ifndef OPENSSL_NO_STDIO
-#  include <stdio.h>
-# endif
-# include <openssl/opensslconf.h>
-# include <openssl/types.h>
-# include <openssl/crypto.h>
-# include <openssl/bnerr.h>
-
-#ifdef  __cplusplus
-extern "C" {
+#define OPENSSL_BN_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_BN_H
+#endif
+
+#include <openssl/e_os2.h>
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#endif
+#include <openssl/opensslconf.h>
+#include <openssl/types.h>
+#include <openssl/crypto.h>
+#include <openssl/bnerr.h>
+
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 /*
  * 64-bit processor with LP64 ABI
  */
-# ifdef SIXTY_FOUR_BIT_LONG
-#  define BN_ULONG        unsigned long
-#  define BN_BYTES        8
-# endif
+#ifdef SIXTY_FOUR_BIT_LONG
+#define BN_ULONG unsigned long
+#define BN_BYTES 8
+#endif
 
 /*
  * 64-bit processor other than LP64 ABI
  */
-# ifdef SIXTY_FOUR_BIT
-#  define BN_ULONG        unsigned long long
-#  define BN_BYTES        8
-# endif
+#ifdef SIXTY_FOUR_BIT
+#define BN_ULONG unsigned long long
+#define BN_BYTES 8
+#endif
 
-# ifdef THIRTY_TWO_BIT
-#  define BN_ULONG        unsigned int
-#  define BN_BYTES        4
-# endif
+#ifdef THIRTY_TWO_BIT
+#define BN_ULONG unsigned int
+#define BN_BYTES 4
+#endif
 
-# define BN_BITS2       (BN_BYTES * 8)
-# define BN_BITS        (BN_BITS2 * 2)
-# define BN_TBIT        ((BN_ULONG)1 << (BN_BITS2 - 1))
+#define BN_BITS2 (BN_BYTES * 8)
+#define BN_BITS (BN_BITS2 * 2)
+#define BN_TBIT ((BN_ULONG)1 << (BN_BITS2 - 1))
 
-# define BN_FLG_MALLOCED         0x01
-# define BN_FLG_STATIC_DATA      0x02
+#define BN_FLG_MALLOCED 0x01
+#define BN_FLG_STATIC_DATA 0x02
 
 /*
  * avoid leaking exponent information through timing,
@@ -64,520 +65,443 @@ extern "C" {
  * BN_div() will call BN_div_no_branch,
  * BN_mod_inverse() will call bn_mod_inverse_no_branch.
  */
-# define BN_FLG_CONSTTIME        0x04
-# define BN_FLG_SECURE           0x08
+#define BN_FLG_CONSTTIME 0x04
+#define BN_FLG_SECURE 0x08
 
-# ifndef OPENSSL_NO_DEPRECATED_0_9_8
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
 /* deprecated name for the flag */
-#  define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME
-#  define BN_FLG_FREE            0x8000 /* used for debugging */
-# endif
+#define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME
+#define BN_FLG_FREE 0x8000 /* used for debugging */
+#endif
 
-void BN_set_flags(BIGNUM *b, int n);
-int BN_get_flags(const BIGNUM *b, int n);
+    void BN_set_flags(BIGNUM* b, int n);
+    int BN_get_flags(const BIGNUM* b, int n);
 
 /* Values for |top| in BN_rand() */
-#define BN_RAND_TOP_ANY    -1
-#define BN_RAND_TOP_ONE     0
-#define BN_RAND_TOP_TWO     1
+#define BN_RAND_TOP_ANY -1
+#define BN_RAND_TOP_ONE 0
+#define BN_RAND_TOP_TWO 1
 
 /* Values for |bottom| in BN_rand() */
-#define BN_RAND_BOTTOM_ANY  0
-#define BN_RAND_BOTTOM_ODD  1
+#define BN_RAND_BOTTOM_ANY 0
+#define BN_RAND_BOTTOM_ODD 1
+
+    /*
+     * get a clone of a BIGNUM with changed flags, for *temporary* use only (the
+     * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The
+     * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that
+     * has not been otherwise initialised or used.
+     */
+    void BN_with_flags(BIGNUM* dest, const BIGNUM* b, int flags);
+
+    /* Wrapper function to make using BN_GENCB easier */
+    int BN_GENCB_call(BN_GENCB* cb, int a, int b);
+
+    BN_GENCB* BN_GENCB_new(void);
+    void BN_GENCB_free(BN_GENCB* cb);
+
+    /* Populate a BN_GENCB structure with an "old"-style callback */
+    void BN_GENCB_set_old(BN_GENCB* gencb, void (*callback)(int, int, void*), void* cb_arg);
+
+    /* Populate a BN_GENCB structure with a "new"-style callback */
+    void BN_GENCB_set(BN_GENCB* gencb, int (*callback)(int, int, BN_GENCB*), void* cb_arg);
+
+    void* BN_GENCB_get_arg(BN_GENCB* cb);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define BN_prime_checks 0 /* default: select number of iterations based \
+                           * on the size of the number */
+
+    /*
+     * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations
+     * that will be done for checking that a random number is probably prime. The
+     * error rate for accepting a composite number as prime depends on the size of
+     * the prime |b|. The error rates used are for calculating an RSA key with 2 primes,
+     * and so the level is what you would expect for a key of double the size of the
+     * prime.
+     *
+     * This table is generated using the algorithm of FIPS PUB 186-4
+     * Digital Signature Standard (DSS), section F.1, page 117.
+     * (https://dx.doi.org/10.6028/NIST.FIPS.186-4)
+     *
+     * The following magma script was used to generate the output:
+     * securitybits:=125;
+     * k:=1024;
+     * for t:=1 to 65 do
+     *   for M:=3 to Floor(2*Sqrt(k-1)-1) do
+     *     S:=0;
+     *     // Sum over m
+     *     for m:=3 to M do
+     *       s:=0;
+     *       // Sum over j
+     *       for j:=2 to m do
+     *         s+:=(RealField(32)!2)^-(j+(k-1)/j);
+     *       end for;
+     *       S+:=2^(m-(m-1)*t)*s;
+     *     end for;
+     *     A:=2^(k-2-M*t);
+     *     B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S;
+     *     pkt:=2.00743*Log(2)*k*2^-k*(A+B);
+     *     seclevel:=Floor(-Log(2,pkt));
+     *     if seclevel ge securitybits then
+     *       printf "k: %5o, security: %o bits  (t: %o, M: %o)\n",k,seclevel,t,M;
+     *       break;
+     *     end if;
+     *   end for;
+     *   if seclevel ge securitybits then break; end if;
+     * end for;
+     *
+     * It can be run online at:
+     * http://magma.maths.usyd.edu.au/calc
+     *
+     * And will output:
+     * k:  1024, security: 129 bits  (t: 6, M: 23)
+     *
+     * k is the number of bits of the prime, securitybits is the level we want to
+     * reach.
+     *
+     * prime length | RSA key size | # MR tests | security level
+     * -------------+--------------|------------+---------------
+     *  (b) >= 6394 |     >= 12788 |          3 |        256 bit
+     *  (b) >= 3747 |     >=  7494 |          3 |        192 bit
+     *  (b) >= 1345 |     >=  2690 |          4 |        128 bit
+     *  (b) >= 1080 |     >=  2160 |          5 |        128 bit
+     *  (b) >=  852 |     >=  1704 |          5 |        112 bit
+     *  (b) >=  476 |     >=   952 |          5 |         80 bit
+     *  (b) >=  400 |     >=   800 |          6 |         80 bit
+     *  (b) >=  347 |     >=   694 |          7 |         80 bit
+     *  (b) >=  308 |     >=   616 |          8 |         80 bit
+     *  (b) >=   55 |     >=   110 |         27 |         64 bit
+     *  (b) >=    6 |     >=    12 |         34 |         64 bit
+     */
+
+#define BN_prime_checks_for_size(b) ((b) >= 3747 ? 3 : (b) >= 1345 ? 4 :  \
+                                                   (b) >= 476      ? 5 :  \
+                                                   (b) >= 400      ? 6 :  \
+                                                   (b) >= 347      ? 7 :  \
+                                                   (b) >= 308      ? 8 :  \
+                                                   (b) >= 55       ? 27 : \
+                                                                     /* b >= 6 */ 34)
+#endif
 
-/*
- * get a clone of a BIGNUM with changed flags, for *temporary* use only (the
- * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The
- * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that
- * has not been otherwise initialised or used.
- */
-void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags);
+#define BN_num_bytes(a) ((BN_num_bits(a) + 7) / 8)
 
-/* Wrapper function to make using BN_GENCB easier */
-int BN_GENCB_call(BN_GENCB *cb, int a, int b);
+    int BN_abs_is_word(const BIGNUM* a, const BN_ULONG w);
+    int BN_is_zero(const BIGNUM* a);
+    int BN_is_one(const BIGNUM* a);
+    int BN_is_word(const BIGNUM* a, const BN_ULONG w);
+    int BN_is_odd(const BIGNUM* a);
 
-BN_GENCB *BN_GENCB_new(void);
-void BN_GENCB_free(BN_GENCB *cb);
+#define BN_one(a) (BN_set_word((a), 1))
 
-/* Populate a BN_GENCB structure with an "old"-style callback */
-void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *),
-                      void *cb_arg);
+    void BN_zero_ex(BIGNUM* a);
 
-/* Populate a BN_GENCB structure with a "new"-style callback */
-void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *),
-                  void *cb_arg);
+#if OPENSSL_API_LEVEL > 908
+#define BN_zero(a) BN_zero_ex(a)
+#else
+#define BN_zero(a) (BN_set_word((a), 0))
+#endif
 
-void *BN_GENCB_get_arg(BN_GENCB *cb);
+    const BIGNUM* BN_value_one(void);
+    char* BN_options(void);
+    BN_CTX* BN_CTX_new_ex(OSSL_LIB_CTX* ctx);
+    BN_CTX* BN_CTX_new(void);
+    BN_CTX* BN_CTX_secure_new_ex(OSSL_LIB_CTX* ctx);
+    BN_CTX* BN_CTX_secure_new(void);
+    void BN_CTX_free(BN_CTX* c);
+    void BN_CTX_start(BN_CTX* ctx);
+    BIGNUM* BN_CTX_get(BN_CTX* ctx);
+    void BN_CTX_end(BN_CTX* ctx);
+    int BN_rand_ex(BIGNUM* rnd, int bits, int top, int bottom, unsigned int strength, BN_CTX* ctx);
+    int BN_rand(BIGNUM* rnd, int bits, int top, int bottom);
+    int BN_priv_rand_ex(BIGNUM* rnd, int bits, int top, int bottom, unsigned int strength, BN_CTX* ctx);
+    int BN_priv_rand(BIGNUM* rnd, int bits, int top, int bottom);
+    int BN_rand_range_ex(BIGNUM* r, const BIGNUM* range, unsigned int strength, BN_CTX* ctx);
+    int BN_rand_range(BIGNUM* rnd, const BIGNUM* range);
+    int BN_priv_rand_range_ex(BIGNUM* r, const BIGNUM* range, unsigned int strength, BN_CTX* ctx);
+    int BN_priv_rand_range(BIGNUM* rnd, const BIGNUM* range);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int BN_pseudo_rand(BIGNUM* rnd, int bits, int top, int bottom);
+    OSSL_DEPRECATEDIN_3_0
+    int BN_pseudo_rand_range(BIGNUM* rnd, const BIGNUM* range);
+#endif
+    int BN_num_bits(const BIGNUM* a);
+    int BN_num_bits_word(BN_ULONG l);
+    int BN_security_bits(int L, int N);
+    BIGNUM* BN_new(void);
+    BIGNUM* BN_secure_new(void);
+    void BN_clear_free(BIGNUM* a);
+    BIGNUM* BN_copy(BIGNUM* a, const BIGNUM* b);
+    void BN_swap(BIGNUM* a, BIGNUM* b);
+    BIGNUM* BN_bin2bn(const unsigned char* s, int len, BIGNUM* ret);
+    int BN_bn2bin(const BIGNUM* a, unsigned char* to);
+    int BN_bn2binpad(const BIGNUM* a, unsigned char* to, int tolen);
+    BIGNUM* BN_lebin2bn(const unsigned char* s, int len, BIGNUM* ret);
+    int BN_bn2lebinpad(const BIGNUM* a, unsigned char* to, int tolen);
+    BIGNUM* BN_native2bn(const unsigned char* s, int len, BIGNUM* ret);
+    int BN_bn2nativepad(const BIGNUM* a, unsigned char* to, int tolen);
+    BIGNUM* BN_mpi2bn(const unsigned char* s, int len, BIGNUM* ret);
+    int BN_bn2mpi(const BIGNUM* a, unsigned char* to);
+    int BN_sub(BIGNUM* r, const BIGNUM* a, const BIGNUM* b);
+    int BN_usub(BIGNUM* r, const BIGNUM* a, const BIGNUM* b);
+    int BN_uadd(BIGNUM* r, const BIGNUM* a, const BIGNUM* b);
+    int BN_add(BIGNUM* r, const BIGNUM* a, const BIGNUM* b);
+    int BN_mul(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, BN_CTX* ctx);
+    int BN_sqr(BIGNUM* r, const BIGNUM* a, BN_CTX* ctx);
+    /** BN_set_negative sets sign of a BIGNUM
+     * \param  b  pointer to the BIGNUM object
+     * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
+     */
+    void BN_set_negative(BIGNUM* b, int n);
+    /** BN_is_negative returns 1 if the BIGNUM is negative
+     * \param  b  pointer to the BIGNUM object
+     * \return 1 if a < 0 and 0 otherwise
+     */
+    int BN_is_negative(const BIGNUM* b);
+
+    int BN_div(BIGNUM* dv, BIGNUM* rem, const BIGNUM* m, const BIGNUM* d, BN_CTX* ctx);
+#define BN_mod(rem, m, d, ctx) BN_div(NULL, (rem), (m), (d), (ctx))
+    int BN_nnmod(BIGNUM* r, const BIGNUM* m, const BIGNUM* d, BN_CTX* ctx);
+    int BN_mod_add(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const BIGNUM* m, BN_CTX* ctx);
+    int BN_mod_add_quick(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const BIGNUM* m);
+    int BN_mod_sub(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const BIGNUM* m, BN_CTX* ctx);
+    int BN_mod_sub_quick(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const BIGNUM* m);
+    int BN_mod_mul(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const BIGNUM* m, BN_CTX* ctx);
+    int BN_mod_sqr(BIGNUM* r, const BIGNUM* a, const BIGNUM* m, BN_CTX* ctx);
+    int BN_mod_lshift1(BIGNUM* r, const BIGNUM* a, const BIGNUM* m, BN_CTX* ctx);
+    int BN_mod_lshift1_quick(BIGNUM* r, const BIGNUM* a, const BIGNUM* m);
+    int BN_mod_lshift(BIGNUM* r, const BIGNUM* a, int n, const BIGNUM* m, BN_CTX* ctx);
+    int BN_mod_lshift_quick(BIGNUM* r, const BIGNUM* a, int n, const BIGNUM* m);
+
+    BN_ULONG BN_mod_word(const BIGNUM* a, BN_ULONG w);
+    BN_ULONG BN_div_word(BIGNUM* a, BN_ULONG w);
+    int BN_mul_word(BIGNUM* a, BN_ULONG w);
+    int BN_add_word(BIGNUM* a, BN_ULONG w);
+    int BN_sub_word(BIGNUM* a, BN_ULONG w);
+    int BN_set_word(BIGNUM* a, BN_ULONG w);
+    BN_ULONG BN_get_word(const BIGNUM* a);
+
+    int BN_cmp(const BIGNUM* a, const BIGNUM* b);
+    void BN_free(BIGNUM* a);
+    int BN_is_bit_set(const BIGNUM* a, int n);
+    int BN_lshift(BIGNUM* r, const BIGNUM* a, int n);
+    int BN_lshift1(BIGNUM* r, const BIGNUM* a);
+    int BN_exp(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+
+    int BN_mod_exp(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx);
+    int BN_mod_exp_mont(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx, BN_MONT_CTX* m_ctx);
+    int BN_mod_exp_mont_consttime(BIGNUM* rr, const BIGNUM* a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx, BN_MONT_CTX* in_mont);
+    int BN_mod_exp_mont_word(BIGNUM* r, BN_ULONG a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx, BN_MONT_CTX* m_ctx);
+    int BN_mod_exp2_mont(BIGNUM* r, const BIGNUM* a1, const BIGNUM* p1, const BIGNUM* a2, const BIGNUM* p2, const BIGNUM* m, BN_CTX* ctx, BN_MONT_CTX* m_ctx);
+    int BN_mod_exp_simple(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx);
+    int BN_mod_exp_mont_consttime_x2(BIGNUM* rr1, const BIGNUM* a1, const BIGNUM* p1, const BIGNUM* m1, BN_MONT_CTX* in_mont1, BIGNUM* rr2, const BIGNUM* a2, const BIGNUM* p2, const BIGNUM* m2, BN_MONT_CTX* in_mont2, BN_CTX* ctx);
+
+    int BN_mask_bits(BIGNUM* a, int n);
+#ifndef OPENSSL_NO_STDIO
+    int BN_print_fp(FILE* fp, const BIGNUM* a);
+#endif
+    int BN_print(BIO* bio, const BIGNUM* a);
+    int BN_reciprocal(BIGNUM* r, const BIGNUM* m, int len, BN_CTX* ctx);
+    int BN_rshift(BIGNUM* r, const BIGNUM* a, int n);
+    int BN_rshift1(BIGNUM* r, const BIGNUM* a);
+    void BN_clear(BIGNUM* a);
+    BIGNUM* BN_dup(const BIGNUM* a);
+    int BN_ucmp(const BIGNUM* a, const BIGNUM* b);
+    int BN_set_bit(BIGNUM* a, int n);
+    int BN_clear_bit(BIGNUM* a, int n);
+    char* BN_bn2hex(const BIGNUM* a);
+    char* BN_bn2dec(const BIGNUM* a);
+    int BN_hex2bn(BIGNUM** a, const char* str);
+    int BN_dec2bn(BIGNUM** a, const char* str);
+    int BN_asc2bn(BIGNUM** a, const char* str);
+    int BN_gcd(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, BN_CTX* ctx);
+    int BN_kronecker(const BIGNUM* a, const BIGNUM* b, BN_CTX* ctx); /* returns
+                                                                      * -2 for
+                                                                      * error */
+    BIGNUM* BN_mod_inverse(BIGNUM* ret, const BIGNUM* a, const BIGNUM* n, BN_CTX* ctx);
+    BIGNUM* BN_mod_sqrt(BIGNUM* ret, const BIGNUM* a, const BIGNUM* n, BN_CTX* ctx);
+
+    void BN_consttime_swap(BN_ULONG swap, BIGNUM* a, BIGNUM* b, int nwords);
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define BN_prime_checks 0      /* default: select number of iterations based
-                                  * on the size of the number */
+/* Deprecated versions */
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+    OSSL_DEPRECATEDIN_0_9_8
+    BIGNUM* BN_generate_prime(BIGNUM* ret, int bits, int safe, const BIGNUM* add, const BIGNUM* rem, void (*callback)(int, int, void*), void* cb_arg);
+    OSSL_DEPRECATEDIN_0_9_8
+    int BN_is_prime(const BIGNUM* p, int nchecks, void (*callback)(int, int, void*), BN_CTX* ctx, void* cb_arg);
+    OSSL_DEPRECATEDIN_0_9_8
+    int BN_is_prime_fasttest(const BIGNUM* p, int nchecks, void (*callback)(int, int, void*), BN_CTX* ctx, void* cb_arg, int do_trial_division);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int BN_is_prime_ex(const BIGNUM* p, int nchecks, BN_CTX* ctx, BN_GENCB* cb);
+    OSSL_DEPRECATEDIN_3_0
+    int BN_is_prime_fasttest_ex(const BIGNUM* p, int nchecks, BN_CTX* ctx, int do_trial_division, BN_GENCB* cb);
+#endif
+    /* Newer versions */
+    int BN_generate_prime_ex2(BIGNUM* ret, int bits, int safe, const BIGNUM* add, const BIGNUM* rem, BN_GENCB* cb, BN_CTX* ctx);
+    int BN_generate_prime_ex(BIGNUM* ret, int bits, int safe, const BIGNUM* add, const BIGNUM* rem, BN_GENCB* cb);
+    int BN_check_prime(const BIGNUM* p, BN_CTX* ctx, BN_GENCB* cb);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int BN_X931_generate_Xpq(BIGNUM* Xp, BIGNUM* Xq, int nbits, BN_CTX* ctx);
+
+    OSSL_DEPRECATEDIN_3_0
+    int BN_X931_derive_prime_ex(BIGNUM* p, BIGNUM* p1, BIGNUM* p2, const BIGNUM* Xp, const BIGNUM* Xp1, const BIGNUM* Xp2, const BIGNUM* e, BN_CTX* ctx, BN_GENCB* cb);
+    OSSL_DEPRECATEDIN_3_0
+    int BN_X931_generate_prime_ex(BIGNUM* p, BIGNUM* p1, BIGNUM* p2, BIGNUM* Xp1, BIGNUM* Xp2, const BIGNUM* Xp, const BIGNUM* e, BN_CTX* ctx, BN_GENCB* cb);
+#endif
 
-/*
- * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations
- * that will be done for checking that a random number is probably prime. The
- * error rate for accepting a composite number as prime depends on the size of
- * the prime |b|. The error rates used are for calculating an RSA key with 2 primes,
- * and so the level is what you would expect for a key of double the size of the
- * prime.
- *
- * This table is generated using the algorithm of FIPS PUB 186-4
- * Digital Signature Standard (DSS), section F.1, page 117.
- * (https://dx.doi.org/10.6028/NIST.FIPS.186-4)
- *
- * The following magma script was used to generate the output:
- * securitybits:=125;
- * k:=1024;
- * for t:=1 to 65 do
- *   for M:=3 to Floor(2*Sqrt(k-1)-1) do
- *     S:=0;
- *     // Sum over m
- *     for m:=3 to M do
- *       s:=0;
- *       // Sum over j
- *       for j:=2 to m do
- *         s+:=(RealField(32)!2)^-(j+(k-1)/j);
- *       end for;
- *       S+:=2^(m-(m-1)*t)*s;
- *     end for;
- *     A:=2^(k-2-M*t);
- *     B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S;
- *     pkt:=2.00743*Log(2)*k*2^-k*(A+B);
- *     seclevel:=Floor(-Log(2,pkt));
- *     if seclevel ge securitybits then
- *       printf "k: %5o, security: %o bits  (t: %o, M: %o)\n",k,seclevel,t,M;
- *       break;
- *     end if;
- *   end for;
- *   if seclevel ge securitybits then break; end if;
- * end for;
- *
- * It can be run online at:
- * http://magma.maths.usyd.edu.au/calc
- *
- * And will output:
- * k:  1024, security: 129 bits  (t: 6, M: 23)
- *
- * k is the number of bits of the prime, securitybits is the level we want to
- * reach.
- *
- * prime length | RSA key size | # MR tests | security level
- * -------------+--------------|------------+---------------
- *  (b) >= 6394 |     >= 12788 |          3 |        256 bit
- *  (b) >= 3747 |     >=  7494 |          3 |        192 bit
- *  (b) >= 1345 |     >=  2690 |          4 |        128 bit
- *  (b) >= 1080 |     >=  2160 |          5 |        128 bit
- *  (b) >=  852 |     >=  1704 |          5 |        112 bit
- *  (b) >=  476 |     >=   952 |          5 |         80 bit
- *  (b) >=  400 |     >=   800 |          6 |         80 bit
- *  (b) >=  347 |     >=   694 |          7 |         80 bit
- *  (b) >=  308 |     >=   616 |          8 |         80 bit
- *  (b) >=   55 |     >=   110 |         27 |         64 bit
- *  (b) >=    6 |     >=    12 |         34 |         64 bit
- */
+    BN_MONT_CTX* BN_MONT_CTX_new(void);
+    int BN_mod_mul_montgomery(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, BN_MONT_CTX* mont, BN_CTX* ctx);
+    int BN_to_montgomery(BIGNUM* r, const BIGNUM* a, BN_MONT_CTX* mont, BN_CTX* ctx);
+    int BN_from_montgomery(BIGNUM* r, const BIGNUM* a, BN_MONT_CTX* mont, BN_CTX* ctx);
+    void BN_MONT_CTX_free(BN_MONT_CTX* mont);
+    int BN_MONT_CTX_set(BN_MONT_CTX* mont, const BIGNUM* mod, BN_CTX* ctx);
+    BN_MONT_CTX* BN_MONT_CTX_copy(BN_MONT_CTX* to, BN_MONT_CTX* from);
+    BN_MONT_CTX* BN_MONT_CTX_set_locked(BN_MONT_CTX** pmont, CRYPTO_RWLOCK* lock, const BIGNUM* mod, BN_CTX* ctx);
 
-#  define BN_prime_checks_for_size(b) ((b) >= 3747 ?  3 : \
-                                      (b) >=  1345 ?  4 : \
-                                      (b) >=  476 ?  5 : \
-                                      (b) >=  400 ?  6 : \
-                                      (b) >=  347 ?  7 : \
-                                      (b) >=  308 ?  8 : \
-                                      (b) >=  55  ? 27 : \
-                                      /* b >= 6 */ 34)
-# endif
-
-# define BN_num_bytes(a) ((BN_num_bits(a)+7)/8)
-
-int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w);
-int BN_is_zero(const BIGNUM *a);
-int BN_is_one(const BIGNUM *a);
-int BN_is_word(const BIGNUM *a, const BN_ULONG w);
-int BN_is_odd(const BIGNUM *a);
-
-# define BN_one(a)       (BN_set_word((a),1))
-
-void BN_zero_ex(BIGNUM *a);
-
-# if OPENSSL_API_LEVEL > 908
-#  define BN_zero(a)      BN_zero_ex(a)
-# else
-#  define BN_zero(a)      (BN_set_word((a),0))
-# endif
-
-const BIGNUM *BN_value_one(void);
-char *BN_options(void);
-BN_CTX *BN_CTX_new_ex(OSSL_LIB_CTX *ctx);
-BN_CTX *BN_CTX_new(void);
-BN_CTX *BN_CTX_secure_new_ex(OSSL_LIB_CTX *ctx);
-BN_CTX *BN_CTX_secure_new(void);
-void BN_CTX_free(BN_CTX *c);
-void BN_CTX_start(BN_CTX *ctx);
-BIGNUM *BN_CTX_get(BN_CTX *ctx);
-void BN_CTX_end(BN_CTX *ctx);
-int BN_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
-               unsigned int strength, BN_CTX *ctx);
-int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
-int BN_priv_rand_ex(BIGNUM *rnd, int bits, int top, int bottom,
-                    unsigned int strength, BN_CTX *ctx);
-int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom);
-int BN_rand_range_ex(BIGNUM *r, const BIGNUM *range, unsigned int strength,
-                     BN_CTX *ctx);
-int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
-int BN_priv_rand_range_ex(BIGNUM *r, const BIGNUM *range,
-                          unsigned int strength, BN_CTX *ctx);
-int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
-OSSL_DEPRECATEDIN_3_0
-int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
-# endif
-int BN_num_bits(const BIGNUM *a);
-int BN_num_bits_word(BN_ULONG l);
-int BN_security_bits(int L, int N);
-BIGNUM *BN_new(void);
-BIGNUM *BN_secure_new(void);
-void BN_clear_free(BIGNUM *a);
-BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
-void BN_swap(BIGNUM *a, BIGNUM *b);
-BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
-int BN_bn2bin(const BIGNUM *a, unsigned char *to);
-int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
-BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
-int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
-BIGNUM *BN_native2bn(const unsigned char *s, int len, BIGNUM *ret);
-int BN_bn2nativepad(const BIGNUM *a, unsigned char *to, int tolen);
-BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
-int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
-int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
-int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
-int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
-int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
-int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
-int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
-/** BN_set_negative sets sign of a BIGNUM
- * \param  b  pointer to the BIGNUM object
- * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
- */
-void BN_set_negative(BIGNUM *b, int n);
-/** BN_is_negative returns 1 if the BIGNUM is negative
- * \param  b  pointer to the BIGNUM object
- * \return 1 if a < 0 and 0 otherwise
- */
-int BN_is_negative(const BIGNUM *b);
-
-int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
-           BN_CTX *ctx);
-# define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx))
-int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
-int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
-               BN_CTX *ctx);
-int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                     const BIGNUM *m);
-int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
-               BN_CTX *ctx);
-int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                     const BIGNUM *m);
-int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
-               BN_CTX *ctx);
-int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
-int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
-int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
-int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
-                  BN_CTX *ctx);
-int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
-
-BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
-BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
-int BN_mul_word(BIGNUM *a, BN_ULONG w);
-int BN_add_word(BIGNUM *a, BN_ULONG w);
-int BN_sub_word(BIGNUM *a, BN_ULONG w);
-int BN_set_word(BIGNUM *a, BN_ULONG w);
-BN_ULONG BN_get_word(const BIGNUM *a);
-
-int BN_cmp(const BIGNUM *a, const BIGNUM *b);
-void BN_free(BIGNUM *a);
-int BN_is_bit_set(const BIGNUM *a, int n);
-int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
-int BN_lshift1(BIGNUM *r, const BIGNUM *a);
-int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
-
-int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
-               const BIGNUM *m, BN_CTX *ctx);
-int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
-                    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
-int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
-                              const BIGNUM *m, BN_CTX *ctx,
-                              BN_MONT_CTX *in_mont);
-int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p,
-                         const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
-int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
-                     const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
-                     BN_CTX *ctx, BN_MONT_CTX *m_ctx);
-int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
-                      const BIGNUM *m, BN_CTX *ctx);
-int BN_mod_exp_mont_consttime_x2(BIGNUM *rr1, const BIGNUM *a1, const BIGNUM *p1,
-                                 const BIGNUM *m1, BN_MONT_CTX *in_mont1,
-                                 BIGNUM *rr2, const BIGNUM *a2, const BIGNUM *p2,
-                                 const BIGNUM *m2, BN_MONT_CTX *in_mont2,
-                                 BN_CTX *ctx);
-
-int BN_mask_bits(BIGNUM *a, int n);
-# ifndef OPENSSL_NO_STDIO
-int BN_print_fp(FILE *fp, const BIGNUM *a);
-# endif
-int BN_print(BIO *bio, const BIGNUM *a);
-int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
-int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
-int BN_rshift1(BIGNUM *r, const BIGNUM *a);
-void BN_clear(BIGNUM *a);
-BIGNUM *BN_dup(const BIGNUM *a);
-int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
-int BN_set_bit(BIGNUM *a, int n);
-int BN_clear_bit(BIGNUM *a, int n);
-char *BN_bn2hex(const BIGNUM *a);
-char *BN_bn2dec(const BIGNUM *a);
-int BN_hex2bn(BIGNUM **a, const char *str);
-int BN_dec2bn(BIGNUM **a, const char *str);
-int BN_asc2bn(BIGNUM **a, const char *str);
-int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
-int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns
-                                                                  * -2 for
-                                                                  * error */
-BIGNUM *BN_mod_inverse(BIGNUM *ret,
-                       const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
-BIGNUM *BN_mod_sqrt(BIGNUM *ret,
-                    const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
-
-void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords);
+/* BN_BLINDING flags */
+#define BN_BLINDING_NO_UPDATE 0x00000001
+#define BN_BLINDING_NO_RECREATE 0x00000002
+
+    BN_BLINDING* BN_BLINDING_new(const BIGNUM* A, const BIGNUM* Ai, BIGNUM* mod);
+    void BN_BLINDING_free(BN_BLINDING* b);
+    int BN_BLINDING_update(BN_BLINDING* b, BN_CTX* ctx);
+    int BN_BLINDING_convert(BIGNUM* n, BN_BLINDING* b, BN_CTX* ctx);
+    int BN_BLINDING_invert(BIGNUM* n, BN_BLINDING* b, BN_CTX* ctx);
+    int BN_BLINDING_convert_ex(BIGNUM* n, BIGNUM* r, BN_BLINDING* b, BN_CTX*);
+    int BN_BLINDING_invert_ex(BIGNUM* n, const BIGNUM* r, BN_BLINDING* b, BN_CTX*);
+
+    int BN_BLINDING_is_current_thread(BN_BLINDING* b);
+    void BN_BLINDING_set_current_thread(BN_BLINDING* b);
+    int BN_BLINDING_lock(BN_BLINDING* b);
+    int BN_BLINDING_unlock(BN_BLINDING* b);
+
+    unsigned long BN_BLINDING_get_flags(const BN_BLINDING*);
+    void BN_BLINDING_set_flags(BN_BLINDING*, unsigned long);
+    BN_BLINDING* BN_BLINDING_create_param(BN_BLINDING* b, const BIGNUM* e, BIGNUM* m, BN_CTX* ctx, int (*bn_mod_exp)(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx, BN_MONT_CTX* m_ctx), BN_MONT_CTX* m_ctx);
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+    OSSL_DEPRECATEDIN_0_9_8
+    void BN_set_params(int mul, int high, int low, int mont);
+    OSSL_DEPRECATEDIN_0_9_8
+    int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */
+#endif
 
-/* Deprecated versions */
-# ifndef OPENSSL_NO_DEPRECATED_0_9_8
-OSSL_DEPRECATEDIN_0_9_8
-BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe,
-                          const BIGNUM *add, const BIGNUM *rem,
-                          void (*callback) (int, int, void *),
-                          void *cb_arg);
-OSSL_DEPRECATEDIN_0_9_8
-int BN_is_prime(const BIGNUM *p, int nchecks,
-                void (*callback) (int, int, void *),
-                BN_CTX *ctx, void *cb_arg);
-OSSL_DEPRECATEDIN_0_9_8
-int BN_is_prime_fasttest(const BIGNUM *p, int nchecks,
-                         void (*callback) (int, int, void *),
-                         BN_CTX *ctx, void *cb_arg,
-                         int do_trial_division);
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
-OSSL_DEPRECATEDIN_3_0
-int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
-                            int do_trial_division, BN_GENCB *cb);
-# endif
-/* Newer versions */
-int BN_generate_prime_ex2(BIGNUM *ret, int bits, int safe,
-                          const BIGNUM *add, const BIGNUM *rem, BN_GENCB *cb,
-                          BN_CTX *ctx);
-int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
-                         const BIGNUM *rem, BN_GENCB *cb);
-int BN_check_prime(const BIGNUM *p, BN_CTX *ctx, BN_GENCB *cb);
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
-
-OSSL_DEPRECATEDIN_3_0
-int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
-                            const BIGNUM *Xp, const BIGNUM *Xp1,
-                            const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,
-                            BN_GENCB *cb);
-OSSL_DEPRECATEDIN_3_0
-int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1,
-                              BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e,
-                              BN_CTX *ctx, BN_GENCB *cb);
-# endif
-
-BN_MONT_CTX *BN_MONT_CTX_new(void);
-int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                          BN_MONT_CTX *mont, BN_CTX *ctx);
-int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
-                     BN_CTX *ctx);
-int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
-                       BN_CTX *ctx);
-void BN_MONT_CTX_free(BN_MONT_CTX *mont);
-int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
-BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
-BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock,
-                                    const BIGNUM *mod, BN_CTX *ctx);
+    BN_RECP_CTX* BN_RECP_CTX_new(void);
+    void BN_RECP_CTX_free(BN_RECP_CTX* recp);
+    int BN_RECP_CTX_set(BN_RECP_CTX* recp, const BIGNUM* rdiv, BN_CTX* ctx);
+    int BN_mod_mul_reciprocal(BIGNUM* r, const BIGNUM* x, const BIGNUM* y, BN_RECP_CTX* recp, BN_CTX* ctx);
+    int BN_mod_exp_recp(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx);
+    int BN_div_recp(BIGNUM* dv, BIGNUM* rem, const BIGNUM* m, BN_RECP_CTX* recp, BN_CTX* ctx);
+
+#ifndef OPENSSL_NO_EC2M
+
+    /*
+     * Functions for arithmetic over binary polynomials represented by BIGNUMs.
+     * The BIGNUM::neg property of BIGNUMs representing binary polynomials is
+     * ignored. Note that input arguments are not const so that their bit arrays
+     * can be expanded to the appropriate size if needed.
+     */
+
+    /*
+     * r = a + b
+     */
+    int BN_GF2m_add(BIGNUM* r, const BIGNUM* a, const BIGNUM* b);
+#define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b)
+    /*
+     * r=a mod p
+     */
+    int BN_GF2m_mod(BIGNUM* r, const BIGNUM* a, const BIGNUM* p);
+    /* r = (a * b) mod p */
+    int BN_GF2m_mod_mul(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const BIGNUM* p, BN_CTX* ctx);
+    /* r = (a * a) mod p */
+    int BN_GF2m_mod_sqr(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+    /* r = (1 / b) mod p */
+    int BN_GF2m_mod_inv(BIGNUM* r, const BIGNUM* b, const BIGNUM* p, BN_CTX* ctx);
+    /* r = (a / b) mod p */
+    int BN_GF2m_mod_div(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const BIGNUM* p, BN_CTX* ctx);
+    /* r = (a ^ b) mod p */
+    int BN_GF2m_mod_exp(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const BIGNUM* p, BN_CTX* ctx);
+    /* r = sqrt(a) mod p */
+    int BN_GF2m_mod_sqrt(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+    /* r^2 + r = a mod p */
+    int BN_GF2m_mod_solve_quad(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+#define BN_GF2m_cmp(a, b) BN_ucmp((a), (b))
+    /*-
+     * Some functions allow for representation of the irreducible polynomials
+     * as an unsigned int[], say p.  The irreducible f(t) is then of the form:
+     *     t^p[0] + t^p[1] + ... + t^p[k]
+     * where m = p[0] > p[1] > ... > p[k] = 0.
+     */
+    /* r = a mod p */
+    int BN_GF2m_mod_arr(BIGNUM* r, const BIGNUM* a, const int p[]);
+    /* r = (a * b) mod p */
+    int BN_GF2m_mod_mul_arr(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const int p[], BN_CTX* ctx);
+    /* r = (a * a) mod p */
+    int BN_GF2m_mod_sqr_arr(BIGNUM* r, const BIGNUM* a, const int p[], BN_CTX* ctx);
+    /* r = (1 / b) mod p */
+    int BN_GF2m_mod_inv_arr(BIGNUM* r, const BIGNUM* b, const int p[], BN_CTX* ctx);
+    /* r = (a / b) mod p */
+    int BN_GF2m_mod_div_arr(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const int p[], BN_CTX* ctx);
+    /* r = (a ^ b) mod p */
+    int BN_GF2m_mod_exp_arr(BIGNUM* r, const BIGNUM* a, const BIGNUM* b, const int p[], BN_CTX* ctx);
+    /* r = sqrt(a) mod p */
+    int BN_GF2m_mod_sqrt_arr(BIGNUM* r, const BIGNUM* a, const int p[], BN_CTX* ctx);
+    /* r^2 + r = a mod p */
+    int BN_GF2m_mod_solve_quad_arr(BIGNUM* r, const BIGNUM* a, const int p[], BN_CTX* ctx);
+    int BN_GF2m_poly2arr(const BIGNUM* a, int p[], int max);
+    int BN_GF2m_arr2poly(const int p[], BIGNUM* a);
 
-/* BN_BLINDING flags */
-# define BN_BLINDING_NO_UPDATE   0x00000001
-# define BN_BLINDING_NO_RECREATE 0x00000002
-
-BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
-void BN_BLINDING_free(BN_BLINDING *b);
-int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
-int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
-int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
-int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
-int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
-                          BN_CTX *);
-
-int BN_BLINDING_is_current_thread(BN_BLINDING *b);
-void BN_BLINDING_set_current_thread(BN_BLINDING *b);
-int BN_BLINDING_lock(BN_BLINDING *b);
-int BN_BLINDING_unlock(BN_BLINDING *b);
-
-unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
-void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
-BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
-                                      const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
-                                      int (*bn_mod_exp) (BIGNUM *r,
-                                                         const BIGNUM *a,
-                                                         const BIGNUM *p,
-                                                         const BIGNUM *m,
-                                                         BN_CTX *ctx,
-                                                         BN_MONT_CTX *m_ctx),
-                                      BN_MONT_CTX *m_ctx);
-# ifndef OPENSSL_NO_DEPRECATED_0_9_8
-OSSL_DEPRECATEDIN_0_9_8
-void BN_set_params(int mul, int high, int low, int mont);
-OSSL_DEPRECATEDIN_0_9_8
-int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */
-# endif
-
-BN_RECP_CTX *BN_RECP_CTX_new(void);
-void BN_RECP_CTX_free(BN_RECP_CTX *recp);
-int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
-int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
-                          BN_RECP_CTX *recp, BN_CTX *ctx);
-int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
-                    const BIGNUM *m, BN_CTX *ctx);
-int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
-                BN_RECP_CTX *recp, BN_CTX *ctx);
-
-# ifndef OPENSSL_NO_EC2M
+#endif
 
-/*
- * Functions for arithmetic over binary polynomials represented by BIGNUMs.
- * The BIGNUM::neg property of BIGNUMs representing binary polynomials is
- * ignored. Note that input arguments are not const so that their bit arrays
- * can be expanded to the appropriate size if needed.
- */
+    /*
+     * faster mod functions for the 'NIST primes' 0 <= a < p^2
+     */
+    int BN_nist_mod_192(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+    int BN_nist_mod_224(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+    int BN_nist_mod_256(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+    int BN_nist_mod_384(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+    int BN_nist_mod_521(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, BN_CTX* ctx);
+
+    const BIGNUM* BN_get0_nist_prime_192(void);
+    const BIGNUM* BN_get0_nist_prime_224(void);
+    const BIGNUM* BN_get0_nist_prime_256(void);
+    const BIGNUM* BN_get0_nist_prime_384(void);
+    const BIGNUM* BN_get0_nist_prime_521(void);
+
+    int (*BN_nist_mod_func(const BIGNUM* p))(BIGNUM* r, const BIGNUM* a, const BIGNUM* field, BN_CTX* ctx);
+
+    int BN_generate_dsa_nonce(BIGNUM* out, const BIGNUM* range, const BIGNUM* priv, const unsigned char* message, size_t message_len, BN_CTX* ctx);
+
+    /* Primes from RFC 2409 */
+    BIGNUM* BN_get_rfc2409_prime_768(BIGNUM* bn);
+    BIGNUM* BN_get_rfc2409_prime_1024(BIGNUM* bn);
+
+    /* Primes from RFC 3526 */
+    BIGNUM* BN_get_rfc3526_prime_1536(BIGNUM* bn);
+    BIGNUM* BN_get_rfc3526_prime_2048(BIGNUM* bn);
+    BIGNUM* BN_get_rfc3526_prime_3072(BIGNUM* bn);
+    BIGNUM* BN_get_rfc3526_prime_4096(BIGNUM* bn);
+    BIGNUM* BN_get_rfc3526_prime_6144(BIGNUM* bn);
+    BIGNUM* BN_get_rfc3526_prime_8192(BIGNUM* bn);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define get_rfc2409_prime_768 BN_get_rfc2409_prime_768
+#define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024
+#define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536
+#define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048
+#define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072
+#define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096
+#define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144
+#define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192
+#endif
 
-/*
- * r = a + b
- */
-int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
-#  define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b)
-/*
- * r=a mod p
- */
-int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p);
-/* r = (a * b) mod p */
-int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                    const BIGNUM *p, BN_CTX *ctx);
-/* r = (a * a) mod p */
-int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
-/* r = (1 / b) mod p */
-int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx);
-/* r = (a / b) mod p */
-int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                    const BIGNUM *p, BN_CTX *ctx);
-/* r = (a ^ b) mod p */
-int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                    const BIGNUM *p, BN_CTX *ctx);
-/* r = sqrt(a) mod p */
-int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
-                     BN_CTX *ctx);
-/* r^2 + r = a mod p */
-int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
-                           BN_CTX *ctx);
-#  define BN_GF2m_cmp(a, b) BN_ucmp((a), (b))
-/*-
- * Some functions allow for representation of the irreducible polynomials
- * as an unsigned int[], say p.  The irreducible f(t) is then of the form:
- *     t^p[0] + t^p[1] + ... + t^p[k]
- * where m = p[0] > p[1] > ... > p[k] = 0.
- */
-/* r = a mod p */
-int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]);
-/* r = (a * b) mod p */
-int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                        const int p[], BN_CTX *ctx);
-/* r = (a * a) mod p */
-int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[],
-                        BN_CTX *ctx);
-/* r = (1 / b) mod p */
-int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[],
-                        BN_CTX *ctx);
-/* r = (a / b) mod p */
-int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                        const int p[], BN_CTX *ctx);
-/* r = (a ^ b) mod p */
-int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
-                        const int p[], BN_CTX *ctx);
-/* r = sqrt(a) mod p */
-int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a,
-                         const int p[], BN_CTX *ctx);
-/* r^2 + r = a mod p */
-int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a,
-                               const int p[], BN_CTX *ctx);
-int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max);
-int BN_GF2m_arr2poly(const int p[], BIGNUM *a);
-
-# endif
+    int BN_bntest_rand(BIGNUM* rnd, int bits, int top, int bottom);
 
-/*
- * faster mod functions for the 'NIST primes' 0 <= a < p^2
- */
-int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
-int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
-int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
-int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
-int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
-
-const BIGNUM *BN_get0_nist_prime_192(void);
-const BIGNUM *BN_get0_nist_prime_224(void);
-const BIGNUM *BN_get0_nist_prime_256(void);
-const BIGNUM *BN_get0_nist_prime_384(void);
-const BIGNUM *BN_get0_nist_prime_521(void);
-
-int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a,
-                                          const BIGNUM *field, BN_CTX *ctx);
-
-int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
-                          const BIGNUM *priv, const unsigned char *message,
-                          size_t message_len, BN_CTX *ctx);
-
-/* Primes from RFC 2409 */
-BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
-BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);
-
-/* Primes from RFC 3526 */
-BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
-BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
-BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
-BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
-BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
-BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
-
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#   define get_rfc2409_prime_768 BN_get_rfc2409_prime_768
-#   define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024
-#   define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536
-#   define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048
-#   define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072
-#   define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096
-#   define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144
-#   define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192
-#  endif
-
-int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);
-
-
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/bnerr.h b/CAPI/cpp/grpc/include/openssl/bnerr.h
index 7c3f6ef..dbbcd69 100644
--- a/CAPI/cpp/grpc/include/openssl/bnerr.h
+++ b/CAPI/cpp/grpc/include/openssl/bnerr.h
@@ -9,39 +9,37 @@
  */
 
 #ifndef OPENSSL_BNERR_H
-# define OPENSSL_BNERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_BNERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * BN reason codes.
  */
-# define BN_R_ARG2_LT_ARG3                                100
-# define BN_R_BAD_RECIPROCAL                              101
-# define BN_R_BIGNUM_TOO_LONG                             114
-# define BN_R_BITS_TOO_SMALL                              118
-# define BN_R_CALLED_WITH_EVEN_MODULUS                    102
-# define BN_R_DIV_BY_ZERO                                 103
-# define BN_R_ENCODING_ERROR                              104
-# define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA                105
-# define BN_R_INPUT_NOT_REDUCED                           110
-# define BN_R_INVALID_LENGTH                              106
-# define BN_R_INVALID_RANGE                               115
-# define BN_R_INVALID_SHIFT                               119
-# define BN_R_NOT_A_SQUARE                                111
-# define BN_R_NOT_INITIALIZED                             107
-# define BN_R_NO_INVERSE                                  108
-# define BN_R_NO_PRIME_CANDIDATE                          121
-# define BN_R_NO_SOLUTION                                 116
-# define BN_R_NO_SUITABLE_DIGEST                          120
-# define BN_R_PRIVATE_KEY_TOO_LARGE                       117
-# define BN_R_P_IS_NOT_PRIME                              112
-# define BN_R_TOO_MANY_ITERATIONS                         113
-# define BN_R_TOO_MANY_TEMPORARY_VARIABLES                109
+#define BN_R_ARG2_LT_ARG3 100
+#define BN_R_BAD_RECIPROCAL 101
+#define BN_R_BIGNUM_TOO_LONG 114
+#define BN_R_BITS_TOO_SMALL 118
+#define BN_R_CALLED_WITH_EVEN_MODULUS 102
+#define BN_R_DIV_BY_ZERO 103
+#define BN_R_ENCODING_ERROR 104
+#define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105
+#define BN_R_INPUT_NOT_REDUCED 110
+#define BN_R_INVALID_LENGTH 106
+#define BN_R_INVALID_RANGE 115
+#define BN_R_INVALID_SHIFT 119
+#define BN_R_NOT_A_SQUARE 111
+#define BN_R_NOT_INITIALIZED 107
+#define BN_R_NO_INVERSE 108
+#define BN_R_NO_PRIME_CANDIDATE 121
+#define BN_R_NO_SOLUTION 116
+#define BN_R_NO_SUITABLE_DIGEST 120
+#define BN_R_PRIVATE_KEY_TOO_LARGE 117
+#define BN_R_P_IS_NOT_PRIME 112
+#define BN_R_TOO_MANY_ITERATIONS 113
+#define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/buffer.h b/CAPI/cpp/grpc/include/openssl/buffer.h
index 5773b98..df4fe18 100644
--- a/CAPI/cpp/grpc/include/openssl/buffer.h
+++ b/CAPI/cpp/grpc/include/openssl/buffer.h
@@ -8,55 +8,55 @@
  */
 
 #ifndef OPENSSL_BUFFER_H
-# define OPENSSL_BUFFER_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_BUFFER_H
-# endif
-
-# include <openssl/types.h>
-# ifndef OPENSSL_CRYPTO_H
-#  include <openssl/crypto.h>
-# endif
-# include <openssl/buffererr.h>
+#define OPENSSL_BUFFER_H
+#pragma once
 
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_BUFFER_H
+#endif
 
-#ifdef  __cplusplus
-extern "C" {
+#include <openssl/types.h>
+#ifndef OPENSSL_CRYPTO_H
+#include <openssl/crypto.h>
 #endif
+#include <openssl/buffererr.h>
 
-# include <stddef.h>
-# include <sys/types.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define BUF_strdup(s) OPENSSL_strdup(s)
-#  define BUF_strndup(s, size) OPENSSL_strndup(s, size)
-#  define BUF_memdup(data, size) OPENSSL_memdup(data, size)
-#  define BUF_strlcpy(dst, src, size)  OPENSSL_strlcpy(dst, src, size)
-#  define BUF_strlcat(dst, src, size) OPENSSL_strlcat(dst, src, size)
-#  define BUF_strnlen(str, maxlen) OPENSSL_strnlen(str, maxlen)
-# endif
+#include <stddef.h>
+#include <sys/types.h>
 
-struct buf_mem_st {
-    size_t length;              /* current number of bytes */
-    char *data;
-    size_t max;                 /* size of buffer */
-    unsigned long flags;
-};
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define BUF_strdup(s) OPENSSL_strdup(s)
+#define BUF_strndup(s, size) OPENSSL_strndup(s, size)
+#define BUF_memdup(data, size) OPENSSL_memdup(data, size)
+#define BUF_strlcpy(dst, src, size) OPENSSL_strlcpy(dst, src, size)
+#define BUF_strlcat(dst, src, size) OPENSSL_strlcat(dst, src, size)
+#define BUF_strnlen(str, maxlen) OPENSSL_strnlen(str, maxlen)
+#endif
 
-# define BUF_MEM_FLAG_SECURE  0x01
+    struct buf_mem_st
+    {
+        size_t length; /* current number of bytes */
+        char* data;
+        size_t max; /* size of buffer */
+        unsigned long flags;
+    };
 
-BUF_MEM *BUF_MEM_new(void);
-BUF_MEM *BUF_MEM_new_ex(unsigned long flags);
-void BUF_MEM_free(BUF_MEM *a);
-size_t BUF_MEM_grow(BUF_MEM *str, size_t len);
-size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len);
-void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz);
+#define BUF_MEM_FLAG_SECURE 0x01
 
+    BUF_MEM* BUF_MEM_new(void);
+    BUF_MEM* BUF_MEM_new_ex(unsigned long flags);
+    void BUF_MEM_free(BUF_MEM* a);
+    size_t BUF_MEM_grow(BUF_MEM* str, size_t len);
+    size_t BUF_MEM_grow_clean(BUF_MEM* str, size_t len);
+    void BUF_reverse(unsigned char* out, const unsigned char* in, size_t siz);
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/buffererr.h b/CAPI/cpp/grpc/include/openssl/buffererr.h
index d18b1f8..4fa0da4 100644
--- a/CAPI/cpp/grpc/include/openssl/buffererr.h
+++ b/CAPI/cpp/grpc/include/openssl/buffererr.h
@@ -9,14 +9,12 @@
  */
 
 #ifndef OPENSSL_BUFFERERR_H
-# define OPENSSL_BUFFERERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_BUFFERERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * BUF reason codes.
diff --git a/CAPI/cpp/grpc/include/openssl/camellia.h b/CAPI/cpp/grpc/include/openssl/camellia.h
index 88c2279..04860dd 100644
--- a/CAPI/cpp/grpc/include/openssl/camellia.h
+++ b/CAPI/cpp/grpc/include/openssl/camellia.h
@@ -8,110 +8,72 @@
  */
 
 #ifndef OPENSSL_CAMELLIA_H
-# define OPENSSL_CAMELLIA_H
-# pragma once
+#define OPENSSL_CAMELLIA_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_CAMELLIA_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CAMELLIA_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_CAMELLIA
-# include <stddef.h>
-#ifdef  __cplusplus
-extern "C" {
+#ifndef OPENSSL_NO_CAMELLIA
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-# define CAMELLIA_BLOCK_SIZE 16
+#define CAMELLIA_BLOCK_SIZE 16
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 
-#  define CAMELLIA_ENCRYPT        1
-#  define CAMELLIA_DECRYPT        0
+#define CAMELLIA_ENCRYPT 1
+#define CAMELLIA_DECRYPT 0
 
-/*
- * Because array size can't be a const in C, the following two are macros.
- * Both sizes are in bytes.
- */
+    /*
+     * Because array size can't be a const in C, the following two are macros.
+     * Both sizes are in bytes.
+     */
 
-/* This should be a hidden type, but EVP requires that the size be known */
+    /* This should be a hidden type, but EVP requires that the size be known */
 
-#  define CAMELLIA_TABLE_BYTE_LEN 272
-#  define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4)
+#define CAMELLIA_TABLE_BYTE_LEN 272
+#define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4)
 
-typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match
-                                                               * with WORD */
+    typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match
+                                                                   * with WORD */
 
-struct camellia_key_st {
-    union {
-        double d;               /* ensures 64-bit align */
-        KEY_TABLE_TYPE rd_key;
-    } u;
-    int grand_rounds;
-};
-typedef struct camellia_key_st CAMELLIA_KEY;
+    struct camellia_key_st
+    {
+        union
+        {
+            double d; /* ensures 64-bit align */
+            KEY_TABLE_TYPE rd_key;
+        } u;
+        int grand_rounds;
+    };
+    typedef struct camellia_key_st CAMELLIA_KEY;
 
-# endif /* OPENSSL_NO_DEPRECATED_3_0 */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int Camellia_set_key(const unsigned char *userKey,
-                                           const int bits,
-                                           CAMELLIA_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void Camellia_encrypt(const unsigned char *in,
-                                            unsigned char *out,
-                                            const CAMELLIA_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void Camellia_decrypt(const unsigned char *in,
-                                            unsigned char *out,
-                                            const CAMELLIA_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void Camellia_ecb_encrypt(const unsigned char *in,
-                                                unsigned char *out,
-                                                const CAMELLIA_KEY *key,
-                                                const int enc);
-OSSL_DEPRECATEDIN_3_0 void Camellia_cbc_encrypt(const unsigned char *in,
-                                                unsigned char *out,
-                                                size_t length,
-                                                const CAMELLIA_KEY *key,
-                                                unsigned char *ivec,
-                                                const int enc);
-OSSL_DEPRECATEDIN_3_0 void Camellia_cfb128_encrypt(const unsigned char *in,
-                                                   unsigned char *out,
-                                                   size_t length,
-                                                   const CAMELLIA_KEY *key,
-                                                   unsigned char *ivec,
-                                                   int *num,
-                                                   const int enc);
-OSSL_DEPRECATEDIN_3_0 void Camellia_cfb1_encrypt(const unsigned char *in,
-                                                 unsigned char *out,
-                                                 size_t length,
-                                                 const CAMELLIA_KEY *key,
-                                                 unsigned char *ivec,
-                                                 int *num,
-                                                 const int enc);
-OSSL_DEPRECATEDIN_3_0 void Camellia_cfb8_encrypt(const unsigned char *in,
-                                                 unsigned char *out,
-                                                 size_t length,
-                                                 const CAMELLIA_KEY *key,
-                                                 unsigned char *ivec,
-                                                 int *num,
-                                                 const int enc);
-OSSL_DEPRECATEDIN_3_0 void Camellia_ofb128_encrypt(const unsigned char *in,
-                                                   unsigned char *out,
-                                                   size_t length,
-                                                   const CAMELLIA_KEY *key,
-                                                   unsigned char *ivec,
-                                                   int *num);
-OSSL_DEPRECATEDIN_3_0
-void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out,
-                             size_t length, const CAMELLIA_KEY *key,
-                             unsigned char ivec[CAMELLIA_BLOCK_SIZE],
-                             unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE],
-                             unsigned int *num);
-# endif
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int Camellia_set_key(const unsigned char* userKey, const int bits, CAMELLIA_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void Camellia_encrypt(const unsigned char* in, unsigned char* out, const CAMELLIA_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void Camellia_decrypt(const unsigned char* in, unsigned char* out, const CAMELLIA_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void Camellia_ecb_encrypt(const unsigned char* in, unsigned char* out, const CAMELLIA_KEY* key, const int enc);
+    OSSL_DEPRECATEDIN_3_0 void Camellia_cbc_encrypt(const unsigned char* in, unsigned char* out, size_t length, const CAMELLIA_KEY* key, unsigned char* ivec, const int enc);
+    OSSL_DEPRECATEDIN_3_0 void Camellia_cfb128_encrypt(const unsigned char* in, unsigned char* out, size_t length, const CAMELLIA_KEY* key, unsigned char* ivec, int* num, const int enc);
+    OSSL_DEPRECATEDIN_3_0 void Camellia_cfb1_encrypt(const unsigned char* in, unsigned char* out, size_t length, const CAMELLIA_KEY* key, unsigned char* ivec, int* num, const int enc);
+    OSSL_DEPRECATEDIN_3_0 void Camellia_cfb8_encrypt(const unsigned char* in, unsigned char* out, size_t length, const CAMELLIA_KEY* key, unsigned char* ivec, int* num, const int enc);
+    OSSL_DEPRECATEDIN_3_0 void Camellia_ofb128_encrypt(const unsigned char* in, unsigned char* out, size_t length, const CAMELLIA_KEY* key, unsigned char* ivec, int* num);
+    OSSL_DEPRECATEDIN_3_0
+    void Camellia_ctr128_encrypt(const unsigned char* in, unsigned char* out, size_t length, const CAMELLIA_KEY* key, unsigned char ivec[CAMELLIA_BLOCK_SIZE], unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE], unsigned int* num);
+#endif
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/cast.h b/CAPI/cpp/grpc/include/openssl/cast.h
index 0bf217b..a88ed1d 100644
--- a/CAPI/cpp/grpc/include/openssl/cast.h
+++ b/CAPI/cpp/grpc/include/openssl/cast.h
@@ -8,64 +8,59 @@
  */
 
 #ifndef OPENSSL_CAST_H
-# define OPENSSL_CAST_H
-# pragma once
+#define OPENSSL_CAST_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_CAST_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CAST_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_CAST
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifndef OPENSSL_NO_CAST
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# define CAST_BLOCK      8
-# define CAST_KEY_LENGTH 16
+#define CAST_BLOCK 8
+#define CAST_KEY_LENGTH 16
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 
-#  define CAST_ENCRYPT    1
-#  define CAST_DECRYPT    0
+#define CAST_ENCRYPT 1
+#define CAST_DECRYPT 0
 
-#  define CAST_LONG unsigned int
+#define CAST_LONG unsigned int
 
-typedef struct cast_key_st {
-    CAST_LONG data[32];
-    int short_key;              /* Use reduced rounds for short key */
-} CAST_KEY;
+    typedef struct cast_key_st
+    {
+        CAST_LONG data[32];
+        int short_key; /* Use reduced rounds for short key */
+    } CAST_KEY;
 
-# endif /* OPENSSL_NO_DEPRECATED_3_0 */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data);
-OSSL_DEPRECATEDIN_3_0
-void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out,
-                      const CAST_KEY *key, int enc);
-OSSL_DEPRECATEDIN_3_0
-void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key);
-OSSL_DEPRECATEDIN_3_0
-void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key);
-OSSL_DEPRECATEDIN_3_0
-void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out,
-                      long length, const CAST_KEY *ks, unsigned char *iv,
-                      int enc);
-OSSL_DEPRECATEDIN_3_0
-void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out,
-                        long length, const CAST_KEY *schedule,
-                        unsigned char *ivec, int *num, int enc);
-OSSL_DEPRECATEDIN_3_0
-void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out,
-                        long length, const CAST_KEY *schedule,
-                        unsigned char *ivec, int *num);
-# endif
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    void CAST_set_key(CAST_KEY* key, int len, const unsigned char* data);
+    OSSL_DEPRECATEDIN_3_0
+    void CAST_ecb_encrypt(const unsigned char* in, unsigned char* out, const CAST_KEY* key, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void CAST_encrypt(CAST_LONG* data, const CAST_KEY* key);
+    OSSL_DEPRECATEDIN_3_0
+    void CAST_decrypt(CAST_LONG* data, const CAST_KEY* key);
+    OSSL_DEPRECATEDIN_3_0
+    void CAST_cbc_encrypt(const unsigned char* in, unsigned char* out, long length, const CAST_KEY* ks, unsigned char* iv, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void CAST_cfb64_encrypt(const unsigned char* in, unsigned char* out, long length, const CAST_KEY* schedule, unsigned char* ivec, int* num, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void CAST_ofb64_encrypt(const unsigned char* in, unsigned char* out, long length, const CAST_KEY* schedule, unsigned char* ivec, int* num);
+#endif
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/cmac.h b/CAPI/cpp/grpc/include/openssl/cmac.h
index f508618..3303c87 100644
--- a/CAPI/cpp/grpc/include/openssl/cmac.h
+++ b/CAPI/cpp/grpc/include/openssl/cmac.h
@@ -8,45 +8,42 @@
  */
 
 #ifndef OPENSSL_CMAC_H
-# define OPENSSL_CMAC_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_CMAC_H
-# endif
-
-# ifndef OPENSSL_NO_CMAC
-
-#  ifdef __cplusplus
-extern "C" {
-#  endif
-
-#  include <openssl/evp.h>
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/* Opaque */
-typedef struct CMAC_CTX_st CMAC_CTX;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 CMAC_CTX *CMAC_CTX_new(void);
-OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_cleanup(CMAC_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_free(CMAC_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 EVP_CIPHER_CTX *CMAC_CTX_get0_cipher_ctx(CMAC_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in);
-OSSL_DEPRECATEDIN_3_0 int CMAC_Init(CMAC_CTX *ctx,
-                                    const void *key, size_t keylen,
-                                    const EVP_CIPHER *cipher, ENGINE *impl);
-OSSL_DEPRECATEDIN_3_0 int CMAC_Update(CMAC_CTX *ctx,
-                                      const void *data, size_t dlen);
-OSSL_DEPRECATEDIN_3_0 int CMAC_Final(CMAC_CTX *ctx,
-                                     unsigned char *out, size_t *poutlen);
-OSSL_DEPRECATEDIN_3_0 int CMAC_resume(CMAC_CTX *ctx);
-#  endif
-
-#  ifdef  __cplusplus
+#define OPENSSL_CMAC_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CMAC_H
+#endif
+
+#ifndef OPENSSL_NO_CMAC
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <openssl/evp.h>
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /* Opaque */
+    typedef struct CMAC_CTX_st CMAC_CTX;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 CMAC_CTX* CMAC_CTX_new(void);
+    OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_cleanup(CMAC_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 void CMAC_CTX_free(CMAC_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 EVP_CIPHER_CTX* CMAC_CTX_get0_cipher_ctx(CMAC_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 int CMAC_CTX_copy(CMAC_CTX* out, const CMAC_CTX* in);
+    OSSL_DEPRECATEDIN_3_0 int CMAC_Init(CMAC_CTX* ctx, const void* key, size_t keylen, const EVP_CIPHER* cipher, ENGINE* impl);
+    OSSL_DEPRECATEDIN_3_0 int CMAC_Update(CMAC_CTX* ctx, const void* data, size_t dlen);
+    OSSL_DEPRECATEDIN_3_0 int CMAC_Final(CMAC_CTX* ctx, unsigned char* out, size_t* poutlen);
+    OSSL_DEPRECATEDIN_3_0 int CMAC_resume(CMAC_CTX* ctx);
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
+#endif
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/cmp.h b/CAPI/cpp/grpc/include/openssl/cmp.h
index 7f258dc..7553d03 100644
--- a/CAPI/cpp/grpc/include/openssl/cmp.h
+++ b/CAPI/cpp/grpc/include/openssl/cmp.h
@@ -12,30 +12,29 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_CMP_H
-# define OPENSSL_CMP_H
+#define OPENSSL_CMP_H
 
-# include <openssl/opensslconf.h>
-# ifndef OPENSSL_NO_CMP
+#include <openssl/opensslconf.h>
+#ifndef OPENSSL_NO_CMP
 
-#  include <openssl/crmf.h>
-#  include <openssl/cmperr.h>
-#  include <openssl/cmp_util.h>
-#  include <openssl/http.h>
+#include <openssl/crmf.h>
+#include <openssl/cmperr.h>
+#include <openssl/cmp_util.h>
+#include <openssl/http.h>
 
 /* explicit #includes not strictly needed since implied by the above: */
-#  include <openssl/types.h>
-#  include <openssl/safestack.h>
-#  include <openssl/x509.h>
-#  include <openssl/x509v3.h>
+#include <openssl/types.h>
+#include <openssl/safestack.h>
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
 
-#  ifdef __cplusplus
-extern "C" {
-#  endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  define OSSL_CMP_PVNO 2
+#define OSSL_CMP_PVNO 2
 
 /*-
  *   PKIFailureInfo ::= BIT STRING {
@@ -104,69 +103,69 @@ extern "C" {
  *       -- certificate already exists
  *   }
  */
-#  define OSSL_CMP_PKIFAILUREINFO_badAlg 0
-#  define OSSL_CMP_PKIFAILUREINFO_badMessageCheck 1
-#  define OSSL_CMP_PKIFAILUREINFO_badRequest 2
-#  define OSSL_CMP_PKIFAILUREINFO_badTime 3
-#  define OSSL_CMP_PKIFAILUREINFO_badCertId 4
-#  define OSSL_CMP_PKIFAILUREINFO_badDataFormat 5
-#  define OSSL_CMP_PKIFAILUREINFO_wrongAuthority 6
-#  define OSSL_CMP_PKIFAILUREINFO_incorrectData 7
-#  define OSSL_CMP_PKIFAILUREINFO_missingTimeStamp 8
-#  define OSSL_CMP_PKIFAILUREINFO_badPOP 9
-#  define OSSL_CMP_PKIFAILUREINFO_certRevoked 10
-#  define OSSL_CMP_PKIFAILUREINFO_certConfirmed 11
-#  define OSSL_CMP_PKIFAILUREINFO_wrongIntegrity 12
-#  define OSSL_CMP_PKIFAILUREINFO_badRecipientNonce 13
-#  define OSSL_CMP_PKIFAILUREINFO_timeNotAvailable 14
-#  define OSSL_CMP_PKIFAILUREINFO_unacceptedPolicy 15
-#  define OSSL_CMP_PKIFAILUREINFO_unacceptedExtension 16
-#  define OSSL_CMP_PKIFAILUREINFO_addInfoNotAvailable 17
-#  define OSSL_CMP_PKIFAILUREINFO_badSenderNonce 18
-#  define OSSL_CMP_PKIFAILUREINFO_badCertTemplate 19
-#  define OSSL_CMP_PKIFAILUREINFO_signerNotTrusted 20
-#  define OSSL_CMP_PKIFAILUREINFO_transactionIdInUse 21
-#  define OSSL_CMP_PKIFAILUREINFO_unsupportedVersion 22
-#  define OSSL_CMP_PKIFAILUREINFO_notAuthorized 23
-#  define OSSL_CMP_PKIFAILUREINFO_systemUnavail 24
-#  define OSSL_CMP_PKIFAILUREINFO_systemFailure 25
-#  define OSSL_CMP_PKIFAILUREINFO_duplicateCertReq 26
-#  define OSSL_CMP_PKIFAILUREINFO_MAX 26
-#  define OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN \
+#define OSSL_CMP_PKIFAILUREINFO_badAlg 0
+#define OSSL_CMP_PKIFAILUREINFO_badMessageCheck 1
+#define OSSL_CMP_PKIFAILUREINFO_badRequest 2
+#define OSSL_CMP_PKIFAILUREINFO_badTime 3
+#define OSSL_CMP_PKIFAILUREINFO_badCertId 4
+#define OSSL_CMP_PKIFAILUREINFO_badDataFormat 5
+#define OSSL_CMP_PKIFAILUREINFO_wrongAuthority 6
+#define OSSL_CMP_PKIFAILUREINFO_incorrectData 7
+#define OSSL_CMP_PKIFAILUREINFO_missingTimeStamp 8
+#define OSSL_CMP_PKIFAILUREINFO_badPOP 9
+#define OSSL_CMP_PKIFAILUREINFO_certRevoked 10
+#define OSSL_CMP_PKIFAILUREINFO_certConfirmed 11
+#define OSSL_CMP_PKIFAILUREINFO_wrongIntegrity 12
+#define OSSL_CMP_PKIFAILUREINFO_badRecipientNonce 13
+#define OSSL_CMP_PKIFAILUREINFO_timeNotAvailable 14
+#define OSSL_CMP_PKIFAILUREINFO_unacceptedPolicy 15
+#define OSSL_CMP_PKIFAILUREINFO_unacceptedExtension 16
+#define OSSL_CMP_PKIFAILUREINFO_addInfoNotAvailable 17
+#define OSSL_CMP_PKIFAILUREINFO_badSenderNonce 18
+#define OSSL_CMP_PKIFAILUREINFO_badCertTemplate 19
+#define OSSL_CMP_PKIFAILUREINFO_signerNotTrusted 20
+#define OSSL_CMP_PKIFAILUREINFO_transactionIdInUse 21
+#define OSSL_CMP_PKIFAILUREINFO_unsupportedVersion 22
+#define OSSL_CMP_PKIFAILUREINFO_notAuthorized 23
+#define OSSL_CMP_PKIFAILUREINFO_systemUnavail 24
+#define OSSL_CMP_PKIFAILUREINFO_systemFailure 25
+#define OSSL_CMP_PKIFAILUREINFO_duplicateCertReq 26
+#define OSSL_CMP_PKIFAILUREINFO_MAX 26
+#define OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN \
     ((1 << (OSSL_CMP_PKIFAILUREINFO_MAX + 1)) - 1)
-#  if OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN > INT_MAX
-#   error CMP_PKIFAILUREINFO_MAX bit pattern does not fit in type int
-#  endif
+#if OSSL_CMP_PKIFAILUREINFO_MAX_BIT_PATTERN > INT_MAX
+#error CMP_PKIFAILUREINFO_MAX bit pattern does not fit in type int
+#endif
 
-typedef ASN1_BIT_STRING OSSL_CMP_PKIFAILUREINFO;
+    typedef ASN1_BIT_STRING OSSL_CMP_PKIFAILUREINFO;
 
-#  define OSSL_CMP_CTX_FAILINFO_badAlg (1 << 0)
-#  define OSSL_CMP_CTX_FAILINFO_badMessageCheck (1 << 1)
-#  define OSSL_CMP_CTX_FAILINFO_badRequest (1 << 2)
-#  define OSSL_CMP_CTX_FAILINFO_badTime (1 << 3)
-#  define OSSL_CMP_CTX_FAILINFO_badCertId (1 << 4)
-#  define OSSL_CMP_CTX_FAILINFO_badDataFormat (1 << 5)
-#  define OSSL_CMP_CTX_FAILINFO_wrongAuthority (1 << 6)
-#  define OSSL_CMP_CTX_FAILINFO_incorrectData (1 << 7)
-#  define OSSL_CMP_CTX_FAILINFO_missingTimeStamp (1 << 8)
-#  define OSSL_CMP_CTX_FAILINFO_badPOP (1 << 9)
-#  define OSSL_CMP_CTX_FAILINFO_certRevoked (1 << 10)
-#  define OSSL_CMP_CTX_FAILINFO_certConfirmed (1 << 11)
-#  define OSSL_CMP_CTX_FAILINFO_wrongIntegrity (1 << 12)
-#  define OSSL_CMP_CTX_FAILINFO_badRecipientNonce (1 << 13)
-#  define OSSL_CMP_CTX_FAILINFO_timeNotAvailable (1 << 14)
-#  define OSSL_CMP_CTX_FAILINFO_unacceptedPolicy (1 << 15)
-#  define OSSL_CMP_CTX_FAILINFO_unacceptedExtension (1 << 16)
-#  define OSSL_CMP_CTX_FAILINFO_addInfoNotAvailable (1 << 17)
-#  define OSSL_CMP_CTX_FAILINFO_badSenderNonce (1 << 18)
-#  define OSSL_CMP_CTX_FAILINFO_badCertTemplate (1 << 19)
-#  define OSSL_CMP_CTX_FAILINFO_signerNotTrusted (1 << 20)
-#  define OSSL_CMP_CTX_FAILINFO_transactionIdInUse (1 << 21)
-#  define OSSL_CMP_CTX_FAILINFO_unsupportedVersion (1 << 22)
-#  define OSSL_CMP_CTX_FAILINFO_notAuthorized (1 << 23)
-#  define OSSL_CMP_CTX_FAILINFO_systemUnavail (1 << 24)
-#  define OSSL_CMP_CTX_FAILINFO_systemFailure (1 << 25)
-#  define OSSL_CMP_CTX_FAILINFO_duplicateCertReq (1 << 26)
+#define OSSL_CMP_CTX_FAILINFO_badAlg (1 << 0)
+#define OSSL_CMP_CTX_FAILINFO_badMessageCheck (1 << 1)
+#define OSSL_CMP_CTX_FAILINFO_badRequest (1 << 2)
+#define OSSL_CMP_CTX_FAILINFO_badTime (1 << 3)
+#define OSSL_CMP_CTX_FAILINFO_badCertId (1 << 4)
+#define OSSL_CMP_CTX_FAILINFO_badDataFormat (1 << 5)
+#define OSSL_CMP_CTX_FAILINFO_wrongAuthority (1 << 6)
+#define OSSL_CMP_CTX_FAILINFO_incorrectData (1 << 7)
+#define OSSL_CMP_CTX_FAILINFO_missingTimeStamp (1 << 8)
+#define OSSL_CMP_CTX_FAILINFO_badPOP (1 << 9)
+#define OSSL_CMP_CTX_FAILINFO_certRevoked (1 << 10)
+#define OSSL_CMP_CTX_FAILINFO_certConfirmed (1 << 11)
+#define OSSL_CMP_CTX_FAILINFO_wrongIntegrity (1 << 12)
+#define OSSL_CMP_CTX_FAILINFO_badRecipientNonce (1 << 13)
+#define OSSL_CMP_CTX_FAILINFO_timeNotAvailable (1 << 14)
+#define OSSL_CMP_CTX_FAILINFO_unacceptedPolicy (1 << 15)
+#define OSSL_CMP_CTX_FAILINFO_unacceptedExtension (1 << 16)
+#define OSSL_CMP_CTX_FAILINFO_addInfoNotAvailable (1 << 17)
+#define OSSL_CMP_CTX_FAILINFO_badSenderNonce (1 << 18)
+#define OSSL_CMP_CTX_FAILINFO_badCertTemplate (1 << 19)
+#define OSSL_CMP_CTX_FAILINFO_signerNotTrusted (1 << 20)
+#define OSSL_CMP_CTX_FAILINFO_transactionIdInUse (1 << 21)
+#define OSSL_CMP_CTX_FAILINFO_unsupportedVersion (1 << 22)
+#define OSSL_CMP_CTX_FAILINFO_notAuthorized (1 << 23)
+#define OSSL_CMP_CTX_FAILINFO_systemUnavail (1 << 24)
+#define OSSL_CMP_CTX_FAILINFO_systemFailure (1 << 25)
+#define OSSL_CMP_CTX_FAILINFO_duplicateCertReq (1 << 26)
 
 /*-
  *   PKIStatus ::= INTEGER {
@@ -193,400 +192,350 @@ typedef ASN1_BIT_STRING OSSL_CMP_PKIFAILUREINFO;
  *       -- CertReqMsg
  *   }
  */
-#  define OSSL_CMP_PKISTATUS_accepted 0
-#  define OSSL_CMP_PKISTATUS_grantedWithMods 1
-#  define OSSL_CMP_PKISTATUS_rejection 2
-#  define OSSL_CMP_PKISTATUS_waiting 3
-#  define OSSL_CMP_PKISTATUS_revocationWarning 4
-#  define OSSL_CMP_PKISTATUS_revocationNotification 5
-#  define OSSL_CMP_PKISTATUS_keyUpdateWarning 6
+#define OSSL_CMP_PKISTATUS_accepted 0
+#define OSSL_CMP_PKISTATUS_grantedWithMods 1
+#define OSSL_CMP_PKISTATUS_rejection 2
+#define OSSL_CMP_PKISTATUS_waiting 3
+#define OSSL_CMP_PKISTATUS_revocationWarning 4
+#define OSSL_CMP_PKISTATUS_revocationNotification 5
+#define OSSL_CMP_PKISTATUS_keyUpdateWarning 6
 
-typedef ASN1_INTEGER OSSL_CMP_PKISTATUS;
-DECLARE_ASN1_ITEM(OSSL_CMP_PKISTATUS)
+    typedef ASN1_INTEGER OSSL_CMP_PKISTATUS;
+    DECLARE_ASN1_ITEM(OSSL_CMP_PKISTATUS)
 
-#  define OSSL_CMP_CERTORENCCERT_CERTIFICATE 0
-#  define OSSL_CMP_CERTORENCCERT_ENCRYPTEDCERT 1
+#define OSSL_CMP_CERTORENCCERT_CERTIFICATE 0
+#define OSSL_CMP_CERTORENCCERT_ENCRYPTEDCERT 1
 
-/* data type declarations */
-typedef struct ossl_cmp_ctx_st OSSL_CMP_CTX;
-typedef struct ossl_cmp_pkiheader_st OSSL_CMP_PKIHEADER;
-DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKIHEADER)
-typedef struct ossl_cmp_msg_st OSSL_CMP_MSG;
-DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_MSG)
-DECLARE_ASN1_ENCODE_FUNCTIONS(OSSL_CMP_MSG, OSSL_CMP_MSG, OSSL_CMP_MSG)
-typedef struct ossl_cmp_certstatus_st OSSL_CMP_CERTSTATUS;
-SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS)
+    /* data type declarations */
+    typedef struct ossl_cmp_ctx_st OSSL_CMP_CTX;
+    typedef struct ossl_cmp_pkiheader_st OSSL_CMP_PKIHEADER;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKIHEADER)
+    typedef struct ossl_cmp_msg_st OSSL_CMP_MSG;
+    DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_MSG)
+    DECLARE_ASN1_ENCODE_FUNCTIONS(OSSL_CMP_MSG, OSSL_CMP_MSG, OSSL_CMP_MSG)
+    typedef struct ossl_cmp_certstatus_st OSSL_CMP_CERTSTATUS;
+    SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS, OSSL_CMP_CERTSTATUS)
 #define sk_OSSL_CMP_CERTSTATUS_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk))
-#define sk_OSSL_CMP_CERTSTATUS_value(sk, idx) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx)))
-#define sk_OSSL_CMP_CERTSTATUS_new(cmp) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
-#define sk_OSSL_CMP_CERTSTATUS_new_null() ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new_null())
-#define sk_OSSL_CMP_CERTSTATUS_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTSTATUS_value(sk, idx) ((OSSL_CMP_CERTSTATUS*)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTSTATUS_new(cmp) ((STACK_OF(OSSL_CMP_CERTSTATUS)*)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTSTATUS_new_null() ((STACK_OF(OSSL_CMP_CERTSTATUS)*)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTSTATUS_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTSTATUS)*)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp), (n)))
 #define sk_OSSL_CMP_CERTSTATUS_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (n))
 #define sk_OSSL_CMP_CERTSTATUS_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
 #define sk_OSSL_CMP_CERTSTATUS_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
-#define sk_OSSL_CMP_CERTSTATUS_delete(sk, i) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (i)))
-#define sk_OSSL_CMP_CERTSTATUS_delete_ptr(sk, ptr) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CERTSTATUS_delete(sk, i) ((OSSL_CMP_CERTSTATUS*)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTSTATUS_delete_ptr(sk, ptr) ((OSSL_CMP_CERTSTATUS*)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
 #define sk_OSSL_CMP_CERTSTATUS_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
 #define sk_OSSL_CMP_CERTSTATUS_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
-#define sk_OSSL_CMP_CERTSTATUS_pop(sk) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
-#define sk_OSSL_CMP_CERTSTATUS_shift(sk) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
-#define sk_OSSL_CMP_CERTSTATUS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk),ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTSTATUS_pop(sk) ((OSSL_CMP_CERTSTATUS*)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_shift(sk) ((OSSL_CMP_CERTSTATUS*)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc))
 #define sk_OSSL_CMP_CERTSTATUS_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr), (idx))
-#define sk_OSSL_CMP_CERTSTATUS_set(sk, idx, ptr) ((OSSL_CMP_CERTSTATUS *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
+#define sk_OSSL_CMP_CERTSTATUS_set(sk, idx, ptr) ((OSSL_CMP_CERTSTATUS*)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr)))
 #define sk_OSSL_CMP_CERTSTATUS_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
 #define sk_OSSL_CMP_CERTSTATUS_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr))
 #define sk_OSSL_CMP_CERTSTATUS_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_type(ptr), pnum)
 #define sk_OSSL_CMP_CERTSTATUS_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk))
 #define sk_OSSL_CMP_CERTSTATUS_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk))
-#define sk_OSSL_CMP_CERTSTATUS_dup(sk) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk)))
-#define sk_OSSL_CMP_CERTSTATUS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTSTATUS) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTSTATUS_dup(sk) ((STACK_OF(OSSL_CMP_CERTSTATUS)*)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk)))
+#define sk_OSSL_CMP_CERTSTATUS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTSTATUS)*)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTSTATUS_freefunc_type(freefunc)))
 #define sk_OSSL_CMP_CERTSTATUS_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTSTATUS_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTSTATUS_sk_type(sk), ossl_check_OSSL_CMP_CERTSTATUS_compfunc_type(cmp)))
 
-typedef struct ossl_cmp_itav_st OSSL_CMP_ITAV;
-DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_ITAV)
-SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_ITAV, OSSL_CMP_ITAV, OSSL_CMP_ITAV)
+    typedef struct ossl_cmp_itav_st OSSL_CMP_ITAV;
+    DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_ITAV)
+    SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_ITAV, OSSL_CMP_ITAV, OSSL_CMP_ITAV)
 #define sk_OSSL_CMP_ITAV_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk))
-#define sk_OSSL_CMP_ITAV_value(sk, idx) ((OSSL_CMP_ITAV *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), (idx)))
-#define sk_OSSL_CMP_ITAV_new(cmp) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
-#define sk_OSSL_CMP_ITAV_new_null() ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new_null())
-#define sk_OSSL_CMP_ITAV_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_ITAV_value(sk, idx) ((OSSL_CMP_ITAV*)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_ITAV_new(cmp) ((STACK_OF(OSSL_CMP_ITAV)*)OPENSSL_sk_new(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
+#define sk_OSSL_CMP_ITAV_new_null() ((STACK_OF(OSSL_CMP_ITAV)*)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_ITAV_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_ITAV)*)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp), (n)))
 #define sk_OSSL_CMP_ITAV_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (n))
 #define sk_OSSL_CMP_ITAV_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
 #define sk_OSSL_CMP_ITAV_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
-#define sk_OSSL_CMP_ITAV_delete(sk, i) ((OSSL_CMP_ITAV *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (i)))
-#define sk_OSSL_CMP_ITAV_delete_ptr(sk, ptr) ((OSSL_CMP_ITAV *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr)))
+#define sk_OSSL_CMP_ITAV_delete(sk, i) ((OSSL_CMP_ITAV*)OPENSSL_sk_delete(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (i)))
+#define sk_OSSL_CMP_ITAV_delete_ptr(sk, ptr) ((OSSL_CMP_ITAV*)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr)))
 #define sk_OSSL_CMP_ITAV_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
 #define sk_OSSL_CMP_ITAV_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
-#define sk_OSSL_CMP_ITAV_pop(sk) ((OSSL_CMP_ITAV *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
-#define sk_OSSL_CMP_ITAV_shift(sk) ((OSSL_CMP_ITAV *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
-#define sk_OSSL_CMP_ITAV_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk),ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc))
+#define sk_OSSL_CMP_ITAV_pop(sk) ((OSSL_CMP_ITAV*)OPENSSL_sk_pop(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_shift(sk) ((OSSL_CMP_ITAV*)OPENSSL_sk_shift(ossl_check_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc))
 #define sk_OSSL_CMP_ITAV_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr), (idx))
-#define sk_OSSL_CMP_ITAV_set(sk, idx, ptr) ((OSSL_CMP_ITAV *)OPENSSL_sk_set(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (idx), ossl_check_OSSL_CMP_ITAV_type(ptr)))
+#define sk_OSSL_CMP_ITAV_set(sk, idx, ptr) ((OSSL_CMP_ITAV*)OPENSSL_sk_set(ossl_check_OSSL_CMP_ITAV_sk_type(sk), (idx), ossl_check_OSSL_CMP_ITAV_type(ptr)))
 #define sk_OSSL_CMP_ITAV_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
 #define sk_OSSL_CMP_ITAV_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr))
 #define sk_OSSL_CMP_ITAV_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_type(ptr), pnum)
 #define sk_OSSL_CMP_ITAV_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_ITAV_sk_type(sk))
 #define sk_OSSL_CMP_ITAV_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk))
-#define sk_OSSL_CMP_ITAV_dup(sk) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk)))
-#define sk_OSSL_CMP_ITAV_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_ITAV) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_ITAV_dup(sk) ((STACK_OF(OSSL_CMP_ITAV)*)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk)))
+#define sk_OSSL_CMP_ITAV_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_ITAV)*)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_ITAV_freefunc_type(freefunc)))
 #define sk_OSSL_CMP_ITAV_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_ITAV_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_ITAV_sk_type(sk), ossl_check_OSSL_CMP_ITAV_compfunc_type(cmp)))
 
-typedef struct ossl_cmp_revrepcontent_st OSSL_CMP_REVREPCONTENT;
-typedef struct ossl_cmp_pkisi_st OSSL_CMP_PKISI;
-DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKISI)
-DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_PKISI)
-SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_PKISI, OSSL_CMP_PKISI, OSSL_CMP_PKISI)
+    typedef struct ossl_cmp_revrepcontent_st OSSL_CMP_REVREPCONTENT;
+    typedef struct ossl_cmp_pkisi_st OSSL_CMP_PKISI;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CMP_PKISI)
+    DECLARE_ASN1_DUP_FUNCTION(OSSL_CMP_PKISI)
+    SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_PKISI, OSSL_CMP_PKISI, OSSL_CMP_PKISI)
 #define sk_OSSL_CMP_PKISI_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk))
-#define sk_OSSL_CMP_PKISI_value(sk, idx) ((OSSL_CMP_PKISI *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), (idx)))
-#define sk_OSSL_CMP_PKISI_new(cmp) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
-#define sk_OSSL_CMP_PKISI_new_null() ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new_null())
-#define sk_OSSL_CMP_PKISI_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_PKISI_value(sk, idx) ((OSSL_CMP_PKISI*)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_PKISI_new(cmp) ((STACK_OF(OSSL_CMP_PKISI)*)OPENSSL_sk_new(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
+#define sk_OSSL_CMP_PKISI_new_null() ((STACK_OF(OSSL_CMP_PKISI)*)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_PKISI_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_PKISI)*)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp), (n)))
 #define sk_OSSL_CMP_PKISI_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (n))
 #define sk_OSSL_CMP_PKISI_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
 #define sk_OSSL_CMP_PKISI_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
-#define sk_OSSL_CMP_PKISI_delete(sk, i) ((OSSL_CMP_PKISI *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (i)))
-#define sk_OSSL_CMP_PKISI_delete_ptr(sk, ptr) ((OSSL_CMP_PKISI *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr)))
+#define sk_OSSL_CMP_PKISI_delete(sk, i) ((OSSL_CMP_PKISI*)OPENSSL_sk_delete(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (i)))
+#define sk_OSSL_CMP_PKISI_delete_ptr(sk, ptr) ((OSSL_CMP_PKISI*)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr)))
 #define sk_OSSL_CMP_PKISI_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
 #define sk_OSSL_CMP_PKISI_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
-#define sk_OSSL_CMP_PKISI_pop(sk) ((OSSL_CMP_PKISI *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
-#define sk_OSSL_CMP_PKISI_shift(sk) ((OSSL_CMP_PKISI *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
-#define sk_OSSL_CMP_PKISI_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk),ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc))
+#define sk_OSSL_CMP_PKISI_pop(sk) ((OSSL_CMP_PKISI*)OPENSSL_sk_pop(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_shift(sk) ((OSSL_CMP_PKISI*)OPENSSL_sk_shift(ossl_check_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc))
 #define sk_OSSL_CMP_PKISI_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr), (idx))
-#define sk_OSSL_CMP_PKISI_set(sk, idx, ptr) ((OSSL_CMP_PKISI *)OPENSSL_sk_set(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (idx), ossl_check_OSSL_CMP_PKISI_type(ptr)))
+#define sk_OSSL_CMP_PKISI_set(sk, idx, ptr) ((OSSL_CMP_PKISI*)OPENSSL_sk_set(ossl_check_OSSL_CMP_PKISI_sk_type(sk), (idx), ossl_check_OSSL_CMP_PKISI_type(ptr)))
 #define sk_OSSL_CMP_PKISI_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
 #define sk_OSSL_CMP_PKISI_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr))
 #define sk_OSSL_CMP_PKISI_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_type(ptr), pnum)
 #define sk_OSSL_CMP_PKISI_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_PKISI_sk_type(sk))
 #define sk_OSSL_CMP_PKISI_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk))
-#define sk_OSSL_CMP_PKISI_dup(sk) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk)))
-#define sk_OSSL_CMP_PKISI_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_PKISI) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_PKISI_dup(sk) ((STACK_OF(OSSL_CMP_PKISI)*)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk)))
+#define sk_OSSL_CMP_PKISI_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_PKISI)*)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_PKISI_freefunc_type(freefunc)))
 #define sk_OSSL_CMP_PKISI_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_PKISI_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_PKISI_sk_type(sk), ossl_check_OSSL_CMP_PKISI_compfunc_type(cmp)))
 
-typedef struct ossl_cmp_certrepmessage_st OSSL_CMP_CERTREPMESSAGE;
-SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE)
+    typedef struct ossl_cmp_certrepmessage_st OSSL_CMP_CERTREPMESSAGE;
+    SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE, OSSL_CMP_CERTREPMESSAGE)
 #define sk_OSSL_CMP_CERTREPMESSAGE_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
-#define sk_OSSL_CMP_CERTREPMESSAGE_value(sk, idx) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx)))
-#define sk_OSSL_CMP_CERTREPMESSAGE_new(cmp) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
-#define sk_OSSL_CMP_CERTREPMESSAGE_new_null() ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new_null())
-#define sk_OSSL_CMP_CERTREPMESSAGE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_value(sk, idx) ((OSSL_CMP_CERTREPMESSAGE*)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_new(cmp) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE)*)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_new_null() ((STACK_OF(OSSL_CMP_CERTREPMESSAGE)*)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTREPMESSAGE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE)*)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp), (n)))
 #define sk_OSSL_CMP_CERTREPMESSAGE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (n))
 #define sk_OSSL_CMP_CERTREPMESSAGE_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
 #define sk_OSSL_CMP_CERTREPMESSAGE_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
-#define sk_OSSL_CMP_CERTREPMESSAGE_delete(sk, i) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (i)))
-#define sk_OSSL_CMP_CERTREPMESSAGE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_delete(sk, i) ((OSSL_CMP_CERTREPMESSAGE*)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTREPMESSAGE*)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
 #define sk_OSSL_CMP_CERTREPMESSAGE_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
 #define sk_OSSL_CMP_CERTREPMESSAGE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
-#define sk_OSSL_CMP_CERTREPMESSAGE_pop(sk) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
-#define sk_OSSL_CMP_CERTREPMESSAGE_shift(sk) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
-#define sk_OSSL_CMP_CERTREPMESSAGE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk),ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTREPMESSAGE_pop(sk) ((OSSL_CMP_CERTREPMESSAGE*)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_shift(sk) ((OSSL_CMP_CERTREPMESSAGE*)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc))
 #define sk_OSSL_CMP_CERTREPMESSAGE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr), (idx))
-#define sk_OSSL_CMP_CERTREPMESSAGE_set(sk, idx, ptr) ((OSSL_CMP_CERTREPMESSAGE *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_set(sk, idx, ptr) ((OSSL_CMP_CERTREPMESSAGE*)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr)))
 #define sk_OSSL_CMP_CERTREPMESSAGE_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
 #define sk_OSSL_CMP_CERTREPMESSAGE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr))
 #define sk_OSSL_CMP_CERTREPMESSAGE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_type(ptr), pnum)
 #define sk_OSSL_CMP_CERTREPMESSAGE_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
 #define sk_OSSL_CMP_CERTREPMESSAGE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk))
-#define sk_OSSL_CMP_CERTREPMESSAGE_dup(sk) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
-#define sk_OSSL_CMP_CERTREPMESSAGE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_dup(sk) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE)*)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTREPMESSAGE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTREPMESSAGE)*)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTREPMESSAGE_freefunc_type(freefunc)))
 #define sk_OSSL_CMP_CERTREPMESSAGE_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTREPMESSAGE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTREPMESSAGE_sk_type(sk), ossl_check_OSSL_CMP_CERTREPMESSAGE_compfunc_type(cmp)))
 
-typedef struct ossl_cmp_pollrep_st OSSL_CMP_POLLREP;
-typedef STACK_OF(OSSL_CMP_POLLREP) OSSL_CMP_POLLREPCONTENT;
-typedef struct ossl_cmp_certresponse_st OSSL_CMP_CERTRESPONSE;
-SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE)
+    typedef struct ossl_cmp_pollrep_st OSSL_CMP_POLLREP;
+    typedef STACK_OF(OSSL_CMP_POLLREP) OSSL_CMP_POLLREPCONTENT;
+    typedef struct ossl_cmp_certresponse_st OSSL_CMP_CERTRESPONSE;
+    SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE, OSSL_CMP_CERTRESPONSE)
 #define sk_OSSL_CMP_CERTRESPONSE_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk))
-#define sk_OSSL_CMP_CERTRESPONSE_value(sk, idx) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx)))
-#define sk_OSSL_CMP_CERTRESPONSE_new(cmp) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
-#define sk_OSSL_CMP_CERTRESPONSE_new_null() ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new_null())
-#define sk_OSSL_CMP_CERTRESPONSE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp), (n)))
+#define sk_OSSL_CMP_CERTRESPONSE_value(sk, idx) ((OSSL_CMP_CERTRESPONSE*)OPENSSL_sk_value(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx)))
+#define sk_OSSL_CMP_CERTRESPONSE_new(cmp) ((STACK_OF(OSSL_CMP_CERTRESPONSE)*)OPENSSL_sk_new(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
+#define sk_OSSL_CMP_CERTRESPONSE_new_null() ((STACK_OF(OSSL_CMP_CERTRESPONSE)*)OPENSSL_sk_new_null())
+#define sk_OSSL_CMP_CERTRESPONSE_new_reserve(cmp, n) ((STACK_OF(OSSL_CMP_CERTRESPONSE)*)OPENSSL_sk_new_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp), (n)))
 #define sk_OSSL_CMP_CERTRESPONSE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (n))
 #define sk_OSSL_CMP_CERTRESPONSE_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
 #define sk_OSSL_CMP_CERTRESPONSE_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
-#define sk_OSSL_CMP_CERTRESPONSE_delete(sk, i) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (i)))
-#define sk_OSSL_CMP_CERTRESPONSE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
+#define sk_OSSL_CMP_CERTRESPONSE_delete(sk, i) ((OSSL_CMP_CERTRESPONSE*)OPENSSL_sk_delete(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (i)))
+#define sk_OSSL_CMP_CERTRESPONSE_delete_ptr(sk, ptr) ((OSSL_CMP_CERTRESPONSE*)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
 #define sk_OSSL_CMP_CERTRESPONSE_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
 #define sk_OSSL_CMP_CERTRESPONSE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
-#define sk_OSSL_CMP_CERTRESPONSE_pop(sk) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
-#define sk_OSSL_CMP_CERTRESPONSE_shift(sk) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
-#define sk_OSSL_CMP_CERTRESPONSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk),ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc))
+#define sk_OSSL_CMP_CERTRESPONSE_pop(sk) ((OSSL_CMP_CERTRESPONSE*)OPENSSL_sk_pop(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_shift(sk) ((OSSL_CMP_CERTRESPONSE*)OPENSSL_sk_shift(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc))
 #define sk_OSSL_CMP_CERTRESPONSE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr), (idx))
-#define sk_OSSL_CMP_CERTRESPONSE_set(sk, idx, ptr) ((OSSL_CMP_CERTRESPONSE *)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
+#define sk_OSSL_CMP_CERTRESPONSE_set(sk, idx, ptr) ((OSSL_CMP_CERTRESPONSE*)OPENSSL_sk_set(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), (idx), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr)))
 #define sk_OSSL_CMP_CERTRESPONSE_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
 #define sk_OSSL_CMP_CERTRESPONSE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr))
 #define sk_OSSL_CMP_CERTRESPONSE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_type(ptr), pnum)
 #define sk_OSSL_CMP_CERTRESPONSE_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk))
 #define sk_OSSL_CMP_CERTRESPONSE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk))
-#define sk_OSSL_CMP_CERTRESPONSE_dup(sk) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
-#define sk_OSSL_CMP_CERTRESPONSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTRESPONSE) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc)))
+#define sk_OSSL_CMP_CERTRESPONSE_dup(sk) ((STACK_OF(OSSL_CMP_CERTRESPONSE)*)OPENSSL_sk_dup(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk)))
+#define sk_OSSL_CMP_CERTRESPONSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CMP_CERTRESPONSE)*)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_copyfunc_type(copyfunc), ossl_check_OSSL_CMP_CERTRESPONSE_freefunc_type(freefunc)))
 #define sk_OSSL_CMP_CERTRESPONSE_set_cmp_func(sk, cmp) ((sk_OSSL_CMP_CERTRESPONSE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CMP_CERTRESPONSE_sk_type(sk), ossl_check_OSSL_CMP_CERTRESPONSE_compfunc_type(cmp)))
 
-typedef STACK_OF(ASN1_UTF8STRING) OSSL_CMP_PKIFREETEXT;
+    typedef STACK_OF(ASN1_UTF8STRING) OSSL_CMP_PKIFREETEXT;
 
-/*
- * function DECLARATIONS
- */
+    /*
+     * function DECLARATIONS
+     */
 
-/* from cmp_asn.c */
-OSSL_CMP_ITAV *OSSL_CMP_ITAV_create(ASN1_OBJECT *type, ASN1_TYPE *value);
-void OSSL_CMP_ITAV_set0(OSSL_CMP_ITAV *itav, ASN1_OBJECT *type,
-                        ASN1_TYPE *value);
-ASN1_OBJECT *OSSL_CMP_ITAV_get0_type(const OSSL_CMP_ITAV *itav);
-ASN1_TYPE *OSSL_CMP_ITAV_get0_value(const OSSL_CMP_ITAV *itav);
-int OSSL_CMP_ITAV_push0_stack_item(STACK_OF(OSSL_CMP_ITAV) **itav_sk_p,
-                                   OSSL_CMP_ITAV *itav);
-void OSSL_CMP_ITAV_free(OSSL_CMP_ITAV *itav);
-void OSSL_CMP_MSG_free(OSSL_CMP_MSG *msg);
+    /* from cmp_asn.c */
+    OSSL_CMP_ITAV* OSSL_CMP_ITAV_create(ASN1_OBJECT* type, ASN1_TYPE* value);
+    void OSSL_CMP_ITAV_set0(OSSL_CMP_ITAV* itav, ASN1_OBJECT* type, ASN1_TYPE* value);
+    ASN1_OBJECT* OSSL_CMP_ITAV_get0_type(const OSSL_CMP_ITAV* itav);
+    ASN1_TYPE* OSSL_CMP_ITAV_get0_value(const OSSL_CMP_ITAV* itav);
+    int OSSL_CMP_ITAV_push0_stack_item(STACK_OF(OSSL_CMP_ITAV) * *itav_sk_p, OSSL_CMP_ITAV* itav);
+    void OSSL_CMP_ITAV_free(OSSL_CMP_ITAV* itav);
+    void OSSL_CMP_MSG_free(OSSL_CMP_MSG* msg);
 
-/* from cmp_ctx.c */
-OSSL_CMP_CTX *OSSL_CMP_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
-void OSSL_CMP_CTX_free(OSSL_CMP_CTX *ctx);
-int OSSL_CMP_CTX_reinit(OSSL_CMP_CTX *ctx);
+    /* from cmp_ctx.c */
+    OSSL_CMP_CTX* OSSL_CMP_CTX_new(OSSL_LIB_CTX* libctx, const char* propq);
+    void OSSL_CMP_CTX_free(OSSL_CMP_CTX* ctx);
+    int OSSL_CMP_CTX_reinit(OSSL_CMP_CTX* ctx);
 /* CMP general options: */
-#  define OSSL_CMP_OPT_LOG_VERBOSITY 0
+#define OSSL_CMP_OPT_LOG_VERBOSITY 0
 /* CMP transfer options: */
-#  define OSSL_CMP_OPT_KEEP_ALIVE 10
-#  define OSSL_CMP_OPT_MSG_TIMEOUT 11
-#  define OSSL_CMP_OPT_TOTAL_TIMEOUT 12
+#define OSSL_CMP_OPT_KEEP_ALIVE 10
+#define OSSL_CMP_OPT_MSG_TIMEOUT 11
+#define OSSL_CMP_OPT_TOTAL_TIMEOUT 12
 /* CMP request options: */
-#  define OSSL_CMP_OPT_VALIDITY_DAYS 20
-#  define OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT 21
-#  define OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL 22
-#  define OSSL_CMP_OPT_POLICIES_CRITICAL 23
-#  define OSSL_CMP_OPT_POPO_METHOD 24
-#  define OSSL_CMP_OPT_IMPLICIT_CONFIRM 25
-#  define OSSL_CMP_OPT_DISABLE_CONFIRM 26
-#  define OSSL_CMP_OPT_REVOCATION_REASON 27
+#define OSSL_CMP_OPT_VALIDITY_DAYS 20
+#define OSSL_CMP_OPT_SUBJECTALTNAME_NODEFAULT 21
+#define OSSL_CMP_OPT_SUBJECTALTNAME_CRITICAL 22
+#define OSSL_CMP_OPT_POLICIES_CRITICAL 23
+#define OSSL_CMP_OPT_POPO_METHOD 24
+#define OSSL_CMP_OPT_IMPLICIT_CONFIRM 25
+#define OSSL_CMP_OPT_DISABLE_CONFIRM 26
+#define OSSL_CMP_OPT_REVOCATION_REASON 27
 /* CMP protection options: */
-#  define OSSL_CMP_OPT_UNPROTECTED_SEND 30
-#  define OSSL_CMP_OPT_UNPROTECTED_ERRORS 31
-#  define OSSL_CMP_OPT_OWF_ALGNID 32
-#  define OSSL_CMP_OPT_MAC_ALGNID 33
-#  define OSSL_CMP_OPT_DIGEST_ALGNID 34
-#  define OSSL_CMP_OPT_IGNORE_KEYUSAGE 35
-#  define OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR 36
-int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX *ctx, int opt, int val);
-int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX *ctx, int opt);
-/* CMP-specific callback for logging and outputting the error queue: */
-int OSSL_CMP_CTX_set_log_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_log_cb_t cb);
-#  define OSSL_CMP_CTX_set_log_verbosity(ctx, level) \
+#define OSSL_CMP_OPT_UNPROTECTED_SEND 30
+#define OSSL_CMP_OPT_UNPROTECTED_ERRORS 31
+#define OSSL_CMP_OPT_OWF_ALGNID 32
+#define OSSL_CMP_OPT_MAC_ALGNID 33
+#define OSSL_CMP_OPT_DIGEST_ALGNID 34
+#define OSSL_CMP_OPT_IGNORE_KEYUSAGE 35
+#define OSSL_CMP_OPT_PERMIT_TA_IN_EXTRACERTS_FOR_IR 36
+    int OSSL_CMP_CTX_set_option(OSSL_CMP_CTX* ctx, int opt, int val);
+    int OSSL_CMP_CTX_get_option(const OSSL_CMP_CTX* ctx, int opt);
+    /* CMP-specific callback for logging and outputting the error queue: */
+    int OSSL_CMP_CTX_set_log_cb(OSSL_CMP_CTX* ctx, OSSL_CMP_log_cb_t cb);
+#define OSSL_CMP_CTX_set_log_verbosity(ctx, level) \
     OSSL_CMP_CTX_set_option(ctx, OSSL_CMP_OPT_LOG_VERBOSITY, level)
-void OSSL_CMP_CTX_print_errors(const OSSL_CMP_CTX *ctx);
-/* message transfer: */
-int OSSL_CMP_CTX_set1_serverPath(OSSL_CMP_CTX *ctx, const char *path);
-int OSSL_CMP_CTX_set1_server(OSSL_CMP_CTX *ctx, const char *address);
-int OSSL_CMP_CTX_set_serverPort(OSSL_CMP_CTX *ctx, int port);
-int OSSL_CMP_CTX_set1_proxy(OSSL_CMP_CTX *ctx, const char *name);
-int OSSL_CMP_CTX_set1_no_proxy(OSSL_CMP_CTX *ctx, const char *names);
-int OSSL_CMP_CTX_set_http_cb(OSSL_CMP_CTX *ctx, OSSL_HTTP_bio_cb_t cb);
-int OSSL_CMP_CTX_set_http_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
-void *OSSL_CMP_CTX_get_http_cb_arg(const OSSL_CMP_CTX *ctx);
-typedef OSSL_CMP_MSG *(*OSSL_CMP_transfer_cb_t) (OSSL_CMP_CTX *ctx,
-                                                 const OSSL_CMP_MSG *req);
-int OSSL_CMP_CTX_set_transfer_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_transfer_cb_t cb);
-int OSSL_CMP_CTX_set_transfer_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
-void *OSSL_CMP_CTX_get_transfer_cb_arg(const OSSL_CMP_CTX *ctx);
-/* server authentication: */
-int OSSL_CMP_CTX_set1_srvCert(OSSL_CMP_CTX *ctx, X509 *cert);
-int OSSL_CMP_CTX_set1_expected_sender(OSSL_CMP_CTX *ctx, const X509_NAME *name);
-int OSSL_CMP_CTX_set0_trustedStore(OSSL_CMP_CTX *ctx, X509_STORE *store);
-X509_STORE *OSSL_CMP_CTX_get0_trustedStore(const OSSL_CMP_CTX *ctx);
-int OSSL_CMP_CTX_set1_untrusted(OSSL_CMP_CTX *ctx, STACK_OF(X509) *certs);
-STACK_OF(X509) *OSSL_CMP_CTX_get0_untrusted(const OSSL_CMP_CTX *ctx);
-/* client authentication: */
-int OSSL_CMP_CTX_set1_cert(OSSL_CMP_CTX *ctx, X509 *cert);
-int OSSL_CMP_CTX_build_cert_chain(OSSL_CMP_CTX *ctx, X509_STORE *own_trusted,
-                                  STACK_OF(X509) *candidates);
-int OSSL_CMP_CTX_set1_pkey(OSSL_CMP_CTX *ctx, EVP_PKEY *pkey);
-int OSSL_CMP_CTX_set1_referenceValue(OSSL_CMP_CTX *ctx,
-                                     const unsigned char *ref, int len);
-int OSSL_CMP_CTX_set1_secretValue(OSSL_CMP_CTX *ctx, const unsigned char *sec,
-                                  const int len);
-/* CMP message header and extra certificates: */
-int OSSL_CMP_CTX_set1_recipient(OSSL_CMP_CTX *ctx, const X509_NAME *name);
-int OSSL_CMP_CTX_push0_geninfo_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav);
-int OSSL_CMP_CTX_set1_extraCertsOut(OSSL_CMP_CTX *ctx,
-                                    STACK_OF(X509) *extraCertsOut);
-/* certificate template: */
-int OSSL_CMP_CTX_set0_newPkey(OSSL_CMP_CTX *ctx, int priv, EVP_PKEY *pkey);
-EVP_PKEY *OSSL_CMP_CTX_get0_newPkey(const OSSL_CMP_CTX *ctx, int priv);
-int OSSL_CMP_CTX_set1_issuer(OSSL_CMP_CTX *ctx, const X509_NAME *name);
-int OSSL_CMP_CTX_set1_subjectName(OSSL_CMP_CTX *ctx, const X509_NAME *name);
-int OSSL_CMP_CTX_push1_subjectAltName(OSSL_CMP_CTX *ctx,
-                                      const GENERAL_NAME *name);
-int OSSL_CMP_CTX_set0_reqExtensions(OSSL_CMP_CTX *ctx, X509_EXTENSIONS *exts);
-int OSSL_CMP_CTX_reqExtensions_have_SAN(OSSL_CMP_CTX *ctx);
-int OSSL_CMP_CTX_push0_policy(OSSL_CMP_CTX *ctx, POLICYINFO *pinfo);
-int OSSL_CMP_CTX_set1_oldCert(OSSL_CMP_CTX *ctx, X509 *cert);
-int OSSL_CMP_CTX_set1_p10CSR(OSSL_CMP_CTX *ctx, const X509_REQ *csr);
-/* misc body contents: */
-int OSSL_CMP_CTX_push0_genm_ITAV(OSSL_CMP_CTX *ctx, OSSL_CMP_ITAV *itav);
-/* certificate confirmation: */
-typedef int (*OSSL_CMP_certConf_cb_t) (OSSL_CMP_CTX *ctx, X509 *cert,
-                                       int fail_info, const char **txt);
-int OSSL_CMP_certConf_cb(OSSL_CMP_CTX *ctx, X509 *cert, int fail_info,
-                         const char **text);
-int OSSL_CMP_CTX_set_certConf_cb(OSSL_CMP_CTX *ctx, OSSL_CMP_certConf_cb_t cb);
-int OSSL_CMP_CTX_set_certConf_cb_arg(OSSL_CMP_CTX *ctx, void *arg);
-void *OSSL_CMP_CTX_get_certConf_cb_arg(const OSSL_CMP_CTX *ctx);
-/* result fetching: */
-int OSSL_CMP_CTX_get_status(const OSSL_CMP_CTX *ctx);
-OSSL_CMP_PKIFREETEXT *OSSL_CMP_CTX_get0_statusString(const OSSL_CMP_CTX *ctx);
-int OSSL_CMP_CTX_get_failInfoCode(const OSSL_CMP_CTX *ctx);
-#  define OSSL_CMP_PKISI_BUFLEN 1024
-X509 *OSSL_CMP_CTX_get0_newCert(const OSSL_CMP_CTX *ctx);
-STACK_OF(X509) *OSSL_CMP_CTX_get1_newChain(const OSSL_CMP_CTX *ctx);
-STACK_OF(X509) *OSSL_CMP_CTX_get1_caPubs(const OSSL_CMP_CTX *ctx);
-STACK_OF(X509) *OSSL_CMP_CTX_get1_extraCertsIn(const OSSL_CMP_CTX *ctx);
-int OSSL_CMP_CTX_set1_transactionID(OSSL_CMP_CTX *ctx,
-                                    const ASN1_OCTET_STRING *id);
-int OSSL_CMP_CTX_set1_senderNonce(OSSL_CMP_CTX *ctx,
-                                  const ASN1_OCTET_STRING *nonce);
+    void OSSL_CMP_CTX_print_errors(const OSSL_CMP_CTX* ctx);
+    /* message transfer: */
+    int OSSL_CMP_CTX_set1_serverPath(OSSL_CMP_CTX* ctx, const char* path);
+    int OSSL_CMP_CTX_set1_server(OSSL_CMP_CTX* ctx, const char* address);
+    int OSSL_CMP_CTX_set_serverPort(OSSL_CMP_CTX* ctx, int port);
+    int OSSL_CMP_CTX_set1_proxy(OSSL_CMP_CTX* ctx, const char* name);
+    int OSSL_CMP_CTX_set1_no_proxy(OSSL_CMP_CTX* ctx, const char* names);
+    int OSSL_CMP_CTX_set_http_cb(OSSL_CMP_CTX* ctx, OSSL_HTTP_bio_cb_t cb);
+    int OSSL_CMP_CTX_set_http_cb_arg(OSSL_CMP_CTX* ctx, void* arg);
+    void* OSSL_CMP_CTX_get_http_cb_arg(const OSSL_CMP_CTX* ctx);
+    typedef OSSL_CMP_MSG* (*OSSL_CMP_transfer_cb_t)(OSSL_CMP_CTX* ctx, const OSSL_CMP_MSG* req);
+    int OSSL_CMP_CTX_set_transfer_cb(OSSL_CMP_CTX* ctx, OSSL_CMP_transfer_cb_t cb);
+    int OSSL_CMP_CTX_set_transfer_cb_arg(OSSL_CMP_CTX* ctx, void* arg);
+    void* OSSL_CMP_CTX_get_transfer_cb_arg(const OSSL_CMP_CTX* ctx);
+    /* server authentication: */
+    int OSSL_CMP_CTX_set1_srvCert(OSSL_CMP_CTX* ctx, X509* cert);
+    int OSSL_CMP_CTX_set1_expected_sender(OSSL_CMP_CTX* ctx, const X509_NAME* name);
+    int OSSL_CMP_CTX_set0_trustedStore(OSSL_CMP_CTX* ctx, X509_STORE* store);
+    X509_STORE* OSSL_CMP_CTX_get0_trustedStore(const OSSL_CMP_CTX* ctx);
+    int OSSL_CMP_CTX_set1_untrusted(OSSL_CMP_CTX* ctx, STACK_OF(X509) * certs);
+    STACK_OF(X509) * OSSL_CMP_CTX_get0_untrusted(const OSSL_CMP_CTX* ctx);
+    /* client authentication: */
+    int OSSL_CMP_CTX_set1_cert(OSSL_CMP_CTX* ctx, X509* cert);
+    int OSSL_CMP_CTX_build_cert_chain(OSSL_CMP_CTX* ctx, X509_STORE* own_trusted, STACK_OF(X509) * candidates);
+    int OSSL_CMP_CTX_set1_pkey(OSSL_CMP_CTX* ctx, EVP_PKEY* pkey);
+    int OSSL_CMP_CTX_set1_referenceValue(OSSL_CMP_CTX* ctx, const unsigned char* ref, int len);
+    int OSSL_CMP_CTX_set1_secretValue(OSSL_CMP_CTX* ctx, const unsigned char* sec, const int len);
+    /* CMP message header and extra certificates: */
+    int OSSL_CMP_CTX_set1_recipient(OSSL_CMP_CTX* ctx, const X509_NAME* name);
+    int OSSL_CMP_CTX_push0_geninfo_ITAV(OSSL_CMP_CTX* ctx, OSSL_CMP_ITAV* itav);
+    int OSSL_CMP_CTX_set1_extraCertsOut(OSSL_CMP_CTX* ctx, STACK_OF(X509) * extraCertsOut);
+    /* certificate template: */
+    int OSSL_CMP_CTX_set0_newPkey(OSSL_CMP_CTX* ctx, int priv, EVP_PKEY* pkey);
+    EVP_PKEY* OSSL_CMP_CTX_get0_newPkey(const OSSL_CMP_CTX* ctx, int priv);
+    int OSSL_CMP_CTX_set1_issuer(OSSL_CMP_CTX* ctx, const X509_NAME* name);
+    int OSSL_CMP_CTX_set1_subjectName(OSSL_CMP_CTX* ctx, const X509_NAME* name);
+    int OSSL_CMP_CTX_push1_subjectAltName(OSSL_CMP_CTX* ctx, const GENERAL_NAME* name);
+    int OSSL_CMP_CTX_set0_reqExtensions(OSSL_CMP_CTX* ctx, X509_EXTENSIONS* exts);
+    int OSSL_CMP_CTX_reqExtensions_have_SAN(OSSL_CMP_CTX* ctx);
+    int OSSL_CMP_CTX_push0_policy(OSSL_CMP_CTX* ctx, POLICYINFO* pinfo);
+    int OSSL_CMP_CTX_set1_oldCert(OSSL_CMP_CTX* ctx, X509* cert);
+    int OSSL_CMP_CTX_set1_p10CSR(OSSL_CMP_CTX* ctx, const X509_REQ* csr);
+    /* misc body contents: */
+    int OSSL_CMP_CTX_push0_genm_ITAV(OSSL_CMP_CTX* ctx, OSSL_CMP_ITAV* itav);
+    /* certificate confirmation: */
+    typedef int (*OSSL_CMP_certConf_cb_t)(OSSL_CMP_CTX* ctx, X509* cert, int fail_info, const char** txt);
+    int OSSL_CMP_certConf_cb(OSSL_CMP_CTX* ctx, X509* cert, int fail_info, const char** text);
+    int OSSL_CMP_CTX_set_certConf_cb(OSSL_CMP_CTX* ctx, OSSL_CMP_certConf_cb_t cb);
+    int OSSL_CMP_CTX_set_certConf_cb_arg(OSSL_CMP_CTX* ctx, void* arg);
+    void* OSSL_CMP_CTX_get_certConf_cb_arg(const OSSL_CMP_CTX* ctx);
+    /* result fetching: */
+    int OSSL_CMP_CTX_get_status(const OSSL_CMP_CTX* ctx);
+    OSSL_CMP_PKIFREETEXT* OSSL_CMP_CTX_get0_statusString(const OSSL_CMP_CTX* ctx);
+    int OSSL_CMP_CTX_get_failInfoCode(const OSSL_CMP_CTX* ctx);
+#define OSSL_CMP_PKISI_BUFLEN 1024
+    X509* OSSL_CMP_CTX_get0_newCert(const OSSL_CMP_CTX* ctx);
+    STACK_OF(X509) * OSSL_CMP_CTX_get1_newChain(const OSSL_CMP_CTX* ctx);
+    STACK_OF(X509) * OSSL_CMP_CTX_get1_caPubs(const OSSL_CMP_CTX* ctx);
+    STACK_OF(X509) * OSSL_CMP_CTX_get1_extraCertsIn(const OSSL_CMP_CTX* ctx);
+    int OSSL_CMP_CTX_set1_transactionID(OSSL_CMP_CTX* ctx, const ASN1_OCTET_STRING* id);
+    int OSSL_CMP_CTX_set1_senderNonce(OSSL_CMP_CTX* ctx, const ASN1_OCTET_STRING* nonce);
 
-/* from cmp_status.c */
-char *OSSL_CMP_CTX_snprint_PKIStatus(const OSSL_CMP_CTX *ctx, char *buf,
-                                     size_t bufsize);
-char *OSSL_CMP_snprint_PKIStatusInfo(const OSSL_CMP_PKISI *statusInfo,
-                                     char *buf, size_t bufsize);
-OSSL_CMP_PKISI *
-OSSL_CMP_STATUSINFO_new(int status, int fail_info, const char *text);
+    /* from cmp_status.c */
+    char* OSSL_CMP_CTX_snprint_PKIStatus(const OSSL_CMP_CTX* ctx, char* buf, size_t bufsize);
+    char* OSSL_CMP_snprint_PKIStatusInfo(const OSSL_CMP_PKISI* statusInfo, char* buf, size_t bufsize);
+    OSSL_CMP_PKISI*
+        OSSL_CMP_STATUSINFO_new(int status, int fail_info, const char* text);
 
-/* from cmp_hdr.c */
-ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_transactionID(const
-                                                   OSSL_CMP_PKIHEADER *hdr);
-ASN1_OCTET_STRING *OSSL_CMP_HDR_get0_recipNonce(const OSSL_CMP_PKIHEADER *hdr);
+    /* from cmp_hdr.c */
+    ASN1_OCTET_STRING* OSSL_CMP_HDR_get0_transactionID(const OSSL_CMP_PKIHEADER* hdr);
+    ASN1_OCTET_STRING* OSSL_CMP_HDR_get0_recipNonce(const OSSL_CMP_PKIHEADER* hdr);
 
-/* from cmp_msg.c */
-OSSL_CMP_PKIHEADER *OSSL_CMP_MSG_get0_header(const OSSL_CMP_MSG *msg);
-int OSSL_CMP_MSG_get_bodytype(const OSSL_CMP_MSG *msg);
-int OSSL_CMP_MSG_update_transactionID(OSSL_CMP_CTX *ctx, OSSL_CMP_MSG *msg);
-OSSL_CRMF_MSG *OSSL_CMP_CTX_setup_CRM(OSSL_CMP_CTX *ctx, int for_KUR, int rid);
-OSSL_CMP_MSG *OSSL_CMP_MSG_read(const char *file, OSSL_LIB_CTX *libctx,
-                                const char *propq);
-int OSSL_CMP_MSG_write(const char *file, const OSSL_CMP_MSG *msg);
-OSSL_CMP_MSG *d2i_OSSL_CMP_MSG_bio(BIO *bio, OSSL_CMP_MSG **msg);
-int i2d_OSSL_CMP_MSG_bio(BIO *bio, const OSSL_CMP_MSG *msg);
+    /* from cmp_msg.c */
+    OSSL_CMP_PKIHEADER* OSSL_CMP_MSG_get0_header(const OSSL_CMP_MSG* msg);
+    int OSSL_CMP_MSG_get_bodytype(const OSSL_CMP_MSG* msg);
+    int OSSL_CMP_MSG_update_transactionID(OSSL_CMP_CTX* ctx, OSSL_CMP_MSG* msg);
+    OSSL_CRMF_MSG* OSSL_CMP_CTX_setup_CRM(OSSL_CMP_CTX* ctx, int for_KUR, int rid);
+    OSSL_CMP_MSG* OSSL_CMP_MSG_read(const char* file, OSSL_LIB_CTX* libctx, const char* propq);
+    int OSSL_CMP_MSG_write(const char* file, const OSSL_CMP_MSG* msg);
+    OSSL_CMP_MSG* d2i_OSSL_CMP_MSG_bio(BIO* bio, OSSL_CMP_MSG** msg);
+    int i2d_OSSL_CMP_MSG_bio(BIO* bio, const OSSL_CMP_MSG* msg);
 
-/* from cmp_vfy.c */
-int OSSL_CMP_validate_msg(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg);
-int OSSL_CMP_validate_cert_path(const OSSL_CMP_CTX *ctx,
-                                X509_STORE *trusted_store, X509 *cert);
+    /* from cmp_vfy.c */
+    int OSSL_CMP_validate_msg(OSSL_CMP_CTX* ctx, const OSSL_CMP_MSG* msg);
+    int OSSL_CMP_validate_cert_path(const OSSL_CMP_CTX* ctx, X509_STORE* trusted_store, X509* cert);
 
-/* from cmp_http.c */
-OSSL_CMP_MSG *OSSL_CMP_MSG_http_perform(OSSL_CMP_CTX *ctx,
-                                        const OSSL_CMP_MSG *req);
+    /* from cmp_http.c */
+    OSSL_CMP_MSG* OSSL_CMP_MSG_http_perform(OSSL_CMP_CTX* ctx, const OSSL_CMP_MSG* req);
 
-/* from cmp_server.c */
-typedef struct ossl_cmp_srv_ctx_st OSSL_CMP_SRV_CTX;
-OSSL_CMP_MSG *OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX *srv_ctx,
-                                           const OSSL_CMP_MSG *req);
-OSSL_CMP_MSG * OSSL_CMP_CTX_server_perform(OSSL_CMP_CTX *client_ctx,
-                                           const OSSL_CMP_MSG *req);
-OSSL_CMP_SRV_CTX *OSSL_CMP_SRV_CTX_new(OSSL_LIB_CTX *libctx, const char *propq);
-void OSSL_CMP_SRV_CTX_free(OSSL_CMP_SRV_CTX *srv_ctx);
-typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_cert_request_cb_t)
-    (OSSL_CMP_SRV_CTX *srv_ctx, const OSSL_CMP_MSG *req, int certReqId,
-     const OSSL_CRMF_MSG *crm, const X509_REQ *p10cr,
-     X509 **certOut, STACK_OF(X509) **chainOut, STACK_OF(X509) **caPubs);
-typedef OSSL_CMP_PKISI *(*OSSL_CMP_SRV_rr_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
-                                                const OSSL_CMP_MSG *req,
-                                                const X509_NAME *issuer,
-                                                const ASN1_INTEGER *serial);
-typedef int (*OSSL_CMP_SRV_genm_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
-                                      const OSSL_CMP_MSG *req,
-                                      const STACK_OF(OSSL_CMP_ITAV) *in,
-                                      STACK_OF(OSSL_CMP_ITAV) **out);
-typedef void (*OSSL_CMP_SRV_error_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
-                                        const OSSL_CMP_MSG *req,
-                                        const OSSL_CMP_PKISI *statusInfo,
-                                        const ASN1_INTEGER *errorCode,
-                                        const OSSL_CMP_PKIFREETEXT *errDetails);
-typedef int (*OSSL_CMP_SRV_certConf_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
-                                          const OSSL_CMP_MSG *req,
-                                          int certReqId,
-                                          const ASN1_OCTET_STRING *certHash,
-                                          const OSSL_CMP_PKISI *si);
-typedef int (*OSSL_CMP_SRV_pollReq_cb_t)(OSSL_CMP_SRV_CTX *srv_ctx,
-                                         const OSSL_CMP_MSG *req, int certReqId,
-                                         OSSL_CMP_MSG **certReq,
-                                         int64_t *check_after);
-int OSSL_CMP_SRV_CTX_init(OSSL_CMP_SRV_CTX *srv_ctx, void *custom_ctx,
-                          OSSL_CMP_SRV_cert_request_cb_t process_cert_request,
-                          OSSL_CMP_SRV_rr_cb_t process_rr,
-                          OSSL_CMP_SRV_genm_cb_t process_genm,
-                          OSSL_CMP_SRV_error_cb_t process_error,
-                          OSSL_CMP_SRV_certConf_cb_t process_certConf,
-                          OSSL_CMP_SRV_pollReq_cb_t process_pollReq);
-OSSL_CMP_CTX *OSSL_CMP_SRV_CTX_get0_cmp_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
-void *OSSL_CMP_SRV_CTX_get0_custom_ctx(const OSSL_CMP_SRV_CTX *srv_ctx);
-int OSSL_CMP_SRV_CTX_set_send_unprotected_errors(OSSL_CMP_SRV_CTX *srv_ctx,
-                                                 int val);
-int OSSL_CMP_SRV_CTX_set_accept_unprotected(OSSL_CMP_SRV_CTX *srv_ctx, int val);
-int OSSL_CMP_SRV_CTX_set_accept_raverified(OSSL_CMP_SRV_CTX *srv_ctx, int val);
-int OSSL_CMP_SRV_CTX_set_grant_implicit_confirm(OSSL_CMP_SRV_CTX *srv_ctx,
-                                                int val);
+    /* from cmp_server.c */
+    typedef struct ossl_cmp_srv_ctx_st OSSL_CMP_SRV_CTX;
+    OSSL_CMP_MSG* OSSL_CMP_SRV_process_request(OSSL_CMP_SRV_CTX* srv_ctx, const OSSL_CMP_MSG* req);
+    OSSL_CMP_MSG* OSSL_CMP_CTX_server_perform(OSSL_CMP_CTX* client_ctx, const OSSL_CMP_MSG* req);
+    OSSL_CMP_SRV_CTX* OSSL_CMP_SRV_CTX_new(OSSL_LIB_CTX* libctx, const char* propq);
+    void OSSL_CMP_SRV_CTX_free(OSSL_CMP_SRV_CTX* srv_ctx);
+    typedef OSSL_CMP_PKISI* (*OSSL_CMP_SRV_cert_request_cb_t)(OSSL_CMP_SRV_CTX* srv_ctx, const OSSL_CMP_MSG* req, int certReqId, const OSSL_CRMF_MSG* crm, const X509_REQ* p10cr, X509** certOut, STACK_OF(X509) * *chainOut, STACK_OF(X509) * *caPubs);
+    typedef OSSL_CMP_PKISI* (*OSSL_CMP_SRV_rr_cb_t)(OSSL_CMP_SRV_CTX* srv_ctx, const OSSL_CMP_MSG* req, const X509_NAME* issuer, const ASN1_INTEGER* serial);
+    typedef int (*OSSL_CMP_SRV_genm_cb_t)(OSSL_CMP_SRV_CTX* srv_ctx, const OSSL_CMP_MSG* req, const STACK_OF(OSSL_CMP_ITAV) * in, STACK_OF(OSSL_CMP_ITAV) * *out);
+    typedef void (*OSSL_CMP_SRV_error_cb_t)(OSSL_CMP_SRV_CTX* srv_ctx, const OSSL_CMP_MSG* req, const OSSL_CMP_PKISI* statusInfo, const ASN1_INTEGER* errorCode, const OSSL_CMP_PKIFREETEXT* errDetails);
+    typedef int (*OSSL_CMP_SRV_certConf_cb_t)(OSSL_CMP_SRV_CTX* srv_ctx, const OSSL_CMP_MSG* req, int certReqId, const ASN1_OCTET_STRING* certHash, const OSSL_CMP_PKISI* si);
+    typedef int (*OSSL_CMP_SRV_pollReq_cb_t)(OSSL_CMP_SRV_CTX* srv_ctx, const OSSL_CMP_MSG* req, int certReqId, OSSL_CMP_MSG** certReq, int64_t* check_after);
+    int OSSL_CMP_SRV_CTX_init(OSSL_CMP_SRV_CTX* srv_ctx, void* custom_ctx, OSSL_CMP_SRV_cert_request_cb_t process_cert_request, OSSL_CMP_SRV_rr_cb_t process_rr, OSSL_CMP_SRV_genm_cb_t process_genm, OSSL_CMP_SRV_error_cb_t process_error, OSSL_CMP_SRV_certConf_cb_t process_certConf, OSSL_CMP_SRV_pollReq_cb_t process_pollReq);
+    OSSL_CMP_CTX* OSSL_CMP_SRV_CTX_get0_cmp_ctx(const OSSL_CMP_SRV_CTX* srv_ctx);
+    void* OSSL_CMP_SRV_CTX_get0_custom_ctx(const OSSL_CMP_SRV_CTX* srv_ctx);
+    int OSSL_CMP_SRV_CTX_set_send_unprotected_errors(OSSL_CMP_SRV_CTX* srv_ctx, int val);
+    int OSSL_CMP_SRV_CTX_set_accept_unprotected(OSSL_CMP_SRV_CTX* srv_ctx, int val);
+    int OSSL_CMP_SRV_CTX_set_accept_raverified(OSSL_CMP_SRV_CTX* srv_ctx, int val);
+    int OSSL_CMP_SRV_CTX_set_grant_implicit_confirm(OSSL_CMP_SRV_CTX* srv_ctx, int val);
 
-/* from cmp_client.c */
-X509 *OSSL_CMP_exec_certreq(OSSL_CMP_CTX *ctx, int req_type,
-                            const OSSL_CRMF_MSG *crm);
-#  define OSSL_CMP_IR    0
-#  define OSSL_CMP_CR    2
-#  define OSSL_CMP_P10CR 4
-#  define OSSL_CMP_KUR   7
-#  define OSSL_CMP_exec_IR_ses(ctx) \
+    /* from cmp_client.c */
+    X509* OSSL_CMP_exec_certreq(OSSL_CMP_CTX* ctx, int req_type, const OSSL_CRMF_MSG* crm);
+#define OSSL_CMP_IR 0
+#define OSSL_CMP_CR 2
+#define OSSL_CMP_P10CR 4
+#define OSSL_CMP_KUR 7
+#define OSSL_CMP_exec_IR_ses(ctx) \
     OSSL_CMP_exec_certreq(ctx, OSSL_CMP_IR, NULL)
-#  define OSSL_CMP_exec_CR_ses(ctx) \
+#define OSSL_CMP_exec_CR_ses(ctx) \
     OSSL_CMP_exec_certreq(ctx, OSSL_CMP_CR, NULL)
-#  define OSSL_CMP_exec_P10CR_ses(ctx) \
+#define OSSL_CMP_exec_P10CR_ses(ctx) \
     OSSL_CMP_exec_certreq(ctx, OSSL_CMP_P10CR, NULL)
-#  define OSSL_CMP_exec_KUR_ses(ctx) \
+#define OSSL_CMP_exec_KUR_ses(ctx) \
     OSSL_CMP_exec_certreq(ctx, OSSL_CMP_KUR, NULL)
-int OSSL_CMP_try_certreq(OSSL_CMP_CTX *ctx, int req_type,
-                         const OSSL_CRMF_MSG *crm, int *checkAfter);
-int OSSL_CMP_exec_RR_ses(OSSL_CMP_CTX *ctx);
-STACK_OF(OSSL_CMP_ITAV) *OSSL_CMP_exec_GENM_ses(OSSL_CMP_CTX *ctx);
+    int OSSL_CMP_try_certreq(OSSL_CMP_CTX* ctx, int req_type, const OSSL_CRMF_MSG* crm, int* checkAfter);
+    int OSSL_CMP_exec_RR_ses(OSSL_CMP_CTX* ctx);
+    STACK_OF(OSSL_CMP_ITAV) * OSSL_CMP_exec_GENM_ses(OSSL_CMP_CTX* ctx);
 
-#  ifdef  __cplusplus
+#ifdef __cplusplus
 }
-#  endif
-# endif /* !defined(OPENSSL_NO_CMP) */
+#endif
+#endif /* !defined(OPENSSL_NO_CMP) */
 #endif /* !defined(OPENSSL_CMP_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/cmp_util.h b/CAPI/cpp/grpc/include/openssl/cmp_util.h
index 9a16892..0356599 100644
--- a/CAPI/cpp/grpc/include/openssl/cmp_util.h
+++ b/CAPI/cpp/grpc/include/openssl/cmp_util.h
@@ -10,47 +10,46 @@
  */
 
 #ifndef OPENSSL_CMP_UTIL_H
-# define OPENSSL_CMP_UTIL_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# ifndef OPENSSL_NO_CMP
-
-#  include <openssl/macros.h>
-#  include <openssl/trace.h>
-
-#  ifdef __cplusplus
-extern "C" {
-#  endif
-
-int  OSSL_CMP_log_open(void);
-void OSSL_CMP_log_close(void);
-#  define OSSL_CMP_LOG_PREFIX "CMP "
-
-/*
- * generalized logging/error callback mirroring the severity levels of syslog.h
- */
-typedef int OSSL_CMP_severity;
-#  define OSSL_CMP_LOG_EMERG   0
-#  define OSSL_CMP_LOG_ALERT   1
-#  define OSSL_CMP_LOG_CRIT    2
-#  define OSSL_CMP_LOG_ERR     3
-#  define OSSL_CMP_LOG_WARNING 4
-#  define OSSL_CMP_LOG_NOTICE  5
-#  define OSSL_CMP_LOG_INFO    6
-#  define OSSL_CMP_LOG_DEBUG   7
-#  define OSSL_CMP_LOG_TRACE   8
-#  define OSSL_CMP_LOG_MAX     OSSL_CMP_LOG_TRACE
-typedef int (*OSSL_CMP_log_cb_t)(const char *func, const char *file, int line,
-                                 OSSL_CMP_severity level, const char *msg);
-
-int OSSL_CMP_print_to_bio(BIO *bio, const char *component, const char *file,
-                          int line, OSSL_CMP_severity level, const char *msg);
-/* use of the logging callback for outputting error queue */
-void OSSL_CMP_print_errors_cb(OSSL_CMP_log_cb_t log_fn);
-
-#  ifdef  __cplusplus
+#define OPENSSL_CMP_UTIL_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+#ifndef OPENSSL_NO_CMP
+
+#include <openssl/macros.h>
+#include <openssl/trace.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    int OSSL_CMP_log_open(void);
+    void OSSL_CMP_log_close(void);
+#define OSSL_CMP_LOG_PREFIX "CMP "
+
+    /*
+     * generalized logging/error callback mirroring the severity levels of syslog.h
+     */
+    typedef int OSSL_CMP_severity;
+#define OSSL_CMP_LOG_EMERG 0
+#define OSSL_CMP_LOG_ALERT 1
+#define OSSL_CMP_LOG_CRIT 2
+#define OSSL_CMP_LOG_ERR 3
+#define OSSL_CMP_LOG_WARNING 4
+#define OSSL_CMP_LOG_NOTICE 5
+#define OSSL_CMP_LOG_INFO 6
+#define OSSL_CMP_LOG_DEBUG 7
+#define OSSL_CMP_LOG_TRACE 8
+#define OSSL_CMP_LOG_MAX OSSL_CMP_LOG_TRACE
+    typedef int (*OSSL_CMP_log_cb_t)(const char* func, const char* file, int line, OSSL_CMP_severity level, const char* msg);
+
+    int OSSL_CMP_print_to_bio(BIO* bio, const char* component, const char* file, int line, OSSL_CMP_severity level, const char* msg);
+    /* use of the logging callback for outputting error queue */
+    void OSSL_CMP_print_errors_cb(OSSL_CMP_log_cb_t log_fn);
+
+#ifdef __cplusplus
 }
-#  endif
-# endif /* !defined(OPENSSL_NO_CMP) */
+#endif
+#endif /* !defined(OPENSSL_NO_CMP) */
 #endif /* !defined(OPENSSL_CMP_UTIL_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/cmperr.h b/CAPI/cpp/grpc/include/openssl/cmperr.h
index 3a26fd0..31164a4 100644
--- a/CAPI/cpp/grpc/include/openssl/cmperr.h
+++ b/CAPI/cpp/grpc/include/openssl/cmperr.h
@@ -9,104 +9,102 @@
  */
 
 #ifndef OPENSSL_CMPERR_H
-# define OPENSSL_CMPERR_H
-# pragma once
+#define OPENSSL_CMPERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_CMP
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_CMP
 
 /*
  * CMP reason codes.
  */
-#  define CMP_R_ALGORITHM_NOT_SUPPORTED                    139
-#  define CMP_R_BAD_CHECKAFTER_IN_POLLREP                  167
-#  define CMP_R_BAD_REQUEST_ID                             108
-#  define CMP_R_CERTHASH_UNMATCHED                         156
-#  define CMP_R_CERTID_NOT_FOUND                           109
-#  define CMP_R_CERTIFICATE_NOT_ACCEPTED                   169
-#  define CMP_R_CERTIFICATE_NOT_FOUND                      112
-#  define CMP_R_CERTREQMSG_NOT_FOUND                       157
-#  define CMP_R_CERTRESPONSE_NOT_FOUND                     113
-#  define CMP_R_CERT_AND_KEY_DO_NOT_MATCH                  114
-#  define CMP_R_CHECKAFTER_OUT_OF_RANGE                    181
-#  define CMP_R_ENCOUNTERED_KEYUPDATEWARNING               176
-#  define CMP_R_ENCOUNTERED_WAITING                        162
-#  define CMP_R_ERROR_CALCULATING_PROTECTION               115
-#  define CMP_R_ERROR_CREATING_CERTCONF                    116
-#  define CMP_R_ERROR_CREATING_CERTREP                     117
-#  define CMP_R_ERROR_CREATING_CERTREQ                     163
-#  define CMP_R_ERROR_CREATING_ERROR                       118
-#  define CMP_R_ERROR_CREATING_GENM                        119
-#  define CMP_R_ERROR_CREATING_GENP                        120
-#  define CMP_R_ERROR_CREATING_PKICONF                     122
-#  define CMP_R_ERROR_CREATING_POLLREP                     123
-#  define CMP_R_ERROR_CREATING_POLLREQ                     124
-#  define CMP_R_ERROR_CREATING_RP                          125
-#  define CMP_R_ERROR_CREATING_RR                          126
-#  define CMP_R_ERROR_PARSING_PKISTATUS                    107
-#  define CMP_R_ERROR_PROCESSING_MESSAGE                   158
-#  define CMP_R_ERROR_PROTECTING_MESSAGE                   127
-#  define CMP_R_ERROR_SETTING_CERTHASH                     128
-#  define CMP_R_ERROR_UNEXPECTED_CERTCONF                  160
-#  define CMP_R_ERROR_VALIDATING_PROTECTION                140
-#  define CMP_R_ERROR_VALIDATING_SIGNATURE                 171
-#  define CMP_R_FAILED_BUILDING_OWN_CHAIN                  164
-#  define CMP_R_FAILED_EXTRACTING_PUBKEY                   141
-#  define CMP_R_FAILURE_OBTAINING_RANDOM                   110
-#  define CMP_R_FAIL_INFO_OUT_OF_RANGE                     129
-#  define CMP_R_INVALID_ARGS                               100
-#  define CMP_R_INVALID_OPTION                             174
-#  define CMP_R_MISSING_CERTID                             165
-#  define CMP_R_MISSING_KEY_INPUT_FOR_CREATING_PROTECTION  130
-#  define CMP_R_MISSING_KEY_USAGE_DIGITALSIGNATURE         142
-#  define CMP_R_MISSING_P10CSR                             121
-#  define CMP_R_MISSING_PBM_SECRET                         166
-#  define CMP_R_MISSING_PRIVATE_KEY                        131
-#  define CMP_R_MISSING_PROTECTION                         143
-#  define CMP_R_MISSING_REFERENCE_CERT                     168
-#  define CMP_R_MISSING_SENDER_IDENTIFICATION              111
-#  define CMP_R_MISSING_TRUST_STORE                        144
-#  define CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED            161
-#  define CMP_R_MULTIPLE_RESPONSES_NOT_SUPPORTED           170
-#  define CMP_R_MULTIPLE_SAN_SOURCES                       102
-#  define CMP_R_NO_STDIO                                   194
-#  define CMP_R_NO_SUITABLE_SENDER_CERT                    145
-#  define CMP_R_NULL_ARGUMENT                              103
-#  define CMP_R_PKIBODY_ERROR                              146
-#  define CMP_R_PKISTATUSINFO_NOT_FOUND                    132
-#  define CMP_R_POLLING_FAILED                             172
-#  define CMP_R_POTENTIALLY_INVALID_CERTIFICATE            147
-#  define CMP_R_RECEIVED_ERROR                             180
-#  define CMP_R_RECIPNONCE_UNMATCHED                       148
-#  define CMP_R_REQUEST_NOT_ACCEPTED                       149
-#  define CMP_R_REQUEST_REJECTED_BY_SERVER                 182
-#  define CMP_R_SENDER_GENERALNAME_TYPE_NOT_SUPPORTED      150
-#  define CMP_R_SRVCERT_DOES_NOT_VALIDATE_MSG              151
-#  define CMP_R_TOTAL_TIMEOUT                              184
-#  define CMP_R_TRANSACTIONID_UNMATCHED                    152
-#  define CMP_R_TRANSFER_ERROR                             159
-#  define CMP_R_UNEXPECTED_PKIBODY                         133
-#  define CMP_R_UNEXPECTED_PKISTATUS                       185
-#  define CMP_R_UNEXPECTED_PVNO                            153
-#  define CMP_R_UNKNOWN_ALGORITHM_ID                       134
-#  define CMP_R_UNKNOWN_CERT_TYPE                          135
-#  define CMP_R_UNKNOWN_PKISTATUS                          186
-#  define CMP_R_UNSUPPORTED_ALGORITHM                      136
-#  define CMP_R_UNSUPPORTED_KEY_TYPE                       137
-#  define CMP_R_UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC      154
-#  define CMP_R_VALUE_TOO_LARGE                            175
-#  define CMP_R_VALUE_TOO_SMALL                            177
-#  define CMP_R_WRONG_ALGORITHM_OID                        138
-#  define CMP_R_WRONG_CERTID                               189
-#  define CMP_R_WRONG_CERTID_IN_RP                         187
-#  define CMP_R_WRONG_PBM_VALUE                            155
-#  define CMP_R_WRONG_RP_COMPONENT_COUNT                   188
-#  define CMP_R_WRONG_SERIAL_IN_RP                         173
+#define CMP_R_ALGORITHM_NOT_SUPPORTED 139
+#define CMP_R_BAD_CHECKAFTER_IN_POLLREP 167
+#define CMP_R_BAD_REQUEST_ID 108
+#define CMP_R_CERTHASH_UNMATCHED 156
+#define CMP_R_CERTID_NOT_FOUND 109
+#define CMP_R_CERTIFICATE_NOT_ACCEPTED 169
+#define CMP_R_CERTIFICATE_NOT_FOUND 112
+#define CMP_R_CERTREQMSG_NOT_FOUND 157
+#define CMP_R_CERTRESPONSE_NOT_FOUND 113
+#define CMP_R_CERT_AND_KEY_DO_NOT_MATCH 114
+#define CMP_R_CHECKAFTER_OUT_OF_RANGE 181
+#define CMP_R_ENCOUNTERED_KEYUPDATEWARNING 176
+#define CMP_R_ENCOUNTERED_WAITING 162
+#define CMP_R_ERROR_CALCULATING_PROTECTION 115
+#define CMP_R_ERROR_CREATING_CERTCONF 116
+#define CMP_R_ERROR_CREATING_CERTREP 117
+#define CMP_R_ERROR_CREATING_CERTREQ 163
+#define CMP_R_ERROR_CREATING_ERROR 118
+#define CMP_R_ERROR_CREATING_GENM 119
+#define CMP_R_ERROR_CREATING_GENP 120
+#define CMP_R_ERROR_CREATING_PKICONF 122
+#define CMP_R_ERROR_CREATING_POLLREP 123
+#define CMP_R_ERROR_CREATING_POLLREQ 124
+#define CMP_R_ERROR_CREATING_RP 125
+#define CMP_R_ERROR_CREATING_RR 126
+#define CMP_R_ERROR_PARSING_PKISTATUS 107
+#define CMP_R_ERROR_PROCESSING_MESSAGE 158
+#define CMP_R_ERROR_PROTECTING_MESSAGE 127
+#define CMP_R_ERROR_SETTING_CERTHASH 128
+#define CMP_R_ERROR_UNEXPECTED_CERTCONF 160
+#define CMP_R_ERROR_VALIDATING_PROTECTION 140
+#define CMP_R_ERROR_VALIDATING_SIGNATURE 171
+#define CMP_R_FAILED_BUILDING_OWN_CHAIN 164
+#define CMP_R_FAILED_EXTRACTING_PUBKEY 141
+#define CMP_R_FAILURE_OBTAINING_RANDOM 110
+#define CMP_R_FAIL_INFO_OUT_OF_RANGE 129
+#define CMP_R_INVALID_ARGS 100
+#define CMP_R_INVALID_OPTION 174
+#define CMP_R_MISSING_CERTID 165
+#define CMP_R_MISSING_KEY_INPUT_FOR_CREATING_PROTECTION 130
+#define CMP_R_MISSING_KEY_USAGE_DIGITALSIGNATURE 142
+#define CMP_R_MISSING_P10CSR 121
+#define CMP_R_MISSING_PBM_SECRET 166
+#define CMP_R_MISSING_PRIVATE_KEY 131
+#define CMP_R_MISSING_PROTECTION 143
+#define CMP_R_MISSING_REFERENCE_CERT 168
+#define CMP_R_MISSING_SENDER_IDENTIFICATION 111
+#define CMP_R_MISSING_TRUST_STORE 144
+#define CMP_R_MULTIPLE_REQUESTS_NOT_SUPPORTED 161
+#define CMP_R_MULTIPLE_RESPONSES_NOT_SUPPORTED 170
+#define CMP_R_MULTIPLE_SAN_SOURCES 102
+#define CMP_R_NO_STDIO 194
+#define CMP_R_NO_SUITABLE_SENDER_CERT 145
+#define CMP_R_NULL_ARGUMENT 103
+#define CMP_R_PKIBODY_ERROR 146
+#define CMP_R_PKISTATUSINFO_NOT_FOUND 132
+#define CMP_R_POLLING_FAILED 172
+#define CMP_R_POTENTIALLY_INVALID_CERTIFICATE 147
+#define CMP_R_RECEIVED_ERROR 180
+#define CMP_R_RECIPNONCE_UNMATCHED 148
+#define CMP_R_REQUEST_NOT_ACCEPTED 149
+#define CMP_R_REQUEST_REJECTED_BY_SERVER 182
+#define CMP_R_SENDER_GENERALNAME_TYPE_NOT_SUPPORTED 150
+#define CMP_R_SRVCERT_DOES_NOT_VALIDATE_MSG 151
+#define CMP_R_TOTAL_TIMEOUT 184
+#define CMP_R_TRANSACTIONID_UNMATCHED 152
+#define CMP_R_TRANSFER_ERROR 159
+#define CMP_R_UNEXPECTED_PKIBODY 133
+#define CMP_R_UNEXPECTED_PKISTATUS 185
+#define CMP_R_UNEXPECTED_PVNO 153
+#define CMP_R_UNKNOWN_ALGORITHM_ID 134
+#define CMP_R_UNKNOWN_CERT_TYPE 135
+#define CMP_R_UNKNOWN_PKISTATUS 186
+#define CMP_R_UNSUPPORTED_ALGORITHM 136
+#define CMP_R_UNSUPPORTED_KEY_TYPE 137
+#define CMP_R_UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC 154
+#define CMP_R_VALUE_TOO_LARGE 175
+#define CMP_R_VALUE_TOO_SMALL 177
+#define CMP_R_WRONG_ALGORITHM_OID 138
+#define CMP_R_WRONG_CERTID 189
+#define CMP_R_WRONG_CERTID_IN_RP 187
+#define CMP_R_WRONG_PBM_VALUE 155
+#define CMP_R_WRONG_RP_COMPONENT_COUNT 188
+#define CMP_R_WRONG_SERIAL_IN_RP 173
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/cms.h b/CAPI/cpp/grpc/include/openssl/cms.h
index 5b907f2..7cba6b4 100644
--- a/CAPI/cpp/grpc/include/openssl/cms.h
+++ b/CAPI/cpp/grpc/include/openssl/cms.h
@@ -10,484 +10,369 @@
  * https://www.openssl.org/source/license.html
  */
 
+#ifndef OPENSSL_CMS_H
+#define OPENSSL_CMS_H
+#pragma once
 
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CMS_H
+#endif
 
-#ifndef OPENSSL_CMS_H
-# define OPENSSL_CMS_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_CMS_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_CMS
-# include <openssl/x509.h>
-# include <openssl/x509v3.h>
-# include <openssl/cmserr.h>
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-typedef struct CMS_ContentInfo_st CMS_ContentInfo;
-typedef struct CMS_SignerInfo_st CMS_SignerInfo;
-typedef struct CMS_CertificateChoices CMS_CertificateChoices;
-typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice;
-typedef struct CMS_RecipientInfo_st CMS_RecipientInfo;
-typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest;
-typedef struct CMS_Receipt_st CMS_Receipt;
-typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey;
-typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute;
-
-SKM_DEFINE_STACK_OF_INTERNAL(CMS_SignerInfo, CMS_SignerInfo, CMS_SignerInfo)
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_CMS
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+#include <openssl/cmserr.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    typedef struct CMS_ContentInfo_st CMS_ContentInfo;
+    typedef struct CMS_SignerInfo_st CMS_SignerInfo;
+    typedef struct CMS_CertificateChoices CMS_CertificateChoices;
+    typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice;
+    typedef struct CMS_RecipientInfo_st CMS_RecipientInfo;
+    typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest;
+    typedef struct CMS_Receipt_st CMS_Receipt;
+    typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey;
+    typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(CMS_SignerInfo, CMS_SignerInfo, CMS_SignerInfo)
 #define sk_CMS_SignerInfo_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_SignerInfo_sk_type(sk))
-#define sk_CMS_SignerInfo_value(sk, idx) ((CMS_SignerInfo *)OPENSSL_sk_value(ossl_check_const_CMS_SignerInfo_sk_type(sk), (idx)))
-#define sk_CMS_SignerInfo_new(cmp) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new(ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
-#define sk_CMS_SignerInfo_new_null() ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new_null())
-#define sk_CMS_SignerInfo_new_reserve(cmp, n) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_new_reserve(ossl_check_CMS_SignerInfo_compfunc_type(cmp), (n)))
+#define sk_CMS_SignerInfo_value(sk, idx) ((CMS_SignerInfo*)OPENSSL_sk_value(ossl_check_const_CMS_SignerInfo_sk_type(sk), (idx)))
+#define sk_CMS_SignerInfo_new(cmp) ((STACK_OF(CMS_SignerInfo)*)OPENSSL_sk_new(ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
+#define sk_CMS_SignerInfo_new_null() ((STACK_OF(CMS_SignerInfo)*)OPENSSL_sk_new_null())
+#define sk_CMS_SignerInfo_new_reserve(cmp, n) ((STACK_OF(CMS_SignerInfo)*)OPENSSL_sk_new_reserve(ossl_check_CMS_SignerInfo_compfunc_type(cmp), (n)))
 #define sk_CMS_SignerInfo_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_SignerInfo_sk_type(sk), (n))
 #define sk_CMS_SignerInfo_free(sk) OPENSSL_sk_free(ossl_check_CMS_SignerInfo_sk_type(sk))
 #define sk_CMS_SignerInfo_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_SignerInfo_sk_type(sk))
-#define sk_CMS_SignerInfo_delete(sk, i) ((CMS_SignerInfo *)OPENSSL_sk_delete(ossl_check_CMS_SignerInfo_sk_type(sk), (i)))
-#define sk_CMS_SignerInfo_delete_ptr(sk, ptr) ((CMS_SignerInfo *)OPENSSL_sk_delete_ptr(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr)))
+#define sk_CMS_SignerInfo_delete(sk, i) ((CMS_SignerInfo*)OPENSSL_sk_delete(ossl_check_CMS_SignerInfo_sk_type(sk), (i)))
+#define sk_CMS_SignerInfo_delete_ptr(sk, ptr) ((CMS_SignerInfo*)OPENSSL_sk_delete_ptr(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr)))
 #define sk_CMS_SignerInfo_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
 #define sk_CMS_SignerInfo_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
-#define sk_CMS_SignerInfo_pop(sk) ((CMS_SignerInfo *)OPENSSL_sk_pop(ossl_check_CMS_SignerInfo_sk_type(sk)))
-#define sk_CMS_SignerInfo_shift(sk) ((CMS_SignerInfo *)OPENSSL_sk_shift(ossl_check_CMS_SignerInfo_sk_type(sk)))
-#define sk_CMS_SignerInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_SignerInfo_sk_type(sk),ossl_check_CMS_SignerInfo_freefunc_type(freefunc))
+#define sk_CMS_SignerInfo_pop(sk) ((CMS_SignerInfo*)OPENSSL_sk_pop(ossl_check_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_shift(sk) ((CMS_SignerInfo*)OPENSSL_sk_shift(ossl_check_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_freefunc_type(freefunc))
 #define sk_CMS_SignerInfo_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr), (idx))
-#define sk_CMS_SignerInfo_set(sk, idx, ptr) ((CMS_SignerInfo *)OPENSSL_sk_set(ossl_check_CMS_SignerInfo_sk_type(sk), (idx), ossl_check_CMS_SignerInfo_type(ptr)))
+#define sk_CMS_SignerInfo_set(sk, idx, ptr) ((CMS_SignerInfo*)OPENSSL_sk_set(ossl_check_CMS_SignerInfo_sk_type(sk), (idx), ossl_check_CMS_SignerInfo_type(ptr)))
 #define sk_CMS_SignerInfo_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
 #define sk_CMS_SignerInfo_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr))
 #define sk_CMS_SignerInfo_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_type(ptr), pnum)
 #define sk_CMS_SignerInfo_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_SignerInfo_sk_type(sk))
 #define sk_CMS_SignerInfo_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_SignerInfo_sk_type(sk))
-#define sk_CMS_SignerInfo_dup(sk) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_dup(ossl_check_const_CMS_SignerInfo_sk_type(sk)))
-#define sk_CMS_SignerInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_SignerInfo) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_copyfunc_type(copyfunc), ossl_check_CMS_SignerInfo_freefunc_type(freefunc)))
+#define sk_CMS_SignerInfo_dup(sk) ((STACK_OF(CMS_SignerInfo)*)OPENSSL_sk_dup(ossl_check_const_CMS_SignerInfo_sk_type(sk)))
+#define sk_CMS_SignerInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_SignerInfo)*)OPENSSL_sk_deep_copy(ossl_check_const_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_copyfunc_type(copyfunc), ossl_check_CMS_SignerInfo_freefunc_type(freefunc)))
 #define sk_CMS_SignerInfo_set_cmp_func(sk, cmp) ((sk_CMS_SignerInfo_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_SignerInfo_sk_type(sk), ossl_check_CMS_SignerInfo_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey)
+    SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey)
 #define sk_CMS_RecipientEncryptedKey_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk))
-#define sk_CMS_RecipientEncryptedKey_value(sk, idx) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_value(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), (idx)))
-#define sk_CMS_RecipientEncryptedKey_new(cmp) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
-#define sk_CMS_RecipientEncryptedKey_new_null() ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new_null())
-#define sk_CMS_RecipientEncryptedKey_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp), (n)))
+#define sk_CMS_RecipientEncryptedKey_value(sk, idx) ((CMS_RecipientEncryptedKey*)OPENSSL_sk_value(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), (idx)))
+#define sk_CMS_RecipientEncryptedKey_new(cmp) ((STACK_OF(CMS_RecipientEncryptedKey)*)OPENSSL_sk_new(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
+#define sk_CMS_RecipientEncryptedKey_new_null() ((STACK_OF(CMS_RecipientEncryptedKey)*)OPENSSL_sk_new_null())
+#define sk_CMS_RecipientEncryptedKey_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientEncryptedKey)*)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp), (n)))
 #define sk_CMS_RecipientEncryptedKey_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (n))
 #define sk_CMS_RecipientEncryptedKey_free(sk) OPENSSL_sk_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
 #define sk_CMS_RecipientEncryptedKey_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
-#define sk_CMS_RecipientEncryptedKey_delete(sk, i) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_delete(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (i)))
-#define sk_CMS_RecipientEncryptedKey_delete_ptr(sk, ptr) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
+#define sk_CMS_RecipientEncryptedKey_delete(sk, i) ((CMS_RecipientEncryptedKey*)OPENSSL_sk_delete(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (i)))
+#define sk_CMS_RecipientEncryptedKey_delete_ptr(sk, ptr) ((CMS_RecipientEncryptedKey*)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
 #define sk_CMS_RecipientEncryptedKey_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
 #define sk_CMS_RecipientEncryptedKey_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
-#define sk_CMS_RecipientEncryptedKey_pop(sk) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_pop(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
-#define sk_CMS_RecipientEncryptedKey_shift(sk) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_shift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
-#define sk_CMS_RecipientEncryptedKey_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk),ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc))
+#define sk_CMS_RecipientEncryptedKey_pop(sk) ((CMS_RecipientEncryptedKey*)OPENSSL_sk_pop(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_shift(sk) ((CMS_RecipientEncryptedKey*)OPENSSL_sk_shift(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc))
 #define sk_CMS_RecipientEncryptedKey_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr), (idx))
-#define sk_CMS_RecipientEncryptedKey_set(sk, idx, ptr) ((CMS_RecipientEncryptedKey *)OPENSSL_sk_set(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (idx), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
+#define sk_CMS_RecipientEncryptedKey_set(sk, idx, ptr) ((CMS_RecipientEncryptedKey*)OPENSSL_sk_set(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), (idx), ossl_check_CMS_RecipientEncryptedKey_type(ptr)))
 #define sk_CMS_RecipientEncryptedKey_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
 #define sk_CMS_RecipientEncryptedKey_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr))
 #define sk_CMS_RecipientEncryptedKey_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_type(ptr), pnum)
 #define sk_CMS_RecipientEncryptedKey_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk))
 #define sk_CMS_RecipientEncryptedKey_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk))
-#define sk_CMS_RecipientEncryptedKey_dup(sk) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk)))
-#define sk_CMS_RecipientEncryptedKey_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientEncryptedKey) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_copyfunc_type(copyfunc), ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc)))
+#define sk_CMS_RecipientEncryptedKey_dup(sk) ((STACK_OF(CMS_RecipientEncryptedKey)*)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk)))
+#define sk_CMS_RecipientEncryptedKey_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientEncryptedKey)*)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_copyfunc_type(copyfunc), ossl_check_CMS_RecipientEncryptedKey_freefunc_type(freefunc)))
 #define sk_CMS_RecipientEncryptedKey_set_cmp_func(sk, cmp) ((sk_CMS_RecipientEncryptedKey_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RecipientEncryptedKey_sk_type(sk), ossl_check_CMS_RecipientEncryptedKey_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientInfo, CMS_RecipientInfo, CMS_RecipientInfo)
+    SKM_DEFINE_STACK_OF_INTERNAL(CMS_RecipientInfo, CMS_RecipientInfo, CMS_RecipientInfo)
 #define sk_CMS_RecipientInfo_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RecipientInfo_sk_type(sk))
-#define sk_CMS_RecipientInfo_value(sk, idx) ((CMS_RecipientInfo *)OPENSSL_sk_value(ossl_check_const_CMS_RecipientInfo_sk_type(sk), (idx)))
-#define sk_CMS_RecipientInfo_new(cmp) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new(ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
-#define sk_CMS_RecipientInfo_new_null() ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new_null())
-#define sk_CMS_RecipientInfo_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientInfo_compfunc_type(cmp), (n)))
+#define sk_CMS_RecipientInfo_value(sk, idx) ((CMS_RecipientInfo*)OPENSSL_sk_value(ossl_check_const_CMS_RecipientInfo_sk_type(sk), (idx)))
+#define sk_CMS_RecipientInfo_new(cmp) ((STACK_OF(CMS_RecipientInfo)*)OPENSSL_sk_new(ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
+#define sk_CMS_RecipientInfo_new_null() ((STACK_OF(CMS_RecipientInfo)*)OPENSSL_sk_new_null())
+#define sk_CMS_RecipientInfo_new_reserve(cmp, n) ((STACK_OF(CMS_RecipientInfo)*)OPENSSL_sk_new_reserve(ossl_check_CMS_RecipientInfo_compfunc_type(cmp), (n)))
 #define sk_CMS_RecipientInfo_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RecipientInfo_sk_type(sk), (n))
 #define sk_CMS_RecipientInfo_free(sk) OPENSSL_sk_free(ossl_check_CMS_RecipientInfo_sk_type(sk))
 #define sk_CMS_RecipientInfo_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RecipientInfo_sk_type(sk))
-#define sk_CMS_RecipientInfo_delete(sk, i) ((CMS_RecipientInfo *)OPENSSL_sk_delete(ossl_check_CMS_RecipientInfo_sk_type(sk), (i)))
-#define sk_CMS_RecipientInfo_delete_ptr(sk, ptr) ((CMS_RecipientInfo *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr)))
+#define sk_CMS_RecipientInfo_delete(sk, i) ((CMS_RecipientInfo*)OPENSSL_sk_delete(ossl_check_CMS_RecipientInfo_sk_type(sk), (i)))
+#define sk_CMS_RecipientInfo_delete_ptr(sk, ptr) ((CMS_RecipientInfo*)OPENSSL_sk_delete_ptr(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr)))
 #define sk_CMS_RecipientInfo_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
 #define sk_CMS_RecipientInfo_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
-#define sk_CMS_RecipientInfo_pop(sk) ((CMS_RecipientInfo *)OPENSSL_sk_pop(ossl_check_CMS_RecipientInfo_sk_type(sk)))
-#define sk_CMS_RecipientInfo_shift(sk) ((CMS_RecipientInfo *)OPENSSL_sk_shift(ossl_check_CMS_RecipientInfo_sk_type(sk)))
-#define sk_CMS_RecipientInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientInfo_sk_type(sk),ossl_check_CMS_RecipientInfo_freefunc_type(freefunc))
+#define sk_CMS_RecipientInfo_pop(sk) ((CMS_RecipientInfo*)OPENSSL_sk_pop(ossl_check_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_shift(sk) ((CMS_RecipientInfo*)OPENSSL_sk_shift(ossl_check_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_freefunc_type(freefunc))
 #define sk_CMS_RecipientInfo_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr), (idx))
-#define sk_CMS_RecipientInfo_set(sk, idx, ptr) ((CMS_RecipientInfo *)OPENSSL_sk_set(ossl_check_CMS_RecipientInfo_sk_type(sk), (idx), ossl_check_CMS_RecipientInfo_type(ptr)))
+#define sk_CMS_RecipientInfo_set(sk, idx, ptr) ((CMS_RecipientInfo*)OPENSSL_sk_set(ossl_check_CMS_RecipientInfo_sk_type(sk), (idx), ossl_check_CMS_RecipientInfo_type(ptr)))
 #define sk_CMS_RecipientInfo_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
 #define sk_CMS_RecipientInfo_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr))
 #define sk_CMS_RecipientInfo_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_type(ptr), pnum)
 #define sk_CMS_RecipientInfo_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RecipientInfo_sk_type(sk))
 #define sk_CMS_RecipientInfo_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RecipientInfo_sk_type(sk))
-#define sk_CMS_RecipientInfo_dup(sk) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientInfo_sk_type(sk)))
-#define sk_CMS_RecipientInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientInfo) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_copyfunc_type(copyfunc), ossl_check_CMS_RecipientInfo_freefunc_type(freefunc)))
+#define sk_CMS_RecipientInfo_dup(sk) ((STACK_OF(CMS_RecipientInfo)*)OPENSSL_sk_dup(ossl_check_const_CMS_RecipientInfo_sk_type(sk)))
+#define sk_CMS_RecipientInfo_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RecipientInfo)*)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_copyfunc_type(copyfunc), ossl_check_CMS_RecipientInfo_freefunc_type(freefunc)))
 #define sk_CMS_RecipientInfo_set_cmp_func(sk, cmp) ((sk_CMS_RecipientInfo_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RecipientInfo_sk_type(sk), ossl_check_CMS_RecipientInfo_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(CMS_RevocationInfoChoice, CMS_RevocationInfoChoice, CMS_RevocationInfoChoice)
+    SKM_DEFINE_STACK_OF_INTERNAL(CMS_RevocationInfoChoice, CMS_RevocationInfoChoice, CMS_RevocationInfoChoice)
 #define sk_CMS_RevocationInfoChoice_num(sk) OPENSSL_sk_num(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk))
-#define sk_CMS_RevocationInfoChoice_value(sk, idx) ((CMS_RevocationInfoChoice *)OPENSSL_sk_value(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), (idx)))
-#define sk_CMS_RevocationInfoChoice_new(cmp) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
-#define sk_CMS_RevocationInfoChoice_new_null() ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new_null())
-#define sk_CMS_RevocationInfoChoice_new_reserve(cmp, n) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_new_reserve(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp), (n)))
+#define sk_CMS_RevocationInfoChoice_value(sk, idx) ((CMS_RevocationInfoChoice*)OPENSSL_sk_value(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), (idx)))
+#define sk_CMS_RevocationInfoChoice_new(cmp) ((STACK_OF(CMS_RevocationInfoChoice)*)OPENSSL_sk_new(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
+#define sk_CMS_RevocationInfoChoice_new_null() ((STACK_OF(CMS_RevocationInfoChoice)*)OPENSSL_sk_new_null())
+#define sk_CMS_RevocationInfoChoice_new_reserve(cmp, n) ((STACK_OF(CMS_RevocationInfoChoice)*)OPENSSL_sk_new_reserve(ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp), (n)))
 #define sk_CMS_RevocationInfoChoice_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (n))
 #define sk_CMS_RevocationInfoChoice_free(sk) OPENSSL_sk_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
 #define sk_CMS_RevocationInfoChoice_zero(sk) OPENSSL_sk_zero(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
-#define sk_CMS_RevocationInfoChoice_delete(sk, i) ((CMS_RevocationInfoChoice *)OPENSSL_sk_delete(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (i)))
-#define sk_CMS_RevocationInfoChoice_delete_ptr(sk, ptr) ((CMS_RevocationInfoChoice *)OPENSSL_sk_delete_ptr(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
+#define sk_CMS_RevocationInfoChoice_delete(sk, i) ((CMS_RevocationInfoChoice*)OPENSSL_sk_delete(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (i)))
+#define sk_CMS_RevocationInfoChoice_delete_ptr(sk, ptr) ((CMS_RevocationInfoChoice*)OPENSSL_sk_delete_ptr(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
 #define sk_CMS_RevocationInfoChoice_push(sk, ptr) OPENSSL_sk_push(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
 #define sk_CMS_RevocationInfoChoice_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
-#define sk_CMS_RevocationInfoChoice_pop(sk) ((CMS_RevocationInfoChoice *)OPENSSL_sk_pop(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
-#define sk_CMS_RevocationInfoChoice_shift(sk) ((CMS_RevocationInfoChoice *)OPENSSL_sk_shift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
-#define sk_CMS_RevocationInfoChoice_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk),ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc))
+#define sk_CMS_RevocationInfoChoice_pop(sk) ((CMS_RevocationInfoChoice*)OPENSSL_sk_pop(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_shift(sk) ((CMS_RevocationInfoChoice*)OPENSSL_sk_shift(ossl_check_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc))
 #define sk_CMS_RevocationInfoChoice_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr), (idx))
-#define sk_CMS_RevocationInfoChoice_set(sk, idx, ptr) ((CMS_RevocationInfoChoice *)OPENSSL_sk_set(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (idx), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
+#define sk_CMS_RevocationInfoChoice_set(sk, idx, ptr) ((CMS_RevocationInfoChoice*)OPENSSL_sk_set(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), (idx), ossl_check_CMS_RevocationInfoChoice_type(ptr)))
 #define sk_CMS_RevocationInfoChoice_find(sk, ptr) OPENSSL_sk_find(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
 #define sk_CMS_RevocationInfoChoice_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr))
 #define sk_CMS_RevocationInfoChoice_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_type(ptr), pnum)
 #define sk_CMS_RevocationInfoChoice_sort(sk) OPENSSL_sk_sort(ossl_check_CMS_RevocationInfoChoice_sk_type(sk))
 #define sk_CMS_RevocationInfoChoice_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk))
-#define sk_CMS_RevocationInfoChoice_dup(sk) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_dup(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk)))
-#define sk_CMS_RevocationInfoChoice_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RevocationInfoChoice) *)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_copyfunc_type(copyfunc), ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc)))
+#define sk_CMS_RevocationInfoChoice_dup(sk) ((STACK_OF(CMS_RevocationInfoChoice)*)OPENSSL_sk_dup(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk)))
+#define sk_CMS_RevocationInfoChoice_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CMS_RevocationInfoChoice)*)OPENSSL_sk_deep_copy(ossl_check_const_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_copyfunc_type(copyfunc), ossl_check_CMS_RevocationInfoChoice_freefunc_type(freefunc)))
 #define sk_CMS_RevocationInfoChoice_set_cmp_func(sk, cmp) ((sk_CMS_RevocationInfoChoice_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CMS_RevocationInfoChoice_sk_type(sk), ossl_check_CMS_RevocationInfoChoice_compfunc_type(cmp)))
 
+    DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo)
+    DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest)
+    DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo)
+
+    CMS_ContentInfo* CMS_ContentInfo_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+
+#define CMS_SIGNERINFO_ISSUER_SERIAL 0
+#define CMS_SIGNERINFO_KEYIDENTIFIER 1
+
+#define CMS_RECIPINFO_NONE -1
+#define CMS_RECIPINFO_TRANS 0
+#define CMS_RECIPINFO_AGREE 1
+#define CMS_RECIPINFO_KEK 2
+#define CMS_RECIPINFO_PASS 3
+#define CMS_RECIPINFO_OTHER 4
+
+    /* S/MIME related flags */
+
+#define CMS_TEXT 0x1
+#define CMS_NOCERTS 0x2
+#define CMS_NO_CONTENT_VERIFY 0x4
+#define CMS_NO_ATTR_VERIFY 0x8
+#define CMS_NOSIGS \
+    (CMS_NO_CONTENT_VERIFY | CMS_NO_ATTR_VERIFY)
+#define CMS_NOINTERN 0x10
+#define CMS_NO_SIGNER_CERT_VERIFY 0x20
+#define CMS_NOVERIFY 0x20
+#define CMS_DETACHED 0x40
+#define CMS_BINARY 0x80
+#define CMS_NOATTR 0x100
+#define CMS_NOSMIMECAP 0x200
+#define CMS_NOOLDMIMETYPE 0x400
+#define CMS_CRLFEOL 0x800
+#define CMS_STREAM 0x1000
+#define CMS_NOCRL 0x2000
+#define CMS_PARTIAL 0x4000
+#define CMS_REUSE_DIGEST 0x8000
+#define CMS_USE_KEYID 0x10000
+#define CMS_DEBUG_DECRYPT 0x20000
+#define CMS_KEY_PARAM 0x40000
+#define CMS_ASCIICRLF 0x80000
+#define CMS_CADES 0x100000
+#define CMS_USE_ORIGINATOR_KEYID 0x200000
+
+    const ASN1_OBJECT* CMS_get0_type(const CMS_ContentInfo* cms);
+
+    BIO* CMS_dataInit(CMS_ContentInfo* cms, BIO* icont);
+    int CMS_dataFinal(CMS_ContentInfo* cms, BIO* bio);
+
+    ASN1_OCTET_STRING** CMS_get0_content(CMS_ContentInfo* cms);
+    int CMS_is_detached(CMS_ContentInfo* cms);
+    int CMS_set_detached(CMS_ContentInfo* cms, int detached);
+
+#ifdef OPENSSL_PEM_H
+    DECLARE_PEM_rw(CMS, CMS_ContentInfo)
+#endif
+        int CMS_stream(unsigned char*** boundary, CMS_ContentInfo* cms);
+    CMS_ContentInfo* d2i_CMS_bio(BIO* bp, CMS_ContentInfo** cms);
+    int i2d_CMS_bio(BIO* bp, CMS_ContentInfo* cms);
+
+    BIO* BIO_new_CMS(BIO* out, CMS_ContentInfo* cms);
+    int i2d_CMS_bio_stream(BIO* out, CMS_ContentInfo* cms, BIO* in, int flags);
+    int PEM_write_bio_CMS_stream(BIO* out, CMS_ContentInfo* cms, BIO* in, int flags);
+    CMS_ContentInfo* SMIME_read_CMS(BIO* bio, BIO** bcont);
+    CMS_ContentInfo* SMIME_read_CMS_ex(BIO* bio, int flags, BIO** bcont, CMS_ContentInfo** ci);
+    int SMIME_write_CMS(BIO* bio, CMS_ContentInfo* cms, BIO* data, int flags);
+
+    int CMS_final(CMS_ContentInfo* cms, BIO* data, BIO* dcont, unsigned int flags);
+
+    CMS_ContentInfo* CMS_sign(X509* signcert, EVP_PKEY* pkey, STACK_OF(X509) * certs, BIO* data, unsigned int flags);
+    CMS_ContentInfo* CMS_sign_ex(X509* signcert, EVP_PKEY* pkey, STACK_OF(X509) * certs, BIO* data, unsigned int flags, OSSL_LIB_CTX* ctx, const char* propq);
+
+    CMS_ContentInfo* CMS_sign_receipt(CMS_SignerInfo* si, X509* signcert, EVP_PKEY* pkey, STACK_OF(X509) * certs, unsigned int flags);
 
-DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo)
-DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest)
-DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo)
-
-CMS_ContentInfo *CMS_ContentInfo_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
-
-# define CMS_SIGNERINFO_ISSUER_SERIAL    0
-# define CMS_SIGNERINFO_KEYIDENTIFIER    1
-
-# define CMS_RECIPINFO_NONE              -1
-# define CMS_RECIPINFO_TRANS             0
-# define CMS_RECIPINFO_AGREE             1
-# define CMS_RECIPINFO_KEK               2
-# define CMS_RECIPINFO_PASS              3
-# define CMS_RECIPINFO_OTHER             4
-
-/* S/MIME related flags */
-
-# define CMS_TEXT                        0x1
-# define CMS_NOCERTS                     0x2
-# define CMS_NO_CONTENT_VERIFY           0x4
-# define CMS_NO_ATTR_VERIFY              0x8
-# define CMS_NOSIGS                      \
-                        (CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY)
-# define CMS_NOINTERN                    0x10
-# define CMS_NO_SIGNER_CERT_VERIFY       0x20
-# define CMS_NOVERIFY                    0x20
-# define CMS_DETACHED                    0x40
-# define CMS_BINARY                      0x80
-# define CMS_NOATTR                      0x100
-# define CMS_NOSMIMECAP                  0x200
-# define CMS_NOOLDMIMETYPE               0x400
-# define CMS_CRLFEOL                     0x800
-# define CMS_STREAM                      0x1000
-# define CMS_NOCRL                       0x2000
-# define CMS_PARTIAL                     0x4000
-# define CMS_REUSE_DIGEST                0x8000
-# define CMS_USE_KEYID                   0x10000
-# define CMS_DEBUG_DECRYPT               0x20000
-# define CMS_KEY_PARAM                   0x40000
-# define CMS_ASCIICRLF                   0x80000
-# define CMS_CADES                       0x100000
-# define CMS_USE_ORIGINATOR_KEYID        0x200000
-
-const ASN1_OBJECT *CMS_get0_type(const CMS_ContentInfo *cms);
-
-BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont);
-int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio);
-
-ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms);
-int CMS_is_detached(CMS_ContentInfo *cms);
-int CMS_set_detached(CMS_ContentInfo *cms, int detached);
-
-# ifdef OPENSSL_PEM_H
-DECLARE_PEM_rw(CMS, CMS_ContentInfo)
-# endif
-int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms);
-CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms);
-int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms);
-
-BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms);
-int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags);
-int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in,
-                             int flags);
-CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont);
-CMS_ContentInfo *SMIME_read_CMS_ex(BIO *bio, int flags, BIO **bcont, CMS_ContentInfo **ci);
-int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags);
-
-int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont,
-              unsigned int flags);
-
-CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey,
-                          STACK_OF(X509) *certs, BIO *data,
-                          unsigned int flags);
-CMS_ContentInfo *CMS_sign_ex(X509 *signcert, EVP_PKEY *pkey,
-                             STACK_OF(X509) *certs, BIO *data,
-                             unsigned int flags, OSSL_LIB_CTX *ctx,
-                             const char *propq);
-
-CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si,
-                                  X509 *signcert, EVP_PKEY *pkey,
-                                  STACK_OF(X509) *certs, unsigned int flags);
-
-int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags);
-CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags);
-CMS_ContentInfo *CMS_data_create_ex(BIO *in, unsigned int flags,
-                                    OSSL_LIB_CTX *ctx, const char *propq);
-
-int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
-                      unsigned int flags);
-CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md,
-                                   unsigned int flags);
-CMS_ContentInfo *CMS_digest_create_ex(BIO *in, const EVP_MD *md,
-                                      unsigned int flags, OSSL_LIB_CTX *ctx,
-                                      const char *propq);
-
-int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms,
-                              const unsigned char *key, size_t keylen,
-                              BIO *dcont, BIO *out, unsigned int flags);
-
-CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher,
-                                           const unsigned char *key,
-                                           size_t keylen, unsigned int flags);
-CMS_ContentInfo *CMS_EncryptedData_encrypt_ex(BIO *in, const EVP_CIPHER *cipher,
-                                              const unsigned char *key,
-                                              size_t keylen, unsigned int flags,
-                                              OSSL_LIB_CTX *ctx,
-                                              const char *propq);
-
-int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph,
-                               const unsigned char *key, size_t keylen);
-
-int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
-               X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags);
-
-int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms,
-                       STACK_OF(X509) *certs,
-                       X509_STORE *store, unsigned int flags);
-
-STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms);
-
-CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in,
-                             const EVP_CIPHER *cipher, unsigned int flags);
-CMS_ContentInfo *CMS_encrypt_ex(STACK_OF(X509) *certs, BIO *in,
-                                const EVP_CIPHER *cipher, unsigned int flags,
-                                OSSL_LIB_CTX *ctx, const char *propq);
-
-int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert,
-                BIO *dcont, BIO *out, unsigned int flags);
-
-int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert);
-int CMS_decrypt_set1_pkey_and_peer(CMS_ContentInfo *cms, EVP_PKEY *pk,
-                                   X509 *cert, X509 *peer);
-int CMS_decrypt_set1_key(CMS_ContentInfo *cms,
-                         unsigned char *key, size_t keylen,
-                         const unsigned char *id, size_t idlen);
-int CMS_decrypt_set1_password(CMS_ContentInfo *cms,
-                              unsigned char *pass, ossl_ssize_t passlen);
-
-STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms);
-int CMS_RecipientInfo_type(CMS_RecipientInfo *ri);
-EVP_PKEY_CTX *CMS_RecipientInfo_get0_pkey_ctx(CMS_RecipientInfo *ri);
-CMS_ContentInfo *CMS_AuthEnvelopedData_create(const EVP_CIPHER *cipher);
-CMS_ContentInfo *
-CMS_AuthEnvelopedData_create_ex(const EVP_CIPHER *cipher, OSSL_LIB_CTX *ctx,
-                                const char *propq);
-CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher);
-CMS_ContentInfo *CMS_EnvelopedData_create_ex(const EVP_CIPHER *cipher,
-                                             OSSL_LIB_CTX *ctx,
-                                             const char *propq);
-
-CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms,
-                                           X509 *recip, unsigned int flags);
-CMS_RecipientInfo *CMS_add1_recipient(CMS_ContentInfo *cms, X509 *recip,
-     EVP_PKEY *originatorPrivKey, X509 * originator, unsigned int flags);
-int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey);
-int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert);
-int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri,
-                                     EVP_PKEY **pk, X509 **recip,
-                                     X509_ALGOR **palg);
-int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri,
-                                          ASN1_OCTET_STRING **keyid,
-                                          X509_NAME **issuer,
-                                          ASN1_INTEGER **sno);
-
-CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid,
-                                          unsigned char *key, size_t keylen,
-                                          unsigned char *id, size_t idlen,
-                                          ASN1_GENERALIZEDTIME *date,
-                                          ASN1_OBJECT *otherTypeId,
-                                          ASN1_TYPE *otherType);
-
-int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri,
-                                    X509_ALGOR **palg,
-                                    ASN1_OCTET_STRING **pid,
-                                    ASN1_GENERALIZEDTIME **pdate,
-                                    ASN1_OBJECT **potherid,
-                                    ASN1_TYPE **pothertype);
-
-int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri,
-                               unsigned char *key, size_t keylen);
-
-int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri,
-                                   const unsigned char *id, size_t idlen);
-
-int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri,
-                                    unsigned char *pass,
-                                    ossl_ssize_t passlen);
-
-CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,
-                                               int iter, int wrap_nid,
-                                               int pbe_nid,
-                                               unsigned char *pass,
-                                               ossl_ssize_t passlen,
-                                               const EVP_CIPHER *kekciph);
-
-int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri);
-int CMS_RecipientInfo_encrypt(const CMS_ContentInfo *cms, CMS_RecipientInfo *ri);
-
-int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out,
-                   unsigned int flags);
-CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags);
-
-int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid);
-const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms);
-
-CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms);
-int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert);
-int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert);
-STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms);
-
-CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms);
-int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl);
-int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl);
-STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms);
-
-int CMS_SignedData_init(CMS_ContentInfo *cms);
-CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms,
-                                X509 *signer, EVP_PKEY *pk, const EVP_MD *md,
-                                unsigned int flags);
-EVP_PKEY_CTX *CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si);
-EVP_MD_CTX *CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si);
-STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms);
-
-void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer);
-int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si,
-                                  ASN1_OCTET_STRING **keyid,
-                                  X509_NAME **issuer, ASN1_INTEGER **sno);
-int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert);
-int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs,
-                           unsigned int flags);
-void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk,
-                              X509 **signer, X509_ALGOR **pdig,
-                              X509_ALGOR **psig);
-ASN1_OCTET_STRING *CMS_SignerInfo_get0_signature(CMS_SignerInfo *si);
-int CMS_SignerInfo_sign(CMS_SignerInfo *si);
-int CMS_SignerInfo_verify(CMS_SignerInfo *si);
-int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain);
-
-int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs);
-int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs,
-                            int algnid, int keysize);
-int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap);
-
-int CMS_signed_get_attr_count(const CMS_SignerInfo *si);
-int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
-                               int lastpos);
-int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, const ASN1_OBJECT *obj,
-                               int lastpos);
-X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc);
-X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc);
-int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr);
-int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si,
-                                const ASN1_OBJECT *obj, int type,
-                                const void *bytes, int len);
-int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si,
-                                int nid, int type,
-                                const void *bytes, int len);
-int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si,
-                                const char *attrname, int type,
-                                const void *bytes, int len);
-void *CMS_signed_get0_data_by_OBJ(const CMS_SignerInfo *si,
-                                  const ASN1_OBJECT *oid,
-                                  int lastpos, int type);
-
-int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si);
-int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid,
-                                 int lastpos);
-int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si,
-                                 const ASN1_OBJECT *obj, int lastpos);
-X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc);
-X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc);
-int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr);
-int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si,
-                                  const ASN1_OBJECT *obj, int type,
-                                  const void *bytes, int len);
-int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si,
-                                  int nid, int type,
-                                  const void *bytes, int len);
-int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si,
-                                  const char *attrname, int type,
-                                  const void *bytes, int len);
-void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid,
-                                    int lastpos, int type);
-
-int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr);
-CMS_ReceiptRequest *CMS_ReceiptRequest_create0(
-    unsigned char *id, int idlen, int allorfirst,
-    STACK_OF(GENERAL_NAMES) *receiptList,
-    STACK_OF(GENERAL_NAMES) *receiptsTo);
-CMS_ReceiptRequest *CMS_ReceiptRequest_create0_ex(
-    unsigned char *id, int idlen, int allorfirst,
-    STACK_OF(GENERAL_NAMES) *receiptList,
-    STACK_OF(GENERAL_NAMES) *receiptsTo,
-    OSSL_LIB_CTX *ctx);
-
-int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr);
-void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr,
-                                    ASN1_STRING **pcid,
-                                    int *pallorfirst,
-                                    STACK_OF(GENERAL_NAMES) **plist,
-                                    STACK_OF(GENERAL_NAMES) **prto);
-int CMS_RecipientInfo_kari_get0_alg(CMS_RecipientInfo *ri,
-                                    X509_ALGOR **palg,
-                                    ASN1_OCTET_STRING **pukm);
-STACK_OF(CMS_RecipientEncryptedKey)
-*CMS_RecipientInfo_kari_get0_reks(CMS_RecipientInfo *ri);
-
-int CMS_RecipientInfo_kari_get0_orig_id(CMS_RecipientInfo *ri,
-                                        X509_ALGOR **pubalg,
-                                        ASN1_BIT_STRING **pubkey,
-                                        ASN1_OCTET_STRING **keyid,
-                                        X509_NAME **issuer,
-                                        ASN1_INTEGER **sno);
-
-int CMS_RecipientInfo_kari_orig_id_cmp(CMS_RecipientInfo *ri, X509 *cert);
-
-int CMS_RecipientEncryptedKey_get0_id(CMS_RecipientEncryptedKey *rek,
-                                      ASN1_OCTET_STRING **keyid,
-                                      ASN1_GENERALIZEDTIME **tm,
-                                      CMS_OtherKeyAttribute **other,
-                                      X509_NAME **issuer, ASN1_INTEGER **sno);
-int CMS_RecipientEncryptedKey_cert_cmp(CMS_RecipientEncryptedKey *rek,
-                                       X509 *cert);
-int CMS_RecipientInfo_kari_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pk);
-int CMS_RecipientInfo_kari_set0_pkey_and_peer(CMS_RecipientInfo *ri, EVP_PKEY *pk, X509 *peer);
-EVP_CIPHER_CTX *CMS_RecipientInfo_kari_get0_ctx(CMS_RecipientInfo *ri);
-int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo *cms,
-                                   CMS_RecipientInfo *ri,
-                                   CMS_RecipientEncryptedKey *rek);
-
-int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg,
-                          ASN1_OCTET_STRING *ukm, int keylen);
+    int CMS_data(CMS_ContentInfo* cms, BIO* out, unsigned int flags);
+    CMS_ContentInfo* CMS_data_create(BIO* in, unsigned int flags);
+    CMS_ContentInfo* CMS_data_create_ex(BIO* in, unsigned int flags, OSSL_LIB_CTX* ctx, const char* propq);
+
+    int CMS_digest_verify(CMS_ContentInfo* cms, BIO* dcont, BIO* out, unsigned int flags);
+    CMS_ContentInfo* CMS_digest_create(BIO* in, const EVP_MD* md, unsigned int flags);
+    CMS_ContentInfo* CMS_digest_create_ex(BIO* in, const EVP_MD* md, unsigned int flags, OSSL_LIB_CTX* ctx, const char* propq);
+
+    int CMS_EncryptedData_decrypt(CMS_ContentInfo* cms, const unsigned char* key, size_t keylen, BIO* dcont, BIO* out, unsigned int flags);
+
+    CMS_ContentInfo* CMS_EncryptedData_encrypt(BIO* in, const EVP_CIPHER* cipher, const unsigned char* key, size_t keylen, unsigned int flags);
+    CMS_ContentInfo* CMS_EncryptedData_encrypt_ex(BIO* in, const EVP_CIPHER* cipher, const unsigned char* key, size_t keylen, unsigned int flags, OSSL_LIB_CTX* ctx, const char* propq);
+
+    int CMS_EncryptedData_set1_key(CMS_ContentInfo* cms, const EVP_CIPHER* ciph, const unsigned char* key, size_t keylen);
+
+    int CMS_verify(CMS_ContentInfo* cms, STACK_OF(X509) * certs, X509_STORE* store, BIO* dcont, BIO* out, unsigned int flags);
+
+    int CMS_verify_receipt(CMS_ContentInfo* rcms, CMS_ContentInfo* ocms, STACK_OF(X509) * certs, X509_STORE* store, unsigned int flags);
+
+    STACK_OF(X509) * CMS_get0_signers(CMS_ContentInfo* cms);
+
+    CMS_ContentInfo* CMS_encrypt(STACK_OF(X509) * certs, BIO* in, const EVP_CIPHER* cipher, unsigned int flags);
+    CMS_ContentInfo* CMS_encrypt_ex(STACK_OF(X509) * certs, BIO* in, const EVP_CIPHER* cipher, unsigned int flags, OSSL_LIB_CTX* ctx, const char* propq);
+
+    int CMS_decrypt(CMS_ContentInfo* cms, EVP_PKEY* pkey, X509* cert, BIO* dcont, BIO* out, unsigned int flags);
+
+    int CMS_decrypt_set1_pkey(CMS_ContentInfo* cms, EVP_PKEY* pk, X509* cert);
+    int CMS_decrypt_set1_pkey_and_peer(CMS_ContentInfo* cms, EVP_PKEY* pk, X509* cert, X509* peer);
+    int CMS_decrypt_set1_key(CMS_ContentInfo* cms, unsigned char* key, size_t keylen, const unsigned char* id, size_t idlen);
+    int CMS_decrypt_set1_password(CMS_ContentInfo* cms, unsigned char* pass, ossl_ssize_t passlen);
+
+    STACK_OF(CMS_RecipientInfo) * CMS_get0_RecipientInfos(CMS_ContentInfo* cms);
+    int CMS_RecipientInfo_type(CMS_RecipientInfo* ri);
+    EVP_PKEY_CTX* CMS_RecipientInfo_get0_pkey_ctx(CMS_RecipientInfo* ri);
+    CMS_ContentInfo* CMS_AuthEnvelopedData_create(const EVP_CIPHER* cipher);
+    CMS_ContentInfo*
+        CMS_AuthEnvelopedData_create_ex(const EVP_CIPHER* cipher, OSSL_LIB_CTX* ctx, const char* propq);
+    CMS_ContentInfo* CMS_EnvelopedData_create(const EVP_CIPHER* cipher);
+    CMS_ContentInfo* CMS_EnvelopedData_create_ex(const EVP_CIPHER* cipher, OSSL_LIB_CTX* ctx, const char* propq);
+
+    CMS_RecipientInfo* CMS_add1_recipient_cert(CMS_ContentInfo* cms, X509* recip, unsigned int flags);
+    CMS_RecipientInfo* CMS_add1_recipient(CMS_ContentInfo* cms, X509* recip, EVP_PKEY* originatorPrivKey, X509* originator, unsigned int flags);
+    int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo* ri, EVP_PKEY* pkey);
+    int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo* ri, X509* cert);
+    int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo* ri, EVP_PKEY** pk, X509** recip, X509_ALGOR** palg);
+    int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo* ri, ASN1_OCTET_STRING** keyid, X509_NAME** issuer, ASN1_INTEGER** sno);
+
+    CMS_RecipientInfo* CMS_add0_recipient_key(CMS_ContentInfo* cms, int nid, unsigned char* key, size_t keylen, unsigned char* id, size_t idlen, ASN1_GENERALIZEDTIME* date, ASN1_OBJECT* otherTypeId, ASN1_TYPE* otherType);
+
+    int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo* ri, X509_ALGOR** palg, ASN1_OCTET_STRING** pid, ASN1_GENERALIZEDTIME** pdate, ASN1_OBJECT** potherid, ASN1_TYPE** pothertype);
+
+    int CMS_RecipientInfo_set0_key(CMS_RecipientInfo* ri, unsigned char* key, size_t keylen);
+
+    int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo* ri, const unsigned char* id, size_t idlen);
+
+    int CMS_RecipientInfo_set0_password(CMS_RecipientInfo* ri, unsigned char* pass, ossl_ssize_t passlen);
+
+    CMS_RecipientInfo* CMS_add0_recipient_password(CMS_ContentInfo* cms, int iter, int wrap_nid, int pbe_nid, unsigned char* pass, ossl_ssize_t passlen, const EVP_CIPHER* kekciph);
+
+    int CMS_RecipientInfo_decrypt(CMS_ContentInfo* cms, CMS_RecipientInfo* ri);
+    int CMS_RecipientInfo_encrypt(const CMS_ContentInfo* cms, CMS_RecipientInfo* ri);
+
+    int CMS_uncompress(CMS_ContentInfo* cms, BIO* dcont, BIO* out, unsigned int flags);
+    CMS_ContentInfo* CMS_compress(BIO* in, int comp_nid, unsigned int flags);
+
+    int CMS_set1_eContentType(CMS_ContentInfo* cms, const ASN1_OBJECT* oid);
+    const ASN1_OBJECT* CMS_get0_eContentType(CMS_ContentInfo* cms);
+
+    CMS_CertificateChoices* CMS_add0_CertificateChoices(CMS_ContentInfo* cms);
+    int CMS_add0_cert(CMS_ContentInfo* cms, X509* cert);
+    int CMS_add1_cert(CMS_ContentInfo* cms, X509* cert);
+    STACK_OF(X509) * CMS_get1_certs(CMS_ContentInfo* cms);
+
+    CMS_RevocationInfoChoice* CMS_add0_RevocationInfoChoice(CMS_ContentInfo* cms);
+    int CMS_add0_crl(CMS_ContentInfo* cms, X509_CRL* crl);
+    int CMS_add1_crl(CMS_ContentInfo* cms, X509_CRL* crl);
+    STACK_OF(X509_CRL) * CMS_get1_crls(CMS_ContentInfo* cms);
+
+    int CMS_SignedData_init(CMS_ContentInfo* cms);
+    CMS_SignerInfo* CMS_add1_signer(CMS_ContentInfo* cms, X509* signer, EVP_PKEY* pk, const EVP_MD* md, unsigned int flags);
+    EVP_PKEY_CTX* CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo* si);
+    EVP_MD_CTX* CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo* si);
+    STACK_OF(CMS_SignerInfo) * CMS_get0_SignerInfos(CMS_ContentInfo* cms);
+
+    void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo* si, X509* signer);
+    int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo* si, ASN1_OCTET_STRING** keyid, X509_NAME** issuer, ASN1_INTEGER** sno);
+    int CMS_SignerInfo_cert_cmp(CMS_SignerInfo* si, X509* cert);
+    int CMS_set1_signers_certs(CMS_ContentInfo* cms, STACK_OF(X509) * certs, unsigned int flags);
+    void CMS_SignerInfo_get0_algs(CMS_SignerInfo* si, EVP_PKEY** pk, X509** signer, X509_ALGOR** pdig, X509_ALGOR** psig);
+    ASN1_OCTET_STRING* CMS_SignerInfo_get0_signature(CMS_SignerInfo* si);
+    int CMS_SignerInfo_sign(CMS_SignerInfo* si);
+    int CMS_SignerInfo_verify(CMS_SignerInfo* si);
+    int CMS_SignerInfo_verify_content(CMS_SignerInfo* si, BIO* chain);
+
+    int CMS_add_smimecap(CMS_SignerInfo* si, STACK_OF(X509_ALGOR) * algs);
+    int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) * *algs, int algnid, int keysize);
+    int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) * *smcap);
+
+    int CMS_signed_get_attr_count(const CMS_SignerInfo* si);
+    int CMS_signed_get_attr_by_NID(const CMS_SignerInfo* si, int nid, int lastpos);
+    int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo* si, const ASN1_OBJECT* obj, int lastpos);
+    X509_ATTRIBUTE* CMS_signed_get_attr(const CMS_SignerInfo* si, int loc);
+    X509_ATTRIBUTE* CMS_signed_delete_attr(CMS_SignerInfo* si, int loc);
+    int CMS_signed_add1_attr(CMS_SignerInfo* si, X509_ATTRIBUTE* attr);
+    int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo* si, const ASN1_OBJECT* obj, int type, const void* bytes, int len);
+    int CMS_signed_add1_attr_by_NID(CMS_SignerInfo* si, int nid, int type, const void* bytes, int len);
+    int CMS_signed_add1_attr_by_txt(CMS_SignerInfo* si, const char* attrname, int type, const void* bytes, int len);
+    void* CMS_signed_get0_data_by_OBJ(const CMS_SignerInfo* si, const ASN1_OBJECT* oid, int lastpos, int type);
+
+    int CMS_unsigned_get_attr_count(const CMS_SignerInfo* si);
+    int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo* si, int nid, int lastpos);
+    int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo* si, const ASN1_OBJECT* obj, int lastpos);
+    X509_ATTRIBUTE* CMS_unsigned_get_attr(const CMS_SignerInfo* si, int loc);
+    X509_ATTRIBUTE* CMS_unsigned_delete_attr(CMS_SignerInfo* si, int loc);
+    int CMS_unsigned_add1_attr(CMS_SignerInfo* si, X509_ATTRIBUTE* attr);
+    int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo* si, const ASN1_OBJECT* obj, int type, const void* bytes, int len);
+    int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo* si, int nid, int type, const void* bytes, int len);
+    int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo* si, const char* attrname, int type, const void* bytes, int len);
+    void* CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo* si, ASN1_OBJECT* oid, int lastpos, int type);
+
+    int CMS_get1_ReceiptRequest(CMS_SignerInfo* si, CMS_ReceiptRequest** prr);
+    CMS_ReceiptRequest* CMS_ReceiptRequest_create0(
+        unsigned char* id, int idlen, int allorfirst, STACK_OF(GENERAL_NAMES) * receiptList, STACK_OF(GENERAL_NAMES) * receiptsTo
+    );
+    CMS_ReceiptRequest* CMS_ReceiptRequest_create0_ex(
+        unsigned char* id, int idlen, int allorfirst, STACK_OF(GENERAL_NAMES) * receiptList, STACK_OF(GENERAL_NAMES) * receiptsTo, OSSL_LIB_CTX* ctx
+    );
+
+    int CMS_add1_ReceiptRequest(CMS_SignerInfo* si, CMS_ReceiptRequest* rr);
+    void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest* rr, ASN1_STRING** pcid, int* pallorfirst, STACK_OF(GENERAL_NAMES) * *plist, STACK_OF(GENERAL_NAMES) * *prto);
+    int CMS_RecipientInfo_kari_get0_alg(CMS_RecipientInfo* ri, X509_ALGOR** palg, ASN1_OCTET_STRING** pukm);
+    STACK_OF(CMS_RecipientEncryptedKey)
+    *CMS_RecipientInfo_kari_get0_reks(CMS_RecipientInfo* ri);
+
+    int CMS_RecipientInfo_kari_get0_orig_id(CMS_RecipientInfo* ri, X509_ALGOR** pubalg, ASN1_BIT_STRING** pubkey, ASN1_OCTET_STRING** keyid, X509_NAME** issuer, ASN1_INTEGER** sno);
+
+    int CMS_RecipientInfo_kari_orig_id_cmp(CMS_RecipientInfo* ri, X509* cert);
+
+    int CMS_RecipientEncryptedKey_get0_id(CMS_RecipientEncryptedKey* rek, ASN1_OCTET_STRING** keyid, ASN1_GENERALIZEDTIME** tm, CMS_OtherKeyAttribute** other, X509_NAME** issuer, ASN1_INTEGER** sno);
+    int CMS_RecipientEncryptedKey_cert_cmp(CMS_RecipientEncryptedKey* rek, X509* cert);
+    int CMS_RecipientInfo_kari_set0_pkey(CMS_RecipientInfo* ri, EVP_PKEY* pk);
+    int CMS_RecipientInfo_kari_set0_pkey_and_peer(CMS_RecipientInfo* ri, EVP_PKEY* pk, X509* peer);
+    EVP_CIPHER_CTX* CMS_RecipientInfo_kari_get0_ctx(CMS_RecipientInfo* ri);
+    int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo* cms, CMS_RecipientInfo* ri, CMS_RecipientEncryptedKey* rek);
+
+    int CMS_SharedInfo_encode(unsigned char** pder, X509_ALGOR* kekalg, ASN1_OCTET_STRING* ukm, int keylen);
 
 /* Backward compatibility for spelling errors. */
-# define CMS_R_UNKNOWN_DIGEST_ALGORITM CMS_R_UNKNOWN_DIGEST_ALGORITHM
-# define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE \
+#define CMS_R_UNKNOWN_DIGEST_ALGORITM CMS_R_UNKNOWN_DIGEST_ALGORITHM
+#define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE \
     CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE
 
-#  ifdef  __cplusplus
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/cmserr.h b/CAPI/cpp/grpc/include/openssl/cmserr.h
index 1c4f4c7..edea34a 100644
--- a/CAPI/cpp/grpc/include/openssl/cmserr.h
+++ b/CAPI/cpp/grpc/include/openssl/cmserr.h
@@ -9,114 +9,112 @@
  */
 
 #ifndef OPENSSL_CMSERR_H
-# define OPENSSL_CMSERR_H
-# pragma once
+#define OPENSSL_CMSERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_CMS
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_CMS
 
 /*
  * CMS reason codes.
  */
-#  define CMS_R_ADD_SIGNER_ERROR                           99
-#  define CMS_R_ATTRIBUTE_ERROR                            161
-#  define CMS_R_CERTIFICATE_ALREADY_PRESENT                175
-#  define CMS_R_CERTIFICATE_HAS_NO_KEYID                   160
-#  define CMS_R_CERTIFICATE_VERIFY_ERROR                   100
-#  define CMS_R_CIPHER_AEAD_SET_TAG_ERROR                  184
-#  define CMS_R_CIPHER_GET_TAG                             185
-#  define CMS_R_CIPHER_INITIALISATION_ERROR                101
-#  define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR      102
-#  define CMS_R_CMS_DATAFINAL_ERROR                        103
-#  define CMS_R_CMS_LIB                                    104
-#  define CMS_R_CONTENTIDENTIFIER_MISMATCH                 170
-#  define CMS_R_CONTENT_NOT_FOUND                          105
-#  define CMS_R_CONTENT_TYPE_MISMATCH                      171
-#  define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA           106
-#  define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA            107
-#  define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA               108
-#  define CMS_R_CONTENT_VERIFY_ERROR                       109
-#  define CMS_R_CTRL_ERROR                                 110
-#  define CMS_R_CTRL_FAILURE                               111
-#  define CMS_R_DECODE_ERROR                               187
-#  define CMS_R_DECRYPT_ERROR                              112
-#  define CMS_R_ERROR_GETTING_PUBLIC_KEY                   113
-#  define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE      114
-#  define CMS_R_ERROR_SETTING_KEY                          115
-#  define CMS_R_ERROR_SETTING_RECIPIENTINFO                116
-#  define CMS_R_ESS_SIGNING_CERTID_MISMATCH_ERROR          183
-#  define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH               117
-#  define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER           176
-#  define CMS_R_INVALID_KEY_LENGTH                         118
-#  define CMS_R_INVALID_LABEL                              190
-#  define CMS_R_INVALID_OAEP_PARAMETERS                    191
-#  define CMS_R_KDF_PARAMETER_ERROR                        186
-#  define CMS_R_MD_BIO_INIT_ERROR                          119
-#  define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH       120
-#  define CMS_R_MESSAGEDIGEST_WRONG_LENGTH                 121
-#  define CMS_R_MSGSIGDIGEST_ERROR                         172
-#  define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE          162
-#  define CMS_R_MSGSIGDIGEST_WRONG_LENGTH                  163
-#  define CMS_R_NEED_ONE_SIGNER                            164
-#  define CMS_R_NOT_A_SIGNED_RECEIPT                       165
-#  define CMS_R_NOT_ENCRYPTED_DATA                         122
-#  define CMS_R_NOT_KEK                                    123
-#  define CMS_R_NOT_KEY_AGREEMENT                          181
-#  define CMS_R_NOT_KEY_TRANSPORT                          124
-#  define CMS_R_NOT_PWRI                                   177
-#  define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE            125
-#  define CMS_R_NO_CIPHER                                  126
-#  define CMS_R_NO_CONTENT                                 127
-#  define CMS_R_NO_CONTENT_TYPE                            173
-#  define CMS_R_NO_DEFAULT_DIGEST                          128
-#  define CMS_R_NO_DIGEST_SET                              129
-#  define CMS_R_NO_KEY                                     130
-#  define CMS_R_NO_KEY_OR_CERT                             174
-#  define CMS_R_NO_MATCHING_DIGEST                         131
-#  define CMS_R_NO_MATCHING_RECIPIENT                      132
-#  define CMS_R_NO_MATCHING_SIGNATURE                      166
-#  define CMS_R_NO_MSGSIGDIGEST                            167
-#  define CMS_R_NO_PASSWORD                                178
-#  define CMS_R_NO_PRIVATE_KEY                             133
-#  define CMS_R_NO_PUBLIC_KEY                              134
-#  define CMS_R_NO_RECEIPT_REQUEST                         168
-#  define CMS_R_NO_SIGNERS                                 135
-#  define CMS_R_PEER_KEY_ERROR                             188
-#  define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE     136
-#  define CMS_R_RECEIPT_DECODE_ERROR                       169
-#  define CMS_R_RECIPIENT_ERROR                            137
-#  define CMS_R_SHARED_INFO_ERROR                          189
-#  define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND               138
-#  define CMS_R_SIGNFINAL_ERROR                            139
-#  define CMS_R_SMIME_TEXT_ERROR                           140
-#  define CMS_R_STORE_INIT_ERROR                           141
-#  define CMS_R_TYPE_NOT_COMPRESSED_DATA                   142
-#  define CMS_R_TYPE_NOT_DATA                              143
-#  define CMS_R_TYPE_NOT_DIGESTED_DATA                     144
-#  define CMS_R_TYPE_NOT_ENCRYPTED_DATA                    145
-#  define CMS_R_TYPE_NOT_ENVELOPED_DATA                    146
-#  define CMS_R_UNABLE_TO_FINALIZE_CONTEXT                 147
-#  define CMS_R_UNKNOWN_CIPHER                             148
-#  define CMS_R_UNKNOWN_DIGEST_ALGORITHM                   149
-#  define CMS_R_UNKNOWN_ID                                 150
-#  define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM          151
-#  define CMS_R_UNSUPPORTED_CONTENT_TYPE                   152
-#  define CMS_R_UNSUPPORTED_ENCRYPTION_TYPE                192
-#  define CMS_R_UNSUPPORTED_KEK_ALGORITHM                  153
-#  define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM       179
-#  define CMS_R_UNSUPPORTED_LABEL_SOURCE                   193
-#  define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE             155
-#  define CMS_R_UNSUPPORTED_RECIPIENT_TYPE                 154
-#  define CMS_R_UNSUPPORTED_TYPE                           156
-#  define CMS_R_UNWRAP_ERROR                               157
-#  define CMS_R_UNWRAP_FAILURE                             180
-#  define CMS_R_VERIFICATION_FAILURE                       158
-#  define CMS_R_WRAP_ERROR                                 159
+#define CMS_R_ADD_SIGNER_ERROR 99
+#define CMS_R_ATTRIBUTE_ERROR 161
+#define CMS_R_CERTIFICATE_ALREADY_PRESENT 175
+#define CMS_R_CERTIFICATE_HAS_NO_KEYID 160
+#define CMS_R_CERTIFICATE_VERIFY_ERROR 100
+#define CMS_R_CIPHER_AEAD_SET_TAG_ERROR 184
+#define CMS_R_CIPHER_GET_TAG 185
+#define CMS_R_CIPHER_INITIALISATION_ERROR 101
+#define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR 102
+#define CMS_R_CMS_DATAFINAL_ERROR 103
+#define CMS_R_CMS_LIB 104
+#define CMS_R_CONTENTIDENTIFIER_MISMATCH 170
+#define CMS_R_CONTENT_NOT_FOUND 105
+#define CMS_R_CONTENT_TYPE_MISMATCH 171
+#define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA 106
+#define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA 107
+#define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA 108
+#define CMS_R_CONTENT_VERIFY_ERROR 109
+#define CMS_R_CTRL_ERROR 110
+#define CMS_R_CTRL_FAILURE 111
+#define CMS_R_DECODE_ERROR 187
+#define CMS_R_DECRYPT_ERROR 112
+#define CMS_R_ERROR_GETTING_PUBLIC_KEY 113
+#define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE 114
+#define CMS_R_ERROR_SETTING_KEY 115
+#define CMS_R_ERROR_SETTING_RECIPIENTINFO 116
+#define CMS_R_ESS_SIGNING_CERTID_MISMATCH_ERROR 183
+#define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH 117
+#define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER 176
+#define CMS_R_INVALID_KEY_LENGTH 118
+#define CMS_R_INVALID_LABEL 190
+#define CMS_R_INVALID_OAEP_PARAMETERS 191
+#define CMS_R_KDF_PARAMETER_ERROR 186
+#define CMS_R_MD_BIO_INIT_ERROR 119
+#define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH 120
+#define CMS_R_MESSAGEDIGEST_WRONG_LENGTH 121
+#define CMS_R_MSGSIGDIGEST_ERROR 172
+#define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE 162
+#define CMS_R_MSGSIGDIGEST_WRONG_LENGTH 163
+#define CMS_R_NEED_ONE_SIGNER 164
+#define CMS_R_NOT_A_SIGNED_RECEIPT 165
+#define CMS_R_NOT_ENCRYPTED_DATA 122
+#define CMS_R_NOT_KEK 123
+#define CMS_R_NOT_KEY_AGREEMENT 181
+#define CMS_R_NOT_KEY_TRANSPORT 124
+#define CMS_R_NOT_PWRI 177
+#define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 125
+#define CMS_R_NO_CIPHER 126
+#define CMS_R_NO_CONTENT 127
+#define CMS_R_NO_CONTENT_TYPE 173
+#define CMS_R_NO_DEFAULT_DIGEST 128
+#define CMS_R_NO_DIGEST_SET 129
+#define CMS_R_NO_KEY 130
+#define CMS_R_NO_KEY_OR_CERT 174
+#define CMS_R_NO_MATCHING_DIGEST 131
+#define CMS_R_NO_MATCHING_RECIPIENT 132
+#define CMS_R_NO_MATCHING_SIGNATURE 166
+#define CMS_R_NO_MSGSIGDIGEST 167
+#define CMS_R_NO_PASSWORD 178
+#define CMS_R_NO_PRIVATE_KEY 133
+#define CMS_R_NO_PUBLIC_KEY 134
+#define CMS_R_NO_RECEIPT_REQUEST 168
+#define CMS_R_NO_SIGNERS 135
+#define CMS_R_PEER_KEY_ERROR 188
+#define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 136
+#define CMS_R_RECEIPT_DECODE_ERROR 169
+#define CMS_R_RECIPIENT_ERROR 137
+#define CMS_R_SHARED_INFO_ERROR 189
+#define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND 138
+#define CMS_R_SIGNFINAL_ERROR 139
+#define CMS_R_SMIME_TEXT_ERROR 140
+#define CMS_R_STORE_INIT_ERROR 141
+#define CMS_R_TYPE_NOT_COMPRESSED_DATA 142
+#define CMS_R_TYPE_NOT_DATA 143
+#define CMS_R_TYPE_NOT_DIGESTED_DATA 144
+#define CMS_R_TYPE_NOT_ENCRYPTED_DATA 145
+#define CMS_R_TYPE_NOT_ENVELOPED_DATA 146
+#define CMS_R_UNABLE_TO_FINALIZE_CONTEXT 147
+#define CMS_R_UNKNOWN_CIPHER 148
+#define CMS_R_UNKNOWN_DIGEST_ALGORITHM 149
+#define CMS_R_UNKNOWN_ID 150
+#define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM 151
+#define CMS_R_UNSUPPORTED_CONTENT_TYPE 152
+#define CMS_R_UNSUPPORTED_ENCRYPTION_TYPE 192
+#define CMS_R_UNSUPPORTED_KEK_ALGORITHM 153
+#define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM 179
+#define CMS_R_UNSUPPORTED_LABEL_SOURCE 193
+#define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE 155
+#define CMS_R_UNSUPPORTED_RECIPIENT_TYPE 154
+#define CMS_R_UNSUPPORTED_TYPE 156
+#define CMS_R_UNWRAP_ERROR 157
+#define CMS_R_UNWRAP_FAILURE 180
+#define CMS_R_VERIFICATION_FAILURE 158
+#define CMS_R_WRAP_ERROR 159
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/comp.h b/CAPI/cpp/grpc/include/openssl/comp.h
index 06ff581..2f2840f 100644
--- a/CAPI/cpp/grpc/include/openssl/comp.h
+++ b/CAPI/cpp/grpc/include/openssl/comp.h
@@ -8,52 +8,50 @@
  */
 
 #ifndef OPENSSL_COMP_H
-# define OPENSSL_COMP_H
-# pragma once
+#define OPENSSL_COMP_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_COMP_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_COMP
-# include <openssl/crypto.h>
-# include <openssl/comperr.h>
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_COMP_H
+#endif
 
+#include <openssl/opensslconf.h>
 
+#ifndef OPENSSL_NO_COMP
+#include <openssl/crypto.h>
+#include <openssl/comperr.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-COMP_CTX *COMP_CTX_new(COMP_METHOD *meth);
-const COMP_METHOD *COMP_CTX_get_method(const COMP_CTX *ctx);
-int COMP_CTX_get_type(const COMP_CTX* comp);
-int COMP_get_type(const COMP_METHOD *meth);
-const char *COMP_get_name(const COMP_METHOD *meth);
-void COMP_CTX_free(COMP_CTX *ctx);
+    COMP_CTX* COMP_CTX_new(COMP_METHOD* meth);
+    const COMP_METHOD* COMP_CTX_get_method(const COMP_CTX* ctx);
+    int COMP_CTX_get_type(const COMP_CTX* comp);
+    int COMP_get_type(const COMP_METHOD* meth);
+    const char* COMP_get_name(const COMP_METHOD* meth);
+    void COMP_CTX_free(COMP_CTX* ctx);
 
-int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen,
-                        unsigned char *in, int ilen);
-int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen,
-                      unsigned char *in, int ilen);
+    int COMP_compress_block(COMP_CTX* ctx, unsigned char* out, int olen, unsigned char* in, int ilen);
+    int COMP_expand_block(COMP_CTX* ctx, unsigned char* out, int olen, unsigned char* in, int ilen);
 
-COMP_METHOD *COMP_zlib(void);
+    COMP_METHOD* COMP_zlib(void);
 
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-# define COMP_zlib_cleanup() while(0) continue
+#define COMP_zlib_cleanup() \
+    while (0)               \
+    continue
 #endif
 
-# ifdef OPENSSL_BIO_H
-#  ifdef ZLIB
-const BIO_METHOD *BIO_f_zlib(void);
-#  endif
-# endif
-
+#ifdef OPENSSL_BIO_H
+#ifdef ZLIB
+    const BIO_METHOD* BIO_f_zlib(void);
+#endif
+#endif
 
-#  ifdef  __cplusplus
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/comperr.h b/CAPI/cpp/grpc/include/openssl/comperr.h
index 01dd3e6..9b5e58a 100644
--- a/CAPI/cpp/grpc/include/openssl/comperr.h
+++ b/CAPI/cpp/grpc/include/openssl/comperr.h
@@ -9,23 +9,21 @@
  */
 
 #ifndef OPENSSL_COMPERR_H
-# define OPENSSL_COMPERR_H
-# pragma once
+#define OPENSSL_COMPERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_COMP
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_COMP
 
 /*
  * COMP reason codes.
  */
-#  define COMP_R_ZLIB_DEFLATE_ERROR                        99
-#  define COMP_R_ZLIB_INFLATE_ERROR                        100
-#  define COMP_R_ZLIB_NOT_SUPPORTED                        101
+#define COMP_R_ZLIB_DEFLATE_ERROR 99
+#define COMP_R_ZLIB_INFLATE_ERROR 100
+#define COMP_R_ZLIB_NOT_SUPPORTED 101
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/conf.h b/CAPI/cpp/grpc/include/openssl/conf.h
index 07793f1..f15f59a 100644
--- a/CAPI/cpp/grpc/include/openssl/conf.h
+++ b/CAPI/cpp/grpc/include/openssl/conf.h
@@ -10,67 +10,67 @@
  * https://www.openssl.org/source/license.html
  */
 
+#ifndef OPENSSL_CONF_H
+#define OPENSSL_CONF_H
+#pragma once
 
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CONF_H
+#endif
 
-#ifndef  OPENSSL_CONF_H
-# define OPENSSL_CONF_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_CONF_H
-# endif
-
-# include <openssl/bio.h>
-# include <openssl/lhash.h>
-# include <openssl/safestack.h>
-# include <openssl/e_os2.h>
-# include <openssl/types.h>
-# include <openssl/conferr.h>
+#include <openssl/bio.h>
+#include <openssl/lhash.h>
+#include <openssl/safestack.h>
+#include <openssl/e_os2.h>
+#include <openssl/types.h>
+#include <openssl/conferr.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-typedef struct {
-    char *section;
-    char *name;
-    char *value;
-} CONF_VALUE;
+    typedef struct
+    {
+        char* section;
+        char* name;
+        char* value;
+    } CONF_VALUE;
 
-SKM_DEFINE_STACK_OF_INTERNAL(CONF_VALUE, CONF_VALUE, CONF_VALUE)
+    SKM_DEFINE_STACK_OF_INTERNAL(CONF_VALUE, CONF_VALUE, CONF_VALUE)
 #define sk_CONF_VALUE_num(sk) OPENSSL_sk_num(ossl_check_const_CONF_VALUE_sk_type(sk))
-#define sk_CONF_VALUE_value(sk, idx) ((CONF_VALUE *)OPENSSL_sk_value(ossl_check_const_CONF_VALUE_sk_type(sk), (idx)))
-#define sk_CONF_VALUE_new(cmp) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new(ossl_check_CONF_VALUE_compfunc_type(cmp)))
-#define sk_CONF_VALUE_new_null() ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new_null())
-#define sk_CONF_VALUE_new_reserve(cmp, n) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_new_reserve(ossl_check_CONF_VALUE_compfunc_type(cmp), (n)))
+#define sk_CONF_VALUE_value(sk, idx) ((CONF_VALUE*)OPENSSL_sk_value(ossl_check_const_CONF_VALUE_sk_type(sk), (idx)))
+#define sk_CONF_VALUE_new(cmp) ((STACK_OF(CONF_VALUE)*)OPENSSL_sk_new(ossl_check_CONF_VALUE_compfunc_type(cmp)))
+#define sk_CONF_VALUE_new_null() ((STACK_OF(CONF_VALUE)*)OPENSSL_sk_new_null())
+#define sk_CONF_VALUE_new_reserve(cmp, n) ((STACK_OF(CONF_VALUE)*)OPENSSL_sk_new_reserve(ossl_check_CONF_VALUE_compfunc_type(cmp), (n)))
 #define sk_CONF_VALUE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CONF_VALUE_sk_type(sk), (n))
 #define sk_CONF_VALUE_free(sk) OPENSSL_sk_free(ossl_check_CONF_VALUE_sk_type(sk))
 #define sk_CONF_VALUE_zero(sk) OPENSSL_sk_zero(ossl_check_CONF_VALUE_sk_type(sk))
-#define sk_CONF_VALUE_delete(sk, i) ((CONF_VALUE *)OPENSSL_sk_delete(ossl_check_CONF_VALUE_sk_type(sk), (i)))
-#define sk_CONF_VALUE_delete_ptr(sk, ptr) ((CONF_VALUE *)OPENSSL_sk_delete_ptr(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr)))
+#define sk_CONF_VALUE_delete(sk, i) ((CONF_VALUE*)OPENSSL_sk_delete(ossl_check_CONF_VALUE_sk_type(sk), (i)))
+#define sk_CONF_VALUE_delete_ptr(sk, ptr) ((CONF_VALUE*)OPENSSL_sk_delete_ptr(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr)))
 #define sk_CONF_VALUE_push(sk, ptr) OPENSSL_sk_push(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
 #define sk_CONF_VALUE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
-#define sk_CONF_VALUE_pop(sk) ((CONF_VALUE *)OPENSSL_sk_pop(ossl_check_CONF_VALUE_sk_type(sk)))
-#define sk_CONF_VALUE_shift(sk) ((CONF_VALUE *)OPENSSL_sk_shift(ossl_check_CONF_VALUE_sk_type(sk)))
-#define sk_CONF_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CONF_VALUE_sk_type(sk),ossl_check_CONF_VALUE_freefunc_type(freefunc))
+#define sk_CONF_VALUE_pop(sk) ((CONF_VALUE*)OPENSSL_sk_pop(ossl_check_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_shift(sk) ((CONF_VALUE*)OPENSSL_sk_shift(ossl_check_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_freefunc_type(freefunc))
 #define sk_CONF_VALUE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr), (idx))
-#define sk_CONF_VALUE_set(sk, idx, ptr) ((CONF_VALUE *)OPENSSL_sk_set(ossl_check_CONF_VALUE_sk_type(sk), (idx), ossl_check_CONF_VALUE_type(ptr)))
+#define sk_CONF_VALUE_set(sk, idx, ptr) ((CONF_VALUE*)OPENSSL_sk_set(ossl_check_CONF_VALUE_sk_type(sk), (idx), ossl_check_CONF_VALUE_type(ptr)))
 #define sk_CONF_VALUE_find(sk, ptr) OPENSSL_sk_find(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
 #define sk_CONF_VALUE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr))
 #define sk_CONF_VALUE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_type(ptr), pnum)
 #define sk_CONF_VALUE_sort(sk) OPENSSL_sk_sort(ossl_check_CONF_VALUE_sk_type(sk))
 #define sk_CONF_VALUE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CONF_VALUE_sk_type(sk))
-#define sk_CONF_VALUE_dup(sk) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_dup(ossl_check_const_CONF_VALUE_sk_type(sk)))
-#define sk_CONF_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CONF_VALUE) *)OPENSSL_sk_deep_copy(ossl_check_const_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_copyfunc_type(copyfunc), ossl_check_CONF_VALUE_freefunc_type(freefunc)))
+#define sk_CONF_VALUE_dup(sk) ((STACK_OF(CONF_VALUE)*)OPENSSL_sk_dup(ossl_check_const_CONF_VALUE_sk_type(sk)))
+#define sk_CONF_VALUE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CONF_VALUE)*)OPENSSL_sk_deep_copy(ossl_check_const_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_copyfunc_type(copyfunc), ossl_check_CONF_VALUE_freefunc_type(freefunc)))
 #define sk_CONF_VALUE_set_cmp_func(sk, cmp) ((sk_CONF_VALUE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CONF_VALUE_sk_type(sk), ossl_check_CONF_VALUE_compfunc_type(cmp)))
-DEFINE_LHASH_OF_INTERNAL(CONF_VALUE);
-#define lh_CONF_VALUE_new(hfn, cmp) ((LHASH_OF(CONF_VALUE) *)OPENSSL_LH_new(ossl_check_CONF_VALUE_lh_hashfunc_type(hfn), ossl_check_CONF_VALUE_lh_compfunc_type(cmp)))
+    DEFINE_LHASH_OF_INTERNAL(CONF_VALUE);
+#define lh_CONF_VALUE_new(hfn, cmp) ((LHASH_OF(CONF_VALUE)*)OPENSSL_LH_new(ossl_check_CONF_VALUE_lh_hashfunc_type(hfn), ossl_check_CONF_VALUE_lh_compfunc_type(cmp)))
 #define lh_CONF_VALUE_free(lh) OPENSSL_LH_free(ossl_check_CONF_VALUE_lh_type(lh))
 #define lh_CONF_VALUE_flush(lh) OPENSSL_LH_flush(ossl_check_CONF_VALUE_lh_type(lh))
-#define lh_CONF_VALUE_insert(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_insert(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_plain_type(ptr)))
-#define lh_CONF_VALUE_delete(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_delete(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
-#define lh_CONF_VALUE_retrieve(lh, ptr) ((CONF_VALUE *)OPENSSL_LH_retrieve(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_insert(lh, ptr) ((CONF_VALUE*)OPENSSL_LH_insert(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_delete(lh, ptr) ((CONF_VALUE*)OPENSSL_LH_delete(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
+#define lh_CONF_VALUE_retrieve(lh, ptr) ((CONF_VALUE*)OPENSSL_LH_retrieve(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_const_CONF_VALUE_lh_plain_type(ptr)))
 #define lh_CONF_VALUE_error(lh) OPENSSL_LH_error(ossl_check_CONF_VALUE_lh_type(lh))
 #define lh_CONF_VALUE_num_items(lh) OPENSSL_LH_num_items(ossl_check_CONF_VALUE_lh_type(lh))
 #define lh_CONF_VALUE_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_CONF_VALUE_lh_type(lh), out)
@@ -80,132 +80,118 @@ DEFINE_LHASH_OF_INTERNAL(CONF_VALUE);
 #define lh_CONF_VALUE_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_CONF_VALUE_lh_type(lh), dl)
 #define lh_CONF_VALUE_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_CONF_VALUE_lh_type(lh), ossl_check_CONF_VALUE_lh_doallfunc_type(dfn))
 
+    struct conf_st;
+    struct conf_method_st;
+    typedef struct conf_method_st CONF_METHOD;
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#include <openssl/conftypes.h>
+#endif
+
+    /* Module definitions */
+    typedef struct conf_imodule_st CONF_IMODULE;
+    typedef struct conf_module_st CONF_MODULE;
+
+    STACK_OF(CONF_MODULE);
+    STACK_OF(CONF_IMODULE);
+
+    /* DSO module function typedefs */
+    typedef int conf_init_func(CONF_IMODULE* md, const CONF* cnf);
+    typedef void conf_finish_func(CONF_IMODULE* md);
 
-struct conf_st;
-struct conf_method_st;
-typedef struct conf_method_st CONF_METHOD;
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  include <openssl/conftypes.h>
-# endif
-
-/* Module definitions */
-typedef struct conf_imodule_st CONF_IMODULE;
-typedef struct conf_module_st CONF_MODULE;
-
-STACK_OF(CONF_MODULE);
-STACK_OF(CONF_IMODULE);
-
-/* DSO module function typedefs */
-typedef int conf_init_func (CONF_IMODULE *md, const CONF *cnf);
-typedef void conf_finish_func (CONF_IMODULE *md);
-
-# define CONF_MFLAGS_IGNORE_ERRORS       0x1
-# define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2
-# define CONF_MFLAGS_SILENT              0x4
-# define CONF_MFLAGS_NO_DSO              0x8
-# define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10
-# define CONF_MFLAGS_DEFAULT_SECTION     0x20
-
-int CONF_set_default_method(CONF_METHOD *meth);
-void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash);
-LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file,
-                                long *eline);
-# ifndef OPENSSL_NO_STDIO
-LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp,
-                                   long *eline);
-# endif
-LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp,
-                                    long *eline);
-STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf,
-                                       const char *section);
-char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group,
-                      const char *name);
-long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group,
-                     const char *name);
-void CONF_free(LHASH_OF(CONF_VALUE) *conf);
+#define CONF_MFLAGS_IGNORE_ERRORS 0x1
+#define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2
+#define CONF_MFLAGS_SILENT 0x4
+#define CONF_MFLAGS_NO_DSO 0x8
+#define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10
+#define CONF_MFLAGS_DEFAULT_SECTION 0x20
+
+    int CONF_set_default_method(CONF_METHOD* meth);
+    void CONF_set_nconf(CONF* conf, LHASH_OF(CONF_VALUE) * hash);
+    LHASH_OF(CONF_VALUE) * CONF_load(LHASH_OF(CONF_VALUE) * conf, const char* file, long* eline);
+#ifndef OPENSSL_NO_STDIO
+    LHASH_OF(CONF_VALUE) * CONF_load_fp(LHASH_OF(CONF_VALUE) * conf, FILE* fp, long* eline);
+#endif
+    LHASH_OF(CONF_VALUE) * CONF_load_bio(LHASH_OF(CONF_VALUE) * conf, BIO* bp, long* eline);
+    STACK_OF(CONF_VALUE) * CONF_get_section(LHASH_OF(CONF_VALUE) * conf, const char* section);
+    char* CONF_get_string(LHASH_OF(CONF_VALUE) * conf, const char* group, const char* name);
+    long CONF_get_number(LHASH_OF(CONF_VALUE) * conf, const char* group, const char* name);
+    void CONF_free(LHASH_OF(CONF_VALUE) * conf);
 #ifndef OPENSSL_NO_STDIO
-int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out);
+    int CONF_dump_fp(LHASH_OF(CONF_VALUE) * conf, FILE* out);
 #endif
-int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out);
+    int CONF_dump_bio(LHASH_OF(CONF_VALUE) * conf, BIO* out);
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 void OPENSSL_config(const char *config_name);
+    OSSL_DEPRECATEDIN_1_1_0 void OPENSSL_config(const char* config_name);
 #endif
 
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-# define OPENSSL_no_config() \
+#define OPENSSL_no_config() \
     OPENSSL_init_crypto(OPENSSL_INIT_NO_LOAD_CONFIG, NULL)
 #endif
 
-/*
- * New conf code.  The semantics are different from the functions above. If
- * that wasn't the case, the above functions would have been replaced
- */
+    /*
+     * New conf code.  The semantics are different from the functions above. If
+     * that wasn't the case, the above functions would have been replaced
+     */
 
-CONF *NCONF_new_ex(OSSL_LIB_CTX *libctx, CONF_METHOD *meth);
-OSSL_LIB_CTX *NCONF_get0_libctx(const CONF *conf);
-CONF *NCONF_new(CONF_METHOD *meth);
-CONF_METHOD *NCONF_default(void);
+    CONF* NCONF_new_ex(OSSL_LIB_CTX* libctx, CONF_METHOD* meth);
+    OSSL_LIB_CTX* NCONF_get0_libctx(const CONF* conf);
+    CONF* NCONF_new(CONF_METHOD* meth);
+    CONF_METHOD* NCONF_default(void);
 #ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 CONF_METHOD *NCONF_WIN32(void);
+    OSSL_DEPRECATEDIN_3_0 CONF_METHOD* NCONF_WIN32(void);
 #endif
-void NCONF_free(CONF *conf);
-void NCONF_free_data(CONF *conf);
-
-int NCONF_load(CONF *conf, const char *file, long *eline);
-# ifndef OPENSSL_NO_STDIO
-int NCONF_load_fp(CONF *conf, FILE *fp, long *eline);
-# endif
-int NCONF_load_bio(CONF *conf, BIO *bp, long *eline);
-STACK_OF(OPENSSL_CSTRING) *NCONF_get_section_names(const CONF *conf);
-STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,
-                                        const char *section);
-char *NCONF_get_string(const CONF *conf, const char *group, const char *name);
-int NCONF_get_number_e(const CONF *conf, const char *group, const char *name,
-                       long *result);
+    void NCONF_free(CONF* conf);
+    void NCONF_free_data(CONF* conf);
+
+    int NCONF_load(CONF* conf, const char* file, long* eline);
+#ifndef OPENSSL_NO_STDIO
+    int NCONF_load_fp(CONF* conf, FILE* fp, long* eline);
+#endif
+    int NCONF_load_bio(CONF* conf, BIO* bp, long* eline);
+    STACK_OF(OPENSSL_CSTRING) * NCONF_get_section_names(const CONF* conf);
+    STACK_OF(CONF_VALUE) * NCONF_get_section(const CONF* conf, const char* section);
+    char* NCONF_get_string(const CONF* conf, const char* group, const char* name);
+    int NCONF_get_number_e(const CONF* conf, const char* group, const char* name, long* result);
 #ifndef OPENSSL_NO_STDIO
-int NCONF_dump_fp(const CONF *conf, FILE *out);
+    int NCONF_dump_fp(const CONF* conf, FILE* out);
 #endif
-int NCONF_dump_bio(const CONF *conf, BIO *out);
+    int NCONF_dump_bio(const CONF* conf, BIO* out);
 
-#define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r)
+#define NCONF_get_number(c, g, n, r) NCONF_get_number_e(c, g, n, r)
 
-/* Module functions */
+    /* Module functions */
 
-int CONF_modules_load(const CONF *cnf, const char *appname,
-                      unsigned long flags);
-int CONF_modules_load_file_ex(OSSL_LIB_CTX *libctx, const char *filename,
-                              const char *appname, unsigned long flags);
-int CONF_modules_load_file(const char *filename, const char *appname,
-                           unsigned long flags);
-void CONF_modules_unload(int all);
-void CONF_modules_finish(void);
+    int CONF_modules_load(const CONF* cnf, const char* appname, unsigned long flags);
+    int CONF_modules_load_file_ex(OSSL_LIB_CTX* libctx, const char* filename, const char* appname, unsigned long flags);
+    int CONF_modules_load_file(const char* filename, const char* appname, unsigned long flags);
+    void CONF_modules_unload(int all);
+    void CONF_modules_finish(void);
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-# define CONF_modules_free() while(0) continue
+#define CONF_modules_free() \
+    while (0)               \
+    continue
 #endif
-int CONF_module_add(const char *name, conf_init_func *ifunc,
-                    conf_finish_func *ffunc);
+    int CONF_module_add(const char* name, conf_init_func* ifunc, conf_finish_func* ffunc);
 
-const char *CONF_imodule_get_name(const CONF_IMODULE *md);
-const char *CONF_imodule_get_value(const CONF_IMODULE *md);
-void *CONF_imodule_get_usr_data(const CONF_IMODULE *md);
-void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data);
-CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md);
-unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md);
-void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags);
-void *CONF_module_get_usr_data(CONF_MODULE *pmod);
-void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data);
+    const char* CONF_imodule_get_name(const CONF_IMODULE* md);
+    const char* CONF_imodule_get_value(const CONF_IMODULE* md);
+    void* CONF_imodule_get_usr_data(const CONF_IMODULE* md);
+    void CONF_imodule_set_usr_data(CONF_IMODULE* md, void* usr_data);
+    CONF_MODULE* CONF_imodule_get_module(const CONF_IMODULE* md);
+    unsigned long CONF_imodule_get_flags(const CONF_IMODULE* md);
+    void CONF_imodule_set_flags(CONF_IMODULE* md, unsigned long flags);
+    void* CONF_module_get_usr_data(CONF_MODULE* pmod);
+    void CONF_module_set_usr_data(CONF_MODULE* pmod, void* usr_data);
 
-char *CONF_get1_default_config_file(void);
+    char* CONF_get1_default_config_file(void);
 
-int CONF_parse_list(const char *list, int sep, int nospc,
-                    int (*list_cb) (const char *elem, int len, void *usr),
-                    void *arg);
+    int CONF_parse_list(const char* list, int sep, int nospc, int (*list_cb)(const char* elem, int len, void* usr), void* arg);
 
-void OPENSSL_load_builtin_modules(void);
+    void OPENSSL_load_builtin_modules(void);
 
-
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/conf_api.h b/CAPI/cpp/grpc/include/openssl/conf_api.h
index ed67d57..7ff695d 100644
--- a/CAPI/cpp/grpc/include/openssl/conf_api.h
+++ b/CAPI/cpp/grpc/include/openssl/conf_api.h
@@ -7,40 +7,38 @@
  * https://www.openssl.org/source/license.html
  */
 
-#ifndef  OPENSSL_CONF_API_H
-# define OPENSSL_CONF_API_H
-# pragma once
+#ifndef OPENSSL_CONF_API_H
+#define OPENSSL_CONF_API_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_CONF_API_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CONF_API_H
+#endif
 
-# include <openssl/lhash.h>
-# include <openssl/conf.h>
+#include <openssl/lhash.h>
+#include <openssl/conf.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-/* Up until OpenSSL 0.9.5a, this was new_section */
-CONF_VALUE *_CONF_new_section(CONF *conf, const char *section);
-/* Up until OpenSSL 0.9.5a, this was get_section */
-CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section);
-/* Up until OpenSSL 0.9.5a, this was CONF_get_section */
-STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf,
-                                               const char *section);
+    /* Up until OpenSSL 0.9.5a, this was new_section */
+    CONF_VALUE* _CONF_new_section(CONF* conf, const char* section);
+    /* Up until OpenSSL 0.9.5a, this was get_section */
+    CONF_VALUE* _CONF_get_section(const CONF* conf, const char* section);
+    /* Up until OpenSSL 0.9.5a, this was CONF_get_section */
+    STACK_OF(CONF_VALUE) * _CONF_get_section_values(const CONF* conf, const char* section);
 
-int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value);
-char *_CONF_get_string(const CONF *conf, const char *section,
-                       const char *name);
-long _CONF_get_number(const CONF *conf, const char *section,
-                      const char *name);
+    int _CONF_add_string(CONF* conf, CONF_VALUE* section, CONF_VALUE* value);
+    char* _CONF_get_string(const CONF* conf, const char* section, const char* name);
+    long _CONF_get_number(const CONF* conf, const char* section, const char* name);
 
-int _CONF_new_data(CONF *conf);
-void _CONF_free_data(CONF *conf);
+    int _CONF_new_data(CONF* conf);
+    void _CONF_free_data(CONF* conf);
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/conferr.h b/CAPI/cpp/grpc/include/openssl/conferr.h
index 496e2e1..11a8f9e 100644
--- a/CAPI/cpp/grpc/include/openssl/conferr.h
+++ b/CAPI/cpp/grpc/include/openssl/conferr.h
@@ -9,43 +9,41 @@
  */
 
 #ifndef OPENSSL_CONFERR_H
-# define OPENSSL_CONFERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_CONFERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * CONF reason codes.
  */
-# define CONF_R_ERROR_LOADING_DSO                         110
-# define CONF_R_INVALID_PRAGMA                            122
-# define CONF_R_LIST_CANNOT_BE_NULL                       115
-# define CONF_R_MANDATORY_BRACES_IN_VARIABLE_EXPANSION    123
-# define CONF_R_MISSING_CLOSE_SQUARE_BRACKET              100
-# define CONF_R_MISSING_EQUAL_SIGN                        101
-# define CONF_R_MISSING_INIT_FUNCTION                     112
-# define CONF_R_MODULE_INITIALIZATION_ERROR               109
-# define CONF_R_NO_CLOSE_BRACE                            102
-# define CONF_R_NO_CONF                                   105
-# define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE           106
-# define CONF_R_NO_SECTION                                107
-# define CONF_R_NO_SUCH_FILE                              114
-# define CONF_R_NO_VALUE                                  108
-# define CONF_R_NUMBER_TOO_LARGE                          121
-# define CONF_R_OPENSSL_CONF_REFERENCES_MISSING_SECTION   124
-# define CONF_R_RECURSIVE_DIRECTORY_INCLUDE               111
-# define CONF_R_RELATIVE_PATH                             125
-# define CONF_R_SSL_COMMAND_SECTION_EMPTY                 117
-# define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND             118
-# define CONF_R_SSL_SECTION_EMPTY                         119
-# define CONF_R_SSL_SECTION_NOT_FOUND                     120
-# define CONF_R_UNABLE_TO_CREATE_NEW_SECTION              103
-# define CONF_R_UNKNOWN_MODULE_NAME                       113
-# define CONF_R_VARIABLE_EXPANSION_TOO_LONG               116
-# define CONF_R_VARIABLE_HAS_NO_VALUE                     104
+#define CONF_R_ERROR_LOADING_DSO 110
+#define CONF_R_INVALID_PRAGMA 122
+#define CONF_R_LIST_CANNOT_BE_NULL 115
+#define CONF_R_MANDATORY_BRACES_IN_VARIABLE_EXPANSION 123
+#define CONF_R_MISSING_CLOSE_SQUARE_BRACKET 100
+#define CONF_R_MISSING_EQUAL_SIGN 101
+#define CONF_R_MISSING_INIT_FUNCTION 112
+#define CONF_R_MODULE_INITIALIZATION_ERROR 109
+#define CONF_R_NO_CLOSE_BRACE 102
+#define CONF_R_NO_CONF 105
+#define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE 106
+#define CONF_R_NO_SECTION 107
+#define CONF_R_NO_SUCH_FILE 114
+#define CONF_R_NO_VALUE 108
+#define CONF_R_NUMBER_TOO_LARGE 121
+#define CONF_R_OPENSSL_CONF_REFERENCES_MISSING_SECTION 124
+#define CONF_R_RECURSIVE_DIRECTORY_INCLUDE 111
+#define CONF_R_RELATIVE_PATH 125
+#define CONF_R_SSL_COMMAND_SECTION_EMPTY 117
+#define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND 118
+#define CONF_R_SSL_SECTION_EMPTY 119
+#define CONF_R_SSL_SECTION_NOT_FOUND 120
+#define CONF_R_UNABLE_TO_CREATE_NEW_SECTION 103
+#define CONF_R_UNKNOWN_MODULE_NAME 113
+#define CONF_R_VARIABLE_EXPANSION_TOO_LONG 116
+#define CONF_R_VARIABLE_HAS_NO_VALUE 104
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/configuration.h b/CAPI/cpp/grpc/include/openssl/configuration.h
index 00d8937..05cf00a 100644
--- a/CAPI/cpp/grpc/include/openssl/configuration.h
+++ b/CAPI/cpp/grpc/include/openssl/configuration.h
@@ -12,135 +12,135 @@
  */
 
 #ifndef OPENSSL_CONFIGURATION_H
-# define OPENSSL_CONFIGURATION_H
-# pragma once
+#define OPENSSL_CONFIGURATION_H
+#pragma once
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# ifdef OPENSSL_ALGORITHM_DEFINES
-#  error OPENSSL_ALGORITHM_DEFINES no longer supported
-# endif
+#ifdef OPENSSL_ALGORITHM_DEFINES
+#error OPENSSL_ALGORITHM_DEFINES no longer supported
+#endif
 
-/*
- * OpenSSL was configured with the following options:
- */
-
-# ifndef OPENSSL_SYS_WIN64A
-#  define OPENSSL_SYS_WIN64A 1
-# endif
-# define OPENSSL_CONFIGURED_API 30000
-# ifndef OPENSSL_RAND_SEED_OS
-#  define OPENSSL_RAND_SEED_OS
-# endif
-# ifndef OPENSSL_THREADS
-#  define OPENSSL_THREADS
-# endif
-# ifndef OPENSSL_NO_ACVP_TESTS
-#  define OPENSSL_NO_ACVP_TESTS
-# endif
-# ifndef OPENSSL_NO_AFALGENG
-#  define OPENSSL_NO_AFALGENG
-# endif
-# ifndef OPENSSL_NO_ASAN
-#  define OPENSSL_NO_ASAN
-# endif
-# ifndef OPENSSL_NO_CRYPTO_MDEBUG
-#  define OPENSSL_NO_CRYPTO_MDEBUG
-# endif
-# ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
-#  define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
-# endif
-# ifndef OPENSSL_NO_DEVCRYPTOENG
-#  define OPENSSL_NO_DEVCRYPTOENG
-# endif
-# ifndef OPENSSL_NO_DSO
-#  define OPENSSL_NO_DSO
-# endif
-# ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
-#  define OPENSSL_NO_EC_NISTP_64_GCC_128
-# endif
-# ifndef OPENSSL_NO_EGD
-#  define OPENSSL_NO_EGD
-# endif
-# ifndef OPENSSL_NO_EXTERNAL_TESTS
-#  define OPENSSL_NO_EXTERNAL_TESTS
-# endif
-# ifndef OPENSSL_NO_FIPS_SECURITYCHECKS
-#  define OPENSSL_NO_FIPS_SECURITYCHECKS
-# endif
-# ifndef OPENSSL_NO_FUZZ_AFL
-#  define OPENSSL_NO_FUZZ_AFL
-# endif
-# ifndef OPENSSL_NO_FUZZ_LIBFUZZER
-#  define OPENSSL_NO_FUZZ_LIBFUZZER
-# endif
-# ifndef OPENSSL_NO_KTLS
-#  define OPENSSL_NO_KTLS
-# endif
-# ifndef OPENSSL_NO_LOADERENG
-#  define OPENSSL_NO_LOADERENG
-# endif
-# ifndef OPENSSL_NO_MD2
-#  define OPENSSL_NO_MD2
-# endif
-# ifndef OPENSSL_NO_MSAN
-#  define OPENSSL_NO_MSAN
-# endif
-# ifndef OPENSSL_NO_RC5
-#  define OPENSSL_NO_RC5
-# endif
-# ifndef OPENSSL_NO_SCTP
-#  define OPENSSL_NO_SCTP
-# endif
-# ifndef OPENSSL_NO_SSL3
-#  define OPENSSL_NO_SSL3
-# endif
-# ifndef OPENSSL_NO_SSL3_METHOD
-#  define OPENSSL_NO_SSL3_METHOD
-# endif
-# ifndef OPENSSL_NO_TESTS
-#  define OPENSSL_NO_TESTS
-# endif
-# ifndef OPENSSL_NO_TRACE
-#  define OPENSSL_NO_TRACE
-# endif
-# ifndef OPENSSL_NO_UBSAN
-#  define OPENSSL_NO_UBSAN
-# endif
-# ifndef OPENSSL_NO_UNIT_TEST
-#  define OPENSSL_NO_UNIT_TEST
-# endif
-# ifndef OPENSSL_NO_UPLINK
-#  define OPENSSL_NO_UPLINK
-# endif
-# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
-#  define OPENSSL_NO_WEAK_SSL_CIPHERS
-# endif
-# ifndef OPENSSL_NO_DYNAMIC_ENGINE
-#  define OPENSSL_NO_DYNAMIC_ENGINE
-# endif
+    /*
+     * OpenSSL was configured with the following options:
+     */
 
+#ifndef OPENSSL_SYS_WIN64A
+#define OPENSSL_SYS_WIN64A 1
+#endif
+#define OPENSSL_CONFIGURED_API 30000
+#ifndef OPENSSL_RAND_SEED_OS
+#define OPENSSL_RAND_SEED_OS
+#endif
+#ifndef OPENSSL_THREADS
+#define OPENSSL_THREADS
+#endif
+#ifndef OPENSSL_NO_ACVP_TESTS
+#define OPENSSL_NO_ACVP_TESTS
+#endif
+#ifndef OPENSSL_NO_AFALGENG
+#define OPENSSL_NO_AFALGENG
+#endif
+#ifndef OPENSSL_NO_ASAN
+#define OPENSSL_NO_ASAN
+#endif
+#ifndef OPENSSL_NO_CRYPTO_MDEBUG
+#define OPENSSL_NO_CRYPTO_MDEBUG
+#endif
+#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
+#define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE
+#endif
+#ifndef OPENSSL_NO_DEVCRYPTOENG
+#define OPENSSL_NO_DEVCRYPTOENG
+#endif
+#ifndef OPENSSL_NO_DSO
+#define OPENSSL_NO_DSO
+#endif
+#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
+#define OPENSSL_NO_EC_NISTP_64_GCC_128
+#endif
+#ifndef OPENSSL_NO_EGD
+#define OPENSSL_NO_EGD
+#endif
+#ifndef OPENSSL_NO_EXTERNAL_TESTS
+#define OPENSSL_NO_EXTERNAL_TESTS
+#endif
+#ifndef OPENSSL_NO_FIPS_SECURITYCHECKS
+#define OPENSSL_NO_FIPS_SECURITYCHECKS
+#endif
+#ifndef OPENSSL_NO_FUZZ_AFL
+#define OPENSSL_NO_FUZZ_AFL
+#endif
+#ifndef OPENSSL_NO_FUZZ_LIBFUZZER
+#define OPENSSL_NO_FUZZ_LIBFUZZER
+#endif
+#ifndef OPENSSL_NO_KTLS
+#define OPENSSL_NO_KTLS
+#endif
+#ifndef OPENSSL_NO_LOADERENG
+#define OPENSSL_NO_LOADERENG
+#endif
+#ifndef OPENSSL_NO_MD2
+#define OPENSSL_NO_MD2
+#endif
+#ifndef OPENSSL_NO_MSAN
+#define OPENSSL_NO_MSAN
+#endif
+#ifndef OPENSSL_NO_RC5
+#define OPENSSL_NO_RC5
+#endif
+#ifndef OPENSSL_NO_SCTP
+#define OPENSSL_NO_SCTP
+#endif
+#ifndef OPENSSL_NO_SSL3
+#define OPENSSL_NO_SSL3
+#endif
+#ifndef OPENSSL_NO_SSL3_METHOD
+#define OPENSSL_NO_SSL3_METHOD
+#endif
+#ifndef OPENSSL_NO_TESTS
+#define OPENSSL_NO_TESTS
+#endif
+#ifndef OPENSSL_NO_TRACE
+#define OPENSSL_NO_TRACE
+#endif
+#ifndef OPENSSL_NO_UBSAN
+#define OPENSSL_NO_UBSAN
+#endif
+#ifndef OPENSSL_NO_UNIT_TEST
+#define OPENSSL_NO_UNIT_TEST
+#endif
+#ifndef OPENSSL_NO_UPLINK
+#define OPENSSL_NO_UPLINK
+#endif
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#define OPENSSL_NO_WEAK_SSL_CIPHERS
+#endif
+#ifndef OPENSSL_NO_DYNAMIC_ENGINE
+#define OPENSSL_NO_DYNAMIC_ENGINE
+#endif
 
 /* Generate 80386 code? */
-# undef I386_ONLY
+#undef I386_ONLY
 
 /*
  * The following are cipher-specific, but are part of the public API.
  */
-# if !defined(OPENSSL_SYS_UEFI)
-#  undef BN_LLONG
+#if !defined(OPENSSL_SYS_UEFI)
+#undef BN_LLONG
 /* Only one for the following should be defined */
-#  undef SIXTY_FOUR_BIT_LONG
-#  define SIXTY_FOUR_BIT
-#  undef THIRTY_TWO_BIT
-# endif
+#undef SIXTY_FOUR_BIT_LONG
+#define SIXTY_FOUR_BIT
+#undef THIRTY_TWO_BIT
+#endif
 
-# define RC4_INT unsigned int
+#define RC4_INT unsigned int
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 
-#endif                          /* OPENSSL_CONFIGURATION_H */
+#endif /* OPENSSL_CONFIGURATION_H */
diff --git a/CAPI/cpp/grpc/include/openssl/conftypes.h b/CAPI/cpp/grpc/include/openssl/conftypes.h
index 17cefaa..d51abb0 100644
--- a/CAPI/cpp/grpc/include/openssl/conftypes.h
+++ b/CAPI/cpp/grpc/include/openssl/conftypes.h
@@ -7,38 +7,40 @@
  * https://www.openssl.org/source/license.html
  */
 
-#ifndef  OPENSSL_CONFTYPES_H
-# define OPENSSL_CONFTYPES_H
-# pragma once
+#ifndef OPENSSL_CONFTYPES_H
+#define OPENSSL_CONFTYPES_H
+#pragma once
 
-#ifndef  OPENSSL_CONF_H
-# include <openssl/conf.h>
+#ifndef OPENSSL_CONF_H
+#include <openssl/conf.h>
 #endif
 
 /*
  * The contents of this file are deprecated and will be made opaque
  */
-struct conf_method_st {
-    const char *name;
-    CONF *(*create) (CONF_METHOD *meth);
-    int (*init) (CONF *conf);
-    int (*destroy) (CONF *conf);
-    int (*destroy_data) (CONF *conf);
-    int (*load_bio) (CONF *conf, BIO *bp, long *eline);
-    int (*dump) (const CONF *conf, BIO *bp);
-    int (*is_number) (const CONF *conf, char c);
-    int (*to_int) (const CONF *conf, char c);
-    int (*load) (CONF *conf, const char *name, long *eline);
+struct conf_method_st
+{
+    const char* name;
+    CONF* (*create)(CONF_METHOD* meth);
+    int (*init)(CONF* conf);
+    int (*destroy)(CONF* conf);
+    int (*destroy_data)(CONF* conf);
+    int (*load_bio)(CONF* conf, BIO* bp, long* eline);
+    int (*dump)(const CONF* conf, BIO* bp);
+    int (*is_number)(const CONF* conf, char c);
+    int (*to_int)(const CONF* conf, char c);
+    int (*load)(CONF* conf, const char* name, long* eline);
 };
 
-struct conf_st {
-    CONF_METHOD *meth;
-    void *meth_data;
-    LHASH_OF(CONF_VALUE) *data;
+struct conf_st
+{
+    CONF_METHOD* meth;
+    void* meth_data;
+    LHASH_OF(CONF_VALUE) * data;
     int flag_dollarid;
     int flag_abspath;
-    char *includedir;
-    OSSL_LIB_CTX *libctx;
+    char* includedir;
+    OSSL_LIB_CTX* libctx;
 };
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/core.h b/CAPI/cpp/grpc/include/openssl/core.h
index 9683ac7..24e5142 100644
--- a/CAPI/cpp/grpc/include/openssl/core.h
+++ b/CAPI/cpp/grpc/include/openssl/core.h
@@ -8,84 +8,89 @@
  */
 
 #ifndef OPENSSL_CORE_H
-# define OPENSSL_CORE_H
-# pragma once
+#define OPENSSL_CORE_H
+#pragma once
 
-# include <stddef.h>
-# include <openssl/types.h>
+#include <stddef.h>
+#include <openssl/types.h>
 
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-/*-
- * Base types
- * ----------
- *
- * These are the types that the OpenSSL core and providers have in common
- * to communicate data between them.
- */
-
-/* Opaque handles to be used with core upcall functions from providers */
-typedef struct ossl_core_handle_st OSSL_CORE_HANDLE;
-typedef struct openssl_core_ctx_st OPENSSL_CORE_CTX;
-typedef struct ossl_core_bio_st OSSL_CORE_BIO;
-
-/*
- * Dispatch table element.  function_id numbers and the functions are defined
- * in core_dispatch.h, see macros with 'OSSL_CORE_MAKE_FUNC' in their names.
- *
- * An array of these is always terminated by function_id == 0
- */
-struct ossl_dispatch_st {
-    int function_id;
-    void (*function)(void);
-};
-
-/*
- * Other items, essentially an int<->pointer map element.
- *
- * We make this type distinct from OSSL_DISPATCH to ensure that dispatch
- * tables remain tables with function pointers only.
- *
- * This is used whenever we need to pass things like a table of error reason
- * codes <-> reason string maps, ...
- *
- * Usage determines which field works as key if any, rather than field order.
- *
- * An array of these is always terminated by id == 0 && ptr == NULL
- */
-struct ossl_item_st {
-    unsigned int id;
-    void *ptr;
-};
-
-/*
- * Type to tie together algorithm names, property definition string and
- * the algorithm implementation in the form of a dispatch table.
- *
- * An array of these is always terminated by algorithm_names == NULL
- */
-struct ossl_algorithm_st {
-    const char *algorithm_names;     /* key */
-    const char *property_definition; /* key */
-    const OSSL_DISPATCH *implementation;
-    const char *algorithm_description;
-};
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-/*
- * Type to pass object data in a uniform way, without exposing the object
- * structure.
- *
- * An array of these is always terminated by key == NULL
- */
-struct ossl_param_st {
-    const char *key;             /* the name of the parameter */
-    unsigned int data_type;      /* declare what kind of content is in buffer */
-    void *data;                  /* value being passed in or out */
-    size_t data_size;            /* data size */
-    size_t return_size;          /* returned content size */
-};
+    /*-
+     * Base types
+     * ----------
+     *
+     * These are the types that the OpenSSL core and providers have in common
+     * to communicate data between them.
+     */
+
+    /* Opaque handles to be used with core upcall functions from providers */
+    typedef struct ossl_core_handle_st OSSL_CORE_HANDLE;
+    typedef struct openssl_core_ctx_st OPENSSL_CORE_CTX;
+    typedef struct ossl_core_bio_st OSSL_CORE_BIO;
+
+    /*
+     * Dispatch table element.  function_id numbers and the functions are defined
+     * in core_dispatch.h, see macros with 'OSSL_CORE_MAKE_FUNC' in their names.
+     *
+     * An array of these is always terminated by function_id == 0
+     */
+    struct ossl_dispatch_st
+    {
+        int function_id;
+        void (*function)(void);
+    };
+
+    /*
+     * Other items, essentially an int<->pointer map element.
+     *
+     * We make this type distinct from OSSL_DISPATCH to ensure that dispatch
+     * tables remain tables with function pointers only.
+     *
+     * This is used whenever we need to pass things like a table of error reason
+     * codes <-> reason string maps, ...
+     *
+     * Usage determines which field works as key if any, rather than field order.
+     *
+     * An array of these is always terminated by id == 0 && ptr == NULL
+     */
+    struct ossl_item_st
+    {
+        unsigned int id;
+        void* ptr;
+    };
+
+    /*
+     * Type to tie together algorithm names, property definition string and
+     * the algorithm implementation in the form of a dispatch table.
+     *
+     * An array of these is always terminated by algorithm_names == NULL
+     */
+    struct ossl_algorithm_st
+    {
+        const char* algorithm_names;     /* key */
+        const char* property_definition; /* key */
+        const OSSL_DISPATCH* implementation;
+        const char* algorithm_description;
+    };
+
+    /*
+     * Type to pass object data in a uniform way, without exposing the object
+     * structure.
+     *
+     * An array of these is always terminated by key == NULL
+     */
+    struct ossl_param_st
+    {
+        const char* key;        /* the name of the parameter */
+        unsigned int data_type; /* declare what kind of content is in buffer */
+        void* data;             /* value being passed in or out */
+        size_t data_size;       /* data size */
+        size_t return_size;     /* returned content size */
+    };
 
 /* Currently supported OSSL_PARAM data types */
 /*
@@ -100,24 +105,24 @@ struct ossl_param_st {
  * buffer size is correct and the buffer itself is properly aligned (for
  * example by having the buffer field point at a C integer).
  */
-# define OSSL_PARAM_INTEGER              1
-# define OSSL_PARAM_UNSIGNED_INTEGER     2
+#define OSSL_PARAM_INTEGER 1
+#define OSSL_PARAM_UNSIGNED_INTEGER 2
 /*-
  * OSSL_PARAM_REAL
  * is a C binary floating point values in native form and alignment.
  */
-# define OSSL_PARAM_REAL                 3
+#define OSSL_PARAM_REAL 3
 /*-
  * OSSL_PARAM_UTF8_STRING
  * is a printable string.  It is expected to be printed as it is.
  */
-# define OSSL_PARAM_UTF8_STRING          4
+#define OSSL_PARAM_UTF8_STRING 4
 /*-
  * OSSL_PARAM_OCTET_STRING
  * is a string of bytes with no further specification.  It is expected to be
  * printed as a hexdump.
  */
-# define OSSL_PARAM_OCTET_STRING         5
+#define OSSL_PARAM_OCTET_STRING 5
 /*-
  * OSSL_PARAM_UTF8_PTR
  * is a pointer to a printable string.  It is expected to be printed as it is.
@@ -135,7 +140,7 @@ struct ossl_param_st {
  * EXTRA WARNING!  If you are not completely sure you most likely want
  * to use the OSSL_PARAM_UTF8_STRING type.
  */
-# define OSSL_PARAM_UTF8_PTR             6
+#define OSSL_PARAM_UTF8_PTR 6
 /*-
  * OSSL_PARAM_OCTET_PTR
  * is a pointer to a string of bytes with no further specification.  It is
@@ -154,80 +159,73 @@ struct ossl_param_st {
  * EXTRA WARNING!  If you are not completely sure you most likely want
  * to use the OSSL_PARAM_OCTET_STRING type.
  */
-# define OSSL_PARAM_OCTET_PTR            7
-
-/*
- * Typedef for the thread stop handling callback. Used both internally and by
- * providers.
- *
- * Providers may register for notifications about threads stopping by
- * registering a callback to hear about such events. Providers register the
- * callback using the OSSL_FUNC_CORE_THREAD_START function in the |in| dispatch
- * table passed to OSSL_provider_init(). The arg passed back to a provider will
- * be the provider side context object.
- */
-typedef void (*OSSL_thread_stop_handler_fn)(void *arg);
-
-
-/*-
- * Provider entry point
- * --------------------
- *
- * This function is expected to be present in any dynamically loadable
- * provider module.  By definition, if this function doesn't exist in a
- * module, that module is not an OpenSSL provider module.
- */
-/*-
- * |handle|     pointer to opaque type OSSL_CORE_HANDLE.  This can be used
- *              together with some functions passed via |in| to query data.
- * |in|         is the array of functions that the Core passes to the provider.
- * |out|        will be the array of base functions that the provider passes
- *              back to the Core.
- * |provctx|    a provider side context object, optionally created if the
- *              provider needs it.  This value is passed to other provider
- *              functions, notably other context constructors.
- */
-typedef int (OSSL_provider_init_fn)(const OSSL_CORE_HANDLE *handle,
-                                    const OSSL_DISPATCH *in,
-                                    const OSSL_DISPATCH **out,
-                                    void **provctx);
-# ifdef __VMS
-#  pragma names save
-#  pragma names uppercase,truncated
-# endif
-OPENSSL_EXPORT OSSL_provider_init_fn OSSL_provider_init;
-# ifdef __VMS
-#  pragma names restore
-# endif
-
-/*
- * Generic callback function signature.
- *
- * The expectation is that any provider function that wants to offer
- * a callback / hook can do so by taking an argument with this type,
- * as well as a pointer to caller-specific data.  When calling the
- * callback, the provider function can populate an OSSL_PARAM array
- * with data of its choice and pass that in the callback call, along
- * with the caller data argument.
- *
- * libcrypto may use the OSSL_PARAM array to create arguments for an
- * application callback it knows about.
- */
-typedef int (OSSL_CALLBACK)(const OSSL_PARAM params[], void *arg);
-typedef int (OSSL_INOUT_CALLBACK)(const OSSL_PARAM in_params[],
-                                  OSSL_PARAM out_params[], void *arg);
-/*
- * Passphrase callback function signature
- *
- * This is similar to the generic callback function above, but adds a
- * result parameter.
- */
-typedef int (OSSL_PASSPHRASE_CALLBACK)(char *pass, size_t pass_size,
-                                       size_t *pass_len,
-                                       const OSSL_PARAM params[], void *arg);
+#define OSSL_PARAM_OCTET_PTR 7
+
+    /*
+     * Typedef for the thread stop handling callback. Used both internally and by
+     * providers.
+     *
+     * Providers may register for notifications about threads stopping by
+     * registering a callback to hear about such events. Providers register the
+     * callback using the OSSL_FUNC_CORE_THREAD_START function in the |in| dispatch
+     * table passed to OSSL_provider_init(). The arg passed back to a provider will
+     * be the provider side context object.
+     */
+    typedef void (*OSSL_thread_stop_handler_fn)(void* arg);
+
+    /*-
+     * Provider entry point
+     * --------------------
+     *
+     * This function is expected to be present in any dynamically loadable
+     * provider module.  By definition, if this function doesn't exist in a
+     * module, that module is not an OpenSSL provider module.
+     */
+    /*-
+     * |handle|     pointer to opaque type OSSL_CORE_HANDLE.  This can be used
+     *              together with some functions passed via |in| to query data.
+     * |in|         is the array of functions that the Core passes to the provider.
+     * |out|        will be the array of base functions that the provider passes
+     *              back to the Core.
+     * |provctx|    a provider side context object, optionally created if the
+     *              provider needs it.  This value is passed to other provider
+     *              functions, notably other context constructors.
+     */
+    typedef int(OSSL_provider_init_fn)(const OSSL_CORE_HANDLE* handle, const OSSL_DISPATCH* in, const OSSL_DISPATCH** out, void** provctx);
+#ifdef __VMS
+#pragma names save
+#pragma names uppercase, truncated
+#endif
+    OPENSSL_EXPORT OSSL_provider_init_fn OSSL_provider_init;
+#ifdef __VMS
+#pragma names restore
+#endif
 
-# ifdef __cplusplus
+    /*
+     * Generic callback function signature.
+     *
+     * The expectation is that any provider function that wants to offer
+     * a callback / hook can do so by taking an argument with this type,
+     * as well as a pointer to caller-specific data.  When calling the
+     * callback, the provider function can populate an OSSL_PARAM array
+     * with data of its choice and pass that in the callback call, along
+     * with the caller data argument.
+     *
+     * libcrypto may use the OSSL_PARAM array to create arguments for an
+     * application callback it knows about.
+     */
+    typedef int(OSSL_CALLBACK)(const OSSL_PARAM params[], void* arg);
+    typedef int(OSSL_INOUT_CALLBACK)(const OSSL_PARAM in_params[], OSSL_PARAM out_params[], void* arg);
+    /*
+     * Passphrase callback function signature
+     *
+     * This is similar to the generic callback function above, but adds a
+     * result parameter.
+     */
+    typedef int(OSSL_PASSPHRASE_CALLBACK)(char* pass, size_t pass_size, size_t* pass_len, const OSSL_PARAM params[], void* arg);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/core_dispatch.h b/CAPI/cpp/grpc/include/openssl/core_dispatch.h
index 99fcda0..b74e075 100644
--- a/CAPI/cpp/grpc/include/openssl/core_dispatch.h
+++ b/CAPI/cpp/grpc/include/openssl/core_dispatch.h
@@ -8,15 +8,16 @@
  */
 
 #ifndef OPENSSL_CORE_NUMBERS_H
-# define OPENSSL_CORE_NUMBERS_H
-# pragma once
+#define OPENSSL_CORE_NUMBERS_H
+#pragma once
 
-# include <stdarg.h>
-# include <openssl/core.h>
+#include <stdarg.h>
+#include <openssl/core.h>
 
-# ifdef __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /*-
  * Identities
@@ -44,12 +45,12 @@ extern "C" {
  * Note: This is considered a "reserved" internal macro. Applications should
  * not use this or assume its existence.
  */
-#define OSSL_CORE_MAKE_FUNC(type,name,args)                             \
-    typedef type (OSSL_FUNC_##name##_fn)args;                           \
-    static ossl_unused ossl_inline \
-    OSSL_FUNC_##name##_fn *OSSL_FUNC_##name(const OSSL_DISPATCH *opf)   \
-    {                                                                   \
-        return (OSSL_FUNC_##name##_fn *)opf->function;                  \
+#define OSSL_CORE_MAKE_FUNC(type, name, args)                             \
+    typedef type(OSSL_FUNC_##name##_fn) args;                             \
+    static ossl_unused ossl_inline                                        \
+        OSSL_FUNC_##name##_fn* OSSL_FUNC_##name(const OSSL_DISPATCH* opf) \
+    {                                                                     \
+        return (OSSL_FUNC_##name##_fn*)opf->function;                     \
     }
 
 /*
@@ -60,448 +61,313 @@ extern "C" {
  * therefore NEVER be used as a function identity.
  */
 /* Functions provided by the Core to the provider, reserved numbers 1-1023 */
-# define OSSL_FUNC_CORE_GETTABLE_PARAMS        1
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
-                    core_gettable_params,(const OSSL_CORE_HANDLE *prov))
-# define OSSL_FUNC_CORE_GET_PARAMS             2
-OSSL_CORE_MAKE_FUNC(int,core_get_params,(const OSSL_CORE_HANDLE *prov,
-                                         OSSL_PARAM params[]))
-# define OSSL_FUNC_CORE_THREAD_START           3
-OSSL_CORE_MAKE_FUNC(int,core_thread_start,(const OSSL_CORE_HANDLE *prov,
-                                           OSSL_thread_stop_handler_fn handfn,
-                                           void *arg))
-# define OSSL_FUNC_CORE_GET_LIBCTX             4
-OSSL_CORE_MAKE_FUNC(OPENSSL_CORE_CTX *,core_get_libctx,
-                    (const OSSL_CORE_HANDLE *prov))
-# define OSSL_FUNC_CORE_NEW_ERROR              5
-OSSL_CORE_MAKE_FUNC(void,core_new_error,(const OSSL_CORE_HANDLE *prov))
-# define OSSL_FUNC_CORE_SET_ERROR_DEBUG        6
-OSSL_CORE_MAKE_FUNC(void,core_set_error_debug,
-                    (const OSSL_CORE_HANDLE *prov,
-                     const char *file, int line, const char *func))
-# define OSSL_FUNC_CORE_VSET_ERROR             7
-OSSL_CORE_MAKE_FUNC(void,core_vset_error,
-                    (const OSSL_CORE_HANDLE *prov,
-                     uint32_t reason, const char *fmt, va_list args))
-# define OSSL_FUNC_CORE_SET_ERROR_MARK         8
-OSSL_CORE_MAKE_FUNC(int, core_set_error_mark, (const OSSL_CORE_HANDLE *prov))
-# define OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK  9
-OSSL_CORE_MAKE_FUNC(int, core_clear_last_error_mark,
-                    (const OSSL_CORE_HANDLE *prov))
-# define OSSL_FUNC_CORE_POP_ERROR_TO_MARK     10
-OSSL_CORE_MAKE_FUNC(int, core_pop_error_to_mark, (const OSSL_CORE_HANDLE *prov))
-
-
-/* Functions to access the OBJ database */
-
-#define OSSL_FUNC_CORE_OBJ_ADD_SIGID          11
-#define OSSL_FUNC_CORE_OBJ_CREATE             12
-
-OSSL_CORE_MAKE_FUNC(int, core_obj_add_sigid,
-                    (const OSSL_CORE_HANDLE *prov, const char  *sign_name,
-                     const char *digest_name, const char *pkey_name))
-OSSL_CORE_MAKE_FUNC(int, core_obj_create,
-                    (const OSSL_CORE_HANDLE *prov, const char *oid,
-                     const char *sn, const char *ln))
+#define OSSL_FUNC_CORE_GETTABLE_PARAMS 1
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, core_gettable_params, (const OSSL_CORE_HANDLE* prov))
+#define OSSL_FUNC_CORE_GET_PARAMS 2
+    OSSL_CORE_MAKE_FUNC(int, core_get_params, (const OSSL_CORE_HANDLE* prov, OSSL_PARAM params[]))
+#define OSSL_FUNC_CORE_THREAD_START 3
+    OSSL_CORE_MAKE_FUNC(int, core_thread_start, (const OSSL_CORE_HANDLE* prov, OSSL_thread_stop_handler_fn handfn, void* arg))
+#define OSSL_FUNC_CORE_GET_LIBCTX 4
+    OSSL_CORE_MAKE_FUNC(OPENSSL_CORE_CTX*, core_get_libctx, (const OSSL_CORE_HANDLE* prov))
+#define OSSL_FUNC_CORE_NEW_ERROR 5
+    OSSL_CORE_MAKE_FUNC(void, core_new_error, (const OSSL_CORE_HANDLE* prov))
+#define OSSL_FUNC_CORE_SET_ERROR_DEBUG 6
+    OSSL_CORE_MAKE_FUNC(void, core_set_error_debug, (const OSSL_CORE_HANDLE* prov, const char* file, int line, const char* func))
+#define OSSL_FUNC_CORE_VSET_ERROR 7
+    OSSL_CORE_MAKE_FUNC(void, core_vset_error, (const OSSL_CORE_HANDLE* prov, uint32_t reason, const char* fmt, va_list args))
+#define OSSL_FUNC_CORE_SET_ERROR_MARK 8
+    OSSL_CORE_MAKE_FUNC(int, core_set_error_mark, (const OSSL_CORE_HANDLE* prov))
+#define OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK 9
+    OSSL_CORE_MAKE_FUNC(int, core_clear_last_error_mark, (const OSSL_CORE_HANDLE* prov))
+#define OSSL_FUNC_CORE_POP_ERROR_TO_MARK 10
+    OSSL_CORE_MAKE_FUNC(int, core_pop_error_to_mark, (const OSSL_CORE_HANDLE* prov))
+
+    /* Functions to access the OBJ database */
+
+#define OSSL_FUNC_CORE_OBJ_ADD_SIGID 11
+#define OSSL_FUNC_CORE_OBJ_CREATE 12
+
+    OSSL_CORE_MAKE_FUNC(int, core_obj_add_sigid, (const OSSL_CORE_HANDLE* prov, const char* sign_name, const char* digest_name, const char* pkey_name))
+    OSSL_CORE_MAKE_FUNC(int, core_obj_create, (const OSSL_CORE_HANDLE* prov, const char* oid, const char* sn, const char* ln))
 
 /* Memory allocation, freeing, clearing. */
-#define OSSL_FUNC_CRYPTO_MALLOC               20
-OSSL_CORE_MAKE_FUNC(void *,
-        CRYPTO_malloc, (size_t num, const char *file, int line))
-#define OSSL_FUNC_CRYPTO_ZALLOC               21
-OSSL_CORE_MAKE_FUNC(void *,
-        CRYPTO_zalloc, (size_t num, const char *file, int line))
-#define OSSL_FUNC_CRYPTO_FREE                 22
-OSSL_CORE_MAKE_FUNC(void,
-        CRYPTO_free, (void *ptr, const char *file, int line))
-#define OSSL_FUNC_CRYPTO_CLEAR_FREE           23
-OSSL_CORE_MAKE_FUNC(void,
-        CRYPTO_clear_free, (void *ptr, size_t num, const char *file, int line))
-#define OSSL_FUNC_CRYPTO_REALLOC              24
-OSSL_CORE_MAKE_FUNC(void *,
-        CRYPTO_realloc, (void *addr, size_t num, const char *file, int line))
-#define OSSL_FUNC_CRYPTO_CLEAR_REALLOC        25
-OSSL_CORE_MAKE_FUNC(void *,
-        CRYPTO_clear_realloc, (void *addr, size_t old_num, size_t num,
-                               const char *file, int line))
-#define OSSL_FUNC_CRYPTO_SECURE_MALLOC        26
-OSSL_CORE_MAKE_FUNC(void *,
-        CRYPTO_secure_malloc, (size_t num, const char *file, int line))
-#define OSSL_FUNC_CRYPTO_SECURE_ZALLOC        27
-OSSL_CORE_MAKE_FUNC(void *,
-        CRYPTO_secure_zalloc, (size_t num, const char *file, int line))
-#define OSSL_FUNC_CRYPTO_SECURE_FREE          28
-OSSL_CORE_MAKE_FUNC(void,
-        CRYPTO_secure_free, (void *ptr, const char *file, int line))
-#define OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE    29
-OSSL_CORE_MAKE_FUNC(void,
-        CRYPTO_secure_clear_free, (void *ptr, size_t num, const char *file,
-                                   int line))
-#define OSSL_FUNC_CRYPTO_SECURE_ALLOCATED     30
-OSSL_CORE_MAKE_FUNC(int,
-        CRYPTO_secure_allocated, (const void *ptr))
-#define OSSL_FUNC_OPENSSL_CLEANSE             31
-OSSL_CORE_MAKE_FUNC(void,
-        OPENSSL_cleanse, (void *ptr, size_t len))
+#define OSSL_FUNC_CRYPTO_MALLOC 20
+    OSSL_CORE_MAKE_FUNC(void*, CRYPTO_malloc, (size_t num, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_ZALLOC 21
+    OSSL_CORE_MAKE_FUNC(void*, CRYPTO_zalloc, (size_t num, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_FREE 22
+    OSSL_CORE_MAKE_FUNC(void, CRYPTO_free, (void* ptr, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_CLEAR_FREE 23
+    OSSL_CORE_MAKE_FUNC(void, CRYPTO_clear_free, (void* ptr, size_t num, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_REALLOC 24
+    OSSL_CORE_MAKE_FUNC(void*, CRYPTO_realloc, (void* addr, size_t num, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_CLEAR_REALLOC 25
+    OSSL_CORE_MAKE_FUNC(void*, CRYPTO_clear_realloc, (void* addr, size_t old_num, size_t num, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_MALLOC 26
+    OSSL_CORE_MAKE_FUNC(void*, CRYPTO_secure_malloc, (size_t num, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_ZALLOC 27
+    OSSL_CORE_MAKE_FUNC(void*, CRYPTO_secure_zalloc, (size_t num, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_FREE 28
+    OSSL_CORE_MAKE_FUNC(void, CRYPTO_secure_free, (void* ptr, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_CLEAR_FREE 29
+    OSSL_CORE_MAKE_FUNC(void, CRYPTO_secure_clear_free, (void* ptr, size_t num, const char* file, int line))
+#define OSSL_FUNC_CRYPTO_SECURE_ALLOCATED 30
+    OSSL_CORE_MAKE_FUNC(int, CRYPTO_secure_allocated, (const void* ptr))
+#define OSSL_FUNC_OPENSSL_CLEANSE 31
+    OSSL_CORE_MAKE_FUNC(void, OPENSSL_cleanse, (void* ptr, size_t len))
 
 /* Bio functions provided by the core */
-#define OSSL_FUNC_BIO_NEW_FILE                40
-#define OSSL_FUNC_BIO_NEW_MEMBUF              41
-#define OSSL_FUNC_BIO_READ_EX                 42
-#define OSSL_FUNC_BIO_WRITE_EX                43
-#define OSSL_FUNC_BIO_UP_REF                  44
-#define OSSL_FUNC_BIO_FREE                    45
-#define OSSL_FUNC_BIO_VPRINTF                 46
-#define OSSL_FUNC_BIO_VSNPRINTF               47
-#define OSSL_FUNC_BIO_PUTS                    48
-#define OSSL_FUNC_BIO_GETS                    49
-#define OSSL_FUNC_BIO_CTRL                    50
-
-
-OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_file, (const char *filename,
-                                                    const char *mode))
-OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_membuf, (const void *buf, int len))
-OSSL_CORE_MAKE_FUNC(int, BIO_read_ex, (OSSL_CORE_BIO *bio, void *data,
-                                       size_t data_len, size_t *bytes_read))
-OSSL_CORE_MAKE_FUNC(int, BIO_write_ex, (OSSL_CORE_BIO *bio, const void *data,
-                                        size_t data_len, size_t *written))
-OSSL_CORE_MAKE_FUNC(int, BIO_gets, (OSSL_CORE_BIO *bio, char *buf, int size))
-OSSL_CORE_MAKE_FUNC(int, BIO_puts, (OSSL_CORE_BIO *bio, const char *str))
-OSSL_CORE_MAKE_FUNC(int, BIO_up_ref, (OSSL_CORE_BIO *bio))
-OSSL_CORE_MAKE_FUNC(int, BIO_free, (OSSL_CORE_BIO *bio))
-OSSL_CORE_MAKE_FUNC(int, BIO_vprintf, (OSSL_CORE_BIO *bio, const char *format,
-                                       va_list args))
-OSSL_CORE_MAKE_FUNC(int, BIO_vsnprintf,
-                   (char *buf, size_t n, const char *fmt, va_list args))
-OSSL_CORE_MAKE_FUNC(int, BIO_ctrl, (OSSL_CORE_BIO *bio,
-                                    int cmd, long num, void *ptr))
-
-#define OSSL_FUNC_SELF_TEST_CB               100
-OSSL_CORE_MAKE_FUNC(void, self_test_cb, (OPENSSL_CORE_CTX *ctx, OSSL_CALLBACK **cb,
-                                         void **cbarg))
+#define OSSL_FUNC_BIO_NEW_FILE 40
+#define OSSL_FUNC_BIO_NEW_MEMBUF 41
+#define OSSL_FUNC_BIO_READ_EX 42
+#define OSSL_FUNC_BIO_WRITE_EX 43
+#define OSSL_FUNC_BIO_UP_REF 44
+#define OSSL_FUNC_BIO_FREE 45
+#define OSSL_FUNC_BIO_VPRINTF 46
+#define OSSL_FUNC_BIO_VSNPRINTF 47
+#define OSSL_FUNC_BIO_PUTS 48
+#define OSSL_FUNC_BIO_GETS 49
+#define OSSL_FUNC_BIO_CTRL 50
+
+    OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO*, BIO_new_file, (const char* filename, const char* mode))
+    OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO*, BIO_new_membuf, (const void* buf, int len))
+    OSSL_CORE_MAKE_FUNC(int, BIO_read_ex, (OSSL_CORE_BIO * bio, void* data, size_t data_len, size_t* bytes_read))
+    OSSL_CORE_MAKE_FUNC(int, BIO_write_ex, (OSSL_CORE_BIO * bio, const void* data, size_t data_len, size_t* written))
+    OSSL_CORE_MAKE_FUNC(int, BIO_gets, (OSSL_CORE_BIO * bio, char* buf, int size))
+    OSSL_CORE_MAKE_FUNC(int, BIO_puts, (OSSL_CORE_BIO * bio, const char* str))
+    OSSL_CORE_MAKE_FUNC(int, BIO_up_ref, (OSSL_CORE_BIO * bio))
+    OSSL_CORE_MAKE_FUNC(int, BIO_free, (OSSL_CORE_BIO * bio))
+    OSSL_CORE_MAKE_FUNC(int, BIO_vprintf, (OSSL_CORE_BIO * bio, const char* format, va_list args))
+    OSSL_CORE_MAKE_FUNC(int, BIO_vsnprintf, (char* buf, size_t n, const char* fmt, va_list args))
+    OSSL_CORE_MAKE_FUNC(int, BIO_ctrl, (OSSL_CORE_BIO * bio, int cmd, long num, void* ptr))
+
+#define OSSL_FUNC_SELF_TEST_CB 100
+    OSSL_CORE_MAKE_FUNC(void, self_test_cb, (OPENSSL_CORE_CTX * ctx, OSSL_CALLBACK** cb, void** cbarg))
 
 /* Functions to get seed material from the operating system */
-#define OSSL_FUNC_GET_ENTROPY                101
-#define OSSL_FUNC_CLEANUP_ENTROPY            102
-#define OSSL_FUNC_GET_NONCE                  103
-#define OSSL_FUNC_CLEANUP_NONCE              104
-OSSL_CORE_MAKE_FUNC(size_t, get_entropy, (const OSSL_CORE_HANDLE *handle,
-                                          unsigned char **pout, int entropy,
-                                          size_t min_len, size_t max_len))
-OSSL_CORE_MAKE_FUNC(void, cleanup_entropy, (const OSSL_CORE_HANDLE *handle,
-                                            unsigned char *buf, size_t len))
-OSSL_CORE_MAKE_FUNC(size_t, get_nonce, (const OSSL_CORE_HANDLE *handle,
-                                        unsigned char **pout, size_t min_len,
-                                        size_t max_len, const void *salt,
-                                        size_t salt_len))
-OSSL_CORE_MAKE_FUNC(void, cleanup_nonce, (const OSSL_CORE_HANDLE *handle,
-                                          unsigned char *buf, size_t len))
+#define OSSL_FUNC_GET_ENTROPY 101
+#define OSSL_FUNC_CLEANUP_ENTROPY 102
+#define OSSL_FUNC_GET_NONCE 103
+#define OSSL_FUNC_CLEANUP_NONCE 104
+    OSSL_CORE_MAKE_FUNC(size_t, get_entropy, (const OSSL_CORE_HANDLE* handle, unsigned char** pout, int entropy, size_t min_len, size_t max_len))
+    OSSL_CORE_MAKE_FUNC(void, cleanup_entropy, (const OSSL_CORE_HANDLE* handle, unsigned char* buf, size_t len))
+    OSSL_CORE_MAKE_FUNC(size_t, get_nonce, (const OSSL_CORE_HANDLE* handle, unsigned char** pout, size_t min_len, size_t max_len, const void* salt, size_t salt_len))
+    OSSL_CORE_MAKE_FUNC(void, cleanup_nonce, (const OSSL_CORE_HANDLE* handle, unsigned char* buf, size_t len))
 
 /* Functions to access the core's providers */
-#define OSSL_FUNC_PROVIDER_REGISTER_CHILD_CB   105
+#define OSSL_FUNC_PROVIDER_REGISTER_CHILD_CB 105
 #define OSSL_FUNC_PROVIDER_DEREGISTER_CHILD_CB 106
-#define OSSL_FUNC_PROVIDER_NAME                107
-#define OSSL_FUNC_PROVIDER_GET0_PROVIDER_CTX   108
-#define OSSL_FUNC_PROVIDER_GET0_DISPATCH       109
-#define OSSL_FUNC_PROVIDER_UP_REF              110
-#define OSSL_FUNC_PROVIDER_FREE                111
-
-OSSL_CORE_MAKE_FUNC(int, provider_register_child_cb,
-                    (const OSSL_CORE_HANDLE *handle,
-                     int (*create_cb)(const OSSL_CORE_HANDLE *provider, void *cbdata),
-                     int (*remove_cb)(const OSSL_CORE_HANDLE *provider, void *cbdata),
-                     int (*global_props_cb)(const char *props, void *cbdata),
-                     void *cbdata))
-OSSL_CORE_MAKE_FUNC(void, provider_deregister_child_cb,
-                    (const OSSL_CORE_HANDLE *handle))
-OSSL_CORE_MAKE_FUNC(const char *, provider_name,
-                    (const OSSL_CORE_HANDLE *prov))
-OSSL_CORE_MAKE_FUNC(void *, provider_get0_provider_ctx,
-                    (const OSSL_CORE_HANDLE *prov))
-OSSL_CORE_MAKE_FUNC(const OSSL_DISPATCH *, provider_get0_dispatch,
-                    (const OSSL_CORE_HANDLE *prov))
-OSSL_CORE_MAKE_FUNC(int, provider_up_ref,
-                    (const OSSL_CORE_HANDLE *prov, int activate))
-OSSL_CORE_MAKE_FUNC(int, provider_free,
-                    (const OSSL_CORE_HANDLE *prov, int deactivate))
+#define OSSL_FUNC_PROVIDER_NAME 107
+#define OSSL_FUNC_PROVIDER_GET0_PROVIDER_CTX 108
+#define OSSL_FUNC_PROVIDER_GET0_DISPATCH 109
+#define OSSL_FUNC_PROVIDER_UP_REF 110
+#define OSSL_FUNC_PROVIDER_FREE 111
+
+    OSSL_CORE_MAKE_FUNC(int, provider_register_child_cb, (const OSSL_CORE_HANDLE* handle, int (*create_cb)(const OSSL_CORE_HANDLE* provider, void* cbdata), int (*remove_cb)(const OSSL_CORE_HANDLE* provider, void* cbdata), int (*global_props_cb)(const char* props, void* cbdata), void* cbdata))
+    OSSL_CORE_MAKE_FUNC(void, provider_deregister_child_cb, (const OSSL_CORE_HANDLE* handle))
+    OSSL_CORE_MAKE_FUNC(const char*, provider_name, (const OSSL_CORE_HANDLE* prov))
+    OSSL_CORE_MAKE_FUNC(void*, provider_get0_provider_ctx, (const OSSL_CORE_HANDLE* prov))
+    OSSL_CORE_MAKE_FUNC(const OSSL_DISPATCH*, provider_get0_dispatch, (const OSSL_CORE_HANDLE* prov))
+    OSSL_CORE_MAKE_FUNC(int, provider_up_ref, (const OSSL_CORE_HANDLE* prov, int activate))
+    OSSL_CORE_MAKE_FUNC(int, provider_free, (const OSSL_CORE_HANDLE* prov, int deactivate))
 
 /* Functions provided by the provider to the Core, reserved numbers 1024-1535 */
-# define OSSL_FUNC_PROVIDER_TEARDOWN           1024
-OSSL_CORE_MAKE_FUNC(void,provider_teardown,(void *provctx))
-# define OSSL_FUNC_PROVIDER_GETTABLE_PARAMS    1025
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
-                    provider_gettable_params,(void *provctx))
-# define OSSL_FUNC_PROVIDER_GET_PARAMS         1026
-OSSL_CORE_MAKE_FUNC(int,provider_get_params,(void *provctx,
-                                             OSSL_PARAM params[]))
-# define OSSL_FUNC_PROVIDER_QUERY_OPERATION    1027
-OSSL_CORE_MAKE_FUNC(const OSSL_ALGORITHM *,provider_query_operation,
-                    (void *provctx, int operation_id, int *no_store))
-# define OSSL_FUNC_PROVIDER_UNQUERY_OPERATION  1028
-OSSL_CORE_MAKE_FUNC(void, provider_unquery_operation,
-                    (void *provctx, int operation_id, const OSSL_ALGORITHM *))
-# define OSSL_FUNC_PROVIDER_GET_REASON_STRINGS 1029
-OSSL_CORE_MAKE_FUNC(const OSSL_ITEM *,provider_get_reason_strings,
-                    (void *provctx))
-# define OSSL_FUNC_PROVIDER_GET_CAPABILITIES   1030
-OSSL_CORE_MAKE_FUNC(int, provider_get_capabilities, (void *provctx,
-                    const char *capability, OSSL_CALLBACK *cb, void *arg))
-# define OSSL_FUNC_PROVIDER_SELF_TEST          1031
-OSSL_CORE_MAKE_FUNC(int, provider_self_test, (void *provctx))
-
-/* Operations */
-
-# define OSSL_OP_DIGEST                              1
-# define OSSL_OP_CIPHER                              2   /* Symmetric Ciphers */
-# define OSSL_OP_MAC                                 3
-# define OSSL_OP_KDF                                 4
-# define OSSL_OP_RAND                                5
-# define OSSL_OP_KEYMGMT                            10
-# define OSSL_OP_KEYEXCH                            11
-# define OSSL_OP_SIGNATURE                          12
-# define OSSL_OP_ASYM_CIPHER                        13
-# define OSSL_OP_KEM                                14
+#define OSSL_FUNC_PROVIDER_TEARDOWN 1024
+    OSSL_CORE_MAKE_FUNC(void, provider_teardown, (void* provctx))
+#define OSSL_FUNC_PROVIDER_GETTABLE_PARAMS 1025
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, provider_gettable_params, (void* provctx))
+#define OSSL_FUNC_PROVIDER_GET_PARAMS 1026
+    OSSL_CORE_MAKE_FUNC(int, provider_get_params, (void* provctx, OSSL_PARAM params[]))
+#define OSSL_FUNC_PROVIDER_QUERY_OPERATION 1027
+    OSSL_CORE_MAKE_FUNC(const OSSL_ALGORITHM*, provider_query_operation, (void* provctx, int operation_id, int* no_store))
+#define OSSL_FUNC_PROVIDER_UNQUERY_OPERATION 1028
+    OSSL_CORE_MAKE_FUNC(void, provider_unquery_operation, (void* provctx, int operation_id, const OSSL_ALGORITHM*))
+#define OSSL_FUNC_PROVIDER_GET_REASON_STRINGS 1029
+    OSSL_CORE_MAKE_FUNC(const OSSL_ITEM*, provider_get_reason_strings, (void* provctx))
+#define OSSL_FUNC_PROVIDER_GET_CAPABILITIES 1030
+    OSSL_CORE_MAKE_FUNC(int, provider_get_capabilities, (void* provctx, const char* capability, OSSL_CALLBACK* cb, void* arg))
+#define OSSL_FUNC_PROVIDER_SELF_TEST 1031
+    OSSL_CORE_MAKE_FUNC(int, provider_self_test, (void* provctx))
+
+    /* Operations */
+
+#define OSSL_OP_DIGEST 1
+#define OSSL_OP_CIPHER 2 /* Symmetric Ciphers */
+#define OSSL_OP_MAC 3
+#define OSSL_OP_KDF 4
+#define OSSL_OP_RAND 5
+#define OSSL_OP_KEYMGMT 10
+#define OSSL_OP_KEYEXCH 11
+#define OSSL_OP_SIGNATURE 12
+#define OSSL_OP_ASYM_CIPHER 13
+#define OSSL_OP_KEM 14
 /* New section for non-EVP operations */
-# define OSSL_OP_ENCODER                            20
-# define OSSL_OP_DECODER                            21
-# define OSSL_OP_STORE                              22
+#define OSSL_OP_ENCODER 20
+#define OSSL_OP_DECODER 21
+#define OSSL_OP_STORE 22
 /* Highest known operation number */
-# define OSSL_OP__HIGHEST                           22
-
-/* Digests */
-
-# define OSSL_FUNC_DIGEST_NEWCTX                     1
-# define OSSL_FUNC_DIGEST_INIT                       2
-# define OSSL_FUNC_DIGEST_UPDATE                     3
-# define OSSL_FUNC_DIGEST_FINAL                      4
-# define OSSL_FUNC_DIGEST_DIGEST                     5
-# define OSSL_FUNC_DIGEST_FREECTX                    6
-# define OSSL_FUNC_DIGEST_DUPCTX                     7
-# define OSSL_FUNC_DIGEST_GET_PARAMS                 8
-# define OSSL_FUNC_DIGEST_SET_CTX_PARAMS             9
-# define OSSL_FUNC_DIGEST_GET_CTX_PARAMS            10
-# define OSSL_FUNC_DIGEST_GETTABLE_PARAMS           11
-# define OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS       12
-# define OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS       13
-
-OSSL_CORE_MAKE_FUNC(void *, digest_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(int, digest_init, (void *dctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, digest_update,
-                    (void *dctx, const unsigned char *in, size_t inl))
-OSSL_CORE_MAKE_FUNC(int, digest_final,
-                    (void *dctx,
-                     unsigned char *out, size_t *outl, size_t outsz))
-OSSL_CORE_MAKE_FUNC(int, digest_digest,
-                    (void *provctx, const unsigned char *in, size_t inl,
-                     unsigned char *out, size_t *outl, size_t outsz))
-
-OSSL_CORE_MAKE_FUNC(void, digest_freectx, (void *dctx))
-OSSL_CORE_MAKE_FUNC(void *, digest_dupctx, (void *dctx))
-
-OSSL_CORE_MAKE_FUNC(int, digest_get_params, (OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, digest_set_ctx_params,
-                    (void *vctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, digest_get_ctx_params,
-                    (void *vctx, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_gettable_params,
-                    (void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_settable_ctx_params,
-                    (void *dctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, digest_gettable_ctx_params,
-                    (void *dctx, void *provctx))
-
-/* Symmetric Ciphers */
-
-# define OSSL_FUNC_CIPHER_NEWCTX                     1
-# define OSSL_FUNC_CIPHER_ENCRYPT_INIT               2
-# define OSSL_FUNC_CIPHER_DECRYPT_INIT               3
-# define OSSL_FUNC_CIPHER_UPDATE                     4
-# define OSSL_FUNC_CIPHER_FINAL                      5
-# define OSSL_FUNC_CIPHER_CIPHER                     6
-# define OSSL_FUNC_CIPHER_FREECTX                    7
-# define OSSL_FUNC_CIPHER_DUPCTX                     8
-# define OSSL_FUNC_CIPHER_GET_PARAMS                 9
-# define OSSL_FUNC_CIPHER_GET_CTX_PARAMS            10
-# define OSSL_FUNC_CIPHER_SET_CTX_PARAMS            11
-# define OSSL_FUNC_CIPHER_GETTABLE_PARAMS           12
-# define OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS       13
-# define OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS       14
-
-OSSL_CORE_MAKE_FUNC(void *, cipher_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(int, cipher_encrypt_init, (void *cctx,
-                                                  const unsigned char *key,
-                                                  size_t keylen,
-                                                  const unsigned char *iv,
-                                                  size_t ivlen,
-                                                  const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, cipher_decrypt_init, (void *cctx,
-                                                  const unsigned char *key,
-                                                  size_t keylen,
-                                                  const unsigned char *iv,
-                                                  size_t ivlen,
-                                                  const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, cipher_update,
-                    (void *cctx,
-                     unsigned char *out, size_t *outl, size_t outsize,
-                     const unsigned char *in, size_t inl))
-OSSL_CORE_MAKE_FUNC(int, cipher_final,
-                    (void *cctx,
-                     unsigned char *out, size_t *outl, size_t outsize))
-OSSL_CORE_MAKE_FUNC(int, cipher_cipher,
-                    (void *cctx,
-                     unsigned char *out, size_t *outl, size_t outsize,
-                     const unsigned char *in, size_t inl))
-OSSL_CORE_MAKE_FUNC(void, cipher_freectx, (void *cctx))
-OSSL_CORE_MAKE_FUNC(void *, cipher_dupctx, (void *cctx))
-OSSL_CORE_MAKE_FUNC(int, cipher_get_params, (OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, cipher_get_ctx_params, (void *cctx,
-                                                    OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, cipher_set_ctx_params, (void *cctx,
-                                                    const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_gettable_params,
-                    (void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_settable_ctx_params,
-                    (void *cctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, cipher_gettable_ctx_params,
-                    (void *cctx, void *provctx))
-
-/* MACs */
-
-# define OSSL_FUNC_MAC_NEWCTX                        1
-# define OSSL_FUNC_MAC_DUPCTX                        2
-# define OSSL_FUNC_MAC_FREECTX                       3
-# define OSSL_FUNC_MAC_INIT                          4
-# define OSSL_FUNC_MAC_UPDATE                        5
-# define OSSL_FUNC_MAC_FINAL                         6
-# define OSSL_FUNC_MAC_GET_PARAMS                    7
-# define OSSL_FUNC_MAC_GET_CTX_PARAMS                8
-# define OSSL_FUNC_MAC_SET_CTX_PARAMS                9
-# define OSSL_FUNC_MAC_GETTABLE_PARAMS              10
-# define OSSL_FUNC_MAC_GETTABLE_CTX_PARAMS          11
-# define OSSL_FUNC_MAC_SETTABLE_CTX_PARAMS          12
-
-OSSL_CORE_MAKE_FUNC(void *, mac_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(void *, mac_dupctx, (void *src))
-OSSL_CORE_MAKE_FUNC(void, mac_freectx, (void *mctx))
-OSSL_CORE_MAKE_FUNC(int, mac_init, (void *mctx, const unsigned char *key,
-                                    size_t keylen, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, mac_update,
-                    (void *mctx, const unsigned char *in, size_t inl))
-OSSL_CORE_MAKE_FUNC(int, mac_final,
-                    (void *mctx,
-                     unsigned char *out, size_t *outl, size_t outsize))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_gettable_params, (void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_gettable_ctx_params,
-                    (void *mctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, mac_settable_ctx_params,
-                    (void *mctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(int, mac_get_params, (OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, mac_get_ctx_params,
-                    (void *mctx, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, mac_set_ctx_params,
-                    (void *mctx, const OSSL_PARAM params[]))
-
-/* KDFs and PRFs */
-
-# define OSSL_FUNC_KDF_NEWCTX                        1
-# define OSSL_FUNC_KDF_DUPCTX                        2
-# define OSSL_FUNC_KDF_FREECTX                       3
-# define OSSL_FUNC_KDF_RESET                         4
-# define OSSL_FUNC_KDF_DERIVE                        5
-# define OSSL_FUNC_KDF_GETTABLE_PARAMS               6
-# define OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS           7
-# define OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS           8
-# define OSSL_FUNC_KDF_GET_PARAMS                    9
-# define OSSL_FUNC_KDF_GET_CTX_PARAMS               10
-# define OSSL_FUNC_KDF_SET_CTX_PARAMS               11
-
-OSSL_CORE_MAKE_FUNC(void *, kdf_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(void *, kdf_dupctx, (void *src))
-OSSL_CORE_MAKE_FUNC(void, kdf_freectx, (void *kctx))
-OSSL_CORE_MAKE_FUNC(void, kdf_reset, (void *kctx))
-OSSL_CORE_MAKE_FUNC(int, kdf_derive, (void *kctx, unsigned char *key,
-                                      size_t keylen, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_gettable_params, (void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_gettable_ctx_params,
-                    (void *kctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kdf_settable_ctx_params,
-                    (void *kctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(int, kdf_get_params, (OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, kdf_get_ctx_params,
-                    (void *kctx, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, kdf_set_ctx_params,
-                    (void *kctx, const OSSL_PARAM params[]))
-
-/* RAND */
-
-# define OSSL_FUNC_RAND_NEWCTX                        1
-# define OSSL_FUNC_RAND_FREECTX                       2
-# define OSSL_FUNC_RAND_INSTANTIATE                   3
-# define OSSL_FUNC_RAND_UNINSTANTIATE                 4
-# define OSSL_FUNC_RAND_GENERATE                      5
-# define OSSL_FUNC_RAND_RESEED                        6
-# define OSSL_FUNC_RAND_NONCE                         7
-# define OSSL_FUNC_RAND_ENABLE_LOCKING                8
-# define OSSL_FUNC_RAND_LOCK                          9
-# define OSSL_FUNC_RAND_UNLOCK                       10
-# define OSSL_FUNC_RAND_GETTABLE_PARAMS              11
-# define OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS          12
-# define OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS          13
-# define OSSL_FUNC_RAND_GET_PARAMS                   14
-# define OSSL_FUNC_RAND_GET_CTX_PARAMS               15
-# define OSSL_FUNC_RAND_SET_CTX_PARAMS               16
-# define OSSL_FUNC_RAND_VERIFY_ZEROIZATION           17
-# define OSSL_FUNC_RAND_GET_SEED                     18
-# define OSSL_FUNC_RAND_CLEAR_SEED                   19
-
-OSSL_CORE_MAKE_FUNC(void *,rand_newctx,
-                    (void *provctx, void *parent,
-                    const OSSL_DISPATCH *parent_calls))
-OSSL_CORE_MAKE_FUNC(void,rand_freectx, (void *vctx))
-OSSL_CORE_MAKE_FUNC(int,rand_instantiate,
-                    (void *vdrbg, unsigned int strength,
-                     int prediction_resistance,
-                     const unsigned char *pstr, size_t pstr_len,
-                     const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int,rand_uninstantiate, (void *vdrbg))
-OSSL_CORE_MAKE_FUNC(int,rand_generate,
-                    (void *vctx, unsigned char *out, size_t outlen,
-                     unsigned int strength, int prediction_resistance,
-                     const unsigned char *addin, size_t addin_len))
-OSSL_CORE_MAKE_FUNC(int,rand_reseed,
-                    (void *vctx, int prediction_resistance,
-                     const unsigned char *ent, size_t ent_len,
-                     const unsigned char *addin, size_t addin_len))
-OSSL_CORE_MAKE_FUNC(size_t,rand_nonce,
-                    (void *vctx, unsigned char *out, unsigned int strength,
-                     size_t min_noncelen, size_t max_noncelen))
-OSSL_CORE_MAKE_FUNC(int,rand_enable_locking, (void *vctx))
-OSSL_CORE_MAKE_FUNC(int,rand_lock, (void *vctx))
-OSSL_CORE_MAKE_FUNC(void,rand_unlock, (void *vctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_gettable_params, (void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_gettable_ctx_params,
-                    (void *vctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,rand_settable_ctx_params,
-                    (void *vctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(int,rand_get_params, (OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int,rand_get_ctx_params,
-                    (void *vctx, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int,rand_set_ctx_params,
-                    (void *vctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(void,rand_set_callbacks,
-                    (void *vctx, OSSL_INOUT_CALLBACK *get_entropy,
-                     OSSL_CALLBACK *cleanup_entropy,
-                     OSSL_INOUT_CALLBACK *get_nonce,
-                     OSSL_CALLBACK *cleanup_nonce, void *arg))
-OSSL_CORE_MAKE_FUNC(int,rand_verify_zeroization,
-                    (void *vctx))
-OSSL_CORE_MAKE_FUNC(size_t,rand_get_seed,
-                    (void *vctx, unsigned char **buffer,
-                     int entropy, size_t min_len, size_t max_len,
-                     int prediction_resistance,
-                     const unsigned char *adin, size_t adin_len))
-OSSL_CORE_MAKE_FUNC(void,rand_clear_seed,
-                    (void *vctx, unsigned char *buffer, size_t b_len))
+#define OSSL_OP__HIGHEST 22
+
+    /* Digests */
+
+#define OSSL_FUNC_DIGEST_NEWCTX 1
+#define OSSL_FUNC_DIGEST_INIT 2
+#define OSSL_FUNC_DIGEST_UPDATE 3
+#define OSSL_FUNC_DIGEST_FINAL 4
+#define OSSL_FUNC_DIGEST_DIGEST 5
+#define OSSL_FUNC_DIGEST_FREECTX 6
+#define OSSL_FUNC_DIGEST_DUPCTX 7
+#define OSSL_FUNC_DIGEST_GET_PARAMS 8
+#define OSSL_FUNC_DIGEST_SET_CTX_PARAMS 9
+#define OSSL_FUNC_DIGEST_GET_CTX_PARAMS 10
+#define OSSL_FUNC_DIGEST_GETTABLE_PARAMS 11
+#define OSSL_FUNC_DIGEST_SETTABLE_CTX_PARAMS 12
+#define OSSL_FUNC_DIGEST_GETTABLE_CTX_PARAMS 13
+
+    OSSL_CORE_MAKE_FUNC(void*, digest_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, digest_init, (void* dctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, digest_update, (void* dctx, const unsigned char* in, size_t inl))
+    OSSL_CORE_MAKE_FUNC(int, digest_final, (void* dctx, unsigned char* out, size_t* outl, size_t outsz))
+    OSSL_CORE_MAKE_FUNC(int, digest_digest, (void* provctx, const unsigned char* in, size_t inl, unsigned char* out, size_t* outl, size_t outsz))
+
+    OSSL_CORE_MAKE_FUNC(void, digest_freectx, (void* dctx))
+    OSSL_CORE_MAKE_FUNC(void*, digest_dupctx, (void* dctx))
+
+    OSSL_CORE_MAKE_FUNC(int, digest_get_params, (OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, digest_set_ctx_params, (void* vctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, digest_get_ctx_params, (void* vctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, digest_gettable_params, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, digest_settable_ctx_params, (void* dctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, digest_gettable_ctx_params, (void* dctx, void* provctx))
+
+    /* Symmetric Ciphers */
+
+#define OSSL_FUNC_CIPHER_NEWCTX 1
+#define OSSL_FUNC_CIPHER_ENCRYPT_INIT 2
+#define OSSL_FUNC_CIPHER_DECRYPT_INIT 3
+#define OSSL_FUNC_CIPHER_UPDATE 4
+#define OSSL_FUNC_CIPHER_FINAL 5
+#define OSSL_FUNC_CIPHER_CIPHER 6
+#define OSSL_FUNC_CIPHER_FREECTX 7
+#define OSSL_FUNC_CIPHER_DUPCTX 8
+#define OSSL_FUNC_CIPHER_GET_PARAMS 9
+#define OSSL_FUNC_CIPHER_GET_CTX_PARAMS 10
+#define OSSL_FUNC_CIPHER_SET_CTX_PARAMS 11
+#define OSSL_FUNC_CIPHER_GETTABLE_PARAMS 12
+#define OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS 13
+#define OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS 14
+
+    OSSL_CORE_MAKE_FUNC(void*, cipher_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, cipher_encrypt_init, (void* cctx, const unsigned char* key, size_t keylen, const unsigned char* iv, size_t ivlen, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, cipher_decrypt_init, (void* cctx, const unsigned char* key, size_t keylen, const unsigned char* iv, size_t ivlen, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, cipher_update, (void* cctx, unsigned char* out, size_t* outl, size_t outsize, const unsigned char* in, size_t inl))
+    OSSL_CORE_MAKE_FUNC(int, cipher_final, (void* cctx, unsigned char* out, size_t* outl, size_t outsize))
+    OSSL_CORE_MAKE_FUNC(int, cipher_cipher, (void* cctx, unsigned char* out, size_t* outl, size_t outsize, const unsigned char* in, size_t inl))
+    OSSL_CORE_MAKE_FUNC(void, cipher_freectx, (void* cctx))
+    OSSL_CORE_MAKE_FUNC(void*, cipher_dupctx, (void* cctx))
+    OSSL_CORE_MAKE_FUNC(int, cipher_get_params, (OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, cipher_get_ctx_params, (void* cctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, cipher_set_ctx_params, (void* cctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, cipher_gettable_params, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, cipher_settable_ctx_params, (void* cctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, cipher_gettable_ctx_params, (void* cctx, void* provctx))
+
+    /* MACs */
+
+#define OSSL_FUNC_MAC_NEWCTX 1
+#define OSSL_FUNC_MAC_DUPCTX 2
+#define OSSL_FUNC_MAC_FREECTX 3
+#define OSSL_FUNC_MAC_INIT 4
+#define OSSL_FUNC_MAC_UPDATE 5
+#define OSSL_FUNC_MAC_FINAL 6
+#define OSSL_FUNC_MAC_GET_PARAMS 7
+#define OSSL_FUNC_MAC_GET_CTX_PARAMS 8
+#define OSSL_FUNC_MAC_SET_CTX_PARAMS 9
+#define OSSL_FUNC_MAC_GETTABLE_PARAMS 10
+#define OSSL_FUNC_MAC_GETTABLE_CTX_PARAMS 11
+#define OSSL_FUNC_MAC_SETTABLE_CTX_PARAMS 12
+
+    OSSL_CORE_MAKE_FUNC(void*, mac_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(void*, mac_dupctx, (void* src))
+    OSSL_CORE_MAKE_FUNC(void, mac_freectx, (void* mctx))
+    OSSL_CORE_MAKE_FUNC(int, mac_init, (void* mctx, const unsigned char* key, size_t keylen, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, mac_update, (void* mctx, const unsigned char* in, size_t inl))
+    OSSL_CORE_MAKE_FUNC(int, mac_final, (void* mctx, unsigned char* out, size_t* outl, size_t outsize))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, mac_gettable_params, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, mac_gettable_ctx_params, (void* mctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, mac_settable_ctx_params, (void* mctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, mac_get_params, (OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, mac_get_ctx_params, (void* mctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, mac_set_ctx_params, (void* mctx, const OSSL_PARAM params[]))
+
+    /* KDFs and PRFs */
+
+#define OSSL_FUNC_KDF_NEWCTX 1
+#define OSSL_FUNC_KDF_DUPCTX 2
+#define OSSL_FUNC_KDF_FREECTX 3
+#define OSSL_FUNC_KDF_RESET 4
+#define OSSL_FUNC_KDF_DERIVE 5
+#define OSSL_FUNC_KDF_GETTABLE_PARAMS 6
+#define OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS 7
+#define OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS 8
+#define OSSL_FUNC_KDF_GET_PARAMS 9
+#define OSSL_FUNC_KDF_GET_CTX_PARAMS 10
+#define OSSL_FUNC_KDF_SET_CTX_PARAMS 11
+
+    OSSL_CORE_MAKE_FUNC(void*, kdf_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(void*, kdf_dupctx, (void* src))
+    OSSL_CORE_MAKE_FUNC(void, kdf_freectx, (void* kctx))
+    OSSL_CORE_MAKE_FUNC(void, kdf_reset, (void* kctx))
+    OSSL_CORE_MAKE_FUNC(int, kdf_derive, (void* kctx, unsigned char* key, size_t keylen, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, kdf_gettable_params, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, kdf_gettable_ctx_params, (void* kctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, kdf_settable_ctx_params, (void* kctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, kdf_get_params, (OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, kdf_get_ctx_params, (void* kctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, kdf_set_ctx_params, (void* kctx, const OSSL_PARAM params[]))
+
+    /* RAND */
+
+#define OSSL_FUNC_RAND_NEWCTX 1
+#define OSSL_FUNC_RAND_FREECTX 2
+#define OSSL_FUNC_RAND_INSTANTIATE 3
+#define OSSL_FUNC_RAND_UNINSTANTIATE 4
+#define OSSL_FUNC_RAND_GENERATE 5
+#define OSSL_FUNC_RAND_RESEED 6
+#define OSSL_FUNC_RAND_NONCE 7
+#define OSSL_FUNC_RAND_ENABLE_LOCKING 8
+#define OSSL_FUNC_RAND_LOCK 9
+#define OSSL_FUNC_RAND_UNLOCK 10
+#define OSSL_FUNC_RAND_GETTABLE_PARAMS 11
+#define OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS 12
+#define OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS 13
+#define OSSL_FUNC_RAND_GET_PARAMS 14
+#define OSSL_FUNC_RAND_GET_CTX_PARAMS 15
+#define OSSL_FUNC_RAND_SET_CTX_PARAMS 16
+#define OSSL_FUNC_RAND_VERIFY_ZEROIZATION 17
+#define OSSL_FUNC_RAND_GET_SEED 18
+#define OSSL_FUNC_RAND_CLEAR_SEED 19
+
+    OSSL_CORE_MAKE_FUNC(void*, rand_newctx, (void* provctx, void* parent, const OSSL_DISPATCH* parent_calls))
+    OSSL_CORE_MAKE_FUNC(void, rand_freectx, (void* vctx))
+    OSSL_CORE_MAKE_FUNC(int, rand_instantiate, (void* vdrbg, unsigned int strength, int prediction_resistance, const unsigned char* pstr, size_t pstr_len, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, rand_uninstantiate, (void* vdrbg))
+    OSSL_CORE_MAKE_FUNC(int, rand_generate, (void* vctx, unsigned char* out, size_t outlen, unsigned int strength, int prediction_resistance, const unsigned char* addin, size_t addin_len))
+    OSSL_CORE_MAKE_FUNC(int, rand_reseed, (void* vctx, int prediction_resistance, const unsigned char* ent, size_t ent_len, const unsigned char* addin, size_t addin_len))
+    OSSL_CORE_MAKE_FUNC(size_t, rand_nonce, (void* vctx, unsigned char* out, unsigned int strength, size_t min_noncelen, size_t max_noncelen))
+    OSSL_CORE_MAKE_FUNC(int, rand_enable_locking, (void* vctx))
+    OSSL_CORE_MAKE_FUNC(int, rand_lock, (void* vctx))
+    OSSL_CORE_MAKE_FUNC(void, rand_unlock, (void* vctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, rand_gettable_params, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, rand_gettable_ctx_params, (void* vctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, rand_settable_ctx_params, (void* vctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, rand_get_params, (OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, rand_get_ctx_params, (void* vctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, rand_set_ctx_params, (void* vctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(void, rand_set_callbacks, (void* vctx, OSSL_INOUT_CALLBACK* get_entropy, OSSL_CALLBACK* cleanup_entropy, OSSL_INOUT_CALLBACK* get_nonce, OSSL_CALLBACK* cleanup_nonce, void* arg))
+    OSSL_CORE_MAKE_FUNC(int, rand_verify_zeroization, (void* vctx))
+    OSSL_CORE_MAKE_FUNC(size_t, rand_get_seed, (void* vctx, unsigned char** buffer, int entropy, size_t min_len, size_t max_len, int prediction_resistance, const unsigned char* adin, size_t adin_len))
+    OSSL_CORE_MAKE_FUNC(void, rand_clear_seed, (void* vctx, unsigned char* buffer, size_t b_len))
 
 /*-
  * Key management
@@ -539,405 +405,293 @@ OSSL_CORE_MAKE_FUNC(void,rand_clear_seed,
  */
 
 /* Key data subset selection - individual bits */
-# define OSSL_KEYMGMT_SELECT_PRIVATE_KEY            0x01
-# define OSSL_KEYMGMT_SELECT_PUBLIC_KEY             0x02
-# define OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS      0x04
-# define OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS       0x80
+#define OSSL_KEYMGMT_SELECT_PRIVATE_KEY 0x01
+#define OSSL_KEYMGMT_SELECT_PUBLIC_KEY 0x02
+#define OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS 0x04
+#define OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS 0x80
 
 /* Key data subset selection - combinations */
-# define OSSL_KEYMGMT_SELECT_ALL_PARAMETERS     \
-    ( OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS     \
-      | OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS)
-# define OSSL_KEYMGMT_SELECT_KEYPAIR            \
-    ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY | OSSL_KEYMGMT_SELECT_PUBLIC_KEY )
-# define OSSL_KEYMGMT_SELECT_ALL                \
-    ( OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS )
+#define OSSL_KEYMGMT_SELECT_ALL_PARAMETERS \
+    (OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS | OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS)
+#define OSSL_KEYMGMT_SELECT_KEYPAIR \
+    (OSSL_KEYMGMT_SELECT_PRIVATE_KEY | OSSL_KEYMGMT_SELECT_PUBLIC_KEY)
+#define OSSL_KEYMGMT_SELECT_ALL \
+    (OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
 
-# define OSSL_KEYMGMT_VALIDATE_FULL_CHECK              0
-# define OSSL_KEYMGMT_VALIDATE_QUICK_CHECK             1
+#define OSSL_KEYMGMT_VALIDATE_FULL_CHECK 0
+#define OSSL_KEYMGMT_VALIDATE_QUICK_CHECK 1
 
 /* Basic key object creation */
-# define OSSL_FUNC_KEYMGMT_NEW                         1
-OSSL_CORE_MAKE_FUNC(void *, keymgmt_new, (void *provctx))
+#define OSSL_FUNC_KEYMGMT_NEW 1
+    OSSL_CORE_MAKE_FUNC(void*, keymgmt_new, (void* provctx))
 
 /* Generation, a more complex constructor */
-# define OSSL_FUNC_KEYMGMT_GEN_INIT                    2
-# define OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE            3
-# define OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS              4
-# define OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS         5
-# define OSSL_FUNC_KEYMGMT_GEN                         6
-# define OSSL_FUNC_KEYMGMT_GEN_CLEANUP                 7
-OSSL_CORE_MAKE_FUNC(void *, keymgmt_gen_init,
-                    (void *provctx, int selection, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_template,
-                    (void *genctx, void *templ))
-OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_params,
-                    (void *genctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
-                    keymgmt_gen_settable_params,
-                    (void *genctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(void *, keymgmt_gen,
-                    (void *genctx, OSSL_CALLBACK *cb, void *cbarg))
-OSSL_CORE_MAKE_FUNC(void, keymgmt_gen_cleanup, (void *genctx))
+#define OSSL_FUNC_KEYMGMT_GEN_INIT 2
+#define OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE 3
+#define OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS 4
+#define OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS 5
+#define OSSL_FUNC_KEYMGMT_GEN 6
+#define OSSL_FUNC_KEYMGMT_GEN_CLEANUP 7
+    OSSL_CORE_MAKE_FUNC(void*, keymgmt_gen_init, (void* provctx, int selection, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_template, (void* genctx, void* templ))
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_gen_set_params, (void* genctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, keymgmt_gen_settable_params, (void* genctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(void*, keymgmt_gen, (void* genctx, OSSL_CALLBACK* cb, void* cbarg))
+    OSSL_CORE_MAKE_FUNC(void, keymgmt_gen_cleanup, (void* genctx))
 
 /* Key loading by object reference */
-# define OSSL_FUNC_KEYMGMT_LOAD                        8
-OSSL_CORE_MAKE_FUNC(void *, keymgmt_load,
-                    (const void *reference, size_t reference_sz))
+#define OSSL_FUNC_KEYMGMT_LOAD 8
+    OSSL_CORE_MAKE_FUNC(void*, keymgmt_load, (const void* reference, size_t reference_sz))
 
 /* Basic key object destruction */
-# define OSSL_FUNC_KEYMGMT_FREE                       10
-OSSL_CORE_MAKE_FUNC(void, keymgmt_free, (void *keydata))
+#define OSSL_FUNC_KEYMGMT_FREE 10
+    OSSL_CORE_MAKE_FUNC(void, keymgmt_free, (void* keydata))
 
 /* Key object information, with discovery */
-#define OSSL_FUNC_KEYMGMT_GET_PARAMS                  11
-#define OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS             12
-OSSL_CORE_MAKE_FUNC(int, keymgmt_get_params,
-                    (void *keydata, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_gettable_params,
-                    (void *provctx))
-
-#define OSSL_FUNC_KEYMGMT_SET_PARAMS                  13
-#define OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS             14
-OSSL_CORE_MAKE_FUNC(int, keymgmt_set_params,
-                    (void *keydata, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_settable_params,
-                    (void *provctx))
+#define OSSL_FUNC_KEYMGMT_GET_PARAMS 11
+#define OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS 12
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_get_params, (void* keydata, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, keymgmt_gettable_params, (void* provctx))
+
+#define OSSL_FUNC_KEYMGMT_SET_PARAMS 13
+#define OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS 14
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_set_params, (void* keydata, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, keymgmt_settable_params, (void* provctx))
 
 /* Key checks - discovery of supported operations */
-# define OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME       20
-OSSL_CORE_MAKE_FUNC(const char *, keymgmt_query_operation_name,
-                    (int operation_id))
+#define OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME 20
+    OSSL_CORE_MAKE_FUNC(const char*, keymgmt_query_operation_name, (int operation_id))
 
 /* Key checks - key data content checks */
-# define OSSL_FUNC_KEYMGMT_HAS                        21
-OSSL_CORE_MAKE_FUNC(int, keymgmt_has, (const void *keydata, int selection))
+#define OSSL_FUNC_KEYMGMT_HAS 21
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_has, (const void* keydata, int selection))
 
 /* Key checks - validation */
-# define OSSL_FUNC_KEYMGMT_VALIDATE                   22
-OSSL_CORE_MAKE_FUNC(int, keymgmt_validate, (const void *keydata, int selection,
-                                            int checktype))
+#define OSSL_FUNC_KEYMGMT_VALIDATE 22
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_validate, (const void* keydata, int selection, int checktype))
 
 /* Key checks - matching */
-# define OSSL_FUNC_KEYMGMT_MATCH                      23
-OSSL_CORE_MAKE_FUNC(int, keymgmt_match,
-                    (const void *keydata1, const void *keydata2,
-                     int selection))
+#define OSSL_FUNC_KEYMGMT_MATCH 23
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_match, (const void* keydata1, const void* keydata2, int selection))
 
 /* Import and export functions, with discovery */
-# define OSSL_FUNC_KEYMGMT_IMPORT                     40
-# define OSSL_FUNC_KEYMGMT_IMPORT_TYPES               41
-# define OSSL_FUNC_KEYMGMT_EXPORT                     42
-# define OSSL_FUNC_KEYMGMT_EXPORT_TYPES               43
-OSSL_CORE_MAKE_FUNC(int, keymgmt_import,
-                    (void *keydata, int selection, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_import_types,
-                    (int selection))
-OSSL_CORE_MAKE_FUNC(int, keymgmt_export,
-                    (void *keydata, int selection,
-                     OSSL_CALLBACK *param_cb, void *cbarg))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keymgmt_export_types,
-                    (int selection))
+#define OSSL_FUNC_KEYMGMT_IMPORT 40
+#define OSSL_FUNC_KEYMGMT_IMPORT_TYPES 41
+#define OSSL_FUNC_KEYMGMT_EXPORT 42
+#define OSSL_FUNC_KEYMGMT_EXPORT_TYPES 43
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_import, (void* keydata, int selection, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, keymgmt_import_types, (int selection))
+    OSSL_CORE_MAKE_FUNC(int, keymgmt_export, (void* keydata, int selection, OSSL_CALLBACK* param_cb, void* cbarg))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, keymgmt_export_types, (int selection))
 
 /* Dup function, constructor */
-# define OSSL_FUNC_KEYMGMT_DUP                        44
-OSSL_CORE_MAKE_FUNC(void *, keymgmt_dup,
-                    (const void *keydata_from, int selection))
-
-/* Key Exchange */
-
-# define OSSL_FUNC_KEYEXCH_NEWCTX                      1
-# define OSSL_FUNC_KEYEXCH_INIT                        2
-# define OSSL_FUNC_KEYEXCH_DERIVE                      3
-# define OSSL_FUNC_KEYEXCH_SET_PEER                    4
-# define OSSL_FUNC_KEYEXCH_FREECTX                     5
-# define OSSL_FUNC_KEYEXCH_DUPCTX                      6
-# define OSSL_FUNC_KEYEXCH_SET_CTX_PARAMS              7
-# define OSSL_FUNC_KEYEXCH_SETTABLE_CTX_PARAMS         8
-# define OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS              9
-# define OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS        10
-
-OSSL_CORE_MAKE_FUNC(void *, keyexch_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(int, keyexch_init, (void *ctx, void *provkey,
-                                        const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, keyexch_derive, (void *ctx,  unsigned char *secret,
-                                             size_t *secretlen, size_t outlen))
-OSSL_CORE_MAKE_FUNC(int, keyexch_set_peer, (void *ctx, void *provkey))
-OSSL_CORE_MAKE_FUNC(void, keyexch_freectx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(void *, keyexch_dupctx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(int, keyexch_set_ctx_params, (void *ctx,
-                                                     const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keyexch_settable_ctx_params,
-                    (void *ctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(int, keyexch_get_ctx_params, (void *ctx,
-                                                     OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, keyexch_gettable_ctx_params,
-                    (void *ctx, void *provctx))
-
-/* Signature */
-
-# define OSSL_FUNC_SIGNATURE_NEWCTX                  1
-# define OSSL_FUNC_SIGNATURE_SIGN_INIT               2
-# define OSSL_FUNC_SIGNATURE_SIGN                    3
-# define OSSL_FUNC_SIGNATURE_VERIFY_INIT             4
-# define OSSL_FUNC_SIGNATURE_VERIFY                  5
-# define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT     6
-# define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER          7
-# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT        8
-# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE      9
-# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL      10
-# define OSSL_FUNC_SIGNATURE_DIGEST_SIGN            11
-# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT     12
-# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE   13
-# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL    14
-# define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY          15
-# define OSSL_FUNC_SIGNATURE_FREECTX                16
-# define OSSL_FUNC_SIGNATURE_DUPCTX                 17
-# define OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS         18
-# define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS    19
-# define OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS         20
-# define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS    21
-# define OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS      22
-# define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS 23
-# define OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS      24
-# define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS 25
-
-OSSL_CORE_MAKE_FUNC(void *, signature_newctx, (void *provctx,
-                                                  const char *propq))
-OSSL_CORE_MAKE_FUNC(int, signature_sign_init, (void *ctx, void *provkey,
-                                               const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, signature_sign, (void *ctx,  unsigned char *sig,
-                                             size_t *siglen, size_t sigsize,
-                                             const unsigned char *tbs,
-                                             size_t tbslen))
-OSSL_CORE_MAKE_FUNC(int, signature_verify_init, (void *ctx, void *provkey,
-                                                 const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, signature_verify, (void *ctx,
-                                               const unsigned char *sig,
-                                               size_t siglen,
-                                               const unsigned char *tbs,
-                                               size_t tbslen))
-OSSL_CORE_MAKE_FUNC(int, signature_verify_recover_init,
-                    (void *ctx, void *provkey, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, signature_verify_recover,
-                    (void *ctx, unsigned char *rout, size_t *routlen,
-                     size_t routsize, const unsigned char *sig, size_t siglen))
-OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_init,
-                    (void *ctx, const char *mdname, void *provkey,
-                     const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_update,
-                    (void *ctx, const unsigned char *data, size_t datalen))
-OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_final,
-                    (void *ctx, unsigned char *sig, size_t *siglen,
-                     size_t sigsize))
-OSSL_CORE_MAKE_FUNC(int, signature_digest_sign,
-                    (void *ctx, unsigned char *sigret, size_t *siglen,
-                     size_t sigsize, const unsigned char *tbs, size_t tbslen))
-OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_init,
-                    (void *ctx, const char *mdname, void *provkey,
-                     const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_update,
-                    (void *ctx, const unsigned char *data, size_t datalen))
-OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_final,
-                    (void *ctx, const unsigned char *sig, size_t siglen))
-OSSL_CORE_MAKE_FUNC(int, signature_digest_verify,
-                    (void *ctx, const unsigned char *sig, size_t siglen,
-                     const unsigned char *tbs, size_t tbslen))
-OSSL_CORE_MAKE_FUNC(void, signature_freectx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(void *, signature_dupctx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_params,
-                    (void *ctx, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_gettable_ctx_params,
-                    (void *ctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_params,
-                    (void *ctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_settable_ctx_params,
-                    (void *ctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_md_params,
-                    (void *ctx, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_gettable_ctx_md_params,
-                    (void *ctx))
-OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_md_params,
-                    (void *ctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, signature_settable_ctx_md_params,
-                    (void *ctx))
-
-
-/* Asymmetric Ciphers */
-
-# define OSSL_FUNC_ASYM_CIPHER_NEWCTX                  1
-# define OSSL_FUNC_ASYM_CIPHER_ENCRYPT_INIT            2
-# define OSSL_FUNC_ASYM_CIPHER_ENCRYPT                 3
-# define OSSL_FUNC_ASYM_CIPHER_DECRYPT_INIT            4
-# define OSSL_FUNC_ASYM_CIPHER_DECRYPT                 5
-# define OSSL_FUNC_ASYM_CIPHER_FREECTX                 6
-# define OSSL_FUNC_ASYM_CIPHER_DUPCTX                  7
-# define OSSL_FUNC_ASYM_CIPHER_GET_CTX_PARAMS          8
-# define OSSL_FUNC_ASYM_CIPHER_GETTABLE_CTX_PARAMS     9
-# define OSSL_FUNC_ASYM_CIPHER_SET_CTX_PARAMS         10
-# define OSSL_FUNC_ASYM_CIPHER_SETTABLE_CTX_PARAMS    11
-
-OSSL_CORE_MAKE_FUNC(void *, asym_cipher_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt_init, (void *ctx, void *provkey,
-                                                    const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt, (void *ctx, unsigned char *out,
-                                                  size_t *outlen,
-                                                  size_t outsize,
-                                                  const unsigned char *in,
-                                                  size_t inlen))
-OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt_init, (void *ctx, void *provkey,
-                                                    const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt, (void *ctx, unsigned char *out,
-                                                  size_t *outlen,
-                                                  size_t outsize,
-                                                  const unsigned char *in,
-                                                  size_t inlen))
-OSSL_CORE_MAKE_FUNC(void, asym_cipher_freectx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(void *, asym_cipher_dupctx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(int, asym_cipher_get_ctx_params,
-                    (void *ctx, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, asym_cipher_gettable_ctx_params,
-                    (void *ctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(int, asym_cipher_set_ctx_params,
-                    (void *ctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, asym_cipher_settable_ctx_params,
-                    (void *ctx, void *provctx))
+#define OSSL_FUNC_KEYMGMT_DUP 44
+    OSSL_CORE_MAKE_FUNC(void*, keymgmt_dup, (const void* keydata_from, int selection))
+
+    /* Key Exchange */
+
+#define OSSL_FUNC_KEYEXCH_NEWCTX 1
+#define OSSL_FUNC_KEYEXCH_INIT 2
+#define OSSL_FUNC_KEYEXCH_DERIVE 3
+#define OSSL_FUNC_KEYEXCH_SET_PEER 4
+#define OSSL_FUNC_KEYEXCH_FREECTX 5
+#define OSSL_FUNC_KEYEXCH_DUPCTX 6
+#define OSSL_FUNC_KEYEXCH_SET_CTX_PARAMS 7
+#define OSSL_FUNC_KEYEXCH_SETTABLE_CTX_PARAMS 8
+#define OSSL_FUNC_KEYEXCH_GET_CTX_PARAMS 9
+#define OSSL_FUNC_KEYEXCH_GETTABLE_CTX_PARAMS 10
+
+    OSSL_CORE_MAKE_FUNC(void*, keyexch_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, keyexch_init, (void* ctx, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, keyexch_derive, (void* ctx, unsigned char* secret, size_t* secretlen, size_t outlen))
+    OSSL_CORE_MAKE_FUNC(int, keyexch_set_peer, (void* ctx, void* provkey))
+    OSSL_CORE_MAKE_FUNC(void, keyexch_freectx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(void*, keyexch_dupctx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(int, keyexch_set_ctx_params, (void* ctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, keyexch_settable_ctx_params, (void* ctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, keyexch_get_ctx_params, (void* ctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, keyexch_gettable_ctx_params, (void* ctx, void* provctx))
+
+    /* Signature */
+
+#define OSSL_FUNC_SIGNATURE_NEWCTX 1
+#define OSSL_FUNC_SIGNATURE_SIGN_INIT 2
+#define OSSL_FUNC_SIGNATURE_SIGN 3
+#define OSSL_FUNC_SIGNATURE_VERIFY_INIT 4
+#define OSSL_FUNC_SIGNATURE_VERIFY 5
+#define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER_INIT 6
+#define OSSL_FUNC_SIGNATURE_VERIFY_RECOVER 7
+#define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT 8
+#define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE 9
+#define OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL 10
+#define OSSL_FUNC_SIGNATURE_DIGEST_SIGN 11
+#define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT 12
+#define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE 13
+#define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL 14
+#define OSSL_FUNC_SIGNATURE_DIGEST_VERIFY 15
+#define OSSL_FUNC_SIGNATURE_FREECTX 16
+#define OSSL_FUNC_SIGNATURE_DUPCTX 17
+#define OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS 18
+#define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS 19
+#define OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS 20
+#define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS 21
+#define OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS 22
+#define OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS 23
+#define OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS 24
+#define OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS 25
+
+    OSSL_CORE_MAKE_FUNC(void*, signature_newctx, (void* provctx, const char* propq))
+    OSSL_CORE_MAKE_FUNC(int, signature_sign_init, (void* ctx, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, signature_sign, (void* ctx, unsigned char* sig, size_t* siglen, size_t sigsize, const unsigned char* tbs, size_t tbslen))
+    OSSL_CORE_MAKE_FUNC(int, signature_verify_init, (void* ctx, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, signature_verify, (void* ctx, const unsigned char* sig, size_t siglen, const unsigned char* tbs, size_t tbslen))
+    OSSL_CORE_MAKE_FUNC(int, signature_verify_recover_init, (void* ctx, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, signature_verify_recover, (void* ctx, unsigned char* rout, size_t* routlen, size_t routsize, const unsigned char* sig, size_t siglen))
+    OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_init, (void* ctx, const char* mdname, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_update, (void* ctx, const unsigned char* data, size_t datalen))
+    OSSL_CORE_MAKE_FUNC(int, signature_digest_sign_final, (void* ctx, unsigned char* sig, size_t* siglen, size_t sigsize))
+    OSSL_CORE_MAKE_FUNC(int, signature_digest_sign, (void* ctx, unsigned char* sigret, size_t* siglen, size_t sigsize, const unsigned char* tbs, size_t tbslen))
+    OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_init, (void* ctx, const char* mdname, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_update, (void* ctx, const unsigned char* data, size_t datalen))
+    OSSL_CORE_MAKE_FUNC(int, signature_digest_verify_final, (void* ctx, const unsigned char* sig, size_t siglen))
+    OSSL_CORE_MAKE_FUNC(int, signature_digest_verify, (void* ctx, const unsigned char* sig, size_t siglen, const unsigned char* tbs, size_t tbslen))
+    OSSL_CORE_MAKE_FUNC(void, signature_freectx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(void*, signature_dupctx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_params, (void* ctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, signature_gettable_ctx_params, (void* ctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_params, (void* ctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, signature_settable_ctx_params, (void* ctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, signature_get_ctx_md_params, (void* ctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, signature_gettable_ctx_md_params, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(int, signature_set_ctx_md_params, (void* ctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, signature_settable_ctx_md_params, (void* ctx))
+
+    /* Asymmetric Ciphers */
+
+#define OSSL_FUNC_ASYM_CIPHER_NEWCTX 1
+#define OSSL_FUNC_ASYM_CIPHER_ENCRYPT_INIT 2
+#define OSSL_FUNC_ASYM_CIPHER_ENCRYPT 3
+#define OSSL_FUNC_ASYM_CIPHER_DECRYPT_INIT 4
+#define OSSL_FUNC_ASYM_CIPHER_DECRYPT 5
+#define OSSL_FUNC_ASYM_CIPHER_FREECTX 6
+#define OSSL_FUNC_ASYM_CIPHER_DUPCTX 7
+#define OSSL_FUNC_ASYM_CIPHER_GET_CTX_PARAMS 8
+#define OSSL_FUNC_ASYM_CIPHER_GETTABLE_CTX_PARAMS 9
+#define OSSL_FUNC_ASYM_CIPHER_SET_CTX_PARAMS 10
+#define OSSL_FUNC_ASYM_CIPHER_SETTABLE_CTX_PARAMS 11
+
+    OSSL_CORE_MAKE_FUNC(void*, asym_cipher_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt_init, (void* ctx, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, asym_cipher_encrypt, (void* ctx, unsigned char* out, size_t* outlen, size_t outsize, const unsigned char* in, size_t inlen))
+    OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt_init, (void* ctx, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, asym_cipher_decrypt, (void* ctx, unsigned char* out, size_t* outlen, size_t outsize, const unsigned char* in, size_t inlen))
+    OSSL_CORE_MAKE_FUNC(void, asym_cipher_freectx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(void*, asym_cipher_dupctx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(int, asym_cipher_get_ctx_params, (void* ctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, asym_cipher_gettable_ctx_params, (void* ctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, asym_cipher_set_ctx_params, (void* ctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, asym_cipher_settable_ctx_params, (void* ctx, void* provctx))
 
 /* Asymmetric Key encapsulation */
-# define OSSL_FUNC_KEM_NEWCTX                  1
-# define OSSL_FUNC_KEM_ENCAPSULATE_INIT        2
-# define OSSL_FUNC_KEM_ENCAPSULATE             3
-# define OSSL_FUNC_KEM_DECAPSULATE_INIT        4
-# define OSSL_FUNC_KEM_DECAPSULATE             5
-# define OSSL_FUNC_KEM_FREECTX                 6
-# define OSSL_FUNC_KEM_DUPCTX                  7
-# define OSSL_FUNC_KEM_GET_CTX_PARAMS          8
-# define OSSL_FUNC_KEM_GETTABLE_CTX_PARAMS     9
-# define OSSL_FUNC_KEM_SET_CTX_PARAMS         10
-# define OSSL_FUNC_KEM_SETTABLE_CTX_PARAMS    11
-
-OSSL_CORE_MAKE_FUNC(void *, kem_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(int, kem_encapsulate_init, (void *ctx, void *provkey,
-                                                const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, kem_encapsulate, (void *ctx,
-                                           unsigned char *out, size_t *outlen,
-                                           unsigned char *secret,
-                                           size_t *secretlen))
-OSSL_CORE_MAKE_FUNC(int, kem_decapsulate_init, (void *ctx, void *provkey,
-                                                const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, kem_decapsulate, (void *ctx,
-                                           unsigned char *out, size_t *outlen,
-                                           const unsigned char *in, size_t inlen))
-OSSL_CORE_MAKE_FUNC(void, kem_freectx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(void *, kem_dupctx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(int, kem_get_ctx_params, (void *ctx, OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kem_gettable_ctx_params,
-                    (void *ctx, void *provctx))
-OSSL_CORE_MAKE_FUNC(int, kem_set_ctx_params,
-                    (void *ctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, kem_settable_ctx_params,
-                    (void *ctx, void *provctx))
+#define OSSL_FUNC_KEM_NEWCTX 1
+#define OSSL_FUNC_KEM_ENCAPSULATE_INIT 2
+#define OSSL_FUNC_KEM_ENCAPSULATE 3
+#define OSSL_FUNC_KEM_DECAPSULATE_INIT 4
+#define OSSL_FUNC_KEM_DECAPSULATE 5
+#define OSSL_FUNC_KEM_FREECTX 6
+#define OSSL_FUNC_KEM_DUPCTX 7
+#define OSSL_FUNC_KEM_GET_CTX_PARAMS 8
+#define OSSL_FUNC_KEM_GETTABLE_CTX_PARAMS 9
+#define OSSL_FUNC_KEM_SET_CTX_PARAMS 10
+#define OSSL_FUNC_KEM_SETTABLE_CTX_PARAMS 11
+
+    OSSL_CORE_MAKE_FUNC(void*, kem_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, kem_encapsulate_init, (void* ctx, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, kem_encapsulate, (void* ctx, unsigned char* out, size_t* outlen, unsigned char* secret, size_t* secretlen))
+    OSSL_CORE_MAKE_FUNC(int, kem_decapsulate_init, (void* ctx, void* provkey, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, kem_decapsulate, (void* ctx, unsigned char* out, size_t* outlen, const unsigned char* in, size_t inlen))
+    OSSL_CORE_MAKE_FUNC(void, kem_freectx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(void*, kem_dupctx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(int, kem_get_ctx_params, (void* ctx, OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, kem_gettable_ctx_params, (void* ctx, void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, kem_set_ctx_params, (void* ctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, kem_settable_ctx_params, (void* ctx, void* provctx))
 
 /* Encoders and decoders */
-# define OSSL_FUNC_ENCODER_NEWCTX                      1
-# define OSSL_FUNC_ENCODER_FREECTX                     2
-# define OSSL_FUNC_ENCODER_GET_PARAMS                  3
-# define OSSL_FUNC_ENCODER_GETTABLE_PARAMS             4
-# define OSSL_FUNC_ENCODER_SET_CTX_PARAMS              5
-# define OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS         6
-# define OSSL_FUNC_ENCODER_DOES_SELECTION             10
-# define OSSL_FUNC_ENCODER_ENCODE                     11
-# define OSSL_FUNC_ENCODER_IMPORT_OBJECT              20
-# define OSSL_FUNC_ENCODER_FREE_OBJECT                21
-OSSL_CORE_MAKE_FUNC(void *, encoder_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(void, encoder_freectx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(int, encoder_get_params, (OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, encoder_gettable_params,
-                    (void *provctx))
-OSSL_CORE_MAKE_FUNC(int, encoder_set_ctx_params,
-                    (void *ctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, encoder_settable_ctx_params,
-                    (void *provctx))
-
-OSSL_CORE_MAKE_FUNC(int, encoder_does_selection,
-                    (void *provctx, int selection))
-OSSL_CORE_MAKE_FUNC(int, encoder_encode,
-                    (void *ctx, OSSL_CORE_BIO *out,
-                     const void *obj_raw, const OSSL_PARAM obj_abstract[],
-                     int selection,
-                     OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg))
-
-OSSL_CORE_MAKE_FUNC(void *, encoder_import_object,
-                    (void *ctx, int selection, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(void, encoder_free_object, (void *obj))
-
-# define OSSL_FUNC_DECODER_NEWCTX                      1
-# define OSSL_FUNC_DECODER_FREECTX                     2
-# define OSSL_FUNC_DECODER_GET_PARAMS                  3
-# define OSSL_FUNC_DECODER_GETTABLE_PARAMS             4
-# define OSSL_FUNC_DECODER_SET_CTX_PARAMS              5
-# define OSSL_FUNC_DECODER_SETTABLE_CTX_PARAMS         6
-# define OSSL_FUNC_DECODER_DOES_SELECTION             10
-# define OSSL_FUNC_DECODER_DECODE                     11
-# define OSSL_FUNC_DECODER_EXPORT_OBJECT              20
-OSSL_CORE_MAKE_FUNC(void *, decoder_newctx, (void *provctx))
-OSSL_CORE_MAKE_FUNC(void, decoder_freectx, (void *ctx))
-OSSL_CORE_MAKE_FUNC(int, decoder_get_params, (OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, decoder_gettable_params,
-                    (void *provctx))
-OSSL_CORE_MAKE_FUNC(int, decoder_set_ctx_params,
-                    (void *ctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, decoder_settable_ctx_params,
-                    (void *provctx))
-
-OSSL_CORE_MAKE_FUNC(int, decoder_does_selection,
-                    (void *provctx, int selection))
-OSSL_CORE_MAKE_FUNC(int, decoder_decode,
-                    (void *ctx, OSSL_CORE_BIO *in, int selection,
-                     OSSL_CALLBACK *data_cb, void *data_cbarg,
-                     OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
-OSSL_CORE_MAKE_FUNC(int, decoder_export_object,
-                    (void *ctx, const void *objref, size_t objref_sz,
-                     OSSL_CALLBACK *export_cb, void *export_cbarg))
-
-/*-
- * Store
- *
- * Objects are scanned by using the 'open', 'load', 'eof' and 'close'
- * functions, which implement an OSSL_STORE loader.
- *
- * store_load() works in a way that's very similar to the decoders, in
- * that they pass an abstract object through a callback, either as a DER
- * octet string or as an object reference, which libcrypto will have to
- * deal with.
- */
-
-#define OSSL_FUNC_STORE_OPEN                        1
-#define OSSL_FUNC_STORE_ATTACH                      2
-#define OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS         3
-#define OSSL_FUNC_STORE_SET_CTX_PARAMS              4
-#define OSSL_FUNC_STORE_LOAD                        5
-#define OSSL_FUNC_STORE_EOF                         6
-#define OSSL_FUNC_STORE_CLOSE                       7
-#define OSSL_FUNC_STORE_EXPORT_OBJECT               8
-OSSL_CORE_MAKE_FUNC(void *, store_open, (void *provctx, const char *uri))
-OSSL_CORE_MAKE_FUNC(void *, store_attach, (void *provctx, OSSL_CORE_BIO *in))
-OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *, store_settable_ctx_params,
-                    (void *provctx))
-OSSL_CORE_MAKE_FUNC(int, store_set_ctx_params,
-                    (void *loaderctx, const OSSL_PARAM params[]))
-OSSL_CORE_MAKE_FUNC(int, store_load,
-                    (void *loaderctx,
-                     OSSL_CALLBACK *object_cb, void *object_cbarg,
-                     OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg))
-OSSL_CORE_MAKE_FUNC(int, store_eof, (void *loaderctx))
-OSSL_CORE_MAKE_FUNC(int, store_close, (void *loaderctx))
-OSSL_CORE_MAKE_FUNC(int, store_export_object,
-                    (void *loaderctx, const void *objref, size_t objref_sz,
-                     OSSL_CALLBACK *export_cb, void *export_cbarg))
-
-# ifdef __cplusplus
+#define OSSL_FUNC_ENCODER_NEWCTX 1
+#define OSSL_FUNC_ENCODER_FREECTX 2
+#define OSSL_FUNC_ENCODER_GET_PARAMS 3
+#define OSSL_FUNC_ENCODER_GETTABLE_PARAMS 4
+#define OSSL_FUNC_ENCODER_SET_CTX_PARAMS 5
+#define OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS 6
+#define OSSL_FUNC_ENCODER_DOES_SELECTION 10
+#define OSSL_FUNC_ENCODER_ENCODE 11
+#define OSSL_FUNC_ENCODER_IMPORT_OBJECT 20
+#define OSSL_FUNC_ENCODER_FREE_OBJECT 21
+    OSSL_CORE_MAKE_FUNC(void*, encoder_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(void, encoder_freectx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(int, encoder_get_params, (OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, encoder_gettable_params, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, encoder_set_ctx_params, (void* ctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, encoder_settable_ctx_params, (void* provctx))
+
+    OSSL_CORE_MAKE_FUNC(int, encoder_does_selection, (void* provctx, int selection))
+    OSSL_CORE_MAKE_FUNC(int, encoder_encode, (void* ctx, OSSL_CORE_BIO* out, const void* obj_raw, const OSSL_PARAM obj_abstract[], int selection, OSSL_PASSPHRASE_CALLBACK* cb, void* cbarg))
+
+    OSSL_CORE_MAKE_FUNC(void*, encoder_import_object, (void* ctx, int selection, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(void, encoder_free_object, (void* obj))
+
+#define OSSL_FUNC_DECODER_NEWCTX 1
+#define OSSL_FUNC_DECODER_FREECTX 2
+#define OSSL_FUNC_DECODER_GET_PARAMS 3
+#define OSSL_FUNC_DECODER_GETTABLE_PARAMS 4
+#define OSSL_FUNC_DECODER_SET_CTX_PARAMS 5
+#define OSSL_FUNC_DECODER_SETTABLE_CTX_PARAMS 6
+#define OSSL_FUNC_DECODER_DOES_SELECTION 10
+#define OSSL_FUNC_DECODER_DECODE 11
+#define OSSL_FUNC_DECODER_EXPORT_OBJECT 20
+    OSSL_CORE_MAKE_FUNC(void*, decoder_newctx, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(void, decoder_freectx, (void* ctx))
+    OSSL_CORE_MAKE_FUNC(int, decoder_get_params, (OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, decoder_gettable_params, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, decoder_set_ctx_params, (void* ctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, decoder_settable_ctx_params, (void* provctx))
+
+    OSSL_CORE_MAKE_FUNC(int, decoder_does_selection, (void* provctx, int selection))
+    OSSL_CORE_MAKE_FUNC(int, decoder_decode, (void* ctx, OSSL_CORE_BIO* in, int selection, OSSL_CALLBACK* data_cb, void* data_cbarg, OSSL_PASSPHRASE_CALLBACK* pw_cb, void* pw_cbarg))
+    OSSL_CORE_MAKE_FUNC(int, decoder_export_object, (void* ctx, const void* objref, size_t objref_sz, OSSL_CALLBACK* export_cb, void* export_cbarg))
+
+    /*-
+     * Store
+     *
+     * Objects are scanned by using the 'open', 'load', 'eof' and 'close'
+     * functions, which implement an OSSL_STORE loader.
+     *
+     * store_load() works in a way that's very similar to the decoders, in
+     * that they pass an abstract object through a callback, either as a DER
+     * octet string or as an object reference, which libcrypto will have to
+     * deal with.
+     */
+
+#define OSSL_FUNC_STORE_OPEN 1
+#define OSSL_FUNC_STORE_ATTACH 2
+#define OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS 3
+#define OSSL_FUNC_STORE_SET_CTX_PARAMS 4
+#define OSSL_FUNC_STORE_LOAD 5
+#define OSSL_FUNC_STORE_EOF 6
+#define OSSL_FUNC_STORE_CLOSE 7
+#define OSSL_FUNC_STORE_EXPORT_OBJECT 8
+    OSSL_CORE_MAKE_FUNC(void*, store_open, (void* provctx, const char* uri))
+    OSSL_CORE_MAKE_FUNC(void*, store_attach, (void* provctx, OSSL_CORE_BIO* in))
+    OSSL_CORE_MAKE_FUNC(const OSSL_PARAM*, store_settable_ctx_params, (void* provctx))
+    OSSL_CORE_MAKE_FUNC(int, store_set_ctx_params, (void* loaderctx, const OSSL_PARAM params[]))
+    OSSL_CORE_MAKE_FUNC(int, store_load, (void* loaderctx, OSSL_CALLBACK* object_cb, void* object_cbarg, OSSL_PASSPHRASE_CALLBACK* pw_cb, void* pw_cbarg))
+    OSSL_CORE_MAKE_FUNC(int, store_eof, (void* loaderctx))
+    OSSL_CORE_MAKE_FUNC(int, store_close, (void* loaderctx))
+    OSSL_CORE_MAKE_FUNC(int, store_export_object, (void* loaderctx, const void* objref, size_t objref_sz, OSSL_CALLBACK* export_cb, void* export_cbarg))
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/core_names.h b/CAPI/cpp/grpc/include/openssl/core_names.h
index 6bed5a8..afb33b7 100644
--- a/CAPI/cpp/grpc/include/openssl/core_names.h
+++ b/CAPI/cpp/grpc/include/openssl/core_names.h
@@ -8,29 +8,30 @@
  */
 
 #ifndef OPENSSL_CORE_NAMES_H
-# define OPENSSL_CORE_NAMES_H
-# pragma once
+#define OPENSSL_CORE_NAMES_H
+#pragma once
 
-# ifdef __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /* Well known parameter names that core passes to providers */
-#define OSSL_PROV_PARAM_CORE_VERSION         "openssl-version" /* utf8_ptr */
-#define OSSL_PROV_PARAM_CORE_PROV_NAME       "provider-name"   /* utf8_ptr */
+#define OSSL_PROV_PARAM_CORE_VERSION "openssl-version"         /* utf8_ptr */
+#define OSSL_PROV_PARAM_CORE_PROV_NAME "provider-name"         /* utf8_ptr */
 #define OSSL_PROV_PARAM_CORE_MODULE_FILENAME "module-filename" /* utf8_ptr */
 
 /* Well known parameter names that Providers can define */
-#define OSSL_PROV_PARAM_NAME            "name"                /* utf8_ptr */
-#define OSSL_PROV_PARAM_VERSION         "version"             /* utf8_ptr */
-#define OSSL_PROV_PARAM_BUILDINFO       "buildinfo"           /* utf8_ptr */
-#define OSSL_PROV_PARAM_STATUS          "status"              /* uint */
-#define OSSL_PROV_PARAM_SECURITY_CHECKS "security-checks"     /* uint */
+#define OSSL_PROV_PARAM_NAME "name"                       /* utf8_ptr */
+#define OSSL_PROV_PARAM_VERSION "version"                 /* utf8_ptr */
+#define OSSL_PROV_PARAM_BUILDINFO "buildinfo"             /* utf8_ptr */
+#define OSSL_PROV_PARAM_STATUS "status"                   /* uint */
+#define OSSL_PROV_PARAM_SECURITY_CHECKS "security-checks" /* uint */
 
 /* Self test callback parameters */
-#define OSSL_PROV_PARAM_SELF_TEST_PHASE  "st-phase" /* utf8_string */
-#define OSSL_PROV_PARAM_SELF_TEST_TYPE   "st-type"  /* utf8_string */
-#define OSSL_PROV_PARAM_SELF_TEST_DESC   "st-desc"  /* utf8_string */
+#define OSSL_PROV_PARAM_SELF_TEST_PHASE "st-phase" /* utf8_string */
+#define OSSL_PROV_PARAM_SELF_TEST_TYPE "st-type"   /* utf8_string */
+#define OSSL_PROV_PARAM_SELF_TEST_DESC "st-desc"   /* utf8_string */
 
 /*-
  * Provider-native object abstractions
@@ -43,12 +44,12 @@ extern "C" {
  * This set of parameter names is explained in detail in provider-object(7)
  * (doc/man7/provider-object.pod)
  */
-#define OSSL_OBJECT_PARAM_TYPE              "type"      /* INTEGER */
-#define OSSL_OBJECT_PARAM_DATA_TYPE         "data-type" /* UTF8_STRING */
-#define OSSL_OBJECT_PARAM_DATA_STRUCTURE    "data-structure" /* UTF8_STRING */
-#define OSSL_OBJECT_PARAM_REFERENCE         "reference" /* OCTET_STRING */
-#define OSSL_OBJECT_PARAM_DATA              "data" /* OCTET_STRING or UTF8_STRING */
-#define OSSL_OBJECT_PARAM_DESC              "desc"      /* UTF8_STRING */
+#define OSSL_OBJECT_PARAM_TYPE "type"                     /* INTEGER */
+#define OSSL_OBJECT_PARAM_DATA_TYPE "data-type"           /* UTF8_STRING */
+#define OSSL_OBJECT_PARAM_DATA_STRUCTURE "data-structure" /* UTF8_STRING */
+#define OSSL_OBJECT_PARAM_REFERENCE "reference"           /* OCTET_STRING */
+#define OSSL_OBJECT_PARAM_DATA "data"                     /* OCTET_STRING or UTF8_STRING */
+#define OSSL_OBJECT_PARAM_DESC "desc"                     /* UTF8_STRING */
 
 /*
  * Algorithm parameters
@@ -57,63 +58,63 @@ extern "C" {
  * Note these are common names that are shared by many types (such as kdf, mac,
  * and pkey) e.g: see OSSL_MAC_PARAM_DIGEST below.
  */
-#define OSSL_ALG_PARAM_DIGEST       "digest"    /* utf8_string */
-#define OSSL_ALG_PARAM_CIPHER       "cipher"    /* utf8_string */
-#define OSSL_ALG_PARAM_ENGINE       "engine"    /* utf8_string */
-#define OSSL_ALG_PARAM_MAC          "mac"       /* utf8_string */
-#define OSSL_ALG_PARAM_PROPERTIES   "properties"/* utf8_string */
+#define OSSL_ALG_PARAM_DIGEST "digest"         /* utf8_string */
+#define OSSL_ALG_PARAM_CIPHER "cipher"         /* utf8_string */
+#define OSSL_ALG_PARAM_ENGINE "engine"         /* utf8_string */
+#define OSSL_ALG_PARAM_MAC "mac"               /* utf8_string */
+#define OSSL_ALG_PARAM_PROPERTIES "properties" /* utf8_string */
 
 /* cipher parameters */
-#define OSSL_CIPHER_PARAM_PADDING              "padding"      /* uint */
-#define OSSL_CIPHER_PARAM_USE_BITS             "use-bits"     /* uint */
-#define OSSL_CIPHER_PARAM_TLS_VERSION          "tls-version"  /* uint */
-#define OSSL_CIPHER_PARAM_TLS_MAC              "tls-mac"      /* octet_ptr */
-#define OSSL_CIPHER_PARAM_TLS_MAC_SIZE         "tls-mac-size" /* size_t */
-#define OSSL_CIPHER_PARAM_MODE                 "mode"         /* uint */
-#define OSSL_CIPHER_PARAM_BLOCK_SIZE           "blocksize"    /* size_t */
-#define OSSL_CIPHER_PARAM_AEAD                 "aead"         /* int, 0 or 1 */
-#define OSSL_CIPHER_PARAM_CUSTOM_IV            "custom-iv"    /* int, 0 or 1 */
-#define OSSL_CIPHER_PARAM_CTS                  "cts"          /* int, 0 or 1 */
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK      "tls-multi"    /* int, 0 or 1 */
-#define OSSL_CIPHER_PARAM_HAS_RAND_KEY         "has-randkey"  /* int, 0 or 1 */
-#define OSSL_CIPHER_PARAM_KEYLEN               "keylen"       /* size_t */
-#define OSSL_CIPHER_PARAM_IVLEN                "ivlen"        /* size_t */
-#define OSSL_CIPHER_PARAM_IV                   "iv"           /* octet_string OR octet_ptr */
-#define OSSL_CIPHER_PARAM_UPDATED_IV           "updated-iv"   /* octet_string OR octet_ptr */
-#define OSSL_CIPHER_PARAM_NUM                  "num"          /* uint */
-#define OSSL_CIPHER_PARAM_ROUNDS               "rounds"       /* uint */
-#define OSSL_CIPHER_PARAM_AEAD_TAG             "tag"          /* octet_string */
-#define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD        "tlsaad"       /* octet_string */
-#define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD    "tlsaadpad"    /* size_t */
-#define OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED   "tlsivfixed"   /* octet_string */
-#define OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN "tlsivgen"     /* octet_string */
-#define OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV "tlsivinv"     /* octet_string */
-#define OSSL_CIPHER_PARAM_AEAD_IVLEN           OSSL_CIPHER_PARAM_IVLEN
-#define OSSL_CIPHER_PARAM_AEAD_TAGLEN          "taglen"       /* size_t */
-#define OSSL_CIPHER_PARAM_AEAD_MAC_KEY         "mackey"       /* octet_string */
-#define OSSL_CIPHER_PARAM_RANDOM_KEY           "randkey"      /* octet_string */
-#define OSSL_CIPHER_PARAM_RC2_KEYBITS          "keybits"      /* size_t */
-#define OSSL_CIPHER_PARAM_SPEED                "speed"        /* uint */
-#define OSSL_CIPHER_PARAM_CTS_MODE             "cts_mode"     /* utf8_string */
+#define OSSL_CIPHER_PARAM_PADDING "padding"               /* uint */
+#define OSSL_CIPHER_PARAM_USE_BITS "use-bits"             /* uint */
+#define OSSL_CIPHER_PARAM_TLS_VERSION "tls-version"       /* uint */
+#define OSSL_CIPHER_PARAM_TLS_MAC "tls-mac"               /* octet_ptr */
+#define OSSL_CIPHER_PARAM_TLS_MAC_SIZE "tls-mac-size"     /* size_t */
+#define OSSL_CIPHER_PARAM_MODE "mode"                     /* uint */
+#define OSSL_CIPHER_PARAM_BLOCK_SIZE "blocksize"          /* size_t */
+#define OSSL_CIPHER_PARAM_AEAD "aead"                     /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_CUSTOM_IV "custom-iv"           /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_CTS "cts"                       /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK "tls-multi"     /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_HAS_RAND_KEY "has-randkey"      /* int, 0 or 1 */
+#define OSSL_CIPHER_PARAM_KEYLEN "keylen"                 /* size_t */
+#define OSSL_CIPHER_PARAM_IVLEN "ivlen"                   /* size_t */
+#define OSSL_CIPHER_PARAM_IV "iv"                         /* octet_string OR octet_ptr */
+#define OSSL_CIPHER_PARAM_UPDATED_IV "updated-iv"         /* octet_string OR octet_ptr */
+#define OSSL_CIPHER_PARAM_NUM "num"                       /* uint */
+#define OSSL_CIPHER_PARAM_ROUNDS "rounds"                 /* uint */
+#define OSSL_CIPHER_PARAM_AEAD_TAG "tag"                  /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD "tlsaad"          /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD "tlsaadpad"   /* size_t */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED "tlsivfixed" /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN "tlsivgen" /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV "tlsivinv" /* octet_string */
+#define OSSL_CIPHER_PARAM_AEAD_IVLEN OSSL_CIPHER_PARAM_IVLEN
+#define OSSL_CIPHER_PARAM_AEAD_TAGLEN "taglen"  /* size_t */
+#define OSSL_CIPHER_PARAM_AEAD_MAC_KEY "mackey" /* octet_string */
+#define OSSL_CIPHER_PARAM_RANDOM_KEY "randkey"  /* octet_string */
+#define OSSL_CIPHER_PARAM_RC2_KEYBITS "keybits" /* size_t */
+#define OSSL_CIPHER_PARAM_SPEED "speed"         /* uint */
+#define OSSL_CIPHER_PARAM_CTS_MODE "cts_mode"   /* utf8_string */
 /* For passing the AlgorithmIdentifier parameter in DER form */
-#define OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS  "alg_id_param" /* octet_string */
+#define OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS "alg_id_param" /* octet_string */
 
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT                    \
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT \
     "tls1multi_maxsndfrag" /* uint */
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE                          \
-    "tls1multi_maxbufsz"   /* size_t */
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE                           \
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE \
+    "tls1multi_maxbufsz" /* size_t */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE \
     "tls1multi_interleave" /* uint */
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD                                  \
-    "tls1multi_aad"        /* octet_string */
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN                          \
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD \
+    "tls1multi_aad" /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN \
     "tls1multi_aadpacklen" /* uint */
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC                                  \
-    "tls1multi_enc"        /* octet_string */
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN                               \
-    "tls1multi_encin"      /* octet_string */
-#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN                              \
-    "tls1multi_enclen"     /* size_t */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC \
+    "tls1multi_enc" /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN \
+    "tls1multi_encin" /* octet_string */
+#define OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN \
+    "tls1multi_enclen" /* size_t */
 
 /* OSSL_CIPHER_PARAM_CTS_MODE Values */
 #define OSSL_CIPHER_CTS_MODE_CS1 "CS1"
@@ -121,214 +122,214 @@ extern "C" {
 #define OSSL_CIPHER_CTS_MODE_CS3 "CS3"
 
 /* digest parameters */
-#define OSSL_DIGEST_PARAM_XOFLEN       "xoflen"        /* size_t */
-#define OSSL_DIGEST_PARAM_SSL3_MS      "ssl3-ms"       /* octet string */
-#define OSSL_DIGEST_PARAM_PAD_TYPE     "pad-type"      /* uint */
-#define OSSL_DIGEST_PARAM_MICALG       "micalg"        /* utf8 string */
-#define OSSL_DIGEST_PARAM_BLOCK_SIZE   "blocksize"     /* size_t */
-#define OSSL_DIGEST_PARAM_SIZE         "size"          /* size_t */
-#define OSSL_DIGEST_PARAM_XOF          "xof"           /* int, 0 or 1 */
-#define OSSL_DIGEST_PARAM_ALGID_ABSENT "algid-absent"  /* int, 0 or 1 */
+#define OSSL_DIGEST_PARAM_XOFLEN "xoflen"             /* size_t */
+#define OSSL_DIGEST_PARAM_SSL3_MS "ssl3-ms"           /* octet string */
+#define OSSL_DIGEST_PARAM_PAD_TYPE "pad-type"         /* uint */
+#define OSSL_DIGEST_PARAM_MICALG "micalg"             /* utf8 string */
+#define OSSL_DIGEST_PARAM_BLOCK_SIZE "blocksize"      /* size_t */
+#define OSSL_DIGEST_PARAM_SIZE "size"                 /* size_t */
+#define OSSL_DIGEST_PARAM_XOF "xof"                   /* int, 0 or 1 */
+#define OSSL_DIGEST_PARAM_ALGID_ABSENT "algid-absent" /* int, 0 or 1 */
 
 /* Known DIGEST names (not a complete list) */
-#define OSSL_DIGEST_NAME_MD5            "MD5"
-#define OSSL_DIGEST_NAME_MD5_SHA1       "MD5-SHA1"
-#define OSSL_DIGEST_NAME_SHA1           "SHA1"
-#define OSSL_DIGEST_NAME_SHA2_224       "SHA2-224"
-#define OSSL_DIGEST_NAME_SHA2_256       "SHA2-256"
-#define OSSL_DIGEST_NAME_SHA2_384       "SHA2-384"
-#define OSSL_DIGEST_NAME_SHA2_512       "SHA2-512"
-#define OSSL_DIGEST_NAME_SHA2_512_224   "SHA2-512/224"
-#define OSSL_DIGEST_NAME_SHA2_512_256   "SHA2-512/256"
-#define OSSL_DIGEST_NAME_MD2            "MD2"
-#define OSSL_DIGEST_NAME_MD4            "MD4"
-#define OSSL_DIGEST_NAME_MDC2           "MDC2"
-#define OSSL_DIGEST_NAME_RIPEMD160      "RIPEMD160"
-#define OSSL_DIGEST_NAME_SHA3_224       "SHA3-224"
-#define OSSL_DIGEST_NAME_SHA3_256       "SHA3-256"
-#define OSSL_DIGEST_NAME_SHA3_384       "SHA3-384"
-#define OSSL_DIGEST_NAME_SHA3_512       "SHA3-512"
+#define OSSL_DIGEST_NAME_MD5 "MD5"
+#define OSSL_DIGEST_NAME_MD5_SHA1 "MD5-SHA1"
+#define OSSL_DIGEST_NAME_SHA1 "SHA1"
+#define OSSL_DIGEST_NAME_SHA2_224 "SHA2-224"
+#define OSSL_DIGEST_NAME_SHA2_256 "SHA2-256"
+#define OSSL_DIGEST_NAME_SHA2_384 "SHA2-384"
+#define OSSL_DIGEST_NAME_SHA2_512 "SHA2-512"
+#define OSSL_DIGEST_NAME_SHA2_512_224 "SHA2-512/224"
+#define OSSL_DIGEST_NAME_SHA2_512_256 "SHA2-512/256"
+#define OSSL_DIGEST_NAME_MD2 "MD2"
+#define OSSL_DIGEST_NAME_MD4 "MD4"
+#define OSSL_DIGEST_NAME_MDC2 "MDC2"
+#define OSSL_DIGEST_NAME_RIPEMD160 "RIPEMD160"
+#define OSSL_DIGEST_NAME_SHA3_224 "SHA3-224"
+#define OSSL_DIGEST_NAME_SHA3_256 "SHA3-256"
+#define OSSL_DIGEST_NAME_SHA3_384 "SHA3-384"
+#define OSSL_DIGEST_NAME_SHA3_512 "SHA3-512"
 #define OSSL_DIGEST_NAME_KECCAK_KMAC128 "KECCAK-KMAC-128"
 #define OSSL_DIGEST_NAME_KECCAK_KMAC256 "KECCAK-KMAC-256"
-#define OSSL_DIGEST_NAME_SM3            "SM3"
+#define OSSL_DIGEST_NAME_SM3 "SM3"
 
 /* MAC parameters */
-#define OSSL_MAC_PARAM_KEY            "key"            /* octet string */
-#define OSSL_MAC_PARAM_IV             "iv"             /* octet string */
-#define OSSL_MAC_PARAM_CUSTOM         "custom"         /* utf8 string */
-#define OSSL_MAC_PARAM_SALT           "salt"           /* octet string */
-#define OSSL_MAC_PARAM_XOF            "xof"            /* int, 0 or 1 */
-#define OSSL_MAC_PARAM_DIGEST_NOINIT  "digest-noinit"  /* int, 0 or 1 */
+#define OSSL_MAC_PARAM_KEY "key"                       /* octet string */
+#define OSSL_MAC_PARAM_IV "iv"                         /* octet string */
+#define OSSL_MAC_PARAM_CUSTOM "custom"                 /* utf8 string */
+#define OSSL_MAC_PARAM_SALT "salt"                     /* octet string */
+#define OSSL_MAC_PARAM_XOF "xof"                       /* int, 0 or 1 */
+#define OSSL_MAC_PARAM_DIGEST_NOINIT "digest-noinit"   /* int, 0 or 1 */
 #define OSSL_MAC_PARAM_DIGEST_ONESHOT "digest-oneshot" /* int, 0 or 1 */
-#define OSSL_MAC_PARAM_C_ROUNDS       "c-rounds"       /* unsigned int */
-#define OSSL_MAC_PARAM_D_ROUNDS       "d-rounds"       /* unsigned int */
+#define OSSL_MAC_PARAM_C_ROUNDS "c-rounds"             /* unsigned int */
+#define OSSL_MAC_PARAM_D_ROUNDS "d-rounds"             /* unsigned int */
 
 /*
  * If "engine" or "properties" are specified, they should always be paired
  * with "cipher" or "digest".
  */
-#define OSSL_MAC_PARAM_CIPHER           OSSL_ALG_PARAM_CIPHER     /* utf8 string */
-#define OSSL_MAC_PARAM_DIGEST           OSSL_ALG_PARAM_DIGEST     /* utf8 string */
-#define OSSL_MAC_PARAM_PROPERTIES       OSSL_ALG_PARAM_PROPERTIES /* utf8 string */
-#define OSSL_MAC_PARAM_SIZE             "size"                    /* size_t */
-#define OSSL_MAC_PARAM_BLOCK_SIZE       "block-size"              /* size_t */
-#define OSSL_MAC_PARAM_TLS_DATA_SIZE    "tls-data-size"           /* size_t */
+#define OSSL_MAC_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER         /* utf8 string */
+#define OSSL_MAC_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST         /* utf8 string */
+#define OSSL_MAC_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES /* utf8 string */
+#define OSSL_MAC_PARAM_SIZE "size"                          /* size_t */
+#define OSSL_MAC_PARAM_BLOCK_SIZE "block-size"              /* size_t */
+#define OSSL_MAC_PARAM_TLS_DATA_SIZE "tls-data-size"        /* size_t */
 
 /* Known MAC names */
-#define OSSL_MAC_NAME_BLAKE2BMAC    "BLAKE2BMAC"
-#define OSSL_MAC_NAME_BLAKE2SMAC    "BLAKE2SMAC"
-#define OSSL_MAC_NAME_CMAC          "CMAC"
-#define OSSL_MAC_NAME_GMAC          "GMAC"
-#define OSSL_MAC_NAME_HMAC          "HMAC"
-#define OSSL_MAC_NAME_KMAC128       "KMAC128"
-#define OSSL_MAC_NAME_KMAC256       "KMAC256"
-#define OSSL_MAC_NAME_POLY1305      "POLY1305"
-#define OSSL_MAC_NAME_SIPHASH       "SIPHASH"
+#define OSSL_MAC_NAME_BLAKE2BMAC "BLAKE2BMAC"
+#define OSSL_MAC_NAME_BLAKE2SMAC "BLAKE2SMAC"
+#define OSSL_MAC_NAME_CMAC "CMAC"
+#define OSSL_MAC_NAME_GMAC "GMAC"
+#define OSSL_MAC_NAME_HMAC "HMAC"
+#define OSSL_MAC_NAME_KMAC128 "KMAC128"
+#define OSSL_MAC_NAME_KMAC256 "KMAC256"
+#define OSSL_MAC_NAME_POLY1305 "POLY1305"
+#define OSSL_MAC_NAME_SIPHASH "SIPHASH"
 
 /* KDF / PRF parameters */
-#define OSSL_KDF_PARAM_SECRET       "secret"    /* octet string */
-#define OSSL_KDF_PARAM_KEY          "key"       /* octet string */
-#define OSSL_KDF_PARAM_SALT         "salt"      /* octet string */
-#define OSSL_KDF_PARAM_PASSWORD     "pass"      /* octet string */
-#define OSSL_KDF_PARAM_PREFIX       "prefix"    /* octet string */
-#define OSSL_KDF_PARAM_LABEL        "label"     /* octet string */
-#define OSSL_KDF_PARAM_DATA         "data"      /* octet string */
-#define OSSL_KDF_PARAM_DIGEST       OSSL_ALG_PARAM_DIGEST     /* utf8 string */
-#define OSSL_KDF_PARAM_CIPHER       OSSL_ALG_PARAM_CIPHER     /* utf8 string */
-#define OSSL_KDF_PARAM_MAC          OSSL_ALG_PARAM_MAC        /* utf8 string */
-#define OSSL_KDF_PARAM_MAC_SIZE     "maclen"    /* size_t */
-#define OSSL_KDF_PARAM_PROPERTIES   OSSL_ALG_PARAM_PROPERTIES /* utf8 string */
-#define OSSL_KDF_PARAM_ITER         "iter"      /* unsigned int */
-#define OSSL_KDF_PARAM_MODE         "mode"      /* utf8 string or int */
-#define OSSL_KDF_PARAM_PKCS5        "pkcs5"     /* int */
-#define OSSL_KDF_PARAM_UKM          "ukm"       /* octet string */
-#define OSSL_KDF_PARAM_CEK_ALG      "cekalg"    /* utf8 string */
-#define OSSL_KDF_PARAM_SCRYPT_N     "n"         /* uint64_t */
-#define OSSL_KDF_PARAM_SCRYPT_R     "r"         /* uint32_t */
-#define OSSL_KDF_PARAM_SCRYPT_P     "p"         /* uint32_t */
-#define OSSL_KDF_PARAM_SCRYPT_MAXMEM "maxmem_bytes" /* uint64_t */
-#define OSSL_KDF_PARAM_INFO         "info"      /* octet string */
-#define OSSL_KDF_PARAM_SEED         "seed"      /* octet string */
-#define OSSL_KDF_PARAM_SSHKDF_XCGHASH "xcghash" /* octet string */
-#define OSSL_KDF_PARAM_SSHKDF_SESSION_ID "session_id" /* octet string */
-#define OSSL_KDF_PARAM_SSHKDF_TYPE  "type"      /* int */
-#define OSSL_KDF_PARAM_SIZE         "size"      /* size_t */
-#define OSSL_KDF_PARAM_CONSTANT     "constant"  /* octet string */
-#define OSSL_KDF_PARAM_PKCS12_ID    "id"        /* int */
-#define OSSL_KDF_PARAM_KBKDF_USE_L  "use-l"             /* int */
-#define OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR  "use-separator"     /* int */
-#define OSSL_KDF_PARAM_X942_ACVPINFO        "acvp-info"
-#define OSSL_KDF_PARAM_X942_PARTYUINFO      "partyu-info"
-#define OSSL_KDF_PARAM_X942_PARTYVINFO      "partyv-info"
-#define OSSL_KDF_PARAM_X942_SUPP_PUBINFO    "supp-pubinfo"
-#define OSSL_KDF_PARAM_X942_SUPP_PRIVINFO   "supp-privinfo"
-#define OSSL_KDF_PARAM_X942_USE_KEYBITS     "use-keybits"
+#define OSSL_KDF_PARAM_SECRET "secret"                      /* octet string */
+#define OSSL_KDF_PARAM_KEY "key"                            /* octet string */
+#define OSSL_KDF_PARAM_SALT "salt"                          /* octet string */
+#define OSSL_KDF_PARAM_PASSWORD "pass"                      /* octet string */
+#define OSSL_KDF_PARAM_PREFIX "prefix"                      /* octet string */
+#define OSSL_KDF_PARAM_LABEL "label"                        /* octet string */
+#define OSSL_KDF_PARAM_DATA "data"                          /* octet string */
+#define OSSL_KDF_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST         /* utf8 string */
+#define OSSL_KDF_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER         /* utf8 string */
+#define OSSL_KDF_PARAM_MAC OSSL_ALG_PARAM_MAC               /* utf8 string */
+#define OSSL_KDF_PARAM_MAC_SIZE "maclen"                    /* size_t */
+#define OSSL_KDF_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES /* utf8 string */
+#define OSSL_KDF_PARAM_ITER "iter"                          /* unsigned int */
+#define OSSL_KDF_PARAM_MODE "mode"                          /* utf8 string or int */
+#define OSSL_KDF_PARAM_PKCS5 "pkcs5"                        /* int */
+#define OSSL_KDF_PARAM_UKM "ukm"                            /* octet string */
+#define OSSL_KDF_PARAM_CEK_ALG "cekalg"                     /* utf8 string */
+#define OSSL_KDF_PARAM_SCRYPT_N "n"                         /* uint64_t */
+#define OSSL_KDF_PARAM_SCRYPT_R "r"                         /* uint32_t */
+#define OSSL_KDF_PARAM_SCRYPT_P "p"                         /* uint32_t */
+#define OSSL_KDF_PARAM_SCRYPT_MAXMEM "maxmem_bytes"         /* uint64_t */
+#define OSSL_KDF_PARAM_INFO "info"                          /* octet string */
+#define OSSL_KDF_PARAM_SEED "seed"                          /* octet string */
+#define OSSL_KDF_PARAM_SSHKDF_XCGHASH "xcghash"             /* octet string */
+#define OSSL_KDF_PARAM_SSHKDF_SESSION_ID "session_id"       /* octet string */
+#define OSSL_KDF_PARAM_SSHKDF_TYPE "type"                   /* int */
+#define OSSL_KDF_PARAM_SIZE "size"                          /* size_t */
+#define OSSL_KDF_PARAM_CONSTANT "constant"                  /* octet string */
+#define OSSL_KDF_PARAM_PKCS12_ID "id"                       /* int */
+#define OSSL_KDF_PARAM_KBKDF_USE_L "use-l"                  /* int */
+#define OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR "use-separator"  /* int */
+#define OSSL_KDF_PARAM_X942_ACVPINFO "acvp-info"
+#define OSSL_KDF_PARAM_X942_PARTYUINFO "partyu-info"
+#define OSSL_KDF_PARAM_X942_PARTYVINFO "partyv-info"
+#define OSSL_KDF_PARAM_X942_SUPP_PUBINFO "supp-pubinfo"
+#define OSSL_KDF_PARAM_X942_SUPP_PRIVINFO "supp-privinfo"
+#define OSSL_KDF_PARAM_X942_USE_KEYBITS "use-keybits"
 
 /* Known KDF names */
-#define OSSL_KDF_NAME_HKDF           "HKDF"
-#define OSSL_KDF_NAME_TLS1_3_KDF     "TLS13-KDF"
-#define OSSL_KDF_NAME_PBKDF1         "PBKDF1"
-#define OSSL_KDF_NAME_PBKDF2         "PBKDF2"
-#define OSSL_KDF_NAME_SCRYPT         "SCRYPT"
-#define OSSL_KDF_NAME_SSHKDF         "SSHKDF"
-#define OSSL_KDF_NAME_SSKDF          "SSKDF"
-#define OSSL_KDF_NAME_TLS1_PRF       "TLS1-PRF"
-#define OSSL_KDF_NAME_X942KDF_ASN1   "X942KDF-ASN1"
+#define OSSL_KDF_NAME_HKDF "HKDF"
+#define OSSL_KDF_NAME_TLS1_3_KDF "TLS13-KDF"
+#define OSSL_KDF_NAME_PBKDF1 "PBKDF1"
+#define OSSL_KDF_NAME_PBKDF2 "PBKDF2"
+#define OSSL_KDF_NAME_SCRYPT "SCRYPT"
+#define OSSL_KDF_NAME_SSHKDF "SSHKDF"
+#define OSSL_KDF_NAME_SSKDF "SSKDF"
+#define OSSL_KDF_NAME_TLS1_PRF "TLS1-PRF"
+#define OSSL_KDF_NAME_X942KDF_ASN1 "X942KDF-ASN1"
 #define OSSL_KDF_NAME_X942KDF_CONCAT "X942KDF-CONCAT"
-#define OSSL_KDF_NAME_X963KDF        "X963KDF"
-#define OSSL_KDF_NAME_KBKDF          "KBKDF"
-#define OSSL_KDF_NAME_KRB5KDF        "KRB5KDF"
+#define OSSL_KDF_NAME_X963KDF "X963KDF"
+#define OSSL_KDF_NAME_KBKDF "KBKDF"
+#define OSSL_KDF_NAME_KRB5KDF "KRB5KDF"
 
 /* Known RAND names */
-#define OSSL_RAND_PARAM_STATE                   "state"
-#define OSSL_RAND_PARAM_STRENGTH                "strength"
-#define OSSL_RAND_PARAM_MAX_REQUEST             "max_request"
-#define OSSL_RAND_PARAM_TEST_ENTROPY            "test_entropy"
-#define OSSL_RAND_PARAM_TEST_NONCE              "test_nonce"
+#define OSSL_RAND_PARAM_STATE "state"
+#define OSSL_RAND_PARAM_STRENGTH "strength"
+#define OSSL_RAND_PARAM_MAX_REQUEST "max_request"
+#define OSSL_RAND_PARAM_TEST_ENTROPY "test_entropy"
+#define OSSL_RAND_PARAM_TEST_NONCE "test_nonce"
 
 /* RAND/DRBG names */
-#define OSSL_DRBG_PARAM_RESEED_REQUESTS         "reseed_requests"
-#define OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL    "reseed_time_interval"
-#define OSSL_DRBG_PARAM_MIN_ENTROPYLEN          "min_entropylen"
-#define OSSL_DRBG_PARAM_MAX_ENTROPYLEN          "max_entropylen"
-#define OSSL_DRBG_PARAM_MIN_NONCELEN            "min_noncelen"
-#define OSSL_DRBG_PARAM_MAX_NONCELEN            "max_noncelen"
-#define OSSL_DRBG_PARAM_MAX_PERSLEN             "max_perslen"
-#define OSSL_DRBG_PARAM_MAX_ADINLEN             "max_adinlen"
-#define OSSL_DRBG_PARAM_RESEED_COUNTER          "reseed_counter"
-#define OSSL_DRBG_PARAM_RESEED_TIME             "reseed_time"
-#define OSSL_DRBG_PARAM_PROPERTIES              OSSL_ALG_PARAM_PROPERTIES
-#define OSSL_DRBG_PARAM_DIGEST                  OSSL_ALG_PARAM_DIGEST
-#define OSSL_DRBG_PARAM_CIPHER                  OSSL_ALG_PARAM_CIPHER
-#define OSSL_DRBG_PARAM_MAC                     OSSL_ALG_PARAM_MAC
-#define OSSL_DRBG_PARAM_USE_DF                  "use_derivation_function"
+#define OSSL_DRBG_PARAM_RESEED_REQUESTS "reseed_requests"
+#define OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL "reseed_time_interval"
+#define OSSL_DRBG_PARAM_MIN_ENTROPYLEN "min_entropylen"
+#define OSSL_DRBG_PARAM_MAX_ENTROPYLEN "max_entropylen"
+#define OSSL_DRBG_PARAM_MIN_NONCELEN "min_noncelen"
+#define OSSL_DRBG_PARAM_MAX_NONCELEN "max_noncelen"
+#define OSSL_DRBG_PARAM_MAX_PERSLEN "max_perslen"
+#define OSSL_DRBG_PARAM_MAX_ADINLEN "max_adinlen"
+#define OSSL_DRBG_PARAM_RESEED_COUNTER "reseed_counter"
+#define OSSL_DRBG_PARAM_RESEED_TIME "reseed_time"
+#define OSSL_DRBG_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+#define OSSL_DRBG_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+#define OSSL_DRBG_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+#define OSSL_DRBG_PARAM_MAC OSSL_ALG_PARAM_MAC
+#define OSSL_DRBG_PARAM_USE_DF "use_derivation_function"
 
 /* DRBG call back parameters */
-#define OSSL_DRBG_PARAM_ENTROPY_REQUIRED        "entropy_required"
-#define OSSL_DRBG_PARAM_PREDICTION_RESISTANCE   "prediction_resistance"
-#define OSSL_DRBG_PARAM_MIN_LENGTH              "minium_length"
-#define OSSL_DRBG_PARAM_MAX_LENGTH              "maxium_length"
-#define OSSL_DRBG_PARAM_RANDOM_DATA             "random_data"
-#define OSSL_DRBG_PARAM_SIZE                    "size"
+#define OSSL_DRBG_PARAM_ENTROPY_REQUIRED "entropy_required"
+#define OSSL_DRBG_PARAM_PREDICTION_RESISTANCE "prediction_resistance"
+#define OSSL_DRBG_PARAM_MIN_LENGTH "minium_length"
+#define OSSL_DRBG_PARAM_MAX_LENGTH "maxium_length"
+#define OSSL_DRBG_PARAM_RANDOM_DATA "random_data"
+#define OSSL_DRBG_PARAM_SIZE "size"
 
 /* PKEY parameters */
 /* Common PKEY parameters */
-#define OSSL_PKEY_PARAM_BITS                "bits" /* integer */
-#define OSSL_PKEY_PARAM_MAX_SIZE            "max-size" /* integer */
-#define OSSL_PKEY_PARAM_SECURITY_BITS       "security-bits" /* integer */
-#define OSSL_PKEY_PARAM_DIGEST              OSSL_ALG_PARAM_DIGEST
-#define OSSL_PKEY_PARAM_CIPHER              OSSL_ALG_PARAM_CIPHER /* utf8 string */
-#define OSSL_PKEY_PARAM_ENGINE              OSSL_ALG_PARAM_ENGINE /* utf8 string */
-#define OSSL_PKEY_PARAM_PROPERTIES          OSSL_ALG_PARAM_PROPERTIES
-#define OSSL_PKEY_PARAM_DEFAULT_DIGEST      "default-digest" /* utf8 string */
-#define OSSL_PKEY_PARAM_MANDATORY_DIGEST    "mandatory-digest" /* utf8 string */
-#define OSSL_PKEY_PARAM_PAD_MODE            "pad-mode"
-#define OSSL_PKEY_PARAM_DIGEST_SIZE         "digest-size"
-#define OSSL_PKEY_PARAM_MASKGENFUNC         "mgf"
-#define OSSL_PKEY_PARAM_MGF1_DIGEST         "mgf1-digest"
-#define OSSL_PKEY_PARAM_MGF1_PROPERTIES     "mgf1-properties"
-#define OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY  "encoded-pub-key"
-#define OSSL_PKEY_PARAM_GROUP_NAME          "group"
-#define OSSL_PKEY_PARAM_DIST_ID             "distid"
-#define OSSL_PKEY_PARAM_PUB_KEY             "pub"
-#define OSSL_PKEY_PARAM_PRIV_KEY            "priv"
+#define OSSL_PKEY_PARAM_BITS "bits"                   /* integer */
+#define OSSL_PKEY_PARAM_MAX_SIZE "max-size"           /* integer */
+#define OSSL_PKEY_PARAM_SECURITY_BITS "security-bits" /* integer */
+#define OSSL_PKEY_PARAM_DIGEST OSSL_ALG_PARAM_DIGEST
+#define OSSL_PKEY_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER /* utf8 string */
+#define OSSL_PKEY_PARAM_ENGINE OSSL_ALG_PARAM_ENGINE /* utf8 string */
+#define OSSL_PKEY_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
+#define OSSL_PKEY_PARAM_DEFAULT_DIGEST "default-digest"     /* utf8 string */
+#define OSSL_PKEY_PARAM_MANDATORY_DIGEST "mandatory-digest" /* utf8 string */
+#define OSSL_PKEY_PARAM_PAD_MODE "pad-mode"
+#define OSSL_PKEY_PARAM_DIGEST_SIZE "digest-size"
+#define OSSL_PKEY_PARAM_MASKGENFUNC "mgf"
+#define OSSL_PKEY_PARAM_MGF1_DIGEST "mgf1-digest"
+#define OSSL_PKEY_PARAM_MGF1_PROPERTIES "mgf1-properties"
+#define OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY "encoded-pub-key"
+#define OSSL_PKEY_PARAM_GROUP_NAME "group"
+#define OSSL_PKEY_PARAM_DIST_ID "distid"
+#define OSSL_PKEY_PARAM_PUB_KEY "pub"
+#define OSSL_PKEY_PARAM_PRIV_KEY "priv"
 
 /* Diffie-Hellman/DSA Parameters */
-#define OSSL_PKEY_PARAM_FFC_P               "p"
-#define OSSL_PKEY_PARAM_FFC_G               "g"
-#define OSSL_PKEY_PARAM_FFC_Q               "q"
-#define OSSL_PKEY_PARAM_FFC_GINDEX          "gindex"
-#define OSSL_PKEY_PARAM_FFC_PCOUNTER        "pcounter"
-#define OSSL_PKEY_PARAM_FFC_SEED            "seed"
-#define OSSL_PKEY_PARAM_FFC_COFACTOR        "j"
-#define OSSL_PKEY_PARAM_FFC_H               "hindex"
-#define OSSL_PKEY_PARAM_FFC_VALIDATE_PQ     "validate-pq"
-#define OSSL_PKEY_PARAM_FFC_VALIDATE_G      "validate-g"
+#define OSSL_PKEY_PARAM_FFC_P "p"
+#define OSSL_PKEY_PARAM_FFC_G "g"
+#define OSSL_PKEY_PARAM_FFC_Q "q"
+#define OSSL_PKEY_PARAM_FFC_GINDEX "gindex"
+#define OSSL_PKEY_PARAM_FFC_PCOUNTER "pcounter"
+#define OSSL_PKEY_PARAM_FFC_SEED "seed"
+#define OSSL_PKEY_PARAM_FFC_COFACTOR "j"
+#define OSSL_PKEY_PARAM_FFC_H "hindex"
+#define OSSL_PKEY_PARAM_FFC_VALIDATE_PQ "validate-pq"
+#define OSSL_PKEY_PARAM_FFC_VALIDATE_G "validate-g"
 #define OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY "validate-legacy"
 
 /* Diffie-Hellman params */
-#define OSSL_PKEY_PARAM_DH_GENERATOR        "safeprime-generator"
-#define OSSL_PKEY_PARAM_DH_PRIV_LEN         "priv_len"
+#define OSSL_PKEY_PARAM_DH_GENERATOR "safeprime-generator"
+#define OSSL_PKEY_PARAM_DH_PRIV_LEN "priv_len"
 
 /* Elliptic Curve Domain Parameters */
-#define OSSL_PKEY_PARAM_EC_PUB_X     "qx"
-#define OSSL_PKEY_PARAM_EC_PUB_Y     "qy"
+#define OSSL_PKEY_PARAM_EC_PUB_X "qx"
+#define OSSL_PKEY_PARAM_EC_PUB_Y "qy"
 
 /* Elliptic Curve Explicit Domain Parameters */
-#define OSSL_PKEY_PARAM_EC_FIELD_TYPE                   "field-type"
-#define OSSL_PKEY_PARAM_EC_P                            "p"
-#define OSSL_PKEY_PARAM_EC_A                            "a"
-#define OSSL_PKEY_PARAM_EC_B                            "b"
-#define OSSL_PKEY_PARAM_EC_GENERATOR                    "generator"
-#define OSSL_PKEY_PARAM_EC_ORDER                        "order"
-#define OSSL_PKEY_PARAM_EC_COFACTOR                     "cofactor"
-#define OSSL_PKEY_PARAM_EC_SEED                         "seed"
-#define OSSL_PKEY_PARAM_EC_CHAR2_M                      "m"
-#define OSSL_PKEY_PARAM_EC_CHAR2_TYPE                   "basis-type"
-#define OSSL_PKEY_PARAM_EC_CHAR2_TP_BASIS               "tp"
-#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K1                  "k1"
-#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K2                  "k2"
-#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K3                  "k3"
+#define OSSL_PKEY_PARAM_EC_FIELD_TYPE "field-type"
+#define OSSL_PKEY_PARAM_EC_P "p"
+#define OSSL_PKEY_PARAM_EC_A "a"
+#define OSSL_PKEY_PARAM_EC_B "b"
+#define OSSL_PKEY_PARAM_EC_GENERATOR "generator"
+#define OSSL_PKEY_PARAM_EC_ORDER "order"
+#define OSSL_PKEY_PARAM_EC_COFACTOR "cofactor"
+#define OSSL_PKEY_PARAM_EC_SEED "seed"
+#define OSSL_PKEY_PARAM_EC_CHAR2_M "m"
+#define OSSL_PKEY_PARAM_EC_CHAR2_TYPE "basis-type"
+#define OSSL_PKEY_PARAM_EC_CHAR2_TP_BASIS "tp"
+#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K1 "k1"
+#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K2 "k2"
+#define OSSL_PKEY_PARAM_EC_CHAR2_PP_K3 "k3"
 #define OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS "decoded-from-explicit"
 
 /* Elliptic Curve Key Parameters */
@@ -350,174 +351,174 @@ extern "C" {
  * (the base i for the coefficients is 2, not 1, at least as implied by
  * RFC 8017)
  */
-#define OSSL_PKEY_PARAM_RSA_N           "n"
-#define OSSL_PKEY_PARAM_RSA_E           "e"
-#define OSSL_PKEY_PARAM_RSA_D           "d"
-#define OSSL_PKEY_PARAM_RSA_FACTOR      "rsa-factor"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT    "rsa-exponent"
+#define OSSL_PKEY_PARAM_RSA_N "n"
+#define OSSL_PKEY_PARAM_RSA_E "e"
+#define OSSL_PKEY_PARAM_RSA_D "d"
+#define OSSL_PKEY_PARAM_RSA_FACTOR "rsa-factor"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT "rsa-exponent"
 #define OSSL_PKEY_PARAM_RSA_COEFFICIENT "rsa-coefficient"
-#define OSSL_PKEY_PARAM_RSA_FACTOR1      OSSL_PKEY_PARAM_RSA_FACTOR"1"
-#define OSSL_PKEY_PARAM_RSA_FACTOR2      OSSL_PKEY_PARAM_RSA_FACTOR"2"
-#define OSSL_PKEY_PARAM_RSA_FACTOR3      OSSL_PKEY_PARAM_RSA_FACTOR"3"
-#define OSSL_PKEY_PARAM_RSA_FACTOR4      OSSL_PKEY_PARAM_RSA_FACTOR"4"
-#define OSSL_PKEY_PARAM_RSA_FACTOR5      OSSL_PKEY_PARAM_RSA_FACTOR"5"
-#define OSSL_PKEY_PARAM_RSA_FACTOR6      OSSL_PKEY_PARAM_RSA_FACTOR"6"
-#define OSSL_PKEY_PARAM_RSA_FACTOR7      OSSL_PKEY_PARAM_RSA_FACTOR"7"
-#define OSSL_PKEY_PARAM_RSA_FACTOR8      OSSL_PKEY_PARAM_RSA_FACTOR"8"
-#define OSSL_PKEY_PARAM_RSA_FACTOR9      OSSL_PKEY_PARAM_RSA_FACTOR"9"
-#define OSSL_PKEY_PARAM_RSA_FACTOR10     OSSL_PKEY_PARAM_RSA_FACTOR"10"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT1    OSSL_PKEY_PARAM_RSA_EXPONENT"1"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT2    OSSL_PKEY_PARAM_RSA_EXPONENT"2"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT3    OSSL_PKEY_PARAM_RSA_EXPONENT"3"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT4    OSSL_PKEY_PARAM_RSA_EXPONENT"4"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT5    OSSL_PKEY_PARAM_RSA_EXPONENT"5"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT6    OSSL_PKEY_PARAM_RSA_EXPONENT"6"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT7    OSSL_PKEY_PARAM_RSA_EXPONENT"7"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT8    OSSL_PKEY_PARAM_RSA_EXPONENT"8"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT9    OSSL_PKEY_PARAM_RSA_EXPONENT"9"
-#define OSSL_PKEY_PARAM_RSA_EXPONENT10   OSSL_PKEY_PARAM_RSA_EXPONENT"10"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT1 OSSL_PKEY_PARAM_RSA_COEFFICIENT"1"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT2 OSSL_PKEY_PARAM_RSA_COEFFICIENT"2"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT3 OSSL_PKEY_PARAM_RSA_COEFFICIENT"3"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT4 OSSL_PKEY_PARAM_RSA_COEFFICIENT"4"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT5 OSSL_PKEY_PARAM_RSA_COEFFICIENT"5"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT6 OSSL_PKEY_PARAM_RSA_COEFFICIENT"6"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT7 OSSL_PKEY_PARAM_RSA_COEFFICIENT"7"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT8 OSSL_PKEY_PARAM_RSA_COEFFICIENT"8"
-#define OSSL_PKEY_PARAM_RSA_COEFFICIENT9 OSSL_PKEY_PARAM_RSA_COEFFICIENT"9"
+#define OSSL_PKEY_PARAM_RSA_FACTOR1 OSSL_PKEY_PARAM_RSA_FACTOR "1"
+#define OSSL_PKEY_PARAM_RSA_FACTOR2 OSSL_PKEY_PARAM_RSA_FACTOR "2"
+#define OSSL_PKEY_PARAM_RSA_FACTOR3 OSSL_PKEY_PARAM_RSA_FACTOR "3"
+#define OSSL_PKEY_PARAM_RSA_FACTOR4 OSSL_PKEY_PARAM_RSA_FACTOR "4"
+#define OSSL_PKEY_PARAM_RSA_FACTOR5 OSSL_PKEY_PARAM_RSA_FACTOR "5"
+#define OSSL_PKEY_PARAM_RSA_FACTOR6 OSSL_PKEY_PARAM_RSA_FACTOR "6"
+#define OSSL_PKEY_PARAM_RSA_FACTOR7 OSSL_PKEY_PARAM_RSA_FACTOR "7"
+#define OSSL_PKEY_PARAM_RSA_FACTOR8 OSSL_PKEY_PARAM_RSA_FACTOR "8"
+#define OSSL_PKEY_PARAM_RSA_FACTOR9 OSSL_PKEY_PARAM_RSA_FACTOR "9"
+#define OSSL_PKEY_PARAM_RSA_FACTOR10 OSSL_PKEY_PARAM_RSA_FACTOR "10"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT1 OSSL_PKEY_PARAM_RSA_EXPONENT "1"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT2 OSSL_PKEY_PARAM_RSA_EXPONENT "2"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT3 OSSL_PKEY_PARAM_RSA_EXPONENT "3"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT4 OSSL_PKEY_PARAM_RSA_EXPONENT "4"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT5 OSSL_PKEY_PARAM_RSA_EXPONENT "5"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT6 OSSL_PKEY_PARAM_RSA_EXPONENT "6"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT7 OSSL_PKEY_PARAM_RSA_EXPONENT "7"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT8 OSSL_PKEY_PARAM_RSA_EXPONENT "8"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT9 OSSL_PKEY_PARAM_RSA_EXPONENT "9"
+#define OSSL_PKEY_PARAM_RSA_EXPONENT10 OSSL_PKEY_PARAM_RSA_EXPONENT "10"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT1 OSSL_PKEY_PARAM_RSA_COEFFICIENT "1"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT2 OSSL_PKEY_PARAM_RSA_COEFFICIENT "2"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT3 OSSL_PKEY_PARAM_RSA_COEFFICIENT "3"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT4 OSSL_PKEY_PARAM_RSA_COEFFICIENT "4"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT5 OSSL_PKEY_PARAM_RSA_COEFFICIENT "5"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT6 OSSL_PKEY_PARAM_RSA_COEFFICIENT "6"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT7 OSSL_PKEY_PARAM_RSA_COEFFICIENT "7"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT8 OSSL_PKEY_PARAM_RSA_COEFFICIENT "8"
+#define OSSL_PKEY_PARAM_RSA_COEFFICIENT9 OSSL_PKEY_PARAM_RSA_COEFFICIENT "9"
 
 /* RSA padding modes */
-#define OSSL_PKEY_RSA_PAD_MODE_NONE    "none"
+#define OSSL_PKEY_RSA_PAD_MODE_NONE "none"
 #define OSSL_PKEY_RSA_PAD_MODE_PKCSV15 "pkcs1"
-#define OSSL_PKEY_RSA_PAD_MODE_OAEP    "oaep"
-#define OSSL_PKEY_RSA_PAD_MODE_X931    "x931"
-#define OSSL_PKEY_RSA_PAD_MODE_PSS     "pss"
+#define OSSL_PKEY_RSA_PAD_MODE_OAEP "oaep"
+#define OSSL_PKEY_RSA_PAD_MODE_X931 "x931"
+#define OSSL_PKEY_RSA_PAD_MODE_PSS "pss"
 
 /* RSA pss padding salt length */
 #define OSSL_PKEY_RSA_PSS_SALT_LEN_DIGEST "digest"
-#define OSSL_PKEY_RSA_PSS_SALT_LEN_MAX    "max"
-#define OSSL_PKEY_RSA_PSS_SALT_LEN_AUTO   "auto"
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_MAX "max"
+#define OSSL_PKEY_RSA_PSS_SALT_LEN_AUTO "auto"
 
 /* Key generation parameters */
-#define OSSL_PKEY_PARAM_RSA_BITS             OSSL_PKEY_PARAM_BITS
-#define OSSL_PKEY_PARAM_RSA_PRIMES           "primes"
-#define OSSL_PKEY_PARAM_RSA_DIGEST           OSSL_PKEY_PARAM_DIGEST
-#define OSSL_PKEY_PARAM_RSA_DIGEST_PROPS     OSSL_PKEY_PARAM_PROPERTIES
-#define OSSL_PKEY_PARAM_RSA_MASKGENFUNC      OSSL_PKEY_PARAM_MASKGENFUNC
-#define OSSL_PKEY_PARAM_RSA_MGF1_DIGEST      OSSL_PKEY_PARAM_MGF1_DIGEST
-#define OSSL_PKEY_PARAM_RSA_PSS_SALTLEN      "saltlen"
+#define OSSL_PKEY_PARAM_RSA_BITS OSSL_PKEY_PARAM_BITS
+#define OSSL_PKEY_PARAM_RSA_PRIMES "primes"
+#define OSSL_PKEY_PARAM_RSA_DIGEST OSSL_PKEY_PARAM_DIGEST
+#define OSSL_PKEY_PARAM_RSA_DIGEST_PROPS OSSL_PKEY_PARAM_PROPERTIES
+#define OSSL_PKEY_PARAM_RSA_MASKGENFUNC OSSL_PKEY_PARAM_MASKGENFUNC
+#define OSSL_PKEY_PARAM_RSA_MGF1_DIGEST OSSL_PKEY_PARAM_MGF1_DIGEST
+#define OSSL_PKEY_PARAM_RSA_PSS_SALTLEN "saltlen"
 
 /* Key generation parameters */
-#define OSSL_PKEY_PARAM_FFC_TYPE         "type"
-#define OSSL_PKEY_PARAM_FFC_PBITS        "pbits"
-#define OSSL_PKEY_PARAM_FFC_QBITS        "qbits"
-#define OSSL_PKEY_PARAM_FFC_DIGEST       OSSL_PKEY_PARAM_DIGEST
+#define OSSL_PKEY_PARAM_FFC_TYPE "type"
+#define OSSL_PKEY_PARAM_FFC_PBITS "pbits"
+#define OSSL_PKEY_PARAM_FFC_QBITS "qbits"
+#define OSSL_PKEY_PARAM_FFC_DIGEST OSSL_PKEY_PARAM_DIGEST
 #define OSSL_PKEY_PARAM_FFC_DIGEST_PROPS OSSL_PKEY_PARAM_PROPERTIES
 
-#define OSSL_PKEY_PARAM_EC_ENCODING                "encoding" /* utf8_string */
+#define OSSL_PKEY_PARAM_EC_ENCODING "encoding" /* utf8_string */
 #define OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT "point-format"
-#define OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE        "group-check"
-#define OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC          "include-public"
+#define OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE "group-check"
+#define OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC "include-public"
 
 /* OSSL_PKEY_PARAM_EC_ENCODING values */
-#define OSSL_PKEY_EC_ENCODING_EXPLICIT  "explicit"
-#define OSSL_PKEY_EC_ENCODING_GROUP     "named_curve"
+#define OSSL_PKEY_EC_ENCODING_EXPLICIT "explicit"
+#define OSSL_PKEY_EC_ENCODING_GROUP "named_curve"
 
 #define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_UNCOMPRESSED "uncompressed"
-#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_COMPRESSED   "compressed"
-#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_HYBRID       "hybrid"
+#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_COMPRESSED "compressed"
+#define OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_HYBRID "hybrid"
 
-#define OSSL_PKEY_EC_GROUP_CHECK_DEFAULT     "default"
-#define OSSL_PKEY_EC_GROUP_CHECK_NAMED       "named"
-#define OSSL_PKEY_EC_GROUP_CHECK_NAMED_NIST  "named-nist"
+#define OSSL_PKEY_EC_GROUP_CHECK_DEFAULT "default"
+#define OSSL_PKEY_EC_GROUP_CHECK_NAMED "named"
+#define OSSL_PKEY_EC_GROUP_CHECK_NAMED_NIST "named-nist"
 
 /* Key Exchange parameters */
-#define OSSL_EXCHANGE_PARAM_PAD                   "pad" /* uint */
+#define OSSL_EXCHANGE_PARAM_PAD "pad"                                  /* uint */
 #define OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE "ecdh-cofactor-mode" /* int */
-#define OSSL_EXCHANGE_PARAM_KDF_TYPE              "kdf-type" /* utf8_string */
-#define OSSL_EXCHANGE_PARAM_KDF_DIGEST            "kdf-digest" /* utf8_string */
-#define OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS      "kdf-digest-props" /* utf8_string */
-#define OSSL_EXCHANGE_PARAM_KDF_OUTLEN            "kdf-outlen" /* size_t */
+#define OSSL_EXCHANGE_PARAM_KDF_TYPE "kdf-type"                        /* utf8_string */
+#define OSSL_EXCHANGE_PARAM_KDF_DIGEST "kdf-digest"                    /* utf8_string */
+#define OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS "kdf-digest-props"        /* utf8_string */
+#define OSSL_EXCHANGE_PARAM_KDF_OUTLEN "kdf-outlen"                    /* size_t */
 /* The following parameter is an octet_string on set and an octet_ptr on get */
-#define OSSL_EXCHANGE_PARAM_KDF_UKM               "kdf-ukm"
+#define OSSL_EXCHANGE_PARAM_KDF_UKM "kdf-ukm"
 
 /* Signature parameters */
-#define OSSL_SIGNATURE_PARAM_ALGORITHM_ID       "algorithm-id"
-#define OSSL_SIGNATURE_PARAM_PAD_MODE           OSSL_PKEY_PARAM_PAD_MODE
-#define OSSL_SIGNATURE_PARAM_DIGEST             OSSL_PKEY_PARAM_DIGEST
-#define OSSL_SIGNATURE_PARAM_PROPERTIES         OSSL_PKEY_PARAM_PROPERTIES
-#define OSSL_SIGNATURE_PARAM_PSS_SALTLEN        "saltlen"
-#define OSSL_SIGNATURE_PARAM_MGF1_DIGEST        OSSL_PKEY_PARAM_MGF1_DIGEST
-#define OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES    \
+#define OSSL_SIGNATURE_PARAM_ALGORITHM_ID "algorithm-id"
+#define OSSL_SIGNATURE_PARAM_PAD_MODE OSSL_PKEY_PARAM_PAD_MODE
+#define OSSL_SIGNATURE_PARAM_DIGEST OSSL_PKEY_PARAM_DIGEST
+#define OSSL_SIGNATURE_PARAM_PROPERTIES OSSL_PKEY_PARAM_PROPERTIES
+#define OSSL_SIGNATURE_PARAM_PSS_SALTLEN "saltlen"
+#define OSSL_SIGNATURE_PARAM_MGF1_DIGEST OSSL_PKEY_PARAM_MGF1_DIGEST
+#define OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES \
     OSSL_PKEY_PARAM_MGF1_PROPERTIES
-#define OSSL_SIGNATURE_PARAM_DIGEST_SIZE        OSSL_PKEY_PARAM_DIGEST_SIZE
+#define OSSL_SIGNATURE_PARAM_DIGEST_SIZE OSSL_PKEY_PARAM_DIGEST_SIZE
 
 /* Asym cipher parameters */
-#define OSSL_ASYM_CIPHER_PARAM_DIGEST                   OSSL_PKEY_PARAM_DIGEST
-#define OSSL_ASYM_CIPHER_PARAM_PROPERTIES               OSSL_PKEY_PARAM_PROPERTIES
-#define OSSL_ASYM_CIPHER_PARAM_ENGINE                   OSSL_PKEY_PARAM_ENGINE
-#define OSSL_ASYM_CIPHER_PARAM_PAD_MODE                 OSSL_PKEY_PARAM_PAD_MODE
-#define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST              \
+#define OSSL_ASYM_CIPHER_PARAM_DIGEST OSSL_PKEY_PARAM_DIGEST
+#define OSSL_ASYM_CIPHER_PARAM_PROPERTIES OSSL_PKEY_PARAM_PROPERTIES
+#define OSSL_ASYM_CIPHER_PARAM_ENGINE OSSL_PKEY_PARAM_ENGINE
+#define OSSL_ASYM_CIPHER_PARAM_PAD_MODE OSSL_PKEY_PARAM_PAD_MODE
+#define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST \
     OSSL_PKEY_PARAM_MGF1_DIGEST
-#define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS        \
+#define OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS \
     OSSL_PKEY_PARAM_MGF1_PROPERTIES
-#define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST              OSSL_ALG_PARAM_DIGEST
-#define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS        "digest-props"
+#define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST OSSL_ALG_PARAM_DIGEST
+#define OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS "digest-props"
 /* The following parameter is an octet_string on set and an octet_ptr on get */
-#define OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL               "oaep-label"
-#define OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION       "tls-client-version"
-#define OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION   "tls-negotiated-version"
+#define OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL "oaep-label"
+#define OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION "tls-client-version"
+#define OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION "tls-negotiated-version"
 
 /*
  * Encoder / decoder parameters
  */
-#define OSSL_ENCODER_PARAM_CIPHER           OSSL_ALG_PARAM_CIPHER
-#define OSSL_ENCODER_PARAM_PROPERTIES       OSSL_ALG_PARAM_PROPERTIES
+#define OSSL_ENCODER_PARAM_CIPHER OSSL_ALG_PARAM_CIPHER
+#define OSSL_ENCODER_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
 /* Currently PVK only, but reusable for others as needed */
-#define OSSL_ENCODER_PARAM_ENCRYPT_LEVEL    "encrypt-level"
-#define OSSL_ENCODER_PARAM_SAVE_PARAMETERS  "save-parameters" /* integer */
+#define OSSL_ENCODER_PARAM_ENCRYPT_LEVEL "encrypt-level"
+#define OSSL_ENCODER_PARAM_SAVE_PARAMETERS "save-parameters" /* integer */
 
-#define OSSL_DECODER_PARAM_PROPERTIES       OSSL_ALG_PARAM_PROPERTIES
+#define OSSL_DECODER_PARAM_PROPERTIES OSSL_ALG_PARAM_PROPERTIES
 
 /* Passphrase callback parameters */
-#define OSSL_PASSPHRASE_PARAM_INFO      "info"
+#define OSSL_PASSPHRASE_PARAM_INFO "info"
 
 /* Keygen callback parameters, from provider to libcrypto */
-#define OSSL_GEN_PARAM_POTENTIAL            "potential" /* integer */
-#define OSSL_GEN_PARAM_ITERATION            "iteration" /* integer */
+#define OSSL_GEN_PARAM_POTENTIAL "potential" /* integer */
+#define OSSL_GEN_PARAM_ITERATION "iteration" /* integer */
 
 /* ACVP Test parameters : These should not be used normally */
 #define OSSL_PKEY_PARAM_RSA_TEST_XP1 "xp1"
 #define OSSL_PKEY_PARAM_RSA_TEST_XP2 "xp2"
-#define OSSL_PKEY_PARAM_RSA_TEST_XP  "xp"
+#define OSSL_PKEY_PARAM_RSA_TEST_XP "xp"
 #define OSSL_PKEY_PARAM_RSA_TEST_XQ1 "xq1"
 #define OSSL_PKEY_PARAM_RSA_TEST_XQ2 "xq2"
-#define OSSL_PKEY_PARAM_RSA_TEST_XQ  "xq"
-#define OSSL_PKEY_PARAM_RSA_TEST_P1  "p1"
-#define OSSL_PKEY_PARAM_RSA_TEST_P2  "p2"
-#define OSSL_PKEY_PARAM_RSA_TEST_Q1  "q1"
-#define OSSL_PKEY_PARAM_RSA_TEST_Q2  "q2"
+#define OSSL_PKEY_PARAM_RSA_TEST_XQ "xq"
+#define OSSL_PKEY_PARAM_RSA_TEST_P1 "p1"
+#define OSSL_PKEY_PARAM_RSA_TEST_P2 "p2"
+#define OSSL_PKEY_PARAM_RSA_TEST_Q1 "q1"
+#define OSSL_PKEY_PARAM_RSA_TEST_Q2 "q2"
 #define OSSL_SIGNATURE_PARAM_KAT "kat"
 
 /* KEM parameters */
-#define OSSL_KEM_PARAM_OPERATION            "operation"
+#define OSSL_KEM_PARAM_OPERATION "operation"
 
 /* OSSL_KEM_PARAM_OPERATION values */
-#define OSSL_KEM_PARAM_OPERATION_RSASVE     "RSASVE"
+#define OSSL_KEM_PARAM_OPERATION_RSASVE "RSASVE"
 
 /* Capabilities */
 
 /* TLS-GROUP Capability */
-#define OSSL_CAPABILITY_TLS_GROUP_NAME              "tls-group-name"
-#define OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL     "tls-group-name-internal"
-#define OSSL_CAPABILITY_TLS_GROUP_ID                "tls-group-id"
-#define OSSL_CAPABILITY_TLS_GROUP_ALG               "tls-group-alg"
-#define OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS     "tls-group-sec-bits"
-#define OSSL_CAPABILITY_TLS_GROUP_IS_KEM            "tls-group-is-kem"
-#define OSSL_CAPABILITY_TLS_GROUP_MIN_TLS           "tls-min-tls"
-#define OSSL_CAPABILITY_TLS_GROUP_MAX_TLS           "tls-max-tls"
-#define OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS          "tls-min-dtls"
-#define OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS          "tls-max-dtls"
+#define OSSL_CAPABILITY_TLS_GROUP_NAME "tls-group-name"
+#define OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL "tls-group-name-internal"
+#define OSSL_CAPABILITY_TLS_GROUP_ID "tls-group-id"
+#define OSSL_CAPABILITY_TLS_GROUP_ALG "tls-group-alg"
+#define OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS "tls-group-sec-bits"
+#define OSSL_CAPABILITY_TLS_GROUP_IS_KEM "tls-group-is-kem"
+#define OSSL_CAPABILITY_TLS_GROUP_MIN_TLS "tls-min-tls"
+#define OSSL_CAPABILITY_TLS_GROUP_MAX_TLS "tls-max-tls"
+#define OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS "tls-min-dtls"
+#define OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS "tls-max-dtls"
 
 /*-
  * storemgmt parameters
@@ -536,21 +537,21 @@ extern "C" {
  *   are used as search criteria.
  *   (OSSL_STORE_PARAM_DIGEST is used with OSSL_STORE_PARAM_FINGERPRINT)
  */
-#define OSSL_STORE_PARAM_EXPECT     "expect"       /* INTEGER */
-#define OSSL_STORE_PARAM_SUBJECT    "subject" /* DER blob => OCTET_STRING */
-#define OSSL_STORE_PARAM_ISSUER     "name" /* DER blob => OCTET_STRING */
-#define OSSL_STORE_PARAM_SERIAL     "serial"       /* INTEGER */
-#define OSSL_STORE_PARAM_DIGEST     "digest"       /* UTF8_STRING */
+#define OSSL_STORE_PARAM_EXPECT "expect"           /* INTEGER */
+#define OSSL_STORE_PARAM_SUBJECT "subject"         /* DER blob => OCTET_STRING */
+#define OSSL_STORE_PARAM_ISSUER "name"             /* DER blob => OCTET_STRING */
+#define OSSL_STORE_PARAM_SERIAL "serial"           /* INTEGER */
+#define OSSL_STORE_PARAM_DIGEST "digest"           /* UTF8_STRING */
 #define OSSL_STORE_PARAM_FINGERPRINT "fingerprint" /* OCTET_STRING */
-#define OSSL_STORE_PARAM_ALIAS      "alias"        /* UTF8_STRING */
+#define OSSL_STORE_PARAM_ALIAS "alias"             /* UTF8_STRING */
 
 /* You may want to pass properties for the provider implementation to use */
-#define OSSL_STORE_PARAM_PROPERTIES "properties"   /* utf8_string */
+#define OSSL_STORE_PARAM_PROPERTIES "properties" /* utf8_string */
 /* OSSL_DECODER input type if a decoder is used by the store */
-#define OSSL_STORE_PARAM_INPUT_TYPE "input-type"   /* UTF8_STRING */
+#define OSSL_STORE_PARAM_INPUT_TYPE "input-type" /* UTF8_STRING */
 
-# ifdef __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/core_object.h b/CAPI/cpp/grpc/include/openssl/core_object.h
index 62ccf39..cd1b7df 100644
--- a/CAPI/cpp/grpc/include/openssl/core_object.h
+++ b/CAPI/cpp/grpc/include/openssl/core_object.h
@@ -8,12 +8,13 @@
  */
 
 #ifndef OPENSSL_CORE_OBJECT_H
-# define OPENSSL_CORE_OBJECT_H
-# pragma once
+#define OPENSSL_CORE_OBJECT_H
+#pragma once
 
-# ifdef __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /*-
  * Known object types
@@ -24,18 +25,18 @@ extern "C" {
  * For most of these types, there's a corresponding libcrypto object type.
  * The corresponding type is indicated with a comment after the number.
  */
-# define OSSL_OBJECT_UNKNOWN            0
-# define OSSL_OBJECT_NAME               1 /* char * */
-# define OSSL_OBJECT_PKEY               2 /* EVP_PKEY * */
-# define OSSL_OBJECT_CERT               3 /* X509 * */
-# define OSSL_OBJECT_CRL                4 /* X509_CRL * */
+#define OSSL_OBJECT_UNKNOWN 0
+#define OSSL_OBJECT_NAME 1 /* char * */
+#define OSSL_OBJECT_PKEY 2 /* EVP_PKEY * */
+#define OSSL_OBJECT_CERT 3 /* X509 * */
+#define OSSL_OBJECT_CRL 4  /* X509_CRL * */
 
-/*
- * The rest of the associated OSSL_PARAM elements is described in core_names.h
- */
+    /*
+     * The rest of the associated OSSL_PARAM elements is described in core_names.h
+     */
 
-# ifdef __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/crmf.h b/CAPI/cpp/grpc/include/openssl/crmf.h
index b2a82ed..bc7eeee 100644
--- a/CAPI/cpp/grpc/include/openssl/crmf.h
+++ b/CAPI/cpp/grpc/include/openssl/crmf.h
@@ -14,214 +14,178 @@
  * CRMF (RFC 4211) implementation by M. Peylo, M. Viljanen, and D. von Oheimb.
  */
 
-
-
 #ifndef OPENSSL_CRMF_H
-# define OPENSSL_CRMF_H
+#define OPENSSL_CRMF_H
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_CRMF
-#  include <openssl/opensslv.h>
-#  include <openssl/safestack.h>
-#  include <openssl/crmferr.h>
-#  include <openssl/x509v3.h> /* for GENERAL_NAME etc. */
+#ifndef OPENSSL_NO_CRMF
+#include <openssl/opensslv.h>
+#include <openssl/safestack.h>
+#include <openssl/crmferr.h>
+#include <openssl/x509v3.h> /* for GENERAL_NAME etc. */
 
 /* explicit #includes not strictly needed since implied by the above: */
-#  include <openssl/types.h>
-#  include <openssl/x509.h>
-
-#  ifdef __cplusplus
-extern "C" {
-#  endif
-
-#  define OSSL_CRMF_POPOPRIVKEY_THISMESSAGE          0
-#  define OSSL_CRMF_POPOPRIVKEY_SUBSEQUENTMESSAGE    1
-#  define OSSL_CRMF_POPOPRIVKEY_DHMAC                2
-#  define OSSL_CRMF_POPOPRIVKEY_AGREEMAC             3
-#  define OSSL_CRMF_POPOPRIVKEY_ENCRYPTEDKEY         4
-
-#  define OSSL_CRMF_SUBSEQUENTMESSAGE_ENCRCERT       0
-#  define OSSL_CRMF_SUBSEQUENTMESSAGE_CHALLENGERESP  1
-
-typedef struct ossl_crmf_encryptedvalue_st OSSL_CRMF_ENCRYPTEDVALUE;
-DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_ENCRYPTEDVALUE)
-typedef struct ossl_crmf_msg_st OSSL_CRMF_MSG;
-DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_MSG)
-DECLARE_ASN1_DUP_FUNCTION(OSSL_CRMF_MSG)
-SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CRMF_MSG, OSSL_CRMF_MSG, OSSL_CRMF_MSG)
+#include <openssl/types.h>
+#include <openssl/x509.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define OSSL_CRMF_POPOPRIVKEY_THISMESSAGE 0
+#define OSSL_CRMF_POPOPRIVKEY_SUBSEQUENTMESSAGE 1
+#define OSSL_CRMF_POPOPRIVKEY_DHMAC 2
+#define OSSL_CRMF_POPOPRIVKEY_AGREEMAC 3
+#define OSSL_CRMF_POPOPRIVKEY_ENCRYPTEDKEY 4
+
+#define OSSL_CRMF_SUBSEQUENTMESSAGE_ENCRCERT 0
+#define OSSL_CRMF_SUBSEQUENTMESSAGE_CHALLENGERESP 1
+
+    typedef struct ossl_crmf_encryptedvalue_st OSSL_CRMF_ENCRYPTEDVALUE;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_ENCRYPTEDVALUE)
+    typedef struct ossl_crmf_msg_st OSSL_CRMF_MSG;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_MSG)
+    DECLARE_ASN1_DUP_FUNCTION(OSSL_CRMF_MSG)
+    SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CRMF_MSG, OSSL_CRMF_MSG, OSSL_CRMF_MSG)
 #define sk_OSSL_CRMF_MSG_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk))
-#define sk_OSSL_CRMF_MSG_value(sk, idx) ((OSSL_CRMF_MSG *)OPENSSL_sk_value(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk), (idx)))
-#define sk_OSSL_CRMF_MSG_new(cmp) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new(ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp)))
-#define sk_OSSL_CRMF_MSG_new_null() ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new_null())
-#define sk_OSSL_CRMF_MSG_new_reserve(cmp, n) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp), (n)))
+#define sk_OSSL_CRMF_MSG_value(sk, idx) ((OSSL_CRMF_MSG*)OPENSSL_sk_value(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk), (idx)))
+#define sk_OSSL_CRMF_MSG_new(cmp) ((STACK_OF(OSSL_CRMF_MSG)*)OPENSSL_sk_new(ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp)))
+#define sk_OSSL_CRMF_MSG_new_null() ((STACK_OF(OSSL_CRMF_MSG)*)OPENSSL_sk_new_null())
+#define sk_OSSL_CRMF_MSG_new_reserve(cmp, n) ((STACK_OF(OSSL_CRMF_MSG)*)OPENSSL_sk_new_reserve(ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp), (n)))
 #define sk_OSSL_CRMF_MSG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (n))
 #define sk_OSSL_CRMF_MSG_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
 #define sk_OSSL_CRMF_MSG_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
-#define sk_OSSL_CRMF_MSG_delete(sk, i) ((OSSL_CRMF_MSG *)OPENSSL_sk_delete(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (i)))
-#define sk_OSSL_CRMF_MSG_delete_ptr(sk, ptr) ((OSSL_CRMF_MSG *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr)))
+#define sk_OSSL_CRMF_MSG_delete(sk, i) ((OSSL_CRMF_MSG*)OPENSSL_sk_delete(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (i)))
+#define sk_OSSL_CRMF_MSG_delete_ptr(sk, ptr) ((OSSL_CRMF_MSG*)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr)))
 #define sk_OSSL_CRMF_MSG_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
 #define sk_OSSL_CRMF_MSG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
-#define sk_OSSL_CRMF_MSG_pop(sk) ((OSSL_CRMF_MSG *)OPENSSL_sk_pop(ossl_check_OSSL_CRMF_MSG_sk_type(sk)))
-#define sk_OSSL_CRMF_MSG_shift(sk) ((OSSL_CRMF_MSG *)OPENSSL_sk_shift(ossl_check_OSSL_CRMF_MSG_sk_type(sk)))
-#define sk_OSSL_CRMF_MSG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CRMF_MSG_sk_type(sk),ossl_check_OSSL_CRMF_MSG_freefunc_type(freefunc))
+#define sk_OSSL_CRMF_MSG_pop(sk) ((OSSL_CRMF_MSG*)OPENSSL_sk_pop(ossl_check_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_shift(sk) ((OSSL_CRMF_MSG*)OPENSSL_sk_shift(ossl_check_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_freefunc_type(freefunc))
 #define sk_OSSL_CRMF_MSG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr), (idx))
-#define sk_OSSL_CRMF_MSG_set(sk, idx, ptr) ((OSSL_CRMF_MSG *)OPENSSL_sk_set(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (idx), ossl_check_OSSL_CRMF_MSG_type(ptr)))
+#define sk_OSSL_CRMF_MSG_set(sk, idx, ptr) ((OSSL_CRMF_MSG*)OPENSSL_sk_set(ossl_check_OSSL_CRMF_MSG_sk_type(sk), (idx), ossl_check_OSSL_CRMF_MSG_type(ptr)))
 #define sk_OSSL_CRMF_MSG_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
 #define sk_OSSL_CRMF_MSG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr))
 #define sk_OSSL_CRMF_MSG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_type(ptr), pnum)
 #define sk_OSSL_CRMF_MSG_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CRMF_MSG_sk_type(sk))
 #define sk_OSSL_CRMF_MSG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk))
-#define sk_OSSL_CRMF_MSG_dup(sk) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk)))
-#define sk_OSSL_CRMF_MSG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CRMF_MSG) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_copyfunc_type(copyfunc), ossl_check_OSSL_CRMF_MSG_freefunc_type(freefunc)))
+#define sk_OSSL_CRMF_MSG_dup(sk) ((STACK_OF(OSSL_CRMF_MSG)*)OPENSSL_sk_dup(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk)))
+#define sk_OSSL_CRMF_MSG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CRMF_MSG)*)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_copyfunc_type(copyfunc), ossl_check_OSSL_CRMF_MSG_freefunc_type(freefunc)))
 #define sk_OSSL_CRMF_MSG_set_cmp_func(sk, cmp) ((sk_OSSL_CRMF_MSG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CRMF_MSG_sk_type(sk), ossl_check_OSSL_CRMF_MSG_compfunc_type(cmp)))
 
-typedef struct ossl_crmf_attributetypeandvalue_st OSSL_CRMF_ATTRIBUTETYPEANDVALUE;
-typedef struct ossl_crmf_pbmparameter_st OSSL_CRMF_PBMPARAMETER;
-DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_PBMPARAMETER)
-typedef struct ossl_crmf_poposigningkey_st OSSL_CRMF_POPOSIGNINGKEY;
-typedef struct ossl_crmf_certrequest_st OSSL_CRMF_CERTREQUEST;
-typedef struct ossl_crmf_certid_st OSSL_CRMF_CERTID;
-DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_CERTID)
-DECLARE_ASN1_DUP_FUNCTION(OSSL_CRMF_CERTID)
-SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CRMF_CERTID, OSSL_CRMF_CERTID, OSSL_CRMF_CERTID)
+    typedef struct ossl_crmf_attributetypeandvalue_st OSSL_CRMF_ATTRIBUTETYPEANDVALUE;
+    typedef struct ossl_crmf_pbmparameter_st OSSL_CRMF_PBMPARAMETER;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_PBMPARAMETER)
+    typedef struct ossl_crmf_poposigningkey_st OSSL_CRMF_POPOSIGNINGKEY;
+    typedef struct ossl_crmf_certrequest_st OSSL_CRMF_CERTREQUEST;
+    typedef struct ossl_crmf_certid_st OSSL_CRMF_CERTID;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_CERTID)
+    DECLARE_ASN1_DUP_FUNCTION(OSSL_CRMF_CERTID)
+    SKM_DEFINE_STACK_OF_INTERNAL(OSSL_CRMF_CERTID, OSSL_CRMF_CERTID, OSSL_CRMF_CERTID)
 #define sk_OSSL_CRMF_CERTID_num(sk) OPENSSL_sk_num(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk))
-#define sk_OSSL_CRMF_CERTID_value(sk, idx) ((OSSL_CRMF_CERTID *)OPENSSL_sk_value(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk), (idx)))
-#define sk_OSSL_CRMF_CERTID_new(cmp) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new(ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp)))
-#define sk_OSSL_CRMF_CERTID_new_null() ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new_null())
-#define sk_OSSL_CRMF_CERTID_new_reserve(cmp, n) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_new_reserve(ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp), (n)))
+#define sk_OSSL_CRMF_CERTID_value(sk, idx) ((OSSL_CRMF_CERTID*)OPENSSL_sk_value(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk), (idx)))
+#define sk_OSSL_CRMF_CERTID_new(cmp) ((STACK_OF(OSSL_CRMF_CERTID)*)OPENSSL_sk_new(ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp)))
+#define sk_OSSL_CRMF_CERTID_new_null() ((STACK_OF(OSSL_CRMF_CERTID)*)OPENSSL_sk_new_null())
+#define sk_OSSL_CRMF_CERTID_new_reserve(cmp, n) ((STACK_OF(OSSL_CRMF_CERTID)*)OPENSSL_sk_new_reserve(ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp), (n)))
 #define sk_OSSL_CRMF_CERTID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (n))
 #define sk_OSSL_CRMF_CERTID_free(sk) OPENSSL_sk_free(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
 #define sk_OSSL_CRMF_CERTID_zero(sk) OPENSSL_sk_zero(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
-#define sk_OSSL_CRMF_CERTID_delete(sk, i) ((OSSL_CRMF_CERTID *)OPENSSL_sk_delete(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (i)))
-#define sk_OSSL_CRMF_CERTID_delete_ptr(sk, ptr) ((OSSL_CRMF_CERTID *)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr)))
+#define sk_OSSL_CRMF_CERTID_delete(sk, i) ((OSSL_CRMF_CERTID*)OPENSSL_sk_delete(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (i)))
+#define sk_OSSL_CRMF_CERTID_delete_ptr(sk, ptr) ((OSSL_CRMF_CERTID*)OPENSSL_sk_delete_ptr(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr)))
 #define sk_OSSL_CRMF_CERTID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
 #define sk_OSSL_CRMF_CERTID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
-#define sk_OSSL_CRMF_CERTID_pop(sk) ((OSSL_CRMF_CERTID *)OPENSSL_sk_pop(ossl_check_OSSL_CRMF_CERTID_sk_type(sk)))
-#define sk_OSSL_CRMF_CERTID_shift(sk) ((OSSL_CRMF_CERTID *)OPENSSL_sk_shift(ossl_check_OSSL_CRMF_CERTID_sk_type(sk)))
-#define sk_OSSL_CRMF_CERTID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CRMF_CERTID_sk_type(sk),ossl_check_OSSL_CRMF_CERTID_freefunc_type(freefunc))
+#define sk_OSSL_CRMF_CERTID_pop(sk) ((OSSL_CRMF_CERTID*)OPENSSL_sk_pop(ossl_check_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_shift(sk) ((OSSL_CRMF_CERTID*)OPENSSL_sk_shift(ossl_check_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_freefunc_type(freefunc))
 #define sk_OSSL_CRMF_CERTID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr), (idx))
-#define sk_OSSL_CRMF_CERTID_set(sk, idx, ptr) ((OSSL_CRMF_CERTID *)OPENSSL_sk_set(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (idx), ossl_check_OSSL_CRMF_CERTID_type(ptr)))
+#define sk_OSSL_CRMF_CERTID_set(sk, idx, ptr) ((OSSL_CRMF_CERTID*)OPENSSL_sk_set(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), (idx), ossl_check_OSSL_CRMF_CERTID_type(ptr)))
 #define sk_OSSL_CRMF_CERTID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
 #define sk_OSSL_CRMF_CERTID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr))
 #define sk_OSSL_CRMF_CERTID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_type(ptr), pnum)
 #define sk_OSSL_CRMF_CERTID_sort(sk) OPENSSL_sk_sort(ossl_check_OSSL_CRMF_CERTID_sk_type(sk))
 #define sk_OSSL_CRMF_CERTID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk))
-#define sk_OSSL_CRMF_CERTID_dup(sk) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_dup(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk)))
-#define sk_OSSL_CRMF_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CRMF_CERTID) *)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_copyfunc_type(copyfunc), ossl_check_OSSL_CRMF_CERTID_freefunc_type(freefunc)))
+#define sk_OSSL_CRMF_CERTID_dup(sk) ((STACK_OF(OSSL_CRMF_CERTID)*)OPENSSL_sk_dup(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk)))
+#define sk_OSSL_CRMF_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OSSL_CRMF_CERTID)*)OPENSSL_sk_deep_copy(ossl_check_const_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_copyfunc_type(copyfunc), ossl_check_OSSL_CRMF_CERTID_freefunc_type(freefunc)))
 #define sk_OSSL_CRMF_CERTID_set_cmp_func(sk, cmp) ((sk_OSSL_CRMF_CERTID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OSSL_CRMF_CERTID_sk_type(sk), ossl_check_OSSL_CRMF_CERTID_compfunc_type(cmp)))
 
-
-typedef struct ossl_crmf_pkipublicationinfo_st OSSL_CRMF_PKIPUBLICATIONINFO;
-DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_PKIPUBLICATIONINFO)
-typedef struct ossl_crmf_singlepubinfo_st OSSL_CRMF_SINGLEPUBINFO;
-DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_SINGLEPUBINFO)
-typedef struct ossl_crmf_certtemplate_st OSSL_CRMF_CERTTEMPLATE;
-DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_CERTTEMPLATE)
-typedef STACK_OF(OSSL_CRMF_MSG) OSSL_CRMF_MSGS;
-DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_MSGS)
-
-typedef struct ossl_crmf_optionalvalidity_st OSSL_CRMF_OPTIONALVALIDITY;
-
-/* crmf_pbm.c */
-OSSL_CRMF_PBMPARAMETER *OSSL_CRMF_pbmp_new(OSSL_LIB_CTX *libctx, size_t slen,
-                                           int owfnid, size_t itercnt,
-                                           int macnid);
-int OSSL_CRMF_pbm_new(OSSL_LIB_CTX *libctx, const char *propq,
-                      const OSSL_CRMF_PBMPARAMETER *pbmp,
-                      const unsigned char *msg, size_t msglen,
-                      const unsigned char *sec, size_t seclen,
-                      unsigned char **mac, size_t *maclen);
-
-/* crmf_lib.c */
-int OSSL_CRMF_MSG_set1_regCtrl_regToken(OSSL_CRMF_MSG *msg,
-                                        const ASN1_UTF8STRING *tok);
-ASN1_UTF8STRING
-*OSSL_CRMF_MSG_get0_regCtrl_regToken(const OSSL_CRMF_MSG *msg);
-int OSSL_CRMF_MSG_set1_regCtrl_authenticator(OSSL_CRMF_MSG *msg,
-                                             const ASN1_UTF8STRING *auth);
-ASN1_UTF8STRING
-*OSSL_CRMF_MSG_get0_regCtrl_authenticator(const OSSL_CRMF_MSG *msg);
-int
-OSSL_CRMF_MSG_PKIPublicationInfo_push0_SinglePubInfo(OSSL_CRMF_PKIPUBLICATIONINFO *pi,
-                                                     OSSL_CRMF_SINGLEPUBINFO *spi);
-#  define OSSL_CRMF_PUB_METHOD_DONTCARE 0
-#  define OSSL_CRMF_PUB_METHOD_X500     1
-#  define OSSL_CRMF_PUB_METHOD_WEB      2
-#  define OSSL_CRMF_PUB_METHOD_LDAP     3
-int OSSL_CRMF_MSG_set0_SinglePubInfo(OSSL_CRMF_SINGLEPUBINFO *spi,
-                                     int method, GENERAL_NAME *nm);
-#  define OSSL_CRMF_PUB_ACTION_DONTPUBLISH   0
-#  define OSSL_CRMF_PUB_ACTION_PLEASEPUBLISH 1
-int OSSL_CRMF_MSG_set_PKIPublicationInfo_action(OSSL_CRMF_PKIPUBLICATIONINFO *pi,
-                                                int action);
-int OSSL_CRMF_MSG_set1_regCtrl_pkiPublicationInfo(OSSL_CRMF_MSG *msg,
-                                                  const OSSL_CRMF_PKIPUBLICATIONINFO *pi);
-OSSL_CRMF_PKIPUBLICATIONINFO
-*OSSL_CRMF_MSG_get0_regCtrl_pkiPublicationInfo(const OSSL_CRMF_MSG *msg);
-int OSSL_CRMF_MSG_set1_regCtrl_protocolEncrKey(OSSL_CRMF_MSG *msg,
-                                               const X509_PUBKEY *pubkey);
-X509_PUBKEY
-*OSSL_CRMF_MSG_get0_regCtrl_protocolEncrKey(const OSSL_CRMF_MSG *msg);
-int OSSL_CRMF_MSG_set1_regCtrl_oldCertID(OSSL_CRMF_MSG *msg,
-                                         const OSSL_CRMF_CERTID *cid);
-OSSL_CRMF_CERTID
-*OSSL_CRMF_MSG_get0_regCtrl_oldCertID(const OSSL_CRMF_MSG *msg);
-OSSL_CRMF_CERTID *OSSL_CRMF_CERTID_gen(const X509_NAME *issuer,
-                                       const ASN1_INTEGER *serial);
-
-int OSSL_CRMF_MSG_set1_regInfo_utf8Pairs(OSSL_CRMF_MSG *msg,
-                                         const ASN1_UTF8STRING *utf8pairs);
-ASN1_UTF8STRING
-*OSSL_CRMF_MSG_get0_regInfo_utf8Pairs(const OSSL_CRMF_MSG *msg);
-int OSSL_CRMF_MSG_set1_regInfo_certReq(OSSL_CRMF_MSG *msg,
-                                       const OSSL_CRMF_CERTREQUEST *cr);
-OSSL_CRMF_CERTREQUEST
-*OSSL_CRMF_MSG_get0_regInfo_certReq(const OSSL_CRMF_MSG *msg);
-
-int OSSL_CRMF_MSG_set0_validity(OSSL_CRMF_MSG *crm,
-                                ASN1_TIME *notBefore, ASN1_TIME *notAfter);
-int OSSL_CRMF_MSG_set_certReqId(OSSL_CRMF_MSG *crm, int rid);
-int OSSL_CRMF_MSG_get_certReqId(const OSSL_CRMF_MSG *crm);
-int OSSL_CRMF_MSG_set0_extensions(OSSL_CRMF_MSG *crm, X509_EXTENSIONS *exts);
-
-int OSSL_CRMF_MSG_push0_extension(OSSL_CRMF_MSG *crm, X509_EXTENSION *ext);
-#  define OSSL_CRMF_POPO_NONE       -1
-#  define OSSL_CRMF_POPO_RAVERIFIED 0
-#  define OSSL_CRMF_POPO_SIGNATURE  1
-#  define OSSL_CRMF_POPO_KEYENC     2
-#  define OSSL_CRMF_POPO_KEYAGREE   3
-int OSSL_CRMF_MSG_create_popo(int meth, OSSL_CRMF_MSG *crm,
-                              EVP_PKEY *pkey, const EVP_MD *digest,
-                              OSSL_LIB_CTX *libctx, const char *propq);
-int OSSL_CRMF_MSGS_verify_popo(const OSSL_CRMF_MSGS *reqs,
-                               int rid, int acceptRAVerified,
-                               OSSL_LIB_CTX *libctx, const char *propq);
-OSSL_CRMF_CERTTEMPLATE *OSSL_CRMF_MSG_get0_tmpl(const OSSL_CRMF_MSG *crm);
-const ASN1_INTEGER
-*OSSL_CRMF_CERTTEMPLATE_get0_serialNumber(const OSSL_CRMF_CERTTEMPLATE *tmpl);
-const X509_NAME
-*OSSL_CRMF_CERTTEMPLATE_get0_subject(const OSSL_CRMF_CERTTEMPLATE *tmpl);
-const X509_NAME
-*OSSL_CRMF_CERTTEMPLATE_get0_issuer(const OSSL_CRMF_CERTTEMPLATE *tmpl);
-X509_EXTENSIONS
-*OSSL_CRMF_CERTTEMPLATE_get0_extensions(const OSSL_CRMF_CERTTEMPLATE *tmpl);
-const X509_NAME
-*OSSL_CRMF_CERTID_get0_issuer(const OSSL_CRMF_CERTID *cid);
-const ASN1_INTEGER
-*OSSL_CRMF_CERTID_get0_serialNumber(const OSSL_CRMF_CERTID *cid);
-int OSSL_CRMF_CERTTEMPLATE_fill(OSSL_CRMF_CERTTEMPLATE *tmpl,
-                                EVP_PKEY *pubkey,
-                                const X509_NAME *subject,
-                                const X509_NAME *issuer,
-                                const ASN1_INTEGER *serial);
-X509
-*OSSL_CRMF_ENCRYPTEDVALUE_get1_encCert(const OSSL_CRMF_ENCRYPTEDVALUE *ecert,
-                                       OSSL_LIB_CTX *libctx, const char *propq,
-                                       EVP_PKEY *pkey);
-
-#  ifdef __cplusplus
+    typedef struct ossl_crmf_pkipublicationinfo_st OSSL_CRMF_PKIPUBLICATIONINFO;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_PKIPUBLICATIONINFO)
+    typedef struct ossl_crmf_singlepubinfo_st OSSL_CRMF_SINGLEPUBINFO;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_SINGLEPUBINFO)
+    typedef struct ossl_crmf_certtemplate_st OSSL_CRMF_CERTTEMPLATE;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_CERTTEMPLATE)
+    typedef STACK_OF(OSSL_CRMF_MSG) OSSL_CRMF_MSGS;
+    DECLARE_ASN1_FUNCTIONS(OSSL_CRMF_MSGS)
+
+    typedef struct ossl_crmf_optionalvalidity_st OSSL_CRMF_OPTIONALVALIDITY;
+
+    /* crmf_pbm.c */
+    OSSL_CRMF_PBMPARAMETER* OSSL_CRMF_pbmp_new(OSSL_LIB_CTX* libctx, size_t slen, int owfnid, size_t itercnt, int macnid);
+    int OSSL_CRMF_pbm_new(OSSL_LIB_CTX* libctx, const char* propq, const OSSL_CRMF_PBMPARAMETER* pbmp, const unsigned char* msg, size_t msglen, const unsigned char* sec, size_t seclen, unsigned char** mac, size_t* maclen);
+
+    /* crmf_lib.c */
+    int OSSL_CRMF_MSG_set1_regCtrl_regToken(OSSL_CRMF_MSG* msg, const ASN1_UTF8STRING* tok);
+    ASN1_UTF8STRING
+    *OSSL_CRMF_MSG_get0_regCtrl_regToken(const OSSL_CRMF_MSG* msg);
+    int OSSL_CRMF_MSG_set1_regCtrl_authenticator(OSSL_CRMF_MSG* msg, const ASN1_UTF8STRING* auth);
+    ASN1_UTF8STRING
+    *OSSL_CRMF_MSG_get0_regCtrl_authenticator(const OSSL_CRMF_MSG* msg);
+    int
+        OSSL_CRMF_MSG_PKIPublicationInfo_push0_SinglePubInfo(OSSL_CRMF_PKIPUBLICATIONINFO* pi, OSSL_CRMF_SINGLEPUBINFO* spi);
+#define OSSL_CRMF_PUB_METHOD_DONTCARE 0
+#define OSSL_CRMF_PUB_METHOD_X500 1
+#define OSSL_CRMF_PUB_METHOD_WEB 2
+#define OSSL_CRMF_PUB_METHOD_LDAP 3
+    int OSSL_CRMF_MSG_set0_SinglePubInfo(OSSL_CRMF_SINGLEPUBINFO* spi, int method, GENERAL_NAME* nm);
+#define OSSL_CRMF_PUB_ACTION_DONTPUBLISH 0
+#define OSSL_CRMF_PUB_ACTION_PLEASEPUBLISH 1
+    int OSSL_CRMF_MSG_set_PKIPublicationInfo_action(OSSL_CRMF_PKIPUBLICATIONINFO* pi, int action);
+    int OSSL_CRMF_MSG_set1_regCtrl_pkiPublicationInfo(OSSL_CRMF_MSG* msg, const OSSL_CRMF_PKIPUBLICATIONINFO* pi);
+    OSSL_CRMF_PKIPUBLICATIONINFO
+    *OSSL_CRMF_MSG_get0_regCtrl_pkiPublicationInfo(const OSSL_CRMF_MSG* msg);
+    int OSSL_CRMF_MSG_set1_regCtrl_protocolEncrKey(OSSL_CRMF_MSG* msg, const X509_PUBKEY* pubkey);
+    X509_PUBKEY
+    *OSSL_CRMF_MSG_get0_regCtrl_protocolEncrKey(const OSSL_CRMF_MSG* msg);
+    int OSSL_CRMF_MSG_set1_regCtrl_oldCertID(OSSL_CRMF_MSG* msg, const OSSL_CRMF_CERTID* cid);
+    OSSL_CRMF_CERTID
+    *OSSL_CRMF_MSG_get0_regCtrl_oldCertID(const OSSL_CRMF_MSG* msg);
+    OSSL_CRMF_CERTID* OSSL_CRMF_CERTID_gen(const X509_NAME* issuer, const ASN1_INTEGER* serial);
+
+    int OSSL_CRMF_MSG_set1_regInfo_utf8Pairs(OSSL_CRMF_MSG* msg, const ASN1_UTF8STRING* utf8pairs);
+    ASN1_UTF8STRING
+    *OSSL_CRMF_MSG_get0_regInfo_utf8Pairs(const OSSL_CRMF_MSG* msg);
+    int OSSL_CRMF_MSG_set1_regInfo_certReq(OSSL_CRMF_MSG* msg, const OSSL_CRMF_CERTREQUEST* cr);
+    OSSL_CRMF_CERTREQUEST
+    *OSSL_CRMF_MSG_get0_regInfo_certReq(const OSSL_CRMF_MSG* msg);
+
+    int OSSL_CRMF_MSG_set0_validity(OSSL_CRMF_MSG* crm, ASN1_TIME* notBefore, ASN1_TIME* notAfter);
+    int OSSL_CRMF_MSG_set_certReqId(OSSL_CRMF_MSG* crm, int rid);
+    int OSSL_CRMF_MSG_get_certReqId(const OSSL_CRMF_MSG* crm);
+    int OSSL_CRMF_MSG_set0_extensions(OSSL_CRMF_MSG* crm, X509_EXTENSIONS* exts);
+
+    int OSSL_CRMF_MSG_push0_extension(OSSL_CRMF_MSG* crm, X509_EXTENSION* ext);
+#define OSSL_CRMF_POPO_NONE -1
+#define OSSL_CRMF_POPO_RAVERIFIED 0
+#define OSSL_CRMF_POPO_SIGNATURE 1
+#define OSSL_CRMF_POPO_KEYENC 2
+#define OSSL_CRMF_POPO_KEYAGREE 3
+    int OSSL_CRMF_MSG_create_popo(int meth, OSSL_CRMF_MSG* crm, EVP_PKEY* pkey, const EVP_MD* digest, OSSL_LIB_CTX* libctx, const char* propq);
+    int OSSL_CRMF_MSGS_verify_popo(const OSSL_CRMF_MSGS* reqs, int rid, int acceptRAVerified, OSSL_LIB_CTX* libctx, const char* propq);
+    OSSL_CRMF_CERTTEMPLATE* OSSL_CRMF_MSG_get0_tmpl(const OSSL_CRMF_MSG* crm);
+    const ASN1_INTEGER* OSSL_CRMF_CERTTEMPLATE_get0_serialNumber(const OSSL_CRMF_CERTTEMPLATE* tmpl);
+    const X509_NAME* OSSL_CRMF_CERTTEMPLATE_get0_subject(const OSSL_CRMF_CERTTEMPLATE* tmpl);
+    const X509_NAME* OSSL_CRMF_CERTTEMPLATE_get0_issuer(const OSSL_CRMF_CERTTEMPLATE* tmpl);
+    X509_EXTENSIONS
+    *OSSL_CRMF_CERTTEMPLATE_get0_extensions(const OSSL_CRMF_CERTTEMPLATE* tmpl);
+    const X509_NAME* OSSL_CRMF_CERTID_get0_issuer(const OSSL_CRMF_CERTID* cid);
+    const ASN1_INTEGER* OSSL_CRMF_CERTID_get0_serialNumber(const OSSL_CRMF_CERTID* cid);
+    int OSSL_CRMF_CERTTEMPLATE_fill(OSSL_CRMF_CERTTEMPLATE* tmpl, EVP_PKEY* pubkey, const X509_NAME* subject, const X509_NAME* issuer, const ASN1_INTEGER* serial);
+    X509* OSSL_CRMF_ENCRYPTEDVALUE_get1_encCert(const OSSL_CRMF_ENCRYPTEDVALUE* ecert, OSSL_LIB_CTX* libctx, const char* propq, EVP_PKEY* pkey);
+
+#ifdef __cplusplus
 }
-#  endif
-# endif /* !defined(OPENSSL_NO_CRMF) */
+#endif
+#endif /* !defined(OPENSSL_NO_CRMF) */
 #endif /* !defined(OPENSSL_CRMF_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/crmferr.h b/CAPI/cpp/grpc/include/openssl/crmferr.h
index b242b92..a5c46ab 100644
--- a/CAPI/cpp/grpc/include/openssl/crmferr.h
+++ b/CAPI/cpp/grpc/include/openssl/crmferr.h
@@ -9,42 +9,40 @@
  */
 
 #ifndef OPENSSL_CRMFERR_H
-# define OPENSSL_CRMFERR_H
-# pragma once
+#define OPENSSL_CRMFERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_CRMF
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_CRMF
 
 /*
  * CRMF reason codes.
  */
-#  define CRMF_R_BAD_PBM_ITERATIONCOUNT                    100
-#  define CRMF_R_CRMFERROR                                 102
-#  define CRMF_R_ERROR                                     103
-#  define CRMF_R_ERROR_DECODING_CERTIFICATE                104
-#  define CRMF_R_ERROR_DECRYPTING_CERTIFICATE              105
-#  define CRMF_R_ERROR_DECRYPTING_SYMMETRIC_KEY            106
-#  define CRMF_R_FAILURE_OBTAINING_RANDOM                  107
-#  define CRMF_R_ITERATIONCOUNT_BELOW_100                  108
-#  define CRMF_R_MALFORMED_IV                              101
-#  define CRMF_R_NULL_ARGUMENT                             109
-#  define CRMF_R_POPOSKINPUT_NOT_SUPPORTED                 113
-#  define CRMF_R_POPO_INCONSISTENT_PUBLIC_KEY              117
-#  define CRMF_R_POPO_MISSING                              121
-#  define CRMF_R_POPO_MISSING_PUBLIC_KEY                   118
-#  define CRMF_R_POPO_MISSING_SUBJECT                      119
-#  define CRMF_R_POPO_RAVERIFIED_NOT_ACCEPTED              120
-#  define CRMF_R_SETTING_MAC_ALGOR_FAILURE                 110
-#  define CRMF_R_SETTING_OWF_ALGOR_FAILURE                 111
-#  define CRMF_R_UNSUPPORTED_ALGORITHM                     112
-#  define CRMF_R_UNSUPPORTED_CIPHER                        114
-#  define CRMF_R_UNSUPPORTED_METHOD_FOR_CREATING_POPO      115
-#  define CRMF_R_UNSUPPORTED_POPO_METHOD                   116
+#define CRMF_R_BAD_PBM_ITERATIONCOUNT 100
+#define CRMF_R_CRMFERROR 102
+#define CRMF_R_ERROR 103
+#define CRMF_R_ERROR_DECODING_CERTIFICATE 104
+#define CRMF_R_ERROR_DECRYPTING_CERTIFICATE 105
+#define CRMF_R_ERROR_DECRYPTING_SYMMETRIC_KEY 106
+#define CRMF_R_FAILURE_OBTAINING_RANDOM 107
+#define CRMF_R_ITERATIONCOUNT_BELOW_100 108
+#define CRMF_R_MALFORMED_IV 101
+#define CRMF_R_NULL_ARGUMENT 109
+#define CRMF_R_POPOSKINPUT_NOT_SUPPORTED 113
+#define CRMF_R_POPO_INCONSISTENT_PUBLIC_KEY 117
+#define CRMF_R_POPO_MISSING 121
+#define CRMF_R_POPO_MISSING_PUBLIC_KEY 118
+#define CRMF_R_POPO_MISSING_SUBJECT 119
+#define CRMF_R_POPO_RAVERIFIED_NOT_ACCEPTED 120
+#define CRMF_R_SETTING_MAC_ALGOR_FAILURE 110
+#define CRMF_R_SETTING_OWF_ALGOR_FAILURE 111
+#define CRMF_R_UNSUPPORTED_ALGORITHM 112
+#define CRMF_R_UNSUPPORTED_CIPHER 114
+#define CRMF_R_UNSUPPORTED_METHOD_FOR_CREATING_POPO 115
+#define CRMF_R_UNSUPPORTED_POPO_METHOD 116
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/crypto.h b/CAPI/cpp/grpc/include/openssl/crypto.h
index 8b82593..03dc945 100644
--- a/CAPI/cpp/grpc/include/openssl/crypto.h
+++ b/CAPI/cpp/grpc/include/openssl/crypto.h
@@ -11,270 +11,261 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_CRYPTO_H
-# define OPENSSL_CRYPTO_H
-# pragma once
+#define OPENSSL_CRYPTO_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_CRYPTO_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CRYPTO_H
+#endif
 
-# include <stdlib.h>
-# include <time.h>
+#include <stdlib.h>
+#include <time.h>
 
-# include <openssl/e_os2.h>
+#include <openssl/e_os2.h>
 
-# ifndef OPENSSL_NO_STDIO
-#  include <stdio.h>
-# endif
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#endif
 
-# include <openssl/safestack.h>
-# include <openssl/opensslv.h>
-# include <openssl/types.h>
-# include <openssl/opensslconf.h>
-# include <openssl/cryptoerr.h>
-# include <openssl/core.h>
+#include <openssl/safestack.h>
+#include <openssl/opensslv.h>
+#include <openssl/types.h>
+#include <openssl/opensslconf.h>
+#include <openssl/cryptoerr.h>
+#include <openssl/core.h>
 
-# ifdef CHARSET_EBCDIC
-#  include <openssl/ebcdic.h>
-# endif
+#ifdef CHARSET_EBCDIC
+#include <openssl/ebcdic.h>
+#endif
 
 /*
  * Resolve problems on some operating systems with symbol names that clash
  * one way or another
  */
-# include <openssl/symhacks.h>
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  include <openssl/opensslv.h>
-# endif
+#include <openssl/symhacks.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/opensslv.h>
 #endif
 
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define SSLeay                  OpenSSL_version_num
-#  define SSLeay_version          OpenSSL_version
-#  define SSLEAY_VERSION_NUMBER   OPENSSL_VERSION_NUMBER
-#  define SSLEAY_VERSION          OPENSSL_VERSION
-#  define SSLEAY_CFLAGS           OPENSSL_CFLAGS
-#  define SSLEAY_BUILT_ON         OPENSSL_BUILT_ON
-#  define SSLEAY_PLATFORM         OPENSSL_PLATFORM
-#  define SSLEAY_DIR              OPENSSL_DIR
-
-/*
- * Old type for allocating dynamic locks. No longer used. Use the new thread
- * API instead.
- */
-typedef struct {
-    int dummy;
-} CRYPTO_dynlock;
-
-# endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
-
-typedef void CRYPTO_RWLOCK;
-
-CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void);
-__owur int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock);
-__owur int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock);
-int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock);
-void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock);
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock);
-int CRYPTO_atomic_or(uint64_t *val, uint64_t op, uint64_t *ret,
-                     CRYPTO_RWLOCK *lock);
-int CRYPTO_atomic_load(uint64_t *val, uint64_t *ret, CRYPTO_RWLOCK *lock);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define SSLeay OpenSSL_version_num
+#define SSLeay_version OpenSSL_version
+#define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER
+#define SSLEAY_VERSION OPENSSL_VERSION
+#define SSLEAY_CFLAGS OPENSSL_CFLAGS
+#define SSLEAY_BUILT_ON OPENSSL_BUILT_ON
+#define SSLEAY_PLATFORM OPENSSL_PLATFORM
+#define SSLEAY_DIR OPENSSL_DIR
+
+    /*
+     * Old type for allocating dynamic locks. No longer used. Use the new thread
+     * API instead.
+     */
+    typedef struct
+    {
+        int dummy;
+    } CRYPTO_dynlock;
+
+#endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
+
+    typedef void CRYPTO_RWLOCK;
+
+    CRYPTO_RWLOCK* CRYPTO_THREAD_lock_new(void);
+    __owur int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK* lock);
+    __owur int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK* lock);
+    int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK* lock);
+    void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK* lock);
+
+    int CRYPTO_atomic_add(int* val, int amount, int* ret, CRYPTO_RWLOCK* lock);
+    int CRYPTO_atomic_or(uint64_t* val, uint64_t op, uint64_t* ret, CRYPTO_RWLOCK* lock);
+    int CRYPTO_atomic_load(uint64_t* val, uint64_t* ret, CRYPTO_RWLOCK* lock);
 
 /* No longer needed, so this is a no-op */
-#define OPENSSL_malloc_init() while(0) continue
-
-# define OPENSSL_malloc(num) \
-        CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_zalloc(num) \
-        CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_realloc(addr, num) \
-        CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_clear_realloc(addr, old_num, num) \
-        CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_clear_free(addr, num) \
-        CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_free(addr) \
-        CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_memdup(str, s) \
-        CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_strdup(str) \
-        CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_strndup(str, n) \
-        CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_secure_malloc(num) \
-        CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_secure_zalloc(num) \
-        CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_secure_free(addr) \
-        CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_secure_clear_free(addr, num) \
-        CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
-# define OPENSSL_secure_actual_size(ptr) \
-        CRYPTO_secure_actual_size(ptr)
-
-size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz);
-size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz);
-size_t OPENSSL_strnlen(const char *str, size_t maxlen);
-int OPENSSL_buf2hexstr_ex(char *str, size_t str_n, size_t *strlength,
-                          const unsigned char *buf, size_t buflen,
-                          const char sep);
-char *OPENSSL_buf2hexstr(const unsigned char *buf, long buflen);
-int OPENSSL_hexstr2buf_ex(unsigned char *buf, size_t buf_n, size_t *buflen,
-                          const char *str, const char sep);
-unsigned char *OPENSSL_hexstr2buf(const char *str, long *buflen);
-int OPENSSL_hexchar2int(unsigned char c);
-int OPENSSL_strcasecmp(const char *s1, const char *s2);
-int OPENSSL_strncasecmp(const char *s1, const char *s2, size_t n);
-
-# define OPENSSL_MALLOC_MAX_NELEMS(type)  (((1U<<(sizeof(int)*8-1))-1)/sizeof(type))
-
-/*
- * These functions return the values of OPENSSL_VERSION_MAJOR,
- * OPENSSL_VERSION_MINOR, OPENSSL_VERSION_PATCH, OPENSSL_VERSION_PRE_RELEASE
- * and OPENSSL_VERSION_BUILD_METADATA, respectively.
- */
-unsigned int OPENSSL_version_major(void);
-unsigned int OPENSSL_version_minor(void);
-unsigned int OPENSSL_version_patch(void);
-const char *OPENSSL_version_pre_release(void);
-const char *OPENSSL_version_build_metadata(void);
-
-unsigned long OpenSSL_version_num(void);
-const char *OpenSSL_version(int type);
-# define OPENSSL_VERSION                0
-# define OPENSSL_CFLAGS                 1
-# define OPENSSL_BUILT_ON               2
-# define OPENSSL_PLATFORM               3
-# define OPENSSL_DIR                    4
-# define OPENSSL_ENGINES_DIR            5
-# define OPENSSL_VERSION_STRING         6
-# define OPENSSL_FULL_VERSION_STRING    7
-# define OPENSSL_MODULES_DIR            8
-# define OPENSSL_CPU_INFO               9
-
-const char *OPENSSL_info(int type);
+#define OPENSSL_malloc_init() \
+    while (0)                 \
+    continue
+
+#define OPENSSL_malloc(num) \
+    CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_zalloc(num) \
+    CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_realloc(addr, num) \
+    CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_clear_realloc(addr, old_num, num) \
+    CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_clear_free(addr, num) \
+    CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_free(addr) \
+    CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_memdup(str, s) \
+    CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_strdup(str) \
+    CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_strndup(str, n) \
+    CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_secure_malloc(num) \
+    CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_secure_zalloc(num) \
+    CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_secure_free(addr) \
+    CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_secure_clear_free(addr, num) \
+    CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_secure_actual_size(ptr) \
+    CRYPTO_secure_actual_size(ptr)
+
+    size_t OPENSSL_strlcpy(char* dst, const char* src, size_t siz);
+    size_t OPENSSL_strlcat(char* dst, const char* src, size_t siz);
+    size_t OPENSSL_strnlen(const char* str, size_t maxlen);
+    int OPENSSL_buf2hexstr_ex(char* str, size_t str_n, size_t* strlength, const unsigned char* buf, size_t buflen, const char sep);
+    char* OPENSSL_buf2hexstr(const unsigned char* buf, long buflen);
+    int OPENSSL_hexstr2buf_ex(unsigned char* buf, size_t buf_n, size_t* buflen, const char* str, const char sep);
+    unsigned char* OPENSSL_hexstr2buf(const char* str, long* buflen);
+    int OPENSSL_hexchar2int(unsigned char c);
+    int OPENSSL_strcasecmp(const char* s1, const char* s2);
+    int OPENSSL_strncasecmp(const char* s1, const char* s2, size_t n);
+
+#define OPENSSL_MALLOC_MAX_NELEMS(type) (((1U << (sizeof(int) * 8 - 1)) - 1) / sizeof(type))
+
+    /*
+     * These functions return the values of OPENSSL_VERSION_MAJOR,
+     * OPENSSL_VERSION_MINOR, OPENSSL_VERSION_PATCH, OPENSSL_VERSION_PRE_RELEASE
+     * and OPENSSL_VERSION_BUILD_METADATA, respectively.
+     */
+    unsigned int OPENSSL_version_major(void);
+    unsigned int OPENSSL_version_minor(void);
+    unsigned int OPENSSL_version_patch(void);
+    const char* OPENSSL_version_pre_release(void);
+    const char* OPENSSL_version_build_metadata(void);
+
+    unsigned long OpenSSL_version_num(void);
+    const char* OpenSSL_version(int type);
+#define OPENSSL_VERSION 0
+#define OPENSSL_CFLAGS 1
+#define OPENSSL_BUILT_ON 2
+#define OPENSSL_PLATFORM 3
+#define OPENSSL_DIR 4
+#define OPENSSL_ENGINES_DIR 5
+#define OPENSSL_VERSION_STRING 6
+#define OPENSSL_FULL_VERSION_STRING 7
+#define OPENSSL_MODULES_DIR 8
+#define OPENSSL_CPU_INFO 9
+
+    const char* OPENSSL_info(int type);
 /*
  * The series starts at 1001 to avoid confusion with the OpenSSL_version
  * types.
  */
-# define OPENSSL_INFO_CONFIG_DIR                1001
-# define OPENSSL_INFO_ENGINES_DIR               1002
-# define OPENSSL_INFO_MODULES_DIR               1003
-# define OPENSSL_INFO_DSO_EXTENSION             1004
-# define OPENSSL_INFO_DIR_FILENAME_SEPARATOR    1005
-# define OPENSSL_INFO_LIST_SEPARATOR            1006
-# define OPENSSL_INFO_SEED_SOURCE               1007
-# define OPENSSL_INFO_CPU_SETTINGS              1008
-
-int OPENSSL_issetugid(void);
-
-struct crypto_ex_data_st {
-    OSSL_LIB_CTX *ctx;
-    STACK_OF(void) *sk;
-};
-
-SKM_DEFINE_STACK_OF_INTERNAL(void, void, void)
+#define OPENSSL_INFO_CONFIG_DIR 1001
+#define OPENSSL_INFO_ENGINES_DIR 1002
+#define OPENSSL_INFO_MODULES_DIR 1003
+#define OPENSSL_INFO_DSO_EXTENSION 1004
+#define OPENSSL_INFO_DIR_FILENAME_SEPARATOR 1005
+#define OPENSSL_INFO_LIST_SEPARATOR 1006
+#define OPENSSL_INFO_SEED_SOURCE 1007
+#define OPENSSL_INFO_CPU_SETTINGS 1008
+
+    int OPENSSL_issetugid(void);
+
+    struct crypto_ex_data_st
+    {
+        OSSL_LIB_CTX* ctx;
+        STACK_OF(void) * sk;
+    };
+
+    SKM_DEFINE_STACK_OF_INTERNAL(void, void, void)
 #define sk_void_num(sk) OPENSSL_sk_num(ossl_check_const_void_sk_type(sk))
-#define sk_void_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_void_sk_type(sk), (idx)))
-#define sk_void_new(cmp) ((STACK_OF(void) *)OPENSSL_sk_new(ossl_check_void_compfunc_type(cmp)))
-#define sk_void_new_null() ((STACK_OF(void) *)OPENSSL_sk_new_null())
-#define sk_void_new_reserve(cmp, n) ((STACK_OF(void) *)OPENSSL_sk_new_reserve(ossl_check_void_compfunc_type(cmp), (n)))
+#define sk_void_value(sk, idx) ((void*)OPENSSL_sk_value(ossl_check_const_void_sk_type(sk), (idx)))
+#define sk_void_new(cmp) ((STACK_OF(void)*)OPENSSL_sk_new(ossl_check_void_compfunc_type(cmp)))
+#define sk_void_new_null() ((STACK_OF(void)*)OPENSSL_sk_new_null())
+#define sk_void_new_reserve(cmp, n) ((STACK_OF(void)*)OPENSSL_sk_new_reserve(ossl_check_void_compfunc_type(cmp), (n)))
 #define sk_void_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_void_sk_type(sk), (n))
 #define sk_void_free(sk) OPENSSL_sk_free(ossl_check_void_sk_type(sk))
 #define sk_void_zero(sk) OPENSSL_sk_zero(ossl_check_void_sk_type(sk))
-#define sk_void_delete(sk, i) ((void *)OPENSSL_sk_delete(ossl_check_void_sk_type(sk), (i)))
-#define sk_void_delete_ptr(sk, ptr) ((void *)OPENSSL_sk_delete_ptr(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr)))
+#define sk_void_delete(sk, i) ((void*)OPENSSL_sk_delete(ossl_check_void_sk_type(sk), (i)))
+#define sk_void_delete_ptr(sk, ptr) ((void*)OPENSSL_sk_delete_ptr(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr)))
 #define sk_void_push(sk, ptr) OPENSSL_sk_push(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
 #define sk_void_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
-#define sk_void_pop(sk) ((void *)OPENSSL_sk_pop(ossl_check_void_sk_type(sk)))
-#define sk_void_shift(sk) ((void *)OPENSSL_sk_shift(ossl_check_void_sk_type(sk)))
-#define sk_void_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_void_sk_type(sk),ossl_check_void_freefunc_type(freefunc))
+#define sk_void_pop(sk) ((void*)OPENSSL_sk_pop(ossl_check_void_sk_type(sk)))
+#define sk_void_shift(sk) ((void*)OPENSSL_sk_shift(ossl_check_void_sk_type(sk)))
+#define sk_void_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_void_sk_type(sk), ossl_check_void_freefunc_type(freefunc))
 #define sk_void_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr), (idx))
-#define sk_void_set(sk, idx, ptr) ((void *)OPENSSL_sk_set(ossl_check_void_sk_type(sk), (idx), ossl_check_void_type(ptr)))
+#define sk_void_set(sk, idx, ptr) ((void*)OPENSSL_sk_set(ossl_check_void_sk_type(sk), (idx), ossl_check_void_type(ptr)))
 #define sk_void_find(sk, ptr) OPENSSL_sk_find(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
 #define sk_void_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
 #define sk_void_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr), pnum)
 #define sk_void_sort(sk) OPENSSL_sk_sort(ossl_check_void_sk_type(sk))
 #define sk_void_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_void_sk_type(sk))
-#define sk_void_dup(sk) ((STACK_OF(void) *)OPENSSL_sk_dup(ossl_check_const_void_sk_type(sk)))
-#define sk_void_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(void) *)OPENSSL_sk_deep_copy(ossl_check_const_void_sk_type(sk), ossl_check_void_copyfunc_type(copyfunc), ossl_check_void_freefunc_type(freefunc)))
+#define sk_void_dup(sk) ((STACK_OF(void)*)OPENSSL_sk_dup(ossl_check_const_void_sk_type(sk)))
+#define sk_void_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(void)*)OPENSSL_sk_deep_copy(ossl_check_const_void_sk_type(sk), ossl_check_void_copyfunc_type(copyfunc), ossl_check_void_freefunc_type(freefunc)))
 #define sk_void_set_cmp_func(sk, cmp) ((sk_void_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_void_sk_type(sk), ossl_check_void_compfunc_type(cmp)))
 
-
-
 /*
  * Per class, we have a STACK of function pointers.
  */
-# define CRYPTO_EX_INDEX_SSL              0
-# define CRYPTO_EX_INDEX_SSL_CTX          1
-# define CRYPTO_EX_INDEX_SSL_SESSION      2
-# define CRYPTO_EX_INDEX_X509             3
-# define CRYPTO_EX_INDEX_X509_STORE       4
-# define CRYPTO_EX_INDEX_X509_STORE_CTX   5
-# define CRYPTO_EX_INDEX_DH               6
-# define CRYPTO_EX_INDEX_DSA              7
-# define CRYPTO_EX_INDEX_EC_KEY           8
-# define CRYPTO_EX_INDEX_RSA              9
-# define CRYPTO_EX_INDEX_ENGINE          10
-# define CRYPTO_EX_INDEX_UI              11
-# define CRYPTO_EX_INDEX_BIO             12
-# define CRYPTO_EX_INDEX_APP             13
-# define CRYPTO_EX_INDEX_UI_METHOD       14
-# define CRYPTO_EX_INDEX_RAND_DRBG       15
-# define CRYPTO_EX_INDEX_DRBG            CRYPTO_EX_INDEX_RAND_DRBG
-# define CRYPTO_EX_INDEX_OSSL_LIB_CTX    16
-# define CRYPTO_EX_INDEX_EVP_PKEY        17
-# define CRYPTO_EX_INDEX__COUNT          18
-
-typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
-                           int idx, long argl, void *argp);
-typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
-                             int idx, long argl, void *argp);
-typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
-                           void **from_d, int idx, long argl, void *argp);
-__owur int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
-                                   CRYPTO_EX_new *new_func,
-                                   CRYPTO_EX_dup *dup_func,
-                                   CRYPTO_EX_free *free_func);
-/* No longer use an index. */
-int CRYPTO_free_ex_index(int class_index, int idx);
-
-/*
- * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a
- * given class (invokes whatever per-class callbacks are applicable)
- */
-int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
-int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
-                       const CRYPTO_EX_DATA *from);
-
-void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
-
-/* Allocate a single item in the CRYPTO_EX_DATA variable */
-int CRYPTO_alloc_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad,
-                         int idx);
-
-/*
- * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular
- * index (relative to the class type involved)
- */
-int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
-void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define CRYPTO_EX_INDEX_SSL 0
+#define CRYPTO_EX_INDEX_SSL_CTX 1
+#define CRYPTO_EX_INDEX_SSL_SESSION 2
+#define CRYPTO_EX_INDEX_X509 3
+#define CRYPTO_EX_INDEX_X509_STORE 4
+#define CRYPTO_EX_INDEX_X509_STORE_CTX 5
+#define CRYPTO_EX_INDEX_DH 6
+#define CRYPTO_EX_INDEX_DSA 7
+#define CRYPTO_EX_INDEX_EC_KEY 8
+#define CRYPTO_EX_INDEX_RSA 9
+#define CRYPTO_EX_INDEX_ENGINE 10
+#define CRYPTO_EX_INDEX_UI 11
+#define CRYPTO_EX_INDEX_BIO 12
+#define CRYPTO_EX_INDEX_APP 13
+#define CRYPTO_EX_INDEX_UI_METHOD 14
+#define CRYPTO_EX_INDEX_RAND_DRBG 15
+#define CRYPTO_EX_INDEX_DRBG CRYPTO_EX_INDEX_RAND_DRBG
+#define CRYPTO_EX_INDEX_OSSL_LIB_CTX 16
+#define CRYPTO_EX_INDEX_EVP_PKEY 17
+#define CRYPTO_EX_INDEX__COUNT 18
+
+    typedef void CRYPTO_EX_new(void* parent, void* ptr, CRYPTO_EX_DATA* ad, int idx, long argl, void* argp);
+    typedef void CRYPTO_EX_free(void* parent, void* ptr, CRYPTO_EX_DATA* ad, int idx, long argl, void* argp);
+    typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA* to, const CRYPTO_EX_DATA* from, void** from_d, int idx, long argl, void* argp);
+    __owur int CRYPTO_get_ex_new_index(int class_index, long argl, void* argp, CRYPTO_EX_new* new_func, CRYPTO_EX_dup* dup_func, CRYPTO_EX_free* free_func);
+    /* No longer use an index. */
+    int CRYPTO_free_ex_index(int class_index, int idx);
+
+    /*
+     * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a
+     * given class (invokes whatever per-class callbacks are applicable)
+     */
+    int CRYPTO_new_ex_data(int class_index, void* obj, CRYPTO_EX_DATA* ad);
+    int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA* to, const CRYPTO_EX_DATA* from);
+
+    void CRYPTO_free_ex_data(int class_index, void* obj, CRYPTO_EX_DATA* ad);
+
+    /* Allocate a single item in the CRYPTO_EX_DATA variable */
+    int CRYPTO_alloc_ex_data(int class_index, void* obj, CRYPTO_EX_DATA* ad, int idx);
+
+    /*
+     * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular
+     * index (relative to the class type involved)
+     */
+    int CRYPTO_set_ex_data(CRYPTO_EX_DATA* ad, int idx, void* val);
+    void* CRYPTO_get_ex_data(const CRYPTO_EX_DATA* ad, int idx);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
 /*
  * This function cleans up all "ex_data" state. It mustn't be called under
  * potential race-conditions.
  */
-# define CRYPTO_cleanup_all_ex_data() while(0) continue
+#define CRYPTO_cleanup_all_ex_data() \
+    while (0)                        \
+    continue
 
 /*
  * The old locking functions have been removed completely without compatibility
@@ -286,185 +277,171 @@ void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
  * On the other hand, the locking callbacks are no longer used.  Consequently,
  * the callback management functions can be safely replaced with no-op macros.
  */
-#  define CRYPTO_num_locks()            (1)
-#  define CRYPTO_set_locking_callback(func)
-#  define CRYPTO_get_locking_callback()         (NULL)
-#  define CRYPTO_set_add_lock_callback(func)
-#  define CRYPTO_get_add_lock_callback()        (NULL)
+#define CRYPTO_num_locks() (1)
+#define CRYPTO_set_locking_callback(func)
+#define CRYPTO_get_locking_callback() (NULL)
+#define CRYPTO_set_add_lock_callback(func)
+#define CRYPTO_get_add_lock_callback() (NULL)
 
 /*
  * These defines where used in combination with the old locking callbacks,
  * they are not called anymore, but old code that's not called might still
  * use them.
  */
-#  define CRYPTO_LOCK             1
-#  define CRYPTO_UNLOCK           2
-#  define CRYPTO_READ             4
-#  define CRYPTO_WRITE            8
-
-/* This structure is no longer used */
-typedef struct crypto_threadid_st {
-    int dummy;
-} CRYPTO_THREADID;
+#define CRYPTO_LOCK 1
+#define CRYPTO_UNLOCK 2
+#define CRYPTO_READ 4
+#define CRYPTO_WRITE 8
+
+    /* This structure is no longer used */
+    typedef struct crypto_threadid_st
+    {
+        int dummy;
+    } CRYPTO_THREADID;
 /* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
-#  define CRYPTO_THREADID_set_numeric(id, val)
-#  define CRYPTO_THREADID_set_pointer(id, ptr)
-#  define CRYPTO_THREADID_set_callback(threadid_func)   (0)
-#  define CRYPTO_THREADID_get_callback()                (NULL)
-#  define CRYPTO_THREADID_current(id)
-#  define CRYPTO_THREADID_cmp(a, b)                     (-1)
-#  define CRYPTO_THREADID_cpy(dest, src)
-#  define CRYPTO_THREADID_hash(id)                      (0UL)
-
-#  ifndef OPENSSL_NO_DEPRECATED_1_0_0
-#   define CRYPTO_set_id_callback(func)
-#   define CRYPTO_get_id_callback()                     (NULL)
-#   define CRYPTO_thread_id()                           (0UL)
-#  endif /* OPENSSL_NO_DEPRECATED_1_0_0 */
-
-#  define CRYPTO_set_dynlock_create_callback(dyn_create_function)
-#  define CRYPTO_set_dynlock_lock_callback(dyn_lock_function)
-#  define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function)
-#  define CRYPTO_get_dynlock_create_callback()          (NULL)
-#  define CRYPTO_get_dynlock_lock_callback()            (NULL)
-#  define CRYPTO_get_dynlock_destroy_callback()         (NULL)
-# endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
-
-typedef void *(*CRYPTO_malloc_fn)(size_t num, const char *file, int line);
-typedef void *(*CRYPTO_realloc_fn)(void *addr, size_t num, const char *file,
-                                   int line);
-typedef void (*CRYPTO_free_fn)(void *addr, const char *file, int line);
-int CRYPTO_set_mem_functions(CRYPTO_malloc_fn malloc_fn,
-                             CRYPTO_realloc_fn realloc_fn,
-                             CRYPTO_free_fn free_fn);
-void CRYPTO_get_mem_functions(CRYPTO_malloc_fn *malloc_fn,
-                              CRYPTO_realloc_fn *realloc_fn,
-                              CRYPTO_free_fn *free_fn);
-
-void *CRYPTO_malloc(size_t num, const char *file, int line);
-void *CRYPTO_zalloc(size_t num, const char *file, int line);
-void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line);
-char *CRYPTO_strdup(const char *str, const char *file, int line);
-char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line);
-void CRYPTO_free(void *ptr, const char *file, int line);
-void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line);
-void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line);
-void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
-                           const char *file, int line);
-
-int CRYPTO_secure_malloc_init(size_t sz, size_t minsize);
-int CRYPTO_secure_malloc_done(void);
-void *CRYPTO_secure_malloc(size_t num, const char *file, int line);
-void *CRYPTO_secure_zalloc(size_t num, const char *file, int line);
-void CRYPTO_secure_free(void *ptr, const char *file, int line);
-void CRYPTO_secure_clear_free(void *ptr, size_t num,
-                              const char *file, int line);
-int CRYPTO_secure_allocated(const void *ptr);
-int CRYPTO_secure_malloc_initialized(void);
-size_t CRYPTO_secure_actual_size(void *ptr);
-size_t CRYPTO_secure_used(void);
-
-void OPENSSL_cleanse(void *ptr, size_t len);
-
-# ifndef OPENSSL_NO_CRYPTO_MDEBUG
+#define CRYPTO_THREADID_set_numeric(id, val)
+#define CRYPTO_THREADID_set_pointer(id, ptr)
+#define CRYPTO_THREADID_set_callback(threadid_func) (0)
+#define CRYPTO_THREADID_get_callback() (NULL)
+#define CRYPTO_THREADID_current(id)
+#define CRYPTO_THREADID_cmp(a, b) (-1)
+#define CRYPTO_THREADID_cpy(dest, src)
+#define CRYPTO_THREADID_hash(id) (0UL)
+
+#ifndef OPENSSL_NO_DEPRECATED_1_0_0
+#define CRYPTO_set_id_callback(func)
+#define CRYPTO_get_id_callback() (NULL)
+#define CRYPTO_thread_id() (0UL)
+#endif /* OPENSSL_NO_DEPRECATED_1_0_0 */
+
+#define CRYPTO_set_dynlock_create_callback(dyn_create_function)
+#define CRYPTO_set_dynlock_lock_callback(dyn_lock_function)
+#define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function)
+#define CRYPTO_get_dynlock_create_callback() (NULL)
+#define CRYPTO_get_dynlock_lock_callback() (NULL)
+#define CRYPTO_get_dynlock_destroy_callback() (NULL)
+#endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
+
+    typedef void* (*CRYPTO_malloc_fn)(size_t num, const char* file, int line);
+    typedef void* (*CRYPTO_realloc_fn)(void* addr, size_t num, const char* file, int line);
+    typedef void (*CRYPTO_free_fn)(void* addr, const char* file, int line);
+    int CRYPTO_set_mem_functions(CRYPTO_malloc_fn malloc_fn, CRYPTO_realloc_fn realloc_fn, CRYPTO_free_fn free_fn);
+    void CRYPTO_get_mem_functions(CRYPTO_malloc_fn* malloc_fn, CRYPTO_realloc_fn* realloc_fn, CRYPTO_free_fn* free_fn);
+
+    void* CRYPTO_malloc(size_t num, const char* file, int line);
+    void* CRYPTO_zalloc(size_t num, const char* file, int line);
+    void* CRYPTO_memdup(const void* str, size_t siz, const char* file, int line);
+    char* CRYPTO_strdup(const char* str, const char* file, int line);
+    char* CRYPTO_strndup(const char* str, size_t s, const char* file, int line);
+    void CRYPTO_free(void* ptr, const char* file, int line);
+    void CRYPTO_clear_free(void* ptr, size_t num, const char* file, int line);
+    void* CRYPTO_realloc(void* addr, size_t num, const char* file, int line);
+    void* CRYPTO_clear_realloc(void* addr, size_t old_num, size_t num, const char* file, int line);
+
+    int CRYPTO_secure_malloc_init(size_t sz, size_t minsize);
+    int CRYPTO_secure_malloc_done(void);
+    void* CRYPTO_secure_malloc(size_t num, const char* file, int line);
+    void* CRYPTO_secure_zalloc(size_t num, const char* file, int line);
+    void CRYPTO_secure_free(void* ptr, const char* file, int line);
+    void CRYPTO_secure_clear_free(void* ptr, size_t num, const char* file, int line);
+    int CRYPTO_secure_allocated(const void* ptr);
+    int CRYPTO_secure_malloc_initialized(void);
+    size_t CRYPTO_secure_actual_size(void* ptr);
+    size_t CRYPTO_secure_used(void);
+
+    void OPENSSL_cleanse(void* ptr, size_t len);
+
+#ifndef OPENSSL_NO_CRYPTO_MDEBUG
 /*
  * The following can be used to detect memory leaks in the library. If
  * used, it turns on malloc checking
  */
-# define CRYPTO_MEM_CHECK_OFF     0x0   /* Control only */
-# define CRYPTO_MEM_CHECK_ON      0x1   /* Control and mode bit */
-# define CRYPTO_MEM_CHECK_ENABLE  0x2   /* Control and mode bit */
-# define CRYPTO_MEM_CHECK_DISABLE 0x3   /* Control only */
-
-void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount);
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#    define OPENSSL_mem_debug_push(info) \
-         CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE)
-#    define OPENSSL_mem_debug_pop() \
-         CRYPTO_mem_debug_pop()
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int CRYPTO_set_mem_debug(int flag);
-OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_ctrl(int mode);
-OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_push(const char *info,
-                                                const char *file, int line);
-OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_pop(void);
-OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_malloc(void *addr, size_t num,
-                                                   int flag,
-                                                   const char *file, int line);
-OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_realloc(void *addr1, void *addr2,
-                                                    size_t num, int flag,
-                                                    const char *file, int line);
-OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_free(void *addr, int flag,
-                                                 const char *file, int line);
-OSSL_DEPRECATEDIN_3_0
-int CRYPTO_mem_leaks_cb(int (*cb)(const char *str, size_t len, void *u),
-                        void *u);
-#  endif
-#  ifndef OPENSSL_NO_STDIO
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks_fp(FILE *);
-#  endif
-#  endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks(BIO *bio);
-# endif
-# endif /* OPENSSL_NO_CRYPTO_MDEBUG */
-
-/* die if we have to */
-ossl_noreturn void OPENSSL_die(const char *assertion, const char *file, int line);
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define OpenSSLDie(f,l,a) OPENSSL_die((a),(f),(l))
-# endif
-# define OPENSSL_assert(e) \
+#define CRYPTO_MEM_CHECK_OFF 0x0     /* Control only */
+#define CRYPTO_MEM_CHECK_ON 0x1      /* Control and mode bit */
+#define CRYPTO_MEM_CHECK_ENABLE 0x2  /* Control and mode bit */
+#define CRYPTO_MEM_CHECK_DISABLE 0x3 /* Control only */
+
+    void CRYPTO_get_alloc_counts(int* mcount, int* rcount, int* fcount);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define OPENSSL_mem_debug_push(info) \
+    CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE)
+#define OPENSSL_mem_debug_pop() \
+    CRYPTO_mem_debug_pop()
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int CRYPTO_set_mem_debug(int flag);
+    OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_ctrl(int mode);
+    OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_push(const char* info, const char* file, int line);
+    OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_pop(void);
+    OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_malloc(void* addr, size_t num, int flag, const char* file, int line);
+    OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_realloc(void* addr1, void* addr2, size_t num, int flag, const char* file, int line);
+    OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_free(void* addr, int flag, const char* file, int line);
+    OSSL_DEPRECATEDIN_3_0
+    int CRYPTO_mem_leaks_cb(int (*cb)(const char* str, size_t len, void* u), void* u);
+#endif
+#ifndef OPENSSL_NO_STDIO
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks_fp(FILE*);
+#endif
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks(BIO* bio);
+#endif
+#endif /* OPENSSL_NO_CRYPTO_MDEBUG */
+
+    /* die if we have to */
+    ossl_noreturn void OPENSSL_die(const char* assertion, const char* file, int line);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define OpenSSLDie(f, l, a) OPENSSL_die((a), (f), (l))
+#endif
+#define OPENSSL_assert(e) \
     (void)((e) ? 0 : (OPENSSL_die("assertion failed: " #e, OPENSSL_FILE, OPENSSL_LINE), 1))
 
-int OPENSSL_isservice(void);
+    int OPENSSL_isservice(void);
 
-void OPENSSL_init(void);
-# ifdef OPENSSL_SYS_UNIX
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_prepare(void);
-OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_parent(void);
-OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_child(void);
-#  endif
-# endif
+    void OPENSSL_init(void);
+#ifdef OPENSSL_SYS_UNIX
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_prepare(void);
+    OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_parent(void);
+    OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_child(void);
+#endif
+#endif
 
-struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result);
-int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec);
-int OPENSSL_gmtime_diff(int *pday, int *psec,
-                        const struct tm *from, const struct tm *to);
+    struct tm* OPENSSL_gmtime(const time_t* timer, struct tm* result);
+    int OPENSSL_gmtime_adj(struct tm* tm, int offset_day, long offset_sec);
+    int OPENSSL_gmtime_diff(int* pday, int* psec, const struct tm* from, const struct tm* to);
 
-/*
- * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal.
- * It takes an amount of time dependent on |len|, but independent of the
- * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements
- * into a defined order as the return value when a != b is undefined, other
- * than to be non-zero.
- */
-int CRYPTO_memcmp(const void * in_a, const void * in_b, size_t len);
+    /*
+     * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal.
+     * It takes an amount of time dependent on |len|, but independent of the
+     * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements
+     * into a defined order as the return value when a != b is undefined, other
+     * than to be non-zero.
+     */
+    int CRYPTO_memcmp(const void* in_a, const void* in_b, size_t len);
 
 /* Standard initialisation options */
-# define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L
-# define OPENSSL_INIT_LOAD_CRYPTO_STRINGS    0x00000002L
-# define OPENSSL_INIT_ADD_ALL_CIPHERS        0x00000004L
-# define OPENSSL_INIT_ADD_ALL_DIGESTS        0x00000008L
-# define OPENSSL_INIT_NO_ADD_ALL_CIPHERS     0x00000010L
-# define OPENSSL_INIT_NO_ADD_ALL_DIGESTS     0x00000020L
-# define OPENSSL_INIT_LOAD_CONFIG            0x00000040L
-# define OPENSSL_INIT_NO_LOAD_CONFIG         0x00000080L
-# define OPENSSL_INIT_ASYNC                  0x00000100L
-# define OPENSSL_INIT_ENGINE_RDRAND          0x00000200L
-# define OPENSSL_INIT_ENGINE_DYNAMIC         0x00000400L
-# define OPENSSL_INIT_ENGINE_OPENSSL         0x00000800L
-# define OPENSSL_INIT_ENGINE_CRYPTODEV       0x00001000L
-# define OPENSSL_INIT_ENGINE_CAPI            0x00002000L
-# define OPENSSL_INIT_ENGINE_PADLOCK         0x00004000L
-# define OPENSSL_INIT_ENGINE_AFALG           0x00008000L
+#define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L
+#define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L
+#define OPENSSL_INIT_ADD_ALL_CIPHERS 0x00000004L
+#define OPENSSL_INIT_ADD_ALL_DIGESTS 0x00000008L
+#define OPENSSL_INIT_NO_ADD_ALL_CIPHERS 0x00000010L
+#define OPENSSL_INIT_NO_ADD_ALL_DIGESTS 0x00000020L
+#define OPENSSL_INIT_LOAD_CONFIG 0x00000040L
+#define OPENSSL_INIT_NO_LOAD_CONFIG 0x00000080L
+#define OPENSSL_INIT_ASYNC 0x00000100L
+#define OPENSSL_INIT_ENGINE_RDRAND 0x00000200L
+#define OPENSSL_INIT_ENGINE_DYNAMIC 0x00000400L
+#define OPENSSL_INIT_ENGINE_OPENSSL 0x00000800L
+#define OPENSSL_INIT_ENGINE_CRYPTODEV 0x00001000L
+#define OPENSSL_INIT_ENGINE_CAPI 0x00002000L
+#define OPENSSL_INIT_ENGINE_PADLOCK 0x00004000L
+#define OPENSSL_INIT_ENGINE_AFALG 0x00008000L
 /* FREE:                                     0x00010000L */
-# define OPENSSL_INIT_ATFORK                 0x00020000L
+#define OPENSSL_INIT_ATFORK 0x00020000L
 /* OPENSSL_INIT_BASE_ONLY                    0x00040000L */
-# define OPENSSL_INIT_NO_ATEXIT              0x00080000L
+#define OPENSSL_INIT_NO_ATEXIT 0x00080000L
 /* OPENSSL_INIT flag range 0x03f00000 reserved for OPENSSL_init_ssl() */
 /* FREE: 0x04000000L */
 /* FREE: 0x08000000L */
@@ -475,84 +452,78 @@ int CRYPTO_memcmp(const void * in_a, const void * in_b, size_t len);
 /* Max OPENSSL_INIT flag value is 0x80000000 */
 
 /* openssl and dasync not counted as builtin */
-# define OPENSSL_INIT_ENGINE_ALL_BUILTIN \
-    (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC \
-    | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | \
-    OPENSSL_INIT_ENGINE_PADLOCK)
-
-/* Library initialisation functions */
-void OPENSSL_cleanup(void);
-int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
-int OPENSSL_atexit(void (*handler)(void));
-void OPENSSL_thread_stop(void);
-void OPENSSL_thread_stop_ex(OSSL_LIB_CTX *ctx);
-
-/* Low-level control of initialization */
-OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void);
-# ifndef OPENSSL_NO_STDIO
-int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings,
-                                     const char *config_filename);
-void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings,
-                                        unsigned long flags);
-int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings,
-                                    const char *config_appname);
-# endif
-void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings);
-
-# if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
-#  if defined(_WIN32)
-#   if defined(BASETYPES) || defined(_WINDEF_H)
-/* application has to include <windows.h> in order to use this */
-typedef DWORD CRYPTO_THREAD_LOCAL;
-typedef DWORD CRYPTO_THREAD_ID;
-
-typedef LONG CRYPTO_ONCE;
-#    define CRYPTO_ONCE_STATIC_INIT 0
-#   endif
-#  else
-#   if defined(__TANDEM) && defined(_SPT_MODEL_)
-#    define  SPT_THREAD_SIGNAL 1
-#    define  SPT_THREAD_AWARE 1
-#    include <spthread.h>
-#   else
-#    include <pthread.h>
-#   endif
-typedef pthread_once_t CRYPTO_ONCE;
-typedef pthread_key_t CRYPTO_THREAD_LOCAL;
-typedef pthread_t CRYPTO_THREAD_ID;
-
-#   define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT
-#  endif
-# endif
-
-# if !defined(CRYPTO_ONCE_STATIC_INIT)
-typedef unsigned int CRYPTO_ONCE;
-typedef unsigned int CRYPTO_THREAD_LOCAL;
-typedef unsigned int CRYPTO_THREAD_ID;
-#  define CRYPTO_ONCE_STATIC_INIT 0
-# endif
-
-int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void));
-
-int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *));
-void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key);
-int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val);
-int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key);
-
-CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void);
-int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b);
-
-OSSL_LIB_CTX *OSSL_LIB_CTX_new(void);
-OSSL_LIB_CTX *OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE *handle,
-                                             const OSSL_DISPATCH *in);
-OSSL_LIB_CTX *OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE *handle,
-                                     const OSSL_DISPATCH *in);
-int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX *ctx, const char *config_file);
-void OSSL_LIB_CTX_free(OSSL_LIB_CTX *);
-OSSL_LIB_CTX *OSSL_LIB_CTX_get0_global_default(void);
-OSSL_LIB_CTX *OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX *libctx);
-
-# ifdef  __cplusplus
+#define OPENSSL_INIT_ENGINE_ALL_BUILTIN                                                                                    \
+    (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | \
+     OPENSSL_INIT_ENGINE_PADLOCK)
+
+    /* Library initialisation functions */
+    void OPENSSL_cleanup(void);
+    int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS* settings);
+    int OPENSSL_atexit(void (*handler)(void));
+    void OPENSSL_thread_stop(void);
+    void OPENSSL_thread_stop_ex(OSSL_LIB_CTX* ctx);
+
+    /* Low-level control of initialization */
+    OPENSSL_INIT_SETTINGS* OPENSSL_INIT_new(void);
+#ifndef OPENSSL_NO_STDIO
+    int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS* settings, const char* config_filename);
+    void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS* settings, unsigned long flags);
+    int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS* settings, const char* config_appname);
+#endif
+    void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS* settings);
+
+#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
+#if defined(_WIN32)
+#if defined(BASETYPES) || defined(_WINDEF_H)
+    /* application has to include <windows.h> in order to use this */
+    typedef DWORD CRYPTO_THREAD_LOCAL;
+    typedef DWORD CRYPTO_THREAD_ID;
+
+    typedef LONG CRYPTO_ONCE;
+#define CRYPTO_ONCE_STATIC_INIT 0
+#endif
+#else
+#if defined(__TANDEM) && defined(_SPT_MODEL_)
+#define SPT_THREAD_SIGNAL 1
+#define SPT_THREAD_AWARE 1
+#include <spthread.h>
+#else
+#include <pthread.h>
+#endif
+    typedef pthread_once_t CRYPTO_ONCE;
+    typedef pthread_key_t CRYPTO_THREAD_LOCAL;
+    typedef pthread_t CRYPTO_THREAD_ID;
+
+#define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT
+#endif
+#endif
+
+#if !defined(CRYPTO_ONCE_STATIC_INIT)
+    typedef unsigned int CRYPTO_ONCE;
+    typedef unsigned int CRYPTO_THREAD_LOCAL;
+    typedef unsigned int CRYPTO_THREAD_ID;
+#define CRYPTO_ONCE_STATIC_INIT 0
+#endif
+
+    int CRYPTO_THREAD_run_once(CRYPTO_ONCE* once, void (*init)(void));
+
+    int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL* key, void (*cleanup)(void*));
+    void* CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL* key);
+    int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL* key, void* val);
+    int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL* key);
+
+    CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void);
+    int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b);
+
+    OSSL_LIB_CTX* OSSL_LIB_CTX_new(void);
+    OSSL_LIB_CTX* OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE* handle, const OSSL_DISPATCH* in);
+    OSSL_LIB_CTX* OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE* handle, const OSSL_DISPATCH* in);
+    int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX* ctx, const char* config_file);
+    void OSSL_LIB_CTX_free(OSSL_LIB_CTX*);
+    OSSL_LIB_CTX* OSSL_LIB_CTX_get0_global_default(void);
+    OSSL_LIB_CTX* OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX* libctx);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/cryptoerr.h b/CAPI/cpp/grpc/include/openssl/cryptoerr.h
index c6a04d9..be0935f 100644
--- a/CAPI/cpp/grpc/include/openssl/cryptoerr.h
+++ b/CAPI/cpp/grpc/include/openssl/cryptoerr.h
@@ -9,38 +9,36 @@
  */
 
 #ifndef OPENSSL_CRYPTOERR_H
-# define OPENSSL_CRYPTOERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_CRYPTOERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * CRYPTO reason codes.
  */
-# define CRYPTO_R_BAD_ALGORITHM_NAME                      117
-# define CRYPTO_R_CONFLICTING_NAMES                       118
-# define CRYPTO_R_HEX_STRING_TOO_SHORT                    121
-# define CRYPTO_R_ILLEGAL_HEX_DIGIT                       102
-# define CRYPTO_R_INSUFFICIENT_DATA_SPACE                 106
-# define CRYPTO_R_INSUFFICIENT_PARAM_SIZE                 107
-# define CRYPTO_R_INSUFFICIENT_SECURE_DATA_SPACE          108
-# define CRYPTO_R_INVALID_NEGATIVE_VALUE                  122
-# define CRYPTO_R_INVALID_NULL_ARGUMENT                   109
-# define CRYPTO_R_INVALID_OSSL_PARAM_TYPE                 110
-# define CRYPTO_R_ODD_NUMBER_OF_DIGITS                    103
-# define CRYPTO_R_PROVIDER_ALREADY_EXISTS                 104
-# define CRYPTO_R_PROVIDER_SECTION_ERROR                  105
-# define CRYPTO_R_RANDOM_SECTION_ERROR                    119
-# define CRYPTO_R_SECURE_MALLOC_FAILURE                   111
-# define CRYPTO_R_STRING_TOO_LONG                         112
-# define CRYPTO_R_TOO_MANY_BYTES                          113
-# define CRYPTO_R_TOO_MANY_RECORDS                        114
-# define CRYPTO_R_TOO_SMALL_BUFFER                        116
-# define CRYPTO_R_UNKNOWN_NAME_IN_RANDOM_SECTION          120
-# define CRYPTO_R_ZERO_LENGTH_NUMBER                      115
+#define CRYPTO_R_BAD_ALGORITHM_NAME 117
+#define CRYPTO_R_CONFLICTING_NAMES 118
+#define CRYPTO_R_HEX_STRING_TOO_SHORT 121
+#define CRYPTO_R_ILLEGAL_HEX_DIGIT 102
+#define CRYPTO_R_INSUFFICIENT_DATA_SPACE 106
+#define CRYPTO_R_INSUFFICIENT_PARAM_SIZE 107
+#define CRYPTO_R_INSUFFICIENT_SECURE_DATA_SPACE 108
+#define CRYPTO_R_INVALID_NEGATIVE_VALUE 122
+#define CRYPTO_R_INVALID_NULL_ARGUMENT 109
+#define CRYPTO_R_INVALID_OSSL_PARAM_TYPE 110
+#define CRYPTO_R_ODD_NUMBER_OF_DIGITS 103
+#define CRYPTO_R_PROVIDER_ALREADY_EXISTS 104
+#define CRYPTO_R_PROVIDER_SECTION_ERROR 105
+#define CRYPTO_R_RANDOM_SECTION_ERROR 119
+#define CRYPTO_R_SECURE_MALLOC_FAILURE 111
+#define CRYPTO_R_STRING_TOO_LONG 112
+#define CRYPTO_R_TOO_MANY_BYTES 113
+#define CRYPTO_R_TOO_MANY_RECORDS 114
+#define CRYPTO_R_TOO_SMALL_BUFFER 116
+#define CRYPTO_R_UNKNOWN_NAME_IN_RANDOM_SECTION 120
+#define CRYPTO_R_ZERO_LENGTH_NUMBER 115
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/cryptoerr_legacy.h b/CAPI/cpp/grpc/include/openssl/cryptoerr_legacy.h
index ccab33a..5129f2f 100644
--- a/CAPI/cpp/grpc/include/openssl/cryptoerr_legacy.h
+++ b/CAPI/cpp/grpc/include/openssl/cryptoerr_legacy.h
@@ -15,1452 +15,1453 @@
  */
 
 #ifndef OPENSSL_CRYPTOERR_LEGACY_H
-# define OPENSSL_CRYPTOERR_LEGACY_H
-# pragma once
+#define OPENSSL_CRYPTOERR_LEGACY_H
+#pragma once
 
-# include <openssl/macros.h>
-# include <openssl/symhacks.h>
+#include <openssl/macros.h>
+#include <openssl/symhacks.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ERR_load_ASN1_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_ASYNC_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_BIO_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_BN_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_BUF_strings(void);
-#  ifndef OPENSSL_NO_CMS
-OSSL_DEPRECATEDIN_3_0 int ERR_load_CMS_strings(void);
-#  endif
-#  ifndef OPENSSL_NO_COMP
-OSSL_DEPRECATEDIN_3_0 int ERR_load_COMP_strings(void);
-#  endif
-OSSL_DEPRECATEDIN_3_0 int ERR_load_CONF_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_CRYPTO_strings(void);
-#  ifndef OPENSSL_NO_CT
-OSSL_DEPRECATEDIN_3_0 int ERR_load_CT_strings(void);
-#  endif
-#  ifndef OPENSSL_NO_DH
-OSSL_DEPRECATEDIN_3_0 int ERR_load_DH_strings(void);
-#  endif
-#  ifndef OPENSSL_NO_DSA
-OSSL_DEPRECATEDIN_3_0 int ERR_load_DSA_strings(void);
-#  endif
-#  ifndef OPENSSL_NO_EC
-OSSL_DEPRECATEDIN_3_0 int ERR_load_EC_strings(void);
-#  endif
-#  ifndef OPENSSL_NO_ENGINE
-OSSL_DEPRECATEDIN_3_0 int ERR_load_ENGINE_strings(void);
-#  endif
-OSSL_DEPRECATEDIN_3_0 int ERR_load_ERR_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_EVP_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_KDF_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_OBJ_strings(void);
-#  ifndef OPENSSL_NO_OCSP
-OSSL_DEPRECATEDIN_3_0 int ERR_load_OCSP_strings(void);
-#  endif
-OSSL_DEPRECATEDIN_3_0 int ERR_load_PEM_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_PKCS12_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_PKCS7_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_RAND_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_RSA_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_OSSL_STORE_strings(void);
-#  ifndef OPENSSL_NO_TS
-OSSL_DEPRECATEDIN_3_0 int ERR_load_TS_strings(void);
-#  endif
-OSSL_DEPRECATEDIN_3_0 int ERR_load_UI_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_X509_strings(void);
-OSSL_DEPRECATEDIN_3_0 int ERR_load_X509V3_strings(void);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_ASN1_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_ASYNC_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_BIO_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_BN_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_BUF_strings(void);
+#ifndef OPENSSL_NO_CMS
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_CMS_strings(void);
+#endif
+#ifndef OPENSSL_NO_COMP
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_COMP_strings(void);
+#endif
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_CONF_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_CRYPTO_strings(void);
+#ifndef OPENSSL_NO_CT
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_CT_strings(void);
+#endif
+#ifndef OPENSSL_NO_DH
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_DH_strings(void);
+#endif
+#ifndef OPENSSL_NO_DSA
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_DSA_strings(void);
+#endif
+#ifndef OPENSSL_NO_EC
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_EC_strings(void);
+#endif
+#ifndef OPENSSL_NO_ENGINE
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_ENGINE_strings(void);
+#endif
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_ERR_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_EVP_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_KDF_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_OBJ_strings(void);
+#ifndef OPENSSL_NO_OCSP
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_OCSP_strings(void);
+#endif
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_PEM_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_PKCS12_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_PKCS7_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_RAND_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_RSA_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_OSSL_STORE_strings(void);
+#ifndef OPENSSL_NO_TS
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_TS_strings(void);
+#endif
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_UI_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_X509_strings(void);
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_X509V3_strings(void);
 
 /* Collected _F_ macros from OpenSSL 1.1.1 */
 
 /*
  * ASN1 function codes.
  */
-#  define ASN1_F_A2D_ASN1_OBJECT                           0
-#  define ASN1_F_A2I_ASN1_INTEGER                          0
-#  define ASN1_F_A2I_ASN1_STRING                           0
-#  define ASN1_F_APPEND_EXP                                0
-#  define ASN1_F_ASN1_BIO_INIT                             0
-#  define ASN1_F_ASN1_BIT_STRING_SET_BIT                   0
-#  define ASN1_F_ASN1_CB                                   0
-#  define ASN1_F_ASN1_CHECK_TLEN                           0
-#  define ASN1_F_ASN1_COLLECT                              0
-#  define ASN1_F_ASN1_D2I_EX_PRIMITIVE                     0
-#  define ASN1_F_ASN1_D2I_FP                               0
-#  define ASN1_F_ASN1_D2I_READ_BIO                         0
-#  define ASN1_F_ASN1_DIGEST                               0
-#  define ASN1_F_ASN1_DO_ADB                               0
-#  define ASN1_F_ASN1_DO_LOCK                              0
-#  define ASN1_F_ASN1_DUP                                  0
-#  define ASN1_F_ASN1_ENC_SAVE                             0
-#  define ASN1_F_ASN1_EX_C2I                               0
-#  define ASN1_F_ASN1_FIND_END                             0
-#  define ASN1_F_ASN1_GENERALIZEDTIME_ADJ                  0
-#  define ASN1_F_ASN1_GENERATE_V3                          0
-#  define ASN1_F_ASN1_GET_INT64                            0
-#  define ASN1_F_ASN1_GET_OBJECT                           0
-#  define ASN1_F_ASN1_GET_UINT64                           0
-#  define ASN1_F_ASN1_I2D_BIO                              0
-#  define ASN1_F_ASN1_I2D_FP                               0
-#  define ASN1_F_ASN1_ITEM_D2I_FP                          0
-#  define ASN1_F_ASN1_ITEM_DUP                             0
-#  define ASN1_F_ASN1_ITEM_EMBED_D2I                       0
-#  define ASN1_F_ASN1_ITEM_EMBED_NEW                       0
-#  define ASN1_F_ASN1_ITEM_FLAGS_I2D                       0
-#  define ASN1_F_ASN1_ITEM_I2D_BIO                         0
-#  define ASN1_F_ASN1_ITEM_I2D_FP                          0
-#  define ASN1_F_ASN1_ITEM_PACK                            0
-#  define ASN1_F_ASN1_ITEM_SIGN                            0
-#  define ASN1_F_ASN1_ITEM_SIGN_CTX                        0
-#  define ASN1_F_ASN1_ITEM_UNPACK                          0
-#  define ASN1_F_ASN1_ITEM_VERIFY                          0
-#  define ASN1_F_ASN1_MBSTRING_NCOPY                       0
-#  define ASN1_F_ASN1_OBJECT_NEW                           0
-#  define ASN1_F_ASN1_OUTPUT_DATA                          0
-#  define ASN1_F_ASN1_PCTX_NEW                             0
-#  define ASN1_F_ASN1_PRIMITIVE_NEW                        0
-#  define ASN1_F_ASN1_SCTX_NEW                             0
-#  define ASN1_F_ASN1_SIGN                                 0
-#  define ASN1_F_ASN1_STR2TYPE                             0
-#  define ASN1_F_ASN1_STRING_GET_INT64                     0
-#  define ASN1_F_ASN1_STRING_GET_UINT64                    0
-#  define ASN1_F_ASN1_STRING_SET                           0
-#  define ASN1_F_ASN1_STRING_TABLE_ADD                     0
-#  define ASN1_F_ASN1_STRING_TO_BN                         0
-#  define ASN1_F_ASN1_STRING_TYPE_NEW                      0
-#  define ASN1_F_ASN1_TEMPLATE_EX_D2I                      0
-#  define ASN1_F_ASN1_TEMPLATE_NEW                         0
-#  define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I                   0
-#  define ASN1_F_ASN1_TIME_ADJ                             0
-#  define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING             0
-#  define ASN1_F_ASN1_TYPE_GET_OCTETSTRING                 0
-#  define ASN1_F_ASN1_UTCTIME_ADJ                          0
-#  define ASN1_F_ASN1_VERIFY                               0
-#  define ASN1_F_B64_READ_ASN1                             0
-#  define ASN1_F_B64_WRITE_ASN1                            0
-#  define ASN1_F_BIO_NEW_NDEF                              0
-#  define ASN1_F_BITSTR_CB                                 0
-#  define ASN1_F_BN_TO_ASN1_STRING                         0
-#  define ASN1_F_C2I_ASN1_BIT_STRING                       0
-#  define ASN1_F_C2I_ASN1_INTEGER                          0
-#  define ASN1_F_C2I_ASN1_OBJECT                           0
-#  define ASN1_F_C2I_IBUF                                  0
-#  define ASN1_F_C2I_UINT64_INT                            0
-#  define ASN1_F_COLLECT_DATA                              0
-#  define ASN1_F_D2I_ASN1_OBJECT                           0
-#  define ASN1_F_D2I_ASN1_UINTEGER                         0
-#  define ASN1_F_D2I_AUTOPRIVATEKEY                        0
-#  define ASN1_F_D2I_PRIVATEKEY                            0
-#  define ASN1_F_D2I_PUBLICKEY                             0
-#  define ASN1_F_DO_BUF                                    0
-#  define ASN1_F_DO_CREATE                                 0
-#  define ASN1_F_DO_DUMP                                   0
-#  define ASN1_F_DO_TCREATE                                0
-#  define ASN1_F_I2A_ASN1_OBJECT                           0
-#  define ASN1_F_I2D_ASN1_BIO_STREAM                       0
-#  define ASN1_F_I2D_ASN1_OBJECT                           0
-#  define ASN1_F_I2D_DSA_PUBKEY                            0
-#  define ASN1_F_I2D_EC_PUBKEY                             0
-#  define ASN1_F_I2D_PRIVATEKEY                            0
-#  define ASN1_F_I2D_PUBLICKEY                             0
-#  define ASN1_F_I2D_RSA_PUBKEY                            0
-#  define ASN1_F_LONG_C2I                                  0
-#  define ASN1_F_NDEF_PREFIX                               0
-#  define ASN1_F_NDEF_SUFFIX                               0
-#  define ASN1_F_OID_MODULE_INIT                           0
-#  define ASN1_F_PARSE_TAGGING                             0
-#  define ASN1_F_PKCS5_PBE2_SET_IV                         0
-#  define ASN1_F_PKCS5_PBE2_SET_SCRYPT                     0
-#  define ASN1_F_PKCS5_PBE_SET                             0
-#  define ASN1_F_PKCS5_PBE_SET0_ALGOR                      0
-#  define ASN1_F_PKCS5_PBKDF2_SET                          0
-#  define ASN1_F_PKCS5_SCRYPT_SET                          0
-#  define ASN1_F_SMIME_READ_ASN1                           0
-#  define ASN1_F_SMIME_TEXT                                0
-#  define ASN1_F_STABLE_GET                                0
-#  define ASN1_F_STBL_MODULE_INIT                          0
-#  define ASN1_F_UINT32_C2I                                0
-#  define ASN1_F_UINT32_NEW                                0
-#  define ASN1_F_UINT64_C2I                                0
-#  define ASN1_F_UINT64_NEW                                0
-#  define ASN1_F_X509_CRL_ADD0_REVOKED                     0
-#  define ASN1_F_X509_INFO_NEW                             0
-#  define ASN1_F_X509_NAME_ENCODE                          0
-#  define ASN1_F_X509_NAME_EX_D2I                          0
-#  define ASN1_F_X509_NAME_EX_NEW                          0
-#  define ASN1_F_X509_PKEY_NEW                             0
+#define ASN1_F_A2D_ASN1_OBJECT 0
+#define ASN1_F_A2I_ASN1_INTEGER 0
+#define ASN1_F_A2I_ASN1_STRING 0
+#define ASN1_F_APPEND_EXP 0
+#define ASN1_F_ASN1_BIO_INIT 0
+#define ASN1_F_ASN1_BIT_STRING_SET_BIT 0
+#define ASN1_F_ASN1_CB 0
+#define ASN1_F_ASN1_CHECK_TLEN 0
+#define ASN1_F_ASN1_COLLECT 0
+#define ASN1_F_ASN1_D2I_EX_PRIMITIVE 0
+#define ASN1_F_ASN1_D2I_FP 0
+#define ASN1_F_ASN1_D2I_READ_BIO 0
+#define ASN1_F_ASN1_DIGEST 0
+#define ASN1_F_ASN1_DO_ADB 0
+#define ASN1_F_ASN1_DO_LOCK 0
+#define ASN1_F_ASN1_DUP 0
+#define ASN1_F_ASN1_ENC_SAVE 0
+#define ASN1_F_ASN1_EX_C2I 0
+#define ASN1_F_ASN1_FIND_END 0
+#define ASN1_F_ASN1_GENERALIZEDTIME_ADJ 0
+#define ASN1_F_ASN1_GENERATE_V3 0
+#define ASN1_F_ASN1_GET_INT64 0
+#define ASN1_F_ASN1_GET_OBJECT 0
+#define ASN1_F_ASN1_GET_UINT64 0
+#define ASN1_F_ASN1_I2D_BIO 0
+#define ASN1_F_ASN1_I2D_FP 0
+#define ASN1_F_ASN1_ITEM_D2I_FP 0
+#define ASN1_F_ASN1_ITEM_DUP 0
+#define ASN1_F_ASN1_ITEM_EMBED_D2I 0
+#define ASN1_F_ASN1_ITEM_EMBED_NEW 0
+#define ASN1_F_ASN1_ITEM_FLAGS_I2D 0
+#define ASN1_F_ASN1_ITEM_I2D_BIO 0
+#define ASN1_F_ASN1_ITEM_I2D_FP 0
+#define ASN1_F_ASN1_ITEM_PACK 0
+#define ASN1_F_ASN1_ITEM_SIGN 0
+#define ASN1_F_ASN1_ITEM_SIGN_CTX 0
+#define ASN1_F_ASN1_ITEM_UNPACK 0
+#define ASN1_F_ASN1_ITEM_VERIFY 0
+#define ASN1_F_ASN1_MBSTRING_NCOPY 0
+#define ASN1_F_ASN1_OBJECT_NEW 0
+#define ASN1_F_ASN1_OUTPUT_DATA 0
+#define ASN1_F_ASN1_PCTX_NEW 0
+#define ASN1_F_ASN1_PRIMITIVE_NEW 0
+#define ASN1_F_ASN1_SCTX_NEW 0
+#define ASN1_F_ASN1_SIGN 0
+#define ASN1_F_ASN1_STR2TYPE 0
+#define ASN1_F_ASN1_STRING_GET_INT64 0
+#define ASN1_F_ASN1_STRING_GET_UINT64 0
+#define ASN1_F_ASN1_STRING_SET 0
+#define ASN1_F_ASN1_STRING_TABLE_ADD 0
+#define ASN1_F_ASN1_STRING_TO_BN 0
+#define ASN1_F_ASN1_STRING_TYPE_NEW 0
+#define ASN1_F_ASN1_TEMPLATE_EX_D2I 0
+#define ASN1_F_ASN1_TEMPLATE_NEW 0
+#define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I 0
+#define ASN1_F_ASN1_TIME_ADJ 0
+#define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING 0
+#define ASN1_F_ASN1_TYPE_GET_OCTETSTRING 0
+#define ASN1_F_ASN1_UTCTIME_ADJ 0
+#define ASN1_F_ASN1_VERIFY 0
+#define ASN1_F_B64_READ_ASN1 0
+#define ASN1_F_B64_WRITE_ASN1 0
+#define ASN1_F_BIO_NEW_NDEF 0
+#define ASN1_F_BITSTR_CB 0
+#define ASN1_F_BN_TO_ASN1_STRING 0
+#define ASN1_F_C2I_ASN1_BIT_STRING 0
+#define ASN1_F_C2I_ASN1_INTEGER 0
+#define ASN1_F_C2I_ASN1_OBJECT 0
+#define ASN1_F_C2I_IBUF 0
+#define ASN1_F_C2I_UINT64_INT 0
+#define ASN1_F_COLLECT_DATA 0
+#define ASN1_F_D2I_ASN1_OBJECT 0
+#define ASN1_F_D2I_ASN1_UINTEGER 0
+#define ASN1_F_D2I_AUTOPRIVATEKEY 0
+#define ASN1_F_D2I_PRIVATEKEY 0
+#define ASN1_F_D2I_PUBLICKEY 0
+#define ASN1_F_DO_BUF 0
+#define ASN1_F_DO_CREATE 0
+#define ASN1_F_DO_DUMP 0
+#define ASN1_F_DO_TCREATE 0
+#define ASN1_F_I2A_ASN1_OBJECT 0
+#define ASN1_F_I2D_ASN1_BIO_STREAM 0
+#define ASN1_F_I2D_ASN1_OBJECT 0
+#define ASN1_F_I2D_DSA_PUBKEY 0
+#define ASN1_F_I2D_EC_PUBKEY 0
+#define ASN1_F_I2D_PRIVATEKEY 0
+#define ASN1_F_I2D_PUBLICKEY 0
+#define ASN1_F_I2D_RSA_PUBKEY 0
+#define ASN1_F_LONG_C2I 0
+#define ASN1_F_NDEF_PREFIX 0
+#define ASN1_F_NDEF_SUFFIX 0
+#define ASN1_F_OID_MODULE_INIT 0
+#define ASN1_F_PARSE_TAGGING 0
+#define ASN1_F_PKCS5_PBE2_SET_IV 0
+#define ASN1_F_PKCS5_PBE2_SET_SCRYPT 0
+#define ASN1_F_PKCS5_PBE_SET 0
+#define ASN1_F_PKCS5_PBE_SET0_ALGOR 0
+#define ASN1_F_PKCS5_PBKDF2_SET 0
+#define ASN1_F_PKCS5_SCRYPT_SET 0
+#define ASN1_F_SMIME_READ_ASN1 0
+#define ASN1_F_SMIME_TEXT 0
+#define ASN1_F_STABLE_GET 0
+#define ASN1_F_STBL_MODULE_INIT 0
+#define ASN1_F_UINT32_C2I 0
+#define ASN1_F_UINT32_NEW 0
+#define ASN1_F_UINT64_C2I 0
+#define ASN1_F_UINT64_NEW 0
+#define ASN1_F_X509_CRL_ADD0_REVOKED 0
+#define ASN1_F_X509_INFO_NEW 0
+#define ASN1_F_X509_NAME_ENCODE 0
+#define ASN1_F_X509_NAME_EX_D2I 0
+#define ASN1_F_X509_NAME_EX_NEW 0
+#define ASN1_F_X509_PKEY_NEW 0
 
 /*
  * ASYNC function codes.
  */
-#  define ASYNC_F_ASYNC_CTX_NEW                            0
-#  define ASYNC_F_ASYNC_INIT_THREAD                        0
-#  define ASYNC_F_ASYNC_JOB_NEW                            0
-#  define ASYNC_F_ASYNC_PAUSE_JOB                          0
-#  define ASYNC_F_ASYNC_START_FUNC                         0
-#  define ASYNC_F_ASYNC_START_JOB                          0
-#  define ASYNC_F_ASYNC_WAIT_CTX_SET_WAIT_FD               0
+#define ASYNC_F_ASYNC_CTX_NEW 0
+#define ASYNC_F_ASYNC_INIT_THREAD 0
+#define ASYNC_F_ASYNC_JOB_NEW 0
+#define ASYNC_F_ASYNC_PAUSE_JOB 0
+#define ASYNC_F_ASYNC_START_FUNC 0
+#define ASYNC_F_ASYNC_START_JOB 0
+#define ASYNC_F_ASYNC_WAIT_CTX_SET_WAIT_FD 0
 
 /*
  * BIO function codes.
  */
-#  define BIO_F_ACPT_STATE                                 0
-#  define BIO_F_ADDRINFO_WRAP                              0
-#  define BIO_F_ADDR_STRINGS                               0
-#  define BIO_F_BIO_ACCEPT                                 0
-#  define BIO_F_BIO_ACCEPT_EX                              0
-#  define BIO_F_BIO_ACCEPT_NEW                             0
-#  define BIO_F_BIO_ADDR_NEW                               0
-#  define BIO_F_BIO_BIND                                   0
-#  define BIO_F_BIO_CALLBACK_CTRL                          0
-#  define BIO_F_BIO_CONNECT                                0
-#  define BIO_F_BIO_CONNECT_NEW                            0
-#  define BIO_F_BIO_CTRL                                   0
-#  define BIO_F_BIO_GETS                                   0
-#  define BIO_F_BIO_GET_HOST_IP                            0
-#  define BIO_F_BIO_GET_NEW_INDEX                          0
-#  define BIO_F_BIO_GET_PORT                               0
-#  define BIO_F_BIO_LISTEN                                 0
-#  define BIO_F_BIO_LOOKUP                                 0
-#  define BIO_F_BIO_LOOKUP_EX                              0
-#  define BIO_F_BIO_MAKE_PAIR                              0
-#  define BIO_F_BIO_METH_NEW                               0
-#  define BIO_F_BIO_NEW                                    0
-#  define BIO_F_BIO_NEW_DGRAM_SCTP                         0
-#  define BIO_F_BIO_NEW_FILE                               0
-#  define BIO_F_BIO_NEW_MEM_BUF                            0
-#  define BIO_F_BIO_NREAD                                  0
-#  define BIO_F_BIO_NREAD0                                 0
-#  define BIO_F_BIO_NWRITE                                 0
-#  define BIO_F_BIO_NWRITE0                                0
-#  define BIO_F_BIO_PARSE_HOSTSERV                         0
-#  define BIO_F_BIO_PUTS                                   0
-#  define BIO_F_BIO_READ                                   0
-#  define BIO_F_BIO_READ_EX                                0
-#  define BIO_F_BIO_READ_INTERN                            0
-#  define BIO_F_BIO_SOCKET                                 0
-#  define BIO_F_BIO_SOCKET_NBIO                            0
-#  define BIO_F_BIO_SOCK_INFO                              0
-#  define BIO_F_BIO_SOCK_INIT                              0
-#  define BIO_F_BIO_WRITE                                  0
-#  define BIO_F_BIO_WRITE_EX                               0
-#  define BIO_F_BIO_WRITE_INTERN                           0
-#  define BIO_F_BUFFER_CTRL                                0
-#  define BIO_F_CONN_CTRL                                  0
-#  define BIO_F_CONN_STATE                                 0
-#  define BIO_F_DGRAM_SCTP_NEW                             0
-#  define BIO_F_DGRAM_SCTP_READ                            0
-#  define BIO_F_DGRAM_SCTP_WRITE                           0
-#  define BIO_F_DOAPR_OUTCH                                0
-#  define BIO_F_FILE_CTRL                                  0
-#  define BIO_F_FILE_READ                                  0
-#  define BIO_F_LINEBUFFER_CTRL                            0
-#  define BIO_F_LINEBUFFER_NEW                             0
-#  define BIO_F_MEM_WRITE                                  0
-#  define BIO_F_NBIOF_NEW                                  0
-#  define BIO_F_SLG_WRITE                                  0
-#  define BIO_F_SSL_NEW                                    0
+#define BIO_F_ACPT_STATE 0
+#define BIO_F_ADDRINFO_WRAP 0
+#define BIO_F_ADDR_STRINGS 0
+#define BIO_F_BIO_ACCEPT 0
+#define BIO_F_BIO_ACCEPT_EX 0
+#define BIO_F_BIO_ACCEPT_NEW 0
+#define BIO_F_BIO_ADDR_NEW 0
+#define BIO_F_BIO_BIND 0
+#define BIO_F_BIO_CALLBACK_CTRL 0
+#define BIO_F_BIO_CONNECT 0
+#define BIO_F_BIO_CONNECT_NEW 0
+#define BIO_F_BIO_CTRL 0
+#define BIO_F_BIO_GETS 0
+#define BIO_F_BIO_GET_HOST_IP 0
+#define BIO_F_BIO_GET_NEW_INDEX 0
+#define BIO_F_BIO_GET_PORT 0
+#define BIO_F_BIO_LISTEN 0
+#define BIO_F_BIO_LOOKUP 0
+#define BIO_F_BIO_LOOKUP_EX 0
+#define BIO_F_BIO_MAKE_PAIR 0
+#define BIO_F_BIO_METH_NEW 0
+#define BIO_F_BIO_NEW 0
+#define BIO_F_BIO_NEW_DGRAM_SCTP 0
+#define BIO_F_BIO_NEW_FILE 0
+#define BIO_F_BIO_NEW_MEM_BUF 0
+#define BIO_F_BIO_NREAD 0
+#define BIO_F_BIO_NREAD0 0
+#define BIO_F_BIO_NWRITE 0
+#define BIO_F_BIO_NWRITE0 0
+#define BIO_F_BIO_PARSE_HOSTSERV 0
+#define BIO_F_BIO_PUTS 0
+#define BIO_F_BIO_READ 0
+#define BIO_F_BIO_READ_EX 0
+#define BIO_F_BIO_READ_INTERN 0
+#define BIO_F_BIO_SOCKET 0
+#define BIO_F_BIO_SOCKET_NBIO 0
+#define BIO_F_BIO_SOCK_INFO 0
+#define BIO_F_BIO_SOCK_INIT 0
+#define BIO_F_BIO_WRITE 0
+#define BIO_F_BIO_WRITE_EX 0
+#define BIO_F_BIO_WRITE_INTERN 0
+#define BIO_F_BUFFER_CTRL 0
+#define BIO_F_CONN_CTRL 0
+#define BIO_F_CONN_STATE 0
+#define BIO_F_DGRAM_SCTP_NEW 0
+#define BIO_F_DGRAM_SCTP_READ 0
+#define BIO_F_DGRAM_SCTP_WRITE 0
+#define BIO_F_DOAPR_OUTCH 0
+#define BIO_F_FILE_CTRL 0
+#define BIO_F_FILE_READ 0
+#define BIO_F_LINEBUFFER_CTRL 0
+#define BIO_F_LINEBUFFER_NEW 0
+#define BIO_F_MEM_WRITE 0
+#define BIO_F_NBIOF_NEW 0
+#define BIO_F_SLG_WRITE 0
+#define BIO_F_SSL_NEW 0
 
 /*
  * BN function codes.
  */
-#  define BN_F_BNRAND                                      0
-#  define BN_F_BNRAND_RANGE                                0
-#  define BN_F_BN_BLINDING_CONVERT_EX                      0
-#  define BN_F_BN_BLINDING_CREATE_PARAM                    0
-#  define BN_F_BN_BLINDING_INVERT_EX                       0
-#  define BN_F_BN_BLINDING_NEW                             0
-#  define BN_F_BN_BLINDING_UPDATE                          0
-#  define BN_F_BN_BN2DEC                                   0
-#  define BN_F_BN_BN2HEX                                   0
-#  define BN_F_BN_COMPUTE_WNAF                             0
-#  define BN_F_BN_CTX_GET                                  0
-#  define BN_F_BN_CTX_NEW                                  0
-#  define BN_F_BN_CTX_START                                0
-#  define BN_F_BN_DIV                                      0
-#  define BN_F_BN_DIV_RECP                                 0
-#  define BN_F_BN_EXP                                      0
-#  define BN_F_BN_EXPAND_INTERNAL                          0
-#  define BN_F_BN_GENCB_NEW                                0
-#  define BN_F_BN_GENERATE_DSA_NONCE                       0
-#  define BN_F_BN_GENERATE_PRIME_EX                        0
-#  define BN_F_BN_GF2M_MOD                                 0
-#  define BN_F_BN_GF2M_MOD_EXP                             0
-#  define BN_F_BN_GF2M_MOD_MUL                             0
-#  define BN_F_BN_GF2M_MOD_SOLVE_QUAD                      0
-#  define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR                  0
-#  define BN_F_BN_GF2M_MOD_SQR                             0
-#  define BN_F_BN_GF2M_MOD_SQRT                            0
-#  define BN_F_BN_LSHIFT                                   0
-#  define BN_F_BN_MOD_EXP2_MONT                            0
-#  define BN_F_BN_MOD_EXP_MONT                             0
-#  define BN_F_BN_MOD_EXP_MONT_CONSTTIME                   0
-#  define BN_F_BN_MOD_EXP_MONT_WORD                        0
-#  define BN_F_BN_MOD_EXP_RECP                             0
-#  define BN_F_BN_MOD_EXP_SIMPLE                           0
-#  define BN_F_BN_MOD_INVERSE                              0
-#  define BN_F_BN_MOD_INVERSE_NO_BRANCH                    0
-#  define BN_F_BN_MOD_LSHIFT_QUICK                         0
-#  define BN_F_BN_MOD_SQRT                                 0
-#  define BN_F_BN_MONT_CTX_NEW                             0
-#  define BN_F_BN_MPI2BN                                   0
-#  define BN_F_BN_NEW                                      0
-#  define BN_F_BN_POOL_GET                                 0
-#  define BN_F_BN_RAND                                     0
-#  define BN_F_BN_RAND_RANGE                               0
-#  define BN_F_BN_RECP_CTX_NEW                             0
-#  define BN_F_BN_RSHIFT                                   0
-#  define BN_F_BN_SET_WORDS                                0
-#  define BN_F_BN_STACK_PUSH                               0
-#  define BN_F_BN_USUB                                     0
+#define BN_F_BNRAND 0
+#define BN_F_BNRAND_RANGE 0
+#define BN_F_BN_BLINDING_CONVERT_EX 0
+#define BN_F_BN_BLINDING_CREATE_PARAM 0
+#define BN_F_BN_BLINDING_INVERT_EX 0
+#define BN_F_BN_BLINDING_NEW 0
+#define BN_F_BN_BLINDING_UPDATE 0
+#define BN_F_BN_BN2DEC 0
+#define BN_F_BN_BN2HEX 0
+#define BN_F_BN_COMPUTE_WNAF 0
+#define BN_F_BN_CTX_GET 0
+#define BN_F_BN_CTX_NEW 0
+#define BN_F_BN_CTX_START 0
+#define BN_F_BN_DIV 0
+#define BN_F_BN_DIV_RECP 0
+#define BN_F_BN_EXP 0
+#define BN_F_BN_EXPAND_INTERNAL 0
+#define BN_F_BN_GENCB_NEW 0
+#define BN_F_BN_GENERATE_DSA_NONCE 0
+#define BN_F_BN_GENERATE_PRIME_EX 0
+#define BN_F_BN_GF2M_MOD 0
+#define BN_F_BN_GF2M_MOD_EXP 0
+#define BN_F_BN_GF2M_MOD_MUL 0
+#define BN_F_BN_GF2M_MOD_SOLVE_QUAD 0
+#define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR 0
+#define BN_F_BN_GF2M_MOD_SQR 0
+#define BN_F_BN_GF2M_MOD_SQRT 0
+#define BN_F_BN_LSHIFT 0
+#define BN_F_BN_MOD_EXP2_MONT 0
+#define BN_F_BN_MOD_EXP_MONT 0
+#define BN_F_BN_MOD_EXP_MONT_CONSTTIME 0
+#define BN_F_BN_MOD_EXP_MONT_WORD 0
+#define BN_F_BN_MOD_EXP_RECP 0
+#define BN_F_BN_MOD_EXP_SIMPLE 0
+#define BN_F_BN_MOD_INVERSE 0
+#define BN_F_BN_MOD_INVERSE_NO_BRANCH 0
+#define BN_F_BN_MOD_LSHIFT_QUICK 0
+#define BN_F_BN_MOD_SQRT 0
+#define BN_F_BN_MONT_CTX_NEW 0
+#define BN_F_BN_MPI2BN 0
+#define BN_F_BN_NEW 0
+#define BN_F_BN_POOL_GET 0
+#define BN_F_BN_RAND 0
+#define BN_F_BN_RAND_RANGE 0
+#define BN_F_BN_RECP_CTX_NEW 0
+#define BN_F_BN_RSHIFT 0
+#define BN_F_BN_SET_WORDS 0
+#define BN_F_BN_STACK_PUSH 0
+#define BN_F_BN_USUB 0
 
 /*
  * BUF function codes.
  */
-#  define BUF_F_BUF_MEM_GROW                               0
-#  define BUF_F_BUF_MEM_GROW_CLEAN                         0
-#  define BUF_F_BUF_MEM_NEW                                0
+#define BUF_F_BUF_MEM_GROW 0
+#define BUF_F_BUF_MEM_GROW_CLEAN 0
+#define BUF_F_BUF_MEM_NEW 0
 
-#  ifndef OPENSSL_NO_CMS
+#ifndef OPENSSL_NO_CMS
 /*
  * CMS function codes.
  */
-#   define CMS_F_CHECK_CONTENT                              0
-#   define CMS_F_CMS_ADD0_CERT                              0
-#   define CMS_F_CMS_ADD0_RECIPIENT_KEY                     0
-#   define CMS_F_CMS_ADD0_RECIPIENT_PASSWORD                0
-#   define CMS_F_CMS_ADD1_RECEIPTREQUEST                    0
-#   define CMS_F_CMS_ADD1_RECIPIENT_CERT                    0
-#   define CMS_F_CMS_ADD1_SIGNER                            0
-#   define CMS_F_CMS_ADD1_SIGNINGTIME                       0
-#   define CMS_F_CMS_COMPRESS                               0
-#   define CMS_F_CMS_COMPRESSEDDATA_CREATE                  0
-#   define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO                0
-#   define CMS_F_CMS_COPY_CONTENT                           0
-#   define CMS_F_CMS_COPY_MESSAGEDIGEST                     0
-#   define CMS_F_CMS_DATA                                   0
-#   define CMS_F_CMS_DATAFINAL                              0
-#   define CMS_F_CMS_DATAINIT                               0
-#   define CMS_F_CMS_DECRYPT                                0
-#   define CMS_F_CMS_DECRYPT_SET1_KEY                       0
-#   define CMS_F_CMS_DECRYPT_SET1_PASSWORD                  0
-#   define CMS_F_CMS_DECRYPT_SET1_PKEY                      0
-#   define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX               0
-#   define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO               0
-#   define CMS_F_CMS_DIGESTEDDATA_DO_FINAL                  0
-#   define CMS_F_CMS_DIGEST_VERIFY                          0
-#   define CMS_F_CMS_ENCODE_RECEIPT                         0
-#   define CMS_F_CMS_ENCRYPT                                0
-#   define CMS_F_CMS_ENCRYPTEDCONTENT_INIT                  0
-#   define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO              0
-#   define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT                  0
-#   define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT                  0
-#   define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY                 0
-#   define CMS_F_CMS_ENVELOPEDDATA_CREATE                   0
-#   define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO                 0
-#   define CMS_F_CMS_ENVELOPED_DATA_INIT                    0
-#   define CMS_F_CMS_ENV_ASN1_CTRL                          0
-#   define CMS_F_CMS_FINAL                                  0
-#   define CMS_F_CMS_GET0_CERTIFICATE_CHOICES               0
-#   define CMS_F_CMS_GET0_CONTENT                           0
-#   define CMS_F_CMS_GET0_ECONTENT_TYPE                     0
-#   define CMS_F_CMS_GET0_ENVELOPED                         0
-#   define CMS_F_CMS_GET0_REVOCATION_CHOICES                0
-#   define CMS_F_CMS_GET0_SIGNED                            0
-#   define CMS_F_CMS_MSGSIGDIGEST_ADD1                      0
-#   define CMS_F_CMS_RECEIPTREQUEST_CREATE0                 0
-#   define CMS_F_CMS_RECEIPT_VERIFY                         0
-#   define CMS_F_CMS_RECIPIENTINFO_DECRYPT                  0
-#   define CMS_F_CMS_RECIPIENTINFO_ENCRYPT                  0
-#   define CMS_F_CMS_RECIPIENTINFO_KARI_ENCRYPT             0
-#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ALG            0
-#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ORIG_ID        0
-#   define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_REKS           0
-#   define CMS_F_CMS_RECIPIENTINFO_KARI_ORIG_ID_CMP         0
-#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT            0
-#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT            0
-#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID            0
-#   define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP             0
-#   define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP            0
-#   define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT             0
-#   define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT             0
-#   define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS           0
-#   define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID      0
-#   define CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT               0
-#   define CMS_F_CMS_RECIPIENTINFO_SET0_KEY                 0
-#   define CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD            0
-#   define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY                0
-#   define CMS_F_CMS_SD_ASN1_CTRL                           0
-#   define CMS_F_CMS_SET1_IAS                               0
-#   define CMS_F_CMS_SET1_KEYID                             0
-#   define CMS_F_CMS_SET1_SIGNERIDENTIFIER                  0
-#   define CMS_F_CMS_SET_DETACHED                           0
-#   define CMS_F_CMS_SIGN                                   0
-#   define CMS_F_CMS_SIGNED_DATA_INIT                       0
-#   define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN                0
-#   define CMS_F_CMS_SIGNERINFO_SIGN                        0
-#   define CMS_F_CMS_SIGNERINFO_VERIFY                      0
-#   define CMS_F_CMS_SIGNERINFO_VERIFY_CERT                 0
-#   define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT              0
-#   define CMS_F_CMS_SIGN_RECEIPT                           0
-#   define CMS_F_CMS_SI_CHECK_ATTRIBUTES                    0
-#   define CMS_F_CMS_STREAM                                 0
-#   define CMS_F_CMS_UNCOMPRESS                             0
-#   define CMS_F_CMS_VERIFY                                 0
-#   define CMS_F_KEK_UNWRAP_KEY                             0
-#  endif
+#define CMS_F_CHECK_CONTENT 0
+#define CMS_F_CMS_ADD0_CERT 0
+#define CMS_F_CMS_ADD0_RECIPIENT_KEY 0
+#define CMS_F_CMS_ADD0_RECIPIENT_PASSWORD 0
+#define CMS_F_CMS_ADD1_RECEIPTREQUEST 0
+#define CMS_F_CMS_ADD1_RECIPIENT_CERT 0
+#define CMS_F_CMS_ADD1_SIGNER 0
+#define CMS_F_CMS_ADD1_SIGNINGTIME 0
+#define CMS_F_CMS_COMPRESS 0
+#define CMS_F_CMS_COMPRESSEDDATA_CREATE 0
+#define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO 0
+#define CMS_F_CMS_COPY_CONTENT 0
+#define CMS_F_CMS_COPY_MESSAGEDIGEST 0
+#define CMS_F_CMS_DATA 0
+#define CMS_F_CMS_DATAFINAL 0
+#define CMS_F_CMS_DATAINIT 0
+#define CMS_F_CMS_DECRYPT 0
+#define CMS_F_CMS_DECRYPT_SET1_KEY 0
+#define CMS_F_CMS_DECRYPT_SET1_PASSWORD 0
+#define CMS_F_CMS_DECRYPT_SET1_PKEY 0
+#define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX 0
+#define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO 0
+#define CMS_F_CMS_DIGESTEDDATA_DO_FINAL 0
+#define CMS_F_CMS_DIGEST_VERIFY 0
+#define CMS_F_CMS_ENCODE_RECEIPT 0
+#define CMS_F_CMS_ENCRYPT 0
+#define CMS_F_CMS_ENCRYPTEDCONTENT_INIT 0
+#define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO 0
+#define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT 0
+#define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT 0
+#define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY 0
+#define CMS_F_CMS_ENVELOPEDDATA_CREATE 0
+#define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO 0
+#define CMS_F_CMS_ENVELOPED_DATA_INIT 0
+#define CMS_F_CMS_ENV_ASN1_CTRL 0
+#define CMS_F_CMS_FINAL 0
+#define CMS_F_CMS_GET0_CERTIFICATE_CHOICES 0
+#define CMS_F_CMS_GET0_CONTENT 0
+#define CMS_F_CMS_GET0_ECONTENT_TYPE 0
+#define CMS_F_CMS_GET0_ENVELOPED 0
+#define CMS_F_CMS_GET0_REVOCATION_CHOICES 0
+#define CMS_F_CMS_GET0_SIGNED 0
+#define CMS_F_CMS_MSGSIGDIGEST_ADD1 0
+#define CMS_F_CMS_RECEIPTREQUEST_CREATE0 0
+#define CMS_F_CMS_RECEIPT_VERIFY 0
+#define CMS_F_CMS_RECIPIENTINFO_DECRYPT 0
+#define CMS_F_CMS_RECIPIENTINFO_ENCRYPT 0
+#define CMS_F_CMS_RECIPIENTINFO_KARI_ENCRYPT 0
+#define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ALG 0
+#define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ORIG_ID 0
+#define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_REKS 0
+#define CMS_F_CMS_RECIPIENTINFO_KARI_ORIG_ID_CMP 0
+#define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT 0
+#define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT 0
+#define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID 0
+#define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP 0
+#define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP 0
+#define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT 0
+#define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT 0
+#define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS 0
+#define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID 0
+#define CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT 0
+#define CMS_F_CMS_RECIPIENTINFO_SET0_KEY 0
+#define CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD 0
+#define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY 0
+#define CMS_F_CMS_SD_ASN1_CTRL 0
+#define CMS_F_CMS_SET1_IAS 0
+#define CMS_F_CMS_SET1_KEYID 0
+#define CMS_F_CMS_SET1_SIGNERIDENTIFIER 0
+#define CMS_F_CMS_SET_DETACHED 0
+#define CMS_F_CMS_SIGN 0
+#define CMS_F_CMS_SIGNED_DATA_INIT 0
+#define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN 0
+#define CMS_F_CMS_SIGNERINFO_SIGN 0
+#define CMS_F_CMS_SIGNERINFO_VERIFY 0
+#define CMS_F_CMS_SIGNERINFO_VERIFY_CERT 0
+#define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT 0
+#define CMS_F_CMS_SIGN_RECEIPT 0
+#define CMS_F_CMS_SI_CHECK_ATTRIBUTES 0
+#define CMS_F_CMS_STREAM 0
+#define CMS_F_CMS_UNCOMPRESS 0
+#define CMS_F_CMS_VERIFY 0
+#define CMS_F_KEK_UNWRAP_KEY 0
+#endif
 
-#  ifndef OPENSSL_NO_COMP
+#ifndef OPENSSL_NO_COMP
 /*
  * COMP function codes.
  */
-#   define COMP_F_BIO_ZLIB_FLUSH                            0
-#   define COMP_F_BIO_ZLIB_NEW                              0
-#   define COMP_F_BIO_ZLIB_READ                             0
-#   define COMP_F_BIO_ZLIB_WRITE                            0
-#   define COMP_F_COMP_CTX_NEW                              0
-#  endif
+#define COMP_F_BIO_ZLIB_FLUSH 0
+#define COMP_F_BIO_ZLIB_NEW 0
+#define COMP_F_BIO_ZLIB_READ 0
+#define COMP_F_BIO_ZLIB_WRITE 0
+#define COMP_F_COMP_CTX_NEW 0
+#endif
 
 /*
  * CONF function codes.
  */
-#  define CONF_F_CONF_DUMP_FP                              0
-#  define CONF_F_CONF_LOAD                                 0
-#  define CONF_F_CONF_LOAD_FP                              0
-#  define CONF_F_CONF_PARSE_LIST                           0
-#  define CONF_F_DEF_LOAD                                  0
-#  define CONF_F_DEF_LOAD_BIO                              0
-#  define CONF_F_GET_NEXT_FILE                             0
-#  define CONF_F_MODULE_ADD                                0
-#  define CONF_F_MODULE_INIT                               0
-#  define CONF_F_MODULE_LOAD_DSO                           0
-#  define CONF_F_MODULE_RUN                                0
-#  define CONF_F_NCONF_DUMP_BIO                            0
-#  define CONF_F_NCONF_DUMP_FP                             0
-#  define CONF_F_NCONF_GET_NUMBER_E                        0
-#  define CONF_F_NCONF_GET_SECTION                         0
-#  define CONF_F_NCONF_GET_STRING                          0
-#  define CONF_F_NCONF_LOAD                                0
-#  define CONF_F_NCONF_LOAD_BIO                            0
-#  define CONF_F_NCONF_LOAD_FP                             0
-#  define CONF_F_NCONF_NEW                                 0
-#  define CONF_F_PROCESS_INCLUDE                           0
-#  define CONF_F_SSL_MODULE_INIT                           0
-#  define CONF_F_STR_COPY                                  0
+#define CONF_F_CONF_DUMP_FP 0
+#define CONF_F_CONF_LOAD 0
+#define CONF_F_CONF_LOAD_FP 0
+#define CONF_F_CONF_PARSE_LIST 0
+#define CONF_F_DEF_LOAD 0
+#define CONF_F_DEF_LOAD_BIO 0
+#define CONF_F_GET_NEXT_FILE 0
+#define CONF_F_MODULE_ADD 0
+#define CONF_F_MODULE_INIT 0
+#define CONF_F_MODULE_LOAD_DSO 0
+#define CONF_F_MODULE_RUN 0
+#define CONF_F_NCONF_DUMP_BIO 0
+#define CONF_F_NCONF_DUMP_FP 0
+#define CONF_F_NCONF_GET_NUMBER_E 0
+#define CONF_F_NCONF_GET_SECTION 0
+#define CONF_F_NCONF_GET_STRING 0
+#define CONF_F_NCONF_LOAD 0
+#define CONF_F_NCONF_LOAD_BIO 0
+#define CONF_F_NCONF_LOAD_FP 0
+#define CONF_F_NCONF_NEW 0
+#define CONF_F_PROCESS_INCLUDE 0
+#define CONF_F_SSL_MODULE_INIT 0
+#define CONF_F_STR_COPY 0
 
 /*
  * CRYPTO function codes.
  */
-#  define CRYPTO_F_CMAC_CTX_NEW                            0
-#  define CRYPTO_F_CRYPTO_DUP_EX_DATA                      0
-#  define CRYPTO_F_CRYPTO_FREE_EX_DATA                     0
-#  define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX                 0
-#  define CRYPTO_F_CRYPTO_MEMDUP                           0
-#  define CRYPTO_F_CRYPTO_NEW_EX_DATA                      0
-#  define CRYPTO_F_CRYPTO_OCB128_COPY_CTX                  0
-#  define CRYPTO_F_CRYPTO_OCB128_INIT                      0
-#  define CRYPTO_F_CRYPTO_SET_EX_DATA                      0
-#  define CRYPTO_F_GET_AND_LOCK                            0
-#  define CRYPTO_F_OPENSSL_ATEXIT                          0
-#  define CRYPTO_F_OPENSSL_BUF2HEXSTR                      0
-#  define CRYPTO_F_OPENSSL_FOPEN                           0
-#  define CRYPTO_F_OPENSSL_HEXSTR2BUF                      0
-#  define CRYPTO_F_OPENSSL_INIT_CRYPTO                     0
-#  define CRYPTO_F_OPENSSL_LH_NEW                          0
-#  define CRYPTO_F_OPENSSL_SK_DEEP_COPY                    0
-#  define CRYPTO_F_OPENSSL_SK_DUP                          0
-#  define CRYPTO_F_PKEY_HMAC_INIT                          0
-#  define CRYPTO_F_PKEY_POLY1305_INIT                      0
-#  define CRYPTO_F_PKEY_SIPHASH_INIT                       0
-#  define CRYPTO_F_SK_RESERVE                              0
+#define CRYPTO_F_CMAC_CTX_NEW 0
+#define CRYPTO_F_CRYPTO_DUP_EX_DATA 0
+#define CRYPTO_F_CRYPTO_FREE_EX_DATA 0
+#define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 0
+#define CRYPTO_F_CRYPTO_MEMDUP 0
+#define CRYPTO_F_CRYPTO_NEW_EX_DATA 0
+#define CRYPTO_F_CRYPTO_OCB128_COPY_CTX 0
+#define CRYPTO_F_CRYPTO_OCB128_INIT 0
+#define CRYPTO_F_CRYPTO_SET_EX_DATA 0
+#define CRYPTO_F_GET_AND_LOCK 0
+#define CRYPTO_F_OPENSSL_ATEXIT 0
+#define CRYPTO_F_OPENSSL_BUF2HEXSTR 0
+#define CRYPTO_F_OPENSSL_FOPEN 0
+#define CRYPTO_F_OPENSSL_HEXSTR2BUF 0
+#define CRYPTO_F_OPENSSL_INIT_CRYPTO 0
+#define CRYPTO_F_OPENSSL_LH_NEW 0
+#define CRYPTO_F_OPENSSL_SK_DEEP_COPY 0
+#define CRYPTO_F_OPENSSL_SK_DUP 0
+#define CRYPTO_F_PKEY_HMAC_INIT 0
+#define CRYPTO_F_PKEY_POLY1305_INIT 0
+#define CRYPTO_F_PKEY_SIPHASH_INIT 0
+#define CRYPTO_F_SK_RESERVE 0
 
-#  ifndef OPENSSL_NO_CT
+#ifndef OPENSSL_NO_CT
 /*
  * CT function codes.
  */
-#   define CT_F_CTLOG_NEW                                   0
-#   define CT_F_CTLOG_NEW_FROM_BASE64                       0
-#   define CT_F_CTLOG_NEW_FROM_CONF                         0
-#   define CT_F_CTLOG_STORE_LOAD_CTX_NEW                    0
-#   define CT_F_CTLOG_STORE_LOAD_FILE                       0
-#   define CT_F_CTLOG_STORE_LOAD_LOG                        0
-#   define CT_F_CTLOG_STORE_NEW                             0
-#   define CT_F_CT_BASE64_DECODE                            0
-#   define CT_F_CT_POLICY_EVAL_CTX_NEW                      0
-#   define CT_F_CT_V1_LOG_ID_FROM_PKEY                      0
-#   define CT_F_I2O_SCT                                     0
-#   define CT_F_I2O_SCT_LIST                                0
-#   define CT_F_I2O_SCT_SIGNATURE                           0
-#   define CT_F_O2I_SCT                                     0
-#   define CT_F_O2I_SCT_LIST                                0
-#   define CT_F_O2I_SCT_SIGNATURE                           0
-#   define CT_F_SCT_CTX_NEW                                 0
-#   define CT_F_SCT_CTX_VERIFY                              0
-#   define CT_F_SCT_NEW                                     0
-#   define CT_F_SCT_NEW_FROM_BASE64                         0
-#   define CT_F_SCT_SET0_LOG_ID                             0
-#   define CT_F_SCT_SET1_EXTENSIONS                         0
-#   define CT_F_SCT_SET1_LOG_ID                             0
-#   define CT_F_SCT_SET1_SIGNATURE                          0
-#   define CT_F_SCT_SET_LOG_ENTRY_TYPE                      0
-#   define CT_F_SCT_SET_SIGNATURE_NID                       0
-#   define CT_F_SCT_SET_VERSION                             0
-#  endif
+#define CT_F_CTLOG_NEW 0
+#define CT_F_CTLOG_NEW_FROM_BASE64 0
+#define CT_F_CTLOG_NEW_FROM_CONF 0
+#define CT_F_CTLOG_STORE_LOAD_CTX_NEW 0
+#define CT_F_CTLOG_STORE_LOAD_FILE 0
+#define CT_F_CTLOG_STORE_LOAD_LOG 0
+#define CT_F_CTLOG_STORE_NEW 0
+#define CT_F_CT_BASE64_DECODE 0
+#define CT_F_CT_POLICY_EVAL_CTX_NEW 0
+#define CT_F_CT_V1_LOG_ID_FROM_PKEY 0
+#define CT_F_I2O_SCT 0
+#define CT_F_I2O_SCT_LIST 0
+#define CT_F_I2O_SCT_SIGNATURE 0
+#define CT_F_O2I_SCT 0
+#define CT_F_O2I_SCT_LIST 0
+#define CT_F_O2I_SCT_SIGNATURE 0
+#define CT_F_SCT_CTX_NEW 0
+#define CT_F_SCT_CTX_VERIFY 0
+#define CT_F_SCT_NEW 0
+#define CT_F_SCT_NEW_FROM_BASE64 0
+#define CT_F_SCT_SET0_LOG_ID 0
+#define CT_F_SCT_SET1_EXTENSIONS 0
+#define CT_F_SCT_SET1_LOG_ID 0
+#define CT_F_SCT_SET1_SIGNATURE 0
+#define CT_F_SCT_SET_LOG_ENTRY_TYPE 0
+#define CT_F_SCT_SET_SIGNATURE_NID 0
+#define CT_F_SCT_SET_VERSION 0
+#endif
 
-#  ifndef OPENSSL_NO_DH
+#ifndef OPENSSL_NO_DH
 /*
  * DH function codes.
  */
-#   define DH_F_COMPUTE_KEY                                 0
-#   define DH_F_DHPARAMS_PRINT_FP                           0
-#   define DH_F_DH_BUILTIN_GENPARAMS                        0
-#   define DH_F_DH_CHECK_EX                                 0
-#   define DH_F_DH_CHECK_PARAMS_EX                          0
-#   define DH_F_DH_CHECK_PUB_KEY_EX                         0
-#   define DH_F_DH_CMS_DECRYPT                              0
-#   define DH_F_DH_CMS_SET_PEERKEY                          0
-#   define DH_F_DH_CMS_SET_SHARED_INFO                      0
-#   define DH_F_DH_METH_DUP                                 0
-#   define DH_F_DH_METH_NEW                                 0
-#   define DH_F_DH_METH_SET1_NAME                           0
-#   define DH_F_DH_NEW_BY_NID                               0
-#   define DH_F_DH_NEW_METHOD                               0
-#   define DH_F_DH_PARAM_DECODE                             0
-#   define DH_F_DH_PKEY_PUBLIC_CHECK                        0
-#   define DH_F_DH_PRIV_DECODE                              0
-#   define DH_F_DH_PRIV_ENCODE                              0
-#   define DH_F_DH_PUB_DECODE                               0
-#   define DH_F_DH_PUB_ENCODE                               0
-#   define DH_F_DO_DH_PRINT                                 0
-#   define DH_F_GENERATE_KEY                                0
-#   define DH_F_PKEY_DH_CTRL_STR                            0
-#   define DH_F_PKEY_DH_DERIVE                              0
-#   define DH_F_PKEY_DH_INIT                                0
-#   define DH_F_PKEY_DH_KEYGEN                              0
-#  endif
+#define DH_F_COMPUTE_KEY 0
+#define DH_F_DHPARAMS_PRINT_FP 0
+#define DH_F_DH_BUILTIN_GENPARAMS 0
+#define DH_F_DH_CHECK_EX 0
+#define DH_F_DH_CHECK_PARAMS_EX 0
+#define DH_F_DH_CHECK_PUB_KEY_EX 0
+#define DH_F_DH_CMS_DECRYPT 0
+#define DH_F_DH_CMS_SET_PEERKEY 0
+#define DH_F_DH_CMS_SET_SHARED_INFO 0
+#define DH_F_DH_METH_DUP 0
+#define DH_F_DH_METH_NEW 0
+#define DH_F_DH_METH_SET1_NAME 0
+#define DH_F_DH_NEW_BY_NID 0
+#define DH_F_DH_NEW_METHOD 0
+#define DH_F_DH_PARAM_DECODE 0
+#define DH_F_DH_PKEY_PUBLIC_CHECK 0
+#define DH_F_DH_PRIV_DECODE 0
+#define DH_F_DH_PRIV_ENCODE 0
+#define DH_F_DH_PUB_DECODE 0
+#define DH_F_DH_PUB_ENCODE 0
+#define DH_F_DO_DH_PRINT 0
+#define DH_F_GENERATE_KEY 0
+#define DH_F_PKEY_DH_CTRL_STR 0
+#define DH_F_PKEY_DH_DERIVE 0
+#define DH_F_PKEY_DH_INIT 0
+#define DH_F_PKEY_DH_KEYGEN 0
+#endif
 
-#  ifndef OPENSSL_NO_DSA
+#ifndef OPENSSL_NO_DSA
 /*
  * DSA function codes.
  */
-#   define DSA_F_DSAPARAMS_PRINT                            0
-#   define DSA_F_DSAPARAMS_PRINT_FP                         0
-#   define DSA_F_DSA_BUILTIN_PARAMGEN                       0
-#   define DSA_F_DSA_BUILTIN_PARAMGEN2                      0
-#   define DSA_F_DSA_DO_SIGN                                0
-#   define DSA_F_DSA_DO_VERIFY                              0
-#   define DSA_F_DSA_METH_DUP                               0
-#   define DSA_F_DSA_METH_NEW                               0
-#   define DSA_F_DSA_METH_SET1_NAME                         0
-#   define DSA_F_DSA_NEW_METHOD                             0
-#   define DSA_F_DSA_PARAM_DECODE                           0
-#   define DSA_F_DSA_PRINT_FP                               0
-#   define DSA_F_DSA_PRIV_DECODE                            0
-#   define DSA_F_DSA_PRIV_ENCODE                            0
-#   define DSA_F_DSA_PUB_DECODE                             0
-#   define DSA_F_DSA_PUB_ENCODE                             0
-#   define DSA_F_DSA_SIGN                                   0
-#   define DSA_F_DSA_SIGN_SETUP                             0
-#   define DSA_F_DSA_SIG_NEW                                0
-#   define DSA_F_OLD_DSA_PRIV_DECODE                        0
-#   define DSA_F_PKEY_DSA_CTRL                              0
-#   define DSA_F_PKEY_DSA_CTRL_STR                          0
-#   define DSA_F_PKEY_DSA_KEYGEN                            0
-#  endif
+#define DSA_F_DSAPARAMS_PRINT 0
+#define DSA_F_DSAPARAMS_PRINT_FP 0
+#define DSA_F_DSA_BUILTIN_PARAMGEN 0
+#define DSA_F_DSA_BUILTIN_PARAMGEN2 0
+#define DSA_F_DSA_DO_SIGN 0
+#define DSA_F_DSA_DO_VERIFY 0
+#define DSA_F_DSA_METH_DUP 0
+#define DSA_F_DSA_METH_NEW 0
+#define DSA_F_DSA_METH_SET1_NAME 0
+#define DSA_F_DSA_NEW_METHOD 0
+#define DSA_F_DSA_PARAM_DECODE 0
+#define DSA_F_DSA_PRINT_FP 0
+#define DSA_F_DSA_PRIV_DECODE 0
+#define DSA_F_DSA_PRIV_ENCODE 0
+#define DSA_F_DSA_PUB_DECODE 0
+#define DSA_F_DSA_PUB_ENCODE 0
+#define DSA_F_DSA_SIGN 0
+#define DSA_F_DSA_SIGN_SETUP 0
+#define DSA_F_DSA_SIG_NEW 0
+#define DSA_F_OLD_DSA_PRIV_DECODE 0
+#define DSA_F_PKEY_DSA_CTRL 0
+#define DSA_F_PKEY_DSA_CTRL_STR 0
+#define DSA_F_PKEY_DSA_KEYGEN 0
+#endif
 
-#  ifndef OPENSSL_NO_EC
+#ifndef OPENSSL_NO_EC
 /*
  * EC function codes.
  */
-#   define EC_F_BN_TO_FELEM                                 0
-#   define EC_F_D2I_ECPARAMETERS                            0
-#   define EC_F_D2I_ECPKPARAMETERS                          0
-#   define EC_F_D2I_ECPRIVATEKEY                            0
-#   define EC_F_DO_EC_KEY_PRINT                             0
-#   define EC_F_ECDH_CMS_DECRYPT                            0
-#   define EC_F_ECDH_CMS_SET_SHARED_INFO                    0
-#   define EC_F_ECDH_COMPUTE_KEY                            0
-#   define EC_F_ECDH_SIMPLE_COMPUTE_KEY                     0
-#   define EC_F_ECDSA_DO_SIGN_EX                            0
-#   define EC_F_ECDSA_DO_VERIFY                             0
-#   define EC_F_ECDSA_SIGN_EX                               0
-#   define EC_F_ECDSA_SIGN_SETUP                            0
-#   define EC_F_ECDSA_SIG_NEW                               0
-#   define EC_F_ECDSA_VERIFY                                0
-#   define EC_F_ECD_ITEM_VERIFY                             0
-#   define EC_F_ECKEY_PARAM2TYPE                            0
-#   define EC_F_ECKEY_PARAM_DECODE                          0
-#   define EC_F_ECKEY_PRIV_DECODE                           0
-#   define EC_F_ECKEY_PRIV_ENCODE                           0
-#   define EC_F_ECKEY_PUB_DECODE                            0
-#   define EC_F_ECKEY_PUB_ENCODE                            0
-#   define EC_F_ECKEY_TYPE2PARAM                            0
-#   define EC_F_ECPARAMETERS_PRINT                          0
-#   define EC_F_ECPARAMETERS_PRINT_FP                       0
-#   define EC_F_ECPKPARAMETERS_PRINT                        0
-#   define EC_F_ECPKPARAMETERS_PRINT_FP                     0
-#   define EC_F_ECP_NISTZ256_GET_AFFINE                     0
-#   define EC_F_ECP_NISTZ256_INV_MOD_ORD                    0
-#   define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE                0
-#   define EC_F_ECP_NISTZ256_POINTS_MUL                     0
-#   define EC_F_ECP_NISTZ256_PRE_COMP_NEW                   0
-#   define EC_F_ECP_NISTZ256_WINDOWED_MUL                   0
-#   define EC_F_ECX_KEY_OP                                  0
-#   define EC_F_ECX_PRIV_ENCODE                             0
-#   define EC_F_ECX_PUB_ENCODE                              0
-#   define EC_F_EC_ASN1_GROUP2CURVE                         0
-#   define EC_F_EC_ASN1_GROUP2FIELDID                       0
-#   define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY           0
-#   define EC_F_EC_GF2M_SIMPLE_FIELD_INV                    0
-#   define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT     0
-#   define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE              0
-#   define EC_F_EC_GF2M_SIMPLE_LADDER_POST                  0
-#   define EC_F_EC_GF2M_SIMPLE_LADDER_PRE                   0
-#   define EC_F_EC_GF2M_SIMPLE_OCT2POINT                    0
-#   define EC_F_EC_GF2M_SIMPLE_POINT2OCT                    0
-#   define EC_F_EC_GF2M_SIMPLE_POINTS_MUL                   0
-#   define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 0
-#   define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 0
-#   define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES   0
-#   define EC_F_EC_GFP_MONT_FIELD_DECODE                    0
-#   define EC_F_EC_GFP_MONT_FIELD_ENCODE                    0
-#   define EC_F_EC_GFP_MONT_FIELD_INV                       0
-#   define EC_F_EC_GFP_MONT_FIELD_MUL                       0
-#   define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE                0
-#   define EC_F_EC_GFP_MONT_FIELD_SQR                       0
-#   define EC_F_EC_GFP_MONT_GROUP_SET_CURVE                 0
-#   define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE             0
-#   define EC_F_EC_GFP_NISTP224_POINTS_MUL                  0
-#   define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 0
-#   define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE             0
-#   define EC_F_EC_GFP_NISTP256_POINTS_MUL                  0
-#   define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 0
-#   define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE             0
-#   define EC_F_EC_GFP_NISTP521_POINTS_MUL                  0
-#   define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 0
-#   define EC_F_EC_GFP_NIST_FIELD_MUL                       0
-#   define EC_F_EC_GFP_NIST_FIELD_SQR                       0
-#   define EC_F_EC_GFP_NIST_GROUP_SET_CURVE                 0
-#   define EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES             0
-#   define EC_F_EC_GFP_SIMPLE_FIELD_INV                     0
-#   define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT      0
-#   define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE               0
-#   define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE                   0
-#   define EC_F_EC_GFP_SIMPLE_OCT2POINT                     0
-#   define EC_F_EC_GFP_SIMPLE_POINT2OCT                     0
-#   define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE            0
-#   define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES  0
-#   define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES  0
-#   define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES    0
-#   define EC_F_EC_GROUP_CHECK                              0
-#   define EC_F_EC_GROUP_CHECK_DISCRIMINANT                 0
-#   define EC_F_EC_GROUP_COPY                               0
-#   define EC_F_EC_GROUP_GET_CURVE                          0
-#   define EC_F_EC_GROUP_GET_CURVE_GF2M                     0
-#   define EC_F_EC_GROUP_GET_CURVE_GFP                      0
-#   define EC_F_EC_GROUP_GET_DEGREE                         0
-#   define EC_F_EC_GROUP_GET_ECPARAMETERS                   0
-#   define EC_F_EC_GROUP_GET_ECPKPARAMETERS                 0
-#   define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS              0
-#   define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS                0
-#   define EC_F_EC_GROUP_NEW                                0
-#   define EC_F_EC_GROUP_NEW_BY_CURVE_NAME                  0
-#   define EC_F_EC_GROUP_NEW_FROM_DATA                      0
-#   define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS              0
-#   define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS            0
-#   define EC_F_EC_GROUP_SET_CURVE                          0
-#   define EC_F_EC_GROUP_SET_CURVE_GF2M                     0
-#   define EC_F_EC_GROUP_SET_CURVE_GFP                      0
-#   define EC_F_EC_GROUP_SET_GENERATOR                      0
-#   define EC_F_EC_GROUP_SET_SEED                           0
-#   define EC_F_EC_KEY_CHECK_KEY                            0
-#   define EC_F_EC_KEY_COPY                                 0
-#   define EC_F_EC_KEY_GENERATE_KEY                         0
-#   define EC_F_EC_KEY_NEW                                  0
-#   define EC_F_EC_KEY_NEW_METHOD                           0
-#   define EC_F_EC_KEY_OCT2PRIV                             0
-#   define EC_F_EC_KEY_PRINT                                0
-#   define EC_F_EC_KEY_PRINT_FP                             0
-#   define EC_F_EC_KEY_PRIV2BUF                             0
-#   define EC_F_EC_KEY_PRIV2OCT                             0
-#   define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES    0
-#   define EC_F_EC_KEY_SIMPLE_CHECK_KEY                     0
-#   define EC_F_EC_KEY_SIMPLE_OCT2PRIV                      0
-#   define EC_F_EC_KEY_SIMPLE_PRIV2OCT                      0
-#   define EC_F_EC_PKEY_CHECK                               0
-#   define EC_F_EC_PKEY_PARAM_CHECK                         0
-#   define EC_F_EC_POINTS_MAKE_AFFINE                       0
-#   define EC_F_EC_POINTS_MUL                               0
-#   define EC_F_EC_POINT_ADD                                0
-#   define EC_F_EC_POINT_BN2POINT                           0
-#   define EC_F_EC_POINT_CMP                                0
-#   define EC_F_EC_POINT_COPY                               0
-#   define EC_F_EC_POINT_DBL                                0
-#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES             0
-#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M        0
-#   define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP         0
-#   define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP    0
-#   define EC_F_EC_POINT_INVERT                             0
-#   define EC_F_EC_POINT_IS_AT_INFINITY                     0
-#   define EC_F_EC_POINT_IS_ON_CURVE                        0
-#   define EC_F_EC_POINT_MAKE_AFFINE                        0
-#   define EC_F_EC_POINT_NEW                                0
-#   define EC_F_EC_POINT_OCT2POINT                          0
-#   define EC_F_EC_POINT_POINT2BUF                          0
-#   define EC_F_EC_POINT_POINT2OCT                          0
-#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES             0
-#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M        0
-#   define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP         0
-#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES         0
-#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M    0
-#   define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP     0
-#   define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP    0
-#   define EC_F_EC_POINT_SET_TO_INFINITY                    0
-#   define EC_F_EC_PRE_COMP_NEW                             0
-#   define EC_F_EC_SCALAR_MUL_LADDER                        0
-#   define EC_F_EC_WNAF_MUL                                 0
-#   define EC_F_EC_WNAF_PRECOMPUTE_MULT                     0
-#   define EC_F_I2D_ECPARAMETERS                            0
-#   define EC_F_I2D_ECPKPARAMETERS                          0
-#   define EC_F_I2D_ECPRIVATEKEY                            0
-#   define EC_F_I2O_ECPUBLICKEY                             0
-#   define EC_F_NISTP224_PRE_COMP_NEW                       0
-#   define EC_F_NISTP256_PRE_COMP_NEW                       0
-#   define EC_F_NISTP521_PRE_COMP_NEW                       0
-#   define EC_F_O2I_ECPUBLICKEY                             0
-#   define EC_F_OLD_EC_PRIV_DECODE                          0
-#   define EC_F_OSSL_ECDH_COMPUTE_KEY                       0
-#   define EC_F_OSSL_ECDSA_SIGN_SIG                         0
-#   define EC_F_OSSL_ECDSA_VERIFY_SIG                       0
-#   define EC_F_PKEY_ECD_CTRL                               0
-#   define EC_F_PKEY_ECD_DIGESTSIGN                         0
-#   define EC_F_PKEY_ECD_DIGESTSIGN25519                    0
-#   define EC_F_PKEY_ECD_DIGESTSIGN448                      0
-#   define EC_F_PKEY_ECX_DERIVE                             0
-#   define EC_F_PKEY_EC_CTRL                                0
-#   define EC_F_PKEY_EC_CTRL_STR                            0
-#   define EC_F_PKEY_EC_DERIVE                              0
-#   define EC_F_PKEY_EC_INIT                                0
-#   define EC_F_PKEY_EC_KDF_DERIVE                          0
-#   define EC_F_PKEY_EC_KEYGEN                              0
-#   define EC_F_PKEY_EC_PARAMGEN                            0
-#   define EC_F_PKEY_EC_SIGN                                0
-#   define EC_F_VALIDATE_ECX_DERIVE                         0
-#  endif
+#define EC_F_BN_TO_FELEM 0
+#define EC_F_D2I_ECPARAMETERS 0
+#define EC_F_D2I_ECPKPARAMETERS 0
+#define EC_F_D2I_ECPRIVATEKEY 0
+#define EC_F_DO_EC_KEY_PRINT 0
+#define EC_F_ECDH_CMS_DECRYPT 0
+#define EC_F_ECDH_CMS_SET_SHARED_INFO 0
+#define EC_F_ECDH_COMPUTE_KEY 0
+#define EC_F_ECDH_SIMPLE_COMPUTE_KEY 0
+#define EC_F_ECDSA_DO_SIGN_EX 0
+#define EC_F_ECDSA_DO_VERIFY 0
+#define EC_F_ECDSA_SIGN_EX 0
+#define EC_F_ECDSA_SIGN_SETUP 0
+#define EC_F_ECDSA_SIG_NEW 0
+#define EC_F_ECDSA_VERIFY 0
+#define EC_F_ECD_ITEM_VERIFY 0
+#define EC_F_ECKEY_PARAM2TYPE 0
+#define EC_F_ECKEY_PARAM_DECODE 0
+#define EC_F_ECKEY_PRIV_DECODE 0
+#define EC_F_ECKEY_PRIV_ENCODE 0
+#define EC_F_ECKEY_PUB_DECODE 0
+#define EC_F_ECKEY_PUB_ENCODE 0
+#define EC_F_ECKEY_TYPE2PARAM 0
+#define EC_F_ECPARAMETERS_PRINT 0
+#define EC_F_ECPARAMETERS_PRINT_FP 0
+#define EC_F_ECPKPARAMETERS_PRINT 0
+#define EC_F_ECPKPARAMETERS_PRINT_FP 0
+#define EC_F_ECP_NISTZ256_GET_AFFINE 0
+#define EC_F_ECP_NISTZ256_INV_MOD_ORD 0
+#define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE 0
+#define EC_F_ECP_NISTZ256_POINTS_MUL 0
+#define EC_F_ECP_NISTZ256_PRE_COMP_NEW 0
+#define EC_F_ECP_NISTZ256_WINDOWED_MUL 0
+#define EC_F_ECX_KEY_OP 0
+#define EC_F_ECX_PRIV_ENCODE 0
+#define EC_F_ECX_PUB_ENCODE 0
+#define EC_F_EC_ASN1_GROUP2CURVE 0
+#define EC_F_EC_ASN1_GROUP2FIELDID 0
+#define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY 0
+#define EC_F_EC_GF2M_SIMPLE_FIELD_INV 0
+#define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT 0
+#define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE 0
+#define EC_F_EC_GF2M_SIMPLE_LADDER_POST 0
+#define EC_F_EC_GF2M_SIMPLE_LADDER_PRE 0
+#define EC_F_EC_GF2M_SIMPLE_OCT2POINT 0
+#define EC_F_EC_GF2M_SIMPLE_POINT2OCT 0
+#define EC_F_EC_GF2M_SIMPLE_POINTS_MUL 0
+#define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 0
+#define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 0
+#define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES 0
+#define EC_F_EC_GFP_MONT_FIELD_DECODE 0
+#define EC_F_EC_GFP_MONT_FIELD_ENCODE 0
+#define EC_F_EC_GFP_MONT_FIELD_INV 0
+#define EC_F_EC_GFP_MONT_FIELD_MUL 0
+#define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE 0
+#define EC_F_EC_GFP_MONT_FIELD_SQR 0
+#define EC_F_EC_GFP_MONT_GROUP_SET_CURVE 0
+#define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE 0
+#define EC_F_EC_GFP_NISTP224_POINTS_MUL 0
+#define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 0
+#define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE 0
+#define EC_F_EC_GFP_NISTP256_POINTS_MUL 0
+#define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 0
+#define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE 0
+#define EC_F_EC_GFP_NISTP521_POINTS_MUL 0
+#define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 0
+#define EC_F_EC_GFP_NIST_FIELD_MUL 0
+#define EC_F_EC_GFP_NIST_FIELD_SQR 0
+#define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 0
+#define EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES 0
+#define EC_F_EC_GFP_SIMPLE_FIELD_INV 0
+#define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 0
+#define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 0
+#define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 0
+#define EC_F_EC_GFP_SIMPLE_OCT2POINT 0
+#define EC_F_EC_GFP_SIMPLE_POINT2OCT 0
+#define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 0
+#define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 0
+#define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 0
+#define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 0
+#define EC_F_EC_GROUP_CHECK 0
+#define EC_F_EC_GROUP_CHECK_DISCRIMINANT 0
+#define EC_F_EC_GROUP_COPY 0
+#define EC_F_EC_GROUP_GET_CURVE 0
+#define EC_F_EC_GROUP_GET_CURVE_GF2M 0
+#define EC_F_EC_GROUP_GET_CURVE_GFP 0
+#define EC_F_EC_GROUP_GET_DEGREE 0
+#define EC_F_EC_GROUP_GET_ECPARAMETERS 0
+#define EC_F_EC_GROUP_GET_ECPKPARAMETERS 0
+#define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS 0
+#define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS 0
+#define EC_F_EC_GROUP_NEW 0
+#define EC_F_EC_GROUP_NEW_BY_CURVE_NAME 0
+#define EC_F_EC_GROUP_NEW_FROM_DATA 0
+#define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS 0
+#define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS 0
+#define EC_F_EC_GROUP_SET_CURVE 0
+#define EC_F_EC_GROUP_SET_CURVE_GF2M 0
+#define EC_F_EC_GROUP_SET_CURVE_GFP 0
+#define EC_F_EC_GROUP_SET_GENERATOR 0
+#define EC_F_EC_GROUP_SET_SEED 0
+#define EC_F_EC_KEY_CHECK_KEY 0
+#define EC_F_EC_KEY_COPY 0
+#define EC_F_EC_KEY_GENERATE_KEY 0
+#define EC_F_EC_KEY_NEW 0
+#define EC_F_EC_KEY_NEW_METHOD 0
+#define EC_F_EC_KEY_OCT2PRIV 0
+#define EC_F_EC_KEY_PRINT 0
+#define EC_F_EC_KEY_PRINT_FP 0
+#define EC_F_EC_KEY_PRIV2BUF 0
+#define EC_F_EC_KEY_PRIV2OCT 0
+#define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES 0
+#define EC_F_EC_KEY_SIMPLE_CHECK_KEY 0
+#define EC_F_EC_KEY_SIMPLE_OCT2PRIV 0
+#define EC_F_EC_KEY_SIMPLE_PRIV2OCT 0
+#define EC_F_EC_PKEY_CHECK 0
+#define EC_F_EC_PKEY_PARAM_CHECK 0
+#define EC_F_EC_POINTS_MAKE_AFFINE 0
+#define EC_F_EC_POINTS_MUL 0
+#define EC_F_EC_POINT_ADD 0
+#define EC_F_EC_POINT_BN2POINT 0
+#define EC_F_EC_POINT_CMP 0
+#define EC_F_EC_POINT_COPY 0
+#define EC_F_EC_POINT_DBL 0
+#define EC_F_EC_POINT_GET_AFFINE_COORDINATES 0
+#define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M 0
+#define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP 0
+#define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP 0
+#define EC_F_EC_POINT_INVERT 0
+#define EC_F_EC_POINT_IS_AT_INFINITY 0
+#define EC_F_EC_POINT_IS_ON_CURVE 0
+#define EC_F_EC_POINT_MAKE_AFFINE 0
+#define EC_F_EC_POINT_NEW 0
+#define EC_F_EC_POINT_OCT2POINT 0
+#define EC_F_EC_POINT_POINT2BUF 0
+#define EC_F_EC_POINT_POINT2OCT 0
+#define EC_F_EC_POINT_SET_AFFINE_COORDINATES 0
+#define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M 0
+#define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP 0
+#define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES 0
+#define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M 0
+#define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP 0
+#define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP 0
+#define EC_F_EC_POINT_SET_TO_INFINITY 0
+#define EC_F_EC_PRE_COMP_NEW 0
+#define EC_F_EC_SCALAR_MUL_LADDER 0
+#define EC_F_EC_WNAF_MUL 0
+#define EC_F_EC_WNAF_PRECOMPUTE_MULT 0
+#define EC_F_I2D_ECPARAMETERS 0
+#define EC_F_I2D_ECPKPARAMETERS 0
+#define EC_F_I2D_ECPRIVATEKEY 0
+#define EC_F_I2O_ECPUBLICKEY 0
+#define EC_F_NISTP224_PRE_COMP_NEW 0
+#define EC_F_NISTP256_PRE_COMP_NEW 0
+#define EC_F_NISTP521_PRE_COMP_NEW 0
+#define EC_F_O2I_ECPUBLICKEY 0
+#define EC_F_OLD_EC_PRIV_DECODE 0
+#define EC_F_OSSL_ECDH_COMPUTE_KEY 0
+#define EC_F_OSSL_ECDSA_SIGN_SIG 0
+#define EC_F_OSSL_ECDSA_VERIFY_SIG 0
+#define EC_F_PKEY_ECD_CTRL 0
+#define EC_F_PKEY_ECD_DIGESTSIGN 0
+#define EC_F_PKEY_ECD_DIGESTSIGN25519 0
+#define EC_F_PKEY_ECD_DIGESTSIGN448 0
+#define EC_F_PKEY_ECX_DERIVE 0
+#define EC_F_PKEY_EC_CTRL 0
+#define EC_F_PKEY_EC_CTRL_STR 0
+#define EC_F_PKEY_EC_DERIVE 0
+#define EC_F_PKEY_EC_INIT 0
+#define EC_F_PKEY_EC_KDF_DERIVE 0
+#define EC_F_PKEY_EC_KEYGEN 0
+#define EC_F_PKEY_EC_PARAMGEN 0
+#define EC_F_PKEY_EC_SIGN 0
+#define EC_F_VALIDATE_ECX_DERIVE 0
+#endif
 
-#  ifndef OPENSSL_NO_ENGINE
+#ifndef OPENSSL_NO_ENGINE
 /*
  * ENGINE function codes.
  */
-#   define ENGINE_F_DIGEST_UPDATE                           0
-#   define ENGINE_F_DYNAMIC_CTRL                            0
-#   define ENGINE_F_DYNAMIC_GET_DATA_CTX                    0
-#   define ENGINE_F_DYNAMIC_LOAD                            0
-#   define ENGINE_F_DYNAMIC_SET_DATA_CTX                    0
-#   define ENGINE_F_ENGINE_ADD                              0
-#   define ENGINE_F_ENGINE_BY_ID                            0
-#   define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE                0
-#   define ENGINE_F_ENGINE_CTRL                             0
-#   define ENGINE_F_ENGINE_CTRL_CMD                         0
-#   define ENGINE_F_ENGINE_CTRL_CMD_STRING                  0
-#   define ENGINE_F_ENGINE_FINISH                           0
-#   define ENGINE_F_ENGINE_GET_CIPHER                       0
-#   define ENGINE_F_ENGINE_GET_DIGEST                       0
-#   define ENGINE_F_ENGINE_GET_FIRST                        0
-#   define ENGINE_F_ENGINE_GET_LAST                         0
-#   define ENGINE_F_ENGINE_GET_NEXT                         0
-#   define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH               0
-#   define ENGINE_F_ENGINE_GET_PKEY_METH                    0
-#   define ENGINE_F_ENGINE_GET_PREV                         0
-#   define ENGINE_F_ENGINE_INIT                             0
-#   define ENGINE_F_ENGINE_LIST_ADD                         0
-#   define ENGINE_F_ENGINE_LIST_REMOVE                      0
-#   define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY                 0
-#   define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY                  0
-#   define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT             0
-#   define ENGINE_F_ENGINE_NEW                              0
-#   define ENGINE_F_ENGINE_PKEY_ASN1_FIND_STR               0
-#   define ENGINE_F_ENGINE_REMOVE                           0
-#   define ENGINE_F_ENGINE_SET_DEFAULT_STRING               0
-#   define ENGINE_F_ENGINE_SET_ID                           0
-#   define ENGINE_F_ENGINE_SET_NAME                         0
-#   define ENGINE_F_ENGINE_TABLE_REGISTER                   0
-#   define ENGINE_F_ENGINE_UNLOCKED_FINISH                  0
-#   define ENGINE_F_ENGINE_UP_REF                           0
-#   define ENGINE_F_INT_CLEANUP_ITEM                        0
-#   define ENGINE_F_INT_CTRL_HELPER                         0
-#   define ENGINE_F_INT_ENGINE_CONFIGURE                    0
-#   define ENGINE_F_INT_ENGINE_MODULE_INIT                  0
-#   define ENGINE_F_OSSL_HMAC_INIT                          0
-#  endif
+#define ENGINE_F_DIGEST_UPDATE 0
+#define ENGINE_F_DYNAMIC_CTRL 0
+#define ENGINE_F_DYNAMIC_GET_DATA_CTX 0
+#define ENGINE_F_DYNAMIC_LOAD 0
+#define ENGINE_F_DYNAMIC_SET_DATA_CTX 0
+#define ENGINE_F_ENGINE_ADD 0
+#define ENGINE_F_ENGINE_BY_ID 0
+#define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE 0
+#define ENGINE_F_ENGINE_CTRL 0
+#define ENGINE_F_ENGINE_CTRL_CMD 0
+#define ENGINE_F_ENGINE_CTRL_CMD_STRING 0
+#define ENGINE_F_ENGINE_FINISH 0
+#define ENGINE_F_ENGINE_GET_CIPHER 0
+#define ENGINE_F_ENGINE_GET_DIGEST 0
+#define ENGINE_F_ENGINE_GET_FIRST 0
+#define ENGINE_F_ENGINE_GET_LAST 0
+#define ENGINE_F_ENGINE_GET_NEXT 0
+#define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH 0
+#define ENGINE_F_ENGINE_GET_PKEY_METH 0
+#define ENGINE_F_ENGINE_GET_PREV 0
+#define ENGINE_F_ENGINE_INIT 0
+#define ENGINE_F_ENGINE_LIST_ADD 0
+#define ENGINE_F_ENGINE_LIST_REMOVE 0
+#define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY 0
+#define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY 0
+#define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT 0
+#define ENGINE_F_ENGINE_NEW 0
+#define ENGINE_F_ENGINE_PKEY_ASN1_FIND_STR 0
+#define ENGINE_F_ENGINE_REMOVE 0
+#define ENGINE_F_ENGINE_SET_DEFAULT_STRING 0
+#define ENGINE_F_ENGINE_SET_ID 0
+#define ENGINE_F_ENGINE_SET_NAME 0
+#define ENGINE_F_ENGINE_TABLE_REGISTER 0
+#define ENGINE_F_ENGINE_UNLOCKED_FINISH 0
+#define ENGINE_F_ENGINE_UP_REF 0
+#define ENGINE_F_INT_CLEANUP_ITEM 0
+#define ENGINE_F_INT_CTRL_HELPER 0
+#define ENGINE_F_INT_ENGINE_CONFIGURE 0
+#define ENGINE_F_INT_ENGINE_MODULE_INIT 0
+#define ENGINE_F_OSSL_HMAC_INIT 0
+#endif
 
 /*
  * EVP function codes.
  */
-#  define EVP_F_AESNI_INIT_KEY                             0
-#  define EVP_F_AESNI_XTS_INIT_KEY                         0
-#  define EVP_F_AES_GCM_CTRL                               0
-#  define EVP_F_AES_INIT_KEY                               0
-#  define EVP_F_AES_OCB_CIPHER                             0
-#  define EVP_F_AES_T4_INIT_KEY                            0
-#  define EVP_F_AES_T4_XTS_INIT_KEY                        0
-#  define EVP_F_AES_WRAP_CIPHER                            0
-#  define EVP_F_AES_XTS_INIT_KEY                           0
-#  define EVP_F_ALG_MODULE_INIT                            0
-#  define EVP_F_ARIA_CCM_INIT_KEY                          0
-#  define EVP_F_ARIA_GCM_CTRL                              0
-#  define EVP_F_ARIA_GCM_INIT_KEY                          0
-#  define EVP_F_ARIA_INIT_KEY                              0
-#  define EVP_F_B64_NEW                                    0
-#  define EVP_F_CAMELLIA_INIT_KEY                          0
-#  define EVP_F_CHACHA20_POLY1305_CTRL                     0
-#  define EVP_F_CMLL_T4_INIT_KEY                           0
-#  define EVP_F_DES_EDE3_WRAP_CIPHER                       0
-#  define EVP_F_DO_SIGVER_INIT                             0
-#  define EVP_F_ENC_NEW                                    0
-#  define EVP_F_EVP_CIPHERINIT_EX                          0
-#  define EVP_F_EVP_CIPHER_ASN1_TO_PARAM                   0
-#  define EVP_F_EVP_CIPHER_CTX_COPY                        0
-#  define EVP_F_EVP_CIPHER_CTX_CTRL                        0
-#  define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH              0
-#  define EVP_F_EVP_CIPHER_PARAM_TO_ASN1                   0
-#  define EVP_F_EVP_DECRYPTFINAL_EX                        0
-#  define EVP_F_EVP_DECRYPTUPDATE                          0
-#  define EVP_F_EVP_DIGESTFINALXOF                         0
-#  define EVP_F_EVP_DIGESTINIT_EX                          0
-#  define EVP_F_EVP_ENCRYPTDECRYPTUPDATE                   0
-#  define EVP_F_EVP_ENCRYPTFINAL_EX                        0
-#  define EVP_F_EVP_ENCRYPTUPDATE                          0
-#  define EVP_F_EVP_MD_CTX_COPY_EX                         0
-#  define EVP_F_EVP_MD_SIZE                                0
-#  define EVP_F_EVP_OPENINIT                               0
-#  define EVP_F_EVP_PBE_ALG_ADD                            0
-#  define EVP_F_EVP_PBE_ALG_ADD_TYPE                       0
-#  define EVP_F_EVP_PBE_CIPHERINIT                         0
-#  define EVP_F_EVP_PBE_SCRYPT                             0
-#  define EVP_F_EVP_PKCS82PKEY                             0
-#  define EVP_F_EVP_PKEY2PKCS8                             0
-#  define EVP_F_EVP_PKEY_ASN1_ADD0                         0
-#  define EVP_F_EVP_PKEY_CHECK                             0
-#  define EVP_F_EVP_PKEY_COPY_PARAMETERS                   0
-#  define EVP_F_EVP_PKEY_CTX_CTRL                          0
-#  define EVP_F_EVP_PKEY_CTX_CTRL_STR                      0
-#  define EVP_F_EVP_PKEY_CTX_DUP                           0
-#  define EVP_F_EVP_PKEY_CTX_MD                            0
-#  define EVP_F_EVP_PKEY_DECRYPT                           0
-#  define EVP_F_EVP_PKEY_DECRYPT_INIT                      0
-#  define EVP_F_EVP_PKEY_DECRYPT_OLD                       0
-#  define EVP_F_EVP_PKEY_DERIVE                            0
-#  define EVP_F_EVP_PKEY_DERIVE_INIT                       0
-#  define EVP_F_EVP_PKEY_DERIVE_SET_PEER                   0
-#  define EVP_F_EVP_PKEY_ENCRYPT                           0
-#  define EVP_F_EVP_PKEY_ENCRYPT_INIT                      0
-#  define EVP_F_EVP_PKEY_ENCRYPT_OLD                       0
-#  define EVP_F_EVP_PKEY_GET0_DH                           0
-#  define EVP_F_EVP_PKEY_GET0_DSA                          0
-#  define EVP_F_EVP_PKEY_GET0_EC_KEY                       0
-#  define EVP_F_EVP_PKEY_GET0_HMAC                         0
-#  define EVP_F_EVP_PKEY_GET0_POLY1305                     0
-#  define EVP_F_EVP_PKEY_GET0_RSA                          0
-#  define EVP_F_EVP_PKEY_GET0_SIPHASH                      0
-#  define EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY               0
-#  define EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY                0
-#  define EVP_F_EVP_PKEY_KEYGEN                            0
-#  define EVP_F_EVP_PKEY_KEYGEN_INIT                       0
-#  define EVP_F_EVP_PKEY_METH_ADD0                         0
-#  define EVP_F_EVP_PKEY_METH_NEW                          0
-#  define EVP_F_EVP_PKEY_NEW                               0
-#  define EVP_F_EVP_PKEY_NEW_CMAC_KEY                      0
-#  define EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY               0
-#  define EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY                0
-#  define EVP_F_EVP_PKEY_PARAMGEN                          0
-#  define EVP_F_EVP_PKEY_PARAMGEN_INIT                     0
-#  define EVP_F_EVP_PKEY_PARAM_CHECK                       0
-#  define EVP_F_EVP_PKEY_PUBLIC_CHECK                      0
-#  define EVP_F_EVP_PKEY_SET1_ENGINE                       0
-#  define EVP_F_EVP_PKEY_SET_ALIAS_TYPE                    0
-#  define EVP_F_EVP_PKEY_SIGN                              0
-#  define EVP_F_EVP_PKEY_SIGN_INIT                         0
-#  define EVP_F_EVP_PKEY_VERIFY                            0
-#  define EVP_F_EVP_PKEY_VERIFY_INIT                       0
-#  define EVP_F_EVP_PKEY_VERIFY_RECOVER                    0
-#  define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT               0
-#  define EVP_F_EVP_SIGNFINAL                              0
-#  define EVP_F_EVP_VERIFYFINAL                            0
-#  define EVP_F_INT_CTX_NEW                                0
-#  define EVP_F_OK_NEW                                     0
-#  define EVP_F_PKCS5_PBE_KEYIVGEN                         0
-#  define EVP_F_PKCS5_V2_PBE_KEYIVGEN                      0
-#  define EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN                   0
-#  define EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN                   0
-#  define EVP_F_PKEY_SET_TYPE                              0
-#  define EVP_F_RC2_MAGIC_TO_METH                          0
-#  define EVP_F_RC5_CTRL                                   0
-#  define EVP_F_R_32_12_16_INIT_KEY                        0
-#  define EVP_F_S390X_AES_GCM_CTRL                         0
-#  define EVP_F_UPDATE                                     0
+#define EVP_F_AESNI_INIT_KEY 0
+#define EVP_F_AESNI_XTS_INIT_KEY 0
+#define EVP_F_AES_GCM_CTRL 0
+#define EVP_F_AES_INIT_KEY 0
+#define EVP_F_AES_OCB_CIPHER 0
+#define EVP_F_AES_T4_INIT_KEY 0
+#define EVP_F_AES_T4_XTS_INIT_KEY 0
+#define EVP_F_AES_WRAP_CIPHER 0
+#define EVP_F_AES_XTS_INIT_KEY 0
+#define EVP_F_ALG_MODULE_INIT 0
+#define EVP_F_ARIA_CCM_INIT_KEY 0
+#define EVP_F_ARIA_GCM_CTRL 0
+#define EVP_F_ARIA_GCM_INIT_KEY 0
+#define EVP_F_ARIA_INIT_KEY 0
+#define EVP_F_B64_NEW 0
+#define EVP_F_CAMELLIA_INIT_KEY 0
+#define EVP_F_CHACHA20_POLY1305_CTRL 0
+#define EVP_F_CMLL_T4_INIT_KEY 0
+#define EVP_F_DES_EDE3_WRAP_CIPHER 0
+#define EVP_F_DO_SIGVER_INIT 0
+#define EVP_F_ENC_NEW 0
+#define EVP_F_EVP_CIPHERINIT_EX 0
+#define EVP_F_EVP_CIPHER_ASN1_TO_PARAM 0
+#define EVP_F_EVP_CIPHER_CTX_COPY 0
+#define EVP_F_EVP_CIPHER_CTX_CTRL 0
+#define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 0
+#define EVP_F_EVP_CIPHER_PARAM_TO_ASN1 0
+#define EVP_F_EVP_DECRYPTFINAL_EX 0
+#define EVP_F_EVP_DECRYPTUPDATE 0
+#define EVP_F_EVP_DIGESTFINALXOF 0
+#define EVP_F_EVP_DIGESTINIT_EX 0
+#define EVP_F_EVP_ENCRYPTDECRYPTUPDATE 0
+#define EVP_F_EVP_ENCRYPTFINAL_EX 0
+#define EVP_F_EVP_ENCRYPTUPDATE 0
+#define EVP_F_EVP_MD_CTX_COPY_EX 0
+#define EVP_F_EVP_MD_SIZE 0
+#define EVP_F_EVP_OPENINIT 0
+#define EVP_F_EVP_PBE_ALG_ADD 0
+#define EVP_F_EVP_PBE_ALG_ADD_TYPE 0
+#define EVP_F_EVP_PBE_CIPHERINIT 0
+#define EVP_F_EVP_PBE_SCRYPT 0
+#define EVP_F_EVP_PKCS82PKEY 0
+#define EVP_F_EVP_PKEY2PKCS8 0
+#define EVP_F_EVP_PKEY_ASN1_ADD0 0
+#define EVP_F_EVP_PKEY_CHECK 0
+#define EVP_F_EVP_PKEY_COPY_PARAMETERS 0
+#define EVP_F_EVP_PKEY_CTX_CTRL 0
+#define EVP_F_EVP_PKEY_CTX_CTRL_STR 0
+#define EVP_F_EVP_PKEY_CTX_DUP 0
+#define EVP_F_EVP_PKEY_CTX_MD 0
+#define EVP_F_EVP_PKEY_DECRYPT 0
+#define EVP_F_EVP_PKEY_DECRYPT_INIT 0
+#define EVP_F_EVP_PKEY_DECRYPT_OLD 0
+#define EVP_F_EVP_PKEY_DERIVE 0
+#define EVP_F_EVP_PKEY_DERIVE_INIT 0
+#define EVP_F_EVP_PKEY_DERIVE_SET_PEER 0
+#define EVP_F_EVP_PKEY_ENCRYPT 0
+#define EVP_F_EVP_PKEY_ENCRYPT_INIT 0
+#define EVP_F_EVP_PKEY_ENCRYPT_OLD 0
+#define EVP_F_EVP_PKEY_GET0_DH 0
+#define EVP_F_EVP_PKEY_GET0_DSA 0
+#define EVP_F_EVP_PKEY_GET0_EC_KEY 0
+#define EVP_F_EVP_PKEY_GET0_HMAC 0
+#define EVP_F_EVP_PKEY_GET0_POLY1305 0
+#define EVP_F_EVP_PKEY_GET0_RSA 0
+#define EVP_F_EVP_PKEY_GET0_SIPHASH 0
+#define EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY 0
+#define EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY 0
+#define EVP_F_EVP_PKEY_KEYGEN 0
+#define EVP_F_EVP_PKEY_KEYGEN_INIT 0
+#define EVP_F_EVP_PKEY_METH_ADD0 0
+#define EVP_F_EVP_PKEY_METH_NEW 0
+#define EVP_F_EVP_PKEY_NEW 0
+#define EVP_F_EVP_PKEY_NEW_CMAC_KEY 0
+#define EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY 0
+#define EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY 0
+#define EVP_F_EVP_PKEY_PARAMGEN 0
+#define EVP_F_EVP_PKEY_PARAMGEN_INIT 0
+#define EVP_F_EVP_PKEY_PARAM_CHECK 0
+#define EVP_F_EVP_PKEY_PUBLIC_CHECK 0
+#define EVP_F_EVP_PKEY_SET1_ENGINE 0
+#define EVP_F_EVP_PKEY_SET_ALIAS_TYPE 0
+#define EVP_F_EVP_PKEY_SIGN 0
+#define EVP_F_EVP_PKEY_SIGN_INIT 0
+#define EVP_F_EVP_PKEY_VERIFY 0
+#define EVP_F_EVP_PKEY_VERIFY_INIT 0
+#define EVP_F_EVP_PKEY_VERIFY_RECOVER 0
+#define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT 0
+#define EVP_F_EVP_SIGNFINAL 0
+#define EVP_F_EVP_VERIFYFINAL 0
+#define EVP_F_INT_CTX_NEW 0
+#define EVP_F_OK_NEW 0
+#define EVP_F_PKCS5_PBE_KEYIVGEN 0
+#define EVP_F_PKCS5_V2_PBE_KEYIVGEN 0
+#define EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN 0
+#define EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN 0
+#define EVP_F_PKEY_SET_TYPE 0
+#define EVP_F_RC2_MAGIC_TO_METH 0
+#define EVP_F_RC5_CTRL 0
+#define EVP_F_R_32_12_16_INIT_KEY 0
+#define EVP_F_S390X_AES_GCM_CTRL 0
+#define EVP_F_UPDATE 0
 
 /*
  * KDF function codes.
  */
-#  define KDF_F_PKEY_HKDF_CTRL_STR                         0
-#  define KDF_F_PKEY_HKDF_DERIVE                           0
-#  define KDF_F_PKEY_HKDF_INIT                             0
-#  define KDF_F_PKEY_SCRYPT_CTRL_STR                       0
-#  define KDF_F_PKEY_SCRYPT_CTRL_UINT64                    0
-#  define KDF_F_PKEY_SCRYPT_DERIVE                         0
-#  define KDF_F_PKEY_SCRYPT_INIT                           0
-#  define KDF_F_PKEY_SCRYPT_SET_MEMBUF                     0
-#  define KDF_F_PKEY_TLS1_PRF_CTRL_STR                     0
-#  define KDF_F_PKEY_TLS1_PRF_DERIVE                       0
-#  define KDF_F_PKEY_TLS1_PRF_INIT                         0
-#  define KDF_F_TLS1_PRF_ALG                               0
+#define KDF_F_PKEY_HKDF_CTRL_STR 0
+#define KDF_F_PKEY_HKDF_DERIVE 0
+#define KDF_F_PKEY_HKDF_INIT 0
+#define KDF_F_PKEY_SCRYPT_CTRL_STR 0
+#define KDF_F_PKEY_SCRYPT_CTRL_UINT64 0
+#define KDF_F_PKEY_SCRYPT_DERIVE 0
+#define KDF_F_PKEY_SCRYPT_INIT 0
+#define KDF_F_PKEY_SCRYPT_SET_MEMBUF 0
+#define KDF_F_PKEY_TLS1_PRF_CTRL_STR 0
+#define KDF_F_PKEY_TLS1_PRF_DERIVE 0
+#define KDF_F_PKEY_TLS1_PRF_INIT 0
+#define KDF_F_TLS1_PRF_ALG 0
 
 /*
  * KDF reason codes.
  */
-#  define KDF_R_INVALID_DIGEST                             0
-#  define KDF_R_MISSING_ITERATION_COUNT                    0
-#  define KDF_R_MISSING_KEY                                0
-#  define KDF_R_MISSING_MESSAGE_DIGEST                     0
-#  define KDF_R_MISSING_PARAMETER                          0
-#  define KDF_R_MISSING_PASS                               0
-#  define KDF_R_MISSING_SALT                               0
-#  define KDF_R_MISSING_SECRET                             0
-#  define KDF_R_MISSING_SEED                               0
-#  define KDF_R_UNKNOWN_PARAMETER_TYPE                     0
-#  define KDF_R_VALUE_ERROR                                0
-#  define KDF_R_VALUE_MISSING                              0
+#define KDF_R_INVALID_DIGEST 0
+#define KDF_R_MISSING_ITERATION_COUNT 0
+#define KDF_R_MISSING_KEY 0
+#define KDF_R_MISSING_MESSAGE_DIGEST 0
+#define KDF_R_MISSING_PARAMETER 0
+#define KDF_R_MISSING_PASS 0
+#define KDF_R_MISSING_SALT 0
+#define KDF_R_MISSING_SECRET 0
+#define KDF_R_MISSING_SEED 0
+#define KDF_R_UNKNOWN_PARAMETER_TYPE 0
+#define KDF_R_VALUE_ERROR 0
+#define KDF_R_VALUE_MISSING 0
 
 /*
  * OBJ function codes.
  */
-#  define OBJ_F_OBJ_ADD_OBJECT                             0
-#  define OBJ_F_OBJ_ADD_SIGID                              0
-#  define OBJ_F_OBJ_CREATE                                 0
-#  define OBJ_F_OBJ_DUP                                    0
-#  define OBJ_F_OBJ_NAME_NEW_INDEX                         0
-#  define OBJ_F_OBJ_NID2LN                                 0
-#  define OBJ_F_OBJ_NID2OBJ                                0
-#  define OBJ_F_OBJ_NID2SN                                 0
-#  define OBJ_F_OBJ_TXT2OBJ                                0
+#define OBJ_F_OBJ_ADD_OBJECT 0
+#define OBJ_F_OBJ_ADD_SIGID 0
+#define OBJ_F_OBJ_CREATE 0
+#define OBJ_F_OBJ_DUP 0
+#define OBJ_F_OBJ_NAME_NEW_INDEX 0
+#define OBJ_F_OBJ_NID2LN 0
+#define OBJ_F_OBJ_NID2OBJ 0
+#define OBJ_F_OBJ_NID2SN 0
+#define OBJ_F_OBJ_TXT2OBJ 0
 
-#  ifndef OPENSSL_NO_OCSP
+#ifndef OPENSSL_NO_OCSP
 /*
  * OCSP function codes.
  */
-#   define OCSP_F_D2I_OCSP_NONCE                            0
-#   define OCSP_F_OCSP_BASIC_ADD1_STATUS                    0
-#   define OCSP_F_OCSP_BASIC_SIGN                           0
-#   define OCSP_F_OCSP_BASIC_SIGN_CTX                       0
-#   define OCSP_F_OCSP_BASIC_VERIFY                         0
-#   define OCSP_F_OCSP_CERT_ID_NEW                          0
-#   define OCSP_F_OCSP_CHECK_DELEGATED                      0
-#   define OCSP_F_OCSP_CHECK_IDS                            0
-#   define OCSP_F_OCSP_CHECK_ISSUER                         0
-#   define OCSP_F_OCSP_CHECK_VALIDITY                       0
-#   define OCSP_F_OCSP_MATCH_ISSUERID                       0
-#   define OCSP_F_OCSP_PARSE_URL                            0
-#   define OCSP_F_OCSP_REQUEST_SIGN                         0
-#   define OCSP_F_OCSP_REQUEST_VERIFY                       0
-#   define OCSP_F_OCSP_RESPONSE_GET1_BASIC                  0
-#   define OCSP_F_PARSE_HTTP_LINE1                          0
-#  endif
+#define OCSP_F_D2I_OCSP_NONCE 0
+#define OCSP_F_OCSP_BASIC_ADD1_STATUS 0
+#define OCSP_F_OCSP_BASIC_SIGN 0
+#define OCSP_F_OCSP_BASIC_SIGN_CTX 0
+#define OCSP_F_OCSP_BASIC_VERIFY 0
+#define OCSP_F_OCSP_CERT_ID_NEW 0
+#define OCSP_F_OCSP_CHECK_DELEGATED 0
+#define OCSP_F_OCSP_CHECK_IDS 0
+#define OCSP_F_OCSP_CHECK_ISSUER 0
+#define OCSP_F_OCSP_CHECK_VALIDITY 0
+#define OCSP_F_OCSP_MATCH_ISSUERID 0
+#define OCSP_F_OCSP_PARSE_URL 0
+#define OCSP_F_OCSP_REQUEST_SIGN 0
+#define OCSP_F_OCSP_REQUEST_VERIFY 0
+#define OCSP_F_OCSP_RESPONSE_GET1_BASIC 0
+#define OCSP_F_PARSE_HTTP_LINE1 0
+#endif
 
 /*
  * PEM function codes.
  */
-#  define PEM_F_B2I_DSS                                    0
-#  define PEM_F_B2I_PVK_BIO                                0
-#  define PEM_F_B2I_RSA                                    0
-#  define PEM_F_CHECK_BITLEN_DSA                           0
-#  define PEM_F_CHECK_BITLEN_RSA                           0
-#  define PEM_F_D2I_PKCS8PRIVATEKEY_BIO                    0
-#  define PEM_F_D2I_PKCS8PRIVATEKEY_FP                     0
-#  define PEM_F_DO_B2I                                     0
-#  define PEM_F_DO_B2I_BIO                                 0
-#  define PEM_F_DO_BLOB_HEADER                             0
-#  define PEM_F_DO_I2B                                     0
-#  define PEM_F_DO_PK8PKEY                                 0
-#  define PEM_F_DO_PK8PKEY_FP                              0
-#  define PEM_F_DO_PVK_BODY                                0
-#  define PEM_F_DO_PVK_HEADER                              0
-#  define PEM_F_GET_HEADER_AND_DATA                        0
-#  define PEM_F_GET_NAME                                   0
-#  define PEM_F_I2B_PVK                                    0
-#  define PEM_F_I2B_PVK_BIO                                0
-#  define PEM_F_LOAD_IV                                    0
-#  define PEM_F_PEM_ASN1_READ                              0
-#  define PEM_F_PEM_ASN1_READ_BIO                          0
-#  define PEM_F_PEM_ASN1_WRITE                             0
-#  define PEM_F_PEM_ASN1_WRITE_BIO                         0
-#  define PEM_F_PEM_DEF_CALLBACK                           0
-#  define PEM_F_PEM_DO_HEADER                              0
-#  define PEM_F_PEM_GET_EVP_CIPHER_INFO                    0
-#  define PEM_F_PEM_READ                                   0
-#  define PEM_F_PEM_READ_BIO                               0
-#  define PEM_F_PEM_READ_BIO_DHPARAMS                      0
-#  define PEM_F_PEM_READ_BIO_EX                            0
-#  define PEM_F_PEM_READ_BIO_PARAMETERS                    0
-#  define PEM_F_PEM_READ_BIO_PRIVATEKEY                    0
-#  define PEM_F_PEM_READ_DHPARAMS                          0
-#  define PEM_F_PEM_READ_PRIVATEKEY                        0
-#  define PEM_F_PEM_SIGNFINAL                              0
-#  define PEM_F_PEM_WRITE                                  0
-#  define PEM_F_PEM_WRITE_BIO                              0
-#  define PEM_F_PEM_WRITE_BIO_PRIVATEKEY_TRADITIONAL       0
-#  define PEM_F_PEM_WRITE_PRIVATEKEY                       0
-#  define PEM_F_PEM_X509_INFO_READ                         0
-#  define PEM_F_PEM_X509_INFO_READ_BIO                     0
-#  define PEM_F_PEM_X509_INFO_WRITE_BIO                    0
+#define PEM_F_B2I_DSS 0
+#define PEM_F_B2I_PVK_BIO 0
+#define PEM_F_B2I_RSA 0
+#define PEM_F_CHECK_BITLEN_DSA 0
+#define PEM_F_CHECK_BITLEN_RSA 0
+#define PEM_F_D2I_PKCS8PRIVATEKEY_BIO 0
+#define PEM_F_D2I_PKCS8PRIVATEKEY_FP 0
+#define PEM_F_DO_B2I 0
+#define PEM_F_DO_B2I_BIO 0
+#define PEM_F_DO_BLOB_HEADER 0
+#define PEM_F_DO_I2B 0
+#define PEM_F_DO_PK8PKEY 0
+#define PEM_F_DO_PK8PKEY_FP 0
+#define PEM_F_DO_PVK_BODY 0
+#define PEM_F_DO_PVK_HEADER 0
+#define PEM_F_GET_HEADER_AND_DATA 0
+#define PEM_F_GET_NAME 0
+#define PEM_F_I2B_PVK 0
+#define PEM_F_I2B_PVK_BIO 0
+#define PEM_F_LOAD_IV 0
+#define PEM_F_PEM_ASN1_READ 0
+#define PEM_F_PEM_ASN1_READ_BIO 0
+#define PEM_F_PEM_ASN1_WRITE 0
+#define PEM_F_PEM_ASN1_WRITE_BIO 0
+#define PEM_F_PEM_DEF_CALLBACK 0
+#define PEM_F_PEM_DO_HEADER 0
+#define PEM_F_PEM_GET_EVP_CIPHER_INFO 0
+#define PEM_F_PEM_READ 0
+#define PEM_F_PEM_READ_BIO 0
+#define PEM_F_PEM_READ_BIO_DHPARAMS 0
+#define PEM_F_PEM_READ_BIO_EX 0
+#define PEM_F_PEM_READ_BIO_PARAMETERS 0
+#define PEM_F_PEM_READ_BIO_PRIVATEKEY 0
+#define PEM_F_PEM_READ_DHPARAMS 0
+#define PEM_F_PEM_READ_PRIVATEKEY 0
+#define PEM_F_PEM_SIGNFINAL 0
+#define PEM_F_PEM_WRITE 0
+#define PEM_F_PEM_WRITE_BIO 0
+#define PEM_F_PEM_WRITE_BIO_PRIVATEKEY_TRADITIONAL 0
+#define PEM_F_PEM_WRITE_PRIVATEKEY 0
+#define PEM_F_PEM_X509_INFO_READ 0
+#define PEM_F_PEM_X509_INFO_READ_BIO 0
+#define PEM_F_PEM_X509_INFO_WRITE_BIO 0
 
 /*
  * PKCS12 function codes.
  */
-#  define PKCS12_F_OPENSSL_ASC2UNI                         0
-#  define PKCS12_F_OPENSSL_UNI2ASC                         0
-#  define PKCS12_F_OPENSSL_UNI2UTF8                        0
-#  define PKCS12_F_OPENSSL_UTF82UNI                        0
-#  define PKCS12_F_PKCS12_CREATE                           0
-#  define PKCS12_F_PKCS12_GEN_MAC                          0
-#  define PKCS12_F_PKCS12_INIT                             0
-#  define PKCS12_F_PKCS12_ITEM_DECRYPT_D2I                 0
-#  define PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT                 0
-#  define PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG                0
-#  define PKCS12_F_PKCS12_KEY_GEN_ASC                      0
-#  define PKCS12_F_PKCS12_KEY_GEN_UNI                      0
-#  define PKCS12_F_PKCS12_KEY_GEN_UTF8                     0
-#  define PKCS12_F_PKCS12_NEWPASS                          0
-#  define PKCS12_F_PKCS12_PACK_P7DATA                      0
-#  define PKCS12_F_PKCS12_PACK_P7ENCDATA                   0
-#  define PKCS12_F_PKCS12_PARSE                            0
-#  define PKCS12_F_PKCS12_PBE_CRYPT                        0
-#  define PKCS12_F_PKCS12_PBE_KEYIVGEN                     0
-#  define PKCS12_F_PKCS12_SAFEBAG_CREATE0_P8INF            0
-#  define PKCS12_F_PKCS12_SAFEBAG_CREATE0_PKCS8            0
-#  define PKCS12_F_PKCS12_SAFEBAG_CREATE_PKCS8_ENCRYPT     0
-#  define PKCS12_F_PKCS12_SETUP_MAC                        0
-#  define PKCS12_F_PKCS12_SET_MAC                          0
-#  define PKCS12_F_PKCS12_UNPACK_AUTHSAFES                 0
-#  define PKCS12_F_PKCS12_UNPACK_P7DATA                    0
-#  define PKCS12_F_PKCS12_VERIFY_MAC                       0
-#  define PKCS12_F_PKCS8_ENCRYPT                           0
-#  define PKCS12_F_PKCS8_SET0_PBE                          0
+#define PKCS12_F_OPENSSL_ASC2UNI 0
+#define PKCS12_F_OPENSSL_UNI2ASC 0
+#define PKCS12_F_OPENSSL_UNI2UTF8 0
+#define PKCS12_F_OPENSSL_UTF82UNI 0
+#define PKCS12_F_PKCS12_CREATE 0
+#define PKCS12_F_PKCS12_GEN_MAC 0
+#define PKCS12_F_PKCS12_INIT 0
+#define PKCS12_F_PKCS12_ITEM_DECRYPT_D2I 0
+#define PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT 0
+#define PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG 0
+#define PKCS12_F_PKCS12_KEY_GEN_ASC 0
+#define PKCS12_F_PKCS12_KEY_GEN_UNI 0
+#define PKCS12_F_PKCS12_KEY_GEN_UTF8 0
+#define PKCS12_F_PKCS12_NEWPASS 0
+#define PKCS12_F_PKCS12_PACK_P7DATA 0
+#define PKCS12_F_PKCS12_PACK_P7ENCDATA 0
+#define PKCS12_F_PKCS12_PARSE 0
+#define PKCS12_F_PKCS12_PBE_CRYPT 0
+#define PKCS12_F_PKCS12_PBE_KEYIVGEN 0
+#define PKCS12_F_PKCS12_SAFEBAG_CREATE0_P8INF 0
+#define PKCS12_F_PKCS12_SAFEBAG_CREATE0_PKCS8 0
+#define PKCS12_F_PKCS12_SAFEBAG_CREATE_PKCS8_ENCRYPT 0
+#define PKCS12_F_PKCS12_SETUP_MAC 0
+#define PKCS12_F_PKCS12_SET_MAC 0
+#define PKCS12_F_PKCS12_UNPACK_AUTHSAFES 0
+#define PKCS12_F_PKCS12_UNPACK_P7DATA 0
+#define PKCS12_F_PKCS12_VERIFY_MAC 0
+#define PKCS12_F_PKCS8_ENCRYPT 0
+#define PKCS12_F_PKCS8_SET0_PBE 0
 
 /*
  * PKCS7 function codes.
  */
-#  define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB                   0
-#  define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME           0
-#  define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP                0
-#  define PKCS7_F_PKCS7_ADD_CERTIFICATE                    0
-#  define PKCS7_F_PKCS7_ADD_CRL                            0
-#  define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO                 0
-#  define PKCS7_F_PKCS7_ADD_SIGNATURE                      0
-#  define PKCS7_F_PKCS7_ADD_SIGNER                         0
-#  define PKCS7_F_PKCS7_BIO_ADD_DIGEST                     0
-#  define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST               0
-#  define PKCS7_F_PKCS7_CTRL                               0
-#  define PKCS7_F_PKCS7_DATADECODE                         0
-#  define PKCS7_F_PKCS7_DATAFINAL                          0
-#  define PKCS7_F_PKCS7_DATAINIT                           0
-#  define PKCS7_F_PKCS7_DATAVERIFY                         0
-#  define PKCS7_F_PKCS7_DECRYPT                            0
-#  define PKCS7_F_PKCS7_DECRYPT_RINFO                      0
-#  define PKCS7_F_PKCS7_ENCODE_RINFO                       0
-#  define PKCS7_F_PKCS7_ENCRYPT                            0
-#  define PKCS7_F_PKCS7_FINAL                              0
-#  define PKCS7_F_PKCS7_FIND_DIGEST                        0
-#  define PKCS7_F_PKCS7_GET0_SIGNERS                       0
-#  define PKCS7_F_PKCS7_RECIP_INFO_SET                     0
-#  define PKCS7_F_PKCS7_SET_CIPHER                         0
-#  define PKCS7_F_PKCS7_SET_CONTENT                        0
-#  define PKCS7_F_PKCS7_SET_DIGEST                         0
-#  define PKCS7_F_PKCS7_SET_TYPE                           0
-#  define PKCS7_F_PKCS7_SIGN                               0
-#  define PKCS7_F_PKCS7_SIGNATUREVERIFY                    0
-#  define PKCS7_F_PKCS7_SIGNER_INFO_SET                    0
-#  define PKCS7_F_PKCS7_SIGNER_INFO_SIGN                   0
-#  define PKCS7_F_PKCS7_SIGN_ADD_SIGNER                    0
-#  define PKCS7_F_PKCS7_SIMPLE_SMIMECAP                    0
-#  define PKCS7_F_PKCS7_VERIFY                             0
+#define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB 0
+#define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME 0
+#define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP 0
+#define PKCS7_F_PKCS7_ADD_CERTIFICATE 0
+#define PKCS7_F_PKCS7_ADD_CRL 0
+#define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO 0
+#define PKCS7_F_PKCS7_ADD_SIGNATURE 0
+#define PKCS7_F_PKCS7_ADD_SIGNER 0
+#define PKCS7_F_PKCS7_BIO_ADD_DIGEST 0
+#define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST 0
+#define PKCS7_F_PKCS7_CTRL 0
+#define PKCS7_F_PKCS7_DATADECODE 0
+#define PKCS7_F_PKCS7_DATAFINAL 0
+#define PKCS7_F_PKCS7_DATAINIT 0
+#define PKCS7_F_PKCS7_DATAVERIFY 0
+#define PKCS7_F_PKCS7_DECRYPT 0
+#define PKCS7_F_PKCS7_DECRYPT_RINFO 0
+#define PKCS7_F_PKCS7_ENCODE_RINFO 0
+#define PKCS7_F_PKCS7_ENCRYPT 0
+#define PKCS7_F_PKCS7_FINAL 0
+#define PKCS7_F_PKCS7_FIND_DIGEST 0
+#define PKCS7_F_PKCS7_GET0_SIGNERS 0
+#define PKCS7_F_PKCS7_RECIP_INFO_SET 0
+#define PKCS7_F_PKCS7_SET_CIPHER 0
+#define PKCS7_F_PKCS7_SET_CONTENT 0
+#define PKCS7_F_PKCS7_SET_DIGEST 0
+#define PKCS7_F_PKCS7_SET_TYPE 0
+#define PKCS7_F_PKCS7_SIGN 0
+#define PKCS7_F_PKCS7_SIGNATUREVERIFY 0
+#define PKCS7_F_PKCS7_SIGNER_INFO_SET 0
+#define PKCS7_F_PKCS7_SIGNER_INFO_SIGN 0
+#define PKCS7_F_PKCS7_SIGN_ADD_SIGNER 0
+#define PKCS7_F_PKCS7_SIMPLE_SMIMECAP 0
+#define PKCS7_F_PKCS7_VERIFY 0
 
 /*
  * RAND function codes.
  */
-#  define RAND_F_DATA_COLLECT_METHOD                       0
-#  define RAND_F_DRBG_BYTES                                0
-#  define RAND_F_DRBG_GET_ENTROPY                          0
-#  define RAND_F_DRBG_SETUP                                0
-#  define RAND_F_GET_ENTROPY                               0
-#  define RAND_F_RAND_BYTES                                0
-#  define RAND_F_RAND_DRBG_ENABLE_LOCKING                  0
-#  define RAND_F_RAND_DRBG_GENERATE                        0
-#  define RAND_F_RAND_DRBG_GET_ENTROPY                     0
-#  define RAND_F_RAND_DRBG_GET_NONCE                       0
-#  define RAND_F_RAND_DRBG_INSTANTIATE                     0
-#  define RAND_F_RAND_DRBG_NEW                             0
-#  define RAND_F_RAND_DRBG_RESEED                          0
-#  define RAND_F_RAND_DRBG_RESTART                         0
-#  define RAND_F_RAND_DRBG_SET                             0
-#  define RAND_F_RAND_DRBG_SET_DEFAULTS                    0
-#  define RAND_F_RAND_DRBG_UNINSTANTIATE                   0
-#  define RAND_F_RAND_LOAD_FILE                            0
-#  define RAND_F_RAND_POOL_ACQUIRE_ENTROPY                 0
-#  define RAND_F_RAND_POOL_ADD                             0
-#  define RAND_F_RAND_POOL_ADD_BEGIN                       0
-#  define RAND_F_RAND_POOL_ADD_END                         0
-#  define RAND_F_RAND_POOL_ATTACH                          0
-#  define RAND_F_RAND_POOL_BYTES_NEEDED                    0
-#  define RAND_F_RAND_POOL_GROW                            0
-#  define RAND_F_RAND_POOL_NEW                             0
-#  define RAND_F_RAND_PSEUDO_BYTES                         0
-#  define RAND_F_RAND_WRITE_FILE                           0
+#define RAND_F_DATA_COLLECT_METHOD 0
+#define RAND_F_DRBG_BYTES 0
+#define RAND_F_DRBG_GET_ENTROPY 0
+#define RAND_F_DRBG_SETUP 0
+#define RAND_F_GET_ENTROPY 0
+#define RAND_F_RAND_BYTES 0
+#define RAND_F_RAND_DRBG_ENABLE_LOCKING 0
+#define RAND_F_RAND_DRBG_GENERATE 0
+#define RAND_F_RAND_DRBG_GET_ENTROPY 0
+#define RAND_F_RAND_DRBG_GET_NONCE 0
+#define RAND_F_RAND_DRBG_INSTANTIATE 0
+#define RAND_F_RAND_DRBG_NEW 0
+#define RAND_F_RAND_DRBG_RESEED 0
+#define RAND_F_RAND_DRBG_RESTART 0
+#define RAND_F_RAND_DRBG_SET 0
+#define RAND_F_RAND_DRBG_SET_DEFAULTS 0
+#define RAND_F_RAND_DRBG_UNINSTANTIATE 0
+#define RAND_F_RAND_LOAD_FILE 0
+#define RAND_F_RAND_POOL_ACQUIRE_ENTROPY 0
+#define RAND_F_RAND_POOL_ADD 0
+#define RAND_F_RAND_POOL_ADD_BEGIN 0
+#define RAND_F_RAND_POOL_ADD_END 0
+#define RAND_F_RAND_POOL_ATTACH 0
+#define RAND_F_RAND_POOL_BYTES_NEEDED 0
+#define RAND_F_RAND_POOL_GROW 0
+#define RAND_F_RAND_POOL_NEW 0
+#define RAND_F_RAND_PSEUDO_BYTES 0
+#define RAND_F_RAND_WRITE_FILE 0
 
 /*
  * RSA function codes.
  */
-#  define RSA_F_CHECK_PADDING_MD                           0
-#  define RSA_F_ENCODE_PKCS1                               0
-#  define RSA_F_INT_RSA_VERIFY                             0
-#  define RSA_F_OLD_RSA_PRIV_DECODE                        0
-#  define RSA_F_PKEY_PSS_INIT                              0
-#  define RSA_F_PKEY_RSA_CTRL                              0
-#  define RSA_F_PKEY_RSA_CTRL_STR                          0
-#  define RSA_F_PKEY_RSA_SIGN                              0
-#  define RSA_F_PKEY_RSA_VERIFY                            0
-#  define RSA_F_PKEY_RSA_VERIFYRECOVER                     0
-#  define RSA_F_RSA_ALGOR_TO_MD                            0
-#  define RSA_F_RSA_BUILTIN_KEYGEN                         0
-#  define RSA_F_RSA_CHECK_KEY                              0
-#  define RSA_F_RSA_CHECK_KEY_EX                           0
-#  define RSA_F_RSA_CMS_DECRYPT                            0
-#  define RSA_F_RSA_CMS_VERIFY                             0
-#  define RSA_F_RSA_ITEM_VERIFY                            0
-#  define RSA_F_RSA_METH_DUP                               0
-#  define RSA_F_RSA_METH_NEW                               0
-#  define RSA_F_RSA_METH_SET1_NAME                         0
-#  define RSA_F_RSA_MGF1_TO_MD                             0
-#  define RSA_F_RSA_MULTIP_INFO_NEW                        0
-#  define RSA_F_RSA_NEW_METHOD                             0
-#  define RSA_F_RSA_NULL                                   0
-#  define RSA_F_RSA_NULL_PRIVATE_DECRYPT                   0
-#  define RSA_F_RSA_NULL_PRIVATE_ENCRYPT                   0
-#  define RSA_F_RSA_NULL_PUBLIC_DECRYPT                    0
-#  define RSA_F_RSA_NULL_PUBLIC_ENCRYPT                    0
-#  define RSA_F_RSA_OSSL_PRIVATE_DECRYPT                   0
-#  define RSA_F_RSA_OSSL_PRIVATE_ENCRYPT                   0
-#  define RSA_F_RSA_OSSL_PUBLIC_DECRYPT                    0
-#  define RSA_F_RSA_OSSL_PUBLIC_ENCRYPT                    0
-#  define RSA_F_RSA_PADDING_ADD_NONE                       0
-#  define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP                 0
-#  define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP_MGF1            0
-#  define RSA_F_RSA_PADDING_ADD_PKCS1_PSS                  0
-#  define RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1             0
-#  define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1               0
-#  define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2               0
-#  define RSA_F_RSA_PADDING_ADD_SSLV23                     0
-#  define RSA_F_RSA_PADDING_ADD_X931                       0
-#  define RSA_F_RSA_PADDING_CHECK_NONE                     0
-#  define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP               0
-#  define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP_MGF1          0
-#  define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1             0
-#  define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2             0
-#  define RSA_F_RSA_PADDING_CHECK_SSLV23                   0
-#  define RSA_F_RSA_PADDING_CHECK_X931                     0
-#  define RSA_F_RSA_PARAM_DECODE                           0
-#  define RSA_F_RSA_PRINT                                  0
-#  define RSA_F_RSA_PRINT_FP                               0
-#  define RSA_F_RSA_PRIV_DECODE                            0
-#  define RSA_F_RSA_PRIV_ENCODE                            0
-#  define RSA_F_RSA_PSS_GET_PARAM                          0
-#  define RSA_F_RSA_PSS_TO_CTX                             0
-#  define RSA_F_RSA_PUB_DECODE                             0
-#  define RSA_F_RSA_SETUP_BLINDING                         0
-#  define RSA_F_RSA_SIGN                                   0
-#  define RSA_F_RSA_SIGN_ASN1_OCTET_STRING                 0
-#  define RSA_F_RSA_VERIFY                                 0
-#  define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING               0
-#  define RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1                  0
-#  define RSA_F_SETUP_TBUF                                 0
+#define RSA_F_CHECK_PADDING_MD 0
+#define RSA_F_ENCODE_PKCS1 0
+#define RSA_F_INT_RSA_VERIFY 0
+#define RSA_F_OLD_RSA_PRIV_DECODE 0
+#define RSA_F_PKEY_PSS_INIT 0
+#define RSA_F_PKEY_RSA_CTRL 0
+#define RSA_F_PKEY_RSA_CTRL_STR 0
+#define RSA_F_PKEY_RSA_SIGN 0
+#define RSA_F_PKEY_RSA_VERIFY 0
+#define RSA_F_PKEY_RSA_VERIFYRECOVER 0
+#define RSA_F_RSA_ALGOR_TO_MD 0
+#define RSA_F_RSA_BUILTIN_KEYGEN 0
+#define RSA_F_RSA_CHECK_KEY 0
+#define RSA_F_RSA_CHECK_KEY_EX 0
+#define RSA_F_RSA_CMS_DECRYPT 0
+#define RSA_F_RSA_CMS_VERIFY 0
+#define RSA_F_RSA_ITEM_VERIFY 0
+#define RSA_F_RSA_METH_DUP 0
+#define RSA_F_RSA_METH_NEW 0
+#define RSA_F_RSA_METH_SET1_NAME 0
+#define RSA_F_RSA_MGF1_TO_MD 0
+#define RSA_F_RSA_MULTIP_INFO_NEW 0
+#define RSA_F_RSA_NEW_METHOD 0
+#define RSA_F_RSA_NULL 0
+#define RSA_F_RSA_NULL_PRIVATE_DECRYPT 0
+#define RSA_F_RSA_NULL_PRIVATE_ENCRYPT 0
+#define RSA_F_RSA_NULL_PUBLIC_DECRYPT 0
+#define RSA_F_RSA_NULL_PUBLIC_ENCRYPT 0
+#define RSA_F_RSA_OSSL_PRIVATE_DECRYPT 0
+#define RSA_F_RSA_OSSL_PRIVATE_ENCRYPT 0
+#define RSA_F_RSA_OSSL_PUBLIC_DECRYPT 0
+#define RSA_F_RSA_OSSL_PUBLIC_ENCRYPT 0
+#define RSA_F_RSA_PADDING_ADD_NONE 0
+#define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP 0
+#define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP_MGF1 0
+#define RSA_F_RSA_PADDING_ADD_PKCS1_PSS 0
+#define RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1 0
+#define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1 0
+#define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2 0
+#define RSA_F_RSA_PADDING_ADD_SSLV23 0
+#define RSA_F_RSA_PADDING_ADD_X931 0
+#define RSA_F_RSA_PADDING_CHECK_NONE 0
+#define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP 0
+#define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP_MGF1 0
+#define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1 0
+#define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2 0
+#define RSA_F_RSA_PADDING_CHECK_SSLV23 0
+#define RSA_F_RSA_PADDING_CHECK_X931 0
+#define RSA_F_RSA_PARAM_DECODE 0
+#define RSA_F_RSA_PRINT 0
+#define RSA_F_RSA_PRINT_FP 0
+#define RSA_F_RSA_PRIV_DECODE 0
+#define RSA_F_RSA_PRIV_ENCODE 0
+#define RSA_F_RSA_PSS_GET_PARAM 0
+#define RSA_F_RSA_PSS_TO_CTX 0
+#define RSA_F_RSA_PUB_DECODE 0
+#define RSA_F_RSA_SETUP_BLINDING 0
+#define RSA_F_RSA_SIGN 0
+#define RSA_F_RSA_SIGN_ASN1_OCTET_STRING 0
+#define RSA_F_RSA_VERIFY 0
+#define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING 0
+#define RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1 0
+#define RSA_F_SETUP_TBUF 0
 
 /*
  * OSSL_STORE function codes.
  */
-#  define OSSL_STORE_F_FILE_CTRL                           0
-#  define OSSL_STORE_F_FILE_FIND                           0
-#  define OSSL_STORE_F_FILE_GET_PASS                       0
-#  define OSSL_STORE_F_FILE_LOAD                           0
-#  define OSSL_STORE_F_FILE_LOAD_TRY_DECODE                0
-#  define OSSL_STORE_F_FILE_NAME_TO_URI                    0
-#  define OSSL_STORE_F_FILE_OPEN                           0
-#  define OSSL_STORE_F_OSSL_STORE_ATTACH_PEM_BIO           0
-#  define OSSL_STORE_F_OSSL_STORE_EXPECT                   0
-#  define OSSL_STORE_F_OSSL_STORE_FILE_ATTACH_PEM_BIO_INT  0
-#  define OSSL_STORE_F_OSSL_STORE_FIND                     0
-#  define OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT          0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CERT           0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CRL            0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME           0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME_DESCRIPTION 0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PARAMS         0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PKEY           0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CERT            0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CRL             0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_EMBEDDED        0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_NAME            0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PARAMS          0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PKEY            0
-#  define OSSL_STORE_F_OSSL_STORE_INFO_SET0_NAME_DESCRIPTION 0
-#  define OSSL_STORE_F_OSSL_STORE_INIT_ONCE                0
-#  define OSSL_STORE_F_OSSL_STORE_LOADER_NEW               0
-#  define OSSL_STORE_F_OSSL_STORE_OPEN                     0
-#  define OSSL_STORE_F_OSSL_STORE_OPEN_INT                 0
-#  define OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT      0
-#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ALIAS          0
-#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ISSUER_SERIAL  0
-#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 0
-#  define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_NAME           0
-#  define OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT    0
-#  define OSSL_STORE_F_TRY_DECODE_PARAMS                   0
-#  define OSSL_STORE_F_TRY_DECODE_PKCS12                   0
-#  define OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED           0
+#define OSSL_STORE_F_FILE_CTRL 0
+#define OSSL_STORE_F_FILE_FIND 0
+#define OSSL_STORE_F_FILE_GET_PASS 0
+#define OSSL_STORE_F_FILE_LOAD 0
+#define OSSL_STORE_F_FILE_LOAD_TRY_DECODE 0
+#define OSSL_STORE_F_FILE_NAME_TO_URI 0
+#define OSSL_STORE_F_FILE_OPEN 0
+#define OSSL_STORE_F_OSSL_STORE_ATTACH_PEM_BIO 0
+#define OSSL_STORE_F_OSSL_STORE_EXPECT 0
+#define OSSL_STORE_F_OSSL_STORE_FILE_ATTACH_PEM_BIO_INT 0
+#define OSSL_STORE_F_OSSL_STORE_FIND 0
+#define OSSL_STORE_F_OSSL_STORE_GET0_LOADER_INT 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CERT 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_GET1_CRL 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME_DESCRIPTION 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PARAMS 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_GET1_PKEY 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CERT 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_NEW_CRL 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_NEW_EMBEDDED 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_NEW_NAME 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PARAMS 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_NEW_PKEY 0
+#define OSSL_STORE_F_OSSL_STORE_INFO_SET0_NAME_DESCRIPTION 0
+#define OSSL_STORE_F_OSSL_STORE_INIT_ONCE 0
+#define OSSL_STORE_F_OSSL_STORE_LOADER_NEW 0
+#define OSSL_STORE_F_OSSL_STORE_OPEN 0
+#define OSSL_STORE_F_OSSL_STORE_OPEN_INT 0
+#define OSSL_STORE_F_OSSL_STORE_REGISTER_LOADER_INT 0
+#define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ALIAS 0
+#define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_ISSUER_SERIAL 0
+#define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 0
+#define OSSL_STORE_F_OSSL_STORE_SEARCH_BY_NAME 0
+#define OSSL_STORE_F_OSSL_STORE_UNREGISTER_LOADER_INT 0
+#define OSSL_STORE_F_TRY_DECODE_PARAMS 0
+#define OSSL_STORE_F_TRY_DECODE_PKCS12 0
+#define OSSL_STORE_F_TRY_DECODE_PKCS8ENCRYPTED 0
 
-#  ifndef OPENSSL_NO_TS
+#ifndef OPENSSL_NO_TS
 /*
  * TS function codes.
  */
-#   define TS_F_DEF_SERIAL_CB                               0
-#   define TS_F_DEF_TIME_CB                                 0
-#   define TS_F_ESS_ADD_SIGNING_CERT                        0
-#   define TS_F_ESS_ADD_SIGNING_CERT_V2                     0
-#   define TS_F_ESS_CERT_ID_NEW_INIT                        0
-#   define TS_F_ESS_CERT_ID_V2_NEW_INIT                     0
-#   define TS_F_ESS_SIGNING_CERT_NEW_INIT                   0
-#   define TS_F_ESS_SIGNING_CERT_V2_NEW_INIT                0
-#   define TS_F_INT_TS_RESP_VERIFY_TOKEN                    0
-#   define TS_F_PKCS7_TO_TS_TST_INFO                        0
-#   define TS_F_TS_ACCURACY_SET_MICROS                      0
-#   define TS_F_TS_ACCURACY_SET_MILLIS                      0
-#   define TS_F_TS_ACCURACY_SET_SECONDS                     0
-#   define TS_F_TS_CHECK_IMPRINTS                           0
-#   define TS_F_TS_CHECK_NONCES                             0
-#   define TS_F_TS_CHECK_POLICY                             0
-#   define TS_F_TS_CHECK_SIGNING_CERTS                      0
-#   define TS_F_TS_CHECK_STATUS_INFO                        0
-#   define TS_F_TS_COMPUTE_IMPRINT                          0
-#   define TS_F_TS_CONF_INVALID                             0
-#   define TS_F_TS_CONF_LOAD_CERT                           0
-#   define TS_F_TS_CONF_LOAD_CERTS                          0
-#   define TS_F_TS_CONF_LOAD_KEY                            0
-#   define TS_F_TS_CONF_LOOKUP_FAIL                         0
-#   define TS_F_TS_CONF_SET_DEFAULT_ENGINE                  0
-#   define TS_F_TS_GET_STATUS_TEXT                          0
-#   define TS_F_TS_MSG_IMPRINT_SET_ALGO                     0
-#   define TS_F_TS_REQ_SET_MSG_IMPRINT                      0
-#   define TS_F_TS_REQ_SET_NONCE                            0
-#   define TS_F_TS_REQ_SET_POLICY_ID                        0
-#   define TS_F_TS_RESP_CREATE_RESPONSE                     0
-#   define TS_F_TS_RESP_CREATE_TST_INFO                     0
-#   define TS_F_TS_RESP_CTX_ADD_FAILURE_INFO                0
-#   define TS_F_TS_RESP_CTX_ADD_MD                          0
-#   define TS_F_TS_RESP_CTX_ADD_POLICY                      0
-#   define TS_F_TS_RESP_CTX_NEW                             0
-#   define TS_F_TS_RESP_CTX_SET_ACCURACY                    0
-#   define TS_F_TS_RESP_CTX_SET_CERTS                       0
-#   define TS_F_TS_RESP_CTX_SET_DEF_POLICY                  0
-#   define TS_F_TS_RESP_CTX_SET_SIGNER_CERT                 0
-#   define TS_F_TS_RESP_CTX_SET_STATUS_INFO                 0
-#   define TS_F_TS_RESP_GET_POLICY                          0
-#   define TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION          0
-#   define TS_F_TS_RESP_SET_STATUS_INFO                     0
-#   define TS_F_TS_RESP_SET_TST_INFO                        0
-#   define TS_F_TS_RESP_SIGN                                0
-#   define TS_F_TS_RESP_VERIFY_SIGNATURE                    0
-#   define TS_F_TS_TST_INFO_SET_ACCURACY                    0
-#   define TS_F_TS_TST_INFO_SET_MSG_IMPRINT                 0
-#   define TS_F_TS_TST_INFO_SET_NONCE                       0
-#   define TS_F_TS_TST_INFO_SET_POLICY_ID                   0
-#   define TS_F_TS_TST_INFO_SET_SERIAL                      0
-#   define TS_F_TS_TST_INFO_SET_TIME                        0
-#   define TS_F_TS_TST_INFO_SET_TSA                         0
-#   define TS_F_TS_VERIFY                                   0
-#   define TS_F_TS_VERIFY_CERT                              0
-#   define TS_F_TS_VERIFY_CTX_NEW                           0
-#  endif
+#define TS_F_DEF_SERIAL_CB 0
+#define TS_F_DEF_TIME_CB 0
+#define TS_F_ESS_ADD_SIGNING_CERT 0
+#define TS_F_ESS_ADD_SIGNING_CERT_V2 0
+#define TS_F_ESS_CERT_ID_NEW_INIT 0
+#define TS_F_ESS_CERT_ID_V2_NEW_INIT 0
+#define TS_F_ESS_SIGNING_CERT_NEW_INIT 0
+#define TS_F_ESS_SIGNING_CERT_V2_NEW_INIT 0
+#define TS_F_INT_TS_RESP_VERIFY_TOKEN 0
+#define TS_F_PKCS7_TO_TS_TST_INFO 0
+#define TS_F_TS_ACCURACY_SET_MICROS 0
+#define TS_F_TS_ACCURACY_SET_MILLIS 0
+#define TS_F_TS_ACCURACY_SET_SECONDS 0
+#define TS_F_TS_CHECK_IMPRINTS 0
+#define TS_F_TS_CHECK_NONCES 0
+#define TS_F_TS_CHECK_POLICY 0
+#define TS_F_TS_CHECK_SIGNING_CERTS 0
+#define TS_F_TS_CHECK_STATUS_INFO 0
+#define TS_F_TS_COMPUTE_IMPRINT 0
+#define TS_F_TS_CONF_INVALID 0
+#define TS_F_TS_CONF_LOAD_CERT 0
+#define TS_F_TS_CONF_LOAD_CERTS 0
+#define TS_F_TS_CONF_LOAD_KEY 0
+#define TS_F_TS_CONF_LOOKUP_FAIL 0
+#define TS_F_TS_CONF_SET_DEFAULT_ENGINE 0
+#define TS_F_TS_GET_STATUS_TEXT 0
+#define TS_F_TS_MSG_IMPRINT_SET_ALGO 0
+#define TS_F_TS_REQ_SET_MSG_IMPRINT 0
+#define TS_F_TS_REQ_SET_NONCE 0
+#define TS_F_TS_REQ_SET_POLICY_ID 0
+#define TS_F_TS_RESP_CREATE_RESPONSE 0
+#define TS_F_TS_RESP_CREATE_TST_INFO 0
+#define TS_F_TS_RESP_CTX_ADD_FAILURE_INFO 0
+#define TS_F_TS_RESP_CTX_ADD_MD 0
+#define TS_F_TS_RESP_CTX_ADD_POLICY 0
+#define TS_F_TS_RESP_CTX_NEW 0
+#define TS_F_TS_RESP_CTX_SET_ACCURACY 0
+#define TS_F_TS_RESP_CTX_SET_CERTS 0
+#define TS_F_TS_RESP_CTX_SET_DEF_POLICY 0
+#define TS_F_TS_RESP_CTX_SET_SIGNER_CERT 0
+#define TS_F_TS_RESP_CTX_SET_STATUS_INFO 0
+#define TS_F_TS_RESP_GET_POLICY 0
+#define TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION 0
+#define TS_F_TS_RESP_SET_STATUS_INFO 0
+#define TS_F_TS_RESP_SET_TST_INFO 0
+#define TS_F_TS_RESP_SIGN 0
+#define TS_F_TS_RESP_VERIFY_SIGNATURE 0
+#define TS_F_TS_TST_INFO_SET_ACCURACY 0
+#define TS_F_TS_TST_INFO_SET_MSG_IMPRINT 0
+#define TS_F_TS_TST_INFO_SET_NONCE 0
+#define TS_F_TS_TST_INFO_SET_POLICY_ID 0
+#define TS_F_TS_TST_INFO_SET_SERIAL 0
+#define TS_F_TS_TST_INFO_SET_TIME 0
+#define TS_F_TS_TST_INFO_SET_TSA 0
+#define TS_F_TS_VERIFY 0
+#define TS_F_TS_VERIFY_CERT 0
+#define TS_F_TS_VERIFY_CTX_NEW 0
+#endif
 
 /*
  * UI function codes.
  */
-#  define UI_F_CLOSE_CONSOLE                               0
-#  define UI_F_ECHO_CONSOLE                                0
-#  define UI_F_GENERAL_ALLOCATE_BOOLEAN                    0
-#  define UI_F_GENERAL_ALLOCATE_PROMPT                     0
-#  define UI_F_NOECHO_CONSOLE                              0
-#  define UI_F_OPEN_CONSOLE                                0
-#  define UI_F_UI_CONSTRUCT_PROMPT                         0
-#  define UI_F_UI_CREATE_METHOD                            0
-#  define UI_F_UI_CTRL                                     0
-#  define UI_F_UI_DUP_ERROR_STRING                         0
-#  define UI_F_UI_DUP_INFO_STRING                          0
-#  define UI_F_UI_DUP_INPUT_BOOLEAN                        0
-#  define UI_F_UI_DUP_INPUT_STRING                         0
-#  define UI_F_UI_DUP_USER_DATA                            0
-#  define UI_F_UI_DUP_VERIFY_STRING                        0
-#  define UI_F_UI_GET0_RESULT                              0
-#  define UI_F_UI_GET_RESULT_LENGTH                        0
-#  define UI_F_UI_NEW_METHOD                               0
-#  define UI_F_UI_PROCESS                                  0
-#  define UI_F_UI_SET_RESULT                               0
-#  define UI_F_UI_SET_RESULT_EX                            0
+#define UI_F_CLOSE_CONSOLE 0
+#define UI_F_ECHO_CONSOLE 0
+#define UI_F_GENERAL_ALLOCATE_BOOLEAN 0
+#define UI_F_GENERAL_ALLOCATE_PROMPT 0
+#define UI_F_NOECHO_CONSOLE 0
+#define UI_F_OPEN_CONSOLE 0
+#define UI_F_UI_CONSTRUCT_PROMPT 0
+#define UI_F_UI_CREATE_METHOD 0
+#define UI_F_UI_CTRL 0
+#define UI_F_UI_DUP_ERROR_STRING 0
+#define UI_F_UI_DUP_INFO_STRING 0
+#define UI_F_UI_DUP_INPUT_BOOLEAN 0
+#define UI_F_UI_DUP_INPUT_STRING 0
+#define UI_F_UI_DUP_USER_DATA 0
+#define UI_F_UI_DUP_VERIFY_STRING 0
+#define UI_F_UI_GET0_RESULT 0
+#define UI_F_UI_GET_RESULT_LENGTH 0
+#define UI_F_UI_NEW_METHOD 0
+#define UI_F_UI_PROCESS 0
+#define UI_F_UI_SET_RESULT 0
+#define UI_F_UI_SET_RESULT_EX 0
 
 /*
  * X509 function codes.
  */
-#  define X509_F_ADD_CERT_DIR                              0
-#  define X509_F_BUILD_CHAIN                               0
-#  define X509_F_BY_FILE_CTRL                              0
-#  define X509_F_CHECK_NAME_CONSTRAINTS                    0
-#  define X509_F_CHECK_POLICY                              0
-#  define X509_F_DANE_I2D                                  0
-#  define X509_F_DIR_CTRL                                  0
-#  define X509_F_GET_CERT_BY_SUBJECT                       0
-#  define X509_F_I2D_X509_AUX                              0
-#  define X509_F_LOOKUP_CERTS_SK                           0
-#  define X509_F_NETSCAPE_SPKI_B64_DECODE                  0
-#  define X509_F_NETSCAPE_SPKI_B64_ENCODE                  0
-#  define X509_F_NEW_DIR                                   0
-#  define X509_F_X509AT_ADD1_ATTR                          0
-#  define X509_F_X509V3_ADD_EXT                            0
-#  define X509_F_X509_ATTRIBUTE_CREATE_BY_NID              0
-#  define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ              0
-#  define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT              0
-#  define X509_F_X509_ATTRIBUTE_GET0_DATA                  0
-#  define X509_F_X509_ATTRIBUTE_SET1_DATA                  0
-#  define X509_F_X509_CHECK_PRIVATE_KEY                    0
-#  define X509_F_X509_CRL_DIFF                             0
-#  define X509_F_X509_CRL_METHOD_NEW                       0
-#  define X509_F_X509_CRL_PRINT_FP                         0
-#  define X509_F_X509_EXTENSION_CREATE_BY_NID              0
-#  define X509_F_X509_EXTENSION_CREATE_BY_OBJ              0
-#  define X509_F_X509_GET_PUBKEY_PARAMETERS                0
-#  define X509_F_X509_LOAD_CERT_CRL_FILE                   0
-#  define X509_F_X509_LOAD_CERT_FILE                       0
-#  define X509_F_X509_LOAD_CRL_FILE                        0
-#  define X509_F_X509_LOOKUP_METH_NEW                      0
-#  define X509_F_X509_LOOKUP_NEW                           0
-#  define X509_F_X509_NAME_ADD_ENTRY                       0
-#  define X509_F_X509_NAME_CANON                           0
-#  define X509_F_X509_NAME_ENTRY_CREATE_BY_NID             0
-#  define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT             0
-#  define X509_F_X509_NAME_ENTRY_SET_OBJECT                0
-#  define X509_F_X509_NAME_ONELINE                         0
-#  define X509_F_X509_NAME_PRINT                           0
-#  define X509_F_X509_OBJECT_NEW                           0
-#  define X509_F_X509_PRINT_EX_FP                          0
-#  define X509_F_X509_PUBKEY_DECODE                        0
-#  define X509_F_X509_PUBKEY_GET                           0
-#  define X509_F_X509_PUBKEY_GET0                          0
-#  define X509_F_X509_PUBKEY_SET                           0
-#  define X509_F_X509_REQ_CHECK_PRIVATE_KEY                0
-#  define X509_F_X509_REQ_PRINT_EX                         0
-#  define X509_F_X509_REQ_PRINT_FP                         0
-#  define X509_F_X509_REQ_TO_X509                          0
-#  define X509_F_X509_STORE_ADD_CERT                       0
-#  define X509_F_X509_STORE_ADD_CRL                        0
-#  define X509_F_X509_STORE_ADD_LOOKUP                     0
-#  define X509_F_X509_STORE_CTX_GET1_ISSUER                0
-#  define X509_F_X509_STORE_CTX_INIT                       0
-#  define X509_F_X509_STORE_CTX_NEW                        0
-#  define X509_F_X509_STORE_CTX_PURPOSE_INHERIT            0
-#  define X509_F_X509_STORE_NEW                            0
-#  define X509_F_X509_TO_X509_REQ                          0
-#  define X509_F_X509_TRUST_ADD                            0
-#  define X509_F_X509_TRUST_SET                            0
-#  define X509_F_X509_VERIFY_CERT                          0
-#  define X509_F_X509_VERIFY_PARAM_NEW                     0
+#define X509_F_ADD_CERT_DIR 0
+#define X509_F_BUILD_CHAIN 0
+#define X509_F_BY_FILE_CTRL 0
+#define X509_F_CHECK_NAME_CONSTRAINTS 0
+#define X509_F_CHECK_POLICY 0
+#define X509_F_DANE_I2D 0
+#define X509_F_DIR_CTRL 0
+#define X509_F_GET_CERT_BY_SUBJECT 0
+#define X509_F_I2D_X509_AUX 0
+#define X509_F_LOOKUP_CERTS_SK 0
+#define X509_F_NETSCAPE_SPKI_B64_DECODE 0
+#define X509_F_NETSCAPE_SPKI_B64_ENCODE 0
+#define X509_F_NEW_DIR 0
+#define X509_F_X509AT_ADD1_ATTR 0
+#define X509_F_X509V3_ADD_EXT 0
+#define X509_F_X509_ATTRIBUTE_CREATE_BY_NID 0
+#define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ 0
+#define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT 0
+#define X509_F_X509_ATTRIBUTE_GET0_DATA 0
+#define X509_F_X509_ATTRIBUTE_SET1_DATA 0
+#define X509_F_X509_CHECK_PRIVATE_KEY 0
+#define X509_F_X509_CRL_DIFF 0
+#define X509_F_X509_CRL_METHOD_NEW 0
+#define X509_F_X509_CRL_PRINT_FP 0
+#define X509_F_X509_EXTENSION_CREATE_BY_NID 0
+#define X509_F_X509_EXTENSION_CREATE_BY_OBJ 0
+#define X509_F_X509_GET_PUBKEY_PARAMETERS 0
+#define X509_F_X509_LOAD_CERT_CRL_FILE 0
+#define X509_F_X509_LOAD_CERT_FILE 0
+#define X509_F_X509_LOAD_CRL_FILE 0
+#define X509_F_X509_LOOKUP_METH_NEW 0
+#define X509_F_X509_LOOKUP_NEW 0
+#define X509_F_X509_NAME_ADD_ENTRY 0
+#define X509_F_X509_NAME_CANON 0
+#define X509_F_X509_NAME_ENTRY_CREATE_BY_NID 0
+#define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT 0
+#define X509_F_X509_NAME_ENTRY_SET_OBJECT 0
+#define X509_F_X509_NAME_ONELINE 0
+#define X509_F_X509_NAME_PRINT 0
+#define X509_F_X509_OBJECT_NEW 0
+#define X509_F_X509_PRINT_EX_FP 0
+#define X509_F_X509_PUBKEY_DECODE 0
+#define X509_F_X509_PUBKEY_GET 0
+#define X509_F_X509_PUBKEY_GET0 0
+#define X509_F_X509_PUBKEY_SET 0
+#define X509_F_X509_REQ_CHECK_PRIVATE_KEY 0
+#define X509_F_X509_REQ_PRINT_EX 0
+#define X509_F_X509_REQ_PRINT_FP 0
+#define X509_F_X509_REQ_TO_X509 0
+#define X509_F_X509_STORE_ADD_CERT 0
+#define X509_F_X509_STORE_ADD_CRL 0
+#define X509_F_X509_STORE_ADD_LOOKUP 0
+#define X509_F_X509_STORE_CTX_GET1_ISSUER 0
+#define X509_F_X509_STORE_CTX_INIT 0
+#define X509_F_X509_STORE_CTX_NEW 0
+#define X509_F_X509_STORE_CTX_PURPOSE_INHERIT 0
+#define X509_F_X509_STORE_NEW 0
+#define X509_F_X509_TO_X509_REQ 0
+#define X509_F_X509_TRUST_ADD 0
+#define X509_F_X509_TRUST_SET 0
+#define X509_F_X509_VERIFY_CERT 0
+#define X509_F_X509_VERIFY_PARAM_NEW 0
 
 /*
  * X509V3 function codes.
  */
-#  define X509V3_F_A2I_GENERAL_NAME                        0
-#  define X509V3_F_ADDR_VALIDATE_PATH_INTERNAL             0
-#  define X509V3_F_ASIDENTIFIERCHOICE_CANONIZE             0
-#  define X509V3_F_ASIDENTIFIERCHOICE_IS_CANONICAL         0
-#  define X509V3_F_BIGNUM_TO_STRING                        0
-#  define X509V3_F_COPY_EMAIL                              0
-#  define X509V3_F_COPY_ISSUER                             0
-#  define X509V3_F_DO_DIRNAME                              0
-#  define X509V3_F_DO_EXT_I2D                              0
-#  define X509V3_F_DO_EXT_NCONF                            0
-#  define X509V3_F_GNAMES_FROM_SECTNAME                    0
-#  define X509V3_F_I2S_ASN1_ENUMERATED                     0
-#  define X509V3_F_I2S_ASN1_IA5STRING                      0
-#  define X509V3_F_I2S_ASN1_INTEGER                        0
-#  define X509V3_F_I2V_AUTHORITY_INFO_ACCESS               0
-#  define X509V3_F_LEVEL_ADD_NODE                          0
-#  define X509V3_F_NOTICE_SECTION                          0
-#  define X509V3_F_NREF_NOS                                0
-#  define X509V3_F_POLICY_CACHE_CREATE                     0
-#  define X509V3_F_POLICY_CACHE_NEW                        0
-#  define X509V3_F_POLICY_DATA_NEW                         0
-#  define X509V3_F_POLICY_SECTION                          0
-#  define X509V3_F_PROCESS_PCI_VALUE                       0
-#  define X509V3_F_R2I_CERTPOL                             0
-#  define X509V3_F_R2I_PCI                                 0
-#  define X509V3_F_S2I_ASN1_IA5STRING                      0
-#  define X509V3_F_S2I_ASN1_INTEGER                        0
-#  define X509V3_F_S2I_ASN1_OCTET_STRING                   0
-#  define X509V3_F_S2I_SKEY_ID                             0
-#  define X509V3_F_SET_DIST_POINT_NAME                     0
-#  define X509V3_F_SXNET_ADD_ID_ASC                        0
-#  define X509V3_F_SXNET_ADD_ID_INTEGER                    0
-#  define X509V3_F_SXNET_ADD_ID_ULONG                      0
-#  define X509V3_F_SXNET_GET_ID_ASC                        0
-#  define X509V3_F_SXNET_GET_ID_ULONG                      0
-#  define X509V3_F_TREE_INIT                               0
-#  define X509V3_F_V2I_ASIDENTIFIERS                       0
-#  define X509V3_F_V2I_ASN1_BIT_STRING                     0
-#  define X509V3_F_V2I_AUTHORITY_INFO_ACCESS               0
-#  define X509V3_F_V2I_AUTHORITY_KEYID                     0
-#  define X509V3_F_V2I_BASIC_CONSTRAINTS                   0
-#  define X509V3_F_V2I_CRLD                                0
-#  define X509V3_F_V2I_EXTENDED_KEY_USAGE                  0
-#  define X509V3_F_V2I_GENERAL_NAMES                       0
-#  define X509V3_F_V2I_GENERAL_NAME_EX                     0
-#  define X509V3_F_V2I_IDP                                 0
-#  define X509V3_F_V2I_IPADDRBLOCKS                        0
-#  define X509V3_F_V2I_ISSUER_ALT                          0
-#  define X509V3_F_V2I_NAME_CONSTRAINTS                    0
-#  define X509V3_F_V2I_POLICY_CONSTRAINTS                  0
-#  define X509V3_F_V2I_POLICY_MAPPINGS                     0
-#  define X509V3_F_V2I_SUBJECT_ALT                         0
-#  define X509V3_F_V2I_TLS_FEATURE                         0
-#  define X509V3_F_V3_GENERIC_EXTENSION                    0
-#  define X509V3_F_X509V3_ADD1_I2D                         0
-#  define X509V3_F_X509V3_ADD_VALUE                        0
-#  define X509V3_F_X509V3_EXT_ADD                          0
-#  define X509V3_F_X509V3_EXT_ADD_ALIAS                    0
-#  define X509V3_F_X509V3_EXT_I2D                          0
-#  define X509V3_F_X509V3_EXT_NCONF                        0
-#  define X509V3_F_X509V3_GET_SECTION                      0
-#  define X509V3_F_X509V3_GET_STRING                       0
-#  define X509V3_F_X509V3_GET_VALUE_BOOL                   0
-#  define X509V3_F_X509V3_PARSE_LIST                       0
-#  define X509V3_F_X509_PURPOSE_ADD                        0
-#  define X509V3_F_X509_PURPOSE_SET                        0
+#define X509V3_F_A2I_GENERAL_NAME 0
+#define X509V3_F_ADDR_VALIDATE_PATH_INTERNAL 0
+#define X509V3_F_ASIDENTIFIERCHOICE_CANONIZE 0
+#define X509V3_F_ASIDENTIFIERCHOICE_IS_CANONICAL 0
+#define X509V3_F_BIGNUM_TO_STRING 0
+#define X509V3_F_COPY_EMAIL 0
+#define X509V3_F_COPY_ISSUER 0
+#define X509V3_F_DO_DIRNAME 0
+#define X509V3_F_DO_EXT_I2D 0
+#define X509V3_F_DO_EXT_NCONF 0
+#define X509V3_F_GNAMES_FROM_SECTNAME 0
+#define X509V3_F_I2S_ASN1_ENUMERATED 0
+#define X509V3_F_I2S_ASN1_IA5STRING 0
+#define X509V3_F_I2S_ASN1_INTEGER 0
+#define X509V3_F_I2V_AUTHORITY_INFO_ACCESS 0
+#define X509V3_F_LEVEL_ADD_NODE 0
+#define X509V3_F_NOTICE_SECTION 0
+#define X509V3_F_NREF_NOS 0
+#define X509V3_F_POLICY_CACHE_CREATE 0
+#define X509V3_F_POLICY_CACHE_NEW 0
+#define X509V3_F_POLICY_DATA_NEW 0
+#define X509V3_F_POLICY_SECTION 0
+#define X509V3_F_PROCESS_PCI_VALUE 0
+#define X509V3_F_R2I_CERTPOL 0
+#define X509V3_F_R2I_PCI 0
+#define X509V3_F_S2I_ASN1_IA5STRING 0
+#define X509V3_F_S2I_ASN1_INTEGER 0
+#define X509V3_F_S2I_ASN1_OCTET_STRING 0
+#define X509V3_F_S2I_SKEY_ID 0
+#define X509V3_F_SET_DIST_POINT_NAME 0
+#define X509V3_F_SXNET_ADD_ID_ASC 0
+#define X509V3_F_SXNET_ADD_ID_INTEGER 0
+#define X509V3_F_SXNET_ADD_ID_ULONG 0
+#define X509V3_F_SXNET_GET_ID_ASC 0
+#define X509V3_F_SXNET_GET_ID_ULONG 0
+#define X509V3_F_TREE_INIT 0
+#define X509V3_F_V2I_ASIDENTIFIERS 0
+#define X509V3_F_V2I_ASN1_BIT_STRING 0
+#define X509V3_F_V2I_AUTHORITY_INFO_ACCESS 0
+#define X509V3_F_V2I_AUTHORITY_KEYID 0
+#define X509V3_F_V2I_BASIC_CONSTRAINTS 0
+#define X509V3_F_V2I_CRLD 0
+#define X509V3_F_V2I_EXTENDED_KEY_USAGE 0
+#define X509V3_F_V2I_GENERAL_NAMES 0
+#define X509V3_F_V2I_GENERAL_NAME_EX 0
+#define X509V3_F_V2I_IDP 0
+#define X509V3_F_V2I_IPADDRBLOCKS 0
+#define X509V3_F_V2I_ISSUER_ALT 0
+#define X509V3_F_V2I_NAME_CONSTRAINTS 0
+#define X509V3_F_V2I_POLICY_CONSTRAINTS 0
+#define X509V3_F_V2I_POLICY_MAPPINGS 0
+#define X509V3_F_V2I_SUBJECT_ALT 0
+#define X509V3_F_V2I_TLS_FEATURE 0
+#define X509V3_F_V3_GENERIC_EXTENSION 0
+#define X509V3_F_X509V3_ADD1_I2D 0
+#define X509V3_F_X509V3_ADD_VALUE 0
+#define X509V3_F_X509V3_EXT_ADD 0
+#define X509V3_F_X509V3_EXT_ADD_ALIAS 0
+#define X509V3_F_X509V3_EXT_I2D 0
+#define X509V3_F_X509V3_EXT_NCONF 0
+#define X509V3_F_X509V3_GET_SECTION 0
+#define X509V3_F_X509V3_GET_STRING 0
+#define X509V3_F_X509V3_GET_VALUE_BOOL 0
+#define X509V3_F_X509V3_PARSE_LIST 0
+#define X509V3_F_X509_PURPOSE_ADD 0
+#define X509V3_F_X509_PURPOSE_SET 0
 
 /*
  * Compatibility defines.
  */
-# define EVP_R_OPERATON_NOT_INITIALIZED    EVP_R_OPERATION_NOT_INITIALIZED
+#define EVP_R_OPERATON_NOT_INITIALIZED EVP_R_OPERATION_NOT_INITIALIZED
 
-# endif
+#endif
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ct.h b/CAPI/cpp/grpc/include/openssl/ct.h
index 06c41b7..7c3db4c 100644
--- a/CAPI/cpp/grpc/include/openssl/ct.h
+++ b/CAPI/cpp/grpc/include/openssl/ct.h
@@ -10,564 +10,542 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_CT_H
-# define OPENSSL_CT_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_CT_H
-# endif
+#define OPENSSL_CT_H
+#pragma once
 
-# include <openssl/opensslconf.h>
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_CT_H
+#endif
 
-# ifndef OPENSSL_NO_CT
-# include <openssl/types.h>
-# include <openssl/safestack.h>
-# include <openssl/x509.h>
-# include <openssl/cterr.h>
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#include <openssl/opensslconf.h>
 
+#ifndef OPENSSL_NO_CT
+#include <openssl/types.h>
+#include <openssl/safestack.h>
+#include <openssl/x509.h>
+#include <openssl/cterr.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /* Minimum RSA key size, from RFC6962 */
-# define SCT_MIN_RSA_BITS 2048
+#define SCT_MIN_RSA_BITS 2048
 
 /* All hashes are SHA256 in v1 of Certificate Transparency */
-# define CT_V1_HASHLEN SHA256_DIGEST_LENGTH
+#define CT_V1_HASHLEN SHA256_DIGEST_LENGTH
 
-SKM_DEFINE_STACK_OF_INTERNAL(SCT, SCT, SCT)
+    SKM_DEFINE_STACK_OF_INTERNAL(SCT, SCT, SCT)
 #define sk_SCT_num(sk) OPENSSL_sk_num(ossl_check_const_SCT_sk_type(sk))
-#define sk_SCT_value(sk, idx) ((SCT *)OPENSSL_sk_value(ossl_check_const_SCT_sk_type(sk), (idx)))
-#define sk_SCT_new(cmp) ((STACK_OF(SCT) *)OPENSSL_sk_new(ossl_check_SCT_compfunc_type(cmp)))
-#define sk_SCT_new_null() ((STACK_OF(SCT) *)OPENSSL_sk_new_null())
-#define sk_SCT_new_reserve(cmp, n) ((STACK_OF(SCT) *)OPENSSL_sk_new_reserve(ossl_check_SCT_compfunc_type(cmp), (n)))
+#define sk_SCT_value(sk, idx) ((SCT*)OPENSSL_sk_value(ossl_check_const_SCT_sk_type(sk), (idx)))
+#define sk_SCT_new(cmp) ((STACK_OF(SCT)*)OPENSSL_sk_new(ossl_check_SCT_compfunc_type(cmp)))
+#define sk_SCT_new_null() ((STACK_OF(SCT)*)OPENSSL_sk_new_null())
+#define sk_SCT_new_reserve(cmp, n) ((STACK_OF(SCT)*)OPENSSL_sk_new_reserve(ossl_check_SCT_compfunc_type(cmp), (n)))
 #define sk_SCT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SCT_sk_type(sk), (n))
 #define sk_SCT_free(sk) OPENSSL_sk_free(ossl_check_SCT_sk_type(sk))
 #define sk_SCT_zero(sk) OPENSSL_sk_zero(ossl_check_SCT_sk_type(sk))
-#define sk_SCT_delete(sk, i) ((SCT *)OPENSSL_sk_delete(ossl_check_SCT_sk_type(sk), (i)))
-#define sk_SCT_delete_ptr(sk, ptr) ((SCT *)OPENSSL_sk_delete_ptr(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr)))
+#define sk_SCT_delete(sk, i) ((SCT*)OPENSSL_sk_delete(ossl_check_SCT_sk_type(sk), (i)))
+#define sk_SCT_delete_ptr(sk, ptr) ((SCT*)OPENSSL_sk_delete_ptr(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr)))
 #define sk_SCT_push(sk, ptr) OPENSSL_sk_push(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
 #define sk_SCT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
-#define sk_SCT_pop(sk) ((SCT *)OPENSSL_sk_pop(ossl_check_SCT_sk_type(sk)))
-#define sk_SCT_shift(sk) ((SCT *)OPENSSL_sk_shift(ossl_check_SCT_sk_type(sk)))
-#define sk_SCT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SCT_sk_type(sk),ossl_check_SCT_freefunc_type(freefunc))
+#define sk_SCT_pop(sk) ((SCT*)OPENSSL_sk_pop(ossl_check_SCT_sk_type(sk)))
+#define sk_SCT_shift(sk) ((SCT*)OPENSSL_sk_shift(ossl_check_SCT_sk_type(sk)))
+#define sk_SCT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SCT_sk_type(sk), ossl_check_SCT_freefunc_type(freefunc))
 #define sk_SCT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr), (idx))
-#define sk_SCT_set(sk, idx, ptr) ((SCT *)OPENSSL_sk_set(ossl_check_SCT_sk_type(sk), (idx), ossl_check_SCT_type(ptr)))
+#define sk_SCT_set(sk, idx, ptr) ((SCT*)OPENSSL_sk_set(ossl_check_SCT_sk_type(sk), (idx), ossl_check_SCT_type(ptr)))
 #define sk_SCT_find(sk, ptr) OPENSSL_sk_find(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
 #define sk_SCT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr))
 #define sk_SCT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SCT_sk_type(sk), ossl_check_SCT_type(ptr), pnum)
 #define sk_SCT_sort(sk) OPENSSL_sk_sort(ossl_check_SCT_sk_type(sk))
 #define sk_SCT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SCT_sk_type(sk))
-#define sk_SCT_dup(sk) ((STACK_OF(SCT) *)OPENSSL_sk_dup(ossl_check_const_SCT_sk_type(sk)))
-#define sk_SCT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SCT) *)OPENSSL_sk_deep_copy(ossl_check_const_SCT_sk_type(sk), ossl_check_SCT_copyfunc_type(copyfunc), ossl_check_SCT_freefunc_type(freefunc)))
+#define sk_SCT_dup(sk) ((STACK_OF(SCT)*)OPENSSL_sk_dup(ossl_check_const_SCT_sk_type(sk)))
+#define sk_SCT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SCT)*)OPENSSL_sk_deep_copy(ossl_check_const_SCT_sk_type(sk), ossl_check_SCT_copyfunc_type(copyfunc), ossl_check_SCT_freefunc_type(freefunc)))
 #define sk_SCT_set_cmp_func(sk, cmp) ((sk_SCT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SCT_sk_type(sk), ossl_check_SCT_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(CTLOG, CTLOG, CTLOG)
+    SKM_DEFINE_STACK_OF_INTERNAL(CTLOG, CTLOG, CTLOG)
 #define sk_CTLOG_num(sk) OPENSSL_sk_num(ossl_check_const_CTLOG_sk_type(sk))
-#define sk_CTLOG_value(sk, idx) ((CTLOG *)OPENSSL_sk_value(ossl_check_const_CTLOG_sk_type(sk), (idx)))
-#define sk_CTLOG_new(cmp) ((STACK_OF(CTLOG) *)OPENSSL_sk_new(ossl_check_CTLOG_compfunc_type(cmp)))
-#define sk_CTLOG_new_null() ((STACK_OF(CTLOG) *)OPENSSL_sk_new_null())
-#define sk_CTLOG_new_reserve(cmp, n) ((STACK_OF(CTLOG) *)OPENSSL_sk_new_reserve(ossl_check_CTLOG_compfunc_type(cmp), (n)))
+#define sk_CTLOG_value(sk, idx) ((CTLOG*)OPENSSL_sk_value(ossl_check_const_CTLOG_sk_type(sk), (idx)))
+#define sk_CTLOG_new(cmp) ((STACK_OF(CTLOG)*)OPENSSL_sk_new(ossl_check_CTLOG_compfunc_type(cmp)))
+#define sk_CTLOG_new_null() ((STACK_OF(CTLOG)*)OPENSSL_sk_new_null())
+#define sk_CTLOG_new_reserve(cmp, n) ((STACK_OF(CTLOG)*)OPENSSL_sk_new_reserve(ossl_check_CTLOG_compfunc_type(cmp), (n)))
 #define sk_CTLOG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_CTLOG_sk_type(sk), (n))
 #define sk_CTLOG_free(sk) OPENSSL_sk_free(ossl_check_CTLOG_sk_type(sk))
 #define sk_CTLOG_zero(sk) OPENSSL_sk_zero(ossl_check_CTLOG_sk_type(sk))
-#define sk_CTLOG_delete(sk, i) ((CTLOG *)OPENSSL_sk_delete(ossl_check_CTLOG_sk_type(sk), (i)))
-#define sk_CTLOG_delete_ptr(sk, ptr) ((CTLOG *)OPENSSL_sk_delete_ptr(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr)))
+#define sk_CTLOG_delete(sk, i) ((CTLOG*)OPENSSL_sk_delete(ossl_check_CTLOG_sk_type(sk), (i)))
+#define sk_CTLOG_delete_ptr(sk, ptr) ((CTLOG*)OPENSSL_sk_delete_ptr(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr)))
 #define sk_CTLOG_push(sk, ptr) OPENSSL_sk_push(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
 #define sk_CTLOG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
-#define sk_CTLOG_pop(sk) ((CTLOG *)OPENSSL_sk_pop(ossl_check_CTLOG_sk_type(sk)))
-#define sk_CTLOG_shift(sk) ((CTLOG *)OPENSSL_sk_shift(ossl_check_CTLOG_sk_type(sk)))
-#define sk_CTLOG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CTLOG_sk_type(sk),ossl_check_CTLOG_freefunc_type(freefunc))
+#define sk_CTLOG_pop(sk) ((CTLOG*)OPENSSL_sk_pop(ossl_check_CTLOG_sk_type(sk)))
+#define sk_CTLOG_shift(sk) ((CTLOG*)OPENSSL_sk_shift(ossl_check_CTLOG_sk_type(sk)))
+#define sk_CTLOG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_freefunc_type(freefunc))
 #define sk_CTLOG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr), (idx))
-#define sk_CTLOG_set(sk, idx, ptr) ((CTLOG *)OPENSSL_sk_set(ossl_check_CTLOG_sk_type(sk), (idx), ossl_check_CTLOG_type(ptr)))
+#define sk_CTLOG_set(sk, idx, ptr) ((CTLOG*)OPENSSL_sk_set(ossl_check_CTLOG_sk_type(sk), (idx), ossl_check_CTLOG_type(ptr)))
 #define sk_CTLOG_find(sk, ptr) OPENSSL_sk_find(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
 #define sk_CTLOG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr))
 #define sk_CTLOG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_type(ptr), pnum)
 #define sk_CTLOG_sort(sk) OPENSSL_sk_sort(ossl_check_CTLOG_sk_type(sk))
 #define sk_CTLOG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_CTLOG_sk_type(sk))
-#define sk_CTLOG_dup(sk) ((STACK_OF(CTLOG) *)OPENSSL_sk_dup(ossl_check_const_CTLOG_sk_type(sk)))
-#define sk_CTLOG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CTLOG) *)OPENSSL_sk_deep_copy(ossl_check_const_CTLOG_sk_type(sk), ossl_check_CTLOG_copyfunc_type(copyfunc), ossl_check_CTLOG_freefunc_type(freefunc)))
+#define sk_CTLOG_dup(sk) ((STACK_OF(CTLOG)*)OPENSSL_sk_dup(ossl_check_const_CTLOG_sk_type(sk)))
+#define sk_CTLOG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(CTLOG)*)OPENSSL_sk_deep_copy(ossl_check_const_CTLOG_sk_type(sk), ossl_check_CTLOG_copyfunc_type(copyfunc), ossl_check_CTLOG_freefunc_type(freefunc)))
 #define sk_CTLOG_set_cmp_func(sk, cmp) ((sk_CTLOG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_CTLOG_sk_type(sk), ossl_check_CTLOG_compfunc_type(cmp)))
 
-
-
-typedef enum {
-    CT_LOG_ENTRY_TYPE_NOT_SET = -1,
-    CT_LOG_ENTRY_TYPE_X509 = 0,
-    CT_LOG_ENTRY_TYPE_PRECERT = 1
-} ct_log_entry_type_t;
-
-typedef enum {
-    SCT_VERSION_NOT_SET = -1,
-    SCT_VERSION_V1 = 0
-} sct_version_t;
-
-typedef enum {
-    SCT_SOURCE_UNKNOWN,
-    SCT_SOURCE_TLS_EXTENSION,
-    SCT_SOURCE_X509V3_EXTENSION,
-    SCT_SOURCE_OCSP_STAPLED_RESPONSE
-} sct_source_t;
-
-typedef enum {
-    SCT_VALIDATION_STATUS_NOT_SET,
-    SCT_VALIDATION_STATUS_UNKNOWN_LOG,
-    SCT_VALIDATION_STATUS_VALID,
-    SCT_VALIDATION_STATUS_INVALID,
-    SCT_VALIDATION_STATUS_UNVERIFIED,
-    SCT_VALIDATION_STATUS_UNKNOWN_VERSION
-} sct_validation_status_t;
-
-/******************************************
- * CT policy evaluation context functions *
- ******************************************/
-
-/*
- * Creates a new, empty policy evaluation context associated with the given
- * library context and property query string.
- * The caller is responsible for calling CT_POLICY_EVAL_CTX_free when finished
- * with the CT_POLICY_EVAL_CTX.
- */
-CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new_ex(OSSL_LIB_CTX *libctx,
-                                              const char *propq);
-                                                       
-/*
- * The same as CT_POLICY_EVAL_CTX_new_ex() but the default library
- * context and property query string is used.
- */
-CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new(void);
-
-/* Deletes a policy evaluation context and anything it owns. */
-void CT_POLICY_EVAL_CTX_free(CT_POLICY_EVAL_CTX *ctx);
-
-/* Gets the peer certificate that the SCTs are for */
-X509* CT_POLICY_EVAL_CTX_get0_cert(const CT_POLICY_EVAL_CTX *ctx);
-
-/*
- * Sets the certificate associated with the received SCTs.
- * Increments the reference count of cert.
- * Returns 1 on success, 0 otherwise.
- */
-int CT_POLICY_EVAL_CTX_set1_cert(CT_POLICY_EVAL_CTX *ctx, X509 *cert);
-
-/* Gets the issuer of the aforementioned certificate */
-X509* CT_POLICY_EVAL_CTX_get0_issuer(const CT_POLICY_EVAL_CTX *ctx);
-
-/*
- * Sets the issuer of the certificate associated with the received SCTs.
- * Increments the reference count of issuer.
- * Returns 1 on success, 0 otherwise.
- */
-int CT_POLICY_EVAL_CTX_set1_issuer(CT_POLICY_EVAL_CTX *ctx, X509 *issuer);
-
-/* Gets the CT logs that are trusted sources of SCTs */
-const CTLOG_STORE *CT_POLICY_EVAL_CTX_get0_log_store(const CT_POLICY_EVAL_CTX *ctx);
-
-/* Sets the log store that is in use. It must outlive the CT_POLICY_EVAL_CTX. */
-void CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(CT_POLICY_EVAL_CTX *ctx,
-                                               CTLOG_STORE *log_store);
-
-/*
- * Gets the time, in milliseconds since the Unix epoch, that will be used as the
- * current time when checking whether an SCT was issued in the future.
- * Such SCTs will fail validation, as required by RFC6962.
- */
-uint64_t CT_POLICY_EVAL_CTX_get_time(const CT_POLICY_EVAL_CTX *ctx);
-
-/*
- * Sets the time to evaluate SCTs against, in milliseconds since the Unix epoch.
- * If an SCT's timestamp is after this time, it will be interpreted as having
- * been issued in the future. RFC6962 states that "TLS clients MUST reject SCTs
- * whose timestamp is in the future", so an SCT will not validate in this case.
- */
-void CT_POLICY_EVAL_CTX_set_time(CT_POLICY_EVAL_CTX *ctx, uint64_t time_in_ms);
-
-/*****************
- * SCT functions *
- *****************/
-
-/*
- * Creates a new, blank SCT.
- * The caller is responsible for calling SCT_free when finished with the SCT.
- */
-SCT *SCT_new(void);
-
-/*
- * Creates a new SCT from some base64-encoded strings.
- * The caller is responsible for calling SCT_free when finished with the SCT.
- */
-SCT *SCT_new_from_base64(unsigned char version,
-                         const char *logid_base64,
-                         ct_log_entry_type_t entry_type,
-                         uint64_t timestamp,
-                         const char *extensions_base64,
-                         const char *signature_base64);
-
-/*
- * Frees the SCT and the underlying data structures.
- */
-void SCT_free(SCT *sct);
-
-/*
- * Free a stack of SCTs, and the underlying SCTs themselves.
- * Intended to be compatible with X509V3_EXT_FREE.
- */
-void SCT_LIST_free(STACK_OF(SCT) *a);
-
-/*
- * Returns the version of the SCT.
- */
-sct_version_t SCT_get_version(const SCT *sct);
-
-/*
- * Set the version of an SCT.
- * Returns 1 on success, 0 if the version is unrecognized.
- */
-__owur int SCT_set_version(SCT *sct, sct_version_t version);
-
-/*
- * Returns the log entry type of the SCT.
- */
-ct_log_entry_type_t SCT_get_log_entry_type(const SCT *sct);
-
-/*
- * Set the log entry type of an SCT.
- * Returns 1 on success, 0 otherwise.
- */
-__owur int SCT_set_log_entry_type(SCT *sct, ct_log_entry_type_t entry_type);
-
-/*
- * Gets the ID of the log that an SCT came from.
- * Ownership of the log ID remains with the SCT.
- * Returns the length of the log ID.
- */
-size_t SCT_get0_log_id(const SCT *sct, unsigned char **log_id);
-
-/*
- * Set the log ID of an SCT to point directly to the *log_id specified.
- * The SCT takes ownership of the specified pointer.
- * Returns 1 on success, 0 otherwise.
- */
-__owur int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len);
-
-/*
- * Set the log ID of an SCT.
- * This makes a copy of the log_id.
- * Returns 1 on success, 0 otherwise.
- */
-__owur int SCT_set1_log_id(SCT *sct, const unsigned char *log_id,
-                           size_t log_id_len);
-
-/*
- * Returns the timestamp for the SCT (epoch time in milliseconds).
- */
-uint64_t SCT_get_timestamp(const SCT *sct);
-
-/*
- * Set the timestamp of an SCT (epoch time in milliseconds).
- */
-void SCT_set_timestamp(SCT *sct, uint64_t timestamp);
-
-/*
- * Return the NID for the signature used by the SCT.
- * For CT v1, this will be either NID_sha256WithRSAEncryption or
- * NID_ecdsa_with_SHA256 (or NID_undef if incorrect/unset).
- */
-int SCT_get_signature_nid(const SCT *sct);
-
-/*
- * Set the signature type of an SCT
- * For CT v1, this should be either NID_sha256WithRSAEncryption or
- * NID_ecdsa_with_SHA256.
- * Returns 1 on success, 0 otherwise.
- */
-__owur int SCT_set_signature_nid(SCT *sct, int nid);
-
-/*
- * Set *ext to point to the extension data for the SCT. ext must not be NULL.
- * The SCT retains ownership of this pointer.
- * Returns length of the data pointed to.
- */
-size_t SCT_get0_extensions(const SCT *sct, unsigned char **ext);
-
-/*
- * Set the extensions of an SCT to point directly to the *ext specified.
- * The SCT takes ownership of the specified pointer.
- */
-void SCT_set0_extensions(SCT *sct, unsigned char *ext, size_t ext_len);
-
-/*
- * Set the extensions of an SCT.
- * This takes a copy of the ext.
- * Returns 1 on success, 0 otherwise.
- */
-__owur int SCT_set1_extensions(SCT *sct, const unsigned char *ext,
-                               size_t ext_len);
-
-/*
- * Set *sig to point to the signature for the SCT. sig must not be NULL.
- * The SCT retains ownership of this pointer.
- * Returns length of the data pointed to.
- */
-size_t SCT_get0_signature(const SCT *sct, unsigned char **sig);
-
-/*
- * Set the signature of an SCT to point directly to the *sig specified.
- * The SCT takes ownership of the specified pointer.
- */
-void SCT_set0_signature(SCT *sct, unsigned char *sig, size_t sig_len);
-
-/*
- * Set the signature of an SCT to be a copy of the *sig specified.
- * Returns 1 on success, 0 otherwise.
- */
-__owur int SCT_set1_signature(SCT *sct, const unsigned char *sig,
-                              size_t sig_len);
-
-/*
- * The origin of this SCT, e.g. TLS extension, OCSP response, etc.
- */
-sct_source_t SCT_get_source(const SCT *sct);
-
-/*
- * Set the origin of this SCT, e.g. TLS extension, OCSP response, etc.
- * Returns 1 on success, 0 otherwise.
- */
-__owur int SCT_set_source(SCT *sct, sct_source_t source);
-
-/*
- * Returns a text string describing the validation status of |sct|.
- */
-const char *SCT_validation_status_string(const SCT *sct);
-
-/*
- * Pretty-prints an |sct| to |out|.
- * It will be indented by the number of spaces specified by |indent|.
- * If |logs| is not NULL, it will be used to lookup the CT log that the SCT came
- * from, so that the log name can be printed.
- */
-void SCT_print(const SCT *sct, BIO *out, int indent, const CTLOG_STORE *logs);
-
-/*
- * Pretty-prints an |sct_list| to |out|.
- * It will be indented by the number of spaces specified by |indent|.
- * SCTs will be delimited by |separator|.
- * If |logs| is not NULL, it will be used to lookup the CT log that each SCT
- * came from, so that the log names can be printed.
- */
-void SCT_LIST_print(const STACK_OF(SCT) *sct_list, BIO *out, int indent,
-                    const char *separator, const CTLOG_STORE *logs);
-
-/*
- * Gets the last result of validating this SCT.
- * If it has not been validated yet, returns SCT_VALIDATION_STATUS_NOT_SET.
- */
-sct_validation_status_t SCT_get_validation_status(const SCT *sct);
-
-/*
- * Validates the given SCT with the provided context.
- * Sets the "validation_status" field of the SCT.
- * Returns 1 if the SCT is valid and the signature verifies.
- * Returns 0 if the SCT is invalid or could not be verified.
- * Returns -1 if an error occurs.
- */
-__owur int SCT_validate(SCT *sct, const CT_POLICY_EVAL_CTX *ctx);
-
-/*
- * Validates the given list of SCTs with the provided context.
- * Sets the "validation_status" field of each SCT.
- * Returns 1 if there are no invalid SCTs and all signatures verify.
- * Returns 0 if at least one SCT is invalid or could not be verified.
- * Returns a negative integer if an error occurs.
- */
-__owur int SCT_LIST_validate(const STACK_OF(SCT) *scts,
-                             CT_POLICY_EVAL_CTX *ctx);
-
-
-/*********************************
- * SCT parsing and serialization *
- *********************************/
-
-/*
- * Serialize (to TLS format) a stack of SCTs and return the length.
- * "a" must not be NULL.
- * If "pp" is NULL, just return the length of what would have been serialized.
- * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer
- * for data that caller is responsible for freeing (only if function returns
- * successfully).
- * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring
- * that "*pp" is large enough to accept all of the serialized data.
- * Returns < 0 on error, >= 0 indicating bytes written (or would have been)
- * on success.
- */
-__owur int i2o_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp);
-
-/*
- * Convert TLS format SCT list to a stack of SCTs.
- * If "a" or "*a" is NULL, a new stack will be created that the caller is
- * responsible for freeing (by calling SCT_LIST_free).
- * "**pp" and "*pp" must not be NULL.
- * Upon success, "*pp" will point to after the last bytes read, and a stack
- * will be returned.
- * Upon failure, a NULL pointer will be returned, and the position of "*pp" is
- * not defined.
- */
-STACK_OF(SCT) *o2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
-                            size_t len);
-
-/*
- * Serialize (to DER format) a stack of SCTs and return the length.
- * "a" must not be NULL.
- * If "pp" is NULL, just returns the length of what would have been serialized.
- * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer
- * for data that caller is responsible for freeing (only if function returns
- * successfully).
- * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring
- * that "*pp" is large enough to accept all of the serialized data.
- * Returns < 0 on error, >= 0 indicating bytes written (or would have been)
- * on success.
- */
-__owur int i2d_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp);
-
-/*
- * Parses an SCT list in DER format and returns it.
- * If "a" or "*a" is NULL, a new stack will be created that the caller is
- * responsible for freeing (by calling SCT_LIST_free).
- * "**pp" and "*pp" must not be NULL.
- * Upon success, "*pp" will point to after the last bytes read, and a stack
- * will be returned.
- * Upon failure, a NULL pointer will be returned, and the position of "*pp" is
- * not defined.
- */
-STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
-                            long len);
-
-/*
- * Serialize (to TLS format) an |sct| and write it to |out|.
- * If |out| is null, no SCT will be output but the length will still be returned.
- * If |out| points to a null pointer, a string will be allocated to hold the
- * TLS-format SCT. It is the responsibility of the caller to free it.
- * If |out| points to an allocated string, the TLS-format SCT will be written
- * to it.
- * The length of the SCT in TLS format will be returned.
- */
-__owur int i2o_SCT(const SCT *sct, unsigned char **out);
-
-/*
- * Parses an SCT in TLS format and returns it.
- * If |psct| is not null, it will end up pointing to the parsed SCT. If it
- * already points to a non-null pointer, the pointer will be free'd.
- * |in| should be a pointer to a string containing the TLS-format SCT.
- * |in| will be advanced to the end of the SCT if parsing succeeds.
- * |len| should be the length of the SCT in |in|.
- * Returns NULL if an error occurs.
- * If the SCT is an unsupported version, only the SCT's 'sct' and 'sct_len'
- * fields will be populated (with |in| and |len| respectively).
- */
-SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len);
-
-/********************
- * CT log functions *
- ********************/
-
-/*
- * Creates a new CT log instance with the given |public_key| and |name| and
- * associates it with the give library context |libctx| and property query
- * string |propq|.
- * Takes ownership of |public_key| but copies |name|.
- * Returns NULL if malloc fails or if |public_key| cannot be converted to DER.
- * Should be deleted by the caller using CTLOG_free when no longer needed.
- */
-CTLOG *CTLOG_new_ex(EVP_PKEY *public_key, const char *name, OSSL_LIB_CTX *libctx,
-                    const char *propq);
-
-/*
- * The same as CTLOG_new_ex except that the default library context and
- * property query string are used.
- */
-CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name);
-
-/*
- * Creates a new CTLOG instance with the base64-encoded SubjectPublicKeyInfo DER
- * in |pkey_base64| and associated with the given library context |libctx| and
- * property query string |propq|. The |name| is a string to help users identify
- * this log.
- * Returns 1 on success, 0 on failure.
- * Should be deleted by the caller using CTLOG_free when no longer needed.
- */
-int CTLOG_new_from_base64_ex(CTLOG **ct_log, const char *pkey_base64,
-                             const char *name, OSSL_LIB_CTX *libctx,
-                             const char *propq);
-
-/*
- * The same as CTLOG_new_from_base64_ex() except that the default
- * library context and property query string are used.
- * Returns 1 on success, 0 on failure.
- */
-int CTLOG_new_from_base64(CTLOG ** ct_log,
-                          const char *pkey_base64, const char *name);
-
-/*
- * Deletes a CT log instance and its fields.
- */
-void CTLOG_free(CTLOG *log);
-
-/* Gets the name of the CT log */
-const char *CTLOG_get0_name(const CTLOG *log);
-/* Gets the ID of the CT log */
-void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id,
-                       size_t *log_id_len);
-/* Gets the public key of the CT log */
-EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log);
-
-/**************************
- * CT log store functions *
- **************************/
-
-/*
- * Creates a new CT log store and associates it with the given libctx and
- * property query string.
- * Should be deleted by the caller using CTLOG_STORE_free when no longer needed.
- */
-CTLOG_STORE *CTLOG_STORE_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
-
-/*
- * Same as CTLOG_STORE_new_ex except that the default libctx and
- * property query string are used.
- * Should be deleted by the caller using CTLOG_STORE_free when no longer needed.
- */
-CTLOG_STORE *CTLOG_STORE_new(void);
-
-/*
- * Deletes a CT log store and all of the CT log instances held within.
- */
-void CTLOG_STORE_free(CTLOG_STORE *store);
-
-/*
- * Finds a CT log in the store based on its log ID.
- * Returns the CT log, or NULL if no match is found.
- */
-const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store,
-                                        const uint8_t *log_id,
-                                        size_t log_id_len);
-
-/*
- * Loads a CT log list into a |store| from a |file|.
- * Returns 1 if loading is successful, or 0 otherwise.
- */
-__owur int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file);
-
-/*
- * Loads the default CT log list into a |store|.
- * Returns 1 if loading is successful, or 0 otherwise.
- */
-__owur int CTLOG_STORE_load_default_file(CTLOG_STORE *store);
-
-#  ifdef  __cplusplus
+    typedef enum
+    {
+        CT_LOG_ENTRY_TYPE_NOT_SET = -1,
+        CT_LOG_ENTRY_TYPE_X509 = 0,
+        CT_LOG_ENTRY_TYPE_PRECERT = 1
+    } ct_log_entry_type_t;
+
+    typedef enum
+    {
+        SCT_VERSION_NOT_SET = -1,
+        SCT_VERSION_V1 = 0
+    } sct_version_t;
+
+    typedef enum
+    {
+        SCT_SOURCE_UNKNOWN,
+        SCT_SOURCE_TLS_EXTENSION,
+        SCT_SOURCE_X509V3_EXTENSION,
+        SCT_SOURCE_OCSP_STAPLED_RESPONSE
+    } sct_source_t;
+
+    typedef enum
+    {
+        SCT_VALIDATION_STATUS_NOT_SET,
+        SCT_VALIDATION_STATUS_UNKNOWN_LOG,
+        SCT_VALIDATION_STATUS_VALID,
+        SCT_VALIDATION_STATUS_INVALID,
+        SCT_VALIDATION_STATUS_UNVERIFIED,
+        SCT_VALIDATION_STATUS_UNKNOWN_VERSION
+    } sct_validation_status_t;
+
+    /******************************************
+     * CT policy evaluation context functions *
+     ******************************************/
+
+    /*
+     * Creates a new, empty policy evaluation context associated with the given
+     * library context and property query string.
+     * The caller is responsible for calling CT_POLICY_EVAL_CTX_free when finished
+     * with the CT_POLICY_EVAL_CTX.
+     */
+    CT_POLICY_EVAL_CTX* CT_POLICY_EVAL_CTX_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+
+    /*
+     * The same as CT_POLICY_EVAL_CTX_new_ex() but the default library
+     * context and property query string is used.
+     */
+    CT_POLICY_EVAL_CTX* CT_POLICY_EVAL_CTX_new(void);
+
+    /* Deletes a policy evaluation context and anything it owns. */
+    void CT_POLICY_EVAL_CTX_free(CT_POLICY_EVAL_CTX* ctx);
+
+    /* Gets the peer certificate that the SCTs are for */
+    X509* CT_POLICY_EVAL_CTX_get0_cert(const CT_POLICY_EVAL_CTX* ctx);
+
+    /*
+     * Sets the certificate associated with the received SCTs.
+     * Increments the reference count of cert.
+     * Returns 1 on success, 0 otherwise.
+     */
+    int CT_POLICY_EVAL_CTX_set1_cert(CT_POLICY_EVAL_CTX* ctx, X509* cert);
+
+    /* Gets the issuer of the aforementioned certificate */
+    X509* CT_POLICY_EVAL_CTX_get0_issuer(const CT_POLICY_EVAL_CTX* ctx);
+
+    /*
+     * Sets the issuer of the certificate associated with the received SCTs.
+     * Increments the reference count of issuer.
+     * Returns 1 on success, 0 otherwise.
+     */
+    int CT_POLICY_EVAL_CTX_set1_issuer(CT_POLICY_EVAL_CTX* ctx, X509* issuer);
+
+    /* Gets the CT logs that are trusted sources of SCTs */
+    const CTLOG_STORE* CT_POLICY_EVAL_CTX_get0_log_store(const CT_POLICY_EVAL_CTX* ctx);
+
+    /* Sets the log store that is in use. It must outlive the CT_POLICY_EVAL_CTX. */
+    void CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(CT_POLICY_EVAL_CTX* ctx, CTLOG_STORE* log_store);
+
+    /*
+     * Gets the time, in milliseconds since the Unix epoch, that will be used as the
+     * current time when checking whether an SCT was issued in the future.
+     * Such SCTs will fail validation, as required by RFC6962.
+     */
+    uint64_t CT_POLICY_EVAL_CTX_get_time(const CT_POLICY_EVAL_CTX* ctx);
+
+    /*
+     * Sets the time to evaluate SCTs against, in milliseconds since the Unix epoch.
+     * If an SCT's timestamp is after this time, it will be interpreted as having
+     * been issued in the future. RFC6962 states that "TLS clients MUST reject SCTs
+     * whose timestamp is in the future", so an SCT will not validate in this case.
+     */
+    void CT_POLICY_EVAL_CTX_set_time(CT_POLICY_EVAL_CTX* ctx, uint64_t time_in_ms);
+
+    /*****************
+     * SCT functions *
+     *****************/
+
+    /*
+     * Creates a new, blank SCT.
+     * The caller is responsible for calling SCT_free when finished with the SCT.
+     */
+    SCT* SCT_new(void);
+
+    /*
+     * Creates a new SCT from some base64-encoded strings.
+     * The caller is responsible for calling SCT_free when finished with the SCT.
+     */
+    SCT* SCT_new_from_base64(unsigned char version, const char* logid_base64, ct_log_entry_type_t entry_type, uint64_t timestamp, const char* extensions_base64, const char* signature_base64);
+
+    /*
+     * Frees the SCT and the underlying data structures.
+     */
+    void SCT_free(SCT* sct);
+
+    /*
+     * Free a stack of SCTs, and the underlying SCTs themselves.
+     * Intended to be compatible with X509V3_EXT_FREE.
+     */
+    void SCT_LIST_free(STACK_OF(SCT) * a);
+
+    /*
+     * Returns the version of the SCT.
+     */
+    sct_version_t SCT_get_version(const SCT* sct);
+
+    /*
+     * Set the version of an SCT.
+     * Returns 1 on success, 0 if the version is unrecognized.
+     */
+    __owur int SCT_set_version(SCT* sct, sct_version_t version);
+
+    /*
+     * Returns the log entry type of the SCT.
+     */
+    ct_log_entry_type_t SCT_get_log_entry_type(const SCT* sct);
+
+    /*
+     * Set the log entry type of an SCT.
+     * Returns 1 on success, 0 otherwise.
+     */
+    __owur int SCT_set_log_entry_type(SCT* sct, ct_log_entry_type_t entry_type);
+
+    /*
+     * Gets the ID of the log that an SCT came from.
+     * Ownership of the log ID remains with the SCT.
+     * Returns the length of the log ID.
+     */
+    size_t SCT_get0_log_id(const SCT* sct, unsigned char** log_id);
+
+    /*
+     * Set the log ID of an SCT to point directly to the *log_id specified.
+     * The SCT takes ownership of the specified pointer.
+     * Returns 1 on success, 0 otherwise.
+     */
+    __owur int SCT_set0_log_id(SCT* sct, unsigned char* log_id, size_t log_id_len);
+
+    /*
+     * Set the log ID of an SCT.
+     * This makes a copy of the log_id.
+     * Returns 1 on success, 0 otherwise.
+     */
+    __owur int SCT_set1_log_id(SCT* sct, const unsigned char* log_id, size_t log_id_len);
+
+    /*
+     * Returns the timestamp for the SCT (epoch time in milliseconds).
+     */
+    uint64_t SCT_get_timestamp(const SCT* sct);
+
+    /*
+     * Set the timestamp of an SCT (epoch time in milliseconds).
+     */
+    void SCT_set_timestamp(SCT* sct, uint64_t timestamp);
+
+    /*
+     * Return the NID for the signature used by the SCT.
+     * For CT v1, this will be either NID_sha256WithRSAEncryption or
+     * NID_ecdsa_with_SHA256 (or NID_undef if incorrect/unset).
+     */
+    int SCT_get_signature_nid(const SCT* sct);
+
+    /*
+     * Set the signature type of an SCT
+     * For CT v1, this should be either NID_sha256WithRSAEncryption or
+     * NID_ecdsa_with_SHA256.
+     * Returns 1 on success, 0 otherwise.
+     */
+    __owur int SCT_set_signature_nid(SCT* sct, int nid);
+
+    /*
+     * Set *ext to point to the extension data for the SCT. ext must not be NULL.
+     * The SCT retains ownership of this pointer.
+     * Returns length of the data pointed to.
+     */
+    size_t SCT_get0_extensions(const SCT* sct, unsigned char** ext);
+
+    /*
+     * Set the extensions of an SCT to point directly to the *ext specified.
+     * The SCT takes ownership of the specified pointer.
+     */
+    void SCT_set0_extensions(SCT* sct, unsigned char* ext, size_t ext_len);
+
+    /*
+     * Set the extensions of an SCT.
+     * This takes a copy of the ext.
+     * Returns 1 on success, 0 otherwise.
+     */
+    __owur int SCT_set1_extensions(SCT* sct, const unsigned char* ext, size_t ext_len);
+
+    /*
+     * Set *sig to point to the signature for the SCT. sig must not be NULL.
+     * The SCT retains ownership of this pointer.
+     * Returns length of the data pointed to.
+     */
+    size_t SCT_get0_signature(const SCT* sct, unsigned char** sig);
+
+    /*
+     * Set the signature of an SCT to point directly to the *sig specified.
+     * The SCT takes ownership of the specified pointer.
+     */
+    void SCT_set0_signature(SCT* sct, unsigned char* sig, size_t sig_len);
+
+    /*
+     * Set the signature of an SCT to be a copy of the *sig specified.
+     * Returns 1 on success, 0 otherwise.
+     */
+    __owur int SCT_set1_signature(SCT* sct, const unsigned char* sig, size_t sig_len);
+
+    /*
+     * The origin of this SCT, e.g. TLS extension, OCSP response, etc.
+     */
+    sct_source_t SCT_get_source(const SCT* sct);
+
+    /*
+     * Set the origin of this SCT, e.g. TLS extension, OCSP response, etc.
+     * Returns 1 on success, 0 otherwise.
+     */
+    __owur int SCT_set_source(SCT* sct, sct_source_t source);
+
+    /*
+     * Returns a text string describing the validation status of |sct|.
+     */
+    const char* SCT_validation_status_string(const SCT* sct);
+
+    /*
+     * Pretty-prints an |sct| to |out|.
+     * It will be indented by the number of spaces specified by |indent|.
+     * If |logs| is not NULL, it will be used to lookup the CT log that the SCT came
+     * from, so that the log name can be printed.
+     */
+    void SCT_print(const SCT* sct, BIO* out, int indent, const CTLOG_STORE* logs);
+
+    /*
+     * Pretty-prints an |sct_list| to |out|.
+     * It will be indented by the number of spaces specified by |indent|.
+     * SCTs will be delimited by |separator|.
+     * If |logs| is not NULL, it will be used to lookup the CT log that each SCT
+     * came from, so that the log names can be printed.
+     */
+    void SCT_LIST_print(const STACK_OF(SCT) * sct_list, BIO* out, int indent, const char* separator, const CTLOG_STORE* logs);
+
+    /*
+     * Gets the last result of validating this SCT.
+     * If it has not been validated yet, returns SCT_VALIDATION_STATUS_NOT_SET.
+     */
+    sct_validation_status_t SCT_get_validation_status(const SCT* sct);
+
+    /*
+     * Validates the given SCT with the provided context.
+     * Sets the "validation_status" field of the SCT.
+     * Returns 1 if the SCT is valid and the signature verifies.
+     * Returns 0 if the SCT is invalid or could not be verified.
+     * Returns -1 if an error occurs.
+     */
+    __owur int SCT_validate(SCT* sct, const CT_POLICY_EVAL_CTX* ctx);
+
+    /*
+     * Validates the given list of SCTs with the provided context.
+     * Sets the "validation_status" field of each SCT.
+     * Returns 1 if there are no invalid SCTs and all signatures verify.
+     * Returns 0 if at least one SCT is invalid or could not be verified.
+     * Returns a negative integer if an error occurs.
+     */
+    __owur int SCT_LIST_validate(const STACK_OF(SCT) * scts, CT_POLICY_EVAL_CTX* ctx);
+
+    /*********************************
+     * SCT parsing and serialization *
+     *********************************/
+
+    /*
+     * Serialize (to TLS format) a stack of SCTs and return the length.
+     * "a" must not be NULL.
+     * If "pp" is NULL, just return the length of what would have been serialized.
+     * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer
+     * for data that caller is responsible for freeing (only if function returns
+     * successfully).
+     * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring
+     * that "*pp" is large enough to accept all of the serialized data.
+     * Returns < 0 on error, >= 0 indicating bytes written (or would have been)
+     * on success.
+     */
+    __owur int i2o_SCT_LIST(const STACK_OF(SCT) * a, unsigned char** pp);
+
+    /*
+     * Convert TLS format SCT list to a stack of SCTs.
+     * If "a" or "*a" is NULL, a new stack will be created that the caller is
+     * responsible for freeing (by calling SCT_LIST_free).
+     * "**pp" and "*pp" must not be NULL.
+     * Upon success, "*pp" will point to after the last bytes read, and a stack
+     * will be returned.
+     * Upon failure, a NULL pointer will be returned, and the position of "*pp" is
+     * not defined.
+     */
+    STACK_OF(SCT) * o2i_SCT_LIST(STACK_OF(SCT) * *a, const unsigned char** pp, size_t len);
+
+    /*
+     * Serialize (to DER format) a stack of SCTs and return the length.
+     * "a" must not be NULL.
+     * If "pp" is NULL, just returns the length of what would have been serialized.
+     * If "pp" is not NULL and "*pp" is null, function will allocate a new pointer
+     * for data that caller is responsible for freeing (only if function returns
+     * successfully).
+     * If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring
+     * that "*pp" is large enough to accept all of the serialized data.
+     * Returns < 0 on error, >= 0 indicating bytes written (or would have been)
+     * on success.
+     */
+    __owur int i2d_SCT_LIST(const STACK_OF(SCT) * a, unsigned char** pp);
+
+    /*
+     * Parses an SCT list in DER format and returns it.
+     * If "a" or "*a" is NULL, a new stack will be created that the caller is
+     * responsible for freeing (by calling SCT_LIST_free).
+     * "**pp" and "*pp" must not be NULL.
+     * Upon success, "*pp" will point to after the last bytes read, and a stack
+     * will be returned.
+     * Upon failure, a NULL pointer will be returned, and the position of "*pp" is
+     * not defined.
+     */
+    STACK_OF(SCT) * d2i_SCT_LIST(STACK_OF(SCT) * *a, const unsigned char** pp, long len);
+
+    /*
+     * Serialize (to TLS format) an |sct| and write it to |out|.
+     * If |out| is null, no SCT will be output but the length will still be returned.
+     * If |out| points to a null pointer, a string will be allocated to hold the
+     * TLS-format SCT. It is the responsibility of the caller to free it.
+     * If |out| points to an allocated string, the TLS-format SCT will be written
+     * to it.
+     * The length of the SCT in TLS format will be returned.
+     */
+    __owur int i2o_SCT(const SCT* sct, unsigned char** out);
+
+    /*
+     * Parses an SCT in TLS format and returns it.
+     * If |psct| is not null, it will end up pointing to the parsed SCT. If it
+     * already points to a non-null pointer, the pointer will be free'd.
+     * |in| should be a pointer to a string containing the TLS-format SCT.
+     * |in| will be advanced to the end of the SCT if parsing succeeds.
+     * |len| should be the length of the SCT in |in|.
+     * Returns NULL if an error occurs.
+     * If the SCT is an unsupported version, only the SCT's 'sct' and 'sct_len'
+     * fields will be populated (with |in| and |len| respectively).
+     */
+    SCT* o2i_SCT(SCT** psct, const unsigned char** in, size_t len);
+
+    /********************
+     * CT log functions *
+     ********************/
+
+    /*
+     * Creates a new CT log instance with the given |public_key| and |name| and
+     * associates it with the give library context |libctx| and property query
+     * string |propq|.
+     * Takes ownership of |public_key| but copies |name|.
+     * Returns NULL if malloc fails or if |public_key| cannot be converted to DER.
+     * Should be deleted by the caller using CTLOG_free when no longer needed.
+     */
+    CTLOG* CTLOG_new_ex(EVP_PKEY* public_key, const char* name, OSSL_LIB_CTX* libctx, const char* propq);
+
+    /*
+     * The same as CTLOG_new_ex except that the default library context and
+     * property query string are used.
+     */
+    CTLOG* CTLOG_new(EVP_PKEY* public_key, const char* name);
+
+    /*
+     * Creates a new CTLOG instance with the base64-encoded SubjectPublicKeyInfo DER
+     * in |pkey_base64| and associated with the given library context |libctx| and
+     * property query string |propq|. The |name| is a string to help users identify
+     * this log.
+     * Returns 1 on success, 0 on failure.
+     * Should be deleted by the caller using CTLOG_free when no longer needed.
+     */
+    int CTLOG_new_from_base64_ex(CTLOG** ct_log, const char* pkey_base64, const char* name, OSSL_LIB_CTX* libctx, const char* propq);
+
+    /*
+     * The same as CTLOG_new_from_base64_ex() except that the default
+     * library context and property query string are used.
+     * Returns 1 on success, 0 on failure.
+     */
+    int CTLOG_new_from_base64(CTLOG** ct_log, const char* pkey_base64, const char* name);
+
+    /*
+     * Deletes a CT log instance and its fields.
+     */
+    void CTLOG_free(CTLOG* log);
+
+    /* Gets the name of the CT log */
+    const char* CTLOG_get0_name(const CTLOG* log);
+    /* Gets the ID of the CT log */
+    void CTLOG_get0_log_id(const CTLOG* log, const uint8_t** log_id, size_t* log_id_len);
+    /* Gets the public key of the CT log */
+    EVP_PKEY* CTLOG_get0_public_key(const CTLOG* log);
+
+    /**************************
+     * CT log store functions *
+     **************************/
+
+    /*
+     * Creates a new CT log store and associates it with the given libctx and
+     * property query string.
+     * Should be deleted by the caller using CTLOG_STORE_free when no longer needed.
+     */
+    CTLOG_STORE* CTLOG_STORE_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+
+    /*
+     * Same as CTLOG_STORE_new_ex except that the default libctx and
+     * property query string are used.
+     * Should be deleted by the caller using CTLOG_STORE_free when no longer needed.
+     */
+    CTLOG_STORE* CTLOG_STORE_new(void);
+
+    /*
+     * Deletes a CT log store and all of the CT log instances held within.
+     */
+    void CTLOG_STORE_free(CTLOG_STORE* store);
+
+    /*
+     * Finds a CT log in the store based on its log ID.
+     * Returns the CT log, or NULL if no match is found.
+     */
+    const CTLOG* CTLOG_STORE_get0_log_by_id(const CTLOG_STORE* store, const uint8_t* log_id, size_t log_id_len);
+
+    /*
+     * Loads a CT log list into a |store| from a |file|.
+     * Returns 1 if loading is successful, or 0 otherwise.
+     */
+    __owur int CTLOG_STORE_load_file(CTLOG_STORE* store, const char* file);
+
+    /*
+     * Loads the default CT log list into a |store|.
+     * Returns 1 if loading is successful, or 0 otherwise.
+     */
+    __owur int CTLOG_STORE_load_default_file(CTLOG_STORE* store);
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/cterr.h b/CAPI/cpp/grpc/include/openssl/cterr.h
index 935d32d..950b7b3 100644
--- a/CAPI/cpp/grpc/include/openssl/cterr.h
+++ b/CAPI/cpp/grpc/include/openssl/cterr.h
@@ -9,37 +9,35 @@
  */
 
 #ifndef OPENSSL_CTERR_H
-# define OPENSSL_CTERR_H
-# pragma once
+#define OPENSSL_CTERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_CT
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_CT
 
 /*
  * CT reason codes.
  */
-#  define CT_R_BASE64_DECODE_ERROR                         108
-#  define CT_R_INVALID_LOG_ID_LENGTH                       100
-#  define CT_R_LOG_CONF_INVALID                            109
-#  define CT_R_LOG_CONF_INVALID_KEY                        110
-#  define CT_R_LOG_CONF_MISSING_DESCRIPTION                111
-#  define CT_R_LOG_CONF_MISSING_KEY                        112
-#  define CT_R_LOG_KEY_INVALID                             113
-#  define CT_R_SCT_FUTURE_TIMESTAMP                        116
-#  define CT_R_SCT_INVALID                                 104
-#  define CT_R_SCT_INVALID_SIGNATURE                       107
-#  define CT_R_SCT_LIST_INVALID                            105
-#  define CT_R_SCT_LOG_ID_MISMATCH                         114
-#  define CT_R_SCT_NOT_SET                                 106
-#  define CT_R_SCT_UNSUPPORTED_VERSION                     115
-#  define CT_R_UNRECOGNIZED_SIGNATURE_NID                  101
-#  define CT_R_UNSUPPORTED_ENTRY_TYPE                      102
-#  define CT_R_UNSUPPORTED_VERSION                         103
+#define CT_R_BASE64_DECODE_ERROR 108
+#define CT_R_INVALID_LOG_ID_LENGTH 100
+#define CT_R_LOG_CONF_INVALID 109
+#define CT_R_LOG_CONF_INVALID_KEY 110
+#define CT_R_LOG_CONF_MISSING_DESCRIPTION 111
+#define CT_R_LOG_CONF_MISSING_KEY 112
+#define CT_R_LOG_KEY_INVALID 113
+#define CT_R_SCT_FUTURE_TIMESTAMP 116
+#define CT_R_SCT_INVALID 104
+#define CT_R_SCT_INVALID_SIGNATURE 107
+#define CT_R_SCT_LIST_INVALID 105
+#define CT_R_SCT_LOG_ID_MISMATCH 114
+#define CT_R_SCT_NOT_SET 106
+#define CT_R_SCT_UNSUPPORTED_VERSION 115
+#define CT_R_UNRECOGNIZED_SIGNATURE_NID 101
+#define CT_R_UNSUPPORTED_ENTRY_TYPE 102
+#define CT_R_UNSUPPORTED_VERSION 103
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/decoder.h b/CAPI/cpp/grpc/include/openssl/decoder.h
index d4ee2cf..c3c0872 100644
--- a/CAPI/cpp/grpc/include/openssl/decoder.h
+++ b/CAPI/cpp/grpc/include/openssl/decoder.h
@@ -8,126 +8,99 @@
  */
 
 #ifndef OPENSSL_DECODER_H
-# define OPENSSL_DECODER_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_STDIO
-#  include <stdio.h>
-# endif
-# include <stdarg.h>
-# include <stddef.h>
-# include <openssl/decodererr.h>
-# include <openssl/types.h>
-# include <openssl/core.h>
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-OSSL_DECODER *OSSL_DECODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
-                                 const char *properties);
-int OSSL_DECODER_up_ref(OSSL_DECODER *encoder);
-void OSSL_DECODER_free(OSSL_DECODER *encoder);
-
-const OSSL_PROVIDER *OSSL_DECODER_get0_provider(const OSSL_DECODER *encoder);
-const char *OSSL_DECODER_get0_properties(const OSSL_DECODER *encoder);
-const char *OSSL_DECODER_get0_name(const OSSL_DECODER *decoder);
-const char *OSSL_DECODER_get0_description(const OSSL_DECODER *decoder);
-int OSSL_DECODER_is_a(const OSSL_DECODER *encoder, const char *name);
-
-void OSSL_DECODER_do_all_provided(OSSL_LIB_CTX *libctx,
-                                  void (*fn)(OSSL_DECODER *encoder, void *arg),
-                                  void *arg);
-int OSSL_DECODER_names_do_all(const OSSL_DECODER *encoder,
-                              void (*fn)(const char *name, void *data),
-                              void *data);
-const OSSL_PARAM *OSSL_DECODER_gettable_params(OSSL_DECODER *decoder);
-int OSSL_DECODER_get_params(OSSL_DECODER *decoder, OSSL_PARAM params[]);
-
-const OSSL_PARAM *OSSL_DECODER_settable_ctx_params(OSSL_DECODER *encoder);
-OSSL_DECODER_CTX *OSSL_DECODER_CTX_new(void);
-int OSSL_DECODER_CTX_set_params(OSSL_DECODER_CTX *ctx,
-                                const OSSL_PARAM params[]);
-void OSSL_DECODER_CTX_free(OSSL_DECODER_CTX *ctx);
-
-/* Utilities that help set specific parameters */
-int OSSL_DECODER_CTX_set_passphrase(OSSL_DECODER_CTX *ctx,
-                                    const unsigned char *kstr, size_t klen);
-int OSSL_DECODER_CTX_set_pem_password_cb(OSSL_DECODER_CTX *ctx,
-                                         pem_password_cb *cb, void *cbarg);
-int OSSL_DECODER_CTX_set_passphrase_cb(OSSL_DECODER_CTX *ctx,
-                                       OSSL_PASSPHRASE_CALLBACK *cb,
-                                       void *cbarg);
-int OSSL_DECODER_CTX_set_passphrase_ui(OSSL_DECODER_CTX *ctx,
-                                       const UI_METHOD *ui_method,
-                                       void *ui_data);
+#define OPENSSL_DECODER_H
+#pragma once
 
-/*
- * Utilities to read the object to decode, with the result sent to cb.
- * These will discover all provided methods
- */
+#include <openssl/opensslconf.h>
 
-int OSSL_DECODER_CTX_set_selection(OSSL_DECODER_CTX *ctx, int selection);
-int OSSL_DECODER_CTX_set_input_type(OSSL_DECODER_CTX *ctx,
-                                    const char *input_type);
-int OSSL_DECODER_CTX_set_input_structure(OSSL_DECODER_CTX *ctx,
-                                         const char *input_structure);
-int OSSL_DECODER_CTX_add_decoder(OSSL_DECODER_CTX *ctx, OSSL_DECODER *decoder);
-int OSSL_DECODER_CTX_add_extra(OSSL_DECODER_CTX *ctx,
-                               OSSL_LIB_CTX *libctx, const char *propq);
-int OSSL_DECODER_CTX_get_num_decoders(OSSL_DECODER_CTX *ctx);
-
-typedef struct ossl_decoder_instance_st OSSL_DECODER_INSTANCE;
-OSSL_DECODER *
-OSSL_DECODER_INSTANCE_get_decoder(OSSL_DECODER_INSTANCE *decoder_inst);
-void *
-OSSL_DECODER_INSTANCE_get_decoder_ctx(OSSL_DECODER_INSTANCE *decoder_inst);
-const char *
-OSSL_DECODER_INSTANCE_get_input_type(OSSL_DECODER_INSTANCE *decoder_inst);
-const char *
-OSSL_DECODER_INSTANCE_get_input_structure(OSSL_DECODER_INSTANCE *decoder_inst,
-                                          int *was_set);
-
-typedef int OSSL_DECODER_CONSTRUCT(OSSL_DECODER_INSTANCE *decoder_inst,
-                                   const OSSL_PARAM *params,
-                                   void *construct_data);
-typedef void OSSL_DECODER_CLEANUP(void *construct_data);
-
-int OSSL_DECODER_CTX_set_construct(OSSL_DECODER_CTX *ctx,
-                                   OSSL_DECODER_CONSTRUCT *construct);
-int OSSL_DECODER_CTX_set_construct_data(OSSL_DECODER_CTX *ctx,
-                                        void *construct_data);
-int OSSL_DECODER_CTX_set_cleanup(OSSL_DECODER_CTX *ctx,
-                                 OSSL_DECODER_CLEANUP *cleanup);
-OSSL_DECODER_CONSTRUCT *OSSL_DECODER_CTX_get_construct(OSSL_DECODER_CTX *ctx);
-void *OSSL_DECODER_CTX_get_construct_data(OSSL_DECODER_CTX *ctx);
-OSSL_DECODER_CLEANUP *OSSL_DECODER_CTX_get_cleanup(OSSL_DECODER_CTX *ctx);
-
-int OSSL_DECODER_export(OSSL_DECODER_INSTANCE *decoder_inst,
-                        void *reference, size_t reference_sz,
-                        OSSL_CALLBACK *export_cb, void *export_cbarg);
-
-int OSSL_DECODER_from_bio(OSSL_DECODER_CTX *ctx, BIO *in);
 #ifndef OPENSSL_NO_STDIO
-int OSSL_DECODER_from_fp(OSSL_DECODER_CTX *ctx, FILE *in);
+#include <stdio.h>
+#endif
+#include <stdarg.h>
+#include <stddef.h>
+#include <openssl/decodererr.h>
+#include <openssl/types.h>
+#include <openssl/core.h>
+
+#ifdef __cplusplus
+extern "C"
+{
 #endif
-int OSSL_DECODER_from_data(OSSL_DECODER_CTX *ctx, const unsigned char **pdata,
-                           size_t *pdata_len);
 
-/*
- * Create the OSSL_DECODER_CTX with an associated type.  This will perform
- * an implicit OSSL_DECODER_fetch(), suitable for the object of that type.
- */
-OSSL_DECODER_CTX *
-OSSL_DECODER_CTX_new_for_pkey(EVP_PKEY **pkey,
-                              const char *input_type,
-                              const char *input_struct,
-                              const char *keytype, int selection,
-                              OSSL_LIB_CTX *libctx, const char *propquery);
-
-# ifdef __cplusplus
+    OSSL_DECODER* OSSL_DECODER_fetch(OSSL_LIB_CTX* libctx, const char* name, const char* properties);
+    int OSSL_DECODER_up_ref(OSSL_DECODER* encoder);
+    void OSSL_DECODER_free(OSSL_DECODER* encoder);
+
+    const OSSL_PROVIDER* OSSL_DECODER_get0_provider(const OSSL_DECODER* encoder);
+    const char* OSSL_DECODER_get0_properties(const OSSL_DECODER* encoder);
+    const char* OSSL_DECODER_get0_name(const OSSL_DECODER* decoder);
+    const char* OSSL_DECODER_get0_description(const OSSL_DECODER* decoder);
+    int OSSL_DECODER_is_a(const OSSL_DECODER* encoder, const char* name);
+
+    void OSSL_DECODER_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(OSSL_DECODER* encoder, void* arg), void* arg);
+    int OSSL_DECODER_names_do_all(const OSSL_DECODER* encoder, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PARAM* OSSL_DECODER_gettable_params(OSSL_DECODER* decoder);
+    int OSSL_DECODER_get_params(OSSL_DECODER* decoder, OSSL_PARAM params[]);
+
+    const OSSL_PARAM* OSSL_DECODER_settable_ctx_params(OSSL_DECODER* encoder);
+    OSSL_DECODER_CTX* OSSL_DECODER_CTX_new(void);
+    int OSSL_DECODER_CTX_set_params(OSSL_DECODER_CTX* ctx, const OSSL_PARAM params[]);
+    void OSSL_DECODER_CTX_free(OSSL_DECODER_CTX* ctx);
+
+    /* Utilities that help set specific parameters */
+    int OSSL_DECODER_CTX_set_passphrase(OSSL_DECODER_CTX* ctx, const unsigned char* kstr, size_t klen);
+    int OSSL_DECODER_CTX_set_pem_password_cb(OSSL_DECODER_CTX* ctx, pem_password_cb* cb, void* cbarg);
+    int OSSL_DECODER_CTX_set_passphrase_cb(OSSL_DECODER_CTX* ctx, OSSL_PASSPHRASE_CALLBACK* cb, void* cbarg);
+    int OSSL_DECODER_CTX_set_passphrase_ui(OSSL_DECODER_CTX* ctx, const UI_METHOD* ui_method, void* ui_data);
+
+    /*
+     * Utilities to read the object to decode, with the result sent to cb.
+     * These will discover all provided methods
+     */
+
+    int OSSL_DECODER_CTX_set_selection(OSSL_DECODER_CTX* ctx, int selection);
+    int OSSL_DECODER_CTX_set_input_type(OSSL_DECODER_CTX* ctx, const char* input_type);
+    int OSSL_DECODER_CTX_set_input_structure(OSSL_DECODER_CTX* ctx, const char* input_structure);
+    int OSSL_DECODER_CTX_add_decoder(OSSL_DECODER_CTX* ctx, OSSL_DECODER* decoder);
+    int OSSL_DECODER_CTX_add_extra(OSSL_DECODER_CTX* ctx, OSSL_LIB_CTX* libctx, const char* propq);
+    int OSSL_DECODER_CTX_get_num_decoders(OSSL_DECODER_CTX* ctx);
+
+    typedef struct ossl_decoder_instance_st OSSL_DECODER_INSTANCE;
+    OSSL_DECODER*
+        OSSL_DECODER_INSTANCE_get_decoder(OSSL_DECODER_INSTANCE* decoder_inst);
+    void*
+        OSSL_DECODER_INSTANCE_get_decoder_ctx(OSSL_DECODER_INSTANCE* decoder_inst);
+    const char*
+        OSSL_DECODER_INSTANCE_get_input_type(OSSL_DECODER_INSTANCE* decoder_inst);
+    const char*
+        OSSL_DECODER_INSTANCE_get_input_structure(OSSL_DECODER_INSTANCE* decoder_inst, int* was_set);
+
+    typedef int OSSL_DECODER_CONSTRUCT(OSSL_DECODER_INSTANCE* decoder_inst, const OSSL_PARAM* params, void* construct_data);
+    typedef void OSSL_DECODER_CLEANUP(void* construct_data);
+
+    int OSSL_DECODER_CTX_set_construct(OSSL_DECODER_CTX* ctx, OSSL_DECODER_CONSTRUCT* construct);
+    int OSSL_DECODER_CTX_set_construct_data(OSSL_DECODER_CTX* ctx, void* construct_data);
+    int OSSL_DECODER_CTX_set_cleanup(OSSL_DECODER_CTX* ctx, OSSL_DECODER_CLEANUP* cleanup);
+    OSSL_DECODER_CONSTRUCT* OSSL_DECODER_CTX_get_construct(OSSL_DECODER_CTX* ctx);
+    void* OSSL_DECODER_CTX_get_construct_data(OSSL_DECODER_CTX* ctx);
+    OSSL_DECODER_CLEANUP* OSSL_DECODER_CTX_get_cleanup(OSSL_DECODER_CTX* ctx);
+
+    int OSSL_DECODER_export(OSSL_DECODER_INSTANCE* decoder_inst, void* reference, size_t reference_sz, OSSL_CALLBACK* export_cb, void* export_cbarg);
+
+    int OSSL_DECODER_from_bio(OSSL_DECODER_CTX* ctx, BIO* in);
+#ifndef OPENSSL_NO_STDIO
+    int OSSL_DECODER_from_fp(OSSL_DECODER_CTX* ctx, FILE* in);
+#endif
+    int OSSL_DECODER_from_data(OSSL_DECODER_CTX* ctx, const unsigned char** pdata, size_t* pdata_len);
+
+    /*
+     * Create the OSSL_DECODER_CTX with an associated type.  This will perform
+     * an implicit OSSL_DECODER_fetch(), suitable for the object of that type.
+     */
+    OSSL_DECODER_CTX*
+        OSSL_DECODER_CTX_new_for_pkey(EVP_PKEY** pkey, const char* input_type, const char* input_struct, const char* keytype, int selection, OSSL_LIB_CTX* libctx, const char* propquery);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/decodererr.h b/CAPI/cpp/grpc/include/openssl/decodererr.h
index 4212a38..5fdeace 100644
--- a/CAPI/cpp/grpc/include/openssl/decodererr.h
+++ b/CAPI/cpp/grpc/include/openssl/decodererr.h
@@ -9,20 +9,18 @@
  */
 
 #ifndef OPENSSL_DECODERERR_H
-# define OPENSSL_DECODERERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_DECODERERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * OSSL_DECODER reason codes.
  */
-# define OSSL_DECODER_R_COULD_NOT_DECODE_OBJECT           101
-# define OSSL_DECODER_R_DECODER_NOT_FOUND                 102
-# define OSSL_DECODER_R_MISSING_GET_PARAMS                100
+#define OSSL_DECODER_R_COULD_NOT_DECODE_OBJECT 101
+#define OSSL_DECODER_R_DECODER_NOT_FOUND 102
+#define OSSL_DECODER_R_MISSING_GET_PARAMS 100
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/des.h b/CAPI/cpp/grpc/include/openssl/des.h
index 09798a6..b8778fe 100644
--- a/CAPI/cpp/grpc/include/openssl/des.h
+++ b/CAPI/cpp/grpc/include/openssl/des.h
@@ -8,103 +8,93 @@
  */
 
 #ifndef OPENSSL_DES_H
-# define OPENSSL_DES_H
-# pragma once
+#define OPENSSL_DES_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_DES_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_DES_H
+#endif
+
+#include <openssl/opensslconf.h>
 
-# include <openssl/opensslconf.h>
+#ifndef OPENSSL_NO_DES
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include <openssl/e_os2.h>
 
-# ifndef OPENSSL_NO_DES
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
-#  include <openssl/e_os2.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef unsigned int DES_LONG;
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef unsigned int DES_LONG;
+#ifdef OPENSSL_BUILD_SHLIBCRYPTO
+#undef OPENSSL_EXTERN
+#define OPENSSL_EXTERN OPENSSL_EXPORT
+#endif
 
-#   ifdef OPENSSL_BUILD_SHLIBCRYPTO
-#    undef OPENSSL_EXTERN
-#    define OPENSSL_EXTERN OPENSSL_EXPORT
-#   endif
+    typedef unsigned char DES_cblock[8];
+    typedef /* const */ unsigned char const_DES_cblock[8];
+    /*
+     * With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * and
+     * const_DES_cblock * are incompatible pointer types.
+     */
 
-typedef unsigned char DES_cblock[8];
-typedef /* const */ unsigned char const_DES_cblock[8];
-/*
- * With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * and
- * const_DES_cblock * are incompatible pointer types.
- */
+    typedef struct DES_ks
+    {
+        union
+        {
+            DES_cblock cblock;
+            /*
+             * make sure things are correct size on machines with 8 byte longs
+             */
+            DES_LONG deslong[2];
+        } ks[16];
+    } DES_key_schedule;
+
+#define DES_KEY_SZ (sizeof(DES_cblock))
+#define DES_SCHEDULE_SZ (sizeof(DES_key_schedule))
+
+#define DES_ENCRYPT 1
+#define DES_DECRYPT 0
+
+#define DES_CBC_MODE 0
+#define DES_PCBC_MODE 1
+
+#define DES_ecb2_encrypt(i, o, k1, k2, e) \
+    DES_ecb3_encrypt((i), (o), (k1), (k2), (k1), (e))
+
+#define DES_ede2_cbc_encrypt(i, o, l, k1, k2, iv, e) \
+    DES_ede3_cbc_encrypt((i), (o), (l), (k1), (k2), (k1), (iv), (e))
 
-typedef struct DES_ks {
-    union {
-        DES_cblock cblock;
-        /*
-         * make sure things are correct size on machines with 8 byte longs
-         */
-        DES_LONG deslong[2];
-    } ks[16];
-} DES_key_schedule;
-
-#   define DES_KEY_SZ      (sizeof(DES_cblock))
-#   define DES_SCHEDULE_SZ (sizeof(DES_key_schedule))
-
-#   define DES_ENCRYPT     1
-#   define DES_DECRYPT     0
-
-#   define DES_CBC_MODE    0
-#   define DES_PCBC_MODE   1
-
-#   define DES_ecb2_encrypt(i,o,k1,k2,e) \
-        DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e))
-
-#   define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \
-        DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e))
-
-#   define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \
-        DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e))
-
-#   define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \
-        DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n))
-
-#   define DES_fixup_key_parity DES_set_odd_parity
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 const char *DES_options(void);
-OSSL_DEPRECATEDIN_3_0
-void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output,
-                      DES_key_schedule *ks1, DES_key_schedule *ks2,
-                      DES_key_schedule *ks3, int enc);
-OSSL_DEPRECATEDIN_3_0
-DES_LONG DES_cbc_cksum(const unsigned char *input, DES_cblock *output,
-                       long length, DES_key_schedule *schedule,
-                       const_DES_cblock *ivec);
-#  endif
+#define DES_ede2_cfb64_encrypt(i, o, l, k1, k2, iv, n, e) \
+    DES_ede3_cfb64_encrypt((i), (o), (l), (k1), (k2), (k1), (iv), (n), (e))
+
+#define DES_ede2_ofb64_encrypt(i, o, l, k1, k2, iv, n) \
+    DES_ede3_ofb64_encrypt((i), (o), (l), (k1), (k2), (k1), (iv), (n))
+
+#define DES_fixup_key_parity DES_set_odd_parity
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 const char* DES_options(void);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ecb3_encrypt(const_DES_cblock* input, DES_cblock* output, DES_key_schedule* ks1, DES_key_schedule* ks2, DES_key_schedule* ks3, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    DES_LONG DES_cbc_cksum(const unsigned char* input, DES_cblock* output, long length, DES_key_schedule* schedule, const_DES_cblock* ivec);
+#endif
 /* DES_cbc_encrypt does not update the IV!  Use DES_ncbc_encrypt instead. */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-void DES_cbc_encrypt(const unsigned char *input, unsigned char *output,
-                     long length, DES_key_schedule *schedule, DES_cblock *ivec,
-                     int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_ncbc_encrypt(const unsigned char *input, unsigned char *output,
-                      long length, DES_key_schedule *schedule, DES_cblock *ivec,
-                      int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_xcbc_encrypt(const unsigned char *input, unsigned char *output,
-                      long length, DES_key_schedule *schedule, DES_cblock *ivec,
-                      const_DES_cblock *inw, const_DES_cblock *outw, int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits,
-                     long length, DES_key_schedule *schedule, DES_cblock *ivec,
-                     int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output,
-                     DES_key_schedule *ks, int enc);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    void DES_cbc_encrypt(const unsigned char* input, unsigned char* output, long length, DES_key_schedule* schedule, DES_cblock* ivec, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ncbc_encrypt(const unsigned char* input, unsigned char* output, long length, DES_key_schedule* schedule, DES_cblock* ivec, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_xcbc_encrypt(const unsigned char* input, unsigned char* output, long length, DES_key_schedule* schedule, DES_cblock* ivec, const_DES_cblock* inw, const_DES_cblock* outw, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_cfb_encrypt(const unsigned char* in, unsigned char* out, int numbits, long length, DES_key_schedule* schedule, DES_cblock* ivec, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ecb_encrypt(const_DES_cblock* input, DES_cblock* output, DES_key_schedule* ks, int enc);
+#endif
 
 /*
  * This is the DES encryption function that gets called by just about every
@@ -116,10 +106,10 @@ void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output,
  * long's and ks is the DES_key_schedule to use.  enc, is non zero specifies
  * encryption, zero if decryption.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    void DES_encrypt1(DES_LONG* data, DES_key_schedule* ks, int enc);
+#endif
 
 /*
  * This functions is the same as DES_encrypt1() except that the DES initial
@@ -129,83 +119,61 @@ void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc);
  * DES_encrypt2() DES_encrypt2() FP() is the same as DES_encrypt1()
  * DES_encrypt1() DES_encrypt1() except faster :-).
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, DES_key_schedule *ks2,
-                  DES_key_schedule *ks3);
-OSSL_DEPRECATEDIN_3_0
-void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, DES_key_schedule *ks2,
-                  DES_key_schedule *ks3);
-OSSL_DEPRECATEDIN_3_0
-void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output,
-                          long length, DES_key_schedule *ks1,
-                          DES_key_schedule *ks2, DES_key_schedule *ks3,
-                          DES_cblock *ivec, int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out,
-                            long length, DES_key_schedule *ks1,
-                            DES_key_schedule *ks2, DES_key_schedule *ks3,
-                            DES_cblock *ivec, int *num, int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_ede3_cfb_encrypt(const unsigned char *in, unsigned char *out,
-                          int numbits, long length, DES_key_schedule *ks1,
-                          DES_key_schedule *ks2, DES_key_schedule *ks3,
-                          DES_cblock *ivec, int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_ede3_ofb64_encrypt(const unsigned char *in, unsigned char *out,
-                            long length, DES_key_schedule *ks1,
-                            DES_key_schedule *ks2, DES_key_schedule *ks3,
-                            DES_cblock *ivec, int *num);
-OSSL_DEPRECATEDIN_3_0
-char *DES_fcrypt(const char *buf, const char *salt, char *ret);
-OSSL_DEPRECATEDIN_3_0
-char *DES_crypt(const char *buf, const char *salt);
-OSSL_DEPRECATEDIN_3_0
-void DES_ofb_encrypt(const unsigned char *in, unsigned char *out, int numbits,
-                     long length, DES_key_schedule *schedule, DES_cblock *ivec);
-OSSL_DEPRECATEDIN_3_0
-void DES_pcbc_encrypt(const unsigned char *input, unsigned char *output,
-                      long length, DES_key_schedule *schedule,
-                      DES_cblock *ivec, int enc);
-OSSL_DEPRECATEDIN_3_0
-DES_LONG DES_quad_cksum(const unsigned char *input, DES_cblock output[],
-                        long length, int out_count, DES_cblock *seed);
-OSSL_DEPRECATEDIN_3_0 int DES_random_key(DES_cblock *ret);
-OSSL_DEPRECATEDIN_3_0 void DES_set_odd_parity(DES_cblock *key);
-OSSL_DEPRECATEDIN_3_0 int DES_check_key_parity(const_DES_cblock *key);
-OSSL_DEPRECATEDIN_3_0 int DES_is_weak_key(const_DES_cblock *key);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    void DES_encrypt2(DES_LONG* data, DES_key_schedule* ks, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_encrypt3(DES_LONG* data, DES_key_schedule* ks1, DES_key_schedule* ks2, DES_key_schedule* ks3);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_decrypt3(DES_LONG* data, DES_key_schedule* ks1, DES_key_schedule* ks2, DES_key_schedule* ks3);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ede3_cbc_encrypt(const unsigned char* input, unsigned char* output, long length, DES_key_schedule* ks1, DES_key_schedule* ks2, DES_key_schedule* ks3, DES_cblock* ivec, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ede3_cfb64_encrypt(const unsigned char* in, unsigned char* out, long length, DES_key_schedule* ks1, DES_key_schedule* ks2, DES_key_schedule* ks3, DES_cblock* ivec, int* num, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ede3_cfb_encrypt(const unsigned char* in, unsigned char* out, int numbits, long length, DES_key_schedule* ks1, DES_key_schedule* ks2, DES_key_schedule* ks3, DES_cblock* ivec, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ede3_ofb64_encrypt(const unsigned char* in, unsigned char* out, long length, DES_key_schedule* ks1, DES_key_schedule* ks2, DES_key_schedule* ks3, DES_cblock* ivec, int* num);
+    OSSL_DEPRECATEDIN_3_0
+    char* DES_fcrypt(const char* buf, const char* salt, char* ret);
+    OSSL_DEPRECATEDIN_3_0
+    char* DES_crypt(const char* buf, const char* salt);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ofb_encrypt(const unsigned char* in, unsigned char* out, int numbits, long length, DES_key_schedule* schedule, DES_cblock* ivec);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_pcbc_encrypt(const unsigned char* input, unsigned char* output, long length, DES_key_schedule* schedule, DES_cblock* ivec, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    DES_LONG DES_quad_cksum(const unsigned char* input, DES_cblock output[], long length, int out_count, DES_cblock* seed);
+    OSSL_DEPRECATEDIN_3_0 int DES_random_key(DES_cblock* ret);
+    OSSL_DEPRECATEDIN_3_0 void DES_set_odd_parity(DES_cblock* key);
+    OSSL_DEPRECATEDIN_3_0 int DES_check_key_parity(const_DES_cblock* key);
+    OSSL_DEPRECATEDIN_3_0 int DES_is_weak_key(const_DES_cblock* key);
+#endif
 /*
  * DES_set_key (= set_key = DES_key_sched = key_sched) calls
  * DES_set_key_checked
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule);
-OSSL_DEPRECATEDIN_3_0
-int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule);
-OSSL_DEPRECATEDIN_3_0
-int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule);
-OSSL_DEPRECATEDIN_3_0
-void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule);
-OSSL_DEPRECATEDIN_3_0 void DES_string_to_key(const char *str, DES_cblock *key);
-OSSL_DEPRECATEDIN_3_0
-void DES_string_to_2keys(const char *str, DES_cblock *key1, DES_cblock *key2);
-OSSL_DEPRECATEDIN_3_0
-void DES_cfb64_encrypt(const unsigned char *in, unsigned char *out,
-                       long length, DES_key_schedule *schedule,
-                       DES_cblock *ivec, int *num, int enc);
-OSSL_DEPRECATEDIN_3_0
-void DES_ofb64_encrypt(const unsigned char *in, unsigned char *out,
-                       long length, DES_key_schedule *schedule,
-                       DES_cblock *ivec, int *num);
-#  endif
-
-#  ifdef  __cplusplus
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int DES_set_key(const_DES_cblock* key, DES_key_schedule* schedule);
+    OSSL_DEPRECATEDIN_3_0
+    int DES_key_sched(const_DES_cblock* key, DES_key_schedule* schedule);
+    OSSL_DEPRECATEDIN_3_0
+    int DES_set_key_checked(const_DES_cblock* key, DES_key_schedule* schedule);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_set_key_unchecked(const_DES_cblock* key, DES_key_schedule* schedule);
+    OSSL_DEPRECATEDIN_3_0 void DES_string_to_key(const char* str, DES_cblock* key);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_string_to_2keys(const char* str, DES_cblock* key1, DES_cblock* key2);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_cfb64_encrypt(const unsigned char* in, unsigned char* out, long length, DES_key_schedule* schedule, DES_cblock* ivec, int* num, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void DES_ofb64_encrypt(const unsigned char* in, unsigned char* out, long length, DES_key_schedule* schedule, DES_cblock* ivec, int* num);
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/dh.h b/CAPI/cpp/grpc/include/openssl/dh.h
index b97871e..39bedd1 100644
--- a/CAPI/cpp/grpc/include/openssl/dh.h
+++ b/CAPI/cpp/grpc/include/openssl/dh.h
@@ -8,321 +8,277 @@
  */
 
 #ifndef OPENSSL_DH_H
-# define OPENSSL_DH_H
-# pragma once
+#define OPENSSL_DH_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_DH_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_DH_H
+#endif
 
-# include <openssl/opensslconf.h>
-# include <openssl/types.h>
+#include <openssl/opensslconf.h>
+#include <openssl/types.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 #include <stdlib.h>
 
 /* DH parameter generation types used by EVP_PKEY_CTX_set_dh_paramgen_type() */
-# define DH_PARAMGEN_TYPE_GENERATOR     0   /* Use a safe prime generator */
-# define DH_PARAMGEN_TYPE_FIPS_186_2    1   /* Use FIPS186-2 standard */
-# define DH_PARAMGEN_TYPE_FIPS_186_4    2   /* Use FIPS186-4 standard */
-# define DH_PARAMGEN_TYPE_GROUP         3   /* Use a named safe prime group */
-
-int EVP_PKEY_CTX_set_dh_paramgen_type(EVP_PKEY_CTX *ctx, int typ);
-int EVP_PKEY_CTX_set_dh_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex);
-int EVP_PKEY_CTX_set_dh_paramgen_seed(EVP_PKEY_CTX *ctx,
-                                      const unsigned char *seed,
-                                      size_t seedlen);
-int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *ctx, int pbits);
-int EVP_PKEY_CTX_set_dh_paramgen_subprime_len(EVP_PKEY_CTX *ctx, int qlen);
-int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *ctx, int gen);
-int EVP_PKEY_CTX_set_dh_nid(EVP_PKEY_CTX *ctx, int nid);
-int EVP_PKEY_CTX_set_dh_rfc5114(EVP_PKEY_CTX *ctx, int gen);
-int EVP_PKEY_CTX_set_dhx_rfc5114(EVP_PKEY_CTX *ctx, int gen);
-int EVP_PKEY_CTX_set_dh_pad(EVP_PKEY_CTX *ctx, int pad);
-
-int EVP_PKEY_CTX_set_dh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
-int EVP_PKEY_CTX_get_dh_kdf_type(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_CTX_set0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT *oid);
-int EVP_PKEY_CTX_get0_dh_kdf_oid(EVP_PKEY_CTX *ctx, ASN1_OBJECT **oid);
-int EVP_PKEY_CTX_set_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
-int EVP_PKEY_CTX_get_dh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
-int EVP_PKEY_CTX_set_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
-int EVP_PKEY_CTX_get_dh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
-int EVP_PKEY_CTX_set0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm, int len);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_CTX_get0_dh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **ukm);
+#define DH_PARAMGEN_TYPE_GENERATOR 0  /* Use a safe prime generator */
+#define DH_PARAMGEN_TYPE_FIPS_186_2 1 /* Use FIPS186-2 standard */
+#define DH_PARAMGEN_TYPE_FIPS_186_4 2 /* Use FIPS186-4 standard */
+#define DH_PARAMGEN_TYPE_GROUP 3      /* Use a named safe prime group */
+
+    int EVP_PKEY_CTX_set_dh_paramgen_type(EVP_PKEY_CTX* ctx, int typ);
+    int EVP_PKEY_CTX_set_dh_paramgen_gindex(EVP_PKEY_CTX* ctx, int gindex);
+    int EVP_PKEY_CTX_set_dh_paramgen_seed(EVP_PKEY_CTX* ctx, const unsigned char* seed, size_t seedlen);
+    int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX* ctx, int pbits);
+    int EVP_PKEY_CTX_set_dh_paramgen_subprime_len(EVP_PKEY_CTX* ctx, int qlen);
+    int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX* ctx, int gen);
+    int EVP_PKEY_CTX_set_dh_nid(EVP_PKEY_CTX* ctx, int nid);
+    int EVP_PKEY_CTX_set_dh_rfc5114(EVP_PKEY_CTX* ctx, int gen);
+    int EVP_PKEY_CTX_set_dhx_rfc5114(EVP_PKEY_CTX* ctx, int gen);
+    int EVP_PKEY_CTX_set_dh_pad(EVP_PKEY_CTX* ctx, int pad);
+
+    int EVP_PKEY_CTX_set_dh_kdf_type(EVP_PKEY_CTX* ctx, int kdf);
+    int EVP_PKEY_CTX_get_dh_kdf_type(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_CTX_set0_dh_kdf_oid(EVP_PKEY_CTX* ctx, ASN1_OBJECT* oid);
+    int EVP_PKEY_CTX_get0_dh_kdf_oid(EVP_PKEY_CTX* ctx, ASN1_OBJECT** oid);
+    int EVP_PKEY_CTX_set_dh_kdf_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
+    int EVP_PKEY_CTX_get_dh_kdf_md(EVP_PKEY_CTX* ctx, const EVP_MD** md);
+    int EVP_PKEY_CTX_set_dh_kdf_outlen(EVP_PKEY_CTX* ctx, int len);
+    int EVP_PKEY_CTX_get_dh_kdf_outlen(EVP_PKEY_CTX* ctx, int* len);
+    int EVP_PKEY_CTX_set0_dh_kdf_ukm(EVP_PKEY_CTX* ctx, unsigned char* ukm, int len);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_CTX_get0_dh_kdf_ukm(EVP_PKEY_CTX* ctx, unsigned char** ukm);
 #endif
 
-# define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN     (EVP_PKEY_ALG_CTRL + 1)
-# define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR     (EVP_PKEY_ALG_CTRL + 2)
-# define EVP_PKEY_CTRL_DH_RFC5114                (EVP_PKEY_ALG_CTRL + 3)
-# define EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN  (EVP_PKEY_ALG_CTRL + 4)
-# define EVP_PKEY_CTRL_DH_PARAMGEN_TYPE          (EVP_PKEY_ALG_CTRL + 5)
-# define EVP_PKEY_CTRL_DH_KDF_TYPE               (EVP_PKEY_ALG_CTRL + 6)
-# define EVP_PKEY_CTRL_DH_KDF_MD                 (EVP_PKEY_ALG_CTRL + 7)
-# define EVP_PKEY_CTRL_GET_DH_KDF_MD             (EVP_PKEY_ALG_CTRL + 8)
-# define EVP_PKEY_CTRL_DH_KDF_OUTLEN             (EVP_PKEY_ALG_CTRL + 9)
-# define EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN         (EVP_PKEY_ALG_CTRL + 10)
-# define EVP_PKEY_CTRL_DH_KDF_UKM                (EVP_PKEY_ALG_CTRL + 11)
-# define EVP_PKEY_CTRL_GET_DH_KDF_UKM            (EVP_PKEY_ALG_CTRL + 12)
-# define EVP_PKEY_CTRL_DH_KDF_OID                (EVP_PKEY_ALG_CTRL + 13)
-# define EVP_PKEY_CTRL_GET_DH_KDF_OID            (EVP_PKEY_ALG_CTRL + 14)
-# define EVP_PKEY_CTRL_DH_NID                    (EVP_PKEY_ALG_CTRL + 15)
-# define EVP_PKEY_CTRL_DH_PAD                    (EVP_PKEY_ALG_CTRL + 16)
+#define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN (EVP_PKEY_ALG_CTRL + 1)
+#define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR (EVP_PKEY_ALG_CTRL + 2)
+#define EVP_PKEY_CTRL_DH_RFC5114 (EVP_PKEY_ALG_CTRL + 3)
+#define EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN (EVP_PKEY_ALG_CTRL + 4)
+#define EVP_PKEY_CTRL_DH_PARAMGEN_TYPE (EVP_PKEY_ALG_CTRL + 5)
+#define EVP_PKEY_CTRL_DH_KDF_TYPE (EVP_PKEY_ALG_CTRL + 6)
+#define EVP_PKEY_CTRL_DH_KDF_MD (EVP_PKEY_ALG_CTRL + 7)
+#define EVP_PKEY_CTRL_GET_DH_KDF_MD (EVP_PKEY_ALG_CTRL + 8)
+#define EVP_PKEY_CTRL_DH_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 9)
+#define EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 10)
+#define EVP_PKEY_CTRL_DH_KDF_UKM (EVP_PKEY_ALG_CTRL + 11)
+#define EVP_PKEY_CTRL_GET_DH_KDF_UKM (EVP_PKEY_ALG_CTRL + 12)
+#define EVP_PKEY_CTRL_DH_KDF_OID (EVP_PKEY_ALG_CTRL + 13)
+#define EVP_PKEY_CTRL_GET_DH_KDF_OID (EVP_PKEY_ALG_CTRL + 14)
+#define EVP_PKEY_CTRL_DH_NID (EVP_PKEY_ALG_CTRL + 15)
+#define EVP_PKEY_CTRL_DH_PAD (EVP_PKEY_ALG_CTRL + 16)
 
 /* KDF types */
-# define EVP_PKEY_DH_KDF_NONE                            1
-# define EVP_PKEY_DH_KDF_X9_42                           2
-
-# ifndef OPENSSL_NO_DH
-#  include <openssl/e_os2.h>
-#  include <openssl/bio.h>
-#  include <openssl/asn1.h>
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#   include <openssl/bn.h>
-#  endif
-#  include <openssl/dherr.h>
+#define EVP_PKEY_DH_KDF_NONE 1
+#define EVP_PKEY_DH_KDF_X9_42 2
+
+#ifndef OPENSSL_NO_DH
+#include <openssl/e_os2.h>
+#include <openssl/bio.h>
+#include <openssl/asn1.h>
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/bn.h>
+#endif
+#include <openssl/dherr.h>
 
-#  ifndef OPENSSL_DH_MAX_MODULUS_BITS
-#   define OPENSSL_DH_MAX_MODULUS_BITS    10000
-#  endif
+#ifndef OPENSSL_DH_MAX_MODULUS_BITS
+#define OPENSSL_DH_MAX_MODULUS_BITS 10000
+#endif
 
-#  define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 1024
+#define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 1024
 
-#  define DH_FLAG_CACHE_MONT_P     0x01
+#define DH_FLAG_CACHE_MONT_P 0x01
 
-#  define DH_FLAG_TYPE_MASK             0xF000
-#  define DH_FLAG_TYPE_DH               0x0000
-#  define DH_FLAG_TYPE_DHX              0x1000
+#define DH_FLAG_TYPE_MASK 0xF000
+#define DH_FLAG_TYPE_DH 0x0000
+#define DH_FLAG_TYPE_DHX 0x1000
 
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
 /*
  * Does nothing. Previously this switched off constant time behaviour.
  */
-#   define DH_FLAG_NO_EXP_CONSTTIME 0x00
-#  endif
+#define DH_FLAG_NO_EXP_CONSTTIME 0x00
+#endif
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/*
- * If this flag is set the DH method is FIPS compliant and can be used in
- * FIPS mode. This is set in the validated module method. If an application
- * sets this flag in its own methods it is its responsibility to ensure the
- * result is compliant.
- */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /*
+     * If this flag is set the DH method is FIPS compliant and can be used in
+     * FIPS mode. This is set in the validated module method. If an application
+     * sets this flag in its own methods it is its responsibility to ensure the
+     * result is compliant.
+     */
 
-#   define DH_FLAG_FIPS_METHOD                     0x0400
+#define DH_FLAG_FIPS_METHOD 0x0400
 
-/*
- * If this flag is set the operations normally disabled in FIPS mode are
- * permitted it is then the applications responsibility to ensure that the
- * usage is compliant.
- */
+    /*
+     * If this flag is set the operations normally disabled in FIPS mode are
+     * permitted it is then the applications responsibility to ensure that the
+     * usage is compliant.
+     */
 
-#   define DH_FLAG_NON_FIPS_ALLOW                  0x0400
-#  endif
+#define DH_FLAG_NON_FIPS_ALLOW 0x0400
+#endif
 
-/* Already defined in ossl_typ.h */
-/* typedef struct dh_st DH; */
-/* typedef struct dh_method DH_METHOD; */
+    /* Already defined in ossl_typ.h */
+    /* typedef struct dh_st DH; */
+    /* typedef struct dh_method DH_METHOD; */
 
-DECLARE_ASN1_ITEM(DHparams)
+    DECLARE_ASN1_ITEM(DHparams)
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define DH_GENERATOR_2          2
-#   define DH_GENERATOR_3          3
-#   define DH_GENERATOR_5          5
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DH_GENERATOR_2 2
+#define DH_GENERATOR_3 3
+#define DH_GENERATOR_5 5
 
 /* DH_check error codes */
 /*
  * NB: These values must align with the equivalently named macros in
  * internal/ffc.h.
  */
-#   define DH_CHECK_P_NOT_PRIME            0x01
-#   define DH_CHECK_P_NOT_SAFE_PRIME       0x02
-#   define DH_UNABLE_TO_CHECK_GENERATOR    0x04
-#   define DH_NOT_SUITABLE_GENERATOR       0x08
-#   define DH_CHECK_Q_NOT_PRIME            0x10
-#   define DH_CHECK_INVALID_Q_VALUE        0x20
-#   define DH_CHECK_INVALID_J_VALUE        0x40
-#   define DH_MODULUS_TOO_SMALL            0x80
-#   define DH_MODULUS_TOO_LARGE            0x100
+#define DH_CHECK_P_NOT_PRIME 0x01
+#define DH_CHECK_P_NOT_SAFE_PRIME 0x02
+#define DH_UNABLE_TO_CHECK_GENERATOR 0x04
+#define DH_NOT_SUITABLE_GENERATOR 0x08
+#define DH_CHECK_Q_NOT_PRIME 0x10
+#define DH_CHECK_INVALID_Q_VALUE 0x20
+#define DH_CHECK_INVALID_J_VALUE 0x40
+#define DH_MODULUS_TOO_SMALL 0x80
+#define DH_MODULUS_TOO_LARGE 0x100
 
 /* DH_check_pub_key error codes */
-#   define DH_CHECK_PUBKEY_TOO_SMALL       0x01
-#   define DH_CHECK_PUBKEY_TOO_LARGE       0x02
-#   define DH_CHECK_PUBKEY_INVALID         0x04
+#define DH_CHECK_PUBKEY_TOO_SMALL 0x01
+#define DH_CHECK_PUBKEY_TOO_LARGE 0x02
+#define DH_CHECK_PUBKEY_INVALID 0x04
 
 /*
  * primes p where (p-1)/2 is prime too are called "safe"; we define this for
  * backward compatibility:
  */
-#   define DH_CHECK_P_NOT_STRONG_PRIME     DH_CHECK_P_NOT_SAFE_PRIME
-
-#   define d2i_DHparams_fp(fp, x) \
-        (DH *)ASN1_d2i_fp((char *(*)())DH_new, \
-                          (char *(*)())d2i_DHparams, \
-                          (fp), \
-                          (unsigned char **)(x))
-#   define i2d_DHparams_fp(fp, x) \
-        ASN1_i2d_fp(i2d_DHparams,(fp), (unsigned char *)(x))
-#   define d2i_DHparams_bio(bp, x) \
-        ASN1_d2i_bio_of(DH, DH_new, d2i_DHparams, bp, x)
-#   define i2d_DHparams_bio(bp, x) \
-        ASN1_i2d_bio_of(DH, i2d_DHparams, bp, x)
-
-#   define d2i_DHxparams_fp(fp,x) \
-        (DH *)ASN1_d2i_fp((char *(*)())DH_new, \
-                          (char *(*)())d2i_DHxparams, \
-                          (fp), \
-                          (unsigned char **)(x))
-#   define i2d_DHxparams_fp(fp, x) \
-        ASN1_i2d_fp(i2d_DHxparams,(fp), (unsigned char *)(x))
-#   define d2i_DHxparams_bio(bp, x) \
-        ASN1_d2i_bio_of(DH, DH_new, d2i_DHxparams, bp, x)
-#   define i2d_DHxparams_bio(bp, x) \
-        ASN1_i2d_bio_of(DH, i2d_DHxparams, bp, x)
-
-DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, DH, DHparams)
-
-OSSL_DEPRECATEDIN_3_0 const DH_METHOD *DH_OpenSSL(void);
-
-OSSL_DEPRECATEDIN_3_0 void DH_set_default_method(const DH_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 const DH_METHOD *DH_get_default_method(void);
-OSSL_DEPRECATEDIN_3_0 int DH_set_method(DH *dh, const DH_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 DH *DH_new_method(ENGINE *engine);
-
-OSSL_DEPRECATEDIN_3_0 DH *DH_new(void);
-OSSL_DEPRECATEDIN_3_0 void DH_free(DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_up_ref(DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_bits(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_size(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_security_bits(const DH *dh);
-
-#   define DH_get_ex_new_index(l, p, newf, dupf, freef) \
-        CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DH, l, p, newf, dupf, freef)
-
-OSSL_DEPRECATEDIN_3_0 int DH_set_ex_data(DH *d, int idx, void *arg);
-OSSL_DEPRECATEDIN_3_0 void *DH_get_ex_data(const DH *d, int idx);
-
-OSSL_DEPRECATEDIN_3_0 int DH_generate_parameters_ex(DH *dh, int prime_len,
-                                                    int generator,
-                                                    BN_GENCB *cb);
-
-OSSL_DEPRECATEDIN_3_0 int DH_check_params_ex(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_check_ex(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_check_pub_key_ex(const DH *dh, const BIGNUM *pub_key);
-OSSL_DEPRECATEDIN_3_0 int DH_check_params(const DH *dh, int *ret);
-OSSL_DEPRECATEDIN_3_0 int DH_check(const DH *dh, int *codes);
-OSSL_DEPRECATEDIN_3_0 int DH_check_pub_key(const DH *dh, const BIGNUM *pub_key,
-                                           int *codes);
-OSSL_DEPRECATEDIN_3_0 int DH_generate_key(DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_compute_key(unsigned char *key,
-                                         const BIGNUM *pub_key, DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_compute_key_padded(unsigned char *key,
-                                                const BIGNUM *pub_key, DH *dh);
-
-DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DH, DHparams)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DH, DHxparams)
-
-#   ifndef OPENSSL_NO_STDIO
-OSSL_DEPRECATEDIN_3_0 int DHparams_print_fp(FILE *fp, const DH *x);
-#   endif
-OSSL_DEPRECATEDIN_3_0 int DHparams_print(BIO *bp, const DH *x);
-
-/* RFC 5114 parameters */
-OSSL_DEPRECATEDIN_3_0 DH *DH_get_1024_160(void);
-OSSL_DEPRECATEDIN_3_0 DH *DH_get_2048_224(void);
-OSSL_DEPRECATEDIN_3_0 DH *DH_get_2048_256(void);
-
-/* Named parameters, currently RFC7919 and RFC3526 */
-OSSL_DEPRECATEDIN_3_0 DH *DH_new_by_nid(int nid);
-OSSL_DEPRECATEDIN_3_0 int DH_get_nid(const DH *dh);
-
-/* RFC2631 KDF */
-OSSL_DEPRECATEDIN_3_0 int DH_KDF_X9_42(unsigned char *out, size_t outlen,
-                                       const unsigned char *Z, size_t Zlen,
-                                       ASN1_OBJECT *key_oid,
-                                       const unsigned char *ukm,
-                                       size_t ukmlen, const EVP_MD *md);
-
-OSSL_DEPRECATEDIN_3_0 void DH_get0_pqg(const DH *dh, const BIGNUM **p,
-                                       const BIGNUM **q, const BIGNUM **g);
-OSSL_DEPRECATEDIN_3_0 int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g);
-OSSL_DEPRECATEDIN_3_0 void DH_get0_key(const DH *dh, const BIGNUM **pub_key,
-                                       const BIGNUM **priv_key);
-OSSL_DEPRECATEDIN_3_0 int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_p(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_q(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_g(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_priv_key(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DH_get0_pub_key(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 void DH_clear_flags(DH *dh, int flags);
-OSSL_DEPRECATEDIN_3_0 int DH_test_flags(const DH *dh, int flags);
-OSSL_DEPRECATEDIN_3_0 void DH_set_flags(DH *dh, int flags);
-OSSL_DEPRECATEDIN_3_0 ENGINE *DH_get0_engine(DH *d);
-OSSL_DEPRECATEDIN_3_0 long DH_get_length(const DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_set_length(DH *dh, long length);
-
-OSSL_DEPRECATEDIN_3_0 DH_METHOD *DH_meth_new(const char *name, int flags);
-OSSL_DEPRECATEDIN_3_0 void DH_meth_free(DH_METHOD *dhm);
-OSSL_DEPRECATEDIN_3_0 DH_METHOD *DH_meth_dup(const DH_METHOD *dhm);
-OSSL_DEPRECATEDIN_3_0 const char *DH_meth_get0_name(const DH_METHOD *dhm);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set1_name(DH_METHOD *dhm, const char *name);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_get_flags(const DH_METHOD *dhm);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set_flags(DH_METHOD *dhm, int flags);
-OSSL_DEPRECATEDIN_3_0 void *DH_meth_get0_app_data(const DH_METHOD *dhm);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data);
-OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set_generate_key(DH_METHOD *dhm,
-                                                   int (*generate_key) (DH *));
-OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_compute_key(const DH_METHOD *dhm))
-                                                   (unsigned char *key,
-                                                    const BIGNUM *pub_key,
-                                                    DH *dh);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set_compute_key(DH_METHOD *dhm,
-                                                  int (*compute_key)
-                                                  (unsigned char *key,
-                                                   const BIGNUM *pub_key,
-                                                   DH *dh));
-OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm))
-                                                   (const DH *, BIGNUM *,
-                                                    const BIGNUM *,
-                                                    const BIGNUM *,
-                                                    const BIGNUM *, BN_CTX *,
-                                                    BN_MONT_CTX *);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set_bn_mod_exp(DH_METHOD *dhm,
-                                                 int (*bn_mod_exp)
-                                                 (const DH *, BIGNUM *,
-                                                  const BIGNUM *, const BIGNUM *,
-                                                  const BIGNUM *, BN_CTX *,
-                                                  BN_MONT_CTX *));
-OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *));
-OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *));
-OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_generate_params(const DH_METHOD *dhm))
-                                                        (DH *, int, int,
-                                                         BN_GENCB *);
-OSSL_DEPRECATEDIN_3_0 int DH_meth_set_generate_params(DH_METHOD *dhm,
-                                                      int (*generate_params)
-                                                      (DH *, int, int,
-                                                       BN_GENCB *));
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-#  ifndef OPENSSL_NO_DEPRECATED_0_9_8
-OSSL_DEPRECATEDIN_0_9_8 DH *DH_generate_parameters(int prime_len, int generator,
-                                                   void (*callback) (int, int,
-                                                                void *),
-                                                   void *cb_arg);
-#  endif
-
-# endif
-# ifdef  __cplusplus
+#define DH_CHECK_P_NOT_STRONG_PRIME DH_CHECK_P_NOT_SAFE_PRIME
+
+#define d2i_DHparams_fp(fp, x) \
+    (DH*)ASN1_d2i_fp((char* (*)())DH_new, (char* (*)())d2i_DHparams, (fp), (unsigned char**)(x))
+#define i2d_DHparams_fp(fp, x) \
+    ASN1_i2d_fp(i2d_DHparams, (fp), (unsigned char*)(x))
+#define d2i_DHparams_bio(bp, x) \
+    ASN1_d2i_bio_of(DH, DH_new, d2i_DHparams, bp, x)
+#define i2d_DHparams_bio(bp, x) \
+    ASN1_i2d_bio_of(DH, i2d_DHparams, bp, x)
+
+#define d2i_DHxparams_fp(fp, x) \
+    (DH*)ASN1_d2i_fp((char* (*)())DH_new, (char* (*)())d2i_DHxparams, (fp), (unsigned char**)(x))
+#define i2d_DHxparams_fp(fp, x) \
+    ASN1_i2d_fp(i2d_DHxparams, (fp), (unsigned char*)(x))
+#define d2i_DHxparams_bio(bp, x) \
+    ASN1_d2i_bio_of(DH, DH_new, d2i_DHxparams, bp, x)
+#define i2d_DHxparams_bio(bp, x) \
+    ASN1_i2d_bio_of(DH, i2d_DHxparams, bp, x)
+
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, DH, DHparams)
+
+        OSSL_DEPRECATEDIN_3_0 const DH_METHOD* DH_OpenSSL(void);
+
+    OSSL_DEPRECATEDIN_3_0 void DH_set_default_method(const DH_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 const DH_METHOD* DH_get_default_method(void);
+    OSSL_DEPRECATEDIN_3_0 int DH_set_method(DH* dh, const DH_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 DH* DH_new_method(ENGINE* engine);
+
+    OSSL_DEPRECATEDIN_3_0 DH* DH_new(void);
+    OSSL_DEPRECATEDIN_3_0 void DH_free(DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_up_ref(DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_bits(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_size(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_security_bits(const DH* dh);
+
+#define DH_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DH, l, p, newf, dupf, freef)
+
+    OSSL_DEPRECATEDIN_3_0 int DH_set_ex_data(DH* d, int idx, void* arg);
+    OSSL_DEPRECATEDIN_3_0 void* DH_get_ex_data(const DH* d, int idx);
+
+    OSSL_DEPRECATEDIN_3_0 int DH_generate_parameters_ex(DH* dh, int prime_len, int generator, BN_GENCB* cb);
+
+    OSSL_DEPRECATEDIN_3_0 int DH_check_params_ex(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_check_ex(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_check_pub_key_ex(const DH* dh, const BIGNUM* pub_key);
+    OSSL_DEPRECATEDIN_3_0 int DH_check_params(const DH* dh, int* ret);
+    OSSL_DEPRECATEDIN_3_0 int DH_check(const DH* dh, int* codes);
+    OSSL_DEPRECATEDIN_3_0 int DH_check_pub_key(const DH* dh, const BIGNUM* pub_key, int* codes);
+    OSSL_DEPRECATEDIN_3_0 int DH_generate_key(DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_compute_key(unsigned char* key, const BIGNUM* pub_key, DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_compute_key_padded(unsigned char* key, const BIGNUM* pub_key, DH* dh);
+
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DH, DHparams)
+        DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DH, DHxparams)
+
+#ifndef OPENSSL_NO_STDIO
+            OSSL_DEPRECATEDIN_3_0 int DHparams_print_fp(FILE* fp, const DH* x);
+#endif
+    OSSL_DEPRECATEDIN_3_0 int DHparams_print(BIO* bp, const DH* x);
+
+    /* RFC 5114 parameters */
+    OSSL_DEPRECATEDIN_3_0 DH* DH_get_1024_160(void);
+    OSSL_DEPRECATEDIN_3_0 DH* DH_get_2048_224(void);
+    OSSL_DEPRECATEDIN_3_0 DH* DH_get_2048_256(void);
+
+    /* Named parameters, currently RFC7919 and RFC3526 */
+    OSSL_DEPRECATEDIN_3_0 DH* DH_new_by_nid(int nid);
+    OSSL_DEPRECATEDIN_3_0 int DH_get_nid(const DH* dh);
+
+    /* RFC2631 KDF */
+    OSSL_DEPRECATEDIN_3_0 int DH_KDF_X9_42(unsigned char* out, size_t outlen, const unsigned char* Z, size_t Zlen, ASN1_OBJECT* key_oid, const unsigned char* ukm, size_t ukmlen, const EVP_MD* md);
+
+    OSSL_DEPRECATEDIN_3_0 void DH_get0_pqg(const DH* dh, const BIGNUM** p, const BIGNUM** q, const BIGNUM** g);
+    OSSL_DEPRECATEDIN_3_0 int DH_set0_pqg(DH* dh, BIGNUM* p, BIGNUM* q, BIGNUM* g);
+    OSSL_DEPRECATEDIN_3_0 void DH_get0_key(const DH* dh, const BIGNUM** pub_key, const BIGNUM** priv_key);
+    OSSL_DEPRECATEDIN_3_0 int DH_set0_key(DH* dh, BIGNUM* pub_key, BIGNUM* priv_key);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DH_get0_p(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DH_get0_q(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DH_get0_g(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DH_get0_priv_key(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DH_get0_pub_key(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 void DH_clear_flags(DH* dh, int flags);
+    OSSL_DEPRECATEDIN_3_0 int DH_test_flags(const DH* dh, int flags);
+    OSSL_DEPRECATEDIN_3_0 void DH_set_flags(DH* dh, int flags);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* DH_get0_engine(DH* d);
+    OSSL_DEPRECATEDIN_3_0 long DH_get_length(const DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_set_length(DH* dh, long length);
+
+    OSSL_DEPRECATEDIN_3_0 DH_METHOD* DH_meth_new(const char* name, int flags);
+    OSSL_DEPRECATEDIN_3_0 void DH_meth_free(DH_METHOD* dhm);
+    OSSL_DEPRECATEDIN_3_0 DH_METHOD* DH_meth_dup(const DH_METHOD* dhm);
+    OSSL_DEPRECATEDIN_3_0 const char* DH_meth_get0_name(const DH_METHOD* dhm);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set1_name(DH_METHOD* dhm, const char* name);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_get_flags(const DH_METHOD* dhm);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set_flags(DH_METHOD* dhm, int flags);
+    OSSL_DEPRECATEDIN_3_0 void* DH_meth_get0_app_data(const DH_METHOD* dhm);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set0_app_data(DH_METHOD* dhm, void* app_data);
+    OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_generate_key(const DH_METHOD* dhm))(DH*);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set_generate_key(DH_METHOD* dhm, int (*generate_key)(DH*));
+    OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_compute_key(const DH_METHOD* dhm))(unsigned char* key, const BIGNUM* pub_key, DH* dh);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set_compute_key(DH_METHOD* dhm, int (*compute_key)(unsigned char* key, const BIGNUM* pub_key, DH* dh));
+    OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_bn_mod_exp(const DH_METHOD* dhm))(const DH*, BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*, BN_MONT_CTX*);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set_bn_mod_exp(DH_METHOD* dhm, int (*bn_mod_exp)(const DH*, BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*, BN_MONT_CTX*));
+    OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_init(const DH_METHOD* dhm))(DH*);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set_init(DH_METHOD* dhm, int (*init)(DH*));
+    OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_finish(const DH_METHOD* dhm))(DH*);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set_finish(DH_METHOD* dhm, int (*finish)(DH*));
+    OSSL_DEPRECATEDIN_3_0 int (*DH_meth_get_generate_params(const DH_METHOD* dhm))(DH*, int, int, BN_GENCB*);
+    OSSL_DEPRECATEDIN_3_0 int DH_meth_set_generate_params(DH_METHOD* dhm, int (*generate_params)(DH*, int, int, BN_GENCB*));
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+    OSSL_DEPRECATEDIN_0_9_8 DH* DH_generate_parameters(int prime_len, int generator, void (*callback)(int, int, void*), void* cb_arg);
+#endif
+
+#endif
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/dherr.h b/CAPI/cpp/grpc/include/openssl/dherr.h
index 5d2a762..1e71f95 100644
--- a/CAPI/cpp/grpc/include/openssl/dherr.h
+++ b/CAPI/cpp/grpc/include/openssl/dherr.h
@@ -9,49 +9,47 @@
  */
 
 #ifndef OPENSSL_DHERR_H
-# define OPENSSL_DHERR_H
-# pragma once
+#define OPENSSL_DHERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_DH
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_DH
 
 /*
  * DH reason codes.
  */
-#  define DH_R_BAD_FFC_PARAMETERS                          127
-#  define DH_R_BAD_GENERATOR                               101
-#  define DH_R_BN_DECODE_ERROR                             109
-#  define DH_R_BN_ERROR                                    106
-#  define DH_R_CHECK_INVALID_J_VALUE                       115
-#  define DH_R_CHECK_INVALID_Q_VALUE                       116
-#  define DH_R_CHECK_PUBKEY_INVALID                        122
-#  define DH_R_CHECK_PUBKEY_TOO_LARGE                      123
-#  define DH_R_CHECK_PUBKEY_TOO_SMALL                      124
-#  define DH_R_CHECK_P_NOT_PRIME                           117
-#  define DH_R_CHECK_P_NOT_SAFE_PRIME                      118
-#  define DH_R_CHECK_Q_NOT_PRIME                           119
-#  define DH_R_DECODE_ERROR                                104
-#  define DH_R_INVALID_PARAMETER_NAME                      110
-#  define DH_R_INVALID_PARAMETER_NID                       114
-#  define DH_R_INVALID_PUBKEY                              102
-#  define DH_R_INVALID_SECRET                              128
-#  define DH_R_KDF_PARAMETER_ERROR                         112
-#  define DH_R_KEYS_NOT_SET                                108
-#  define DH_R_MISSING_PUBKEY                              125
-#  define DH_R_MODULUS_TOO_LARGE                           103
-#  define DH_R_MODULUS_TOO_SMALL                           126
-#  define DH_R_NOT_SUITABLE_GENERATOR                      120
-#  define DH_R_NO_PARAMETERS_SET                           107
-#  define DH_R_NO_PRIVATE_VALUE                            100
-#  define DH_R_PARAMETER_ENCODING_ERROR                    105
-#  define DH_R_PEER_KEY_ERROR                              111
-#  define DH_R_SHARED_INFO_ERROR                           113
-#  define DH_R_UNABLE_TO_CHECK_GENERATOR                   121
+#define DH_R_BAD_FFC_PARAMETERS 127
+#define DH_R_BAD_GENERATOR 101
+#define DH_R_BN_DECODE_ERROR 109
+#define DH_R_BN_ERROR 106
+#define DH_R_CHECK_INVALID_J_VALUE 115
+#define DH_R_CHECK_INVALID_Q_VALUE 116
+#define DH_R_CHECK_PUBKEY_INVALID 122
+#define DH_R_CHECK_PUBKEY_TOO_LARGE 123
+#define DH_R_CHECK_PUBKEY_TOO_SMALL 124
+#define DH_R_CHECK_P_NOT_PRIME 117
+#define DH_R_CHECK_P_NOT_SAFE_PRIME 118
+#define DH_R_CHECK_Q_NOT_PRIME 119
+#define DH_R_DECODE_ERROR 104
+#define DH_R_INVALID_PARAMETER_NAME 110
+#define DH_R_INVALID_PARAMETER_NID 114
+#define DH_R_INVALID_PUBKEY 102
+#define DH_R_INVALID_SECRET 128
+#define DH_R_KDF_PARAMETER_ERROR 112
+#define DH_R_KEYS_NOT_SET 108
+#define DH_R_MISSING_PUBKEY 125
+#define DH_R_MODULUS_TOO_LARGE 103
+#define DH_R_MODULUS_TOO_SMALL 126
+#define DH_R_NOT_SUITABLE_GENERATOR 120
+#define DH_R_NO_PARAMETERS_SET 107
+#define DH_R_NO_PRIVATE_VALUE 100
+#define DH_R_PARAMETER_ENCODING_ERROR 105
+#define DH_R_PEER_KEY_ERROR 111
+#define DH_R_SHARED_INFO_ERROR 113
+#define DH_R_UNABLE_TO_CHECK_GENERATOR 121
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/dsa.h b/CAPI/cpp/grpc/include/openssl/dsa.h
index 5c0e4cd..db888c0 100644
--- a/CAPI/cpp/grpc/include/openssl/dsa.h
+++ b/CAPI/cpp/grpc/include/openssl/dsa.h
@@ -8,268 +8,216 @@
  */
 
 #ifndef OPENSSL_DSA_H
-# define OPENSSL_DSA_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_DSA_H
-# endif
-
-# include <openssl/opensslconf.h>
-# include <openssl/types.h>
-
-# ifdef  __cplusplus
-extern "C" {
-# endif
-
-# include <stdlib.h>
-
-int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX *ctx, int nbits);
-int EVP_PKEY_CTX_set_dsa_paramgen_q_bits(EVP_PKEY_CTX *ctx, int qbits);
-int EVP_PKEY_CTX_set_dsa_paramgen_md_props(EVP_PKEY_CTX *ctx,
-                                           const char *md_name,
-                                           const char *md_properties);
-int EVP_PKEY_CTX_set_dsa_paramgen_gindex(EVP_PKEY_CTX *ctx, int gindex);
-int EVP_PKEY_CTX_set_dsa_paramgen_type(EVP_PKEY_CTX *ctx, const char *name);
-int EVP_PKEY_CTX_set_dsa_paramgen_seed(EVP_PKEY_CTX *ctx,
-                                       const unsigned char *seed,
-                                       size_t seedlen);
-int EVP_PKEY_CTX_set_dsa_paramgen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
-
-# define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS         (EVP_PKEY_ALG_CTRL + 1)
-# define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS       (EVP_PKEY_ALG_CTRL + 2)
-# define EVP_PKEY_CTRL_DSA_PARAMGEN_MD           (EVP_PKEY_ALG_CTRL + 3)
-
-# ifndef OPENSSL_NO_DSA
-#  include <openssl/e_os2.h>
-#  include <openssl/asn1.h>
-#  include <openssl/bio.h>
-#  include <openssl/crypto.h>
-#  include <openssl/bn.h>
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#   include <openssl/dh.h>
-#  endif
-#  include <openssl/dsaerr.h>
-
-#  ifndef OPENSSL_DSA_MAX_MODULUS_BITS
-#   define OPENSSL_DSA_MAX_MODULUS_BITS   10000
-#  endif
-
-#  define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 1024
-
-typedef struct DSA_SIG_st DSA_SIG;
-DSA_SIG *DSA_SIG_new(void);
-void DSA_SIG_free(DSA_SIG *a);
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(DSA_SIG, DSA_SIG)
-void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
-int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s);
-
-
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define OPENSSL_DSA_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_DSA_H
+#endif
+
+#include <openssl/opensslconf.h>
+#include <openssl/types.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdlib.h>
+
+    int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX* ctx, int nbits);
+    int EVP_PKEY_CTX_set_dsa_paramgen_q_bits(EVP_PKEY_CTX* ctx, int qbits);
+    int EVP_PKEY_CTX_set_dsa_paramgen_md_props(EVP_PKEY_CTX* ctx, const char* md_name, const char* md_properties);
+    int EVP_PKEY_CTX_set_dsa_paramgen_gindex(EVP_PKEY_CTX* ctx, int gindex);
+    int EVP_PKEY_CTX_set_dsa_paramgen_type(EVP_PKEY_CTX* ctx, const char* name);
+    int EVP_PKEY_CTX_set_dsa_paramgen_seed(EVP_PKEY_CTX* ctx, const unsigned char* seed, size_t seedlen);
+    int EVP_PKEY_CTX_set_dsa_paramgen_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
+
+#define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS (EVP_PKEY_ALG_CTRL + 1)
+#define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS (EVP_PKEY_ALG_CTRL + 2)
+#define EVP_PKEY_CTRL_DSA_PARAMGEN_MD (EVP_PKEY_ALG_CTRL + 3)
+
+#ifndef OPENSSL_NO_DSA
+#include <openssl/e_os2.h>
+#include <openssl/asn1.h>
+#include <openssl/bio.h>
+#include <openssl/crypto.h>
+#include <openssl/bn.h>
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/dh.h>
+#endif
+#include <openssl/dsaerr.h>
+
+#ifndef OPENSSL_DSA_MAX_MODULUS_BITS
+#define OPENSSL_DSA_MAX_MODULUS_BITS 10000
+#endif
+
+#define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 1024
+
+    typedef struct DSA_SIG_st DSA_SIG;
+    DSA_SIG* DSA_SIG_new(void);
+    void DSA_SIG_free(DSA_SIG* a);
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(DSA_SIG, DSA_SIG) void DSA_SIG_get0(const DSA_SIG* sig, const BIGNUM** pr, const BIGNUM** ps);
+    int DSA_SIG_set0(DSA_SIG* sig, BIGNUM* r, BIGNUM* s);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
 /*
  * Does nothing. Previously this switched off constant time behaviour.
  */
-#   define DSA_FLAG_NO_EXP_CONSTTIME       0x00
-#  endif
+#define DSA_FLAG_NO_EXP_CONSTTIME 0x00
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DSA_FLAG_CACHE_MONT_P 0x01
+
+    /*
+     * If this flag is set the DSA method is FIPS compliant and can be used in
+     * FIPS mode. This is set in the validated module method. If an application
+     * sets this flag in its own methods it is its responsibility to ensure the
+     * result is compliant.
+     */
+
+#define DSA_FLAG_FIPS_METHOD 0x0400
+
+    /*
+     * If this flag is set the operations normally disabled in FIPS mode are
+     * permitted it is then the applications responsibility to ensure that the
+     * usage is compliant.
+     */
+
+#define DSA_FLAG_NON_FIPS_ALLOW 0x0400
+#define DSA_FLAG_FIPS_CHECKED 0x0800
+
+    /* Already defined in ossl_typ.h */
+    /* typedef struct dsa_st DSA; */
+    /* typedef struct dsa_method DSA_METHOD; */
+
+#define d2i_DSAparams_fp(fp, x) \
+    (DSA*)ASN1_d2i_fp((char* (*)())DSA_new, (char* (*)())d2i_DSAparams, (fp), (unsigned char**)(x))
+#define i2d_DSAparams_fp(fp, x) \
+    ASN1_i2d_fp(i2d_DSAparams, (fp), (unsigned char*)(x))
+#define d2i_DSAparams_bio(bp, x) \
+    ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSAparams, bp, x)
+#define i2d_DSAparams_bio(bp, x) \
+    ASN1_i2d_bio_of(DSA, i2d_DSAparams, bp, x)
+
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, DSA, DSAparams)
+        OSSL_DEPRECATEDIN_3_0 DSA_SIG* DSA_do_sign(const unsigned char* dgst, int dlen, DSA* dsa);
+    OSSL_DEPRECATEDIN_3_0 int DSA_do_verify(const unsigned char* dgst, int dgst_len, DSA_SIG* sig, DSA* dsa);
+
+    OSSL_DEPRECATEDIN_3_0 const DSA_METHOD* DSA_OpenSSL(void);
+
+    OSSL_DEPRECATEDIN_3_0 void DSA_set_default_method(const DSA_METHOD*);
+    OSSL_DEPRECATEDIN_3_0 const DSA_METHOD* DSA_get_default_method(void);
+    OSSL_DEPRECATEDIN_3_0 int DSA_set_method(DSA* dsa, const DSA_METHOD*);
+    OSSL_DEPRECATEDIN_3_0 const DSA_METHOD* DSA_get_method(DSA* d);
+
+    OSSL_DEPRECATEDIN_3_0 DSA* DSA_new(void);
+    OSSL_DEPRECATEDIN_3_0 DSA* DSA_new_method(ENGINE* engine);
+    OSSL_DEPRECATEDIN_3_0 void DSA_free(DSA* r);
+    /* "up" the DSA object's reference count */
+    OSSL_DEPRECATEDIN_3_0 int DSA_up_ref(DSA* r);
+    OSSL_DEPRECATEDIN_3_0 int DSA_size(const DSA*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_bits(const DSA* d);
+    OSSL_DEPRECATEDIN_3_0 int DSA_security_bits(const DSA* d);
+    /* next 4 return -1 on error */
+    OSSL_DEPRECATEDIN_3_0 int DSA_sign_setup(DSA* dsa, BN_CTX* ctx_in, BIGNUM** kinvp, BIGNUM** rp);
+    OSSL_DEPRECATEDIN_3_0 int DSA_sign(int type, const unsigned char* dgst, int dlen, unsigned char* sig, unsigned int* siglen, DSA* dsa);
+    OSSL_DEPRECATEDIN_3_0 int DSA_verify(int type, const unsigned char* dgst, int dgst_len, const unsigned char* sigbuf, int siglen, DSA* dsa);
+
+#define DSA_get_ex_new_index(l, p, newf, dupf, freef) \
+    CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, l, p, newf, dupf, freef)
+    OSSL_DEPRECATEDIN_3_0 int DSA_set_ex_data(DSA* d, int idx, void* arg);
+    OSSL_DEPRECATEDIN_3_0 void* DSA_get_ex_data(const DSA* d, int idx);
+
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DSA, DSAPublicKey)
+        DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DSA, DSAPrivateKey)
+            DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DSA, DSAparams)
+#endif
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define DSA_FLAG_CACHE_MONT_P   0x01
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+        /* Deprecated version */
+        OSSL_DEPRECATEDIN_0_9_8
+        DSA* DSA_generate_parameters(int bits, unsigned char* seed, int seed_len, int* counter_ret, unsigned long* h_ret, void (*callback)(int, int, void*), void* cb_arg);
+#endif
 
-/*
- * If this flag is set the DSA method is FIPS compliant and can be used in
- * FIPS mode. This is set in the validated module method. If an application
- * sets this flag in its own methods it is its responsibility to ensure the
- * result is compliant.
- */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /* New version */
+    OSSL_DEPRECATEDIN_3_0 int DSA_generate_parameters_ex(DSA* dsa, int bits, const unsigned char* seed, int seed_len, int* counter_ret, unsigned long* h_ret, BN_GENCB* cb);
 
-#   define DSA_FLAG_FIPS_METHOD                    0x0400
+    OSSL_DEPRECATEDIN_3_0 int DSA_generate_key(DSA* a);
 
-/*
- * If this flag is set the operations normally disabled in FIPS mode are
- * permitted it is then the applications responsibility to ensure that the
- * usage is compliant.
- */
+    OSSL_DEPRECATEDIN_3_0 int DSAparams_print(BIO* bp, const DSA* x);
+    OSSL_DEPRECATEDIN_3_0 int DSA_print(BIO* bp, const DSA* x, int off);
+#ifndef OPENSSL_NO_STDIO
+    OSSL_DEPRECATEDIN_3_0 int DSAparams_print_fp(FILE* fp, const DSA* x);
+    OSSL_DEPRECATEDIN_3_0 int DSA_print_fp(FILE* bp, const DSA* x, int off);
+#endif
 
-#   define DSA_FLAG_NON_FIPS_ALLOW                 0x0400
-#   define DSA_FLAG_FIPS_CHECKED                   0x0800
-
-/* Already defined in ossl_typ.h */
-/* typedef struct dsa_st DSA; */
-/* typedef struct dsa_method DSA_METHOD; */
-
-#   define d2i_DSAparams_fp(fp, x) \
-        (DSA *)ASN1_d2i_fp((char *(*)())DSA_new, \
-                           (char *(*)())d2i_DSAparams, (fp), \
-                           (unsigned char **)(x))
-#   define i2d_DSAparams_fp(fp, x) \
-        ASN1_i2d_fp(i2d_DSAparams, (fp), (unsigned char *)(x))
-#   define d2i_DSAparams_bio(bp, x) \
-        ASN1_d2i_bio_of(DSA, DSA_new, d2i_DSAparams, bp, x)
-#   define i2d_DSAparams_bio(bp, x) \
-        ASN1_i2d_bio_of(DSA, i2d_DSAparams, bp, x)
-
-DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, DSA, DSAparams)
-OSSL_DEPRECATEDIN_3_0 DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen,
-                                           DSA *dsa);
-OSSL_DEPRECATEDIN_3_0 int DSA_do_verify(const unsigned char *dgst, int dgst_len,
-                                        DSA_SIG *sig, DSA *dsa);
-
-OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_OpenSSL(void);
-
-OSSL_DEPRECATEDIN_3_0 void DSA_set_default_method(const DSA_METHOD *);
-OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_get_default_method(void);
-OSSL_DEPRECATEDIN_3_0 int DSA_set_method(DSA *dsa, const DSA_METHOD *);
-OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *DSA_get_method(DSA *d);
-
-OSSL_DEPRECATEDIN_3_0 DSA *DSA_new(void);
-OSSL_DEPRECATEDIN_3_0 DSA *DSA_new_method(ENGINE *engine);
-OSSL_DEPRECATEDIN_3_0 void DSA_free(DSA *r);
-/* "up" the DSA object's reference count */
-OSSL_DEPRECATEDIN_3_0 int DSA_up_ref(DSA *r);
-OSSL_DEPRECATEDIN_3_0 int DSA_size(const DSA *);
-OSSL_DEPRECATEDIN_3_0 int DSA_bits(const DSA *d);
-OSSL_DEPRECATEDIN_3_0 int DSA_security_bits(const DSA *d);
-        /* next 4 return -1 on error */
-OSSL_DEPRECATEDIN_3_0 int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in,
-                                         BIGNUM **kinvp, BIGNUM **rp);
-OSSL_DEPRECATEDIN_3_0 int DSA_sign(int type, const unsigned char *dgst,
-                                   int dlen, unsigned char *sig,
-                                   unsigned int *siglen, DSA *dsa);
-OSSL_DEPRECATEDIN_3_0 int DSA_verify(int type, const unsigned char *dgst,
-                                     int dgst_len, const unsigned char *sigbuf,
-                                     int siglen, DSA *dsa);
-
-#   define DSA_get_ex_new_index(l, p, newf, dupf, freef) \
-        CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, l, p, newf, dupf, freef)
-OSSL_DEPRECATEDIN_3_0 int DSA_set_ex_data(DSA *d, int idx, void *arg);
-OSSL_DEPRECATEDIN_3_0 void *DSA_get_ex_data(const DSA *d, int idx);
-
-DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
-                                        DSA, DSAPublicKey)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
-                                        DSA, DSAPrivateKey)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,
-                                        DSA, DSAparams)
-#  endif
-
-#  ifndef OPENSSL_NO_DEPRECATED_0_9_8
-/* Deprecated version */
-OSSL_DEPRECATEDIN_0_9_8
-DSA *DSA_generate_parameters(int bits, unsigned char *seed, int seed_len,
-                             int *counter_ret, unsigned long *h_ret,
-                             void (*callback) (int, int, void *),
-                             void *cb_arg);
-#  endif
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/* New version */
-OSSL_DEPRECATEDIN_3_0 int DSA_generate_parameters_ex(DSA *dsa, int bits,
-                                                     const unsigned char *seed,
-                                                     int seed_len,
-                                                     int *counter_ret,
-                                                     unsigned long *h_ret,
-                                                     BN_GENCB *cb);
-
-OSSL_DEPRECATEDIN_3_0 int DSA_generate_key(DSA *a);
-
-OSSL_DEPRECATEDIN_3_0 int DSAparams_print(BIO *bp, const DSA *x);
-OSSL_DEPRECATEDIN_3_0 int DSA_print(BIO *bp, const DSA *x, int off);
-#   ifndef OPENSSL_NO_STDIO
-OSSL_DEPRECATEDIN_3_0 int DSAparams_print_fp(FILE *fp, const DSA *x);
-OSSL_DEPRECATEDIN_3_0 int DSA_print_fp(FILE *bp, const DSA *x, int off);
-#   endif
-
-#   define DSS_prime_checks 64
+#define DSS_prime_checks 64
 /*
  * Primality test according to FIPS PUB 186-4, Appendix C.3. Since we only
  * have one value here we set the number of checks to 64 which is the 128 bit
  * security level that is the highest level and valid for creating a 3072 bit
  * DSA key.
  */
-#   define DSA_is_prime(n, callback, cb_arg) \
-            BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg)
+#define DSA_is_prime(n, callback, cb_arg) \
+    BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg)
+
+#ifndef OPENSSL_NO_DH
+    /*
+     * Convert DSA structure (key or just parameters) into DH structure (be
+     * careful to avoid small subgroup attacks when using this!)
+     */
+    OSSL_DEPRECATEDIN_3_0 DH* DSA_dup_DH(const DSA* r);
+#endif
 
-#   ifndef OPENSSL_NO_DH
-/*
- * Convert DSA structure (key or just parameters) into DH structure (be
- * careful to avoid small subgroup attacks when using this!)
- */
-OSSL_DEPRECATEDIN_3_0 DH *DSA_dup_DH(const DSA *r);
-#   endif
-
-OSSL_DEPRECATEDIN_3_0 void DSA_get0_pqg(const DSA *d, const BIGNUM **p,
-                                        const BIGNUM **q, const BIGNUM **g);
-OSSL_DEPRECATEDIN_3_0 int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g);
-OSSL_DEPRECATEDIN_3_0 void DSA_get0_key(const DSA *d, const BIGNUM **pub_key,
-                                        const BIGNUM **priv_key);
-OSSL_DEPRECATEDIN_3_0 int DSA_set0_key(DSA *d, BIGNUM *pub_key,
-                                       BIGNUM *priv_key);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_p(const DSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_q(const DSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_g(const DSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_pub_key(const DSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *DSA_get0_priv_key(const DSA *d);
-OSSL_DEPRECATEDIN_3_0 void DSA_clear_flags(DSA *d, int flags);
-OSSL_DEPRECATEDIN_3_0 int DSA_test_flags(const DSA *d, int flags);
-OSSL_DEPRECATEDIN_3_0 void DSA_set_flags(DSA *d, int flags);
-OSSL_DEPRECATEDIN_3_0 ENGINE *DSA_get0_engine(DSA *d);
-
-OSSL_DEPRECATEDIN_3_0 DSA_METHOD *DSA_meth_new(const char *name, int flags);
-OSSL_DEPRECATEDIN_3_0 void DSA_meth_free(DSA_METHOD *dsam);
-OSSL_DEPRECATEDIN_3_0 DSA_METHOD *DSA_meth_dup(const DSA_METHOD *dsam);
-OSSL_DEPRECATEDIN_3_0 const char *DSA_meth_get0_name(const DSA_METHOD *dsam);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set1_name(DSA_METHOD *dsam,
-                                             const char *name);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_get_flags(const DSA_METHOD *dsam);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_flags(DSA_METHOD *dsam, int flags);
-OSSL_DEPRECATEDIN_3_0 void *DSA_meth_get0_app_data(const DSA_METHOD *dsam);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set0_app_data(DSA_METHOD *dsam,
-                                                 void *app_data);
-OSSL_DEPRECATEDIN_3_0 DSA_SIG *(*DSA_meth_get_sign(const DSA_METHOD *dsam))
-        (const unsigned char *, int, DSA *);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_sign(DSA_METHOD *dsam,
-                       DSA_SIG *(*sign) (const unsigned char *, int, DSA *));
-OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_sign_setup(const DSA_METHOD *dsam))
-        (DSA *, BN_CTX *, BIGNUM **, BIGNUM **);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_sign_setup(DSA_METHOD *dsam,
-        int (*sign_setup) (DSA *, BN_CTX *, BIGNUM **, BIGNUM **));
-OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_verify(const DSA_METHOD *dsam))
-        (const unsigned char *, int, DSA_SIG *, DSA *);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_verify(DSA_METHOD *dsam,
-    int (*verify) (const unsigned char *, int, DSA_SIG *, DSA *));
-OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_mod_exp(const DSA_METHOD *dsam))
-        (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
-         const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_mod_exp(DSA_METHOD *dsam,
-    int (*mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
-                    const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *,
-                    BN_MONT_CTX *));
-OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD *dsam))
-    (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
-     BN_CTX *, BN_MONT_CTX *);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_bn_mod_exp(DSA_METHOD *dsam,
-    int (*bn_mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
-                       const BIGNUM *, BN_CTX *, BN_MONT_CTX *));
-OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_init(const DSA_METHOD *dsam))(DSA *);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_init(DSA_METHOD *dsam,
-                                            int (*init)(DSA *));
-OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_finish(const DSA_METHOD *dsam))(DSA *);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_finish(DSA_METHOD *dsam,
-                                              int (*finish)(DSA *));
-OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_paramgen(const DSA_METHOD *dsam))
-        (DSA *, int, const unsigned char *, int, int *, unsigned long *,
-         BN_GENCB *);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_paramgen(DSA_METHOD *dsam,
-        int (*paramgen) (DSA *, int, const unsigned char *, int, int *,
-                         unsigned long *, BN_GENCB *));
-OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_keygen(const DSA_METHOD *dsam))(DSA *);
-OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_keygen(DSA_METHOD *dsam,
-                                              int (*keygen) (DSA *));
-
-#  endif
-# endif
-# ifdef  __cplusplus
+    OSSL_DEPRECATEDIN_3_0 void DSA_get0_pqg(const DSA* d, const BIGNUM** p, const BIGNUM** q, const BIGNUM** g);
+    OSSL_DEPRECATEDIN_3_0 int DSA_set0_pqg(DSA* d, BIGNUM* p, BIGNUM* q, BIGNUM* g);
+    OSSL_DEPRECATEDIN_3_0 void DSA_get0_key(const DSA* d, const BIGNUM** pub_key, const BIGNUM** priv_key);
+    OSSL_DEPRECATEDIN_3_0 int DSA_set0_key(DSA* d, BIGNUM* pub_key, BIGNUM* priv_key);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DSA_get0_p(const DSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DSA_get0_q(const DSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DSA_get0_g(const DSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DSA_get0_pub_key(const DSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* DSA_get0_priv_key(const DSA* d);
+    OSSL_DEPRECATEDIN_3_0 void DSA_clear_flags(DSA* d, int flags);
+    OSSL_DEPRECATEDIN_3_0 int DSA_test_flags(const DSA* d, int flags);
+    OSSL_DEPRECATEDIN_3_0 void DSA_set_flags(DSA* d, int flags);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* DSA_get0_engine(DSA* d);
+
+    OSSL_DEPRECATEDIN_3_0 DSA_METHOD* DSA_meth_new(const char* name, int flags);
+    OSSL_DEPRECATEDIN_3_0 void DSA_meth_free(DSA_METHOD* dsam);
+    OSSL_DEPRECATEDIN_3_0 DSA_METHOD* DSA_meth_dup(const DSA_METHOD* dsam);
+    OSSL_DEPRECATEDIN_3_0 const char* DSA_meth_get0_name(const DSA_METHOD* dsam);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set1_name(DSA_METHOD* dsam, const char* name);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_get_flags(const DSA_METHOD* dsam);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_flags(DSA_METHOD* dsam, int flags);
+    OSSL_DEPRECATEDIN_3_0 void* DSA_meth_get0_app_data(const DSA_METHOD* dsam);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set0_app_data(DSA_METHOD* dsam, void* app_data);
+    OSSL_DEPRECATEDIN_3_0 DSA_SIG* (*DSA_meth_get_sign(const DSA_METHOD* dsam))(const unsigned char*, int, DSA*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_sign(DSA_METHOD* dsam, DSA_SIG* (*sign)(const unsigned char*, int, DSA*));
+    OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_sign_setup(const DSA_METHOD* dsam))(DSA*, BN_CTX*, BIGNUM**, BIGNUM**);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_sign_setup(DSA_METHOD* dsam, int (*sign_setup)(DSA*, BN_CTX*, BIGNUM**, BIGNUM**));
+    OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_verify(const DSA_METHOD* dsam))(const unsigned char*, int, DSA_SIG*, DSA*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_verify(DSA_METHOD* dsam, int (*verify)(const unsigned char*, int, DSA_SIG*, DSA*));
+    OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_mod_exp(const DSA_METHOD* dsam))(DSA*, BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*, BN_MONT_CTX*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_mod_exp(DSA_METHOD* dsam, int (*mod_exp)(DSA*, BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*, BN_MONT_CTX*));
+    OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD* dsam))(DSA*, BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*, BN_MONT_CTX*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_bn_mod_exp(DSA_METHOD* dsam, int (*bn_mod_exp)(DSA*, BIGNUM*, const BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*, BN_MONT_CTX*));
+    OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_init(const DSA_METHOD* dsam))(DSA*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_init(DSA_METHOD* dsam, int (*init)(DSA*));
+    OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_finish(const DSA_METHOD* dsam))(DSA*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_finish(DSA_METHOD* dsam, int (*finish)(DSA*));
+    OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_paramgen(const DSA_METHOD* dsam))(DSA*, int, const unsigned char*, int, int*, unsigned long*, BN_GENCB*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_paramgen(DSA_METHOD* dsam, int (*paramgen)(DSA*, int, const unsigned char*, int, int*, unsigned long*, BN_GENCB*));
+    OSSL_DEPRECATEDIN_3_0 int (*DSA_meth_get_keygen(const DSA_METHOD* dsam))(DSA*);
+    OSSL_DEPRECATEDIN_3_0 int DSA_meth_set_keygen(DSA_METHOD* dsam, int (*keygen)(DSA*));
+
+#endif
+#endif
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/dsaerr.h b/CAPI/cpp/grpc/include/openssl/dsaerr.h
index 5f0ca8d..870836b 100644
--- a/CAPI/cpp/grpc/include/openssl/dsaerr.h
+++ b/CAPI/cpp/grpc/include/openssl/dsaerr.h
@@ -9,35 +9,33 @@
  */
 
 #ifndef OPENSSL_DSAERR_H
-# define OPENSSL_DSAERR_H
-# pragma once
+#define OPENSSL_DSAERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_DSA
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_DSA
 
 /*
  * DSA reason codes.
  */
-#  define DSA_R_BAD_FFC_PARAMETERS                         114
-#  define DSA_R_BAD_Q_VALUE                                102
-#  define DSA_R_BN_DECODE_ERROR                            108
-#  define DSA_R_BN_ERROR                                   109
-#  define DSA_R_DECODE_ERROR                               104
-#  define DSA_R_INVALID_DIGEST_TYPE                        106
-#  define DSA_R_INVALID_PARAMETERS                         112
-#  define DSA_R_MISSING_PARAMETERS                         101
-#  define DSA_R_MISSING_PRIVATE_KEY                        111
-#  define DSA_R_MODULUS_TOO_LARGE                          103
-#  define DSA_R_NO_PARAMETERS_SET                          107
-#  define DSA_R_PARAMETER_ENCODING_ERROR                   105
-#  define DSA_R_P_NOT_PRIME                                115
-#  define DSA_R_Q_NOT_PRIME                                113
-#  define DSA_R_SEED_LEN_SMALL                             110
+#define DSA_R_BAD_FFC_PARAMETERS 114
+#define DSA_R_BAD_Q_VALUE 102
+#define DSA_R_BN_DECODE_ERROR 108
+#define DSA_R_BN_ERROR 109
+#define DSA_R_DECODE_ERROR 104
+#define DSA_R_INVALID_DIGEST_TYPE 106
+#define DSA_R_INVALID_PARAMETERS 112
+#define DSA_R_MISSING_PARAMETERS 101
+#define DSA_R_MISSING_PRIVATE_KEY 111
+#define DSA_R_MODULUS_TOO_LARGE 103
+#define DSA_R_NO_PARAMETERS_SET 107
+#define DSA_R_PARAMETER_ENCODING_ERROR 105
+#define DSA_R_P_NOT_PRIME 115
+#define DSA_R_Q_NOT_PRIME 113
+#define DSA_R_SEED_LEN_SMALL 110
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/dtls1.h b/CAPI/cpp/grpc/include/openssl/dtls1.h
index 5dc6b54..3392a1e 100644
--- a/CAPI/cpp/grpc/include/openssl/dtls1.h
+++ b/CAPI/cpp/grpc/include/openssl/dtls1.h
@@ -8,50 +8,51 @@
  */
 
 #ifndef OPENSSL_DTLS1_H
-# define OPENSSL_DTLS1_H
-# pragma once
+#define OPENSSL_DTLS1_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_DTLS1_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_DTLS1_H
+#endif
 
-# include <openssl/prov_ssl.h>
+#include <openssl/prov_ssl.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 #include <openssl/opensslconf.h>
 
 /* DTLS*_VERSION constants are defined in prov_ssl.h */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define DTLS_MIN_VERSION                DTLS1_VERSION
-#  define DTLS_MAX_VERSION                DTLS1_2_VERSION
-# endif
-# define DTLS1_VERSION_MAJOR             0xFE
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DTLS_MIN_VERSION DTLS1_VERSION
+#define DTLS_MAX_VERSION DTLS1_2_VERSION
+#endif
+#define DTLS1_VERSION_MAJOR 0xFE
 
 /* Special value for method supporting multiple versions */
-# define DTLS_ANY_VERSION                0x1FFFF
+#define DTLS_ANY_VERSION 0x1FFFF
 
-/* lengths of messages */
+    /* lengths of messages */
 
-# define DTLS1_COOKIE_LENGTH                     255
+#define DTLS1_COOKIE_LENGTH 255
 
-# define DTLS1_RT_HEADER_LENGTH                  13
+#define DTLS1_RT_HEADER_LENGTH 13
 
-# define DTLS1_HM_HEADER_LENGTH                  12
+#define DTLS1_HM_HEADER_LENGTH 12
 
-# define DTLS1_HM_BAD_FRAGMENT                   -2
-# define DTLS1_HM_FRAGMENT_RETRY                 -3
+#define DTLS1_HM_BAD_FRAGMENT -2
+#define DTLS1_HM_FRAGMENT_RETRY -3
 
-# define DTLS1_CCS_HEADER_LENGTH                  1
+#define DTLS1_CCS_HEADER_LENGTH 1
 
-# define DTLS1_AL_HEADER_LENGTH                   2
+#define DTLS1_AL_HEADER_LENGTH 2
 
-# define DTLS1_TMO_ALERT_COUNT                     12
+#define DTLS1_TMO_ALERT_COUNT 12
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/e_os2.h b/CAPI/cpp/grpc/include/openssl/e_os2.h
index 6728909..4d8e0c1 100644
--- a/CAPI/cpp/grpc/include/openssl/e_os2.h
+++ b/CAPI/cpp/grpc/include/openssl/e_os2.h
@@ -8,27 +8,28 @@
  */
 
 #ifndef OPENSSL_E_OS2_H
-# define OPENSSL_E_OS2_H
-# pragma once
+#define OPENSSL_E_OS2_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_E_OS2_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_E_OS2_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-/******************************************************************************
- * Detect operating systems.  This probably needs completing.
- * The result is that at least one OPENSSL_SYS_os macro should be defined.
- * However, if none is defined, Unix is assumed.
- **/
+    /******************************************************************************
+     * Detect operating systems.  This probably needs completing.
+     * The result is that at least one OPENSSL_SYS_os macro should be defined.
+     * However, if none is defined, Unix is assumed.
+     **/
 
-# define OPENSSL_SYS_UNIX
+#define OPENSSL_SYS_UNIX
 
 /* --------------------- Microsoft operating systems ---------------------- */
 
@@ -36,9 +37,9 @@ extern "C" {
  * Note that MSDOS actually denotes 32-bit environments running on top of
  * MS-DOS, such as DJGPP one.
  */
-# if defined(OPENSSL_SYS_MSDOS)
-#  undef OPENSSL_SYS_UNIX
-# endif
+#if defined(OPENSSL_SYS_MSDOS)
+#undef OPENSSL_SYS_UNIX
+#endif
 
 /*
  * For 32 bit environment, there seems to be the CygWin environment and then
@@ -48,194 +49,194 @@ extern "C" {
  * UEFI lives here because it might be built with a Microsoft toolchain and
  * we need to avoid the false positive match on Windows.
  */
-# if defined(OPENSSL_SYS_UEFI)
-#  undef OPENSSL_SYS_UNIX
-# elif defined(OPENSSL_SYS_UWIN)
-#  undef OPENSSL_SYS_UNIX
-#  define OPENSSL_SYS_WIN32_UWIN
-# else
-#  if defined(__CYGWIN__) || defined(OPENSSL_SYS_CYGWIN)
-#   define OPENSSL_SYS_WIN32_CYGWIN
-#  else
-#   if defined(_WIN32) || defined(OPENSSL_SYS_WIN32)
-#    undef OPENSSL_SYS_UNIX
-#    if !defined(OPENSSL_SYS_WIN32)
-#     define OPENSSL_SYS_WIN32
-#    endif
-#   endif
-#   if defined(_WIN64) || defined(OPENSSL_SYS_WIN64)
-#    undef OPENSSL_SYS_UNIX
-#    if !defined(OPENSSL_SYS_WIN64)
-#     define OPENSSL_SYS_WIN64
-#    endif
-#   endif
-#   if defined(OPENSSL_SYS_WINNT)
-#    undef OPENSSL_SYS_UNIX
-#   endif
-#   if defined(OPENSSL_SYS_WINCE)
-#    undef OPENSSL_SYS_UNIX
-#   endif
-#  endif
-# endif
+#if defined(OPENSSL_SYS_UEFI)
+#undef OPENSSL_SYS_UNIX
+#elif defined(OPENSSL_SYS_UWIN)
+#undef OPENSSL_SYS_UNIX
+#define OPENSSL_SYS_WIN32_UWIN
+#else
+#if defined(__CYGWIN__) || defined(OPENSSL_SYS_CYGWIN)
+#define OPENSSL_SYS_WIN32_CYGWIN
+#else
+#if defined(_WIN32) || defined(OPENSSL_SYS_WIN32)
+#undef OPENSSL_SYS_UNIX
+#if !defined(OPENSSL_SYS_WIN32)
+#define OPENSSL_SYS_WIN32
+#endif
+#endif
+#if defined(_WIN64) || defined(OPENSSL_SYS_WIN64)
+#undef OPENSSL_SYS_UNIX
+#if !defined(OPENSSL_SYS_WIN64)
+#define OPENSSL_SYS_WIN64
+#endif
+#endif
+#if defined(OPENSSL_SYS_WINNT)
+#undef OPENSSL_SYS_UNIX
+#endif
+#if defined(OPENSSL_SYS_WINCE)
+#undef OPENSSL_SYS_UNIX
+#endif
+#endif
+#endif
 
 /* Anything that tries to look like Microsoft is "Windows" */
-# if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN64) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE)
-#  undef OPENSSL_SYS_UNIX
-#  define OPENSSL_SYS_WINDOWS
-#  ifndef OPENSSL_SYS_MSDOS
-#   define OPENSSL_SYS_MSDOS
-#  endif
-# endif
+#if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN64) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE)
+#undef OPENSSL_SYS_UNIX
+#define OPENSSL_SYS_WINDOWS
+#ifndef OPENSSL_SYS_MSDOS
+#define OPENSSL_SYS_MSDOS
+#endif
+#endif
 
 /*
  * DLL settings.  This part is a bit tough, because it's up to the
  * application implementor how he or she will link the application, so it
  * requires some macro to be used.
  */
-# ifdef OPENSSL_SYS_WINDOWS
-#  ifndef OPENSSL_OPT_WINDLL
-#   if defined(_WINDLL)         /* This is used when building OpenSSL to
-                                 * indicate that DLL linkage should be used */
-#    define OPENSSL_OPT_WINDLL
-#   endif
-#  endif
-# endif
+#ifdef OPENSSL_SYS_WINDOWS
+#ifndef OPENSSL_OPT_WINDLL
+#if defined(_WINDLL) /* This is used when building OpenSSL to \
+                      * indicate that DLL linkage should be used */
+#define OPENSSL_OPT_WINDLL
+#endif
+#endif
+#endif
 
 /* ------------------------------- OpenVMS -------------------------------- */
-# if defined(__VMS) || defined(VMS)
-#  if !defined(OPENSSL_SYS_VMS)
-#   undef OPENSSL_SYS_UNIX
-#   define OPENSSL_SYS_VMS
-#  endif
-#  if defined(__DECC)
-#   define OPENSSL_SYS_VMS_DECC
-#  elif defined(__DECCXX)
-#   define OPENSSL_SYS_VMS_DECC
-#   define OPENSSL_SYS_VMS_DECCXX
-#  else
-#   define OPENSSL_SYS_VMS_NODECC
-#  endif
-# endif
+#if defined(__VMS) || defined(VMS)
+#if !defined(OPENSSL_SYS_VMS)
+#undef OPENSSL_SYS_UNIX
+#define OPENSSL_SYS_VMS
+#endif
+#if defined(__DECC)
+#define OPENSSL_SYS_VMS_DECC
+#elif defined(__DECCXX)
+#define OPENSSL_SYS_VMS_DECC
+#define OPENSSL_SYS_VMS_DECCXX
+#else
+#define OPENSSL_SYS_VMS_NODECC
+#endif
+#endif
 
 /* -------------------------------- Unix ---------------------------------- */
-# ifdef OPENSSL_SYS_UNIX
-#  if defined(linux) || defined(__linux__) && !defined(OPENSSL_SYS_LINUX)
-#   define OPENSSL_SYS_LINUX
-#  endif
-#  if defined(_AIX) && !defined(OPENSSL_SYS_AIX)
-#   define OPENSSL_SYS_AIX
-#  endif
-# endif
+#ifdef OPENSSL_SYS_UNIX
+#if defined(linux) || defined(__linux__) && !defined(OPENSSL_SYS_LINUX)
+#define OPENSSL_SYS_LINUX
+#endif
+#if defined(_AIX) && !defined(OPENSSL_SYS_AIX)
+#define OPENSSL_SYS_AIX
+#endif
+#endif
 
 /* -------------------------------- VOS ----------------------------------- */
-# if defined(__VOS__) && !defined(OPENSSL_SYS_VOS)
-#  define OPENSSL_SYS_VOS
-#  ifdef __HPPA__
-#   define OPENSSL_SYS_VOS_HPPA
-#  endif
-#  ifdef __IA32__
-#   define OPENSSL_SYS_VOS_IA32
-#  endif
-# endif
+#if defined(__VOS__) && !defined(OPENSSL_SYS_VOS)
+#define OPENSSL_SYS_VOS
+#ifdef __HPPA__
+#define OPENSSL_SYS_VOS_HPPA
+#endif
+#ifdef __IA32__
+#define OPENSSL_SYS_VOS_IA32
+#endif
+#endif
 
 /* ---------------------------- HP NonStop -------------------------------- */
-# ifdef __TANDEM
-#  ifdef _STRING
-#   include <strings.h>
-#  endif
-# define OPENSSL_USE_BUILD_DATE
-# if defined(OPENSSL_THREADS) && defined(_SPT_MODEL_)
-#  define  SPT_THREAD_SIGNAL 1
-#  define  SPT_THREAD_AWARE 1
-#  include <spthread.h>
-# elif defined(OPENSSL_THREADS) && defined(_PUT_MODEL_)
-#  include <pthread.h>
-# endif
-# endif
+#ifdef __TANDEM
+#ifdef _STRING
+#include <strings.h>
+#endif
+#define OPENSSL_USE_BUILD_DATE
+#if defined(OPENSSL_THREADS) && defined(_SPT_MODEL_)
+#define SPT_THREAD_SIGNAL 1
+#define SPT_THREAD_AWARE 1
+#include <spthread.h>
+#elif defined(OPENSSL_THREADS) && defined(_PUT_MODEL_)
+#include <pthread.h>
+#endif
+#endif
 
-/**
- * That's it for OS-specific stuff
- *****************************************************************************/
+    /**
+     * That's it for OS-specific stuff
+     *****************************************************************************/
 
-/*-
- * OPENSSL_EXTERN is normally used to declare a symbol with possible extra
- * attributes to handle its presence in a shared library.
- * OPENSSL_EXPORT is used to define a symbol with extra possible attributes
- * to make it visible in a shared library.
- * Care needs to be taken when a header file is used both to declare and
- * define symbols.  Basically, for any library that exports some global
- * variables, the following code must be present in the header file that
- * declares them, before OPENSSL_EXTERN is used:
- *
- * #ifdef SOME_BUILD_FLAG_MACRO
- * # undef OPENSSL_EXTERN
- * # define OPENSSL_EXTERN OPENSSL_EXPORT
- * #endif
- *
- * The default is to have OPENSSL_EXPORT and OPENSSL_EXTERN
- * have some generally sensible values.
- */
+    /*-
+     * OPENSSL_EXTERN is normally used to declare a symbol with possible extra
+     * attributes to handle its presence in a shared library.
+     * OPENSSL_EXPORT is used to define a symbol with extra possible attributes
+     * to make it visible in a shared library.
+     * Care needs to be taken when a header file is used both to declare and
+     * define symbols.  Basically, for any library that exports some global
+     * variables, the following code must be present in the header file that
+     * declares them, before OPENSSL_EXTERN is used:
+     *
+     * #ifdef SOME_BUILD_FLAG_MACRO
+     * # undef OPENSSL_EXTERN
+     * # define OPENSSL_EXTERN OPENSSL_EXPORT
+     * #endif
+     *
+     * The default is to have OPENSSL_EXPORT and OPENSSL_EXTERN
+     * have some generally sensible values.
+     */
 
-# if defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL)
-#  define OPENSSL_EXPORT extern __declspec(dllexport)
-#  define OPENSSL_EXTERN extern __declspec(dllimport)
-# else
-#  define OPENSSL_EXPORT extern
-#  define OPENSSL_EXTERN extern
-# endif
+#if defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL)
+#define OPENSSL_EXPORT extern __declspec(dllexport)
+#define OPENSSL_EXTERN extern __declspec(dllimport)
+#else
+#define OPENSSL_EXPORT extern
+#define OPENSSL_EXTERN extern
+#endif
 
-# ifdef _WIN32
-#  ifdef _WIN64
-#   define ossl_ssize_t __int64
-#   define OSSL_SSIZE_MAX _I64_MAX
-#  else
-#   define ossl_ssize_t int
-#   define OSSL_SSIZE_MAX INT_MAX
-#  endif
-# endif
+#ifdef _WIN32
+#ifdef _WIN64
+#define ossl_ssize_t __int64
+#define OSSL_SSIZE_MAX _I64_MAX
+#else
+#define ossl_ssize_t int
+#define OSSL_SSIZE_MAX INT_MAX
+#endif
+#endif
 
-# if defined(OPENSSL_SYS_UEFI) && !defined(ossl_ssize_t)
-#  define ossl_ssize_t INTN
-#  define OSSL_SSIZE_MAX MAX_INTN
-# endif
+#if defined(OPENSSL_SYS_UEFI) && !defined(ossl_ssize_t)
+#define ossl_ssize_t INTN
+#define OSSL_SSIZE_MAX MAX_INTN
+#endif
 
-# ifndef ossl_ssize_t
-#  define ossl_ssize_t ssize_t
-#  if defined(SSIZE_MAX)
-#   define OSSL_SSIZE_MAX SSIZE_MAX
-#  elif defined(_POSIX_SSIZE_MAX)
-#   define OSSL_SSIZE_MAX _POSIX_SSIZE_MAX
-#  else
-#   define OSSL_SSIZE_MAX ((ssize_t)(SIZE_MAX>>1))
-#  endif
-# endif
+#ifndef ossl_ssize_t
+#define ossl_ssize_t ssize_t
+#if defined(SSIZE_MAX)
+#define OSSL_SSIZE_MAX SSIZE_MAX
+#elif defined(_POSIX_SSIZE_MAX)
+#define OSSL_SSIZE_MAX _POSIX_SSIZE_MAX
+#else
+#define OSSL_SSIZE_MAX ((ssize_t)(SIZE_MAX >> 1))
+#endif
+#endif
 
-# if defined(UNUSEDRESULT_DEBUG)
-#  define __owur __attribute__((__warn_unused_result__))
-# else
-#  define __owur
-# endif
+#if defined(UNUSEDRESULT_DEBUG)
+#define __owur __attribute__((__warn_unused_result__))
+#else
+#define __owur
+#endif
 
 /* Standard integer types */
-# define OPENSSL_NO_INTTYPES_H
-# define OPENSSL_NO_STDINT_H
-# if defined(OPENSSL_SYS_UEFI)
-typedef INT8 int8_t;
-typedef UINT8 uint8_t;
-typedef INT16 int16_t;
-typedef UINT16 uint16_t;
-typedef INT32 int32_t;
-typedef UINT32 uint32_t;
-typedef INT64 int64_t;
-typedef UINT64 uint64_t;
-# elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \
-     defined(__osf__) || defined(__sgi) || defined(__hpux) || \
-     defined(OPENSSL_SYS_VMS) || defined (__OpenBSD__)
-#  include <inttypes.h>
-#  undef OPENSSL_NO_INTTYPES_H
+#define OPENSSL_NO_INTTYPES_H
+#define OPENSSL_NO_STDINT_H
+#if defined(OPENSSL_SYS_UEFI)
+    typedef INT8 int8_t;
+    typedef UINT8 uint8_t;
+    typedef INT16 int16_t;
+    typedef UINT16 uint16_t;
+    typedef INT32 int32_t;
+    typedef UINT32 uint32_t;
+    typedef INT64 int64_t;
+    typedef UINT64 uint64_t;
+#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \
+    defined(__osf__) || defined(__sgi) || defined(__hpux) ||        \
+    defined(OPENSSL_SYS_VMS) || defined(__OpenBSD__)
+#include <inttypes.h>
+#undef OPENSSL_NO_INTTYPES_H
 /* Because the specs say that inttypes.h includes stdint.h if present */
-#  undef OPENSSL_NO_STDINT_H
-# elif defined(_MSC_VER) && _MSC_VER<1600
+#undef OPENSSL_NO_STDINT_H
+#elif defined(_MSC_VER) && _MSC_VER < 1600
 /*
  * minimally required typdefs for systems not supporting inttypes.h or
  * stdint.h: currently just older VC++
@@ -248,58 +249,58 @@ typedef int int32_t;
 typedef unsigned int uint32_t;
 typedef __int64 int64_t;
 typedef unsigned __int64 uint64_t;
-# else
-#  include <stdint.h>
-#  undef OPENSSL_NO_STDINT_H
-# endif
-# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \
+#else
+#include <stdint.h>
+#undef OPENSSL_NO_STDINT_H
+#endif
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \
     defined(INTMAX_MAX) && defined(UINTMAX_MAX)
-typedef intmax_t ossl_intmax_t;
-typedef uintmax_t ossl_uintmax_t;
-# else
+    typedef intmax_t ossl_intmax_t;
+    typedef uintmax_t ossl_uintmax_t;
+#else
 /* Fall back to the largest we know we require and can handle */
 typedef int64_t ossl_intmax_t;
 typedef uint64_t ossl_uintmax_t;
-# endif
+#endif
 
 /* ossl_inline: portable inline definition usable in public headers */
-# if !defined(inline) && !defined(__cplusplus)
-#  if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
-   /* just use inline */
-#   define ossl_inline inline
-#  elif defined(__GNUC__) && __GNUC__>=2
-#   define ossl_inline __inline__
-#  elif defined(_MSC_VER)
-  /*
-   * Visual Studio: inline is available in C++ only, however
-   * __inline is available for C, see
-   * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx
-   */
-#   define ossl_inline __inline
-#  else
-#   define ossl_inline
-#  endif
-# else
-#  define ossl_inline inline
-# endif
+#if !defined(inline) && !defined(__cplusplus)
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    /* just use inline */
+#define ossl_inline inline
+#elif defined(__GNUC__) && __GNUC__ >= 2
+#define ossl_inline __inline__
+#elif defined(_MSC_VER)
+    /*
+     * Visual Studio: inline is available in C++ only, however
+     * __inline is available for C, see
+     * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx
+     */
+#define ossl_inline __inline
+#else
+#define ossl_inline
+#endif
+#else
+#define ossl_inline inline
+#endif
 
-# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && \
-     !defined(__cplusplus) 
-#  define ossl_noreturn _Noreturn
-# elif defined(__GNUC__) && __GNUC__ >= 2
-#  define ossl_noreturn __attribute__((noreturn))
-# else
-#  define ossl_noreturn
-# endif
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && \
+    !defined(__cplusplus)
+#define ossl_noreturn _Noreturn
+#elif defined(__GNUC__) && __GNUC__ >= 2
+#define ossl_noreturn __attribute__((noreturn))
+#else
+#define ossl_noreturn
+#endif
 
 /* ossl_unused: portable unused attribute for use in public headers */
-# if defined(__GNUC__)
-#  define ossl_unused __attribute__((unused))
-# else
-#  define ossl_unused
-# endif
+#if defined(__GNUC__)
+#define ossl_unused __attribute__((unused))
+#else
+#define ossl_unused
+#endif
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ebcdic.h b/CAPI/cpp/grpc/include/openssl/ebcdic.h
index e0ae1aa..394689e 100644
--- a/CAPI/cpp/grpc/include/openssl/ebcdic.h
+++ b/CAPI/cpp/grpc/include/openssl/ebcdic.h
@@ -8,32 +8,33 @@
  */
 
 #ifndef OPENSSL_EBCDIC_H
-# define OPENSSL_EBCDIC_H
-# pragma once
+#define OPENSSL_EBCDIC_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_EBCDIC_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_EBCDIC_H
+#endif
 
-# include <stdlib.h>
+#include <stdlib.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 /* Avoid name clashes with other applications */
-# define os_toascii   _openssl_os_toascii
-# define os_toebcdic  _openssl_os_toebcdic
-# define ebcdic2ascii _openssl_ebcdic2ascii
-# define ascii2ebcdic _openssl_ascii2ebcdic
+#define os_toascii _openssl_os_toascii
+#define os_toebcdic _openssl_os_toebcdic
+#define ebcdic2ascii _openssl_ebcdic2ascii
+#define ascii2ebcdic _openssl_ascii2ebcdic
 
-extern const unsigned char os_toascii[256];
-extern const unsigned char os_toebcdic[256];
-void *ebcdic2ascii(void *dest, const void *srce, size_t count);
-void *ascii2ebcdic(void *dest, const void *srce, size_t count);
+    extern const unsigned char os_toascii[256];
+    extern const unsigned char os_toebcdic[256];
+    void* ebcdic2ascii(void* dest, const void* srce, size_t count);
+    void* ascii2ebcdic(void* dest, const void* srce, size_t count);
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ec.h b/CAPI/cpp/grpc/include/openssl/ec.h
index 44d7193..1d7c8fc 100644
--- a/CAPI/cpp/grpc/include/openssl/ec.h
+++ b/CAPI/cpp/grpc/include/openssl/ec.h
@@ -9,1561 +9,1383 @@
  */
 
 #ifndef OPENSSL_EC_H
-# define OPENSSL_EC_H
-# pragma once
+#define OPENSSL_EC_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_EC_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_EC_H
+#endif
 
-# include <openssl/opensslconf.h>
-# include <openssl/types.h>
+#include <openssl/opensslconf.h>
+#include <openssl/types.h>
 
-# include <string.h>
+#include <string.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /* Values for EVP_PKEY_CTX_set_ec_param_enc() */
-# define OPENSSL_EC_EXPLICIT_CURVE  0x000
-# define OPENSSL_EC_NAMED_CURVE     0x001
-
-int EVP_PKEY_CTX_set_ec_paramgen_curve_nid(EVP_PKEY_CTX *ctx, int nid);
-int EVP_PKEY_CTX_set_ec_param_enc(EVP_PKEY_CTX *ctx, int param_enc);
-int EVP_PKEY_CTX_set_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx, int cofactor_mode);
-int EVP_PKEY_CTX_get_ecdh_cofactor_mode(EVP_PKEY_CTX *ctx);
-
-int EVP_PKEY_CTX_set_ecdh_kdf_type(EVP_PKEY_CTX *ctx, int kdf);
-int EVP_PKEY_CTX_get_ecdh_kdf_type(EVP_PKEY_CTX *ctx);
-
-int EVP_PKEY_CTX_set_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
-int EVP_PKEY_CTX_get_ecdh_kdf_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
-
-int EVP_PKEY_CTX_set_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int len);
-int EVP_PKEY_CTX_get_ecdh_kdf_outlen(EVP_PKEY_CTX *ctx, int *len);
-
-int EVP_PKEY_CTX_set0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char *ukm,
-                                   int len);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_CTX_get0_ecdh_kdf_ukm(EVP_PKEY_CTX *ctx, unsigned char **ukm);
-# endif
-
-# define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID    (EVP_PKEY_ALG_CTRL + 1)
-# define EVP_PKEY_CTRL_EC_PARAM_ENC             (EVP_PKEY_ALG_CTRL + 2)
-# define EVP_PKEY_CTRL_EC_ECDH_COFACTOR         (EVP_PKEY_ALG_CTRL + 3)
-# define EVP_PKEY_CTRL_EC_KDF_TYPE              (EVP_PKEY_ALG_CTRL + 4)
-# define EVP_PKEY_CTRL_EC_KDF_MD                (EVP_PKEY_ALG_CTRL + 5)
-# define EVP_PKEY_CTRL_GET_EC_KDF_MD            (EVP_PKEY_ALG_CTRL + 6)
-# define EVP_PKEY_CTRL_EC_KDF_OUTLEN            (EVP_PKEY_ALG_CTRL + 7)
-# define EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN        (EVP_PKEY_ALG_CTRL + 8)
-# define EVP_PKEY_CTRL_EC_KDF_UKM               (EVP_PKEY_ALG_CTRL + 9)
-# define EVP_PKEY_CTRL_GET_EC_KDF_UKM           (EVP_PKEY_ALG_CTRL + 10)
+#define OPENSSL_EC_EXPLICIT_CURVE 0x000
+#define OPENSSL_EC_NAMED_CURVE 0x001
+
+    int EVP_PKEY_CTX_set_ec_paramgen_curve_nid(EVP_PKEY_CTX* ctx, int nid);
+    int EVP_PKEY_CTX_set_ec_param_enc(EVP_PKEY_CTX* ctx, int param_enc);
+    int EVP_PKEY_CTX_set_ecdh_cofactor_mode(EVP_PKEY_CTX* ctx, int cofactor_mode);
+    int EVP_PKEY_CTX_get_ecdh_cofactor_mode(EVP_PKEY_CTX* ctx);
+
+    int EVP_PKEY_CTX_set_ecdh_kdf_type(EVP_PKEY_CTX* ctx, int kdf);
+    int EVP_PKEY_CTX_get_ecdh_kdf_type(EVP_PKEY_CTX* ctx);
+
+    int EVP_PKEY_CTX_set_ecdh_kdf_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
+    int EVP_PKEY_CTX_get_ecdh_kdf_md(EVP_PKEY_CTX* ctx, const EVP_MD** md);
+
+    int EVP_PKEY_CTX_set_ecdh_kdf_outlen(EVP_PKEY_CTX* ctx, int len);
+    int EVP_PKEY_CTX_get_ecdh_kdf_outlen(EVP_PKEY_CTX* ctx, int* len);
+
+    int EVP_PKEY_CTX_set0_ecdh_kdf_ukm(EVP_PKEY_CTX* ctx, unsigned char* ukm, int len);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_CTX_get0_ecdh_kdf_ukm(EVP_PKEY_CTX* ctx, unsigned char** ukm);
+#endif
+
+#define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID (EVP_PKEY_ALG_CTRL + 1)
+#define EVP_PKEY_CTRL_EC_PARAM_ENC (EVP_PKEY_ALG_CTRL + 2)
+#define EVP_PKEY_CTRL_EC_ECDH_COFACTOR (EVP_PKEY_ALG_CTRL + 3)
+#define EVP_PKEY_CTRL_EC_KDF_TYPE (EVP_PKEY_ALG_CTRL + 4)
+#define EVP_PKEY_CTRL_EC_KDF_MD (EVP_PKEY_ALG_CTRL + 5)
+#define EVP_PKEY_CTRL_GET_EC_KDF_MD (EVP_PKEY_ALG_CTRL + 6)
+#define EVP_PKEY_CTRL_EC_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 7)
+#define EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 8)
+#define EVP_PKEY_CTRL_EC_KDF_UKM (EVP_PKEY_ALG_CTRL + 9)
+#define EVP_PKEY_CTRL_GET_EC_KDF_UKM (EVP_PKEY_ALG_CTRL + 10)
 
 /* KDF types */
-# define EVP_PKEY_ECDH_KDF_NONE                      1
-# define EVP_PKEY_ECDH_KDF_X9_63                     2
+#define EVP_PKEY_ECDH_KDF_NONE 1
+#define EVP_PKEY_ECDH_KDF_X9_63 2
 /*
  * The old name for EVP_PKEY_ECDH_KDF_X9_63
  *  The ECDH KDF specification has been mistakenly attributed to ANSI X9.62,
  *  it is actually specified in ANSI X9.63.
  *  This identifier is retained for backwards compatibility
  */
-# define EVP_PKEY_ECDH_KDF_X9_62   EVP_PKEY_ECDH_KDF_X9_63
+#define EVP_PKEY_ECDH_KDF_X9_62 EVP_PKEY_ECDH_KDF_X9_63
 
-/** Enum for the point conversion form as defined in X9.62 (ECDSA)
- *  for the encoding of a elliptic curve point (x,y) */
-typedef enum {
+    /** Enum for the point conversion form as defined in X9.62 (ECDSA)
+     *  for the encoding of a elliptic curve point (x,y) */
+    typedef enum
+    {
         /** the point is encoded as z||x, where the octet z specifies
          *  which solution of the quadratic equation y is  */
-    POINT_CONVERSION_COMPRESSED = 2,
+        POINT_CONVERSION_COMPRESSED = 2,
         /** the point is encoded as z||x||y, where z is the octet 0x04  */
-    POINT_CONVERSION_UNCOMPRESSED = 4,
+        POINT_CONVERSION_UNCOMPRESSED = 4,
         /** the point is encoded as z||x||y, where the octet z specifies
          *  which solution of the quadratic equation y is  */
-    POINT_CONVERSION_HYBRID = 6
-} point_conversion_form_t;
-
-const char *OSSL_EC_curve_nid2name(int nid);
-
-# ifndef OPENSSL_NO_EC
-#  include <openssl/asn1.h>
-#  include <openssl/symhacks.h>
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#   include <openssl/bn.h>
-#  endif
-#  include <openssl/ecerr.h>
-
-#  ifndef OPENSSL_ECC_MAX_FIELD_BITS
-#   define OPENSSL_ECC_MAX_FIELD_BITS 661
-#  endif
-
-#  include <openssl/params.h>
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef struct ec_method_st EC_METHOD;
-#  endif
-typedef struct ec_group_st EC_GROUP;
-typedef struct ec_point_st EC_POINT;
-typedef struct ecpk_parameters_st ECPKPARAMETERS;
-typedef struct ec_parameters_st ECPARAMETERS;
-
-/********************************************************************/
-/*               EC_METHODs for curves over GF(p)                   */
-/********************************************************************/
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/** Returns the basic GFp ec methods which provides the basis for the
- *  optimized methods.
- *  \return  EC_METHOD object
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_simple_method(void);
-
-/** Returns GFp methods using montgomery multiplication.
- *  \return  EC_METHOD object
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_mont_method(void);
-
-/** Returns GFp methods using optimized methods for NIST recommended curves
- *  \return  EC_METHOD object
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nist_method(void);
-
-#   ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
-/** Returns 64-bit optimized methods for nistp224
- *  \return  EC_METHOD object
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp224_method(void);
-
-/** Returns 64-bit optimized methods for nistp256
- *  \return  EC_METHOD object
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp256_method(void);
-
-/** Returns 64-bit optimized methods for nistp521
- *  \return  EC_METHOD object
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GFp_nistp521_method(void);
-#   endif /* OPENSSL_NO_EC_NISTP_64_GCC_128 */
-
-#   ifndef OPENSSL_NO_EC2M
-/********************************************************************/
-/*           EC_METHOD for curves over GF(2^m)                      */
-/********************************************************************/
-
-/** Returns the basic GF2m ec method
- *  \return  EC_METHOD object
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GF2m_simple_method(void);
-
-#   endif
-
-/********************************************************************/
-/*                   EC_GROUP functions                             */
-/********************************************************************/
-
-/**
- *  Creates a new EC_GROUP object
- *  \param   meth   EC_METHOD to use
- *  \return  newly created EC_GROUP object or NULL in case of an error.
- */
-OSSL_DEPRECATEDIN_3_0 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth);
-
-/** Clears and frees a EC_GROUP object
- *  \param  group  EC_GROUP object to be cleared and freed.
- */
-OSSL_DEPRECATEDIN_3_0 void EC_GROUP_clear_free(EC_GROUP *group);
-
-/** Returns the EC_METHOD of the EC_GROUP object.
- *  \param  group  EC_GROUP object
- *  \return EC_METHOD used in this EC_GROUP object.
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group);
-
-/** Returns the field type of the EC_METHOD.
- *  \param  meth  EC_METHOD object
- *  \return NID of the underlying field type OID.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_METHOD_get_field_type(const EC_METHOD *meth);
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-/** Frees a EC_GROUP object
- *  \param  group  EC_GROUP object to be freed.
- */
-void EC_GROUP_free(EC_GROUP *group);
-
-/** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD.
- *  \param  dst  destination EC_GROUP object
- *  \param  src  source EC_GROUP object
- *  \return 1 on success and 0 if an error occurred.
- */
-int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src);
-
-/** Creates a new EC_GROUP object and copies the content
- *  form src to the newly created EC_KEY object
- *  \param  src  source EC_GROUP object
- *  \return newly created EC_GROUP object or NULL in case of an error.
- */
-EC_GROUP *EC_GROUP_dup(const EC_GROUP *src);
-
-/** Sets the generator and its order/cofactor of a EC_GROUP object.
- *  \param  group      EC_GROUP object
- *  \param  generator  EC_POINT object with the generator.
- *  \param  order      the order of the group generated by the generator.
- *  \param  cofactor   the index of the sub-group generated by the generator
- *                     in the group of all points on the elliptic curve.
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
-                           const BIGNUM *order, const BIGNUM *cofactor);
-
-/** Returns the generator of a EC_GROUP object.
- *  \param  group  EC_GROUP object
- *  \return the currently used generator (possibly NULL).
- */
-const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group);
-
-/** Returns the montgomery data for order(Generator)
- *  \param  group  EC_GROUP object
- *  \return the currently used montgomery data (possibly NULL).
-*/
-BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group);
-
-/** Gets the order of a EC_GROUP
- *  \param  group  EC_GROUP object
- *  \param  order  BIGNUM to which the order is copied
- *  \param  ctx    unused
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx);
-
-/** Gets the order of an EC_GROUP
- *  \param  group  EC_GROUP object
- *  \return the group order
- */
-const BIGNUM *EC_GROUP_get0_order(const EC_GROUP *group);
-
-/** Gets the number of bits of the order of an EC_GROUP
- *  \param  group  EC_GROUP object
- *  \return number of bits of group order.
- */
-int EC_GROUP_order_bits(const EC_GROUP *group);
-
-/** Gets the cofactor of a EC_GROUP
- *  \param  group     EC_GROUP object
- *  \param  cofactor  BIGNUM to which the cofactor is copied
- *  \param  ctx       unused
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor,
-                          BN_CTX *ctx);
-
-/** Gets the cofactor of an EC_GROUP
- *  \param  group  EC_GROUP object
- *  \return the group cofactor
- */
-const BIGNUM *EC_GROUP_get0_cofactor(const EC_GROUP *group);
-
-/** Sets the name of a EC_GROUP object
- *  \param  group  EC_GROUP object
- *  \param  nid    NID of the curve name OID
- */
-void EC_GROUP_set_curve_name(EC_GROUP *group, int nid);
-
-/** Returns the curve name of a EC_GROUP object
- *  \param  group  EC_GROUP object
- *  \return NID of the curve name OID or 0 if not set.
- */
-int EC_GROUP_get_curve_name(const EC_GROUP *group);
-
-/** Gets the field of an EC_GROUP
- *  \param  group  EC_GROUP object
- *  \return the group field
- */
-const BIGNUM *EC_GROUP_get0_field(const EC_GROUP *group);
-
-/** Returns the field type of the EC_GROUP.
- *  \param  group  EC_GROUP object
- *  \return NID of the underlying field type OID.
- */
-int EC_GROUP_get_field_type(const EC_GROUP *group);
-
-void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag);
-int EC_GROUP_get_asn1_flag(const EC_GROUP *group);
-
-void EC_GROUP_set_point_conversion_form(EC_GROUP *group,
-                                        point_conversion_form_t form);
-point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *);
-
-unsigned char *EC_GROUP_get0_seed(const EC_GROUP *x);
-size_t EC_GROUP_get_seed_len(const EC_GROUP *);
-size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len);
-
-/** Sets the parameters of an ec curve defined by y^2 = x^3 + a*x + b (for GFp)
- *  or y^2 + x*y = x^3 + a*x^2 + b (for GF2m)
- *  \param  group  EC_GROUP object
- *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
- *                 defining the underlying field (GF2m)
- *  \param  a      BIGNUM with parameter a of the equation
- *  \param  b      BIGNUM with parameter b of the equation
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
-                       const BIGNUM *b, BN_CTX *ctx);
-
-/** Gets the parameters of the ec curve defined by y^2 = x^3 + a*x + b (for GFp)
- *  or y^2 + x*y = x^3 + a*x^2 + b (for GF2m)
- *  \param  group  EC_GROUP object
- *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
- *                 defining the underlying field (GF2m)
- *  \param  a      BIGNUM for parameter a of the equation
- *  \param  b      BIGNUM for parameter b of the equation
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b,
-                       BN_CTX *ctx);
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/** Sets the parameters of an ec curve. Synonym for EC_GROUP_set_curve
- *  \param  group  EC_GROUP object
- *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
- *                 defining the underlying field (GF2m)
- *  \param  a      BIGNUM with parameter a of the equation
- *  \param  b      BIGNUM with parameter b of the equation
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_GROUP_set_curve_GFp(EC_GROUP *group,
-                                                 const BIGNUM *p,
-                                                 const BIGNUM *a,
-                                                 const BIGNUM *b,
-                                                 BN_CTX *ctx);
-
-/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve
- *  \param  group  EC_GROUP object
- *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
- *                 defining the underlying field (GF2m)
- *  \param  a      BIGNUM for parameter a of the equation
- *  \param  b      BIGNUM for parameter b of the equation
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_GROUP_get_curve_GFp(const EC_GROUP *group,
-                                                 BIGNUM *p,
-                                                 BIGNUM *a, BIGNUM *b,
-                                                 BN_CTX *ctx);
-
-#   ifndef OPENSSL_NO_EC2M
-/** Sets the parameter of an ec curve. Synonym for EC_GROUP_set_curve
- *  \param  group  EC_GROUP object
- *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
- *                 defining the underlying field (GF2m)
- *  \param  a      BIGNUM with parameter a of the equation
- *  \param  b      BIGNUM with parameter b of the equation
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_GROUP_set_curve_GF2m(EC_GROUP *group,
-                                                  const BIGNUM *p,
-                                                  const BIGNUM *a,
-                                                  const BIGNUM *b,
-                                                  BN_CTX *ctx);
-
-/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve
- *  \param  group  EC_GROUP object
- *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
- *                 defining the underlying field (GF2m)
- *  \param  a      BIGNUM for parameter a of the equation
- *  \param  b      BIGNUM for parameter b of the equation
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_GROUP_get_curve_GF2m(const EC_GROUP *group,
-                                                  BIGNUM *p,
-                                                  BIGNUM *a, BIGNUM *b,
-                                                  BN_CTX *ctx);
-#   endif /* OPENSSL_NO_EC2M */
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-/** Returns the number of bits needed to represent a field element
- *  \param  group  EC_GROUP object
- *  \return number of bits needed to represent a field element
- */
-int EC_GROUP_get_degree(const EC_GROUP *group);
-
-/** Checks whether the parameter in the EC_GROUP define a valid ec group
- *  \param  group  EC_GROUP object
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 if group is a valid ec group and 0 otherwise
- */
-int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx);
-
-/** Checks whether the discriminant of the elliptic curve is zero or not
- *  \param  group  EC_GROUP object
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 if the discriminant is not zero and 0 otherwise
- */
-int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx);
-
-/** Compares two EC_GROUP objects
- *  \param  a    first EC_GROUP object
- *  \param  b    second EC_GROUP object
- *  \param  ctx  BN_CTX object (optional)
- *  \return 0 if the groups are equal, 1 if not, or -1 on error
- */
-int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx);
-
-/*
- * EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*() after
- * choosing an appropriate EC_METHOD
- */
-
-/** Creates a new EC_GROUP object with the specified parameters defined
- *  over GFp (defined by the equation y^2 = x^3 + a*x + b)
- *  \param  p    BIGNUM with the prime number
- *  \param  a    BIGNUM with the parameter a of the equation
- *  \param  b    BIGNUM with the parameter b of the equation
- *  \param  ctx  BN_CTX object (optional)
- *  \return newly created EC_GROUP object with the specified parameters
- */
-EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a,
-                                 const BIGNUM *b, BN_CTX *ctx);
-#  ifndef OPENSSL_NO_EC2M
-/** Creates a new EC_GROUP object with the specified parameters defined
- *  over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b)
- *  \param  p    BIGNUM with the polynomial defining the underlying field
- *  \param  a    BIGNUM with the parameter a of the equation
- *  \param  b    BIGNUM with the parameter b of the equation
- *  \param  ctx  BN_CTX object (optional)
- *  \return newly created EC_GROUP object with the specified parameters
- */
-EC_GROUP *EC_GROUP_new_curve_GF2m(const BIGNUM *p, const BIGNUM *a,
-                                  const BIGNUM *b, BN_CTX *ctx);
-#  endif
-
-/**
- * Creates a EC_GROUP object with a curve specified by parameters.
- * The parameters may be explicit or a named curve,
- *  \param  params A list of parameters describing the group.
- *  \param  libctx The associated library context or NULL for the default
- *                 context
- *  \param  propq  A property query string
- *  \return newly created EC_GROUP object with specified parameters or NULL
- *          if an error occurred
- */
-EC_GROUP *EC_GROUP_new_from_params(const OSSL_PARAM params[],
-                                   OSSL_LIB_CTX *libctx, const char *propq);
-
-/**
- * Creates a EC_GROUP object with a curve specified by a NID
- *  \param  libctx The associated library context or NULL for the default
- *                 context
- *  \param  propq  A property query string
- *  \param  nid    NID of the OID of the curve name
- *  \return newly created EC_GROUP object with specified curve or NULL
- *          if an error occurred
- */
-EC_GROUP *EC_GROUP_new_by_curve_name_ex(OSSL_LIB_CTX *libctx, const char *propq,
-                                        int nid);
-
-/**
- * Creates a EC_GROUP object with a curve specified by a NID. Same as
- * EC_GROUP_new_by_curve_name_ex but the libctx and propq are always
- * NULL.
- *  \param  nid    NID of the OID of the curve name
- *  \return newly created EC_GROUP object with specified curve or NULL
- *          if an error occurred
- */
-EC_GROUP *EC_GROUP_new_by_curve_name(int nid);
-
-/** Creates a new EC_GROUP object from an ECPARAMETERS object
- *  \param  params  pointer to the ECPARAMETERS object
- *  \return newly created EC_GROUP object with specified curve or NULL
- *          if an error occurred
- */
-EC_GROUP *EC_GROUP_new_from_ecparameters(const ECPARAMETERS *params);
-
-/** Creates an ECPARAMETERS object for the given EC_GROUP object.
- *  \param  group   pointer to the EC_GROUP object
- *  \param  params  pointer to an existing ECPARAMETERS object or NULL
- *  \return pointer to the new ECPARAMETERS object or NULL
- *          if an error occurred.
- */
-ECPARAMETERS *EC_GROUP_get_ecparameters(const EC_GROUP *group,
-                                        ECPARAMETERS *params);
-
-/** Creates a new EC_GROUP object from an ECPKPARAMETERS object
- *  \param  params  pointer to an existing ECPKPARAMETERS object, or NULL
- *  \return newly created EC_GROUP object with specified curve, or NULL
- *          if an error occurred
- */
-EC_GROUP *EC_GROUP_new_from_ecpkparameters(const ECPKPARAMETERS *params);
-
-/** Creates an ECPKPARAMETERS object for the given EC_GROUP object.
- *  \param  group   pointer to the EC_GROUP object
- *  \param  params  pointer to an existing ECPKPARAMETERS object or NULL
- *  \return pointer to the new ECPKPARAMETERS object or NULL
- *          if an error occurred.
- */
-ECPKPARAMETERS *EC_GROUP_get_ecpkparameters(const EC_GROUP *group,
-                                            ECPKPARAMETERS *params);
-
-/********************************************************************/
-/*               handling of internal curves                        */
-/********************************************************************/
-
-typedef struct {
-    int nid;
-    const char *comment;
-} EC_builtin_curve;
-
-/*
- * EC_builtin_curves(EC_builtin_curve *r, size_t size) returns number of all
- * available curves or zero if a error occurred. In case r is not zero,
- * nitems EC_builtin_curve structures are filled with the data of the first
- * nitems internal groups
- */
-size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems);
+        POINT_CONVERSION_HYBRID = 6
+    } point_conversion_form_t;
 
-const char *EC_curve_nid2nist(int nid);
-int EC_curve_nist2nid(const char *name);
-int EC_GROUP_check_named_curve(const EC_GROUP *group, int nist_only,
-                               BN_CTX *ctx);
+    const char* OSSL_EC_curve_nid2name(int nid);
 
-/********************************************************************/
-/*                    EC_POINT functions                            */
-/********************************************************************/
-
-/** Creates a new EC_POINT object for the specified EC_GROUP
- *  \param  group  EC_GROUP the underlying EC_GROUP object
- *  \return newly created EC_POINT object or NULL if an error occurred
- */
-EC_POINT *EC_POINT_new(const EC_GROUP *group);
-
-/** Frees a EC_POINT object
- *  \param  point  EC_POINT object to be freed
- */
-void EC_POINT_free(EC_POINT *point);
+#ifndef OPENSSL_NO_EC
+#include <openssl/asn1.h>
+#include <openssl/symhacks.h>
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/bn.h>
+#endif
+#include <openssl/ecerr.h>
 
-/** Clears and frees a EC_POINT object
- *  \param  point  EC_POINT object to be cleared and freed
- */
-void EC_POINT_clear_free(EC_POINT *point);
+#ifndef OPENSSL_ECC_MAX_FIELD_BITS
+#define OPENSSL_ECC_MAX_FIELD_BITS 661
+#endif
 
-/** Copies EC_POINT object
- *  \param  dst  destination EC_POINT object
- *  \param  src  source EC_POINT object
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src);
+#include <openssl/params.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef struct ec_method_st EC_METHOD;
+#endif
+    typedef struct ec_group_st EC_GROUP;
+    typedef struct ec_point_st EC_POINT;
+    typedef struct ecpk_parameters_st ECPKPARAMETERS;
+    typedef struct ec_parameters_st ECPARAMETERS;
+
+    /********************************************************************/
+    /*               EC_METHODs for curves over GF(p)                   */
+    /********************************************************************/
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /** Returns the basic GFp ec methods which provides the basis for the
+     *  optimized methods.
+     *  \return  EC_METHOD object
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_GFp_simple_method(void);
+
+    /** Returns GFp methods using montgomery multiplication.
+     *  \return  EC_METHOD object
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_GFp_mont_method(void);
+
+    /** Returns GFp methods using optimized methods for NIST recommended curves
+     *  \return  EC_METHOD object
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_GFp_nist_method(void);
+
+#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
+    /** Returns 64-bit optimized methods for nistp224
+     *  \return  EC_METHOD object
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_GFp_nistp224_method(void);
+
+    /** Returns 64-bit optimized methods for nistp256
+     *  \return  EC_METHOD object
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_GFp_nistp256_method(void);
+
+    /** Returns 64-bit optimized methods for nistp521
+     *  \return  EC_METHOD object
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_GFp_nistp521_method(void);
+#endif /* OPENSSL_NO_EC_NISTP_64_GCC_128 */
+
+#ifndef OPENSSL_NO_EC2M
+    /********************************************************************/
+    /*           EC_METHOD for curves over GF(2^m)                      */
+    /********************************************************************/
+
+    /** Returns the basic GF2m ec method
+     *  \return  EC_METHOD object
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_GF2m_simple_method(void);
 
-/** Creates a new EC_POINT object and copies the content of the supplied
- *  EC_POINT
- *  \param  src    source EC_POINT object
- *  \param  group  underlying the EC_GROUP object
- *  \return newly created EC_POINT object or NULL if an error occurred
- */
-EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group);
+#endif
 
-/** Sets a point to infinity (neutral element)
- *  \param  group  underlying EC_GROUP object
- *  \param  point  EC_POINT to set to infinity
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point);
+    /********************************************************************/
+    /*                   EC_GROUP functions                             */
+    /********************************************************************/
+
+    /**
+     *  Creates a new EC_GROUP object
+     *  \param   meth   EC_METHOD to use
+     *  \return  newly created EC_GROUP object or NULL in case of an error.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_GROUP* EC_GROUP_new(const EC_METHOD* meth);
+
+    /** Clears and frees a EC_GROUP object
+     *  \param  group  EC_GROUP object to be cleared and freed.
+     */
+    OSSL_DEPRECATEDIN_3_0 void EC_GROUP_clear_free(EC_GROUP* group);
+
+    /** Returns the EC_METHOD of the EC_GROUP object.
+     *  \param  group  EC_GROUP object
+     *  \return EC_METHOD used in this EC_GROUP object.
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_GROUP_method_of(const EC_GROUP* group);
+
+    /** Returns the field type of the EC_METHOD.
+     *  \param  meth  EC_METHOD object
+     *  \return NID of the underlying field type OID.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_METHOD_get_field_type(const EC_METHOD* meth);
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    /** Frees a EC_GROUP object
+     *  \param  group  EC_GROUP object to be freed.
+     */
+    void EC_GROUP_free(EC_GROUP* group);
+
+    /** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD.
+     *  \param  dst  destination EC_GROUP object
+     *  \param  src  source EC_GROUP object
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    int EC_GROUP_copy(EC_GROUP* dst, const EC_GROUP* src);
+
+    /** Creates a new EC_GROUP object and copies the content
+     *  form src to the newly created EC_KEY object
+     *  \param  src  source EC_GROUP object
+     *  \return newly created EC_GROUP object or NULL in case of an error.
+     */
+    EC_GROUP* EC_GROUP_dup(const EC_GROUP* src);
+
+    /** Sets the generator and its order/cofactor of a EC_GROUP object.
+     *  \param  group      EC_GROUP object
+     *  \param  generator  EC_POINT object with the generator.
+     *  \param  order      the order of the group generated by the generator.
+     *  \param  cofactor   the index of the sub-group generated by the generator
+     *                     in the group of all points on the elliptic curve.
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_GROUP_set_generator(EC_GROUP* group, const EC_POINT* generator, const BIGNUM* order, const BIGNUM* cofactor);
+
+    /** Returns the generator of a EC_GROUP object.
+     *  \param  group  EC_GROUP object
+     *  \return the currently used generator (possibly NULL).
+     */
+    const EC_POINT* EC_GROUP_get0_generator(const EC_GROUP* group);
+
+    /** Returns the montgomery data for order(Generator)
+     *  \param  group  EC_GROUP object
+     *  \return the currently used montgomery data (possibly NULL).
+     */
+    BN_MONT_CTX* EC_GROUP_get_mont_data(const EC_GROUP* group);
+
+    /** Gets the order of a EC_GROUP
+     *  \param  group  EC_GROUP object
+     *  \param  order  BIGNUM to which the order is copied
+     *  \param  ctx    unused
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_GROUP_get_order(const EC_GROUP* group, BIGNUM* order, BN_CTX* ctx);
+
+    /** Gets the order of an EC_GROUP
+     *  \param  group  EC_GROUP object
+     *  \return the group order
+     */
+    const BIGNUM* EC_GROUP_get0_order(const EC_GROUP* group);
+
+    /** Gets the number of bits of the order of an EC_GROUP
+     *  \param  group  EC_GROUP object
+     *  \return number of bits of group order.
+     */
+    int EC_GROUP_order_bits(const EC_GROUP* group);
+
+    /** Gets the cofactor of a EC_GROUP
+     *  \param  group     EC_GROUP object
+     *  \param  cofactor  BIGNUM to which the cofactor is copied
+     *  \param  ctx       unused
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_GROUP_get_cofactor(const EC_GROUP* group, BIGNUM* cofactor, BN_CTX* ctx);
+
+    /** Gets the cofactor of an EC_GROUP
+     *  \param  group  EC_GROUP object
+     *  \return the group cofactor
+     */
+    const BIGNUM* EC_GROUP_get0_cofactor(const EC_GROUP* group);
+
+    /** Sets the name of a EC_GROUP object
+     *  \param  group  EC_GROUP object
+     *  \param  nid    NID of the curve name OID
+     */
+    void EC_GROUP_set_curve_name(EC_GROUP* group, int nid);
+
+    /** Returns the curve name of a EC_GROUP object
+     *  \param  group  EC_GROUP object
+     *  \return NID of the curve name OID or 0 if not set.
+     */
+    int EC_GROUP_get_curve_name(const EC_GROUP* group);
+
+    /** Gets the field of an EC_GROUP
+     *  \param  group  EC_GROUP object
+     *  \return the group field
+     */
+    const BIGNUM* EC_GROUP_get0_field(const EC_GROUP* group);
+
+    /** Returns the field type of the EC_GROUP.
+     *  \param  group  EC_GROUP object
+     *  \return NID of the underlying field type OID.
+     */
+    int EC_GROUP_get_field_type(const EC_GROUP* group);
+
+    void EC_GROUP_set_asn1_flag(EC_GROUP* group, int flag);
+    int EC_GROUP_get_asn1_flag(const EC_GROUP* group);
+
+    void EC_GROUP_set_point_conversion_form(EC_GROUP* group, point_conversion_form_t form);
+    point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP*);
+
+    unsigned char* EC_GROUP_get0_seed(const EC_GROUP* x);
+    size_t EC_GROUP_get_seed_len(const EC_GROUP*);
+    size_t EC_GROUP_set_seed(EC_GROUP*, const unsigned char*, size_t len);
+
+    /** Sets the parameters of an ec curve defined by y^2 = x^3 + a*x + b (for GFp)
+     *  or y^2 + x*y = x^3 + a*x^2 + b (for GF2m)
+     *  \param  group  EC_GROUP object
+     *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+     *                 defining the underlying field (GF2m)
+     *  \param  a      BIGNUM with parameter a of the equation
+     *  \param  b      BIGNUM with parameter b of the equation
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_GROUP_set_curve(EC_GROUP* group, const BIGNUM* p, const BIGNUM* a, const BIGNUM* b, BN_CTX* ctx);
+
+    /** Gets the parameters of the ec curve defined by y^2 = x^3 + a*x + b (for GFp)
+     *  or y^2 + x*y = x^3 + a*x^2 + b (for GF2m)
+     *  \param  group  EC_GROUP object
+     *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+     *                 defining the underlying field (GF2m)
+     *  \param  a      BIGNUM for parameter a of the equation
+     *  \param  b      BIGNUM for parameter b of the equation
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_GROUP_get_curve(const EC_GROUP* group, BIGNUM* p, BIGNUM* a, BIGNUM* b, BN_CTX* ctx);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /** Sets the parameters of an ec curve. Synonym for EC_GROUP_set_curve
+     *  \param  group  EC_GROUP object
+     *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+     *                 defining the underlying field (GF2m)
+     *  \param  a      BIGNUM with parameter a of the equation
+     *  \param  b      BIGNUM with parameter b of the equation
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_GROUP_set_curve_GFp(EC_GROUP* group, const BIGNUM* p, const BIGNUM* a, const BIGNUM* b, BN_CTX* ctx);
+
+    /** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve
+     *  \param  group  EC_GROUP object
+     *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+     *                 defining the underlying field (GF2m)
+     *  \param  a      BIGNUM for parameter a of the equation
+     *  \param  b      BIGNUM for parameter b of the equation
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_GROUP_get_curve_GFp(const EC_GROUP* group, BIGNUM* p, BIGNUM* a, BIGNUM* b, BN_CTX* ctx);
+
+#ifndef OPENSSL_NO_EC2M
+    /** Sets the parameter of an ec curve. Synonym for EC_GROUP_set_curve
+     *  \param  group  EC_GROUP object
+     *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+     *                 defining the underlying field (GF2m)
+     *  \param  a      BIGNUM with parameter a of the equation
+     *  \param  b      BIGNUM with parameter b of the equation
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_GROUP_set_curve_GF2m(EC_GROUP* group, const BIGNUM* p, const BIGNUM* a, const BIGNUM* b, BN_CTX* ctx);
+
+    /** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve
+     *  \param  group  EC_GROUP object
+     *  \param  p      BIGNUM with the prime number (GFp) or the polynomial
+     *                 defining the underlying field (GF2m)
+     *  \param  a      BIGNUM for parameter a of the equation
+     *  \param  b      BIGNUM for parameter b of the equation
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_GROUP_get_curve_GF2m(const EC_GROUP* group, BIGNUM* p, BIGNUM* a, BIGNUM* b, BN_CTX* ctx);
+#endif /* OPENSSL_NO_EC2M */
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    /** Returns the number of bits needed to represent a field element
+     *  \param  group  EC_GROUP object
+     *  \return number of bits needed to represent a field element
+     */
+    int EC_GROUP_get_degree(const EC_GROUP* group);
+
+    /** Checks whether the parameter in the EC_GROUP define a valid ec group
+     *  \param  group  EC_GROUP object
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 if group is a valid ec group and 0 otherwise
+     */
+    int EC_GROUP_check(const EC_GROUP* group, BN_CTX* ctx);
+
+    /** Checks whether the discriminant of the elliptic curve is zero or not
+     *  \param  group  EC_GROUP object
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 if the discriminant is not zero and 0 otherwise
+     */
+    int EC_GROUP_check_discriminant(const EC_GROUP* group, BN_CTX* ctx);
+
+    /** Compares two EC_GROUP objects
+     *  \param  a    first EC_GROUP object
+     *  \param  b    second EC_GROUP object
+     *  \param  ctx  BN_CTX object (optional)
+     *  \return 0 if the groups are equal, 1 if not, or -1 on error
+     */
+    int EC_GROUP_cmp(const EC_GROUP* a, const EC_GROUP* b, BN_CTX* ctx);
+
+    /*
+     * EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*() after
+     * choosing an appropriate EC_METHOD
+     */
+
+    /** Creates a new EC_GROUP object with the specified parameters defined
+     *  over GFp (defined by the equation y^2 = x^3 + a*x + b)
+     *  \param  p    BIGNUM with the prime number
+     *  \param  a    BIGNUM with the parameter a of the equation
+     *  \param  b    BIGNUM with the parameter b of the equation
+     *  \param  ctx  BN_CTX object (optional)
+     *  \return newly created EC_GROUP object with the specified parameters
+     */
+    EC_GROUP* EC_GROUP_new_curve_GFp(const BIGNUM* p, const BIGNUM* a, const BIGNUM* b, BN_CTX* ctx);
+#ifndef OPENSSL_NO_EC2M
+    /** Creates a new EC_GROUP object with the specified parameters defined
+     *  over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b)
+     *  \param  p    BIGNUM with the polynomial defining the underlying field
+     *  \param  a    BIGNUM with the parameter a of the equation
+     *  \param  b    BIGNUM with the parameter b of the equation
+     *  \param  ctx  BN_CTX object (optional)
+     *  \return newly created EC_GROUP object with the specified parameters
+     */
+    EC_GROUP* EC_GROUP_new_curve_GF2m(const BIGNUM* p, const BIGNUM* a, const BIGNUM* b, BN_CTX* ctx);
+#endif
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/** Returns the EC_METHOD used in EC_POINT object
- *  \param  point  EC_POINT object
- *  \return the EC_METHOD used
- */
-OSSL_DEPRECATEDIN_3_0 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point);
-
-/** Sets the jacobian projective coordinates of a EC_POINT over GFp
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM with the x-coordinate
- *  \param  y      BIGNUM with the y-coordinate
- *  \param  z      BIGNUM with the z-coordinate
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_Jprojective_coordinates_GFp
-                      (const EC_GROUP *group, EC_POINT *p,
-                       const BIGNUM *x, const BIGNUM *y, const BIGNUM *z,
-                       BN_CTX *ctx);
-
-/** Gets the jacobian projective coordinates of a EC_POINT over GFp
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM for the x-coordinate
- *  \param  y      BIGNUM for the y-coordinate
- *  \param  z      BIGNUM for the z-coordinate
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_Jprojective_coordinates_GFp
-                      (const EC_GROUP *group, const EC_POINT *p,
-                       BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx);
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-/** Sets the affine coordinates of an EC_POINT
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM with the x-coordinate
- *  \param  y      BIGNUM with the y-coordinate
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *p,
-                                    const BIGNUM *x, const BIGNUM *y,
-                                    BN_CTX *ctx);
-
-/** Gets the affine coordinates of an EC_POINT.
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM for the x-coordinate
- *  \param  y      BIGNUM for the y-coordinate
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *p,
-                                    BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/** Sets the affine coordinates of an EC_POINT. A synonym of
- *  EC_POINT_set_affine_coordinates
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM with the x-coordinate
- *  \param  y      BIGNUM with the y-coordinate
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_affine_coordinates_GFp
-                      (const EC_GROUP *group, EC_POINT *p,
-                       const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx);
-
-/** Gets the affine coordinates of an EC_POINT. A synonym of
- *  EC_POINT_get_affine_coordinates
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM for the x-coordinate
- *  \param  y      BIGNUM for the y-coordinate
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_affine_coordinates_GFp
-                      (const EC_GROUP *group, const EC_POINT *p,
-                       BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-/** Sets the x9.62 compressed coordinates of a EC_POINT
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM with x-coordinate
- *  \param  y_bit  integer with the y-Bit (either 0 or 1)
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *p,
-                                        const BIGNUM *x, int y_bit,
-                                        BN_CTX *ctx);
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of
- *  EC_POINT_set_compressed_coordinates
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM with x-coordinate
- *  \param  y_bit  integer with the y-Bit (either 0 or 1)
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_compressed_coordinates_GFp
-                      (const EC_GROUP *group, EC_POINT *p,
-                       const BIGNUM *x, int y_bit, BN_CTX *ctx);
-#   ifndef OPENSSL_NO_EC2M
-/** Sets the affine coordinates of an EC_POINT. A synonym of
- *  EC_POINT_set_affine_coordinates
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM with the x-coordinate
- *  \param  y      BIGNUM with the y-coordinate
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_affine_coordinates_GF2m
-                      (const EC_GROUP *group, EC_POINT *p,
-                       const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx);
-
-/** Gets the affine coordinates of an EC_POINT. A synonym of
- *  EC_POINT_get_affine_coordinates
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM for the x-coordinate
- *  \param  y      BIGNUM for the y-coordinate
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_affine_coordinates_GF2m
-                      (const EC_GROUP *group, const EC_POINT *p,
-                       BIGNUM *x, BIGNUM *y, BN_CTX *ctx);
-
-/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of
- *  EC_POINT_set_compressed_coordinates
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  x      BIGNUM with x-coordinate
- *  \param  y_bit  integer with the y-Bit (either 0 or 1)
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_compressed_coordinates_GF2m
-                      (const EC_GROUP *group, EC_POINT *p,
-                       const BIGNUM *x, int y_bit, BN_CTX *ctx);
-#   endif
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-/** Encodes a EC_POINT object to a octet string
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  form   point conversion form
- *  \param  buf    memory buffer for the result. If NULL the function returns
- *                 required buffer size.
- *  \param  len    length of the memory buffer
- *  \param  ctx    BN_CTX object (optional)
- *  \return the length of the encoded octet string or 0 if an error occurred
- */
-size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p,
-                          point_conversion_form_t form,
-                          unsigned char *buf, size_t len, BN_CTX *ctx);
-
-/** Decodes a EC_POINT from a octet string
- *  \param  group  underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \param  buf    memory buffer with the encoded ec point
- *  \param  len    length of the encoded ec point
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p,
-                       const unsigned char *buf, size_t len, BN_CTX *ctx);
-
-/** Encodes an EC_POINT object to an allocated octet string
- *  \param  group  underlying EC_GROUP object
- *  \param  point  EC_POINT object
- *  \param  form   point conversion form
- *  \param  pbuf   returns pointer to allocated buffer
- *  \param  ctx    BN_CTX object (optional)
- *  \return the length of the encoded octet string or 0 if an error occurred
- */
-size_t EC_POINT_point2buf(const EC_GROUP *group, const EC_POINT *point,
-                          point_conversion_form_t form,
-                          unsigned char **pbuf, BN_CTX *ctx);
+    /**
+     * Creates a EC_GROUP object with a curve specified by parameters.
+     * The parameters may be explicit or a named curve,
+     *  \param  params A list of parameters describing the group.
+     *  \param  libctx The associated library context or NULL for the default
+     *                 context
+     *  \param  propq  A property query string
+     *  \return newly created EC_GROUP object with specified parameters or NULL
+     *          if an error occurred
+     */
+    EC_GROUP* EC_GROUP_new_from_params(const OSSL_PARAM params[], OSSL_LIB_CTX* libctx, const char* propq);
+
+    /**
+     * Creates a EC_GROUP object with a curve specified by a NID
+     *  \param  libctx The associated library context or NULL for the default
+     *                 context
+     *  \param  propq  A property query string
+     *  \param  nid    NID of the OID of the curve name
+     *  \return newly created EC_GROUP object with specified curve or NULL
+     *          if an error occurred
+     */
+    EC_GROUP* EC_GROUP_new_by_curve_name_ex(OSSL_LIB_CTX* libctx, const char* propq, int nid);
+
+    /**
+     * Creates a EC_GROUP object with a curve specified by a NID. Same as
+     * EC_GROUP_new_by_curve_name_ex but the libctx and propq are always
+     * NULL.
+     *  \param  nid    NID of the OID of the curve name
+     *  \return newly created EC_GROUP object with specified curve or NULL
+     *          if an error occurred
+     */
+    EC_GROUP* EC_GROUP_new_by_curve_name(int nid);
+
+    /** Creates a new EC_GROUP object from an ECPARAMETERS object
+     *  \param  params  pointer to the ECPARAMETERS object
+     *  \return newly created EC_GROUP object with specified curve or NULL
+     *          if an error occurred
+     */
+    EC_GROUP* EC_GROUP_new_from_ecparameters(const ECPARAMETERS* params);
+
+    /** Creates an ECPARAMETERS object for the given EC_GROUP object.
+     *  \param  group   pointer to the EC_GROUP object
+     *  \param  params  pointer to an existing ECPARAMETERS object or NULL
+     *  \return pointer to the new ECPARAMETERS object or NULL
+     *          if an error occurred.
+     */
+    ECPARAMETERS* EC_GROUP_get_ecparameters(const EC_GROUP* group, ECPARAMETERS* params);
+
+    /** Creates a new EC_GROUP object from an ECPKPARAMETERS object
+     *  \param  params  pointer to an existing ECPKPARAMETERS object, or NULL
+     *  \return newly created EC_GROUP object with specified curve, or NULL
+     *          if an error occurred
+     */
+    EC_GROUP* EC_GROUP_new_from_ecpkparameters(const ECPKPARAMETERS* params);
+
+    /** Creates an ECPKPARAMETERS object for the given EC_GROUP object.
+     *  \param  group   pointer to the EC_GROUP object
+     *  \param  params  pointer to an existing ECPKPARAMETERS object or NULL
+     *  \return pointer to the new ECPKPARAMETERS object or NULL
+     *          if an error occurred.
+     */
+    ECPKPARAMETERS* EC_GROUP_get_ecpkparameters(const EC_GROUP* group, ECPKPARAMETERS* params);
+
+    /********************************************************************/
+    /*               handling of internal curves                        */
+    /********************************************************************/
+
+    typedef struct
+    {
+        int nid;
+        const char* comment;
+    } EC_builtin_curve;
+
+    /*
+     * EC_builtin_curves(EC_builtin_curve *r, size_t size) returns number of all
+     * available curves or zero if a error occurred. In case r is not zero,
+     * nitems EC_builtin_curve structures are filled with the data of the first
+     * nitems internal groups
+     */
+    size_t EC_get_builtin_curves(EC_builtin_curve* r, size_t nitems);
+
+    const char* EC_curve_nid2nist(int nid);
+    int EC_curve_nist2nid(const char* name);
+    int EC_GROUP_check_named_curve(const EC_GROUP* group, int nist_only, BN_CTX* ctx);
+
+    /********************************************************************/
+    /*                    EC_POINT functions                            */
+    /********************************************************************/
+
+    /** Creates a new EC_POINT object for the specified EC_GROUP
+     *  \param  group  EC_GROUP the underlying EC_GROUP object
+     *  \return newly created EC_POINT object or NULL if an error occurred
+     */
+    EC_POINT* EC_POINT_new(const EC_GROUP* group);
+
+    /** Frees a EC_POINT object
+     *  \param  point  EC_POINT object to be freed
+     */
+    void EC_POINT_free(EC_POINT* point);
+
+    /** Clears and frees a EC_POINT object
+     *  \param  point  EC_POINT object to be cleared and freed
+     */
+    void EC_POINT_clear_free(EC_POINT* point);
+
+    /** Copies EC_POINT object
+     *  \param  dst  destination EC_POINT object
+     *  \param  src  source EC_POINT object
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_copy(EC_POINT* dst, const EC_POINT* src);
+
+    /** Creates a new EC_POINT object and copies the content of the supplied
+     *  EC_POINT
+     *  \param  src    source EC_POINT object
+     *  \param  group  underlying the EC_GROUP object
+     *  \return newly created EC_POINT object or NULL if an error occurred
+     */
+    EC_POINT* EC_POINT_dup(const EC_POINT* src, const EC_GROUP* group);
+
+    /** Sets a point to infinity (neutral element)
+     *  \param  group  underlying EC_GROUP object
+     *  \param  point  EC_POINT to set to infinity
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_set_to_infinity(const EC_GROUP* group, EC_POINT* point);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /** Returns the EC_METHOD used in EC_POINT object
+     *  \param  point  EC_POINT object
+     *  \return the EC_METHOD used
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_METHOD* EC_POINT_method_of(const EC_POINT* point);
+
+    /** Sets the jacobian projective coordinates of a EC_POINT over GFp
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM with the x-coordinate
+     *  \param  y      BIGNUM with the y-coordinate
+     *  \param  z      BIGNUM with the z-coordinate
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP* group, EC_POINT* p, const BIGNUM* x, const BIGNUM* y, const BIGNUM* z, BN_CTX* ctx);
+
+    /** Gets the jacobian projective coordinates of a EC_POINT over GFp
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM for the x-coordinate
+     *  \param  y      BIGNUM for the y-coordinate
+     *  \param  z      BIGNUM for the z-coordinate
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP* group, const EC_POINT* p, BIGNUM* x, BIGNUM* y, BIGNUM* z, BN_CTX* ctx);
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    /** Sets the affine coordinates of an EC_POINT
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM with the x-coordinate
+     *  \param  y      BIGNUM with the y-coordinate
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_set_affine_coordinates(const EC_GROUP* group, EC_POINT* p, const BIGNUM* x, const BIGNUM* y, BN_CTX* ctx);
+
+    /** Gets the affine coordinates of an EC_POINT.
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM for the x-coordinate
+     *  \param  y      BIGNUM for the y-coordinate
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_get_affine_coordinates(const EC_GROUP* group, const EC_POINT* p, BIGNUM* x, BIGNUM* y, BN_CTX* ctx);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /** Sets the affine coordinates of an EC_POINT. A synonym of
+     *  EC_POINT_set_affine_coordinates
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM with the x-coordinate
+     *  \param  y      BIGNUM with the y-coordinate
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP* group, EC_POINT* p, const BIGNUM* x, const BIGNUM* y, BN_CTX* ctx);
+
+    /** Gets the affine coordinates of an EC_POINT. A synonym of
+     *  EC_POINT_get_affine_coordinates
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM for the x-coordinate
+     *  \param  y      BIGNUM for the y-coordinate
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP* group, const EC_POINT* p, BIGNUM* x, BIGNUM* y, BN_CTX* ctx);
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    /** Sets the x9.62 compressed coordinates of a EC_POINT
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM with x-coordinate
+     *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_set_compressed_coordinates(const EC_GROUP* group, EC_POINT* p, const BIGNUM* x, int y_bit, BN_CTX* ctx);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of
+     *  EC_POINT_set_compressed_coordinates
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM with x-coordinate
+     *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP* group, EC_POINT* p, const BIGNUM* x, int y_bit, BN_CTX* ctx);
+#ifndef OPENSSL_NO_EC2M
+    /** Sets the affine coordinates of an EC_POINT. A synonym of
+     *  EC_POINT_set_affine_coordinates
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM with the x-coordinate
+     *  \param  y      BIGNUM with the y-coordinate
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP* group, EC_POINT* p, const BIGNUM* x, const BIGNUM* y, BN_CTX* ctx);
+
+    /** Gets the affine coordinates of an EC_POINT. A synonym of
+     *  EC_POINT_get_affine_coordinates
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM for the x-coordinate
+     *  \param  y      BIGNUM for the y-coordinate
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP* group, const EC_POINT* p, BIGNUM* x, BIGNUM* y, BN_CTX* ctx);
+
+    /** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of
+     *  EC_POINT_set_compressed_coordinates
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  x      BIGNUM with x-coordinate
+     *  \param  y_bit  integer with the y-Bit (either 0 or 1)
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP* group, EC_POINT* p, const BIGNUM* x, int y_bit, BN_CTX* ctx);
+#endif
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    /** Encodes a EC_POINT object to a octet string
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  form   point conversion form
+     *  \param  buf    memory buffer for the result. If NULL the function returns
+     *                 required buffer size.
+     *  \param  len    length of the memory buffer
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return the length of the encoded octet string or 0 if an error occurred
+     */
+    size_t EC_POINT_point2oct(const EC_GROUP* group, const EC_POINT* p, point_conversion_form_t form, unsigned char* buf, size_t len, BN_CTX* ctx);
+
+    /** Decodes a EC_POINT from a octet string
+     *  \param  group  underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \param  buf    memory buffer with the encoded ec point
+     *  \param  len    length of the encoded ec point
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_oct2point(const EC_GROUP* group, EC_POINT* p, const unsigned char* buf, size_t len, BN_CTX* ctx);
+
+    /** Encodes an EC_POINT object to an allocated octet string
+     *  \param  group  underlying EC_GROUP object
+     *  \param  point  EC_POINT object
+     *  \param  form   point conversion form
+     *  \param  pbuf   returns pointer to allocated buffer
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return the length of the encoded octet string or 0 if an error occurred
+     */
+    size_t EC_POINT_point2buf(const EC_GROUP* group, const EC_POINT* point, point_conversion_form_t form, unsigned char** pbuf, BN_CTX* ctx);
 
 /* other interfaces to point2oct/oct2point: */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 BIGNUM *EC_POINT_point2bn(const EC_GROUP *,
-                                                const EC_POINT *,
-                                                point_conversion_form_t form,
-                                                BIGNUM *, BN_CTX *);
-OSSL_DEPRECATEDIN_3_0 EC_POINT *EC_POINT_bn2point(const EC_GROUP *,
-                                                  const BIGNUM *,
-                                                  EC_POINT *, BN_CTX *);
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *,
-                         point_conversion_form_t form, BN_CTX *);
-EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *,
-                             EC_POINT *, BN_CTX *);
-
-/********************************************************************/
-/*         functions for doing EC_POINT arithmetic                  */
-/********************************************************************/
-
-/** Computes the sum of two EC_POINT
- *  \param  group  underlying EC_GROUP object
- *  \param  r      EC_POINT object for the result (r = a + b)
- *  \param  a      EC_POINT object with the first summand
- *  \param  b      EC_POINT object with the second summand
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
-                 const EC_POINT *b, BN_CTX *ctx);
-
-/** Computes the double of a EC_POINT
- *  \param  group  underlying EC_GROUP object
- *  \param  r      EC_POINT object for the result (r = 2 * a)
- *  \param  a      EC_POINT object
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
-                 BN_CTX *ctx);
-
-/** Computes the inverse of a EC_POINT
- *  \param  group  underlying EC_GROUP object
- *  \param  a      EC_POINT object to be inverted (it's used for the result as well)
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx);
-
-/** Checks whether the point is the neutral element of the group
- *  \param  group  the underlying EC_GROUP object
- *  \param  p      EC_POINT object
- *  \return 1 if the point is the neutral element and 0 otherwise
- */
-int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p);
-
-/** Checks whether the point is on the curve
- *  \param  group  underlying EC_GROUP object
- *  \param  point  EC_POINT object to check
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 if the point is on the curve, 0 if not, or -1 on error
- */
-int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
-                         BN_CTX *ctx);
-
-/** Compares two EC_POINTs
- *  \param  group  underlying EC_GROUP object
- *  \param  a      first EC_POINT object
- *  \param  b      second EC_POINT object
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 if the points are not equal, 0 if they are, or -1 on error
- */
-int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
-                 BN_CTX *ctx);
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int EC_POINT_make_affine(const EC_GROUP *group,
-                                               EC_POINT *point, BN_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num,
-                                                EC_POINT *points[], BN_CTX *ctx);
-
-/** Computes r = generator * n + sum_{i=0}^{num-1} p[i] * m[i]
- *  \param  group  underlying EC_GROUP object
- *  \param  r      EC_POINT object for the result
- *  \param  n      BIGNUM with the multiplier for the group generator (optional)
- *  \param  num    number further summands
- *  \param  p      array of size num of EC_POINT objects
- *  \param  m      array of size num of BIGNUM objects
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r,
-                                        const BIGNUM *n, size_t num,
-                                        const EC_POINT *p[], const BIGNUM *m[],
-                                        BN_CTX *ctx);
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-/** Computes r = generator * n + q * m
- *  \param  group  underlying EC_GROUP object
- *  \param  r      EC_POINT object for the result
- *  \param  n      BIGNUM with the multiplier for the group generator (optional)
- *  \param  q      EC_POINT object with the first factor of the second summand
- *  \param  m      BIGNUM with the second factor of the second summand
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n,
-                 const EC_POINT *q, const BIGNUM *m, BN_CTX *ctx);
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/** Stores multiples of generator for faster point multiplication
- *  \param  group  EC_GROUP object
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx);
-
-/** Reports whether a precomputation has been done
- *  \param  group  EC_GROUP object
- *  \return 1 if a pre-computation has been done and 0 otherwise
- */
-OSSL_DEPRECATEDIN_3_0 int EC_GROUP_have_precompute_mult(const EC_GROUP *group);
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-/********************************************************************/
-/*                       ASN1 stuff                                 */
-/********************************************************************/
-
-DECLARE_ASN1_ITEM(ECPKPARAMETERS)
-DECLARE_ASN1_ALLOC_FUNCTIONS(ECPKPARAMETERS)
-DECLARE_ASN1_ITEM(ECPARAMETERS)
-DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS)
-
-/*
- * EC_GROUP_get_basis_type() returns the NID of the basis type used to
- * represent the field elements
- */
-int EC_GROUP_get_basis_type(const EC_GROUP *);
-#  ifndef OPENSSL_NO_EC2M
-int EC_GROUP_get_trinomial_basis(const EC_GROUP *, unsigned int *k);
-int EC_GROUP_get_pentanomial_basis(const EC_GROUP *, unsigned int *k1,
-                                   unsigned int *k2, unsigned int *k3);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 BIGNUM* EC_POINT_point2bn(const EC_GROUP*, const EC_POINT*, point_conversion_form_t form, BIGNUM*, BN_CTX*);
+    OSSL_DEPRECATEDIN_3_0 EC_POINT* EC_POINT_bn2point(const EC_GROUP*, const BIGNUM*, EC_POINT*, BN_CTX*);
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    char* EC_POINT_point2hex(const EC_GROUP*, const EC_POINT*, point_conversion_form_t form, BN_CTX*);
+    EC_POINT* EC_POINT_hex2point(const EC_GROUP*, const char*, EC_POINT*, BN_CTX*);
+
+    /********************************************************************/
+    /*         functions for doing EC_POINT arithmetic                  */
+    /********************************************************************/
+
+    /** Computes the sum of two EC_POINT
+     *  \param  group  underlying EC_GROUP object
+     *  \param  r      EC_POINT object for the result (r = a + b)
+     *  \param  a      EC_POINT object with the first summand
+     *  \param  b      EC_POINT object with the second summand
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_add(const EC_GROUP* group, EC_POINT* r, const EC_POINT* a, const EC_POINT* b, BN_CTX* ctx);
+
+    /** Computes the double of a EC_POINT
+     *  \param  group  underlying EC_GROUP object
+     *  \param  r      EC_POINT object for the result (r = 2 * a)
+     *  \param  a      EC_POINT object
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_dbl(const EC_GROUP* group, EC_POINT* r, const EC_POINT* a, BN_CTX* ctx);
+
+    /** Computes the inverse of a EC_POINT
+     *  \param  group  underlying EC_GROUP object
+     *  \param  a      EC_POINT object to be inverted (it's used for the result as well)
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_invert(const EC_GROUP* group, EC_POINT* a, BN_CTX* ctx);
+
+    /** Checks whether the point is the neutral element of the group
+     *  \param  group  the underlying EC_GROUP object
+     *  \param  p      EC_POINT object
+     *  \return 1 if the point is the neutral element and 0 otherwise
+     */
+    int EC_POINT_is_at_infinity(const EC_GROUP* group, const EC_POINT* p);
+
+    /** Checks whether the point is on the curve
+     *  \param  group  underlying EC_GROUP object
+     *  \param  point  EC_POINT object to check
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 if the point is on the curve, 0 if not, or -1 on error
+     */
+    int EC_POINT_is_on_curve(const EC_GROUP* group, const EC_POINT* point, BN_CTX* ctx);
+
+    /** Compares two EC_POINTs
+     *  \param  group  underlying EC_GROUP object
+     *  \param  a      first EC_POINT object
+     *  \param  b      second EC_POINT object
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 if the points are not equal, 0 if they are, or -1 on error
+     */
+    int EC_POINT_cmp(const EC_GROUP* group, const EC_POINT* a, const EC_POINT* b, BN_CTX* ctx);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int EC_POINT_make_affine(const EC_GROUP* group, EC_POINT* point, BN_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 int EC_POINTs_make_affine(const EC_GROUP* group, size_t num, EC_POINT* points[], BN_CTX* ctx);
+
+    /** Computes r = generator * n + sum_{i=0}^{num-1} p[i] * m[i]
+     *  \param  group  underlying EC_GROUP object
+     *  \param  r      EC_POINT object for the result
+     *  \param  n      BIGNUM with the multiplier for the group generator (optional)
+     *  \param  num    number further summands
+     *  \param  p      array of size num of EC_POINT objects
+     *  \param  m      array of size num of BIGNUM objects
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_POINTs_mul(const EC_GROUP* group, EC_POINT* r, const BIGNUM* n, size_t num, const EC_POINT* p[], const BIGNUM* m[], BN_CTX* ctx);
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    /** Computes r = generator * n + q * m
+     *  \param  group  underlying EC_GROUP object
+     *  \param  r      EC_POINT object for the result
+     *  \param  n      BIGNUM with the multiplier for the group generator (optional)
+     *  \param  q      EC_POINT object with the first factor of the second summand
+     *  \param  m      BIGNUM with the second factor of the second summand
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    int EC_POINT_mul(const EC_GROUP* group, EC_POINT* r, const BIGNUM* n, const EC_POINT* q, const BIGNUM* m, BN_CTX* ctx);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /** Stores multiples of generator for faster point multiplication
+     *  \param  group  EC_GROUP object
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_GROUP_precompute_mult(EC_GROUP* group, BN_CTX* ctx);
+
+    /** Reports whether a precomputation has been done
+     *  \param  group  EC_GROUP object
+     *  \return 1 if a pre-computation has been done and 0 otherwise
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_GROUP_have_precompute_mult(const EC_GROUP* group);
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    /********************************************************************/
+    /*                       ASN1 stuff                                 */
+    /********************************************************************/
+
+    DECLARE_ASN1_ITEM(ECPKPARAMETERS)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(ECPKPARAMETERS)
+    DECLARE_ASN1_ITEM(ECPARAMETERS)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS)
+
+    /*
+     * EC_GROUP_get_basis_type() returns the NID of the basis type used to
+     * represent the field elements
+     */
+    int EC_GROUP_get_basis_type(const EC_GROUP*);
+#ifndef OPENSSL_NO_EC2M
+    int EC_GROUP_get_trinomial_basis(const EC_GROUP*, unsigned int* k);
+    int EC_GROUP_get_pentanomial_basis(const EC_GROUP*, unsigned int* k1, unsigned int* k2, unsigned int* k3);
+#endif
 
-EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len);
-int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out);
+    EC_GROUP* d2i_ECPKParameters(EC_GROUP**, const unsigned char** in, long len);
+    int i2d_ECPKParameters(const EC_GROUP*, unsigned char** out);
 
-#  define d2i_ECPKParameters_bio(bp,x) \
+#define d2i_ECPKParameters_bio(bp, x) \
     ASN1_d2i_bio_of(EC_GROUP, NULL, d2i_ECPKParameters, bp, x)
-#  define i2d_ECPKParameters_bio(bp,x) \
+#define i2d_ECPKParameters_bio(bp, x) \
     ASN1_i2d_bio_of(EC_GROUP, i2d_ECPKParameters, bp, x)
-#  define d2i_ECPKParameters_fp(fp,x) \
-    (EC_GROUP *)ASN1_d2i_fp(NULL, (d2i_of_void *)d2i_ECPKParameters, (fp), \
-                            (void **)(x))
-#  define i2d_ECPKParameters_fp(fp,x) \
-    ASN1_i2d_fp((i2d_of_void *)i2d_ECPKParameters, (fp), (void *)(x))
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ECPKParameters_print(BIO *bp, const EC_GROUP *x,
-                                               int off);
-#   ifndef OPENSSL_NO_STDIO
-OSSL_DEPRECATEDIN_3_0 int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x,
-                                                  int off);
-#   endif
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#define d2i_ECPKParameters_fp(fp, x) \
+    (EC_GROUP*)ASN1_d2i_fp(NULL, (d2i_of_void*)d2i_ECPKParameters, (fp), (void**)(x))
+#define i2d_ECPKParameters_fp(fp, x) \
+    ASN1_i2d_fp((i2d_of_void*)i2d_ECPKParameters, (fp), (void*)(x))
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ECPKParameters_print(BIO* bp, const EC_GROUP* x, int off);
+#ifndef OPENSSL_NO_STDIO
+    OSSL_DEPRECATEDIN_3_0 int ECPKParameters_print_fp(FILE* fp, const EC_GROUP* x, int off);
+#endif
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
 
 /********************************************************************/
 /*                      EC_KEY functions                            */
 /********************************************************************/
 
 /* some values for the encoding_flag */
-#  define EC_PKEY_NO_PARAMETERS   0x001
-#  define EC_PKEY_NO_PUBKEY       0x002
+#define EC_PKEY_NO_PARAMETERS 0x001
+#define EC_PKEY_NO_PUBKEY 0x002
 
 /* some values for the flags field */
-#  define EC_FLAG_SM2_RANGE              0x0004
-#  define EC_FLAG_COFACTOR_ECDH          0x1000
-#  define EC_FLAG_CHECK_NAMED_GROUP      0x2000
-#  define EC_FLAG_CHECK_NAMED_GROUP_NIST 0x4000
-#  define EC_FLAG_CHECK_NAMED_GROUP_MASK \
+#define EC_FLAG_SM2_RANGE 0x0004
+#define EC_FLAG_COFACTOR_ECDH 0x1000
+#define EC_FLAG_CHECK_NAMED_GROUP 0x2000
+#define EC_FLAG_CHECK_NAMED_GROUP_NIST 0x4000
+#define EC_FLAG_CHECK_NAMED_GROUP_MASK \
     (EC_FLAG_CHECK_NAMED_GROUP | EC_FLAG_CHECK_NAMED_GROUP_NIST)
 
 /* Deprecated flags -  it was using 0x01..0x02 */
-#  define EC_FLAG_NON_FIPS_ALLOW         0x0000
-#  define EC_FLAG_FIPS_CHECKED           0x0000
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/**
- *  Creates a new EC_KEY object.
- *  \param  ctx  The library context for to use for this EC_KEY. May be NULL in
- *               which case the default library context is used.
- *  \return EC_KEY object or NULL if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_ex(OSSL_LIB_CTX *ctx, const char *propq);
-
-/**
- *  Creates a new EC_KEY object. Same as calling EC_KEY_new_ex with a
- *  NULL library context
- *  \return EC_KEY object or NULL if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new(void);
-
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_get_flags(const EC_KEY *key);
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_flags(EC_KEY *key, int flags);
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_clear_flags(EC_KEY *key, int flags);
-
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_decoded_from_explicit_params(const EC_KEY *key);
-
-/**
- *  Creates a new EC_KEY object using a named curve as underlying
- *  EC_GROUP object.
- *  \param  ctx   The library context for to use for this EC_KEY. May be NULL in
- *                which case the default library context is used.
- *  \param  propq Any property query string
- *  \param  nid   NID of the named curve.
- *  \return EC_KEY object or NULL if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_by_curve_name_ex(OSSL_LIB_CTX *ctx,
-                                                          const char *propq,
-                                                          int nid);
-
-/**
- *  Creates a new EC_KEY object using a named curve as underlying
- *  EC_GROUP object. Same as calling EC_KEY_new_by_curve_name_ex with a NULL
- *  library context and property query string.
- *  \param  nid  NID of the named curve.
- *  \return EC_KEY object or NULL if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_by_curve_name(int nid);
-
-/** Frees a EC_KEY object.
- *  \param  key  EC_KEY object to be freed.
- */
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_free(EC_KEY *key);
-
-/** Copies a EC_KEY object.
- *  \param  dst  destination EC_KEY object
- *  \param  src  src EC_KEY object
- *  \return dst or NULL if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src);
-
-/** Creates a new EC_KEY object and copies the content from src to it.
- *  \param  src  the source EC_KEY object
- *  \return newly created EC_KEY object or NULL if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_dup(const EC_KEY *src);
-
-/** Increases the internal reference count of a EC_KEY object.
- *  \param  key  EC_KEY object
- *  \return 1 on success and 0 if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_up_ref(EC_KEY *key);
-
-/** Returns the ENGINE object of a EC_KEY object
- *  \param  eckey  EC_KEY object
- *  \return the ENGINE object (possibly NULL).
- */
-OSSL_DEPRECATEDIN_3_0 ENGINE *EC_KEY_get0_engine(const EC_KEY *eckey);
-
-/** Returns the EC_GROUP object of a EC_KEY object
- *  \param  key  EC_KEY object
- *  \return the EC_GROUP object (possibly NULL).
- */
-OSSL_DEPRECATEDIN_3_0 const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key);
-
-/** Sets the EC_GROUP of a EC_KEY object.
- *  \param  key    EC_KEY object
- *  \param  group  EC_GROUP to use in the EC_KEY object (note: the EC_KEY
- *                 object will use an own copy of the EC_GROUP).
- *  \return 1 on success and 0 if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group);
-
-/** Returns the private key of a EC_KEY object.
- *  \param  key  EC_KEY object
- *  \return a BIGNUM with the private key (possibly NULL).
- */
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key);
-
-/** Sets the private key of a EC_KEY object.
- *  \param  key  EC_KEY object
- *  \param  prv  BIGNUM with the private key (note: the EC_KEY object
- *               will use an own copy of the BIGNUM).
- *  \return 1 on success and 0 if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv);
-
-/** Returns the public key of a EC_KEY object.
- *  \param  key  the EC_KEY object
- *  \return a EC_POINT object with the public key (possibly NULL)
- */
-OSSL_DEPRECATEDIN_3_0 const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key);
-
-/** Sets the public key of a EC_KEY object.
- *  \param  key  EC_KEY object
- *  \param  pub  EC_POINT object with the public key (note: the EC_KEY object
- *               will use an own copy of the EC_POINT object).
- *  \return 1 on success and 0 if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub);
-
-OSSL_DEPRECATEDIN_3_0 unsigned EC_KEY_get_enc_flags(const EC_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags);
-OSSL_DEPRECATEDIN_3_0 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_conv_form(EC_KEY *eckey,
-                                                point_conversion_form_t cform);
-#  endif /*OPENSSL_NO_DEPRECATED_3_0 */
-
-#  define EC_KEY_get_ex_new_index(l, p, newf, dupf, freef) \
+#define EC_FLAG_NON_FIPS_ALLOW 0x0000
+#define EC_FLAG_FIPS_CHECKED 0x0000
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /**
+     *  Creates a new EC_KEY object.
+     *  \param  ctx  The library context for to use for this EC_KEY. May be NULL in
+     *               which case the default library context is used.
+     *  \return EC_KEY object or NULL if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* EC_KEY_new_ex(OSSL_LIB_CTX* ctx, const char* propq);
+
+    /**
+     *  Creates a new EC_KEY object. Same as calling EC_KEY_new_ex with a
+     *  NULL library context
+     *  \return EC_KEY object or NULL if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* EC_KEY_new(void);
+
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_get_flags(const EC_KEY* key);
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_flags(EC_KEY* key, int flags);
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_clear_flags(EC_KEY* key, int flags);
+
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_decoded_from_explicit_params(const EC_KEY* key);
+
+    /**
+     *  Creates a new EC_KEY object using a named curve as underlying
+     *  EC_GROUP object.
+     *  \param  ctx   The library context for to use for this EC_KEY. May be NULL in
+     *                which case the default library context is used.
+     *  \param  propq Any property query string
+     *  \param  nid   NID of the named curve.
+     *  \return EC_KEY object or NULL if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* EC_KEY_new_by_curve_name_ex(OSSL_LIB_CTX* ctx, const char* propq, int nid);
+
+    /**
+     *  Creates a new EC_KEY object using a named curve as underlying
+     *  EC_GROUP object. Same as calling EC_KEY_new_by_curve_name_ex with a NULL
+     *  library context and property query string.
+     *  \param  nid  NID of the named curve.
+     *  \return EC_KEY object or NULL if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* EC_KEY_new_by_curve_name(int nid);
+
+    /** Frees a EC_KEY object.
+     *  \param  key  EC_KEY object to be freed.
+     */
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_free(EC_KEY* key);
+
+    /** Copies a EC_KEY object.
+     *  \param  dst  destination EC_KEY object
+     *  \param  src  src EC_KEY object
+     *  \return dst or NULL if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* EC_KEY_copy(EC_KEY* dst, const EC_KEY* src);
+
+    /** Creates a new EC_KEY object and copies the content from src to it.
+     *  \param  src  the source EC_KEY object
+     *  \return newly created EC_KEY object or NULL if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* EC_KEY_dup(const EC_KEY* src);
+
+    /** Increases the internal reference count of a EC_KEY object.
+     *  \param  key  EC_KEY object
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_up_ref(EC_KEY* key);
+
+    /** Returns the ENGINE object of a EC_KEY object
+     *  \param  eckey  EC_KEY object
+     *  \return the ENGINE object (possibly NULL).
+     */
+    OSSL_DEPRECATEDIN_3_0 ENGINE* EC_KEY_get0_engine(const EC_KEY* eckey);
+
+    /** Returns the EC_GROUP object of a EC_KEY object
+     *  \param  key  EC_KEY object
+     *  \return the EC_GROUP object (possibly NULL).
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_GROUP* EC_KEY_get0_group(const EC_KEY* key);
+
+    /** Sets the EC_GROUP of a EC_KEY object.
+     *  \param  key    EC_KEY object
+     *  \param  group  EC_GROUP to use in the EC_KEY object (note: the EC_KEY
+     *                 object will use an own copy of the EC_GROUP).
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_group(EC_KEY* key, const EC_GROUP* group);
+
+    /** Returns the private key of a EC_KEY object.
+     *  \param  key  EC_KEY object
+     *  \return a BIGNUM with the private key (possibly NULL).
+     */
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* EC_KEY_get0_private_key(const EC_KEY* key);
+
+    /** Sets the private key of a EC_KEY object.
+     *  \param  key  EC_KEY object
+     *  \param  prv  BIGNUM with the private key (note: the EC_KEY object
+     *               will use an own copy of the BIGNUM).
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_private_key(EC_KEY* key, const BIGNUM* prv);
+
+    /** Returns the public key of a EC_KEY object.
+     *  \param  key  the EC_KEY object
+     *  \return a EC_POINT object with the public key (possibly NULL)
+     */
+    OSSL_DEPRECATEDIN_3_0 const EC_POINT* EC_KEY_get0_public_key(const EC_KEY* key);
+
+    /** Sets the public key of a EC_KEY object.
+     *  \param  key  EC_KEY object
+     *  \param  pub  EC_POINT object with the public key (note: the EC_KEY object
+     *               will use an own copy of the EC_POINT object).
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_public_key(EC_KEY* key, const EC_POINT* pub);
+
+    OSSL_DEPRECATEDIN_3_0 unsigned EC_KEY_get_enc_flags(const EC_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_enc_flags(EC_KEY* eckey, unsigned int flags);
+    OSSL_DEPRECATEDIN_3_0 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_conv_form(EC_KEY* eckey, point_conversion_form_t cform);
+#endif /*OPENSSL_NO_DEPRECATED_3_0 */
+
+#define EC_KEY_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_EC_KEY, l, p, newf, dupf, freef)
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_ex_data(EC_KEY *key, int idx, void *arg);
-OSSL_DEPRECATEDIN_3_0 void *EC_KEY_get_ex_data(const EC_KEY *key, int idx);
-
-/* wrapper functions for the underlying EC_GROUP object */
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag);
-
-/** Creates a table of pre-computed multiples of the generator to
- *  accelerate further EC_KEY operations.
- *  \param  key  EC_KEY object
- *  \param  ctx  BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx);
-
-/** Creates a new ec private (and optional a new public) key.
- *  \param  key  EC_KEY object
- *  \return 1 on success and 0 if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_generate_key(EC_KEY *key);
-
-/** Verifies that a private and/or public key is valid.
- *  \param  key  the EC_KEY object
- *  \return 1 on success and 0 otherwise.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_check_key(const EC_KEY *key);
-
-/** Indicates if an EC_KEY can be used for signing.
- *  \param  eckey  the EC_KEY object
- *  \return 1 if can can sign and 0 otherwise.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_can_sign(const EC_KEY *eckey);
-
-/** Sets a public key from affine coordinates performing
- *  necessary NIST PKV tests.
- *  \param  key  the EC_KEY object
- *  \param  x    public key x coordinate
- *  \param  y    public key y coordinate
- *  \return 1 on success and 0 otherwise.
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key,
-                                                                   BIGNUM *x,
-                                                                   BIGNUM *y);
-
-/** Encodes an EC_KEY public key to an allocated octet string
- *  \param  key    key to encode
- *  \param  form   point conversion form
- *  \param  pbuf   returns pointer to allocated buffer
- *  \param  ctx    BN_CTX object (optional)
- *  \return the length of the encoded octet string or 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_key2buf(const EC_KEY *key,
-                                            point_conversion_form_t form,
-                                            unsigned char **pbuf, BN_CTX *ctx);
-
-/** Decodes a EC_KEY public key from a octet string
- *  \param  key    key to decode
- *  \param  buf    memory buffer with the encoded ec point
- *  \param  len    length of the encoded ec point
- *  \param  ctx    BN_CTX object (optional)
- *  \return 1 on success and 0 if an error occurred
- */
-
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf,
-                                         size_t len, BN_CTX *ctx);
-
-/** Decodes an EC_KEY private key from an octet string
- *  \param  key    key to decode
- *  \param  buf    memory buffer with the encoded private key
- *  \param  len    length of the encoded key
- *  \return 1 on success and 0 if an error occurred
- */
-
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_oct2priv(EC_KEY *key, const unsigned char *buf,
-                                          size_t len);
-
-/** Encodes a EC_KEY private key to an octet string
- *  \param  key    key to encode
- *  \param  buf    memory buffer for the result. If NULL the function returns
- *                 required buffer size.
- *  \param  len    length of the memory buffer
- *  \return the length of the encoded octet string or 0 if an error occurred
- */
-
-OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_priv2oct(const EC_KEY *key,
-                                             unsigned char *buf, size_t len);
-
-/** Encodes an EC_KEY private key to an allocated octet string
- *  \param  eckey  key to encode
- *  \param  pbuf   returns pointer to allocated buffer
- *  \return the length of the encoded octet string or 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_priv2buf(const EC_KEY *eckey,
-                                             unsigned char **pbuf);
-
-/********************************************************************/
-/*        de- and encoding functions for SEC1 ECPrivateKey          */
-/********************************************************************/
-
-/** Decodes a private key from a memory buffer.
- *  \param  key  a pointer to a EC_KEY object which should be used (or NULL)
- *  \param  in   pointer to memory with the DER encoded private key
- *  \param  len  length of the DER encoded private key
- *  \return the decoded private key or NULL if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey(EC_KEY **key,
-                                               const unsigned char **in,
-                                               long len);
-
-/** Encodes a private key object and stores the result in a buffer.
- *  \param  key  the EC_KEY object to encode
- *  \param  out  the buffer for the result (if NULL the function returns number
- *               of bytes needed).
- *  \return 1 on success and 0 if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey(const EC_KEY *key,
-                                           unsigned char **out);
-
-/********************************************************************/
-/*        de- and encoding functions for EC parameters              */
-/********************************************************************/
-
-/** Decodes ec parameter from a memory buffer.
- *  \param  key  a pointer to a EC_KEY object which should be used (or NULL)
- *  \param  in   pointer to memory with the DER encoded ec parameters
- *  \param  len  length of the DER encoded ec parameters
- *  \return a EC_KEY object with the decoded parameters or NULL if an error
- *          occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECParameters(EC_KEY **key,
-                                               const unsigned char **in,
-                                               long len);
-
-/** Encodes ec parameter and stores the result in a buffer.
- *  \param  key  the EC_KEY object with ec parameters to encode
- *  \param  out  the buffer for the result (if NULL the function returns number
- *               of bytes needed).
- *  \return 1 on success and 0 if an error occurred.
- */
-OSSL_DEPRECATEDIN_3_0 int i2d_ECParameters(const EC_KEY *key,
-                                           unsigned char **out);
-
-/********************************************************************/
-/*         de- and encoding functions for EC public key             */
-/*         (octet string, not DER -- hence 'o2i' and 'i2o')         */
-/********************************************************************/
-
-/** Decodes an ec public key from a octet string.
- *  \param  key  a pointer to a EC_KEY object which should be used
- *  \param  in   memory buffer with the encoded public key
- *  \param  len  length of the encoded public key
- *  \return EC_KEY object with decoded public key or NULL if an error
- *          occurred.
- */
-OSSL_DEPRECATEDIN_3_0 EC_KEY *o2i_ECPublicKey(EC_KEY **key,
-                                              const unsigned char **in, long len);
-
-/** Encodes an ec public key in an octet string.
- *  \param  key  the EC_KEY object with the public key
- *  \param  out  the buffer for the result (if NULL the function returns number
- *               of bytes needed).
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int i2o_ECPublicKey(const EC_KEY *key, unsigned char **out);
-
-/** Prints out the ec parameters on human readable form.
- *  \param  bp   BIO object to which the information is printed
- *  \param  key  EC_KEY object
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int ECParameters_print(BIO *bp, const EC_KEY *key);
-
-/** Prints out the contents of a EC_KEY object
- *  \param  bp   BIO object to which the information is printed
- *  \param  key  EC_KEY object
- *  \param  off  line offset
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_print(BIO *bp, const EC_KEY *key, int off);
-
-#   ifndef OPENSSL_NO_STDIO
-/** Prints out the ec parameters on human readable form.
- *  \param  fp   file descriptor to which the information is printed
- *  \param  key  EC_KEY object
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int ECParameters_print_fp(FILE *fp, const EC_KEY *key);
-
-/** Prints out the contents of a EC_KEY object
- *  \param  fp   file descriptor to which the information is printed
- *  \param  key  EC_KEY object
- *  \param  off  line offset
- *  \return 1 on success and 0 if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off);
-#   endif /* OPENSSL_NO_STDIO */
-
-OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_OpenSSL(void);
-OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_get_default_method(void);
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_default_method(const EC_KEY_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *EC_KEY_get_method(const EC_KEY *key);
-OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 EC_KEY *EC_KEY_new_method(ENGINE *engine);
-
-/** The old name for ecdh_KDF_X9_63
- *  The ECDH KDF specification has been mistakingly attributed to ANSI X9.62,
- *  it is actually specified in ANSI X9.63.
- *  This identifier is retained for backwards compatibility
- */
-OSSL_DEPRECATEDIN_3_0 int ECDH_KDF_X9_62(unsigned char *out, size_t outlen,
-                                         const unsigned char *Z, size_t Zlen,
-                                         const unsigned char *sinfo,
-                                         size_t sinfolen, const EVP_MD *md);
-
-OSSL_DEPRECATEDIN_3_0 int ECDH_compute_key(void *out, size_t outlen,
-                                           const EC_POINT *pub_key,
-                                           const EC_KEY *ecdh,
-                                           void *(*KDF)(const void *in,
-                                                        size_t inlen, void *out,
-                                                        size_t *outlen));
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-typedef struct ECDSA_SIG_st ECDSA_SIG;
-
-/** Allocates and initialize a ECDSA_SIG structure
- *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
- */
-ECDSA_SIG *ECDSA_SIG_new(void);
-
-/** frees a ECDSA_SIG structure
- *  \param  sig  pointer to the ECDSA_SIG structure
- */
-void ECDSA_SIG_free(ECDSA_SIG *sig);
-
-/** i2d_ECDSA_SIG encodes content of ECDSA_SIG (note: this function modifies *pp
- *  (*pp += length of the DER encoded signature)).
- *  \param  sig  pointer to the ECDSA_SIG object
- *  \param  pp   pointer to a unsigned char pointer for the output or NULL
- *  \return the length of the DER encoded ECDSA_SIG object or a negative value
- *          on error
- */
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(ECDSA_SIG, ECDSA_SIG)
-
-/** d2i_ECDSA_SIG decodes an ECDSA signature (note: this function modifies *pp
- *  (*pp += len)).
- *  \param  sig  pointer to ECDSA_SIG pointer (may be NULL)
- *  \param  pp   memory buffer with the DER encoded signature
- *  \param  len  length of the buffer
- *  \return pointer to the decoded ECDSA_SIG structure (or NULL)
- */
-
-/** Accessor for r and s fields of ECDSA_SIG
- *  \param  sig  pointer to ECDSA_SIG structure
- *  \param  pr   pointer to BIGNUM pointer for r (may be NULL)
- *  \param  ps   pointer to BIGNUM pointer for s (may be NULL)
- */
-void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
-
-/** Accessor for r field of ECDSA_SIG
- *  \param  sig  pointer to ECDSA_SIG structure
- */
-const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig);
-
-/** Accessor for s field of ECDSA_SIG
- *  \param  sig  pointer to ECDSA_SIG structure
- */
-const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig);
-
-/** Setter for r and s fields of ECDSA_SIG
- *  \param  sig  pointer to ECDSA_SIG structure
- *  \param  r    pointer to BIGNUM for r
- *  \param  s    pointer to BIGNUM for s
- */
-int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s);
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/** Computes the ECDSA signature of the given hash value using
- *  the supplied private key and returns the created signature.
- *  \param  dgst      pointer to the hash value
- *  \param  dgst_len  length of the hash value
- *  \param  eckey     EC_KEY object containing a private EC key
- *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst,
-                                               int dgst_len, EC_KEY *eckey);
-
-/** Computes ECDSA signature of a given hash value using the supplied
- *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
- *  \param  dgst     pointer to the hash value to sign
- *  \param  dgstlen  length of the hash value
- *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
- *  \param  rp       BIGNUM with a pre-computed rp value (optional),
- *                   see ECDSA_sign_setup
- *  \param  eckey    EC_KEY object containing a private EC key
- *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
- */
-OSSL_DEPRECATEDIN_3_0 ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst,
-                                                  int dgstlen, const BIGNUM *kinv,
-                                                  const BIGNUM *rp, EC_KEY *eckey);
-
-/** Verifies that the supplied signature is a valid ECDSA
- *  signature of the supplied hash value using the supplied public key.
- *  \param  dgst      pointer to the hash value
- *  \param  dgst_len  length of the hash value
- *  \param  sig       ECDSA_SIG structure
- *  \param  eckey     EC_KEY object containing a public EC key
- *  \return 1 if the signature is valid, 0 if the signature is invalid
- *          and -1 on error
- */
-OSSL_DEPRECATEDIN_3_0 int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
-                                          const ECDSA_SIG *sig, EC_KEY *eckey);
-
-/** Precompute parts of the signing operation
- *  \param  eckey  EC_KEY object containing a private EC key
- *  \param  ctx    BN_CTX object (optional)
- *  \param  kinv   BIGNUM pointer for the inverse of k
- *  \param  rp     BIGNUM pointer for x coordinate of k * generator
- *  \return 1 on success and 0 otherwise
- */
-OSSL_DEPRECATEDIN_3_0 int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx,
-                                           BIGNUM **kinv, BIGNUM **rp);
-
-/** Computes ECDSA signature of a given hash value using the supplied
- *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
- *  \param  type     this parameter is ignored
- *  \param  dgst     pointer to the hash value to sign
- *  \param  dgstlen  length of the hash value
- *  \param  sig      memory for the DER encoded created signature
- *  \param  siglen   pointer to the length of the returned signature
- *  \param  eckey    EC_KEY object containing a private EC key
- *  \return 1 on success and 0 otherwise
- */
-OSSL_DEPRECATEDIN_3_0 int ECDSA_sign(int type, const unsigned char *dgst,
-                                     int dgstlen, unsigned char *sig,
-                                     unsigned int *siglen, EC_KEY *eckey);
-
-/** Computes ECDSA signature of a given hash value using the supplied
- *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
- *  \param  type     this parameter is ignored
- *  \param  dgst     pointer to the hash value to sign
- *  \param  dgstlen  length of the hash value
- *  \param  sig      buffer to hold the DER encoded signature
- *  \param  siglen   pointer to the length of the returned signature
- *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
- *  \param  rp       BIGNUM with a pre-computed rp value (optional),
- *                   see ECDSA_sign_setup
- *  \param  eckey    EC_KEY object containing a private EC key
- *  \return 1 on success and 0 otherwise
- */
-OSSL_DEPRECATEDIN_3_0 int ECDSA_sign_ex(int type, const unsigned char *dgst,
-                                        int dgstlen, unsigned char *sig,
-                                        unsigned int *siglen, const BIGNUM *kinv,
-                                        const BIGNUM *rp, EC_KEY *eckey);
-
-/** Verifies that the given signature is valid ECDSA signature
- *  of the supplied hash value using the specified public key.
- *  \param  type     this parameter is ignored
- *  \param  dgst     pointer to the hash value
- *  \param  dgstlen  length of the hash value
- *  \param  sig      pointer to the DER encoded signature
- *  \param  siglen   length of the DER encoded signature
- *  \param  eckey    EC_KEY object containing a public EC key
- *  \return 1 if the signature is valid, 0 if the signature is invalid
- *          and -1 on error
- */
-OSSL_DEPRECATEDIN_3_0 int ECDSA_verify(int type, const unsigned char *dgst,
-                                       int dgstlen, const unsigned char *sig,
-                                       int siglen, EC_KEY *eckey);
-
-/** Returns the maximum length of the DER encoded signature
- *  \param  eckey  EC_KEY object
- *  \return numbers of bytes required for the DER encoded signature
- */
-OSSL_DEPRECATEDIN_3_0 int ECDSA_size(const EC_KEY *eckey);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_ex_data(EC_KEY* key, int idx, void* arg);
+    OSSL_DEPRECATEDIN_3_0 void* EC_KEY_get_ex_data(const EC_KEY* key, int idx);
+
+    /* wrapper functions for the underlying EC_GROUP object */
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_asn1_flag(EC_KEY* eckey, int asn1_flag);
+
+    /** Creates a table of pre-computed multiples of the generator to
+     *  accelerate further EC_KEY operations.
+     *  \param  key  EC_KEY object
+     *  \param  ctx  BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_precompute_mult(EC_KEY* key, BN_CTX* ctx);
+
+    /** Creates a new ec private (and optional a new public) key.
+     *  \param  key  EC_KEY object
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_generate_key(EC_KEY* key);
+
+    /** Verifies that a private and/or public key is valid.
+     *  \param  key  the EC_KEY object
+     *  \return 1 on success and 0 otherwise.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_check_key(const EC_KEY* key);
+
+    /** Indicates if an EC_KEY can be used for signing.
+     *  \param  eckey  the EC_KEY object
+     *  \return 1 if can can sign and 0 otherwise.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_can_sign(const EC_KEY* eckey);
+
+    /** Sets a public key from affine coordinates performing
+     *  necessary NIST PKV tests.
+     *  \param  key  the EC_KEY object
+     *  \param  x    public key x coordinate
+     *  \param  y    public key y coordinate
+     *  \return 1 on success and 0 otherwise.
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_public_key_affine_coordinates(EC_KEY* key, BIGNUM* x, BIGNUM* y);
+
+    /** Encodes an EC_KEY public key to an allocated octet string
+     *  \param  key    key to encode
+     *  \param  form   point conversion form
+     *  \param  pbuf   returns pointer to allocated buffer
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return the length of the encoded octet string or 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_key2buf(const EC_KEY* key, point_conversion_form_t form, unsigned char** pbuf, BN_CTX* ctx);
+
+    /** Decodes a EC_KEY public key from a octet string
+     *  \param  key    key to decode
+     *  \param  buf    memory buffer with the encoded ec point
+     *  \param  len    length of the encoded ec point
+     *  \param  ctx    BN_CTX object (optional)
+     *  \return 1 on success and 0 if an error occurred
+     */
+
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_oct2key(EC_KEY* key, const unsigned char* buf, size_t len, BN_CTX* ctx);
+
+    /** Decodes an EC_KEY private key from an octet string
+     *  \param  key    key to decode
+     *  \param  buf    memory buffer with the encoded private key
+     *  \param  len    length of the encoded key
+     *  \return 1 on success and 0 if an error occurred
+     */
+
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_oct2priv(EC_KEY* key, const unsigned char* buf, size_t len);
+
+    /** Encodes a EC_KEY private key to an octet string
+     *  \param  key    key to encode
+     *  \param  buf    memory buffer for the result. If NULL the function returns
+     *                 required buffer size.
+     *  \param  len    length of the memory buffer
+     *  \return the length of the encoded octet string or 0 if an error occurred
+     */
+
+    OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_priv2oct(const EC_KEY* key, unsigned char* buf, size_t len);
+
+    /** Encodes an EC_KEY private key to an allocated octet string
+     *  \param  eckey  key to encode
+     *  \param  pbuf   returns pointer to allocated buffer
+     *  \return the length of the encoded octet string or 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 size_t EC_KEY_priv2buf(const EC_KEY* eckey, unsigned char** pbuf);
+
+    /********************************************************************/
+    /*        de- and encoding functions for SEC1 ECPrivateKey          */
+    /********************************************************************/
+
+    /** Decodes a private key from a memory buffer.
+     *  \param  key  a pointer to a EC_KEY object which should be used (or NULL)
+     *  \param  in   pointer to memory with the DER encoded private key
+     *  \param  len  length of the DER encoded private key
+     *  \return the decoded private key or NULL if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* d2i_ECPrivateKey(EC_KEY** key, const unsigned char** in, long len);
+
+    /** Encodes a private key object and stores the result in a buffer.
+     *  \param  key  the EC_KEY object to encode
+     *  \param  out  the buffer for the result (if NULL the function returns number
+     *               of bytes needed).
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey(const EC_KEY* key, unsigned char** out);
+
+    /********************************************************************/
+    /*        de- and encoding functions for EC parameters              */
+    /********************************************************************/
+
+    /** Decodes ec parameter from a memory buffer.
+     *  \param  key  a pointer to a EC_KEY object which should be used (or NULL)
+     *  \param  in   pointer to memory with the DER encoded ec parameters
+     *  \param  len  length of the DER encoded ec parameters
+     *  \return a EC_KEY object with the decoded parameters or NULL if an error
+     *          occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* d2i_ECParameters(EC_KEY** key, const unsigned char** in, long len);
+
+    /** Encodes ec parameter and stores the result in a buffer.
+     *  \param  key  the EC_KEY object with ec parameters to encode
+     *  \param  out  the buffer for the result (if NULL the function returns number
+     *               of bytes needed).
+     *  \return 1 on success and 0 if an error occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 int i2d_ECParameters(const EC_KEY* key, unsigned char** out);
+
+    /********************************************************************/
+    /*         de- and encoding functions for EC public key             */
+    /*         (octet string, not DER -- hence 'o2i' and 'i2o')         */
+    /********************************************************************/
+
+    /** Decodes an ec public key from a octet string.
+     *  \param  key  a pointer to a EC_KEY object which should be used
+     *  \param  in   memory buffer with the encoded public key
+     *  \param  len  length of the encoded public key
+     *  \return EC_KEY object with decoded public key or NULL if an error
+     *          occurred.
+     */
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* o2i_ECPublicKey(EC_KEY** key, const unsigned char** in, long len);
+
+    /** Encodes an ec public key in an octet string.
+     *  \param  key  the EC_KEY object with the public key
+     *  \param  out  the buffer for the result (if NULL the function returns number
+     *               of bytes needed).
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int i2o_ECPublicKey(const EC_KEY* key, unsigned char** out);
+
+    /** Prints out the ec parameters on human readable form.
+     *  \param  bp   BIO object to which the information is printed
+     *  \param  key  EC_KEY object
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECParameters_print(BIO* bp, const EC_KEY* key);
+
+    /** Prints out the contents of a EC_KEY object
+     *  \param  bp   BIO object to which the information is printed
+     *  \param  key  EC_KEY object
+     *  \param  off  line offset
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_print(BIO* bp, const EC_KEY* key, int off);
+
+#ifndef OPENSSL_NO_STDIO
+    /** Prints out the ec parameters on human readable form.
+     *  \param  fp   file descriptor to which the information is printed
+     *  \param  key  EC_KEY object
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECParameters_print_fp(FILE* fp, const EC_KEY* key);
+
+    /** Prints out the contents of a EC_KEY object
+     *  \param  fp   file descriptor to which the information is printed
+     *  \param  key  EC_KEY object
+     *  \param  off  line offset
+     *  \return 1 on success and 0 if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_print_fp(FILE* fp, const EC_KEY* key, int off);
+#endif /* OPENSSL_NO_STDIO */
+
+    OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD* EC_KEY_OpenSSL(void);
+    OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD* EC_KEY_get_default_method(void);
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_set_default_method(const EC_KEY_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD* EC_KEY_get_method(const EC_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 int EC_KEY_set_method(EC_KEY* key, const EC_KEY_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* EC_KEY_new_method(ENGINE* engine);
+
+    /** The old name for ecdh_KDF_X9_63
+     *  The ECDH KDF specification has been mistakingly attributed to ANSI X9.62,
+     *  it is actually specified in ANSI X9.63.
+     *  This identifier is retained for backwards compatibility
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECDH_KDF_X9_62(unsigned char* out, size_t outlen, const unsigned char* Z, size_t Zlen, const unsigned char* sinfo, size_t sinfolen, const EVP_MD* md);
+
+    OSSL_DEPRECATEDIN_3_0 int ECDH_compute_key(void* out, size_t outlen, const EC_POINT* pub_key, const EC_KEY* ecdh, void* (*KDF)(const void* in, size_t inlen, void* out, size_t* outlen));
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    typedef struct ECDSA_SIG_st ECDSA_SIG;
+
+    /** Allocates and initialize a ECDSA_SIG structure
+     *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+     */
+    ECDSA_SIG* ECDSA_SIG_new(void);
+
+    /** frees a ECDSA_SIG structure
+     *  \param  sig  pointer to the ECDSA_SIG structure
+     */
+    void ECDSA_SIG_free(ECDSA_SIG* sig);
+
+    /** i2d_ECDSA_SIG encodes content of ECDSA_SIG (note: this function modifies *pp
+     *  (*pp += length of the DER encoded signature)).
+     *  \param  sig  pointer to the ECDSA_SIG object
+     *  \param  pp   pointer to a unsigned char pointer for the output or NULL
+     *  \return the length of the DER encoded ECDSA_SIG object or a negative value
+     *          on error
+     */
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(ECDSA_SIG, ECDSA_SIG)
+
+        /** d2i_ECDSA_SIG decodes an ECDSA signature (note: this function modifies *pp
+         *  (*pp += len)).
+         *  \param  sig  pointer to ECDSA_SIG pointer (may be NULL)
+         *  \param  pp   memory buffer with the DER encoded signature
+         *  \param  len  length of the buffer
+         *  \return pointer to the decoded ECDSA_SIG structure (or NULL)
+         */
+
+        /** Accessor for r and s fields of ECDSA_SIG
+         *  \param  sig  pointer to ECDSA_SIG structure
+         *  \param  pr   pointer to BIGNUM pointer for r (may be NULL)
+         *  \param  ps   pointer to BIGNUM pointer for s (may be NULL)
+         */
+        void ECDSA_SIG_get0(const ECDSA_SIG* sig, const BIGNUM** pr, const BIGNUM** ps);
+
+    /** Accessor for r field of ECDSA_SIG
+     *  \param  sig  pointer to ECDSA_SIG structure
+     */
+    const BIGNUM* ECDSA_SIG_get0_r(const ECDSA_SIG* sig);
+
+    /** Accessor for s field of ECDSA_SIG
+     *  \param  sig  pointer to ECDSA_SIG structure
+     */
+    const BIGNUM* ECDSA_SIG_get0_s(const ECDSA_SIG* sig);
+
+    /** Setter for r and s fields of ECDSA_SIG
+     *  \param  sig  pointer to ECDSA_SIG structure
+     *  \param  r    pointer to BIGNUM for r
+     *  \param  s    pointer to BIGNUM for s
+     */
+    int ECDSA_SIG_set0(ECDSA_SIG* sig, BIGNUM* r, BIGNUM* s);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /** Computes the ECDSA signature of the given hash value using
+     *  the supplied private key and returns the created signature.
+     *  \param  dgst      pointer to the hash value
+     *  \param  dgst_len  length of the hash value
+     *  \param  eckey     EC_KEY object containing a private EC key
+     *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 ECDSA_SIG* ECDSA_do_sign(const unsigned char* dgst, int dgst_len, EC_KEY* eckey);
+
+    /** Computes ECDSA signature of a given hash value using the supplied
+     *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+     *  \param  dgst     pointer to the hash value to sign
+     *  \param  dgstlen  length of the hash value
+     *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
+     *  \param  rp       BIGNUM with a pre-computed rp value (optional),
+     *                   see ECDSA_sign_setup
+     *  \param  eckey    EC_KEY object containing a private EC key
+     *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
+     */
+    OSSL_DEPRECATEDIN_3_0 ECDSA_SIG* ECDSA_do_sign_ex(const unsigned char* dgst, int dgstlen, const BIGNUM* kinv, const BIGNUM* rp, EC_KEY* eckey);
+
+    /** Verifies that the supplied signature is a valid ECDSA
+     *  signature of the supplied hash value using the supplied public key.
+     *  \param  dgst      pointer to the hash value
+     *  \param  dgst_len  length of the hash value
+     *  \param  sig       ECDSA_SIG structure
+     *  \param  eckey     EC_KEY object containing a public EC key
+     *  \return 1 if the signature is valid, 0 if the signature is invalid
+     *          and -1 on error
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECDSA_do_verify(const unsigned char* dgst, int dgst_len, const ECDSA_SIG* sig, EC_KEY* eckey);
+
+    /** Precompute parts of the signing operation
+     *  \param  eckey  EC_KEY object containing a private EC key
+     *  \param  ctx    BN_CTX object (optional)
+     *  \param  kinv   BIGNUM pointer for the inverse of k
+     *  \param  rp     BIGNUM pointer for x coordinate of k * generator
+     *  \return 1 on success and 0 otherwise
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECDSA_sign_setup(EC_KEY* eckey, BN_CTX* ctx, BIGNUM** kinv, BIGNUM** rp);
+
+    /** Computes ECDSA signature of a given hash value using the supplied
+     *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+     *  \param  type     this parameter is ignored
+     *  \param  dgst     pointer to the hash value to sign
+     *  \param  dgstlen  length of the hash value
+     *  \param  sig      memory for the DER encoded created signature
+     *  \param  siglen   pointer to the length of the returned signature
+     *  \param  eckey    EC_KEY object containing a private EC key
+     *  \return 1 on success and 0 otherwise
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECDSA_sign(int type, const unsigned char* dgst, int dgstlen, unsigned char* sig, unsigned int* siglen, EC_KEY* eckey);
+
+    /** Computes ECDSA signature of a given hash value using the supplied
+     *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
+     *  \param  type     this parameter is ignored
+     *  \param  dgst     pointer to the hash value to sign
+     *  \param  dgstlen  length of the hash value
+     *  \param  sig      buffer to hold the DER encoded signature
+     *  \param  siglen   pointer to the length of the returned signature
+     *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
+     *  \param  rp       BIGNUM with a pre-computed rp value (optional),
+     *                   see ECDSA_sign_setup
+     *  \param  eckey    EC_KEY object containing a private EC key
+     *  \return 1 on success and 0 otherwise
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECDSA_sign_ex(int type, const unsigned char* dgst, int dgstlen, unsigned char* sig, unsigned int* siglen, const BIGNUM* kinv, const BIGNUM* rp, EC_KEY* eckey);
+
+    /** Verifies that the given signature is valid ECDSA signature
+     *  of the supplied hash value using the specified public key.
+     *  \param  type     this parameter is ignored
+     *  \param  dgst     pointer to the hash value
+     *  \param  dgstlen  length of the hash value
+     *  \param  sig      pointer to the DER encoded signature
+     *  \param  siglen   length of the DER encoded signature
+     *  \param  eckey    EC_KEY object containing a public EC key
+     *  \return 1 if the signature is valid, 0 if the signature is invalid
+     *          and -1 on error
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECDSA_verify(int type, const unsigned char* dgst, int dgstlen, const unsigned char* sig, int siglen, EC_KEY* eckey);
+
+    /** Returns the maximum length of the DER encoded signature
+     *  \param  eckey  EC_KEY object
+     *  \return numbers of bytes required for the DER encoded signature
+     */
+    OSSL_DEPRECATEDIN_3_0 int ECDSA_size(const EC_KEY* eckey);
+
+    /********************************************************************/
+    /*  EC_KEY_METHOD constructors, destructors, writers and accessors  */
+    /********************************************************************/
+
+    OSSL_DEPRECATEDIN_3_0 EC_KEY_METHOD* EC_KEY_METHOD_new(const EC_KEY_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_free(EC_KEY_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_init(EC_KEY_METHOD* meth, int (*init)(EC_KEY* key), void (*finish)(EC_KEY* key), int (*copy)(EC_KEY* dest, const EC_KEY* src), int (*set_group)(EC_KEY* key, const EC_GROUP* grp), int (*set_private)(EC_KEY* key, const BIGNUM* priv_key), int (*set_public)(EC_KEY* key, const EC_POINT* pub_key));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD* meth, int (*keygen)(EC_KEY* key));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD* meth, int (*ckey)(unsigned char** psec, size_t* pseclen, const EC_POINT* pub_key, const EC_KEY* ecdh));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_sign(EC_KEY_METHOD* meth, int (*sign)(int type, const unsigned char* dgst, int dlen, unsigned char* sig, unsigned int* siglen, const BIGNUM* kinv, const BIGNUM* r, EC_KEY* eckey), int (*sign_setup)(EC_KEY* eckey, BN_CTX* ctx_in, BIGNUM** kinvp, BIGNUM** rp), ECDSA_SIG* (*sign_sig)(const unsigned char* dgst, int dgst_len, const BIGNUM* in_kinv, const BIGNUM* in_r, EC_KEY* eckey));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_verify(EC_KEY_METHOD* meth, int (*verify)(int type, const unsigned char* dgst, int dgst_len, const unsigned char* sigbuf, int sig_len, EC_KEY* eckey), int (*verify_sig)(const unsigned char* dgst, int dgst_len, const ECDSA_SIG* sig, EC_KEY* eckey));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_init(const EC_KEY_METHOD* meth, int (**pinit)(EC_KEY* key), void (**pfinish)(EC_KEY* key), int (**pcopy)(EC_KEY* dest, const EC_KEY* src), int (**pset_group)(EC_KEY* key, const EC_GROUP* grp), int (**pset_private)(EC_KEY* key, const BIGNUM* priv_key), int (**pset_public)(EC_KEY* key, const EC_POINT* pub_key));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD* meth, int (**pkeygen)(EC_KEY* key));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD* meth, int (**pck)(unsigned char** psec, size_t* pseclen, const EC_POINT* pub_key, const EC_KEY* ecdh));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_sign(const EC_KEY_METHOD* meth, int (**psign)(int type, const unsigned char* dgst, int dlen, unsigned char* sig, unsigned int* siglen, const BIGNUM* kinv, const BIGNUM* r, EC_KEY* eckey), int (**psign_setup)(EC_KEY* eckey, BN_CTX* ctx_in, BIGNUM** kinvp, BIGNUM** rp), ECDSA_SIG* (**psign_sig)(const unsigned char* dgst, int dgst_len, const BIGNUM* in_kinv, const BIGNUM* in_r, EC_KEY* eckey));
+
+    OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_verify(const EC_KEY_METHOD* meth, int (**pverify)(int type, const unsigned char* dgst, int dgst_len, const unsigned char* sigbuf, int sig_len, EC_KEY* eckey), int (**pverify_sig)(const unsigned char* dgst, int dgst_len, const ECDSA_SIG* sig, EC_KEY* eckey));
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+#define EVP_EC_gen(curve) \
+    EVP_PKEY_Q_keygen(NULL, NULL, "EC", (char*)(strstr(curve, "")))
+    /* strstr is used to enable type checking for the variadic string arg */
+#define ECParameters_dup(x) ASN1_dup_of(EC_KEY, i2d_ECParameters, d2i_ECParameters, x)
 
-/********************************************************************/
-/*  EC_KEY_METHOD constructors, destructors, writers and accessors  */
-/********************************************************************/
+#ifndef __cplusplus
+#if defined(__SUNPRO_C)
+#if __SUNPRO_C >= 0x520
+#pragma error_messages(default, E_ARRAY_OF_INCOMPLETE_NONAME, E_ARRAY_OF_INCOMPLETE)
+#endif
+#endif
+#endif
 
-OSSL_DEPRECATEDIN_3_0 EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_free(EC_KEY_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_init
-                      (EC_KEY_METHOD *meth,
-                       int (*init)(EC_KEY *key),
-                       void (*finish)(EC_KEY *key),
-                       int (*copy)(EC_KEY *dest, const EC_KEY *src),
-                       int (*set_group)(EC_KEY *key, const EC_GROUP *grp),
-                       int (*set_private)(EC_KEY *key, const BIGNUM *priv_key),
-                       int (*set_public)(EC_KEY *key, const EC_POINT *pub_key));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth,
-                                                    int (*keygen)(EC_KEY *key));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_compute_key
-                      (EC_KEY_METHOD *meth,
-                       int (*ckey)(unsigned char **psec, size_t *pseclen,
-                                   const EC_POINT *pub_key, const EC_KEY *ecdh));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_sign
-                      (EC_KEY_METHOD *meth,
-                       int (*sign)(int type, const unsigned char *dgst,
-                                   int dlen, unsigned char *sig,
-                                   unsigned int *siglen,
-                                   const BIGNUM *kinv, const BIGNUM *r,
-                                   EC_KEY *eckey),
-                       int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
-                                         BIGNUM **kinvp, BIGNUM **rp),
-                       ECDSA_SIG *(*sign_sig)(const unsigned char *dgst,
-                                              int dgst_len,
-                                              const BIGNUM *in_kinv,
-                                              const BIGNUM *in_r,
-                                              EC_KEY *eckey));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_set_verify
-                      (EC_KEY_METHOD *meth,
-                       int (*verify)(int type, const unsigned
-                                     char *dgst, int dgst_len,
-                                     const unsigned char *sigbuf,
-                                     int sig_len, EC_KEY *eckey),
-                       int (*verify_sig)(const unsigned char *dgst,
-                                         int dgst_len, const ECDSA_SIG *sig,
-                                         EC_KEY *eckey));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_init
-                      (const EC_KEY_METHOD *meth,
-                       int (**pinit)(EC_KEY *key),
-                       void (**pfinish)(EC_KEY *key),
-                       int (**pcopy)(EC_KEY *dest, const EC_KEY *src),
-                       int (**pset_group)(EC_KEY *key, const EC_GROUP *grp),
-                       int (**pset_private)(EC_KEY *key, const BIGNUM *priv_key),
-                       int (**pset_public)(EC_KEY *key, const EC_POINT *pub_key));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_keygen
-                      (const EC_KEY_METHOD *meth, int (**pkeygen)(EC_KEY *key));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_compute_key
-                      (const EC_KEY_METHOD *meth,
-                       int (**pck)(unsigned char **psec,
-                       size_t *pseclen,
-                       const EC_POINT *pub_key,
-                       const EC_KEY *ecdh));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_sign
-                      (const EC_KEY_METHOD *meth,
-                       int (**psign)(int type, const unsigned char *dgst,
-                                     int dlen, unsigned char *sig,
-                                     unsigned int *siglen,
-                                     const BIGNUM *kinv, const BIGNUM *r,
-                                     EC_KEY *eckey),
-                       int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
-                                           BIGNUM **kinvp, BIGNUM **rp),
-                       ECDSA_SIG *(**psign_sig)(const unsigned char *dgst,
-                                                int dgst_len,
-                                                const BIGNUM *in_kinv,
-                                                const BIGNUM *in_r,
-                                                EC_KEY *eckey));
-
-OSSL_DEPRECATEDIN_3_0 void EC_KEY_METHOD_get_verify
-                      (const EC_KEY_METHOD *meth,
-                       int (**pverify)(int type, const unsigned
-                                       char *dgst, int dgst_len,
-                                       const unsigned char *sigbuf,
-                                       int sig_len, EC_KEY *eckey),
-                       int (**pverify_sig)(const unsigned char *dgst,
-                                           int dgst_len,
-                                           const ECDSA_SIG *sig,
-                                           EC_KEY *eckey));
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-#  define EVP_EC_gen(curve) \
-    EVP_PKEY_Q_keygen(NULL, NULL, "EC", (char *)(strstr(curve, "")))
-    /* strstr is used to enable type checking for the variadic string arg */
-#  define ECParameters_dup(x) ASN1_dup_of(EC_KEY, i2d_ECParameters, \
-                                          d2i_ECParameters, x)
-
-#  ifndef __cplusplus
-#   if defined(__SUNPRO_C)
-#    if __SUNPRO_C >= 0x520
-#     pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE)
-#    endif
-#   endif
-#  endif
-
-# endif
-# ifdef  __cplusplus
+#endif
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ecerr.h b/CAPI/cpp/grpc/include/openssl/ecerr.h
index 46405ac..8d5f3eb 100644
--- a/CAPI/cpp/grpc/include/openssl/ecerr.h
+++ b/CAPI/cpp/grpc/include/openssl/ecerr.h
@@ -9,95 +9,93 @@
  */
 
 #ifndef OPENSSL_ECERR_H
-# define OPENSSL_ECERR_H
-# pragma once
+#define OPENSSL_ECERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_EC
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_EC
 
 /*
  * EC reason codes.
  */
-#  define EC_R_ASN1_ERROR                                  115
-#  define EC_R_BAD_SIGNATURE                               156
-#  define EC_R_BIGNUM_OUT_OF_RANGE                         144
-#  define EC_R_BUFFER_TOO_SMALL                            100
-#  define EC_R_CANNOT_INVERT                               165
-#  define EC_R_COORDINATES_OUT_OF_RANGE                    146
-#  define EC_R_CURVE_DOES_NOT_SUPPORT_ECDH                 160
-#  define EC_R_CURVE_DOES_NOT_SUPPORT_ECDSA                170
-#  define EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING              159
-#  define EC_R_DECODE_ERROR                                142
-#  define EC_R_DISCRIMINANT_IS_ZERO                        118
-#  define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE                119
-#  define EC_R_EXPLICIT_PARAMS_NOT_SUPPORTED               127
-#  define EC_R_FAILED_MAKING_PUBLIC_KEY                    166
-#  define EC_R_FIELD_TOO_LARGE                             143
-#  define EC_R_GF2M_NOT_SUPPORTED                          147
-#  define EC_R_GROUP2PKPARAMETERS_FAILURE                  120
-#  define EC_R_I2D_ECPKPARAMETERS_FAILURE                  121
-#  define EC_R_INCOMPATIBLE_OBJECTS                        101
-#  define EC_R_INVALID_A                                   168
-#  define EC_R_INVALID_ARGUMENT                            112
-#  define EC_R_INVALID_B                                   169
-#  define EC_R_INVALID_COFACTOR                            171
-#  define EC_R_INVALID_COMPRESSED_POINT                    110
-#  define EC_R_INVALID_COMPRESSION_BIT                     109
-#  define EC_R_INVALID_CURVE                               141
-#  define EC_R_INVALID_DIGEST                              151
-#  define EC_R_INVALID_DIGEST_TYPE                         138
-#  define EC_R_INVALID_ENCODING                            102
-#  define EC_R_INVALID_FIELD                               103
-#  define EC_R_INVALID_FORM                                104
-#  define EC_R_INVALID_GENERATOR                           173
-#  define EC_R_INVALID_GROUP_ORDER                         122
-#  define EC_R_INVALID_KEY                                 116
-#  define EC_R_INVALID_LENGTH                              117
-#  define EC_R_INVALID_NAMED_GROUP_CONVERSION              174
-#  define EC_R_INVALID_OUTPUT_LENGTH                       161
-#  define EC_R_INVALID_P                                   172
-#  define EC_R_INVALID_PEER_KEY                            133
-#  define EC_R_INVALID_PENTANOMIAL_BASIS                   132
-#  define EC_R_INVALID_PRIVATE_KEY                         123
-#  define EC_R_INVALID_SEED                                175
-#  define EC_R_INVALID_TRINOMIAL_BASIS                     137
-#  define EC_R_KDF_PARAMETER_ERROR                         148
-#  define EC_R_KEYS_NOT_SET                                140
-#  define EC_R_LADDER_POST_FAILURE                         136
-#  define EC_R_LADDER_PRE_FAILURE                          153
-#  define EC_R_LADDER_STEP_FAILURE                         162
-#  define EC_R_MISSING_OID                                 167
-#  define EC_R_MISSING_PARAMETERS                          124
-#  define EC_R_MISSING_PRIVATE_KEY                         125
-#  define EC_R_NEED_NEW_SETUP_VALUES                       157
-#  define EC_R_NOT_A_NIST_PRIME                            135
-#  define EC_R_NOT_IMPLEMENTED                             126
-#  define EC_R_NOT_INITIALIZED                             111
-#  define EC_R_NO_PARAMETERS_SET                           139
-#  define EC_R_NO_PRIVATE_VALUE                            154
-#  define EC_R_OPERATION_NOT_SUPPORTED                     152
-#  define EC_R_PASSED_NULL_PARAMETER                       134
-#  define EC_R_PEER_KEY_ERROR                              149
-#  define EC_R_POINT_ARITHMETIC_FAILURE                    155
-#  define EC_R_POINT_AT_INFINITY                           106
-#  define EC_R_POINT_COORDINATES_BLIND_FAILURE             163
-#  define EC_R_POINT_IS_NOT_ON_CURVE                       107
-#  define EC_R_RANDOM_NUMBER_GENERATION_FAILED             158
-#  define EC_R_SHARED_INFO_ERROR                           150
-#  define EC_R_SLOT_FULL                                   108
-#  define EC_R_UNDEFINED_GENERATOR                         113
-#  define EC_R_UNDEFINED_ORDER                             128
-#  define EC_R_UNKNOWN_COFACTOR                            164
-#  define EC_R_UNKNOWN_GROUP                               129
-#  define EC_R_UNKNOWN_ORDER                               114
-#  define EC_R_UNSUPPORTED_FIELD                           131
-#  define EC_R_WRONG_CURVE_PARAMETERS                      145
-#  define EC_R_WRONG_ORDER                                 130
+#define EC_R_ASN1_ERROR 115
+#define EC_R_BAD_SIGNATURE 156
+#define EC_R_BIGNUM_OUT_OF_RANGE 144
+#define EC_R_BUFFER_TOO_SMALL 100
+#define EC_R_CANNOT_INVERT 165
+#define EC_R_COORDINATES_OUT_OF_RANGE 146
+#define EC_R_CURVE_DOES_NOT_SUPPORT_ECDH 160
+#define EC_R_CURVE_DOES_NOT_SUPPORT_ECDSA 170
+#define EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING 159
+#define EC_R_DECODE_ERROR 142
+#define EC_R_DISCRIMINANT_IS_ZERO 118
+#define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE 119
+#define EC_R_EXPLICIT_PARAMS_NOT_SUPPORTED 127
+#define EC_R_FAILED_MAKING_PUBLIC_KEY 166
+#define EC_R_FIELD_TOO_LARGE 143
+#define EC_R_GF2M_NOT_SUPPORTED 147
+#define EC_R_GROUP2PKPARAMETERS_FAILURE 120
+#define EC_R_I2D_ECPKPARAMETERS_FAILURE 121
+#define EC_R_INCOMPATIBLE_OBJECTS 101
+#define EC_R_INVALID_A 168
+#define EC_R_INVALID_ARGUMENT 112
+#define EC_R_INVALID_B 169
+#define EC_R_INVALID_COFACTOR 171
+#define EC_R_INVALID_COMPRESSED_POINT 110
+#define EC_R_INVALID_COMPRESSION_BIT 109
+#define EC_R_INVALID_CURVE 141
+#define EC_R_INVALID_DIGEST 151
+#define EC_R_INVALID_DIGEST_TYPE 138
+#define EC_R_INVALID_ENCODING 102
+#define EC_R_INVALID_FIELD 103
+#define EC_R_INVALID_FORM 104
+#define EC_R_INVALID_GENERATOR 173
+#define EC_R_INVALID_GROUP_ORDER 122
+#define EC_R_INVALID_KEY 116
+#define EC_R_INVALID_LENGTH 117
+#define EC_R_INVALID_NAMED_GROUP_CONVERSION 174
+#define EC_R_INVALID_OUTPUT_LENGTH 161
+#define EC_R_INVALID_P 172
+#define EC_R_INVALID_PEER_KEY 133
+#define EC_R_INVALID_PENTANOMIAL_BASIS 132
+#define EC_R_INVALID_PRIVATE_KEY 123
+#define EC_R_INVALID_SEED 175
+#define EC_R_INVALID_TRINOMIAL_BASIS 137
+#define EC_R_KDF_PARAMETER_ERROR 148
+#define EC_R_KEYS_NOT_SET 140
+#define EC_R_LADDER_POST_FAILURE 136
+#define EC_R_LADDER_PRE_FAILURE 153
+#define EC_R_LADDER_STEP_FAILURE 162
+#define EC_R_MISSING_OID 167
+#define EC_R_MISSING_PARAMETERS 124
+#define EC_R_MISSING_PRIVATE_KEY 125
+#define EC_R_NEED_NEW_SETUP_VALUES 157
+#define EC_R_NOT_A_NIST_PRIME 135
+#define EC_R_NOT_IMPLEMENTED 126
+#define EC_R_NOT_INITIALIZED 111
+#define EC_R_NO_PARAMETERS_SET 139
+#define EC_R_NO_PRIVATE_VALUE 154
+#define EC_R_OPERATION_NOT_SUPPORTED 152
+#define EC_R_PASSED_NULL_PARAMETER 134
+#define EC_R_PEER_KEY_ERROR 149
+#define EC_R_POINT_ARITHMETIC_FAILURE 155
+#define EC_R_POINT_AT_INFINITY 106
+#define EC_R_POINT_COORDINATES_BLIND_FAILURE 163
+#define EC_R_POINT_IS_NOT_ON_CURVE 107
+#define EC_R_RANDOM_NUMBER_GENERATION_FAILED 158
+#define EC_R_SHARED_INFO_ERROR 150
+#define EC_R_SLOT_FULL 108
+#define EC_R_UNDEFINED_GENERATOR 113
+#define EC_R_UNDEFINED_ORDER 128
+#define EC_R_UNKNOWN_COFACTOR 164
+#define EC_R_UNKNOWN_GROUP 129
+#define EC_R_UNKNOWN_ORDER 114
+#define EC_R_UNSUPPORTED_FIELD 131
+#define EC_R_WRONG_CURVE_PARAMETERS 145
+#define EC_R_WRONG_ORDER 130
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/encoder.h b/CAPI/cpp/grpc/include/openssl/encoder.h
index c37a6f1..d83f842 100644
--- a/CAPI/cpp/grpc/include/openssl/encoder.h
+++ b/CAPI/cpp/grpc/include/openssl/encoder.h
@@ -8,117 +8,92 @@
  */
 
 #ifndef OPENSSL_ENCODER_H
-# define OPENSSL_ENCODER_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_STDIO
-#  include <stdio.h>
-# endif
-# include <stdarg.h>
-# include <stddef.h>
-# include <openssl/encodererr.h>
-# include <openssl/types.h>
-# include <openssl/core.h>
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-OSSL_ENCODER *OSSL_ENCODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
-                                 const char *properties);
-int OSSL_ENCODER_up_ref(OSSL_ENCODER *encoder);
-void OSSL_ENCODER_free(OSSL_ENCODER *encoder);
-
-const OSSL_PROVIDER *OSSL_ENCODER_get0_provider(const OSSL_ENCODER *encoder);
-const char *OSSL_ENCODER_get0_properties(const OSSL_ENCODER *encoder);
-const char *OSSL_ENCODER_get0_name(const OSSL_ENCODER *kdf);
-const char *OSSL_ENCODER_get0_description(const OSSL_ENCODER *kdf);
-int OSSL_ENCODER_is_a(const OSSL_ENCODER *encoder, const char *name);
-
-void OSSL_ENCODER_do_all_provided(OSSL_LIB_CTX *libctx,
-                                  void (*fn)(OSSL_ENCODER *encoder, void *arg),
-                                  void *arg);
-int OSSL_ENCODER_names_do_all(const OSSL_ENCODER *encoder,
-                              void (*fn)(const char *name, void *data),
-                              void *data);
-const OSSL_PARAM *OSSL_ENCODER_gettable_params(OSSL_ENCODER *encoder);
-int OSSL_ENCODER_get_params(OSSL_ENCODER *encoder, OSSL_PARAM params[]);
-
-const OSSL_PARAM *OSSL_ENCODER_settable_ctx_params(OSSL_ENCODER *encoder);
-OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new(void);
-int OSSL_ENCODER_CTX_set_params(OSSL_ENCODER_CTX *ctx,
-                                const OSSL_PARAM params[]);
-void OSSL_ENCODER_CTX_free(OSSL_ENCODER_CTX *ctx);
-
-/* Utilities that help set specific parameters */
-int OSSL_ENCODER_CTX_set_passphrase(OSSL_ENCODER_CTX *ctx,
-                                    const unsigned char *kstr, size_t klen);
-int OSSL_ENCODER_CTX_set_pem_password_cb(OSSL_ENCODER_CTX *ctx,
-                                         pem_password_cb *cb, void *cbarg);
-int OSSL_ENCODER_CTX_set_passphrase_cb(OSSL_ENCODER_CTX *ctx,
-                                       OSSL_PASSPHRASE_CALLBACK *cb,
-                                       void *cbarg);
-int OSSL_ENCODER_CTX_set_passphrase_ui(OSSL_ENCODER_CTX *ctx,
-                                       const UI_METHOD *ui_method,
-                                       void *ui_data);
-int OSSL_ENCODER_CTX_set_cipher(OSSL_ENCODER_CTX *ctx,
-                                const char *cipher_name,
-                                const char *propquery);
-int OSSL_ENCODER_CTX_set_selection(OSSL_ENCODER_CTX *ctx, int selection);
-int OSSL_ENCODER_CTX_set_output_type(OSSL_ENCODER_CTX *ctx,
-                                     const char *output_type);
-int OSSL_ENCODER_CTX_set_output_structure(OSSL_ENCODER_CTX *ctx,
-                                          const char *output_structure);
-
-/* Utilities to add encoders */
-int OSSL_ENCODER_CTX_add_encoder(OSSL_ENCODER_CTX *ctx, OSSL_ENCODER *encoder);
-int OSSL_ENCODER_CTX_add_extra(OSSL_ENCODER_CTX *ctx,
-                               OSSL_LIB_CTX *libctx, const char *propq);
-int OSSL_ENCODER_CTX_get_num_encoders(OSSL_ENCODER_CTX *ctx);
-
-typedef struct ossl_encoder_instance_st OSSL_ENCODER_INSTANCE;
-OSSL_ENCODER *
-OSSL_ENCODER_INSTANCE_get_encoder(OSSL_ENCODER_INSTANCE *encoder_inst);
-void *
-OSSL_ENCODER_INSTANCE_get_encoder_ctx(OSSL_ENCODER_INSTANCE *encoder_inst);
-const char *
-OSSL_ENCODER_INSTANCE_get_output_type(OSSL_ENCODER_INSTANCE *encoder_inst);
-const char *
-OSSL_ENCODER_INSTANCE_get_output_structure(OSSL_ENCODER_INSTANCE *encoder_inst);
-
-typedef const void *OSSL_ENCODER_CONSTRUCT(OSSL_ENCODER_INSTANCE *encoder_inst,
-                                           void *construct_data);
-typedef void OSSL_ENCODER_CLEANUP(void *construct_data);
-
-int OSSL_ENCODER_CTX_set_construct(OSSL_ENCODER_CTX *ctx,
-                                   OSSL_ENCODER_CONSTRUCT *construct);
-int OSSL_ENCODER_CTX_set_construct_data(OSSL_ENCODER_CTX *ctx,
-                                        void *construct_data);
-int OSSL_ENCODER_CTX_set_cleanup(OSSL_ENCODER_CTX *ctx,
-                                 OSSL_ENCODER_CLEANUP *cleanup);
-
-/* Utilities to output the object to encode */
-int OSSL_ENCODER_to_bio(OSSL_ENCODER_CTX *ctx, BIO *out);
+#define OPENSSL_ENCODER_H
+#pragma once
+
+#include <openssl/opensslconf.h>
+
 #ifndef OPENSSL_NO_STDIO
-int OSSL_ENCODER_to_fp(OSSL_ENCODER_CTX *ctx, FILE *fp);
+#include <stdio.h>
+#endif
+#include <stdarg.h>
+#include <stddef.h>
+#include <openssl/encodererr.h>
+#include <openssl/types.h>
+#include <openssl/core.h>
+
+#ifdef __cplusplus
+extern "C"
+{
 #endif
-int OSSL_ENCODER_to_data(OSSL_ENCODER_CTX *ctx, unsigned char **pdata,
-                         size_t *pdata_len);
 
-/*
- * Create the OSSL_ENCODER_CTX with an associated type.  This will perform
- * an implicit OSSL_ENCODER_fetch(), suitable for the object of that type.
- * This is more useful than calling OSSL_ENCODER_CTX_new().
- */
-OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new_for_pkey(const EVP_PKEY *pkey,
-                                                int selection,
-                                                const char *output_type,
-                                                const char *output_struct,
-                                                const char *propquery);
+    OSSL_ENCODER* OSSL_ENCODER_fetch(OSSL_LIB_CTX* libctx, const char* name, const char* properties);
+    int OSSL_ENCODER_up_ref(OSSL_ENCODER* encoder);
+    void OSSL_ENCODER_free(OSSL_ENCODER* encoder);
+
+    const OSSL_PROVIDER* OSSL_ENCODER_get0_provider(const OSSL_ENCODER* encoder);
+    const char* OSSL_ENCODER_get0_properties(const OSSL_ENCODER* encoder);
+    const char* OSSL_ENCODER_get0_name(const OSSL_ENCODER* kdf);
+    const char* OSSL_ENCODER_get0_description(const OSSL_ENCODER* kdf);
+    int OSSL_ENCODER_is_a(const OSSL_ENCODER* encoder, const char* name);
+
+    void OSSL_ENCODER_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(OSSL_ENCODER* encoder, void* arg), void* arg);
+    int OSSL_ENCODER_names_do_all(const OSSL_ENCODER* encoder, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PARAM* OSSL_ENCODER_gettable_params(OSSL_ENCODER* encoder);
+    int OSSL_ENCODER_get_params(OSSL_ENCODER* encoder, OSSL_PARAM params[]);
+
+    const OSSL_PARAM* OSSL_ENCODER_settable_ctx_params(OSSL_ENCODER* encoder);
+    OSSL_ENCODER_CTX* OSSL_ENCODER_CTX_new(void);
+    int OSSL_ENCODER_CTX_set_params(OSSL_ENCODER_CTX* ctx, const OSSL_PARAM params[]);
+    void OSSL_ENCODER_CTX_free(OSSL_ENCODER_CTX* ctx);
+
+    /* Utilities that help set specific parameters */
+    int OSSL_ENCODER_CTX_set_passphrase(OSSL_ENCODER_CTX* ctx, const unsigned char* kstr, size_t klen);
+    int OSSL_ENCODER_CTX_set_pem_password_cb(OSSL_ENCODER_CTX* ctx, pem_password_cb* cb, void* cbarg);
+    int OSSL_ENCODER_CTX_set_passphrase_cb(OSSL_ENCODER_CTX* ctx, OSSL_PASSPHRASE_CALLBACK* cb, void* cbarg);
+    int OSSL_ENCODER_CTX_set_passphrase_ui(OSSL_ENCODER_CTX* ctx, const UI_METHOD* ui_method, void* ui_data);
+    int OSSL_ENCODER_CTX_set_cipher(OSSL_ENCODER_CTX* ctx, const char* cipher_name, const char* propquery);
+    int OSSL_ENCODER_CTX_set_selection(OSSL_ENCODER_CTX* ctx, int selection);
+    int OSSL_ENCODER_CTX_set_output_type(OSSL_ENCODER_CTX* ctx, const char* output_type);
+    int OSSL_ENCODER_CTX_set_output_structure(OSSL_ENCODER_CTX* ctx, const char* output_structure);
+
+    /* Utilities to add encoders */
+    int OSSL_ENCODER_CTX_add_encoder(OSSL_ENCODER_CTX* ctx, OSSL_ENCODER* encoder);
+    int OSSL_ENCODER_CTX_add_extra(OSSL_ENCODER_CTX* ctx, OSSL_LIB_CTX* libctx, const char* propq);
+    int OSSL_ENCODER_CTX_get_num_encoders(OSSL_ENCODER_CTX* ctx);
+
+    typedef struct ossl_encoder_instance_st OSSL_ENCODER_INSTANCE;
+    OSSL_ENCODER*
+        OSSL_ENCODER_INSTANCE_get_encoder(OSSL_ENCODER_INSTANCE* encoder_inst);
+    void*
+        OSSL_ENCODER_INSTANCE_get_encoder_ctx(OSSL_ENCODER_INSTANCE* encoder_inst);
+    const char*
+        OSSL_ENCODER_INSTANCE_get_output_type(OSSL_ENCODER_INSTANCE* encoder_inst);
+    const char*
+        OSSL_ENCODER_INSTANCE_get_output_structure(OSSL_ENCODER_INSTANCE* encoder_inst);
+
+    typedef const void* OSSL_ENCODER_CONSTRUCT(OSSL_ENCODER_INSTANCE* encoder_inst, void* construct_data);
+    typedef void OSSL_ENCODER_CLEANUP(void* construct_data);
+
+    int OSSL_ENCODER_CTX_set_construct(OSSL_ENCODER_CTX* ctx, OSSL_ENCODER_CONSTRUCT* construct);
+    int OSSL_ENCODER_CTX_set_construct_data(OSSL_ENCODER_CTX* ctx, void* construct_data);
+    int OSSL_ENCODER_CTX_set_cleanup(OSSL_ENCODER_CTX* ctx, OSSL_ENCODER_CLEANUP* cleanup);
+
+    /* Utilities to output the object to encode */
+    int OSSL_ENCODER_to_bio(OSSL_ENCODER_CTX* ctx, BIO* out);
+#ifndef OPENSSL_NO_STDIO
+    int OSSL_ENCODER_to_fp(OSSL_ENCODER_CTX* ctx, FILE* fp);
+#endif
+    int OSSL_ENCODER_to_data(OSSL_ENCODER_CTX* ctx, unsigned char** pdata, size_t* pdata_len);
 
-# ifdef __cplusplus
+    /*
+     * Create the OSSL_ENCODER_CTX with an associated type.  This will perform
+     * an implicit OSSL_ENCODER_fetch(), suitable for the object of that type.
+     * This is more useful than calling OSSL_ENCODER_CTX_new().
+     */
+    OSSL_ENCODER_CTX* OSSL_ENCODER_CTX_new_for_pkey(const EVP_PKEY* pkey, int selection, const char* output_type, const char* output_struct, const char* propquery);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/encodererr.h b/CAPI/cpp/grpc/include/openssl/encodererr.h
index 5e318b1..e07174c 100644
--- a/CAPI/cpp/grpc/include/openssl/encodererr.h
+++ b/CAPI/cpp/grpc/include/openssl/encodererr.h
@@ -9,20 +9,18 @@
  */
 
 #ifndef OPENSSL_ENCODERERR_H
-# define OPENSSL_ENCODERERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_ENCODERERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * OSSL_ENCODER reason codes.
  */
-# define OSSL_ENCODER_R_ENCODER_NOT_FOUND                 101
-# define OSSL_ENCODER_R_INCORRECT_PROPERTY_QUERY          100
-# define OSSL_ENCODER_R_MISSING_GET_PARAMS                102
+#define OSSL_ENCODER_R_ENCODER_NOT_FOUND 101
+#define OSSL_ENCODER_R_INCORRECT_PROPERTY_QUERY 100
+#define OSSL_ENCODER_R_MISSING_GET_PARAMS 102
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/engine.h b/CAPI/cpp/grpc/include/openssl/engine.h
index c965800..84ce032 100644
--- a/CAPI/cpp/grpc/include/openssl/engine.h
+++ b/CAPI/cpp/grpc/include/openssl/engine.h
@@ -9,51 +9,52 @@
  */
 
 #ifndef OPENSSL_ENGINE_H
-# define OPENSSL_ENGINE_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_ENGINE_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_ENGINE
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#   include <openssl/bn.h>
-#   include <openssl/rsa.h>
-#   include <openssl/dsa.h>
-#   include <openssl/dh.h>
-#   include <openssl/ec.h>
-#   include <openssl/rand.h>
-#   include <openssl/ui.h>
-#   include <openssl/err.h>
-#  endif
-#  include <openssl/types.h>
-#  include <openssl/symhacks.h>
-#  include <openssl/x509.h>
-#  include <openssl/engineerr.h>
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
+#define OPENSSL_ENGINE_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ENGINE_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_ENGINE
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/bn.h>
+#include <openssl/rsa.h>
+#include <openssl/dsa.h>
+#include <openssl/dh.h>
+#include <openssl/ec.h>
+#include <openssl/rand.h>
+#include <openssl/ui.h>
+#include <openssl/err.h>
+#endif
+#include <openssl/types.h>
+#include <openssl/symhacks.h>
+#include <openssl/x509.h>
+#include <openssl/engineerr.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /*
  * These flags are used to control combinations of algorithm (methods) by
  * bitwise "OR"ing.
  */
-#  define ENGINE_METHOD_RSA               (unsigned int)0x0001
-#  define ENGINE_METHOD_DSA               (unsigned int)0x0002
-#  define ENGINE_METHOD_DH                (unsigned int)0x0004
-#  define ENGINE_METHOD_RAND              (unsigned int)0x0008
-#  define ENGINE_METHOD_CIPHERS           (unsigned int)0x0040
-#  define ENGINE_METHOD_DIGESTS           (unsigned int)0x0080
-#  define ENGINE_METHOD_PKEY_METHS        (unsigned int)0x0200
-#  define ENGINE_METHOD_PKEY_ASN1_METHS   (unsigned int)0x0400
-#  define ENGINE_METHOD_EC                (unsigned int)0x0800
+#define ENGINE_METHOD_RSA (unsigned int)0x0001
+#define ENGINE_METHOD_DSA (unsigned int)0x0002
+#define ENGINE_METHOD_DH (unsigned int)0x0004
+#define ENGINE_METHOD_RAND (unsigned int)0x0008
+#define ENGINE_METHOD_CIPHERS (unsigned int)0x0040
+#define ENGINE_METHOD_DIGESTS (unsigned int)0x0080
+#define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200
+#define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400
+#define ENGINE_METHOD_EC (unsigned int)0x0800
 /* Obvious all-or-nothing cases. */
-#  define ENGINE_METHOD_ALL               (unsigned int)0xFFFF
-#  define ENGINE_METHOD_NONE              (unsigned int)0x0000
+#define ENGINE_METHOD_ALL (unsigned int)0xFFFF
+#define ENGINE_METHOD_NONE (unsigned int)0x0000
 
 /*
  * This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used
@@ -61,7 +62,7 @@ extern "C" {
  * set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to
  * initialise registered ENGINEs if they are not already initialised.
  */
-#  define ENGINE_TABLE_FLAG_NOINIT        (unsigned int)0x0001
+#define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001
 
 /* ENGINE flags that can be set by ENGINE_set_flags(). */
 /* Not used */
@@ -73,7 +74,7 @@ extern "C" {
  * these control commands on behalf of the ENGINE using their "cmd_defns"
  * data.
  */
-#  define ENGINE_FLAGS_MANUAL_CMD_CTRL    (int)0x0002
+#define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002
 
 /*
  * This flag is for ENGINEs who return new duplicate structures when found
@@ -85,15 +86,15 @@ extern "C" {
  * ENGINE_by_id() just increments the existing ENGINE's structural reference
  * count.
  */
-#  define ENGINE_FLAGS_BY_ID_COPY         (int)0x0004
+#define ENGINE_FLAGS_BY_ID_COPY (int)0x0004
 
-/*
- * This flag if for an ENGINE that does not want its methods registered as
- * part of ENGINE_register_all_complete() for example if the methods are not
- * usable as default methods.
- */
+    /*
+     * This flag if for an ENGINE that does not want its methods registered as
+     * part of ENGINE_register_all_complete() for example if the methods are not
+     * usable as default methods.
+     */
 
-#  define ENGINE_FLAGS_NO_REGISTER_ALL    (int)0x0008
+#define ENGINE_FLAGS_NO_REGISTER_ALL (int)0x0008
 
 /*
  * ENGINEs can support their own command types, and these flags are used in
@@ -108,23 +109,23 @@ extern "C" {
  */
 
 /* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */
-#  define ENGINE_CMD_FLAG_NUMERIC         (unsigned int)0x0001
+#define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001
 /*
  * accepts string input (cast from 'void*' to 'const char *', 4th parameter
  * to ENGINE_ctrl)
  */
-#  define ENGINE_CMD_FLAG_STRING          (unsigned int)0x0002
+#define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002
 /*
  * Indicates that the control command takes *no* input. Ie. the control
  * command is unparameterised.
  */
-#  define ENGINE_CMD_FLAG_NO_INPUT        (unsigned int)0x0004
+#define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004
 /*
  * Indicates that the control command is internal. This control command won't
  * be shown in any output, and is only usable through the ENGINE_ctrl_cmd()
  * function.
  */
-#  define ENGINE_CMD_FLAG_INTERNAL        (unsigned int)0x0008
+#define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008
 
 /*
  * NB: These 3 control commands are deprecated and should not be used.
@@ -143,23 +144,23 @@ extern "C" {
  * sense to some engines.  In such a case, they do nothing but return the
  * error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED.
  */
-#  define ENGINE_CTRL_SET_LOGSTREAM               1
-#  define ENGINE_CTRL_SET_PASSWORD_CALLBACK       2
-#  define ENGINE_CTRL_HUP                         3/* Close and reinitialise
-                                                   * any handles/connections
-                                                   * etc. */
-#  define ENGINE_CTRL_SET_USER_INTERFACE          4/* Alternative to callback */
-#  define ENGINE_CTRL_SET_CALLBACK_DATA           5/* User-specific data, used
-                                                   * when calling the password
-                                                   * callback and the user
-                                                   * interface */
-#  define ENGINE_CTRL_LOAD_CONFIGURATION          6/* Load a configuration,
-                                                   * given a string that
-                                                   * represents a file name
-                                                   * or so */
-#  define ENGINE_CTRL_LOAD_SECTION                7/* Load data from a given
-                                                   * section in the already
-                                                   * loaded configuration */
+#define ENGINE_CTRL_SET_LOGSTREAM 1
+#define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2
+#define ENGINE_CTRL_HUP 3                /* Close and reinitialise  \
+                                          * any handles/connections \
+                                          * etc. */
+#define ENGINE_CTRL_SET_USER_INTERFACE 4 /* Alternative to callback */
+#define ENGINE_CTRL_SET_CALLBACK_DATA 5  /* User-specific data, used  \
+                                          * when calling the password \
+                                          * callback and the user     \
+                                          * interface */
+#define ENGINE_CTRL_LOAD_CONFIGURATION 6 /* Load a configuration,  \
+                                          * given a string that    \
+                                          * represents a file name \
+                                          * or so */
+#define ENGINE_CTRL_LOAD_SECTION 7       /* Load data from a given \
+                                          * section in the already \
+                                          * loaded configuration */
 
 /*
  * These control commands allow an application to deal with an arbitrary
@@ -181,22 +182,22 @@ extern "C" {
  * worth checking this first if the caller is trying to "discover" the
  * engine's capabilities and doesn't want errors generated unnecessarily.
  */
-#  define ENGINE_CTRL_HAS_CTRL_FUNCTION           10
+#define ENGINE_CTRL_HAS_CTRL_FUNCTION 10
 /*
  * Returns a positive command number for the first command supported by the
  * engine. Returns zero if no ctrl commands are supported.
  */
-#  define ENGINE_CTRL_GET_FIRST_CMD_TYPE          11
+#define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11
 /*
  * The 'long' argument specifies a command implemented by the engine, and the
  * return value is the next command supported, or zero if there are no more.
  */
-#  define ENGINE_CTRL_GET_NEXT_CMD_TYPE           12
+#define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12
 /*
  * The 'void*' argument is a command name (cast from 'const char *'), and the
  * return value is the command that corresponds to it.
  */
-#  define ENGINE_CTRL_GET_CMD_FROM_NAME           13
+#define ENGINE_CTRL_GET_CMD_FROM_NAME 13
 /*
  * The next two allow a command to be converted into its corresponding string
  * form. In each case, the 'long' argument supplies the command. In the
@@ -205,23 +206,23 @@ extern "C" {
  * string buffer large enough, and it will be populated with the name of the
  * command (WITH a trailing EOL).
  */
-#  define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD       14
-#  define ENGINE_CTRL_GET_NAME_FROM_CMD           15
+#define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14
+#define ENGINE_CTRL_GET_NAME_FROM_CMD 15
 /* The next two are similar but give a "short description" of a command. */
-#  define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD       16
-#  define ENGINE_CTRL_GET_DESC_FROM_CMD           17
+#define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16
+#define ENGINE_CTRL_GET_DESC_FROM_CMD 17
 /*
  * With this command, the return value is the OR'd combination of
  * ENGINE_CMD_FLAG_*** values that indicate what kind of input a given
  * engine-specific ctrl command expects.
  */
-#  define ENGINE_CTRL_GET_CMD_FLAGS               18
+#define ENGINE_CTRL_GET_CMD_FLAGS 18
 
 /*
  * ENGINE implementations should start the numbering of their own control
  * commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc).
  */
-#  define ENGINE_CMD_BASE                         200
+#define ENGINE_CMD_BASE 200
 
 /*
  * NB: These 2 nCipher "chil" control commands are deprecated, and their
@@ -232,75 +233,64 @@ extern "C" {
  */
 
 /* Flags specific to the nCipher "chil" engine */
-#  define ENGINE_CTRL_CHIL_SET_FORKCHECK          100
-         /*
-          * Depending on the value of the (long)i argument, this sets or
-          * unsets the SimpleForkCheck flag in the CHIL API to enable or
-          * disable checking and workarounds for applications that fork().
-          */
-#  define ENGINE_CTRL_CHIL_NO_LOCKING             101
-         /*
-          * This prevents the initialisation function from providing mutex
-          * callbacks to the nCipher library.
-          */
-
-/*
- * If an ENGINE supports its own specific control commands and wishes the
- * framework to handle the above 'ENGINE_CMD_***'-manipulation commands on
- * its behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN
- * entries to ENGINE_set_cmd_defns(). It should also implement a ctrl()
- * handler that supports the stated commands (ie. the "cmd_num" entries as
- * described by the array). NB: The array must be ordered in increasing order
- * of cmd_num. "null-terminated" means that the last ENGINE_CMD_DEFN element
- * has cmd_num set to zero and/or cmd_name set to NULL.
- */
-typedef struct ENGINE_CMD_DEFN_st {
-    unsigned int cmd_num;       /* The command number */
-    const char *cmd_name;       /* The command name itself */
-    const char *cmd_desc;       /* A short description of the command */
-    unsigned int cmd_flags;     /* The input the command expects */
-} ENGINE_CMD_DEFN;
-
-/* Generic function pointer */
-typedef int (*ENGINE_GEN_FUNC_PTR) (void);
-/* Generic function pointer taking no arguments */
-typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *);
-/* Specific control function pointer */
-typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *,
-                                     void (*f) (void));
-/* Generic load_key function pointer */
-typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *,
-                                         UI_METHOD *ui_method,
-                                         void *callback_data);
-typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl,
-                                           STACK_OF(X509_NAME) *ca_dn,
-                                           X509 **pcert, EVP_PKEY **pkey,
-                                           STACK_OF(X509) **pother,
-                                           UI_METHOD *ui_method,
-                                           void *callback_data);
-/*-
- * These callback types are for an ENGINE's handler for cipher and digest logic.
- * These handlers have these prototypes;
- *   int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);
- *   int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid);
- * Looking at how to implement these handlers in the case of cipher support, if
- * the framework wants the EVP_CIPHER for 'nid', it will call;
- *   foo(e, &p_evp_cipher, NULL, nid);    (return zero for failure)
- * If the framework wants a list of supported 'nid's, it will call;
- *   foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error)
- */
-/*
- * Returns to a pointer to the array of supported cipher 'nid's. If the
- * second parameter is non-NULL it is set to the size of the returned array.
- */
-typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **,
-                                   const int **, int);
-typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **,
-                                   int);
-typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **,
-                                      const int **, int);
-typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **,
-                                           const int **, int);
+#define ENGINE_CTRL_CHIL_SET_FORKCHECK 100
+    /*
+     * Depending on the value of the (long)i argument, this sets or
+     * unsets the SimpleForkCheck flag in the CHIL API to enable or
+     * disable checking and workarounds for applications that fork().
+     */
+#define ENGINE_CTRL_CHIL_NO_LOCKING 101
+    /*
+     * This prevents the initialisation function from providing mutex
+     * callbacks to the nCipher library.
+     */
+
+    /*
+     * If an ENGINE supports its own specific control commands and wishes the
+     * framework to handle the above 'ENGINE_CMD_***'-manipulation commands on
+     * its behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN
+     * entries to ENGINE_set_cmd_defns(). It should also implement a ctrl()
+     * handler that supports the stated commands (ie. the "cmd_num" entries as
+     * described by the array). NB: The array must be ordered in increasing order
+     * of cmd_num. "null-terminated" means that the last ENGINE_CMD_DEFN element
+     * has cmd_num set to zero and/or cmd_name set to NULL.
+     */
+    typedef struct ENGINE_CMD_DEFN_st
+    {
+        unsigned int cmd_num;   /* The command number */
+        const char* cmd_name;   /* The command name itself */
+        const char* cmd_desc;   /* A short description of the command */
+        unsigned int cmd_flags; /* The input the command expects */
+    } ENGINE_CMD_DEFN;
+
+    /* Generic function pointer */
+    typedef int (*ENGINE_GEN_FUNC_PTR)(void);
+    /* Generic function pointer taking no arguments */
+    typedef int (*ENGINE_GEN_INT_FUNC_PTR)(ENGINE*);
+    /* Specific control function pointer */
+    typedef int (*ENGINE_CTRL_FUNC_PTR)(ENGINE*, int, long, void*, void (*f)(void));
+    /* Generic load_key function pointer */
+    typedef EVP_PKEY* (*ENGINE_LOAD_KEY_PTR)(ENGINE*, const char*, UI_METHOD* ui_method, void* callback_data);
+    typedef int (*ENGINE_SSL_CLIENT_CERT_PTR)(ENGINE*, SSL* ssl, STACK_OF(X509_NAME) * ca_dn, X509** pcert, EVP_PKEY** pkey, STACK_OF(X509) * *pother, UI_METHOD* ui_method, void* callback_data);
+    /*-
+     * These callback types are for an ENGINE's handler for cipher and digest logic.
+     * These handlers have these prototypes;
+     *   int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid);
+     *   int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid);
+     * Looking at how to implement these handlers in the case of cipher support, if
+     * the framework wants the EVP_CIPHER for 'nid', it will call;
+     *   foo(e, &p_evp_cipher, NULL, nid);    (return zero for failure)
+     * If the framework wants a list of supported 'nid's, it will call;
+     *   foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error)
+     */
+    /*
+     * Returns to a pointer to the array of supported cipher 'nid's. If the
+     * second parameter is non-NULL it is set to the size of the returned array.
+     */
+    typedef int (*ENGINE_CIPHERS_PTR)(ENGINE*, const EVP_CIPHER**, const int**, int);
+    typedef int (*ENGINE_DIGESTS_PTR)(ENGINE*, const EVP_MD**, const int**, int);
+    typedef int (*ENGINE_PKEY_METHS_PTR)(ENGINE*, EVP_PKEY_METHOD**, const int**, int);
+    typedef int (*ENGINE_PKEY_ASN1_METHS_PTR)(ENGINE*, EVP_PKEY_ASN1_METHOD**, const int**, int);
 /*
  * STRUCTURE functions ... all of these functions deal with pointers to
  * ENGINE structures where the pointers have a "structural reference". This
@@ -314,58 +304,58 @@ typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **,
  */
 
 /* Get the first/last "ENGINE" type available. */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_first(void);
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_last(void);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_first(void);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_last(void);
+#endif
 /* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_next(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_prev(ENGINE *e);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_next(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_prev(ENGINE* e);
+#endif
 /* Add another "ENGINE" type into the array. */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_add(ENGINE *e);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_add(ENGINE* e);
+#endif
 /* Remove an existing "ENGINE" type from the array. */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_remove(ENGINE *e);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_remove(ENGINE* e);
+#endif
 /* Retrieve an engine from the list by its unique "id" value. */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_by_id(const char *id);
-#  endif
-
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#   define ENGINE_load_openssl() \
-        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL)
-#   define ENGINE_load_dynamic() \
-        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL)
-#   ifndef OPENSSL_NO_STATIC_ENGINE
-#    define ENGINE_load_padlock() \
-        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL)
-#    define ENGINE_load_capi() \
-        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL)
-#    define ENGINE_load_afalg() \
-        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL)
-#   endif
-#   define ENGINE_load_cryptodev() \
-        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL)
-#   define ENGINE_load_rdrand() \
-        OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL)
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 void ENGINE_load_builtin_engines(void);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_by_id(const char* id);
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define ENGINE_load_openssl() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL)
+#define ENGINE_load_dynamic() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL)
+#ifndef OPENSSL_NO_STATIC_ENGINE
+#define ENGINE_load_padlock() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL)
+#define ENGINE_load_capi() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL)
+#define ENGINE_load_afalg() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL)
+#endif
+#define ENGINE_load_cryptodev() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL)
+#define ENGINE_load_rdrand() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL)
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_load_builtin_engines(void);
+#endif
 
 /*
  * Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation
  * "registry" handling.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 unsigned int ENGINE_get_table_flags(void);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_set_table_flags(unsigned int flags);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 unsigned int ENGINE_get_table_flags(void);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_set_table_flags(unsigned int flags);
+#endif
 
 /*- Manage registration of ENGINEs per "table". For each type, there are 3
  * functions;
@@ -374,35 +364,35 @@ OSSL_DEPRECATEDIN_3_0 void ENGINE_set_table_flags(unsigned int flags);
  *   ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list
  * Cleanup is automatically registered from each table when required.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_RSA(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_RSA(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_RSA(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_DSA(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_DSA(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_DSA(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_EC(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_EC(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_EC(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_DH(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_DH(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_DH(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_RAND(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_RAND(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_RAND(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_ciphers(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_ciphers(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_ciphers(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_digests(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_digests(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_digests(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_pkey_meths(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_pkey_meths(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_meths(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_pkey_asn1_meths(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_pkey_asn1_meths(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_asn1_meths(void);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_RSA(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_RSA(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_RSA(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_DSA(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_DSA(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_DSA(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_EC(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_EC(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_EC(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_DH(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_DH(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_DH(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_RAND(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_RAND(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_RAND(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_ciphers(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_ciphers(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_ciphers(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_digests(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_digests(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_digests(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_pkey_meths(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_pkey_meths(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_meths(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_pkey_asn1_meths(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_unregister_pkey_asn1_meths(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_asn1_meths(void);
+#endif
 
 /*
  * These functions register all support from the above categories. Note, use
@@ -410,10 +400,10 @@ OSSL_DEPRECATEDIN_3_0 void ENGINE_register_all_pkey_asn1_meths(void);
  * may not need. If you only need a subset of functionality, consider using
  * more selective initialisation.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_complete(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_register_all_complete(void);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_complete(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_register_all_complete(void);
+#endif
 
 /*
  * Send parameterised control commands to the engine. The possibilities to
@@ -425,10 +415,9 @@ OSSL_DEPRECATEDIN_3_0 int ENGINE_register_all_complete(void);
  * commands that require an operational ENGINE, and only use functional
  * references in such situations.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p,
-                                      void (*f) (void));
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl(ENGINE* e, int cmd, long i, void* p, void (*f)(void));
+#endif
 
 /*
  * This function tests if an ENGINE-specific command is usable as a
@@ -436,9 +425,9 @@ OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p,
  * ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to
  * ENGINE_ctrl_cmd_string(), only ENGINE_ctrl().
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_cmd_is_executable(ENGINE* e, int cmd);
+#endif
 
 /*
  * This function works like ENGINE_ctrl() with the exception of taking a
@@ -446,11 +435,9 @@ OSSL_DEPRECATEDIN_3_0 int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
  * commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation
  * on how to use the cmd_name and cmd_optional.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
-                                          long i, void *p, void (*f) (void),
-                                          int cmd_optional);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl_cmd(ENGINE* e, const char* cmd_name, long i, void* p, void (*f)(void), int cmd_optional);
+#endif
 
 /*
  * This function passes a command-name and argument to an ENGINE. The
@@ -474,11 +461,10 @@ OSSL_DEPRECATEDIN_3_0 int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
  * applications can work consistently with the same configuration for the
  * same ENGINE-enabled devices, across applications.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
-                           int cmd_optional);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_ctrl_cmd_string(ENGINE* e, const char* cmd_name, const char* arg, int cmd_optional);
+#endif
 
 /*
  * These functions are useful for manufacturing new ENGINE structures. They
@@ -488,59 +474,59 @@ int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
  * These are also here so that the ENGINE structure doesn't have to be
  * exposed and break binary compatibility!
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_new(void);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_free(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_up_ref(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_id(ENGINE *e, const char *id);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_name(ENGINE *e, const char *name);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_destroy_function(ENGINE *e,ENGINE_GEN_INT_FUNC_PTR destroy_f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
-                                             ENGINE_SSL_CLIENT_CERT_PTR loadssl_f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_flags(ENGINE *e, int flags);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_cmd_defns(ENGINE *e,
-                                               const ENGINE_CMD_DEFN *defns);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_new(void);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_free(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_up_ref(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_id(ENGINE* e, const char* id);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_name(ENGINE* e, const char* name);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_RSA(ENGINE* e, const RSA_METHOD* rsa_meth);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_DSA(ENGINE* e, const DSA_METHOD* dsa_meth);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_EC(ENGINE* e, const EC_KEY_METHOD* ecdsa_meth);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_DH(ENGINE* e, const DH_METHOD* dh_meth);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_RAND(ENGINE* e, const RAND_METHOD* rand_meth);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_destroy_function(ENGINE* e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_init_function(ENGINE* e, ENGINE_GEN_INT_FUNC_PTR init_f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_finish_function(ENGINE* e, ENGINE_GEN_INT_FUNC_PTR finish_f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_ctrl_function(ENGINE* e, ENGINE_CTRL_FUNC_PTR ctrl_f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_load_privkey_function(ENGINE* e, ENGINE_LOAD_KEY_PTR loadpriv_f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_load_pubkey_function(ENGINE* e, ENGINE_LOAD_KEY_PTR loadpub_f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_load_ssl_client_cert_function(ENGINE* e, ENGINE_SSL_CLIENT_CERT_PTR loadssl_f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_ciphers(ENGINE* e, ENGINE_CIPHERS_PTR f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_digests(ENGINE* e, ENGINE_DIGESTS_PTR f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_pkey_meths(ENGINE* e, ENGINE_PKEY_METHS_PTR f);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_set_pkey_asn1_meths(ENGINE* e, ENGINE_PKEY_ASN1_METHS_PTR f);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_flags(ENGINE* e, int flags);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_cmd_defns(ENGINE* e, const ENGINE_CMD_DEFN* defns);
+#endif
 /* These functions allow control over any per-structure ENGINE data. */
-#  define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \
+#define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, l, p, newf, dupf, freef)
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg);
-OSSL_DEPRECATEDIN_3_0 void *ENGINE_get_ex_data(const ENGINE *e, int idx);
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_ex_data(ENGINE* e, int idx, void* arg);
+    OSSL_DEPRECATEDIN_3_0 void* ENGINE_get_ex_data(const ENGINE* e, int idx);
+#endif
 
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
 /*
  * This function previously cleaned up anything that needs it. Auto-deinit will
  * now take care of it so it is no longer required to call this function.
  */
-#   define ENGINE_cleanup() while(0) continue
-#  endif
+#define ENGINE_cleanup() \
+    while (0)            \
+    continue
+#endif
 
 /*
  * These return values from within the ENGINE structure. These can be useful
@@ -548,55 +534,52 @@ OSSL_DEPRECATEDIN_3_0 void *ENGINE_get_ex_data(const ENGINE *e, int idx);
  * which you obtained. Using the result for functional purposes if you only
  * obtained a structural reference may be problematic!
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 const char *ENGINE_get_id(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 const char *ENGINE_get_name(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
-OSSL_DEPRECATEDIN_3_0
-const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
-OSSL_DEPRECATEDIN_3_0
-const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid);
-OSSL_DEPRECATEDIN_3_0
-const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid);
-OSSL_DEPRECATEDIN_3_0
-const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e,
-                                                          const char *str,
-                                                          int len);
-OSSL_DEPRECATEDIN_3_0
-const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe,
-                                                      const char *str, int len);
-OSSL_DEPRECATEDIN_3_0
-const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_get_flags(const ENGINE *e);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 const char* ENGINE_get_id(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 const char* ENGINE_get_name(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 const RSA_METHOD* ENGINE_get_RSA(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 const DSA_METHOD* ENGINE_get_DSA(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 const EC_KEY_METHOD* ENGINE_get_EC(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 const DH_METHOD* ENGINE_get_DH(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 const RAND_METHOD* ENGINE_get_RAND(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    const EVP_CIPHER* ENGINE_get_cipher(ENGINE* e, int nid);
+    OSSL_DEPRECATEDIN_3_0
+    const EVP_MD* ENGINE_get_digest(ENGINE* e, int nid);
+    OSSL_DEPRECATEDIN_3_0
+    const EVP_PKEY_METHOD* ENGINE_get_pkey_meth(ENGINE* e, int nid);
+    OSSL_DEPRECATEDIN_3_0
+    const EVP_PKEY_ASN1_METHOD* ENGINE_get_pkey_asn1_meth(ENGINE* e, int nid);
+    OSSL_DEPRECATEDIN_3_0
+    const EVP_PKEY_ASN1_METHOD* ENGINE_get_pkey_asn1_meth_str(ENGINE* e, const char* str, int len);
+    OSSL_DEPRECATEDIN_3_0
+    const EVP_PKEY_ASN1_METHOD* ENGINE_pkey_asn1_find_str(ENGINE** pe, const char* str, int len);
+    OSSL_DEPRECATEDIN_3_0
+    const ENGINE_CMD_DEFN* ENGINE_get_cmd_defns(const ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_get_flags(const ENGINE* e);
+#endif
 
 /*
  * FUNCTIONAL functions. These functions deal with ENGINE structures that
@@ -616,36 +599,31 @@ OSSL_DEPRECATEDIN_3_0 int ENGINE_get_flags(const ENGINE *e);
  * already in use). This will fail if the engine is not currently operational
  * and cannot initialise.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_init(ENGINE *e);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_init(ENGINE* e);
+#endif
 /*
  * Free a functional reference to a engine type. This does not require a
  * corresponding call to ENGINE_free as it also releases a structural
  * reference.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_finish(ENGINE *e);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_finish(ENGINE* e);
+#endif
 
 /*
  * The following functions handle keys that are stored in some secondary
  * location, handled by the engine.  The storage may be on a card or
  * whatever.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
-                                  UI_METHOD *ui_method, void *callback_data);
-OSSL_DEPRECATEDIN_3_0
-EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
-                                 UI_METHOD *ui_method, void *callback_data);
-OSSL_DEPRECATEDIN_3_0
-int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, STACK_OF(X509_NAME) *ca_dn,
-                                X509 **pcert, EVP_PKEY **ppkey,
-                                STACK_OF(X509) **pother,
-                                UI_METHOD *ui_method, void *callback_data);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    EVP_PKEY* ENGINE_load_private_key(ENGINE* e, const char* key_id, UI_METHOD* ui_method, void* callback_data);
+    OSSL_DEPRECATEDIN_3_0
+    EVP_PKEY* ENGINE_load_public_key(ENGINE* e, const char* key_id, UI_METHOD* ui_method, void* callback_data);
+    OSSL_DEPRECATEDIN_3_0
+    int ENGINE_load_ssl_client_cert(ENGINE* e, SSL* s, STACK_OF(X509_NAME) * ca_dn, X509** pcert, EVP_PKEY** ppkey, STACK_OF(X509) * *pother, UI_METHOD* ui_method, void* callback_data);
+#endif
 
 /*
  * This returns a pointer for the current ENGINE structure that is (by
@@ -653,26 +631,26 @@ int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, STACK_OF(X509_NAME) *ca_dn,
  * incremented reference, so it should be free'd (ENGINE_finish) before it is
  * discarded.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_RSA(void);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_default_RSA(void);
+#endif
 /* Same for the other "methods" */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_DSA(void);
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_EC(void);
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_DH(void);
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_default_RAND(void);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_default_DSA(void);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_default_EC(void);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_default_DH(void);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_default_RAND(void);
+#endif
 /*
  * These functions can be used to get a functional reference to perform
  * ciphering or digesting corresponding to "nid".
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_cipher_engine(int nid);
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_digest_engine(int nid);
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_pkey_meth_engine(int nid);
-OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_cipher_engine(int nid);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_digest_engine(int nid);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_pkey_meth_engine(int nid);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* ENGINE_get_pkey_asn1_meth_engine(int nid);
+#endif
 
 /*
  * This sets a new default ENGINE structure for performing RSA operations. If
@@ -680,22 +658,21 @@ OSSL_DEPRECATEDIN_3_0 ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid);
  * its reference count up'd so the caller should still free their own
  * reference 'e'.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_RSA(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_string(ENGINE *e,
-                                                    const char *def_list);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_RSA(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_string(ENGINE* e, const char* def_list);
+#endif
 /* Same for the other "methods" */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_DSA(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_EC(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_DH(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_RAND(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_ciphers(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_digests(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_meths(ENGINE *e);
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_asn1_meths(ENGINE *e);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_DSA(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_EC(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_DH(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_RAND(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_ciphers(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_digests(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_meths(ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_asn1_meths(ENGINE* e);
+#endif
 
 /*
  * The combination "set" - the flags are bitwise "OR"d from the
@@ -704,10 +681,10 @@ OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default_pkey_asn1_meths(ENGINE *e);
  * application requires only specific functionality, consider using more
  * selective functions.
  */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default(ENGINE *e, unsigned int flags);
-OSSL_DEPRECATEDIN_3_0 void ENGINE_add_conf_module(void);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ENGINE_set_default(ENGINE* e, unsigned int flags);
+    OSSL_DEPRECATEDIN_3_0 void ENGINE_add_conf_module(void);
+#endif
 
 /* Deprecated functions ... */
 /* int ENGINE_clear_defaults(void); */
@@ -717,117 +694,122 @@ OSSL_DEPRECATEDIN_3_0 void ENGINE_add_conf_module(void);
 /**************************/
 
 /* Binary/behaviour compatibility levels */
-#  define OSSL_DYNAMIC_VERSION            (unsigned long)0x00030000
+#define OSSL_DYNAMIC_VERSION (unsigned long)0x00030000
 /*
  * Binary versions older than this are too old for us (whether we're a loader
  * or a loadee)
  */
-#  define OSSL_DYNAMIC_OLDEST             (unsigned long)0x00030000
-
-/*
- * When compiling an ENGINE entirely as an external shared library, loadable
- * by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns'
- * structure type provides the calling application's (or library's) error
- * functionality and memory management function pointers to the loaded
- * library. These should be used/set in the loaded library code so that the
- * loading application's 'state' will be used/changed in all operations. The
- * 'static_state' pointer allows the loaded library to know if it shares the
- * same static data as the calling application (or library), and thus whether
- * these callbacks need to be set or not.
- */
-typedef void *(*dyn_MEM_malloc_fn) (size_t, const char *, int);
-typedef void *(*dyn_MEM_realloc_fn) (void *, size_t, const char *, int);
-typedef void (*dyn_MEM_free_fn) (void *, const char *, int);
-typedef struct st_dynamic_MEM_fns {
-    dyn_MEM_malloc_fn malloc_fn;
-    dyn_MEM_realloc_fn realloc_fn;
-    dyn_MEM_free_fn free_fn;
-} dynamic_MEM_fns;
-/*
- * FIXME: Perhaps the memory and locking code (crypto.h) should declare and
- * use these types so we (and any other dependent code) can simplify a bit??
- */
-/* The top-level structure */
-typedef struct st_dynamic_fns {
-    void *static_state;
-    dynamic_MEM_fns mem_fns;
-} dynamic_fns;
-
-/*
- * The version checking function should be of this prototype. NB: The
- * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading
- * code. If this function returns zero, it indicates a (potential) version
- * incompatibility and the loaded library doesn't believe it can proceed.
- * Otherwise, the returned value is the (latest) version supported by the
- * loading library. The loader may still decide that the loaded code's
- * version is unsatisfactory and could veto the load. The function is
- * expected to be implemented with the symbol name "v_check", and a default
- * implementation can be fully instantiated with
- * IMPLEMENT_DYNAMIC_CHECK_FN().
- */
-typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version);
-#  define IMPLEMENT_DYNAMIC_CHECK_FN() \
-        OPENSSL_EXPORT unsigned long v_check(unsigned long v); \
-        OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \
-                if (v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \
-                return 0; }
-
-/*
- * This function is passed the ENGINE structure to initialise with its own
- * function and command settings. It should not adjust the structural or
- * functional reference counts. If this function returns zero, (a) the load
- * will be aborted, (b) the previous ENGINE state will be memcpy'd back onto
- * the structure, and (c) the shared library will be unloaded. So
- * implementations should do their own internal cleanup in failure
- * circumstances otherwise they could leak. The 'id' parameter, if non-NULL,
- * represents the ENGINE id that the loader is looking for. If this is NULL,
- * the shared library can choose to return failure or to initialise a
- * 'default' ENGINE. If non-NULL, the shared library must initialise only an
- * ENGINE matching the passed 'id'. The function is expected to be
- * implemented with the symbol name "bind_engine". A standard implementation
- * can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where the parameter
- * 'fn' is a callback function that populates the ENGINE structure and
- * returns an int value (zero for failure). 'fn' should have prototype;
- * [static] int fn(ENGINE *e, const char *id);
- */
-typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id,
-                                    const dynamic_fns *fns);
-#  define IMPLEMENT_DYNAMIC_BIND_FN(fn) \
-        OPENSSL_EXPORT \
-        int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \
-        OPENSSL_EXPORT \
-        int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \
-            if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \
-            CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, \
-                                     fns->mem_fns.realloc_fn, \
-                                     fns->mem_fns.free_fn); \
-            OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, NULL); \
-        skip_cbs: \
-            if (!fn(e, id)) return 0; \
-            return 1; }
-
-/*
- * If the loading application (or library) and the loaded ENGINE library
- * share the same static data (eg. they're both dynamically linked to the
- * same libcrypto.so) we need a way to avoid trying to set system callbacks -
- * this would fail, and for the same reason that it's unnecessary to try. If
- * the loaded ENGINE has (or gets from through the loader) its own copy of
- * the libcrypto static data, we will need to set the callbacks. The easiest
- * way to detect this is to have a function that returns a pointer to some
- * static data and let the loading application and loaded ENGINE compare
- * their respective values.
- */
-void *ENGINE_get_static_state(void);
-
-#  if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
-#   ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 void ENGINE_setup_bsd_cryptodev(void);
-#   endif
-#  endif
-
-
-#  ifdef  __cplusplus
+#define OSSL_DYNAMIC_OLDEST (unsigned long)0x00030000
+
+    /*
+     * When compiling an ENGINE entirely as an external shared library, loadable
+     * by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns'
+     * structure type provides the calling application's (or library's) error
+     * functionality and memory management function pointers to the loaded
+     * library. These should be used/set in the loaded library code so that the
+     * loading application's 'state' will be used/changed in all operations. The
+     * 'static_state' pointer allows the loaded library to know if it shares the
+     * same static data as the calling application (or library), and thus whether
+     * these callbacks need to be set or not.
+     */
+    typedef void* (*dyn_MEM_malloc_fn)(size_t, const char*, int);
+    typedef void* (*dyn_MEM_realloc_fn)(void*, size_t, const char*, int);
+    typedef void (*dyn_MEM_free_fn)(void*, const char*, int);
+    typedef struct st_dynamic_MEM_fns
+    {
+        dyn_MEM_malloc_fn malloc_fn;
+        dyn_MEM_realloc_fn realloc_fn;
+        dyn_MEM_free_fn free_fn;
+    } dynamic_MEM_fns;
+    /*
+     * FIXME: Perhaps the memory and locking code (crypto.h) should declare and
+     * use these types so we (and any other dependent code) can simplify a bit??
+     */
+    /* The top-level structure */
+    typedef struct st_dynamic_fns
+    {
+        void* static_state;
+        dynamic_MEM_fns mem_fns;
+    } dynamic_fns;
+
+    /*
+     * The version checking function should be of this prototype. NB: The
+     * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading
+     * code. If this function returns zero, it indicates a (potential) version
+     * incompatibility and the loaded library doesn't believe it can proceed.
+     * Otherwise, the returned value is the (latest) version supported by the
+     * loading library. The loader may still decide that the loaded code's
+     * version is unsatisfactory and could veto the load. The function is
+     * expected to be implemented with the symbol name "v_check", and a default
+     * implementation can be fully instantiated with
+     * IMPLEMENT_DYNAMIC_CHECK_FN().
+     */
+    typedef unsigned long (*dynamic_v_check_fn)(unsigned long ossl_version);
+#define IMPLEMENT_DYNAMIC_CHECK_FN()                       \
+    OPENSSL_EXPORT unsigned long v_check(unsigned long v); \
+    OPENSSL_EXPORT unsigned long v_check(unsigned long v)  \
+    {                                                      \
+        if (v >= OSSL_DYNAMIC_OLDEST)                      \
+            return OSSL_DYNAMIC_VERSION;                   \
+        return 0;                                          \
+    }
+
+    /*
+     * This function is passed the ENGINE structure to initialise with its own
+     * function and command settings. It should not adjust the structural or
+     * functional reference counts. If this function returns zero, (a) the load
+     * will be aborted, (b) the previous ENGINE state will be memcpy'd back onto
+     * the structure, and (c) the shared library will be unloaded. So
+     * implementations should do their own internal cleanup in failure
+     * circumstances otherwise they could leak. The 'id' parameter, if non-NULL,
+     * represents the ENGINE id that the loader is looking for. If this is NULL,
+     * the shared library can choose to return failure or to initialise a
+     * 'default' ENGINE. If non-NULL, the shared library must initialise only an
+     * ENGINE matching the passed 'id'. The function is expected to be
+     * implemented with the symbol name "bind_engine". A standard implementation
+     * can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where the parameter
+     * 'fn' is a callback function that populates the ENGINE structure and
+     * returns an int value (zero for failure). 'fn' should have prototype;
+     * [static] int fn(ENGINE *e, const char *id);
+     */
+    typedef int (*dynamic_bind_engine)(ENGINE* e, const char* id, const dynamic_fns* fns);
+#define IMPLEMENT_DYNAMIC_BIND_FN(fn)                                                                    \
+    OPENSSL_EXPORT                                                                                       \
+    int bind_engine(ENGINE* e, const char* id, const dynamic_fns* fns);                                  \
+    OPENSSL_EXPORT                                                                                       \
+    int bind_engine(ENGINE* e, const char* id, const dynamic_fns* fns)                                   \
+    {                                                                                                    \
+        if (ENGINE_get_static_state() == fns->static_state)                                              \
+            goto skip_cbs;                                                                               \
+        CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, fns->mem_fns.realloc_fn, fns->mem_fns.free_fn); \
+        OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, NULL);                                               \
+    skip_cbs:                                                                                            \
+        if (!fn(e, id))                                                                                  \
+            return 0;                                                                                    \
+        return 1;                                                                                        \
+    }
+
+    /*
+     * If the loading application (or library) and the loaded ENGINE library
+     * share the same static data (eg. they're both dynamically linked to the
+     * same libcrypto.so) we need a way to avoid trying to set system callbacks -
+     * this would fail, and for the same reason that it's unnecessary to try. If
+     * the loaded ENGINE has (or gets from through the loader) its own copy of
+     * the libcrypto static data, we will need to set the callbacks. The easiest
+     * way to detect this is to have a function that returns a pointer to some
+     * static data and let the loading application and loaded ENGINE compare
+     * their respective values.
+     */
+    void* ENGINE_get_static_state(void);
+
+#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 void ENGINE_setup_bsd_cryptodev(void);
+#endif
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
-# endif /* OPENSSL_NO_ENGINE */
-#endif  /* OPENSSL_ENGINE_H */
+#endif
+#endif /* OPENSSL_NO_ENGINE */
+#endif /* OPENSSL_ENGINE_H */
diff --git a/CAPI/cpp/grpc/include/openssl/engineerr.h b/CAPI/cpp/grpc/include/openssl/engineerr.h
index d439b68..7cdfb8a 100644
--- a/CAPI/cpp/grpc/include/openssl/engineerr.h
+++ b/CAPI/cpp/grpc/include/openssl/engineerr.h
@@ -9,55 +9,53 @@
  */
 
 #ifndef OPENSSL_ENGINEERR_H
-# define OPENSSL_ENGINEERR_H
-# pragma once
+#define OPENSSL_ENGINEERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_ENGINE
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_ENGINE
 
 /*
  * ENGINE reason codes.
  */
-#  define ENGINE_R_ALREADY_LOADED                          100
-#  define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER                133
-#  define ENGINE_R_CMD_NOT_EXECUTABLE                      134
-#  define ENGINE_R_COMMAND_TAKES_INPUT                     135
-#  define ENGINE_R_COMMAND_TAKES_NO_INPUT                  136
-#  define ENGINE_R_CONFLICTING_ENGINE_ID                   103
-#  define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED            119
-#  define ENGINE_R_DSO_FAILURE                             104
-#  define ENGINE_R_DSO_NOT_FOUND                           132
-#  define ENGINE_R_ENGINES_SECTION_ERROR                   148
-#  define ENGINE_R_ENGINE_CONFIGURATION_ERROR              102
-#  define ENGINE_R_ENGINE_IS_NOT_IN_LIST                   105
-#  define ENGINE_R_ENGINE_SECTION_ERROR                    149
-#  define ENGINE_R_FAILED_LOADING_PRIVATE_KEY              128
-#  define ENGINE_R_FAILED_LOADING_PUBLIC_KEY               129
-#  define ENGINE_R_FINISH_FAILED                           106
-#  define ENGINE_R_ID_OR_NAME_MISSING                      108
-#  define ENGINE_R_INIT_FAILED                             109
-#  define ENGINE_R_INTERNAL_LIST_ERROR                     110
-#  define ENGINE_R_INVALID_ARGUMENT                        143
-#  define ENGINE_R_INVALID_CMD_NAME                        137
-#  define ENGINE_R_INVALID_CMD_NUMBER                      138
-#  define ENGINE_R_INVALID_INIT_VALUE                      151
-#  define ENGINE_R_INVALID_STRING                          150
-#  define ENGINE_R_NOT_INITIALISED                         117
-#  define ENGINE_R_NOT_LOADED                              112
-#  define ENGINE_R_NO_CONTROL_FUNCTION                     120
-#  define ENGINE_R_NO_INDEX                                144
-#  define ENGINE_R_NO_LOAD_FUNCTION                        125
-#  define ENGINE_R_NO_REFERENCE                            130
-#  define ENGINE_R_NO_SUCH_ENGINE                          116
-#  define ENGINE_R_UNIMPLEMENTED_CIPHER                    146
-#  define ENGINE_R_UNIMPLEMENTED_DIGEST                    147
-#  define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD         101
-#  define ENGINE_R_VERSION_INCOMPATIBILITY                 145
+#define ENGINE_R_ALREADY_LOADED 100
+#define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER 133
+#define ENGINE_R_CMD_NOT_EXECUTABLE 134
+#define ENGINE_R_COMMAND_TAKES_INPUT 135
+#define ENGINE_R_COMMAND_TAKES_NO_INPUT 136
+#define ENGINE_R_CONFLICTING_ENGINE_ID 103
+#define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED 119
+#define ENGINE_R_DSO_FAILURE 104
+#define ENGINE_R_DSO_NOT_FOUND 132
+#define ENGINE_R_ENGINES_SECTION_ERROR 148
+#define ENGINE_R_ENGINE_CONFIGURATION_ERROR 102
+#define ENGINE_R_ENGINE_IS_NOT_IN_LIST 105
+#define ENGINE_R_ENGINE_SECTION_ERROR 149
+#define ENGINE_R_FAILED_LOADING_PRIVATE_KEY 128
+#define ENGINE_R_FAILED_LOADING_PUBLIC_KEY 129
+#define ENGINE_R_FINISH_FAILED 106
+#define ENGINE_R_ID_OR_NAME_MISSING 108
+#define ENGINE_R_INIT_FAILED 109
+#define ENGINE_R_INTERNAL_LIST_ERROR 110
+#define ENGINE_R_INVALID_ARGUMENT 143
+#define ENGINE_R_INVALID_CMD_NAME 137
+#define ENGINE_R_INVALID_CMD_NUMBER 138
+#define ENGINE_R_INVALID_INIT_VALUE 151
+#define ENGINE_R_INVALID_STRING 150
+#define ENGINE_R_NOT_INITIALISED 117
+#define ENGINE_R_NOT_LOADED 112
+#define ENGINE_R_NO_CONTROL_FUNCTION 120
+#define ENGINE_R_NO_INDEX 144
+#define ENGINE_R_NO_LOAD_FUNCTION 125
+#define ENGINE_R_NO_REFERENCE 130
+#define ENGINE_R_NO_SUCH_ENGINE 116
+#define ENGINE_R_UNIMPLEMENTED_CIPHER 146
+#define ENGINE_R_UNIMPLEMENTED_DIGEST 147
+#define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD 101
+#define ENGINE_R_VERSION_INCOMPATIBILITY 145
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/err.h b/CAPI/cpp/grpc/include/openssl/err.h
index 3c7299d..fb4a21b 100644
--- a/CAPI/cpp/grpc/include/openssl/err.h
+++ b/CAPI/cpp/grpc/include/openssl/err.h
@@ -7,167 +7,167 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_ERR_H
-# define OPENSSL_ERR_H
-# pragma once
+#define OPENSSL_ERR_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_ERR_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ERR_H
+#endif
 
-# include <openssl/e_os2.h>
+#include <openssl/e_os2.h>
 
-# ifndef OPENSSL_NO_STDIO
-#  include <stdio.h>
-#  include <stdlib.h>
-# endif
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#include <stdlib.h>
+#endif
 
-# include <openssl/types.h>
-# include <openssl/bio.h>
-# include <openssl/lhash.h>
-# include <openssl/cryptoerr_legacy.h>
+#include <openssl/types.h>
+#include <openssl/bio.h>
+#include <openssl/lhash.h>
+#include <openssl/cryptoerr_legacy.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifndef OPENSSL_NO_FILENAMES
-#   define ERR_PUT_error(l,f,r,fn,ln)      ERR_put_error(l,f,r,fn,ln)
-#  else
-#   define ERR_PUT_error(l,f,r,fn,ln)      ERR_put_error(l,f,r,NULL,0)
-#  endif
-# endif
-
-# include <limits.h>
-# include <errno.h>
-
-# define ERR_TXT_MALLOCED        0x01
-# define ERR_TXT_STRING          0x02
-
-# if !defined(OPENSSL_NO_DEPRECATED_3_0) || defined(OSSL_FORCE_ERR_STATE)
-#  define ERR_FLAG_MARK           0x01
-#  define ERR_FLAG_CLEAR          0x02
-
-#  define ERR_NUM_ERRORS  16
-struct err_state_st {
-    int err_flags[ERR_NUM_ERRORS];
-    int err_marks[ERR_NUM_ERRORS];
-    unsigned long err_buffer[ERR_NUM_ERRORS];
-    char *err_data[ERR_NUM_ERRORS];
-    size_t err_data_size[ERR_NUM_ERRORS];
-    int err_data_flags[ERR_NUM_ERRORS];
-    char *err_file[ERR_NUM_ERRORS];
-    int err_line[ERR_NUM_ERRORS];
-    char *err_func[ERR_NUM_ERRORS];
-    int top, bottom;
-};
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_FILENAMES
+#define ERR_PUT_error(l, f, r, fn, ln) ERR_put_error(l, f, r, fn, ln)
+#else
+#define ERR_PUT_error(l, f, r, fn, ln) ERR_put_error(l, f, r, NULL, 0)
+#endif
+#endif
+
+#include <limits.h>
+#include <errno.h>
+
+#define ERR_TXT_MALLOCED 0x01
+#define ERR_TXT_STRING 0x02
+
+#if !defined(OPENSSL_NO_DEPRECATED_3_0) || defined(OSSL_FORCE_ERR_STATE)
+#define ERR_FLAG_MARK 0x01
+#define ERR_FLAG_CLEAR 0x02
+
+#define ERR_NUM_ERRORS 16
+    struct err_state_st
+    {
+        int err_flags[ERR_NUM_ERRORS];
+        int err_marks[ERR_NUM_ERRORS];
+        unsigned long err_buffer[ERR_NUM_ERRORS];
+        char* err_data[ERR_NUM_ERRORS];
+        size_t err_data_size[ERR_NUM_ERRORS];
+        int err_data_flags[ERR_NUM_ERRORS];
+        char* err_file[ERR_NUM_ERRORS];
+        int err_line[ERR_NUM_ERRORS];
+        char* err_func[ERR_NUM_ERRORS];
+        int top, bottom;
+    };
+#endif
 
 /* library */
-# define ERR_LIB_NONE            1
-# define ERR_LIB_SYS             2
-# define ERR_LIB_BN              3
-# define ERR_LIB_RSA             4
-# define ERR_LIB_DH              5
-# define ERR_LIB_EVP             6
-# define ERR_LIB_BUF             7
-# define ERR_LIB_OBJ             8
-# define ERR_LIB_PEM             9
-# define ERR_LIB_DSA             10
-# define ERR_LIB_X509            11
+#define ERR_LIB_NONE 1
+#define ERR_LIB_SYS 2
+#define ERR_LIB_BN 3
+#define ERR_LIB_RSA 4
+#define ERR_LIB_DH 5
+#define ERR_LIB_EVP 6
+#define ERR_LIB_BUF 7
+#define ERR_LIB_OBJ 8
+#define ERR_LIB_PEM 9
+#define ERR_LIB_DSA 10
+#define ERR_LIB_X509 11
 /* #define ERR_LIB_METH         12 */
-# define ERR_LIB_ASN1            13
-# define ERR_LIB_CONF            14
-# define ERR_LIB_CRYPTO          15
-# define ERR_LIB_EC              16
-# define ERR_LIB_SSL             20
+#define ERR_LIB_ASN1 13
+#define ERR_LIB_CONF 14
+#define ERR_LIB_CRYPTO 15
+#define ERR_LIB_EC 16
+#define ERR_LIB_SSL 20
 /* #define ERR_LIB_SSL23        21 */
 /* #define ERR_LIB_SSL2         22 */
 /* #define ERR_LIB_SSL3         23 */
 /* #define ERR_LIB_RSAREF       30 */
 /* #define ERR_LIB_PROXY        31 */
-# define ERR_LIB_BIO             32
-# define ERR_LIB_PKCS7           33
-# define ERR_LIB_X509V3          34
-# define ERR_LIB_PKCS12          35
-# define ERR_LIB_RAND            36
-# define ERR_LIB_DSO             37
-# define ERR_LIB_ENGINE          38
-# define ERR_LIB_OCSP            39
-# define ERR_LIB_UI              40
-# define ERR_LIB_COMP            41
-# define ERR_LIB_ECDSA           42
-# define ERR_LIB_ECDH            43
-# define ERR_LIB_OSSL_STORE      44
-# define ERR_LIB_FIPS            45
-# define ERR_LIB_CMS             46
-# define ERR_LIB_TS              47
-# define ERR_LIB_HMAC            48
+#define ERR_LIB_BIO 32
+#define ERR_LIB_PKCS7 33
+#define ERR_LIB_X509V3 34
+#define ERR_LIB_PKCS12 35
+#define ERR_LIB_RAND 36
+#define ERR_LIB_DSO 37
+#define ERR_LIB_ENGINE 38
+#define ERR_LIB_OCSP 39
+#define ERR_LIB_UI 40
+#define ERR_LIB_COMP 41
+#define ERR_LIB_ECDSA 42
+#define ERR_LIB_ECDH 43
+#define ERR_LIB_OSSL_STORE 44
+#define ERR_LIB_FIPS 45
+#define ERR_LIB_CMS 46
+#define ERR_LIB_TS 47
+#define ERR_LIB_HMAC 48
 /* # define ERR_LIB_JPAKE       49 */
-# define ERR_LIB_CT              50
-# define ERR_LIB_ASYNC           51
-# define ERR_LIB_KDF             52
-# define ERR_LIB_SM2             53
-# define ERR_LIB_ESS             54
-# define ERR_LIB_PROP            55
-# define ERR_LIB_CRMF            56
-# define ERR_LIB_PROV            57
-# define ERR_LIB_CMP             58
-# define ERR_LIB_OSSL_ENCODER    59
-# define ERR_LIB_OSSL_DECODER    60
-# define ERR_LIB_HTTP            61
-
-# define ERR_LIB_USER            128
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define ASN1err(f, r) ERR_raise_data(ERR_LIB_ASN1, (r), NULL)
-#  define ASYNCerr(f, r) ERR_raise_data(ERR_LIB_ASYNC, (r), NULL)
-#  define BIOerr(f, r) ERR_raise_data(ERR_LIB_BIO, (r), NULL)
-#  define BNerr(f, r)  ERR_raise_data(ERR_LIB_BN, (r), NULL)
-#  define BUFerr(f, r) ERR_raise_data(ERR_LIB_BUF, (r), NULL)
-#  define CMPerr(f, r) ERR_raise_data(ERR_LIB_CMP, (r), NULL)
-#  define CMSerr(f, r) ERR_raise_data(ERR_LIB_CMS, (r), NULL)
-#  define COMPerr(f, r) ERR_raise_data(ERR_LIB_COMP, (r), NULL)
-#  define CONFerr(f, r) ERR_raise_data(ERR_LIB_CONF, (r), NULL)
-#  define CRMFerr(f, r) ERR_raise_data(ERR_LIB_CRMF, (r), NULL)
-#  define CRYPTOerr(f, r) ERR_raise_data(ERR_LIB_CRYPTO, (r), NULL)
-#  define CTerr(f, r) ERR_raise_data(ERR_LIB_CT, (r), NULL)
-#  define DHerr(f, r)  ERR_raise_data(ERR_LIB_DH, (r), NULL)
-#  define DSAerr(f, r) ERR_raise_data(ERR_LIB_DSA, (r), NULL)
-#  define DSOerr(f, r) ERR_raise_data(ERR_LIB_DSO, (r), NULL)
-#  define ECDHerr(f, r) ERR_raise_data(ERR_LIB_ECDH, (r), NULL)
-#  define ECDSAerr(f, r) ERR_raise_data(ERR_LIB_ECDSA, (r), NULL)
-#  define ECerr(f, r)  ERR_raise_data(ERR_LIB_EC, (r), NULL)
-#  define ENGINEerr(f, r) ERR_raise_data(ERR_LIB_ENGINE, (r), NULL)
-#  define ESSerr(f, r) ERR_raise_data(ERR_LIB_ESS, (r), NULL)
-#  define EVPerr(f, r) ERR_raise_data(ERR_LIB_EVP, (r), NULL)
-#  define FIPSerr(f, r) ERR_raise_data(ERR_LIB_FIPS, (r), NULL)
-#  define HMACerr(f, r) ERR_raise_data(ERR_LIB_HMAC, (r), NULL)
-#  define HTTPerr(f, r) ERR_raise_data(ERR_LIB_HTTP, (r), NULL)
-#  define KDFerr(f, r) ERR_raise_data(ERR_LIB_KDF, (r), NULL)
-#  define OBJerr(f, r) ERR_raise_data(ERR_LIB_OBJ, (r), NULL)
-#  define OCSPerr(f, r) ERR_raise_data(ERR_LIB_OCSP, (r), NULL)
-#  define OSSL_STOREerr(f, r) ERR_raise_data(ERR_LIB_OSSL_STORE, (r), NULL)
-#  define PEMerr(f, r) ERR_raise_data(ERR_LIB_PEM, (r), NULL)
-#  define PKCS12err(f, r) ERR_raise_data(ERR_LIB_PKCS12, (r), NULL)
-#  define PKCS7err(f, r) ERR_raise_data(ERR_LIB_PKCS7, (r), NULL)
-#  define PROPerr(f, r) ERR_raise_data(ERR_LIB_PROP, (r), NULL)
-#  define PROVerr(f, r) ERR_raise_data(ERR_LIB_PROV, (r), NULL)
-#  define RANDerr(f, r) ERR_raise_data(ERR_LIB_RAND, (r), NULL)
-#  define RSAerr(f, r) ERR_raise_data(ERR_LIB_RSA, (r), NULL)
-#  define KDFerr(f, r) ERR_raise_data(ERR_LIB_KDF, (r), NULL)
-#  define SM2err(f, r) ERR_raise_data(ERR_LIB_SM2, (r), NULL)
-#  define SSLerr(f, r) ERR_raise_data(ERR_LIB_SSL, (r), NULL)
-#  define SYSerr(f, r) ERR_raise_data(ERR_LIB_SYS, (r), NULL)
-#  define TSerr(f, r) ERR_raise_data(ERR_LIB_TS, (r), NULL)
-#  define UIerr(f, r) ERR_raise_data(ERR_LIB_UI, (r), NULL)
-#  define X509V3err(f, r) ERR_raise_data(ERR_LIB_X509V3, (r), NULL)
-#  define X509err(f, r) ERR_raise_data(ERR_LIB_X509, (r), NULL)
-# endif
+#define ERR_LIB_CT 50
+#define ERR_LIB_ASYNC 51
+#define ERR_LIB_KDF 52
+#define ERR_LIB_SM2 53
+#define ERR_LIB_ESS 54
+#define ERR_LIB_PROP 55
+#define ERR_LIB_CRMF 56
+#define ERR_LIB_PROV 57
+#define ERR_LIB_CMP 58
+#define ERR_LIB_OSSL_ENCODER 59
+#define ERR_LIB_OSSL_DECODER 60
+#define ERR_LIB_HTTP 61
+
+#define ERR_LIB_USER 128
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define ASN1err(f, r) ERR_raise_data(ERR_LIB_ASN1, (r), NULL)
+#define ASYNCerr(f, r) ERR_raise_data(ERR_LIB_ASYNC, (r), NULL)
+#define BIOerr(f, r) ERR_raise_data(ERR_LIB_BIO, (r), NULL)
+#define BNerr(f, r) ERR_raise_data(ERR_LIB_BN, (r), NULL)
+#define BUFerr(f, r) ERR_raise_data(ERR_LIB_BUF, (r), NULL)
+#define CMPerr(f, r) ERR_raise_data(ERR_LIB_CMP, (r), NULL)
+#define CMSerr(f, r) ERR_raise_data(ERR_LIB_CMS, (r), NULL)
+#define COMPerr(f, r) ERR_raise_data(ERR_LIB_COMP, (r), NULL)
+#define CONFerr(f, r) ERR_raise_data(ERR_LIB_CONF, (r), NULL)
+#define CRMFerr(f, r) ERR_raise_data(ERR_LIB_CRMF, (r), NULL)
+#define CRYPTOerr(f, r) ERR_raise_data(ERR_LIB_CRYPTO, (r), NULL)
+#define CTerr(f, r) ERR_raise_data(ERR_LIB_CT, (r), NULL)
+#define DHerr(f, r) ERR_raise_data(ERR_LIB_DH, (r), NULL)
+#define DSAerr(f, r) ERR_raise_data(ERR_LIB_DSA, (r), NULL)
+#define DSOerr(f, r) ERR_raise_data(ERR_LIB_DSO, (r), NULL)
+#define ECDHerr(f, r) ERR_raise_data(ERR_LIB_ECDH, (r), NULL)
+#define ECDSAerr(f, r) ERR_raise_data(ERR_LIB_ECDSA, (r), NULL)
+#define ECerr(f, r) ERR_raise_data(ERR_LIB_EC, (r), NULL)
+#define ENGINEerr(f, r) ERR_raise_data(ERR_LIB_ENGINE, (r), NULL)
+#define ESSerr(f, r) ERR_raise_data(ERR_LIB_ESS, (r), NULL)
+#define EVPerr(f, r) ERR_raise_data(ERR_LIB_EVP, (r), NULL)
+#define FIPSerr(f, r) ERR_raise_data(ERR_LIB_FIPS, (r), NULL)
+#define HMACerr(f, r) ERR_raise_data(ERR_LIB_HMAC, (r), NULL)
+#define HTTPerr(f, r) ERR_raise_data(ERR_LIB_HTTP, (r), NULL)
+#define KDFerr(f, r) ERR_raise_data(ERR_LIB_KDF, (r), NULL)
+#define OBJerr(f, r) ERR_raise_data(ERR_LIB_OBJ, (r), NULL)
+#define OCSPerr(f, r) ERR_raise_data(ERR_LIB_OCSP, (r), NULL)
+#define OSSL_STOREerr(f, r) ERR_raise_data(ERR_LIB_OSSL_STORE, (r), NULL)
+#define PEMerr(f, r) ERR_raise_data(ERR_LIB_PEM, (r), NULL)
+#define PKCS12err(f, r) ERR_raise_data(ERR_LIB_PKCS12, (r), NULL)
+#define PKCS7err(f, r) ERR_raise_data(ERR_LIB_PKCS7, (r), NULL)
+#define PROPerr(f, r) ERR_raise_data(ERR_LIB_PROP, (r), NULL)
+#define PROVerr(f, r) ERR_raise_data(ERR_LIB_PROV, (r), NULL)
+#define RANDerr(f, r) ERR_raise_data(ERR_LIB_RAND, (r), NULL)
+#define RSAerr(f, r) ERR_raise_data(ERR_LIB_RSA, (r), NULL)
+#define KDFerr(f, r) ERR_raise_data(ERR_LIB_KDF, (r), NULL)
+#define SM2err(f, r) ERR_raise_data(ERR_LIB_SM2, (r), NULL)
+#define SSLerr(f, r) ERR_raise_data(ERR_LIB_SSL, (r), NULL)
+#define SYSerr(f, r) ERR_raise_data(ERR_LIB_SYS, (r), NULL)
+#define TSerr(f, r) ERR_raise_data(ERR_LIB_TS, (r), NULL)
+#define UIerr(f, r) ERR_raise_data(ERR_LIB_UI, (r), NULL)
+#define X509V3err(f, r) ERR_raise_data(ERR_LIB_X509V3, (r), NULL)
+#define X509err(f, r) ERR_raise_data(ERR_LIB_X509, (r), NULL)
+#endif
 
 /*-
  * The error code packs differently depending on if it records a system
@@ -215,59 +215,59 @@ struct err_state_st {
  */
 
 /* Macros to help decode recorded system errors */
-# define ERR_SYSTEM_FLAG                ((unsigned int)INT_MAX + 1)
-# define ERR_SYSTEM_MASK                ((unsigned int)INT_MAX)
+#define ERR_SYSTEM_FLAG ((unsigned int)INT_MAX + 1)
+#define ERR_SYSTEM_MASK ((unsigned int)INT_MAX)
 
 /*
  * Macros to help decode recorded OpenSSL errors
  * As expressed above, RFLAGS and REASON overlap by one bit to allow
  * ERR_R_FATAL to use ERR_RFLAG_FATAL as its reason code.
  */
-# define ERR_LIB_OFFSET                 23L
-# define ERR_LIB_MASK                   0xFF
-# define ERR_RFLAGS_OFFSET              18L
-# define ERR_RFLAGS_MASK                0x1F
-# define ERR_REASON_MASK                0X7FFFFF
+#define ERR_LIB_OFFSET 23L
+#define ERR_LIB_MASK 0xFF
+#define ERR_RFLAGS_OFFSET 18L
+#define ERR_RFLAGS_MASK 0x1F
+#define ERR_REASON_MASK 0X7FFFFF
 
 /*
  * Reason flags are defined pre-shifted to easily combine with the reason
  * number.
  */
-# define ERR_RFLAG_FATAL                (0x1 << ERR_RFLAGS_OFFSET)
-# define ERR_RFLAG_COMMON               (0x2 << ERR_RFLAGS_OFFSET)
-
-# define ERR_SYSTEM_ERROR(errcode)      (((errcode) & ERR_SYSTEM_FLAG) != 0)
-
-static ossl_unused ossl_inline int ERR_GET_LIB(unsigned long errcode)
-{
-    if (ERR_SYSTEM_ERROR(errcode))
-        return ERR_LIB_SYS;
-    return (errcode >> ERR_LIB_OFFSET) & ERR_LIB_MASK;
-}
-
-static ossl_unused ossl_inline int ERR_GET_RFLAGS(unsigned long errcode)
-{
-    if (ERR_SYSTEM_ERROR(errcode))
-        return 0;
-    return errcode & (ERR_RFLAGS_MASK << ERR_RFLAGS_OFFSET);
-}
-
-static ossl_unused ossl_inline int ERR_GET_REASON(unsigned long errcode)
-{
-    if (ERR_SYSTEM_ERROR(errcode))
-        return errcode & ERR_SYSTEM_MASK;
-    return errcode & ERR_REASON_MASK;
-}
-
-static ossl_unused ossl_inline int ERR_FATAL_ERROR(unsigned long errcode)
-{
-    return (ERR_GET_RFLAGS(errcode) & ERR_RFLAG_FATAL) != 0;
-}
-
-static ossl_unused ossl_inline int ERR_COMMON_ERROR(unsigned long errcode)
-{
-    return (ERR_GET_RFLAGS(errcode) & ERR_RFLAG_COMMON) != 0;
-}
+#define ERR_RFLAG_FATAL (0x1 << ERR_RFLAGS_OFFSET)
+#define ERR_RFLAG_COMMON (0x2 << ERR_RFLAGS_OFFSET)
+
+#define ERR_SYSTEM_ERROR(errcode) (((errcode)&ERR_SYSTEM_FLAG) != 0)
+
+    static ossl_unused ossl_inline int ERR_GET_LIB(unsigned long errcode)
+    {
+        if (ERR_SYSTEM_ERROR(errcode))
+            return ERR_LIB_SYS;
+        return (errcode >> ERR_LIB_OFFSET) & ERR_LIB_MASK;
+    }
+
+    static ossl_unused ossl_inline int ERR_GET_RFLAGS(unsigned long errcode)
+    {
+        if (ERR_SYSTEM_ERROR(errcode))
+            return 0;
+        return errcode & (ERR_RFLAGS_MASK << ERR_RFLAGS_OFFSET);
+    }
+
+    static ossl_unused ossl_inline int ERR_GET_REASON(unsigned long errcode)
+    {
+        if (ERR_SYSTEM_ERROR(errcode))
+            return errcode & ERR_SYSTEM_MASK;
+        return errcode & ERR_REASON_MASK;
+    }
+
+    static ossl_unused ossl_inline int ERR_FATAL_ERROR(unsigned long errcode)
+    {
+        return (ERR_GET_RFLAGS(errcode) & ERR_RFLAG_FATAL) != 0;
+    }
+
+    static ossl_unused ossl_inline int ERR_COMMON_ERROR(unsigned long errcode)
+    {
+        return (ERR_GET_RFLAGS(errcode) & ERR_RFLAG_COMMON) != 0;
+    }
 
 /*
  * ERR_PACK is a helper macro to properly pack OpenSSL error codes and may
@@ -275,97 +275,98 @@ static ossl_unused ossl_inline int ERR_COMMON_ERROR(unsigned long errcode)
  * ERR_PACK takes reason flags and reason code combined in |reason|.
  * ERR_PACK ignores |func|, that parameter is just legacy from pre-3.0 OpenSSL.
  */
-# define ERR_PACK(lib,func,reason)                                      \
-    ( (((unsigned long)(lib)    & ERR_LIB_MASK   ) << ERR_LIB_OFFSET) | \
-      (((unsigned long)(reason) & ERR_REASON_MASK)) )
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SYS_F_FOPEN             0
-#  define SYS_F_CONNECT           0
-#  define SYS_F_GETSERVBYNAME     0
-#  define SYS_F_SOCKET            0
-#  define SYS_F_IOCTLSOCKET       0
-#  define SYS_F_BIND              0
-#  define SYS_F_LISTEN            0
-#  define SYS_F_ACCEPT            0
-#  define SYS_F_WSASTARTUP        0
-#  define SYS_F_OPENDIR           0
-#  define SYS_F_FREAD             0
-#  define SYS_F_GETADDRINFO       0
-#  define SYS_F_GETNAMEINFO       0
-#  define SYS_F_SETSOCKOPT        0
-#  define SYS_F_GETSOCKOPT        0
-#  define SYS_F_GETSOCKNAME       0
-#  define SYS_F_GETHOSTBYNAME     0
-#  define SYS_F_FFLUSH            0
-#  define SYS_F_OPEN              0
-#  define SYS_F_CLOSE             0
-#  define SYS_F_IOCTL             0
-#  define SYS_F_STAT              0
-#  define SYS_F_FCNTL             0
-#  define SYS_F_FSTAT             0
-#  define SYS_F_SENDFILE          0
-# endif
+#define ERR_PACK(lib, func, reason)                            \
+    ((((unsigned long)(lib)&ERR_LIB_MASK) << ERR_LIB_OFFSET) | \
+     (((unsigned long)(reason)&ERR_REASON_MASK)))
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SYS_F_FOPEN 0
+#define SYS_F_CONNECT 0
+#define SYS_F_GETSERVBYNAME 0
+#define SYS_F_SOCKET 0
+#define SYS_F_IOCTLSOCKET 0
+#define SYS_F_BIND 0
+#define SYS_F_LISTEN 0
+#define SYS_F_ACCEPT 0
+#define SYS_F_WSASTARTUP 0
+#define SYS_F_OPENDIR 0
+#define SYS_F_FREAD 0
+#define SYS_F_GETADDRINFO 0
+#define SYS_F_GETNAMEINFO 0
+#define SYS_F_SETSOCKOPT 0
+#define SYS_F_GETSOCKOPT 0
+#define SYS_F_GETSOCKNAME 0
+#define SYS_F_GETHOSTBYNAME 0
+#define SYS_F_FFLUSH 0
+#define SYS_F_OPEN 0
+#define SYS_F_CLOSE 0
+#define SYS_F_IOCTL 0
+#define SYS_F_STAT 0
+#define SYS_F_FCNTL 0
+#define SYS_F_FSTAT 0
+#define SYS_F_SENDFILE 0
+#endif
 
 /*
  * All ERR_R_ codes must be combined with ERR_RFLAG_COMMON.
  */
 
 /* "we came from here" global reason codes, range 1..255 */
-# define ERR_R_SYS_LIB          (ERR_LIB_SYS/* 2 */ | ERR_RFLAG_COMMON)
-# define ERR_R_BN_LIB           (ERR_LIB_BN/* 3 */ | ERR_RFLAG_COMMON)
-# define ERR_R_RSA_LIB          (ERR_LIB_RSA/* 4 */ | ERR_RFLAG_COMMON)
-# define ERR_R_DH_LIB           (ERR_LIB_DH/* 5 */ | ERR_RFLAG_COMMON)
-# define ERR_R_EVP_LIB          (ERR_LIB_EVP/* 6 */ | ERR_RFLAG_COMMON)
-# define ERR_R_BUF_LIB          (ERR_LIB_BUF/* 7 */ | ERR_RFLAG_COMMON)
-# define ERR_R_OBJ_LIB          (ERR_LIB_OBJ/* 8 */ | ERR_RFLAG_COMMON)
-# define ERR_R_PEM_LIB          (ERR_LIB_PEM/* 9 */ | ERR_RFLAG_COMMON)
-# define ERR_R_DSA_LIB          (ERR_LIB_DSA/* 10 */ | ERR_RFLAG_COMMON)
-# define ERR_R_X509_LIB         (ERR_LIB_X509/* 11 */ | ERR_RFLAG_COMMON)
-# define ERR_R_ASN1_LIB         (ERR_LIB_ASN1/* 13 */ | ERR_RFLAG_COMMON)
-# define ERR_R_CRYPTO_LIB       (ERR_LIB_CRYPTO/* 15 */ | ERR_RFLAG_COMMON)
-# define ERR_R_EC_LIB           (ERR_LIB_EC/* 16 */ | ERR_RFLAG_COMMON)
-# define ERR_R_BIO_LIB          (ERR_LIB_BIO/* 32 */ | ERR_RFLAG_COMMON)
-# define ERR_R_PKCS7_LIB        (ERR_LIB_PKCS7/* 33 */ | ERR_RFLAG_COMMON)
-# define ERR_R_X509V3_LIB       (ERR_LIB_X509V3/* 34 */ | ERR_RFLAG_COMMON)
-# define ERR_R_ENGINE_LIB       (ERR_LIB_ENGINE/* 38 */ | ERR_RFLAG_COMMON)
-# define ERR_R_UI_LIB           (ERR_LIB_UI/* 40 */ | ERR_RFLAG_COMMON)
-# define ERR_R_ECDSA_LIB        (ERR_LIB_ECDSA/* 42 */ | ERR_RFLAG_COMMON)
-# define ERR_R_OSSL_STORE_LIB   (ERR_LIB_OSSL_STORE/* 44 */ | ERR_RFLAG_COMMON)
-# define ERR_R_OSSL_DECODER_LIB (ERR_LIB_OSSL_DECODER/* 60 */ | ERR_RFLAG_COMMON)
+#define ERR_R_SYS_LIB (ERR_LIB_SYS /* 2 */ | ERR_RFLAG_COMMON)
+#define ERR_R_BN_LIB (ERR_LIB_BN /* 3 */ | ERR_RFLAG_COMMON)
+#define ERR_R_RSA_LIB (ERR_LIB_RSA /* 4 */ | ERR_RFLAG_COMMON)
+#define ERR_R_DH_LIB (ERR_LIB_DH /* 5 */ | ERR_RFLAG_COMMON)
+#define ERR_R_EVP_LIB (ERR_LIB_EVP /* 6 */ | ERR_RFLAG_COMMON)
+#define ERR_R_BUF_LIB (ERR_LIB_BUF /* 7 */ | ERR_RFLAG_COMMON)
+#define ERR_R_OBJ_LIB (ERR_LIB_OBJ /* 8 */ | ERR_RFLAG_COMMON)
+#define ERR_R_PEM_LIB (ERR_LIB_PEM /* 9 */ | ERR_RFLAG_COMMON)
+#define ERR_R_DSA_LIB (ERR_LIB_DSA /* 10 */ | ERR_RFLAG_COMMON)
+#define ERR_R_X509_LIB (ERR_LIB_X509 /* 11 */ | ERR_RFLAG_COMMON)
+#define ERR_R_ASN1_LIB (ERR_LIB_ASN1 /* 13 */ | ERR_RFLAG_COMMON)
+#define ERR_R_CRYPTO_LIB (ERR_LIB_CRYPTO /* 15 */ | ERR_RFLAG_COMMON)
+#define ERR_R_EC_LIB (ERR_LIB_EC /* 16 */ | ERR_RFLAG_COMMON)
+#define ERR_R_BIO_LIB (ERR_LIB_BIO /* 32 */ | ERR_RFLAG_COMMON)
+#define ERR_R_PKCS7_LIB (ERR_LIB_PKCS7 /* 33 */ | ERR_RFLAG_COMMON)
+#define ERR_R_X509V3_LIB (ERR_LIB_X509V3 /* 34 */ | ERR_RFLAG_COMMON)
+#define ERR_R_ENGINE_LIB (ERR_LIB_ENGINE /* 38 */ | ERR_RFLAG_COMMON)
+#define ERR_R_UI_LIB (ERR_LIB_UI /* 40 */ | ERR_RFLAG_COMMON)
+#define ERR_R_ECDSA_LIB (ERR_LIB_ECDSA /* 42 */ | ERR_RFLAG_COMMON)
+#define ERR_R_OSSL_STORE_LIB (ERR_LIB_OSSL_STORE /* 44 */ | ERR_RFLAG_COMMON)
+#define ERR_R_OSSL_DECODER_LIB (ERR_LIB_OSSL_DECODER /* 60 */ | ERR_RFLAG_COMMON)
 
 /* Other common error codes, range 256..2^ERR_RFLAGS_OFFSET-1 */
-# define ERR_R_FATAL                             (ERR_RFLAG_FATAL|ERR_RFLAG_COMMON)
-# define ERR_R_MALLOC_FAILURE                    (256|ERR_R_FATAL)
-# define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED       (257|ERR_R_FATAL)
-# define ERR_R_PASSED_NULL_PARAMETER             (258|ERR_R_FATAL)
-# define ERR_R_INTERNAL_ERROR                    (259|ERR_R_FATAL)
-# define ERR_R_DISABLED                          (260|ERR_R_FATAL)
-# define ERR_R_INIT_FAIL                         (261|ERR_R_FATAL)
-# define ERR_R_PASSED_INVALID_ARGUMENT           (262|ERR_RFLAG_COMMON)
-# define ERR_R_OPERATION_FAIL                    (263|ERR_R_FATAL)
-# define ERR_R_INVALID_PROVIDER_FUNCTIONS        (264|ERR_R_FATAL)
-# define ERR_R_INTERRUPTED_OR_CANCELLED          (265|ERR_RFLAG_COMMON)
-# define ERR_R_NESTED_ASN1_ERROR                 (266|ERR_RFLAG_COMMON)
-# define ERR_R_MISSING_ASN1_EOS                  (267|ERR_RFLAG_COMMON)
-# define ERR_R_UNSUPPORTED                       (268|ERR_RFLAG_COMMON)
-# define ERR_R_FETCH_FAILED                      (269|ERR_RFLAG_COMMON)
-# define ERR_R_INVALID_PROPERTY_DEFINITION       (270|ERR_RFLAG_COMMON)
-# define ERR_R_UNABLE_TO_GET_READ_LOCK           (271|ERR_R_FATAL)
-# define ERR_R_UNABLE_TO_GET_WRITE_LOCK          (272|ERR_R_FATAL)
-
-typedef struct ERR_string_data_st {
-    unsigned long error;
-    const char *string;
-} ERR_STRING_DATA;
-
-DEFINE_LHASH_OF_INTERNAL(ERR_STRING_DATA);
-#define lh_ERR_STRING_DATA_new(hfn, cmp) ((LHASH_OF(ERR_STRING_DATA) *)OPENSSL_LH_new(ossl_check_ERR_STRING_DATA_lh_hashfunc_type(hfn), ossl_check_ERR_STRING_DATA_lh_compfunc_type(cmp)))
+#define ERR_R_FATAL (ERR_RFLAG_FATAL | ERR_RFLAG_COMMON)
+#define ERR_R_MALLOC_FAILURE (256 | ERR_R_FATAL)
+#define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED (257 | ERR_R_FATAL)
+#define ERR_R_PASSED_NULL_PARAMETER (258 | ERR_R_FATAL)
+#define ERR_R_INTERNAL_ERROR (259 | ERR_R_FATAL)
+#define ERR_R_DISABLED (260 | ERR_R_FATAL)
+#define ERR_R_INIT_FAIL (261 | ERR_R_FATAL)
+#define ERR_R_PASSED_INVALID_ARGUMENT (262 | ERR_RFLAG_COMMON)
+#define ERR_R_OPERATION_FAIL (263 | ERR_R_FATAL)
+#define ERR_R_INVALID_PROVIDER_FUNCTIONS (264 | ERR_R_FATAL)
+#define ERR_R_INTERRUPTED_OR_CANCELLED (265 | ERR_RFLAG_COMMON)
+#define ERR_R_NESTED_ASN1_ERROR (266 | ERR_RFLAG_COMMON)
+#define ERR_R_MISSING_ASN1_EOS (267 | ERR_RFLAG_COMMON)
+#define ERR_R_UNSUPPORTED (268 | ERR_RFLAG_COMMON)
+#define ERR_R_FETCH_FAILED (269 | ERR_RFLAG_COMMON)
+#define ERR_R_INVALID_PROPERTY_DEFINITION (270 | ERR_RFLAG_COMMON)
+#define ERR_R_UNABLE_TO_GET_READ_LOCK (271 | ERR_R_FATAL)
+#define ERR_R_UNABLE_TO_GET_WRITE_LOCK (272 | ERR_R_FATAL)
+
+    typedef struct ERR_string_data_st
+    {
+        unsigned long error;
+        const char* string;
+    } ERR_STRING_DATA;
+
+    DEFINE_LHASH_OF_INTERNAL(ERR_STRING_DATA);
+#define lh_ERR_STRING_DATA_new(hfn, cmp) ((LHASH_OF(ERR_STRING_DATA)*)OPENSSL_LH_new(ossl_check_ERR_STRING_DATA_lh_hashfunc_type(hfn), ossl_check_ERR_STRING_DATA_lh_compfunc_type(cmp)))
 #define lh_ERR_STRING_DATA_free(lh) OPENSSL_LH_free(ossl_check_ERR_STRING_DATA_lh_type(lh))
 #define lh_ERR_STRING_DATA_flush(lh) OPENSSL_LH_flush(ossl_check_ERR_STRING_DATA_lh_type(lh))
-#define lh_ERR_STRING_DATA_insert(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_insert(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_ERR_STRING_DATA_lh_plain_type(ptr)))
-#define lh_ERR_STRING_DATA_delete(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_delete(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_const_ERR_STRING_DATA_lh_plain_type(ptr)))
-#define lh_ERR_STRING_DATA_retrieve(lh, ptr) ((ERR_STRING_DATA *)OPENSSL_LH_retrieve(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_const_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_insert(lh, ptr) ((ERR_STRING_DATA*)OPENSSL_LH_insert(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_delete(lh, ptr) ((ERR_STRING_DATA*)OPENSSL_LH_delete(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_const_ERR_STRING_DATA_lh_plain_type(ptr)))
+#define lh_ERR_STRING_DATA_retrieve(lh, ptr) ((ERR_STRING_DATA*)OPENSSL_LH_retrieve(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_const_ERR_STRING_DATA_lh_plain_type(ptr)))
 #define lh_ERR_STRING_DATA_error(lh) OPENSSL_LH_error(ossl_check_ERR_STRING_DATA_lh_type(lh))
 #define lh_ERR_STRING_DATA_num_items(lh) OPENSSL_LH_num_items(ossl_check_ERR_STRING_DATA_lh_type(lh))
 #define lh_ERR_STRING_DATA_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_ERR_STRING_DATA_lh_type(lh), out)
@@ -375,117 +376,108 @@ DEFINE_LHASH_OF_INTERNAL(ERR_STRING_DATA);
 #define lh_ERR_STRING_DATA_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_ERR_STRING_DATA_lh_type(lh), dl)
 #define lh_ERR_STRING_DATA_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_ERR_STRING_DATA_lh_type(lh), ossl_check_ERR_STRING_DATA_lh_doallfunc_type(dfn))
 
-
 /* 12 lines and some on an 80 column terminal */
-#define ERR_MAX_DATA_SIZE       1024
+#define ERR_MAX_DATA_SIZE 1024
 
-/* Building blocks */
-void ERR_new(void);
-void ERR_set_debug(const char *file, int line, const char *func);
-void ERR_set_error(int lib, int reason, const char *fmt, ...);
-void ERR_vset_error(int lib, int reason, const char *fmt, va_list args);
+    /* Building blocks */
+    void ERR_new(void);
+    void ERR_set_debug(const char* file, int line, const char* func);
+    void ERR_set_error(int lib, int reason, const char* fmt, ...);
+    void ERR_vset_error(int lib, int reason, const char* fmt, va_list args);
 
 /* Main error raising functions */
-# define ERR_raise(lib, reason) ERR_raise_data((lib),(reason),NULL)
-# define ERR_raise_data                                         \
-    (ERR_new(),                                                 \
-     ERR_set_debug(OPENSSL_FILE,OPENSSL_LINE,OPENSSL_FUNC),     \
+#define ERR_raise(lib, reason) ERR_raise_data((lib), (reason), NULL)
+#define ERR_raise_data                                        \
+    (ERR_new(),                                               \
+     ERR_set_debug(OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC), \
      ERR_set_error)
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 /* Backward compatibility */
-#  define ERR_put_error(lib, func, reason, file, line)          \
-    (ERR_new(),                                                 \
-     ERR_set_debug((file), (line), OPENSSL_FUNC),               \
+#define ERR_put_error(lib, func, reason, file, line) \
+    (ERR_new(),                                      \
+     ERR_set_debug((file), (line), OPENSSL_FUNC),    \
      ERR_set_error((lib), (reason), NULL))
-# endif
-
-void ERR_set_error_data(char *data, int flags);
-
-unsigned long ERR_get_error(void);
-unsigned long ERR_get_error_all(const char **file, int *line,
-                                const char **func,
-                                const char **data, int *flags);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-unsigned long ERR_get_error_line(const char **file, int *line);
-OSSL_DEPRECATEDIN_3_0
-unsigned long ERR_get_error_line_data(const char **file, int *line,
-                                      const char **data, int *flags);
 #endif
-unsigned long ERR_peek_error(void);
-unsigned long ERR_peek_error_line(const char **file, int *line);
-unsigned long ERR_peek_error_func(const char **func);
-unsigned long ERR_peek_error_data(const char **data, int *flags);
-unsigned long ERR_peek_error_all(const char **file, int *line,
-                                 const char **func,
-                                 const char **data, int *flags);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-unsigned long ERR_peek_error_line_data(const char **file, int *line,
-                                       const char **data, int *flags);
-# endif
-unsigned long ERR_peek_last_error(void);
-unsigned long ERR_peek_last_error_line(const char **file, int *line);
-unsigned long ERR_peek_last_error_func(const char **func);
-unsigned long ERR_peek_last_error_data(const char **data, int *flags);
-unsigned long ERR_peek_last_error_all(const char **file, int *line,
-                                      const char **func,
-                                      const char **data, int *flags);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-unsigned long ERR_peek_last_error_line_data(const char **file, int *line,
-                                            const char **data, int *flags);
-# endif
-
-void ERR_clear_error(void);
-
-char *ERR_error_string(unsigned long e, char *buf);
-void ERR_error_string_n(unsigned long e, char *buf, size_t len);
-const char *ERR_lib_error_string(unsigned long e);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 const char *ERR_func_error_string(unsigned long e);
-# endif
-const char *ERR_reason_error_string(unsigned long e);
-
-void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u),
-                         void *u);
-# ifndef OPENSSL_NO_STDIO
-void ERR_print_errors_fp(FILE *fp);
-# endif
-void ERR_print_errors(BIO *bp);
-
-void ERR_add_error_data(int num, ...);
-void ERR_add_error_vdata(int num, va_list args);
-void ERR_add_error_txt(const char *sepr, const char *txt);
-void ERR_add_error_mem_bio(const char *sep, BIO *bio);
-
-int ERR_load_strings(int lib, ERR_STRING_DATA *str);
-int ERR_load_strings_const(const ERR_STRING_DATA *str);
-int ERR_unload_strings(int lib, ERR_STRING_DATA *str);
+
+    void ERR_set_error_data(char* data, int flags);
+
+    unsigned long ERR_get_error(void);
+    unsigned long ERR_get_error_all(const char** file, int* line, const char** func, const char** data, int* flags);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    unsigned long ERR_get_error_line(const char** file, int* line);
+    OSSL_DEPRECATEDIN_3_0
+    unsigned long ERR_get_error_line_data(const char** file, int* line, const char** data, int* flags);
+#endif
+    unsigned long ERR_peek_error(void);
+    unsigned long ERR_peek_error_line(const char** file, int* line);
+    unsigned long ERR_peek_error_func(const char** func);
+    unsigned long ERR_peek_error_data(const char** data, int* flags);
+    unsigned long ERR_peek_error_all(const char** file, int* line, const char** func, const char** data, int* flags);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    unsigned long ERR_peek_error_line_data(const char** file, int* line, const char** data, int* flags);
+#endif
+    unsigned long ERR_peek_last_error(void);
+    unsigned long ERR_peek_last_error_line(const char** file, int* line);
+    unsigned long ERR_peek_last_error_func(const char** func);
+    unsigned long ERR_peek_last_error_data(const char** data, int* flags);
+    unsigned long ERR_peek_last_error_all(const char** file, int* line, const char** func, const char** data, int* flags);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    unsigned long ERR_peek_last_error_line_data(const char** file, int* line, const char** data, int* flags);
+#endif
+
+    void ERR_clear_error(void);
+
+    char* ERR_error_string(unsigned long e, char* buf);
+    void ERR_error_string_n(unsigned long e, char* buf, size_t len);
+    const char* ERR_lib_error_string(unsigned long e);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 const char* ERR_func_error_string(unsigned long e);
+#endif
+    const char* ERR_reason_error_string(unsigned long e);
+
+    void ERR_print_errors_cb(int (*cb)(const char* str, size_t len, void* u), void* u);
+#ifndef OPENSSL_NO_STDIO
+    void ERR_print_errors_fp(FILE* fp);
+#endif
+    void ERR_print_errors(BIO* bp);
+
+    void ERR_add_error_data(int num, ...);
+    void ERR_add_error_vdata(int num, va_list args);
+    void ERR_add_error_txt(const char* sepr, const char* txt);
+    void ERR_add_error_mem_bio(const char* sep, BIO* bio);
+
+    int ERR_load_strings(int lib, ERR_STRING_DATA* str);
+    int ERR_load_strings_const(const ERR_STRING_DATA* str);
+    int ERR_unload_strings(int lib, ERR_STRING_DATA* str);
 
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-# define ERR_load_crypto_strings() \
+#define ERR_load_crypto_strings() \
     OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
-# define ERR_free_strings() while(0) continue
+#define ERR_free_strings() \
+    while (0)              \
+    continue
 #endif
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 void ERR_remove_thread_state(void *);
+    OSSL_DEPRECATEDIN_1_1_0 void ERR_remove_thread_state(void*);
 #endif
 #ifndef OPENSSL_NO_DEPRECATED_1_0_0
-OSSL_DEPRECATEDIN_1_0_0 void ERR_remove_state(unsigned long pid);
+    OSSL_DEPRECATEDIN_1_0_0 void ERR_remove_state(unsigned long pid);
 #endif
 #ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 ERR_STATE *ERR_get_state(void);
+    OSSL_DEPRECATEDIN_3_0 ERR_STATE* ERR_get_state(void);
 #endif
 
-int ERR_get_next_error_library(void);
+    int ERR_get_next_error_library(void);
 
-int ERR_set_mark(void);
-int ERR_pop_to_mark(void);
-int ERR_clear_last_mark(void);
+    int ERR_set_mark(void);
+    int ERR_pop_to_mark(void);
+    int ERR_clear_last_mark(void);
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/CAPI/cpp/grpc/include/openssl/ess.h b/CAPI/cpp/grpc/include/openssl/ess.h
index dad596a..25f09fb 100644
--- a/CAPI/cpp/grpc/include/openssl/ess.h
+++ b/CAPI/cpp/grpc/include/openssl/ess.h
@@ -10,119 +10,105 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_ESS_H
-# define OPENSSL_ESS_H
-# pragma once
+#define OPENSSL_ESS_H
+#pragma once
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# include <openssl/safestack.h>
-# include <openssl/x509.h>
-# include <openssl/esserr.h>
-
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#include <openssl/safestack.h>
+#include <openssl/x509.h>
+#include <openssl/esserr.h>
 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-typedef struct ESS_issuer_serial ESS_ISSUER_SERIAL;
-typedef struct ESS_cert_id ESS_CERT_ID;
-typedef struct ESS_signing_cert ESS_SIGNING_CERT;
+    typedef struct ESS_issuer_serial ESS_ISSUER_SERIAL;
+    typedef struct ESS_cert_id ESS_CERT_ID;
+    typedef struct ESS_signing_cert ESS_SIGNING_CERT;
 
-SKM_DEFINE_STACK_OF_INTERNAL(ESS_CERT_ID, ESS_CERT_ID, ESS_CERT_ID)
+    SKM_DEFINE_STACK_OF_INTERNAL(ESS_CERT_ID, ESS_CERT_ID, ESS_CERT_ID)
 #define sk_ESS_CERT_ID_num(sk) OPENSSL_sk_num(ossl_check_const_ESS_CERT_ID_sk_type(sk))
-#define sk_ESS_CERT_ID_value(sk, idx) ((ESS_CERT_ID *)OPENSSL_sk_value(ossl_check_const_ESS_CERT_ID_sk_type(sk), (idx)))
-#define sk_ESS_CERT_ID_new(cmp) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new(ossl_check_ESS_CERT_ID_compfunc_type(cmp)))
-#define sk_ESS_CERT_ID_new_null() ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new_null())
-#define sk_ESS_CERT_ID_new_reserve(cmp, n) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_new_reserve(ossl_check_ESS_CERT_ID_compfunc_type(cmp), (n)))
+#define sk_ESS_CERT_ID_value(sk, idx) ((ESS_CERT_ID*)OPENSSL_sk_value(ossl_check_const_ESS_CERT_ID_sk_type(sk), (idx)))
+#define sk_ESS_CERT_ID_new(cmp) ((STACK_OF(ESS_CERT_ID)*)OPENSSL_sk_new(ossl_check_ESS_CERT_ID_compfunc_type(cmp)))
+#define sk_ESS_CERT_ID_new_null() ((STACK_OF(ESS_CERT_ID)*)OPENSSL_sk_new_null())
+#define sk_ESS_CERT_ID_new_reserve(cmp, n) ((STACK_OF(ESS_CERT_ID)*)OPENSSL_sk_new_reserve(ossl_check_ESS_CERT_ID_compfunc_type(cmp), (n)))
 #define sk_ESS_CERT_ID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ESS_CERT_ID_sk_type(sk), (n))
 #define sk_ESS_CERT_ID_free(sk) OPENSSL_sk_free(ossl_check_ESS_CERT_ID_sk_type(sk))
 #define sk_ESS_CERT_ID_zero(sk) OPENSSL_sk_zero(ossl_check_ESS_CERT_ID_sk_type(sk))
-#define sk_ESS_CERT_ID_delete(sk, i) ((ESS_CERT_ID *)OPENSSL_sk_delete(ossl_check_ESS_CERT_ID_sk_type(sk), (i)))
-#define sk_ESS_CERT_ID_delete_ptr(sk, ptr) ((ESS_CERT_ID *)OPENSSL_sk_delete_ptr(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr)))
+#define sk_ESS_CERT_ID_delete(sk, i) ((ESS_CERT_ID*)OPENSSL_sk_delete(ossl_check_ESS_CERT_ID_sk_type(sk), (i)))
+#define sk_ESS_CERT_ID_delete_ptr(sk, ptr) ((ESS_CERT_ID*)OPENSSL_sk_delete_ptr(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr)))
 #define sk_ESS_CERT_ID_push(sk, ptr) OPENSSL_sk_push(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
 #define sk_ESS_CERT_ID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
-#define sk_ESS_CERT_ID_pop(sk) ((ESS_CERT_ID *)OPENSSL_sk_pop(ossl_check_ESS_CERT_ID_sk_type(sk)))
-#define sk_ESS_CERT_ID_shift(sk) ((ESS_CERT_ID *)OPENSSL_sk_shift(ossl_check_ESS_CERT_ID_sk_type(sk)))
-#define sk_ESS_CERT_ID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ESS_CERT_ID_sk_type(sk),ossl_check_ESS_CERT_ID_freefunc_type(freefunc))
+#define sk_ESS_CERT_ID_pop(sk) ((ESS_CERT_ID*)OPENSSL_sk_pop(ossl_check_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_shift(sk) ((ESS_CERT_ID*)OPENSSL_sk_shift(ossl_check_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_freefunc_type(freefunc))
 #define sk_ESS_CERT_ID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr), (idx))
-#define sk_ESS_CERT_ID_set(sk, idx, ptr) ((ESS_CERT_ID *)OPENSSL_sk_set(ossl_check_ESS_CERT_ID_sk_type(sk), (idx), ossl_check_ESS_CERT_ID_type(ptr)))
+#define sk_ESS_CERT_ID_set(sk, idx, ptr) ((ESS_CERT_ID*)OPENSSL_sk_set(ossl_check_ESS_CERT_ID_sk_type(sk), (idx), ossl_check_ESS_CERT_ID_type(ptr)))
 #define sk_ESS_CERT_ID_find(sk, ptr) OPENSSL_sk_find(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
 #define sk_ESS_CERT_ID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr))
 #define sk_ESS_CERT_ID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_type(ptr), pnum)
 #define sk_ESS_CERT_ID_sort(sk) OPENSSL_sk_sort(ossl_check_ESS_CERT_ID_sk_type(sk))
 #define sk_ESS_CERT_ID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ESS_CERT_ID_sk_type(sk))
-#define sk_ESS_CERT_ID_dup(sk) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_dup(ossl_check_const_ESS_CERT_ID_sk_type(sk)))
-#define sk_ESS_CERT_ID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ESS_CERT_ID) *)OPENSSL_sk_deep_copy(ossl_check_const_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_copyfunc_type(copyfunc), ossl_check_ESS_CERT_ID_freefunc_type(freefunc)))
+#define sk_ESS_CERT_ID_dup(sk) ((STACK_OF(ESS_CERT_ID)*)OPENSSL_sk_dup(ossl_check_const_ESS_CERT_ID_sk_type(sk)))
+#define sk_ESS_CERT_ID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ESS_CERT_ID)*)OPENSSL_sk_deep_copy(ossl_check_const_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_copyfunc_type(copyfunc), ossl_check_ESS_CERT_ID_freefunc_type(freefunc)))
 #define sk_ESS_CERT_ID_set_cmp_func(sk, cmp) ((sk_ESS_CERT_ID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ESS_CERT_ID_sk_type(sk), ossl_check_ESS_CERT_ID_compfunc_type(cmp)))
 
+    typedef struct ESS_signing_cert_v2_st ESS_SIGNING_CERT_V2;
+    typedef struct ESS_cert_id_v2_st ESS_CERT_ID_V2;
 
-
-typedef struct ESS_signing_cert_v2_st ESS_SIGNING_CERT_V2;
-typedef struct ESS_cert_id_v2_st ESS_CERT_ID_V2;
-
-SKM_DEFINE_STACK_OF_INTERNAL(ESS_CERT_ID_V2, ESS_CERT_ID_V2, ESS_CERT_ID_V2)
+    SKM_DEFINE_STACK_OF_INTERNAL(ESS_CERT_ID_V2, ESS_CERT_ID_V2, ESS_CERT_ID_V2)
 #define sk_ESS_CERT_ID_V2_num(sk) OPENSSL_sk_num(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk))
-#define sk_ESS_CERT_ID_V2_value(sk, idx) ((ESS_CERT_ID_V2 *)OPENSSL_sk_value(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk), (idx)))
-#define sk_ESS_CERT_ID_V2_new(cmp) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new(ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp)))
-#define sk_ESS_CERT_ID_V2_new_null() ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new_null())
-#define sk_ESS_CERT_ID_V2_new_reserve(cmp, n) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_new_reserve(ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp), (n)))
+#define sk_ESS_CERT_ID_V2_value(sk, idx) ((ESS_CERT_ID_V2*)OPENSSL_sk_value(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk), (idx)))
+#define sk_ESS_CERT_ID_V2_new(cmp) ((STACK_OF(ESS_CERT_ID_V2)*)OPENSSL_sk_new(ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp)))
+#define sk_ESS_CERT_ID_V2_new_null() ((STACK_OF(ESS_CERT_ID_V2)*)OPENSSL_sk_new_null())
+#define sk_ESS_CERT_ID_V2_new_reserve(cmp, n) ((STACK_OF(ESS_CERT_ID_V2)*)OPENSSL_sk_new_reserve(ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp), (n)))
 #define sk_ESS_CERT_ID_V2_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (n))
 #define sk_ESS_CERT_ID_V2_free(sk) OPENSSL_sk_free(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
 #define sk_ESS_CERT_ID_V2_zero(sk) OPENSSL_sk_zero(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
-#define sk_ESS_CERT_ID_V2_delete(sk, i) ((ESS_CERT_ID_V2 *)OPENSSL_sk_delete(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (i)))
-#define sk_ESS_CERT_ID_V2_delete_ptr(sk, ptr) ((ESS_CERT_ID_V2 *)OPENSSL_sk_delete_ptr(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr)))
+#define sk_ESS_CERT_ID_V2_delete(sk, i) ((ESS_CERT_ID_V2*)OPENSSL_sk_delete(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (i)))
+#define sk_ESS_CERT_ID_V2_delete_ptr(sk, ptr) ((ESS_CERT_ID_V2*)OPENSSL_sk_delete_ptr(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr)))
 #define sk_ESS_CERT_ID_V2_push(sk, ptr) OPENSSL_sk_push(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
 #define sk_ESS_CERT_ID_V2_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
-#define sk_ESS_CERT_ID_V2_pop(sk) ((ESS_CERT_ID_V2 *)OPENSSL_sk_pop(ossl_check_ESS_CERT_ID_V2_sk_type(sk)))
-#define sk_ESS_CERT_ID_V2_shift(sk) ((ESS_CERT_ID_V2 *)OPENSSL_sk_shift(ossl_check_ESS_CERT_ID_V2_sk_type(sk)))
-#define sk_ESS_CERT_ID_V2_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ESS_CERT_ID_V2_sk_type(sk),ossl_check_ESS_CERT_ID_V2_freefunc_type(freefunc))
+#define sk_ESS_CERT_ID_V2_pop(sk) ((ESS_CERT_ID_V2*)OPENSSL_sk_pop(ossl_check_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_shift(sk) ((ESS_CERT_ID_V2*)OPENSSL_sk_shift(ossl_check_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_freefunc_type(freefunc))
 #define sk_ESS_CERT_ID_V2_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr), (idx))
-#define sk_ESS_CERT_ID_V2_set(sk, idx, ptr) ((ESS_CERT_ID_V2 *)OPENSSL_sk_set(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (idx), ossl_check_ESS_CERT_ID_V2_type(ptr)))
+#define sk_ESS_CERT_ID_V2_set(sk, idx, ptr) ((ESS_CERT_ID_V2*)OPENSSL_sk_set(ossl_check_ESS_CERT_ID_V2_sk_type(sk), (idx), ossl_check_ESS_CERT_ID_V2_type(ptr)))
 #define sk_ESS_CERT_ID_V2_find(sk, ptr) OPENSSL_sk_find(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
 #define sk_ESS_CERT_ID_V2_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr))
 #define sk_ESS_CERT_ID_V2_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_type(ptr), pnum)
 #define sk_ESS_CERT_ID_V2_sort(sk) OPENSSL_sk_sort(ossl_check_ESS_CERT_ID_V2_sk_type(sk))
 #define sk_ESS_CERT_ID_V2_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk))
-#define sk_ESS_CERT_ID_V2_dup(sk) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_dup(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk)))
-#define sk_ESS_CERT_ID_V2_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ESS_CERT_ID_V2) *)OPENSSL_sk_deep_copy(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_copyfunc_type(copyfunc), ossl_check_ESS_CERT_ID_V2_freefunc_type(freefunc)))
+#define sk_ESS_CERT_ID_V2_dup(sk) ((STACK_OF(ESS_CERT_ID_V2)*)OPENSSL_sk_dup(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk)))
+#define sk_ESS_CERT_ID_V2_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ESS_CERT_ID_V2)*)OPENSSL_sk_deep_copy(ossl_check_const_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_copyfunc_type(copyfunc), ossl_check_ESS_CERT_ID_V2_freefunc_type(freefunc)))
 #define sk_ESS_CERT_ID_V2_set_cmp_func(sk, cmp) ((sk_ESS_CERT_ID_V2_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ESS_CERT_ID_V2_sk_type(sk), ossl_check_ESS_CERT_ID_V2_compfunc_type(cmp)))
 
+    DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_ISSUER_SERIAL)
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_ISSUER_SERIAL, ESS_ISSUER_SERIAL)
+        DECLARE_ASN1_DUP_FUNCTION(ESS_ISSUER_SERIAL)
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_ISSUER_SERIAL)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_ISSUER_SERIAL, ESS_ISSUER_SERIAL)
-DECLARE_ASN1_DUP_FUNCTION(ESS_ISSUER_SERIAL)
+            DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_CERT_ID)
+                DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_CERT_ID, ESS_CERT_ID)
+                    DECLARE_ASN1_DUP_FUNCTION(ESS_CERT_ID)
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_CERT_ID)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_CERT_ID, ESS_CERT_ID)
-DECLARE_ASN1_DUP_FUNCTION(ESS_CERT_ID)
+                        DECLARE_ASN1_FUNCTIONS(ESS_SIGNING_CERT)
+                            DECLARE_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT)
 
-DECLARE_ASN1_FUNCTIONS(ESS_SIGNING_CERT)
-DECLARE_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT)
+                                DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_CERT_ID_V2)
+                                    DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_CERT_ID_V2, ESS_CERT_ID_V2)
+                                        DECLARE_ASN1_DUP_FUNCTION(ESS_CERT_ID_V2)
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(ESS_CERT_ID_V2)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(ESS_CERT_ID_V2, ESS_CERT_ID_V2)
-DECLARE_ASN1_DUP_FUNCTION(ESS_CERT_ID_V2)
+                                            DECLARE_ASN1_FUNCTIONS(ESS_SIGNING_CERT_V2)
+                                                DECLARE_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT_V2)
 
-DECLARE_ASN1_FUNCTIONS(ESS_SIGNING_CERT_V2)
-DECLARE_ASN1_DUP_FUNCTION(ESS_SIGNING_CERT_V2)
+                                                    ESS_SIGNING_CERT* OSSL_ESS_signing_cert_new_init(const X509* signcert, const STACK_OF(X509) * certs, int set_issuer_serial);
+    ESS_SIGNING_CERT_V2* OSSL_ESS_signing_cert_v2_new_init(const EVP_MD* hash_alg, const X509* signcert, const STACK_OF(X509) * certs, int set_issuer_serial);
+    int OSSL_ESS_check_signing_certs(const ESS_SIGNING_CERT* ss, const ESS_SIGNING_CERT_V2* ssv2, const STACK_OF(X509) * chain, int require_signing_cert);
 
-ESS_SIGNING_CERT *OSSL_ESS_signing_cert_new_init(const X509 *signcert,
-                                                 const STACK_OF(X509) *certs,
-                                                 int set_issuer_serial);
-ESS_SIGNING_CERT_V2 *OSSL_ESS_signing_cert_v2_new_init(const EVP_MD *hash_alg,
-                                                       const X509 *signcert,
-                                                       const
-                                                       STACK_OF(X509) *certs,
-                                                       int set_issuer_serial);
-int OSSL_ESS_check_signing_certs(const ESS_SIGNING_CERT *ss,
-                                 const ESS_SIGNING_CERT_V2 *ssv2,
-                                 const STACK_OF(X509) *chain,
-                                 int require_signing_cert);
-
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/esserr.h b/CAPI/cpp/grpc/include/openssl/esserr.h
index 165ce7c..4688129 100644
--- a/CAPI/cpp/grpc/include/openssl/esserr.h
+++ b/CAPI/cpp/grpc/include/openssl/esserr.h
@@ -9,24 +9,24 @@
  */
 
 #ifndef OPENSSL_ESSERR_H
-# define OPENSSL_ESSERR_H
-# pragma once
+#define OPENSSL_ESSERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * ESS reason codes.
  */
-# define ESS_R_EMPTY_ESS_CERT_ID_LIST                     107
-# define ESS_R_ESS_CERT_DIGEST_ERROR                      103
-# define ESS_R_ESS_CERT_ID_NOT_FOUND                      104
-# define ESS_R_ESS_CERT_ID_WRONG_ORDER                    105
-# define ESS_R_ESS_DIGEST_ALG_UNKNOWN                     106
-# define ESS_R_ESS_SIGNING_CERTIFICATE_ERROR              102
-# define ESS_R_ESS_SIGNING_CERT_ADD_ERROR                 100
-# define ESS_R_ESS_SIGNING_CERT_V2_ADD_ERROR              101
-# define ESS_R_MISSING_SIGNING_CERTIFICATE_ATTRIBUTE      108
+#define ESS_R_EMPTY_ESS_CERT_ID_LIST 107
+#define ESS_R_ESS_CERT_DIGEST_ERROR 103
+#define ESS_R_ESS_CERT_ID_NOT_FOUND 104
+#define ESS_R_ESS_CERT_ID_WRONG_ORDER 105
+#define ESS_R_ESS_DIGEST_ALG_UNKNOWN 106
+#define ESS_R_ESS_SIGNING_CERTIFICATE_ERROR 102
+#define ESS_R_ESS_SIGNING_CERT_ADD_ERROR 100
+#define ESS_R_ESS_SIGNING_CERT_V2_ADD_ERROR 101
+#define ESS_R_MISSING_SIGNING_CERTIFICATE_ATTRIBUTE 108
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/evp.h b/CAPI/cpp/grpc/include/openssl/evp.h
index 49e8e1d..d776f45 100644
--- a/CAPI/cpp/grpc/include/openssl/evp.h
+++ b/CAPI/cpp/grpc/include/openssl/evp.h
@@ -8,2163 +8,1681 @@
  */
 
 #ifndef OPENSSL_EVP_H
-# define OPENSSL_EVP_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_ENVELOPE_H
-# endif
-
-# include <stdarg.h>
-
-# ifndef OPENSSL_NO_STDIO
-#  include <stdio.h>
-# endif
-
-# include <openssl/opensslconf.h>
-# include <openssl/types.h>
-# include <openssl/core.h>
-# include <openssl/core_dispatch.h>
-# include <openssl/symhacks.h>
-# include <openssl/bio.h>
-# include <openssl/evperr.h>
-# include <openssl/params.h>
-
-# define EVP_MAX_MD_SIZE                 64/* longest known is SHA512 */
-# define EVP_MAX_KEY_LENGTH              64
-# define EVP_MAX_IV_LENGTH               16
-# define EVP_MAX_BLOCK_LENGTH            32
-
-# define PKCS5_SALT_LEN                  8
+#define OPENSSL_EVP_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_ENVELOPE_H
+#endif
+
+#include <stdarg.h>
+
+#ifndef OPENSSL_NO_STDIO
+#include <stdio.h>
+#endif
+
+#include <openssl/opensslconf.h>
+#include <openssl/types.h>
+#include <openssl/core.h>
+#include <openssl/core_dispatch.h>
+#include <openssl/symhacks.h>
+#include <openssl/bio.h>
+#include <openssl/evperr.h>
+#include <openssl/params.h>
+
+#define EVP_MAX_MD_SIZE 64 /* longest known is SHA512 */
+#define EVP_MAX_KEY_LENGTH 64
+#define EVP_MAX_IV_LENGTH 16
+#define EVP_MAX_BLOCK_LENGTH 32
+
+#define PKCS5_SALT_LEN 8
 /* Default PKCS#5 iteration count */
-# define PKCS5_DEFAULT_ITER              2048
-
-# include <openssl/objects.h>
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define EVP_PK_RSA      0x0001
-#  define EVP_PK_DSA      0x0002
-#  define EVP_PK_DH       0x0004
-#  define EVP_PK_EC       0x0008
-#  define EVP_PKT_SIGN    0x0010
-#  define EVP_PKT_ENC     0x0020
-#  define EVP_PKT_EXCH    0x0040
-#  define EVP_PKS_RSA     0x0100
-#  define EVP_PKS_DSA     0x0200
-#  define EVP_PKS_EC      0x0400
-# endif
-
-# define EVP_PKEY_NONE   NID_undef
-# define EVP_PKEY_RSA    NID_rsaEncryption
-# define EVP_PKEY_RSA2   NID_rsa
-# define EVP_PKEY_RSA_PSS NID_rsassaPss
-# define EVP_PKEY_DSA    NID_dsa
-# define EVP_PKEY_DSA1   NID_dsa_2
-# define EVP_PKEY_DSA2   NID_dsaWithSHA
-# define EVP_PKEY_DSA3   NID_dsaWithSHA1
-# define EVP_PKEY_DSA4   NID_dsaWithSHA1_2
-# define EVP_PKEY_DH     NID_dhKeyAgreement
-# define EVP_PKEY_DHX    NID_dhpublicnumber
-# define EVP_PKEY_EC     NID_X9_62_id_ecPublicKey
-# define EVP_PKEY_SM2    NID_sm2
-# define EVP_PKEY_HMAC   NID_hmac
-# define EVP_PKEY_CMAC   NID_cmac
-# define EVP_PKEY_SCRYPT NID_id_scrypt
-# define EVP_PKEY_TLS1_PRF NID_tls1_prf
-# define EVP_PKEY_HKDF   NID_hkdf
-# define EVP_PKEY_POLY1305 NID_poly1305
-# define EVP_PKEY_SIPHASH NID_siphash
-# define EVP_PKEY_X25519 NID_X25519
-# define EVP_PKEY_ED25519 NID_ED25519
-# define EVP_PKEY_X448 NID_X448
-# define EVP_PKEY_ED448 NID_ED448
+#define PKCS5_DEFAULT_ITER 2048
+
+#include <openssl/objects.h>
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define EVP_PK_RSA 0x0001
+#define EVP_PK_DSA 0x0002
+#define EVP_PK_DH 0x0004
+#define EVP_PK_EC 0x0008
+#define EVP_PKT_SIGN 0x0010
+#define EVP_PKT_ENC 0x0020
+#define EVP_PKT_EXCH 0x0040
+#define EVP_PKS_RSA 0x0100
+#define EVP_PKS_DSA 0x0200
+#define EVP_PKS_EC 0x0400
+#endif
+
+#define EVP_PKEY_NONE NID_undef
+#define EVP_PKEY_RSA NID_rsaEncryption
+#define EVP_PKEY_RSA2 NID_rsa
+#define EVP_PKEY_RSA_PSS NID_rsassaPss
+#define EVP_PKEY_DSA NID_dsa
+#define EVP_PKEY_DSA1 NID_dsa_2
+#define EVP_PKEY_DSA2 NID_dsaWithSHA
+#define EVP_PKEY_DSA3 NID_dsaWithSHA1
+#define EVP_PKEY_DSA4 NID_dsaWithSHA1_2
+#define EVP_PKEY_DH NID_dhKeyAgreement
+#define EVP_PKEY_DHX NID_dhpublicnumber
+#define EVP_PKEY_EC NID_X9_62_id_ecPublicKey
+#define EVP_PKEY_SM2 NID_sm2
+#define EVP_PKEY_HMAC NID_hmac
+#define EVP_PKEY_CMAC NID_cmac
+#define EVP_PKEY_SCRYPT NID_id_scrypt
+#define EVP_PKEY_TLS1_PRF NID_tls1_prf
+#define EVP_PKEY_HKDF NID_hkdf
+#define EVP_PKEY_POLY1305 NID_poly1305
+#define EVP_PKEY_SIPHASH NID_siphash
+#define EVP_PKEY_X25519 NID_X25519
+#define EVP_PKEY_ED25519 NID_ED25519
+#define EVP_PKEY_X448 NID_X448
+#define EVP_PKEY_ED448 NID_ED448
 /* Special indicator that the object is uniquely provider side */
-# define EVP_PKEY_KEYMGMT -1
+#define EVP_PKEY_KEYMGMT -1
 
 /* Easy to use macros for EVP_PKEY related selections */
-# define EVP_PKEY_KEY_PARAMETERS                                            \
-    ( OSSL_KEYMGMT_SELECT_ALL_PARAMETERS )
-# define EVP_PKEY_PUBLIC_KEY                                                \
-    ( EVP_PKEY_KEY_PARAMETERS | OSSL_KEYMGMT_SELECT_PUBLIC_KEY )
-# define EVP_PKEY_KEYPAIR                                                   \
-    ( EVP_PKEY_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_PRIVATE_KEY )
-
-#ifdef  __cplusplus
-extern "C" {
-#endif
-
-int EVP_set_default_properties(OSSL_LIB_CTX *libctx, const char *propq);
-int EVP_default_properties_is_fips_enabled(OSSL_LIB_CTX *libctx);
-int EVP_default_properties_enable_fips(OSSL_LIB_CTX *libctx, int enable);
-
-# define EVP_PKEY_MO_SIGN        0x0001
-# define EVP_PKEY_MO_VERIFY      0x0002
-# define EVP_PKEY_MO_ENCRYPT     0x0004
-# define EVP_PKEY_MO_DECRYPT     0x0008
-
-# ifndef EVP_MD
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type);
-OSSL_DEPRECATEDIN_3_0 EVP_MD *EVP_MD_meth_dup(const EVP_MD *md);
-OSSL_DEPRECATEDIN_3_0 void EVP_MD_meth_free(EVP_MD *md);
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize);
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize);
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize);
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags);
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx));
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
-                                                     const void *data,
-                                                     size_t count));
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
-                                                   unsigned char *md));
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
-                                                 const EVP_MD_CTX *from));
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx));
-OSSL_DEPRECATEDIN_3_0
-int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
-                                                 int p1, void *p2));
-OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_input_blocksize(const EVP_MD *md);
-OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_result_size(const EVP_MD *md);
-OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_app_datasize(const EVP_MD *md);
-OSSL_DEPRECATEDIN_3_0 unsigned long EVP_MD_meth_get_flags(const EVP_MD *md);
-OSSL_DEPRECATEDIN_3_0
-int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0
-int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
-                                                const void *data, size_t count);
-OSSL_DEPRECATEDIN_3_0
-int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
-                                               unsigned char *md);
-OSSL_DEPRECATEDIN_3_0
-int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
-                                              const EVP_MD_CTX *from);
-OSSL_DEPRECATEDIN_3_0
-int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0
-int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
-                                              int p1, void *p2);
-#  endif
+#define EVP_PKEY_KEY_PARAMETERS \
+    (OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
+#define EVP_PKEY_PUBLIC_KEY \
+    (EVP_PKEY_KEY_PARAMETERS | OSSL_KEYMGMT_SELECT_PUBLIC_KEY)
+#define EVP_PKEY_KEYPAIR \
+    (EVP_PKEY_PUBLIC_KEY | OSSL_KEYMGMT_SELECT_PRIVATE_KEY)
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    int EVP_set_default_properties(OSSL_LIB_CTX* libctx, const char* propq);
+    int EVP_default_properties_is_fips_enabled(OSSL_LIB_CTX* libctx);
+    int EVP_default_properties_enable_fips(OSSL_LIB_CTX* libctx, int enable);
+
+#define EVP_PKEY_MO_SIGN 0x0001
+#define EVP_PKEY_MO_VERIFY 0x0002
+#define EVP_PKEY_MO_ENCRYPT 0x0004
+#define EVP_PKEY_MO_DECRYPT 0x0008
+
+#ifndef EVP_MD
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 EVP_MD* EVP_MD_meth_new(int md_type, int pkey_type);
+    OSSL_DEPRECATEDIN_3_0 EVP_MD* EVP_MD_meth_dup(const EVP_MD* md);
+    OSSL_DEPRECATEDIN_3_0 void EVP_MD_meth_free(EVP_MD* md);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_input_blocksize(EVP_MD* md, int blocksize);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_result_size(EVP_MD* md, int resultsize);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_app_datasize(EVP_MD* md, int datasize);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_flags(EVP_MD* md, unsigned long flags);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_init(EVP_MD* md, int (*init)(EVP_MD_CTX* ctx));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_update(EVP_MD* md, int (*update)(EVP_MD_CTX* ctx, const void* data, size_t count));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_final(EVP_MD* md, int (*final)(EVP_MD_CTX* ctx, unsigned char* md));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_copy(EVP_MD* md, int (*copy)(EVP_MD_CTX* to, const EVP_MD_CTX* from));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_cleanup(EVP_MD* md, int (*cleanup)(EVP_MD_CTX* ctx));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_MD_meth_set_ctrl(EVP_MD* md, int (*ctrl)(EVP_MD_CTX* ctx, int cmd, int p1, void* p2));
+    OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_input_blocksize(const EVP_MD* md);
+    OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_result_size(const EVP_MD* md);
+    OSSL_DEPRECATEDIN_3_0 int EVP_MD_meth_get_app_datasize(const EVP_MD* md);
+    OSSL_DEPRECATEDIN_3_0 unsigned long EVP_MD_meth_get_flags(const EVP_MD* md);
+    OSSL_DEPRECATEDIN_3_0
+    int (*EVP_MD_meth_get_init(const EVP_MD* md))(EVP_MD_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0
+    int (*EVP_MD_meth_get_update(const EVP_MD* md))(EVP_MD_CTX* ctx, const void* data, size_t count);
+    OSSL_DEPRECATEDIN_3_0
+    int (*EVP_MD_meth_get_final(const EVP_MD* md))(EVP_MD_CTX* ctx, unsigned char* md);
+    OSSL_DEPRECATEDIN_3_0
+    int (*EVP_MD_meth_get_copy(const EVP_MD* md))(EVP_MD_CTX* to, const EVP_MD_CTX* from);
+    OSSL_DEPRECATEDIN_3_0
+    int (*EVP_MD_meth_get_cleanup(const EVP_MD* md))(EVP_MD_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0
+    int (*EVP_MD_meth_get_ctrl(const EVP_MD* md))(EVP_MD_CTX* ctx, int cmd, int p1, void* p2);
+#endif
 /* digest can only handle a single block */
-#  define EVP_MD_FLAG_ONESHOT     0x0001
+#define EVP_MD_FLAG_ONESHOT 0x0001
 
 /* digest is extensible-output function, XOF */
-#  define EVP_MD_FLAG_XOF         0x0002
+#define EVP_MD_FLAG_XOF 0x0002
 
-/* DigestAlgorithmIdentifier flags... */
+    /* DigestAlgorithmIdentifier flags... */
 
-#  define EVP_MD_FLAG_DIGALGID_MASK               0x0018
+#define EVP_MD_FLAG_DIGALGID_MASK 0x0018
 
-/* NULL or absent parameter accepted. Use NULL */
+    /* NULL or absent parameter accepted. Use NULL */
 
-#  define EVP_MD_FLAG_DIGALGID_NULL               0x0000
+#define EVP_MD_FLAG_DIGALGID_NULL 0x0000
 
-/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */
+    /* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */
 
-#  define EVP_MD_FLAG_DIGALGID_ABSENT             0x0008
+#define EVP_MD_FLAG_DIGALGID_ABSENT 0x0008
 
-/* Custom handling via ctrl */
+    /* Custom handling via ctrl */
 
-#  define EVP_MD_FLAG_DIGALGID_CUSTOM             0x0018
+#define EVP_MD_FLAG_DIGALGID_CUSTOM 0x0018
 
 /* Note if suitable for use in FIPS mode */
-#  define EVP_MD_FLAG_FIPS        0x0400
+#define EVP_MD_FLAG_FIPS 0x0400
 
-/* Digest ctrls */
+    /* Digest ctrls */
 
-#  define EVP_MD_CTRL_DIGALGID                    0x1
-#  define EVP_MD_CTRL_MICALG                      0x2
-#  define EVP_MD_CTRL_XOF_LEN                     0x3
-#  define EVP_MD_CTRL_TLSTREE                     0x4
+#define EVP_MD_CTRL_DIGALGID 0x1
+#define EVP_MD_CTRL_MICALG 0x2
+#define EVP_MD_CTRL_XOF_LEN 0x3
+#define EVP_MD_CTRL_TLSTREE 0x4
 
-/* Minimum Algorithm specific ctrl value */
+    /* Minimum Algorithm specific ctrl value */
 
-#  define EVP_MD_CTRL_ALG_CTRL                    0x1000
+#define EVP_MD_CTRL_ALG_CTRL 0x1000
 
-# endif                         /* !EVP_MD */
+#endif /* !EVP_MD */
 
-/* values for EVP_MD_CTX flags */
+    /* values for EVP_MD_CTX flags */
 
-# define EVP_MD_CTX_FLAG_ONESHOT         0x0001/* digest update will be
-                                                * called once only */
-# define EVP_MD_CTX_FLAG_CLEANED         0x0002/* context has already been
-                                                * cleaned */
-# define EVP_MD_CTX_FLAG_REUSE           0x0004/* Don't free up ctx->md_data
-                                                * in EVP_MD_CTX_reset */
+#define EVP_MD_CTX_FLAG_ONESHOT 0x0001 /* digest update will be \
+                                        * called once only */
+#define EVP_MD_CTX_FLAG_CLEANED 0x0002 /* context has already been \
+                                        * cleaned */
+#define EVP_MD_CTX_FLAG_REUSE 0x0004   /* Don't free up ctx->md_data \
+                                        * in EVP_MD_CTX_reset */
 /*
  * FIPS and pad options are ignored in 1.0.0, definitions are here so we
  * don't accidentally reuse the values for other purposes.
  */
 
 /* This flag has no effect from openssl-3.0 onwards */
-# define EVP_MD_CTX_FLAG_NON_FIPS_ALLOW  0x0008
+#define EVP_MD_CTX_FLAG_NON_FIPS_ALLOW 0x0008
 
 /*
  * The following PAD options are also currently ignored in 1.0.0, digest
  * parameters are handled through EVP_DigestSign*() and EVP_DigestVerify*()
  * instead.
  */
-# define EVP_MD_CTX_FLAG_PAD_MASK        0xF0/* RSA mode to use */
-# define EVP_MD_CTX_FLAG_PAD_PKCS1       0x00/* PKCS#1 v1.5 mode */
-# define EVP_MD_CTX_FLAG_PAD_X931        0x10/* X9.31 mode */
-# define EVP_MD_CTX_FLAG_PAD_PSS         0x20/* PSS mode */
+#define EVP_MD_CTX_FLAG_PAD_MASK 0xF0  /* RSA mode to use */
+#define EVP_MD_CTX_FLAG_PAD_PKCS1 0x00 /* PKCS#1 v1.5 mode */
+#define EVP_MD_CTX_FLAG_PAD_X931 0x10  /* X9.31 mode */
+#define EVP_MD_CTX_FLAG_PAD_PSS 0x20   /* PSS mode */
 
-# define EVP_MD_CTX_FLAG_NO_INIT         0x0100/* Don't initialize md_data */
+#define EVP_MD_CTX_FLAG_NO_INIT 0x0100 /* Don't initialize md_data */
 /*
  * Some functions such as EVP_DigestSign only finalise copies of internal
  * contexts so additional data can be included after the finalisation call.
  * This is inefficient if this functionality is not required: it is disabled
  * if the following flag is set.
  */
-# define EVP_MD_CTX_FLAG_FINALISE        0x0200
+#define EVP_MD_CTX_FLAG_FINALISE 0x0200
 /* NOTE: 0x0400 is reserved for internal usage */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-EVP_CIPHER *EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len);
-OSSL_DEPRECATEDIN_3_0
-EVP_CIPHER *EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher);
-OSSL_DEPRECATEDIN_3_0
-void EVP_CIPHER_meth_free(EVP_CIPHER *cipher);
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len);
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags);
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size);
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher,
-                             int (*init) (EVP_CIPHER_CTX *ctx,
-                                          const unsigned char *key,
-                                          const unsigned char *iv,
-                                          int enc));
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher,
-                                  int (*do_cipher) (EVP_CIPHER_CTX *ctx,
-                                                    unsigned char *out,
-                                                    const unsigned char *in,
-                                                    size_t inl));
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher,
-                                int (*cleanup) (EVP_CIPHER_CTX *));
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher,
-                                        int (*set_asn1_parameters) (EVP_CIPHER_CTX *,
-                                                                    ASN1_TYPE *));
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher,
-                                        int (*get_asn1_parameters) (EVP_CIPHER_CTX *,
-                                                                    ASN1_TYPE *));
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher,
-                             int (*ctrl) (EVP_CIPHER_CTX *, int type,
-                                          int arg, void *ptr));
-OSSL_DEPRECATEDIN_3_0 int
-(*EVP_CIPHER_meth_get_init(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
-                                                      const unsigned char *key,
-                                                      const unsigned char *iv,
-                                                      int enc);
-OSSL_DEPRECATEDIN_3_0 int
-(*EVP_CIPHER_meth_get_do_cipher(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
-                                                           unsigned char *out,
-                                                           const unsigned char *in,
-                                                           size_t inl);
-OSSL_DEPRECATEDIN_3_0 int
-(*EVP_CIPHER_meth_get_cleanup(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *);
-OSSL_DEPRECATEDIN_3_0 int
-(*EVP_CIPHER_meth_get_set_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
-                                                                 ASN1_TYPE *);
-OSSL_DEPRECATEDIN_3_0 int
-(*EVP_CIPHER_meth_get_get_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
-                                                                 ASN1_TYPE *);
-OSSL_DEPRECATEDIN_3_0 int
-(*EVP_CIPHER_meth_get_ctrl(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, int type,
-                                                      int arg, void *ptr);
-# endif
-
-/* Values for cipher flags */
-
-/* Modes for ciphers */
-
-# define         EVP_CIPH_STREAM_CIPHER          0x0
-# define         EVP_CIPH_ECB_MODE               0x1
-# define         EVP_CIPH_CBC_MODE               0x2
-# define         EVP_CIPH_CFB_MODE               0x3
-# define         EVP_CIPH_OFB_MODE               0x4
-# define         EVP_CIPH_CTR_MODE               0x5
-# define         EVP_CIPH_GCM_MODE               0x6
-# define         EVP_CIPH_CCM_MODE               0x7
-# define         EVP_CIPH_XTS_MODE               0x10001
-# define         EVP_CIPH_WRAP_MODE              0x10002
-# define         EVP_CIPH_OCB_MODE               0x10003
-# define         EVP_CIPH_SIV_MODE               0x10004
-# define         EVP_CIPH_MODE                   0xF0007
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    EVP_CIPHER* EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len);
+    OSSL_DEPRECATEDIN_3_0
+    EVP_CIPHER* EVP_CIPHER_meth_dup(const EVP_CIPHER* cipher);
+    OSSL_DEPRECATEDIN_3_0
+    void EVP_CIPHER_meth_free(EVP_CIPHER* cipher);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_iv_length(EVP_CIPHER* cipher, int iv_len);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_flags(EVP_CIPHER* cipher, unsigned long flags);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER* cipher, int ctx_size);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_init(EVP_CIPHER* cipher, int (*init)(EVP_CIPHER_CTX* ctx, const unsigned char* key, const unsigned char* iv, int enc));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER* cipher, int (*do_cipher)(EVP_CIPHER_CTX* ctx, unsigned char* out, const unsigned char* in, size_t inl));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_cleanup(EVP_CIPHER* cipher, int (*cleanup)(EVP_CIPHER_CTX*));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER* cipher, int (*set_asn1_parameters)(EVP_CIPHER_CTX*, ASN1_TYPE*));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER* cipher, int (*get_asn1_parameters)(EVP_CIPHER_CTX*, ASN1_TYPE*));
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_meth_set_ctrl(EVP_CIPHER* cipher, int (*ctrl)(EVP_CIPHER_CTX*, int type, int arg, void* ptr));
+    OSSL_DEPRECATEDIN_3_0 int (*EVP_CIPHER_meth_get_init(const EVP_CIPHER* cipher))(EVP_CIPHER_CTX* ctx, const unsigned char* key, const unsigned char* iv, int enc);
+    OSSL_DEPRECATEDIN_3_0 int (*EVP_CIPHER_meth_get_do_cipher(const EVP_CIPHER* cipher))(EVP_CIPHER_CTX* ctx, unsigned char* out, const unsigned char* in, size_t inl);
+    OSSL_DEPRECATEDIN_3_0 int (*EVP_CIPHER_meth_get_cleanup(const EVP_CIPHER* cipher))(EVP_CIPHER_CTX*);
+    OSSL_DEPRECATEDIN_3_0 int (*EVP_CIPHER_meth_get_set_asn1_params(const EVP_CIPHER* cipher))(EVP_CIPHER_CTX*, ASN1_TYPE*);
+    OSSL_DEPRECATEDIN_3_0 int (*EVP_CIPHER_meth_get_get_asn1_params(const EVP_CIPHER* cipher))(EVP_CIPHER_CTX*, ASN1_TYPE*);
+    OSSL_DEPRECATEDIN_3_0 int (*EVP_CIPHER_meth_get_ctrl(const EVP_CIPHER* cipher))(EVP_CIPHER_CTX*, int type, int arg, void* ptr);
+#endif
+
+    /* Values for cipher flags */
+
+    /* Modes for ciphers */
+
+#define EVP_CIPH_STREAM_CIPHER 0x0
+#define EVP_CIPH_ECB_MODE 0x1
+#define EVP_CIPH_CBC_MODE 0x2
+#define EVP_CIPH_CFB_MODE 0x3
+#define EVP_CIPH_OFB_MODE 0x4
+#define EVP_CIPH_CTR_MODE 0x5
+#define EVP_CIPH_GCM_MODE 0x6
+#define EVP_CIPH_CCM_MODE 0x7
+#define EVP_CIPH_XTS_MODE 0x10001
+#define EVP_CIPH_WRAP_MODE 0x10002
+#define EVP_CIPH_OCB_MODE 0x10003
+#define EVP_CIPH_SIV_MODE 0x10004
+#define EVP_CIPH_MODE 0xF0007
 /* Set if variable length cipher */
-# define         EVP_CIPH_VARIABLE_LENGTH        0x8
+#define EVP_CIPH_VARIABLE_LENGTH 0x8
 /* Set if the iv handling should be done by the cipher itself */
-# define         EVP_CIPH_CUSTOM_IV              0x10
+#define EVP_CIPH_CUSTOM_IV 0x10
 /* Set if the cipher's init() function should be called if key is NULL */
-# define         EVP_CIPH_ALWAYS_CALL_INIT       0x20
+#define EVP_CIPH_ALWAYS_CALL_INIT 0x20
 /* Call ctrl() to init cipher parameters */
-# define         EVP_CIPH_CTRL_INIT              0x40
+#define EVP_CIPH_CTRL_INIT 0x40
 /* Don't use standard key length function */
-# define         EVP_CIPH_CUSTOM_KEY_LENGTH      0x80
+#define EVP_CIPH_CUSTOM_KEY_LENGTH 0x80
 /* Don't use standard block padding */
-# define         EVP_CIPH_NO_PADDING             0x100
+#define EVP_CIPH_NO_PADDING 0x100
 /* cipher handles random key generation */
-# define         EVP_CIPH_RAND_KEY               0x200
+#define EVP_CIPH_RAND_KEY 0x200
 /* cipher has its own additional copying logic */
-# define         EVP_CIPH_CUSTOM_COPY            0x400
+#define EVP_CIPH_CUSTOM_COPY 0x400
 /* Don't use standard iv length function */
-# define         EVP_CIPH_CUSTOM_IV_LENGTH       0x800
+#define EVP_CIPH_CUSTOM_IV_LENGTH 0x800
 /* Legacy and no longer relevant: Allow use default ASN1 get/set iv */
-# define         EVP_CIPH_FLAG_DEFAULT_ASN1      0
+#define EVP_CIPH_FLAG_DEFAULT_ASN1 0
 /* Free:                                         0x1000 */
 /* Buffer length in bits not bytes: CFB1 mode only */
-# define         EVP_CIPH_FLAG_LENGTH_BITS       0x2000
+#define EVP_CIPH_FLAG_LENGTH_BITS 0x2000
 /* Deprecated FIPS flag: was 0x4000 */
-# define         EVP_CIPH_FLAG_FIPS              0
+#define EVP_CIPH_FLAG_FIPS 0
 /* Deprecated FIPS flag: was 0x8000 */
-# define         EVP_CIPH_FLAG_NON_FIPS_ALLOW    0
+#define EVP_CIPH_FLAG_NON_FIPS_ALLOW 0
 
 /*
  * Cipher handles any and all padding logic as well as finalisation.
  */
-# define         EVP_CIPH_FLAG_CTS               0x4000
-# define         EVP_CIPH_FLAG_CUSTOM_CIPHER     0x100000
-# define         EVP_CIPH_FLAG_AEAD_CIPHER       0x200000
-# define         EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0x400000
+#define EVP_CIPH_FLAG_CTS 0x4000
+#define EVP_CIPH_FLAG_CUSTOM_CIPHER 0x100000
+#define EVP_CIPH_FLAG_AEAD_CIPHER 0x200000
+#define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0x400000
 /* Cipher can handle pipeline operations */
-# define         EVP_CIPH_FLAG_PIPELINE          0X800000
+#define EVP_CIPH_FLAG_PIPELINE 0X800000
 /* For provider implementations that handle  ASN1 get/set param themselves */
-# define         EVP_CIPH_FLAG_CUSTOM_ASN1       0x1000000
+#define EVP_CIPH_FLAG_CUSTOM_ASN1 0x1000000
 /* For ciphers generating unprotected CMS attributes */
-# define         EVP_CIPH_FLAG_CIPHER_WITH_MAC   0x2000000
+#define EVP_CIPH_FLAG_CIPHER_WITH_MAC 0x2000000
 /* For supplementary wrap cipher support */
-# define         EVP_CIPH_FLAG_GET_WRAP_CIPHER   0x4000000
-# define         EVP_CIPH_FLAG_INVERSE_CIPHER    0x8000000
-
-/*
- * Cipher context flag to indicate we can handle wrap mode: if allowed in
- * older applications it could overflow buffers.
- */
-
-# define         EVP_CIPHER_CTX_FLAG_WRAP_ALLOW  0x1
-
-/* ctrl() values */
-
-# define         EVP_CTRL_INIT                   0x0
-# define         EVP_CTRL_SET_KEY_LENGTH         0x1
-# define         EVP_CTRL_GET_RC2_KEY_BITS       0x2
-# define         EVP_CTRL_SET_RC2_KEY_BITS       0x3
-# define         EVP_CTRL_GET_RC5_ROUNDS         0x4
-# define         EVP_CTRL_SET_RC5_ROUNDS         0x5
-# define         EVP_CTRL_RAND_KEY               0x6
-# define         EVP_CTRL_PBE_PRF_NID            0x7
-# define         EVP_CTRL_COPY                   0x8
-# define         EVP_CTRL_AEAD_SET_IVLEN         0x9
-# define         EVP_CTRL_AEAD_GET_TAG           0x10
-# define         EVP_CTRL_AEAD_SET_TAG           0x11
-# define         EVP_CTRL_AEAD_SET_IV_FIXED      0x12
-# define         EVP_CTRL_GCM_SET_IVLEN          EVP_CTRL_AEAD_SET_IVLEN
-# define         EVP_CTRL_GCM_GET_TAG            EVP_CTRL_AEAD_GET_TAG
-# define         EVP_CTRL_GCM_SET_TAG            EVP_CTRL_AEAD_SET_TAG
-# define         EVP_CTRL_GCM_SET_IV_FIXED       EVP_CTRL_AEAD_SET_IV_FIXED
-# define         EVP_CTRL_GCM_IV_GEN             0x13
-# define         EVP_CTRL_CCM_SET_IVLEN          EVP_CTRL_AEAD_SET_IVLEN
-# define         EVP_CTRL_CCM_GET_TAG            EVP_CTRL_AEAD_GET_TAG
-# define         EVP_CTRL_CCM_SET_TAG            EVP_CTRL_AEAD_SET_TAG
-# define         EVP_CTRL_CCM_SET_IV_FIXED       EVP_CTRL_AEAD_SET_IV_FIXED
-# define         EVP_CTRL_CCM_SET_L              0x14
-# define         EVP_CTRL_CCM_SET_MSGLEN         0x15
+#define EVP_CIPH_FLAG_GET_WRAP_CIPHER 0x4000000
+#define EVP_CIPH_FLAG_INVERSE_CIPHER 0x8000000
+
+    /*
+     * Cipher context flag to indicate we can handle wrap mode: if allowed in
+     * older applications it could overflow buffers.
+     */
+
+#define EVP_CIPHER_CTX_FLAG_WRAP_ALLOW 0x1
+
+    /* ctrl() values */
+
+#define EVP_CTRL_INIT 0x0
+#define EVP_CTRL_SET_KEY_LENGTH 0x1
+#define EVP_CTRL_GET_RC2_KEY_BITS 0x2
+#define EVP_CTRL_SET_RC2_KEY_BITS 0x3
+#define EVP_CTRL_GET_RC5_ROUNDS 0x4
+#define EVP_CTRL_SET_RC5_ROUNDS 0x5
+#define EVP_CTRL_RAND_KEY 0x6
+#define EVP_CTRL_PBE_PRF_NID 0x7
+#define EVP_CTRL_COPY 0x8
+#define EVP_CTRL_AEAD_SET_IVLEN 0x9
+#define EVP_CTRL_AEAD_GET_TAG 0x10
+#define EVP_CTRL_AEAD_SET_TAG 0x11
+#define EVP_CTRL_AEAD_SET_IV_FIXED 0x12
+#define EVP_CTRL_GCM_SET_IVLEN EVP_CTRL_AEAD_SET_IVLEN
+#define EVP_CTRL_GCM_GET_TAG EVP_CTRL_AEAD_GET_TAG
+#define EVP_CTRL_GCM_SET_TAG EVP_CTRL_AEAD_SET_TAG
+#define EVP_CTRL_GCM_SET_IV_FIXED EVP_CTRL_AEAD_SET_IV_FIXED
+#define EVP_CTRL_GCM_IV_GEN 0x13
+#define EVP_CTRL_CCM_SET_IVLEN EVP_CTRL_AEAD_SET_IVLEN
+#define EVP_CTRL_CCM_GET_TAG EVP_CTRL_AEAD_GET_TAG
+#define EVP_CTRL_CCM_SET_TAG EVP_CTRL_AEAD_SET_TAG
+#define EVP_CTRL_CCM_SET_IV_FIXED EVP_CTRL_AEAD_SET_IV_FIXED
+#define EVP_CTRL_CCM_SET_L 0x14
+#define EVP_CTRL_CCM_SET_MSGLEN 0x15
 /*
  * AEAD cipher deduces payload length and returns number of bytes required to
  * store MAC and eventual padding. Subsequent call to EVP_Cipher even
  * appends/verifies MAC.
  */
-# define         EVP_CTRL_AEAD_TLS1_AAD          0x16
+#define EVP_CTRL_AEAD_TLS1_AAD 0x16
 /* Used by composite AEAD ciphers, no-op in GCM, CCM... */
-# define         EVP_CTRL_AEAD_SET_MAC_KEY       0x17
+#define EVP_CTRL_AEAD_SET_MAC_KEY 0x17
 /* Set the GCM invocation field, decrypt only */
-# define         EVP_CTRL_GCM_SET_IV_INV         0x18
+#define EVP_CTRL_GCM_SET_IV_INV 0x18
 
-# define         EVP_CTRL_TLS1_1_MULTIBLOCK_AAD  0x19
-# define         EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT      0x1a
-# define         EVP_CTRL_TLS1_1_MULTIBLOCK_DECRYPT      0x1b
-# define         EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE  0x1c
+#define EVP_CTRL_TLS1_1_MULTIBLOCK_AAD 0x19
+#define EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT 0x1a
+#define EVP_CTRL_TLS1_1_MULTIBLOCK_DECRYPT 0x1b
+#define EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE 0x1c
 
-# define         EVP_CTRL_SSL3_MASTER_SECRET             0x1d
+#define EVP_CTRL_SSL3_MASTER_SECRET 0x1d
 
 /* EVP_CTRL_SET_SBOX takes the char * specifying S-boxes */
-# define         EVP_CTRL_SET_SBOX                       0x1e
+#define EVP_CTRL_SET_SBOX 0x1e
 /*
  * EVP_CTRL_SBOX_USED takes a 'size_t' and 'char *', pointing at a
  * pre-allocated buffer with specified size
  */
-# define         EVP_CTRL_SBOX_USED                      0x1f
+#define EVP_CTRL_SBOX_USED 0x1f
 /* EVP_CTRL_KEY_MESH takes 'size_t' number of bytes to mesh the key after,
  * 0 switches meshing off
  */
-# define         EVP_CTRL_KEY_MESH                       0x20
+#define EVP_CTRL_KEY_MESH 0x20
 /* EVP_CTRL_BLOCK_PADDING_MODE takes the padding mode */
-# define         EVP_CTRL_BLOCK_PADDING_MODE             0x21
+#define EVP_CTRL_BLOCK_PADDING_MODE 0x21
 
 /* Set the output buffers to use for a pipelined operation */
-# define         EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS       0x22
+#define EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS 0x22
 /* Set the input buffers to use for a pipelined operation */
-# define         EVP_CTRL_SET_PIPELINE_INPUT_BUFS        0x23
+#define EVP_CTRL_SET_PIPELINE_INPUT_BUFS 0x23
 /* Set the input buffer lengths to use for a pipelined operation */
-# define         EVP_CTRL_SET_PIPELINE_INPUT_LENS        0x24
+#define EVP_CTRL_SET_PIPELINE_INPUT_LENS 0x24
 /* Get the IV length used by the cipher */
-# define         EVP_CTRL_GET_IVLEN                      0x25
+#define EVP_CTRL_GET_IVLEN 0x25
 /* 0x26 is unused */
 /* Tell the cipher it's doing a speed test (SIV disallows multiple ops) */
-# define         EVP_CTRL_SET_SPEED                      0x27
+#define EVP_CTRL_SET_SPEED 0x27
 /* Get the unprotectedAttrs from cipher ctx */
-# define         EVP_CTRL_PROCESS_UNPROTECTED            0x28
+#define EVP_CTRL_PROCESS_UNPROTECTED 0x28
 /* Get the supplementary wrap cipher */
-#define          EVP_CTRL_GET_WRAP_CIPHER                0x29
+#define EVP_CTRL_GET_WRAP_CIPHER 0x29
 /* TLSTREE key diversification */
-#define          EVP_CTRL_TLSTREE                        0x2A
+#define EVP_CTRL_TLSTREE 0x2A
 
 /* Padding modes */
-#define EVP_PADDING_PKCS7       1
-#define EVP_PADDING_ISO7816_4   2
-#define EVP_PADDING_ANSI923     3
-#define EVP_PADDING_ISO10126    4
-#define EVP_PADDING_ZERO        5
+#define EVP_PADDING_PKCS7 1
+#define EVP_PADDING_ISO7816_4 2
+#define EVP_PADDING_ANSI923 3
+#define EVP_PADDING_ISO10126 4
+#define EVP_PADDING_ZERO 5
 
 /* RFC 5246 defines additional data to be 13 bytes in length */
-# define         EVP_AEAD_TLS1_AAD_LEN           13
+#define EVP_AEAD_TLS1_AAD_LEN 13
 
-typedef struct {
-    unsigned char *out;
-    const unsigned char *inp;
-    size_t len;
-    unsigned int interleave;
-} EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM;
+    typedef struct
+    {
+        unsigned char* out;
+        const unsigned char* inp;
+        size_t len;
+        unsigned int interleave;
+    } EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM;
 
 /* GCM TLS constants */
 /* Length of fixed part of IV derived from PRF */
-# define EVP_GCM_TLS_FIXED_IV_LEN                        4
+#define EVP_GCM_TLS_FIXED_IV_LEN 4
 /* Length of explicit part of IV part of TLS records */
-# define EVP_GCM_TLS_EXPLICIT_IV_LEN                     8
+#define EVP_GCM_TLS_EXPLICIT_IV_LEN 8
 /* Length of tag for TLS */
-# define EVP_GCM_TLS_TAG_LEN                             16
+#define EVP_GCM_TLS_TAG_LEN 16
 
 /* CCM TLS constants */
 /* Length of fixed part of IV derived from PRF */
-# define EVP_CCM_TLS_FIXED_IV_LEN                        4
+#define EVP_CCM_TLS_FIXED_IV_LEN 4
 /* Length of explicit part of IV part of TLS records */
-# define EVP_CCM_TLS_EXPLICIT_IV_LEN                     8
+#define EVP_CCM_TLS_EXPLICIT_IV_LEN 8
 /* Total length of CCM IV length for TLS */
-# define EVP_CCM_TLS_IV_LEN                              12
+#define EVP_CCM_TLS_IV_LEN 12
 /* Length of tag for TLS */
-# define EVP_CCM_TLS_TAG_LEN                             16
+#define EVP_CCM_TLS_TAG_LEN 16
 /* Length of CCM8 tag for TLS */
-# define EVP_CCM8_TLS_TAG_LEN                            8
+#define EVP_CCM8_TLS_TAG_LEN 8
 
 /* Length of tag for TLS */
-# define EVP_CHACHAPOLY_TLS_TAG_LEN                      16
-
-typedef struct evp_cipher_info_st {
-    const EVP_CIPHER *cipher;
-    unsigned char iv[EVP_MAX_IV_LENGTH];
-} EVP_CIPHER_INFO;
-
-
-/* Password based encryption function */
-typedef int (EVP_PBE_KEYGEN) (EVP_CIPHER_CTX *ctx, const char *pass,
-                              int passlen, ASN1_TYPE *param,
-                              const EVP_CIPHER *cipher, const EVP_MD *md,
-                              int en_de);
-
-typedef int (EVP_PBE_KEYGEN_EX) (EVP_CIPHER_CTX *ctx, const char *pass,
-                                 int passlen, ASN1_TYPE *param,
-                                 const EVP_CIPHER *cipher, const EVP_MD *md,
-                                 int en_de, OSSL_LIB_CTX *libctx, const char *propq);
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\
-                                                         (rsa))
-# endif
-
-# ifndef OPENSSL_NO_DSA
-#  define EVP_PKEY_assign_DSA(pkey,dsa) EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\
-                                        (dsa))
-# endif
-
-# if !defined(OPENSSL_NO_DH) && !defined(OPENSSL_NO_DEPRECATED_3_0)
-#  define EVP_PKEY_assign_DH(pkey,dh) EVP_PKEY_assign((pkey),EVP_PKEY_DH,(dh))
-# endif
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifndef OPENSSL_NO_EC
-#   define EVP_PKEY_assign_EC_KEY(pkey,eckey) \
-        EVP_PKEY_assign((pkey), EVP_PKEY_EC, (eckey))
-#  endif
-# endif
-# ifndef OPENSSL_NO_SIPHASH
-#  define EVP_PKEY_assign_SIPHASH(pkey,shkey) EVP_PKEY_assign((pkey),\
-                                        EVP_PKEY_SIPHASH,(shkey))
-# endif
-
-# ifndef OPENSSL_NO_POLY1305
-#  define EVP_PKEY_assign_POLY1305(pkey,polykey) EVP_PKEY_assign((pkey),\
-                                        EVP_PKEY_POLY1305,(polykey))
-# endif
+#define EVP_CHACHAPOLY_TLS_TAG_LEN 16
+
+    typedef struct evp_cipher_info_st
+    {
+        const EVP_CIPHER* cipher;
+        unsigned char iv[EVP_MAX_IV_LENGTH];
+    } EVP_CIPHER_INFO;
+
+    /* Password based encryption function */
+    typedef int(EVP_PBE_KEYGEN)(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* cipher, const EVP_MD* md, int en_de);
+
+    typedef int(EVP_PBE_KEYGEN_EX)(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* cipher, const EVP_MD* md, int en_de, OSSL_LIB_CTX* libctx, const char* propq);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define EVP_PKEY_assign_RSA(pkey, rsa) EVP_PKEY_assign((pkey), EVP_PKEY_RSA, (rsa))
+#endif
+
+#ifndef OPENSSL_NO_DSA
+#define EVP_PKEY_assign_DSA(pkey, dsa) EVP_PKEY_assign((pkey), EVP_PKEY_DSA, (dsa))
+#endif
+
+#if !defined(OPENSSL_NO_DH) && !defined(OPENSSL_NO_DEPRECATED_3_0)
+#define EVP_PKEY_assign_DH(pkey, dh) EVP_PKEY_assign((pkey), EVP_PKEY_DH, (dh))
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_EC
+#define EVP_PKEY_assign_EC_KEY(pkey, eckey) \
+    EVP_PKEY_assign((pkey), EVP_PKEY_EC, (eckey))
+#endif
+#endif
+#ifndef OPENSSL_NO_SIPHASH
+#define EVP_PKEY_assign_SIPHASH(pkey, shkey) EVP_PKEY_assign((pkey), EVP_PKEY_SIPHASH, (shkey))
+#endif
+
+#ifndef OPENSSL_NO_POLY1305
+#define EVP_PKEY_assign_POLY1305(pkey, polykey) EVP_PKEY_assign((pkey), EVP_PKEY_POLY1305, (polykey))
+#endif
 
 /* Add some extra combinations */
-# define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a))
-# define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a))
-# define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a))
-# define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a))
-
-int EVP_MD_get_type(const EVP_MD *md);
-# define EVP_MD_type EVP_MD_get_type
-# define EVP_MD_nid EVP_MD_get_type
-const char *EVP_MD_get0_name(const EVP_MD *md);
-# define EVP_MD_name EVP_MD_get0_name
-const char *EVP_MD_get0_description(const EVP_MD *md);
-int EVP_MD_is_a(const EVP_MD *md, const char *name);
-int EVP_MD_names_do_all(const EVP_MD *md,
-                        void (*fn)(const char *name, void *data),
-                        void *data);
-const OSSL_PROVIDER *EVP_MD_get0_provider(const EVP_MD *md);
-int EVP_MD_get_pkey_type(const EVP_MD *md);
-# define EVP_MD_pkey_type EVP_MD_get_pkey_type
-int EVP_MD_get_size(const EVP_MD *md);
-# define EVP_MD_size EVP_MD_get_size
-int EVP_MD_get_block_size(const EVP_MD *md);
-# define EVP_MD_block_size EVP_MD_get_block_size
-unsigned long EVP_MD_get_flags(const EVP_MD *md);
-# define EVP_MD_flags EVP_MD_get_flags
-
-const EVP_MD *EVP_MD_CTX_get0_md(const EVP_MD_CTX *ctx);
-EVP_MD *EVP_MD_CTX_get1_md(EVP_MD_CTX *ctx);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0
-int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
-                                             const void *data, size_t count);
-OSSL_DEPRECATEDIN_3_0
-void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
-                              int (*update) (EVP_MD_CTX *ctx,
-                                             const void *data, size_t count));
-# endif
-# define EVP_MD_CTX_get0_name(e)       EVP_MD_get0_name(EVP_MD_CTX_get0_md(e))
-# define EVP_MD_CTX_get_size(e)        EVP_MD_get_size(EVP_MD_CTX_get0_md(e))
-# define EVP_MD_CTX_size               EVP_MD_CTX_get_size
-# define EVP_MD_CTX_get_block_size(e)  EVP_MD_get_block_size(EVP_MD_CTX_get0_md(e))
-# define EVP_MD_CTX_block_size EVP_MD_CTX_get_block_size
-# define EVP_MD_CTX_get_type(e)            EVP_MD_get_type(EVP_MD_CTX_get0_md(e))
-# define EVP_MD_CTX_type EVP_MD_CTX_get_type
-EVP_PKEY_CTX *EVP_MD_CTX_get_pkey_ctx(const EVP_MD_CTX *ctx);
-# define EVP_MD_CTX_pkey_ctx EVP_MD_CTX_get_pkey_ctx
-void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx);
-void *EVP_MD_CTX_get0_md_data(const EVP_MD_CTX *ctx);
-# define EVP_MD_CTX_md_data EVP_MD_CTX_get0_md_data
-
-int EVP_CIPHER_get_nid(const EVP_CIPHER *cipher);
-# define EVP_CIPHER_nid EVP_CIPHER_get_nid
-const char *EVP_CIPHER_get0_name(const EVP_CIPHER *cipher);
-# define EVP_CIPHER_name EVP_CIPHER_get0_name
-const char *EVP_CIPHER_get0_description(const EVP_CIPHER *cipher);
-int EVP_CIPHER_is_a(const EVP_CIPHER *cipher, const char *name);
-int EVP_CIPHER_names_do_all(const EVP_CIPHER *cipher,
-                            void (*fn)(const char *name, void *data),
-                            void *data);
-const OSSL_PROVIDER *EVP_CIPHER_get0_provider(const EVP_CIPHER *cipher);
-int EVP_CIPHER_get_block_size(const EVP_CIPHER *cipher);
-# define EVP_CIPHER_block_size EVP_CIPHER_get_block_size
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *cipher);
-# endif
-int EVP_CIPHER_get_key_length(const EVP_CIPHER *cipher);
-# define EVP_CIPHER_key_length EVP_CIPHER_get_key_length
-int EVP_CIPHER_get_iv_length(const EVP_CIPHER *cipher);
-# define EVP_CIPHER_iv_length EVP_CIPHER_get_iv_length
-unsigned long EVP_CIPHER_get_flags(const EVP_CIPHER *cipher);
-# define EVP_CIPHER_flags EVP_CIPHER_get_flags
-int EVP_CIPHER_get_mode(const EVP_CIPHER *cipher);
-# define EVP_CIPHER_mode EVP_CIPHER_get_mode
-int EVP_CIPHER_get_type(const EVP_CIPHER *cipher);
-# define EVP_CIPHER_type EVP_CIPHER_get_type
-EVP_CIPHER *EVP_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
-                             const char *properties);
-int EVP_CIPHER_up_ref(EVP_CIPHER *cipher);
-void EVP_CIPHER_free(EVP_CIPHER *cipher);
-
-const EVP_CIPHER *EVP_CIPHER_CTX_get0_cipher(const EVP_CIPHER_CTX *ctx);
-EVP_CIPHER *EVP_CIPHER_CTX_get1_cipher(EVP_CIPHER_CTX *ctx);
-int EVP_CIPHER_CTX_is_encrypting(const EVP_CIPHER_CTX *ctx);
-# define EVP_CIPHER_CTX_encrypting EVP_CIPHER_CTX_is_encrypting
-int EVP_CIPHER_CTX_get_nid(const EVP_CIPHER_CTX *ctx);
-# define EVP_CIPHER_CTX_nid EVP_CIPHER_CTX_get_nid
-int EVP_CIPHER_CTX_get_block_size(const EVP_CIPHER_CTX *ctx);
-# define EVP_CIPHER_CTX_block_size EVP_CIPHER_CTX_get_block_size
-int EVP_CIPHER_CTX_get_key_length(const EVP_CIPHER_CTX *ctx);
-# define EVP_CIPHER_CTX_key_length EVP_CIPHER_CTX_get_key_length
-int EVP_CIPHER_CTX_get_iv_length(const EVP_CIPHER_CTX *ctx);
-# define EVP_CIPHER_CTX_iv_length EVP_CIPHER_CTX_get_iv_length
-int EVP_CIPHER_CTX_get_tag_length(const EVP_CIPHER_CTX *ctx);
-# define EVP_CIPHER_CTX_tag_length EVP_CIPHER_CTX_get_tag_length
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx);
-# endif
-int EVP_CIPHER_CTX_get_updated_iv(EVP_CIPHER_CTX *ctx, void *buf, size_t len);
-int EVP_CIPHER_CTX_get_original_iv(EVP_CIPHER_CTX *ctx, void *buf, size_t len);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx);
-# endif
-int EVP_CIPHER_CTX_get_num(const EVP_CIPHER_CTX *ctx);
-# define EVP_CIPHER_CTX_num EVP_CIPHER_CTX_get_num
-int EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num);
-int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in);
-void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
-void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data);
-void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx);
-void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data);
-# define EVP_CIPHER_CTX_get0_name(c) EVP_CIPHER_get0_name(EVP_CIPHER_CTX_get0_cipher(c))
-# define EVP_CIPHER_CTX_get_type(c)  EVP_CIPHER_get_type(EVP_CIPHER_CTX_get0_cipher(c))
-# define EVP_CIPHER_CTX_type         EVP_CIPHER_CTX_get_type
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define EVP_CIPHER_CTX_flags(c)    EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(c))
-# endif
-# define EVP_CIPHER_CTX_get_mode(c)  EVP_CIPHER_get_mode(EVP_CIPHER_CTX_get0_cipher(c))
-# define EVP_CIPHER_CTX_mode         EVP_CIPHER_CTX_get_mode
-
-# define EVP_ENCODE_LENGTH(l)    ((((l)+2)/3*4)+((l)/48+1)*2+80)
-# define EVP_DECODE_LENGTH(l)    (((l)+3)/4*3+80)
-
-# define EVP_SignInit_ex(a,b,c)          EVP_DigestInit_ex(a,b,c)
-# define EVP_SignInit(a,b)               EVP_DigestInit(a,b)
-# define EVP_SignUpdate(a,b,c)           EVP_DigestUpdate(a,b,c)
-# define EVP_VerifyInit_ex(a,b,c)        EVP_DigestInit_ex(a,b,c)
-# define EVP_VerifyInit(a,b)             EVP_DigestInit(a,b)
-# define EVP_VerifyUpdate(a,b,c)         EVP_DigestUpdate(a,b,c)
-# define EVP_OpenUpdate(a,b,c,d,e)       EVP_DecryptUpdate(a,b,c,d,e)
-# define EVP_SealUpdate(a,b,c,d,e)       EVP_EncryptUpdate(a,b,c,d,e)
-
-# ifdef CONST_STRICT
-void BIO_set_md(BIO *, const EVP_MD *md);
-# else
-#  define BIO_set_md(b,md)          BIO_ctrl(b,BIO_C_SET_MD,0,(void *)(md))
-# endif
-# define BIO_get_md(b,mdp)          BIO_ctrl(b,BIO_C_GET_MD,0,(mdp))
-# define BIO_get_md_ctx(b,mdcp)     BIO_ctrl(b,BIO_C_GET_MD_CTX,0,(mdcp))
-# define BIO_set_md_ctx(b,mdcp)     BIO_ctrl(b,BIO_C_SET_MD_CTX,0,(mdcp))
-# define BIO_get_cipher_status(b)   BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL)
-# define BIO_get_cipher_ctx(b,c_pp) BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0,(c_pp))
-
-/*__owur*/ int EVP_Cipher(EVP_CIPHER_CTX *c,
-                          unsigned char *out,
-                          const unsigned char *in, unsigned int inl);
-
-# define EVP_add_cipher_alias(n,alias) \
-        OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n))
-# define EVP_add_digest_alias(n,alias) \
-        OBJ_NAME_add((alias),OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n))
-# define EVP_delete_cipher_alias(alias) \
-        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS);
-# define EVP_delete_digest_alias(alias) \
-        OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS);
-
-int EVP_MD_get_params(const EVP_MD *digest, OSSL_PARAM params[]);
-int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[]);
-const OSSL_PARAM *EVP_MD_gettable_params(const EVP_MD *digest);
-const OSSL_PARAM *EVP_MD_settable_ctx_params(const EVP_MD *md);
-const OSSL_PARAM *EVP_MD_gettable_ctx_params(const EVP_MD *md);
-const OSSL_PARAM *EVP_MD_CTX_settable_params(EVP_MD_CTX *ctx);
-const OSSL_PARAM *EVP_MD_CTX_gettable_params(EVP_MD_CTX *ctx);
-int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
-EVP_MD_CTX *EVP_MD_CTX_new(void);
-int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
-void EVP_MD_CTX_free(EVP_MD_CTX *ctx);
-# define EVP_MD_CTX_create()     EVP_MD_CTX_new()
-# define EVP_MD_CTX_init(ctx)    EVP_MD_CTX_reset((ctx))
-# define EVP_MD_CTX_destroy(ctx) EVP_MD_CTX_free((ctx))
-__owur int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in);
-void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
-void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);
-int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags);
-__owur int EVP_DigestInit_ex2(EVP_MD_CTX *ctx, const EVP_MD *type,
-                              const OSSL_PARAM params[]);
-__owur int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type,
-                                 ENGINE *impl);
-__owur int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d,
-                                size_t cnt);
-__owur int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
-                                  unsigned int *s);
-__owur int EVP_Digest(const void *data, size_t count,
-                          unsigned char *md, unsigned int *size,
-                          const EVP_MD *type, ENGINE *impl);
-__owur int EVP_Q_digest(OSSL_LIB_CTX *libctx, const char *name,
-                        const char *propq, const void *data, size_t datalen,
-                        unsigned char *md, size_t *mdlen);
-
-__owur int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in);
-__owur int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
-__owur int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md,
-                           unsigned int *s);
-__owur int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md,
-                              size_t len);
-
-__owur EVP_MD *EVP_MD_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
-                            const char *properties);
-
-int EVP_MD_up_ref(EVP_MD *md);
-void EVP_MD_free(EVP_MD *md);
-
-int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify);
-int EVP_read_pw_string_min(char *buf, int minlen, int maxlen,
-                           const char *prompt, int verify);
-void EVP_set_pw_prompt(const char *prompt);
-char *EVP_get_pw_prompt(void);
-
-__owur int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
-                          const unsigned char *salt,
-                          const unsigned char *data, int datal, int count,
-                          unsigned char *key, unsigned char *iv);
-
-void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags);
-void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags);
-int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags);
-
-__owur int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
-                           const unsigned char *key, const unsigned char *iv);
-/*__owur*/ int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,
-                                  const EVP_CIPHER *cipher, ENGINE *impl,
-                                  const unsigned char *key,
-                                  const unsigned char *iv);
-__owur int EVP_EncryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
-                               const unsigned char *key,
-                               const unsigned char *iv,
-                               const OSSL_PARAM params[]);
-/*__owur*/ int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
-                                 int *outl, const unsigned char *in, int inl);
-/*__owur*/ int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out,
-                                   int *outl);
-/*__owur*/ int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out,
-                                int *outl);
-
-__owur int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
-                           const unsigned char *key, const unsigned char *iv);
-/*__owur*/ int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,
-                                  const EVP_CIPHER *cipher, ENGINE *impl,
-                                  const unsigned char *key,
-                                  const unsigned char *iv);
-__owur int EVP_DecryptInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
-                               const unsigned char *key,
-                               const unsigned char *iv,
-                               const OSSL_PARAM params[]);
-/*__owur*/ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
-                                 int *outl, const unsigned char *in, int inl);
-__owur int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
-                            int *outl);
-/*__owur*/ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
-                                   int *outl);
-
-__owur int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
-                          const unsigned char *key, const unsigned char *iv,
-                          int enc);
-/*__owur*/ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx,
-                                 const EVP_CIPHER *cipher, ENGINE *impl,
-                                 const unsigned char *key,
-                                 const unsigned char *iv, int enc);
-__owur int EVP_CipherInit_ex2(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
-                              const unsigned char *key, const unsigned char *iv,
-                              int enc, const OSSL_PARAM params[]);
-__owur int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
-                            int *outl, const unsigned char *in, int inl);
-__owur int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
-                           int *outl);
-__owur int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
-                              int *outl);
-
-__owur int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
-                         EVP_PKEY *pkey);
-__owur int EVP_SignFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
-                            EVP_PKEY *pkey, OSSL_LIB_CTX *libctx,
-                            const char *propq);
-
-__owur int EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret,
-                          size_t *siglen, const unsigned char *tbs,
-                          size_t tbslen);
-
-__owur int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
-                           unsigned int siglen, EVP_PKEY *pkey);
-__owur int EVP_VerifyFinal_ex(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
-                              unsigned int siglen, EVP_PKEY *pkey,
-                              OSSL_LIB_CTX *libctx, const char *propq);
-
-__owur int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret,
-                            size_t siglen, const unsigned char *tbs,
-                            size_t tbslen);
-
-int EVP_DigestSignInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
-                          const char *mdname, OSSL_LIB_CTX *libctx,
-                          const char *props, EVP_PKEY *pkey,
-                          const OSSL_PARAM params[]);
-/*__owur*/ int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
-                                  const EVP_MD *type, ENGINE *e,
-                                  EVP_PKEY *pkey);
-int EVP_DigestSignUpdate(EVP_MD_CTX *ctx, const void *data, size_t dsize);
-__owur int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
-                               size_t *siglen);
-
-int EVP_DigestVerifyInit_ex(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
-                            const char *mdname, OSSL_LIB_CTX *libctx,
-                            const char *props, EVP_PKEY *pkey,
-                            const OSSL_PARAM params[]);
-__owur int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
-                                const EVP_MD *type, ENGINE *e,
-                                EVP_PKEY *pkey);
-int EVP_DigestVerifyUpdate(EVP_MD_CTX *ctx, const void *data, size_t dsize);
-__owur int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
-                                 size_t siglen);
-
-__owur int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
-                        const unsigned char *ek, int ekl,
-                        const unsigned char *iv, EVP_PKEY *priv);
-__owur int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
-
-__owur int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
-                        unsigned char **ek, int *ekl, unsigned char *iv,
-                        EVP_PKEY **pubk, int npubk);
-__owur int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
-
-EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void);
-void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx);
-int EVP_ENCODE_CTX_copy(EVP_ENCODE_CTX *dctx, const EVP_ENCODE_CTX *sctx);
-int EVP_ENCODE_CTX_num(EVP_ENCODE_CTX *ctx);
-void EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
-int EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
-                     const unsigned char *in, int inl);
-void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl);
-int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);
-
-void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
-int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
-                     const unsigned char *in, int inl);
-int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned
-                    char *out, int *outl);
-int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n);
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define EVP_CIPHER_CTX_init(c)      EVP_CIPHER_CTX_reset(c)
-#  define EVP_CIPHER_CTX_cleanup(c)   EVP_CIPHER_CTX_reset(c)
-# endif
-EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
-int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *c);
-void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *c);
-int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
-int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad);
-int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
-int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);
-int EVP_CIPHER_get_params(EVP_CIPHER *cipher, OSSL_PARAM params[]);
-int EVP_CIPHER_CTX_set_params(EVP_CIPHER_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_CIPHER_CTX_get_params(EVP_CIPHER_CTX *ctx, OSSL_PARAM params[]);
-const OSSL_PARAM *EVP_CIPHER_gettable_params(const EVP_CIPHER *cipher);
-const OSSL_PARAM *EVP_CIPHER_settable_ctx_params(const EVP_CIPHER *cipher);
-const OSSL_PARAM *EVP_CIPHER_gettable_ctx_params(const EVP_CIPHER *cipher);
-const OSSL_PARAM *EVP_CIPHER_CTX_settable_params(EVP_CIPHER_CTX *ctx);
-const OSSL_PARAM *EVP_CIPHER_CTX_gettable_params(EVP_CIPHER_CTX *ctx);
-
-const BIO_METHOD *BIO_f_md(void);
-const BIO_METHOD *BIO_f_base64(void);
-const BIO_METHOD *BIO_f_cipher(void);
-const BIO_METHOD *BIO_f_reliable(void);
-__owur int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
-                          const unsigned char *i, int enc);
-
-const EVP_MD *EVP_md_null(void);
-# ifndef OPENSSL_NO_MD2
-const EVP_MD *EVP_md2(void);
-# endif
-# ifndef OPENSSL_NO_MD4
-const EVP_MD *EVP_md4(void);
-# endif
-# ifndef OPENSSL_NO_MD5
-const EVP_MD *EVP_md5(void);
-const EVP_MD *EVP_md5_sha1(void);
-# endif
-# ifndef OPENSSL_NO_BLAKE2
-const EVP_MD *EVP_blake2b512(void);
-const EVP_MD *EVP_blake2s256(void);
-# endif
-const EVP_MD *EVP_sha1(void);
-const EVP_MD *EVP_sha224(void);
-const EVP_MD *EVP_sha256(void);
-const EVP_MD *EVP_sha384(void);
-const EVP_MD *EVP_sha512(void);
-const EVP_MD *EVP_sha512_224(void);
-const EVP_MD *EVP_sha512_256(void);
-const EVP_MD *EVP_sha3_224(void);
-const EVP_MD *EVP_sha3_256(void);
-const EVP_MD *EVP_sha3_384(void);
-const EVP_MD *EVP_sha3_512(void);
-const EVP_MD *EVP_shake128(void);
-const EVP_MD *EVP_shake256(void);
-
-# ifndef OPENSSL_NO_MDC2
-const EVP_MD *EVP_mdc2(void);
-# endif
-# ifndef OPENSSL_NO_RMD160
-const EVP_MD *EVP_ripemd160(void);
-# endif
-# ifndef OPENSSL_NO_WHIRLPOOL
-const EVP_MD *EVP_whirlpool(void);
-# endif
-# ifndef OPENSSL_NO_SM3
-const EVP_MD *EVP_sm3(void);
-# endif
-const EVP_CIPHER *EVP_enc_null(void); /* does nothing :-) */
-# ifndef OPENSSL_NO_DES
-const EVP_CIPHER *EVP_des_ecb(void);
-const EVP_CIPHER *EVP_des_ede(void);
-const EVP_CIPHER *EVP_des_ede3(void);
-const EVP_CIPHER *EVP_des_ede_ecb(void);
-const EVP_CIPHER *EVP_des_ede3_ecb(void);
-const EVP_CIPHER *EVP_des_cfb64(void);
-#  define EVP_des_cfb EVP_des_cfb64
-const EVP_CIPHER *EVP_des_cfb1(void);
-const EVP_CIPHER *EVP_des_cfb8(void);
-const EVP_CIPHER *EVP_des_ede_cfb64(void);
-#  define EVP_des_ede_cfb EVP_des_ede_cfb64
-const EVP_CIPHER *EVP_des_ede3_cfb64(void);
-#  define EVP_des_ede3_cfb EVP_des_ede3_cfb64
-const EVP_CIPHER *EVP_des_ede3_cfb1(void);
-const EVP_CIPHER *EVP_des_ede3_cfb8(void);
-const EVP_CIPHER *EVP_des_ofb(void);
-const EVP_CIPHER *EVP_des_ede_ofb(void);
-const EVP_CIPHER *EVP_des_ede3_ofb(void);
-const EVP_CIPHER *EVP_des_cbc(void);
-const EVP_CIPHER *EVP_des_ede_cbc(void);
-const EVP_CIPHER *EVP_des_ede3_cbc(void);
-const EVP_CIPHER *EVP_desx_cbc(void);
-const EVP_CIPHER *EVP_des_ede3_wrap(void);
+#define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a))
+#define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a))
+#define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a))
+#define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a))
+
+    int EVP_MD_get_type(const EVP_MD* md);
+#define EVP_MD_type EVP_MD_get_type
+#define EVP_MD_nid EVP_MD_get_type
+    const char* EVP_MD_get0_name(const EVP_MD* md);
+#define EVP_MD_name EVP_MD_get0_name
+    const char* EVP_MD_get0_description(const EVP_MD* md);
+    int EVP_MD_is_a(const EVP_MD* md, const char* name);
+    int EVP_MD_names_do_all(const EVP_MD* md, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PROVIDER* EVP_MD_get0_provider(const EVP_MD* md);
+    int EVP_MD_get_pkey_type(const EVP_MD* md);
+#define EVP_MD_pkey_type EVP_MD_get_pkey_type
+    int EVP_MD_get_size(const EVP_MD* md);
+#define EVP_MD_size EVP_MD_get_size
+    int EVP_MD_get_block_size(const EVP_MD* md);
+#define EVP_MD_block_size EVP_MD_get_block_size
+    unsigned long EVP_MD_get_flags(const EVP_MD* md);
+#define EVP_MD_flags EVP_MD_get_flags
+
+    const EVP_MD* EVP_MD_CTX_get0_md(const EVP_MD_CTX* ctx);
+    EVP_MD* EVP_MD_CTX_get1_md(EVP_MD_CTX* ctx);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    const EVP_MD* EVP_MD_CTX_md(const EVP_MD_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0
+    int (*EVP_MD_CTX_update_fn(EVP_MD_CTX* ctx))(EVP_MD_CTX* ctx, const void* data, size_t count);
+    OSSL_DEPRECATEDIN_3_0
+    void EVP_MD_CTX_set_update_fn(EVP_MD_CTX* ctx, int (*update)(EVP_MD_CTX* ctx, const void* data, size_t count));
+#endif
+#define EVP_MD_CTX_get0_name(e) EVP_MD_get0_name(EVP_MD_CTX_get0_md(e))
+#define EVP_MD_CTX_get_size(e) EVP_MD_get_size(EVP_MD_CTX_get0_md(e))
+#define EVP_MD_CTX_size EVP_MD_CTX_get_size
+#define EVP_MD_CTX_get_block_size(e) EVP_MD_get_block_size(EVP_MD_CTX_get0_md(e))
+#define EVP_MD_CTX_block_size EVP_MD_CTX_get_block_size
+#define EVP_MD_CTX_get_type(e) EVP_MD_get_type(EVP_MD_CTX_get0_md(e))
+#define EVP_MD_CTX_type EVP_MD_CTX_get_type
+    EVP_PKEY_CTX* EVP_MD_CTX_get_pkey_ctx(const EVP_MD_CTX* ctx);
+#define EVP_MD_CTX_pkey_ctx EVP_MD_CTX_get_pkey_ctx
+    void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX* ctx, EVP_PKEY_CTX* pctx);
+    void* EVP_MD_CTX_get0_md_data(const EVP_MD_CTX* ctx);
+#define EVP_MD_CTX_md_data EVP_MD_CTX_get0_md_data
+
+    int EVP_CIPHER_get_nid(const EVP_CIPHER* cipher);
+#define EVP_CIPHER_nid EVP_CIPHER_get_nid
+    const char* EVP_CIPHER_get0_name(const EVP_CIPHER* cipher);
+#define EVP_CIPHER_name EVP_CIPHER_get0_name
+    const char* EVP_CIPHER_get0_description(const EVP_CIPHER* cipher);
+    int EVP_CIPHER_is_a(const EVP_CIPHER* cipher, const char* name);
+    int EVP_CIPHER_names_do_all(const EVP_CIPHER* cipher, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PROVIDER* EVP_CIPHER_get0_provider(const EVP_CIPHER* cipher);
+    int EVP_CIPHER_get_block_size(const EVP_CIPHER* cipher);
+#define EVP_CIPHER_block_size EVP_CIPHER_get_block_size
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER* cipher);
+#endif
+    int EVP_CIPHER_get_key_length(const EVP_CIPHER* cipher);
+#define EVP_CIPHER_key_length EVP_CIPHER_get_key_length
+    int EVP_CIPHER_get_iv_length(const EVP_CIPHER* cipher);
+#define EVP_CIPHER_iv_length EVP_CIPHER_get_iv_length
+    unsigned long EVP_CIPHER_get_flags(const EVP_CIPHER* cipher);
+#define EVP_CIPHER_flags EVP_CIPHER_get_flags
+    int EVP_CIPHER_get_mode(const EVP_CIPHER* cipher);
+#define EVP_CIPHER_mode EVP_CIPHER_get_mode
+    int EVP_CIPHER_get_type(const EVP_CIPHER* cipher);
+#define EVP_CIPHER_type EVP_CIPHER_get_type
+    EVP_CIPHER* EVP_CIPHER_fetch(OSSL_LIB_CTX* ctx, const char* algorithm, const char* properties);
+    int EVP_CIPHER_up_ref(EVP_CIPHER* cipher);
+    void EVP_CIPHER_free(EVP_CIPHER* cipher);
+
+    const EVP_CIPHER* EVP_CIPHER_CTX_get0_cipher(const EVP_CIPHER_CTX* ctx);
+    EVP_CIPHER* EVP_CIPHER_CTX_get1_cipher(EVP_CIPHER_CTX* ctx);
+    int EVP_CIPHER_CTX_is_encrypting(const EVP_CIPHER_CTX* ctx);
+#define EVP_CIPHER_CTX_encrypting EVP_CIPHER_CTX_is_encrypting
+    int EVP_CIPHER_CTX_get_nid(const EVP_CIPHER_CTX* ctx);
+#define EVP_CIPHER_CTX_nid EVP_CIPHER_CTX_get_nid
+    int EVP_CIPHER_CTX_get_block_size(const EVP_CIPHER_CTX* ctx);
+#define EVP_CIPHER_CTX_block_size EVP_CIPHER_CTX_get_block_size
+    int EVP_CIPHER_CTX_get_key_length(const EVP_CIPHER_CTX* ctx);
+#define EVP_CIPHER_CTX_key_length EVP_CIPHER_CTX_get_key_length
+    int EVP_CIPHER_CTX_get_iv_length(const EVP_CIPHER_CTX* ctx);
+#define EVP_CIPHER_CTX_iv_length EVP_CIPHER_CTX_get_iv_length
+    int EVP_CIPHER_CTX_get_tag_length(const EVP_CIPHER_CTX* ctx);
+#define EVP_CIPHER_CTX_tag_length EVP_CIPHER_CTX_get_tag_length
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    const EVP_CIPHER* EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 const unsigned char* EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 const unsigned char* EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 unsigned char* EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX* ctx);
+#endif
+    int EVP_CIPHER_CTX_get_updated_iv(EVP_CIPHER_CTX* ctx, void* buf, size_t len);
+    int EVP_CIPHER_CTX_get_original_iv(EVP_CIPHER_CTX* ctx, void* buf, size_t len);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    unsigned char* EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX* ctx);
+#endif
+    int EVP_CIPHER_CTX_get_num(const EVP_CIPHER_CTX* ctx);
+#define EVP_CIPHER_CTX_num EVP_CIPHER_CTX_get_num
+    int EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX* ctx, int num);
+    int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX* out, const EVP_CIPHER_CTX* in);
+    void* EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX* ctx);
+    void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX* ctx, void* data);
+    void* EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX* ctx);
+    void* EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX* ctx, void* cipher_data);
+#define EVP_CIPHER_CTX_get0_name(c) EVP_CIPHER_get0_name(EVP_CIPHER_CTX_get0_cipher(c))
+#define EVP_CIPHER_CTX_get_type(c) EVP_CIPHER_get_type(EVP_CIPHER_CTX_get0_cipher(c))
+#define EVP_CIPHER_CTX_type EVP_CIPHER_CTX_get_type
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define EVP_CIPHER_CTX_flags(c) EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(c))
+#endif
+#define EVP_CIPHER_CTX_get_mode(c) EVP_CIPHER_get_mode(EVP_CIPHER_CTX_get0_cipher(c))
+#define EVP_CIPHER_CTX_mode EVP_CIPHER_CTX_get_mode
+
+#define EVP_ENCODE_LENGTH(l) ((((l) + 2) / 3 * 4) + ((l) / 48 + 1) * 2 + 80)
+#define EVP_DECODE_LENGTH(l) (((l) + 3) / 4 * 3 + 80)
+
+#define EVP_SignInit_ex(a, b, c) EVP_DigestInit_ex(a, b, c)
+#define EVP_SignInit(a, b) EVP_DigestInit(a, b)
+#define EVP_SignUpdate(a, b, c) EVP_DigestUpdate(a, b, c)
+#define EVP_VerifyInit_ex(a, b, c) EVP_DigestInit_ex(a, b, c)
+#define EVP_VerifyInit(a, b) EVP_DigestInit(a, b)
+#define EVP_VerifyUpdate(a, b, c) EVP_DigestUpdate(a, b, c)
+#define EVP_OpenUpdate(a, b, c, d, e) EVP_DecryptUpdate(a, b, c, d, e)
+#define EVP_SealUpdate(a, b, c, d, e) EVP_EncryptUpdate(a, b, c, d, e)
+
+#ifdef CONST_STRICT
+    void BIO_set_md(BIO*, const EVP_MD* md);
+#else
+#define BIO_set_md(b, md) BIO_ctrl(b, BIO_C_SET_MD, 0, (void*)(md))
+#endif
+#define BIO_get_md(b, mdp) BIO_ctrl(b, BIO_C_GET_MD, 0, (mdp))
+#define BIO_get_md_ctx(b, mdcp) BIO_ctrl(b, BIO_C_GET_MD_CTX, 0, (mdcp))
+#define BIO_set_md_ctx(b, mdcp) BIO_ctrl(b, BIO_C_SET_MD_CTX, 0, (mdcp))
+#define BIO_get_cipher_status(b) BIO_ctrl(b, BIO_C_GET_CIPHER_STATUS, 0, NULL)
+#define BIO_get_cipher_ctx(b, c_pp) BIO_ctrl(b, BIO_C_GET_CIPHER_CTX, 0, (c_pp))
+
+    /*__owur*/ int EVP_Cipher(EVP_CIPHER_CTX* c, unsigned char* out, const unsigned char* in, unsigned int inl);
+
+#define EVP_add_cipher_alias(n, alias) \
+    OBJ_NAME_add((alias), OBJ_NAME_TYPE_CIPHER_METH | OBJ_NAME_ALIAS, (n))
+#define EVP_add_digest_alias(n, alias) \
+    OBJ_NAME_add((alias), OBJ_NAME_TYPE_MD_METH | OBJ_NAME_ALIAS, (n))
+#define EVP_delete_cipher_alias(alias) \
+    OBJ_NAME_remove(alias, OBJ_NAME_TYPE_CIPHER_METH | OBJ_NAME_ALIAS);
+#define EVP_delete_digest_alias(alias) \
+    OBJ_NAME_remove(alias, OBJ_NAME_TYPE_MD_METH | OBJ_NAME_ALIAS);
+
+    int EVP_MD_get_params(const EVP_MD* digest, OSSL_PARAM params[]);
+    int EVP_MD_CTX_set_params(EVP_MD_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_MD_CTX_get_params(EVP_MD_CTX* ctx, OSSL_PARAM params[]);
+    const OSSL_PARAM* EVP_MD_gettable_params(const EVP_MD* digest);
+    const OSSL_PARAM* EVP_MD_settable_ctx_params(const EVP_MD* md);
+    const OSSL_PARAM* EVP_MD_gettable_ctx_params(const EVP_MD* md);
+    const OSSL_PARAM* EVP_MD_CTX_settable_params(EVP_MD_CTX* ctx);
+    const OSSL_PARAM* EVP_MD_CTX_gettable_params(EVP_MD_CTX* ctx);
+    int EVP_MD_CTX_ctrl(EVP_MD_CTX* ctx, int cmd, int p1, void* p2);
+    EVP_MD_CTX* EVP_MD_CTX_new(void);
+    int EVP_MD_CTX_reset(EVP_MD_CTX* ctx);
+    void EVP_MD_CTX_free(EVP_MD_CTX* ctx);
+#define EVP_MD_CTX_create() EVP_MD_CTX_new()
+#define EVP_MD_CTX_init(ctx) EVP_MD_CTX_reset((ctx))
+#define EVP_MD_CTX_destroy(ctx) EVP_MD_CTX_free((ctx))
+    __owur int EVP_MD_CTX_copy_ex(EVP_MD_CTX* out, const EVP_MD_CTX* in);
+    void EVP_MD_CTX_set_flags(EVP_MD_CTX* ctx, int flags);
+    void EVP_MD_CTX_clear_flags(EVP_MD_CTX* ctx, int flags);
+    int EVP_MD_CTX_test_flags(const EVP_MD_CTX* ctx, int flags);
+    __owur int EVP_DigestInit_ex2(EVP_MD_CTX* ctx, const EVP_MD* type, const OSSL_PARAM params[]);
+    __owur int EVP_DigestInit_ex(EVP_MD_CTX* ctx, const EVP_MD* type, ENGINE* impl);
+    __owur int EVP_DigestUpdate(EVP_MD_CTX* ctx, const void* d, size_t cnt);
+    __owur int EVP_DigestFinal_ex(EVP_MD_CTX* ctx, unsigned char* md, unsigned int* s);
+    __owur int EVP_Digest(const void* data, size_t count, unsigned char* md, unsigned int* size, const EVP_MD* type, ENGINE* impl);
+    __owur int EVP_Q_digest(OSSL_LIB_CTX* libctx, const char* name, const char* propq, const void* data, size_t datalen, unsigned char* md, size_t* mdlen);
+
+    __owur int EVP_MD_CTX_copy(EVP_MD_CTX* out, const EVP_MD_CTX* in);
+    __owur int EVP_DigestInit(EVP_MD_CTX* ctx, const EVP_MD* type);
+    __owur int EVP_DigestFinal(EVP_MD_CTX* ctx, unsigned char* md, unsigned int* s);
+    __owur int EVP_DigestFinalXOF(EVP_MD_CTX* ctx, unsigned char* md, size_t len);
+
+    __owur EVP_MD* EVP_MD_fetch(OSSL_LIB_CTX* ctx, const char* algorithm, const char* properties);
+
+    int EVP_MD_up_ref(EVP_MD* md);
+    void EVP_MD_free(EVP_MD* md);
+
+    int EVP_read_pw_string(char* buf, int length, const char* prompt, int verify);
+    int EVP_read_pw_string_min(char* buf, int minlen, int maxlen, const char* prompt, int verify);
+    void EVP_set_pw_prompt(const char* prompt);
+    char* EVP_get_pw_prompt(void);
+
+    __owur int EVP_BytesToKey(const EVP_CIPHER* type, const EVP_MD* md, const unsigned char* salt, const unsigned char* data, int datal, int count, unsigned char* key, unsigned char* iv);
+
+    void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX* ctx, int flags);
+    void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX* ctx, int flags);
+    int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX* ctx, int flags);
+
+    __owur int EVP_EncryptInit(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, const unsigned char* key, const unsigned char* iv);
+    /*__owur*/ int EVP_EncryptInit_ex(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, ENGINE* impl, const unsigned char* key, const unsigned char* iv);
+    __owur int EVP_EncryptInit_ex2(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, const unsigned char* key, const unsigned char* iv, const OSSL_PARAM params[]);
+    /*__owur*/ int EVP_EncryptUpdate(EVP_CIPHER_CTX* ctx, unsigned char* out, int* outl, const unsigned char* in, int inl);
+    /*__owur*/ int EVP_EncryptFinal_ex(EVP_CIPHER_CTX* ctx, unsigned char* out, int* outl);
+    /*__owur*/ int EVP_EncryptFinal(EVP_CIPHER_CTX* ctx, unsigned char* out, int* outl);
+
+    __owur int EVP_DecryptInit(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, const unsigned char* key, const unsigned char* iv);
+    /*__owur*/ int EVP_DecryptInit_ex(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, ENGINE* impl, const unsigned char* key, const unsigned char* iv);
+    __owur int EVP_DecryptInit_ex2(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, const unsigned char* key, const unsigned char* iv, const OSSL_PARAM params[]);
+    /*__owur*/ int EVP_DecryptUpdate(EVP_CIPHER_CTX* ctx, unsigned char* out, int* outl, const unsigned char* in, int inl);
+    __owur int EVP_DecryptFinal(EVP_CIPHER_CTX* ctx, unsigned char* outm, int* outl);
+    /*__owur*/ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX* ctx, unsigned char* outm, int* outl);
+
+    __owur int EVP_CipherInit(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, const unsigned char* key, const unsigned char* iv, int enc);
+    /*__owur*/ int EVP_CipherInit_ex(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, ENGINE* impl, const unsigned char* key, const unsigned char* iv, int enc);
+    __owur int EVP_CipherInit_ex2(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* cipher, const unsigned char* key, const unsigned char* iv, int enc, const OSSL_PARAM params[]);
+    __owur int EVP_CipherUpdate(EVP_CIPHER_CTX* ctx, unsigned char* out, int* outl, const unsigned char* in, int inl);
+    __owur int EVP_CipherFinal(EVP_CIPHER_CTX* ctx, unsigned char* outm, int* outl);
+    __owur int EVP_CipherFinal_ex(EVP_CIPHER_CTX* ctx, unsigned char* outm, int* outl);
+
+    __owur int EVP_SignFinal(EVP_MD_CTX* ctx, unsigned char* md, unsigned int* s, EVP_PKEY* pkey);
+    __owur int EVP_SignFinal_ex(EVP_MD_CTX* ctx, unsigned char* md, unsigned int* s, EVP_PKEY* pkey, OSSL_LIB_CTX* libctx, const char* propq);
+
+    __owur int EVP_DigestSign(EVP_MD_CTX* ctx, unsigned char* sigret, size_t* siglen, const unsigned char* tbs, size_t tbslen);
+
+    __owur int EVP_VerifyFinal(EVP_MD_CTX* ctx, const unsigned char* sigbuf, unsigned int siglen, EVP_PKEY* pkey);
+    __owur int EVP_VerifyFinal_ex(EVP_MD_CTX* ctx, const unsigned char* sigbuf, unsigned int siglen, EVP_PKEY* pkey, OSSL_LIB_CTX* libctx, const char* propq);
+
+    __owur int EVP_DigestVerify(EVP_MD_CTX* ctx, const unsigned char* sigret, size_t siglen, const unsigned char* tbs, size_t tbslen);
+
+    int EVP_DigestSignInit_ex(EVP_MD_CTX* ctx, EVP_PKEY_CTX** pctx, const char* mdname, OSSL_LIB_CTX* libctx, const char* props, EVP_PKEY* pkey, const OSSL_PARAM params[]);
+    /*__owur*/ int EVP_DigestSignInit(EVP_MD_CTX* ctx, EVP_PKEY_CTX** pctx, const EVP_MD* type, ENGINE* e, EVP_PKEY* pkey);
+    int EVP_DigestSignUpdate(EVP_MD_CTX* ctx, const void* data, size_t dsize);
+    __owur int EVP_DigestSignFinal(EVP_MD_CTX* ctx, unsigned char* sigret, size_t* siglen);
+
+    int EVP_DigestVerifyInit_ex(EVP_MD_CTX* ctx, EVP_PKEY_CTX** pctx, const char* mdname, OSSL_LIB_CTX* libctx, const char* props, EVP_PKEY* pkey, const OSSL_PARAM params[]);
+    __owur int EVP_DigestVerifyInit(EVP_MD_CTX* ctx, EVP_PKEY_CTX** pctx, const EVP_MD* type, ENGINE* e, EVP_PKEY* pkey);
+    int EVP_DigestVerifyUpdate(EVP_MD_CTX* ctx, const void* data, size_t dsize);
+    __owur int EVP_DigestVerifyFinal(EVP_MD_CTX* ctx, const unsigned char* sig, size_t siglen);
+
+    __owur int EVP_OpenInit(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* type, const unsigned char* ek, int ekl, const unsigned char* iv, EVP_PKEY* priv);
+    __owur int EVP_OpenFinal(EVP_CIPHER_CTX* ctx, unsigned char* out, int* outl);
+
+    __owur int EVP_SealInit(EVP_CIPHER_CTX* ctx, const EVP_CIPHER* type, unsigned char** ek, int* ekl, unsigned char* iv, EVP_PKEY** pubk, int npubk);
+    __owur int EVP_SealFinal(EVP_CIPHER_CTX* ctx, unsigned char* out, int* outl);
+
+    EVP_ENCODE_CTX* EVP_ENCODE_CTX_new(void);
+    void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX* ctx);
+    int EVP_ENCODE_CTX_copy(EVP_ENCODE_CTX* dctx, const EVP_ENCODE_CTX* sctx);
+    int EVP_ENCODE_CTX_num(EVP_ENCODE_CTX* ctx);
+    void EVP_EncodeInit(EVP_ENCODE_CTX* ctx);
+    int EVP_EncodeUpdate(EVP_ENCODE_CTX* ctx, unsigned char* out, int* outl, const unsigned char* in, int inl);
+    void EVP_EncodeFinal(EVP_ENCODE_CTX* ctx, unsigned char* out, int* outl);
+    int EVP_EncodeBlock(unsigned char* t, const unsigned char* f, int n);
+
+    void EVP_DecodeInit(EVP_ENCODE_CTX* ctx);
+    int EVP_DecodeUpdate(EVP_ENCODE_CTX* ctx, unsigned char* out, int* outl, const unsigned char* in, int inl);
+    int EVP_DecodeFinal(EVP_ENCODE_CTX* ctx, unsigned char* out, int* outl);
+    int EVP_DecodeBlock(unsigned char* t, const unsigned char* f, int n);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define EVP_CIPHER_CTX_init(c) EVP_CIPHER_CTX_reset(c)
+#define EVP_CIPHER_CTX_cleanup(c) EVP_CIPHER_CTX_reset(c)
+#endif
+    EVP_CIPHER_CTX* EVP_CIPHER_CTX_new(void);
+    int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX* c);
+    void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX* c);
+    int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX* x, int keylen);
+    int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX* c, int pad);
+    int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX* ctx, int type, int arg, void* ptr);
+    int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX* ctx, unsigned char* key);
+    int EVP_CIPHER_get_params(EVP_CIPHER* cipher, OSSL_PARAM params[]);
+    int EVP_CIPHER_CTX_set_params(EVP_CIPHER_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_CIPHER_CTX_get_params(EVP_CIPHER_CTX* ctx, OSSL_PARAM params[]);
+    const OSSL_PARAM* EVP_CIPHER_gettable_params(const EVP_CIPHER* cipher);
+    const OSSL_PARAM* EVP_CIPHER_settable_ctx_params(const EVP_CIPHER* cipher);
+    const OSSL_PARAM* EVP_CIPHER_gettable_ctx_params(const EVP_CIPHER* cipher);
+    const OSSL_PARAM* EVP_CIPHER_CTX_settable_params(EVP_CIPHER_CTX* ctx);
+    const OSSL_PARAM* EVP_CIPHER_CTX_gettable_params(EVP_CIPHER_CTX* ctx);
+
+    const BIO_METHOD* BIO_f_md(void);
+    const BIO_METHOD* BIO_f_base64(void);
+    const BIO_METHOD* BIO_f_cipher(void);
+    const BIO_METHOD* BIO_f_reliable(void);
+    __owur int BIO_set_cipher(BIO* b, const EVP_CIPHER* c, const unsigned char* k, const unsigned char* i, int enc);
+
+    const EVP_MD* EVP_md_null(void);
+#ifndef OPENSSL_NO_MD2
+    const EVP_MD* EVP_md2(void);
+#endif
+#ifndef OPENSSL_NO_MD4
+    const EVP_MD* EVP_md4(void);
+#endif
+#ifndef OPENSSL_NO_MD5
+    const EVP_MD* EVP_md5(void);
+    const EVP_MD* EVP_md5_sha1(void);
+#endif
+#ifndef OPENSSL_NO_BLAKE2
+    const EVP_MD* EVP_blake2b512(void);
+    const EVP_MD* EVP_blake2s256(void);
+#endif
+    const EVP_MD* EVP_sha1(void);
+    const EVP_MD* EVP_sha224(void);
+    const EVP_MD* EVP_sha256(void);
+    const EVP_MD* EVP_sha384(void);
+    const EVP_MD* EVP_sha512(void);
+    const EVP_MD* EVP_sha512_224(void);
+    const EVP_MD* EVP_sha512_256(void);
+    const EVP_MD* EVP_sha3_224(void);
+    const EVP_MD* EVP_sha3_256(void);
+    const EVP_MD* EVP_sha3_384(void);
+    const EVP_MD* EVP_sha3_512(void);
+    const EVP_MD* EVP_shake128(void);
+    const EVP_MD* EVP_shake256(void);
+
+#ifndef OPENSSL_NO_MDC2
+    const EVP_MD* EVP_mdc2(void);
+#endif
+#ifndef OPENSSL_NO_RMD160
+    const EVP_MD* EVP_ripemd160(void);
+#endif
+#ifndef OPENSSL_NO_WHIRLPOOL
+    const EVP_MD* EVP_whirlpool(void);
+#endif
+#ifndef OPENSSL_NO_SM3
+    const EVP_MD* EVP_sm3(void);
+#endif
+    const EVP_CIPHER* EVP_enc_null(void); /* does nothing :-) */
+#ifndef OPENSSL_NO_DES
+    const EVP_CIPHER* EVP_des_ecb(void);
+    const EVP_CIPHER* EVP_des_ede(void);
+    const EVP_CIPHER* EVP_des_ede3(void);
+    const EVP_CIPHER* EVP_des_ede_ecb(void);
+    const EVP_CIPHER* EVP_des_ede3_ecb(void);
+    const EVP_CIPHER* EVP_des_cfb64(void);
+#define EVP_des_cfb EVP_des_cfb64
+    const EVP_CIPHER* EVP_des_cfb1(void);
+    const EVP_CIPHER* EVP_des_cfb8(void);
+    const EVP_CIPHER* EVP_des_ede_cfb64(void);
+#define EVP_des_ede_cfb EVP_des_ede_cfb64
+    const EVP_CIPHER* EVP_des_ede3_cfb64(void);
+#define EVP_des_ede3_cfb EVP_des_ede3_cfb64
+    const EVP_CIPHER* EVP_des_ede3_cfb1(void);
+    const EVP_CIPHER* EVP_des_ede3_cfb8(void);
+    const EVP_CIPHER* EVP_des_ofb(void);
+    const EVP_CIPHER* EVP_des_ede_ofb(void);
+    const EVP_CIPHER* EVP_des_ede3_ofb(void);
+    const EVP_CIPHER* EVP_des_cbc(void);
+    const EVP_CIPHER* EVP_des_ede_cbc(void);
+    const EVP_CIPHER* EVP_des_ede3_cbc(void);
+    const EVP_CIPHER* EVP_desx_cbc(void);
+    const EVP_CIPHER* EVP_des_ede3_wrap(void);
 /*
  * This should now be supported through the dev_crypto ENGINE. But also, why
  * are rc4 and md5 declarations made here inside a "NO_DES" precompiler
  * branch?
  */
-# endif
-# ifndef OPENSSL_NO_RC4
-const EVP_CIPHER *EVP_rc4(void);
-const EVP_CIPHER *EVP_rc4_40(void);
-#  ifndef OPENSSL_NO_MD5
-const EVP_CIPHER *EVP_rc4_hmac_md5(void);
-#  endif
-# endif
-# ifndef OPENSSL_NO_IDEA
-const EVP_CIPHER *EVP_idea_ecb(void);
-const EVP_CIPHER *EVP_idea_cfb64(void);
-#  define EVP_idea_cfb EVP_idea_cfb64
-const EVP_CIPHER *EVP_idea_ofb(void);
-const EVP_CIPHER *EVP_idea_cbc(void);
-# endif
-# ifndef OPENSSL_NO_RC2
-const EVP_CIPHER *EVP_rc2_ecb(void);
-const EVP_CIPHER *EVP_rc2_cbc(void);
-const EVP_CIPHER *EVP_rc2_40_cbc(void);
-const EVP_CIPHER *EVP_rc2_64_cbc(void);
-const EVP_CIPHER *EVP_rc2_cfb64(void);
-#  define EVP_rc2_cfb EVP_rc2_cfb64
-const EVP_CIPHER *EVP_rc2_ofb(void);
-# endif
-# ifndef OPENSSL_NO_BF
-const EVP_CIPHER *EVP_bf_ecb(void);
-const EVP_CIPHER *EVP_bf_cbc(void);
-const EVP_CIPHER *EVP_bf_cfb64(void);
-#  define EVP_bf_cfb EVP_bf_cfb64
-const EVP_CIPHER *EVP_bf_ofb(void);
-# endif
-# ifndef OPENSSL_NO_CAST
-const EVP_CIPHER *EVP_cast5_ecb(void);
-const EVP_CIPHER *EVP_cast5_cbc(void);
-const EVP_CIPHER *EVP_cast5_cfb64(void);
-#  define EVP_cast5_cfb EVP_cast5_cfb64
-const EVP_CIPHER *EVP_cast5_ofb(void);
-# endif
-# ifndef OPENSSL_NO_RC5
-const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void);
-const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void);
-const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void);
-#  define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64
-const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void);
-# endif
-const EVP_CIPHER *EVP_aes_128_ecb(void);
-const EVP_CIPHER *EVP_aes_128_cbc(void);
-const EVP_CIPHER *EVP_aes_128_cfb1(void);
-const EVP_CIPHER *EVP_aes_128_cfb8(void);
-const EVP_CIPHER *EVP_aes_128_cfb128(void);
-# define EVP_aes_128_cfb EVP_aes_128_cfb128
-const EVP_CIPHER *EVP_aes_128_ofb(void);
-const EVP_CIPHER *EVP_aes_128_ctr(void);
-const EVP_CIPHER *EVP_aes_128_ccm(void);
-const EVP_CIPHER *EVP_aes_128_gcm(void);
-const EVP_CIPHER *EVP_aes_128_xts(void);
-const EVP_CIPHER *EVP_aes_128_wrap(void);
-const EVP_CIPHER *EVP_aes_128_wrap_pad(void);
-# ifndef OPENSSL_NO_OCB
-const EVP_CIPHER *EVP_aes_128_ocb(void);
-# endif
-const EVP_CIPHER *EVP_aes_192_ecb(void);
-const EVP_CIPHER *EVP_aes_192_cbc(void);
-const EVP_CIPHER *EVP_aes_192_cfb1(void);
-const EVP_CIPHER *EVP_aes_192_cfb8(void);
-const EVP_CIPHER *EVP_aes_192_cfb128(void);
-# define EVP_aes_192_cfb EVP_aes_192_cfb128
-const EVP_CIPHER *EVP_aes_192_ofb(void);
-const EVP_CIPHER *EVP_aes_192_ctr(void);
-const EVP_CIPHER *EVP_aes_192_ccm(void);
-const EVP_CIPHER *EVP_aes_192_gcm(void);
-const EVP_CIPHER *EVP_aes_192_wrap(void);
-const EVP_CIPHER *EVP_aes_192_wrap_pad(void);
-# ifndef OPENSSL_NO_OCB
-const EVP_CIPHER *EVP_aes_192_ocb(void);
-# endif
-const EVP_CIPHER *EVP_aes_256_ecb(void);
-const EVP_CIPHER *EVP_aes_256_cbc(void);
-const EVP_CIPHER *EVP_aes_256_cfb1(void);
-const EVP_CIPHER *EVP_aes_256_cfb8(void);
-const EVP_CIPHER *EVP_aes_256_cfb128(void);
-# define EVP_aes_256_cfb EVP_aes_256_cfb128
-const EVP_CIPHER *EVP_aes_256_ofb(void);
-const EVP_CIPHER *EVP_aes_256_ctr(void);
-const EVP_CIPHER *EVP_aes_256_ccm(void);
-const EVP_CIPHER *EVP_aes_256_gcm(void);
-const EVP_CIPHER *EVP_aes_256_xts(void);
-const EVP_CIPHER *EVP_aes_256_wrap(void);
-const EVP_CIPHER *EVP_aes_256_wrap_pad(void);
-# ifndef OPENSSL_NO_OCB
-const EVP_CIPHER *EVP_aes_256_ocb(void);
-# endif
-const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void);
-const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void);
-const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha256(void);
-const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha256(void);
-# ifndef OPENSSL_NO_ARIA
-const EVP_CIPHER *EVP_aria_128_ecb(void);
-const EVP_CIPHER *EVP_aria_128_cbc(void);
-const EVP_CIPHER *EVP_aria_128_cfb1(void);
-const EVP_CIPHER *EVP_aria_128_cfb8(void);
-const EVP_CIPHER *EVP_aria_128_cfb128(void);
-#  define EVP_aria_128_cfb EVP_aria_128_cfb128
-const EVP_CIPHER *EVP_aria_128_ctr(void);
-const EVP_CIPHER *EVP_aria_128_ofb(void);
-const EVP_CIPHER *EVP_aria_128_gcm(void);
-const EVP_CIPHER *EVP_aria_128_ccm(void);
-const EVP_CIPHER *EVP_aria_192_ecb(void);
-const EVP_CIPHER *EVP_aria_192_cbc(void);
-const EVP_CIPHER *EVP_aria_192_cfb1(void);
-const EVP_CIPHER *EVP_aria_192_cfb8(void);
-const EVP_CIPHER *EVP_aria_192_cfb128(void);
-#  define EVP_aria_192_cfb EVP_aria_192_cfb128
-const EVP_CIPHER *EVP_aria_192_ctr(void);
-const EVP_CIPHER *EVP_aria_192_ofb(void);
-const EVP_CIPHER *EVP_aria_192_gcm(void);
-const EVP_CIPHER *EVP_aria_192_ccm(void);
-const EVP_CIPHER *EVP_aria_256_ecb(void);
-const EVP_CIPHER *EVP_aria_256_cbc(void);
-const EVP_CIPHER *EVP_aria_256_cfb1(void);
-const EVP_CIPHER *EVP_aria_256_cfb8(void);
-const EVP_CIPHER *EVP_aria_256_cfb128(void);
-#  define EVP_aria_256_cfb EVP_aria_256_cfb128
-const EVP_CIPHER *EVP_aria_256_ctr(void);
-const EVP_CIPHER *EVP_aria_256_ofb(void);
-const EVP_CIPHER *EVP_aria_256_gcm(void);
-const EVP_CIPHER *EVP_aria_256_ccm(void);
-# endif
-# ifndef OPENSSL_NO_CAMELLIA
-const EVP_CIPHER *EVP_camellia_128_ecb(void);
-const EVP_CIPHER *EVP_camellia_128_cbc(void);
-const EVP_CIPHER *EVP_camellia_128_cfb1(void);
-const EVP_CIPHER *EVP_camellia_128_cfb8(void);
-const EVP_CIPHER *EVP_camellia_128_cfb128(void);
-#  define EVP_camellia_128_cfb EVP_camellia_128_cfb128
-const EVP_CIPHER *EVP_camellia_128_ofb(void);
-const EVP_CIPHER *EVP_camellia_128_ctr(void);
-const EVP_CIPHER *EVP_camellia_192_ecb(void);
-const EVP_CIPHER *EVP_camellia_192_cbc(void);
-const EVP_CIPHER *EVP_camellia_192_cfb1(void);
-const EVP_CIPHER *EVP_camellia_192_cfb8(void);
-const EVP_CIPHER *EVP_camellia_192_cfb128(void);
-#  define EVP_camellia_192_cfb EVP_camellia_192_cfb128
-const EVP_CIPHER *EVP_camellia_192_ofb(void);
-const EVP_CIPHER *EVP_camellia_192_ctr(void);
-const EVP_CIPHER *EVP_camellia_256_ecb(void);
-const EVP_CIPHER *EVP_camellia_256_cbc(void);
-const EVP_CIPHER *EVP_camellia_256_cfb1(void);
-const EVP_CIPHER *EVP_camellia_256_cfb8(void);
-const EVP_CIPHER *EVP_camellia_256_cfb128(void);
-#  define EVP_camellia_256_cfb EVP_camellia_256_cfb128
-const EVP_CIPHER *EVP_camellia_256_ofb(void);
-const EVP_CIPHER *EVP_camellia_256_ctr(void);
-# endif
-# ifndef OPENSSL_NO_CHACHA
-const EVP_CIPHER *EVP_chacha20(void);
-#  ifndef OPENSSL_NO_POLY1305
-const EVP_CIPHER *EVP_chacha20_poly1305(void);
-#  endif
-# endif
-
-# ifndef OPENSSL_NO_SEED
-const EVP_CIPHER *EVP_seed_ecb(void);
-const EVP_CIPHER *EVP_seed_cbc(void);
-const EVP_CIPHER *EVP_seed_cfb128(void);
-#  define EVP_seed_cfb EVP_seed_cfb128
-const EVP_CIPHER *EVP_seed_ofb(void);
-# endif
-
-# ifndef OPENSSL_NO_SM4
-const EVP_CIPHER *EVP_sm4_ecb(void);
-const EVP_CIPHER *EVP_sm4_cbc(void);
-const EVP_CIPHER *EVP_sm4_cfb128(void);
-#  define EVP_sm4_cfb EVP_sm4_cfb128
-const EVP_CIPHER *EVP_sm4_ofb(void);
-const EVP_CIPHER *EVP_sm4_ctr(void);
-# endif
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define OPENSSL_add_all_algorithms_conf() \
-    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \
-                        | OPENSSL_INIT_ADD_ALL_DIGESTS \
-                        | OPENSSL_INIT_LOAD_CONFIG, NULL)
-#  define OPENSSL_add_all_algorithms_noconf() \
-    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \
-                        | OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
-
-#  ifdef OPENSSL_LOAD_CONF
-#   define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_conf()
-#  else
-#   define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_noconf()
-#  endif
-
-#  define OpenSSL_add_all_ciphers() \
+#endif
+#ifndef OPENSSL_NO_RC4
+    const EVP_CIPHER* EVP_rc4(void);
+    const EVP_CIPHER* EVP_rc4_40(void);
+#ifndef OPENSSL_NO_MD5
+    const EVP_CIPHER* EVP_rc4_hmac_md5(void);
+#endif
+#endif
+#ifndef OPENSSL_NO_IDEA
+    const EVP_CIPHER* EVP_idea_ecb(void);
+    const EVP_CIPHER* EVP_idea_cfb64(void);
+#define EVP_idea_cfb EVP_idea_cfb64
+    const EVP_CIPHER* EVP_idea_ofb(void);
+    const EVP_CIPHER* EVP_idea_cbc(void);
+#endif
+#ifndef OPENSSL_NO_RC2
+    const EVP_CIPHER* EVP_rc2_ecb(void);
+    const EVP_CIPHER* EVP_rc2_cbc(void);
+    const EVP_CIPHER* EVP_rc2_40_cbc(void);
+    const EVP_CIPHER* EVP_rc2_64_cbc(void);
+    const EVP_CIPHER* EVP_rc2_cfb64(void);
+#define EVP_rc2_cfb EVP_rc2_cfb64
+    const EVP_CIPHER* EVP_rc2_ofb(void);
+#endif
+#ifndef OPENSSL_NO_BF
+    const EVP_CIPHER* EVP_bf_ecb(void);
+    const EVP_CIPHER* EVP_bf_cbc(void);
+    const EVP_CIPHER* EVP_bf_cfb64(void);
+#define EVP_bf_cfb EVP_bf_cfb64
+    const EVP_CIPHER* EVP_bf_ofb(void);
+#endif
+#ifndef OPENSSL_NO_CAST
+    const EVP_CIPHER* EVP_cast5_ecb(void);
+    const EVP_CIPHER* EVP_cast5_cbc(void);
+    const EVP_CIPHER* EVP_cast5_cfb64(void);
+#define EVP_cast5_cfb EVP_cast5_cfb64
+    const EVP_CIPHER* EVP_cast5_ofb(void);
+#endif
+#ifndef OPENSSL_NO_RC5
+    const EVP_CIPHER* EVP_rc5_32_12_16_cbc(void);
+    const EVP_CIPHER* EVP_rc5_32_12_16_ecb(void);
+    const EVP_CIPHER* EVP_rc5_32_12_16_cfb64(void);
+#define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64
+    const EVP_CIPHER* EVP_rc5_32_12_16_ofb(void);
+#endif
+    const EVP_CIPHER* EVP_aes_128_ecb(void);
+    const EVP_CIPHER* EVP_aes_128_cbc(void);
+    const EVP_CIPHER* EVP_aes_128_cfb1(void);
+    const EVP_CIPHER* EVP_aes_128_cfb8(void);
+    const EVP_CIPHER* EVP_aes_128_cfb128(void);
+#define EVP_aes_128_cfb EVP_aes_128_cfb128
+    const EVP_CIPHER* EVP_aes_128_ofb(void);
+    const EVP_CIPHER* EVP_aes_128_ctr(void);
+    const EVP_CIPHER* EVP_aes_128_ccm(void);
+    const EVP_CIPHER* EVP_aes_128_gcm(void);
+    const EVP_CIPHER* EVP_aes_128_xts(void);
+    const EVP_CIPHER* EVP_aes_128_wrap(void);
+    const EVP_CIPHER* EVP_aes_128_wrap_pad(void);
+#ifndef OPENSSL_NO_OCB
+    const EVP_CIPHER* EVP_aes_128_ocb(void);
+#endif
+    const EVP_CIPHER* EVP_aes_192_ecb(void);
+    const EVP_CIPHER* EVP_aes_192_cbc(void);
+    const EVP_CIPHER* EVP_aes_192_cfb1(void);
+    const EVP_CIPHER* EVP_aes_192_cfb8(void);
+    const EVP_CIPHER* EVP_aes_192_cfb128(void);
+#define EVP_aes_192_cfb EVP_aes_192_cfb128
+    const EVP_CIPHER* EVP_aes_192_ofb(void);
+    const EVP_CIPHER* EVP_aes_192_ctr(void);
+    const EVP_CIPHER* EVP_aes_192_ccm(void);
+    const EVP_CIPHER* EVP_aes_192_gcm(void);
+    const EVP_CIPHER* EVP_aes_192_wrap(void);
+    const EVP_CIPHER* EVP_aes_192_wrap_pad(void);
+#ifndef OPENSSL_NO_OCB
+    const EVP_CIPHER* EVP_aes_192_ocb(void);
+#endif
+    const EVP_CIPHER* EVP_aes_256_ecb(void);
+    const EVP_CIPHER* EVP_aes_256_cbc(void);
+    const EVP_CIPHER* EVP_aes_256_cfb1(void);
+    const EVP_CIPHER* EVP_aes_256_cfb8(void);
+    const EVP_CIPHER* EVP_aes_256_cfb128(void);
+#define EVP_aes_256_cfb EVP_aes_256_cfb128
+    const EVP_CIPHER* EVP_aes_256_ofb(void);
+    const EVP_CIPHER* EVP_aes_256_ctr(void);
+    const EVP_CIPHER* EVP_aes_256_ccm(void);
+    const EVP_CIPHER* EVP_aes_256_gcm(void);
+    const EVP_CIPHER* EVP_aes_256_xts(void);
+    const EVP_CIPHER* EVP_aes_256_wrap(void);
+    const EVP_CIPHER* EVP_aes_256_wrap_pad(void);
+#ifndef OPENSSL_NO_OCB
+    const EVP_CIPHER* EVP_aes_256_ocb(void);
+#endif
+    const EVP_CIPHER* EVP_aes_128_cbc_hmac_sha1(void);
+    const EVP_CIPHER* EVP_aes_256_cbc_hmac_sha1(void);
+    const EVP_CIPHER* EVP_aes_128_cbc_hmac_sha256(void);
+    const EVP_CIPHER* EVP_aes_256_cbc_hmac_sha256(void);
+#ifndef OPENSSL_NO_ARIA
+    const EVP_CIPHER* EVP_aria_128_ecb(void);
+    const EVP_CIPHER* EVP_aria_128_cbc(void);
+    const EVP_CIPHER* EVP_aria_128_cfb1(void);
+    const EVP_CIPHER* EVP_aria_128_cfb8(void);
+    const EVP_CIPHER* EVP_aria_128_cfb128(void);
+#define EVP_aria_128_cfb EVP_aria_128_cfb128
+    const EVP_CIPHER* EVP_aria_128_ctr(void);
+    const EVP_CIPHER* EVP_aria_128_ofb(void);
+    const EVP_CIPHER* EVP_aria_128_gcm(void);
+    const EVP_CIPHER* EVP_aria_128_ccm(void);
+    const EVP_CIPHER* EVP_aria_192_ecb(void);
+    const EVP_CIPHER* EVP_aria_192_cbc(void);
+    const EVP_CIPHER* EVP_aria_192_cfb1(void);
+    const EVP_CIPHER* EVP_aria_192_cfb8(void);
+    const EVP_CIPHER* EVP_aria_192_cfb128(void);
+#define EVP_aria_192_cfb EVP_aria_192_cfb128
+    const EVP_CIPHER* EVP_aria_192_ctr(void);
+    const EVP_CIPHER* EVP_aria_192_ofb(void);
+    const EVP_CIPHER* EVP_aria_192_gcm(void);
+    const EVP_CIPHER* EVP_aria_192_ccm(void);
+    const EVP_CIPHER* EVP_aria_256_ecb(void);
+    const EVP_CIPHER* EVP_aria_256_cbc(void);
+    const EVP_CIPHER* EVP_aria_256_cfb1(void);
+    const EVP_CIPHER* EVP_aria_256_cfb8(void);
+    const EVP_CIPHER* EVP_aria_256_cfb128(void);
+#define EVP_aria_256_cfb EVP_aria_256_cfb128
+    const EVP_CIPHER* EVP_aria_256_ctr(void);
+    const EVP_CIPHER* EVP_aria_256_ofb(void);
+    const EVP_CIPHER* EVP_aria_256_gcm(void);
+    const EVP_CIPHER* EVP_aria_256_ccm(void);
+#endif
+#ifndef OPENSSL_NO_CAMELLIA
+    const EVP_CIPHER* EVP_camellia_128_ecb(void);
+    const EVP_CIPHER* EVP_camellia_128_cbc(void);
+    const EVP_CIPHER* EVP_camellia_128_cfb1(void);
+    const EVP_CIPHER* EVP_camellia_128_cfb8(void);
+    const EVP_CIPHER* EVP_camellia_128_cfb128(void);
+#define EVP_camellia_128_cfb EVP_camellia_128_cfb128
+    const EVP_CIPHER* EVP_camellia_128_ofb(void);
+    const EVP_CIPHER* EVP_camellia_128_ctr(void);
+    const EVP_CIPHER* EVP_camellia_192_ecb(void);
+    const EVP_CIPHER* EVP_camellia_192_cbc(void);
+    const EVP_CIPHER* EVP_camellia_192_cfb1(void);
+    const EVP_CIPHER* EVP_camellia_192_cfb8(void);
+    const EVP_CIPHER* EVP_camellia_192_cfb128(void);
+#define EVP_camellia_192_cfb EVP_camellia_192_cfb128
+    const EVP_CIPHER* EVP_camellia_192_ofb(void);
+    const EVP_CIPHER* EVP_camellia_192_ctr(void);
+    const EVP_CIPHER* EVP_camellia_256_ecb(void);
+    const EVP_CIPHER* EVP_camellia_256_cbc(void);
+    const EVP_CIPHER* EVP_camellia_256_cfb1(void);
+    const EVP_CIPHER* EVP_camellia_256_cfb8(void);
+    const EVP_CIPHER* EVP_camellia_256_cfb128(void);
+#define EVP_camellia_256_cfb EVP_camellia_256_cfb128
+    const EVP_CIPHER* EVP_camellia_256_ofb(void);
+    const EVP_CIPHER* EVP_camellia_256_ctr(void);
+#endif
+#ifndef OPENSSL_NO_CHACHA
+    const EVP_CIPHER* EVP_chacha20(void);
+#ifndef OPENSSL_NO_POLY1305
+    const EVP_CIPHER* EVP_chacha20_poly1305(void);
+#endif
+#endif
+
+#ifndef OPENSSL_NO_SEED
+    const EVP_CIPHER* EVP_seed_ecb(void);
+    const EVP_CIPHER* EVP_seed_cbc(void);
+    const EVP_CIPHER* EVP_seed_cfb128(void);
+#define EVP_seed_cfb EVP_seed_cfb128
+    const EVP_CIPHER* EVP_seed_ofb(void);
+#endif
+
+#ifndef OPENSSL_NO_SM4
+    const EVP_CIPHER* EVP_sm4_ecb(void);
+    const EVP_CIPHER* EVP_sm4_cbc(void);
+    const EVP_CIPHER* EVP_sm4_cfb128(void);
+#define EVP_sm4_cfb EVP_sm4_cfb128
+    const EVP_CIPHER* EVP_sm4_ofb(void);
+    const EVP_CIPHER* EVP_sm4_ctr(void);
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define OPENSSL_add_all_algorithms_conf() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS | OPENSSL_INIT_LOAD_CONFIG, NULL)
+#define OPENSSL_add_all_algorithms_noconf() \
+    OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
+
+#ifdef OPENSSL_LOAD_CONF
+#define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_conf()
+#else
+#define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_noconf()
+#endif
+
+#define OpenSSL_add_all_ciphers() \
     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL)
-#  define OpenSSL_add_all_digests() \
+#define OpenSSL_add_all_digests() \
     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL)
 
-#  define EVP_cleanup() while(0) continue
-# endif
-
-int EVP_add_cipher(const EVP_CIPHER *cipher);
-int EVP_add_digest(const EVP_MD *digest);
-
-const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
-const EVP_MD *EVP_get_digestbyname(const char *name);
-
-void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph,
-                                   const char *from, const char *to, void *x),
-                       void *arg);
-void EVP_CIPHER_do_all_sorted(void (*fn)
-                               (const EVP_CIPHER *ciph, const char *from,
-                                const char *to, void *x), void *arg);
-void EVP_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx,
-                                void (*fn)(EVP_CIPHER *cipher, void *arg),
-                                void *arg);
-
-void EVP_MD_do_all(void (*fn) (const EVP_MD *ciph,
-                               const char *from, const char *to, void *x),
-                   void *arg);
-void EVP_MD_do_all_sorted(void (*fn)
-                           (const EVP_MD *ciph, const char *from,
-                            const char *to, void *x), void *arg);
-void EVP_MD_do_all_provided(OSSL_LIB_CTX *libctx,
-                            void (*fn)(EVP_MD *md, void *arg),
-                            void *arg);
-
-/* MAC stuff */
-
-EVP_MAC *EVP_MAC_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
-                       const char *properties);
-int EVP_MAC_up_ref(EVP_MAC *mac);
-void EVP_MAC_free(EVP_MAC *mac);
-const char *EVP_MAC_get0_name(const EVP_MAC *mac);
-const char *EVP_MAC_get0_description(const EVP_MAC *mac);
-int EVP_MAC_is_a(const EVP_MAC *mac, const char *name);
-const OSSL_PROVIDER *EVP_MAC_get0_provider(const EVP_MAC *mac);
-int EVP_MAC_get_params(EVP_MAC *mac, OSSL_PARAM params[]);
-
-EVP_MAC_CTX *EVP_MAC_CTX_new(EVP_MAC *mac);
-void EVP_MAC_CTX_free(EVP_MAC_CTX *ctx);
-EVP_MAC_CTX *EVP_MAC_CTX_dup(const EVP_MAC_CTX *src);
-EVP_MAC *EVP_MAC_CTX_get0_mac(EVP_MAC_CTX *ctx);
-int EVP_MAC_CTX_get_params(EVP_MAC_CTX *ctx, OSSL_PARAM params[]);
-int EVP_MAC_CTX_set_params(EVP_MAC_CTX *ctx, const OSSL_PARAM params[]);
-
-size_t EVP_MAC_CTX_get_mac_size(EVP_MAC_CTX *ctx);
-size_t EVP_MAC_CTX_get_block_size(EVP_MAC_CTX *ctx);
-unsigned char *EVP_Q_mac(OSSL_LIB_CTX *libctx, const char *name, const char *propq,
-                         const char *subalg, const OSSL_PARAM *params,
-                         const void *key, size_t keylen,
-                         const unsigned char *data, size_t datalen,
-                         unsigned char *out, size_t outsize, size_t *outlen);
-int EVP_MAC_init(EVP_MAC_CTX *ctx, const unsigned char *key, size_t keylen,
-                 const OSSL_PARAM params[]);
-int EVP_MAC_update(EVP_MAC_CTX *ctx, const unsigned char *data, size_t datalen);
-int EVP_MAC_final(EVP_MAC_CTX *ctx,
-                  unsigned char *out, size_t *outl, size_t outsize);
-int EVP_MAC_finalXOF(EVP_MAC_CTX *ctx, unsigned char *out, size_t outsize);
-const OSSL_PARAM *EVP_MAC_gettable_params(const EVP_MAC *mac);
-const OSSL_PARAM *EVP_MAC_gettable_ctx_params(const EVP_MAC *mac);
-const OSSL_PARAM *EVP_MAC_settable_ctx_params(const EVP_MAC *mac);
-const OSSL_PARAM *EVP_MAC_CTX_gettable_params(EVP_MAC_CTX *ctx);
-const OSSL_PARAM *EVP_MAC_CTX_settable_params(EVP_MAC_CTX *ctx);
-
-void EVP_MAC_do_all_provided(OSSL_LIB_CTX *libctx,
-                             void (*fn)(EVP_MAC *mac, void *arg),
-                             void *arg);
-int EVP_MAC_names_do_all(const EVP_MAC *mac,
-                         void (*fn)(const char *name, void *data),
-                         void *data);
-
-/* RAND stuff */
-EVP_RAND *EVP_RAND_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
-                         const char *properties);
-int EVP_RAND_up_ref(EVP_RAND *rand);
-void EVP_RAND_free(EVP_RAND *rand);
-const char *EVP_RAND_get0_name(const EVP_RAND *rand);
-const char *EVP_RAND_get0_description(const EVP_RAND *md);
-int EVP_RAND_is_a(const EVP_RAND *rand, const char *name);
-const OSSL_PROVIDER *EVP_RAND_get0_provider(const EVP_RAND *rand);
-int EVP_RAND_get_params(EVP_RAND *rand, OSSL_PARAM params[]);
-
-EVP_RAND_CTX *EVP_RAND_CTX_new(EVP_RAND *rand, EVP_RAND_CTX *parent);
-void EVP_RAND_CTX_free(EVP_RAND_CTX *ctx);
-EVP_RAND *EVP_RAND_CTX_get0_rand(EVP_RAND_CTX *ctx);
-int EVP_RAND_CTX_get_params(EVP_RAND_CTX *ctx, OSSL_PARAM params[]);
-int EVP_RAND_CTX_set_params(EVP_RAND_CTX *ctx, const OSSL_PARAM params[]);
-const OSSL_PARAM *EVP_RAND_gettable_params(const EVP_RAND *rand);
-const OSSL_PARAM *EVP_RAND_gettable_ctx_params(const EVP_RAND *rand);
-const OSSL_PARAM *EVP_RAND_settable_ctx_params(const EVP_RAND *rand);
-const OSSL_PARAM *EVP_RAND_CTX_gettable_params(EVP_RAND_CTX *ctx);
-const OSSL_PARAM *EVP_RAND_CTX_settable_params(EVP_RAND_CTX *ctx);
-
-void EVP_RAND_do_all_provided(OSSL_LIB_CTX *libctx,
-                              void (*fn)(EVP_RAND *rand, void *arg),
-                              void *arg);
-int EVP_RAND_names_do_all(const EVP_RAND *rand,
-                          void (*fn)(const char *name, void *data),
-                          void *data);
-
-__owur int EVP_RAND_instantiate(EVP_RAND_CTX *ctx, unsigned int strength,
-                                int prediction_resistance,
-                                const unsigned char *pstr, size_t pstr_len,
-                                const OSSL_PARAM params[]);
-int EVP_RAND_uninstantiate(EVP_RAND_CTX *ctx);
-__owur int EVP_RAND_generate(EVP_RAND_CTX *ctx, unsigned char *out,
-                             size_t outlen, unsigned int strength,
-                             int prediction_resistance,
-                             const unsigned char *addin, size_t addin_len);
-int EVP_RAND_reseed(EVP_RAND_CTX *ctx, int prediction_resistance,
-                    const unsigned char *ent, size_t ent_len,
-                    const unsigned char *addin, size_t addin_len);
-__owur int EVP_RAND_nonce(EVP_RAND_CTX *ctx, unsigned char *out, size_t outlen);
-__owur int EVP_RAND_enable_locking(EVP_RAND_CTX *ctx);
-
-int EVP_RAND_verify_zeroization(EVP_RAND_CTX *ctx);
-unsigned int EVP_RAND_get_strength(EVP_RAND_CTX *ctx);
-int EVP_RAND_get_state(EVP_RAND_CTX *ctx);
-
-# define EVP_RAND_STATE_UNINITIALISED    0
-# define EVP_RAND_STATE_READY            1
-# define EVP_RAND_STATE_ERROR            2
+#define EVP_cleanup() \
+    while (0)         \
+    continue
+#endif
+
+    int EVP_add_cipher(const EVP_CIPHER* cipher);
+    int EVP_add_digest(const EVP_MD* digest);
+
+    const EVP_CIPHER* EVP_get_cipherbyname(const char* name);
+    const EVP_MD* EVP_get_digestbyname(const char* name);
+
+    void EVP_CIPHER_do_all(void (*fn)(const EVP_CIPHER* ciph, const char* from, const char* to, void* x), void* arg);
+    void EVP_CIPHER_do_all_sorted(void (*fn)(const EVP_CIPHER* ciph, const char* from, const char* to, void* x), void* arg);
+    void EVP_CIPHER_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_CIPHER* cipher, void* arg), void* arg);
+
+    void EVP_MD_do_all(void (*fn)(const EVP_MD* ciph, const char* from, const char* to, void* x), void* arg);
+    void EVP_MD_do_all_sorted(void (*fn)(const EVP_MD* ciph, const char* from, const char* to, void* x), void* arg);
+    void EVP_MD_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_MD* md, void* arg), void* arg);
+
+    /* MAC stuff */
+
+    EVP_MAC* EVP_MAC_fetch(OSSL_LIB_CTX* libctx, const char* algorithm, const char* properties);
+    int EVP_MAC_up_ref(EVP_MAC* mac);
+    void EVP_MAC_free(EVP_MAC* mac);
+    const char* EVP_MAC_get0_name(const EVP_MAC* mac);
+    const char* EVP_MAC_get0_description(const EVP_MAC* mac);
+    int EVP_MAC_is_a(const EVP_MAC* mac, const char* name);
+    const OSSL_PROVIDER* EVP_MAC_get0_provider(const EVP_MAC* mac);
+    int EVP_MAC_get_params(EVP_MAC* mac, OSSL_PARAM params[]);
+
+    EVP_MAC_CTX* EVP_MAC_CTX_new(EVP_MAC* mac);
+    void EVP_MAC_CTX_free(EVP_MAC_CTX* ctx);
+    EVP_MAC_CTX* EVP_MAC_CTX_dup(const EVP_MAC_CTX* src);
+    EVP_MAC* EVP_MAC_CTX_get0_mac(EVP_MAC_CTX* ctx);
+    int EVP_MAC_CTX_get_params(EVP_MAC_CTX* ctx, OSSL_PARAM params[]);
+    int EVP_MAC_CTX_set_params(EVP_MAC_CTX* ctx, const OSSL_PARAM params[]);
+
+    size_t EVP_MAC_CTX_get_mac_size(EVP_MAC_CTX* ctx);
+    size_t EVP_MAC_CTX_get_block_size(EVP_MAC_CTX* ctx);
+    unsigned char* EVP_Q_mac(OSSL_LIB_CTX* libctx, const char* name, const char* propq, const char* subalg, const OSSL_PARAM* params, const void* key, size_t keylen, const unsigned char* data, size_t datalen, unsigned char* out, size_t outsize, size_t* outlen);
+    int EVP_MAC_init(EVP_MAC_CTX* ctx, const unsigned char* key, size_t keylen, const OSSL_PARAM params[]);
+    int EVP_MAC_update(EVP_MAC_CTX* ctx, const unsigned char* data, size_t datalen);
+    int EVP_MAC_final(EVP_MAC_CTX* ctx, unsigned char* out, size_t* outl, size_t outsize);
+    int EVP_MAC_finalXOF(EVP_MAC_CTX* ctx, unsigned char* out, size_t outsize);
+    const OSSL_PARAM* EVP_MAC_gettable_params(const EVP_MAC* mac);
+    const OSSL_PARAM* EVP_MAC_gettable_ctx_params(const EVP_MAC* mac);
+    const OSSL_PARAM* EVP_MAC_settable_ctx_params(const EVP_MAC* mac);
+    const OSSL_PARAM* EVP_MAC_CTX_gettable_params(EVP_MAC_CTX* ctx);
+    const OSSL_PARAM* EVP_MAC_CTX_settable_params(EVP_MAC_CTX* ctx);
+
+    void EVP_MAC_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_MAC* mac, void* arg), void* arg);
+    int EVP_MAC_names_do_all(const EVP_MAC* mac, void (*fn)(const char* name, void* data), void* data);
+
+    /* RAND stuff */
+    EVP_RAND* EVP_RAND_fetch(OSSL_LIB_CTX* libctx, const char* algorithm, const char* properties);
+    int EVP_RAND_up_ref(EVP_RAND* rand);
+    void EVP_RAND_free(EVP_RAND* rand);
+    const char* EVP_RAND_get0_name(const EVP_RAND* rand);
+    const char* EVP_RAND_get0_description(const EVP_RAND* md);
+    int EVP_RAND_is_a(const EVP_RAND* rand, const char* name);
+    const OSSL_PROVIDER* EVP_RAND_get0_provider(const EVP_RAND* rand);
+    int EVP_RAND_get_params(EVP_RAND* rand, OSSL_PARAM params[]);
+
+    EVP_RAND_CTX* EVP_RAND_CTX_new(EVP_RAND* rand, EVP_RAND_CTX* parent);
+    void EVP_RAND_CTX_free(EVP_RAND_CTX* ctx);
+    EVP_RAND* EVP_RAND_CTX_get0_rand(EVP_RAND_CTX* ctx);
+    int EVP_RAND_CTX_get_params(EVP_RAND_CTX* ctx, OSSL_PARAM params[]);
+    int EVP_RAND_CTX_set_params(EVP_RAND_CTX* ctx, const OSSL_PARAM params[]);
+    const OSSL_PARAM* EVP_RAND_gettable_params(const EVP_RAND* rand);
+    const OSSL_PARAM* EVP_RAND_gettable_ctx_params(const EVP_RAND* rand);
+    const OSSL_PARAM* EVP_RAND_settable_ctx_params(const EVP_RAND* rand);
+    const OSSL_PARAM* EVP_RAND_CTX_gettable_params(EVP_RAND_CTX* ctx);
+    const OSSL_PARAM* EVP_RAND_CTX_settable_params(EVP_RAND_CTX* ctx);
+
+    void EVP_RAND_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_RAND* rand, void* arg), void* arg);
+    int EVP_RAND_names_do_all(const EVP_RAND* rand, void (*fn)(const char* name, void* data), void* data);
+
+    __owur int EVP_RAND_instantiate(EVP_RAND_CTX* ctx, unsigned int strength, int prediction_resistance, const unsigned char* pstr, size_t pstr_len, const OSSL_PARAM params[]);
+    int EVP_RAND_uninstantiate(EVP_RAND_CTX* ctx);
+    __owur int EVP_RAND_generate(EVP_RAND_CTX* ctx, unsigned char* out, size_t outlen, unsigned int strength, int prediction_resistance, const unsigned char* addin, size_t addin_len);
+    int EVP_RAND_reseed(EVP_RAND_CTX* ctx, int prediction_resistance, const unsigned char* ent, size_t ent_len, const unsigned char* addin, size_t addin_len);
+    __owur int EVP_RAND_nonce(EVP_RAND_CTX* ctx, unsigned char* out, size_t outlen);
+    __owur int EVP_RAND_enable_locking(EVP_RAND_CTX* ctx);
+
+    int EVP_RAND_verify_zeroization(EVP_RAND_CTX* ctx);
+    unsigned int EVP_RAND_get_strength(EVP_RAND_CTX* ctx);
+    int EVP_RAND_get_state(EVP_RAND_CTX* ctx);
+
+#define EVP_RAND_STATE_UNINITIALISED 0
+#define EVP_RAND_STATE_READY 1
+#define EVP_RAND_STATE_ERROR 2
 
 /* PKEY stuff */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_decrypt_old(unsigned char *dec_key,
-                                          const unsigned char *enc_key,
-                                          int enc_key_len,
-                                          EVP_PKEY *private_key);
-OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_encrypt_old(unsigned char *enc_key,
-                                          const unsigned char *key,
-                                          int key_len, EVP_PKEY *pub_key);
-# endif
-int EVP_PKEY_is_a(const EVP_PKEY *pkey, const char *name);
-int EVP_PKEY_type_names_do_all(const EVP_PKEY *pkey,
-                               void (*fn)(const char *name, void *data),
-                               void *data);
-int EVP_PKEY_type(int type);
-int EVP_PKEY_get_id(const EVP_PKEY *pkey);
-# define EVP_PKEY_id EVP_PKEY_get_id
-int EVP_PKEY_get_base_id(const EVP_PKEY *pkey);
-# define EVP_PKEY_base_id EVP_PKEY_get_base_id
-int EVP_PKEY_get_bits(const EVP_PKEY *pkey);
-# define EVP_PKEY_bits EVP_PKEY_get_bits
-int EVP_PKEY_get_security_bits(const EVP_PKEY *pkey);
-# define EVP_PKEY_security_bits EVP_PKEY_get_security_bits
-int EVP_PKEY_get_size(const EVP_PKEY *pkey);
-# define EVP_PKEY_size EVP_PKEY_get_size
-int EVP_PKEY_can_sign(const EVP_PKEY *pkey);
-int EVP_PKEY_set_type(EVP_PKEY *pkey, int type);
-int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len);
-int EVP_PKEY_set_type_by_keymgmt(EVP_PKEY *pkey, EVP_KEYMGMT *keymgmt);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifndef OPENSSL_NO_ENGINE
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e);
-OSSL_DEPRECATEDIN_3_0
-ENGINE *EVP_PKEY_get0_engine(const EVP_PKEY *pkey);
-#  endif
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key);
-OSSL_DEPRECATEDIN_3_0
-void *EVP_PKEY_get0(const EVP_PKEY *pkey);
-OSSL_DEPRECATEDIN_3_0
-const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len);
-#  ifndef OPENSSL_NO_POLY1305
-OSSL_DEPRECATEDIN_3_0
-const unsigned char *EVP_PKEY_get0_poly1305(const EVP_PKEY *pkey, size_t *len);
-#  endif
-#  ifndef OPENSSL_NO_SIPHASH
-OSSL_DEPRECATEDIN_3_0
-const unsigned char *EVP_PKEY_get0_siphash(const EVP_PKEY *pkey, size_t *len);
-#  endif
-
-struct rsa_st;
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key);
-OSSL_DEPRECATEDIN_3_0
-const struct rsa_st *EVP_PKEY_get0_RSA(const EVP_PKEY *pkey);
-OSSL_DEPRECATEDIN_3_0
-struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
-
-#  ifndef OPENSSL_NO_DSA
-struct dsa_st;
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key);
-OSSL_DEPRECATEDIN_3_0
-const struct dsa_st *EVP_PKEY_get0_DSA(const EVP_PKEY *pkey);
-OSSL_DEPRECATEDIN_3_0
-struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
-#  endif
-
-#  ifndef OPENSSL_NO_DH
-struct dh_st;
-OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key);
-OSSL_DEPRECATEDIN_3_0 const struct dh_st *EVP_PKEY_get0_DH(const EVP_PKEY *pkey);
-OSSL_DEPRECATEDIN_3_0 struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
-#  endif
-
-#  ifndef OPENSSL_NO_EC
-struct ec_key_st;
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key);
-OSSL_DEPRECATEDIN_3_0
-const struct ec_key_st *EVP_PKEY_get0_EC_KEY(const EVP_PKEY *pkey);
-OSSL_DEPRECATEDIN_3_0
-struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
-#  endif
-# endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-EVP_PKEY *EVP_PKEY_new(void);
-int EVP_PKEY_up_ref(EVP_PKEY *pkey);
-EVP_PKEY *EVP_PKEY_dup(EVP_PKEY *pkey);
-void EVP_PKEY_free(EVP_PKEY *pkey);
-const char *EVP_PKEY_get0_description(const EVP_PKEY *pkey);
-const OSSL_PROVIDER *EVP_PKEY_get0_provider(const EVP_PKEY *key);
-
-EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp,
-                        long length);
-int i2d_PublicKey(const EVP_PKEY *a, unsigned char **pp);
-
-
-EVP_PKEY *d2i_PrivateKey_ex(int type, EVP_PKEY **a, const unsigned char **pp,
-                            long length, OSSL_LIB_CTX *libctx,
-                            const char *propq);
-EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp,
-                         long length);
-EVP_PKEY *d2i_AutoPrivateKey_ex(EVP_PKEY **a, const unsigned char **pp,
-                                long length, OSSL_LIB_CTX *libctx,
-                                const char *propq);
-EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp,
-                             long length);
-int i2d_PrivateKey(const EVP_PKEY *a, unsigned char **pp);
-
-int i2d_KeyParams(const EVP_PKEY *a, unsigned char **pp);
-EVP_PKEY *d2i_KeyParams(int type, EVP_PKEY **a, const unsigned char **pp,
-                        long length);
-int i2d_KeyParams_bio(BIO *bp, const EVP_PKEY *pkey);
-EVP_PKEY *d2i_KeyParams_bio(int type, EVP_PKEY **a, BIO *in);
-
-int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from);
-int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey);
-int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode);
-int EVP_PKEY_parameters_eq(const EVP_PKEY *a, const EVP_PKEY *b);
-int EVP_PKEY_eq(const EVP_PKEY *a, const EVP_PKEY *b);
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b);
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b);
-# endif
-
-int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
-                          int indent, ASN1_PCTX *pctx);
-int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
-                           int indent, ASN1_PCTX *pctx);
-int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
-                          int indent, ASN1_PCTX *pctx);
-# ifndef OPENSSL_NO_STDIO
-int EVP_PKEY_print_public_fp(FILE *fp, const EVP_PKEY *pkey,
-                             int indent, ASN1_PCTX *pctx);
-int EVP_PKEY_print_private_fp(FILE *fp, const EVP_PKEY *pkey,
-                              int indent, ASN1_PCTX *pctx);
-int EVP_PKEY_print_params_fp(FILE *fp, const EVP_PKEY *pkey,
-                             int indent, ASN1_PCTX *pctx);
-# endif
-
-int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid);
-int EVP_PKEY_get_default_digest_name(EVP_PKEY *pkey,
-                                     char *mdname, size_t mdname_sz);
-int EVP_PKEY_digestsign_supports_digest(EVP_PKEY *pkey, OSSL_LIB_CTX *libctx,
-                                        const char *name, const char *propq);
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_decrypt_old(unsigned char* dec_key, const unsigned char* enc_key, int enc_key_len, EVP_PKEY* private_key);
+    OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_encrypt_old(unsigned char* enc_key, const unsigned char* key, int key_len, EVP_PKEY* pub_key);
+#endif
+    int EVP_PKEY_is_a(const EVP_PKEY* pkey, const char* name);
+    int EVP_PKEY_type_names_do_all(const EVP_PKEY* pkey, void (*fn)(const char* name, void* data), void* data);
+    int EVP_PKEY_type(int type);
+    int EVP_PKEY_get_id(const EVP_PKEY* pkey);
+#define EVP_PKEY_id EVP_PKEY_get_id
+    int EVP_PKEY_get_base_id(const EVP_PKEY* pkey);
+#define EVP_PKEY_base_id EVP_PKEY_get_base_id
+    int EVP_PKEY_get_bits(const EVP_PKEY* pkey);
+#define EVP_PKEY_bits EVP_PKEY_get_bits
+    int EVP_PKEY_get_security_bits(const EVP_PKEY* pkey);
+#define EVP_PKEY_security_bits EVP_PKEY_get_security_bits
+    int EVP_PKEY_get_size(const EVP_PKEY* pkey);
+#define EVP_PKEY_size EVP_PKEY_get_size
+    int EVP_PKEY_can_sign(const EVP_PKEY* pkey);
+    int EVP_PKEY_set_type(EVP_PKEY* pkey, int type);
+    int EVP_PKEY_set_type_str(EVP_PKEY* pkey, const char* str, int len);
+    int EVP_PKEY_set_type_by_keymgmt(EVP_PKEY* pkey, EVP_KEYMGMT* keymgmt);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_ENGINE
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_set1_engine(EVP_PKEY* pkey, ENGINE* e);
+    OSSL_DEPRECATEDIN_3_0
+    ENGINE* EVP_PKEY_get0_engine(const EVP_PKEY* pkey);
+#endif
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_assign(EVP_PKEY* pkey, int type, void* key);
+    OSSL_DEPRECATEDIN_3_0
+    void* EVP_PKEY_get0(const EVP_PKEY* pkey);
+    OSSL_DEPRECATEDIN_3_0
+    const unsigned char* EVP_PKEY_get0_hmac(const EVP_PKEY* pkey, size_t* len);
+#ifndef OPENSSL_NO_POLY1305
+    OSSL_DEPRECATEDIN_3_0
+    const unsigned char* EVP_PKEY_get0_poly1305(const EVP_PKEY* pkey, size_t* len);
+#endif
+#ifndef OPENSSL_NO_SIPHASH
+    OSSL_DEPRECATEDIN_3_0
+    const unsigned char* EVP_PKEY_get0_siphash(const EVP_PKEY* pkey, size_t* len);
+#endif
+
+    struct rsa_st;
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_set1_RSA(EVP_PKEY* pkey, struct rsa_st* key);
+    OSSL_DEPRECATEDIN_3_0
+    const struct rsa_st* EVP_PKEY_get0_RSA(const EVP_PKEY* pkey);
+    OSSL_DEPRECATEDIN_3_0
+    struct rsa_st* EVP_PKEY_get1_RSA(EVP_PKEY* pkey);
+
+#ifndef OPENSSL_NO_DSA
+    struct dsa_st;
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_set1_DSA(EVP_PKEY* pkey, struct dsa_st* key);
+    OSSL_DEPRECATEDIN_3_0
+    const struct dsa_st* EVP_PKEY_get0_DSA(const EVP_PKEY* pkey);
+    OSSL_DEPRECATEDIN_3_0
+    struct dsa_st* EVP_PKEY_get1_DSA(EVP_PKEY* pkey);
+#endif
+
+#ifndef OPENSSL_NO_DH
+    struct dh_st;
+    OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_set1_DH(EVP_PKEY* pkey, struct dh_st* key);
+    OSSL_DEPRECATEDIN_3_0 const struct dh_st* EVP_PKEY_get0_DH(const EVP_PKEY* pkey);
+    OSSL_DEPRECATEDIN_3_0 struct dh_st* EVP_PKEY_get1_DH(EVP_PKEY* pkey);
+#endif
+
+#ifndef OPENSSL_NO_EC
+    struct ec_key_st;
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_set1_EC_KEY(EVP_PKEY* pkey, struct ec_key_st* key);
+    OSSL_DEPRECATEDIN_3_0
+    const struct ec_key_st* EVP_PKEY_get0_EC_KEY(const EVP_PKEY* pkey);
+    OSSL_DEPRECATEDIN_3_0
+    struct ec_key_st* EVP_PKEY_get1_EC_KEY(EVP_PKEY* pkey);
+#endif
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    EVP_PKEY* EVP_PKEY_new(void);
+    int EVP_PKEY_up_ref(EVP_PKEY* pkey);
+    EVP_PKEY* EVP_PKEY_dup(EVP_PKEY* pkey);
+    void EVP_PKEY_free(EVP_PKEY* pkey);
+    const char* EVP_PKEY_get0_description(const EVP_PKEY* pkey);
+    const OSSL_PROVIDER* EVP_PKEY_get0_provider(const EVP_PKEY* key);
+
+    EVP_PKEY* d2i_PublicKey(int type, EVP_PKEY** a, const unsigned char** pp, long length);
+    int i2d_PublicKey(const EVP_PKEY* a, unsigned char** pp);
+
+    EVP_PKEY* d2i_PrivateKey_ex(int type, EVP_PKEY** a, const unsigned char** pp, long length, OSSL_LIB_CTX* libctx, const char* propq);
+    EVP_PKEY* d2i_PrivateKey(int type, EVP_PKEY** a, const unsigned char** pp, long length);
+    EVP_PKEY* d2i_AutoPrivateKey_ex(EVP_PKEY** a, const unsigned char** pp, long length, OSSL_LIB_CTX* libctx, const char* propq);
+    EVP_PKEY* d2i_AutoPrivateKey(EVP_PKEY** a, const unsigned char** pp, long length);
+    int i2d_PrivateKey(const EVP_PKEY* a, unsigned char** pp);
+
+    int i2d_KeyParams(const EVP_PKEY* a, unsigned char** pp);
+    EVP_PKEY* d2i_KeyParams(int type, EVP_PKEY** a, const unsigned char** pp, long length);
+    int i2d_KeyParams_bio(BIO* bp, const EVP_PKEY* pkey);
+    EVP_PKEY* d2i_KeyParams_bio(int type, EVP_PKEY** a, BIO* in);
+
+    int EVP_PKEY_copy_parameters(EVP_PKEY* to, const EVP_PKEY* from);
+    int EVP_PKEY_missing_parameters(const EVP_PKEY* pkey);
+    int EVP_PKEY_save_parameters(EVP_PKEY* pkey, int mode);
+    int EVP_PKEY_parameters_eq(const EVP_PKEY* a, const EVP_PKEY* b);
+    int EVP_PKEY_eq(const EVP_PKEY* a, const EVP_PKEY* b);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_cmp_parameters(const EVP_PKEY* a, const EVP_PKEY* b);
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_cmp(const EVP_PKEY* a, const EVP_PKEY* b);
+#endif
+
+    int EVP_PKEY_print_public(BIO* out, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx);
+    int EVP_PKEY_print_private(BIO* out, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx);
+    int EVP_PKEY_print_params(BIO* out, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx);
+#ifndef OPENSSL_NO_STDIO
+    int EVP_PKEY_print_public_fp(FILE* fp, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx);
+    int EVP_PKEY_print_private_fp(FILE* fp, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx);
+    int EVP_PKEY_print_params_fp(FILE* fp, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx);
+#endif
+
+    int EVP_PKEY_get_default_digest_nid(EVP_PKEY* pkey, int* pnid);
+    int EVP_PKEY_get_default_digest_name(EVP_PKEY* pkey, char* mdname, size_t mdname_sz);
+    int EVP_PKEY_digestsign_supports_digest(EVP_PKEY* pkey, OSSL_LIB_CTX* libctx, const char* name, const char* propq);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 /*
  * For backwards compatibility. Use EVP_PKEY_set1_encoded_public_key in
  * preference
  */
-#  define EVP_PKEY_set1_tls_encodedpoint(pkey, pt, ptlen) \
-          EVP_PKEY_set1_encoded_public_key((pkey), (pt), (ptlen))
-# endif
+#define EVP_PKEY_set1_tls_encodedpoint(pkey, pt, ptlen) \
+    EVP_PKEY_set1_encoded_public_key((pkey), (pt), (ptlen))
+#endif
 
-int EVP_PKEY_set1_encoded_public_key(EVP_PKEY *pkey,
-                                     const unsigned char *pub, size_t publen);
+    int EVP_PKEY_set1_encoded_public_key(EVP_PKEY* pkey, const unsigned char* pub, size_t publen);
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 /*
  * For backwards compatibility. Use EVP_PKEY_get1_encoded_public_key in
  * preference
  */
-#  define EVP_PKEY_get1_tls_encodedpoint(pkey, ppt) \
-          EVP_PKEY_get1_encoded_public_key((pkey), (ppt))
-# endif
-
-size_t EVP_PKEY_get1_encoded_public_key(EVP_PKEY *pkey, unsigned char **ppub);
-
-/* calls methods */
-int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
-int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
-
-/* These are used by EVP_CIPHER methods */
-int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
-int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
-
-/* PKCS5 password based encryption */
-int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
-                       ASN1_TYPE *param, const EVP_CIPHER *cipher,
-                       const EVP_MD *md, int en_de);
-int PKCS5_PBE_keyivgen_ex(EVP_CIPHER_CTX *cctx, const char *pass, int passlen,
-                          ASN1_TYPE *param, const EVP_CIPHER *cipher,
-                          const EVP_MD *md, int en_de, OSSL_LIB_CTX *libctx,
-                          const char *propq);
-int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
-                           const unsigned char *salt, int saltlen, int iter,
-                           int keylen, unsigned char *out);
-int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
-                      const unsigned char *salt, int saltlen, int iter,
-                      const EVP_MD *digest, int keylen, unsigned char *out);
-int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
-                          ASN1_TYPE *param, const EVP_CIPHER *cipher,
-                          const EVP_MD *md, int en_de);
-int PKCS5_v2_PBE_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
-                             ASN1_TYPE *param, const EVP_CIPHER *cipher,
-                             const EVP_MD *md, int en_de,
-                             OSSL_LIB_CTX *libctx, const char *propq);
+#define EVP_PKEY_get1_tls_encodedpoint(pkey, ppt) \
+    EVP_PKEY_get1_encoded_public_key((pkey), (ppt))
+#endif
+
+    size_t EVP_PKEY_get1_encoded_public_key(EVP_PKEY* pkey, unsigned char** ppub);
+
+    /* calls methods */
+    int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX* c, ASN1_TYPE* type);
+    int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX* c, ASN1_TYPE* type);
+
+    /* These are used by EVP_CIPHER methods */
+    int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX* c, ASN1_TYPE* type);
+    int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX* c, ASN1_TYPE* type);
+
+    /* PKCS5 password based encryption */
+    int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* cipher, const EVP_MD* md, int en_de);
+    int PKCS5_PBE_keyivgen_ex(EVP_CIPHER_CTX* cctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* cipher, const EVP_MD* md, int en_de, OSSL_LIB_CTX* libctx, const char* propq);
+    int PKCS5_PBKDF2_HMAC_SHA1(const char* pass, int passlen, const unsigned char* salt, int saltlen, int iter, int keylen, unsigned char* out);
+    int PKCS5_PBKDF2_HMAC(const char* pass, int passlen, const unsigned char* salt, int saltlen, int iter, const EVP_MD* digest, int keylen, unsigned char* out);
+    int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* cipher, const EVP_MD* md, int en_de);
+    int PKCS5_v2_PBE_keyivgen_ex(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* cipher, const EVP_MD* md, int en_de, OSSL_LIB_CTX* libctx, const char* propq);
 
 #ifndef OPENSSL_NO_SCRYPT
-int EVP_PBE_scrypt(const char *pass, size_t passlen,
-                   const unsigned char *salt, size_t saltlen,
-                   uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem,
-                   unsigned char *key, size_t keylen);
-int EVP_PBE_scrypt_ex(const char *pass, size_t passlen,
-                      const unsigned char *salt, size_t saltlen,
-                      uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem,
-                      unsigned char *key, size_t keylen,
-                      OSSL_LIB_CTX *ctx, const char *propq);
-
-int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
-                             int passlen, ASN1_TYPE *param,
-                             const EVP_CIPHER *c, const EVP_MD *md, int en_de);
-int PKCS5_v2_scrypt_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass,
-                                int passlen, ASN1_TYPE *param,
-                                const EVP_CIPHER *c, const EVP_MD *md, int en_de,
-                                OSSL_LIB_CTX *libctx, const char *propq);
-#endif
-
-void PKCS5_PBE_add(void);
-
-int EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
-                       ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de);
-
-int EVP_PBE_CipherInit_ex(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
-                          ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de,
-                          OSSL_LIB_CTX *libctx, const char *propq);
+    int EVP_PBE_scrypt(const char* pass, size_t passlen, const unsigned char* salt, size_t saltlen, uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem, unsigned char* key, size_t keylen);
+    int EVP_PBE_scrypt_ex(const char* pass, size_t passlen, const unsigned char* salt, size_t saltlen, uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem, unsigned char* key, size_t keylen, OSSL_LIB_CTX* ctx, const char* propq);
+
+    int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* c, const EVP_MD* md, int en_de);
+    int PKCS5_v2_scrypt_keyivgen_ex(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* c, const EVP_MD* md, int en_de, OSSL_LIB_CTX* libctx, const char* propq);
+#endif
+
+    void PKCS5_PBE_add(void);
+
+    int EVP_PBE_CipherInit(ASN1_OBJECT* pbe_obj, const char* pass, int passlen, ASN1_TYPE* param, EVP_CIPHER_CTX* ctx, int en_de);
+
+    int EVP_PBE_CipherInit_ex(ASN1_OBJECT* pbe_obj, const char* pass, int passlen, ASN1_TYPE* param, EVP_CIPHER_CTX* ctx, int en_de, OSSL_LIB_CTX* libctx, const char* propq);
 
 /* PBE type */
 
 /* Can appear as the outermost AlgorithmIdentifier */
-# define EVP_PBE_TYPE_OUTER      0x0
+#define EVP_PBE_TYPE_OUTER 0x0
 /* Is an PRF type OID */
-# define EVP_PBE_TYPE_PRF        0x1
+#define EVP_PBE_TYPE_PRF 0x1
 /* Is a PKCS#5 v2.0 KDF */
-# define EVP_PBE_TYPE_KDF        0x2
-
-int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid,
-                         int md_nid, EVP_PBE_KEYGEN *keygen);
-int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
-                    EVP_PBE_KEYGEN *keygen);
-int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid,
-                 EVP_PBE_KEYGEN **pkeygen);
-int EVP_PBE_find_ex(int type, int pbe_nid, int *pcnid, int *pmnid,
-                    EVP_PBE_KEYGEN **pkeygen, EVP_PBE_KEYGEN_EX **pkeygen_ex);
-void EVP_PBE_cleanup(void);
-int EVP_PBE_get(int *ptype, int *ppbe_nid, size_t num);
-
-# define ASN1_PKEY_ALIAS         0x1
-# define ASN1_PKEY_DYNAMIC       0x2
-# define ASN1_PKEY_SIGPARAM_NULL 0x4
-
-# define ASN1_PKEY_CTRL_PKCS7_SIGN       0x1
-# define ASN1_PKEY_CTRL_PKCS7_ENCRYPT    0x2
-# define ASN1_PKEY_CTRL_DEFAULT_MD_NID   0x3
-# define ASN1_PKEY_CTRL_CMS_SIGN         0x5
-# define ASN1_PKEY_CTRL_CMS_ENVELOPE     0x7
-# define ASN1_PKEY_CTRL_CMS_RI_TYPE      0x8
-
-# define ASN1_PKEY_CTRL_SET1_TLS_ENCPT   0x9
-# define ASN1_PKEY_CTRL_GET1_TLS_ENCPT   0xa
-# define ASN1_PKEY_CTRL_CMS_IS_RI_TYPE_SUPPORTED 0xb
-
-int EVP_PKEY_asn1_get_count(void);
-const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx);
-const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type);
-const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
-                                                   const char *str, int len);
-int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth);
-int EVP_PKEY_asn1_add_alias(int to, int from);
-int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id,
-                            int *ppkey_flags, const char **pinfo,
-                            const char **ppem_str,
-                            const EVP_PKEY_ASN1_METHOD *ameth);
-
-const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(const EVP_PKEY *pkey);
-EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,
-                                        const char *pem_str,
-                                        const char *info);
-void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
-                        const EVP_PKEY_ASN1_METHOD *src);
-void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth);
-void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
-                              int (*pub_decode) (EVP_PKEY *pk,
-                                                 const X509_PUBKEY *pub),
-                              int (*pub_encode) (X509_PUBKEY *pub,
-                                                 const EVP_PKEY *pk),
-                              int (*pub_cmp) (const EVP_PKEY *a,
-                                              const EVP_PKEY *b),
-                              int (*pub_print) (BIO *out,
-                                                const EVP_PKEY *pkey,
-                                                int indent, ASN1_PCTX *pctx),
-                              int (*pkey_size) (const EVP_PKEY *pk),
-                              int (*pkey_bits) (const EVP_PKEY *pk));
-void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
-                               int (*priv_decode) (EVP_PKEY *pk,
-                                                   const PKCS8_PRIV_KEY_INFO
-                                                   *p8inf),
-                               int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8,
-                                                   const EVP_PKEY *pk),
-                               int (*priv_print) (BIO *out,
-                                                  const EVP_PKEY *pkey,
-                                                  int indent,
-                                                  ASN1_PCTX *pctx));
-void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
-                             int (*param_decode) (EVP_PKEY *pkey,
-                                                  const unsigned char **pder,
-                                                  int derlen),
-                             int (*param_encode) (const EVP_PKEY *pkey,
-                                                  unsigned char **pder),
-                             int (*param_missing) (const EVP_PKEY *pk),
-                             int (*param_copy) (EVP_PKEY *to,
-                                                const EVP_PKEY *from),
-                             int (*param_cmp) (const EVP_PKEY *a,
-                                               const EVP_PKEY *b),
-                             int (*param_print) (BIO *out,
-                                                 const EVP_PKEY *pkey,
-                                                 int indent,
-                                                 ASN1_PCTX *pctx));
-
-void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
-                            void (*pkey_free) (EVP_PKEY *pkey));
-void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
-                            int (*pkey_ctrl) (EVP_PKEY *pkey, int op,
-                                              long arg1, void *arg2));
-void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth,
-                            int (*item_verify) (EVP_MD_CTX *ctx,
-                                                const ASN1_ITEM *it,
-                                                const void *data,
-                                                const X509_ALGOR *a,
-                                                const ASN1_BIT_STRING *sig,
-                                                EVP_PKEY *pkey),
-                            int (*item_sign) (EVP_MD_CTX *ctx,
-                                              const ASN1_ITEM *it,
-                                              const void *data,
-                                              X509_ALGOR *alg1,
-                                              X509_ALGOR *alg2,
-                                              ASN1_BIT_STRING *sig));
-
-void EVP_PKEY_asn1_set_siginf(EVP_PKEY_ASN1_METHOD *ameth,
-                              int (*siginf_set) (X509_SIG_INFO *siginf,
-                                                 const X509_ALGOR *alg,
-                                                 const ASN1_STRING *sig));
-
-void EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth,
-                             int (*pkey_check) (const EVP_PKEY *pk));
-
-void EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth,
-                                    int (*pkey_pub_check) (const EVP_PKEY *pk));
-
-void EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth,
-                                   int (*pkey_param_check) (const EVP_PKEY *pk));
-
-void EVP_PKEY_asn1_set_set_priv_key(EVP_PKEY_ASN1_METHOD *ameth,
-                                    int (*set_priv_key) (EVP_PKEY *pk,
-                                                         const unsigned char
-                                                            *priv,
-                                                         size_t len));
-void EVP_PKEY_asn1_set_set_pub_key(EVP_PKEY_ASN1_METHOD *ameth,
-                                   int (*set_pub_key) (EVP_PKEY *pk,
-                                                       const unsigned char *pub,
-                                                       size_t len));
-void EVP_PKEY_asn1_set_get_priv_key(EVP_PKEY_ASN1_METHOD *ameth,
-                                    int (*get_priv_key) (const EVP_PKEY *pk,
-                                                         unsigned char *priv,
-                                                         size_t *len));
-void EVP_PKEY_asn1_set_get_pub_key(EVP_PKEY_ASN1_METHOD *ameth,
-                                   int (*get_pub_key) (const EVP_PKEY *pk,
-                                                       unsigned char *pub,
-                                                       size_t *len));
-
-void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
-                                     int (*pkey_security_bits) (const EVP_PKEY
-                                                                *pk));
-
-int EVP_PKEY_CTX_get_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
-int EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
-
-int EVP_PKEY_CTX_set1_id(EVP_PKEY_CTX *ctx, const void *id, int len);
-int EVP_PKEY_CTX_get1_id(EVP_PKEY_CTX *ctx, void *id);
-int EVP_PKEY_CTX_get1_id_len(EVP_PKEY_CTX *ctx, size_t *id_len);
-
-int EVP_PKEY_CTX_set_kem_op(EVP_PKEY_CTX *ctx, const char *op);
-
-const char *EVP_PKEY_get0_type_name(const EVP_PKEY *key);
-
-# define EVP_PKEY_OP_UNDEFINED           0
-# define EVP_PKEY_OP_PARAMGEN            (1<<1)
-# define EVP_PKEY_OP_KEYGEN              (1<<2)
-# define EVP_PKEY_OP_FROMDATA            (1<<3)
-# define EVP_PKEY_OP_SIGN                (1<<4)
-# define EVP_PKEY_OP_VERIFY              (1<<5)
-# define EVP_PKEY_OP_VERIFYRECOVER       (1<<6)
-# define EVP_PKEY_OP_SIGNCTX             (1<<7)
-# define EVP_PKEY_OP_VERIFYCTX           (1<<8)
-# define EVP_PKEY_OP_ENCRYPT             (1<<9)
-# define EVP_PKEY_OP_DECRYPT             (1<<10)
-# define EVP_PKEY_OP_DERIVE              (1<<11)
-# define EVP_PKEY_OP_ENCAPSULATE         (1<<12)
-# define EVP_PKEY_OP_DECAPSULATE         (1<<13)
-
-# define EVP_PKEY_OP_TYPE_SIG    \
-        (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER \
-                | EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX)
-
-# define EVP_PKEY_OP_TYPE_CRYPT \
-        (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT)
-
-# define EVP_PKEY_OP_TYPE_NOGEN \
-        (EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_DERIVE)
-
-# define EVP_PKEY_OP_TYPE_GEN \
-        (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN)
-
-
-int EVP_PKEY_CTX_set_mac_key(EVP_PKEY_CTX *ctx, const unsigned char *key,
-                             int keylen);
-
-# define EVP_PKEY_CTRL_MD                1
-# define EVP_PKEY_CTRL_PEER_KEY          2
-# define EVP_PKEY_CTRL_SET_MAC_KEY       6
-# define EVP_PKEY_CTRL_DIGESTINIT        7
+#define EVP_PBE_TYPE_KDF 0x2
+
+    int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, int md_nid, EVP_PBE_KEYGEN* keygen);
+    int EVP_PBE_alg_add(int nid, const EVP_CIPHER* cipher, const EVP_MD* md, EVP_PBE_KEYGEN* keygen);
+    int EVP_PBE_find(int type, int pbe_nid, int* pcnid, int* pmnid, EVP_PBE_KEYGEN** pkeygen);
+    int EVP_PBE_find_ex(int type, int pbe_nid, int* pcnid, int* pmnid, EVP_PBE_KEYGEN** pkeygen, EVP_PBE_KEYGEN_EX** pkeygen_ex);
+    void EVP_PBE_cleanup(void);
+    int EVP_PBE_get(int* ptype, int* ppbe_nid, size_t num);
+
+#define ASN1_PKEY_ALIAS 0x1
+#define ASN1_PKEY_DYNAMIC 0x2
+#define ASN1_PKEY_SIGPARAM_NULL 0x4
+
+#define ASN1_PKEY_CTRL_PKCS7_SIGN 0x1
+#define ASN1_PKEY_CTRL_PKCS7_ENCRYPT 0x2
+#define ASN1_PKEY_CTRL_DEFAULT_MD_NID 0x3
+#define ASN1_PKEY_CTRL_CMS_SIGN 0x5
+#define ASN1_PKEY_CTRL_CMS_ENVELOPE 0x7
+#define ASN1_PKEY_CTRL_CMS_RI_TYPE 0x8
+
+#define ASN1_PKEY_CTRL_SET1_TLS_ENCPT 0x9
+#define ASN1_PKEY_CTRL_GET1_TLS_ENCPT 0xa
+#define ASN1_PKEY_CTRL_CMS_IS_RI_TYPE_SUPPORTED 0xb
+
+    int EVP_PKEY_asn1_get_count(void);
+    const EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_get0(int idx);
+    const EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_find(ENGINE** pe, int type);
+    const EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_find_str(ENGINE** pe, const char* str, int len);
+    int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD* ameth);
+    int EVP_PKEY_asn1_add_alias(int to, int from);
+    int EVP_PKEY_asn1_get0_info(int* ppkey_id, int* pkey_base_id, int* ppkey_flags, const char** pinfo, const char** ppem_str, const EVP_PKEY_ASN1_METHOD* ameth);
+
+    const EVP_PKEY_ASN1_METHOD* EVP_PKEY_get0_asn1(const EVP_PKEY* pkey);
+    EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags, const char* pem_str, const char* info);
+    void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD* dst, const EVP_PKEY_ASN1_METHOD* src);
+    void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD* ameth);
+    void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD* ameth, int (*pub_decode)(EVP_PKEY* pk, const X509_PUBKEY* pub), int (*pub_encode)(X509_PUBKEY* pub, const EVP_PKEY* pk), int (*pub_cmp)(const EVP_PKEY* a, const EVP_PKEY* b), int (*pub_print)(BIO* out, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx), int (*pkey_size)(const EVP_PKEY* pk), int (*pkey_bits)(const EVP_PKEY* pk));
+    void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD* ameth, int (*priv_decode)(EVP_PKEY* pk, const PKCS8_PRIV_KEY_INFO* p8inf), int (*priv_encode)(PKCS8_PRIV_KEY_INFO* p8, const EVP_PKEY* pk), int (*priv_print)(BIO* out, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx));
+    void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD* ameth, int (*param_decode)(EVP_PKEY* pkey, const unsigned char** pder, int derlen), int (*param_encode)(const EVP_PKEY* pkey, unsigned char** pder), int (*param_missing)(const EVP_PKEY* pk), int (*param_copy)(EVP_PKEY* to, const EVP_PKEY* from), int (*param_cmp)(const EVP_PKEY* a, const EVP_PKEY* b), int (*param_print)(BIO* out, const EVP_PKEY* pkey, int indent, ASN1_PCTX* pctx));
+
+    void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD* ameth, void (*pkey_free)(EVP_PKEY* pkey));
+    void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD* ameth, int (*pkey_ctrl)(EVP_PKEY* pkey, int op, long arg1, void* arg2));
+    void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD* ameth, int (*item_verify)(EVP_MD_CTX* ctx, const ASN1_ITEM* it, const void* data, const X509_ALGOR* a, const ASN1_BIT_STRING* sig, EVP_PKEY* pkey), int (*item_sign)(EVP_MD_CTX* ctx, const ASN1_ITEM* it, const void* data, X509_ALGOR* alg1, X509_ALGOR* alg2, ASN1_BIT_STRING* sig));
+
+    void EVP_PKEY_asn1_set_siginf(EVP_PKEY_ASN1_METHOD* ameth, int (*siginf_set)(X509_SIG_INFO* siginf, const X509_ALGOR* alg, const ASN1_STRING* sig));
+
+    void EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD* ameth, int (*pkey_check)(const EVP_PKEY* pk));
+
+    void EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD* ameth, int (*pkey_pub_check)(const EVP_PKEY* pk));
+
+    void EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD* ameth, int (*pkey_param_check)(const EVP_PKEY* pk));
+
+    void EVP_PKEY_asn1_set_set_priv_key(EVP_PKEY_ASN1_METHOD* ameth, int (*set_priv_key)(EVP_PKEY* pk, const unsigned char* priv, size_t len));
+    void EVP_PKEY_asn1_set_set_pub_key(EVP_PKEY_ASN1_METHOD* ameth, int (*set_pub_key)(EVP_PKEY* pk, const unsigned char* pub, size_t len));
+    void EVP_PKEY_asn1_set_get_priv_key(EVP_PKEY_ASN1_METHOD* ameth, int (*get_priv_key)(const EVP_PKEY* pk, unsigned char* priv, size_t* len));
+    void EVP_PKEY_asn1_set_get_pub_key(EVP_PKEY_ASN1_METHOD* ameth, int (*get_pub_key)(const EVP_PKEY* pk, unsigned char* pub, size_t* len));
+
+    void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD* ameth, int (*pkey_security_bits)(const EVP_PKEY* pk));
+
+    int EVP_PKEY_CTX_get_signature_md(EVP_PKEY_CTX* ctx, const EVP_MD** md);
+    int EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
+
+    int EVP_PKEY_CTX_set1_id(EVP_PKEY_CTX* ctx, const void* id, int len);
+    int EVP_PKEY_CTX_get1_id(EVP_PKEY_CTX* ctx, void* id);
+    int EVP_PKEY_CTX_get1_id_len(EVP_PKEY_CTX* ctx, size_t* id_len);
+
+    int EVP_PKEY_CTX_set_kem_op(EVP_PKEY_CTX* ctx, const char* op);
+
+    const char* EVP_PKEY_get0_type_name(const EVP_PKEY* key);
+
+#define EVP_PKEY_OP_UNDEFINED 0
+#define EVP_PKEY_OP_PARAMGEN (1 << 1)
+#define EVP_PKEY_OP_KEYGEN (1 << 2)
+#define EVP_PKEY_OP_FROMDATA (1 << 3)
+#define EVP_PKEY_OP_SIGN (1 << 4)
+#define EVP_PKEY_OP_VERIFY (1 << 5)
+#define EVP_PKEY_OP_VERIFYRECOVER (1 << 6)
+#define EVP_PKEY_OP_SIGNCTX (1 << 7)
+#define EVP_PKEY_OP_VERIFYCTX (1 << 8)
+#define EVP_PKEY_OP_ENCRYPT (1 << 9)
+#define EVP_PKEY_OP_DECRYPT (1 << 10)
+#define EVP_PKEY_OP_DERIVE (1 << 11)
+#define EVP_PKEY_OP_ENCAPSULATE (1 << 12)
+#define EVP_PKEY_OP_DECAPSULATE (1 << 13)
+
+#define EVP_PKEY_OP_TYPE_SIG \
+    (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER | EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX)
+
+#define EVP_PKEY_OP_TYPE_CRYPT \
+    (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT)
+
+#define EVP_PKEY_OP_TYPE_NOGEN \
+    (EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_DERIVE)
+
+#define EVP_PKEY_OP_TYPE_GEN \
+    (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN)
+
+    int EVP_PKEY_CTX_set_mac_key(EVP_PKEY_CTX* ctx, const unsigned char* key, int keylen);
+
+#define EVP_PKEY_CTRL_MD 1
+#define EVP_PKEY_CTRL_PEER_KEY 2
+#define EVP_PKEY_CTRL_SET_MAC_KEY 6
+#define EVP_PKEY_CTRL_DIGESTINIT 7
 /* Used by GOST key encryption in TLS */
-# define EVP_PKEY_CTRL_SET_IV            8
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define EVP_PKEY_CTRL_PKCS7_ENCRYPT     3
-#  define EVP_PKEY_CTRL_PKCS7_DECRYPT     4
-#  define EVP_PKEY_CTRL_PKCS7_SIGN        5
-#  define EVP_PKEY_CTRL_CMS_ENCRYPT       9
-#  define EVP_PKEY_CTRL_CMS_DECRYPT       10
-#  define EVP_PKEY_CTRL_CMS_SIGN          11
-# endif
-# define EVP_PKEY_CTRL_CIPHER            12
-# define EVP_PKEY_CTRL_GET_MD            13
-# define EVP_PKEY_CTRL_SET_DIGEST_SIZE   14
-# define EVP_PKEY_CTRL_SET1_ID           15
-# define EVP_PKEY_CTRL_GET1_ID           16
-# define EVP_PKEY_CTRL_GET1_ID_LEN       17
-
-# define EVP_PKEY_ALG_CTRL               0x1000
-
-# define EVP_PKEY_FLAG_AUTOARGLEN        2
+#define EVP_PKEY_CTRL_SET_IV 8
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define EVP_PKEY_CTRL_PKCS7_ENCRYPT 3
+#define EVP_PKEY_CTRL_PKCS7_DECRYPT 4
+#define EVP_PKEY_CTRL_PKCS7_SIGN 5
+#define EVP_PKEY_CTRL_CMS_ENCRYPT 9
+#define EVP_PKEY_CTRL_CMS_DECRYPT 10
+#define EVP_PKEY_CTRL_CMS_SIGN 11
+#endif
+#define EVP_PKEY_CTRL_CIPHER 12
+#define EVP_PKEY_CTRL_GET_MD 13
+#define EVP_PKEY_CTRL_SET_DIGEST_SIZE 14
+#define EVP_PKEY_CTRL_SET1_ID 15
+#define EVP_PKEY_CTRL_GET1_ID 16
+#define EVP_PKEY_CTRL_GET1_ID_LEN 17
+
+#define EVP_PKEY_ALG_CTRL 0x1000
+
+#define EVP_PKEY_FLAG_AUTOARGLEN 2
 /*
  * Method handles all operations: don't assume any digest related defaults.
  */
-# define EVP_PKEY_FLAG_SIGCTX_CUSTOM     4
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
-OSSL_DEPRECATEDIN_3_0 EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags);
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
-                                              const EVP_PKEY_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst,
-                                         const EVP_PKEY_METHOD *src);
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
-OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
-OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth);
-OSSL_DEPRECATEDIN_3_0 size_t EVP_PKEY_meth_get_count(void);
-OSSL_DEPRECATEDIN_3_0 const EVP_PKEY_METHOD *EVP_PKEY_meth_get0(size_t idx);
-# endif
-
-EVP_KEYMGMT *EVP_KEYMGMT_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
-                               const char *properties);
-int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt);
-void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt);
-const OSSL_PROVIDER *EVP_KEYMGMT_get0_provider(const EVP_KEYMGMT *keymgmt);
-const char *EVP_KEYMGMT_get0_name(const EVP_KEYMGMT *keymgmt);
-const char *EVP_KEYMGMT_get0_description(const EVP_KEYMGMT *keymgmt);
-int EVP_KEYMGMT_is_a(const EVP_KEYMGMT *keymgmt, const char *name);
-void EVP_KEYMGMT_do_all_provided(OSSL_LIB_CTX *libctx,
-                                 void (*fn)(EVP_KEYMGMT *keymgmt, void *arg),
-                                 void *arg);
-int EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
-                             void (*fn)(const char *name, void *data),
-                             void *data);
-const OSSL_PARAM *EVP_KEYMGMT_gettable_params(const EVP_KEYMGMT *keymgmt);
-const OSSL_PARAM *EVP_KEYMGMT_settable_params(const EVP_KEYMGMT *keymgmt);
-const OSSL_PARAM *EVP_KEYMGMT_gen_settable_params(const EVP_KEYMGMT *keymgmt);
-
-EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
-EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
-EVP_PKEY_CTX *EVP_PKEY_CTX_new_from_name(OSSL_LIB_CTX *libctx,
-                                         const char *name,
-                                         const char *propquery);
-EVP_PKEY_CTX *EVP_PKEY_CTX_new_from_pkey(OSSL_LIB_CTX *libctx,
-                                         EVP_PKEY *pkey, const char *propquery);
-EVP_PKEY_CTX *EVP_PKEY_CTX_dup(const EVP_PKEY_CTX *ctx);
-void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_CTX_is_a(EVP_PKEY_CTX *ctx, const char *keytype);
-
-int EVP_PKEY_CTX_get_params(EVP_PKEY_CTX *ctx, OSSL_PARAM *params);
-const OSSL_PARAM *EVP_PKEY_CTX_gettable_params(const EVP_PKEY_CTX *ctx);
-int EVP_PKEY_CTX_set_params(EVP_PKEY_CTX *ctx, const OSSL_PARAM *params);
-const OSSL_PARAM *EVP_PKEY_CTX_settable_params(const EVP_PKEY_CTX *ctx);
-int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
-                      int cmd, int p1, void *p2);
-int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
-                          const char *value);
-int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype,
-                             int cmd, uint64_t value);
-
-int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str);
-int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex);
-
-int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md);
-
-int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx);
-void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen);
-
-EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
-                               const unsigned char *key, int keylen);
-EVP_PKEY *EVP_PKEY_new_raw_private_key_ex(OSSL_LIB_CTX *libctx,
-                                          const char *keytype,
-                                          const char *propq,
-                                          const unsigned char *priv, size_t len);
-EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e,
-                                       const unsigned char *priv,
-                                       size_t len);
-EVP_PKEY *EVP_PKEY_new_raw_public_key_ex(OSSL_LIB_CTX *libctx,
-                                         const char *keytype, const char *propq,
-                                         const unsigned char *pub, size_t len);
-EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e,
-                                      const unsigned char *pub,
-                                      size_t len);
-int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv,
-                                 size_t *len);
-int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub,
-                                size_t *len);
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-EVP_PKEY *EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv,
-                                size_t len, const EVP_CIPHER *cipher);
-# endif
-
-void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data);
-void *EVP_PKEY_CTX_get_data(const EVP_PKEY_CTX *ctx);
-EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx);
-
-EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx);
-
-void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data);
-void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);
-
-void EVP_SIGNATURE_free(EVP_SIGNATURE *signature);
-int EVP_SIGNATURE_up_ref(EVP_SIGNATURE *signature);
-OSSL_PROVIDER *EVP_SIGNATURE_get0_provider(const EVP_SIGNATURE *signature);
-EVP_SIGNATURE *EVP_SIGNATURE_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
-                                   const char *properties);
-int EVP_SIGNATURE_is_a(const EVP_SIGNATURE *signature, const char *name);
-const char *EVP_SIGNATURE_get0_name(const EVP_SIGNATURE *signature);
-const char *EVP_SIGNATURE_get0_description(const EVP_SIGNATURE *signature);
-void EVP_SIGNATURE_do_all_provided(OSSL_LIB_CTX *libctx,
-                                   void (*fn)(EVP_SIGNATURE *signature,
-                                              void *data),
-                                   void *data);
-int EVP_SIGNATURE_names_do_all(const EVP_SIGNATURE *signature,
-                               void (*fn)(const char *name, void *data),
-                               void *data);
-const OSSL_PARAM *EVP_SIGNATURE_gettable_ctx_params(const EVP_SIGNATURE *sig);
-const OSSL_PARAM *EVP_SIGNATURE_settable_ctx_params(const EVP_SIGNATURE *sig);
-
-void EVP_ASYM_CIPHER_free(EVP_ASYM_CIPHER *cipher);
-int EVP_ASYM_CIPHER_up_ref(EVP_ASYM_CIPHER *cipher);
-OSSL_PROVIDER *EVP_ASYM_CIPHER_get0_provider(const EVP_ASYM_CIPHER *cipher);
-EVP_ASYM_CIPHER *EVP_ASYM_CIPHER_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
-                                       const char *properties);
-int EVP_ASYM_CIPHER_is_a(const EVP_ASYM_CIPHER *cipher, const char *name);
-const char *EVP_ASYM_CIPHER_get0_name(const EVP_ASYM_CIPHER *cipher);
-const char *EVP_ASYM_CIPHER_get0_description(const EVP_ASYM_CIPHER *cipher);
-void EVP_ASYM_CIPHER_do_all_provided(OSSL_LIB_CTX *libctx,
-                                     void (*fn)(EVP_ASYM_CIPHER *cipher,
-                                                void *arg),
-                                     void *arg);
-int EVP_ASYM_CIPHER_names_do_all(const EVP_ASYM_CIPHER *cipher,
-                                 void (*fn)(const char *name, void *data),
-                                 void *data);
-const OSSL_PARAM *EVP_ASYM_CIPHER_gettable_ctx_params(const EVP_ASYM_CIPHER *ciph);
-const OSSL_PARAM *EVP_ASYM_CIPHER_settable_ctx_params(const EVP_ASYM_CIPHER *ciph);
-
-void EVP_KEM_free(EVP_KEM *wrap);
-int EVP_KEM_up_ref(EVP_KEM *wrap);
-OSSL_PROVIDER *EVP_KEM_get0_provider(const EVP_KEM *wrap);
-EVP_KEM *EVP_KEM_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
-                       const char *properties);
-int EVP_KEM_is_a(const EVP_KEM *wrap, const char *name);
-const char *EVP_KEM_get0_name(const EVP_KEM *wrap);
-const char *EVP_KEM_get0_description(const EVP_KEM *wrap);
-void EVP_KEM_do_all_provided(OSSL_LIB_CTX *libctx,
-                             void (*fn)(EVP_KEM *wrap, void *arg), void *arg);
-int EVP_KEM_names_do_all(const EVP_KEM *wrap,
-                         void (*fn)(const char *name, void *data), void *data);
-const OSSL_PARAM *EVP_KEM_gettable_ctx_params(const EVP_KEM *kem);
-const OSSL_PARAM *EVP_KEM_settable_ctx_params(const EVP_KEM *kem);
-
-int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_sign_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
-                  unsigned char *sig, size_t *siglen,
-                  const unsigned char *tbs, size_t tbslen);
-int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_verify_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
-                    const unsigned char *sig, size_t siglen,
-                    const unsigned char *tbs, size_t tbslen);
-int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_verify_recover_init_ex(EVP_PKEY_CTX *ctx,
-                                    const OSSL_PARAM params[]);
-int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
-                            unsigned char *rout, size_t *routlen,
-                            const unsigned char *sig, size_t siglen);
-int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_encrypt_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
-                     unsigned char *out, size_t *outlen,
-                     const unsigned char *in, size_t inlen);
-int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_decrypt_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
-                     unsigned char *out, size_t *outlen,
-                     const unsigned char *in, size_t inlen);
-
-int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_derive_init_ex(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_PKEY_derive_set_peer_ex(EVP_PKEY_CTX *ctx, EVP_PKEY *peer,
-                                int validate_peer);
-int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
-int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
-
-int EVP_PKEY_encapsulate_init(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_PKEY_encapsulate(EVP_PKEY_CTX *ctx,
-                         unsigned char *wrappedkey, size_t *wrappedkeylen,
-                         unsigned char *genkey, size_t *genkeylen);
-int EVP_PKEY_decapsulate_init(EVP_PKEY_CTX *ctx, const OSSL_PARAM params[]);
-int EVP_PKEY_decapsulate(EVP_PKEY_CTX *ctx,
-                         unsigned char *unwrapped, size_t *unwrappedlen,
-                         const unsigned char *wrapped, size_t wrappedlen);
-
-typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);
-
-int EVP_PKEY_fromdata_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_fromdata(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, int selection,
-                      OSSL_PARAM param[]);
-const OSSL_PARAM *EVP_PKEY_fromdata_settable(EVP_PKEY_CTX *ctx, int selection);
-
-int EVP_PKEY_todata(const EVP_PKEY *pkey, int selection, OSSL_PARAM **params);
-int EVP_PKEY_export(const EVP_PKEY *pkey, int selection,
-                    OSSL_CALLBACK *export_cb, void *export_cbarg);
-
-const OSSL_PARAM *EVP_PKEY_gettable_params(const EVP_PKEY *pkey);
-int EVP_PKEY_get_params(const EVP_PKEY *pkey, OSSL_PARAM params[]);
-int EVP_PKEY_get_int_param(const EVP_PKEY *pkey, const char *key_name,
-                           int *out);
-int EVP_PKEY_get_size_t_param(const EVP_PKEY *pkey, const char *key_name,
-                              size_t *out);
-int EVP_PKEY_get_bn_param(const EVP_PKEY *pkey, const char *key_name,
-                          BIGNUM **bn);
-int EVP_PKEY_get_utf8_string_param(const EVP_PKEY *pkey, const char *key_name,
-                                    char *str, size_t max_buf_sz, size_t *out_sz);
-int EVP_PKEY_get_octet_string_param(const EVP_PKEY *pkey, const char *key_name,
-                                    unsigned char *buf, size_t max_buf_sz,
-                                    size_t *out_sz);
-
-const OSSL_PARAM *EVP_PKEY_settable_params(const EVP_PKEY *pkey);
-int EVP_PKEY_set_params(EVP_PKEY *pkey, OSSL_PARAM params[]);
-int EVP_PKEY_set_int_param(EVP_PKEY *pkey, const char *key_name, int in);
-int EVP_PKEY_set_size_t_param(EVP_PKEY *pkey, const char *key_name, size_t in);
-int EVP_PKEY_set_bn_param(EVP_PKEY *pkey, const char *key_name,
-                          const BIGNUM *bn);
-int EVP_PKEY_set_utf8_string_param(EVP_PKEY *pkey, const char *key_name,
-                                   const char *str);
-int EVP_PKEY_set_octet_string_param(EVP_PKEY *pkey, const char *key_name,
-                                    const unsigned char *buf, size_t bsize);
-
-int EVP_PKEY_get_ec_point_conv_form(const EVP_PKEY *pkey);
-int EVP_PKEY_get_field_type(const EVP_PKEY *pkey);
-
-EVP_PKEY *EVP_PKEY_Q_keygen(OSSL_LIB_CTX *libctx, const char *propq,
-                            const char *type, ...);
-int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
-int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
-int EVP_PKEY_generate(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
-int EVP_PKEY_check(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_public_check(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_public_check_quick(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_param_check(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_param_check_quick(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_private_check(EVP_PKEY_CTX *ctx);
-int EVP_PKEY_pairwise_check(EVP_PKEY_CTX *ctx);
-
-# define EVP_PKEY_get_ex_new_index(l, p, newf, dupf, freef) \
+#define EVP_PKEY_FLAG_SIGCTX_CUSTOM 4
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 const EVP_PKEY_METHOD* EVP_PKEY_meth_find(int type);
+    OSSL_DEPRECATEDIN_3_0 EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags);
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get0_info(int* ppkey_id, int* pflags, const EVP_PKEY_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_copy(EVP_PKEY_METHOD* dst, const EVP_PKEY_METHOD* src);
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_free(EVP_PKEY_METHOD* pmeth);
+    OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD* pmeth);
+    OSSL_DEPRECATEDIN_3_0 int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD* pmeth);
+    OSSL_DEPRECATEDIN_3_0 size_t EVP_PKEY_meth_get_count(void);
+    OSSL_DEPRECATEDIN_3_0 const EVP_PKEY_METHOD* EVP_PKEY_meth_get0(size_t idx);
+#endif
+
+    EVP_KEYMGMT* EVP_KEYMGMT_fetch(OSSL_LIB_CTX* ctx, const char* algorithm, const char* properties);
+    int EVP_KEYMGMT_up_ref(EVP_KEYMGMT* keymgmt);
+    void EVP_KEYMGMT_free(EVP_KEYMGMT* keymgmt);
+    const OSSL_PROVIDER* EVP_KEYMGMT_get0_provider(const EVP_KEYMGMT* keymgmt);
+    const char* EVP_KEYMGMT_get0_name(const EVP_KEYMGMT* keymgmt);
+    const char* EVP_KEYMGMT_get0_description(const EVP_KEYMGMT* keymgmt);
+    int EVP_KEYMGMT_is_a(const EVP_KEYMGMT* keymgmt, const char* name);
+    void EVP_KEYMGMT_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_KEYMGMT* keymgmt, void* arg), void* arg);
+    int EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT* keymgmt, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PARAM* EVP_KEYMGMT_gettable_params(const EVP_KEYMGMT* keymgmt);
+    const OSSL_PARAM* EVP_KEYMGMT_settable_params(const EVP_KEYMGMT* keymgmt);
+    const OSSL_PARAM* EVP_KEYMGMT_gen_settable_params(const EVP_KEYMGMT* keymgmt);
+
+    EVP_PKEY_CTX* EVP_PKEY_CTX_new(EVP_PKEY* pkey, ENGINE* e);
+    EVP_PKEY_CTX* EVP_PKEY_CTX_new_id(int id, ENGINE* e);
+    EVP_PKEY_CTX* EVP_PKEY_CTX_new_from_name(OSSL_LIB_CTX* libctx, const char* name, const char* propquery);
+    EVP_PKEY_CTX* EVP_PKEY_CTX_new_from_pkey(OSSL_LIB_CTX* libctx, EVP_PKEY* pkey, const char* propquery);
+    EVP_PKEY_CTX* EVP_PKEY_CTX_dup(const EVP_PKEY_CTX* ctx);
+    void EVP_PKEY_CTX_free(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_CTX_is_a(EVP_PKEY_CTX* ctx, const char* keytype);
+
+    int EVP_PKEY_CTX_get_params(EVP_PKEY_CTX* ctx, OSSL_PARAM* params);
+    const OSSL_PARAM* EVP_PKEY_CTX_gettable_params(const EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_CTX_set_params(EVP_PKEY_CTX* ctx, const OSSL_PARAM* params);
+    const OSSL_PARAM* EVP_PKEY_CTX_settable_params(const EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX* ctx, int keytype, int optype, int cmd, int p1, void* p2);
+    int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX* ctx, const char* type, const char* value);
+    int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX* ctx, int keytype, int optype, int cmd, uint64_t value);
+
+    int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX* ctx, int cmd, const char* str);
+    int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX* ctx, int cmd, const char* hex);
+
+    int EVP_PKEY_CTX_md(EVP_PKEY_CTX* ctx, int optype, int cmd, const char* md);
+
+    int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX* ctx);
+    void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX* ctx, int* dat, int datlen);
+
+    EVP_PKEY* EVP_PKEY_new_mac_key(int type, ENGINE* e, const unsigned char* key, int keylen);
+    EVP_PKEY* EVP_PKEY_new_raw_private_key_ex(OSSL_LIB_CTX* libctx, const char* keytype, const char* propq, const unsigned char* priv, size_t len);
+    EVP_PKEY* EVP_PKEY_new_raw_private_key(int type, ENGINE* e, const unsigned char* priv, size_t len);
+    EVP_PKEY* EVP_PKEY_new_raw_public_key_ex(OSSL_LIB_CTX* libctx, const char* keytype, const char* propq, const unsigned char* pub, size_t len);
+    EVP_PKEY* EVP_PKEY_new_raw_public_key(int type, ENGINE* e, const unsigned char* pub, size_t len);
+    int EVP_PKEY_get_raw_private_key(const EVP_PKEY* pkey, unsigned char* priv, size_t* len);
+    int EVP_PKEY_get_raw_public_key(const EVP_PKEY* pkey, unsigned char* pub, size_t* len);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    EVP_PKEY* EVP_PKEY_new_CMAC_key(ENGINE* e, const unsigned char* priv, size_t len, const EVP_CIPHER* cipher);
+#endif
+
+    void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX* ctx, void* data);
+    void* EVP_PKEY_CTX_get_data(const EVP_PKEY_CTX* ctx);
+    EVP_PKEY* EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX* ctx);
+
+    EVP_PKEY* EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX* ctx);
+
+    void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX* ctx, void* data);
+    void* EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX* ctx);
+
+    void EVP_SIGNATURE_free(EVP_SIGNATURE* signature);
+    int EVP_SIGNATURE_up_ref(EVP_SIGNATURE* signature);
+    OSSL_PROVIDER* EVP_SIGNATURE_get0_provider(const EVP_SIGNATURE* signature);
+    EVP_SIGNATURE* EVP_SIGNATURE_fetch(OSSL_LIB_CTX* ctx, const char* algorithm, const char* properties);
+    int EVP_SIGNATURE_is_a(const EVP_SIGNATURE* signature, const char* name);
+    const char* EVP_SIGNATURE_get0_name(const EVP_SIGNATURE* signature);
+    const char* EVP_SIGNATURE_get0_description(const EVP_SIGNATURE* signature);
+    void EVP_SIGNATURE_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_SIGNATURE* signature, void* data), void* data);
+    int EVP_SIGNATURE_names_do_all(const EVP_SIGNATURE* signature, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PARAM* EVP_SIGNATURE_gettable_ctx_params(const EVP_SIGNATURE* sig);
+    const OSSL_PARAM* EVP_SIGNATURE_settable_ctx_params(const EVP_SIGNATURE* sig);
+
+    void EVP_ASYM_CIPHER_free(EVP_ASYM_CIPHER* cipher);
+    int EVP_ASYM_CIPHER_up_ref(EVP_ASYM_CIPHER* cipher);
+    OSSL_PROVIDER* EVP_ASYM_CIPHER_get0_provider(const EVP_ASYM_CIPHER* cipher);
+    EVP_ASYM_CIPHER* EVP_ASYM_CIPHER_fetch(OSSL_LIB_CTX* ctx, const char* algorithm, const char* properties);
+    int EVP_ASYM_CIPHER_is_a(const EVP_ASYM_CIPHER* cipher, const char* name);
+    const char* EVP_ASYM_CIPHER_get0_name(const EVP_ASYM_CIPHER* cipher);
+    const char* EVP_ASYM_CIPHER_get0_description(const EVP_ASYM_CIPHER* cipher);
+    void EVP_ASYM_CIPHER_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_ASYM_CIPHER* cipher, void* arg), void* arg);
+    int EVP_ASYM_CIPHER_names_do_all(const EVP_ASYM_CIPHER* cipher, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PARAM* EVP_ASYM_CIPHER_gettable_ctx_params(const EVP_ASYM_CIPHER* ciph);
+    const OSSL_PARAM* EVP_ASYM_CIPHER_settable_ctx_params(const EVP_ASYM_CIPHER* ciph);
+
+    void EVP_KEM_free(EVP_KEM* wrap);
+    int EVP_KEM_up_ref(EVP_KEM* wrap);
+    OSSL_PROVIDER* EVP_KEM_get0_provider(const EVP_KEM* wrap);
+    EVP_KEM* EVP_KEM_fetch(OSSL_LIB_CTX* ctx, const char* algorithm, const char* properties);
+    int EVP_KEM_is_a(const EVP_KEM* wrap, const char* name);
+    const char* EVP_KEM_get0_name(const EVP_KEM* wrap);
+    const char* EVP_KEM_get0_description(const EVP_KEM* wrap);
+    void EVP_KEM_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_KEM* wrap, void* arg), void* arg);
+    int EVP_KEM_names_do_all(const EVP_KEM* wrap, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PARAM* EVP_KEM_gettable_ctx_params(const EVP_KEM* kem);
+    const OSSL_PARAM* EVP_KEM_settable_ctx_params(const EVP_KEM* kem);
+
+    int EVP_PKEY_sign_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_sign_init_ex(EVP_PKEY_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_PKEY_sign(EVP_PKEY_CTX* ctx, unsigned char* sig, size_t* siglen, const unsigned char* tbs, size_t tbslen);
+    int EVP_PKEY_verify_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_verify_init_ex(EVP_PKEY_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_PKEY_verify(EVP_PKEY_CTX* ctx, const unsigned char* sig, size_t siglen, const unsigned char* tbs, size_t tbslen);
+    int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_verify_recover_init_ex(EVP_PKEY_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_PKEY_verify_recover(EVP_PKEY_CTX* ctx, unsigned char* rout, size_t* routlen, const unsigned char* sig, size_t siglen);
+    int EVP_PKEY_encrypt_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_encrypt_init_ex(EVP_PKEY_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_PKEY_encrypt(EVP_PKEY_CTX* ctx, unsigned char* out, size_t* outlen, const unsigned char* in, size_t inlen);
+    int EVP_PKEY_decrypt_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_decrypt_init_ex(EVP_PKEY_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_PKEY_decrypt(EVP_PKEY_CTX* ctx, unsigned char* out, size_t* outlen, const unsigned char* in, size_t inlen);
+
+    int EVP_PKEY_derive_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_derive_init_ex(EVP_PKEY_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_PKEY_derive_set_peer_ex(EVP_PKEY_CTX* ctx, EVP_PKEY* peer, int validate_peer);
+    int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX* ctx, EVP_PKEY* peer);
+    int EVP_PKEY_derive(EVP_PKEY_CTX* ctx, unsigned char* key, size_t* keylen);
+
+    int EVP_PKEY_encapsulate_init(EVP_PKEY_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_PKEY_encapsulate(EVP_PKEY_CTX* ctx, unsigned char* wrappedkey, size_t* wrappedkeylen, unsigned char* genkey, size_t* genkeylen);
+    int EVP_PKEY_decapsulate_init(EVP_PKEY_CTX* ctx, const OSSL_PARAM params[]);
+    int EVP_PKEY_decapsulate(EVP_PKEY_CTX* ctx, unsigned char* unwrapped, size_t* unwrappedlen, const unsigned char* wrapped, size_t wrappedlen);
+
+    typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX* ctx);
+
+    int EVP_PKEY_fromdata_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_fromdata(EVP_PKEY_CTX* ctx, EVP_PKEY** ppkey, int selection, OSSL_PARAM param[]);
+    const OSSL_PARAM* EVP_PKEY_fromdata_settable(EVP_PKEY_CTX* ctx, int selection);
+
+    int EVP_PKEY_todata(const EVP_PKEY* pkey, int selection, OSSL_PARAM** params);
+    int EVP_PKEY_export(const EVP_PKEY* pkey, int selection, OSSL_CALLBACK* export_cb, void* export_cbarg);
+
+    const OSSL_PARAM* EVP_PKEY_gettable_params(const EVP_PKEY* pkey);
+    int EVP_PKEY_get_params(const EVP_PKEY* pkey, OSSL_PARAM params[]);
+    int EVP_PKEY_get_int_param(const EVP_PKEY* pkey, const char* key_name, int* out);
+    int EVP_PKEY_get_size_t_param(const EVP_PKEY* pkey, const char* key_name, size_t* out);
+    int EVP_PKEY_get_bn_param(const EVP_PKEY* pkey, const char* key_name, BIGNUM** bn);
+    int EVP_PKEY_get_utf8_string_param(const EVP_PKEY* pkey, const char* key_name, char* str, size_t max_buf_sz, size_t* out_sz);
+    int EVP_PKEY_get_octet_string_param(const EVP_PKEY* pkey, const char* key_name, unsigned char* buf, size_t max_buf_sz, size_t* out_sz);
+
+    const OSSL_PARAM* EVP_PKEY_settable_params(const EVP_PKEY* pkey);
+    int EVP_PKEY_set_params(EVP_PKEY* pkey, OSSL_PARAM params[]);
+    int EVP_PKEY_set_int_param(EVP_PKEY* pkey, const char* key_name, int in);
+    int EVP_PKEY_set_size_t_param(EVP_PKEY* pkey, const char* key_name, size_t in);
+    int EVP_PKEY_set_bn_param(EVP_PKEY* pkey, const char* key_name, const BIGNUM* bn);
+    int EVP_PKEY_set_utf8_string_param(EVP_PKEY* pkey, const char* key_name, const char* str);
+    int EVP_PKEY_set_octet_string_param(EVP_PKEY* pkey, const char* key_name, const unsigned char* buf, size_t bsize);
+
+    int EVP_PKEY_get_ec_point_conv_form(const EVP_PKEY* pkey);
+    int EVP_PKEY_get_field_type(const EVP_PKEY* pkey);
+
+    EVP_PKEY* EVP_PKEY_Q_keygen(OSSL_LIB_CTX* libctx, const char* propq, const char* type, ...);
+    int EVP_PKEY_paramgen_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_paramgen(EVP_PKEY_CTX* ctx, EVP_PKEY** ppkey);
+    int EVP_PKEY_keygen_init(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_keygen(EVP_PKEY_CTX* ctx, EVP_PKEY** ppkey);
+    int EVP_PKEY_generate(EVP_PKEY_CTX* ctx, EVP_PKEY** ppkey);
+    int EVP_PKEY_check(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_public_check(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_public_check_quick(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_param_check(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_param_check_quick(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_private_check(EVP_PKEY_CTX* ctx);
+    int EVP_PKEY_pairwise_check(EVP_PKEY_CTX* ctx);
+
+#define EVP_PKEY_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_EVP_PKEY, l, p, newf, dupf, freef)
-int EVP_PKEY_set_ex_data(EVP_PKEY *key, int idx, void *arg);
-void *EVP_PKEY_get_ex_data(const EVP_PKEY *key, int idx);
-
-void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb);
-EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx);
-
-int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
-                                             int (*init) (EVP_PKEY_CTX *ctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_copy
-    (EVP_PKEY_METHOD *pmeth, int (*copy) (EVP_PKEY_CTX *dst,
-                                          const EVP_PKEY_CTX *src));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_cleanup
-    (EVP_PKEY_METHOD *pmeth, void (*cleanup) (EVP_PKEY_CTX *ctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_paramgen
-    (EVP_PKEY_METHOD *pmeth, int (*paramgen_init) (EVP_PKEY_CTX *ctx),
-     int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_keygen
-    (EVP_PKEY_METHOD *pmeth, int (*keygen_init) (EVP_PKEY_CTX *ctx),
-     int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_sign
-    (EVP_PKEY_METHOD *pmeth, int (*sign_init) (EVP_PKEY_CTX *ctx),
-     int (*sign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
-                  const unsigned char *tbs, size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verify
-    (EVP_PKEY_METHOD *pmeth, int (*verify_init) (EVP_PKEY_CTX *ctx),
-     int (*verify) (EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
-                    const unsigned char *tbs, size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verify_recover
-    (EVP_PKEY_METHOD *pmeth, int (*verify_recover_init) (EVP_PKEY_CTX *ctx),
-     int (*verify_recover) (EVP_PKEY_CTX *ctx, unsigned char *sig,
-                            size_t *siglen, const unsigned char *tbs,
-                            size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_signctx
-    (EVP_PKEY_METHOD *pmeth, int (*signctx_init) (EVP_PKEY_CTX *ctx,
-                                                  EVP_MD_CTX *mctx),
-     int (*signctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
-                     EVP_MD_CTX *mctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verifyctx
-    (EVP_PKEY_METHOD *pmeth, int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
-                                                    EVP_MD_CTX *mctx),
-     int (*verifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig, int siglen,
-                       EVP_MD_CTX *mctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_encrypt
-    (EVP_PKEY_METHOD *pmeth, int (*encrypt_init) (EVP_PKEY_CTX *ctx),
-     int (*encryptfn) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
-                       const unsigned char *in, size_t inlen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_decrypt
-    (EVP_PKEY_METHOD *pmeth, int (*decrypt_init) (EVP_PKEY_CTX *ctx),
-     int (*decrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
-                     const unsigned char *in, size_t inlen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_derive
-    (EVP_PKEY_METHOD *pmeth, int (*derive_init) (EVP_PKEY_CTX *ctx),
-     int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_ctrl
-    (EVP_PKEY_METHOD *pmeth, int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
-                                          void *p2),
-     int (*ctrl_str) (EVP_PKEY_CTX *ctx, const char *type, const char *value));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digestsign
-    (EVP_PKEY_METHOD *pmeth,
-     int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
-                        const unsigned char *tbs, size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digestverify
-    (EVP_PKEY_METHOD *pmeth,
-     int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
-                          size_t siglen, const unsigned char *tbs,
-                          size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_check
-    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_public_check
-    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_param_check
-    (EVP_PKEY_METHOD *pmeth, int (*check) (EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digest_custom
-    (EVP_PKEY_METHOD *pmeth, int (*digest_custom) (EVP_PKEY_CTX *ctx,
-                                                   EVP_MD_CTX *mctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_init
-    (const EVP_PKEY_METHOD *pmeth, int (**pinit) (EVP_PKEY_CTX *ctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_copy
-    (const EVP_PKEY_METHOD *pmeth, int (**pcopy) (EVP_PKEY_CTX *dst,
-                                                  const EVP_PKEY_CTX *src));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_cleanup
-    (const EVP_PKEY_METHOD *pmeth, void (**pcleanup) (EVP_PKEY_CTX *ctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_paramgen
-    (const EVP_PKEY_METHOD *pmeth, int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
-     int (**pparamgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_keygen
-    (const EVP_PKEY_METHOD *pmeth, int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
-     int (**pkeygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_sign
-    (const EVP_PKEY_METHOD *pmeth, int (**psign_init) (EVP_PKEY_CTX *ctx),
-     int (**psign) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
-                    const unsigned char *tbs, size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verify
-    (const EVP_PKEY_METHOD *pmeth, int (**pverify_init) (EVP_PKEY_CTX *ctx),
-     int (**pverify) (EVP_PKEY_CTX *ctx, const unsigned char *sig,
-                      size_t siglen, const unsigned char *tbs, size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verify_recover
-    (const EVP_PKEY_METHOD *pmeth,
-     int (**pverify_recover_init) (EVP_PKEY_CTX *ctx),
-     int (**pverify_recover) (EVP_PKEY_CTX *ctx, unsigned char *sig,
-                              size_t *siglen, const unsigned char *tbs,
-                              size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_signctx
-    (const EVP_PKEY_METHOD *pmeth,
-     int (**psignctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
-     int (**psignctx) (EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
-                       EVP_MD_CTX *mctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verifyctx
-    (const EVP_PKEY_METHOD *pmeth,
-     int (**pverifyctx_init) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx),
-     int (**pverifyctx) (EVP_PKEY_CTX *ctx, const unsigned char *sig,
-                          int siglen, EVP_MD_CTX *mctx));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_encrypt
-    (const EVP_PKEY_METHOD *pmeth, int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
-     int (**pencryptfn) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
-                         const unsigned char *in, size_t inlen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_decrypt
-    (const EVP_PKEY_METHOD *pmeth, int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
-     int (**pdecrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
-                       const unsigned char *in, size_t inlen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_derive
-    (const EVP_PKEY_METHOD *pmeth, int (**pderive_init) (EVP_PKEY_CTX *ctx),
-     int (**pderive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_ctrl
-    (const EVP_PKEY_METHOD *pmeth,
-     int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1, void *p2),
-     int (**pctrl_str) (EVP_PKEY_CTX *ctx, const char *type,
-                        const char *value));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digestsign
-    (const EVP_PKEY_METHOD *pmeth,
-     int (**digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
-                         const unsigned char *tbs, size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digestverify
-    (const EVP_PKEY_METHOD *pmeth,
-     int (**digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig,
-                           size_t siglen, const unsigned char *tbs,
-                           size_t tbslen));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_check
-    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_public_check
-    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_param_check
-    (const EVP_PKEY_METHOD *pmeth, int (**pcheck) (EVP_PKEY *pkey));
-OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digest_custom
-    (const EVP_PKEY_METHOD *pmeth,
-     int (**pdigest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx));
-# endif
-
-void EVP_KEYEXCH_free(EVP_KEYEXCH *exchange);
-int EVP_KEYEXCH_up_ref(EVP_KEYEXCH *exchange);
-EVP_KEYEXCH *EVP_KEYEXCH_fetch(OSSL_LIB_CTX *ctx, const char *algorithm,
-                               const char *properties);
-OSSL_PROVIDER *EVP_KEYEXCH_get0_provider(const EVP_KEYEXCH *exchange);
-int EVP_KEYEXCH_is_a(const EVP_KEYEXCH *keyexch, const char *name);
-const char *EVP_KEYEXCH_get0_name(const EVP_KEYEXCH *keyexch);
-const char *EVP_KEYEXCH_get0_description(const EVP_KEYEXCH *keyexch);
-void EVP_KEYEXCH_do_all_provided(OSSL_LIB_CTX *libctx,
-                                 void (*fn)(EVP_KEYEXCH *keyexch, void *data),
-                                 void *data);
-int EVP_KEYEXCH_names_do_all(const EVP_KEYEXCH *keyexch,
-                             void (*fn)(const char *name, void *data),
-                             void *data);
-const OSSL_PARAM *EVP_KEYEXCH_gettable_ctx_params(const EVP_KEYEXCH *keyexch);
-const OSSL_PARAM *EVP_KEYEXCH_settable_ctx_params(const EVP_KEYEXCH *keyexch);
-
-void EVP_add_alg_module(void);
-
-int EVP_PKEY_CTX_set_group_name(EVP_PKEY_CTX *ctx, const char *name);
-int EVP_PKEY_CTX_get_group_name(EVP_PKEY_CTX *ctx, char *name, size_t namelen);
-int EVP_PKEY_get_group_name(const EVP_PKEY *pkey, char *name, size_t name_sz,
-                            size_t *gname_len);
-
-OSSL_LIB_CTX *EVP_PKEY_CTX_get0_libctx(EVP_PKEY_CTX *ctx);
-const char *EVP_PKEY_CTX_get0_propq(const EVP_PKEY_CTX *ctx);
-const OSSL_PROVIDER *EVP_PKEY_CTX_get0_provider(const EVP_PKEY_CTX *ctx);
-
-# ifdef  __cplusplus
+    int EVP_PKEY_set_ex_data(EVP_PKEY* key, int idx, void* arg);
+    void* EVP_PKEY_get_ex_data(const EVP_PKEY* key, int idx);
+
+    void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX* ctx, EVP_PKEY_gen_cb* cb);
+    EVP_PKEY_gen_cb* EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX* ctx);
+
+    int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX* ctx, int idx);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD* pmeth, int (*init)(EVP_PKEY_CTX* ctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD* pmeth, int (*copy)(EVP_PKEY_CTX* dst, const EVP_PKEY_CTX* src));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD* pmeth, void (*cleanup)(EVP_PKEY_CTX* ctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD* pmeth, int (*paramgen_init)(EVP_PKEY_CTX* ctx), int (*paramgen)(EVP_PKEY_CTX* ctx, EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD* pmeth, int (*keygen_init)(EVP_PKEY_CTX* ctx), int (*keygen)(EVP_PKEY_CTX* ctx, EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD* pmeth, int (*sign_init)(EVP_PKEY_CTX* ctx), int (*sign)(EVP_PKEY_CTX* ctx, unsigned char* sig, size_t* siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD* pmeth, int (*verify_init)(EVP_PKEY_CTX* ctx), int (*verify)(EVP_PKEY_CTX* ctx, const unsigned char* sig, size_t siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD* pmeth, int (*verify_recover_init)(EVP_PKEY_CTX* ctx), int (*verify_recover)(EVP_PKEY_CTX* ctx, unsigned char* sig, size_t* siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD* pmeth, int (*signctx_init)(EVP_PKEY_CTX* ctx, EVP_MD_CTX* mctx), int (*signctx)(EVP_PKEY_CTX* ctx, unsigned char* sig, size_t* siglen, EVP_MD_CTX* mctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD* pmeth, int (*verifyctx_init)(EVP_PKEY_CTX* ctx, EVP_MD_CTX* mctx), int (*verifyctx)(EVP_PKEY_CTX* ctx, const unsigned char* sig, int siglen, EVP_MD_CTX* mctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD* pmeth, int (*encrypt_init)(EVP_PKEY_CTX* ctx), int (*encryptfn)(EVP_PKEY_CTX* ctx, unsigned char* out, size_t* outlen, const unsigned char* in, size_t inlen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD* pmeth, int (*decrypt_init)(EVP_PKEY_CTX* ctx), int (*decrypt)(EVP_PKEY_CTX* ctx, unsigned char* out, size_t* outlen, const unsigned char* in, size_t inlen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD* pmeth, int (*derive_init)(EVP_PKEY_CTX* ctx), int (*derive)(EVP_PKEY_CTX* ctx, unsigned char* key, size_t* keylen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD* pmeth, int (*ctrl)(EVP_PKEY_CTX* ctx, int type, int p1, void* p2), int (*ctrl_str)(EVP_PKEY_CTX* ctx, const char* type, const char* value));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digestsign(EVP_PKEY_METHOD* pmeth, int (*digestsign)(EVP_MD_CTX* ctx, unsigned char* sig, size_t* siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digestverify(EVP_PKEY_METHOD* pmeth, int (*digestverify)(EVP_MD_CTX* ctx, const unsigned char* sig, size_t siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD* pmeth, int (*check)(EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD* pmeth, int (*check)(EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD* pmeth, int (*check)(EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_set_digest_custom(EVP_PKEY_METHOD* pmeth, int (*digest_custom)(EVP_PKEY_CTX* ctx, EVP_MD_CTX* mctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD* pmeth, int (**pinit)(EVP_PKEY_CTX* ctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD* pmeth, int (**pcopy)(EVP_PKEY_CTX* dst, const EVP_PKEY_CTX* src));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD* pmeth, void (**pcleanup)(EVP_PKEY_CTX* ctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD* pmeth, int (**pparamgen_init)(EVP_PKEY_CTX* ctx), int (**pparamgen)(EVP_PKEY_CTX* ctx, EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD* pmeth, int (**pkeygen_init)(EVP_PKEY_CTX* ctx), int (**pkeygen)(EVP_PKEY_CTX* ctx, EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_sign(const EVP_PKEY_METHOD* pmeth, int (**psign_init)(EVP_PKEY_CTX* ctx), int (**psign)(EVP_PKEY_CTX* ctx, unsigned char* sig, size_t* siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verify(const EVP_PKEY_METHOD* pmeth, int (**pverify_init)(EVP_PKEY_CTX* ctx), int (**pverify)(EVP_PKEY_CTX* ctx, const unsigned char* sig, size_t siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verify_recover(const EVP_PKEY_METHOD* pmeth, int (**pverify_recover_init)(EVP_PKEY_CTX* ctx), int (**pverify_recover)(EVP_PKEY_CTX* ctx, unsigned char* sig, size_t* siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_signctx(const EVP_PKEY_METHOD* pmeth, int (**psignctx_init)(EVP_PKEY_CTX* ctx, EVP_MD_CTX* mctx), int (**psignctx)(EVP_PKEY_CTX* ctx, unsigned char* sig, size_t* siglen, EVP_MD_CTX* mctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_verifyctx(const EVP_PKEY_METHOD* pmeth, int (**pverifyctx_init)(EVP_PKEY_CTX* ctx, EVP_MD_CTX* mctx), int (**pverifyctx)(EVP_PKEY_CTX* ctx, const unsigned char* sig, int siglen, EVP_MD_CTX* mctx));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_encrypt(const EVP_PKEY_METHOD* pmeth, int (**pencrypt_init)(EVP_PKEY_CTX* ctx), int (**pencryptfn)(EVP_PKEY_CTX* ctx, unsigned char* out, size_t* outlen, const unsigned char* in, size_t inlen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_decrypt(const EVP_PKEY_METHOD* pmeth, int (**pdecrypt_init)(EVP_PKEY_CTX* ctx), int (**pdecrypt)(EVP_PKEY_CTX* ctx, unsigned char* out, size_t* outlen, const unsigned char* in, size_t inlen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD* pmeth, int (**pderive_init)(EVP_PKEY_CTX* ctx), int (**pderive)(EVP_PKEY_CTX* ctx, unsigned char* key, size_t* keylen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_ctrl(const EVP_PKEY_METHOD* pmeth, int (**pctrl)(EVP_PKEY_CTX* ctx, int type, int p1, void* p2), int (**pctrl_str)(EVP_PKEY_CTX* ctx, const char* type, const char* value));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digestsign(const EVP_PKEY_METHOD* pmeth, int (**digestsign)(EVP_MD_CTX* ctx, unsigned char* sig, size_t* siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digestverify(const EVP_PKEY_METHOD* pmeth, int (**digestverify)(EVP_MD_CTX* ctx, const unsigned char* sig, size_t siglen, const unsigned char* tbs, size_t tbslen));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD* pmeth, int (**pcheck)(EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD* pmeth, int (**pcheck)(EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD* pmeth, int (**pcheck)(EVP_PKEY* pkey));
+    OSSL_DEPRECATEDIN_3_0 void EVP_PKEY_meth_get_digest_custom(const EVP_PKEY_METHOD* pmeth, int (**pdigest_custom)(EVP_PKEY_CTX* ctx, EVP_MD_CTX* mctx));
+#endif
+
+    void EVP_KEYEXCH_free(EVP_KEYEXCH* exchange);
+    int EVP_KEYEXCH_up_ref(EVP_KEYEXCH* exchange);
+    EVP_KEYEXCH* EVP_KEYEXCH_fetch(OSSL_LIB_CTX* ctx, const char* algorithm, const char* properties);
+    OSSL_PROVIDER* EVP_KEYEXCH_get0_provider(const EVP_KEYEXCH* exchange);
+    int EVP_KEYEXCH_is_a(const EVP_KEYEXCH* keyexch, const char* name);
+    const char* EVP_KEYEXCH_get0_name(const EVP_KEYEXCH* keyexch);
+    const char* EVP_KEYEXCH_get0_description(const EVP_KEYEXCH* keyexch);
+    void EVP_KEYEXCH_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_KEYEXCH* keyexch, void* data), void* data);
+    int EVP_KEYEXCH_names_do_all(const EVP_KEYEXCH* keyexch, void (*fn)(const char* name, void* data), void* data);
+    const OSSL_PARAM* EVP_KEYEXCH_gettable_ctx_params(const EVP_KEYEXCH* keyexch);
+    const OSSL_PARAM* EVP_KEYEXCH_settable_ctx_params(const EVP_KEYEXCH* keyexch);
+
+    void EVP_add_alg_module(void);
+
+    int EVP_PKEY_CTX_set_group_name(EVP_PKEY_CTX* ctx, const char* name);
+    int EVP_PKEY_CTX_get_group_name(EVP_PKEY_CTX* ctx, char* name, size_t namelen);
+    int EVP_PKEY_get_group_name(const EVP_PKEY* pkey, char* name, size_t name_sz, size_t* gname_len);
+
+    OSSL_LIB_CTX* EVP_PKEY_CTX_get0_libctx(EVP_PKEY_CTX* ctx);
+    const char* EVP_PKEY_CTX_get0_propq(const EVP_PKEY_CTX* ctx);
+    const OSSL_PROVIDER* EVP_PKEY_CTX_get0_provider(const EVP_PKEY_CTX* ctx);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/evperr.h b/CAPI/cpp/grpc/include/openssl/evperr.h
index a5053f6..9f021ab 100644
--- a/CAPI/cpp/grpc/include/openssl/evperr.h
+++ b/CAPI/cpp/grpc/include/openssl/evperr.h
@@ -9,126 +9,124 @@
  */
 
 #ifndef OPENSSL_EVPERR_H
-# define OPENSSL_EVPERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_EVPERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * EVP reason codes.
  */
-# define EVP_R_AES_KEY_SETUP_FAILED                       143
-# define EVP_R_ARIA_KEY_SETUP_FAILED                      176
-# define EVP_R_BAD_ALGORITHM_NAME                         200
-# define EVP_R_BAD_DECRYPT                                100
-# define EVP_R_BAD_KEY_LENGTH                             195
-# define EVP_R_BUFFER_TOO_SMALL                           155
-# define EVP_R_CACHE_CONSTANTS_FAILED                     225
-# define EVP_R_CAMELLIA_KEY_SETUP_FAILED                  157
-# define EVP_R_CANNOT_GET_PARAMETERS                      197
-# define EVP_R_CANNOT_SET_PARAMETERS                      198
-# define EVP_R_CIPHER_NOT_GCM_MODE                        184
-# define EVP_R_CIPHER_PARAMETER_ERROR                     122
-# define EVP_R_COMMAND_NOT_SUPPORTED                      147
-# define EVP_R_CONFLICTING_ALGORITHM_NAME                 201
-# define EVP_R_COPY_ERROR                                 173
-# define EVP_R_CTRL_NOT_IMPLEMENTED                       132
-# define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED             133
-# define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH          138
-# define EVP_R_DECODE_ERROR                               114
-# define EVP_R_DEFAULT_QUERY_PARSE_ERROR                  210
-# define EVP_R_DIFFERENT_KEY_TYPES                        101
-# define EVP_R_DIFFERENT_PARAMETERS                       153
-# define EVP_R_ERROR_LOADING_SECTION                      165
-# define EVP_R_EXPECTING_AN_HMAC_KEY                      174
-# define EVP_R_EXPECTING_AN_RSA_KEY                       127
-# define EVP_R_EXPECTING_A_DH_KEY                         128
-# define EVP_R_EXPECTING_A_DSA_KEY                        129
-# define EVP_R_EXPECTING_A_ECX_KEY                        219
-# define EVP_R_EXPECTING_A_EC_KEY                         142
-# define EVP_R_EXPECTING_A_POLY1305_KEY                   164
-# define EVP_R_EXPECTING_A_SIPHASH_KEY                    175
-# define EVP_R_FINAL_ERROR                                188
-# define EVP_R_GENERATE_ERROR                             214
-# define EVP_R_GET_RAW_KEY_FAILED                         182
-# define EVP_R_ILLEGAL_SCRYPT_PARAMETERS                  171
-# define EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS             204
-# define EVP_R_INACCESSIBLE_KEY                           203
-# define EVP_R_INITIALIZATION_ERROR                       134
-# define EVP_R_INPUT_NOT_INITIALIZED                      111
-# define EVP_R_INVALID_CUSTOM_LENGTH                      185
-# define EVP_R_INVALID_DIGEST                             152
-# define EVP_R_INVALID_IV_LENGTH                          194
-# define EVP_R_INVALID_KEY                                163
-# define EVP_R_INVALID_KEY_LENGTH                         130
-# define EVP_R_INVALID_LENGTH                             221
-# define EVP_R_INVALID_NULL_ALGORITHM                     218
-# define EVP_R_INVALID_OPERATION                          148
-# define EVP_R_INVALID_PROVIDER_FUNCTIONS                 193
-# define EVP_R_INVALID_SALT_LENGTH                        186
-# define EVP_R_INVALID_SECRET_LENGTH                      223
-# define EVP_R_INVALID_SEED_LENGTH                        220
-# define EVP_R_INVALID_VALUE                              222
-# define EVP_R_KEYMGMT_EXPORT_FAILURE                     205
-# define EVP_R_KEY_SETUP_FAILED                           180
-# define EVP_R_LOCKING_NOT_SUPPORTED                      213
-# define EVP_R_MEMORY_LIMIT_EXCEEDED                      172
-# define EVP_R_MESSAGE_DIGEST_IS_NULL                     159
-# define EVP_R_METHOD_NOT_SUPPORTED                       144
-# define EVP_R_MISSING_PARAMETERS                         103
-# define EVP_R_NOT_ABLE_TO_COPY_CTX                       190
-# define EVP_R_NOT_XOF_OR_INVALID_LENGTH                  178
-# define EVP_R_NO_CIPHER_SET                              131
-# define EVP_R_NO_DEFAULT_DIGEST                          158
-# define EVP_R_NO_DIGEST_SET                              139
-# define EVP_R_NO_IMPORT_FUNCTION                         206
-# define EVP_R_NO_KEYMGMT_AVAILABLE                       199
-# define EVP_R_NO_KEYMGMT_PRESENT                         196
-# define EVP_R_NO_KEY_SET                                 154
-# define EVP_R_NO_OPERATION_SET                           149
-# define EVP_R_NULL_MAC_PKEY_CTX                          208
-# define EVP_R_ONLY_ONESHOT_SUPPORTED                     177
-# define EVP_R_OPERATION_NOT_INITIALIZED                  151
-# define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE   150
-# define EVP_R_OUTPUT_WOULD_OVERFLOW                      202
-# define EVP_R_PARAMETER_TOO_LARGE                        187
-# define EVP_R_PARTIALLY_OVERLAPPING                      162
-# define EVP_R_PBKDF2_ERROR                               181
-# define EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED 179
-# define EVP_R_PRIVATE_KEY_DECODE_ERROR                   145
-# define EVP_R_PRIVATE_KEY_ENCODE_ERROR                   146
-# define EVP_R_PUBLIC_KEY_NOT_RSA                         106
-# define EVP_R_SETTING_XOF_FAILED                         227
-# define EVP_R_SET_DEFAULT_PROPERTY_FAILURE               209
-# define EVP_R_TOO_MANY_RECORDS                           183
-# define EVP_R_UNABLE_TO_ENABLE_LOCKING                   212
-# define EVP_R_UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE         215
-# define EVP_R_UNABLE_TO_GET_RANDOM_STRENGTH              216
-# define EVP_R_UNABLE_TO_LOCK_CONTEXT                     211
-# define EVP_R_UNABLE_TO_SET_CALLBACKS                    217
-# define EVP_R_UNKNOWN_CIPHER                             160
-# define EVP_R_UNKNOWN_DIGEST                             161
-# define EVP_R_UNKNOWN_KEY_TYPE                           207
-# define EVP_R_UNKNOWN_OPTION                             169
-# define EVP_R_UNKNOWN_PBE_ALGORITHM                      121
-# define EVP_R_UNSUPPORTED_ALGORITHM                      156
-# define EVP_R_UNSUPPORTED_CIPHER                         107
-# define EVP_R_UNSUPPORTED_KEYLENGTH                      123
-# define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION        124
-# define EVP_R_UNSUPPORTED_KEY_SIZE                       108
-# define EVP_R_UNSUPPORTED_KEY_TYPE                       224
-# define EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS               135
-# define EVP_R_UNSUPPORTED_PRF                            125
-# define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM          118
-# define EVP_R_UNSUPPORTED_SALT_TYPE                      126
-# define EVP_R_UPDATE_ERROR                               189
-# define EVP_R_WRAP_MODE_NOT_ALLOWED                      170
-# define EVP_R_WRONG_FINAL_BLOCK_LENGTH                   109
-# define EVP_R_XTS_DATA_UNIT_IS_TOO_LARGE                 191
-# define EVP_R_XTS_DUPLICATED_KEYS                        192
+#define EVP_R_AES_KEY_SETUP_FAILED 143
+#define EVP_R_ARIA_KEY_SETUP_FAILED 176
+#define EVP_R_BAD_ALGORITHM_NAME 200
+#define EVP_R_BAD_DECRYPT 100
+#define EVP_R_BAD_KEY_LENGTH 195
+#define EVP_R_BUFFER_TOO_SMALL 155
+#define EVP_R_CACHE_CONSTANTS_FAILED 225
+#define EVP_R_CAMELLIA_KEY_SETUP_FAILED 157
+#define EVP_R_CANNOT_GET_PARAMETERS 197
+#define EVP_R_CANNOT_SET_PARAMETERS 198
+#define EVP_R_CIPHER_NOT_GCM_MODE 184
+#define EVP_R_CIPHER_PARAMETER_ERROR 122
+#define EVP_R_COMMAND_NOT_SUPPORTED 147
+#define EVP_R_CONFLICTING_ALGORITHM_NAME 201
+#define EVP_R_COPY_ERROR 173
+#define EVP_R_CTRL_NOT_IMPLEMENTED 132
+#define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED 133
+#define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH 138
+#define EVP_R_DECODE_ERROR 114
+#define EVP_R_DEFAULT_QUERY_PARSE_ERROR 210
+#define EVP_R_DIFFERENT_KEY_TYPES 101
+#define EVP_R_DIFFERENT_PARAMETERS 153
+#define EVP_R_ERROR_LOADING_SECTION 165
+#define EVP_R_EXPECTING_AN_HMAC_KEY 174
+#define EVP_R_EXPECTING_AN_RSA_KEY 127
+#define EVP_R_EXPECTING_A_DH_KEY 128
+#define EVP_R_EXPECTING_A_DSA_KEY 129
+#define EVP_R_EXPECTING_A_ECX_KEY 219
+#define EVP_R_EXPECTING_A_EC_KEY 142
+#define EVP_R_EXPECTING_A_POLY1305_KEY 164
+#define EVP_R_EXPECTING_A_SIPHASH_KEY 175
+#define EVP_R_FINAL_ERROR 188
+#define EVP_R_GENERATE_ERROR 214
+#define EVP_R_GET_RAW_KEY_FAILED 182
+#define EVP_R_ILLEGAL_SCRYPT_PARAMETERS 171
+#define EVP_R_INACCESSIBLE_DOMAIN_PARAMETERS 204
+#define EVP_R_INACCESSIBLE_KEY 203
+#define EVP_R_INITIALIZATION_ERROR 134
+#define EVP_R_INPUT_NOT_INITIALIZED 111
+#define EVP_R_INVALID_CUSTOM_LENGTH 185
+#define EVP_R_INVALID_DIGEST 152
+#define EVP_R_INVALID_IV_LENGTH 194
+#define EVP_R_INVALID_KEY 163
+#define EVP_R_INVALID_KEY_LENGTH 130
+#define EVP_R_INVALID_LENGTH 221
+#define EVP_R_INVALID_NULL_ALGORITHM 218
+#define EVP_R_INVALID_OPERATION 148
+#define EVP_R_INVALID_PROVIDER_FUNCTIONS 193
+#define EVP_R_INVALID_SALT_LENGTH 186
+#define EVP_R_INVALID_SECRET_LENGTH 223
+#define EVP_R_INVALID_SEED_LENGTH 220
+#define EVP_R_INVALID_VALUE 222
+#define EVP_R_KEYMGMT_EXPORT_FAILURE 205
+#define EVP_R_KEY_SETUP_FAILED 180
+#define EVP_R_LOCKING_NOT_SUPPORTED 213
+#define EVP_R_MEMORY_LIMIT_EXCEEDED 172
+#define EVP_R_MESSAGE_DIGEST_IS_NULL 159
+#define EVP_R_METHOD_NOT_SUPPORTED 144
+#define EVP_R_MISSING_PARAMETERS 103
+#define EVP_R_NOT_ABLE_TO_COPY_CTX 190
+#define EVP_R_NOT_XOF_OR_INVALID_LENGTH 178
+#define EVP_R_NO_CIPHER_SET 131
+#define EVP_R_NO_DEFAULT_DIGEST 158
+#define EVP_R_NO_DIGEST_SET 139
+#define EVP_R_NO_IMPORT_FUNCTION 206
+#define EVP_R_NO_KEYMGMT_AVAILABLE 199
+#define EVP_R_NO_KEYMGMT_PRESENT 196
+#define EVP_R_NO_KEY_SET 154
+#define EVP_R_NO_OPERATION_SET 149
+#define EVP_R_NULL_MAC_PKEY_CTX 208
+#define EVP_R_ONLY_ONESHOT_SUPPORTED 177
+#define EVP_R_OPERATION_NOT_INITIALIZED 151
+#define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 150
+#define EVP_R_OUTPUT_WOULD_OVERFLOW 202
+#define EVP_R_PARAMETER_TOO_LARGE 187
+#define EVP_R_PARTIALLY_OVERLAPPING 162
+#define EVP_R_PBKDF2_ERROR 181
+#define EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED 179
+#define EVP_R_PRIVATE_KEY_DECODE_ERROR 145
+#define EVP_R_PRIVATE_KEY_ENCODE_ERROR 146
+#define EVP_R_PUBLIC_KEY_NOT_RSA 106
+#define EVP_R_SETTING_XOF_FAILED 227
+#define EVP_R_SET_DEFAULT_PROPERTY_FAILURE 209
+#define EVP_R_TOO_MANY_RECORDS 183
+#define EVP_R_UNABLE_TO_ENABLE_LOCKING 212
+#define EVP_R_UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE 215
+#define EVP_R_UNABLE_TO_GET_RANDOM_STRENGTH 216
+#define EVP_R_UNABLE_TO_LOCK_CONTEXT 211
+#define EVP_R_UNABLE_TO_SET_CALLBACKS 217
+#define EVP_R_UNKNOWN_CIPHER 160
+#define EVP_R_UNKNOWN_DIGEST 161
+#define EVP_R_UNKNOWN_KEY_TYPE 207
+#define EVP_R_UNKNOWN_OPTION 169
+#define EVP_R_UNKNOWN_PBE_ALGORITHM 121
+#define EVP_R_UNSUPPORTED_ALGORITHM 156
+#define EVP_R_UNSUPPORTED_CIPHER 107
+#define EVP_R_UNSUPPORTED_KEYLENGTH 123
+#define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION 124
+#define EVP_R_UNSUPPORTED_KEY_SIZE 108
+#define EVP_R_UNSUPPORTED_KEY_TYPE 224
+#define EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS 135
+#define EVP_R_UNSUPPORTED_PRF 125
+#define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM 118
+#define EVP_R_UNSUPPORTED_SALT_TYPE 126
+#define EVP_R_UPDATE_ERROR 189
+#define EVP_R_WRAP_MODE_NOT_ALLOWED 170
+#define EVP_R_WRONG_FINAL_BLOCK_LENGTH 109
+#define EVP_R_XTS_DATA_UNIT_IS_TOO_LARGE 191
+#define EVP_R_XTS_DUPLICATED_KEYS 192
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/fips_names.h b/CAPI/cpp/grpc/include/openssl/fips_names.h
index 0fdf544..b6a0588 100644
--- a/CAPI/cpp/grpc/include/openssl/fips_names.h
+++ b/CAPI/cpp/grpc/include/openssl/fips_names.h
@@ -8,12 +8,13 @@
  */
 
 #ifndef OPENSSL_FIPS_NAMES_H
-# define OPENSSL_FIPS_NAMES_H
-# pragma once
+#define OPENSSL_FIPS_NAMES_H
+#pragma once
 
-# ifdef __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /*
  * Parameter names that the FIPS Provider defines
@@ -23,38 +24,38 @@ extern "C" {
  * The calculated MAC of the module file (Used for FIPS Self Testing)
  * Type: OSSL_PARAM_UTF8_STRING
  */
-# define OSSL_PROV_FIPS_PARAM_MODULE_MAC      "module-mac"
+#define OSSL_PROV_FIPS_PARAM_MODULE_MAC "module-mac"
 /*
  * A version number for the fips install process (Used for FIPS Self Testing)
  * Type: OSSL_PARAM_UTF8_STRING
  */
-# define OSSL_PROV_FIPS_PARAM_INSTALL_VERSION "install-version"
+#define OSSL_PROV_FIPS_PARAM_INSTALL_VERSION "install-version"
 /*
  * The calculated MAC of the install status indicator (Used for FIPS Self Testing)
  * Type: OSSL_PARAM_UTF8_STRING
  */
-# define OSSL_PROV_FIPS_PARAM_INSTALL_MAC     "install-mac"
+#define OSSL_PROV_FIPS_PARAM_INSTALL_MAC "install-mac"
 /*
  * The install status indicator (Used for FIPS Self Testing)
  * Type: OSSL_PARAM_UTF8_STRING
  */
-# define OSSL_PROV_FIPS_PARAM_INSTALL_STATUS  "install-status"
+#define OSSL_PROV_FIPS_PARAM_INSTALL_STATUS "install-status"
 
 /*
  * A boolean that determines if the FIPS conditional test errors result in
  * the module entering an error state.
  * Type: OSSL_PARAM_UTF8_STRING
  */
-# define OSSL_PROV_FIPS_PARAM_CONDITIONAL_ERRORS "conditional-errors"
+#define OSSL_PROV_FIPS_PARAM_CONDITIONAL_ERRORS "conditional-errors"
 
 /*
  * A boolean that determines if the runtime FIPS security checks are performed.
  * Type: OSSL_PARAM_UTF8_STRING
  */
-# define OSSL_PROV_FIPS_PARAM_SECURITY_CHECKS "security-checks"
+#define OSSL_PROV_FIPS_PARAM_SECURITY_CHECKS "security-checks"
 
-# ifdef __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif /* OPENSSL_FIPS_NAMES_H */
diff --git a/CAPI/cpp/grpc/include/openssl/fipskey.h b/CAPI/cpp/grpc/include/openssl/fipskey.h
index ccc1d2f..529bfa6 100644
--- a/CAPI/cpp/grpc/include/openssl/fipskey.h
+++ b/CAPI/cpp/grpc/include/openssl/fipskey.h
@@ -11,12 +11,13 @@
  */
 
 #ifndef OPENSSL_FIPSKEY_H
-# define OPENSSL_FIPSKEY_H
-# pragma once
+#define OPENSSL_FIPSKEY_H
+#pragma once
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /*
  * The FIPS validation HMAC key, usable as an array initializer.
@@ -29,8 +30,8 @@ extern "C" {
  */
 #define FIPS_KEY_STRING "f4556650ac31d35461610bac4ed81b1a181b2d8a43ea2854cbae22ca74560813"
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/hmac.h b/CAPI/cpp/grpc/include/openssl/hmac.h
index f9e1bff..b54d6d8 100644
--- a/CAPI/cpp/grpc/include/openssl/hmac.h
+++ b/CAPI/cpp/grpc/include/openssl/hmac.h
@@ -8,55 +8,49 @@
  */
 
 #ifndef OPENSSL_HMAC_H
-# define OPENSSL_HMAC_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_HMAC_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# include <openssl/evp.h>
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HMAC_MAX_MD_CBLOCK      200    /* Deprecated */
-# endif
-
-# ifdef  __cplusplus
-extern "C" {
-# endif
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 size_t HMAC_size(const HMAC_CTX *e);
-OSSL_DEPRECATEDIN_3_0 HMAC_CTX *HMAC_CTX_new(void);
-OSSL_DEPRECATEDIN_3_0 int HMAC_CTX_reset(HMAC_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_free(HMAC_CTX *ctx);
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 __owur int HMAC_Init(HMAC_CTX *ctx,
-                                             const void *key, int len,
-                                             const EVP_MD *md);
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
-                                       const EVP_MD *md, ENGINE *impl);
-OSSL_DEPRECATEDIN_3_0 int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data,
-                                      size_t len);
-OSSL_DEPRECATEDIN_3_0 int HMAC_Final(HMAC_CTX *ctx, unsigned char *md,
-                                     unsigned int *len);
-OSSL_DEPRECATEDIN_3_0 __owur int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);
-OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags);
-OSSL_DEPRECATEDIN_3_0 const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx);
-# endif
-
-unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
-                    const unsigned char *data, size_t data_len,
-                    unsigned char *md, unsigned int *md_len);
-
-# ifdef  __cplusplus
+#define OPENSSL_HMAC_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_HMAC_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#include <openssl/evp.h>
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HMAC_MAX_MD_CBLOCK 200 /* Deprecated */
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 size_t HMAC_size(const HMAC_CTX* e);
+    OSSL_DEPRECATEDIN_3_0 HMAC_CTX* HMAC_CTX_new(void);
+    OSSL_DEPRECATEDIN_3_0 int HMAC_CTX_reset(HMAC_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_free(HMAC_CTX* ctx);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 __owur int HMAC_Init(HMAC_CTX* ctx, const void* key, int len, const EVP_MD* md);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int HMAC_Init_ex(HMAC_CTX* ctx, const void* key, int len, const EVP_MD* md, ENGINE* impl);
+    OSSL_DEPRECATEDIN_3_0 int HMAC_Update(HMAC_CTX* ctx, const unsigned char* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int HMAC_Final(HMAC_CTX* ctx, unsigned char* md, unsigned int* len);
+    OSSL_DEPRECATEDIN_3_0 __owur int HMAC_CTX_copy(HMAC_CTX* dctx, HMAC_CTX* sctx);
+    OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_set_flags(HMAC_CTX* ctx, unsigned long flags);
+    OSSL_DEPRECATEDIN_3_0 const EVP_MD* HMAC_CTX_get_md(const HMAC_CTX* ctx);
+#endif
+
+    unsigned char* HMAC(const EVP_MD* evp_md, const void* key, int key_len, const unsigned char* data, size_t data_len, unsigned char* md, unsigned int* md_len);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/http.h b/CAPI/cpp/grpc/include/openssl/http.h
index f7ab214..ba26f7c 100644
--- a/CAPI/cpp/grpc/include/openssl/http.h
+++ b/CAPI/cpp/grpc/include/openssl/http.h
@@ -9,101 +9,64 @@
  */
 
 #ifndef OPENSSL_HTTP_H
-# define OPENSSL_HTTP_H
-# pragma once
+#define OPENSSL_HTTP_H
+#pragma once
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# include <openssl/bio.h>
-# include <openssl/asn1.h>
-# include <openssl/conf.h>
+#include <openssl/bio.h>
+#include <openssl/asn1.h>
+#include <openssl/conf.h>
 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-# define OSSL_HTTP_NAME "http"
-# define OSSL_HTTPS_NAME "https"
-# define OSSL_HTTP_PREFIX OSSL_HTTP_NAME"://"
-# define OSSL_HTTPS_PREFIX OSSL_HTTPS_NAME"://"
-# define OSSL_HTTP_PORT "80"
-# define OSSL_HTTPS_PORT "443"
-# define OPENSSL_NO_PROXY "NO_PROXY"
-# define OPENSSL_HTTP_PROXY "HTTP_PROXY"
-# define OPENSSL_HTTPS_PROXY "HTTPS_PROXY"
+#define OSSL_HTTP_NAME "http"
+#define OSSL_HTTPS_NAME "https"
+#define OSSL_HTTP_PREFIX OSSL_HTTP_NAME "://"
+#define OSSL_HTTPS_PREFIX OSSL_HTTPS_NAME "://"
+#define OSSL_HTTP_PORT "80"
+#define OSSL_HTTPS_PORT "443"
+#define OPENSSL_NO_PROXY "NO_PROXY"
+#define OPENSSL_HTTP_PROXY "HTTP_PROXY"
+#define OPENSSL_HTTPS_PROXY "HTTPS_PROXY"
 
 #define OSSL_HTTP_DEFAULT_MAX_LINE_LEN (4 * 1024)
 #define OSSL_HTTP_DEFAULT_MAX_RESP_LEN (100 * 1024)
 
-/* Low-level HTTP API */
-OSSL_HTTP_REQ_CTX *OSSL_HTTP_REQ_CTX_new(BIO *wbio, BIO *rbio, int buf_size);
-void OSSL_HTTP_REQ_CTX_free(OSSL_HTTP_REQ_CTX *rctx);
-int OSSL_HTTP_REQ_CTX_set_request_line(OSSL_HTTP_REQ_CTX *rctx, int method_POST,
-                                       const char *server, const char *port,
-                                       const char *path);
-int OSSL_HTTP_REQ_CTX_add1_header(OSSL_HTTP_REQ_CTX *rctx,
-                                  const char *name, const char *value);
-int OSSL_HTTP_REQ_CTX_set_expected(OSSL_HTTP_REQ_CTX *rctx,
-                                   const char *content_type, int asn1,
-                                   int timeout, int keep_alive);
-int OSSL_HTTP_REQ_CTX_set1_req(OSSL_HTTP_REQ_CTX *rctx, const char *content_type,
-                               const ASN1_ITEM *it, const ASN1_VALUE *req);
-int OSSL_HTTP_REQ_CTX_nbio(OSSL_HTTP_REQ_CTX *rctx);
-int OSSL_HTTP_REQ_CTX_nbio_d2i(OSSL_HTTP_REQ_CTX *rctx,
-                               ASN1_VALUE **pval, const ASN1_ITEM *it);
-BIO *OSSL_HTTP_REQ_CTX_exchange(OSSL_HTTP_REQ_CTX *rctx);
-BIO *OSSL_HTTP_REQ_CTX_get0_mem_bio(const OSSL_HTTP_REQ_CTX *rctx);
-size_t OSSL_HTTP_REQ_CTX_get_resp_len(const OSSL_HTTP_REQ_CTX *rctx);
-void OSSL_HTTP_REQ_CTX_set_max_response_length(OSSL_HTTP_REQ_CTX *rctx,
-                                               unsigned long len);
-int OSSL_HTTP_is_alive(const OSSL_HTTP_REQ_CTX *rctx);
+    /* Low-level HTTP API */
+    OSSL_HTTP_REQ_CTX* OSSL_HTTP_REQ_CTX_new(BIO* wbio, BIO* rbio, int buf_size);
+    void OSSL_HTTP_REQ_CTX_free(OSSL_HTTP_REQ_CTX* rctx);
+    int OSSL_HTTP_REQ_CTX_set_request_line(OSSL_HTTP_REQ_CTX* rctx, int method_POST, const char* server, const char* port, const char* path);
+    int OSSL_HTTP_REQ_CTX_add1_header(OSSL_HTTP_REQ_CTX* rctx, const char* name, const char* value);
+    int OSSL_HTTP_REQ_CTX_set_expected(OSSL_HTTP_REQ_CTX* rctx, const char* content_type, int asn1, int timeout, int keep_alive);
+    int OSSL_HTTP_REQ_CTX_set1_req(OSSL_HTTP_REQ_CTX* rctx, const char* content_type, const ASN1_ITEM* it, const ASN1_VALUE* req);
+    int OSSL_HTTP_REQ_CTX_nbio(OSSL_HTTP_REQ_CTX* rctx);
+    int OSSL_HTTP_REQ_CTX_nbio_d2i(OSSL_HTTP_REQ_CTX* rctx, ASN1_VALUE** pval, const ASN1_ITEM* it);
+    BIO* OSSL_HTTP_REQ_CTX_exchange(OSSL_HTTP_REQ_CTX* rctx);
+    BIO* OSSL_HTTP_REQ_CTX_get0_mem_bio(const OSSL_HTTP_REQ_CTX* rctx);
+    size_t OSSL_HTTP_REQ_CTX_get_resp_len(const OSSL_HTTP_REQ_CTX* rctx);
+    void OSSL_HTTP_REQ_CTX_set_max_response_length(OSSL_HTTP_REQ_CTX* rctx, unsigned long len);
+    int OSSL_HTTP_is_alive(const OSSL_HTTP_REQ_CTX* rctx);
 
-/* High-level HTTP API */
-typedef BIO *(*OSSL_HTTP_bio_cb_t)(BIO *bio, void *arg, int connect, int detail);
-OSSL_HTTP_REQ_CTX *OSSL_HTTP_open(const char *server, const char *port,
-                                  const char *proxy, const char *no_proxy,
-                                  int use_ssl, BIO *bio, BIO *rbio,
-                                  OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
-                                  int buf_size, int overall_timeout);
-int OSSL_HTTP_proxy_connect(BIO *bio, const char *server, const char *port,
-                            const char *proxyuser, const char *proxypass,
-                            int timeout, BIO *bio_err, const char *prog);
-int OSSL_HTTP_set1_request(OSSL_HTTP_REQ_CTX *rctx, const char *path,
-                           const STACK_OF(CONF_VALUE) *headers,
-                           const char *content_type, BIO *req,
-                           const char *expected_content_type, int expect_asn1,
-                           size_t max_resp_len, int timeout, int keep_alive);
-BIO *OSSL_HTTP_exchange(OSSL_HTTP_REQ_CTX *rctx, char **redirection_url);
-BIO *OSSL_HTTP_get(const char *url, const char *proxy, const char *no_proxy,
-                   BIO *bio, BIO *rbio,
-                   OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
-                   int buf_size, const STACK_OF(CONF_VALUE) *headers,
-                   const char *expected_content_type, int expect_asn1,
-                   size_t max_resp_len, int timeout);
-BIO *OSSL_HTTP_transfer(OSSL_HTTP_REQ_CTX **prctx,
-                        const char *server, const char *port,
-                        const char *path, int use_ssl,
-                        const char *proxy, const char *no_proxy,
-                        BIO *bio, BIO *rbio,
-                        OSSL_HTTP_bio_cb_t bio_update_fn, void *arg,
-                        int buf_size, const STACK_OF(CONF_VALUE) *headers,
-                        const char *content_type, BIO *req,
-                        const char *expected_content_type, int expect_asn1,
-                        size_t max_resp_len, int timeout, int keep_alive);
-int OSSL_HTTP_close(OSSL_HTTP_REQ_CTX *rctx, int ok);
+    /* High-level HTTP API */
+    typedef BIO* (*OSSL_HTTP_bio_cb_t)(BIO* bio, void* arg, int connect, int detail);
+    OSSL_HTTP_REQ_CTX* OSSL_HTTP_open(const char* server, const char* port, const char* proxy, const char* no_proxy, int use_ssl, BIO* bio, BIO* rbio, OSSL_HTTP_bio_cb_t bio_update_fn, void* arg, int buf_size, int overall_timeout);
+    int OSSL_HTTP_proxy_connect(BIO* bio, const char* server, const char* port, const char* proxyuser, const char* proxypass, int timeout, BIO* bio_err, const char* prog);
+    int OSSL_HTTP_set1_request(OSSL_HTTP_REQ_CTX* rctx, const char* path, const STACK_OF(CONF_VALUE) * headers, const char* content_type, BIO* req, const char* expected_content_type, int expect_asn1, size_t max_resp_len, int timeout, int keep_alive);
+    BIO* OSSL_HTTP_exchange(OSSL_HTTP_REQ_CTX* rctx, char** redirection_url);
+    BIO* OSSL_HTTP_get(const char* url, const char* proxy, const char* no_proxy, BIO* bio, BIO* rbio, OSSL_HTTP_bio_cb_t bio_update_fn, void* arg, int buf_size, const STACK_OF(CONF_VALUE) * headers, const char* expected_content_type, int expect_asn1, size_t max_resp_len, int timeout);
+    BIO* OSSL_HTTP_transfer(OSSL_HTTP_REQ_CTX** prctx, const char* server, const char* port, const char* path, int use_ssl, const char* proxy, const char* no_proxy, BIO* bio, BIO* rbio, OSSL_HTTP_bio_cb_t bio_update_fn, void* arg, int buf_size, const STACK_OF(CONF_VALUE) * headers, const char* content_type, BIO* req, const char* expected_content_type, int expect_asn1, size_t max_resp_len, int timeout, int keep_alive);
+    int OSSL_HTTP_close(OSSL_HTTP_REQ_CTX* rctx, int ok);
 
-/* Auxiliary functions */
-int OSSL_parse_url(const char *url, char **pscheme, char **puser, char **phost,
-                   char **pport, int *pport_num,
-                   char **ppath, char **pquery, char **pfrag);
-int OSSL_HTTP_parse_url(const char *url, int *pssl, char **puser, char **phost,
-                        char **pport, int *pport_num,
-                        char **ppath, char **pquery, char **pfrag);
-const char *OSSL_HTTP_adapt_proxy(const char *proxy, const char *no_proxy,
-                                  const char *server, int use_ssl);
+    /* Auxiliary functions */
+    int OSSL_parse_url(const char* url, char** pscheme, char** puser, char** phost, char** pport, int* pport_num, char** ppath, char** pquery, char** pfrag);
+    int OSSL_HTTP_parse_url(const char* url, int* pssl, char** puser, char** phost, char** pport, int* pport_num, char** ppath, char** pquery, char** pfrag);
+    const char* OSSL_HTTP_adapt_proxy(const char* proxy, const char* no_proxy, const char* server, int use_ssl);
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif /* !defined(OPENSSL_HTTP_H) */
diff --git a/CAPI/cpp/grpc/include/openssl/httperr.h b/CAPI/cpp/grpc/include/openssl/httperr.h
index ee08959..41f0490 100644
--- a/CAPI/cpp/grpc/include/openssl/httperr.h
+++ b/CAPI/cpp/grpc/include/openssl/httperr.h
@@ -9,47 +9,45 @@
  */
 
 #ifndef OPENSSL_HTTPERR_H
-# define OPENSSL_HTTPERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_HTTPERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * HTTP reason codes.
  */
-# define HTTP_R_ASN1_LEN_EXCEEDS_MAX_RESP_LEN             108
-# define HTTP_R_CONNECT_FAILURE                           100
-# define HTTP_R_ERROR_PARSING_ASN1_LENGTH                 109
-# define HTTP_R_ERROR_PARSING_CONTENT_LENGTH              119
-# define HTTP_R_ERROR_PARSING_URL                         101
-# define HTTP_R_ERROR_RECEIVING                           103
-# define HTTP_R_ERROR_SENDING                             102
-# define HTTP_R_FAILED_READING_DATA                       128
-# define HTTP_R_HEADER_PARSE_ERROR                        126
-# define HTTP_R_INCONSISTENT_CONTENT_LENGTH               120
-# define HTTP_R_INVALID_PORT_NUMBER                       123
-# define HTTP_R_INVALID_URL_PATH                          125
-# define HTTP_R_INVALID_URL_SCHEME                        124
-# define HTTP_R_MAX_RESP_LEN_EXCEEDED                     117
-# define HTTP_R_MISSING_ASN1_ENCODING                     110
-# define HTTP_R_MISSING_CONTENT_TYPE                      121
-# define HTTP_R_MISSING_REDIRECT_LOCATION                 111
-# define HTTP_R_RECEIVED_ERROR                            105
-# define HTTP_R_RECEIVED_WRONG_HTTP_VERSION               106
-# define HTTP_R_REDIRECTION_FROM_HTTPS_TO_HTTP            112
-# define HTTP_R_REDIRECTION_NOT_ENABLED                   116
-# define HTTP_R_RESPONSE_LINE_TOO_LONG                    113
-# define HTTP_R_RESPONSE_PARSE_ERROR                      104
-# define HTTP_R_RETRY_TIMEOUT                             129
-# define HTTP_R_SERVER_CANCELED_CONNECTION                127
-# define HTTP_R_SOCK_NOT_SUPPORTED                        122
-# define HTTP_R_STATUS_CODE_UNSUPPORTED                   114
-# define HTTP_R_TLS_NOT_ENABLED                           107
-# define HTTP_R_TOO_MANY_REDIRECTIONS                     115
-# define HTTP_R_UNEXPECTED_CONTENT_TYPE                   118
+#define HTTP_R_ASN1_LEN_EXCEEDS_MAX_RESP_LEN 108
+#define HTTP_R_CONNECT_FAILURE 100
+#define HTTP_R_ERROR_PARSING_ASN1_LENGTH 109
+#define HTTP_R_ERROR_PARSING_CONTENT_LENGTH 119
+#define HTTP_R_ERROR_PARSING_URL 101
+#define HTTP_R_ERROR_RECEIVING 103
+#define HTTP_R_ERROR_SENDING 102
+#define HTTP_R_FAILED_READING_DATA 128
+#define HTTP_R_HEADER_PARSE_ERROR 126
+#define HTTP_R_INCONSISTENT_CONTENT_LENGTH 120
+#define HTTP_R_INVALID_PORT_NUMBER 123
+#define HTTP_R_INVALID_URL_PATH 125
+#define HTTP_R_INVALID_URL_SCHEME 124
+#define HTTP_R_MAX_RESP_LEN_EXCEEDED 117
+#define HTTP_R_MISSING_ASN1_ENCODING 110
+#define HTTP_R_MISSING_CONTENT_TYPE 121
+#define HTTP_R_MISSING_REDIRECT_LOCATION 111
+#define HTTP_R_RECEIVED_ERROR 105
+#define HTTP_R_RECEIVED_WRONG_HTTP_VERSION 106
+#define HTTP_R_REDIRECTION_FROM_HTTPS_TO_HTTP 112
+#define HTTP_R_REDIRECTION_NOT_ENABLED 116
+#define HTTP_R_RESPONSE_LINE_TOO_LONG 113
+#define HTTP_R_RESPONSE_PARSE_ERROR 104
+#define HTTP_R_RETRY_TIMEOUT 129
+#define HTTP_R_SERVER_CANCELED_CONNECTION 127
+#define HTTP_R_SOCK_NOT_SUPPORTED 122
+#define HTTP_R_STATUS_CODE_UNSUPPORTED 114
+#define HTTP_R_TLS_NOT_ENABLED 107
+#define HTTP_R_TOO_MANY_REDIRECTIONS 115
+#define HTTP_R_UNEXPECTED_CONTENT_TYPE 118
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/idea.h b/CAPI/cpp/grpc/include/openssl/idea.h
index 1f9bb3b..cc62231 100644
--- a/CAPI/cpp/grpc/include/openssl/idea.h
+++ b/CAPI/cpp/grpc/include/openssl/idea.h
@@ -8,75 +8,62 @@
  */
 
 #ifndef OPENSSL_IDEA_H
-# define OPENSSL_IDEA_H
-# pragma once
+#define OPENSSL_IDEA_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_IDEA_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_IDEA_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_IDEA
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
+#ifndef OPENSSL_NO_IDEA
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  define IDEA_BLOCK      8
-#  define IDEA_KEY_LENGTH 16
+#define IDEA_BLOCK 8
+#define IDEA_KEY_LENGTH 16
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 
-typedef unsigned int IDEA_INT;
+    typedef unsigned int IDEA_INT;
 
-#   define IDEA_ENCRYPT    1
-#   define IDEA_DECRYPT    0
+#define IDEA_ENCRYPT 1
+#define IDEA_DECRYPT 0
 
-typedef struct idea_key_st {
-    IDEA_INT data[9][6];
-} IDEA_KEY_SCHEDULE;
+    typedef struct idea_key_st
+    {
+        IDEA_INT data[9][6];
+    } IDEA_KEY_SCHEDULE;
 #endif
 #ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 const char *IDEA_options(void);
-OSSL_DEPRECATEDIN_3_0 void IDEA_ecb_encrypt(const unsigned char *in,
-                                            unsigned char *out,
-                                            IDEA_KEY_SCHEDULE *ks);
-OSSL_DEPRECATEDIN_3_0 void IDEA_set_encrypt_key(const unsigned char *key,
-                                                IDEA_KEY_SCHEDULE *ks);
-OSSL_DEPRECATEDIN_3_0 void IDEA_set_decrypt_key(IDEA_KEY_SCHEDULE *ek,
-                                                IDEA_KEY_SCHEDULE *dk);
-OSSL_DEPRECATEDIN_3_0 void IDEA_cbc_encrypt(const unsigned char *in,
-                                            unsigned char *out, long length,
-                                            IDEA_KEY_SCHEDULE *ks,
-                                            unsigned char *iv, int enc);
-OSSL_DEPRECATEDIN_3_0 void IDEA_cfb64_encrypt(const unsigned char *in,
-                                              unsigned char *out, long length,
-                                              IDEA_KEY_SCHEDULE *ks,
-                                              unsigned char *iv, int *num,
-                                              int enc);
-OSSL_DEPRECATEDIN_3_0 void IDEA_ofb64_encrypt(const unsigned char *in,
-                                              unsigned char *out, long length,
-                                              IDEA_KEY_SCHEDULE *ks,
-                                              unsigned char *iv, int *num);
-OSSL_DEPRECATEDIN_3_0 void IDEA_encrypt(unsigned long *in,
-                                        IDEA_KEY_SCHEDULE *ks);
+    OSSL_DEPRECATEDIN_3_0 const char* IDEA_options(void);
+    OSSL_DEPRECATEDIN_3_0 void IDEA_ecb_encrypt(const unsigned char* in, unsigned char* out, IDEA_KEY_SCHEDULE* ks);
+    OSSL_DEPRECATEDIN_3_0 void IDEA_set_encrypt_key(const unsigned char* key, IDEA_KEY_SCHEDULE* ks);
+    OSSL_DEPRECATEDIN_3_0 void IDEA_set_decrypt_key(IDEA_KEY_SCHEDULE* ek, IDEA_KEY_SCHEDULE* dk);
+    OSSL_DEPRECATEDIN_3_0 void IDEA_cbc_encrypt(const unsigned char* in, unsigned char* out, long length, IDEA_KEY_SCHEDULE* ks, unsigned char* iv, int enc);
+    OSSL_DEPRECATEDIN_3_0 void IDEA_cfb64_encrypt(const unsigned char* in, unsigned char* out, long length, IDEA_KEY_SCHEDULE* ks, unsigned char* iv, int* num, int enc);
+    OSSL_DEPRECATEDIN_3_0 void IDEA_ofb64_encrypt(const unsigned char* in, unsigned char* out, long length, IDEA_KEY_SCHEDULE* ks, unsigned char* iv, int* num);
+    OSSL_DEPRECATEDIN_3_0 void IDEA_encrypt(unsigned long* in, IDEA_KEY_SCHEDULE* ks);
 #endif
 
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#   define idea_options          IDEA_options
-#   define idea_ecb_encrypt      IDEA_ecb_encrypt
-#   define idea_set_encrypt_key  IDEA_set_encrypt_key
-#   define idea_set_decrypt_key  IDEA_set_decrypt_key
-#   define idea_cbc_encrypt      IDEA_cbc_encrypt
-#   define idea_cfb64_encrypt    IDEA_cfb64_encrypt
-#   define idea_ofb64_encrypt    IDEA_ofb64_encrypt
-#   define idea_encrypt          IDEA_encrypt
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define idea_options IDEA_options
+#define idea_ecb_encrypt IDEA_ecb_encrypt
+#define idea_set_encrypt_key IDEA_set_encrypt_key
+#define idea_set_decrypt_key IDEA_set_decrypt_key
+#define idea_cbc_encrypt IDEA_cbc_encrypt
+#define idea_cfb64_encrypt IDEA_cfb64_encrypt
+#define idea_ofb64_encrypt IDEA_ofb64_encrypt
+#define idea_encrypt IDEA_encrypt
+#endif
 
-#  ifdef  __cplusplus
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/kdf.h b/CAPI/cpp/grpc/include/openssl/kdf.h
index 0983230..dea2ecd 100644
--- a/CAPI/cpp/grpc/include/openssl/kdf.h
+++ b/CAPI/cpp/grpc/include/openssl/kdf.h
@@ -8,131 +8,117 @@
  */
 
 #ifndef OPENSSL_KDF_H
-# define OPENSSL_KDF_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_KDF_H
-# endif
-
-# include <stdarg.h>
-# include <stddef.h>
-# include <openssl/types.h>
-# include <openssl/core.h>
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-int EVP_KDF_up_ref(EVP_KDF *kdf);
-void EVP_KDF_free(EVP_KDF *kdf);
-EVP_KDF *EVP_KDF_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
-                       const char *properties);
-
-EVP_KDF_CTX *EVP_KDF_CTX_new(EVP_KDF *kdf);
-void EVP_KDF_CTX_free(EVP_KDF_CTX *ctx);
-EVP_KDF_CTX *EVP_KDF_CTX_dup(const EVP_KDF_CTX *src);
-const char *EVP_KDF_get0_description(const EVP_KDF *kdf);
-int EVP_KDF_is_a(const EVP_KDF *kdf, const char *name);
-const char *EVP_KDF_get0_name(const EVP_KDF *kdf);
-const OSSL_PROVIDER *EVP_KDF_get0_provider(const EVP_KDF *kdf);
-const EVP_KDF *EVP_KDF_CTX_kdf(EVP_KDF_CTX *ctx);
-
-void EVP_KDF_CTX_reset(EVP_KDF_CTX *ctx);
-size_t EVP_KDF_CTX_get_kdf_size(EVP_KDF_CTX *ctx);
-int EVP_KDF_derive(EVP_KDF_CTX *ctx, unsigned char *key, size_t keylen,
-                   const OSSL_PARAM params[]);
-int EVP_KDF_get_params(EVP_KDF *kdf, OSSL_PARAM params[]);
-int EVP_KDF_CTX_get_params(EVP_KDF_CTX *ctx, OSSL_PARAM params[]);
-int EVP_KDF_CTX_set_params(EVP_KDF_CTX *ctx, const OSSL_PARAM params[]);
-const OSSL_PARAM *EVP_KDF_gettable_params(const EVP_KDF *kdf);
-const OSSL_PARAM *EVP_KDF_gettable_ctx_params(const EVP_KDF *kdf);
-const OSSL_PARAM *EVP_KDF_settable_ctx_params(const EVP_KDF *kdf);
-const OSSL_PARAM *EVP_KDF_CTX_gettable_params(EVP_KDF_CTX *ctx);
-const OSSL_PARAM *EVP_KDF_CTX_settable_params(EVP_KDF_CTX *ctx);
-
-void EVP_KDF_do_all_provided(OSSL_LIB_CTX *libctx,
-                             void (*fn)(EVP_KDF *kdf, void *arg),
-                             void *arg);
-int EVP_KDF_names_do_all(const EVP_KDF *kdf,
-                         void (*fn)(const char *name, void *data),
-                         void *data);
-
-# define EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND  0
-# define EVP_KDF_HKDF_MODE_EXTRACT_ONLY        1
-# define EVP_KDF_HKDF_MODE_EXPAND_ONLY         2
-
-#define EVP_KDF_SSHKDF_TYPE_INITIAL_IV_CLI_TO_SRV     65
-#define EVP_KDF_SSHKDF_TYPE_INITIAL_IV_SRV_TO_CLI     66
+#define OPENSSL_KDF_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_KDF_H
+#endif
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <openssl/types.h>
+#include <openssl/core.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    int EVP_KDF_up_ref(EVP_KDF* kdf);
+    void EVP_KDF_free(EVP_KDF* kdf);
+    EVP_KDF* EVP_KDF_fetch(OSSL_LIB_CTX* libctx, const char* algorithm, const char* properties);
+
+    EVP_KDF_CTX* EVP_KDF_CTX_new(EVP_KDF* kdf);
+    void EVP_KDF_CTX_free(EVP_KDF_CTX* ctx);
+    EVP_KDF_CTX* EVP_KDF_CTX_dup(const EVP_KDF_CTX* src);
+    const char* EVP_KDF_get0_description(const EVP_KDF* kdf);
+    int EVP_KDF_is_a(const EVP_KDF* kdf, const char* name);
+    const char* EVP_KDF_get0_name(const EVP_KDF* kdf);
+    const OSSL_PROVIDER* EVP_KDF_get0_provider(const EVP_KDF* kdf);
+    const EVP_KDF* EVP_KDF_CTX_kdf(EVP_KDF_CTX* ctx);
+
+    void EVP_KDF_CTX_reset(EVP_KDF_CTX* ctx);
+    size_t EVP_KDF_CTX_get_kdf_size(EVP_KDF_CTX* ctx);
+    int EVP_KDF_derive(EVP_KDF_CTX* ctx, unsigned char* key, size_t keylen, const OSSL_PARAM params[]);
+    int EVP_KDF_get_params(EVP_KDF* kdf, OSSL_PARAM params[]);
+    int EVP_KDF_CTX_get_params(EVP_KDF_CTX* ctx, OSSL_PARAM params[]);
+    int EVP_KDF_CTX_set_params(EVP_KDF_CTX* ctx, const OSSL_PARAM params[]);
+    const OSSL_PARAM* EVP_KDF_gettable_params(const EVP_KDF* kdf);
+    const OSSL_PARAM* EVP_KDF_gettable_ctx_params(const EVP_KDF* kdf);
+    const OSSL_PARAM* EVP_KDF_settable_ctx_params(const EVP_KDF* kdf);
+    const OSSL_PARAM* EVP_KDF_CTX_gettable_params(EVP_KDF_CTX* ctx);
+    const OSSL_PARAM* EVP_KDF_CTX_settable_params(EVP_KDF_CTX* ctx);
+
+    void EVP_KDF_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(EVP_KDF* kdf, void* arg), void* arg);
+    int EVP_KDF_names_do_all(const EVP_KDF* kdf, void (*fn)(const char* name, void* data), void* data);
+
+#define EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND 0
+#define EVP_KDF_HKDF_MODE_EXTRACT_ONLY 1
+#define EVP_KDF_HKDF_MODE_EXPAND_ONLY 2
+
+#define EVP_KDF_SSHKDF_TYPE_INITIAL_IV_CLI_TO_SRV 65
+#define EVP_KDF_SSHKDF_TYPE_INITIAL_IV_SRV_TO_CLI 66
 #define EVP_KDF_SSHKDF_TYPE_ENCRYPTION_KEY_CLI_TO_SRV 67
 #define EVP_KDF_SSHKDF_TYPE_ENCRYPTION_KEY_SRV_TO_CLI 68
-#define EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_CLI_TO_SRV  69
-#define EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_SRV_TO_CLI  70
+#define EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_CLI_TO_SRV 69
+#define EVP_KDF_SSHKDF_TYPE_INTEGRITY_KEY_SRV_TO_CLI 70
 
-/**** The legacy PKEY-based KDF API follows. ****/
+    /**** The legacy PKEY-based KDF API follows. ****/
 
-# define EVP_PKEY_CTRL_TLS_MD                   (EVP_PKEY_ALG_CTRL)
-# define EVP_PKEY_CTRL_TLS_SECRET               (EVP_PKEY_ALG_CTRL + 1)
-# define EVP_PKEY_CTRL_TLS_SEED                 (EVP_PKEY_ALG_CTRL + 2)
-# define EVP_PKEY_CTRL_HKDF_MD                  (EVP_PKEY_ALG_CTRL + 3)
-# define EVP_PKEY_CTRL_HKDF_SALT                (EVP_PKEY_ALG_CTRL + 4)
-# define EVP_PKEY_CTRL_HKDF_KEY                 (EVP_PKEY_ALG_CTRL + 5)
-# define EVP_PKEY_CTRL_HKDF_INFO                (EVP_PKEY_ALG_CTRL + 6)
-# define EVP_PKEY_CTRL_HKDF_MODE                (EVP_PKEY_ALG_CTRL + 7)
-# define EVP_PKEY_CTRL_PASS                     (EVP_PKEY_ALG_CTRL + 8)
-# define EVP_PKEY_CTRL_SCRYPT_SALT              (EVP_PKEY_ALG_CTRL + 9)
-# define EVP_PKEY_CTRL_SCRYPT_N                 (EVP_PKEY_ALG_CTRL + 10)
-# define EVP_PKEY_CTRL_SCRYPT_R                 (EVP_PKEY_ALG_CTRL + 11)
-# define EVP_PKEY_CTRL_SCRYPT_P                 (EVP_PKEY_ALG_CTRL + 12)
-# define EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES      (EVP_PKEY_ALG_CTRL + 13)
+#define EVP_PKEY_CTRL_TLS_MD (EVP_PKEY_ALG_CTRL)
+#define EVP_PKEY_CTRL_TLS_SECRET (EVP_PKEY_ALG_CTRL + 1)
+#define EVP_PKEY_CTRL_TLS_SEED (EVP_PKEY_ALG_CTRL + 2)
+#define EVP_PKEY_CTRL_HKDF_MD (EVP_PKEY_ALG_CTRL + 3)
+#define EVP_PKEY_CTRL_HKDF_SALT (EVP_PKEY_ALG_CTRL + 4)
+#define EVP_PKEY_CTRL_HKDF_KEY (EVP_PKEY_ALG_CTRL + 5)
+#define EVP_PKEY_CTRL_HKDF_INFO (EVP_PKEY_ALG_CTRL + 6)
+#define EVP_PKEY_CTRL_HKDF_MODE (EVP_PKEY_ALG_CTRL + 7)
+#define EVP_PKEY_CTRL_PASS (EVP_PKEY_ALG_CTRL + 8)
+#define EVP_PKEY_CTRL_SCRYPT_SALT (EVP_PKEY_ALG_CTRL + 9)
+#define EVP_PKEY_CTRL_SCRYPT_N (EVP_PKEY_ALG_CTRL + 10)
+#define EVP_PKEY_CTRL_SCRYPT_R (EVP_PKEY_ALG_CTRL + 11)
+#define EVP_PKEY_CTRL_SCRYPT_P (EVP_PKEY_ALG_CTRL + 12)
+#define EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES (EVP_PKEY_ALG_CTRL + 13)
 
-# define EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND \
-            EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND
-# define EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY       \
-            EVP_KDF_HKDF_MODE_EXTRACT_ONLY
-# define EVP_PKEY_HKDEF_MODE_EXPAND_ONLY        \
-            EVP_KDF_HKDF_MODE_EXPAND_ONLY
+#define EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND \
+    EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND
+#define EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY \
+    EVP_KDF_HKDF_MODE_EXTRACT_ONLY
+#define EVP_PKEY_HKDEF_MODE_EXPAND_ONLY \
+    EVP_KDF_HKDF_MODE_EXPAND_ONLY
 
-int EVP_PKEY_CTX_set_tls1_prf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+    int EVP_PKEY_CTX_set_tls1_prf_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
 
-int EVP_PKEY_CTX_set1_tls1_prf_secret(EVP_PKEY_CTX *pctx,
-                                      const unsigned char *sec, int seclen);
+    int EVP_PKEY_CTX_set1_tls1_prf_secret(EVP_PKEY_CTX* pctx, const unsigned char* sec, int seclen);
 
-int EVP_PKEY_CTX_add1_tls1_prf_seed(EVP_PKEY_CTX *pctx,
-                                    const unsigned char *seed, int seedlen);
+    int EVP_PKEY_CTX_add1_tls1_prf_seed(EVP_PKEY_CTX* pctx, const unsigned char* seed, int seedlen);
 
-int EVP_PKEY_CTX_set_hkdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
+    int EVP_PKEY_CTX_set_hkdf_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
 
-int EVP_PKEY_CTX_set1_hkdf_salt(EVP_PKEY_CTX *ctx,
-                                const unsigned char *salt, int saltlen);
+    int EVP_PKEY_CTX_set1_hkdf_salt(EVP_PKEY_CTX* ctx, const unsigned char* salt, int saltlen);
 
-int EVP_PKEY_CTX_set1_hkdf_key(EVP_PKEY_CTX *ctx,
-                               const unsigned char *key, int keylen);
+    int EVP_PKEY_CTX_set1_hkdf_key(EVP_PKEY_CTX* ctx, const unsigned char* key, int keylen);
 
-int EVP_PKEY_CTX_add1_hkdf_info(EVP_PKEY_CTX *ctx,
-                                const unsigned char *info, int infolen);
+    int EVP_PKEY_CTX_add1_hkdf_info(EVP_PKEY_CTX* ctx, const unsigned char* info, int infolen);
 
-int EVP_PKEY_CTX_set_hkdf_mode(EVP_PKEY_CTX *ctx, int mode);
-# define EVP_PKEY_CTX_hkdf_mode EVP_PKEY_CTX_set_hkdf_mode
+    int EVP_PKEY_CTX_set_hkdf_mode(EVP_PKEY_CTX* ctx, int mode);
+#define EVP_PKEY_CTX_hkdf_mode EVP_PKEY_CTX_set_hkdf_mode
 
-int EVP_PKEY_CTX_set1_pbe_pass(EVP_PKEY_CTX *ctx, const char *pass,
-                               int passlen);
+    int EVP_PKEY_CTX_set1_pbe_pass(EVP_PKEY_CTX* ctx, const char* pass, int passlen);
 
-int EVP_PKEY_CTX_set1_scrypt_salt(EVP_PKEY_CTX *ctx,
-                                  const unsigned char *salt, int saltlen);
+    int EVP_PKEY_CTX_set1_scrypt_salt(EVP_PKEY_CTX* ctx, const unsigned char* salt, int saltlen);
 
-int EVP_PKEY_CTX_set_scrypt_N(EVP_PKEY_CTX *ctx, uint64_t n);
+    int EVP_PKEY_CTX_set_scrypt_N(EVP_PKEY_CTX* ctx, uint64_t n);
 
-int EVP_PKEY_CTX_set_scrypt_r(EVP_PKEY_CTX *ctx, uint64_t r);
+    int EVP_PKEY_CTX_set_scrypt_r(EVP_PKEY_CTX* ctx, uint64_t r);
 
-int EVP_PKEY_CTX_set_scrypt_p(EVP_PKEY_CTX *ctx, uint64_t p);
+    int EVP_PKEY_CTX_set_scrypt_p(EVP_PKEY_CTX* ctx, uint64_t p);
 
-int EVP_PKEY_CTX_set_scrypt_maxmem_bytes(EVP_PKEY_CTX *ctx,
-                                         uint64_t maxmem_bytes);
+    int EVP_PKEY_CTX_set_scrypt_maxmem_bytes(EVP_PKEY_CTX* ctx, uint64_t maxmem_bytes);
 
-
-# ifdef __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/kdferr.h b/CAPI/cpp/grpc/include/openssl/kdferr.h
index 963d766..a2c1f24 100644
--- a/CAPI/cpp/grpc/include/openssl/kdferr.h
+++ b/CAPI/cpp/grpc/include/openssl/kdferr.h
@@ -8,8 +8,8 @@
  */
 
 #ifndef OPENSSL_KDFERR_H
-# define OPENSSL_KDFERR_H
-# pragma once
+#define OPENSSL_KDFERR_H
+#pragma once
 
 #include <openssl/cryptoerr_legacy.h>
 
diff --git a/CAPI/cpp/grpc/include/openssl/lhash.h b/CAPI/cpp/grpc/include/openssl/lhash.h
index 39dd625..2a5d0a2 100644
--- a/CAPI/cpp/grpc/include/openssl/lhash.h
+++ b/CAPI/cpp/grpc/include/openssl/lhash.h
@@ -7,34 +7,33 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 /*
  * Header for dynamic hash table routines Author - Eric Young
  */
 
 #ifndef OPENSSL_LHASH_H
-# define OPENSSL_LHASH_H
-# pragma once
+#define OPENSSL_LHASH_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_LHASH_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_LHASH_H
+#endif
 
-# include <openssl/e_os2.h>
-# include <openssl/bio.h>
+#include <openssl/e_os2.h>
+#include <openssl/bio.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-typedef struct lhash_node_st OPENSSL_LH_NODE;
-typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *);
-typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *);
-typedef void (*OPENSSL_LH_DOALL_FUNC) (void *);
-typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *);
-typedef struct lhash_st OPENSSL_LHASH;
+    typedef struct lhash_node_st OPENSSL_LH_NODE;
+    typedef int (*OPENSSL_LH_COMPFUNC)(const void*, const void*);
+    typedef unsigned long (*OPENSSL_LH_HASHFUNC)(const void*);
+    typedef void (*OPENSSL_LH_DOALL_FUNC)(void*);
+    typedef void (*OPENSSL_LH_DOALL_FUNCARG)(void*, void*);
+    typedef struct lhash_st OPENSSL_LHASH;
 
 /*
  * Macros for declaring and implementing type-safe wrappers for LHASH
@@ -46,191 +45,207 @@ typedef struct lhash_st OPENSSL_LHASH;
  */
 
 /* First: "hash" functions */
-# define DECLARE_LHASH_HASH_FN(name, o_type) \
-        unsigned long name##_LHASH_HASH(const void *);
-# define IMPLEMENT_LHASH_HASH_FN(name, o_type) \
-        unsigned long name##_LHASH_HASH(const void *arg) { \
-                const o_type *a = arg; \
-                return name##_hash(a); }
-# define LHASH_HASH_FN(name) name##_LHASH_HASH
+#define DECLARE_LHASH_HASH_FN(name, o_type) \
+    unsigned long name##_LHASH_HASH(const void*);
+#define IMPLEMENT_LHASH_HASH_FN(name, o_type)        \
+    unsigned long name##_LHASH_HASH(const void* arg) \
+    {                                                \
+        const o_type* a = arg;                       \
+        return name##_hash(a);                       \
+    }
+#define LHASH_HASH_FN(name) name##_LHASH_HASH
 
 /* Second: "compare" functions */
-# define DECLARE_LHASH_COMP_FN(name, o_type) \
-        int name##_LHASH_COMP(const void *, const void *);
-# define IMPLEMENT_LHASH_COMP_FN(name, o_type) \
-        int name##_LHASH_COMP(const void *arg1, const void *arg2) { \
-                const o_type *a = arg1;             \
-                const o_type *b = arg2; \
-                return name##_cmp(a,b); }
-# define LHASH_COMP_FN(name) name##_LHASH_COMP
+#define DECLARE_LHASH_COMP_FN(name, o_type) \
+    int name##_LHASH_COMP(const void*, const void*);
+#define IMPLEMENT_LHASH_COMP_FN(name, o_type)                 \
+    int name##_LHASH_COMP(const void* arg1, const void* arg2) \
+    {                                                         \
+        const o_type* a = arg1;                               \
+        const o_type* b = arg2;                               \
+        return name##_cmp(a, b);                              \
+    }
+#define LHASH_COMP_FN(name) name##_LHASH_COMP
 
 /* Fourth: "doall_arg" functions */
-# define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
-        void name##_LHASH_DOALL_ARG(void *, void *);
-# define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
-        void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \
-                o_type *a = arg1; \
-                a_type *b = arg2; \
-                name##_doall_arg(a, b); }
-# define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG
-
+#define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
+    void name##_LHASH_DOALL_ARG(void*, void*);
+#define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \
+    void name##_LHASH_DOALL_ARG(void* arg1, void* arg2)    \
+    {                                                      \
+        o_type* a = arg1;                                  \
+        a_type* b = arg2;                                  \
+        name##_doall_arg(a, b);                            \
+    }
+#define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG
 
-# define LH_LOAD_MULT    256
+#define LH_LOAD_MULT 256
 
-int OPENSSL_LH_error(OPENSSL_LHASH *lh);
-OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c);
-void OPENSSL_LH_free(OPENSSL_LHASH *lh);
-void OPENSSL_LH_flush(OPENSSL_LHASH *lh);
-void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data);
-void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data);
-void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data);
-void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func);
-void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg);
-unsigned long OPENSSL_LH_strhash(const char *c);
-unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh);
-unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh);
-void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load);
+    int OPENSSL_LH_error(OPENSSL_LHASH* lh);
+    OPENSSL_LHASH* OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c);
+    void OPENSSL_LH_free(OPENSSL_LHASH* lh);
+    void OPENSSL_LH_flush(OPENSSL_LHASH* lh);
+    void* OPENSSL_LH_insert(OPENSSL_LHASH* lh, void* data);
+    void* OPENSSL_LH_delete(OPENSSL_LHASH* lh, const void* data);
+    void* OPENSSL_LH_retrieve(OPENSSL_LHASH* lh, const void* data);
+    void OPENSSL_LH_doall(OPENSSL_LHASH* lh, OPENSSL_LH_DOALL_FUNC func);
+    void OPENSSL_LH_doall_arg(OPENSSL_LHASH* lh, OPENSSL_LH_DOALL_FUNCARG func, void* arg);
+    unsigned long OPENSSL_LH_strhash(const char* c);
+    unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH* lh);
+    unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH* lh);
+    void OPENSSL_LH_set_down_load(OPENSSL_LHASH* lh, unsigned long down_load);
 
-# ifndef OPENSSL_NO_STDIO
-void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp);
-void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp);
-void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp);
-# endif
-void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
-void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
-void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
+#ifndef OPENSSL_NO_STDIO
+    void OPENSSL_LH_stats(const OPENSSL_LHASH* lh, FILE* fp);
+    void OPENSSL_LH_node_stats(const OPENSSL_LHASH* lh, FILE* fp);
+    void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH* lh, FILE* fp);
+#endif
+    void OPENSSL_LH_stats_bio(const OPENSSL_LHASH* lh, BIO* out);
+    void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH* lh, BIO* out);
+    void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH* lh, BIO* out);
 
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define _LHASH OPENSSL_LHASH
-#  define LHASH_NODE OPENSSL_LH_NODE
-#  define lh_error OPENSSL_LH_error
-#  define lh_new OPENSSL_LH_new
-#  define lh_free OPENSSL_LH_free
-#  define lh_insert OPENSSL_LH_insert
-#  define lh_delete OPENSSL_LH_delete
-#  define lh_retrieve OPENSSL_LH_retrieve
-#  define lh_doall OPENSSL_LH_doall
-#  define lh_doall_arg OPENSSL_LH_doall_arg
-#  define lh_strhash OPENSSL_LH_strhash
-#  define lh_num_items OPENSSL_LH_num_items
-#  ifndef OPENSSL_NO_STDIO
-#   define lh_stats OPENSSL_LH_stats
-#   define lh_node_stats OPENSSL_LH_node_stats
-#   define lh_node_usage_stats OPENSSL_LH_node_usage_stats
-#  endif
-#  define lh_stats_bio OPENSSL_LH_stats_bio
-#  define lh_node_stats_bio OPENSSL_LH_node_stats_bio
-#  define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define _LHASH OPENSSL_LHASH
+#define LHASH_NODE OPENSSL_LH_NODE
+#define lh_error OPENSSL_LH_error
+#define lh_new OPENSSL_LH_new
+#define lh_free OPENSSL_LH_free
+#define lh_insert OPENSSL_LH_insert
+#define lh_delete OPENSSL_LH_delete
+#define lh_retrieve OPENSSL_LH_retrieve
+#define lh_doall OPENSSL_LH_doall
+#define lh_doall_arg OPENSSL_LH_doall_arg
+#define lh_strhash OPENSSL_LH_strhash
+#define lh_num_items OPENSSL_LH_num_items
+#ifndef OPENSSL_NO_STDIO
+#define lh_stats OPENSSL_LH_stats
+#define lh_node_stats OPENSSL_LH_node_stats
+#define lh_node_usage_stats OPENSSL_LH_node_usage_stats
+#endif
+#define lh_stats_bio OPENSSL_LH_stats_bio
+#define lh_node_stats_bio OPENSSL_LH_node_stats_bio
+#define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio
+#endif
 
-/* Type checking... */
+    /* Type checking... */
 
-# define LHASH_OF(type) struct lhash_st_##type
+#define LHASH_OF(type) struct lhash_st_##type
 
 /* Helper macro for internal use */
-# define DEFINE_LHASH_OF_INTERNAL(type) \
-    LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \
-    typedef int (*lh_##type##_compfunc)(const type *a, const type *b); \
-    typedef unsigned long (*lh_##type##_hashfunc)(const type *a); \
-    typedef void (*lh_##type##_doallfunc)(type *a); \
-    static ossl_unused ossl_inline type *ossl_check_##type##_lh_plain_type(type *ptr) \
-    { \
-        return ptr; \
-    } \
-    static ossl_unused ossl_inline const type *ossl_check_const_##type##_lh_plain_type(const type *ptr) \
-    { \
-        return ptr; \
-    } \
-    static ossl_unused ossl_inline const OPENSSL_LHASH *ossl_check_const_##type##_lh_type(const LHASH_OF(type) *lh) \
-    { \
-        return (const OPENSSL_LHASH *)lh; \
-    } \
-    static ossl_unused ossl_inline OPENSSL_LHASH *ossl_check_##type##_lh_type(LHASH_OF(type) *lh) \
-    { \
-        return (OPENSSL_LHASH *)lh; \
-    } \
-    static ossl_unused ossl_inline OPENSSL_LH_COMPFUNC ossl_check_##type##_lh_compfunc_type(lh_##type##_compfunc cmp) \
-    { \
-        return (OPENSSL_LH_COMPFUNC)cmp; \
-    } \
-    static ossl_unused ossl_inline OPENSSL_LH_HASHFUNC ossl_check_##type##_lh_hashfunc_type(lh_##type##_hashfunc hfn) \
-    { \
-        return (OPENSSL_LH_HASHFUNC)hfn; \
-    } \
+#define DEFINE_LHASH_OF_INTERNAL(type)                                                                                    \
+    LHASH_OF(type)                                                                                                        \
+    {                                                                                                                     \
+        union lh_##type##_dummy                                                                                           \
+        {                                                                                                                 \
+            void* d1;                                                                                                     \
+            unsigned long d2;                                                                                             \
+            int d3;                                                                                                       \
+        } dummy;                                                                                                          \
+    };                                                                                                                    \
+    typedef int (*lh_##type##_compfunc)(const type* a, const type* b);                                                    \
+    typedef unsigned long (*lh_##type##_hashfunc)(const type* a);                                                         \
+    typedef void (*lh_##type##_doallfunc)(type * a);                                                                      \
+    static ossl_unused ossl_inline type* ossl_check_##type##_lh_plain_type(type* ptr)                                     \
+    {                                                                                                                     \
+        return ptr;                                                                                                       \
+    }                                                                                                                     \
+    static ossl_unused ossl_inline const type* ossl_check_const_##type##_lh_plain_type(const type* ptr)                   \
+    {                                                                                                                     \
+        return ptr;                                                                                                       \
+    }                                                                                                                     \
+    static ossl_unused ossl_inline const OPENSSL_LHASH* ossl_check_const_##type##_lh_type(const LHASH_OF(type) * lh)      \
+    {                                                                                                                     \
+        return (const OPENSSL_LHASH*)lh;                                                                                  \
+    }                                                                                                                     \
+    static ossl_unused ossl_inline OPENSSL_LHASH* ossl_check_##type##_lh_type(LHASH_OF(type) * lh)                        \
+    {                                                                                                                     \
+        return (OPENSSL_LHASH*)lh;                                                                                        \
+    }                                                                                                                     \
+    static ossl_unused ossl_inline OPENSSL_LH_COMPFUNC ossl_check_##type##_lh_compfunc_type(lh_##type##_compfunc cmp)     \
+    {                                                                                                                     \
+        return (OPENSSL_LH_COMPFUNC)cmp;                                                                                  \
+    }                                                                                                                     \
+    static ossl_unused ossl_inline OPENSSL_LH_HASHFUNC ossl_check_##type##_lh_hashfunc_type(lh_##type##_hashfunc hfn)     \
+    {                                                                                                                     \
+        return (OPENSSL_LH_HASHFUNC)hfn;                                                                                  \
+    }                                                                                                                     \
     static ossl_unused ossl_inline OPENSSL_LH_DOALL_FUNC ossl_check_##type##_lh_doallfunc_type(lh_##type##_doallfunc dfn) \
-    { \
-        return (OPENSSL_LH_DOALL_FUNC)dfn; \
-    } \
+    {                                                                                                                     \
+        return (OPENSSL_LH_DOALL_FUNC)dfn;                                                                                \
+    }                                                                                                                     \
     LHASH_OF(type)
 
-# define DEFINE_LHASH_OF(type) \
-    LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \
-    static ossl_unused ossl_inline LHASH_OF(type) *lh_##type##_new(unsigned long (*hfn)(const type *), \
-                                                                   int (*cfn)(const type *, const type *)) \
-    { \
-        return (LHASH_OF(type) *) \
-            OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); \
-    } \
-    static ossl_unused ossl_inline void lh_##type##_free(LHASH_OF(type) *lh) \
-    { \
-        OPENSSL_LH_free((OPENSSL_LHASH *)lh); \
-    } \
-    static ossl_unused ossl_inline void lh_##type##_flush(LHASH_OF(type) *lh) \
-    { \
-        OPENSSL_LH_flush((OPENSSL_LHASH *)lh); \
-    } \
-    static ossl_unused ossl_inline type *lh_##type##_insert(LHASH_OF(type) *lh, type *d) \
-    { \
-        return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \
-    } \
-    static ossl_unused ossl_inline type *lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \
-    { \
-        return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \
-    } \
-    static ossl_unused ossl_inline type *lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \
-    { \
-        return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \
-    } \
-    static ossl_unused ossl_inline int lh_##type##_error(LHASH_OF(type) *lh) \
-    { \
-        return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \
-    } \
-    static ossl_unused ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) *lh) \
-    { \
-        return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \
-    } \
-    static ossl_unused ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
-    { \
-        OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \
-    } \
-    static ossl_unused ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
-    { \
-        OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \
-    } \
-    static ossl_unused ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \
-    { \
-        OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \
-    } \
-    static ossl_unused ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) *lh) \
-    { \
-        return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \
-    } \
-    static ossl_unused ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \
-    { \
-        OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \
-    } \
-    static ossl_unused ossl_inline void lh_##type##_doall(LHASH_OF(type) *lh, \
-                                                          void (*doall)(type *)) \
-    { \
-        OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \
-    } \
-    static ossl_unused ossl_inline void lh_##type##_doall_arg(LHASH_OF(type) *lh, \
-                                                              void (*doallarg)(type *, void *), \
-                                                              void *arg) \
-    { \
-        OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, \
-                             (OPENSSL_LH_DOALL_FUNCARG)doallarg, arg); \
-    } \
+#define DEFINE_LHASH_OF(type)                                                                                                                \
+    LHASH_OF(type)                                                                                                                           \
+    {                                                                                                                                        \
+        union lh_##type##_dummy                                                                                                              \
+        {                                                                                                                                    \
+            void* d1;                                                                                                                        \
+            unsigned long d2;                                                                                                                \
+            int d3;                                                                                                                          \
+        } dummy;                                                                                                                             \
+    };                                                                                                                                       \
+    static ossl_unused ossl_inline LHASH_OF(type) * lh_##type##_new(unsigned long (*hfn)(const type*), int (*cfn)(const type*, const type*)) \
+    {                                                                                                                                        \
+        return (LHASH_OF(type)*)                                                                                                             \
+            OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn);                                                              \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline void lh_##type##_free(LHASH_OF(type) * lh)                                                                \
+    {                                                                                                                                        \
+        OPENSSL_LH_free((OPENSSL_LHASH*)lh);                                                                                                 \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline void lh_##type##_flush(LHASH_OF(type) * lh)                                                               \
+    {                                                                                                                                        \
+        OPENSSL_LH_flush((OPENSSL_LHASH*)lh);                                                                                                \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline type* lh_##type##_insert(LHASH_OF(type) * lh, type * d)                                                   \
+    {                                                                                                                                        \
+        return (type*)OPENSSL_LH_insert((OPENSSL_LHASH*)lh, d);                                                                              \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline type* lh_##type##_delete(LHASH_OF(type) * lh, const type* d)                                              \
+    {                                                                                                                                        \
+        return (type*)OPENSSL_LH_delete((OPENSSL_LHASH*)lh, d);                                                                              \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline type* lh_##type##_retrieve(LHASH_OF(type) * lh, const type* d)                                            \
+    {                                                                                                                                        \
+        return (type*)OPENSSL_LH_retrieve((OPENSSL_LHASH*)lh, d);                                                                            \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline int lh_##type##_error(LHASH_OF(type) * lh)                                                                \
+    {                                                                                                                                        \
+        return OPENSSL_LH_error((OPENSSL_LHASH*)lh);                                                                                         \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) * lh)                                                  \
+    {                                                                                                                                        \
+        return OPENSSL_LH_num_items((OPENSSL_LHASH*)lh);                                                                                     \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) * lh, BIO * out)                                     \
+    {                                                                                                                                        \
+        OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH*)lh, out);                                                                            \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) * lh, BIO * out)                               \
+    {                                                                                                                                        \
+        OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH*)lh, out);                                                                      \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) * lh, BIO * out)                                          \
+    {                                                                                                                                        \
+        OPENSSL_LH_stats_bio((const OPENSSL_LHASH*)lh, out);                                                                                 \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) * lh)                                              \
+    {                                                                                                                                        \
+        return OPENSSL_LH_get_down_load((OPENSSL_LHASH*)lh);                                                                                 \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) * lh, unsigned long dl)                                     \
+    {                                                                                                                                        \
+        OPENSSL_LH_set_down_load((OPENSSL_LHASH*)lh, dl);                                                                                    \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline void lh_##type##_doall(LHASH_OF(type) * lh, void (*doall)(type*))                                         \
+    {                                                                                                                                        \
+        OPENSSL_LH_doall((OPENSSL_LHASH*)lh, (OPENSSL_LH_DOALL_FUNC)doall);                                                                  \
+    }                                                                                                                                        \
+    static ossl_unused ossl_inline void lh_##type##_doall_arg(LHASH_OF(type) * lh, void (*doallarg)(type*, void*), void* arg)                \
+    {                                                                                                                                        \
+        OPENSSL_LH_doall_arg((OPENSSL_LHASH*)lh, (OPENSSL_LH_DOALL_FUNCARG)doallarg, arg);                                                   \
+    }                                                                                                                                        \
     LHASH_OF(type)
 
 #define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \
@@ -239,23 +254,21 @@ void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
 #define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \
     int_implement_lhash_doall(type, argtype, type)
 
-#define int_implement_lhash_doall(type, argtype, cbargtype) \
-    static ossl_unused ossl_inline void \
-        lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \
-                                   void (*fn)(cbargtype *, argtype *), \
-                                   argtype *arg) \
-    { \
-        OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void *)arg); \
-    } \
+#define int_implement_lhash_doall(type, argtype, cbargtype)                                              \
+    static ossl_unused ossl_inline void                                                                  \
+        lh_##type##_doall_##argtype(LHASH_OF(type) * lh, void (*fn)(cbargtype*, argtype*), argtype* arg) \
+    {                                                                                                    \
+        OPENSSL_LH_doall_arg((OPENSSL_LHASH*)lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void*)arg);              \
+    }                                                                                                    \
     LHASH_OF(type)
 
-DEFINE_LHASH_OF_INTERNAL(OPENSSL_STRING);
-#define lh_OPENSSL_STRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_STRING) *)OPENSSL_LH_new(ossl_check_OPENSSL_STRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_STRING_lh_compfunc_type(cmp)))
+    DEFINE_LHASH_OF_INTERNAL(OPENSSL_STRING);
+#define lh_OPENSSL_STRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_STRING)*)OPENSSL_LH_new(ossl_check_OPENSSL_STRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_STRING_lh_compfunc_type(cmp)))
 #define lh_OPENSSL_STRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_STRING_lh_type(lh))
 #define lh_OPENSSL_STRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_STRING_lh_type(lh))
-#define lh_OPENSSL_STRING_insert(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_plain_type(ptr)))
-#define lh_OPENSSL_STRING_delete(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
-#define lh_OPENSSL_STRING_retrieve(lh, ptr) ((OPENSSL_STRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_insert(lh, ptr) ((OPENSSL_STRING*)OPENSSL_LH_insert(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_delete(lh, ptr) ((OPENSSL_STRING*)OPENSSL_LH_delete(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_STRING_retrieve(lh, ptr) ((OPENSSL_STRING*)OPENSSL_LH_retrieve(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_const_OPENSSL_STRING_lh_plain_type(ptr)))
 #define lh_OPENSSL_STRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_STRING_lh_type(lh))
 #define lh_OPENSSL_STRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_STRING_lh_type(lh))
 #define lh_OPENSSL_STRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_STRING_lh_type(lh), out)
@@ -264,13 +277,13 @@ DEFINE_LHASH_OF_INTERNAL(OPENSSL_STRING);
 #define lh_OPENSSL_STRING_get_down_load(lh) OPENSSL_LH_get_down_load(ossl_check_OPENSSL_STRING_lh_type(lh))
 #define lh_OPENSSL_STRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_STRING_lh_type(lh), dl)
 #define lh_OPENSSL_STRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_STRING_lh_type(lh), ossl_check_OPENSSL_STRING_lh_doallfunc_type(dfn))
-DEFINE_LHASH_OF_INTERNAL(OPENSSL_CSTRING);
-#define lh_OPENSSL_CSTRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_CSTRING) *)OPENSSL_LH_new(ossl_check_OPENSSL_CSTRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_CSTRING_lh_compfunc_type(cmp)))
+    DEFINE_LHASH_OF_INTERNAL(OPENSSL_CSTRING);
+#define lh_OPENSSL_CSTRING_new(hfn, cmp) ((LHASH_OF(OPENSSL_CSTRING)*)OPENSSL_LH_new(ossl_check_OPENSSL_CSTRING_lh_hashfunc_type(hfn), ossl_check_OPENSSL_CSTRING_lh_compfunc_type(cmp)))
 #define lh_OPENSSL_CSTRING_free(lh) OPENSSL_LH_free(ossl_check_OPENSSL_CSTRING_lh_type(lh))
 #define lh_OPENSSL_CSTRING_flush(lh) OPENSSL_LH_flush(ossl_check_OPENSSL_CSTRING_lh_type(lh))
-#define lh_OPENSSL_CSTRING_insert(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_insert(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_plain_type(ptr)))
-#define lh_OPENSSL_CSTRING_delete(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_delete(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
-#define lh_OPENSSL_CSTRING_retrieve(lh, ptr) ((OPENSSL_CSTRING *)OPENSSL_LH_retrieve(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_insert(lh, ptr) ((OPENSSL_CSTRING*)OPENSSL_LH_insert(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_delete(lh, ptr) ((OPENSSL_CSTRING*)OPENSSL_LH_delete(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
+#define lh_OPENSSL_CSTRING_retrieve(lh, ptr) ((OPENSSL_CSTRING*)OPENSSL_LH_retrieve(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_const_OPENSSL_CSTRING_lh_plain_type(ptr)))
 #define lh_OPENSSL_CSTRING_error(lh) OPENSSL_LH_error(ossl_check_OPENSSL_CSTRING_lh_type(lh))
 #define lh_OPENSSL_CSTRING_num_items(lh) OPENSSL_LH_num_items(ossl_check_OPENSSL_CSTRING_lh_type(lh))
 #define lh_OPENSSL_CSTRING_node_stats_bio(lh, out) OPENSSL_LH_node_stats_bio(ossl_check_const_OPENSSL_CSTRING_lh_type(lh), out)
@@ -280,8 +293,7 @@ DEFINE_LHASH_OF_INTERNAL(OPENSSL_CSTRING);
 #define lh_OPENSSL_CSTRING_set_down_load(lh, dl) OPENSSL_LH_set_down_load(ossl_check_OPENSSL_CSTRING_lh_type(lh), dl)
 #define lh_OPENSSL_CSTRING_doall(lh, dfn) OPENSSL_LH_doall(ossl_check_OPENSSL_CSTRING_lh_type(lh), ossl_check_OPENSSL_CSTRING_lh_doallfunc_type(dfn))
 
-
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/CAPI/cpp/grpc/include/openssl/macros.h b/CAPI/cpp/grpc/include/openssl/macros.h
index a6bc3f1..05c016f 100644
--- a/CAPI/cpp/grpc/include/openssl/macros.h
+++ b/CAPI/cpp/grpc/include/openssl/macros.h
@@ -8,22 +8,21 @@
  */
 
 #ifndef OPENSSL_MACROS_H
-# define OPENSSL_MACROS_H
-# pragma once
+#define OPENSSL_MACROS_H
+#pragma once
 
 #include <openssl/opensslconf.h>
 #include <openssl/opensslv.h>
 
-
 /* Helper macros for CPP string composition */
-# define OPENSSL_MSTR_HELPER(x) #x
-# define OPENSSL_MSTR(x) OPENSSL_MSTR_HELPER(x)
+#define OPENSSL_MSTR_HELPER(x) #x
+#define OPENSSL_MSTR(x) OPENSSL_MSTR_HELPER(x)
 
 /*
  * Sometimes OPENSSL_NO_xxx ends up with an empty file and some compilers
  * don't like that.  This will hopefully silence them.
  */
-# define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy;
+#define NON_EMPTY_TRANSLATION_UNIT static void* dummy = &dummy;
 
 /*
  * Generic deprecation macro
@@ -31,54 +30,54 @@
  * If OPENSSL_SUPPRESS_DEPRECATED is defined, then OSSL_DEPRECATED and
  * OSSL_DEPRECATED_FOR become no-ops
  */
-# ifndef OSSL_DEPRECATED
-#  undef OSSL_DEPRECATED_FOR
-#  ifndef OPENSSL_SUPPRESS_DEPRECATED
-#   if defined(_MSC_VER)
-     /*
-      * MSVC supports __declspec(deprecated) since MSVC 2003 (13.10),
-      * and __declspec(deprecated(message)) since MSVC 2005 (14.00)
-      */
-#    if _MSC_VER >= 1400
-#     define OSSL_DEPRECATED(since) \
-          __declspec(deprecated("Since OpenSSL " # since))
-#     define OSSL_DEPRECATED_FOR(since, message) \
-          __declspec(deprecated("Since OpenSSL " # since ";" message))
-#    elif _MSC_VER >= 1310
-#     define OSSL_DEPRECATED(since) __declspec(deprecated)
-#     define OSSL_DEPRECATED_FOR(since, message) __declspec(deprecated)
-#    endif
-#   elif defined(__GNUC__)
-     /*
-      * According to GCC documentation, deprecations with message appeared in
-      * GCC 4.5.0
-      */
-#    if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
-#     define OSSL_DEPRECATED(since) \
-          __attribute__((deprecated("Since OpenSSL " # since)))
-#     define OSSL_DEPRECATED_FOR(since, message) \
-          __attribute__((deprecated("Since OpenSSL " # since ";" message)))
-#    elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
-#     define OSSL_DEPRECATED(since) __attribute__((deprecated))
-#     define OSSL_DEPRECATED_FOR(since, message) __attribute__((deprecated))
-#    endif
-#   elif defined(__SUNPRO_C)
-#    if (__SUNPRO_C >= 0x5130)
-#     define OSSL_DEPRECATED(since) __attribute__ ((deprecated))
-#     define OSSL_DEPRECATED_FOR(since, message) __attribute__ ((deprecated))
-#    endif
-#   endif
-#  endif
-# endif
+#ifndef OSSL_DEPRECATED
+#undef OSSL_DEPRECATED_FOR
+#ifndef OPENSSL_SUPPRESS_DEPRECATED
+#if defined(_MSC_VER)
+/*
+ * MSVC supports __declspec(deprecated) since MSVC 2003 (13.10),
+ * and __declspec(deprecated(message)) since MSVC 2005 (14.00)
+ */
+#if _MSC_VER >= 1400
+#define OSSL_DEPRECATED(since) \
+    __declspec(deprecated("Since OpenSSL " #since))
+#define OSSL_DEPRECATED_FOR(since, message) \
+    __declspec(deprecated("Since OpenSSL " #since ";" message))
+#elif _MSC_VER >= 1310
+#define OSSL_DEPRECATED(since) __declspec(deprecated)
+#define OSSL_DEPRECATED_FOR(since, message) __declspec(deprecated)
+#endif
+#elif defined(__GNUC__)
+/*
+ * According to GCC documentation, deprecations with message appeared in
+ * GCC 4.5.0
+ */
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#define OSSL_DEPRECATED(since) \
+    __attribute__((deprecated("Since OpenSSL " #since)))
+#define OSSL_DEPRECATED_FOR(since, message) \
+    __attribute__((deprecated("Since OpenSSL " #since ";" message)))
+#elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
+#define OSSL_DEPRECATED(since) __attribute__((deprecated))
+#define OSSL_DEPRECATED_FOR(since, message) __attribute__((deprecated))
+#endif
+#elif defined(__SUNPRO_C)
+#if (__SUNPRO_C >= 0x5130)
+#define OSSL_DEPRECATED(since) __attribute__((deprecated))
+#define OSSL_DEPRECATED_FOR(since, message) __attribute__((deprecated))
+#endif
+#endif
+#endif
+#endif
 
 /*
  * Still not defined?  Then define no-op macros. This means these macros
  * are unsuitable for use in a typedef.
  */
-# ifndef OSSL_DEPRECATED
-#  define OSSL_DEPRECATED(since)                extern
-#  define OSSL_DEPRECATED_FOR(since, message)   extern
-# endif
+#ifndef OSSL_DEPRECATED
+#define OSSL_DEPRECATED(since) extern
+#define OSSL_DEPRECATED_FOR(since, message) extern
+#endif
 
 /*
  * Applications should use -DOPENSSL_API_COMPAT=<version> to suppress the
@@ -101,9 +100,9 @@
  * macros are used to enable or disable features at that API version boundary.
  */
 
-# ifdef OPENSSL_API_LEVEL
-#  error "OPENSSL_API_LEVEL must not be defined by application"
-# endif
+#ifdef OPENSSL_API_LEVEL
+#error "OPENSSL_API_LEVEL must not be defined by application"
+#endif
 
 /*
  * We figure out what API level was intended by simple numeric comparison.
@@ -111,49 +110,47 @@
  * safety margin and assume that anything below 0x00900000L is a new style
  * number.  This allows new versions up to and including v943.71.83.
  */
-# ifdef OPENSSL_API_COMPAT
-#  if OPENSSL_API_COMPAT < 0x900000L
-#   define OPENSSL_API_LEVEL (OPENSSL_API_COMPAT)
-#  else
-#   define OPENSSL_API_LEVEL                            \
-           (((OPENSSL_API_COMPAT >> 28) & 0xF) * 10000  \
-            + ((OPENSSL_API_COMPAT >> 20) & 0xFF) * 100 \
-            + ((OPENSSL_API_COMPAT >> 12) & 0xFF))
-#  endif
-# endif
+#ifdef OPENSSL_API_COMPAT
+#if OPENSSL_API_COMPAT < 0x900000L
+#define OPENSSL_API_LEVEL (OPENSSL_API_COMPAT)
+#else
+#define OPENSSL_API_LEVEL \
+    (((OPENSSL_API_COMPAT >> 28) & 0xF) * 10000 + ((OPENSSL_API_COMPAT >> 20) & 0xFF) * 100 + ((OPENSSL_API_COMPAT >> 12) & 0xFF))
+#endif
+#endif
 
 /*
  * If OPENSSL_API_COMPAT wasn't given, we use default numbers to set
  * the API compatibility level.
  */
-# ifndef OPENSSL_API_LEVEL
-#  if OPENSSL_CONFIGURED_API > 0
-#   define OPENSSL_API_LEVEL (OPENSSL_CONFIGURED_API)
-#  else
-#   define OPENSSL_API_LEVEL \
-           (OPENSSL_VERSION_MAJOR * 10000 + OPENSSL_VERSION_MINOR * 100)
-#  endif
-# endif
+#ifndef OPENSSL_API_LEVEL
+#if OPENSSL_CONFIGURED_API > 0
+#define OPENSSL_API_LEVEL (OPENSSL_CONFIGURED_API)
+#else
+#define OPENSSL_API_LEVEL \
+    (OPENSSL_VERSION_MAJOR * 10000 + OPENSSL_VERSION_MINOR * 100)
+#endif
+#endif
 
-# if OPENSSL_API_LEVEL > OPENSSL_CONFIGURED_API
-#  error "The requested API level higher than the configured API compatibility level"
-# endif
+#if OPENSSL_API_LEVEL > OPENSSL_CONFIGURED_API
+#error "The requested API level higher than the configured API compatibility level"
+#endif
 
 /*
  * Check of sane values.
  */
 /* Can't go higher than the current version. */
-# if OPENSSL_API_LEVEL > (OPENSSL_VERSION_MAJOR * 10000 + OPENSSL_VERSION_MINOR * 100)
-#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
-# endif
+#if OPENSSL_API_LEVEL > (OPENSSL_VERSION_MAJOR * 10000 + OPENSSL_VERSION_MINOR * 100)
+#error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+#endif
 /* OpenSSL will have no version 2.y.z */
-# if OPENSSL_API_LEVEL < 30000 && OPENSSL_API_LEVEL >= 20000
-#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
-# endif
+#if OPENSSL_API_LEVEL < 30000 && OPENSSL_API_LEVEL >= 20000
+#error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+#endif
 /* Below 0.9.8 is unacceptably low */
-# if OPENSSL_API_LEVEL < 908
-#  error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
-# endif
+#if OPENSSL_API_LEVEL < 908
+#error "OPENSSL_API_COMPAT expresses an impossible API compatibility level"
+#endif
 
 /*
  * Define macros for deprecation and simulated removal purposes.
@@ -169,105 +166,105 @@
  * 'no-deprecated'.
  */
 
-# undef OPENSSL_NO_DEPRECATED_3_0
-# undef OPENSSL_NO_DEPRECATED_1_1_1
-# undef OPENSSL_NO_DEPRECATED_1_1_0
-# undef OPENSSL_NO_DEPRECATED_1_0_2
-# undef OPENSSL_NO_DEPRECATED_1_0_1
-# undef OPENSSL_NO_DEPRECATED_1_0_0
-# undef OPENSSL_NO_DEPRECATED_0_9_8
+#undef OPENSSL_NO_DEPRECATED_3_0
+#undef OPENSSL_NO_DEPRECATED_1_1_1
+#undef OPENSSL_NO_DEPRECATED_1_1_0
+#undef OPENSSL_NO_DEPRECATED_1_0_2
+#undef OPENSSL_NO_DEPRECATED_1_0_1
+#undef OPENSSL_NO_DEPRECATED_1_0_0
+#undef OPENSSL_NO_DEPRECATED_0_9_8
 
-# if OPENSSL_API_LEVEL >= 30000
-#  ifndef OPENSSL_NO_DEPRECATED
-#   define OSSL_DEPRECATEDIN_3_0                OSSL_DEPRECATED(3.0)
-#   define OSSL_DEPRECATEDIN_3_0_FOR(msg)       OSSL_DEPRECATED_FOR(3.0, msg)
-#  else
-#   define OPENSSL_NO_DEPRECATED_3_0
-#  endif
-# else
-#  define OSSL_DEPRECATEDIN_3_0
-#  define OSSL_DEPRECATEDIN_3_0_FOR(msg)
-# endif
-# if OPENSSL_API_LEVEL >= 10101
-#  ifndef OPENSSL_NO_DEPRECATED
-#   define OSSL_DEPRECATEDIN_1_1_1              OSSL_DEPRECATED(1.1.1)
-#   define OSSL_DEPRECATEDIN_1_1_1_FOR(msg)     OSSL_DEPRECATED_FOR(1.1.1, msg)
-#  else
-#   define OPENSSL_NO_DEPRECATED_1_1_1
-#  endif
-# else
-#  define OSSL_DEPRECATEDIN_1_1_1
-#  define OSSL_DEPRECATEDIN_1_1_1_FOR(msg)
-# endif
-# if OPENSSL_API_LEVEL >= 10100
-#  ifndef OPENSSL_NO_DEPRECATED
-#   define OSSL_DEPRECATEDIN_1_1_0              OSSL_DEPRECATED(1.1.0)
-#   define OSSL_DEPRECATEDIN_1_1_0_FOR(msg)     OSSL_DEPRECATED_FOR(1.1.0, msg)
-#  else
-#   define OPENSSL_NO_DEPRECATED_1_1_0
-#  endif
-# else
-#  define OSSL_DEPRECATEDIN_1_1_0
-#  define OSSL_DEPRECATEDIN_1_1_0_FOR(msg)
-# endif
-# if OPENSSL_API_LEVEL >= 10002
-#  ifndef OPENSSL_NO_DEPRECATED
-#   define OSSL_DEPRECATEDIN_1_0_2              OSSL_DEPRECATED(1.0.2)
-#   define OSSL_DEPRECATEDIN_1_0_2_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.2, msg)
-#  else
-#   define OPENSSL_NO_DEPRECATED_1_0_2
-#  endif
-# else
-#  define OSSL_DEPRECATEDIN_1_0_2
-#  define OSSL_DEPRECATEDIN_1_0_2_FOR(msg)
-# endif
-# if OPENSSL_API_LEVEL >= 10001
-#  ifndef OPENSSL_NO_DEPRECATED
-#   define OSSL_DEPRECATEDIN_1_0_1              OSSL_DEPRECATED(1.0.1)
-#   define OSSL_DEPRECATEDIN_1_0_1_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.1, msg)
-#  else
-#   define OPENSSL_NO_DEPRECATED_1_0_1
-#  endif
-# else
-#  define OSSL_DEPRECATEDIN_1_0_1
-#  define OSSL_DEPRECATEDIN_1_0_1_FOR(msg)
-# endif
-# if OPENSSL_API_LEVEL >= 10000
-#  ifndef OPENSSL_NO_DEPRECATED
-#   define OSSL_DEPRECATEDIN_1_0_0              OSSL_DEPRECATED(1.0.0)
-#   define OSSL_DEPRECATEDIN_1_0_0_FOR(msg)     OSSL_DEPRECATED_FOR(1.0.0, msg)
-#  else
-#   define OPENSSL_NO_DEPRECATED_1_0_0
-#  endif
-# else
-#  define OSSL_DEPRECATEDIN_1_0_0
-#  define OSSL_DEPRECATEDIN_1_0_0_FOR(msg)
-# endif
-# if OPENSSL_API_LEVEL >= 908
-#  ifndef OPENSSL_NO_DEPRECATED
-#   define OSSL_DEPRECATEDIN_0_9_8              OSSL_DEPRECATED(0.9.8)
-#   define OSSL_DEPRECATEDIN_0_9_8_FOR(msg)     OSSL_DEPRECATED_FOR(0.9.8, msg)
-#  else
-#   define OPENSSL_NO_DEPRECATED_0_9_8
-#  endif
-# else
-#  define OSSL_DEPRECATEDIN_0_9_8
-#  define OSSL_DEPRECATEDIN_0_9_8_FOR(msg)
-# endif
+#if OPENSSL_API_LEVEL >= 30000
+#ifndef OPENSSL_NO_DEPRECATED
+#define OSSL_DEPRECATEDIN_3_0 OSSL_DEPRECATED(3.0)
+#define OSSL_DEPRECATEDIN_3_0_FOR(msg) OSSL_DEPRECATED_FOR(3.0, msg)
+#else
+#define OPENSSL_NO_DEPRECATED_3_0
+#endif
+#else
+#define OSSL_DEPRECATEDIN_3_0
+#define OSSL_DEPRECATEDIN_3_0_FOR(msg)
+#endif
+#if OPENSSL_API_LEVEL >= 10101
+#ifndef OPENSSL_NO_DEPRECATED
+#define OSSL_DEPRECATEDIN_1_1_1 OSSL_DEPRECATED(1.1.1)
+#define OSSL_DEPRECATEDIN_1_1_1_FOR(msg) OSSL_DEPRECATED_FOR(1.1.1, msg)
+#else
+#define OPENSSL_NO_DEPRECATED_1_1_1
+#endif
+#else
+#define OSSL_DEPRECATEDIN_1_1_1
+#define OSSL_DEPRECATEDIN_1_1_1_FOR(msg)
+#endif
+#if OPENSSL_API_LEVEL >= 10100
+#ifndef OPENSSL_NO_DEPRECATED
+#define OSSL_DEPRECATEDIN_1_1_0 OSSL_DEPRECATED(1.1.0)
+#define OSSL_DEPRECATEDIN_1_1_0_FOR(msg) OSSL_DEPRECATED_FOR(1.1.0, msg)
+#else
+#define OPENSSL_NO_DEPRECATED_1_1_0
+#endif
+#else
+#define OSSL_DEPRECATEDIN_1_1_0
+#define OSSL_DEPRECATEDIN_1_1_0_FOR(msg)
+#endif
+#if OPENSSL_API_LEVEL >= 10002
+#ifndef OPENSSL_NO_DEPRECATED
+#define OSSL_DEPRECATEDIN_1_0_2 OSSL_DEPRECATED(1.0.2)
+#define OSSL_DEPRECATEDIN_1_0_2_FOR(msg) OSSL_DEPRECATED_FOR(1.0.2, msg)
+#else
+#define OPENSSL_NO_DEPRECATED_1_0_2
+#endif
+#else
+#define OSSL_DEPRECATEDIN_1_0_2
+#define OSSL_DEPRECATEDIN_1_0_2_FOR(msg)
+#endif
+#if OPENSSL_API_LEVEL >= 10001
+#ifndef OPENSSL_NO_DEPRECATED
+#define OSSL_DEPRECATEDIN_1_0_1 OSSL_DEPRECATED(1.0.1)
+#define OSSL_DEPRECATEDIN_1_0_1_FOR(msg) OSSL_DEPRECATED_FOR(1.0.1, msg)
+#else
+#define OPENSSL_NO_DEPRECATED_1_0_1
+#endif
+#else
+#define OSSL_DEPRECATEDIN_1_0_1
+#define OSSL_DEPRECATEDIN_1_0_1_FOR(msg)
+#endif
+#if OPENSSL_API_LEVEL >= 10000
+#ifndef OPENSSL_NO_DEPRECATED
+#define OSSL_DEPRECATEDIN_1_0_0 OSSL_DEPRECATED(1.0.0)
+#define OSSL_DEPRECATEDIN_1_0_0_FOR(msg) OSSL_DEPRECATED_FOR(1.0.0, msg)
+#else
+#define OPENSSL_NO_DEPRECATED_1_0_0
+#endif
+#else
+#define OSSL_DEPRECATEDIN_1_0_0
+#define OSSL_DEPRECATEDIN_1_0_0_FOR(msg)
+#endif
+#if OPENSSL_API_LEVEL >= 908
+#ifndef OPENSSL_NO_DEPRECATED
+#define OSSL_DEPRECATEDIN_0_9_8 OSSL_DEPRECATED(0.9.8)
+#define OSSL_DEPRECATEDIN_0_9_8_FOR(msg) OSSL_DEPRECATED_FOR(0.9.8, msg)
+#else
+#define OPENSSL_NO_DEPRECATED_0_9_8
+#endif
+#else
+#define OSSL_DEPRECATEDIN_0_9_8
+#define OSSL_DEPRECATEDIN_0_9_8_FOR(msg)
+#endif
 
 /*
  * Make our own variants of __FILE__ and __LINE__, depending on configuration
  */
 
-# ifndef OPENSSL_FILE
-#  ifdef OPENSSL_NO_FILENAMES
-#   define OPENSSL_FILE ""
-#   define OPENSSL_LINE 0
-#  else
-#   define OPENSSL_FILE __FILE__
-#   define OPENSSL_LINE __LINE__
-#  endif
-# endif
+#ifndef OPENSSL_FILE
+#ifdef OPENSSL_NO_FILENAMES
+#define OPENSSL_FILE ""
+#define OPENSSL_LINE 0
+#else
+#define OPENSSL_FILE __FILE__
+#define OPENSSL_LINE __LINE__
+#endif
+#endif
 
 /*
  * __func__ was standardized in C99, so for any compiler that claims
@@ -282,23 +279,23 @@
  * If none of the above applies, we check if the compiler is MSVC,
  * and use __FUNCTION__ if that's the case.
  */
-# ifndef OPENSSL_FUNC
-#  if defined(__STDC_VERSION__)
-#   if __STDC_VERSION__ >= 199901L
-#    define OPENSSL_FUNC __func__
-#   elif defined(__GNUC__) && __GNUC__ >= 2
-#    define OPENSSL_FUNC __FUNCTION__
-#   endif
-#  elif defined(_MSC_VER)
-#    define OPENSSL_FUNC __FUNCTION__
-#  endif
+#ifndef OPENSSL_FUNC
+#if defined(__STDC_VERSION__)
+#if __STDC_VERSION__ >= 199901L
+#define OPENSSL_FUNC __func__
+#elif defined(__GNUC__) && __GNUC__ >= 2
+#define OPENSSL_FUNC __FUNCTION__
+#endif
+#elif defined(_MSC_VER)
+#define OPENSSL_FUNC __FUNCTION__
+#endif
 /*
  * If all these possibilities are exhausted, we give up and use a
  * static string.
  */
-#  ifndef OPENSSL_FUNC
-#   define OPENSSL_FUNC "(unknown function)"
-#  endif
-# endif
+#ifndef OPENSSL_FUNC
+#define OPENSSL_FUNC "(unknown function)"
+#endif
+#endif
 
-#endif  /* OPENSSL_MACROS_H */
+#endif /* OPENSSL_MACROS_H */
diff --git a/CAPI/cpp/grpc/include/openssl/md2.h b/CAPI/cpp/grpc/include/openssl/md2.h
index 5d4cb77..34d3692 100644
--- a/CAPI/cpp/grpc/include/openssl/md2.h
+++ b/CAPI/cpp/grpc/include/openssl/md2.h
@@ -8,49 +8,49 @@
  */
 
 #ifndef OPENSSL_MD2_H
-# define OPENSSL_MD2_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_MD2_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_MD2
-#  include <stddef.h>
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
-
-#  define MD2_DIGEST_LENGTH       16
-
-#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
-
-typedef unsigned char MD2_INT;
-
-#   define MD2_BLOCK               16
-
-typedef struct MD2state_st {
-    unsigned int num;
-    unsigned char data[MD2_BLOCK];
-    MD2_INT cksm[MD2_BLOCK];
-    MD2_INT state[MD2_BLOCK];
-} MD2_CTX;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 const char *MD2_options(void);
-OSSL_DEPRECATEDIN_3_0 int MD2_Init(MD2_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int MD2_Update(MD2_CTX *c, const unsigned char *data,
-                                     size_t len);
-OSSL_DEPRECATEDIN_3_0 int MD2_Final(unsigned char *md, MD2_CTX *c);
-OSSL_DEPRECATEDIN_3_0 unsigned char *MD2(const unsigned char *d, size_t n,
-                                         unsigned char *md);
-#  endif
-
-#  ifdef  __cplusplus
+#define OPENSSL_MD2_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_MD2_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_MD2
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define MD2_DIGEST_LENGTH 16
+
+#if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+    typedef unsigned char MD2_INT;
+
+#define MD2_BLOCK 16
+
+    typedef struct MD2state_st
+    {
+        unsigned int num;
+        unsigned char data[MD2_BLOCK];
+        MD2_INT cksm[MD2_BLOCK];
+        MD2_INT state[MD2_BLOCK];
+    } MD2_CTX;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 const char* MD2_options(void);
+    OSSL_DEPRECATEDIN_3_0 int MD2_Init(MD2_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int MD2_Update(MD2_CTX* c, const unsigned char* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int MD2_Final(unsigned char* md, MD2_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 unsigned char* MD2(const unsigned char* d, size_t n, unsigned char* md);
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/md4.h b/CAPI/cpp/grpc/include/openssl/md4.h
index 6c150a6..b469061 100644
--- a/CAPI/cpp/grpc/include/openssl/md4.h
+++ b/CAPI/cpp/grpc/include/openssl/md4.h
@@ -8,56 +8,57 @@
  */
 
 #ifndef OPENSSL_MD4_H
-# define OPENSSL_MD4_H
-# pragma once
+#define OPENSSL_MD4_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_MD4_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_MD4_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_MD4
-#  include <openssl/e_os2.h>
-#  include <stddef.h>
-#  ifdef  __cplusplus
-extern "C" {
-#   endif
+#ifndef OPENSSL_NO_MD4
+#include <openssl/e_os2.h>
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  define MD4_DIGEST_LENGTH 16
+#define MD4_DIGEST_LENGTH 16
 
-#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+#if !defined(OPENSSL_NO_DEPRECATED_3_0)
 
 /*-
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  * ! MD4_LONG has to be at least 32 bits wide.                     !
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  */
-#   define MD4_LONG unsigned int
-
-#   define MD4_CBLOCK      64
-#   define MD4_LBLOCK      (MD4_CBLOCK/4)
-
-typedef struct MD4state_st {
-    MD4_LONG A, B, C, D;
-    MD4_LONG Nl, Nh;
-    MD4_LONG data[MD4_LBLOCK];
-    unsigned int num;
-} MD4_CTX;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int MD4_Init(MD4_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int MD4_Update(MD4_CTX *c, const void *data, size_t len);
-OSSL_DEPRECATEDIN_3_0 int MD4_Final(unsigned char *md, MD4_CTX *c);
-OSSL_DEPRECATEDIN_3_0 unsigned char *MD4(const unsigned char *d, size_t n,
-                                         unsigned char *md);
-OSSL_DEPRECATEDIN_3_0 void MD4_Transform(MD4_CTX *c, const unsigned char *b);
-#  endif
-
-#  ifdef  __cplusplus
+#define MD4_LONG unsigned int
+
+#define MD4_CBLOCK 64
+#define MD4_LBLOCK (MD4_CBLOCK / 4)
+
+    typedef struct MD4state_st
+    {
+        MD4_LONG A, B, C, D;
+        MD4_LONG Nl, Nh;
+        MD4_LONG data[MD4_LBLOCK];
+        unsigned int num;
+    } MD4_CTX;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int MD4_Init(MD4_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int MD4_Update(MD4_CTX* c, const void* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int MD4_Final(unsigned char* md, MD4_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 unsigned char* MD4(const unsigned char* d, size_t n, unsigned char* md);
+    OSSL_DEPRECATEDIN_3_0 void MD4_Transform(MD4_CTX* c, const unsigned char* b);
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/md5.h b/CAPI/cpp/grpc/include/openssl/md5.h
index 77a5773..95db256 100644
--- a/CAPI/cpp/grpc/include/openssl/md5.h
+++ b/CAPI/cpp/grpc/include/openssl/md5.h
@@ -8,55 +8,56 @@
  */
 
 #ifndef OPENSSL_MD5_H
-# define OPENSSL_MD5_H
-# pragma once
+#define OPENSSL_MD5_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_MD5_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_MD5_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_MD5
-#  include <openssl/e_os2.h>
-#  include <stddef.h>
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
+#ifndef OPENSSL_NO_MD5
+#include <openssl/e_os2.h>
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  define MD5_DIGEST_LENGTH 16
+#define MD5_DIGEST_LENGTH 16
 
-#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
+#if !defined(OPENSSL_NO_DEPRECATED_3_0)
 /*
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  * ! MD5_LONG has to be at least 32 bits wide.                     !
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  */
-#   define MD5_LONG unsigned int
-
-#   define MD5_CBLOCK      64
-#   define MD5_LBLOCK      (MD5_CBLOCK/4)
-
-typedef struct MD5state_st {
-    MD5_LONG A, B, C, D;
-    MD5_LONG Nl, Nh;
-    MD5_LONG data[MD5_LBLOCK];
-    unsigned int num;
-} MD5_CTX;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int MD5_Init(MD5_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int MD5_Update(MD5_CTX *c, const void *data, size_t len);
-OSSL_DEPRECATEDIN_3_0 int MD5_Final(unsigned char *md, MD5_CTX *c);
-OSSL_DEPRECATEDIN_3_0 unsigned char *MD5(const unsigned char *d, size_t n,
-                                         unsigned char *md);
-OSSL_DEPRECATEDIN_3_0 void MD5_Transform(MD5_CTX *c, const unsigned char *b);
-#  endif
-
-#  ifdef  __cplusplus
+#define MD5_LONG unsigned int
+
+#define MD5_CBLOCK 64
+#define MD5_LBLOCK (MD5_CBLOCK / 4)
+
+    typedef struct MD5state_st
+    {
+        MD5_LONG A, B, C, D;
+        MD5_LONG Nl, Nh;
+        MD5_LONG data[MD5_LBLOCK];
+        unsigned int num;
+    } MD5_CTX;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int MD5_Init(MD5_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int MD5_Update(MD5_CTX* c, const void* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int MD5_Final(unsigned char* md, MD5_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 unsigned char* MD5(const unsigned char* d, size_t n, unsigned char* md);
+    OSSL_DEPRECATEDIN_3_0 void MD5_Transform(MD5_CTX* c, const unsigned char* b);
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/mdc2.h b/CAPI/cpp/grpc/include/openssl/mdc2.h
index 5a7ee28..62c3e3c 100644
--- a/CAPI/cpp/grpc/include/openssl/mdc2.h
+++ b/CAPI/cpp/grpc/include/openssl/mdc2.h
@@ -8,48 +8,48 @@
  */
 
 #ifndef OPENSSL_MDC2_H
-# define OPENSSL_MDC2_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_MDC2_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_MDC2
-#  include <stdlib.h>
-#  include <openssl/des.h>
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
-
-#  define MDC2_DIGEST_LENGTH      16
-
-#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
-
-#   define MDC2_BLOCK              8
-
-typedef struct mdc2_ctx_st {
-    unsigned int num;
-    unsigned char data[MDC2_BLOCK];
-    DES_cblock h, hh;
-    unsigned int pad_type;   /* either 1 or 2, default 1 */
-} MDC2_CTX;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int MDC2_Init(MDC2_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int MDC2_Update(MDC2_CTX *c, const unsigned char *data,
-                                      size_t len);
-OSSL_DEPRECATEDIN_3_0 int MDC2_Final(unsigned char *md, MDC2_CTX *c);
-OSSL_DEPRECATEDIN_3_0 unsigned char *MDC2(const unsigned char *d, size_t n,
-                                          unsigned char *md);
-#  endif
-
-#  ifdef  __cplusplus
+#define OPENSSL_MDC2_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_MDC2_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_MDC2
+#include <stdlib.h>
+#include <openssl/des.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define MDC2_DIGEST_LENGTH 16
+
+#if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#define MDC2_BLOCK 8
+
+    typedef struct mdc2_ctx_st
+    {
+        unsigned int num;
+        unsigned char data[MDC2_BLOCK];
+        DES_cblock h, hh;
+        unsigned int pad_type; /* either 1 or 2, default 1 */
+    } MDC2_CTX;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int MDC2_Init(MDC2_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int MDC2_Update(MDC2_CTX* c, const unsigned char* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int MDC2_Final(unsigned char* md, MDC2_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 unsigned char* MDC2(const unsigned char* d, size_t n, unsigned char* md);
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/modes.h b/CAPI/cpp/grpc/include/openssl/modes.h
index e190799..6d46368 100644
--- a/CAPI/cpp/grpc/include/openssl/modes.h
+++ b/CAPI/cpp/grpc/include/openssl/modes.h
@@ -8,212 +8,108 @@
  */
 
 #ifndef OPENSSL_MODES_H
-# define OPENSSL_MODES_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_MODES_H
-# endif
-
-# include <stddef.h>
-# include <openssl/types.h>
-
-# ifdef  __cplusplus
-extern "C" {
-# endif
-typedef void (*block128_f) (const unsigned char in[16],
-                            unsigned char out[16], const void *key);
-
-typedef void (*cbc128_f) (const unsigned char *in, unsigned char *out,
-                          size_t len, const void *key,
-                          unsigned char ivec[16], int enc);
-
-typedef void (*ecb128_f) (const unsigned char *in, unsigned char *out,
-                          size_t len, const void *key,
-                          int enc);
-
-typedef void (*ctr128_f) (const unsigned char *in, unsigned char *out,
-                          size_t blocks, const void *key,
-                          const unsigned char ivec[16]);
-
-typedef void (*ccm128_f) (const unsigned char *in, unsigned char *out,
-                          size_t blocks, const void *key,
-                          const unsigned char ivec[16],
-                          unsigned char cmac[16]);
-
-void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out,
-                           size_t len, const void *key,
-                           unsigned char ivec[16], block128_f block);
-void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out,
-                           size_t len, const void *key,
-                           unsigned char ivec[16], block128_f block);
-
-void CRYPTO_ctr128_encrypt(const unsigned char *in, unsigned char *out,
-                           size_t len, const void *key,
-                           unsigned char ivec[16],
-                           unsigned char ecount_buf[16], unsigned int *num,
-                           block128_f block);
-
-void CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out,
-                                 size_t len, const void *key,
-                                 unsigned char ivec[16],
-                                 unsigned char ecount_buf[16],
-                                 unsigned int *num, ctr128_f ctr);
-
-void CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out,
-                           size_t len, const void *key,
-                           unsigned char ivec[16], int *num,
-                           block128_f block);
-
-void CRYPTO_cfb128_encrypt(const unsigned char *in, unsigned char *out,
-                           size_t len, const void *key,
-                           unsigned char ivec[16], int *num,
-                           int enc, block128_f block);
-void CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out,
-                             size_t length, const void *key,
-                             unsigned char ivec[16], int *num,
-                             int enc, block128_f block);
-void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out,
-                             size_t bits, const void *key,
-                             unsigned char ivec[16], int *num,
-                             int enc, block128_f block);
-
-size_t CRYPTO_cts128_encrypt_block(const unsigned char *in,
-                                   unsigned char *out, size_t len,
-                                   const void *key, unsigned char ivec[16],
-                                   block128_f block);
-size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out,
-                             size_t len, const void *key,
-                             unsigned char ivec[16], cbc128_f cbc);
-size_t CRYPTO_cts128_decrypt_block(const unsigned char *in,
-                                   unsigned char *out, size_t len,
-                                   const void *key, unsigned char ivec[16],
-                                   block128_f block);
-size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out,
-                             size_t len, const void *key,
-                             unsigned char ivec[16], cbc128_f cbc);
-
-size_t CRYPTO_nistcts128_encrypt_block(const unsigned char *in,
-                                       unsigned char *out, size_t len,
-                                       const void *key,
-                                       unsigned char ivec[16],
-                                       block128_f block);
-size_t CRYPTO_nistcts128_encrypt(const unsigned char *in, unsigned char *out,
-                                 size_t len, const void *key,
-                                 unsigned char ivec[16], cbc128_f cbc);
-size_t CRYPTO_nistcts128_decrypt_block(const unsigned char *in,
-                                       unsigned char *out, size_t len,
-                                       const void *key,
-                                       unsigned char ivec[16],
-                                       block128_f block);
-size_t CRYPTO_nistcts128_decrypt(const unsigned char *in, unsigned char *out,
-                                 size_t len, const void *key,
-                                 unsigned char ivec[16], cbc128_f cbc);
-
-typedef struct gcm128_context GCM128_CONTEXT;
-
-GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block);
-void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key, block128_f block);
-void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const unsigned char *iv,
-                         size_t len);
-int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const unsigned char *aad,
-                      size_t len);
-int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx,
-                          const unsigned char *in, unsigned char *out,
-                          size_t len);
-int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx,
-                          const unsigned char *in, unsigned char *out,
-                          size_t len);
-int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx,
-                                const unsigned char *in, unsigned char *out,
-                                size_t len, ctr128_f stream);
-int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
-                                const unsigned char *in, unsigned char *out,
-                                size_t len, ctr128_f stream);
-int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const unsigned char *tag,
-                         size_t len);
-void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, unsigned char *tag, size_t len);
-void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx);
-
-typedef struct ccm128_context CCM128_CONTEXT;
-
-void CRYPTO_ccm128_init(CCM128_CONTEXT *ctx,
-                        unsigned int M, unsigned int L, void *key,
-                        block128_f block);
-int CRYPTO_ccm128_setiv(CCM128_CONTEXT *ctx, const unsigned char *nonce,
-                        size_t nlen, size_t mlen);
-void CRYPTO_ccm128_aad(CCM128_CONTEXT *ctx, const unsigned char *aad,
-                       size_t alen);
-int CRYPTO_ccm128_encrypt(CCM128_CONTEXT *ctx, const unsigned char *inp,
-                          unsigned char *out, size_t len);
-int CRYPTO_ccm128_decrypt(CCM128_CONTEXT *ctx, const unsigned char *inp,
-                          unsigned char *out, size_t len);
-int CRYPTO_ccm128_encrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp,
-                                unsigned char *out, size_t len,
-                                ccm128_f stream);
-int CRYPTO_ccm128_decrypt_ccm64(CCM128_CONTEXT *ctx, const unsigned char *inp,
-                                unsigned char *out, size_t len,
-                                ccm128_f stream);
-size_t CRYPTO_ccm128_tag(CCM128_CONTEXT *ctx, unsigned char *tag, size_t len);
-
-typedef struct xts128_context XTS128_CONTEXT;
-
-int CRYPTO_xts128_encrypt(const XTS128_CONTEXT *ctx,
-                          const unsigned char iv[16],
-                          const unsigned char *inp, unsigned char *out,
-                          size_t len, int enc);
-
-size_t CRYPTO_128_wrap(void *key, const unsigned char *iv,
-                       unsigned char *out,
-                       const unsigned char *in, size_t inlen,
-                       block128_f block);
-
-size_t CRYPTO_128_unwrap(void *key, const unsigned char *iv,
-                         unsigned char *out,
-                         const unsigned char *in, size_t inlen,
-                         block128_f block);
-size_t CRYPTO_128_wrap_pad(void *key, const unsigned char *icv,
-                           unsigned char *out, const unsigned char *in,
-                           size_t inlen, block128_f block);
-size_t CRYPTO_128_unwrap_pad(void *key, const unsigned char *icv,
-                             unsigned char *out, const unsigned char *in,
-                             size_t inlen, block128_f block);
-
-# ifndef OPENSSL_NO_OCB
-typedef struct ocb128_context OCB128_CONTEXT;
-
-typedef void (*ocb128_f) (const unsigned char *in, unsigned char *out,
-                          size_t blocks, const void *key,
-                          size_t start_block_num,
-                          unsigned char offset_i[16],
-                          const unsigned char L_[][16],
-                          unsigned char checksum[16]);
-
-OCB128_CONTEXT *CRYPTO_ocb128_new(void *keyenc, void *keydec,
-                                  block128_f encrypt, block128_f decrypt,
-                                  ocb128_f stream);
-int CRYPTO_ocb128_init(OCB128_CONTEXT *ctx, void *keyenc, void *keydec,
-                       block128_f encrypt, block128_f decrypt,
-                       ocb128_f stream);
-int CRYPTO_ocb128_copy_ctx(OCB128_CONTEXT *dest, OCB128_CONTEXT *src,
-                           void *keyenc, void *keydec);
-int CRYPTO_ocb128_setiv(OCB128_CONTEXT *ctx, const unsigned char *iv,
-                        size_t len, size_t taglen);
-int CRYPTO_ocb128_aad(OCB128_CONTEXT *ctx, const unsigned char *aad,
-                      size_t len);
-int CRYPTO_ocb128_encrypt(OCB128_CONTEXT *ctx, const unsigned char *in,
-                          unsigned char *out, size_t len);
-int CRYPTO_ocb128_decrypt(OCB128_CONTEXT *ctx, const unsigned char *in,
-                          unsigned char *out, size_t len);
-int CRYPTO_ocb128_finish(OCB128_CONTEXT *ctx, const unsigned char *tag,
-                         size_t len);
-int CRYPTO_ocb128_tag(OCB128_CONTEXT *ctx, unsigned char *tag, size_t len);
-void CRYPTO_ocb128_cleanup(OCB128_CONTEXT *ctx);
-# endif                          /* OPENSSL_NO_OCB */
-
-# ifdef  __cplusplus
+#define OPENSSL_MODES_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_MODES_H
+#endif
+
+#include <stddef.h>
+#include <openssl/types.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    typedef void (*block128_f)(const unsigned char in[16], unsigned char out[16], const void* key);
+
+    typedef void (*cbc128_f)(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], int enc);
+
+    typedef void (*ecb128_f)(const unsigned char* in, unsigned char* out, size_t len, const void* key, int enc);
+
+    typedef void (*ctr128_f)(const unsigned char* in, unsigned char* out, size_t blocks, const void* key, const unsigned char ivec[16]);
+
+    typedef void (*ccm128_f)(const unsigned char* in, unsigned char* out, size_t blocks, const void* key, const unsigned char ivec[16], unsigned char cmac[16]);
+
+    void CRYPTO_cbc128_encrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], block128_f block);
+    void CRYPTO_cbc128_decrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], block128_f block);
+
+    void CRYPTO_ctr128_encrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], unsigned char ecount_buf[16], unsigned int* num, block128_f block);
+
+    void CRYPTO_ctr128_encrypt_ctr32(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], unsigned char ecount_buf[16], unsigned int* num, ctr128_f ctr);
+
+    void CRYPTO_ofb128_encrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], int* num, block128_f block);
+
+    void CRYPTO_cfb128_encrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], int* num, int enc, block128_f block);
+    void CRYPTO_cfb128_8_encrypt(const unsigned char* in, unsigned char* out, size_t length, const void* key, unsigned char ivec[16], int* num, int enc, block128_f block);
+    void CRYPTO_cfb128_1_encrypt(const unsigned char* in, unsigned char* out, size_t bits, const void* key, unsigned char ivec[16], int* num, int enc, block128_f block);
+
+    size_t CRYPTO_cts128_encrypt_block(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], block128_f block);
+    size_t CRYPTO_cts128_encrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], cbc128_f cbc);
+    size_t CRYPTO_cts128_decrypt_block(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], block128_f block);
+    size_t CRYPTO_cts128_decrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], cbc128_f cbc);
+
+    size_t CRYPTO_nistcts128_encrypt_block(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], block128_f block);
+    size_t CRYPTO_nistcts128_encrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], cbc128_f cbc);
+    size_t CRYPTO_nistcts128_decrypt_block(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], block128_f block);
+    size_t CRYPTO_nistcts128_decrypt(const unsigned char* in, unsigned char* out, size_t len, const void* key, unsigned char ivec[16], cbc128_f cbc);
+
+    typedef struct gcm128_context GCM128_CONTEXT;
+
+    GCM128_CONTEXT* CRYPTO_gcm128_new(void* key, block128_f block);
+    void CRYPTO_gcm128_init(GCM128_CONTEXT* ctx, void* key, block128_f block);
+    void CRYPTO_gcm128_setiv(GCM128_CONTEXT* ctx, const unsigned char* iv, size_t len);
+    int CRYPTO_gcm128_aad(GCM128_CONTEXT* ctx, const unsigned char* aad, size_t len);
+    int CRYPTO_gcm128_encrypt(GCM128_CONTEXT* ctx, const unsigned char* in, unsigned char* out, size_t len);
+    int CRYPTO_gcm128_decrypt(GCM128_CONTEXT* ctx, const unsigned char* in, unsigned char* out, size_t len);
+    int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT* ctx, const unsigned char* in, unsigned char* out, size_t len, ctr128_f stream);
+    int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT* ctx, const unsigned char* in, unsigned char* out, size_t len, ctr128_f stream);
+    int CRYPTO_gcm128_finish(GCM128_CONTEXT* ctx, const unsigned char* tag, size_t len);
+    void CRYPTO_gcm128_tag(GCM128_CONTEXT* ctx, unsigned char* tag, size_t len);
+    void CRYPTO_gcm128_release(GCM128_CONTEXT* ctx);
+
+    typedef struct ccm128_context CCM128_CONTEXT;
+
+    void CRYPTO_ccm128_init(CCM128_CONTEXT* ctx, unsigned int M, unsigned int L, void* key, block128_f block);
+    int CRYPTO_ccm128_setiv(CCM128_CONTEXT* ctx, const unsigned char* nonce, size_t nlen, size_t mlen);
+    void CRYPTO_ccm128_aad(CCM128_CONTEXT* ctx, const unsigned char* aad, size_t alen);
+    int CRYPTO_ccm128_encrypt(CCM128_CONTEXT* ctx, const unsigned char* inp, unsigned char* out, size_t len);
+    int CRYPTO_ccm128_decrypt(CCM128_CONTEXT* ctx, const unsigned char* inp, unsigned char* out, size_t len);
+    int CRYPTO_ccm128_encrypt_ccm64(CCM128_CONTEXT* ctx, const unsigned char* inp, unsigned char* out, size_t len, ccm128_f stream);
+    int CRYPTO_ccm128_decrypt_ccm64(CCM128_CONTEXT* ctx, const unsigned char* inp, unsigned char* out, size_t len, ccm128_f stream);
+    size_t CRYPTO_ccm128_tag(CCM128_CONTEXT* ctx, unsigned char* tag, size_t len);
+
+    typedef struct xts128_context XTS128_CONTEXT;
+
+    int CRYPTO_xts128_encrypt(const XTS128_CONTEXT* ctx, const unsigned char iv[16], const unsigned char* inp, unsigned char* out, size_t len, int enc);
+
+    size_t CRYPTO_128_wrap(void* key, const unsigned char* iv, unsigned char* out, const unsigned char* in, size_t inlen, block128_f block);
+
+    size_t CRYPTO_128_unwrap(void* key, const unsigned char* iv, unsigned char* out, const unsigned char* in, size_t inlen, block128_f block);
+    size_t CRYPTO_128_wrap_pad(void* key, const unsigned char* icv, unsigned char* out, const unsigned char* in, size_t inlen, block128_f block);
+    size_t CRYPTO_128_unwrap_pad(void* key, const unsigned char* icv, unsigned char* out, const unsigned char* in, size_t inlen, block128_f block);
+
+#ifndef OPENSSL_NO_OCB
+    typedef struct ocb128_context OCB128_CONTEXT;
+
+    typedef void (*ocb128_f)(const unsigned char* in, unsigned char* out, size_t blocks, const void* key, size_t start_block_num, unsigned char offset_i[16], const unsigned char L_[][16], unsigned char checksum[16]);
+
+    OCB128_CONTEXT* CRYPTO_ocb128_new(void* keyenc, void* keydec, block128_f encrypt, block128_f decrypt, ocb128_f stream);
+    int CRYPTO_ocb128_init(OCB128_CONTEXT* ctx, void* keyenc, void* keydec, block128_f encrypt, block128_f decrypt, ocb128_f stream);
+    int CRYPTO_ocb128_copy_ctx(OCB128_CONTEXT* dest, OCB128_CONTEXT* src, void* keyenc, void* keydec);
+    int CRYPTO_ocb128_setiv(OCB128_CONTEXT* ctx, const unsigned char* iv, size_t len, size_t taglen);
+    int CRYPTO_ocb128_aad(OCB128_CONTEXT* ctx, const unsigned char* aad, size_t len);
+    int CRYPTO_ocb128_encrypt(OCB128_CONTEXT* ctx, const unsigned char* in, unsigned char* out, size_t len);
+    int CRYPTO_ocb128_decrypt(OCB128_CONTEXT* ctx, const unsigned char* in, unsigned char* out, size_t len);
+    int CRYPTO_ocb128_finish(OCB128_CONTEXT* ctx, const unsigned char* tag, size_t len);
+    int CRYPTO_ocb128_tag(OCB128_CONTEXT* ctx, unsigned char* tag, size_t len);
+    void CRYPTO_ocb128_cleanup(OCB128_CONTEXT* ctx);
+#endif /* OPENSSL_NO_OCB */
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/obj_mac.h b/CAPI/cpp/grpc/include/openssl/obj_mac.h
index 0e86027..0bc6654 100644
--- a/CAPI/cpp/grpc/include/openssl/obj_mac.h
+++ b/CAPI/cpp/grpc/include/openssl/obj_mac.h
@@ -10,5472 +10,5472 @@
  */
 
 #ifndef OPENSSL_OBJ_MAC_H
-# define OPENSSL_OBJ_MAC_H
-# pragma once
-
-#define SN_undef                        "UNDEF"
-#define LN_undef                        "undefined"
-#define NID_undef                       0
-#define OBJ_undef                       0L
-
-#define SN_itu_t                "ITU-T"
-#define LN_itu_t                "itu-t"
-#define NID_itu_t               645
-#define OBJ_itu_t               0L
-
-#define NID_ccitt               404
-#define OBJ_ccitt               OBJ_itu_t
-
-#define SN_iso          "ISO"
-#define LN_iso          "iso"
-#define NID_iso         181
-#define OBJ_iso         1L
-
-#define SN_joint_iso_itu_t              "JOINT-ISO-ITU-T"
-#define LN_joint_iso_itu_t              "joint-iso-itu-t"
-#define NID_joint_iso_itu_t             646
-#define OBJ_joint_iso_itu_t             2L
-
-#define NID_joint_iso_ccitt             393
-#define OBJ_joint_iso_ccitt             OBJ_joint_iso_itu_t
-
-#define SN_member_body          "member-body"
-#define LN_member_body          "ISO Member Body"
-#define NID_member_body         182
-#define OBJ_member_body         OBJ_iso,2L
-
-#define SN_identified_organization              "identified-organization"
-#define NID_identified_organization             676
-#define OBJ_identified_organization             OBJ_iso,3L
-
-#define SN_gmac         "GMAC"
-#define LN_gmac         "gmac"
-#define NID_gmac                1195
-#define OBJ_gmac                OBJ_iso,0L,9797L,3L,4L
-
-#define SN_hmac_md5             "HMAC-MD5"
-#define LN_hmac_md5             "hmac-md5"
-#define NID_hmac_md5            780
-#define OBJ_hmac_md5            OBJ_identified_organization,6L,1L,5L,5L,8L,1L,1L
-
-#define SN_hmac_sha1            "HMAC-SHA1"
-#define LN_hmac_sha1            "hmac-sha1"
-#define NID_hmac_sha1           781
-#define OBJ_hmac_sha1           OBJ_identified_organization,6L,1L,5L,5L,8L,1L,2L
-
-#define SN_x509ExtAdmission             "x509ExtAdmission"
-#define LN_x509ExtAdmission             "Professional Information or basis for Admission"
-#define NID_x509ExtAdmission            1093
-#define OBJ_x509ExtAdmission            OBJ_identified_organization,36L,8L,3L,3L
-
-#define SN_certicom_arc         "certicom-arc"
-#define NID_certicom_arc                677
-#define OBJ_certicom_arc                OBJ_identified_organization,132L
-
-#define SN_ieee         "ieee"
-#define NID_ieee                1170
-#define OBJ_ieee                OBJ_identified_organization,111L
-
-#define SN_ieee_siswg           "ieee-siswg"
-#define LN_ieee_siswg           "IEEE Security in Storage Working Group"
-#define NID_ieee_siswg          1171
-#define OBJ_ieee_siswg          OBJ_ieee,2L,1619L
-
-#define SN_international_organizations          "international-organizations"
-#define LN_international_organizations          "International Organizations"
-#define NID_international_organizations         647
-#define OBJ_international_organizations         OBJ_joint_iso_itu_t,23L
-
-#define SN_wap          "wap"
-#define NID_wap         678
-#define OBJ_wap         OBJ_international_organizations,43L
-
-#define SN_wap_wsg              "wap-wsg"
-#define NID_wap_wsg             679
-#define OBJ_wap_wsg             OBJ_wap,1L
-
-#define SN_selected_attribute_types             "selected-attribute-types"
-#define LN_selected_attribute_types             "Selected Attribute Types"
-#define NID_selected_attribute_types            394
-#define OBJ_selected_attribute_types            OBJ_joint_iso_itu_t,5L,1L,5L
-
-#define SN_clearance            "clearance"
-#define NID_clearance           395
-#define OBJ_clearance           OBJ_selected_attribute_types,55L
-
-#define SN_ISO_US               "ISO-US"
-#define LN_ISO_US               "ISO US Member Body"
-#define NID_ISO_US              183
-#define OBJ_ISO_US              OBJ_member_body,840L
-
-#define SN_X9_57                "X9-57"
-#define LN_X9_57                "X9.57"
-#define NID_X9_57               184
-#define OBJ_X9_57               OBJ_ISO_US,10040L
-
-#define SN_X9cm         "X9cm"
-#define LN_X9cm         "X9.57 CM ?"
-#define NID_X9cm                185
-#define OBJ_X9cm                OBJ_X9_57,4L
-
-#define SN_ISO_CN               "ISO-CN"
-#define LN_ISO_CN               "ISO CN Member Body"
-#define NID_ISO_CN              1140
-#define OBJ_ISO_CN              OBJ_member_body,156L
-
-#define SN_oscca                "oscca"
-#define NID_oscca               1141
-#define OBJ_oscca               OBJ_ISO_CN,10197L
-
-#define SN_sm_scheme            "sm-scheme"
-#define NID_sm_scheme           1142
-#define OBJ_sm_scheme           OBJ_oscca,1L
-
-#define SN_dsa          "DSA"
-#define LN_dsa          "dsaEncryption"
-#define NID_dsa         116
-#define OBJ_dsa         OBJ_X9cm,1L
-
-#define SN_dsaWithSHA1          "DSA-SHA1"
-#define LN_dsaWithSHA1          "dsaWithSHA1"
-#define NID_dsaWithSHA1         113
-#define OBJ_dsaWithSHA1         OBJ_X9cm,3L
-
-#define SN_ansi_X9_62           "ansi-X9-62"
-#define LN_ansi_X9_62           "ANSI X9.62"
-#define NID_ansi_X9_62          405
-#define OBJ_ansi_X9_62          OBJ_ISO_US,10045L
-
-#define OBJ_X9_62_id_fieldType          OBJ_ansi_X9_62,1L
-
-#define SN_X9_62_prime_field            "prime-field"
-#define NID_X9_62_prime_field           406
-#define OBJ_X9_62_prime_field           OBJ_X9_62_id_fieldType,1L
-
-#define SN_X9_62_characteristic_two_field               "characteristic-two-field"
-#define NID_X9_62_characteristic_two_field              407
-#define OBJ_X9_62_characteristic_two_field              OBJ_X9_62_id_fieldType,2L
-
-#define SN_X9_62_id_characteristic_two_basis            "id-characteristic-two-basis"
-#define NID_X9_62_id_characteristic_two_basis           680
-#define OBJ_X9_62_id_characteristic_two_basis           OBJ_X9_62_characteristic_two_field,3L
-
-#define SN_X9_62_onBasis                "onBasis"
-#define NID_X9_62_onBasis               681
-#define OBJ_X9_62_onBasis               OBJ_X9_62_id_characteristic_two_basis,1L
+#define OPENSSL_OBJ_MAC_H
+#pragma once
+
+#define SN_undef "UNDEF"
+#define LN_undef "undefined"
+#define NID_undef 0
+#define OBJ_undef 0L
+
+#define SN_itu_t "ITU-T"
+#define LN_itu_t "itu-t"
+#define NID_itu_t 645
+#define OBJ_itu_t 0L
+
+#define NID_ccitt 404
+#define OBJ_ccitt OBJ_itu_t
+
+#define SN_iso "ISO"
+#define LN_iso "iso"
+#define NID_iso 181
+#define OBJ_iso 1L
+
+#define SN_joint_iso_itu_t "JOINT-ISO-ITU-T"
+#define LN_joint_iso_itu_t "joint-iso-itu-t"
+#define NID_joint_iso_itu_t 646
+#define OBJ_joint_iso_itu_t 2L
+
+#define NID_joint_iso_ccitt 393
+#define OBJ_joint_iso_ccitt OBJ_joint_iso_itu_t
+
+#define SN_member_body "member-body"
+#define LN_member_body "ISO Member Body"
+#define NID_member_body 182
+#define OBJ_member_body OBJ_iso, 2L
+
+#define SN_identified_organization "identified-organization"
+#define NID_identified_organization 676
+#define OBJ_identified_organization OBJ_iso, 3L
+
+#define SN_gmac "GMAC"
+#define LN_gmac "gmac"
+#define NID_gmac 1195
+#define OBJ_gmac OBJ_iso, 0L, 9797L, 3L, 4L
+
+#define SN_hmac_md5 "HMAC-MD5"
+#define LN_hmac_md5 "hmac-md5"
+#define NID_hmac_md5 780
+#define OBJ_hmac_md5 OBJ_identified_organization, 6L, 1L, 5L, 5L, 8L, 1L, 1L
+
+#define SN_hmac_sha1 "HMAC-SHA1"
+#define LN_hmac_sha1 "hmac-sha1"
+#define NID_hmac_sha1 781
+#define OBJ_hmac_sha1 OBJ_identified_organization, 6L, 1L, 5L, 5L, 8L, 1L, 2L
+
+#define SN_x509ExtAdmission "x509ExtAdmission"
+#define LN_x509ExtAdmission "Professional Information or basis for Admission"
+#define NID_x509ExtAdmission 1093
+#define OBJ_x509ExtAdmission OBJ_identified_organization, 36L, 8L, 3L, 3L
+
+#define SN_certicom_arc "certicom-arc"
+#define NID_certicom_arc 677
+#define OBJ_certicom_arc OBJ_identified_organization, 132L
+
+#define SN_ieee "ieee"
+#define NID_ieee 1170
+#define OBJ_ieee OBJ_identified_organization, 111L
+
+#define SN_ieee_siswg "ieee-siswg"
+#define LN_ieee_siswg "IEEE Security in Storage Working Group"
+#define NID_ieee_siswg 1171
+#define OBJ_ieee_siswg OBJ_ieee, 2L, 1619L
+
+#define SN_international_organizations "international-organizations"
+#define LN_international_organizations "International Organizations"
+#define NID_international_organizations 647
+#define OBJ_international_organizations OBJ_joint_iso_itu_t, 23L
+
+#define SN_wap "wap"
+#define NID_wap 678
+#define OBJ_wap OBJ_international_organizations, 43L
+
+#define SN_wap_wsg "wap-wsg"
+#define NID_wap_wsg 679
+#define OBJ_wap_wsg OBJ_wap, 1L
+
+#define SN_selected_attribute_types "selected-attribute-types"
+#define LN_selected_attribute_types "Selected Attribute Types"
+#define NID_selected_attribute_types 394
+#define OBJ_selected_attribute_types OBJ_joint_iso_itu_t, 5L, 1L, 5L
+
+#define SN_clearance "clearance"
+#define NID_clearance 395
+#define OBJ_clearance OBJ_selected_attribute_types, 55L
+
+#define SN_ISO_US "ISO-US"
+#define LN_ISO_US "ISO US Member Body"
+#define NID_ISO_US 183
+#define OBJ_ISO_US OBJ_member_body, 840L
+
+#define SN_X9_57 "X9-57"
+#define LN_X9_57 "X9.57"
+#define NID_X9_57 184
+#define OBJ_X9_57 OBJ_ISO_US, 10040L
+
+#define SN_X9cm "X9cm"
+#define LN_X9cm "X9.57 CM ?"
+#define NID_X9cm 185
+#define OBJ_X9cm OBJ_X9_57, 4L
+
+#define SN_ISO_CN "ISO-CN"
+#define LN_ISO_CN "ISO CN Member Body"
+#define NID_ISO_CN 1140
+#define OBJ_ISO_CN OBJ_member_body, 156L
+
+#define SN_oscca "oscca"
+#define NID_oscca 1141
+#define OBJ_oscca OBJ_ISO_CN, 10197L
+
+#define SN_sm_scheme "sm-scheme"
+#define NID_sm_scheme 1142
+#define OBJ_sm_scheme OBJ_oscca, 1L
+
+#define SN_dsa "DSA"
+#define LN_dsa "dsaEncryption"
+#define NID_dsa 116
+#define OBJ_dsa OBJ_X9cm, 1L
+
+#define SN_dsaWithSHA1 "DSA-SHA1"
+#define LN_dsaWithSHA1 "dsaWithSHA1"
+#define NID_dsaWithSHA1 113
+#define OBJ_dsaWithSHA1 OBJ_X9cm, 3L
+
+#define SN_ansi_X9_62 "ansi-X9-62"
+#define LN_ansi_X9_62 "ANSI X9.62"
+#define NID_ansi_X9_62 405
+#define OBJ_ansi_X9_62 OBJ_ISO_US, 10045L
+
+#define OBJ_X9_62_id_fieldType OBJ_ansi_X9_62, 1L
+
+#define SN_X9_62_prime_field "prime-field"
+#define NID_X9_62_prime_field 406
+#define OBJ_X9_62_prime_field OBJ_X9_62_id_fieldType, 1L
+
+#define SN_X9_62_characteristic_two_field "characteristic-two-field"
+#define NID_X9_62_characteristic_two_field 407
+#define OBJ_X9_62_characteristic_two_field OBJ_X9_62_id_fieldType, 2L
+
+#define SN_X9_62_id_characteristic_two_basis "id-characteristic-two-basis"
+#define NID_X9_62_id_characteristic_two_basis 680
+#define OBJ_X9_62_id_characteristic_two_basis OBJ_X9_62_characteristic_two_field, 3L
+
+#define SN_X9_62_onBasis "onBasis"
+#define NID_X9_62_onBasis 681
+#define OBJ_X9_62_onBasis OBJ_X9_62_id_characteristic_two_basis, 1L
 
-#define SN_X9_62_tpBasis                "tpBasis"
-#define NID_X9_62_tpBasis               682
-#define OBJ_X9_62_tpBasis               OBJ_X9_62_id_characteristic_two_basis,2L
+#define SN_X9_62_tpBasis "tpBasis"
+#define NID_X9_62_tpBasis 682
+#define OBJ_X9_62_tpBasis OBJ_X9_62_id_characteristic_two_basis, 2L
 
-#define SN_X9_62_ppBasis                "ppBasis"
-#define NID_X9_62_ppBasis               683
-#define OBJ_X9_62_ppBasis               OBJ_X9_62_id_characteristic_two_basis,3L
+#define SN_X9_62_ppBasis "ppBasis"
+#define NID_X9_62_ppBasis 683
+#define OBJ_X9_62_ppBasis OBJ_X9_62_id_characteristic_two_basis, 3L
 
-#define OBJ_X9_62_id_publicKeyType              OBJ_ansi_X9_62,2L
+#define OBJ_X9_62_id_publicKeyType OBJ_ansi_X9_62, 2L
 
-#define SN_X9_62_id_ecPublicKey         "id-ecPublicKey"
-#define NID_X9_62_id_ecPublicKey                408
-#define OBJ_X9_62_id_ecPublicKey                OBJ_X9_62_id_publicKeyType,1L
+#define SN_X9_62_id_ecPublicKey "id-ecPublicKey"
+#define NID_X9_62_id_ecPublicKey 408
+#define OBJ_X9_62_id_ecPublicKey OBJ_X9_62_id_publicKeyType, 1L
 
-#define OBJ_X9_62_ellipticCurve         OBJ_ansi_X9_62,3L
+#define OBJ_X9_62_ellipticCurve OBJ_ansi_X9_62, 3L
 
-#define OBJ_X9_62_c_TwoCurve            OBJ_X9_62_ellipticCurve,0L
+#define OBJ_X9_62_c_TwoCurve OBJ_X9_62_ellipticCurve, 0L
 
-#define SN_X9_62_c2pnb163v1             "c2pnb163v1"
-#define NID_X9_62_c2pnb163v1            684
-#define OBJ_X9_62_c2pnb163v1            OBJ_X9_62_c_TwoCurve,1L
+#define SN_X9_62_c2pnb163v1 "c2pnb163v1"
+#define NID_X9_62_c2pnb163v1 684
+#define OBJ_X9_62_c2pnb163v1 OBJ_X9_62_c_TwoCurve, 1L
 
-#define SN_X9_62_c2pnb163v2             "c2pnb163v2"
-#define NID_X9_62_c2pnb163v2            685
-#define OBJ_X9_62_c2pnb163v2            OBJ_X9_62_c_TwoCurve,2L
+#define SN_X9_62_c2pnb163v2 "c2pnb163v2"
+#define NID_X9_62_c2pnb163v2 685
+#define OBJ_X9_62_c2pnb163v2 OBJ_X9_62_c_TwoCurve, 2L
 
-#define SN_X9_62_c2pnb163v3             "c2pnb163v3"
-#define NID_X9_62_c2pnb163v3            686
-#define OBJ_X9_62_c2pnb163v3            OBJ_X9_62_c_TwoCurve,3L
+#define SN_X9_62_c2pnb163v3 "c2pnb163v3"
+#define NID_X9_62_c2pnb163v3 686
+#define OBJ_X9_62_c2pnb163v3 OBJ_X9_62_c_TwoCurve, 3L
 
-#define SN_X9_62_c2pnb176v1             "c2pnb176v1"
-#define NID_X9_62_c2pnb176v1            687
-#define OBJ_X9_62_c2pnb176v1            OBJ_X9_62_c_TwoCurve,4L
+#define SN_X9_62_c2pnb176v1 "c2pnb176v1"
+#define NID_X9_62_c2pnb176v1 687
+#define OBJ_X9_62_c2pnb176v1 OBJ_X9_62_c_TwoCurve, 4L
 
-#define SN_X9_62_c2tnb191v1             "c2tnb191v1"
-#define NID_X9_62_c2tnb191v1            688
-#define OBJ_X9_62_c2tnb191v1            OBJ_X9_62_c_TwoCurve,5L
+#define SN_X9_62_c2tnb191v1 "c2tnb191v1"
+#define NID_X9_62_c2tnb191v1 688
+#define OBJ_X9_62_c2tnb191v1 OBJ_X9_62_c_TwoCurve, 5L
 
-#define SN_X9_62_c2tnb191v2             "c2tnb191v2"
-#define NID_X9_62_c2tnb191v2            689
-#define OBJ_X9_62_c2tnb191v2            OBJ_X9_62_c_TwoCurve,6L
+#define SN_X9_62_c2tnb191v2 "c2tnb191v2"
+#define NID_X9_62_c2tnb191v2 689
+#define OBJ_X9_62_c2tnb191v2 OBJ_X9_62_c_TwoCurve, 6L
 
-#define SN_X9_62_c2tnb191v3             "c2tnb191v3"
-#define NID_X9_62_c2tnb191v3            690
-#define OBJ_X9_62_c2tnb191v3            OBJ_X9_62_c_TwoCurve,7L
+#define SN_X9_62_c2tnb191v3 "c2tnb191v3"
+#define NID_X9_62_c2tnb191v3 690
+#define OBJ_X9_62_c2tnb191v3 OBJ_X9_62_c_TwoCurve, 7L
 
-#define SN_X9_62_c2onb191v4             "c2onb191v4"
-#define NID_X9_62_c2onb191v4            691
-#define OBJ_X9_62_c2onb191v4            OBJ_X9_62_c_TwoCurve,8L
+#define SN_X9_62_c2onb191v4 "c2onb191v4"
+#define NID_X9_62_c2onb191v4 691
+#define OBJ_X9_62_c2onb191v4 OBJ_X9_62_c_TwoCurve, 8L
 
-#define SN_X9_62_c2onb191v5             "c2onb191v5"
-#define NID_X9_62_c2onb191v5            692
-#define OBJ_X9_62_c2onb191v5            OBJ_X9_62_c_TwoCurve,9L
+#define SN_X9_62_c2onb191v5 "c2onb191v5"
+#define NID_X9_62_c2onb191v5 692
+#define OBJ_X9_62_c2onb191v5 OBJ_X9_62_c_TwoCurve, 9L
 
-#define SN_X9_62_c2pnb208w1             "c2pnb208w1"
-#define NID_X9_62_c2pnb208w1            693
-#define OBJ_X9_62_c2pnb208w1            OBJ_X9_62_c_TwoCurve,10L
+#define SN_X9_62_c2pnb208w1 "c2pnb208w1"
+#define NID_X9_62_c2pnb208w1 693
+#define OBJ_X9_62_c2pnb208w1 OBJ_X9_62_c_TwoCurve, 10L
 
-#define SN_X9_62_c2tnb239v1             "c2tnb239v1"
-#define NID_X9_62_c2tnb239v1            694
-#define OBJ_X9_62_c2tnb239v1            OBJ_X9_62_c_TwoCurve,11L
+#define SN_X9_62_c2tnb239v1 "c2tnb239v1"
+#define NID_X9_62_c2tnb239v1 694
+#define OBJ_X9_62_c2tnb239v1 OBJ_X9_62_c_TwoCurve, 11L
 
-#define SN_X9_62_c2tnb239v2             "c2tnb239v2"
-#define NID_X9_62_c2tnb239v2            695
-#define OBJ_X9_62_c2tnb239v2            OBJ_X9_62_c_TwoCurve,12L
+#define SN_X9_62_c2tnb239v2 "c2tnb239v2"
+#define NID_X9_62_c2tnb239v2 695
+#define OBJ_X9_62_c2tnb239v2 OBJ_X9_62_c_TwoCurve, 12L
 
-#define SN_X9_62_c2tnb239v3             "c2tnb239v3"
-#define NID_X9_62_c2tnb239v3            696
-#define OBJ_X9_62_c2tnb239v3            OBJ_X9_62_c_TwoCurve,13L
+#define SN_X9_62_c2tnb239v3 "c2tnb239v3"
+#define NID_X9_62_c2tnb239v3 696
+#define OBJ_X9_62_c2tnb239v3 OBJ_X9_62_c_TwoCurve, 13L
 
-#define SN_X9_62_c2onb239v4             "c2onb239v4"
-#define NID_X9_62_c2onb239v4            697
-#define OBJ_X9_62_c2onb239v4            OBJ_X9_62_c_TwoCurve,14L
+#define SN_X9_62_c2onb239v4 "c2onb239v4"
+#define NID_X9_62_c2onb239v4 697
+#define OBJ_X9_62_c2onb239v4 OBJ_X9_62_c_TwoCurve, 14L
 
-#define SN_X9_62_c2onb239v5             "c2onb239v5"
-#define NID_X9_62_c2onb239v5            698
-#define OBJ_X9_62_c2onb239v5            OBJ_X9_62_c_TwoCurve,15L
+#define SN_X9_62_c2onb239v5 "c2onb239v5"
+#define NID_X9_62_c2onb239v5 698
+#define OBJ_X9_62_c2onb239v5 OBJ_X9_62_c_TwoCurve, 15L
 
-#define SN_X9_62_c2pnb272w1             "c2pnb272w1"
-#define NID_X9_62_c2pnb272w1            699
-#define OBJ_X9_62_c2pnb272w1            OBJ_X9_62_c_TwoCurve,16L
+#define SN_X9_62_c2pnb272w1 "c2pnb272w1"
+#define NID_X9_62_c2pnb272w1 699
+#define OBJ_X9_62_c2pnb272w1 OBJ_X9_62_c_TwoCurve, 16L
 
-#define SN_X9_62_c2pnb304w1             "c2pnb304w1"
-#define NID_X9_62_c2pnb304w1            700
-#define OBJ_X9_62_c2pnb304w1            OBJ_X9_62_c_TwoCurve,17L
+#define SN_X9_62_c2pnb304w1 "c2pnb304w1"
+#define NID_X9_62_c2pnb304w1 700
+#define OBJ_X9_62_c2pnb304w1 OBJ_X9_62_c_TwoCurve, 17L
 
-#define SN_X9_62_c2tnb359v1             "c2tnb359v1"
-#define NID_X9_62_c2tnb359v1            701
-#define OBJ_X9_62_c2tnb359v1            OBJ_X9_62_c_TwoCurve,18L
+#define SN_X9_62_c2tnb359v1 "c2tnb359v1"
+#define NID_X9_62_c2tnb359v1 701
+#define OBJ_X9_62_c2tnb359v1 OBJ_X9_62_c_TwoCurve, 18L
 
-#define SN_X9_62_c2pnb368w1             "c2pnb368w1"
-#define NID_X9_62_c2pnb368w1            702
-#define OBJ_X9_62_c2pnb368w1            OBJ_X9_62_c_TwoCurve,19L
+#define SN_X9_62_c2pnb368w1 "c2pnb368w1"
+#define NID_X9_62_c2pnb368w1 702
+#define OBJ_X9_62_c2pnb368w1 OBJ_X9_62_c_TwoCurve, 19L
 
-#define SN_X9_62_c2tnb431r1             "c2tnb431r1"
-#define NID_X9_62_c2tnb431r1            703
-#define OBJ_X9_62_c2tnb431r1            OBJ_X9_62_c_TwoCurve,20L
+#define SN_X9_62_c2tnb431r1 "c2tnb431r1"
+#define NID_X9_62_c2tnb431r1 703
+#define OBJ_X9_62_c2tnb431r1 OBJ_X9_62_c_TwoCurve, 20L
 
-#define OBJ_X9_62_primeCurve            OBJ_X9_62_ellipticCurve,1L
+#define OBJ_X9_62_primeCurve OBJ_X9_62_ellipticCurve, 1L
 
-#define SN_X9_62_prime192v1             "prime192v1"
-#define NID_X9_62_prime192v1            409
-#define OBJ_X9_62_prime192v1            OBJ_X9_62_primeCurve,1L
+#define SN_X9_62_prime192v1 "prime192v1"
+#define NID_X9_62_prime192v1 409
+#define OBJ_X9_62_prime192v1 OBJ_X9_62_primeCurve, 1L
 
-#define SN_X9_62_prime192v2             "prime192v2"
-#define NID_X9_62_prime192v2            410
-#define OBJ_X9_62_prime192v2            OBJ_X9_62_primeCurve,2L
+#define SN_X9_62_prime192v2 "prime192v2"
+#define NID_X9_62_prime192v2 410
+#define OBJ_X9_62_prime192v2 OBJ_X9_62_primeCurve, 2L
 
-#define SN_X9_62_prime192v3             "prime192v3"
-#define NID_X9_62_prime192v3            411
-#define OBJ_X9_62_prime192v3            OBJ_X9_62_primeCurve,3L
+#define SN_X9_62_prime192v3 "prime192v3"
+#define NID_X9_62_prime192v3 411
+#define OBJ_X9_62_prime192v3 OBJ_X9_62_primeCurve, 3L
 
-#define SN_X9_62_prime239v1             "prime239v1"
-#define NID_X9_62_prime239v1            412
-#define OBJ_X9_62_prime239v1            OBJ_X9_62_primeCurve,4L
+#define SN_X9_62_prime239v1 "prime239v1"
+#define NID_X9_62_prime239v1 412
+#define OBJ_X9_62_prime239v1 OBJ_X9_62_primeCurve, 4L
 
-#define SN_X9_62_prime239v2             "prime239v2"
-#define NID_X9_62_prime239v2            413
-#define OBJ_X9_62_prime239v2            OBJ_X9_62_primeCurve,5L
+#define SN_X9_62_prime239v2 "prime239v2"
+#define NID_X9_62_prime239v2 413
+#define OBJ_X9_62_prime239v2 OBJ_X9_62_primeCurve, 5L
 
-#define SN_X9_62_prime239v3             "prime239v3"
-#define NID_X9_62_prime239v3            414
-#define OBJ_X9_62_prime239v3            OBJ_X9_62_primeCurve,6L
+#define SN_X9_62_prime239v3 "prime239v3"
+#define NID_X9_62_prime239v3 414
+#define OBJ_X9_62_prime239v3 OBJ_X9_62_primeCurve, 6L
 
-#define SN_X9_62_prime256v1             "prime256v1"
-#define NID_X9_62_prime256v1            415
-#define OBJ_X9_62_prime256v1            OBJ_X9_62_primeCurve,7L
+#define SN_X9_62_prime256v1 "prime256v1"
+#define NID_X9_62_prime256v1 415
+#define OBJ_X9_62_prime256v1 OBJ_X9_62_primeCurve, 7L
 
-#define OBJ_X9_62_id_ecSigType          OBJ_ansi_X9_62,4L
+#define OBJ_X9_62_id_ecSigType OBJ_ansi_X9_62, 4L
 
-#define SN_ecdsa_with_SHA1              "ecdsa-with-SHA1"
-#define NID_ecdsa_with_SHA1             416
-#define OBJ_ecdsa_with_SHA1             OBJ_X9_62_id_ecSigType,1L
+#define SN_ecdsa_with_SHA1 "ecdsa-with-SHA1"
+#define NID_ecdsa_with_SHA1 416
+#define OBJ_ecdsa_with_SHA1 OBJ_X9_62_id_ecSigType, 1L
 
-#define SN_ecdsa_with_Recommended               "ecdsa-with-Recommended"
-#define NID_ecdsa_with_Recommended              791
-#define OBJ_ecdsa_with_Recommended              OBJ_X9_62_id_ecSigType,2L
+#define SN_ecdsa_with_Recommended "ecdsa-with-Recommended"
+#define NID_ecdsa_with_Recommended 791
+#define OBJ_ecdsa_with_Recommended OBJ_X9_62_id_ecSigType, 2L
 
-#define SN_ecdsa_with_Specified         "ecdsa-with-Specified"
-#define NID_ecdsa_with_Specified                792
-#define OBJ_ecdsa_with_Specified                OBJ_X9_62_id_ecSigType,3L
+#define SN_ecdsa_with_Specified "ecdsa-with-Specified"
+#define NID_ecdsa_with_Specified 792
+#define OBJ_ecdsa_with_Specified OBJ_X9_62_id_ecSigType, 3L
 
-#define SN_ecdsa_with_SHA224            "ecdsa-with-SHA224"
-#define NID_ecdsa_with_SHA224           793
-#define OBJ_ecdsa_with_SHA224           OBJ_ecdsa_with_Specified,1L
+#define SN_ecdsa_with_SHA224 "ecdsa-with-SHA224"
+#define NID_ecdsa_with_SHA224 793
+#define OBJ_ecdsa_with_SHA224 OBJ_ecdsa_with_Specified, 1L
 
-#define SN_ecdsa_with_SHA256            "ecdsa-with-SHA256"
-#define NID_ecdsa_with_SHA256           794
-#define OBJ_ecdsa_with_SHA256           OBJ_ecdsa_with_Specified,2L
+#define SN_ecdsa_with_SHA256 "ecdsa-with-SHA256"
+#define NID_ecdsa_with_SHA256 794
+#define OBJ_ecdsa_with_SHA256 OBJ_ecdsa_with_Specified, 2L
 
-#define SN_ecdsa_with_SHA384            "ecdsa-with-SHA384"
-#define NID_ecdsa_with_SHA384           795
-#define OBJ_ecdsa_with_SHA384           OBJ_ecdsa_with_Specified,3L
+#define SN_ecdsa_with_SHA384 "ecdsa-with-SHA384"
+#define NID_ecdsa_with_SHA384 795
+#define OBJ_ecdsa_with_SHA384 OBJ_ecdsa_with_Specified, 3L
 
-#define SN_ecdsa_with_SHA512            "ecdsa-with-SHA512"
-#define NID_ecdsa_with_SHA512           796
-#define OBJ_ecdsa_with_SHA512           OBJ_ecdsa_with_Specified,4L
+#define SN_ecdsa_with_SHA512 "ecdsa-with-SHA512"
+#define NID_ecdsa_with_SHA512 796
+#define OBJ_ecdsa_with_SHA512 OBJ_ecdsa_with_Specified, 4L
 
-#define OBJ_secg_ellipticCurve          OBJ_certicom_arc,0L
+#define OBJ_secg_ellipticCurve OBJ_certicom_arc, 0L
 
-#define SN_secp112r1            "secp112r1"
-#define NID_secp112r1           704
-#define OBJ_secp112r1           OBJ_secg_ellipticCurve,6L
+#define SN_secp112r1 "secp112r1"
+#define NID_secp112r1 704
+#define OBJ_secp112r1 OBJ_secg_ellipticCurve, 6L
 
-#define SN_secp112r2            "secp112r2"
-#define NID_secp112r2           705
-#define OBJ_secp112r2           OBJ_secg_ellipticCurve,7L
+#define SN_secp112r2 "secp112r2"
+#define NID_secp112r2 705
+#define OBJ_secp112r2 OBJ_secg_ellipticCurve, 7L
 
-#define SN_secp128r1            "secp128r1"
-#define NID_secp128r1           706
-#define OBJ_secp128r1           OBJ_secg_ellipticCurve,28L
+#define SN_secp128r1 "secp128r1"
+#define NID_secp128r1 706
+#define OBJ_secp128r1 OBJ_secg_ellipticCurve, 28L
 
-#define SN_secp128r2            "secp128r2"
-#define NID_secp128r2           707
-#define OBJ_secp128r2           OBJ_secg_ellipticCurve,29L
+#define SN_secp128r2 "secp128r2"
+#define NID_secp128r2 707
+#define OBJ_secp128r2 OBJ_secg_ellipticCurve, 29L
 
-#define SN_secp160k1            "secp160k1"
-#define NID_secp160k1           708
-#define OBJ_secp160k1           OBJ_secg_ellipticCurve,9L
+#define SN_secp160k1 "secp160k1"
+#define NID_secp160k1 708
+#define OBJ_secp160k1 OBJ_secg_ellipticCurve, 9L
 
-#define SN_secp160r1            "secp160r1"
-#define NID_secp160r1           709
-#define OBJ_secp160r1           OBJ_secg_ellipticCurve,8L
+#define SN_secp160r1 "secp160r1"
+#define NID_secp160r1 709
+#define OBJ_secp160r1 OBJ_secg_ellipticCurve, 8L
 
-#define SN_secp160r2            "secp160r2"
-#define NID_secp160r2           710
-#define OBJ_secp160r2           OBJ_secg_ellipticCurve,30L
+#define SN_secp160r2 "secp160r2"
+#define NID_secp160r2 710
+#define OBJ_secp160r2 OBJ_secg_ellipticCurve, 30L
 
-#define SN_secp192k1            "secp192k1"
-#define NID_secp192k1           711
-#define OBJ_secp192k1           OBJ_secg_ellipticCurve,31L
+#define SN_secp192k1 "secp192k1"
+#define NID_secp192k1 711
+#define OBJ_secp192k1 OBJ_secg_ellipticCurve, 31L
 
-#define SN_secp224k1            "secp224k1"
-#define NID_secp224k1           712
-#define OBJ_secp224k1           OBJ_secg_ellipticCurve,32L
+#define SN_secp224k1 "secp224k1"
+#define NID_secp224k1 712
+#define OBJ_secp224k1 OBJ_secg_ellipticCurve, 32L
 
-#define SN_secp224r1            "secp224r1"
-#define NID_secp224r1           713
-#define OBJ_secp224r1           OBJ_secg_ellipticCurve,33L
+#define SN_secp224r1 "secp224r1"
+#define NID_secp224r1 713
+#define OBJ_secp224r1 OBJ_secg_ellipticCurve, 33L
 
-#define SN_secp256k1            "secp256k1"
-#define NID_secp256k1           714
-#define OBJ_secp256k1           OBJ_secg_ellipticCurve,10L
+#define SN_secp256k1 "secp256k1"
+#define NID_secp256k1 714
+#define OBJ_secp256k1 OBJ_secg_ellipticCurve, 10L
 
-#define SN_secp384r1            "secp384r1"
-#define NID_secp384r1           715
-#define OBJ_secp384r1           OBJ_secg_ellipticCurve,34L
+#define SN_secp384r1 "secp384r1"
+#define NID_secp384r1 715
+#define OBJ_secp384r1 OBJ_secg_ellipticCurve, 34L
 
-#define SN_secp521r1            "secp521r1"
-#define NID_secp521r1           716
-#define OBJ_secp521r1           OBJ_secg_ellipticCurve,35L
+#define SN_secp521r1 "secp521r1"
+#define NID_secp521r1 716
+#define OBJ_secp521r1 OBJ_secg_ellipticCurve, 35L
 
-#define SN_sect113r1            "sect113r1"
-#define NID_sect113r1           717
-#define OBJ_sect113r1           OBJ_secg_ellipticCurve,4L
+#define SN_sect113r1 "sect113r1"
+#define NID_sect113r1 717
+#define OBJ_sect113r1 OBJ_secg_ellipticCurve, 4L
 
-#define SN_sect113r2            "sect113r2"
-#define NID_sect113r2           718
-#define OBJ_sect113r2           OBJ_secg_ellipticCurve,5L
+#define SN_sect113r2 "sect113r2"
+#define NID_sect113r2 718
+#define OBJ_sect113r2 OBJ_secg_ellipticCurve, 5L
 
-#define SN_sect131r1            "sect131r1"
-#define NID_sect131r1           719
-#define OBJ_sect131r1           OBJ_secg_ellipticCurve,22L
+#define SN_sect131r1 "sect131r1"
+#define NID_sect131r1 719
+#define OBJ_sect131r1 OBJ_secg_ellipticCurve, 22L
 
-#define SN_sect131r2            "sect131r2"
-#define NID_sect131r2           720
-#define OBJ_sect131r2           OBJ_secg_ellipticCurve,23L
+#define SN_sect131r2 "sect131r2"
+#define NID_sect131r2 720
+#define OBJ_sect131r2 OBJ_secg_ellipticCurve, 23L
 
-#define SN_sect163k1            "sect163k1"
-#define NID_sect163k1           721
-#define OBJ_sect163k1           OBJ_secg_ellipticCurve,1L
+#define SN_sect163k1 "sect163k1"
+#define NID_sect163k1 721
+#define OBJ_sect163k1 OBJ_secg_ellipticCurve, 1L
 
-#define SN_sect163r1            "sect163r1"
-#define NID_sect163r1           722
-#define OBJ_sect163r1           OBJ_secg_ellipticCurve,2L
+#define SN_sect163r1 "sect163r1"
+#define NID_sect163r1 722
+#define OBJ_sect163r1 OBJ_secg_ellipticCurve, 2L
 
-#define SN_sect163r2            "sect163r2"
-#define NID_sect163r2           723
-#define OBJ_sect163r2           OBJ_secg_ellipticCurve,15L
+#define SN_sect163r2 "sect163r2"
+#define NID_sect163r2 723
+#define OBJ_sect163r2 OBJ_secg_ellipticCurve, 15L
 
-#define SN_sect193r1            "sect193r1"
-#define NID_sect193r1           724
-#define OBJ_sect193r1           OBJ_secg_ellipticCurve,24L
+#define SN_sect193r1 "sect193r1"
+#define NID_sect193r1 724
+#define OBJ_sect193r1 OBJ_secg_ellipticCurve, 24L
 
-#define SN_sect193r2            "sect193r2"
-#define NID_sect193r2           725
-#define OBJ_sect193r2           OBJ_secg_ellipticCurve,25L
+#define SN_sect193r2 "sect193r2"
+#define NID_sect193r2 725
+#define OBJ_sect193r2 OBJ_secg_ellipticCurve, 25L
 
-#define SN_sect233k1            "sect233k1"
-#define NID_sect233k1           726
-#define OBJ_sect233k1           OBJ_secg_ellipticCurve,26L
+#define SN_sect233k1 "sect233k1"
+#define NID_sect233k1 726
+#define OBJ_sect233k1 OBJ_secg_ellipticCurve, 26L
 
-#define SN_sect233r1            "sect233r1"
-#define NID_sect233r1           727
-#define OBJ_sect233r1           OBJ_secg_ellipticCurve,27L
+#define SN_sect233r1 "sect233r1"
+#define NID_sect233r1 727
+#define OBJ_sect233r1 OBJ_secg_ellipticCurve, 27L
 
-#define SN_sect239k1            "sect239k1"
-#define NID_sect239k1           728
-#define OBJ_sect239k1           OBJ_secg_ellipticCurve,3L
+#define SN_sect239k1 "sect239k1"
+#define NID_sect239k1 728
+#define OBJ_sect239k1 OBJ_secg_ellipticCurve, 3L
 
-#define SN_sect283k1            "sect283k1"
-#define NID_sect283k1           729
-#define OBJ_sect283k1           OBJ_secg_ellipticCurve,16L
+#define SN_sect283k1 "sect283k1"
+#define NID_sect283k1 729
+#define OBJ_sect283k1 OBJ_secg_ellipticCurve, 16L
 
-#define SN_sect283r1            "sect283r1"
-#define NID_sect283r1           730
-#define OBJ_sect283r1           OBJ_secg_ellipticCurve,17L
+#define SN_sect283r1 "sect283r1"
+#define NID_sect283r1 730
+#define OBJ_sect283r1 OBJ_secg_ellipticCurve, 17L
 
-#define SN_sect409k1            "sect409k1"
-#define NID_sect409k1           731
-#define OBJ_sect409k1           OBJ_secg_ellipticCurve,36L
+#define SN_sect409k1 "sect409k1"
+#define NID_sect409k1 731
+#define OBJ_sect409k1 OBJ_secg_ellipticCurve, 36L
 
-#define SN_sect409r1            "sect409r1"
-#define NID_sect409r1           732
-#define OBJ_sect409r1           OBJ_secg_ellipticCurve,37L
+#define SN_sect409r1 "sect409r1"
+#define NID_sect409r1 732
+#define OBJ_sect409r1 OBJ_secg_ellipticCurve, 37L
 
-#define SN_sect571k1            "sect571k1"
-#define NID_sect571k1           733
-#define OBJ_sect571k1           OBJ_secg_ellipticCurve,38L
+#define SN_sect571k1 "sect571k1"
+#define NID_sect571k1 733
+#define OBJ_sect571k1 OBJ_secg_ellipticCurve, 38L
 
-#define SN_sect571r1            "sect571r1"
-#define NID_sect571r1           734
-#define OBJ_sect571r1           OBJ_secg_ellipticCurve,39L
+#define SN_sect571r1 "sect571r1"
+#define NID_sect571r1 734
+#define OBJ_sect571r1 OBJ_secg_ellipticCurve, 39L
 
-#define OBJ_wap_wsg_idm_ecid            OBJ_wap_wsg,4L
-
-#define SN_wap_wsg_idm_ecid_wtls1               "wap-wsg-idm-ecid-wtls1"
-#define NID_wap_wsg_idm_ecid_wtls1              735
-#define OBJ_wap_wsg_idm_ecid_wtls1              OBJ_wap_wsg_idm_ecid,1L
-
-#define SN_wap_wsg_idm_ecid_wtls3               "wap-wsg-idm-ecid-wtls3"
-#define NID_wap_wsg_idm_ecid_wtls3              736
-#define OBJ_wap_wsg_idm_ecid_wtls3              OBJ_wap_wsg_idm_ecid,3L
-
-#define SN_wap_wsg_idm_ecid_wtls4               "wap-wsg-idm-ecid-wtls4"
-#define NID_wap_wsg_idm_ecid_wtls4              737
-#define OBJ_wap_wsg_idm_ecid_wtls4              OBJ_wap_wsg_idm_ecid,4L
-
-#define SN_wap_wsg_idm_ecid_wtls5               "wap-wsg-idm-ecid-wtls5"
-#define NID_wap_wsg_idm_ecid_wtls5              738
-#define OBJ_wap_wsg_idm_ecid_wtls5              OBJ_wap_wsg_idm_ecid,5L
-
-#define SN_wap_wsg_idm_ecid_wtls6               "wap-wsg-idm-ecid-wtls6"
-#define NID_wap_wsg_idm_ecid_wtls6              739
-#define OBJ_wap_wsg_idm_ecid_wtls6              OBJ_wap_wsg_idm_ecid,6L
-
-#define SN_wap_wsg_idm_ecid_wtls7               "wap-wsg-idm-ecid-wtls7"
-#define NID_wap_wsg_idm_ecid_wtls7              740
-#define OBJ_wap_wsg_idm_ecid_wtls7              OBJ_wap_wsg_idm_ecid,7L
-
-#define SN_wap_wsg_idm_ecid_wtls8               "wap-wsg-idm-ecid-wtls8"
-#define NID_wap_wsg_idm_ecid_wtls8              741
-#define OBJ_wap_wsg_idm_ecid_wtls8              OBJ_wap_wsg_idm_ecid,8L
-
-#define SN_wap_wsg_idm_ecid_wtls9               "wap-wsg-idm-ecid-wtls9"
-#define NID_wap_wsg_idm_ecid_wtls9              742
-#define OBJ_wap_wsg_idm_ecid_wtls9              OBJ_wap_wsg_idm_ecid,9L
-
-#define SN_wap_wsg_idm_ecid_wtls10              "wap-wsg-idm-ecid-wtls10"
-#define NID_wap_wsg_idm_ecid_wtls10             743
-#define OBJ_wap_wsg_idm_ecid_wtls10             OBJ_wap_wsg_idm_ecid,10L
-
-#define SN_wap_wsg_idm_ecid_wtls11              "wap-wsg-idm-ecid-wtls11"
-#define NID_wap_wsg_idm_ecid_wtls11             744
-#define OBJ_wap_wsg_idm_ecid_wtls11             OBJ_wap_wsg_idm_ecid,11L
-
-#define SN_wap_wsg_idm_ecid_wtls12              "wap-wsg-idm-ecid-wtls12"
-#define NID_wap_wsg_idm_ecid_wtls12             745
-#define OBJ_wap_wsg_idm_ecid_wtls12             OBJ_wap_wsg_idm_ecid,12L
-
-#define SN_cast5_cbc            "CAST5-CBC"
-#define LN_cast5_cbc            "cast5-cbc"
-#define NID_cast5_cbc           108
-#define OBJ_cast5_cbc           OBJ_ISO_US,113533L,7L,66L,10L
-
-#define SN_cast5_ecb            "CAST5-ECB"
-#define LN_cast5_ecb            "cast5-ecb"
-#define NID_cast5_ecb           109
-
-#define SN_cast5_cfb64          "CAST5-CFB"
-#define LN_cast5_cfb64          "cast5-cfb"
-#define NID_cast5_cfb64         110
-
-#define SN_cast5_ofb64          "CAST5-OFB"
-#define LN_cast5_ofb64          "cast5-ofb"
-#define NID_cast5_ofb64         111
-
-#define LN_pbeWithMD5AndCast5_CBC               "pbeWithMD5AndCast5CBC"
-#define NID_pbeWithMD5AndCast5_CBC              112
-#define OBJ_pbeWithMD5AndCast5_CBC              OBJ_ISO_US,113533L,7L,66L,12L
-
-#define SN_id_PasswordBasedMAC          "id-PasswordBasedMAC"
-#define LN_id_PasswordBasedMAC          "password based MAC"
-#define NID_id_PasswordBasedMAC         782
-#define OBJ_id_PasswordBasedMAC         OBJ_ISO_US,113533L,7L,66L,13L
-
-#define SN_id_DHBasedMac                "id-DHBasedMac"
-#define LN_id_DHBasedMac                "Diffie-Hellman based MAC"
-#define NID_id_DHBasedMac               783
-#define OBJ_id_DHBasedMac               OBJ_ISO_US,113533L,7L,66L,30L
-
-#define SN_rsadsi               "rsadsi"
-#define LN_rsadsi               "RSA Data Security, Inc."
-#define NID_rsadsi              1
-#define OBJ_rsadsi              OBJ_ISO_US,113549L
-
-#define SN_pkcs         "pkcs"
-#define LN_pkcs         "RSA Data Security, Inc. PKCS"
-#define NID_pkcs                2
-#define OBJ_pkcs                OBJ_rsadsi,1L
-
-#define SN_pkcs1                "pkcs1"
-#define NID_pkcs1               186
-#define OBJ_pkcs1               OBJ_pkcs,1L
-
-#define LN_rsaEncryption                "rsaEncryption"
-#define NID_rsaEncryption               6
-#define OBJ_rsaEncryption               OBJ_pkcs1,1L
-
-#define SN_md2WithRSAEncryption         "RSA-MD2"
-#define LN_md2WithRSAEncryption         "md2WithRSAEncryption"
-#define NID_md2WithRSAEncryption                7
-#define OBJ_md2WithRSAEncryption                OBJ_pkcs1,2L
-
-#define SN_md4WithRSAEncryption         "RSA-MD4"
-#define LN_md4WithRSAEncryption         "md4WithRSAEncryption"
-#define NID_md4WithRSAEncryption                396
-#define OBJ_md4WithRSAEncryption                OBJ_pkcs1,3L
-
-#define SN_md5WithRSAEncryption         "RSA-MD5"
-#define LN_md5WithRSAEncryption         "md5WithRSAEncryption"
-#define NID_md5WithRSAEncryption                8
-#define OBJ_md5WithRSAEncryption                OBJ_pkcs1,4L
-
-#define SN_sha1WithRSAEncryption                "RSA-SHA1"
-#define LN_sha1WithRSAEncryption                "sha1WithRSAEncryption"
-#define NID_sha1WithRSAEncryption               65
-#define OBJ_sha1WithRSAEncryption               OBJ_pkcs1,5L
-
-#define SN_rsaesOaep            "RSAES-OAEP"
-#define LN_rsaesOaep            "rsaesOaep"
-#define NID_rsaesOaep           919
-#define OBJ_rsaesOaep           OBJ_pkcs1,7L
-
-#define SN_mgf1         "MGF1"
-#define LN_mgf1         "mgf1"
-#define NID_mgf1                911
-#define OBJ_mgf1                OBJ_pkcs1,8L
-
-#define SN_pSpecified           "PSPECIFIED"
-#define LN_pSpecified           "pSpecified"
-#define NID_pSpecified          935
-#define OBJ_pSpecified          OBJ_pkcs1,9L
-
-#define SN_rsassaPss            "RSASSA-PSS"
-#define LN_rsassaPss            "rsassaPss"
-#define NID_rsassaPss           912
-#define OBJ_rsassaPss           OBJ_pkcs1,10L
-
-#define SN_sha256WithRSAEncryption              "RSA-SHA256"
-#define LN_sha256WithRSAEncryption              "sha256WithRSAEncryption"
-#define NID_sha256WithRSAEncryption             668
-#define OBJ_sha256WithRSAEncryption             OBJ_pkcs1,11L
-
-#define SN_sha384WithRSAEncryption              "RSA-SHA384"
-#define LN_sha384WithRSAEncryption              "sha384WithRSAEncryption"
-#define NID_sha384WithRSAEncryption             669
-#define OBJ_sha384WithRSAEncryption             OBJ_pkcs1,12L
-
-#define SN_sha512WithRSAEncryption              "RSA-SHA512"
-#define LN_sha512WithRSAEncryption              "sha512WithRSAEncryption"
-#define NID_sha512WithRSAEncryption             670
-#define OBJ_sha512WithRSAEncryption             OBJ_pkcs1,13L
-
-#define SN_sha224WithRSAEncryption              "RSA-SHA224"
-#define LN_sha224WithRSAEncryption              "sha224WithRSAEncryption"
-#define NID_sha224WithRSAEncryption             671
-#define OBJ_sha224WithRSAEncryption             OBJ_pkcs1,14L
-
-#define SN_sha512_224WithRSAEncryption          "RSA-SHA512/224"
-#define LN_sha512_224WithRSAEncryption          "sha512-224WithRSAEncryption"
-#define NID_sha512_224WithRSAEncryption         1145
-#define OBJ_sha512_224WithRSAEncryption         OBJ_pkcs1,15L
-
-#define SN_sha512_256WithRSAEncryption          "RSA-SHA512/256"
-#define LN_sha512_256WithRSAEncryption          "sha512-256WithRSAEncryption"
-#define NID_sha512_256WithRSAEncryption         1146
-#define OBJ_sha512_256WithRSAEncryption         OBJ_pkcs1,16L
-
-#define SN_pkcs3                "pkcs3"
-#define NID_pkcs3               27
-#define OBJ_pkcs3               OBJ_pkcs,3L
-
-#define LN_dhKeyAgreement               "dhKeyAgreement"
-#define NID_dhKeyAgreement              28
-#define OBJ_dhKeyAgreement              OBJ_pkcs3,1L
-
-#define SN_pkcs5                "pkcs5"
-#define NID_pkcs5               187
-#define OBJ_pkcs5               OBJ_pkcs,5L
-
-#define SN_pbeWithMD2AndDES_CBC         "PBE-MD2-DES"
-#define LN_pbeWithMD2AndDES_CBC         "pbeWithMD2AndDES-CBC"
-#define NID_pbeWithMD2AndDES_CBC                9
-#define OBJ_pbeWithMD2AndDES_CBC                OBJ_pkcs5,1L
-
-#define SN_pbeWithMD5AndDES_CBC         "PBE-MD5-DES"
-#define LN_pbeWithMD5AndDES_CBC         "pbeWithMD5AndDES-CBC"
-#define NID_pbeWithMD5AndDES_CBC                10
-#define OBJ_pbeWithMD5AndDES_CBC                OBJ_pkcs5,3L
-
-#define SN_pbeWithMD2AndRC2_CBC         "PBE-MD2-RC2-64"
-#define LN_pbeWithMD2AndRC2_CBC         "pbeWithMD2AndRC2-CBC"
-#define NID_pbeWithMD2AndRC2_CBC                168
-#define OBJ_pbeWithMD2AndRC2_CBC                OBJ_pkcs5,4L
-
-#define SN_pbeWithMD5AndRC2_CBC         "PBE-MD5-RC2-64"
-#define LN_pbeWithMD5AndRC2_CBC         "pbeWithMD5AndRC2-CBC"
-#define NID_pbeWithMD5AndRC2_CBC                169
-#define OBJ_pbeWithMD5AndRC2_CBC                OBJ_pkcs5,6L
-
-#define SN_pbeWithSHA1AndDES_CBC                "PBE-SHA1-DES"
-#define LN_pbeWithSHA1AndDES_CBC                "pbeWithSHA1AndDES-CBC"
-#define NID_pbeWithSHA1AndDES_CBC               170
-#define OBJ_pbeWithSHA1AndDES_CBC               OBJ_pkcs5,10L
-
-#define SN_pbeWithSHA1AndRC2_CBC                "PBE-SHA1-RC2-64"
-#define LN_pbeWithSHA1AndRC2_CBC                "pbeWithSHA1AndRC2-CBC"
-#define NID_pbeWithSHA1AndRC2_CBC               68
-#define OBJ_pbeWithSHA1AndRC2_CBC               OBJ_pkcs5,11L
-
-#define LN_id_pbkdf2            "PBKDF2"
-#define NID_id_pbkdf2           69
-#define OBJ_id_pbkdf2           OBJ_pkcs5,12L
-
-#define LN_pbes2                "PBES2"
-#define NID_pbes2               161
-#define OBJ_pbes2               OBJ_pkcs5,13L
-
-#define LN_pbmac1               "PBMAC1"
-#define NID_pbmac1              162
-#define OBJ_pbmac1              OBJ_pkcs5,14L
-
-#define SN_pkcs7                "pkcs7"
-#define NID_pkcs7               20
-#define OBJ_pkcs7               OBJ_pkcs,7L
-
-#define LN_pkcs7_data           "pkcs7-data"
-#define NID_pkcs7_data          21
-#define OBJ_pkcs7_data          OBJ_pkcs7,1L
-
-#define LN_pkcs7_signed         "pkcs7-signedData"
-#define NID_pkcs7_signed                22
-#define OBJ_pkcs7_signed                OBJ_pkcs7,2L
-
-#define LN_pkcs7_enveloped              "pkcs7-envelopedData"
-#define NID_pkcs7_enveloped             23
-#define OBJ_pkcs7_enveloped             OBJ_pkcs7,3L
-
-#define LN_pkcs7_signedAndEnveloped             "pkcs7-signedAndEnvelopedData"
-#define NID_pkcs7_signedAndEnveloped            24
-#define OBJ_pkcs7_signedAndEnveloped            OBJ_pkcs7,4L
-
-#define LN_pkcs7_digest         "pkcs7-digestData"
-#define NID_pkcs7_digest                25
-#define OBJ_pkcs7_digest                OBJ_pkcs7,5L
-
-#define LN_pkcs7_encrypted              "pkcs7-encryptedData"
-#define NID_pkcs7_encrypted             26
-#define OBJ_pkcs7_encrypted             OBJ_pkcs7,6L
-
-#define SN_pkcs9                "pkcs9"
-#define NID_pkcs9               47
-#define OBJ_pkcs9               OBJ_pkcs,9L
-
-#define LN_pkcs9_emailAddress           "emailAddress"
-#define NID_pkcs9_emailAddress          48
-#define OBJ_pkcs9_emailAddress          OBJ_pkcs9,1L
-
-#define LN_pkcs9_unstructuredName               "unstructuredName"
-#define NID_pkcs9_unstructuredName              49
-#define OBJ_pkcs9_unstructuredName              OBJ_pkcs9,2L
-
-#define LN_pkcs9_contentType            "contentType"
-#define NID_pkcs9_contentType           50
-#define OBJ_pkcs9_contentType           OBJ_pkcs9,3L
-
-#define LN_pkcs9_messageDigest          "messageDigest"
-#define NID_pkcs9_messageDigest         51
-#define OBJ_pkcs9_messageDigest         OBJ_pkcs9,4L
-
-#define LN_pkcs9_signingTime            "signingTime"
-#define NID_pkcs9_signingTime           52
-#define OBJ_pkcs9_signingTime           OBJ_pkcs9,5L
-
-#define LN_pkcs9_countersignature               "countersignature"
-#define NID_pkcs9_countersignature              53
-#define OBJ_pkcs9_countersignature              OBJ_pkcs9,6L
-
-#define LN_pkcs9_challengePassword              "challengePassword"
-#define NID_pkcs9_challengePassword             54
-#define OBJ_pkcs9_challengePassword             OBJ_pkcs9,7L
-
-#define LN_pkcs9_unstructuredAddress            "unstructuredAddress"
-#define NID_pkcs9_unstructuredAddress           55
-#define OBJ_pkcs9_unstructuredAddress           OBJ_pkcs9,8L
-
-#define LN_pkcs9_extCertAttributes              "extendedCertificateAttributes"
-#define NID_pkcs9_extCertAttributes             56
-#define OBJ_pkcs9_extCertAttributes             OBJ_pkcs9,9L
-
-#define SN_ext_req              "extReq"
-#define LN_ext_req              "Extension Request"
-#define NID_ext_req             172
-#define OBJ_ext_req             OBJ_pkcs9,14L
-
-#define SN_SMIMECapabilities            "SMIME-CAPS"
-#define LN_SMIMECapabilities            "S/MIME Capabilities"
-#define NID_SMIMECapabilities           167
-#define OBJ_SMIMECapabilities           OBJ_pkcs9,15L
-
-#define SN_SMIME                "SMIME"
-#define LN_SMIME                "S/MIME"
-#define NID_SMIME               188
-#define OBJ_SMIME               OBJ_pkcs9,16L
+#define OBJ_wap_wsg_idm_ecid OBJ_wap_wsg, 4L
+
+#define SN_wap_wsg_idm_ecid_wtls1 "wap-wsg-idm-ecid-wtls1"
+#define NID_wap_wsg_idm_ecid_wtls1 735
+#define OBJ_wap_wsg_idm_ecid_wtls1 OBJ_wap_wsg_idm_ecid, 1L
+
+#define SN_wap_wsg_idm_ecid_wtls3 "wap-wsg-idm-ecid-wtls3"
+#define NID_wap_wsg_idm_ecid_wtls3 736
+#define OBJ_wap_wsg_idm_ecid_wtls3 OBJ_wap_wsg_idm_ecid, 3L
+
+#define SN_wap_wsg_idm_ecid_wtls4 "wap-wsg-idm-ecid-wtls4"
+#define NID_wap_wsg_idm_ecid_wtls4 737
+#define OBJ_wap_wsg_idm_ecid_wtls4 OBJ_wap_wsg_idm_ecid, 4L
+
+#define SN_wap_wsg_idm_ecid_wtls5 "wap-wsg-idm-ecid-wtls5"
+#define NID_wap_wsg_idm_ecid_wtls5 738
+#define OBJ_wap_wsg_idm_ecid_wtls5 OBJ_wap_wsg_idm_ecid, 5L
+
+#define SN_wap_wsg_idm_ecid_wtls6 "wap-wsg-idm-ecid-wtls6"
+#define NID_wap_wsg_idm_ecid_wtls6 739
+#define OBJ_wap_wsg_idm_ecid_wtls6 OBJ_wap_wsg_idm_ecid, 6L
+
+#define SN_wap_wsg_idm_ecid_wtls7 "wap-wsg-idm-ecid-wtls7"
+#define NID_wap_wsg_idm_ecid_wtls7 740
+#define OBJ_wap_wsg_idm_ecid_wtls7 OBJ_wap_wsg_idm_ecid, 7L
+
+#define SN_wap_wsg_idm_ecid_wtls8 "wap-wsg-idm-ecid-wtls8"
+#define NID_wap_wsg_idm_ecid_wtls8 741
+#define OBJ_wap_wsg_idm_ecid_wtls8 OBJ_wap_wsg_idm_ecid, 8L
+
+#define SN_wap_wsg_idm_ecid_wtls9 "wap-wsg-idm-ecid-wtls9"
+#define NID_wap_wsg_idm_ecid_wtls9 742
+#define OBJ_wap_wsg_idm_ecid_wtls9 OBJ_wap_wsg_idm_ecid, 9L
+
+#define SN_wap_wsg_idm_ecid_wtls10 "wap-wsg-idm-ecid-wtls10"
+#define NID_wap_wsg_idm_ecid_wtls10 743
+#define OBJ_wap_wsg_idm_ecid_wtls10 OBJ_wap_wsg_idm_ecid, 10L
+
+#define SN_wap_wsg_idm_ecid_wtls11 "wap-wsg-idm-ecid-wtls11"
+#define NID_wap_wsg_idm_ecid_wtls11 744
+#define OBJ_wap_wsg_idm_ecid_wtls11 OBJ_wap_wsg_idm_ecid, 11L
+
+#define SN_wap_wsg_idm_ecid_wtls12 "wap-wsg-idm-ecid-wtls12"
+#define NID_wap_wsg_idm_ecid_wtls12 745
+#define OBJ_wap_wsg_idm_ecid_wtls12 OBJ_wap_wsg_idm_ecid, 12L
+
+#define SN_cast5_cbc "CAST5-CBC"
+#define LN_cast5_cbc "cast5-cbc"
+#define NID_cast5_cbc 108
+#define OBJ_cast5_cbc OBJ_ISO_US, 113533L, 7L, 66L, 10L
+
+#define SN_cast5_ecb "CAST5-ECB"
+#define LN_cast5_ecb "cast5-ecb"
+#define NID_cast5_ecb 109
+
+#define SN_cast5_cfb64 "CAST5-CFB"
+#define LN_cast5_cfb64 "cast5-cfb"
+#define NID_cast5_cfb64 110
+
+#define SN_cast5_ofb64 "CAST5-OFB"
+#define LN_cast5_ofb64 "cast5-ofb"
+#define NID_cast5_ofb64 111
+
+#define LN_pbeWithMD5AndCast5_CBC "pbeWithMD5AndCast5CBC"
+#define NID_pbeWithMD5AndCast5_CBC 112
+#define OBJ_pbeWithMD5AndCast5_CBC OBJ_ISO_US, 113533L, 7L, 66L, 12L
+
+#define SN_id_PasswordBasedMAC "id-PasswordBasedMAC"
+#define LN_id_PasswordBasedMAC "password based MAC"
+#define NID_id_PasswordBasedMAC 782
+#define OBJ_id_PasswordBasedMAC OBJ_ISO_US, 113533L, 7L, 66L, 13L
+
+#define SN_id_DHBasedMac "id-DHBasedMac"
+#define LN_id_DHBasedMac "Diffie-Hellman based MAC"
+#define NID_id_DHBasedMac 783
+#define OBJ_id_DHBasedMac OBJ_ISO_US, 113533L, 7L, 66L, 30L
+
+#define SN_rsadsi "rsadsi"
+#define LN_rsadsi "RSA Data Security, Inc."
+#define NID_rsadsi 1
+#define OBJ_rsadsi OBJ_ISO_US, 113549L
+
+#define SN_pkcs "pkcs"
+#define LN_pkcs "RSA Data Security, Inc. PKCS"
+#define NID_pkcs 2
+#define OBJ_pkcs OBJ_rsadsi, 1L
+
+#define SN_pkcs1 "pkcs1"
+#define NID_pkcs1 186
+#define OBJ_pkcs1 OBJ_pkcs, 1L
+
+#define LN_rsaEncryption "rsaEncryption"
+#define NID_rsaEncryption 6
+#define OBJ_rsaEncryption OBJ_pkcs1, 1L
+
+#define SN_md2WithRSAEncryption "RSA-MD2"
+#define LN_md2WithRSAEncryption "md2WithRSAEncryption"
+#define NID_md2WithRSAEncryption 7
+#define OBJ_md2WithRSAEncryption OBJ_pkcs1, 2L
+
+#define SN_md4WithRSAEncryption "RSA-MD4"
+#define LN_md4WithRSAEncryption "md4WithRSAEncryption"
+#define NID_md4WithRSAEncryption 396
+#define OBJ_md4WithRSAEncryption OBJ_pkcs1, 3L
+
+#define SN_md5WithRSAEncryption "RSA-MD5"
+#define LN_md5WithRSAEncryption "md5WithRSAEncryption"
+#define NID_md5WithRSAEncryption 8
+#define OBJ_md5WithRSAEncryption OBJ_pkcs1, 4L
+
+#define SN_sha1WithRSAEncryption "RSA-SHA1"
+#define LN_sha1WithRSAEncryption "sha1WithRSAEncryption"
+#define NID_sha1WithRSAEncryption 65
+#define OBJ_sha1WithRSAEncryption OBJ_pkcs1, 5L
+
+#define SN_rsaesOaep "RSAES-OAEP"
+#define LN_rsaesOaep "rsaesOaep"
+#define NID_rsaesOaep 919
+#define OBJ_rsaesOaep OBJ_pkcs1, 7L
+
+#define SN_mgf1 "MGF1"
+#define LN_mgf1 "mgf1"
+#define NID_mgf1 911
+#define OBJ_mgf1 OBJ_pkcs1, 8L
+
+#define SN_pSpecified "PSPECIFIED"
+#define LN_pSpecified "pSpecified"
+#define NID_pSpecified 935
+#define OBJ_pSpecified OBJ_pkcs1, 9L
+
+#define SN_rsassaPss "RSASSA-PSS"
+#define LN_rsassaPss "rsassaPss"
+#define NID_rsassaPss 912
+#define OBJ_rsassaPss OBJ_pkcs1, 10L
+
+#define SN_sha256WithRSAEncryption "RSA-SHA256"
+#define LN_sha256WithRSAEncryption "sha256WithRSAEncryption"
+#define NID_sha256WithRSAEncryption 668
+#define OBJ_sha256WithRSAEncryption OBJ_pkcs1, 11L
+
+#define SN_sha384WithRSAEncryption "RSA-SHA384"
+#define LN_sha384WithRSAEncryption "sha384WithRSAEncryption"
+#define NID_sha384WithRSAEncryption 669
+#define OBJ_sha384WithRSAEncryption OBJ_pkcs1, 12L
+
+#define SN_sha512WithRSAEncryption "RSA-SHA512"
+#define LN_sha512WithRSAEncryption "sha512WithRSAEncryption"
+#define NID_sha512WithRSAEncryption 670
+#define OBJ_sha512WithRSAEncryption OBJ_pkcs1, 13L
+
+#define SN_sha224WithRSAEncryption "RSA-SHA224"
+#define LN_sha224WithRSAEncryption "sha224WithRSAEncryption"
+#define NID_sha224WithRSAEncryption 671
+#define OBJ_sha224WithRSAEncryption OBJ_pkcs1, 14L
+
+#define SN_sha512_224WithRSAEncryption "RSA-SHA512/224"
+#define LN_sha512_224WithRSAEncryption "sha512-224WithRSAEncryption"
+#define NID_sha512_224WithRSAEncryption 1145
+#define OBJ_sha512_224WithRSAEncryption OBJ_pkcs1, 15L
+
+#define SN_sha512_256WithRSAEncryption "RSA-SHA512/256"
+#define LN_sha512_256WithRSAEncryption "sha512-256WithRSAEncryption"
+#define NID_sha512_256WithRSAEncryption 1146
+#define OBJ_sha512_256WithRSAEncryption OBJ_pkcs1, 16L
+
+#define SN_pkcs3 "pkcs3"
+#define NID_pkcs3 27
+#define OBJ_pkcs3 OBJ_pkcs, 3L
+
+#define LN_dhKeyAgreement "dhKeyAgreement"
+#define NID_dhKeyAgreement 28
+#define OBJ_dhKeyAgreement OBJ_pkcs3, 1L
+
+#define SN_pkcs5 "pkcs5"
+#define NID_pkcs5 187
+#define OBJ_pkcs5 OBJ_pkcs, 5L
+
+#define SN_pbeWithMD2AndDES_CBC "PBE-MD2-DES"
+#define LN_pbeWithMD2AndDES_CBC "pbeWithMD2AndDES-CBC"
+#define NID_pbeWithMD2AndDES_CBC 9
+#define OBJ_pbeWithMD2AndDES_CBC OBJ_pkcs5, 1L
+
+#define SN_pbeWithMD5AndDES_CBC "PBE-MD5-DES"
+#define LN_pbeWithMD5AndDES_CBC "pbeWithMD5AndDES-CBC"
+#define NID_pbeWithMD5AndDES_CBC 10
+#define OBJ_pbeWithMD5AndDES_CBC OBJ_pkcs5, 3L
+
+#define SN_pbeWithMD2AndRC2_CBC "PBE-MD2-RC2-64"
+#define LN_pbeWithMD2AndRC2_CBC "pbeWithMD2AndRC2-CBC"
+#define NID_pbeWithMD2AndRC2_CBC 168
+#define OBJ_pbeWithMD2AndRC2_CBC OBJ_pkcs5, 4L
+
+#define SN_pbeWithMD5AndRC2_CBC "PBE-MD5-RC2-64"
+#define LN_pbeWithMD5AndRC2_CBC "pbeWithMD5AndRC2-CBC"
+#define NID_pbeWithMD5AndRC2_CBC 169
+#define OBJ_pbeWithMD5AndRC2_CBC OBJ_pkcs5, 6L
+
+#define SN_pbeWithSHA1AndDES_CBC "PBE-SHA1-DES"
+#define LN_pbeWithSHA1AndDES_CBC "pbeWithSHA1AndDES-CBC"
+#define NID_pbeWithSHA1AndDES_CBC 170
+#define OBJ_pbeWithSHA1AndDES_CBC OBJ_pkcs5, 10L
+
+#define SN_pbeWithSHA1AndRC2_CBC "PBE-SHA1-RC2-64"
+#define LN_pbeWithSHA1AndRC2_CBC "pbeWithSHA1AndRC2-CBC"
+#define NID_pbeWithSHA1AndRC2_CBC 68
+#define OBJ_pbeWithSHA1AndRC2_CBC OBJ_pkcs5, 11L
+
+#define LN_id_pbkdf2 "PBKDF2"
+#define NID_id_pbkdf2 69
+#define OBJ_id_pbkdf2 OBJ_pkcs5, 12L
+
+#define LN_pbes2 "PBES2"
+#define NID_pbes2 161
+#define OBJ_pbes2 OBJ_pkcs5, 13L
+
+#define LN_pbmac1 "PBMAC1"
+#define NID_pbmac1 162
+#define OBJ_pbmac1 OBJ_pkcs5, 14L
+
+#define SN_pkcs7 "pkcs7"
+#define NID_pkcs7 20
+#define OBJ_pkcs7 OBJ_pkcs, 7L
+
+#define LN_pkcs7_data "pkcs7-data"
+#define NID_pkcs7_data 21
+#define OBJ_pkcs7_data OBJ_pkcs7, 1L
+
+#define LN_pkcs7_signed "pkcs7-signedData"
+#define NID_pkcs7_signed 22
+#define OBJ_pkcs7_signed OBJ_pkcs7, 2L
+
+#define LN_pkcs7_enveloped "pkcs7-envelopedData"
+#define NID_pkcs7_enveloped 23
+#define OBJ_pkcs7_enveloped OBJ_pkcs7, 3L
+
+#define LN_pkcs7_signedAndEnveloped "pkcs7-signedAndEnvelopedData"
+#define NID_pkcs7_signedAndEnveloped 24
+#define OBJ_pkcs7_signedAndEnveloped OBJ_pkcs7, 4L
+
+#define LN_pkcs7_digest "pkcs7-digestData"
+#define NID_pkcs7_digest 25
+#define OBJ_pkcs7_digest OBJ_pkcs7, 5L
+
+#define LN_pkcs7_encrypted "pkcs7-encryptedData"
+#define NID_pkcs7_encrypted 26
+#define OBJ_pkcs7_encrypted OBJ_pkcs7, 6L
+
+#define SN_pkcs9 "pkcs9"
+#define NID_pkcs9 47
+#define OBJ_pkcs9 OBJ_pkcs, 9L
+
+#define LN_pkcs9_emailAddress "emailAddress"
+#define NID_pkcs9_emailAddress 48
+#define OBJ_pkcs9_emailAddress OBJ_pkcs9, 1L
+
+#define LN_pkcs9_unstructuredName "unstructuredName"
+#define NID_pkcs9_unstructuredName 49
+#define OBJ_pkcs9_unstructuredName OBJ_pkcs9, 2L
+
+#define LN_pkcs9_contentType "contentType"
+#define NID_pkcs9_contentType 50
+#define OBJ_pkcs9_contentType OBJ_pkcs9, 3L
+
+#define LN_pkcs9_messageDigest "messageDigest"
+#define NID_pkcs9_messageDigest 51
+#define OBJ_pkcs9_messageDigest OBJ_pkcs9, 4L
+
+#define LN_pkcs9_signingTime "signingTime"
+#define NID_pkcs9_signingTime 52
+#define OBJ_pkcs9_signingTime OBJ_pkcs9, 5L
+
+#define LN_pkcs9_countersignature "countersignature"
+#define NID_pkcs9_countersignature 53
+#define OBJ_pkcs9_countersignature OBJ_pkcs9, 6L
+
+#define LN_pkcs9_challengePassword "challengePassword"
+#define NID_pkcs9_challengePassword 54
+#define OBJ_pkcs9_challengePassword OBJ_pkcs9, 7L
+
+#define LN_pkcs9_unstructuredAddress "unstructuredAddress"
+#define NID_pkcs9_unstructuredAddress 55
+#define OBJ_pkcs9_unstructuredAddress OBJ_pkcs9, 8L
+
+#define LN_pkcs9_extCertAttributes "extendedCertificateAttributes"
+#define NID_pkcs9_extCertAttributes 56
+#define OBJ_pkcs9_extCertAttributes OBJ_pkcs9, 9L
+
+#define SN_ext_req "extReq"
+#define LN_ext_req "Extension Request"
+#define NID_ext_req 172
+#define OBJ_ext_req OBJ_pkcs9, 14L
+
+#define SN_SMIMECapabilities "SMIME-CAPS"
+#define LN_SMIMECapabilities "S/MIME Capabilities"
+#define NID_SMIMECapabilities 167
+#define OBJ_SMIMECapabilities OBJ_pkcs9, 15L
+
+#define SN_SMIME "SMIME"
+#define LN_SMIME "S/MIME"
+#define NID_SMIME 188
+#define OBJ_SMIME OBJ_pkcs9, 16L
 
-#define SN_id_smime_mod         "id-smime-mod"
-#define NID_id_smime_mod                189
-#define OBJ_id_smime_mod                OBJ_SMIME,0L
+#define SN_id_smime_mod "id-smime-mod"
+#define NID_id_smime_mod 189
+#define OBJ_id_smime_mod OBJ_SMIME, 0L
 
-#define SN_id_smime_ct          "id-smime-ct"
-#define NID_id_smime_ct         190
-#define OBJ_id_smime_ct         OBJ_SMIME,1L
+#define SN_id_smime_ct "id-smime-ct"
+#define NID_id_smime_ct 190
+#define OBJ_id_smime_ct OBJ_SMIME, 1L
 
-#define SN_id_smime_aa          "id-smime-aa"
-#define NID_id_smime_aa         191
-#define OBJ_id_smime_aa         OBJ_SMIME,2L
+#define SN_id_smime_aa "id-smime-aa"
+#define NID_id_smime_aa 191
+#define OBJ_id_smime_aa OBJ_SMIME, 2L
 
-#define SN_id_smime_alg         "id-smime-alg"
-#define NID_id_smime_alg                192
-#define OBJ_id_smime_alg                OBJ_SMIME,3L
+#define SN_id_smime_alg "id-smime-alg"
+#define NID_id_smime_alg 192
+#define OBJ_id_smime_alg OBJ_SMIME, 3L
 
-#define SN_id_smime_cd          "id-smime-cd"
-#define NID_id_smime_cd         193
-#define OBJ_id_smime_cd         OBJ_SMIME,4L
+#define SN_id_smime_cd "id-smime-cd"
+#define NID_id_smime_cd 193
+#define OBJ_id_smime_cd OBJ_SMIME, 4L
 
-#define SN_id_smime_spq         "id-smime-spq"
-#define NID_id_smime_spq                194
-#define OBJ_id_smime_spq                OBJ_SMIME,5L
+#define SN_id_smime_spq "id-smime-spq"
+#define NID_id_smime_spq 194
+#define OBJ_id_smime_spq OBJ_SMIME, 5L
 
-#define SN_id_smime_cti         "id-smime-cti"
-#define NID_id_smime_cti                195
-#define OBJ_id_smime_cti                OBJ_SMIME,6L
+#define SN_id_smime_cti "id-smime-cti"
+#define NID_id_smime_cti 195
+#define OBJ_id_smime_cti OBJ_SMIME, 6L
 
-#define SN_id_smime_mod_cms             "id-smime-mod-cms"
-#define NID_id_smime_mod_cms            196
-#define OBJ_id_smime_mod_cms            OBJ_id_smime_mod,1L
+#define SN_id_smime_mod_cms "id-smime-mod-cms"
+#define NID_id_smime_mod_cms 196
+#define OBJ_id_smime_mod_cms OBJ_id_smime_mod, 1L
 
-#define SN_id_smime_mod_ess             "id-smime-mod-ess"
-#define NID_id_smime_mod_ess            197
-#define OBJ_id_smime_mod_ess            OBJ_id_smime_mod,2L
+#define SN_id_smime_mod_ess "id-smime-mod-ess"
+#define NID_id_smime_mod_ess 197
+#define OBJ_id_smime_mod_ess OBJ_id_smime_mod, 2L
 
-#define SN_id_smime_mod_oid             "id-smime-mod-oid"
-#define NID_id_smime_mod_oid            198
-#define OBJ_id_smime_mod_oid            OBJ_id_smime_mod,3L
+#define SN_id_smime_mod_oid "id-smime-mod-oid"
+#define NID_id_smime_mod_oid 198
+#define OBJ_id_smime_mod_oid OBJ_id_smime_mod, 3L
 
-#define SN_id_smime_mod_msg_v3          "id-smime-mod-msg-v3"
-#define NID_id_smime_mod_msg_v3         199
-#define OBJ_id_smime_mod_msg_v3         OBJ_id_smime_mod,4L
+#define SN_id_smime_mod_msg_v3 "id-smime-mod-msg-v3"
+#define NID_id_smime_mod_msg_v3 199
+#define OBJ_id_smime_mod_msg_v3 OBJ_id_smime_mod, 4L
 
-#define SN_id_smime_mod_ets_eSignature_88               "id-smime-mod-ets-eSignature-88"
-#define NID_id_smime_mod_ets_eSignature_88              200
-#define OBJ_id_smime_mod_ets_eSignature_88              OBJ_id_smime_mod,5L
+#define SN_id_smime_mod_ets_eSignature_88 "id-smime-mod-ets-eSignature-88"
+#define NID_id_smime_mod_ets_eSignature_88 200
+#define OBJ_id_smime_mod_ets_eSignature_88 OBJ_id_smime_mod, 5L
 
-#define SN_id_smime_mod_ets_eSignature_97               "id-smime-mod-ets-eSignature-97"
-#define NID_id_smime_mod_ets_eSignature_97              201
-#define OBJ_id_smime_mod_ets_eSignature_97              OBJ_id_smime_mod,6L
+#define SN_id_smime_mod_ets_eSignature_97 "id-smime-mod-ets-eSignature-97"
+#define NID_id_smime_mod_ets_eSignature_97 201
+#define OBJ_id_smime_mod_ets_eSignature_97 OBJ_id_smime_mod, 6L
 
-#define SN_id_smime_mod_ets_eSigPolicy_88               "id-smime-mod-ets-eSigPolicy-88"
-#define NID_id_smime_mod_ets_eSigPolicy_88              202
-#define OBJ_id_smime_mod_ets_eSigPolicy_88              OBJ_id_smime_mod,7L
+#define SN_id_smime_mod_ets_eSigPolicy_88 "id-smime-mod-ets-eSigPolicy-88"
+#define NID_id_smime_mod_ets_eSigPolicy_88 202
+#define OBJ_id_smime_mod_ets_eSigPolicy_88 OBJ_id_smime_mod, 7L
 
-#define SN_id_smime_mod_ets_eSigPolicy_97               "id-smime-mod-ets-eSigPolicy-97"
-#define NID_id_smime_mod_ets_eSigPolicy_97              203
-#define OBJ_id_smime_mod_ets_eSigPolicy_97              OBJ_id_smime_mod,8L
+#define SN_id_smime_mod_ets_eSigPolicy_97 "id-smime-mod-ets-eSigPolicy-97"
+#define NID_id_smime_mod_ets_eSigPolicy_97 203
+#define OBJ_id_smime_mod_ets_eSigPolicy_97 OBJ_id_smime_mod, 8L
 
-#define SN_id_smime_ct_receipt          "id-smime-ct-receipt"
-#define NID_id_smime_ct_receipt         204
-#define OBJ_id_smime_ct_receipt         OBJ_id_smime_ct,1L
+#define SN_id_smime_ct_receipt "id-smime-ct-receipt"
+#define NID_id_smime_ct_receipt 204
+#define OBJ_id_smime_ct_receipt OBJ_id_smime_ct, 1L
 
-#define SN_id_smime_ct_authData         "id-smime-ct-authData"
-#define NID_id_smime_ct_authData                205
-#define OBJ_id_smime_ct_authData                OBJ_id_smime_ct,2L
+#define SN_id_smime_ct_authData "id-smime-ct-authData"
+#define NID_id_smime_ct_authData 205
+#define OBJ_id_smime_ct_authData OBJ_id_smime_ct, 2L
 
-#define SN_id_smime_ct_publishCert              "id-smime-ct-publishCert"
-#define NID_id_smime_ct_publishCert             206
-#define OBJ_id_smime_ct_publishCert             OBJ_id_smime_ct,3L
+#define SN_id_smime_ct_publishCert "id-smime-ct-publishCert"
+#define NID_id_smime_ct_publishCert 206
+#define OBJ_id_smime_ct_publishCert OBJ_id_smime_ct, 3L
 
-#define SN_id_smime_ct_TSTInfo          "id-smime-ct-TSTInfo"
-#define NID_id_smime_ct_TSTInfo         207
-#define OBJ_id_smime_ct_TSTInfo         OBJ_id_smime_ct,4L
+#define SN_id_smime_ct_TSTInfo "id-smime-ct-TSTInfo"
+#define NID_id_smime_ct_TSTInfo 207
+#define OBJ_id_smime_ct_TSTInfo OBJ_id_smime_ct, 4L
 
-#define SN_id_smime_ct_TDTInfo          "id-smime-ct-TDTInfo"
-#define NID_id_smime_ct_TDTInfo         208
-#define OBJ_id_smime_ct_TDTInfo         OBJ_id_smime_ct,5L
+#define SN_id_smime_ct_TDTInfo "id-smime-ct-TDTInfo"
+#define NID_id_smime_ct_TDTInfo 208
+#define OBJ_id_smime_ct_TDTInfo OBJ_id_smime_ct, 5L
 
-#define SN_id_smime_ct_contentInfo              "id-smime-ct-contentInfo"
-#define NID_id_smime_ct_contentInfo             209
-#define OBJ_id_smime_ct_contentInfo             OBJ_id_smime_ct,6L
+#define SN_id_smime_ct_contentInfo "id-smime-ct-contentInfo"
+#define NID_id_smime_ct_contentInfo 209
+#define OBJ_id_smime_ct_contentInfo OBJ_id_smime_ct, 6L
 
-#define SN_id_smime_ct_DVCSRequestData          "id-smime-ct-DVCSRequestData"
-#define NID_id_smime_ct_DVCSRequestData         210
-#define OBJ_id_smime_ct_DVCSRequestData         OBJ_id_smime_ct,7L
+#define SN_id_smime_ct_DVCSRequestData "id-smime-ct-DVCSRequestData"
+#define NID_id_smime_ct_DVCSRequestData 210
+#define OBJ_id_smime_ct_DVCSRequestData OBJ_id_smime_ct, 7L
 
-#define SN_id_smime_ct_DVCSResponseData         "id-smime-ct-DVCSResponseData"
-#define NID_id_smime_ct_DVCSResponseData                211
-#define OBJ_id_smime_ct_DVCSResponseData                OBJ_id_smime_ct,8L
+#define SN_id_smime_ct_DVCSResponseData "id-smime-ct-DVCSResponseData"
+#define NID_id_smime_ct_DVCSResponseData 211
+#define OBJ_id_smime_ct_DVCSResponseData OBJ_id_smime_ct, 8L
 
-#define SN_id_smime_ct_compressedData           "id-smime-ct-compressedData"
-#define NID_id_smime_ct_compressedData          786
-#define OBJ_id_smime_ct_compressedData          OBJ_id_smime_ct,9L
+#define SN_id_smime_ct_compressedData "id-smime-ct-compressedData"
+#define NID_id_smime_ct_compressedData 786
+#define OBJ_id_smime_ct_compressedData OBJ_id_smime_ct, 9L
 
-#define SN_id_smime_ct_contentCollection                "id-smime-ct-contentCollection"
-#define NID_id_smime_ct_contentCollection               1058
-#define OBJ_id_smime_ct_contentCollection               OBJ_id_smime_ct,19L
+#define SN_id_smime_ct_contentCollection "id-smime-ct-contentCollection"
+#define NID_id_smime_ct_contentCollection 1058
+#define OBJ_id_smime_ct_contentCollection OBJ_id_smime_ct, 19L
 
-#define SN_id_smime_ct_authEnvelopedData                "id-smime-ct-authEnvelopedData"
-#define NID_id_smime_ct_authEnvelopedData               1059
-#define OBJ_id_smime_ct_authEnvelopedData               OBJ_id_smime_ct,23L
+#define SN_id_smime_ct_authEnvelopedData "id-smime-ct-authEnvelopedData"
+#define NID_id_smime_ct_authEnvelopedData 1059
+#define OBJ_id_smime_ct_authEnvelopedData OBJ_id_smime_ct, 23L
 
-#define SN_id_ct_routeOriginAuthz               "id-ct-routeOriginAuthz"
-#define NID_id_ct_routeOriginAuthz              1234
-#define OBJ_id_ct_routeOriginAuthz              OBJ_id_smime_ct,24L
+#define SN_id_ct_routeOriginAuthz "id-ct-routeOriginAuthz"
+#define NID_id_ct_routeOriginAuthz 1234
+#define OBJ_id_ct_routeOriginAuthz OBJ_id_smime_ct, 24L
 
-#define SN_id_ct_rpkiManifest           "id-ct-rpkiManifest"
-#define NID_id_ct_rpkiManifest          1235
-#define OBJ_id_ct_rpkiManifest          OBJ_id_smime_ct,26L
+#define SN_id_ct_rpkiManifest "id-ct-rpkiManifest"
+#define NID_id_ct_rpkiManifest 1235
+#define OBJ_id_ct_rpkiManifest OBJ_id_smime_ct, 26L
 
-#define SN_id_ct_asciiTextWithCRLF              "id-ct-asciiTextWithCRLF"
-#define NID_id_ct_asciiTextWithCRLF             787
-#define OBJ_id_ct_asciiTextWithCRLF             OBJ_id_smime_ct,27L
+#define SN_id_ct_asciiTextWithCRLF "id-ct-asciiTextWithCRLF"
+#define NID_id_ct_asciiTextWithCRLF 787
+#define OBJ_id_ct_asciiTextWithCRLF OBJ_id_smime_ct, 27L
 
-#define SN_id_ct_xml            "id-ct-xml"
-#define NID_id_ct_xml           1060
-#define OBJ_id_ct_xml           OBJ_id_smime_ct,28L
+#define SN_id_ct_xml "id-ct-xml"
+#define NID_id_ct_xml 1060
+#define OBJ_id_ct_xml OBJ_id_smime_ct, 28L
 
-#define SN_id_ct_rpkiGhostbusters               "id-ct-rpkiGhostbusters"
-#define NID_id_ct_rpkiGhostbusters              1236
-#define OBJ_id_ct_rpkiGhostbusters              OBJ_id_smime_ct,35L
+#define SN_id_ct_rpkiGhostbusters "id-ct-rpkiGhostbusters"
+#define NID_id_ct_rpkiGhostbusters 1236
+#define OBJ_id_ct_rpkiGhostbusters OBJ_id_smime_ct, 35L
 
-#define SN_id_ct_resourceTaggedAttest           "id-ct-resourceTaggedAttest"
-#define NID_id_ct_resourceTaggedAttest          1237
-#define OBJ_id_ct_resourceTaggedAttest          OBJ_id_smime_ct,36L
+#define SN_id_ct_resourceTaggedAttest "id-ct-resourceTaggedAttest"
+#define NID_id_ct_resourceTaggedAttest 1237
+#define OBJ_id_ct_resourceTaggedAttest OBJ_id_smime_ct, 36L
 
-#define SN_id_ct_geofeedCSVwithCRLF             "id-ct-geofeedCSVwithCRLF"
-#define NID_id_ct_geofeedCSVwithCRLF            1246
-#define OBJ_id_ct_geofeedCSVwithCRLF            OBJ_id_smime_ct,47L
+#define SN_id_ct_geofeedCSVwithCRLF "id-ct-geofeedCSVwithCRLF"
+#define NID_id_ct_geofeedCSVwithCRLF 1246
+#define OBJ_id_ct_geofeedCSVwithCRLF OBJ_id_smime_ct, 47L
 
-#define SN_id_ct_signedChecklist                "id-ct-signedChecklist"
-#define NID_id_ct_signedChecklist               1247
-#define OBJ_id_ct_signedChecklist               OBJ_id_smime_ct,48L
+#define SN_id_ct_signedChecklist "id-ct-signedChecklist"
+#define NID_id_ct_signedChecklist 1247
+#define OBJ_id_ct_signedChecklist OBJ_id_smime_ct, 48L
 
-#define SN_id_smime_aa_receiptRequest           "id-smime-aa-receiptRequest"
-#define NID_id_smime_aa_receiptRequest          212
-#define OBJ_id_smime_aa_receiptRequest          OBJ_id_smime_aa,1L
+#define SN_id_smime_aa_receiptRequest "id-smime-aa-receiptRequest"
+#define NID_id_smime_aa_receiptRequest 212
+#define OBJ_id_smime_aa_receiptRequest OBJ_id_smime_aa, 1L
 
-#define SN_id_smime_aa_securityLabel            "id-smime-aa-securityLabel"
-#define NID_id_smime_aa_securityLabel           213
-#define OBJ_id_smime_aa_securityLabel           OBJ_id_smime_aa,2L
+#define SN_id_smime_aa_securityLabel "id-smime-aa-securityLabel"
+#define NID_id_smime_aa_securityLabel 213
+#define OBJ_id_smime_aa_securityLabel OBJ_id_smime_aa, 2L
 
-#define SN_id_smime_aa_mlExpandHistory          "id-smime-aa-mlExpandHistory"
-#define NID_id_smime_aa_mlExpandHistory         214
-#define OBJ_id_smime_aa_mlExpandHistory         OBJ_id_smime_aa,3L
+#define SN_id_smime_aa_mlExpandHistory "id-smime-aa-mlExpandHistory"
+#define NID_id_smime_aa_mlExpandHistory 214
+#define OBJ_id_smime_aa_mlExpandHistory OBJ_id_smime_aa, 3L
 
-#define SN_id_smime_aa_contentHint              "id-smime-aa-contentHint"
-#define NID_id_smime_aa_contentHint             215
-#define OBJ_id_smime_aa_contentHint             OBJ_id_smime_aa,4L
+#define SN_id_smime_aa_contentHint "id-smime-aa-contentHint"
+#define NID_id_smime_aa_contentHint 215
+#define OBJ_id_smime_aa_contentHint OBJ_id_smime_aa, 4L
 
-#define SN_id_smime_aa_msgSigDigest             "id-smime-aa-msgSigDigest"
-#define NID_id_smime_aa_msgSigDigest            216
-#define OBJ_id_smime_aa_msgSigDigest            OBJ_id_smime_aa,5L
+#define SN_id_smime_aa_msgSigDigest "id-smime-aa-msgSigDigest"
+#define NID_id_smime_aa_msgSigDigest 216
+#define OBJ_id_smime_aa_msgSigDigest OBJ_id_smime_aa, 5L
 
-#define SN_id_smime_aa_encapContentType         "id-smime-aa-encapContentType"
-#define NID_id_smime_aa_encapContentType                217
-#define OBJ_id_smime_aa_encapContentType                OBJ_id_smime_aa,6L
+#define SN_id_smime_aa_encapContentType "id-smime-aa-encapContentType"
+#define NID_id_smime_aa_encapContentType 217
+#define OBJ_id_smime_aa_encapContentType OBJ_id_smime_aa, 6L
 
-#define SN_id_smime_aa_contentIdentifier                "id-smime-aa-contentIdentifier"
-#define NID_id_smime_aa_contentIdentifier               218
-#define OBJ_id_smime_aa_contentIdentifier               OBJ_id_smime_aa,7L
+#define SN_id_smime_aa_contentIdentifier "id-smime-aa-contentIdentifier"
+#define NID_id_smime_aa_contentIdentifier 218
+#define OBJ_id_smime_aa_contentIdentifier OBJ_id_smime_aa, 7L
 
-#define SN_id_smime_aa_macValue         "id-smime-aa-macValue"
-#define NID_id_smime_aa_macValue                219
-#define OBJ_id_smime_aa_macValue                OBJ_id_smime_aa,8L
+#define SN_id_smime_aa_macValue "id-smime-aa-macValue"
+#define NID_id_smime_aa_macValue 219
+#define OBJ_id_smime_aa_macValue OBJ_id_smime_aa, 8L
 
-#define SN_id_smime_aa_equivalentLabels         "id-smime-aa-equivalentLabels"
-#define NID_id_smime_aa_equivalentLabels                220
-#define OBJ_id_smime_aa_equivalentLabels                OBJ_id_smime_aa,9L
+#define SN_id_smime_aa_equivalentLabels "id-smime-aa-equivalentLabels"
+#define NID_id_smime_aa_equivalentLabels 220
+#define OBJ_id_smime_aa_equivalentLabels OBJ_id_smime_aa, 9L
 
-#define SN_id_smime_aa_contentReference         "id-smime-aa-contentReference"
-#define NID_id_smime_aa_contentReference                221
-#define OBJ_id_smime_aa_contentReference                OBJ_id_smime_aa,10L
+#define SN_id_smime_aa_contentReference "id-smime-aa-contentReference"
+#define NID_id_smime_aa_contentReference 221
+#define OBJ_id_smime_aa_contentReference OBJ_id_smime_aa, 10L
 
-#define SN_id_smime_aa_encrypKeyPref            "id-smime-aa-encrypKeyPref"
-#define NID_id_smime_aa_encrypKeyPref           222
-#define OBJ_id_smime_aa_encrypKeyPref           OBJ_id_smime_aa,11L
+#define SN_id_smime_aa_encrypKeyPref "id-smime-aa-encrypKeyPref"
+#define NID_id_smime_aa_encrypKeyPref 222
+#define OBJ_id_smime_aa_encrypKeyPref OBJ_id_smime_aa, 11L
 
-#define SN_id_smime_aa_signingCertificate               "id-smime-aa-signingCertificate"
-#define NID_id_smime_aa_signingCertificate              223
-#define OBJ_id_smime_aa_signingCertificate              OBJ_id_smime_aa,12L
+#define SN_id_smime_aa_signingCertificate "id-smime-aa-signingCertificate"
+#define NID_id_smime_aa_signingCertificate 223
+#define OBJ_id_smime_aa_signingCertificate OBJ_id_smime_aa, 12L
 
-#define SN_id_smime_aa_smimeEncryptCerts                "id-smime-aa-smimeEncryptCerts"
-#define NID_id_smime_aa_smimeEncryptCerts               224
-#define OBJ_id_smime_aa_smimeEncryptCerts               OBJ_id_smime_aa,13L
+#define SN_id_smime_aa_smimeEncryptCerts "id-smime-aa-smimeEncryptCerts"
+#define NID_id_smime_aa_smimeEncryptCerts 224
+#define OBJ_id_smime_aa_smimeEncryptCerts OBJ_id_smime_aa, 13L
 
-#define SN_id_smime_aa_timeStampToken           "id-smime-aa-timeStampToken"
-#define NID_id_smime_aa_timeStampToken          225
-#define OBJ_id_smime_aa_timeStampToken          OBJ_id_smime_aa,14L
+#define SN_id_smime_aa_timeStampToken "id-smime-aa-timeStampToken"
+#define NID_id_smime_aa_timeStampToken 225
+#define OBJ_id_smime_aa_timeStampToken OBJ_id_smime_aa, 14L
 
-#define SN_id_smime_aa_ets_sigPolicyId          "id-smime-aa-ets-sigPolicyId"
-#define NID_id_smime_aa_ets_sigPolicyId         226
-#define OBJ_id_smime_aa_ets_sigPolicyId         OBJ_id_smime_aa,15L
+#define SN_id_smime_aa_ets_sigPolicyId "id-smime-aa-ets-sigPolicyId"
+#define NID_id_smime_aa_ets_sigPolicyId 226
+#define OBJ_id_smime_aa_ets_sigPolicyId OBJ_id_smime_aa, 15L
 
-#define SN_id_smime_aa_ets_commitmentType               "id-smime-aa-ets-commitmentType"
-#define NID_id_smime_aa_ets_commitmentType              227
-#define OBJ_id_smime_aa_ets_commitmentType              OBJ_id_smime_aa,16L
+#define SN_id_smime_aa_ets_commitmentType "id-smime-aa-ets-commitmentType"
+#define NID_id_smime_aa_ets_commitmentType 227
+#define OBJ_id_smime_aa_ets_commitmentType OBJ_id_smime_aa, 16L
 
-#define SN_id_smime_aa_ets_signerLocation               "id-smime-aa-ets-signerLocation"
-#define NID_id_smime_aa_ets_signerLocation              228
-#define OBJ_id_smime_aa_ets_signerLocation              OBJ_id_smime_aa,17L
+#define SN_id_smime_aa_ets_signerLocation "id-smime-aa-ets-signerLocation"
+#define NID_id_smime_aa_ets_signerLocation 228
+#define OBJ_id_smime_aa_ets_signerLocation OBJ_id_smime_aa, 17L
 
-#define SN_id_smime_aa_ets_signerAttr           "id-smime-aa-ets-signerAttr"
-#define NID_id_smime_aa_ets_signerAttr          229
-#define OBJ_id_smime_aa_ets_signerAttr          OBJ_id_smime_aa,18L
+#define SN_id_smime_aa_ets_signerAttr "id-smime-aa-ets-signerAttr"
+#define NID_id_smime_aa_ets_signerAttr 229
+#define OBJ_id_smime_aa_ets_signerAttr OBJ_id_smime_aa, 18L
 
-#define SN_id_smime_aa_ets_otherSigCert         "id-smime-aa-ets-otherSigCert"
-#define NID_id_smime_aa_ets_otherSigCert                230
-#define OBJ_id_smime_aa_ets_otherSigCert                OBJ_id_smime_aa,19L
+#define SN_id_smime_aa_ets_otherSigCert "id-smime-aa-ets-otherSigCert"
+#define NID_id_smime_aa_ets_otherSigCert 230
+#define OBJ_id_smime_aa_ets_otherSigCert OBJ_id_smime_aa, 19L
 
-#define SN_id_smime_aa_ets_contentTimestamp             "id-smime-aa-ets-contentTimestamp"
-#define NID_id_smime_aa_ets_contentTimestamp            231
-#define OBJ_id_smime_aa_ets_contentTimestamp            OBJ_id_smime_aa,20L
+#define SN_id_smime_aa_ets_contentTimestamp "id-smime-aa-ets-contentTimestamp"
+#define NID_id_smime_aa_ets_contentTimestamp 231
+#define OBJ_id_smime_aa_ets_contentTimestamp OBJ_id_smime_aa, 20L
 
-#define SN_id_smime_aa_ets_CertificateRefs              "id-smime-aa-ets-CertificateRefs"
-#define NID_id_smime_aa_ets_CertificateRefs             232
-#define OBJ_id_smime_aa_ets_CertificateRefs             OBJ_id_smime_aa,21L
+#define SN_id_smime_aa_ets_CertificateRefs "id-smime-aa-ets-CertificateRefs"
+#define NID_id_smime_aa_ets_CertificateRefs 232
+#define OBJ_id_smime_aa_ets_CertificateRefs OBJ_id_smime_aa, 21L
 
-#define SN_id_smime_aa_ets_RevocationRefs               "id-smime-aa-ets-RevocationRefs"
-#define NID_id_smime_aa_ets_RevocationRefs              233
-#define OBJ_id_smime_aa_ets_RevocationRefs              OBJ_id_smime_aa,22L
+#define SN_id_smime_aa_ets_RevocationRefs "id-smime-aa-ets-RevocationRefs"
+#define NID_id_smime_aa_ets_RevocationRefs 233
+#define OBJ_id_smime_aa_ets_RevocationRefs OBJ_id_smime_aa, 22L
 
-#define SN_id_smime_aa_ets_certValues           "id-smime-aa-ets-certValues"
-#define NID_id_smime_aa_ets_certValues          234
-#define OBJ_id_smime_aa_ets_certValues          OBJ_id_smime_aa,23L
+#define SN_id_smime_aa_ets_certValues "id-smime-aa-ets-certValues"
+#define NID_id_smime_aa_ets_certValues 234
+#define OBJ_id_smime_aa_ets_certValues OBJ_id_smime_aa, 23L
 
-#define SN_id_smime_aa_ets_revocationValues             "id-smime-aa-ets-revocationValues"
-#define NID_id_smime_aa_ets_revocationValues            235
-#define OBJ_id_smime_aa_ets_revocationValues            OBJ_id_smime_aa,24L
+#define SN_id_smime_aa_ets_revocationValues "id-smime-aa-ets-revocationValues"
+#define NID_id_smime_aa_ets_revocationValues 235
+#define OBJ_id_smime_aa_ets_revocationValues OBJ_id_smime_aa, 24L
 
-#define SN_id_smime_aa_ets_escTimeStamp         "id-smime-aa-ets-escTimeStamp"
-#define NID_id_smime_aa_ets_escTimeStamp                236
-#define OBJ_id_smime_aa_ets_escTimeStamp                OBJ_id_smime_aa,25L
+#define SN_id_smime_aa_ets_escTimeStamp "id-smime-aa-ets-escTimeStamp"
+#define NID_id_smime_aa_ets_escTimeStamp 236
+#define OBJ_id_smime_aa_ets_escTimeStamp OBJ_id_smime_aa, 25L
 
-#define SN_id_smime_aa_ets_certCRLTimestamp             "id-smime-aa-ets-certCRLTimestamp"
-#define NID_id_smime_aa_ets_certCRLTimestamp            237
-#define OBJ_id_smime_aa_ets_certCRLTimestamp            OBJ_id_smime_aa,26L
+#define SN_id_smime_aa_ets_certCRLTimestamp "id-smime-aa-ets-certCRLTimestamp"
+#define NID_id_smime_aa_ets_certCRLTimestamp 237
+#define OBJ_id_smime_aa_ets_certCRLTimestamp OBJ_id_smime_aa, 26L
 
-#define SN_id_smime_aa_ets_archiveTimeStamp             "id-smime-aa-ets-archiveTimeStamp"
-#define NID_id_smime_aa_ets_archiveTimeStamp            238
-#define OBJ_id_smime_aa_ets_archiveTimeStamp            OBJ_id_smime_aa,27L
+#define SN_id_smime_aa_ets_archiveTimeStamp "id-smime-aa-ets-archiveTimeStamp"
+#define NID_id_smime_aa_ets_archiveTimeStamp 238
+#define OBJ_id_smime_aa_ets_archiveTimeStamp OBJ_id_smime_aa, 27L
 
-#define SN_id_smime_aa_signatureType            "id-smime-aa-signatureType"
-#define NID_id_smime_aa_signatureType           239
-#define OBJ_id_smime_aa_signatureType           OBJ_id_smime_aa,28L
+#define SN_id_smime_aa_signatureType "id-smime-aa-signatureType"
+#define NID_id_smime_aa_signatureType 239
+#define OBJ_id_smime_aa_signatureType OBJ_id_smime_aa, 28L
 
-#define SN_id_smime_aa_dvcs_dvc         "id-smime-aa-dvcs-dvc"
-#define NID_id_smime_aa_dvcs_dvc                240
-#define OBJ_id_smime_aa_dvcs_dvc                OBJ_id_smime_aa,29L
+#define SN_id_smime_aa_dvcs_dvc "id-smime-aa-dvcs-dvc"
+#define NID_id_smime_aa_dvcs_dvc 240
+#define OBJ_id_smime_aa_dvcs_dvc OBJ_id_smime_aa, 29L
 
-#define SN_id_smime_aa_signingCertificateV2             "id-smime-aa-signingCertificateV2"
-#define NID_id_smime_aa_signingCertificateV2            1086
-#define OBJ_id_smime_aa_signingCertificateV2            OBJ_id_smime_aa,47L
+#define SN_id_smime_aa_signingCertificateV2 "id-smime-aa-signingCertificateV2"
+#define NID_id_smime_aa_signingCertificateV2 1086
+#define OBJ_id_smime_aa_signingCertificateV2 OBJ_id_smime_aa, 47L
 
-#define SN_id_smime_alg_ESDHwith3DES            "id-smime-alg-ESDHwith3DES"
-#define NID_id_smime_alg_ESDHwith3DES           241
-#define OBJ_id_smime_alg_ESDHwith3DES           OBJ_id_smime_alg,1L
+#define SN_id_smime_alg_ESDHwith3DES "id-smime-alg-ESDHwith3DES"
+#define NID_id_smime_alg_ESDHwith3DES 241
+#define OBJ_id_smime_alg_ESDHwith3DES OBJ_id_smime_alg, 1L
 
-#define SN_id_smime_alg_ESDHwithRC2             "id-smime-alg-ESDHwithRC2"
-#define NID_id_smime_alg_ESDHwithRC2            242
-#define OBJ_id_smime_alg_ESDHwithRC2            OBJ_id_smime_alg,2L
+#define SN_id_smime_alg_ESDHwithRC2 "id-smime-alg-ESDHwithRC2"
+#define NID_id_smime_alg_ESDHwithRC2 242
+#define OBJ_id_smime_alg_ESDHwithRC2 OBJ_id_smime_alg, 2L
 
-#define SN_id_smime_alg_3DESwrap                "id-smime-alg-3DESwrap"
-#define NID_id_smime_alg_3DESwrap               243
-#define OBJ_id_smime_alg_3DESwrap               OBJ_id_smime_alg,3L
+#define SN_id_smime_alg_3DESwrap "id-smime-alg-3DESwrap"
+#define NID_id_smime_alg_3DESwrap 243
+#define OBJ_id_smime_alg_3DESwrap OBJ_id_smime_alg, 3L
 
-#define SN_id_smime_alg_RC2wrap         "id-smime-alg-RC2wrap"
-#define NID_id_smime_alg_RC2wrap                244
-#define OBJ_id_smime_alg_RC2wrap                OBJ_id_smime_alg,4L
+#define SN_id_smime_alg_RC2wrap "id-smime-alg-RC2wrap"
+#define NID_id_smime_alg_RC2wrap 244
+#define OBJ_id_smime_alg_RC2wrap OBJ_id_smime_alg, 4L
 
-#define SN_id_smime_alg_ESDH            "id-smime-alg-ESDH"
-#define NID_id_smime_alg_ESDH           245
-#define OBJ_id_smime_alg_ESDH           OBJ_id_smime_alg,5L
+#define SN_id_smime_alg_ESDH "id-smime-alg-ESDH"
+#define NID_id_smime_alg_ESDH 245
+#define OBJ_id_smime_alg_ESDH OBJ_id_smime_alg, 5L
 
-#define SN_id_smime_alg_CMS3DESwrap             "id-smime-alg-CMS3DESwrap"
-#define NID_id_smime_alg_CMS3DESwrap            246
-#define OBJ_id_smime_alg_CMS3DESwrap            OBJ_id_smime_alg,6L
+#define SN_id_smime_alg_CMS3DESwrap "id-smime-alg-CMS3DESwrap"
+#define NID_id_smime_alg_CMS3DESwrap 246
+#define OBJ_id_smime_alg_CMS3DESwrap OBJ_id_smime_alg, 6L
 
-#define SN_id_smime_alg_CMSRC2wrap              "id-smime-alg-CMSRC2wrap"
-#define NID_id_smime_alg_CMSRC2wrap             247
-#define OBJ_id_smime_alg_CMSRC2wrap             OBJ_id_smime_alg,7L
+#define SN_id_smime_alg_CMSRC2wrap "id-smime-alg-CMSRC2wrap"
+#define NID_id_smime_alg_CMSRC2wrap 247
+#define OBJ_id_smime_alg_CMSRC2wrap OBJ_id_smime_alg, 7L
 
-#define SN_id_alg_PWRI_KEK              "id-alg-PWRI-KEK"
-#define NID_id_alg_PWRI_KEK             893
-#define OBJ_id_alg_PWRI_KEK             OBJ_id_smime_alg,9L
+#define SN_id_alg_PWRI_KEK "id-alg-PWRI-KEK"
+#define NID_id_alg_PWRI_KEK 893
+#define OBJ_id_alg_PWRI_KEK OBJ_id_smime_alg, 9L
 
-#define SN_id_smime_cd_ldap             "id-smime-cd-ldap"
-#define NID_id_smime_cd_ldap            248
-#define OBJ_id_smime_cd_ldap            OBJ_id_smime_cd,1L
+#define SN_id_smime_cd_ldap "id-smime-cd-ldap"
+#define NID_id_smime_cd_ldap 248
+#define OBJ_id_smime_cd_ldap OBJ_id_smime_cd, 1L
 
-#define SN_id_smime_spq_ets_sqt_uri             "id-smime-spq-ets-sqt-uri"
-#define NID_id_smime_spq_ets_sqt_uri            249
-#define OBJ_id_smime_spq_ets_sqt_uri            OBJ_id_smime_spq,1L
+#define SN_id_smime_spq_ets_sqt_uri "id-smime-spq-ets-sqt-uri"
+#define NID_id_smime_spq_ets_sqt_uri 249
+#define OBJ_id_smime_spq_ets_sqt_uri OBJ_id_smime_spq, 1L
 
-#define SN_id_smime_spq_ets_sqt_unotice         "id-smime-spq-ets-sqt-unotice"
-#define NID_id_smime_spq_ets_sqt_unotice                250
-#define OBJ_id_smime_spq_ets_sqt_unotice                OBJ_id_smime_spq,2L
+#define SN_id_smime_spq_ets_sqt_unotice "id-smime-spq-ets-sqt-unotice"
+#define NID_id_smime_spq_ets_sqt_unotice 250
+#define OBJ_id_smime_spq_ets_sqt_unotice OBJ_id_smime_spq, 2L
 
-#define SN_id_smime_cti_ets_proofOfOrigin               "id-smime-cti-ets-proofOfOrigin"
-#define NID_id_smime_cti_ets_proofOfOrigin              251
-#define OBJ_id_smime_cti_ets_proofOfOrigin              OBJ_id_smime_cti,1L
+#define SN_id_smime_cti_ets_proofOfOrigin "id-smime-cti-ets-proofOfOrigin"
+#define NID_id_smime_cti_ets_proofOfOrigin 251
+#define OBJ_id_smime_cti_ets_proofOfOrigin OBJ_id_smime_cti, 1L
 
-#define SN_id_smime_cti_ets_proofOfReceipt              "id-smime-cti-ets-proofOfReceipt"
-#define NID_id_smime_cti_ets_proofOfReceipt             252
-#define OBJ_id_smime_cti_ets_proofOfReceipt             OBJ_id_smime_cti,2L
+#define SN_id_smime_cti_ets_proofOfReceipt "id-smime-cti-ets-proofOfReceipt"
+#define NID_id_smime_cti_ets_proofOfReceipt 252
+#define OBJ_id_smime_cti_ets_proofOfReceipt OBJ_id_smime_cti, 2L
 
-#define SN_id_smime_cti_ets_proofOfDelivery             "id-smime-cti-ets-proofOfDelivery"
-#define NID_id_smime_cti_ets_proofOfDelivery            253
-#define OBJ_id_smime_cti_ets_proofOfDelivery            OBJ_id_smime_cti,3L
+#define SN_id_smime_cti_ets_proofOfDelivery "id-smime-cti-ets-proofOfDelivery"
+#define NID_id_smime_cti_ets_proofOfDelivery 253
+#define OBJ_id_smime_cti_ets_proofOfDelivery OBJ_id_smime_cti, 3L
 
-#define SN_id_smime_cti_ets_proofOfSender               "id-smime-cti-ets-proofOfSender"
-#define NID_id_smime_cti_ets_proofOfSender              254
-#define OBJ_id_smime_cti_ets_proofOfSender              OBJ_id_smime_cti,4L
+#define SN_id_smime_cti_ets_proofOfSender "id-smime-cti-ets-proofOfSender"
+#define NID_id_smime_cti_ets_proofOfSender 254
+#define OBJ_id_smime_cti_ets_proofOfSender OBJ_id_smime_cti, 4L
 
-#define SN_id_smime_cti_ets_proofOfApproval             "id-smime-cti-ets-proofOfApproval"
-#define NID_id_smime_cti_ets_proofOfApproval            255
-#define OBJ_id_smime_cti_ets_proofOfApproval            OBJ_id_smime_cti,5L
+#define SN_id_smime_cti_ets_proofOfApproval "id-smime-cti-ets-proofOfApproval"
+#define NID_id_smime_cti_ets_proofOfApproval 255
+#define OBJ_id_smime_cti_ets_proofOfApproval OBJ_id_smime_cti, 5L
 
-#define SN_id_smime_cti_ets_proofOfCreation             "id-smime-cti-ets-proofOfCreation"
-#define NID_id_smime_cti_ets_proofOfCreation            256
-#define OBJ_id_smime_cti_ets_proofOfCreation            OBJ_id_smime_cti,6L
+#define SN_id_smime_cti_ets_proofOfCreation "id-smime-cti-ets-proofOfCreation"
+#define NID_id_smime_cti_ets_proofOfCreation 256
+#define OBJ_id_smime_cti_ets_proofOfCreation OBJ_id_smime_cti, 6L
 
-#define LN_friendlyName         "friendlyName"
-#define NID_friendlyName                156
-#define OBJ_friendlyName                OBJ_pkcs9,20L
+#define LN_friendlyName "friendlyName"
+#define NID_friendlyName 156
+#define OBJ_friendlyName OBJ_pkcs9, 20L
 
-#define LN_localKeyID           "localKeyID"
-#define NID_localKeyID          157
-#define OBJ_localKeyID          OBJ_pkcs9,21L
+#define LN_localKeyID "localKeyID"
+#define NID_localKeyID 157
+#define OBJ_localKeyID OBJ_pkcs9, 21L
 
-#define SN_ms_csp_name          "CSPName"
-#define LN_ms_csp_name          "Microsoft CSP Name"
-#define NID_ms_csp_name         417
-#define OBJ_ms_csp_name         1L,3L,6L,1L,4L,1L,311L,17L,1L
+#define SN_ms_csp_name "CSPName"
+#define LN_ms_csp_name "Microsoft CSP Name"
+#define NID_ms_csp_name 417
+#define OBJ_ms_csp_name 1L, 3L, 6L, 1L, 4L, 1L, 311L, 17L, 1L
 
-#define SN_LocalKeySet          "LocalKeySet"
-#define LN_LocalKeySet          "Microsoft Local Key set"
-#define NID_LocalKeySet         856
-#define OBJ_LocalKeySet         1L,3L,6L,1L,4L,1L,311L,17L,2L
+#define SN_LocalKeySet "LocalKeySet"
+#define LN_LocalKeySet "Microsoft Local Key set"
+#define NID_LocalKeySet 856
+#define OBJ_LocalKeySet 1L, 3L, 6L, 1L, 4L, 1L, 311L, 17L, 2L
 
-#define OBJ_certTypes           OBJ_pkcs9,22L
+#define OBJ_certTypes OBJ_pkcs9, 22L
 
-#define LN_x509Certificate              "x509Certificate"
-#define NID_x509Certificate             158
-#define OBJ_x509Certificate             OBJ_certTypes,1L
+#define LN_x509Certificate "x509Certificate"
+#define NID_x509Certificate 158
+#define OBJ_x509Certificate OBJ_certTypes, 1L
 
-#define LN_sdsiCertificate              "sdsiCertificate"
-#define NID_sdsiCertificate             159
-#define OBJ_sdsiCertificate             OBJ_certTypes,2L
+#define LN_sdsiCertificate "sdsiCertificate"
+#define NID_sdsiCertificate 159
+#define OBJ_sdsiCertificate OBJ_certTypes, 2L
 
-#define OBJ_crlTypes            OBJ_pkcs9,23L
+#define OBJ_crlTypes OBJ_pkcs9, 23L
 
-#define LN_x509Crl              "x509Crl"
-#define NID_x509Crl             160
-#define OBJ_x509Crl             OBJ_crlTypes,1L
+#define LN_x509Crl "x509Crl"
+#define NID_x509Crl 160
+#define OBJ_x509Crl OBJ_crlTypes, 1L
 
-#define OBJ_pkcs12              OBJ_pkcs,12L
+#define OBJ_pkcs12 OBJ_pkcs, 12L
 
-#define OBJ_pkcs12_pbeids               OBJ_pkcs12,1L
+#define OBJ_pkcs12_pbeids OBJ_pkcs12, 1L
 
-#define SN_pbe_WithSHA1And128BitRC4             "PBE-SHA1-RC4-128"
-#define LN_pbe_WithSHA1And128BitRC4             "pbeWithSHA1And128BitRC4"
-#define NID_pbe_WithSHA1And128BitRC4            144
-#define OBJ_pbe_WithSHA1And128BitRC4            OBJ_pkcs12_pbeids,1L
+#define SN_pbe_WithSHA1And128BitRC4 "PBE-SHA1-RC4-128"
+#define LN_pbe_WithSHA1And128BitRC4 "pbeWithSHA1And128BitRC4"
+#define NID_pbe_WithSHA1And128BitRC4 144
+#define OBJ_pbe_WithSHA1And128BitRC4 OBJ_pkcs12_pbeids, 1L
 
-#define SN_pbe_WithSHA1And40BitRC4              "PBE-SHA1-RC4-40"
-#define LN_pbe_WithSHA1And40BitRC4              "pbeWithSHA1And40BitRC4"
-#define NID_pbe_WithSHA1And40BitRC4             145
-#define OBJ_pbe_WithSHA1And40BitRC4             OBJ_pkcs12_pbeids,2L
+#define SN_pbe_WithSHA1And40BitRC4 "PBE-SHA1-RC4-40"
+#define LN_pbe_WithSHA1And40BitRC4 "pbeWithSHA1And40BitRC4"
+#define NID_pbe_WithSHA1And40BitRC4 145
+#define OBJ_pbe_WithSHA1And40BitRC4 OBJ_pkcs12_pbeids, 2L
 
-#define SN_pbe_WithSHA1And3_Key_TripleDES_CBC           "PBE-SHA1-3DES"
-#define LN_pbe_WithSHA1And3_Key_TripleDES_CBC           "pbeWithSHA1And3-KeyTripleDES-CBC"
-#define NID_pbe_WithSHA1And3_Key_TripleDES_CBC          146
-#define OBJ_pbe_WithSHA1And3_Key_TripleDES_CBC          OBJ_pkcs12_pbeids,3L
-
-#define SN_pbe_WithSHA1And2_Key_TripleDES_CBC           "PBE-SHA1-2DES"
-#define LN_pbe_WithSHA1And2_Key_TripleDES_CBC           "pbeWithSHA1And2-KeyTripleDES-CBC"
-#define NID_pbe_WithSHA1And2_Key_TripleDES_CBC          147
-#define OBJ_pbe_WithSHA1And2_Key_TripleDES_CBC          OBJ_pkcs12_pbeids,4L
-
-#define SN_pbe_WithSHA1And128BitRC2_CBC         "PBE-SHA1-RC2-128"
-#define LN_pbe_WithSHA1And128BitRC2_CBC         "pbeWithSHA1And128BitRC2-CBC"
-#define NID_pbe_WithSHA1And128BitRC2_CBC                148
-#define OBJ_pbe_WithSHA1And128BitRC2_CBC                OBJ_pkcs12_pbeids,5L
+#define SN_pbe_WithSHA1And3_Key_TripleDES_CBC "PBE-SHA1-3DES"
+#define LN_pbe_WithSHA1And3_Key_TripleDES_CBC "pbeWithSHA1And3-KeyTripleDES-CBC"
+#define NID_pbe_WithSHA1And3_Key_TripleDES_CBC 146
+#define OBJ_pbe_WithSHA1And3_Key_TripleDES_CBC OBJ_pkcs12_pbeids, 3L
+
+#define SN_pbe_WithSHA1And2_Key_TripleDES_CBC "PBE-SHA1-2DES"
+#define LN_pbe_WithSHA1And2_Key_TripleDES_CBC "pbeWithSHA1And2-KeyTripleDES-CBC"
+#define NID_pbe_WithSHA1And2_Key_TripleDES_CBC 147
+#define OBJ_pbe_WithSHA1And2_Key_TripleDES_CBC OBJ_pkcs12_pbeids, 4L
+
+#define SN_pbe_WithSHA1And128BitRC2_CBC "PBE-SHA1-RC2-128"
+#define LN_pbe_WithSHA1And128BitRC2_CBC "pbeWithSHA1And128BitRC2-CBC"
+#define NID_pbe_WithSHA1And128BitRC2_CBC 148
+#define OBJ_pbe_WithSHA1And128BitRC2_CBC OBJ_pkcs12_pbeids, 5L
 
-#define SN_pbe_WithSHA1And40BitRC2_CBC          "PBE-SHA1-RC2-40"
-#define LN_pbe_WithSHA1And40BitRC2_CBC          "pbeWithSHA1And40BitRC2-CBC"
-#define NID_pbe_WithSHA1And40BitRC2_CBC         149
-#define OBJ_pbe_WithSHA1And40BitRC2_CBC         OBJ_pkcs12_pbeids,6L
+#define SN_pbe_WithSHA1And40BitRC2_CBC "PBE-SHA1-RC2-40"
+#define LN_pbe_WithSHA1And40BitRC2_CBC "pbeWithSHA1And40BitRC2-CBC"
+#define NID_pbe_WithSHA1And40BitRC2_CBC 149
+#define OBJ_pbe_WithSHA1And40BitRC2_CBC OBJ_pkcs12_pbeids, 6L
 
-#define OBJ_pkcs12_Version1             OBJ_pkcs12,10L
-
-#define OBJ_pkcs12_BagIds               OBJ_pkcs12_Version1,1L
+#define OBJ_pkcs12_Version1 OBJ_pkcs12, 10L
+
+#define OBJ_pkcs12_BagIds OBJ_pkcs12_Version1, 1L
 
-#define LN_keyBag               "keyBag"
-#define NID_keyBag              150
-#define OBJ_keyBag              OBJ_pkcs12_BagIds,1L
+#define LN_keyBag "keyBag"
+#define NID_keyBag 150
+#define OBJ_keyBag OBJ_pkcs12_BagIds, 1L
 
-#define LN_pkcs8ShroudedKeyBag          "pkcs8ShroudedKeyBag"
-#define NID_pkcs8ShroudedKeyBag         151
-#define OBJ_pkcs8ShroudedKeyBag         OBJ_pkcs12_BagIds,2L
+#define LN_pkcs8ShroudedKeyBag "pkcs8ShroudedKeyBag"
+#define NID_pkcs8ShroudedKeyBag 151
+#define OBJ_pkcs8ShroudedKeyBag OBJ_pkcs12_BagIds, 2L
 
-#define LN_certBag              "certBag"
-#define NID_certBag             152
-#define OBJ_certBag             OBJ_pkcs12_BagIds,3L
+#define LN_certBag "certBag"
+#define NID_certBag 152
+#define OBJ_certBag OBJ_pkcs12_BagIds, 3L
 
-#define LN_crlBag               "crlBag"
-#define NID_crlBag              153
-#define OBJ_crlBag              OBJ_pkcs12_BagIds,4L
+#define LN_crlBag "crlBag"
+#define NID_crlBag 153
+#define OBJ_crlBag OBJ_pkcs12_BagIds, 4L
 
-#define LN_secretBag            "secretBag"
-#define NID_secretBag           154
-#define OBJ_secretBag           OBJ_pkcs12_BagIds,5L
+#define LN_secretBag "secretBag"
+#define NID_secretBag 154
+#define OBJ_secretBag OBJ_pkcs12_BagIds, 5L
 
-#define LN_safeContentsBag              "safeContentsBag"
-#define NID_safeContentsBag             155
-#define OBJ_safeContentsBag             OBJ_pkcs12_BagIds,6L
-
-#define SN_md2          "MD2"
-#define LN_md2          "md2"
-#define NID_md2         3
-#define OBJ_md2         OBJ_rsadsi,2L,2L
-
-#define SN_md4          "MD4"
-#define LN_md4          "md4"
-#define NID_md4         257
-#define OBJ_md4         OBJ_rsadsi,2L,4L
-
-#define SN_md5          "MD5"
-#define LN_md5          "md5"
-#define NID_md5         4
-#define OBJ_md5         OBJ_rsadsi,2L,5L
-
-#define SN_md5_sha1             "MD5-SHA1"
-#define LN_md5_sha1             "md5-sha1"
-#define NID_md5_sha1            114
-
-#define LN_hmacWithMD5          "hmacWithMD5"
-#define NID_hmacWithMD5         797
-#define OBJ_hmacWithMD5         OBJ_rsadsi,2L,6L
-
-#define LN_hmacWithSHA1         "hmacWithSHA1"
-#define NID_hmacWithSHA1                163
-#define OBJ_hmacWithSHA1                OBJ_rsadsi,2L,7L
-
-#define SN_sm2          "SM2"
-#define LN_sm2          "sm2"
-#define NID_sm2         1172
-#define OBJ_sm2         OBJ_sm_scheme,301L
-
-#define SN_sm3          "SM3"
-#define LN_sm3          "sm3"
-#define NID_sm3         1143
-#define OBJ_sm3         OBJ_sm_scheme,401L
-
-#define SN_sm3WithRSAEncryption         "RSA-SM3"
-#define LN_sm3WithRSAEncryption         "sm3WithRSAEncryption"
-#define NID_sm3WithRSAEncryption                1144
-#define OBJ_sm3WithRSAEncryption                OBJ_sm_scheme,504L
-
-#define SN_SM2_with_SM3         "SM2-SM3"
-#define LN_SM2_with_SM3         "SM2-with-SM3"
-#define NID_SM2_with_SM3                1204
-#define OBJ_SM2_with_SM3                OBJ_sm_scheme,501L
-
-#define LN_hmacWithSHA224               "hmacWithSHA224"
-#define NID_hmacWithSHA224              798
-#define OBJ_hmacWithSHA224              OBJ_rsadsi,2L,8L
-
-#define LN_hmacWithSHA256               "hmacWithSHA256"
-#define NID_hmacWithSHA256              799
-#define OBJ_hmacWithSHA256              OBJ_rsadsi,2L,9L
-
-#define LN_hmacWithSHA384               "hmacWithSHA384"
-#define NID_hmacWithSHA384              800
-#define OBJ_hmacWithSHA384              OBJ_rsadsi,2L,10L
-
-#define LN_hmacWithSHA512               "hmacWithSHA512"
-#define NID_hmacWithSHA512              801
-#define OBJ_hmacWithSHA512              OBJ_rsadsi,2L,11L
-
-#define LN_hmacWithSHA512_224           "hmacWithSHA512-224"
-#define NID_hmacWithSHA512_224          1193
-#define OBJ_hmacWithSHA512_224          OBJ_rsadsi,2L,12L
-
-#define LN_hmacWithSHA512_256           "hmacWithSHA512-256"
-#define NID_hmacWithSHA512_256          1194
-#define OBJ_hmacWithSHA512_256          OBJ_rsadsi,2L,13L
-
-#define SN_rc2_cbc              "RC2-CBC"
-#define LN_rc2_cbc              "rc2-cbc"
-#define NID_rc2_cbc             37
-#define OBJ_rc2_cbc             OBJ_rsadsi,3L,2L
-
-#define SN_rc2_ecb              "RC2-ECB"
-#define LN_rc2_ecb              "rc2-ecb"
-#define NID_rc2_ecb             38
-
-#define SN_rc2_cfb64            "RC2-CFB"
-#define LN_rc2_cfb64            "rc2-cfb"
-#define NID_rc2_cfb64           39
-
-#define SN_rc2_ofb64            "RC2-OFB"
-#define LN_rc2_ofb64            "rc2-ofb"
-#define NID_rc2_ofb64           40
-
-#define SN_rc2_40_cbc           "RC2-40-CBC"
-#define LN_rc2_40_cbc           "rc2-40-cbc"
-#define NID_rc2_40_cbc          98
-
-#define SN_rc2_64_cbc           "RC2-64-CBC"
-#define LN_rc2_64_cbc           "rc2-64-cbc"
-#define NID_rc2_64_cbc          166
-
-#define SN_rc4          "RC4"
-#define LN_rc4          "rc4"
-#define NID_rc4         5
-#define OBJ_rc4         OBJ_rsadsi,3L,4L
-
-#define SN_rc4_40               "RC4-40"
-#define LN_rc4_40               "rc4-40"
-#define NID_rc4_40              97
-
-#define SN_des_ede3_cbc         "DES-EDE3-CBC"
-#define LN_des_ede3_cbc         "des-ede3-cbc"
-#define NID_des_ede3_cbc                44
-#define OBJ_des_ede3_cbc                OBJ_rsadsi,3L,7L
-
-#define SN_rc5_cbc              "RC5-CBC"
-#define LN_rc5_cbc              "rc5-cbc"
-#define NID_rc5_cbc             120
-#define OBJ_rc5_cbc             OBJ_rsadsi,3L,8L
-
-#define SN_rc5_ecb              "RC5-ECB"
-#define LN_rc5_ecb              "rc5-ecb"
-#define NID_rc5_ecb             121
-
-#define SN_rc5_cfb64            "RC5-CFB"
-#define LN_rc5_cfb64            "rc5-cfb"
-#define NID_rc5_cfb64           122
-
-#define SN_rc5_ofb64            "RC5-OFB"
-#define LN_rc5_ofb64            "rc5-ofb"
-#define NID_rc5_ofb64           123
-
-#define SN_ms_ext_req           "msExtReq"
-#define LN_ms_ext_req           "Microsoft Extension Request"
-#define NID_ms_ext_req          171
-#define OBJ_ms_ext_req          1L,3L,6L,1L,4L,1L,311L,2L,1L,14L
-
-#define SN_ms_code_ind          "msCodeInd"
-#define LN_ms_code_ind          "Microsoft Individual Code Signing"
-#define NID_ms_code_ind         134
-#define OBJ_ms_code_ind         1L,3L,6L,1L,4L,1L,311L,2L,1L,21L
-
-#define SN_ms_code_com          "msCodeCom"
-#define LN_ms_code_com          "Microsoft Commercial Code Signing"
-#define NID_ms_code_com         135
-#define OBJ_ms_code_com         1L,3L,6L,1L,4L,1L,311L,2L,1L,22L
-
-#define SN_ms_ctl_sign          "msCTLSign"
-#define LN_ms_ctl_sign          "Microsoft Trust List Signing"
-#define NID_ms_ctl_sign         136
-#define OBJ_ms_ctl_sign         1L,3L,6L,1L,4L,1L,311L,10L,3L,1L
-
-#define SN_ms_sgc               "msSGC"
-#define LN_ms_sgc               "Microsoft Server Gated Crypto"
-#define NID_ms_sgc              137
-#define OBJ_ms_sgc              1L,3L,6L,1L,4L,1L,311L,10L,3L,3L
-
-#define SN_ms_efs               "msEFS"
-#define LN_ms_efs               "Microsoft Encrypted File System"
-#define NID_ms_efs              138
-#define OBJ_ms_efs              1L,3L,6L,1L,4L,1L,311L,10L,3L,4L
-
-#define SN_ms_smartcard_login           "msSmartcardLogin"
-#define LN_ms_smartcard_login           "Microsoft Smartcard Login"
-#define NID_ms_smartcard_login          648
-#define OBJ_ms_smartcard_login          1L,3L,6L,1L,4L,1L,311L,20L,2L,2L
-
-#define SN_ms_upn               "msUPN"
-#define LN_ms_upn               "Microsoft User Principal Name"
-#define NID_ms_upn              649
-#define OBJ_ms_upn              1L,3L,6L,1L,4L,1L,311L,20L,2L,3L
-
-#define SN_idea_cbc             "IDEA-CBC"
-#define LN_idea_cbc             "idea-cbc"
-#define NID_idea_cbc            34
-#define OBJ_idea_cbc            1L,3L,6L,1L,4L,1L,188L,7L,1L,1L,2L
-
-#define SN_idea_ecb             "IDEA-ECB"
-#define LN_idea_ecb             "idea-ecb"
-#define NID_idea_ecb            36
-
-#define SN_idea_cfb64           "IDEA-CFB"
-#define LN_idea_cfb64           "idea-cfb"
-#define NID_idea_cfb64          35
-
-#define SN_idea_ofb64           "IDEA-OFB"
-#define LN_idea_ofb64           "idea-ofb"
-#define NID_idea_ofb64          46
-
-#define SN_bf_cbc               "BF-CBC"
-#define LN_bf_cbc               "bf-cbc"
-#define NID_bf_cbc              91
-#define OBJ_bf_cbc              1L,3L,6L,1L,4L,1L,3029L,1L,2L
-
-#define SN_bf_ecb               "BF-ECB"
-#define LN_bf_ecb               "bf-ecb"
-#define NID_bf_ecb              92
-
-#define SN_bf_cfb64             "BF-CFB"
-#define LN_bf_cfb64             "bf-cfb"
-#define NID_bf_cfb64            93
-
-#define SN_bf_ofb64             "BF-OFB"
-#define LN_bf_ofb64             "bf-ofb"
-#define NID_bf_ofb64            94
-
-#define SN_id_pkix              "PKIX"
-#define NID_id_pkix             127
-#define OBJ_id_pkix             1L,3L,6L,1L,5L,5L,7L
-
-#define SN_id_pkix_mod          "id-pkix-mod"
-#define NID_id_pkix_mod         258
-#define OBJ_id_pkix_mod         OBJ_id_pkix,0L
-
-#define SN_id_pe                "id-pe"
-#define NID_id_pe               175
-#define OBJ_id_pe               OBJ_id_pkix,1L
-
-#define SN_id_qt                "id-qt"
-#define NID_id_qt               259
-#define OBJ_id_qt               OBJ_id_pkix,2L
-
-#define SN_id_kp                "id-kp"
-#define NID_id_kp               128
-#define OBJ_id_kp               OBJ_id_pkix,3L
-
-#define SN_id_it                "id-it"
-#define NID_id_it               260
-#define OBJ_id_it               OBJ_id_pkix,4L
-
-#define SN_id_pkip              "id-pkip"
-#define NID_id_pkip             261
-#define OBJ_id_pkip             OBJ_id_pkix,5L
-
-#define SN_id_alg               "id-alg"
-#define NID_id_alg              262
-#define OBJ_id_alg              OBJ_id_pkix,6L
-
-#define SN_id_cmc               "id-cmc"
-#define NID_id_cmc              263
-#define OBJ_id_cmc              OBJ_id_pkix,7L
-
-#define SN_id_on                "id-on"
-#define NID_id_on               264
-#define OBJ_id_on               OBJ_id_pkix,8L
-
-#define SN_id_pda               "id-pda"
-#define NID_id_pda              265
-#define OBJ_id_pda              OBJ_id_pkix,9L
-
-#define SN_id_aca               "id-aca"
-#define NID_id_aca              266
-#define OBJ_id_aca              OBJ_id_pkix,10L
-
-#define SN_id_qcs               "id-qcs"
-#define NID_id_qcs              267
-#define OBJ_id_qcs              OBJ_id_pkix,11L
-
-#define SN_id_cp                "id-cp"
-#define NID_id_cp               1238
-#define OBJ_id_cp               OBJ_id_pkix,14L
-
-#define SN_id_cct               "id-cct"
-#define NID_id_cct              268
-#define OBJ_id_cct              OBJ_id_pkix,12L
-
-#define SN_id_ppl               "id-ppl"
-#define NID_id_ppl              662
-#define OBJ_id_ppl              OBJ_id_pkix,21L
-
-#define SN_id_ad                "id-ad"
-#define NID_id_ad               176
-#define OBJ_id_ad               OBJ_id_pkix,48L
-
-#define SN_id_pkix1_explicit_88         "id-pkix1-explicit-88"
-#define NID_id_pkix1_explicit_88                269
-#define OBJ_id_pkix1_explicit_88                OBJ_id_pkix_mod,1L
-
-#define SN_id_pkix1_implicit_88         "id-pkix1-implicit-88"
-#define NID_id_pkix1_implicit_88                270
-#define OBJ_id_pkix1_implicit_88                OBJ_id_pkix_mod,2L
-
-#define SN_id_pkix1_explicit_93         "id-pkix1-explicit-93"
-#define NID_id_pkix1_explicit_93                271
-#define OBJ_id_pkix1_explicit_93                OBJ_id_pkix_mod,3L
-
-#define SN_id_pkix1_implicit_93         "id-pkix1-implicit-93"
-#define NID_id_pkix1_implicit_93                272
-#define OBJ_id_pkix1_implicit_93                OBJ_id_pkix_mod,4L
-
-#define SN_id_mod_crmf          "id-mod-crmf"
-#define NID_id_mod_crmf         273
-#define OBJ_id_mod_crmf         OBJ_id_pkix_mod,5L
-
-#define SN_id_mod_cmc           "id-mod-cmc"
-#define NID_id_mod_cmc          274
-#define OBJ_id_mod_cmc          OBJ_id_pkix_mod,6L
-
-#define SN_id_mod_kea_profile_88                "id-mod-kea-profile-88"
-#define NID_id_mod_kea_profile_88               275
-#define OBJ_id_mod_kea_profile_88               OBJ_id_pkix_mod,7L
-
-#define SN_id_mod_kea_profile_93                "id-mod-kea-profile-93"
-#define NID_id_mod_kea_profile_93               276
-#define OBJ_id_mod_kea_profile_93               OBJ_id_pkix_mod,8L
-
-#define SN_id_mod_cmp           "id-mod-cmp"
-#define NID_id_mod_cmp          277
-#define OBJ_id_mod_cmp          OBJ_id_pkix_mod,9L
-
-#define SN_id_mod_qualified_cert_88             "id-mod-qualified-cert-88"
-#define NID_id_mod_qualified_cert_88            278
-#define OBJ_id_mod_qualified_cert_88            OBJ_id_pkix_mod,10L
-
-#define SN_id_mod_qualified_cert_93             "id-mod-qualified-cert-93"
-#define NID_id_mod_qualified_cert_93            279
-#define OBJ_id_mod_qualified_cert_93            OBJ_id_pkix_mod,11L
-
-#define SN_id_mod_attribute_cert                "id-mod-attribute-cert"
-#define NID_id_mod_attribute_cert               280
-#define OBJ_id_mod_attribute_cert               OBJ_id_pkix_mod,12L
-
-#define SN_id_mod_timestamp_protocol            "id-mod-timestamp-protocol"
-#define NID_id_mod_timestamp_protocol           281
-#define OBJ_id_mod_timestamp_protocol           OBJ_id_pkix_mod,13L
-
-#define SN_id_mod_ocsp          "id-mod-ocsp"
-#define NID_id_mod_ocsp         282
-#define OBJ_id_mod_ocsp         OBJ_id_pkix_mod,14L
-
-#define SN_id_mod_dvcs          "id-mod-dvcs"
-#define NID_id_mod_dvcs         283
-#define OBJ_id_mod_dvcs         OBJ_id_pkix_mod,15L
-
-#define SN_id_mod_cmp2000               "id-mod-cmp2000"
-#define NID_id_mod_cmp2000              284
-#define OBJ_id_mod_cmp2000              OBJ_id_pkix_mod,16L
-
-#define SN_info_access          "authorityInfoAccess"
-#define LN_info_access          "Authority Information Access"
-#define NID_info_access         177
-#define OBJ_info_access         OBJ_id_pe,1L
-
-#define SN_biometricInfo                "biometricInfo"
-#define LN_biometricInfo                "Biometric Info"
-#define NID_biometricInfo               285
-#define OBJ_biometricInfo               OBJ_id_pe,2L
-
-#define SN_qcStatements         "qcStatements"
-#define NID_qcStatements                286
-#define OBJ_qcStatements                OBJ_id_pe,3L
-
-#define SN_ac_auditEntity               "ac-auditEntity"
-#define NID_ac_auditEntity              287
-#define OBJ_ac_auditEntity              OBJ_id_pe,4L
-
-#define SN_ac_targeting         "ac-targeting"
-#define NID_ac_targeting                288
-#define OBJ_ac_targeting                OBJ_id_pe,5L
-
-#define SN_aaControls           "aaControls"
-#define NID_aaControls          289
-#define OBJ_aaControls          OBJ_id_pe,6L
-
-#define SN_sbgp_ipAddrBlock             "sbgp-ipAddrBlock"
-#define NID_sbgp_ipAddrBlock            290
-#define OBJ_sbgp_ipAddrBlock            OBJ_id_pe,7L
-
-#define SN_sbgp_autonomousSysNum                "sbgp-autonomousSysNum"
-#define NID_sbgp_autonomousSysNum               291
-#define OBJ_sbgp_autonomousSysNum               OBJ_id_pe,8L
-
-#define SN_sbgp_routerIdentifier                "sbgp-routerIdentifier"
-#define NID_sbgp_routerIdentifier               292
-#define OBJ_sbgp_routerIdentifier               OBJ_id_pe,9L
-
-#define SN_ac_proxying          "ac-proxying"
-#define NID_ac_proxying         397
-#define OBJ_ac_proxying         OBJ_id_pe,10L
-
-#define SN_sinfo_access         "subjectInfoAccess"
-#define LN_sinfo_access         "Subject Information Access"
-#define NID_sinfo_access                398
-#define OBJ_sinfo_access                OBJ_id_pe,11L
-
-#define SN_proxyCertInfo                "proxyCertInfo"
-#define LN_proxyCertInfo                "Proxy Certificate Information"
-#define NID_proxyCertInfo               663
-#define OBJ_proxyCertInfo               OBJ_id_pe,14L
-
-#define SN_tlsfeature           "tlsfeature"
-#define LN_tlsfeature           "TLS Feature"
-#define NID_tlsfeature          1020
-#define OBJ_tlsfeature          OBJ_id_pe,24L
-
-#define SN_sbgp_ipAddrBlockv2           "sbgp-ipAddrBlockv2"
-#define NID_sbgp_ipAddrBlockv2          1239
-#define OBJ_sbgp_ipAddrBlockv2          OBJ_id_pe,28L
-
-#define SN_sbgp_autonomousSysNumv2              "sbgp-autonomousSysNumv2"
-#define NID_sbgp_autonomousSysNumv2             1240
-#define OBJ_sbgp_autonomousSysNumv2             OBJ_id_pe,29L
-
-#define SN_id_qt_cps            "id-qt-cps"
-#define LN_id_qt_cps            "Policy Qualifier CPS"
-#define NID_id_qt_cps           164
-#define OBJ_id_qt_cps           OBJ_id_qt,1L
-
-#define SN_id_qt_unotice                "id-qt-unotice"
-#define LN_id_qt_unotice                "Policy Qualifier User Notice"
-#define NID_id_qt_unotice               165
-#define OBJ_id_qt_unotice               OBJ_id_qt,2L
-
-#define SN_textNotice           "textNotice"
-#define NID_textNotice          293
-#define OBJ_textNotice          OBJ_id_qt,3L
-
-#define SN_server_auth          "serverAuth"
-#define LN_server_auth          "TLS Web Server Authentication"
-#define NID_server_auth         129
-#define OBJ_server_auth         OBJ_id_kp,1L
-
-#define SN_client_auth          "clientAuth"
-#define LN_client_auth          "TLS Web Client Authentication"
-#define NID_client_auth         130
-#define OBJ_client_auth         OBJ_id_kp,2L
-
-#define SN_code_sign            "codeSigning"
-#define LN_code_sign            "Code Signing"
-#define NID_code_sign           131
-#define OBJ_code_sign           OBJ_id_kp,3L
-
-#define SN_email_protect                "emailProtection"
-#define LN_email_protect                "E-mail Protection"
-#define NID_email_protect               132
-#define OBJ_email_protect               OBJ_id_kp,4L
-
-#define SN_ipsecEndSystem               "ipsecEndSystem"
-#define LN_ipsecEndSystem               "IPSec End System"
-#define NID_ipsecEndSystem              294
-#define OBJ_ipsecEndSystem              OBJ_id_kp,5L
-
-#define SN_ipsecTunnel          "ipsecTunnel"
-#define LN_ipsecTunnel          "IPSec Tunnel"
-#define NID_ipsecTunnel         295
-#define OBJ_ipsecTunnel         OBJ_id_kp,6L
-
-#define SN_ipsecUser            "ipsecUser"
-#define LN_ipsecUser            "IPSec User"
-#define NID_ipsecUser           296
-#define OBJ_ipsecUser           OBJ_id_kp,7L
-
-#define SN_time_stamp           "timeStamping"
-#define LN_time_stamp           "Time Stamping"
-#define NID_time_stamp          133
-#define OBJ_time_stamp          OBJ_id_kp,8L
-
-#define SN_OCSP_sign            "OCSPSigning"
-#define LN_OCSP_sign            "OCSP Signing"
-#define NID_OCSP_sign           180
-#define OBJ_OCSP_sign           OBJ_id_kp,9L
-
-#define SN_dvcs         "DVCS"
-#define LN_dvcs         "dvcs"
-#define NID_dvcs                297
-#define OBJ_dvcs                OBJ_id_kp,10L
-
-#define SN_ipsec_IKE            "ipsecIKE"
-#define LN_ipsec_IKE            "ipsec Internet Key Exchange"
-#define NID_ipsec_IKE           1022
-#define OBJ_ipsec_IKE           OBJ_id_kp,17L
-
-#define SN_capwapAC             "capwapAC"
-#define LN_capwapAC             "Ctrl/provision WAP Access"
-#define NID_capwapAC            1023
-#define OBJ_capwapAC            OBJ_id_kp,18L
-
-#define SN_capwapWTP            "capwapWTP"
-#define LN_capwapWTP            "Ctrl/Provision WAP Termination"
-#define NID_capwapWTP           1024
-#define OBJ_capwapWTP           OBJ_id_kp,19L
-
-#define SN_sshClient            "secureShellClient"
-#define LN_sshClient            "SSH Client"
-#define NID_sshClient           1025
-#define OBJ_sshClient           OBJ_id_kp,21L
-
-#define SN_sshServer            "secureShellServer"
-#define LN_sshServer            "SSH Server"
-#define NID_sshServer           1026
-#define OBJ_sshServer           OBJ_id_kp,22L
-
-#define SN_sendRouter           "sendRouter"
-#define LN_sendRouter           "Send Router"
-#define NID_sendRouter          1027
-#define OBJ_sendRouter          OBJ_id_kp,23L
-
-#define SN_sendProxiedRouter            "sendProxiedRouter"
-#define LN_sendProxiedRouter            "Send Proxied Router"
-#define NID_sendProxiedRouter           1028
-#define OBJ_sendProxiedRouter           OBJ_id_kp,24L
-
-#define SN_sendOwner            "sendOwner"
-#define LN_sendOwner            "Send Owner"
-#define NID_sendOwner           1029
-#define OBJ_sendOwner           OBJ_id_kp,25L
-
-#define SN_sendProxiedOwner             "sendProxiedOwner"
-#define LN_sendProxiedOwner             "Send Proxied Owner"
-#define NID_sendProxiedOwner            1030
-#define OBJ_sendProxiedOwner            OBJ_id_kp,26L
-
-#define SN_cmcCA                "cmcCA"
-#define LN_cmcCA                "CMC Certificate Authority"
-#define NID_cmcCA               1131
-#define OBJ_cmcCA               OBJ_id_kp,27L
-
-#define SN_cmcRA                "cmcRA"
-#define LN_cmcRA                "CMC Registration Authority"
-#define NID_cmcRA               1132
-#define OBJ_cmcRA               OBJ_id_kp,28L
-
-#define SN_cmcArchive           "cmcArchive"
-#define LN_cmcArchive           "CMC Archive Server"
-#define NID_cmcArchive          1219
-#define OBJ_cmcArchive          OBJ_id_kp,29L
-
-#define SN_id_kp_bgpsec_router          "id-kp-bgpsec-router"
-#define LN_id_kp_bgpsec_router          "BGPsec Router"
-#define NID_id_kp_bgpsec_router         1220
-#define OBJ_id_kp_bgpsec_router         OBJ_id_kp,30L
-
-#define SN_id_kp_BrandIndicatorforMessageIdentification         "id-kp-BrandIndicatorforMessageIdentification"
-#define LN_id_kp_BrandIndicatorforMessageIdentification         "Brand Indicator for Message Identification"
-#define NID_id_kp_BrandIndicatorforMessageIdentification                1221
-#define OBJ_id_kp_BrandIndicatorforMessageIdentification                OBJ_id_kp,31L
-
-#define SN_cmKGA                "cmKGA"
-#define LN_cmKGA                "Certificate Management Key Generation Authority"
-#define NID_cmKGA               1222
-#define OBJ_cmKGA               OBJ_id_kp,32L
-
-#define SN_id_it_caProtEncCert          "id-it-caProtEncCert"
-#define NID_id_it_caProtEncCert         298
-#define OBJ_id_it_caProtEncCert         OBJ_id_it,1L
-
-#define SN_id_it_signKeyPairTypes               "id-it-signKeyPairTypes"
-#define NID_id_it_signKeyPairTypes              299
-#define OBJ_id_it_signKeyPairTypes              OBJ_id_it,2L
-
-#define SN_id_it_encKeyPairTypes                "id-it-encKeyPairTypes"
-#define NID_id_it_encKeyPairTypes               300
-#define OBJ_id_it_encKeyPairTypes               OBJ_id_it,3L
-
-#define SN_id_it_preferredSymmAlg               "id-it-preferredSymmAlg"
-#define NID_id_it_preferredSymmAlg              301
-#define OBJ_id_it_preferredSymmAlg              OBJ_id_it,4L
-
-#define SN_id_it_caKeyUpdateInfo                "id-it-caKeyUpdateInfo"
-#define NID_id_it_caKeyUpdateInfo               302
-#define OBJ_id_it_caKeyUpdateInfo               OBJ_id_it,5L
-
-#define SN_id_it_currentCRL             "id-it-currentCRL"
-#define NID_id_it_currentCRL            303
-#define OBJ_id_it_currentCRL            OBJ_id_it,6L
-
-#define SN_id_it_unsupportedOIDs                "id-it-unsupportedOIDs"
-#define NID_id_it_unsupportedOIDs               304
-#define OBJ_id_it_unsupportedOIDs               OBJ_id_it,7L
-
-#define SN_id_it_subscriptionRequest            "id-it-subscriptionRequest"
-#define NID_id_it_subscriptionRequest           305
-#define OBJ_id_it_subscriptionRequest           OBJ_id_it,8L
-
-#define SN_id_it_subscriptionResponse           "id-it-subscriptionResponse"
-#define NID_id_it_subscriptionResponse          306
-#define OBJ_id_it_subscriptionResponse          OBJ_id_it,9L
-
-#define SN_id_it_keyPairParamReq                "id-it-keyPairParamReq"
-#define NID_id_it_keyPairParamReq               307
-#define OBJ_id_it_keyPairParamReq               OBJ_id_it,10L
-
-#define SN_id_it_keyPairParamRep                "id-it-keyPairParamRep"
-#define NID_id_it_keyPairParamRep               308
-#define OBJ_id_it_keyPairParamRep               OBJ_id_it,11L
-
-#define SN_id_it_revPassphrase          "id-it-revPassphrase"
-#define NID_id_it_revPassphrase         309
-#define OBJ_id_it_revPassphrase         OBJ_id_it,12L
-
-#define SN_id_it_implicitConfirm                "id-it-implicitConfirm"
-#define NID_id_it_implicitConfirm               310
-#define OBJ_id_it_implicitConfirm               OBJ_id_it,13L
-
-#define SN_id_it_confirmWaitTime                "id-it-confirmWaitTime"
-#define NID_id_it_confirmWaitTime               311
-#define OBJ_id_it_confirmWaitTime               OBJ_id_it,14L
-
-#define SN_id_it_origPKIMessage         "id-it-origPKIMessage"
-#define NID_id_it_origPKIMessage                312
-#define OBJ_id_it_origPKIMessage                OBJ_id_it,15L
-
-#define SN_id_it_suppLangTags           "id-it-suppLangTags"
-#define NID_id_it_suppLangTags          784
-#define OBJ_id_it_suppLangTags          OBJ_id_it,16L
-
-#define SN_id_it_caCerts                "id-it-caCerts"
-#define NID_id_it_caCerts               1223
-#define OBJ_id_it_caCerts               OBJ_id_it,17L
-
-#define SN_id_it_rootCaKeyUpdate                "id-it-rootCaKeyUpdate"
-#define NID_id_it_rootCaKeyUpdate               1224
-#define OBJ_id_it_rootCaKeyUpdate               OBJ_id_it,18L
-
-#define SN_id_it_certReqTemplate                "id-it-certReqTemplate"
-#define NID_id_it_certReqTemplate               1225
-#define OBJ_id_it_certReqTemplate               OBJ_id_it,19L
-
-#define SN_id_regCtrl           "id-regCtrl"
-#define NID_id_regCtrl          313
-#define OBJ_id_regCtrl          OBJ_id_pkip,1L
+#define LN_safeContentsBag "safeContentsBag"
+#define NID_safeContentsBag 155
+#define OBJ_safeContentsBag OBJ_pkcs12_BagIds, 6L
+
+#define SN_md2 "MD2"
+#define LN_md2 "md2"
+#define NID_md2 3
+#define OBJ_md2 OBJ_rsadsi, 2L, 2L
+
+#define SN_md4 "MD4"
+#define LN_md4 "md4"
+#define NID_md4 257
+#define OBJ_md4 OBJ_rsadsi, 2L, 4L
+
+#define SN_md5 "MD5"
+#define LN_md5 "md5"
+#define NID_md5 4
+#define OBJ_md5 OBJ_rsadsi, 2L, 5L
+
+#define SN_md5_sha1 "MD5-SHA1"
+#define LN_md5_sha1 "md5-sha1"
+#define NID_md5_sha1 114
+
+#define LN_hmacWithMD5 "hmacWithMD5"
+#define NID_hmacWithMD5 797
+#define OBJ_hmacWithMD5 OBJ_rsadsi, 2L, 6L
+
+#define LN_hmacWithSHA1 "hmacWithSHA1"
+#define NID_hmacWithSHA1 163
+#define OBJ_hmacWithSHA1 OBJ_rsadsi, 2L, 7L
+
+#define SN_sm2 "SM2"
+#define LN_sm2 "sm2"
+#define NID_sm2 1172
+#define OBJ_sm2 OBJ_sm_scheme, 301L
+
+#define SN_sm3 "SM3"
+#define LN_sm3 "sm3"
+#define NID_sm3 1143
+#define OBJ_sm3 OBJ_sm_scheme, 401L
+
+#define SN_sm3WithRSAEncryption "RSA-SM3"
+#define LN_sm3WithRSAEncryption "sm3WithRSAEncryption"
+#define NID_sm3WithRSAEncryption 1144
+#define OBJ_sm3WithRSAEncryption OBJ_sm_scheme, 504L
+
+#define SN_SM2_with_SM3 "SM2-SM3"
+#define LN_SM2_with_SM3 "SM2-with-SM3"
+#define NID_SM2_with_SM3 1204
+#define OBJ_SM2_with_SM3 OBJ_sm_scheme, 501L
+
+#define LN_hmacWithSHA224 "hmacWithSHA224"
+#define NID_hmacWithSHA224 798
+#define OBJ_hmacWithSHA224 OBJ_rsadsi, 2L, 8L
+
+#define LN_hmacWithSHA256 "hmacWithSHA256"
+#define NID_hmacWithSHA256 799
+#define OBJ_hmacWithSHA256 OBJ_rsadsi, 2L, 9L
+
+#define LN_hmacWithSHA384 "hmacWithSHA384"
+#define NID_hmacWithSHA384 800
+#define OBJ_hmacWithSHA384 OBJ_rsadsi, 2L, 10L
+
+#define LN_hmacWithSHA512 "hmacWithSHA512"
+#define NID_hmacWithSHA512 801
+#define OBJ_hmacWithSHA512 OBJ_rsadsi, 2L, 11L
+
+#define LN_hmacWithSHA512_224 "hmacWithSHA512-224"
+#define NID_hmacWithSHA512_224 1193
+#define OBJ_hmacWithSHA512_224 OBJ_rsadsi, 2L, 12L
+
+#define LN_hmacWithSHA512_256 "hmacWithSHA512-256"
+#define NID_hmacWithSHA512_256 1194
+#define OBJ_hmacWithSHA512_256 OBJ_rsadsi, 2L, 13L
+
+#define SN_rc2_cbc "RC2-CBC"
+#define LN_rc2_cbc "rc2-cbc"
+#define NID_rc2_cbc 37
+#define OBJ_rc2_cbc OBJ_rsadsi, 3L, 2L
+
+#define SN_rc2_ecb "RC2-ECB"
+#define LN_rc2_ecb "rc2-ecb"
+#define NID_rc2_ecb 38
+
+#define SN_rc2_cfb64 "RC2-CFB"
+#define LN_rc2_cfb64 "rc2-cfb"
+#define NID_rc2_cfb64 39
+
+#define SN_rc2_ofb64 "RC2-OFB"
+#define LN_rc2_ofb64 "rc2-ofb"
+#define NID_rc2_ofb64 40
+
+#define SN_rc2_40_cbc "RC2-40-CBC"
+#define LN_rc2_40_cbc "rc2-40-cbc"
+#define NID_rc2_40_cbc 98
+
+#define SN_rc2_64_cbc "RC2-64-CBC"
+#define LN_rc2_64_cbc "rc2-64-cbc"
+#define NID_rc2_64_cbc 166
+
+#define SN_rc4 "RC4"
+#define LN_rc4 "rc4"
+#define NID_rc4 5
+#define OBJ_rc4 OBJ_rsadsi, 3L, 4L
+
+#define SN_rc4_40 "RC4-40"
+#define LN_rc4_40 "rc4-40"
+#define NID_rc4_40 97
+
+#define SN_des_ede3_cbc "DES-EDE3-CBC"
+#define LN_des_ede3_cbc "des-ede3-cbc"
+#define NID_des_ede3_cbc 44
+#define OBJ_des_ede3_cbc OBJ_rsadsi, 3L, 7L
+
+#define SN_rc5_cbc "RC5-CBC"
+#define LN_rc5_cbc "rc5-cbc"
+#define NID_rc5_cbc 120
+#define OBJ_rc5_cbc OBJ_rsadsi, 3L, 8L
+
+#define SN_rc5_ecb "RC5-ECB"
+#define LN_rc5_ecb "rc5-ecb"
+#define NID_rc5_ecb 121
+
+#define SN_rc5_cfb64 "RC5-CFB"
+#define LN_rc5_cfb64 "rc5-cfb"
+#define NID_rc5_cfb64 122
+
+#define SN_rc5_ofb64 "RC5-OFB"
+#define LN_rc5_ofb64 "rc5-ofb"
+#define NID_rc5_ofb64 123
+
+#define SN_ms_ext_req "msExtReq"
+#define LN_ms_ext_req "Microsoft Extension Request"
+#define NID_ms_ext_req 171
+#define OBJ_ms_ext_req 1L, 3L, 6L, 1L, 4L, 1L, 311L, 2L, 1L, 14L
+
+#define SN_ms_code_ind "msCodeInd"
+#define LN_ms_code_ind "Microsoft Individual Code Signing"
+#define NID_ms_code_ind 134
+#define OBJ_ms_code_ind 1L, 3L, 6L, 1L, 4L, 1L, 311L, 2L, 1L, 21L
+
+#define SN_ms_code_com "msCodeCom"
+#define LN_ms_code_com "Microsoft Commercial Code Signing"
+#define NID_ms_code_com 135
+#define OBJ_ms_code_com 1L, 3L, 6L, 1L, 4L, 1L, 311L, 2L, 1L, 22L
+
+#define SN_ms_ctl_sign "msCTLSign"
+#define LN_ms_ctl_sign "Microsoft Trust List Signing"
+#define NID_ms_ctl_sign 136
+#define OBJ_ms_ctl_sign 1L, 3L, 6L, 1L, 4L, 1L, 311L, 10L, 3L, 1L
+
+#define SN_ms_sgc "msSGC"
+#define LN_ms_sgc "Microsoft Server Gated Crypto"
+#define NID_ms_sgc 137
+#define OBJ_ms_sgc 1L, 3L, 6L, 1L, 4L, 1L, 311L, 10L, 3L, 3L
+
+#define SN_ms_efs "msEFS"
+#define LN_ms_efs "Microsoft Encrypted File System"
+#define NID_ms_efs 138
+#define OBJ_ms_efs 1L, 3L, 6L, 1L, 4L, 1L, 311L, 10L, 3L, 4L
+
+#define SN_ms_smartcard_login "msSmartcardLogin"
+#define LN_ms_smartcard_login "Microsoft Smartcard Login"
+#define NID_ms_smartcard_login 648
+#define OBJ_ms_smartcard_login 1L, 3L, 6L, 1L, 4L, 1L, 311L, 20L, 2L, 2L
+
+#define SN_ms_upn "msUPN"
+#define LN_ms_upn "Microsoft User Principal Name"
+#define NID_ms_upn 649
+#define OBJ_ms_upn 1L, 3L, 6L, 1L, 4L, 1L, 311L, 20L, 2L, 3L
+
+#define SN_idea_cbc "IDEA-CBC"
+#define LN_idea_cbc "idea-cbc"
+#define NID_idea_cbc 34
+#define OBJ_idea_cbc 1L, 3L, 6L, 1L, 4L, 1L, 188L, 7L, 1L, 1L, 2L
+
+#define SN_idea_ecb "IDEA-ECB"
+#define LN_idea_ecb "idea-ecb"
+#define NID_idea_ecb 36
+
+#define SN_idea_cfb64 "IDEA-CFB"
+#define LN_idea_cfb64 "idea-cfb"
+#define NID_idea_cfb64 35
+
+#define SN_idea_ofb64 "IDEA-OFB"
+#define LN_idea_ofb64 "idea-ofb"
+#define NID_idea_ofb64 46
+
+#define SN_bf_cbc "BF-CBC"
+#define LN_bf_cbc "bf-cbc"
+#define NID_bf_cbc 91
+#define OBJ_bf_cbc 1L, 3L, 6L, 1L, 4L, 1L, 3029L, 1L, 2L
+
+#define SN_bf_ecb "BF-ECB"
+#define LN_bf_ecb "bf-ecb"
+#define NID_bf_ecb 92
+
+#define SN_bf_cfb64 "BF-CFB"
+#define LN_bf_cfb64 "bf-cfb"
+#define NID_bf_cfb64 93
+
+#define SN_bf_ofb64 "BF-OFB"
+#define LN_bf_ofb64 "bf-ofb"
+#define NID_bf_ofb64 94
+
+#define SN_id_pkix "PKIX"
+#define NID_id_pkix 127
+#define OBJ_id_pkix 1L, 3L, 6L, 1L, 5L, 5L, 7L
+
+#define SN_id_pkix_mod "id-pkix-mod"
+#define NID_id_pkix_mod 258
+#define OBJ_id_pkix_mod OBJ_id_pkix, 0L
+
+#define SN_id_pe "id-pe"
+#define NID_id_pe 175
+#define OBJ_id_pe OBJ_id_pkix, 1L
+
+#define SN_id_qt "id-qt"
+#define NID_id_qt 259
+#define OBJ_id_qt OBJ_id_pkix, 2L
+
+#define SN_id_kp "id-kp"
+#define NID_id_kp 128
+#define OBJ_id_kp OBJ_id_pkix, 3L
+
+#define SN_id_it "id-it"
+#define NID_id_it 260
+#define OBJ_id_it OBJ_id_pkix, 4L
+
+#define SN_id_pkip "id-pkip"
+#define NID_id_pkip 261
+#define OBJ_id_pkip OBJ_id_pkix, 5L
+
+#define SN_id_alg "id-alg"
+#define NID_id_alg 262
+#define OBJ_id_alg OBJ_id_pkix, 6L
+
+#define SN_id_cmc "id-cmc"
+#define NID_id_cmc 263
+#define OBJ_id_cmc OBJ_id_pkix, 7L
+
+#define SN_id_on "id-on"
+#define NID_id_on 264
+#define OBJ_id_on OBJ_id_pkix, 8L
+
+#define SN_id_pda "id-pda"
+#define NID_id_pda 265
+#define OBJ_id_pda OBJ_id_pkix, 9L
+
+#define SN_id_aca "id-aca"
+#define NID_id_aca 266
+#define OBJ_id_aca OBJ_id_pkix, 10L
+
+#define SN_id_qcs "id-qcs"
+#define NID_id_qcs 267
+#define OBJ_id_qcs OBJ_id_pkix, 11L
+
+#define SN_id_cp "id-cp"
+#define NID_id_cp 1238
+#define OBJ_id_cp OBJ_id_pkix, 14L
+
+#define SN_id_cct "id-cct"
+#define NID_id_cct 268
+#define OBJ_id_cct OBJ_id_pkix, 12L
+
+#define SN_id_ppl "id-ppl"
+#define NID_id_ppl 662
+#define OBJ_id_ppl OBJ_id_pkix, 21L
+
+#define SN_id_ad "id-ad"
+#define NID_id_ad 176
+#define OBJ_id_ad OBJ_id_pkix, 48L
+
+#define SN_id_pkix1_explicit_88 "id-pkix1-explicit-88"
+#define NID_id_pkix1_explicit_88 269
+#define OBJ_id_pkix1_explicit_88 OBJ_id_pkix_mod, 1L
+
+#define SN_id_pkix1_implicit_88 "id-pkix1-implicit-88"
+#define NID_id_pkix1_implicit_88 270
+#define OBJ_id_pkix1_implicit_88 OBJ_id_pkix_mod, 2L
+
+#define SN_id_pkix1_explicit_93 "id-pkix1-explicit-93"
+#define NID_id_pkix1_explicit_93 271
+#define OBJ_id_pkix1_explicit_93 OBJ_id_pkix_mod, 3L
+
+#define SN_id_pkix1_implicit_93 "id-pkix1-implicit-93"
+#define NID_id_pkix1_implicit_93 272
+#define OBJ_id_pkix1_implicit_93 OBJ_id_pkix_mod, 4L
+
+#define SN_id_mod_crmf "id-mod-crmf"
+#define NID_id_mod_crmf 273
+#define OBJ_id_mod_crmf OBJ_id_pkix_mod, 5L
+
+#define SN_id_mod_cmc "id-mod-cmc"
+#define NID_id_mod_cmc 274
+#define OBJ_id_mod_cmc OBJ_id_pkix_mod, 6L
+
+#define SN_id_mod_kea_profile_88 "id-mod-kea-profile-88"
+#define NID_id_mod_kea_profile_88 275
+#define OBJ_id_mod_kea_profile_88 OBJ_id_pkix_mod, 7L
+
+#define SN_id_mod_kea_profile_93 "id-mod-kea-profile-93"
+#define NID_id_mod_kea_profile_93 276
+#define OBJ_id_mod_kea_profile_93 OBJ_id_pkix_mod, 8L
+
+#define SN_id_mod_cmp "id-mod-cmp"
+#define NID_id_mod_cmp 277
+#define OBJ_id_mod_cmp OBJ_id_pkix_mod, 9L
+
+#define SN_id_mod_qualified_cert_88 "id-mod-qualified-cert-88"
+#define NID_id_mod_qualified_cert_88 278
+#define OBJ_id_mod_qualified_cert_88 OBJ_id_pkix_mod, 10L
+
+#define SN_id_mod_qualified_cert_93 "id-mod-qualified-cert-93"
+#define NID_id_mod_qualified_cert_93 279
+#define OBJ_id_mod_qualified_cert_93 OBJ_id_pkix_mod, 11L
+
+#define SN_id_mod_attribute_cert "id-mod-attribute-cert"
+#define NID_id_mod_attribute_cert 280
+#define OBJ_id_mod_attribute_cert OBJ_id_pkix_mod, 12L
+
+#define SN_id_mod_timestamp_protocol "id-mod-timestamp-protocol"
+#define NID_id_mod_timestamp_protocol 281
+#define OBJ_id_mod_timestamp_protocol OBJ_id_pkix_mod, 13L
+
+#define SN_id_mod_ocsp "id-mod-ocsp"
+#define NID_id_mod_ocsp 282
+#define OBJ_id_mod_ocsp OBJ_id_pkix_mod, 14L
+
+#define SN_id_mod_dvcs "id-mod-dvcs"
+#define NID_id_mod_dvcs 283
+#define OBJ_id_mod_dvcs OBJ_id_pkix_mod, 15L
+
+#define SN_id_mod_cmp2000 "id-mod-cmp2000"
+#define NID_id_mod_cmp2000 284
+#define OBJ_id_mod_cmp2000 OBJ_id_pkix_mod, 16L
+
+#define SN_info_access "authorityInfoAccess"
+#define LN_info_access "Authority Information Access"
+#define NID_info_access 177
+#define OBJ_info_access OBJ_id_pe, 1L
+
+#define SN_biometricInfo "biometricInfo"
+#define LN_biometricInfo "Biometric Info"
+#define NID_biometricInfo 285
+#define OBJ_biometricInfo OBJ_id_pe, 2L
+
+#define SN_qcStatements "qcStatements"
+#define NID_qcStatements 286
+#define OBJ_qcStatements OBJ_id_pe, 3L
+
+#define SN_ac_auditEntity "ac-auditEntity"
+#define NID_ac_auditEntity 287
+#define OBJ_ac_auditEntity OBJ_id_pe, 4L
+
+#define SN_ac_targeting "ac-targeting"
+#define NID_ac_targeting 288
+#define OBJ_ac_targeting OBJ_id_pe, 5L
+
+#define SN_aaControls "aaControls"
+#define NID_aaControls 289
+#define OBJ_aaControls OBJ_id_pe, 6L
+
+#define SN_sbgp_ipAddrBlock "sbgp-ipAddrBlock"
+#define NID_sbgp_ipAddrBlock 290
+#define OBJ_sbgp_ipAddrBlock OBJ_id_pe, 7L
+
+#define SN_sbgp_autonomousSysNum "sbgp-autonomousSysNum"
+#define NID_sbgp_autonomousSysNum 291
+#define OBJ_sbgp_autonomousSysNum OBJ_id_pe, 8L
+
+#define SN_sbgp_routerIdentifier "sbgp-routerIdentifier"
+#define NID_sbgp_routerIdentifier 292
+#define OBJ_sbgp_routerIdentifier OBJ_id_pe, 9L
+
+#define SN_ac_proxying "ac-proxying"
+#define NID_ac_proxying 397
+#define OBJ_ac_proxying OBJ_id_pe, 10L
+
+#define SN_sinfo_access "subjectInfoAccess"
+#define LN_sinfo_access "Subject Information Access"
+#define NID_sinfo_access 398
+#define OBJ_sinfo_access OBJ_id_pe, 11L
+
+#define SN_proxyCertInfo "proxyCertInfo"
+#define LN_proxyCertInfo "Proxy Certificate Information"
+#define NID_proxyCertInfo 663
+#define OBJ_proxyCertInfo OBJ_id_pe, 14L
+
+#define SN_tlsfeature "tlsfeature"
+#define LN_tlsfeature "TLS Feature"
+#define NID_tlsfeature 1020
+#define OBJ_tlsfeature OBJ_id_pe, 24L
+
+#define SN_sbgp_ipAddrBlockv2 "sbgp-ipAddrBlockv2"
+#define NID_sbgp_ipAddrBlockv2 1239
+#define OBJ_sbgp_ipAddrBlockv2 OBJ_id_pe, 28L
+
+#define SN_sbgp_autonomousSysNumv2 "sbgp-autonomousSysNumv2"
+#define NID_sbgp_autonomousSysNumv2 1240
+#define OBJ_sbgp_autonomousSysNumv2 OBJ_id_pe, 29L
+
+#define SN_id_qt_cps "id-qt-cps"
+#define LN_id_qt_cps "Policy Qualifier CPS"
+#define NID_id_qt_cps 164
+#define OBJ_id_qt_cps OBJ_id_qt, 1L
+
+#define SN_id_qt_unotice "id-qt-unotice"
+#define LN_id_qt_unotice "Policy Qualifier User Notice"
+#define NID_id_qt_unotice 165
+#define OBJ_id_qt_unotice OBJ_id_qt, 2L
+
+#define SN_textNotice "textNotice"
+#define NID_textNotice 293
+#define OBJ_textNotice OBJ_id_qt, 3L
+
+#define SN_server_auth "serverAuth"
+#define LN_server_auth "TLS Web Server Authentication"
+#define NID_server_auth 129
+#define OBJ_server_auth OBJ_id_kp, 1L
+
+#define SN_client_auth "clientAuth"
+#define LN_client_auth "TLS Web Client Authentication"
+#define NID_client_auth 130
+#define OBJ_client_auth OBJ_id_kp, 2L
+
+#define SN_code_sign "codeSigning"
+#define LN_code_sign "Code Signing"
+#define NID_code_sign 131
+#define OBJ_code_sign OBJ_id_kp, 3L
+
+#define SN_email_protect "emailProtection"
+#define LN_email_protect "E-mail Protection"
+#define NID_email_protect 132
+#define OBJ_email_protect OBJ_id_kp, 4L
+
+#define SN_ipsecEndSystem "ipsecEndSystem"
+#define LN_ipsecEndSystem "IPSec End System"
+#define NID_ipsecEndSystem 294
+#define OBJ_ipsecEndSystem OBJ_id_kp, 5L
+
+#define SN_ipsecTunnel "ipsecTunnel"
+#define LN_ipsecTunnel "IPSec Tunnel"
+#define NID_ipsecTunnel 295
+#define OBJ_ipsecTunnel OBJ_id_kp, 6L
+
+#define SN_ipsecUser "ipsecUser"
+#define LN_ipsecUser "IPSec User"
+#define NID_ipsecUser 296
+#define OBJ_ipsecUser OBJ_id_kp, 7L
+
+#define SN_time_stamp "timeStamping"
+#define LN_time_stamp "Time Stamping"
+#define NID_time_stamp 133
+#define OBJ_time_stamp OBJ_id_kp, 8L
+
+#define SN_OCSP_sign "OCSPSigning"
+#define LN_OCSP_sign "OCSP Signing"
+#define NID_OCSP_sign 180
+#define OBJ_OCSP_sign OBJ_id_kp, 9L
+
+#define SN_dvcs "DVCS"
+#define LN_dvcs "dvcs"
+#define NID_dvcs 297
+#define OBJ_dvcs OBJ_id_kp, 10L
+
+#define SN_ipsec_IKE "ipsecIKE"
+#define LN_ipsec_IKE "ipsec Internet Key Exchange"
+#define NID_ipsec_IKE 1022
+#define OBJ_ipsec_IKE OBJ_id_kp, 17L
+
+#define SN_capwapAC "capwapAC"
+#define LN_capwapAC "Ctrl/provision WAP Access"
+#define NID_capwapAC 1023
+#define OBJ_capwapAC OBJ_id_kp, 18L
+
+#define SN_capwapWTP "capwapWTP"
+#define LN_capwapWTP "Ctrl/Provision WAP Termination"
+#define NID_capwapWTP 1024
+#define OBJ_capwapWTP OBJ_id_kp, 19L
+
+#define SN_sshClient "secureShellClient"
+#define LN_sshClient "SSH Client"
+#define NID_sshClient 1025
+#define OBJ_sshClient OBJ_id_kp, 21L
+
+#define SN_sshServer "secureShellServer"
+#define LN_sshServer "SSH Server"
+#define NID_sshServer 1026
+#define OBJ_sshServer OBJ_id_kp, 22L
+
+#define SN_sendRouter "sendRouter"
+#define LN_sendRouter "Send Router"
+#define NID_sendRouter 1027
+#define OBJ_sendRouter OBJ_id_kp, 23L
+
+#define SN_sendProxiedRouter "sendProxiedRouter"
+#define LN_sendProxiedRouter "Send Proxied Router"
+#define NID_sendProxiedRouter 1028
+#define OBJ_sendProxiedRouter OBJ_id_kp, 24L
+
+#define SN_sendOwner "sendOwner"
+#define LN_sendOwner "Send Owner"
+#define NID_sendOwner 1029
+#define OBJ_sendOwner OBJ_id_kp, 25L
+
+#define SN_sendProxiedOwner "sendProxiedOwner"
+#define LN_sendProxiedOwner "Send Proxied Owner"
+#define NID_sendProxiedOwner 1030
+#define OBJ_sendProxiedOwner OBJ_id_kp, 26L
+
+#define SN_cmcCA "cmcCA"
+#define LN_cmcCA "CMC Certificate Authority"
+#define NID_cmcCA 1131
+#define OBJ_cmcCA OBJ_id_kp, 27L
+
+#define SN_cmcRA "cmcRA"
+#define LN_cmcRA "CMC Registration Authority"
+#define NID_cmcRA 1132
+#define OBJ_cmcRA OBJ_id_kp, 28L
+
+#define SN_cmcArchive "cmcArchive"
+#define LN_cmcArchive "CMC Archive Server"
+#define NID_cmcArchive 1219
+#define OBJ_cmcArchive OBJ_id_kp, 29L
+
+#define SN_id_kp_bgpsec_router "id-kp-bgpsec-router"
+#define LN_id_kp_bgpsec_router "BGPsec Router"
+#define NID_id_kp_bgpsec_router 1220
+#define OBJ_id_kp_bgpsec_router OBJ_id_kp, 30L
+
+#define SN_id_kp_BrandIndicatorforMessageIdentification "id-kp-BrandIndicatorforMessageIdentification"
+#define LN_id_kp_BrandIndicatorforMessageIdentification "Brand Indicator for Message Identification"
+#define NID_id_kp_BrandIndicatorforMessageIdentification 1221
+#define OBJ_id_kp_BrandIndicatorforMessageIdentification OBJ_id_kp, 31L
+
+#define SN_cmKGA "cmKGA"
+#define LN_cmKGA "Certificate Management Key Generation Authority"
+#define NID_cmKGA 1222
+#define OBJ_cmKGA OBJ_id_kp, 32L
+
+#define SN_id_it_caProtEncCert "id-it-caProtEncCert"
+#define NID_id_it_caProtEncCert 298
+#define OBJ_id_it_caProtEncCert OBJ_id_it, 1L
+
+#define SN_id_it_signKeyPairTypes "id-it-signKeyPairTypes"
+#define NID_id_it_signKeyPairTypes 299
+#define OBJ_id_it_signKeyPairTypes OBJ_id_it, 2L
+
+#define SN_id_it_encKeyPairTypes "id-it-encKeyPairTypes"
+#define NID_id_it_encKeyPairTypes 300
+#define OBJ_id_it_encKeyPairTypes OBJ_id_it, 3L
+
+#define SN_id_it_preferredSymmAlg "id-it-preferredSymmAlg"
+#define NID_id_it_preferredSymmAlg 301
+#define OBJ_id_it_preferredSymmAlg OBJ_id_it, 4L
+
+#define SN_id_it_caKeyUpdateInfo "id-it-caKeyUpdateInfo"
+#define NID_id_it_caKeyUpdateInfo 302
+#define OBJ_id_it_caKeyUpdateInfo OBJ_id_it, 5L
+
+#define SN_id_it_currentCRL "id-it-currentCRL"
+#define NID_id_it_currentCRL 303
+#define OBJ_id_it_currentCRL OBJ_id_it, 6L
+
+#define SN_id_it_unsupportedOIDs "id-it-unsupportedOIDs"
+#define NID_id_it_unsupportedOIDs 304
+#define OBJ_id_it_unsupportedOIDs OBJ_id_it, 7L
+
+#define SN_id_it_subscriptionRequest "id-it-subscriptionRequest"
+#define NID_id_it_subscriptionRequest 305
+#define OBJ_id_it_subscriptionRequest OBJ_id_it, 8L
+
+#define SN_id_it_subscriptionResponse "id-it-subscriptionResponse"
+#define NID_id_it_subscriptionResponse 306
+#define OBJ_id_it_subscriptionResponse OBJ_id_it, 9L
+
+#define SN_id_it_keyPairParamReq "id-it-keyPairParamReq"
+#define NID_id_it_keyPairParamReq 307
+#define OBJ_id_it_keyPairParamReq OBJ_id_it, 10L
+
+#define SN_id_it_keyPairParamRep "id-it-keyPairParamRep"
+#define NID_id_it_keyPairParamRep 308
+#define OBJ_id_it_keyPairParamRep OBJ_id_it, 11L
+
+#define SN_id_it_revPassphrase "id-it-revPassphrase"
+#define NID_id_it_revPassphrase 309
+#define OBJ_id_it_revPassphrase OBJ_id_it, 12L
+
+#define SN_id_it_implicitConfirm "id-it-implicitConfirm"
+#define NID_id_it_implicitConfirm 310
+#define OBJ_id_it_implicitConfirm OBJ_id_it, 13L
+
+#define SN_id_it_confirmWaitTime "id-it-confirmWaitTime"
+#define NID_id_it_confirmWaitTime 311
+#define OBJ_id_it_confirmWaitTime OBJ_id_it, 14L
+
+#define SN_id_it_origPKIMessage "id-it-origPKIMessage"
+#define NID_id_it_origPKIMessage 312
+#define OBJ_id_it_origPKIMessage OBJ_id_it, 15L
+
+#define SN_id_it_suppLangTags "id-it-suppLangTags"
+#define NID_id_it_suppLangTags 784
+#define OBJ_id_it_suppLangTags OBJ_id_it, 16L
+
+#define SN_id_it_caCerts "id-it-caCerts"
+#define NID_id_it_caCerts 1223
+#define OBJ_id_it_caCerts OBJ_id_it, 17L
+
+#define SN_id_it_rootCaKeyUpdate "id-it-rootCaKeyUpdate"
+#define NID_id_it_rootCaKeyUpdate 1224
+#define OBJ_id_it_rootCaKeyUpdate OBJ_id_it, 18L
+
+#define SN_id_it_certReqTemplate "id-it-certReqTemplate"
+#define NID_id_it_certReqTemplate 1225
+#define OBJ_id_it_certReqTemplate OBJ_id_it, 19L
+
+#define SN_id_regCtrl "id-regCtrl"
+#define NID_id_regCtrl 313
+#define OBJ_id_regCtrl OBJ_id_pkip, 1L
 
-#define SN_id_regInfo           "id-regInfo"
-#define NID_id_regInfo          314
-#define OBJ_id_regInfo          OBJ_id_pkip,2L
+#define SN_id_regInfo "id-regInfo"
+#define NID_id_regInfo 314
+#define OBJ_id_regInfo OBJ_id_pkip, 2L
 
-#define SN_id_regCtrl_regToken          "id-regCtrl-regToken"
-#define NID_id_regCtrl_regToken         315
-#define OBJ_id_regCtrl_regToken         OBJ_id_regCtrl,1L
+#define SN_id_regCtrl_regToken "id-regCtrl-regToken"
+#define NID_id_regCtrl_regToken 315
+#define OBJ_id_regCtrl_regToken OBJ_id_regCtrl, 1L
 
-#define SN_id_regCtrl_authenticator             "id-regCtrl-authenticator"
-#define NID_id_regCtrl_authenticator            316
-#define OBJ_id_regCtrl_authenticator            OBJ_id_regCtrl,2L
+#define SN_id_regCtrl_authenticator "id-regCtrl-authenticator"
+#define NID_id_regCtrl_authenticator 316
+#define OBJ_id_regCtrl_authenticator OBJ_id_regCtrl, 2L
 
-#define SN_id_regCtrl_pkiPublicationInfo                "id-regCtrl-pkiPublicationInfo"
-#define NID_id_regCtrl_pkiPublicationInfo               317
-#define OBJ_id_regCtrl_pkiPublicationInfo               OBJ_id_regCtrl,3L
+#define SN_id_regCtrl_pkiPublicationInfo "id-regCtrl-pkiPublicationInfo"
+#define NID_id_regCtrl_pkiPublicationInfo 317
+#define OBJ_id_regCtrl_pkiPublicationInfo OBJ_id_regCtrl, 3L
 
-#define SN_id_regCtrl_pkiArchiveOptions         "id-regCtrl-pkiArchiveOptions"
-#define NID_id_regCtrl_pkiArchiveOptions                318
-#define OBJ_id_regCtrl_pkiArchiveOptions                OBJ_id_regCtrl,4L
+#define SN_id_regCtrl_pkiArchiveOptions "id-regCtrl-pkiArchiveOptions"
+#define NID_id_regCtrl_pkiArchiveOptions 318
+#define OBJ_id_regCtrl_pkiArchiveOptions OBJ_id_regCtrl, 4L
 
-#define SN_id_regCtrl_oldCertID         "id-regCtrl-oldCertID"
-#define NID_id_regCtrl_oldCertID                319
-#define OBJ_id_regCtrl_oldCertID                OBJ_id_regCtrl,5L
+#define SN_id_regCtrl_oldCertID "id-regCtrl-oldCertID"
+#define NID_id_regCtrl_oldCertID 319
+#define OBJ_id_regCtrl_oldCertID OBJ_id_regCtrl, 5L
 
-#define SN_id_regCtrl_protocolEncrKey           "id-regCtrl-protocolEncrKey"
-#define NID_id_regCtrl_protocolEncrKey          320
-#define OBJ_id_regCtrl_protocolEncrKey          OBJ_id_regCtrl,6L
+#define SN_id_regCtrl_protocolEncrKey "id-regCtrl-protocolEncrKey"
+#define NID_id_regCtrl_protocolEncrKey 320
+#define OBJ_id_regCtrl_protocolEncrKey OBJ_id_regCtrl, 6L
 
-#define SN_id_regInfo_utf8Pairs         "id-regInfo-utf8Pairs"
-#define NID_id_regInfo_utf8Pairs                321
-#define OBJ_id_regInfo_utf8Pairs                OBJ_id_regInfo,1L
+#define SN_id_regInfo_utf8Pairs "id-regInfo-utf8Pairs"
+#define NID_id_regInfo_utf8Pairs 321
+#define OBJ_id_regInfo_utf8Pairs OBJ_id_regInfo, 1L
 
-#define SN_id_regInfo_certReq           "id-regInfo-certReq"
-#define NID_id_regInfo_certReq          322
-#define OBJ_id_regInfo_certReq          OBJ_id_regInfo,2L
+#define SN_id_regInfo_certReq "id-regInfo-certReq"
+#define NID_id_regInfo_certReq 322
+#define OBJ_id_regInfo_certReq OBJ_id_regInfo, 2L
 
-#define SN_id_alg_des40         "id-alg-des40"
-#define NID_id_alg_des40                323
-#define OBJ_id_alg_des40                OBJ_id_alg,1L
+#define SN_id_alg_des40 "id-alg-des40"
+#define NID_id_alg_des40 323
+#define OBJ_id_alg_des40 OBJ_id_alg, 1L
 
-#define SN_id_alg_noSignature           "id-alg-noSignature"
-#define NID_id_alg_noSignature          324
-#define OBJ_id_alg_noSignature          OBJ_id_alg,2L
+#define SN_id_alg_noSignature "id-alg-noSignature"
+#define NID_id_alg_noSignature 324
+#define OBJ_id_alg_noSignature OBJ_id_alg, 2L
 
-#define SN_id_alg_dh_sig_hmac_sha1              "id-alg-dh-sig-hmac-sha1"
-#define NID_id_alg_dh_sig_hmac_sha1             325
-#define OBJ_id_alg_dh_sig_hmac_sha1             OBJ_id_alg,3L
+#define SN_id_alg_dh_sig_hmac_sha1 "id-alg-dh-sig-hmac-sha1"
+#define NID_id_alg_dh_sig_hmac_sha1 325
+#define OBJ_id_alg_dh_sig_hmac_sha1 OBJ_id_alg, 3L
 
-#define SN_id_alg_dh_pop                "id-alg-dh-pop"
-#define NID_id_alg_dh_pop               326
-#define OBJ_id_alg_dh_pop               OBJ_id_alg,4L
+#define SN_id_alg_dh_pop "id-alg-dh-pop"
+#define NID_id_alg_dh_pop 326
+#define OBJ_id_alg_dh_pop OBJ_id_alg, 4L
 
-#define SN_id_cmc_statusInfo            "id-cmc-statusInfo"
-#define NID_id_cmc_statusInfo           327
-#define OBJ_id_cmc_statusInfo           OBJ_id_cmc,1L
+#define SN_id_cmc_statusInfo "id-cmc-statusInfo"
+#define NID_id_cmc_statusInfo 327
+#define OBJ_id_cmc_statusInfo OBJ_id_cmc, 1L
 
-#define SN_id_cmc_identification                "id-cmc-identification"
-#define NID_id_cmc_identification               328
-#define OBJ_id_cmc_identification               OBJ_id_cmc,2L
-
-#define SN_id_cmc_identityProof         "id-cmc-identityProof"
-#define NID_id_cmc_identityProof                329
-#define OBJ_id_cmc_identityProof                OBJ_id_cmc,3L
-
-#define SN_id_cmc_dataReturn            "id-cmc-dataReturn"
-#define NID_id_cmc_dataReturn           330
-#define OBJ_id_cmc_dataReturn           OBJ_id_cmc,4L
-
-#define SN_id_cmc_transactionId         "id-cmc-transactionId"
-#define NID_id_cmc_transactionId                331
-#define OBJ_id_cmc_transactionId                OBJ_id_cmc,5L
-
-#define SN_id_cmc_senderNonce           "id-cmc-senderNonce"
-#define NID_id_cmc_senderNonce          332
-#define OBJ_id_cmc_senderNonce          OBJ_id_cmc,6L
-
-#define SN_id_cmc_recipientNonce                "id-cmc-recipientNonce"
-#define NID_id_cmc_recipientNonce               333
-#define OBJ_id_cmc_recipientNonce               OBJ_id_cmc,7L
-
-#define SN_id_cmc_addExtensions         "id-cmc-addExtensions"
-#define NID_id_cmc_addExtensions                334
-#define OBJ_id_cmc_addExtensions                OBJ_id_cmc,8L
-
-#define SN_id_cmc_encryptedPOP          "id-cmc-encryptedPOP"
-#define NID_id_cmc_encryptedPOP         335
-#define OBJ_id_cmc_encryptedPOP         OBJ_id_cmc,9L
-
-#define SN_id_cmc_decryptedPOP          "id-cmc-decryptedPOP"
-#define NID_id_cmc_decryptedPOP         336
-#define OBJ_id_cmc_decryptedPOP         OBJ_id_cmc,10L
-
-#define SN_id_cmc_lraPOPWitness         "id-cmc-lraPOPWitness"
-#define NID_id_cmc_lraPOPWitness                337
-#define OBJ_id_cmc_lraPOPWitness                OBJ_id_cmc,11L
-
-#define SN_id_cmc_getCert               "id-cmc-getCert"
-#define NID_id_cmc_getCert              338
-#define OBJ_id_cmc_getCert              OBJ_id_cmc,15L
-
-#define SN_id_cmc_getCRL                "id-cmc-getCRL"
-#define NID_id_cmc_getCRL               339
-#define OBJ_id_cmc_getCRL               OBJ_id_cmc,16L
-
-#define SN_id_cmc_revokeRequest         "id-cmc-revokeRequest"
-#define NID_id_cmc_revokeRequest                340
-#define OBJ_id_cmc_revokeRequest                OBJ_id_cmc,17L
-
-#define SN_id_cmc_regInfo               "id-cmc-regInfo"
-#define NID_id_cmc_regInfo              341
-#define OBJ_id_cmc_regInfo              OBJ_id_cmc,18L
-
-#define SN_id_cmc_responseInfo          "id-cmc-responseInfo"
-#define NID_id_cmc_responseInfo         342
-#define OBJ_id_cmc_responseInfo         OBJ_id_cmc,19L
-
-#define SN_id_cmc_queryPending          "id-cmc-queryPending"
-#define NID_id_cmc_queryPending         343
-#define OBJ_id_cmc_queryPending         OBJ_id_cmc,21L
-
-#define SN_id_cmc_popLinkRandom         "id-cmc-popLinkRandom"
-#define NID_id_cmc_popLinkRandom                344
-#define OBJ_id_cmc_popLinkRandom                OBJ_id_cmc,22L
-
-#define SN_id_cmc_popLinkWitness                "id-cmc-popLinkWitness"
-#define NID_id_cmc_popLinkWitness               345
-#define OBJ_id_cmc_popLinkWitness               OBJ_id_cmc,23L
-
-#define SN_id_cmc_confirmCertAcceptance         "id-cmc-confirmCertAcceptance"
-#define NID_id_cmc_confirmCertAcceptance                346
-#define OBJ_id_cmc_confirmCertAcceptance                OBJ_id_cmc,24L
-
-#define SN_id_on_personalData           "id-on-personalData"
-#define NID_id_on_personalData          347
-#define OBJ_id_on_personalData          OBJ_id_on,1L
-
-#define SN_id_on_permanentIdentifier            "id-on-permanentIdentifier"
-#define LN_id_on_permanentIdentifier            "Permanent Identifier"
-#define NID_id_on_permanentIdentifier           858
-#define OBJ_id_on_permanentIdentifier           OBJ_id_on,3L
-
-#define SN_XmppAddr             "id-on-xmppAddr"
-#define LN_XmppAddr             "XmppAddr"
-#define NID_XmppAddr            1209
-#define OBJ_XmppAddr            OBJ_id_on,5L
-
-#define SN_SRVName              "id-on-dnsSRV"
-#define LN_SRVName              "SRVName"
-#define NID_SRVName             1210
-#define OBJ_SRVName             OBJ_id_on,7L
-
-#define SN_NAIRealm             "id-on-NAIRealm"
-#define LN_NAIRealm             "NAIRealm"
-#define NID_NAIRealm            1211
-#define OBJ_NAIRealm            OBJ_id_on,8L
-
-#define SN_id_on_SmtpUTF8Mailbox                "id-on-SmtpUTF8Mailbox"
-#define LN_id_on_SmtpUTF8Mailbox                "Smtp UTF8 Mailbox"
-#define NID_id_on_SmtpUTF8Mailbox               1208
-#define OBJ_id_on_SmtpUTF8Mailbox               OBJ_id_on,9L
-
-#define SN_id_pda_dateOfBirth           "id-pda-dateOfBirth"
-#define NID_id_pda_dateOfBirth          348
-#define OBJ_id_pda_dateOfBirth          OBJ_id_pda,1L
-
-#define SN_id_pda_placeOfBirth          "id-pda-placeOfBirth"
-#define NID_id_pda_placeOfBirth         349
-#define OBJ_id_pda_placeOfBirth         OBJ_id_pda,2L
-
-#define SN_id_pda_gender                "id-pda-gender"
-#define NID_id_pda_gender               351
-#define OBJ_id_pda_gender               OBJ_id_pda,3L
-
-#define SN_id_pda_countryOfCitizenship          "id-pda-countryOfCitizenship"
-#define NID_id_pda_countryOfCitizenship         352
-#define OBJ_id_pda_countryOfCitizenship         OBJ_id_pda,4L
-
-#define SN_id_pda_countryOfResidence            "id-pda-countryOfResidence"
-#define NID_id_pda_countryOfResidence           353
-#define OBJ_id_pda_countryOfResidence           OBJ_id_pda,5L
-
-#define SN_id_aca_authenticationInfo            "id-aca-authenticationInfo"
-#define NID_id_aca_authenticationInfo           354
-#define OBJ_id_aca_authenticationInfo           OBJ_id_aca,1L
-
-#define SN_id_aca_accessIdentity                "id-aca-accessIdentity"
-#define NID_id_aca_accessIdentity               355
-#define OBJ_id_aca_accessIdentity               OBJ_id_aca,2L
-
-#define SN_id_aca_chargingIdentity              "id-aca-chargingIdentity"
-#define NID_id_aca_chargingIdentity             356
-#define OBJ_id_aca_chargingIdentity             OBJ_id_aca,3L
-
-#define SN_id_aca_group         "id-aca-group"
-#define NID_id_aca_group                357
-#define OBJ_id_aca_group                OBJ_id_aca,4L
-
-#define SN_id_aca_role          "id-aca-role"
-#define NID_id_aca_role         358
-#define OBJ_id_aca_role         OBJ_id_aca,5L
-
-#define SN_id_aca_encAttrs              "id-aca-encAttrs"
-#define NID_id_aca_encAttrs             399
-#define OBJ_id_aca_encAttrs             OBJ_id_aca,6L
-
-#define SN_id_qcs_pkixQCSyntax_v1               "id-qcs-pkixQCSyntax-v1"
-#define NID_id_qcs_pkixQCSyntax_v1              359
-#define OBJ_id_qcs_pkixQCSyntax_v1              OBJ_id_qcs,1L
-
-#define SN_ipAddr_asNumber              "ipAddr-asNumber"
-#define NID_ipAddr_asNumber             1241
-#define OBJ_ipAddr_asNumber             OBJ_id_cp,2L
-
-#define SN_ipAddr_asNumberv2            "ipAddr-asNumberv2"
-#define NID_ipAddr_asNumberv2           1242
-#define OBJ_ipAddr_asNumberv2           OBJ_id_cp,3L
-
-#define SN_id_cct_crs           "id-cct-crs"
-#define NID_id_cct_crs          360
-#define OBJ_id_cct_crs          OBJ_id_cct,1L
-
-#define SN_id_cct_PKIData               "id-cct-PKIData"
-#define NID_id_cct_PKIData              361
-#define OBJ_id_cct_PKIData              OBJ_id_cct,2L
-
-#define SN_id_cct_PKIResponse           "id-cct-PKIResponse"
-#define NID_id_cct_PKIResponse          362
-#define OBJ_id_cct_PKIResponse          OBJ_id_cct,3L
-
-#define SN_id_ppl_anyLanguage           "id-ppl-anyLanguage"
-#define LN_id_ppl_anyLanguage           "Any language"
-#define NID_id_ppl_anyLanguage          664
-#define OBJ_id_ppl_anyLanguage          OBJ_id_ppl,0L
-
-#define SN_id_ppl_inheritAll            "id-ppl-inheritAll"
-#define LN_id_ppl_inheritAll            "Inherit all"
-#define NID_id_ppl_inheritAll           665
-#define OBJ_id_ppl_inheritAll           OBJ_id_ppl,1L
-
-#define SN_Independent          "id-ppl-independent"
-#define LN_Independent          "Independent"
-#define NID_Independent         667
-#define OBJ_Independent         OBJ_id_ppl,2L
-
-#define SN_ad_OCSP              "OCSP"
-#define LN_ad_OCSP              "OCSP"
-#define NID_ad_OCSP             178
-#define OBJ_ad_OCSP             OBJ_id_ad,1L
-
-#define SN_ad_ca_issuers                "caIssuers"
-#define LN_ad_ca_issuers                "CA Issuers"
-#define NID_ad_ca_issuers               179
-#define OBJ_ad_ca_issuers               OBJ_id_ad,2L
-
-#define SN_ad_timeStamping              "ad_timestamping"
-#define LN_ad_timeStamping              "AD Time Stamping"
-#define NID_ad_timeStamping             363
-#define OBJ_ad_timeStamping             OBJ_id_ad,3L
-
-#define SN_ad_dvcs              "AD_DVCS"
-#define LN_ad_dvcs              "ad dvcs"
-#define NID_ad_dvcs             364
-#define OBJ_ad_dvcs             OBJ_id_ad,4L
-
-#define SN_caRepository         "caRepository"
-#define LN_caRepository         "CA Repository"
-#define NID_caRepository                785
-#define OBJ_caRepository                OBJ_id_ad,5L
-
-#define SN_rpkiManifest         "rpkiManifest"
-#define LN_rpkiManifest         "RPKI Manifest"
-#define NID_rpkiManifest                1243
-#define OBJ_rpkiManifest                OBJ_id_ad,10L
-
-#define SN_signedObject         "signedObject"
-#define LN_signedObject         "Signed Object"
-#define NID_signedObject                1244
-#define OBJ_signedObject                OBJ_id_ad,11L
-
-#define SN_rpkiNotify           "rpkiNotify"
-#define LN_rpkiNotify           "RPKI Notify"
-#define NID_rpkiNotify          1245
-#define OBJ_rpkiNotify          OBJ_id_ad,13L
-
-#define OBJ_id_pkix_OCSP                OBJ_ad_OCSP
-
-#define SN_id_pkix_OCSP_basic           "basicOCSPResponse"
-#define LN_id_pkix_OCSP_basic           "Basic OCSP Response"
-#define NID_id_pkix_OCSP_basic          365
-#define OBJ_id_pkix_OCSP_basic          OBJ_id_pkix_OCSP,1L
-
-#define SN_id_pkix_OCSP_Nonce           "Nonce"
-#define LN_id_pkix_OCSP_Nonce           "OCSP Nonce"
-#define NID_id_pkix_OCSP_Nonce          366
-#define OBJ_id_pkix_OCSP_Nonce          OBJ_id_pkix_OCSP,2L
-
-#define SN_id_pkix_OCSP_CrlID           "CrlID"
-#define LN_id_pkix_OCSP_CrlID           "OCSP CRL ID"
-#define NID_id_pkix_OCSP_CrlID          367
-#define OBJ_id_pkix_OCSP_CrlID          OBJ_id_pkix_OCSP,3L
-
-#define SN_id_pkix_OCSP_acceptableResponses             "acceptableResponses"
-#define LN_id_pkix_OCSP_acceptableResponses             "Acceptable OCSP Responses"
-#define NID_id_pkix_OCSP_acceptableResponses            368
-#define OBJ_id_pkix_OCSP_acceptableResponses            OBJ_id_pkix_OCSP,4L
-
-#define SN_id_pkix_OCSP_noCheck         "noCheck"
-#define LN_id_pkix_OCSP_noCheck         "OCSP No Check"
-#define NID_id_pkix_OCSP_noCheck                369
-#define OBJ_id_pkix_OCSP_noCheck                OBJ_id_pkix_OCSP,5L
-
-#define SN_id_pkix_OCSP_archiveCutoff           "archiveCutoff"
-#define LN_id_pkix_OCSP_archiveCutoff           "OCSP Archive Cutoff"
-#define NID_id_pkix_OCSP_archiveCutoff          370
-#define OBJ_id_pkix_OCSP_archiveCutoff          OBJ_id_pkix_OCSP,6L
-
-#define SN_id_pkix_OCSP_serviceLocator          "serviceLocator"
-#define LN_id_pkix_OCSP_serviceLocator          "OCSP Service Locator"
-#define NID_id_pkix_OCSP_serviceLocator         371
-#define OBJ_id_pkix_OCSP_serviceLocator         OBJ_id_pkix_OCSP,7L
-
-#define SN_id_pkix_OCSP_extendedStatus          "extendedStatus"
-#define LN_id_pkix_OCSP_extendedStatus          "Extended OCSP Status"
-#define NID_id_pkix_OCSP_extendedStatus         372
-#define OBJ_id_pkix_OCSP_extendedStatus         OBJ_id_pkix_OCSP,8L
-
-#define SN_id_pkix_OCSP_valid           "valid"
-#define NID_id_pkix_OCSP_valid          373
-#define OBJ_id_pkix_OCSP_valid          OBJ_id_pkix_OCSP,9L
-
-#define SN_id_pkix_OCSP_path            "path"
-#define NID_id_pkix_OCSP_path           374
-#define OBJ_id_pkix_OCSP_path           OBJ_id_pkix_OCSP,10L
-
-#define SN_id_pkix_OCSP_trustRoot               "trustRoot"
-#define LN_id_pkix_OCSP_trustRoot               "Trust Root"
-#define NID_id_pkix_OCSP_trustRoot              375
-#define OBJ_id_pkix_OCSP_trustRoot              OBJ_id_pkix_OCSP,11L
-
-#define SN_algorithm            "algorithm"
-#define LN_algorithm            "algorithm"
-#define NID_algorithm           376
-#define OBJ_algorithm           1L,3L,14L,3L,2L
-
-#define SN_md5WithRSA           "RSA-NP-MD5"
-#define LN_md5WithRSA           "md5WithRSA"
-#define NID_md5WithRSA          104
-#define OBJ_md5WithRSA          OBJ_algorithm,3L
-
-#define SN_des_ecb              "DES-ECB"
-#define LN_des_ecb              "des-ecb"
-#define NID_des_ecb             29
-#define OBJ_des_ecb             OBJ_algorithm,6L
-
-#define SN_des_cbc              "DES-CBC"
-#define LN_des_cbc              "des-cbc"
-#define NID_des_cbc             31
-#define OBJ_des_cbc             OBJ_algorithm,7L
-
-#define SN_des_ofb64            "DES-OFB"
-#define LN_des_ofb64            "des-ofb"
-#define NID_des_ofb64           45
-#define OBJ_des_ofb64           OBJ_algorithm,8L
-
-#define SN_des_cfb64            "DES-CFB"
-#define LN_des_cfb64            "des-cfb"
-#define NID_des_cfb64           30
-#define OBJ_des_cfb64           OBJ_algorithm,9L
-
-#define SN_rsaSignature         "rsaSignature"
-#define NID_rsaSignature                377
-#define OBJ_rsaSignature                OBJ_algorithm,11L
-
-#define SN_dsa_2                "DSA-old"
-#define LN_dsa_2                "dsaEncryption-old"
-#define NID_dsa_2               67
-#define OBJ_dsa_2               OBJ_algorithm,12L
-
-#define SN_dsaWithSHA           "DSA-SHA"
-#define LN_dsaWithSHA           "dsaWithSHA"
-#define NID_dsaWithSHA          66
-#define OBJ_dsaWithSHA          OBJ_algorithm,13L
-
-#define SN_shaWithRSAEncryption         "RSA-SHA"
-#define LN_shaWithRSAEncryption         "shaWithRSAEncryption"
-#define NID_shaWithRSAEncryption                42
-#define OBJ_shaWithRSAEncryption                OBJ_algorithm,15L
-
-#define SN_des_ede_ecb          "DES-EDE"
-#define LN_des_ede_ecb          "des-ede"
-#define NID_des_ede_ecb         32
-#define OBJ_des_ede_ecb         OBJ_algorithm,17L
-
-#define SN_des_ede3_ecb         "DES-EDE3"
-#define LN_des_ede3_ecb         "des-ede3"
-#define NID_des_ede3_ecb                33
-
-#define SN_des_ede_cbc          "DES-EDE-CBC"
-#define LN_des_ede_cbc          "des-ede-cbc"
-#define NID_des_ede_cbc         43
-
-#define SN_des_ede_cfb64                "DES-EDE-CFB"
-#define LN_des_ede_cfb64                "des-ede-cfb"
-#define NID_des_ede_cfb64               60
-
-#define SN_des_ede3_cfb64               "DES-EDE3-CFB"
-#define LN_des_ede3_cfb64               "des-ede3-cfb"
-#define NID_des_ede3_cfb64              61
-
-#define SN_des_ede_ofb64                "DES-EDE-OFB"
-#define LN_des_ede_ofb64                "des-ede-ofb"
-#define NID_des_ede_ofb64               62
-
-#define SN_des_ede3_ofb64               "DES-EDE3-OFB"
-#define LN_des_ede3_ofb64               "des-ede3-ofb"
-#define NID_des_ede3_ofb64              63
-
-#define SN_desx_cbc             "DESX-CBC"
-#define LN_desx_cbc             "desx-cbc"
-#define NID_desx_cbc            80
-
-#define SN_sha          "SHA"
-#define LN_sha          "sha"
-#define NID_sha         41
-#define OBJ_sha         OBJ_algorithm,18L
-
-#define SN_sha1         "SHA1"
-#define LN_sha1         "sha1"
-#define NID_sha1                64
-#define OBJ_sha1                OBJ_algorithm,26L
-
-#define SN_dsaWithSHA1_2                "DSA-SHA1-old"
-#define LN_dsaWithSHA1_2                "dsaWithSHA1-old"
-#define NID_dsaWithSHA1_2               70
-#define OBJ_dsaWithSHA1_2               OBJ_algorithm,27L
-
-#define SN_sha1WithRSA          "RSA-SHA1-2"
-#define LN_sha1WithRSA          "sha1WithRSA"
-#define NID_sha1WithRSA         115
-#define OBJ_sha1WithRSA         OBJ_algorithm,29L
-
-#define SN_ripemd160            "RIPEMD160"
-#define LN_ripemd160            "ripemd160"
-#define NID_ripemd160           117
-#define OBJ_ripemd160           1L,3L,36L,3L,2L,1L
-
-#define SN_ripemd160WithRSA             "RSA-RIPEMD160"
-#define LN_ripemd160WithRSA             "ripemd160WithRSA"
-#define NID_ripemd160WithRSA            119
-#define OBJ_ripemd160WithRSA            1L,3L,36L,3L,3L,1L,2L
-
-#define SN_blake2bmac           "BLAKE2BMAC"
-#define LN_blake2bmac           "blake2bmac"
-#define NID_blake2bmac          1201
-#define OBJ_blake2bmac          1L,3L,6L,1L,4L,1L,1722L,12L,2L,1L
-
-#define SN_blake2smac           "BLAKE2SMAC"
-#define LN_blake2smac           "blake2smac"
-#define NID_blake2smac          1202
-#define OBJ_blake2smac          1L,3L,6L,1L,4L,1L,1722L,12L,2L,2L
-
-#define SN_blake2b512           "BLAKE2b512"
-#define LN_blake2b512           "blake2b512"
-#define NID_blake2b512          1056
-#define OBJ_blake2b512          OBJ_blake2bmac,16L
-
-#define SN_blake2s256           "BLAKE2s256"
-#define LN_blake2s256           "blake2s256"
-#define NID_blake2s256          1057
-#define OBJ_blake2s256          OBJ_blake2smac,8L
-
-#define SN_sxnet                "SXNetID"
-#define LN_sxnet                "Strong Extranet ID"
-#define NID_sxnet               143
-#define OBJ_sxnet               1L,3L,101L,1L,4L,1L
-
-#define SN_X500         "X500"
-#define LN_X500         "directory services (X.500)"
-#define NID_X500                11
-#define OBJ_X500                2L,5L
-
-#define SN_X509         "X509"
-#define NID_X509                12
-#define OBJ_X509                OBJ_X500,4L
-
-#define SN_commonName           "CN"
-#define LN_commonName           "commonName"
-#define NID_commonName          13
-#define OBJ_commonName          OBJ_X509,3L
-
-#define SN_surname              "SN"
-#define LN_surname              "surname"
-#define NID_surname             100
-#define OBJ_surname             OBJ_X509,4L
-
-#define LN_serialNumber         "serialNumber"
-#define NID_serialNumber                105
-#define OBJ_serialNumber                OBJ_X509,5L
-
-#define SN_countryName          "C"
-#define LN_countryName          "countryName"
-#define NID_countryName         14
-#define OBJ_countryName         OBJ_X509,6L
-
-#define SN_localityName         "L"
-#define LN_localityName         "localityName"
-#define NID_localityName                15
-#define OBJ_localityName                OBJ_X509,7L
-
-#define SN_stateOrProvinceName          "ST"
-#define LN_stateOrProvinceName          "stateOrProvinceName"
-#define NID_stateOrProvinceName         16
-#define OBJ_stateOrProvinceName         OBJ_X509,8L
-
-#define SN_streetAddress                "street"
-#define LN_streetAddress                "streetAddress"
-#define NID_streetAddress               660
-#define OBJ_streetAddress               OBJ_X509,9L
-
-#define SN_organizationName             "O"
-#define LN_organizationName             "organizationName"
-#define NID_organizationName            17
-#define OBJ_organizationName            OBJ_X509,10L
-
-#define SN_organizationalUnitName               "OU"
-#define LN_organizationalUnitName               "organizationalUnitName"
-#define NID_organizationalUnitName              18
-#define OBJ_organizationalUnitName              OBJ_X509,11L
-
-#define SN_title                "title"
-#define LN_title                "title"
-#define NID_title               106
-#define OBJ_title               OBJ_X509,12L
-
-#define LN_description          "description"
-#define NID_description         107
-#define OBJ_description         OBJ_X509,13L
-
-#define LN_searchGuide          "searchGuide"
-#define NID_searchGuide         859
-#define OBJ_searchGuide         OBJ_X509,14L
-
-#define LN_businessCategory             "businessCategory"
-#define NID_businessCategory            860
-#define OBJ_businessCategory            OBJ_X509,15L
-
-#define LN_postalAddress                "postalAddress"
-#define NID_postalAddress               861
-#define OBJ_postalAddress               OBJ_X509,16L
-
-#define LN_postalCode           "postalCode"
-#define NID_postalCode          661
-#define OBJ_postalCode          OBJ_X509,17L
-
-#define LN_postOfficeBox                "postOfficeBox"
-#define NID_postOfficeBox               862
-#define OBJ_postOfficeBox               OBJ_X509,18L
-
-#define LN_physicalDeliveryOfficeName           "physicalDeliveryOfficeName"
-#define NID_physicalDeliveryOfficeName          863
-#define OBJ_physicalDeliveryOfficeName          OBJ_X509,19L
-
-#define LN_telephoneNumber              "telephoneNumber"
-#define NID_telephoneNumber             864
-#define OBJ_telephoneNumber             OBJ_X509,20L
-
-#define LN_telexNumber          "telexNumber"
-#define NID_telexNumber         865
-#define OBJ_telexNumber         OBJ_X509,21L
-
-#define LN_teletexTerminalIdentifier            "teletexTerminalIdentifier"
-#define NID_teletexTerminalIdentifier           866
-#define OBJ_teletexTerminalIdentifier           OBJ_X509,22L
-
-#define LN_facsimileTelephoneNumber             "facsimileTelephoneNumber"
-#define NID_facsimileTelephoneNumber            867
-#define OBJ_facsimileTelephoneNumber            OBJ_X509,23L
-
-#define LN_x121Address          "x121Address"
-#define NID_x121Address         868
-#define OBJ_x121Address         OBJ_X509,24L
-
-#define LN_internationaliSDNNumber              "internationaliSDNNumber"
-#define NID_internationaliSDNNumber             869
-#define OBJ_internationaliSDNNumber             OBJ_X509,25L
-
-#define LN_registeredAddress            "registeredAddress"
-#define NID_registeredAddress           870
-#define OBJ_registeredAddress           OBJ_X509,26L
-
-#define LN_destinationIndicator         "destinationIndicator"
-#define NID_destinationIndicator                871
-#define OBJ_destinationIndicator                OBJ_X509,27L
-
-#define LN_preferredDeliveryMethod              "preferredDeliveryMethod"
-#define NID_preferredDeliveryMethod             872
-#define OBJ_preferredDeliveryMethod             OBJ_X509,28L
-
-#define LN_presentationAddress          "presentationAddress"
-#define NID_presentationAddress         873
-#define OBJ_presentationAddress         OBJ_X509,29L
-
-#define LN_supportedApplicationContext          "supportedApplicationContext"
-#define NID_supportedApplicationContext         874
-#define OBJ_supportedApplicationContext         OBJ_X509,30L
-
-#define SN_member               "member"
-#define NID_member              875
-#define OBJ_member              OBJ_X509,31L
-
-#define SN_owner                "owner"
-#define NID_owner               876
-#define OBJ_owner               OBJ_X509,32L
-
-#define LN_roleOccupant         "roleOccupant"
-#define NID_roleOccupant                877
-#define OBJ_roleOccupant                OBJ_X509,33L
-
-#define SN_seeAlso              "seeAlso"
-#define NID_seeAlso             878
-#define OBJ_seeAlso             OBJ_X509,34L
-
-#define LN_userPassword         "userPassword"
-#define NID_userPassword                879
-#define OBJ_userPassword                OBJ_X509,35L
-
-#define LN_userCertificate              "userCertificate"
-#define NID_userCertificate             880
-#define OBJ_userCertificate             OBJ_X509,36L
-
-#define LN_cACertificate                "cACertificate"
-#define NID_cACertificate               881
-#define OBJ_cACertificate               OBJ_X509,37L
-
-#define LN_authorityRevocationList              "authorityRevocationList"
-#define NID_authorityRevocationList             882
-#define OBJ_authorityRevocationList             OBJ_X509,38L
-
-#define LN_certificateRevocationList            "certificateRevocationList"
-#define NID_certificateRevocationList           883
-#define OBJ_certificateRevocationList           OBJ_X509,39L
-
-#define LN_crossCertificatePair         "crossCertificatePair"
-#define NID_crossCertificatePair                884
-#define OBJ_crossCertificatePair                OBJ_X509,40L
-
-#define SN_name         "name"
-#define LN_name         "name"
-#define NID_name                173
-#define OBJ_name                OBJ_X509,41L
-
-#define SN_givenName            "GN"
-#define LN_givenName            "givenName"
-#define NID_givenName           99
-#define OBJ_givenName           OBJ_X509,42L
-
-#define SN_initials             "initials"
-#define LN_initials             "initials"
-#define NID_initials            101
-#define OBJ_initials            OBJ_X509,43L
-
-#define LN_generationQualifier          "generationQualifier"
-#define NID_generationQualifier         509
-#define OBJ_generationQualifier         OBJ_X509,44L
-
-#define LN_x500UniqueIdentifier         "x500UniqueIdentifier"
-#define NID_x500UniqueIdentifier                503
-#define OBJ_x500UniqueIdentifier                OBJ_X509,45L
-
-#define SN_dnQualifier          "dnQualifier"
-#define LN_dnQualifier          "dnQualifier"
-#define NID_dnQualifier         174
-#define OBJ_dnQualifier         OBJ_X509,46L
-
-#define LN_enhancedSearchGuide          "enhancedSearchGuide"
-#define NID_enhancedSearchGuide         885
-#define OBJ_enhancedSearchGuide         OBJ_X509,47L
-
-#define LN_protocolInformation          "protocolInformation"
-#define NID_protocolInformation         886
-#define OBJ_protocolInformation         OBJ_X509,48L
-
-#define LN_distinguishedName            "distinguishedName"
-#define NID_distinguishedName           887
-#define OBJ_distinguishedName           OBJ_X509,49L
-
-#define LN_uniqueMember         "uniqueMember"
-#define NID_uniqueMember                888
-#define OBJ_uniqueMember                OBJ_X509,50L
-
-#define LN_houseIdentifier              "houseIdentifier"
-#define NID_houseIdentifier             889
-#define OBJ_houseIdentifier             OBJ_X509,51L
-
-#define LN_supportedAlgorithms          "supportedAlgorithms"
-#define NID_supportedAlgorithms         890
-#define OBJ_supportedAlgorithms         OBJ_X509,52L
-
-#define LN_deltaRevocationList          "deltaRevocationList"
-#define NID_deltaRevocationList         891
-#define OBJ_deltaRevocationList         OBJ_X509,53L
-
-#define SN_dmdName              "dmdName"
-#define NID_dmdName             892
-#define OBJ_dmdName             OBJ_X509,54L
-
-#define LN_pseudonym            "pseudonym"
-#define NID_pseudonym           510
-#define OBJ_pseudonym           OBJ_X509,65L
-
-#define SN_role         "role"
-#define LN_role         "role"
-#define NID_role                400
-#define OBJ_role                OBJ_X509,72L
-
-#define LN_organizationIdentifier               "organizationIdentifier"
-#define NID_organizationIdentifier              1089
-#define OBJ_organizationIdentifier              OBJ_X509,97L
-
-#define SN_countryCode3c                "c3"
-#define LN_countryCode3c                "countryCode3c"
-#define NID_countryCode3c               1090
-#define OBJ_countryCode3c               OBJ_X509,98L
-
-#define SN_countryCode3n                "n3"
-#define LN_countryCode3n                "countryCode3n"
-#define NID_countryCode3n               1091
-#define OBJ_countryCode3n               OBJ_X509,99L
-
-#define LN_dnsName              "dnsName"
-#define NID_dnsName             1092
-#define OBJ_dnsName             OBJ_X509,100L
-
-#define SN_X500algorithms               "X500algorithms"
-#define LN_X500algorithms               "directory services - algorithms"
-#define NID_X500algorithms              378
-#define OBJ_X500algorithms              OBJ_X500,8L
-
-#define SN_rsa          "RSA"
-#define LN_rsa          "rsa"
-#define NID_rsa         19
-#define OBJ_rsa         OBJ_X500algorithms,1L,1L
-
-#define SN_mdc2WithRSA          "RSA-MDC2"
-#define LN_mdc2WithRSA          "mdc2WithRSA"
-#define NID_mdc2WithRSA         96
-#define OBJ_mdc2WithRSA         OBJ_X500algorithms,3L,100L
-
-#define SN_mdc2         "MDC2"
-#define LN_mdc2         "mdc2"
-#define NID_mdc2                95
-#define OBJ_mdc2                OBJ_X500algorithms,3L,101L
-
-#define SN_id_ce                "id-ce"
-#define NID_id_ce               81
-#define OBJ_id_ce               OBJ_X500,29L
-
-#define SN_subject_directory_attributes         "subjectDirectoryAttributes"
-#define LN_subject_directory_attributes         "X509v3 Subject Directory Attributes"
-#define NID_subject_directory_attributes                769
-#define OBJ_subject_directory_attributes                OBJ_id_ce,9L
-
-#define SN_subject_key_identifier               "subjectKeyIdentifier"
-#define LN_subject_key_identifier               "X509v3 Subject Key Identifier"
-#define NID_subject_key_identifier              82
-#define OBJ_subject_key_identifier              OBJ_id_ce,14L
-
-#define SN_key_usage            "keyUsage"
-#define LN_key_usage            "X509v3 Key Usage"
-#define NID_key_usage           83
-#define OBJ_key_usage           OBJ_id_ce,15L
-
-#define SN_private_key_usage_period             "privateKeyUsagePeriod"
-#define LN_private_key_usage_period             "X509v3 Private Key Usage Period"
-#define NID_private_key_usage_period            84
-#define OBJ_private_key_usage_period            OBJ_id_ce,16L
-
-#define SN_subject_alt_name             "subjectAltName"
-#define LN_subject_alt_name             "X509v3 Subject Alternative Name"
-#define NID_subject_alt_name            85
-#define OBJ_subject_alt_name            OBJ_id_ce,17L
-
-#define SN_issuer_alt_name              "issuerAltName"
-#define LN_issuer_alt_name              "X509v3 Issuer Alternative Name"
-#define NID_issuer_alt_name             86
-#define OBJ_issuer_alt_name             OBJ_id_ce,18L
-
-#define SN_basic_constraints            "basicConstraints"
-#define LN_basic_constraints            "X509v3 Basic Constraints"
-#define NID_basic_constraints           87
-#define OBJ_basic_constraints           OBJ_id_ce,19L
-
-#define SN_crl_number           "crlNumber"
-#define LN_crl_number           "X509v3 CRL Number"
-#define NID_crl_number          88
-#define OBJ_crl_number          OBJ_id_ce,20L
-
-#define SN_crl_reason           "CRLReason"
-#define LN_crl_reason           "X509v3 CRL Reason Code"
-#define NID_crl_reason          141
-#define OBJ_crl_reason          OBJ_id_ce,21L
-
-#define SN_invalidity_date              "invalidityDate"
-#define LN_invalidity_date              "Invalidity Date"
-#define NID_invalidity_date             142
-#define OBJ_invalidity_date             OBJ_id_ce,24L
-
-#define SN_delta_crl            "deltaCRL"
-#define LN_delta_crl            "X509v3 Delta CRL Indicator"
-#define NID_delta_crl           140
-#define OBJ_delta_crl           OBJ_id_ce,27L
-
-#define SN_issuing_distribution_point           "issuingDistributionPoint"
-#define LN_issuing_distribution_point           "X509v3 Issuing Distribution Point"
-#define NID_issuing_distribution_point          770
-#define OBJ_issuing_distribution_point          OBJ_id_ce,28L
-
-#define SN_certificate_issuer           "certificateIssuer"
-#define LN_certificate_issuer           "X509v3 Certificate Issuer"
-#define NID_certificate_issuer          771
-#define OBJ_certificate_issuer          OBJ_id_ce,29L
-
-#define SN_name_constraints             "nameConstraints"
-#define LN_name_constraints             "X509v3 Name Constraints"
-#define NID_name_constraints            666
-#define OBJ_name_constraints            OBJ_id_ce,30L
-
-#define SN_crl_distribution_points              "crlDistributionPoints"
-#define LN_crl_distribution_points              "X509v3 CRL Distribution Points"
-#define NID_crl_distribution_points             103
-#define OBJ_crl_distribution_points             OBJ_id_ce,31L
-
-#define SN_certificate_policies         "certificatePolicies"
-#define LN_certificate_policies         "X509v3 Certificate Policies"
-#define NID_certificate_policies                89
-#define OBJ_certificate_policies                OBJ_id_ce,32L
-
-#define SN_any_policy           "anyPolicy"
-#define LN_any_policy           "X509v3 Any Policy"
-#define NID_any_policy          746
-#define OBJ_any_policy          OBJ_certificate_policies,0L
-
-#define SN_policy_mappings              "policyMappings"
-#define LN_policy_mappings              "X509v3 Policy Mappings"
-#define NID_policy_mappings             747
-#define OBJ_policy_mappings             OBJ_id_ce,33L
-
-#define SN_authority_key_identifier             "authorityKeyIdentifier"
-#define LN_authority_key_identifier             "X509v3 Authority Key Identifier"
-#define NID_authority_key_identifier            90
-#define OBJ_authority_key_identifier            OBJ_id_ce,35L
-
-#define SN_policy_constraints           "policyConstraints"
-#define LN_policy_constraints           "X509v3 Policy Constraints"
-#define NID_policy_constraints          401
-#define OBJ_policy_constraints          OBJ_id_ce,36L
-
-#define SN_ext_key_usage                "extendedKeyUsage"
-#define LN_ext_key_usage                "X509v3 Extended Key Usage"
-#define NID_ext_key_usage               126
-#define OBJ_ext_key_usage               OBJ_id_ce,37L
-
-#define SN_freshest_crl         "freshestCRL"
-#define LN_freshest_crl         "X509v3 Freshest CRL"
-#define NID_freshest_crl                857
-#define OBJ_freshest_crl                OBJ_id_ce,46L
-
-#define SN_inhibit_any_policy           "inhibitAnyPolicy"
-#define LN_inhibit_any_policy           "X509v3 Inhibit Any Policy"
-#define NID_inhibit_any_policy          748
-#define OBJ_inhibit_any_policy          OBJ_id_ce,54L
-
-#define SN_target_information           "targetInformation"
-#define LN_target_information           "X509v3 AC Targeting"
-#define NID_target_information          402
-#define OBJ_target_information          OBJ_id_ce,55L
-
-#define SN_no_rev_avail         "noRevAvail"
-#define LN_no_rev_avail         "X509v3 No Revocation Available"
-#define NID_no_rev_avail                403
-#define OBJ_no_rev_avail                OBJ_id_ce,56L
-
-#define SN_anyExtendedKeyUsage          "anyExtendedKeyUsage"
-#define LN_anyExtendedKeyUsage          "Any Extended Key Usage"
-#define NID_anyExtendedKeyUsage         910
-#define OBJ_anyExtendedKeyUsage         OBJ_ext_key_usage,0L
-
-#define SN_netscape             "Netscape"
-#define LN_netscape             "Netscape Communications Corp."
-#define NID_netscape            57
-#define OBJ_netscape            2L,16L,840L,1L,113730L
-
-#define SN_netscape_cert_extension              "nsCertExt"
-#define LN_netscape_cert_extension              "Netscape Certificate Extension"
-#define NID_netscape_cert_extension             58
-#define OBJ_netscape_cert_extension             OBJ_netscape,1L
-
-#define SN_netscape_data_type           "nsDataType"
-#define LN_netscape_data_type           "Netscape Data Type"
-#define NID_netscape_data_type          59
-#define OBJ_netscape_data_type          OBJ_netscape,2L
-
-#define SN_netscape_cert_type           "nsCertType"
-#define LN_netscape_cert_type           "Netscape Cert Type"
-#define NID_netscape_cert_type          71
-#define OBJ_netscape_cert_type          OBJ_netscape_cert_extension,1L
-
-#define SN_netscape_base_url            "nsBaseUrl"
-#define LN_netscape_base_url            "Netscape Base Url"
-#define NID_netscape_base_url           72
-#define OBJ_netscape_base_url           OBJ_netscape_cert_extension,2L
-
-#define SN_netscape_revocation_url              "nsRevocationUrl"
-#define LN_netscape_revocation_url              "Netscape Revocation Url"
-#define NID_netscape_revocation_url             73
-#define OBJ_netscape_revocation_url             OBJ_netscape_cert_extension,3L
-
-#define SN_netscape_ca_revocation_url           "nsCaRevocationUrl"
-#define LN_netscape_ca_revocation_url           "Netscape CA Revocation Url"
-#define NID_netscape_ca_revocation_url          74
-#define OBJ_netscape_ca_revocation_url          OBJ_netscape_cert_extension,4L
-
-#define SN_netscape_renewal_url         "nsRenewalUrl"
-#define LN_netscape_renewal_url         "Netscape Renewal Url"
-#define NID_netscape_renewal_url                75
-#define OBJ_netscape_renewal_url                OBJ_netscape_cert_extension,7L
-
-#define SN_netscape_ca_policy_url               "nsCaPolicyUrl"
-#define LN_netscape_ca_policy_url               "Netscape CA Policy Url"
-#define NID_netscape_ca_policy_url              76
-#define OBJ_netscape_ca_policy_url              OBJ_netscape_cert_extension,8L
-
-#define SN_netscape_ssl_server_name             "nsSslServerName"
-#define LN_netscape_ssl_server_name             "Netscape SSL Server Name"
-#define NID_netscape_ssl_server_name            77
-#define OBJ_netscape_ssl_server_name            OBJ_netscape_cert_extension,12L
-
-#define SN_netscape_comment             "nsComment"
-#define LN_netscape_comment             "Netscape Comment"
-#define NID_netscape_comment            78
-#define OBJ_netscape_comment            OBJ_netscape_cert_extension,13L
-
-#define SN_netscape_cert_sequence               "nsCertSequence"
-#define LN_netscape_cert_sequence               "Netscape Certificate Sequence"
-#define NID_netscape_cert_sequence              79
-#define OBJ_netscape_cert_sequence              OBJ_netscape_data_type,5L
-
-#define SN_ns_sgc               "nsSGC"
-#define LN_ns_sgc               "Netscape Server Gated Crypto"
-#define NID_ns_sgc              139
-#define OBJ_ns_sgc              OBJ_netscape,4L,1L
-
-#define SN_org          "ORG"
-#define LN_org          "org"
-#define NID_org         379
-#define OBJ_org         OBJ_iso,3L
-
-#define SN_dod          "DOD"
-#define LN_dod          "dod"
-#define NID_dod         380
-#define OBJ_dod         OBJ_org,6L
-
-#define SN_iana         "IANA"
-#define LN_iana         "iana"
-#define NID_iana                381
-#define OBJ_iana                OBJ_dod,1L
-
-#define OBJ_internet            OBJ_iana
-
-#define SN_Directory            "directory"
-#define LN_Directory            "Directory"
-#define NID_Directory           382
-#define OBJ_Directory           OBJ_internet,1L
-
-#define SN_Management           "mgmt"
-#define LN_Management           "Management"
-#define NID_Management          383
-#define OBJ_Management          OBJ_internet,2L
-
-#define SN_Experimental         "experimental"
-#define LN_Experimental         "Experimental"
-#define NID_Experimental                384
-#define OBJ_Experimental                OBJ_internet,3L
-
-#define SN_Private              "private"
-#define LN_Private              "Private"
-#define NID_Private             385
-#define OBJ_Private             OBJ_internet,4L
-
-#define SN_Security             "security"
-#define LN_Security             "Security"
-#define NID_Security            386
-#define OBJ_Security            OBJ_internet,5L
-
-#define SN_SNMPv2               "snmpv2"
-#define LN_SNMPv2               "SNMPv2"
-#define NID_SNMPv2              387
-#define OBJ_SNMPv2              OBJ_internet,6L
-
-#define LN_Mail         "Mail"
-#define NID_Mail                388
-#define OBJ_Mail                OBJ_internet,7L
-
-#define SN_Enterprises          "enterprises"
-#define LN_Enterprises          "Enterprises"
-#define NID_Enterprises         389
-#define OBJ_Enterprises         OBJ_Private,1L
-
-#define SN_dcObject             "dcobject"
-#define LN_dcObject             "dcObject"
-#define NID_dcObject            390
-#define OBJ_dcObject            OBJ_Enterprises,1466L,344L
-
-#define SN_mime_mhs             "mime-mhs"
-#define LN_mime_mhs             "MIME MHS"
-#define NID_mime_mhs            504
-#define OBJ_mime_mhs            OBJ_Mail,1L
-
-#define SN_mime_mhs_headings            "mime-mhs-headings"
-#define LN_mime_mhs_headings            "mime-mhs-headings"
-#define NID_mime_mhs_headings           505
-#define OBJ_mime_mhs_headings           OBJ_mime_mhs,1L
-
-#define SN_mime_mhs_bodies              "mime-mhs-bodies"
-#define LN_mime_mhs_bodies              "mime-mhs-bodies"
-#define NID_mime_mhs_bodies             506
-#define OBJ_mime_mhs_bodies             OBJ_mime_mhs,2L
-
-#define SN_id_hex_partial_message               "id-hex-partial-message"
-#define LN_id_hex_partial_message               "id-hex-partial-message"
-#define NID_id_hex_partial_message              507
-#define OBJ_id_hex_partial_message              OBJ_mime_mhs_headings,1L
-
-#define SN_id_hex_multipart_message             "id-hex-multipart-message"
-#define LN_id_hex_multipart_message             "id-hex-multipart-message"
-#define NID_id_hex_multipart_message            508
-#define OBJ_id_hex_multipart_message            OBJ_mime_mhs_headings,2L
-
-#define SN_zlib_compression             "ZLIB"
-#define LN_zlib_compression             "zlib compression"
-#define NID_zlib_compression            125
-#define OBJ_zlib_compression            OBJ_id_smime_alg,8L
-
-#define OBJ_csor                2L,16L,840L,1L,101L,3L
-
-#define OBJ_nistAlgorithms              OBJ_csor,4L
-
-#define OBJ_aes         OBJ_nistAlgorithms,1L
-
-#define SN_aes_128_ecb          "AES-128-ECB"
-#define LN_aes_128_ecb          "aes-128-ecb"
-#define NID_aes_128_ecb         418
-#define OBJ_aes_128_ecb         OBJ_aes,1L
-
-#define SN_aes_128_cbc          "AES-128-CBC"
-#define LN_aes_128_cbc          "aes-128-cbc"
-#define NID_aes_128_cbc         419
-#define OBJ_aes_128_cbc         OBJ_aes,2L
-
-#define SN_aes_128_ofb128               "AES-128-OFB"
-#define LN_aes_128_ofb128               "aes-128-ofb"
-#define NID_aes_128_ofb128              420
-#define OBJ_aes_128_ofb128              OBJ_aes,3L
-
-#define SN_aes_128_cfb128               "AES-128-CFB"
-#define LN_aes_128_cfb128               "aes-128-cfb"
-#define NID_aes_128_cfb128              421
-#define OBJ_aes_128_cfb128              OBJ_aes,4L
-
-#define SN_id_aes128_wrap               "id-aes128-wrap"
-#define NID_id_aes128_wrap              788
-#define OBJ_id_aes128_wrap              OBJ_aes,5L
-
-#define SN_aes_128_gcm          "id-aes128-GCM"
-#define LN_aes_128_gcm          "aes-128-gcm"
-#define NID_aes_128_gcm         895
-#define OBJ_aes_128_gcm         OBJ_aes,6L
-
-#define SN_aes_128_ccm          "id-aes128-CCM"
-#define LN_aes_128_ccm          "aes-128-ccm"
-#define NID_aes_128_ccm         896
-#define OBJ_aes_128_ccm         OBJ_aes,7L
-
-#define SN_id_aes128_wrap_pad           "id-aes128-wrap-pad"
-#define NID_id_aes128_wrap_pad          897
-#define OBJ_id_aes128_wrap_pad          OBJ_aes,8L
-
-#define SN_aes_192_ecb          "AES-192-ECB"
-#define LN_aes_192_ecb          "aes-192-ecb"
-#define NID_aes_192_ecb         422
-#define OBJ_aes_192_ecb         OBJ_aes,21L
-
-#define SN_aes_192_cbc          "AES-192-CBC"
-#define LN_aes_192_cbc          "aes-192-cbc"
-#define NID_aes_192_cbc         423
-#define OBJ_aes_192_cbc         OBJ_aes,22L
-
-#define SN_aes_192_ofb128               "AES-192-OFB"
-#define LN_aes_192_ofb128               "aes-192-ofb"
-#define NID_aes_192_ofb128              424
-#define OBJ_aes_192_ofb128              OBJ_aes,23L
-
-#define SN_aes_192_cfb128               "AES-192-CFB"
-#define LN_aes_192_cfb128               "aes-192-cfb"
-#define NID_aes_192_cfb128              425
-#define OBJ_aes_192_cfb128              OBJ_aes,24L
-
-#define SN_id_aes192_wrap               "id-aes192-wrap"
-#define NID_id_aes192_wrap              789
-#define OBJ_id_aes192_wrap              OBJ_aes,25L
-
-#define SN_aes_192_gcm          "id-aes192-GCM"
-#define LN_aes_192_gcm          "aes-192-gcm"
-#define NID_aes_192_gcm         898
-#define OBJ_aes_192_gcm         OBJ_aes,26L
-
-#define SN_aes_192_ccm          "id-aes192-CCM"
-#define LN_aes_192_ccm          "aes-192-ccm"
-#define NID_aes_192_ccm         899
-#define OBJ_aes_192_ccm         OBJ_aes,27L
-
-#define SN_id_aes192_wrap_pad           "id-aes192-wrap-pad"
-#define NID_id_aes192_wrap_pad          900
-#define OBJ_id_aes192_wrap_pad          OBJ_aes,28L
-
-#define SN_aes_256_ecb          "AES-256-ECB"
-#define LN_aes_256_ecb          "aes-256-ecb"
-#define NID_aes_256_ecb         426
-#define OBJ_aes_256_ecb         OBJ_aes,41L
-
-#define SN_aes_256_cbc          "AES-256-CBC"
-#define LN_aes_256_cbc          "aes-256-cbc"
-#define NID_aes_256_cbc         427
-#define OBJ_aes_256_cbc         OBJ_aes,42L
-
-#define SN_aes_256_ofb128               "AES-256-OFB"
-#define LN_aes_256_ofb128               "aes-256-ofb"
-#define NID_aes_256_ofb128              428
-#define OBJ_aes_256_ofb128              OBJ_aes,43L
-
-#define SN_aes_256_cfb128               "AES-256-CFB"
-#define LN_aes_256_cfb128               "aes-256-cfb"
-#define NID_aes_256_cfb128              429
-#define OBJ_aes_256_cfb128              OBJ_aes,44L
-
-#define SN_id_aes256_wrap               "id-aes256-wrap"
-#define NID_id_aes256_wrap              790
-#define OBJ_id_aes256_wrap              OBJ_aes,45L
-
-#define SN_aes_256_gcm          "id-aes256-GCM"
-#define LN_aes_256_gcm          "aes-256-gcm"
-#define NID_aes_256_gcm         901
-#define OBJ_aes_256_gcm         OBJ_aes,46L
-
-#define SN_aes_256_ccm          "id-aes256-CCM"
-#define LN_aes_256_ccm          "aes-256-ccm"
-#define NID_aes_256_ccm         902
-#define OBJ_aes_256_ccm         OBJ_aes,47L
-
-#define SN_id_aes256_wrap_pad           "id-aes256-wrap-pad"
-#define NID_id_aes256_wrap_pad          903
-#define OBJ_id_aes256_wrap_pad          OBJ_aes,48L
-
-#define SN_aes_128_xts          "AES-128-XTS"
-#define LN_aes_128_xts          "aes-128-xts"
-#define NID_aes_128_xts         913
-#define OBJ_aes_128_xts         OBJ_ieee_siswg,0L,1L,1L
-
-#define SN_aes_256_xts          "AES-256-XTS"
-#define LN_aes_256_xts          "aes-256-xts"
-#define NID_aes_256_xts         914
-#define OBJ_aes_256_xts         OBJ_ieee_siswg,0L,1L,2L
-
-#define SN_aes_128_cfb1         "AES-128-CFB1"
-#define LN_aes_128_cfb1         "aes-128-cfb1"
-#define NID_aes_128_cfb1                650
-
-#define SN_aes_192_cfb1         "AES-192-CFB1"
-#define LN_aes_192_cfb1         "aes-192-cfb1"
-#define NID_aes_192_cfb1                651
-
-#define SN_aes_256_cfb1         "AES-256-CFB1"
-#define LN_aes_256_cfb1         "aes-256-cfb1"
-#define NID_aes_256_cfb1                652
-
-#define SN_aes_128_cfb8         "AES-128-CFB8"
-#define LN_aes_128_cfb8         "aes-128-cfb8"
-#define NID_aes_128_cfb8                653
-
-#define SN_aes_192_cfb8         "AES-192-CFB8"
-#define LN_aes_192_cfb8         "aes-192-cfb8"
-#define NID_aes_192_cfb8                654
-
-#define SN_aes_256_cfb8         "AES-256-CFB8"
-#define LN_aes_256_cfb8         "aes-256-cfb8"
-#define NID_aes_256_cfb8                655
-
-#define SN_aes_128_ctr          "AES-128-CTR"
-#define LN_aes_128_ctr          "aes-128-ctr"
-#define NID_aes_128_ctr         904
-
-#define SN_aes_192_ctr          "AES-192-CTR"
-#define LN_aes_192_ctr          "aes-192-ctr"
-#define NID_aes_192_ctr         905
-
-#define SN_aes_256_ctr          "AES-256-CTR"
-#define LN_aes_256_ctr          "aes-256-ctr"
-#define NID_aes_256_ctr         906
-
-#define SN_aes_128_ocb          "AES-128-OCB"
-#define LN_aes_128_ocb          "aes-128-ocb"
-#define NID_aes_128_ocb         958
-
-#define SN_aes_192_ocb          "AES-192-OCB"
-#define LN_aes_192_ocb          "aes-192-ocb"
-#define NID_aes_192_ocb         959
-
-#define SN_aes_256_ocb          "AES-256-OCB"
-#define LN_aes_256_ocb          "aes-256-ocb"
-#define NID_aes_256_ocb         960
-
-#define SN_des_cfb1             "DES-CFB1"
-#define LN_des_cfb1             "des-cfb1"
-#define NID_des_cfb1            656
-
-#define SN_des_cfb8             "DES-CFB8"
-#define LN_des_cfb8             "des-cfb8"
-#define NID_des_cfb8            657
-
-#define SN_des_ede3_cfb1                "DES-EDE3-CFB1"
-#define LN_des_ede3_cfb1                "des-ede3-cfb1"
-#define NID_des_ede3_cfb1               658
-
-#define SN_des_ede3_cfb8                "DES-EDE3-CFB8"
-#define LN_des_ede3_cfb8                "des-ede3-cfb8"
-#define NID_des_ede3_cfb8               659
-
-#define OBJ_nist_hashalgs               OBJ_nistAlgorithms,2L
-
-#define SN_sha256               "SHA256"
-#define LN_sha256               "sha256"
-#define NID_sha256              672
-#define OBJ_sha256              OBJ_nist_hashalgs,1L
-
-#define SN_sha384               "SHA384"
-#define LN_sha384               "sha384"
-#define NID_sha384              673
-#define OBJ_sha384              OBJ_nist_hashalgs,2L
-
-#define SN_sha512               "SHA512"
-#define LN_sha512               "sha512"
-#define NID_sha512              674
-#define OBJ_sha512              OBJ_nist_hashalgs,3L
-
-#define SN_sha224               "SHA224"
-#define LN_sha224               "sha224"
-#define NID_sha224              675
-#define OBJ_sha224              OBJ_nist_hashalgs,4L
-
-#define SN_sha512_224           "SHA512-224"
-#define LN_sha512_224           "sha512-224"
-#define NID_sha512_224          1094
-#define OBJ_sha512_224          OBJ_nist_hashalgs,5L
-
-#define SN_sha512_256           "SHA512-256"
-#define LN_sha512_256           "sha512-256"
-#define NID_sha512_256          1095
-#define OBJ_sha512_256          OBJ_nist_hashalgs,6L
-
-#define SN_sha3_224             "SHA3-224"
-#define LN_sha3_224             "sha3-224"
-#define NID_sha3_224            1096
-#define OBJ_sha3_224            OBJ_nist_hashalgs,7L
-
-#define SN_sha3_256             "SHA3-256"
-#define LN_sha3_256             "sha3-256"
-#define NID_sha3_256            1097
-#define OBJ_sha3_256            OBJ_nist_hashalgs,8L
-
-#define SN_sha3_384             "SHA3-384"
-#define LN_sha3_384             "sha3-384"
-#define NID_sha3_384            1098
-#define OBJ_sha3_384            OBJ_nist_hashalgs,9L
-
-#define SN_sha3_512             "SHA3-512"
-#define LN_sha3_512             "sha3-512"
-#define NID_sha3_512            1099
-#define OBJ_sha3_512            OBJ_nist_hashalgs,10L
-
-#define SN_shake128             "SHAKE128"
-#define LN_shake128             "shake128"
-#define NID_shake128            1100
-#define OBJ_shake128            OBJ_nist_hashalgs,11L
-
-#define SN_shake256             "SHAKE256"
-#define LN_shake256             "shake256"
-#define NID_shake256            1101
-#define OBJ_shake256            OBJ_nist_hashalgs,12L
-
-#define SN_hmac_sha3_224                "id-hmacWithSHA3-224"
-#define LN_hmac_sha3_224                "hmac-sha3-224"
-#define NID_hmac_sha3_224               1102
-#define OBJ_hmac_sha3_224               OBJ_nist_hashalgs,13L
-
-#define SN_hmac_sha3_256                "id-hmacWithSHA3-256"
-#define LN_hmac_sha3_256                "hmac-sha3-256"
-#define NID_hmac_sha3_256               1103
-#define OBJ_hmac_sha3_256               OBJ_nist_hashalgs,14L
-
-#define SN_hmac_sha3_384                "id-hmacWithSHA3-384"
-#define LN_hmac_sha3_384                "hmac-sha3-384"
-#define NID_hmac_sha3_384               1104
-#define OBJ_hmac_sha3_384               OBJ_nist_hashalgs,15L
-
-#define SN_hmac_sha3_512                "id-hmacWithSHA3-512"
-#define LN_hmac_sha3_512                "hmac-sha3-512"
-#define NID_hmac_sha3_512               1105
-#define OBJ_hmac_sha3_512               OBJ_nist_hashalgs,16L
-
-#define SN_kmac128              "KMAC128"
-#define LN_kmac128              "kmac128"
-#define NID_kmac128             1196
-#define OBJ_kmac128             OBJ_nist_hashalgs,19L
-
-#define SN_kmac256              "KMAC256"
-#define LN_kmac256              "kmac256"
-#define NID_kmac256             1197
-#define OBJ_kmac256             OBJ_nist_hashalgs,20L
-
-#define OBJ_dsa_with_sha2               OBJ_nistAlgorithms,3L
-
-#define SN_dsa_with_SHA224              "dsa_with_SHA224"
-#define NID_dsa_with_SHA224             802
-#define OBJ_dsa_with_SHA224             OBJ_dsa_with_sha2,1L
-
-#define SN_dsa_with_SHA256              "dsa_with_SHA256"
-#define NID_dsa_with_SHA256             803
-#define OBJ_dsa_with_SHA256             OBJ_dsa_with_sha2,2L
-
-#define OBJ_sigAlgs             OBJ_nistAlgorithms,3L
-
-#define SN_dsa_with_SHA384              "id-dsa-with-sha384"
-#define LN_dsa_with_SHA384              "dsa_with_SHA384"
-#define NID_dsa_with_SHA384             1106
-#define OBJ_dsa_with_SHA384             OBJ_sigAlgs,3L
-
-#define SN_dsa_with_SHA512              "id-dsa-with-sha512"
-#define LN_dsa_with_SHA512              "dsa_with_SHA512"
-#define NID_dsa_with_SHA512             1107
-#define OBJ_dsa_with_SHA512             OBJ_sigAlgs,4L
-
-#define SN_dsa_with_SHA3_224            "id-dsa-with-sha3-224"
-#define LN_dsa_with_SHA3_224            "dsa_with_SHA3-224"
-#define NID_dsa_with_SHA3_224           1108
-#define OBJ_dsa_with_SHA3_224           OBJ_sigAlgs,5L
-
-#define SN_dsa_with_SHA3_256            "id-dsa-with-sha3-256"
-#define LN_dsa_with_SHA3_256            "dsa_with_SHA3-256"
-#define NID_dsa_with_SHA3_256           1109
-#define OBJ_dsa_with_SHA3_256           OBJ_sigAlgs,6L
-
-#define SN_dsa_with_SHA3_384            "id-dsa-with-sha3-384"
-#define LN_dsa_with_SHA3_384            "dsa_with_SHA3-384"
-#define NID_dsa_with_SHA3_384           1110
-#define OBJ_dsa_with_SHA3_384           OBJ_sigAlgs,7L
-
-#define SN_dsa_with_SHA3_512            "id-dsa-with-sha3-512"
-#define LN_dsa_with_SHA3_512            "dsa_with_SHA3-512"
-#define NID_dsa_with_SHA3_512           1111
-#define OBJ_dsa_with_SHA3_512           OBJ_sigAlgs,8L
-
-#define SN_ecdsa_with_SHA3_224          "id-ecdsa-with-sha3-224"
-#define LN_ecdsa_with_SHA3_224          "ecdsa_with_SHA3-224"
-#define NID_ecdsa_with_SHA3_224         1112
-#define OBJ_ecdsa_with_SHA3_224         OBJ_sigAlgs,9L
-
-#define SN_ecdsa_with_SHA3_256          "id-ecdsa-with-sha3-256"
-#define LN_ecdsa_with_SHA3_256          "ecdsa_with_SHA3-256"
-#define NID_ecdsa_with_SHA3_256         1113
-#define OBJ_ecdsa_with_SHA3_256         OBJ_sigAlgs,10L
-
-#define SN_ecdsa_with_SHA3_384          "id-ecdsa-with-sha3-384"
-#define LN_ecdsa_with_SHA3_384          "ecdsa_with_SHA3-384"
-#define NID_ecdsa_with_SHA3_384         1114
-#define OBJ_ecdsa_with_SHA3_384         OBJ_sigAlgs,11L
-
-#define SN_ecdsa_with_SHA3_512          "id-ecdsa-with-sha3-512"
-#define LN_ecdsa_with_SHA3_512          "ecdsa_with_SHA3-512"
-#define NID_ecdsa_with_SHA3_512         1115
-#define OBJ_ecdsa_with_SHA3_512         OBJ_sigAlgs,12L
-
-#define SN_RSA_SHA3_224         "id-rsassa-pkcs1-v1_5-with-sha3-224"
-#define LN_RSA_SHA3_224         "RSA-SHA3-224"
-#define NID_RSA_SHA3_224                1116
-#define OBJ_RSA_SHA3_224                OBJ_sigAlgs,13L
-
-#define SN_RSA_SHA3_256         "id-rsassa-pkcs1-v1_5-with-sha3-256"
-#define LN_RSA_SHA3_256         "RSA-SHA3-256"
-#define NID_RSA_SHA3_256                1117
-#define OBJ_RSA_SHA3_256                OBJ_sigAlgs,14L
-
-#define SN_RSA_SHA3_384         "id-rsassa-pkcs1-v1_5-with-sha3-384"
-#define LN_RSA_SHA3_384         "RSA-SHA3-384"
-#define NID_RSA_SHA3_384                1118
-#define OBJ_RSA_SHA3_384                OBJ_sigAlgs,15L
-
-#define SN_RSA_SHA3_512         "id-rsassa-pkcs1-v1_5-with-sha3-512"
-#define LN_RSA_SHA3_512         "RSA-SHA3-512"
-#define NID_RSA_SHA3_512                1119
-#define OBJ_RSA_SHA3_512                OBJ_sigAlgs,16L
-
-#define SN_hold_instruction_code                "holdInstructionCode"
-#define LN_hold_instruction_code                "Hold Instruction Code"
-#define NID_hold_instruction_code               430
-#define OBJ_hold_instruction_code               OBJ_id_ce,23L
-
-#define OBJ_holdInstruction             OBJ_X9_57,2L
-
-#define SN_hold_instruction_none                "holdInstructionNone"
-#define LN_hold_instruction_none                "Hold Instruction None"
-#define NID_hold_instruction_none               431
-#define OBJ_hold_instruction_none               OBJ_holdInstruction,1L
-
-#define SN_hold_instruction_call_issuer         "holdInstructionCallIssuer"
-#define LN_hold_instruction_call_issuer         "Hold Instruction Call Issuer"
-#define NID_hold_instruction_call_issuer                432
-#define OBJ_hold_instruction_call_issuer                OBJ_holdInstruction,2L
-
-#define SN_hold_instruction_reject              "holdInstructionReject"
-#define LN_hold_instruction_reject              "Hold Instruction Reject"
-#define NID_hold_instruction_reject             433
-#define OBJ_hold_instruction_reject             OBJ_holdInstruction,3L
-
-#define SN_data         "data"
-#define NID_data                434
-#define OBJ_data                OBJ_itu_t,9L
-
-#define SN_pss          "pss"
-#define NID_pss         435
-#define OBJ_pss         OBJ_data,2342L
-
-#define SN_ucl          "ucl"
-#define NID_ucl         436
-#define OBJ_ucl         OBJ_pss,19200300L
-
-#define SN_pilot                "pilot"
-#define NID_pilot               437
-#define OBJ_pilot               OBJ_ucl,100L
-
-#define LN_pilotAttributeType           "pilotAttributeType"
-#define NID_pilotAttributeType          438
-#define OBJ_pilotAttributeType          OBJ_pilot,1L
-
-#define LN_pilotAttributeSyntax         "pilotAttributeSyntax"
-#define NID_pilotAttributeSyntax                439
-#define OBJ_pilotAttributeSyntax                OBJ_pilot,3L
-
-#define LN_pilotObjectClass             "pilotObjectClass"
-#define NID_pilotObjectClass            440
-#define OBJ_pilotObjectClass            OBJ_pilot,4L
-
-#define LN_pilotGroups          "pilotGroups"
-#define NID_pilotGroups         441
-#define OBJ_pilotGroups         OBJ_pilot,10L
-
-#define LN_iA5StringSyntax              "iA5StringSyntax"
-#define NID_iA5StringSyntax             442
-#define OBJ_iA5StringSyntax             OBJ_pilotAttributeSyntax,4L
-
-#define LN_caseIgnoreIA5StringSyntax            "caseIgnoreIA5StringSyntax"
-#define NID_caseIgnoreIA5StringSyntax           443
-#define OBJ_caseIgnoreIA5StringSyntax           OBJ_pilotAttributeSyntax,5L
-
-#define LN_pilotObject          "pilotObject"
-#define NID_pilotObject         444
-#define OBJ_pilotObject         OBJ_pilotObjectClass,3L
-
-#define LN_pilotPerson          "pilotPerson"
-#define NID_pilotPerson         445
-#define OBJ_pilotPerson         OBJ_pilotObjectClass,4L
-
-#define SN_account              "account"
-#define NID_account             446
-#define OBJ_account             OBJ_pilotObjectClass,5L
-
-#define SN_document             "document"
-#define NID_document            447
-#define OBJ_document            OBJ_pilotObjectClass,6L
-
-#define SN_room         "room"
-#define NID_room                448
-#define OBJ_room                OBJ_pilotObjectClass,7L
-
-#define LN_documentSeries               "documentSeries"
-#define NID_documentSeries              449
-#define OBJ_documentSeries              OBJ_pilotObjectClass,9L
-
-#define SN_Domain               "domain"
-#define LN_Domain               "Domain"
-#define NID_Domain              392
-#define OBJ_Domain              OBJ_pilotObjectClass,13L
-
-#define LN_rFC822localPart              "rFC822localPart"
-#define NID_rFC822localPart             450
-#define OBJ_rFC822localPart             OBJ_pilotObjectClass,14L
-
-#define LN_dNSDomain            "dNSDomain"
-#define NID_dNSDomain           451
-#define OBJ_dNSDomain           OBJ_pilotObjectClass,15L
-
-#define LN_domainRelatedObject          "domainRelatedObject"
-#define NID_domainRelatedObject         452
-#define OBJ_domainRelatedObject         OBJ_pilotObjectClass,17L
-
-#define LN_friendlyCountry              "friendlyCountry"
-#define NID_friendlyCountry             453
-#define OBJ_friendlyCountry             OBJ_pilotObjectClass,18L
-
-#define LN_simpleSecurityObject         "simpleSecurityObject"
-#define NID_simpleSecurityObject                454
-#define OBJ_simpleSecurityObject                OBJ_pilotObjectClass,19L
-
-#define LN_pilotOrganization            "pilotOrganization"
-#define NID_pilotOrganization           455
-#define OBJ_pilotOrganization           OBJ_pilotObjectClass,20L
-
-#define LN_pilotDSA             "pilotDSA"
-#define NID_pilotDSA            456
-#define OBJ_pilotDSA            OBJ_pilotObjectClass,21L
-
-#define LN_qualityLabelledData          "qualityLabelledData"
-#define NID_qualityLabelledData         457
-#define OBJ_qualityLabelledData         OBJ_pilotObjectClass,22L
-
-#define SN_userId               "UID"
-#define LN_userId               "userId"
-#define NID_userId              458
-#define OBJ_userId              OBJ_pilotAttributeType,1L
-
-#define LN_textEncodedORAddress         "textEncodedORAddress"
-#define NID_textEncodedORAddress                459
-#define OBJ_textEncodedORAddress                OBJ_pilotAttributeType,2L
-
-#define SN_rfc822Mailbox                "mail"
-#define LN_rfc822Mailbox                "rfc822Mailbox"
-#define NID_rfc822Mailbox               460
-#define OBJ_rfc822Mailbox               OBJ_pilotAttributeType,3L
-
-#define SN_info         "info"
-#define NID_info                461
-#define OBJ_info                OBJ_pilotAttributeType,4L
-
-#define LN_favouriteDrink               "favouriteDrink"
-#define NID_favouriteDrink              462
-#define OBJ_favouriteDrink              OBJ_pilotAttributeType,5L
-
-#define LN_roomNumber           "roomNumber"
-#define NID_roomNumber          463
-#define OBJ_roomNumber          OBJ_pilotAttributeType,6L
-
-#define SN_photo                "photo"
-#define NID_photo               464
-#define OBJ_photo               OBJ_pilotAttributeType,7L
-
-#define LN_userClass            "userClass"
-#define NID_userClass           465
-#define OBJ_userClass           OBJ_pilotAttributeType,8L
-
-#define SN_host         "host"
-#define NID_host                466
-#define OBJ_host                OBJ_pilotAttributeType,9L
-
-#define SN_manager              "manager"
-#define NID_manager             467
-#define OBJ_manager             OBJ_pilotAttributeType,10L
-
-#define LN_documentIdentifier           "documentIdentifier"
-#define NID_documentIdentifier          468
-#define OBJ_documentIdentifier          OBJ_pilotAttributeType,11L
-
-#define LN_documentTitle                "documentTitle"
-#define NID_documentTitle               469
-#define OBJ_documentTitle               OBJ_pilotAttributeType,12L
-
-#define LN_documentVersion              "documentVersion"
-#define NID_documentVersion             470
-#define OBJ_documentVersion             OBJ_pilotAttributeType,13L
-
-#define LN_documentAuthor               "documentAuthor"
-#define NID_documentAuthor              471
-#define OBJ_documentAuthor              OBJ_pilotAttributeType,14L
-
-#define LN_documentLocation             "documentLocation"
-#define NID_documentLocation            472
-#define OBJ_documentLocation            OBJ_pilotAttributeType,15L
-
-#define LN_homeTelephoneNumber          "homeTelephoneNumber"
-#define NID_homeTelephoneNumber         473
-#define OBJ_homeTelephoneNumber         OBJ_pilotAttributeType,20L
-
-#define SN_secretary            "secretary"
-#define NID_secretary           474
-#define OBJ_secretary           OBJ_pilotAttributeType,21L
-
-#define LN_otherMailbox         "otherMailbox"
-#define NID_otherMailbox                475
-#define OBJ_otherMailbox                OBJ_pilotAttributeType,22L
-
-#define LN_lastModifiedTime             "lastModifiedTime"
-#define NID_lastModifiedTime            476
-#define OBJ_lastModifiedTime            OBJ_pilotAttributeType,23L
-
-#define LN_lastModifiedBy               "lastModifiedBy"
-#define NID_lastModifiedBy              477
-#define OBJ_lastModifiedBy              OBJ_pilotAttributeType,24L
-
-#define SN_domainComponent              "DC"
-#define LN_domainComponent              "domainComponent"
-#define NID_domainComponent             391
-#define OBJ_domainComponent             OBJ_pilotAttributeType,25L
-
-#define LN_aRecord              "aRecord"
-#define NID_aRecord             478
-#define OBJ_aRecord             OBJ_pilotAttributeType,26L
-
-#define LN_pilotAttributeType27         "pilotAttributeType27"
-#define NID_pilotAttributeType27                479
-#define OBJ_pilotAttributeType27                OBJ_pilotAttributeType,27L
-
-#define LN_mXRecord             "mXRecord"
-#define NID_mXRecord            480
-#define OBJ_mXRecord            OBJ_pilotAttributeType,28L
-
-#define LN_nSRecord             "nSRecord"
-#define NID_nSRecord            481
-#define OBJ_nSRecord            OBJ_pilotAttributeType,29L
-
-#define LN_sOARecord            "sOARecord"
-#define NID_sOARecord           482
-#define OBJ_sOARecord           OBJ_pilotAttributeType,30L
-
-#define LN_cNAMERecord          "cNAMERecord"
-#define NID_cNAMERecord         483
-#define OBJ_cNAMERecord         OBJ_pilotAttributeType,31L
-
-#define LN_associatedDomain             "associatedDomain"
-#define NID_associatedDomain            484
-#define OBJ_associatedDomain            OBJ_pilotAttributeType,37L
-
-#define LN_associatedName               "associatedName"
-#define NID_associatedName              485
-#define OBJ_associatedName              OBJ_pilotAttributeType,38L
-
-#define LN_homePostalAddress            "homePostalAddress"
-#define NID_homePostalAddress           486
-#define OBJ_homePostalAddress           OBJ_pilotAttributeType,39L
-
-#define LN_personalTitle                "personalTitle"
-#define NID_personalTitle               487
-#define OBJ_personalTitle               OBJ_pilotAttributeType,40L
-
-#define LN_mobileTelephoneNumber                "mobileTelephoneNumber"
-#define NID_mobileTelephoneNumber               488
-#define OBJ_mobileTelephoneNumber               OBJ_pilotAttributeType,41L
-
-#define LN_pagerTelephoneNumber         "pagerTelephoneNumber"
-#define NID_pagerTelephoneNumber                489
-#define OBJ_pagerTelephoneNumber                OBJ_pilotAttributeType,42L
-
-#define LN_friendlyCountryName          "friendlyCountryName"
-#define NID_friendlyCountryName         490
-#define OBJ_friendlyCountryName         OBJ_pilotAttributeType,43L
-
-#define SN_uniqueIdentifier             "uid"
-#define LN_uniqueIdentifier             "uniqueIdentifier"
-#define NID_uniqueIdentifier            102
-#define OBJ_uniqueIdentifier            OBJ_pilotAttributeType,44L
-
-#define LN_organizationalStatus         "organizationalStatus"
-#define NID_organizationalStatus                491
-#define OBJ_organizationalStatus                OBJ_pilotAttributeType,45L
-
-#define LN_janetMailbox         "janetMailbox"
-#define NID_janetMailbox                492
-#define OBJ_janetMailbox                OBJ_pilotAttributeType,46L
-
-#define LN_mailPreferenceOption         "mailPreferenceOption"
-#define NID_mailPreferenceOption                493
-#define OBJ_mailPreferenceOption                OBJ_pilotAttributeType,47L
-
-#define LN_buildingName         "buildingName"
-#define NID_buildingName                494
-#define OBJ_buildingName                OBJ_pilotAttributeType,48L
-
-#define LN_dSAQuality           "dSAQuality"
-#define NID_dSAQuality          495
-#define OBJ_dSAQuality          OBJ_pilotAttributeType,49L
-
-#define LN_singleLevelQuality           "singleLevelQuality"
-#define NID_singleLevelQuality          496
-#define OBJ_singleLevelQuality          OBJ_pilotAttributeType,50L
-
-#define LN_subtreeMinimumQuality                "subtreeMinimumQuality"
-#define NID_subtreeMinimumQuality               497
-#define OBJ_subtreeMinimumQuality               OBJ_pilotAttributeType,51L
-
-#define LN_subtreeMaximumQuality                "subtreeMaximumQuality"
-#define NID_subtreeMaximumQuality               498
-#define OBJ_subtreeMaximumQuality               OBJ_pilotAttributeType,52L
-
-#define LN_personalSignature            "personalSignature"
-#define NID_personalSignature           499
-#define OBJ_personalSignature           OBJ_pilotAttributeType,53L
-
-#define LN_dITRedirect          "dITRedirect"
-#define NID_dITRedirect         500
-#define OBJ_dITRedirect         OBJ_pilotAttributeType,54L
-
-#define SN_audio                "audio"
-#define NID_audio               501
-#define OBJ_audio               OBJ_pilotAttributeType,55L
-
-#define LN_documentPublisher            "documentPublisher"
-#define NID_documentPublisher           502
-#define OBJ_documentPublisher           OBJ_pilotAttributeType,56L
-
-#define SN_id_set               "id-set"
-#define LN_id_set               "Secure Electronic Transactions"
-#define NID_id_set              512
-#define OBJ_id_set              OBJ_international_organizations,42L
-
-#define SN_set_ctype            "set-ctype"
-#define LN_set_ctype            "content types"
-#define NID_set_ctype           513
-#define OBJ_set_ctype           OBJ_id_set,0L
-
-#define SN_set_msgExt           "set-msgExt"
-#define LN_set_msgExt           "message extensions"
-#define NID_set_msgExt          514
-#define OBJ_set_msgExt          OBJ_id_set,1L
-
-#define SN_set_attr             "set-attr"
-#define NID_set_attr            515
-#define OBJ_set_attr            OBJ_id_set,3L
-
-#define SN_set_policy           "set-policy"
-#define NID_set_policy          516
-#define OBJ_set_policy          OBJ_id_set,5L
-
-#define SN_set_certExt          "set-certExt"
-#define LN_set_certExt          "certificate extensions"
-#define NID_set_certExt         517
-#define OBJ_set_certExt         OBJ_id_set,7L
-
-#define SN_set_brand            "set-brand"
-#define NID_set_brand           518
-#define OBJ_set_brand           OBJ_id_set,8L
-
-#define SN_setct_PANData                "setct-PANData"
-#define NID_setct_PANData               519
-#define OBJ_setct_PANData               OBJ_set_ctype,0L
-
-#define SN_setct_PANToken               "setct-PANToken"
-#define NID_setct_PANToken              520
-#define OBJ_setct_PANToken              OBJ_set_ctype,1L
-
-#define SN_setct_PANOnly                "setct-PANOnly"
-#define NID_setct_PANOnly               521
-#define OBJ_setct_PANOnly               OBJ_set_ctype,2L
-
-#define SN_setct_OIData         "setct-OIData"
-#define NID_setct_OIData                522
-#define OBJ_setct_OIData                OBJ_set_ctype,3L
-
-#define SN_setct_PI             "setct-PI"
-#define NID_setct_PI            523
-#define OBJ_setct_PI            OBJ_set_ctype,4L
+#define SN_id_cmc_identification "id-cmc-identification"
+#define NID_id_cmc_identification 328
+#define OBJ_id_cmc_identification OBJ_id_cmc, 2L
+
+#define SN_id_cmc_identityProof "id-cmc-identityProof"
+#define NID_id_cmc_identityProof 329
+#define OBJ_id_cmc_identityProof OBJ_id_cmc, 3L
+
+#define SN_id_cmc_dataReturn "id-cmc-dataReturn"
+#define NID_id_cmc_dataReturn 330
+#define OBJ_id_cmc_dataReturn OBJ_id_cmc, 4L
+
+#define SN_id_cmc_transactionId "id-cmc-transactionId"
+#define NID_id_cmc_transactionId 331
+#define OBJ_id_cmc_transactionId OBJ_id_cmc, 5L
+
+#define SN_id_cmc_senderNonce "id-cmc-senderNonce"
+#define NID_id_cmc_senderNonce 332
+#define OBJ_id_cmc_senderNonce OBJ_id_cmc, 6L
+
+#define SN_id_cmc_recipientNonce "id-cmc-recipientNonce"
+#define NID_id_cmc_recipientNonce 333
+#define OBJ_id_cmc_recipientNonce OBJ_id_cmc, 7L
+
+#define SN_id_cmc_addExtensions "id-cmc-addExtensions"
+#define NID_id_cmc_addExtensions 334
+#define OBJ_id_cmc_addExtensions OBJ_id_cmc, 8L
+
+#define SN_id_cmc_encryptedPOP "id-cmc-encryptedPOP"
+#define NID_id_cmc_encryptedPOP 335
+#define OBJ_id_cmc_encryptedPOP OBJ_id_cmc, 9L
+
+#define SN_id_cmc_decryptedPOP "id-cmc-decryptedPOP"
+#define NID_id_cmc_decryptedPOP 336
+#define OBJ_id_cmc_decryptedPOP OBJ_id_cmc, 10L
+
+#define SN_id_cmc_lraPOPWitness "id-cmc-lraPOPWitness"
+#define NID_id_cmc_lraPOPWitness 337
+#define OBJ_id_cmc_lraPOPWitness OBJ_id_cmc, 11L
+
+#define SN_id_cmc_getCert "id-cmc-getCert"
+#define NID_id_cmc_getCert 338
+#define OBJ_id_cmc_getCert OBJ_id_cmc, 15L
+
+#define SN_id_cmc_getCRL "id-cmc-getCRL"
+#define NID_id_cmc_getCRL 339
+#define OBJ_id_cmc_getCRL OBJ_id_cmc, 16L
+
+#define SN_id_cmc_revokeRequest "id-cmc-revokeRequest"
+#define NID_id_cmc_revokeRequest 340
+#define OBJ_id_cmc_revokeRequest OBJ_id_cmc, 17L
+
+#define SN_id_cmc_regInfo "id-cmc-regInfo"
+#define NID_id_cmc_regInfo 341
+#define OBJ_id_cmc_regInfo OBJ_id_cmc, 18L
+
+#define SN_id_cmc_responseInfo "id-cmc-responseInfo"
+#define NID_id_cmc_responseInfo 342
+#define OBJ_id_cmc_responseInfo OBJ_id_cmc, 19L
+
+#define SN_id_cmc_queryPending "id-cmc-queryPending"
+#define NID_id_cmc_queryPending 343
+#define OBJ_id_cmc_queryPending OBJ_id_cmc, 21L
+
+#define SN_id_cmc_popLinkRandom "id-cmc-popLinkRandom"
+#define NID_id_cmc_popLinkRandom 344
+#define OBJ_id_cmc_popLinkRandom OBJ_id_cmc, 22L
+
+#define SN_id_cmc_popLinkWitness "id-cmc-popLinkWitness"
+#define NID_id_cmc_popLinkWitness 345
+#define OBJ_id_cmc_popLinkWitness OBJ_id_cmc, 23L
+
+#define SN_id_cmc_confirmCertAcceptance "id-cmc-confirmCertAcceptance"
+#define NID_id_cmc_confirmCertAcceptance 346
+#define OBJ_id_cmc_confirmCertAcceptance OBJ_id_cmc, 24L
+
+#define SN_id_on_personalData "id-on-personalData"
+#define NID_id_on_personalData 347
+#define OBJ_id_on_personalData OBJ_id_on, 1L
+
+#define SN_id_on_permanentIdentifier "id-on-permanentIdentifier"
+#define LN_id_on_permanentIdentifier "Permanent Identifier"
+#define NID_id_on_permanentIdentifier 858
+#define OBJ_id_on_permanentIdentifier OBJ_id_on, 3L
+
+#define SN_XmppAddr "id-on-xmppAddr"
+#define LN_XmppAddr "XmppAddr"
+#define NID_XmppAddr 1209
+#define OBJ_XmppAddr OBJ_id_on, 5L
+
+#define SN_SRVName "id-on-dnsSRV"
+#define LN_SRVName "SRVName"
+#define NID_SRVName 1210
+#define OBJ_SRVName OBJ_id_on, 7L
+
+#define SN_NAIRealm "id-on-NAIRealm"
+#define LN_NAIRealm "NAIRealm"
+#define NID_NAIRealm 1211
+#define OBJ_NAIRealm OBJ_id_on, 8L
+
+#define SN_id_on_SmtpUTF8Mailbox "id-on-SmtpUTF8Mailbox"
+#define LN_id_on_SmtpUTF8Mailbox "Smtp UTF8 Mailbox"
+#define NID_id_on_SmtpUTF8Mailbox 1208
+#define OBJ_id_on_SmtpUTF8Mailbox OBJ_id_on, 9L
+
+#define SN_id_pda_dateOfBirth "id-pda-dateOfBirth"
+#define NID_id_pda_dateOfBirth 348
+#define OBJ_id_pda_dateOfBirth OBJ_id_pda, 1L
+
+#define SN_id_pda_placeOfBirth "id-pda-placeOfBirth"
+#define NID_id_pda_placeOfBirth 349
+#define OBJ_id_pda_placeOfBirth OBJ_id_pda, 2L
+
+#define SN_id_pda_gender "id-pda-gender"
+#define NID_id_pda_gender 351
+#define OBJ_id_pda_gender OBJ_id_pda, 3L
+
+#define SN_id_pda_countryOfCitizenship "id-pda-countryOfCitizenship"
+#define NID_id_pda_countryOfCitizenship 352
+#define OBJ_id_pda_countryOfCitizenship OBJ_id_pda, 4L
+
+#define SN_id_pda_countryOfResidence "id-pda-countryOfResidence"
+#define NID_id_pda_countryOfResidence 353
+#define OBJ_id_pda_countryOfResidence OBJ_id_pda, 5L
+
+#define SN_id_aca_authenticationInfo "id-aca-authenticationInfo"
+#define NID_id_aca_authenticationInfo 354
+#define OBJ_id_aca_authenticationInfo OBJ_id_aca, 1L
+
+#define SN_id_aca_accessIdentity "id-aca-accessIdentity"
+#define NID_id_aca_accessIdentity 355
+#define OBJ_id_aca_accessIdentity OBJ_id_aca, 2L
+
+#define SN_id_aca_chargingIdentity "id-aca-chargingIdentity"
+#define NID_id_aca_chargingIdentity 356
+#define OBJ_id_aca_chargingIdentity OBJ_id_aca, 3L
+
+#define SN_id_aca_group "id-aca-group"
+#define NID_id_aca_group 357
+#define OBJ_id_aca_group OBJ_id_aca, 4L
+
+#define SN_id_aca_role "id-aca-role"
+#define NID_id_aca_role 358
+#define OBJ_id_aca_role OBJ_id_aca, 5L
+
+#define SN_id_aca_encAttrs "id-aca-encAttrs"
+#define NID_id_aca_encAttrs 399
+#define OBJ_id_aca_encAttrs OBJ_id_aca, 6L
+
+#define SN_id_qcs_pkixQCSyntax_v1 "id-qcs-pkixQCSyntax-v1"
+#define NID_id_qcs_pkixQCSyntax_v1 359
+#define OBJ_id_qcs_pkixQCSyntax_v1 OBJ_id_qcs, 1L
+
+#define SN_ipAddr_asNumber "ipAddr-asNumber"
+#define NID_ipAddr_asNumber 1241
+#define OBJ_ipAddr_asNumber OBJ_id_cp, 2L
+
+#define SN_ipAddr_asNumberv2 "ipAddr-asNumberv2"
+#define NID_ipAddr_asNumberv2 1242
+#define OBJ_ipAddr_asNumberv2 OBJ_id_cp, 3L
+
+#define SN_id_cct_crs "id-cct-crs"
+#define NID_id_cct_crs 360
+#define OBJ_id_cct_crs OBJ_id_cct, 1L
+
+#define SN_id_cct_PKIData "id-cct-PKIData"
+#define NID_id_cct_PKIData 361
+#define OBJ_id_cct_PKIData OBJ_id_cct, 2L
+
+#define SN_id_cct_PKIResponse "id-cct-PKIResponse"
+#define NID_id_cct_PKIResponse 362
+#define OBJ_id_cct_PKIResponse OBJ_id_cct, 3L
+
+#define SN_id_ppl_anyLanguage "id-ppl-anyLanguage"
+#define LN_id_ppl_anyLanguage "Any language"
+#define NID_id_ppl_anyLanguage 664
+#define OBJ_id_ppl_anyLanguage OBJ_id_ppl, 0L
+
+#define SN_id_ppl_inheritAll "id-ppl-inheritAll"
+#define LN_id_ppl_inheritAll "Inherit all"
+#define NID_id_ppl_inheritAll 665
+#define OBJ_id_ppl_inheritAll OBJ_id_ppl, 1L
+
+#define SN_Independent "id-ppl-independent"
+#define LN_Independent "Independent"
+#define NID_Independent 667
+#define OBJ_Independent OBJ_id_ppl, 2L
+
+#define SN_ad_OCSP "OCSP"
+#define LN_ad_OCSP "OCSP"
+#define NID_ad_OCSP 178
+#define OBJ_ad_OCSP OBJ_id_ad, 1L
+
+#define SN_ad_ca_issuers "caIssuers"
+#define LN_ad_ca_issuers "CA Issuers"
+#define NID_ad_ca_issuers 179
+#define OBJ_ad_ca_issuers OBJ_id_ad, 2L
+
+#define SN_ad_timeStamping "ad_timestamping"
+#define LN_ad_timeStamping "AD Time Stamping"
+#define NID_ad_timeStamping 363
+#define OBJ_ad_timeStamping OBJ_id_ad, 3L
+
+#define SN_ad_dvcs "AD_DVCS"
+#define LN_ad_dvcs "ad dvcs"
+#define NID_ad_dvcs 364
+#define OBJ_ad_dvcs OBJ_id_ad, 4L
+
+#define SN_caRepository "caRepository"
+#define LN_caRepository "CA Repository"
+#define NID_caRepository 785
+#define OBJ_caRepository OBJ_id_ad, 5L
+
+#define SN_rpkiManifest "rpkiManifest"
+#define LN_rpkiManifest "RPKI Manifest"
+#define NID_rpkiManifest 1243
+#define OBJ_rpkiManifest OBJ_id_ad, 10L
+
+#define SN_signedObject "signedObject"
+#define LN_signedObject "Signed Object"
+#define NID_signedObject 1244
+#define OBJ_signedObject OBJ_id_ad, 11L
+
+#define SN_rpkiNotify "rpkiNotify"
+#define LN_rpkiNotify "RPKI Notify"
+#define NID_rpkiNotify 1245
+#define OBJ_rpkiNotify OBJ_id_ad, 13L
+
+#define OBJ_id_pkix_OCSP OBJ_ad_OCSP
+
+#define SN_id_pkix_OCSP_basic "basicOCSPResponse"
+#define LN_id_pkix_OCSP_basic "Basic OCSP Response"
+#define NID_id_pkix_OCSP_basic 365
+#define OBJ_id_pkix_OCSP_basic OBJ_id_pkix_OCSP, 1L
+
+#define SN_id_pkix_OCSP_Nonce "Nonce"
+#define LN_id_pkix_OCSP_Nonce "OCSP Nonce"
+#define NID_id_pkix_OCSP_Nonce 366
+#define OBJ_id_pkix_OCSP_Nonce OBJ_id_pkix_OCSP, 2L
+
+#define SN_id_pkix_OCSP_CrlID "CrlID"
+#define LN_id_pkix_OCSP_CrlID "OCSP CRL ID"
+#define NID_id_pkix_OCSP_CrlID 367
+#define OBJ_id_pkix_OCSP_CrlID OBJ_id_pkix_OCSP, 3L
+
+#define SN_id_pkix_OCSP_acceptableResponses "acceptableResponses"
+#define LN_id_pkix_OCSP_acceptableResponses "Acceptable OCSP Responses"
+#define NID_id_pkix_OCSP_acceptableResponses 368
+#define OBJ_id_pkix_OCSP_acceptableResponses OBJ_id_pkix_OCSP, 4L
+
+#define SN_id_pkix_OCSP_noCheck "noCheck"
+#define LN_id_pkix_OCSP_noCheck "OCSP No Check"
+#define NID_id_pkix_OCSP_noCheck 369
+#define OBJ_id_pkix_OCSP_noCheck OBJ_id_pkix_OCSP, 5L
+
+#define SN_id_pkix_OCSP_archiveCutoff "archiveCutoff"
+#define LN_id_pkix_OCSP_archiveCutoff "OCSP Archive Cutoff"
+#define NID_id_pkix_OCSP_archiveCutoff 370
+#define OBJ_id_pkix_OCSP_archiveCutoff OBJ_id_pkix_OCSP, 6L
+
+#define SN_id_pkix_OCSP_serviceLocator "serviceLocator"
+#define LN_id_pkix_OCSP_serviceLocator "OCSP Service Locator"
+#define NID_id_pkix_OCSP_serviceLocator 371
+#define OBJ_id_pkix_OCSP_serviceLocator OBJ_id_pkix_OCSP, 7L
+
+#define SN_id_pkix_OCSP_extendedStatus "extendedStatus"
+#define LN_id_pkix_OCSP_extendedStatus "Extended OCSP Status"
+#define NID_id_pkix_OCSP_extendedStatus 372
+#define OBJ_id_pkix_OCSP_extendedStatus OBJ_id_pkix_OCSP, 8L
+
+#define SN_id_pkix_OCSP_valid "valid"
+#define NID_id_pkix_OCSP_valid 373
+#define OBJ_id_pkix_OCSP_valid OBJ_id_pkix_OCSP, 9L
+
+#define SN_id_pkix_OCSP_path "path"
+#define NID_id_pkix_OCSP_path 374
+#define OBJ_id_pkix_OCSP_path OBJ_id_pkix_OCSP, 10L
+
+#define SN_id_pkix_OCSP_trustRoot "trustRoot"
+#define LN_id_pkix_OCSP_trustRoot "Trust Root"
+#define NID_id_pkix_OCSP_trustRoot 375
+#define OBJ_id_pkix_OCSP_trustRoot OBJ_id_pkix_OCSP, 11L
+
+#define SN_algorithm "algorithm"
+#define LN_algorithm "algorithm"
+#define NID_algorithm 376
+#define OBJ_algorithm 1L, 3L, 14L, 3L, 2L
+
+#define SN_md5WithRSA "RSA-NP-MD5"
+#define LN_md5WithRSA "md5WithRSA"
+#define NID_md5WithRSA 104
+#define OBJ_md5WithRSA OBJ_algorithm, 3L
+
+#define SN_des_ecb "DES-ECB"
+#define LN_des_ecb "des-ecb"
+#define NID_des_ecb 29
+#define OBJ_des_ecb OBJ_algorithm, 6L
+
+#define SN_des_cbc "DES-CBC"
+#define LN_des_cbc "des-cbc"
+#define NID_des_cbc 31
+#define OBJ_des_cbc OBJ_algorithm, 7L
+
+#define SN_des_ofb64 "DES-OFB"
+#define LN_des_ofb64 "des-ofb"
+#define NID_des_ofb64 45
+#define OBJ_des_ofb64 OBJ_algorithm, 8L
+
+#define SN_des_cfb64 "DES-CFB"
+#define LN_des_cfb64 "des-cfb"
+#define NID_des_cfb64 30
+#define OBJ_des_cfb64 OBJ_algorithm, 9L
+
+#define SN_rsaSignature "rsaSignature"
+#define NID_rsaSignature 377
+#define OBJ_rsaSignature OBJ_algorithm, 11L
+
+#define SN_dsa_2 "DSA-old"
+#define LN_dsa_2 "dsaEncryption-old"
+#define NID_dsa_2 67
+#define OBJ_dsa_2 OBJ_algorithm, 12L
+
+#define SN_dsaWithSHA "DSA-SHA"
+#define LN_dsaWithSHA "dsaWithSHA"
+#define NID_dsaWithSHA 66
+#define OBJ_dsaWithSHA OBJ_algorithm, 13L
+
+#define SN_shaWithRSAEncryption "RSA-SHA"
+#define LN_shaWithRSAEncryption "shaWithRSAEncryption"
+#define NID_shaWithRSAEncryption 42
+#define OBJ_shaWithRSAEncryption OBJ_algorithm, 15L
+
+#define SN_des_ede_ecb "DES-EDE"
+#define LN_des_ede_ecb "des-ede"
+#define NID_des_ede_ecb 32
+#define OBJ_des_ede_ecb OBJ_algorithm, 17L
+
+#define SN_des_ede3_ecb "DES-EDE3"
+#define LN_des_ede3_ecb "des-ede3"
+#define NID_des_ede3_ecb 33
+
+#define SN_des_ede_cbc "DES-EDE-CBC"
+#define LN_des_ede_cbc "des-ede-cbc"
+#define NID_des_ede_cbc 43
+
+#define SN_des_ede_cfb64 "DES-EDE-CFB"
+#define LN_des_ede_cfb64 "des-ede-cfb"
+#define NID_des_ede_cfb64 60
+
+#define SN_des_ede3_cfb64 "DES-EDE3-CFB"
+#define LN_des_ede3_cfb64 "des-ede3-cfb"
+#define NID_des_ede3_cfb64 61
+
+#define SN_des_ede_ofb64 "DES-EDE-OFB"
+#define LN_des_ede_ofb64 "des-ede-ofb"
+#define NID_des_ede_ofb64 62
+
+#define SN_des_ede3_ofb64 "DES-EDE3-OFB"
+#define LN_des_ede3_ofb64 "des-ede3-ofb"
+#define NID_des_ede3_ofb64 63
+
+#define SN_desx_cbc "DESX-CBC"
+#define LN_desx_cbc "desx-cbc"
+#define NID_desx_cbc 80
+
+#define SN_sha "SHA"
+#define LN_sha "sha"
+#define NID_sha 41
+#define OBJ_sha OBJ_algorithm, 18L
+
+#define SN_sha1 "SHA1"
+#define LN_sha1 "sha1"
+#define NID_sha1 64
+#define OBJ_sha1 OBJ_algorithm, 26L
+
+#define SN_dsaWithSHA1_2 "DSA-SHA1-old"
+#define LN_dsaWithSHA1_2 "dsaWithSHA1-old"
+#define NID_dsaWithSHA1_2 70
+#define OBJ_dsaWithSHA1_2 OBJ_algorithm, 27L
+
+#define SN_sha1WithRSA "RSA-SHA1-2"
+#define LN_sha1WithRSA "sha1WithRSA"
+#define NID_sha1WithRSA 115
+#define OBJ_sha1WithRSA OBJ_algorithm, 29L
+
+#define SN_ripemd160 "RIPEMD160"
+#define LN_ripemd160 "ripemd160"
+#define NID_ripemd160 117
+#define OBJ_ripemd160 1L, 3L, 36L, 3L, 2L, 1L
+
+#define SN_ripemd160WithRSA "RSA-RIPEMD160"
+#define LN_ripemd160WithRSA "ripemd160WithRSA"
+#define NID_ripemd160WithRSA 119
+#define OBJ_ripemd160WithRSA 1L, 3L, 36L, 3L, 3L, 1L, 2L
+
+#define SN_blake2bmac "BLAKE2BMAC"
+#define LN_blake2bmac "blake2bmac"
+#define NID_blake2bmac 1201
+#define OBJ_blake2bmac 1L, 3L, 6L, 1L, 4L, 1L, 1722L, 12L, 2L, 1L
+
+#define SN_blake2smac "BLAKE2SMAC"
+#define LN_blake2smac "blake2smac"
+#define NID_blake2smac 1202
+#define OBJ_blake2smac 1L, 3L, 6L, 1L, 4L, 1L, 1722L, 12L, 2L, 2L
+
+#define SN_blake2b512 "BLAKE2b512"
+#define LN_blake2b512 "blake2b512"
+#define NID_blake2b512 1056
+#define OBJ_blake2b512 OBJ_blake2bmac, 16L
+
+#define SN_blake2s256 "BLAKE2s256"
+#define LN_blake2s256 "blake2s256"
+#define NID_blake2s256 1057
+#define OBJ_blake2s256 OBJ_blake2smac, 8L
+
+#define SN_sxnet "SXNetID"
+#define LN_sxnet "Strong Extranet ID"
+#define NID_sxnet 143
+#define OBJ_sxnet 1L, 3L, 101L, 1L, 4L, 1L
+
+#define SN_X500 "X500"
+#define LN_X500 "directory services (X.500)"
+#define NID_X500 11
+#define OBJ_X500 2L, 5L
+
+#define SN_X509 "X509"
+#define NID_X509 12
+#define OBJ_X509 OBJ_X500, 4L
+
+#define SN_commonName "CN"
+#define LN_commonName "commonName"
+#define NID_commonName 13
+#define OBJ_commonName OBJ_X509, 3L
+
+#define SN_surname "SN"
+#define LN_surname "surname"
+#define NID_surname 100
+#define OBJ_surname OBJ_X509, 4L
+
+#define LN_serialNumber "serialNumber"
+#define NID_serialNumber 105
+#define OBJ_serialNumber OBJ_X509, 5L
+
+#define SN_countryName "C"
+#define LN_countryName "countryName"
+#define NID_countryName 14
+#define OBJ_countryName OBJ_X509, 6L
+
+#define SN_localityName "L"
+#define LN_localityName "localityName"
+#define NID_localityName 15
+#define OBJ_localityName OBJ_X509, 7L
+
+#define SN_stateOrProvinceName "ST"
+#define LN_stateOrProvinceName "stateOrProvinceName"
+#define NID_stateOrProvinceName 16
+#define OBJ_stateOrProvinceName OBJ_X509, 8L
+
+#define SN_streetAddress "street"
+#define LN_streetAddress "streetAddress"
+#define NID_streetAddress 660
+#define OBJ_streetAddress OBJ_X509, 9L
+
+#define SN_organizationName "O"
+#define LN_organizationName "organizationName"
+#define NID_organizationName 17
+#define OBJ_organizationName OBJ_X509, 10L
+
+#define SN_organizationalUnitName "OU"
+#define LN_organizationalUnitName "organizationalUnitName"
+#define NID_organizationalUnitName 18
+#define OBJ_organizationalUnitName OBJ_X509, 11L
+
+#define SN_title "title"
+#define LN_title "title"
+#define NID_title 106
+#define OBJ_title OBJ_X509, 12L
+
+#define LN_description "description"
+#define NID_description 107
+#define OBJ_description OBJ_X509, 13L
+
+#define LN_searchGuide "searchGuide"
+#define NID_searchGuide 859
+#define OBJ_searchGuide OBJ_X509, 14L
+
+#define LN_businessCategory "businessCategory"
+#define NID_businessCategory 860
+#define OBJ_businessCategory OBJ_X509, 15L
+
+#define LN_postalAddress "postalAddress"
+#define NID_postalAddress 861
+#define OBJ_postalAddress OBJ_X509, 16L
+
+#define LN_postalCode "postalCode"
+#define NID_postalCode 661
+#define OBJ_postalCode OBJ_X509, 17L
+
+#define LN_postOfficeBox "postOfficeBox"
+#define NID_postOfficeBox 862
+#define OBJ_postOfficeBox OBJ_X509, 18L
+
+#define LN_physicalDeliveryOfficeName "physicalDeliveryOfficeName"
+#define NID_physicalDeliveryOfficeName 863
+#define OBJ_physicalDeliveryOfficeName OBJ_X509, 19L
+
+#define LN_telephoneNumber "telephoneNumber"
+#define NID_telephoneNumber 864
+#define OBJ_telephoneNumber OBJ_X509, 20L
+
+#define LN_telexNumber "telexNumber"
+#define NID_telexNumber 865
+#define OBJ_telexNumber OBJ_X509, 21L
+
+#define LN_teletexTerminalIdentifier "teletexTerminalIdentifier"
+#define NID_teletexTerminalIdentifier 866
+#define OBJ_teletexTerminalIdentifier OBJ_X509, 22L
+
+#define LN_facsimileTelephoneNumber "facsimileTelephoneNumber"
+#define NID_facsimileTelephoneNumber 867
+#define OBJ_facsimileTelephoneNumber OBJ_X509, 23L
+
+#define LN_x121Address "x121Address"
+#define NID_x121Address 868
+#define OBJ_x121Address OBJ_X509, 24L
+
+#define LN_internationaliSDNNumber "internationaliSDNNumber"
+#define NID_internationaliSDNNumber 869
+#define OBJ_internationaliSDNNumber OBJ_X509, 25L
+
+#define LN_registeredAddress "registeredAddress"
+#define NID_registeredAddress 870
+#define OBJ_registeredAddress OBJ_X509, 26L
+
+#define LN_destinationIndicator "destinationIndicator"
+#define NID_destinationIndicator 871
+#define OBJ_destinationIndicator OBJ_X509, 27L
+
+#define LN_preferredDeliveryMethod "preferredDeliveryMethod"
+#define NID_preferredDeliveryMethod 872
+#define OBJ_preferredDeliveryMethod OBJ_X509, 28L
+
+#define LN_presentationAddress "presentationAddress"
+#define NID_presentationAddress 873
+#define OBJ_presentationAddress OBJ_X509, 29L
+
+#define LN_supportedApplicationContext "supportedApplicationContext"
+#define NID_supportedApplicationContext 874
+#define OBJ_supportedApplicationContext OBJ_X509, 30L
+
+#define SN_member "member"
+#define NID_member 875
+#define OBJ_member OBJ_X509, 31L
+
+#define SN_owner "owner"
+#define NID_owner 876
+#define OBJ_owner OBJ_X509, 32L
+
+#define LN_roleOccupant "roleOccupant"
+#define NID_roleOccupant 877
+#define OBJ_roleOccupant OBJ_X509, 33L
+
+#define SN_seeAlso "seeAlso"
+#define NID_seeAlso 878
+#define OBJ_seeAlso OBJ_X509, 34L
+
+#define LN_userPassword "userPassword"
+#define NID_userPassword 879
+#define OBJ_userPassword OBJ_X509, 35L
+
+#define LN_userCertificate "userCertificate"
+#define NID_userCertificate 880
+#define OBJ_userCertificate OBJ_X509, 36L
+
+#define LN_cACertificate "cACertificate"
+#define NID_cACertificate 881
+#define OBJ_cACertificate OBJ_X509, 37L
+
+#define LN_authorityRevocationList "authorityRevocationList"
+#define NID_authorityRevocationList 882
+#define OBJ_authorityRevocationList OBJ_X509, 38L
+
+#define LN_certificateRevocationList "certificateRevocationList"
+#define NID_certificateRevocationList 883
+#define OBJ_certificateRevocationList OBJ_X509, 39L
+
+#define LN_crossCertificatePair "crossCertificatePair"
+#define NID_crossCertificatePair 884
+#define OBJ_crossCertificatePair OBJ_X509, 40L
+
+#define SN_name "name"
+#define LN_name "name"
+#define NID_name 173
+#define OBJ_name OBJ_X509, 41L
+
+#define SN_givenName "GN"
+#define LN_givenName "givenName"
+#define NID_givenName 99
+#define OBJ_givenName OBJ_X509, 42L
+
+#define SN_initials "initials"
+#define LN_initials "initials"
+#define NID_initials 101
+#define OBJ_initials OBJ_X509, 43L
+
+#define LN_generationQualifier "generationQualifier"
+#define NID_generationQualifier 509
+#define OBJ_generationQualifier OBJ_X509, 44L
+
+#define LN_x500UniqueIdentifier "x500UniqueIdentifier"
+#define NID_x500UniqueIdentifier 503
+#define OBJ_x500UniqueIdentifier OBJ_X509, 45L
+
+#define SN_dnQualifier "dnQualifier"
+#define LN_dnQualifier "dnQualifier"
+#define NID_dnQualifier 174
+#define OBJ_dnQualifier OBJ_X509, 46L
+
+#define LN_enhancedSearchGuide "enhancedSearchGuide"
+#define NID_enhancedSearchGuide 885
+#define OBJ_enhancedSearchGuide OBJ_X509, 47L
+
+#define LN_protocolInformation "protocolInformation"
+#define NID_protocolInformation 886
+#define OBJ_protocolInformation OBJ_X509, 48L
+
+#define LN_distinguishedName "distinguishedName"
+#define NID_distinguishedName 887
+#define OBJ_distinguishedName OBJ_X509, 49L
+
+#define LN_uniqueMember "uniqueMember"
+#define NID_uniqueMember 888
+#define OBJ_uniqueMember OBJ_X509, 50L
+
+#define LN_houseIdentifier "houseIdentifier"
+#define NID_houseIdentifier 889
+#define OBJ_houseIdentifier OBJ_X509, 51L
+
+#define LN_supportedAlgorithms "supportedAlgorithms"
+#define NID_supportedAlgorithms 890
+#define OBJ_supportedAlgorithms OBJ_X509, 52L
+
+#define LN_deltaRevocationList "deltaRevocationList"
+#define NID_deltaRevocationList 891
+#define OBJ_deltaRevocationList OBJ_X509, 53L
+
+#define SN_dmdName "dmdName"
+#define NID_dmdName 892
+#define OBJ_dmdName OBJ_X509, 54L
+
+#define LN_pseudonym "pseudonym"
+#define NID_pseudonym 510
+#define OBJ_pseudonym OBJ_X509, 65L
+
+#define SN_role "role"
+#define LN_role "role"
+#define NID_role 400
+#define OBJ_role OBJ_X509, 72L
+
+#define LN_organizationIdentifier "organizationIdentifier"
+#define NID_organizationIdentifier 1089
+#define OBJ_organizationIdentifier OBJ_X509, 97L
+
+#define SN_countryCode3c "c3"
+#define LN_countryCode3c "countryCode3c"
+#define NID_countryCode3c 1090
+#define OBJ_countryCode3c OBJ_X509, 98L
+
+#define SN_countryCode3n "n3"
+#define LN_countryCode3n "countryCode3n"
+#define NID_countryCode3n 1091
+#define OBJ_countryCode3n OBJ_X509, 99L
+
+#define LN_dnsName "dnsName"
+#define NID_dnsName 1092
+#define OBJ_dnsName OBJ_X509, 100L
+
+#define SN_X500algorithms "X500algorithms"
+#define LN_X500algorithms "directory services - algorithms"
+#define NID_X500algorithms 378
+#define OBJ_X500algorithms OBJ_X500, 8L
+
+#define SN_rsa "RSA"
+#define LN_rsa "rsa"
+#define NID_rsa 19
+#define OBJ_rsa OBJ_X500algorithms, 1L, 1L
+
+#define SN_mdc2WithRSA "RSA-MDC2"
+#define LN_mdc2WithRSA "mdc2WithRSA"
+#define NID_mdc2WithRSA 96
+#define OBJ_mdc2WithRSA OBJ_X500algorithms, 3L, 100L
+
+#define SN_mdc2 "MDC2"
+#define LN_mdc2 "mdc2"
+#define NID_mdc2 95
+#define OBJ_mdc2 OBJ_X500algorithms, 3L, 101L
+
+#define SN_id_ce "id-ce"
+#define NID_id_ce 81
+#define OBJ_id_ce OBJ_X500, 29L
+
+#define SN_subject_directory_attributes "subjectDirectoryAttributes"
+#define LN_subject_directory_attributes "X509v3 Subject Directory Attributes"
+#define NID_subject_directory_attributes 769
+#define OBJ_subject_directory_attributes OBJ_id_ce, 9L
+
+#define SN_subject_key_identifier "subjectKeyIdentifier"
+#define LN_subject_key_identifier "X509v3 Subject Key Identifier"
+#define NID_subject_key_identifier 82
+#define OBJ_subject_key_identifier OBJ_id_ce, 14L
+
+#define SN_key_usage "keyUsage"
+#define LN_key_usage "X509v3 Key Usage"
+#define NID_key_usage 83
+#define OBJ_key_usage OBJ_id_ce, 15L
+
+#define SN_private_key_usage_period "privateKeyUsagePeriod"
+#define LN_private_key_usage_period "X509v3 Private Key Usage Period"
+#define NID_private_key_usage_period 84
+#define OBJ_private_key_usage_period OBJ_id_ce, 16L
+
+#define SN_subject_alt_name "subjectAltName"
+#define LN_subject_alt_name "X509v3 Subject Alternative Name"
+#define NID_subject_alt_name 85
+#define OBJ_subject_alt_name OBJ_id_ce, 17L
+
+#define SN_issuer_alt_name "issuerAltName"
+#define LN_issuer_alt_name "X509v3 Issuer Alternative Name"
+#define NID_issuer_alt_name 86
+#define OBJ_issuer_alt_name OBJ_id_ce, 18L
+
+#define SN_basic_constraints "basicConstraints"
+#define LN_basic_constraints "X509v3 Basic Constraints"
+#define NID_basic_constraints 87
+#define OBJ_basic_constraints OBJ_id_ce, 19L
+
+#define SN_crl_number "crlNumber"
+#define LN_crl_number "X509v3 CRL Number"
+#define NID_crl_number 88
+#define OBJ_crl_number OBJ_id_ce, 20L
+
+#define SN_crl_reason "CRLReason"
+#define LN_crl_reason "X509v3 CRL Reason Code"
+#define NID_crl_reason 141
+#define OBJ_crl_reason OBJ_id_ce, 21L
+
+#define SN_invalidity_date "invalidityDate"
+#define LN_invalidity_date "Invalidity Date"
+#define NID_invalidity_date 142
+#define OBJ_invalidity_date OBJ_id_ce, 24L
+
+#define SN_delta_crl "deltaCRL"
+#define LN_delta_crl "X509v3 Delta CRL Indicator"
+#define NID_delta_crl 140
+#define OBJ_delta_crl OBJ_id_ce, 27L
+
+#define SN_issuing_distribution_point "issuingDistributionPoint"
+#define LN_issuing_distribution_point "X509v3 Issuing Distribution Point"
+#define NID_issuing_distribution_point 770
+#define OBJ_issuing_distribution_point OBJ_id_ce, 28L
+
+#define SN_certificate_issuer "certificateIssuer"
+#define LN_certificate_issuer "X509v3 Certificate Issuer"
+#define NID_certificate_issuer 771
+#define OBJ_certificate_issuer OBJ_id_ce, 29L
+
+#define SN_name_constraints "nameConstraints"
+#define LN_name_constraints "X509v3 Name Constraints"
+#define NID_name_constraints 666
+#define OBJ_name_constraints OBJ_id_ce, 30L
+
+#define SN_crl_distribution_points "crlDistributionPoints"
+#define LN_crl_distribution_points "X509v3 CRL Distribution Points"
+#define NID_crl_distribution_points 103
+#define OBJ_crl_distribution_points OBJ_id_ce, 31L
+
+#define SN_certificate_policies "certificatePolicies"
+#define LN_certificate_policies "X509v3 Certificate Policies"
+#define NID_certificate_policies 89
+#define OBJ_certificate_policies OBJ_id_ce, 32L
+
+#define SN_any_policy "anyPolicy"
+#define LN_any_policy "X509v3 Any Policy"
+#define NID_any_policy 746
+#define OBJ_any_policy OBJ_certificate_policies, 0L
+
+#define SN_policy_mappings "policyMappings"
+#define LN_policy_mappings "X509v3 Policy Mappings"
+#define NID_policy_mappings 747
+#define OBJ_policy_mappings OBJ_id_ce, 33L
+
+#define SN_authority_key_identifier "authorityKeyIdentifier"
+#define LN_authority_key_identifier "X509v3 Authority Key Identifier"
+#define NID_authority_key_identifier 90
+#define OBJ_authority_key_identifier OBJ_id_ce, 35L
+
+#define SN_policy_constraints "policyConstraints"
+#define LN_policy_constraints "X509v3 Policy Constraints"
+#define NID_policy_constraints 401
+#define OBJ_policy_constraints OBJ_id_ce, 36L
+
+#define SN_ext_key_usage "extendedKeyUsage"
+#define LN_ext_key_usage "X509v3 Extended Key Usage"
+#define NID_ext_key_usage 126
+#define OBJ_ext_key_usage OBJ_id_ce, 37L
+
+#define SN_freshest_crl "freshestCRL"
+#define LN_freshest_crl "X509v3 Freshest CRL"
+#define NID_freshest_crl 857
+#define OBJ_freshest_crl OBJ_id_ce, 46L
+
+#define SN_inhibit_any_policy "inhibitAnyPolicy"
+#define LN_inhibit_any_policy "X509v3 Inhibit Any Policy"
+#define NID_inhibit_any_policy 748
+#define OBJ_inhibit_any_policy OBJ_id_ce, 54L
+
+#define SN_target_information "targetInformation"
+#define LN_target_information "X509v3 AC Targeting"
+#define NID_target_information 402
+#define OBJ_target_information OBJ_id_ce, 55L
+
+#define SN_no_rev_avail "noRevAvail"
+#define LN_no_rev_avail "X509v3 No Revocation Available"
+#define NID_no_rev_avail 403
+#define OBJ_no_rev_avail OBJ_id_ce, 56L
+
+#define SN_anyExtendedKeyUsage "anyExtendedKeyUsage"
+#define LN_anyExtendedKeyUsage "Any Extended Key Usage"
+#define NID_anyExtendedKeyUsage 910
+#define OBJ_anyExtendedKeyUsage OBJ_ext_key_usage, 0L
+
+#define SN_netscape "Netscape"
+#define LN_netscape "Netscape Communications Corp."
+#define NID_netscape 57
+#define OBJ_netscape 2L, 16L, 840L, 1L, 113730L
+
+#define SN_netscape_cert_extension "nsCertExt"
+#define LN_netscape_cert_extension "Netscape Certificate Extension"
+#define NID_netscape_cert_extension 58
+#define OBJ_netscape_cert_extension OBJ_netscape, 1L
+
+#define SN_netscape_data_type "nsDataType"
+#define LN_netscape_data_type "Netscape Data Type"
+#define NID_netscape_data_type 59
+#define OBJ_netscape_data_type OBJ_netscape, 2L
+
+#define SN_netscape_cert_type "nsCertType"
+#define LN_netscape_cert_type "Netscape Cert Type"
+#define NID_netscape_cert_type 71
+#define OBJ_netscape_cert_type OBJ_netscape_cert_extension, 1L
+
+#define SN_netscape_base_url "nsBaseUrl"
+#define LN_netscape_base_url "Netscape Base Url"
+#define NID_netscape_base_url 72
+#define OBJ_netscape_base_url OBJ_netscape_cert_extension, 2L
+
+#define SN_netscape_revocation_url "nsRevocationUrl"
+#define LN_netscape_revocation_url "Netscape Revocation Url"
+#define NID_netscape_revocation_url 73
+#define OBJ_netscape_revocation_url OBJ_netscape_cert_extension, 3L
+
+#define SN_netscape_ca_revocation_url "nsCaRevocationUrl"
+#define LN_netscape_ca_revocation_url "Netscape CA Revocation Url"
+#define NID_netscape_ca_revocation_url 74
+#define OBJ_netscape_ca_revocation_url OBJ_netscape_cert_extension, 4L
+
+#define SN_netscape_renewal_url "nsRenewalUrl"
+#define LN_netscape_renewal_url "Netscape Renewal Url"
+#define NID_netscape_renewal_url 75
+#define OBJ_netscape_renewal_url OBJ_netscape_cert_extension, 7L
+
+#define SN_netscape_ca_policy_url "nsCaPolicyUrl"
+#define LN_netscape_ca_policy_url "Netscape CA Policy Url"
+#define NID_netscape_ca_policy_url 76
+#define OBJ_netscape_ca_policy_url OBJ_netscape_cert_extension, 8L
+
+#define SN_netscape_ssl_server_name "nsSslServerName"
+#define LN_netscape_ssl_server_name "Netscape SSL Server Name"
+#define NID_netscape_ssl_server_name 77
+#define OBJ_netscape_ssl_server_name OBJ_netscape_cert_extension, 12L
+
+#define SN_netscape_comment "nsComment"
+#define LN_netscape_comment "Netscape Comment"
+#define NID_netscape_comment 78
+#define OBJ_netscape_comment OBJ_netscape_cert_extension, 13L
+
+#define SN_netscape_cert_sequence "nsCertSequence"
+#define LN_netscape_cert_sequence "Netscape Certificate Sequence"
+#define NID_netscape_cert_sequence 79
+#define OBJ_netscape_cert_sequence OBJ_netscape_data_type, 5L
+
+#define SN_ns_sgc "nsSGC"
+#define LN_ns_sgc "Netscape Server Gated Crypto"
+#define NID_ns_sgc 139
+#define OBJ_ns_sgc OBJ_netscape, 4L, 1L
+
+#define SN_org "ORG"
+#define LN_org "org"
+#define NID_org 379
+#define OBJ_org OBJ_iso, 3L
+
+#define SN_dod "DOD"
+#define LN_dod "dod"
+#define NID_dod 380
+#define OBJ_dod OBJ_org, 6L
+
+#define SN_iana "IANA"
+#define LN_iana "iana"
+#define NID_iana 381
+#define OBJ_iana OBJ_dod, 1L
+
+#define OBJ_internet OBJ_iana
+
+#define SN_Directory "directory"
+#define LN_Directory "Directory"
+#define NID_Directory 382
+#define OBJ_Directory OBJ_internet, 1L
+
+#define SN_Management "mgmt"
+#define LN_Management "Management"
+#define NID_Management 383
+#define OBJ_Management OBJ_internet, 2L
+
+#define SN_Experimental "experimental"
+#define LN_Experimental "Experimental"
+#define NID_Experimental 384
+#define OBJ_Experimental OBJ_internet, 3L
+
+#define SN_Private "private"
+#define LN_Private "Private"
+#define NID_Private 385
+#define OBJ_Private OBJ_internet, 4L
+
+#define SN_Security "security"
+#define LN_Security "Security"
+#define NID_Security 386
+#define OBJ_Security OBJ_internet, 5L
+
+#define SN_SNMPv2 "snmpv2"
+#define LN_SNMPv2 "SNMPv2"
+#define NID_SNMPv2 387
+#define OBJ_SNMPv2 OBJ_internet, 6L
+
+#define LN_Mail "Mail"
+#define NID_Mail 388
+#define OBJ_Mail OBJ_internet, 7L
+
+#define SN_Enterprises "enterprises"
+#define LN_Enterprises "Enterprises"
+#define NID_Enterprises 389
+#define OBJ_Enterprises OBJ_Private, 1L
+
+#define SN_dcObject "dcobject"
+#define LN_dcObject "dcObject"
+#define NID_dcObject 390
+#define OBJ_dcObject OBJ_Enterprises, 1466L, 344L
+
+#define SN_mime_mhs "mime-mhs"
+#define LN_mime_mhs "MIME MHS"
+#define NID_mime_mhs 504
+#define OBJ_mime_mhs OBJ_Mail, 1L
+
+#define SN_mime_mhs_headings "mime-mhs-headings"
+#define LN_mime_mhs_headings "mime-mhs-headings"
+#define NID_mime_mhs_headings 505
+#define OBJ_mime_mhs_headings OBJ_mime_mhs, 1L
+
+#define SN_mime_mhs_bodies "mime-mhs-bodies"
+#define LN_mime_mhs_bodies "mime-mhs-bodies"
+#define NID_mime_mhs_bodies 506
+#define OBJ_mime_mhs_bodies OBJ_mime_mhs, 2L
+
+#define SN_id_hex_partial_message "id-hex-partial-message"
+#define LN_id_hex_partial_message "id-hex-partial-message"
+#define NID_id_hex_partial_message 507
+#define OBJ_id_hex_partial_message OBJ_mime_mhs_headings, 1L
+
+#define SN_id_hex_multipart_message "id-hex-multipart-message"
+#define LN_id_hex_multipart_message "id-hex-multipart-message"
+#define NID_id_hex_multipart_message 508
+#define OBJ_id_hex_multipart_message OBJ_mime_mhs_headings, 2L
+
+#define SN_zlib_compression "ZLIB"
+#define LN_zlib_compression "zlib compression"
+#define NID_zlib_compression 125
+#define OBJ_zlib_compression OBJ_id_smime_alg, 8L
+
+#define OBJ_csor 2L, 16L, 840L, 1L, 101L, 3L
+
+#define OBJ_nistAlgorithms OBJ_csor, 4L
+
+#define OBJ_aes OBJ_nistAlgorithms, 1L
+
+#define SN_aes_128_ecb "AES-128-ECB"
+#define LN_aes_128_ecb "aes-128-ecb"
+#define NID_aes_128_ecb 418
+#define OBJ_aes_128_ecb OBJ_aes, 1L
+
+#define SN_aes_128_cbc "AES-128-CBC"
+#define LN_aes_128_cbc "aes-128-cbc"
+#define NID_aes_128_cbc 419
+#define OBJ_aes_128_cbc OBJ_aes, 2L
+
+#define SN_aes_128_ofb128 "AES-128-OFB"
+#define LN_aes_128_ofb128 "aes-128-ofb"
+#define NID_aes_128_ofb128 420
+#define OBJ_aes_128_ofb128 OBJ_aes, 3L
+
+#define SN_aes_128_cfb128 "AES-128-CFB"
+#define LN_aes_128_cfb128 "aes-128-cfb"
+#define NID_aes_128_cfb128 421
+#define OBJ_aes_128_cfb128 OBJ_aes, 4L
+
+#define SN_id_aes128_wrap "id-aes128-wrap"
+#define NID_id_aes128_wrap 788
+#define OBJ_id_aes128_wrap OBJ_aes, 5L
+
+#define SN_aes_128_gcm "id-aes128-GCM"
+#define LN_aes_128_gcm "aes-128-gcm"
+#define NID_aes_128_gcm 895
+#define OBJ_aes_128_gcm OBJ_aes, 6L
+
+#define SN_aes_128_ccm "id-aes128-CCM"
+#define LN_aes_128_ccm "aes-128-ccm"
+#define NID_aes_128_ccm 896
+#define OBJ_aes_128_ccm OBJ_aes, 7L
+
+#define SN_id_aes128_wrap_pad "id-aes128-wrap-pad"
+#define NID_id_aes128_wrap_pad 897
+#define OBJ_id_aes128_wrap_pad OBJ_aes, 8L
+
+#define SN_aes_192_ecb "AES-192-ECB"
+#define LN_aes_192_ecb "aes-192-ecb"
+#define NID_aes_192_ecb 422
+#define OBJ_aes_192_ecb OBJ_aes, 21L
+
+#define SN_aes_192_cbc "AES-192-CBC"
+#define LN_aes_192_cbc "aes-192-cbc"
+#define NID_aes_192_cbc 423
+#define OBJ_aes_192_cbc OBJ_aes, 22L
+
+#define SN_aes_192_ofb128 "AES-192-OFB"
+#define LN_aes_192_ofb128 "aes-192-ofb"
+#define NID_aes_192_ofb128 424
+#define OBJ_aes_192_ofb128 OBJ_aes, 23L
+
+#define SN_aes_192_cfb128 "AES-192-CFB"
+#define LN_aes_192_cfb128 "aes-192-cfb"
+#define NID_aes_192_cfb128 425
+#define OBJ_aes_192_cfb128 OBJ_aes, 24L
+
+#define SN_id_aes192_wrap "id-aes192-wrap"
+#define NID_id_aes192_wrap 789
+#define OBJ_id_aes192_wrap OBJ_aes, 25L
+
+#define SN_aes_192_gcm "id-aes192-GCM"
+#define LN_aes_192_gcm "aes-192-gcm"
+#define NID_aes_192_gcm 898
+#define OBJ_aes_192_gcm OBJ_aes, 26L
+
+#define SN_aes_192_ccm "id-aes192-CCM"
+#define LN_aes_192_ccm "aes-192-ccm"
+#define NID_aes_192_ccm 899
+#define OBJ_aes_192_ccm OBJ_aes, 27L
+
+#define SN_id_aes192_wrap_pad "id-aes192-wrap-pad"
+#define NID_id_aes192_wrap_pad 900
+#define OBJ_id_aes192_wrap_pad OBJ_aes, 28L
+
+#define SN_aes_256_ecb "AES-256-ECB"
+#define LN_aes_256_ecb "aes-256-ecb"
+#define NID_aes_256_ecb 426
+#define OBJ_aes_256_ecb OBJ_aes, 41L
+
+#define SN_aes_256_cbc "AES-256-CBC"
+#define LN_aes_256_cbc "aes-256-cbc"
+#define NID_aes_256_cbc 427
+#define OBJ_aes_256_cbc OBJ_aes, 42L
+
+#define SN_aes_256_ofb128 "AES-256-OFB"
+#define LN_aes_256_ofb128 "aes-256-ofb"
+#define NID_aes_256_ofb128 428
+#define OBJ_aes_256_ofb128 OBJ_aes, 43L
+
+#define SN_aes_256_cfb128 "AES-256-CFB"
+#define LN_aes_256_cfb128 "aes-256-cfb"
+#define NID_aes_256_cfb128 429
+#define OBJ_aes_256_cfb128 OBJ_aes, 44L
+
+#define SN_id_aes256_wrap "id-aes256-wrap"
+#define NID_id_aes256_wrap 790
+#define OBJ_id_aes256_wrap OBJ_aes, 45L
+
+#define SN_aes_256_gcm "id-aes256-GCM"
+#define LN_aes_256_gcm "aes-256-gcm"
+#define NID_aes_256_gcm 901
+#define OBJ_aes_256_gcm OBJ_aes, 46L
+
+#define SN_aes_256_ccm "id-aes256-CCM"
+#define LN_aes_256_ccm "aes-256-ccm"
+#define NID_aes_256_ccm 902
+#define OBJ_aes_256_ccm OBJ_aes, 47L
+
+#define SN_id_aes256_wrap_pad "id-aes256-wrap-pad"
+#define NID_id_aes256_wrap_pad 903
+#define OBJ_id_aes256_wrap_pad OBJ_aes, 48L
+
+#define SN_aes_128_xts "AES-128-XTS"
+#define LN_aes_128_xts "aes-128-xts"
+#define NID_aes_128_xts 913
+#define OBJ_aes_128_xts OBJ_ieee_siswg, 0L, 1L, 1L
+
+#define SN_aes_256_xts "AES-256-XTS"
+#define LN_aes_256_xts "aes-256-xts"
+#define NID_aes_256_xts 914
+#define OBJ_aes_256_xts OBJ_ieee_siswg, 0L, 1L, 2L
+
+#define SN_aes_128_cfb1 "AES-128-CFB1"
+#define LN_aes_128_cfb1 "aes-128-cfb1"
+#define NID_aes_128_cfb1 650
+
+#define SN_aes_192_cfb1 "AES-192-CFB1"
+#define LN_aes_192_cfb1 "aes-192-cfb1"
+#define NID_aes_192_cfb1 651
+
+#define SN_aes_256_cfb1 "AES-256-CFB1"
+#define LN_aes_256_cfb1 "aes-256-cfb1"
+#define NID_aes_256_cfb1 652
+
+#define SN_aes_128_cfb8 "AES-128-CFB8"
+#define LN_aes_128_cfb8 "aes-128-cfb8"
+#define NID_aes_128_cfb8 653
+
+#define SN_aes_192_cfb8 "AES-192-CFB8"
+#define LN_aes_192_cfb8 "aes-192-cfb8"
+#define NID_aes_192_cfb8 654
+
+#define SN_aes_256_cfb8 "AES-256-CFB8"
+#define LN_aes_256_cfb8 "aes-256-cfb8"
+#define NID_aes_256_cfb8 655
+
+#define SN_aes_128_ctr "AES-128-CTR"
+#define LN_aes_128_ctr "aes-128-ctr"
+#define NID_aes_128_ctr 904
+
+#define SN_aes_192_ctr "AES-192-CTR"
+#define LN_aes_192_ctr "aes-192-ctr"
+#define NID_aes_192_ctr 905
+
+#define SN_aes_256_ctr "AES-256-CTR"
+#define LN_aes_256_ctr "aes-256-ctr"
+#define NID_aes_256_ctr 906
+
+#define SN_aes_128_ocb "AES-128-OCB"
+#define LN_aes_128_ocb "aes-128-ocb"
+#define NID_aes_128_ocb 958
+
+#define SN_aes_192_ocb "AES-192-OCB"
+#define LN_aes_192_ocb "aes-192-ocb"
+#define NID_aes_192_ocb 959
+
+#define SN_aes_256_ocb "AES-256-OCB"
+#define LN_aes_256_ocb "aes-256-ocb"
+#define NID_aes_256_ocb 960
+
+#define SN_des_cfb1 "DES-CFB1"
+#define LN_des_cfb1 "des-cfb1"
+#define NID_des_cfb1 656
+
+#define SN_des_cfb8 "DES-CFB8"
+#define LN_des_cfb8 "des-cfb8"
+#define NID_des_cfb8 657
+
+#define SN_des_ede3_cfb1 "DES-EDE3-CFB1"
+#define LN_des_ede3_cfb1 "des-ede3-cfb1"
+#define NID_des_ede3_cfb1 658
+
+#define SN_des_ede3_cfb8 "DES-EDE3-CFB8"
+#define LN_des_ede3_cfb8 "des-ede3-cfb8"
+#define NID_des_ede3_cfb8 659
+
+#define OBJ_nist_hashalgs OBJ_nistAlgorithms, 2L
+
+#define SN_sha256 "SHA256"
+#define LN_sha256 "sha256"
+#define NID_sha256 672
+#define OBJ_sha256 OBJ_nist_hashalgs, 1L
+
+#define SN_sha384 "SHA384"
+#define LN_sha384 "sha384"
+#define NID_sha384 673
+#define OBJ_sha384 OBJ_nist_hashalgs, 2L
+
+#define SN_sha512 "SHA512"
+#define LN_sha512 "sha512"
+#define NID_sha512 674
+#define OBJ_sha512 OBJ_nist_hashalgs, 3L
+
+#define SN_sha224 "SHA224"
+#define LN_sha224 "sha224"
+#define NID_sha224 675
+#define OBJ_sha224 OBJ_nist_hashalgs, 4L
+
+#define SN_sha512_224 "SHA512-224"
+#define LN_sha512_224 "sha512-224"
+#define NID_sha512_224 1094
+#define OBJ_sha512_224 OBJ_nist_hashalgs, 5L
+
+#define SN_sha512_256 "SHA512-256"
+#define LN_sha512_256 "sha512-256"
+#define NID_sha512_256 1095
+#define OBJ_sha512_256 OBJ_nist_hashalgs, 6L
+
+#define SN_sha3_224 "SHA3-224"
+#define LN_sha3_224 "sha3-224"
+#define NID_sha3_224 1096
+#define OBJ_sha3_224 OBJ_nist_hashalgs, 7L
+
+#define SN_sha3_256 "SHA3-256"
+#define LN_sha3_256 "sha3-256"
+#define NID_sha3_256 1097
+#define OBJ_sha3_256 OBJ_nist_hashalgs, 8L
+
+#define SN_sha3_384 "SHA3-384"
+#define LN_sha3_384 "sha3-384"
+#define NID_sha3_384 1098
+#define OBJ_sha3_384 OBJ_nist_hashalgs, 9L
+
+#define SN_sha3_512 "SHA3-512"
+#define LN_sha3_512 "sha3-512"
+#define NID_sha3_512 1099
+#define OBJ_sha3_512 OBJ_nist_hashalgs, 10L
+
+#define SN_shake128 "SHAKE128"
+#define LN_shake128 "shake128"
+#define NID_shake128 1100
+#define OBJ_shake128 OBJ_nist_hashalgs, 11L
+
+#define SN_shake256 "SHAKE256"
+#define LN_shake256 "shake256"
+#define NID_shake256 1101
+#define OBJ_shake256 OBJ_nist_hashalgs, 12L
+
+#define SN_hmac_sha3_224 "id-hmacWithSHA3-224"
+#define LN_hmac_sha3_224 "hmac-sha3-224"
+#define NID_hmac_sha3_224 1102
+#define OBJ_hmac_sha3_224 OBJ_nist_hashalgs, 13L
+
+#define SN_hmac_sha3_256 "id-hmacWithSHA3-256"
+#define LN_hmac_sha3_256 "hmac-sha3-256"
+#define NID_hmac_sha3_256 1103
+#define OBJ_hmac_sha3_256 OBJ_nist_hashalgs, 14L
+
+#define SN_hmac_sha3_384 "id-hmacWithSHA3-384"
+#define LN_hmac_sha3_384 "hmac-sha3-384"
+#define NID_hmac_sha3_384 1104
+#define OBJ_hmac_sha3_384 OBJ_nist_hashalgs, 15L
+
+#define SN_hmac_sha3_512 "id-hmacWithSHA3-512"
+#define LN_hmac_sha3_512 "hmac-sha3-512"
+#define NID_hmac_sha3_512 1105
+#define OBJ_hmac_sha3_512 OBJ_nist_hashalgs, 16L
+
+#define SN_kmac128 "KMAC128"
+#define LN_kmac128 "kmac128"
+#define NID_kmac128 1196
+#define OBJ_kmac128 OBJ_nist_hashalgs, 19L
+
+#define SN_kmac256 "KMAC256"
+#define LN_kmac256 "kmac256"
+#define NID_kmac256 1197
+#define OBJ_kmac256 OBJ_nist_hashalgs, 20L
+
+#define OBJ_dsa_with_sha2 OBJ_nistAlgorithms, 3L
+
+#define SN_dsa_with_SHA224 "dsa_with_SHA224"
+#define NID_dsa_with_SHA224 802
+#define OBJ_dsa_with_SHA224 OBJ_dsa_with_sha2, 1L
+
+#define SN_dsa_with_SHA256 "dsa_with_SHA256"
+#define NID_dsa_with_SHA256 803
+#define OBJ_dsa_with_SHA256 OBJ_dsa_with_sha2, 2L
+
+#define OBJ_sigAlgs OBJ_nistAlgorithms, 3L
+
+#define SN_dsa_with_SHA384 "id-dsa-with-sha384"
+#define LN_dsa_with_SHA384 "dsa_with_SHA384"
+#define NID_dsa_with_SHA384 1106
+#define OBJ_dsa_with_SHA384 OBJ_sigAlgs, 3L
+
+#define SN_dsa_with_SHA512 "id-dsa-with-sha512"
+#define LN_dsa_with_SHA512 "dsa_with_SHA512"
+#define NID_dsa_with_SHA512 1107
+#define OBJ_dsa_with_SHA512 OBJ_sigAlgs, 4L
+
+#define SN_dsa_with_SHA3_224 "id-dsa-with-sha3-224"
+#define LN_dsa_with_SHA3_224 "dsa_with_SHA3-224"
+#define NID_dsa_with_SHA3_224 1108
+#define OBJ_dsa_with_SHA3_224 OBJ_sigAlgs, 5L
+
+#define SN_dsa_with_SHA3_256 "id-dsa-with-sha3-256"
+#define LN_dsa_with_SHA3_256 "dsa_with_SHA3-256"
+#define NID_dsa_with_SHA3_256 1109
+#define OBJ_dsa_with_SHA3_256 OBJ_sigAlgs, 6L
+
+#define SN_dsa_with_SHA3_384 "id-dsa-with-sha3-384"
+#define LN_dsa_with_SHA3_384 "dsa_with_SHA3-384"
+#define NID_dsa_with_SHA3_384 1110
+#define OBJ_dsa_with_SHA3_384 OBJ_sigAlgs, 7L
+
+#define SN_dsa_with_SHA3_512 "id-dsa-with-sha3-512"
+#define LN_dsa_with_SHA3_512 "dsa_with_SHA3-512"
+#define NID_dsa_with_SHA3_512 1111
+#define OBJ_dsa_with_SHA3_512 OBJ_sigAlgs, 8L
+
+#define SN_ecdsa_with_SHA3_224 "id-ecdsa-with-sha3-224"
+#define LN_ecdsa_with_SHA3_224 "ecdsa_with_SHA3-224"
+#define NID_ecdsa_with_SHA3_224 1112
+#define OBJ_ecdsa_with_SHA3_224 OBJ_sigAlgs, 9L
+
+#define SN_ecdsa_with_SHA3_256 "id-ecdsa-with-sha3-256"
+#define LN_ecdsa_with_SHA3_256 "ecdsa_with_SHA3-256"
+#define NID_ecdsa_with_SHA3_256 1113
+#define OBJ_ecdsa_with_SHA3_256 OBJ_sigAlgs, 10L
+
+#define SN_ecdsa_with_SHA3_384 "id-ecdsa-with-sha3-384"
+#define LN_ecdsa_with_SHA3_384 "ecdsa_with_SHA3-384"
+#define NID_ecdsa_with_SHA3_384 1114
+#define OBJ_ecdsa_with_SHA3_384 OBJ_sigAlgs, 11L
+
+#define SN_ecdsa_with_SHA3_512 "id-ecdsa-with-sha3-512"
+#define LN_ecdsa_with_SHA3_512 "ecdsa_with_SHA3-512"
+#define NID_ecdsa_with_SHA3_512 1115
+#define OBJ_ecdsa_with_SHA3_512 OBJ_sigAlgs, 12L
+
+#define SN_RSA_SHA3_224 "id-rsassa-pkcs1-v1_5-with-sha3-224"
+#define LN_RSA_SHA3_224 "RSA-SHA3-224"
+#define NID_RSA_SHA3_224 1116
+#define OBJ_RSA_SHA3_224 OBJ_sigAlgs, 13L
+
+#define SN_RSA_SHA3_256 "id-rsassa-pkcs1-v1_5-with-sha3-256"
+#define LN_RSA_SHA3_256 "RSA-SHA3-256"
+#define NID_RSA_SHA3_256 1117
+#define OBJ_RSA_SHA3_256 OBJ_sigAlgs, 14L
+
+#define SN_RSA_SHA3_384 "id-rsassa-pkcs1-v1_5-with-sha3-384"
+#define LN_RSA_SHA3_384 "RSA-SHA3-384"
+#define NID_RSA_SHA3_384 1118
+#define OBJ_RSA_SHA3_384 OBJ_sigAlgs, 15L
+
+#define SN_RSA_SHA3_512 "id-rsassa-pkcs1-v1_5-with-sha3-512"
+#define LN_RSA_SHA3_512 "RSA-SHA3-512"
+#define NID_RSA_SHA3_512 1119
+#define OBJ_RSA_SHA3_512 OBJ_sigAlgs, 16L
+
+#define SN_hold_instruction_code "holdInstructionCode"
+#define LN_hold_instruction_code "Hold Instruction Code"
+#define NID_hold_instruction_code 430
+#define OBJ_hold_instruction_code OBJ_id_ce, 23L
+
+#define OBJ_holdInstruction OBJ_X9_57, 2L
+
+#define SN_hold_instruction_none "holdInstructionNone"
+#define LN_hold_instruction_none "Hold Instruction None"
+#define NID_hold_instruction_none 431
+#define OBJ_hold_instruction_none OBJ_holdInstruction, 1L
+
+#define SN_hold_instruction_call_issuer "holdInstructionCallIssuer"
+#define LN_hold_instruction_call_issuer "Hold Instruction Call Issuer"
+#define NID_hold_instruction_call_issuer 432
+#define OBJ_hold_instruction_call_issuer OBJ_holdInstruction, 2L
+
+#define SN_hold_instruction_reject "holdInstructionReject"
+#define LN_hold_instruction_reject "Hold Instruction Reject"
+#define NID_hold_instruction_reject 433
+#define OBJ_hold_instruction_reject OBJ_holdInstruction, 3L
+
+#define SN_data "data"
+#define NID_data 434
+#define OBJ_data OBJ_itu_t, 9L
+
+#define SN_pss "pss"
+#define NID_pss 435
+#define OBJ_pss OBJ_data, 2342L
+
+#define SN_ucl "ucl"
+#define NID_ucl 436
+#define OBJ_ucl OBJ_pss, 19200300L
+
+#define SN_pilot "pilot"
+#define NID_pilot 437
+#define OBJ_pilot OBJ_ucl, 100L
+
+#define LN_pilotAttributeType "pilotAttributeType"
+#define NID_pilotAttributeType 438
+#define OBJ_pilotAttributeType OBJ_pilot, 1L
+
+#define LN_pilotAttributeSyntax "pilotAttributeSyntax"
+#define NID_pilotAttributeSyntax 439
+#define OBJ_pilotAttributeSyntax OBJ_pilot, 3L
+
+#define LN_pilotObjectClass "pilotObjectClass"
+#define NID_pilotObjectClass 440
+#define OBJ_pilotObjectClass OBJ_pilot, 4L
+
+#define LN_pilotGroups "pilotGroups"
+#define NID_pilotGroups 441
+#define OBJ_pilotGroups OBJ_pilot, 10L
+
+#define LN_iA5StringSyntax "iA5StringSyntax"
+#define NID_iA5StringSyntax 442
+#define OBJ_iA5StringSyntax OBJ_pilotAttributeSyntax, 4L
+
+#define LN_caseIgnoreIA5StringSyntax "caseIgnoreIA5StringSyntax"
+#define NID_caseIgnoreIA5StringSyntax 443
+#define OBJ_caseIgnoreIA5StringSyntax OBJ_pilotAttributeSyntax, 5L
+
+#define LN_pilotObject "pilotObject"
+#define NID_pilotObject 444
+#define OBJ_pilotObject OBJ_pilotObjectClass, 3L
+
+#define LN_pilotPerson "pilotPerson"
+#define NID_pilotPerson 445
+#define OBJ_pilotPerson OBJ_pilotObjectClass, 4L
+
+#define SN_account "account"
+#define NID_account 446
+#define OBJ_account OBJ_pilotObjectClass, 5L
+
+#define SN_document "document"
+#define NID_document 447
+#define OBJ_document OBJ_pilotObjectClass, 6L
+
+#define SN_room "room"
+#define NID_room 448
+#define OBJ_room OBJ_pilotObjectClass, 7L
+
+#define LN_documentSeries "documentSeries"
+#define NID_documentSeries 449
+#define OBJ_documentSeries OBJ_pilotObjectClass, 9L
+
+#define SN_Domain "domain"
+#define LN_Domain "Domain"
+#define NID_Domain 392
+#define OBJ_Domain OBJ_pilotObjectClass, 13L
+
+#define LN_rFC822localPart "rFC822localPart"
+#define NID_rFC822localPart 450
+#define OBJ_rFC822localPart OBJ_pilotObjectClass, 14L
+
+#define LN_dNSDomain "dNSDomain"
+#define NID_dNSDomain 451
+#define OBJ_dNSDomain OBJ_pilotObjectClass, 15L
+
+#define LN_domainRelatedObject "domainRelatedObject"
+#define NID_domainRelatedObject 452
+#define OBJ_domainRelatedObject OBJ_pilotObjectClass, 17L
+
+#define LN_friendlyCountry "friendlyCountry"
+#define NID_friendlyCountry 453
+#define OBJ_friendlyCountry OBJ_pilotObjectClass, 18L
+
+#define LN_simpleSecurityObject "simpleSecurityObject"
+#define NID_simpleSecurityObject 454
+#define OBJ_simpleSecurityObject OBJ_pilotObjectClass, 19L
+
+#define LN_pilotOrganization "pilotOrganization"
+#define NID_pilotOrganization 455
+#define OBJ_pilotOrganization OBJ_pilotObjectClass, 20L
+
+#define LN_pilotDSA "pilotDSA"
+#define NID_pilotDSA 456
+#define OBJ_pilotDSA OBJ_pilotObjectClass, 21L
+
+#define LN_qualityLabelledData "qualityLabelledData"
+#define NID_qualityLabelledData 457
+#define OBJ_qualityLabelledData OBJ_pilotObjectClass, 22L
+
+#define SN_userId "UID"
+#define LN_userId "userId"
+#define NID_userId 458
+#define OBJ_userId OBJ_pilotAttributeType, 1L
+
+#define LN_textEncodedORAddress "textEncodedORAddress"
+#define NID_textEncodedORAddress 459
+#define OBJ_textEncodedORAddress OBJ_pilotAttributeType, 2L
+
+#define SN_rfc822Mailbox "mail"
+#define LN_rfc822Mailbox "rfc822Mailbox"
+#define NID_rfc822Mailbox 460
+#define OBJ_rfc822Mailbox OBJ_pilotAttributeType, 3L
+
+#define SN_info "info"
+#define NID_info 461
+#define OBJ_info OBJ_pilotAttributeType, 4L
+
+#define LN_favouriteDrink "favouriteDrink"
+#define NID_favouriteDrink 462
+#define OBJ_favouriteDrink OBJ_pilotAttributeType, 5L
+
+#define LN_roomNumber "roomNumber"
+#define NID_roomNumber 463
+#define OBJ_roomNumber OBJ_pilotAttributeType, 6L
+
+#define SN_photo "photo"
+#define NID_photo 464
+#define OBJ_photo OBJ_pilotAttributeType, 7L
+
+#define LN_userClass "userClass"
+#define NID_userClass 465
+#define OBJ_userClass OBJ_pilotAttributeType, 8L
+
+#define SN_host "host"
+#define NID_host 466
+#define OBJ_host OBJ_pilotAttributeType, 9L
+
+#define SN_manager "manager"
+#define NID_manager 467
+#define OBJ_manager OBJ_pilotAttributeType, 10L
+
+#define LN_documentIdentifier "documentIdentifier"
+#define NID_documentIdentifier 468
+#define OBJ_documentIdentifier OBJ_pilotAttributeType, 11L
+
+#define LN_documentTitle "documentTitle"
+#define NID_documentTitle 469
+#define OBJ_documentTitle OBJ_pilotAttributeType, 12L
+
+#define LN_documentVersion "documentVersion"
+#define NID_documentVersion 470
+#define OBJ_documentVersion OBJ_pilotAttributeType, 13L
+
+#define LN_documentAuthor "documentAuthor"
+#define NID_documentAuthor 471
+#define OBJ_documentAuthor OBJ_pilotAttributeType, 14L
+
+#define LN_documentLocation "documentLocation"
+#define NID_documentLocation 472
+#define OBJ_documentLocation OBJ_pilotAttributeType, 15L
+
+#define LN_homeTelephoneNumber "homeTelephoneNumber"
+#define NID_homeTelephoneNumber 473
+#define OBJ_homeTelephoneNumber OBJ_pilotAttributeType, 20L
+
+#define SN_secretary "secretary"
+#define NID_secretary 474
+#define OBJ_secretary OBJ_pilotAttributeType, 21L
+
+#define LN_otherMailbox "otherMailbox"
+#define NID_otherMailbox 475
+#define OBJ_otherMailbox OBJ_pilotAttributeType, 22L
+
+#define LN_lastModifiedTime "lastModifiedTime"
+#define NID_lastModifiedTime 476
+#define OBJ_lastModifiedTime OBJ_pilotAttributeType, 23L
+
+#define LN_lastModifiedBy "lastModifiedBy"
+#define NID_lastModifiedBy 477
+#define OBJ_lastModifiedBy OBJ_pilotAttributeType, 24L
+
+#define SN_domainComponent "DC"
+#define LN_domainComponent "domainComponent"
+#define NID_domainComponent 391
+#define OBJ_domainComponent OBJ_pilotAttributeType, 25L
+
+#define LN_aRecord "aRecord"
+#define NID_aRecord 478
+#define OBJ_aRecord OBJ_pilotAttributeType, 26L
+
+#define LN_pilotAttributeType27 "pilotAttributeType27"
+#define NID_pilotAttributeType27 479
+#define OBJ_pilotAttributeType27 OBJ_pilotAttributeType, 27L
+
+#define LN_mXRecord "mXRecord"
+#define NID_mXRecord 480
+#define OBJ_mXRecord OBJ_pilotAttributeType, 28L
+
+#define LN_nSRecord "nSRecord"
+#define NID_nSRecord 481
+#define OBJ_nSRecord OBJ_pilotAttributeType, 29L
+
+#define LN_sOARecord "sOARecord"
+#define NID_sOARecord 482
+#define OBJ_sOARecord OBJ_pilotAttributeType, 30L
+
+#define LN_cNAMERecord "cNAMERecord"
+#define NID_cNAMERecord 483
+#define OBJ_cNAMERecord OBJ_pilotAttributeType, 31L
+
+#define LN_associatedDomain "associatedDomain"
+#define NID_associatedDomain 484
+#define OBJ_associatedDomain OBJ_pilotAttributeType, 37L
+
+#define LN_associatedName "associatedName"
+#define NID_associatedName 485
+#define OBJ_associatedName OBJ_pilotAttributeType, 38L
+
+#define LN_homePostalAddress "homePostalAddress"
+#define NID_homePostalAddress 486
+#define OBJ_homePostalAddress OBJ_pilotAttributeType, 39L
+
+#define LN_personalTitle "personalTitle"
+#define NID_personalTitle 487
+#define OBJ_personalTitle OBJ_pilotAttributeType, 40L
+
+#define LN_mobileTelephoneNumber "mobileTelephoneNumber"
+#define NID_mobileTelephoneNumber 488
+#define OBJ_mobileTelephoneNumber OBJ_pilotAttributeType, 41L
+
+#define LN_pagerTelephoneNumber "pagerTelephoneNumber"
+#define NID_pagerTelephoneNumber 489
+#define OBJ_pagerTelephoneNumber OBJ_pilotAttributeType, 42L
+
+#define LN_friendlyCountryName "friendlyCountryName"
+#define NID_friendlyCountryName 490
+#define OBJ_friendlyCountryName OBJ_pilotAttributeType, 43L
+
+#define SN_uniqueIdentifier "uid"
+#define LN_uniqueIdentifier "uniqueIdentifier"
+#define NID_uniqueIdentifier 102
+#define OBJ_uniqueIdentifier OBJ_pilotAttributeType, 44L
+
+#define LN_organizationalStatus "organizationalStatus"
+#define NID_organizationalStatus 491
+#define OBJ_organizationalStatus OBJ_pilotAttributeType, 45L
+
+#define LN_janetMailbox "janetMailbox"
+#define NID_janetMailbox 492
+#define OBJ_janetMailbox OBJ_pilotAttributeType, 46L
+
+#define LN_mailPreferenceOption "mailPreferenceOption"
+#define NID_mailPreferenceOption 493
+#define OBJ_mailPreferenceOption OBJ_pilotAttributeType, 47L
+
+#define LN_buildingName "buildingName"
+#define NID_buildingName 494
+#define OBJ_buildingName OBJ_pilotAttributeType, 48L
+
+#define LN_dSAQuality "dSAQuality"
+#define NID_dSAQuality 495
+#define OBJ_dSAQuality OBJ_pilotAttributeType, 49L
+
+#define LN_singleLevelQuality "singleLevelQuality"
+#define NID_singleLevelQuality 496
+#define OBJ_singleLevelQuality OBJ_pilotAttributeType, 50L
+
+#define LN_subtreeMinimumQuality "subtreeMinimumQuality"
+#define NID_subtreeMinimumQuality 497
+#define OBJ_subtreeMinimumQuality OBJ_pilotAttributeType, 51L
+
+#define LN_subtreeMaximumQuality "subtreeMaximumQuality"
+#define NID_subtreeMaximumQuality 498
+#define OBJ_subtreeMaximumQuality OBJ_pilotAttributeType, 52L
+
+#define LN_personalSignature "personalSignature"
+#define NID_personalSignature 499
+#define OBJ_personalSignature OBJ_pilotAttributeType, 53L
+
+#define LN_dITRedirect "dITRedirect"
+#define NID_dITRedirect 500
+#define OBJ_dITRedirect OBJ_pilotAttributeType, 54L
+
+#define SN_audio "audio"
+#define NID_audio 501
+#define OBJ_audio OBJ_pilotAttributeType, 55L
+
+#define LN_documentPublisher "documentPublisher"
+#define NID_documentPublisher 502
+#define OBJ_documentPublisher OBJ_pilotAttributeType, 56L
+
+#define SN_id_set "id-set"
+#define LN_id_set "Secure Electronic Transactions"
+#define NID_id_set 512
+#define OBJ_id_set OBJ_international_organizations, 42L
+
+#define SN_set_ctype "set-ctype"
+#define LN_set_ctype "content types"
+#define NID_set_ctype 513
+#define OBJ_set_ctype OBJ_id_set, 0L
+
+#define SN_set_msgExt "set-msgExt"
+#define LN_set_msgExt "message extensions"
+#define NID_set_msgExt 514
+#define OBJ_set_msgExt OBJ_id_set, 1L
+
+#define SN_set_attr "set-attr"
+#define NID_set_attr 515
+#define OBJ_set_attr OBJ_id_set, 3L
+
+#define SN_set_policy "set-policy"
+#define NID_set_policy 516
+#define OBJ_set_policy OBJ_id_set, 5L
+
+#define SN_set_certExt "set-certExt"
+#define LN_set_certExt "certificate extensions"
+#define NID_set_certExt 517
+#define OBJ_set_certExt OBJ_id_set, 7L
+
+#define SN_set_brand "set-brand"
+#define NID_set_brand 518
+#define OBJ_set_brand OBJ_id_set, 8L
+
+#define SN_setct_PANData "setct-PANData"
+#define NID_setct_PANData 519
+#define OBJ_setct_PANData OBJ_set_ctype, 0L
+
+#define SN_setct_PANToken "setct-PANToken"
+#define NID_setct_PANToken 520
+#define OBJ_setct_PANToken OBJ_set_ctype, 1L
+
+#define SN_setct_PANOnly "setct-PANOnly"
+#define NID_setct_PANOnly 521
+#define OBJ_setct_PANOnly OBJ_set_ctype, 2L
+
+#define SN_setct_OIData "setct-OIData"
+#define NID_setct_OIData 522
+#define OBJ_setct_OIData OBJ_set_ctype, 3L
+
+#define SN_setct_PI "setct-PI"
+#define NID_setct_PI 523
+#define OBJ_setct_PI OBJ_set_ctype, 4L
 
-#define SN_setct_PIData         "setct-PIData"
-#define NID_setct_PIData                524
-#define OBJ_setct_PIData                OBJ_set_ctype,5L
+#define SN_setct_PIData "setct-PIData"
+#define NID_setct_PIData 524
+#define OBJ_setct_PIData OBJ_set_ctype, 5L
 
-#define SN_setct_PIDataUnsigned         "setct-PIDataUnsigned"
-#define NID_setct_PIDataUnsigned                525
-#define OBJ_setct_PIDataUnsigned                OBJ_set_ctype,6L
+#define SN_setct_PIDataUnsigned "setct-PIDataUnsigned"
+#define NID_setct_PIDataUnsigned 525
+#define OBJ_setct_PIDataUnsigned OBJ_set_ctype, 6L
 
-#define SN_setct_HODInput               "setct-HODInput"
-#define NID_setct_HODInput              526
-#define OBJ_setct_HODInput              OBJ_set_ctype,7L
+#define SN_setct_HODInput "setct-HODInput"
+#define NID_setct_HODInput 526
+#define OBJ_setct_HODInput OBJ_set_ctype, 7L
 
-#define SN_setct_AuthResBaggage         "setct-AuthResBaggage"
-#define NID_setct_AuthResBaggage                527
-#define OBJ_setct_AuthResBaggage                OBJ_set_ctype,8L
+#define SN_setct_AuthResBaggage "setct-AuthResBaggage"
+#define NID_setct_AuthResBaggage 527
+#define OBJ_setct_AuthResBaggage OBJ_set_ctype, 8L
 
-#define SN_setct_AuthRevReqBaggage              "setct-AuthRevReqBaggage"
-#define NID_setct_AuthRevReqBaggage             528
-#define OBJ_setct_AuthRevReqBaggage             OBJ_set_ctype,9L
+#define SN_setct_AuthRevReqBaggage "setct-AuthRevReqBaggage"
+#define NID_setct_AuthRevReqBaggage 528
+#define OBJ_setct_AuthRevReqBaggage OBJ_set_ctype, 9L
 
-#define SN_setct_AuthRevResBaggage              "setct-AuthRevResBaggage"
-#define NID_setct_AuthRevResBaggage             529
-#define OBJ_setct_AuthRevResBaggage             OBJ_set_ctype,10L
+#define SN_setct_AuthRevResBaggage "setct-AuthRevResBaggage"
+#define NID_setct_AuthRevResBaggage 529
+#define OBJ_setct_AuthRevResBaggage OBJ_set_ctype, 10L
 
-#define SN_setct_CapTokenSeq            "setct-CapTokenSeq"
-#define NID_setct_CapTokenSeq           530
-#define OBJ_setct_CapTokenSeq           OBJ_set_ctype,11L
+#define SN_setct_CapTokenSeq "setct-CapTokenSeq"
+#define NID_setct_CapTokenSeq 530
+#define OBJ_setct_CapTokenSeq OBJ_set_ctype, 11L
 
-#define SN_setct_PInitResData           "setct-PInitResData"
-#define NID_setct_PInitResData          531
-#define OBJ_setct_PInitResData          OBJ_set_ctype,12L
+#define SN_setct_PInitResData "setct-PInitResData"
+#define NID_setct_PInitResData 531
+#define OBJ_setct_PInitResData OBJ_set_ctype, 12L
 
-#define SN_setct_PI_TBS         "setct-PI-TBS"
-#define NID_setct_PI_TBS                532
-#define OBJ_setct_PI_TBS                OBJ_set_ctype,13L
+#define SN_setct_PI_TBS "setct-PI-TBS"
+#define NID_setct_PI_TBS 532
+#define OBJ_setct_PI_TBS OBJ_set_ctype, 13L
 
-#define SN_setct_PResData               "setct-PResData"
-#define NID_setct_PResData              533
-#define OBJ_setct_PResData              OBJ_set_ctype,14L
+#define SN_setct_PResData "setct-PResData"
+#define NID_setct_PResData 533
+#define OBJ_setct_PResData OBJ_set_ctype, 14L
 
-#define SN_setct_AuthReqTBS             "setct-AuthReqTBS"
-#define NID_setct_AuthReqTBS            534
-#define OBJ_setct_AuthReqTBS            OBJ_set_ctype,16L
+#define SN_setct_AuthReqTBS "setct-AuthReqTBS"
+#define NID_setct_AuthReqTBS 534
+#define OBJ_setct_AuthReqTBS OBJ_set_ctype, 16L
 
-#define SN_setct_AuthResTBS             "setct-AuthResTBS"
-#define NID_setct_AuthResTBS            535
-#define OBJ_setct_AuthResTBS            OBJ_set_ctype,17L
+#define SN_setct_AuthResTBS "setct-AuthResTBS"
+#define NID_setct_AuthResTBS 535
+#define OBJ_setct_AuthResTBS OBJ_set_ctype, 17L
 
-#define SN_setct_AuthResTBSX            "setct-AuthResTBSX"
-#define NID_setct_AuthResTBSX           536
-#define OBJ_setct_AuthResTBSX           OBJ_set_ctype,18L
+#define SN_setct_AuthResTBSX "setct-AuthResTBSX"
+#define NID_setct_AuthResTBSX 536
+#define OBJ_setct_AuthResTBSX OBJ_set_ctype, 18L
 
-#define SN_setct_AuthTokenTBS           "setct-AuthTokenTBS"
-#define NID_setct_AuthTokenTBS          537
-#define OBJ_setct_AuthTokenTBS          OBJ_set_ctype,19L
+#define SN_setct_AuthTokenTBS "setct-AuthTokenTBS"
+#define NID_setct_AuthTokenTBS 537
+#define OBJ_setct_AuthTokenTBS OBJ_set_ctype, 19L
 
-#define SN_setct_CapTokenData           "setct-CapTokenData"
-#define NID_setct_CapTokenData          538
-#define OBJ_setct_CapTokenData          OBJ_set_ctype,20L
+#define SN_setct_CapTokenData "setct-CapTokenData"
+#define NID_setct_CapTokenData 538
+#define OBJ_setct_CapTokenData OBJ_set_ctype, 20L
 
-#define SN_setct_CapTokenTBS            "setct-CapTokenTBS"
-#define NID_setct_CapTokenTBS           539
-#define OBJ_setct_CapTokenTBS           OBJ_set_ctype,21L
+#define SN_setct_CapTokenTBS "setct-CapTokenTBS"
+#define NID_setct_CapTokenTBS 539
+#define OBJ_setct_CapTokenTBS OBJ_set_ctype, 21L
 
-#define SN_setct_AcqCardCodeMsg         "setct-AcqCardCodeMsg"
-#define NID_setct_AcqCardCodeMsg                540
-#define OBJ_setct_AcqCardCodeMsg                OBJ_set_ctype,22L
+#define SN_setct_AcqCardCodeMsg "setct-AcqCardCodeMsg"
+#define NID_setct_AcqCardCodeMsg 540
+#define OBJ_setct_AcqCardCodeMsg OBJ_set_ctype, 22L
 
-#define SN_setct_AuthRevReqTBS          "setct-AuthRevReqTBS"
-#define NID_setct_AuthRevReqTBS         541
-#define OBJ_setct_AuthRevReqTBS         OBJ_set_ctype,23L
+#define SN_setct_AuthRevReqTBS "setct-AuthRevReqTBS"
+#define NID_setct_AuthRevReqTBS 541
+#define OBJ_setct_AuthRevReqTBS OBJ_set_ctype, 23L
 
-#define SN_setct_AuthRevResData         "setct-AuthRevResData"
-#define NID_setct_AuthRevResData                542
-#define OBJ_setct_AuthRevResData                OBJ_set_ctype,24L
+#define SN_setct_AuthRevResData "setct-AuthRevResData"
+#define NID_setct_AuthRevResData 542
+#define OBJ_setct_AuthRevResData OBJ_set_ctype, 24L
 
-#define SN_setct_AuthRevResTBS          "setct-AuthRevResTBS"
-#define NID_setct_AuthRevResTBS         543
-#define OBJ_setct_AuthRevResTBS         OBJ_set_ctype,25L
+#define SN_setct_AuthRevResTBS "setct-AuthRevResTBS"
+#define NID_setct_AuthRevResTBS 543
+#define OBJ_setct_AuthRevResTBS OBJ_set_ctype, 25L
 
-#define SN_setct_CapReqTBS              "setct-CapReqTBS"
-#define NID_setct_CapReqTBS             544
-#define OBJ_setct_CapReqTBS             OBJ_set_ctype,26L
+#define SN_setct_CapReqTBS "setct-CapReqTBS"
+#define NID_setct_CapReqTBS 544
+#define OBJ_setct_CapReqTBS OBJ_set_ctype, 26L
 
-#define SN_setct_CapReqTBSX             "setct-CapReqTBSX"
-#define NID_setct_CapReqTBSX            545
-#define OBJ_setct_CapReqTBSX            OBJ_set_ctype,27L
+#define SN_setct_CapReqTBSX "setct-CapReqTBSX"
+#define NID_setct_CapReqTBSX 545
+#define OBJ_setct_CapReqTBSX OBJ_set_ctype, 27L
 
-#define SN_setct_CapResData             "setct-CapResData"
-#define NID_setct_CapResData            546
-#define OBJ_setct_CapResData            OBJ_set_ctype,28L
+#define SN_setct_CapResData "setct-CapResData"
+#define NID_setct_CapResData 546
+#define OBJ_setct_CapResData OBJ_set_ctype, 28L
 
-#define SN_setct_CapRevReqTBS           "setct-CapRevReqTBS"
-#define NID_setct_CapRevReqTBS          547
-#define OBJ_setct_CapRevReqTBS          OBJ_set_ctype,29L
+#define SN_setct_CapRevReqTBS "setct-CapRevReqTBS"
+#define NID_setct_CapRevReqTBS 547
+#define OBJ_setct_CapRevReqTBS OBJ_set_ctype, 29L
 
-#define SN_setct_CapRevReqTBSX          "setct-CapRevReqTBSX"
-#define NID_setct_CapRevReqTBSX         548
-#define OBJ_setct_CapRevReqTBSX         OBJ_set_ctype,30L
+#define SN_setct_CapRevReqTBSX "setct-CapRevReqTBSX"
+#define NID_setct_CapRevReqTBSX 548
+#define OBJ_setct_CapRevReqTBSX OBJ_set_ctype, 30L
 
-#define SN_setct_CapRevResData          "setct-CapRevResData"
-#define NID_setct_CapRevResData         549
-#define OBJ_setct_CapRevResData         OBJ_set_ctype,31L
+#define SN_setct_CapRevResData "setct-CapRevResData"
+#define NID_setct_CapRevResData 549
+#define OBJ_setct_CapRevResData OBJ_set_ctype, 31L
 
-#define SN_setct_CredReqTBS             "setct-CredReqTBS"
-#define NID_setct_CredReqTBS            550
-#define OBJ_setct_CredReqTBS            OBJ_set_ctype,32L
+#define SN_setct_CredReqTBS "setct-CredReqTBS"
+#define NID_setct_CredReqTBS 550
+#define OBJ_setct_CredReqTBS OBJ_set_ctype, 32L
 
-#define SN_setct_CredReqTBSX            "setct-CredReqTBSX"
-#define NID_setct_CredReqTBSX           551
-#define OBJ_setct_CredReqTBSX           OBJ_set_ctype,33L
+#define SN_setct_CredReqTBSX "setct-CredReqTBSX"
+#define NID_setct_CredReqTBSX 551
+#define OBJ_setct_CredReqTBSX OBJ_set_ctype, 33L
 
-#define SN_setct_CredResData            "setct-CredResData"
-#define NID_setct_CredResData           552
-#define OBJ_setct_CredResData           OBJ_set_ctype,34L
+#define SN_setct_CredResData "setct-CredResData"
+#define NID_setct_CredResData 552
+#define OBJ_setct_CredResData OBJ_set_ctype, 34L
 
-#define SN_setct_CredRevReqTBS          "setct-CredRevReqTBS"
-#define NID_setct_CredRevReqTBS         553
-#define OBJ_setct_CredRevReqTBS         OBJ_set_ctype,35L
+#define SN_setct_CredRevReqTBS "setct-CredRevReqTBS"
+#define NID_setct_CredRevReqTBS 553
+#define OBJ_setct_CredRevReqTBS OBJ_set_ctype, 35L
 
-#define SN_setct_CredRevReqTBSX         "setct-CredRevReqTBSX"
-#define NID_setct_CredRevReqTBSX                554
-#define OBJ_setct_CredRevReqTBSX                OBJ_set_ctype,36L
+#define SN_setct_CredRevReqTBSX "setct-CredRevReqTBSX"
+#define NID_setct_CredRevReqTBSX 554
+#define OBJ_setct_CredRevReqTBSX OBJ_set_ctype, 36L
 
-#define SN_setct_CredRevResData         "setct-CredRevResData"
-#define NID_setct_CredRevResData                555
-#define OBJ_setct_CredRevResData                OBJ_set_ctype,37L
+#define SN_setct_CredRevResData "setct-CredRevResData"
+#define NID_setct_CredRevResData 555
+#define OBJ_setct_CredRevResData OBJ_set_ctype, 37L
 
-#define SN_setct_PCertReqData           "setct-PCertReqData"
-#define NID_setct_PCertReqData          556
-#define OBJ_setct_PCertReqData          OBJ_set_ctype,38L
+#define SN_setct_PCertReqData "setct-PCertReqData"
+#define NID_setct_PCertReqData 556
+#define OBJ_setct_PCertReqData OBJ_set_ctype, 38L
 
-#define SN_setct_PCertResTBS            "setct-PCertResTBS"
-#define NID_setct_PCertResTBS           557
-#define OBJ_setct_PCertResTBS           OBJ_set_ctype,39L
+#define SN_setct_PCertResTBS "setct-PCertResTBS"
+#define NID_setct_PCertResTBS 557
+#define OBJ_setct_PCertResTBS OBJ_set_ctype, 39L
 
-#define SN_setct_BatchAdminReqData              "setct-BatchAdminReqData"
-#define NID_setct_BatchAdminReqData             558
-#define OBJ_setct_BatchAdminReqData             OBJ_set_ctype,40L
+#define SN_setct_BatchAdminReqData "setct-BatchAdminReqData"
+#define NID_setct_BatchAdminReqData 558
+#define OBJ_setct_BatchAdminReqData OBJ_set_ctype, 40L
 
-#define SN_setct_BatchAdminResData              "setct-BatchAdminResData"
-#define NID_setct_BatchAdminResData             559
-#define OBJ_setct_BatchAdminResData             OBJ_set_ctype,41L
+#define SN_setct_BatchAdminResData "setct-BatchAdminResData"
+#define NID_setct_BatchAdminResData 559
+#define OBJ_setct_BatchAdminResData OBJ_set_ctype, 41L
 
-#define SN_setct_CardCInitResTBS                "setct-CardCInitResTBS"
-#define NID_setct_CardCInitResTBS               560
-#define OBJ_setct_CardCInitResTBS               OBJ_set_ctype,42L
+#define SN_setct_CardCInitResTBS "setct-CardCInitResTBS"
+#define NID_setct_CardCInitResTBS 560
+#define OBJ_setct_CardCInitResTBS OBJ_set_ctype, 42L
 
-#define SN_setct_MeAqCInitResTBS                "setct-MeAqCInitResTBS"
-#define NID_setct_MeAqCInitResTBS               561
-#define OBJ_setct_MeAqCInitResTBS               OBJ_set_ctype,43L
+#define SN_setct_MeAqCInitResTBS "setct-MeAqCInitResTBS"
+#define NID_setct_MeAqCInitResTBS 561
+#define OBJ_setct_MeAqCInitResTBS OBJ_set_ctype, 43L
 
-#define SN_setct_RegFormResTBS          "setct-RegFormResTBS"
-#define NID_setct_RegFormResTBS         562
-#define OBJ_setct_RegFormResTBS         OBJ_set_ctype,44L
+#define SN_setct_RegFormResTBS "setct-RegFormResTBS"
+#define NID_setct_RegFormResTBS 562
+#define OBJ_setct_RegFormResTBS OBJ_set_ctype, 44L
 
-#define SN_setct_CertReqData            "setct-CertReqData"
-#define NID_setct_CertReqData           563
-#define OBJ_setct_CertReqData           OBJ_set_ctype,45L
+#define SN_setct_CertReqData "setct-CertReqData"
+#define NID_setct_CertReqData 563
+#define OBJ_setct_CertReqData OBJ_set_ctype, 45L
 
-#define SN_setct_CertReqTBS             "setct-CertReqTBS"
-#define NID_setct_CertReqTBS            564
-#define OBJ_setct_CertReqTBS            OBJ_set_ctype,46L
+#define SN_setct_CertReqTBS "setct-CertReqTBS"
+#define NID_setct_CertReqTBS 564
+#define OBJ_setct_CertReqTBS OBJ_set_ctype, 46L
 
-#define SN_setct_CertResData            "setct-CertResData"
-#define NID_setct_CertResData           565
-#define OBJ_setct_CertResData           OBJ_set_ctype,47L
+#define SN_setct_CertResData "setct-CertResData"
+#define NID_setct_CertResData 565
+#define OBJ_setct_CertResData OBJ_set_ctype, 47L
 
-#define SN_setct_CertInqReqTBS          "setct-CertInqReqTBS"
-#define NID_setct_CertInqReqTBS         566
-#define OBJ_setct_CertInqReqTBS         OBJ_set_ctype,48L
+#define SN_setct_CertInqReqTBS "setct-CertInqReqTBS"
+#define NID_setct_CertInqReqTBS 566
+#define OBJ_setct_CertInqReqTBS OBJ_set_ctype, 48L
 
-#define SN_setct_ErrorTBS               "setct-ErrorTBS"
-#define NID_setct_ErrorTBS              567
-#define OBJ_setct_ErrorTBS              OBJ_set_ctype,49L
+#define SN_setct_ErrorTBS "setct-ErrorTBS"
+#define NID_setct_ErrorTBS 567
+#define OBJ_setct_ErrorTBS OBJ_set_ctype, 49L
 
-#define SN_setct_PIDualSignedTBE                "setct-PIDualSignedTBE"
-#define NID_setct_PIDualSignedTBE               568
-#define OBJ_setct_PIDualSignedTBE               OBJ_set_ctype,50L
+#define SN_setct_PIDualSignedTBE "setct-PIDualSignedTBE"
+#define NID_setct_PIDualSignedTBE 568
+#define OBJ_setct_PIDualSignedTBE OBJ_set_ctype, 50L
 
-#define SN_setct_PIUnsignedTBE          "setct-PIUnsignedTBE"
-#define NID_setct_PIUnsignedTBE         569
-#define OBJ_setct_PIUnsignedTBE         OBJ_set_ctype,51L
+#define SN_setct_PIUnsignedTBE "setct-PIUnsignedTBE"
+#define NID_setct_PIUnsignedTBE 569
+#define OBJ_setct_PIUnsignedTBE OBJ_set_ctype, 51L
 
-#define SN_setct_AuthReqTBE             "setct-AuthReqTBE"
-#define NID_setct_AuthReqTBE            570
-#define OBJ_setct_AuthReqTBE            OBJ_set_ctype,52L
+#define SN_setct_AuthReqTBE "setct-AuthReqTBE"
+#define NID_setct_AuthReqTBE 570
+#define OBJ_setct_AuthReqTBE OBJ_set_ctype, 52L
 
-#define SN_setct_AuthResTBE             "setct-AuthResTBE"
-#define NID_setct_AuthResTBE            571
-#define OBJ_setct_AuthResTBE            OBJ_set_ctype,53L
+#define SN_setct_AuthResTBE "setct-AuthResTBE"
+#define NID_setct_AuthResTBE 571
+#define OBJ_setct_AuthResTBE OBJ_set_ctype, 53L
 
-#define SN_setct_AuthResTBEX            "setct-AuthResTBEX"
-#define NID_setct_AuthResTBEX           572
-#define OBJ_setct_AuthResTBEX           OBJ_set_ctype,54L
+#define SN_setct_AuthResTBEX "setct-AuthResTBEX"
+#define NID_setct_AuthResTBEX 572
+#define OBJ_setct_AuthResTBEX OBJ_set_ctype, 54L
 
-#define SN_setct_AuthTokenTBE           "setct-AuthTokenTBE"
-#define NID_setct_AuthTokenTBE          573
-#define OBJ_setct_AuthTokenTBE          OBJ_set_ctype,55L
+#define SN_setct_AuthTokenTBE "setct-AuthTokenTBE"
+#define NID_setct_AuthTokenTBE 573
+#define OBJ_setct_AuthTokenTBE OBJ_set_ctype, 55L
 
-#define SN_setct_CapTokenTBE            "setct-CapTokenTBE"
-#define NID_setct_CapTokenTBE           574
-#define OBJ_setct_CapTokenTBE           OBJ_set_ctype,56L
+#define SN_setct_CapTokenTBE "setct-CapTokenTBE"
+#define NID_setct_CapTokenTBE 574
+#define OBJ_setct_CapTokenTBE OBJ_set_ctype, 56L
 
-#define SN_setct_CapTokenTBEX           "setct-CapTokenTBEX"
-#define NID_setct_CapTokenTBEX          575
-#define OBJ_setct_CapTokenTBEX          OBJ_set_ctype,57L
+#define SN_setct_CapTokenTBEX "setct-CapTokenTBEX"
+#define NID_setct_CapTokenTBEX 575
+#define OBJ_setct_CapTokenTBEX OBJ_set_ctype, 57L
 
-#define SN_setct_AcqCardCodeMsgTBE              "setct-AcqCardCodeMsgTBE"
-#define NID_setct_AcqCardCodeMsgTBE             576
-#define OBJ_setct_AcqCardCodeMsgTBE             OBJ_set_ctype,58L
+#define SN_setct_AcqCardCodeMsgTBE "setct-AcqCardCodeMsgTBE"
+#define NID_setct_AcqCardCodeMsgTBE 576
+#define OBJ_setct_AcqCardCodeMsgTBE OBJ_set_ctype, 58L
 
-#define SN_setct_AuthRevReqTBE          "setct-AuthRevReqTBE"
-#define NID_setct_AuthRevReqTBE         577
-#define OBJ_setct_AuthRevReqTBE         OBJ_set_ctype,59L
+#define SN_setct_AuthRevReqTBE "setct-AuthRevReqTBE"
+#define NID_setct_AuthRevReqTBE 577
+#define OBJ_setct_AuthRevReqTBE OBJ_set_ctype, 59L
 
-#define SN_setct_AuthRevResTBE          "setct-AuthRevResTBE"
-#define NID_setct_AuthRevResTBE         578
-#define OBJ_setct_AuthRevResTBE         OBJ_set_ctype,60L
+#define SN_setct_AuthRevResTBE "setct-AuthRevResTBE"
+#define NID_setct_AuthRevResTBE 578
+#define OBJ_setct_AuthRevResTBE OBJ_set_ctype, 60L
 
-#define SN_setct_AuthRevResTBEB         "setct-AuthRevResTBEB"
-#define NID_setct_AuthRevResTBEB                579
-#define OBJ_setct_AuthRevResTBEB                OBJ_set_ctype,61L
+#define SN_setct_AuthRevResTBEB "setct-AuthRevResTBEB"
+#define NID_setct_AuthRevResTBEB 579
+#define OBJ_setct_AuthRevResTBEB OBJ_set_ctype, 61L
 
-#define SN_setct_CapReqTBE              "setct-CapReqTBE"
-#define NID_setct_CapReqTBE             580
-#define OBJ_setct_CapReqTBE             OBJ_set_ctype,62L
+#define SN_setct_CapReqTBE "setct-CapReqTBE"
+#define NID_setct_CapReqTBE 580
+#define OBJ_setct_CapReqTBE OBJ_set_ctype, 62L
 
-#define SN_setct_CapReqTBEX             "setct-CapReqTBEX"
-#define NID_setct_CapReqTBEX            581
-#define OBJ_setct_CapReqTBEX            OBJ_set_ctype,63L
+#define SN_setct_CapReqTBEX "setct-CapReqTBEX"
+#define NID_setct_CapReqTBEX 581
+#define OBJ_setct_CapReqTBEX OBJ_set_ctype, 63L
 
-#define SN_setct_CapResTBE              "setct-CapResTBE"
-#define NID_setct_CapResTBE             582
-#define OBJ_setct_CapResTBE             OBJ_set_ctype,64L
+#define SN_setct_CapResTBE "setct-CapResTBE"
+#define NID_setct_CapResTBE 582
+#define OBJ_setct_CapResTBE OBJ_set_ctype, 64L
 
-#define SN_setct_CapRevReqTBE           "setct-CapRevReqTBE"
-#define NID_setct_CapRevReqTBE          583
-#define OBJ_setct_CapRevReqTBE          OBJ_set_ctype,65L
+#define SN_setct_CapRevReqTBE "setct-CapRevReqTBE"
+#define NID_setct_CapRevReqTBE 583
+#define OBJ_setct_CapRevReqTBE OBJ_set_ctype, 65L
 
-#define SN_setct_CapRevReqTBEX          "setct-CapRevReqTBEX"
-#define NID_setct_CapRevReqTBEX         584
-#define OBJ_setct_CapRevReqTBEX         OBJ_set_ctype,66L
+#define SN_setct_CapRevReqTBEX "setct-CapRevReqTBEX"
+#define NID_setct_CapRevReqTBEX 584
+#define OBJ_setct_CapRevReqTBEX OBJ_set_ctype, 66L
 
-#define SN_setct_CapRevResTBE           "setct-CapRevResTBE"
-#define NID_setct_CapRevResTBE          585
-#define OBJ_setct_CapRevResTBE          OBJ_set_ctype,67L
+#define SN_setct_CapRevResTBE "setct-CapRevResTBE"
+#define NID_setct_CapRevResTBE 585
+#define OBJ_setct_CapRevResTBE OBJ_set_ctype, 67L
 
-#define SN_setct_CredReqTBE             "setct-CredReqTBE"
-#define NID_setct_CredReqTBE            586
-#define OBJ_setct_CredReqTBE            OBJ_set_ctype,68L
+#define SN_setct_CredReqTBE "setct-CredReqTBE"
+#define NID_setct_CredReqTBE 586
+#define OBJ_setct_CredReqTBE OBJ_set_ctype, 68L
 
-#define SN_setct_CredReqTBEX            "setct-CredReqTBEX"
-#define NID_setct_CredReqTBEX           587
-#define OBJ_setct_CredReqTBEX           OBJ_set_ctype,69L
+#define SN_setct_CredReqTBEX "setct-CredReqTBEX"
+#define NID_setct_CredReqTBEX 587
+#define OBJ_setct_CredReqTBEX OBJ_set_ctype, 69L
 
-#define SN_setct_CredResTBE             "setct-CredResTBE"
-#define NID_setct_CredResTBE            588
-#define OBJ_setct_CredResTBE            OBJ_set_ctype,70L
+#define SN_setct_CredResTBE "setct-CredResTBE"
+#define NID_setct_CredResTBE 588
+#define OBJ_setct_CredResTBE OBJ_set_ctype, 70L
 
-#define SN_setct_CredRevReqTBE          "setct-CredRevReqTBE"
-#define NID_setct_CredRevReqTBE         589
-#define OBJ_setct_CredRevReqTBE         OBJ_set_ctype,71L
+#define SN_setct_CredRevReqTBE "setct-CredRevReqTBE"
+#define NID_setct_CredRevReqTBE 589
+#define OBJ_setct_CredRevReqTBE OBJ_set_ctype, 71L
 
-#define SN_setct_CredRevReqTBEX         "setct-CredRevReqTBEX"
-#define NID_setct_CredRevReqTBEX                590
-#define OBJ_setct_CredRevReqTBEX                OBJ_set_ctype,72L
+#define SN_setct_CredRevReqTBEX "setct-CredRevReqTBEX"
+#define NID_setct_CredRevReqTBEX 590
+#define OBJ_setct_CredRevReqTBEX OBJ_set_ctype, 72L
 
-#define SN_setct_CredRevResTBE          "setct-CredRevResTBE"
-#define NID_setct_CredRevResTBE         591
-#define OBJ_setct_CredRevResTBE         OBJ_set_ctype,73L
+#define SN_setct_CredRevResTBE "setct-CredRevResTBE"
+#define NID_setct_CredRevResTBE 591
+#define OBJ_setct_CredRevResTBE OBJ_set_ctype, 73L
 
-#define SN_setct_BatchAdminReqTBE               "setct-BatchAdminReqTBE"
-#define NID_setct_BatchAdminReqTBE              592
-#define OBJ_setct_BatchAdminReqTBE              OBJ_set_ctype,74L
+#define SN_setct_BatchAdminReqTBE "setct-BatchAdminReqTBE"
+#define NID_setct_BatchAdminReqTBE 592
+#define OBJ_setct_BatchAdminReqTBE OBJ_set_ctype, 74L
 
-#define SN_setct_BatchAdminResTBE               "setct-BatchAdminResTBE"
-#define NID_setct_BatchAdminResTBE              593
-#define OBJ_setct_BatchAdminResTBE              OBJ_set_ctype,75L
+#define SN_setct_BatchAdminResTBE "setct-BatchAdminResTBE"
+#define NID_setct_BatchAdminResTBE 593
+#define OBJ_setct_BatchAdminResTBE OBJ_set_ctype, 75L
 
-#define SN_setct_RegFormReqTBE          "setct-RegFormReqTBE"
-#define NID_setct_RegFormReqTBE         594
-#define OBJ_setct_RegFormReqTBE         OBJ_set_ctype,76L
+#define SN_setct_RegFormReqTBE "setct-RegFormReqTBE"
+#define NID_setct_RegFormReqTBE 594
+#define OBJ_setct_RegFormReqTBE OBJ_set_ctype, 76L
 
-#define SN_setct_CertReqTBE             "setct-CertReqTBE"
-#define NID_setct_CertReqTBE            595
-#define OBJ_setct_CertReqTBE            OBJ_set_ctype,77L
+#define SN_setct_CertReqTBE "setct-CertReqTBE"
+#define NID_setct_CertReqTBE 595
+#define OBJ_setct_CertReqTBE OBJ_set_ctype, 77L
 
-#define SN_setct_CertReqTBEX            "setct-CertReqTBEX"
-#define NID_setct_CertReqTBEX           596
-#define OBJ_setct_CertReqTBEX           OBJ_set_ctype,78L
+#define SN_setct_CertReqTBEX "setct-CertReqTBEX"
+#define NID_setct_CertReqTBEX 596
+#define OBJ_setct_CertReqTBEX OBJ_set_ctype, 78L
 
-#define SN_setct_CertResTBE             "setct-CertResTBE"
-#define NID_setct_CertResTBE            597
-#define OBJ_setct_CertResTBE            OBJ_set_ctype,79L
+#define SN_setct_CertResTBE "setct-CertResTBE"
+#define NID_setct_CertResTBE 597
+#define OBJ_setct_CertResTBE OBJ_set_ctype, 79L
 
-#define SN_setct_CRLNotificationTBS             "setct-CRLNotificationTBS"
-#define NID_setct_CRLNotificationTBS            598
-#define OBJ_setct_CRLNotificationTBS            OBJ_set_ctype,80L
+#define SN_setct_CRLNotificationTBS "setct-CRLNotificationTBS"
+#define NID_setct_CRLNotificationTBS 598
+#define OBJ_setct_CRLNotificationTBS OBJ_set_ctype, 80L
 
-#define SN_setct_CRLNotificationResTBS          "setct-CRLNotificationResTBS"
-#define NID_setct_CRLNotificationResTBS         599
-#define OBJ_setct_CRLNotificationResTBS         OBJ_set_ctype,81L
-
-#define SN_setct_BCIDistributionTBS             "setct-BCIDistributionTBS"
-#define NID_setct_BCIDistributionTBS            600
-#define OBJ_setct_BCIDistributionTBS            OBJ_set_ctype,82L
-
-#define SN_setext_genCrypt              "setext-genCrypt"
-#define LN_setext_genCrypt              "generic cryptogram"
-#define NID_setext_genCrypt             601
-#define OBJ_setext_genCrypt             OBJ_set_msgExt,1L
-
-#define SN_setext_miAuth                "setext-miAuth"
-#define LN_setext_miAuth                "merchant initiated auth"
-#define NID_setext_miAuth               602
-#define OBJ_setext_miAuth               OBJ_set_msgExt,3L
-
-#define SN_setext_pinSecure             "setext-pinSecure"
-#define NID_setext_pinSecure            603
-#define OBJ_setext_pinSecure            OBJ_set_msgExt,4L
-
-#define SN_setext_pinAny                "setext-pinAny"
-#define NID_setext_pinAny               604
-#define OBJ_setext_pinAny               OBJ_set_msgExt,5L
-
-#define SN_setext_track2                "setext-track2"
-#define NID_setext_track2               605
-#define OBJ_setext_track2               OBJ_set_msgExt,7L
-
-#define SN_setext_cv            "setext-cv"
-#define LN_setext_cv            "additional verification"
-#define NID_setext_cv           606
-#define OBJ_setext_cv           OBJ_set_msgExt,8L
-
-#define SN_set_policy_root              "set-policy-root"
-#define NID_set_policy_root             607
-#define OBJ_set_policy_root             OBJ_set_policy,0L
-
-#define SN_setCext_hashedRoot           "setCext-hashedRoot"
-#define NID_setCext_hashedRoot          608
-#define OBJ_setCext_hashedRoot          OBJ_set_certExt,0L
-
-#define SN_setCext_certType             "setCext-certType"
-#define NID_setCext_certType            609
-#define OBJ_setCext_certType            OBJ_set_certExt,1L
-
-#define SN_setCext_merchData            "setCext-merchData"
-#define NID_setCext_merchData           610
-#define OBJ_setCext_merchData           OBJ_set_certExt,2L
-
-#define SN_setCext_cCertRequired                "setCext-cCertRequired"
-#define NID_setCext_cCertRequired               611
-#define OBJ_setCext_cCertRequired               OBJ_set_certExt,3L
-
-#define SN_setCext_tunneling            "setCext-tunneling"
-#define NID_setCext_tunneling           612
-#define OBJ_setCext_tunneling           OBJ_set_certExt,4L
-
-#define SN_setCext_setExt               "setCext-setExt"
-#define NID_setCext_setExt              613
-#define OBJ_setCext_setExt              OBJ_set_certExt,5L
-
-#define SN_setCext_setQualf             "setCext-setQualf"
-#define NID_setCext_setQualf            614
-#define OBJ_setCext_setQualf            OBJ_set_certExt,6L
-
-#define SN_setCext_PGWYcapabilities             "setCext-PGWYcapabilities"
-#define NID_setCext_PGWYcapabilities            615
-#define OBJ_setCext_PGWYcapabilities            OBJ_set_certExt,7L
-
-#define SN_setCext_TokenIdentifier              "setCext-TokenIdentifier"
-#define NID_setCext_TokenIdentifier             616
-#define OBJ_setCext_TokenIdentifier             OBJ_set_certExt,8L
-
-#define SN_setCext_Track2Data           "setCext-Track2Data"
-#define NID_setCext_Track2Data          617
-#define OBJ_setCext_Track2Data          OBJ_set_certExt,9L
-
-#define SN_setCext_TokenType            "setCext-TokenType"
-#define NID_setCext_TokenType           618
-#define OBJ_setCext_TokenType           OBJ_set_certExt,10L
-
-#define SN_setCext_IssuerCapabilities           "setCext-IssuerCapabilities"
-#define NID_setCext_IssuerCapabilities          619
-#define OBJ_setCext_IssuerCapabilities          OBJ_set_certExt,11L
-
-#define SN_setAttr_Cert         "setAttr-Cert"
-#define NID_setAttr_Cert                620
-#define OBJ_setAttr_Cert                OBJ_set_attr,0L
-
-#define SN_setAttr_PGWYcap              "setAttr-PGWYcap"
-#define LN_setAttr_PGWYcap              "payment gateway capabilities"
-#define NID_setAttr_PGWYcap             621
-#define OBJ_setAttr_PGWYcap             OBJ_set_attr,1L
-
-#define SN_setAttr_TokenType            "setAttr-TokenType"
-#define NID_setAttr_TokenType           622
-#define OBJ_setAttr_TokenType           OBJ_set_attr,2L
-
-#define SN_setAttr_IssCap               "setAttr-IssCap"
-#define LN_setAttr_IssCap               "issuer capabilities"
-#define NID_setAttr_IssCap              623
-#define OBJ_setAttr_IssCap              OBJ_set_attr,3L
-
-#define SN_set_rootKeyThumb             "set-rootKeyThumb"
-#define NID_set_rootKeyThumb            624
-#define OBJ_set_rootKeyThumb            OBJ_setAttr_Cert,0L
-
-#define SN_set_addPolicy                "set-addPolicy"
-#define NID_set_addPolicy               625
-#define OBJ_set_addPolicy               OBJ_setAttr_Cert,1L
-
-#define SN_setAttr_Token_EMV            "setAttr-Token-EMV"
-#define NID_setAttr_Token_EMV           626
-#define OBJ_setAttr_Token_EMV           OBJ_setAttr_TokenType,1L
-
-#define SN_setAttr_Token_B0Prime                "setAttr-Token-B0Prime"
-#define NID_setAttr_Token_B0Prime               627
-#define OBJ_setAttr_Token_B0Prime               OBJ_setAttr_TokenType,2L
-
-#define SN_setAttr_IssCap_CVM           "setAttr-IssCap-CVM"
-#define NID_setAttr_IssCap_CVM          628
-#define OBJ_setAttr_IssCap_CVM          OBJ_setAttr_IssCap,3L
-
-#define SN_setAttr_IssCap_T2            "setAttr-IssCap-T2"
-#define NID_setAttr_IssCap_T2           629
-#define OBJ_setAttr_IssCap_T2           OBJ_setAttr_IssCap,4L
-
-#define SN_setAttr_IssCap_Sig           "setAttr-IssCap-Sig"
-#define NID_setAttr_IssCap_Sig          630
-#define OBJ_setAttr_IssCap_Sig          OBJ_setAttr_IssCap,5L
-
-#define SN_setAttr_GenCryptgrm          "setAttr-GenCryptgrm"
-#define LN_setAttr_GenCryptgrm          "generate cryptogram"
-#define NID_setAttr_GenCryptgrm         631
-#define OBJ_setAttr_GenCryptgrm         OBJ_setAttr_IssCap_CVM,1L
-
-#define SN_setAttr_T2Enc                "setAttr-T2Enc"
-#define LN_setAttr_T2Enc                "encrypted track 2"
-#define NID_setAttr_T2Enc               632
-#define OBJ_setAttr_T2Enc               OBJ_setAttr_IssCap_T2,1L
-
-#define SN_setAttr_T2cleartxt           "setAttr-T2cleartxt"
-#define LN_setAttr_T2cleartxt           "cleartext track 2"
-#define NID_setAttr_T2cleartxt          633
-#define OBJ_setAttr_T2cleartxt          OBJ_setAttr_IssCap_T2,2L
-
-#define SN_setAttr_TokICCsig            "setAttr-TokICCsig"
-#define LN_setAttr_TokICCsig            "ICC or token signature"
-#define NID_setAttr_TokICCsig           634
-#define OBJ_setAttr_TokICCsig           OBJ_setAttr_IssCap_Sig,1L
-
-#define SN_setAttr_SecDevSig            "setAttr-SecDevSig"
-#define LN_setAttr_SecDevSig            "secure device signature"
-#define NID_setAttr_SecDevSig           635
-#define OBJ_setAttr_SecDevSig           OBJ_setAttr_IssCap_Sig,2L
-
-#define SN_set_brand_IATA_ATA           "set-brand-IATA-ATA"
-#define NID_set_brand_IATA_ATA          636
-#define OBJ_set_brand_IATA_ATA          OBJ_set_brand,1L
-
-#define SN_set_brand_Diners             "set-brand-Diners"
-#define NID_set_brand_Diners            637
-#define OBJ_set_brand_Diners            OBJ_set_brand,30L
-
-#define SN_set_brand_AmericanExpress            "set-brand-AmericanExpress"
-#define NID_set_brand_AmericanExpress           638
-#define OBJ_set_brand_AmericanExpress           OBJ_set_brand,34L
-
-#define SN_set_brand_JCB                "set-brand-JCB"
-#define NID_set_brand_JCB               639
-#define OBJ_set_brand_JCB               OBJ_set_brand,35L
-
-#define SN_set_brand_Visa               "set-brand-Visa"
-#define NID_set_brand_Visa              640
-#define OBJ_set_brand_Visa              OBJ_set_brand,4L
-
-#define SN_set_brand_MasterCard         "set-brand-MasterCard"
-#define NID_set_brand_MasterCard                641
-#define OBJ_set_brand_MasterCard                OBJ_set_brand,5L
-
-#define SN_set_brand_Novus              "set-brand-Novus"
-#define NID_set_brand_Novus             642
-#define OBJ_set_brand_Novus             OBJ_set_brand,6011L
-
-#define SN_des_cdmf             "DES-CDMF"
-#define LN_des_cdmf             "des-cdmf"
-#define NID_des_cdmf            643
-#define OBJ_des_cdmf            OBJ_rsadsi,3L,10L
-
-#define SN_rsaOAEPEncryptionSET         "rsaOAEPEncryptionSET"
-#define NID_rsaOAEPEncryptionSET                644
-#define OBJ_rsaOAEPEncryptionSET                OBJ_rsadsi,1L,1L,6L
-
-#define SN_ipsec3               "Oakley-EC2N-3"
-#define LN_ipsec3               "ipsec3"
-#define NID_ipsec3              749
-
-#define SN_ipsec4               "Oakley-EC2N-4"
-#define LN_ipsec4               "ipsec4"
-#define NID_ipsec4              750
-
-#define SN_whirlpool            "whirlpool"
-#define NID_whirlpool           804
-#define OBJ_whirlpool           OBJ_iso,0L,10118L,3L,0L,55L
-
-#define SN_cryptopro            "cryptopro"
-#define NID_cryptopro           805
-#define OBJ_cryptopro           OBJ_member_body,643L,2L,2L
-
-#define SN_cryptocom            "cryptocom"
-#define NID_cryptocom           806
-#define OBJ_cryptocom           OBJ_member_body,643L,2L,9L
-
-#define SN_id_tc26              "id-tc26"
-#define NID_id_tc26             974
-#define OBJ_id_tc26             OBJ_member_body,643L,7L,1L
-
-#define SN_id_GostR3411_94_with_GostR3410_2001          "id-GostR3411-94-with-GostR3410-2001"
-#define LN_id_GostR3411_94_with_GostR3410_2001          "GOST R 34.11-94 with GOST R 34.10-2001"
-#define NID_id_GostR3411_94_with_GostR3410_2001         807
-#define OBJ_id_GostR3411_94_with_GostR3410_2001         OBJ_cryptopro,3L
-
-#define SN_id_GostR3411_94_with_GostR3410_94            "id-GostR3411-94-with-GostR3410-94"
-#define LN_id_GostR3411_94_with_GostR3410_94            "GOST R 34.11-94 with GOST R 34.10-94"
-#define NID_id_GostR3411_94_with_GostR3410_94           808
-#define OBJ_id_GostR3411_94_with_GostR3410_94           OBJ_cryptopro,4L
-
-#define SN_id_GostR3411_94              "md_gost94"
-#define LN_id_GostR3411_94              "GOST R 34.11-94"
-#define NID_id_GostR3411_94             809
-#define OBJ_id_GostR3411_94             OBJ_cryptopro,9L
-
-#define SN_id_HMACGostR3411_94          "id-HMACGostR3411-94"
-#define LN_id_HMACGostR3411_94          "HMAC GOST 34.11-94"
-#define NID_id_HMACGostR3411_94         810
-#define OBJ_id_HMACGostR3411_94         OBJ_cryptopro,10L
-
-#define SN_id_GostR3410_2001            "gost2001"
-#define LN_id_GostR3410_2001            "GOST R 34.10-2001"
-#define NID_id_GostR3410_2001           811
-#define OBJ_id_GostR3410_2001           OBJ_cryptopro,19L
-
-#define SN_id_GostR3410_94              "gost94"
-#define LN_id_GostR3410_94              "GOST R 34.10-94"
-#define NID_id_GostR3410_94             812
-#define OBJ_id_GostR3410_94             OBJ_cryptopro,20L
-
-#define SN_id_Gost28147_89              "gost89"
-#define LN_id_Gost28147_89              "GOST 28147-89"
-#define NID_id_Gost28147_89             813
-#define OBJ_id_Gost28147_89             OBJ_cryptopro,21L
-
-#define SN_gost89_cnt           "gost89-cnt"
-#define NID_gost89_cnt          814
-
-#define SN_gost89_cnt_12                "gost89-cnt-12"
-#define NID_gost89_cnt_12               975
-
-#define SN_gost89_cbc           "gost89-cbc"
-#define NID_gost89_cbc          1009
-
-#define SN_gost89_ecb           "gost89-ecb"
-#define NID_gost89_ecb          1010
-
-#define SN_gost89_ctr           "gost89-ctr"
-#define NID_gost89_ctr          1011
-
-#define SN_id_Gost28147_89_MAC          "gost-mac"
-#define LN_id_Gost28147_89_MAC          "GOST 28147-89 MAC"
-#define NID_id_Gost28147_89_MAC         815
-#define OBJ_id_Gost28147_89_MAC         OBJ_cryptopro,22L
-
-#define SN_gost_mac_12          "gost-mac-12"
-#define NID_gost_mac_12         976
-
-#define SN_id_GostR3411_94_prf          "prf-gostr3411-94"
-#define LN_id_GostR3411_94_prf          "GOST R 34.11-94 PRF"
-#define NID_id_GostR3411_94_prf         816
-#define OBJ_id_GostR3411_94_prf         OBJ_cryptopro,23L
-
-#define SN_id_GostR3410_2001DH          "id-GostR3410-2001DH"
-#define LN_id_GostR3410_2001DH          "GOST R 34.10-2001 DH"
-#define NID_id_GostR3410_2001DH         817
-#define OBJ_id_GostR3410_2001DH         OBJ_cryptopro,98L
-
-#define SN_id_GostR3410_94DH            "id-GostR3410-94DH"
-#define LN_id_GostR3410_94DH            "GOST R 34.10-94 DH"
-#define NID_id_GostR3410_94DH           818
-#define OBJ_id_GostR3410_94DH           OBJ_cryptopro,99L
-
-#define SN_id_Gost28147_89_CryptoPro_KeyMeshing         "id-Gost28147-89-CryptoPro-KeyMeshing"
-#define NID_id_Gost28147_89_CryptoPro_KeyMeshing                819
-#define OBJ_id_Gost28147_89_CryptoPro_KeyMeshing                OBJ_cryptopro,14L,1L
-
-#define SN_id_Gost28147_89_None_KeyMeshing              "id-Gost28147-89-None-KeyMeshing"
-#define NID_id_Gost28147_89_None_KeyMeshing             820
-#define OBJ_id_Gost28147_89_None_KeyMeshing             OBJ_cryptopro,14L,0L
-
-#define SN_id_GostR3411_94_TestParamSet         "id-GostR3411-94-TestParamSet"
-#define NID_id_GostR3411_94_TestParamSet                821
-#define OBJ_id_GostR3411_94_TestParamSet                OBJ_cryptopro,30L,0L
-
-#define SN_id_GostR3411_94_CryptoProParamSet            "id-GostR3411-94-CryptoProParamSet"
-#define NID_id_GostR3411_94_CryptoProParamSet           822
-#define OBJ_id_GostR3411_94_CryptoProParamSet           OBJ_cryptopro,30L,1L
-
-#define SN_id_Gost28147_89_TestParamSet         "id-Gost28147-89-TestParamSet"
-#define NID_id_Gost28147_89_TestParamSet                823
-#define OBJ_id_Gost28147_89_TestParamSet                OBJ_cryptopro,31L,0L
-
-#define SN_id_Gost28147_89_CryptoPro_A_ParamSet         "id-Gost28147-89-CryptoPro-A-ParamSet"
-#define NID_id_Gost28147_89_CryptoPro_A_ParamSet                824
-#define OBJ_id_Gost28147_89_CryptoPro_A_ParamSet                OBJ_cryptopro,31L,1L
-
-#define SN_id_Gost28147_89_CryptoPro_B_ParamSet         "id-Gost28147-89-CryptoPro-B-ParamSet"
-#define NID_id_Gost28147_89_CryptoPro_B_ParamSet                825
-#define OBJ_id_Gost28147_89_CryptoPro_B_ParamSet                OBJ_cryptopro,31L,2L
-
-#define SN_id_Gost28147_89_CryptoPro_C_ParamSet         "id-Gost28147-89-CryptoPro-C-ParamSet"
-#define NID_id_Gost28147_89_CryptoPro_C_ParamSet                826
-#define OBJ_id_Gost28147_89_CryptoPro_C_ParamSet                OBJ_cryptopro,31L,3L
-
-#define SN_id_Gost28147_89_CryptoPro_D_ParamSet         "id-Gost28147-89-CryptoPro-D-ParamSet"
-#define NID_id_Gost28147_89_CryptoPro_D_ParamSet                827
-#define OBJ_id_Gost28147_89_CryptoPro_D_ParamSet                OBJ_cryptopro,31L,4L
-
-#define SN_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet         "id-Gost28147-89-CryptoPro-Oscar-1-1-ParamSet"
-#define NID_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet                828
-#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet                OBJ_cryptopro,31L,5L
-
-#define SN_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet         "id-Gost28147-89-CryptoPro-Oscar-1-0-ParamSet"
-#define NID_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet                829
-#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet                OBJ_cryptopro,31L,6L
-
-#define SN_id_Gost28147_89_CryptoPro_RIC_1_ParamSet             "id-Gost28147-89-CryptoPro-RIC-1-ParamSet"
-#define NID_id_Gost28147_89_CryptoPro_RIC_1_ParamSet            830
-#define OBJ_id_Gost28147_89_CryptoPro_RIC_1_ParamSet            OBJ_cryptopro,31L,7L
-
-#define SN_id_GostR3410_94_TestParamSet         "id-GostR3410-94-TestParamSet"
-#define NID_id_GostR3410_94_TestParamSet                831
-#define OBJ_id_GostR3410_94_TestParamSet                OBJ_cryptopro,32L,0L
-
-#define SN_id_GostR3410_94_CryptoPro_A_ParamSet         "id-GostR3410-94-CryptoPro-A-ParamSet"
-#define NID_id_GostR3410_94_CryptoPro_A_ParamSet                832
-#define OBJ_id_GostR3410_94_CryptoPro_A_ParamSet                OBJ_cryptopro,32L,2L
-
-#define SN_id_GostR3410_94_CryptoPro_B_ParamSet         "id-GostR3410-94-CryptoPro-B-ParamSet"
-#define NID_id_GostR3410_94_CryptoPro_B_ParamSet                833
-#define OBJ_id_GostR3410_94_CryptoPro_B_ParamSet                OBJ_cryptopro,32L,3L
-
-#define SN_id_GostR3410_94_CryptoPro_C_ParamSet         "id-GostR3410-94-CryptoPro-C-ParamSet"
-#define NID_id_GostR3410_94_CryptoPro_C_ParamSet                834
-#define OBJ_id_GostR3410_94_CryptoPro_C_ParamSet                OBJ_cryptopro,32L,4L
-
-#define SN_id_GostR3410_94_CryptoPro_D_ParamSet         "id-GostR3410-94-CryptoPro-D-ParamSet"
-#define NID_id_GostR3410_94_CryptoPro_D_ParamSet                835
-#define OBJ_id_GostR3410_94_CryptoPro_D_ParamSet                OBJ_cryptopro,32L,5L
-
-#define SN_id_GostR3410_94_CryptoPro_XchA_ParamSet              "id-GostR3410-94-CryptoPro-XchA-ParamSet"
-#define NID_id_GostR3410_94_CryptoPro_XchA_ParamSet             836
-#define OBJ_id_GostR3410_94_CryptoPro_XchA_ParamSet             OBJ_cryptopro,33L,1L
-
-#define SN_id_GostR3410_94_CryptoPro_XchB_ParamSet              "id-GostR3410-94-CryptoPro-XchB-ParamSet"
-#define NID_id_GostR3410_94_CryptoPro_XchB_ParamSet             837
-#define OBJ_id_GostR3410_94_CryptoPro_XchB_ParamSet             OBJ_cryptopro,33L,2L
-
-#define SN_id_GostR3410_94_CryptoPro_XchC_ParamSet              "id-GostR3410-94-CryptoPro-XchC-ParamSet"
-#define NID_id_GostR3410_94_CryptoPro_XchC_ParamSet             838
-#define OBJ_id_GostR3410_94_CryptoPro_XchC_ParamSet             OBJ_cryptopro,33L,3L
-
-#define SN_id_GostR3410_2001_TestParamSet               "id-GostR3410-2001-TestParamSet"
-#define NID_id_GostR3410_2001_TestParamSet              839
-#define OBJ_id_GostR3410_2001_TestParamSet              OBJ_cryptopro,35L,0L
-
-#define SN_id_GostR3410_2001_CryptoPro_A_ParamSet               "id-GostR3410-2001-CryptoPro-A-ParamSet"
-#define NID_id_GostR3410_2001_CryptoPro_A_ParamSet              840
-#define OBJ_id_GostR3410_2001_CryptoPro_A_ParamSet              OBJ_cryptopro,35L,1L
-
-#define SN_id_GostR3410_2001_CryptoPro_B_ParamSet               "id-GostR3410-2001-CryptoPro-B-ParamSet"
-#define NID_id_GostR3410_2001_CryptoPro_B_ParamSet              841
-#define OBJ_id_GostR3410_2001_CryptoPro_B_ParamSet              OBJ_cryptopro,35L,2L
-
-#define SN_id_GostR3410_2001_CryptoPro_C_ParamSet               "id-GostR3410-2001-CryptoPro-C-ParamSet"
-#define NID_id_GostR3410_2001_CryptoPro_C_ParamSet              842
-#define OBJ_id_GostR3410_2001_CryptoPro_C_ParamSet              OBJ_cryptopro,35L,3L
-
-#define SN_id_GostR3410_2001_CryptoPro_XchA_ParamSet            "id-GostR3410-2001-CryptoPro-XchA-ParamSet"
-#define NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet           843
-#define OBJ_id_GostR3410_2001_CryptoPro_XchA_ParamSet           OBJ_cryptopro,36L,0L
-
-#define SN_id_GostR3410_2001_CryptoPro_XchB_ParamSet            "id-GostR3410-2001-CryptoPro-XchB-ParamSet"
-#define NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet           844
-#define OBJ_id_GostR3410_2001_CryptoPro_XchB_ParamSet           OBJ_cryptopro,36L,1L
-
-#define SN_id_GostR3410_94_a            "id-GostR3410-94-a"
-#define NID_id_GostR3410_94_a           845
-#define OBJ_id_GostR3410_94_a           OBJ_id_GostR3410_94,1L
-
-#define SN_id_GostR3410_94_aBis         "id-GostR3410-94-aBis"
-#define NID_id_GostR3410_94_aBis                846
-#define OBJ_id_GostR3410_94_aBis                OBJ_id_GostR3410_94,2L
-
-#define SN_id_GostR3410_94_b            "id-GostR3410-94-b"
-#define NID_id_GostR3410_94_b           847
-#define OBJ_id_GostR3410_94_b           OBJ_id_GostR3410_94,3L
-
-#define SN_id_GostR3410_94_bBis         "id-GostR3410-94-bBis"
-#define NID_id_GostR3410_94_bBis                848
-#define OBJ_id_GostR3410_94_bBis                OBJ_id_GostR3410_94,4L
-
-#define SN_id_Gost28147_89_cc           "id-Gost28147-89-cc"
-#define LN_id_Gost28147_89_cc           "GOST 28147-89 Cryptocom ParamSet"
-#define NID_id_Gost28147_89_cc          849
-#define OBJ_id_Gost28147_89_cc          OBJ_cryptocom,1L,6L,1L
-
-#define SN_id_GostR3410_94_cc           "gost94cc"
-#define LN_id_GostR3410_94_cc           "GOST 34.10-94 Cryptocom"
-#define NID_id_GostR3410_94_cc          850
-#define OBJ_id_GostR3410_94_cc          OBJ_cryptocom,1L,5L,3L
-
-#define SN_id_GostR3410_2001_cc         "gost2001cc"
-#define LN_id_GostR3410_2001_cc         "GOST 34.10-2001 Cryptocom"
-#define NID_id_GostR3410_2001_cc                851
-#define OBJ_id_GostR3410_2001_cc                OBJ_cryptocom,1L,5L,4L
-
-#define SN_id_GostR3411_94_with_GostR3410_94_cc         "id-GostR3411-94-with-GostR3410-94-cc"
-#define LN_id_GostR3411_94_with_GostR3410_94_cc         "GOST R 34.11-94 with GOST R 34.10-94 Cryptocom"
-#define NID_id_GostR3411_94_with_GostR3410_94_cc                852
-#define OBJ_id_GostR3411_94_with_GostR3410_94_cc                OBJ_cryptocom,1L,3L,3L
-
-#define SN_id_GostR3411_94_with_GostR3410_2001_cc               "id-GostR3411-94-with-GostR3410-2001-cc"
-#define LN_id_GostR3411_94_with_GostR3410_2001_cc               "GOST R 34.11-94 with GOST R 34.10-2001 Cryptocom"
-#define NID_id_GostR3411_94_with_GostR3410_2001_cc              853
-#define OBJ_id_GostR3411_94_with_GostR3410_2001_cc              OBJ_cryptocom,1L,3L,4L
-
-#define SN_id_GostR3410_2001_ParamSet_cc                "id-GostR3410-2001-ParamSet-cc"
-#define LN_id_GostR3410_2001_ParamSet_cc                "GOST R 3410-2001 Parameter Set Cryptocom"
-#define NID_id_GostR3410_2001_ParamSet_cc               854
-#define OBJ_id_GostR3410_2001_ParamSet_cc               OBJ_cryptocom,1L,8L,1L
-
-#define SN_id_tc26_algorithms           "id-tc26-algorithms"
-#define NID_id_tc26_algorithms          977
-#define OBJ_id_tc26_algorithms          OBJ_id_tc26,1L
-
-#define SN_id_tc26_sign         "id-tc26-sign"
-#define NID_id_tc26_sign                978
-#define OBJ_id_tc26_sign                OBJ_id_tc26_algorithms,1L
-
-#define SN_id_GostR3410_2012_256                "gost2012_256"
-#define LN_id_GostR3410_2012_256                "GOST R 34.10-2012 with 256 bit modulus"
-#define NID_id_GostR3410_2012_256               979
-#define OBJ_id_GostR3410_2012_256               OBJ_id_tc26_sign,1L
-
-#define SN_id_GostR3410_2012_512                "gost2012_512"
-#define LN_id_GostR3410_2012_512                "GOST R 34.10-2012 with 512 bit modulus"
-#define NID_id_GostR3410_2012_512               980
-#define OBJ_id_GostR3410_2012_512               OBJ_id_tc26_sign,2L
-
-#define SN_id_tc26_digest               "id-tc26-digest"
-#define NID_id_tc26_digest              981
-#define OBJ_id_tc26_digest              OBJ_id_tc26_algorithms,2L
-
-#define SN_id_GostR3411_2012_256                "md_gost12_256"
-#define LN_id_GostR3411_2012_256                "GOST R 34.11-2012 with 256 bit hash"
-#define NID_id_GostR3411_2012_256               982
-#define OBJ_id_GostR3411_2012_256               OBJ_id_tc26_digest,2L
-
-#define SN_id_GostR3411_2012_512                "md_gost12_512"
-#define LN_id_GostR3411_2012_512                "GOST R 34.11-2012 with 512 bit hash"
-#define NID_id_GostR3411_2012_512               983
-#define OBJ_id_GostR3411_2012_512               OBJ_id_tc26_digest,3L
-
-#define SN_id_tc26_signwithdigest               "id-tc26-signwithdigest"
-#define NID_id_tc26_signwithdigest              984
-#define OBJ_id_tc26_signwithdigest              OBJ_id_tc26_algorithms,3L
-
-#define SN_id_tc26_signwithdigest_gost3410_2012_256             "id-tc26-signwithdigest-gost3410-2012-256"
-#define LN_id_tc26_signwithdigest_gost3410_2012_256             "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)"
-#define NID_id_tc26_signwithdigest_gost3410_2012_256            985
-#define OBJ_id_tc26_signwithdigest_gost3410_2012_256            OBJ_id_tc26_signwithdigest,2L
-
-#define SN_id_tc26_signwithdigest_gost3410_2012_512             "id-tc26-signwithdigest-gost3410-2012-512"
-#define LN_id_tc26_signwithdigest_gost3410_2012_512             "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)"
-#define NID_id_tc26_signwithdigest_gost3410_2012_512            986
-#define OBJ_id_tc26_signwithdigest_gost3410_2012_512            OBJ_id_tc26_signwithdigest,3L
-
-#define SN_id_tc26_mac          "id-tc26-mac"
-#define NID_id_tc26_mac         987
-#define OBJ_id_tc26_mac         OBJ_id_tc26_algorithms,4L
-
-#define SN_id_tc26_hmac_gost_3411_2012_256              "id-tc26-hmac-gost-3411-2012-256"
-#define LN_id_tc26_hmac_gost_3411_2012_256              "HMAC GOST 34.11-2012 256 bit"
-#define NID_id_tc26_hmac_gost_3411_2012_256             988
-#define OBJ_id_tc26_hmac_gost_3411_2012_256             OBJ_id_tc26_mac,1L
-
-#define SN_id_tc26_hmac_gost_3411_2012_512              "id-tc26-hmac-gost-3411-2012-512"
-#define LN_id_tc26_hmac_gost_3411_2012_512              "HMAC GOST 34.11-2012 512 bit"
-#define NID_id_tc26_hmac_gost_3411_2012_512             989
-#define OBJ_id_tc26_hmac_gost_3411_2012_512             OBJ_id_tc26_mac,2L
-
-#define SN_id_tc26_cipher               "id-tc26-cipher"
-#define NID_id_tc26_cipher              990
-#define OBJ_id_tc26_cipher              OBJ_id_tc26_algorithms,5L
-
-#define SN_id_tc26_cipher_gostr3412_2015_magma          "id-tc26-cipher-gostr3412-2015-magma"
-#define NID_id_tc26_cipher_gostr3412_2015_magma         1173
-#define OBJ_id_tc26_cipher_gostr3412_2015_magma         OBJ_id_tc26_cipher,1L
-
-#define SN_magma_ctr_acpkm              "magma-ctr-acpkm"
-#define NID_magma_ctr_acpkm             1174
-#define OBJ_magma_ctr_acpkm             OBJ_id_tc26_cipher_gostr3412_2015_magma,1L
-
-#define SN_magma_ctr_acpkm_omac         "magma-ctr-acpkm-omac"
-#define NID_magma_ctr_acpkm_omac                1175
-#define OBJ_magma_ctr_acpkm_omac                OBJ_id_tc26_cipher_gostr3412_2015_magma,2L
-
-#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik             "id-tc26-cipher-gostr3412-2015-kuznyechik"
-#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik            1176
-#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik            OBJ_id_tc26_cipher,2L
-
-#define SN_kuznyechik_ctr_acpkm         "kuznyechik-ctr-acpkm"
-#define NID_kuznyechik_ctr_acpkm                1177
-#define OBJ_kuznyechik_ctr_acpkm                OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,1L
-
-#define SN_kuznyechik_ctr_acpkm_omac            "kuznyechik-ctr-acpkm-omac"
-#define NID_kuznyechik_ctr_acpkm_omac           1178
-#define OBJ_kuznyechik_ctr_acpkm_omac           OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,2L
-
-#define SN_id_tc26_agreement            "id-tc26-agreement"
-#define NID_id_tc26_agreement           991
-#define OBJ_id_tc26_agreement           OBJ_id_tc26_algorithms,6L
-
-#define SN_id_tc26_agreement_gost_3410_2012_256         "id-tc26-agreement-gost-3410-2012-256"
-#define NID_id_tc26_agreement_gost_3410_2012_256                992
-#define OBJ_id_tc26_agreement_gost_3410_2012_256                OBJ_id_tc26_agreement,1L
-
-#define SN_id_tc26_agreement_gost_3410_2012_512         "id-tc26-agreement-gost-3410-2012-512"
-#define NID_id_tc26_agreement_gost_3410_2012_512                993
-#define OBJ_id_tc26_agreement_gost_3410_2012_512                OBJ_id_tc26_agreement,2L
-
-#define SN_id_tc26_wrap         "id-tc26-wrap"
-#define NID_id_tc26_wrap                1179
-#define OBJ_id_tc26_wrap                OBJ_id_tc26_algorithms,7L
-
-#define SN_id_tc26_wrap_gostr3412_2015_magma            "id-tc26-wrap-gostr3412-2015-magma"
-#define NID_id_tc26_wrap_gostr3412_2015_magma           1180
-#define OBJ_id_tc26_wrap_gostr3412_2015_magma           OBJ_id_tc26_wrap,1L
-
-#define SN_magma_kexp15         "magma-kexp15"
-#define NID_magma_kexp15                1181
-#define OBJ_magma_kexp15                OBJ_id_tc26_wrap_gostr3412_2015_magma,1L
-
-#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik               "id-tc26-wrap-gostr3412-2015-kuznyechik"
-#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik              1182
-#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik              OBJ_id_tc26_wrap,2L
-
-#define SN_kuznyechik_kexp15            "kuznyechik-kexp15"
-#define NID_kuznyechik_kexp15           1183
-#define OBJ_kuznyechik_kexp15           OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik,1L
-
-#define SN_id_tc26_constants            "id-tc26-constants"
-#define NID_id_tc26_constants           994
-#define OBJ_id_tc26_constants           OBJ_id_tc26,2L
-
-#define SN_id_tc26_sign_constants               "id-tc26-sign-constants"
-#define NID_id_tc26_sign_constants              995
-#define OBJ_id_tc26_sign_constants              OBJ_id_tc26_constants,1L
-
-#define SN_id_tc26_gost_3410_2012_256_constants         "id-tc26-gost-3410-2012-256-constants"
-#define NID_id_tc26_gost_3410_2012_256_constants                1147
-#define OBJ_id_tc26_gost_3410_2012_256_constants                OBJ_id_tc26_sign_constants,1L
-
-#define SN_id_tc26_gost_3410_2012_256_paramSetA         "id-tc26-gost-3410-2012-256-paramSetA"
-#define LN_id_tc26_gost_3410_2012_256_paramSetA         "GOST R 34.10-2012 (256 bit) ParamSet A"
-#define NID_id_tc26_gost_3410_2012_256_paramSetA                1148
-#define OBJ_id_tc26_gost_3410_2012_256_paramSetA                OBJ_id_tc26_gost_3410_2012_256_constants,1L
-
-#define SN_id_tc26_gost_3410_2012_256_paramSetB         "id-tc26-gost-3410-2012-256-paramSetB"
-#define LN_id_tc26_gost_3410_2012_256_paramSetB         "GOST R 34.10-2012 (256 bit) ParamSet B"
-#define NID_id_tc26_gost_3410_2012_256_paramSetB                1184
-#define OBJ_id_tc26_gost_3410_2012_256_paramSetB                OBJ_id_tc26_gost_3410_2012_256_constants,2L
-
-#define SN_id_tc26_gost_3410_2012_256_paramSetC         "id-tc26-gost-3410-2012-256-paramSetC"
-#define LN_id_tc26_gost_3410_2012_256_paramSetC         "GOST R 34.10-2012 (256 bit) ParamSet C"
-#define NID_id_tc26_gost_3410_2012_256_paramSetC                1185
-#define OBJ_id_tc26_gost_3410_2012_256_paramSetC                OBJ_id_tc26_gost_3410_2012_256_constants,3L
-
-#define SN_id_tc26_gost_3410_2012_256_paramSetD         "id-tc26-gost-3410-2012-256-paramSetD"
-#define LN_id_tc26_gost_3410_2012_256_paramSetD         "GOST R 34.10-2012 (256 bit) ParamSet D"
-#define NID_id_tc26_gost_3410_2012_256_paramSetD                1186
-#define OBJ_id_tc26_gost_3410_2012_256_paramSetD                OBJ_id_tc26_gost_3410_2012_256_constants,4L
-
-#define SN_id_tc26_gost_3410_2012_512_constants         "id-tc26-gost-3410-2012-512-constants"
-#define NID_id_tc26_gost_3410_2012_512_constants                996
-#define OBJ_id_tc26_gost_3410_2012_512_constants                OBJ_id_tc26_sign_constants,2L
-
-#define SN_id_tc26_gost_3410_2012_512_paramSetTest              "id-tc26-gost-3410-2012-512-paramSetTest"
-#define LN_id_tc26_gost_3410_2012_512_paramSetTest              "GOST R 34.10-2012 (512 bit) testing parameter set"
-#define NID_id_tc26_gost_3410_2012_512_paramSetTest             997
-#define OBJ_id_tc26_gost_3410_2012_512_paramSetTest             OBJ_id_tc26_gost_3410_2012_512_constants,0L
-
-#define SN_id_tc26_gost_3410_2012_512_paramSetA         "id-tc26-gost-3410-2012-512-paramSetA"
-#define LN_id_tc26_gost_3410_2012_512_paramSetA         "GOST R 34.10-2012 (512 bit) ParamSet A"
-#define NID_id_tc26_gost_3410_2012_512_paramSetA                998
-#define OBJ_id_tc26_gost_3410_2012_512_paramSetA                OBJ_id_tc26_gost_3410_2012_512_constants,1L
-
-#define SN_id_tc26_gost_3410_2012_512_paramSetB         "id-tc26-gost-3410-2012-512-paramSetB"
-#define LN_id_tc26_gost_3410_2012_512_paramSetB         "GOST R 34.10-2012 (512 bit) ParamSet B"
-#define NID_id_tc26_gost_3410_2012_512_paramSetB                999
-#define OBJ_id_tc26_gost_3410_2012_512_paramSetB                OBJ_id_tc26_gost_3410_2012_512_constants,2L
-
-#define SN_id_tc26_gost_3410_2012_512_paramSetC         "id-tc26-gost-3410-2012-512-paramSetC"
-#define LN_id_tc26_gost_3410_2012_512_paramSetC         "GOST R 34.10-2012 (512 bit) ParamSet C"
-#define NID_id_tc26_gost_3410_2012_512_paramSetC                1149
-#define OBJ_id_tc26_gost_3410_2012_512_paramSetC                OBJ_id_tc26_gost_3410_2012_512_constants,3L
-
-#define SN_id_tc26_digest_constants             "id-tc26-digest-constants"
-#define NID_id_tc26_digest_constants            1000
-#define OBJ_id_tc26_digest_constants            OBJ_id_tc26_constants,2L
-
-#define SN_id_tc26_cipher_constants             "id-tc26-cipher-constants"
-#define NID_id_tc26_cipher_constants            1001
-#define OBJ_id_tc26_cipher_constants            OBJ_id_tc26_constants,5L
-
-#define SN_id_tc26_gost_28147_constants         "id-tc26-gost-28147-constants"
-#define NID_id_tc26_gost_28147_constants                1002
-#define OBJ_id_tc26_gost_28147_constants                OBJ_id_tc26_cipher_constants,1L
-
-#define SN_id_tc26_gost_28147_param_Z           "id-tc26-gost-28147-param-Z"
-#define LN_id_tc26_gost_28147_param_Z           "GOST 28147-89 TC26 parameter set"
-#define NID_id_tc26_gost_28147_param_Z          1003
-#define OBJ_id_tc26_gost_28147_param_Z          OBJ_id_tc26_gost_28147_constants,1L
-
-#define SN_INN          "INN"
-#define LN_INN          "INN"
-#define NID_INN         1004
-#define OBJ_INN         OBJ_member_body,643L,3L,131L,1L,1L
-
-#define SN_OGRN         "OGRN"
-#define LN_OGRN         "OGRN"
-#define NID_OGRN                1005
-#define OBJ_OGRN                OBJ_member_body,643L,100L,1L
-
-#define SN_SNILS                "SNILS"
-#define LN_SNILS                "SNILS"
-#define NID_SNILS               1006
-#define OBJ_SNILS               OBJ_member_body,643L,100L,3L
-
-#define SN_OGRNIP               "OGRNIP"
-#define LN_OGRNIP               "OGRNIP"
-#define NID_OGRNIP              1226
-#define OBJ_OGRNIP              OBJ_member_body,643L,100L,5L
-
-#define SN_subjectSignTool              "subjectSignTool"
-#define LN_subjectSignTool              "Signing Tool of Subject"
-#define NID_subjectSignTool             1007
-#define OBJ_subjectSignTool             OBJ_member_body,643L,100L,111L
-
-#define SN_issuerSignTool               "issuerSignTool"
-#define LN_issuerSignTool               "Signing Tool of Issuer"
-#define NID_issuerSignTool              1008
-#define OBJ_issuerSignTool              OBJ_member_body,643L,100L,112L
-
-#define SN_classSignTool                "classSignTool"
-#define LN_classSignTool                "Class of Signing Tool"
-#define NID_classSignTool               1227
-#define OBJ_classSignTool               OBJ_member_body,643L,100L,113L
-
-#define SN_classSignToolKC1             "classSignToolKC1"
-#define LN_classSignToolKC1             "Class of Signing Tool KC1"
-#define NID_classSignToolKC1            1228
-#define OBJ_classSignToolKC1            OBJ_member_body,643L,100L,113L,1L
-
-#define SN_classSignToolKC2             "classSignToolKC2"
-#define LN_classSignToolKC2             "Class of Signing Tool KC2"
-#define NID_classSignToolKC2            1229
-#define OBJ_classSignToolKC2            OBJ_member_body,643L,100L,113L,2L
-
-#define SN_classSignToolKC3             "classSignToolKC3"
-#define LN_classSignToolKC3             "Class of Signing Tool KC3"
-#define NID_classSignToolKC3            1230
-#define OBJ_classSignToolKC3            OBJ_member_body,643L,100L,113L,3L
-
-#define SN_classSignToolKB1             "classSignToolKB1"
-#define LN_classSignToolKB1             "Class of Signing Tool KB1"
-#define NID_classSignToolKB1            1231
-#define OBJ_classSignToolKB1            OBJ_member_body,643L,100L,113L,4L
-
-#define SN_classSignToolKB2             "classSignToolKB2"
-#define LN_classSignToolKB2             "Class of Signing Tool KB2"
-#define NID_classSignToolKB2            1232
-#define OBJ_classSignToolKB2            OBJ_member_body,643L,100L,113L,5L
-
-#define SN_classSignToolKA1             "classSignToolKA1"
-#define LN_classSignToolKA1             "Class of Signing Tool KA1"
-#define NID_classSignToolKA1            1233
-#define OBJ_classSignToolKA1            OBJ_member_body,643L,100L,113L,6L
-
-#define SN_kuznyechik_ecb               "kuznyechik-ecb"
-#define NID_kuznyechik_ecb              1012
-
-#define SN_kuznyechik_ctr               "kuznyechik-ctr"
-#define NID_kuznyechik_ctr              1013
-
-#define SN_kuznyechik_ofb               "kuznyechik-ofb"
-#define NID_kuznyechik_ofb              1014
-
-#define SN_kuznyechik_cbc               "kuznyechik-cbc"
-#define NID_kuznyechik_cbc              1015
-
-#define SN_kuznyechik_cfb               "kuznyechik-cfb"
-#define NID_kuznyechik_cfb              1016
-
-#define SN_kuznyechik_mac               "kuznyechik-mac"
-#define NID_kuznyechik_mac              1017
-
-#define SN_magma_ecb            "magma-ecb"
-#define NID_magma_ecb           1187
-
-#define SN_magma_ctr            "magma-ctr"
-#define NID_magma_ctr           1188
-
-#define SN_magma_ofb            "magma-ofb"
-#define NID_magma_ofb           1189
-
-#define SN_magma_cbc            "magma-cbc"
-#define NID_magma_cbc           1190
-
-#define SN_magma_cfb            "magma-cfb"
-#define NID_magma_cfb           1191
-
-#define SN_magma_mac            "magma-mac"
-#define NID_magma_mac           1192
-
-#define SN_camellia_128_cbc             "CAMELLIA-128-CBC"
-#define LN_camellia_128_cbc             "camellia-128-cbc"
-#define NID_camellia_128_cbc            751
-#define OBJ_camellia_128_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,2L
-
-#define SN_camellia_192_cbc             "CAMELLIA-192-CBC"
-#define LN_camellia_192_cbc             "camellia-192-cbc"
-#define NID_camellia_192_cbc            752
-#define OBJ_camellia_192_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,3L
-
-#define SN_camellia_256_cbc             "CAMELLIA-256-CBC"
-#define LN_camellia_256_cbc             "camellia-256-cbc"
-#define NID_camellia_256_cbc            753
-#define OBJ_camellia_256_cbc            1L,2L,392L,200011L,61L,1L,1L,1L,4L
-
-#define SN_id_camellia128_wrap          "id-camellia128-wrap"
-#define NID_id_camellia128_wrap         907
-#define OBJ_id_camellia128_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,2L
-
-#define SN_id_camellia192_wrap          "id-camellia192-wrap"
-#define NID_id_camellia192_wrap         908
-#define OBJ_id_camellia192_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,3L
-
-#define SN_id_camellia256_wrap          "id-camellia256-wrap"
-#define NID_id_camellia256_wrap         909
-#define OBJ_id_camellia256_wrap         1L,2L,392L,200011L,61L,1L,1L,3L,4L
-
-#define OBJ_ntt_ds              0L,3L,4401L,5L
-
-#define OBJ_camellia            OBJ_ntt_ds,3L,1L,9L
-
-#define SN_camellia_128_ecb             "CAMELLIA-128-ECB"
-#define LN_camellia_128_ecb             "camellia-128-ecb"
-#define NID_camellia_128_ecb            754
-#define OBJ_camellia_128_ecb            OBJ_camellia,1L
-
-#define SN_camellia_128_ofb128          "CAMELLIA-128-OFB"
-#define LN_camellia_128_ofb128          "camellia-128-ofb"
-#define NID_camellia_128_ofb128         766
-#define OBJ_camellia_128_ofb128         OBJ_camellia,3L
-
-#define SN_camellia_128_cfb128          "CAMELLIA-128-CFB"
-#define LN_camellia_128_cfb128          "camellia-128-cfb"
-#define NID_camellia_128_cfb128         757
-#define OBJ_camellia_128_cfb128         OBJ_camellia,4L
-
-#define SN_camellia_128_gcm             "CAMELLIA-128-GCM"
-#define LN_camellia_128_gcm             "camellia-128-gcm"
-#define NID_camellia_128_gcm            961
-#define OBJ_camellia_128_gcm            OBJ_camellia,6L
-
-#define SN_camellia_128_ccm             "CAMELLIA-128-CCM"
-#define LN_camellia_128_ccm             "camellia-128-ccm"
-#define NID_camellia_128_ccm            962
-#define OBJ_camellia_128_ccm            OBJ_camellia,7L
-
-#define SN_camellia_128_ctr             "CAMELLIA-128-CTR"
-#define LN_camellia_128_ctr             "camellia-128-ctr"
-#define NID_camellia_128_ctr            963
-#define OBJ_camellia_128_ctr            OBJ_camellia,9L
-
-#define SN_camellia_128_cmac            "CAMELLIA-128-CMAC"
-#define LN_camellia_128_cmac            "camellia-128-cmac"
-#define NID_camellia_128_cmac           964
-#define OBJ_camellia_128_cmac           OBJ_camellia,10L
-
-#define SN_camellia_192_ecb             "CAMELLIA-192-ECB"
-#define LN_camellia_192_ecb             "camellia-192-ecb"
-#define NID_camellia_192_ecb            755
-#define OBJ_camellia_192_ecb            OBJ_camellia,21L
-
-#define SN_camellia_192_ofb128          "CAMELLIA-192-OFB"
-#define LN_camellia_192_ofb128          "camellia-192-ofb"
-#define NID_camellia_192_ofb128         767
-#define OBJ_camellia_192_ofb128         OBJ_camellia,23L
-
-#define SN_camellia_192_cfb128          "CAMELLIA-192-CFB"
-#define LN_camellia_192_cfb128          "camellia-192-cfb"
-#define NID_camellia_192_cfb128         758
-#define OBJ_camellia_192_cfb128         OBJ_camellia,24L
-
-#define SN_camellia_192_gcm             "CAMELLIA-192-GCM"
-#define LN_camellia_192_gcm             "camellia-192-gcm"
-#define NID_camellia_192_gcm            965
-#define OBJ_camellia_192_gcm            OBJ_camellia,26L
-
-#define SN_camellia_192_ccm             "CAMELLIA-192-CCM"
-#define LN_camellia_192_ccm             "camellia-192-ccm"
-#define NID_camellia_192_ccm            966
-#define OBJ_camellia_192_ccm            OBJ_camellia,27L
-
-#define SN_camellia_192_ctr             "CAMELLIA-192-CTR"
-#define LN_camellia_192_ctr             "camellia-192-ctr"
-#define NID_camellia_192_ctr            967
-#define OBJ_camellia_192_ctr            OBJ_camellia,29L
-
-#define SN_camellia_192_cmac            "CAMELLIA-192-CMAC"
-#define LN_camellia_192_cmac            "camellia-192-cmac"
-#define NID_camellia_192_cmac           968
-#define OBJ_camellia_192_cmac           OBJ_camellia,30L
-
-#define SN_camellia_256_ecb             "CAMELLIA-256-ECB"
-#define LN_camellia_256_ecb             "camellia-256-ecb"
-#define NID_camellia_256_ecb            756
-#define OBJ_camellia_256_ecb            OBJ_camellia,41L
-
-#define SN_camellia_256_ofb128          "CAMELLIA-256-OFB"
-#define LN_camellia_256_ofb128          "camellia-256-ofb"
-#define NID_camellia_256_ofb128         768
-#define OBJ_camellia_256_ofb128         OBJ_camellia,43L
-
-#define SN_camellia_256_cfb128          "CAMELLIA-256-CFB"
-#define LN_camellia_256_cfb128          "camellia-256-cfb"
-#define NID_camellia_256_cfb128         759
-#define OBJ_camellia_256_cfb128         OBJ_camellia,44L
-
-#define SN_camellia_256_gcm             "CAMELLIA-256-GCM"
-#define LN_camellia_256_gcm             "camellia-256-gcm"
-#define NID_camellia_256_gcm            969
-#define OBJ_camellia_256_gcm            OBJ_camellia,46L
-
-#define SN_camellia_256_ccm             "CAMELLIA-256-CCM"
-#define LN_camellia_256_ccm             "camellia-256-ccm"
-#define NID_camellia_256_ccm            970
-#define OBJ_camellia_256_ccm            OBJ_camellia,47L
-
-#define SN_camellia_256_ctr             "CAMELLIA-256-CTR"
-#define LN_camellia_256_ctr             "camellia-256-ctr"
-#define NID_camellia_256_ctr            971
-#define OBJ_camellia_256_ctr            OBJ_camellia,49L
-
-#define SN_camellia_256_cmac            "CAMELLIA-256-CMAC"
-#define LN_camellia_256_cmac            "camellia-256-cmac"
-#define NID_camellia_256_cmac           972
-#define OBJ_camellia_256_cmac           OBJ_camellia,50L
-
-#define SN_camellia_128_cfb1            "CAMELLIA-128-CFB1"
-#define LN_camellia_128_cfb1            "camellia-128-cfb1"
-#define NID_camellia_128_cfb1           760
-
-#define SN_camellia_192_cfb1            "CAMELLIA-192-CFB1"
-#define LN_camellia_192_cfb1            "camellia-192-cfb1"
-#define NID_camellia_192_cfb1           761
-
-#define SN_camellia_256_cfb1            "CAMELLIA-256-CFB1"
-#define LN_camellia_256_cfb1            "camellia-256-cfb1"
-#define NID_camellia_256_cfb1           762
-
-#define SN_camellia_128_cfb8            "CAMELLIA-128-CFB8"
-#define LN_camellia_128_cfb8            "camellia-128-cfb8"
-#define NID_camellia_128_cfb8           763
-
-#define SN_camellia_192_cfb8            "CAMELLIA-192-CFB8"
-#define LN_camellia_192_cfb8            "camellia-192-cfb8"
-#define NID_camellia_192_cfb8           764
-
-#define SN_camellia_256_cfb8            "CAMELLIA-256-CFB8"
-#define LN_camellia_256_cfb8            "camellia-256-cfb8"
-#define NID_camellia_256_cfb8           765
-
-#define OBJ_aria                1L,2L,410L,200046L,1L,1L
-
-#define SN_aria_128_ecb         "ARIA-128-ECB"
-#define LN_aria_128_ecb         "aria-128-ecb"
-#define NID_aria_128_ecb                1065
-#define OBJ_aria_128_ecb                OBJ_aria,1L
-
-#define SN_aria_128_cbc         "ARIA-128-CBC"
-#define LN_aria_128_cbc         "aria-128-cbc"
-#define NID_aria_128_cbc                1066
-#define OBJ_aria_128_cbc                OBJ_aria,2L
-
-#define SN_aria_128_cfb128              "ARIA-128-CFB"
-#define LN_aria_128_cfb128              "aria-128-cfb"
-#define NID_aria_128_cfb128             1067
-#define OBJ_aria_128_cfb128             OBJ_aria,3L
-
-#define SN_aria_128_ofb128              "ARIA-128-OFB"
-#define LN_aria_128_ofb128              "aria-128-ofb"
-#define NID_aria_128_ofb128             1068
-#define OBJ_aria_128_ofb128             OBJ_aria,4L
-
-#define SN_aria_128_ctr         "ARIA-128-CTR"
-#define LN_aria_128_ctr         "aria-128-ctr"
-#define NID_aria_128_ctr                1069
-#define OBJ_aria_128_ctr                OBJ_aria,5L
-
-#define SN_aria_192_ecb         "ARIA-192-ECB"
-#define LN_aria_192_ecb         "aria-192-ecb"
-#define NID_aria_192_ecb                1070
-#define OBJ_aria_192_ecb                OBJ_aria,6L
-
-#define SN_aria_192_cbc         "ARIA-192-CBC"
-#define LN_aria_192_cbc         "aria-192-cbc"
-#define NID_aria_192_cbc                1071
-#define OBJ_aria_192_cbc                OBJ_aria,7L
-
-#define SN_aria_192_cfb128              "ARIA-192-CFB"
-#define LN_aria_192_cfb128              "aria-192-cfb"
-#define NID_aria_192_cfb128             1072
-#define OBJ_aria_192_cfb128             OBJ_aria,8L
-
-#define SN_aria_192_ofb128              "ARIA-192-OFB"
-#define LN_aria_192_ofb128              "aria-192-ofb"
-#define NID_aria_192_ofb128             1073
-#define OBJ_aria_192_ofb128             OBJ_aria,9L
-
-#define SN_aria_192_ctr         "ARIA-192-CTR"
-#define LN_aria_192_ctr         "aria-192-ctr"
-#define NID_aria_192_ctr                1074
-#define OBJ_aria_192_ctr                OBJ_aria,10L
-
-#define SN_aria_256_ecb         "ARIA-256-ECB"
-#define LN_aria_256_ecb         "aria-256-ecb"
-#define NID_aria_256_ecb                1075
-#define OBJ_aria_256_ecb                OBJ_aria,11L
-
-#define SN_aria_256_cbc         "ARIA-256-CBC"
-#define LN_aria_256_cbc         "aria-256-cbc"
-#define NID_aria_256_cbc                1076
-#define OBJ_aria_256_cbc                OBJ_aria,12L
-
-#define SN_aria_256_cfb128              "ARIA-256-CFB"
-#define LN_aria_256_cfb128              "aria-256-cfb"
-#define NID_aria_256_cfb128             1077
-#define OBJ_aria_256_cfb128             OBJ_aria,13L
-
-#define SN_aria_256_ofb128              "ARIA-256-OFB"
-#define LN_aria_256_ofb128              "aria-256-ofb"
-#define NID_aria_256_ofb128             1078
-#define OBJ_aria_256_ofb128             OBJ_aria,14L
-
-#define SN_aria_256_ctr         "ARIA-256-CTR"
-#define LN_aria_256_ctr         "aria-256-ctr"
-#define NID_aria_256_ctr                1079
-#define OBJ_aria_256_ctr                OBJ_aria,15L
-
-#define SN_aria_128_cfb1                "ARIA-128-CFB1"
-#define LN_aria_128_cfb1                "aria-128-cfb1"
-#define NID_aria_128_cfb1               1080
-
-#define SN_aria_192_cfb1                "ARIA-192-CFB1"
-#define LN_aria_192_cfb1                "aria-192-cfb1"
-#define NID_aria_192_cfb1               1081
-
-#define SN_aria_256_cfb1                "ARIA-256-CFB1"
-#define LN_aria_256_cfb1                "aria-256-cfb1"
-#define NID_aria_256_cfb1               1082
-
-#define SN_aria_128_cfb8                "ARIA-128-CFB8"
-#define LN_aria_128_cfb8                "aria-128-cfb8"
-#define NID_aria_128_cfb8               1083
-
-#define SN_aria_192_cfb8                "ARIA-192-CFB8"
-#define LN_aria_192_cfb8                "aria-192-cfb8"
-#define NID_aria_192_cfb8               1084
-
-#define SN_aria_256_cfb8                "ARIA-256-CFB8"
-#define LN_aria_256_cfb8                "aria-256-cfb8"
-#define NID_aria_256_cfb8               1085
-
-#define SN_aria_128_ccm         "ARIA-128-CCM"
-#define LN_aria_128_ccm         "aria-128-ccm"
-#define NID_aria_128_ccm                1120
-#define OBJ_aria_128_ccm                OBJ_aria,37L
-
-#define SN_aria_192_ccm         "ARIA-192-CCM"
-#define LN_aria_192_ccm         "aria-192-ccm"
-#define NID_aria_192_ccm                1121
-#define OBJ_aria_192_ccm                OBJ_aria,38L
-
-#define SN_aria_256_ccm         "ARIA-256-CCM"
-#define LN_aria_256_ccm         "aria-256-ccm"
-#define NID_aria_256_ccm                1122
-#define OBJ_aria_256_ccm                OBJ_aria,39L
-
-#define SN_aria_128_gcm         "ARIA-128-GCM"
-#define LN_aria_128_gcm         "aria-128-gcm"
-#define NID_aria_128_gcm                1123
-#define OBJ_aria_128_gcm                OBJ_aria,34L
-
-#define SN_aria_192_gcm         "ARIA-192-GCM"
-#define LN_aria_192_gcm         "aria-192-gcm"
-#define NID_aria_192_gcm                1124
-#define OBJ_aria_192_gcm                OBJ_aria,35L
-
-#define SN_aria_256_gcm         "ARIA-256-GCM"
-#define LN_aria_256_gcm         "aria-256-gcm"
-#define NID_aria_256_gcm                1125
-#define OBJ_aria_256_gcm                OBJ_aria,36L
-
-#define SN_kisa         "KISA"
-#define LN_kisa         "kisa"
-#define NID_kisa                773
-#define OBJ_kisa                OBJ_member_body,410L,200004L
-
-#define SN_seed_ecb             "SEED-ECB"
-#define LN_seed_ecb             "seed-ecb"
-#define NID_seed_ecb            776
-#define OBJ_seed_ecb            OBJ_kisa,1L,3L
-
-#define SN_seed_cbc             "SEED-CBC"
-#define LN_seed_cbc             "seed-cbc"
-#define NID_seed_cbc            777
-#define OBJ_seed_cbc            OBJ_kisa,1L,4L
-
-#define SN_seed_cfb128          "SEED-CFB"
-#define LN_seed_cfb128          "seed-cfb"
-#define NID_seed_cfb128         779
-#define OBJ_seed_cfb128         OBJ_kisa,1L,5L
-
-#define SN_seed_ofb128          "SEED-OFB"
-#define LN_seed_ofb128          "seed-ofb"
-#define NID_seed_ofb128         778
-#define OBJ_seed_ofb128         OBJ_kisa,1L,6L
-
-#define SN_sm4_ecb              "SM4-ECB"
-#define LN_sm4_ecb              "sm4-ecb"
-#define NID_sm4_ecb             1133
-#define OBJ_sm4_ecb             OBJ_sm_scheme,104L,1L
-
-#define SN_sm4_cbc              "SM4-CBC"
-#define LN_sm4_cbc              "sm4-cbc"
-#define NID_sm4_cbc             1134
-#define OBJ_sm4_cbc             OBJ_sm_scheme,104L,2L
-
-#define SN_sm4_ofb128           "SM4-OFB"
-#define LN_sm4_ofb128           "sm4-ofb"
-#define NID_sm4_ofb128          1135
-#define OBJ_sm4_ofb128          OBJ_sm_scheme,104L,3L
-
-#define SN_sm4_cfb128           "SM4-CFB"
-#define LN_sm4_cfb128           "sm4-cfb"
-#define NID_sm4_cfb128          1137
-#define OBJ_sm4_cfb128          OBJ_sm_scheme,104L,4L
-
-#define SN_sm4_cfb1             "SM4-CFB1"
-#define LN_sm4_cfb1             "sm4-cfb1"
-#define NID_sm4_cfb1            1136
-#define OBJ_sm4_cfb1            OBJ_sm_scheme,104L,5L
-
-#define SN_sm4_cfb8             "SM4-CFB8"
-#define LN_sm4_cfb8             "sm4-cfb8"
-#define NID_sm4_cfb8            1138
-#define OBJ_sm4_cfb8            OBJ_sm_scheme,104L,6L
-
-#define SN_sm4_ctr              "SM4-CTR"
-#define LN_sm4_ctr              "sm4-ctr"
-#define NID_sm4_ctr             1139
-#define OBJ_sm4_ctr             OBJ_sm_scheme,104L,7L
-
-#define SN_hmac         "HMAC"
-#define LN_hmac         "hmac"
-#define NID_hmac                855
-
-#define SN_cmac         "CMAC"
-#define LN_cmac         "cmac"
-#define NID_cmac                894
-
-#define SN_rc4_hmac_md5         "RC4-HMAC-MD5"
-#define LN_rc4_hmac_md5         "rc4-hmac-md5"
-#define NID_rc4_hmac_md5                915
-
-#define SN_aes_128_cbc_hmac_sha1                "AES-128-CBC-HMAC-SHA1"
-#define LN_aes_128_cbc_hmac_sha1                "aes-128-cbc-hmac-sha1"
-#define NID_aes_128_cbc_hmac_sha1               916
-
-#define SN_aes_192_cbc_hmac_sha1                "AES-192-CBC-HMAC-SHA1"
-#define LN_aes_192_cbc_hmac_sha1                "aes-192-cbc-hmac-sha1"
-#define NID_aes_192_cbc_hmac_sha1               917
-
-#define SN_aes_256_cbc_hmac_sha1                "AES-256-CBC-HMAC-SHA1"
-#define LN_aes_256_cbc_hmac_sha1                "aes-256-cbc-hmac-sha1"
-#define NID_aes_256_cbc_hmac_sha1               918
-
-#define SN_aes_128_cbc_hmac_sha256              "AES-128-CBC-HMAC-SHA256"
-#define LN_aes_128_cbc_hmac_sha256              "aes-128-cbc-hmac-sha256"
-#define NID_aes_128_cbc_hmac_sha256             948
-
-#define SN_aes_192_cbc_hmac_sha256              "AES-192-CBC-HMAC-SHA256"
-#define LN_aes_192_cbc_hmac_sha256              "aes-192-cbc-hmac-sha256"
-#define NID_aes_192_cbc_hmac_sha256             949
-
-#define SN_aes_256_cbc_hmac_sha256              "AES-256-CBC-HMAC-SHA256"
-#define LN_aes_256_cbc_hmac_sha256              "aes-256-cbc-hmac-sha256"
-#define NID_aes_256_cbc_hmac_sha256             950
-
-#define SN_chacha20_poly1305            "ChaCha20-Poly1305"
-#define LN_chacha20_poly1305            "chacha20-poly1305"
-#define NID_chacha20_poly1305           1018
-
-#define SN_chacha20             "ChaCha20"
-#define LN_chacha20             "chacha20"
-#define NID_chacha20            1019
-
-#define SN_dhpublicnumber               "dhpublicnumber"
-#define LN_dhpublicnumber               "X9.42 DH"
-#define NID_dhpublicnumber              920
-#define OBJ_dhpublicnumber              OBJ_ISO_US,10046L,2L,1L
-
-#define SN_brainpoolP160r1              "brainpoolP160r1"
-#define NID_brainpoolP160r1             921
-#define OBJ_brainpoolP160r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,1L
-
-#define SN_brainpoolP160t1              "brainpoolP160t1"
-#define NID_brainpoolP160t1             922
-#define OBJ_brainpoolP160t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,2L
-
-#define SN_brainpoolP192r1              "brainpoolP192r1"
-#define NID_brainpoolP192r1             923
-#define OBJ_brainpoolP192r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,3L
-
-#define SN_brainpoolP192t1              "brainpoolP192t1"
-#define NID_brainpoolP192t1             924
-#define OBJ_brainpoolP192t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,4L
+#define SN_setct_CRLNotificationResTBS "setct-CRLNotificationResTBS"
+#define NID_setct_CRLNotificationResTBS 599
+#define OBJ_setct_CRLNotificationResTBS OBJ_set_ctype, 81L
+
+#define SN_setct_BCIDistributionTBS "setct-BCIDistributionTBS"
+#define NID_setct_BCIDistributionTBS 600
+#define OBJ_setct_BCIDistributionTBS OBJ_set_ctype, 82L
+
+#define SN_setext_genCrypt "setext-genCrypt"
+#define LN_setext_genCrypt "generic cryptogram"
+#define NID_setext_genCrypt 601
+#define OBJ_setext_genCrypt OBJ_set_msgExt, 1L
+
+#define SN_setext_miAuth "setext-miAuth"
+#define LN_setext_miAuth "merchant initiated auth"
+#define NID_setext_miAuth 602
+#define OBJ_setext_miAuth OBJ_set_msgExt, 3L
+
+#define SN_setext_pinSecure "setext-pinSecure"
+#define NID_setext_pinSecure 603
+#define OBJ_setext_pinSecure OBJ_set_msgExt, 4L
+
+#define SN_setext_pinAny "setext-pinAny"
+#define NID_setext_pinAny 604
+#define OBJ_setext_pinAny OBJ_set_msgExt, 5L
+
+#define SN_setext_track2 "setext-track2"
+#define NID_setext_track2 605
+#define OBJ_setext_track2 OBJ_set_msgExt, 7L
+
+#define SN_setext_cv "setext-cv"
+#define LN_setext_cv "additional verification"
+#define NID_setext_cv 606
+#define OBJ_setext_cv OBJ_set_msgExt, 8L
+
+#define SN_set_policy_root "set-policy-root"
+#define NID_set_policy_root 607
+#define OBJ_set_policy_root OBJ_set_policy, 0L
+
+#define SN_setCext_hashedRoot "setCext-hashedRoot"
+#define NID_setCext_hashedRoot 608
+#define OBJ_setCext_hashedRoot OBJ_set_certExt, 0L
+
+#define SN_setCext_certType "setCext-certType"
+#define NID_setCext_certType 609
+#define OBJ_setCext_certType OBJ_set_certExt, 1L
+
+#define SN_setCext_merchData "setCext-merchData"
+#define NID_setCext_merchData 610
+#define OBJ_setCext_merchData OBJ_set_certExt, 2L
+
+#define SN_setCext_cCertRequired "setCext-cCertRequired"
+#define NID_setCext_cCertRequired 611
+#define OBJ_setCext_cCertRequired OBJ_set_certExt, 3L
+
+#define SN_setCext_tunneling "setCext-tunneling"
+#define NID_setCext_tunneling 612
+#define OBJ_setCext_tunneling OBJ_set_certExt, 4L
+
+#define SN_setCext_setExt "setCext-setExt"
+#define NID_setCext_setExt 613
+#define OBJ_setCext_setExt OBJ_set_certExt, 5L
+
+#define SN_setCext_setQualf "setCext-setQualf"
+#define NID_setCext_setQualf 614
+#define OBJ_setCext_setQualf OBJ_set_certExt, 6L
+
+#define SN_setCext_PGWYcapabilities "setCext-PGWYcapabilities"
+#define NID_setCext_PGWYcapabilities 615
+#define OBJ_setCext_PGWYcapabilities OBJ_set_certExt, 7L
+
+#define SN_setCext_TokenIdentifier "setCext-TokenIdentifier"
+#define NID_setCext_TokenIdentifier 616
+#define OBJ_setCext_TokenIdentifier OBJ_set_certExt, 8L
+
+#define SN_setCext_Track2Data "setCext-Track2Data"
+#define NID_setCext_Track2Data 617
+#define OBJ_setCext_Track2Data OBJ_set_certExt, 9L
+
+#define SN_setCext_TokenType "setCext-TokenType"
+#define NID_setCext_TokenType 618
+#define OBJ_setCext_TokenType OBJ_set_certExt, 10L
+
+#define SN_setCext_IssuerCapabilities "setCext-IssuerCapabilities"
+#define NID_setCext_IssuerCapabilities 619
+#define OBJ_setCext_IssuerCapabilities OBJ_set_certExt, 11L
+
+#define SN_setAttr_Cert "setAttr-Cert"
+#define NID_setAttr_Cert 620
+#define OBJ_setAttr_Cert OBJ_set_attr, 0L
+
+#define SN_setAttr_PGWYcap "setAttr-PGWYcap"
+#define LN_setAttr_PGWYcap "payment gateway capabilities"
+#define NID_setAttr_PGWYcap 621
+#define OBJ_setAttr_PGWYcap OBJ_set_attr, 1L
+
+#define SN_setAttr_TokenType "setAttr-TokenType"
+#define NID_setAttr_TokenType 622
+#define OBJ_setAttr_TokenType OBJ_set_attr, 2L
+
+#define SN_setAttr_IssCap "setAttr-IssCap"
+#define LN_setAttr_IssCap "issuer capabilities"
+#define NID_setAttr_IssCap 623
+#define OBJ_setAttr_IssCap OBJ_set_attr, 3L
+
+#define SN_set_rootKeyThumb "set-rootKeyThumb"
+#define NID_set_rootKeyThumb 624
+#define OBJ_set_rootKeyThumb OBJ_setAttr_Cert, 0L
+
+#define SN_set_addPolicy "set-addPolicy"
+#define NID_set_addPolicy 625
+#define OBJ_set_addPolicy OBJ_setAttr_Cert, 1L
+
+#define SN_setAttr_Token_EMV "setAttr-Token-EMV"
+#define NID_setAttr_Token_EMV 626
+#define OBJ_setAttr_Token_EMV OBJ_setAttr_TokenType, 1L
+
+#define SN_setAttr_Token_B0Prime "setAttr-Token-B0Prime"
+#define NID_setAttr_Token_B0Prime 627
+#define OBJ_setAttr_Token_B0Prime OBJ_setAttr_TokenType, 2L
+
+#define SN_setAttr_IssCap_CVM "setAttr-IssCap-CVM"
+#define NID_setAttr_IssCap_CVM 628
+#define OBJ_setAttr_IssCap_CVM OBJ_setAttr_IssCap, 3L
+
+#define SN_setAttr_IssCap_T2 "setAttr-IssCap-T2"
+#define NID_setAttr_IssCap_T2 629
+#define OBJ_setAttr_IssCap_T2 OBJ_setAttr_IssCap, 4L
+
+#define SN_setAttr_IssCap_Sig "setAttr-IssCap-Sig"
+#define NID_setAttr_IssCap_Sig 630
+#define OBJ_setAttr_IssCap_Sig OBJ_setAttr_IssCap, 5L
+
+#define SN_setAttr_GenCryptgrm "setAttr-GenCryptgrm"
+#define LN_setAttr_GenCryptgrm "generate cryptogram"
+#define NID_setAttr_GenCryptgrm 631
+#define OBJ_setAttr_GenCryptgrm OBJ_setAttr_IssCap_CVM, 1L
+
+#define SN_setAttr_T2Enc "setAttr-T2Enc"
+#define LN_setAttr_T2Enc "encrypted track 2"
+#define NID_setAttr_T2Enc 632
+#define OBJ_setAttr_T2Enc OBJ_setAttr_IssCap_T2, 1L
+
+#define SN_setAttr_T2cleartxt "setAttr-T2cleartxt"
+#define LN_setAttr_T2cleartxt "cleartext track 2"
+#define NID_setAttr_T2cleartxt 633
+#define OBJ_setAttr_T2cleartxt OBJ_setAttr_IssCap_T2, 2L
+
+#define SN_setAttr_TokICCsig "setAttr-TokICCsig"
+#define LN_setAttr_TokICCsig "ICC or token signature"
+#define NID_setAttr_TokICCsig 634
+#define OBJ_setAttr_TokICCsig OBJ_setAttr_IssCap_Sig, 1L
+
+#define SN_setAttr_SecDevSig "setAttr-SecDevSig"
+#define LN_setAttr_SecDevSig "secure device signature"
+#define NID_setAttr_SecDevSig 635
+#define OBJ_setAttr_SecDevSig OBJ_setAttr_IssCap_Sig, 2L
+
+#define SN_set_brand_IATA_ATA "set-brand-IATA-ATA"
+#define NID_set_brand_IATA_ATA 636
+#define OBJ_set_brand_IATA_ATA OBJ_set_brand, 1L
+
+#define SN_set_brand_Diners "set-brand-Diners"
+#define NID_set_brand_Diners 637
+#define OBJ_set_brand_Diners OBJ_set_brand, 30L
+
+#define SN_set_brand_AmericanExpress "set-brand-AmericanExpress"
+#define NID_set_brand_AmericanExpress 638
+#define OBJ_set_brand_AmericanExpress OBJ_set_brand, 34L
+
+#define SN_set_brand_JCB "set-brand-JCB"
+#define NID_set_brand_JCB 639
+#define OBJ_set_brand_JCB OBJ_set_brand, 35L
+
+#define SN_set_brand_Visa "set-brand-Visa"
+#define NID_set_brand_Visa 640
+#define OBJ_set_brand_Visa OBJ_set_brand, 4L
+
+#define SN_set_brand_MasterCard "set-brand-MasterCard"
+#define NID_set_brand_MasterCard 641
+#define OBJ_set_brand_MasterCard OBJ_set_brand, 5L
+
+#define SN_set_brand_Novus "set-brand-Novus"
+#define NID_set_brand_Novus 642
+#define OBJ_set_brand_Novus OBJ_set_brand, 6011L
+
+#define SN_des_cdmf "DES-CDMF"
+#define LN_des_cdmf "des-cdmf"
+#define NID_des_cdmf 643
+#define OBJ_des_cdmf OBJ_rsadsi, 3L, 10L
+
+#define SN_rsaOAEPEncryptionSET "rsaOAEPEncryptionSET"
+#define NID_rsaOAEPEncryptionSET 644
+#define OBJ_rsaOAEPEncryptionSET OBJ_rsadsi, 1L, 1L, 6L
+
+#define SN_ipsec3 "Oakley-EC2N-3"
+#define LN_ipsec3 "ipsec3"
+#define NID_ipsec3 749
+
+#define SN_ipsec4 "Oakley-EC2N-4"
+#define LN_ipsec4 "ipsec4"
+#define NID_ipsec4 750
+
+#define SN_whirlpool "whirlpool"
+#define NID_whirlpool 804
+#define OBJ_whirlpool OBJ_iso, 0L, 10118L, 3L, 0L, 55L
+
+#define SN_cryptopro "cryptopro"
+#define NID_cryptopro 805
+#define OBJ_cryptopro OBJ_member_body, 643L, 2L, 2L
+
+#define SN_cryptocom "cryptocom"
+#define NID_cryptocom 806
+#define OBJ_cryptocom OBJ_member_body, 643L, 2L, 9L
+
+#define SN_id_tc26 "id-tc26"
+#define NID_id_tc26 974
+#define OBJ_id_tc26 OBJ_member_body, 643L, 7L, 1L
+
+#define SN_id_GostR3411_94_with_GostR3410_2001 "id-GostR3411-94-with-GostR3410-2001"
+#define LN_id_GostR3411_94_with_GostR3410_2001 "GOST R 34.11-94 with GOST R 34.10-2001"
+#define NID_id_GostR3411_94_with_GostR3410_2001 807
+#define OBJ_id_GostR3411_94_with_GostR3410_2001 OBJ_cryptopro, 3L
+
+#define SN_id_GostR3411_94_with_GostR3410_94 "id-GostR3411-94-with-GostR3410-94"
+#define LN_id_GostR3411_94_with_GostR3410_94 "GOST R 34.11-94 with GOST R 34.10-94"
+#define NID_id_GostR3411_94_with_GostR3410_94 808
+#define OBJ_id_GostR3411_94_with_GostR3410_94 OBJ_cryptopro, 4L
+
+#define SN_id_GostR3411_94 "md_gost94"
+#define LN_id_GostR3411_94 "GOST R 34.11-94"
+#define NID_id_GostR3411_94 809
+#define OBJ_id_GostR3411_94 OBJ_cryptopro, 9L
+
+#define SN_id_HMACGostR3411_94 "id-HMACGostR3411-94"
+#define LN_id_HMACGostR3411_94 "HMAC GOST 34.11-94"
+#define NID_id_HMACGostR3411_94 810
+#define OBJ_id_HMACGostR3411_94 OBJ_cryptopro, 10L
+
+#define SN_id_GostR3410_2001 "gost2001"
+#define LN_id_GostR3410_2001 "GOST R 34.10-2001"
+#define NID_id_GostR3410_2001 811
+#define OBJ_id_GostR3410_2001 OBJ_cryptopro, 19L
+
+#define SN_id_GostR3410_94 "gost94"
+#define LN_id_GostR3410_94 "GOST R 34.10-94"
+#define NID_id_GostR3410_94 812
+#define OBJ_id_GostR3410_94 OBJ_cryptopro, 20L
+
+#define SN_id_Gost28147_89 "gost89"
+#define LN_id_Gost28147_89 "GOST 28147-89"
+#define NID_id_Gost28147_89 813
+#define OBJ_id_Gost28147_89 OBJ_cryptopro, 21L
+
+#define SN_gost89_cnt "gost89-cnt"
+#define NID_gost89_cnt 814
+
+#define SN_gost89_cnt_12 "gost89-cnt-12"
+#define NID_gost89_cnt_12 975
+
+#define SN_gost89_cbc "gost89-cbc"
+#define NID_gost89_cbc 1009
+
+#define SN_gost89_ecb "gost89-ecb"
+#define NID_gost89_ecb 1010
+
+#define SN_gost89_ctr "gost89-ctr"
+#define NID_gost89_ctr 1011
+
+#define SN_id_Gost28147_89_MAC "gost-mac"
+#define LN_id_Gost28147_89_MAC "GOST 28147-89 MAC"
+#define NID_id_Gost28147_89_MAC 815
+#define OBJ_id_Gost28147_89_MAC OBJ_cryptopro, 22L
+
+#define SN_gost_mac_12 "gost-mac-12"
+#define NID_gost_mac_12 976
+
+#define SN_id_GostR3411_94_prf "prf-gostr3411-94"
+#define LN_id_GostR3411_94_prf "GOST R 34.11-94 PRF"
+#define NID_id_GostR3411_94_prf 816
+#define OBJ_id_GostR3411_94_prf OBJ_cryptopro, 23L
+
+#define SN_id_GostR3410_2001DH "id-GostR3410-2001DH"
+#define LN_id_GostR3410_2001DH "GOST R 34.10-2001 DH"
+#define NID_id_GostR3410_2001DH 817
+#define OBJ_id_GostR3410_2001DH OBJ_cryptopro, 98L
+
+#define SN_id_GostR3410_94DH "id-GostR3410-94DH"
+#define LN_id_GostR3410_94DH "GOST R 34.10-94 DH"
+#define NID_id_GostR3410_94DH 818
+#define OBJ_id_GostR3410_94DH OBJ_cryptopro, 99L
+
+#define SN_id_Gost28147_89_CryptoPro_KeyMeshing "id-Gost28147-89-CryptoPro-KeyMeshing"
+#define NID_id_Gost28147_89_CryptoPro_KeyMeshing 819
+#define OBJ_id_Gost28147_89_CryptoPro_KeyMeshing OBJ_cryptopro, 14L, 1L
+
+#define SN_id_Gost28147_89_None_KeyMeshing "id-Gost28147-89-None-KeyMeshing"
+#define NID_id_Gost28147_89_None_KeyMeshing 820
+#define OBJ_id_Gost28147_89_None_KeyMeshing OBJ_cryptopro, 14L, 0L
+
+#define SN_id_GostR3411_94_TestParamSet "id-GostR3411-94-TestParamSet"
+#define NID_id_GostR3411_94_TestParamSet 821
+#define OBJ_id_GostR3411_94_TestParamSet OBJ_cryptopro, 30L, 0L
+
+#define SN_id_GostR3411_94_CryptoProParamSet "id-GostR3411-94-CryptoProParamSet"
+#define NID_id_GostR3411_94_CryptoProParamSet 822
+#define OBJ_id_GostR3411_94_CryptoProParamSet OBJ_cryptopro, 30L, 1L
+
+#define SN_id_Gost28147_89_TestParamSet "id-Gost28147-89-TestParamSet"
+#define NID_id_Gost28147_89_TestParamSet 823
+#define OBJ_id_Gost28147_89_TestParamSet OBJ_cryptopro, 31L, 0L
+
+#define SN_id_Gost28147_89_CryptoPro_A_ParamSet "id-Gost28147-89-CryptoPro-A-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_A_ParamSet 824
+#define OBJ_id_Gost28147_89_CryptoPro_A_ParamSet OBJ_cryptopro, 31L, 1L
+
+#define SN_id_Gost28147_89_CryptoPro_B_ParamSet "id-Gost28147-89-CryptoPro-B-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_B_ParamSet 825
+#define OBJ_id_Gost28147_89_CryptoPro_B_ParamSet OBJ_cryptopro, 31L, 2L
+
+#define SN_id_Gost28147_89_CryptoPro_C_ParamSet "id-Gost28147-89-CryptoPro-C-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_C_ParamSet 826
+#define OBJ_id_Gost28147_89_CryptoPro_C_ParamSet OBJ_cryptopro, 31L, 3L
+
+#define SN_id_Gost28147_89_CryptoPro_D_ParamSet "id-Gost28147-89-CryptoPro-D-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_D_ParamSet 827
+#define OBJ_id_Gost28147_89_CryptoPro_D_ParamSet OBJ_cryptopro, 31L, 4L
+
+#define SN_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet "id-Gost28147-89-CryptoPro-Oscar-1-1-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet 828
+#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet OBJ_cryptopro, 31L, 5L
+
+#define SN_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet "id-Gost28147-89-CryptoPro-Oscar-1-0-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet 829
+#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet OBJ_cryptopro, 31L, 6L
+
+#define SN_id_Gost28147_89_CryptoPro_RIC_1_ParamSet "id-Gost28147-89-CryptoPro-RIC-1-ParamSet"
+#define NID_id_Gost28147_89_CryptoPro_RIC_1_ParamSet 830
+#define OBJ_id_Gost28147_89_CryptoPro_RIC_1_ParamSet OBJ_cryptopro, 31L, 7L
+
+#define SN_id_GostR3410_94_TestParamSet "id-GostR3410-94-TestParamSet"
+#define NID_id_GostR3410_94_TestParamSet 831
+#define OBJ_id_GostR3410_94_TestParamSet OBJ_cryptopro, 32L, 0L
+
+#define SN_id_GostR3410_94_CryptoPro_A_ParamSet "id-GostR3410-94-CryptoPro-A-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_A_ParamSet 832
+#define OBJ_id_GostR3410_94_CryptoPro_A_ParamSet OBJ_cryptopro, 32L, 2L
+
+#define SN_id_GostR3410_94_CryptoPro_B_ParamSet "id-GostR3410-94-CryptoPro-B-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_B_ParamSet 833
+#define OBJ_id_GostR3410_94_CryptoPro_B_ParamSet OBJ_cryptopro, 32L, 3L
+
+#define SN_id_GostR3410_94_CryptoPro_C_ParamSet "id-GostR3410-94-CryptoPro-C-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_C_ParamSet 834
+#define OBJ_id_GostR3410_94_CryptoPro_C_ParamSet OBJ_cryptopro, 32L, 4L
+
+#define SN_id_GostR3410_94_CryptoPro_D_ParamSet "id-GostR3410-94-CryptoPro-D-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_D_ParamSet 835
+#define OBJ_id_GostR3410_94_CryptoPro_D_ParamSet OBJ_cryptopro, 32L, 5L
+
+#define SN_id_GostR3410_94_CryptoPro_XchA_ParamSet "id-GostR3410-94-CryptoPro-XchA-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchA_ParamSet 836
+#define OBJ_id_GostR3410_94_CryptoPro_XchA_ParamSet OBJ_cryptopro, 33L, 1L
+
+#define SN_id_GostR3410_94_CryptoPro_XchB_ParamSet "id-GostR3410-94-CryptoPro-XchB-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchB_ParamSet 837
+#define OBJ_id_GostR3410_94_CryptoPro_XchB_ParamSet OBJ_cryptopro, 33L, 2L
+
+#define SN_id_GostR3410_94_CryptoPro_XchC_ParamSet "id-GostR3410-94-CryptoPro-XchC-ParamSet"
+#define NID_id_GostR3410_94_CryptoPro_XchC_ParamSet 838
+#define OBJ_id_GostR3410_94_CryptoPro_XchC_ParamSet OBJ_cryptopro, 33L, 3L
+
+#define SN_id_GostR3410_2001_TestParamSet "id-GostR3410-2001-TestParamSet"
+#define NID_id_GostR3410_2001_TestParamSet 839
+#define OBJ_id_GostR3410_2001_TestParamSet OBJ_cryptopro, 35L, 0L
+
+#define SN_id_GostR3410_2001_CryptoPro_A_ParamSet "id-GostR3410-2001-CryptoPro-A-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_A_ParamSet 840
+#define OBJ_id_GostR3410_2001_CryptoPro_A_ParamSet OBJ_cryptopro, 35L, 1L
+
+#define SN_id_GostR3410_2001_CryptoPro_B_ParamSet "id-GostR3410-2001-CryptoPro-B-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_B_ParamSet 841
+#define OBJ_id_GostR3410_2001_CryptoPro_B_ParamSet OBJ_cryptopro, 35L, 2L
+
+#define SN_id_GostR3410_2001_CryptoPro_C_ParamSet "id-GostR3410-2001-CryptoPro-C-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_C_ParamSet 842
+#define OBJ_id_GostR3410_2001_CryptoPro_C_ParamSet OBJ_cryptopro, 35L, 3L
+
+#define SN_id_GostR3410_2001_CryptoPro_XchA_ParamSet "id-GostR3410-2001-CryptoPro-XchA-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet 843
+#define OBJ_id_GostR3410_2001_CryptoPro_XchA_ParamSet OBJ_cryptopro, 36L, 0L
+
+#define SN_id_GostR3410_2001_CryptoPro_XchB_ParamSet "id-GostR3410-2001-CryptoPro-XchB-ParamSet"
+#define NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet 844
+#define OBJ_id_GostR3410_2001_CryptoPro_XchB_ParamSet OBJ_cryptopro, 36L, 1L
+
+#define SN_id_GostR3410_94_a "id-GostR3410-94-a"
+#define NID_id_GostR3410_94_a 845
+#define OBJ_id_GostR3410_94_a OBJ_id_GostR3410_94, 1L
+
+#define SN_id_GostR3410_94_aBis "id-GostR3410-94-aBis"
+#define NID_id_GostR3410_94_aBis 846
+#define OBJ_id_GostR3410_94_aBis OBJ_id_GostR3410_94, 2L
+
+#define SN_id_GostR3410_94_b "id-GostR3410-94-b"
+#define NID_id_GostR3410_94_b 847
+#define OBJ_id_GostR3410_94_b OBJ_id_GostR3410_94, 3L
+
+#define SN_id_GostR3410_94_bBis "id-GostR3410-94-bBis"
+#define NID_id_GostR3410_94_bBis 848
+#define OBJ_id_GostR3410_94_bBis OBJ_id_GostR3410_94, 4L
+
+#define SN_id_Gost28147_89_cc "id-Gost28147-89-cc"
+#define LN_id_Gost28147_89_cc "GOST 28147-89 Cryptocom ParamSet"
+#define NID_id_Gost28147_89_cc 849
+#define OBJ_id_Gost28147_89_cc OBJ_cryptocom, 1L, 6L, 1L
+
+#define SN_id_GostR3410_94_cc "gost94cc"
+#define LN_id_GostR3410_94_cc "GOST 34.10-94 Cryptocom"
+#define NID_id_GostR3410_94_cc 850
+#define OBJ_id_GostR3410_94_cc OBJ_cryptocom, 1L, 5L, 3L
+
+#define SN_id_GostR3410_2001_cc "gost2001cc"
+#define LN_id_GostR3410_2001_cc "GOST 34.10-2001 Cryptocom"
+#define NID_id_GostR3410_2001_cc 851
+#define OBJ_id_GostR3410_2001_cc OBJ_cryptocom, 1L, 5L, 4L
+
+#define SN_id_GostR3411_94_with_GostR3410_94_cc "id-GostR3411-94-with-GostR3410-94-cc"
+#define LN_id_GostR3411_94_with_GostR3410_94_cc "GOST R 34.11-94 with GOST R 34.10-94 Cryptocom"
+#define NID_id_GostR3411_94_with_GostR3410_94_cc 852
+#define OBJ_id_GostR3411_94_with_GostR3410_94_cc OBJ_cryptocom, 1L, 3L, 3L
+
+#define SN_id_GostR3411_94_with_GostR3410_2001_cc "id-GostR3411-94-with-GostR3410-2001-cc"
+#define LN_id_GostR3411_94_with_GostR3410_2001_cc "GOST R 34.11-94 with GOST R 34.10-2001 Cryptocom"
+#define NID_id_GostR3411_94_with_GostR3410_2001_cc 853
+#define OBJ_id_GostR3411_94_with_GostR3410_2001_cc OBJ_cryptocom, 1L, 3L, 4L
+
+#define SN_id_GostR3410_2001_ParamSet_cc "id-GostR3410-2001-ParamSet-cc"
+#define LN_id_GostR3410_2001_ParamSet_cc "GOST R 3410-2001 Parameter Set Cryptocom"
+#define NID_id_GostR3410_2001_ParamSet_cc 854
+#define OBJ_id_GostR3410_2001_ParamSet_cc OBJ_cryptocom, 1L, 8L, 1L
+
+#define SN_id_tc26_algorithms "id-tc26-algorithms"
+#define NID_id_tc26_algorithms 977
+#define OBJ_id_tc26_algorithms OBJ_id_tc26, 1L
+
+#define SN_id_tc26_sign "id-tc26-sign"
+#define NID_id_tc26_sign 978
+#define OBJ_id_tc26_sign OBJ_id_tc26_algorithms, 1L
+
+#define SN_id_GostR3410_2012_256 "gost2012_256"
+#define LN_id_GostR3410_2012_256 "GOST R 34.10-2012 with 256 bit modulus"
+#define NID_id_GostR3410_2012_256 979
+#define OBJ_id_GostR3410_2012_256 OBJ_id_tc26_sign, 1L
+
+#define SN_id_GostR3410_2012_512 "gost2012_512"
+#define LN_id_GostR3410_2012_512 "GOST R 34.10-2012 with 512 bit modulus"
+#define NID_id_GostR3410_2012_512 980
+#define OBJ_id_GostR3410_2012_512 OBJ_id_tc26_sign, 2L
+
+#define SN_id_tc26_digest "id-tc26-digest"
+#define NID_id_tc26_digest 981
+#define OBJ_id_tc26_digest OBJ_id_tc26_algorithms, 2L
+
+#define SN_id_GostR3411_2012_256 "md_gost12_256"
+#define LN_id_GostR3411_2012_256 "GOST R 34.11-2012 with 256 bit hash"
+#define NID_id_GostR3411_2012_256 982
+#define OBJ_id_GostR3411_2012_256 OBJ_id_tc26_digest, 2L
+
+#define SN_id_GostR3411_2012_512 "md_gost12_512"
+#define LN_id_GostR3411_2012_512 "GOST R 34.11-2012 with 512 bit hash"
+#define NID_id_GostR3411_2012_512 983
+#define OBJ_id_GostR3411_2012_512 OBJ_id_tc26_digest, 3L
+
+#define SN_id_tc26_signwithdigest "id-tc26-signwithdigest"
+#define NID_id_tc26_signwithdigest 984
+#define OBJ_id_tc26_signwithdigest OBJ_id_tc26_algorithms, 3L
+
+#define SN_id_tc26_signwithdigest_gost3410_2012_256 "id-tc26-signwithdigest-gost3410-2012-256"
+#define LN_id_tc26_signwithdigest_gost3410_2012_256 "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)"
+#define NID_id_tc26_signwithdigest_gost3410_2012_256 985
+#define OBJ_id_tc26_signwithdigest_gost3410_2012_256 OBJ_id_tc26_signwithdigest, 2L
+
+#define SN_id_tc26_signwithdigest_gost3410_2012_512 "id-tc26-signwithdigest-gost3410-2012-512"
+#define LN_id_tc26_signwithdigest_gost3410_2012_512 "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)"
+#define NID_id_tc26_signwithdigest_gost3410_2012_512 986
+#define OBJ_id_tc26_signwithdigest_gost3410_2012_512 OBJ_id_tc26_signwithdigest, 3L
+
+#define SN_id_tc26_mac "id-tc26-mac"
+#define NID_id_tc26_mac 987
+#define OBJ_id_tc26_mac OBJ_id_tc26_algorithms, 4L
+
+#define SN_id_tc26_hmac_gost_3411_2012_256 "id-tc26-hmac-gost-3411-2012-256"
+#define LN_id_tc26_hmac_gost_3411_2012_256 "HMAC GOST 34.11-2012 256 bit"
+#define NID_id_tc26_hmac_gost_3411_2012_256 988
+#define OBJ_id_tc26_hmac_gost_3411_2012_256 OBJ_id_tc26_mac, 1L
+
+#define SN_id_tc26_hmac_gost_3411_2012_512 "id-tc26-hmac-gost-3411-2012-512"
+#define LN_id_tc26_hmac_gost_3411_2012_512 "HMAC GOST 34.11-2012 512 bit"
+#define NID_id_tc26_hmac_gost_3411_2012_512 989
+#define OBJ_id_tc26_hmac_gost_3411_2012_512 OBJ_id_tc26_mac, 2L
+
+#define SN_id_tc26_cipher "id-tc26-cipher"
+#define NID_id_tc26_cipher 990
+#define OBJ_id_tc26_cipher OBJ_id_tc26_algorithms, 5L
+
+#define SN_id_tc26_cipher_gostr3412_2015_magma "id-tc26-cipher-gostr3412-2015-magma"
+#define NID_id_tc26_cipher_gostr3412_2015_magma 1173
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma OBJ_id_tc26_cipher, 1L
+
+#define SN_magma_ctr_acpkm "magma-ctr-acpkm"
+#define NID_magma_ctr_acpkm 1174
+#define OBJ_magma_ctr_acpkm OBJ_id_tc26_cipher_gostr3412_2015_magma, 1L
+
+#define SN_magma_ctr_acpkm_omac "magma-ctr-acpkm-omac"
+#define NID_magma_ctr_acpkm_omac 1175
+#define OBJ_magma_ctr_acpkm_omac OBJ_id_tc26_cipher_gostr3412_2015_magma, 2L
+
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik "id-tc26-cipher-gostr3412-2015-kuznyechik"
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik 1176
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik OBJ_id_tc26_cipher, 2L
+
+#define SN_kuznyechik_ctr_acpkm "kuznyechik-ctr-acpkm"
+#define NID_kuznyechik_ctr_acpkm 1177
+#define OBJ_kuznyechik_ctr_acpkm OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik, 1L
+
+#define SN_kuznyechik_ctr_acpkm_omac "kuznyechik-ctr-acpkm-omac"
+#define NID_kuznyechik_ctr_acpkm_omac 1178
+#define OBJ_kuznyechik_ctr_acpkm_omac OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik, 2L
+
+#define SN_id_tc26_agreement "id-tc26-agreement"
+#define NID_id_tc26_agreement 991
+#define OBJ_id_tc26_agreement OBJ_id_tc26_algorithms, 6L
+
+#define SN_id_tc26_agreement_gost_3410_2012_256 "id-tc26-agreement-gost-3410-2012-256"
+#define NID_id_tc26_agreement_gost_3410_2012_256 992
+#define OBJ_id_tc26_agreement_gost_3410_2012_256 OBJ_id_tc26_agreement, 1L
+
+#define SN_id_tc26_agreement_gost_3410_2012_512 "id-tc26-agreement-gost-3410-2012-512"
+#define NID_id_tc26_agreement_gost_3410_2012_512 993
+#define OBJ_id_tc26_agreement_gost_3410_2012_512 OBJ_id_tc26_agreement, 2L
+
+#define SN_id_tc26_wrap "id-tc26-wrap"
+#define NID_id_tc26_wrap 1179
+#define OBJ_id_tc26_wrap OBJ_id_tc26_algorithms, 7L
+
+#define SN_id_tc26_wrap_gostr3412_2015_magma "id-tc26-wrap-gostr3412-2015-magma"
+#define NID_id_tc26_wrap_gostr3412_2015_magma 1180
+#define OBJ_id_tc26_wrap_gostr3412_2015_magma OBJ_id_tc26_wrap, 1L
+
+#define SN_magma_kexp15 "magma-kexp15"
+#define NID_magma_kexp15 1181
+#define OBJ_magma_kexp15 OBJ_id_tc26_wrap_gostr3412_2015_magma, 1L
+
+#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik "id-tc26-wrap-gostr3412-2015-kuznyechik"
+#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik 1182
+#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik OBJ_id_tc26_wrap, 2L
+
+#define SN_kuznyechik_kexp15 "kuznyechik-kexp15"
+#define NID_kuznyechik_kexp15 1183
+#define OBJ_kuznyechik_kexp15 OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik, 1L
+
+#define SN_id_tc26_constants "id-tc26-constants"
+#define NID_id_tc26_constants 994
+#define OBJ_id_tc26_constants OBJ_id_tc26, 2L
+
+#define SN_id_tc26_sign_constants "id-tc26-sign-constants"
+#define NID_id_tc26_sign_constants 995
+#define OBJ_id_tc26_sign_constants OBJ_id_tc26_constants, 1L
+
+#define SN_id_tc26_gost_3410_2012_256_constants "id-tc26-gost-3410-2012-256-constants"
+#define NID_id_tc26_gost_3410_2012_256_constants 1147
+#define OBJ_id_tc26_gost_3410_2012_256_constants OBJ_id_tc26_sign_constants, 1L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetA "id-tc26-gost-3410-2012-256-paramSetA"
+#define LN_id_tc26_gost_3410_2012_256_paramSetA "GOST R 34.10-2012 (256 bit) ParamSet A"
+#define NID_id_tc26_gost_3410_2012_256_paramSetA 1148
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetA OBJ_id_tc26_gost_3410_2012_256_constants, 1L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetB "id-tc26-gost-3410-2012-256-paramSetB"
+#define LN_id_tc26_gost_3410_2012_256_paramSetB "GOST R 34.10-2012 (256 bit) ParamSet B"
+#define NID_id_tc26_gost_3410_2012_256_paramSetB 1184
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetB OBJ_id_tc26_gost_3410_2012_256_constants, 2L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetC "id-tc26-gost-3410-2012-256-paramSetC"
+#define LN_id_tc26_gost_3410_2012_256_paramSetC "GOST R 34.10-2012 (256 bit) ParamSet C"
+#define NID_id_tc26_gost_3410_2012_256_paramSetC 1185
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetC OBJ_id_tc26_gost_3410_2012_256_constants, 3L
+
+#define SN_id_tc26_gost_3410_2012_256_paramSetD "id-tc26-gost-3410-2012-256-paramSetD"
+#define LN_id_tc26_gost_3410_2012_256_paramSetD "GOST R 34.10-2012 (256 bit) ParamSet D"
+#define NID_id_tc26_gost_3410_2012_256_paramSetD 1186
+#define OBJ_id_tc26_gost_3410_2012_256_paramSetD OBJ_id_tc26_gost_3410_2012_256_constants, 4L
+
+#define SN_id_tc26_gost_3410_2012_512_constants "id-tc26-gost-3410-2012-512-constants"
+#define NID_id_tc26_gost_3410_2012_512_constants 996
+#define OBJ_id_tc26_gost_3410_2012_512_constants OBJ_id_tc26_sign_constants, 2L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetTest "id-tc26-gost-3410-2012-512-paramSetTest"
+#define LN_id_tc26_gost_3410_2012_512_paramSetTest "GOST R 34.10-2012 (512 bit) testing parameter set"
+#define NID_id_tc26_gost_3410_2012_512_paramSetTest 997
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetTest OBJ_id_tc26_gost_3410_2012_512_constants, 0L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetA "id-tc26-gost-3410-2012-512-paramSetA"
+#define LN_id_tc26_gost_3410_2012_512_paramSetA "GOST R 34.10-2012 (512 bit) ParamSet A"
+#define NID_id_tc26_gost_3410_2012_512_paramSetA 998
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetA OBJ_id_tc26_gost_3410_2012_512_constants, 1L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetB "id-tc26-gost-3410-2012-512-paramSetB"
+#define LN_id_tc26_gost_3410_2012_512_paramSetB "GOST R 34.10-2012 (512 bit) ParamSet B"
+#define NID_id_tc26_gost_3410_2012_512_paramSetB 999
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetB OBJ_id_tc26_gost_3410_2012_512_constants, 2L
+
+#define SN_id_tc26_gost_3410_2012_512_paramSetC "id-tc26-gost-3410-2012-512-paramSetC"
+#define LN_id_tc26_gost_3410_2012_512_paramSetC "GOST R 34.10-2012 (512 bit) ParamSet C"
+#define NID_id_tc26_gost_3410_2012_512_paramSetC 1149
+#define OBJ_id_tc26_gost_3410_2012_512_paramSetC OBJ_id_tc26_gost_3410_2012_512_constants, 3L
+
+#define SN_id_tc26_digest_constants "id-tc26-digest-constants"
+#define NID_id_tc26_digest_constants 1000
+#define OBJ_id_tc26_digest_constants OBJ_id_tc26_constants, 2L
+
+#define SN_id_tc26_cipher_constants "id-tc26-cipher-constants"
+#define NID_id_tc26_cipher_constants 1001
+#define OBJ_id_tc26_cipher_constants OBJ_id_tc26_constants, 5L
+
+#define SN_id_tc26_gost_28147_constants "id-tc26-gost-28147-constants"
+#define NID_id_tc26_gost_28147_constants 1002
+#define OBJ_id_tc26_gost_28147_constants OBJ_id_tc26_cipher_constants, 1L
+
+#define SN_id_tc26_gost_28147_param_Z "id-tc26-gost-28147-param-Z"
+#define LN_id_tc26_gost_28147_param_Z "GOST 28147-89 TC26 parameter set"
+#define NID_id_tc26_gost_28147_param_Z 1003
+#define OBJ_id_tc26_gost_28147_param_Z OBJ_id_tc26_gost_28147_constants, 1L
+
+#define SN_INN "INN"
+#define LN_INN "INN"
+#define NID_INN 1004
+#define OBJ_INN OBJ_member_body, 643L, 3L, 131L, 1L, 1L
+
+#define SN_OGRN "OGRN"
+#define LN_OGRN "OGRN"
+#define NID_OGRN 1005
+#define OBJ_OGRN OBJ_member_body, 643L, 100L, 1L
+
+#define SN_SNILS "SNILS"
+#define LN_SNILS "SNILS"
+#define NID_SNILS 1006
+#define OBJ_SNILS OBJ_member_body, 643L, 100L, 3L
+
+#define SN_OGRNIP "OGRNIP"
+#define LN_OGRNIP "OGRNIP"
+#define NID_OGRNIP 1226
+#define OBJ_OGRNIP OBJ_member_body, 643L, 100L, 5L
+
+#define SN_subjectSignTool "subjectSignTool"
+#define LN_subjectSignTool "Signing Tool of Subject"
+#define NID_subjectSignTool 1007
+#define OBJ_subjectSignTool OBJ_member_body, 643L, 100L, 111L
+
+#define SN_issuerSignTool "issuerSignTool"
+#define LN_issuerSignTool "Signing Tool of Issuer"
+#define NID_issuerSignTool 1008
+#define OBJ_issuerSignTool OBJ_member_body, 643L, 100L, 112L
+
+#define SN_classSignTool "classSignTool"
+#define LN_classSignTool "Class of Signing Tool"
+#define NID_classSignTool 1227
+#define OBJ_classSignTool OBJ_member_body, 643L, 100L, 113L
+
+#define SN_classSignToolKC1 "classSignToolKC1"
+#define LN_classSignToolKC1 "Class of Signing Tool KC1"
+#define NID_classSignToolKC1 1228
+#define OBJ_classSignToolKC1 OBJ_member_body, 643L, 100L, 113L, 1L
+
+#define SN_classSignToolKC2 "classSignToolKC2"
+#define LN_classSignToolKC2 "Class of Signing Tool KC2"
+#define NID_classSignToolKC2 1229
+#define OBJ_classSignToolKC2 OBJ_member_body, 643L, 100L, 113L, 2L
+
+#define SN_classSignToolKC3 "classSignToolKC3"
+#define LN_classSignToolKC3 "Class of Signing Tool KC3"
+#define NID_classSignToolKC3 1230
+#define OBJ_classSignToolKC3 OBJ_member_body, 643L, 100L, 113L, 3L
+
+#define SN_classSignToolKB1 "classSignToolKB1"
+#define LN_classSignToolKB1 "Class of Signing Tool KB1"
+#define NID_classSignToolKB1 1231
+#define OBJ_classSignToolKB1 OBJ_member_body, 643L, 100L, 113L, 4L
+
+#define SN_classSignToolKB2 "classSignToolKB2"
+#define LN_classSignToolKB2 "Class of Signing Tool KB2"
+#define NID_classSignToolKB2 1232
+#define OBJ_classSignToolKB2 OBJ_member_body, 643L, 100L, 113L, 5L
+
+#define SN_classSignToolKA1 "classSignToolKA1"
+#define LN_classSignToolKA1 "Class of Signing Tool KA1"
+#define NID_classSignToolKA1 1233
+#define OBJ_classSignToolKA1 OBJ_member_body, 643L, 100L, 113L, 6L
+
+#define SN_kuznyechik_ecb "kuznyechik-ecb"
+#define NID_kuznyechik_ecb 1012
+
+#define SN_kuznyechik_ctr "kuznyechik-ctr"
+#define NID_kuznyechik_ctr 1013
+
+#define SN_kuznyechik_ofb "kuznyechik-ofb"
+#define NID_kuznyechik_ofb 1014
+
+#define SN_kuznyechik_cbc "kuznyechik-cbc"
+#define NID_kuznyechik_cbc 1015
+
+#define SN_kuznyechik_cfb "kuznyechik-cfb"
+#define NID_kuznyechik_cfb 1016
+
+#define SN_kuznyechik_mac "kuznyechik-mac"
+#define NID_kuznyechik_mac 1017
+
+#define SN_magma_ecb "magma-ecb"
+#define NID_magma_ecb 1187
+
+#define SN_magma_ctr "magma-ctr"
+#define NID_magma_ctr 1188
+
+#define SN_magma_ofb "magma-ofb"
+#define NID_magma_ofb 1189
+
+#define SN_magma_cbc "magma-cbc"
+#define NID_magma_cbc 1190
+
+#define SN_magma_cfb "magma-cfb"
+#define NID_magma_cfb 1191
+
+#define SN_magma_mac "magma-mac"
+#define NID_magma_mac 1192
+
+#define SN_camellia_128_cbc "CAMELLIA-128-CBC"
+#define LN_camellia_128_cbc "camellia-128-cbc"
+#define NID_camellia_128_cbc 751
+#define OBJ_camellia_128_cbc 1L, 2L, 392L, 200011L, 61L, 1L, 1L, 1L, 2L
+
+#define SN_camellia_192_cbc "CAMELLIA-192-CBC"
+#define LN_camellia_192_cbc "camellia-192-cbc"
+#define NID_camellia_192_cbc 752
+#define OBJ_camellia_192_cbc 1L, 2L, 392L, 200011L, 61L, 1L, 1L, 1L, 3L
+
+#define SN_camellia_256_cbc "CAMELLIA-256-CBC"
+#define LN_camellia_256_cbc "camellia-256-cbc"
+#define NID_camellia_256_cbc 753
+#define OBJ_camellia_256_cbc 1L, 2L, 392L, 200011L, 61L, 1L, 1L, 1L, 4L
+
+#define SN_id_camellia128_wrap "id-camellia128-wrap"
+#define NID_id_camellia128_wrap 907
+#define OBJ_id_camellia128_wrap 1L, 2L, 392L, 200011L, 61L, 1L, 1L, 3L, 2L
+
+#define SN_id_camellia192_wrap "id-camellia192-wrap"
+#define NID_id_camellia192_wrap 908
+#define OBJ_id_camellia192_wrap 1L, 2L, 392L, 200011L, 61L, 1L, 1L, 3L, 3L
+
+#define SN_id_camellia256_wrap "id-camellia256-wrap"
+#define NID_id_camellia256_wrap 909
+#define OBJ_id_camellia256_wrap 1L, 2L, 392L, 200011L, 61L, 1L, 1L, 3L, 4L
+
+#define OBJ_ntt_ds 0L, 3L, 4401L, 5L
+
+#define OBJ_camellia OBJ_ntt_ds, 3L, 1L, 9L
+
+#define SN_camellia_128_ecb "CAMELLIA-128-ECB"
+#define LN_camellia_128_ecb "camellia-128-ecb"
+#define NID_camellia_128_ecb 754
+#define OBJ_camellia_128_ecb OBJ_camellia, 1L
+
+#define SN_camellia_128_ofb128 "CAMELLIA-128-OFB"
+#define LN_camellia_128_ofb128 "camellia-128-ofb"
+#define NID_camellia_128_ofb128 766
+#define OBJ_camellia_128_ofb128 OBJ_camellia, 3L
+
+#define SN_camellia_128_cfb128 "CAMELLIA-128-CFB"
+#define LN_camellia_128_cfb128 "camellia-128-cfb"
+#define NID_camellia_128_cfb128 757
+#define OBJ_camellia_128_cfb128 OBJ_camellia, 4L
+
+#define SN_camellia_128_gcm "CAMELLIA-128-GCM"
+#define LN_camellia_128_gcm "camellia-128-gcm"
+#define NID_camellia_128_gcm 961
+#define OBJ_camellia_128_gcm OBJ_camellia, 6L
+
+#define SN_camellia_128_ccm "CAMELLIA-128-CCM"
+#define LN_camellia_128_ccm "camellia-128-ccm"
+#define NID_camellia_128_ccm 962
+#define OBJ_camellia_128_ccm OBJ_camellia, 7L
+
+#define SN_camellia_128_ctr "CAMELLIA-128-CTR"
+#define LN_camellia_128_ctr "camellia-128-ctr"
+#define NID_camellia_128_ctr 963
+#define OBJ_camellia_128_ctr OBJ_camellia, 9L
+
+#define SN_camellia_128_cmac "CAMELLIA-128-CMAC"
+#define LN_camellia_128_cmac "camellia-128-cmac"
+#define NID_camellia_128_cmac 964
+#define OBJ_camellia_128_cmac OBJ_camellia, 10L
+
+#define SN_camellia_192_ecb "CAMELLIA-192-ECB"
+#define LN_camellia_192_ecb "camellia-192-ecb"
+#define NID_camellia_192_ecb 755
+#define OBJ_camellia_192_ecb OBJ_camellia, 21L
+
+#define SN_camellia_192_ofb128 "CAMELLIA-192-OFB"
+#define LN_camellia_192_ofb128 "camellia-192-ofb"
+#define NID_camellia_192_ofb128 767
+#define OBJ_camellia_192_ofb128 OBJ_camellia, 23L
+
+#define SN_camellia_192_cfb128 "CAMELLIA-192-CFB"
+#define LN_camellia_192_cfb128 "camellia-192-cfb"
+#define NID_camellia_192_cfb128 758
+#define OBJ_camellia_192_cfb128 OBJ_camellia, 24L
+
+#define SN_camellia_192_gcm "CAMELLIA-192-GCM"
+#define LN_camellia_192_gcm "camellia-192-gcm"
+#define NID_camellia_192_gcm 965
+#define OBJ_camellia_192_gcm OBJ_camellia, 26L
+
+#define SN_camellia_192_ccm "CAMELLIA-192-CCM"
+#define LN_camellia_192_ccm "camellia-192-ccm"
+#define NID_camellia_192_ccm 966
+#define OBJ_camellia_192_ccm OBJ_camellia, 27L
+
+#define SN_camellia_192_ctr "CAMELLIA-192-CTR"
+#define LN_camellia_192_ctr "camellia-192-ctr"
+#define NID_camellia_192_ctr 967
+#define OBJ_camellia_192_ctr OBJ_camellia, 29L
+
+#define SN_camellia_192_cmac "CAMELLIA-192-CMAC"
+#define LN_camellia_192_cmac "camellia-192-cmac"
+#define NID_camellia_192_cmac 968
+#define OBJ_camellia_192_cmac OBJ_camellia, 30L
+
+#define SN_camellia_256_ecb "CAMELLIA-256-ECB"
+#define LN_camellia_256_ecb "camellia-256-ecb"
+#define NID_camellia_256_ecb 756
+#define OBJ_camellia_256_ecb OBJ_camellia, 41L
+
+#define SN_camellia_256_ofb128 "CAMELLIA-256-OFB"
+#define LN_camellia_256_ofb128 "camellia-256-ofb"
+#define NID_camellia_256_ofb128 768
+#define OBJ_camellia_256_ofb128 OBJ_camellia, 43L
+
+#define SN_camellia_256_cfb128 "CAMELLIA-256-CFB"
+#define LN_camellia_256_cfb128 "camellia-256-cfb"
+#define NID_camellia_256_cfb128 759
+#define OBJ_camellia_256_cfb128 OBJ_camellia, 44L
+
+#define SN_camellia_256_gcm "CAMELLIA-256-GCM"
+#define LN_camellia_256_gcm "camellia-256-gcm"
+#define NID_camellia_256_gcm 969
+#define OBJ_camellia_256_gcm OBJ_camellia, 46L
+
+#define SN_camellia_256_ccm "CAMELLIA-256-CCM"
+#define LN_camellia_256_ccm "camellia-256-ccm"
+#define NID_camellia_256_ccm 970
+#define OBJ_camellia_256_ccm OBJ_camellia, 47L
+
+#define SN_camellia_256_ctr "CAMELLIA-256-CTR"
+#define LN_camellia_256_ctr "camellia-256-ctr"
+#define NID_camellia_256_ctr 971
+#define OBJ_camellia_256_ctr OBJ_camellia, 49L
+
+#define SN_camellia_256_cmac "CAMELLIA-256-CMAC"
+#define LN_camellia_256_cmac "camellia-256-cmac"
+#define NID_camellia_256_cmac 972
+#define OBJ_camellia_256_cmac OBJ_camellia, 50L
+
+#define SN_camellia_128_cfb1 "CAMELLIA-128-CFB1"
+#define LN_camellia_128_cfb1 "camellia-128-cfb1"
+#define NID_camellia_128_cfb1 760
+
+#define SN_camellia_192_cfb1 "CAMELLIA-192-CFB1"
+#define LN_camellia_192_cfb1 "camellia-192-cfb1"
+#define NID_camellia_192_cfb1 761
+
+#define SN_camellia_256_cfb1 "CAMELLIA-256-CFB1"
+#define LN_camellia_256_cfb1 "camellia-256-cfb1"
+#define NID_camellia_256_cfb1 762
+
+#define SN_camellia_128_cfb8 "CAMELLIA-128-CFB8"
+#define LN_camellia_128_cfb8 "camellia-128-cfb8"
+#define NID_camellia_128_cfb8 763
+
+#define SN_camellia_192_cfb8 "CAMELLIA-192-CFB8"
+#define LN_camellia_192_cfb8 "camellia-192-cfb8"
+#define NID_camellia_192_cfb8 764
+
+#define SN_camellia_256_cfb8 "CAMELLIA-256-CFB8"
+#define LN_camellia_256_cfb8 "camellia-256-cfb8"
+#define NID_camellia_256_cfb8 765
+
+#define OBJ_aria 1L, 2L, 410L, 200046L, 1L, 1L
+
+#define SN_aria_128_ecb "ARIA-128-ECB"
+#define LN_aria_128_ecb "aria-128-ecb"
+#define NID_aria_128_ecb 1065
+#define OBJ_aria_128_ecb OBJ_aria, 1L
+
+#define SN_aria_128_cbc "ARIA-128-CBC"
+#define LN_aria_128_cbc "aria-128-cbc"
+#define NID_aria_128_cbc 1066
+#define OBJ_aria_128_cbc OBJ_aria, 2L
+
+#define SN_aria_128_cfb128 "ARIA-128-CFB"
+#define LN_aria_128_cfb128 "aria-128-cfb"
+#define NID_aria_128_cfb128 1067
+#define OBJ_aria_128_cfb128 OBJ_aria, 3L
+
+#define SN_aria_128_ofb128 "ARIA-128-OFB"
+#define LN_aria_128_ofb128 "aria-128-ofb"
+#define NID_aria_128_ofb128 1068
+#define OBJ_aria_128_ofb128 OBJ_aria, 4L
+
+#define SN_aria_128_ctr "ARIA-128-CTR"
+#define LN_aria_128_ctr "aria-128-ctr"
+#define NID_aria_128_ctr 1069
+#define OBJ_aria_128_ctr OBJ_aria, 5L
+
+#define SN_aria_192_ecb "ARIA-192-ECB"
+#define LN_aria_192_ecb "aria-192-ecb"
+#define NID_aria_192_ecb 1070
+#define OBJ_aria_192_ecb OBJ_aria, 6L
+
+#define SN_aria_192_cbc "ARIA-192-CBC"
+#define LN_aria_192_cbc "aria-192-cbc"
+#define NID_aria_192_cbc 1071
+#define OBJ_aria_192_cbc OBJ_aria, 7L
+
+#define SN_aria_192_cfb128 "ARIA-192-CFB"
+#define LN_aria_192_cfb128 "aria-192-cfb"
+#define NID_aria_192_cfb128 1072
+#define OBJ_aria_192_cfb128 OBJ_aria, 8L
+
+#define SN_aria_192_ofb128 "ARIA-192-OFB"
+#define LN_aria_192_ofb128 "aria-192-ofb"
+#define NID_aria_192_ofb128 1073
+#define OBJ_aria_192_ofb128 OBJ_aria, 9L
+
+#define SN_aria_192_ctr "ARIA-192-CTR"
+#define LN_aria_192_ctr "aria-192-ctr"
+#define NID_aria_192_ctr 1074
+#define OBJ_aria_192_ctr OBJ_aria, 10L
+
+#define SN_aria_256_ecb "ARIA-256-ECB"
+#define LN_aria_256_ecb "aria-256-ecb"
+#define NID_aria_256_ecb 1075
+#define OBJ_aria_256_ecb OBJ_aria, 11L
+
+#define SN_aria_256_cbc "ARIA-256-CBC"
+#define LN_aria_256_cbc "aria-256-cbc"
+#define NID_aria_256_cbc 1076
+#define OBJ_aria_256_cbc OBJ_aria, 12L
+
+#define SN_aria_256_cfb128 "ARIA-256-CFB"
+#define LN_aria_256_cfb128 "aria-256-cfb"
+#define NID_aria_256_cfb128 1077
+#define OBJ_aria_256_cfb128 OBJ_aria, 13L
+
+#define SN_aria_256_ofb128 "ARIA-256-OFB"
+#define LN_aria_256_ofb128 "aria-256-ofb"
+#define NID_aria_256_ofb128 1078
+#define OBJ_aria_256_ofb128 OBJ_aria, 14L
+
+#define SN_aria_256_ctr "ARIA-256-CTR"
+#define LN_aria_256_ctr "aria-256-ctr"
+#define NID_aria_256_ctr 1079
+#define OBJ_aria_256_ctr OBJ_aria, 15L
+
+#define SN_aria_128_cfb1 "ARIA-128-CFB1"
+#define LN_aria_128_cfb1 "aria-128-cfb1"
+#define NID_aria_128_cfb1 1080
+
+#define SN_aria_192_cfb1 "ARIA-192-CFB1"
+#define LN_aria_192_cfb1 "aria-192-cfb1"
+#define NID_aria_192_cfb1 1081
+
+#define SN_aria_256_cfb1 "ARIA-256-CFB1"
+#define LN_aria_256_cfb1 "aria-256-cfb1"
+#define NID_aria_256_cfb1 1082
+
+#define SN_aria_128_cfb8 "ARIA-128-CFB8"
+#define LN_aria_128_cfb8 "aria-128-cfb8"
+#define NID_aria_128_cfb8 1083
+
+#define SN_aria_192_cfb8 "ARIA-192-CFB8"
+#define LN_aria_192_cfb8 "aria-192-cfb8"
+#define NID_aria_192_cfb8 1084
+
+#define SN_aria_256_cfb8 "ARIA-256-CFB8"
+#define LN_aria_256_cfb8 "aria-256-cfb8"
+#define NID_aria_256_cfb8 1085
+
+#define SN_aria_128_ccm "ARIA-128-CCM"
+#define LN_aria_128_ccm "aria-128-ccm"
+#define NID_aria_128_ccm 1120
+#define OBJ_aria_128_ccm OBJ_aria, 37L
+
+#define SN_aria_192_ccm "ARIA-192-CCM"
+#define LN_aria_192_ccm "aria-192-ccm"
+#define NID_aria_192_ccm 1121
+#define OBJ_aria_192_ccm OBJ_aria, 38L
+
+#define SN_aria_256_ccm "ARIA-256-CCM"
+#define LN_aria_256_ccm "aria-256-ccm"
+#define NID_aria_256_ccm 1122
+#define OBJ_aria_256_ccm OBJ_aria, 39L
+
+#define SN_aria_128_gcm "ARIA-128-GCM"
+#define LN_aria_128_gcm "aria-128-gcm"
+#define NID_aria_128_gcm 1123
+#define OBJ_aria_128_gcm OBJ_aria, 34L
+
+#define SN_aria_192_gcm "ARIA-192-GCM"
+#define LN_aria_192_gcm "aria-192-gcm"
+#define NID_aria_192_gcm 1124
+#define OBJ_aria_192_gcm OBJ_aria, 35L
+
+#define SN_aria_256_gcm "ARIA-256-GCM"
+#define LN_aria_256_gcm "aria-256-gcm"
+#define NID_aria_256_gcm 1125
+#define OBJ_aria_256_gcm OBJ_aria, 36L
+
+#define SN_kisa "KISA"
+#define LN_kisa "kisa"
+#define NID_kisa 773
+#define OBJ_kisa OBJ_member_body, 410L, 200004L
+
+#define SN_seed_ecb "SEED-ECB"
+#define LN_seed_ecb "seed-ecb"
+#define NID_seed_ecb 776
+#define OBJ_seed_ecb OBJ_kisa, 1L, 3L
+
+#define SN_seed_cbc "SEED-CBC"
+#define LN_seed_cbc "seed-cbc"
+#define NID_seed_cbc 777
+#define OBJ_seed_cbc OBJ_kisa, 1L, 4L
+
+#define SN_seed_cfb128 "SEED-CFB"
+#define LN_seed_cfb128 "seed-cfb"
+#define NID_seed_cfb128 779
+#define OBJ_seed_cfb128 OBJ_kisa, 1L, 5L
+
+#define SN_seed_ofb128 "SEED-OFB"
+#define LN_seed_ofb128 "seed-ofb"
+#define NID_seed_ofb128 778
+#define OBJ_seed_ofb128 OBJ_kisa, 1L, 6L
+
+#define SN_sm4_ecb "SM4-ECB"
+#define LN_sm4_ecb "sm4-ecb"
+#define NID_sm4_ecb 1133
+#define OBJ_sm4_ecb OBJ_sm_scheme, 104L, 1L
+
+#define SN_sm4_cbc "SM4-CBC"
+#define LN_sm4_cbc "sm4-cbc"
+#define NID_sm4_cbc 1134
+#define OBJ_sm4_cbc OBJ_sm_scheme, 104L, 2L
+
+#define SN_sm4_ofb128 "SM4-OFB"
+#define LN_sm4_ofb128 "sm4-ofb"
+#define NID_sm4_ofb128 1135
+#define OBJ_sm4_ofb128 OBJ_sm_scheme, 104L, 3L
+
+#define SN_sm4_cfb128 "SM4-CFB"
+#define LN_sm4_cfb128 "sm4-cfb"
+#define NID_sm4_cfb128 1137
+#define OBJ_sm4_cfb128 OBJ_sm_scheme, 104L, 4L
+
+#define SN_sm4_cfb1 "SM4-CFB1"
+#define LN_sm4_cfb1 "sm4-cfb1"
+#define NID_sm4_cfb1 1136
+#define OBJ_sm4_cfb1 OBJ_sm_scheme, 104L, 5L
+
+#define SN_sm4_cfb8 "SM4-CFB8"
+#define LN_sm4_cfb8 "sm4-cfb8"
+#define NID_sm4_cfb8 1138
+#define OBJ_sm4_cfb8 OBJ_sm_scheme, 104L, 6L
+
+#define SN_sm4_ctr "SM4-CTR"
+#define LN_sm4_ctr "sm4-ctr"
+#define NID_sm4_ctr 1139
+#define OBJ_sm4_ctr OBJ_sm_scheme, 104L, 7L
+
+#define SN_hmac "HMAC"
+#define LN_hmac "hmac"
+#define NID_hmac 855
+
+#define SN_cmac "CMAC"
+#define LN_cmac "cmac"
+#define NID_cmac 894
+
+#define SN_rc4_hmac_md5 "RC4-HMAC-MD5"
+#define LN_rc4_hmac_md5 "rc4-hmac-md5"
+#define NID_rc4_hmac_md5 915
+
+#define SN_aes_128_cbc_hmac_sha1 "AES-128-CBC-HMAC-SHA1"
+#define LN_aes_128_cbc_hmac_sha1 "aes-128-cbc-hmac-sha1"
+#define NID_aes_128_cbc_hmac_sha1 916
+
+#define SN_aes_192_cbc_hmac_sha1 "AES-192-CBC-HMAC-SHA1"
+#define LN_aes_192_cbc_hmac_sha1 "aes-192-cbc-hmac-sha1"
+#define NID_aes_192_cbc_hmac_sha1 917
+
+#define SN_aes_256_cbc_hmac_sha1 "AES-256-CBC-HMAC-SHA1"
+#define LN_aes_256_cbc_hmac_sha1 "aes-256-cbc-hmac-sha1"
+#define NID_aes_256_cbc_hmac_sha1 918
+
+#define SN_aes_128_cbc_hmac_sha256 "AES-128-CBC-HMAC-SHA256"
+#define LN_aes_128_cbc_hmac_sha256 "aes-128-cbc-hmac-sha256"
+#define NID_aes_128_cbc_hmac_sha256 948
+
+#define SN_aes_192_cbc_hmac_sha256 "AES-192-CBC-HMAC-SHA256"
+#define LN_aes_192_cbc_hmac_sha256 "aes-192-cbc-hmac-sha256"
+#define NID_aes_192_cbc_hmac_sha256 949
+
+#define SN_aes_256_cbc_hmac_sha256 "AES-256-CBC-HMAC-SHA256"
+#define LN_aes_256_cbc_hmac_sha256 "aes-256-cbc-hmac-sha256"
+#define NID_aes_256_cbc_hmac_sha256 950
+
+#define SN_chacha20_poly1305 "ChaCha20-Poly1305"
+#define LN_chacha20_poly1305 "chacha20-poly1305"
+#define NID_chacha20_poly1305 1018
+
+#define SN_chacha20 "ChaCha20"
+#define LN_chacha20 "chacha20"
+#define NID_chacha20 1019
+
+#define SN_dhpublicnumber "dhpublicnumber"
+#define LN_dhpublicnumber "X9.42 DH"
+#define NID_dhpublicnumber 920
+#define OBJ_dhpublicnumber OBJ_ISO_US, 10046L, 2L, 1L
+
+#define SN_brainpoolP160r1 "brainpoolP160r1"
+#define NID_brainpoolP160r1 921
+#define OBJ_brainpoolP160r1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 1L
+
+#define SN_brainpoolP160t1 "brainpoolP160t1"
+#define NID_brainpoolP160t1 922
+#define OBJ_brainpoolP160t1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 2L
+
+#define SN_brainpoolP192r1 "brainpoolP192r1"
+#define NID_brainpoolP192r1 923
+#define OBJ_brainpoolP192r1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 3L
+
+#define SN_brainpoolP192t1 "brainpoolP192t1"
+#define NID_brainpoolP192t1 924
+#define OBJ_brainpoolP192t1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 4L
 
-#define SN_brainpoolP224r1              "brainpoolP224r1"
-#define NID_brainpoolP224r1             925
-#define OBJ_brainpoolP224r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,5L
-
-#define SN_brainpoolP224t1              "brainpoolP224t1"
-#define NID_brainpoolP224t1             926
-#define OBJ_brainpoolP224t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,6L
-
-#define SN_brainpoolP256r1              "brainpoolP256r1"
-#define NID_brainpoolP256r1             927
-#define OBJ_brainpoolP256r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,7L
-
-#define SN_brainpoolP256t1              "brainpoolP256t1"
-#define NID_brainpoolP256t1             928
-#define OBJ_brainpoolP256t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,8L
-
-#define SN_brainpoolP320r1              "brainpoolP320r1"
-#define NID_brainpoolP320r1             929
-#define OBJ_brainpoolP320r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,9L
+#define SN_brainpoolP224r1 "brainpoolP224r1"
+#define NID_brainpoolP224r1 925
+#define OBJ_brainpoolP224r1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 5L
+
+#define SN_brainpoolP224t1 "brainpoolP224t1"
+#define NID_brainpoolP224t1 926
+#define OBJ_brainpoolP224t1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 6L
+
+#define SN_brainpoolP256r1 "brainpoolP256r1"
+#define NID_brainpoolP256r1 927
+#define OBJ_brainpoolP256r1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 7L
+
+#define SN_brainpoolP256t1 "brainpoolP256t1"
+#define NID_brainpoolP256t1 928
+#define OBJ_brainpoolP256t1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 8L
+
+#define SN_brainpoolP320r1 "brainpoolP320r1"
+#define NID_brainpoolP320r1 929
+#define OBJ_brainpoolP320r1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 9L
 
-#define SN_brainpoolP320t1              "brainpoolP320t1"
-#define NID_brainpoolP320t1             930
-#define OBJ_brainpoolP320t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,10L
-
-#define SN_brainpoolP384r1              "brainpoolP384r1"
-#define NID_brainpoolP384r1             931
-#define OBJ_brainpoolP384r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,11L
-
-#define SN_brainpoolP384t1              "brainpoolP384t1"
-#define NID_brainpoolP384t1             932
-#define OBJ_brainpoolP384t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,12L
-
-#define SN_brainpoolP512r1              "brainpoolP512r1"
-#define NID_brainpoolP512r1             933
-#define OBJ_brainpoolP512r1             1L,3L,36L,3L,3L,2L,8L,1L,1L,13L
-
-#define SN_brainpoolP512t1              "brainpoolP512t1"
-#define NID_brainpoolP512t1             934
-#define OBJ_brainpoolP512t1             1L,3L,36L,3L,3L,2L,8L,1L,1L,14L
-
-#define OBJ_x9_63_scheme                1L,3L,133L,16L,840L,63L,0L
+#define SN_brainpoolP320t1 "brainpoolP320t1"
+#define NID_brainpoolP320t1 930
+#define OBJ_brainpoolP320t1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 10L
+
+#define SN_brainpoolP384r1 "brainpoolP384r1"
+#define NID_brainpoolP384r1 931
+#define OBJ_brainpoolP384r1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 11L
+
+#define SN_brainpoolP384t1 "brainpoolP384t1"
+#define NID_brainpoolP384t1 932
+#define OBJ_brainpoolP384t1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 12L
+
+#define SN_brainpoolP512r1 "brainpoolP512r1"
+#define NID_brainpoolP512r1 933
+#define OBJ_brainpoolP512r1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 13L
+
+#define SN_brainpoolP512t1 "brainpoolP512t1"
+#define NID_brainpoolP512t1 934
+#define OBJ_brainpoolP512t1 1L, 3L, 36L, 3L, 3L, 2L, 8L, 1L, 1L, 14L
+
+#define OBJ_x9_63_scheme 1L, 3L, 133L, 16L, 840L, 63L, 0L
 
-#define OBJ_secg_scheme         OBJ_certicom_arc,1L
-
-#define SN_dhSinglePass_stdDH_sha1kdf_scheme            "dhSinglePass-stdDH-sha1kdf-scheme"
-#define NID_dhSinglePass_stdDH_sha1kdf_scheme           936
-#define OBJ_dhSinglePass_stdDH_sha1kdf_scheme           OBJ_x9_63_scheme,2L
-
-#define SN_dhSinglePass_stdDH_sha224kdf_scheme          "dhSinglePass-stdDH-sha224kdf-scheme"
-#define NID_dhSinglePass_stdDH_sha224kdf_scheme         937
-#define OBJ_dhSinglePass_stdDH_sha224kdf_scheme         OBJ_secg_scheme,11L,0L
-
-#define SN_dhSinglePass_stdDH_sha256kdf_scheme          "dhSinglePass-stdDH-sha256kdf-scheme"
-#define NID_dhSinglePass_stdDH_sha256kdf_scheme         938
-#define OBJ_dhSinglePass_stdDH_sha256kdf_scheme         OBJ_secg_scheme,11L,1L
-
-#define SN_dhSinglePass_stdDH_sha384kdf_scheme          "dhSinglePass-stdDH-sha384kdf-scheme"
-#define NID_dhSinglePass_stdDH_sha384kdf_scheme         939
-#define OBJ_dhSinglePass_stdDH_sha384kdf_scheme         OBJ_secg_scheme,11L,2L
-
-#define SN_dhSinglePass_stdDH_sha512kdf_scheme          "dhSinglePass-stdDH-sha512kdf-scheme"
-#define NID_dhSinglePass_stdDH_sha512kdf_scheme         940
-#define OBJ_dhSinglePass_stdDH_sha512kdf_scheme         OBJ_secg_scheme,11L,3L
-
-#define SN_dhSinglePass_cofactorDH_sha1kdf_scheme               "dhSinglePass-cofactorDH-sha1kdf-scheme"
-#define NID_dhSinglePass_cofactorDH_sha1kdf_scheme              941
-#define OBJ_dhSinglePass_cofactorDH_sha1kdf_scheme              OBJ_x9_63_scheme,3L
-
-#define SN_dhSinglePass_cofactorDH_sha224kdf_scheme             "dhSinglePass-cofactorDH-sha224kdf-scheme"
-#define NID_dhSinglePass_cofactorDH_sha224kdf_scheme            942
-#define OBJ_dhSinglePass_cofactorDH_sha224kdf_scheme            OBJ_secg_scheme,14L,0L
-
-#define SN_dhSinglePass_cofactorDH_sha256kdf_scheme             "dhSinglePass-cofactorDH-sha256kdf-scheme"
-#define NID_dhSinglePass_cofactorDH_sha256kdf_scheme            943
-#define OBJ_dhSinglePass_cofactorDH_sha256kdf_scheme            OBJ_secg_scheme,14L,1L
-
-#define SN_dhSinglePass_cofactorDH_sha384kdf_scheme             "dhSinglePass-cofactorDH-sha384kdf-scheme"
-#define NID_dhSinglePass_cofactorDH_sha384kdf_scheme            944
-#define OBJ_dhSinglePass_cofactorDH_sha384kdf_scheme            OBJ_secg_scheme,14L,2L
-
-#define SN_dhSinglePass_cofactorDH_sha512kdf_scheme             "dhSinglePass-cofactorDH-sha512kdf-scheme"
-#define NID_dhSinglePass_cofactorDH_sha512kdf_scheme            945
-#define OBJ_dhSinglePass_cofactorDH_sha512kdf_scheme            OBJ_secg_scheme,14L,3L
+#define OBJ_secg_scheme OBJ_certicom_arc, 1L
+
+#define SN_dhSinglePass_stdDH_sha1kdf_scheme "dhSinglePass-stdDH-sha1kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha1kdf_scheme 936
+#define OBJ_dhSinglePass_stdDH_sha1kdf_scheme OBJ_x9_63_scheme, 2L
+
+#define SN_dhSinglePass_stdDH_sha224kdf_scheme "dhSinglePass-stdDH-sha224kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha224kdf_scheme 937
+#define OBJ_dhSinglePass_stdDH_sha224kdf_scheme OBJ_secg_scheme, 11L, 0L
+
+#define SN_dhSinglePass_stdDH_sha256kdf_scheme "dhSinglePass-stdDH-sha256kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha256kdf_scheme 938
+#define OBJ_dhSinglePass_stdDH_sha256kdf_scheme OBJ_secg_scheme, 11L, 1L
+
+#define SN_dhSinglePass_stdDH_sha384kdf_scheme "dhSinglePass-stdDH-sha384kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha384kdf_scheme 939
+#define OBJ_dhSinglePass_stdDH_sha384kdf_scheme OBJ_secg_scheme, 11L, 2L
+
+#define SN_dhSinglePass_stdDH_sha512kdf_scheme "dhSinglePass-stdDH-sha512kdf-scheme"
+#define NID_dhSinglePass_stdDH_sha512kdf_scheme 940
+#define OBJ_dhSinglePass_stdDH_sha512kdf_scheme OBJ_secg_scheme, 11L, 3L
+
+#define SN_dhSinglePass_cofactorDH_sha1kdf_scheme "dhSinglePass-cofactorDH-sha1kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha1kdf_scheme 941
+#define OBJ_dhSinglePass_cofactorDH_sha1kdf_scheme OBJ_x9_63_scheme, 3L
+
+#define SN_dhSinglePass_cofactorDH_sha224kdf_scheme "dhSinglePass-cofactorDH-sha224kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha224kdf_scheme 942
+#define OBJ_dhSinglePass_cofactorDH_sha224kdf_scheme OBJ_secg_scheme, 14L, 0L
+
+#define SN_dhSinglePass_cofactorDH_sha256kdf_scheme "dhSinglePass-cofactorDH-sha256kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha256kdf_scheme 943
+#define OBJ_dhSinglePass_cofactorDH_sha256kdf_scheme OBJ_secg_scheme, 14L, 1L
+
+#define SN_dhSinglePass_cofactorDH_sha384kdf_scheme "dhSinglePass-cofactorDH-sha384kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha384kdf_scheme 944
+#define OBJ_dhSinglePass_cofactorDH_sha384kdf_scheme OBJ_secg_scheme, 14L, 2L
+
+#define SN_dhSinglePass_cofactorDH_sha512kdf_scheme "dhSinglePass-cofactorDH-sha512kdf-scheme"
+#define NID_dhSinglePass_cofactorDH_sha512kdf_scheme 945
+#define OBJ_dhSinglePass_cofactorDH_sha512kdf_scheme OBJ_secg_scheme, 14L, 3L
 
-#define SN_dh_std_kdf           "dh-std-kdf"
-#define NID_dh_std_kdf          946
-
-#define SN_dh_cofactor_kdf              "dh-cofactor-kdf"
-#define NID_dh_cofactor_kdf             947
-
-#define SN_ct_precert_scts              "ct_precert_scts"
-#define LN_ct_precert_scts              "CT Precertificate SCTs"
-#define NID_ct_precert_scts             951
-#define OBJ_ct_precert_scts             1L,3L,6L,1L,4L,1L,11129L,2L,4L,2L
-
-#define SN_ct_precert_poison            "ct_precert_poison"
-#define LN_ct_precert_poison            "CT Precertificate Poison"
-#define NID_ct_precert_poison           952
-#define OBJ_ct_precert_poison           1L,3L,6L,1L,4L,1L,11129L,2L,4L,3L
+#define SN_dh_std_kdf "dh-std-kdf"
+#define NID_dh_std_kdf 946
+
+#define SN_dh_cofactor_kdf "dh-cofactor-kdf"
+#define NID_dh_cofactor_kdf 947
+
+#define SN_ct_precert_scts "ct_precert_scts"
+#define LN_ct_precert_scts "CT Precertificate SCTs"
+#define NID_ct_precert_scts 951
+#define OBJ_ct_precert_scts 1L, 3L, 6L, 1L, 4L, 1L, 11129L, 2L, 4L, 2L
+
+#define SN_ct_precert_poison "ct_precert_poison"
+#define LN_ct_precert_poison "CT Precertificate Poison"
+#define NID_ct_precert_poison 952
+#define OBJ_ct_precert_poison 1L, 3L, 6L, 1L, 4L, 1L, 11129L, 2L, 4L, 3L
 
-#define SN_ct_precert_signer            "ct_precert_signer"
-#define LN_ct_precert_signer            "CT Precertificate Signer"
-#define NID_ct_precert_signer           953
-#define OBJ_ct_precert_signer           1L,3L,6L,1L,4L,1L,11129L,2L,4L,4L
-
-#define SN_ct_cert_scts         "ct_cert_scts"
-#define LN_ct_cert_scts         "CT Certificate SCTs"
-#define NID_ct_cert_scts                954
-#define OBJ_ct_cert_scts                1L,3L,6L,1L,4L,1L,11129L,2L,4L,5L
-
-#define SN_jurisdictionLocalityName             "jurisdictionL"
-#define LN_jurisdictionLocalityName             "jurisdictionLocalityName"
-#define NID_jurisdictionLocalityName            955
-#define OBJ_jurisdictionLocalityName            1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,1L
-
-#define SN_jurisdictionStateOrProvinceName              "jurisdictionST"
-#define LN_jurisdictionStateOrProvinceName              "jurisdictionStateOrProvinceName"
-#define NID_jurisdictionStateOrProvinceName             956
-#define OBJ_jurisdictionStateOrProvinceName             1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,2L
+#define SN_ct_precert_signer "ct_precert_signer"
+#define LN_ct_precert_signer "CT Precertificate Signer"
+#define NID_ct_precert_signer 953
+#define OBJ_ct_precert_signer 1L, 3L, 6L, 1L, 4L, 1L, 11129L, 2L, 4L, 4L
+
+#define SN_ct_cert_scts "ct_cert_scts"
+#define LN_ct_cert_scts "CT Certificate SCTs"
+#define NID_ct_cert_scts 954
+#define OBJ_ct_cert_scts 1L, 3L, 6L, 1L, 4L, 1L, 11129L, 2L, 4L, 5L
+
+#define SN_jurisdictionLocalityName "jurisdictionL"
+#define LN_jurisdictionLocalityName "jurisdictionLocalityName"
+#define NID_jurisdictionLocalityName 955
+#define OBJ_jurisdictionLocalityName 1L, 3L, 6L, 1L, 4L, 1L, 311L, 60L, 2L, 1L, 1L
+
+#define SN_jurisdictionStateOrProvinceName "jurisdictionST"
+#define LN_jurisdictionStateOrProvinceName "jurisdictionStateOrProvinceName"
+#define NID_jurisdictionStateOrProvinceName 956
+#define OBJ_jurisdictionStateOrProvinceName 1L, 3L, 6L, 1L, 4L, 1L, 311L, 60L, 2L, 1L, 2L
 
-#define SN_jurisdictionCountryName              "jurisdictionC"
-#define LN_jurisdictionCountryName              "jurisdictionCountryName"
-#define NID_jurisdictionCountryName             957
-#define OBJ_jurisdictionCountryName             1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,3L
-
-#define SN_id_scrypt            "id-scrypt"
-#define LN_id_scrypt            "scrypt"
-#define NID_id_scrypt           973
-#define OBJ_id_scrypt           1L,3L,6L,1L,4L,1L,11591L,4L,11L
-
-#define SN_tls1_prf             "TLS1-PRF"
-#define LN_tls1_prf             "tls1-prf"
-#define NID_tls1_prf            1021
-
-#define SN_hkdf         "HKDF"
-#define LN_hkdf         "hkdf"
-#define NID_hkdf                1036
-
-#define SN_sshkdf               "SSHKDF"
-#define LN_sshkdf               "sshkdf"
-#define NID_sshkdf              1203
-
-#define SN_sskdf                "SSKDF"
-#define LN_sskdf                "sskdf"
-#define NID_sskdf               1205
-
-#define SN_x942kdf              "X942KDF"
-#define LN_x942kdf              "x942kdf"
-#define NID_x942kdf             1207
-
-#define SN_x963kdf              "X963KDF"
-#define LN_x963kdf              "x963kdf"
-#define NID_x963kdf             1206
-
-#define SN_id_pkinit            "id-pkinit"
-#define NID_id_pkinit           1031
-#define OBJ_id_pkinit           1L,3L,6L,1L,5L,2L,3L
-
-#define SN_pkInitClientAuth             "pkInitClientAuth"
-#define LN_pkInitClientAuth             "PKINIT Client Auth"
-#define NID_pkInitClientAuth            1032
-#define OBJ_pkInitClientAuth            OBJ_id_pkinit,4L
-
-#define SN_pkInitKDC            "pkInitKDC"
-#define LN_pkInitKDC            "Signing KDC Response"
-#define NID_pkInitKDC           1033
-#define OBJ_pkInitKDC           OBJ_id_pkinit,5L
-
-#define SN_X25519               "X25519"
-#define NID_X25519              1034
-#define OBJ_X25519              1L,3L,101L,110L
-
-#define SN_X448         "X448"
-#define NID_X448                1035
-#define OBJ_X448                1L,3L,101L,111L
-
-#define SN_ED25519              "ED25519"
-#define NID_ED25519             1087
-#define OBJ_ED25519             1L,3L,101L,112L
-
-#define SN_ED448                "ED448"
-#define NID_ED448               1088
-#define OBJ_ED448               1L,3L,101L,113L
+#define SN_jurisdictionCountryName "jurisdictionC"
+#define LN_jurisdictionCountryName "jurisdictionCountryName"
+#define NID_jurisdictionCountryName 957
+#define OBJ_jurisdictionCountryName 1L, 3L, 6L, 1L, 4L, 1L, 311L, 60L, 2L, 1L, 3L
+
+#define SN_id_scrypt "id-scrypt"
+#define LN_id_scrypt "scrypt"
+#define NID_id_scrypt 973
+#define OBJ_id_scrypt 1L, 3L, 6L, 1L, 4L, 1L, 11591L, 4L, 11L
+
+#define SN_tls1_prf "TLS1-PRF"
+#define LN_tls1_prf "tls1-prf"
+#define NID_tls1_prf 1021
+
+#define SN_hkdf "HKDF"
+#define LN_hkdf "hkdf"
+#define NID_hkdf 1036
+
+#define SN_sshkdf "SSHKDF"
+#define LN_sshkdf "sshkdf"
+#define NID_sshkdf 1203
+
+#define SN_sskdf "SSKDF"
+#define LN_sskdf "sskdf"
+#define NID_sskdf 1205
+
+#define SN_x942kdf "X942KDF"
+#define LN_x942kdf "x942kdf"
+#define NID_x942kdf 1207
+
+#define SN_x963kdf "X963KDF"
+#define LN_x963kdf "x963kdf"
+#define NID_x963kdf 1206
+
+#define SN_id_pkinit "id-pkinit"
+#define NID_id_pkinit 1031
+#define OBJ_id_pkinit 1L, 3L, 6L, 1L, 5L, 2L, 3L
+
+#define SN_pkInitClientAuth "pkInitClientAuth"
+#define LN_pkInitClientAuth "PKINIT Client Auth"
+#define NID_pkInitClientAuth 1032
+#define OBJ_pkInitClientAuth OBJ_id_pkinit, 4L
+
+#define SN_pkInitKDC "pkInitKDC"
+#define LN_pkInitKDC "Signing KDC Response"
+#define NID_pkInitKDC 1033
+#define OBJ_pkInitKDC OBJ_id_pkinit, 5L
+
+#define SN_X25519 "X25519"
+#define NID_X25519 1034
+#define OBJ_X25519 1L, 3L, 101L, 110L
+
+#define SN_X448 "X448"
+#define NID_X448 1035
+#define OBJ_X448 1L, 3L, 101L, 111L
+
+#define SN_ED25519 "ED25519"
+#define NID_ED25519 1087
+#define OBJ_ED25519 1L, 3L, 101L, 112L
+
+#define SN_ED448 "ED448"
+#define NID_ED448 1088
+#define OBJ_ED448 1L, 3L, 101L, 113L
 
-#define SN_kx_rsa               "KxRSA"
-#define LN_kx_rsa               "kx-rsa"
-#define NID_kx_rsa              1037
-
-#define SN_kx_ecdhe             "KxECDHE"
-#define LN_kx_ecdhe             "kx-ecdhe"
-#define NID_kx_ecdhe            1038
-
-#define SN_kx_dhe               "KxDHE"
-#define LN_kx_dhe               "kx-dhe"
-#define NID_kx_dhe              1039
+#define SN_kx_rsa "KxRSA"
+#define LN_kx_rsa "kx-rsa"
+#define NID_kx_rsa 1037
+
+#define SN_kx_ecdhe "KxECDHE"
+#define LN_kx_ecdhe "kx-ecdhe"
+#define NID_kx_ecdhe 1038
+
+#define SN_kx_dhe "KxDHE"
+#define LN_kx_dhe "kx-dhe"
+#define NID_kx_dhe 1039
 
-#define SN_kx_ecdhe_psk         "KxECDHE-PSK"
-#define LN_kx_ecdhe_psk         "kx-ecdhe-psk"
-#define NID_kx_ecdhe_psk                1040
+#define SN_kx_ecdhe_psk "KxECDHE-PSK"
+#define LN_kx_ecdhe_psk "kx-ecdhe-psk"
+#define NID_kx_ecdhe_psk 1040
 
-#define SN_kx_dhe_psk           "KxDHE-PSK"
-#define LN_kx_dhe_psk           "kx-dhe-psk"
-#define NID_kx_dhe_psk          1041
+#define SN_kx_dhe_psk "KxDHE-PSK"
+#define LN_kx_dhe_psk "kx-dhe-psk"
+#define NID_kx_dhe_psk 1041
 
-#define SN_kx_rsa_psk           "KxRSA_PSK"
-#define LN_kx_rsa_psk           "kx-rsa-psk"
-#define NID_kx_rsa_psk          1042
+#define SN_kx_rsa_psk "KxRSA_PSK"
+#define LN_kx_rsa_psk "kx-rsa-psk"
+#define NID_kx_rsa_psk 1042
 
-#define SN_kx_psk               "KxPSK"
-#define LN_kx_psk               "kx-psk"
-#define NID_kx_psk              1043
+#define SN_kx_psk "KxPSK"
+#define LN_kx_psk "kx-psk"
+#define NID_kx_psk 1043
 
-#define SN_kx_srp               "KxSRP"
-#define LN_kx_srp               "kx-srp"
-#define NID_kx_srp              1044
+#define SN_kx_srp "KxSRP"
+#define LN_kx_srp "kx-srp"
+#define NID_kx_srp 1044
 
-#define SN_kx_gost              "KxGOST"
-#define LN_kx_gost              "kx-gost"
-#define NID_kx_gost             1045
+#define SN_kx_gost "KxGOST"
+#define LN_kx_gost "kx-gost"
+#define NID_kx_gost 1045
 
-#define SN_kx_gost18            "KxGOST18"
-#define LN_kx_gost18            "kx-gost18"
-#define NID_kx_gost18           1218
+#define SN_kx_gost18 "KxGOST18"
+#define LN_kx_gost18 "kx-gost18"
+#define NID_kx_gost18 1218
 
-#define SN_kx_any               "KxANY"
-#define LN_kx_any               "kx-any"
-#define NID_kx_any              1063
+#define SN_kx_any "KxANY"
+#define LN_kx_any "kx-any"
+#define NID_kx_any 1063
 
-#define SN_auth_rsa             "AuthRSA"
-#define LN_auth_rsa             "auth-rsa"
-#define NID_auth_rsa            1046
+#define SN_auth_rsa "AuthRSA"
+#define LN_auth_rsa "auth-rsa"
+#define NID_auth_rsa 1046
 
-#define SN_auth_ecdsa           "AuthECDSA"
-#define LN_auth_ecdsa           "auth-ecdsa"
-#define NID_auth_ecdsa          1047
+#define SN_auth_ecdsa "AuthECDSA"
+#define LN_auth_ecdsa "auth-ecdsa"
+#define NID_auth_ecdsa 1047
 
-#define SN_auth_psk             "AuthPSK"
-#define LN_auth_psk             "auth-psk"
-#define NID_auth_psk            1048
+#define SN_auth_psk "AuthPSK"
+#define LN_auth_psk "auth-psk"
+#define NID_auth_psk 1048
 
-#define SN_auth_dss             "AuthDSS"
-#define LN_auth_dss             "auth-dss"
-#define NID_auth_dss            1049
+#define SN_auth_dss "AuthDSS"
+#define LN_auth_dss "auth-dss"
+#define NID_auth_dss 1049
 
-#define SN_auth_gost01          "AuthGOST01"
-#define LN_auth_gost01          "auth-gost01"
-#define NID_auth_gost01         1050
+#define SN_auth_gost01 "AuthGOST01"
+#define LN_auth_gost01 "auth-gost01"
+#define NID_auth_gost01 1050
 
-#define SN_auth_gost12          "AuthGOST12"
-#define LN_auth_gost12          "auth-gost12"
-#define NID_auth_gost12         1051
+#define SN_auth_gost12 "AuthGOST12"
+#define LN_auth_gost12 "auth-gost12"
+#define NID_auth_gost12 1051
 
-#define SN_auth_srp             "AuthSRP"
-#define LN_auth_srp             "auth-srp"
-#define NID_auth_srp            1052
+#define SN_auth_srp "AuthSRP"
+#define LN_auth_srp "auth-srp"
+#define NID_auth_srp 1052
 
-#define SN_auth_null            "AuthNULL"
-#define LN_auth_null            "auth-null"
-#define NID_auth_null           1053
+#define SN_auth_null "AuthNULL"
+#define LN_auth_null "auth-null"
+#define NID_auth_null 1053
 
-#define SN_auth_any             "AuthANY"
-#define LN_auth_any             "auth-any"
-#define NID_auth_any            1064
+#define SN_auth_any "AuthANY"
+#define LN_auth_any "auth-any"
+#define NID_auth_any 1064
 
-#define SN_poly1305             "Poly1305"
-#define LN_poly1305             "poly1305"
-#define NID_poly1305            1061
+#define SN_poly1305 "Poly1305"
+#define LN_poly1305 "poly1305"
+#define NID_poly1305 1061
 
-#define SN_siphash              "SipHash"
-#define LN_siphash              "siphash"
-#define NID_siphash             1062
+#define SN_siphash "SipHash"
+#define LN_siphash "siphash"
+#define NID_siphash 1062
 
-#define SN_ffdhe2048            "ffdhe2048"
-#define NID_ffdhe2048           1126
+#define SN_ffdhe2048 "ffdhe2048"
+#define NID_ffdhe2048 1126
 
-#define SN_ffdhe3072            "ffdhe3072"
-#define NID_ffdhe3072           1127
+#define SN_ffdhe3072 "ffdhe3072"
+#define NID_ffdhe3072 1127
 
-#define SN_ffdhe4096            "ffdhe4096"
-#define NID_ffdhe4096           1128
-
-#define SN_ffdhe6144            "ffdhe6144"
-#define NID_ffdhe6144           1129
+#define SN_ffdhe4096 "ffdhe4096"
+#define NID_ffdhe4096 1128
+
+#define SN_ffdhe6144 "ffdhe6144"
+#define NID_ffdhe6144 1129
 
-#define SN_ffdhe8192            "ffdhe8192"
-#define NID_ffdhe8192           1130
-
-#define SN_modp_1536            "modp_1536"
-#define NID_modp_1536           1212
-
-#define SN_modp_2048            "modp_2048"
-#define NID_modp_2048           1213
-
-#define SN_modp_3072            "modp_3072"
-#define NID_modp_3072           1214
-
-#define SN_modp_4096            "modp_4096"
-#define NID_modp_4096           1215
-
-#define SN_modp_6144            "modp_6144"
-#define NID_modp_6144           1216
-
-#define SN_modp_8192            "modp_8192"
-#define NID_modp_8192           1217
-
-#define SN_ISO_UA               "ISO-UA"
-#define NID_ISO_UA              1150
-#define OBJ_ISO_UA              OBJ_member_body,804L
-
-#define SN_ua_pki               "ua-pki"
-#define NID_ua_pki              1151
-#define OBJ_ua_pki              OBJ_ISO_UA,2L,1L,1L,1L
-
-#define SN_dstu28147            "dstu28147"
-#define LN_dstu28147            "DSTU Gost 28147-2009"
-#define NID_dstu28147           1152
-#define OBJ_dstu28147           OBJ_ua_pki,1L,1L,1L
-
-#define SN_dstu28147_ofb                "dstu28147-ofb"
-#define LN_dstu28147_ofb                "DSTU Gost 28147-2009 OFB mode"
-#define NID_dstu28147_ofb               1153
-#define OBJ_dstu28147_ofb               OBJ_dstu28147,2L
-
-#define SN_dstu28147_cfb                "dstu28147-cfb"
-#define LN_dstu28147_cfb                "DSTU Gost 28147-2009 CFB mode"
-#define NID_dstu28147_cfb               1154
-#define OBJ_dstu28147_cfb               OBJ_dstu28147,3L
-
-#define SN_dstu28147_wrap               "dstu28147-wrap"
-#define LN_dstu28147_wrap               "DSTU Gost 28147-2009 key wrap"
-#define NID_dstu28147_wrap              1155
-#define OBJ_dstu28147_wrap              OBJ_dstu28147,5L
-
-#define SN_hmacWithDstu34311            "hmacWithDstu34311"
-#define LN_hmacWithDstu34311            "HMAC DSTU Gost 34311-95"
-#define NID_hmacWithDstu34311           1156
-#define OBJ_hmacWithDstu34311           OBJ_ua_pki,1L,1L,2L
-
-#define SN_dstu34311            "dstu34311"
-#define LN_dstu34311            "DSTU Gost 34311-95"
-#define NID_dstu34311           1157
-#define OBJ_dstu34311           OBJ_ua_pki,1L,2L,1L
-
-#define SN_dstu4145le           "dstu4145le"
-#define LN_dstu4145le           "DSTU 4145-2002 little endian"
-#define NID_dstu4145le          1158
-#define OBJ_dstu4145le          OBJ_ua_pki,1L,3L,1L,1L
-
-#define SN_dstu4145be           "dstu4145be"
-#define LN_dstu4145be           "DSTU 4145-2002 big endian"
-#define NID_dstu4145be          1159
-#define OBJ_dstu4145be          OBJ_dstu4145le,1L,1L
-
-#define SN_uacurve0             "uacurve0"
-#define LN_uacurve0             "DSTU curve 0"
-#define NID_uacurve0            1160
-#define OBJ_uacurve0            OBJ_dstu4145le,2L,0L
-
-#define SN_uacurve1             "uacurve1"
-#define LN_uacurve1             "DSTU curve 1"
-#define NID_uacurve1            1161
-#define OBJ_uacurve1            OBJ_dstu4145le,2L,1L
-
-#define SN_uacurve2             "uacurve2"
-#define LN_uacurve2             "DSTU curve 2"
-#define NID_uacurve2            1162
-#define OBJ_uacurve2            OBJ_dstu4145le,2L,2L
-
-#define SN_uacurve3             "uacurve3"
-#define LN_uacurve3             "DSTU curve 3"
-#define NID_uacurve3            1163
-#define OBJ_uacurve3            OBJ_dstu4145le,2L,3L
-
-#define SN_uacurve4             "uacurve4"
-#define LN_uacurve4             "DSTU curve 4"
-#define NID_uacurve4            1164
-#define OBJ_uacurve4            OBJ_dstu4145le,2L,4L
-
-#define SN_uacurve5             "uacurve5"
-#define LN_uacurve5             "DSTU curve 5"
-#define NID_uacurve5            1165
-#define OBJ_uacurve5            OBJ_dstu4145le,2L,5L
-
-#define SN_uacurve6             "uacurve6"
-#define LN_uacurve6             "DSTU curve 6"
-#define NID_uacurve6            1166
-#define OBJ_uacurve6            OBJ_dstu4145le,2L,6L
-
-#define SN_uacurve7             "uacurve7"
-#define LN_uacurve7             "DSTU curve 7"
-#define NID_uacurve7            1167
-#define OBJ_uacurve7            OBJ_dstu4145le,2L,7L
-
-#define SN_uacurve8             "uacurve8"
-#define LN_uacurve8             "DSTU curve 8"
-#define NID_uacurve8            1168
-#define OBJ_uacurve8            OBJ_dstu4145le,2L,8L
-
-#define SN_uacurve9             "uacurve9"
-#define LN_uacurve9             "DSTU curve 9"
-#define NID_uacurve9            1169
-#define OBJ_uacurve9            OBJ_dstu4145le,2L,9L
-
-#define SN_aes_128_siv          "AES-128-SIV"
-#define LN_aes_128_siv          "aes-128-siv"
-#define NID_aes_128_siv         1198
-
-#define SN_aes_192_siv          "AES-192-SIV"
-#define LN_aes_192_siv          "aes-192-siv"
-#define NID_aes_192_siv         1199
-
-#define SN_aes_256_siv          "AES-256-SIV"
-#define LN_aes_256_siv          "aes-256-siv"
-#define NID_aes_256_siv         1200
+#define SN_ffdhe8192 "ffdhe8192"
+#define NID_ffdhe8192 1130
+
+#define SN_modp_1536 "modp_1536"
+#define NID_modp_1536 1212
+
+#define SN_modp_2048 "modp_2048"
+#define NID_modp_2048 1213
+
+#define SN_modp_3072 "modp_3072"
+#define NID_modp_3072 1214
+
+#define SN_modp_4096 "modp_4096"
+#define NID_modp_4096 1215
+
+#define SN_modp_6144 "modp_6144"
+#define NID_modp_6144 1216
+
+#define SN_modp_8192 "modp_8192"
+#define NID_modp_8192 1217
+
+#define SN_ISO_UA "ISO-UA"
+#define NID_ISO_UA 1150
+#define OBJ_ISO_UA OBJ_member_body, 804L
+
+#define SN_ua_pki "ua-pki"
+#define NID_ua_pki 1151
+#define OBJ_ua_pki OBJ_ISO_UA, 2L, 1L, 1L, 1L
+
+#define SN_dstu28147 "dstu28147"
+#define LN_dstu28147 "DSTU Gost 28147-2009"
+#define NID_dstu28147 1152
+#define OBJ_dstu28147 OBJ_ua_pki, 1L, 1L, 1L
+
+#define SN_dstu28147_ofb "dstu28147-ofb"
+#define LN_dstu28147_ofb "DSTU Gost 28147-2009 OFB mode"
+#define NID_dstu28147_ofb 1153
+#define OBJ_dstu28147_ofb OBJ_dstu28147, 2L
+
+#define SN_dstu28147_cfb "dstu28147-cfb"
+#define LN_dstu28147_cfb "DSTU Gost 28147-2009 CFB mode"
+#define NID_dstu28147_cfb 1154
+#define OBJ_dstu28147_cfb OBJ_dstu28147, 3L
+
+#define SN_dstu28147_wrap "dstu28147-wrap"
+#define LN_dstu28147_wrap "DSTU Gost 28147-2009 key wrap"
+#define NID_dstu28147_wrap 1155
+#define OBJ_dstu28147_wrap OBJ_dstu28147, 5L
+
+#define SN_hmacWithDstu34311 "hmacWithDstu34311"
+#define LN_hmacWithDstu34311 "HMAC DSTU Gost 34311-95"
+#define NID_hmacWithDstu34311 1156
+#define OBJ_hmacWithDstu34311 OBJ_ua_pki, 1L, 1L, 2L
+
+#define SN_dstu34311 "dstu34311"
+#define LN_dstu34311 "DSTU Gost 34311-95"
+#define NID_dstu34311 1157
+#define OBJ_dstu34311 OBJ_ua_pki, 1L, 2L, 1L
+
+#define SN_dstu4145le "dstu4145le"
+#define LN_dstu4145le "DSTU 4145-2002 little endian"
+#define NID_dstu4145le 1158
+#define OBJ_dstu4145le OBJ_ua_pki, 1L, 3L, 1L, 1L
+
+#define SN_dstu4145be "dstu4145be"
+#define LN_dstu4145be "DSTU 4145-2002 big endian"
+#define NID_dstu4145be 1159
+#define OBJ_dstu4145be OBJ_dstu4145le, 1L, 1L
+
+#define SN_uacurve0 "uacurve0"
+#define LN_uacurve0 "DSTU curve 0"
+#define NID_uacurve0 1160
+#define OBJ_uacurve0 OBJ_dstu4145le, 2L, 0L
+
+#define SN_uacurve1 "uacurve1"
+#define LN_uacurve1 "DSTU curve 1"
+#define NID_uacurve1 1161
+#define OBJ_uacurve1 OBJ_dstu4145le, 2L, 1L
+
+#define SN_uacurve2 "uacurve2"
+#define LN_uacurve2 "DSTU curve 2"
+#define NID_uacurve2 1162
+#define OBJ_uacurve2 OBJ_dstu4145le, 2L, 2L
+
+#define SN_uacurve3 "uacurve3"
+#define LN_uacurve3 "DSTU curve 3"
+#define NID_uacurve3 1163
+#define OBJ_uacurve3 OBJ_dstu4145le, 2L, 3L
+
+#define SN_uacurve4 "uacurve4"
+#define LN_uacurve4 "DSTU curve 4"
+#define NID_uacurve4 1164
+#define OBJ_uacurve4 OBJ_dstu4145le, 2L, 4L
+
+#define SN_uacurve5 "uacurve5"
+#define LN_uacurve5 "DSTU curve 5"
+#define NID_uacurve5 1165
+#define OBJ_uacurve5 OBJ_dstu4145le, 2L, 5L
+
+#define SN_uacurve6 "uacurve6"
+#define LN_uacurve6 "DSTU curve 6"
+#define NID_uacurve6 1166
+#define OBJ_uacurve6 OBJ_dstu4145le, 2L, 6L
+
+#define SN_uacurve7 "uacurve7"
+#define LN_uacurve7 "DSTU curve 7"
+#define NID_uacurve7 1167
+#define OBJ_uacurve7 OBJ_dstu4145le, 2L, 7L
+
+#define SN_uacurve8 "uacurve8"
+#define LN_uacurve8 "DSTU curve 8"
+#define NID_uacurve8 1168
+#define OBJ_uacurve8 OBJ_dstu4145le, 2L, 8L
+
+#define SN_uacurve9 "uacurve9"
+#define LN_uacurve9 "DSTU curve 9"
+#define NID_uacurve9 1169
+#define OBJ_uacurve9 OBJ_dstu4145le, 2L, 9L
+
+#define SN_aes_128_siv "AES-128-SIV"
+#define LN_aes_128_siv "aes-128-siv"
+#define NID_aes_128_siv 1198
+
+#define SN_aes_192_siv "AES-192-SIV"
+#define LN_aes_192_siv "aes-192-siv"
+#define NID_aes_192_siv 1199
+
+#define SN_aes_256_siv "AES-256-SIV"
+#define LN_aes_256_siv "aes-256-siv"
+#define NID_aes_256_siv 1200
 
 #endif /* OPENSSL_OBJ_MAC_H */
 
 #ifndef OPENSSL_NO_DEPRECATED_3_0
 
-#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                 SN_magma_ctr_acpkm
-#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                NID_magma_ctr_acpkm
-#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm                OBJ_magma_ctr_acpkm
+#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm SN_magma_ctr_acpkm
+#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm NID_magma_ctr_acpkm
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm OBJ_magma_ctr_acpkm
 
-#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac            SN_magma_ctr_acpkm_omac
-#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac           NID_magma_ctr_acpkm_omac
-#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac           OBJ_magma_ctr_acpkm_omac
+#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac SN_magma_ctr_acpkm_omac
+#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac NID_magma_ctr_acpkm_omac
+#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac OBJ_magma_ctr_acpkm_omac
 
-#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm            SN_kuznyechik_ctr_acpkm
-#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm           NID_kuznyechik_ctr_acpkm
-#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm           OBJ_kuznyechik_ctr_acpkm
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm SN_kuznyechik_ctr_acpkm
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm NID_kuznyechik_ctr_acpkm
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm OBJ_kuznyechik_ctr_acpkm
 
-#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac               SN_kuznyechik_ctr_acpkm_omac
-#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac              NID_kuznyechik_ctr_acpkm_omac
-#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac              OBJ_kuznyechik_ctr_acpkm_omac
+#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac SN_kuznyechik_ctr_acpkm_omac
+#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac NID_kuznyechik_ctr_acpkm_omac
+#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac OBJ_kuznyechik_ctr_acpkm_omac
 
-#define SN_id_tc26_wrap_gostr3412_2015_magma_kexp15             SN_magma_kexp15
-#define NID_id_tc26_wrap_gostr3412_2015_magma_kexp15            NID_magma_kexp15
-#define OBJ_id_tc26_wrap_gostr3412_2015_magma_kexp15            OBJ_magma_kexp15
+#define SN_id_tc26_wrap_gostr3412_2015_magma_kexp15 SN_magma_kexp15
+#define NID_id_tc26_wrap_gostr3412_2015_magma_kexp15 NID_magma_kexp15
+#define OBJ_id_tc26_wrap_gostr3412_2015_magma_kexp15 OBJ_magma_kexp15
 
-#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15                SN_kuznyechik_kexp15
-#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15               NID_kuznyechik_kexp15
-#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15               OBJ_kuznyechik_kexp15
+#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 SN_kuznyechik_kexp15
+#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 NID_kuznyechik_kexp15
+#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 OBJ_kuznyechik_kexp15
 
-#define SN_grasshopper_ecb              SN_kuznyechik_ecb
-#define NID_grasshopper_ecb             NID_kuznyechik_ecb
+#define SN_grasshopper_ecb SN_kuznyechik_ecb
+#define NID_grasshopper_ecb NID_kuznyechik_ecb
 
-#define SN_grasshopper_ctr              SN_kuznyechik_ctr
-#define NID_grasshopper_ctr             NID_kuznyechik_ctr
+#define SN_grasshopper_ctr SN_kuznyechik_ctr
+#define NID_grasshopper_ctr NID_kuznyechik_ctr
 
-#define SN_grasshopper_ofb              SN_kuznyechik_ofb
-#define NID_grasshopper_ofb             NID_kuznyechik_ofb
+#define SN_grasshopper_ofb SN_kuznyechik_ofb
+#define NID_grasshopper_ofb NID_kuznyechik_ofb
 
-#define SN_grasshopper_cbc              SN_kuznyechik_cbc
-#define NID_grasshopper_cbc             NID_kuznyechik_cbc
+#define SN_grasshopper_cbc SN_kuznyechik_cbc
+#define NID_grasshopper_cbc NID_kuznyechik_cbc
 
-#define SN_grasshopper_cfb              SN_kuznyechik_cfb
-#define NID_grasshopper_cfb             NID_kuznyechik_cfb
+#define SN_grasshopper_cfb SN_kuznyechik_cfb
+#define NID_grasshopper_cfb NID_kuznyechik_cfb
 
-#define SN_grasshopper_mac              SN_kuznyechik_mac
-#define NID_grasshopper_mac             NID_kuznyechik_mac
+#define SN_grasshopper_mac SN_kuznyechik_mac
+#define NID_grasshopper_mac NID_kuznyechik_mac
 
-#endif  /* OPENSSL_NO_DEPRECATED_3_0 */
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
diff --git a/CAPI/cpp/grpc/include/openssl/objects.h b/CAPI/cpp/grpc/include/openssl/objects.h
index 9ea91c2..7cf5f97 100644
--- a/CAPI/cpp/grpc/include/openssl/objects.h
+++ b/CAPI/cpp/grpc/include/openssl/objects.h
@@ -8,176 +8,159 @@
  */
 
 #ifndef OPENSSL_OBJECTS_H
-# define OPENSSL_OBJECTS_H
-# pragma once
+#define OPENSSL_OBJECTS_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_OBJECTS_H
-# endif
-
-# include <openssl/obj_mac.h>
-# include <openssl/bio.h>
-# include <openssl/asn1.h>
-# include <openssl/objectserr.h>
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_OBJECTS_H
+#endif
 
-# define OBJ_NAME_TYPE_UNDEF             0x00
-# define OBJ_NAME_TYPE_MD_METH           0x01
-# define OBJ_NAME_TYPE_CIPHER_METH       0x02
-# define OBJ_NAME_TYPE_PKEY_METH         0x03
-# define OBJ_NAME_TYPE_COMP_METH         0x04
-# define OBJ_NAME_TYPE_MAC_METH          0x05
-# define OBJ_NAME_TYPE_KDF_METH          0x06
-# define OBJ_NAME_TYPE_NUM               0x07
+#include <openssl/obj_mac.h>
+#include <openssl/bio.h>
+#include <openssl/asn1.h>
+#include <openssl/objectserr.h>
 
-# define OBJ_NAME_ALIAS                  0x8000
+#define OBJ_NAME_TYPE_UNDEF 0x00
+#define OBJ_NAME_TYPE_MD_METH 0x01
+#define OBJ_NAME_TYPE_CIPHER_METH 0x02
+#define OBJ_NAME_TYPE_PKEY_METH 0x03
+#define OBJ_NAME_TYPE_COMP_METH 0x04
+#define OBJ_NAME_TYPE_MAC_METH 0x05
+#define OBJ_NAME_TYPE_KDF_METH 0x06
+#define OBJ_NAME_TYPE_NUM 0x07
 
-# define OBJ_BSEARCH_VALUE_ON_NOMATCH            0x01
-# define OBJ_BSEARCH_FIRST_VALUE_ON_MATCH        0x02
+#define OBJ_NAME_ALIAS 0x8000
 
+#define OBJ_BSEARCH_VALUE_ON_NOMATCH 0x01
+#define OBJ_BSEARCH_FIRST_VALUE_ON_MATCH 0x02
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-typedef struct obj_name_st {
-    int type;
-    int alias;
-    const char *name;
-    const char *data;
-} OBJ_NAME;
-
-# define         OBJ_create_and_add_object(a,b,c) OBJ_create(a,b,c)
-
-int OBJ_NAME_init(void);
-int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
-                       int (*cmp_func) (const char *, const char *),
-                       void (*free_func) (const char *, int, const char *));
-const char *OBJ_NAME_get(const char *name, int type);
-int OBJ_NAME_add(const char *name, int type, const char *data);
-int OBJ_NAME_remove(const char *name, int type);
-void OBJ_NAME_cleanup(int type); /* -1 for everything */
-void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg),
-                     void *arg);
-void OBJ_NAME_do_all_sorted(int type,
-                            void (*fn) (const OBJ_NAME *, void *arg),
-                            void *arg);
-
-DECLARE_ASN1_DUP_FUNCTION_name(ASN1_OBJECT, OBJ)
-ASN1_OBJECT *OBJ_nid2obj(int n);
-const char *OBJ_nid2ln(int n);
-const char *OBJ_nid2sn(int n);
-int OBJ_obj2nid(const ASN1_OBJECT *o);
-ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name);
-int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name);
-int OBJ_txt2nid(const char *s);
-int OBJ_ln2nid(const char *s);
-int OBJ_sn2nid(const char *s);
-int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b);
-const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
-                         int (*cmp) (const void *, const void *));
-const void *OBJ_bsearch_ex_(const void *key, const void *base, int num,
-                            int size,
-                            int (*cmp) (const void *, const void *),
-                            int flags);
-
-# define _DECLARE_OBJ_BSEARCH_CMP_FN(scope, type1, type2, nm)    \
-  static int nm##_cmp_BSEARCH_CMP_FN(const void *, const void *); \
-  static int nm##_cmp(type1 const *, type2 const *); \
-  scope type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num)
-
-# define DECLARE_OBJ_BSEARCH_CMP_FN(type1, type2, cmp)   \
-  _DECLARE_OBJ_BSEARCH_CMP_FN(static, type1, type2, cmp)
-# define DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm)     \
-  type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num)
-
-/*-
- * Unsolved problem: if a type is actually a pointer type, like
- * nid_triple is, then its impossible to get a const where you need
- * it. Consider:
- *
- * typedef int nid_triple[3];
- * const void *a_;
- * const nid_triple const *a = a_;
- *
- * The assignment discards a const because what you really want is:
- *
- * const int const * const *a = a_;
- *
- * But if you do that, you lose the fact that a is an array of 3 ints,
- * which breaks comparison functions.
- *
- * Thus we end up having to cast, sadly, or unpack the
- * declarations. Or, as I finally did in this case, declare nid_triple
- * to be a struct, which it should have been in the first place.
- *
- * Ben, August 2008.
- *
- * Also, strictly speaking not all types need be const, but handling
- * the non-constness means a lot of complication, and in practice
- * comparison routines do always not touch their arguments.
- */
-
-# define IMPLEMENT_OBJ_BSEARCH_CMP_FN(type1, type2, nm)  \
-  static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)    \
-      { \
-      type1 const *a = a_; \
-      type2 const *b = b_; \
-      return nm##_cmp(a,b); \
-      } \
-  static type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \
-      { \
-      return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \
-                                        nm##_cmp_BSEARCH_CMP_FN); \
-      } \
-      extern void dummy_prototype(void)
-
-# define IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm)   \
-  static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_)    \
-      { \
-      type1 const *a = a_; \
-      type2 const *b = b_; \
-      return nm##_cmp(a,b); \
-      } \
-  type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \
-      { \
-      return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \
-                                        nm##_cmp_BSEARCH_CMP_FN); \
-      } \
-      extern void dummy_prototype(void)
-
-# define OBJ_bsearch(type1,key,type2,base,num,cmp)                              \
-  ((type2 *)OBJ_bsearch_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \
-                         num,sizeof(type2),                             \
-                         ((void)CHECKED_PTR_OF(type1,cmp##_type_1),     \
-                          (void)CHECKED_PTR_OF(type2,cmp##_type_2),     \
-                          cmp##_BSEARCH_CMP_FN)))
-
-# define OBJ_bsearch_ex(type1,key,type2,base,num,cmp,flags)                      \
-  ((type2 *)OBJ_bsearch_ex_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \
-                         num,sizeof(type2),                             \
-                         ((void)CHECKED_PTR_OF(type1,cmp##_type_1),     \
-                          (void)type_2=CHECKED_PTR_OF(type2,cmp##_type_2), \
-                          cmp##_BSEARCH_CMP_FN)),flags)
-
-int OBJ_new_nid(int num);
-int OBJ_add_object(const ASN1_OBJECT *obj);
-int OBJ_create(const char *oid, const char *sn, const char *ln);
+    typedef struct obj_name_st
+    {
+        int type;
+        int alias;
+        const char* name;
+        const char* data;
+    } OBJ_NAME;
+
+#define OBJ_create_and_add_object(a, b, c) OBJ_create(a, b, c)
+
+    int OBJ_NAME_init(void);
+    int OBJ_NAME_new_index(unsigned long (*hash_func)(const char*), int (*cmp_func)(const char*, const char*), void (*free_func)(const char*, int, const char*));
+    const char* OBJ_NAME_get(const char* name, int type);
+    int OBJ_NAME_add(const char* name, int type, const char* data);
+    int OBJ_NAME_remove(const char* name, int type);
+    void OBJ_NAME_cleanup(int type); /* -1 for everything */
+    void OBJ_NAME_do_all(int type, void (*fn)(const OBJ_NAME*, void* arg), void* arg);
+    void OBJ_NAME_do_all_sorted(int type, void (*fn)(const OBJ_NAME*, void* arg), void* arg);
+
+    DECLARE_ASN1_DUP_FUNCTION_name(ASN1_OBJECT, OBJ)
+        ASN1_OBJECT* OBJ_nid2obj(int n);
+    const char* OBJ_nid2ln(int n);
+    const char* OBJ_nid2sn(int n);
+    int OBJ_obj2nid(const ASN1_OBJECT* o);
+    ASN1_OBJECT* OBJ_txt2obj(const char* s, int no_name);
+    int OBJ_obj2txt(char* buf, int buf_len, const ASN1_OBJECT* a, int no_name);
+    int OBJ_txt2nid(const char* s);
+    int OBJ_ln2nid(const char* s);
+    int OBJ_sn2nid(const char* s);
+    int OBJ_cmp(const ASN1_OBJECT* a, const ASN1_OBJECT* b);
+    const void* OBJ_bsearch_(const void* key, const void* base, int num, int size, int (*cmp)(const void*, const void*));
+    const void* OBJ_bsearch_ex_(const void* key, const void* base, int num, int size, int (*cmp)(const void*, const void*), int flags);
+
+#define _DECLARE_OBJ_BSEARCH_CMP_FN(scope, type1, type2, nm)      \
+    static int nm##_cmp_BSEARCH_CMP_FN(const void*, const void*); \
+    static int nm##_cmp(type1 const*, type2 const*);              \
+    scope type2* OBJ_bsearch_##nm(type1* key, type2 const* base, int num)
+
+#define DECLARE_OBJ_BSEARCH_CMP_FN(type1, type2, cmp) \
+    _DECLARE_OBJ_BSEARCH_CMP_FN(static, type1, type2, cmp)
+#define DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \
+    type2* OBJ_bsearch_##nm(type1* key, type2 const* base, int num)
+
+    /*-
+     * Unsolved problem: if a type is actually a pointer type, like
+     * nid_triple is, then its impossible to get a const where you need
+     * it. Consider:
+     *
+     * typedef int nid_triple[3];
+     * const void *a_;
+     * const nid_triple const *a = a_;
+     *
+     * The assignment discards a const because what you really want is:
+     *
+     * const int const * const *a = a_;
+     *
+     * But if you do that, you lose the fact that a is an array of 3 ints,
+     * which breaks comparison functions.
+     *
+     * Thus we end up having to cast, sadly, or unpack the
+     * declarations. Or, as I finally did in this case, declare nid_triple
+     * to be a struct, which it should have been in the first place.
+     *
+     * Ben, August 2008.
+     *
+     * Also, strictly speaking not all types need be const, but handling
+     * the non-constness means a lot of complication, and in practice
+     * comparison routines do always not touch their arguments.
+     */
+
+#define IMPLEMENT_OBJ_BSEARCH_CMP_FN(type1, type2, nm)                                       \
+    static int nm##_cmp_BSEARCH_CMP_FN(const void* a_, const void* b_)                       \
+    {                                                                                        \
+        type1 const* a = a_;                                                                 \
+        type2 const* b = b_;                                                                 \
+        return nm##_cmp(a, b);                                                               \
+    }                                                                                        \
+    static type2* OBJ_bsearch_##nm(type1* key, type2 const* base, int num)                   \
+    {                                                                                        \
+        return (type2*)OBJ_bsearch_(key, base, num, sizeof(type2), nm##_cmp_BSEARCH_CMP_FN); \
+    }                                                                                        \
+    extern void dummy_prototype(void)
+
+#define IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm)                                \
+    static int nm##_cmp_BSEARCH_CMP_FN(const void* a_, const void* b_)                       \
+    {                                                                                        \
+        type1 const* a = a_;                                                                 \
+        type2 const* b = b_;                                                                 \
+        return nm##_cmp(a, b);                                                               \
+    }                                                                                        \
+    type2* OBJ_bsearch_##nm(type1* key, type2 const* base, int num)                          \
+    {                                                                                        \
+        return (type2*)OBJ_bsearch_(key, base, num, sizeof(type2), nm##_cmp_BSEARCH_CMP_FN); \
+    }                                                                                        \
+    extern void dummy_prototype(void)
+
+#define OBJ_bsearch(type1, key, type2, base, num, cmp) \
+    ((type2*)OBJ_bsearch_(CHECKED_PTR_OF(type1, key), CHECKED_PTR_OF(type2, base), num, sizeof(type2), ((void)CHECKED_PTR_OF(type1, cmp##_type_1), (void)CHECKED_PTR_OF(type2, cmp##_type_2), cmp##_BSEARCH_CMP_FN)))
+
+#define OBJ_bsearch_ex(type1, key, type2, base, num, cmp, flags) \
+    ((type2*)OBJ_bsearch_ex_(CHECKED_PTR_OF(type1, key), CHECKED_PTR_OF(type2, base), num, sizeof(type2), ((void)CHECKED_PTR_OF(type1, cmp##_type_1), (void)type_2 = CHECKED_PTR_OF(type2, cmp##_type_2), cmp##_BSEARCH_CMP_FN)), flags)
+
+    int OBJ_new_nid(int num);
+    int OBJ_add_object(const ASN1_OBJECT* obj);
+    int OBJ_create(const char* oid, const char* sn, const char* ln);
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-# define OBJ_cleanup() while(0) continue
+#define OBJ_cleanup() \
+    while (0)         \
+    continue
 #endif
-int OBJ_create_objects(BIO *in);
-
-size_t OBJ_length(const ASN1_OBJECT *obj);
-const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj);
+    int OBJ_create_objects(BIO* in);
 
-int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid);
-int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid);
-int OBJ_add_sigid(int signid, int dig_id, int pkey_id);
-void OBJ_sigid_free(void);
+    size_t OBJ_length(const ASN1_OBJECT* obj);
+    const unsigned char* OBJ_get0_data(const ASN1_OBJECT* obj);
 
+    int OBJ_find_sigid_algs(int signid, int* pdig_nid, int* ppkey_nid);
+    int OBJ_find_sigid_by_algs(int* psignid, int dig_nid, int pkey_nid);
+    int OBJ_add_sigid(int signid, int dig_id, int pkey_id);
+    void OBJ_sigid_free(void);
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/objectserr.h b/CAPI/cpp/grpc/include/openssl/objectserr.h
index 585217f..2927561 100644
--- a/CAPI/cpp/grpc/include/openssl/objectserr.h
+++ b/CAPI/cpp/grpc/include/openssl/objectserr.h
@@ -9,20 +9,18 @@
  */
 
 #ifndef OPENSSL_OBJECTSERR_H
-# define OPENSSL_OBJECTSERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_OBJECTSERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * OBJ reason codes.
  */
-# define OBJ_R_OID_EXISTS                                 102
-# define OBJ_R_UNKNOWN_NID                                101
-# define OBJ_R_UNKNOWN_OBJECT_NAME                        103
+#define OBJ_R_OID_EXISTS 102
+#define OBJ_R_UNKNOWN_NID 101
+#define OBJ_R_UNKNOWN_OBJECT_NAME 103
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ocsp.h b/CAPI/cpp/grpc/include/openssl/ocsp.h
index 5688381..0e12dd9 100644
--- a/CAPI/cpp/grpc/include/openssl/ocsp.h
+++ b/CAPI/cpp/grpc/include/openssl/ocsp.h
@@ -10,20 +10,18 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_OCSP_H
-# define OPENSSL_OCSP_H
-# pragma once
+#define OPENSSL_OCSP_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_OCSP_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_OCSP_H
+#endif
 
-# include <openssl/opensslconf.h>
-# include <openssl/http.h>
-# include <openssl/asn1.h>
+#include <openssl/opensslconf.h>
+#include <openssl/http.h>
+#include <openssl/asn1.h>
 
 /*
  * These definitions are outside the OPENSSL_NO_OCSP guard because although for
@@ -44,440 +42,382 @@
  *        privilegeWithdrawn      (9),
  *        aACompromise           (10) }
  */
-# define OCSP_REVOKED_STATUS_NOSTATUS                -1
-# define OCSP_REVOKED_STATUS_UNSPECIFIED             0
-# define OCSP_REVOKED_STATUS_KEYCOMPROMISE           1
-# define OCSP_REVOKED_STATUS_CACOMPROMISE            2
-# define OCSP_REVOKED_STATUS_AFFILIATIONCHANGED      3
-# define OCSP_REVOKED_STATUS_SUPERSEDED              4
-# define OCSP_REVOKED_STATUS_CESSATIONOFOPERATION    5
-# define OCSP_REVOKED_STATUS_CERTIFICATEHOLD         6
-# define OCSP_REVOKED_STATUS_REMOVEFROMCRL           8
-# define OCSP_REVOKED_STATUS_PRIVILEGEWITHDRAWN      9
-# define OCSP_REVOKED_STATUS_AACOMPROMISE            10
-
-
-# ifndef OPENSSL_NO_OCSP
-
-#  include <openssl/x509.h>
-#  include <openssl/x509v3.h>
-#  include <openssl/safestack.h>
-#  include <openssl/ocsperr.h>
-
-#  ifdef __cplusplus
-extern "C" {
-#  endif
-
-/* Various flags and values */
-
-#  define OCSP_DEFAULT_NONCE_LENGTH       16
-
-#  define OCSP_NOCERTS                    0x1
-#  define OCSP_NOINTERN                   0x2
-#  define OCSP_NOSIGS                     0x4
-#  define OCSP_NOCHAIN                    0x8
-#  define OCSP_NOVERIFY                   0x10
-#  define OCSP_NOEXPLICIT                 0x20
-#  define OCSP_NOCASIGN                   0x40
-#  define OCSP_NODELEGATED                0x80
-#  define OCSP_NOCHECKS                   0x100
-#  define OCSP_TRUSTOTHER                 0x200
-#  define OCSP_RESPID_KEY                 0x400
-#  define OCSP_NOTIME                     0x800
-#  define OCSP_PARTIAL_CHAIN              0x1000
-
-typedef struct ocsp_cert_id_st OCSP_CERTID;
-typedef struct ocsp_one_request_st OCSP_ONEREQ;
-typedef struct ocsp_req_info_st OCSP_REQINFO;
-typedef struct ocsp_signature_st OCSP_SIGNATURE;
-typedef struct ocsp_request_st OCSP_REQUEST;
-
-SKM_DEFINE_STACK_OF_INTERNAL(OCSP_CERTID, OCSP_CERTID, OCSP_CERTID)
+#define OCSP_REVOKED_STATUS_NOSTATUS -1
+#define OCSP_REVOKED_STATUS_UNSPECIFIED 0
+#define OCSP_REVOKED_STATUS_KEYCOMPROMISE 1
+#define OCSP_REVOKED_STATUS_CACOMPROMISE 2
+#define OCSP_REVOKED_STATUS_AFFILIATIONCHANGED 3
+#define OCSP_REVOKED_STATUS_SUPERSEDED 4
+#define OCSP_REVOKED_STATUS_CESSATIONOFOPERATION 5
+#define OCSP_REVOKED_STATUS_CERTIFICATEHOLD 6
+#define OCSP_REVOKED_STATUS_REMOVEFROMCRL 8
+#define OCSP_REVOKED_STATUS_PRIVILEGEWITHDRAWN 9
+#define OCSP_REVOKED_STATUS_AACOMPROMISE 10
+
+#ifndef OPENSSL_NO_OCSP
+
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+#include <openssl/safestack.h>
+#include <openssl/ocsperr.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /* Various flags and values */
+
+#define OCSP_DEFAULT_NONCE_LENGTH 16
+
+#define OCSP_NOCERTS 0x1
+#define OCSP_NOINTERN 0x2
+#define OCSP_NOSIGS 0x4
+#define OCSP_NOCHAIN 0x8
+#define OCSP_NOVERIFY 0x10
+#define OCSP_NOEXPLICIT 0x20
+#define OCSP_NOCASIGN 0x40
+#define OCSP_NODELEGATED 0x80
+#define OCSP_NOCHECKS 0x100
+#define OCSP_TRUSTOTHER 0x200
+#define OCSP_RESPID_KEY 0x400
+#define OCSP_NOTIME 0x800
+#define OCSP_PARTIAL_CHAIN 0x1000
+
+    typedef struct ocsp_cert_id_st OCSP_CERTID;
+    typedef struct ocsp_one_request_st OCSP_ONEREQ;
+    typedef struct ocsp_req_info_st OCSP_REQINFO;
+    typedef struct ocsp_signature_st OCSP_SIGNATURE;
+    typedef struct ocsp_request_st OCSP_REQUEST;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(OCSP_CERTID, OCSP_CERTID, OCSP_CERTID)
 #define sk_OCSP_CERTID_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_CERTID_sk_type(sk))
-#define sk_OCSP_CERTID_value(sk, idx) ((OCSP_CERTID *)OPENSSL_sk_value(ossl_check_const_OCSP_CERTID_sk_type(sk), (idx)))
-#define sk_OCSP_CERTID_new(cmp) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new(ossl_check_OCSP_CERTID_compfunc_type(cmp)))
-#define sk_OCSP_CERTID_new_null() ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new_null())
-#define sk_OCSP_CERTID_new_reserve(cmp, n) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_CERTID_compfunc_type(cmp), (n)))
+#define sk_OCSP_CERTID_value(sk, idx) ((OCSP_CERTID*)OPENSSL_sk_value(ossl_check_const_OCSP_CERTID_sk_type(sk), (idx)))
+#define sk_OCSP_CERTID_new(cmp) ((STACK_OF(OCSP_CERTID)*)OPENSSL_sk_new(ossl_check_OCSP_CERTID_compfunc_type(cmp)))
+#define sk_OCSP_CERTID_new_null() ((STACK_OF(OCSP_CERTID)*)OPENSSL_sk_new_null())
+#define sk_OCSP_CERTID_new_reserve(cmp, n) ((STACK_OF(OCSP_CERTID)*)OPENSSL_sk_new_reserve(ossl_check_OCSP_CERTID_compfunc_type(cmp), (n)))
 #define sk_OCSP_CERTID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_CERTID_sk_type(sk), (n))
 #define sk_OCSP_CERTID_free(sk) OPENSSL_sk_free(ossl_check_OCSP_CERTID_sk_type(sk))
 #define sk_OCSP_CERTID_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_CERTID_sk_type(sk))
-#define sk_OCSP_CERTID_delete(sk, i) ((OCSP_CERTID *)OPENSSL_sk_delete(ossl_check_OCSP_CERTID_sk_type(sk), (i)))
-#define sk_OCSP_CERTID_delete_ptr(sk, ptr) ((OCSP_CERTID *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr)))
+#define sk_OCSP_CERTID_delete(sk, i) ((OCSP_CERTID*)OPENSSL_sk_delete(ossl_check_OCSP_CERTID_sk_type(sk), (i)))
+#define sk_OCSP_CERTID_delete_ptr(sk, ptr) ((OCSP_CERTID*)OPENSSL_sk_delete_ptr(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr)))
 #define sk_OCSP_CERTID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
 #define sk_OCSP_CERTID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
-#define sk_OCSP_CERTID_pop(sk) ((OCSP_CERTID *)OPENSSL_sk_pop(ossl_check_OCSP_CERTID_sk_type(sk)))
-#define sk_OCSP_CERTID_shift(sk) ((OCSP_CERTID *)OPENSSL_sk_shift(ossl_check_OCSP_CERTID_sk_type(sk)))
-#define sk_OCSP_CERTID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_CERTID_sk_type(sk),ossl_check_OCSP_CERTID_freefunc_type(freefunc))
+#define sk_OCSP_CERTID_pop(sk) ((OCSP_CERTID*)OPENSSL_sk_pop(ossl_check_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_shift(sk) ((OCSP_CERTID*)OPENSSL_sk_shift(ossl_check_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_freefunc_type(freefunc))
 #define sk_OCSP_CERTID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr), (idx))
-#define sk_OCSP_CERTID_set(sk, idx, ptr) ((OCSP_CERTID *)OPENSSL_sk_set(ossl_check_OCSP_CERTID_sk_type(sk), (idx), ossl_check_OCSP_CERTID_type(ptr)))
+#define sk_OCSP_CERTID_set(sk, idx, ptr) ((OCSP_CERTID*)OPENSSL_sk_set(ossl_check_OCSP_CERTID_sk_type(sk), (idx), ossl_check_OCSP_CERTID_type(ptr)))
 #define sk_OCSP_CERTID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
 #define sk_OCSP_CERTID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr))
 #define sk_OCSP_CERTID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr), pnum)
 #define sk_OCSP_CERTID_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_CERTID_sk_type(sk))
 #define sk_OCSP_CERTID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_CERTID_sk_type(sk))
-#define sk_OCSP_CERTID_dup(sk) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_dup(ossl_check_const_OCSP_CERTID_sk_type(sk)))
-#define sk_OCSP_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_copyfunc_type(copyfunc), ossl_check_OCSP_CERTID_freefunc_type(freefunc)))
+#define sk_OCSP_CERTID_dup(sk) ((STACK_OF(OCSP_CERTID)*)OPENSSL_sk_dup(ossl_check_const_OCSP_CERTID_sk_type(sk)))
+#define sk_OCSP_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_CERTID)*)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_copyfunc_type(copyfunc), ossl_check_OCSP_CERTID_freefunc_type(freefunc)))
 #define sk_OCSP_CERTID_set_cmp_func(sk, cmp) ((sk_OCSP_CERTID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(OCSP_ONEREQ, OCSP_ONEREQ, OCSP_ONEREQ)
+    SKM_DEFINE_STACK_OF_INTERNAL(OCSP_ONEREQ, OCSP_ONEREQ, OCSP_ONEREQ)
 #define sk_OCSP_ONEREQ_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_ONEREQ_sk_type(sk))
-#define sk_OCSP_ONEREQ_value(sk, idx) ((OCSP_ONEREQ *)OPENSSL_sk_value(ossl_check_const_OCSP_ONEREQ_sk_type(sk), (idx)))
-#define sk_OCSP_ONEREQ_new(cmp) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new(ossl_check_OCSP_ONEREQ_compfunc_type(cmp)))
-#define sk_OCSP_ONEREQ_new_null() ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new_null())
-#define sk_OCSP_ONEREQ_new_reserve(cmp, n) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_ONEREQ_compfunc_type(cmp), (n)))
+#define sk_OCSP_ONEREQ_value(sk, idx) ((OCSP_ONEREQ*)OPENSSL_sk_value(ossl_check_const_OCSP_ONEREQ_sk_type(sk), (idx)))
+#define sk_OCSP_ONEREQ_new(cmp) ((STACK_OF(OCSP_ONEREQ)*)OPENSSL_sk_new(ossl_check_OCSP_ONEREQ_compfunc_type(cmp)))
+#define sk_OCSP_ONEREQ_new_null() ((STACK_OF(OCSP_ONEREQ)*)OPENSSL_sk_new_null())
+#define sk_OCSP_ONEREQ_new_reserve(cmp, n) ((STACK_OF(OCSP_ONEREQ)*)OPENSSL_sk_new_reserve(ossl_check_OCSP_ONEREQ_compfunc_type(cmp), (n)))
 #define sk_OCSP_ONEREQ_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_ONEREQ_sk_type(sk), (n))
 #define sk_OCSP_ONEREQ_free(sk) OPENSSL_sk_free(ossl_check_OCSP_ONEREQ_sk_type(sk))
 #define sk_OCSP_ONEREQ_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_ONEREQ_sk_type(sk))
-#define sk_OCSP_ONEREQ_delete(sk, i) ((OCSP_ONEREQ *)OPENSSL_sk_delete(ossl_check_OCSP_ONEREQ_sk_type(sk), (i)))
-#define sk_OCSP_ONEREQ_delete_ptr(sk, ptr) ((OCSP_ONEREQ *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr)))
+#define sk_OCSP_ONEREQ_delete(sk, i) ((OCSP_ONEREQ*)OPENSSL_sk_delete(ossl_check_OCSP_ONEREQ_sk_type(sk), (i)))
+#define sk_OCSP_ONEREQ_delete_ptr(sk, ptr) ((OCSP_ONEREQ*)OPENSSL_sk_delete_ptr(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr)))
 #define sk_OCSP_ONEREQ_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
 #define sk_OCSP_ONEREQ_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
-#define sk_OCSP_ONEREQ_pop(sk) ((OCSP_ONEREQ *)OPENSSL_sk_pop(ossl_check_OCSP_ONEREQ_sk_type(sk)))
-#define sk_OCSP_ONEREQ_shift(sk) ((OCSP_ONEREQ *)OPENSSL_sk_shift(ossl_check_OCSP_ONEREQ_sk_type(sk)))
-#define sk_OCSP_ONEREQ_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_ONEREQ_sk_type(sk),ossl_check_OCSP_ONEREQ_freefunc_type(freefunc))
+#define sk_OCSP_ONEREQ_pop(sk) ((OCSP_ONEREQ*)OPENSSL_sk_pop(ossl_check_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_shift(sk) ((OCSP_ONEREQ*)OPENSSL_sk_shift(ossl_check_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_freefunc_type(freefunc))
 #define sk_OCSP_ONEREQ_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr), (idx))
-#define sk_OCSP_ONEREQ_set(sk, idx, ptr) ((OCSP_ONEREQ *)OPENSSL_sk_set(ossl_check_OCSP_ONEREQ_sk_type(sk), (idx), ossl_check_OCSP_ONEREQ_type(ptr)))
+#define sk_OCSP_ONEREQ_set(sk, idx, ptr) ((OCSP_ONEREQ*)OPENSSL_sk_set(ossl_check_OCSP_ONEREQ_sk_type(sk), (idx), ossl_check_OCSP_ONEREQ_type(ptr)))
 #define sk_OCSP_ONEREQ_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
 #define sk_OCSP_ONEREQ_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr))
 #define sk_OCSP_ONEREQ_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr), pnum)
 #define sk_OCSP_ONEREQ_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_ONEREQ_sk_type(sk))
 #define sk_OCSP_ONEREQ_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_ONEREQ_sk_type(sk))
-#define sk_OCSP_ONEREQ_dup(sk) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_dup(ossl_check_const_OCSP_ONEREQ_sk_type(sk)))
-#define sk_OCSP_ONEREQ_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_copyfunc_type(copyfunc), ossl_check_OCSP_ONEREQ_freefunc_type(freefunc)))
+#define sk_OCSP_ONEREQ_dup(sk) ((STACK_OF(OCSP_ONEREQ)*)OPENSSL_sk_dup(ossl_check_const_OCSP_ONEREQ_sk_type(sk)))
+#define sk_OCSP_ONEREQ_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_ONEREQ)*)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_copyfunc_type(copyfunc), ossl_check_OCSP_ONEREQ_freefunc_type(freefunc)))
 #define sk_OCSP_ONEREQ_set_cmp_func(sk, cmp) ((sk_OCSP_ONEREQ_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_compfunc_type(cmp)))
 
+#define OCSP_RESPONSE_STATUS_SUCCESSFUL 0
+#define OCSP_RESPONSE_STATUS_MALFORMEDREQUEST 1
+#define OCSP_RESPONSE_STATUS_INTERNALERROR 2
+#define OCSP_RESPONSE_STATUS_TRYLATER 3
+#define OCSP_RESPONSE_STATUS_SIGREQUIRED 5
+#define OCSP_RESPONSE_STATUS_UNAUTHORIZED 6
 
-#  define OCSP_RESPONSE_STATUS_SUCCESSFUL           0
-#  define OCSP_RESPONSE_STATUS_MALFORMEDREQUEST     1
-#  define OCSP_RESPONSE_STATUS_INTERNALERROR        2
-#  define OCSP_RESPONSE_STATUS_TRYLATER             3
-#  define OCSP_RESPONSE_STATUS_SIGREQUIRED          5
-#  define OCSP_RESPONSE_STATUS_UNAUTHORIZED         6
+    typedef struct ocsp_resp_bytes_st OCSP_RESPBYTES;
 
-typedef struct ocsp_resp_bytes_st OCSP_RESPBYTES;
+#define V_OCSP_RESPID_NAME 0
+#define V_OCSP_RESPID_KEY 1
 
-#  define V_OCSP_RESPID_NAME 0
-#  define V_OCSP_RESPID_KEY  1
-
-SKM_DEFINE_STACK_OF_INTERNAL(OCSP_RESPID, OCSP_RESPID, OCSP_RESPID)
+    SKM_DEFINE_STACK_OF_INTERNAL(OCSP_RESPID, OCSP_RESPID, OCSP_RESPID)
 #define sk_OCSP_RESPID_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_RESPID_sk_type(sk))
-#define sk_OCSP_RESPID_value(sk, idx) ((OCSP_RESPID *)OPENSSL_sk_value(ossl_check_const_OCSP_RESPID_sk_type(sk), (idx)))
-#define sk_OCSP_RESPID_new(cmp) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new(ossl_check_OCSP_RESPID_compfunc_type(cmp)))
-#define sk_OCSP_RESPID_new_null() ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new_null())
-#define sk_OCSP_RESPID_new_reserve(cmp, n) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_RESPID_compfunc_type(cmp), (n)))
+#define sk_OCSP_RESPID_value(sk, idx) ((OCSP_RESPID*)OPENSSL_sk_value(ossl_check_const_OCSP_RESPID_sk_type(sk), (idx)))
+#define sk_OCSP_RESPID_new(cmp) ((STACK_OF(OCSP_RESPID)*)OPENSSL_sk_new(ossl_check_OCSP_RESPID_compfunc_type(cmp)))
+#define sk_OCSP_RESPID_new_null() ((STACK_OF(OCSP_RESPID)*)OPENSSL_sk_new_null())
+#define sk_OCSP_RESPID_new_reserve(cmp, n) ((STACK_OF(OCSP_RESPID)*)OPENSSL_sk_new_reserve(ossl_check_OCSP_RESPID_compfunc_type(cmp), (n)))
 #define sk_OCSP_RESPID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_RESPID_sk_type(sk), (n))
 #define sk_OCSP_RESPID_free(sk) OPENSSL_sk_free(ossl_check_OCSP_RESPID_sk_type(sk))
 #define sk_OCSP_RESPID_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_RESPID_sk_type(sk))
-#define sk_OCSP_RESPID_delete(sk, i) ((OCSP_RESPID *)OPENSSL_sk_delete(ossl_check_OCSP_RESPID_sk_type(sk), (i)))
-#define sk_OCSP_RESPID_delete_ptr(sk, ptr) ((OCSP_RESPID *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr)))
+#define sk_OCSP_RESPID_delete(sk, i) ((OCSP_RESPID*)OPENSSL_sk_delete(ossl_check_OCSP_RESPID_sk_type(sk), (i)))
+#define sk_OCSP_RESPID_delete_ptr(sk, ptr) ((OCSP_RESPID*)OPENSSL_sk_delete_ptr(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr)))
 #define sk_OCSP_RESPID_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
 #define sk_OCSP_RESPID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
-#define sk_OCSP_RESPID_pop(sk) ((OCSP_RESPID *)OPENSSL_sk_pop(ossl_check_OCSP_RESPID_sk_type(sk)))
-#define sk_OCSP_RESPID_shift(sk) ((OCSP_RESPID *)OPENSSL_sk_shift(ossl_check_OCSP_RESPID_sk_type(sk)))
-#define sk_OCSP_RESPID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_RESPID_sk_type(sk),ossl_check_OCSP_RESPID_freefunc_type(freefunc))
+#define sk_OCSP_RESPID_pop(sk) ((OCSP_RESPID*)OPENSSL_sk_pop(ossl_check_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_shift(sk) ((OCSP_RESPID*)OPENSSL_sk_shift(ossl_check_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_freefunc_type(freefunc))
 #define sk_OCSP_RESPID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr), (idx))
-#define sk_OCSP_RESPID_set(sk, idx, ptr) ((OCSP_RESPID *)OPENSSL_sk_set(ossl_check_OCSP_RESPID_sk_type(sk), (idx), ossl_check_OCSP_RESPID_type(ptr)))
+#define sk_OCSP_RESPID_set(sk, idx, ptr) ((OCSP_RESPID*)OPENSSL_sk_set(ossl_check_OCSP_RESPID_sk_type(sk), (idx), ossl_check_OCSP_RESPID_type(ptr)))
 #define sk_OCSP_RESPID_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
 #define sk_OCSP_RESPID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr))
 #define sk_OCSP_RESPID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr), pnum)
 #define sk_OCSP_RESPID_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_RESPID_sk_type(sk))
 #define sk_OCSP_RESPID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_RESPID_sk_type(sk))
-#define sk_OCSP_RESPID_dup(sk) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_dup(ossl_check_const_OCSP_RESPID_sk_type(sk)))
-#define sk_OCSP_RESPID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_copyfunc_type(copyfunc), ossl_check_OCSP_RESPID_freefunc_type(freefunc)))
+#define sk_OCSP_RESPID_dup(sk) ((STACK_OF(OCSP_RESPID)*)OPENSSL_sk_dup(ossl_check_const_OCSP_RESPID_sk_type(sk)))
+#define sk_OCSP_RESPID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_RESPID)*)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_copyfunc_type(copyfunc), ossl_check_OCSP_RESPID_freefunc_type(freefunc)))
 #define sk_OCSP_RESPID_set_cmp_func(sk, cmp) ((sk_OCSP_RESPID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_compfunc_type(cmp)))
 
+    typedef struct ocsp_revoked_info_st OCSP_REVOKEDINFO;
 
-typedef struct ocsp_revoked_info_st OCSP_REVOKEDINFO;
-
-#  define V_OCSP_CERTSTATUS_GOOD    0
-#  define V_OCSP_CERTSTATUS_REVOKED 1
-#  define V_OCSP_CERTSTATUS_UNKNOWN 2
+#define V_OCSP_CERTSTATUS_GOOD 0
+#define V_OCSP_CERTSTATUS_REVOKED 1
+#define V_OCSP_CERTSTATUS_UNKNOWN 2
 
-typedef struct ocsp_cert_status_st OCSP_CERTSTATUS;
-typedef struct ocsp_single_response_st OCSP_SINGLERESP;
+    typedef struct ocsp_cert_status_st OCSP_CERTSTATUS;
+    typedef struct ocsp_single_response_st OCSP_SINGLERESP;
 
-SKM_DEFINE_STACK_OF_INTERNAL(OCSP_SINGLERESP, OCSP_SINGLERESP, OCSP_SINGLERESP)
+    SKM_DEFINE_STACK_OF_INTERNAL(OCSP_SINGLERESP, OCSP_SINGLERESP, OCSP_SINGLERESP)
 #define sk_OCSP_SINGLERESP_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_SINGLERESP_sk_type(sk))
-#define sk_OCSP_SINGLERESP_value(sk, idx) ((OCSP_SINGLERESP *)OPENSSL_sk_value(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), (idx)))
-#define sk_OCSP_SINGLERESP_new(cmp) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)))
-#define sk_OCSP_SINGLERESP_new_null() ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new_null())
-#define sk_OCSP_SINGLERESP_new_reserve(cmp, n) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_new_reserve(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp), (n)))
+#define sk_OCSP_SINGLERESP_value(sk, idx) ((OCSP_SINGLERESP*)OPENSSL_sk_value(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), (idx)))
+#define sk_OCSP_SINGLERESP_new(cmp) ((STACK_OF(OCSP_SINGLERESP)*)OPENSSL_sk_new(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)))
+#define sk_OCSP_SINGLERESP_new_null() ((STACK_OF(OCSP_SINGLERESP)*)OPENSSL_sk_new_null())
+#define sk_OCSP_SINGLERESP_new_reserve(cmp, n) ((STACK_OF(OCSP_SINGLERESP)*)OPENSSL_sk_new_reserve(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp), (n)))
 #define sk_OCSP_SINGLERESP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_SINGLERESP_sk_type(sk), (n))
 #define sk_OCSP_SINGLERESP_free(sk) OPENSSL_sk_free(ossl_check_OCSP_SINGLERESP_sk_type(sk))
 #define sk_OCSP_SINGLERESP_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_SINGLERESP_sk_type(sk))
-#define sk_OCSP_SINGLERESP_delete(sk, i) ((OCSP_SINGLERESP *)OPENSSL_sk_delete(ossl_check_OCSP_SINGLERESP_sk_type(sk), (i)))
-#define sk_OCSP_SINGLERESP_delete_ptr(sk, ptr) ((OCSP_SINGLERESP *)OPENSSL_sk_delete_ptr(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr)))
+#define sk_OCSP_SINGLERESP_delete(sk, i) ((OCSP_SINGLERESP*)OPENSSL_sk_delete(ossl_check_OCSP_SINGLERESP_sk_type(sk), (i)))
+#define sk_OCSP_SINGLERESP_delete_ptr(sk, ptr) ((OCSP_SINGLERESP*)OPENSSL_sk_delete_ptr(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr)))
 #define sk_OCSP_SINGLERESP_push(sk, ptr) OPENSSL_sk_push(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
 #define sk_OCSP_SINGLERESP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
-#define sk_OCSP_SINGLERESP_pop(sk) ((OCSP_SINGLERESP *)OPENSSL_sk_pop(ossl_check_OCSP_SINGLERESP_sk_type(sk)))
-#define sk_OCSP_SINGLERESP_shift(sk) ((OCSP_SINGLERESP *)OPENSSL_sk_shift(ossl_check_OCSP_SINGLERESP_sk_type(sk)))
-#define sk_OCSP_SINGLERESP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_SINGLERESP_sk_type(sk),ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc))
+#define sk_OCSP_SINGLERESP_pop(sk) ((OCSP_SINGLERESP*)OPENSSL_sk_pop(ossl_check_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_shift(sk) ((OCSP_SINGLERESP*)OPENSSL_sk_shift(ossl_check_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc))
 #define sk_OCSP_SINGLERESP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr), (idx))
-#define sk_OCSP_SINGLERESP_set(sk, idx, ptr) ((OCSP_SINGLERESP *)OPENSSL_sk_set(ossl_check_OCSP_SINGLERESP_sk_type(sk), (idx), ossl_check_OCSP_SINGLERESP_type(ptr)))
+#define sk_OCSP_SINGLERESP_set(sk, idx, ptr) ((OCSP_SINGLERESP*)OPENSSL_sk_set(ossl_check_OCSP_SINGLERESP_sk_type(sk), (idx), ossl_check_OCSP_SINGLERESP_type(ptr)))
 #define sk_OCSP_SINGLERESP_find(sk, ptr) OPENSSL_sk_find(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
 #define sk_OCSP_SINGLERESP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr))
 #define sk_OCSP_SINGLERESP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr), pnum)
 #define sk_OCSP_SINGLERESP_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_SINGLERESP_sk_type(sk))
 #define sk_OCSP_SINGLERESP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_SINGLERESP_sk_type(sk))
-#define sk_OCSP_SINGLERESP_dup(sk) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_dup(ossl_check_const_OCSP_SINGLERESP_sk_type(sk)))
-#define sk_OCSP_SINGLERESP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_copyfunc_type(copyfunc), ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc)))
+#define sk_OCSP_SINGLERESP_dup(sk) ((STACK_OF(OCSP_SINGLERESP)*)OPENSSL_sk_dup(ossl_check_const_OCSP_SINGLERESP_sk_type(sk)))
+#define sk_OCSP_SINGLERESP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_SINGLERESP)*)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_copyfunc_type(copyfunc), ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc)))
 #define sk_OCSP_SINGLERESP_set_cmp_func(sk, cmp) ((sk_OCSP_SINGLERESP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)))
 
+    typedef struct ocsp_response_data_st OCSP_RESPDATA;
+
+    typedef struct ocsp_basic_response_st OCSP_BASICRESP;
+
+    typedef struct ocsp_crl_id_st OCSP_CRLID;
+    typedef struct ocsp_service_locator_st OCSP_SERVICELOC;
+
+#define PEM_STRING_OCSP_REQUEST "OCSP REQUEST"
+#define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE"
+
+#define d2i_OCSP_REQUEST_bio(bp, p) ASN1_d2i_bio_of(OCSP_REQUEST, OCSP_REQUEST_new, d2i_OCSP_REQUEST, bp, p)
+
+#define d2i_OCSP_RESPONSE_bio(bp, p) ASN1_d2i_bio_of(OCSP_RESPONSE, OCSP_RESPONSE_new, d2i_OCSP_RESPONSE, bp, p)
+
+#define PEM_read_bio_OCSP_REQUEST(bp, x, cb) (OCSP_REQUEST*)PEM_ASN1_read_bio(        \
+    (char* (*)())d2i_OCSP_REQUEST, PEM_STRING_OCSP_REQUEST, bp, (char**)(x), cb, NULL \
+)
+
+#define PEM_read_bio_OCSP_RESPONSE(bp, x, cb) (OCSP_RESPONSE*)PEM_ASN1_read_bio(        \
+    (char* (*)())d2i_OCSP_RESPONSE, PEM_STRING_OCSP_RESPONSE, bp, (char**)(x), cb, NULL \
+)
+
+#define PEM_write_bio_OCSP_REQUEST(bp, o) \
+    PEM_ASN1_write_bio((int (*)())i2d_OCSP_REQUEST, PEM_STRING_OCSP_REQUEST, bp, (char*)(o), NULL, NULL, 0, NULL, NULL)
+
+#define PEM_write_bio_OCSP_RESPONSE(bp, o) \
+    PEM_ASN1_write_bio((int (*)())i2d_OCSP_RESPONSE, PEM_STRING_OCSP_RESPONSE, bp, (char*)(o), NULL, NULL, 0, NULL, NULL)
+
+#define i2d_OCSP_RESPONSE_bio(bp, o) ASN1_i2d_bio_of(OCSP_RESPONSE, i2d_OCSP_RESPONSE, bp, o)
 
-typedef struct ocsp_response_data_st OCSP_RESPDATA;
+#define i2d_OCSP_REQUEST_bio(bp, o) ASN1_i2d_bio_of(OCSP_REQUEST, i2d_OCSP_REQUEST, bp, o)
 
-typedef struct ocsp_basic_response_st OCSP_BASICRESP;
+#define ASN1_BIT_STRING_digest(data, type, md, len) \
+    ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING), type, data, md, len)
 
-typedef struct ocsp_crl_id_st OCSP_CRLID;
-typedef struct ocsp_service_locator_st OCSP_SERVICELOC;
+#define OCSP_CERTSTATUS_dup(cs) \
+    (OCSP_CERTSTATUS*)ASN1_dup((i2d_of_void*)i2d_OCSP_CERTSTATUS, (d2i_of_void*)d2i_OCSP_CERTSTATUS, (char*)(cs))
 
-#  define PEM_STRING_OCSP_REQUEST "OCSP REQUEST"
-#  define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE"
-
-#  define d2i_OCSP_REQUEST_bio(bp,p) ASN1_d2i_bio_of(OCSP_REQUEST,OCSP_REQUEST_new,d2i_OCSP_REQUEST,bp,p)
-
-#  define d2i_OCSP_RESPONSE_bio(bp,p) ASN1_d2i_bio_of(OCSP_RESPONSE,OCSP_RESPONSE_new,d2i_OCSP_RESPONSE,bp,p)
-
-#  define PEM_read_bio_OCSP_REQUEST(bp,x,cb) (OCSP_REQUEST *)PEM_ASN1_read_bio( \
-     (char *(*)())d2i_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST, \
-     bp,(char **)(x),cb,NULL)
-
-#  define PEM_read_bio_OCSP_RESPONSE(bp,x,cb) (OCSP_RESPONSE *)PEM_ASN1_read_bio(\
-     (char *(*)())d2i_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE, \
-     bp,(char **)(x),cb,NULL)
-
-#  define PEM_write_bio_OCSP_REQUEST(bp,o) \
-    PEM_ASN1_write_bio((int (*)())i2d_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,\
-                        bp,(char *)(o), NULL,NULL,0,NULL,NULL)
-
-#  define PEM_write_bio_OCSP_RESPONSE(bp,o) \
-    PEM_ASN1_write_bio((int (*)())i2d_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,\
-                        bp,(char *)(o), NULL,NULL,0,NULL,NULL)
-
-#  define i2d_OCSP_RESPONSE_bio(bp,o) ASN1_i2d_bio_of(OCSP_RESPONSE,i2d_OCSP_RESPONSE,bp,o)
-
-#  define i2d_OCSP_REQUEST_bio(bp,o) ASN1_i2d_bio_of(OCSP_REQUEST,i2d_OCSP_REQUEST,bp,o)
-
-#  define ASN1_BIT_STRING_digest(data,type,md,len) \
-        ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING),type,data,md,len)
-
-#  define OCSP_CERTSTATUS_dup(cs)\
-                (OCSP_CERTSTATUS*)ASN1_dup((i2d_of_void *)i2d_OCSP_CERTSTATUS,\
-                (d2i_of_void *)d2i_OCSP_CERTSTATUS,(char *)(cs))
-
-DECLARE_ASN1_DUP_FUNCTION(OCSP_CERTID)
-
-OSSL_HTTP_REQ_CTX *OCSP_sendreq_new(BIO *io, const char *path,
-                                    const OCSP_REQUEST *req, int buf_size);
-OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, const char *path, OCSP_REQUEST *req);
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef OSSL_HTTP_REQ_CTX OCSP_REQ_CTX;
-#   define OCSP_REQ_CTX_new(io, buf_size) \
-        OSSL_HTTP_REQ_CTX_new(io, io, buf_size)
-#   define OCSP_REQ_CTX_free OSSL_HTTP_REQ_CTX_free
-#   define OCSP_REQ_CTX_http(rctx, op, path) \
-        (OSSL_HTTP_REQ_CTX_set_expected(rctx, NULL, 1 /* asn1 */, 0, 0) && \
-         OSSL_HTTP_REQ_CTX_set_request_line(rctx, strcmp(op, "POST") == 0, \
-                                            NULL, NULL, path))
-#   define OCSP_REQ_CTX_add1_header OSSL_HTTP_REQ_CTX_add1_header
-#   define OCSP_REQ_CTX_i2d(r, it, req) \
-        OSSL_HTTP_REQ_CTX_set1_req(r, "application/ocsp-request", it, req)
-#   define OCSP_REQ_CTX_set1_req(r, req) \
-        OCSP_REQ_CTX_i2d(r, ASN1_ITEM_rptr(OCSP_REQUEST), (ASN1_VALUE *)(req))
-#   define OCSP_REQ_CTX_nbio OSSL_HTTP_REQ_CTX_nbio
-#   define OCSP_REQ_CTX_nbio_d2i OSSL_HTTP_REQ_CTX_nbio_d2i
-#   define OCSP_sendreq_nbio(p, r) \
-        OSSL_HTTP_REQ_CTX_nbio_d2i(r, (ASN1_VALUE **)(p), \
-                                   ASN1_ITEM_rptr(OCSP_RESPONSE))
-#   define OCSP_REQ_CTX_get0_mem_bio OSSL_HTTP_REQ_CTX_get0_mem_bio
-#   define OCSP_set_max_response_length OSSL_HTTP_REQ_CTX_set_max_response_length
-#  endif
-
-OCSP_CERTID *OCSP_cert_to_id(const EVP_MD *dgst, const X509 *subject,
-                             const X509 *issuer);
-
-OCSP_CERTID *OCSP_cert_id_new(const EVP_MD *dgst,
-                              const X509_NAME *issuerName,
-                              const ASN1_BIT_STRING *issuerKey,
-                              const ASN1_INTEGER *serialNumber);
-
-OCSP_ONEREQ *OCSP_request_add0_id(OCSP_REQUEST *req, OCSP_CERTID *cid);
-
-int OCSP_request_add1_nonce(OCSP_REQUEST *req, unsigned char *val, int len);
-int OCSP_basic_add1_nonce(OCSP_BASICRESP *resp, unsigned char *val, int len);
-int OCSP_check_nonce(OCSP_REQUEST *req, OCSP_BASICRESP *bs);
-int OCSP_copy_nonce(OCSP_BASICRESP *resp, OCSP_REQUEST *req);
-
-int OCSP_request_set1_name(OCSP_REQUEST *req, const X509_NAME *nm);
-int OCSP_request_add1_cert(OCSP_REQUEST *req, X509 *cert);
-
-int OCSP_request_sign(OCSP_REQUEST *req,
-                      X509 *signer,
-                      EVP_PKEY *key,
-                      const EVP_MD *dgst,
-                      STACK_OF(X509) *certs, unsigned long flags);
-
-int OCSP_response_status(OCSP_RESPONSE *resp);
-OCSP_BASICRESP *OCSP_response_get1_basic(OCSP_RESPONSE *resp);
-
-const ASN1_OCTET_STRING *OCSP_resp_get0_signature(const OCSP_BASICRESP *bs);
-const X509_ALGOR *OCSP_resp_get0_tbs_sigalg(const OCSP_BASICRESP *bs);
-const OCSP_RESPDATA *OCSP_resp_get0_respdata(const OCSP_BASICRESP *bs);
-int OCSP_resp_get0_signer(OCSP_BASICRESP *bs, X509 **signer,
-                          STACK_OF(X509) *extra_certs);
-
-int OCSP_resp_count(OCSP_BASICRESP *bs);
-OCSP_SINGLERESP *OCSP_resp_get0(OCSP_BASICRESP *bs, int idx);
-const ASN1_GENERALIZEDTIME *OCSP_resp_get0_produced_at(const OCSP_BASICRESP* bs);
-const STACK_OF(X509) *OCSP_resp_get0_certs(const OCSP_BASICRESP *bs);
-int OCSP_resp_get0_id(const OCSP_BASICRESP *bs,
-                      const ASN1_OCTET_STRING **pid,
-                      const X509_NAME **pname);
-int OCSP_resp_get1_id(const OCSP_BASICRESP *bs,
-                      ASN1_OCTET_STRING **pid,
-                      X509_NAME **pname);
-
-int OCSP_resp_find(OCSP_BASICRESP *bs, OCSP_CERTID *id, int last);
-int OCSP_single_get0_status(OCSP_SINGLERESP *single, int *reason,
-                            ASN1_GENERALIZEDTIME **revtime,
-                            ASN1_GENERALIZEDTIME **thisupd,
-                            ASN1_GENERALIZEDTIME **nextupd);
-int OCSP_resp_find_status(OCSP_BASICRESP *bs, OCSP_CERTID *id, int *status,
-                          int *reason,
-                          ASN1_GENERALIZEDTIME **revtime,
-                          ASN1_GENERALIZEDTIME **thisupd,
-                          ASN1_GENERALIZEDTIME **nextupd);
-int OCSP_check_validity(ASN1_GENERALIZEDTIME *thisupd,
-                        ASN1_GENERALIZEDTIME *nextupd, long sec, long maxsec);
-
-int OCSP_request_verify(OCSP_REQUEST *req, STACK_OF(X509) *certs,
-                        X509_STORE *store, unsigned long flags);
-
-#  define OCSP_parse_url(url, host, port, path, ssl) \
+    DECLARE_ASN1_DUP_FUNCTION(OCSP_CERTID)
+
+    OSSL_HTTP_REQ_CTX* OCSP_sendreq_new(BIO* io, const char* path, const OCSP_REQUEST* req, int buf_size);
+    OCSP_RESPONSE* OCSP_sendreq_bio(BIO* b, const char* path, OCSP_REQUEST* req);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef OSSL_HTTP_REQ_CTX OCSP_REQ_CTX;
+#define OCSP_REQ_CTX_new(io, buf_size) \
+    OSSL_HTTP_REQ_CTX_new(io, io, buf_size)
+#define OCSP_REQ_CTX_free OSSL_HTTP_REQ_CTX_free
+#define OCSP_REQ_CTX_http(rctx, op, path)                              \
+    (OSSL_HTTP_REQ_CTX_set_expected(rctx, NULL, 1 /* asn1 */, 0, 0) && \
+     OSSL_HTTP_REQ_CTX_set_request_line(rctx, strcmp(op, "POST") == 0, NULL, NULL, path))
+#define OCSP_REQ_CTX_add1_header OSSL_HTTP_REQ_CTX_add1_header
+#define OCSP_REQ_CTX_i2d(r, it, req) \
+    OSSL_HTTP_REQ_CTX_set1_req(r, "application/ocsp-request", it, req)
+#define OCSP_REQ_CTX_set1_req(r, req) \
+    OCSP_REQ_CTX_i2d(r, ASN1_ITEM_rptr(OCSP_REQUEST), (ASN1_VALUE*)(req))
+#define OCSP_REQ_CTX_nbio OSSL_HTTP_REQ_CTX_nbio
+#define OCSP_REQ_CTX_nbio_d2i OSSL_HTTP_REQ_CTX_nbio_d2i
+#define OCSP_sendreq_nbio(p, r) \
+    OSSL_HTTP_REQ_CTX_nbio_d2i(r, (ASN1_VALUE**)(p), ASN1_ITEM_rptr(OCSP_RESPONSE))
+#define OCSP_REQ_CTX_get0_mem_bio OSSL_HTTP_REQ_CTX_get0_mem_bio
+#define OCSP_set_max_response_length OSSL_HTTP_REQ_CTX_set_max_response_length
+#endif
+
+    OCSP_CERTID* OCSP_cert_to_id(const EVP_MD* dgst, const X509* subject, const X509* issuer);
+
+    OCSP_CERTID* OCSP_cert_id_new(const EVP_MD* dgst, const X509_NAME* issuerName, const ASN1_BIT_STRING* issuerKey, const ASN1_INTEGER* serialNumber);
+
+    OCSP_ONEREQ* OCSP_request_add0_id(OCSP_REQUEST* req, OCSP_CERTID* cid);
+
+    int OCSP_request_add1_nonce(OCSP_REQUEST* req, unsigned char* val, int len);
+    int OCSP_basic_add1_nonce(OCSP_BASICRESP* resp, unsigned char* val, int len);
+    int OCSP_check_nonce(OCSP_REQUEST* req, OCSP_BASICRESP* bs);
+    int OCSP_copy_nonce(OCSP_BASICRESP* resp, OCSP_REQUEST* req);
+
+    int OCSP_request_set1_name(OCSP_REQUEST* req, const X509_NAME* nm);
+    int OCSP_request_add1_cert(OCSP_REQUEST* req, X509* cert);
+
+    int OCSP_request_sign(OCSP_REQUEST* req, X509* signer, EVP_PKEY* key, const EVP_MD* dgst, STACK_OF(X509) * certs, unsigned long flags);
+
+    int OCSP_response_status(OCSP_RESPONSE* resp);
+    OCSP_BASICRESP* OCSP_response_get1_basic(OCSP_RESPONSE* resp);
+
+    const ASN1_OCTET_STRING* OCSP_resp_get0_signature(const OCSP_BASICRESP* bs);
+    const X509_ALGOR* OCSP_resp_get0_tbs_sigalg(const OCSP_BASICRESP* bs);
+    const OCSP_RESPDATA* OCSP_resp_get0_respdata(const OCSP_BASICRESP* bs);
+    int OCSP_resp_get0_signer(OCSP_BASICRESP* bs, X509** signer, STACK_OF(X509) * extra_certs);
+
+    int OCSP_resp_count(OCSP_BASICRESP* bs);
+    OCSP_SINGLERESP* OCSP_resp_get0(OCSP_BASICRESP* bs, int idx);
+    const ASN1_GENERALIZEDTIME* OCSP_resp_get0_produced_at(const OCSP_BASICRESP* bs);
+    const STACK_OF(X509) * OCSP_resp_get0_certs(const OCSP_BASICRESP* bs);
+    int OCSP_resp_get0_id(const OCSP_BASICRESP* bs, const ASN1_OCTET_STRING** pid, const X509_NAME** pname);
+    int OCSP_resp_get1_id(const OCSP_BASICRESP* bs, ASN1_OCTET_STRING** pid, X509_NAME** pname);
+
+    int OCSP_resp_find(OCSP_BASICRESP* bs, OCSP_CERTID* id, int last);
+    int OCSP_single_get0_status(OCSP_SINGLERESP* single, int* reason, ASN1_GENERALIZEDTIME** revtime, ASN1_GENERALIZEDTIME** thisupd, ASN1_GENERALIZEDTIME** nextupd);
+    int OCSP_resp_find_status(OCSP_BASICRESP* bs, OCSP_CERTID* id, int* status, int* reason, ASN1_GENERALIZEDTIME** revtime, ASN1_GENERALIZEDTIME** thisupd, ASN1_GENERALIZEDTIME** nextupd);
+    int OCSP_check_validity(ASN1_GENERALIZEDTIME* thisupd, ASN1_GENERALIZEDTIME* nextupd, long sec, long maxsec);
+
+    int OCSP_request_verify(OCSP_REQUEST* req, STACK_OF(X509) * certs, X509_STORE* store, unsigned long flags);
+
+#define OCSP_parse_url(url, host, port, path, ssl) \
     OSSL_HTTP_parse_url(url, ssl, NULL, host, port, NULL, path, NULL, NULL)
 
-int OCSP_id_issuer_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b);
-int OCSP_id_cmp(const OCSP_CERTID *a, const OCSP_CERTID *b);
-
-int OCSP_request_onereq_count(OCSP_REQUEST *req);
-OCSP_ONEREQ *OCSP_request_onereq_get0(OCSP_REQUEST *req, int i);
-OCSP_CERTID *OCSP_onereq_get0_id(OCSP_ONEREQ *one);
-int OCSP_id_get0_info(ASN1_OCTET_STRING **piNameHash, ASN1_OBJECT **pmd,
-                      ASN1_OCTET_STRING **pikeyHash,
-                      ASN1_INTEGER **pserial, OCSP_CERTID *cid);
-int OCSP_request_is_signed(OCSP_REQUEST *req);
-OCSP_RESPONSE *OCSP_response_create(int status, OCSP_BASICRESP *bs);
-OCSP_SINGLERESP *OCSP_basic_add1_status(OCSP_BASICRESP *rsp,
-                                        OCSP_CERTID *cid,
-                                        int status, int reason,
-                                        ASN1_TIME *revtime,
-                                        ASN1_TIME *thisupd,
-                                        ASN1_TIME *nextupd);
-int OCSP_basic_add1_cert(OCSP_BASICRESP *resp, X509 *cert);
-int OCSP_basic_sign(OCSP_BASICRESP *brsp,
-                    X509 *signer, EVP_PKEY *key, const EVP_MD *dgst,
-                    STACK_OF(X509) *certs, unsigned long flags);
-int OCSP_basic_sign_ctx(OCSP_BASICRESP *brsp,
-                        X509 *signer, EVP_MD_CTX *ctx,
-                        STACK_OF(X509) *certs, unsigned long flags);
-int OCSP_RESPID_set_by_name(OCSP_RESPID *respid, X509 *cert);
-int OCSP_RESPID_set_by_key_ex(OCSP_RESPID *respid, X509 *cert,
-                              OSSL_LIB_CTX *libctx, const char *propq);
-int OCSP_RESPID_set_by_key(OCSP_RESPID *respid, X509 *cert);
-int OCSP_RESPID_match_ex(OCSP_RESPID *respid, X509 *cert, OSSL_LIB_CTX *libctx,
-                         const char *propq);
-int OCSP_RESPID_match(OCSP_RESPID *respid, X509 *cert);
-
-X509_EXTENSION *OCSP_crlID_new(const char *url, long *n, char *tim);
-
-X509_EXTENSION *OCSP_accept_responses_new(char **oids);
-
-X509_EXTENSION *OCSP_archive_cutoff_new(char *tim);
-
-X509_EXTENSION *OCSP_url_svcloc_new(const X509_NAME *issuer, const char **urls);
-
-int OCSP_REQUEST_get_ext_count(OCSP_REQUEST *x);
-int OCSP_REQUEST_get_ext_by_NID(OCSP_REQUEST *x, int nid, int lastpos);
-int OCSP_REQUEST_get_ext_by_OBJ(OCSP_REQUEST *x, const ASN1_OBJECT *obj,
-                                int lastpos);
-int OCSP_REQUEST_get_ext_by_critical(OCSP_REQUEST *x, int crit, int lastpos);
-X509_EXTENSION *OCSP_REQUEST_get_ext(OCSP_REQUEST *x, int loc);
-X509_EXTENSION *OCSP_REQUEST_delete_ext(OCSP_REQUEST *x, int loc);
-void *OCSP_REQUEST_get1_ext_d2i(OCSP_REQUEST *x, int nid, int *crit,
-                                int *idx);
-int OCSP_REQUEST_add1_ext_i2d(OCSP_REQUEST *x, int nid, void *value, int crit,
-                              unsigned long flags);
-int OCSP_REQUEST_add_ext(OCSP_REQUEST *x, X509_EXTENSION *ex, int loc);
-
-int OCSP_ONEREQ_get_ext_count(OCSP_ONEREQ *x);
-int OCSP_ONEREQ_get_ext_by_NID(OCSP_ONEREQ *x, int nid, int lastpos);
-int OCSP_ONEREQ_get_ext_by_OBJ(OCSP_ONEREQ *x, const ASN1_OBJECT *obj, int lastpos);
-int OCSP_ONEREQ_get_ext_by_critical(OCSP_ONEREQ *x, int crit, int lastpos);
-X509_EXTENSION *OCSP_ONEREQ_get_ext(OCSP_ONEREQ *x, int loc);
-X509_EXTENSION *OCSP_ONEREQ_delete_ext(OCSP_ONEREQ *x, int loc);
-void *OCSP_ONEREQ_get1_ext_d2i(OCSP_ONEREQ *x, int nid, int *crit, int *idx);
-int OCSP_ONEREQ_add1_ext_i2d(OCSP_ONEREQ *x, int nid, void *value, int crit,
-                             unsigned long flags);
-int OCSP_ONEREQ_add_ext(OCSP_ONEREQ *x, X509_EXTENSION *ex, int loc);
-
-int OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP *x);
-int OCSP_BASICRESP_get_ext_by_NID(OCSP_BASICRESP *x, int nid, int lastpos);
-int OCSP_BASICRESP_get_ext_by_OBJ(OCSP_BASICRESP *x, const ASN1_OBJECT *obj,
-                                  int lastpos);
-int OCSP_BASICRESP_get_ext_by_critical(OCSP_BASICRESP *x, int crit,
-                                       int lastpos);
-X509_EXTENSION *OCSP_BASICRESP_get_ext(OCSP_BASICRESP *x, int loc);
-X509_EXTENSION *OCSP_BASICRESP_delete_ext(OCSP_BASICRESP *x, int loc);
-void *OCSP_BASICRESP_get1_ext_d2i(OCSP_BASICRESP *x, int nid, int *crit,
-                                  int *idx);
-int OCSP_BASICRESP_add1_ext_i2d(OCSP_BASICRESP *x, int nid, void *value,
-                                int crit, unsigned long flags);
-int OCSP_BASICRESP_add_ext(OCSP_BASICRESP *x, X509_EXTENSION *ex, int loc);
-
-int OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP *x);
-int OCSP_SINGLERESP_get_ext_by_NID(OCSP_SINGLERESP *x, int nid, int lastpos);
-int OCSP_SINGLERESP_get_ext_by_OBJ(OCSP_SINGLERESP *x, const ASN1_OBJECT *obj,
-                                   int lastpos);
-int OCSP_SINGLERESP_get_ext_by_critical(OCSP_SINGLERESP *x, int crit,
-                                        int lastpos);
-X509_EXTENSION *OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP *x, int loc);
-X509_EXTENSION *OCSP_SINGLERESP_delete_ext(OCSP_SINGLERESP *x, int loc);
-void *OCSP_SINGLERESP_get1_ext_d2i(OCSP_SINGLERESP *x, int nid, int *crit,
-                                   int *idx);
-int OCSP_SINGLERESP_add1_ext_i2d(OCSP_SINGLERESP *x, int nid, void *value,
-                                 int crit, unsigned long flags);
-int OCSP_SINGLERESP_add_ext(OCSP_SINGLERESP *x, X509_EXTENSION *ex, int loc);
-const OCSP_CERTID *OCSP_SINGLERESP_get0_id(const OCSP_SINGLERESP *x);
-
-DECLARE_ASN1_FUNCTIONS(OCSP_SINGLERESP)
-DECLARE_ASN1_FUNCTIONS(OCSP_CERTSTATUS)
-DECLARE_ASN1_FUNCTIONS(OCSP_REVOKEDINFO)
-DECLARE_ASN1_FUNCTIONS(OCSP_BASICRESP)
-DECLARE_ASN1_FUNCTIONS(OCSP_RESPDATA)
-DECLARE_ASN1_FUNCTIONS(OCSP_RESPID)
-DECLARE_ASN1_FUNCTIONS(OCSP_RESPONSE)
-DECLARE_ASN1_FUNCTIONS(OCSP_RESPBYTES)
-DECLARE_ASN1_FUNCTIONS(OCSP_ONEREQ)
-DECLARE_ASN1_FUNCTIONS(OCSP_CERTID)
-DECLARE_ASN1_FUNCTIONS(OCSP_REQUEST)
-DECLARE_ASN1_FUNCTIONS(OCSP_SIGNATURE)
-DECLARE_ASN1_FUNCTIONS(OCSP_REQINFO)
-DECLARE_ASN1_FUNCTIONS(OCSP_CRLID)
-DECLARE_ASN1_FUNCTIONS(OCSP_SERVICELOC)
-
-const char *OCSP_response_status_str(long s);
-const char *OCSP_cert_status_str(long s);
-const char *OCSP_crl_reason_str(long s);
-
-int OCSP_REQUEST_print(BIO *bp, OCSP_REQUEST *a, unsigned long flags);
-int OCSP_RESPONSE_print(BIO *bp, OCSP_RESPONSE *o, unsigned long flags);
-
-int OCSP_basic_verify(OCSP_BASICRESP *bs, STACK_OF(X509) *certs,
-                      X509_STORE *st, unsigned long flags);
-
-
-#  ifdef  __cplusplus
+    int OCSP_id_issuer_cmp(const OCSP_CERTID* a, const OCSP_CERTID* b);
+    int OCSP_id_cmp(const OCSP_CERTID* a, const OCSP_CERTID* b);
+
+    int OCSP_request_onereq_count(OCSP_REQUEST* req);
+    OCSP_ONEREQ* OCSP_request_onereq_get0(OCSP_REQUEST* req, int i);
+    OCSP_CERTID* OCSP_onereq_get0_id(OCSP_ONEREQ* one);
+    int OCSP_id_get0_info(ASN1_OCTET_STRING** piNameHash, ASN1_OBJECT** pmd, ASN1_OCTET_STRING** pikeyHash, ASN1_INTEGER** pserial, OCSP_CERTID* cid);
+    int OCSP_request_is_signed(OCSP_REQUEST* req);
+    OCSP_RESPONSE* OCSP_response_create(int status, OCSP_BASICRESP* bs);
+    OCSP_SINGLERESP* OCSP_basic_add1_status(OCSP_BASICRESP* rsp, OCSP_CERTID* cid, int status, int reason, ASN1_TIME* revtime, ASN1_TIME* thisupd, ASN1_TIME* nextupd);
+    int OCSP_basic_add1_cert(OCSP_BASICRESP* resp, X509* cert);
+    int OCSP_basic_sign(OCSP_BASICRESP* brsp, X509* signer, EVP_PKEY* key, const EVP_MD* dgst, STACK_OF(X509) * certs, unsigned long flags);
+    int OCSP_basic_sign_ctx(OCSP_BASICRESP* brsp, X509* signer, EVP_MD_CTX* ctx, STACK_OF(X509) * certs, unsigned long flags);
+    int OCSP_RESPID_set_by_name(OCSP_RESPID* respid, X509* cert);
+    int OCSP_RESPID_set_by_key_ex(OCSP_RESPID* respid, X509* cert, OSSL_LIB_CTX* libctx, const char* propq);
+    int OCSP_RESPID_set_by_key(OCSP_RESPID* respid, X509* cert);
+    int OCSP_RESPID_match_ex(OCSP_RESPID* respid, X509* cert, OSSL_LIB_CTX* libctx, const char* propq);
+    int OCSP_RESPID_match(OCSP_RESPID* respid, X509* cert);
+
+    X509_EXTENSION* OCSP_crlID_new(const char* url, long* n, char* tim);
+
+    X509_EXTENSION* OCSP_accept_responses_new(char** oids);
+
+    X509_EXTENSION* OCSP_archive_cutoff_new(char* tim);
+
+    X509_EXTENSION* OCSP_url_svcloc_new(const X509_NAME* issuer, const char** urls);
+
+    int OCSP_REQUEST_get_ext_count(OCSP_REQUEST* x);
+    int OCSP_REQUEST_get_ext_by_NID(OCSP_REQUEST* x, int nid, int lastpos);
+    int OCSP_REQUEST_get_ext_by_OBJ(OCSP_REQUEST* x, const ASN1_OBJECT* obj, int lastpos);
+    int OCSP_REQUEST_get_ext_by_critical(OCSP_REQUEST* x, int crit, int lastpos);
+    X509_EXTENSION* OCSP_REQUEST_get_ext(OCSP_REQUEST* x, int loc);
+    X509_EXTENSION* OCSP_REQUEST_delete_ext(OCSP_REQUEST* x, int loc);
+    void* OCSP_REQUEST_get1_ext_d2i(OCSP_REQUEST* x, int nid, int* crit, int* idx);
+    int OCSP_REQUEST_add1_ext_i2d(OCSP_REQUEST* x, int nid, void* value, int crit, unsigned long flags);
+    int OCSP_REQUEST_add_ext(OCSP_REQUEST* x, X509_EXTENSION* ex, int loc);
+
+    int OCSP_ONEREQ_get_ext_count(OCSP_ONEREQ* x);
+    int OCSP_ONEREQ_get_ext_by_NID(OCSP_ONEREQ* x, int nid, int lastpos);
+    int OCSP_ONEREQ_get_ext_by_OBJ(OCSP_ONEREQ* x, const ASN1_OBJECT* obj, int lastpos);
+    int OCSP_ONEREQ_get_ext_by_critical(OCSP_ONEREQ* x, int crit, int lastpos);
+    X509_EXTENSION* OCSP_ONEREQ_get_ext(OCSP_ONEREQ* x, int loc);
+    X509_EXTENSION* OCSP_ONEREQ_delete_ext(OCSP_ONEREQ* x, int loc);
+    void* OCSP_ONEREQ_get1_ext_d2i(OCSP_ONEREQ* x, int nid, int* crit, int* idx);
+    int OCSP_ONEREQ_add1_ext_i2d(OCSP_ONEREQ* x, int nid, void* value, int crit, unsigned long flags);
+    int OCSP_ONEREQ_add_ext(OCSP_ONEREQ* x, X509_EXTENSION* ex, int loc);
+
+    int OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP* x);
+    int OCSP_BASICRESP_get_ext_by_NID(OCSP_BASICRESP* x, int nid, int lastpos);
+    int OCSP_BASICRESP_get_ext_by_OBJ(OCSP_BASICRESP* x, const ASN1_OBJECT* obj, int lastpos);
+    int OCSP_BASICRESP_get_ext_by_critical(OCSP_BASICRESP* x, int crit, int lastpos);
+    X509_EXTENSION* OCSP_BASICRESP_get_ext(OCSP_BASICRESP* x, int loc);
+    X509_EXTENSION* OCSP_BASICRESP_delete_ext(OCSP_BASICRESP* x, int loc);
+    void* OCSP_BASICRESP_get1_ext_d2i(OCSP_BASICRESP* x, int nid, int* crit, int* idx);
+    int OCSP_BASICRESP_add1_ext_i2d(OCSP_BASICRESP* x, int nid, void* value, int crit, unsigned long flags);
+    int OCSP_BASICRESP_add_ext(OCSP_BASICRESP* x, X509_EXTENSION* ex, int loc);
+
+    int OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP* x);
+    int OCSP_SINGLERESP_get_ext_by_NID(OCSP_SINGLERESP* x, int nid, int lastpos);
+    int OCSP_SINGLERESP_get_ext_by_OBJ(OCSP_SINGLERESP* x, const ASN1_OBJECT* obj, int lastpos);
+    int OCSP_SINGLERESP_get_ext_by_critical(OCSP_SINGLERESP* x, int crit, int lastpos);
+    X509_EXTENSION* OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP* x, int loc);
+    X509_EXTENSION* OCSP_SINGLERESP_delete_ext(OCSP_SINGLERESP* x, int loc);
+    void* OCSP_SINGLERESP_get1_ext_d2i(OCSP_SINGLERESP* x, int nid, int* crit, int* idx);
+    int OCSP_SINGLERESP_add1_ext_i2d(OCSP_SINGLERESP* x, int nid, void* value, int crit, unsigned long flags);
+    int OCSP_SINGLERESP_add_ext(OCSP_SINGLERESP* x, X509_EXTENSION* ex, int loc);
+    const OCSP_CERTID* OCSP_SINGLERESP_get0_id(const OCSP_SINGLERESP* x);
+
+    DECLARE_ASN1_FUNCTIONS(OCSP_SINGLERESP)
+    DECLARE_ASN1_FUNCTIONS(OCSP_CERTSTATUS)
+    DECLARE_ASN1_FUNCTIONS(OCSP_REVOKEDINFO)
+    DECLARE_ASN1_FUNCTIONS(OCSP_BASICRESP)
+    DECLARE_ASN1_FUNCTIONS(OCSP_RESPDATA)
+    DECLARE_ASN1_FUNCTIONS(OCSP_RESPID)
+    DECLARE_ASN1_FUNCTIONS(OCSP_RESPONSE)
+    DECLARE_ASN1_FUNCTIONS(OCSP_RESPBYTES)
+    DECLARE_ASN1_FUNCTIONS(OCSP_ONEREQ)
+    DECLARE_ASN1_FUNCTIONS(OCSP_CERTID)
+    DECLARE_ASN1_FUNCTIONS(OCSP_REQUEST)
+    DECLARE_ASN1_FUNCTIONS(OCSP_SIGNATURE)
+    DECLARE_ASN1_FUNCTIONS(OCSP_REQINFO)
+    DECLARE_ASN1_FUNCTIONS(OCSP_CRLID)
+    DECLARE_ASN1_FUNCTIONS(OCSP_SERVICELOC)
+
+    const char* OCSP_response_status_str(long s);
+    const char* OCSP_cert_status_str(long s);
+    const char* OCSP_crl_reason_str(long s);
+
+    int OCSP_REQUEST_print(BIO* bp, OCSP_REQUEST* a, unsigned long flags);
+    int OCSP_RESPONSE_print(BIO* bp, OCSP_RESPONSE* o, unsigned long flags);
+
+    int OCSP_basic_verify(OCSP_BASICRESP* bs, STACK_OF(X509) * certs, X509_STORE* st, unsigned long flags);
+
+#ifdef __cplusplus
 }
-#  endif
-# endif /* !defined(OPENSSL_NO_OCSP) */
+#endif
+#endif /* !defined(OPENSSL_NO_OCSP) */
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ocsperr.h b/CAPI/cpp/grpc/include/openssl/ocsperr.h
index 46a0523..18e035e 100644
--- a/CAPI/cpp/grpc/include/openssl/ocsperr.h
+++ b/CAPI/cpp/grpc/include/openssl/ocsperr.h
@@ -9,45 +9,43 @@
  */
 
 #ifndef OPENSSL_OCSPERR_H
-# define OPENSSL_OCSPERR_H
-# pragma once
+#define OPENSSL_OCSPERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_OCSP
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_OCSP
 
 /*
  * OCSP reason codes.
  */
-#  define OCSP_R_CERTIFICATE_VERIFY_ERROR                  101
-#  define OCSP_R_DIGEST_ERR                                102
-#  define OCSP_R_DIGEST_NAME_ERR                           106
-#  define OCSP_R_DIGEST_SIZE_ERR                           107
-#  define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD                 122
-#  define OCSP_R_ERROR_IN_THISUPDATE_FIELD                 123
-#  define OCSP_R_MISSING_OCSPSIGNING_USAGE                 103
-#  define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE              124
-#  define OCSP_R_NOT_BASIC_RESPONSE                        104
-#  define OCSP_R_NO_CERTIFICATES_IN_CHAIN                  105
-#  define OCSP_R_NO_RESPONSE_DATA                          108
-#  define OCSP_R_NO_REVOKED_TIME                           109
-#  define OCSP_R_NO_SIGNER_KEY                             130
-#  define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE    110
-#  define OCSP_R_REQUEST_NOT_SIGNED                        128
-#  define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA      111
-#  define OCSP_R_ROOT_CA_NOT_TRUSTED                       112
-#  define OCSP_R_SIGNATURE_FAILURE                         117
-#  define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND              118
-#  define OCSP_R_STATUS_EXPIRED                            125
-#  define OCSP_R_STATUS_NOT_YET_VALID                      126
-#  define OCSP_R_STATUS_TOO_OLD                            127
-#  define OCSP_R_UNKNOWN_MESSAGE_DIGEST                    119
-#  define OCSP_R_UNKNOWN_NID                               120
-#  define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE            129
+#define OCSP_R_CERTIFICATE_VERIFY_ERROR 101
+#define OCSP_R_DIGEST_ERR 102
+#define OCSP_R_DIGEST_NAME_ERR 106
+#define OCSP_R_DIGEST_SIZE_ERR 107
+#define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD 122
+#define OCSP_R_ERROR_IN_THISUPDATE_FIELD 123
+#define OCSP_R_MISSING_OCSPSIGNING_USAGE 103
+#define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE 124
+#define OCSP_R_NOT_BASIC_RESPONSE 104
+#define OCSP_R_NO_CERTIFICATES_IN_CHAIN 105
+#define OCSP_R_NO_RESPONSE_DATA 108
+#define OCSP_R_NO_REVOKED_TIME 109
+#define OCSP_R_NO_SIGNER_KEY 130
+#define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 110
+#define OCSP_R_REQUEST_NOT_SIGNED 128
+#define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA 111
+#define OCSP_R_ROOT_CA_NOT_TRUSTED 112
+#define OCSP_R_SIGNATURE_FAILURE 117
+#define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND 118
+#define OCSP_R_STATUS_EXPIRED 125
+#define OCSP_R_STATUS_NOT_YET_VALID 126
+#define OCSP_R_STATUS_TOO_OLD 127
+#define OCSP_R_UNKNOWN_MESSAGE_DIGEST 119
+#define OCSP_R_UNKNOWN_NID 120
+#define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE 129
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/opensslconf.h b/CAPI/cpp/grpc/include/openssl/opensslconf.h
index 1e83371..4a8d78e 100644
--- a/CAPI/cpp/grpc/include/openssl/opensslconf.h
+++ b/CAPI/cpp/grpc/include/openssl/opensslconf.h
@@ -8,10 +8,10 @@
  */
 
 #ifndef OPENSSL_OPENSSLCONF_H
-# define OPENSSL_OPENSSLCONF_H
-# pragma once
+#define OPENSSL_OPENSSLCONF_H
+#pragma once
 
-# include <openssl/configuration.h>
-# include <openssl/macros.h>
+#include <openssl/configuration.h>
+#include <openssl/macros.h>
 
-#endif  /* OPENSSL_OPENSSLCONF_H */
+#endif /* OPENSSL_OPENSSLCONF_H */
diff --git a/CAPI/cpp/grpc/include/openssl/opensslv.h b/CAPI/cpp/grpc/include/openssl/opensslv.h
index 028ae24..70b5001 100644
--- a/CAPI/cpp/grpc/include/openssl/opensslv.h
+++ b/CAPI/cpp/grpc/include/openssl/opensslv.h
@@ -11,12 +11,13 @@
  */
 
 #ifndef OPENSSL_OPENSSLV_H
-# define OPENSSL_OPENSSLV_H
-# pragma once
+#define OPENSSL_OPENSSLV_H
+#pragma once
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /*
  * SECTION 1: VERSION DATA.  These will change for each release
@@ -27,9 +28,9 @@ extern "C" {
  *
  * These macros express version number MAJOR.MINOR.PATCH exactly
  */
-# define OPENSSL_VERSION_MAJOR  3
-# define OPENSSL_VERSION_MINOR  0
-# define OPENSSL_VERSION_PATCH  5
+#define OPENSSL_VERSION_MAJOR 3
+#define OPENSSL_VERSION_MINOR 0
+#define OPENSSL_VERSION_PATCH 5
 
 /*
  * Additional version information
@@ -39,10 +40,10 @@ extern "C" {
  */
 
 /* Could be: #define OPENSSL_VERSION_PRE_RELEASE "-alpha.1" */
-# define OPENSSL_VERSION_PRE_RELEASE ""
+#define OPENSSL_VERSION_PRE_RELEASE ""
 /* Could be: #define OPENSSL_VERSION_BUILD_METADATA "+fips" */
 /* Could be: #define OPENSSL_VERSION_BUILD_METADATA "+vendor.1" */
-# define OPENSSL_VERSION_BUILD_METADATA ""
+#define OPENSSL_VERSION_BUILD_METADATA ""
 
 /*
  * Note: The OpenSSL Project will never define OPENSSL_VERSION_BUILD_METADATA
@@ -57,14 +58,14 @@ extern "C" {
  * be related to the API version expressed with the macros above.
  * This is defined in free form.
  */
-# define OPENSSL_SHLIB_VERSION 3
+#define OPENSSL_SHLIB_VERSION 3
 
 /*
  * SECTION 2: USEFUL MACROS
  */
 
 /* For checking general API compatibility when preprocessing */
-# define OPENSSL_VERSION_PREREQ(maj,min)                                \
+#define OPENSSL_VERSION_PREREQ(maj, min) \
     ((OPENSSL_VERSION_MAJOR << 16) + OPENSSL_VERSION_MINOR >= ((maj) << 16) + (min))
 
 /*
@@ -74,41 +75,38 @@ extern "C" {
  * longer variant with OPENSSL_VERSION_PRE_RELEASE_STR and
  * OPENSSL_VERSION_BUILD_METADATA_STR appended.
  */
-# define OPENSSL_VERSION_STR "3.0.5"
-# define OPENSSL_FULL_VERSION_STR "3.0.5"
+#define OPENSSL_VERSION_STR "3.0.5"
+#define OPENSSL_FULL_VERSION_STR "3.0.5"
 
 /*
  * SECTION 3: ADDITIONAL METADATA
  *
  * These strings are defined separately to allow them to be parsable.
  */
-# define OPENSSL_RELEASE_DATE "5 Jul 2022"
+#define OPENSSL_RELEASE_DATE "5 Jul 2022"
 
-/*
- * SECTION 4: BACKWARD COMPATIBILITY
- */
+    /*
+     * SECTION 4: BACKWARD COMPATIBILITY
+     */
 
-# define OPENSSL_VERSION_TEXT "OpenSSL 3.0.5 5 Jul 2022"
+#define OPENSSL_VERSION_TEXT "OpenSSL 3.0.5 5 Jul 2022"
 
 /* Synthesize OPENSSL_VERSION_NUMBER with the layout 0xMNN00PPSL */
-# ifdef OPENSSL_VERSION_PRE_RELEASE
-#  define _OPENSSL_VERSION_PRE_RELEASE 0x0L
-# else
-#  define _OPENSSL_VERSION_PRE_RELEASE 0xfL
-# endif
-# define OPENSSL_VERSION_NUMBER          \
-    ( (OPENSSL_VERSION_MAJOR<<28)        \
-      |(OPENSSL_VERSION_MINOR<<20)       \
-      |(OPENSSL_VERSION_PATCH<<4)        \
-      |_OPENSSL_VERSION_PRE_RELEASE )
-
-# ifdef  __cplusplus
+#ifdef OPENSSL_VERSION_PRE_RELEASE
+#define _OPENSSL_VERSION_PRE_RELEASE 0x0L
+#else
+#define _OPENSSL_VERSION_PRE_RELEASE 0xfL
+#endif
+#define OPENSSL_VERSION_NUMBER \
+    ((OPENSSL_VERSION_MAJOR << 28) | (OPENSSL_VERSION_MINOR << 20) | (OPENSSL_VERSION_PATCH << 4) | _OPENSSL_VERSION_PRE_RELEASE)
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_OPENSSLV_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_OPENSSLV_H
+#endif
 
-#endif                          /* OPENSSL_OPENSSLV_H */
+#endif /* OPENSSL_OPENSSLV_H */
diff --git a/CAPI/cpp/grpc/include/openssl/ossl_typ.h b/CAPI/cpp/grpc/include/openssl/ossl_typ.h
index 82a5898..a562299 100644
--- a/CAPI/cpp/grpc/include/openssl/ossl_typ.h
+++ b/CAPI/cpp/grpc/include/openssl/ossl_typ.h
@@ -13,4 +13,4 @@
  * This header file only exists for compatibility reasons with older
  * applications which #include <openssl/ossl_typ.h>.
  */
-# include <openssl/types.h>
+#include <openssl/types.h>
diff --git a/CAPI/cpp/grpc/include/openssl/param_build.h b/CAPI/cpp/grpc/include/openssl/param_build.h
index f29fdb2..7b6a429 100644
--- a/CAPI/cpp/grpc/include/openssl/param_build.h
+++ b/CAPI/cpp/grpc/include/openssl/param_build.h
@@ -9,55 +9,40 @@
  */
 
 #ifndef OPENSSL_PARAM_BUILD_H
-# define OPENSSL_PARAM_BUILD_H
-# pragma once
+#define OPENSSL_PARAM_BUILD_H
+#pragma once
 
-# include <openssl/params.h>
-# include <openssl/types.h>
+#include <openssl/params.h>
+#include <openssl/types.h>
 
-# ifdef __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-OSSL_PARAM_BLD *OSSL_PARAM_BLD_new(void);
-OSSL_PARAM *OSSL_PARAM_BLD_to_param(OSSL_PARAM_BLD *bld);
-void OSSL_PARAM_BLD_free(OSSL_PARAM_BLD *bld);
+    OSSL_PARAM_BLD* OSSL_PARAM_BLD_new(void);
+    OSSL_PARAM* OSSL_PARAM_BLD_to_param(OSSL_PARAM_BLD* bld);
+    void OSSL_PARAM_BLD_free(OSSL_PARAM_BLD* bld);
 
-int OSSL_PARAM_BLD_push_int(OSSL_PARAM_BLD *bld, const char *key, int val);
-int OSSL_PARAM_BLD_push_uint(OSSL_PARAM_BLD *bld, const char *key,
-                             unsigned int val);
-int OSSL_PARAM_BLD_push_long(OSSL_PARAM_BLD *bld, const char *key,
-                             long int val);
-int OSSL_PARAM_BLD_push_ulong(OSSL_PARAM_BLD *bld, const char *key,
-                              unsigned long int val);
-int OSSL_PARAM_BLD_push_int32(OSSL_PARAM_BLD *bld, const char *key,
-                              int32_t val);
-int OSSL_PARAM_BLD_push_uint32(OSSL_PARAM_BLD *bld, const char *key,
-                               uint32_t val);
-int OSSL_PARAM_BLD_push_int64(OSSL_PARAM_BLD *bld, const char *key,
-                              int64_t val);
-int OSSL_PARAM_BLD_push_uint64(OSSL_PARAM_BLD *bld, const char *key,
-                               uint64_t val);
-int OSSL_PARAM_BLD_push_size_t(OSSL_PARAM_BLD *bld, const char *key,
-                               size_t val);
-int OSSL_PARAM_BLD_push_time_t(OSSL_PARAM_BLD *bld, const char *key,
-                               time_t val);
-int OSSL_PARAM_BLD_push_double(OSSL_PARAM_BLD *bld, const char *key,
-                               double val);
-int OSSL_PARAM_BLD_push_BN(OSSL_PARAM_BLD *bld, const char *key,
-                           const BIGNUM *bn);
-int OSSL_PARAM_BLD_push_BN_pad(OSSL_PARAM_BLD *bld, const char *key,
-                               const BIGNUM *bn, size_t sz);
-int OSSL_PARAM_BLD_push_utf8_string(OSSL_PARAM_BLD *bld, const char *key,
-                                    const char *buf, size_t bsize);
-int OSSL_PARAM_BLD_push_utf8_ptr(OSSL_PARAM_BLD *bld, const char *key,
-                                 char *buf, size_t bsize);
-int OSSL_PARAM_BLD_push_octet_string(OSSL_PARAM_BLD *bld, const char *key,
-                                     const void *buf, size_t bsize);
-int OSSL_PARAM_BLD_push_octet_ptr(OSSL_PARAM_BLD *bld, const char *key,
-                                  void *buf, size_t bsize);
+    int OSSL_PARAM_BLD_push_int(OSSL_PARAM_BLD* bld, const char* key, int val);
+    int OSSL_PARAM_BLD_push_uint(OSSL_PARAM_BLD* bld, const char* key, unsigned int val);
+    int OSSL_PARAM_BLD_push_long(OSSL_PARAM_BLD* bld, const char* key, long int val);
+    int OSSL_PARAM_BLD_push_ulong(OSSL_PARAM_BLD* bld, const char* key, unsigned long int val);
+    int OSSL_PARAM_BLD_push_int32(OSSL_PARAM_BLD* bld, const char* key, int32_t val);
+    int OSSL_PARAM_BLD_push_uint32(OSSL_PARAM_BLD* bld, const char* key, uint32_t val);
+    int OSSL_PARAM_BLD_push_int64(OSSL_PARAM_BLD* bld, const char* key, int64_t val);
+    int OSSL_PARAM_BLD_push_uint64(OSSL_PARAM_BLD* bld, const char* key, uint64_t val);
+    int OSSL_PARAM_BLD_push_size_t(OSSL_PARAM_BLD* bld, const char* key, size_t val);
+    int OSSL_PARAM_BLD_push_time_t(OSSL_PARAM_BLD* bld, const char* key, time_t val);
+    int OSSL_PARAM_BLD_push_double(OSSL_PARAM_BLD* bld, const char* key, double val);
+    int OSSL_PARAM_BLD_push_BN(OSSL_PARAM_BLD* bld, const char* key, const BIGNUM* bn);
+    int OSSL_PARAM_BLD_push_BN_pad(OSSL_PARAM_BLD* bld, const char* key, const BIGNUM* bn, size_t sz);
+    int OSSL_PARAM_BLD_push_utf8_string(OSSL_PARAM_BLD* bld, const char* key, const char* buf, size_t bsize);
+    int OSSL_PARAM_BLD_push_utf8_ptr(OSSL_PARAM_BLD* bld, const char* key, char* buf, size_t bsize);
+    int OSSL_PARAM_BLD_push_octet_string(OSSL_PARAM_BLD* bld, const char* key, const void* buf, size_t bsize);
+    int OSSL_PARAM_BLD_push_octet_ptr(OSSL_PARAM_BLD* bld, const char* key, void* buf, size_t bsize);
 
-# ifdef __cplusplus
+#ifdef __cplusplus
 }
-# endif
-#endif  /* OPENSSL_PARAM_BUILD_H */
+#endif
+#endif /* OPENSSL_PARAM_BUILD_H */
diff --git a/CAPI/cpp/grpc/include/openssl/params.h b/CAPI/cpp/grpc/include/openssl/params.h
index d75eab0..e94256b 100644
--- a/CAPI/cpp/grpc/include/openssl/params.h
+++ b/CAPI/cpp/grpc/include/openssl/params.h
@@ -9,152 +9,141 @@
  */
 
 #ifndef OPENSSL_PARAMS_H
-# define OPENSSL_PARAMS_H
-# pragma once
+#define OPENSSL_PARAMS_H
+#pragma once
 
-# include <openssl/core.h>
-# include <openssl/bn.h>
+#include <openssl/core.h>
+#include <openssl/bn.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# define OSSL_PARAM_UNMODIFIED ((size_t)-1)
+#define OSSL_PARAM_UNMODIFIED ((size_t)-1)
 
-# define OSSL_PARAM_END \
-    { NULL, 0, NULL, 0, 0 }
+#define OSSL_PARAM_END      \
+    {                       \
+        NULL, 0, NULL, 0, 0 \
+    }
 
-# define OSSL_PARAM_DEFN(key, type, addr, sz)    \
-    { (key), (type), (addr), (sz), OSSL_PARAM_UNMODIFIED }
+#define OSSL_PARAM_DEFN(key, type, addr, sz)               \
+    {                                                      \
+        (key), (type), (addr), (sz), OSSL_PARAM_UNMODIFIED \
+    }
 
 /* Basic parameter types without return sizes */
-# define OSSL_PARAM_int(key, addr) \
+#define OSSL_PARAM_int(key, addr) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int))
-# define OSSL_PARAM_uint(key, addr) \
-    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
-                    sizeof(unsigned int))
-# define OSSL_PARAM_long(key, addr) \
+#define OSSL_PARAM_uint(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(unsigned int))
+#define OSSL_PARAM_long(key, addr) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(long int))
-# define OSSL_PARAM_ulong(key, addr) \
-    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
-                    sizeof(unsigned long int))
-# define OSSL_PARAM_int32(key, addr) \
+#define OSSL_PARAM_ulong(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(unsigned long int))
+#define OSSL_PARAM_int32(key, addr) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int32_t))
-# define OSSL_PARAM_uint32(key, addr) \
-    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
-                    sizeof(uint32_t))
-# define OSSL_PARAM_int64(key, addr) \
+#define OSSL_PARAM_uint32(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(uint32_t))
+#define OSSL_PARAM_int64(key, addr) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int64_t))
-# define OSSL_PARAM_uint64(key, addr) \
-    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
-                    sizeof(uint64_t))
-# define OSSL_PARAM_size_t(key, addr) \
+#define OSSL_PARAM_uint64(key, addr) \
+    OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(uint64_t))
+#define OSSL_PARAM_size_t(key, addr) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(size_t))
-# define OSSL_PARAM_time_t(key, addr) \
+#define OSSL_PARAM_time_t(key, addr) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(time_t))
-# define OSSL_PARAM_double(key, addr) \
+#define OSSL_PARAM_double(key, addr) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_REAL, (addr), sizeof(double))
 
-# define OSSL_PARAM_BN(key, bn, sz) \
+#define OSSL_PARAM_BN(key, bn, sz) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (bn), (sz))
-# define OSSL_PARAM_utf8_string(key, addr, sz) \
+#define OSSL_PARAM_utf8_string(key, addr, sz) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_STRING, (addr), sz)
-# define OSSL_PARAM_octet_string(key, addr, sz) \
+#define OSSL_PARAM_octet_string(key, addr, sz) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_STRING, (addr), sz)
 
-# define OSSL_PARAM_utf8_ptr(key, addr, sz) \
+#define OSSL_PARAM_utf8_ptr(key, addr, sz) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_PTR, (addr), sz)
-# define OSSL_PARAM_octet_ptr(key, addr, sz) \
+#define OSSL_PARAM_octet_ptr(key, addr, sz) \
     OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_PTR, (addr), sz)
 
-/* Search an OSSL_PARAM array for a matching name */
-OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key);
-const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key);
-
-/* Basic parameter type run-time construction */
-OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf);
-OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf);
-OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf);
-OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf);
-OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf);
-OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf);
-OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf);
-OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf);
-OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf);
-OSSL_PARAM OSSL_PARAM_construct_time_t(const char *key, time_t *buf);
-OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
-                                   size_t bsize);
-OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf);
-OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
-                                            size_t bsize);
-OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
-                                         size_t bsize);
-OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
-                                             size_t bsize);
-OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
-                                          size_t bsize);
-OSSL_PARAM OSSL_PARAM_construct_end(void);
-
-int OSSL_PARAM_allocate_from_text(OSSL_PARAM *to,
-                                  const OSSL_PARAM *paramdefs,
-                                  const char *key, const char *value,
-                                  size_t value_n, int *found);
-
-int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val);
-int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val);
-int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val);
-int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val);
-int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val);
-int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val);
-int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val);
-int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val);
-int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val);
-int OSSL_PARAM_get_time_t(const OSSL_PARAM *p, time_t *val);
-
-int OSSL_PARAM_set_int(OSSL_PARAM *p, int val);
-int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val);
-int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val);
-int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val);
-int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val);
-int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val);
-int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val);
-int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val);
-int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val);
-int OSSL_PARAM_set_time_t(OSSL_PARAM *p, time_t val);
-
-int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val);
-int OSSL_PARAM_set_double(OSSL_PARAM *p, double val);
-
-int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val);
-int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val);
-
-int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len);
-int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val);
-
-int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
-                                size_t *used_len);
-int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val, size_t len);
-
-int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val);
-int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val);
-
-int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
-                             size_t *used_len);
-int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
-                             size_t used_len);
-
-int OSSL_PARAM_get_utf8_string_ptr(const OSSL_PARAM *p, const char **val);
-int OSSL_PARAM_get_octet_string_ptr(const OSSL_PARAM *p, const void **val,
-                                    size_t *used_len);
-
-int OSSL_PARAM_modified(const OSSL_PARAM *p);
-void OSSL_PARAM_set_all_unmodified(OSSL_PARAM *p);
-
-OSSL_PARAM *OSSL_PARAM_dup(const OSSL_PARAM *p);
-OSSL_PARAM *OSSL_PARAM_merge(const OSSL_PARAM *p1, const OSSL_PARAM *p2);
-void OSSL_PARAM_free(OSSL_PARAM *p);
-
-# ifdef  __cplusplus
+    /* Search an OSSL_PARAM array for a matching name */
+    OSSL_PARAM* OSSL_PARAM_locate(OSSL_PARAM* p, const char* key);
+    const OSSL_PARAM* OSSL_PARAM_locate_const(const OSSL_PARAM* p, const char* key);
+
+    /* Basic parameter type run-time construction */
+    OSSL_PARAM OSSL_PARAM_construct_int(const char* key, int* buf);
+    OSSL_PARAM OSSL_PARAM_construct_uint(const char* key, unsigned int* buf);
+    OSSL_PARAM OSSL_PARAM_construct_long(const char* key, long int* buf);
+    OSSL_PARAM OSSL_PARAM_construct_ulong(const char* key, unsigned long int* buf);
+    OSSL_PARAM OSSL_PARAM_construct_int32(const char* key, int32_t* buf);
+    OSSL_PARAM OSSL_PARAM_construct_uint32(const char* key, uint32_t* buf);
+    OSSL_PARAM OSSL_PARAM_construct_int64(const char* key, int64_t* buf);
+    OSSL_PARAM OSSL_PARAM_construct_uint64(const char* key, uint64_t* buf);
+    OSSL_PARAM OSSL_PARAM_construct_size_t(const char* key, size_t* buf);
+    OSSL_PARAM OSSL_PARAM_construct_time_t(const char* key, time_t* buf);
+    OSSL_PARAM OSSL_PARAM_construct_BN(const char* key, unsigned char* buf, size_t bsize);
+    OSSL_PARAM OSSL_PARAM_construct_double(const char* key, double* buf);
+    OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char* key, char* buf, size_t bsize);
+    OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char* key, char** buf, size_t bsize);
+    OSSL_PARAM OSSL_PARAM_construct_octet_string(const char* key, void* buf, size_t bsize);
+    OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char* key, void** buf, size_t bsize);
+    OSSL_PARAM OSSL_PARAM_construct_end(void);
+
+    int OSSL_PARAM_allocate_from_text(OSSL_PARAM* to, const OSSL_PARAM* paramdefs, const char* key, const char* value, size_t value_n, int* found);
+
+    int OSSL_PARAM_get_int(const OSSL_PARAM* p, int* val);
+    int OSSL_PARAM_get_uint(const OSSL_PARAM* p, unsigned int* val);
+    int OSSL_PARAM_get_long(const OSSL_PARAM* p, long int* val);
+    int OSSL_PARAM_get_ulong(const OSSL_PARAM* p, unsigned long int* val);
+    int OSSL_PARAM_get_int32(const OSSL_PARAM* p, int32_t* val);
+    int OSSL_PARAM_get_uint32(const OSSL_PARAM* p, uint32_t* val);
+    int OSSL_PARAM_get_int64(const OSSL_PARAM* p, int64_t* val);
+    int OSSL_PARAM_get_uint64(const OSSL_PARAM* p, uint64_t* val);
+    int OSSL_PARAM_get_size_t(const OSSL_PARAM* p, size_t* val);
+    int OSSL_PARAM_get_time_t(const OSSL_PARAM* p, time_t* val);
+
+    int OSSL_PARAM_set_int(OSSL_PARAM* p, int val);
+    int OSSL_PARAM_set_uint(OSSL_PARAM* p, unsigned int val);
+    int OSSL_PARAM_set_long(OSSL_PARAM* p, long int val);
+    int OSSL_PARAM_set_ulong(OSSL_PARAM* p, unsigned long int val);
+    int OSSL_PARAM_set_int32(OSSL_PARAM* p, int32_t val);
+    int OSSL_PARAM_set_uint32(OSSL_PARAM* p, uint32_t val);
+    int OSSL_PARAM_set_int64(OSSL_PARAM* p, int64_t val);
+    int OSSL_PARAM_set_uint64(OSSL_PARAM* p, uint64_t val);
+    int OSSL_PARAM_set_size_t(OSSL_PARAM* p, size_t val);
+    int OSSL_PARAM_set_time_t(OSSL_PARAM* p, time_t val);
+
+    int OSSL_PARAM_get_double(const OSSL_PARAM* p, double* val);
+    int OSSL_PARAM_set_double(OSSL_PARAM* p, double val);
+
+    int OSSL_PARAM_get_BN(const OSSL_PARAM* p, BIGNUM** val);
+    int OSSL_PARAM_set_BN(OSSL_PARAM* p, const BIGNUM* val);
+
+    int OSSL_PARAM_get_utf8_string(const OSSL_PARAM* p, char** val, size_t max_len);
+    int OSSL_PARAM_set_utf8_string(OSSL_PARAM* p, const char* val);
+
+    int OSSL_PARAM_get_octet_string(const OSSL_PARAM* p, void** val, size_t max_len, size_t* used_len);
+    int OSSL_PARAM_set_octet_string(OSSL_PARAM* p, const void* val, size_t len);
+
+    int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM* p, const char** val);
+    int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM* p, const char* val);
+
+    int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM* p, const void** val, size_t* used_len);
+    int OSSL_PARAM_set_octet_ptr(OSSL_PARAM* p, const void* val, size_t used_len);
+
+    int OSSL_PARAM_get_utf8_string_ptr(const OSSL_PARAM* p, const char** val);
+    int OSSL_PARAM_get_octet_string_ptr(const OSSL_PARAM* p, const void** val, size_t* used_len);
+
+    int OSSL_PARAM_modified(const OSSL_PARAM* p);
+    void OSSL_PARAM_set_all_unmodified(OSSL_PARAM* p);
+
+    OSSL_PARAM* OSSL_PARAM_dup(const OSSL_PARAM* p);
+    OSSL_PARAM* OSSL_PARAM_merge(const OSSL_PARAM* p1, const OSSL_PARAM* p2);
+    void OSSL_PARAM_free(OSSL_PARAM* p);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/pem.h b/CAPI/cpp/grpc/include/openssl/pem.h
index 80940df..7ec9f39 100644
--- a/CAPI/cpp/grpc/include/openssl/pem.h
+++ b/CAPI/cpp/grpc/include/openssl/pem.h
@@ -8,205 +8,185 @@
  */
 
 #ifndef OPENSSL_PEM_H
-# define OPENSSL_PEM_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_PEM_H
-# endif
-
-# include <openssl/e_os2.h>
-# include <openssl/bio.h>
-# include <openssl/safestack.h>
-# include <openssl/evp.h>
-# include <openssl/x509.h>
-# include <openssl/pemerr.h>
-
-#ifdef  __cplusplus
-extern "C" {
+#define OPENSSL_PEM_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_PEM_H
 #endif
 
-# define PEM_BUFSIZE             1024
-
-# define PEM_STRING_X509_OLD     "X509 CERTIFICATE"
-# define PEM_STRING_X509         "CERTIFICATE"
-# define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE"
-# define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"
-# define PEM_STRING_X509_REQ     "CERTIFICATE REQUEST"
-# define PEM_STRING_X509_CRL     "X509 CRL"
-# define PEM_STRING_EVP_PKEY     "ANY PRIVATE KEY"
-# define PEM_STRING_PUBLIC       "PUBLIC KEY"
-# define PEM_STRING_RSA          "RSA PRIVATE KEY"
-# define PEM_STRING_RSA_PUBLIC   "RSA PUBLIC KEY"
-# define PEM_STRING_DSA          "DSA PRIVATE KEY"
-# define PEM_STRING_DSA_PUBLIC   "DSA PUBLIC KEY"
-# define PEM_STRING_PKCS7        "PKCS7"
-# define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA"
-# define PEM_STRING_PKCS8        "ENCRYPTED PRIVATE KEY"
-# define PEM_STRING_PKCS8INF     "PRIVATE KEY"
-# define PEM_STRING_DHPARAMS     "DH PARAMETERS"
-# define PEM_STRING_DHXPARAMS    "X9.42 DH PARAMETERS"
-# define PEM_STRING_SSL_SESSION  "SSL SESSION PARAMETERS"
-# define PEM_STRING_DSAPARAMS    "DSA PARAMETERS"
-# define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"
-# define PEM_STRING_ECPARAMETERS "EC PARAMETERS"
-# define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY"
-# define PEM_STRING_PARAMETERS   "PARAMETERS"
-# define PEM_STRING_CMS          "CMS"
-
-# define PEM_TYPE_ENCRYPTED      10
-# define PEM_TYPE_MIC_ONLY       20
-# define PEM_TYPE_MIC_CLEAR      30
-# define PEM_TYPE_CLEAR          40
+#include <openssl/e_os2.h>
+#include <openssl/bio.h>
+#include <openssl/safestack.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
+#include <openssl/pemerr.h>
 
-/*
- * These macros make the PEM_read/PEM_write functions easier to maintain and
- * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or
- * IMPLEMENT_PEM_rw_cb(...)
- */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# define PEM_read_cb_fnsig(name, type, INTYPE, readname)                \
-    type *PEM_##readname##_##name(INTYPE *out, type **x,                \
-                                 pem_password_cb *cb, void *u)
-# define PEM_read_cb_ex_fnsig(name, type, INTYPE, readname)             \
-    type *PEM_##readname##_##name##_ex(INTYPE *out, type **x,           \
-                                       pem_password_cb *cb, void *u,    \
-                                       OSSL_LIB_CTX *libctx,            \
-                                       const char *propq)
-
-# define PEM_write_fnsig(name, type, OUTTYPE, writename)                \
-    int PEM_##writename##_##name(OUTTYPE *out, const type *x)
-# define PEM_write_cb_fnsig(name, type, OUTTYPE, writename)             \
-    int PEM_##writename##_##name(OUTTYPE *out, const type *x,           \
-                                 const EVP_CIPHER *enc,                 \
-                                 const unsigned char *kstr, int klen,   \
-                                 pem_password_cb *cb, void *u)
-# define PEM_write_ex_fnsig(name, type, OUTTYPE, writename)             \
-    int PEM_##writename##_##name##_ex(OUTTYPE *out, const type *x,      \
-                                      OSSL_LIB_CTX *libctx,             \
-                                      const char *propq)
-# define PEM_write_cb_ex_fnsig(name, type, OUTTYPE, writename)          \
-    int PEM_##writename##_##name##_ex(OUTTYPE *out, const type *x,      \
-                                      const EVP_CIPHER *enc,            \
-                                      const unsigned char *kstr, int klen, \
-                                      pem_password_cb *cb, void *u,     \
-                                      OSSL_LIB_CTX *libctx,             \
-                                      const char *propq)
-
-# ifdef OPENSSL_NO_STDIO
-
-#  define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/
-#  define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/
-#  endif
-#  define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/
-#  endif
-# else
-
-#  define IMPLEMENT_PEM_read_fp(name, type, str, asn1)                  \
-    type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u) \
-    {                                                                   \
-        return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str, fp,        \
-                             (void **)x, cb, u);                        \
+#define PEM_BUFSIZE 1024
+
+#define PEM_STRING_X509_OLD "X509 CERTIFICATE"
+#define PEM_STRING_X509 "CERTIFICATE"
+#define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE"
+#define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"
+#define PEM_STRING_X509_REQ "CERTIFICATE REQUEST"
+#define PEM_STRING_X509_CRL "X509 CRL"
+#define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY"
+#define PEM_STRING_PUBLIC "PUBLIC KEY"
+#define PEM_STRING_RSA "RSA PRIVATE KEY"
+#define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY"
+#define PEM_STRING_DSA "DSA PRIVATE KEY"
+#define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY"
+#define PEM_STRING_PKCS7 "PKCS7"
+#define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA"
+#define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY"
+#define PEM_STRING_PKCS8INF "PRIVATE KEY"
+#define PEM_STRING_DHPARAMS "DH PARAMETERS"
+#define PEM_STRING_DHXPARAMS "X9.42 DH PARAMETERS"
+#define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS"
+#define PEM_STRING_DSAPARAMS "DSA PARAMETERS"
+#define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"
+#define PEM_STRING_ECPARAMETERS "EC PARAMETERS"
+#define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY"
+#define PEM_STRING_PARAMETERS "PARAMETERS"
+#define PEM_STRING_CMS "CMS"
+
+#define PEM_TYPE_ENCRYPTED 10
+#define PEM_TYPE_MIC_ONLY 20
+#define PEM_TYPE_MIC_CLEAR 30
+#define PEM_TYPE_CLEAR 40
+
+    /*
+     * These macros make the PEM_read/PEM_write functions easier to maintain and
+     * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or
+     * IMPLEMENT_PEM_rw_cb(...)
+     */
+
+#define PEM_read_cb_fnsig(name, type, INTYPE, readname) \
+    type* PEM_##readname##_##name(INTYPE* out, type** x, pem_password_cb* cb, void* u)
+#define PEM_read_cb_ex_fnsig(name, type, INTYPE, readname) \
+    type* PEM_##readname##_##name##_ex(INTYPE* out, type** x, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq)
+
+#define PEM_write_fnsig(name, type, OUTTYPE, writename) \
+    int PEM_##writename##_##name(OUTTYPE* out, const type* x)
+#define PEM_write_cb_fnsig(name, type, OUTTYPE, writename) \
+    int PEM_##writename##_##name(OUTTYPE* out, const type* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cb, void* u)
+#define PEM_write_ex_fnsig(name, type, OUTTYPE, writename) \
+    int PEM_##writename##_##name##_ex(OUTTYPE* out, const type* x, OSSL_LIB_CTX* libctx, const char* propq)
+#define PEM_write_cb_ex_fnsig(name, type, OUTTYPE, writename) \
+    int PEM_##writename##_##name##_ex(OUTTYPE* out, const type* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq)
+
+#ifdef OPENSSL_NO_STDIO
+
+#define IMPLEMENT_PEM_read_fp(name, type, str, asn1)  /**/
+#define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/
+#endif
+#define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/
+#endif
+#else
+
+#define IMPLEMENT_PEM_read_fp(name, type, str, asn1)                               \
+    type* PEM_read_##name(FILE* fp, type** x, pem_password_cb* cb, void* u)        \
+    {                                                                              \
+        return PEM_ASN1_read((d2i_of_void*)d2i_##asn1, str, fp, (void**)x, cb, u); \
     }
 
-#  define IMPLEMENT_PEM_write_fp(name, type, str, asn1)                 \
-    PEM_write_fnsig(name, type, FILE, write)                            \
-    {                                                                   \
-        return PEM_ASN1_write((i2d_of_void *)i2d_##asn1, str, out,      \
-                              x, NULL, NULL, 0, NULL, NULL);            \
+#define IMPLEMENT_PEM_write_fp(name, type, str, asn1)                                            \
+    PEM_write_fnsig(name, type, FILE, write)                                                     \
+    {                                                                                            \
+        return PEM_ASN1_write((i2d_of_void*)i2d_##asn1, str, out, x, NULL, NULL, 0, NULL, NULL); \
     }
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)  \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \
     IMPLEMENT_PEM_write_fp(name, type, str, asn1)
-#  endif
+#endif
 
-#  define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)              \
-    PEM_write_cb_fnsig(name, type, FILE, write)                         \
-    {                                                                   \
-        return PEM_ASN1_write((i2d_of_void *)i2d_##asn1, str, out,      \
-                              x, enc, kstr, klen, cb, u);               \
+#define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)                                      \
+    PEM_write_cb_fnsig(name, type, FILE, write)                                               \
+    {                                                                                         \
+        return PEM_ASN1_write((i2d_of_void*)i2d_##asn1, str, out, x, enc, kstr, klen, cb, u); \
     }
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)       \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \
     IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
-#  endif
-# endif
-
-# define IMPLEMENT_PEM_read_bio(name, type, str, asn1)                  \
-    type *PEM_read_bio_##name(BIO *bp, type **x,                        \
-                              pem_password_cb *cb, void *u)             \
-    {                                                                   \
-        return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str, bp,    \
-                                 (void **)x, cb, u);                    \
+#endif
+#endif
+
+#define IMPLEMENT_PEM_read_bio(name, type, str, asn1)                                  \
+    type* PEM_read_bio_##name(BIO* bp, type** x, pem_password_cb* cb, void* u)         \
+    {                                                                                  \
+        return PEM_ASN1_read_bio((d2i_of_void*)d2i_##asn1, str, bp, (void**)x, cb, u); \
     }
 
-# define IMPLEMENT_PEM_write_bio(name, type, str, asn1)                 \
-    PEM_write_fnsig(name, type, BIO, write_bio)                         \
-    {                                                                   \
-        return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1, str, out,  \
-                                  x, NULL,NULL,0,NULL,NULL);            \
+#define IMPLEMENT_PEM_write_bio(name, type, str, asn1)                                               \
+    PEM_write_fnsig(name, type, BIO, write_bio)                                                      \
+    {                                                                                                \
+        return PEM_ASN1_write_bio((i2d_of_void*)i2d_##asn1, str, out, x, NULL, NULL, 0, NULL, NULL); \
     }
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1)   \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
     IMPLEMENT_PEM_write_bio(name, type, str, asn1)
-# endif
+#endif
 
-# define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)              \
-    PEM_write_cb_fnsig(name, type, BIO, write_bio)                      \
-    {                                                                   \
-        return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1, str, out,  \
-                                  x, enc, kstr, klen, cb, u);           \
+#define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)                                         \
+    PEM_write_cb_fnsig(name, type, BIO, write_bio)                                                \
+    {                                                                                             \
+        return PEM_ASN1_write_bio((i2d_of_void*)i2d_##asn1, str, out, x, enc, kstr, klen, cb, u); \
     }
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1)  \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
     IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1)
-# endif
+#endif
 
-# define IMPLEMENT_PEM_write(name, type, str, asn1) \
-        IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
+#define IMPLEMENT_PEM_write(name, type, str, asn1) \
+    IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
         IMPLEMENT_PEM_write_fp(name, type, str, asn1)
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define IMPLEMENT_PEM_write_const(name, type, str, asn1) \
-        IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_write_const(name, type, str, asn1) \
+    IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
         IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)
-# endif
+#endif
 
-# define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \
-        IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
+#define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \
+    IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
         IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \
-        IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \
+    IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
         IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)
-# endif
+#endif
 
-# define IMPLEMENT_PEM_read(name, type, str, asn1) \
-        IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
+#define IMPLEMENT_PEM_read(name, type, str, asn1) \
+    IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
         IMPLEMENT_PEM_read_fp(name, type, str, asn1)
 
-# define IMPLEMENT_PEM_rw(name, type, str, asn1) \
-        IMPLEMENT_PEM_read(name, type, str, asn1) \
+#define IMPLEMENT_PEM_rw(name, type, str, asn1) \
+    IMPLEMENT_PEM_read(name, type, str, asn1)   \
         IMPLEMENT_PEM_write(name, type, str, asn1)
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \
-        IMPLEMENT_PEM_read(name, type, str, asn1) \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \
+    IMPLEMENT_PEM_read(name, type, str, asn1)         \
         IMPLEMENT_PEM_write_const(name, type, str, asn1)
-# endif
+#endif
 
-# define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \
-        IMPLEMENT_PEM_read(name, type, str, asn1) \
+#define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \
+    IMPLEMENT_PEM_read(name, type, str, asn1)      \
         IMPLEMENT_PEM_write_cb(name, type, str, asn1)
 
 /* These are the same except they are for the declarations */
@@ -216,323 +196,271 @@ extern "C" {
  * and is there to quiet pre-C99 compilers that may complain about empty
  * arguments in macro calls.
  */
-# if defined(OPENSSL_NO_STDIO)
-
-#  define DECLARE_PEM_read_fp_attr(attr, name, type) /**/
-#  define DECLARE_PEM_read_fp_ex_attr(attr, name, type) /**/
-#  define DECLARE_PEM_write_fp_attr(attr, name, type) /**/
-#  define DECLARE_PEM_write_fp_ex_attr(attr, name, type) /**/
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define DECLARE_PEM_write_fp_const_attr(attr, name, type) /**/
-#  endif
-#  define DECLARE_PEM_write_cb_fp_attr(attr, name, type) /**/
-#  define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) /**/
+#if defined(OPENSSL_NO_STDIO)
+
+#define DECLARE_PEM_read_fp_attr(attr, name, type)     /**/
+#define DECLARE_PEM_read_fp_ex_attr(attr, name, type)  /**/
+#define DECLARE_PEM_write_fp_attr(attr, name, type)    /**/
+#define DECLARE_PEM_write_fp_ex_attr(attr, name, type) /**/
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DECLARE_PEM_write_fp_const_attr(attr, name, type) /**/
+#endif
+#define DECLARE_PEM_write_cb_fp_attr(attr, name, type)    /**/
+#define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) /**/
 
-# else
+#else
 
-#  define DECLARE_PEM_read_fp_attr(attr, name, type)                        \
+#define DECLARE_PEM_read_fp_attr(attr, name, type) \
     attr PEM_read_cb_fnsig(name, type, FILE, read);
-#  define DECLARE_PEM_read_fp_ex_attr(attr, name, type)                     \
-    attr PEM_read_cb_fnsig(name, type, FILE, read);                         \
+#define DECLARE_PEM_read_fp_ex_attr(attr, name, type) \
+    attr PEM_read_cb_fnsig(name, type, FILE, read);   \
     attr PEM_read_cb_ex_fnsig(name, type, FILE, read);
 
-#  define DECLARE_PEM_write_fp_attr(attr, name, type)                       \
+#define DECLARE_PEM_write_fp_attr(attr, name, type) \
     attr PEM_write_fnsig(name, type, FILE, write);
-#  define DECLARE_PEM_write_fp_ex_attr(attr, name, type)                    \
-    attr PEM_write_fnsig(name, type, FILE, write);                          \
+#define DECLARE_PEM_write_fp_ex_attr(attr, name, type) \
+    attr PEM_write_fnsig(name, type, FILE, write);     \
     attr PEM_write_ex_fnsig(name, type, FILE, write);
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define DECLARE_PEM_write_fp_const_attr(attr, name, type)                \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DECLARE_PEM_write_fp_const_attr(attr, name, type) \
     attr PEM_write_fnsig(name, type, FILE, write);
-#  endif
-#  define DECLARE_PEM_write_cb_fp_attr(attr, name, type)                    \
+#endif
+#define DECLARE_PEM_write_cb_fp_attr(attr, name, type) \
     attr PEM_write_cb_fnsig(name, type, FILE, write);
-#  define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)                 \
-    attr PEM_write_cb_fnsig(name, type, FILE, write);                       \
+#define DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type) \
+    attr PEM_write_cb_fnsig(name, type, FILE, write);     \
     attr PEM_write_cb_ex_fnsig(name, type, FILE, write);
 
-# endif
+#endif
 
-# define DECLARE_PEM_read_fp(name, type)                                    \
+#define DECLARE_PEM_read_fp(name, type) \
     DECLARE_PEM_read_fp_attr(extern, name, type)
-# define DECLARE_PEM_write_fp(name, type)                                   \
+#define DECLARE_PEM_write_fp(name, type) \
     DECLARE_PEM_write_fp_attr(extern, name, type)
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define DECLARE_PEM_write_fp_const(name, type)                           \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DECLARE_PEM_write_fp_const(name, type) \
     DECLARE_PEM_write_fp_const_attr(extern, name, type)
-# endif
-# define DECLARE_PEM_write_cb_fp(name, type)                                \
+#endif
+#define DECLARE_PEM_write_cb_fp(name, type) \
     DECLARE_PEM_write_cb_fp_attr(extern, name, type)
 
-#  define DECLARE_PEM_read_bio_attr(attr, name, type)                       \
+#define DECLARE_PEM_read_bio_attr(attr, name, type) \
     attr PEM_read_cb_fnsig(name, type, BIO, read_bio);
-#  define DECLARE_PEM_read_bio_ex_attr(attr, name, type)                    \
-    attr PEM_read_cb_fnsig(name, type, BIO, read_bio);                      \
+#define DECLARE_PEM_read_bio_ex_attr(attr, name, type) \
+    attr PEM_read_cb_fnsig(name, type, BIO, read_bio); \
     attr PEM_read_cb_ex_fnsig(name, type, BIO, read_bio);
-# define DECLARE_PEM_read_bio(name, type)                                   \
+#define DECLARE_PEM_read_bio(name, type) \
     DECLARE_PEM_read_bio_attr(extern, name, type)
-# define DECLARE_PEM_read_bio_ex(name, type)                                \
+#define DECLARE_PEM_read_bio_ex(name, type) \
     DECLARE_PEM_read_bio_ex_attr(extern, name, type)
 
-# define DECLARE_PEM_write_bio_attr(attr, name, type)                       \
+#define DECLARE_PEM_write_bio_attr(attr, name, type) \
     attr PEM_write_fnsig(name, type, BIO, write_bio);
-# define DECLARE_PEM_write_bio_ex_attr(attr, name, type)                    \
-    attr PEM_write_fnsig(name, type, BIO, write_bio);                       \
+#define DECLARE_PEM_write_bio_ex_attr(attr, name, type) \
+    attr PEM_write_fnsig(name, type, BIO, write_bio);   \
     attr PEM_write_ex_fnsig(name, type, BIO, write_bio);
-# define DECLARE_PEM_write_bio(name, type)                                  \
+#define DECLARE_PEM_write_bio(name, type) \
     DECLARE_PEM_write_bio_attr(extern, name, type)
-# define DECLARE_PEM_write_bio_ex(name, type)                               \
+#define DECLARE_PEM_write_bio_ex(name, type) \
     DECLARE_PEM_write_bio_ex_attr(extern, name, type)
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define DECLARE_PEM_write_bio_const_attr(attr, name, type)                \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DECLARE_PEM_write_bio_const_attr(attr, name, type) \
     attr PEM_write_fnsig(name, type, BIO, write_bio);
-#  define DECLARE_PEM_write_bio_const(name, type)      \
+#define DECLARE_PEM_write_bio_const(name, type) \
     DECLARE_PEM_write_bio_const_attr(extern, name, type)
-# endif
+#endif
 
-# define DECLARE_PEM_write_cb_bio_attr(attr, name, type)                    \
+#define DECLARE_PEM_write_cb_bio_attr(attr, name, type) \
     attr PEM_write_cb_fnsig(name, type, BIO, write_bio);
-# define DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type)                 \
-    attr PEM_write_cb_fnsig(name, type, BIO, write_bio);                    \
+#define DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type) \
+    attr PEM_write_cb_fnsig(name, type, BIO, write_bio);   \
     attr PEM_write_cb_ex_fnsig(name, type, BIO, write_bio);
-# define DECLARE_PEM_write_cb_bio(name, type)                               \
+#define DECLARE_PEM_write_cb_bio(name, type) \
     DECLARE_PEM_write_cb_bio_attr(extern, name, type)
-# define DECLARE_PEM_write_cb_ex_bio(name, type)                            \
+#define DECLARE_PEM_write_cb_ex_bio(name, type) \
     DECLARE_PEM_write_cb_bio_ex_attr(extern, name, type)
 
-# define DECLARE_PEM_write_attr(attr, name, type)                           \
-    DECLARE_PEM_write_bio_attr(attr, name, type)                            \
-    DECLARE_PEM_write_fp_attr(attr, name, type)
-# define DECLARE_PEM_write_ex_attr(attr, name, type)                        \
-    DECLARE_PEM_write_bio_ex_attr(attr, name, type)                         \
-    DECLARE_PEM_write_fp_ex_attr(attr, name, type)
-# define DECLARE_PEM_write(name, type) \
+#define DECLARE_PEM_write_attr(attr, name, type) \
+    DECLARE_PEM_write_bio_attr(attr, name, type) \
+        DECLARE_PEM_write_fp_attr(attr, name, type)
+#define DECLARE_PEM_write_ex_attr(attr, name, type) \
+    DECLARE_PEM_write_bio_ex_attr(attr, name, type) \
+        DECLARE_PEM_write_fp_ex_attr(attr, name, type)
+#define DECLARE_PEM_write(name, type) \
     DECLARE_PEM_write_attr(extern, name, type)
-# define DECLARE_PEM_write_ex(name, type) \
+#define DECLARE_PEM_write_ex(name, type) \
     DECLARE_PEM_write_ex_attr(extern, name, type)
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define DECLARE_PEM_write_const_attr(attr, name, type)                    \
-    DECLARE_PEM_write_bio_const_attr(attr, name, type)                      \
-    DECLARE_PEM_write_fp_const_attr(attr, name, type)
-#  define DECLARE_PEM_write_const(name, type)                               \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DECLARE_PEM_write_const_attr(attr, name, type) \
+    DECLARE_PEM_write_bio_const_attr(attr, name, type) \
+        DECLARE_PEM_write_fp_const_attr(attr, name, type)
+#define DECLARE_PEM_write_const(name, type) \
     DECLARE_PEM_write_const_attr(extern, name, type)
-# endif
-# define DECLARE_PEM_write_cb_attr(attr, name, type)                        \
-    DECLARE_PEM_write_cb_bio_attr(attr, name, type)                         \
-    DECLARE_PEM_write_cb_fp_attr(attr, name, type)
-# define DECLARE_PEM_write_cb_ex_attr(attr, name, type)                     \
-    DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type)                      \
-    DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)
-# define DECLARE_PEM_write_cb(name, type)                                   \
+#endif
+#define DECLARE_PEM_write_cb_attr(attr, name, type) \
+    DECLARE_PEM_write_cb_bio_attr(attr, name, type) \
+        DECLARE_PEM_write_cb_fp_attr(attr, name, type)
+#define DECLARE_PEM_write_cb_ex_attr(attr, name, type) \
+    DECLARE_PEM_write_cb_bio_ex_attr(attr, name, type) \
+        DECLARE_PEM_write_cb_fp_ex_attr(attr, name, type)
+#define DECLARE_PEM_write_cb(name, type) \
     DECLARE_PEM_write_cb_attr(extern, name, type)
-# define DECLARE_PEM_write_cb_ex(name, type)                                \
+#define DECLARE_PEM_write_cb_ex(name, type) \
     DECLARE_PEM_write_cb_ex_attr(extern, name, type)
-# define DECLARE_PEM_read_attr(attr, name, type)                            \
-    DECLARE_PEM_read_bio_attr(attr, name, type)                             \
-    DECLARE_PEM_read_fp_attr(attr, name, type)
-# define DECLARE_PEM_read_ex_attr(attr, name, type)                         \
-    DECLARE_PEM_read_bio_ex_attr(attr, name, type)                          \
-    DECLARE_PEM_read_fp_ex_attr(attr, name, type)
-# define DECLARE_PEM_read(name, type)                                       \
+#define DECLARE_PEM_read_attr(attr, name, type) \
+    DECLARE_PEM_read_bio_attr(attr, name, type) \
+        DECLARE_PEM_read_fp_attr(attr, name, type)
+#define DECLARE_PEM_read_ex_attr(attr, name, type) \
+    DECLARE_PEM_read_bio_ex_attr(attr, name, type) \
+        DECLARE_PEM_read_fp_ex_attr(attr, name, type)
+#define DECLARE_PEM_read(name, type) \
     DECLARE_PEM_read_attr(extern, name, type)
-# define DECLARE_PEM_read_ex(name, type)                                    \
+#define DECLARE_PEM_read_ex(name, type) \
     DECLARE_PEM_read_ex_attr(extern, name, type)
-# define DECLARE_PEM_rw_attr(attr, name, type)                              \
-    DECLARE_PEM_read_attr(attr, name, type)                                 \
-    DECLARE_PEM_write_attr(attr, name, type)
-# define DECLARE_PEM_rw_ex_attr(attr, name, type)                           \
-    DECLARE_PEM_read_ex_attr(attr, name, type)                              \
-    DECLARE_PEM_write_ex_attr(attr, name, type)
-# define DECLARE_PEM_rw(name, type) \
+#define DECLARE_PEM_rw_attr(attr, name, type) \
+    DECLARE_PEM_read_attr(attr, name, type)   \
+        DECLARE_PEM_write_attr(attr, name, type)
+#define DECLARE_PEM_rw_ex_attr(attr, name, type) \
+    DECLARE_PEM_read_ex_attr(attr, name, type)   \
+        DECLARE_PEM_write_ex_attr(attr, name, type)
+#define DECLARE_PEM_rw(name, type) \
     DECLARE_PEM_rw_attr(extern, name, type)
-# define DECLARE_PEM_rw_ex(name, type) \
+#define DECLARE_PEM_rw_ex(name, type) \
     DECLARE_PEM_rw_ex_attr(extern, name, type)
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define DECLARE_PEM_rw_const_attr(attr, name, type)                       \
-    DECLARE_PEM_read_attr(attr, name, type)                                 \
-    DECLARE_PEM_write_const_attr(attr, name, type)
-#  define DECLARE_PEM_rw_const(name, type) \
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define DECLARE_PEM_rw_const_attr(attr, name, type) \
+    DECLARE_PEM_read_attr(attr, name, type)         \
+        DECLARE_PEM_write_const_attr(attr, name, type)
+#define DECLARE_PEM_rw_const(name, type) \
     DECLARE_PEM_rw_const_attr(extern, name, type)
-# endif
-# define DECLARE_PEM_rw_cb_attr(attr, name, type)                           \
-    DECLARE_PEM_read_attr(attr, name, type)                                 \
-    DECLARE_PEM_write_cb_attr(attr, name, type)
-# define DECLARE_PEM_rw_cb_ex_attr(attr, name, type)                        \
-    DECLARE_PEM_read_ex_attr(attr, name, type)                              \
-    DECLARE_PEM_write_cb_ex_attr(attr, name, type)
-# define DECLARE_PEM_rw_cb(name, type) \
+#endif
+#define DECLARE_PEM_rw_cb_attr(attr, name, type) \
+    DECLARE_PEM_read_attr(attr, name, type)      \
+        DECLARE_PEM_write_cb_attr(attr, name, type)
+#define DECLARE_PEM_rw_cb_ex_attr(attr, name, type) \
+    DECLARE_PEM_read_ex_attr(attr, name, type)      \
+        DECLARE_PEM_write_cb_ex_attr(attr, name, type)
+#define DECLARE_PEM_rw_cb(name, type) \
     DECLARE_PEM_rw_cb_attr(extern, name, type)
-# define DECLARE_PEM_rw_cb_ex(name, type) \
+#define DECLARE_PEM_rw_cb_ex(name, type) \
     DECLARE_PEM_rw_cb_ex_attr(extern, name, type)
 
-int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);
-int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len,
-                  pem_password_cb *callback, void *u);
-
-int PEM_read_bio(BIO *bp, char **name, char **header,
-                 unsigned char **data, long *len);
-#   define PEM_FLAG_SECURE             0x1
-#   define PEM_FLAG_EAY_COMPATIBLE     0x2
-#   define PEM_FLAG_ONLY_B64           0x4
-int PEM_read_bio_ex(BIO *bp, char **name, char **header,
-                    unsigned char **data, long *len, unsigned int flags);
-int PEM_bytes_read_bio_secmem(unsigned char **pdata, long *plen, char **pnm,
-                              const char *name, BIO *bp, pem_password_cb *cb,
-                              void *u);
-int PEM_write_bio(BIO *bp, const char *name, const char *hdr,
-                  const unsigned char *data, long len);
-int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
-                       const char *name, BIO *bp, pem_password_cb *cb,
-                       void *u);
-void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x,
-                        pem_password_cb *cb, void *u);
-int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp,
-                       const void *x, const EVP_CIPHER *enc,
-                       const unsigned char *kstr, int klen,
-                       pem_password_cb *cb, void *u);
-
-STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk,
-                                            pem_password_cb *cb, void *u);
-STACK_OF(X509_INFO)
-*PEM_X509_INFO_read_bio_ex(BIO *bp, STACK_OF(X509_INFO) *sk,
-                           pem_password_cb *cb, void *u, OSSL_LIB_CTX *libctx,
-                           const char *propq);
-
-int PEM_X509_INFO_write_bio(BIO *bp, const X509_INFO *xi, EVP_CIPHER *enc,
-                            const unsigned char *kstr, int klen,
-                            pem_password_cb *cd, void *u);
+    int PEM_get_EVP_CIPHER_INFO(char* header, EVP_CIPHER_INFO* cipher);
+    int PEM_do_header(EVP_CIPHER_INFO* cipher, unsigned char* data, long* len, pem_password_cb* callback, void* u);
+
+    int PEM_read_bio(BIO* bp, char** name, char** header, unsigned char** data, long* len);
+#define PEM_FLAG_SECURE 0x1
+#define PEM_FLAG_EAY_COMPATIBLE 0x2
+#define PEM_FLAG_ONLY_B64 0x4
+    int PEM_read_bio_ex(BIO* bp, char** name, char** header, unsigned char** data, long* len, unsigned int flags);
+    int PEM_bytes_read_bio_secmem(unsigned char** pdata, long* plen, char** pnm, const char* name, BIO* bp, pem_password_cb* cb, void* u);
+    int PEM_write_bio(BIO* bp, const char* name, const char* hdr, const unsigned char* data, long len);
+    int PEM_bytes_read_bio(unsigned char** pdata, long* plen, char** pnm, const char* name, BIO* bp, pem_password_cb* cb, void* u);
+    void* PEM_ASN1_read_bio(d2i_of_void* d2i, const char* name, BIO* bp, void** x, pem_password_cb* cb, void* u);
+    int PEM_ASN1_write_bio(i2d_of_void* i2d, const char* name, BIO* bp, const void* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cb, void* u);
+
+    STACK_OF(X509_INFO) * PEM_X509_INFO_read_bio(BIO* bp, STACK_OF(X509_INFO) * sk, pem_password_cb* cb, void* u);
+    STACK_OF(X509_INFO)
+    *PEM_X509_INFO_read_bio_ex(BIO* bp, STACK_OF(X509_INFO) * sk, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq);
+
+    int PEM_X509_INFO_write_bio(BIO* bp, const X509_INFO* xi, EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cd, void* u);
 
 #ifndef OPENSSL_NO_STDIO
-int PEM_read(FILE *fp, char **name, char **header,
-             unsigned char **data, long *len);
-int PEM_write(FILE *fp, const char *name, const char *hdr,
-              const unsigned char *data, long len);
-void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
-                    pem_password_cb *cb, void *u);
-int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp,
-                   const void *x, const EVP_CIPHER *enc,
-                   const unsigned char *kstr, int klen,
-                   pem_password_cb *callback, void *u);
-STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
-                                        pem_password_cb *cb, void *u);
-STACK_OF(X509_INFO)
-*PEM_X509_INFO_read_ex(FILE *fp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb,
-                       void *u, OSSL_LIB_CTX *libctx, const char *propq);
+    int PEM_read(FILE* fp, char** name, char** header, unsigned char** data, long* len);
+    int PEM_write(FILE* fp, const char* name, const char* hdr, const unsigned char* data, long len);
+    void* PEM_ASN1_read(d2i_of_void* d2i, const char* name, FILE* fp, void** x, pem_password_cb* cb, void* u);
+    int PEM_ASN1_write(i2d_of_void* i2d, const char* name, FILE* fp, const void* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* callback, void* u);
+    STACK_OF(X509_INFO) * PEM_X509_INFO_read(FILE* fp, STACK_OF(X509_INFO) * sk, pem_password_cb* cb, void* u);
+    STACK_OF(X509_INFO)
+    *PEM_X509_INFO_read_ex(FILE* fp, STACK_OF(X509_INFO) * sk, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq);
+#endif
+
+    int PEM_SignInit(EVP_MD_CTX* ctx, EVP_MD* type);
+    int PEM_SignUpdate(EVP_MD_CTX* ctx, const unsigned char* d, unsigned int cnt);
+    int PEM_SignFinal(EVP_MD_CTX* ctx, unsigned char* sigret, unsigned int* siglen, EVP_PKEY* pkey);
+
+    /* The default pem_password_cb that's used internally */
+    int PEM_def_callback(char* buf, int num, int rwflag, void* userdata);
+    void PEM_proc_type(char* buf, int type);
+    void PEM_dek_info(char* buf, const char* type, int len, const char* str);
+
+#include <openssl/symhacks.h>
+
+    DECLARE_PEM_rw(X509, X509)
+        DECLARE_PEM_rw(X509_AUX, X509)
+            DECLARE_PEM_rw(X509_REQ, X509_REQ)
+                DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)
+                    DECLARE_PEM_rw(X509_CRL, X509_CRL)
+                        DECLARE_PEM_rw(X509_PUBKEY, X509_PUBKEY)
+                            DECLARE_PEM_rw(PKCS7, PKCS7)
+                                DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)
+                                    DECLARE_PEM_rw(PKCS8, X509_SIG)
+                                        DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+                                            DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, RSAPrivateKey, RSA)
+                                                DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSAPublicKey, RSA)
+                                                    DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSA_PUBKEY, RSA)
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DSA
+                                                        DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, DSAPrivateKey, DSA)
+                                                            DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSA_PUBKEY, DSA)
+                                                                DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSAparams, DSA)
+#endif
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_EC
+                                                                    DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, ECPKParameters, EC_GROUP)
+                                                                        DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, ECPrivateKey, EC_KEY)
+                                                                            DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, EC_PUBKEY, EC_KEY)
 #endif
+#endif
+
+#ifndef OPENSSL_NO_DH
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+                                                                                DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DHparams, DH)
+                                                                                    DECLARE_PEM_write_attr(OSSL_DEPRECATEDIN_3_0, DHxparams, DH)
+#endif
+#endif
+                                                                                        DECLARE_PEM_rw_cb_ex(PrivateKey, EVP_PKEY)
+                                                                                            DECLARE_PEM_rw_ex(PUBKEY, EVP_PKEY)
+
+                                                                                                int PEM_write_bio_PrivateKey_traditional(BIO* bp, const EVP_PKEY* x, const EVP_CIPHER* enc, const unsigned char* kstr, int klen, pem_password_cb* cb, void* u);
+
+    /* Why do these take a signed char *kstr? */
+    int PEM_write_bio_PKCS8PrivateKey_nid(BIO* bp, const EVP_PKEY* x, int nid, const char* kstr, int klen, pem_password_cb* cb, void* u);
+    int PEM_write_bio_PKCS8PrivateKey(BIO*, const EVP_PKEY*, const EVP_CIPHER*, const char* kstr, int klen, pem_password_cb* cb, void* u);
+    int i2d_PKCS8PrivateKey_bio(BIO* bp, const EVP_PKEY* x, const EVP_CIPHER* enc, const char* kstr, int klen, pem_password_cb* cb, void* u);
+    int i2d_PKCS8PrivateKey_nid_bio(BIO* bp, const EVP_PKEY* x, int nid, const char* kstr, int klen, pem_password_cb* cb, void* u);
+    EVP_PKEY* d2i_PKCS8PrivateKey_bio(BIO* bp, EVP_PKEY** x, pem_password_cb* cb, void* u);
 
-int PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);
-int PEM_SignUpdate(EVP_MD_CTX *ctx, const unsigned char *d, unsigned int cnt);
-int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
-                  unsigned int *siglen, EVP_PKEY *pkey);
-
-/* The default pem_password_cb that's used internally */
-int PEM_def_callback(char *buf, int num, int rwflag, void *userdata);
-void PEM_proc_type(char *buf, int type);
-void PEM_dek_info(char *buf, const char *type, int len, const char *str);
-
-# include <openssl/symhacks.h>
-
-DECLARE_PEM_rw(X509, X509)
-DECLARE_PEM_rw(X509_AUX, X509)
-DECLARE_PEM_rw(X509_REQ, X509_REQ)
-DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)
-DECLARE_PEM_rw(X509_CRL, X509_CRL)
-DECLARE_PEM_rw(X509_PUBKEY, X509_PUBKEY)
-DECLARE_PEM_rw(PKCS7, PKCS7)
-DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)
-DECLARE_PEM_rw(PKCS8, X509_SIG)
-DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, RSAPrivateKey, RSA)
-DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSAPublicKey, RSA)
-DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, RSA_PUBKEY, RSA)
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifndef OPENSSL_NO_DSA
-DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, DSAPrivateKey, DSA)
-DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSA_PUBKEY, DSA)
-DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DSAparams, DSA)
-#  endif
-# endif
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifndef OPENSSL_NO_EC
-DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, ECPKParameters, EC_GROUP)
-DECLARE_PEM_rw_cb_attr(OSSL_DEPRECATEDIN_3_0, ECPrivateKey, EC_KEY)
-DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, EC_PUBKEY, EC_KEY)
-#  endif
-# endif
-
-# ifndef OPENSSL_NO_DH
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-DECLARE_PEM_rw_attr(OSSL_DEPRECATEDIN_3_0, DHparams, DH)
-DECLARE_PEM_write_attr(OSSL_DEPRECATEDIN_3_0, DHxparams, DH)
-#  endif
-# endif
-DECLARE_PEM_rw_cb_ex(PrivateKey, EVP_PKEY)
-DECLARE_PEM_rw_ex(PUBKEY, EVP_PKEY)
-
-int PEM_write_bio_PrivateKey_traditional(BIO *bp, const EVP_PKEY *x,
-                                         const EVP_CIPHER *enc,
-                                         const unsigned char *kstr, int klen,
-                                         pem_password_cb *cb, void *u);
-
-/* Why do these take a signed char *kstr? */
-int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, const EVP_PKEY *x, int nid,
-                                      const char *kstr, int klen,
-                                      pem_password_cb *cb, void *u);
-int PEM_write_bio_PKCS8PrivateKey(BIO *, const EVP_PKEY *, const EVP_CIPHER *,
-                                  const char *kstr, int klen,
-                                  pem_password_cb *cb, void *u);
-int i2d_PKCS8PrivateKey_bio(BIO *bp, const EVP_PKEY *x, const EVP_CIPHER *enc,
-                            const char *kstr, int klen,
-                            pem_password_cb *cb, void *u);
-int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, const EVP_PKEY *x, int nid,
-                                const char *kstr, int klen,
-                                pem_password_cb *cb, void *u);
-EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
-                                  void *u);
-
-# ifndef OPENSSL_NO_STDIO
-int i2d_PKCS8PrivateKey_fp(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
-                           const char *kstr, int klen,
-                           pem_password_cb *cb, void *u);
-int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, const EVP_PKEY *x, int nid,
-                               const char *kstr, int klen,
-                               pem_password_cb *cb, void *u);
-int PEM_write_PKCS8PrivateKey_nid(FILE *fp, const EVP_PKEY *x, int nid,
-                                  const char *kstr, int klen,
-                                  pem_password_cb *cb, void *u);
-
-EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
-                                 void *u);
-
-int PEM_write_PKCS8PrivateKey(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
-                              const char *kstr, int klen,
-                              pem_password_cb *cd, void *u);
-# endif
-EVP_PKEY *PEM_read_bio_Parameters_ex(BIO *bp, EVP_PKEY **x,
-                                     OSSL_LIB_CTX *libctx, const char *propq);
-EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x);
-int PEM_write_bio_Parameters(BIO *bp, const EVP_PKEY *x);
-
-EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length);
-EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length);
-EVP_PKEY *b2i_PrivateKey_bio(BIO *in);
-EVP_PKEY *b2i_PublicKey_bio(BIO *in);
-int i2b_PrivateKey_bio(BIO *out, const EVP_PKEY *pk);
-int i2b_PublicKey_bio(BIO *out, const EVP_PKEY *pk);
-EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u);
-EVP_PKEY *b2i_PVK_bio_ex(BIO *in, pem_password_cb *cb, void *u,
-                         OSSL_LIB_CTX *libctx, const char *propq);
-int i2b_PVK_bio(BIO *out, const EVP_PKEY *pk, int enclevel,
-                pem_password_cb *cb, void *u);
-int i2b_PVK_bio_ex(BIO *out, const EVP_PKEY *pk, int enclevel,
-                   pem_password_cb *cb, void *u,
-                   OSSL_LIB_CTX *libctx, const char *propq);
-
-# ifdef  __cplusplus
+#ifndef OPENSSL_NO_STDIO
+    int i2d_PKCS8PrivateKey_fp(FILE* fp, const EVP_PKEY* x, const EVP_CIPHER* enc, const char* kstr, int klen, pem_password_cb* cb, void* u);
+    int i2d_PKCS8PrivateKey_nid_fp(FILE* fp, const EVP_PKEY* x, int nid, const char* kstr, int klen, pem_password_cb* cb, void* u);
+    int PEM_write_PKCS8PrivateKey_nid(FILE* fp, const EVP_PKEY* x, int nid, const char* kstr, int klen, pem_password_cb* cb, void* u);
+
+    EVP_PKEY* d2i_PKCS8PrivateKey_fp(FILE* fp, EVP_PKEY** x, pem_password_cb* cb, void* u);
+
+    int PEM_write_PKCS8PrivateKey(FILE* fp, const EVP_PKEY* x, const EVP_CIPHER* enc, const char* kstr, int klen, pem_password_cb* cd, void* u);
+#endif
+    EVP_PKEY* PEM_read_bio_Parameters_ex(BIO* bp, EVP_PKEY** x, OSSL_LIB_CTX* libctx, const char* propq);
+    EVP_PKEY* PEM_read_bio_Parameters(BIO* bp, EVP_PKEY** x);
+    int PEM_write_bio_Parameters(BIO* bp, const EVP_PKEY* x);
+
+    EVP_PKEY* b2i_PrivateKey(const unsigned char** in, long length);
+    EVP_PKEY* b2i_PublicKey(const unsigned char** in, long length);
+    EVP_PKEY* b2i_PrivateKey_bio(BIO* in);
+    EVP_PKEY* b2i_PublicKey_bio(BIO* in);
+    int i2b_PrivateKey_bio(BIO* out, const EVP_PKEY* pk);
+    int i2b_PublicKey_bio(BIO* out, const EVP_PKEY* pk);
+    EVP_PKEY* b2i_PVK_bio(BIO* in, pem_password_cb* cb, void* u);
+    EVP_PKEY* b2i_PVK_bio_ex(BIO* in, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq);
+    int i2b_PVK_bio(BIO* out, const EVP_PKEY* pk, int enclevel, pem_password_cb* cb, void* u);
+    int i2b_PVK_bio_ex(BIO* out, const EVP_PKEY* pk, int enclevel, pem_password_cb* cb, void* u, OSSL_LIB_CTX* libctx, const char* propq);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/pem2.h b/CAPI/cpp/grpc/include/openssl/pem2.h
index a8a5325..6d3ab2a 100644
--- a/CAPI/cpp/grpc/include/openssl/pem2.h
+++ b/CAPI/cpp/grpc/include/openssl/pem2.h
@@ -8,12 +8,12 @@
  */
 
 #ifndef OPENSSL_PEM2_H
-# define OPENSSL_PEM2_H
-# pragma once
+#define OPENSSL_PEM2_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_PEM2_H
-# endif
-# include <openssl/pemerr.h>
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_PEM2_H
+#endif
+#include <openssl/pemerr.h>
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/pemerr.h b/CAPI/cpp/grpc/include/openssl/pemerr.h
index 18f6d9e..5b13999 100644
--- a/CAPI/cpp/grpc/include/openssl/pemerr.h
+++ b/CAPI/cpp/grpc/include/openssl/pemerr.h
@@ -9,50 +9,48 @@
  */
 
 #ifndef OPENSSL_PEMERR_H
-# define OPENSSL_PEMERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_PEMERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * PEM reason codes.
  */
-# define PEM_R_BAD_BASE64_DECODE                          100
-# define PEM_R_BAD_DECRYPT                                101
-# define PEM_R_BAD_END_LINE                               102
-# define PEM_R_BAD_IV_CHARS                               103
-# define PEM_R_BAD_MAGIC_NUMBER                           116
-# define PEM_R_BAD_PASSWORD_READ                          104
-# define PEM_R_BAD_VERSION_NUMBER                         117
-# define PEM_R_BIO_WRITE_FAILURE                          118
-# define PEM_R_CIPHER_IS_NULL                             127
-# define PEM_R_ERROR_CONVERTING_PRIVATE_KEY               115
-# define PEM_R_EXPECTING_DSS_KEY_BLOB                     131
-# define PEM_R_EXPECTING_PRIVATE_KEY_BLOB                 119
-# define PEM_R_EXPECTING_PUBLIC_KEY_BLOB                  120
-# define PEM_R_EXPECTING_RSA_KEY_BLOB                     132
-# define PEM_R_HEADER_TOO_LONG                            128
-# define PEM_R_INCONSISTENT_HEADER                        121
-# define PEM_R_KEYBLOB_HEADER_PARSE_ERROR                 122
-# define PEM_R_KEYBLOB_TOO_SHORT                          123
-# define PEM_R_MISSING_DEK_IV                             129
-# define PEM_R_NOT_DEK_INFO                               105
-# define PEM_R_NOT_ENCRYPTED                              106
-# define PEM_R_NOT_PROC_TYPE                              107
-# define PEM_R_NO_START_LINE                              108
-# define PEM_R_PROBLEMS_GETTING_PASSWORD                  109
-# define PEM_R_PVK_DATA_TOO_SHORT                         124
-# define PEM_R_PVK_TOO_SHORT                              125
-# define PEM_R_READ_KEY                                   111
-# define PEM_R_SHORT_HEADER                               112
-# define PEM_R_UNEXPECTED_DEK_IV                          130
-# define PEM_R_UNSUPPORTED_CIPHER                         113
-# define PEM_R_UNSUPPORTED_ENCRYPTION                     114
-# define PEM_R_UNSUPPORTED_KEY_COMPONENTS                 126
-# define PEM_R_UNSUPPORTED_PUBLIC_KEY_TYPE                110
+#define PEM_R_BAD_BASE64_DECODE 100
+#define PEM_R_BAD_DECRYPT 101
+#define PEM_R_BAD_END_LINE 102
+#define PEM_R_BAD_IV_CHARS 103
+#define PEM_R_BAD_MAGIC_NUMBER 116
+#define PEM_R_BAD_PASSWORD_READ 104
+#define PEM_R_BAD_VERSION_NUMBER 117
+#define PEM_R_BIO_WRITE_FAILURE 118
+#define PEM_R_CIPHER_IS_NULL 127
+#define PEM_R_ERROR_CONVERTING_PRIVATE_KEY 115
+#define PEM_R_EXPECTING_DSS_KEY_BLOB 131
+#define PEM_R_EXPECTING_PRIVATE_KEY_BLOB 119
+#define PEM_R_EXPECTING_PUBLIC_KEY_BLOB 120
+#define PEM_R_EXPECTING_RSA_KEY_BLOB 132
+#define PEM_R_HEADER_TOO_LONG 128
+#define PEM_R_INCONSISTENT_HEADER 121
+#define PEM_R_KEYBLOB_HEADER_PARSE_ERROR 122
+#define PEM_R_KEYBLOB_TOO_SHORT 123
+#define PEM_R_MISSING_DEK_IV 129
+#define PEM_R_NOT_DEK_INFO 105
+#define PEM_R_NOT_ENCRYPTED 106
+#define PEM_R_NOT_PROC_TYPE 107
+#define PEM_R_NO_START_LINE 108
+#define PEM_R_PROBLEMS_GETTING_PASSWORD 109
+#define PEM_R_PVK_DATA_TOO_SHORT 124
+#define PEM_R_PVK_TOO_SHORT 125
+#define PEM_R_READ_KEY 111
+#define PEM_R_SHORT_HEADER 112
+#define PEM_R_UNEXPECTED_DEK_IV 130
+#define PEM_R_UNSUPPORTED_CIPHER 113
+#define PEM_R_UNSUPPORTED_ENCRYPTION 114
+#define PEM_R_UNSUPPORTED_KEY_COMPONENTS 126
+#define PEM_R_UNSUPPORTED_PUBLIC_KEY_TYPE 110
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/pkcs12.h b/CAPI/cpp/grpc/include/openssl/pkcs12.h
index f0da086..7d7b6cd 100644
--- a/CAPI/cpp/grpc/include/openssl/pkcs12.h
+++ b/CAPI/cpp/grpc/include/openssl/pkcs12.h
@@ -10,341 +10,226 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_PKCS12_H
-# define OPENSSL_PKCS12_H
-# pragma once
+#define OPENSSL_PKCS12_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_PKCS12_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_PKCS12_H
+#endif
 
-# include <openssl/bio.h>
-# include <openssl/core.h>
-# include <openssl/x509.h>
-# include <openssl/pkcs12err.h>
+#include <openssl/bio.h>
+#include <openssl/core.h>
+#include <openssl/x509.h>
+#include <openssl/pkcs12err.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-# define PKCS12_KEY_ID   1
-# define PKCS12_IV_ID    2
-# define PKCS12_MAC_ID   3
+#define PKCS12_KEY_ID 1
+#define PKCS12_IV_ID 2
+#define PKCS12_MAC_ID 3
 
 /* Default iteration count */
-# ifndef PKCS12_DEFAULT_ITER
-#  define PKCS12_DEFAULT_ITER     PKCS5_DEFAULT_ITER
-# endif
+#ifndef PKCS12_DEFAULT_ITER
+#define PKCS12_DEFAULT_ITER PKCS5_DEFAULT_ITER
+#endif
 
-# define PKCS12_MAC_KEY_LENGTH 20
+#define PKCS12_MAC_KEY_LENGTH 20
 
-# define PKCS12_SALT_LEN 8
+#define PKCS12_SALT_LEN 8
 
 /* It's not clear if these are actually needed... */
-# define PKCS12_key_gen PKCS12_key_gen_utf8
-# define PKCS12_add_friendlyname PKCS12_add_friendlyname_utf8
+#define PKCS12_key_gen PKCS12_key_gen_utf8
+#define PKCS12_add_friendlyname PKCS12_add_friendlyname_utf8
 
-/* MS key usage constants */
+    /* MS key usage constants */
 
-# define KEY_EX  0x10
-# define KEY_SIG 0x80
+#define KEY_EX 0x10
+#define KEY_SIG 0x80
 
-typedef struct PKCS12_MAC_DATA_st PKCS12_MAC_DATA;
+    typedef struct PKCS12_MAC_DATA_st PKCS12_MAC_DATA;
 
-typedef struct PKCS12_st PKCS12;
+    typedef struct PKCS12_st PKCS12;
 
-typedef struct PKCS12_SAFEBAG_st PKCS12_SAFEBAG;
+    typedef struct PKCS12_SAFEBAG_st PKCS12_SAFEBAG;
 
-SKM_DEFINE_STACK_OF_INTERNAL(PKCS12_SAFEBAG, PKCS12_SAFEBAG, PKCS12_SAFEBAG)
+    SKM_DEFINE_STACK_OF_INTERNAL(PKCS12_SAFEBAG, PKCS12_SAFEBAG, PKCS12_SAFEBAG)
 #define sk_PKCS12_SAFEBAG_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk))
-#define sk_PKCS12_SAFEBAG_value(sk, idx) ((PKCS12_SAFEBAG *)OPENSSL_sk_value(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), (idx)))
-#define sk_PKCS12_SAFEBAG_new(cmp) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)))
-#define sk_PKCS12_SAFEBAG_new_null() ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new_null())
-#define sk_PKCS12_SAFEBAG_new_reserve(cmp, n) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_new_reserve(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp), (n)))
+#define sk_PKCS12_SAFEBAG_value(sk, idx) ((PKCS12_SAFEBAG*)OPENSSL_sk_value(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), (idx)))
+#define sk_PKCS12_SAFEBAG_new(cmp) ((STACK_OF(PKCS12_SAFEBAG)*)OPENSSL_sk_new(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)))
+#define sk_PKCS12_SAFEBAG_new_null() ((STACK_OF(PKCS12_SAFEBAG)*)OPENSSL_sk_new_null())
+#define sk_PKCS12_SAFEBAG_new_reserve(cmp, n) ((STACK_OF(PKCS12_SAFEBAG)*)OPENSSL_sk_new_reserve(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp), (n)))
 #define sk_PKCS12_SAFEBAG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (n))
 #define sk_PKCS12_SAFEBAG_free(sk) OPENSSL_sk_free(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
 #define sk_PKCS12_SAFEBAG_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
-#define sk_PKCS12_SAFEBAG_delete(sk, i) ((PKCS12_SAFEBAG *)OPENSSL_sk_delete(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (i)))
-#define sk_PKCS12_SAFEBAG_delete_ptr(sk, ptr) ((PKCS12_SAFEBAG *)OPENSSL_sk_delete_ptr(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr)))
+#define sk_PKCS12_SAFEBAG_delete(sk, i) ((PKCS12_SAFEBAG*)OPENSSL_sk_delete(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (i)))
+#define sk_PKCS12_SAFEBAG_delete_ptr(sk, ptr) ((PKCS12_SAFEBAG*)OPENSSL_sk_delete_ptr(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr)))
 #define sk_PKCS12_SAFEBAG_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
 #define sk_PKCS12_SAFEBAG_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
-#define sk_PKCS12_SAFEBAG_pop(sk) ((PKCS12_SAFEBAG *)OPENSSL_sk_pop(ossl_check_PKCS12_SAFEBAG_sk_type(sk)))
-#define sk_PKCS12_SAFEBAG_shift(sk) ((PKCS12_SAFEBAG *)OPENSSL_sk_shift(ossl_check_PKCS12_SAFEBAG_sk_type(sk)))
-#define sk_PKCS12_SAFEBAG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS12_SAFEBAG_sk_type(sk),ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc))
+#define sk_PKCS12_SAFEBAG_pop(sk) ((PKCS12_SAFEBAG*)OPENSSL_sk_pop(ossl_check_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_shift(sk) ((PKCS12_SAFEBAG*)OPENSSL_sk_shift(ossl_check_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc))
 #define sk_PKCS12_SAFEBAG_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr), (idx))
-#define sk_PKCS12_SAFEBAG_set(sk, idx, ptr) ((PKCS12_SAFEBAG *)OPENSSL_sk_set(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (idx), ossl_check_PKCS12_SAFEBAG_type(ptr)))
+#define sk_PKCS12_SAFEBAG_set(sk, idx, ptr) ((PKCS12_SAFEBAG*)OPENSSL_sk_set(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (idx), ossl_check_PKCS12_SAFEBAG_type(ptr)))
 #define sk_PKCS12_SAFEBAG_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
 #define sk_PKCS12_SAFEBAG_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr))
 #define sk_PKCS12_SAFEBAG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr), pnum)
 #define sk_PKCS12_SAFEBAG_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
 #define sk_PKCS12_SAFEBAG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk))
-#define sk_PKCS12_SAFEBAG_dup(sk) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_dup(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk)))
-#define sk_PKCS12_SAFEBAG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_copyfunc_type(copyfunc), ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc)))
+#define sk_PKCS12_SAFEBAG_dup(sk) ((STACK_OF(PKCS12_SAFEBAG)*)OPENSSL_sk_dup(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk)))
+#define sk_PKCS12_SAFEBAG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS12_SAFEBAG)*)OPENSSL_sk_deep_copy(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_copyfunc_type(copyfunc), ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc)))
 #define sk_PKCS12_SAFEBAG_set_cmp_func(sk, cmp) ((sk_PKCS12_SAFEBAG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)))
 
+    typedef struct pkcs12_bag_st PKCS12_BAGS;
 
-typedef struct pkcs12_bag_st PKCS12_BAGS;
-
-# define PKCS12_ERROR    0
-# define PKCS12_OK       1
+#define PKCS12_ERROR 0
+#define PKCS12_OK 1
 
-/* Compatibility macros */
+    /* Compatibility macros */
 
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
 
-# define M_PKCS12_bag_type PKCS12_bag_type
-# define M_PKCS12_cert_bag_type PKCS12_cert_bag_type
-# define M_PKCS12_crl_bag_type PKCS12_cert_bag_type
+#define M_PKCS12_bag_type PKCS12_bag_type
+#define M_PKCS12_cert_bag_type PKCS12_cert_bag_type
+#define M_PKCS12_crl_bag_type PKCS12_cert_bag_type
 
-# define PKCS12_certbag2x509 PKCS12_SAFEBAG_get1_cert
-# define PKCS12_certbag2scrl PKCS12_SAFEBAG_get1_crl
-# define PKCS12_bag_type PKCS12_SAFEBAG_get_nid
-# define PKCS12_cert_bag_type PKCS12_SAFEBAG_get_bag_nid
-# define PKCS12_x5092certbag PKCS12_SAFEBAG_create_cert
-# define PKCS12_x509crl2certbag PKCS12_SAFEBAG_create_crl
-# define PKCS12_MAKE_KEYBAG PKCS12_SAFEBAG_create0_p8inf
-# define PKCS12_MAKE_SHKEYBAG PKCS12_SAFEBAG_create_pkcs8_encrypt
+#define PKCS12_certbag2x509 PKCS12_SAFEBAG_get1_cert
+#define PKCS12_certbag2scrl PKCS12_SAFEBAG_get1_crl
+#define PKCS12_bag_type PKCS12_SAFEBAG_get_nid
+#define PKCS12_cert_bag_type PKCS12_SAFEBAG_get_bag_nid
+#define PKCS12_x5092certbag PKCS12_SAFEBAG_create_cert
+#define PKCS12_x509crl2certbag PKCS12_SAFEBAG_create_crl
+#define PKCS12_MAKE_KEYBAG PKCS12_SAFEBAG_create0_p8inf
+#define PKCS12_MAKE_SHKEYBAG PKCS12_SAFEBAG_create_pkcs8_encrypt
 
 #endif
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 ASN1_TYPE *PKCS12_get_attr(const PKCS12_SAFEBAG *bag,
-                                                   int attr_nid);
+    OSSL_DEPRECATEDIN_1_1_0 ASN1_TYPE* PKCS12_get_attr(const PKCS12_SAFEBAG* bag, int attr_nid);
 #endif
 
-ASN1_TYPE *PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid);
-int PKCS12_mac_present(const PKCS12 *p12);
-void PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac,
-                     const X509_ALGOR **pmacalg,
-                     const ASN1_OCTET_STRING **psalt,
-                     const ASN1_INTEGER **piter,
-                     const PKCS12 *p12);
-
-const ASN1_TYPE *PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG *bag,
-                                          int attr_nid);
-const ASN1_OBJECT *PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag);
-int PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag);
-int PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag);
-const ASN1_TYPE *PKCS12_SAFEBAG_get0_bag_obj(const PKCS12_SAFEBAG *bag);
-const ASN1_OBJECT *PKCS12_SAFEBAG_get0_bag_type(const PKCS12_SAFEBAG *bag);
-
-X509 *PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag);
-X509_CRL *PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag);
-const STACK_OF(PKCS12_SAFEBAG) *
-PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag);
-const PKCS8_PRIV_KEY_INFO *PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag);
-const X509_SIG *PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag);
-
-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_cert(X509 *x509);
-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_crl(X509_CRL *crl);
-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_secret(int type, int vtype, const unsigned char *value, int len);
-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO *p8);
-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create0_pkcs8(X509_SIG *p8);
-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid,
-                                                    const char *pass,
-                                                    int passlen,
-                                                    unsigned char *salt,
-                                                    int saltlen, int iter,
-                                                    PKCS8_PRIV_KEY_INFO *p8inf);
-PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt_ex(int pbe_nid,
-                                                       const char *pass,
-                                                       int passlen,
-                                                       unsigned char *salt,
-                                                       int saltlen, int iter,
-                                                       PKCS8_PRIV_KEY_INFO *p8inf,
-                                                       OSSL_LIB_CTX *ctx,
-                                                       const char *propq);
-
-PKCS12_SAFEBAG *PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it,
-                                         int nid1, int nid2);
-PKCS8_PRIV_KEY_INFO *PKCS8_decrypt(const X509_SIG *p8, const char *pass,
-                                   int passlen);
-PKCS8_PRIV_KEY_INFO *PKCS8_decrypt_ex(const X509_SIG *p8, const char *pass,
-                                      int passlen, OSSL_LIB_CTX *ctx,
-                                      const char *propq);
-PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey(const PKCS12_SAFEBAG *bag,
-                                         const char *pass, int passlen);
-PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey_ex(const PKCS12_SAFEBAG *bag,
-                                            const char *pass, int passlen,
-                                            OSSL_LIB_CTX *ctx,
-                                            const char *propq);
-X509_SIG *PKCS8_encrypt(int pbe_nid, const EVP_CIPHER *cipher,
-                        const char *pass, int passlen, unsigned char *salt,
-                        int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8);
-X509_SIG *PKCS8_encrypt_ex(int pbe_nid, const EVP_CIPHER *cipher,
-                           const char *pass, int passlen, unsigned char *salt,
-                           int saltlen, int iter, PKCS8_PRIV_KEY_INFO *p8,
-                           OSSL_LIB_CTX *ctx, const char *propq);
-X509_SIG *PKCS8_set0_pbe(const char *pass, int passlen,
-                        PKCS8_PRIV_KEY_INFO *p8inf, X509_ALGOR *pbe);
-X509_SIG *PKCS8_set0_pbe_ex(const char *pass, int passlen,
-                            PKCS8_PRIV_KEY_INFO *p8inf, X509_ALGOR *pbe,
-                            OSSL_LIB_CTX *ctx, const char *propq);
-PKCS7 *PKCS12_pack_p7data(STACK_OF(PKCS12_SAFEBAG) *sk);
-STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7data(PKCS7 *p7);
-PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, const char *pass, int passlen,
-                             unsigned char *salt, int saltlen, int iter,
-                             STACK_OF(PKCS12_SAFEBAG) *bags);
-PKCS7 *PKCS12_pack_p7encdata_ex(int pbe_nid, const char *pass, int passlen,
-                                unsigned char *salt, int saltlen, int iter,
-                                STACK_OF(PKCS12_SAFEBAG) *bags,
-                                OSSL_LIB_CTX *ctx, const char *propq);
-
-STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass,
-                                                  int passlen);
-
-int PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes);
-STACK_OF(PKCS7) *PKCS12_unpack_authsafes(const PKCS12 *p12);
-
-int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name,
-                          int namelen);
-int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name,
-                                int namelen);
-int PKCS12_add_friendlyname_utf8(PKCS12_SAFEBAG *bag, const char *name,
-                                 int namelen);
-int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name,
-                           int namelen);
-int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag,
-                                const unsigned char *name, int namelen);
-int PKCS12_add1_attr_by_NID(PKCS12_SAFEBAG *bag, int nid, int type,
-                            const unsigned char *bytes, int len);
-int PKCS12_add1_attr_by_txt(PKCS12_SAFEBAG *bag, const char *attrname, int type,
-                            const unsigned char *bytes, int len);
-int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage);
-ASN1_TYPE *PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs,
-                               int attr_nid);
-char *PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag);
-const STACK_OF(X509_ATTRIBUTE) *
-PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG *bag);
-unsigned char *PKCS12_pbe_crypt(const X509_ALGOR *algor,
-                                const char *pass, int passlen,
-                                const unsigned char *in, int inlen,
-                                unsigned char **data, int *datalen,
-                                int en_de);
-unsigned char *PKCS12_pbe_crypt_ex(const X509_ALGOR *algor,
-                                   const char *pass, int passlen,
-                                   const unsigned char *in, int inlen,
-                                   unsigned char **data, int *datalen,
-                                   int en_de, OSSL_LIB_CTX *libctx,
-                                   const char *propq);
-void *PKCS12_item_decrypt_d2i(const X509_ALGOR *algor, const ASN1_ITEM *it,
-                              const char *pass, int passlen,
-                              const ASN1_OCTET_STRING *oct, int zbuf);
-void *PKCS12_item_decrypt_d2i_ex(const X509_ALGOR *algor, const ASN1_ITEM *it,
-                                 const char *pass, int passlen,
-                                 const ASN1_OCTET_STRING *oct, int zbuf,
-                                 OSSL_LIB_CTX *libctx, 
-                                 const char *propq);
-ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor,
-                                           const ASN1_ITEM *it,
-                                           const char *pass, int passlen,
-                                           void *obj, int zbuf);
-ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt_ex(X509_ALGOR *algor,
-                                              const ASN1_ITEM *it,
-                                              const char *pass, int passlen,
-                                              void *obj, int zbuf,
-                                              OSSL_LIB_CTX *ctx,
-                                              const char *propq);
-PKCS12 *PKCS12_init(int mode);
-PKCS12 *PKCS12_init_ex(int mode, OSSL_LIB_CTX *ctx, const char *propq);
-
-int PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt,
-                       int saltlen, int id, int iter, int n,
-                       unsigned char *out, const EVP_MD *md_type);
-int PKCS12_key_gen_asc_ex(const char *pass, int passlen, unsigned char *salt,
-                          int saltlen, int id, int iter, int n,
-                          unsigned char *out, const EVP_MD *md_type,
-                          OSSL_LIB_CTX *ctx, const char *propq);
-int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt,
-                       int saltlen, int id, int iter, int n,
-                       unsigned char *out, const EVP_MD *md_type);
-int PKCS12_key_gen_uni_ex(unsigned char *pass, int passlen, unsigned char *salt,
-                          int saltlen, int id, int iter, int n,
-                          unsigned char *out, const EVP_MD *md_type,
-                          OSSL_LIB_CTX *ctx, const char *propq);
-int PKCS12_key_gen_utf8(const char *pass, int passlen, unsigned char *salt,
-                        int saltlen, int id, int iter, int n,
-                        unsigned char *out, const EVP_MD *md_type);
-int PKCS12_key_gen_utf8_ex(const char *pass, int passlen, unsigned char *salt,
-                           int saltlen, int id, int iter, int n,
-                           unsigned char *out, const EVP_MD *md_type,
-                           OSSL_LIB_CTX *ctx, const char *propq);
-
-int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
-                        ASN1_TYPE *param, const EVP_CIPHER *cipher,
-                        const EVP_MD *md_type, int en_de);
-int PKCS12_PBE_keyivgen_ex(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
-                           ASN1_TYPE *param, const EVP_CIPHER *cipher,
-                           const EVP_MD *md_type, int en_de,
-                           OSSL_LIB_CTX *libctx, const char *propq);
-int PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen,
-                   unsigned char *mac, unsigned int *maclen);
-int PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen);
-int PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen,
-                   unsigned char *salt, int saltlen, int iter,
-                   const EVP_MD *md_type);
-int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt,
-                     int saltlen, const EVP_MD *md_type);
-unsigned char *OPENSSL_asc2uni(const char *asc, int asclen,
-                               unsigned char **uni, int *unilen);
-char *OPENSSL_uni2asc(const unsigned char *uni, int unilen);
-unsigned char *OPENSSL_utf82uni(const char *asc, int asclen,
-                                unsigned char **uni, int *unilen);
-char *OPENSSL_uni2utf8(const unsigned char *uni, int unilen);
-
-DECLARE_ASN1_FUNCTIONS(PKCS12)
-DECLARE_ASN1_FUNCTIONS(PKCS12_MAC_DATA)
-DECLARE_ASN1_FUNCTIONS(PKCS12_SAFEBAG)
-DECLARE_ASN1_FUNCTIONS(PKCS12_BAGS)
-
-DECLARE_ASN1_ITEM(PKCS12_SAFEBAGS)
-DECLARE_ASN1_ITEM(PKCS12_AUTHSAFES)
-
-void PKCS12_PBE_add(void);
-int PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert,
-                 STACK_OF(X509) **ca);
-PKCS12 *PKCS12_create(const char *pass, const char *name, EVP_PKEY *pkey,
-                      X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert,
-                      int iter, int mac_iter, int keytype);
-PKCS12 *PKCS12_create_ex(const char *pass, const char *name, EVP_PKEY *pkey,
-                         X509 *cert, STACK_OF(X509) *ca, int nid_key, int nid_cert,
-                         int iter, int mac_iter, int keytype,
-                         OSSL_LIB_CTX *ctx, const char *propq);
-
-PKCS12_SAFEBAG *PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert);
-PKCS12_SAFEBAG *PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags,
-                               EVP_PKEY *key, int key_usage, int iter,
-                               int key_nid, const char *pass);
-PKCS12_SAFEBAG *PKCS12_add_key_ex(STACK_OF(PKCS12_SAFEBAG) **pbags,
-                                  EVP_PKEY *key, int key_usage, int iter,
-                                  int key_nid, const char *pass,
-                                  OSSL_LIB_CTX *ctx, const char *propq);
-
-PKCS12_SAFEBAG *PKCS12_add_secret(STACK_OF(PKCS12_SAFEBAG) **pbags,
-                                  int nid_type, const unsigned char *value, int len);
-int PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags,
-                    int safe_nid, int iter, const char *pass);
-int PKCS12_add_safe_ex(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags,
-                       int safe_nid, int iter, const char *pass,
-                       OSSL_LIB_CTX *ctx, const char *propq);
-
-PKCS12 *PKCS12_add_safes(STACK_OF(PKCS7) *safes, int p7_nid);
-PKCS12 *PKCS12_add_safes_ex(STACK_OF(PKCS7) *safes, int p7_nid,
-                            OSSL_LIB_CTX *ctx, const char *propq);
-
-int i2d_PKCS12_bio(BIO *bp, const PKCS12 *p12);
-# ifndef OPENSSL_NO_STDIO
-int i2d_PKCS12_fp(FILE *fp, const PKCS12 *p12);
-# endif
-PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12);
-# ifndef OPENSSL_NO_STDIO
-PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12);
-# endif
-int PKCS12_newpass(PKCS12 *p12, const char *oldpass, const char *newpass);
-
-# ifdef  __cplusplus
+    ASN1_TYPE* PKCS8_get_attr(PKCS8_PRIV_KEY_INFO* p8, int attr_nid);
+    int PKCS12_mac_present(const PKCS12* p12);
+    void PKCS12_get0_mac(const ASN1_OCTET_STRING** pmac, const X509_ALGOR** pmacalg, const ASN1_OCTET_STRING** psalt, const ASN1_INTEGER** piter, const PKCS12* p12);
+
+    const ASN1_TYPE* PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG* bag, int attr_nid);
+    const ASN1_OBJECT* PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG* bag);
+    int PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG* bag);
+    int PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG* bag);
+    const ASN1_TYPE* PKCS12_SAFEBAG_get0_bag_obj(const PKCS12_SAFEBAG* bag);
+    const ASN1_OBJECT* PKCS12_SAFEBAG_get0_bag_type(const PKCS12_SAFEBAG* bag);
+
+    X509* PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG* bag);
+    X509_CRL* PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG* bag);
+    const STACK_OF(PKCS12_SAFEBAG) *
+        PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG* bag);
+    const PKCS8_PRIV_KEY_INFO* PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG* bag);
+    const X509_SIG* PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG* bag);
+
+    PKCS12_SAFEBAG* PKCS12_SAFEBAG_create_cert(X509* x509);
+    PKCS12_SAFEBAG* PKCS12_SAFEBAG_create_crl(X509_CRL* crl);
+    PKCS12_SAFEBAG* PKCS12_SAFEBAG_create_secret(int type, int vtype, const unsigned char* value, int len);
+    PKCS12_SAFEBAG* PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO* p8);
+    PKCS12_SAFEBAG* PKCS12_SAFEBAG_create0_pkcs8(X509_SIG* p8);
+    PKCS12_SAFEBAG* PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid, const char* pass, int passlen, unsigned char* salt, int saltlen, int iter, PKCS8_PRIV_KEY_INFO* p8inf);
+    PKCS12_SAFEBAG* PKCS12_SAFEBAG_create_pkcs8_encrypt_ex(int pbe_nid, const char* pass, int passlen, unsigned char* salt, int saltlen, int iter, PKCS8_PRIV_KEY_INFO* p8inf, OSSL_LIB_CTX* ctx, const char* propq);
+
+    PKCS12_SAFEBAG* PKCS12_item_pack_safebag(void* obj, const ASN1_ITEM* it, int nid1, int nid2);
+    PKCS8_PRIV_KEY_INFO* PKCS8_decrypt(const X509_SIG* p8, const char* pass, int passlen);
+    PKCS8_PRIV_KEY_INFO* PKCS8_decrypt_ex(const X509_SIG* p8, const char* pass, int passlen, OSSL_LIB_CTX* ctx, const char* propq);
+    PKCS8_PRIV_KEY_INFO* PKCS12_decrypt_skey(const PKCS12_SAFEBAG* bag, const char* pass, int passlen);
+    PKCS8_PRIV_KEY_INFO* PKCS12_decrypt_skey_ex(const PKCS12_SAFEBAG* bag, const char* pass, int passlen, OSSL_LIB_CTX* ctx, const char* propq);
+    X509_SIG* PKCS8_encrypt(int pbe_nid, const EVP_CIPHER* cipher, const char* pass, int passlen, unsigned char* salt, int saltlen, int iter, PKCS8_PRIV_KEY_INFO* p8);
+    X509_SIG* PKCS8_encrypt_ex(int pbe_nid, const EVP_CIPHER* cipher, const char* pass, int passlen, unsigned char* salt, int saltlen, int iter, PKCS8_PRIV_KEY_INFO* p8, OSSL_LIB_CTX* ctx, const char* propq);
+    X509_SIG* PKCS8_set0_pbe(const char* pass, int passlen, PKCS8_PRIV_KEY_INFO* p8inf, X509_ALGOR* pbe);
+    X509_SIG* PKCS8_set0_pbe_ex(const char* pass, int passlen, PKCS8_PRIV_KEY_INFO* p8inf, X509_ALGOR* pbe, OSSL_LIB_CTX* ctx, const char* propq);
+    PKCS7* PKCS12_pack_p7data(STACK_OF(PKCS12_SAFEBAG) * sk);
+    STACK_OF(PKCS12_SAFEBAG) * PKCS12_unpack_p7data(PKCS7* p7);
+    PKCS7* PKCS12_pack_p7encdata(int pbe_nid, const char* pass, int passlen, unsigned char* salt, int saltlen, int iter, STACK_OF(PKCS12_SAFEBAG) * bags);
+    PKCS7* PKCS12_pack_p7encdata_ex(int pbe_nid, const char* pass, int passlen, unsigned char* salt, int saltlen, int iter, STACK_OF(PKCS12_SAFEBAG) * bags, OSSL_LIB_CTX* ctx, const char* propq);
+
+    STACK_OF(PKCS12_SAFEBAG) * PKCS12_unpack_p7encdata(PKCS7* p7, const char* pass, int passlen);
+
+    int PKCS12_pack_authsafes(PKCS12* p12, STACK_OF(PKCS7) * safes);
+    STACK_OF(PKCS7) * PKCS12_unpack_authsafes(const PKCS12* p12);
+
+    int PKCS12_add_localkeyid(PKCS12_SAFEBAG* bag, unsigned char* name, int namelen);
+    int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG* bag, const char* name, int namelen);
+    int PKCS12_add_friendlyname_utf8(PKCS12_SAFEBAG* bag, const char* name, int namelen);
+    int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG* bag, const char* name, int namelen);
+    int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG* bag, const unsigned char* name, int namelen);
+    int PKCS12_add1_attr_by_NID(PKCS12_SAFEBAG* bag, int nid, int type, const unsigned char* bytes, int len);
+    int PKCS12_add1_attr_by_txt(PKCS12_SAFEBAG* bag, const char* attrname, int type, const unsigned char* bytes, int len);
+    int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO* p8, int usage);
+    ASN1_TYPE* PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) * attrs, int attr_nid);
+    char* PKCS12_get_friendlyname(PKCS12_SAFEBAG* bag);
+    const STACK_OF(X509_ATTRIBUTE) *
+        PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG* bag);
+    unsigned char* PKCS12_pbe_crypt(const X509_ALGOR* algor, const char* pass, int passlen, const unsigned char* in, int inlen, unsigned char** data, int* datalen, int en_de);
+    unsigned char* PKCS12_pbe_crypt_ex(const X509_ALGOR* algor, const char* pass, int passlen, const unsigned char* in, int inlen, unsigned char** data, int* datalen, int en_de, OSSL_LIB_CTX* libctx, const char* propq);
+    void* PKCS12_item_decrypt_d2i(const X509_ALGOR* algor, const ASN1_ITEM* it, const char* pass, int passlen, const ASN1_OCTET_STRING* oct, int zbuf);
+    void* PKCS12_item_decrypt_d2i_ex(const X509_ALGOR* algor, const ASN1_ITEM* it, const char* pass, int passlen, const ASN1_OCTET_STRING* oct, int zbuf, OSSL_LIB_CTX* libctx, const char* propq);
+    ASN1_OCTET_STRING* PKCS12_item_i2d_encrypt(X509_ALGOR* algor, const ASN1_ITEM* it, const char* pass, int passlen, void* obj, int zbuf);
+    ASN1_OCTET_STRING* PKCS12_item_i2d_encrypt_ex(X509_ALGOR* algor, const ASN1_ITEM* it, const char* pass, int passlen, void* obj, int zbuf, OSSL_LIB_CTX* ctx, const char* propq);
+    PKCS12* PKCS12_init(int mode);
+    PKCS12* PKCS12_init_ex(int mode, OSSL_LIB_CTX* ctx, const char* propq);
+
+    int PKCS12_key_gen_asc(const char* pass, int passlen, unsigned char* salt, int saltlen, int id, int iter, int n, unsigned char* out, const EVP_MD* md_type);
+    int PKCS12_key_gen_asc_ex(const char* pass, int passlen, unsigned char* salt, int saltlen, int id, int iter, int n, unsigned char* out, const EVP_MD* md_type, OSSL_LIB_CTX* ctx, const char* propq);
+    int PKCS12_key_gen_uni(unsigned char* pass, int passlen, unsigned char* salt, int saltlen, int id, int iter, int n, unsigned char* out, const EVP_MD* md_type);
+    int PKCS12_key_gen_uni_ex(unsigned char* pass, int passlen, unsigned char* salt, int saltlen, int id, int iter, int n, unsigned char* out, const EVP_MD* md_type, OSSL_LIB_CTX* ctx, const char* propq);
+    int PKCS12_key_gen_utf8(const char* pass, int passlen, unsigned char* salt, int saltlen, int id, int iter, int n, unsigned char* out, const EVP_MD* md_type);
+    int PKCS12_key_gen_utf8_ex(const char* pass, int passlen, unsigned char* salt, int saltlen, int id, int iter, int n, unsigned char* out, const EVP_MD* md_type, OSSL_LIB_CTX* ctx, const char* propq);
+
+    int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* cipher, const EVP_MD* md_type, int en_de);
+    int PKCS12_PBE_keyivgen_ex(EVP_CIPHER_CTX* ctx, const char* pass, int passlen, ASN1_TYPE* param, const EVP_CIPHER* cipher, const EVP_MD* md_type, int en_de, OSSL_LIB_CTX* libctx, const char* propq);
+    int PKCS12_gen_mac(PKCS12* p12, const char* pass, int passlen, unsigned char* mac, unsigned int* maclen);
+    int PKCS12_verify_mac(PKCS12* p12, const char* pass, int passlen);
+    int PKCS12_set_mac(PKCS12* p12, const char* pass, int passlen, unsigned char* salt, int saltlen, int iter, const EVP_MD* md_type);
+    int PKCS12_setup_mac(PKCS12* p12, int iter, unsigned char* salt, int saltlen, const EVP_MD* md_type);
+    unsigned char* OPENSSL_asc2uni(const char* asc, int asclen, unsigned char** uni, int* unilen);
+    char* OPENSSL_uni2asc(const unsigned char* uni, int unilen);
+    unsigned char* OPENSSL_utf82uni(const char* asc, int asclen, unsigned char** uni, int* unilen);
+    char* OPENSSL_uni2utf8(const unsigned char* uni, int unilen);
+
+    DECLARE_ASN1_FUNCTIONS(PKCS12)
+    DECLARE_ASN1_FUNCTIONS(PKCS12_MAC_DATA)
+    DECLARE_ASN1_FUNCTIONS(PKCS12_SAFEBAG)
+    DECLARE_ASN1_FUNCTIONS(PKCS12_BAGS)
+
+    DECLARE_ASN1_ITEM(PKCS12_SAFEBAGS)
+    DECLARE_ASN1_ITEM(PKCS12_AUTHSAFES)
+
+    void PKCS12_PBE_add(void);
+    int PKCS12_parse(PKCS12* p12, const char* pass, EVP_PKEY** pkey, X509** cert, STACK_OF(X509) * *ca);
+    PKCS12* PKCS12_create(const char* pass, const char* name, EVP_PKEY* pkey, X509* cert, STACK_OF(X509) * ca, int nid_key, int nid_cert, int iter, int mac_iter, int keytype);
+    PKCS12* PKCS12_create_ex(const char* pass, const char* name, EVP_PKEY* pkey, X509* cert, STACK_OF(X509) * ca, int nid_key, int nid_cert, int iter, int mac_iter, int keytype, OSSL_LIB_CTX* ctx, const char* propq);
+
+    PKCS12_SAFEBAG* PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) * *pbags, X509* cert);
+    PKCS12_SAFEBAG* PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) * *pbags, EVP_PKEY* key, int key_usage, int iter, int key_nid, const char* pass);
+    PKCS12_SAFEBAG* PKCS12_add_key_ex(STACK_OF(PKCS12_SAFEBAG) * *pbags, EVP_PKEY* key, int key_usage, int iter, int key_nid, const char* pass, OSSL_LIB_CTX* ctx, const char* propq);
+
+    PKCS12_SAFEBAG* PKCS12_add_secret(STACK_OF(PKCS12_SAFEBAG) * *pbags, int nid_type, const unsigned char* value, int len);
+    int PKCS12_add_safe(STACK_OF(PKCS7) * *psafes, STACK_OF(PKCS12_SAFEBAG) * bags, int safe_nid, int iter, const char* pass);
+    int PKCS12_add_safe_ex(STACK_OF(PKCS7) * *psafes, STACK_OF(PKCS12_SAFEBAG) * bags, int safe_nid, int iter, const char* pass, OSSL_LIB_CTX* ctx, const char* propq);
+
+    PKCS12* PKCS12_add_safes(STACK_OF(PKCS7) * safes, int p7_nid);
+    PKCS12* PKCS12_add_safes_ex(STACK_OF(PKCS7) * safes, int p7_nid, OSSL_LIB_CTX* ctx, const char* propq);
+
+    int i2d_PKCS12_bio(BIO* bp, const PKCS12* p12);
+#ifndef OPENSSL_NO_STDIO
+    int i2d_PKCS12_fp(FILE* fp, const PKCS12* p12);
+#endif
+    PKCS12* d2i_PKCS12_bio(BIO* bp, PKCS12** p12);
+#ifndef OPENSSL_NO_STDIO
+    PKCS12* d2i_PKCS12_fp(FILE* fp, PKCS12** p12);
+#endif
+    int PKCS12_newpass(PKCS12* p12, const char* oldpass, const char* newpass);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/pkcs12err.h b/CAPI/cpp/grpc/include/openssl/pkcs12err.h
index 933c832..507e81f 100644
--- a/CAPI/cpp/grpc/include/openssl/pkcs12err.h
+++ b/CAPI/cpp/grpc/include/openssl/pkcs12err.h
@@ -9,37 +9,35 @@
  */
 
 #ifndef OPENSSL_PKCS12ERR_H
-# define OPENSSL_PKCS12ERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_PKCS12ERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * PKCS12 reason codes.
  */
-# define PKCS12_R_CANT_PACK_STRUCTURE                     100
-# define PKCS12_R_CONTENT_TYPE_NOT_DATA                   121
-# define PKCS12_R_DECODE_ERROR                            101
-# define PKCS12_R_ENCODE_ERROR                            102
-# define PKCS12_R_ENCRYPT_ERROR                           103
-# define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE       120
-# define PKCS12_R_INVALID_NULL_ARGUMENT                   104
-# define PKCS12_R_INVALID_NULL_PKCS12_POINTER             105
-# define PKCS12_R_INVALID_TYPE                            112
-# define PKCS12_R_IV_GEN_ERROR                            106
-# define PKCS12_R_KEY_GEN_ERROR                           107
-# define PKCS12_R_MAC_ABSENT                              108
-# define PKCS12_R_MAC_GENERATION_ERROR                    109
-# define PKCS12_R_MAC_SETUP_ERROR                         110
-# define PKCS12_R_MAC_STRING_SET_ERROR                    111
-# define PKCS12_R_MAC_VERIFY_FAILURE                      113
-# define PKCS12_R_PARSE_ERROR                             114
-# define PKCS12_R_PKCS12_CIPHERFINAL_ERROR                116
-# define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM                118
-# define PKCS12_R_UNSUPPORTED_PKCS12_MODE                 119
+#define PKCS12_R_CANT_PACK_STRUCTURE 100
+#define PKCS12_R_CONTENT_TYPE_NOT_DATA 121
+#define PKCS12_R_DECODE_ERROR 101
+#define PKCS12_R_ENCODE_ERROR 102
+#define PKCS12_R_ENCRYPT_ERROR 103
+#define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE 120
+#define PKCS12_R_INVALID_NULL_ARGUMENT 104
+#define PKCS12_R_INVALID_NULL_PKCS12_POINTER 105
+#define PKCS12_R_INVALID_TYPE 112
+#define PKCS12_R_IV_GEN_ERROR 106
+#define PKCS12_R_KEY_GEN_ERROR 107
+#define PKCS12_R_MAC_ABSENT 108
+#define PKCS12_R_MAC_GENERATION_ERROR 109
+#define PKCS12_R_MAC_SETUP_ERROR 110
+#define PKCS12_R_MAC_STRING_SET_ERROR 111
+#define PKCS12_R_MAC_VERIFY_FAILURE 113
+#define PKCS12_R_PARSE_ERROR 114
+#define PKCS12_R_PKCS12_CIPHERFINAL_ERROR 116
+#define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM 118
+#define PKCS12_R_UNSUPPORTED_PKCS12_MODE 119
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/pkcs7.h b/CAPI/cpp/grpc/include/openssl/pkcs7.h
index 097d2db..9b1d589 100644
--- a/CAPI/cpp/grpc/include/openssl/pkcs7.h
+++ b/CAPI/cpp/grpc/include/openssl/pkcs7.h
@@ -10,418 +10,399 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_PKCS7_H
-# define OPENSSL_PKCS7_H
-# pragma once
+#define OPENSSL_PKCS7_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_PKCS7_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_PKCS7_H
+#endif
 
-# include <openssl/asn1.h>
-# include <openssl/bio.h>
-# include <openssl/e_os2.h>
+#include <openssl/asn1.h>
+#include <openssl/bio.h>
+#include <openssl/e_os2.h>
 
-# include <openssl/symhacks.h>
-# include <openssl/types.h>
-# include <openssl/pkcs7err.h>
+#include <openssl/symhacks.h>
+#include <openssl/types.h>
+#include <openssl/pkcs7err.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-
-/*-
-Encryption_ID           DES-CBC
-Digest_ID               MD5
-Digest_Encryption_ID    rsaEncryption
-Key_Encryption_ID       rsaEncryption
-*/
-
-typedef struct PKCS7_CTX_st {
-    OSSL_LIB_CTX *libctx;
-    char *propq;
-} PKCS7_CTX;
-
-typedef struct pkcs7_issuer_and_serial_st {
-    X509_NAME *issuer;
-    ASN1_INTEGER *serial;
-} PKCS7_ISSUER_AND_SERIAL;
-
-typedef struct pkcs7_signer_info_st {
-    ASN1_INTEGER *version;      /* version 1 */
-    PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
-    X509_ALGOR *digest_alg;
-    STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */
-    X509_ALGOR *digest_enc_alg;
-    ASN1_OCTET_STRING *enc_digest;
-    STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */
-    /* The private key to sign with */
-    EVP_PKEY *pkey;
-    const PKCS7_CTX *ctx;
-} PKCS7_SIGNER_INFO;
-SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO)
+    /*-
+    Encryption_ID           DES-CBC
+    Digest_ID               MD5
+    Digest_Encryption_ID    rsaEncryption
+    Key_Encryption_ID       rsaEncryption
+    */
+
+    typedef struct PKCS7_CTX_st
+    {
+        OSSL_LIB_CTX* libctx;
+        char* propq;
+    } PKCS7_CTX;
+
+    typedef struct pkcs7_issuer_and_serial_st
+    {
+        X509_NAME* issuer;
+        ASN1_INTEGER* serial;
+    } PKCS7_ISSUER_AND_SERIAL;
+
+    typedef struct pkcs7_signer_info_st
+    {
+        ASN1_INTEGER* version; /* version 1 */
+        PKCS7_ISSUER_AND_SERIAL* issuer_and_serial;
+        X509_ALGOR* digest_alg;
+        STACK_OF(X509_ATTRIBUTE) * auth_attr; /* [ 0 ] */
+        X509_ALGOR* digest_enc_alg;
+        ASN1_OCTET_STRING* enc_digest;
+        STACK_OF(X509_ATTRIBUTE) * unauth_attr; /* [ 1 ] */
+        /* The private key to sign with */
+        EVP_PKEY* pkey;
+        const PKCS7_CTX* ctx;
+    } PKCS7_SIGNER_INFO;
+    SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO, PKCS7_SIGNER_INFO)
 #define sk_PKCS7_SIGNER_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))
-#define sk_PKCS7_SIGNER_INFO_value(sk, idx) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_value(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), (idx)))
-#define sk_PKCS7_SIGNER_INFO_new(cmp) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)))
-#define sk_PKCS7_SIGNER_INFO_new_null() ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new_null())
-#define sk_PKCS7_SIGNER_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp), (n)))
+#define sk_PKCS7_SIGNER_INFO_value(sk, idx) ((PKCS7_SIGNER_INFO*)OPENSSL_sk_value(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), (idx)))
+#define sk_PKCS7_SIGNER_INFO_new(cmp) ((STACK_OF(PKCS7_SIGNER_INFO)*)OPENSSL_sk_new(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)))
+#define sk_PKCS7_SIGNER_INFO_new_null() ((STACK_OF(PKCS7_SIGNER_INFO)*)OPENSSL_sk_new_null())
+#define sk_PKCS7_SIGNER_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_SIGNER_INFO)*)OPENSSL_sk_new_reserve(ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp), (n)))
 #define sk_PKCS7_SIGNER_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (n))
 #define sk_PKCS7_SIGNER_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
 #define sk_PKCS7_SIGNER_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
-#define sk_PKCS7_SIGNER_INFO_delete(sk, i) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_delete(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (i)))
-#define sk_PKCS7_SIGNER_INFO_delete_ptr(sk, ptr) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr)))
+#define sk_PKCS7_SIGNER_INFO_delete(sk, i) ((PKCS7_SIGNER_INFO*)OPENSSL_sk_delete(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (i)))
+#define sk_PKCS7_SIGNER_INFO_delete_ptr(sk, ptr) ((PKCS7_SIGNER_INFO*)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr)))
 #define sk_PKCS7_SIGNER_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
 #define sk_PKCS7_SIGNER_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
-#define sk_PKCS7_SIGNER_INFO_pop(sk) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_pop(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)))
-#define sk_PKCS7_SIGNER_INFO_shift(sk) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_shift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)))
-#define sk_PKCS7_SIGNER_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk),ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc))
+#define sk_PKCS7_SIGNER_INFO_pop(sk) ((PKCS7_SIGNER_INFO*)OPENSSL_sk_pop(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_shift(sk) ((PKCS7_SIGNER_INFO*)OPENSSL_sk_shift(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc))
 #define sk_PKCS7_SIGNER_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), (idx))
-#define sk_PKCS7_SIGNER_INFO_set(sk, idx, ptr) ((PKCS7_SIGNER_INFO *)OPENSSL_sk_set(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (idx), ossl_check_PKCS7_SIGNER_INFO_type(ptr)))
+#define sk_PKCS7_SIGNER_INFO_set(sk, idx, ptr) ((PKCS7_SIGNER_INFO*)OPENSSL_sk_set(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), (idx), ossl_check_PKCS7_SIGNER_INFO_type(ptr)))
 #define sk_PKCS7_SIGNER_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
 #define sk_PKCS7_SIGNER_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr))
 #define sk_PKCS7_SIGNER_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_type(ptr), pnum)
 #define sk_PKCS7_SIGNER_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk))
 #define sk_PKCS7_SIGNER_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk))
-#define sk_PKCS7_SIGNER_INFO_dup(sk) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk)))
-#define sk_PKCS7_SIGNER_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_SIGNER_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc)))
+#define sk_PKCS7_SIGNER_INFO_dup(sk) ((STACK_OF(PKCS7_SIGNER_INFO)*)OPENSSL_sk_dup(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk)))
+#define sk_PKCS7_SIGNER_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_SIGNER_INFO)*)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_SIGNER_INFO_freefunc_type(freefunc)))
 #define sk_PKCS7_SIGNER_INFO_set_cmp_func(sk, cmp) ((sk_PKCS7_SIGNER_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_SIGNER_INFO_sk_type(sk), ossl_check_PKCS7_SIGNER_INFO_compfunc_type(cmp)))
 
-
-typedef struct pkcs7_recip_info_st {
-    ASN1_INTEGER *version;      /* version 0 */
-    PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
-    X509_ALGOR *key_enc_algor;
-    ASN1_OCTET_STRING *enc_key;
-    X509 *cert;                 /* get the pub-key from this */
-    const PKCS7_CTX *ctx;
-} PKCS7_RECIP_INFO;
-SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO, PKCS7_RECIP_INFO)
+    typedef struct pkcs7_recip_info_st
+    {
+        ASN1_INTEGER* version; /* version 0 */
+        PKCS7_ISSUER_AND_SERIAL* issuer_and_serial;
+        X509_ALGOR* key_enc_algor;
+        ASN1_OCTET_STRING* enc_key;
+        X509* cert; /* get the pub-key from this */
+        const PKCS7_CTX* ctx;
+    } PKCS7_RECIP_INFO;
+    SKM_DEFINE_STACK_OF_INTERNAL(PKCS7_RECIP_INFO, PKCS7_RECIP_INFO, PKCS7_RECIP_INFO)
 #define sk_PKCS7_RECIP_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))
-#define sk_PKCS7_RECIP_INFO_value(sk, idx) ((PKCS7_RECIP_INFO *)OPENSSL_sk_value(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), (idx)))
-#define sk_PKCS7_RECIP_INFO_new(cmp) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)))
-#define sk_PKCS7_RECIP_INFO_new_null() ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new_null())
-#define sk_PKCS7_RECIP_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp), (n)))
+#define sk_PKCS7_RECIP_INFO_value(sk, idx) ((PKCS7_RECIP_INFO*)OPENSSL_sk_value(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), (idx)))
+#define sk_PKCS7_RECIP_INFO_new(cmp) ((STACK_OF(PKCS7_RECIP_INFO)*)OPENSSL_sk_new(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)))
+#define sk_PKCS7_RECIP_INFO_new_null() ((STACK_OF(PKCS7_RECIP_INFO)*)OPENSSL_sk_new_null())
+#define sk_PKCS7_RECIP_INFO_new_reserve(cmp, n) ((STACK_OF(PKCS7_RECIP_INFO)*)OPENSSL_sk_new_reserve(ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp), (n)))
 #define sk_PKCS7_RECIP_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (n))
 #define sk_PKCS7_RECIP_INFO_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
 #define sk_PKCS7_RECIP_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
-#define sk_PKCS7_RECIP_INFO_delete(sk, i) ((PKCS7_RECIP_INFO *)OPENSSL_sk_delete(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (i)))
-#define sk_PKCS7_RECIP_INFO_delete_ptr(sk, ptr) ((PKCS7_RECIP_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr)))
+#define sk_PKCS7_RECIP_INFO_delete(sk, i) ((PKCS7_RECIP_INFO*)OPENSSL_sk_delete(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (i)))
+#define sk_PKCS7_RECIP_INFO_delete_ptr(sk, ptr) ((PKCS7_RECIP_INFO*)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr)))
 #define sk_PKCS7_RECIP_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
 #define sk_PKCS7_RECIP_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
-#define sk_PKCS7_RECIP_INFO_pop(sk) ((PKCS7_RECIP_INFO *)OPENSSL_sk_pop(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)))
-#define sk_PKCS7_RECIP_INFO_shift(sk) ((PKCS7_RECIP_INFO *)OPENSSL_sk_shift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)))
-#define sk_PKCS7_RECIP_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk),ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc))
+#define sk_PKCS7_RECIP_INFO_pop(sk) ((PKCS7_RECIP_INFO*)OPENSSL_sk_pop(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_shift(sk) ((PKCS7_RECIP_INFO*)OPENSSL_sk_shift(ossl_check_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc))
 #define sk_PKCS7_RECIP_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), (idx))
-#define sk_PKCS7_RECIP_INFO_set(sk, idx, ptr) ((PKCS7_RECIP_INFO *)OPENSSL_sk_set(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (idx), ossl_check_PKCS7_RECIP_INFO_type(ptr)))
+#define sk_PKCS7_RECIP_INFO_set(sk, idx, ptr) ((PKCS7_RECIP_INFO*)OPENSSL_sk_set(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), (idx), ossl_check_PKCS7_RECIP_INFO_type(ptr)))
 #define sk_PKCS7_RECIP_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
 #define sk_PKCS7_RECIP_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr))
 #define sk_PKCS7_RECIP_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_type(ptr), pnum)
 #define sk_PKCS7_RECIP_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_RECIP_INFO_sk_type(sk))
 #define sk_PKCS7_RECIP_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk))
-#define sk_PKCS7_RECIP_INFO_dup(sk) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk)))
-#define sk_PKCS7_RECIP_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_RECIP_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc)))
+#define sk_PKCS7_RECIP_INFO_dup(sk) ((STACK_OF(PKCS7_RECIP_INFO)*)OPENSSL_sk_dup(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk)))
+#define sk_PKCS7_RECIP_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7_RECIP_INFO)*)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_copyfunc_type(copyfunc), ossl_check_PKCS7_RECIP_INFO_freefunc_type(freefunc)))
 #define sk_PKCS7_RECIP_INFO_set_cmp_func(sk, cmp) ((sk_PKCS7_RECIP_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_RECIP_INFO_sk_type(sk), ossl_check_PKCS7_RECIP_INFO_compfunc_type(cmp)))
 
-
-
-typedef struct pkcs7_signed_st {
-    ASN1_INTEGER *version;      /* version 1 */
-    STACK_OF(X509_ALGOR) *md_algs; /* md used */
-    STACK_OF(X509) *cert;       /* [ 0 ] */
-    STACK_OF(X509_CRL) *crl;    /* [ 1 ] */
-    STACK_OF(PKCS7_SIGNER_INFO) *signer_info;
-    struct pkcs7_st *contents;
-} PKCS7_SIGNED;
-/*
- * The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about
- * merging the two
- */
-
-typedef struct pkcs7_enc_content_st {
-    ASN1_OBJECT *content_type;
-    X509_ALGOR *algorithm;
-    ASN1_OCTET_STRING *enc_data; /* [ 0 ] */
-    const EVP_CIPHER *cipher;
-    const PKCS7_CTX *ctx;
-} PKCS7_ENC_CONTENT;
-
-typedef struct pkcs7_enveloped_st {
-    ASN1_INTEGER *version;      /* version 0 */
-    STACK_OF(PKCS7_RECIP_INFO) *recipientinfo;
-    PKCS7_ENC_CONTENT *enc_data;
-} PKCS7_ENVELOPE;
-
-typedef struct pkcs7_signedandenveloped_st {
-    ASN1_INTEGER *version;      /* version 1 */
-    STACK_OF(X509_ALGOR) *md_algs; /* md used */
-    STACK_OF(X509) *cert;       /* [ 0 ] */
-    STACK_OF(X509_CRL) *crl;    /* [ 1 ] */
-    STACK_OF(PKCS7_SIGNER_INFO) *signer_info;
-    PKCS7_ENC_CONTENT *enc_data;
-    STACK_OF(PKCS7_RECIP_INFO) *recipientinfo;
-} PKCS7_SIGN_ENVELOPE;
-
-typedef struct pkcs7_digest_st {
-    ASN1_INTEGER *version;      /* version 0 */
-    X509_ALGOR *md;             /* md used */
-    struct pkcs7_st *contents;
-    ASN1_OCTET_STRING *digest;
-} PKCS7_DIGEST;
-
-typedef struct pkcs7_encrypted_st {
-    ASN1_INTEGER *version;      /* version 0 */
-    PKCS7_ENC_CONTENT *enc_data;
-} PKCS7_ENCRYPT;
-
-typedef struct pkcs7_st {
-    /*
-     * The following is non NULL if it contains ASN1 encoding of this
-     * structure
-     */
-    unsigned char *asn1;
-    long length;
-# define PKCS7_S_HEADER  0
-# define PKCS7_S_BODY    1
-# define PKCS7_S_TAIL    2
-    int state;                  /* used during processing */
-    int detached;
-    ASN1_OBJECT *type;
-    /* content as defined by the type */
+    typedef struct pkcs7_signed_st
+    {
+        ASN1_INTEGER* version;          /* version 1 */
+        STACK_OF(X509_ALGOR) * md_algs; /* md used */
+        STACK_OF(X509) * cert;          /* [ 0 ] */
+        STACK_OF(X509_CRL) * crl;       /* [ 1 ] */
+        STACK_OF(PKCS7_SIGNER_INFO) * signer_info;
+        struct pkcs7_st* contents;
+    } PKCS7_SIGNED;
     /*
-     * all encryption/message digests are applied to the 'contents', leaving
-     * out the 'type' field.
+     * The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about
+     * merging the two
      */
-    union {
-        char *ptr;
-        /* NID_pkcs7_data */
-        ASN1_OCTET_STRING *data;
-        /* NID_pkcs7_signed */
-        PKCS7_SIGNED *sign;
-        /* NID_pkcs7_enveloped */
-        PKCS7_ENVELOPE *enveloped;
-        /* NID_pkcs7_signedAndEnveloped */
-        PKCS7_SIGN_ENVELOPE *signed_and_enveloped;
-        /* NID_pkcs7_digest */
-        PKCS7_DIGEST *digest;
-        /* NID_pkcs7_encrypted */
-        PKCS7_ENCRYPT *encrypted;
-        /* Anything else */
-        ASN1_TYPE *other;
-    } d;
-    PKCS7_CTX ctx;
-} PKCS7;
-SKM_DEFINE_STACK_OF_INTERNAL(PKCS7, PKCS7, PKCS7)
+
+    typedef struct pkcs7_enc_content_st
+    {
+        ASN1_OBJECT* content_type;
+        X509_ALGOR* algorithm;
+        ASN1_OCTET_STRING* enc_data; /* [ 0 ] */
+        const EVP_CIPHER* cipher;
+        const PKCS7_CTX* ctx;
+    } PKCS7_ENC_CONTENT;
+
+    typedef struct pkcs7_enveloped_st
+    {
+        ASN1_INTEGER* version; /* version 0 */
+        STACK_OF(PKCS7_RECIP_INFO) * recipientinfo;
+        PKCS7_ENC_CONTENT* enc_data;
+    } PKCS7_ENVELOPE;
+
+    typedef struct pkcs7_signedandenveloped_st
+    {
+        ASN1_INTEGER* version;          /* version 1 */
+        STACK_OF(X509_ALGOR) * md_algs; /* md used */
+        STACK_OF(X509) * cert;          /* [ 0 ] */
+        STACK_OF(X509_CRL) * crl;       /* [ 1 ] */
+        STACK_OF(PKCS7_SIGNER_INFO) * signer_info;
+        PKCS7_ENC_CONTENT* enc_data;
+        STACK_OF(PKCS7_RECIP_INFO) * recipientinfo;
+    } PKCS7_SIGN_ENVELOPE;
+
+    typedef struct pkcs7_digest_st
+    {
+        ASN1_INTEGER* version; /* version 0 */
+        X509_ALGOR* md;        /* md used */
+        struct pkcs7_st* contents;
+        ASN1_OCTET_STRING* digest;
+    } PKCS7_DIGEST;
+
+    typedef struct pkcs7_encrypted_st
+    {
+        ASN1_INTEGER* version; /* version 0 */
+        PKCS7_ENC_CONTENT* enc_data;
+    } PKCS7_ENCRYPT;
+
+    typedef struct pkcs7_st
+    {
+        /*
+         * The following is non NULL if it contains ASN1 encoding of this
+         * structure
+         */
+        unsigned char* asn1;
+        long length;
+#define PKCS7_S_HEADER 0
+#define PKCS7_S_BODY 1
+#define PKCS7_S_TAIL 2
+        int state; /* used during processing */
+        int detached;
+        ASN1_OBJECT* type;
+        /* content as defined by the type */
+        /*
+         * all encryption/message digests are applied to the 'contents', leaving
+         * out the 'type' field.
+         */
+        union
+        {
+            char* ptr;
+            /* NID_pkcs7_data */
+            ASN1_OCTET_STRING* data;
+            /* NID_pkcs7_signed */
+            PKCS7_SIGNED* sign;
+            /* NID_pkcs7_enveloped */
+            PKCS7_ENVELOPE* enveloped;
+            /* NID_pkcs7_signedAndEnveloped */
+            PKCS7_SIGN_ENVELOPE* signed_and_enveloped;
+            /* NID_pkcs7_digest */
+            PKCS7_DIGEST* digest;
+            /* NID_pkcs7_encrypted */
+            PKCS7_ENCRYPT* encrypted;
+            /* Anything else */
+            ASN1_TYPE* other;
+        } d;
+        PKCS7_CTX ctx;
+    } PKCS7;
+    SKM_DEFINE_STACK_OF_INTERNAL(PKCS7, PKCS7, PKCS7)
 #define sk_PKCS7_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS7_sk_type(sk))
-#define sk_PKCS7_value(sk, idx) ((PKCS7 *)OPENSSL_sk_value(ossl_check_const_PKCS7_sk_type(sk), (idx)))
-#define sk_PKCS7_new(cmp) ((STACK_OF(PKCS7) *)OPENSSL_sk_new(ossl_check_PKCS7_compfunc_type(cmp)))
-#define sk_PKCS7_new_null() ((STACK_OF(PKCS7) *)OPENSSL_sk_new_null())
-#define sk_PKCS7_new_reserve(cmp, n) ((STACK_OF(PKCS7) *)OPENSSL_sk_new_reserve(ossl_check_PKCS7_compfunc_type(cmp), (n)))
+#define sk_PKCS7_value(sk, idx) ((PKCS7*)OPENSSL_sk_value(ossl_check_const_PKCS7_sk_type(sk), (idx)))
+#define sk_PKCS7_new(cmp) ((STACK_OF(PKCS7)*)OPENSSL_sk_new(ossl_check_PKCS7_compfunc_type(cmp)))
+#define sk_PKCS7_new_null() ((STACK_OF(PKCS7)*)OPENSSL_sk_new_null())
+#define sk_PKCS7_new_reserve(cmp, n) ((STACK_OF(PKCS7)*)OPENSSL_sk_new_reserve(ossl_check_PKCS7_compfunc_type(cmp), (n)))
 #define sk_PKCS7_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS7_sk_type(sk), (n))
 #define sk_PKCS7_free(sk) OPENSSL_sk_free(ossl_check_PKCS7_sk_type(sk))
 #define sk_PKCS7_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS7_sk_type(sk))
-#define sk_PKCS7_delete(sk, i) ((PKCS7 *)OPENSSL_sk_delete(ossl_check_PKCS7_sk_type(sk), (i)))
-#define sk_PKCS7_delete_ptr(sk, ptr) ((PKCS7 *)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr)))
+#define sk_PKCS7_delete(sk, i) ((PKCS7*)OPENSSL_sk_delete(ossl_check_PKCS7_sk_type(sk), (i)))
+#define sk_PKCS7_delete_ptr(sk, ptr) ((PKCS7*)OPENSSL_sk_delete_ptr(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr)))
 #define sk_PKCS7_push(sk, ptr) OPENSSL_sk_push(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
 #define sk_PKCS7_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
-#define sk_PKCS7_pop(sk) ((PKCS7 *)OPENSSL_sk_pop(ossl_check_PKCS7_sk_type(sk)))
-#define sk_PKCS7_shift(sk) ((PKCS7 *)OPENSSL_sk_shift(ossl_check_PKCS7_sk_type(sk)))
-#define sk_PKCS7_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_sk_type(sk),ossl_check_PKCS7_freefunc_type(freefunc))
+#define sk_PKCS7_pop(sk) ((PKCS7*)OPENSSL_sk_pop(ossl_check_PKCS7_sk_type(sk)))
+#define sk_PKCS7_shift(sk) ((PKCS7*)OPENSSL_sk_shift(ossl_check_PKCS7_sk_type(sk)))
+#define sk_PKCS7_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_freefunc_type(freefunc))
 #define sk_PKCS7_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), (idx))
-#define sk_PKCS7_set(sk, idx, ptr) ((PKCS7 *)OPENSSL_sk_set(ossl_check_PKCS7_sk_type(sk), (idx), ossl_check_PKCS7_type(ptr)))
+#define sk_PKCS7_set(sk, idx, ptr) ((PKCS7*)OPENSSL_sk_set(ossl_check_PKCS7_sk_type(sk), (idx), ossl_check_PKCS7_type(ptr)))
 #define sk_PKCS7_find(sk, ptr) OPENSSL_sk_find(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
 #define sk_PKCS7_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr))
 #define sk_PKCS7_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_type(ptr), pnum)
 #define sk_PKCS7_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS7_sk_type(sk))
 #define sk_PKCS7_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS7_sk_type(sk))
-#define sk_PKCS7_dup(sk) ((STACK_OF(PKCS7) *)OPENSSL_sk_dup(ossl_check_const_PKCS7_sk_type(sk)))
-#define sk_PKCS7_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_sk_type(sk), ossl_check_PKCS7_copyfunc_type(copyfunc), ossl_check_PKCS7_freefunc_type(freefunc)))
+#define sk_PKCS7_dup(sk) ((STACK_OF(PKCS7)*)OPENSSL_sk_dup(ossl_check_const_PKCS7_sk_type(sk)))
+#define sk_PKCS7_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS7)*)OPENSSL_sk_deep_copy(ossl_check_const_PKCS7_sk_type(sk), ossl_check_PKCS7_copyfunc_type(copyfunc), ossl_check_PKCS7_freefunc_type(freefunc)))
 #define sk_PKCS7_set_cmp_func(sk, cmp) ((sk_PKCS7_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS7_sk_type(sk), ossl_check_PKCS7_compfunc_type(cmp)))
 
+#define PKCS7_OP_SET_DETACHED_SIGNATURE 1
+#define PKCS7_OP_GET_DETACHED_SIGNATURE 2
+
+#define PKCS7_get_signed_attributes(si) ((si)->auth_attr)
+#define PKCS7_get_attributes(si) ((si)->unauth_attr)
+
+#define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed)
+#define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted)
+#define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped)
+#define PKCS7_type_is_signedAndEnveloped(a) \
+    (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped)
+#define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data)
+#define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest)
+
+#define PKCS7_set_detached(p, v) \
+    PKCS7_ctrl(p, PKCS7_OP_SET_DETACHED_SIGNATURE, v, NULL)
+#define PKCS7_get_detached(p) \
+    PKCS7_ctrl(p, PKCS7_OP_GET_DETACHED_SIGNATURE, 0, NULL)
+
+#define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7))
+
+    /* S/MIME related flags */
+
+#define PKCS7_TEXT 0x1
+#define PKCS7_NOCERTS 0x2
+#define PKCS7_NOSIGS 0x4
+#define PKCS7_NOCHAIN 0x8
+#define PKCS7_NOINTERN 0x10
+#define PKCS7_NOVERIFY 0x20
+#define PKCS7_DETACHED 0x40
+#define PKCS7_BINARY 0x80
+#define PKCS7_NOATTR 0x100
+#define PKCS7_NOSMIMECAP 0x200
+#define PKCS7_NOOLDMIMETYPE 0x400
+#define PKCS7_CRLFEOL 0x800
+#define PKCS7_STREAM 0x1000
+#define PKCS7_NOCRL 0x2000
+#define PKCS7_PARTIAL 0x4000
+#define PKCS7_REUSE_DIGEST 0x8000
+#define PKCS7_NO_DUAL_CONTENT 0x10000
+
+    /* Flags: for compatibility with older code */
+
+#define SMIME_TEXT PKCS7_TEXT
+#define SMIME_NOCERTS PKCS7_NOCERTS
+#define SMIME_NOSIGS PKCS7_NOSIGS
+#define SMIME_NOCHAIN PKCS7_NOCHAIN
+#define SMIME_NOINTERN PKCS7_NOINTERN
+#define SMIME_NOVERIFY PKCS7_NOVERIFY
+#define SMIME_DETACHED PKCS7_DETACHED
+#define SMIME_BINARY PKCS7_BINARY
+#define SMIME_NOATTR PKCS7_NOATTR
 
+/* CRLF ASCII canonicalisation */
+#define SMIME_ASCIICRLF 0x80000
 
-# define PKCS7_OP_SET_DETACHED_SIGNATURE 1
-# define PKCS7_OP_GET_DETACHED_SIGNATURE 2
-
-# define PKCS7_get_signed_attributes(si) ((si)->auth_attr)
-# define PKCS7_get_attributes(si)        ((si)->unauth_attr)
-
-# define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed)
-# define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted)
-# define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped)
-# define PKCS7_type_is_signedAndEnveloped(a) \
-                (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped)
-# define PKCS7_type_is_data(a)   (OBJ_obj2nid((a)->type) == NID_pkcs7_data)
-# define PKCS7_type_is_digest(a)   (OBJ_obj2nid((a)->type) == NID_pkcs7_digest)
-
-# define PKCS7_set_detached(p,v) \
-                PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL)
-# define PKCS7_get_detached(p) \
-                PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL)
-
-# define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7))
-
-/* S/MIME related flags */
-
-# define PKCS7_TEXT              0x1
-# define PKCS7_NOCERTS           0x2
-# define PKCS7_NOSIGS            0x4
-# define PKCS7_NOCHAIN           0x8
-# define PKCS7_NOINTERN          0x10
-# define PKCS7_NOVERIFY          0x20
-# define PKCS7_DETACHED          0x40
-# define PKCS7_BINARY            0x80
-# define PKCS7_NOATTR            0x100
-# define PKCS7_NOSMIMECAP        0x200
-# define PKCS7_NOOLDMIMETYPE     0x400
-# define PKCS7_CRLFEOL           0x800
-# define PKCS7_STREAM            0x1000
-# define PKCS7_NOCRL             0x2000
-# define PKCS7_PARTIAL           0x4000
-# define PKCS7_REUSE_DIGEST      0x8000
-# define PKCS7_NO_DUAL_CONTENT   0x10000
-
-/* Flags: for compatibility with older code */
-
-# define SMIME_TEXT      PKCS7_TEXT
-# define SMIME_NOCERTS   PKCS7_NOCERTS
-# define SMIME_NOSIGS    PKCS7_NOSIGS
-# define SMIME_NOCHAIN   PKCS7_NOCHAIN
-# define SMIME_NOINTERN  PKCS7_NOINTERN
-# define SMIME_NOVERIFY  PKCS7_NOVERIFY
-# define SMIME_DETACHED  PKCS7_DETACHED
-# define SMIME_BINARY    PKCS7_BINARY
-# define SMIME_NOATTR    PKCS7_NOATTR
+    DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL)
 
-/* CRLF ASCII canonicalisation */
-# define SMIME_ASCIICRLF         0x80000
-
-DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL)
-
-int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
-                                   const EVP_MD *type, unsigned char *md,
-                                   unsigned int *len);
-# ifndef OPENSSL_NO_STDIO
-PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7);
-int i2d_PKCS7_fp(FILE *fp, const PKCS7 *p7);
-# endif
-DECLARE_ASN1_DUP_FUNCTION(PKCS7)
-PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7);
-int i2d_PKCS7_bio(BIO *bp, const PKCS7 *p7);
-int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
-int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
-
-DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO)
-DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO)
-DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED)
-DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT)
-DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE)
-DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE)
-DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST)
-DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT)
-DECLARE_ASN1_FUNCTIONS(PKCS7)
-PKCS7 *PKCS7_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
-
-DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN)
-DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY)
-
-DECLARE_ASN1_NDEF_FUNCTION(PKCS7)
-DECLARE_ASN1_PRINT_FUNCTION(PKCS7)
-
-long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg);
-
-int PKCS7_type_is_other(PKCS7 *p7);
-int PKCS7_set_type(PKCS7 *p7, int type);
-int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other);
-int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data);
-int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
-                          const EVP_MD *dgst);
-int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si);
-int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i);
-int PKCS7_add_certificate(PKCS7 *p7, X509 *x509);
-int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509);
-int PKCS7_content_new(PKCS7 *p7, int nid);
-int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx,
-                     BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si);
-int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si,
-                          X509 *x509);
-
-BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio);
-int PKCS7_dataFinal(PKCS7 *p7, BIO *bio);
-BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert);
-
-PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509,
-                                       EVP_PKEY *pkey, const EVP_MD *dgst);
-X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si);
-int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md);
-STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7);
-
-PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509);
-void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
-                                 X509_ALGOR **pdig, X509_ALGOR **psig);
-void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc);
-int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri);
-int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509);
-int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher);
-int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7);
-
-PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx);
-ASN1_OCTET_STRING *PKCS7_get_octet_string(PKCS7 *p7);
-ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk);
-int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int type,
-                               void *data);
-int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
-                        void *value);
-ASN1_TYPE *PKCS7_get_attribute(const PKCS7_SIGNER_INFO *si, int nid);
-ASN1_TYPE *PKCS7_get_signed_attribute(const PKCS7_SIGNER_INFO *si, int nid);
-int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
-                                STACK_OF(X509_ATTRIBUTE) *sk);
-int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si,
-                         STACK_OF(X509_ATTRIBUTE) *sk);
-
-PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
-                  BIO *data, int flags);
-PKCS7 *PKCS7_sign_ex(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
-                     BIO *data, int flags, OSSL_LIB_CTX *libctx,
-                     const char *propq);
-
-PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7,
-                                         X509 *signcert, EVP_PKEY *pkey,
-                                         const EVP_MD *md, int flags);
-
-int PKCS7_final(PKCS7 *p7, BIO *data, int flags);
-int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store,
-                 BIO *indata, BIO *out, int flags);
-STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs,
-                                   int flags);
-PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher,
-                     int flags);
-PKCS7 *PKCS7_encrypt_ex(STACK_OF(X509) *certs, BIO *in,
-                        const EVP_CIPHER *cipher, int flags,
-                        OSSL_LIB_CTX *libctx, const char *propq);
-int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data,
-                  int flags);
-
-int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si,
-                              STACK_OF(X509_ALGOR) *cap);
-STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si);
-int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg);
-
-int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid);
-int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t);
-int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si,
-                             const unsigned char *md, int mdlen);
-
-int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags);
-PKCS7 *SMIME_read_PKCS7_ex(BIO *bio, BIO **bcont, PKCS7 **p7);
-PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont);
-
-BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7);
-
-# ifdef  __cplusplus
+    int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL* data, const EVP_MD* type, unsigned char* md, unsigned int* len);
+#ifndef OPENSSL_NO_STDIO
+    PKCS7* d2i_PKCS7_fp(FILE* fp, PKCS7** p7);
+    int i2d_PKCS7_fp(FILE* fp, const PKCS7* p7);
+#endif
+    DECLARE_ASN1_DUP_FUNCTION(PKCS7)
+    PKCS7* d2i_PKCS7_bio(BIO* bp, PKCS7** p7);
+    int i2d_PKCS7_bio(BIO* bp, const PKCS7* p7);
+    int i2d_PKCS7_bio_stream(BIO* out, PKCS7* p7, BIO* in, int flags);
+    int PEM_write_bio_PKCS7_stream(BIO* out, PKCS7* p7, BIO* in, int flags);
+
+    DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO)
+    DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO)
+    DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED)
+    DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT)
+    DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE)
+    DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE)
+    DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST)
+    DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT)
+    DECLARE_ASN1_FUNCTIONS(PKCS7)
+    PKCS7* PKCS7_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+
+    DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN)
+    DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY)
+
+    DECLARE_ASN1_NDEF_FUNCTION(PKCS7)
+    DECLARE_ASN1_PRINT_FUNCTION(PKCS7)
+
+    long PKCS7_ctrl(PKCS7* p7, int cmd, long larg, char* parg);
+
+    int PKCS7_type_is_other(PKCS7* p7);
+    int PKCS7_set_type(PKCS7* p7, int type);
+    int PKCS7_set0_type_other(PKCS7* p7, int type, ASN1_TYPE* other);
+    int PKCS7_set_content(PKCS7* p7, PKCS7* p7_data);
+    int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO* p7i, X509* x509, EVP_PKEY* pkey, const EVP_MD* dgst);
+    int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO* si);
+    int PKCS7_add_signer(PKCS7* p7, PKCS7_SIGNER_INFO* p7i);
+    int PKCS7_add_certificate(PKCS7* p7, X509* x509);
+    int PKCS7_add_crl(PKCS7* p7, X509_CRL* x509);
+    int PKCS7_content_new(PKCS7* p7, int nid);
+    int PKCS7_dataVerify(X509_STORE* cert_store, X509_STORE_CTX* ctx, BIO* bio, PKCS7* p7, PKCS7_SIGNER_INFO* si);
+    int PKCS7_signatureVerify(BIO* bio, PKCS7* p7, PKCS7_SIGNER_INFO* si, X509* x509);
+
+    BIO* PKCS7_dataInit(PKCS7* p7, BIO* bio);
+    int PKCS7_dataFinal(PKCS7* p7, BIO* bio);
+    BIO* PKCS7_dataDecode(PKCS7* p7, EVP_PKEY* pkey, BIO* in_bio, X509* pcert);
+
+    PKCS7_SIGNER_INFO* PKCS7_add_signature(PKCS7* p7, X509* x509, EVP_PKEY* pkey, const EVP_MD* dgst);
+    X509* PKCS7_cert_from_signer_info(PKCS7* p7, PKCS7_SIGNER_INFO* si);
+    int PKCS7_set_digest(PKCS7* p7, const EVP_MD* md);
+    STACK_OF(PKCS7_SIGNER_INFO) * PKCS7_get_signer_info(PKCS7* p7);
+
+    PKCS7_RECIP_INFO* PKCS7_add_recipient(PKCS7* p7, X509* x509);
+    void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO* si, EVP_PKEY** pk, X509_ALGOR** pdig, X509_ALGOR** psig);
+    void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO* ri, X509_ALGOR** penc);
+    int PKCS7_add_recipient_info(PKCS7* p7, PKCS7_RECIP_INFO* ri);
+    int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO* p7i, X509* x509);
+    int PKCS7_set_cipher(PKCS7* p7, const EVP_CIPHER* cipher);
+    int PKCS7_stream(unsigned char*** boundary, PKCS7* p7);
+
+    PKCS7_ISSUER_AND_SERIAL* PKCS7_get_issuer_and_serial(PKCS7* p7, int idx);
+    ASN1_OCTET_STRING* PKCS7_get_octet_string(PKCS7* p7);
+    ASN1_OCTET_STRING* PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) * sk);
+    int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO* p7si, int nid, int type, void* data);
+    int PKCS7_add_attribute(PKCS7_SIGNER_INFO* p7si, int nid, int atrtype, void* value);
+    ASN1_TYPE* PKCS7_get_attribute(const PKCS7_SIGNER_INFO* si, int nid);
+    ASN1_TYPE* PKCS7_get_signed_attribute(const PKCS7_SIGNER_INFO* si, int nid);
+    int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO* p7si, STACK_OF(X509_ATTRIBUTE) * sk);
+    int PKCS7_set_attributes(PKCS7_SIGNER_INFO* p7si, STACK_OF(X509_ATTRIBUTE) * sk);
+
+    PKCS7* PKCS7_sign(X509* signcert, EVP_PKEY* pkey, STACK_OF(X509) * certs, BIO* data, int flags);
+    PKCS7* PKCS7_sign_ex(X509* signcert, EVP_PKEY* pkey, STACK_OF(X509) * certs, BIO* data, int flags, OSSL_LIB_CTX* libctx, const char* propq);
+
+    PKCS7_SIGNER_INFO* PKCS7_sign_add_signer(PKCS7* p7, X509* signcert, EVP_PKEY* pkey, const EVP_MD* md, int flags);
+
+    int PKCS7_final(PKCS7* p7, BIO* data, int flags);
+    int PKCS7_verify(PKCS7* p7, STACK_OF(X509) * certs, X509_STORE* store, BIO* indata, BIO* out, int flags);
+    STACK_OF(X509) * PKCS7_get0_signers(PKCS7* p7, STACK_OF(X509) * certs, int flags);
+    PKCS7* PKCS7_encrypt(STACK_OF(X509) * certs, BIO* in, const EVP_CIPHER* cipher, int flags);
+    PKCS7* PKCS7_encrypt_ex(STACK_OF(X509) * certs, BIO* in, const EVP_CIPHER* cipher, int flags, OSSL_LIB_CTX* libctx, const char* propq);
+    int PKCS7_decrypt(PKCS7* p7, EVP_PKEY* pkey, X509* cert, BIO* data, int flags);
+
+    int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO* si, STACK_OF(X509_ALGOR) * cap);
+    STACK_OF(X509_ALGOR) * PKCS7_get_smimecap(PKCS7_SIGNER_INFO* si);
+    int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) * sk, int nid, int arg);
+
+    int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO* si, ASN1_OBJECT* coid);
+    int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO* si, ASN1_TIME* t);
+    int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO* si, const unsigned char* md, int mdlen);
+
+    int SMIME_write_PKCS7(BIO* bio, PKCS7* p7, BIO* data, int flags);
+    PKCS7* SMIME_read_PKCS7_ex(BIO* bio, BIO** bcont, PKCS7** p7);
+    PKCS7* SMIME_read_PKCS7(BIO* bio, BIO** bcont);
+
+    BIO* BIO_new_PKCS7(BIO* out, PKCS7* p7);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/pkcs7err.h b/CAPI/cpp/grpc/include/openssl/pkcs7err.h
index ceb1a50..358fe10 100644
--- a/CAPI/cpp/grpc/include/openssl/pkcs7err.h
+++ b/CAPI/cpp/grpc/include/openssl/pkcs7err.h
@@ -9,55 +9,53 @@
  */
 
 #ifndef OPENSSL_PKCS7ERR_H
-# define OPENSSL_PKCS7ERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_PKCS7ERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * PKCS7 reason codes.
  */
-# define PKCS7_R_CERTIFICATE_VERIFY_ERROR                 117
-# define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER          144
-# define PKCS7_R_CIPHER_NOT_INITIALIZED                   116
-# define PKCS7_R_CONTENT_AND_DATA_PRESENT                 118
-# define PKCS7_R_CTRL_ERROR                               152
-# define PKCS7_R_DECRYPT_ERROR                            119
-# define PKCS7_R_DIGEST_FAILURE                           101
-# define PKCS7_R_ENCRYPTION_CTRL_FAILURE                  149
-# define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150
-# define PKCS7_R_ERROR_ADDING_RECIPIENT                   120
-# define PKCS7_R_ERROR_SETTING_CIPHER                     121
-# define PKCS7_R_INVALID_NULL_POINTER                     143
-# define PKCS7_R_INVALID_SIGNED_DATA_TYPE                 155
-# define PKCS7_R_NO_CONTENT                               122
-# define PKCS7_R_NO_DEFAULT_DIGEST                        151
-# define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND            154
-# define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE         115
-# define PKCS7_R_NO_SIGNATURES_ON_DATA                    123
-# define PKCS7_R_NO_SIGNERS                               142
-# define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE     104
-# define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR                124
-# define PKCS7_R_PKCS7_ADD_SIGNER_ERROR                   153
-# define PKCS7_R_PKCS7_DATASIGN                           145
-# define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE   127
-# define PKCS7_R_SIGNATURE_FAILURE                        105
-# define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND             128
-# define PKCS7_R_SIGNING_CTRL_FAILURE                     147
-# define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE  148
-# define PKCS7_R_SMIME_TEXT_ERROR                         129
-# define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE               106
-# define PKCS7_R_UNABLE_TO_FIND_MEM_BIO                   107
-# define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST            108
-# define PKCS7_R_UNKNOWN_DIGEST_TYPE                      109
-# define PKCS7_R_UNKNOWN_OPERATION                        110
-# define PKCS7_R_UNSUPPORTED_CIPHER_TYPE                  111
-# define PKCS7_R_UNSUPPORTED_CONTENT_TYPE                 112
-# define PKCS7_R_WRONG_CONTENT_TYPE                       113
-# define PKCS7_R_WRONG_PKCS7_TYPE                         114
+#define PKCS7_R_CERTIFICATE_VERIFY_ERROR 117
+#define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 144
+#define PKCS7_R_CIPHER_NOT_INITIALIZED 116
+#define PKCS7_R_CONTENT_AND_DATA_PRESENT 118
+#define PKCS7_R_CTRL_ERROR 152
+#define PKCS7_R_DECRYPT_ERROR 119
+#define PKCS7_R_DIGEST_FAILURE 101
+#define PKCS7_R_ENCRYPTION_CTRL_FAILURE 149
+#define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150
+#define PKCS7_R_ERROR_ADDING_RECIPIENT 120
+#define PKCS7_R_ERROR_SETTING_CIPHER 121
+#define PKCS7_R_INVALID_NULL_POINTER 143
+#define PKCS7_R_INVALID_SIGNED_DATA_TYPE 155
+#define PKCS7_R_NO_CONTENT 122
+#define PKCS7_R_NO_DEFAULT_DIGEST 151
+#define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND 154
+#define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE 115
+#define PKCS7_R_NO_SIGNATURES_ON_DATA 123
+#define PKCS7_R_NO_SIGNERS 142
+#define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE 104
+#define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR 124
+#define PKCS7_R_PKCS7_ADD_SIGNER_ERROR 153
+#define PKCS7_R_PKCS7_DATASIGN 145
+#define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 127
+#define PKCS7_R_SIGNATURE_FAILURE 105
+#define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND 128
+#define PKCS7_R_SIGNING_CTRL_FAILURE 147
+#define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 148
+#define PKCS7_R_SMIME_TEXT_ERROR 129
+#define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE 106
+#define PKCS7_R_UNABLE_TO_FIND_MEM_BIO 107
+#define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST 108
+#define PKCS7_R_UNKNOWN_DIGEST_TYPE 109
+#define PKCS7_R_UNKNOWN_OPERATION 110
+#define PKCS7_R_UNSUPPORTED_CIPHER_TYPE 111
+#define PKCS7_R_UNSUPPORTED_CONTENT_TYPE 112
+#define PKCS7_R_WRONG_CONTENT_TYPE 113
+#define PKCS7_R_WRONG_PKCS7_TYPE 114
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/prov_ssl.h b/CAPI/cpp/grpc/include/openssl/prov_ssl.h
index d3e0896..2b0d6d7 100644
--- a/CAPI/cpp/grpc/include/openssl/prov_ssl.h
+++ b/CAPI/cpp/grpc/include/openssl/prov_ssl.h
@@ -8,27 +8,28 @@
  */
 
 #ifndef OPENSSL_PROV_SSL_H
-# define OPENSSL_PROV_SSL_H
-# pragma once
+#define OPENSSL_PROV_SSL_H
+#pragma once
 
-# ifdef __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-/* SSL/TLS related defines useful to providers */
+    /* SSL/TLS related defines useful to providers */
 
-# define SSL_MAX_MASTER_KEY_LENGTH 48
+#define SSL_MAX_MASTER_KEY_LENGTH 48
 
-# define SSL3_VERSION                    0x0300
-# define TLS1_VERSION                    0x0301
-# define TLS1_1_VERSION                  0x0302
-# define TLS1_2_VERSION                  0x0303
-# define TLS1_3_VERSION                  0x0304
-# define DTLS1_VERSION                   0xFEFF
-# define DTLS1_2_VERSION                 0xFEFD
-# define DTLS1_BAD_VER                   0x0100
+#define SSL3_VERSION 0x0300
+#define TLS1_VERSION 0x0301
+#define TLS1_1_VERSION 0x0302
+#define TLS1_2_VERSION 0x0303
+#define TLS1_3_VERSION 0x0304
+#define DTLS1_VERSION 0xFEFF
+#define DTLS1_2_VERSION 0xFEFD
+#define DTLS1_BAD_VER 0x0100
 
-# ifdef __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif /* OPENSSL_PROV_SSL_H */
diff --git a/CAPI/cpp/grpc/include/openssl/proverr.h b/CAPI/cpp/grpc/include/openssl/proverr.h
index ad67a8f..464b857 100644
--- a/CAPI/cpp/grpc/include/openssl/proverr.h
+++ b/CAPI/cpp/grpc/include/openssl/proverr.h
@@ -9,140 +9,138 @@
  */
 
 #ifndef OPENSSL_PROVERR_H
-# define OPENSSL_PROVERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_PROVERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * PROV reason codes.
  */
-# define PROV_R_ADDITIONAL_INPUT_TOO_LONG                 184
-# define PROV_R_ALGORITHM_MISMATCH                        173
-# define PROV_R_ALREADY_INSTANTIATED                      185
-# define PROV_R_BAD_DECRYPT                               100
-# define PROV_R_BAD_ENCODING                              141
-# define PROV_R_BAD_LENGTH                                142
-# define PROV_R_BAD_TLS_CLIENT_VERSION                    161
-# define PROV_R_BN_ERROR                                  160
-# define PROV_R_CIPHER_OPERATION_FAILED                   102
-# define PROV_R_DERIVATION_FUNCTION_INIT_FAILED           205
-# define PROV_R_DIGEST_NOT_ALLOWED                        174
-# define PROV_R_ENTROPY_SOURCE_STRENGTH_TOO_WEAK          186
-# define PROV_R_ERROR_INSTANTIATING_DRBG                  188
-# define PROV_R_ERROR_RETRIEVING_ENTROPY                  189
-# define PROV_R_ERROR_RETRIEVING_NONCE                    190
-# define PROV_R_FAILED_DURING_DERIVATION                  164
-# define PROV_R_FAILED_TO_CREATE_LOCK                     180
-# define PROV_R_FAILED_TO_DECRYPT                         162
-# define PROV_R_FAILED_TO_GENERATE_KEY                    121
-# define PROV_R_FAILED_TO_GET_PARAMETER                   103
-# define PROV_R_FAILED_TO_SET_PARAMETER                   104
-# define PROV_R_FAILED_TO_SIGN                            175
-# define PROV_R_FIPS_MODULE_CONDITIONAL_ERROR             227
-# define PROV_R_FIPS_MODULE_ENTERING_ERROR_STATE          224
-# define PROV_R_FIPS_MODULE_IN_ERROR_STATE                225
-# define PROV_R_GENERATE_ERROR                            191
-# define PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE       165
-# define PROV_R_INDICATOR_INTEGRITY_FAILURE               210
-# define PROV_R_INSUFFICIENT_DRBG_STRENGTH                181
-# define PROV_R_INVALID_AAD                               108
-# define PROV_R_INVALID_CONFIG_DATA                       211
-# define PROV_R_INVALID_CONSTANT_LENGTH                   157
-# define PROV_R_INVALID_CURVE                             176
-# define PROV_R_INVALID_CUSTOM_LENGTH                     111
-# define PROV_R_INVALID_DATA                              115
-# define PROV_R_INVALID_DIGEST                            122
-# define PROV_R_INVALID_DIGEST_LENGTH                     166
-# define PROV_R_INVALID_DIGEST_SIZE                       218
-# define PROV_R_INVALID_INPUT_LENGTH                      230
-# define PROV_R_INVALID_ITERATION_COUNT                   123
-# define PROV_R_INVALID_IV_LENGTH                         109
-# define PROV_R_INVALID_KEY                               158
-# define PROV_R_INVALID_KEY_LENGTH                        105
-# define PROV_R_INVALID_MAC                               151
-# define PROV_R_INVALID_MGF1_MD                           167
-# define PROV_R_INVALID_MODE                              125
-# define PROV_R_INVALID_OUTPUT_LENGTH                     217
-# define PROV_R_INVALID_PADDING_MODE                      168
-# define PROV_R_INVALID_PUBINFO                           198
-# define PROV_R_INVALID_SALT_LENGTH                       112
-# define PROV_R_INVALID_SEED_LENGTH                       154
-# define PROV_R_INVALID_SIGNATURE_SIZE                    179
-# define PROV_R_INVALID_STATE                             212
-# define PROV_R_INVALID_TAG                               110
-# define PROV_R_INVALID_TAG_LENGTH                        118
-# define PROV_R_INVALID_UKM_LENGTH                        200
-# define PROV_R_INVALID_X931_DIGEST                       170
-# define PROV_R_IN_ERROR_STATE                            192
-# define PROV_R_KEY_SETUP_FAILED                          101
-# define PROV_R_KEY_SIZE_TOO_SMALL                        171
-# define PROV_R_LENGTH_TOO_LARGE                          202
-# define PROV_R_MISMATCHING_DOMAIN_PARAMETERS             203
-# define PROV_R_MISSING_CEK_ALG                           144
-# define PROV_R_MISSING_CIPHER                            155
-# define PROV_R_MISSING_CONFIG_DATA                       213
-# define PROV_R_MISSING_CONSTANT                          156
-# define PROV_R_MISSING_KEY                               128
-# define PROV_R_MISSING_MAC                               150
-# define PROV_R_MISSING_MESSAGE_DIGEST                    129
-# define PROV_R_MISSING_OID                               209
-# define PROV_R_MISSING_PASS                              130
-# define PROV_R_MISSING_SALT                              131
-# define PROV_R_MISSING_SECRET                            132
-# define PROV_R_MISSING_SEED                              140
-# define PROV_R_MISSING_SESSION_ID                        133
-# define PROV_R_MISSING_TYPE                              134
-# define PROV_R_MISSING_XCGHASH                           135
-# define PROV_R_MODULE_INTEGRITY_FAILURE                  214
-# define PROV_R_NOT_A_PRIVATE_KEY                         221
-# define PROV_R_NOT_A_PUBLIC_KEY                          220
-# define PROV_R_NOT_INSTANTIATED                          193
-# define PROV_R_NOT_PARAMETERS                            226
-# define PROV_R_NOT_SUPPORTED                             136
-# define PROV_R_NOT_XOF_OR_INVALID_LENGTH                 113
-# define PROV_R_NO_KEY_SET                                114
-# define PROV_R_NO_PARAMETERS_SET                         177
-# define PROV_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE  178
-# define PROV_R_OUTPUT_BUFFER_TOO_SMALL                   106
-# define PROV_R_PARENT_CANNOT_GENERATE_RANDOM_NUMBERS     228
-# define PROV_R_PARENT_CANNOT_SUPPLY_ENTROPY_SEED         187
-# define PROV_R_PARENT_LOCKING_NOT_ENABLED                182
-# define PROV_R_PARENT_STRENGTH_TOO_WEAK                  194
-# define PROV_R_PATH_MUST_BE_ABSOLUTE                     219
-# define PROV_R_PERSONALISATION_STRING_TOO_LONG           195
-# define PROV_R_PSS_SALTLEN_TOO_SMALL                     172
-# define PROV_R_REQUEST_TOO_LARGE_FOR_DRBG                196
-# define PROV_R_REQUIRE_CTR_MODE_CIPHER                   206
-# define PROV_R_RESEED_ERROR                              197
-# define PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES     222
-# define PROV_R_SEED_SOURCES_MUST_NOT_HAVE_A_PARENT       229
-# define PROV_R_SELF_TEST_KAT_FAILURE                     215
-# define PROV_R_SELF_TEST_POST_FAILURE                    216
-# define PROV_R_TAG_NOT_NEEDED                            120
-# define PROV_R_TAG_NOT_SET                               119
-# define PROV_R_TOO_MANY_RECORDS                          126
-# define PROV_R_UNABLE_TO_FIND_CIPHERS                    207
-# define PROV_R_UNABLE_TO_GET_PARENT_STRENGTH             199
-# define PROV_R_UNABLE_TO_GET_PASSPHRASE                  159
-# define PROV_R_UNABLE_TO_INITIALISE_CIPHERS              208
-# define PROV_R_UNABLE_TO_LOAD_SHA256                     147
-# define PROV_R_UNABLE_TO_LOCK_PARENT                     201
-# define PROV_R_UNABLE_TO_RESEED                          204
-# define PROV_R_UNSUPPORTED_CEK_ALG                       145
-# define PROV_R_UNSUPPORTED_KEY_SIZE                      153
-# define PROV_R_UNSUPPORTED_MAC_TYPE                      137
-# define PROV_R_UNSUPPORTED_NUMBER_OF_ROUNDS              152
-# define PROV_R_URI_AUTHORITY_UNSUPPORTED                 223
-# define PROV_R_VALUE_ERROR                               138
-# define PROV_R_WRONG_FINAL_BLOCK_LENGTH                  107
-# define PROV_R_WRONG_OUTPUT_BUFFER_SIZE                  139
-# define PROV_R_XOF_DIGESTS_NOT_ALLOWED                   183
-# define PROV_R_XTS_DATA_UNIT_IS_TOO_LARGE                148
-# define PROV_R_XTS_DUPLICATED_KEYS                       149
+#define PROV_R_ADDITIONAL_INPUT_TOO_LONG 184
+#define PROV_R_ALGORITHM_MISMATCH 173
+#define PROV_R_ALREADY_INSTANTIATED 185
+#define PROV_R_BAD_DECRYPT 100
+#define PROV_R_BAD_ENCODING 141
+#define PROV_R_BAD_LENGTH 142
+#define PROV_R_BAD_TLS_CLIENT_VERSION 161
+#define PROV_R_BN_ERROR 160
+#define PROV_R_CIPHER_OPERATION_FAILED 102
+#define PROV_R_DERIVATION_FUNCTION_INIT_FAILED 205
+#define PROV_R_DIGEST_NOT_ALLOWED 174
+#define PROV_R_ENTROPY_SOURCE_STRENGTH_TOO_WEAK 186
+#define PROV_R_ERROR_INSTANTIATING_DRBG 188
+#define PROV_R_ERROR_RETRIEVING_ENTROPY 189
+#define PROV_R_ERROR_RETRIEVING_NONCE 190
+#define PROV_R_FAILED_DURING_DERIVATION 164
+#define PROV_R_FAILED_TO_CREATE_LOCK 180
+#define PROV_R_FAILED_TO_DECRYPT 162
+#define PROV_R_FAILED_TO_GENERATE_KEY 121
+#define PROV_R_FAILED_TO_GET_PARAMETER 103
+#define PROV_R_FAILED_TO_SET_PARAMETER 104
+#define PROV_R_FAILED_TO_SIGN 175
+#define PROV_R_FIPS_MODULE_CONDITIONAL_ERROR 227
+#define PROV_R_FIPS_MODULE_ENTERING_ERROR_STATE 224
+#define PROV_R_FIPS_MODULE_IN_ERROR_STATE 225
+#define PROV_R_GENERATE_ERROR 191
+#define PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 165
+#define PROV_R_INDICATOR_INTEGRITY_FAILURE 210
+#define PROV_R_INSUFFICIENT_DRBG_STRENGTH 181
+#define PROV_R_INVALID_AAD 108
+#define PROV_R_INVALID_CONFIG_DATA 211
+#define PROV_R_INVALID_CONSTANT_LENGTH 157
+#define PROV_R_INVALID_CURVE 176
+#define PROV_R_INVALID_CUSTOM_LENGTH 111
+#define PROV_R_INVALID_DATA 115
+#define PROV_R_INVALID_DIGEST 122
+#define PROV_R_INVALID_DIGEST_LENGTH 166
+#define PROV_R_INVALID_DIGEST_SIZE 218
+#define PROV_R_INVALID_INPUT_LENGTH 230
+#define PROV_R_INVALID_ITERATION_COUNT 123
+#define PROV_R_INVALID_IV_LENGTH 109
+#define PROV_R_INVALID_KEY 158
+#define PROV_R_INVALID_KEY_LENGTH 105
+#define PROV_R_INVALID_MAC 151
+#define PROV_R_INVALID_MGF1_MD 167
+#define PROV_R_INVALID_MODE 125
+#define PROV_R_INVALID_OUTPUT_LENGTH 217
+#define PROV_R_INVALID_PADDING_MODE 168
+#define PROV_R_INVALID_PUBINFO 198
+#define PROV_R_INVALID_SALT_LENGTH 112
+#define PROV_R_INVALID_SEED_LENGTH 154
+#define PROV_R_INVALID_SIGNATURE_SIZE 179
+#define PROV_R_INVALID_STATE 212
+#define PROV_R_INVALID_TAG 110
+#define PROV_R_INVALID_TAG_LENGTH 118
+#define PROV_R_INVALID_UKM_LENGTH 200
+#define PROV_R_INVALID_X931_DIGEST 170
+#define PROV_R_IN_ERROR_STATE 192
+#define PROV_R_KEY_SETUP_FAILED 101
+#define PROV_R_KEY_SIZE_TOO_SMALL 171
+#define PROV_R_LENGTH_TOO_LARGE 202
+#define PROV_R_MISMATCHING_DOMAIN_PARAMETERS 203
+#define PROV_R_MISSING_CEK_ALG 144
+#define PROV_R_MISSING_CIPHER 155
+#define PROV_R_MISSING_CONFIG_DATA 213
+#define PROV_R_MISSING_CONSTANT 156
+#define PROV_R_MISSING_KEY 128
+#define PROV_R_MISSING_MAC 150
+#define PROV_R_MISSING_MESSAGE_DIGEST 129
+#define PROV_R_MISSING_OID 209
+#define PROV_R_MISSING_PASS 130
+#define PROV_R_MISSING_SALT 131
+#define PROV_R_MISSING_SECRET 132
+#define PROV_R_MISSING_SEED 140
+#define PROV_R_MISSING_SESSION_ID 133
+#define PROV_R_MISSING_TYPE 134
+#define PROV_R_MISSING_XCGHASH 135
+#define PROV_R_MODULE_INTEGRITY_FAILURE 214
+#define PROV_R_NOT_A_PRIVATE_KEY 221
+#define PROV_R_NOT_A_PUBLIC_KEY 220
+#define PROV_R_NOT_INSTANTIATED 193
+#define PROV_R_NOT_PARAMETERS 226
+#define PROV_R_NOT_SUPPORTED 136
+#define PROV_R_NOT_XOF_OR_INVALID_LENGTH 113
+#define PROV_R_NO_KEY_SET 114
+#define PROV_R_NO_PARAMETERS_SET 177
+#define PROV_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 178
+#define PROV_R_OUTPUT_BUFFER_TOO_SMALL 106
+#define PROV_R_PARENT_CANNOT_GENERATE_RANDOM_NUMBERS 228
+#define PROV_R_PARENT_CANNOT_SUPPLY_ENTROPY_SEED 187
+#define PROV_R_PARENT_LOCKING_NOT_ENABLED 182
+#define PROV_R_PARENT_STRENGTH_TOO_WEAK 194
+#define PROV_R_PATH_MUST_BE_ABSOLUTE 219
+#define PROV_R_PERSONALISATION_STRING_TOO_LONG 195
+#define PROV_R_PSS_SALTLEN_TOO_SMALL 172
+#define PROV_R_REQUEST_TOO_LARGE_FOR_DRBG 196
+#define PROV_R_REQUIRE_CTR_MODE_CIPHER 206
+#define PROV_R_RESEED_ERROR 197
+#define PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES 222
+#define PROV_R_SEED_SOURCES_MUST_NOT_HAVE_A_PARENT 229
+#define PROV_R_SELF_TEST_KAT_FAILURE 215
+#define PROV_R_SELF_TEST_POST_FAILURE 216
+#define PROV_R_TAG_NOT_NEEDED 120
+#define PROV_R_TAG_NOT_SET 119
+#define PROV_R_TOO_MANY_RECORDS 126
+#define PROV_R_UNABLE_TO_FIND_CIPHERS 207
+#define PROV_R_UNABLE_TO_GET_PARENT_STRENGTH 199
+#define PROV_R_UNABLE_TO_GET_PASSPHRASE 159
+#define PROV_R_UNABLE_TO_INITIALISE_CIPHERS 208
+#define PROV_R_UNABLE_TO_LOAD_SHA256 147
+#define PROV_R_UNABLE_TO_LOCK_PARENT 201
+#define PROV_R_UNABLE_TO_RESEED 204
+#define PROV_R_UNSUPPORTED_CEK_ALG 145
+#define PROV_R_UNSUPPORTED_KEY_SIZE 153
+#define PROV_R_UNSUPPORTED_MAC_TYPE 137
+#define PROV_R_UNSUPPORTED_NUMBER_OF_ROUNDS 152
+#define PROV_R_URI_AUTHORITY_UNSUPPORTED 223
+#define PROV_R_VALUE_ERROR 138
+#define PROV_R_WRONG_FINAL_BLOCK_LENGTH 107
+#define PROV_R_WRONG_OUTPUT_BUFFER_SIZE 139
+#define PROV_R_XOF_DIGESTS_NOT_ALLOWED 183
+#define PROV_R_XTS_DATA_UNIT_IS_TOO_LARGE 148
+#define PROV_R_XTS_DUPLICATED_KEYS 149
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/provider.h b/CAPI/cpp/grpc/include/openssl/provider.h
index dc86ff5..6262453 100644
--- a/CAPI/cpp/grpc/include/openssl/provider.h
+++ b/CAPI/cpp/grpc/include/openssl/provider.h
@@ -8,53 +8,44 @@
  */
 
 #ifndef OPENSSL_PROVIDER_H
-# define OPENSSL_PROVIDER_H
-# pragma once
-
-# include <openssl/core.h>
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-/* Set the default provider search path */
-int OSSL_PROVIDER_set_default_search_path(OSSL_LIB_CTX *, const char *path);
-
-/* Load and unload a provider */
-OSSL_PROVIDER *OSSL_PROVIDER_load(OSSL_LIB_CTX *, const char *name);
-OSSL_PROVIDER *OSSL_PROVIDER_try_load(OSSL_LIB_CTX *, const char *name,
-                                      int retain_fallbacks);
-int OSSL_PROVIDER_unload(OSSL_PROVIDER *prov);
-int OSSL_PROVIDER_available(OSSL_LIB_CTX *, const char *name);
-int OSSL_PROVIDER_do_all(OSSL_LIB_CTX *ctx,
-                         int (*cb)(OSSL_PROVIDER *provider, void *cbdata),
-                         void *cbdata);
-
-const OSSL_PARAM *OSSL_PROVIDER_gettable_params(const OSSL_PROVIDER *prov);
-int OSSL_PROVIDER_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[]);
-int OSSL_PROVIDER_self_test(const OSSL_PROVIDER *prov);
-int OSSL_PROVIDER_get_capabilities(const OSSL_PROVIDER *prov,
-                                   const char *capability,
-                                   OSSL_CALLBACK *cb,
-                                   void *arg);
-
-const OSSL_ALGORITHM *OSSL_PROVIDER_query_operation(const OSSL_PROVIDER *prov,
-                                                    int operation_id,
-                                                    int *no_cache);
-void OSSL_PROVIDER_unquery_operation(const OSSL_PROVIDER *prov,
-                                     int operation_id, const OSSL_ALGORITHM *algs);
-void *OSSL_PROVIDER_get0_provider_ctx(const OSSL_PROVIDER *prov);
-const OSSL_DISPATCH *OSSL_PROVIDER_get0_dispatch(const OSSL_PROVIDER *prov);
-
-/* Add a built in providers */
-int OSSL_PROVIDER_add_builtin(OSSL_LIB_CTX *, const char *name,
-                              OSSL_provider_init_fn *init_fn);
-
-/* Information */
-const char *OSSL_PROVIDER_get0_name(const OSSL_PROVIDER *prov);
-
-# ifdef __cplusplus
+#define OPENSSL_PROVIDER_H
+#pragma once
+
+#include <openssl/core.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /* Set the default provider search path */
+    int OSSL_PROVIDER_set_default_search_path(OSSL_LIB_CTX*, const char* path);
+
+    /* Load and unload a provider */
+    OSSL_PROVIDER* OSSL_PROVIDER_load(OSSL_LIB_CTX*, const char* name);
+    OSSL_PROVIDER* OSSL_PROVIDER_try_load(OSSL_LIB_CTX*, const char* name, int retain_fallbacks);
+    int OSSL_PROVIDER_unload(OSSL_PROVIDER* prov);
+    int OSSL_PROVIDER_available(OSSL_LIB_CTX*, const char* name);
+    int OSSL_PROVIDER_do_all(OSSL_LIB_CTX* ctx, int (*cb)(OSSL_PROVIDER* provider, void* cbdata), void* cbdata);
+
+    const OSSL_PARAM* OSSL_PROVIDER_gettable_params(const OSSL_PROVIDER* prov);
+    int OSSL_PROVIDER_get_params(const OSSL_PROVIDER* prov, OSSL_PARAM params[]);
+    int OSSL_PROVIDER_self_test(const OSSL_PROVIDER* prov);
+    int OSSL_PROVIDER_get_capabilities(const OSSL_PROVIDER* prov, const char* capability, OSSL_CALLBACK* cb, void* arg);
+
+    const OSSL_ALGORITHM* OSSL_PROVIDER_query_operation(const OSSL_PROVIDER* prov, int operation_id, int* no_cache);
+    void OSSL_PROVIDER_unquery_operation(const OSSL_PROVIDER* prov, int operation_id, const OSSL_ALGORITHM* algs);
+    void* OSSL_PROVIDER_get0_provider_ctx(const OSSL_PROVIDER* prov);
+    const OSSL_DISPATCH* OSSL_PROVIDER_get0_dispatch(const OSSL_PROVIDER* prov);
+
+    /* Add a built in providers */
+    int OSSL_PROVIDER_add_builtin(OSSL_LIB_CTX*, const char* name, OSSL_provider_init_fn* init_fn);
+
+    /* Information */
+    const char* OSSL_PROVIDER_get0_name(const OSSL_PROVIDER* prov);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/rand.h b/CAPI/cpp/grpc/include/openssl/rand.h
index ad3054f..3262ead 100644
--- a/CAPI/cpp/grpc/include/openssl/rand.h
+++ b/CAPI/cpp/grpc/include/openssl/rand.h
@@ -8,22 +8,23 @@
  */
 
 #ifndef OPENSSL_RAND_H
-# define OPENSSL_RAND_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_RAND_H
-# endif
-
-# include <stdlib.h>
-# include <openssl/types.h>
-# include <openssl/e_os2.h>
-# include <openssl/randerr.h>
-# include <openssl/evp.h>
-
-#ifdef  __cplusplus
-extern "C" {
+#define OPENSSL_RAND_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_RAND_H
+#endif
+
+#include <stdlib.h>
+#include <openssl/types.h>
+#include <openssl/e_os2.h>
+#include <openssl/randerr.h>
+#include <openssl/evp.h>
+
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 /*
@@ -34,89 +35,89 @@ extern "C" {
  * does not take RAND_DRBG_STRENGTH into account and sets the strength of the
  * DRBG to that of the cipher.
  */
-# define RAND_DRBG_STRENGTH             256
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-struct rand_meth_st {
-    int (*seed) (const void *buf, int num);
-    int (*bytes) (unsigned char *buf, int num);
-    void (*cleanup) (void);
-    int (*add) (const void *buf, int num, double randomness);
-    int (*pseudorand) (unsigned char *buf, int num);
-    int (*status) (void);
-};
-
-OSSL_DEPRECATEDIN_3_0 int RAND_set_rand_method(const RAND_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 const RAND_METHOD *RAND_get_rand_method(void);
-#  ifndef OPENSSL_NO_ENGINE
-OSSL_DEPRECATEDIN_3_0 int RAND_set_rand_engine(ENGINE *engine);
-#  endif
-
-OSSL_DEPRECATEDIN_3_0 RAND_METHOD *RAND_OpenSSL(void);
-# endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#   define RAND_cleanup() while(0) continue
-# endif
-int RAND_bytes(unsigned char *buf, int num);
-int RAND_priv_bytes(unsigned char *buf, int num);
+#define RAND_DRBG_STRENGTH 256
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    struct rand_meth_st
+    {
+        int (*seed)(const void* buf, int num);
+        int (*bytes)(unsigned char* buf, int num);
+        void (*cleanup)(void);
+        int (*add)(const void* buf, int num, double randomness);
+        int (*pseudorand)(unsigned char* buf, int num);
+        int (*status)(void);
+    };
+
+    OSSL_DEPRECATEDIN_3_0 int RAND_set_rand_method(const RAND_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 const RAND_METHOD* RAND_get_rand_method(void);
+#ifndef OPENSSL_NO_ENGINE
+    OSSL_DEPRECATEDIN_3_0 int RAND_set_rand_engine(ENGINE* engine);
+#endif
 
-/*
- * Equivalent of RAND_priv_bytes() but additionally taking an OSSL_LIB_CTX and
- * a strength.
- */
-int RAND_priv_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, size_t num,
-                       unsigned int strength);
+    OSSL_DEPRECATEDIN_3_0 RAND_METHOD* RAND_OpenSSL(void);
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
 
-/*
- * Equivalent of RAND_bytes() but additionally taking an OSSL_LIB_CTX and
- * a strength.
- */
-int RAND_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, size_t num,
-                  unsigned int strength);
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 int RAND_pseudo_bytes(unsigned char *buf, int num);
-# endif
-
-EVP_RAND_CTX *RAND_get0_primary(OSSL_LIB_CTX *ctx);
-EVP_RAND_CTX *RAND_get0_public(OSSL_LIB_CTX *ctx);
-EVP_RAND_CTX *RAND_get0_private(OSSL_LIB_CTX *ctx);
-
-int RAND_set_DRBG_type(OSSL_LIB_CTX *ctx, const char *drbg, const char *propq,
-                       const char *cipher, const char *digest);
-int RAND_set_seed_source_type(OSSL_LIB_CTX *ctx, const char *seed,
-                              const char *propq);
-
-void RAND_seed(const void *buf, int num);
-void RAND_keep_random_devices_open(int keep);
-
-# if defined(__ANDROID__) && defined(__NDK_FPABI__)
-__NDK_FPABI__   /* __attribute__((pcs("aapcs"))) on ARM */
-# endif
-void RAND_add(const void *buf, int num, double randomness);
-int RAND_load_file(const char *file, long max_bytes);
-int RAND_write_file(const char *file);
-const char *RAND_file_name(char *file, size_t num);
-int RAND_status(void);
-
-# ifndef OPENSSL_NO_EGD
-int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes);
-int RAND_egd(const char *path);
-int RAND_egd_bytes(const char *path, int bytes);
-# endif
-
-int RAND_poll(void);
-
-# if defined(_WIN32) && (defined(BASETYPES) || defined(_WINDEF_H))
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define RAND_cleanup() \
+    while (0)          \
+    continue
+#endif
+    int RAND_bytes(unsigned char* buf, int num);
+    int RAND_priv_bytes(unsigned char* buf, int num);
+
+    /*
+     * Equivalent of RAND_priv_bytes() but additionally taking an OSSL_LIB_CTX and
+     * a strength.
+     */
+    int RAND_priv_bytes_ex(OSSL_LIB_CTX* ctx, unsigned char* buf, size_t num, unsigned int strength);
+
+    /*
+     * Equivalent of RAND_bytes() but additionally taking an OSSL_LIB_CTX and
+     * a strength.
+     */
+    int RAND_bytes_ex(OSSL_LIB_CTX* ctx, unsigned char* buf, size_t num, unsigned int strength);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 int RAND_pseudo_bytes(unsigned char* buf, int num);
+#endif
+
+    EVP_RAND_CTX* RAND_get0_primary(OSSL_LIB_CTX* ctx);
+    EVP_RAND_CTX* RAND_get0_public(OSSL_LIB_CTX* ctx);
+    EVP_RAND_CTX* RAND_get0_private(OSSL_LIB_CTX* ctx);
+
+    int RAND_set_DRBG_type(OSSL_LIB_CTX* ctx, const char* drbg, const char* propq, const char* cipher, const char* digest);
+    int RAND_set_seed_source_type(OSSL_LIB_CTX* ctx, const char* seed, const char* propq);
+
+    void RAND_seed(const void* buf, int num);
+    void RAND_keep_random_devices_open(int keep);
+
+#if defined(__ANDROID__) && defined(__NDK_FPABI__)
+    __NDK_FPABI__ /* __attribute__((pcs("aapcs"))) on ARM */
+#endif
+        void
+        RAND_add(const void* buf, int num, double randomness);
+    int RAND_load_file(const char* file, long max_bytes);
+    int RAND_write_file(const char* file);
+    const char* RAND_file_name(char* file, size_t num);
+    int RAND_status(void);
+
+#ifndef OPENSSL_NO_EGD
+    int RAND_query_egd_bytes(const char* path, unsigned char* buf, int bytes);
+    int RAND_egd(const char* path);
+    int RAND_egd_bytes(const char* path, int bytes);
+#endif
+
+    int RAND_poll(void);
+
+#if defined(_WIN32) && (defined(BASETYPES) || defined(_WINDEF_H))
 /* application has to include <windows.h> in order to use these */
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 void RAND_screen(void);
-OSSL_DEPRECATEDIN_1_1_0 int RAND_event(UINT, WPARAM, LPARAM);
-#  endif
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 void RAND_screen(void);
+    OSSL_DEPRECATEDIN_1_1_0 int RAND_event(UINT, WPARAM, LPARAM);
+#endif
+#endif
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/CAPI/cpp/grpc/include/openssl/randerr.h b/CAPI/cpp/grpc/include/openssl/randerr.h
index b5e08e4..63412a4 100644
--- a/CAPI/cpp/grpc/include/openssl/randerr.h
+++ b/CAPI/cpp/grpc/include/openssl/randerr.h
@@ -9,60 +9,58 @@
  */
 
 #ifndef OPENSSL_RANDERR_H
-# define OPENSSL_RANDERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_RANDERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * RAND reason codes.
  */
-# define RAND_R_ADDITIONAL_INPUT_TOO_LONG                 102
-# define RAND_R_ALREADY_INSTANTIATED                      103
-# define RAND_R_ARGUMENT_OUT_OF_RANGE                     105
-# define RAND_R_CANNOT_OPEN_FILE                          121
-# define RAND_R_DRBG_ALREADY_INITIALIZED                  129
-# define RAND_R_DRBG_NOT_INITIALISED                      104
-# define RAND_R_ENTROPY_INPUT_TOO_LONG                    106
-# define RAND_R_ENTROPY_OUT_OF_RANGE                      124
-# define RAND_R_ERROR_ENTROPY_POOL_WAS_IGNORED            127
-# define RAND_R_ERROR_INITIALISING_DRBG                   107
-# define RAND_R_ERROR_INSTANTIATING_DRBG                  108
-# define RAND_R_ERROR_RETRIEVING_ADDITIONAL_INPUT         109
-# define RAND_R_ERROR_RETRIEVING_ENTROPY                  110
-# define RAND_R_ERROR_RETRIEVING_NONCE                    111
-# define RAND_R_FAILED_TO_CREATE_LOCK                     126
-# define RAND_R_FUNC_NOT_IMPLEMENTED                      101
-# define RAND_R_FWRITE_ERROR                              123
-# define RAND_R_GENERATE_ERROR                            112
-# define RAND_R_INSUFFICIENT_DRBG_STRENGTH                139
-# define RAND_R_INTERNAL_ERROR                            113
-# define RAND_R_IN_ERROR_STATE                            114
-# define RAND_R_NOT_A_REGULAR_FILE                        122
-# define RAND_R_NOT_INSTANTIATED                          115
-# define RAND_R_NO_DRBG_IMPLEMENTATION_SELECTED           128
-# define RAND_R_PARENT_LOCKING_NOT_ENABLED                130
-# define RAND_R_PARENT_STRENGTH_TOO_WEAK                  131
-# define RAND_R_PERSONALISATION_STRING_TOO_LONG           116
-# define RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED       133
-# define RAND_R_PRNG_NOT_SEEDED                           100
-# define RAND_R_RANDOM_POOL_OVERFLOW                      125
-# define RAND_R_RANDOM_POOL_UNDERFLOW                     134
-# define RAND_R_REQUEST_TOO_LARGE_FOR_DRBG                117
-# define RAND_R_RESEED_ERROR                              118
-# define RAND_R_SELFTEST_FAILURE                          119
-# define RAND_R_TOO_LITTLE_NONCE_REQUESTED                135
-# define RAND_R_TOO_MUCH_NONCE_REQUESTED                  136
-# define RAND_R_UNABLE_TO_CREATE_DRBG                     143
-# define RAND_R_UNABLE_TO_FETCH_DRBG                      144
-# define RAND_R_UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER  141
-# define RAND_R_UNABLE_TO_GET_PARENT_STRENGTH             138
-# define RAND_R_UNABLE_TO_LOCK_PARENT                     140
-# define RAND_R_UNSUPPORTED_DRBG_FLAGS                    132
-# define RAND_R_UNSUPPORTED_DRBG_TYPE                     120
+#define RAND_R_ADDITIONAL_INPUT_TOO_LONG 102
+#define RAND_R_ALREADY_INSTANTIATED 103
+#define RAND_R_ARGUMENT_OUT_OF_RANGE 105
+#define RAND_R_CANNOT_OPEN_FILE 121
+#define RAND_R_DRBG_ALREADY_INITIALIZED 129
+#define RAND_R_DRBG_NOT_INITIALISED 104
+#define RAND_R_ENTROPY_INPUT_TOO_LONG 106
+#define RAND_R_ENTROPY_OUT_OF_RANGE 124
+#define RAND_R_ERROR_ENTROPY_POOL_WAS_IGNORED 127
+#define RAND_R_ERROR_INITIALISING_DRBG 107
+#define RAND_R_ERROR_INSTANTIATING_DRBG 108
+#define RAND_R_ERROR_RETRIEVING_ADDITIONAL_INPUT 109
+#define RAND_R_ERROR_RETRIEVING_ENTROPY 110
+#define RAND_R_ERROR_RETRIEVING_NONCE 111
+#define RAND_R_FAILED_TO_CREATE_LOCK 126
+#define RAND_R_FUNC_NOT_IMPLEMENTED 101
+#define RAND_R_FWRITE_ERROR 123
+#define RAND_R_GENERATE_ERROR 112
+#define RAND_R_INSUFFICIENT_DRBG_STRENGTH 139
+#define RAND_R_INTERNAL_ERROR 113
+#define RAND_R_IN_ERROR_STATE 114
+#define RAND_R_NOT_A_REGULAR_FILE 122
+#define RAND_R_NOT_INSTANTIATED 115
+#define RAND_R_NO_DRBG_IMPLEMENTATION_SELECTED 128
+#define RAND_R_PARENT_LOCKING_NOT_ENABLED 130
+#define RAND_R_PARENT_STRENGTH_TOO_WEAK 131
+#define RAND_R_PERSONALISATION_STRING_TOO_LONG 116
+#define RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED 133
+#define RAND_R_PRNG_NOT_SEEDED 100
+#define RAND_R_RANDOM_POOL_OVERFLOW 125
+#define RAND_R_RANDOM_POOL_UNDERFLOW 134
+#define RAND_R_REQUEST_TOO_LARGE_FOR_DRBG 117
+#define RAND_R_RESEED_ERROR 118
+#define RAND_R_SELFTEST_FAILURE 119
+#define RAND_R_TOO_LITTLE_NONCE_REQUESTED 135
+#define RAND_R_TOO_MUCH_NONCE_REQUESTED 136
+#define RAND_R_UNABLE_TO_CREATE_DRBG 143
+#define RAND_R_UNABLE_TO_FETCH_DRBG 144
+#define RAND_R_UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER 141
+#define RAND_R_UNABLE_TO_GET_PARENT_STRENGTH 138
+#define RAND_R_UNABLE_TO_LOCK_PARENT 140
+#define RAND_R_UNSUPPORTED_DRBG_FLAGS 132
+#define RAND_R_UNSUPPORTED_DRBG_TYPE 120
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/rc2.h b/CAPI/cpp/grpc/include/openssl/rc2.h
index ff633fd..b7e41a4 100644
--- a/CAPI/cpp/grpc/include/openssl/rc2.h
+++ b/CAPI/cpp/grpc/include/openssl/rc2.h
@@ -8,61 +8,49 @@
  */
 
 #ifndef OPENSSL_RC2_H
-# define OPENSSL_RC2_H
-# pragma once
+#define OPENSSL_RC2_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_RC2_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_RC2_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_RC2
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
+#ifndef OPENSSL_NO_RC2
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  define RC2_BLOCK       8
-#  define RC2_KEY_LENGTH  16
+#define RC2_BLOCK 8
+#define RC2_KEY_LENGTH 16
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef unsigned int RC2_INT;
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef unsigned int RC2_INT;
 
-#   define RC2_ENCRYPT     1
-#   define RC2_DECRYPT     0
+#define RC2_ENCRYPT 1
+#define RC2_DECRYPT 0
 
-typedef struct rc2_key_st {
-    RC2_INT data[64];
-} RC2_KEY;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 void RC2_set_key(RC2_KEY *key, int len,
-                                       const unsigned char *data, int bits);
-OSSL_DEPRECATEDIN_3_0 void RC2_ecb_encrypt(const unsigned char *in,
-                                           unsigned char *out, RC2_KEY *key,
-                                           int enc);
-OSSL_DEPRECATEDIN_3_0 void RC2_encrypt(unsigned long *data, RC2_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void RC2_decrypt(unsigned long *data, RC2_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void RC2_cbc_encrypt(const unsigned char *in,
-                                           unsigned char *out, long length,
-                                           RC2_KEY *ks, unsigned char *iv,
-                                           int enc);
-OSSL_DEPRECATEDIN_3_0 void RC2_cfb64_encrypt(const unsigned char *in,
-                                             unsigned char *out, long length,
-                                             RC2_KEY *schedule,
-                                             unsigned char *ivec,
-                                             int *num, int enc);
-OSSL_DEPRECATEDIN_3_0 void RC2_ofb64_encrypt(const unsigned char *in,
-                                             unsigned char *out, long length,
-                                             RC2_KEY *schedule,
-                                             unsigned char *ivec,
-                                             int *num);
-#  endif
+    typedef struct rc2_key_st
+    {
+        RC2_INT data[64];
+    } RC2_KEY;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 void RC2_set_key(RC2_KEY* key, int len, const unsigned char* data, int bits);
+    OSSL_DEPRECATEDIN_3_0 void RC2_ecb_encrypt(const unsigned char* in, unsigned char* out, RC2_KEY* key, int enc);
+    OSSL_DEPRECATEDIN_3_0 void RC2_encrypt(unsigned long* data, RC2_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void RC2_decrypt(unsigned long* data, RC2_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void RC2_cbc_encrypt(const unsigned char* in, unsigned char* out, long length, RC2_KEY* ks, unsigned char* iv, int enc);
+    OSSL_DEPRECATEDIN_3_0 void RC2_cfb64_encrypt(const unsigned char* in, unsigned char* out, long length, RC2_KEY* schedule, unsigned char* ivec, int* num, int enc);
+    OSSL_DEPRECATEDIN_3_0 void RC2_ofb64_encrypt(const unsigned char* in, unsigned char* out, long length, RC2_KEY* schedule, unsigned char* ivec, int* num);
+#endif
 
-#  ifdef  __cplusplus
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/rc4.h b/CAPI/cpp/grpc/include/openssl/rc4.h
index 600b288..ecaee10 100644
--- a/CAPI/cpp/grpc/include/openssl/rc4.h
+++ b/CAPI/cpp/grpc/include/openssl/rc4.h
@@ -8,40 +8,39 @@
  */
 
 #ifndef OPENSSL_RC4_H
-# define OPENSSL_RC4_H
-# pragma once
+#define OPENSSL_RC4_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_RC4_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_RC4_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_RC4
-#  include <stddef.h>
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
+#ifndef OPENSSL_NO_RC4
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef struct rc4_key_st {
-    RC4_INT x, y;
-    RC4_INT data[256];
-} RC4_KEY;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 const char *RC4_options(void);
-OSSL_DEPRECATEDIN_3_0 void RC4_set_key(RC4_KEY *key, int len,
-                                       const unsigned char *data);
-OSSL_DEPRECATEDIN_3_0 void RC4(RC4_KEY *key, size_t len,
-                               const unsigned char *indata,
-                               unsigned char *outdata);
-#  endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef struct rc4_key_st
+    {
+        RC4_INT x, y;
+        RC4_INT data[256];
+    } RC4_KEY;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 const char* RC4_options(void);
+    OSSL_DEPRECATEDIN_3_0 void RC4_set_key(RC4_KEY* key, int len, const unsigned char* data);
+    OSSL_DEPRECATEDIN_3_0 void RC4(RC4_KEY* key, size_t len, const unsigned char* indata, unsigned char* outdata);
+#endif
 
-#  ifdef  __cplusplus
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/rc5.h b/CAPI/cpp/grpc/include/openssl/rc5.h
index de83352..473ef0e 100644
--- a/CAPI/cpp/grpc/include/openssl/rc5.h
+++ b/CAPI/cpp/grpc/include/openssl/rc5.h
@@ -8,72 +8,59 @@
  */
 
 #ifndef OPENSSL_RC5_H
-# define OPENSSL_RC5_H
-# pragma once
+#define OPENSSL_RC5_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_RC5_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_RC5_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_RC5
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
+#ifndef OPENSSL_NO_RC5
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  define RC5_32_BLOCK            8
-#  define RC5_32_KEY_LENGTH       16/* This is a default, max is 255 */
+#define RC5_32_BLOCK 8
+#define RC5_32_KEY_LENGTH 16 /* This is a default, max is 255 */
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define RC5_ENCRYPT     1
-#   define RC5_DECRYPT     0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define RC5_ENCRYPT 1
+#define RC5_DECRYPT 0
 
-#   define RC5_32_INT unsigned int
+#define RC5_32_INT unsigned int
 
 /*
  * This are the only values supported.  Tweak the code if you want more The
  * most supported modes will be RC5-32/12/16 RC5-32/16/8
  */
-#   define RC5_8_ROUNDS    8
-#   define RC5_12_ROUNDS   12
-#   define RC5_16_ROUNDS   16
+#define RC5_8_ROUNDS 8
+#define RC5_12_ROUNDS 12
+#define RC5_16_ROUNDS 16
 
-typedef struct rc5_key_st {
-    /* Number of rounds */
-    int rounds;
-    RC5_32_INT data[2 * (RC5_16_ROUNDS + 1)];
-} RC5_32_KEY;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int RC5_32_set_key(RC5_32_KEY *key, int len,
-                                         const unsigned char *data,
-                                         int rounds);
-OSSL_DEPRECATEDIN_3_0 void RC5_32_ecb_encrypt(const unsigned char *in,
-                                              unsigned char *out,
-                                              RC5_32_KEY *key,
-                                              int enc);
-OSSL_DEPRECATEDIN_3_0 void RC5_32_encrypt(unsigned long *data, RC5_32_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void RC5_32_decrypt(unsigned long *data, RC5_32_KEY *key);
-OSSL_DEPRECATEDIN_3_0 void RC5_32_cbc_encrypt(const unsigned char *in,
-                                              unsigned char *out, long length,
-                                              RC5_32_KEY *ks, unsigned char *iv,
-                                              int enc);
-OSSL_DEPRECATEDIN_3_0 void RC5_32_cfb64_encrypt(const unsigned char *in,
-                                                unsigned char *out, long length,
-                                                RC5_32_KEY *schedule,
-                                                unsigned char *ivec, int *num,
-                                                int enc);
-OSSL_DEPRECATEDIN_3_0 void RC5_32_ofb64_encrypt(const unsigned char *in,
-                                                unsigned char *out, long length,
-                                                RC5_32_KEY *schedule,
-                                                unsigned char *ivec, int *num);
-#  endif
+    typedef struct rc5_key_st
+    {
+        /* Number of rounds */
+        int rounds;
+        RC5_32_INT data[2 * (RC5_16_ROUNDS + 1)];
+    } RC5_32_KEY;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int RC5_32_set_key(RC5_32_KEY* key, int len, const unsigned char* data, int rounds);
+    OSSL_DEPRECATEDIN_3_0 void RC5_32_ecb_encrypt(const unsigned char* in, unsigned char* out, RC5_32_KEY* key, int enc);
+    OSSL_DEPRECATEDIN_3_0 void RC5_32_encrypt(unsigned long* data, RC5_32_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void RC5_32_decrypt(unsigned long* data, RC5_32_KEY* key);
+    OSSL_DEPRECATEDIN_3_0 void RC5_32_cbc_encrypt(const unsigned char* in, unsigned char* out, long length, RC5_32_KEY* ks, unsigned char* iv, int enc);
+    OSSL_DEPRECATEDIN_3_0 void RC5_32_cfb64_encrypt(const unsigned char* in, unsigned char* out, long length, RC5_32_KEY* schedule, unsigned char* ivec, int* num, int enc);
+    OSSL_DEPRECATEDIN_3_0 void RC5_32_ofb64_encrypt(const unsigned char* in, unsigned char* out, long length, RC5_32_KEY* schedule, unsigned char* ivec, int* num);
+#endif
 
-#  ifdef  __cplusplus
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ripemd.h b/CAPI/cpp/grpc/include/openssl/ripemd.h
index 900ee31..f42b0d3 100644
--- a/CAPI/cpp/grpc/include/openssl/ripemd.h
+++ b/CAPI/cpp/grpc/include/openssl/ripemd.h
@@ -8,52 +8,51 @@
  */
 
 #ifndef OPENSSL_RIPEMD_H
-# define OPENSSL_RIPEMD_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_RIPEMD_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_RMD160
-#  include <openssl/e_os2.h>
-#  include <stddef.h>
-
-#  define RIPEMD160_DIGEST_LENGTH 20
-
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
-#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
-
-#   define RIPEMD160_LONG unsigned int
-
-#   define RIPEMD160_CBLOCK        64
-#   define RIPEMD160_LBLOCK        (RIPEMD160_CBLOCK/4)
-
-typedef struct RIPEMD160state_st {
-    RIPEMD160_LONG A, B, C, D, E;
-    RIPEMD160_LONG Nl, Nh;
-    RIPEMD160_LONG data[RIPEMD160_LBLOCK];
-    unsigned int num;
-} RIPEMD160_CTX;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Init(RIPEMD160_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data,
-                                           size_t len);
-OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c);
-OSSL_DEPRECATEDIN_3_0 unsigned char *RIPEMD160(const unsigned char *d, size_t n,
-                                               unsigned char *md);
-OSSL_DEPRECATEDIN_3_0 void RIPEMD160_Transform(RIPEMD160_CTX *c,
-                                               const unsigned char *b);
-#  endif
-
-#  ifdef  __cplusplus
+#define OPENSSL_RIPEMD_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_RIPEMD_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_RMD160
+#include <openssl/e_os2.h>
+#include <stddef.h>
+
+#define RIPEMD160_DIGEST_LENGTH 20
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#define RIPEMD160_LONG unsigned int
+
+#define RIPEMD160_CBLOCK 64
+#define RIPEMD160_LBLOCK (RIPEMD160_CBLOCK / 4)
+
+    typedef struct RIPEMD160state_st
+    {
+        RIPEMD160_LONG A, B, C, D, E;
+        RIPEMD160_LONG Nl, Nh;
+        RIPEMD160_LONG data[RIPEMD160_LBLOCK];
+        unsigned int num;
+    } RIPEMD160_CTX;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Init(RIPEMD160_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Update(RIPEMD160_CTX* c, const void* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int RIPEMD160_Final(unsigned char* md, RIPEMD160_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 unsigned char* RIPEMD160(const unsigned char* d, size_t n, unsigned char* md);
+    OSSL_DEPRECATEDIN_3_0 void RIPEMD160_Transform(RIPEMD160_CTX* c, const unsigned char* b);
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/rsa.h b/CAPI/cpp/grpc/include/openssl/rsa.h
index a55c972..ecdf805 100644
--- a/CAPI/cpp/grpc/include/openssl/rsa.h
+++ b/CAPI/cpp/grpc/include/openssl/rsa.h
@@ -8,68 +8,69 @@
  */
 
 #ifndef OPENSSL_RSA_H
-# define OPENSSL_RSA_H
-# pragma once
+#define OPENSSL_RSA_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_RSA_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_RSA_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# include <openssl/asn1.h>
-# include <openssl/bio.h>
-# include <openssl/crypto.h>
-# include <openssl/types.h>
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  include <openssl/bn.h>
-# endif
-# include <openssl/rsaerr.h>
-# include <openssl/safestack.h>
+#include <openssl/asn1.h>
+#include <openssl/bio.h>
+#include <openssl/crypto.h>
+#include <openssl/types.h>
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/bn.h>
+#endif
+#include <openssl/rsaerr.h>
+#include <openssl/safestack.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# ifndef OPENSSL_RSA_MAX_MODULUS_BITS
-#  define OPENSSL_RSA_MAX_MODULUS_BITS   16384
-# endif
+#ifndef OPENSSL_RSA_MAX_MODULUS_BITS
+#define OPENSSL_RSA_MAX_MODULUS_BITS 16384
+#endif
 
-# define RSA_3   0x3L
-# define RSA_F4  0x10001L
+#define RSA_3 0x3L
+#define RSA_F4 0x10001L
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-/* The types RSA and RSA_METHOD are defined in ossl_typ.h */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /* The types RSA and RSA_METHOD are defined in ossl_typ.h */
 
-#  define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS 2048
+#define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS 2048
 
-#  ifndef OPENSSL_RSA_SMALL_MODULUS_BITS
-#   define OPENSSL_RSA_SMALL_MODULUS_BITS 3072
-#  endif
+#ifndef OPENSSL_RSA_SMALL_MODULUS_BITS
+#define OPENSSL_RSA_SMALL_MODULUS_BITS 3072
+#endif
 
 /* exponent limit enforced for "large" modulus only */
-#  ifndef OPENSSL_RSA_MAX_PUBEXP_BITS
-#   define OPENSSL_RSA_MAX_PUBEXP_BITS    64
-#  endif
+#ifndef OPENSSL_RSA_MAX_PUBEXP_BITS
+#define OPENSSL_RSA_MAX_PUBEXP_BITS 64
+#endif
 /* based on RFC 8017 appendix A.1.2 */
-#  define RSA_ASN1_VERSION_DEFAULT        0
-#  define RSA_ASN1_VERSION_MULTI          1
+#define RSA_ASN1_VERSION_DEFAULT 0
+#define RSA_ASN1_VERSION_MULTI 1
 
-#  define RSA_DEFAULT_PRIME_NUM           2
+#define RSA_DEFAULT_PRIME_NUM 2
 
-#  define RSA_METHOD_FLAG_NO_CHECK        0x0001
-#  define RSA_FLAG_CACHE_PUBLIC           0x0002
-#  define RSA_FLAG_CACHE_PRIVATE          0x0004
-#  define RSA_FLAG_BLINDING               0x0008
-#  define RSA_FLAG_THREAD_SAFE            0x0010
+#define RSA_METHOD_FLAG_NO_CHECK 0x0001
+#define RSA_FLAG_CACHE_PUBLIC 0x0002
+#define RSA_FLAG_CACHE_PRIVATE 0x0004
+#define RSA_FLAG_BLINDING 0x0008
+#define RSA_FLAG_THREAD_SAFE 0x0010
 /*
  * This flag means the private key operations will be handled by rsa_mod_exp
  * and that they do not depend on the private key components being present:
  * for example a key stored in external hardware. Without this flag
  * bn_mod_exp gets called when private key components are absent.
  */
-#  define RSA_FLAG_EXT_PKEY               0x0020
+#define RSA_FLAG_EXT_PKEY 0x0020
 
 /*
  * new with 0.9.6j and 0.9.7b; the built-in
@@ -77,14 +78,14 @@ extern "C" {
  * default (ignoring RSA_FLAG_BLINDING),
  * but other engines might not need it
  */
-#  define RSA_FLAG_NO_BLINDING            0x0080
-# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#define RSA_FLAG_NO_BLINDING 0x0080
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
 /*
  * Does nothing. Previously this switched off constant time behaviour.
  */
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define RSA_FLAG_NO_CONSTTIME           0x0000
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define RSA_FLAG_NO_CONSTTIME 0x0000
+#endif
 /* deprecated name for the flag*/
 /*
  * new with 0.9.7h; the built-in RSA
@@ -94,9 +95,9 @@ extern "C" {
  * faster variable sliding window method to
  * be used for all exponents.
  */
-# ifndef OPENSSL_NO_DEPRECATED_0_9_8
-#  define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+#define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME
+#endif
 
 /*-
  * New with 3.0: use part of the flags to denote exact type of RSA key,
@@ -111,494 +112,343 @@ extern "C" {
  *
  * 4 bits allow for 16 types
  */
-# define RSA_FLAG_TYPE_MASK            0xF000
-# define RSA_FLAG_TYPE_RSA             0x0000
-# define RSA_FLAG_TYPE_RSASSAPSS       0x1000
-# define RSA_FLAG_TYPE_RSAESOAEP       0x2000
-
-int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *ctx, int pad_mode);
-int EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX *ctx, int *pad_mode);
-
-int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int saltlen);
-int EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int *saltlen);
-
-int EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX *ctx, int bits);
-int EVP_PKEY_CTX_set1_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
-int EVP_PKEY_CTX_set_rsa_keygen_primes(EVP_PKEY_CTX *ctx, int primes);
-int EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(EVP_PKEY_CTX *ctx, int saltlen);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
-# endif
+#define RSA_FLAG_TYPE_MASK 0xF000
+#define RSA_FLAG_TYPE_RSA 0x0000
+#define RSA_FLAG_TYPE_RSASSAPSS 0x1000
+#define RSA_FLAG_TYPE_RSAESOAEP 0x2000
+
+    int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX* ctx, int pad_mode);
+    int EVP_PKEY_CTX_get_rsa_padding(EVP_PKEY_CTX* ctx, int* pad_mode);
+
+    int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX* ctx, int saltlen);
+    int EVP_PKEY_CTX_get_rsa_pss_saltlen(EVP_PKEY_CTX* ctx, int* saltlen);
+
+    int EVP_PKEY_CTX_set_rsa_keygen_bits(EVP_PKEY_CTX* ctx, int bits);
+    int EVP_PKEY_CTX_set1_rsa_keygen_pubexp(EVP_PKEY_CTX* ctx, BIGNUM* pubexp);
+    int EVP_PKEY_CTX_set_rsa_keygen_primes(EVP_PKEY_CTX* ctx, int primes);
+    int EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(EVP_PKEY_CTX* ctx, int saltlen);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX* ctx, BIGNUM* pubexp);
+#endif
 
 /* Salt length matches digest */
-# define RSA_PSS_SALTLEN_DIGEST -1
+#define RSA_PSS_SALTLEN_DIGEST -1
 /* Verify only: auto detect salt length */
-# define RSA_PSS_SALTLEN_AUTO   -2
+#define RSA_PSS_SALTLEN_AUTO -2
 /* Set salt length to maximum possible */
-# define RSA_PSS_SALTLEN_MAX    -3
+#define RSA_PSS_SALTLEN_MAX -3
 /* Old compatible max salt length for sign only */
-# define RSA_PSS_SALTLEN_MAX_SIGN    -2
-
-int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
-int EVP_PKEY_CTX_set_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
-                                      const char *mdprops);
-int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
-int EVP_PKEY_CTX_get_rsa_mgf1_md_name(EVP_PKEY_CTX *ctx, char *name,
-                                      size_t namelen);
-int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
-int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md_name(EVP_PKEY_CTX *ctx,
-                                                 const char *mdname);
-
-int EVP_PKEY_CTX_set_rsa_pss_keygen_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
-int EVP_PKEY_CTX_set_rsa_pss_keygen_md_name(EVP_PKEY_CTX *ctx,
-                                            const char *mdname,
-                                            const char *mdprops);
-
-int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
-int EVP_PKEY_CTX_set_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, const char *mdname,
-                                      const char *mdprops);
-int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX *ctx, const EVP_MD **md);
-int EVP_PKEY_CTX_get_rsa_oaep_md_name(EVP_PKEY_CTX *ctx, char *name,
-                                      size_t namelen);
-int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX *ctx, void *label, int llen);
-int EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX *ctx, unsigned char **label);
-
-# define EVP_PKEY_CTRL_RSA_PADDING       (EVP_PKEY_ALG_CTRL + 1)
-# define EVP_PKEY_CTRL_RSA_PSS_SALTLEN   (EVP_PKEY_ALG_CTRL + 2)
-
-# define EVP_PKEY_CTRL_RSA_KEYGEN_BITS   (EVP_PKEY_ALG_CTRL + 3)
-# define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4)
-# define EVP_PKEY_CTRL_RSA_MGF1_MD       (EVP_PKEY_ALG_CTRL + 5)
-
-# define EVP_PKEY_CTRL_GET_RSA_PADDING           (EVP_PKEY_ALG_CTRL + 6)
-# define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN       (EVP_PKEY_ALG_CTRL + 7)
-# define EVP_PKEY_CTRL_GET_RSA_MGF1_MD           (EVP_PKEY_ALG_CTRL + 8)
-
-# define EVP_PKEY_CTRL_RSA_OAEP_MD       (EVP_PKEY_ALG_CTRL + 9)
-# define EVP_PKEY_CTRL_RSA_OAEP_LABEL    (EVP_PKEY_ALG_CTRL + 10)
-
-# define EVP_PKEY_CTRL_GET_RSA_OAEP_MD   (EVP_PKEY_ALG_CTRL + 11)
-# define EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 12)
-
-# define EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES  (EVP_PKEY_ALG_CTRL + 13)
-
-# define RSA_PKCS1_PADDING          1
-# define RSA_NO_PADDING             3
-# define RSA_PKCS1_OAEP_PADDING     4
-# define RSA_X931_PADDING           5
+#define RSA_PSS_SALTLEN_MAX_SIGN -2
+
+    int EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
+    int EVP_PKEY_CTX_set_rsa_mgf1_md_name(EVP_PKEY_CTX* ctx, const char* mdname, const char* mdprops);
+    int EVP_PKEY_CTX_get_rsa_mgf1_md(EVP_PKEY_CTX* ctx, const EVP_MD** md);
+    int EVP_PKEY_CTX_get_rsa_mgf1_md_name(EVP_PKEY_CTX* ctx, char* name, size_t namelen);
+    int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
+    int EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md_name(EVP_PKEY_CTX* ctx, const char* mdname);
+
+    int EVP_PKEY_CTX_set_rsa_pss_keygen_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
+    int EVP_PKEY_CTX_set_rsa_pss_keygen_md_name(EVP_PKEY_CTX* ctx, const char* mdname, const char* mdprops);
+
+    int EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX* ctx, const EVP_MD* md);
+    int EVP_PKEY_CTX_set_rsa_oaep_md_name(EVP_PKEY_CTX* ctx, const char* mdname, const char* mdprops);
+    int EVP_PKEY_CTX_get_rsa_oaep_md(EVP_PKEY_CTX* ctx, const EVP_MD** md);
+    int EVP_PKEY_CTX_get_rsa_oaep_md_name(EVP_PKEY_CTX* ctx, char* name, size_t namelen);
+    int EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX* ctx, void* label, int llen);
+    int EVP_PKEY_CTX_get0_rsa_oaep_label(EVP_PKEY_CTX* ctx, unsigned char** label);
+
+#define EVP_PKEY_CTRL_RSA_PADDING (EVP_PKEY_ALG_CTRL + 1)
+#define EVP_PKEY_CTRL_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 2)
+
+#define EVP_PKEY_CTRL_RSA_KEYGEN_BITS (EVP_PKEY_ALG_CTRL + 3)
+#define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4)
+#define EVP_PKEY_CTRL_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 5)
+
+#define EVP_PKEY_CTRL_GET_RSA_PADDING (EVP_PKEY_ALG_CTRL + 6)
+#define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 7)
+#define EVP_PKEY_CTRL_GET_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 8)
+
+#define EVP_PKEY_CTRL_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 9)
+#define EVP_PKEY_CTRL_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 10)
+
+#define EVP_PKEY_CTRL_GET_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 11)
+#define EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 12)
+
+#define EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES (EVP_PKEY_ALG_CTRL + 13)
+
+#define RSA_PKCS1_PADDING 1
+#define RSA_NO_PADDING 3
+#define RSA_PKCS1_OAEP_PADDING 4
+#define RSA_X931_PADDING 5
 
 /* EVP_PKEY_ only */
-# define RSA_PKCS1_PSS_PADDING      6
-# define RSA_PKCS1_WITH_TLS_PADDING 7
-
-# define RSA_PKCS1_PADDING_SIZE    11
-
-# define RSA_set_app_data(s,arg)         RSA_set_ex_data(s,0,arg)
-# define RSA_get_app_data(s)             RSA_get_ex_data(s,0)
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 RSA *RSA_new(void);
-OSSL_DEPRECATEDIN_3_0 RSA *RSA_new_method(ENGINE *engine);
-OSSL_DEPRECATEDIN_3_0 int RSA_bits(const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 int RSA_size(const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 int RSA_security_bits(const RSA *rsa);
-
-OSSL_DEPRECATEDIN_3_0 int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d);
-OSSL_DEPRECATEDIN_3_0 int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q);
-OSSL_DEPRECATEDIN_3_0 int RSA_set0_crt_params(RSA *r,
-                                              BIGNUM *dmp1, BIGNUM *dmq1,
-                                              BIGNUM *iqmp);
-OSSL_DEPRECATEDIN_3_0 int RSA_set0_multi_prime_params(RSA *r,
-                                                      BIGNUM *primes[],
-                                                      BIGNUM *exps[],
-                                                      BIGNUM *coeffs[],
-                                                      int pnum);
-OSSL_DEPRECATEDIN_3_0 void RSA_get0_key(const RSA *r,
-                                        const BIGNUM **n, const BIGNUM **e,
-                                        const BIGNUM **d);
-OSSL_DEPRECATEDIN_3_0 void RSA_get0_factors(const RSA *r,
-                                            const BIGNUM **p, const BIGNUM **q);
-OSSL_DEPRECATEDIN_3_0 int RSA_get_multi_prime_extra_count(const RSA *r);
-OSSL_DEPRECATEDIN_3_0 int RSA_get0_multi_prime_factors(const RSA *r,
-                                                       const BIGNUM *primes[]);
-OSSL_DEPRECATEDIN_3_0 void RSA_get0_crt_params(const RSA *r,
-                                               const BIGNUM **dmp1,
-                                               const BIGNUM **dmq1,
-                                               const BIGNUM **iqmp);
-OSSL_DEPRECATEDIN_3_0
-int RSA_get0_multi_prime_crt_params(const RSA *r, const BIGNUM *exps[],
-                                    const BIGNUM *coeffs[]);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_n(const RSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_e(const RSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_d(const RSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_p(const RSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_q(const RSA *d);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_dmp1(const RSA *r);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_dmq1(const RSA *r);
-OSSL_DEPRECATEDIN_3_0 const BIGNUM *RSA_get0_iqmp(const RSA *r);
-OSSL_DEPRECATEDIN_3_0 const RSA_PSS_PARAMS *RSA_get0_pss_params(const RSA *r);
-OSSL_DEPRECATEDIN_3_0 void RSA_clear_flags(RSA *r, int flags);
-OSSL_DEPRECATEDIN_3_0 int RSA_test_flags(const RSA *r, int flags);
-OSSL_DEPRECATEDIN_3_0 void RSA_set_flags(RSA *r, int flags);
-OSSL_DEPRECATEDIN_3_0 int RSA_get_version(RSA *r);
-OSSL_DEPRECATEDIN_3_0 ENGINE *RSA_get0_engine(const RSA *r);
-# endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
-
-# define EVP_RSA_gen(bits) \
+#define RSA_PKCS1_PSS_PADDING 6
+#define RSA_PKCS1_WITH_TLS_PADDING 7
+
+#define RSA_PKCS1_PADDING_SIZE 11
+
+#define RSA_set_app_data(s, arg) RSA_set_ex_data(s, 0, arg)
+#define RSA_get_app_data(s) RSA_get_ex_data(s, 0)
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 RSA* RSA_new(void);
+    OSSL_DEPRECATEDIN_3_0 RSA* RSA_new_method(ENGINE* engine);
+    OSSL_DEPRECATEDIN_3_0 int RSA_bits(const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 int RSA_size(const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 int RSA_security_bits(const RSA* rsa);
+
+    OSSL_DEPRECATEDIN_3_0 int RSA_set0_key(RSA* r, BIGNUM* n, BIGNUM* e, BIGNUM* d);
+    OSSL_DEPRECATEDIN_3_0 int RSA_set0_factors(RSA* r, BIGNUM* p, BIGNUM* q);
+    OSSL_DEPRECATEDIN_3_0 int RSA_set0_crt_params(RSA* r, BIGNUM* dmp1, BIGNUM* dmq1, BIGNUM* iqmp);
+    OSSL_DEPRECATEDIN_3_0 int RSA_set0_multi_prime_params(RSA* r, BIGNUM* primes[], BIGNUM* exps[], BIGNUM* coeffs[], int pnum);
+    OSSL_DEPRECATEDIN_3_0 void RSA_get0_key(const RSA* r, const BIGNUM** n, const BIGNUM** e, const BIGNUM** d);
+    OSSL_DEPRECATEDIN_3_0 void RSA_get0_factors(const RSA* r, const BIGNUM** p, const BIGNUM** q);
+    OSSL_DEPRECATEDIN_3_0 int RSA_get_multi_prime_extra_count(const RSA* r);
+    OSSL_DEPRECATEDIN_3_0 int RSA_get0_multi_prime_factors(const RSA* r, const BIGNUM* primes[]);
+    OSSL_DEPRECATEDIN_3_0 void RSA_get0_crt_params(const RSA* r, const BIGNUM** dmp1, const BIGNUM** dmq1, const BIGNUM** iqmp);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_get0_multi_prime_crt_params(const RSA* r, const BIGNUM* exps[], const BIGNUM* coeffs[]);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* RSA_get0_n(const RSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* RSA_get0_e(const RSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* RSA_get0_d(const RSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* RSA_get0_p(const RSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* RSA_get0_q(const RSA* d);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* RSA_get0_dmp1(const RSA* r);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* RSA_get0_dmq1(const RSA* r);
+    OSSL_DEPRECATEDIN_3_0 const BIGNUM* RSA_get0_iqmp(const RSA* r);
+    OSSL_DEPRECATEDIN_3_0 const RSA_PSS_PARAMS* RSA_get0_pss_params(const RSA* r);
+    OSSL_DEPRECATEDIN_3_0 void RSA_clear_flags(RSA* r, int flags);
+    OSSL_DEPRECATEDIN_3_0 int RSA_test_flags(const RSA* r, int flags);
+    OSSL_DEPRECATEDIN_3_0 void RSA_set_flags(RSA* r, int flags);
+    OSSL_DEPRECATEDIN_3_0 int RSA_get_version(RSA* r);
+    OSSL_DEPRECATEDIN_3_0 ENGINE* RSA_get0_engine(const RSA* r);
+#endif /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+#define EVP_RSA_gen(bits) \
     EVP_PKEY_Q_keygen(NULL, NULL, "RSA", (size_t)(0 + (bits)))
 
 /* Deprecated version */
-# ifndef OPENSSL_NO_DEPRECATED_0_9_8
-OSSL_DEPRECATEDIN_0_9_8 RSA *RSA_generate_key(int bits, unsigned long e, void
-                                              (*callback) (int, int, void *),
-                                              void *cb_arg);
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_0_9_8
+    OSSL_DEPRECATEDIN_0_9_8 RSA* RSA_generate_key(int bits, unsigned long e, void (*callback)(int, int, void*), void* cb_arg);
+#endif
 
 /* New version */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e,
-                                              BN_GENCB *cb);
-/* Multi-prime version */
-OSSL_DEPRECATEDIN_3_0 int RSA_generate_multi_prime_key(RSA *rsa, int bits,
-                                                       int primes, BIGNUM *e,
-                                                       BN_GENCB *cb);
-
-OSSL_DEPRECATEDIN_3_0
-int RSA_X931_derive_ex(RSA *rsa, BIGNUM *p1, BIGNUM *p2,
-                       BIGNUM *q1, BIGNUM *q2,
-                       const BIGNUM *Xp1, const BIGNUM *Xp2,
-                       const BIGNUM *Xp, const BIGNUM *Xq1,
-                       const BIGNUM *Xq2, const BIGNUM *Xq,
-                       const BIGNUM *e, BN_GENCB *cb);
-OSSL_DEPRECATEDIN_3_0 int RSA_X931_generate_key_ex(RSA *rsa, int bits,
-                                                   const BIGNUM *e,
-                                                   BN_GENCB *cb);
-
-OSSL_DEPRECATEDIN_3_0 int RSA_check_key(const RSA *);
-OSSL_DEPRECATEDIN_3_0 int RSA_check_key_ex(const RSA *, BN_GENCB *cb);
-        /* next 4 return -1 on error */
-OSSL_DEPRECATEDIN_3_0
-int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to,
-                       RSA *rsa, int padding);
-OSSL_DEPRECATEDIN_3_0
-int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to,
-                        RSA *rsa, int padding);
-OSSL_DEPRECATEDIN_3_0
-int RSA_public_decrypt(int flen, const unsigned char *from, unsigned char *to,
-                       RSA *rsa, int padding);
-OSSL_DEPRECATEDIN_3_0
-int RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to,
-                        RSA *rsa, int padding);
-OSSL_DEPRECATEDIN_3_0 void RSA_free(RSA *r);
-/* "up" the RSA object's reference count */
-OSSL_DEPRECATEDIN_3_0 int RSA_up_ref(RSA *r);
-OSSL_DEPRECATEDIN_3_0 int RSA_flags(const RSA *r);
-
-OSSL_DEPRECATEDIN_3_0 void RSA_set_default_method(const RSA_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_get_default_method(void);
-OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_null_method(void);
-OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_get_method(const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 int RSA_set_method(RSA *rsa, const RSA_METHOD *meth);
-
-/* these are the actual RSA functions */
-OSSL_DEPRECATEDIN_3_0 const RSA_METHOD *RSA_PKCS1_OpenSSL(void);
-
-DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(OSSL_DEPRECATEDIN_3_0,
-                                        RSA, RSAPublicKey)
-DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(OSSL_DEPRECATEDIN_3_0,
-                                        RSA, RSAPrivateKey)
-# endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
-
-int RSA_pkey_ctx_ctrl(EVP_PKEY_CTX *ctx, int optype, int cmd, int p1, void *p2);
-
-struct rsa_pss_params_st {
-    X509_ALGOR *hashAlgorithm;
-    X509_ALGOR *maskGenAlgorithm;
-    ASN1_INTEGER *saltLength;
-    ASN1_INTEGER *trailerField;
-    /* Decoded hash algorithm from maskGenAlgorithm */
-    X509_ALGOR *maskHash;
-};
-
-DECLARE_ASN1_FUNCTIONS(RSA_PSS_PARAMS)
-DECLARE_ASN1_DUP_FUNCTION(RSA_PSS_PARAMS)
-
-typedef struct rsa_oaep_params_st {
-    X509_ALGOR *hashFunc;
-    X509_ALGOR *maskGenFunc;
-    X509_ALGOR *pSourceFunc;
-    /* Decoded hash algorithm from maskGenFunc */
-    X509_ALGOR *maskHash;
-} RSA_OAEP_PARAMS;
-
-DECLARE_ASN1_FUNCTIONS(RSA_OAEP_PARAMS)
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifndef OPENSSL_NO_STDIO
-OSSL_DEPRECATEDIN_3_0 int RSA_print_fp(FILE *fp, const RSA *r, int offset);
-#  endif
-
-OSSL_DEPRECATEDIN_3_0 int RSA_print(BIO *bp, const RSA *r, int offset);
-
-/*
- * The following 2 functions sign and verify a X509_SIG ASN1 object inside
- * PKCS#1 padded RSA encryption
- */
-OSSL_DEPRECATEDIN_3_0 int RSA_sign(int type, const unsigned char *m,
-                                   unsigned int m_length, unsigned char *sigret,
-                                   unsigned int *siglen, RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 int RSA_verify(int type, const unsigned char *m,
-                                     unsigned int m_length,
-                                     const unsigned char *sigbuf,
-                                     unsigned int siglen, RSA *rsa);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int RSA_generate_key_ex(RSA* rsa, int bits, BIGNUM* e, BN_GENCB* cb);
+    /* Multi-prime version */
+    OSSL_DEPRECATEDIN_3_0 int RSA_generate_multi_prime_key(RSA* rsa, int bits, int primes, BIGNUM* e, BN_GENCB* cb);
+
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_X931_derive_ex(RSA* rsa, BIGNUM* p1, BIGNUM* p2, BIGNUM* q1, BIGNUM* q2, const BIGNUM* Xp1, const BIGNUM* Xp2, const BIGNUM* Xp, const BIGNUM* Xq1, const BIGNUM* Xq2, const BIGNUM* Xq, const BIGNUM* e, BN_GENCB* cb);
+    OSSL_DEPRECATEDIN_3_0 int RSA_X931_generate_key_ex(RSA* rsa, int bits, const BIGNUM* e, BN_GENCB* cb);
+
+    OSSL_DEPRECATEDIN_3_0 int RSA_check_key(const RSA*);
+    OSSL_DEPRECATEDIN_3_0 int RSA_check_key_ex(const RSA*, BN_GENCB* cb);
+    /* next 4 return -1 on error */
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_public_encrypt(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_private_encrypt(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_public_decrypt(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_private_decrypt(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding);
+    OSSL_DEPRECATEDIN_3_0 void RSA_free(RSA* r);
+    /* "up" the RSA object's reference count */
+    OSSL_DEPRECATEDIN_3_0 int RSA_up_ref(RSA* r);
+    OSSL_DEPRECATEDIN_3_0 int RSA_flags(const RSA* r);
+
+    OSSL_DEPRECATEDIN_3_0 void RSA_set_default_method(const RSA_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 const RSA_METHOD* RSA_get_default_method(void);
+    OSSL_DEPRECATEDIN_3_0 const RSA_METHOD* RSA_null_method(void);
+    OSSL_DEPRECATEDIN_3_0 const RSA_METHOD* RSA_get_method(const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 int RSA_set_method(RSA* rsa, const RSA_METHOD* meth);
+
+    /* these are the actual RSA functions */
+    OSSL_DEPRECATEDIN_3_0 const RSA_METHOD* RSA_PKCS1_OpenSSL(void);
+
+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPublicKey)
+        DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPrivateKey)
+#endif /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+            int RSA_pkey_ctx_ctrl(EVP_PKEY_CTX* ctx, int optype, int cmd, int p1, void* p2);
+
+    struct rsa_pss_params_st
+    {
+        X509_ALGOR* hashAlgorithm;
+        X509_ALGOR* maskGenAlgorithm;
+        ASN1_INTEGER* saltLength;
+        ASN1_INTEGER* trailerField;
+        /* Decoded hash algorithm from maskGenAlgorithm */
+        X509_ALGOR* maskHash;
+    };
+
+    DECLARE_ASN1_FUNCTIONS(RSA_PSS_PARAMS)
+    DECLARE_ASN1_DUP_FUNCTION(RSA_PSS_PARAMS)
+
+    typedef struct rsa_oaep_params_st
+    {
+        X509_ALGOR* hashFunc;
+        X509_ALGOR* maskGenFunc;
+        X509_ALGOR* pSourceFunc;
+        /* Decoded hash algorithm from maskGenFunc */
+        X509_ALGOR* maskHash;
+    } RSA_OAEP_PARAMS;
+
+    DECLARE_ASN1_FUNCTIONS(RSA_OAEP_PARAMS)
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_STDIO
+    OSSL_DEPRECATEDIN_3_0 int RSA_print_fp(FILE* fp, const RSA* r, int offset);
+#endif
 
-/*
- * The following 2 function sign and verify a ASN1_OCTET_STRING object inside
- * PKCS#1 padded RSA encryption
- */
-OSSL_DEPRECATEDIN_3_0
-int RSA_sign_ASN1_OCTET_STRING(int type,
-                               const unsigned char *m, unsigned int m_length,
-                               unsigned char *sigret, unsigned int *siglen,
-                               RSA *rsa);
-OSSL_DEPRECATEDIN_3_0
-int RSA_verify_ASN1_OCTET_STRING(int type,
-                                 const unsigned char *m, unsigned int m_length,
-                                 unsigned char *sigbuf, unsigned int siglen,
-                                 RSA *rsa);
-
-OSSL_DEPRECATEDIN_3_0 int RSA_blinding_on(RSA *rsa, BN_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 void RSA_blinding_off(RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx);
-
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen,
-                                 const unsigned char *f, int fl);
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen,
-                                   const unsigned char *f, int fl,
-                                   int rsa_len);
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen,
-                                 const unsigned char *f, int fl);
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen,
-                                   const unsigned char *f, int fl,
-                                   int rsa_len);
-OSSL_DEPRECATEDIN_3_0 int PKCS1_MGF1(unsigned char *mask, long len,
-                                     const unsigned char *seed, long seedlen,
-                                     const EVP_MD *dgst);
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen,
-                               const unsigned char *f, int fl,
-                               const unsigned char *p, int pl);
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen,
-                                 const unsigned char *f, int fl, int rsa_len,
-                                 const unsigned char *p, int pl);
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_add_PKCS1_OAEP_mgf1(unsigned char *to, int tlen,
-                                    const unsigned char *from, int flen,
-                                    const unsigned char *param, int plen,
-                                    const EVP_MD *md, const EVP_MD *mgf1md);
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_check_PKCS1_OAEP_mgf1(unsigned char *to, int tlen,
-                                      const unsigned char *from, int flen,
-                                      int num,
-                                      const unsigned char *param, int plen,
-                                      const EVP_MD *md, const EVP_MD *mgf1md);
-OSSL_DEPRECATEDIN_3_0 int RSA_padding_add_none(unsigned char *to, int tlen,
-                                               const unsigned char *f, int fl);
-OSSL_DEPRECATEDIN_3_0 int RSA_padding_check_none(unsigned char *to, int tlen,
-                                                 const unsigned char *f, int fl,
-                                                 int rsa_len);
-OSSL_DEPRECATEDIN_3_0 int RSA_padding_add_X931(unsigned char *to, int tlen,
-                                               const unsigned char *f, int fl);
-OSSL_DEPRECATEDIN_3_0 int RSA_padding_check_X931(unsigned char *to, int tlen,
-                                                 const unsigned char *f, int fl,
-                                                 int rsa_len);
-OSSL_DEPRECATEDIN_3_0 int RSA_X931_hash_id(int nid);
-
-OSSL_DEPRECATEDIN_3_0
-int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash,
-                         const EVP_MD *Hash, const unsigned char *EM,
-                         int sLen);
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM,
-                              const unsigned char *mHash, const EVP_MD *Hash,
-                              int sLen);
-
-OSSL_DEPRECATEDIN_3_0
-int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash,
-                              const EVP_MD *Hash, const EVP_MD *mgf1Hash,
-                              const unsigned char *EM, int sLen);
-
-OSSL_DEPRECATEDIN_3_0
-int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM,
-                                   const unsigned char *mHash,
-                                   const EVP_MD *Hash, const EVP_MD *mgf1Hash,
-                                   int sLen);
-
-# define RSA_get_ex_new_index(l, p, newf, dupf, freef) \
+    OSSL_DEPRECATEDIN_3_0 int RSA_print(BIO* bp, const RSA* r, int offset);
+
+    /*
+     * The following 2 functions sign and verify a X509_SIG ASN1 object inside
+     * PKCS#1 padded RSA encryption
+     */
+    OSSL_DEPRECATEDIN_3_0 int RSA_sign(int type, const unsigned char* m, unsigned int m_length, unsigned char* sigret, unsigned int* siglen, RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 int RSA_verify(int type, const unsigned char* m, unsigned int m_length, const unsigned char* sigbuf, unsigned int siglen, RSA* rsa);
+
+    /*
+     * The following 2 function sign and verify a ASN1_OCTET_STRING object inside
+     * PKCS#1 padded RSA encryption
+     */
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_sign_ASN1_OCTET_STRING(int type, const unsigned char* m, unsigned int m_length, unsigned char* sigret, unsigned int* siglen, RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_verify_ASN1_OCTET_STRING(int type, const unsigned char* m, unsigned int m_length, unsigned char* sigbuf, unsigned int siglen, RSA* rsa);
+
+    OSSL_DEPRECATEDIN_3_0 int RSA_blinding_on(RSA* rsa, BN_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 void RSA_blinding_off(RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 BN_BLINDING* RSA_setup_blinding(RSA* rsa, BN_CTX* ctx);
+
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_add_PKCS1_type_1(unsigned char* to, int tlen, const unsigned char* f, int fl);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_check_PKCS1_type_1(unsigned char* to, int tlen, const unsigned char* f, int fl, int rsa_len);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_add_PKCS1_type_2(unsigned char* to, int tlen, const unsigned char* f, int fl);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_check_PKCS1_type_2(unsigned char* to, int tlen, const unsigned char* f, int fl, int rsa_len);
+    OSSL_DEPRECATEDIN_3_0 int PKCS1_MGF1(unsigned char* mask, long len, const unsigned char* seed, long seedlen, const EVP_MD* dgst);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_add_PKCS1_OAEP(unsigned char* to, int tlen, const unsigned char* f, int fl, const unsigned char* p, int pl);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_check_PKCS1_OAEP(unsigned char* to, int tlen, const unsigned char* f, int fl, int rsa_len, const unsigned char* p, int pl);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_add_PKCS1_OAEP_mgf1(unsigned char* to, int tlen, const unsigned char* from, int flen, const unsigned char* param, int plen, const EVP_MD* md, const EVP_MD* mgf1md);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_check_PKCS1_OAEP_mgf1(unsigned char* to, int tlen, const unsigned char* from, int flen, int num, const unsigned char* param, int plen, const EVP_MD* md, const EVP_MD* mgf1md);
+    OSSL_DEPRECATEDIN_3_0 int RSA_padding_add_none(unsigned char* to, int tlen, const unsigned char* f, int fl);
+    OSSL_DEPRECATEDIN_3_0 int RSA_padding_check_none(unsigned char* to, int tlen, const unsigned char* f, int fl, int rsa_len);
+    OSSL_DEPRECATEDIN_3_0 int RSA_padding_add_X931(unsigned char* to, int tlen, const unsigned char* f, int fl);
+    OSSL_DEPRECATEDIN_3_0 int RSA_padding_check_X931(unsigned char* to, int tlen, const unsigned char* f, int fl, int rsa_len);
+    OSSL_DEPRECATEDIN_3_0 int RSA_X931_hash_id(int nid);
+
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_verify_PKCS1_PSS(RSA* rsa, const unsigned char* mHash, const EVP_MD* Hash, const unsigned char* EM, int sLen);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_add_PKCS1_PSS(RSA* rsa, unsigned char* EM, const unsigned char* mHash, const EVP_MD* Hash, int sLen);
+
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_verify_PKCS1_PSS_mgf1(RSA* rsa, const unsigned char* mHash, const EVP_MD* Hash, const EVP_MD* mgf1Hash, const unsigned char* EM, int sLen);
+
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_padding_add_PKCS1_PSS_mgf1(RSA* rsa, unsigned char* EM, const unsigned char* mHash, const EVP_MD* Hash, const EVP_MD* mgf1Hash, int sLen);
+
+#define RSA_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, l, p, newf, dupf, freef)
-OSSL_DEPRECATEDIN_3_0 int RSA_set_ex_data(RSA *r, int idx, void *arg);
-OSSL_DEPRECATEDIN_3_0 void *RSA_get_ex_data(const RSA *r, int idx);
+    OSSL_DEPRECATEDIN_3_0 int RSA_set_ex_data(RSA* r, int idx, void* arg);
+    OSSL_DEPRECATEDIN_3_0 void* RSA_get_ex_data(const RSA* r, int idx);
 
-DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPublicKey)
-DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPrivateKey)
+    DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPublicKey)
+        DECLARE_ASN1_DUP_FUNCTION_name_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSAPrivateKey)
 
-/*
- * If this flag is set the RSA method is FIPS compliant and can be used in
- * FIPS mode. This is set in the validated module method. If an application
- * sets this flag in its own methods it is its responsibility to ensure the
- * result is compliant.
- */
+    /*
+     * If this flag is set the RSA method is FIPS compliant and can be used in
+     * FIPS mode. This is set in the validated module method. If an application
+     * sets this flag in its own methods it is its responsibility to ensure the
+     * result is compliant.
+     */
 
-#  define RSA_FLAG_FIPS_METHOD                    0x0400
+#define RSA_FLAG_FIPS_METHOD 0x0400
 
-/*
- * If this flag is set the operations normally disabled in FIPS mode are
- * permitted it is then the applications responsibility to ensure that the
- * usage is compliant.
- */
+    /*
+     * If this flag is set the operations normally disabled in FIPS mode are
+     * permitted it is then the applications responsibility to ensure that the
+     * usage is compliant.
+     */
 
-#  define RSA_FLAG_NON_FIPS_ALLOW                 0x0400
+#define RSA_FLAG_NON_FIPS_ALLOW 0x0400
 /*
  * Application has decided PRNG is good enough to generate a key: don't
  * check.
  */
-#  define RSA_FLAG_CHECKED                        0x0800
-
-OSSL_DEPRECATEDIN_3_0 RSA_METHOD *RSA_meth_new(const char *name, int flags);
-OSSL_DEPRECATEDIN_3_0 void RSA_meth_free(RSA_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 const char *RSA_meth_get0_name(const RSA_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 int RSA_meth_set1_name(RSA_METHOD *meth,
-                                             const char *name);
-OSSL_DEPRECATEDIN_3_0 int RSA_meth_get_flags(const RSA_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 int RSA_meth_set_flags(RSA_METHOD *meth, int flags);
-OSSL_DEPRECATEDIN_3_0 void *RSA_meth_get0_app_data(const RSA_METHOD *meth);
-OSSL_DEPRECATEDIN_3_0 int RSA_meth_set0_app_data(RSA_METHOD *meth,
-                                                 void *app_data);
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_pub_enc(const RSA_METHOD *meth)) (int flen,
-                                                     const unsigned char *from,
-                                                     unsigned char *to,
-                                                     RSA *rsa, int padding);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_pub_enc(RSA_METHOD *rsa,
-                         int (*pub_enc) (int flen, const unsigned char *from,
-                                         unsigned char *to, RSA *rsa,
-                                         int padding));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_pub_dec(const RSA_METHOD *meth)) (int flen,
-                                                     const unsigned char *from,
-                                                     unsigned char *to,
-                                                     RSA *rsa, int padding);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_pub_dec(RSA_METHOD *rsa,
-                         int (*pub_dec) (int flen, const unsigned char *from,
-                                         unsigned char *to, RSA *rsa,
-                                         int padding));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_priv_enc(const RSA_METHOD *meth)) (int flen,
-                                                      const unsigned char *from,
-                                                      unsigned char *to,
-                                                      RSA *rsa, int padding);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_priv_enc(RSA_METHOD *rsa,
-                          int (*priv_enc) (int flen, const unsigned char *from,
-                                           unsigned char *to, RSA *rsa,
-                                           int padding));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_priv_dec(const RSA_METHOD *meth)) (int flen,
-                                                      const unsigned char *from,
-                                                      unsigned char *to,
-                                                      RSA *rsa, int padding);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_priv_dec(RSA_METHOD *rsa,
-                          int (*priv_dec) (int flen, const unsigned char *from,
-                                           unsigned char *to, RSA *rsa,
-                                           int padding));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_mod_exp(const RSA_METHOD *meth)) (BIGNUM *r0,
-                                                     const BIGNUM *i,
-                                                     RSA *rsa, BN_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_mod_exp(RSA_METHOD *rsa,
-                         int (*mod_exp) (BIGNUM *r0, const BIGNUM *i, RSA *rsa,
-                                         BN_CTX *ctx));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD *meth)) (BIGNUM *r,
-                                                        const BIGNUM *a,
-                                                        const BIGNUM *p,
-                                                        const BIGNUM *m,
-                                                        BN_CTX *ctx,
-                                                        BN_MONT_CTX *m_ctx);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa,
-                            int (*bn_mod_exp) (BIGNUM *r,
-                                               const BIGNUM *a,
-                                               const BIGNUM *p,
-                                               const BIGNUM *m,
-                                               BN_CTX *ctx,
-                                               BN_MONT_CTX *m_ctx));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_init(const RSA_METHOD *meth)) (RSA *rsa);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_finish(const RSA_METHOD *meth)) (RSA *rsa);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_sign(const RSA_METHOD *meth)) (int type,
-                                                  const unsigned char *m,
-                                                  unsigned int m_length,
-                                                  unsigned char *sigret,
-                                                  unsigned int *siglen,
-                                                  const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_sign(RSA_METHOD *rsa,
-                      int (*sign) (int type, const unsigned char *m,
-                                   unsigned int m_length,
-                                   unsigned char *sigret, unsigned int *siglen,
-                                   const RSA *rsa));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_verify(const RSA_METHOD *meth)) (int dtype,
-                                                    const unsigned char *m,
-                                                    unsigned int m_length,
-                                                    const unsigned char *sigbuf,
-                                                    unsigned int siglen,
-                                                    const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_verify(RSA_METHOD *rsa,
-                        int (*verify) (int dtype, const unsigned char *m,
-                                       unsigned int m_length,
-                                       const unsigned char *sigbuf,
-                                       unsigned int siglen, const RSA *rsa));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_keygen(const RSA_METHOD *meth)) (RSA *rsa, int bits,
-                                                    BIGNUM *e, BN_GENCB *cb);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_keygen(RSA_METHOD *rsa,
-                        int (*keygen) (RSA *rsa, int bits, BIGNUM *e,
-                                       BN_GENCB *cb));
-OSSL_DEPRECATEDIN_3_0
-int (*RSA_meth_get_multi_prime_keygen(const RSA_METHOD *meth)) (RSA *rsa,
-                                                                int bits,
-                                                                int primes,
-                                                                BIGNUM *e,
-                                                                BN_GENCB *cb);
-OSSL_DEPRECATEDIN_3_0
-int RSA_meth_set_multi_prime_keygen(RSA_METHOD *meth,
-                                    int (*keygen) (RSA *rsa, int bits,
-                                                   int primes, BIGNUM *e,
-                                                   BN_GENCB *cb));
-#endif  /* !OPENSSL_NO_DEPRECATED_3_0 */
-
-# ifdef  __cplusplus
+#define RSA_FLAG_CHECKED 0x0800
+
+            OSSL_DEPRECATEDIN_3_0 RSA_METHOD* RSA_meth_new(const char* name, int flags);
+    OSSL_DEPRECATEDIN_3_0 void RSA_meth_free(RSA_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 RSA_METHOD* RSA_meth_dup(const RSA_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 const char* RSA_meth_get0_name(const RSA_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 int RSA_meth_set1_name(RSA_METHOD* meth, const char* name);
+    OSSL_DEPRECATEDIN_3_0 int RSA_meth_get_flags(const RSA_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 int RSA_meth_set_flags(RSA_METHOD* meth, int flags);
+    OSSL_DEPRECATEDIN_3_0 void* RSA_meth_get0_app_data(const RSA_METHOD* meth);
+    OSSL_DEPRECATEDIN_3_0 int RSA_meth_set0_app_data(RSA_METHOD* meth, void* app_data);
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_pub_enc(const RSA_METHOD* meth))(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_pub_enc(RSA_METHOD* rsa, int (*pub_enc)(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_pub_dec(const RSA_METHOD* meth))(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_pub_dec(RSA_METHOD* rsa, int (*pub_dec)(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_priv_enc(const RSA_METHOD* meth))(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_priv_enc(RSA_METHOD* rsa, int (*priv_enc)(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_priv_dec(const RSA_METHOD* meth))(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_priv_dec(RSA_METHOD* rsa, int (*priv_dec)(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_mod_exp(const RSA_METHOD* meth))(BIGNUM* r0, const BIGNUM* i, RSA* rsa, BN_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_mod_exp(RSA_METHOD* rsa, int (*mod_exp)(BIGNUM* r0, const BIGNUM* i, RSA* rsa, BN_CTX* ctx));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD* meth))(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx, BN_MONT_CTX* m_ctx);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_bn_mod_exp(RSA_METHOD* rsa, int (*bn_mod_exp)(BIGNUM* r, const BIGNUM* a, const BIGNUM* p, const BIGNUM* m, BN_CTX* ctx, BN_MONT_CTX* m_ctx));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_init(const RSA_METHOD* meth))(RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_init(RSA_METHOD* rsa, int (*init)(RSA* rsa));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_finish(const RSA_METHOD* meth))(RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_finish(RSA_METHOD* rsa, int (*finish)(RSA* rsa));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_sign(const RSA_METHOD* meth))(int type, const unsigned char* m, unsigned int m_length, unsigned char* sigret, unsigned int* siglen, const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_sign(RSA_METHOD* rsa, int (*sign)(int type, const unsigned char* m, unsigned int m_length, unsigned char* sigret, unsigned int* siglen, const RSA* rsa));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_verify(const RSA_METHOD* meth))(int dtype, const unsigned char* m, unsigned int m_length, const unsigned char* sigbuf, unsigned int siglen, const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_verify(RSA_METHOD* rsa, int (*verify)(int dtype, const unsigned char* m, unsigned int m_length, const unsigned char* sigbuf, unsigned int siglen, const RSA* rsa));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_keygen(const RSA_METHOD* meth))(RSA* rsa, int bits, BIGNUM* e, BN_GENCB* cb);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_keygen(RSA_METHOD* rsa, int (*keygen)(RSA* rsa, int bits, BIGNUM* e, BN_GENCB* cb));
+    OSSL_DEPRECATEDIN_3_0
+    int (*RSA_meth_get_multi_prime_keygen(const RSA_METHOD* meth))(RSA* rsa, int bits, int primes, BIGNUM* e, BN_GENCB* cb);
+    OSSL_DEPRECATEDIN_3_0
+    int RSA_meth_set_multi_prime_keygen(RSA_METHOD* meth, int (*keygen)(RSA* rsa, int bits, int primes, BIGNUM* e, BN_GENCB* cb));
+#endif /* !OPENSSL_NO_DEPRECATED_3_0 */
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/rsaerr.h b/CAPI/cpp/grpc/include/openssl/rsaerr.h
index c58463c..8432f5f 100644
--- a/CAPI/cpp/grpc/include/openssl/rsaerr.h
+++ b/CAPI/cpp/grpc/include/openssl/rsaerr.h
@@ -9,99 +9,97 @@
  */
 
 #ifndef OPENSSL_RSAERR_H
-# define OPENSSL_RSAERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_RSAERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * RSA reason codes.
  */
-# define RSA_R_ALGORITHM_MISMATCH                         100
-# define RSA_R_BAD_E_VALUE                                101
-# define RSA_R_BAD_FIXED_HEADER_DECRYPT                   102
-# define RSA_R_BAD_PAD_BYTE_COUNT                         103
-# define RSA_R_BAD_SIGNATURE                              104
-# define RSA_R_BLOCK_TYPE_IS_NOT_01                       106
-# define RSA_R_BLOCK_TYPE_IS_NOT_02                       107
-# define RSA_R_DATA_GREATER_THAN_MOD_LEN                  108
-# define RSA_R_DATA_TOO_LARGE                             109
-# define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE                110
-# define RSA_R_DATA_TOO_LARGE_FOR_MODULUS                 132
-# define RSA_R_DATA_TOO_SMALL                             111
-# define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE                122
-# define RSA_R_DIGEST_DOES_NOT_MATCH                      158
-# define RSA_R_DIGEST_NOT_ALLOWED                         145
-# define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY                 112
-# define RSA_R_DMP1_NOT_CONGRUENT_TO_D                    124
-# define RSA_R_DMQ1_NOT_CONGRUENT_TO_D                    125
-# define RSA_R_D_E_NOT_CONGRUENT_TO_1                     123
-# define RSA_R_FIRST_OCTET_INVALID                        133
-# define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE        144
-# define RSA_R_INVALID_DIGEST                             157
-# define RSA_R_INVALID_DIGEST_LENGTH                      143
-# define RSA_R_INVALID_HEADER                             137
-# define RSA_R_INVALID_KEYPAIR                            171
-# define RSA_R_INVALID_KEY_LENGTH                         173
-# define RSA_R_INVALID_LABEL                              160
-# define RSA_R_INVALID_LENGTH                             181
-# define RSA_R_INVALID_MESSAGE_LENGTH                     131
-# define RSA_R_INVALID_MGF1_MD                            156
-# define RSA_R_INVALID_MODULUS                            174
-# define RSA_R_INVALID_MULTI_PRIME_KEY                    167
-# define RSA_R_INVALID_OAEP_PARAMETERS                    161
-# define RSA_R_INVALID_PADDING                            138
-# define RSA_R_INVALID_PADDING_MODE                       141
-# define RSA_R_INVALID_PSS_PARAMETERS                     149
-# define RSA_R_INVALID_PSS_SALTLEN                        146
-# define RSA_R_INVALID_REQUEST                            175
-# define RSA_R_INVALID_SALT_LENGTH                        150
-# define RSA_R_INVALID_STRENGTH                           176
-# define RSA_R_INVALID_TRAILER                            139
-# define RSA_R_INVALID_X931_DIGEST                        142
-# define RSA_R_IQMP_NOT_INVERSE_OF_Q                      126
-# define RSA_R_KEY_PRIME_NUM_INVALID                      165
-# define RSA_R_KEY_SIZE_TOO_SMALL                         120
-# define RSA_R_LAST_OCTET_INVALID                         134
-# define RSA_R_MGF1_DIGEST_NOT_ALLOWED                    152
-# define RSA_R_MISSING_PRIVATE_KEY                        179
-# define RSA_R_MODULUS_TOO_LARGE                          105
-# define RSA_R_MP_COEFFICIENT_NOT_INVERSE_OF_R            168
-# define RSA_R_MP_EXPONENT_NOT_CONGRUENT_TO_D             169
-# define RSA_R_MP_R_NOT_PRIME                             170
-# define RSA_R_NO_PUBLIC_EXPONENT                         140
-# define RSA_R_NULL_BEFORE_BLOCK_MISSING                  113
-# define RSA_R_N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES         172
-# define RSA_R_N_DOES_NOT_EQUAL_P_Q                       127
-# define RSA_R_OAEP_DECODING_ERROR                        121
-# define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE   148
-# define RSA_R_PADDING_CHECK_FAILED                       114
-# define RSA_R_PAIRWISE_TEST_FAILURE                      177
-# define RSA_R_PKCS_DECODING_ERROR                        159
-# define RSA_R_PSS_SALTLEN_TOO_SMALL                      164
-# define RSA_R_PUB_EXPONENT_OUT_OF_RANGE                  178
-# define RSA_R_P_NOT_PRIME                                128
-# define RSA_R_Q_NOT_PRIME                                129
-# define RSA_R_RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT    180
-# define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED               130
-# define RSA_R_SLEN_CHECK_FAILED                          136
-# define RSA_R_SLEN_RECOVERY_FAILED                       135
-# define RSA_R_SSLV3_ROLLBACK_ATTACK                      115
-# define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116
-# define RSA_R_UNKNOWN_ALGORITHM_TYPE                     117
-# define RSA_R_UNKNOWN_DIGEST                             166
-# define RSA_R_UNKNOWN_MASK_DIGEST                        151
-# define RSA_R_UNKNOWN_PADDING_TYPE                       118
-# define RSA_R_UNSUPPORTED_ENCRYPTION_TYPE                162
-# define RSA_R_UNSUPPORTED_LABEL_SOURCE                   163
-# define RSA_R_UNSUPPORTED_MASK_ALGORITHM                 153
-# define RSA_R_UNSUPPORTED_MASK_PARAMETER                 154
-# define RSA_R_UNSUPPORTED_SIGNATURE_TYPE                 155
-# define RSA_R_VALUE_MISSING                              147
-# define RSA_R_WRONG_SIGNATURE_LENGTH                     119
+#define RSA_R_ALGORITHM_MISMATCH 100
+#define RSA_R_BAD_E_VALUE 101
+#define RSA_R_BAD_FIXED_HEADER_DECRYPT 102
+#define RSA_R_BAD_PAD_BYTE_COUNT 103
+#define RSA_R_BAD_SIGNATURE 104
+#define RSA_R_BLOCK_TYPE_IS_NOT_01 106
+#define RSA_R_BLOCK_TYPE_IS_NOT_02 107
+#define RSA_R_DATA_GREATER_THAN_MOD_LEN 108
+#define RSA_R_DATA_TOO_LARGE 109
+#define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 110
+#define RSA_R_DATA_TOO_LARGE_FOR_MODULUS 132
+#define RSA_R_DATA_TOO_SMALL 111
+#define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE 122
+#define RSA_R_DIGEST_DOES_NOT_MATCH 158
+#define RSA_R_DIGEST_NOT_ALLOWED 145
+#define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY 112
+#define RSA_R_DMP1_NOT_CONGRUENT_TO_D 124
+#define RSA_R_DMQ1_NOT_CONGRUENT_TO_D 125
+#define RSA_R_D_E_NOT_CONGRUENT_TO_1 123
+#define RSA_R_FIRST_OCTET_INVALID 133
+#define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 144
+#define RSA_R_INVALID_DIGEST 157
+#define RSA_R_INVALID_DIGEST_LENGTH 143
+#define RSA_R_INVALID_HEADER 137
+#define RSA_R_INVALID_KEYPAIR 171
+#define RSA_R_INVALID_KEY_LENGTH 173
+#define RSA_R_INVALID_LABEL 160
+#define RSA_R_INVALID_LENGTH 181
+#define RSA_R_INVALID_MESSAGE_LENGTH 131
+#define RSA_R_INVALID_MGF1_MD 156
+#define RSA_R_INVALID_MODULUS 174
+#define RSA_R_INVALID_MULTI_PRIME_KEY 167
+#define RSA_R_INVALID_OAEP_PARAMETERS 161
+#define RSA_R_INVALID_PADDING 138
+#define RSA_R_INVALID_PADDING_MODE 141
+#define RSA_R_INVALID_PSS_PARAMETERS 149
+#define RSA_R_INVALID_PSS_SALTLEN 146
+#define RSA_R_INVALID_REQUEST 175
+#define RSA_R_INVALID_SALT_LENGTH 150
+#define RSA_R_INVALID_STRENGTH 176
+#define RSA_R_INVALID_TRAILER 139
+#define RSA_R_INVALID_X931_DIGEST 142
+#define RSA_R_IQMP_NOT_INVERSE_OF_Q 126
+#define RSA_R_KEY_PRIME_NUM_INVALID 165
+#define RSA_R_KEY_SIZE_TOO_SMALL 120
+#define RSA_R_LAST_OCTET_INVALID 134
+#define RSA_R_MGF1_DIGEST_NOT_ALLOWED 152
+#define RSA_R_MISSING_PRIVATE_KEY 179
+#define RSA_R_MODULUS_TOO_LARGE 105
+#define RSA_R_MP_COEFFICIENT_NOT_INVERSE_OF_R 168
+#define RSA_R_MP_EXPONENT_NOT_CONGRUENT_TO_D 169
+#define RSA_R_MP_R_NOT_PRIME 170
+#define RSA_R_NO_PUBLIC_EXPONENT 140
+#define RSA_R_NULL_BEFORE_BLOCK_MISSING 113
+#define RSA_R_N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES 172
+#define RSA_R_N_DOES_NOT_EQUAL_P_Q 127
+#define RSA_R_OAEP_DECODING_ERROR 121
+#define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 148
+#define RSA_R_PADDING_CHECK_FAILED 114
+#define RSA_R_PAIRWISE_TEST_FAILURE 177
+#define RSA_R_PKCS_DECODING_ERROR 159
+#define RSA_R_PSS_SALTLEN_TOO_SMALL 164
+#define RSA_R_PUB_EXPONENT_OUT_OF_RANGE 178
+#define RSA_R_P_NOT_PRIME 128
+#define RSA_R_Q_NOT_PRIME 129
+#define RSA_R_RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT 180
+#define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED 130
+#define RSA_R_SLEN_CHECK_FAILED 136
+#define RSA_R_SLEN_RECOVERY_FAILED 135
+#define RSA_R_SSLV3_ROLLBACK_ATTACK 115
+#define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116
+#define RSA_R_UNKNOWN_ALGORITHM_TYPE 117
+#define RSA_R_UNKNOWN_DIGEST 166
+#define RSA_R_UNKNOWN_MASK_DIGEST 151
+#define RSA_R_UNKNOWN_PADDING_TYPE 118
+#define RSA_R_UNSUPPORTED_ENCRYPTION_TYPE 162
+#define RSA_R_UNSUPPORTED_LABEL_SOURCE 163
+#define RSA_R_UNSUPPORTED_MASK_ALGORITHM 153
+#define RSA_R_UNSUPPORTED_MASK_PARAMETER 154
+#define RSA_R_UNSUPPORTED_SIGNATURE_TYPE 155
+#define RSA_R_VALUE_MISSING 147
+#define RSA_R_WRONG_SIGNATURE_LENGTH 119
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/safestack.h b/CAPI/cpp/grpc/include/openssl/safestack.h
index 159ccf2..dd26a6a 100644
--- a/CAPI/cpp/grpc/include/openssl/safestack.h
+++ b/CAPI/cpp/grpc/include/openssl/safestack.h
@@ -10,288 +10,281 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_SAFESTACK_H
-# define OPENSSL_SAFESTACK_H
-# pragma once
+#define OPENSSL_SAFESTACK_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_SAFESTACK_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_SAFESTACK_H
+#endif
 
-# include <openssl/stack.h>
-# include <openssl/e_os2.h>
+#include <openssl/stack.h>
+#include <openssl/e_os2.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-# define STACK_OF(type) struct stack_st_##type
+#define STACK_OF(type) struct stack_st_##type
 
 /* Helper macro for internal use */
-# define SKM_DEFINE_STACK_OF_INTERNAL(t1, t2, t3) \
-    STACK_OF(t1); \
-    typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \
-    typedef void (*sk_##t1##_freefunc)(t3 *a); \
-    typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \
-    static ossl_unused ossl_inline t2 *ossl_check_##t1##_type(t2 *ptr) \
-    { \
-        return ptr; \
-    } \
-    static ossl_unused ossl_inline const OPENSSL_STACK *ossl_check_const_##t1##_sk_type(const STACK_OF(t1) *sk) \
-    { \
-        return (const OPENSSL_STACK *)sk; \
-    } \
-    static ossl_unused ossl_inline OPENSSL_STACK *ossl_check_##t1##_sk_type(STACK_OF(t1) *sk) \
-    { \
-        return (OPENSSL_STACK *)sk; \
-    } \
-    static ossl_unused ossl_inline OPENSSL_sk_compfunc ossl_check_##t1##_compfunc_type(sk_##t1##_compfunc cmp) \
-    { \
-        return (OPENSSL_sk_compfunc)cmp; \
-    } \
-    static ossl_unused ossl_inline OPENSSL_sk_copyfunc ossl_check_##t1##_copyfunc_type(sk_##t1##_copyfunc cpy) \
-    { \
-        return (OPENSSL_sk_copyfunc)cpy; \
-    } \
-    static ossl_unused ossl_inline OPENSSL_sk_freefunc ossl_check_##t1##_freefunc_type(sk_##t1##_freefunc fr) \
-    { \
-        return (OPENSSL_sk_freefunc)fr; \
+#define SKM_DEFINE_STACK_OF_INTERNAL(t1, t2, t3)                                                                 \
+    STACK_OF(t1);                                                                                                \
+    typedef int (*sk_##t1##_compfunc)(const t3* const* a, const t3* const* b);                                   \
+    typedef void (*sk_##t1##_freefunc)(t3 * a);                                                                  \
+    typedef t3* (*sk_##t1##_copyfunc)(const t3* a);                                                              \
+    static ossl_unused ossl_inline t2* ossl_check_##t1##_type(t2* ptr)                                           \
+    {                                                                                                            \
+        return ptr;                                                                                              \
+    }                                                                                                            \
+    static ossl_unused ossl_inline const OPENSSL_STACK* ossl_check_const_##t1##_sk_type(const STACK_OF(t1) * sk) \
+    {                                                                                                            \
+        return (const OPENSSL_STACK*)sk;                                                                         \
+    }                                                                                                            \
+    static ossl_unused ossl_inline OPENSSL_STACK* ossl_check_##t1##_sk_type(STACK_OF(t1) * sk)                   \
+    {                                                                                                            \
+        return (OPENSSL_STACK*)sk;                                                                               \
+    }                                                                                                            \
+    static ossl_unused ossl_inline OPENSSL_sk_compfunc ossl_check_##t1##_compfunc_type(sk_##t1##_compfunc cmp)   \
+    {                                                                                                            \
+        return (OPENSSL_sk_compfunc)cmp;                                                                         \
+    }                                                                                                            \
+    static ossl_unused ossl_inline OPENSSL_sk_copyfunc ossl_check_##t1##_copyfunc_type(sk_##t1##_copyfunc cpy)   \
+    {                                                                                                            \
+        return (OPENSSL_sk_copyfunc)cpy;                                                                         \
+    }                                                                                                            \
+    static ossl_unused ossl_inline OPENSSL_sk_freefunc ossl_check_##t1##_freefunc_type(sk_##t1##_freefunc fr)    \
+    {                                                                                                            \
+        return (OPENSSL_sk_freefunc)fr;                                                                          \
     }
 
-# define SKM_DEFINE_STACK_OF(t1, t2, t3) \
-    STACK_OF(t1); \
-    typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \
-    typedef void (*sk_##t1##_freefunc)(t3 *a); \
-    typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \
-    static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \
-    { \
-        return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \
-    } \
-    static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \
-    { \
-        return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \
-    } \
-    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \
-    { \
-        return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \
-    } \
-    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \
-    { \
-        return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \
-    } \
-    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n) \
-    { \
-        return (STACK_OF(t1) *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); \
-    } \
-    static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n) \
-    { \
-        return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); \
-    } \
-    static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \
-    { \
-        OPENSSL_sk_free((OPENSSL_STACK *)sk); \
-    } \
-    static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \
-    { \
-        OPENSSL_sk_zero((OPENSSL_STACK *)sk); \
-    } \
-    static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \
-    { \
-        return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \
-    } \
-    static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \
-    { \
-        return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \
-                                           (const void *)ptr); \
-    } \
-    static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \
-    { \
-        return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); \
-    } \
-    static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \
-    { \
-        return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); \
-    } \
-    static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \
-    { \
-        return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \
-    } \
-    static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \
-    { \
-        return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \
-    } \
-    static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \
-    { \
-        OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \
-    } \
-    static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \
-    { \
-        return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); \
-    } \
-    static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \
-    { \
-        return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); \
-    } \
-    static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \
-    { \
-        return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); \
-    } \
-    static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \
-    { \
-        return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); \
-    } \
-    static ossl_unused ossl_inline int sk_##t1##_find_all(STACK_OF(t1) *sk, t2 *ptr, int *pnum) \
-    { \
-        return OPENSSL_sk_find_all((OPENSSL_STACK *)sk, (const void *)ptr, pnum); \
-    } \
-    static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \
-    { \
-        OPENSSL_sk_sort((OPENSSL_STACK *)sk); \
-    } \
-    static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \
-    { \
-        return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \
-    } \
-    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) *sk) \
-    { \
-        return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); \
-    } \
-    static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk, \
-                                                    sk_##t1##_copyfunc copyfunc, \
-                                                    sk_##t1##_freefunc freefunc) \
-    { \
-        return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, \
-                                            (OPENSSL_sk_copyfunc)copyfunc, \
-                                            (OPENSSL_sk_freefunc)freefunc); \
-    } \
-    static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \
-    { \
-        return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \
+#define SKM_DEFINE_STACK_OF(t1, t2, t3)                                                                                                                  \
+    STACK_OF(t1);                                                                                                                                        \
+    typedef int (*sk_##t1##_compfunc)(const t3* const* a, const t3* const* b);                                                                           \
+    typedef void (*sk_##t1##_freefunc)(t3 * a);                                                                                                          \
+    typedef t3* (*sk_##t1##_copyfunc)(const t3* a);                                                                                                      \
+    static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) * sk)                                                                            \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_num((const OPENSSL_STACK*)sk);                                                                                                 \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline t2* sk_##t1##_value(const STACK_OF(t1) * sk, int idx)                                                                 \
+    {                                                                                                                                                    \
+        return (t2*)OPENSSL_sk_value((const OPENSSL_STACK*)sk, idx);                                                                                     \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_new(sk_##t1##_compfunc compare)                                                              \
+    {                                                                                                                                                    \
+        return (STACK_OF(t1)*)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare);                                                                              \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_new_null(void)                                                                               \
+    {                                                                                                                                                    \
+        return (STACK_OF(t1)*)OPENSSL_sk_new_null();                                                                                                     \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n)                                               \
+    {                                                                                                                                                    \
+        return (STACK_OF(t1)*)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n);                                                                   \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) * sk, int n)                                                                       \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_reserve((OPENSSL_STACK*)sk, n);                                                                                                \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) * sk)                                                                                \
+    {                                                                                                                                                    \
+        OPENSSL_sk_free((OPENSSL_STACK*)sk);                                                                                                             \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) * sk)                                                                                \
+    {                                                                                                                                                    \
+        OPENSSL_sk_zero((OPENSSL_STACK*)sk);                                                                                                             \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline t2* sk_##t1##_delete(STACK_OF(t1) * sk, int i)                                                                        \
+    {                                                                                                                                                    \
+        return (t2*)OPENSSL_sk_delete((OPENSSL_STACK*)sk, i);                                                                                            \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline t2* sk_##t1##_delete_ptr(STACK_OF(t1) * sk, t2 * ptr)                                                                 \
+    {                                                                                                                                                    \
+        return (t2*)OPENSSL_sk_delete_ptr((OPENSSL_STACK*)sk, (const void*)ptr);                                                                         \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) * sk, t2 * ptr)                                                                       \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_push((OPENSSL_STACK*)sk, (const void*)ptr);                                                                                    \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) * sk, t2 * ptr)                                                                    \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_unshift((OPENSSL_STACK*)sk, (const void*)ptr);                                                                                 \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline t2* sk_##t1##_pop(STACK_OF(t1) * sk)                                                                                  \
+    {                                                                                                                                                    \
+        return (t2*)OPENSSL_sk_pop((OPENSSL_STACK*)sk);                                                                                                  \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline t2* sk_##t1##_shift(STACK_OF(t1) * sk)                                                                                \
+    {                                                                                                                                                    \
+        return (t2*)OPENSSL_sk_shift((OPENSSL_STACK*)sk);                                                                                                \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) * sk, sk_##t1##_freefunc freefunc)                                               \
+    {                                                                                                                                                    \
+        OPENSSL_sk_pop_free((OPENSSL_STACK*)sk, (OPENSSL_sk_freefunc)freefunc);                                                                          \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) * sk, t2 * ptr, int idx)                                                            \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_insert((OPENSSL_STACK*)sk, (const void*)ptr, idx);                                                                             \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline t2* sk_##t1##_set(STACK_OF(t1) * sk, int idx, t2* ptr)                                                                \
+    {                                                                                                                                                    \
+        return (t2*)OPENSSL_sk_set((OPENSSL_STACK*)sk, idx, (const void*)ptr);                                                                           \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) * sk, t2 * ptr)                                                                       \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_find((OPENSSL_STACK*)sk, (const void*)ptr);                                                                                    \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) * sk, t2 * ptr)                                                                    \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_find_ex((OPENSSL_STACK*)sk, (const void*)ptr);                                                                                 \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline int sk_##t1##_find_all(STACK_OF(t1) * sk, t2 * ptr, int* pnum)                                                        \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_find_all((OPENSSL_STACK*)sk, (const void*)ptr, pnum);                                                                          \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) * sk)                                                                                \
+    {                                                                                                                                                    \
+        OPENSSL_sk_sort((OPENSSL_STACK*)sk);                                                                                                             \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) * sk)                                                                      \
+    {                                                                                                                                                    \
+        return OPENSSL_sk_is_sorted((const OPENSSL_STACK*)sk);                                                                                           \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) * sk)                                                                 \
+    {                                                                                                                                                    \
+        return (STACK_OF(t1)*)OPENSSL_sk_dup((const OPENSSL_STACK*)sk);                                                                                  \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_deep_copy(const STACK_OF(t1) * sk, sk_##t1##_copyfunc copyfunc, sk_##t1##_freefunc freefunc) \
+    {                                                                                                                                                    \
+        return (STACK_OF(t1)*)OPENSSL_sk_deep_copy((const OPENSSL_STACK*)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc);              \
+    }                                                                                                                                                    \
+    static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) * sk, sk_##t1##_compfunc compare)                              \
+    {                                                                                                                                                    \
+        return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK*)sk, (OPENSSL_sk_compfunc)compare);                                            \
     }
 
-# define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t)
-# define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t)
-# define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2)
-# define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \
-            SKM_DEFINE_STACK_OF(t1, const t2, t2)
+#define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t)
+#define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t)
+#define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2)
+#define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \
+    SKM_DEFINE_STACK_OF(t1, const t2, t2)
 
-/*-
- * Strings are special: normally an lhash entry will point to a single
- * (somewhat) mutable object. In the case of strings:
- *
- * a) Instead of a single char, there is an array of chars, NUL-terminated.
- * b) The string may have be immutable.
- *
- * So, they need their own declarations. Especially important for
- * type-checking tools, such as Deputy.
- *
- * In practice, however, it appears to be hard to have a const
- * string. For now, I'm settling for dealing with the fact it is a
- * string at all.
- */
-typedef char *OPENSSL_STRING;
-typedef const char *OPENSSL_CSTRING;
+    /*-
+     * Strings are special: normally an lhash entry will point to a single
+     * (somewhat) mutable object. In the case of strings:
+     *
+     * a) Instead of a single char, there is an array of chars, NUL-terminated.
+     * b) The string may have be immutable.
+     *
+     * So, they need their own declarations. Especially important for
+     * type-checking tools, such as Deputy.
+     *
+     * In practice, however, it appears to be hard to have a const
+     * string. For now, I'm settling for dealing with the fact it is a
+     * string at all.
+     */
+    typedef char* OPENSSL_STRING;
+    typedef const char* OPENSSL_CSTRING;
 
-/*-
- * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but
- * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned
- * above, instead of a single char each entry is a NUL-terminated array of
- * chars. So, we have to implement STRING specially for STACK_OF. This is
- * dealt with in the autogenerated macros below.
- */
-SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_STRING, char, char)
+    /*-
+     * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but
+     * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned
+     * above, instead of a single char each entry is a NUL-terminated array of
+     * chars. So, we have to implement STRING specially for STACK_OF. This is
+     * dealt with in the autogenerated macros below.
+     */
+    SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_STRING, char, char)
 #define sk_OPENSSL_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_STRING_sk_type(sk))
-#define sk_OPENSSL_STRING_value(sk, idx) ((char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_STRING_sk_type(sk), (idx)))
-#define sk_OPENSSL_STRING_new(cmp) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new(ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
-#define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new_null())
-#define sk_OPENSSL_STRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_STRING_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_STRING_value(sk, idx) ((char*)OPENSSL_sk_value(ossl_check_const_OPENSSL_STRING_sk_type(sk), (idx)))
+#define sk_OPENSSL_STRING_new(cmp) ((STACK_OF(OPENSSL_STRING)*)OPENSSL_sk_new(ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
+#define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING)*)OPENSSL_sk_new_null())
+#define sk_OPENSSL_STRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_STRING)*)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_STRING_compfunc_type(cmp), (n)))
 #define sk_OPENSSL_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_STRING_sk_type(sk), (n))
 #define sk_OPENSSL_STRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_STRING_sk_type(sk))
 #define sk_OPENSSL_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_STRING_sk_type(sk))
-#define sk_OPENSSL_STRING_delete(sk, i) ((char *)OPENSSL_sk_delete(ossl_check_OPENSSL_STRING_sk_type(sk), (i)))
-#define sk_OPENSSL_STRING_delete_ptr(sk, ptr) ((char *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr)))
+#define sk_OPENSSL_STRING_delete(sk, i) ((char*)OPENSSL_sk_delete(ossl_check_OPENSSL_STRING_sk_type(sk), (i)))
+#define sk_OPENSSL_STRING_delete_ptr(sk, ptr) ((char*)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr)))
 #define sk_OPENSSL_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
 #define sk_OPENSSL_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
-#define sk_OPENSSL_STRING_pop(sk) ((char *)OPENSSL_sk_pop(ossl_check_OPENSSL_STRING_sk_type(sk)))
-#define sk_OPENSSL_STRING_shift(sk) ((char *)OPENSSL_sk_shift(ossl_check_OPENSSL_STRING_sk_type(sk)))
-#define sk_OPENSSL_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_STRING_sk_type(sk),ossl_check_OPENSSL_STRING_freefunc_type(freefunc))
+#define sk_OPENSSL_STRING_pop(sk) ((char*)OPENSSL_sk_pop(ossl_check_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_shift(sk) ((char*)OPENSSL_sk_shift(ossl_check_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_freefunc_type(freefunc))
 #define sk_OPENSSL_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), (idx))
-#define sk_OPENSSL_STRING_set(sk, idx, ptr) ((char *)OPENSSL_sk_set(ossl_check_OPENSSL_STRING_sk_type(sk), (idx), ossl_check_OPENSSL_STRING_type(ptr)))
+#define sk_OPENSSL_STRING_set(sk, idx, ptr) ((char*)OPENSSL_sk_set(ossl_check_OPENSSL_STRING_sk_type(sk), (idx), ossl_check_OPENSSL_STRING_type(ptr)))
 #define sk_OPENSSL_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
 #define sk_OPENSSL_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr))
 #define sk_OPENSSL_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_type(ptr), pnum)
 #define sk_OPENSSL_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_STRING_sk_type(sk))
 #define sk_OPENSSL_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_STRING_sk_type(sk))
-#define sk_OPENSSL_STRING_dup(sk) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_STRING_sk_type(sk)))
-#define sk_OPENSSL_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_STRING_freefunc_type(freefunc)))
+#define sk_OPENSSL_STRING_dup(sk) ((STACK_OF(OPENSSL_STRING)*)OPENSSL_sk_dup(ossl_check_const_OPENSSL_STRING_sk_type(sk)))
+#define sk_OPENSSL_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_STRING)*)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_STRING_freefunc_type(freefunc)))
 #define sk_OPENSSL_STRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_STRING_sk_type(sk), ossl_check_OPENSSL_STRING_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_CSTRING, const char, char)
+    SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_CSTRING, const char, char)
 #define sk_OPENSSL_CSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
-#define sk_OPENSSL_CSTRING_value(sk, idx) ((const char *)OPENSSL_sk_value(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), (idx)))
-#define sk_OPENSSL_CSTRING_new(cmp) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
-#define sk_OPENSSL_CSTRING_new_null() ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new_null())
-#define sk_OPENSSL_CSTRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_CSTRING_value(sk, idx) ((const char*)OPENSSL_sk_value(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), (idx)))
+#define sk_OPENSSL_CSTRING_new(cmp) ((STACK_OF(OPENSSL_CSTRING)*)OPENSSL_sk_new(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
+#define sk_OPENSSL_CSTRING_new_null() ((STACK_OF(OPENSSL_CSTRING)*)OPENSSL_sk_new_null())
+#define sk_OPENSSL_CSTRING_new_reserve(cmp, n) ((STACK_OF(OPENSSL_CSTRING)*)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_CSTRING_compfunc_type(cmp), (n)))
 #define sk_OPENSSL_CSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_CSTRING_sk_type(sk), (n))
 #define sk_OPENSSL_CSTRING_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_CSTRING_sk_type(sk))
 #define sk_OPENSSL_CSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_CSTRING_sk_type(sk))
-#define sk_OPENSSL_CSTRING_delete(sk, i) ((const char *)OPENSSL_sk_delete(ossl_check_OPENSSL_CSTRING_sk_type(sk), (i)))
-#define sk_OPENSSL_CSTRING_delete_ptr(sk, ptr) ((const char *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr)))
+#define sk_OPENSSL_CSTRING_delete(sk, i) ((const char*)OPENSSL_sk_delete(ossl_check_OPENSSL_CSTRING_sk_type(sk), (i)))
+#define sk_OPENSSL_CSTRING_delete_ptr(sk, ptr) ((const char*)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr)))
 #define sk_OPENSSL_CSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
 #define sk_OPENSSL_CSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
-#define sk_OPENSSL_CSTRING_pop(sk) ((const char *)OPENSSL_sk_pop(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
-#define sk_OPENSSL_CSTRING_shift(sk) ((const char *)OPENSSL_sk_shift(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
-#define sk_OPENSSL_CSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_CSTRING_sk_type(sk),ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc))
+#define sk_OPENSSL_CSTRING_pop(sk) ((const char*)OPENSSL_sk_pop(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_shift(sk) ((const char*)OPENSSL_sk_shift(ossl_check_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc))
 #define sk_OPENSSL_CSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), (idx))
-#define sk_OPENSSL_CSTRING_set(sk, idx, ptr) ((const char *)OPENSSL_sk_set(ossl_check_OPENSSL_CSTRING_sk_type(sk), (idx), ossl_check_OPENSSL_CSTRING_type(ptr)))
+#define sk_OPENSSL_CSTRING_set(sk, idx, ptr) ((const char*)OPENSSL_sk_set(ossl_check_OPENSSL_CSTRING_sk_type(sk), (idx), ossl_check_OPENSSL_CSTRING_type(ptr)))
 #define sk_OPENSSL_CSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
 #define sk_OPENSSL_CSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr))
 #define sk_OPENSSL_CSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_type(ptr), pnum)
 #define sk_OPENSSL_CSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_CSTRING_sk_type(sk))
 #define sk_OPENSSL_CSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_CSTRING_sk_type(sk))
-#define sk_OPENSSL_CSTRING_dup(sk) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_CSTRING_sk_type(sk)))
-#define sk_OPENSSL_CSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_CSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc)))
+#define sk_OPENSSL_CSTRING_dup(sk) ((STACK_OF(OPENSSL_CSTRING)*)OPENSSL_sk_dup(ossl_check_const_OPENSSL_CSTRING_sk_type(sk)))
+#define sk_OPENSSL_CSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_CSTRING)*)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_copyfunc_type(copyfunc), ossl_check_OPENSSL_CSTRING_freefunc_type(freefunc)))
 #define sk_OPENSSL_CSTRING_set_cmp_func(sk, cmp) ((sk_OPENSSL_CSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_CSTRING_sk_type(sk), ossl_check_OPENSSL_CSTRING_compfunc_type(cmp)))
 
-
 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
-/*
- * This is not used by OpenSSL.  A block of bytes,  NOT nul-terminated.
- * These should also be distinguished from "normal" stacks.
- */
-typedef void *OPENSSL_BLOCK;
-SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_BLOCK, void, void)
+    /*
+     * This is not used by OpenSSL.  A block of bytes,  NOT nul-terminated.
+     * These should also be distinguished from "normal" stacks.
+     */
+    typedef void* OPENSSL_BLOCK;
+    SKM_DEFINE_STACK_OF_INTERNAL(OPENSSL_BLOCK, void, void)
 #define sk_OPENSSL_BLOCK_num(sk) OPENSSL_sk_num(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
-#define sk_OPENSSL_BLOCK_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), (idx)))
-#define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
-#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new_null())
-#define sk_OPENSSL_BLOCK_new_reserve(cmp, n) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp), (n)))
+#define sk_OPENSSL_BLOCK_value(sk, idx) ((void*)OPENSSL_sk_value(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), (idx)))
+#define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK)*)OPENSSL_sk_new(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
+#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK)*)OPENSSL_sk_new_null())
+#define sk_OPENSSL_BLOCK_new_reserve(cmp, n) ((STACK_OF(OPENSSL_BLOCK)*)OPENSSL_sk_new_reserve(ossl_check_OPENSSL_BLOCK_compfunc_type(cmp), (n)))
 #define sk_OPENSSL_BLOCK_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OPENSSL_BLOCK_sk_type(sk), (n))
 #define sk_OPENSSL_BLOCK_free(sk) OPENSSL_sk_free(ossl_check_OPENSSL_BLOCK_sk_type(sk))
 #define sk_OPENSSL_BLOCK_zero(sk) OPENSSL_sk_zero(ossl_check_OPENSSL_BLOCK_sk_type(sk))
-#define sk_OPENSSL_BLOCK_delete(sk, i) ((void *)OPENSSL_sk_delete(ossl_check_OPENSSL_BLOCK_sk_type(sk), (i)))
-#define sk_OPENSSL_BLOCK_delete_ptr(sk, ptr) ((void *)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr)))
+#define sk_OPENSSL_BLOCK_delete(sk, i) ((void*)OPENSSL_sk_delete(ossl_check_OPENSSL_BLOCK_sk_type(sk), (i)))
+#define sk_OPENSSL_BLOCK_delete_ptr(sk, ptr) ((void*)OPENSSL_sk_delete_ptr(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr)))
 #define sk_OPENSSL_BLOCK_push(sk, ptr) OPENSSL_sk_push(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
 #define sk_OPENSSL_BLOCK_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
-#define sk_OPENSSL_BLOCK_pop(sk) ((void *)OPENSSL_sk_pop(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
-#define sk_OPENSSL_BLOCK_shift(sk) ((void *)OPENSSL_sk_shift(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
-#define sk_OPENSSL_BLOCK_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_BLOCK_sk_type(sk),ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc))
+#define sk_OPENSSL_BLOCK_pop(sk) ((void*)OPENSSL_sk_pop(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_shift(sk) ((void*)OPENSSL_sk_shift(ossl_check_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc))
 #define sk_OPENSSL_BLOCK_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), (idx))
-#define sk_OPENSSL_BLOCK_set(sk, idx, ptr) ((void *)OPENSSL_sk_set(ossl_check_OPENSSL_BLOCK_sk_type(sk), (idx), ossl_check_OPENSSL_BLOCK_type(ptr)))
+#define sk_OPENSSL_BLOCK_set(sk, idx, ptr) ((void*)OPENSSL_sk_set(ossl_check_OPENSSL_BLOCK_sk_type(sk), (idx), ossl_check_OPENSSL_BLOCK_type(ptr)))
 #define sk_OPENSSL_BLOCK_find(sk, ptr) OPENSSL_sk_find(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
 #define sk_OPENSSL_BLOCK_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr))
 #define sk_OPENSSL_BLOCK_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_type(ptr), pnum)
 #define sk_OPENSSL_BLOCK_sort(sk) OPENSSL_sk_sort(ossl_check_OPENSSL_BLOCK_sk_type(sk))
 #define sk_OPENSSL_BLOCK_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OPENSSL_BLOCK_sk_type(sk))
-#define sk_OPENSSL_BLOCK_dup(sk) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_dup(ossl_check_const_OPENSSL_BLOCK_sk_type(sk)))
-#define sk_OPENSSL_BLOCK_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_BLOCK) *)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_copyfunc_type(copyfunc), ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc)))
+#define sk_OPENSSL_BLOCK_dup(sk) ((STACK_OF(OPENSSL_BLOCK)*)OPENSSL_sk_dup(ossl_check_const_OPENSSL_BLOCK_sk_type(sk)))
+#define sk_OPENSSL_BLOCK_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OPENSSL_BLOCK)*)OPENSSL_sk_deep_copy(ossl_check_const_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_copyfunc_type(copyfunc), ossl_check_OPENSSL_BLOCK_freefunc_type(freefunc)))
 #define sk_OPENSSL_BLOCK_set_cmp_func(sk, cmp) ((sk_OPENSSL_BLOCK_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OPENSSL_BLOCK_sk_type(sk), ossl_check_OPENSSL_BLOCK_compfunc_type(cmp)))
 
 #endif
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/seed.h b/CAPI/cpp/grpc/include/openssl/seed.h
index edb218a..1521784 100644
--- a/CAPI/cpp/grpc/include/openssl/seed.h
+++ b/CAPI/cpp/grpc/include/openssl/seed.h
@@ -33,81 +33,66 @@
  */
 
 #ifndef OPENSSL_SEED_H
-# define OPENSSL_SEED_H
-# pragma once
+#define OPENSSL_SEED_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_SEED_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_SEED_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_SEED
-#  include <openssl/e_os2.h>
-#  include <openssl/crypto.h>
-#  include <sys/types.h>
+#ifndef OPENSSL_NO_SEED
+#include <openssl/e_os2.h>
+#include <openssl/crypto.h>
+#include <sys/types.h>
 
-#  ifdef  __cplusplus
-extern "C" {
-#  endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-#  define SEED_BLOCK_SIZE 16
-#  define SEED_KEY_LENGTH 16
+#define SEED_BLOCK_SIZE 16
+#define SEED_KEY_LENGTH 16
 
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 /* look whether we need 'long' to get 32 bits */
-#   ifdef AES_LONG
-#    ifndef SEED_LONG
-#     define SEED_LONG 1
-#    endif
-#   endif
-
+#ifdef AES_LONG
+#ifndef SEED_LONG
+#define SEED_LONG 1
+#endif
+#endif
 
-typedef struct seed_key_st {
-#   ifdef SEED_LONG
-    unsigned long data[32];
-#   else
-    unsigned int data[32];
-#   endif
-} SEED_KEY_SCHEDULE;
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH],
-                  SEED_KEY_SCHEDULE *ks);
-OSSL_DEPRECATEDIN_3_0
-void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE],
-                  unsigned char d[SEED_BLOCK_SIZE],
-                  const SEED_KEY_SCHEDULE *ks);
-OSSL_DEPRECATEDIN_3_0
-void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE],
-                  unsigned char d[SEED_BLOCK_SIZE],
-                  const SEED_KEY_SCHEDULE *ks);
-OSSL_DEPRECATEDIN_3_0
-void SEED_ecb_encrypt(const unsigned char *in,
-                      unsigned char *out,
-                      const SEED_KEY_SCHEDULE *ks, int enc);
-OSSL_DEPRECATEDIN_3_0
-void SEED_cbc_encrypt(const unsigned char *in, unsigned char *out, size_t len,
-                      const SEED_KEY_SCHEDULE *ks,
-                      unsigned char ivec[SEED_BLOCK_SIZE],
-                      int enc);
-OSSL_DEPRECATEDIN_3_0
-void SEED_cfb128_encrypt(const unsigned char *in, unsigned char *out,
-                         size_t len, const SEED_KEY_SCHEDULE *ks,
-                         unsigned char ivec[SEED_BLOCK_SIZE],
-                         int *num, int enc);
-OSSL_DEPRECATEDIN_3_0
-void SEED_ofb128_encrypt(const unsigned char *in, unsigned char *out,
-                         size_t len, const SEED_KEY_SCHEDULE *ks,
-                         unsigned char ivec[SEED_BLOCK_SIZE],
-                         int *num);
-#  endif
+    typedef struct seed_key_st
+    {
+#ifdef SEED_LONG
+        unsigned long data[32];
+#else
+        unsigned int data[32];
+#endif
+    } SEED_KEY_SCHEDULE;
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH], SEED_KEY_SCHEDULE* ks);
+    OSSL_DEPRECATEDIN_3_0
+    void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE], unsigned char d[SEED_BLOCK_SIZE], const SEED_KEY_SCHEDULE* ks);
+    OSSL_DEPRECATEDIN_3_0
+    void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE], unsigned char d[SEED_BLOCK_SIZE], const SEED_KEY_SCHEDULE* ks);
+    OSSL_DEPRECATEDIN_3_0
+    void SEED_ecb_encrypt(const unsigned char* in, unsigned char* out, const SEED_KEY_SCHEDULE* ks, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void SEED_cbc_encrypt(const unsigned char* in, unsigned char* out, size_t len, const SEED_KEY_SCHEDULE* ks, unsigned char ivec[SEED_BLOCK_SIZE], int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void SEED_cfb128_encrypt(const unsigned char* in, unsigned char* out, size_t len, const SEED_KEY_SCHEDULE* ks, unsigned char ivec[SEED_BLOCK_SIZE], int* num, int enc);
+    OSSL_DEPRECATEDIN_3_0
+    void SEED_ofb128_encrypt(const unsigned char* in, unsigned char* out, size_t len, const SEED_KEY_SCHEDULE* ks, unsigned char ivec[SEED_BLOCK_SIZE], int* num);
+#endif
 
-#  ifdef  __cplusplus
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/self_test.h b/CAPI/cpp/grpc/include/openssl/self_test.h
index ee4949e..fae1c4a 100644
--- a/CAPI/cpp/grpc/include/openssl/self_test.h
+++ b/CAPI/cpp/grpc/include/openssl/self_test.h
@@ -8,85 +8,83 @@
  */
 
 #ifndef OPENSSL_SELF_TEST_H
-# define OPENSSL_SELF_TEST_H
-# pragma once
+#define OPENSSL_SELF_TEST_H
+#pragma once
 
-# include <openssl/core.h> /* OSSL_CALLBACK */
+#include <openssl/core.h> /* OSSL_CALLBACK */
 
-# ifdef __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /* The test event phases */
-# define OSSL_SELF_TEST_PHASE_NONE     "None"
-# define OSSL_SELF_TEST_PHASE_START    "Start"
-# define OSSL_SELF_TEST_PHASE_CORRUPT  "Corrupt"
-# define OSSL_SELF_TEST_PHASE_PASS     "Pass"
-# define OSSL_SELF_TEST_PHASE_FAIL     "Fail"
+#define OSSL_SELF_TEST_PHASE_NONE "None"
+#define OSSL_SELF_TEST_PHASE_START "Start"
+#define OSSL_SELF_TEST_PHASE_CORRUPT "Corrupt"
+#define OSSL_SELF_TEST_PHASE_PASS "Pass"
+#define OSSL_SELF_TEST_PHASE_FAIL "Fail"
 
 /* Test event categories */
-# define OSSL_SELF_TEST_TYPE_NONE               "None"
-# define OSSL_SELF_TEST_TYPE_MODULE_INTEGRITY   "Module_Integrity"
-# define OSSL_SELF_TEST_TYPE_INSTALL_INTEGRITY  "Install_Integrity"
-# define OSSL_SELF_TEST_TYPE_CRNG               "Continuous_RNG_Test"
-# define OSSL_SELF_TEST_TYPE_PCT                "Conditional_PCT"
-# define OSSL_SELF_TEST_TYPE_KAT_CIPHER         "KAT_Cipher"
-# define OSSL_SELF_TEST_TYPE_KAT_ASYM_CIPHER    "KAT_AsymmetricCipher"
-# define OSSL_SELF_TEST_TYPE_KAT_DIGEST         "KAT_Digest"
-# define OSSL_SELF_TEST_TYPE_KAT_SIGNATURE      "KAT_Signature"
-# define OSSL_SELF_TEST_TYPE_PCT_SIGNATURE      "PCT_Signature"
-# define OSSL_SELF_TEST_TYPE_KAT_KDF            "KAT_KDF"
-# define OSSL_SELF_TEST_TYPE_KAT_KA             "KAT_KA"
-# define OSSL_SELF_TEST_TYPE_DRBG               "DRBG"
+#define OSSL_SELF_TEST_TYPE_NONE "None"
+#define OSSL_SELF_TEST_TYPE_MODULE_INTEGRITY "Module_Integrity"
+#define OSSL_SELF_TEST_TYPE_INSTALL_INTEGRITY "Install_Integrity"
+#define OSSL_SELF_TEST_TYPE_CRNG "Continuous_RNG_Test"
+#define OSSL_SELF_TEST_TYPE_PCT "Conditional_PCT"
+#define OSSL_SELF_TEST_TYPE_KAT_CIPHER "KAT_Cipher"
+#define OSSL_SELF_TEST_TYPE_KAT_ASYM_CIPHER "KAT_AsymmetricCipher"
+#define OSSL_SELF_TEST_TYPE_KAT_DIGEST "KAT_Digest"
+#define OSSL_SELF_TEST_TYPE_KAT_SIGNATURE "KAT_Signature"
+#define OSSL_SELF_TEST_TYPE_PCT_SIGNATURE "PCT_Signature"
+#define OSSL_SELF_TEST_TYPE_KAT_KDF "KAT_KDF"
+#define OSSL_SELF_TEST_TYPE_KAT_KA "KAT_KA"
+#define OSSL_SELF_TEST_TYPE_DRBG "DRBG"
 
 /* Test event sub categories */
-# define OSSL_SELF_TEST_DESC_NONE           "None"
-# define OSSL_SELF_TEST_DESC_INTEGRITY_HMAC "HMAC"
-# define OSSL_SELF_TEST_DESC_PCT_RSA_PKCS1  "RSA"
-# define OSSL_SELF_TEST_DESC_PCT_ECDSA      "ECDSA"
-# define OSSL_SELF_TEST_DESC_PCT_DSA        "DSA"
-# define OSSL_SELF_TEST_DESC_CIPHER_AES_GCM "AES_GCM"
-# define OSSL_SELF_TEST_DESC_CIPHER_AES_ECB "AES_ECB_Decrypt"
-# define OSSL_SELF_TEST_DESC_CIPHER_TDES    "TDES"
-# define OSSL_SELF_TEST_DESC_ASYM_RSA_ENC   "RSA_Encrypt"
-# define OSSL_SELF_TEST_DESC_ASYM_RSA_DEC   "RSA_Decrypt"
-# define OSSL_SELF_TEST_DESC_MD_SHA1        "SHA1"
-# define OSSL_SELF_TEST_DESC_MD_SHA2        "SHA2"
-# define OSSL_SELF_TEST_DESC_MD_SHA3        "SHA3"
-# define OSSL_SELF_TEST_DESC_SIGN_DSA       "DSA"
-# define OSSL_SELF_TEST_DESC_SIGN_RSA       "RSA"
-# define OSSL_SELF_TEST_DESC_SIGN_ECDSA     "ECDSA"
-# define OSSL_SELF_TEST_DESC_DRBG_CTR       "CTR"
-# define OSSL_SELF_TEST_DESC_DRBG_HASH      "HASH"
-# define OSSL_SELF_TEST_DESC_DRBG_HMAC      "HMAC"
-# define OSSL_SELF_TEST_DESC_KA_DH          "DH"
-# define OSSL_SELF_TEST_DESC_KA_ECDH        "ECDH"
-# define OSSL_SELF_TEST_DESC_KDF_HKDF       "HKDF"
-# define OSSL_SELF_TEST_DESC_KDF_SSKDF      "SSKDF"
-# define OSSL_SELF_TEST_DESC_KDF_X963KDF    "X963KDF"
-# define OSSL_SELF_TEST_DESC_KDF_X942KDF    "X942KDF"
-# define OSSL_SELF_TEST_DESC_KDF_PBKDF2     "PBKDF2"
-# define OSSL_SELF_TEST_DESC_KDF_SSHKDF     "SSHKDF"
-# define OSSL_SELF_TEST_DESC_KDF_TLS12_PRF  "TLS12_PRF"
-# define OSSL_SELF_TEST_DESC_KDF_KBKDF      "KBKDF"
-# define OSSL_SELF_TEST_DESC_KDF_TLS13_EXTRACT  "TLS13_KDF_EXTRACT"
-# define OSSL_SELF_TEST_DESC_KDF_TLS13_EXPAND   "TLS13_KDF_EXPAND"
-# define OSSL_SELF_TEST_DESC_RNG            "RNG"
+#define OSSL_SELF_TEST_DESC_NONE "None"
+#define OSSL_SELF_TEST_DESC_INTEGRITY_HMAC "HMAC"
+#define OSSL_SELF_TEST_DESC_PCT_RSA_PKCS1 "RSA"
+#define OSSL_SELF_TEST_DESC_PCT_ECDSA "ECDSA"
+#define OSSL_SELF_TEST_DESC_PCT_DSA "DSA"
+#define OSSL_SELF_TEST_DESC_CIPHER_AES_GCM "AES_GCM"
+#define OSSL_SELF_TEST_DESC_CIPHER_AES_ECB "AES_ECB_Decrypt"
+#define OSSL_SELF_TEST_DESC_CIPHER_TDES "TDES"
+#define OSSL_SELF_TEST_DESC_ASYM_RSA_ENC "RSA_Encrypt"
+#define OSSL_SELF_TEST_DESC_ASYM_RSA_DEC "RSA_Decrypt"
+#define OSSL_SELF_TEST_DESC_MD_SHA1 "SHA1"
+#define OSSL_SELF_TEST_DESC_MD_SHA2 "SHA2"
+#define OSSL_SELF_TEST_DESC_MD_SHA3 "SHA3"
+#define OSSL_SELF_TEST_DESC_SIGN_DSA "DSA"
+#define OSSL_SELF_TEST_DESC_SIGN_RSA "RSA"
+#define OSSL_SELF_TEST_DESC_SIGN_ECDSA "ECDSA"
+#define OSSL_SELF_TEST_DESC_DRBG_CTR "CTR"
+#define OSSL_SELF_TEST_DESC_DRBG_HASH "HASH"
+#define OSSL_SELF_TEST_DESC_DRBG_HMAC "HMAC"
+#define OSSL_SELF_TEST_DESC_KA_DH "DH"
+#define OSSL_SELF_TEST_DESC_KA_ECDH "ECDH"
+#define OSSL_SELF_TEST_DESC_KDF_HKDF "HKDF"
+#define OSSL_SELF_TEST_DESC_KDF_SSKDF "SSKDF"
+#define OSSL_SELF_TEST_DESC_KDF_X963KDF "X963KDF"
+#define OSSL_SELF_TEST_DESC_KDF_X942KDF "X942KDF"
+#define OSSL_SELF_TEST_DESC_KDF_PBKDF2 "PBKDF2"
+#define OSSL_SELF_TEST_DESC_KDF_SSHKDF "SSHKDF"
+#define OSSL_SELF_TEST_DESC_KDF_TLS12_PRF "TLS12_PRF"
+#define OSSL_SELF_TEST_DESC_KDF_KBKDF "KBKDF"
+#define OSSL_SELF_TEST_DESC_KDF_TLS13_EXTRACT "TLS13_KDF_EXTRACT"
+#define OSSL_SELF_TEST_DESC_KDF_TLS13_EXPAND "TLS13_KDF_EXPAND"
+#define OSSL_SELF_TEST_DESC_RNG "RNG"
 
-void OSSL_SELF_TEST_set_callback(OSSL_LIB_CTX *libctx, OSSL_CALLBACK *cb,
-                                 void *cbarg);
-void OSSL_SELF_TEST_get_callback(OSSL_LIB_CTX *libctx, OSSL_CALLBACK **cb,
-                                 void **cbarg);
+    void OSSL_SELF_TEST_set_callback(OSSL_LIB_CTX* libctx, OSSL_CALLBACK* cb, void* cbarg);
+    void OSSL_SELF_TEST_get_callback(OSSL_LIB_CTX* libctx, OSSL_CALLBACK** cb, void** cbarg);
 
-OSSL_SELF_TEST *OSSL_SELF_TEST_new(OSSL_CALLBACK *cb, void *cbarg);
-void OSSL_SELF_TEST_free(OSSL_SELF_TEST *st);
+    OSSL_SELF_TEST* OSSL_SELF_TEST_new(OSSL_CALLBACK* cb, void* cbarg);
+    void OSSL_SELF_TEST_free(OSSL_SELF_TEST* st);
 
-void OSSL_SELF_TEST_onbegin(OSSL_SELF_TEST *st, const char *type,
-                            const char *desc);
-int OSSL_SELF_TEST_oncorrupt_byte(OSSL_SELF_TEST *st, unsigned char *bytes);
-void OSSL_SELF_TEST_onend(OSSL_SELF_TEST *st, int ret);
+    void OSSL_SELF_TEST_onbegin(OSSL_SELF_TEST* st, const char* type, const char* desc);
+    int OSSL_SELF_TEST_oncorrupt_byte(OSSL_SELF_TEST* st, unsigned char* bytes);
+    void OSSL_SELF_TEST_onend(OSSL_SELF_TEST* st, int ret);
 
-# ifdef __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif /* OPENSSL_SELF_TEST_H */
diff --git a/CAPI/cpp/grpc/include/openssl/sha.h b/CAPI/cpp/grpc/include/openssl/sha.h
index 6e65a04..c49d12a 100644
--- a/CAPI/cpp/grpc/include/openssl/sha.h
+++ b/CAPI/cpp/grpc/include/openssl/sha.h
@@ -8,85 +8,85 @@
  */
 
 #ifndef OPENSSL_SHA_H
-# define OPENSSL_SHA_H
-# pragma once
+#define OPENSSL_SHA_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_SHA_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_SHA_H
+#endif
 
-# include <openssl/e_os2.h>
-# include <stddef.h>
+#include <openssl/e_os2.h>
+#include <stddef.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# define SHA_DIGEST_LENGTH 20
+#define SHA_DIGEST_LENGTH 20
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 /*-
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  * ! SHA_LONG has to be at least 32 bits wide.                    !
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  */
-#  define SHA_LONG unsigned int
-
-#  define SHA_LBLOCK      16
-#  define SHA_CBLOCK      (SHA_LBLOCK*4)/* SHA treats input data as a
-                                         * contiguous array of 32 bit wide
-                                         * big-endian values. */
-#  define SHA_LAST_BLOCK  (SHA_CBLOCK-8)
-
-typedef struct SHAstate_st {
-    SHA_LONG h0, h1, h2, h3, h4;
-    SHA_LONG Nl, Nh;
-    SHA_LONG data[SHA_LBLOCK];
-    unsigned int num;
-} SHA_CTX;
-
-OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
-OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char *md, SHA_CTX *c);
-OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
-# endif
-
-unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SHA256_CBLOCK   (SHA_LBLOCK*4)/* SHA-256 treats input data as a
-                                        * contiguous array of 32 bit wide
+#define SHA_LONG unsigned int
+
+#define SHA_LBLOCK 16
+#define SHA_CBLOCK (SHA_LBLOCK * 4) /* SHA treats input data as a      \
+                                     * contiguous array of 32 bit wide \
+                                     * big-endian values. */
+#define SHA_LAST_BLOCK (SHA_CBLOCK - 8)
+
+    typedef struct SHAstate_st
+    {
+        SHA_LONG h0, h1, h2, h3, h4;
+        SHA_LONG Nl, Nh;
+        SHA_LONG data[SHA_LBLOCK];
+        unsigned int num;
+    } SHA_CTX;
+
+    OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX* c, const void* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char* md, SHA_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX* c, const unsigned char* data);
+#endif
+
+    unsigned char* SHA1(const unsigned char* d, size_t n, unsigned char* md);
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SHA256_CBLOCK (SHA_LBLOCK * 4) /* SHA-256 treats input data as a  \
+                                        * contiguous array of 32 bit wide \
                                         * big-endian values. */
 
-typedef struct SHA256state_st {
-    SHA_LONG h[8];
-    SHA_LONG Nl, Nh;
-    SHA_LONG data[SHA_LBLOCK];
-    unsigned int num, md_len;
-} SHA256_CTX;
-
-OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c,
-                                        const void *data, size_t len);
-OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c,
-                                        const void *data, size_t len);
-OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
-OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c,
-                                            const unsigned char *data);
-# endif
-
-unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
-unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
-
-# define SHA224_DIGEST_LENGTH    28
-# define SHA256_DIGEST_LENGTH    32
-# define SHA384_DIGEST_LENGTH    48
-# define SHA512_DIGEST_LENGTH    64
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef struct SHA256state_st
+    {
+        SHA_LONG h[8];
+        SHA_LONG Nl, Nh;
+        SHA_LONG data[SHA_LBLOCK];
+        unsigned int num, md_len;
+    } SHA256_CTX;
+
+    OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX* c, const void* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char* md, SHA256_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX* c, const void* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char* md, SHA256_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX* c, const unsigned char* data);
+#endif
+
+    unsigned char* SHA224(const unsigned char* d, size_t n, unsigned char* md);
+    unsigned char* SHA256(const unsigned char* d, size_t n, unsigned char* md);
+
+#define SHA224_DIGEST_LENGTH 28
+#define SHA256_DIGEST_LENGTH 32
+#define SHA384_DIGEST_LENGTH 48
+#define SHA512_DIGEST_LENGTH 64
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 /*
  * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64
  * being exactly 64-bit wide. See Implementation Notes in sha512.c
@@ -97,42 +97,41 @@ unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
  * contiguous array of 64 bit
  * wide big-endian values.
  */
-#  define SHA512_CBLOCK   (SHA_LBLOCK*8)
-#  if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
-#   define SHA_LONG64 unsigned __int64
-#  elif defined(__arch64__)
-#   define SHA_LONG64 unsigned long
-#  else
-#   define SHA_LONG64 unsigned long long
-#  endif
-
-typedef struct SHA512state_st {
-    SHA_LONG64 h[8];
-    SHA_LONG64 Nl, Nh;
-    union {
-        SHA_LONG64 d[SHA_LBLOCK];
-        unsigned char p[SHA512_CBLOCK];
-    } u;
-    unsigned int num, md_len;
-} SHA512_CTX;
-
-OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c,
-                                        const void *data, size_t len);
-OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX *c,
-                                        const void *data, size_t len);
-OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char *md, SHA512_CTX *c);
-OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c,
-                                            const unsigned char *data);
-# endif
-
-unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
-unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
-
-# ifdef  __cplusplus
+#define SHA512_CBLOCK (SHA_LBLOCK * 8)
+#if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
+#define SHA_LONG64 unsigned __int64
+#elif defined(__arch64__)
+#define SHA_LONG64 unsigned long
+#else
+#define SHA_LONG64 unsigned long long
+#endif
+
+    typedef struct SHA512state_st
+    {
+        SHA_LONG64 h[8];
+        SHA_LONG64 Nl, Nh;
+        union
+        {
+            SHA_LONG64 d[SHA_LBLOCK];
+            unsigned char p[SHA512_CBLOCK];
+        } u;
+        unsigned int num, md_len;
+    } SHA512_CTX;
+
+    OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX* c, const void* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char* md, SHA512_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX* c, const void* data, size_t len);
+    OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char* md, SHA512_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX* c, const unsigned char* data);
+#endif
+
+    unsigned char* SHA384(const unsigned char* d, size_t n, unsigned char* md);
+    unsigned char* SHA512(const unsigned char* d, size_t n, unsigned char* md);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/srp.h b/CAPI/cpp/grpc/include/openssl/srp.h
index a86fa5d..9286955 100644
--- a/CAPI/cpp/grpc/include/openssl/srp.h
+++ b/CAPI/cpp/grpc/include/openssl/srp.h
@@ -14,272 +14,252 @@
  * for the EdelKey project.
  */
 
-
-
 #ifndef OPENSSL_SRP_H
-# define OPENSSL_SRP_H
-# pragma once
+#define OPENSSL_SRP_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_SRP_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_SRP_H
+#endif
 
 #include <openssl/opensslconf.h>
 
 #ifndef OPENSSL_NO_SRP
-# include <stdio.h>
-# include <string.h>
-# include <openssl/safestack.h>
-# include <openssl/bn.h>
-# include <openssl/crypto.h>
-
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#include <stdio.h>
+#include <string.h>
+#include <openssl/safestack.h>
+#include <openssl/bn.h>
+#include <openssl/crypto.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 
-typedef struct SRP_gN_cache_st {
-    char *b64_bn;
-    BIGNUM *bn;
-} SRP_gN_cache;
-SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN_cache, SRP_gN_cache, SRP_gN_cache)
+    typedef struct SRP_gN_cache_st
+    {
+        char* b64_bn;
+        BIGNUM* bn;
+    } SRP_gN_cache;
+    SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN_cache, SRP_gN_cache, SRP_gN_cache)
 #define sk_SRP_gN_cache_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_cache_sk_type(sk))
-#define sk_SRP_gN_cache_value(sk, idx) ((SRP_gN_cache *)OPENSSL_sk_value(ossl_check_const_SRP_gN_cache_sk_type(sk), (idx)))
-#define sk_SRP_gN_cache_new(cmp) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new(ossl_check_SRP_gN_cache_compfunc_type(cmp)))
-#define sk_SRP_gN_cache_new_null() ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new_null())
-#define sk_SRP_gN_cache_new_reserve(cmp, n) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_cache_compfunc_type(cmp), (n)))
+#define sk_SRP_gN_cache_value(sk, idx) ((SRP_gN_cache*)OPENSSL_sk_value(ossl_check_const_SRP_gN_cache_sk_type(sk), (idx)))
+#define sk_SRP_gN_cache_new(cmp) ((STACK_OF(SRP_gN_cache)*)OPENSSL_sk_new(ossl_check_SRP_gN_cache_compfunc_type(cmp)))
+#define sk_SRP_gN_cache_new_null() ((STACK_OF(SRP_gN_cache)*)OPENSSL_sk_new_null())
+#define sk_SRP_gN_cache_new_reserve(cmp, n) ((STACK_OF(SRP_gN_cache)*)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_cache_compfunc_type(cmp), (n)))
 #define sk_SRP_gN_cache_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_cache_sk_type(sk), (n))
 #define sk_SRP_gN_cache_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_cache_sk_type(sk))
 #define sk_SRP_gN_cache_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_cache_sk_type(sk))
-#define sk_SRP_gN_cache_delete(sk, i) ((SRP_gN_cache *)OPENSSL_sk_delete(ossl_check_SRP_gN_cache_sk_type(sk), (i)))
-#define sk_SRP_gN_cache_delete_ptr(sk, ptr) ((SRP_gN_cache *)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr)))
+#define sk_SRP_gN_cache_delete(sk, i) ((SRP_gN_cache*)OPENSSL_sk_delete(ossl_check_SRP_gN_cache_sk_type(sk), (i)))
+#define sk_SRP_gN_cache_delete_ptr(sk, ptr) ((SRP_gN_cache*)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr)))
 #define sk_SRP_gN_cache_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
 #define sk_SRP_gN_cache_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
-#define sk_SRP_gN_cache_pop(sk) ((SRP_gN_cache *)OPENSSL_sk_pop(ossl_check_SRP_gN_cache_sk_type(sk)))
-#define sk_SRP_gN_cache_shift(sk) ((SRP_gN_cache *)OPENSSL_sk_shift(ossl_check_SRP_gN_cache_sk_type(sk)))
-#define sk_SRP_gN_cache_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_cache_sk_type(sk),ossl_check_SRP_gN_cache_freefunc_type(freefunc))
+#define sk_SRP_gN_cache_pop(sk) ((SRP_gN_cache*)OPENSSL_sk_pop(ossl_check_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_shift(sk) ((SRP_gN_cache*)OPENSSL_sk_shift(ossl_check_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_freefunc_type(freefunc))
 #define sk_SRP_gN_cache_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), (idx))
-#define sk_SRP_gN_cache_set(sk, idx, ptr) ((SRP_gN_cache *)OPENSSL_sk_set(ossl_check_SRP_gN_cache_sk_type(sk), (idx), ossl_check_SRP_gN_cache_type(ptr)))
+#define sk_SRP_gN_cache_set(sk, idx, ptr) ((SRP_gN_cache*)OPENSSL_sk_set(ossl_check_SRP_gN_cache_sk_type(sk), (idx), ossl_check_SRP_gN_cache_type(ptr)))
 #define sk_SRP_gN_cache_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
 #define sk_SRP_gN_cache_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
 #define sk_SRP_gN_cache_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), pnum)
 #define sk_SRP_gN_cache_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_cache_sk_type(sk))
 #define sk_SRP_gN_cache_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_cache_sk_type(sk))
-#define sk_SRP_gN_cache_dup(sk) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_cache_sk_type(sk)))
-#define sk_SRP_gN_cache_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_copyfunc_type(copyfunc), ossl_check_SRP_gN_cache_freefunc_type(freefunc)))
+#define sk_SRP_gN_cache_dup(sk) ((STACK_OF(SRP_gN_cache)*)OPENSSL_sk_dup(ossl_check_const_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN_cache)*)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_copyfunc_type(copyfunc), ossl_check_SRP_gN_cache_freefunc_type(freefunc)))
 #define sk_SRP_gN_cache_set_cmp_func(sk, cmp) ((sk_SRP_gN_cache_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_compfunc_type(cmp)))
 
-
-
-typedef struct SRP_user_pwd_st {
-    /* Owned by us. */
-    char *id;
-    BIGNUM *s;
-    BIGNUM *v;
-    /* Not owned by us. */
-    const BIGNUM *g;
-    const BIGNUM *N;
-    /* Owned by us. */
-    char *info;
-} SRP_user_pwd;
-SKM_DEFINE_STACK_OF_INTERNAL(SRP_user_pwd, SRP_user_pwd, SRP_user_pwd)
+    typedef struct SRP_user_pwd_st
+    {
+        /* Owned by us. */
+        char* id;
+        BIGNUM* s;
+        BIGNUM* v;
+        /* Not owned by us. */
+        const BIGNUM* g;
+        const BIGNUM* N;
+        /* Owned by us. */
+        char* info;
+    } SRP_user_pwd;
+    SKM_DEFINE_STACK_OF_INTERNAL(SRP_user_pwd, SRP_user_pwd, SRP_user_pwd)
 #define sk_SRP_user_pwd_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_user_pwd_sk_type(sk))
-#define sk_SRP_user_pwd_value(sk, idx) ((SRP_user_pwd *)OPENSSL_sk_value(ossl_check_const_SRP_user_pwd_sk_type(sk), (idx)))
-#define sk_SRP_user_pwd_new(cmp) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new(ossl_check_SRP_user_pwd_compfunc_type(cmp)))
-#define sk_SRP_user_pwd_new_null() ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new_null())
-#define sk_SRP_user_pwd_new_reserve(cmp, n) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new_reserve(ossl_check_SRP_user_pwd_compfunc_type(cmp), (n)))
+#define sk_SRP_user_pwd_value(sk, idx) ((SRP_user_pwd*)OPENSSL_sk_value(ossl_check_const_SRP_user_pwd_sk_type(sk), (idx)))
+#define sk_SRP_user_pwd_new(cmp) ((STACK_OF(SRP_user_pwd)*)OPENSSL_sk_new(ossl_check_SRP_user_pwd_compfunc_type(cmp)))
+#define sk_SRP_user_pwd_new_null() ((STACK_OF(SRP_user_pwd)*)OPENSSL_sk_new_null())
+#define sk_SRP_user_pwd_new_reserve(cmp, n) ((STACK_OF(SRP_user_pwd)*)OPENSSL_sk_new_reserve(ossl_check_SRP_user_pwd_compfunc_type(cmp), (n)))
 #define sk_SRP_user_pwd_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_user_pwd_sk_type(sk), (n))
 #define sk_SRP_user_pwd_free(sk) OPENSSL_sk_free(ossl_check_SRP_user_pwd_sk_type(sk))
 #define sk_SRP_user_pwd_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_user_pwd_sk_type(sk))
-#define sk_SRP_user_pwd_delete(sk, i) ((SRP_user_pwd *)OPENSSL_sk_delete(ossl_check_SRP_user_pwd_sk_type(sk), (i)))
-#define sk_SRP_user_pwd_delete_ptr(sk, ptr) ((SRP_user_pwd *)OPENSSL_sk_delete_ptr(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr)))
+#define sk_SRP_user_pwd_delete(sk, i) ((SRP_user_pwd*)OPENSSL_sk_delete(ossl_check_SRP_user_pwd_sk_type(sk), (i)))
+#define sk_SRP_user_pwd_delete_ptr(sk, ptr) ((SRP_user_pwd*)OPENSSL_sk_delete_ptr(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr)))
 #define sk_SRP_user_pwd_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
 #define sk_SRP_user_pwd_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
-#define sk_SRP_user_pwd_pop(sk) ((SRP_user_pwd *)OPENSSL_sk_pop(ossl_check_SRP_user_pwd_sk_type(sk)))
-#define sk_SRP_user_pwd_shift(sk) ((SRP_user_pwd *)OPENSSL_sk_shift(ossl_check_SRP_user_pwd_sk_type(sk)))
-#define sk_SRP_user_pwd_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_user_pwd_sk_type(sk),ossl_check_SRP_user_pwd_freefunc_type(freefunc))
+#define sk_SRP_user_pwd_pop(sk) ((SRP_user_pwd*)OPENSSL_sk_pop(ossl_check_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_shift(sk) ((SRP_user_pwd*)OPENSSL_sk_shift(ossl_check_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_freefunc_type(freefunc))
 #define sk_SRP_user_pwd_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), (idx))
-#define sk_SRP_user_pwd_set(sk, idx, ptr) ((SRP_user_pwd *)OPENSSL_sk_set(ossl_check_SRP_user_pwd_sk_type(sk), (idx), ossl_check_SRP_user_pwd_type(ptr)))
+#define sk_SRP_user_pwd_set(sk, idx, ptr) ((SRP_user_pwd*)OPENSSL_sk_set(ossl_check_SRP_user_pwd_sk_type(sk), (idx), ossl_check_SRP_user_pwd_type(ptr)))
 #define sk_SRP_user_pwd_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
 #define sk_SRP_user_pwd_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
 #define sk_SRP_user_pwd_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), pnum)
 #define sk_SRP_user_pwd_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_user_pwd_sk_type(sk))
 #define sk_SRP_user_pwd_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_user_pwd_sk_type(sk))
-#define sk_SRP_user_pwd_dup(sk) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_dup(ossl_check_const_SRP_user_pwd_sk_type(sk)))
-#define sk_SRP_user_pwd_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_copyfunc_type(copyfunc), ossl_check_SRP_user_pwd_freefunc_type(freefunc)))
+#define sk_SRP_user_pwd_dup(sk) ((STACK_OF(SRP_user_pwd)*)OPENSSL_sk_dup(ossl_check_const_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_user_pwd)*)OPENSSL_sk_deep_copy(ossl_check_const_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_copyfunc_type(copyfunc), ossl_check_SRP_user_pwd_freefunc_type(freefunc)))
 #define sk_SRP_user_pwd_set_cmp_func(sk, cmp) ((sk_SRP_user_pwd_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_compfunc_type(cmp)))
 
-
-OSSL_DEPRECATEDIN_3_0
-SRP_user_pwd *SRP_user_pwd_new(void);
-OSSL_DEPRECATEDIN_3_0
-void SRP_user_pwd_free(SRP_user_pwd *user_pwd);
-
-OSSL_DEPRECATEDIN_3_0
-void SRP_user_pwd_set_gN(SRP_user_pwd *user_pwd, const BIGNUM *g,
-                         const BIGNUM *N);
-OSSL_DEPRECATEDIN_3_0
-int SRP_user_pwd_set1_ids(SRP_user_pwd *user_pwd, const char *id,
-                          const char *info);
-OSSL_DEPRECATEDIN_3_0
-int SRP_user_pwd_set0_sv(SRP_user_pwd *user_pwd, BIGNUM *s, BIGNUM *v);
-
-typedef struct SRP_VBASE_st {
-    STACK_OF(SRP_user_pwd) *users_pwd;
-    STACK_OF(SRP_gN_cache) *gN_cache;
-/* to simulate a user */
-    char *seed_key;
-    const BIGNUM *default_g;
-    const BIGNUM *default_N;
-} SRP_VBASE;
-
-/*
- * Internal structure storing N and g pair
- */
-typedef struct SRP_gN_st {
-    char *id;
-    const BIGNUM *g;
-    const BIGNUM *N;
-} SRP_gN;
-SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN, SRP_gN, SRP_gN)
+    OSSL_DEPRECATEDIN_3_0
+    SRP_user_pwd* SRP_user_pwd_new(void);
+    OSSL_DEPRECATEDIN_3_0
+    void SRP_user_pwd_free(SRP_user_pwd* user_pwd);
+
+    OSSL_DEPRECATEDIN_3_0
+    void SRP_user_pwd_set_gN(SRP_user_pwd* user_pwd, const BIGNUM* g, const BIGNUM* N);
+    OSSL_DEPRECATEDIN_3_0
+    int SRP_user_pwd_set1_ids(SRP_user_pwd* user_pwd, const char* id, const char* info);
+    OSSL_DEPRECATEDIN_3_0
+    int SRP_user_pwd_set0_sv(SRP_user_pwd* user_pwd, BIGNUM* s, BIGNUM* v);
+
+    typedef struct SRP_VBASE_st
+    {
+        STACK_OF(SRP_user_pwd) * users_pwd;
+        STACK_OF(SRP_gN_cache) * gN_cache;
+        /* to simulate a user */
+        char* seed_key;
+        const BIGNUM* default_g;
+        const BIGNUM* default_N;
+    } SRP_VBASE;
+
+    /*
+     * Internal structure storing N and g pair
+     */
+    typedef struct SRP_gN_st
+    {
+        char* id;
+        const BIGNUM* g;
+        const BIGNUM* N;
+    } SRP_gN;
+    SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN, SRP_gN, SRP_gN)
 #define sk_SRP_gN_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_sk_type(sk))
-#define sk_SRP_gN_value(sk, idx) ((SRP_gN *)OPENSSL_sk_value(ossl_check_const_SRP_gN_sk_type(sk), (idx)))
-#define sk_SRP_gN_new(cmp) ((STACK_OF(SRP_gN) *)OPENSSL_sk_new(ossl_check_SRP_gN_compfunc_type(cmp)))
-#define sk_SRP_gN_new_null() ((STACK_OF(SRP_gN) *)OPENSSL_sk_new_null())
-#define sk_SRP_gN_new_reserve(cmp, n) ((STACK_OF(SRP_gN) *)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_compfunc_type(cmp), (n)))
+#define sk_SRP_gN_value(sk, idx) ((SRP_gN*)OPENSSL_sk_value(ossl_check_const_SRP_gN_sk_type(sk), (idx)))
+#define sk_SRP_gN_new(cmp) ((STACK_OF(SRP_gN)*)OPENSSL_sk_new(ossl_check_SRP_gN_compfunc_type(cmp)))
+#define sk_SRP_gN_new_null() ((STACK_OF(SRP_gN)*)OPENSSL_sk_new_null())
+#define sk_SRP_gN_new_reserve(cmp, n) ((STACK_OF(SRP_gN)*)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_compfunc_type(cmp), (n)))
 #define sk_SRP_gN_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_sk_type(sk), (n))
 #define sk_SRP_gN_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_sk_type(sk))
 #define sk_SRP_gN_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_sk_type(sk))
-#define sk_SRP_gN_delete(sk, i) ((SRP_gN *)OPENSSL_sk_delete(ossl_check_SRP_gN_sk_type(sk), (i)))
-#define sk_SRP_gN_delete_ptr(sk, ptr) ((SRP_gN *)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr)))
+#define sk_SRP_gN_delete(sk, i) ((SRP_gN*)OPENSSL_sk_delete(ossl_check_SRP_gN_sk_type(sk), (i)))
+#define sk_SRP_gN_delete_ptr(sk, ptr) ((SRP_gN*)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr)))
 #define sk_SRP_gN_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
 #define sk_SRP_gN_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
-#define sk_SRP_gN_pop(sk) ((SRP_gN *)OPENSSL_sk_pop(ossl_check_SRP_gN_sk_type(sk)))
-#define sk_SRP_gN_shift(sk) ((SRP_gN *)OPENSSL_sk_shift(ossl_check_SRP_gN_sk_type(sk)))
-#define sk_SRP_gN_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_sk_type(sk),ossl_check_SRP_gN_freefunc_type(freefunc))
+#define sk_SRP_gN_pop(sk) ((SRP_gN*)OPENSSL_sk_pop(ossl_check_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_shift(sk) ((SRP_gN*)OPENSSL_sk_shift(ossl_check_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_freefunc_type(freefunc))
 #define sk_SRP_gN_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), (idx))
-#define sk_SRP_gN_set(sk, idx, ptr) ((SRP_gN *)OPENSSL_sk_set(ossl_check_SRP_gN_sk_type(sk), (idx), ossl_check_SRP_gN_type(ptr)))
+#define sk_SRP_gN_set(sk, idx, ptr) ((SRP_gN*)OPENSSL_sk_set(ossl_check_SRP_gN_sk_type(sk), (idx), ossl_check_SRP_gN_type(ptr)))
 #define sk_SRP_gN_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
 #define sk_SRP_gN_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
 #define sk_SRP_gN_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), pnum)
 #define sk_SRP_gN_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_sk_type(sk))
 #define sk_SRP_gN_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_sk_type(sk))
-#define sk_SRP_gN_dup(sk) ((STACK_OF(SRP_gN) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_sk_type(sk)))
-#define sk_SRP_gN_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_sk_type(sk), ossl_check_SRP_gN_copyfunc_type(copyfunc), ossl_check_SRP_gN_freefunc_type(freefunc)))
+#define sk_SRP_gN_dup(sk) ((STACK_OF(SRP_gN)*)OPENSSL_sk_dup(ossl_check_const_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN)*)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_sk_type(sk), ossl_check_SRP_gN_copyfunc_type(copyfunc), ossl_check_SRP_gN_freefunc_type(freefunc)))
 #define sk_SRP_gN_set_cmp_func(sk, cmp) ((sk_SRP_gN_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_compfunc_type(cmp)))
 
-
-
-OSSL_DEPRECATEDIN_3_0
-SRP_VBASE *SRP_VBASE_new(char *seed_key);
-OSSL_DEPRECATEDIN_3_0
-void SRP_VBASE_free(SRP_VBASE *vb);
-OSSL_DEPRECATEDIN_3_0
-int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file);
-
-OSSL_DEPRECATEDIN_3_0
-int SRP_VBASE_add0_user(SRP_VBASE *vb, SRP_user_pwd *user_pwd);
-
-/* NOTE: unlike in SRP_VBASE_get_by_user, caller owns the returned pointer.*/
-OSSL_DEPRECATEDIN_3_0
-SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username);
-
-OSSL_DEPRECATEDIN_3_0
-char *SRP_create_verifier_ex(const char *user, const char *pass, char **salt,
-                             char **verifier, const char *N, const char *g,
-                             OSSL_LIB_CTX *libctx, const char *propq);
-OSSL_DEPRECATEDIN_3_0
-char *SRP_create_verifier(const char *user, const char *pass, char **salt,
-                          char **verifier, const char *N, const char *g);
-OSSL_DEPRECATEDIN_3_0
-int SRP_create_verifier_BN_ex(const char *user, const char *pass, BIGNUM **salt,
-                              BIGNUM **verifier, const BIGNUM *N,
-                              const BIGNUM *g, OSSL_LIB_CTX *libctx,
-                              const char *propq);
-OSSL_DEPRECATEDIN_3_0
-int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt,
-                           BIGNUM **verifier, const BIGNUM *N,
-                           const BIGNUM *g);
-
-#  define SRP_NO_ERROR 0
-#  define SRP_ERR_VBASE_INCOMPLETE_FILE 1
-#  define SRP_ERR_VBASE_BN_LIB 2
-#  define SRP_ERR_OPEN_FILE 3
-#  define SRP_ERR_MEMORY 4
-
-#  define DB_srptype      0
-#  define DB_srpverifier  1
-#  define DB_srpsalt      2
-#  define DB_srpid        3
-#  define DB_srpgN        4
-#  define DB_srpinfo      5
-#  undef  DB_NUMBER
-#  define DB_NUMBER       6
-
-#  define DB_SRP_INDEX    'I'
-#  define DB_SRP_VALID    'V'
-#  define DB_SRP_REVOKED  'R'
-#  define DB_SRP_MODIF    'v'
-
-/* see srp.c */
-OSSL_DEPRECATEDIN_3_0
-char *SRP_check_known_gN_param(const BIGNUM *g, const BIGNUM *N);
-OSSL_DEPRECATEDIN_3_0
-SRP_gN *SRP_get_default_gN(const char *id);
-
-/* server side .... */
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_server_key(const BIGNUM *A, const BIGNUM *v, const BIGNUM *u,
-                            const BIGNUM *b, const BIGNUM *N);
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_B_ex(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g,
-                      const BIGNUM *v, OSSL_LIB_CTX *libctx, const char *propq);
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_B(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g,
-                   const BIGNUM *v);
-
-OSSL_DEPRECATEDIN_3_0
-int SRP_Verify_A_mod_N(const BIGNUM *A, const BIGNUM *N);
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_u_ex(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N,
-                      OSSL_LIB_CTX *libctx, const char *propq);
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_u(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N);
-
-/* client side .... */
-
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_x_ex(const BIGNUM *s, const char *user, const char *pass,
-                      OSSL_LIB_CTX *libctx, const char *propq);
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_x(const BIGNUM *s, const char *user, const char *pass);
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_A(const BIGNUM *a, const BIGNUM *N, const BIGNUM *g);
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_client_key_ex(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g,
-                            const BIGNUM *x, const BIGNUM *a, const BIGNUM *u,
-                            OSSL_LIB_CTX *libctx, const char *propq);
-OSSL_DEPRECATEDIN_3_0
-BIGNUM *SRP_Calc_client_key(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g,
-                            const BIGNUM *x, const BIGNUM *a, const BIGNUM *u);
-OSSL_DEPRECATEDIN_3_0
-int SRP_Verify_B_mod_N(const BIGNUM *B, const BIGNUM *N);
-
-#  define SRP_MINIMAL_N 1024
-
-# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+    OSSL_DEPRECATEDIN_3_0
+    SRP_VBASE* SRP_VBASE_new(char* seed_key);
+    OSSL_DEPRECATEDIN_3_0
+    void SRP_VBASE_free(SRP_VBASE* vb);
+    OSSL_DEPRECATEDIN_3_0
+    int SRP_VBASE_init(SRP_VBASE* vb, char* verifier_file);
+
+    OSSL_DEPRECATEDIN_3_0
+    int SRP_VBASE_add0_user(SRP_VBASE* vb, SRP_user_pwd* user_pwd);
+
+    /* NOTE: unlike in SRP_VBASE_get_by_user, caller owns the returned pointer.*/
+    OSSL_DEPRECATEDIN_3_0
+    SRP_user_pwd* SRP_VBASE_get1_by_user(SRP_VBASE* vb, char* username);
+
+    OSSL_DEPRECATEDIN_3_0
+    char* SRP_create_verifier_ex(const char* user, const char* pass, char** salt, char** verifier, const char* N, const char* g, OSSL_LIB_CTX* libctx, const char* propq);
+    OSSL_DEPRECATEDIN_3_0
+    char* SRP_create_verifier(const char* user, const char* pass, char** salt, char** verifier, const char* N, const char* g);
+    OSSL_DEPRECATEDIN_3_0
+    int SRP_create_verifier_BN_ex(const char* user, const char* pass, BIGNUM** salt, BIGNUM** verifier, const BIGNUM* N, const BIGNUM* g, OSSL_LIB_CTX* libctx, const char* propq);
+    OSSL_DEPRECATEDIN_3_0
+    int SRP_create_verifier_BN(const char* user, const char* pass, BIGNUM** salt, BIGNUM** verifier, const BIGNUM* N, const BIGNUM* g);
+
+#define SRP_NO_ERROR 0
+#define SRP_ERR_VBASE_INCOMPLETE_FILE 1
+#define SRP_ERR_VBASE_BN_LIB 2
+#define SRP_ERR_OPEN_FILE 3
+#define SRP_ERR_MEMORY 4
+
+#define DB_srptype 0
+#define DB_srpverifier 1
+#define DB_srpsalt 2
+#define DB_srpid 3
+#define DB_srpgN 4
+#define DB_srpinfo 5
+#undef DB_NUMBER
+#define DB_NUMBER 6
+
+#define DB_SRP_INDEX 'I'
+#define DB_SRP_VALID 'V'
+#define DB_SRP_REVOKED 'R'
+#define DB_SRP_MODIF 'v'
+
+    /* see srp.c */
+    OSSL_DEPRECATEDIN_3_0
+    char* SRP_check_known_gN_param(const BIGNUM* g, const BIGNUM* N);
+    OSSL_DEPRECATEDIN_3_0
+    SRP_gN* SRP_get_default_gN(const char* id);
+
+    /* server side .... */
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_server_key(const BIGNUM* A, const BIGNUM* v, const BIGNUM* u, const BIGNUM* b, const BIGNUM* N);
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_B_ex(const BIGNUM* b, const BIGNUM* N, const BIGNUM* g, const BIGNUM* v, OSSL_LIB_CTX* libctx, const char* propq);
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_B(const BIGNUM* b, const BIGNUM* N, const BIGNUM* g, const BIGNUM* v);
+
+    OSSL_DEPRECATEDIN_3_0
+    int SRP_Verify_A_mod_N(const BIGNUM* A, const BIGNUM* N);
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_u_ex(const BIGNUM* A, const BIGNUM* B, const BIGNUM* N, OSSL_LIB_CTX* libctx, const char* propq);
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_u(const BIGNUM* A, const BIGNUM* B, const BIGNUM* N);
+
+    /* client side .... */
+
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_x_ex(const BIGNUM* s, const char* user, const char* pass, OSSL_LIB_CTX* libctx, const char* propq);
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_x(const BIGNUM* s, const char* user, const char* pass);
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_A(const BIGNUM* a, const BIGNUM* N, const BIGNUM* g);
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_client_key_ex(const BIGNUM* N, const BIGNUM* B, const BIGNUM* g, const BIGNUM* x, const BIGNUM* a, const BIGNUM* u, OSSL_LIB_CTX* libctx, const char* propq);
+    OSSL_DEPRECATEDIN_3_0
+    BIGNUM* SRP_Calc_client_key(const BIGNUM* N, const BIGNUM* B, const BIGNUM* g, const BIGNUM* x, const BIGNUM* a, const BIGNUM* u);
+    OSSL_DEPRECATEDIN_3_0
+    int SRP_Verify_B_mod_N(const BIGNUM* B, const BIGNUM* N);
+
+#define SRP_MINIMAL_N 1024
+
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
 
 /* This method ignores the configured seed and fails for an unknown user. */
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0
-SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username);
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0
+    SRP_user_pwd* SRP_VBASE_get_by_user(SRP_VBASE* vb, char* username);
+#endif
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/srtp.h b/CAPI/cpp/grpc/include/openssl/srtp.h
index d64606e..f4a161b 100644
--- a/CAPI/cpp/grpc/include/openssl/srtp.h
+++ b/CAPI/cpp/grpc/include/openssl/srtp.h
@@ -14,42 +14,43 @@
  */
 
 #ifndef OPENSSL_SRTP_H
-# define OPENSSL_SRTP_H
-# pragma once
+#define OPENSSL_SRTP_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_D1_SRTP_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_D1_SRTP_H
+#endif
 
-# include <openssl/ssl.h>
+#include <openssl/ssl.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-# define SRTP_AES128_CM_SHA1_80 0x0001
-# define SRTP_AES128_CM_SHA1_32 0x0002
-# define SRTP_AES128_F8_SHA1_80 0x0003
-# define SRTP_AES128_F8_SHA1_32 0x0004
-# define SRTP_NULL_SHA1_80      0x0005
-# define SRTP_NULL_SHA1_32      0x0006
+#define SRTP_AES128_CM_SHA1_80 0x0001
+#define SRTP_AES128_CM_SHA1_32 0x0002
+#define SRTP_AES128_F8_SHA1_80 0x0003
+#define SRTP_AES128_F8_SHA1_32 0x0004
+#define SRTP_NULL_SHA1_80 0x0005
+#define SRTP_NULL_SHA1_32 0x0006
 
 /* AEAD SRTP protection profiles from RFC 7714 */
-# define SRTP_AEAD_AES_128_GCM  0x0007
-# define SRTP_AEAD_AES_256_GCM  0x0008
+#define SRTP_AEAD_AES_128_GCM 0x0007
+#define SRTP_AEAD_AES_256_GCM 0x0008
 
-# ifndef OPENSSL_NO_SRTP
+#ifndef OPENSSL_NO_SRTP
 
-__owur int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles);
-__owur int SSL_set_tlsext_use_srtp(SSL *ssl, const char *profiles);
+    __owur int SSL_CTX_set_tlsext_use_srtp(SSL_CTX* ctx, const char* profiles);
+    __owur int SSL_set_tlsext_use_srtp(SSL* ssl, const char* profiles);
 
-__owur STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *ssl);
-__owur SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s);
+    __owur STACK_OF(SRTP_PROTECTION_PROFILE) * SSL_get_srtp_profiles(SSL* ssl);
+    __owur SRTP_PROTECTION_PROFILE* SSL_get_selected_srtp_profile(SSL* s);
 
-# endif
+#endif
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/CAPI/cpp/grpc/include/openssl/ssl.h b/CAPI/cpp/grpc/include/openssl/ssl.h
index 441b818..c1f411d 100644
--- a/CAPI/cpp/grpc/include/openssl/ssl.h
+++ b/CAPI/cpp/grpc/include/openssl/ssl.h
@@ -12,39 +12,38 @@
  * https://www.openssl.org/source/license.html
  */
 
+#ifndef OPENSSL_SSL_H
+#define OPENSSL_SSL_H
+#pragma once
 
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_SSL_H
+#endif
 
-#ifndef OPENSSL_SSL_H
-# define OPENSSL_SSL_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_SSL_H
-# endif
-
-# include <openssl/e_os2.h>
-# include <openssl/opensslconf.h>
-# include <openssl/comp.h>
-# include <openssl/bio.h>
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  include <openssl/x509.h>
-#  include <openssl/crypto.h>
-#  include <openssl/buffer.h>
-# endif
-# include <openssl/lhash.h>
-# include <openssl/pem.h>
-# include <openssl/hmac.h>
-# include <openssl/async.h>
-
-# include <openssl/safestack.h>
-# include <openssl/symhacks.h>
-# include <openssl/ct.h>
-# include <openssl/sslerr.h>
-# include <openssl/prov_ssl.h>
-
-#ifdef  __cplusplus
-extern "C" {
+#include <openssl/e_os2.h>
+#include <openssl/opensslconf.h>
+#include <openssl/comp.h>
+#include <openssl/bio.h>
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/x509.h>
+#include <openssl/crypto.h>
+#include <openssl/buffer.h>
+#endif
+#include <openssl/lhash.h>
+#include <openssl/pem.h>
+#include <openssl/hmac.h>
+#include <openssl/async.h>
+
+#include <openssl/safestack.h>
+#include <openssl/symhacks.h>
+#include <openssl/ct.h>
+#include <openssl/sslerr.h>
+#include <openssl/prov_ssl.h>
+
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 /* OpenSSL version number for ASN.1 encoding of the session information */
@@ -52,116 +51,116 @@ extern "C" {
  * Version 0 - initial version
  * Version 1 - added the optional peer certificate
  */
-# define SSL_SESSION_ASN1_VERSION 0x0001
+#define SSL_SESSION_ASN1_VERSION 0x0001
 
-# define SSL_MAX_SSL_SESSION_ID_LENGTH           32
-# define SSL_MAX_SID_CTX_LENGTH                  32
+#define SSL_MAX_SSL_SESSION_ID_LENGTH 32
+#define SSL_MAX_SID_CTX_LENGTH 32
 
-# define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES     (512/8)
-# define SSL_MAX_KEY_ARG_LENGTH                  8
+#define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES (512 / 8)
+#define SSL_MAX_KEY_ARG_LENGTH 8
 /* SSL_MAX_MASTER_KEY_LENGTH is defined in prov_ssl.h */
 
 /* The maximum number of encrypt/decrypt pipelines we can support */
-# define SSL_MAX_PIPELINES  32
-
-/* text strings for the ciphers */
-
-/* These are used to specify which ciphers to use and not to use */
-
-# define SSL_TXT_LOW             "LOW"
-# define SSL_TXT_MEDIUM          "MEDIUM"
-# define SSL_TXT_HIGH            "HIGH"
-# define SSL_TXT_FIPS            "FIPS"
-
-# define SSL_TXT_aNULL           "aNULL"
-# define SSL_TXT_eNULL           "eNULL"
-# define SSL_TXT_NULL            "NULL"
-
-# define SSL_TXT_kRSA            "kRSA"
-# define SSL_TXT_kDHr            "kDHr"/* this cipher class has been removed */
-# define SSL_TXT_kDHd            "kDHd"/* this cipher class has been removed */
-# define SSL_TXT_kDH             "kDH"/* this cipher class has been removed */
-# define SSL_TXT_kEDH            "kEDH"/* alias for kDHE */
-# define SSL_TXT_kDHE            "kDHE"
-# define SSL_TXT_kECDHr          "kECDHr"/* this cipher class has been removed */
-# define SSL_TXT_kECDHe          "kECDHe"/* this cipher class has been removed */
-# define SSL_TXT_kECDH           "kECDH"/* this cipher class has been removed */
-# define SSL_TXT_kEECDH          "kEECDH"/* alias for kECDHE */
-# define SSL_TXT_kECDHE          "kECDHE"
-# define SSL_TXT_kPSK            "kPSK"
-# define SSL_TXT_kRSAPSK         "kRSAPSK"
-# define SSL_TXT_kECDHEPSK       "kECDHEPSK"
-# define SSL_TXT_kDHEPSK         "kDHEPSK"
-# define SSL_TXT_kGOST           "kGOST"
-# define SSL_TXT_kGOST18         "kGOST18"
-# define SSL_TXT_kSRP            "kSRP"
-
-# define SSL_TXT_aRSA            "aRSA"
-# define SSL_TXT_aDSS            "aDSS"
-# define SSL_TXT_aDH             "aDH"/* this cipher class has been removed */
-# define SSL_TXT_aECDH           "aECDH"/* this cipher class has been removed */
-# define SSL_TXT_aECDSA          "aECDSA"
-# define SSL_TXT_aPSK            "aPSK"
-# define SSL_TXT_aGOST94         "aGOST94"
-# define SSL_TXT_aGOST01         "aGOST01"
-# define SSL_TXT_aGOST12         "aGOST12"
-# define SSL_TXT_aGOST           "aGOST"
-# define SSL_TXT_aSRP            "aSRP"
-
-# define SSL_TXT_DSS             "DSS"
-# define SSL_TXT_DH              "DH"
-# define SSL_TXT_DHE             "DHE"/* same as "kDHE:-ADH" */
-# define SSL_TXT_EDH             "EDH"/* alias for DHE */
-# define SSL_TXT_ADH             "ADH"
-# define SSL_TXT_RSA             "RSA"
-# define SSL_TXT_ECDH            "ECDH"
-# define SSL_TXT_EECDH           "EECDH"/* alias for ECDHE" */
-# define SSL_TXT_ECDHE           "ECDHE"/* same as "kECDHE:-AECDH" */
-# define SSL_TXT_AECDH           "AECDH"
-# define SSL_TXT_ECDSA           "ECDSA"
-# define SSL_TXT_PSK             "PSK"
-# define SSL_TXT_SRP             "SRP"
-
-# define SSL_TXT_DES             "DES"
-# define SSL_TXT_3DES            "3DES"
-# define SSL_TXT_RC4             "RC4"
-# define SSL_TXT_RC2             "RC2"
-# define SSL_TXT_IDEA            "IDEA"
-# define SSL_TXT_SEED            "SEED"
-# define SSL_TXT_AES128          "AES128"
-# define SSL_TXT_AES256          "AES256"
-# define SSL_TXT_AES             "AES"
-# define SSL_TXT_AES_GCM         "AESGCM"
-# define SSL_TXT_AES_CCM         "AESCCM"
-# define SSL_TXT_AES_CCM_8       "AESCCM8"
-# define SSL_TXT_CAMELLIA128     "CAMELLIA128"
-# define SSL_TXT_CAMELLIA256     "CAMELLIA256"
-# define SSL_TXT_CAMELLIA        "CAMELLIA"
-# define SSL_TXT_CHACHA20        "CHACHA20"
-# define SSL_TXT_GOST            "GOST89"
-# define SSL_TXT_ARIA            "ARIA"
-# define SSL_TXT_ARIA_GCM        "ARIAGCM"
-# define SSL_TXT_ARIA128         "ARIA128"
-# define SSL_TXT_ARIA256         "ARIA256"
-# define SSL_TXT_GOST2012_GOST8912_GOST8912 "GOST2012-GOST8912-GOST8912"
-# define SSL_TXT_CBC             "CBC"
-
-# define SSL_TXT_MD5             "MD5"
-# define SSL_TXT_SHA1            "SHA1"
-# define SSL_TXT_SHA             "SHA"/* same as "SHA1" */
-# define SSL_TXT_GOST94          "GOST94"
-# define SSL_TXT_GOST89MAC       "GOST89MAC"
-# define SSL_TXT_GOST12          "GOST12"
-# define SSL_TXT_GOST89MAC12     "GOST89MAC12"
-# define SSL_TXT_SHA256          "SHA256"
-# define SSL_TXT_SHA384          "SHA384"
-
-# define SSL_TXT_SSLV3           "SSLv3"
-# define SSL_TXT_TLSV1           "TLSv1"
-# define SSL_TXT_TLSV1_1         "TLSv1.1"
-# define SSL_TXT_TLSV1_2         "TLSv1.2"
-
-# define SSL_TXT_ALL             "ALL"
+#define SSL_MAX_PIPELINES 32
+
+    /* text strings for the ciphers */
+
+    /* These are used to specify which ciphers to use and not to use */
+
+#define SSL_TXT_LOW "LOW"
+#define SSL_TXT_MEDIUM "MEDIUM"
+#define SSL_TXT_HIGH "HIGH"
+#define SSL_TXT_FIPS "FIPS"
+
+#define SSL_TXT_aNULL "aNULL"
+#define SSL_TXT_eNULL "eNULL"
+#define SSL_TXT_NULL "NULL"
+
+#define SSL_TXT_kRSA "kRSA"
+#define SSL_TXT_kDHr "kDHr" /* this cipher class has been removed */
+#define SSL_TXT_kDHd "kDHd" /* this cipher class has been removed */
+#define SSL_TXT_kDH "kDH"   /* this cipher class has been removed */
+#define SSL_TXT_kEDH "kEDH" /* alias for kDHE */
+#define SSL_TXT_kDHE "kDHE"
+#define SSL_TXT_kECDHr "kECDHr" /* this cipher class has been removed */
+#define SSL_TXT_kECDHe "kECDHe" /* this cipher class has been removed */
+#define SSL_TXT_kECDH "kECDH"   /* this cipher class has been removed */
+#define SSL_TXT_kEECDH "kEECDH" /* alias for kECDHE */
+#define SSL_TXT_kECDHE "kECDHE"
+#define SSL_TXT_kPSK "kPSK"
+#define SSL_TXT_kRSAPSK "kRSAPSK"
+#define SSL_TXT_kECDHEPSK "kECDHEPSK"
+#define SSL_TXT_kDHEPSK "kDHEPSK"
+#define SSL_TXT_kGOST "kGOST"
+#define SSL_TXT_kGOST18 "kGOST18"
+#define SSL_TXT_kSRP "kSRP"
+
+#define SSL_TXT_aRSA "aRSA"
+#define SSL_TXT_aDSS "aDSS"
+#define SSL_TXT_aDH "aDH"     /* this cipher class has been removed */
+#define SSL_TXT_aECDH "aECDH" /* this cipher class has been removed */
+#define SSL_TXT_aECDSA "aECDSA"
+#define SSL_TXT_aPSK "aPSK"
+#define SSL_TXT_aGOST94 "aGOST94"
+#define SSL_TXT_aGOST01 "aGOST01"
+#define SSL_TXT_aGOST12 "aGOST12"
+#define SSL_TXT_aGOST "aGOST"
+#define SSL_TXT_aSRP "aSRP"
+
+#define SSL_TXT_DSS "DSS"
+#define SSL_TXT_DH "DH"
+#define SSL_TXT_DHE "DHE" /* same as "kDHE:-ADH" */
+#define SSL_TXT_EDH "EDH" /* alias for DHE */
+#define SSL_TXT_ADH "ADH"
+#define SSL_TXT_RSA "RSA"
+#define SSL_TXT_ECDH "ECDH"
+#define SSL_TXT_EECDH "EECDH" /* alias for ECDHE" */
+#define SSL_TXT_ECDHE "ECDHE" /* same as "kECDHE:-AECDH" */
+#define SSL_TXT_AECDH "AECDH"
+#define SSL_TXT_ECDSA "ECDSA"
+#define SSL_TXT_PSK "PSK"
+#define SSL_TXT_SRP "SRP"
+
+#define SSL_TXT_DES "DES"
+#define SSL_TXT_3DES "3DES"
+#define SSL_TXT_RC4 "RC4"
+#define SSL_TXT_RC2 "RC2"
+#define SSL_TXT_IDEA "IDEA"
+#define SSL_TXT_SEED "SEED"
+#define SSL_TXT_AES128 "AES128"
+#define SSL_TXT_AES256 "AES256"
+#define SSL_TXT_AES "AES"
+#define SSL_TXT_AES_GCM "AESGCM"
+#define SSL_TXT_AES_CCM "AESCCM"
+#define SSL_TXT_AES_CCM_8 "AESCCM8"
+#define SSL_TXT_CAMELLIA128 "CAMELLIA128"
+#define SSL_TXT_CAMELLIA256 "CAMELLIA256"
+#define SSL_TXT_CAMELLIA "CAMELLIA"
+#define SSL_TXT_CHACHA20 "CHACHA20"
+#define SSL_TXT_GOST "GOST89"
+#define SSL_TXT_ARIA "ARIA"
+#define SSL_TXT_ARIA_GCM "ARIAGCM"
+#define SSL_TXT_ARIA128 "ARIA128"
+#define SSL_TXT_ARIA256 "ARIA256"
+#define SSL_TXT_GOST2012_GOST8912_GOST8912 "GOST2012-GOST8912-GOST8912"
+#define SSL_TXT_CBC "CBC"
+
+#define SSL_TXT_MD5 "MD5"
+#define SSL_TXT_SHA1 "SHA1"
+#define SSL_TXT_SHA "SHA" /* same as "SHA1" */
+#define SSL_TXT_GOST94 "GOST94"
+#define SSL_TXT_GOST89MAC "GOST89MAC"
+#define SSL_TXT_GOST12 "GOST12"
+#define SSL_TXT_GOST89MAC12 "GOST89MAC12"
+#define SSL_TXT_SHA256 "SHA256"
+#define SSL_TXT_SHA384 "SHA384"
+
+#define SSL_TXT_SSLV3 "SSLv3"
+#define SSL_TXT_TLSV1 "TLSv1"
+#define SSL_TXT_TLSV1_1 "TLSv1.1"
+#define SSL_TXT_TLSV1_2 "TLSv1.2"
+
+#define SSL_TXT_ALL "ALL"
 
 /*-
  * COMPLEMENTOF* definitions. These identifiers are used to (de-select)
@@ -177,8 +176,8 @@ extern "C" {
  * DEFAULT gets, as only selection is being done and no sorting as needed
  * for DEFAULT.
  */
-# define SSL_TXT_CMPALL          "COMPLEMENTOFALL"
-# define SSL_TXT_CMPDEF          "COMPLEMENTOFDEFAULT"
+#define SSL_TXT_CMPALL "COMPLEMENTOFALL"
+#define SSL_TXT_CMPDEF "COMPLEMENTOFDEFAULT"
 
 /*
  * The following cipher list is used by default. It also is substituted when
@@ -187,17 +186,17 @@ extern "C" {
  * DEPRECATED IN 3.0.0, in favor of OSSL_default_cipher_list()
  * Update both macro and function simultaneously
  */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SSL_DEFAULT_CIPHER_LIST "ALL:!COMPLEMENTOFDEFAULT:!eNULL"
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SSL_DEFAULT_CIPHER_LIST "ALL:!COMPLEMENTOFDEFAULT:!eNULL"
 /*
  * This is the default set of TLSv1.3 ciphersuites
  * DEPRECATED IN 3.0.0, in favor of OSSL_default_ciphersuites()
  * Update both macro and function simultaneously
  */
-#  define TLS_DEFAULT_CIPHERSUITES "TLS_AES_256_GCM_SHA384:" \
-                                   "TLS_CHACHA20_POLY1305_SHA256:" \
-                                   "TLS_AES_128_GCM_SHA256"
-# endif
+#define TLS_DEFAULT_CIPHERSUITES "TLS_AES_256_GCM_SHA384:"       \
+                                 "TLS_CHACHA20_POLY1305_SHA256:" \
+                                 "TLS_AES_128_GCM_SHA256"
+#endif
 /*
  * As of OpenSSL 1.0.0, ssl_create_cipher_list() in ssl/ssl_ciph.c always
  * starts with a reasonable order, and all we have to do for DEFAULT is
@@ -206,160 +205,138 @@ extern "C" {
  */
 
 /* Used in SSL_set_shutdown()/SSL_get_shutdown(); */
-# define SSL_SENT_SHUTDOWN       1
-# define SSL_RECEIVED_SHUTDOWN   2
+#define SSL_SENT_SHUTDOWN 1
+#define SSL_RECEIVED_SHUTDOWN 2
 
 #ifdef __cplusplus
 }
 #endif
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-# define SSL_FILETYPE_ASN1       X509_FILETYPE_ASN1
-# define SSL_FILETYPE_PEM        X509_FILETYPE_PEM
+#define SSL_FILETYPE_ASN1 X509_FILETYPE_ASN1
+#define SSL_FILETYPE_PEM X509_FILETYPE_PEM
 
-/*
- * This is needed to stop compilers complaining about the 'struct ssl_st *'
- * function parameters used to prototype callbacks in SSL_CTX.
- */
-typedef struct ssl_st *ssl_crock_st;
-typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT;
-typedef struct ssl_method_st SSL_METHOD;
-typedef struct ssl_cipher_st SSL_CIPHER;
-typedef struct ssl_session_st SSL_SESSION;
-typedef struct tls_sigalgs_st TLS_SIGALGS;
-typedef struct ssl_conf_ctx_st SSL_CONF_CTX;
-typedef struct ssl_comp_st SSL_COMP;
-
-STACK_OF(SSL_CIPHER);
-STACK_OF(SSL_COMP);
-
-/* SRTP protection profiles for use with the use_srtp extension (RFC 5764)*/
-typedef struct srtp_protection_profile_st {
-    const char *name;
-    unsigned long id;
-} SRTP_PROTECTION_PROFILE;
-SKM_DEFINE_STACK_OF_INTERNAL(SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE)
+    /*
+     * This is needed to stop compilers complaining about the 'struct ssl_st *'
+     * function parameters used to prototype callbacks in SSL_CTX.
+     */
+    typedef struct ssl_st* ssl_crock_st;
+    typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT;
+    typedef struct ssl_method_st SSL_METHOD;
+    typedef struct ssl_cipher_st SSL_CIPHER;
+    typedef struct ssl_session_st SSL_SESSION;
+    typedef struct tls_sigalgs_st TLS_SIGALGS;
+    typedef struct ssl_conf_ctx_st SSL_CONF_CTX;
+    typedef struct ssl_comp_st SSL_COMP;
+
+    STACK_OF(SSL_CIPHER);
+    STACK_OF(SSL_COMP);
+
+    /* SRTP protection profiles for use with the use_srtp extension (RFC 5764)*/
+    typedef struct srtp_protection_profile_st
+    {
+        const char* name;
+        unsigned long id;
+    } SRTP_PROTECTION_PROFILE;
+    SKM_DEFINE_STACK_OF_INTERNAL(SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE)
 #define sk_SRTP_PROTECTION_PROFILE_num(sk) OPENSSL_sk_num(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk))
-#define sk_SRTP_PROTECTION_PROFILE_value(sk, idx) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_value(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx)))
-#define sk_SRTP_PROTECTION_PROFILE_new(cmp) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)))
-#define sk_SRTP_PROTECTION_PROFILE_new_null() ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new_null())
-#define sk_SRTP_PROTECTION_PROFILE_new_reserve(cmp, n) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_new_reserve(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp), (n)))
+#define sk_SRTP_PROTECTION_PROFILE_value(sk, idx) ((SRTP_PROTECTION_PROFILE*)OPENSSL_sk_value(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx)))
+#define sk_SRTP_PROTECTION_PROFILE_new(cmp) ((STACK_OF(SRTP_PROTECTION_PROFILE)*)OPENSSL_sk_new(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)))
+#define sk_SRTP_PROTECTION_PROFILE_new_null() ((STACK_OF(SRTP_PROTECTION_PROFILE)*)OPENSSL_sk_new_null())
+#define sk_SRTP_PROTECTION_PROFILE_new_reserve(cmp, n) ((STACK_OF(SRTP_PROTECTION_PROFILE)*)OPENSSL_sk_new_reserve(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp), (n)))
 #define sk_SRTP_PROTECTION_PROFILE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (n))
 #define sk_SRTP_PROTECTION_PROFILE_free(sk) OPENSSL_sk_free(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
 #define sk_SRTP_PROTECTION_PROFILE_zero(sk) OPENSSL_sk_zero(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
-#define sk_SRTP_PROTECTION_PROFILE_delete(sk, i) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_delete(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (i)))
-#define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, ptr) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_delete_ptr(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr)))
+#define sk_SRTP_PROTECTION_PROFILE_delete(sk, i) ((SRTP_PROTECTION_PROFILE*)OPENSSL_sk_delete(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (i)))
+#define sk_SRTP_PROTECTION_PROFILE_delete_ptr(sk, ptr) ((SRTP_PROTECTION_PROFILE*)OPENSSL_sk_delete_ptr(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr)))
 #define sk_SRTP_PROTECTION_PROFILE_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
 #define sk_SRTP_PROTECTION_PROFILE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
-#define sk_SRTP_PROTECTION_PROFILE_pop(sk) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_pop(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk)))
-#define sk_SRTP_PROTECTION_PROFILE_shift(sk) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_shift(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk)))
-#define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk),ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc))
+#define sk_SRTP_PROTECTION_PROFILE_pop(sk) ((SRTP_PROTECTION_PROFILE*)OPENSSL_sk_pop(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_shift(sk) ((SRTP_PROTECTION_PROFILE*)OPENSSL_sk_shift(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc))
 #define sk_SRTP_PROTECTION_PROFILE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr), (idx))
-#define sk_SRTP_PROTECTION_PROFILE_set(sk, idx, ptr) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_set(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr)))
+#define sk_SRTP_PROTECTION_PROFILE_set(sk, idx, ptr) ((SRTP_PROTECTION_PROFILE*)OPENSSL_sk_set(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr)))
 #define sk_SRTP_PROTECTION_PROFILE_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
 #define sk_SRTP_PROTECTION_PROFILE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr))
 #define sk_SRTP_PROTECTION_PROFILE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr), pnum)
 #define sk_SRTP_PROTECTION_PROFILE_sort(sk) OPENSSL_sk_sort(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
 #define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk))
-#define sk_SRTP_PROTECTION_PROFILE_dup(sk) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_dup(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk)))
-#define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_deep_copy(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_copyfunc_type(copyfunc), ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc)))
+#define sk_SRTP_PROTECTION_PROFILE_dup(sk) ((STACK_OF(SRTP_PROTECTION_PROFILE)*)OPENSSL_sk_dup(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk)))
+#define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRTP_PROTECTION_PROFILE)*)OPENSSL_sk_deep_copy(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_copyfunc_type(copyfunc), ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc)))
 #define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, cmp) ((sk_SRTP_PROTECTION_PROFILE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)))
 
-
-
-typedef int (*tls_session_ticket_ext_cb_fn)(SSL *s, const unsigned char *data,
-                                            int len, void *arg);
-typedef int (*tls_session_secret_cb_fn)(SSL *s, void *secret, int *secret_len,
-                                        STACK_OF(SSL_CIPHER) *peer_ciphers,
-                                        const SSL_CIPHER **cipher, void *arg);
+    typedef int (*tls_session_ticket_ext_cb_fn)(SSL* s, const unsigned char* data, int len, void* arg);
+    typedef int (*tls_session_secret_cb_fn)(SSL* s, void* secret, int* secret_len, STACK_OF(SSL_CIPHER) * peer_ciphers, const SSL_CIPHER** cipher, void* arg);
 
 /* Extension context codes */
 /* This extension is only allowed in TLS */
-#define SSL_EXT_TLS_ONLY                        0x0001
+#define SSL_EXT_TLS_ONLY 0x0001
 /* This extension is only allowed in DTLS */
-#define SSL_EXT_DTLS_ONLY                       0x0002
+#define SSL_EXT_DTLS_ONLY 0x0002
 /* Some extensions may be allowed in DTLS but we don't implement them for it */
-#define SSL_EXT_TLS_IMPLEMENTATION_ONLY         0x0004
+#define SSL_EXT_TLS_IMPLEMENTATION_ONLY 0x0004
 /* Most extensions are not defined for SSLv3 but EXT_TYPE_renegotiate is */
-#define SSL_EXT_SSL3_ALLOWED                    0x0008
+#define SSL_EXT_SSL3_ALLOWED 0x0008
 /* Extension is only defined for TLS1.2 and below */
-#define SSL_EXT_TLS1_2_AND_BELOW_ONLY           0x0010
+#define SSL_EXT_TLS1_2_AND_BELOW_ONLY 0x0010
 /* Extension is only defined for TLS1.3 and above */
-#define SSL_EXT_TLS1_3_ONLY                     0x0020
+#define SSL_EXT_TLS1_3_ONLY 0x0020
 /* Ignore this extension during parsing if we are resuming */
-#define SSL_EXT_IGNORE_ON_RESUMPTION            0x0040
-#define SSL_EXT_CLIENT_HELLO                    0x0080
+#define SSL_EXT_IGNORE_ON_RESUMPTION 0x0040
+#define SSL_EXT_CLIENT_HELLO 0x0080
 /* Really means TLS1.2 or below */
-#define SSL_EXT_TLS1_2_SERVER_HELLO             0x0100
-#define SSL_EXT_TLS1_3_SERVER_HELLO             0x0200
-#define SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS     0x0400
-#define SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST      0x0800
-#define SSL_EXT_TLS1_3_CERTIFICATE              0x1000
-#define SSL_EXT_TLS1_3_NEW_SESSION_TICKET       0x2000
-#define SSL_EXT_TLS1_3_CERTIFICATE_REQUEST      0x4000
-
-/* Typedefs for handling custom extensions */
+#define SSL_EXT_TLS1_2_SERVER_HELLO 0x0100
+#define SSL_EXT_TLS1_3_SERVER_HELLO 0x0200
+#define SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS 0x0400
+#define SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST 0x0800
+#define SSL_EXT_TLS1_3_CERTIFICATE 0x1000
+#define SSL_EXT_TLS1_3_NEW_SESSION_TICKET 0x2000
+#define SSL_EXT_TLS1_3_CERTIFICATE_REQUEST 0x4000
 
-typedef int (*custom_ext_add_cb)(SSL *s, unsigned int ext_type,
-                                 const unsigned char **out, size_t *outlen,
-                                 int *al, void *add_arg);
+    /* Typedefs for handling custom extensions */
 
-typedef void (*custom_ext_free_cb)(SSL *s, unsigned int ext_type,
-                                   const unsigned char *out, void *add_arg);
+    typedef int (*custom_ext_add_cb)(SSL* s, unsigned int ext_type, const unsigned char** out, size_t* outlen, int* al, void* add_arg);
 
-typedef int (*custom_ext_parse_cb)(SSL *s, unsigned int ext_type,
-                                   const unsigned char *in, size_t inlen,
-                                   int *al, void *parse_arg);
+    typedef void (*custom_ext_free_cb)(SSL* s, unsigned int ext_type, const unsigned char* out, void* add_arg);
 
+    typedef int (*custom_ext_parse_cb)(SSL* s, unsigned int ext_type, const unsigned char* in, size_t inlen, int* al, void* parse_arg);
 
-typedef int (*SSL_custom_ext_add_cb_ex)(SSL *s, unsigned int ext_type,
-                                        unsigned int context,
-                                        const unsigned char **out,
-                                        size_t *outlen, X509 *x,
-                                        size_t chainidx,
-                                        int *al, void *add_arg);
+    typedef int (*SSL_custom_ext_add_cb_ex)(SSL* s, unsigned int ext_type, unsigned int context, const unsigned char** out, size_t* outlen, X509* x, size_t chainidx, int* al, void* add_arg);
 
-typedef void (*SSL_custom_ext_free_cb_ex)(SSL *s, unsigned int ext_type,
-                                          unsigned int context,
-                                          const unsigned char *out,
-                                          void *add_arg);
+    typedef void (*SSL_custom_ext_free_cb_ex)(SSL* s, unsigned int ext_type, unsigned int context, const unsigned char* out, void* add_arg);
 
-typedef int (*SSL_custom_ext_parse_cb_ex)(SSL *s, unsigned int ext_type,
-                                          unsigned int context,
-                                          const unsigned char *in,
-                                          size_t inlen, X509 *x,
-                                          size_t chainidx,
-                                          int *al, void *parse_arg);
+    typedef int (*SSL_custom_ext_parse_cb_ex)(SSL* s, unsigned int ext_type, unsigned int context, const unsigned char* in, size_t inlen, X509* x, size_t chainidx, int* al, void* parse_arg);
 
-/* Typedef for verification callback */
-typedef int (*SSL_verify_cb)(int preverify_ok, X509_STORE_CTX *x509_ctx);
+    /* Typedef for verification callback */
+    typedef int (*SSL_verify_cb)(int preverify_ok, X509_STORE_CTX* x509_ctx);
 
-/* Typedef for SSL async callback */
-typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
+    /* Typedef for SSL async callback */
+    typedef int (*SSL_async_callback_fn)(SSL* s, void* arg);
 
-#define SSL_OP_BIT(n)  ((uint64_t)1 << (uint64_t)n)
+#define SSL_OP_BIT(n) ((uint64_t)1 << (uint64_t)n)
 
-/*
- * SSL/TLS connection options.
- */
+    /*
+     * SSL/TLS connection options.
+     */
     /* Disable Extended master secret */
-# define SSL_OP_NO_EXTENDED_MASTER_SECRET                SSL_OP_BIT(0)
+#define SSL_OP_NO_EXTENDED_MASTER_SECRET SSL_OP_BIT(0)
     /* Cleanse plaintext copies of data delivered to the application */
-# define SSL_OP_CLEANSE_PLAINTEXT                        SSL_OP_BIT(1)
+#define SSL_OP_CLEANSE_PLAINTEXT SSL_OP_BIT(1)
     /* Allow initial connection to servers that don't support RI */
-# define SSL_OP_LEGACY_SERVER_CONNECT                    SSL_OP_BIT(2)
+#define SSL_OP_LEGACY_SERVER_CONNECT SSL_OP_BIT(2)
     /* Enable support for Kernel TLS */
-# define SSL_OP_ENABLE_KTLS                              SSL_OP_BIT(3)
-# define SSL_OP_TLSEXT_PADDING                           SSL_OP_BIT(4)
-# define SSL_OP_SAFARI_ECDHE_ECDSA_BUG                   SSL_OP_BIT(6)
-# define SSL_OP_IGNORE_UNEXPECTED_EOF                    SSL_OP_BIT(7)
-# define SSL_OP_ALLOW_CLIENT_RENEGOTIATION               SSL_OP_BIT(8)
-# define SSL_OP_DISABLE_TLSEXT_CA_NAMES                  SSL_OP_BIT(9)
+#define SSL_OP_ENABLE_KTLS SSL_OP_BIT(3)
+#define SSL_OP_TLSEXT_PADDING SSL_OP_BIT(4)
+#define SSL_OP_SAFARI_ECDHE_ECDSA_BUG SSL_OP_BIT(6)
+#define SSL_OP_IGNORE_UNEXPECTED_EOF SSL_OP_BIT(7)
+#define SSL_OP_ALLOW_CLIENT_RENEGOTIATION SSL_OP_BIT(8)
+#define SSL_OP_DISABLE_TLSEXT_CA_NAMES SSL_OP_BIT(9)
     /* In TLSv1.3 allow a non-(ec)dhe based kex_mode */
-# define SSL_OP_ALLOW_NO_DHE_KEX                         SSL_OP_BIT(10)
+#define SSL_OP_ALLOW_NO_DHE_KEX SSL_OP_BIT(10)
     /*
      * Disable SSL 3.0/TLS 1.0 CBC vulnerability workaround that was added
      * in OpenSSL 0.9.6d.  Usually (depending on the application protocol)
@@ -367,136 +344,134 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
      * implementations cannot handle it at all, which is why we include it
      * in SSL_OP_ALL. Added in 0.9.6e
      */
-# define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS              SSL_OP_BIT(11)
+#define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS SSL_OP_BIT(11)
     /* DTLS options */
-# define SSL_OP_NO_QUERY_MTU                             SSL_OP_BIT(12)
+#define SSL_OP_NO_QUERY_MTU SSL_OP_BIT(12)
     /* Turn on Cookie Exchange (on relevant for servers) */
-# define SSL_OP_COOKIE_EXCHANGE                          SSL_OP_BIT(13)
+#define SSL_OP_COOKIE_EXCHANGE SSL_OP_BIT(13)
     /* Don't use RFC4507 ticket extension */
-# define SSL_OP_NO_TICKET                                SSL_OP_BIT(14)
-# ifndef OPENSSL_NO_DTLS1_METHOD
+#define SSL_OP_NO_TICKET SSL_OP_BIT(14)
+#ifndef OPENSSL_NO_DTLS1_METHOD
     /*
      * Use Cisco's version identifier of DTLS_BAD_VER
      * (only with deprecated DTLSv1_client_method())
      */
-#  define SSL_OP_CISCO_ANYCONNECT                        SSL_OP_BIT(15)
-# endif
+#define SSL_OP_CISCO_ANYCONNECT SSL_OP_BIT(15)
+#endif
     /* As server, disallow session resumption on renegotiation */
-# define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION   SSL_OP_BIT(16)
+#define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION SSL_OP_BIT(16)
     /* Don't use compression even if supported */
-# define SSL_OP_NO_COMPRESSION                           SSL_OP_BIT(17)
+#define SSL_OP_NO_COMPRESSION SSL_OP_BIT(17)
     /* Permit unsafe legacy renegotiation */
-# define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION        SSL_OP_BIT(18)
+#define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION SSL_OP_BIT(18)
     /* Disable encrypt-then-mac */
-# define SSL_OP_NO_ENCRYPT_THEN_MAC                      SSL_OP_BIT(19)
+#define SSL_OP_NO_ENCRYPT_THEN_MAC SSL_OP_BIT(19)
     /*
      * Enable TLSv1.3 Compatibility mode. This is on by default. A future
      * version of OpenSSL may have this disabled by default.
      */
-# define SSL_OP_ENABLE_MIDDLEBOX_COMPAT                  SSL_OP_BIT(20)
+#define SSL_OP_ENABLE_MIDDLEBOX_COMPAT SSL_OP_BIT(20)
     /*
      * Prioritize Chacha20Poly1305 when client does.
      * Modifies SSL_OP_CIPHER_SERVER_PREFERENCE
      */
-# define SSL_OP_PRIORITIZE_CHACHA                        SSL_OP_BIT(21)
+#define SSL_OP_PRIORITIZE_CHACHA SSL_OP_BIT(21)
     /*
      * Set on servers to choose the cipher according to server's preferences.
      */
-# define SSL_OP_CIPHER_SERVER_PREFERENCE                 SSL_OP_BIT(22)
+#define SSL_OP_CIPHER_SERVER_PREFERENCE SSL_OP_BIT(22)
     /*
      * If set, a server will allow a client to issue a SSLv3.0 version
      * number as latest version supported in the premaster secret, even when
      * TLSv1.0 (version 3.1) was announced in the client hello. Normally
      * this is forbidden to prevent version rollback attacks.
      */
-# define SSL_OP_TLS_ROLLBACK_BUG                         SSL_OP_BIT(23)
+#define SSL_OP_TLS_ROLLBACK_BUG SSL_OP_BIT(23)
     /*
      * Switches off automatic TLSv1.3 anti-replay protection for early data.
      * This is a server-side option only (no effect on the client).
      */
-# define SSL_OP_NO_ANTI_REPLAY                           SSL_OP_BIT(24)
-# define SSL_OP_NO_SSLv3                                 SSL_OP_BIT(25)
-# define SSL_OP_NO_TLSv1                                 SSL_OP_BIT(26)
-# define SSL_OP_NO_TLSv1_2                               SSL_OP_BIT(27)
-# define SSL_OP_NO_TLSv1_1                               SSL_OP_BIT(28)
-# define SSL_OP_NO_TLSv1_3                               SSL_OP_BIT(29)
-# define SSL_OP_NO_DTLSv1                                SSL_OP_BIT(26)
-# define SSL_OP_NO_DTLSv1_2                              SSL_OP_BIT(27)
+#define SSL_OP_NO_ANTI_REPLAY SSL_OP_BIT(24)
+#define SSL_OP_NO_SSLv3 SSL_OP_BIT(25)
+#define SSL_OP_NO_TLSv1 SSL_OP_BIT(26)
+#define SSL_OP_NO_TLSv1_2 SSL_OP_BIT(27)
+#define SSL_OP_NO_TLSv1_1 SSL_OP_BIT(28)
+#define SSL_OP_NO_TLSv1_3 SSL_OP_BIT(29)
+#define SSL_OP_NO_DTLSv1 SSL_OP_BIT(26)
+#define SSL_OP_NO_DTLSv1_2 SSL_OP_BIT(27)
     /* Disallow all renegotiation */
-# define SSL_OP_NO_RENEGOTIATION                         SSL_OP_BIT(30)
+#define SSL_OP_NO_RENEGOTIATION SSL_OP_BIT(30)
     /*
      * Make server add server-hello extension from early version of
      * cryptopro draft, when GOST ciphersuite is negotiated. Required for
      * interoperability with CryptoPro CSP 3.x
      */
-# define SSL_OP_CRYPTOPRO_TLSEXT_BUG                     SSL_OP_BIT(31)
+#define SSL_OP_CRYPTOPRO_TLSEXT_BUG SSL_OP_BIT(31)
 
 /*
  * Option "collections."
  */
-# define SSL_OP_NO_SSL_MASK \
-        ( SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 \
-          | SSL_OP_NO_TLSv1_2 | SSL_OP_NO_TLSv1_3 )
-# define SSL_OP_NO_DTLS_MASK \
-        ( SSL_OP_NO_DTLSv1 | SSL_OP_NO_DTLSv1_2 )
+#define SSL_OP_NO_SSL_MASK \
+    (SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2 | SSL_OP_NO_TLSv1_3)
+#define SSL_OP_NO_DTLS_MASK \
+    (SSL_OP_NO_DTLSv1 | SSL_OP_NO_DTLSv1_2)
 
 /* Various bug workarounds that should be rather harmless. */
-# define SSL_OP_ALL \
-        ( SSL_OP_CRYPTOPRO_TLSEXT_BUG | SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS \
-          | SSL_OP_TLSEXT_PADDING | SSL_OP_SAFARI_ECDHE_ECDSA_BUG )
+#define SSL_OP_ALL \
+    (SSL_OP_CRYPTOPRO_TLSEXT_BUG | SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS | SSL_OP_TLSEXT_PADDING | SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
 
-/*
- * OBSOLETE OPTIONS retained for compatibility
- */
+    /*
+     * OBSOLETE OPTIONS retained for compatibility
+     */
 
-# define SSL_OP_MICROSOFT_SESS_ID_BUG                    0x0
-# define SSL_OP_NETSCAPE_CHALLENGE_BUG                   0x0
-# define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG         0x0
-# define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG              0x0
-# define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER               0x0
-# define SSL_OP_MSIE_SSLV2_RSA_PADDING                   0x0
-# define SSL_OP_SSLEAY_080_CLIENT_DH_BUG                 0x0
-# define SSL_OP_TLS_D5_BUG                               0x0
-# define SSL_OP_TLS_BLOCK_PADDING_BUG                    0x0
-# define SSL_OP_SINGLE_ECDH_USE                          0x0
-# define SSL_OP_SINGLE_DH_USE                            0x0
-# define SSL_OP_EPHEMERAL_RSA                            0x0
-# define SSL_OP_NO_SSLv2                                 0x0
-# define SSL_OP_PKCS1_CHECK_1                            0x0
-# define SSL_OP_PKCS1_CHECK_2                            0x0
-# define SSL_OP_NETSCAPE_CA_DN_BUG                       0x0
-# define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG          0x0
+#define SSL_OP_MICROSOFT_SESS_ID_BUG 0x0
+#define SSL_OP_NETSCAPE_CHALLENGE_BUG 0x0
+#define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG 0x0
+#define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG 0x0
+#define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER 0x0
+#define SSL_OP_MSIE_SSLV2_RSA_PADDING 0x0
+#define SSL_OP_SSLEAY_080_CLIENT_DH_BUG 0x0
+#define SSL_OP_TLS_D5_BUG 0x0
+#define SSL_OP_TLS_BLOCK_PADDING_BUG 0x0
+#define SSL_OP_SINGLE_ECDH_USE 0x0
+#define SSL_OP_SINGLE_DH_USE 0x0
+#define SSL_OP_EPHEMERAL_RSA 0x0
+#define SSL_OP_NO_SSLv2 0x0
+#define SSL_OP_PKCS1_CHECK_1 0x0
+#define SSL_OP_PKCS1_CHECK_2 0x0
+#define SSL_OP_NETSCAPE_CA_DN_BUG 0x0
+#define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG 0x0
 
 /*
  * Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success
  * when just a single record has been written):
  */
-# define SSL_MODE_ENABLE_PARTIAL_WRITE       0x00000001U
+#define SSL_MODE_ENABLE_PARTIAL_WRITE 0x00000001U
 /*
  * Make it possible to retry SSL_write() with changed buffer location (buffer
  * contents must stay the same!); this is not the default to avoid the
  * misconception that non-blocking SSL_write() behaves like non-blocking
  * write():
  */
-# define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002U
+#define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002U
 /*
  * Never bother the application with retries if the transport is blocking:
  */
-# define SSL_MODE_AUTO_RETRY 0x00000004U
+#define SSL_MODE_AUTO_RETRY 0x00000004U
 /* Don't attempt to automatically build certificate chain */
-# define SSL_MODE_NO_AUTO_CHAIN 0x00000008U
+#define SSL_MODE_NO_AUTO_CHAIN 0x00000008U
 /*
  * Save RAM by releasing read and write buffers when they're empty. (SSL3 and
  * TLS only.) Released buffers are freed.
  */
-# define SSL_MODE_RELEASE_BUFFERS 0x00000010U
+#define SSL_MODE_RELEASE_BUFFERS 0x00000010U
 /*
  * Send the current time in the Random fields of the ClientHello and
  * ServerHello records for compatibility with hypothetical implementations
  * that require it.
  */
-# define SSL_MODE_SEND_CLIENTHELLO_TIME 0x00000020U
-# define SSL_MODE_SEND_SERVERHELLO_TIME 0x00000040U
+#define SSL_MODE_SEND_CLIENTHELLO_TIME 0x00000020U
+#define SSL_MODE_SEND_SERVERHELLO_TIME 0x00000040U
 /*
  * Send TLS_FALLBACK_SCSV in the ClientHello. To be set only by applications
  * that reconnect with a downgraded protocol version; see
@@ -505,11 +480,11 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
  * fallback retries, following the guidance in
  * draft-ietf-tls-downgrade-scsv-00.
  */
-# define SSL_MODE_SEND_FALLBACK_SCSV 0x00000080U
+#define SSL_MODE_SEND_FALLBACK_SCSV 0x00000080U
 /*
  * Support Asynchronous operation
  */
-# define SSL_MODE_ASYNC 0x00000100U
+#define SSL_MODE_ASYNC 0x00000100U
 
 /*
  * When using DTLS/SCTP, include the terminating zero in the label
@@ -522,2078 +497,1864 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
  * - OpenSSL 1.1.0 series
  * - OpenSSL 1.1.1 and 1.1.1a
  */
-# define SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG 0x00000400U
+#define SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG 0x00000400U
 
 /* Cert related flags */
 /*
  * Many implementations ignore some aspects of the TLS standards such as
  * enforcing certificate chain algorithms. When this is set we enforce them.
  */
-# define SSL_CERT_FLAG_TLS_STRICT                0x00000001U
+#define SSL_CERT_FLAG_TLS_STRICT 0x00000001U
 
 /* Suite B modes, takes same values as certificate verify flags */
-# define SSL_CERT_FLAG_SUITEB_128_LOS_ONLY       0x10000
+#define SSL_CERT_FLAG_SUITEB_128_LOS_ONLY 0x10000
 /* Suite B 192 bit only mode */
-# define SSL_CERT_FLAG_SUITEB_192_LOS            0x20000
+#define SSL_CERT_FLAG_SUITEB_192_LOS 0x20000
 /* Suite B 128 bit mode allowing 192 bit algorithms */
-# define SSL_CERT_FLAG_SUITEB_128_LOS            0x30000
+#define SSL_CERT_FLAG_SUITEB_128_LOS 0x30000
 
 /* Perform all sorts of protocol violations for testing purposes */
-# define SSL_CERT_FLAG_BROKEN_PROTOCOL           0x10000000
+#define SSL_CERT_FLAG_BROKEN_PROTOCOL 0x10000000
 
 /* Flags for building certificate chains */
 /* Treat any existing certificates as untrusted CAs */
-# define SSL_BUILD_CHAIN_FLAG_UNTRUSTED          0x1
+#define SSL_BUILD_CHAIN_FLAG_UNTRUSTED 0x1
 /* Don't include root CA in chain */
-# define SSL_BUILD_CHAIN_FLAG_NO_ROOT            0x2
+#define SSL_BUILD_CHAIN_FLAG_NO_ROOT 0x2
 /* Just check certificates already there */
-# define SSL_BUILD_CHAIN_FLAG_CHECK              0x4
+#define SSL_BUILD_CHAIN_FLAG_CHECK 0x4
 /* Ignore verification errors */
-# define SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR       0x8
+#define SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR 0x8
 /* Clear verification errors from queue */
-# define SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR        0x10
+#define SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR 0x10
 
 /* Flags returned by SSL_check_chain */
 /* Certificate can be used with this session */
-# define CERT_PKEY_VALID         0x1
+#define CERT_PKEY_VALID 0x1
 /* Certificate can also be used for signing */
-# define CERT_PKEY_SIGN          0x2
+#define CERT_PKEY_SIGN 0x2
 /* EE certificate signing algorithm OK */
-# define CERT_PKEY_EE_SIGNATURE  0x10
+#define CERT_PKEY_EE_SIGNATURE 0x10
 /* CA signature algorithms OK */
-# define CERT_PKEY_CA_SIGNATURE  0x20
+#define CERT_PKEY_CA_SIGNATURE 0x20
 /* EE certificate parameters OK */
-# define CERT_PKEY_EE_PARAM      0x40
+#define CERT_PKEY_EE_PARAM 0x40
 /* CA certificate parameters OK */
-# define CERT_PKEY_CA_PARAM      0x80
+#define CERT_PKEY_CA_PARAM 0x80
 /* Signing explicitly allowed as opposed to SHA1 fallback */
-# define CERT_PKEY_EXPLICIT_SIGN 0x100
+#define CERT_PKEY_EXPLICIT_SIGN 0x100
 /* Client CA issuer names match (always set for server cert) */
-# define CERT_PKEY_ISSUER_NAME   0x200
+#define CERT_PKEY_ISSUER_NAME 0x200
 /* Cert type matches client types (always set for server cert) */
-# define CERT_PKEY_CERT_TYPE     0x400
+#define CERT_PKEY_CERT_TYPE 0x400
 /* Cert chain suitable to Suite B */
-# define CERT_PKEY_SUITEB        0x800
-
-# define SSL_CONF_FLAG_CMDLINE           0x1
-# define SSL_CONF_FLAG_FILE              0x2
-# define SSL_CONF_FLAG_CLIENT            0x4
-# define SSL_CONF_FLAG_SERVER            0x8
-# define SSL_CONF_FLAG_SHOW_ERRORS       0x10
-# define SSL_CONF_FLAG_CERTIFICATE       0x20
-# define SSL_CONF_FLAG_REQUIRE_PRIVATE   0x40
+#define CERT_PKEY_SUITEB 0x800
+
+#define SSL_CONF_FLAG_CMDLINE 0x1
+#define SSL_CONF_FLAG_FILE 0x2
+#define SSL_CONF_FLAG_CLIENT 0x4
+#define SSL_CONF_FLAG_SERVER 0x8
+#define SSL_CONF_FLAG_SHOW_ERRORS 0x10
+#define SSL_CONF_FLAG_CERTIFICATE 0x20
+#define SSL_CONF_FLAG_REQUIRE_PRIVATE 0x40
 /* Configuration value types */
-# define SSL_CONF_TYPE_UNKNOWN           0x0
-# define SSL_CONF_TYPE_STRING            0x1
-# define SSL_CONF_TYPE_FILE              0x2
-# define SSL_CONF_TYPE_DIR               0x3
-# define SSL_CONF_TYPE_NONE              0x4
-# define SSL_CONF_TYPE_STORE             0x5
+#define SSL_CONF_TYPE_UNKNOWN 0x0
+#define SSL_CONF_TYPE_STRING 0x1
+#define SSL_CONF_TYPE_FILE 0x2
+#define SSL_CONF_TYPE_DIR 0x3
+#define SSL_CONF_TYPE_NONE 0x4
+#define SSL_CONF_TYPE_STORE 0x5
 
 /* Maximum length of the application-controlled segment of a a TLSv1.3 cookie */
-# define SSL_COOKIE_LENGTH                       4096
+#define SSL_COOKIE_LENGTH 4096
 
-/*
- * Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value, they
- * cannot be used to clear bits.
- */
+    /*
+     * Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value, they
+     * cannot be used to clear bits.
+     */
 
-uint64_t SSL_CTX_get_options(const SSL_CTX *ctx);
-uint64_t SSL_get_options(const SSL *s);
-uint64_t SSL_CTX_clear_options(SSL_CTX *ctx, uint64_t op);
-uint64_t SSL_clear_options(SSL *s, uint64_t op);
-uint64_t SSL_CTX_set_options(SSL_CTX *ctx, uint64_t op);
-uint64_t SSL_set_options(SSL *s, uint64_t op);
-
-# define SSL_CTX_set_mode(ctx,op) \
-        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,(op),NULL)
-# define SSL_CTX_clear_mode(ctx,op) \
-        SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_MODE,(op),NULL)
-# define SSL_CTX_get_mode(ctx) \
-        SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,0,NULL)
-# define SSL_clear_mode(ssl,op) \
-        SSL_ctrl((ssl),SSL_CTRL_CLEAR_MODE,(op),NULL)
-# define SSL_set_mode(ssl,op) \
-        SSL_ctrl((ssl),SSL_CTRL_MODE,(op),NULL)
-# define SSL_get_mode(ssl) \
-        SSL_ctrl((ssl),SSL_CTRL_MODE,0,NULL)
-# define SSL_set_mtu(ssl, mtu) \
-        SSL_ctrl((ssl),SSL_CTRL_SET_MTU,(mtu),NULL)
-# define DTLS_set_link_mtu(ssl, mtu) \
-        SSL_ctrl((ssl),DTLS_CTRL_SET_LINK_MTU,(mtu),NULL)
-# define DTLS_get_link_min_mtu(ssl) \
-        SSL_ctrl((ssl),DTLS_CTRL_GET_LINK_MIN_MTU,0,NULL)
-
-# define SSL_get_secure_renegotiation_support(ssl) \
-        SSL_ctrl((ssl), SSL_CTRL_GET_RI_SUPPORT, 0, NULL)
-
-# define SSL_CTX_set_cert_flags(ctx,op) \
-        SSL_CTX_ctrl((ctx),SSL_CTRL_CERT_FLAGS,(op),NULL)
-# define SSL_set_cert_flags(s,op) \
-        SSL_ctrl((s),SSL_CTRL_CERT_FLAGS,(op),NULL)
-# define SSL_CTX_clear_cert_flags(ctx,op) \
-        SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL)
-# define SSL_clear_cert_flags(s,op) \
-        SSL_ctrl((s),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL)
-
-void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
-                              void (*cb) (int write_p, int version,
-                                          int content_type, const void *buf,
-                                          size_t len, SSL *ssl, void *arg));
-void SSL_set_msg_callback(SSL *ssl,
-                          void (*cb) (int write_p, int version,
-                                      int content_type, const void *buf,
-                                      size_t len, SSL *ssl, void *arg));
-# define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
-# define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
-
-# define SSL_get_extms_support(s) \
-        SSL_ctrl((s),SSL_CTRL_GET_EXTMS_SUPPORT,0,NULL)
-
-# ifndef OPENSSL_NO_SRP
+    uint64_t SSL_CTX_get_options(const SSL_CTX* ctx);
+    uint64_t SSL_get_options(const SSL* s);
+    uint64_t SSL_CTX_clear_options(SSL_CTX* ctx, uint64_t op);
+    uint64_t SSL_clear_options(SSL* s, uint64_t op);
+    uint64_t SSL_CTX_set_options(SSL_CTX* ctx, uint64_t op);
+    uint64_t SSL_set_options(SSL* s, uint64_t op);
+
+#define SSL_CTX_set_mode(ctx, op) \
+    SSL_CTX_ctrl((ctx), SSL_CTRL_MODE, (op), NULL)
+#define SSL_CTX_clear_mode(ctx, op) \
+    SSL_CTX_ctrl((ctx), SSL_CTRL_CLEAR_MODE, (op), NULL)
+#define SSL_CTX_get_mode(ctx) \
+    SSL_CTX_ctrl((ctx), SSL_CTRL_MODE, 0, NULL)
+#define SSL_clear_mode(ssl, op) \
+    SSL_ctrl((ssl), SSL_CTRL_CLEAR_MODE, (op), NULL)
+#define SSL_set_mode(ssl, op) \
+    SSL_ctrl((ssl), SSL_CTRL_MODE, (op), NULL)
+#define SSL_get_mode(ssl) \
+    SSL_ctrl((ssl), SSL_CTRL_MODE, 0, NULL)
+#define SSL_set_mtu(ssl, mtu) \
+    SSL_ctrl((ssl), SSL_CTRL_SET_MTU, (mtu), NULL)
+#define DTLS_set_link_mtu(ssl, mtu) \
+    SSL_ctrl((ssl), DTLS_CTRL_SET_LINK_MTU, (mtu), NULL)
+#define DTLS_get_link_min_mtu(ssl) \
+    SSL_ctrl((ssl), DTLS_CTRL_GET_LINK_MIN_MTU, 0, NULL)
+
+#define SSL_get_secure_renegotiation_support(ssl) \
+    SSL_ctrl((ssl), SSL_CTRL_GET_RI_SUPPORT, 0, NULL)
+
+#define SSL_CTX_set_cert_flags(ctx, op) \
+    SSL_CTX_ctrl((ctx), SSL_CTRL_CERT_FLAGS, (op), NULL)
+#define SSL_set_cert_flags(s, op) \
+    SSL_ctrl((s), SSL_CTRL_CERT_FLAGS, (op), NULL)
+#define SSL_CTX_clear_cert_flags(ctx, op) \
+    SSL_CTX_ctrl((ctx), SSL_CTRL_CLEAR_CERT_FLAGS, (op), NULL)
+#define SSL_clear_cert_flags(s, op) \
+    SSL_ctrl((s), SSL_CTRL_CLEAR_CERT_FLAGS, (op), NULL)
+
+    void SSL_CTX_set_msg_callback(SSL_CTX* ctx, void (*cb)(int write_p, int version, int content_type, const void* buf, size_t len, SSL* ssl, void* arg));
+    void SSL_set_msg_callback(SSL* ssl, void (*cb)(int write_p, int version, int content_type, const void* buf, size_t len, SSL* ssl, void* arg));
+#define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
+#define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))
+
+#define SSL_get_extms_support(s) \
+    SSL_ctrl((s), SSL_CTRL_GET_EXTMS_SUPPORT, 0, NULL)
+
+#ifndef OPENSSL_NO_SRP
 /* see tls_srp.c */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 __owur int SSL_SRP_CTX_init(SSL *s);
-OSSL_DEPRECATEDIN_3_0 __owur int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 int SSL_SRP_CTX_free(SSL *ctx);
-OSSL_DEPRECATEDIN_3_0 int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx);
-OSSL_DEPRECATEDIN_3_0 __owur int SSL_srp_server_param_with_username(SSL *s,
-                                                                    int *ad);
-OSSL_DEPRECATEDIN_3_0 __owur int SRP_Calc_A_param(SSL *s);
-#  endif
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 __owur int SSL_SRP_CTX_init(SSL* s);
+    OSSL_DEPRECATEDIN_3_0 __owur int SSL_CTX_SRP_CTX_init(SSL_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 int SSL_SRP_CTX_free(SSL* ctx);
+    OSSL_DEPRECATEDIN_3_0 int SSL_CTX_SRP_CTX_free(SSL_CTX* ctx);
+    OSSL_DEPRECATEDIN_3_0 __owur int SSL_srp_server_param_with_username(SSL* s, int* ad);
+    OSSL_DEPRECATEDIN_3_0 __owur int SRP_Calc_A_param(SSL* s);
+#endif
+#endif
 
 /* 100k max cert list */
-# define SSL_MAX_CERT_LIST_DEFAULT (1024*100)
+#define SSL_MAX_CERT_LIST_DEFAULT (1024 * 100)
 
-# define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT      (1024*20)
+#define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT (1024 * 20)
 
-/*
- * This callback type is used inside SSL_CTX, SSL, and in the functions that
- * set them. It is used to override the generation of SSL/TLS session IDs in
- * a server. Return value should be zero on an error, non-zero to proceed.
- * Also, callbacks should themselves check if the id they generate is unique
- * otherwise the SSL handshake will fail with an error - callbacks can do
- * this using the 'ssl' value they're passed by;
- * SSL_has_matching_session_id(ssl, id, *id_len) The length value passed in
- * is set at the maximum size the session ID can be. In SSLv3/TLSv1 it is 32
- * bytes. The callback can alter this length to be less if desired. It is
- * also an error for the callback to set the size to zero.
- */
-typedef int (*GEN_SESSION_CB) (SSL *ssl, unsigned char *id,
-                               unsigned int *id_len);
-
-# define SSL_SESS_CACHE_OFF                      0x0000
-# define SSL_SESS_CACHE_CLIENT                   0x0001
-# define SSL_SESS_CACHE_SERVER                   0x0002
-# define SSL_SESS_CACHE_BOTH     (SSL_SESS_CACHE_CLIENT|SSL_SESS_CACHE_SERVER)
-# define SSL_SESS_CACHE_NO_AUTO_CLEAR            0x0080
+    /*
+     * This callback type is used inside SSL_CTX, SSL, and in the functions that
+     * set them. It is used to override the generation of SSL/TLS session IDs in
+     * a server. Return value should be zero on an error, non-zero to proceed.
+     * Also, callbacks should themselves check if the id they generate is unique
+     * otherwise the SSL handshake will fail with an error - callbacks can do
+     * this using the 'ssl' value they're passed by;
+     * SSL_has_matching_session_id(ssl, id, *id_len) The length value passed in
+     * is set at the maximum size the session ID can be. In SSLv3/TLSv1 it is 32
+     * bytes. The callback can alter this length to be less if desired. It is
+     * also an error for the callback to set the size to zero.
+     */
+    typedef int (*GEN_SESSION_CB)(SSL* ssl, unsigned char* id, unsigned int* id_len);
+
+#define SSL_SESS_CACHE_OFF 0x0000
+#define SSL_SESS_CACHE_CLIENT 0x0001
+#define SSL_SESS_CACHE_SERVER 0x0002
+#define SSL_SESS_CACHE_BOTH (SSL_SESS_CACHE_CLIENT | SSL_SESS_CACHE_SERVER)
+#define SSL_SESS_CACHE_NO_AUTO_CLEAR 0x0080
 /* enough comments already ... see SSL_CTX_set_session_cache_mode(3) */
-# define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP       0x0100
-# define SSL_SESS_CACHE_NO_INTERNAL_STORE        0x0200
-# define SSL_SESS_CACHE_NO_INTERNAL \
-        (SSL_SESS_CACHE_NO_INTERNAL_LOOKUP|SSL_SESS_CACHE_NO_INTERNAL_STORE)
-# define SSL_SESS_CACHE_UPDATE_TIME              0x0400
-
-LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx);
-# define SSL_CTX_sess_number(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_NUMBER,0,NULL)
-# define SSL_CTX_sess_connect(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT,0,NULL)
-# define SSL_CTX_sess_connect_good(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_GOOD,0,NULL)
-# define SSL_CTX_sess_connect_renegotiate(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_RENEGOTIATE,0,NULL)
-# define SSL_CTX_sess_accept(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT,0,NULL)
-# define SSL_CTX_sess_accept_renegotiate(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,0,NULL)
-# define SSL_CTX_sess_accept_good(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_GOOD,0,NULL)
-# define SSL_CTX_sess_hits(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_HIT,0,NULL)
-# define SSL_CTX_sess_cb_hits(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CB_HIT,0,NULL)
-# define SSL_CTX_sess_misses(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_MISSES,0,NULL)
-# define SSL_CTX_sess_timeouts(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_TIMEOUTS,0,NULL)
-# define SSL_CTX_sess_cache_full(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL)
-
-void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
-                             int (*new_session_cb) (struct ssl_st *ssl,
-                                                    SSL_SESSION *sess));
-int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,
-                                              SSL_SESSION *sess);
-void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
-                                void (*remove_session_cb) (struct ssl_ctx_st
-                                                           *ctx,
-                                                           SSL_SESSION *sess));
-void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (struct ssl_ctx_st *ctx,
-                                                  SSL_SESSION *sess);
-void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
-                             SSL_SESSION *(*get_session_cb) (struct ssl_st
-                                                             *ssl,
-                                                             const unsigned char
-                                                             *data, int len,
-                                                             int *copy));
-SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,
-                                                       const unsigned char *data,
-                                                       int len, int *copy);
-void SSL_CTX_set_info_callback(SSL_CTX *ctx,
-                               void (*cb) (const SSL *ssl, int type, int val));
-void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type,
-                                                 int val);
-void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
-                                int (*client_cert_cb) (SSL *ssl, X509 **x509,
-                                                       EVP_PKEY **pkey));
-int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509,
-                                                 EVP_PKEY **pkey);
-# ifndef OPENSSL_NO_ENGINE
-__owur int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e);
-# endif
-void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
-                                    int (*app_gen_cookie_cb) (SSL *ssl,
-                                                              unsigned char
-                                                              *cookie,
-                                                              unsigned int
-                                                              *cookie_len));
-void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,
-                                  int (*app_verify_cookie_cb) (SSL *ssl,
-                                                               const unsigned
-                                                               char *cookie,
-                                                               unsigned int
-                                                               cookie_len));
-
-void SSL_CTX_set_stateless_cookie_generate_cb(
-    SSL_CTX *ctx,
-    int (*gen_stateless_cookie_cb) (SSL *ssl,
-                                    unsigned char *cookie,
-                                    size_t *cookie_len));
-void SSL_CTX_set_stateless_cookie_verify_cb(
-    SSL_CTX *ctx,
-    int (*verify_stateless_cookie_cb) (SSL *ssl,
-                                       const unsigned char *cookie,
-                                       size_t cookie_len));
-# ifndef OPENSSL_NO_NEXTPROTONEG
-
-typedef int (*SSL_CTX_npn_advertised_cb_func)(SSL *ssl,
-                                              const unsigned char **out,
-                                              unsigned int *outlen,
-                                              void *arg);
-void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *s,
-                                           SSL_CTX_npn_advertised_cb_func cb,
-                                           void *arg);
-#  define SSL_CTX_set_npn_advertised_cb SSL_CTX_set_next_protos_advertised_cb
-
-typedef int (*SSL_CTX_npn_select_cb_func)(SSL *s,
-                                          unsigned char **out,
-                                          unsigned char *outlen,
-                                          const unsigned char *in,
-                                          unsigned int inlen,
-                                          void *arg);
-void SSL_CTX_set_next_proto_select_cb(SSL_CTX *s,
-                                      SSL_CTX_npn_select_cb_func cb,
-                                      void *arg);
-#  define SSL_CTX_set_npn_select_cb SSL_CTX_set_next_proto_select_cb
-
-void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
-                                    unsigned *len);
-#  define SSL_get0_npn_negotiated SSL_get0_next_proto_negotiated
-# endif
-
-__owur int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
-                                 const unsigned char *in, unsigned int inlen,
-                                 const unsigned char *client,
-                                 unsigned int client_len);
-
-# define OPENSSL_NPN_UNSUPPORTED 0
-# define OPENSSL_NPN_NEGOTIATED  1
-# define OPENSSL_NPN_NO_OVERLAP  2
-
-__owur int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
-                                   unsigned int protos_len);
-__owur int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
-                               unsigned int protos_len);
-typedef int (*SSL_CTX_alpn_select_cb_func)(SSL *ssl,
-                                           const unsigned char **out,
-                                           unsigned char *outlen,
-                                           const unsigned char *in,
-                                           unsigned int inlen,
-                                           void *arg);
-void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
-                                SSL_CTX_alpn_select_cb_func cb,
-                                void *arg);
-void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
-                            unsigned int *len);
-
-# ifndef OPENSSL_NO_PSK
+#define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP 0x0100
+#define SSL_SESS_CACHE_NO_INTERNAL_STORE 0x0200
+#define SSL_SESS_CACHE_NO_INTERNAL \
+    (SSL_SESS_CACHE_NO_INTERNAL_LOOKUP | SSL_SESS_CACHE_NO_INTERNAL_STORE)
+#define SSL_SESS_CACHE_UPDATE_TIME 0x0400
+
+    LHASH_OF(SSL_SESSION) * SSL_CTX_sessions(SSL_CTX* ctx);
+#define SSL_CTX_sess_number(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_NUMBER, 0, NULL)
+#define SSL_CTX_sess_connect(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_CONNECT, 0, NULL)
+#define SSL_CTX_sess_connect_good(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_CONNECT_GOOD, 0, NULL)
+#define SSL_CTX_sess_connect_renegotiate(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_CONNECT_RENEGOTIATE, 0, NULL)
+#define SSL_CTX_sess_accept(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_ACCEPT, 0, NULL)
+#define SSL_CTX_sess_accept_renegotiate(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_ACCEPT_RENEGOTIATE, 0, NULL)
+#define SSL_CTX_sess_accept_good(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_ACCEPT_GOOD, 0, NULL)
+#define SSL_CTX_sess_hits(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_HIT, 0, NULL)
+#define SSL_CTX_sess_cb_hits(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_CB_HIT, 0, NULL)
+#define SSL_CTX_sess_misses(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_MISSES, 0, NULL)
+#define SSL_CTX_sess_timeouts(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_TIMEOUTS, 0, NULL)
+#define SSL_CTX_sess_cache_full(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SESS_CACHE_FULL, 0, NULL)
+
+    void SSL_CTX_sess_set_new_cb(SSL_CTX* ctx, int (*new_session_cb)(struct ssl_st* ssl, SSL_SESSION* sess));
+    int (*SSL_CTX_sess_get_new_cb(SSL_CTX* ctx))(struct ssl_st* ssl, SSL_SESSION* sess);
+    void SSL_CTX_sess_set_remove_cb(SSL_CTX* ctx, void (*remove_session_cb)(struct ssl_ctx_st* ctx, SSL_SESSION* sess));
+    void (*SSL_CTX_sess_get_remove_cb(SSL_CTX* ctx))(struct ssl_ctx_st* ctx, SSL_SESSION* sess);
+    void SSL_CTX_sess_set_get_cb(SSL_CTX* ctx, SSL_SESSION* (*get_session_cb)(struct ssl_st* ssl, const unsigned char* data, int len, int* copy));
+    SSL_SESSION* (*SSL_CTX_sess_get_get_cb(SSL_CTX* ctx))(struct ssl_st* ssl, const unsigned char* data, int len, int* copy);
+    void SSL_CTX_set_info_callback(SSL_CTX* ctx, void (*cb)(const SSL* ssl, int type, int val));
+    void (*SSL_CTX_get_info_callback(SSL_CTX* ctx))(const SSL* ssl, int type, int val);
+    void SSL_CTX_set_client_cert_cb(SSL_CTX* ctx, int (*client_cert_cb)(SSL* ssl, X509** x509, EVP_PKEY** pkey));
+    int (*SSL_CTX_get_client_cert_cb(SSL_CTX* ctx))(SSL* ssl, X509** x509, EVP_PKEY** pkey);
+#ifndef OPENSSL_NO_ENGINE
+    __owur int SSL_CTX_set_client_cert_engine(SSL_CTX* ctx, ENGINE* e);
+#endif
+    void SSL_CTX_set_cookie_generate_cb(SSL_CTX* ctx, int (*app_gen_cookie_cb)(SSL* ssl, unsigned char* cookie, unsigned int* cookie_len));
+    void SSL_CTX_set_cookie_verify_cb(SSL_CTX* ctx, int (*app_verify_cookie_cb)(SSL* ssl, const unsigned char* cookie, unsigned int cookie_len));
+
+    void SSL_CTX_set_stateless_cookie_generate_cb(
+        SSL_CTX* ctx,
+        int (*gen_stateless_cookie_cb)(SSL* ssl, unsigned char* cookie, size_t* cookie_len)
+    );
+    void SSL_CTX_set_stateless_cookie_verify_cb(
+        SSL_CTX* ctx,
+        int (*verify_stateless_cookie_cb)(SSL* ssl, const unsigned char* cookie, size_t cookie_len)
+    );
+#ifndef OPENSSL_NO_NEXTPROTONEG
+
+    typedef int (*SSL_CTX_npn_advertised_cb_func)(SSL* ssl, const unsigned char** out, unsigned int* outlen, void* arg);
+    void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX* s, SSL_CTX_npn_advertised_cb_func cb, void* arg);
+#define SSL_CTX_set_npn_advertised_cb SSL_CTX_set_next_protos_advertised_cb
+
+    typedef int (*SSL_CTX_npn_select_cb_func)(SSL* s, unsigned char** out, unsigned char* outlen, const unsigned char* in, unsigned int inlen, void* arg);
+    void SSL_CTX_set_next_proto_select_cb(SSL_CTX* s, SSL_CTX_npn_select_cb_func cb, void* arg);
+#define SSL_CTX_set_npn_select_cb SSL_CTX_set_next_proto_select_cb
+
+    void SSL_get0_next_proto_negotiated(const SSL* s, const unsigned char** data, unsigned* len);
+#define SSL_get0_npn_negotiated SSL_get0_next_proto_negotiated
+#endif
+
+    __owur int SSL_select_next_proto(unsigned char** out, unsigned char* outlen, const unsigned char* in, unsigned int inlen, const unsigned char* client, unsigned int client_len);
+
+#define OPENSSL_NPN_UNSUPPORTED 0
+#define OPENSSL_NPN_NEGOTIATED 1
+#define OPENSSL_NPN_NO_OVERLAP 2
+
+    __owur int SSL_CTX_set_alpn_protos(SSL_CTX* ctx, const unsigned char* protos, unsigned int protos_len);
+    __owur int SSL_set_alpn_protos(SSL* ssl, const unsigned char* protos, unsigned int protos_len);
+    typedef int (*SSL_CTX_alpn_select_cb_func)(SSL* ssl, const unsigned char** out, unsigned char* outlen, const unsigned char* in, unsigned int inlen, void* arg);
+    void SSL_CTX_set_alpn_select_cb(SSL_CTX* ctx, SSL_CTX_alpn_select_cb_func cb, void* arg);
+    void SSL_get0_alpn_selected(const SSL* ssl, const unsigned char** data, unsigned int* len);
+
+#ifndef OPENSSL_NO_PSK
 /*
  * the maximum length of the buffer given to callbacks containing the
  * resulting identity/psk
  */
-#  define PSK_MAX_IDENTITY_LEN 256
-#  define PSK_MAX_PSK_LEN 512
-typedef unsigned int (*SSL_psk_client_cb_func)(SSL *ssl,
-                                               const char *hint,
-                                               char *identity,
-                                               unsigned int max_identity_len,
-                                               unsigned char *psk,
-                                               unsigned int max_psk_len);
-void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb);
-void SSL_set_psk_client_callback(SSL *ssl, SSL_psk_client_cb_func cb);
-
-typedef unsigned int (*SSL_psk_server_cb_func)(SSL *ssl,
-                                               const char *identity,
-                                               unsigned char *psk,
-                                               unsigned int max_psk_len);
-void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb);
-void SSL_set_psk_server_callback(SSL *ssl, SSL_psk_server_cb_func cb);
-
-__owur int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint);
-__owur int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint);
-const char *SSL_get_psk_identity_hint(const SSL *s);
-const char *SSL_get_psk_identity(const SSL *s);
-# endif
-
-typedef int (*SSL_psk_find_session_cb_func)(SSL *ssl,
-                                            const unsigned char *identity,
-                                            size_t identity_len,
-                                            SSL_SESSION **sess);
-typedef int (*SSL_psk_use_session_cb_func)(SSL *ssl, const EVP_MD *md,
-                                           const unsigned char **id,
-                                           size_t *idlen,
-                                           SSL_SESSION **sess);
-
-void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb);
-void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx,
-                                           SSL_psk_find_session_cb_func cb);
-void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb);
-void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx,
-                                          SSL_psk_use_session_cb_func cb);
-
-/* Register callbacks to handle custom TLS Extensions for client or server. */
-
-__owur int SSL_CTX_has_client_custom_ext(const SSL_CTX *ctx,
-                                         unsigned int ext_type);
-
-__owur int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx,
-                                         unsigned int ext_type,
-                                         custom_ext_add_cb add_cb,
-                                         custom_ext_free_cb free_cb,
-                                         void *add_arg,
-                                         custom_ext_parse_cb parse_cb,
-                                         void *parse_arg);
-
-__owur int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx,
-                                         unsigned int ext_type,
-                                         custom_ext_add_cb add_cb,
-                                         custom_ext_free_cb free_cb,
-                                         void *add_arg,
-                                         custom_ext_parse_cb parse_cb,
-                                         void *parse_arg);
-
-__owur int SSL_CTX_add_custom_ext(SSL_CTX *ctx, unsigned int ext_type,
-                                  unsigned int context,
-                                  SSL_custom_ext_add_cb_ex add_cb,
-                                  SSL_custom_ext_free_cb_ex free_cb,
-                                  void *add_arg,
-                                  SSL_custom_ext_parse_cb_ex parse_cb,
-                                  void *parse_arg);
-
-__owur int SSL_extension_supported(unsigned int ext_type);
-
-# define SSL_NOTHING            1
-# define SSL_WRITING            2
-# define SSL_READING            3
-# define SSL_X509_LOOKUP        4
-# define SSL_ASYNC_PAUSED       5
-# define SSL_ASYNC_NO_JOBS      6
-# define SSL_CLIENT_HELLO_CB    7
-# define SSL_RETRY_VERIFY       8
+#define PSK_MAX_IDENTITY_LEN 256
+#define PSK_MAX_PSK_LEN 512
+    typedef unsigned int (*SSL_psk_client_cb_func)(SSL* ssl, const char* hint, char* identity, unsigned int max_identity_len, unsigned char* psk, unsigned int max_psk_len);
+    void SSL_CTX_set_psk_client_callback(SSL_CTX* ctx, SSL_psk_client_cb_func cb);
+    void SSL_set_psk_client_callback(SSL* ssl, SSL_psk_client_cb_func cb);
+
+    typedef unsigned int (*SSL_psk_server_cb_func)(SSL* ssl, const char* identity, unsigned char* psk, unsigned int max_psk_len);
+    void SSL_CTX_set_psk_server_callback(SSL_CTX* ctx, SSL_psk_server_cb_func cb);
+    void SSL_set_psk_server_callback(SSL* ssl, SSL_psk_server_cb_func cb);
+
+    __owur int SSL_CTX_use_psk_identity_hint(SSL_CTX* ctx, const char* identity_hint);
+    __owur int SSL_use_psk_identity_hint(SSL* s, const char* identity_hint);
+    const char* SSL_get_psk_identity_hint(const SSL* s);
+    const char* SSL_get_psk_identity(const SSL* s);
+#endif
+
+    typedef int (*SSL_psk_find_session_cb_func)(SSL* ssl, const unsigned char* identity, size_t identity_len, SSL_SESSION** sess);
+    typedef int (*SSL_psk_use_session_cb_func)(SSL* ssl, const EVP_MD* md, const unsigned char** id, size_t* idlen, SSL_SESSION** sess);
+
+    void SSL_set_psk_find_session_callback(SSL* s, SSL_psk_find_session_cb_func cb);
+    void SSL_CTX_set_psk_find_session_callback(SSL_CTX* ctx, SSL_psk_find_session_cb_func cb);
+    void SSL_set_psk_use_session_callback(SSL* s, SSL_psk_use_session_cb_func cb);
+    void SSL_CTX_set_psk_use_session_callback(SSL_CTX* ctx, SSL_psk_use_session_cb_func cb);
+
+    /* Register callbacks to handle custom TLS Extensions for client or server. */
+
+    __owur int SSL_CTX_has_client_custom_ext(const SSL_CTX* ctx, unsigned int ext_type);
+
+    __owur int SSL_CTX_add_client_custom_ext(SSL_CTX* ctx, unsigned int ext_type, custom_ext_add_cb add_cb, custom_ext_free_cb free_cb, void* add_arg, custom_ext_parse_cb parse_cb, void* parse_arg);
+
+    __owur int SSL_CTX_add_server_custom_ext(SSL_CTX* ctx, unsigned int ext_type, custom_ext_add_cb add_cb, custom_ext_free_cb free_cb, void* add_arg, custom_ext_parse_cb parse_cb, void* parse_arg);
+
+    __owur int SSL_CTX_add_custom_ext(SSL_CTX* ctx, unsigned int ext_type, unsigned int context, SSL_custom_ext_add_cb_ex add_cb, SSL_custom_ext_free_cb_ex free_cb, void* add_arg, SSL_custom_ext_parse_cb_ex parse_cb, void* parse_arg);
+
+    __owur int SSL_extension_supported(unsigned int ext_type);
+
+#define SSL_NOTHING 1
+#define SSL_WRITING 2
+#define SSL_READING 3
+#define SSL_X509_LOOKUP 4
+#define SSL_ASYNC_PAUSED 5
+#define SSL_ASYNC_NO_JOBS 6
+#define SSL_CLIENT_HELLO_CB 7
+#define SSL_RETRY_VERIFY 8
 
 /* These will only be used when doing non-blocking IO */
-# define SSL_want_nothing(s)         (SSL_want(s) == SSL_NOTHING)
-# define SSL_want_read(s)            (SSL_want(s) == SSL_READING)
-# define SSL_want_write(s)           (SSL_want(s) == SSL_WRITING)
-# define SSL_want_x509_lookup(s)     (SSL_want(s) == SSL_X509_LOOKUP)
-# define SSL_want_retry_verify(s)    (SSL_want(s) == SSL_RETRY_VERIFY)
-# define SSL_want_async(s)           (SSL_want(s) == SSL_ASYNC_PAUSED)
-# define SSL_want_async_job(s)       (SSL_want(s) == SSL_ASYNC_NO_JOBS)
-# define SSL_want_client_hello_cb(s) (SSL_want(s) == SSL_CLIENT_HELLO_CB)
-
-# define SSL_MAC_FLAG_READ_MAC_STREAM 1
-# define SSL_MAC_FLAG_WRITE_MAC_STREAM 2
-# define SSL_MAC_FLAG_READ_MAC_TLSTREE 4
-# define SSL_MAC_FLAG_WRITE_MAC_TLSTREE 8
+#define SSL_want_nothing(s) (SSL_want(s) == SSL_NOTHING)
+#define SSL_want_read(s) (SSL_want(s) == SSL_READING)
+#define SSL_want_write(s) (SSL_want(s) == SSL_WRITING)
+#define SSL_want_x509_lookup(s) (SSL_want(s) == SSL_X509_LOOKUP)
+#define SSL_want_retry_verify(s) (SSL_want(s) == SSL_RETRY_VERIFY)
+#define SSL_want_async(s) (SSL_want(s) == SSL_ASYNC_PAUSED)
+#define SSL_want_async_job(s) (SSL_want(s) == SSL_ASYNC_NO_JOBS)
+#define SSL_want_client_hello_cb(s) (SSL_want(s) == SSL_CLIENT_HELLO_CB)
+
+#define SSL_MAC_FLAG_READ_MAC_STREAM 1
+#define SSL_MAC_FLAG_WRITE_MAC_STREAM 2
+#define SSL_MAC_FLAG_READ_MAC_TLSTREE 4
+#define SSL_MAC_FLAG_WRITE_MAC_TLSTREE 8
 
-/*
- * A callback for logging out TLS key material. This callback should log out
- * |line| followed by a newline.
- */
-typedef void (*SSL_CTX_keylog_cb_func)(const SSL *ssl, const char *line);
+    /*
+     * A callback for logging out TLS key material. This callback should log out
+     * |line| followed by a newline.
+     */
+    typedef void (*SSL_CTX_keylog_cb_func)(const SSL* ssl, const char* line);
 
-/*
- * SSL_CTX_set_keylog_callback configures a callback to log key material. This
- * is intended for debugging use with tools like Wireshark. The cb function
- * should log line followed by a newline.
- */
-void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb);
+    /*
+     * SSL_CTX_set_keylog_callback configures a callback to log key material. This
+     * is intended for debugging use with tools like Wireshark. The cb function
+     * should log line followed by a newline.
+     */
+    void SSL_CTX_set_keylog_callback(SSL_CTX* ctx, SSL_CTX_keylog_cb_func cb);
 
-/*
- * SSL_CTX_get_keylog_callback returns the callback configured by
- * SSL_CTX_set_keylog_callback.
- */
-SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx);
+    /*
+     * SSL_CTX_get_keylog_callback returns the callback configured by
+     * SSL_CTX_set_keylog_callback.
+     */
+    SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX* ctx);
 
-int SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data);
-uint32_t SSL_CTX_get_max_early_data(const SSL_CTX *ctx);
-int SSL_set_max_early_data(SSL *s, uint32_t max_early_data);
-uint32_t SSL_get_max_early_data(const SSL *s);
-int SSL_CTX_set_recv_max_early_data(SSL_CTX *ctx, uint32_t recv_max_early_data);
-uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX *ctx);
-int SSL_set_recv_max_early_data(SSL *s, uint32_t recv_max_early_data);
-uint32_t SSL_get_recv_max_early_data(const SSL *s);
+    int SSL_CTX_set_max_early_data(SSL_CTX* ctx, uint32_t max_early_data);
+    uint32_t SSL_CTX_get_max_early_data(const SSL_CTX* ctx);
+    int SSL_set_max_early_data(SSL* s, uint32_t max_early_data);
+    uint32_t SSL_get_max_early_data(const SSL* s);
+    int SSL_CTX_set_recv_max_early_data(SSL_CTX* ctx, uint32_t recv_max_early_data);
+    uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX* ctx);
+    int SSL_set_recv_max_early_data(SSL* s, uint32_t recv_max_early_data);
+    uint32_t SSL_get_recv_max_early_data(const SSL* s);
 
 #ifdef __cplusplus
 }
 #endif
 
-# include <openssl/ssl2.h>
-# include <openssl/ssl3.h>
-# include <openssl/tls1.h>      /* This is mostly sslv3 with a few tweaks */
-# include <openssl/dtls1.h>     /* Datagram TLS */
-# include <openssl/srtp.h>      /* Support for the use_srtp extension */
+#include <openssl/ssl2.h>
+#include <openssl/ssl3.h>
+#include <openssl/tls1.h>  /* This is mostly sslv3 with a few tweaks */
+#include <openssl/dtls1.h> /* Datagram TLS */
+#include <openssl/srtp.h>  /* Support for the use_srtp extension */
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-/*
- * These need to be after the above set of includes due to a compiler bug
- * in VisualStudio 2015
- */
-SKM_DEFINE_STACK_OF_INTERNAL(SSL_CIPHER, const SSL_CIPHER, SSL_CIPHER)
+    /*
+     * These need to be after the above set of includes due to a compiler bug
+     * in VisualStudio 2015
+     */
+    SKM_DEFINE_STACK_OF_INTERNAL(SSL_CIPHER, const SSL_CIPHER, SSL_CIPHER)
 #define sk_SSL_CIPHER_num(sk) OPENSSL_sk_num(ossl_check_const_SSL_CIPHER_sk_type(sk))
-#define sk_SSL_CIPHER_value(sk, idx) ((const SSL_CIPHER *)OPENSSL_sk_value(ossl_check_const_SSL_CIPHER_sk_type(sk), (idx)))
-#define sk_SSL_CIPHER_new(cmp) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new(ossl_check_SSL_CIPHER_compfunc_type(cmp)))
-#define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new_null())
-#define sk_SSL_CIPHER_new_reserve(cmp, n) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_new_reserve(ossl_check_SSL_CIPHER_compfunc_type(cmp), (n)))
+#define sk_SSL_CIPHER_value(sk, idx) ((const SSL_CIPHER*)OPENSSL_sk_value(ossl_check_const_SSL_CIPHER_sk_type(sk), (idx)))
+#define sk_SSL_CIPHER_new(cmp) ((STACK_OF(SSL_CIPHER)*)OPENSSL_sk_new(ossl_check_SSL_CIPHER_compfunc_type(cmp)))
+#define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER)*)OPENSSL_sk_new_null())
+#define sk_SSL_CIPHER_new_reserve(cmp, n) ((STACK_OF(SSL_CIPHER)*)OPENSSL_sk_new_reserve(ossl_check_SSL_CIPHER_compfunc_type(cmp), (n)))
 #define sk_SSL_CIPHER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SSL_CIPHER_sk_type(sk), (n))
 #define sk_SSL_CIPHER_free(sk) OPENSSL_sk_free(ossl_check_SSL_CIPHER_sk_type(sk))
 #define sk_SSL_CIPHER_zero(sk) OPENSSL_sk_zero(ossl_check_SSL_CIPHER_sk_type(sk))
-#define sk_SSL_CIPHER_delete(sk, i) ((const SSL_CIPHER *)OPENSSL_sk_delete(ossl_check_SSL_CIPHER_sk_type(sk), (i)))
-#define sk_SSL_CIPHER_delete_ptr(sk, ptr) ((const SSL_CIPHER *)OPENSSL_sk_delete_ptr(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr)))
+#define sk_SSL_CIPHER_delete(sk, i) ((const SSL_CIPHER*)OPENSSL_sk_delete(ossl_check_SSL_CIPHER_sk_type(sk), (i)))
+#define sk_SSL_CIPHER_delete_ptr(sk, ptr) ((const SSL_CIPHER*)OPENSSL_sk_delete_ptr(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr)))
 #define sk_SSL_CIPHER_push(sk, ptr) OPENSSL_sk_push(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
 #define sk_SSL_CIPHER_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
-#define sk_SSL_CIPHER_pop(sk) ((const SSL_CIPHER *)OPENSSL_sk_pop(ossl_check_SSL_CIPHER_sk_type(sk)))
-#define sk_SSL_CIPHER_shift(sk) ((const SSL_CIPHER *)OPENSSL_sk_shift(ossl_check_SSL_CIPHER_sk_type(sk)))
-#define sk_SSL_CIPHER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_CIPHER_sk_type(sk),ossl_check_SSL_CIPHER_freefunc_type(freefunc))
+#define sk_SSL_CIPHER_pop(sk) ((const SSL_CIPHER*)OPENSSL_sk_pop(ossl_check_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_shift(sk) ((const SSL_CIPHER*)OPENSSL_sk_shift(ossl_check_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_freefunc_type(freefunc))
 #define sk_SSL_CIPHER_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr), (idx))
-#define sk_SSL_CIPHER_set(sk, idx, ptr) ((const SSL_CIPHER *)OPENSSL_sk_set(ossl_check_SSL_CIPHER_sk_type(sk), (idx), ossl_check_SSL_CIPHER_type(ptr)))
+#define sk_SSL_CIPHER_set(sk, idx, ptr) ((const SSL_CIPHER*)OPENSSL_sk_set(ossl_check_SSL_CIPHER_sk_type(sk), (idx), ossl_check_SSL_CIPHER_type(ptr)))
 #define sk_SSL_CIPHER_find(sk, ptr) OPENSSL_sk_find(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
 #define sk_SSL_CIPHER_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr))
 #define sk_SSL_CIPHER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr), pnum)
 #define sk_SSL_CIPHER_sort(sk) OPENSSL_sk_sort(ossl_check_SSL_CIPHER_sk_type(sk))
 #define sk_SSL_CIPHER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SSL_CIPHER_sk_type(sk))
-#define sk_SSL_CIPHER_dup(sk) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_dup(ossl_check_const_SSL_CIPHER_sk_type(sk)))
-#define sk_SSL_CIPHER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_deep_copy(ossl_check_const_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_copyfunc_type(copyfunc), ossl_check_SSL_CIPHER_freefunc_type(freefunc)))
+#define sk_SSL_CIPHER_dup(sk) ((STACK_OF(SSL_CIPHER)*)OPENSSL_sk_dup(ossl_check_const_SSL_CIPHER_sk_type(sk)))
+#define sk_SSL_CIPHER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_CIPHER)*)OPENSSL_sk_deep_copy(ossl_check_const_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_copyfunc_type(copyfunc), ossl_check_SSL_CIPHER_freefunc_type(freefunc)))
 #define sk_SSL_CIPHER_set_cmp_func(sk, cmp) ((sk_SSL_CIPHER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(SSL_COMP, SSL_COMP, SSL_COMP)
+    SKM_DEFINE_STACK_OF_INTERNAL(SSL_COMP, SSL_COMP, SSL_COMP)
 #define sk_SSL_COMP_num(sk) OPENSSL_sk_num(ossl_check_const_SSL_COMP_sk_type(sk))
-#define sk_SSL_COMP_value(sk, idx) ((SSL_COMP *)OPENSSL_sk_value(ossl_check_const_SSL_COMP_sk_type(sk), (idx)))
-#define sk_SSL_COMP_new(cmp) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new(ossl_check_SSL_COMP_compfunc_type(cmp)))
-#define sk_SSL_COMP_new_null() ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new_null())
-#define sk_SSL_COMP_new_reserve(cmp, n) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_new_reserve(ossl_check_SSL_COMP_compfunc_type(cmp), (n)))
+#define sk_SSL_COMP_value(sk, idx) ((SSL_COMP*)OPENSSL_sk_value(ossl_check_const_SSL_COMP_sk_type(sk), (idx)))
+#define sk_SSL_COMP_new(cmp) ((STACK_OF(SSL_COMP)*)OPENSSL_sk_new(ossl_check_SSL_COMP_compfunc_type(cmp)))
+#define sk_SSL_COMP_new_null() ((STACK_OF(SSL_COMP)*)OPENSSL_sk_new_null())
+#define sk_SSL_COMP_new_reserve(cmp, n) ((STACK_OF(SSL_COMP)*)OPENSSL_sk_new_reserve(ossl_check_SSL_COMP_compfunc_type(cmp), (n)))
 #define sk_SSL_COMP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SSL_COMP_sk_type(sk), (n))
 #define sk_SSL_COMP_free(sk) OPENSSL_sk_free(ossl_check_SSL_COMP_sk_type(sk))
 #define sk_SSL_COMP_zero(sk) OPENSSL_sk_zero(ossl_check_SSL_COMP_sk_type(sk))
-#define sk_SSL_COMP_delete(sk, i) ((SSL_COMP *)OPENSSL_sk_delete(ossl_check_SSL_COMP_sk_type(sk), (i)))
-#define sk_SSL_COMP_delete_ptr(sk, ptr) ((SSL_COMP *)OPENSSL_sk_delete_ptr(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr)))
+#define sk_SSL_COMP_delete(sk, i) ((SSL_COMP*)OPENSSL_sk_delete(ossl_check_SSL_COMP_sk_type(sk), (i)))
+#define sk_SSL_COMP_delete_ptr(sk, ptr) ((SSL_COMP*)OPENSSL_sk_delete_ptr(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr)))
 #define sk_SSL_COMP_push(sk, ptr) OPENSSL_sk_push(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
 #define sk_SSL_COMP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
-#define sk_SSL_COMP_pop(sk) ((SSL_COMP *)OPENSSL_sk_pop(ossl_check_SSL_COMP_sk_type(sk)))
-#define sk_SSL_COMP_shift(sk) ((SSL_COMP *)OPENSSL_sk_shift(ossl_check_SSL_COMP_sk_type(sk)))
-#define sk_SSL_COMP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_COMP_sk_type(sk),ossl_check_SSL_COMP_freefunc_type(freefunc))
+#define sk_SSL_COMP_pop(sk) ((SSL_COMP*)OPENSSL_sk_pop(ossl_check_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_shift(sk) ((SSL_COMP*)OPENSSL_sk_shift(ossl_check_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_freefunc_type(freefunc))
 #define sk_SSL_COMP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr), (idx))
-#define sk_SSL_COMP_set(sk, idx, ptr) ((SSL_COMP *)OPENSSL_sk_set(ossl_check_SSL_COMP_sk_type(sk), (idx), ossl_check_SSL_COMP_type(ptr)))
+#define sk_SSL_COMP_set(sk, idx, ptr) ((SSL_COMP*)OPENSSL_sk_set(ossl_check_SSL_COMP_sk_type(sk), (idx), ossl_check_SSL_COMP_type(ptr)))
 #define sk_SSL_COMP_find(sk, ptr) OPENSSL_sk_find(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
 #define sk_SSL_COMP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr))
 #define sk_SSL_COMP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_type(ptr), pnum)
 #define sk_SSL_COMP_sort(sk) OPENSSL_sk_sort(ossl_check_SSL_COMP_sk_type(sk))
 #define sk_SSL_COMP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SSL_COMP_sk_type(sk))
-#define sk_SSL_COMP_dup(sk) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_dup(ossl_check_const_SSL_COMP_sk_type(sk)))
-#define sk_SSL_COMP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_COMP) *)OPENSSL_sk_deep_copy(ossl_check_const_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_copyfunc_type(copyfunc), ossl_check_SSL_COMP_freefunc_type(freefunc)))
+#define sk_SSL_COMP_dup(sk) ((STACK_OF(SSL_COMP)*)OPENSSL_sk_dup(ossl_check_const_SSL_COMP_sk_type(sk)))
+#define sk_SSL_COMP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_COMP)*)OPENSSL_sk_deep_copy(ossl_check_const_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_copyfunc_type(copyfunc), ossl_check_SSL_COMP_freefunc_type(freefunc)))
 #define sk_SSL_COMP_set_cmp_func(sk, cmp) ((sk_SSL_COMP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SSL_COMP_sk_type(sk), ossl_check_SSL_COMP_compfunc_type(cmp)))
 
-
 /* compatibility */
-# define SSL_set_app_data(s,arg)         (SSL_set_ex_data(s,0,(char *)(arg)))
-# define SSL_get_app_data(s)             (SSL_get_ex_data(s,0))
-# define SSL_SESSION_set_app_data(s,a)   (SSL_SESSION_set_ex_data(s,0, \
-                                                                  (char *)(a)))
-# define SSL_SESSION_get_app_data(s)     (SSL_SESSION_get_ex_data(s,0))
-# define SSL_CTX_get_app_data(ctx)       (SSL_CTX_get_ex_data(ctx,0))
-# define SSL_CTX_set_app_data(ctx,arg)   (SSL_CTX_set_ex_data(ctx,0, \
-                                                              (char *)(arg)))
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 void SSL_set_debug(SSL *s, int debug);
-# endif
+#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char*)(arg)))
+#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0))
+#define SSL_SESSION_set_app_data(s, a) (SSL_SESSION_set_ex_data(s, 0, (char*)(a)))
+#define SSL_SESSION_get_app_data(s) (SSL_SESSION_get_ex_data(s, 0))
+#define SSL_CTX_get_app_data(ctx) (SSL_CTX_get_ex_data(ctx, 0))
+#define SSL_CTX_set_app_data(ctx, arg) (SSL_CTX_set_ex_data(ctx, 0, (char*)(arg)))
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 void SSL_set_debug(SSL* s, int debug);
+#endif
 
 /* TLSv1.3 KeyUpdate message types */
 /* -1 used so that this is an invalid value for the on-the-wire protocol */
-#define SSL_KEY_UPDATE_NONE             -1
+#define SSL_KEY_UPDATE_NONE -1
 /* Values as defined for the on-the-wire protocol */
-#define SSL_KEY_UPDATE_NOT_REQUESTED     0
-#define SSL_KEY_UPDATE_REQUESTED         1
+#define SSL_KEY_UPDATE_NOT_REQUESTED 0
+#define SSL_KEY_UPDATE_REQUESTED 1
 
-/*
- * The valid handshake states (one for each type message sent and one for each
- * type of message received). There are also two "special" states:
- * TLS = TLS or DTLS state
- * DTLS = DTLS specific state
- * CR/SR = Client Read/Server Read
- * CW/SW = Client Write/Server Write
- *
- * The "special" states are:
- * TLS_ST_BEFORE = No handshake has been initiated yet
- * TLS_ST_OK = A handshake has been successfully completed
- */
-typedef enum {
-    TLS_ST_BEFORE,
-    TLS_ST_OK,
-    DTLS_ST_CR_HELLO_VERIFY_REQUEST,
-    TLS_ST_CR_SRVR_HELLO,
-    TLS_ST_CR_CERT,
-    TLS_ST_CR_CERT_STATUS,
-    TLS_ST_CR_KEY_EXCH,
-    TLS_ST_CR_CERT_REQ,
-    TLS_ST_CR_SRVR_DONE,
-    TLS_ST_CR_SESSION_TICKET,
-    TLS_ST_CR_CHANGE,
-    TLS_ST_CR_FINISHED,
-    TLS_ST_CW_CLNT_HELLO,
-    TLS_ST_CW_CERT,
-    TLS_ST_CW_KEY_EXCH,
-    TLS_ST_CW_CERT_VRFY,
-    TLS_ST_CW_CHANGE,
-    TLS_ST_CW_NEXT_PROTO,
-    TLS_ST_CW_FINISHED,
-    TLS_ST_SW_HELLO_REQ,
-    TLS_ST_SR_CLNT_HELLO,
-    DTLS_ST_SW_HELLO_VERIFY_REQUEST,
-    TLS_ST_SW_SRVR_HELLO,
-    TLS_ST_SW_CERT,
-    TLS_ST_SW_KEY_EXCH,
-    TLS_ST_SW_CERT_REQ,
-    TLS_ST_SW_SRVR_DONE,
-    TLS_ST_SR_CERT,
-    TLS_ST_SR_KEY_EXCH,
-    TLS_ST_SR_CERT_VRFY,
-    TLS_ST_SR_NEXT_PROTO,
-    TLS_ST_SR_CHANGE,
-    TLS_ST_SR_FINISHED,
-    TLS_ST_SW_SESSION_TICKET,
-    TLS_ST_SW_CERT_STATUS,
-    TLS_ST_SW_CHANGE,
-    TLS_ST_SW_FINISHED,
-    TLS_ST_SW_ENCRYPTED_EXTENSIONS,
-    TLS_ST_CR_ENCRYPTED_EXTENSIONS,
-    TLS_ST_CR_CERT_VRFY,
-    TLS_ST_SW_CERT_VRFY,
-    TLS_ST_CR_HELLO_REQ,
-    TLS_ST_SW_KEY_UPDATE,
-    TLS_ST_CW_KEY_UPDATE,
-    TLS_ST_SR_KEY_UPDATE,
-    TLS_ST_CR_KEY_UPDATE,
-    TLS_ST_EARLY_DATA,
-    TLS_ST_PENDING_EARLY_DATA_END,
-    TLS_ST_CW_END_OF_EARLY_DATA,
-    TLS_ST_SR_END_OF_EARLY_DATA
-} OSSL_HANDSHAKE_STATE;
+    /*
+     * The valid handshake states (one for each type message sent and one for each
+     * type of message received). There are also two "special" states:
+     * TLS = TLS or DTLS state
+     * DTLS = DTLS specific state
+     * CR/SR = Client Read/Server Read
+     * CW/SW = Client Write/Server Write
+     *
+     * The "special" states are:
+     * TLS_ST_BEFORE = No handshake has been initiated yet
+     * TLS_ST_OK = A handshake has been successfully completed
+     */
+    typedef enum
+    {
+        TLS_ST_BEFORE,
+        TLS_ST_OK,
+        DTLS_ST_CR_HELLO_VERIFY_REQUEST,
+        TLS_ST_CR_SRVR_HELLO,
+        TLS_ST_CR_CERT,
+        TLS_ST_CR_CERT_STATUS,
+        TLS_ST_CR_KEY_EXCH,
+        TLS_ST_CR_CERT_REQ,
+        TLS_ST_CR_SRVR_DONE,
+        TLS_ST_CR_SESSION_TICKET,
+        TLS_ST_CR_CHANGE,
+        TLS_ST_CR_FINISHED,
+        TLS_ST_CW_CLNT_HELLO,
+        TLS_ST_CW_CERT,
+        TLS_ST_CW_KEY_EXCH,
+        TLS_ST_CW_CERT_VRFY,
+        TLS_ST_CW_CHANGE,
+        TLS_ST_CW_NEXT_PROTO,
+        TLS_ST_CW_FINISHED,
+        TLS_ST_SW_HELLO_REQ,
+        TLS_ST_SR_CLNT_HELLO,
+        DTLS_ST_SW_HELLO_VERIFY_REQUEST,
+        TLS_ST_SW_SRVR_HELLO,
+        TLS_ST_SW_CERT,
+        TLS_ST_SW_KEY_EXCH,
+        TLS_ST_SW_CERT_REQ,
+        TLS_ST_SW_SRVR_DONE,
+        TLS_ST_SR_CERT,
+        TLS_ST_SR_KEY_EXCH,
+        TLS_ST_SR_CERT_VRFY,
+        TLS_ST_SR_NEXT_PROTO,
+        TLS_ST_SR_CHANGE,
+        TLS_ST_SR_FINISHED,
+        TLS_ST_SW_SESSION_TICKET,
+        TLS_ST_SW_CERT_STATUS,
+        TLS_ST_SW_CHANGE,
+        TLS_ST_SW_FINISHED,
+        TLS_ST_SW_ENCRYPTED_EXTENSIONS,
+        TLS_ST_CR_ENCRYPTED_EXTENSIONS,
+        TLS_ST_CR_CERT_VRFY,
+        TLS_ST_SW_CERT_VRFY,
+        TLS_ST_CR_HELLO_REQ,
+        TLS_ST_SW_KEY_UPDATE,
+        TLS_ST_CW_KEY_UPDATE,
+        TLS_ST_SR_KEY_UPDATE,
+        TLS_ST_CR_KEY_UPDATE,
+        TLS_ST_EARLY_DATA,
+        TLS_ST_PENDING_EARLY_DATA_END,
+        TLS_ST_CW_END_OF_EARLY_DATA,
+        TLS_ST_SR_END_OF_EARLY_DATA
+    } OSSL_HANDSHAKE_STATE;
 
-/*
- * Most of the following state values are no longer used and are defined to be
- * the closest equivalent value in the current state machine code. Not all
- * defines have an equivalent and are set to a dummy value (-1). SSL_ST_CONNECT
- * and SSL_ST_ACCEPT are still in use in the definition of SSL_CB_ACCEPT_LOOP,
- * SSL_CB_ACCEPT_EXIT, SSL_CB_CONNECT_LOOP and SSL_CB_CONNECT_EXIT.
- */
+    /*
+     * Most of the following state values are no longer used and are defined to be
+     * the closest equivalent value in the current state machine code. Not all
+     * defines have an equivalent and are set to a dummy value (-1). SSL_ST_CONNECT
+     * and SSL_ST_ACCEPT are still in use in the definition of SSL_CB_ACCEPT_LOOP,
+     * SSL_CB_ACCEPT_EXIT, SSL_CB_CONNECT_LOOP and SSL_CB_CONNECT_EXIT.
+     */
 
-# define SSL_ST_CONNECT                  0x1000
-# define SSL_ST_ACCEPT                   0x2000
-
-# define SSL_ST_MASK                     0x0FFF
-
-# define SSL_CB_LOOP                     0x01
-# define SSL_CB_EXIT                     0x02
-# define SSL_CB_READ                     0x04
-# define SSL_CB_WRITE                    0x08
-# define SSL_CB_ALERT                    0x4000/* used in callback */
-# define SSL_CB_READ_ALERT               (SSL_CB_ALERT|SSL_CB_READ)
-# define SSL_CB_WRITE_ALERT              (SSL_CB_ALERT|SSL_CB_WRITE)
-# define SSL_CB_ACCEPT_LOOP              (SSL_ST_ACCEPT|SSL_CB_LOOP)
-# define SSL_CB_ACCEPT_EXIT              (SSL_ST_ACCEPT|SSL_CB_EXIT)
-# define SSL_CB_CONNECT_LOOP             (SSL_ST_CONNECT|SSL_CB_LOOP)
-# define SSL_CB_CONNECT_EXIT             (SSL_ST_CONNECT|SSL_CB_EXIT)
-# define SSL_CB_HANDSHAKE_START          0x10
-# define SSL_CB_HANDSHAKE_DONE           0x20
+#define SSL_ST_CONNECT 0x1000
+#define SSL_ST_ACCEPT 0x2000
+
+#define SSL_ST_MASK 0x0FFF
+
+#define SSL_CB_LOOP 0x01
+#define SSL_CB_EXIT 0x02
+#define SSL_CB_READ 0x04
+#define SSL_CB_WRITE 0x08
+#define SSL_CB_ALERT 0x4000 /* used in callback */
+#define SSL_CB_READ_ALERT (SSL_CB_ALERT | SSL_CB_READ)
+#define SSL_CB_WRITE_ALERT (SSL_CB_ALERT | SSL_CB_WRITE)
+#define SSL_CB_ACCEPT_LOOP (SSL_ST_ACCEPT | SSL_CB_LOOP)
+#define SSL_CB_ACCEPT_EXIT (SSL_ST_ACCEPT | SSL_CB_EXIT)
+#define SSL_CB_CONNECT_LOOP (SSL_ST_CONNECT | SSL_CB_LOOP)
+#define SSL_CB_CONNECT_EXIT (SSL_ST_CONNECT | SSL_CB_EXIT)
+#define SSL_CB_HANDSHAKE_START 0x10
+#define SSL_CB_HANDSHAKE_DONE 0x20
 
 /* Is the SSL_connection established? */
-# define SSL_in_connect_init(a)          (SSL_in_init(a) && !SSL_is_server(a))
-# define SSL_in_accept_init(a)           (SSL_in_init(a) && SSL_is_server(a))
-int SSL_in_init(const SSL *s);
-int SSL_in_before(const SSL *s);
-int SSL_is_init_finished(const SSL *s);
+#define SSL_in_connect_init(a) (SSL_in_init(a) && !SSL_is_server(a))
+#define SSL_in_accept_init(a) (SSL_in_init(a) && SSL_is_server(a))
+    int SSL_in_init(const SSL* s);
+    int SSL_in_before(const SSL* s);
+    int SSL_is_init_finished(const SSL* s);
 
 /*
  * The following 3 states are kept in ssl->rlayer.rstate when reads fail, you
  * should not need these
  */
-# define SSL_ST_READ_HEADER                      0xF0
-# define SSL_ST_READ_BODY                        0xF1
-# define SSL_ST_READ_DONE                        0xF2
-
-/*-
- * Obtain latest Finished message
- *   -- that we sent (SSL_get_finished)
- *   -- that we expected from peer (SSL_get_peer_finished).
- * Returns length (0 == no Finished so far), copies up to 'count' bytes.
- */
-size_t SSL_get_finished(const SSL *s, void *buf, size_t count);
-size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count);
+#define SSL_ST_READ_HEADER 0xF0
+#define SSL_ST_READ_BODY 0xF1
+#define SSL_ST_READ_DONE 0xF2
+
+    /*-
+     * Obtain latest Finished message
+     *   -- that we sent (SSL_get_finished)
+     *   -- that we expected from peer (SSL_get_peer_finished).
+     * Returns length (0 == no Finished so far), copies up to 'count' bytes.
+     */
+    size_t SSL_get_finished(const SSL* s, void* buf, size_t count);
+    size_t SSL_get_peer_finished(const SSL* s, void* buf, size_t count);
 
 /*
  * use either SSL_VERIFY_NONE or SSL_VERIFY_PEER, the last 3 options are
  * 'ored' with SSL_VERIFY_PEER if they are desired
  */
-# define SSL_VERIFY_NONE                 0x00
-# define SSL_VERIFY_PEER                 0x01
-# define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02
-# define SSL_VERIFY_CLIENT_ONCE          0x04
-# define SSL_VERIFY_POST_HANDSHAKE       0x08
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define OpenSSL_add_ssl_algorithms()   SSL_library_init()
-#  define SSLeay_add_ssl_algorithms()    SSL_library_init()
-# endif
+#define SSL_VERIFY_NONE 0x00
+#define SSL_VERIFY_PEER 0x01
+#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02
+#define SSL_VERIFY_CLIENT_ONCE 0x04
+#define SSL_VERIFY_POST_HANDSHAKE 0x08
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define OpenSSL_add_ssl_algorithms() SSL_library_init()
+#define SSLeay_add_ssl_algorithms() SSL_library_init()
+#endif
 
 /* More backward compatibility */
-# define SSL_get_cipher(s) \
-                SSL_CIPHER_get_name(SSL_get_current_cipher(s))
-# define SSL_get_cipher_bits(s,np) \
-                SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np)
-# define SSL_get_cipher_version(s) \
-                SSL_CIPHER_get_version(SSL_get_current_cipher(s))
-# define SSL_get_cipher_name(s) \
-                SSL_CIPHER_get_name(SSL_get_current_cipher(s))
-# define SSL_get_time(a)         SSL_SESSION_get_time(a)
-# define SSL_set_time(a,b)       SSL_SESSION_set_time((a),(b))
-# define SSL_get_timeout(a)      SSL_SESSION_get_timeout(a)
-# define SSL_set_timeout(a,b)    SSL_SESSION_set_timeout((a),(b))
-
-# define d2i_SSL_SESSION_bio(bp,s_id) ASN1_d2i_bio_of(SSL_SESSION,SSL_SESSION_new,d2i_SSL_SESSION,bp,s_id)
-# define i2d_SSL_SESSION_bio(bp,s_id) ASN1_i2d_bio_of(SSL_SESSION,i2d_SSL_SESSION,bp,s_id)
-
-DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION)
-# define SSL_AD_REASON_OFFSET            1000/* offset to get SSL_R_... value
-                                              * from SSL_AD_... */
+#define SSL_get_cipher(s) \
+    SSL_CIPHER_get_name(SSL_get_current_cipher(s))
+#define SSL_get_cipher_bits(s, np) \
+    SSL_CIPHER_get_bits(SSL_get_current_cipher(s), np)
+#define SSL_get_cipher_version(s) \
+    SSL_CIPHER_get_version(SSL_get_current_cipher(s))
+#define SSL_get_cipher_name(s) \
+    SSL_CIPHER_get_name(SSL_get_current_cipher(s))
+#define SSL_get_time(a) SSL_SESSION_get_time(a)
+#define SSL_set_time(a, b) SSL_SESSION_set_time((a), (b))
+#define SSL_get_timeout(a) SSL_SESSION_get_timeout(a)
+#define SSL_set_timeout(a, b) SSL_SESSION_set_timeout((a), (b))
+
+#define d2i_SSL_SESSION_bio(bp, s_id) ASN1_d2i_bio_of(SSL_SESSION, SSL_SESSION_new, d2i_SSL_SESSION, bp, s_id)
+#define i2d_SSL_SESSION_bio(bp, s_id) ASN1_i2d_bio_of(SSL_SESSION, i2d_SSL_SESSION, bp, s_id)
+
+    DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION)
+#define SSL_AD_REASON_OFFSET 1000 /* offset to get SSL_R_... value \
+                                   * from SSL_AD_... */
 /* These alert types are for SSLv3 and TLSv1 */
-# define SSL_AD_CLOSE_NOTIFY             SSL3_AD_CLOSE_NOTIFY
+#define SSL_AD_CLOSE_NOTIFY SSL3_AD_CLOSE_NOTIFY
 /* fatal */
-# define SSL_AD_UNEXPECTED_MESSAGE       SSL3_AD_UNEXPECTED_MESSAGE
+#define SSL_AD_UNEXPECTED_MESSAGE SSL3_AD_UNEXPECTED_MESSAGE
 /* fatal */
-# define SSL_AD_BAD_RECORD_MAC           SSL3_AD_BAD_RECORD_MAC
-# define SSL_AD_DECRYPTION_FAILED        TLS1_AD_DECRYPTION_FAILED
-# define SSL_AD_RECORD_OVERFLOW          TLS1_AD_RECORD_OVERFLOW
+#define SSL_AD_BAD_RECORD_MAC SSL3_AD_BAD_RECORD_MAC
+#define SSL_AD_DECRYPTION_FAILED TLS1_AD_DECRYPTION_FAILED
+#define SSL_AD_RECORD_OVERFLOW TLS1_AD_RECORD_OVERFLOW
 /* fatal */
-# define SSL_AD_DECOMPRESSION_FAILURE    SSL3_AD_DECOMPRESSION_FAILURE
+#define SSL_AD_DECOMPRESSION_FAILURE SSL3_AD_DECOMPRESSION_FAILURE
 /* fatal */
-# define SSL_AD_HANDSHAKE_FAILURE        SSL3_AD_HANDSHAKE_FAILURE
+#define SSL_AD_HANDSHAKE_FAILURE SSL3_AD_HANDSHAKE_FAILURE
 /* Not for TLS */
-# define SSL_AD_NO_CERTIFICATE           SSL3_AD_NO_CERTIFICATE
-# define SSL_AD_BAD_CERTIFICATE          SSL3_AD_BAD_CERTIFICATE
-# define SSL_AD_UNSUPPORTED_CERTIFICATE  SSL3_AD_UNSUPPORTED_CERTIFICATE
-# define SSL_AD_CERTIFICATE_REVOKED      SSL3_AD_CERTIFICATE_REVOKED
-# define SSL_AD_CERTIFICATE_EXPIRED      SSL3_AD_CERTIFICATE_EXPIRED
-# define SSL_AD_CERTIFICATE_UNKNOWN      SSL3_AD_CERTIFICATE_UNKNOWN
+#define SSL_AD_NO_CERTIFICATE SSL3_AD_NO_CERTIFICATE
+#define SSL_AD_BAD_CERTIFICATE SSL3_AD_BAD_CERTIFICATE
+#define SSL_AD_UNSUPPORTED_CERTIFICATE SSL3_AD_UNSUPPORTED_CERTIFICATE
+#define SSL_AD_CERTIFICATE_REVOKED SSL3_AD_CERTIFICATE_REVOKED
+#define SSL_AD_CERTIFICATE_EXPIRED SSL3_AD_CERTIFICATE_EXPIRED
+#define SSL_AD_CERTIFICATE_UNKNOWN SSL3_AD_CERTIFICATE_UNKNOWN
 /* fatal */
-# define SSL_AD_ILLEGAL_PARAMETER        SSL3_AD_ILLEGAL_PARAMETER
+#define SSL_AD_ILLEGAL_PARAMETER SSL3_AD_ILLEGAL_PARAMETER
 /* fatal */
-# define SSL_AD_UNKNOWN_CA               TLS1_AD_UNKNOWN_CA
+#define SSL_AD_UNKNOWN_CA TLS1_AD_UNKNOWN_CA
 /* fatal */
-# define SSL_AD_ACCESS_DENIED            TLS1_AD_ACCESS_DENIED
+#define SSL_AD_ACCESS_DENIED TLS1_AD_ACCESS_DENIED
 /* fatal */
-# define SSL_AD_DECODE_ERROR             TLS1_AD_DECODE_ERROR
-# define SSL_AD_DECRYPT_ERROR            TLS1_AD_DECRYPT_ERROR
+#define SSL_AD_DECODE_ERROR TLS1_AD_DECODE_ERROR
+#define SSL_AD_DECRYPT_ERROR TLS1_AD_DECRYPT_ERROR
 /* fatal */
-# define SSL_AD_EXPORT_RESTRICTION       TLS1_AD_EXPORT_RESTRICTION
+#define SSL_AD_EXPORT_RESTRICTION TLS1_AD_EXPORT_RESTRICTION
 /* fatal */
-# define SSL_AD_PROTOCOL_VERSION         TLS1_AD_PROTOCOL_VERSION
+#define SSL_AD_PROTOCOL_VERSION TLS1_AD_PROTOCOL_VERSION
 /* fatal */
-# define SSL_AD_INSUFFICIENT_SECURITY    TLS1_AD_INSUFFICIENT_SECURITY
+#define SSL_AD_INSUFFICIENT_SECURITY TLS1_AD_INSUFFICIENT_SECURITY
 /* fatal */
-# define SSL_AD_INTERNAL_ERROR           TLS1_AD_INTERNAL_ERROR
-# define SSL_AD_USER_CANCELLED           TLS1_AD_USER_CANCELLED
-# define SSL_AD_NO_RENEGOTIATION         TLS1_AD_NO_RENEGOTIATION
-# define SSL_AD_MISSING_EXTENSION        TLS13_AD_MISSING_EXTENSION
-# define SSL_AD_CERTIFICATE_REQUIRED     TLS13_AD_CERTIFICATE_REQUIRED
-# define SSL_AD_UNSUPPORTED_EXTENSION    TLS1_AD_UNSUPPORTED_EXTENSION
-# define SSL_AD_CERTIFICATE_UNOBTAINABLE TLS1_AD_CERTIFICATE_UNOBTAINABLE
-# define SSL_AD_UNRECOGNIZED_NAME        TLS1_AD_UNRECOGNIZED_NAME
-# define SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE
-# define SSL_AD_BAD_CERTIFICATE_HASH_VALUE TLS1_AD_BAD_CERTIFICATE_HASH_VALUE
+#define SSL_AD_INTERNAL_ERROR TLS1_AD_INTERNAL_ERROR
+#define SSL_AD_USER_CANCELLED TLS1_AD_USER_CANCELLED
+#define SSL_AD_NO_RENEGOTIATION TLS1_AD_NO_RENEGOTIATION
+#define SSL_AD_MISSING_EXTENSION TLS13_AD_MISSING_EXTENSION
+#define SSL_AD_CERTIFICATE_REQUIRED TLS13_AD_CERTIFICATE_REQUIRED
+#define SSL_AD_UNSUPPORTED_EXTENSION TLS1_AD_UNSUPPORTED_EXTENSION
+#define SSL_AD_CERTIFICATE_UNOBTAINABLE TLS1_AD_CERTIFICATE_UNOBTAINABLE
+#define SSL_AD_UNRECOGNIZED_NAME TLS1_AD_UNRECOGNIZED_NAME
+#define SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE
+#define SSL_AD_BAD_CERTIFICATE_HASH_VALUE TLS1_AD_BAD_CERTIFICATE_HASH_VALUE
 /* fatal */
-# define SSL_AD_UNKNOWN_PSK_IDENTITY     TLS1_AD_UNKNOWN_PSK_IDENTITY
+#define SSL_AD_UNKNOWN_PSK_IDENTITY TLS1_AD_UNKNOWN_PSK_IDENTITY
 /* fatal */
-# define SSL_AD_INAPPROPRIATE_FALLBACK   TLS1_AD_INAPPROPRIATE_FALLBACK
-# define SSL_AD_NO_APPLICATION_PROTOCOL  TLS1_AD_NO_APPLICATION_PROTOCOL
-# define SSL_ERROR_NONE                  0
-# define SSL_ERROR_SSL                   1
-# define SSL_ERROR_WANT_READ             2
-# define SSL_ERROR_WANT_WRITE            3
-# define SSL_ERROR_WANT_X509_LOOKUP      4
-# define SSL_ERROR_SYSCALL               5/* look at error stack/return
-                                           * value/errno */
-# define SSL_ERROR_ZERO_RETURN           6
-# define SSL_ERROR_WANT_CONNECT          7
-# define SSL_ERROR_WANT_ACCEPT           8
-# define SSL_ERROR_WANT_ASYNC            9
-# define SSL_ERROR_WANT_ASYNC_JOB       10
-# define SSL_ERROR_WANT_CLIENT_HELLO_CB 11
-# define SSL_ERROR_WANT_RETRY_VERIFY    12
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SSL_CTRL_SET_TMP_DH                    3
-#  define SSL_CTRL_SET_TMP_ECDH                  4
-#  define SSL_CTRL_SET_TMP_DH_CB                 6
-# endif
-
-# define SSL_CTRL_GET_CLIENT_CERT_REQUEST        9
-# define SSL_CTRL_GET_NUM_RENEGOTIATIONS         10
-# define SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS       11
-# define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS       12
-# define SSL_CTRL_GET_FLAGS                      13
-# define SSL_CTRL_EXTRA_CHAIN_CERT               14
-# define SSL_CTRL_SET_MSG_CALLBACK               15
-# define SSL_CTRL_SET_MSG_CALLBACK_ARG           16
+#define SSL_AD_INAPPROPRIATE_FALLBACK TLS1_AD_INAPPROPRIATE_FALLBACK
+#define SSL_AD_NO_APPLICATION_PROTOCOL TLS1_AD_NO_APPLICATION_PROTOCOL
+#define SSL_ERROR_NONE 0
+#define SSL_ERROR_SSL 1
+#define SSL_ERROR_WANT_READ 2
+#define SSL_ERROR_WANT_WRITE 3
+#define SSL_ERROR_WANT_X509_LOOKUP 4
+#define SSL_ERROR_SYSCALL 5 /* look at error stack/return \
+                             * value/errno */
+#define SSL_ERROR_ZERO_RETURN 6
+#define SSL_ERROR_WANT_CONNECT 7
+#define SSL_ERROR_WANT_ACCEPT 8
+#define SSL_ERROR_WANT_ASYNC 9
+#define SSL_ERROR_WANT_ASYNC_JOB 10
+#define SSL_ERROR_WANT_CLIENT_HELLO_CB 11
+#define SSL_ERROR_WANT_RETRY_VERIFY 12
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SSL_CTRL_SET_TMP_DH 3
+#define SSL_CTRL_SET_TMP_ECDH 4
+#define SSL_CTRL_SET_TMP_DH_CB 6
+#endif
+
+#define SSL_CTRL_GET_CLIENT_CERT_REQUEST 9
+#define SSL_CTRL_GET_NUM_RENEGOTIATIONS 10
+#define SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS 11
+#define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS 12
+#define SSL_CTRL_GET_FLAGS 13
+#define SSL_CTRL_EXTRA_CHAIN_CERT 14
+#define SSL_CTRL_SET_MSG_CALLBACK 15
+#define SSL_CTRL_SET_MSG_CALLBACK_ARG 16
 /* only applies to datagram connections */
-# define SSL_CTRL_SET_MTU                17
+#define SSL_CTRL_SET_MTU 17
 /* Stats */
-# define SSL_CTRL_SESS_NUMBER                    20
-# define SSL_CTRL_SESS_CONNECT                   21
-# define SSL_CTRL_SESS_CONNECT_GOOD              22
-# define SSL_CTRL_SESS_CONNECT_RENEGOTIATE       23
-# define SSL_CTRL_SESS_ACCEPT                    24
-# define SSL_CTRL_SESS_ACCEPT_GOOD               25
-# define SSL_CTRL_SESS_ACCEPT_RENEGOTIATE        26
-# define SSL_CTRL_SESS_HIT                       27
-# define SSL_CTRL_SESS_CB_HIT                    28
-# define SSL_CTRL_SESS_MISSES                    29
-# define SSL_CTRL_SESS_TIMEOUTS                  30
-# define SSL_CTRL_SESS_CACHE_FULL                31
-# define SSL_CTRL_MODE                           33
-# define SSL_CTRL_GET_READ_AHEAD                 40
-# define SSL_CTRL_SET_READ_AHEAD                 41
-# define SSL_CTRL_SET_SESS_CACHE_SIZE            42
-# define SSL_CTRL_GET_SESS_CACHE_SIZE            43
-# define SSL_CTRL_SET_SESS_CACHE_MODE            44
-# define SSL_CTRL_GET_SESS_CACHE_MODE            45
-# define SSL_CTRL_GET_MAX_CERT_LIST              50
-# define SSL_CTRL_SET_MAX_CERT_LIST              51
-# define SSL_CTRL_SET_MAX_SEND_FRAGMENT          52
+#define SSL_CTRL_SESS_NUMBER 20
+#define SSL_CTRL_SESS_CONNECT 21
+#define SSL_CTRL_SESS_CONNECT_GOOD 22
+#define SSL_CTRL_SESS_CONNECT_RENEGOTIATE 23
+#define SSL_CTRL_SESS_ACCEPT 24
+#define SSL_CTRL_SESS_ACCEPT_GOOD 25
+#define SSL_CTRL_SESS_ACCEPT_RENEGOTIATE 26
+#define SSL_CTRL_SESS_HIT 27
+#define SSL_CTRL_SESS_CB_HIT 28
+#define SSL_CTRL_SESS_MISSES 29
+#define SSL_CTRL_SESS_TIMEOUTS 30
+#define SSL_CTRL_SESS_CACHE_FULL 31
+#define SSL_CTRL_MODE 33
+#define SSL_CTRL_GET_READ_AHEAD 40
+#define SSL_CTRL_SET_READ_AHEAD 41
+#define SSL_CTRL_SET_SESS_CACHE_SIZE 42
+#define SSL_CTRL_GET_SESS_CACHE_SIZE 43
+#define SSL_CTRL_SET_SESS_CACHE_MODE 44
+#define SSL_CTRL_GET_SESS_CACHE_MODE 45
+#define SSL_CTRL_GET_MAX_CERT_LIST 50
+#define SSL_CTRL_SET_MAX_CERT_LIST 51
+#define SSL_CTRL_SET_MAX_SEND_FRAGMENT 52
 /* see tls1.h for macros based on these */
-# define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB       53
-# define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG      54
-# define SSL_CTRL_SET_TLSEXT_HOSTNAME            55
-# define SSL_CTRL_SET_TLSEXT_DEBUG_CB            56
-# define SSL_CTRL_SET_TLSEXT_DEBUG_ARG           57
-# define SSL_CTRL_GET_TLSEXT_TICKET_KEYS         58
-# define SSL_CTRL_SET_TLSEXT_TICKET_KEYS         59
+#define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB 53
+#define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG 54
+#define SSL_CTRL_SET_TLSEXT_HOSTNAME 55
+#define SSL_CTRL_SET_TLSEXT_DEBUG_CB 56
+#define SSL_CTRL_SET_TLSEXT_DEBUG_ARG 57
+#define SSL_CTRL_GET_TLSEXT_TICKET_KEYS 58
+#define SSL_CTRL_SET_TLSEXT_TICKET_KEYS 59
 /*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT    60 */
 /*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB 61 */
 /*# define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB_ARG 62 */
-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB       63
-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG   64
-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE     65
-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS     66
-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS     67
-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS      68
-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS      69
-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP        70
-# define SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP        71
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB      72
-# endif
-# define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB    75
-# define SSL_CTRL_SET_SRP_VERIFY_PARAM_CB                76
-# define SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB             77
-# define SSL_CTRL_SET_SRP_ARG            78
-# define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME               79
-# define SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH               80
-# define SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD               81
-# define DTLS_CTRL_GET_TIMEOUT           73
-# define DTLS_CTRL_HANDLE_TIMEOUT        74
-# define SSL_CTRL_GET_RI_SUPPORT                 76
-# define SSL_CTRL_CLEAR_MODE                     78
-# define SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB      79
-# define SSL_CTRL_GET_EXTRA_CHAIN_CERTS          82
-# define SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS        83
-# define SSL_CTRL_CHAIN                          88
-# define SSL_CTRL_CHAIN_CERT                     89
-# define SSL_CTRL_GET_GROUPS                     90
-# define SSL_CTRL_SET_GROUPS                     91
-# define SSL_CTRL_SET_GROUPS_LIST                92
-# define SSL_CTRL_GET_SHARED_GROUP               93
-# define SSL_CTRL_SET_SIGALGS                    97
-# define SSL_CTRL_SET_SIGALGS_LIST               98
-# define SSL_CTRL_CERT_FLAGS                     99
-# define SSL_CTRL_CLEAR_CERT_FLAGS               100
-# define SSL_CTRL_SET_CLIENT_SIGALGS             101
-# define SSL_CTRL_SET_CLIENT_SIGALGS_LIST        102
-# define SSL_CTRL_GET_CLIENT_CERT_TYPES          103
-# define SSL_CTRL_SET_CLIENT_CERT_TYPES          104
-# define SSL_CTRL_BUILD_CERT_CHAIN               105
-# define SSL_CTRL_SET_VERIFY_CERT_STORE          106
-# define SSL_CTRL_SET_CHAIN_CERT_STORE           107
-# define SSL_CTRL_GET_PEER_SIGNATURE_NID         108
-# define SSL_CTRL_GET_PEER_TMP_KEY               109
-# define SSL_CTRL_GET_RAW_CIPHERLIST             110
-# define SSL_CTRL_GET_EC_POINT_FORMATS           111
-# define SSL_CTRL_GET_CHAIN_CERTS                115
-# define SSL_CTRL_SELECT_CURRENT_CERT            116
-# define SSL_CTRL_SET_CURRENT_CERT               117
-# define SSL_CTRL_SET_DH_AUTO                    118
-# define DTLS_CTRL_SET_LINK_MTU                  120
-# define DTLS_CTRL_GET_LINK_MIN_MTU              121
-# define SSL_CTRL_GET_EXTMS_SUPPORT              122
-# define SSL_CTRL_SET_MIN_PROTO_VERSION          123
-# define SSL_CTRL_SET_MAX_PROTO_VERSION          124
-# define SSL_CTRL_SET_SPLIT_SEND_FRAGMENT        125
-# define SSL_CTRL_SET_MAX_PIPELINES              126
-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE     127
-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB       128
-# define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG   129
-# define SSL_CTRL_GET_MIN_PROTO_VERSION          130
-# define SSL_CTRL_GET_MAX_PROTO_VERSION          131
-# define SSL_CTRL_GET_SIGNATURE_NID              132
-# define SSL_CTRL_GET_TMP_KEY                    133
-# define SSL_CTRL_GET_NEGOTIATED_GROUP           134
-# define SSL_CTRL_SET_RETRY_VERIFY               136
-# define SSL_CTRL_GET_VERIFY_CERT_STORE          137
-# define SSL_CTRL_GET_CHAIN_CERT_STORE           138
-# define SSL_CERT_SET_FIRST                      1
-# define SSL_CERT_SET_NEXT                       2
-# define SSL_CERT_SET_SERVER                     3
-# define DTLSv1_get_timeout(ssl, arg) \
-        SSL_ctrl(ssl,DTLS_CTRL_GET_TIMEOUT,0, (void *)(arg))
-# define DTLSv1_handle_timeout(ssl) \
-        SSL_ctrl(ssl,DTLS_CTRL_HANDLE_TIMEOUT,0, NULL)
-# define SSL_num_renegotiations(ssl) \
-        SSL_ctrl((ssl),SSL_CTRL_GET_NUM_RENEGOTIATIONS,0,NULL)
-# define SSL_clear_num_renegotiations(ssl) \
-        SSL_ctrl((ssl),SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS,0,NULL)
-# define SSL_total_renegotiations(ssl) \
-        SSL_ctrl((ssl),SSL_CTRL_GET_TOTAL_RENEGOTIATIONS,0,NULL)
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SSL_CTX_set_tmp_dh(ctx,dh) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH,0,(char *)(dh))
-# endif
-# define SSL_CTX_set_dh_auto(ctx, onoff) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_DH_AUTO,onoff,NULL)
-# define SSL_set_dh_auto(s, onoff) \
-        SSL_ctrl(s,SSL_CTRL_SET_DH_AUTO,onoff,NULL)
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SSL_set_tmp_dh(ssl,dh) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH,0,(char *)(dh))
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SSL_CTX_set_tmp_ecdh(ctx,ecdh) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH,0,(char *)(ecdh))
-#  define SSL_set_tmp_ecdh(ssl,ecdh) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH,0,(char *)(ecdh))
-# endif
-# define SSL_CTX_add_extra_chain_cert(ctx,x509) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char *)(x509))
-# define SSL_CTX_get_extra_chain_certs(ctx,px509) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_EXTRA_CHAIN_CERTS,0,px509)
-# define SSL_CTX_get_extra_chain_certs_only(ctx,px509) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_EXTRA_CHAIN_CERTS,1,px509)
-# define SSL_CTX_clear_extra_chain_certs(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS,0,NULL)
-# define SSL_CTX_set0_chain(ctx,sk) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN,0,(char *)(sk))
-# define SSL_CTX_set1_chain(ctx,sk) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN,1,(char *)(sk))
-# define SSL_CTX_add0_chain_cert(ctx,x509) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN_CERT,0,(char *)(x509))
-# define SSL_CTX_add1_chain_cert(ctx,x509) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_CHAIN_CERT,1,(char *)(x509))
-# define SSL_CTX_get0_chain_certs(ctx,px509) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_CHAIN_CERTS,0,px509)
-# define SSL_CTX_clear_chain_certs(ctx) \
-        SSL_CTX_set0_chain(ctx,NULL)
-# define SSL_CTX_build_cert_chain(ctx, flags) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL)
-# define SSL_CTX_select_current_cert(ctx,x509) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SELECT_CURRENT_CERT,0,(char *)(x509))
-# define SSL_CTX_set_current_cert(ctx, op) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CURRENT_CERT, op, NULL)
-# define SSL_CTX_set0_verify_cert_store(ctx,st) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st))
-# define SSL_CTX_set1_verify_cert_store(ctx,st) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st))
-# define SSL_CTX_get0_verify_cert_store(ctx,st) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_VERIFY_CERT_STORE,0,(char *)(st))
-# define SSL_CTX_set0_chain_cert_store(ctx,st) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st))
-# define SSL_CTX_set1_chain_cert_store(ctx,st) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st))
-# define SSL_CTX_get0_chain_cert_store(ctx,st) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_CHAIN_CERT_STORE,0,(char *)(st))
-# define SSL_set0_chain(s,sk) \
-        SSL_ctrl(s,SSL_CTRL_CHAIN,0,(char *)(sk))
-# define SSL_set1_chain(s,sk) \
-        SSL_ctrl(s,SSL_CTRL_CHAIN,1,(char *)(sk))
-# define SSL_add0_chain_cert(s,x509) \
-        SSL_ctrl(s,SSL_CTRL_CHAIN_CERT,0,(char *)(x509))
-# define SSL_add1_chain_cert(s,x509) \
-        SSL_ctrl(s,SSL_CTRL_CHAIN_CERT,1,(char *)(x509))
-# define SSL_get0_chain_certs(s,px509) \
-        SSL_ctrl(s,SSL_CTRL_GET_CHAIN_CERTS,0,px509)
-# define SSL_clear_chain_certs(s) \
-        SSL_set0_chain(s,NULL)
-# define SSL_build_cert_chain(s, flags) \
-        SSL_ctrl(s,SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL)
-# define SSL_select_current_cert(s,x509) \
-        SSL_ctrl(s,SSL_CTRL_SELECT_CURRENT_CERT,0,(char *)(x509))
-# define SSL_set_current_cert(s,op) \
-        SSL_ctrl(s,SSL_CTRL_SET_CURRENT_CERT, op, NULL)
-# define SSL_set0_verify_cert_store(s,st) \
-        SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,0,(char *)(st))
-# define SSL_set1_verify_cert_store(s,st) \
-        SSL_ctrl(s,SSL_CTRL_SET_VERIFY_CERT_STORE,1,(char *)(st))
-#define SSL_get0_verify_cert_store(s,st) \
-        SSL_ctrl(s,SSL_CTRL_GET_VERIFY_CERT_STORE,0,(char *)(st))
-# define SSL_set0_chain_cert_store(s,st) \
-        SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,0,(char *)(st))
-# define SSL_set1_chain_cert_store(s,st) \
-        SSL_ctrl(s,SSL_CTRL_SET_CHAIN_CERT_STORE,1,(char *)(st))
-#define SSL_get0_chain_cert_store(s,st) \
-        SSL_ctrl(s,SSL_CTRL_GET_CHAIN_CERT_STORE,0,(char *)(st))
-
-# define SSL_get1_groups(s, glist) \
-        SSL_ctrl(s,SSL_CTRL_GET_GROUPS,0,(int*)(glist))
-# define SSL_CTX_set1_groups(ctx, glist, glistlen) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_GROUPS,glistlen,(int *)(glist))
-# define SSL_CTX_set1_groups_list(ctx, s) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_GROUPS_LIST,0,(char *)(s))
-# define SSL_set1_groups(s, glist, glistlen) \
-        SSL_ctrl(s,SSL_CTRL_SET_GROUPS,glistlen,(char *)(glist))
-# define SSL_set1_groups_list(s, str) \
-        SSL_ctrl(s,SSL_CTRL_SET_GROUPS_LIST,0,(char *)(str))
-# define SSL_get_shared_group(s, n) \
-        SSL_ctrl(s,SSL_CTRL_GET_SHARED_GROUP,n,NULL)
-# define SSL_get_negotiated_group(s) \
-        SSL_ctrl(s,SSL_CTRL_GET_NEGOTIATED_GROUP,0,NULL)
-# define SSL_CTX_set1_sigalgs(ctx, slist, slistlen) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SIGALGS,slistlen,(int *)(slist))
-# define SSL_CTX_set1_sigalgs_list(ctx, s) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SIGALGS_LIST,0,(char *)(s))
-# define SSL_set1_sigalgs(s, slist, slistlen) \
-        SSL_ctrl(s,SSL_CTRL_SET_SIGALGS,slistlen,(int *)(slist))
-# define SSL_set1_sigalgs_list(s, str) \
-        SSL_ctrl(s,SSL_CTRL_SET_SIGALGS_LIST,0,(char *)(str))
-# define SSL_CTX_set1_client_sigalgs(ctx, slist, slistlen) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_SIGALGS,slistlen,(int *)(slist))
-# define SSL_CTX_set1_client_sigalgs_list(ctx, s) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_SIGALGS_LIST,0,(char *)(s))
-# define SSL_set1_client_sigalgs(s, slist, slistlen) \
-        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_SIGALGS,slistlen,(int *)(slist))
-# define SSL_set1_client_sigalgs_list(s, str) \
-        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_SIGALGS_LIST,0,(char *)(str))
-# define SSL_get0_certificate_types(s, clist) \
-        SSL_ctrl(s, SSL_CTRL_GET_CLIENT_CERT_TYPES, 0, (char *)(clist))
-# define SSL_CTX_set1_client_certificate_types(ctx, clist, clistlen) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_CLIENT_CERT_TYPES,clistlen, \
-                     (char *)(clist))
-# define SSL_set1_client_certificate_types(s, clist, clistlen) \
-        SSL_ctrl(s,SSL_CTRL_SET_CLIENT_CERT_TYPES,clistlen,(char *)(clist))
-# define SSL_get_signature_nid(s, pn) \
-        SSL_ctrl(s,SSL_CTRL_GET_SIGNATURE_NID,0,pn)
-# define SSL_get_peer_signature_nid(s, pn) \
-        SSL_ctrl(s,SSL_CTRL_GET_PEER_SIGNATURE_NID,0,pn)
-# define SSL_get_peer_tmp_key(s, pk) \
-        SSL_ctrl(s,SSL_CTRL_GET_PEER_TMP_KEY,0,pk)
-# define SSL_get_tmp_key(s, pk) \
-        SSL_ctrl(s,SSL_CTRL_GET_TMP_KEY,0,pk)
-# define SSL_get0_raw_cipherlist(s, plst) \
-        SSL_ctrl(s,SSL_CTRL_GET_RAW_CIPHERLIST,0,plst)
-# define SSL_get0_ec_point_formats(s, plst) \
-        SSL_ctrl(s,SSL_CTRL_GET_EC_POINT_FORMATS,0,plst)
-# define SSL_CTX_set_min_proto_version(ctx, version) \
-        SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL)
-# define SSL_CTX_set_max_proto_version(ctx, version) \
-        SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL)
-# define SSL_CTX_get_min_proto_version(ctx) \
-        SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL)
-# define SSL_CTX_get_max_proto_version(ctx) \
-        SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL)
-# define SSL_set_min_proto_version(s, version) \
-        SSL_ctrl(s, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL)
-# define SSL_set_max_proto_version(s, version) \
-        SSL_ctrl(s, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL)
-# define SSL_get_min_proto_version(s) \
-        SSL_ctrl(s, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL)
-# define SSL_get_max_proto_version(s) \
-        SSL_ctrl(s, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL)
-
-const char *SSL_group_to_name(SSL *s, int id);
+#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB 63
+#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG 64
+#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE 65
+#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS 66
+#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS 67
+#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS 68
+#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS 69
+#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP 70
+#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP 71
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB 72
+#endif
+#define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB 75
+#define SSL_CTRL_SET_SRP_VERIFY_PARAM_CB 76
+#define SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB 77
+#define SSL_CTRL_SET_SRP_ARG 78
+#define SSL_CTRL_SET_TLS_EXT_SRP_USERNAME 79
+#define SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH 80
+#define SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD 81
+#define DTLS_CTRL_GET_TIMEOUT 73
+#define DTLS_CTRL_HANDLE_TIMEOUT 74
+#define SSL_CTRL_GET_RI_SUPPORT 76
+#define SSL_CTRL_CLEAR_MODE 78
+#define SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB 79
+#define SSL_CTRL_GET_EXTRA_CHAIN_CERTS 82
+#define SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS 83
+#define SSL_CTRL_CHAIN 88
+#define SSL_CTRL_CHAIN_CERT 89
+#define SSL_CTRL_GET_GROUPS 90
+#define SSL_CTRL_SET_GROUPS 91
+#define SSL_CTRL_SET_GROUPS_LIST 92
+#define SSL_CTRL_GET_SHARED_GROUP 93
+#define SSL_CTRL_SET_SIGALGS 97
+#define SSL_CTRL_SET_SIGALGS_LIST 98
+#define SSL_CTRL_CERT_FLAGS 99
+#define SSL_CTRL_CLEAR_CERT_FLAGS 100
+#define SSL_CTRL_SET_CLIENT_SIGALGS 101
+#define SSL_CTRL_SET_CLIENT_SIGALGS_LIST 102
+#define SSL_CTRL_GET_CLIENT_CERT_TYPES 103
+#define SSL_CTRL_SET_CLIENT_CERT_TYPES 104
+#define SSL_CTRL_BUILD_CERT_CHAIN 105
+#define SSL_CTRL_SET_VERIFY_CERT_STORE 106
+#define SSL_CTRL_SET_CHAIN_CERT_STORE 107
+#define SSL_CTRL_GET_PEER_SIGNATURE_NID 108
+#define SSL_CTRL_GET_PEER_TMP_KEY 109
+#define SSL_CTRL_GET_RAW_CIPHERLIST 110
+#define SSL_CTRL_GET_EC_POINT_FORMATS 111
+#define SSL_CTRL_GET_CHAIN_CERTS 115
+#define SSL_CTRL_SELECT_CURRENT_CERT 116
+#define SSL_CTRL_SET_CURRENT_CERT 117
+#define SSL_CTRL_SET_DH_AUTO 118
+#define DTLS_CTRL_SET_LINK_MTU 120
+#define DTLS_CTRL_GET_LINK_MIN_MTU 121
+#define SSL_CTRL_GET_EXTMS_SUPPORT 122
+#define SSL_CTRL_SET_MIN_PROTO_VERSION 123
+#define SSL_CTRL_SET_MAX_PROTO_VERSION 124
+#define SSL_CTRL_SET_SPLIT_SEND_FRAGMENT 125
+#define SSL_CTRL_SET_MAX_PIPELINES 126
+#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE 127
+#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB 128
+#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG 129
+#define SSL_CTRL_GET_MIN_PROTO_VERSION 130
+#define SSL_CTRL_GET_MAX_PROTO_VERSION 131
+#define SSL_CTRL_GET_SIGNATURE_NID 132
+#define SSL_CTRL_GET_TMP_KEY 133
+#define SSL_CTRL_GET_NEGOTIATED_GROUP 134
+#define SSL_CTRL_SET_RETRY_VERIFY 136
+#define SSL_CTRL_GET_VERIFY_CERT_STORE 137
+#define SSL_CTRL_GET_CHAIN_CERT_STORE 138
+#define SSL_CERT_SET_FIRST 1
+#define SSL_CERT_SET_NEXT 2
+#define SSL_CERT_SET_SERVER 3
+#define DTLSv1_get_timeout(ssl, arg) \
+    SSL_ctrl(ssl, DTLS_CTRL_GET_TIMEOUT, 0, (void*)(arg))
+#define DTLSv1_handle_timeout(ssl) \
+    SSL_ctrl(ssl, DTLS_CTRL_HANDLE_TIMEOUT, 0, NULL)
+#define SSL_num_renegotiations(ssl) \
+    SSL_ctrl((ssl), SSL_CTRL_GET_NUM_RENEGOTIATIONS, 0, NULL)
+#define SSL_clear_num_renegotiations(ssl) \
+    SSL_ctrl((ssl), SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS, 0, NULL)
+#define SSL_total_renegotiations(ssl) \
+    SSL_ctrl((ssl), SSL_CTRL_GET_TOTAL_RENEGOTIATIONS, 0, NULL)
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SSL_CTX_set_tmp_dh(ctx, dh) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_TMP_DH, 0, (char*)(dh))
+#endif
+#define SSL_CTX_set_dh_auto(ctx, onoff) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_DH_AUTO, onoff, NULL)
+#define SSL_set_dh_auto(s, onoff) \
+    SSL_ctrl(s, SSL_CTRL_SET_DH_AUTO, onoff, NULL)
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SSL_set_tmp_dh(ssl, dh) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_TMP_DH, 0, (char*)(dh))
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SSL_CTX_set_tmp_ecdh(ctx, ecdh) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_TMP_ECDH, 0, (char*)(ecdh))
+#define SSL_set_tmp_ecdh(ssl, ecdh) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_TMP_ECDH, 0, (char*)(ecdh))
+#endif
+#define SSL_CTX_add_extra_chain_cert(ctx, x509) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_EXTRA_CHAIN_CERT, 0, (char*)(x509))
+#define SSL_CTX_get_extra_chain_certs(ctx, px509) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_EXTRA_CHAIN_CERTS, 0, px509)
+#define SSL_CTX_get_extra_chain_certs_only(ctx, px509) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_EXTRA_CHAIN_CERTS, 1, px509)
+#define SSL_CTX_clear_extra_chain_certs(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS, 0, NULL)
+#define SSL_CTX_set0_chain(ctx, sk) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_CHAIN, 0, (char*)(sk))
+#define SSL_CTX_set1_chain(ctx, sk) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_CHAIN, 1, (char*)(sk))
+#define SSL_CTX_add0_chain_cert(ctx, x509) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_CHAIN_CERT, 0, (char*)(x509))
+#define SSL_CTX_add1_chain_cert(ctx, x509) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_CHAIN_CERT, 1, (char*)(x509))
+#define SSL_CTX_get0_chain_certs(ctx, px509) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_CHAIN_CERTS, 0, px509)
+#define SSL_CTX_clear_chain_certs(ctx) \
+    SSL_CTX_set0_chain(ctx, NULL)
+#define SSL_CTX_build_cert_chain(ctx, flags) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL)
+#define SSL_CTX_select_current_cert(ctx, x509) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SELECT_CURRENT_CERT, 0, (char*)(x509))
+#define SSL_CTX_set_current_cert(ctx, op) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_CURRENT_CERT, op, NULL)
+#define SSL_CTX_set0_verify_cert_store(ctx, st) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_VERIFY_CERT_STORE, 0, (char*)(st))
+#define SSL_CTX_set1_verify_cert_store(ctx, st) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_VERIFY_CERT_STORE, 1, (char*)(st))
+#define SSL_CTX_get0_verify_cert_store(ctx, st) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_VERIFY_CERT_STORE, 0, (char*)(st))
+#define SSL_CTX_set0_chain_cert_store(ctx, st) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_CHAIN_CERT_STORE, 0, (char*)(st))
+#define SSL_CTX_set1_chain_cert_store(ctx, st) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_CHAIN_CERT_STORE, 1, (char*)(st))
+#define SSL_CTX_get0_chain_cert_store(ctx, st) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_CHAIN_CERT_STORE, 0, (char*)(st))
+#define SSL_set0_chain(s, sk) \
+    SSL_ctrl(s, SSL_CTRL_CHAIN, 0, (char*)(sk))
+#define SSL_set1_chain(s, sk) \
+    SSL_ctrl(s, SSL_CTRL_CHAIN, 1, (char*)(sk))
+#define SSL_add0_chain_cert(s, x509) \
+    SSL_ctrl(s, SSL_CTRL_CHAIN_CERT, 0, (char*)(x509))
+#define SSL_add1_chain_cert(s, x509) \
+    SSL_ctrl(s, SSL_CTRL_CHAIN_CERT, 1, (char*)(x509))
+#define SSL_get0_chain_certs(s, px509) \
+    SSL_ctrl(s, SSL_CTRL_GET_CHAIN_CERTS, 0, px509)
+#define SSL_clear_chain_certs(s) \
+    SSL_set0_chain(s, NULL)
+#define SSL_build_cert_chain(s, flags) \
+    SSL_ctrl(s, SSL_CTRL_BUILD_CERT_CHAIN, flags, NULL)
+#define SSL_select_current_cert(s, x509) \
+    SSL_ctrl(s, SSL_CTRL_SELECT_CURRENT_CERT, 0, (char*)(x509))
+#define SSL_set_current_cert(s, op) \
+    SSL_ctrl(s, SSL_CTRL_SET_CURRENT_CERT, op, NULL)
+#define SSL_set0_verify_cert_store(s, st) \
+    SSL_ctrl(s, SSL_CTRL_SET_VERIFY_CERT_STORE, 0, (char*)(st))
+#define SSL_set1_verify_cert_store(s, st) \
+    SSL_ctrl(s, SSL_CTRL_SET_VERIFY_CERT_STORE, 1, (char*)(st))
+#define SSL_get0_verify_cert_store(s, st) \
+    SSL_ctrl(s, SSL_CTRL_GET_VERIFY_CERT_STORE, 0, (char*)(st))
+#define SSL_set0_chain_cert_store(s, st) \
+    SSL_ctrl(s, SSL_CTRL_SET_CHAIN_CERT_STORE, 0, (char*)(st))
+#define SSL_set1_chain_cert_store(s, st) \
+    SSL_ctrl(s, SSL_CTRL_SET_CHAIN_CERT_STORE, 1, (char*)(st))
+#define SSL_get0_chain_cert_store(s, st) \
+    SSL_ctrl(s, SSL_CTRL_GET_CHAIN_CERT_STORE, 0, (char*)(st))
+
+#define SSL_get1_groups(s, glist) \
+    SSL_ctrl(s, SSL_CTRL_GET_GROUPS, 0, (int*)(glist))
+#define SSL_CTX_set1_groups(ctx, glist, glistlen) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_GROUPS, glistlen, (int*)(glist))
+#define SSL_CTX_set1_groups_list(ctx, s) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_GROUPS_LIST, 0, (char*)(s))
+#define SSL_set1_groups(s, glist, glistlen) \
+    SSL_ctrl(s, SSL_CTRL_SET_GROUPS, glistlen, (char*)(glist))
+#define SSL_set1_groups_list(s, str) \
+    SSL_ctrl(s, SSL_CTRL_SET_GROUPS_LIST, 0, (char*)(str))
+#define SSL_get_shared_group(s, n) \
+    SSL_ctrl(s, SSL_CTRL_GET_SHARED_GROUP, n, NULL)
+#define SSL_get_negotiated_group(s) \
+    SSL_ctrl(s, SSL_CTRL_GET_NEGOTIATED_GROUP, 0, NULL)
+#define SSL_CTX_set1_sigalgs(ctx, slist, slistlen) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_SIGALGS, slistlen, (int*)(slist))
+#define SSL_CTX_set1_sigalgs_list(ctx, s) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_SIGALGS_LIST, 0, (char*)(s))
+#define SSL_set1_sigalgs(s, slist, slistlen) \
+    SSL_ctrl(s, SSL_CTRL_SET_SIGALGS, slistlen, (int*)(slist))
+#define SSL_set1_sigalgs_list(s, str) \
+    SSL_ctrl(s, SSL_CTRL_SET_SIGALGS_LIST, 0, (char*)(str))
+#define SSL_CTX_set1_client_sigalgs(ctx, slist, slistlen) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_CLIENT_SIGALGS, slistlen, (int*)(slist))
+#define SSL_CTX_set1_client_sigalgs_list(ctx, s) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_CLIENT_SIGALGS_LIST, 0, (char*)(s))
+#define SSL_set1_client_sigalgs(s, slist, slistlen) \
+    SSL_ctrl(s, SSL_CTRL_SET_CLIENT_SIGALGS, slistlen, (int*)(slist))
+#define SSL_set1_client_sigalgs_list(s, str) \
+    SSL_ctrl(s, SSL_CTRL_SET_CLIENT_SIGALGS_LIST, 0, (char*)(str))
+#define SSL_get0_certificate_types(s, clist) \
+    SSL_ctrl(s, SSL_CTRL_GET_CLIENT_CERT_TYPES, 0, (char*)(clist))
+#define SSL_CTX_set1_client_certificate_types(ctx, clist, clistlen) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_CLIENT_CERT_TYPES, clistlen, (char*)(clist))
+#define SSL_set1_client_certificate_types(s, clist, clistlen) \
+    SSL_ctrl(s, SSL_CTRL_SET_CLIENT_CERT_TYPES, clistlen, (char*)(clist))
+#define SSL_get_signature_nid(s, pn) \
+    SSL_ctrl(s, SSL_CTRL_GET_SIGNATURE_NID, 0, pn)
+#define SSL_get_peer_signature_nid(s, pn) \
+    SSL_ctrl(s, SSL_CTRL_GET_PEER_SIGNATURE_NID, 0, pn)
+#define SSL_get_peer_tmp_key(s, pk) \
+    SSL_ctrl(s, SSL_CTRL_GET_PEER_TMP_KEY, 0, pk)
+#define SSL_get_tmp_key(s, pk) \
+    SSL_ctrl(s, SSL_CTRL_GET_TMP_KEY, 0, pk)
+#define SSL_get0_raw_cipherlist(s, plst) \
+    SSL_ctrl(s, SSL_CTRL_GET_RAW_CIPHERLIST, 0, plst)
+#define SSL_get0_ec_point_formats(s, plst) \
+    SSL_ctrl(s, SSL_CTRL_GET_EC_POINT_FORMATS, 0, plst)
+#define SSL_CTX_set_min_proto_version(ctx, version) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL)
+#define SSL_CTX_set_max_proto_version(ctx, version) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL)
+#define SSL_CTX_get_min_proto_version(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL)
+#define SSL_CTX_get_max_proto_version(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL)
+#define SSL_set_min_proto_version(s, version) \
+    SSL_ctrl(s, SSL_CTRL_SET_MIN_PROTO_VERSION, version, NULL)
+#define SSL_set_max_proto_version(s, version) \
+    SSL_ctrl(s, SSL_CTRL_SET_MAX_PROTO_VERSION, version, NULL)
+#define SSL_get_min_proto_version(s) \
+    SSL_ctrl(s, SSL_CTRL_GET_MIN_PROTO_VERSION, 0, NULL)
+#define SSL_get_max_proto_version(s) \
+    SSL_ctrl(s, SSL_CTRL_GET_MAX_PROTO_VERSION, 0, NULL)
+
+        const char* SSL_group_to_name(SSL* s, int id);
 
 /* Backwards compatibility, original 1.1.0 names */
-# define SSL_CTRL_GET_SERVER_TMP_KEY \
-         SSL_CTRL_GET_PEER_TMP_KEY
-# define SSL_get_server_tmp_key(s, pk) \
-         SSL_get_peer_tmp_key(s, pk)
+#define SSL_CTRL_GET_SERVER_TMP_KEY \
+    SSL_CTRL_GET_PEER_TMP_KEY
+#define SSL_get_server_tmp_key(s, pk) \
+    SSL_get_peer_tmp_key(s, pk)
 
-int SSL_set0_tmp_dh_pkey(SSL *s, EVP_PKEY *dhpkey);
-int SSL_CTX_set0_tmp_dh_pkey(SSL_CTX *ctx, EVP_PKEY *dhpkey);
+    int SSL_set0_tmp_dh_pkey(SSL* s, EVP_PKEY* dhpkey);
+    int SSL_CTX_set0_tmp_dh_pkey(SSL_CTX* ctx, EVP_PKEY* dhpkey);
 
 /*
  * The following symbol names are old and obsolete. They are kept
  * for compatibility reasons only and should not be used anymore.
  */
-# define SSL_CTRL_GET_CURVES           SSL_CTRL_GET_GROUPS
-# define SSL_CTRL_SET_CURVES           SSL_CTRL_SET_GROUPS
-# define SSL_CTRL_SET_CURVES_LIST      SSL_CTRL_SET_GROUPS_LIST
-# define SSL_CTRL_GET_SHARED_CURVE     SSL_CTRL_GET_SHARED_GROUP
-
-# define SSL_get1_curves               SSL_get1_groups
-# define SSL_CTX_set1_curves           SSL_CTX_set1_groups
-# define SSL_CTX_set1_curves_list      SSL_CTX_set1_groups_list
-# define SSL_set1_curves               SSL_set1_groups
-# define SSL_set1_curves_list          SSL_set1_groups_list
-# define SSL_get_shared_curve          SSL_get_shared_group
-
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define SSL_CTRL_GET_CURVES SSL_CTRL_GET_GROUPS
+#define SSL_CTRL_SET_CURVES SSL_CTRL_SET_GROUPS
+#define SSL_CTRL_SET_CURVES_LIST SSL_CTRL_SET_GROUPS_LIST
+#define SSL_CTRL_GET_SHARED_CURVE SSL_CTRL_GET_SHARED_GROUP
+
+#define SSL_get1_curves SSL_get1_groups
+#define SSL_CTX_set1_curves SSL_CTX_set1_groups
+#define SSL_CTX_set1_curves_list SSL_CTX_set1_groups_list
+#define SSL_set1_curves SSL_set1_groups
+#define SSL_set1_curves_list SSL_set1_groups_list
+#define SSL_get_shared_curve SSL_get_shared_group
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
 /* Provide some compatibility macros for removed functionality. */
-#  define SSL_CTX_need_tmp_RSA(ctx)                0
-#  define SSL_CTX_set_tmp_rsa(ctx,rsa)             1
-#  define SSL_need_tmp_RSA(ssl)                    0
-#  define SSL_set_tmp_rsa(ssl,rsa)                 1
-#  define SSL_CTX_set_ecdh_auto(dummy, onoff)      ((onoff) != 0)
-#  define SSL_set_ecdh_auto(dummy, onoff)          ((onoff) != 0)
+#define SSL_CTX_need_tmp_RSA(ctx) 0
+#define SSL_CTX_set_tmp_rsa(ctx, rsa) 1
+#define SSL_need_tmp_RSA(ssl) 0
+#define SSL_set_tmp_rsa(ssl, rsa) 1
+#define SSL_CTX_set_ecdh_auto(dummy, onoff) ((onoff) != 0)
+#define SSL_set_ecdh_auto(dummy, onoff) ((onoff) != 0)
 /*
  * We "pretend" to call the callback to avoid warnings about unused static
  * functions.
  */
-#  define SSL_CTX_set_tmp_rsa_callback(ctx, cb)    while(0) (cb)(NULL, 0, 0)
-#  define SSL_set_tmp_rsa_callback(ssl, cb)        while(0) (cb)(NULL, 0, 0)
-# endif
-__owur const BIO_METHOD *BIO_f_ssl(void);
-__owur BIO *BIO_new_ssl(SSL_CTX *ctx, int client);
-__owur BIO *BIO_new_ssl_connect(SSL_CTX *ctx);
-__owur BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx);
-__owur int BIO_ssl_copy_session_id(BIO *to, BIO *from);
-void BIO_ssl_shutdown(BIO *ssl_bio);
-
-__owur int SSL_CTX_set_cipher_list(SSL_CTX *, const char *str);
-__owur SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth);
-__owur SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
-                               const SSL_METHOD *meth);
-int SSL_CTX_up_ref(SSL_CTX *ctx);
-void SSL_CTX_free(SSL_CTX *);
-__owur long SSL_CTX_set_timeout(SSL_CTX *ctx, long t);
-__owur long SSL_CTX_get_timeout(const SSL_CTX *ctx);
-__owur X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *);
-void SSL_CTX_set_cert_store(SSL_CTX *, X509_STORE *);
-void SSL_CTX_set1_cert_store(SSL_CTX *, X509_STORE *);
-__owur int SSL_want(const SSL *s);
-__owur int SSL_clear(SSL *s);
-
-void SSL_CTX_flush_sessions(SSL_CTX *ctx, long tm);
-
-__owur const SSL_CIPHER *SSL_get_current_cipher(const SSL *s);
-__owur const SSL_CIPHER *SSL_get_pending_cipher(const SSL *s);
-__owur int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits);
-__owur const char *SSL_CIPHER_get_version(const SSL_CIPHER *c);
-__owur const char *SSL_CIPHER_get_name(const SSL_CIPHER *c);
-__owur const char *SSL_CIPHER_standard_name(const SSL_CIPHER *c);
-__owur const char *OPENSSL_cipher_name(const char *rfc_name);
-__owur uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *c);
-__owur uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER *c);
-__owur int SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c);
-__owur int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c);
-__owur const EVP_MD *SSL_CIPHER_get_handshake_digest(const SSL_CIPHER *c);
-__owur int SSL_CIPHER_is_aead(const SSL_CIPHER *c);
-
-__owur int SSL_get_fd(const SSL *s);
-__owur int SSL_get_rfd(const SSL *s);
-__owur int SSL_get_wfd(const SSL *s);
-__owur const char *SSL_get_cipher_list(const SSL *s, int n);
-__owur char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size);
-__owur int SSL_get_read_ahead(const SSL *s);
-__owur int SSL_pending(const SSL *s);
-__owur int SSL_has_pending(const SSL *s);
-# ifndef OPENSSL_NO_SOCK
-__owur int SSL_set_fd(SSL *s, int fd);
-__owur int SSL_set_rfd(SSL *s, int fd);
-__owur int SSL_set_wfd(SSL *s, int fd);
-# endif
-void SSL_set0_rbio(SSL *s, BIO *rbio);
-void SSL_set0_wbio(SSL *s, BIO *wbio);
-void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio);
-__owur BIO *SSL_get_rbio(const SSL *s);
-__owur BIO *SSL_get_wbio(const SSL *s);
-__owur int SSL_set_cipher_list(SSL *s, const char *str);
-__owur int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str);
-__owur int SSL_set_ciphersuites(SSL *s, const char *str);
-void SSL_set_read_ahead(SSL *s, int yes);
-__owur int SSL_get_verify_mode(const SSL *s);
-__owur int SSL_get_verify_depth(const SSL *s);
-__owur SSL_verify_cb SSL_get_verify_callback(const SSL *s);
-void SSL_set_verify(SSL *s, int mode, SSL_verify_cb callback);
-void SSL_set_verify_depth(SSL *s, int depth);
-void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 __owur int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);
-OSSL_DEPRECATEDIN_3_0
-__owur int SSL_use_RSAPrivateKey_ASN1(SSL *ssl,
-                                      const unsigned char *d, long len);
-# endif
-__owur int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);
-__owur int SSL_use_PrivateKey_ASN1(int pk, SSL *ssl, const unsigned char *d,
-                                   long len);
-__owur int SSL_use_certificate(SSL *ssl, X509 *x);
-__owur int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len);
-__owur int SSL_use_cert_and_key(SSL *ssl, X509 *x509, EVP_PKEY *privatekey,
-                                STACK_OF(X509) *chain, int override);
-
+#define SSL_CTX_set_tmp_rsa_callback(ctx, cb) \
+    while (0)                                 \
+    (cb)(NULL, 0, 0)
+#define SSL_set_tmp_rsa_callback(ssl, cb) \
+    while (0)                             \
+    (cb)(NULL, 0, 0)
+#endif
+    __owur const BIO_METHOD* BIO_f_ssl(void);
+    __owur BIO* BIO_new_ssl(SSL_CTX* ctx, int client);
+    __owur BIO* BIO_new_ssl_connect(SSL_CTX* ctx);
+    __owur BIO* BIO_new_buffer_ssl_connect(SSL_CTX* ctx);
+    __owur int BIO_ssl_copy_session_id(BIO* to, BIO* from);
+    void BIO_ssl_shutdown(BIO* ssl_bio);
+
+    __owur int SSL_CTX_set_cipher_list(SSL_CTX*, const char* str);
+    __owur SSL_CTX* SSL_CTX_new(const SSL_METHOD* meth);
+    __owur SSL_CTX* SSL_CTX_new_ex(OSSL_LIB_CTX* libctx, const char* propq, const SSL_METHOD* meth);
+    int SSL_CTX_up_ref(SSL_CTX* ctx);
+    void SSL_CTX_free(SSL_CTX*);
+    __owur long SSL_CTX_set_timeout(SSL_CTX* ctx, long t);
+    __owur long SSL_CTX_get_timeout(const SSL_CTX* ctx);
+    __owur X509_STORE* SSL_CTX_get_cert_store(const SSL_CTX*);
+    void SSL_CTX_set_cert_store(SSL_CTX*, X509_STORE*);
+    void SSL_CTX_set1_cert_store(SSL_CTX*, X509_STORE*);
+    __owur int SSL_want(const SSL* s);
+    __owur int SSL_clear(SSL* s);
+
+    void SSL_CTX_flush_sessions(SSL_CTX* ctx, long tm);
+
+    __owur const SSL_CIPHER* SSL_get_current_cipher(const SSL* s);
+    __owur const SSL_CIPHER* SSL_get_pending_cipher(const SSL* s);
+    __owur int SSL_CIPHER_get_bits(const SSL_CIPHER* c, int* alg_bits);
+    __owur const char* SSL_CIPHER_get_version(const SSL_CIPHER* c);
+    __owur const char* SSL_CIPHER_get_name(const SSL_CIPHER* c);
+    __owur const char* SSL_CIPHER_standard_name(const SSL_CIPHER* c);
+    __owur const char* OPENSSL_cipher_name(const char* rfc_name);
+    __owur uint32_t SSL_CIPHER_get_id(const SSL_CIPHER* c);
+    __owur uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER* c);
+    __owur int SSL_CIPHER_get_kx_nid(const SSL_CIPHER* c);
+    __owur int SSL_CIPHER_get_auth_nid(const SSL_CIPHER* c);
+    __owur const EVP_MD* SSL_CIPHER_get_handshake_digest(const SSL_CIPHER* c);
+    __owur int SSL_CIPHER_is_aead(const SSL_CIPHER* c);
+
+    __owur int SSL_get_fd(const SSL* s);
+    __owur int SSL_get_rfd(const SSL* s);
+    __owur int SSL_get_wfd(const SSL* s);
+    __owur const char* SSL_get_cipher_list(const SSL* s, int n);
+    __owur char* SSL_get_shared_ciphers(const SSL* s, char* buf, int size);
+    __owur int SSL_get_read_ahead(const SSL* s);
+    __owur int SSL_pending(const SSL* s);
+    __owur int SSL_has_pending(const SSL* s);
+#ifndef OPENSSL_NO_SOCK
+    __owur int SSL_set_fd(SSL* s, int fd);
+    __owur int SSL_set_rfd(SSL* s, int fd);
+    __owur int SSL_set_wfd(SSL* s, int fd);
+#endif
+    void SSL_set0_rbio(SSL* s, BIO* rbio);
+    void SSL_set0_wbio(SSL* s, BIO* wbio);
+    void SSL_set_bio(SSL* s, BIO* rbio, BIO* wbio);
+    __owur BIO* SSL_get_rbio(const SSL* s);
+    __owur BIO* SSL_get_wbio(const SSL* s);
+    __owur int SSL_set_cipher_list(SSL* s, const char* str);
+    __owur int SSL_CTX_set_ciphersuites(SSL_CTX* ctx, const char* str);
+    __owur int SSL_set_ciphersuites(SSL* s, const char* str);
+    void SSL_set_read_ahead(SSL* s, int yes);
+    __owur int SSL_get_verify_mode(const SSL* s);
+    __owur int SSL_get_verify_depth(const SSL* s);
+    __owur SSL_verify_cb SSL_get_verify_callback(const SSL* s);
+    void SSL_set_verify(SSL* s, int mode, SSL_verify_cb callback);
+    void SSL_set_verify_depth(SSL* s, int depth);
+    void SSL_set_cert_cb(SSL* s, int (*cb)(SSL* ssl, void* arg), void* arg);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 __owur int SSL_use_RSAPrivateKey(SSL* ssl, RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0
+    __owur int SSL_use_RSAPrivateKey_ASN1(SSL* ssl, const unsigned char* d, long len);
+#endif
+    __owur int SSL_use_PrivateKey(SSL* ssl, EVP_PKEY* pkey);
+    __owur int SSL_use_PrivateKey_ASN1(int pk, SSL* ssl, const unsigned char* d, long len);
+    __owur int SSL_use_certificate(SSL* ssl, X509* x);
+    __owur int SSL_use_certificate_ASN1(SSL* ssl, const unsigned char* d, int len);
+    __owur int SSL_use_cert_and_key(SSL* ssl, X509* x509, EVP_PKEY* privatekey, STACK_OF(X509) * chain, int override);
 
 /* serverinfo file format versions */
-# define SSL_SERVERINFOV1   1
-# define SSL_SERVERINFOV2   2
+#define SSL_SERVERINFOV1 1
+#define SSL_SERVERINFOV2 2
 
-/* Set serverinfo data for the current active cert. */
-__owur int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,
-                                  size_t serverinfo_length);
-__owur int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
-                                     const unsigned char *serverinfo,
-                                     size_t serverinfo_length);
-__owur int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file);
+    /* Set serverinfo data for the current active cert. */
+    __owur int SSL_CTX_use_serverinfo(SSL_CTX* ctx, const unsigned char* serverinfo, size_t serverinfo_length);
+    __owur int SSL_CTX_use_serverinfo_ex(SSL_CTX* ctx, unsigned int version, const unsigned char* serverinfo, size_t serverinfo_length);
+    __owur int SSL_CTX_use_serverinfo_file(SSL_CTX* ctx, const char* file);
 
 #ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-__owur int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type);
+    OSSL_DEPRECATEDIN_3_0
+    __owur int SSL_use_RSAPrivateKey_file(SSL* ssl, const char* file, int type);
 #endif
 
-__owur int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type);
-__owur int SSL_use_certificate_file(SSL *ssl, const char *file, int type);
+    __owur int SSL_use_PrivateKey_file(SSL* ssl, const char* file, int type);
+    __owur int SSL_use_certificate_file(SSL* ssl, const char* file, int type);
 
 #ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-__owur int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file,
-                                          int type);
+    OSSL_DEPRECATEDIN_3_0
+    __owur int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX* ctx, const char* file, int type);
+#endif
+    __owur int SSL_CTX_use_PrivateKey_file(SSL_CTX* ctx, const char* file, int type);
+    __owur int SSL_CTX_use_certificate_file(SSL_CTX* ctx, const char* file, int type);
+    /* PEM type */
+    __owur int SSL_CTX_use_certificate_chain_file(SSL_CTX* ctx, const char* file);
+    __owur int SSL_use_certificate_chain_file(SSL* ssl, const char* file);
+    __owur STACK_OF(X509_NAME) * SSL_load_client_CA_file(const char* file);
+    __owur STACK_OF(X509_NAME) * SSL_load_client_CA_file_ex(const char* file, OSSL_LIB_CTX* libctx, const char* propq);
+    __owur int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) * stackCAs, const char* file);
+    int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) * stackCAs, const char* dir);
+    int SSL_add_store_cert_subjects_to_stack(STACK_OF(X509_NAME) * stackCAs, const char* uri);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define SSL_load_error_strings() \
+    OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
+#endif
+
+    __owur const char* SSL_state_string(const SSL* s);
+    __owur const char* SSL_rstate_string(const SSL* s);
+    __owur const char* SSL_state_string_long(const SSL* s);
+    __owur const char* SSL_rstate_string_long(const SSL* s);
+    __owur long SSL_SESSION_get_time(const SSL_SESSION* s);
+    __owur long SSL_SESSION_set_time(SSL_SESSION* s, long t);
+    __owur long SSL_SESSION_get_timeout(const SSL_SESSION* s);
+    __owur long SSL_SESSION_set_timeout(SSL_SESSION* s, long t);
+    __owur int SSL_SESSION_get_protocol_version(const SSL_SESSION* s);
+    __owur int SSL_SESSION_set_protocol_version(SSL_SESSION* s, int version);
+
+    __owur const char* SSL_SESSION_get0_hostname(const SSL_SESSION* s);
+    __owur int SSL_SESSION_set1_hostname(SSL_SESSION* s, const char* hostname);
+    void SSL_SESSION_get0_alpn_selected(const SSL_SESSION* s, const unsigned char** alpn, size_t* len);
+    __owur int SSL_SESSION_set1_alpn_selected(SSL_SESSION* s, const unsigned char* alpn, size_t len);
+    __owur const SSL_CIPHER* SSL_SESSION_get0_cipher(const SSL_SESSION* s);
+    __owur int SSL_SESSION_set_cipher(SSL_SESSION* s, const SSL_CIPHER* cipher);
+    __owur int SSL_SESSION_has_ticket(const SSL_SESSION* s);
+    __owur unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION* s);
+    void SSL_SESSION_get0_ticket(const SSL_SESSION* s, const unsigned char** tick, size_t* len);
+    __owur uint32_t SSL_SESSION_get_max_early_data(const SSL_SESSION* s);
+    __owur int SSL_SESSION_set_max_early_data(SSL_SESSION* s, uint32_t max_early_data);
+    __owur int SSL_copy_session_id(SSL* to, const SSL* from);
+    __owur X509* SSL_SESSION_get0_peer(SSL_SESSION* s);
+    __owur int SSL_SESSION_set1_id_context(SSL_SESSION* s, const unsigned char* sid_ctx, unsigned int sid_ctx_len);
+    __owur int SSL_SESSION_set1_id(SSL_SESSION* s, const unsigned char* sid, unsigned int sid_len);
+    __owur int SSL_SESSION_is_resumable(const SSL_SESSION* s);
+
+    __owur SSL_SESSION* SSL_SESSION_new(void);
+    __owur SSL_SESSION* SSL_SESSION_dup(const SSL_SESSION* src);
+    const unsigned char* SSL_SESSION_get_id(const SSL_SESSION* s, unsigned int* len);
+    const unsigned char* SSL_SESSION_get0_id_context(const SSL_SESSION* s, unsigned int* len);
+    __owur unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION* s);
+#ifndef OPENSSL_NO_STDIO
+    int SSL_SESSION_print_fp(FILE* fp, const SSL_SESSION* ses);
 #endif
-__owur int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file,
-                                       int type);
-__owur int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file,
-                                        int type);
-/* PEM type */
-__owur int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file);
-__owur int SSL_use_certificate_chain_file(SSL *ssl, const char *file);
-__owur STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file);
-__owur STACK_OF(X509_NAME)
-*SSL_load_client_CA_file_ex(const char *file, OSSL_LIB_CTX *libctx,
-                            const char *propq);
-__owur int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
-                                               const char *file);
-int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
-                                       const char *dir);
-int SSL_add_store_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs,
-                                       const char *uri);
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define SSL_load_error_strings() \
-    OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS \
-                     | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL)
-# endif
-
-__owur const char *SSL_state_string(const SSL *s);
-__owur const char *SSL_rstate_string(const SSL *s);
-__owur const char *SSL_state_string_long(const SSL *s);
-__owur const char *SSL_rstate_string_long(const SSL *s);
-__owur long SSL_SESSION_get_time(const SSL_SESSION *s);
-__owur long SSL_SESSION_set_time(SSL_SESSION *s, long t);
-__owur long SSL_SESSION_get_timeout(const SSL_SESSION *s);
-__owur long SSL_SESSION_set_timeout(SSL_SESSION *s, long t);
-__owur int SSL_SESSION_get_protocol_version(const SSL_SESSION *s);
-__owur int SSL_SESSION_set_protocol_version(SSL_SESSION *s, int version);
-
-__owur const char *SSL_SESSION_get0_hostname(const SSL_SESSION *s);
-__owur int SSL_SESSION_set1_hostname(SSL_SESSION *s, const char *hostname);
-void SSL_SESSION_get0_alpn_selected(const SSL_SESSION *s,
-                                    const unsigned char **alpn,
-                                    size_t *len);
-__owur int SSL_SESSION_set1_alpn_selected(SSL_SESSION *s,
-                                          const unsigned char *alpn,
-                                          size_t len);
-__owur const SSL_CIPHER *SSL_SESSION_get0_cipher(const SSL_SESSION *s);
-__owur int SSL_SESSION_set_cipher(SSL_SESSION *s, const SSL_CIPHER *cipher);
-__owur int SSL_SESSION_has_ticket(const SSL_SESSION *s);
-__owur unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION *s);
-void SSL_SESSION_get0_ticket(const SSL_SESSION *s, const unsigned char **tick,
-                             size_t *len);
-__owur uint32_t SSL_SESSION_get_max_early_data(const SSL_SESSION *s);
-__owur int SSL_SESSION_set_max_early_data(SSL_SESSION *s,
-                                          uint32_t max_early_data);
-__owur int SSL_copy_session_id(SSL *to, const SSL *from);
-__owur X509 *SSL_SESSION_get0_peer(SSL_SESSION *s);
-__owur int SSL_SESSION_set1_id_context(SSL_SESSION *s,
-                                       const unsigned char *sid_ctx,
-                                       unsigned int sid_ctx_len);
-__owur int SSL_SESSION_set1_id(SSL_SESSION *s, const unsigned char *sid,
-                               unsigned int sid_len);
-__owur int SSL_SESSION_is_resumable(const SSL_SESSION *s);
-
-__owur SSL_SESSION *SSL_SESSION_new(void);
-__owur SSL_SESSION *SSL_SESSION_dup(const SSL_SESSION *src);
-const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s,
-                                        unsigned int *len);
-const unsigned char *SSL_SESSION_get0_id_context(const SSL_SESSION *s,
-                                                 unsigned int *len);
-__owur unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s);
-# ifndef OPENSSL_NO_STDIO
-int SSL_SESSION_print_fp(FILE *fp, const SSL_SESSION *ses);
-# endif
-int SSL_SESSION_print(BIO *fp, const SSL_SESSION *ses);
-int SSL_SESSION_print_keylog(BIO *bp, const SSL_SESSION *x);
-int SSL_SESSION_up_ref(SSL_SESSION *ses);
-void SSL_SESSION_free(SSL_SESSION *ses);
-__owur int i2d_SSL_SESSION(const SSL_SESSION *in, unsigned char **pp);
-__owur int SSL_set_session(SSL *to, SSL_SESSION *session);
-int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *session);
-int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *session);
-__owur int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb);
-__owur int SSL_set_generate_session_id(SSL *s, GEN_SESSION_CB cb);
-__owur int SSL_has_matching_session_id(const SSL *s,
-                                       const unsigned char *id,
-                                       unsigned int id_len);
-SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp,
-                             long length);
-
-# ifdef OPENSSL_X509_H
-__owur X509 *SSL_get0_peer_certificate(const SSL *s);
-__owur X509 *SSL_get1_peer_certificate(const SSL *s);
+    int SSL_SESSION_print(BIO* fp, const SSL_SESSION* ses);
+    int SSL_SESSION_print_keylog(BIO* bp, const SSL_SESSION* x);
+    int SSL_SESSION_up_ref(SSL_SESSION* ses);
+    void SSL_SESSION_free(SSL_SESSION* ses);
+    __owur int i2d_SSL_SESSION(const SSL_SESSION* in, unsigned char** pp);
+    __owur int SSL_set_session(SSL* to, SSL_SESSION* session);
+    int SSL_CTX_add_session(SSL_CTX* ctx, SSL_SESSION* session);
+    int SSL_CTX_remove_session(SSL_CTX* ctx, SSL_SESSION* session);
+    __owur int SSL_CTX_set_generate_session_id(SSL_CTX* ctx, GEN_SESSION_CB cb);
+    __owur int SSL_set_generate_session_id(SSL* s, GEN_SESSION_CB cb);
+    __owur int SSL_has_matching_session_id(const SSL* s, const unsigned char* id, unsigned int id_len);
+    SSL_SESSION* d2i_SSL_SESSION(SSL_SESSION** a, const unsigned char** pp, long length);
+
+#ifdef OPENSSL_X509_H
+    __owur X509* SSL_get0_peer_certificate(const SSL* s);
+    __owur X509* SSL_get1_peer_certificate(const SSL* s);
 /* Deprecated in 3.0.0 */
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   define SSL_get_peer_certificate SSL_get1_peer_certificate
-#  endif
-# endif
-
-__owur STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s);
-
-__owur int SSL_CTX_get_verify_mode(const SSL_CTX *ctx);
-__owur int SSL_CTX_get_verify_depth(const SSL_CTX *ctx);
-__owur SSL_verify_cb SSL_CTX_get_verify_callback(const SSL_CTX *ctx);
-void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, SSL_verify_cb callback);
-void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth);
-void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
-                                      int (*cb) (X509_STORE_CTX *, void *),
-                                      void *arg);
-void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
-                         void *arg);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-__owur int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
-OSSL_DEPRECATEDIN_3_0
-__owur int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d,
-                                          long len);
-# endif
-__owur int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
-__owur int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx,
-                                       const unsigned char *d, long len);
-__owur int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);
-__owur int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len,
-                                        const unsigned char *d);
-__owur int SSL_CTX_use_cert_and_key(SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey,
-                                    STACK_OF(X509) *chain, int override);
-
-void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb);
-void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u);
-pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx);
-void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx);
-void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb);
-void SSL_set_default_passwd_cb_userdata(SSL *s, void *u);
-pem_password_cb *SSL_get_default_passwd_cb(SSL *s);
-void *SSL_get_default_passwd_cb_userdata(SSL *s);
-
-__owur int SSL_CTX_check_private_key(const SSL_CTX *ctx);
-__owur int SSL_check_private_key(const SSL *ctx);
-
-__owur int SSL_CTX_set_session_id_context(SSL_CTX *ctx,
-                                          const unsigned char *sid_ctx,
-                                          unsigned int sid_ctx_len);
-
-SSL *SSL_new(SSL_CTX *ctx);
-int SSL_up_ref(SSL *s);
-int SSL_is_dtls(const SSL *s);
-__owur int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
-                                      unsigned int sid_ctx_len);
-
-__owur int SSL_CTX_set_purpose(SSL_CTX *ctx, int purpose);
-__owur int SSL_set_purpose(SSL *ssl, int purpose);
-__owur int SSL_CTX_set_trust(SSL_CTX *ctx, int trust);
-__owur int SSL_set_trust(SSL *ssl, int trust);
-
-__owur int SSL_set1_host(SSL *s, const char *hostname);
-__owur int SSL_add1_host(SSL *s, const char *hostname);
-__owur const char *SSL_get0_peername(SSL *s);
-void SSL_set_hostflags(SSL *s, unsigned int flags);
-
-__owur int SSL_CTX_dane_enable(SSL_CTX *ctx);
-__owur int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md,
-                                  uint8_t mtype, uint8_t ord);
-__owur int SSL_dane_enable(SSL *s, const char *basedomain);
-__owur int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
-                             uint8_t mtype, const unsigned char *data, size_t dlen);
-__owur int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki);
-__owur int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
-                              uint8_t *mtype, const unsigned char **data,
-                              size_t *dlen);
-/*
- * Bridge opacity barrier between libcrypt and libssl, also needed to support
- * offline testing in test/danetest.c
- */
-SSL_DANE *SSL_get0_dane(SSL *ssl);
-/*
- * DANE flags
- */
-unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags);
-unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags);
-unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags);
-unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags);
-
-__owur int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm);
-__owur int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm);
-
-__owur X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx);
-__owur X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl);
-
-# ifndef OPENSSL_NO_SRP
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name);
-OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password);
-OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength);
-OSSL_DEPRECATEDIN_3_0
-int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx,
-                                        char *(*cb) (SSL *, void *));
-OSSL_DEPRECATEDIN_3_0
-int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx,
-                                          int (*cb) (SSL *, void *));
-OSSL_DEPRECATEDIN_3_0
-int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
-                                      int (*cb) (SSL *, int *, void *));
-OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg);
-
-OSSL_DEPRECATEDIN_3_0
-int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
-                             BIGNUM *sa, BIGNUM *v, char *info);
-OSSL_DEPRECATEDIN_3_0
-int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
-                                const char *grp);
-
-OSSL_DEPRECATEDIN_3_0 __owur BIGNUM *SSL_get_srp_g(SSL *s);
-OSSL_DEPRECATEDIN_3_0 __owur BIGNUM *SSL_get_srp_N(SSL *s);
-
-OSSL_DEPRECATEDIN_3_0 __owur char *SSL_get_srp_username(SSL *s);
-OSSL_DEPRECATEDIN_3_0 __owur char *SSL_get_srp_userinfo(SSL *s);
-#  endif
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SSL_get_peer_certificate SSL_get1_peer_certificate
+#endif
+#endif
 
-/*
- * ClientHello callback and helpers.
- */
+    __owur STACK_OF(X509) * SSL_get_peer_cert_chain(const SSL* s);
 
-# define SSL_CLIENT_HELLO_SUCCESS 1
-# define SSL_CLIENT_HELLO_ERROR   0
-# define SSL_CLIENT_HELLO_RETRY   (-1)
-
-typedef int (*SSL_client_hello_cb_fn) (SSL *s, int *al, void *arg);
-void SSL_CTX_set_client_hello_cb(SSL_CTX *c, SSL_client_hello_cb_fn cb,
-                                 void *arg);
-int SSL_client_hello_isv2(SSL *s);
-unsigned int SSL_client_hello_get0_legacy_version(SSL *s);
-size_t SSL_client_hello_get0_random(SSL *s, const unsigned char **out);
-size_t SSL_client_hello_get0_session_id(SSL *s, const unsigned char **out);
-size_t SSL_client_hello_get0_ciphers(SSL *s, const unsigned char **out);
-size_t SSL_client_hello_get0_compression_methods(SSL *s,
-                                                 const unsigned char **out);
-int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen);
-int SSL_client_hello_get0_ext(SSL *s, unsigned int type,
-                              const unsigned char **out, size_t *outlen);
-
-void SSL_certs_clear(SSL *s);
-void SSL_free(SSL *ssl);
-# ifdef OSSL_ASYNC_FD
-/*
- * Windows application developer has to include windows.h to use these.
- */
-__owur int SSL_waiting_for_async(SSL *s);
-__owur int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds);
-__owur int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd,
-                                     size_t *numaddfds, OSSL_ASYNC_FD *delfd,
-                                     size_t *numdelfds);
-__owur int SSL_CTX_set_async_callback(SSL_CTX *ctx, SSL_async_callback_fn callback);
-__owur int SSL_CTX_set_async_callback_arg(SSL_CTX *ctx, void *arg);
-__owur int SSL_set_async_callback(SSL *s, SSL_async_callback_fn callback);
-__owur int SSL_set_async_callback_arg(SSL *s, void *arg);
-__owur int SSL_get_async_status(SSL *s, int *status);
-
-# endif
-__owur int SSL_accept(SSL *ssl);
-__owur int SSL_stateless(SSL *s);
-__owur int SSL_connect(SSL *ssl);
-__owur int SSL_read(SSL *ssl, void *buf, int num);
-__owur int SSL_read_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes);
-
-# define SSL_READ_EARLY_DATA_ERROR   0
-# define SSL_READ_EARLY_DATA_SUCCESS 1
-# define SSL_READ_EARLY_DATA_FINISH  2
-
-__owur int SSL_read_early_data(SSL *s, void *buf, size_t num,
-                               size_t *readbytes);
-__owur int SSL_peek(SSL *ssl, void *buf, int num);
-__owur int SSL_peek_ex(SSL *ssl, void *buf, size_t num, size_t *readbytes);
-__owur ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size,
-                                 int flags);
-__owur int SSL_write(SSL *ssl, const void *buf, int num);
-__owur int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written);
-__owur int SSL_write_early_data(SSL *s, const void *buf, size_t num,
-                                size_t *written);
-long SSL_ctrl(SSL *ssl, int cmd, long larg, void *parg);
-long SSL_callback_ctrl(SSL *, int, void (*)(void));
-long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg);
-long SSL_CTX_callback_ctrl(SSL_CTX *, int, void (*)(void));
-
-# define SSL_EARLY_DATA_NOT_SENT    0
-# define SSL_EARLY_DATA_REJECTED    1
-# define SSL_EARLY_DATA_ACCEPTED    2
-
-__owur int SSL_get_early_data_status(const SSL *s);
-
-__owur int SSL_get_error(const SSL *s, int ret_code);
-__owur const char *SSL_get_version(const SSL *s);
+    __owur int SSL_CTX_get_verify_mode(const SSL_CTX* ctx);
+    __owur int SSL_CTX_get_verify_depth(const SSL_CTX* ctx);
+    __owur SSL_verify_cb SSL_CTX_get_verify_callback(const SSL_CTX* ctx);
+    void SSL_CTX_set_verify(SSL_CTX* ctx, int mode, SSL_verify_cb callback);
+    void SSL_CTX_set_verify_depth(SSL_CTX* ctx, int depth);
+    void SSL_CTX_set_cert_verify_callback(SSL_CTX* ctx, int (*cb)(X509_STORE_CTX*, void*), void* arg);
+    void SSL_CTX_set_cert_cb(SSL_CTX* c, int (*cb)(SSL* ssl, void* arg), void* arg);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    __owur int SSL_CTX_use_RSAPrivateKey(SSL_CTX* ctx, RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0
+    __owur int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX* ctx, const unsigned char* d, long len);
+#endif
+    __owur int SSL_CTX_use_PrivateKey(SSL_CTX* ctx, EVP_PKEY* pkey);
+    __owur int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX* ctx, const unsigned char* d, long len);
+    __owur int SSL_CTX_use_certificate(SSL_CTX* ctx, X509* x);
+    __owur int SSL_CTX_use_certificate_ASN1(SSL_CTX* ctx, int len, const unsigned char* d);
+    __owur int SSL_CTX_use_cert_and_key(SSL_CTX* ctx, X509* x509, EVP_PKEY* privatekey, STACK_OF(X509) * chain, int override);
+
+    void SSL_CTX_set_default_passwd_cb(SSL_CTX* ctx, pem_password_cb* cb);
+    void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX* ctx, void* u);
+    pem_password_cb* SSL_CTX_get_default_passwd_cb(SSL_CTX* ctx);
+    void* SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX* ctx);
+    void SSL_set_default_passwd_cb(SSL* s, pem_password_cb* cb);
+    void SSL_set_default_passwd_cb_userdata(SSL* s, void* u);
+    pem_password_cb* SSL_get_default_passwd_cb(SSL* s);
+    void* SSL_get_default_passwd_cb_userdata(SSL* s);
+
+    __owur int SSL_CTX_check_private_key(const SSL_CTX* ctx);
+    __owur int SSL_check_private_key(const SSL* ctx);
+
+    __owur int SSL_CTX_set_session_id_context(SSL_CTX* ctx, const unsigned char* sid_ctx, unsigned int sid_ctx_len);
+
+    SSL* SSL_new(SSL_CTX* ctx);
+    int SSL_up_ref(SSL* s);
+    int SSL_is_dtls(const SSL* s);
+    __owur int SSL_set_session_id_context(SSL* ssl, const unsigned char* sid_ctx, unsigned int sid_ctx_len);
+
+    __owur int SSL_CTX_set_purpose(SSL_CTX* ctx, int purpose);
+    __owur int SSL_set_purpose(SSL* ssl, int purpose);
+    __owur int SSL_CTX_set_trust(SSL_CTX* ctx, int trust);
+    __owur int SSL_set_trust(SSL* ssl, int trust);
+
+    __owur int SSL_set1_host(SSL* s, const char* hostname);
+    __owur int SSL_add1_host(SSL* s, const char* hostname);
+    __owur const char* SSL_get0_peername(SSL* s);
+    void SSL_set_hostflags(SSL* s, unsigned int flags);
+
+    __owur int SSL_CTX_dane_enable(SSL_CTX* ctx);
+    __owur int SSL_CTX_dane_mtype_set(SSL_CTX* ctx, const EVP_MD* md, uint8_t mtype, uint8_t ord);
+    __owur int SSL_dane_enable(SSL* s, const char* basedomain);
+    __owur int SSL_dane_tlsa_add(SSL* s, uint8_t usage, uint8_t selector, uint8_t mtype, const unsigned char* data, size_t dlen);
+    __owur int SSL_get0_dane_authority(SSL* s, X509** mcert, EVP_PKEY** mspki);
+    __owur int SSL_get0_dane_tlsa(SSL* s, uint8_t* usage, uint8_t* selector, uint8_t* mtype, const unsigned char** data, size_t* dlen);
+    /*
+     * Bridge opacity barrier between libcrypt and libssl, also needed to support
+     * offline testing in test/danetest.c
+     */
+    SSL_DANE* SSL_get0_dane(SSL* ssl);
+    /*
+     * DANE flags
+     */
+    unsigned long SSL_CTX_dane_set_flags(SSL_CTX* ctx, unsigned long flags);
+    unsigned long SSL_CTX_dane_clear_flags(SSL_CTX* ctx, unsigned long flags);
+    unsigned long SSL_dane_set_flags(SSL* ssl, unsigned long flags);
+    unsigned long SSL_dane_clear_flags(SSL* ssl, unsigned long flags);
+
+    __owur int SSL_CTX_set1_param(SSL_CTX* ctx, X509_VERIFY_PARAM* vpm);
+    __owur int SSL_set1_param(SSL* ssl, X509_VERIFY_PARAM* vpm);
+
+    __owur X509_VERIFY_PARAM* SSL_CTX_get0_param(SSL_CTX* ctx);
+    __owur X509_VERIFY_PARAM* SSL_get0_param(SSL* ssl);
+
+#ifndef OPENSSL_NO_SRP
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_username(SSL_CTX* ctx, char* name);
+    OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_password(SSL_CTX* ctx, char* password);
+    OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_strength(SSL_CTX* ctx, int strength);
+    OSSL_DEPRECATEDIN_3_0
+    int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX* ctx, char* (*cb)(SSL*, void*));
+    OSSL_DEPRECATEDIN_3_0
+    int SSL_CTX_set_srp_verify_param_callback(SSL_CTX* ctx, int (*cb)(SSL*, void*));
+    OSSL_DEPRECATEDIN_3_0
+    int SSL_CTX_set_srp_username_callback(SSL_CTX* ctx, int (*cb)(SSL*, int*, void*));
+    OSSL_DEPRECATEDIN_3_0 int SSL_CTX_set_srp_cb_arg(SSL_CTX* ctx, void* arg);
+
+    OSSL_DEPRECATEDIN_3_0
+    int SSL_set_srp_server_param(SSL* s, const BIGNUM* N, const BIGNUM* g, BIGNUM* sa, BIGNUM* v, char* info);
+    OSSL_DEPRECATEDIN_3_0
+    int SSL_set_srp_server_param_pw(SSL* s, const char* user, const char* pass, const char* grp);
+
+    OSSL_DEPRECATEDIN_3_0 __owur BIGNUM* SSL_get_srp_g(SSL* s);
+    OSSL_DEPRECATEDIN_3_0 __owur BIGNUM* SSL_get_srp_N(SSL* s);
+
+    OSSL_DEPRECATEDIN_3_0 __owur char* SSL_get_srp_username(SSL* s);
+    OSSL_DEPRECATEDIN_3_0 __owur char* SSL_get_srp_userinfo(SSL* s);
+#endif
+#endif
+
+    /*
+     * ClientHello callback and helpers.
+     */
+
+#define SSL_CLIENT_HELLO_SUCCESS 1
+#define SSL_CLIENT_HELLO_ERROR 0
+#define SSL_CLIENT_HELLO_RETRY (-1)
+
+    typedef int (*SSL_client_hello_cb_fn)(SSL* s, int* al, void* arg);
+    void SSL_CTX_set_client_hello_cb(SSL_CTX* c, SSL_client_hello_cb_fn cb, void* arg);
+    int SSL_client_hello_isv2(SSL* s);
+    unsigned int SSL_client_hello_get0_legacy_version(SSL* s);
+    size_t SSL_client_hello_get0_random(SSL* s, const unsigned char** out);
+    size_t SSL_client_hello_get0_session_id(SSL* s, const unsigned char** out);
+    size_t SSL_client_hello_get0_ciphers(SSL* s, const unsigned char** out);
+    size_t SSL_client_hello_get0_compression_methods(SSL* s, const unsigned char** out);
+    int SSL_client_hello_get1_extensions_present(SSL* s, int** out, size_t* outlen);
+    int SSL_client_hello_get0_ext(SSL* s, unsigned int type, const unsigned char** out, size_t* outlen);
+
+    void SSL_certs_clear(SSL* s);
+    void SSL_free(SSL* ssl);
+#ifdef OSSL_ASYNC_FD
+    /*
+     * Windows application developer has to include windows.h to use these.
+     */
+    __owur int SSL_waiting_for_async(SSL* s);
+    __owur int SSL_get_all_async_fds(SSL* s, OSSL_ASYNC_FD* fds, size_t* numfds);
+    __owur int SSL_get_changed_async_fds(SSL* s, OSSL_ASYNC_FD* addfd, size_t* numaddfds, OSSL_ASYNC_FD* delfd, size_t* numdelfds);
+    __owur int SSL_CTX_set_async_callback(SSL_CTX* ctx, SSL_async_callback_fn callback);
+    __owur int SSL_CTX_set_async_callback_arg(SSL_CTX* ctx, void* arg);
+    __owur int SSL_set_async_callback(SSL* s, SSL_async_callback_fn callback);
+    __owur int SSL_set_async_callback_arg(SSL* s, void* arg);
+    __owur int SSL_get_async_status(SSL* s, int* status);
+
+#endif
+    __owur int SSL_accept(SSL* ssl);
+    __owur int SSL_stateless(SSL* s);
+    __owur int SSL_connect(SSL* ssl);
+    __owur int SSL_read(SSL* ssl, void* buf, int num);
+    __owur int SSL_read_ex(SSL* ssl, void* buf, size_t num, size_t* readbytes);
+
+#define SSL_READ_EARLY_DATA_ERROR 0
+#define SSL_READ_EARLY_DATA_SUCCESS 1
+#define SSL_READ_EARLY_DATA_FINISH 2
+
+    __owur int SSL_read_early_data(SSL* s, void* buf, size_t num, size_t* readbytes);
+    __owur int SSL_peek(SSL* ssl, void* buf, int num);
+    __owur int SSL_peek_ex(SSL* ssl, void* buf, size_t num, size_t* readbytes);
+    __owur ossl_ssize_t SSL_sendfile(SSL* s, int fd, off_t offset, size_t size, int flags);
+    __owur int SSL_write(SSL* ssl, const void* buf, int num);
+    __owur int SSL_write_ex(SSL* s, const void* buf, size_t num, size_t* written);
+    __owur int SSL_write_early_data(SSL* s, const void* buf, size_t num, size_t* written);
+    long SSL_ctrl(SSL* ssl, int cmd, long larg, void* parg);
+    long SSL_callback_ctrl(SSL*, int, void (*)(void));
+    long SSL_CTX_ctrl(SSL_CTX* ctx, int cmd, long larg, void* parg);
+    long SSL_CTX_callback_ctrl(SSL_CTX*, int, void (*)(void));
+
+#define SSL_EARLY_DATA_NOT_SENT 0
+#define SSL_EARLY_DATA_REJECTED 1
+#define SSL_EARLY_DATA_ACCEPTED 2
+
+    __owur int SSL_get_early_data_status(const SSL* s);
+
+    __owur int SSL_get_error(const SSL* s, int ret_code);
+    __owur const char* SSL_get_version(const SSL* s);
 
 /* This sets the 'default' SSL version that SSL_new() will create */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-__owur int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth);
-# endif
-
-# ifndef OPENSSL_NO_SSL3_METHOD
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_method(void); /* SSLv3 */
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_server_method(void);
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *SSLv3_client_method(void);
-#  endif
-# endif
-
-#define SSLv23_method           TLS_method
-#define SSLv23_server_method    TLS_server_method
-#define SSLv23_client_method    TLS_client_method
-
-/* Negotiate highest available SSL/TLS version */
-__owur const SSL_METHOD *TLS_method(void);
-__owur const SSL_METHOD *TLS_server_method(void);
-__owur const SSL_METHOD *TLS_client_method(void);
-
-# ifndef OPENSSL_NO_TLS1_METHOD
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_method(void); /* TLSv1.0 */
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_server_method(void);
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_client_method(void);
-#  endif
-# endif
-
-# ifndef OPENSSL_NO_TLS1_1_METHOD
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_method(void); /* TLSv1.1 */
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_server_method(void);
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_1_client_method(void);
-#  endif
-# endif
-
-# ifndef OPENSSL_NO_TLS1_2_METHOD
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_method(void); /* TLSv1.2 */
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_server_method(void);
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *TLSv1_2_client_method(void);
-#  endif
-# endif
-
-# ifndef OPENSSL_NO_DTLS1_METHOD
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_method(void); /* DTLSv1.0 */
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_server_method(void);
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_client_method(void);
-#  endif
-# endif
-
-# ifndef OPENSSL_NO_DTLS1_2_METHOD
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    __owur int SSL_CTX_set_ssl_version(SSL_CTX* ctx, const SSL_METHOD* meth);
+#endif
+
+#ifndef OPENSSL_NO_SSL3_METHOD
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* SSLv3_method(void); /* SSLv3 */
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* SSLv3_server_method(void);
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* SSLv3_client_method(void);
+#endif
+#endif
+
+#define SSLv23_method TLS_method
+#define SSLv23_server_method TLS_server_method
+#define SSLv23_client_method TLS_client_method
+
+    /* Negotiate highest available SSL/TLS version */
+    __owur const SSL_METHOD* TLS_method(void);
+    __owur const SSL_METHOD* TLS_server_method(void);
+    __owur const SSL_METHOD* TLS_client_method(void);
+
+#ifndef OPENSSL_NO_TLS1_METHOD
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_method(void); /* TLSv1.0 */
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_server_method(void);
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_client_method(void);
+#endif
+#endif
+
+#ifndef OPENSSL_NO_TLS1_1_METHOD
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_1_method(void); /* TLSv1.1 */
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_1_server_method(void);
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_1_client_method(void);
+#endif
+#endif
+
+#ifndef OPENSSL_NO_TLS1_2_METHOD
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_2_method(void); /* TLSv1.2 */
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_2_server_method(void);
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* TLSv1_2_client_method(void);
+#endif
+#endif
+
+#ifndef OPENSSL_NO_DTLS1_METHOD
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* DTLSv1_method(void); /* DTLSv1.0 */
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* DTLSv1_server_method(void);
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* DTLSv1_client_method(void);
+#endif
+#endif
+
+#ifndef OPENSSL_NO_DTLS1_2_METHOD
 /* DTLSv1.2 */
-#  ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_method(void);
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_server_method(void);
-OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD *DTLSv1_2_client_method(void);
-#  endif
-# endif
-
-__owur const SSL_METHOD *DTLS_method(void); /* DTLS 1.0 and 1.2 */
-__owur const SSL_METHOD *DTLS_server_method(void); /* DTLS 1.0 and 1.2 */
-__owur const SSL_METHOD *DTLS_client_method(void); /* DTLS 1.0 and 1.2 */
-
-__owur size_t DTLS_get_data_mtu(const SSL *s);
-
-__owur STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s);
-__owur STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx);
-__owur STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s);
-__owur STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s);
-
-__owur int SSL_do_handshake(SSL *s);
-int SSL_key_update(SSL *s, int updatetype);
-int SSL_get_key_update_type(const SSL *s);
-int SSL_renegotiate(SSL *s);
-int SSL_renegotiate_abbreviated(SSL *s);
-__owur int SSL_renegotiate_pending(const SSL *s);
-int SSL_new_session_ticket(SSL *s);
-int SSL_shutdown(SSL *s);
-__owur int SSL_verify_client_post_handshake(SSL *s);
-void SSL_CTX_set_post_handshake_auth(SSL_CTX *ctx, int val);
-void SSL_set_post_handshake_auth(SSL *s, int val);
-
-__owur const SSL_METHOD *SSL_CTX_get_ssl_method(const SSL_CTX *ctx);
-__owur const SSL_METHOD *SSL_get_ssl_method(const SSL *s);
-__owur int SSL_set_ssl_method(SSL *s, const SSL_METHOD *method);
-__owur const char *SSL_alert_type_string_long(int value);
-__owur const char *SSL_alert_type_string(int value);
-__owur const char *SSL_alert_desc_string_long(int value);
-__owur const char *SSL_alert_desc_string(int value);
-
-void SSL_set0_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list);
-void SSL_CTX_set0_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list);
-__owur const STACK_OF(X509_NAME) *SSL_get0_CA_list(const SSL *s);
-__owur const STACK_OF(X509_NAME) *SSL_CTX_get0_CA_list(const SSL_CTX *ctx);
-__owur int SSL_add1_to_CA_list(SSL *ssl, const X509 *x);
-__owur int SSL_CTX_add1_to_CA_list(SSL_CTX *ctx, const X509 *x);
-__owur const STACK_OF(X509_NAME) *SSL_get0_peer_CA_list(const SSL *s);
-
-void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list);
-void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list);
-__owur STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s);
-__owur STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *s);
-__owur int SSL_add_client_CA(SSL *ssl, X509 *x);
-__owur int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x);
-
-void SSL_set_connect_state(SSL *s);
-void SSL_set_accept_state(SSL *s);
-
-__owur long SSL_get_default_timeout(const SSL *s);
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define SSL_library_init() OPENSSL_init_ssl(0, NULL)
-# endif
-
-__owur char *SSL_CIPHER_description(const SSL_CIPHER *, char *buf, int size);
-__owur STACK_OF(X509_NAME) *SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk);
-
-__owur SSL *SSL_dup(SSL *ssl);
-
-__owur X509 *SSL_get_certificate(const SSL *ssl);
-/*
- * EVP_PKEY
- */
-struct evp_pkey_st *SSL_get_privatekey(const SSL *ssl);
-
-__owur X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx);
-__owur EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx);
-
-void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode);
-__owur int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx);
-void SSL_set_quiet_shutdown(SSL *ssl, int mode);
-__owur int SSL_get_quiet_shutdown(const SSL *ssl);
-void SSL_set_shutdown(SSL *ssl, int mode);
-__owur int SSL_get_shutdown(const SSL *ssl);
-__owur int SSL_version(const SSL *ssl);
-__owur int SSL_client_version(const SSL *s);
-__owur int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);
-__owur int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx);
-__owur int SSL_CTX_set_default_verify_file(SSL_CTX *ctx);
-__owur int SSL_CTX_set_default_verify_store(SSL_CTX *ctx);
-__owur int SSL_CTX_load_verify_file(SSL_CTX *ctx, const char *CAfile);
-__owur int SSL_CTX_load_verify_dir(SSL_CTX *ctx, const char *CApath);
-__owur int SSL_CTX_load_verify_store(SSL_CTX *ctx, const char *CAstore);
-__owur int SSL_CTX_load_verify_locations(SSL_CTX *ctx,
-                                                        const char *CAfile,
-                                                        const char *CApath);
-# define SSL_get0_session SSL_get_session/* just peek at pointer */
-__owur SSL_SESSION *SSL_get_session(const SSL *ssl);
-__owur SSL_SESSION *SSL_get1_session(SSL *ssl); /* obtain a reference count */
-__owur SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl);
-SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx);
-void SSL_set_info_callback(SSL *ssl,
-                           void (*cb) (const SSL *ssl, int type, int val));
-void (*SSL_get_info_callback(const SSL *ssl)) (const SSL *ssl, int type,
-                                               int val);
-__owur OSSL_HANDSHAKE_STATE SSL_get_state(const SSL *ssl);
-
-void SSL_set_verify_result(SSL *ssl, long v);
-__owur long SSL_get_verify_result(const SSL *ssl);
-__owur STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s);
-
-__owur size_t SSL_get_client_random(const SSL *ssl, unsigned char *out,
-                                    size_t outlen);
-__owur size_t SSL_get_server_random(const SSL *ssl, unsigned char *out,
-                                    size_t outlen);
-__owur size_t SSL_SESSION_get_master_key(const SSL_SESSION *sess,
-                                         unsigned char *out, size_t outlen);
-__owur int SSL_SESSION_set1_master_key(SSL_SESSION *sess,
-                                       const unsigned char *in, size_t len);
-uint8_t SSL_SESSION_get_max_fragment_length(const SSL_SESSION *sess);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* DTLSv1_2_method(void);
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* DTLSv1_2_server_method(void);
+    OSSL_DEPRECATEDIN_1_1_0 __owur const SSL_METHOD* DTLSv1_2_client_method(void);
+#endif
+#endif
+
+    __owur const SSL_METHOD* DTLS_method(void);        /* DTLS 1.0 and 1.2 */
+    __owur const SSL_METHOD* DTLS_server_method(void); /* DTLS 1.0 and 1.2 */
+    __owur const SSL_METHOD* DTLS_client_method(void); /* DTLS 1.0 and 1.2 */
+
+    __owur size_t DTLS_get_data_mtu(const SSL* s);
+
+    __owur STACK_OF(SSL_CIPHER) * SSL_get_ciphers(const SSL* s);
+    __owur STACK_OF(SSL_CIPHER) * SSL_CTX_get_ciphers(const SSL_CTX* ctx);
+    __owur STACK_OF(SSL_CIPHER) * SSL_get_client_ciphers(const SSL* s);
+    __owur STACK_OF(SSL_CIPHER) * SSL_get1_supported_ciphers(SSL* s);
+
+    __owur int SSL_do_handshake(SSL* s);
+    int SSL_key_update(SSL* s, int updatetype);
+    int SSL_get_key_update_type(const SSL* s);
+    int SSL_renegotiate(SSL* s);
+    int SSL_renegotiate_abbreviated(SSL* s);
+    __owur int SSL_renegotiate_pending(const SSL* s);
+    int SSL_new_session_ticket(SSL* s);
+    int SSL_shutdown(SSL* s);
+    __owur int SSL_verify_client_post_handshake(SSL* s);
+    void SSL_CTX_set_post_handshake_auth(SSL_CTX* ctx, int val);
+    void SSL_set_post_handshake_auth(SSL* s, int val);
+
+    __owur const SSL_METHOD* SSL_CTX_get_ssl_method(const SSL_CTX* ctx);
+    __owur const SSL_METHOD* SSL_get_ssl_method(const SSL* s);
+    __owur int SSL_set_ssl_method(SSL* s, const SSL_METHOD* method);
+    __owur const char* SSL_alert_type_string_long(int value);
+    __owur const char* SSL_alert_type_string(int value);
+    __owur const char* SSL_alert_desc_string_long(int value);
+    __owur const char* SSL_alert_desc_string(int value);
+
+    void SSL_set0_CA_list(SSL* s, STACK_OF(X509_NAME) * name_list);
+    void SSL_CTX_set0_CA_list(SSL_CTX* ctx, STACK_OF(X509_NAME) * name_list);
+    __owur const STACK_OF(X509_NAME) * SSL_get0_CA_list(const SSL* s);
+    __owur const STACK_OF(X509_NAME) * SSL_CTX_get0_CA_list(const SSL_CTX* ctx);
+    __owur int SSL_add1_to_CA_list(SSL* ssl, const X509* x);
+    __owur int SSL_CTX_add1_to_CA_list(SSL_CTX* ctx, const X509* x);
+    __owur const STACK_OF(X509_NAME) * SSL_get0_peer_CA_list(const SSL* s);
+
+    void SSL_set_client_CA_list(SSL* s, STACK_OF(X509_NAME) * name_list);
+    void SSL_CTX_set_client_CA_list(SSL_CTX* ctx, STACK_OF(X509_NAME) * name_list);
+    __owur STACK_OF(X509_NAME) * SSL_get_client_CA_list(const SSL* s);
+    __owur STACK_OF(X509_NAME) * SSL_CTX_get_client_CA_list(const SSL_CTX* s);
+    __owur int SSL_add_client_CA(SSL* ssl, X509* x);
+    __owur int SSL_CTX_add_client_CA(SSL_CTX* ctx, X509* x);
+
+    void SSL_set_connect_state(SSL* s);
+    void SSL_set_accept_state(SSL* s);
+
+    __owur long SSL_get_default_timeout(const SSL* s);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define SSL_library_init() OPENSSL_init_ssl(0, NULL)
+#endif
+
+    __owur char* SSL_CIPHER_description(const SSL_CIPHER*, char* buf, int size);
+    __owur STACK_OF(X509_NAME) * SSL_dup_CA_list(const STACK_OF(X509_NAME) * sk);
+
+    __owur SSL* SSL_dup(SSL* ssl);
+
+    __owur X509* SSL_get_certificate(const SSL* ssl);
+    /*
+     * EVP_PKEY
+     */
+    struct evp_pkey_st* SSL_get_privatekey(const SSL* ssl);
+
+    __owur X509* SSL_CTX_get0_certificate(const SSL_CTX* ctx);
+    __owur EVP_PKEY* SSL_CTX_get0_privatekey(const SSL_CTX* ctx);
+
+    void SSL_CTX_set_quiet_shutdown(SSL_CTX* ctx, int mode);
+    __owur int SSL_CTX_get_quiet_shutdown(const SSL_CTX* ctx);
+    void SSL_set_quiet_shutdown(SSL* ssl, int mode);
+    __owur int SSL_get_quiet_shutdown(const SSL* ssl);
+    void SSL_set_shutdown(SSL* ssl, int mode);
+    __owur int SSL_get_shutdown(const SSL* ssl);
+    __owur int SSL_version(const SSL* ssl);
+    __owur int SSL_client_version(const SSL* s);
+    __owur int SSL_CTX_set_default_verify_paths(SSL_CTX* ctx);
+    __owur int SSL_CTX_set_default_verify_dir(SSL_CTX* ctx);
+    __owur int SSL_CTX_set_default_verify_file(SSL_CTX* ctx);
+    __owur int SSL_CTX_set_default_verify_store(SSL_CTX* ctx);
+    __owur int SSL_CTX_load_verify_file(SSL_CTX* ctx, const char* CAfile);
+    __owur int SSL_CTX_load_verify_dir(SSL_CTX* ctx, const char* CApath);
+    __owur int SSL_CTX_load_verify_store(SSL_CTX* ctx, const char* CAstore);
+    __owur int SSL_CTX_load_verify_locations(SSL_CTX* ctx, const char* CAfile, const char* CApath);
+#define SSL_get0_session SSL_get_session /* just peek at pointer */
+    __owur SSL_SESSION* SSL_get_session(const SSL* ssl);
+    __owur SSL_SESSION* SSL_get1_session(SSL* ssl); /* obtain a reference count */
+    __owur SSL_CTX* SSL_get_SSL_CTX(const SSL* ssl);
+    SSL_CTX* SSL_set_SSL_CTX(SSL* ssl, SSL_CTX* ctx);
+    void SSL_set_info_callback(SSL* ssl, void (*cb)(const SSL* ssl, int type, int val));
+    void (*SSL_get_info_callback(const SSL* ssl))(const SSL* ssl, int type, int val);
+    __owur OSSL_HANDSHAKE_STATE SSL_get_state(const SSL* ssl);
+
+    void SSL_set_verify_result(SSL* ssl, long v);
+    __owur long SSL_get_verify_result(const SSL* ssl);
+    __owur STACK_OF(X509) * SSL_get0_verified_chain(const SSL* s);
+
+    __owur size_t SSL_get_client_random(const SSL* ssl, unsigned char* out, size_t outlen);
+    __owur size_t SSL_get_server_random(const SSL* ssl, unsigned char* out, size_t outlen);
+    __owur size_t SSL_SESSION_get_master_key(const SSL_SESSION* sess, unsigned char* out, size_t outlen);
+    __owur int SSL_SESSION_set1_master_key(SSL_SESSION* sess, const unsigned char* in, size_t len);
+    uint8_t SSL_SESSION_get_max_fragment_length(const SSL_SESSION* sess);
 
 #define SSL_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, l, p, newf, dupf, freef)
-__owur int SSL_set_ex_data(SSL *ssl, int idx, void *data);
-void *SSL_get_ex_data(const SSL *ssl, int idx);
+    __owur int SSL_set_ex_data(SSL* ssl, int idx, void* data);
+    void* SSL_get_ex_data(const SSL* ssl, int idx);
 #define SSL_SESSION_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_SESSION, l, p, newf, dupf, freef)
-__owur int SSL_SESSION_set_ex_data(SSL_SESSION *ss, int idx, void *data);
-void *SSL_SESSION_get_ex_data(const SSL_SESSION *ss, int idx);
+    __owur int SSL_SESSION_set_ex_data(SSL_SESSION* ss, int idx, void* data);
+    void* SSL_SESSION_get_ex_data(const SSL_SESSION* ss, int idx);
 #define SSL_CTX_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, l, p, newf, dupf, freef)
-__owur int SSL_CTX_set_ex_data(SSL_CTX *ssl, int idx, void *data);
-void *SSL_CTX_get_ex_data(const SSL_CTX *ssl, int idx);
-
-__owur int SSL_get_ex_data_X509_STORE_CTX_idx(void);
-
-# define SSL_CTX_sess_set_cache_size(ctx,t) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_SIZE,t,NULL)
-# define SSL_CTX_sess_get_cache_size(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_SIZE,0,NULL)
-# define SSL_CTX_set_session_cache_mode(ctx,m) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_MODE,m,NULL)
-# define SSL_CTX_get_session_cache_mode(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_MODE,0,NULL)
-
-# define SSL_CTX_get_default_read_ahead(ctx) SSL_CTX_get_read_ahead(ctx)
-# define SSL_CTX_set_default_read_ahead(ctx,m) SSL_CTX_set_read_ahead(ctx,m)
-# define SSL_CTX_get_read_ahead(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_READ_AHEAD,0,NULL)
-# define SSL_CTX_set_read_ahead(ctx,m) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_READ_AHEAD,m,NULL)
-# define SSL_CTX_get_max_cert_list(ctx) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL)
-# define SSL_CTX_set_max_cert_list(ctx,m) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL)
-# define SSL_get_max_cert_list(ssl) \
-        SSL_ctrl(ssl,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL)
-# define SSL_set_max_cert_list(ssl,m) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL)
-
-# define SSL_CTX_set_max_send_fragment(ctx,m) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL)
-# define SSL_set_max_send_fragment(ssl,m) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL)
-# define SSL_CTX_set_split_send_fragment(ctx,m) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SPLIT_SEND_FRAGMENT,m,NULL)
-# define SSL_set_split_send_fragment(ssl,m) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_SPLIT_SEND_FRAGMENT,m,NULL)
-# define SSL_CTX_set_max_pipelines(ctx,m) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_PIPELINES,m,NULL)
-# define SSL_set_max_pipelines(ssl,m) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_MAX_PIPELINES,m,NULL)
-# define SSL_set_retry_verify(ssl) \
-        (SSL_ctrl(ssl,SSL_CTRL_SET_RETRY_VERIFY,0,NULL) > 0)
-
-void SSL_CTX_set_default_read_buffer_len(SSL_CTX *ctx, size_t len);
-void SSL_set_default_read_buffer_len(SSL *s, size_t len);
-
-# ifndef OPENSSL_NO_DH
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-/* NB: the |keylength| is only applicable when is_export is true */
-OSSL_DEPRECATEDIN_3_0
-void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
-                                 DH *(*dh) (SSL *ssl, int is_export,
-                                            int keylength));
-OSSL_DEPRECATEDIN_3_0
-void SSL_set_tmp_dh_callback(SSL *ssl,
-                             DH *(*dh) (SSL *ssl, int is_export,
-                                        int keylength));
-#  endif
-# endif
-
-__owur const COMP_METHOD *SSL_get_current_compression(const SSL *s);
-__owur const COMP_METHOD *SSL_get_current_expansion(const SSL *s);
-__owur const char *SSL_COMP_get_name(const COMP_METHOD *comp);
-__owur const char *SSL_COMP_get0_name(const SSL_COMP *comp);
-__owur int SSL_COMP_get_id(const SSL_COMP *comp);
-STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void);
-__owur STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP)
-                                                             *meths);
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define SSL_COMP_free_compression_methods() while(0) continue
-# endif
-__owur int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm);
-
-const SSL_CIPHER *SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr);
-int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c);
-int SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c);
-int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len,
-                             int isv2format, STACK_OF(SSL_CIPHER) **sk,
-                             STACK_OF(SSL_CIPHER) **scsvs);
-
-/* TLS extensions functions */
-__owur int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len);
-
-__owur int SSL_set_session_ticket_ext_cb(SSL *s,
-                                         tls_session_ticket_ext_cb_fn cb,
-                                         void *arg);
-
-/* Pre-shared secret session resumption functions */
-__owur int SSL_set_session_secret_cb(SSL *s,
-                                     tls_session_secret_cb_fn session_secret_cb,
-                                     void *arg);
-
-void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
-                                                int (*cb) (SSL *ssl,
-                                                           int
-                                                           is_forward_secure));
-
-void SSL_set_not_resumable_session_callback(SSL *ssl,
-                                            int (*cb) (SSL *ssl,
-                                                       int is_forward_secure));
-
-void SSL_CTX_set_record_padding_callback(SSL_CTX *ctx,
-                                         size_t (*cb) (SSL *ssl, int type,
-                                                       size_t len, void *arg));
-void SSL_CTX_set_record_padding_callback_arg(SSL_CTX *ctx, void *arg);
-void *SSL_CTX_get_record_padding_callback_arg(const SSL_CTX *ctx);
-int SSL_CTX_set_block_padding(SSL_CTX *ctx, size_t block_size);
-
-int SSL_set_record_padding_callback(SSL *ssl,
-                                    size_t (*cb) (SSL *ssl, int type,
-                                                  size_t len, void *arg));
-void SSL_set_record_padding_callback_arg(SSL *ssl, void *arg);
-void *SSL_get_record_padding_callback_arg(const SSL *ssl);
-int SSL_set_block_padding(SSL *ssl, size_t block_size);
-
-int SSL_set_num_tickets(SSL *s, size_t num_tickets);
-size_t SSL_get_num_tickets(const SSL *s);
-int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets);
-size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx);
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define SSL_cache_hit(s) SSL_session_reused(s)
-# endif
-
-__owur int SSL_session_reused(const SSL *s);
-__owur int SSL_is_server(const SSL *s);
-
-__owur __owur SSL_CONF_CTX *SSL_CONF_CTX_new(void);
-int SSL_CONF_CTX_finish(SSL_CONF_CTX *cctx);
-void SSL_CONF_CTX_free(SSL_CONF_CTX *cctx);
-unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX *cctx, unsigned int flags);
-__owur unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX *cctx,
-                                             unsigned int flags);
-__owur int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX *cctx, const char *pre);
-
-void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl);
-void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx);
-
-__owur int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value);
-__owur int SSL_CONF_cmd_argv(SSL_CONF_CTX *cctx, int *pargc, char ***pargv);
-__owur int SSL_CONF_cmd_value_type(SSL_CONF_CTX *cctx, const char *cmd);
-
-void SSL_add_ssl_module(void);
-int SSL_config(SSL *s, const char *name);
-int SSL_CTX_config(SSL_CTX *ctx, const char *name);
-
-# ifndef OPENSSL_NO_SSL_TRACE
-void SSL_trace(int write_p, int version, int content_type,
-               const void *buf, size_t len, SSL *ssl, void *arg);
-# endif
-
-# ifndef OPENSSL_NO_SOCK
-int DTLSv1_listen(SSL *s, BIO_ADDR *client);
-# endif
-
-# ifndef OPENSSL_NO_CT
+    __owur int SSL_CTX_set_ex_data(SSL_CTX* ssl, int idx, void* data);
+    void* SSL_CTX_get_ex_data(const SSL_CTX* ssl, int idx);
+
+    __owur int SSL_get_ex_data_X509_STORE_CTX_idx(void);
+
+#define SSL_CTX_sess_set_cache_size(ctx, t) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_SESS_CACHE_SIZE, t, NULL)
+#define SSL_CTX_sess_get_cache_size(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_SESS_CACHE_SIZE, 0, NULL)
+#define SSL_CTX_set_session_cache_mode(ctx, m) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_SESS_CACHE_MODE, m, NULL)
+#define SSL_CTX_get_session_cache_mode(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_SESS_CACHE_MODE, 0, NULL)
+
+#define SSL_CTX_get_default_read_ahead(ctx) SSL_CTX_get_read_ahead(ctx)
+#define SSL_CTX_set_default_read_ahead(ctx, m) SSL_CTX_set_read_ahead(ctx, m)
+#define SSL_CTX_get_read_ahead(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_READ_AHEAD, 0, NULL)
+#define SSL_CTX_set_read_ahead(ctx, m) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_READ_AHEAD, m, NULL)
+#define SSL_CTX_get_max_cert_list(ctx) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_MAX_CERT_LIST, 0, NULL)
+#define SSL_CTX_set_max_cert_list(ctx, m) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MAX_CERT_LIST, m, NULL)
+#define SSL_get_max_cert_list(ssl) \
+    SSL_ctrl(ssl, SSL_CTRL_GET_MAX_CERT_LIST, 0, NULL)
+#define SSL_set_max_cert_list(ssl, m) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_MAX_CERT_LIST, m, NULL)
+
+#define SSL_CTX_set_max_send_fragment(ctx, m) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MAX_SEND_FRAGMENT, m, NULL)
+#define SSL_set_max_send_fragment(ssl, m) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_MAX_SEND_FRAGMENT, m, NULL)
+#define SSL_CTX_set_split_send_fragment(ctx, m) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_SPLIT_SEND_FRAGMENT, m, NULL)
+#define SSL_set_split_send_fragment(ssl, m) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_SPLIT_SEND_FRAGMENT, m, NULL)
+#define SSL_CTX_set_max_pipelines(ctx, m) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_MAX_PIPELINES, m, NULL)
+#define SSL_set_max_pipelines(ssl, m) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_MAX_PIPELINES, m, NULL)
+#define SSL_set_retry_verify(ssl) \
+    (SSL_ctrl(ssl, SSL_CTRL_SET_RETRY_VERIFY, 0, NULL) > 0)
+
+    void SSL_CTX_set_default_read_buffer_len(SSL_CTX* ctx, size_t len);
+    void SSL_set_default_read_buffer_len(SSL* s, size_t len);
+
+#ifndef OPENSSL_NO_DH
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    /* NB: the |keylength| is only applicable when is_export is true */
+    OSSL_DEPRECATEDIN_3_0
+    void SSL_CTX_set_tmp_dh_callback(SSL_CTX* ctx, DH* (*dh)(SSL* ssl, int is_export, int keylength));
+    OSSL_DEPRECATEDIN_3_0
+    void SSL_set_tmp_dh_callback(SSL* ssl, DH* (*dh)(SSL* ssl, int is_export, int keylength));
+#endif
+#endif
 
-/*
- * A callback for verifying that the received SCTs are sufficient.
- * Expected to return 1 if they are sufficient, otherwise 0.
- * May return a negative integer if an error occurs.
- * A connection should be aborted if the SCTs are deemed insufficient.
- */
-typedef int (*ssl_ct_validation_cb)(const CT_POLICY_EVAL_CTX *ctx,
-                                    const STACK_OF(SCT) *scts, void *arg);
+    __owur const COMP_METHOD* SSL_get_current_compression(const SSL* s);
+    __owur const COMP_METHOD* SSL_get_current_expansion(const SSL* s);
+    __owur const char* SSL_COMP_get_name(const COMP_METHOD* comp);
+    __owur const char* SSL_COMP_get0_name(const SSL_COMP* comp);
+    __owur int SSL_COMP_get_id(const SSL_COMP* comp);
+    STACK_OF(SSL_COMP) * SSL_COMP_get_compression_methods(void);
+    __owur STACK_OF(SSL_COMP) * SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP) * meths);
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define SSL_COMP_free_compression_methods() \
+    while (0)                               \
+    continue
+#endif
+    __owur int SSL_COMP_add_compression_method(int id, COMP_METHOD* cm);
 
-/*
- * Sets a |callback| that is invoked upon receipt of ServerHelloDone to validate
- * the received SCTs.
- * If the callback returns a non-positive result, the connection is terminated.
- * Call this function before beginning a handshake.
- * If a NULL |callback| is provided, SCT validation is disabled.
- * |arg| is arbitrary userdata that will be passed to the callback whenever it
- * is invoked. Ownership of |arg| remains with the caller.
- *
- * NOTE: A side-effect of setting a CT callback is that an OCSP stapled response
- *       will be requested.
- */
-int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
-                                   void *arg);
-int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
-                                       ssl_ct_validation_cb callback,
-                                       void *arg);
+    const SSL_CIPHER* SSL_CIPHER_find(SSL* ssl, const unsigned char* ptr);
+    int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER* c);
+    int SSL_CIPHER_get_digest_nid(const SSL_CIPHER* c);
+    int SSL_bytes_to_cipher_list(SSL* s, const unsigned char* bytes, size_t len, int isv2format, STACK_OF(SSL_CIPHER) * *sk, STACK_OF(SSL_CIPHER) * *scsvs);
+
+    /* TLS extensions functions */
+    __owur int SSL_set_session_ticket_ext(SSL* s, void* ext_data, int ext_len);
+
+    __owur int SSL_set_session_ticket_ext_cb(SSL* s, tls_session_ticket_ext_cb_fn cb, void* arg);
+
+    /* Pre-shared secret session resumption functions */
+    __owur int SSL_set_session_secret_cb(SSL* s, tls_session_secret_cb_fn session_secret_cb, void* arg);
+
+    void SSL_CTX_set_not_resumable_session_callback(SSL_CTX* ctx, int (*cb)(SSL* ssl, int is_forward_secure));
+
+    void SSL_set_not_resumable_session_callback(SSL* ssl, int (*cb)(SSL* ssl, int is_forward_secure));
+
+    void SSL_CTX_set_record_padding_callback(SSL_CTX* ctx, size_t (*cb)(SSL* ssl, int type, size_t len, void* arg));
+    void SSL_CTX_set_record_padding_callback_arg(SSL_CTX* ctx, void* arg);
+    void* SSL_CTX_get_record_padding_callback_arg(const SSL_CTX* ctx);
+    int SSL_CTX_set_block_padding(SSL_CTX* ctx, size_t block_size);
+
+    int SSL_set_record_padding_callback(SSL* ssl, size_t (*cb)(SSL* ssl, int type, size_t len, void* arg));
+    void SSL_set_record_padding_callback_arg(SSL* ssl, void* arg);
+    void* SSL_get_record_padding_callback_arg(const SSL* ssl);
+    int SSL_set_block_padding(SSL* ssl, size_t block_size);
+
+    int SSL_set_num_tickets(SSL* s, size_t num_tickets);
+    size_t SSL_get_num_tickets(const SSL* s);
+    int SSL_CTX_set_num_tickets(SSL_CTX* ctx, size_t num_tickets);
+    size_t SSL_CTX_get_num_tickets(const SSL_CTX* ctx);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define SSL_cache_hit(s) SSL_session_reused(s)
+#endif
+
+    __owur int SSL_session_reused(const SSL* s);
+    __owur int SSL_is_server(const SSL* s);
+
+    __owur __owur SSL_CONF_CTX* SSL_CONF_CTX_new(void);
+    int SSL_CONF_CTX_finish(SSL_CONF_CTX* cctx);
+    void SSL_CONF_CTX_free(SSL_CONF_CTX* cctx);
+    unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX* cctx, unsigned int flags);
+    __owur unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX* cctx, unsigned int flags);
+    __owur int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX* cctx, const char* pre);
+
+    void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX* cctx, SSL* ssl);
+    void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX* cctx, SSL_CTX* ctx);
+
+    __owur int SSL_CONF_cmd(SSL_CONF_CTX* cctx, const char* cmd, const char* value);
+    __owur int SSL_CONF_cmd_argv(SSL_CONF_CTX* cctx, int* pargc, char*** pargv);
+    __owur int SSL_CONF_cmd_value_type(SSL_CONF_CTX* cctx, const char* cmd);
+
+    void SSL_add_ssl_module(void);
+    int SSL_config(SSL* s, const char* name);
+    int SSL_CTX_config(SSL_CTX* ctx, const char* name);
+
+#ifndef OPENSSL_NO_SSL_TRACE
+    void SSL_trace(int write_p, int version, int content_type, const void* buf, size_t len, SSL* ssl, void* arg);
+#endif
+
+#ifndef OPENSSL_NO_SOCK
+    int DTLSv1_listen(SSL* s, BIO_ADDR* client);
+#endif
+
+#ifndef OPENSSL_NO_CT
+
+    /*
+     * A callback for verifying that the received SCTs are sufficient.
+     * Expected to return 1 if they are sufficient, otherwise 0.
+     * May return a negative integer if an error occurs.
+     * A connection should be aborted if the SCTs are deemed insufficient.
+     */
+    typedef int (*ssl_ct_validation_cb)(const CT_POLICY_EVAL_CTX* ctx, const STACK_OF(SCT) * scts, void* arg);
+
+    /*
+     * Sets a |callback| that is invoked upon receipt of ServerHelloDone to validate
+     * the received SCTs.
+     * If the callback returns a non-positive result, the connection is terminated.
+     * Call this function before beginning a handshake.
+     * If a NULL |callback| is provided, SCT validation is disabled.
+     * |arg| is arbitrary userdata that will be passed to the callback whenever it
+     * is invoked. Ownership of |arg| remains with the caller.
+     *
+     * NOTE: A side-effect of setting a CT callback is that an OCSP stapled response
+     *       will be requested.
+     */
+    int SSL_set_ct_validation_callback(SSL* s, ssl_ct_validation_cb callback, void* arg);
+    int SSL_CTX_set_ct_validation_callback(SSL_CTX* ctx, ssl_ct_validation_cb callback, void* arg);
 #define SSL_disable_ct(s) \
-        ((void) SSL_set_validation_callback((s), NULL, NULL))
+    ((void)SSL_set_validation_callback((s), NULL, NULL))
 #define SSL_CTX_disable_ct(ctx) \
-        ((void) SSL_CTX_set_validation_callback((ctx), NULL, NULL))
+    ((void)SSL_CTX_set_validation_callback((ctx), NULL, NULL))
 
-/*
- * The validation type enumerates the available behaviours of the built-in SSL
- * CT validation callback selected via SSL_enable_ct() and SSL_CTX_enable_ct().
- * The underlying callback is a static function in libssl.
- */
-enum {
-    SSL_CT_VALIDATION_PERMISSIVE = 0,
-    SSL_CT_VALIDATION_STRICT
-};
+    /*
+     * The validation type enumerates the available behaviours of the built-in SSL
+     * CT validation callback selected via SSL_enable_ct() and SSL_CTX_enable_ct().
+     * The underlying callback is a static function in libssl.
+     */
+    enum
+    {
+        SSL_CT_VALIDATION_PERMISSIVE = 0,
+        SSL_CT_VALIDATION_STRICT
+    };
 
-/*
- * Enable CT by setting up a callback that implements one of the built-in
- * validation variants.  The SSL_CT_VALIDATION_PERMISSIVE variant always
- * continues the handshake, the application can make appropriate decisions at
- * handshake completion.  The SSL_CT_VALIDATION_STRICT variant requires at
- * least one valid SCT, or else handshake termination will be requested.  The
- * handshake may continue anyway if SSL_VERIFY_NONE is in effect.
- */
-int SSL_enable_ct(SSL *s, int validation_mode);
-int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode);
+    /*
+     * Enable CT by setting up a callback that implements one of the built-in
+     * validation variants.  The SSL_CT_VALIDATION_PERMISSIVE variant always
+     * continues the handshake, the application can make appropriate decisions at
+     * handshake completion.  The SSL_CT_VALIDATION_STRICT variant requires at
+     * least one valid SCT, or else handshake termination will be requested.  The
+     * handshake may continue anyway if SSL_VERIFY_NONE is in effect.
+     */
+    int SSL_enable_ct(SSL* s, int validation_mode);
+    int SSL_CTX_enable_ct(SSL_CTX* ctx, int validation_mode);
 
-/*
- * Report whether a non-NULL callback is enabled.
- */
-int SSL_ct_is_enabled(const SSL *s);
-int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx);
+    /*
+     * Report whether a non-NULL callback is enabled.
+     */
+    int SSL_ct_is_enabled(const SSL* s);
+    int SSL_CTX_ct_is_enabled(const SSL_CTX* ctx);
 
-/* Gets the SCTs received from a connection */
-const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s);
+    /* Gets the SCTs received from a connection */
+    const STACK_OF(SCT) * SSL_get0_peer_scts(SSL* s);
 
-/*
- * Loads the CT log list from the default location.
- * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store,
- * the log information loaded from this file will be appended to the
- * CTLOG_STORE.
- * Returns 1 on success, 0 otherwise.
- */
-int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx);
+    /*
+     * Loads the CT log list from the default location.
+     * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store,
+     * the log information loaded from this file will be appended to the
+     * CTLOG_STORE.
+     * Returns 1 on success, 0 otherwise.
+     */
+    int SSL_CTX_set_default_ctlog_list_file(SSL_CTX* ctx);
 
-/*
- * Loads the CT log list from the specified file path.
- * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store,
- * the log information loaded from this file will be appended to the
- * CTLOG_STORE.
- * Returns 1 on success, 0 otherwise.
- */
-int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path);
+    /*
+     * Loads the CT log list from the specified file path.
+     * If a CTLOG_STORE has previously been set using SSL_CTX_set_ctlog_store,
+     * the log information loaded from this file will be appended to the
+     * CTLOG_STORE.
+     * Returns 1 on success, 0 otherwise.
+     */
+    int SSL_CTX_set_ctlog_list_file(SSL_CTX* ctx, const char* path);
 
-/*
- * Sets the CT log list used by all SSL connections created from this SSL_CTX.
- * Ownership of the CTLOG_STORE is transferred to the SSL_CTX.
- */
-void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE *logs);
+    /*
+     * Sets the CT log list used by all SSL connections created from this SSL_CTX.
+     * Ownership of the CTLOG_STORE is transferred to the SSL_CTX.
+     */
+    void SSL_CTX_set0_ctlog_store(SSL_CTX* ctx, CTLOG_STORE* logs);
 
-/*
- * Gets the CT log list used by all SSL connections created from this SSL_CTX.
- * This will be NULL unless one of the following functions has been called:
- * - SSL_CTX_set_default_ctlog_list_file
- * - SSL_CTX_set_ctlog_list_file
- * - SSL_CTX_set_ctlog_store
- */
-const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx);
+    /*
+     * Gets the CT log list used by all SSL connections created from this SSL_CTX.
+     * This will be NULL unless one of the following functions has been called:
+     * - SSL_CTX_set_default_ctlog_list_file
+     * - SSL_CTX_set_ctlog_list_file
+     * - SSL_CTX_set_ctlog_store
+     */
+    const CTLOG_STORE* SSL_CTX_get0_ctlog_store(const SSL_CTX* ctx);
 
-# endif /* OPENSSL_NO_CT */
+#endif /* OPENSSL_NO_CT */
 
 /* What the "other" parameter contains in security callback */
 /* Mask for type */
-# define SSL_SECOP_OTHER_TYPE    0xffff0000
-# define SSL_SECOP_OTHER_NONE    0
-# define SSL_SECOP_OTHER_CIPHER  (1 << 16)
-# define SSL_SECOP_OTHER_CURVE   (2 << 16)
-# define SSL_SECOP_OTHER_DH      (3 << 16)
-# define SSL_SECOP_OTHER_PKEY    (4 << 16)
-# define SSL_SECOP_OTHER_SIGALG  (5 << 16)
-# define SSL_SECOP_OTHER_CERT    (6 << 16)
+#define SSL_SECOP_OTHER_TYPE 0xffff0000
+#define SSL_SECOP_OTHER_NONE 0
+#define SSL_SECOP_OTHER_CIPHER (1 << 16)
+#define SSL_SECOP_OTHER_CURVE (2 << 16)
+#define SSL_SECOP_OTHER_DH (3 << 16)
+#define SSL_SECOP_OTHER_PKEY (4 << 16)
+#define SSL_SECOP_OTHER_SIGALG (5 << 16)
+#define SSL_SECOP_OTHER_CERT (6 << 16)
 
 /* Indicated operation refers to peer key or certificate */
-# define SSL_SECOP_PEER          0x1000
+#define SSL_SECOP_PEER 0x1000
 
 /* Values for "op" parameter in security callback */
 
 /* Called to filter ciphers */
 /* Ciphers client supports */
-# define SSL_SECOP_CIPHER_SUPPORTED      (1 | SSL_SECOP_OTHER_CIPHER)
+#define SSL_SECOP_CIPHER_SUPPORTED (1 | SSL_SECOP_OTHER_CIPHER)
 /* Cipher shared by client/server */
-# define SSL_SECOP_CIPHER_SHARED         (2 | SSL_SECOP_OTHER_CIPHER)
+#define SSL_SECOP_CIPHER_SHARED (2 | SSL_SECOP_OTHER_CIPHER)
 /* Sanity check of cipher server selects */
-# define SSL_SECOP_CIPHER_CHECK          (3 | SSL_SECOP_OTHER_CIPHER)
+#define SSL_SECOP_CIPHER_CHECK (3 | SSL_SECOP_OTHER_CIPHER)
 /* Curves supported by client */
-# define SSL_SECOP_CURVE_SUPPORTED       (4 | SSL_SECOP_OTHER_CURVE)
+#define SSL_SECOP_CURVE_SUPPORTED (4 | SSL_SECOP_OTHER_CURVE)
 /* Curves shared by client/server */
-# define SSL_SECOP_CURVE_SHARED          (5 | SSL_SECOP_OTHER_CURVE)
+#define SSL_SECOP_CURVE_SHARED (5 | SSL_SECOP_OTHER_CURVE)
 /* Sanity check of curve server selects */
-# define SSL_SECOP_CURVE_CHECK           (6 | SSL_SECOP_OTHER_CURVE)
+#define SSL_SECOP_CURVE_CHECK (6 | SSL_SECOP_OTHER_CURVE)
 /* Temporary DH key */
-# define SSL_SECOP_TMP_DH                (7 | SSL_SECOP_OTHER_PKEY)
+#define SSL_SECOP_TMP_DH (7 | SSL_SECOP_OTHER_PKEY)
 /* SSL/TLS version */
-# define SSL_SECOP_VERSION               (9 | SSL_SECOP_OTHER_NONE)
+#define SSL_SECOP_VERSION (9 | SSL_SECOP_OTHER_NONE)
 /* Session tickets */
-# define SSL_SECOP_TICKET                (10 | SSL_SECOP_OTHER_NONE)
+#define SSL_SECOP_TICKET (10 | SSL_SECOP_OTHER_NONE)
 /* Supported signature algorithms sent to peer */
-# define SSL_SECOP_SIGALG_SUPPORTED      (11 | SSL_SECOP_OTHER_SIGALG)
+#define SSL_SECOP_SIGALG_SUPPORTED (11 | SSL_SECOP_OTHER_SIGALG)
 /* Shared signature algorithm */
-# define SSL_SECOP_SIGALG_SHARED         (12 | SSL_SECOP_OTHER_SIGALG)
+#define SSL_SECOP_SIGALG_SHARED (12 | SSL_SECOP_OTHER_SIGALG)
 /* Sanity check signature algorithm allowed */
-# define SSL_SECOP_SIGALG_CHECK          (13 | SSL_SECOP_OTHER_SIGALG)
+#define SSL_SECOP_SIGALG_CHECK (13 | SSL_SECOP_OTHER_SIGALG)
 /* Used to get mask of supported public key signature algorithms */
-# define SSL_SECOP_SIGALG_MASK           (14 | SSL_SECOP_OTHER_SIGALG)
+#define SSL_SECOP_SIGALG_MASK (14 | SSL_SECOP_OTHER_SIGALG)
 /* Use to see if compression is allowed */
-# define SSL_SECOP_COMPRESSION           (15 | SSL_SECOP_OTHER_NONE)
+#define SSL_SECOP_COMPRESSION (15 | SSL_SECOP_OTHER_NONE)
 /* EE key in certificate */
-# define SSL_SECOP_EE_KEY                (16 | SSL_SECOP_OTHER_CERT)
+#define SSL_SECOP_EE_KEY (16 | SSL_SECOP_OTHER_CERT)
 /* CA key in certificate */
-# define SSL_SECOP_CA_KEY                (17 | SSL_SECOP_OTHER_CERT)
+#define SSL_SECOP_CA_KEY (17 | SSL_SECOP_OTHER_CERT)
 /* CA digest algorithm in certificate */
-# define SSL_SECOP_CA_MD                 (18 | SSL_SECOP_OTHER_CERT)
+#define SSL_SECOP_CA_MD (18 | SSL_SECOP_OTHER_CERT)
 /* Peer EE key in certificate */
-# define SSL_SECOP_PEER_EE_KEY           (SSL_SECOP_EE_KEY | SSL_SECOP_PEER)
+#define SSL_SECOP_PEER_EE_KEY (SSL_SECOP_EE_KEY | SSL_SECOP_PEER)
 /* Peer CA key in certificate */
-# define SSL_SECOP_PEER_CA_KEY           (SSL_SECOP_CA_KEY | SSL_SECOP_PEER)
+#define SSL_SECOP_PEER_CA_KEY (SSL_SECOP_CA_KEY | SSL_SECOP_PEER)
 /* Peer CA digest algorithm in certificate */
-# define SSL_SECOP_PEER_CA_MD            (SSL_SECOP_CA_MD | SSL_SECOP_PEER)
-
-void SSL_set_security_level(SSL *s, int level);
-__owur int SSL_get_security_level(const SSL *s);
-void SSL_set_security_callback(SSL *s,
-                               int (*cb) (const SSL *s, const SSL_CTX *ctx,
-                                          int op, int bits, int nid,
-                                          void *other, void *ex));
-int (*SSL_get_security_callback(const SSL *s)) (const SSL *s,
-                                                const SSL_CTX *ctx, int op,
-                                                int bits, int nid, void *other,
-                                                void *ex);
-void SSL_set0_security_ex_data(SSL *s, void *ex);
-__owur void *SSL_get0_security_ex_data(const SSL *s);
-
-void SSL_CTX_set_security_level(SSL_CTX *ctx, int level);
-__owur int SSL_CTX_get_security_level(const SSL_CTX *ctx);
-void SSL_CTX_set_security_callback(SSL_CTX *ctx,
-                                   int (*cb) (const SSL *s, const SSL_CTX *ctx,
-                                              int op, int bits, int nid,
-                                              void *other, void *ex));
-int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
-                                                          const SSL_CTX *ctx,
-                                                          int op, int bits,
-                                                          int nid,
-                                                          void *other,
-                                                          void *ex);
-void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex);
-__owur void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx);
+#define SSL_SECOP_PEER_CA_MD (SSL_SECOP_CA_MD | SSL_SECOP_PEER)
+
+    void SSL_set_security_level(SSL* s, int level);
+    __owur int SSL_get_security_level(const SSL* s);
+    void SSL_set_security_callback(SSL* s, int (*cb)(const SSL* s, const SSL_CTX* ctx, int op, int bits, int nid, void* other, void* ex));
+    int (*SSL_get_security_callback(const SSL* s))(const SSL* s, const SSL_CTX* ctx, int op, int bits, int nid, void* other, void* ex);
+    void SSL_set0_security_ex_data(SSL* s, void* ex);
+    __owur void* SSL_get0_security_ex_data(const SSL* s);
+
+    void SSL_CTX_set_security_level(SSL_CTX* ctx, int level);
+    __owur int SSL_CTX_get_security_level(const SSL_CTX* ctx);
+    void SSL_CTX_set_security_callback(SSL_CTX* ctx, int (*cb)(const SSL* s, const SSL_CTX* ctx, int op, int bits, int nid, void* other, void* ex));
+    int (*SSL_CTX_get_security_callback(const SSL_CTX* ctx))(const SSL* s, const SSL_CTX* ctx, int op, int bits, int nid, void* other, void* ex);
+    void SSL_CTX_set0_security_ex_data(SSL_CTX* ctx, void* ex);
+    __owur void* SSL_CTX_get0_security_ex_data(const SSL_CTX* ctx);
 
 /* OPENSSL_INIT flag 0x010000 reserved for internal use */
-# define OPENSSL_INIT_NO_LOAD_SSL_STRINGS    0x00100000L
-# define OPENSSL_INIT_LOAD_SSL_STRINGS       0x00200000L
+#define OPENSSL_INIT_NO_LOAD_SSL_STRINGS 0x00100000L
+#define OPENSSL_INIT_LOAD_SSL_STRINGS 0x00200000L
 
-# define OPENSSL_INIT_SSL_DEFAULT \
-        (OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
+#define OPENSSL_INIT_SSL_DEFAULT \
+    (OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
 
-int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
+    int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS* settings);
 
-# ifndef OPENSSL_NO_UNIT_TEST
-__owur const struct openssl_ssl_test_functions *SSL_test_functions(void);
-# endif
+#ifndef OPENSSL_NO_UNIT_TEST
+    __owur const struct openssl_ssl_test_functions* SSL_test_functions(void);
+#endif
 
-__owur int SSL_free_buffers(SSL *ssl);
-__owur int SSL_alloc_buffers(SSL *ssl);
+    __owur int SSL_free_buffers(SSL* ssl);
+    __owur int SSL_alloc_buffers(SSL* ssl);
 
-/* Status codes passed to the decrypt session ticket callback. Some of these
- * are for internal use only and are never passed to the callback. */
-typedef int SSL_TICKET_STATUS;
+    /* Status codes passed to the decrypt session ticket callback. Some of these
+     * are for internal use only and are never passed to the callback. */
+    typedef int SSL_TICKET_STATUS;
 
 /* Support for ticket appdata */
 /* fatal error, malloc failure */
-# define SSL_TICKET_FATAL_ERR_MALLOC 0
+#define SSL_TICKET_FATAL_ERR_MALLOC 0
 /* fatal error, either from parsing or decrypting the ticket */
-# define SSL_TICKET_FATAL_ERR_OTHER  1
+#define SSL_TICKET_FATAL_ERR_OTHER 1
 /* No ticket present */
-# define SSL_TICKET_NONE             2
+#define SSL_TICKET_NONE 2
 /* Empty ticket present */
-# define SSL_TICKET_EMPTY            3
+#define SSL_TICKET_EMPTY 3
 /* the ticket couldn't be decrypted */
-# define SSL_TICKET_NO_DECRYPT       4
+#define SSL_TICKET_NO_DECRYPT 4
 /* a ticket was successfully decrypted */
-# define SSL_TICKET_SUCCESS          5
+#define SSL_TICKET_SUCCESS 5
 /* same as above but the ticket needs to be renewed */
-# define SSL_TICKET_SUCCESS_RENEW    6
+#define SSL_TICKET_SUCCESS_RENEW 6
 
-/* Return codes for the decrypt session ticket callback */
-typedef int SSL_TICKET_RETURN;
+    /* Return codes for the decrypt session ticket callback */
+    typedef int SSL_TICKET_RETURN;
 
 /* An error occurred */
-#define SSL_TICKET_RETURN_ABORT             0
+#define SSL_TICKET_RETURN_ABORT 0
 /* Do not use the ticket, do not send a renewed ticket to the client */
-#define SSL_TICKET_RETURN_IGNORE            1
+#define SSL_TICKET_RETURN_IGNORE 1
 /* Do not use the ticket, send a renewed ticket to the client */
-#define SSL_TICKET_RETURN_IGNORE_RENEW      2
+#define SSL_TICKET_RETURN_IGNORE_RENEW 2
 /* Use the ticket, do not send a renewed ticket to the client */
-#define SSL_TICKET_RETURN_USE               3
+#define SSL_TICKET_RETURN_USE 3
 /* Use the ticket, send a renewed ticket to the client */
-#define SSL_TICKET_RETURN_USE_RENEW         4
-
-typedef int (*SSL_CTX_generate_session_ticket_fn)(SSL *s, void *arg);
-typedef SSL_TICKET_RETURN (*SSL_CTX_decrypt_session_ticket_fn)(SSL *s, SSL_SESSION *ss,
-                                                               const unsigned char *keyname,
-                                                               size_t keyname_length,
-                                                               SSL_TICKET_STATUS status,
-                                                               void *arg);
-int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx,
-                                  SSL_CTX_generate_session_ticket_fn gen_cb,
-                                  SSL_CTX_decrypt_session_ticket_fn dec_cb,
-                                  void *arg);
-int SSL_SESSION_set1_ticket_appdata(SSL_SESSION *ss, const void *data, size_t len);
-int SSL_SESSION_get0_ticket_appdata(SSL_SESSION *ss, void **data, size_t *len);
-
-typedef unsigned int (*DTLS_timer_cb)(SSL *s, unsigned int timer_us);
-
-void DTLS_set_timer_cb(SSL *s, DTLS_timer_cb cb);
-
-
-typedef int (*SSL_allow_early_data_cb_fn)(SSL *s, void *arg);
-void SSL_CTX_set_allow_early_data_cb(SSL_CTX *ctx,
-                                     SSL_allow_early_data_cb_fn cb,
-                                     void *arg);
-void SSL_set_allow_early_data_cb(SSL *s,
-                                 SSL_allow_early_data_cb_fn cb,
-                                 void *arg);
-
-/* store the default cipher strings inside the library */
-const char *OSSL_default_cipher_list(void);
-const char *OSSL_default_ciphersuites(void);
-
-# ifdef  __cplusplus
+#define SSL_TICKET_RETURN_USE_RENEW 4
+
+    typedef int (*SSL_CTX_generate_session_ticket_fn)(SSL* s, void* arg);
+    typedef SSL_TICKET_RETURN (*SSL_CTX_decrypt_session_ticket_fn)(SSL* s, SSL_SESSION* ss, const unsigned char* keyname, size_t keyname_length, SSL_TICKET_STATUS status, void* arg);
+    int SSL_CTX_set_session_ticket_cb(SSL_CTX* ctx, SSL_CTX_generate_session_ticket_fn gen_cb, SSL_CTX_decrypt_session_ticket_fn dec_cb, void* arg);
+    int SSL_SESSION_set1_ticket_appdata(SSL_SESSION* ss, const void* data, size_t len);
+    int SSL_SESSION_get0_ticket_appdata(SSL_SESSION* ss, void** data, size_t* len);
+
+    typedef unsigned int (*DTLS_timer_cb)(SSL* s, unsigned int timer_us);
+
+    void DTLS_set_timer_cb(SSL* s, DTLS_timer_cb cb);
+
+    typedef int (*SSL_allow_early_data_cb_fn)(SSL* s, void* arg);
+    void SSL_CTX_set_allow_early_data_cb(SSL_CTX* ctx, SSL_allow_early_data_cb_fn cb, void* arg);
+    void SSL_set_allow_early_data_cb(SSL* s, SSL_allow_early_data_cb_fn cb, void* arg);
+
+    /* store the default cipher strings inside the library */
+    const char* OSSL_default_cipher_list(void);
+    const char* OSSL_default_ciphersuites(void);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ssl2.h b/CAPI/cpp/grpc/include/openssl/ssl2.h
index 428ead0..c059caf 100644
--- a/CAPI/cpp/grpc/include/openssl/ssl2.h
+++ b/CAPI/cpp/grpc/include/openssl/ssl2.h
@@ -8,23 +8,24 @@
  */
 
 #ifndef OPENSSL_SSL2_H
-# define OPENSSL_SSL2_H
-# pragma once
+#define OPENSSL_SSL2_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_SSL2_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_SSL2_H
+#endif
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-# define SSL2_VERSION            0x0002
+#define SSL2_VERSION 0x0002
 
-# define SSL2_MT_CLIENT_HELLO            1
+#define SSL2_MT_CLIENT_HELLO 1
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ssl3.h b/CAPI/cpp/grpc/include/openssl/ssl3.h
index 49bd51f..01d73ff 100644
--- a/CAPI/cpp/grpc/include/openssl/ssl3.h
+++ b/CAPI/cpp/grpc/include/openssl/ssl3.h
@@ -9,339 +9,339 @@
  */
 
 #ifndef OPENSSL_SSL3_H
-# define OPENSSL_SSL3_H
-# pragma once
+#define OPENSSL_SSL3_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_SSL3_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_SSL3_H
+#endif
 
-# include <openssl/comp.h>
-# include <openssl/buffer.h>
-# include <openssl/evp.h>
-# include <openssl/ssl.h>
+#include <openssl/comp.h>
+#include <openssl/buffer.h>
+#include <openssl/evp.h>
+#include <openssl/ssl.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 /*
  * Signalling cipher suite value from RFC 5746
  * (TLS_EMPTY_RENEGOTIATION_INFO_SCSV)
  */
-# define SSL3_CK_SCSV                            0x030000FF
+#define SSL3_CK_SCSV 0x030000FF
 
 /*
  * Signalling cipher suite value from draft-ietf-tls-downgrade-scsv-00
  * (TLS_FALLBACK_SCSV)
  */
-# define SSL3_CK_FALLBACK_SCSV                   0x03005600
-
-# define SSL3_CK_RSA_NULL_MD5                    0x03000001
-# define SSL3_CK_RSA_NULL_SHA                    0x03000002
-# define SSL3_CK_RSA_RC4_40_MD5                  0x03000003
-# define SSL3_CK_RSA_RC4_128_MD5                 0x03000004
-# define SSL3_CK_RSA_RC4_128_SHA                 0x03000005
-# define SSL3_CK_RSA_RC2_40_MD5                  0x03000006
-# define SSL3_CK_RSA_IDEA_128_SHA                0x03000007
-# define SSL3_CK_RSA_DES_40_CBC_SHA              0x03000008
-# define SSL3_CK_RSA_DES_64_CBC_SHA              0x03000009
-# define SSL3_CK_RSA_DES_192_CBC3_SHA            0x0300000A
-
-# define SSL3_CK_DH_DSS_DES_40_CBC_SHA           0x0300000B
-# define SSL3_CK_DH_DSS_DES_64_CBC_SHA           0x0300000C
-# define SSL3_CK_DH_DSS_DES_192_CBC3_SHA         0x0300000D
-# define SSL3_CK_DH_RSA_DES_40_CBC_SHA           0x0300000E
-# define SSL3_CK_DH_RSA_DES_64_CBC_SHA           0x0300000F
-# define SSL3_CK_DH_RSA_DES_192_CBC3_SHA         0x03000010
-
-# define SSL3_CK_DHE_DSS_DES_40_CBC_SHA          0x03000011
-# define SSL3_CK_EDH_DSS_DES_40_CBC_SHA          SSL3_CK_DHE_DSS_DES_40_CBC_SHA
-# define SSL3_CK_DHE_DSS_DES_64_CBC_SHA          0x03000012
-# define SSL3_CK_EDH_DSS_DES_64_CBC_SHA          SSL3_CK_DHE_DSS_DES_64_CBC_SHA
-# define SSL3_CK_DHE_DSS_DES_192_CBC3_SHA        0x03000013
-# define SSL3_CK_EDH_DSS_DES_192_CBC3_SHA        SSL3_CK_DHE_DSS_DES_192_CBC3_SHA
-# define SSL3_CK_DHE_RSA_DES_40_CBC_SHA          0x03000014
-# define SSL3_CK_EDH_RSA_DES_40_CBC_SHA          SSL3_CK_DHE_RSA_DES_40_CBC_SHA
-# define SSL3_CK_DHE_RSA_DES_64_CBC_SHA          0x03000015
-# define SSL3_CK_EDH_RSA_DES_64_CBC_SHA          SSL3_CK_DHE_RSA_DES_64_CBC_SHA
-# define SSL3_CK_DHE_RSA_DES_192_CBC3_SHA        0x03000016
-# define SSL3_CK_EDH_RSA_DES_192_CBC3_SHA        SSL3_CK_DHE_RSA_DES_192_CBC3_SHA
-
-# define SSL3_CK_ADH_RC4_40_MD5                  0x03000017
-# define SSL3_CK_ADH_RC4_128_MD5                 0x03000018
-# define SSL3_CK_ADH_DES_40_CBC_SHA              0x03000019
-# define SSL3_CK_ADH_DES_64_CBC_SHA              0x0300001A
-# define SSL3_CK_ADH_DES_192_CBC_SHA             0x0300001B
+#define SSL3_CK_FALLBACK_SCSV 0x03005600
+
+#define SSL3_CK_RSA_NULL_MD5 0x03000001
+#define SSL3_CK_RSA_NULL_SHA 0x03000002
+#define SSL3_CK_RSA_RC4_40_MD5 0x03000003
+#define SSL3_CK_RSA_RC4_128_MD5 0x03000004
+#define SSL3_CK_RSA_RC4_128_SHA 0x03000005
+#define SSL3_CK_RSA_RC2_40_MD5 0x03000006
+#define SSL3_CK_RSA_IDEA_128_SHA 0x03000007
+#define SSL3_CK_RSA_DES_40_CBC_SHA 0x03000008
+#define SSL3_CK_RSA_DES_64_CBC_SHA 0x03000009
+#define SSL3_CK_RSA_DES_192_CBC3_SHA 0x0300000A
+
+#define SSL3_CK_DH_DSS_DES_40_CBC_SHA 0x0300000B
+#define SSL3_CK_DH_DSS_DES_64_CBC_SHA 0x0300000C
+#define SSL3_CK_DH_DSS_DES_192_CBC3_SHA 0x0300000D
+#define SSL3_CK_DH_RSA_DES_40_CBC_SHA 0x0300000E
+#define SSL3_CK_DH_RSA_DES_64_CBC_SHA 0x0300000F
+#define SSL3_CK_DH_RSA_DES_192_CBC3_SHA 0x03000010
+
+#define SSL3_CK_DHE_DSS_DES_40_CBC_SHA 0x03000011
+#define SSL3_CK_EDH_DSS_DES_40_CBC_SHA SSL3_CK_DHE_DSS_DES_40_CBC_SHA
+#define SSL3_CK_DHE_DSS_DES_64_CBC_SHA 0x03000012
+#define SSL3_CK_EDH_DSS_DES_64_CBC_SHA SSL3_CK_DHE_DSS_DES_64_CBC_SHA
+#define SSL3_CK_DHE_DSS_DES_192_CBC3_SHA 0x03000013
+#define SSL3_CK_EDH_DSS_DES_192_CBC3_SHA SSL3_CK_DHE_DSS_DES_192_CBC3_SHA
+#define SSL3_CK_DHE_RSA_DES_40_CBC_SHA 0x03000014
+#define SSL3_CK_EDH_RSA_DES_40_CBC_SHA SSL3_CK_DHE_RSA_DES_40_CBC_SHA
+#define SSL3_CK_DHE_RSA_DES_64_CBC_SHA 0x03000015
+#define SSL3_CK_EDH_RSA_DES_64_CBC_SHA SSL3_CK_DHE_RSA_DES_64_CBC_SHA
+#define SSL3_CK_DHE_RSA_DES_192_CBC3_SHA 0x03000016
+#define SSL3_CK_EDH_RSA_DES_192_CBC3_SHA SSL3_CK_DHE_RSA_DES_192_CBC3_SHA
+
+#define SSL3_CK_ADH_RC4_40_MD5 0x03000017
+#define SSL3_CK_ADH_RC4_128_MD5 0x03000018
+#define SSL3_CK_ADH_DES_40_CBC_SHA 0x03000019
+#define SSL3_CK_ADH_DES_64_CBC_SHA 0x0300001A
+#define SSL3_CK_ADH_DES_192_CBC_SHA 0x0300001B
 
 /* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */
-# define SSL3_RFC_RSA_NULL_MD5                   "TLS_RSA_WITH_NULL_MD5"
-# define SSL3_RFC_RSA_NULL_SHA                   "TLS_RSA_WITH_NULL_SHA"
-# define SSL3_RFC_RSA_DES_192_CBC3_SHA           "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
-# define SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA       "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"
-# define SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA       "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"
-# define SSL3_RFC_ADH_DES_192_CBC_SHA            "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"
-# define SSL3_RFC_RSA_IDEA_128_SHA               "TLS_RSA_WITH_IDEA_CBC_SHA"
-# define SSL3_RFC_RSA_RC4_128_MD5                "TLS_RSA_WITH_RC4_128_MD5"
-# define SSL3_RFC_RSA_RC4_128_SHA                "TLS_RSA_WITH_RC4_128_SHA"
-# define SSL3_RFC_ADH_RC4_128_MD5                "TLS_DH_anon_WITH_RC4_128_MD5"
-
-# define SSL3_TXT_RSA_NULL_MD5                   "NULL-MD5"
-# define SSL3_TXT_RSA_NULL_SHA                   "NULL-SHA"
-# define SSL3_TXT_RSA_RC4_40_MD5                 "EXP-RC4-MD5"
-# define SSL3_TXT_RSA_RC4_128_MD5                "RC4-MD5"
-# define SSL3_TXT_RSA_RC4_128_SHA                "RC4-SHA"
-# define SSL3_TXT_RSA_RC2_40_MD5                 "EXP-RC2-CBC-MD5"
-# define SSL3_TXT_RSA_IDEA_128_SHA               "IDEA-CBC-SHA"
-# define SSL3_TXT_RSA_DES_40_CBC_SHA             "EXP-DES-CBC-SHA"
-# define SSL3_TXT_RSA_DES_64_CBC_SHA             "DES-CBC-SHA"
-# define SSL3_TXT_RSA_DES_192_CBC3_SHA           "DES-CBC3-SHA"
-
-# define SSL3_TXT_DH_DSS_DES_40_CBC_SHA          "EXP-DH-DSS-DES-CBC-SHA"
-# define SSL3_TXT_DH_DSS_DES_64_CBC_SHA          "DH-DSS-DES-CBC-SHA"
-# define SSL3_TXT_DH_DSS_DES_192_CBC3_SHA        "DH-DSS-DES-CBC3-SHA"
-# define SSL3_TXT_DH_RSA_DES_40_CBC_SHA          "EXP-DH-RSA-DES-CBC-SHA"
-# define SSL3_TXT_DH_RSA_DES_64_CBC_SHA          "DH-RSA-DES-CBC-SHA"
-# define SSL3_TXT_DH_RSA_DES_192_CBC3_SHA        "DH-RSA-DES-CBC3-SHA"
-
-# define SSL3_TXT_DHE_DSS_DES_40_CBC_SHA         "EXP-DHE-DSS-DES-CBC-SHA"
-# define SSL3_TXT_DHE_DSS_DES_64_CBC_SHA         "DHE-DSS-DES-CBC-SHA"
-# define SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA       "DHE-DSS-DES-CBC3-SHA"
-# define SSL3_TXT_DHE_RSA_DES_40_CBC_SHA         "EXP-DHE-RSA-DES-CBC-SHA"
-# define SSL3_TXT_DHE_RSA_DES_64_CBC_SHA         "DHE-RSA-DES-CBC-SHA"
-# define SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA       "DHE-RSA-DES-CBC3-SHA"
+#define SSL3_RFC_RSA_NULL_MD5 "TLS_RSA_WITH_NULL_MD5"
+#define SSL3_RFC_RSA_NULL_SHA "TLS_RSA_WITH_NULL_SHA"
+#define SSL3_RFC_RSA_DES_192_CBC3_SHA "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
+#define SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"
+#define SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"
+#define SSL3_RFC_ADH_DES_192_CBC_SHA "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"
+#define SSL3_RFC_RSA_IDEA_128_SHA "TLS_RSA_WITH_IDEA_CBC_SHA"
+#define SSL3_RFC_RSA_RC4_128_MD5 "TLS_RSA_WITH_RC4_128_MD5"
+#define SSL3_RFC_RSA_RC4_128_SHA "TLS_RSA_WITH_RC4_128_SHA"
+#define SSL3_RFC_ADH_RC4_128_MD5 "TLS_DH_anon_WITH_RC4_128_MD5"
+
+#define SSL3_TXT_RSA_NULL_MD5 "NULL-MD5"
+#define SSL3_TXT_RSA_NULL_SHA "NULL-SHA"
+#define SSL3_TXT_RSA_RC4_40_MD5 "EXP-RC4-MD5"
+#define SSL3_TXT_RSA_RC4_128_MD5 "RC4-MD5"
+#define SSL3_TXT_RSA_RC4_128_SHA "RC4-SHA"
+#define SSL3_TXT_RSA_RC2_40_MD5 "EXP-RC2-CBC-MD5"
+#define SSL3_TXT_RSA_IDEA_128_SHA "IDEA-CBC-SHA"
+#define SSL3_TXT_RSA_DES_40_CBC_SHA "EXP-DES-CBC-SHA"
+#define SSL3_TXT_RSA_DES_64_CBC_SHA "DES-CBC-SHA"
+#define SSL3_TXT_RSA_DES_192_CBC3_SHA "DES-CBC3-SHA"
+
+#define SSL3_TXT_DH_DSS_DES_40_CBC_SHA "EXP-DH-DSS-DES-CBC-SHA"
+#define SSL3_TXT_DH_DSS_DES_64_CBC_SHA "DH-DSS-DES-CBC-SHA"
+#define SSL3_TXT_DH_DSS_DES_192_CBC3_SHA "DH-DSS-DES-CBC3-SHA"
+#define SSL3_TXT_DH_RSA_DES_40_CBC_SHA "EXP-DH-RSA-DES-CBC-SHA"
+#define SSL3_TXT_DH_RSA_DES_64_CBC_SHA "DH-RSA-DES-CBC-SHA"
+#define SSL3_TXT_DH_RSA_DES_192_CBC3_SHA "DH-RSA-DES-CBC3-SHA"
+
+#define SSL3_TXT_DHE_DSS_DES_40_CBC_SHA "EXP-DHE-DSS-DES-CBC-SHA"
+#define SSL3_TXT_DHE_DSS_DES_64_CBC_SHA "DHE-DSS-DES-CBC-SHA"
+#define SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA "DHE-DSS-DES-CBC3-SHA"
+#define SSL3_TXT_DHE_RSA_DES_40_CBC_SHA "EXP-DHE-RSA-DES-CBC-SHA"
+#define SSL3_TXT_DHE_RSA_DES_64_CBC_SHA "DHE-RSA-DES-CBC-SHA"
+#define SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA "DHE-RSA-DES-CBC3-SHA"
 
 /*
  * This next block of six "EDH" labels is for backward compatibility with
  * older versions of OpenSSL.  New code should use the six "DHE" labels above
  * instead:
  */
-# define SSL3_TXT_EDH_DSS_DES_40_CBC_SHA         "EXP-EDH-DSS-DES-CBC-SHA"
-# define SSL3_TXT_EDH_DSS_DES_64_CBC_SHA         "EDH-DSS-DES-CBC-SHA"
-# define SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA       "EDH-DSS-DES-CBC3-SHA"
-# define SSL3_TXT_EDH_RSA_DES_40_CBC_SHA         "EXP-EDH-RSA-DES-CBC-SHA"
-# define SSL3_TXT_EDH_RSA_DES_64_CBC_SHA         "EDH-RSA-DES-CBC-SHA"
-# define SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA       "EDH-RSA-DES-CBC3-SHA"
-
-# define SSL3_TXT_ADH_RC4_40_MD5                 "EXP-ADH-RC4-MD5"
-# define SSL3_TXT_ADH_RC4_128_MD5                "ADH-RC4-MD5"
-# define SSL3_TXT_ADH_DES_40_CBC_SHA             "EXP-ADH-DES-CBC-SHA"
-# define SSL3_TXT_ADH_DES_64_CBC_SHA             "ADH-DES-CBC-SHA"
-# define SSL3_TXT_ADH_DES_192_CBC_SHA            "ADH-DES-CBC3-SHA"
-
-# define SSL3_SSL_SESSION_ID_LENGTH              32
-# define SSL3_MAX_SSL_SESSION_ID_LENGTH          32
-
-# define SSL3_MASTER_SECRET_SIZE                 48
-# define SSL3_RANDOM_SIZE                        32
-# define SSL3_SESSION_ID_SIZE                    32
-# define SSL3_RT_HEADER_LENGTH                   5
-
-# define SSL3_HM_HEADER_LENGTH                  4
-
-# ifndef SSL3_ALIGN_PAYLOAD
- /*
-  * Some will argue that this increases memory footprint, but it's not
-  * actually true. Point is that malloc has to return at least 64-bit aligned
-  * pointers, meaning that allocating 5 bytes wastes 3 bytes in either case.
-  * Suggested pre-gaping simply moves these wasted bytes from the end of
-  * allocated region to its front, but makes data payload aligned, which
-  * improves performance:-)
-  */
-#  define SSL3_ALIGN_PAYLOAD                     8
-# else
-#  if (SSL3_ALIGN_PAYLOAD&(SSL3_ALIGN_PAYLOAD-1))!=0
-#   error "insane SSL3_ALIGN_PAYLOAD"
-#   undef SSL3_ALIGN_PAYLOAD
-#  endif
-# endif
+#define SSL3_TXT_EDH_DSS_DES_40_CBC_SHA "EXP-EDH-DSS-DES-CBC-SHA"
+#define SSL3_TXT_EDH_DSS_DES_64_CBC_SHA "EDH-DSS-DES-CBC-SHA"
+#define SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA "EDH-DSS-DES-CBC3-SHA"
+#define SSL3_TXT_EDH_RSA_DES_40_CBC_SHA "EXP-EDH-RSA-DES-CBC-SHA"
+#define SSL3_TXT_EDH_RSA_DES_64_CBC_SHA "EDH-RSA-DES-CBC-SHA"
+#define SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA "EDH-RSA-DES-CBC3-SHA"
+
+#define SSL3_TXT_ADH_RC4_40_MD5 "EXP-ADH-RC4-MD5"
+#define SSL3_TXT_ADH_RC4_128_MD5 "ADH-RC4-MD5"
+#define SSL3_TXT_ADH_DES_40_CBC_SHA "EXP-ADH-DES-CBC-SHA"
+#define SSL3_TXT_ADH_DES_64_CBC_SHA "ADH-DES-CBC-SHA"
+#define SSL3_TXT_ADH_DES_192_CBC_SHA "ADH-DES-CBC3-SHA"
+
+#define SSL3_SSL_SESSION_ID_LENGTH 32
+#define SSL3_MAX_SSL_SESSION_ID_LENGTH 32
+
+#define SSL3_MASTER_SECRET_SIZE 48
+#define SSL3_RANDOM_SIZE 32
+#define SSL3_SESSION_ID_SIZE 32
+#define SSL3_RT_HEADER_LENGTH 5
+
+#define SSL3_HM_HEADER_LENGTH 4
+
+#ifndef SSL3_ALIGN_PAYLOAD
+    /*
+     * Some will argue that this increases memory footprint, but it's not
+     * actually true. Point is that malloc has to return at least 64-bit aligned
+     * pointers, meaning that allocating 5 bytes wastes 3 bytes in either case.
+     * Suggested pre-gaping simply moves these wasted bytes from the end of
+     * allocated region to its front, but makes data payload aligned, which
+     * improves performance:-)
+     */
+#define SSL3_ALIGN_PAYLOAD 8
+#else
+#if (SSL3_ALIGN_PAYLOAD & (SSL3_ALIGN_PAYLOAD - 1)) != 0
+#error "insane SSL3_ALIGN_PAYLOAD"
+#undef SSL3_ALIGN_PAYLOAD
+#endif
+#endif
 
-/*
- * This is the maximum MAC (digest) size used by the SSL library. Currently
- * maximum of 20 is used by SHA1, but we reserve for future extension for
- * 512-bit hashes.
- */
+    /*
+     * This is the maximum MAC (digest) size used by the SSL library. Currently
+     * maximum of 20 is used by SHA1, but we reserve for future extension for
+     * 512-bit hashes.
+     */
 
-# define SSL3_RT_MAX_MD_SIZE                     64
+#define SSL3_RT_MAX_MD_SIZE 64
 
-/*
- * Maximum block size used in all ciphersuites. Currently 16 for AES.
- */
+    /*
+     * Maximum block size used in all ciphersuites. Currently 16 for AES.
+     */
 
-# define SSL_RT_MAX_CIPHER_BLOCK_SIZE            16
+#define SSL_RT_MAX_CIPHER_BLOCK_SIZE 16
 
-# define SSL3_RT_MAX_EXTRA                       (16384)
+#define SSL3_RT_MAX_EXTRA (16384)
 
 /* Maximum plaintext length: defined by SSL/TLS standards */
-# define SSL3_RT_MAX_PLAIN_LENGTH                16384
+#define SSL3_RT_MAX_PLAIN_LENGTH 16384
 /* Maximum compression overhead: defined by SSL/TLS standards */
-# define SSL3_RT_MAX_COMPRESSED_OVERHEAD         1024
+#define SSL3_RT_MAX_COMPRESSED_OVERHEAD 1024
 
 /*
  * The standards give a maximum encryption overhead of 1024 bytes. In
  * practice the value is lower than this. The overhead is the maximum number
  * of padding bytes (256) plus the mac size.
  */
-# define SSL3_RT_MAX_ENCRYPTED_OVERHEAD        (256 + SSL3_RT_MAX_MD_SIZE)
-# define SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD  256
+#define SSL3_RT_MAX_ENCRYPTED_OVERHEAD (256 + SSL3_RT_MAX_MD_SIZE)
+#define SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD 256
 
-/*
- * OpenSSL currently only uses a padding length of at most one block so the
- * send overhead is smaller.
- */
+    /*
+     * OpenSSL currently only uses a padding length of at most one block so the
+     * send overhead is smaller.
+     */
 
-# define SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
-                        (SSL_RT_MAX_CIPHER_BLOCK_SIZE + SSL3_RT_MAX_MD_SIZE)
+#define SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
+    (SSL_RT_MAX_CIPHER_BLOCK_SIZE + SSL3_RT_MAX_MD_SIZE)
 
-/* If compression isn't used don't include the compression overhead */
+    /* If compression isn't used don't include the compression overhead */
 
-# ifdef OPENSSL_NO_COMP
-#  define SSL3_RT_MAX_COMPRESSED_LENGTH           SSL3_RT_MAX_PLAIN_LENGTH
-# else
-#  define SSL3_RT_MAX_COMPRESSED_LENGTH   \
-            (SSL3_RT_MAX_PLAIN_LENGTH+SSL3_RT_MAX_COMPRESSED_OVERHEAD)
-# endif
-# define SSL3_RT_MAX_ENCRYPTED_LENGTH    \
-            (SSL3_RT_MAX_ENCRYPTED_OVERHEAD+SSL3_RT_MAX_COMPRESSED_LENGTH)
-# define SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH \
-            (SSL3_RT_MAX_PLAIN_LENGTH + SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD)
-# define SSL3_RT_MAX_PACKET_SIZE         \
-            (SSL3_RT_MAX_ENCRYPTED_LENGTH+SSL3_RT_HEADER_LENGTH)
+#ifdef OPENSSL_NO_COMP
+#define SSL3_RT_MAX_COMPRESSED_LENGTH SSL3_RT_MAX_PLAIN_LENGTH
+#else
+#define SSL3_RT_MAX_COMPRESSED_LENGTH \
+    (SSL3_RT_MAX_PLAIN_LENGTH + SSL3_RT_MAX_COMPRESSED_OVERHEAD)
+#endif
+#define SSL3_RT_MAX_ENCRYPTED_LENGTH \
+    (SSL3_RT_MAX_ENCRYPTED_OVERHEAD + SSL3_RT_MAX_COMPRESSED_LENGTH)
+#define SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH \
+    (SSL3_RT_MAX_PLAIN_LENGTH + SSL3_RT_MAX_TLS13_ENCRYPTED_OVERHEAD)
+#define SSL3_RT_MAX_PACKET_SIZE \
+    (SSL3_RT_MAX_ENCRYPTED_LENGTH + SSL3_RT_HEADER_LENGTH)
 
-# define SSL3_MD_CLIENT_FINISHED_CONST   "\x43\x4C\x4E\x54"
-# define SSL3_MD_SERVER_FINISHED_CONST   "\x53\x52\x56\x52"
+#define SSL3_MD_CLIENT_FINISHED_CONST "\x43\x4C\x4E\x54"
+#define SSL3_MD_SERVER_FINISHED_CONST "\x53\x52\x56\x52"
 
 /* SSL3_VERSION is defined in prov_ssl.h */
-# define SSL3_VERSION_MAJOR              0x03
-# define SSL3_VERSION_MINOR              0x00
+#define SSL3_VERSION_MAJOR 0x03
+#define SSL3_VERSION_MINOR 0x00
 
-# define SSL3_RT_CHANGE_CIPHER_SPEC      20
-# define SSL3_RT_ALERT                   21
-# define SSL3_RT_HANDSHAKE               22
-# define SSL3_RT_APPLICATION_DATA        23
+#define SSL3_RT_CHANGE_CIPHER_SPEC 20
+#define SSL3_RT_ALERT 21
+#define SSL3_RT_HANDSHAKE 22
+#define SSL3_RT_APPLICATION_DATA 23
 
 /* Pseudo content types to indicate additional parameters */
-# define TLS1_RT_CRYPTO                  0x1000
-# define TLS1_RT_CRYPTO_PREMASTER        (TLS1_RT_CRYPTO | 0x1)
-# define TLS1_RT_CRYPTO_CLIENT_RANDOM    (TLS1_RT_CRYPTO | 0x2)
-# define TLS1_RT_CRYPTO_SERVER_RANDOM    (TLS1_RT_CRYPTO | 0x3)
-# define TLS1_RT_CRYPTO_MASTER           (TLS1_RT_CRYPTO | 0x4)
-
-# define TLS1_RT_CRYPTO_READ             0x0000
-# define TLS1_RT_CRYPTO_WRITE            0x0100
-# define TLS1_RT_CRYPTO_MAC              (TLS1_RT_CRYPTO | 0x5)
-# define TLS1_RT_CRYPTO_KEY              (TLS1_RT_CRYPTO | 0x6)
-# define TLS1_RT_CRYPTO_IV               (TLS1_RT_CRYPTO | 0x7)
-# define TLS1_RT_CRYPTO_FIXED_IV         (TLS1_RT_CRYPTO | 0x8)
+#define TLS1_RT_CRYPTO 0x1000
+#define TLS1_RT_CRYPTO_PREMASTER (TLS1_RT_CRYPTO | 0x1)
+#define TLS1_RT_CRYPTO_CLIENT_RANDOM (TLS1_RT_CRYPTO | 0x2)
+#define TLS1_RT_CRYPTO_SERVER_RANDOM (TLS1_RT_CRYPTO | 0x3)
+#define TLS1_RT_CRYPTO_MASTER (TLS1_RT_CRYPTO | 0x4)
+
+#define TLS1_RT_CRYPTO_READ 0x0000
+#define TLS1_RT_CRYPTO_WRITE 0x0100
+#define TLS1_RT_CRYPTO_MAC (TLS1_RT_CRYPTO | 0x5)
+#define TLS1_RT_CRYPTO_KEY (TLS1_RT_CRYPTO | 0x6)
+#define TLS1_RT_CRYPTO_IV (TLS1_RT_CRYPTO | 0x7)
+#define TLS1_RT_CRYPTO_FIXED_IV (TLS1_RT_CRYPTO | 0x8)
 
 /* Pseudo content types for SSL/TLS header info */
-# define SSL3_RT_HEADER                  0x100
-# define SSL3_RT_INNER_CONTENT_TYPE      0x101
-
-# define SSL3_AL_WARNING                 1
-# define SSL3_AL_FATAL                   2
-
-# define SSL3_AD_CLOSE_NOTIFY             0
-# define SSL3_AD_UNEXPECTED_MESSAGE      10/* fatal */
-# define SSL3_AD_BAD_RECORD_MAC          20/* fatal */
-# define SSL3_AD_DECOMPRESSION_FAILURE   30/* fatal */
-# define SSL3_AD_HANDSHAKE_FAILURE       40/* fatal */
-# define SSL3_AD_NO_CERTIFICATE          41
-# define SSL3_AD_BAD_CERTIFICATE         42
-# define SSL3_AD_UNSUPPORTED_CERTIFICATE 43
-# define SSL3_AD_CERTIFICATE_REVOKED     44
-# define SSL3_AD_CERTIFICATE_EXPIRED     45
-# define SSL3_AD_CERTIFICATE_UNKNOWN     46
-# define SSL3_AD_ILLEGAL_PARAMETER       47/* fatal */
-
-# define TLS1_HB_REQUEST         1
-# define TLS1_HB_RESPONSE        2
-
-
-# define SSL3_CT_RSA_SIGN                        1
-# define SSL3_CT_DSS_SIGN                        2
-# define SSL3_CT_RSA_FIXED_DH                    3
-# define SSL3_CT_DSS_FIXED_DH                    4
-# define SSL3_CT_RSA_EPHEMERAL_DH                5
-# define SSL3_CT_DSS_EPHEMERAL_DH                6
-# define SSL3_CT_FORTEZZA_DMS                    20
+#define SSL3_RT_HEADER 0x100
+#define SSL3_RT_INNER_CONTENT_TYPE 0x101
+
+#define SSL3_AL_WARNING 1
+#define SSL3_AL_FATAL 2
+
+#define SSL3_AD_CLOSE_NOTIFY 0
+#define SSL3_AD_UNEXPECTED_MESSAGE 10    /* fatal */
+#define SSL3_AD_BAD_RECORD_MAC 20        /* fatal */
+#define SSL3_AD_DECOMPRESSION_FAILURE 30 /* fatal */
+#define SSL3_AD_HANDSHAKE_FAILURE 40     /* fatal */
+#define SSL3_AD_NO_CERTIFICATE 41
+#define SSL3_AD_BAD_CERTIFICATE 42
+#define SSL3_AD_UNSUPPORTED_CERTIFICATE 43
+#define SSL3_AD_CERTIFICATE_REVOKED 44
+#define SSL3_AD_CERTIFICATE_EXPIRED 45
+#define SSL3_AD_CERTIFICATE_UNKNOWN 46
+#define SSL3_AD_ILLEGAL_PARAMETER 47 /* fatal */
+
+#define TLS1_HB_REQUEST 1
+#define TLS1_HB_RESPONSE 2
+
+#define SSL3_CT_RSA_SIGN 1
+#define SSL3_CT_DSS_SIGN 2
+#define SSL3_CT_RSA_FIXED_DH 3
+#define SSL3_CT_DSS_FIXED_DH 4
+#define SSL3_CT_RSA_EPHEMERAL_DH 5
+#define SSL3_CT_DSS_EPHEMERAL_DH 6
+#define SSL3_CT_FORTEZZA_DMS 20
 /*
  * SSL3_CT_NUMBER is used to size arrays and it must be large enough to
  * contain all of the cert types defined for *either* SSLv3 and TLSv1.
  */
-# define SSL3_CT_NUMBER                  12
+#define SSL3_CT_NUMBER 12
 
-# if defined(TLS_CT_NUMBER)
-#  if TLS_CT_NUMBER != SSL3_CT_NUMBER
-#    error "SSL/TLS CT_NUMBER values do not match"
-#  endif
-# endif
+#if defined(TLS_CT_NUMBER)
+#if TLS_CT_NUMBER != SSL3_CT_NUMBER
+#error "SSL/TLS CT_NUMBER values do not match"
+#endif
+#endif
 
 /* No longer used as of OpenSSL 1.1.1 */
-# define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS       0x0001
+#define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS 0x0001
 
 /* Removed from OpenSSL 1.1.0 */
-# define TLS1_FLAGS_TLS_PADDING_BUG              0x0
+#define TLS1_FLAGS_TLS_PADDING_BUG 0x0
 
-# define TLS1_FLAGS_SKIP_CERT_VERIFY             0x0010
+#define TLS1_FLAGS_SKIP_CERT_VERIFY 0x0010
 
 /* Set if we encrypt then mac instead of usual mac then encrypt */
-# define TLS1_FLAGS_ENCRYPT_THEN_MAC_READ        0x0100
-# define TLS1_FLAGS_ENCRYPT_THEN_MAC             TLS1_FLAGS_ENCRYPT_THEN_MAC_READ
+#define TLS1_FLAGS_ENCRYPT_THEN_MAC_READ 0x0100
+#define TLS1_FLAGS_ENCRYPT_THEN_MAC TLS1_FLAGS_ENCRYPT_THEN_MAC_READ
 
 /* Set if extended master secret extension received from peer */
-# define TLS1_FLAGS_RECEIVED_EXTMS               0x0200
+#define TLS1_FLAGS_RECEIVED_EXTMS 0x0200
 
-# define TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE       0x0400
+#define TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE 0x0400
 
-# define TLS1_FLAGS_STATELESS                    0x0800
+#define TLS1_FLAGS_STATELESS 0x0800
 
 /* Set if extended master secret extension required on renegotiation */
-# define TLS1_FLAGS_REQUIRED_EXTMS               0x1000
-
-# define SSL3_MT_HELLO_REQUEST                   0
-# define SSL3_MT_CLIENT_HELLO                    1
-# define SSL3_MT_SERVER_HELLO                    2
-# define SSL3_MT_NEWSESSION_TICKET               4
-# define SSL3_MT_END_OF_EARLY_DATA               5
-# define SSL3_MT_ENCRYPTED_EXTENSIONS            8
-# define SSL3_MT_CERTIFICATE                     11
-# define SSL3_MT_SERVER_KEY_EXCHANGE             12
-# define SSL3_MT_CERTIFICATE_REQUEST             13
-# define SSL3_MT_SERVER_DONE                     14
-# define SSL3_MT_CERTIFICATE_VERIFY              15
-# define SSL3_MT_CLIENT_KEY_EXCHANGE             16
-# define SSL3_MT_FINISHED                        20
-# define SSL3_MT_CERTIFICATE_URL                 21
-# define SSL3_MT_CERTIFICATE_STATUS              22
-# define SSL3_MT_SUPPLEMENTAL_DATA               23
-# define SSL3_MT_KEY_UPDATE                      24
-# ifndef OPENSSL_NO_NEXTPROTONEG
-#  define SSL3_MT_NEXT_PROTO                     67
-# endif
-# define SSL3_MT_MESSAGE_HASH                    254
-# define DTLS1_MT_HELLO_VERIFY_REQUEST           3
+#define TLS1_FLAGS_REQUIRED_EXTMS 0x1000
+
+#define SSL3_MT_HELLO_REQUEST 0
+#define SSL3_MT_CLIENT_HELLO 1
+#define SSL3_MT_SERVER_HELLO 2
+#define SSL3_MT_NEWSESSION_TICKET 4
+#define SSL3_MT_END_OF_EARLY_DATA 5
+#define SSL3_MT_ENCRYPTED_EXTENSIONS 8
+#define SSL3_MT_CERTIFICATE 11
+#define SSL3_MT_SERVER_KEY_EXCHANGE 12
+#define SSL3_MT_CERTIFICATE_REQUEST 13
+#define SSL3_MT_SERVER_DONE 14
+#define SSL3_MT_CERTIFICATE_VERIFY 15
+#define SSL3_MT_CLIENT_KEY_EXCHANGE 16
+#define SSL3_MT_FINISHED 20
+#define SSL3_MT_CERTIFICATE_URL 21
+#define SSL3_MT_CERTIFICATE_STATUS 22
+#define SSL3_MT_SUPPLEMENTAL_DATA 23
+#define SSL3_MT_KEY_UPDATE 24
+#ifndef OPENSSL_NO_NEXTPROTONEG
+#define SSL3_MT_NEXT_PROTO 67
+#endif
+#define SSL3_MT_MESSAGE_HASH 254
+#define DTLS1_MT_HELLO_VERIFY_REQUEST 3
 
 /* Dummy message type for handling CCS like a normal handshake message */
-# define SSL3_MT_CHANGE_CIPHER_SPEC              0x0101
+#define SSL3_MT_CHANGE_CIPHER_SPEC 0x0101
 
-# define SSL3_MT_CCS                             1
+#define SSL3_MT_CCS 1
 
 /* These are used when changing over to a new cipher */
-# define SSL3_CC_READ            0x001
-# define SSL3_CC_WRITE           0x002
-# define SSL3_CC_CLIENT          0x010
-# define SSL3_CC_SERVER          0x020
-# define SSL3_CC_EARLY           0x040
-# define SSL3_CC_HANDSHAKE       0x080
-# define SSL3_CC_APPLICATION     0x100
-# define SSL3_CHANGE_CIPHER_CLIENT_WRITE (SSL3_CC_CLIENT|SSL3_CC_WRITE)
-# define SSL3_CHANGE_CIPHER_SERVER_READ  (SSL3_CC_SERVER|SSL3_CC_READ)
-# define SSL3_CHANGE_CIPHER_CLIENT_READ  (SSL3_CC_CLIENT|SSL3_CC_READ)
-# define SSL3_CHANGE_CIPHER_SERVER_WRITE (SSL3_CC_SERVER|SSL3_CC_WRITE)
-
-#ifdef  __cplusplus
+#define SSL3_CC_READ 0x001
+#define SSL3_CC_WRITE 0x002
+#define SSL3_CC_CLIENT 0x010
+#define SSL3_CC_SERVER 0x020
+#define SSL3_CC_EARLY 0x040
+#define SSL3_CC_HANDSHAKE 0x080
+#define SSL3_CC_APPLICATION 0x100
+#define SSL3_CHANGE_CIPHER_CLIENT_WRITE (SSL3_CC_CLIENT | SSL3_CC_WRITE)
+#define SSL3_CHANGE_CIPHER_SERVER_READ (SSL3_CC_SERVER | SSL3_CC_READ)
+#define SSL3_CHANGE_CIPHER_CLIENT_READ (SSL3_CC_CLIENT | SSL3_CC_READ)
+#define SSL3_CHANGE_CIPHER_SERVER_WRITE (SSL3_CC_SERVER | SSL3_CC_WRITE)
+
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/sslerr.h b/CAPI/cpp/grpc/include/openssl/sslerr.h
index a4746d7..acaf4b6 100644
--- a/CAPI/cpp/grpc/include/openssl/sslerr.h
+++ b/CAPI/cpp/grpc/include/openssl/sslerr.h
@@ -9,335 +9,333 @@
  */
 
 #ifndef OPENSSL_SSLERR_H
-# define OPENSSL_SSLERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/sslerr_legacy.h>
-
+#define OPENSSL_SSLERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/sslerr_legacy.h>
 
 /*
  * SSL reason codes.
  */
-# define SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY        291
-# define SSL_R_APP_DATA_IN_HANDSHAKE                      100
-# define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 272
-# define SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE     158
-# define SSL_R_BAD_CHANGE_CIPHER_SPEC                     103
-# define SSL_R_BAD_CIPHER                                 186
-# define SSL_R_BAD_DATA                                   390
-# define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK              106
-# define SSL_R_BAD_DECOMPRESSION                          107
-# define SSL_R_BAD_DH_VALUE                               102
-# define SSL_R_BAD_DIGEST_LENGTH                          111
-# define SSL_R_BAD_EARLY_DATA                             233
-# define SSL_R_BAD_ECC_CERT                               304
-# define SSL_R_BAD_ECPOINT                                306
-# define SSL_R_BAD_EXTENSION                              110
-# define SSL_R_BAD_HANDSHAKE_LENGTH                       332
-# define SSL_R_BAD_HANDSHAKE_STATE                        236
-# define SSL_R_BAD_HELLO_REQUEST                          105
-# define SSL_R_BAD_HRR_VERSION                            263
-# define SSL_R_BAD_KEY_SHARE                              108
-# define SSL_R_BAD_KEY_UPDATE                             122
-# define SSL_R_BAD_LEGACY_VERSION                         292
-# define SSL_R_BAD_LENGTH                                 271
-# define SSL_R_BAD_PACKET                                 240
-# define SSL_R_BAD_PACKET_LENGTH                          115
-# define SSL_R_BAD_PROTOCOL_VERSION_NUMBER                116
-# define SSL_R_BAD_PSK                                    219
-# define SSL_R_BAD_PSK_IDENTITY                           114
-# define SSL_R_BAD_RECORD_TYPE                            443
-# define SSL_R_BAD_RSA_ENCRYPT                            119
-# define SSL_R_BAD_SIGNATURE                              123
-# define SSL_R_BAD_SRP_A_LENGTH                           347
-# define SSL_R_BAD_SRP_PARAMETERS                         371
-# define SSL_R_BAD_SRTP_MKI_VALUE                         352
-# define SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST           353
-# define SSL_R_BAD_SSL_FILETYPE                           124
-# define SSL_R_BAD_VALUE                                  384
-# define SSL_R_BAD_WRITE_RETRY                            127
-# define SSL_R_BINDER_DOES_NOT_VERIFY                     253
-# define SSL_R_BIO_NOT_SET                                128
-# define SSL_R_BLOCK_CIPHER_PAD_IS_WRONG                  129
-# define SSL_R_BN_LIB                                     130
-# define SSL_R_CALLBACK_FAILED                            234
-# define SSL_R_CANNOT_CHANGE_CIPHER                       109
-# define SSL_R_CANNOT_GET_GROUP_NAME                      299
-# define SSL_R_CA_DN_LENGTH_MISMATCH                      131
-# define SSL_R_CA_KEY_TOO_SMALL                           397
-# define SSL_R_CA_MD_TOO_WEAK                             398
-# define SSL_R_CCS_RECEIVED_EARLY                         133
-# define SSL_R_CERTIFICATE_VERIFY_FAILED                  134
-# define SSL_R_CERT_CB_ERROR                              377
-# define SSL_R_CERT_LENGTH_MISMATCH                       135
-# define SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED             218
-# define SSL_R_CIPHER_CODE_WRONG_LENGTH                   137
-# define SSL_R_CLIENTHELLO_TLSEXT                         226
-# define SSL_R_COMPRESSED_LENGTH_TOO_LONG                 140
-# define SSL_R_COMPRESSION_DISABLED                       343
-# define SSL_R_COMPRESSION_FAILURE                        141
-# define SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE    307
-# define SSL_R_COMPRESSION_LIBRARY_ERROR                  142
-# define SSL_R_CONNECTION_TYPE_NOT_SET                    144
-# define SSL_R_CONTEXT_NOT_DANE_ENABLED                   167
-# define SSL_R_COOKIE_GEN_CALLBACK_FAILURE                400
-# define SSL_R_COOKIE_MISMATCH                            308
-# define SSL_R_COPY_PARAMETERS_FAILED                     296
-# define SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED       206
-# define SSL_R_DANE_ALREADY_ENABLED                       172
-# define SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL            173
-# define SSL_R_DANE_NOT_ENABLED                           175
-# define SSL_R_DANE_TLSA_BAD_CERTIFICATE                  180
-# define SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE            184
-# define SSL_R_DANE_TLSA_BAD_DATA_LENGTH                  189
-# define SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH                192
-# define SSL_R_DANE_TLSA_BAD_MATCHING_TYPE                200
-# define SSL_R_DANE_TLSA_BAD_PUBLIC_KEY                   201
-# define SSL_R_DANE_TLSA_BAD_SELECTOR                     202
-# define SSL_R_DANE_TLSA_NULL_DATA                        203
-# define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED              145
-# define SSL_R_DATA_LENGTH_TOO_LONG                       146
-# define SSL_R_DECRYPTION_FAILED                          147
-# define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC        281
-# define SSL_R_DH_KEY_TOO_SMALL                           394
-# define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG            148
-# define SSL_R_DIGEST_CHECK_FAILED                        149
-# define SSL_R_DTLS_MESSAGE_TOO_BIG                       334
-# define SSL_R_DUPLICATE_COMPRESSION_ID                   309
-# define SSL_R_ECC_CERT_NOT_FOR_SIGNING                   318
-# define SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE              374
-# define SSL_R_EE_KEY_TOO_SMALL                           399
-# define SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST         354
-# define SSL_R_ENCRYPTED_LENGTH_TOO_LONG                  150
-# define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST              151
-# define SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN             204
-# define SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE                  194
-# define SSL_R_EXCESSIVE_MESSAGE_SIZE                     152
-# define SSL_R_EXTENSION_NOT_RECEIVED                     279
-# define SSL_R_EXTRA_DATA_IN_MESSAGE                      153
-# define SSL_R_EXT_LENGTH_MISMATCH                        163
-# define SSL_R_FAILED_TO_INIT_ASYNC                       405
-# define SSL_R_FRAGMENTED_CLIENT_HELLO                    401
-# define SSL_R_GOT_A_FIN_BEFORE_A_CCS                     154
-# define SSL_R_HTTPS_PROXY_REQUEST                        155
-# define SSL_R_HTTP_REQUEST                               156
-# define SSL_R_ILLEGAL_POINT_COMPRESSION                  162
-# define SSL_R_ILLEGAL_SUITEB_DIGEST                      380
-# define SSL_R_INAPPROPRIATE_FALLBACK                     373
-# define SSL_R_INCONSISTENT_COMPRESSION                   340
-# define SSL_R_INCONSISTENT_EARLY_DATA_ALPN               222
-# define SSL_R_INCONSISTENT_EARLY_DATA_SNI                231
-# define SSL_R_INCONSISTENT_EXTMS                         104
-# define SSL_R_INSUFFICIENT_SECURITY                      241
-# define SSL_R_INVALID_ALERT                              205
-# define SSL_R_INVALID_CCS_MESSAGE                        260
-# define SSL_R_INVALID_CERTIFICATE_OR_ALG                 238
-# define SSL_R_INVALID_COMMAND                            280
-# define SSL_R_INVALID_COMPRESSION_ALGORITHM              341
-# define SSL_R_INVALID_CONFIG                             283
-# define SSL_R_INVALID_CONFIGURATION_NAME                 113
-# define SSL_R_INVALID_CONTEXT                            282
-# define SSL_R_INVALID_CT_VALIDATION_TYPE                 212
-# define SSL_R_INVALID_KEY_UPDATE_TYPE                    120
-# define SSL_R_INVALID_MAX_EARLY_DATA                     174
-# define SSL_R_INVALID_NULL_CMD_NAME                      385
-# define SSL_R_INVALID_SEQUENCE_NUMBER                    402
-# define SSL_R_INVALID_SERVERINFO_DATA                    388
-# define SSL_R_INVALID_SESSION_ID                         999
-# define SSL_R_INVALID_SRP_USERNAME                       357
-# define SSL_R_INVALID_STATUS_RESPONSE                    328
-# define SSL_R_INVALID_TICKET_KEYS_LENGTH                 325
-# define SSL_R_LENGTH_MISMATCH                            159
-# define SSL_R_LENGTH_TOO_LONG                            404
-# define SSL_R_LENGTH_TOO_SHORT                           160
-# define SSL_R_LIBRARY_BUG                                274
-# define SSL_R_LIBRARY_HAS_NO_CIPHERS                     161
-# define SSL_R_MISSING_DSA_SIGNING_CERT                   165
-# define SSL_R_MISSING_ECDSA_SIGNING_CERT                 381
-# define SSL_R_MISSING_FATAL                              256
-# define SSL_R_MISSING_PARAMETERS                         290
-# define SSL_R_MISSING_PSK_KEX_MODES_EXTENSION            310
-# define SSL_R_MISSING_RSA_CERTIFICATE                    168
-# define SSL_R_MISSING_RSA_ENCRYPTING_CERT                169
-# define SSL_R_MISSING_RSA_SIGNING_CERT                   170
-# define SSL_R_MISSING_SIGALGS_EXTENSION                  112
-# define SSL_R_MISSING_SIGNING_CERT                       221
-# define SSL_R_MISSING_SRP_PARAM                          358
-# define SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION         209
-# define SSL_R_MISSING_TMP_DH_KEY                         171
-# define SSL_R_MISSING_TMP_ECDH_KEY                       311
-# define SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA     293
-# define SSL_R_NOT_ON_RECORD_BOUNDARY                     182
-# define SSL_R_NOT_REPLACING_CERTIFICATE                  289
-# define SSL_R_NOT_SERVER                                 284
-# define SSL_R_NO_APPLICATION_PROTOCOL                    235
-# define SSL_R_NO_CERTIFICATES_RETURNED                   176
-# define SSL_R_NO_CERTIFICATE_ASSIGNED                    177
-# define SSL_R_NO_CERTIFICATE_SET                         179
-# define SSL_R_NO_CHANGE_FOLLOWING_HRR                    214
-# define SSL_R_NO_CIPHERS_AVAILABLE                       181
-# define SSL_R_NO_CIPHERS_SPECIFIED                       183
-# define SSL_R_NO_CIPHER_MATCH                            185
-# define SSL_R_NO_CLIENT_CERT_METHOD                      331
-# define SSL_R_NO_COMPRESSION_SPECIFIED                   187
-# define SSL_R_NO_COOKIE_CALLBACK_SET                     287
-# define SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER           330
-# define SSL_R_NO_METHOD_SPECIFIED                        188
-# define SSL_R_NO_PEM_EXTENSIONS                          389
-# define SSL_R_NO_PRIVATE_KEY_ASSIGNED                    190
-# define SSL_R_NO_PROTOCOLS_AVAILABLE                     191
-# define SSL_R_NO_RENEGOTIATION                           339
-# define SSL_R_NO_REQUIRED_DIGEST                         324
-# define SSL_R_NO_SHARED_CIPHER                           193
-# define SSL_R_NO_SHARED_GROUPS                           410
-# define SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS             376
-# define SSL_R_NO_SRTP_PROFILES                           359
-# define SSL_R_NO_SUITABLE_DIGEST_ALGORITHM               297
-# define SSL_R_NO_SUITABLE_GROUPS                         295
-# define SSL_R_NO_SUITABLE_KEY_SHARE                      101
-# define SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM            118
-# define SSL_R_NO_VALID_SCTS                              216
-# define SSL_R_NO_VERIFY_COOKIE_CALLBACK                  403
-# define SSL_R_NULL_SSL_CTX                               195
-# define SSL_R_NULL_SSL_METHOD_PASSED                     196
-# define SSL_R_OCSP_CALLBACK_FAILURE                      305
-# define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED            197
-# define SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED 344
-# define SSL_R_OVERFLOW_ERROR                             237
-# define SSL_R_PACKET_LENGTH_TOO_LONG                     198
-# define SSL_R_PARSE_TLSEXT                               227
-# define SSL_R_PATH_TOO_LONG                              270
-# define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE          199
-# define SSL_R_PEM_NAME_BAD_PREFIX                        391
-# define SSL_R_PEM_NAME_TOO_SHORT                         392
-# define SSL_R_PIPELINE_FAILURE                           406
-# define SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR           278
-# define SSL_R_PRIVATE_KEY_MISMATCH                       288
-# define SSL_R_PROTOCOL_IS_SHUTDOWN                       207
-# define SSL_R_PSK_IDENTITY_NOT_FOUND                     223
-# define SSL_R_PSK_NO_CLIENT_CB                           224
-# define SSL_R_PSK_NO_SERVER_CB                           225
-# define SSL_R_READ_BIO_NOT_SET                           211
-# define SSL_R_READ_TIMEOUT_EXPIRED                       312
-# define SSL_R_RECORD_LENGTH_MISMATCH                     213
-# define SSL_R_RECORD_TOO_SMALL                           298
-# define SSL_R_RENEGOTIATE_EXT_TOO_LONG                   335
-# define SSL_R_RENEGOTIATION_ENCODING_ERR                 336
-# define SSL_R_RENEGOTIATION_MISMATCH                     337
-# define SSL_R_REQUEST_PENDING                            285
-# define SSL_R_REQUEST_SENT                               286
-# define SSL_R_REQUIRED_CIPHER_MISSING                    215
-# define SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING     342
-# define SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING           345
-# define SSL_R_SCT_VERIFICATION_FAILED                    208
-# define SSL_R_SERVERHELLO_TLSEXT                         275
-# define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED           277
-# define SSL_R_SHUTDOWN_WHILE_IN_INIT                     407
-# define SSL_R_SIGNATURE_ALGORITHMS_ERROR                 360
-# define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE      220
-# define SSL_R_SRP_A_CALC                                 361
-# define SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES           362
-# define SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG      363
-# define SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE            364
-# define SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH       232
-# define SSL_R_SSL3_EXT_INVALID_SERVERNAME                319
-# define SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE           320
-# define SSL_R_SSL3_SESSION_ID_TOO_LONG                   300
-# define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE                1042
-# define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC                 1020
-# define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED            1045
-# define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED            1044
-# define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN            1046
-# define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE          1030
-# define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE              1040
-# define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER              1047
-# define SSL_R_SSLV3_ALERT_NO_CERTIFICATE                 1041
-# define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE             1010
-# define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE        1043
-# define SSL_R_SSL_COMMAND_SECTION_EMPTY                  117
-# define SSL_R_SSL_COMMAND_SECTION_NOT_FOUND              125
-# define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION         228
-# define SSL_R_SSL_HANDSHAKE_FAILURE                      229
-# define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS                 230
-# define SSL_R_SSL_NEGATIVE_LENGTH                        372
-# define SSL_R_SSL_SECTION_EMPTY                          126
-# define SSL_R_SSL_SECTION_NOT_FOUND                      136
-# define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED             301
-# define SSL_R_SSL_SESSION_ID_CONFLICT                    302
-# define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG            273
-# define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH              303
-# define SSL_R_SSL_SESSION_ID_TOO_LONG                    408
-# define SSL_R_SSL_SESSION_VERSION_MISMATCH               210
-# define SSL_R_STILL_IN_INIT                              121
-# define SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED          1116
-# define SSL_R_TLSV13_ALERT_MISSING_EXTENSION             1109
-# define SSL_R_TLSV1_ALERT_ACCESS_DENIED                  1049
-# define SSL_R_TLSV1_ALERT_DECODE_ERROR                   1050
-# define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED              1021
-# define SSL_R_TLSV1_ALERT_DECRYPT_ERROR                  1051
-# define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION             1060
-# define SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK         1086
-# define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY          1071
-# define SSL_R_TLSV1_ALERT_INTERNAL_ERROR                 1080
-# define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION               1100
-# define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION               1070
-# define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW                1022
-# define SSL_R_TLSV1_ALERT_UNKNOWN_CA                     1048
-# define SSL_R_TLSV1_ALERT_USER_CANCELLED                 1090
-# define SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE           1114
-# define SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE      1113
-# define SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE             1111
-# define SSL_R_TLSV1_UNRECOGNIZED_NAME                    1112
-# define SSL_R_TLSV1_UNSUPPORTED_EXTENSION                1110
-# define SSL_R_TLS_ILLEGAL_EXPORTER_LABEL                 367
-# define SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST             157
-# define SSL_R_TOO_MANY_KEY_UPDATES                       132
-# define SSL_R_TOO_MANY_WARN_ALERTS                       409
-# define SSL_R_TOO_MUCH_EARLY_DATA                        164
-# define SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS             314
-# define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS       239
-# define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES           242
-# define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES          243
-# define SSL_R_UNEXPECTED_CCS_MESSAGE                     262
-# define SSL_R_UNEXPECTED_END_OF_EARLY_DATA               178
-# define SSL_R_UNEXPECTED_EOF_WHILE_READING               294
-# define SSL_R_UNEXPECTED_MESSAGE                         244
-# define SSL_R_UNEXPECTED_RECORD                          245
-# define SSL_R_UNINITIALIZED                              276
-# define SSL_R_UNKNOWN_ALERT_TYPE                         246
-# define SSL_R_UNKNOWN_CERTIFICATE_TYPE                   247
-# define SSL_R_UNKNOWN_CIPHER_RETURNED                    248
-# define SSL_R_UNKNOWN_CIPHER_TYPE                        249
-# define SSL_R_UNKNOWN_CMD_NAME                           386
-# define SSL_R_UNKNOWN_COMMAND                            139
-# define SSL_R_UNKNOWN_DIGEST                             368
-# define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE                  250
-# define SSL_R_UNKNOWN_PKEY_TYPE                          251
-# define SSL_R_UNKNOWN_PROTOCOL                           252
-# define SSL_R_UNKNOWN_SSL_VERSION                        254
-# define SSL_R_UNKNOWN_STATE                              255
-# define SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED       338
-# define SSL_R_UNSOLICITED_EXTENSION                      217
-# define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM          257
-# define SSL_R_UNSUPPORTED_ELLIPTIC_CURVE                 315
-# define SSL_R_UNSUPPORTED_PROTOCOL                       258
-# define SSL_R_UNSUPPORTED_SSL_VERSION                    259
-# define SSL_R_UNSUPPORTED_STATUS_TYPE                    329
-# define SSL_R_USE_SRTP_NOT_NEGOTIATED                    369
-# define SSL_R_VERSION_TOO_HIGH                           166
-# define SSL_R_VERSION_TOO_LOW                            396
-# define SSL_R_WRONG_CERTIFICATE_TYPE                     383
-# define SSL_R_WRONG_CIPHER_RETURNED                      261
-# define SSL_R_WRONG_CURVE                                378
-# define SSL_R_WRONG_SIGNATURE_LENGTH                     264
-# define SSL_R_WRONG_SIGNATURE_SIZE                       265
-# define SSL_R_WRONG_SIGNATURE_TYPE                       370
-# define SSL_R_WRONG_SSL_VERSION                          266
-# define SSL_R_WRONG_VERSION_NUMBER                       267
-# define SSL_R_X509_LIB                                   268
-# define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS           269
+#define SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY 291
+#define SSL_R_APP_DATA_IN_HANDSHAKE 100
+#define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 272
+#define SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE 158
+#define SSL_R_BAD_CHANGE_CIPHER_SPEC 103
+#define SSL_R_BAD_CIPHER 186
+#define SSL_R_BAD_DATA 390
+#define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK 106
+#define SSL_R_BAD_DECOMPRESSION 107
+#define SSL_R_BAD_DH_VALUE 102
+#define SSL_R_BAD_DIGEST_LENGTH 111
+#define SSL_R_BAD_EARLY_DATA 233
+#define SSL_R_BAD_ECC_CERT 304
+#define SSL_R_BAD_ECPOINT 306
+#define SSL_R_BAD_EXTENSION 110
+#define SSL_R_BAD_HANDSHAKE_LENGTH 332
+#define SSL_R_BAD_HANDSHAKE_STATE 236
+#define SSL_R_BAD_HELLO_REQUEST 105
+#define SSL_R_BAD_HRR_VERSION 263
+#define SSL_R_BAD_KEY_SHARE 108
+#define SSL_R_BAD_KEY_UPDATE 122
+#define SSL_R_BAD_LEGACY_VERSION 292
+#define SSL_R_BAD_LENGTH 271
+#define SSL_R_BAD_PACKET 240
+#define SSL_R_BAD_PACKET_LENGTH 115
+#define SSL_R_BAD_PROTOCOL_VERSION_NUMBER 116
+#define SSL_R_BAD_PSK 219
+#define SSL_R_BAD_PSK_IDENTITY 114
+#define SSL_R_BAD_RECORD_TYPE 443
+#define SSL_R_BAD_RSA_ENCRYPT 119
+#define SSL_R_BAD_SIGNATURE 123
+#define SSL_R_BAD_SRP_A_LENGTH 347
+#define SSL_R_BAD_SRP_PARAMETERS 371
+#define SSL_R_BAD_SRTP_MKI_VALUE 352
+#define SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST 353
+#define SSL_R_BAD_SSL_FILETYPE 124
+#define SSL_R_BAD_VALUE 384
+#define SSL_R_BAD_WRITE_RETRY 127
+#define SSL_R_BINDER_DOES_NOT_VERIFY 253
+#define SSL_R_BIO_NOT_SET 128
+#define SSL_R_BLOCK_CIPHER_PAD_IS_WRONG 129
+#define SSL_R_BN_LIB 130
+#define SSL_R_CALLBACK_FAILED 234
+#define SSL_R_CANNOT_CHANGE_CIPHER 109
+#define SSL_R_CANNOT_GET_GROUP_NAME 299
+#define SSL_R_CA_DN_LENGTH_MISMATCH 131
+#define SSL_R_CA_KEY_TOO_SMALL 397
+#define SSL_R_CA_MD_TOO_WEAK 398
+#define SSL_R_CCS_RECEIVED_EARLY 133
+#define SSL_R_CERTIFICATE_VERIFY_FAILED 134
+#define SSL_R_CERT_CB_ERROR 377
+#define SSL_R_CERT_LENGTH_MISMATCH 135
+#define SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED 218
+#define SSL_R_CIPHER_CODE_WRONG_LENGTH 137
+#define SSL_R_CLIENTHELLO_TLSEXT 226
+#define SSL_R_COMPRESSED_LENGTH_TOO_LONG 140
+#define SSL_R_COMPRESSION_DISABLED 343
+#define SSL_R_COMPRESSION_FAILURE 141
+#define SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE 307
+#define SSL_R_COMPRESSION_LIBRARY_ERROR 142
+#define SSL_R_CONNECTION_TYPE_NOT_SET 144
+#define SSL_R_CONTEXT_NOT_DANE_ENABLED 167
+#define SSL_R_COOKIE_GEN_CALLBACK_FAILURE 400
+#define SSL_R_COOKIE_MISMATCH 308
+#define SSL_R_COPY_PARAMETERS_FAILED 296
+#define SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED 206
+#define SSL_R_DANE_ALREADY_ENABLED 172
+#define SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL 173
+#define SSL_R_DANE_NOT_ENABLED 175
+#define SSL_R_DANE_TLSA_BAD_CERTIFICATE 180
+#define SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE 184
+#define SSL_R_DANE_TLSA_BAD_DATA_LENGTH 189
+#define SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH 192
+#define SSL_R_DANE_TLSA_BAD_MATCHING_TYPE 200
+#define SSL_R_DANE_TLSA_BAD_PUBLIC_KEY 201
+#define SSL_R_DANE_TLSA_BAD_SELECTOR 202
+#define SSL_R_DANE_TLSA_NULL_DATA 203
+#define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED 145
+#define SSL_R_DATA_LENGTH_TOO_LONG 146
+#define SSL_R_DECRYPTION_FAILED 147
+#define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC 281
+#define SSL_R_DH_KEY_TOO_SMALL 394
+#define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG 148
+#define SSL_R_DIGEST_CHECK_FAILED 149
+#define SSL_R_DTLS_MESSAGE_TOO_BIG 334
+#define SSL_R_DUPLICATE_COMPRESSION_ID 309
+#define SSL_R_ECC_CERT_NOT_FOR_SIGNING 318
+#define SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE 374
+#define SSL_R_EE_KEY_TOO_SMALL 399
+#define SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST 354
+#define SSL_R_ENCRYPTED_LENGTH_TOO_LONG 150
+#define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST 151
+#define SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN 204
+#define SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE 194
+#define SSL_R_EXCESSIVE_MESSAGE_SIZE 152
+#define SSL_R_EXTENSION_NOT_RECEIVED 279
+#define SSL_R_EXTRA_DATA_IN_MESSAGE 153
+#define SSL_R_EXT_LENGTH_MISMATCH 163
+#define SSL_R_FAILED_TO_INIT_ASYNC 405
+#define SSL_R_FRAGMENTED_CLIENT_HELLO 401
+#define SSL_R_GOT_A_FIN_BEFORE_A_CCS 154
+#define SSL_R_HTTPS_PROXY_REQUEST 155
+#define SSL_R_HTTP_REQUEST 156
+#define SSL_R_ILLEGAL_POINT_COMPRESSION 162
+#define SSL_R_ILLEGAL_SUITEB_DIGEST 380
+#define SSL_R_INAPPROPRIATE_FALLBACK 373
+#define SSL_R_INCONSISTENT_COMPRESSION 340
+#define SSL_R_INCONSISTENT_EARLY_DATA_ALPN 222
+#define SSL_R_INCONSISTENT_EARLY_DATA_SNI 231
+#define SSL_R_INCONSISTENT_EXTMS 104
+#define SSL_R_INSUFFICIENT_SECURITY 241
+#define SSL_R_INVALID_ALERT 205
+#define SSL_R_INVALID_CCS_MESSAGE 260
+#define SSL_R_INVALID_CERTIFICATE_OR_ALG 238
+#define SSL_R_INVALID_COMMAND 280
+#define SSL_R_INVALID_COMPRESSION_ALGORITHM 341
+#define SSL_R_INVALID_CONFIG 283
+#define SSL_R_INVALID_CONFIGURATION_NAME 113
+#define SSL_R_INVALID_CONTEXT 282
+#define SSL_R_INVALID_CT_VALIDATION_TYPE 212
+#define SSL_R_INVALID_KEY_UPDATE_TYPE 120
+#define SSL_R_INVALID_MAX_EARLY_DATA 174
+#define SSL_R_INVALID_NULL_CMD_NAME 385
+#define SSL_R_INVALID_SEQUENCE_NUMBER 402
+#define SSL_R_INVALID_SERVERINFO_DATA 388
+#define SSL_R_INVALID_SESSION_ID 999
+#define SSL_R_INVALID_SRP_USERNAME 357
+#define SSL_R_INVALID_STATUS_RESPONSE 328
+#define SSL_R_INVALID_TICKET_KEYS_LENGTH 325
+#define SSL_R_LENGTH_MISMATCH 159
+#define SSL_R_LENGTH_TOO_LONG 404
+#define SSL_R_LENGTH_TOO_SHORT 160
+#define SSL_R_LIBRARY_BUG 274
+#define SSL_R_LIBRARY_HAS_NO_CIPHERS 161
+#define SSL_R_MISSING_DSA_SIGNING_CERT 165
+#define SSL_R_MISSING_ECDSA_SIGNING_CERT 381
+#define SSL_R_MISSING_FATAL 256
+#define SSL_R_MISSING_PARAMETERS 290
+#define SSL_R_MISSING_PSK_KEX_MODES_EXTENSION 310
+#define SSL_R_MISSING_RSA_CERTIFICATE 168
+#define SSL_R_MISSING_RSA_ENCRYPTING_CERT 169
+#define SSL_R_MISSING_RSA_SIGNING_CERT 170
+#define SSL_R_MISSING_SIGALGS_EXTENSION 112
+#define SSL_R_MISSING_SIGNING_CERT 221
+#define SSL_R_MISSING_SRP_PARAM 358
+#define SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION 209
+#define SSL_R_MISSING_TMP_DH_KEY 171
+#define SSL_R_MISSING_TMP_ECDH_KEY 311
+#define SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA 293
+#define SSL_R_NOT_ON_RECORD_BOUNDARY 182
+#define SSL_R_NOT_REPLACING_CERTIFICATE 289
+#define SSL_R_NOT_SERVER 284
+#define SSL_R_NO_APPLICATION_PROTOCOL 235
+#define SSL_R_NO_CERTIFICATES_RETURNED 176
+#define SSL_R_NO_CERTIFICATE_ASSIGNED 177
+#define SSL_R_NO_CERTIFICATE_SET 179
+#define SSL_R_NO_CHANGE_FOLLOWING_HRR 214
+#define SSL_R_NO_CIPHERS_AVAILABLE 181
+#define SSL_R_NO_CIPHERS_SPECIFIED 183
+#define SSL_R_NO_CIPHER_MATCH 185
+#define SSL_R_NO_CLIENT_CERT_METHOD 331
+#define SSL_R_NO_COMPRESSION_SPECIFIED 187
+#define SSL_R_NO_COOKIE_CALLBACK_SET 287
+#define SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER 330
+#define SSL_R_NO_METHOD_SPECIFIED 188
+#define SSL_R_NO_PEM_EXTENSIONS 389
+#define SSL_R_NO_PRIVATE_KEY_ASSIGNED 190
+#define SSL_R_NO_PROTOCOLS_AVAILABLE 191
+#define SSL_R_NO_RENEGOTIATION 339
+#define SSL_R_NO_REQUIRED_DIGEST 324
+#define SSL_R_NO_SHARED_CIPHER 193
+#define SSL_R_NO_SHARED_GROUPS 410
+#define SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS 376
+#define SSL_R_NO_SRTP_PROFILES 359
+#define SSL_R_NO_SUITABLE_DIGEST_ALGORITHM 297
+#define SSL_R_NO_SUITABLE_GROUPS 295
+#define SSL_R_NO_SUITABLE_KEY_SHARE 101
+#define SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM 118
+#define SSL_R_NO_VALID_SCTS 216
+#define SSL_R_NO_VERIFY_COOKIE_CALLBACK 403
+#define SSL_R_NULL_SSL_CTX 195
+#define SSL_R_NULL_SSL_METHOD_PASSED 196
+#define SSL_R_OCSP_CALLBACK_FAILURE 305
+#define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED 197
+#define SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED 344
+#define SSL_R_OVERFLOW_ERROR 237
+#define SSL_R_PACKET_LENGTH_TOO_LONG 198
+#define SSL_R_PARSE_TLSEXT 227
+#define SSL_R_PATH_TOO_LONG 270
+#define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE 199
+#define SSL_R_PEM_NAME_BAD_PREFIX 391
+#define SSL_R_PEM_NAME_TOO_SHORT 392
+#define SSL_R_PIPELINE_FAILURE 406
+#define SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR 278
+#define SSL_R_PRIVATE_KEY_MISMATCH 288
+#define SSL_R_PROTOCOL_IS_SHUTDOWN 207
+#define SSL_R_PSK_IDENTITY_NOT_FOUND 223
+#define SSL_R_PSK_NO_CLIENT_CB 224
+#define SSL_R_PSK_NO_SERVER_CB 225
+#define SSL_R_READ_BIO_NOT_SET 211
+#define SSL_R_READ_TIMEOUT_EXPIRED 312
+#define SSL_R_RECORD_LENGTH_MISMATCH 213
+#define SSL_R_RECORD_TOO_SMALL 298
+#define SSL_R_RENEGOTIATE_EXT_TOO_LONG 335
+#define SSL_R_RENEGOTIATION_ENCODING_ERR 336
+#define SSL_R_RENEGOTIATION_MISMATCH 337
+#define SSL_R_REQUEST_PENDING 285
+#define SSL_R_REQUEST_SENT 286
+#define SSL_R_REQUIRED_CIPHER_MISSING 215
+#define SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING 342
+#define SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING 345
+#define SSL_R_SCT_VERIFICATION_FAILED 208
+#define SSL_R_SERVERHELLO_TLSEXT 275
+#define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED 277
+#define SSL_R_SHUTDOWN_WHILE_IN_INIT 407
+#define SSL_R_SIGNATURE_ALGORITHMS_ERROR 360
+#define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE 220
+#define SSL_R_SRP_A_CALC 361
+#define SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES 362
+#define SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG 363
+#define SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE 364
+#define SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH 232
+#define SSL_R_SSL3_EXT_INVALID_SERVERNAME 319
+#define SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE 320
+#define SSL_R_SSL3_SESSION_ID_TOO_LONG 300
+#define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE 1042
+#define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC 1020
+#define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED 1045
+#define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED 1044
+#define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN 1046
+#define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE 1030
+#define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE 1040
+#define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER 1047
+#define SSL_R_SSLV3_ALERT_NO_CERTIFICATE 1041
+#define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE 1010
+#define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE 1043
+#define SSL_R_SSL_COMMAND_SECTION_EMPTY 117
+#define SSL_R_SSL_COMMAND_SECTION_NOT_FOUND 125
+#define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION 228
+#define SSL_R_SSL_HANDSHAKE_FAILURE 229
+#define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS 230
+#define SSL_R_SSL_NEGATIVE_LENGTH 372
+#define SSL_R_SSL_SECTION_EMPTY 126
+#define SSL_R_SSL_SECTION_NOT_FOUND 136
+#define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED 301
+#define SSL_R_SSL_SESSION_ID_CONFLICT 302
+#define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG 273
+#define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH 303
+#define SSL_R_SSL_SESSION_ID_TOO_LONG 408
+#define SSL_R_SSL_SESSION_VERSION_MISMATCH 210
+#define SSL_R_STILL_IN_INIT 121
+#define SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED 1116
+#define SSL_R_TLSV13_ALERT_MISSING_EXTENSION 1109
+#define SSL_R_TLSV1_ALERT_ACCESS_DENIED 1049
+#define SSL_R_TLSV1_ALERT_DECODE_ERROR 1050
+#define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED 1021
+#define SSL_R_TLSV1_ALERT_DECRYPT_ERROR 1051
+#define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION 1060
+#define SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK 1086
+#define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY 1071
+#define SSL_R_TLSV1_ALERT_INTERNAL_ERROR 1080
+#define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION 1100
+#define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION 1070
+#define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW 1022
+#define SSL_R_TLSV1_ALERT_UNKNOWN_CA 1048
+#define SSL_R_TLSV1_ALERT_USER_CANCELLED 1090
+#define SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE 1114
+#define SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE 1113
+#define SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE 1111
+#define SSL_R_TLSV1_UNRECOGNIZED_NAME 1112
+#define SSL_R_TLSV1_UNSUPPORTED_EXTENSION 1110
+#define SSL_R_TLS_ILLEGAL_EXPORTER_LABEL 367
+#define SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST 157
+#define SSL_R_TOO_MANY_KEY_UPDATES 132
+#define SSL_R_TOO_MANY_WARN_ALERTS 409
+#define SSL_R_TOO_MUCH_EARLY_DATA 164
+#define SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS 314
+#define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS 239
+#define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES 242
+#define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES 243
+#define SSL_R_UNEXPECTED_CCS_MESSAGE 262
+#define SSL_R_UNEXPECTED_END_OF_EARLY_DATA 178
+#define SSL_R_UNEXPECTED_EOF_WHILE_READING 294
+#define SSL_R_UNEXPECTED_MESSAGE 244
+#define SSL_R_UNEXPECTED_RECORD 245
+#define SSL_R_UNINITIALIZED 276
+#define SSL_R_UNKNOWN_ALERT_TYPE 246
+#define SSL_R_UNKNOWN_CERTIFICATE_TYPE 247
+#define SSL_R_UNKNOWN_CIPHER_RETURNED 248
+#define SSL_R_UNKNOWN_CIPHER_TYPE 249
+#define SSL_R_UNKNOWN_CMD_NAME 386
+#define SSL_R_UNKNOWN_COMMAND 139
+#define SSL_R_UNKNOWN_DIGEST 368
+#define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE 250
+#define SSL_R_UNKNOWN_PKEY_TYPE 251
+#define SSL_R_UNKNOWN_PROTOCOL 252
+#define SSL_R_UNKNOWN_SSL_VERSION 254
+#define SSL_R_UNKNOWN_STATE 255
+#define SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED 338
+#define SSL_R_UNSOLICITED_EXTENSION 217
+#define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM 257
+#define SSL_R_UNSUPPORTED_ELLIPTIC_CURVE 315
+#define SSL_R_UNSUPPORTED_PROTOCOL 258
+#define SSL_R_UNSUPPORTED_SSL_VERSION 259
+#define SSL_R_UNSUPPORTED_STATUS_TYPE 329
+#define SSL_R_USE_SRTP_NOT_NEGOTIATED 369
+#define SSL_R_VERSION_TOO_HIGH 166
+#define SSL_R_VERSION_TOO_LOW 396
+#define SSL_R_WRONG_CERTIFICATE_TYPE 383
+#define SSL_R_WRONG_CIPHER_RETURNED 261
+#define SSL_R_WRONG_CURVE 378
+#define SSL_R_WRONG_SIGNATURE_LENGTH 264
+#define SSL_R_WRONG_SIGNATURE_SIZE 265
+#define SSL_R_WRONG_SIGNATURE_TYPE 370
+#define SSL_R_WRONG_SSL_VERSION 266
+#define SSL_R_WRONG_VERSION_NUMBER 267
+#define SSL_R_X509_LIB 268
+#define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS 269
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/sslerr_legacy.h b/CAPI/cpp/grpc/include/openssl/sslerr_legacy.h
index ccf6d3b..b831ae0 100644
--- a/CAPI/cpp/grpc/include/openssl/sslerr_legacy.h
+++ b/CAPI/cpp/grpc/include/openssl/sslerr_legacy.h
@@ -15,454 +15,455 @@
  */
 
 #ifndef OPENSSL_SSLERR_LEGACY_H
-# define OPENSSL_SSLERR_LEGACY_H
-# pragma once
+#define OPENSSL_SSLERR_LEGACY_H
+#pragma once
 
-# include <openssl/macros.h>
-# include <openssl/symhacks.h>
+#include <openssl/macros.h>
+#include <openssl/symhacks.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int ERR_load_SSL_strings(void);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int ERR_load_SSL_strings(void);
 
 /* Collected _F_ macros from OpenSSL 1.1.1 */
 
 /*
  * SSL function codes.
  */
-#  define SSL_F_ADD_CLIENT_KEY_SHARE_EXT                   0
-#  define SSL_F_ADD_KEY_SHARE                              0
-#  define SSL_F_BYTES_TO_CIPHER_LIST                       0
-#  define SSL_F_CHECK_SUITEB_CIPHER_LIST                   0
-#  define SSL_F_CIPHERSUITE_CB                             0
-#  define SSL_F_CONSTRUCT_CA_NAMES                         0
-#  define SSL_F_CONSTRUCT_KEY_EXCHANGE_TBS                 0
-#  define SSL_F_CONSTRUCT_STATEFUL_TICKET                  0
-#  define SSL_F_CONSTRUCT_STATELESS_TICKET                 0
-#  define SSL_F_CREATE_SYNTHETIC_MESSAGE_HASH              0
-#  define SSL_F_CREATE_TICKET_PREQUEL                      0
-#  define SSL_F_CT_MOVE_SCTS                               0
-#  define SSL_F_CT_STRICT                                  0
-#  define SSL_F_CUSTOM_EXT_ADD                             0
-#  define SSL_F_CUSTOM_EXT_PARSE                           0
-#  define SSL_F_D2I_SSL_SESSION                            0
-#  define SSL_F_DANE_CTX_ENABLE                            0
-#  define SSL_F_DANE_MTYPE_SET                             0
-#  define SSL_F_DANE_TLSA_ADD                              0
-#  define SSL_F_DERIVE_SECRET_KEY_AND_IV                   0
-#  define SSL_F_DO_DTLS1_WRITE                             0
-#  define SSL_F_DO_SSL3_WRITE                              0
-#  define SSL_F_DTLS1_BUFFER_RECORD                        0
-#  define SSL_F_DTLS1_CHECK_TIMEOUT_NUM                    0
-#  define SSL_F_DTLS1_HEARTBEAT                            0
-#  define SSL_F_DTLS1_HM_FRAGMENT_NEW                      0
-#  define SSL_F_DTLS1_PREPROCESS_FRAGMENT                  0
-#  define SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS             0
-#  define SSL_F_DTLS1_PROCESS_RECORD                       0
-#  define SSL_F_DTLS1_READ_BYTES                           0
-#  define SSL_F_DTLS1_READ_FAILED                          0
-#  define SSL_F_DTLS1_RETRANSMIT_MESSAGE                   0
-#  define SSL_F_DTLS1_WRITE_APP_DATA_BYTES                 0
-#  define SSL_F_DTLS1_WRITE_BYTES                          0
-#  define SSL_F_DTLSV1_LISTEN                              0
-#  define SSL_F_DTLS_CONSTRUCT_CHANGE_CIPHER_SPEC          0
-#  define SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST        0
-#  define SSL_F_DTLS_GET_REASSEMBLED_MESSAGE               0
-#  define SSL_F_DTLS_PROCESS_HELLO_VERIFY                  0
-#  define SSL_F_DTLS_RECORD_LAYER_NEW                      0
-#  define SSL_F_DTLS_WAIT_FOR_DRY                          0
-#  define SSL_F_EARLY_DATA_COUNT_OK                        0
-#  define SSL_F_FINAL_EARLY_DATA                           0
-#  define SSL_F_FINAL_EC_PT_FORMATS                        0
-#  define SSL_F_FINAL_EMS                                  0
-#  define SSL_F_FINAL_KEY_SHARE                            0
-#  define SSL_F_FINAL_MAXFRAGMENTLEN                       0
-#  define SSL_F_FINAL_RENEGOTIATE                          0
-#  define SSL_F_FINAL_SERVER_NAME                          0
-#  define SSL_F_FINAL_SIG_ALGS                             0
-#  define SSL_F_GET_CERT_VERIFY_TBS_DATA                   0
-#  define SSL_F_NSS_KEYLOG_INT                             0
-#  define SSL_F_OPENSSL_INIT_SSL                           0
-#  define SSL_F_OSSL_STATEM_CLIENT13_READ_TRANSITION       0
-#  define SSL_F_OSSL_STATEM_CLIENT13_WRITE_TRANSITION      0
-#  define SSL_F_OSSL_STATEM_CLIENT_CONSTRUCT_MESSAGE       0
-#  define SSL_F_OSSL_STATEM_CLIENT_POST_PROCESS_MESSAGE    0
-#  define SSL_F_OSSL_STATEM_CLIENT_PROCESS_MESSAGE         0
-#  define SSL_F_OSSL_STATEM_CLIENT_READ_TRANSITION         0
-#  define SSL_F_OSSL_STATEM_CLIENT_WRITE_TRANSITION        0
-#  define SSL_F_OSSL_STATEM_SERVER13_READ_TRANSITION       0
-#  define SSL_F_OSSL_STATEM_SERVER13_WRITE_TRANSITION      0
-#  define SSL_F_OSSL_STATEM_SERVER_CONSTRUCT_MESSAGE       0
-#  define SSL_F_OSSL_STATEM_SERVER_POST_PROCESS_MESSAGE    0
-#  define SSL_F_OSSL_STATEM_SERVER_POST_WORK               0
-#  define SSL_F_OSSL_STATEM_SERVER_PRE_WORK                0
-#  define SSL_F_OSSL_STATEM_SERVER_PROCESS_MESSAGE         0
-#  define SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION         0
-#  define SSL_F_OSSL_STATEM_SERVER_WRITE_TRANSITION        0
-#  define SSL_F_PARSE_CA_NAMES                             0
-#  define SSL_F_PITEM_NEW                                  0
-#  define SSL_F_PQUEUE_NEW                                 0
-#  define SSL_F_PROCESS_KEY_SHARE_EXT                      0
-#  define SSL_F_READ_STATE_MACHINE                         0
-#  define SSL_F_SET_CLIENT_CIPHERSUITE                     0
-#  define SSL_F_SRP_GENERATE_CLIENT_MASTER_SECRET          0
-#  define SSL_F_SRP_GENERATE_SERVER_MASTER_SECRET          0
-#  define SSL_F_SRP_VERIFY_SERVER_PARAM                    0
-#  define SSL_F_SSL3_CHANGE_CIPHER_STATE                   0
-#  define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM              0
-#  define SSL_F_SSL3_CTRL                                  0
-#  define SSL_F_SSL3_CTX_CTRL                              0
-#  define SSL_F_SSL3_DIGEST_CACHED_RECORDS                 0
-#  define SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC                 0
-#  define SSL_F_SSL3_ENC                                   0
-#  define SSL_F_SSL3_FINAL_FINISH_MAC                      0
-#  define SSL_F_SSL3_FINISH_MAC                            0
-#  define SSL_F_SSL3_GENERATE_KEY_BLOCK                    0
-#  define SSL_F_SSL3_GENERATE_MASTER_SECRET                0
-#  define SSL_F_SSL3_GET_RECORD                            0
-#  define SSL_F_SSL3_INIT_FINISHED_MAC                     0
-#  define SSL_F_SSL3_OUTPUT_CERT_CHAIN                     0
-#  define SSL_F_SSL3_READ_BYTES                            0
-#  define SSL_F_SSL3_READ_N                                0
-#  define SSL_F_SSL3_SETUP_KEY_BLOCK                       0
-#  define SSL_F_SSL3_SETUP_READ_BUFFER                     0
-#  define SSL_F_SSL3_SETUP_WRITE_BUFFER                    0
-#  define SSL_F_SSL3_WRITE_BYTES                           0
-#  define SSL_F_SSL3_WRITE_PENDING                         0
-#  define SSL_F_SSL_ADD_CERT_CHAIN                         0
-#  define SSL_F_SSL_ADD_CERT_TO_BUF                        0
-#  define SSL_F_SSL_ADD_CERT_TO_WPACKET                    0
-#  define SSL_F_SSL_ADD_CLIENTHELLO_RENEGOTIATE_EXT        0
-#  define SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT                 0
-#  define SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT           0
-#  define SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK         0
-#  define SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK        0
-#  define SSL_F_SSL_ADD_SERVERHELLO_RENEGOTIATE_EXT        0
-#  define SSL_F_SSL_ADD_SERVERHELLO_TLSEXT                 0
-#  define SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT           0
-#  define SSL_F_SSL_BAD_METHOD                             0
-#  define SSL_F_SSL_BUILD_CERT_CHAIN                       0
-#  define SSL_F_SSL_BYTES_TO_CIPHER_LIST                   0
-#  define SSL_F_SSL_CACHE_CIPHERLIST                       0
-#  define SSL_F_SSL_CERT_ADD0_CHAIN_CERT                   0
-#  define SSL_F_SSL_CERT_DUP                               0
-#  define SSL_F_SSL_CERT_NEW                               0
-#  define SSL_F_SSL_CERT_SET0_CHAIN                        0
-#  define SSL_F_SSL_CHECK_PRIVATE_KEY                      0
-#  define SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT               0
-#  define SSL_F_SSL_CHECK_SRP_EXT_CLIENTHELLO              0
-#  define SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG            0
-#  define SSL_F_SSL_CHOOSE_CLIENT_VERSION                  0
-#  define SSL_F_SSL_CIPHER_DESCRIPTION                     0
-#  define SSL_F_SSL_CIPHER_LIST_TO_BYTES                   0
-#  define SSL_F_SSL_CIPHER_PROCESS_RULESTR                 0
-#  define SSL_F_SSL_CIPHER_STRENGTH_SORT                   0
-#  define SSL_F_SSL_CLEAR                                  0
-#  define SSL_F_SSL_CLIENT_HELLO_GET1_EXTENSIONS_PRESENT   0
-#  define SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD            0
-#  define SSL_F_SSL_CONF_CMD                               0
-#  define SSL_F_SSL_CREATE_CIPHER_LIST                     0
-#  define SSL_F_SSL_CTRL                                   0
-#  define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY                  0
-#  define SSL_F_SSL_CTX_ENABLE_CT                          0
-#  define SSL_F_SSL_CTX_MAKE_PROFILES                      0
-#  define SSL_F_SSL_CTX_NEW                                0
-#  define SSL_F_SSL_CTX_SET_ALPN_PROTOS                    0
-#  define SSL_F_SSL_CTX_SET_CIPHER_LIST                    0
-#  define SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE             0
-#  define SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK         0
-#  define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT             0
-#  define SSL_F_SSL_CTX_SET_SSL_VERSION                    0
-#  define SSL_F_SSL_CTX_SET_TLSEXT_MAX_FRAGMENT_LENGTH     0
-#  define SSL_F_SSL_CTX_USE_CERTIFICATE                    0
-#  define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1               0
-#  define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE               0
-#  define SSL_F_SSL_CTX_USE_PRIVATEKEY                     0
-#  define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1                0
-#  define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE                0
-#  define SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT              0
-#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY                  0
-#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1             0
-#  define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE             0
-#  define SSL_F_SSL_CTX_USE_SERVERINFO                     0
-#  define SSL_F_SSL_CTX_USE_SERVERINFO_EX                  0
-#  define SSL_F_SSL_CTX_USE_SERVERINFO_FILE                0
-#  define SSL_F_SSL_DANE_DUP                               0
-#  define SSL_F_SSL_DANE_ENABLE                            0
-#  define SSL_F_SSL_DERIVE                                 0
-#  define SSL_F_SSL_DO_CONFIG                              0
-#  define SSL_F_SSL_DO_HANDSHAKE                           0
-#  define SSL_F_SSL_DUP_CA_LIST                            0
-#  define SSL_F_SSL_ENABLE_CT                              0
-#  define SSL_F_SSL_GENERATE_PKEY_GROUP                    0
-#  define SSL_F_SSL_GENERATE_SESSION_ID                    0
-#  define SSL_F_SSL_GET_NEW_SESSION                        0
-#  define SSL_F_SSL_GET_PREV_SESSION                       0
-#  define SSL_F_SSL_GET_SERVER_CERT_INDEX                  0
-#  define SSL_F_SSL_GET_SIGN_PKEY                          0
-#  define SSL_F_SSL_HANDSHAKE_HASH                         0
-#  define SSL_F_SSL_INIT_WBIO_BUFFER                       0
-#  define SSL_F_SSL_KEY_UPDATE                             0
-#  define SSL_F_SSL_LOAD_CLIENT_CA_FILE                    0
-#  define SSL_F_SSL_LOG_MASTER_SECRET                      0
-#  define SSL_F_SSL_LOG_RSA_CLIENT_KEY_EXCHANGE            0
-#  define SSL_F_SSL_MODULE_INIT                            0
-#  define SSL_F_SSL_NEW                                    0
-#  define SSL_F_SSL_NEXT_PROTO_VALIDATE                    0
-#  define SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT      0
-#  define SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT               0
-#  define SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT         0
-#  define SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT      0
-#  define SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT               0
-#  define SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT         0
-#  define SSL_F_SSL_PEEK                                   0
-#  define SSL_F_SSL_PEEK_EX                                0
-#  define SSL_F_SSL_PEEK_INTERNAL                          0
-#  define SSL_F_SSL_READ                                   0
-#  define SSL_F_SSL_READ_EARLY_DATA                        0
-#  define SSL_F_SSL_READ_EX                                0
-#  define SSL_F_SSL_READ_INTERNAL                          0
-#  define SSL_F_SSL_RENEGOTIATE                            0
-#  define SSL_F_SSL_RENEGOTIATE_ABBREVIATED                0
-#  define SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT                0
-#  define SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT                0
-#  define SSL_F_SSL_SESSION_DUP                            0
-#  define SSL_F_SSL_SESSION_NEW                            0
-#  define SSL_F_SSL_SESSION_PRINT_FP                       0
-#  define SSL_F_SSL_SESSION_SET1_ID                        0
-#  define SSL_F_SSL_SESSION_SET1_ID_CONTEXT                0
-#  define SSL_F_SSL_SET_ALPN_PROTOS                        0
-#  define SSL_F_SSL_SET_CERT                               0
-#  define SSL_F_SSL_SET_CERT_AND_KEY                       0
-#  define SSL_F_SSL_SET_CIPHER_LIST                        0
-#  define SSL_F_SSL_SET_CT_VALIDATION_CALLBACK             0
-#  define SSL_F_SSL_SET_FD                                 0
-#  define SSL_F_SSL_SET_PKEY                               0
-#  define SSL_F_SSL_SET_RFD                                0
-#  define SSL_F_SSL_SET_SESSION                            0
-#  define SSL_F_SSL_SET_SESSION_ID_CONTEXT                 0
-#  define SSL_F_SSL_SET_SESSION_TICKET_EXT                 0
-#  define SSL_F_SSL_SET_TLSEXT_MAX_FRAGMENT_LENGTH         0
-#  define SSL_F_SSL_SET_WFD                                0
-#  define SSL_F_SSL_SHUTDOWN                               0
-#  define SSL_F_SSL_SRP_CTX_INIT                           0
-#  define SSL_F_SSL_START_ASYNC_JOB                        0
-#  define SSL_F_SSL_UNDEFINED_FUNCTION                     0
-#  define SSL_F_SSL_UNDEFINED_VOID_FUNCTION                0
-#  define SSL_F_SSL_USE_CERTIFICATE                        0
-#  define SSL_F_SSL_USE_CERTIFICATE_ASN1                   0
-#  define SSL_F_SSL_USE_CERTIFICATE_FILE                   0
-#  define SSL_F_SSL_USE_PRIVATEKEY                         0
-#  define SSL_F_SSL_USE_PRIVATEKEY_ASN1                    0
-#  define SSL_F_SSL_USE_PRIVATEKEY_FILE                    0
-#  define SSL_F_SSL_USE_PSK_IDENTITY_HINT                  0
-#  define SSL_F_SSL_USE_RSAPRIVATEKEY                      0
-#  define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1                 0
-#  define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE                 0
-#  define SSL_F_SSL_VALIDATE_CT                            0
-#  define SSL_F_SSL_VERIFY_CERT_CHAIN                      0
-#  define SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE           0
-#  define SSL_F_SSL_WRITE                                  0
-#  define SSL_F_SSL_WRITE_EARLY_DATA                       0
-#  define SSL_F_SSL_WRITE_EARLY_FINISH                     0
-#  define SSL_F_SSL_WRITE_EX                               0
-#  define SSL_F_SSL_WRITE_INTERNAL                         0
-#  define SSL_F_STATE_MACHINE                              0
-#  define SSL_F_TLS12_CHECK_PEER_SIGALG                    0
-#  define SSL_F_TLS12_COPY_SIGALGS                         0
-#  define SSL_F_TLS13_CHANGE_CIPHER_STATE                  0
-#  define SSL_F_TLS13_ENC                                  0
-#  define SSL_F_TLS13_FINAL_FINISH_MAC                     0
-#  define SSL_F_TLS13_GENERATE_SECRET                      0
-#  define SSL_F_TLS13_HKDF_EXPAND                          0
-#  define SSL_F_TLS13_RESTORE_HANDSHAKE_DIGEST_FOR_PHA     0
-#  define SSL_F_TLS13_SAVE_HANDSHAKE_DIGEST_FOR_PHA        0
-#  define SSL_F_TLS13_SETUP_KEY_BLOCK                      0
-#  define SSL_F_TLS1_CHANGE_CIPHER_STATE                   0
-#  define SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS            0
-#  define SSL_F_TLS1_ENC                                   0
-#  define SSL_F_TLS1_EXPORT_KEYING_MATERIAL                0
-#  define SSL_F_TLS1_GET_CURVELIST                         0
-#  define SSL_F_TLS1_PRF                                   0
-#  define SSL_F_TLS1_SAVE_U16                              0
-#  define SSL_F_TLS1_SETUP_KEY_BLOCK                       0
-#  define SSL_F_TLS1_SET_GROUPS                            0
-#  define SSL_F_TLS1_SET_RAW_SIGALGS                       0
-#  define SSL_F_TLS1_SET_SERVER_SIGALGS                    0
-#  define SSL_F_TLS1_SET_SHARED_SIGALGS                    0
-#  define SSL_F_TLS1_SET_SIGALGS                           0
-#  define SSL_F_TLS_CHOOSE_SIGALG                          0
-#  define SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK          0
-#  define SSL_F_TLS_COLLECT_EXTENSIONS                     0
-#  define SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES      0
-#  define SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST          0
-#  define SSL_F_TLS_CONSTRUCT_CERT_STATUS                  0
-#  define SSL_F_TLS_CONSTRUCT_CERT_STATUS_BODY             0
-#  define SSL_F_TLS_CONSTRUCT_CERT_VERIFY                  0
-#  define SSL_F_TLS_CONSTRUCT_CHANGE_CIPHER_SPEC           0
-#  define SSL_F_TLS_CONSTRUCT_CKE_DHE                      0
-#  define SSL_F_TLS_CONSTRUCT_CKE_ECDHE                    0
-#  define SSL_F_TLS_CONSTRUCT_CKE_GOST                     0
-#  define SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE             0
-#  define SSL_F_TLS_CONSTRUCT_CKE_RSA                      0
-#  define SSL_F_TLS_CONSTRUCT_CKE_SRP                      0
-#  define SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE           0
-#  define SSL_F_TLS_CONSTRUCT_CLIENT_HELLO                 0
-#  define SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE          0
-#  define SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY                0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_ALPN                    0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_CERTIFICATE             0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_COOKIE                  0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA              0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_EC_PT_FORMATS           0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_EMS                     0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_ETM                     0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_HELLO                   0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_KEY_EXCHANGE            0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE               0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_MAXFRAGMENTLEN          0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_NPN                     0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_PADDING                 0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_POST_HANDSHAKE_AUTH     0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_PSK                     0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_PSK_KEX_MODES           0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_RENEGOTIATE             0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_SCT                     0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_SERVER_NAME             0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET          0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_SIG_ALGS                0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_SRP                     0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST          0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS        0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS      0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP                0
-#  define SSL_F_TLS_CONSTRUCT_CTOS_VERIFY                  0
-#  define SSL_F_TLS_CONSTRUCT_ENCRYPTED_EXTENSIONS         0
-#  define SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA            0
-#  define SSL_F_TLS_CONSTRUCT_EXTENSIONS                   0
-#  define SSL_F_TLS_CONSTRUCT_FINISHED                     0
-#  define SSL_F_TLS_CONSTRUCT_HELLO_REQUEST                0
-#  define SSL_F_TLS_CONSTRUCT_HELLO_RETRY_REQUEST          0
-#  define SSL_F_TLS_CONSTRUCT_KEY_UPDATE                   0
-#  define SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET           0
-#  define SSL_F_TLS_CONSTRUCT_NEXT_PROTO                   0
-#  define SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE           0
-#  define SSL_F_TLS_CONSTRUCT_SERVER_HELLO                 0
-#  define SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE          0
-#  define SSL_F_TLS_CONSTRUCT_STOC_ALPN                    0
-#  define SSL_F_TLS_CONSTRUCT_STOC_CERTIFICATE             0
-#  define SSL_F_TLS_CONSTRUCT_STOC_COOKIE                  0
-#  define SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG           0
-#  define SSL_F_TLS_CONSTRUCT_STOC_DONE                    0
-#  define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA              0
-#  define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA_INFO         0
-#  define SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS           0
-#  define SSL_F_TLS_CONSTRUCT_STOC_EMS                     0
-#  define SSL_F_TLS_CONSTRUCT_STOC_ETM                     0
-#  define SSL_F_TLS_CONSTRUCT_STOC_HELLO                   0
-#  define SSL_F_TLS_CONSTRUCT_STOC_KEY_EXCHANGE            0
-#  define SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE               0
-#  define SSL_F_TLS_CONSTRUCT_STOC_MAXFRAGMENTLEN          0
-#  define SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG          0
-#  define SSL_F_TLS_CONSTRUCT_STOC_PSK                     0
-#  define SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE             0
-#  define SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME             0
-#  define SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET          0
-#  define SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST          0
-#  define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS        0
-#  define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_VERSIONS      0
-#  define SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP                0
-#  define SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO        0
-#  define SSL_F_TLS_FINISH_HANDSHAKE                       0
-#  define SSL_F_TLS_GET_MESSAGE_BODY                       0
-#  define SSL_F_TLS_GET_MESSAGE_HEADER                     0
-#  define SSL_F_TLS_HANDLE_ALPN                            0
-#  define SSL_F_TLS_HANDLE_STATUS_REQUEST                  0
-#  define SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES          0
-#  define SSL_F_TLS_PARSE_CLIENTHELLO_TLSEXT               0
-#  define SSL_F_TLS_PARSE_CTOS_ALPN                        0
-#  define SSL_F_TLS_PARSE_CTOS_COOKIE                      0
-#  define SSL_F_TLS_PARSE_CTOS_EARLY_DATA                  0
-#  define SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS               0
-#  define SSL_F_TLS_PARSE_CTOS_EMS                         0
-#  define SSL_F_TLS_PARSE_CTOS_KEY_SHARE                   0
-#  define SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN              0
-#  define SSL_F_TLS_PARSE_CTOS_POST_HANDSHAKE_AUTH         0
-#  define SSL_F_TLS_PARSE_CTOS_PSK                         0
-#  define SSL_F_TLS_PARSE_CTOS_PSK_KEX_MODES               0
-#  define SSL_F_TLS_PARSE_CTOS_RENEGOTIATE                 0
-#  define SSL_F_TLS_PARSE_CTOS_SERVER_NAME                 0
-#  define SSL_F_TLS_PARSE_CTOS_SESSION_TICKET              0
-#  define SSL_F_TLS_PARSE_CTOS_SIG_ALGS                    0
-#  define SSL_F_TLS_PARSE_CTOS_SIG_ALGS_CERT               0
-#  define SSL_F_TLS_PARSE_CTOS_SRP                         0
-#  define SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST              0
-#  define SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS            0
-#  define SSL_F_TLS_PARSE_CTOS_USE_SRTP                    0
-#  define SSL_F_TLS_PARSE_STOC_ALPN                        0
-#  define SSL_F_TLS_PARSE_STOC_COOKIE                      0
-#  define SSL_F_TLS_PARSE_STOC_EARLY_DATA                  0
-#  define SSL_F_TLS_PARSE_STOC_EARLY_DATA_INFO             0
-#  define SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS               0
-#  define SSL_F_TLS_PARSE_STOC_KEY_SHARE                   0
-#  define SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN              0
-#  define SSL_F_TLS_PARSE_STOC_NPN                         0
-#  define SSL_F_TLS_PARSE_STOC_PSK                         0
-#  define SSL_F_TLS_PARSE_STOC_RENEGOTIATE                 0
-#  define SSL_F_TLS_PARSE_STOC_SCT                         0
-#  define SSL_F_TLS_PARSE_STOC_SERVER_NAME                 0
-#  define SSL_F_TLS_PARSE_STOC_SESSION_TICKET              0
-#  define SSL_F_TLS_PARSE_STOC_STATUS_REQUEST              0
-#  define SSL_F_TLS_PARSE_STOC_SUPPORTED_VERSIONS          0
-#  define SSL_F_TLS_PARSE_STOC_USE_SRTP                    0
-#  define SSL_F_TLS_POST_PROCESS_CLIENT_HELLO              0
-#  define SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE       0
-#  define SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE             0
-#  define SSL_F_TLS_PROCESS_AS_HELLO_RETRY_REQUEST         0
-#  define SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST            0
-#  define SSL_F_TLS_PROCESS_CERT_STATUS                    0
-#  define SSL_F_TLS_PROCESS_CERT_STATUS_BODY               0
-#  define SSL_F_TLS_PROCESS_CERT_VERIFY                    0
-#  define SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC             0
-#  define SSL_F_TLS_PROCESS_CKE_DHE                        0
-#  define SSL_F_TLS_PROCESS_CKE_ECDHE                      0
-#  define SSL_F_TLS_PROCESS_CKE_GOST                       0
-#  define SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE               0
-#  define SSL_F_TLS_PROCESS_CKE_RSA                        0
-#  define SSL_F_TLS_PROCESS_CKE_SRP                        0
-#  define SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE             0
-#  define SSL_F_TLS_PROCESS_CLIENT_HELLO                   0
-#  define SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE            0
-#  define SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS           0
-#  define SSL_F_TLS_PROCESS_END_OF_EARLY_DATA              0
-#  define SSL_F_TLS_PROCESS_FINISHED                       0
-#  define SSL_F_TLS_PROCESS_HELLO_REQ                      0
-#  define SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST            0
-#  define SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT          0
-#  define SSL_F_TLS_PROCESS_KEY_EXCHANGE                   0
-#  define SSL_F_TLS_PROCESS_KEY_UPDATE                     0
-#  define SSL_F_TLS_PROCESS_NEW_SESSION_TICKET             0
-#  define SSL_F_TLS_PROCESS_NEXT_PROTO                     0
-#  define SSL_F_TLS_PROCESS_SERVER_CERTIFICATE             0
-#  define SSL_F_TLS_PROCESS_SERVER_DONE                    0
-#  define SSL_F_TLS_PROCESS_SERVER_HELLO                   0
-#  define SSL_F_TLS_PROCESS_SKE_DHE                        0
-#  define SSL_F_TLS_PROCESS_SKE_ECDHE                      0
-#  define SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE               0
-#  define SSL_F_TLS_PROCESS_SKE_SRP                        0
-#  define SSL_F_TLS_PSK_DO_BINDER                          0
-#  define SSL_F_TLS_SCAN_CLIENTHELLO_TLSEXT                0
-#  define SSL_F_TLS_SETUP_HANDSHAKE                        0
-#  define SSL_F_USE_CERTIFICATE_CHAIN_FILE                 0
-#  define SSL_F_WPACKET_INTERN_INIT_LEN                    0
-#  define SSL_F_WPACKET_START_SUB_PACKET_LEN__             0
-#  define SSL_F_WRITE_STATE_MACHINE                        0
-# endif
+#define SSL_F_ADD_CLIENT_KEY_SHARE_EXT 0
+#define SSL_F_ADD_KEY_SHARE 0
+#define SSL_F_BYTES_TO_CIPHER_LIST 0
+#define SSL_F_CHECK_SUITEB_CIPHER_LIST 0
+#define SSL_F_CIPHERSUITE_CB 0
+#define SSL_F_CONSTRUCT_CA_NAMES 0
+#define SSL_F_CONSTRUCT_KEY_EXCHANGE_TBS 0
+#define SSL_F_CONSTRUCT_STATEFUL_TICKET 0
+#define SSL_F_CONSTRUCT_STATELESS_TICKET 0
+#define SSL_F_CREATE_SYNTHETIC_MESSAGE_HASH 0
+#define SSL_F_CREATE_TICKET_PREQUEL 0
+#define SSL_F_CT_MOVE_SCTS 0
+#define SSL_F_CT_STRICT 0
+#define SSL_F_CUSTOM_EXT_ADD 0
+#define SSL_F_CUSTOM_EXT_PARSE 0
+#define SSL_F_D2I_SSL_SESSION 0
+#define SSL_F_DANE_CTX_ENABLE 0
+#define SSL_F_DANE_MTYPE_SET 0
+#define SSL_F_DANE_TLSA_ADD 0
+#define SSL_F_DERIVE_SECRET_KEY_AND_IV 0
+#define SSL_F_DO_DTLS1_WRITE 0
+#define SSL_F_DO_SSL3_WRITE 0
+#define SSL_F_DTLS1_BUFFER_RECORD 0
+#define SSL_F_DTLS1_CHECK_TIMEOUT_NUM 0
+#define SSL_F_DTLS1_HEARTBEAT 0
+#define SSL_F_DTLS1_HM_FRAGMENT_NEW 0
+#define SSL_F_DTLS1_PREPROCESS_FRAGMENT 0
+#define SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS 0
+#define SSL_F_DTLS1_PROCESS_RECORD 0
+#define SSL_F_DTLS1_READ_BYTES 0
+#define SSL_F_DTLS1_READ_FAILED 0
+#define SSL_F_DTLS1_RETRANSMIT_MESSAGE 0
+#define SSL_F_DTLS1_WRITE_APP_DATA_BYTES 0
+#define SSL_F_DTLS1_WRITE_BYTES 0
+#define SSL_F_DTLSV1_LISTEN 0
+#define SSL_F_DTLS_CONSTRUCT_CHANGE_CIPHER_SPEC 0
+#define SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST 0
+#define SSL_F_DTLS_GET_REASSEMBLED_MESSAGE 0
+#define SSL_F_DTLS_PROCESS_HELLO_VERIFY 0
+#define SSL_F_DTLS_RECORD_LAYER_NEW 0
+#define SSL_F_DTLS_WAIT_FOR_DRY 0
+#define SSL_F_EARLY_DATA_COUNT_OK 0
+#define SSL_F_FINAL_EARLY_DATA 0
+#define SSL_F_FINAL_EC_PT_FORMATS 0
+#define SSL_F_FINAL_EMS 0
+#define SSL_F_FINAL_KEY_SHARE 0
+#define SSL_F_FINAL_MAXFRAGMENTLEN 0
+#define SSL_F_FINAL_RENEGOTIATE 0
+#define SSL_F_FINAL_SERVER_NAME 0
+#define SSL_F_FINAL_SIG_ALGS 0
+#define SSL_F_GET_CERT_VERIFY_TBS_DATA 0
+#define SSL_F_NSS_KEYLOG_INT 0
+#define SSL_F_OPENSSL_INIT_SSL 0
+#define SSL_F_OSSL_STATEM_CLIENT13_READ_TRANSITION 0
+#define SSL_F_OSSL_STATEM_CLIENT13_WRITE_TRANSITION 0
+#define SSL_F_OSSL_STATEM_CLIENT_CONSTRUCT_MESSAGE 0
+#define SSL_F_OSSL_STATEM_CLIENT_POST_PROCESS_MESSAGE 0
+#define SSL_F_OSSL_STATEM_CLIENT_PROCESS_MESSAGE 0
+#define SSL_F_OSSL_STATEM_CLIENT_READ_TRANSITION 0
+#define SSL_F_OSSL_STATEM_CLIENT_WRITE_TRANSITION 0
+#define SSL_F_OSSL_STATEM_SERVER13_READ_TRANSITION 0
+#define SSL_F_OSSL_STATEM_SERVER13_WRITE_TRANSITION 0
+#define SSL_F_OSSL_STATEM_SERVER_CONSTRUCT_MESSAGE 0
+#define SSL_F_OSSL_STATEM_SERVER_POST_PROCESS_MESSAGE 0
+#define SSL_F_OSSL_STATEM_SERVER_POST_WORK 0
+#define SSL_F_OSSL_STATEM_SERVER_PRE_WORK 0
+#define SSL_F_OSSL_STATEM_SERVER_PROCESS_MESSAGE 0
+#define SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION 0
+#define SSL_F_OSSL_STATEM_SERVER_WRITE_TRANSITION 0
+#define SSL_F_PARSE_CA_NAMES 0
+#define SSL_F_PITEM_NEW 0
+#define SSL_F_PQUEUE_NEW 0
+#define SSL_F_PROCESS_KEY_SHARE_EXT 0
+#define SSL_F_READ_STATE_MACHINE 0
+#define SSL_F_SET_CLIENT_CIPHERSUITE 0
+#define SSL_F_SRP_GENERATE_CLIENT_MASTER_SECRET 0
+#define SSL_F_SRP_GENERATE_SERVER_MASTER_SECRET 0
+#define SSL_F_SRP_VERIFY_SERVER_PARAM 0
+#define SSL_F_SSL3_CHANGE_CIPHER_STATE 0
+#define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM 0
+#define SSL_F_SSL3_CTRL 0
+#define SSL_F_SSL3_CTX_CTRL 0
+#define SSL_F_SSL3_DIGEST_CACHED_RECORDS 0
+#define SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC 0
+#define SSL_F_SSL3_ENC 0
+#define SSL_F_SSL3_FINAL_FINISH_MAC 0
+#define SSL_F_SSL3_FINISH_MAC 0
+#define SSL_F_SSL3_GENERATE_KEY_BLOCK 0
+#define SSL_F_SSL3_GENERATE_MASTER_SECRET 0
+#define SSL_F_SSL3_GET_RECORD 0
+#define SSL_F_SSL3_INIT_FINISHED_MAC 0
+#define SSL_F_SSL3_OUTPUT_CERT_CHAIN 0
+#define SSL_F_SSL3_READ_BYTES 0
+#define SSL_F_SSL3_READ_N 0
+#define SSL_F_SSL3_SETUP_KEY_BLOCK 0
+#define SSL_F_SSL3_SETUP_READ_BUFFER 0
+#define SSL_F_SSL3_SETUP_WRITE_BUFFER 0
+#define SSL_F_SSL3_WRITE_BYTES 0
+#define SSL_F_SSL3_WRITE_PENDING 0
+#define SSL_F_SSL_ADD_CERT_CHAIN 0
+#define SSL_F_SSL_ADD_CERT_TO_BUF 0
+#define SSL_F_SSL_ADD_CERT_TO_WPACKET 0
+#define SSL_F_SSL_ADD_CLIENTHELLO_RENEGOTIATE_EXT 0
+#define SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT 0
+#define SSL_F_SSL_ADD_CLIENTHELLO_USE_SRTP_EXT 0
+#define SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK 0
+#define SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK 0
+#define SSL_F_SSL_ADD_SERVERHELLO_RENEGOTIATE_EXT 0
+#define SSL_F_SSL_ADD_SERVERHELLO_TLSEXT 0
+#define SSL_F_SSL_ADD_SERVERHELLO_USE_SRTP_EXT 0
+#define SSL_F_SSL_BAD_METHOD 0
+#define SSL_F_SSL_BUILD_CERT_CHAIN 0
+#define SSL_F_SSL_BYTES_TO_CIPHER_LIST 0
+#define SSL_F_SSL_CACHE_CIPHERLIST 0
+#define SSL_F_SSL_CERT_ADD0_CHAIN_CERT 0
+#define SSL_F_SSL_CERT_DUP 0
+#define SSL_F_SSL_CERT_NEW 0
+#define SSL_F_SSL_CERT_SET0_CHAIN 0
+#define SSL_F_SSL_CHECK_PRIVATE_KEY 0
+#define SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT 0
+#define SSL_F_SSL_CHECK_SRP_EXT_CLIENTHELLO 0
+#define SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG 0
+#define SSL_F_SSL_CHOOSE_CLIENT_VERSION 0
+#define SSL_F_SSL_CIPHER_DESCRIPTION 0
+#define SSL_F_SSL_CIPHER_LIST_TO_BYTES 0
+#define SSL_F_SSL_CIPHER_PROCESS_RULESTR 0
+#define SSL_F_SSL_CIPHER_STRENGTH_SORT 0
+#define SSL_F_SSL_CLEAR 0
+#define SSL_F_SSL_CLIENT_HELLO_GET1_EXTENSIONS_PRESENT 0
+#define SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD 0
+#define SSL_F_SSL_CONF_CMD 0
+#define SSL_F_SSL_CREATE_CIPHER_LIST 0
+#define SSL_F_SSL_CTRL 0
+#define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY 0
+#define SSL_F_SSL_CTX_ENABLE_CT 0
+#define SSL_F_SSL_CTX_MAKE_PROFILES 0
+#define SSL_F_SSL_CTX_NEW 0
+#define SSL_F_SSL_CTX_SET_ALPN_PROTOS 0
+#define SSL_F_SSL_CTX_SET_CIPHER_LIST 0
+#define SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE 0
+#define SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK 0
+#define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT 0
+#define SSL_F_SSL_CTX_SET_SSL_VERSION 0
+#define SSL_F_SSL_CTX_SET_TLSEXT_MAX_FRAGMENT_LENGTH 0
+#define SSL_F_SSL_CTX_USE_CERTIFICATE 0
+#define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1 0
+#define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE 0
+#define SSL_F_SSL_CTX_USE_PRIVATEKEY 0
+#define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1 0
+#define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE 0
+#define SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT 0
+#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY 0
+#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1 0
+#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE 0
+#define SSL_F_SSL_CTX_USE_SERVERINFO 0
+#define SSL_F_SSL_CTX_USE_SERVERINFO_EX 0
+#define SSL_F_SSL_CTX_USE_SERVERINFO_FILE 0
+#define SSL_F_SSL_DANE_DUP 0
+#define SSL_F_SSL_DANE_ENABLE 0
+#define SSL_F_SSL_DERIVE 0
+#define SSL_F_SSL_DO_CONFIG 0
+#define SSL_F_SSL_DO_HANDSHAKE 0
+#define SSL_F_SSL_DUP_CA_LIST 0
+#define SSL_F_SSL_ENABLE_CT 0
+#define SSL_F_SSL_GENERATE_PKEY_GROUP 0
+#define SSL_F_SSL_GENERATE_SESSION_ID 0
+#define SSL_F_SSL_GET_NEW_SESSION 0
+#define SSL_F_SSL_GET_PREV_SESSION 0
+#define SSL_F_SSL_GET_SERVER_CERT_INDEX 0
+#define SSL_F_SSL_GET_SIGN_PKEY 0
+#define SSL_F_SSL_HANDSHAKE_HASH 0
+#define SSL_F_SSL_INIT_WBIO_BUFFER 0
+#define SSL_F_SSL_KEY_UPDATE 0
+#define SSL_F_SSL_LOAD_CLIENT_CA_FILE 0
+#define SSL_F_SSL_LOG_MASTER_SECRET 0
+#define SSL_F_SSL_LOG_RSA_CLIENT_KEY_EXCHANGE 0
+#define SSL_F_SSL_MODULE_INIT 0
+#define SSL_F_SSL_NEW 0
+#define SSL_F_SSL_NEXT_PROTO_VALIDATE 0
+#define SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT 0
+#define SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT 0
+#define SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT 0
+#define SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT 0
+#define SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT 0
+#define SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT 0
+#define SSL_F_SSL_PEEK 0
+#define SSL_F_SSL_PEEK_EX 0
+#define SSL_F_SSL_PEEK_INTERNAL 0
+#define SSL_F_SSL_READ 0
+#define SSL_F_SSL_READ_EARLY_DATA 0
+#define SSL_F_SSL_READ_EX 0
+#define SSL_F_SSL_READ_INTERNAL 0
+#define SSL_F_SSL_RENEGOTIATE 0
+#define SSL_F_SSL_RENEGOTIATE_ABBREVIATED 0
+#define SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT 0
+#define SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT 0
+#define SSL_F_SSL_SESSION_DUP 0
+#define SSL_F_SSL_SESSION_NEW 0
+#define SSL_F_SSL_SESSION_PRINT_FP 0
+#define SSL_F_SSL_SESSION_SET1_ID 0
+#define SSL_F_SSL_SESSION_SET1_ID_CONTEXT 0
+#define SSL_F_SSL_SET_ALPN_PROTOS 0
+#define SSL_F_SSL_SET_CERT 0
+#define SSL_F_SSL_SET_CERT_AND_KEY 0
+#define SSL_F_SSL_SET_CIPHER_LIST 0
+#define SSL_F_SSL_SET_CT_VALIDATION_CALLBACK 0
+#define SSL_F_SSL_SET_FD 0
+#define SSL_F_SSL_SET_PKEY 0
+#define SSL_F_SSL_SET_RFD 0
+#define SSL_F_SSL_SET_SESSION 0
+#define SSL_F_SSL_SET_SESSION_ID_CONTEXT 0
+#define SSL_F_SSL_SET_SESSION_TICKET_EXT 0
+#define SSL_F_SSL_SET_TLSEXT_MAX_FRAGMENT_LENGTH 0
+#define SSL_F_SSL_SET_WFD 0
+#define SSL_F_SSL_SHUTDOWN 0
+#define SSL_F_SSL_SRP_CTX_INIT 0
+#define SSL_F_SSL_START_ASYNC_JOB 0
+#define SSL_F_SSL_UNDEFINED_FUNCTION 0
+#define SSL_F_SSL_UNDEFINED_VOID_FUNCTION 0
+#define SSL_F_SSL_USE_CERTIFICATE 0
+#define SSL_F_SSL_USE_CERTIFICATE_ASN1 0
+#define SSL_F_SSL_USE_CERTIFICATE_FILE 0
+#define SSL_F_SSL_USE_PRIVATEKEY 0
+#define SSL_F_SSL_USE_PRIVATEKEY_ASN1 0
+#define SSL_F_SSL_USE_PRIVATEKEY_FILE 0
+#define SSL_F_SSL_USE_PSK_IDENTITY_HINT 0
+#define SSL_F_SSL_USE_RSAPRIVATEKEY 0
+#define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1 0
+#define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE 0
+#define SSL_F_SSL_VALIDATE_CT 0
+#define SSL_F_SSL_VERIFY_CERT_CHAIN 0
+#define SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE 0
+#define SSL_F_SSL_WRITE 0
+#define SSL_F_SSL_WRITE_EARLY_DATA 0
+#define SSL_F_SSL_WRITE_EARLY_FINISH 0
+#define SSL_F_SSL_WRITE_EX 0
+#define SSL_F_SSL_WRITE_INTERNAL 0
+#define SSL_F_STATE_MACHINE 0
+#define SSL_F_TLS12_CHECK_PEER_SIGALG 0
+#define SSL_F_TLS12_COPY_SIGALGS 0
+#define SSL_F_TLS13_CHANGE_CIPHER_STATE 0
+#define SSL_F_TLS13_ENC 0
+#define SSL_F_TLS13_FINAL_FINISH_MAC 0
+#define SSL_F_TLS13_GENERATE_SECRET 0
+#define SSL_F_TLS13_HKDF_EXPAND 0
+#define SSL_F_TLS13_RESTORE_HANDSHAKE_DIGEST_FOR_PHA 0
+#define SSL_F_TLS13_SAVE_HANDSHAKE_DIGEST_FOR_PHA 0
+#define SSL_F_TLS13_SETUP_KEY_BLOCK 0
+#define SSL_F_TLS1_CHANGE_CIPHER_STATE 0
+#define SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS 0
+#define SSL_F_TLS1_ENC 0
+#define SSL_F_TLS1_EXPORT_KEYING_MATERIAL 0
+#define SSL_F_TLS1_GET_CURVELIST 0
+#define SSL_F_TLS1_PRF 0
+#define SSL_F_TLS1_SAVE_U16 0
+#define SSL_F_TLS1_SETUP_KEY_BLOCK 0
+#define SSL_F_TLS1_SET_GROUPS 0
+#define SSL_F_TLS1_SET_RAW_SIGALGS 0
+#define SSL_F_TLS1_SET_SERVER_SIGALGS 0
+#define SSL_F_TLS1_SET_SHARED_SIGALGS 0
+#define SSL_F_TLS1_SET_SIGALGS 0
+#define SSL_F_TLS_CHOOSE_SIGALG 0
+#define SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK 0
+#define SSL_F_TLS_COLLECT_EXTENSIONS 0
+#define SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES 0
+#define SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST 0
+#define SSL_F_TLS_CONSTRUCT_CERT_STATUS 0
+#define SSL_F_TLS_CONSTRUCT_CERT_STATUS_BODY 0
+#define SSL_F_TLS_CONSTRUCT_CERT_VERIFY 0
+#define SSL_F_TLS_CONSTRUCT_CHANGE_CIPHER_SPEC 0
+#define SSL_F_TLS_CONSTRUCT_CKE_DHE 0
+#define SSL_F_TLS_CONSTRUCT_CKE_ECDHE 0
+#define SSL_F_TLS_CONSTRUCT_CKE_GOST 0
+#define SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE 0
+#define SSL_F_TLS_CONSTRUCT_CKE_RSA 0
+#define SSL_F_TLS_CONSTRUCT_CKE_SRP 0
+#define SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE 0
+#define SSL_F_TLS_CONSTRUCT_CLIENT_HELLO 0
+#define SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE 0
+#define SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_ALPN 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_CERTIFICATE 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_COOKIE 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_EC_PT_FORMATS 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_EMS 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_ETM 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_HELLO 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_KEY_EXCHANGE 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_MAXFRAGMENTLEN 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_NPN 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_PADDING 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_POST_HANDSHAKE_AUTH 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_PSK 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_PSK_KEX_MODES 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_RENEGOTIATE 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_SCT 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_SERVER_NAME 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_SIG_ALGS 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_SRP 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP 0
+#define SSL_F_TLS_CONSTRUCT_CTOS_VERIFY 0
+#define SSL_F_TLS_CONSTRUCT_ENCRYPTED_EXTENSIONS 0
+#define SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA 0
+#define SSL_F_TLS_CONSTRUCT_EXTENSIONS 0
+#define SSL_F_TLS_CONSTRUCT_FINISHED 0
+#define SSL_F_TLS_CONSTRUCT_HELLO_REQUEST 0
+#define SSL_F_TLS_CONSTRUCT_HELLO_RETRY_REQUEST 0
+#define SSL_F_TLS_CONSTRUCT_KEY_UPDATE 0
+#define SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET 0
+#define SSL_F_TLS_CONSTRUCT_NEXT_PROTO 0
+#define SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE 0
+#define SSL_F_TLS_CONSTRUCT_SERVER_HELLO 0
+#define SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE 0
+#define SSL_F_TLS_CONSTRUCT_STOC_ALPN 0
+#define SSL_F_TLS_CONSTRUCT_STOC_CERTIFICATE 0
+#define SSL_F_TLS_CONSTRUCT_STOC_COOKIE 0
+#define SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG 0
+#define SSL_F_TLS_CONSTRUCT_STOC_DONE 0
+#define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA 0
+#define SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA_INFO 0
+#define SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS 0
+#define SSL_F_TLS_CONSTRUCT_STOC_EMS 0
+#define SSL_F_TLS_CONSTRUCT_STOC_ETM 0
+#define SSL_F_TLS_CONSTRUCT_STOC_HELLO 0
+#define SSL_F_TLS_CONSTRUCT_STOC_KEY_EXCHANGE 0
+#define SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE 0
+#define SSL_F_TLS_CONSTRUCT_STOC_MAXFRAGMENTLEN 0
+#define SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG 0
+#define SSL_F_TLS_CONSTRUCT_STOC_PSK 0
+#define SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE 0
+#define SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME 0
+#define SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET 0
+#define SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST 0
+#define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS 0
+#define SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_VERSIONS 0
+#define SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP 0
+#define SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO 0
+#define SSL_F_TLS_FINISH_HANDSHAKE 0
+#define SSL_F_TLS_GET_MESSAGE_BODY 0
+#define SSL_F_TLS_GET_MESSAGE_HEADER 0
+#define SSL_F_TLS_HANDLE_ALPN 0
+#define SSL_F_TLS_HANDLE_STATUS_REQUEST 0
+#define SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES 0
+#define SSL_F_TLS_PARSE_CLIENTHELLO_TLSEXT 0
+#define SSL_F_TLS_PARSE_CTOS_ALPN 0
+#define SSL_F_TLS_PARSE_CTOS_COOKIE 0
+#define SSL_F_TLS_PARSE_CTOS_EARLY_DATA 0
+#define SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS 0
+#define SSL_F_TLS_PARSE_CTOS_EMS 0
+#define SSL_F_TLS_PARSE_CTOS_KEY_SHARE 0
+#define SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN 0
+#define SSL_F_TLS_PARSE_CTOS_POST_HANDSHAKE_AUTH 0
+#define SSL_F_TLS_PARSE_CTOS_PSK 0
+#define SSL_F_TLS_PARSE_CTOS_PSK_KEX_MODES 0
+#define SSL_F_TLS_PARSE_CTOS_RENEGOTIATE 0
+#define SSL_F_TLS_PARSE_CTOS_SERVER_NAME 0
+#define SSL_F_TLS_PARSE_CTOS_SESSION_TICKET 0
+#define SSL_F_TLS_PARSE_CTOS_SIG_ALGS 0
+#define SSL_F_TLS_PARSE_CTOS_SIG_ALGS_CERT 0
+#define SSL_F_TLS_PARSE_CTOS_SRP 0
+#define SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST 0
+#define SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS 0
+#define SSL_F_TLS_PARSE_CTOS_USE_SRTP 0
+#define SSL_F_TLS_PARSE_STOC_ALPN 0
+#define SSL_F_TLS_PARSE_STOC_COOKIE 0
+#define SSL_F_TLS_PARSE_STOC_EARLY_DATA 0
+#define SSL_F_TLS_PARSE_STOC_EARLY_DATA_INFO 0
+#define SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS 0
+#define SSL_F_TLS_PARSE_STOC_KEY_SHARE 0
+#define SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN 0
+#define SSL_F_TLS_PARSE_STOC_NPN 0
+#define SSL_F_TLS_PARSE_STOC_PSK 0
+#define SSL_F_TLS_PARSE_STOC_RENEGOTIATE 0
+#define SSL_F_TLS_PARSE_STOC_SCT 0
+#define SSL_F_TLS_PARSE_STOC_SERVER_NAME 0
+#define SSL_F_TLS_PARSE_STOC_SESSION_TICKET 0
+#define SSL_F_TLS_PARSE_STOC_STATUS_REQUEST 0
+#define SSL_F_TLS_PARSE_STOC_SUPPORTED_VERSIONS 0
+#define SSL_F_TLS_PARSE_STOC_USE_SRTP 0
+#define SSL_F_TLS_POST_PROCESS_CLIENT_HELLO 0
+#define SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE 0
+#define SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE 0
+#define SSL_F_TLS_PROCESS_AS_HELLO_RETRY_REQUEST 0
+#define SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST 0
+#define SSL_F_TLS_PROCESS_CERT_STATUS 0
+#define SSL_F_TLS_PROCESS_CERT_STATUS_BODY 0
+#define SSL_F_TLS_PROCESS_CERT_VERIFY 0
+#define SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC 0
+#define SSL_F_TLS_PROCESS_CKE_DHE 0
+#define SSL_F_TLS_PROCESS_CKE_ECDHE 0
+#define SSL_F_TLS_PROCESS_CKE_GOST 0
+#define SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE 0
+#define SSL_F_TLS_PROCESS_CKE_RSA 0
+#define SSL_F_TLS_PROCESS_CKE_SRP 0
+#define SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE 0
+#define SSL_F_TLS_PROCESS_CLIENT_HELLO 0
+#define SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE 0
+#define SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS 0
+#define SSL_F_TLS_PROCESS_END_OF_EARLY_DATA 0
+#define SSL_F_TLS_PROCESS_FINISHED 0
+#define SSL_F_TLS_PROCESS_HELLO_REQ 0
+#define SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST 0
+#define SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT 0
+#define SSL_F_TLS_PROCESS_KEY_EXCHANGE 0
+#define SSL_F_TLS_PROCESS_KEY_UPDATE 0
+#define SSL_F_TLS_PROCESS_NEW_SESSION_TICKET 0
+#define SSL_F_TLS_PROCESS_NEXT_PROTO 0
+#define SSL_F_TLS_PROCESS_SERVER_CERTIFICATE 0
+#define SSL_F_TLS_PROCESS_SERVER_DONE 0
+#define SSL_F_TLS_PROCESS_SERVER_HELLO 0
+#define SSL_F_TLS_PROCESS_SKE_DHE 0
+#define SSL_F_TLS_PROCESS_SKE_ECDHE 0
+#define SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE 0
+#define SSL_F_TLS_PROCESS_SKE_SRP 0
+#define SSL_F_TLS_PSK_DO_BINDER 0
+#define SSL_F_TLS_SCAN_CLIENTHELLO_TLSEXT 0
+#define SSL_F_TLS_SETUP_HANDSHAKE 0
+#define SSL_F_USE_CERTIFICATE_CHAIN_FILE 0
+#define SSL_F_WPACKET_INTERN_INIT_LEN 0
+#define SSL_F_WPACKET_START_SUB_PACKET_LEN__ 0
+#define SSL_F_WRITE_STATE_MACHINE 0
+#endif
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/stack.h b/CAPI/cpp/grpc/include/openssl/stack.h
index f0c5c54..3ab4d19 100644
--- a/CAPI/cpp/grpc/include/openssl/stack.h
+++ b/CAPI/cpp/grpc/include/openssl/stack.h
@@ -8,82 +8,80 @@
  */
 
 #ifndef OPENSSL_STACK_H
-# define OPENSSL_STACK_H
-# pragma once
+#define OPENSSL_STACK_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_STACK_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_STACK_H
+#endif
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-typedef struct stack_st OPENSSL_STACK; /* Use STACK_OF(...) instead */
+    typedef struct stack_st OPENSSL_STACK; /* Use STACK_OF(...) instead */
 
-typedef int (*OPENSSL_sk_compfunc)(const void *, const void *);
-typedef void (*OPENSSL_sk_freefunc)(void *);
-typedef void *(*OPENSSL_sk_copyfunc)(const void *);
+    typedef int (*OPENSSL_sk_compfunc)(const void*, const void*);
+    typedef void (*OPENSSL_sk_freefunc)(void*);
+    typedef void* (*OPENSSL_sk_copyfunc)(const void*);
 
-int OPENSSL_sk_num(const OPENSSL_STACK *);
-void *OPENSSL_sk_value(const OPENSSL_STACK *, int);
+    int OPENSSL_sk_num(const OPENSSL_STACK*);
+    void* OPENSSL_sk_value(const OPENSSL_STACK*, int);
 
-void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data);
+    void* OPENSSL_sk_set(OPENSSL_STACK* st, int i, const void* data);
 
-OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp);
-OPENSSL_STACK *OPENSSL_sk_new_null(void);
-OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n);
-int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n);
-void OPENSSL_sk_free(OPENSSL_STACK *);
-void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *));
-OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *,
-                                    OPENSSL_sk_copyfunc c,
-                                    OPENSSL_sk_freefunc f);
-int OPENSSL_sk_insert(OPENSSL_STACK *sk, const void *data, int where);
-void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc);
-void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p);
-int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data);
-int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data);
-int OPENSSL_sk_find_all(OPENSSL_STACK *st, const void *data, int *pnum);
-int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data);
-int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data);
-void *OPENSSL_sk_shift(OPENSSL_STACK *st);
-void *OPENSSL_sk_pop(OPENSSL_STACK *st);
-void OPENSSL_sk_zero(OPENSSL_STACK *st);
-OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk,
-                                            OPENSSL_sk_compfunc cmp);
-OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *st);
-void OPENSSL_sk_sort(OPENSSL_STACK *st);
-int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st);
+    OPENSSL_STACK* OPENSSL_sk_new(OPENSSL_sk_compfunc cmp);
+    OPENSSL_STACK* OPENSSL_sk_new_null(void);
+    OPENSSL_STACK* OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n);
+    int OPENSSL_sk_reserve(OPENSSL_STACK* st, int n);
+    void OPENSSL_sk_free(OPENSSL_STACK*);
+    void OPENSSL_sk_pop_free(OPENSSL_STACK* st, void (*func)(void*));
+    OPENSSL_STACK* OPENSSL_sk_deep_copy(const OPENSSL_STACK*, OPENSSL_sk_copyfunc c, OPENSSL_sk_freefunc f);
+    int OPENSSL_sk_insert(OPENSSL_STACK* sk, const void* data, int where);
+    void* OPENSSL_sk_delete(OPENSSL_STACK* st, int loc);
+    void* OPENSSL_sk_delete_ptr(OPENSSL_STACK* st, const void* p);
+    int OPENSSL_sk_find(OPENSSL_STACK* st, const void* data);
+    int OPENSSL_sk_find_ex(OPENSSL_STACK* st, const void* data);
+    int OPENSSL_sk_find_all(OPENSSL_STACK* st, const void* data, int* pnum);
+    int OPENSSL_sk_push(OPENSSL_STACK* st, const void* data);
+    int OPENSSL_sk_unshift(OPENSSL_STACK* st, const void* data);
+    void* OPENSSL_sk_shift(OPENSSL_STACK* st);
+    void* OPENSSL_sk_pop(OPENSSL_STACK* st);
+    void OPENSSL_sk_zero(OPENSSL_STACK* st);
+    OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK* sk, OPENSSL_sk_compfunc cmp);
+    OPENSSL_STACK* OPENSSL_sk_dup(const OPENSSL_STACK* st);
+    void OPENSSL_sk_sort(OPENSSL_STACK* st);
+    int OPENSSL_sk_is_sorted(const OPENSSL_STACK* st);
 
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define _STACK OPENSSL_STACK
-#  define sk_num OPENSSL_sk_num
-#  define sk_value OPENSSL_sk_value
-#  define sk_set OPENSSL_sk_set
-#  define sk_new OPENSSL_sk_new
-#  define sk_new_null OPENSSL_sk_new_null
-#  define sk_free OPENSSL_sk_free
-#  define sk_pop_free OPENSSL_sk_pop_free
-#  define sk_deep_copy OPENSSL_sk_deep_copy
-#  define sk_insert OPENSSL_sk_insert
-#  define sk_delete OPENSSL_sk_delete
-#  define sk_delete_ptr OPENSSL_sk_delete_ptr
-#  define sk_find OPENSSL_sk_find
-#  define sk_find_ex OPENSSL_sk_find_ex
-#  define sk_push OPENSSL_sk_push
-#  define sk_unshift OPENSSL_sk_unshift
-#  define sk_shift OPENSSL_sk_shift
-#  define sk_pop OPENSSL_sk_pop
-#  define sk_zero OPENSSL_sk_zero
-#  define sk_set_cmp_func OPENSSL_sk_set_cmp_func
-#  define sk_dup OPENSSL_sk_dup
-#  define sk_sort OPENSSL_sk_sort
-#  define sk_is_sorted OPENSSL_sk_is_sorted
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define _STACK OPENSSL_STACK
+#define sk_num OPENSSL_sk_num
+#define sk_value OPENSSL_sk_value
+#define sk_set OPENSSL_sk_set
+#define sk_new OPENSSL_sk_new
+#define sk_new_null OPENSSL_sk_new_null
+#define sk_free OPENSSL_sk_free
+#define sk_pop_free OPENSSL_sk_pop_free
+#define sk_deep_copy OPENSSL_sk_deep_copy
+#define sk_insert OPENSSL_sk_insert
+#define sk_delete OPENSSL_sk_delete
+#define sk_delete_ptr OPENSSL_sk_delete_ptr
+#define sk_find OPENSSL_sk_find
+#define sk_find_ex OPENSSL_sk_find_ex
+#define sk_push OPENSSL_sk_push
+#define sk_unshift OPENSSL_sk_unshift
+#define sk_shift OPENSSL_sk_shift
+#define sk_pop OPENSSL_sk_pop
+#define sk_zero OPENSSL_sk_zero
+#define sk_set_cmp_func OPENSSL_sk_set_cmp_func
+#define sk_dup OPENSSL_sk_dup
+#define sk_sort OPENSSL_sk_sort
+#define sk_is_sorted OPENSSL_sk_is_sorted
+#endif
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/CAPI/cpp/grpc/include/openssl/store.h b/CAPI/cpp/grpc/include/openssl/store.h
index 3c1445e..6e2738e 100644
--- a/CAPI/cpp/grpc/include/openssl/store.h
+++ b/CAPI/cpp/grpc/include/openssl/store.h
@@ -8,60 +8,54 @@
  */
 
 #ifndef OPENSSL_STORE_H
-# define OPENSSL_STORE_H
-# pragma once
+#define OPENSSL_STORE_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_OSSL_STORE_H
-# endif
-
-# include <stdarg.h>
-# include <openssl/types.h>
-# include <openssl/pem.h>
-# include <openssl/storeerr.h>
-
-# ifdef  __cplusplus
-extern "C" {
-# endif
-
-/*-
- *  The main OSSL_STORE functions.
- *  ------------------------------
- *
- *  These allow applications to open a channel to a resource with supported
- *  data (keys, certs, crls, ...), read the data a piece at a time and decide
- *  what to do with it, and finally close.
- */
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_OSSL_STORE_H
+#endif
 
-typedef struct ossl_store_ctx_st OSSL_STORE_CTX;
+#include <stdarg.h>
+#include <openssl/types.h>
+#include <openssl/pem.h>
+#include <openssl/storeerr.h>
 
-/*
- * Typedef for the OSSL_STORE_INFO post processing callback.  This can be used
- * to massage the given OSSL_STORE_INFO, or to drop it entirely (by returning
- * NULL).
- */
-typedef OSSL_STORE_INFO *(*OSSL_STORE_post_process_info_fn)(OSSL_STORE_INFO *,
-                                                            void *);
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-/*
- * Open a channel given a URI.  The given UI method will be used any time the
- * loader needs extra input, for example when a password or pin is needed, and
- * will be passed the same user data every time it's needed in this context.
- *
- * Returns a context reference which represents the channel to communicate
- * through.
- */
-OSSL_STORE_CTX *
-OSSL_STORE_open(const char *uri, const UI_METHOD *ui_method, void *ui_data,
-                OSSL_STORE_post_process_info_fn post_process,
-                void *post_process_data);
-OSSL_STORE_CTX *
-OSSL_STORE_open_ex(const char *uri, OSSL_LIB_CTX *libctx, const char *propq,
-                   const UI_METHOD *ui_method, void *ui_data,
-                   const OSSL_PARAM params[],
-                   OSSL_STORE_post_process_info_fn post_process,
-                   void *post_process_data);
+    /*-
+     *  The main OSSL_STORE functions.
+     *  ------------------------------
+     *
+     *  These allow applications to open a channel to a resource with supported
+     *  data (keys, certs, crls, ...), read the data a piece at a time and decide
+     *  what to do with it, and finally close.
+     */
+
+    typedef struct ossl_store_ctx_st OSSL_STORE_CTX;
+
+    /*
+     * Typedef for the OSSL_STORE_INFO post processing callback.  This can be used
+     * to massage the given OSSL_STORE_INFO, or to drop it entirely (by returning
+     * NULL).
+     */
+    typedef OSSL_STORE_INFO* (*OSSL_STORE_post_process_info_fn)(OSSL_STORE_INFO*, void*);
+
+    /*
+     * Open a channel given a URI.  The given UI method will be used any time the
+     * loader needs extra input, for example when a password or pin is needed, and
+     * will be passed the same user data every time it's needed in this context.
+     *
+     * Returns a context reference which represents the channel to communicate
+     * through.
+     */
+    OSSL_STORE_CTX*
+        OSSL_STORE_open(const char* uri, const UI_METHOD* ui_method, void* ui_data, OSSL_STORE_post_process_info_fn post_process, void* post_process_data);
+    OSSL_STORE_CTX*
+        OSSL_STORE_open_ex(const char* uri, OSSL_LIB_CTX* libctx, const char* propq, const UI_METHOD* ui_method, void* ui_data, const OSSL_PARAM params[], OSSL_STORE_post_process_info_fn post_process, void* post_process_data);
 
 /*
  * Control / fine tune the OSSL_STORE channel.  |cmd| determines what is to be
@@ -69,72 +63,65 @@ OSSL_STORE_open_ex(const char *uri, OSSL_LIB_CTX *libctx, const char *propq,
  * determine which loader is used), except for common commands (see below).
  * Each command takes different arguments.
  */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int OSSL_STORE_ctrl(OSSL_STORE_CTX *ctx, int cmd,
-                                          ... /* args */);
-OSSL_DEPRECATEDIN_3_0 int OSSL_STORE_vctrl(OSSL_STORE_CTX *ctx, int cmd,
-                                           va_list args);
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int OSSL_STORE_ctrl(OSSL_STORE_CTX* ctx, int cmd, ... /* args */);
+    OSSL_DEPRECATEDIN_3_0 int OSSL_STORE_vctrl(OSSL_STORE_CTX* ctx, int cmd, va_list args);
+#endif
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 
 /*
  * Common ctrl commands that different loaders may choose to support.
  */
 /* int on = 0 or 1; STORE_ctrl(ctx, STORE_C_USE_SECMEM, &on); */
-# define OSSL_STORE_C_USE_SECMEM      1
+#define OSSL_STORE_C_USE_SECMEM 1
 /* Where custom commands start */
-# define OSSL_STORE_C_CUSTOM_START    100
-
-# endif
-
-/*
- * Read one data item (a key, a cert, a CRL) that is supported by the OSSL_STORE
- * functionality, given a context.
- * Returns a OSSL_STORE_INFO pointer, from which OpenSSL typed data can be
- * extracted with OSSL_STORE_INFO_get0_PKEY(), OSSL_STORE_INFO_get0_CERT(), ...
- * NULL is returned on error, which may include that the data found at the URI
- * can't be figured out for certain or is ambiguous.
- */
-OSSL_STORE_INFO *OSSL_STORE_load(OSSL_STORE_CTX *ctx);
-
-/*
- * Check if end of data (end of file) is reached
- * Returns 1 on end, 0 otherwise.
- */
-int OSSL_STORE_eof(OSSL_STORE_CTX *ctx);
-
-/*
- * Check if an error occurred
- * Returns 1 if it did, 0 otherwise.
- */
-int OSSL_STORE_error(OSSL_STORE_CTX *ctx);
+#define OSSL_STORE_C_CUSTOM_START 100
 
-/*
- * Close the channel
- * Returns 1 on success, 0 on error.
- */
-int OSSL_STORE_close(OSSL_STORE_CTX *ctx);
+#endif
 
-/*
- * Attach to a BIO.  This works like OSSL_STORE_open() except it takes a
- * BIO instead of a uri, along with a scheme to use when reading.
- * The given UI method will be used any time the loader needs extra input,
- * for example when a password or pin is needed, and will be passed the
- * same user data every time it's needed in this context.
- *
- * Returns a context reference which represents the channel to communicate
- * through.
- *
- * Note that this function is considered unsafe, all depending on what the
- * BIO actually reads.
- */
-OSSL_STORE_CTX *OSSL_STORE_attach(BIO *bio, const char *scheme,
-                                  OSSL_LIB_CTX *libctx, const char *propq,
-                                  const UI_METHOD *ui_method, void *ui_data,
-                                  const OSSL_PARAM params[],
-                                  OSSL_STORE_post_process_info_fn post_process,
-                                  void *post_process_data);
+    /*
+     * Read one data item (a key, a cert, a CRL) that is supported by the OSSL_STORE
+     * functionality, given a context.
+     * Returns a OSSL_STORE_INFO pointer, from which OpenSSL typed data can be
+     * extracted with OSSL_STORE_INFO_get0_PKEY(), OSSL_STORE_INFO_get0_CERT(), ...
+     * NULL is returned on error, which may include that the data found at the URI
+     * can't be figured out for certain or is ambiguous.
+     */
+    OSSL_STORE_INFO* OSSL_STORE_load(OSSL_STORE_CTX* ctx);
+
+    /*
+     * Check if end of data (end of file) is reached
+     * Returns 1 on end, 0 otherwise.
+     */
+    int OSSL_STORE_eof(OSSL_STORE_CTX* ctx);
+
+    /*
+     * Check if an error occurred
+     * Returns 1 if it did, 0 otherwise.
+     */
+    int OSSL_STORE_error(OSSL_STORE_CTX* ctx);
+
+    /*
+     * Close the channel
+     * Returns 1 on success, 0 on error.
+     */
+    int OSSL_STORE_close(OSSL_STORE_CTX* ctx);
+
+    /*
+     * Attach to a BIO.  This works like OSSL_STORE_open() except it takes a
+     * BIO instead of a uri, along with a scheme to use when reading.
+     * The given UI method will be used any time the loader needs extra input,
+     * for example when a password or pin is needed, and will be passed the
+     * same user data every time it's needed in this context.
+     *
+     * Returns a context reference which represents the channel to communicate
+     * through.
+     *
+     * Note that this function is considered unsafe, all depending on what the
+     * BIO actually reads.
+     */
+    OSSL_STORE_CTX* OSSL_STORE_attach(BIO* bio, const char* scheme, OSSL_LIB_CTX* libctx, const char* propq, const UI_METHOD* ui_method, void* ui_data, const OSSL_PARAM params[], OSSL_STORE_post_process_info_fn post_process, void* post_process_data);
 
 /*-
  *  Extracting OpenSSL types from and creating new OSSL_STORE_INFOs
@@ -146,56 +133,55 @@ OSSL_STORE_CTX *OSSL_STORE_attach(BIO *bio, const char *scheme,
  * OSSL_STORE_INFO_NAME is typically found when getting a listing of
  * available "files" / "tokens" / what have you.
  */
-# define OSSL_STORE_INFO_NAME           1   /* char * */
-# define OSSL_STORE_INFO_PARAMS         2   /* EVP_PKEY * */
-# define OSSL_STORE_INFO_PUBKEY         3   /* EVP_PKEY * */
-# define OSSL_STORE_INFO_PKEY           4   /* EVP_PKEY * */
-# define OSSL_STORE_INFO_CERT           5   /* X509 * */
-# define OSSL_STORE_INFO_CRL            6   /* X509_CRL * */
-
-/*
- * Functions to generate OSSL_STORE_INFOs, one function for each type we
- * support having in them, as well as a generic constructor.
- *
- * In all cases, ownership of the object is transferred to the OSSL_STORE_INFO
- * and will therefore be freed when the OSSL_STORE_INFO is freed.
- */
-OSSL_STORE_INFO *OSSL_STORE_INFO_new(int type, void *data);
-OSSL_STORE_INFO *OSSL_STORE_INFO_new_NAME(char *name);
-int OSSL_STORE_INFO_set0_NAME_description(OSSL_STORE_INFO *info, char *desc);
-OSSL_STORE_INFO *OSSL_STORE_INFO_new_PARAMS(EVP_PKEY *params);
-OSSL_STORE_INFO *OSSL_STORE_INFO_new_PUBKEY(EVP_PKEY *pubkey);
-OSSL_STORE_INFO *OSSL_STORE_INFO_new_PKEY(EVP_PKEY *pkey);
-OSSL_STORE_INFO *OSSL_STORE_INFO_new_CERT(X509 *x509);
-OSSL_STORE_INFO *OSSL_STORE_INFO_new_CRL(X509_CRL *crl);
-
-/*
- * Functions to try to extract data from a OSSL_STORE_INFO.
- */
-int OSSL_STORE_INFO_get_type(const OSSL_STORE_INFO *info);
-void *OSSL_STORE_INFO_get0_data(int type, const OSSL_STORE_INFO *info);
-const char *OSSL_STORE_INFO_get0_NAME(const OSSL_STORE_INFO *info);
-char *OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO *info);
-const char *OSSL_STORE_INFO_get0_NAME_description(const OSSL_STORE_INFO *info);
-char *OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO *info);
-EVP_PKEY *OSSL_STORE_INFO_get0_PARAMS(const OSSL_STORE_INFO *info);
-EVP_PKEY *OSSL_STORE_INFO_get1_PARAMS(const OSSL_STORE_INFO *info);
-EVP_PKEY *OSSL_STORE_INFO_get0_PUBKEY(const OSSL_STORE_INFO *info);
-EVP_PKEY *OSSL_STORE_INFO_get1_PUBKEY(const OSSL_STORE_INFO *info);
-EVP_PKEY *OSSL_STORE_INFO_get0_PKEY(const OSSL_STORE_INFO *info);
-EVP_PKEY *OSSL_STORE_INFO_get1_PKEY(const OSSL_STORE_INFO *info);
-X509 *OSSL_STORE_INFO_get0_CERT(const OSSL_STORE_INFO *info);
-X509 *OSSL_STORE_INFO_get1_CERT(const OSSL_STORE_INFO *info);
-X509_CRL *OSSL_STORE_INFO_get0_CRL(const OSSL_STORE_INFO *info);
-X509_CRL *OSSL_STORE_INFO_get1_CRL(const OSSL_STORE_INFO *info);
-
-const char *OSSL_STORE_INFO_type_string(int type);
-
-/*
- * Free the OSSL_STORE_INFO
- */
-void OSSL_STORE_INFO_free(OSSL_STORE_INFO *info);
-
+#define OSSL_STORE_INFO_NAME 1   /* char * */
+#define OSSL_STORE_INFO_PARAMS 2 /* EVP_PKEY * */
+#define OSSL_STORE_INFO_PUBKEY 3 /* EVP_PKEY * */
+#define OSSL_STORE_INFO_PKEY 4   /* EVP_PKEY * */
+#define OSSL_STORE_INFO_CERT 5   /* X509 * */
+#define OSSL_STORE_INFO_CRL 6    /* X509_CRL * */
+
+    /*
+     * Functions to generate OSSL_STORE_INFOs, one function for each type we
+     * support having in them, as well as a generic constructor.
+     *
+     * In all cases, ownership of the object is transferred to the OSSL_STORE_INFO
+     * and will therefore be freed when the OSSL_STORE_INFO is freed.
+     */
+    OSSL_STORE_INFO* OSSL_STORE_INFO_new(int type, void* data);
+    OSSL_STORE_INFO* OSSL_STORE_INFO_new_NAME(char* name);
+    int OSSL_STORE_INFO_set0_NAME_description(OSSL_STORE_INFO* info, char* desc);
+    OSSL_STORE_INFO* OSSL_STORE_INFO_new_PARAMS(EVP_PKEY* params);
+    OSSL_STORE_INFO* OSSL_STORE_INFO_new_PUBKEY(EVP_PKEY* pubkey);
+    OSSL_STORE_INFO* OSSL_STORE_INFO_new_PKEY(EVP_PKEY* pkey);
+    OSSL_STORE_INFO* OSSL_STORE_INFO_new_CERT(X509* x509);
+    OSSL_STORE_INFO* OSSL_STORE_INFO_new_CRL(X509_CRL* crl);
+
+    /*
+     * Functions to try to extract data from a OSSL_STORE_INFO.
+     */
+    int OSSL_STORE_INFO_get_type(const OSSL_STORE_INFO* info);
+    void* OSSL_STORE_INFO_get0_data(int type, const OSSL_STORE_INFO* info);
+    const char* OSSL_STORE_INFO_get0_NAME(const OSSL_STORE_INFO* info);
+    char* OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO* info);
+    const char* OSSL_STORE_INFO_get0_NAME_description(const OSSL_STORE_INFO* info);
+    char* OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO* info);
+    EVP_PKEY* OSSL_STORE_INFO_get0_PARAMS(const OSSL_STORE_INFO* info);
+    EVP_PKEY* OSSL_STORE_INFO_get1_PARAMS(const OSSL_STORE_INFO* info);
+    EVP_PKEY* OSSL_STORE_INFO_get0_PUBKEY(const OSSL_STORE_INFO* info);
+    EVP_PKEY* OSSL_STORE_INFO_get1_PUBKEY(const OSSL_STORE_INFO* info);
+    EVP_PKEY* OSSL_STORE_INFO_get0_PKEY(const OSSL_STORE_INFO* info);
+    EVP_PKEY* OSSL_STORE_INFO_get1_PKEY(const OSSL_STORE_INFO* info);
+    X509* OSSL_STORE_INFO_get0_CERT(const OSSL_STORE_INFO* info);
+    X509* OSSL_STORE_INFO_get1_CERT(const OSSL_STORE_INFO* info);
+    X509_CRL* OSSL_STORE_INFO_get0_CRL(const OSSL_STORE_INFO* info);
+    X509_CRL* OSSL_STORE_INFO_get1_CRL(const OSSL_STORE_INFO* info);
+
+    const char* OSSL_STORE_INFO_type_string(int type);
+
+    /*
+     * Free the OSSL_STORE_INFO
+     */
+    void OSSL_STORE_INFO_free(OSSL_STORE_INFO* info);
 
 /*-
  *  Functions to construct a search URI from a base URI and search criteria
@@ -203,167 +189,128 @@ void OSSL_STORE_INFO_free(OSSL_STORE_INFO *info);
  */
 
 /* OSSL_STORE search types */
-# define OSSL_STORE_SEARCH_BY_NAME              1 /* subject in certs, issuer in CRLs */
-# define OSSL_STORE_SEARCH_BY_ISSUER_SERIAL     2
-# define OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT   3
-# define OSSL_STORE_SEARCH_BY_ALIAS             4
-
-/* To check what search types the scheme handler supports */
-int OSSL_STORE_supports_search(OSSL_STORE_CTX *ctx, int search_type);
-
-/* Search term constructors */
-/*
- * The input is considered to be owned by the caller, and must therefore
- * remain present throughout the lifetime of the returned OSSL_STORE_SEARCH
- */
-OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_name(X509_NAME *name);
-OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_issuer_serial(X509_NAME *name,
-                                                      const ASN1_INTEGER
-                                                      *serial);
-OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_key_fingerprint(const EVP_MD *digest,
-                                                        const unsigned char
-                                                        *bytes, size_t len);
-OSSL_STORE_SEARCH *OSSL_STORE_SEARCH_by_alias(const char *alias);
-
-/* Search term destructor */
-void OSSL_STORE_SEARCH_free(OSSL_STORE_SEARCH *search);
-
-/* Search term accessors */
-int OSSL_STORE_SEARCH_get_type(const OSSL_STORE_SEARCH *criterion);
-X509_NAME *OSSL_STORE_SEARCH_get0_name(const OSSL_STORE_SEARCH *criterion);
-const ASN1_INTEGER *OSSL_STORE_SEARCH_get0_serial(const OSSL_STORE_SEARCH
-                                                  *criterion);
-const unsigned char *OSSL_STORE_SEARCH_get0_bytes(const OSSL_STORE_SEARCH
-                                                  *criterion, size_t *length);
-const char *OSSL_STORE_SEARCH_get0_string(const OSSL_STORE_SEARCH *criterion);
-const EVP_MD *OSSL_STORE_SEARCH_get0_digest(const OSSL_STORE_SEARCH *criterion);
+#define OSSL_STORE_SEARCH_BY_NAME 1 /* subject in certs, issuer in CRLs */
+#define OSSL_STORE_SEARCH_BY_ISSUER_SERIAL 2
+#define OSSL_STORE_SEARCH_BY_KEY_FINGERPRINT 3
+#define OSSL_STORE_SEARCH_BY_ALIAS 4
+
+    /* To check what search types the scheme handler supports */
+    int OSSL_STORE_supports_search(OSSL_STORE_CTX* ctx, int search_type);
+
+    /* Search term constructors */
+    /*
+     * The input is considered to be owned by the caller, and must therefore
+     * remain present throughout the lifetime of the returned OSSL_STORE_SEARCH
+     */
+    OSSL_STORE_SEARCH* OSSL_STORE_SEARCH_by_name(X509_NAME* name);
+    OSSL_STORE_SEARCH* OSSL_STORE_SEARCH_by_issuer_serial(X509_NAME* name, const ASN1_INTEGER* serial);
+    OSSL_STORE_SEARCH* OSSL_STORE_SEARCH_by_key_fingerprint(const EVP_MD* digest, const unsigned char* bytes, size_t len);
+    OSSL_STORE_SEARCH* OSSL_STORE_SEARCH_by_alias(const char* alias);
+
+    /* Search term destructor */
+    void OSSL_STORE_SEARCH_free(OSSL_STORE_SEARCH* search);
+
+    /* Search term accessors */
+    int OSSL_STORE_SEARCH_get_type(const OSSL_STORE_SEARCH* criterion);
+    X509_NAME* OSSL_STORE_SEARCH_get0_name(const OSSL_STORE_SEARCH* criterion);
+    const ASN1_INTEGER* OSSL_STORE_SEARCH_get0_serial(const OSSL_STORE_SEARCH* criterion);
+    const unsigned char* OSSL_STORE_SEARCH_get0_bytes(const OSSL_STORE_SEARCH* criterion, size_t* length);
+    const char* OSSL_STORE_SEARCH_get0_string(const OSSL_STORE_SEARCH* criterion);
+    const EVP_MD* OSSL_STORE_SEARCH_get0_digest(const OSSL_STORE_SEARCH* criterion);
+
+    /*
+     * Add search criterion and expected return type (which can be unspecified)
+     * to the loading channel.  This MUST happen before the first OSSL_STORE_load().
+     */
+    int OSSL_STORE_expect(OSSL_STORE_CTX* ctx, int expected_type);
+    int OSSL_STORE_find(OSSL_STORE_CTX* ctx, const OSSL_STORE_SEARCH* search);
+
+    /*-
+     *  Function to fetch a loader and extract data from it
+     *  ---------------------------------------------------
+     */
+
+    typedef struct ossl_store_loader_st OSSL_STORE_LOADER;
+
+    OSSL_STORE_LOADER* OSSL_STORE_LOADER_fetch(OSSL_LIB_CTX* libctx, const char* scheme, const char* properties);
+    int OSSL_STORE_LOADER_up_ref(OSSL_STORE_LOADER* loader);
+    void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER* loader);
+    const OSSL_PROVIDER* OSSL_STORE_LOADER_get0_provider(const OSSL_STORE_LOADER*
+                                                             loader);
+    const char* OSSL_STORE_LOADER_get0_properties(const OSSL_STORE_LOADER* loader);
+    const char* OSSL_STORE_LOADER_get0_description(const OSSL_STORE_LOADER* loader);
+    int OSSL_STORE_LOADER_is_a(const OSSL_STORE_LOADER* loader, const char* scheme);
+    void OSSL_STORE_LOADER_do_all_provided(OSSL_LIB_CTX* libctx, void (*fn)(OSSL_STORE_LOADER* loader, void* arg), void* arg);
+    int OSSL_STORE_LOADER_names_do_all(const OSSL_STORE_LOADER* loader, void (*fn)(const char* name, void* data), void* data);
+
+    /*-
+     *  Function to register a loader for the given URI scheme.
+     *  -------------------------------------------------------
+     *
+     *  The loader receives all the main components of an URI except for the
+     *  scheme.
+     */
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+
+    /* struct ossl_store_loader_ctx_st is defined differently by each loader */
+    typedef struct ossl_store_loader_ctx_st OSSL_STORE_LOADER_CTX;
+    typedef OSSL_STORE_LOADER_CTX* (*OSSL_STORE_open_fn)(const OSSL_STORE_LOADER* loader, const char* uri, const UI_METHOD* ui_method, void* ui_data);
+    typedef OSSL_STORE_LOADER_CTX* (*OSSL_STORE_open_ex_fn)(const OSSL_STORE_LOADER* loader, const char* uri, OSSL_LIB_CTX* libctx, const char* propq, const UI_METHOD* ui_method, void* ui_data);
+
+    typedef OSSL_STORE_LOADER_CTX* (*OSSL_STORE_attach_fn)(const OSSL_STORE_LOADER* loader, BIO* bio, OSSL_LIB_CTX* libctx, const char* propq, const UI_METHOD* ui_method, void* ui_data);
+    typedef int (*OSSL_STORE_ctrl_fn)(OSSL_STORE_LOADER_CTX* ctx, int cmd, va_list args);
+    typedef int (*OSSL_STORE_expect_fn)(OSSL_STORE_LOADER_CTX* ctx, int expected);
+    typedef int (*OSSL_STORE_find_fn)(OSSL_STORE_LOADER_CTX* ctx, const OSSL_STORE_SEARCH* criteria);
+    typedef OSSL_STORE_INFO* (*OSSL_STORE_load_fn)(OSSL_STORE_LOADER_CTX* ctx, const UI_METHOD* ui_method, void* ui_data);
+    typedef int (*OSSL_STORE_eof_fn)(OSSL_STORE_LOADER_CTX* ctx);
+    typedef int (*OSSL_STORE_error_fn)(OSSL_STORE_LOADER_CTX* ctx);
+    typedef int (*OSSL_STORE_close_fn)(OSSL_STORE_LOADER_CTX* ctx);
 
-/*
- * Add search criterion and expected return type (which can be unspecified)
- * to the loading channel.  This MUST happen before the first OSSL_STORE_load().
- */
-int OSSL_STORE_expect(OSSL_STORE_CTX *ctx, int expected_type);
-int OSSL_STORE_find(OSSL_STORE_CTX *ctx, const OSSL_STORE_SEARCH *search);
-
-
-/*-
- *  Function to fetch a loader and extract data from it
- *  ---------------------------------------------------
- */
-
-typedef struct ossl_store_loader_st OSSL_STORE_LOADER;
-
-OSSL_STORE_LOADER *OSSL_STORE_LOADER_fetch(OSSL_LIB_CTX *libctx,
-                                           const char *scheme,
-                                           const char *properties);
-int OSSL_STORE_LOADER_up_ref(OSSL_STORE_LOADER *loader);
-void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader);
-const OSSL_PROVIDER *OSSL_STORE_LOADER_get0_provider(const OSSL_STORE_LOADER *
-                                                loader);
-const char *OSSL_STORE_LOADER_get0_properties(const OSSL_STORE_LOADER *loader);
-const char *OSSL_STORE_LOADER_get0_description(const OSSL_STORE_LOADER *loader);
-int OSSL_STORE_LOADER_is_a(const OSSL_STORE_LOADER *loader,
-                           const char *scheme);
-void OSSL_STORE_LOADER_do_all_provided(OSSL_LIB_CTX *libctx,
-                                       void (*fn)(OSSL_STORE_LOADER *loader,
-                                                  void *arg),
-                                       void *arg);
-int OSSL_STORE_LOADER_names_do_all(const OSSL_STORE_LOADER *loader,
-                                   void (*fn)(const char *name, void *data),
-                                   void *data);
-
-/*-
- *  Function to register a loader for the given URI scheme.
- *  -------------------------------------------------------
- *
- *  The loader receives all the main components of an URI except for the
- *  scheme.
- */
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-
-/* struct ossl_store_loader_ctx_st is defined differently by each loader */
-typedef struct ossl_store_loader_ctx_st OSSL_STORE_LOADER_CTX;
-typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_open_fn)
-    (const OSSL_STORE_LOADER *loader, const char *uri,
-     const UI_METHOD *ui_method, void *ui_data);
-typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_open_ex_fn)
-    (const OSSL_STORE_LOADER *loader,
-     const char *uri, OSSL_LIB_CTX *libctx, const char *propq,
-     const UI_METHOD *ui_method, void *ui_data);
-
-typedef OSSL_STORE_LOADER_CTX *(*OSSL_STORE_attach_fn)
-    (const OSSL_STORE_LOADER *loader, BIO *bio,
-     OSSL_LIB_CTX *libctx, const char *propq,
-     const UI_METHOD *ui_method, void *ui_data);
-typedef int (*OSSL_STORE_ctrl_fn)
-    (OSSL_STORE_LOADER_CTX *ctx, int cmd, va_list args);
-typedef int (*OSSL_STORE_expect_fn)
-    (OSSL_STORE_LOADER_CTX *ctx, int expected);
-typedef int (*OSSL_STORE_find_fn)
-    (OSSL_STORE_LOADER_CTX *ctx, const OSSL_STORE_SEARCH *criteria);
-typedef OSSL_STORE_INFO *(*OSSL_STORE_load_fn)
-    (OSSL_STORE_LOADER_CTX *ctx, const UI_METHOD *ui_method, void *ui_data);
-typedef int (*OSSL_STORE_eof_fn)(OSSL_STORE_LOADER_CTX *ctx);
-typedef int (*OSSL_STORE_error_fn)(OSSL_STORE_LOADER_CTX *ctx);
-typedef int (*OSSL_STORE_close_fn)(OSSL_STORE_LOADER_CTX *ctx);
-
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-OSSL_STORE_LOADER *OSSL_STORE_LOADER_new(ENGINE *e, const char *scheme);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER *loader,
-                               OSSL_STORE_open_fn open_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_open_ex(OSSL_STORE_LOADER *loader,
-                                  OSSL_STORE_open_ex_fn open_ex_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_attach(OSSL_STORE_LOADER *loader,
-                                 OSSL_STORE_attach_fn attach_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER *loader,
-                               OSSL_STORE_ctrl_fn ctrl_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER *loader,
-                                 OSSL_STORE_expect_fn expect_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER *loader,
-                               OSSL_STORE_find_fn find_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER *loader,
-                               OSSL_STORE_load_fn load_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER *loader,
-                              OSSL_STORE_eof_fn eof_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER *loader,
-                                OSSL_STORE_error_fn error_function);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER *loader,
-                                OSSL_STORE_close_fn close_function);
-OSSL_DEPRECATEDIN_3_0
-const ENGINE *OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER *loader);
-OSSL_DEPRECATEDIN_3_0
-const char * OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER *loader);
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_register_loader(OSSL_STORE_LOADER *loader);
-OSSL_DEPRECATEDIN_3_0
-OSSL_STORE_LOADER *OSSL_STORE_unregister_loader(const char *scheme);
-# endif
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    OSSL_STORE_LOADER* OSSL_STORE_LOADER_new(ENGINE* e, const char* scheme);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_open(OSSL_STORE_LOADER* loader, OSSL_STORE_open_fn open_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_open_ex(OSSL_STORE_LOADER* loader, OSSL_STORE_open_ex_fn open_ex_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_attach(OSSL_STORE_LOADER* loader, OSSL_STORE_attach_fn attach_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_ctrl(OSSL_STORE_LOADER* loader, OSSL_STORE_ctrl_fn ctrl_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_expect(OSSL_STORE_LOADER* loader, OSSL_STORE_expect_fn expect_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_find(OSSL_STORE_LOADER* loader, OSSL_STORE_find_fn find_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_load(OSSL_STORE_LOADER* loader, OSSL_STORE_load_fn load_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_eof(OSSL_STORE_LOADER* loader, OSSL_STORE_eof_fn eof_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_error(OSSL_STORE_LOADER* loader, OSSL_STORE_error_fn error_function);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_LOADER_set_close(OSSL_STORE_LOADER* loader, OSSL_STORE_close_fn close_function);
+    OSSL_DEPRECATEDIN_3_0
+    const ENGINE* OSSL_STORE_LOADER_get0_engine(const OSSL_STORE_LOADER* loader);
+    OSSL_DEPRECATEDIN_3_0
+    const char* OSSL_STORE_LOADER_get0_scheme(const OSSL_STORE_LOADER* loader);
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_register_loader(OSSL_STORE_LOADER* loader);
+    OSSL_DEPRECATEDIN_3_0
+    OSSL_STORE_LOADER* OSSL_STORE_unregister_loader(const char* scheme);
+#endif
 
 /*-
  *  Functions to list STORE loaders
  *  -------------------------------
  */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int OSSL_STORE_do_all_loaders(void (*do_function)(const OSSL_STORE_LOADER *loader,
-                                                  void *do_arg),
-                              void *do_arg);
-# endif
-
-# ifdef  __cplusplus
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0
+    int OSSL_STORE_do_all_loaders(void (*do_function)(const OSSL_STORE_LOADER* loader, void* do_arg), void* do_arg);
+#endif
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/storeerr.h b/CAPI/cpp/grpc/include/openssl/storeerr.h
index 00529c8..a61bee1 100644
--- a/CAPI/cpp/grpc/include/openssl/storeerr.h
+++ b/CAPI/cpp/grpc/include/openssl/storeerr.h
@@ -9,41 +9,39 @@
  */
 
 #ifndef OPENSSL_STOREERR_H
-# define OPENSSL_STOREERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_STOREERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * OSSL_STORE reason codes.
  */
-# define OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE              107
-# define OSSL_STORE_R_BAD_PASSWORD_READ                   115
-# define OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC          113
-# define OSSL_STORE_R_FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST 121
-# define OSSL_STORE_R_INVALID_SCHEME                      106
-# define OSSL_STORE_R_IS_NOT_A                            112
-# define OSSL_STORE_R_LOADER_INCOMPLETE                   116
-# define OSSL_STORE_R_LOADING_STARTED                     117
-# define OSSL_STORE_R_NOT_A_CERTIFICATE                   100
-# define OSSL_STORE_R_NOT_A_CRL                           101
-# define OSSL_STORE_R_NOT_A_NAME                          103
-# define OSSL_STORE_R_NOT_A_PRIVATE_KEY                   102
-# define OSSL_STORE_R_NOT_A_PUBLIC_KEY                    122
-# define OSSL_STORE_R_NOT_PARAMETERS                      104
-# define OSSL_STORE_R_NO_LOADERS_FOUND                    123
-# define OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR           114
-# define OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE               108
-# define OSSL_STORE_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES 119
-# define OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED 109
-# define OSSL_STORE_R_UNREGISTERED_SCHEME                 105
-# define OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE            110
-# define OSSL_STORE_R_UNSUPPORTED_OPERATION               118
-# define OSSL_STORE_R_UNSUPPORTED_SEARCH_TYPE             120
-# define OSSL_STORE_R_URI_AUTHORITY_UNSUPPORTED           111
+#define OSSL_STORE_R_AMBIGUOUS_CONTENT_TYPE 107
+#define OSSL_STORE_R_BAD_PASSWORD_READ 115
+#define OSSL_STORE_R_ERROR_VERIFYING_PKCS12_MAC 113
+#define OSSL_STORE_R_FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST 121
+#define OSSL_STORE_R_INVALID_SCHEME 106
+#define OSSL_STORE_R_IS_NOT_A 112
+#define OSSL_STORE_R_LOADER_INCOMPLETE 116
+#define OSSL_STORE_R_LOADING_STARTED 117
+#define OSSL_STORE_R_NOT_A_CERTIFICATE 100
+#define OSSL_STORE_R_NOT_A_CRL 101
+#define OSSL_STORE_R_NOT_A_NAME 103
+#define OSSL_STORE_R_NOT_A_PRIVATE_KEY 102
+#define OSSL_STORE_R_NOT_A_PUBLIC_KEY 122
+#define OSSL_STORE_R_NOT_PARAMETERS 104
+#define OSSL_STORE_R_NO_LOADERS_FOUND 123
+#define OSSL_STORE_R_PASSPHRASE_CALLBACK_ERROR 114
+#define OSSL_STORE_R_PATH_MUST_BE_ABSOLUTE 108
+#define OSSL_STORE_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES 119
+#define OSSL_STORE_R_UI_PROCESS_INTERRUPTED_OR_CANCELLED 109
+#define OSSL_STORE_R_UNREGISTERED_SCHEME 105
+#define OSSL_STORE_R_UNSUPPORTED_CONTENT_TYPE 110
+#define OSSL_STORE_R_UNSUPPORTED_OPERATION 118
+#define OSSL_STORE_R_UNSUPPORTED_SEARCH_TYPE 120
+#define OSSL_STORE_R_URI_AUTHORITY_UNSUPPORTED 111
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/symhacks.h b/CAPI/cpp/grpc/include/openssl/symhacks.h
index 816f8f9..d041395 100644
--- a/CAPI/cpp/grpc/include/openssl/symhacks.h
+++ b/CAPI/cpp/grpc/include/openssl/symhacks.h
@@ -8,32 +8,32 @@
  */
 
 #ifndef OPENSSL_SYMHACKS_H
-# define OPENSSL_SYMHACKS_H
-# pragma once
+#define OPENSSL_SYMHACKS_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_SYMHACKS_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_SYMHACKS_H
+#endif
 
-# include <openssl/e_os2.h>
+#include <openssl/e_os2.h>
 
 /* Case insensitive linking causes problems.... */
-# if defined(OPENSSL_SYS_VMS)
-#  undef ERR_load_CRYPTO_strings
-#  define ERR_load_CRYPTO_strings                 ERR_load_CRYPTOlib_strings
-#  undef OCSP_crlID_new
-#  define OCSP_crlID_new                          OCSP_crlID2_new
+#if defined(OPENSSL_SYS_VMS)
+#undef ERR_load_CRYPTO_strings
+#define ERR_load_CRYPTO_strings ERR_load_CRYPTOlib_strings
+#undef OCSP_crlID_new
+#define OCSP_crlID_new OCSP_crlID2_new
 
-#  undef d2i_ECPARAMETERS
-#  define d2i_ECPARAMETERS                        d2i_UC_ECPARAMETERS
-#  undef i2d_ECPARAMETERS
-#  define i2d_ECPARAMETERS                        i2d_UC_ECPARAMETERS
-#  undef d2i_ECPKPARAMETERS
-#  define d2i_ECPKPARAMETERS                      d2i_UC_ECPKPARAMETERS
-#  undef i2d_ECPKPARAMETERS
-#  define i2d_ECPKPARAMETERS                      i2d_UC_ECPKPARAMETERS
+#undef d2i_ECPARAMETERS
+#define d2i_ECPARAMETERS d2i_UC_ECPARAMETERS
+#undef i2d_ECPARAMETERS
+#define i2d_ECPARAMETERS i2d_UC_ECPARAMETERS
+#undef d2i_ECPKPARAMETERS
+#define d2i_ECPKPARAMETERS d2i_UC_ECPKPARAMETERS
+#undef i2d_ECPKPARAMETERS
+#define i2d_ECPKPARAMETERS i2d_UC_ECPKPARAMETERS
 
-# endif
+#endif
 
-#endif                          /* ! defined HEADER_VMS_IDHACKS_H */
+#endif /* ! defined HEADER_VMS_IDHACKS_H */
diff --git a/CAPI/cpp/grpc/include/openssl/tls1.h b/CAPI/cpp/grpc/include/openssl/tls1.h
index d6e9331..a6dabf1 100644
--- a/CAPI/cpp/grpc/include/openssl/tls1.h
+++ b/CAPI/cpp/grpc/include/openssl/tls1.h
@@ -10,807 +10,788 @@
  */
 
 #ifndef OPENSSL_TLS1_H
-# define OPENSSL_TLS1_H
-# pragma once
+#define OPENSSL_TLS1_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_TLS1_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_TLS1_H
+#endif
 
-# include <openssl/buffer.h>
-# include <openssl/x509.h>
-# include <openssl/prov_ssl.h>
+#include <openssl/buffer.h>
+#include <openssl/x509.h>
+#include <openssl/prov_ssl.h>
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 /* Default security level if not overridden at config time */
-# ifndef OPENSSL_TLS_SECURITY_LEVEL
-#  define OPENSSL_TLS_SECURITY_LEVEL 1
-# endif
+#ifndef OPENSSL_TLS_SECURITY_LEVEL
+#define OPENSSL_TLS_SECURITY_LEVEL 1
+#endif
 
 /* TLS*_VERSION constants are defined in prov_ssl.h */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define TLS_MAX_VERSION                TLS1_3_VERSION
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define TLS_MAX_VERSION TLS1_3_VERSION
+#endif
 
 /* Special value for method supporting multiple versions */
-# define TLS_ANY_VERSION                 0x10000
-
-# define TLS1_VERSION_MAJOR              0x03
-# define TLS1_VERSION_MINOR              0x01
-
-# define TLS1_1_VERSION_MAJOR            0x03
-# define TLS1_1_VERSION_MINOR            0x02
-
-# define TLS1_2_VERSION_MAJOR            0x03
-# define TLS1_2_VERSION_MINOR            0x03
-
-# define TLS1_get_version(s) \
-        ((SSL_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_version(s) : 0)
-
-# define TLS1_get_client_version(s) \
-        ((SSL_client_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_client_version(s) : 0)
-
-# define TLS1_AD_DECRYPTION_FAILED       21
-# define TLS1_AD_RECORD_OVERFLOW         22
-# define TLS1_AD_UNKNOWN_CA              48/* fatal */
-# define TLS1_AD_ACCESS_DENIED           49/* fatal */
-# define TLS1_AD_DECODE_ERROR            50/* fatal */
-# define TLS1_AD_DECRYPT_ERROR           51
-# define TLS1_AD_EXPORT_RESTRICTION      60/* fatal */
-# define TLS1_AD_PROTOCOL_VERSION        70/* fatal */
-# define TLS1_AD_INSUFFICIENT_SECURITY   71/* fatal */
-# define TLS1_AD_INTERNAL_ERROR          80/* fatal */
-# define TLS1_AD_INAPPROPRIATE_FALLBACK  86/* fatal */
-# define TLS1_AD_USER_CANCELLED          90
-# define TLS1_AD_NO_RENEGOTIATION        100
+#define TLS_ANY_VERSION 0x10000
+
+#define TLS1_VERSION_MAJOR 0x03
+#define TLS1_VERSION_MINOR 0x01
+
+#define TLS1_1_VERSION_MAJOR 0x03
+#define TLS1_1_VERSION_MINOR 0x02
+
+#define TLS1_2_VERSION_MAJOR 0x03
+#define TLS1_2_VERSION_MINOR 0x03
+
+#define TLS1_get_version(s) \
+    ((SSL_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_version(s) : 0)
+
+#define TLS1_get_client_version(s) \
+    ((SSL_client_version(s) >> 8) == TLS1_VERSION_MAJOR ? SSL_client_version(s) : 0)
+
+#define TLS1_AD_DECRYPTION_FAILED 21
+#define TLS1_AD_RECORD_OVERFLOW 22
+#define TLS1_AD_UNKNOWN_CA 48    /* fatal */
+#define TLS1_AD_ACCESS_DENIED 49 /* fatal */
+#define TLS1_AD_DECODE_ERROR 50  /* fatal */
+#define TLS1_AD_DECRYPT_ERROR 51
+#define TLS1_AD_EXPORT_RESTRICTION 60     /* fatal */
+#define TLS1_AD_PROTOCOL_VERSION 70       /* fatal */
+#define TLS1_AD_INSUFFICIENT_SECURITY 71  /* fatal */
+#define TLS1_AD_INTERNAL_ERROR 80         /* fatal */
+#define TLS1_AD_INAPPROPRIATE_FALLBACK 86 /* fatal */
+#define TLS1_AD_USER_CANCELLED 90
+#define TLS1_AD_NO_RENEGOTIATION 100
 /* TLSv1.3 alerts */
-# define TLS13_AD_MISSING_EXTENSION      109 /* fatal */
-# define TLS13_AD_CERTIFICATE_REQUIRED   116 /* fatal */
+#define TLS13_AD_MISSING_EXTENSION 109    /* fatal */
+#define TLS13_AD_CERTIFICATE_REQUIRED 116 /* fatal */
 /* codes 110-114 are from RFC3546 */
-# define TLS1_AD_UNSUPPORTED_EXTENSION   110
-# define TLS1_AD_CERTIFICATE_UNOBTAINABLE 111
-# define TLS1_AD_UNRECOGNIZED_NAME       112
-# define TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE 113
-# define TLS1_AD_BAD_CERTIFICATE_HASH_VALUE 114
-# define TLS1_AD_UNKNOWN_PSK_IDENTITY    115/* fatal */
-# define TLS1_AD_NO_APPLICATION_PROTOCOL 120 /* fatal */
+#define TLS1_AD_UNSUPPORTED_EXTENSION 110
+#define TLS1_AD_CERTIFICATE_UNOBTAINABLE 111
+#define TLS1_AD_UNRECOGNIZED_NAME 112
+#define TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE 113
+#define TLS1_AD_BAD_CERTIFICATE_HASH_VALUE 114
+#define TLS1_AD_UNKNOWN_PSK_IDENTITY 115    /* fatal */
+#define TLS1_AD_NO_APPLICATION_PROTOCOL 120 /* fatal */
 
 /* ExtensionType values from RFC3546 / RFC4366 / RFC6066 */
-# define TLSEXT_TYPE_server_name                 0
-# define TLSEXT_TYPE_max_fragment_length         1
-# define TLSEXT_TYPE_client_certificate_url      2
-# define TLSEXT_TYPE_trusted_ca_keys             3
-# define TLSEXT_TYPE_truncated_hmac              4
-# define TLSEXT_TYPE_status_request              5
+#define TLSEXT_TYPE_server_name 0
+#define TLSEXT_TYPE_max_fragment_length 1
+#define TLSEXT_TYPE_client_certificate_url 2
+#define TLSEXT_TYPE_trusted_ca_keys 3
+#define TLSEXT_TYPE_truncated_hmac 4
+#define TLSEXT_TYPE_status_request 5
 /* ExtensionType values from RFC4681 */
-# define TLSEXT_TYPE_user_mapping                6
+#define TLSEXT_TYPE_user_mapping 6
 /* ExtensionType values from RFC5878 */
-# define TLSEXT_TYPE_client_authz                7
-# define TLSEXT_TYPE_server_authz                8
+#define TLSEXT_TYPE_client_authz 7
+#define TLSEXT_TYPE_server_authz 8
 /* ExtensionType values from RFC6091 */
-# define TLSEXT_TYPE_cert_type           9
+#define TLSEXT_TYPE_cert_type 9
 
 /* ExtensionType values from RFC4492 */
 /*
  * Prior to TLSv1.3 the supported_groups extension was known as
  * elliptic_curves
  */
-# define TLSEXT_TYPE_supported_groups            10
-# define TLSEXT_TYPE_elliptic_curves             TLSEXT_TYPE_supported_groups
-# define TLSEXT_TYPE_ec_point_formats            11
-
+#define TLSEXT_TYPE_supported_groups 10
+#define TLSEXT_TYPE_elliptic_curves TLSEXT_TYPE_supported_groups
+#define TLSEXT_TYPE_ec_point_formats 11
 
 /* ExtensionType value from RFC5054 */
-# define TLSEXT_TYPE_srp                         12
+#define TLSEXT_TYPE_srp 12
 
 /* ExtensionType values from RFC5246 */
-# define TLSEXT_TYPE_signature_algorithms        13
+#define TLSEXT_TYPE_signature_algorithms 13
 
 /* ExtensionType value from RFC5764 */
-# define TLSEXT_TYPE_use_srtp    14
+#define TLSEXT_TYPE_use_srtp 14
 
 /* ExtensionType value from RFC7301 */
-# define TLSEXT_TYPE_application_layer_protocol_negotiation 16
+#define TLSEXT_TYPE_application_layer_protocol_negotiation 16
 
 /*
  * Extension type for Certificate Transparency
  * https://tools.ietf.org/html/rfc6962#section-3.3.1
  */
-# define TLSEXT_TYPE_signed_certificate_timestamp    18
+#define TLSEXT_TYPE_signed_certificate_timestamp 18
 
 /*
  * ExtensionType value for TLS padding extension.
  * http://tools.ietf.org/html/draft-agl-tls-padding
  */
-# define TLSEXT_TYPE_padding     21
+#define TLSEXT_TYPE_padding 21
 
 /* ExtensionType value from RFC7366 */
-# define TLSEXT_TYPE_encrypt_then_mac    22
+#define TLSEXT_TYPE_encrypt_then_mac 22
 
 /* ExtensionType value from RFC7627 */
-# define TLSEXT_TYPE_extended_master_secret      23
+#define TLSEXT_TYPE_extended_master_secret 23
 
 /* ExtensionType value from RFC4507 */
-# define TLSEXT_TYPE_session_ticket              35
+#define TLSEXT_TYPE_session_ticket 35
 
 /* As defined for TLS1.3 */
-# define TLSEXT_TYPE_psk                         41
-# define TLSEXT_TYPE_early_data                  42
-# define TLSEXT_TYPE_supported_versions          43
-# define TLSEXT_TYPE_cookie                      44
-# define TLSEXT_TYPE_psk_kex_modes               45
-# define TLSEXT_TYPE_certificate_authorities     47
-# define TLSEXT_TYPE_post_handshake_auth         49
-# define TLSEXT_TYPE_signature_algorithms_cert   50
-# define TLSEXT_TYPE_key_share                   51
+#define TLSEXT_TYPE_psk 41
+#define TLSEXT_TYPE_early_data 42
+#define TLSEXT_TYPE_supported_versions 43
+#define TLSEXT_TYPE_cookie 44
+#define TLSEXT_TYPE_psk_kex_modes 45
+#define TLSEXT_TYPE_certificate_authorities 47
+#define TLSEXT_TYPE_post_handshake_auth 49
+#define TLSEXT_TYPE_signature_algorithms_cert 50
+#define TLSEXT_TYPE_key_share 51
 
 /* Temporary extension type */
-# define TLSEXT_TYPE_renegotiate                 0xff01
+#define TLSEXT_TYPE_renegotiate 0xff01
 
-# ifndef OPENSSL_NO_NEXTPROTONEG
+#ifndef OPENSSL_NO_NEXTPROTONEG
 /* This is not an IANA defined extension number */
-#  define TLSEXT_TYPE_next_proto_neg              13172
-# endif
+#define TLSEXT_TYPE_next_proto_neg 13172
+#endif
 
 /* NameType value from RFC3546 */
-# define TLSEXT_NAMETYPE_host_name 0
+#define TLSEXT_NAMETYPE_host_name 0
 /* status request value from RFC3546 */
-# define TLSEXT_STATUSTYPE_ocsp 1
+#define TLSEXT_STATUSTYPE_ocsp 1
 
 /* ECPointFormat values from RFC4492 */
-# define TLSEXT_ECPOINTFORMAT_first                      0
-# define TLSEXT_ECPOINTFORMAT_uncompressed               0
-# define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime  1
-# define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2  2
-# define TLSEXT_ECPOINTFORMAT_last                       2
+#define TLSEXT_ECPOINTFORMAT_first 0
+#define TLSEXT_ECPOINTFORMAT_uncompressed 0
+#define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime 1
+#define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2 2
+#define TLSEXT_ECPOINTFORMAT_last 2
 
 /* Signature and hash algorithms from RFC5246 */
-# define TLSEXT_signature_anonymous                      0
-# define TLSEXT_signature_rsa                            1
-# define TLSEXT_signature_dsa                            2
-# define TLSEXT_signature_ecdsa                          3
-# define TLSEXT_signature_gostr34102001                  237
-# define TLSEXT_signature_gostr34102012_256              238
-# define TLSEXT_signature_gostr34102012_512              239
+#define TLSEXT_signature_anonymous 0
+#define TLSEXT_signature_rsa 1
+#define TLSEXT_signature_dsa 2
+#define TLSEXT_signature_ecdsa 3
+#define TLSEXT_signature_gostr34102001 237
+#define TLSEXT_signature_gostr34102012_256 238
+#define TLSEXT_signature_gostr34102012_512 239
 
 /* Total number of different signature algorithms */
-# define TLSEXT_signature_num                            7
+#define TLSEXT_signature_num 7
 
-# define TLSEXT_hash_none                                0
-# define TLSEXT_hash_md5                                 1
-# define TLSEXT_hash_sha1                                2
-# define TLSEXT_hash_sha224                              3
-# define TLSEXT_hash_sha256                              4
-# define TLSEXT_hash_sha384                              5
-# define TLSEXT_hash_sha512                              6
-# define TLSEXT_hash_gostr3411                           237
-# define TLSEXT_hash_gostr34112012_256                   238
-# define TLSEXT_hash_gostr34112012_512                   239
+#define TLSEXT_hash_none 0
+#define TLSEXT_hash_md5 1
+#define TLSEXT_hash_sha1 2
+#define TLSEXT_hash_sha224 3
+#define TLSEXT_hash_sha256 4
+#define TLSEXT_hash_sha384 5
+#define TLSEXT_hash_sha512 6
+#define TLSEXT_hash_gostr3411 237
+#define TLSEXT_hash_gostr34112012_256 238
+#define TLSEXT_hash_gostr34112012_512 239
 
-/* Total number of different digest algorithms */
+    /* Total number of different digest algorithms */
 
-# define TLSEXT_hash_num                                 10
+#define TLSEXT_hash_num 10
 
 /* Flag set for unrecognised algorithms */
-# define TLSEXT_nid_unknown                              0x1000000
+#define TLSEXT_nid_unknown 0x1000000
 
-/* ECC curves */
+    /* ECC curves */
 
-# define TLSEXT_curve_P_256                              23
-# define TLSEXT_curve_P_384                              24
+#define TLSEXT_curve_P_256 23
+#define TLSEXT_curve_P_384 24
 
 /* OpenSSL value to disable maximum fragment length extension */
-# define TLSEXT_max_fragment_length_DISABLED    0
+#define TLSEXT_max_fragment_length_DISABLED 0
 /* Allowed values for max fragment length extension */
-# define TLSEXT_max_fragment_length_512         1
-# define TLSEXT_max_fragment_length_1024        2
-# define TLSEXT_max_fragment_length_2048        3
-# define TLSEXT_max_fragment_length_4096        4
+#define TLSEXT_max_fragment_length_512 1
+#define TLSEXT_max_fragment_length_1024 2
+#define TLSEXT_max_fragment_length_2048 3
+#define TLSEXT_max_fragment_length_4096 4
 
-int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX *ctx, uint8_t mode);
-int SSL_set_tlsext_max_fragment_length(SSL *ssl, uint8_t mode);
+    int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX* ctx, uint8_t mode);
+    int SSL_set_tlsext_max_fragment_length(SSL* ssl, uint8_t mode);
 
-# define TLSEXT_MAXLEN_host_name 255
+#define TLSEXT_MAXLEN_host_name 255
 
-__owur const char *SSL_get_servername(const SSL *s, const int type);
-__owur int SSL_get_servername_type(const SSL *s);
-/*
- * SSL_export_keying_material exports a value derived from the master secret,
- * as specified in RFC 5705. It writes |olen| bytes to |out| given a label and
- * optional context. (Since a zero length context is allowed, the |use_context|
- * flag controls whether a context is included.) It returns 1 on success and
- * 0 or -1 otherwise.
- */
-__owur int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
-                                      const char *label, size_t llen,
-                                      const unsigned char *context,
-                                      size_t contextlen, int use_context);
+    __owur const char* SSL_get_servername(const SSL* s, const int type);
+    __owur int SSL_get_servername_type(const SSL* s);
+    /*
+     * SSL_export_keying_material exports a value derived from the master secret,
+     * as specified in RFC 5705. It writes |olen| bytes to |out| given a label and
+     * optional context. (Since a zero length context is allowed, the |use_context|
+     * flag controls whether a context is included.) It returns 1 on success and
+     * 0 or -1 otherwise.
+     */
+    __owur int SSL_export_keying_material(SSL* s, unsigned char* out, size_t olen, const char* label, size_t llen, const unsigned char* context, size_t contextlen, int use_context);
 
-/*
- * SSL_export_keying_material_early exports a value derived from the
- * early exporter master secret, as specified in
- * https://tools.ietf.org/html/draft-ietf-tls-tls13-23. It writes
- * |olen| bytes to |out| given a label and optional context. It
- * returns 1 on success and 0 otherwise.
- */
-__owur int SSL_export_keying_material_early(SSL *s, unsigned char *out,
-                                            size_t olen, const char *label,
-                                            size_t llen,
-                                            const unsigned char *context,
-                                            size_t contextlen);
+    /*
+     * SSL_export_keying_material_early exports a value derived from the
+     * early exporter master secret, as specified in
+     * https://tools.ietf.org/html/draft-ietf-tls-tls13-23. It writes
+     * |olen| bytes to |out| given a label and optional context. It
+     * returns 1 on success and 0 otherwise.
+     */
+    __owur int SSL_export_keying_material_early(SSL* s, unsigned char* out, size_t olen, const char* label, size_t llen, const unsigned char* context, size_t contextlen);
 
-int SSL_get_peer_signature_type_nid(const SSL *s, int *pnid);
-int SSL_get_signature_type_nid(const SSL *s, int *pnid);
+    int SSL_get_peer_signature_type_nid(const SSL* s, int* pnid);
+    int SSL_get_signature_type_nid(const SSL* s, int* pnid);
 
-int SSL_get_sigalgs(SSL *s, int idx,
-                    int *psign, int *phash, int *psignandhash,
-                    unsigned char *rsig, unsigned char *rhash);
+    int SSL_get_sigalgs(SSL* s, int idx, int* psign, int* phash, int* psignandhash, unsigned char* rsig, unsigned char* rhash);
 
-int SSL_get_shared_sigalgs(SSL *s, int idx,
-                           int *psign, int *phash, int *psignandhash,
-                           unsigned char *rsig, unsigned char *rhash);
+    int SSL_get_shared_sigalgs(SSL* s, int idx, int* psign, int* phash, int* psignandhash, unsigned char* rsig, unsigned char* rhash);
 
-__owur int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain);
+    __owur int SSL_check_chain(SSL* s, X509* x, EVP_PKEY* pk, STACK_OF(X509) * chain);
 
-# define SSL_set_tlsext_host_name(s,name) \
-        SSL_ctrl(s,SSL_CTRL_SET_TLSEXT_HOSTNAME,TLSEXT_NAMETYPE_host_name,\
-                (void *)name)
+#define SSL_set_tlsext_host_name(s, name) \
+    SSL_ctrl(s, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, (void*)name)
 
-# define SSL_set_tlsext_debug_callback(ssl, cb) \
-        SSL_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_CB,\
-                (void (*)(void))cb)
+#define SSL_set_tlsext_debug_callback(ssl, cb) \
+    SSL_callback_ctrl(ssl, SSL_CTRL_SET_TLSEXT_DEBUG_CB, (void (*)(void))cb)
 
-# define SSL_set_tlsext_debug_arg(ssl, arg) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_ARG,0,arg)
+#define SSL_set_tlsext_debug_arg(ssl, arg) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_TLSEXT_DEBUG_ARG, 0, arg)
 
-# define SSL_get_tlsext_status_type(ssl) \
-        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE,0,NULL)
+#define SSL_get_tlsext_status_type(ssl) \
+    SSL_ctrl(ssl, SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE, 0, NULL)
 
-# define SSL_set_tlsext_status_type(ssl, type) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type,NULL)
+#define SSL_set_tlsext_status_type(ssl, type) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE, type, NULL)
 
-# define SSL_get_tlsext_status_exts(ssl, arg) \
-        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS,0,arg)
+#define SSL_get_tlsext_status_exts(ssl, arg) \
+    SSL_ctrl(ssl, SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS, 0, arg)
 
-# define SSL_set_tlsext_status_exts(ssl, arg) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS,0,arg)
+#define SSL_set_tlsext_status_exts(ssl, arg) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS, 0, arg)
 
-# define SSL_get_tlsext_status_ids(ssl, arg) \
-        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS,0,arg)
+#define SSL_get_tlsext_status_ids(ssl, arg) \
+    SSL_ctrl(ssl, SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS, 0, arg)
 
-# define SSL_set_tlsext_status_ids(ssl, arg) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS,0,arg)
+#define SSL_set_tlsext_status_ids(ssl, arg) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS, 0, arg)
 
-# define SSL_get_tlsext_status_ocsp_resp(ssl, arg) \
-        SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP,0,arg)
+#define SSL_get_tlsext_status_ocsp_resp(ssl, arg) \
+    SSL_ctrl(ssl, SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP, 0, arg)
 
-# define SSL_set_tlsext_status_ocsp_resp(ssl, arg, arglen) \
-        SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP,arglen,arg)
+#define SSL_set_tlsext_status_ocsp_resp(ssl, arg, arglen) \
+    SSL_ctrl(ssl, SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP, arglen, arg)
 
-# define SSL_CTX_set_tlsext_servername_callback(ctx, cb) \
-        SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_CB,\
-                (void (*)(void))cb)
+#define SSL_CTX_set_tlsext_servername_callback(ctx, cb) \
+    SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TLSEXT_SERVERNAME_CB, (void (*)(void))cb)
 
-# define SSL_TLSEXT_ERR_OK 0
-# define SSL_TLSEXT_ERR_ALERT_WARNING 1
-# define SSL_TLSEXT_ERR_ALERT_FATAL 2
-# define SSL_TLSEXT_ERR_NOACK 3
+#define SSL_TLSEXT_ERR_OK 0
+#define SSL_TLSEXT_ERR_ALERT_WARNING 1
+#define SSL_TLSEXT_ERR_ALERT_FATAL 2
+#define SSL_TLSEXT_ERR_NOACK 3
 
-# define SSL_CTX_set_tlsext_servername_arg(ctx, arg) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG,0,arg)
+#define SSL_CTX_set_tlsext_servername_arg(ctx, arg) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG, 0, arg)
 
-# define SSL_CTX_get_tlsext_ticket_keys(ctx, keys, keylen) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_GET_TLSEXT_TICKET_KEYS,keylen,keys)
-# define SSL_CTX_set_tlsext_ticket_keys(ctx, keys, keylen) \
-        SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_TICKET_KEYS,keylen,keys)
+#define SSL_CTX_get_tlsext_ticket_keys(ctx, keys, keylen) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_GET_TLSEXT_TICKET_KEYS, keylen, keys)
+#define SSL_CTX_set_tlsext_ticket_keys(ctx, keys, keylen) \
+    SSL_CTX_ctrl(ctx, SSL_CTRL_SET_TLSEXT_TICKET_KEYS, keylen, keys)
 
-# define SSL_CTX_get_tlsext_status_cb(ssl, cb) \
-        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB,0,(void *)cb)
-# define SSL_CTX_set_tlsext_status_cb(ssl, cb) \
-        SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB,\
-                (void (*)(void))cb)
+#define SSL_CTX_get_tlsext_status_cb(ssl, cb) \
+    SSL_CTX_ctrl(ssl, SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB, 0, (void*)cb)
+#define SSL_CTX_set_tlsext_status_cb(ssl, cb) \
+    SSL_CTX_callback_ctrl(ssl, SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB, (void (*)(void))cb)
 
-# define SSL_CTX_get_tlsext_status_arg(ssl, arg) \
-        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG,0,arg)
-# define SSL_CTX_set_tlsext_status_arg(ssl, arg) \
-        SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG,0,arg)
+#define SSL_CTX_get_tlsext_status_arg(ssl, arg) \
+    SSL_CTX_ctrl(ssl, SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG, 0, arg)
+#define SSL_CTX_set_tlsext_status_arg(ssl, arg) \
+    SSL_CTX_ctrl(ssl, SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG, 0, arg)
 
-# define SSL_CTX_set_tlsext_status_type(ssl, type) \
-        SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type,NULL)
+#define SSL_CTX_set_tlsext_status_type(ssl, type) \
+    SSL_CTX_ctrl(ssl, SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE, type, NULL)
 
-# define SSL_CTX_get_tlsext_status_type(ssl) \
-        SSL_CTX_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE,0,NULL)
+#define SSL_CTX_get_tlsext_status_type(ssl) \
+    SSL_CTX_ctrl(ssl, SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE, 0, NULL)
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define SSL_CTX_set_tlsext_ticket_key_cb(ssl, cb) \
-        SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB,\
-                (void (*)(void))cb)
-# endif
-int SSL_CTX_set_tlsext_ticket_key_evp_cb
-    (SSL_CTX *ctx, int (*fp)(SSL *, unsigned char *, unsigned char *,
-                             EVP_CIPHER_CTX *, EVP_MAC_CTX *, int));
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define SSL_CTX_set_tlsext_ticket_key_cb(ssl, cb) \
+    SSL_CTX_callback_ctrl(ssl, SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB, (void (*)(void))cb)
+#endif
+    int SSL_CTX_set_tlsext_ticket_key_evp_cb(SSL_CTX* ctx, int (*fp)(SSL*, unsigned char*, unsigned char*, EVP_CIPHER_CTX*, EVP_MAC_CTX*, int));
 
 /* PSK ciphersuites from 4279 */
-# define TLS1_CK_PSK_WITH_RC4_128_SHA                    0x0300008A
-# define TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA               0x0300008B
-# define TLS1_CK_PSK_WITH_AES_128_CBC_SHA                0x0300008C
-# define TLS1_CK_PSK_WITH_AES_256_CBC_SHA                0x0300008D
-# define TLS1_CK_DHE_PSK_WITH_RC4_128_SHA                0x0300008E
-# define TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA           0x0300008F
-# define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA            0x03000090
-# define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA            0x03000091
-# define TLS1_CK_RSA_PSK_WITH_RC4_128_SHA                0x03000092
-# define TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA           0x03000093
-# define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA            0x03000094
-# define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA            0x03000095
+#define TLS1_CK_PSK_WITH_RC4_128_SHA 0x0300008A
+#define TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA 0x0300008B
+#define TLS1_CK_PSK_WITH_AES_128_CBC_SHA 0x0300008C
+#define TLS1_CK_PSK_WITH_AES_256_CBC_SHA 0x0300008D
+#define TLS1_CK_DHE_PSK_WITH_RC4_128_SHA 0x0300008E
+#define TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA 0x0300008F
+#define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA 0x03000090
+#define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA 0x03000091
+#define TLS1_CK_RSA_PSK_WITH_RC4_128_SHA 0x03000092
+#define TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA 0x03000093
+#define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA 0x03000094
+#define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA 0x03000095
 
 /* PSK ciphersuites from 5487 */
-# define TLS1_CK_PSK_WITH_AES_128_GCM_SHA256             0x030000A8
-# define TLS1_CK_PSK_WITH_AES_256_GCM_SHA384             0x030000A9
-# define TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256         0x030000AA
-# define TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384         0x030000AB
-# define TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256         0x030000AC
-# define TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384         0x030000AD
-# define TLS1_CK_PSK_WITH_AES_128_CBC_SHA256             0x030000AE
-# define TLS1_CK_PSK_WITH_AES_256_CBC_SHA384             0x030000AF
-# define TLS1_CK_PSK_WITH_NULL_SHA256                    0x030000B0
-# define TLS1_CK_PSK_WITH_NULL_SHA384                    0x030000B1
-# define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256         0x030000B2
-# define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384         0x030000B3
-# define TLS1_CK_DHE_PSK_WITH_NULL_SHA256                0x030000B4
-# define TLS1_CK_DHE_PSK_WITH_NULL_SHA384                0x030000B5
-# define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256         0x030000B6
-# define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384         0x030000B7
-# define TLS1_CK_RSA_PSK_WITH_NULL_SHA256                0x030000B8
-# define TLS1_CK_RSA_PSK_WITH_NULL_SHA384                0x030000B9
+#define TLS1_CK_PSK_WITH_AES_128_GCM_SHA256 0x030000A8
+#define TLS1_CK_PSK_WITH_AES_256_GCM_SHA384 0x030000A9
+#define TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256 0x030000AA
+#define TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384 0x030000AB
+#define TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256 0x030000AC
+#define TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384 0x030000AD
+#define TLS1_CK_PSK_WITH_AES_128_CBC_SHA256 0x030000AE
+#define TLS1_CK_PSK_WITH_AES_256_CBC_SHA384 0x030000AF
+#define TLS1_CK_PSK_WITH_NULL_SHA256 0x030000B0
+#define TLS1_CK_PSK_WITH_NULL_SHA384 0x030000B1
+#define TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256 0x030000B2
+#define TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384 0x030000B3
+#define TLS1_CK_DHE_PSK_WITH_NULL_SHA256 0x030000B4
+#define TLS1_CK_DHE_PSK_WITH_NULL_SHA384 0x030000B5
+#define TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256 0x030000B6
+#define TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384 0x030000B7
+#define TLS1_CK_RSA_PSK_WITH_NULL_SHA256 0x030000B8
+#define TLS1_CK_RSA_PSK_WITH_NULL_SHA384 0x030000B9
 
 /* NULL PSK ciphersuites from RFC4785 */
-# define TLS1_CK_PSK_WITH_NULL_SHA                       0x0300002C
-# define TLS1_CK_DHE_PSK_WITH_NULL_SHA                   0x0300002D
-# define TLS1_CK_RSA_PSK_WITH_NULL_SHA                   0x0300002E
+#define TLS1_CK_PSK_WITH_NULL_SHA 0x0300002C
+#define TLS1_CK_DHE_PSK_WITH_NULL_SHA 0x0300002D
+#define TLS1_CK_RSA_PSK_WITH_NULL_SHA 0x0300002E
 
 /* AES ciphersuites from RFC3268 */
-# define TLS1_CK_RSA_WITH_AES_128_SHA                    0x0300002F
-# define TLS1_CK_DH_DSS_WITH_AES_128_SHA                 0x03000030
-# define TLS1_CK_DH_RSA_WITH_AES_128_SHA                 0x03000031
-# define TLS1_CK_DHE_DSS_WITH_AES_128_SHA                0x03000032
-# define TLS1_CK_DHE_RSA_WITH_AES_128_SHA                0x03000033
-# define TLS1_CK_ADH_WITH_AES_128_SHA                    0x03000034
-# define TLS1_CK_RSA_WITH_AES_256_SHA                    0x03000035
-# define TLS1_CK_DH_DSS_WITH_AES_256_SHA                 0x03000036
-# define TLS1_CK_DH_RSA_WITH_AES_256_SHA                 0x03000037
-# define TLS1_CK_DHE_DSS_WITH_AES_256_SHA                0x03000038
-# define TLS1_CK_DHE_RSA_WITH_AES_256_SHA                0x03000039
-# define TLS1_CK_ADH_WITH_AES_256_SHA                    0x0300003A
+#define TLS1_CK_RSA_WITH_AES_128_SHA 0x0300002F
+#define TLS1_CK_DH_DSS_WITH_AES_128_SHA 0x03000030
+#define TLS1_CK_DH_RSA_WITH_AES_128_SHA 0x03000031
+#define TLS1_CK_DHE_DSS_WITH_AES_128_SHA 0x03000032
+#define TLS1_CK_DHE_RSA_WITH_AES_128_SHA 0x03000033
+#define TLS1_CK_ADH_WITH_AES_128_SHA 0x03000034
+#define TLS1_CK_RSA_WITH_AES_256_SHA 0x03000035
+#define TLS1_CK_DH_DSS_WITH_AES_256_SHA 0x03000036
+#define TLS1_CK_DH_RSA_WITH_AES_256_SHA 0x03000037
+#define TLS1_CK_DHE_DSS_WITH_AES_256_SHA 0x03000038
+#define TLS1_CK_DHE_RSA_WITH_AES_256_SHA 0x03000039
+#define TLS1_CK_ADH_WITH_AES_256_SHA 0x0300003A
 
 /* TLS v1.2 ciphersuites */
-# define TLS1_CK_RSA_WITH_NULL_SHA256                    0x0300003B
-# define TLS1_CK_RSA_WITH_AES_128_SHA256                 0x0300003C
-# define TLS1_CK_RSA_WITH_AES_256_SHA256                 0x0300003D
-# define TLS1_CK_DH_DSS_WITH_AES_128_SHA256              0x0300003E
-# define TLS1_CK_DH_RSA_WITH_AES_128_SHA256              0x0300003F
-# define TLS1_CK_DHE_DSS_WITH_AES_128_SHA256             0x03000040
+#define TLS1_CK_RSA_WITH_NULL_SHA256 0x0300003B
+#define TLS1_CK_RSA_WITH_AES_128_SHA256 0x0300003C
+#define TLS1_CK_RSA_WITH_AES_256_SHA256 0x0300003D
+#define TLS1_CK_DH_DSS_WITH_AES_128_SHA256 0x0300003E
+#define TLS1_CK_DH_RSA_WITH_AES_128_SHA256 0x0300003F
+#define TLS1_CK_DHE_DSS_WITH_AES_128_SHA256 0x03000040
 
 /* Camellia ciphersuites from RFC4132 */
-# define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA           0x03000041
-# define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA        0x03000042
-# define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA        0x03000043
-# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA       0x03000044
-# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA       0x03000045
-# define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA           0x03000046
+#define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000041
+#define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA 0x03000042
+#define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000043
+#define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA 0x03000044
+#define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000045
+#define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA 0x03000046
 
 /* TLS v1.2 ciphersuites */
-# define TLS1_CK_DHE_RSA_WITH_AES_128_SHA256             0x03000067
-# define TLS1_CK_DH_DSS_WITH_AES_256_SHA256              0x03000068
-# define TLS1_CK_DH_RSA_WITH_AES_256_SHA256              0x03000069
-# define TLS1_CK_DHE_DSS_WITH_AES_256_SHA256             0x0300006A
-# define TLS1_CK_DHE_RSA_WITH_AES_256_SHA256             0x0300006B
-# define TLS1_CK_ADH_WITH_AES_128_SHA256                 0x0300006C
-# define TLS1_CK_ADH_WITH_AES_256_SHA256                 0x0300006D
+#define TLS1_CK_DHE_RSA_WITH_AES_128_SHA256 0x03000067
+#define TLS1_CK_DH_DSS_WITH_AES_256_SHA256 0x03000068
+#define TLS1_CK_DH_RSA_WITH_AES_256_SHA256 0x03000069
+#define TLS1_CK_DHE_DSS_WITH_AES_256_SHA256 0x0300006A
+#define TLS1_CK_DHE_RSA_WITH_AES_256_SHA256 0x0300006B
+#define TLS1_CK_ADH_WITH_AES_128_SHA256 0x0300006C
+#define TLS1_CK_ADH_WITH_AES_256_SHA256 0x0300006D
 
 /* Camellia ciphersuites from RFC4132 */
-# define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA           0x03000084
-# define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA        0x03000085
-# define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA        0x03000086
-# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA       0x03000087
-# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA       0x03000088
-# define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA           0x03000089
+#define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000084
+#define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA 0x03000085
+#define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000086
+#define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA 0x03000087
+#define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000088
+#define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA 0x03000089
 
 /* SEED ciphersuites from RFC4162 */
-# define TLS1_CK_RSA_WITH_SEED_SHA                       0x03000096
-# define TLS1_CK_DH_DSS_WITH_SEED_SHA                    0x03000097
-# define TLS1_CK_DH_RSA_WITH_SEED_SHA                    0x03000098
-# define TLS1_CK_DHE_DSS_WITH_SEED_SHA                   0x03000099
-# define TLS1_CK_DHE_RSA_WITH_SEED_SHA                   0x0300009A
-# define TLS1_CK_ADH_WITH_SEED_SHA                       0x0300009B
+#define TLS1_CK_RSA_WITH_SEED_SHA 0x03000096
+#define TLS1_CK_DH_DSS_WITH_SEED_SHA 0x03000097
+#define TLS1_CK_DH_RSA_WITH_SEED_SHA 0x03000098
+#define TLS1_CK_DHE_DSS_WITH_SEED_SHA 0x03000099
+#define TLS1_CK_DHE_RSA_WITH_SEED_SHA 0x0300009A
+#define TLS1_CK_ADH_WITH_SEED_SHA 0x0300009B
 
 /* TLS v1.2 GCM ciphersuites from RFC5288 */
-# define TLS1_CK_RSA_WITH_AES_128_GCM_SHA256             0x0300009C
-# define TLS1_CK_RSA_WITH_AES_256_GCM_SHA384             0x0300009D
-# define TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256         0x0300009E
-# define TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384         0x0300009F
-# define TLS1_CK_DH_RSA_WITH_AES_128_GCM_SHA256          0x030000A0
-# define TLS1_CK_DH_RSA_WITH_AES_256_GCM_SHA384          0x030000A1
-# define TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256         0x030000A2
-# define TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384         0x030000A3
-# define TLS1_CK_DH_DSS_WITH_AES_128_GCM_SHA256          0x030000A4
-# define TLS1_CK_DH_DSS_WITH_AES_256_GCM_SHA384          0x030000A5
-# define TLS1_CK_ADH_WITH_AES_128_GCM_SHA256             0x030000A6
-# define TLS1_CK_ADH_WITH_AES_256_GCM_SHA384             0x030000A7
+#define TLS1_CK_RSA_WITH_AES_128_GCM_SHA256 0x0300009C
+#define TLS1_CK_RSA_WITH_AES_256_GCM_SHA384 0x0300009D
+#define TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256 0x0300009E
+#define TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384 0x0300009F
+#define TLS1_CK_DH_RSA_WITH_AES_128_GCM_SHA256 0x030000A0
+#define TLS1_CK_DH_RSA_WITH_AES_256_GCM_SHA384 0x030000A1
+#define TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256 0x030000A2
+#define TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384 0x030000A3
+#define TLS1_CK_DH_DSS_WITH_AES_128_GCM_SHA256 0x030000A4
+#define TLS1_CK_DH_DSS_WITH_AES_256_GCM_SHA384 0x030000A5
+#define TLS1_CK_ADH_WITH_AES_128_GCM_SHA256 0x030000A6
+#define TLS1_CK_ADH_WITH_AES_256_GCM_SHA384 0x030000A7
 
 /* CCM ciphersuites from RFC6655 */
-# define TLS1_CK_RSA_WITH_AES_128_CCM                    0x0300C09C
-# define TLS1_CK_RSA_WITH_AES_256_CCM                    0x0300C09D
-# define TLS1_CK_DHE_RSA_WITH_AES_128_CCM                0x0300C09E
-# define TLS1_CK_DHE_RSA_WITH_AES_256_CCM                0x0300C09F
-# define TLS1_CK_RSA_WITH_AES_128_CCM_8                  0x0300C0A0
-# define TLS1_CK_RSA_WITH_AES_256_CCM_8                  0x0300C0A1
-# define TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8              0x0300C0A2
-# define TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8              0x0300C0A3
-# define TLS1_CK_PSK_WITH_AES_128_CCM                    0x0300C0A4
-# define TLS1_CK_PSK_WITH_AES_256_CCM                    0x0300C0A5
-# define TLS1_CK_DHE_PSK_WITH_AES_128_CCM                0x0300C0A6
-# define TLS1_CK_DHE_PSK_WITH_AES_256_CCM                0x0300C0A7
-# define TLS1_CK_PSK_WITH_AES_128_CCM_8                  0x0300C0A8
-# define TLS1_CK_PSK_WITH_AES_256_CCM_8                  0x0300C0A9
-# define TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8              0x0300C0AA
-# define TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8              0x0300C0AB
+#define TLS1_CK_RSA_WITH_AES_128_CCM 0x0300C09C
+#define TLS1_CK_RSA_WITH_AES_256_CCM 0x0300C09D
+#define TLS1_CK_DHE_RSA_WITH_AES_128_CCM 0x0300C09E
+#define TLS1_CK_DHE_RSA_WITH_AES_256_CCM 0x0300C09F
+#define TLS1_CK_RSA_WITH_AES_128_CCM_8 0x0300C0A0
+#define TLS1_CK_RSA_WITH_AES_256_CCM_8 0x0300C0A1
+#define TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8 0x0300C0A2
+#define TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8 0x0300C0A3
+#define TLS1_CK_PSK_WITH_AES_128_CCM 0x0300C0A4
+#define TLS1_CK_PSK_WITH_AES_256_CCM 0x0300C0A5
+#define TLS1_CK_DHE_PSK_WITH_AES_128_CCM 0x0300C0A6
+#define TLS1_CK_DHE_PSK_WITH_AES_256_CCM 0x0300C0A7
+#define TLS1_CK_PSK_WITH_AES_128_CCM_8 0x0300C0A8
+#define TLS1_CK_PSK_WITH_AES_256_CCM_8 0x0300C0A9
+#define TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8 0x0300C0AA
+#define TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8 0x0300C0AB
 
 /* CCM ciphersuites from RFC7251 */
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM            0x0300C0AC
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM            0x0300C0AD
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8          0x0300C0AE
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8          0x0300C0AF
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM 0x0300C0AC
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM 0x0300C0AD
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8 0x0300C0AE
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8 0x0300C0AF
 
 /* TLS 1.2 Camellia SHA-256 ciphersuites from RFC5932 */
-# define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256                0x030000BA
-# define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256             0x030000BB
-# define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256             0x030000BC
-# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256            0x030000BD
-# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256            0x030000BE
-# define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256                0x030000BF
-
-# define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256                0x030000C0
-# define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256             0x030000C1
-# define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256             0x030000C2
-# define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256            0x030000C3
-# define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256            0x030000C4
-# define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256                0x030000C5
+#define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x030000BA
+#define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 0x030000BB
+#define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x030000BC
+#define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 0x030000BD
+#define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x030000BE
+#define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256 0x030000BF
+
+#define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256 0x030000C0
+#define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 0x030000C1
+#define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 0x030000C2
+#define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 0x030000C3
+#define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 0x030000C4
+#define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256 0x030000C5
 
 /* ECC ciphersuites from RFC4492 */
-# define TLS1_CK_ECDH_ECDSA_WITH_NULL_SHA                0x0300C001
-# define TLS1_CK_ECDH_ECDSA_WITH_RC4_128_SHA             0x0300C002
-# define TLS1_CK_ECDH_ECDSA_WITH_DES_192_CBC3_SHA        0x0300C003
-# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_CBC_SHA         0x0300C004
-# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_CBC_SHA         0x0300C005
-
-# define TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA               0x0300C006
-# define TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA            0x0300C007
-# define TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA       0x0300C008
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA        0x0300C009
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA        0x0300C00A
-
-# define TLS1_CK_ECDH_RSA_WITH_NULL_SHA                  0x0300C00B
-# define TLS1_CK_ECDH_RSA_WITH_RC4_128_SHA               0x0300C00C
-# define TLS1_CK_ECDH_RSA_WITH_DES_192_CBC3_SHA          0x0300C00D
-# define TLS1_CK_ECDH_RSA_WITH_AES_128_CBC_SHA           0x0300C00E
-# define TLS1_CK_ECDH_RSA_WITH_AES_256_CBC_SHA           0x0300C00F
-
-# define TLS1_CK_ECDHE_RSA_WITH_NULL_SHA                 0x0300C010
-# define TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA              0x0300C011
-# define TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA         0x0300C012
-# define TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA          0x0300C013
-# define TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA          0x0300C014
-
-# define TLS1_CK_ECDH_anon_WITH_NULL_SHA                 0x0300C015
-# define TLS1_CK_ECDH_anon_WITH_RC4_128_SHA              0x0300C016
-# define TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA         0x0300C017
-# define TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA          0x0300C018
-# define TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA          0x0300C019
+#define TLS1_CK_ECDH_ECDSA_WITH_NULL_SHA 0x0300C001
+#define TLS1_CK_ECDH_ECDSA_WITH_RC4_128_SHA 0x0300C002
+#define TLS1_CK_ECDH_ECDSA_WITH_DES_192_CBC3_SHA 0x0300C003
+#define TLS1_CK_ECDH_ECDSA_WITH_AES_128_CBC_SHA 0x0300C004
+#define TLS1_CK_ECDH_ECDSA_WITH_AES_256_CBC_SHA 0x0300C005
+
+#define TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA 0x0300C006
+#define TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA 0x0300C007
+#define TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA 0x0300C008
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA 0x0300C009
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA 0x0300C00A
+
+#define TLS1_CK_ECDH_RSA_WITH_NULL_SHA 0x0300C00B
+#define TLS1_CK_ECDH_RSA_WITH_RC4_128_SHA 0x0300C00C
+#define TLS1_CK_ECDH_RSA_WITH_DES_192_CBC3_SHA 0x0300C00D
+#define TLS1_CK_ECDH_RSA_WITH_AES_128_CBC_SHA 0x0300C00E
+#define TLS1_CK_ECDH_RSA_WITH_AES_256_CBC_SHA 0x0300C00F
+
+#define TLS1_CK_ECDHE_RSA_WITH_NULL_SHA 0x0300C010
+#define TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA 0x0300C011
+#define TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA 0x0300C012
+#define TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA 0x0300C013
+#define TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA 0x0300C014
+
+#define TLS1_CK_ECDH_anon_WITH_NULL_SHA 0x0300C015
+#define TLS1_CK_ECDH_anon_WITH_RC4_128_SHA 0x0300C016
+#define TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA 0x0300C017
+#define TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA 0x0300C018
+#define TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA 0x0300C019
 
 /* SRP ciphersuites from RFC 5054 */
-# define TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA           0x0300C01A
-# define TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA       0x0300C01B
-# define TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA       0x0300C01C
-# define TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA            0x0300C01D
-# define TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA        0x0300C01E
-# define TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA        0x0300C01F
-# define TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA            0x0300C020
-# define TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA        0x0300C021
-# define TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA        0x0300C022
+#define TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA 0x0300C01A
+#define TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA 0x0300C01B
+#define TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA 0x0300C01C
+#define TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA 0x0300C01D
+#define TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA 0x0300C01E
+#define TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA 0x0300C01F
+#define TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA 0x0300C020
+#define TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA 0x0300C021
+#define TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA 0x0300C022
 
 /* ECDH HMAC based ciphersuites from RFC5289 */
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256         0x0300C023
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384         0x0300C024
-# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_SHA256          0x0300C025
-# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_SHA384          0x0300C026
-# define TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256           0x0300C027
-# define TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384           0x0300C028
-# define TLS1_CK_ECDH_RSA_WITH_AES_128_SHA256            0x0300C029
-# define TLS1_CK_ECDH_RSA_WITH_AES_256_SHA384            0x0300C02A
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256 0x0300C023
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384 0x0300C024
+#define TLS1_CK_ECDH_ECDSA_WITH_AES_128_SHA256 0x0300C025
+#define TLS1_CK_ECDH_ECDSA_WITH_AES_256_SHA384 0x0300C026
+#define TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256 0x0300C027
+#define TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384 0x0300C028
+#define TLS1_CK_ECDH_RSA_WITH_AES_128_SHA256 0x0300C029
+#define TLS1_CK_ECDH_RSA_WITH_AES_256_SHA384 0x0300C02A
 
 /* ECDH GCM based ciphersuites from RFC5289 */
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256     0x0300C02B
-# define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384     0x0300C02C
-# define TLS1_CK_ECDH_ECDSA_WITH_AES_128_GCM_SHA256      0x0300C02D
-# define TLS1_CK_ECDH_ECDSA_WITH_AES_256_GCM_SHA384      0x0300C02E
-# define TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256       0x0300C02F
-# define TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384       0x0300C030
-# define TLS1_CK_ECDH_RSA_WITH_AES_128_GCM_SHA256        0x0300C031
-# define TLS1_CK_ECDH_RSA_WITH_AES_256_GCM_SHA384        0x0300C032
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 0x0300C02B
+#define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 0x0300C02C
+#define TLS1_CK_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 0x0300C02D
+#define TLS1_CK_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 0x0300C02E
+#define TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256 0x0300C02F
+#define TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384 0x0300C030
+#define TLS1_CK_ECDH_RSA_WITH_AES_128_GCM_SHA256 0x0300C031
+#define TLS1_CK_ECDH_RSA_WITH_AES_256_GCM_SHA384 0x0300C032
 
 /* ECDHE PSK ciphersuites from RFC5489 */
-# define TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA              0x0300C033
-# define TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA         0x0300C034
-# define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA          0x0300C035
-# define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA          0x0300C036
+#define TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA 0x0300C033
+#define TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA 0x0300C034
+#define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA 0x0300C035
+#define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA 0x0300C036
 
-# define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256       0x0300C037
-# define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384       0x0300C038
+#define TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256 0x0300C037
+#define TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384 0x0300C038
 
 /* NULL PSK ciphersuites from RFC4785 */
-# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA                 0x0300C039
-# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256              0x0300C03A
-# define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384              0x0300C03B
+#define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA 0x0300C039
+#define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256 0x0300C03A
+#define TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384 0x0300C03B
 
 /* Camellia-CBC ciphersuites from RFC6367 */
-# define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C072
-# define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C073
-# define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256  0x0300C074
-# define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384  0x0300C075
-# define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   0x0300C076
-# define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384   0x0300C077
-# define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256    0x0300C078
-# define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384    0x0300C079
-
-# define TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256         0x0300C094
-# define TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384         0x0300C095
-# define TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256     0x0300C096
-# define TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384     0x0300C097
-# define TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256     0x0300C098
-# define TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384     0x0300C099
-# define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256   0x0300C09A
-# define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384   0x0300C09B
+#define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C072
+#define TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C073
+#define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C074
+#define TLS1_CK_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C075
+#define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C076
+#define TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C077
+#define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 0x0300C078
+#define TLS1_CK_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 0x0300C079
+
+#define TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256 0x0300C094
+#define TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384 0x0300C095
+#define TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 0x0300C096
+#define TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 0x0300C097
+#define TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 0x0300C098
+#define TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 0x0300C099
+#define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 0x0300C09A
+#define TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 0x0300C09B
 
 /* draft-ietf-tls-chacha20-poly1305-03 */
-# define TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305         0x0300CCA8
-# define TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305       0x0300CCA9
-# define TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305           0x0300CCAA
-# define TLS1_CK_PSK_WITH_CHACHA20_POLY1305               0x0300CCAB
-# define TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305         0x0300CCAC
-# define TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305           0x0300CCAD
-# define TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305           0x0300CCAE
+#define TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305 0x0300CCA8
+#define TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 0x0300CCA9
+#define TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305 0x0300CCAA
+#define TLS1_CK_PSK_WITH_CHACHA20_POLY1305 0x0300CCAB
+#define TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305 0x0300CCAC
+#define TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305 0x0300CCAD
+#define TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305 0x0300CCAE
 
 /* TLS v1.3 ciphersuites */
-# define TLS1_3_CK_AES_128_GCM_SHA256                     0x03001301
-# define TLS1_3_CK_AES_256_GCM_SHA384                     0x03001302
-# define TLS1_3_CK_CHACHA20_POLY1305_SHA256               0x03001303
-# define TLS1_3_CK_AES_128_CCM_SHA256                     0x03001304
-# define TLS1_3_CK_AES_128_CCM_8_SHA256                   0x03001305
+#define TLS1_3_CK_AES_128_GCM_SHA256 0x03001301
+#define TLS1_3_CK_AES_256_GCM_SHA384 0x03001302
+#define TLS1_3_CK_CHACHA20_POLY1305_SHA256 0x03001303
+#define TLS1_3_CK_AES_128_CCM_SHA256 0x03001304
+#define TLS1_3_CK_AES_128_CCM_8_SHA256 0x03001305
 
 /* Aria ciphersuites from RFC6209 */
-# define TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256             0x0300C050
-# define TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384             0x0300C051
-# define TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256         0x0300C052
-# define TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384         0x0300C053
-# define TLS1_CK_DH_RSA_WITH_ARIA_128_GCM_SHA256          0x0300C054
-# define TLS1_CK_DH_RSA_WITH_ARIA_256_GCM_SHA384          0x0300C055
-# define TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256         0x0300C056
-# define TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384         0x0300C057
-# define TLS1_CK_DH_DSS_WITH_ARIA_128_GCM_SHA256          0x0300C058
-# define TLS1_CK_DH_DSS_WITH_ARIA_256_GCM_SHA384          0x0300C059
-# define TLS1_CK_DH_anon_WITH_ARIA_128_GCM_SHA256         0x0300C05A
-# define TLS1_CK_DH_anon_WITH_ARIA_256_GCM_SHA384         0x0300C05B
-# define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256     0x0300C05C
-# define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384     0x0300C05D
-# define TLS1_CK_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256      0x0300C05E
-# define TLS1_CK_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384      0x0300C05F
-# define TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256       0x0300C060
-# define TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384       0x0300C061
-# define TLS1_CK_ECDH_RSA_WITH_ARIA_128_GCM_SHA256        0x0300C062
-# define TLS1_CK_ECDH_RSA_WITH_ARIA_256_GCM_SHA384        0x0300C063
-# define TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256             0x0300C06A
-# define TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384             0x0300C06B
-# define TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256         0x0300C06C
-# define TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384         0x0300C06D
-# define TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256         0x0300C06E
-# define TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384         0x0300C06F
+#define TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C050
+#define TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C051
+#define TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C052
+#define TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C053
+#define TLS1_CK_DH_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C054
+#define TLS1_CK_DH_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C055
+#define TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256 0x0300C056
+#define TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384 0x0300C057
+#define TLS1_CK_DH_DSS_WITH_ARIA_128_GCM_SHA256 0x0300C058
+#define TLS1_CK_DH_DSS_WITH_ARIA_256_GCM_SHA384 0x0300C059
+#define TLS1_CK_DH_anon_WITH_ARIA_128_GCM_SHA256 0x0300C05A
+#define TLS1_CK_DH_anon_WITH_ARIA_256_GCM_SHA384 0x0300C05B
+#define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 0x0300C05C
+#define TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 0x0300C05D
+#define TLS1_CK_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 0x0300C05E
+#define TLS1_CK_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 0x0300C05F
+#define TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C060
+#define TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C061
+#define TLS1_CK_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 0x0300C062
+#define TLS1_CK_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 0x0300C063
+#define TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256 0x0300C06A
+#define TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384 0x0300C06B
+#define TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256 0x0300C06C
+#define TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384 0x0300C06D
+#define TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256 0x0300C06E
+#define TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384 0x0300C06F
 
 /* a bundle of RFC standard cipher names, generated from ssl3_ciphers[] */
-# define TLS1_RFC_RSA_WITH_AES_128_SHA                   "TLS_RSA_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA               "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA               "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_ADH_WITH_AES_128_SHA                   "TLS_DH_anon_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_RSA_WITH_AES_256_SHA                   "TLS_RSA_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA               "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA               "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_ADH_WITH_AES_256_SHA                   "TLS_DH_anon_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_RSA_WITH_NULL_SHA256                   "TLS_RSA_WITH_NULL_SHA256"
-# define TLS1_RFC_RSA_WITH_AES_128_SHA256                "TLS_RSA_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_RSA_WITH_AES_256_SHA256                "TLS_RSA_WITH_AES_256_CBC_SHA256"
-# define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256            "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256            "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256            "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"
-# define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256            "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"
-# define TLS1_RFC_ADH_WITH_AES_128_SHA256                "TLS_DH_anon_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_ADH_WITH_AES_256_SHA256                "TLS_DH_anon_WITH_AES_256_CBC_SHA256"
-# define TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256            "TLS_RSA_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384            "TLS_RSA_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256        "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384        "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256        "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384        "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256            "TLS_DH_anon_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384            "TLS_DH_anon_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_RSA_WITH_AES_128_CCM                   "TLS_RSA_WITH_AES_128_CCM"
-# define TLS1_RFC_RSA_WITH_AES_256_CCM                   "TLS_RSA_WITH_AES_256_CCM"
-# define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM               "TLS_DHE_RSA_WITH_AES_128_CCM"
-# define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM               "TLS_DHE_RSA_WITH_AES_256_CCM"
-# define TLS1_RFC_RSA_WITH_AES_128_CCM_8                 "TLS_RSA_WITH_AES_128_CCM_8"
-# define TLS1_RFC_RSA_WITH_AES_256_CCM_8                 "TLS_RSA_WITH_AES_256_CCM_8"
-# define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8             "TLS_DHE_RSA_WITH_AES_128_CCM_8"
-# define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8             "TLS_DHE_RSA_WITH_AES_256_CCM_8"
-# define TLS1_RFC_PSK_WITH_AES_128_CCM                   "TLS_PSK_WITH_AES_128_CCM"
-# define TLS1_RFC_PSK_WITH_AES_256_CCM                   "TLS_PSK_WITH_AES_256_CCM"
-# define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM               "TLS_DHE_PSK_WITH_AES_128_CCM"
-# define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM               "TLS_DHE_PSK_WITH_AES_256_CCM"
-# define TLS1_RFC_PSK_WITH_AES_128_CCM_8                 "TLS_PSK_WITH_AES_128_CCM_8"
-# define TLS1_RFC_PSK_WITH_AES_256_CCM_8                 "TLS_PSK_WITH_AES_256_CCM_8"
-# define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8             "TLS_PSK_DHE_WITH_AES_128_CCM_8"
-# define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8             "TLS_PSK_DHE_WITH_AES_256_CCM_8"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM           "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM           "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8         "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8         "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"
-# define TLS1_3_RFC_AES_128_GCM_SHA256                   "TLS_AES_128_GCM_SHA256"
-# define TLS1_3_RFC_AES_256_GCM_SHA384                   "TLS_AES_256_GCM_SHA384"
-# define TLS1_3_RFC_CHACHA20_POLY1305_SHA256             "TLS_CHACHA20_POLY1305_SHA256"
-# define TLS1_3_RFC_AES_128_CCM_SHA256                   "TLS_AES_128_CCM_SHA256"
-# define TLS1_3_RFC_AES_128_CCM_8_SHA256                 "TLS_AES_128_CCM_8_SHA256"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA              "TLS_ECDHE_ECDSA_WITH_NULL_SHA"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA      "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA       "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA       "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA                "TLS_ECDHE_RSA_WITH_NULL_SHA"
-# define TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA        "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA         "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA         "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_ECDH_anon_WITH_NULL_SHA                "TLS_ECDH_anon_WITH_NULL_SHA"
-# define TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA        "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA         "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA         "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256        "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384        "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
-# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256          "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384          "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256    "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384    "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256      "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384      "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_PSK_WITH_NULL_SHA                      "TLS_PSK_WITH_NULL_SHA"
-# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA                  "TLS_DHE_PSK_WITH_NULL_SHA"
-# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA                  "TLS_RSA_PSK_WITH_NULL_SHA"
-# define TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA              "TLS_PSK_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA               "TLS_PSK_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA               "TLS_PSK_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA          "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA           "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA           "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA          "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA           "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA           "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256            "TLS_PSK_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384            "TLS_PSK_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256        "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384        "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256        "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"
-# define TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384        "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"
-# define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256            "TLS_PSK_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384            "TLS_PSK_WITH_AES_256_CBC_SHA384"
-# define TLS1_RFC_PSK_WITH_NULL_SHA256                   "TLS_PSK_WITH_NULL_SHA256"
-# define TLS1_RFC_PSK_WITH_NULL_SHA384                   "TLS_PSK_WITH_NULL_SHA384"
-# define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256        "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384        "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"
-# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA256               "TLS_DHE_PSK_WITH_NULL_SHA256"
-# define TLS1_RFC_DHE_PSK_WITH_NULL_SHA384               "TLS_DHE_PSK_WITH_NULL_SHA384"
-# define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256        "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384        "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"
-# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA256               "TLS_RSA_PSK_WITH_NULL_SHA256"
-# define TLS1_RFC_RSA_PSK_WITH_NULL_SHA384               "TLS_RSA_PSK_WITH_NULL_SHA384"
-# define TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA        "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA         "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA         "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256      "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"
-# define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384      "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"
-# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA                "TLS_ECDHE_PSK_WITH_NULL_SHA"
-# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256             "TLS_ECDHE_PSK_WITH_NULL_SHA256"
-# define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384             "TLS_ECDHE_PSK_WITH_NULL_SHA384"
-# define TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA          "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA      "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA      "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"
-# define TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA           "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA       "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA       "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"
-# define TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA           "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA       "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA       "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"
-# define TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305         "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
-# define TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305       "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305     "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"
-# define TLS1_RFC_PSK_WITH_CHACHA20_POLY1305             "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"
-# define TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305       "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
-# define TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305         "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
-# define TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305         "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"
-# define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256       "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256       "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256       "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"
-# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256   "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"
-# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256   "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"
-# define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256       "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"
-# define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA          "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"
-# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA      "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"
-# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA      "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"
-# define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA          "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"
-# define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA          "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"
-# define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA      "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"
-# define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA      "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"
-# define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA          "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"
-# define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"
-# define TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256       "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384       "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"
-# define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256   "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384   "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"
-# define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256   "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384   "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"
-# define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"
-# define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"
-# define TLS1_RFC_RSA_WITH_SEED_SHA                      "TLS_RSA_WITH_SEED_CBC_SHA"
-# define TLS1_RFC_DHE_DSS_WITH_SEED_SHA                  "TLS_DHE_DSS_WITH_SEED_CBC_SHA"
-# define TLS1_RFC_DHE_RSA_WITH_SEED_SHA                  "TLS_DHE_RSA_WITH_SEED_CBC_SHA"
-# define TLS1_RFC_ADH_WITH_SEED_SHA                      "TLS_DH_anon_WITH_SEED_CBC_SHA"
-# define TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA             "TLS_ECDHE_PSK_WITH_RC4_128_SHA"
-# define TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA             "TLS_ECDH_anon_WITH_RC4_128_SHA"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA           "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"
-# define TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA             "TLS_ECDHE_RSA_WITH_RC4_128_SHA"
-# define TLS1_RFC_PSK_WITH_RC4_128_SHA                   "TLS_PSK_WITH_RC4_128_SHA"
-# define TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA               "TLS_RSA_PSK_WITH_RC4_128_SHA"
-# define TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA               "TLS_DHE_PSK_WITH_RC4_128_SHA"
-# define TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256           "TLS_RSA_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384           "TLS_RSA_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_DH_RSA_WITH_ARIA_128_GCM_SHA256        "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_DH_RSA_WITH_ARIA_256_GCM_SHA384        "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_DH_DSS_WITH_ARIA_128_GCM_SHA256        "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_DH_DSS_WITH_ARIA_256_GCM_SHA384        "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_DH_anon_WITH_ARIA_128_GCM_SHA256       "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_DH_anon_WITH_ARIA_256_GCM_SHA384       "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256   "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384   "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256    "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384    "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256     "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384     "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_ECDH_RSA_WITH_ARIA_128_GCM_SHA256      "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_ECDH_RSA_WITH_ARIA_256_GCM_SHA384      "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256           "TLS_PSK_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384           "TLS_PSK_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256       "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384       "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"
-# define TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256       "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"
-# define TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384       "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"
-
+#define TLS1_RFC_RSA_WITH_AES_128_SHA "TLS_RSA_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_ADH_WITH_AES_128_SHA "TLS_DH_anon_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_RSA_WITH_AES_256_SHA "TLS_RSA_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_ADH_WITH_AES_256_SHA "TLS_DH_anon_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_RSA_WITH_NULL_SHA256 "TLS_RSA_WITH_NULL_SHA256"
+#define TLS1_RFC_RSA_WITH_AES_128_SHA256 "TLS_RSA_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_RSA_WITH_AES_256_SHA256 "TLS_RSA_WITH_AES_256_CBC_SHA256"
+#define TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256 "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256 "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256 "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"
+#define TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256 "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"
+#define TLS1_RFC_ADH_WITH_AES_128_SHA256 "TLS_DH_anon_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_ADH_WITH_AES_256_SHA256 "TLS_DH_anon_WITH_AES_256_CBC_SHA256"
+#define TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256 "TLS_RSA_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384 "TLS_RSA_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256 "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384 "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256 "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384 "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256 "TLS_DH_anon_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384 "TLS_DH_anon_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_RSA_WITH_AES_128_CCM "TLS_RSA_WITH_AES_128_CCM"
+#define TLS1_RFC_RSA_WITH_AES_256_CCM "TLS_RSA_WITH_AES_256_CCM"
+#define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM "TLS_DHE_RSA_WITH_AES_128_CCM"
+#define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM "TLS_DHE_RSA_WITH_AES_256_CCM"
+#define TLS1_RFC_RSA_WITH_AES_128_CCM_8 "TLS_RSA_WITH_AES_128_CCM_8"
+#define TLS1_RFC_RSA_WITH_AES_256_CCM_8 "TLS_RSA_WITH_AES_256_CCM_8"
+#define TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8 "TLS_DHE_RSA_WITH_AES_128_CCM_8"
+#define TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8 "TLS_DHE_RSA_WITH_AES_256_CCM_8"
+#define TLS1_RFC_PSK_WITH_AES_128_CCM "TLS_PSK_WITH_AES_128_CCM"
+#define TLS1_RFC_PSK_WITH_AES_256_CCM "TLS_PSK_WITH_AES_256_CCM"
+#define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM "TLS_DHE_PSK_WITH_AES_128_CCM"
+#define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM "TLS_DHE_PSK_WITH_AES_256_CCM"
+#define TLS1_RFC_PSK_WITH_AES_128_CCM_8 "TLS_PSK_WITH_AES_128_CCM_8"
+#define TLS1_RFC_PSK_WITH_AES_256_CCM_8 "TLS_PSK_WITH_AES_256_CCM_8"
+#define TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8 "TLS_PSK_DHE_WITH_AES_128_CCM_8"
+#define TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8 "TLS_PSK_DHE_WITH_AES_256_CCM_8"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8 "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8 "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"
+#define TLS1_3_RFC_AES_128_GCM_SHA256 "TLS_AES_128_GCM_SHA256"
+#define TLS1_3_RFC_AES_256_GCM_SHA384 "TLS_AES_256_GCM_SHA384"
+#define TLS1_3_RFC_CHACHA20_POLY1305_SHA256 "TLS_CHACHA20_POLY1305_SHA256"
+#define TLS1_3_RFC_AES_128_CCM_SHA256 "TLS_AES_128_CCM_SHA256"
+#define TLS1_3_RFC_AES_128_CCM_8_SHA256 "TLS_AES_128_CCM_8_SHA256"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA "TLS_ECDHE_ECDSA_WITH_NULL_SHA"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA "TLS_ECDHE_RSA_WITH_NULL_SHA"
+#define TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_ECDH_anon_WITH_NULL_SHA "TLS_ECDH_anon_WITH_NULL_SHA"
+#define TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256 "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384 "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"
+#define TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256 "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384 "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256 "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384 "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_PSK_WITH_NULL_SHA "TLS_PSK_WITH_NULL_SHA"
+#define TLS1_RFC_DHE_PSK_WITH_NULL_SHA "TLS_DHE_PSK_WITH_NULL_SHA"
+#define TLS1_RFC_RSA_PSK_WITH_NULL_SHA "TLS_RSA_PSK_WITH_NULL_SHA"
+#define TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA "TLS_PSK_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA "TLS_PSK_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA "TLS_PSK_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256 "TLS_PSK_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384 "TLS_PSK_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256 "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384 "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256 "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"
+#define TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384 "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"
+#define TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256 "TLS_PSK_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384 "TLS_PSK_WITH_AES_256_CBC_SHA384"
+#define TLS1_RFC_PSK_WITH_NULL_SHA256 "TLS_PSK_WITH_NULL_SHA256"
+#define TLS1_RFC_PSK_WITH_NULL_SHA384 "TLS_PSK_WITH_NULL_SHA384"
+#define TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256 "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384 "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"
+#define TLS1_RFC_DHE_PSK_WITH_NULL_SHA256 "TLS_DHE_PSK_WITH_NULL_SHA256"
+#define TLS1_RFC_DHE_PSK_WITH_NULL_SHA384 "TLS_DHE_PSK_WITH_NULL_SHA384"
+#define TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256 "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384 "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"
+#define TLS1_RFC_RSA_PSK_WITH_NULL_SHA256 "TLS_RSA_PSK_WITH_NULL_SHA256"
+#define TLS1_RFC_RSA_PSK_WITH_NULL_SHA384 "TLS_RSA_PSK_WITH_NULL_SHA384"
+#define TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256 "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"
+#define TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384 "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"
+#define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA "TLS_ECDHE_PSK_WITH_NULL_SHA"
+#define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256 "TLS_ECDHE_PSK_WITH_NULL_SHA256"
+#define TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384 "TLS_ECDHE_PSK_WITH_NULL_SHA384"
+#define TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"
+#define TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"
+#define TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"
+#define TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305 "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
+#define TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305 "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"
+#define TLS1_RFC_PSK_WITH_CHACHA20_POLY1305 "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"
+#define TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305 "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
+#define TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305 "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
+#define TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305 "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"
+#define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256 "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256 "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"
+#define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"
+#define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"
+#define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256 "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"
+#define TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"
+#define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"
+#define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"
+#define TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"
+#define TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"
+#define TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"
+#define TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"
+#define TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"
+#define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"
+#define TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+#define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+#define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+#define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"
+#define TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"
+#define TLS1_RFC_RSA_WITH_SEED_SHA "TLS_RSA_WITH_SEED_CBC_SHA"
+#define TLS1_RFC_DHE_DSS_WITH_SEED_SHA "TLS_DHE_DSS_WITH_SEED_CBC_SHA"
+#define TLS1_RFC_DHE_RSA_WITH_SEED_SHA "TLS_DHE_RSA_WITH_SEED_CBC_SHA"
+#define TLS1_RFC_ADH_WITH_SEED_SHA "TLS_DH_anon_WITH_SEED_CBC_SHA"
+#define TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA "TLS_ECDHE_PSK_WITH_RC4_128_SHA"
+#define TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA "TLS_ECDH_anon_WITH_RC4_128_SHA"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"
+#define TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA "TLS_ECDHE_RSA_WITH_RC4_128_SHA"
+#define TLS1_RFC_PSK_WITH_RC4_128_SHA "TLS_PSK_WITH_RC4_128_SHA"
+#define TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA "TLS_RSA_PSK_WITH_RC4_128_SHA"
+#define TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA "TLS_DHE_PSK_WITH_RC4_128_SHA"
+#define TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_RSA_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_RSA_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_DH_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_DH_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256 "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384 "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_DH_DSS_WITH_ARIA_128_GCM_SHA256 "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_DH_DSS_WITH_ARIA_256_GCM_SHA384 "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_DH_anon_WITH_ARIA_128_GCM_SHA256 "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_DH_anon_WITH_ARIA_256_GCM_SHA384 "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256 "TLS_PSK_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384 "TLS_PSK_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256 "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384 "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"
+#define TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256 "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"
+#define TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384 "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"
 
 /*
  * XXX Backward compatibility alert: Older versions of OpenSSL gave some DHE
@@ -818,406 +799,407 @@ int SSL_CTX_set_tlsext_ticket_key_evp_cb
  * using DHE everywhere, though we may indefinitely maintain aliases for
  * users or configurations that used "EDH"
  */
-# define TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA               "DHE-DSS-RC4-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA "DHE-DSS-RC4-SHA"
 
-# define TLS1_TXT_PSK_WITH_NULL_SHA                      "PSK-NULL-SHA"
-# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA                  "DHE-PSK-NULL-SHA"
-# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA                  "RSA-PSK-NULL-SHA"
+#define TLS1_TXT_PSK_WITH_NULL_SHA "PSK-NULL-SHA"
+#define TLS1_TXT_DHE_PSK_WITH_NULL_SHA "DHE-PSK-NULL-SHA"
+#define TLS1_TXT_RSA_PSK_WITH_NULL_SHA "RSA-PSK-NULL-SHA"
 
 /* AES ciphersuites from RFC3268 */
-# define TLS1_TXT_RSA_WITH_AES_128_SHA                   "AES128-SHA"
-# define TLS1_TXT_DH_DSS_WITH_AES_128_SHA                "DH-DSS-AES128-SHA"
-# define TLS1_TXT_DH_RSA_WITH_AES_128_SHA                "DH-RSA-AES128-SHA"
-# define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA               "DHE-DSS-AES128-SHA"
-# define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA               "DHE-RSA-AES128-SHA"
-# define TLS1_TXT_ADH_WITH_AES_128_SHA                   "ADH-AES128-SHA"
-
-# define TLS1_TXT_RSA_WITH_AES_256_SHA                   "AES256-SHA"
-# define TLS1_TXT_DH_DSS_WITH_AES_256_SHA                "DH-DSS-AES256-SHA"
-# define TLS1_TXT_DH_RSA_WITH_AES_256_SHA                "DH-RSA-AES256-SHA"
-# define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA               "DHE-DSS-AES256-SHA"
-# define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA               "DHE-RSA-AES256-SHA"
-# define TLS1_TXT_ADH_WITH_AES_256_SHA                   "ADH-AES256-SHA"
+#define TLS1_TXT_RSA_WITH_AES_128_SHA "AES128-SHA"
+#define TLS1_TXT_DH_DSS_WITH_AES_128_SHA "DH-DSS-AES128-SHA"
+#define TLS1_TXT_DH_RSA_WITH_AES_128_SHA "DH-RSA-AES128-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA "DHE-DSS-AES128-SHA"
+#define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA "DHE-RSA-AES128-SHA"
+#define TLS1_TXT_ADH_WITH_AES_128_SHA "ADH-AES128-SHA"
+
+#define TLS1_TXT_RSA_WITH_AES_256_SHA "AES256-SHA"
+#define TLS1_TXT_DH_DSS_WITH_AES_256_SHA "DH-DSS-AES256-SHA"
+#define TLS1_TXT_DH_RSA_WITH_AES_256_SHA "DH-RSA-AES256-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA "DHE-DSS-AES256-SHA"
+#define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA "DHE-RSA-AES256-SHA"
+#define TLS1_TXT_ADH_WITH_AES_256_SHA "ADH-AES256-SHA"
 
 /* ECC ciphersuites from RFC4492 */
-# define TLS1_TXT_ECDH_ECDSA_WITH_NULL_SHA               "ECDH-ECDSA-NULL-SHA"
-# define TLS1_TXT_ECDH_ECDSA_WITH_RC4_128_SHA            "ECDH-ECDSA-RC4-SHA"
-# define TLS1_TXT_ECDH_ECDSA_WITH_DES_192_CBC3_SHA       "ECDH-ECDSA-DES-CBC3-SHA"
-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_CBC_SHA        "ECDH-ECDSA-AES128-SHA"
-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_CBC_SHA        "ECDH-ECDSA-AES256-SHA"
-
-# define TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA              "ECDHE-ECDSA-NULL-SHA"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA           "ECDHE-ECDSA-RC4-SHA"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA      "ECDHE-ECDSA-DES-CBC3-SHA"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA       "ECDHE-ECDSA-AES128-SHA"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA       "ECDHE-ECDSA-AES256-SHA"
-
-# define TLS1_TXT_ECDH_RSA_WITH_NULL_SHA                 "ECDH-RSA-NULL-SHA"
-# define TLS1_TXT_ECDH_RSA_WITH_RC4_128_SHA              "ECDH-RSA-RC4-SHA"
-# define TLS1_TXT_ECDH_RSA_WITH_DES_192_CBC3_SHA         "ECDH-RSA-DES-CBC3-SHA"
-# define TLS1_TXT_ECDH_RSA_WITH_AES_128_CBC_SHA          "ECDH-RSA-AES128-SHA"
-# define TLS1_TXT_ECDH_RSA_WITH_AES_256_CBC_SHA          "ECDH-RSA-AES256-SHA"
-
-# define TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA                "ECDHE-RSA-NULL-SHA"
-# define TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA             "ECDHE-RSA-RC4-SHA"
-# define TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA        "ECDHE-RSA-DES-CBC3-SHA"
-# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA         "ECDHE-RSA-AES128-SHA"
-# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA         "ECDHE-RSA-AES256-SHA"
-
-# define TLS1_TXT_ECDH_anon_WITH_NULL_SHA                "AECDH-NULL-SHA"
-# define TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA             "AECDH-RC4-SHA"
-# define TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA        "AECDH-DES-CBC3-SHA"
-# define TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA         "AECDH-AES128-SHA"
-# define TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA         "AECDH-AES256-SHA"
+#define TLS1_TXT_ECDH_ECDSA_WITH_NULL_SHA "ECDH-ECDSA-NULL-SHA"
+#define TLS1_TXT_ECDH_ECDSA_WITH_RC4_128_SHA "ECDH-ECDSA-RC4-SHA"
+#define TLS1_TXT_ECDH_ECDSA_WITH_DES_192_CBC3_SHA "ECDH-ECDSA-DES-CBC3-SHA"
+#define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_CBC_SHA "ECDH-ECDSA-AES128-SHA"
+#define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_CBC_SHA "ECDH-ECDSA-AES256-SHA"
+
+#define TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA "ECDHE-ECDSA-NULL-SHA"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA "ECDHE-ECDSA-RC4-SHA"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA "ECDHE-ECDSA-DES-CBC3-SHA"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA "ECDHE-ECDSA-AES128-SHA"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA "ECDHE-ECDSA-AES256-SHA"
+
+#define TLS1_TXT_ECDH_RSA_WITH_NULL_SHA "ECDH-RSA-NULL-SHA"
+#define TLS1_TXT_ECDH_RSA_WITH_RC4_128_SHA "ECDH-RSA-RC4-SHA"
+#define TLS1_TXT_ECDH_RSA_WITH_DES_192_CBC3_SHA "ECDH-RSA-DES-CBC3-SHA"
+#define TLS1_TXT_ECDH_RSA_WITH_AES_128_CBC_SHA "ECDH-RSA-AES128-SHA"
+#define TLS1_TXT_ECDH_RSA_WITH_AES_256_CBC_SHA "ECDH-RSA-AES256-SHA"
+
+#define TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA "ECDHE-RSA-NULL-SHA"
+#define TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA "ECDHE-RSA-RC4-SHA"
+#define TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA "ECDHE-RSA-DES-CBC3-SHA"
+#define TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA "ECDHE-RSA-AES128-SHA"
+#define TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA "ECDHE-RSA-AES256-SHA"
+
+#define TLS1_TXT_ECDH_anon_WITH_NULL_SHA "AECDH-NULL-SHA"
+#define TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA "AECDH-RC4-SHA"
+#define TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA "AECDH-DES-CBC3-SHA"
+#define TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA "AECDH-AES128-SHA"
+#define TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA "AECDH-AES256-SHA"
 
 /* PSK ciphersuites from RFC 4279 */
-# define TLS1_TXT_PSK_WITH_RC4_128_SHA                   "PSK-RC4-SHA"
-# define TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA              "PSK-3DES-EDE-CBC-SHA"
-# define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA               "PSK-AES128-CBC-SHA"
-# define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA               "PSK-AES256-CBC-SHA"
-
-# define TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA               "DHE-PSK-RC4-SHA"
-# define TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA          "DHE-PSK-3DES-EDE-CBC-SHA"
-# define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA           "DHE-PSK-AES128-CBC-SHA"
-# define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA           "DHE-PSK-AES256-CBC-SHA"
-# define TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA               "RSA-PSK-RC4-SHA"
-# define TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA          "RSA-PSK-3DES-EDE-CBC-SHA"
-# define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA           "RSA-PSK-AES128-CBC-SHA"
-# define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA           "RSA-PSK-AES256-CBC-SHA"
+#define TLS1_TXT_PSK_WITH_RC4_128_SHA "PSK-RC4-SHA"
+#define TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA "PSK-3DES-EDE-CBC-SHA"
+#define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA "PSK-AES128-CBC-SHA"
+#define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA "PSK-AES256-CBC-SHA"
+
+#define TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA "DHE-PSK-RC4-SHA"
+#define TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA "DHE-PSK-3DES-EDE-CBC-SHA"
+#define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA "DHE-PSK-AES128-CBC-SHA"
+#define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA "DHE-PSK-AES256-CBC-SHA"
+#define TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA "RSA-PSK-RC4-SHA"
+#define TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA "RSA-PSK-3DES-EDE-CBC-SHA"
+#define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA "RSA-PSK-AES128-CBC-SHA"
+#define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA "RSA-PSK-AES256-CBC-SHA"
 
 /* PSK ciphersuites from RFC 5487 */
-# define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256            "PSK-AES128-GCM-SHA256"
-# define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384            "PSK-AES256-GCM-SHA384"
-# define TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256        "DHE-PSK-AES128-GCM-SHA256"
-# define TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384        "DHE-PSK-AES256-GCM-SHA384"
-# define TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256        "RSA-PSK-AES128-GCM-SHA256"
-# define TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384        "RSA-PSK-AES256-GCM-SHA384"
-
-# define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256            "PSK-AES128-CBC-SHA256"
-# define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384            "PSK-AES256-CBC-SHA384"
-# define TLS1_TXT_PSK_WITH_NULL_SHA256                   "PSK-NULL-SHA256"
-# define TLS1_TXT_PSK_WITH_NULL_SHA384                   "PSK-NULL-SHA384"
-
-# define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256        "DHE-PSK-AES128-CBC-SHA256"
-# define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384        "DHE-PSK-AES256-CBC-SHA384"
-# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA256               "DHE-PSK-NULL-SHA256"
-# define TLS1_TXT_DHE_PSK_WITH_NULL_SHA384               "DHE-PSK-NULL-SHA384"
-
-# define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256        "RSA-PSK-AES128-CBC-SHA256"
-# define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384        "RSA-PSK-AES256-CBC-SHA384"
-# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA256               "RSA-PSK-NULL-SHA256"
-# define TLS1_TXT_RSA_PSK_WITH_NULL_SHA384               "RSA-PSK-NULL-SHA384"
+#define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256 "PSK-AES128-GCM-SHA256"
+#define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384 "PSK-AES256-GCM-SHA384"
+#define TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256 "DHE-PSK-AES128-GCM-SHA256"
+#define TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384 "DHE-PSK-AES256-GCM-SHA384"
+#define TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256 "RSA-PSK-AES128-GCM-SHA256"
+#define TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384 "RSA-PSK-AES256-GCM-SHA384"
+
+#define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256 "PSK-AES128-CBC-SHA256"
+#define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384 "PSK-AES256-CBC-SHA384"
+#define TLS1_TXT_PSK_WITH_NULL_SHA256 "PSK-NULL-SHA256"
+#define TLS1_TXT_PSK_WITH_NULL_SHA384 "PSK-NULL-SHA384"
+
+#define TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256 "DHE-PSK-AES128-CBC-SHA256"
+#define TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384 "DHE-PSK-AES256-CBC-SHA384"
+#define TLS1_TXT_DHE_PSK_WITH_NULL_SHA256 "DHE-PSK-NULL-SHA256"
+#define TLS1_TXT_DHE_PSK_WITH_NULL_SHA384 "DHE-PSK-NULL-SHA384"
+
+#define TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256 "RSA-PSK-AES128-CBC-SHA256"
+#define TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384 "RSA-PSK-AES256-CBC-SHA384"
+#define TLS1_TXT_RSA_PSK_WITH_NULL_SHA256 "RSA-PSK-NULL-SHA256"
+#define TLS1_TXT_RSA_PSK_WITH_NULL_SHA384 "RSA-PSK-NULL-SHA384"
 
 /* SRP ciphersuite from RFC 5054 */
-# define TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA          "SRP-3DES-EDE-CBC-SHA"
-# define TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA      "SRP-RSA-3DES-EDE-CBC-SHA"
-# define TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA      "SRP-DSS-3DES-EDE-CBC-SHA"
-# define TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA           "SRP-AES-128-CBC-SHA"
-# define TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA       "SRP-RSA-AES-128-CBC-SHA"
-# define TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA       "SRP-DSS-AES-128-CBC-SHA"
-# define TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA           "SRP-AES-256-CBC-SHA"
-# define TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA       "SRP-RSA-AES-256-CBC-SHA"
-# define TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA       "SRP-DSS-AES-256-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA "SRP-3DES-EDE-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA "SRP-RSA-3DES-EDE-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA "SRP-DSS-3DES-EDE-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA "SRP-AES-128-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA "SRP-RSA-AES-128-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA "SRP-DSS-AES-128-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA "SRP-AES-256-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA "SRP-RSA-AES-256-CBC-SHA"
+#define TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA "SRP-DSS-AES-256-CBC-SHA"
 
 /* Camellia ciphersuites from RFC4132 */
-# define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA          "CAMELLIA128-SHA"
-# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA       "DH-DSS-CAMELLIA128-SHA"
-# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA       "DH-RSA-CAMELLIA128-SHA"
-# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA      "DHE-DSS-CAMELLIA128-SHA"
-# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA      "DHE-RSA-CAMELLIA128-SHA"
-# define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA          "ADH-CAMELLIA128-SHA"
-
-# define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA          "CAMELLIA256-SHA"
-# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA       "DH-DSS-CAMELLIA256-SHA"
-# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA       "DH-RSA-CAMELLIA256-SHA"
-# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA      "DHE-DSS-CAMELLIA256-SHA"
-# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA      "DHE-RSA-CAMELLIA256-SHA"
-# define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA          "ADH-CAMELLIA256-SHA"
+#define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA "CAMELLIA128-SHA"
+#define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA "DH-DSS-CAMELLIA128-SHA"
+#define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA "DH-RSA-CAMELLIA128-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA "DHE-DSS-CAMELLIA128-SHA"
+#define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA "DHE-RSA-CAMELLIA128-SHA"
+#define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA "ADH-CAMELLIA128-SHA"
+
+#define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA "CAMELLIA256-SHA"
+#define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA "DH-DSS-CAMELLIA256-SHA"
+#define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA "DH-RSA-CAMELLIA256-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA "DHE-DSS-CAMELLIA256-SHA"
+#define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA "DHE-RSA-CAMELLIA256-SHA"
+#define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA "ADH-CAMELLIA256-SHA"
 
 /* TLS 1.2 Camellia SHA-256 ciphersuites from RFC5932 */
-# define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256               "CAMELLIA128-SHA256"
-# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256            "DH-DSS-CAMELLIA128-SHA256"
-# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256            "DH-RSA-CAMELLIA128-SHA256"
-# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256           "DHE-DSS-CAMELLIA128-SHA256"
-# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256           "DHE-RSA-CAMELLIA128-SHA256"
-# define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256               "ADH-CAMELLIA128-SHA256"
-
-# define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256               "CAMELLIA256-SHA256"
-# define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256            "DH-DSS-CAMELLIA256-SHA256"
-# define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256            "DH-RSA-CAMELLIA256-SHA256"
-# define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256           "DHE-DSS-CAMELLIA256-SHA256"
-# define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256           "DHE-RSA-CAMELLIA256-SHA256"
-# define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256               "ADH-CAMELLIA256-SHA256"
-
-# define TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256               "PSK-CAMELLIA128-SHA256"
-# define TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384               "PSK-CAMELLIA256-SHA384"
-# define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256           "DHE-PSK-CAMELLIA128-SHA256"
-# define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384           "DHE-PSK-CAMELLIA256-SHA384"
-# define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256           "RSA-PSK-CAMELLIA128-SHA256"
-# define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384           "RSA-PSK-CAMELLIA256-SHA384"
-# define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256         "ECDHE-PSK-CAMELLIA128-SHA256"
-# define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384         "ECDHE-PSK-CAMELLIA256-SHA384"
+#define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256 "CAMELLIA128-SHA256"
+#define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 "DH-DSS-CAMELLIA128-SHA256"
+#define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 "DH-RSA-CAMELLIA128-SHA256"
+#define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 "DHE-DSS-CAMELLIA128-SHA256"
+#define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "DHE-RSA-CAMELLIA128-SHA256"
+#define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256 "ADH-CAMELLIA128-SHA256"
+
+#define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256 "CAMELLIA256-SHA256"
+#define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 "DH-DSS-CAMELLIA256-SHA256"
+#define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 "DH-RSA-CAMELLIA256-SHA256"
+#define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 "DHE-DSS-CAMELLIA256-SHA256"
+#define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 "DHE-RSA-CAMELLIA256-SHA256"
+#define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256 "ADH-CAMELLIA256-SHA256"
+
+#define TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256 "PSK-CAMELLIA128-SHA256"
+#define TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384 "PSK-CAMELLIA256-SHA384"
+#define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "DHE-PSK-CAMELLIA128-SHA256"
+#define TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "DHE-PSK-CAMELLIA256-SHA384"
+#define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 "RSA-PSK-CAMELLIA128-SHA256"
+#define TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 "RSA-PSK-CAMELLIA256-SHA384"
+#define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-PSK-CAMELLIA128-SHA256"
+#define TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-PSK-CAMELLIA256-SHA384"
 
 /* SEED ciphersuites from RFC4162 */
-# define TLS1_TXT_RSA_WITH_SEED_SHA                      "SEED-SHA"
-# define TLS1_TXT_DH_DSS_WITH_SEED_SHA                   "DH-DSS-SEED-SHA"
-# define TLS1_TXT_DH_RSA_WITH_SEED_SHA                   "DH-RSA-SEED-SHA"
-# define TLS1_TXT_DHE_DSS_WITH_SEED_SHA                  "DHE-DSS-SEED-SHA"
-# define TLS1_TXT_DHE_RSA_WITH_SEED_SHA                  "DHE-RSA-SEED-SHA"
-# define TLS1_TXT_ADH_WITH_SEED_SHA                      "ADH-SEED-SHA"
+#define TLS1_TXT_RSA_WITH_SEED_SHA "SEED-SHA"
+#define TLS1_TXT_DH_DSS_WITH_SEED_SHA "DH-DSS-SEED-SHA"
+#define TLS1_TXT_DH_RSA_WITH_SEED_SHA "DH-RSA-SEED-SHA"
+#define TLS1_TXT_DHE_DSS_WITH_SEED_SHA "DHE-DSS-SEED-SHA"
+#define TLS1_TXT_DHE_RSA_WITH_SEED_SHA "DHE-RSA-SEED-SHA"
+#define TLS1_TXT_ADH_WITH_SEED_SHA "ADH-SEED-SHA"
 
 /* TLS v1.2 ciphersuites */
-# define TLS1_TXT_RSA_WITH_NULL_SHA256                   "NULL-SHA256"
-# define TLS1_TXT_RSA_WITH_AES_128_SHA256                "AES128-SHA256"
-# define TLS1_TXT_RSA_WITH_AES_256_SHA256                "AES256-SHA256"
-# define TLS1_TXT_DH_DSS_WITH_AES_128_SHA256             "DH-DSS-AES128-SHA256"
-# define TLS1_TXT_DH_RSA_WITH_AES_128_SHA256             "DH-RSA-AES128-SHA256"
-# define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256            "DHE-DSS-AES128-SHA256"
-# define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256            "DHE-RSA-AES128-SHA256"
-# define TLS1_TXT_DH_DSS_WITH_AES_256_SHA256             "DH-DSS-AES256-SHA256"
-# define TLS1_TXT_DH_RSA_WITH_AES_256_SHA256             "DH-RSA-AES256-SHA256"
-# define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256            "DHE-DSS-AES256-SHA256"
-# define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256            "DHE-RSA-AES256-SHA256"
-# define TLS1_TXT_ADH_WITH_AES_128_SHA256                "ADH-AES128-SHA256"
-# define TLS1_TXT_ADH_WITH_AES_256_SHA256                "ADH-AES256-SHA256"
+#define TLS1_TXT_RSA_WITH_NULL_SHA256 "NULL-SHA256"
+#define TLS1_TXT_RSA_WITH_AES_128_SHA256 "AES128-SHA256"
+#define TLS1_TXT_RSA_WITH_AES_256_SHA256 "AES256-SHA256"
+#define TLS1_TXT_DH_DSS_WITH_AES_128_SHA256 "DH-DSS-AES128-SHA256"
+#define TLS1_TXT_DH_RSA_WITH_AES_128_SHA256 "DH-RSA-AES128-SHA256"
+#define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256 "DHE-DSS-AES128-SHA256"
+#define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256 "DHE-RSA-AES128-SHA256"
+#define TLS1_TXT_DH_DSS_WITH_AES_256_SHA256 "DH-DSS-AES256-SHA256"
+#define TLS1_TXT_DH_RSA_WITH_AES_256_SHA256 "DH-RSA-AES256-SHA256"
+#define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256 "DHE-DSS-AES256-SHA256"
+#define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256 "DHE-RSA-AES256-SHA256"
+#define TLS1_TXT_ADH_WITH_AES_128_SHA256 "ADH-AES128-SHA256"
+#define TLS1_TXT_ADH_WITH_AES_256_SHA256 "ADH-AES256-SHA256"
 
 /* TLS v1.2 GCM ciphersuites from RFC5288 */
-# define TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256            "AES128-GCM-SHA256"
-# define TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384            "AES256-GCM-SHA384"
-# define TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256        "DHE-RSA-AES128-GCM-SHA256"
-# define TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384        "DHE-RSA-AES256-GCM-SHA384"
-# define TLS1_TXT_DH_RSA_WITH_AES_128_GCM_SHA256         "DH-RSA-AES128-GCM-SHA256"
-# define TLS1_TXT_DH_RSA_WITH_AES_256_GCM_SHA384         "DH-RSA-AES256-GCM-SHA384"
-# define TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256        "DHE-DSS-AES128-GCM-SHA256"
-# define TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384        "DHE-DSS-AES256-GCM-SHA384"
-# define TLS1_TXT_DH_DSS_WITH_AES_128_GCM_SHA256         "DH-DSS-AES128-GCM-SHA256"
-# define TLS1_TXT_DH_DSS_WITH_AES_256_GCM_SHA384         "DH-DSS-AES256-GCM-SHA384"
-# define TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256            "ADH-AES128-GCM-SHA256"
-# define TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384            "ADH-AES256-GCM-SHA384"
+#define TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256 "AES128-GCM-SHA256"
+#define TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384 "AES256-GCM-SHA384"
+#define TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256 "DHE-RSA-AES128-GCM-SHA256"
+#define TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384 "DHE-RSA-AES256-GCM-SHA384"
+#define TLS1_TXT_DH_RSA_WITH_AES_128_GCM_SHA256 "DH-RSA-AES128-GCM-SHA256"
+#define TLS1_TXT_DH_RSA_WITH_AES_256_GCM_SHA384 "DH-RSA-AES256-GCM-SHA384"
+#define TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256 "DHE-DSS-AES128-GCM-SHA256"
+#define TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384 "DHE-DSS-AES256-GCM-SHA384"
+#define TLS1_TXT_DH_DSS_WITH_AES_128_GCM_SHA256 "DH-DSS-AES128-GCM-SHA256"
+#define TLS1_TXT_DH_DSS_WITH_AES_256_GCM_SHA384 "DH-DSS-AES256-GCM-SHA384"
+#define TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256 "ADH-AES128-GCM-SHA256"
+#define TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384 "ADH-AES256-GCM-SHA384"
 
 /* CCM ciphersuites from RFC6655 */
-# define TLS1_TXT_RSA_WITH_AES_128_CCM                   "AES128-CCM"
-# define TLS1_TXT_RSA_WITH_AES_256_CCM                   "AES256-CCM"
-# define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM               "DHE-RSA-AES128-CCM"
-# define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM               "DHE-RSA-AES256-CCM"
-
-# define TLS1_TXT_RSA_WITH_AES_128_CCM_8                 "AES128-CCM8"
-# define TLS1_TXT_RSA_WITH_AES_256_CCM_8                 "AES256-CCM8"
-# define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8             "DHE-RSA-AES128-CCM8"
-# define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8             "DHE-RSA-AES256-CCM8"
-
-# define TLS1_TXT_PSK_WITH_AES_128_CCM                   "PSK-AES128-CCM"
-# define TLS1_TXT_PSK_WITH_AES_256_CCM                   "PSK-AES256-CCM"
-# define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM               "DHE-PSK-AES128-CCM"
-# define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM               "DHE-PSK-AES256-CCM"
-
-# define TLS1_TXT_PSK_WITH_AES_128_CCM_8                 "PSK-AES128-CCM8"
-# define TLS1_TXT_PSK_WITH_AES_256_CCM_8                 "PSK-AES256-CCM8"
-# define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8             "DHE-PSK-AES128-CCM8"
-# define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8             "DHE-PSK-AES256-CCM8"
+#define TLS1_TXT_RSA_WITH_AES_128_CCM "AES128-CCM"
+#define TLS1_TXT_RSA_WITH_AES_256_CCM "AES256-CCM"
+#define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM "DHE-RSA-AES128-CCM"
+#define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM "DHE-RSA-AES256-CCM"
+
+#define TLS1_TXT_RSA_WITH_AES_128_CCM_8 "AES128-CCM8"
+#define TLS1_TXT_RSA_WITH_AES_256_CCM_8 "AES256-CCM8"
+#define TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8 "DHE-RSA-AES128-CCM8"
+#define TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8 "DHE-RSA-AES256-CCM8"
+
+#define TLS1_TXT_PSK_WITH_AES_128_CCM "PSK-AES128-CCM"
+#define TLS1_TXT_PSK_WITH_AES_256_CCM "PSK-AES256-CCM"
+#define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM "DHE-PSK-AES128-CCM"
+#define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM "DHE-PSK-AES256-CCM"
+
+#define TLS1_TXT_PSK_WITH_AES_128_CCM_8 "PSK-AES128-CCM8"
+#define TLS1_TXT_PSK_WITH_AES_256_CCM_8 "PSK-AES256-CCM8"
+#define TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8 "DHE-PSK-AES128-CCM8"
+#define TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8 "DHE-PSK-AES256-CCM8"
 
 /* CCM ciphersuites from RFC7251 */
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM       "ECDHE-ECDSA-AES128-CCM"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM       "ECDHE-ECDSA-AES256-CCM"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8     "ECDHE-ECDSA-AES128-CCM8"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8     "ECDHE-ECDSA-AES256-CCM8"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM "ECDHE-ECDSA-AES128-CCM"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM "ECDHE-ECDSA-AES256-CCM"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8 "ECDHE-ECDSA-AES128-CCM8"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8 "ECDHE-ECDSA-AES256-CCM8"
 
 /* ECDH HMAC based ciphersuites from RFC5289 */
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256    "ECDHE-ECDSA-AES128-SHA256"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384    "ECDHE-ECDSA-AES256-SHA384"
-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_SHA256     "ECDH-ECDSA-AES128-SHA256"
-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_SHA384     "ECDH-ECDSA-AES256-SHA384"
-# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256      "ECDHE-RSA-AES128-SHA256"
-# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384      "ECDHE-RSA-AES256-SHA384"
-# define TLS1_TXT_ECDH_RSA_WITH_AES_128_SHA256       "ECDH-RSA-AES128-SHA256"
-# define TLS1_TXT_ECDH_RSA_WITH_AES_256_SHA384       "ECDH-RSA-AES256-SHA384"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256 "ECDHE-ECDSA-AES128-SHA256"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384 "ECDHE-ECDSA-AES256-SHA384"
+#define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_SHA256 "ECDH-ECDSA-AES128-SHA256"
+#define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_SHA384 "ECDH-ECDSA-AES256-SHA384"
+#define TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256 "ECDHE-RSA-AES128-SHA256"
+#define TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384 "ECDHE-RSA-AES256-SHA384"
+#define TLS1_TXT_ECDH_RSA_WITH_AES_128_SHA256 "ECDH-RSA-AES128-SHA256"
+#define TLS1_TXT_ECDH_RSA_WITH_AES_256_SHA384 "ECDH-RSA-AES256-SHA384"
 
 /* ECDH GCM based ciphersuites from RFC5289 */
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256    "ECDHE-ECDSA-AES128-GCM-SHA256"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384    "ECDHE-ECDSA-AES256-GCM-SHA384"
-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_GCM_SHA256     "ECDH-ECDSA-AES128-GCM-SHA256"
-# define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_GCM_SHA384     "ECDH-ECDSA-AES256-GCM-SHA384"
-# define TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256      "ECDHE-RSA-AES128-GCM-SHA256"
-# define TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384      "ECDHE-RSA-AES256-GCM-SHA384"
-# define TLS1_TXT_ECDH_RSA_WITH_AES_128_GCM_SHA256       "ECDH-RSA-AES128-GCM-SHA256"
-# define TLS1_TXT_ECDH_RSA_WITH_AES_256_GCM_SHA384       "ECDH-RSA-AES256-GCM-SHA384"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 "ECDHE-ECDSA-AES128-GCM-SHA256"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 "ECDHE-ECDSA-AES256-GCM-SHA384"
+#define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 "ECDH-ECDSA-AES128-GCM-SHA256"
+#define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 "ECDH-ECDSA-AES256-GCM-SHA384"
+#define TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256 "ECDHE-RSA-AES128-GCM-SHA256"
+#define TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384 "ECDHE-RSA-AES256-GCM-SHA384"
+#define TLS1_TXT_ECDH_RSA_WITH_AES_128_GCM_SHA256 "ECDH-RSA-AES128-GCM-SHA256"
+#define TLS1_TXT_ECDH_RSA_WITH_AES_256_GCM_SHA384 "ECDH-RSA-AES256-GCM-SHA384"
 
 /* TLS v1.2 PSK GCM ciphersuites from RFC5487 */
-# define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256            "PSK-AES128-GCM-SHA256"
-# define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384            "PSK-AES256-GCM-SHA384"
+#define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256 "PSK-AES128-GCM-SHA256"
+#define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384 "PSK-AES256-GCM-SHA384"
 
 /* ECDHE PSK ciphersuites from RFC 5489 */
-# define TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA               "ECDHE-PSK-RC4-SHA"
-# define TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA          "ECDHE-PSK-3DES-EDE-CBC-SHA"
-# define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA           "ECDHE-PSK-AES128-CBC-SHA"
-# define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA           "ECDHE-PSK-AES256-CBC-SHA"
+#define TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA "ECDHE-PSK-RC4-SHA"
+#define TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA "ECDHE-PSK-3DES-EDE-CBC-SHA"
+#define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA "ECDHE-PSK-AES128-CBC-SHA"
+#define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA "ECDHE-PSK-AES256-CBC-SHA"
 
-# define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256        "ECDHE-PSK-AES128-CBC-SHA256"
-# define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384        "ECDHE-PSK-AES256-CBC-SHA384"
+#define TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256 "ECDHE-PSK-AES128-CBC-SHA256"
+#define TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384 "ECDHE-PSK-AES256-CBC-SHA384"
 
-# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA                  "ECDHE-PSK-NULL-SHA"
-# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256               "ECDHE-PSK-NULL-SHA256"
-# define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384               "ECDHE-PSK-NULL-SHA384"
+#define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA "ECDHE-PSK-NULL-SHA"
+#define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256 "ECDHE-PSK-NULL-SHA256"
+#define TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384 "ECDHE-PSK-NULL-SHA384"
 
 /* Camellia-CBC ciphersuites from RFC6367 */
-# define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-ECDSA-CAMELLIA128-SHA256"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-ECDSA-CAMELLIA256-SHA384"
-# define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256  "ECDH-ECDSA-CAMELLIA128-SHA256"
-# define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384  "ECDH-ECDSA-CAMELLIA256-SHA384"
-# define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256   "ECDHE-RSA-CAMELLIA128-SHA256"
-# define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384   "ECDHE-RSA-CAMELLIA256-SHA384"
-# define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256    "ECDH-RSA-CAMELLIA128-SHA256"
-# define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384    "ECDH-RSA-CAMELLIA256-SHA384"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-ECDSA-CAMELLIA128-SHA256"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-ECDSA-CAMELLIA256-SHA384"
+#define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDH-ECDSA-CAMELLIA128-SHA256"
+#define TLS1_TXT_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDH-ECDSA-CAMELLIA256-SHA384"
+#define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDHE-RSA-CAMELLIA128-SHA256"
+#define TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDHE-RSA-CAMELLIA256-SHA384"
+#define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 "ECDH-RSA-CAMELLIA128-SHA256"
+#define TLS1_TXT_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 "ECDH-RSA-CAMELLIA256-SHA384"
 
 /* draft-ietf-tls-chacha20-poly1305-03 */
-# define TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305         "ECDHE-RSA-CHACHA20-POLY1305"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305       "ECDHE-ECDSA-CHACHA20-POLY1305"
-# define TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305           "DHE-RSA-CHACHA20-POLY1305"
-# define TLS1_TXT_PSK_WITH_CHACHA20_POLY1305               "PSK-CHACHA20-POLY1305"
-# define TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305         "ECDHE-PSK-CHACHA20-POLY1305"
-# define TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305           "DHE-PSK-CHACHA20-POLY1305"
-# define TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305           "RSA-PSK-CHACHA20-POLY1305"
+#define TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305 "ECDHE-RSA-CHACHA20-POLY1305"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305 "ECDHE-ECDSA-CHACHA20-POLY1305"
+#define TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305 "DHE-RSA-CHACHA20-POLY1305"
+#define TLS1_TXT_PSK_WITH_CHACHA20_POLY1305 "PSK-CHACHA20-POLY1305"
+#define TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305 "ECDHE-PSK-CHACHA20-POLY1305"
+#define TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305 "DHE-PSK-CHACHA20-POLY1305"
+#define TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305 "RSA-PSK-CHACHA20-POLY1305"
 
 /* Aria ciphersuites from RFC6209 */
-# define TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256             "ARIA128-GCM-SHA256"
-# define TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384             "ARIA256-GCM-SHA384"
-# define TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256         "DHE-RSA-ARIA128-GCM-SHA256"
-# define TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384         "DHE-RSA-ARIA256-GCM-SHA384"
-# define TLS1_TXT_DH_RSA_WITH_ARIA_128_GCM_SHA256          "DH-RSA-ARIA128-GCM-SHA256"
-# define TLS1_TXT_DH_RSA_WITH_ARIA_256_GCM_SHA384          "DH-RSA-ARIA256-GCM-SHA384"
-# define TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256         "DHE-DSS-ARIA128-GCM-SHA256"
-# define TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384         "DHE-DSS-ARIA256-GCM-SHA384"
-# define TLS1_TXT_DH_DSS_WITH_ARIA_128_GCM_SHA256          "DH-DSS-ARIA128-GCM-SHA256"
-# define TLS1_TXT_DH_DSS_WITH_ARIA_256_GCM_SHA384          "DH-DSS-ARIA256-GCM-SHA384"
-# define TLS1_TXT_DH_anon_WITH_ARIA_128_GCM_SHA256         "ADH-ARIA128-GCM-SHA256"
-# define TLS1_TXT_DH_anon_WITH_ARIA_256_GCM_SHA384         "ADH-ARIA256-GCM-SHA384"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256     "ECDHE-ECDSA-ARIA128-GCM-SHA256"
-# define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384     "ECDHE-ECDSA-ARIA256-GCM-SHA384"
-# define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256      "ECDH-ECDSA-ARIA128-GCM-SHA256"
-# define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384      "ECDH-ECDSA-ARIA256-GCM-SHA384"
-# define TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256       "ECDHE-ARIA128-GCM-SHA256"
-# define TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384       "ECDHE-ARIA256-GCM-SHA384"
-# define TLS1_TXT_ECDH_RSA_WITH_ARIA_128_GCM_SHA256        "ECDH-ARIA128-GCM-SHA256"
-# define TLS1_TXT_ECDH_RSA_WITH_ARIA_256_GCM_SHA384        "ECDH-ARIA256-GCM-SHA384"
-# define TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256             "PSK-ARIA128-GCM-SHA256"
-# define TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384             "PSK-ARIA256-GCM-SHA384"
-# define TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256         "DHE-PSK-ARIA128-GCM-SHA256"
-# define TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384         "DHE-PSK-ARIA256-GCM-SHA384"
-# define TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256         "RSA-PSK-ARIA128-GCM-SHA256"
-# define TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384         "RSA-PSK-ARIA256-GCM-SHA384"
-
-# define TLS_CT_RSA_SIGN                 1
-# define TLS_CT_DSS_SIGN                 2
-# define TLS_CT_RSA_FIXED_DH             3
-# define TLS_CT_DSS_FIXED_DH             4
-# define TLS_CT_ECDSA_SIGN               64
-# define TLS_CT_RSA_FIXED_ECDH           65
-# define TLS_CT_ECDSA_FIXED_ECDH         66
-# define TLS_CT_GOST01_SIGN              22
-# define TLS_CT_GOST12_IANA_SIGN         67
-# define TLS_CT_GOST12_IANA_512_SIGN     68
-# define TLS_CT_GOST12_LEGACY_SIGN       238
-# define TLS_CT_GOST12_LEGACY_512_SIGN   239
-
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define TLS_CT_GOST12_SIGN TLS_CT_GOST12_LEGACY_SIGN
-#  define TLS_CT_GOST12_512_SIGN TLS_CT_GOST12_LEGACY_512_SIGN
-# endif
+#define TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256 "ARIA128-GCM-SHA256"
+#define TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384 "ARIA256-GCM-SHA384"
+#define TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256 "DHE-RSA-ARIA128-GCM-SHA256"
+#define TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384 "DHE-RSA-ARIA256-GCM-SHA384"
+#define TLS1_TXT_DH_RSA_WITH_ARIA_128_GCM_SHA256 "DH-RSA-ARIA128-GCM-SHA256"
+#define TLS1_TXT_DH_RSA_WITH_ARIA_256_GCM_SHA384 "DH-RSA-ARIA256-GCM-SHA384"
+#define TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256 "DHE-DSS-ARIA128-GCM-SHA256"
+#define TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384 "DHE-DSS-ARIA256-GCM-SHA384"
+#define TLS1_TXT_DH_DSS_WITH_ARIA_128_GCM_SHA256 "DH-DSS-ARIA128-GCM-SHA256"
+#define TLS1_TXT_DH_DSS_WITH_ARIA_256_GCM_SHA384 "DH-DSS-ARIA256-GCM-SHA384"
+#define TLS1_TXT_DH_anon_WITH_ARIA_128_GCM_SHA256 "ADH-ARIA128-GCM-SHA256"
+#define TLS1_TXT_DH_anon_WITH_ARIA_256_GCM_SHA384 "ADH-ARIA256-GCM-SHA384"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 "ECDHE-ECDSA-ARIA128-GCM-SHA256"
+#define TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 "ECDHE-ECDSA-ARIA256-GCM-SHA384"
+#define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 "ECDH-ECDSA-ARIA128-GCM-SHA256"
+#define TLS1_TXT_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 "ECDH-ECDSA-ARIA256-GCM-SHA384"
+#define TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 "ECDHE-ARIA128-GCM-SHA256"
+#define TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 "ECDHE-ARIA256-GCM-SHA384"
+#define TLS1_TXT_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 "ECDH-ARIA128-GCM-SHA256"
+#define TLS1_TXT_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 "ECDH-ARIA256-GCM-SHA384"
+#define TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256 "PSK-ARIA128-GCM-SHA256"
+#define TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384 "PSK-ARIA256-GCM-SHA384"
+#define TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256 "DHE-PSK-ARIA128-GCM-SHA256"
+#define TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384 "DHE-PSK-ARIA256-GCM-SHA384"
+#define TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256 "RSA-PSK-ARIA128-GCM-SHA256"
+#define TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384 "RSA-PSK-ARIA256-GCM-SHA384"
+
+#define TLS_CT_RSA_SIGN 1
+#define TLS_CT_DSS_SIGN 2
+#define TLS_CT_RSA_FIXED_DH 3
+#define TLS_CT_DSS_FIXED_DH 4
+#define TLS_CT_ECDSA_SIGN 64
+#define TLS_CT_RSA_FIXED_ECDH 65
+#define TLS_CT_ECDSA_FIXED_ECDH 66
+#define TLS_CT_GOST01_SIGN 22
+#define TLS_CT_GOST12_IANA_SIGN 67
+#define TLS_CT_GOST12_IANA_512_SIGN 68
+#define TLS_CT_GOST12_LEGACY_SIGN 238
+#define TLS_CT_GOST12_LEGACY_512_SIGN 239
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define TLS_CT_GOST12_SIGN TLS_CT_GOST12_LEGACY_SIGN
+#define TLS_CT_GOST12_512_SIGN TLS_CT_GOST12_LEGACY_512_SIGN
+#endif
 
 /*
  * when correcting this number, correct also SSL3_CT_NUMBER in ssl3.h (see
  * comment there)
  */
-# define TLS_CT_NUMBER                   12
-
-# if defined(SSL3_CT_NUMBER)
-#  if TLS_CT_NUMBER != SSL3_CT_NUMBER
-#    error "SSL/TLS CT_NUMBER values do not match"
-#  endif
-# endif
-
-# define TLS1_FINISH_MAC_LENGTH          12
-
-# define TLS_MD_MAX_CONST_SIZE                   22
-# define TLS_MD_CLIENT_FINISH_CONST              "client finished"
-# define TLS_MD_CLIENT_FINISH_CONST_SIZE         15
-# define TLS_MD_SERVER_FINISH_CONST              "server finished"
-# define TLS_MD_SERVER_FINISH_CONST_SIZE         15
-# define TLS_MD_KEY_EXPANSION_CONST              "key expansion"
-# define TLS_MD_KEY_EXPANSION_CONST_SIZE         13
-# define TLS_MD_CLIENT_WRITE_KEY_CONST           "client write key"
-# define TLS_MD_CLIENT_WRITE_KEY_CONST_SIZE      16
-# define TLS_MD_SERVER_WRITE_KEY_CONST           "server write key"
-# define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE      16
-# define TLS_MD_IV_BLOCK_CONST                   "IV block"
-# define TLS_MD_IV_BLOCK_CONST_SIZE              8
-# define TLS_MD_MASTER_SECRET_CONST              "master secret"
-# define TLS_MD_MASTER_SECRET_CONST_SIZE         13
-# define TLS_MD_EXTENDED_MASTER_SECRET_CONST     "extended master secret"
-# define TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE        22
-
-# ifdef CHARSET_EBCDIC
-#  undef TLS_MD_CLIENT_FINISH_CONST
+#define TLS_CT_NUMBER 12
+
+#if defined(SSL3_CT_NUMBER)
+#if TLS_CT_NUMBER != SSL3_CT_NUMBER
+#error "SSL/TLS CT_NUMBER values do not match"
+#endif
+#endif
+
+#define TLS1_FINISH_MAC_LENGTH 12
+
+#define TLS_MD_MAX_CONST_SIZE 22
+#define TLS_MD_CLIENT_FINISH_CONST "client finished"
+#define TLS_MD_CLIENT_FINISH_CONST_SIZE 15
+#define TLS_MD_SERVER_FINISH_CONST "server finished"
+#define TLS_MD_SERVER_FINISH_CONST_SIZE 15
+#define TLS_MD_KEY_EXPANSION_CONST "key expansion"
+#define TLS_MD_KEY_EXPANSION_CONST_SIZE 13
+#define TLS_MD_CLIENT_WRITE_KEY_CONST "client write key"
+#define TLS_MD_CLIENT_WRITE_KEY_CONST_SIZE 16
+#define TLS_MD_SERVER_WRITE_KEY_CONST "server write key"
+#define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE 16
+#define TLS_MD_IV_BLOCK_CONST "IV block"
+#define TLS_MD_IV_BLOCK_CONST_SIZE 8
+#define TLS_MD_MASTER_SECRET_CONST "master secret"
+#define TLS_MD_MASTER_SECRET_CONST_SIZE 13
+#define TLS_MD_EXTENDED_MASTER_SECRET_CONST "extended master secret"
+#define TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE 22
+
+#ifdef CHARSET_EBCDIC
+#undef TLS_MD_CLIENT_FINISH_CONST
 /*
  * client finished
  */
-#  define TLS_MD_CLIENT_FINISH_CONST    "\x63\x6c\x69\x65\x6e\x74\x20\x66\x69\x6e\x69\x73\x68\x65\x64"
+#define TLS_MD_CLIENT_FINISH_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x66\x69\x6e\x69\x73\x68\x65\x64"
 
-#  undef TLS_MD_SERVER_FINISH_CONST
+#undef TLS_MD_SERVER_FINISH_CONST
 /*
  * server finished
  */
-#  define TLS_MD_SERVER_FINISH_CONST    "\x73\x65\x72\x76\x65\x72\x20\x66\x69\x6e\x69\x73\x68\x65\x64"
+#define TLS_MD_SERVER_FINISH_CONST "\x73\x65\x72\x76\x65\x72\x20\x66\x69\x6e\x69\x73\x68\x65\x64"
 
-#  undef TLS_MD_SERVER_WRITE_KEY_CONST
+#undef TLS_MD_SERVER_WRITE_KEY_CONST
 /*
  * server write key
  */
-#  define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+#define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
 
-#  undef TLS_MD_KEY_EXPANSION_CONST
+#undef TLS_MD_KEY_EXPANSION_CONST
 /*
  * key expansion
  */
-#  define TLS_MD_KEY_EXPANSION_CONST    "\x6b\x65\x79\x20\x65\x78\x70\x61\x6e\x73\x69\x6f\x6e"
+#define TLS_MD_KEY_EXPANSION_CONST "\x6b\x65\x79\x20\x65\x78\x70\x61\x6e\x73\x69\x6f\x6e"
 
-#  undef TLS_MD_CLIENT_WRITE_KEY_CONST
+#undef TLS_MD_CLIENT_WRITE_KEY_CONST
 /*
  * client write key
  */
-#  define TLS_MD_CLIENT_WRITE_KEY_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+#define TLS_MD_CLIENT_WRITE_KEY_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
 
-#  undef TLS_MD_SERVER_WRITE_KEY_CONST
+#undef TLS_MD_SERVER_WRITE_KEY_CONST
 /*
  * server write key
  */
-#  define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
+#define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
 
-#  undef TLS_MD_IV_BLOCK_CONST
+#undef TLS_MD_IV_BLOCK_CONST
 /*
  * IV block
  */
-#  define TLS_MD_IV_BLOCK_CONST         "\x49\x56\x20\x62\x6c\x6f\x63\x6b"
+#define TLS_MD_IV_BLOCK_CONST "\x49\x56\x20\x62\x6c\x6f\x63\x6b"
 
-#  undef TLS_MD_MASTER_SECRET_CONST
+#undef TLS_MD_MASTER_SECRET_CONST
 /*
  * master secret
  */
-#  define TLS_MD_MASTER_SECRET_CONST    "\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"
-#  undef TLS_MD_EXTENDED_MASTER_SECRET_CONST
+#define TLS_MD_MASTER_SECRET_CONST "\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"
+#undef TLS_MD_EXTENDED_MASTER_SECRET_CONST
 /*
  * extended master secret
  */
-#  define TLS_MD_EXTENDED_MASTER_SECRET_CONST    "\x65\x78\x74\x65\x6e\x64\x65\x64\x20\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"
-# endif
+#define TLS_MD_EXTENDED_MASTER_SECRET_CONST "\x65\x78\x74\x65\x6e\x64\x65\x64\x20\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74"
+#endif
 
-/* TLS Session Ticket extension struct */
-struct tls_session_ticket_ext_st {
-    unsigned short length;
-    void *data;
-};
+    /* TLS Session Ticket extension struct */
+    struct tls_session_ticket_ext_st
+    {
+        unsigned short length;
+        void* data;
+    };
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/trace.h b/CAPI/cpp/grpc/include/openssl/trace.h
index 2820013..6cadef7 100644
--- a/CAPI/cpp/grpc/include/openssl/trace.h
+++ b/CAPI/cpp/grpc/include/openssl/trace.h
@@ -8,16 +8,17 @@
  */
 
 #ifndef OPENSSL_TRACE_H
-# define OPENSSL_TRACE_H
-# pragma once
+#define OPENSSL_TRACE_H
+#pragma once
 
-# include <stdarg.h>
+#include <stdarg.h>
 
-# include <openssl/bio.h>
+#include <openssl/bio.h>
 
-# ifdef  __cplusplus
-extern "C" {
-# endif
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
 /*
  * TRACE CATEGORIES
@@ -37,196 +38,199 @@ extern "C" {
  * it is better to register channels for all categories separately.
  * (This is how the openssl application does it.)
  */
-# define OSSL_TRACE_CATEGORY_ALL                 0 /* The fallback */
-# define OSSL_TRACE_CATEGORY_TRACE               1
-# define OSSL_TRACE_CATEGORY_INIT                2
-# define OSSL_TRACE_CATEGORY_TLS                 3
-# define OSSL_TRACE_CATEGORY_TLS_CIPHER          4
-# define OSSL_TRACE_CATEGORY_CONF                5
-# ifndef OPENSSL_NO_ENGINE
-#  define OSSL_TRACE_CATEGORY_ENGINE_TABLE       6
-#  define OSSL_TRACE_CATEGORY_ENGINE_REF_COUNT   7
-# endif
-# define OSSL_TRACE_CATEGORY_PKCS5V2             8
-# define OSSL_TRACE_CATEGORY_PKCS12_KEYGEN       9
-# define OSSL_TRACE_CATEGORY_PKCS12_DECRYPT     10
-# define OSSL_TRACE_CATEGORY_X509V3_POLICY      11
-# define OSSL_TRACE_CATEGORY_BN_CTX             12
-# define OSSL_TRACE_CATEGORY_CMP                13
-# define OSSL_TRACE_CATEGORY_STORE              14
-# define OSSL_TRACE_CATEGORY_DECODER            15
-# define OSSL_TRACE_CATEGORY_ENCODER            16
-# define OSSL_TRACE_CATEGORY_REF_COUNT          17
+#define OSSL_TRACE_CATEGORY_ALL 0 /* The fallback */
+#define OSSL_TRACE_CATEGORY_TRACE 1
+#define OSSL_TRACE_CATEGORY_INIT 2
+#define OSSL_TRACE_CATEGORY_TLS 3
+#define OSSL_TRACE_CATEGORY_TLS_CIPHER 4
+#define OSSL_TRACE_CATEGORY_CONF 5
+#ifndef OPENSSL_NO_ENGINE
+#define OSSL_TRACE_CATEGORY_ENGINE_TABLE 6
+#define OSSL_TRACE_CATEGORY_ENGINE_REF_COUNT 7
+#endif
+#define OSSL_TRACE_CATEGORY_PKCS5V2 8
+#define OSSL_TRACE_CATEGORY_PKCS12_KEYGEN 9
+#define OSSL_TRACE_CATEGORY_PKCS12_DECRYPT 10
+#define OSSL_TRACE_CATEGORY_X509V3_POLICY 11
+#define OSSL_TRACE_CATEGORY_BN_CTX 12
+#define OSSL_TRACE_CATEGORY_CMP 13
+#define OSSL_TRACE_CATEGORY_STORE 14
+#define OSSL_TRACE_CATEGORY_DECODER 15
+#define OSSL_TRACE_CATEGORY_ENCODER 16
+#define OSSL_TRACE_CATEGORY_REF_COUNT 17
 /* Count of available categories. */
-# define OSSL_TRACE_CATEGORY_NUM                18
-
-/* Returns the trace category number for the given |name| */
-int OSSL_trace_get_category_num(const char *name);
-
-/* Returns the trace category name for the given |num| */
-const char *OSSL_trace_get_category_name(int num);
-
-/*
- * TRACE CONSUMERS
- */
-
-/*
- * Enables tracing for the given |category| by providing a BIO sink
- * as |channel|. If a null pointer is passed as |channel|, an existing
- * trace channel is removed and tracing for the category is disabled.
- *
- * Returns 1 on success and 0 on failure
- */
-int OSSL_trace_set_channel(int category, BIO* channel);
-
-/*
- * Attach a prefix and a suffix to the given |category|, to be printed at the
- * beginning and at the end of each trace output group, i.e. when
- * OSSL_trace_begin() and OSSL_trace_end() are called.
- * If a null pointer is passed as argument, the existing prefix or suffix is
- * removed.
- *
- * They return 1 on success and 0 on failure
- */
-int OSSL_trace_set_prefix(int category, const char *prefix);
-int OSSL_trace_set_suffix(int category, const char *suffix);
-
-/*
- * OSSL_trace_cb is the type tracing callback provided by the application.
- * It MUST return the number of bytes written, or 0 on error (in other words,
- * it can never write zero bytes).
- *
- * The |buffer| will always contain text, which may consist of several lines.
- * The |data| argument points to whatever data was provided by the application
- * when registering the tracer function.
- *
- * The |category| number is given, as well as a |cmd| number, described below.
- */
-typedef size_t (*OSSL_trace_cb)(const char *buffer, size_t count,
-                                int category, int cmd, void *data);
+#define OSSL_TRACE_CATEGORY_NUM 18
+
+    /* Returns the trace category number for the given |name| */
+    int OSSL_trace_get_category_num(const char* name);
+
+    /* Returns the trace category name for the given |num| */
+    const char* OSSL_trace_get_category_name(int num);
+
+    /*
+     * TRACE CONSUMERS
+     */
+
+    /*
+     * Enables tracing for the given |category| by providing a BIO sink
+     * as |channel|. If a null pointer is passed as |channel|, an existing
+     * trace channel is removed and tracing for the category is disabled.
+     *
+     * Returns 1 on success and 0 on failure
+     */
+    int OSSL_trace_set_channel(int category, BIO* channel);
+
+    /*
+     * Attach a prefix and a suffix to the given |category|, to be printed at the
+     * beginning and at the end of each trace output group, i.e. when
+     * OSSL_trace_begin() and OSSL_trace_end() are called.
+     * If a null pointer is passed as argument, the existing prefix or suffix is
+     * removed.
+     *
+     * They return 1 on success and 0 on failure
+     */
+    int OSSL_trace_set_prefix(int category, const char* prefix);
+    int OSSL_trace_set_suffix(int category, const char* suffix);
+
+    /*
+     * OSSL_trace_cb is the type tracing callback provided by the application.
+     * It MUST return the number of bytes written, or 0 on error (in other words,
+     * it can never write zero bytes).
+     *
+     * The |buffer| will always contain text, which may consist of several lines.
+     * The |data| argument points to whatever data was provided by the application
+     * when registering the tracer function.
+     *
+     * The |category| number is given, as well as a |cmd| number, described below.
+     */
+    typedef size_t (*OSSL_trace_cb)(const char* buffer, size_t count, int category, int cmd, void* data);
 /*
  * Possible |cmd| numbers.
  */
-# define OSSL_TRACE_CTRL_BEGIN  0
-# define OSSL_TRACE_CTRL_WRITE  1
-# define OSSL_TRACE_CTRL_END    2
-
-/*
- * Enables tracing for the given |category| by creating an internal
- * trace channel which sends the output to the given |callback|.
- * If a null pointer is passed as callback, an existing trace channel
- * is removed and tracing for the category is disabled.
- *
- * NOTE: OSSL_trace_set_channel() and OSSL_trace_set_callback() are mutually
- *       exclusive.
- *
- * Returns 1 on success and 0 on failure
- */
-int OSSL_trace_set_callback(int category, OSSL_trace_cb callback, void *data);
-
-/*
- * TRACE PRODUCERS
- */
-
-/*
- * Returns 1 if tracing for the specified category is enabled, otherwise 0
- */
-int OSSL_trace_enabled(int category);
-
-/*
- * Wrap a group of tracing output calls.  OSSL_trace_begin() locks tracing and
- * returns the trace channel associated with the given category, or NULL if no
- * channel is associated with the category.  OSSL_trace_end() unlocks tracing.
- *
- * Usage:
- *
- *    BIO *out;
- *    if ((out = OSSL_trace_begin(category)) != NULL) {
- *        ...
- *        BIO_fprintf(out, ...);
- *        ...
- *        OSSL_trace_end(category, out);
- *    }
- *
- * See also the convenience macros OSSL_TRACE_BEGIN and OSSL_TRACE_END below.
- */
-BIO *OSSL_trace_begin(int category);
-void OSSL_trace_end(int category, BIO *channel);
-
-/*
- * OSSL_TRACE* Convenience Macros
- */
-
-/*
- * When the tracing feature is disabled, these macros are defined to
- * produce dead code, which a good compiler should eliminate.
- */
-
-/*
- * OSSL_TRACE_BEGIN, OSSL_TRACE_END - Define a Trace Group
- *
- * These two macros can be used to create a block which is executed only
- * if the corresponding trace category is enabled. Inside this block, a
- * local variable named |trc_out| is defined, which points to the channel
- * associated with the given trace category.
- *
- * Usage: (using 'TLS' as an example category)
- *
- *     OSSL_TRACE_BEGIN(TLS) {
- *
- *         BIO_fprintf(trc_out, ... );
- *
- *     } OSSL_TRACE_END(TLS);
- *
- *
- * This expands to the following code
- *
- *     do {
- *         BIO *trc_out = OSSL_trace_begin(OSSL_TRACE_CATEGORY_TLS);
- *         if (trc_out != NULL) {
- *             ...
- *             BIO_fprintf(trc_out, ...);
- *         }
- *         OSSL_trace_end(OSSL_TRACE_CATEGORY_TLS, trc_out);
- *     } while (0);
- *
- * The use of the inner '{...}' group and the trailing ';' is enforced
- * by the definition of the macros in order to make the code look as much
- * like C code as possible.
- *
- * Before returning from inside the trace block, it is necessary to
- * call OSSL_TRACE_CANCEL(category).
- */
-
-# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
-
-#  define OSSL_TRACE_BEGIN(category) \
-    do { \
-        BIO *trc_out = OSSL_trace_begin(OSSL_TRACE_CATEGORY_##category); \
- \
+#define OSSL_TRACE_CTRL_BEGIN 0
+#define OSSL_TRACE_CTRL_WRITE 1
+#define OSSL_TRACE_CTRL_END 2
+
+    /*
+     * Enables tracing for the given |category| by creating an internal
+     * trace channel which sends the output to the given |callback|.
+     * If a null pointer is passed as callback, an existing trace channel
+     * is removed and tracing for the category is disabled.
+     *
+     * NOTE: OSSL_trace_set_channel() and OSSL_trace_set_callback() are mutually
+     *       exclusive.
+     *
+     * Returns 1 on success and 0 on failure
+     */
+    int OSSL_trace_set_callback(int category, OSSL_trace_cb callback, void* data);
+
+    /*
+     * TRACE PRODUCERS
+     */
+
+    /*
+     * Returns 1 if tracing for the specified category is enabled, otherwise 0
+     */
+    int OSSL_trace_enabled(int category);
+
+    /*
+     * Wrap a group of tracing output calls.  OSSL_trace_begin() locks tracing and
+     * returns the trace channel associated with the given category, or NULL if no
+     * channel is associated with the category.  OSSL_trace_end() unlocks tracing.
+     *
+     * Usage:
+     *
+     *    BIO *out;
+     *    if ((out = OSSL_trace_begin(category)) != NULL) {
+     *        ...
+     *        BIO_fprintf(out, ...);
+     *        ...
+     *        OSSL_trace_end(category, out);
+     *    }
+     *
+     * See also the convenience macros OSSL_TRACE_BEGIN and OSSL_TRACE_END below.
+     */
+    BIO* OSSL_trace_begin(int category);
+    void OSSL_trace_end(int category, BIO* channel);
+
+    /*
+     * OSSL_TRACE* Convenience Macros
+     */
+
+    /*
+     * When the tracing feature is disabled, these macros are defined to
+     * produce dead code, which a good compiler should eliminate.
+     */
+
+    /*
+     * OSSL_TRACE_BEGIN, OSSL_TRACE_END - Define a Trace Group
+     *
+     * These two macros can be used to create a block which is executed only
+     * if the corresponding trace category is enabled. Inside this block, a
+     * local variable named |trc_out| is defined, which points to the channel
+     * associated with the given trace category.
+     *
+     * Usage: (using 'TLS' as an example category)
+     *
+     *     OSSL_TRACE_BEGIN(TLS) {
+     *
+     *         BIO_fprintf(trc_out, ... );
+     *
+     *     } OSSL_TRACE_END(TLS);
+     *
+     *
+     * This expands to the following code
+     *
+     *     do {
+     *         BIO *trc_out = OSSL_trace_begin(OSSL_TRACE_CATEGORY_TLS);
+     *         if (trc_out != NULL) {
+     *             ...
+     *             BIO_fprintf(trc_out, ...);
+     *         }
+     *         OSSL_trace_end(OSSL_TRACE_CATEGORY_TLS, trc_out);
+     *     } while (0);
+     *
+     * The use of the inner '{...}' group and the trailing ';' is enforced
+     * by the definition of the macros in order to make the code look as much
+     * like C code as possible.
+     *
+     * Before returning from inside the trace block, it is necessary to
+     * call OSSL_TRACE_CANCEL(category).
+     */
+
+#if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+
+#define OSSL_TRACE_BEGIN(category)                                       \
+    do                                                                   \
+    {                                                                    \
+        BIO* trc_out = OSSL_trace_begin(OSSL_TRACE_CATEGORY_##category); \
+                                                                         \
         if (trc_out != NULL)
 
-#  define OSSL_TRACE_END(category) \
-        OSSL_trace_end(OSSL_TRACE_CATEGORY_##category, trc_out); \
-    } while (0)
+#define OSSL_TRACE_END(category)                             \
+    OSSL_trace_end(OSSL_TRACE_CATEGORY_##category, trc_out); \
+    }                                                        \
+    while (0)
 
-#  define OSSL_TRACE_CANCEL(category) \
-        OSSL_trace_end(OSSL_TRACE_CATEGORY_##category, trc_out) \
+#define OSSL_TRACE_CANCEL(category) \
+    OSSL_trace_end(OSSL_TRACE_CATEGORY_##category, trc_out)
 
-# else
+#else
 
-#  define OSSL_TRACE_BEGIN(category)           \
-    do {                                        \
-        BIO *trc_out = NULL;                    \
+#define OSSL_TRACE_BEGIN(category) \
+    do                             \
+    {                              \
+        BIO* trc_out = NULL;       \
         if (0)
 
-#  define OSSL_TRACE_END(category)             \
-    } while(0)
+#define OSSL_TRACE_END(category) \
+    }                            \
+    while (0)
 
-#  define OSSL_TRACE_CANCEL(category)          \
+#define OSSL_TRACE_CANCEL(category) \
     ((void)0)
 
-# endif
+#endif
 
 /*
  * OSSL_TRACE_ENABLED() - Check whether tracing is enabled for |category|
@@ -237,76 +241,76 @@ void OSSL_trace_end(int category, BIO *channel);
  *         ...
  *     }
  */
-# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+#if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
 
-#  define OSSL_TRACE_ENABLED(category) \
+#define OSSL_TRACE_ENABLED(category) \
     OSSL_trace_enabled(OSSL_TRACE_CATEGORY_##category)
 
-# else
+#else
 
-#  define OSSL_TRACE_ENABLED(category) (0)
-
-# endif
-
-/*
- * OSSL_TRACE*() - OneShot Trace Macros
- *
- * These macros are intended to produce a simple printf-style trace output.
- * Unfortunately, C90 macros don't support variable arguments, so the
- * "vararg" OSSL_TRACEV() macro has a rather weird usage pattern:
- *
- *    OSSL_TRACEV(category, (trc_out, "format string", ...args...));
- *
- * Where 'channel' is the literal symbol of this name, not a variable.
- * For that reason, it is currently not intended to be used directly,
- * but only as helper macro for the other oneshot trace macros
- * OSSL_TRACE(), OSSL_TRACE1(), OSSL_TRACE2(), ...
- *
- * Usage:
- *
- *    OSSL_TRACE(INIT, "Hello world!\n");
- *    OSSL_TRACE1(TLS, "The answer is %d\n", 42);
- *    OSSL_TRACE2(TLS, "The ultimate question to answer %d is '%s'\n",
- *                42, "What do you get when you multiply six by nine?");
- */
+#define OSSL_TRACE_ENABLED(category) (0)
 
-# if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+#endif
 
-#  define OSSL_TRACEV(category, args) \
-    OSSL_TRACE_BEGIN(category) \
-        BIO_printf args; \
+    /*
+     * OSSL_TRACE*() - OneShot Trace Macros
+     *
+     * These macros are intended to produce a simple printf-style trace output.
+     * Unfortunately, C90 macros don't support variable arguments, so the
+     * "vararg" OSSL_TRACEV() macro has a rather weird usage pattern:
+     *
+     *    OSSL_TRACEV(category, (trc_out, "format string", ...args...));
+     *
+     * Where 'channel' is the literal symbol of this name, not a variable.
+     * For that reason, it is currently not intended to be used directly,
+     * but only as helper macro for the other oneshot trace macros
+     * OSSL_TRACE(), OSSL_TRACE1(), OSSL_TRACE2(), ...
+     *
+     * Usage:
+     *
+     *    OSSL_TRACE(INIT, "Hello world!\n");
+     *    OSSL_TRACE1(TLS, "The answer is %d\n", 42);
+     *    OSSL_TRACE2(TLS, "The ultimate question to answer %d is '%s'\n",
+     *                42, "What do you get when you multiply six by nine?");
+     */
+
+#if !defined OPENSSL_NO_TRACE && !defined FIPS_MODULE
+
+#define OSSL_TRACEV(category, args) \
+    OSSL_TRACE_BEGIN(category)      \
+    BIO_printf args;                \
     OSSL_TRACE_END(category)
 
-# else
+#else
 
-#  define OSSL_TRACEV(category, args) ((void)0)
+#define OSSL_TRACEV(category, args) ((void)0)
 
-# endif
+#endif
 
-# define OSSL_TRACE(category, text) \
+#define OSSL_TRACE(category, text) \
     OSSL_TRACEV(category, (trc_out, "%s", text))
 
-# define OSSL_TRACE1(category, format, arg1) \
+#define OSSL_TRACE1(category, format, arg1) \
     OSSL_TRACEV(category, (trc_out, format, arg1))
-# define OSSL_TRACE2(category, format, arg1, arg2) \
+#define OSSL_TRACE2(category, format, arg1, arg2) \
     OSSL_TRACEV(category, (trc_out, format, arg1, arg2))
-# define OSSL_TRACE3(category, format, arg1, arg2, arg3) \
+#define OSSL_TRACE3(category, format, arg1, arg2, arg3) \
     OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3))
-# define OSSL_TRACE4(category, format, arg1, arg2, arg3, arg4) \
+#define OSSL_TRACE4(category, format, arg1, arg2, arg3, arg4) \
     OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4))
-# define OSSL_TRACE5(category, format, arg1, arg2, arg3, arg4, arg5) \
+#define OSSL_TRACE5(category, format, arg1, arg2, arg3, arg4, arg5) \
     OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5))
-# define OSSL_TRACE6(category, format, arg1, arg2, arg3, arg4, arg5, arg6) \
+#define OSSL_TRACE6(category, format, arg1, arg2, arg3, arg4, arg5, arg6) \
     OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6))
-# define OSSL_TRACE7(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
+#define OSSL_TRACE7(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
     OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7))
-# define OSSL_TRACE8(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+#define OSSL_TRACE8(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
     OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8))
-# define OSSL_TRACE9(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
+#define OSSL_TRACE9(category, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
     OSSL_TRACEV(category, (trc_out, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9))
 
-# ifdef  __cplusplus
+#ifdef __cplusplus
 }
-# endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/ts.h b/CAPI/cpp/grpc/include/openssl/ts.h
index 5136e4e..ea91eac 100644
--- a/CAPI/cpp/grpc/include/openssl/ts.h
+++ b/CAPI/cpp/grpc/include/openssl/ts.h
@@ -8,218 +8,217 @@
  */
 
 #ifndef OPENSSL_TS_H
-# define OPENSSL_TS_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_TS_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_TS
-# include <openssl/symhacks.h>
-# include <openssl/buffer.h>
-# include <openssl/evp.h>
-# include <openssl/bio.h>
-# include <openssl/asn1.h>
-# include <openssl/safestack.h>
-# include <openssl/rsa.h>
-# include <openssl/dsa.h>
-# include <openssl/dh.h>
-# include <openssl/tserr.h>
-# include <openssl/ess.h>
-# ifdef  __cplusplus
-extern "C" {
-# endif
-
-# include <openssl/x509.h>
-# include <openssl/x509v3.h>
-
-typedef struct TS_msg_imprint_st TS_MSG_IMPRINT;
-typedef struct TS_req_st TS_REQ;
-typedef struct TS_accuracy_st TS_ACCURACY;
-typedef struct TS_tst_info_st TS_TST_INFO;
+#define OPENSSL_TS_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_TS_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_TS
+#include <openssl/symhacks.h>
+#include <openssl/buffer.h>
+#include <openssl/evp.h>
+#include <openssl/bio.h>
+#include <openssl/asn1.h>
+#include <openssl/safestack.h>
+#include <openssl/rsa.h>
+#include <openssl/dsa.h>
+#include <openssl/dh.h>
+#include <openssl/tserr.h>
+#include <openssl/ess.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <openssl/x509.h>
+#include <openssl/x509v3.h>
+
+    typedef struct TS_msg_imprint_st TS_MSG_IMPRINT;
+    typedef struct TS_req_st TS_REQ;
+    typedef struct TS_accuracy_st TS_ACCURACY;
+    typedef struct TS_tst_info_st TS_TST_INFO;
 
 /* Possible values for status. */
-# define TS_STATUS_GRANTED                       0
-# define TS_STATUS_GRANTED_WITH_MODS             1
-# define TS_STATUS_REJECTION                     2
-# define TS_STATUS_WAITING                       3
-# define TS_STATUS_REVOCATION_WARNING            4
-# define TS_STATUS_REVOCATION_NOTIFICATION       5
+#define TS_STATUS_GRANTED 0
+#define TS_STATUS_GRANTED_WITH_MODS 1
+#define TS_STATUS_REJECTION 2
+#define TS_STATUS_WAITING 3
+#define TS_STATUS_REVOCATION_WARNING 4
+#define TS_STATUS_REVOCATION_NOTIFICATION 5
 
 /* Possible values for failure_info. */
-# define TS_INFO_BAD_ALG                 0
-# define TS_INFO_BAD_REQUEST             2
-# define TS_INFO_BAD_DATA_FORMAT         5
-# define TS_INFO_TIME_NOT_AVAILABLE      14
-# define TS_INFO_UNACCEPTED_POLICY       15
-# define TS_INFO_UNACCEPTED_EXTENSION    16
-# define TS_INFO_ADD_INFO_NOT_AVAILABLE  17
-# define TS_INFO_SYSTEM_FAILURE          25
-
+#define TS_INFO_BAD_ALG 0
+#define TS_INFO_BAD_REQUEST 2
+#define TS_INFO_BAD_DATA_FORMAT 5
+#define TS_INFO_TIME_NOT_AVAILABLE 14
+#define TS_INFO_UNACCEPTED_POLICY 15
+#define TS_INFO_UNACCEPTED_EXTENSION 16
+#define TS_INFO_ADD_INFO_NOT_AVAILABLE 17
+#define TS_INFO_SYSTEM_FAILURE 25
 
-typedef struct TS_status_info_st TS_STATUS_INFO;
+    typedef struct TS_status_info_st TS_STATUS_INFO;
 
-typedef struct TS_resp_st TS_RESP;
+    typedef struct TS_resp_st TS_RESP;
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(TS_REQ)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_REQ, TS_REQ)
-DECLARE_ASN1_DUP_FUNCTION(TS_REQ)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(TS_REQ)
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_REQ, TS_REQ)
+        DECLARE_ASN1_DUP_FUNCTION(TS_REQ)
 
 #ifndef OPENSSL_NO_STDIO
-TS_REQ *d2i_TS_REQ_fp(FILE *fp, TS_REQ **a);
-int i2d_TS_REQ_fp(FILE *fp, const TS_REQ *a);
+            TS_REQ* d2i_TS_REQ_fp(FILE* fp, TS_REQ** a);
+    int i2d_TS_REQ_fp(FILE* fp, const TS_REQ* a);
 #endif
-TS_REQ *d2i_TS_REQ_bio(BIO *fp, TS_REQ **a);
-int i2d_TS_REQ_bio(BIO *fp, const TS_REQ *a);
+    TS_REQ* d2i_TS_REQ_bio(BIO* fp, TS_REQ** a);
+    int i2d_TS_REQ_bio(BIO* fp, const TS_REQ* a);
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(TS_MSG_IMPRINT)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_MSG_IMPRINT, TS_MSG_IMPRINT)
-DECLARE_ASN1_DUP_FUNCTION(TS_MSG_IMPRINT)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(TS_MSG_IMPRINT)
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_MSG_IMPRINT, TS_MSG_IMPRINT)
+        DECLARE_ASN1_DUP_FUNCTION(TS_MSG_IMPRINT)
 
 #ifndef OPENSSL_NO_STDIO
-TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a);
-int i2d_TS_MSG_IMPRINT_fp(FILE *fp, const TS_MSG_IMPRINT *a);
+            TS_MSG_IMPRINT* d2i_TS_MSG_IMPRINT_fp(FILE* fp, TS_MSG_IMPRINT** a);
+    int i2d_TS_MSG_IMPRINT_fp(FILE* fp, const TS_MSG_IMPRINT* a);
 #endif
-TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_bio(BIO *bio, TS_MSG_IMPRINT **a);
-int i2d_TS_MSG_IMPRINT_bio(BIO *bio, const TS_MSG_IMPRINT *a);
+    TS_MSG_IMPRINT* d2i_TS_MSG_IMPRINT_bio(BIO* bio, TS_MSG_IMPRINT** a);
+    int i2d_TS_MSG_IMPRINT_bio(BIO* bio, const TS_MSG_IMPRINT* a);
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(TS_RESP)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_RESP, TS_RESP)
-DECLARE_ASN1_DUP_FUNCTION(TS_RESP)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(TS_RESP)
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_RESP, TS_RESP)
+        DECLARE_ASN1_DUP_FUNCTION(TS_RESP)
 
 #ifndef OPENSSL_NO_STDIO
-TS_RESP *d2i_TS_RESP_fp(FILE *fp, TS_RESP **a);
-int i2d_TS_RESP_fp(FILE *fp, const TS_RESP *a);
+            TS_RESP* d2i_TS_RESP_fp(FILE* fp, TS_RESP** a);
+    int i2d_TS_RESP_fp(FILE* fp, const TS_RESP* a);
 #endif
-TS_RESP *d2i_TS_RESP_bio(BIO *bio, TS_RESP **a);
-int i2d_TS_RESP_bio(BIO *bio, const TS_RESP *a);
+    TS_RESP* d2i_TS_RESP_bio(BIO* bio, TS_RESP** a);
+    int i2d_TS_RESP_bio(BIO* bio, const TS_RESP* a);
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(TS_STATUS_INFO)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_STATUS_INFO, TS_STATUS_INFO)
-DECLARE_ASN1_DUP_FUNCTION(TS_STATUS_INFO)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(TS_STATUS_INFO)
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_STATUS_INFO, TS_STATUS_INFO)
+        DECLARE_ASN1_DUP_FUNCTION(TS_STATUS_INFO)
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(TS_TST_INFO)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_TST_INFO, TS_TST_INFO)
-DECLARE_ASN1_DUP_FUNCTION(TS_TST_INFO)
-TS_TST_INFO *PKCS7_to_TS_TST_INFO(PKCS7 *token);
+            DECLARE_ASN1_ALLOC_FUNCTIONS(TS_TST_INFO)
+                DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_TST_INFO, TS_TST_INFO)
+                    DECLARE_ASN1_DUP_FUNCTION(TS_TST_INFO)
+                        TS_TST_INFO* PKCS7_to_TS_TST_INFO(PKCS7* token);
 
 #ifndef OPENSSL_NO_STDIO
-TS_TST_INFO *d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a);
-int i2d_TS_TST_INFO_fp(FILE *fp, const TS_TST_INFO *a);
+    TS_TST_INFO* d2i_TS_TST_INFO_fp(FILE* fp, TS_TST_INFO** a);
+    int i2d_TS_TST_INFO_fp(FILE* fp, const TS_TST_INFO* a);
 #endif
-TS_TST_INFO *d2i_TS_TST_INFO_bio(BIO *bio, TS_TST_INFO **a);
-int i2d_TS_TST_INFO_bio(BIO *bio, const TS_TST_INFO *a);
+    TS_TST_INFO* d2i_TS_TST_INFO_bio(BIO* bio, TS_TST_INFO** a);
+    int i2d_TS_TST_INFO_bio(BIO* bio, const TS_TST_INFO* a);
 
-DECLARE_ASN1_ALLOC_FUNCTIONS(TS_ACCURACY)
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_ACCURACY, TS_ACCURACY)
-DECLARE_ASN1_DUP_FUNCTION(TS_ACCURACY)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(TS_ACCURACY)
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(TS_ACCURACY, TS_ACCURACY)
+        DECLARE_ASN1_DUP_FUNCTION(TS_ACCURACY)
 
-int TS_REQ_set_version(TS_REQ *a, long version);
-long TS_REQ_get_version(const TS_REQ *a);
+            int TS_REQ_set_version(TS_REQ* a, long version);
+    long TS_REQ_get_version(const TS_REQ* a);
 
-int TS_STATUS_INFO_set_status(TS_STATUS_INFO *a, int i);
-const ASN1_INTEGER *TS_STATUS_INFO_get0_status(const TS_STATUS_INFO *a);
+    int TS_STATUS_INFO_set_status(TS_STATUS_INFO* a, int i);
+    const ASN1_INTEGER* TS_STATUS_INFO_get0_status(const TS_STATUS_INFO* a);
 
-const STACK_OF(ASN1_UTF8STRING) *
-TS_STATUS_INFO_get0_text(const TS_STATUS_INFO *a);
+    const STACK_OF(ASN1_UTF8STRING) *
+        TS_STATUS_INFO_get0_text(const TS_STATUS_INFO* a);
 
-const ASN1_BIT_STRING *
-TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO *a);
+    const ASN1_BIT_STRING*
+        TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO* a);
 
-int TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint);
-TS_MSG_IMPRINT *TS_REQ_get_msg_imprint(TS_REQ *a);
+    int TS_REQ_set_msg_imprint(TS_REQ* a, TS_MSG_IMPRINT* msg_imprint);
+    TS_MSG_IMPRINT* TS_REQ_get_msg_imprint(TS_REQ* a);
 
-int TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg);
-X509_ALGOR *TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a);
+    int TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT* a, X509_ALGOR* alg);
+    X509_ALGOR* TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT* a);
 
-int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len);
-ASN1_OCTET_STRING *TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a);
+    int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT* a, unsigned char* d, int len);
+    ASN1_OCTET_STRING* TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT* a);
 
-int TS_REQ_set_policy_id(TS_REQ *a, const ASN1_OBJECT *policy);
-ASN1_OBJECT *TS_REQ_get_policy_id(TS_REQ *a);
+    int TS_REQ_set_policy_id(TS_REQ* a, const ASN1_OBJECT* policy);
+    ASN1_OBJECT* TS_REQ_get_policy_id(TS_REQ* a);
 
-int TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce);
-const ASN1_INTEGER *TS_REQ_get_nonce(const TS_REQ *a);
+    int TS_REQ_set_nonce(TS_REQ* a, const ASN1_INTEGER* nonce);
+    const ASN1_INTEGER* TS_REQ_get_nonce(const TS_REQ* a);
 
-int TS_REQ_set_cert_req(TS_REQ *a, int cert_req);
-int TS_REQ_get_cert_req(const TS_REQ *a);
+    int TS_REQ_set_cert_req(TS_REQ* a, int cert_req);
+    int TS_REQ_get_cert_req(const TS_REQ* a);
 
-STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a);
-void TS_REQ_ext_free(TS_REQ *a);
-int TS_REQ_get_ext_count(TS_REQ *a);
-int TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos);
-int TS_REQ_get_ext_by_OBJ(TS_REQ *a, const ASN1_OBJECT *obj, int lastpos);
-int TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos);
-X509_EXTENSION *TS_REQ_get_ext(TS_REQ *a, int loc);
-X509_EXTENSION *TS_REQ_delete_ext(TS_REQ *a, int loc);
-int TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc);
-void *TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx);
+    STACK_OF(X509_EXTENSION) * TS_REQ_get_exts(TS_REQ* a);
+    void TS_REQ_ext_free(TS_REQ* a);
+    int TS_REQ_get_ext_count(TS_REQ* a);
+    int TS_REQ_get_ext_by_NID(TS_REQ* a, int nid, int lastpos);
+    int TS_REQ_get_ext_by_OBJ(TS_REQ* a, const ASN1_OBJECT* obj, int lastpos);
+    int TS_REQ_get_ext_by_critical(TS_REQ* a, int crit, int lastpos);
+    X509_EXTENSION* TS_REQ_get_ext(TS_REQ* a, int loc);
+    X509_EXTENSION* TS_REQ_delete_ext(TS_REQ* a, int loc);
+    int TS_REQ_add_ext(TS_REQ* a, X509_EXTENSION* ex, int loc);
+    void* TS_REQ_get_ext_d2i(TS_REQ* a, int nid, int* crit, int* idx);
 
-/* Function declarations for TS_REQ defined in ts/ts_req_print.c */
+    /* Function declarations for TS_REQ defined in ts/ts_req_print.c */
 
-int TS_REQ_print_bio(BIO *bio, TS_REQ *a);
+    int TS_REQ_print_bio(BIO* bio, TS_REQ* a);
 
-/* Function declarations for TS_RESP defined in ts/ts_resp_utils.c */
+    /* Function declarations for TS_RESP defined in ts/ts_resp_utils.c */
 
-int TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *info);
-TS_STATUS_INFO *TS_RESP_get_status_info(TS_RESP *a);
+    int TS_RESP_set_status_info(TS_RESP* a, TS_STATUS_INFO* info);
+    TS_STATUS_INFO* TS_RESP_get_status_info(TS_RESP* a);
 
-/* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */
-void TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info);
-PKCS7 *TS_RESP_get_token(TS_RESP *a);
-TS_TST_INFO *TS_RESP_get_tst_info(TS_RESP *a);
+    /* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */
+    void TS_RESP_set_tst_info(TS_RESP* a, PKCS7* p7, TS_TST_INFO* tst_info);
+    PKCS7* TS_RESP_get_token(TS_RESP* a);
+    TS_TST_INFO* TS_RESP_get_tst_info(TS_RESP* a);
 
-int TS_TST_INFO_set_version(TS_TST_INFO *a, long version);
-long TS_TST_INFO_get_version(const TS_TST_INFO *a);
+    int TS_TST_INFO_set_version(TS_TST_INFO* a, long version);
+    long TS_TST_INFO_get_version(const TS_TST_INFO* a);
 
-int TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy_id);
-ASN1_OBJECT *TS_TST_INFO_get_policy_id(TS_TST_INFO *a);
+    int TS_TST_INFO_set_policy_id(TS_TST_INFO* a, ASN1_OBJECT* policy_id);
+    ASN1_OBJECT* TS_TST_INFO_get_policy_id(TS_TST_INFO* a);
 
-int TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint);
-TS_MSG_IMPRINT *TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a);
+    int TS_TST_INFO_set_msg_imprint(TS_TST_INFO* a, TS_MSG_IMPRINT* msg_imprint);
+    TS_MSG_IMPRINT* TS_TST_INFO_get_msg_imprint(TS_TST_INFO* a);
 
-int TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial);
-const ASN1_INTEGER *TS_TST_INFO_get_serial(const TS_TST_INFO *a);
+    int TS_TST_INFO_set_serial(TS_TST_INFO* a, const ASN1_INTEGER* serial);
+    const ASN1_INTEGER* TS_TST_INFO_get_serial(const TS_TST_INFO* a);
 
-int TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime);
-const ASN1_GENERALIZEDTIME *TS_TST_INFO_get_time(const TS_TST_INFO *a);
+    int TS_TST_INFO_set_time(TS_TST_INFO* a, const ASN1_GENERALIZEDTIME* gtime);
+    const ASN1_GENERALIZEDTIME* TS_TST_INFO_get_time(const TS_TST_INFO* a);
 
-int TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy);
-TS_ACCURACY *TS_TST_INFO_get_accuracy(TS_TST_INFO *a);
+    int TS_TST_INFO_set_accuracy(TS_TST_INFO* a, TS_ACCURACY* accuracy);
+    TS_ACCURACY* TS_TST_INFO_get_accuracy(TS_TST_INFO* a);
 
-int TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds);
-const ASN1_INTEGER *TS_ACCURACY_get_seconds(const TS_ACCURACY *a);
+    int TS_ACCURACY_set_seconds(TS_ACCURACY* a, const ASN1_INTEGER* seconds);
+    const ASN1_INTEGER* TS_ACCURACY_get_seconds(const TS_ACCURACY* a);
 
-int TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis);
-const ASN1_INTEGER *TS_ACCURACY_get_millis(const TS_ACCURACY *a);
+    int TS_ACCURACY_set_millis(TS_ACCURACY* a, const ASN1_INTEGER* millis);
+    const ASN1_INTEGER* TS_ACCURACY_get_millis(const TS_ACCURACY* a);
 
-int TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros);
-const ASN1_INTEGER *TS_ACCURACY_get_micros(const TS_ACCURACY *a);
+    int TS_ACCURACY_set_micros(TS_ACCURACY* a, const ASN1_INTEGER* micros);
+    const ASN1_INTEGER* TS_ACCURACY_get_micros(const TS_ACCURACY* a);
 
-int TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering);
-int TS_TST_INFO_get_ordering(const TS_TST_INFO *a);
+    int TS_TST_INFO_set_ordering(TS_TST_INFO* a, int ordering);
+    int TS_TST_INFO_get_ordering(const TS_TST_INFO* a);
 
-int TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce);
-const ASN1_INTEGER *TS_TST_INFO_get_nonce(const TS_TST_INFO *a);
+    int TS_TST_INFO_set_nonce(TS_TST_INFO* a, const ASN1_INTEGER* nonce);
+    const ASN1_INTEGER* TS_TST_INFO_get_nonce(const TS_TST_INFO* a);
 
-int TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa);
-GENERAL_NAME *TS_TST_INFO_get_tsa(TS_TST_INFO *a);
+    int TS_TST_INFO_set_tsa(TS_TST_INFO* a, GENERAL_NAME* tsa);
+    GENERAL_NAME* TS_TST_INFO_get_tsa(TS_TST_INFO* a);
 
-STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a);
-void TS_TST_INFO_ext_free(TS_TST_INFO *a);
-int TS_TST_INFO_get_ext_count(TS_TST_INFO *a);
-int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos);
-int TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, const ASN1_OBJECT *obj,
-                               int lastpos);
-int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos);
-X509_EXTENSION *TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc);
-X509_EXTENSION *TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc);
-int TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc);
-void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx);
+    STACK_OF(X509_EXTENSION) * TS_TST_INFO_get_exts(TS_TST_INFO* a);
+    void TS_TST_INFO_ext_free(TS_TST_INFO* a);
+    int TS_TST_INFO_get_ext_count(TS_TST_INFO* a);
+    int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO* a, int nid, int lastpos);
+    int TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO* a, const ASN1_OBJECT* obj, int lastpos);
+    int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO* a, int crit, int lastpos);
+    X509_EXTENSION* TS_TST_INFO_get_ext(TS_TST_INFO* a, int loc);
+    X509_EXTENSION* TS_TST_INFO_delete_ext(TS_TST_INFO* a, int loc);
+    int TS_TST_INFO_add_ext(TS_TST_INFO* a, X509_EXTENSION* ex, int loc);
+    void* TS_TST_INFO_get_ext_d2i(TS_TST_INFO* a, int nid, int* crit, int* idx);
 
 /*
  * Declarations related to response generation, defined in ts/ts_resp_sign.c.
@@ -228,276 +227,243 @@ void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx);
 /* Optional flags for response generation. */
 
 /* Don't include the TSA name in response. */
-# define TS_TSA_NAME             0x01
+#define TS_TSA_NAME 0x01
 
 /* Set ordering to true in response. */
-# define TS_ORDERING             0x02
+#define TS_ORDERING 0x02
 
 /*
  * Include the signer certificate and the other specified certificates in
  * the ESS signing certificate attribute beside the PKCS7 signed data.
  * Only the signer certificates is included by default.
  */
-# define TS_ESS_CERT_ID_CHAIN    0x04
-
-/* Forward declaration. */
-struct TS_resp_ctx;
-
-/* This must return a unique number less than 160 bits long. */
-typedef ASN1_INTEGER *(*TS_serial_cb) (struct TS_resp_ctx *, void *);
-
-/*
- * This must return the seconds and microseconds since Jan 1, 1970 in the sec
- * and usec variables allocated by the caller. Return non-zero for success
- * and zero for failure.
- */
-typedef int (*TS_time_cb) (struct TS_resp_ctx *, void *, long *sec,
-                           long *usec);
-
-/*
- * This must process the given extension. It can modify the TS_TST_INFO
- * object of the context. Return values: !0 (processed), 0 (error, it must
- * set the status info/failure info of the response).
- */
-typedef int (*TS_extension_cb) (struct TS_resp_ctx *, X509_EXTENSION *,
-                                void *);
-
-typedef struct TS_resp_ctx TS_RESP_CTX;
-
-/* Creates a response context that can be used for generating responses. */
-TS_RESP_CTX *TS_RESP_CTX_new(void);
-TS_RESP_CTX *TS_RESP_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
-void TS_RESP_CTX_free(TS_RESP_CTX *ctx);
-
-/* This parameter must be set. */
-int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer);
-
-/* This parameter must be set. */
-int TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key);
-
-int TS_RESP_CTX_set_signer_digest(TS_RESP_CTX *ctx,
-                                  const EVP_MD *signer_digest);
-int TS_RESP_CTX_set_ess_cert_id_digest(TS_RESP_CTX *ctx, const EVP_MD *md);
-
-/* This parameter must be set. */
-int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *def_policy);
-
-/* No additional certs are included in the response by default. */
-int TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs);
-
-/*
- * Adds a new acceptable policy, only the default policy is accepted by
- * default.
- */
-int TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, const ASN1_OBJECT *policy);
-
-/*
- * Adds a new acceptable message digest. Note that no message digests are
- * accepted by default. The md argument is shared with the caller.
- */
-int TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md);
-
-/* Accuracy is not included by default. */
-int TS_RESP_CTX_set_accuracy(TS_RESP_CTX *ctx,
-                             int secs, int millis, int micros);
-
-/*
- * Clock precision digits, i.e. the number of decimal digits: '0' means sec,
- * '3' msec, '6' usec, and so on. Default is 0.
- */
-int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx,
-                                           unsigned clock_precision_digits);
+#define TS_ESS_CERT_ID_CHAIN 0x04
+
+    /* Forward declaration. */
+    struct TS_resp_ctx;
+
+    /* This must return a unique number less than 160 bits long. */
+    typedef ASN1_INTEGER* (*TS_serial_cb)(struct TS_resp_ctx*, void*);
+
+    /*
+     * This must return the seconds and microseconds since Jan 1, 1970 in the sec
+     * and usec variables allocated by the caller. Return non-zero for success
+     * and zero for failure.
+     */
+    typedef int (*TS_time_cb)(struct TS_resp_ctx*, void*, long* sec, long* usec);
+
+    /*
+     * This must process the given extension. It can modify the TS_TST_INFO
+     * object of the context. Return values: !0 (processed), 0 (error, it must
+     * set the status info/failure info of the response).
+     */
+    typedef int (*TS_extension_cb)(struct TS_resp_ctx*, X509_EXTENSION*, void*);
+
+    typedef struct TS_resp_ctx TS_RESP_CTX;
+
+    /* Creates a response context that can be used for generating responses. */
+    TS_RESP_CTX* TS_RESP_CTX_new(void);
+    TS_RESP_CTX* TS_RESP_CTX_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+    void TS_RESP_CTX_free(TS_RESP_CTX* ctx);
+
+    /* This parameter must be set. */
+    int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX* ctx, X509* signer);
+
+    /* This parameter must be set. */
+    int TS_RESP_CTX_set_signer_key(TS_RESP_CTX* ctx, EVP_PKEY* key);
+
+    int TS_RESP_CTX_set_signer_digest(TS_RESP_CTX* ctx, const EVP_MD* signer_digest);
+    int TS_RESP_CTX_set_ess_cert_id_digest(TS_RESP_CTX* ctx, const EVP_MD* md);
+
+    /* This parameter must be set. */
+    int TS_RESP_CTX_set_def_policy(TS_RESP_CTX* ctx, const ASN1_OBJECT* def_policy);
+
+    /* No additional certs are included in the response by default. */
+    int TS_RESP_CTX_set_certs(TS_RESP_CTX* ctx, STACK_OF(X509) * certs);
+
+    /*
+     * Adds a new acceptable policy, only the default policy is accepted by
+     * default.
+     */
+    int TS_RESP_CTX_add_policy(TS_RESP_CTX* ctx, const ASN1_OBJECT* policy);
+
+    /*
+     * Adds a new acceptable message digest. Note that no message digests are
+     * accepted by default. The md argument is shared with the caller.
+     */
+    int TS_RESP_CTX_add_md(TS_RESP_CTX* ctx, const EVP_MD* md);
+
+    /* Accuracy is not included by default. */
+    int TS_RESP_CTX_set_accuracy(TS_RESP_CTX* ctx, int secs, int millis, int micros);
+
+    /*
+     * Clock precision digits, i.e. the number of decimal digits: '0' means sec,
+     * '3' msec, '6' usec, and so on. Default is 0.
+     */
+    int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX* ctx, unsigned clock_precision_digits);
 /* At most we accept usec precision. */
-# define TS_MAX_CLOCK_PRECISION_DIGITS   6
+#define TS_MAX_CLOCK_PRECISION_DIGITS 6
 
 /* Maximum status message length */
-# define TS_MAX_STATUS_LENGTH   (1024 * 1024)
+#define TS_MAX_STATUS_LENGTH (1024 * 1024)
 
-/* No flags are set by default. */
-void TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags);
+    /* No flags are set by default. */
+    void TS_RESP_CTX_add_flags(TS_RESP_CTX* ctx, int flags);
 
-/* Default callback always returns a constant. */
-void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data);
+    /* Default callback always returns a constant. */
+    void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX* ctx, TS_serial_cb cb, void* data);
 
-/* Default callback uses the gettimeofday() and gmtime() system calls. */
-void TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data);
+    /* Default callback uses the gettimeofday() and gmtime() system calls. */
+    void TS_RESP_CTX_set_time_cb(TS_RESP_CTX* ctx, TS_time_cb cb, void* data);
 
-/*
- * Default callback rejects all extensions. The extension callback is called
- * when the TS_TST_INFO object is already set up and not signed yet.
- */
-/* FIXME: extension handling is not tested yet. */
-void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx,
-                                  TS_extension_cb cb, void *data);
+    /*
+     * Default callback rejects all extensions. The extension callback is called
+     * when the TS_TST_INFO object is already set up and not signed yet.
+     */
+    /* FIXME: extension handling is not tested yet. */
+    void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX* ctx, TS_extension_cb cb, void* data);
 
-/* The following methods can be used in the callbacks. */
-int TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx,
-                                int status, const char *text);
+    /* The following methods can be used in the callbacks. */
+    int TS_RESP_CTX_set_status_info(TS_RESP_CTX* ctx, int status, const char* text);
 
-/* Sets the status info only if it is still TS_STATUS_GRANTED. */
-int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx,
-                                     int status, const char *text);
+    /* Sets the status info only if it is still TS_STATUS_GRANTED. */
+    int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX* ctx, int status, const char* text);
 
-int TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure);
+    int TS_RESP_CTX_add_failure_info(TS_RESP_CTX* ctx, int failure);
 
-/* The get methods below can be used in the extension callback. */
-TS_REQ *TS_RESP_CTX_get_request(TS_RESP_CTX *ctx);
+    /* The get methods below can be used in the extension callback. */
+    TS_REQ* TS_RESP_CTX_get_request(TS_RESP_CTX* ctx);
 
-TS_TST_INFO *TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx);
+    TS_TST_INFO* TS_RESP_CTX_get_tst_info(TS_RESP_CTX* ctx);
 
-/*
- * Creates the signed TS_TST_INFO and puts it in TS_RESP.
- * In case of errors it sets the status info properly.
- * Returns NULL only in case of memory allocation/fatal error.
- */
-TS_RESP *TS_RESP_create_response(TS_RESP_CTX *ctx, BIO *req_bio);
+    /*
+     * Creates the signed TS_TST_INFO and puts it in TS_RESP.
+     * In case of errors it sets the status info properly.
+     * Returns NULL only in case of memory allocation/fatal error.
+     */
+    TS_RESP* TS_RESP_create_response(TS_RESP_CTX* ctx, BIO* req_bio);
 
-/*
- * Declarations related to response verification,
- * they are defined in ts/ts_resp_verify.c.
- */
+    /*
+     * Declarations related to response verification,
+     * they are defined in ts/ts_resp_verify.c.
+     */
 
-int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,
-                             X509_STORE *store, X509 **signer_out);
+    int TS_RESP_verify_signature(PKCS7* token, STACK_OF(X509) * certs, X509_STORE* store, X509** signer_out);
 
 /* Context structure for the generic verify method. */
 
 /* Verify the signer's certificate and the signature of the response. */
-# define TS_VFY_SIGNATURE        (1u << 0)
+#define TS_VFY_SIGNATURE (1u << 0)
 /* Verify the version number of the response. */
-# define TS_VFY_VERSION          (1u << 1)
+#define TS_VFY_VERSION (1u << 1)
 /* Verify if the policy supplied by the user matches the policy of the TSA. */
-# define TS_VFY_POLICY           (1u << 2)
+#define TS_VFY_POLICY (1u << 2)
 /*
  * Verify the message imprint provided by the user. This flag should not be
  * specified with TS_VFY_DATA.
  */
-# define TS_VFY_IMPRINT          (1u << 3)
+#define TS_VFY_IMPRINT (1u << 3)
 /*
  * Verify the message imprint computed by the verify method from the user
  * provided data and the MD algorithm of the response. This flag should not
  * be specified with TS_VFY_IMPRINT.
  */
-# define TS_VFY_DATA             (1u << 4)
+#define TS_VFY_DATA (1u << 4)
 /* Verify the nonce value. */
-# define TS_VFY_NONCE            (1u << 5)
+#define TS_VFY_NONCE (1u << 5)
 /* Verify if the TSA name field matches the signer certificate. */
-# define TS_VFY_SIGNER           (1u << 6)
+#define TS_VFY_SIGNER (1u << 6)
 /* Verify if the TSA name field equals to the user provided name. */
-# define TS_VFY_TSA_NAME         (1u << 7)
+#define TS_VFY_TSA_NAME (1u << 7)
 
 /* You can use the following convenience constants. */
-# define TS_VFY_ALL_IMPRINT      (TS_VFY_SIGNATURE       \
-                                 | TS_VFY_VERSION       \
-                                 | TS_VFY_POLICY        \
-                                 | TS_VFY_IMPRINT       \
-                                 | TS_VFY_NONCE         \
-                                 | TS_VFY_SIGNER        \
-                                 | TS_VFY_TSA_NAME)
-# define TS_VFY_ALL_DATA         (TS_VFY_SIGNATURE       \
-                                 | TS_VFY_VERSION       \
-                                 | TS_VFY_POLICY        \
-                                 | TS_VFY_DATA          \
-                                 | TS_VFY_NONCE         \
-                                 | TS_VFY_SIGNER        \
-                                 | TS_VFY_TSA_NAME)
-
-typedef struct TS_verify_ctx TS_VERIFY_CTX;
-
-int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response);
-int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token);
-
-/*
- * Declarations related to response verification context,
- */
-TS_VERIFY_CTX *TS_VERIFY_CTX_new(void);
-void TS_VERIFY_CTX_init(TS_VERIFY_CTX *ctx);
-void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx);
-void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx);
-int TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int f);
-int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int f);
-BIO *TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *b);
-unsigned char *TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx,
-                                         unsigned char *hexstr, long len);
-X509_STORE *TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *s);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define TS_VERIFY_CTS_set_certs(ctx, cert) TS_VERIFY_CTX_set_certs(ctx,cert)
-# endif
-STACK_OF(X509) *TS_VERIFY_CTX_set_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs);
-
-/*-
- * If ctx is NULL, it allocates and returns a new object, otherwise
- * it returns ctx. It initialises all the members as follows:
- * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE)
- * certs = NULL
- * store = NULL
- * policy = policy from the request or NULL if absent (in this case
- *      TS_VFY_POLICY is cleared from flags as well)
- * md_alg = MD algorithm from request
- * imprint, imprint_len = imprint from request
- * data = NULL
- * nonce, nonce_len = nonce from the request or NULL if absent (in this case
- *      TS_VFY_NONCE is cleared from flags as well)
- * tsa_name = NULL
- * Important: after calling this method TS_VFY_SIGNATURE should be added!
- */
-TS_VERIFY_CTX *TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx);
-
-/* Function declarations for TS_RESP defined in ts/ts_resp_print.c */
-
-int TS_RESP_print_bio(BIO *bio, TS_RESP *a);
-int TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a);
-int TS_TST_INFO_print_bio(BIO *bio, TS_TST_INFO *a);
-
-/* Common utility functions defined in ts/ts_lib.c */
-
-int TS_ASN1_INTEGER_print_bio(BIO *bio, const ASN1_INTEGER *num);
-int TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj);
-int TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions);
-int TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg);
-int TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *msg);
-
-/*
- * Function declarations for handling configuration options, defined in
- * ts/ts_conf.c
- */
-
-X509 *TS_CONF_load_cert(const char *file);
-STACK_OF(X509) *TS_CONF_load_certs(const char *file);
-EVP_PKEY *TS_CONF_load_key(const char *file, const char *pass);
-const char *TS_CONF_get_tsa_section(CONF *conf, const char *section);
-int TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb,
-                       TS_RESP_CTX *ctx);
+#define TS_VFY_ALL_IMPRINT (TS_VFY_SIGNATURE | TS_VFY_VERSION | TS_VFY_POLICY | TS_VFY_IMPRINT | TS_VFY_NONCE | TS_VFY_SIGNER | TS_VFY_TSA_NAME)
+#define TS_VFY_ALL_DATA (TS_VFY_SIGNATURE | TS_VFY_VERSION | TS_VFY_POLICY | TS_VFY_DATA | TS_VFY_NONCE | TS_VFY_SIGNER | TS_VFY_TSA_NAME)
+
+    typedef struct TS_verify_ctx TS_VERIFY_CTX;
+
+    int TS_RESP_verify_response(TS_VERIFY_CTX* ctx, TS_RESP* response);
+    int TS_RESP_verify_token(TS_VERIFY_CTX* ctx, PKCS7* token);
+
+    /*
+     * Declarations related to response verification context,
+     */
+    TS_VERIFY_CTX* TS_VERIFY_CTX_new(void);
+    void TS_VERIFY_CTX_init(TS_VERIFY_CTX* ctx);
+    void TS_VERIFY_CTX_free(TS_VERIFY_CTX* ctx);
+    void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX* ctx);
+    int TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX* ctx, int f);
+    int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX* ctx, int f);
+    BIO* TS_VERIFY_CTX_set_data(TS_VERIFY_CTX* ctx, BIO* b);
+    unsigned char* TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX* ctx, unsigned char* hexstr, long len);
+    X509_STORE* TS_VERIFY_CTX_set_store(TS_VERIFY_CTX* ctx, X509_STORE* s);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define TS_VERIFY_CTS_set_certs(ctx, cert) TS_VERIFY_CTX_set_certs(ctx, cert)
+#endif
+    STACK_OF(X509) * TS_VERIFY_CTX_set_certs(TS_VERIFY_CTX* ctx, STACK_OF(X509) * certs);
+
+    /*-
+     * If ctx is NULL, it allocates and returns a new object, otherwise
+     * it returns ctx. It initialises all the members as follows:
+     * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE)
+     * certs = NULL
+     * store = NULL
+     * policy = policy from the request or NULL if absent (in this case
+     *      TS_VFY_POLICY is cleared from flags as well)
+     * md_alg = MD algorithm from request
+     * imprint, imprint_len = imprint from request
+     * data = NULL
+     * nonce, nonce_len = nonce from the request or NULL if absent (in this case
+     *      TS_VFY_NONCE is cleared from flags as well)
+     * tsa_name = NULL
+     * Important: after calling this method TS_VFY_SIGNATURE should be added!
+     */
+    TS_VERIFY_CTX* TS_REQ_to_TS_VERIFY_CTX(TS_REQ* req, TS_VERIFY_CTX* ctx);
+
+    /* Function declarations for TS_RESP defined in ts/ts_resp_print.c */
+
+    int TS_RESP_print_bio(BIO* bio, TS_RESP* a);
+    int TS_STATUS_INFO_print_bio(BIO* bio, TS_STATUS_INFO* a);
+    int TS_TST_INFO_print_bio(BIO* bio, TS_TST_INFO* a);
+
+    /* Common utility functions defined in ts/ts_lib.c */
+
+    int TS_ASN1_INTEGER_print_bio(BIO* bio, const ASN1_INTEGER* num);
+    int TS_OBJ_print_bio(BIO* bio, const ASN1_OBJECT* obj);
+    int TS_ext_print_bio(BIO* bio, const STACK_OF(X509_EXTENSION) * extensions);
+    int TS_X509_ALGOR_print_bio(BIO* bio, const X509_ALGOR* alg);
+    int TS_MSG_IMPRINT_print_bio(BIO* bio, TS_MSG_IMPRINT* msg);
+
+    /*
+     * Function declarations for handling configuration options, defined in
+     * ts/ts_conf.c
+     */
+
+    X509* TS_CONF_load_cert(const char* file);
+    STACK_OF(X509) * TS_CONF_load_certs(const char* file);
+    EVP_PKEY* TS_CONF_load_key(const char* file, const char* pass);
+    const char* TS_CONF_get_tsa_section(CONF* conf, const char* section);
+    int TS_CONF_set_serial(CONF* conf, const char* section, TS_serial_cb cb, TS_RESP_CTX* ctx);
 #ifndef OPENSSL_NO_ENGINE
-int TS_CONF_set_crypto_device(CONF *conf, const char *section,
-                              const char *device);
-int TS_CONF_set_default_engine(const char *name);
+    int TS_CONF_set_crypto_device(CONF* conf, const char* section, const char* device);
+    int TS_CONF_set_default_engine(const char* name);
 #endif
-int TS_CONF_set_signer_cert(CONF *conf, const char *section,
-                            const char *cert, TS_RESP_CTX *ctx);
-int TS_CONF_set_certs(CONF *conf, const char *section, const char *certs,
-                      TS_RESP_CTX *ctx);
-int TS_CONF_set_signer_key(CONF *conf, const char *section,
-                           const char *key, const char *pass,
-                           TS_RESP_CTX *ctx);
-int TS_CONF_set_signer_digest(CONF *conf, const char *section,
-                               const char *md, TS_RESP_CTX *ctx);
-int TS_CONF_set_def_policy(CONF *conf, const char *section,
-                           const char *policy, TS_RESP_CTX *ctx);
-int TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx);
-int TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx);
-int TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx);
-int TS_CONF_set_clock_precision_digits(const CONF *conf, const char *section,
-                                       TS_RESP_CTX *ctx);
-int TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx);
-int TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx);
-int TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section,
-                                  TS_RESP_CTX *ctx);
-int TS_CONF_set_ess_cert_id_digest(CONF *conf, const char *section,
-                                      TS_RESP_CTX *ctx);
-
-#  ifdef  __cplusplus
+    int TS_CONF_set_signer_cert(CONF* conf, const char* section, const char* cert, TS_RESP_CTX* ctx);
+    int TS_CONF_set_certs(CONF* conf, const char* section, const char* certs, TS_RESP_CTX* ctx);
+    int TS_CONF_set_signer_key(CONF* conf, const char* section, const char* key, const char* pass, TS_RESP_CTX* ctx);
+    int TS_CONF_set_signer_digest(CONF* conf, const char* section, const char* md, TS_RESP_CTX* ctx);
+    int TS_CONF_set_def_policy(CONF* conf, const char* section, const char* policy, TS_RESP_CTX* ctx);
+    int TS_CONF_set_policies(CONF* conf, const char* section, TS_RESP_CTX* ctx);
+    int TS_CONF_set_digests(CONF* conf, const char* section, TS_RESP_CTX* ctx);
+    int TS_CONF_set_accuracy(CONF* conf, const char* section, TS_RESP_CTX* ctx);
+    int TS_CONF_set_clock_precision_digits(const CONF* conf, const char* section, TS_RESP_CTX* ctx);
+    int TS_CONF_set_ordering(CONF* conf, const char* section, TS_RESP_CTX* ctx);
+    int TS_CONF_set_tsa_name(CONF* conf, const char* section, TS_RESP_CTX* ctx);
+    int TS_CONF_set_ess_cert_id_chain(CONF* conf, const char* section, TS_RESP_CTX* ctx);
+    int TS_CONF_set_ess_cert_id_digest(CONF* conf, const char* section, TS_RESP_CTX* ctx);
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/tserr.h b/CAPI/cpp/grpc/include/openssl/tserr.h
index e1b943e..0bec94a 100644
--- a/CAPI/cpp/grpc/include/openssl/tserr.h
+++ b/CAPI/cpp/grpc/include/openssl/tserr.h
@@ -9,59 +9,57 @@
  */
 
 #ifndef OPENSSL_TSERR_H
-# define OPENSSL_TSERR_H
-# pragma once
+#define OPENSSL_TSERR_H
+#pragma once
 
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
-
-# ifndef OPENSSL_NO_TS
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
+#ifndef OPENSSL_NO_TS
 
 /*
  * TS reason codes.
  */
-#  define TS_R_BAD_PKCS7_TYPE                              132
-#  define TS_R_BAD_TYPE                                    133
-#  define TS_R_CANNOT_LOAD_CERT                            137
-#  define TS_R_CANNOT_LOAD_KEY                             138
-#  define TS_R_CERTIFICATE_VERIFY_ERROR                    100
-#  define TS_R_COULD_NOT_SET_ENGINE                        127
-#  define TS_R_COULD_NOT_SET_TIME                          115
-#  define TS_R_DETACHED_CONTENT                            134
-#  define TS_R_ESS_ADD_SIGNING_CERT_ERROR                  116
-#  define TS_R_ESS_ADD_SIGNING_CERT_V2_ERROR               139
-#  define TS_R_ESS_SIGNING_CERTIFICATE_ERROR               101
-#  define TS_R_INVALID_NULL_POINTER                        102
-#  define TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE          117
-#  define TS_R_MESSAGE_IMPRINT_MISMATCH                    103
-#  define TS_R_NONCE_MISMATCH                              104
-#  define TS_R_NONCE_NOT_RETURNED                          105
-#  define TS_R_NO_CONTENT                                  106
-#  define TS_R_NO_TIME_STAMP_TOKEN                         107
-#  define TS_R_PKCS7_ADD_SIGNATURE_ERROR                   118
-#  define TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR                 119
-#  define TS_R_PKCS7_TO_TS_TST_INFO_FAILED                 129
-#  define TS_R_POLICY_MISMATCH                             108
-#  define TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE      120
-#  define TS_R_RESPONSE_SETUP_ERROR                        121
-#  define TS_R_SIGNATURE_FAILURE                           109
-#  define TS_R_THERE_MUST_BE_ONE_SIGNER                    110
-#  define TS_R_TIME_SYSCALL_ERROR                          122
-#  define TS_R_TOKEN_NOT_PRESENT                           130
-#  define TS_R_TOKEN_PRESENT                               131
-#  define TS_R_TSA_NAME_MISMATCH                           111
-#  define TS_R_TSA_UNTRUSTED                               112
-#  define TS_R_TST_INFO_SETUP_ERROR                        123
-#  define TS_R_TS_DATASIGN                                 124
-#  define TS_R_UNACCEPTABLE_POLICY                         125
-#  define TS_R_UNSUPPORTED_MD_ALGORITHM                    126
-#  define TS_R_UNSUPPORTED_VERSION                         113
-#  define TS_R_VAR_BAD_VALUE                               135
-#  define TS_R_VAR_LOOKUP_FAILURE                          136
-#  define TS_R_WRONG_CONTENT_TYPE                          114
+#define TS_R_BAD_PKCS7_TYPE 132
+#define TS_R_BAD_TYPE 133
+#define TS_R_CANNOT_LOAD_CERT 137
+#define TS_R_CANNOT_LOAD_KEY 138
+#define TS_R_CERTIFICATE_VERIFY_ERROR 100
+#define TS_R_COULD_NOT_SET_ENGINE 127
+#define TS_R_COULD_NOT_SET_TIME 115
+#define TS_R_DETACHED_CONTENT 134
+#define TS_R_ESS_ADD_SIGNING_CERT_ERROR 116
+#define TS_R_ESS_ADD_SIGNING_CERT_V2_ERROR 139
+#define TS_R_ESS_SIGNING_CERTIFICATE_ERROR 101
+#define TS_R_INVALID_NULL_POINTER 102
+#define TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE 117
+#define TS_R_MESSAGE_IMPRINT_MISMATCH 103
+#define TS_R_NONCE_MISMATCH 104
+#define TS_R_NONCE_NOT_RETURNED 105
+#define TS_R_NO_CONTENT 106
+#define TS_R_NO_TIME_STAMP_TOKEN 107
+#define TS_R_PKCS7_ADD_SIGNATURE_ERROR 118
+#define TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR 119
+#define TS_R_PKCS7_TO_TS_TST_INFO_FAILED 129
+#define TS_R_POLICY_MISMATCH 108
+#define TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 120
+#define TS_R_RESPONSE_SETUP_ERROR 121
+#define TS_R_SIGNATURE_FAILURE 109
+#define TS_R_THERE_MUST_BE_ONE_SIGNER 110
+#define TS_R_TIME_SYSCALL_ERROR 122
+#define TS_R_TOKEN_NOT_PRESENT 130
+#define TS_R_TOKEN_PRESENT 131
+#define TS_R_TSA_NAME_MISMATCH 111
+#define TS_R_TSA_UNTRUSTED 112
+#define TS_R_TST_INFO_SETUP_ERROR 123
+#define TS_R_TS_DATASIGN 124
+#define TS_R_UNACCEPTABLE_POLICY 125
+#define TS_R_UNSUPPORTED_MD_ALGORITHM 126
+#define TS_R_UNSUPPORTED_VERSION 113
+#define TS_R_VAR_BAD_VALUE 135
+#define TS_R_VAR_LOOKUP_FAILURE 136
+#define TS_R_WRONG_CONTENT_TYPE 114
 
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/txt_db.h b/CAPI/cpp/grpc/include/openssl/txt_db.h
index af169a3..ec1cc0b 100644
--- a/CAPI/cpp/grpc/include/openssl/txt_db.h
+++ b/CAPI/cpp/grpc/include/openssl/txt_db.h
@@ -8,55 +8,55 @@
  */
 
 #ifndef OPENSSL_TXT_DB_H
-# define OPENSSL_TXT_DB_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_TXT_DB_H
-# endif
-
-# include <openssl/opensslconf.h>
-# include <openssl/bio.h>
-# include <openssl/safestack.h>
-# include <openssl/lhash.h>
-
-# define DB_ERROR_OK                     0
-# define DB_ERROR_MALLOC                 1
-# define DB_ERROR_INDEX_CLASH            2
-# define DB_ERROR_INDEX_OUT_OF_RANGE     3
-# define DB_ERROR_NO_INDEX               4
-# define DB_ERROR_INSERT_INDEX_CLASH     5
-# define DB_ERROR_WRONG_NUM_FIELDS       6
-
-#ifdef  __cplusplus
-extern "C" {
+#define OPENSSL_TXT_DB_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_TXT_DB_H
+#endif
+
+#include <openssl/opensslconf.h>
+#include <openssl/bio.h>
+#include <openssl/safestack.h>
+#include <openssl/lhash.h>
+
+#define DB_ERROR_OK 0
+#define DB_ERROR_MALLOC 1
+#define DB_ERROR_INDEX_CLASH 2
+#define DB_ERROR_INDEX_OUT_OF_RANGE 3
+#define DB_ERROR_NO_INDEX 4
+#define DB_ERROR_INSERT_INDEX_CLASH 5
+#define DB_ERROR_WRONG_NUM_FIELDS 6
+
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-typedef OPENSSL_STRING *OPENSSL_PSTRING;
-DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
-
-typedef struct txt_db_st {
-    int num_fields;
-    STACK_OF(OPENSSL_PSTRING) *data;
-    LHASH_OF(OPENSSL_STRING) **index;
-    int (**qual) (OPENSSL_STRING *);
-    long error;
-    long arg1;
-    long arg2;
-    OPENSSL_STRING *arg_row;
-} TXT_DB;
-
-TXT_DB *TXT_DB_read(BIO *in, int num);
-long TXT_DB_write(BIO *out, TXT_DB *db);
-int TXT_DB_create_index(TXT_DB *db, int field, int (*qual) (OPENSSL_STRING *),
-                        OPENSSL_LH_HASHFUNC hash, OPENSSL_LH_COMPFUNC cmp);
-void TXT_DB_free(TXT_DB *db);
-OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx,
-                                    OPENSSL_STRING *value);
-int TXT_DB_insert(TXT_DB *db, OPENSSL_STRING *value);
-
-#ifdef  __cplusplus
+    typedef OPENSSL_STRING* OPENSSL_PSTRING;
+    DEFINE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
+
+    typedef struct txt_db_st
+    {
+        int num_fields;
+        STACK_OF(OPENSSL_PSTRING) * data;
+        LHASH_OF(OPENSSL_STRING) * *index;
+        int (**qual)(OPENSSL_STRING*);
+        long error;
+        long arg1;
+        long arg2;
+        OPENSSL_STRING* arg_row;
+    } TXT_DB;
+
+    TXT_DB* TXT_DB_read(BIO* in, int num);
+    long TXT_DB_write(BIO* out, TXT_DB* db);
+    int TXT_DB_create_index(TXT_DB* db, int field, int (*qual)(OPENSSL_STRING*), OPENSSL_LH_HASHFUNC hash, OPENSSL_LH_COMPFUNC cmp);
+    void TXT_DB_free(TXT_DB* db);
+    OPENSSL_STRING* TXT_DB_get_by_index(TXT_DB* db, int idx, OPENSSL_STRING* value);
+    int TXT_DB_insert(TXT_DB* db, OPENSSL_STRING* value);
+
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/CAPI/cpp/grpc/include/openssl/types.h b/CAPI/cpp/grpc/include/openssl/types.h
index de9f166..333c408 100644
--- a/CAPI/cpp/grpc/include/openssl/types.h
+++ b/CAPI/cpp/grpc/include/openssl/types.h
@@ -8,40 +8,41 @@
  */
 
 #ifndef OPENSSL_TYPES_H
-# define OPENSSL_TYPES_H
-# pragma once
-
-# include <limits.h>
-
-# ifdef  __cplusplus
-extern "C" {
-# endif
-
-# include <openssl/e_os2.h>
-# include <openssl/safestack.h>
-# include <openssl/macros.h>
-
-typedef struct ossl_provider_st OSSL_PROVIDER; /* Provider Object */
-
-# ifdef NO_ASN1_TYPEDEFS
-#  define ASN1_INTEGER            ASN1_STRING
-#  define ASN1_ENUMERATED         ASN1_STRING
-#  define ASN1_BIT_STRING         ASN1_STRING
-#  define ASN1_OCTET_STRING       ASN1_STRING
-#  define ASN1_PRINTABLESTRING    ASN1_STRING
-#  define ASN1_T61STRING          ASN1_STRING
-#  define ASN1_IA5STRING          ASN1_STRING
-#  define ASN1_UTCTIME            ASN1_STRING
-#  define ASN1_GENERALIZEDTIME    ASN1_STRING
-#  define ASN1_TIME               ASN1_STRING
-#  define ASN1_GENERALSTRING      ASN1_STRING
-#  define ASN1_UNIVERSALSTRING    ASN1_STRING
-#  define ASN1_BMPSTRING          ASN1_STRING
-#  define ASN1_VISIBLESTRING      ASN1_STRING
-#  define ASN1_UTF8STRING         ASN1_STRING
-#  define ASN1_BOOLEAN            int
-#  define ASN1_NULL               int
-# else
+#define OPENSSL_TYPES_H
+#pragma once
+
+#include <limits.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <openssl/e_os2.h>
+#include <openssl/safestack.h>
+#include <openssl/macros.h>
+
+    typedef struct ossl_provider_st OSSL_PROVIDER; /* Provider Object */
+
+#ifdef NO_ASN1_TYPEDEFS
+#define ASN1_INTEGER ASN1_STRING
+#define ASN1_ENUMERATED ASN1_STRING
+#define ASN1_BIT_STRING ASN1_STRING
+#define ASN1_OCTET_STRING ASN1_STRING
+#define ASN1_PRINTABLESTRING ASN1_STRING
+#define ASN1_T61STRING ASN1_STRING
+#define ASN1_IA5STRING ASN1_STRING
+#define ASN1_UTCTIME ASN1_STRING
+#define ASN1_GENERALIZEDTIME ASN1_STRING
+#define ASN1_TIME ASN1_STRING
+#define ASN1_GENERALSTRING ASN1_STRING
+#define ASN1_UNIVERSALSTRING ASN1_STRING
+#define ASN1_BMPSTRING ASN1_STRING
+#define ASN1_VISIBLESTRING ASN1_STRING
+#define ASN1_UTF8STRING ASN1_STRING
+#define ASN1_BOOLEAN int
+#define ASN1_NULL int
+#else
 typedef struct asn1_string_st ASN1_INTEGER;
 typedef struct asn1_string_st ASN1_ENUMERATED;
 typedef struct asn1_string_st ASN1_BIT_STRING;
@@ -60,176 +61,176 @@ typedef struct asn1_string_st ASN1_UTF8STRING;
 typedef struct asn1_string_st ASN1_STRING;
 typedef int ASN1_BOOLEAN;
 typedef int ASN1_NULL;
-# endif
-
-typedef struct asn1_type_st ASN1_TYPE;
-typedef struct asn1_object_st ASN1_OBJECT;
-typedef struct asn1_string_table_st ASN1_STRING_TABLE;
-
-typedef struct ASN1_ITEM_st ASN1_ITEM;
-typedef struct asn1_pctx_st ASN1_PCTX;
-typedef struct asn1_sctx_st ASN1_SCTX;
+#endif
 
-# ifdef _WIN32
-#  undef X509_NAME
-#  undef X509_EXTENSIONS
-#  undef PKCS7_ISSUER_AND_SERIAL
-#  undef PKCS7_SIGNER_INFO
-#  undef OCSP_REQUEST
-#  undef OCSP_RESPONSE
-# endif
+    typedef struct asn1_type_st ASN1_TYPE;
+    typedef struct asn1_object_st ASN1_OBJECT;
+    typedef struct asn1_string_table_st ASN1_STRING_TABLE;
+
+    typedef struct ASN1_ITEM_st ASN1_ITEM;
+    typedef struct asn1_pctx_st ASN1_PCTX;
+    typedef struct asn1_sctx_st ASN1_SCTX;
+
+#ifdef _WIN32
+#undef X509_NAME
+#undef X509_EXTENSIONS
+#undef PKCS7_ISSUER_AND_SERIAL
+#undef PKCS7_SIGNER_INFO
+#undef OCSP_REQUEST
+#undef OCSP_RESPONSE
+#endif
 
-# ifdef BIGNUM
-#  undef BIGNUM
-# endif
+#ifdef BIGNUM
+#undef BIGNUM
+#endif
 
-typedef struct bio_st BIO;
-typedef struct bignum_st BIGNUM;
-typedef struct bignum_ctx BN_CTX;
-typedef struct bn_blinding_st BN_BLINDING;
-typedef struct bn_mont_ctx_st BN_MONT_CTX;
-typedef struct bn_recp_ctx_st BN_RECP_CTX;
-typedef struct bn_gencb_st BN_GENCB;
+    typedef struct bio_st BIO;
+    typedef struct bignum_st BIGNUM;
+    typedef struct bignum_ctx BN_CTX;
+    typedef struct bn_blinding_st BN_BLINDING;
+    typedef struct bn_mont_ctx_st BN_MONT_CTX;
+    typedef struct bn_recp_ctx_st BN_RECP_CTX;
+    typedef struct bn_gencb_st BN_GENCB;
 
-typedef struct buf_mem_st BUF_MEM;
+    typedef struct buf_mem_st BUF_MEM;
 
-STACK_OF(BIGNUM);
-STACK_OF(BIGNUM_const);
+    STACK_OF(BIGNUM);
+    STACK_OF(BIGNUM_const);
 
-typedef struct err_state_st ERR_STATE;
+    typedef struct err_state_st ERR_STATE;
 
-typedef struct evp_cipher_st EVP_CIPHER;
-typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
-typedef struct evp_md_st EVP_MD;
-typedef struct evp_md_ctx_st EVP_MD_CTX;
-typedef struct evp_mac_st EVP_MAC;
-typedef struct evp_mac_ctx_st EVP_MAC_CTX;
-typedef struct evp_pkey_st EVP_PKEY;
+    typedef struct evp_cipher_st EVP_CIPHER;
+    typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
+    typedef struct evp_md_st EVP_MD;
+    typedef struct evp_md_ctx_st EVP_MD_CTX;
+    typedef struct evp_mac_st EVP_MAC;
+    typedef struct evp_mac_ctx_st EVP_MAC_CTX;
+    typedef struct evp_pkey_st EVP_PKEY;
 
-typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD;
+    typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD;
 
-typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
-typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
+    typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
+    typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
 
-typedef struct evp_keymgmt_st EVP_KEYMGMT;
+    typedef struct evp_keymgmt_st EVP_KEYMGMT;
 
-typedef struct evp_kdf_st EVP_KDF;
-typedef struct evp_kdf_ctx_st EVP_KDF_CTX;
+    typedef struct evp_kdf_st EVP_KDF;
+    typedef struct evp_kdf_ctx_st EVP_KDF_CTX;
 
-typedef struct evp_rand_st EVP_RAND;
-typedef struct evp_rand_ctx_st EVP_RAND_CTX;
+    typedef struct evp_rand_st EVP_RAND;
+    typedef struct evp_rand_ctx_st EVP_RAND_CTX;
 
-typedef struct evp_keyexch_st EVP_KEYEXCH;
+    typedef struct evp_keyexch_st EVP_KEYEXCH;
 
-typedef struct evp_signature_st EVP_SIGNATURE;
+    typedef struct evp_signature_st EVP_SIGNATURE;
 
-typedef struct evp_asym_cipher_st EVP_ASYM_CIPHER;
+    typedef struct evp_asym_cipher_st EVP_ASYM_CIPHER;
 
-typedef struct evp_kem_st EVP_KEM;
+    typedef struct evp_kem_st EVP_KEM;
 
-typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX;
+    typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX;
 
-typedef struct hmac_ctx_st HMAC_CTX;
+    typedef struct hmac_ctx_st HMAC_CTX;
 
-typedef struct dh_st DH;
-typedef struct dh_method DH_METHOD;
+    typedef struct dh_st DH;
+    typedef struct dh_method DH_METHOD;
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef struct dsa_st DSA;
-typedef struct dsa_method DSA_METHOD;
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef struct dsa_st DSA;
+    typedef struct dsa_method DSA_METHOD;
+#endif
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef struct rsa_st RSA;
-typedef struct rsa_meth_st RSA_METHOD;
-# endif
-typedef struct rsa_pss_params_st RSA_PSS_PARAMS;
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef struct rsa_st RSA;
+    typedef struct rsa_meth_st RSA_METHOD;
+#endif
+    typedef struct rsa_pss_params_st RSA_PSS_PARAMS;
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-typedef struct ec_key_st EC_KEY;
-typedef struct ec_key_method_st EC_KEY_METHOD;
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    typedef struct ec_key_st EC_KEY;
+    typedef struct ec_key_method_st EC_KEY_METHOD;
+#endif
 
-typedef struct rand_meth_st RAND_METHOD;
-typedef struct rand_drbg_st RAND_DRBG;
+    typedef struct rand_meth_st RAND_METHOD;
+    typedef struct rand_drbg_st RAND_DRBG;
 
-typedef struct ssl_dane_st SSL_DANE;
-typedef struct x509_st X509;
-typedef struct X509_algor_st X509_ALGOR;
-typedef struct X509_crl_st X509_CRL;
-typedef struct x509_crl_method_st X509_CRL_METHOD;
-typedef struct x509_revoked_st X509_REVOKED;
-typedef struct X509_name_st X509_NAME;
-typedef struct X509_pubkey_st X509_PUBKEY;
-typedef struct x509_store_st X509_STORE;
-typedef struct x509_store_ctx_st X509_STORE_CTX;
+    typedef struct ssl_dane_st SSL_DANE;
+    typedef struct x509_st X509;
+    typedef struct X509_algor_st X509_ALGOR;
+    typedef struct X509_crl_st X509_CRL;
+    typedef struct x509_crl_method_st X509_CRL_METHOD;
+    typedef struct x509_revoked_st X509_REVOKED;
+    typedef struct X509_name_st X509_NAME;
+    typedef struct X509_pubkey_st X509_PUBKEY;
+    typedef struct x509_store_st X509_STORE;
+    typedef struct x509_store_ctx_st X509_STORE_CTX;
 
-typedef struct x509_object_st X509_OBJECT;
-typedef struct x509_lookup_st X509_LOOKUP;
-typedef struct x509_lookup_method_st X509_LOOKUP_METHOD;
-typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
+    typedef struct x509_object_st X509_OBJECT;
+    typedef struct x509_lookup_st X509_LOOKUP;
+    typedef struct x509_lookup_method_st X509_LOOKUP_METHOD;
+    typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
 
-typedef struct x509_sig_info_st X509_SIG_INFO;
+    typedef struct x509_sig_info_st X509_SIG_INFO;
 
-typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
+    typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
 
-typedef struct v3_ext_ctx X509V3_CTX;
-typedef struct conf_st CONF;
-typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;
+    typedef struct v3_ext_ctx X509V3_CTX;
+    typedef struct conf_st CONF;
+    typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;
 
-typedef struct ui_st UI;
-typedef struct ui_method_st UI_METHOD;
+    typedef struct ui_st UI;
+    typedef struct ui_method_st UI_METHOD;
 
-typedef struct engine_st ENGINE;
-typedef struct ssl_st SSL;
-typedef struct ssl_ctx_st SSL_CTX;
+    typedef struct engine_st ENGINE;
+    typedef struct ssl_st SSL;
+    typedef struct ssl_ctx_st SSL_CTX;
 
-typedef struct comp_ctx_st COMP_CTX;
-typedef struct comp_method_st COMP_METHOD;
+    typedef struct comp_ctx_st COMP_CTX;
+    typedef struct comp_method_st COMP_METHOD;
 
-typedef struct X509_POLICY_NODE_st X509_POLICY_NODE;
-typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL;
-typedef struct X509_POLICY_TREE_st X509_POLICY_TREE;
-typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE;
+    typedef struct X509_POLICY_NODE_st X509_POLICY_NODE;
+    typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL;
+    typedef struct X509_POLICY_TREE_st X509_POLICY_TREE;
+    typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE;
 
-typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID;
-typedef struct DIST_POINT_st DIST_POINT;
-typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT;
-typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS;
+    typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID;
+    typedef struct DIST_POINT_st DIST_POINT;
+    typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT;
+    typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS;
 
-typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
+    typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
 
-typedef struct ossl_http_req_ctx_st OSSL_HTTP_REQ_CTX;
-typedef struct ocsp_response_st OCSP_RESPONSE;
-typedef struct ocsp_responder_id_st OCSP_RESPID;
+    typedef struct ossl_http_req_ctx_st OSSL_HTTP_REQ_CTX;
+    typedef struct ocsp_response_st OCSP_RESPONSE;
+    typedef struct ocsp_responder_id_st OCSP_RESPID;
 
-typedef struct sct_st SCT;
-typedef struct sct_ctx_st SCT_CTX;
-typedef struct ctlog_st CTLOG;
-typedef struct ctlog_store_st CTLOG_STORE;
-typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX;
+    typedef struct sct_st SCT;
+    typedef struct sct_ctx_st SCT_CTX;
+    typedef struct ctlog_st CTLOG;
+    typedef struct ctlog_store_st CTLOG_STORE;
+    typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX;
 
-typedef struct ossl_store_info_st OSSL_STORE_INFO;
-typedef struct ossl_store_search_st OSSL_STORE_SEARCH;
+    typedef struct ossl_store_info_st OSSL_STORE_INFO;
+    typedef struct ossl_store_search_st OSSL_STORE_SEARCH;
 
-typedef struct ossl_lib_ctx_st OSSL_LIB_CTX;
+    typedef struct ossl_lib_ctx_st OSSL_LIB_CTX;
 
-typedef struct ossl_dispatch_st OSSL_DISPATCH;
-typedef struct ossl_item_st OSSL_ITEM;
-typedef struct ossl_algorithm_st OSSL_ALGORITHM;
-typedef struct ossl_param_st OSSL_PARAM;
-typedef struct ossl_param_bld_st OSSL_PARAM_BLD;
+    typedef struct ossl_dispatch_st OSSL_DISPATCH;
+    typedef struct ossl_item_st OSSL_ITEM;
+    typedef struct ossl_algorithm_st OSSL_ALGORITHM;
+    typedef struct ossl_param_st OSSL_PARAM;
+    typedef struct ossl_param_bld_st OSSL_PARAM_BLD;
 
-typedef int pem_password_cb (char *buf, int size, int rwflag, void *userdata);
+    typedef int pem_password_cb(char* buf, int size, int rwflag, void* userdata);
 
-typedef struct ossl_encoder_st OSSL_ENCODER;
-typedef struct ossl_encoder_ctx_st OSSL_ENCODER_CTX;
-typedef struct ossl_decoder_st OSSL_DECODER;
-typedef struct ossl_decoder_ctx_st OSSL_DECODER_CTX;
+    typedef struct ossl_encoder_st OSSL_ENCODER;
+    typedef struct ossl_encoder_ctx_st OSSL_ENCODER_CTX;
+    typedef struct ossl_decoder_st OSSL_DECODER;
+    typedef struct ossl_decoder_ctx_st OSSL_DECODER_CTX;
 
-typedef struct ossl_self_test_st OSSL_SELF_TEST;
+    typedef struct ossl_self_test_st OSSL_SELF_TEST;
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/CAPI/cpp/grpc/include/openssl/ui.h b/CAPI/cpp/grpc/include/openssl/ui.h
index 835b0eb..7d511c0 100644
--- a/CAPI/cpp/grpc/include/openssl/ui.h
+++ b/CAPI/cpp/grpc/include/openssl/ui.h
@@ -10,117 +10,106 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_UI_H
-# define OPENSSL_UI_H
-# pragma once
+#define OPENSSL_UI_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_UI_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_UI_H
+#endif
 
-# include <openssl/opensslconf.h>
+#include <openssl/opensslconf.h>
 
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  include <openssl/crypto.h>
-# endif
-# include <openssl/safestack.h>
-# include <openssl/pem.h>
-# include <openssl/types.h>
-# include <openssl/uierr.h>
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/crypto.h>
+#endif
+#include <openssl/safestack.h>
+#include <openssl/pem.h>
+#include <openssl/types.h>
+#include <openssl/uierr.h>
 
 /* For compatibility reasons, the macro OPENSSL_NO_UI is currently retained */
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifdef OPENSSL_NO_UI_CONSOLE
-#   define OPENSSL_NO_UI
-#  endif
-# endif
-
-# ifdef  __cplusplus
-extern "C" {
-# endif
-
-/*
- * All the following functions return -1 or NULL on error and in some cases
- * (UI_process()) -2 if interrupted or in some other way cancelled. When
- * everything is fine, they return 0, a positive value or a non-NULL pointer,
- * all depending on their purpose.
- */
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifdef OPENSSL_NO_UI_CONSOLE
+#define OPENSSL_NO_UI
+#endif
+#endif
 
-/* Creators and destructor.   */
-UI *UI_new(void);
-UI *UI_new_method(const UI_METHOD *method);
-void UI_free(UI *ui);
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-/*-
-   The following functions are used to add strings to be printed and prompt
-   strings to prompt for data.  The names are UI_{add,dup}_<function>_string
-   and UI_{add,dup}_input_boolean.
-
-   UI_{add,dup}_<function>_string have the following meanings:
-        add     add a text or prompt string.  The pointers given to these
-                functions are used verbatim, no copying is done.
-        dup     make a copy of the text or prompt string, then add the copy
-                to the collection of strings in the user interface.
-        <function>
-                The function is a name for the functionality that the given
-                string shall be used for.  It can be one of:
-                        input   use the string as data prompt.
-                        verify  use the string as verification prompt.  This
-                                is used to verify a previous input.
-                        info    use the string for informational output.
-                        error   use the string for error output.
-   Honestly, there's currently no difference between info and error for the
-   moment.
-
-   UI_{add,dup}_input_boolean have the same semantics for "add" and "dup",
-   and are typically used when one wants to prompt for a yes/no response.
-
-   All of the functions in this group take a UI and a prompt string.
-   The string input and verify addition functions also take a flag argument,
-   a buffer for the result to end up with, a minimum input size and a maximum
-   input size (the result buffer MUST be large enough to be able to contain
-   the maximum number of characters).  Additionally, the verify addition
-   functions takes another buffer to compare the result against.
-   The boolean input functions take an action description string (which should
-   be safe to ignore if the expected user action is obvious, for example with
-   a dialog box with an OK button and a Cancel button), a string of acceptable
-   characters to mean OK and to mean Cancel.  The two last strings are checked
-   to make sure they don't have common characters.  Additionally, the same
-   flag argument as for the string input is taken, as well as a result buffer.
-   The result buffer is required to be at least one byte long.  Depending on
-   the answer, the first character from the OK or the Cancel character strings
-   will be stored in the first byte of the result buffer.  No NUL will be
-   added, so the result is *not* a string.
-
-   On success, the all return an index of the added information.  That index
-   is useful when retrieving results with UI_get0_result(). */
-int UI_add_input_string(UI *ui, const char *prompt, int flags,
-                        char *result_buf, int minsize, int maxsize);
-int UI_dup_input_string(UI *ui, const char *prompt, int flags,
-                        char *result_buf, int minsize, int maxsize);
-int UI_add_verify_string(UI *ui, const char *prompt, int flags,
-                         char *result_buf, int minsize, int maxsize,
-                         const char *test_buf);
-int UI_dup_verify_string(UI *ui, const char *prompt, int flags,
-                         char *result_buf, int minsize, int maxsize,
-                         const char *test_buf);
-int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
-                         const char *ok_chars, const char *cancel_chars,
-                         int flags, char *result_buf);
-int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
-                         const char *ok_chars, const char *cancel_chars,
-                         int flags, char *result_buf);
-int UI_add_info_string(UI *ui, const char *text);
-int UI_dup_info_string(UI *ui, const char *text);
-int UI_add_error_string(UI *ui, const char *text);
-int UI_dup_error_string(UI *ui, const char *text);
+    /*
+     * All the following functions return -1 or NULL on error and in some cases
+     * (UI_process()) -2 if interrupted or in some other way cancelled. When
+     * everything is fine, they return 0, a positive value or a non-NULL pointer,
+     * all depending on their purpose.
+     */
+
+    /* Creators and destructor.   */
+    UI* UI_new(void);
+    UI* UI_new_method(const UI_METHOD* method);
+    void UI_free(UI* ui);
+
+    /*-
+       The following functions are used to add strings to be printed and prompt
+       strings to prompt for data.  The names are UI_{add,dup}_<function>_string
+       and UI_{add,dup}_input_boolean.
+
+       UI_{add,dup}_<function>_string have the following meanings:
+            add     add a text or prompt string.  The pointers given to these
+                    functions are used verbatim, no copying is done.
+            dup     make a copy of the text or prompt string, then add the copy
+                    to the collection of strings in the user interface.
+            <function>
+                    The function is a name for the functionality that the given
+                    string shall be used for.  It can be one of:
+                            input   use the string as data prompt.
+                            verify  use the string as verification prompt.  This
+                                    is used to verify a previous input.
+                            info    use the string for informational output.
+                            error   use the string for error output.
+       Honestly, there's currently no difference between info and error for the
+       moment.
+
+       UI_{add,dup}_input_boolean have the same semantics for "add" and "dup",
+       and are typically used when one wants to prompt for a yes/no response.
+
+       All of the functions in this group take a UI and a prompt string.
+       The string input and verify addition functions also take a flag argument,
+       a buffer for the result to end up with, a minimum input size and a maximum
+       input size (the result buffer MUST be large enough to be able to contain
+       the maximum number of characters).  Additionally, the verify addition
+       functions takes another buffer to compare the result against.
+       The boolean input functions take an action description string (which should
+       be safe to ignore if the expected user action is obvious, for example with
+       a dialog box with an OK button and a Cancel button), a string of acceptable
+       characters to mean OK and to mean Cancel.  The two last strings are checked
+       to make sure they don't have common characters.  Additionally, the same
+       flag argument as for the string input is taken, as well as a result buffer.
+       The result buffer is required to be at least one byte long.  Depending on
+       the answer, the first character from the OK or the Cancel character strings
+       will be stored in the first byte of the result buffer.  No NUL will be
+       added, so the result is *not* a string.
+
+       On success, the all return an index of the added information.  That index
+       is useful when retrieving results with UI_get0_result(). */
+    int UI_add_input_string(UI* ui, const char* prompt, int flags, char* result_buf, int minsize, int maxsize);
+    int UI_dup_input_string(UI* ui, const char* prompt, int flags, char* result_buf, int minsize, int maxsize);
+    int UI_add_verify_string(UI* ui, const char* prompt, int flags, char* result_buf, int minsize, int maxsize, const char* test_buf);
+    int UI_dup_verify_string(UI* ui, const char* prompt, int flags, char* result_buf, int minsize, int maxsize, const char* test_buf);
+    int UI_add_input_boolean(UI* ui, const char* prompt, const char* action_desc, const char* ok_chars, const char* cancel_chars, int flags, char* result_buf);
+    int UI_dup_input_boolean(UI* ui, const char* prompt, const char* action_desc, const char* ok_chars, const char* cancel_chars, int flags, char* result_buf);
+    int UI_add_info_string(UI* ui, const char* text);
+    int UI_dup_info_string(UI* ui, const char* text);
+    int UI_add_error_string(UI* ui, const char* text);
+    int UI_dup_error_string(UI* ui, const char* text);
 
 /* These are the possible flags.  They can be or'ed together. */
 /* Use to have echoing of input */
-# define UI_INPUT_FLAG_ECHO              0x01
+#define UI_INPUT_FLAG_ECHO 0x01
 /*
  * Use a default password.  Where that password is found is completely up to
  * the application, it might for example be in the user data set with
@@ -128,7 +117,7 @@ int UI_dup_error_string(UI *ui, const char *text);
  * each UI being marked with this flag, or the application might get
  * confused.
  */
-# define UI_INPUT_FLAG_DEFAULT_PWD       0x02
+#define UI_INPUT_FLAG_DEFAULT_PWD 0x02
 
 /*-
  * The user of these routines may want to define flags of their own.  The core
@@ -139,65 +128,64 @@ int UI_dup_error_string(UI *ui, const char *text);
  *
  *    #define MY_UI_FLAG1       (0x01 << UI_INPUT_FLAG_USER_BASE)
  *
-*/
-# define UI_INPUT_FLAG_USER_BASE 16
-
-/*-
- * The following function helps construct a prompt.
- * phrase_desc is a textual short description of the phrase to enter,
- * for example "pass phrase", and
- * object_name is the name of the object
- * (which might be a card name or a file name) or NULL.
- * The returned string shall always be allocated on the heap with
- * OPENSSL_malloc(), and need to be free'd with OPENSSL_free().
- *
- * If the ui_method doesn't contain a pointer to a user-defined prompt
- * constructor, a default string is built, looking like this:
- *
- *       "Enter {phrase_desc} for {object_name}:"
- *
- * So, if phrase_desc has the value "pass phrase" and object_name has
- * the value "foo.key", the resulting string is:
- *
- *       "Enter pass phrase for foo.key:"
-*/
-char *UI_construct_prompt(UI *ui_method,
-                          const char *phrase_desc, const char *object_name);
-
-/*
- * The following function is used to store a pointer to user-specific data.
- * Any previous such pointer will be returned and replaced.
- *
- * For callback purposes, this function makes a lot more sense than using
- * ex_data, since the latter requires that different parts of OpenSSL or
- * applications share the same ex_data index.
- *
- * Note that the UI_OpenSSL() method completely ignores the user data. Other
- * methods may not, however.
- */
-void *UI_add_user_data(UI *ui, void *user_data);
-/*
- * Alternatively, this function is used to duplicate the user data.
- * This uses the duplicator method function.  The destroy function will
- * be used to free the user data in this case.
- */
-int UI_dup_user_data(UI *ui, void *user_data);
-/* We need a user data retrieving function as well.  */
-void *UI_get0_user_data(UI *ui);
-
-/* Return the result associated with a prompt given with the index i. */
-const char *UI_get0_result(UI *ui, int i);
-int UI_get_result_length(UI *ui, int i);
-
-/* When all strings have been added, process the whole thing. */
-int UI_process(UI *ui);
-
-/*
- * Give a user interface parameterised control commands.  This can be used to
- * send down an integer, a data pointer or a function pointer, as well as be
- * used to get information from a UI.
  */
-int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void));
+#define UI_INPUT_FLAG_USER_BASE 16
+
+    /*-
+     * The following function helps construct a prompt.
+     * phrase_desc is a textual short description of the phrase to enter,
+     * for example "pass phrase", and
+     * object_name is the name of the object
+     * (which might be a card name or a file name) or NULL.
+     * The returned string shall always be allocated on the heap with
+     * OPENSSL_malloc(), and need to be free'd with OPENSSL_free().
+     *
+     * If the ui_method doesn't contain a pointer to a user-defined prompt
+     * constructor, a default string is built, looking like this:
+     *
+     *       "Enter {phrase_desc} for {object_name}:"
+     *
+     * So, if phrase_desc has the value "pass phrase" and object_name has
+     * the value "foo.key", the resulting string is:
+     *
+     *       "Enter pass phrase for foo.key:"
+     */
+    char* UI_construct_prompt(UI* ui_method, const char* phrase_desc, const char* object_name);
+
+    /*
+     * The following function is used to store a pointer to user-specific data.
+     * Any previous such pointer will be returned and replaced.
+     *
+     * For callback purposes, this function makes a lot more sense than using
+     * ex_data, since the latter requires that different parts of OpenSSL or
+     * applications share the same ex_data index.
+     *
+     * Note that the UI_OpenSSL() method completely ignores the user data. Other
+     * methods may not, however.
+     */
+    void* UI_add_user_data(UI* ui, void* user_data);
+    /*
+     * Alternatively, this function is used to duplicate the user data.
+     * This uses the duplicator method function.  The destroy function will
+     * be used to free the user data in this case.
+     */
+    int UI_dup_user_data(UI* ui, void* user_data);
+    /* We need a user data retrieving function as well.  */
+    void* UI_get0_user_data(UI* ui);
+
+    /* Return the result associated with a prompt given with the index i. */
+    const char* UI_get0_result(UI* ui, int i);
+    int UI_get_result_length(UI* ui, int i);
+
+    /* When all strings have been added, process the whole thing. */
+    int UI_process(UI* ui);
+
+    /*
+     * Give a user interface parameterised control commands.  This can be used to
+     * send down an integer, a data pointer or a function pointer, as well as be
+     * used to get information from a UI.
+     */
+    int UI_ctrl(UI* ui, int cmd, long i, void* p, void (*f)(void));
 
 /* The commands */
 /*
@@ -205,203 +193,190 @@ int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void));
  * OpenSSL error stack before printing any info or added error messages and
  * before any prompting.
  */
-# define UI_CTRL_PRINT_ERRORS            1
+#define UI_CTRL_PRINT_ERRORS 1
 /*
  * Check if a UI_process() is possible to do again with the same instance of
  * a user interface.  This makes UI_ctrl() return 1 if it is redoable, and 0
  * if not.
  */
-# define UI_CTRL_IS_REDOABLE             2
+#define UI_CTRL_IS_REDOABLE 2
 
 /* Some methods may use extra data */
-# define UI_set_app_data(s,arg)         UI_set_ex_data(s,0,arg)
-# define UI_get_app_data(s)             UI_get_ex_data(s,0)
+#define UI_set_app_data(s, arg) UI_set_ex_data(s, 0, arg)
+#define UI_get_app_data(s) UI_get_ex_data(s, 0)
 
-# define UI_get_ex_new_index(l, p, newf, dupf, freef) \
+#define UI_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_UI, l, p, newf, dupf, freef)
-int UI_set_ex_data(UI *r, int idx, void *arg);
-void *UI_get_ex_data(const UI *r, int idx);
+    int UI_set_ex_data(UI* r, int idx, void* arg);
+    void* UI_get_ex_data(const UI* r, int idx);
 
-/* Use specific methods instead of the built-in one */
-void UI_set_default_method(const UI_METHOD *meth);
-const UI_METHOD *UI_get_default_method(void);
-const UI_METHOD *UI_get_method(UI *ui);
-const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth);
+    /* Use specific methods instead of the built-in one */
+    void UI_set_default_method(const UI_METHOD* meth);
+    const UI_METHOD* UI_get_default_method(void);
+    const UI_METHOD* UI_get_method(UI* ui);
+    const UI_METHOD* UI_set_method(UI* ui, const UI_METHOD* meth);
 
-# ifndef OPENSSL_NO_UI_CONSOLE
+#ifndef OPENSSL_NO_UI_CONSOLE
 
-/* The method with all the built-in thingies */
-UI_METHOD *UI_OpenSSL(void);
+    /* The method with all the built-in thingies */
+    UI_METHOD* UI_OpenSSL(void);
 
-# endif
-
-/*
- * NULL method.  Literally does nothing, but may serve as a placeholder
- * to avoid internal default.
- */
-const UI_METHOD *UI_null(void);
-
-/* ---------- For method writers ---------- */
-/*-
-   A method contains a number of functions that implement the low level
-   of the User Interface.  The functions are:
-
-        an opener       This function starts a session, maybe by opening
-                        a channel to a tty, or by opening a window.
-        a writer        This function is called to write a given string,
-                        maybe to the tty, maybe as a field label in a
-                        window.
-        a flusher       This function is called to flush everything that
-                        has been output so far.  It can be used to actually
-                        display a dialog box after it has been built.
-        a reader        This function is called to read a given prompt,
-                        maybe from the tty, maybe from a field in a
-                        window.  Note that it's called with all string
-                        structures, not only the prompt ones, so it must
-                        check such things itself.
-        a closer        This function closes the session, maybe by closing
-                        the channel to the tty, or closing the window.
-
-   All these functions are expected to return:
-
-        0       on error.
-        1       on success.
-        -1      on out-of-band events, for example if some prompting has
-                been canceled (by pressing Ctrl-C, for example).  This is
-                only checked when returned by the flusher or the reader.
-
-   The way this is used, the opener is first called, then the writer for all
-   strings, then the flusher, then the reader for all strings and finally the
-   closer.  Note that if you want to prompt from a terminal or other command
-   line interface, the best is to have the reader also write the prompts
-   instead of having the writer do it.  If you want to prompt from a dialog
-   box, the writer can be used to build up the contents of the box, and the
-   flusher to actually display the box and run the event loop until all data
-   has been given, after which the reader only grabs the given data and puts
-   them back into the UI strings.
-
-   All method functions take a UI as argument.  Additionally, the writer and
-   the reader take a UI_STRING.
-*/
-
-/*
- * The UI_STRING type is the data structure that contains all the needed info
- * about a string or a prompt, including test data for a verification prompt.
- */
-typedef struct ui_string_st UI_STRING;
+#endif
 
-SKM_DEFINE_STACK_OF_INTERNAL(UI_STRING, UI_STRING, UI_STRING)
+    /*
+     * NULL method.  Literally does nothing, but may serve as a placeholder
+     * to avoid internal default.
+     */
+    const UI_METHOD* UI_null(void);
+
+    /* ---------- For method writers ---------- */
+    /*-
+       A method contains a number of functions that implement the low level
+       of the User Interface.  The functions are:
+
+            an opener       This function starts a session, maybe by opening
+                            a channel to a tty, or by opening a window.
+            a writer        This function is called to write a given string,
+                            maybe to the tty, maybe as a field label in a
+                            window.
+            a flusher       This function is called to flush everything that
+                            has been output so far.  It can be used to actually
+                            display a dialog box after it has been built.
+            a reader        This function is called to read a given prompt,
+                            maybe from the tty, maybe from a field in a
+                            window.  Note that it's called with all string
+                            structures, not only the prompt ones, so it must
+                            check such things itself.
+            a closer        This function closes the session, maybe by closing
+                            the channel to the tty, or closing the window.
+
+       All these functions are expected to return:
+
+            0       on error.
+            1       on success.
+            -1      on out-of-band events, for example if some prompting has
+                    been canceled (by pressing Ctrl-C, for example).  This is
+                    only checked when returned by the flusher or the reader.
+
+       The way this is used, the opener is first called, then the writer for all
+       strings, then the flusher, then the reader for all strings and finally the
+       closer.  Note that if you want to prompt from a terminal or other command
+       line interface, the best is to have the reader also write the prompts
+       instead of having the writer do it.  If you want to prompt from a dialog
+       box, the writer can be used to build up the contents of the box, and the
+       flusher to actually display the box and run the event loop until all data
+       has been given, after which the reader only grabs the given data and puts
+       them back into the UI strings.
+
+       All method functions take a UI as argument.  Additionally, the writer and
+       the reader take a UI_STRING.
+    */
+
+    /*
+     * The UI_STRING type is the data structure that contains all the needed info
+     * about a string or a prompt, including test data for a verification prompt.
+     */
+    typedef struct ui_string_st UI_STRING;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(UI_STRING, UI_STRING, UI_STRING)
 #define sk_UI_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_UI_STRING_sk_type(sk))
-#define sk_UI_STRING_value(sk, idx) ((UI_STRING *)OPENSSL_sk_value(ossl_check_const_UI_STRING_sk_type(sk), (idx)))
-#define sk_UI_STRING_new(cmp) ((STACK_OF(UI_STRING) *)OPENSSL_sk_new(ossl_check_UI_STRING_compfunc_type(cmp)))
-#define sk_UI_STRING_new_null() ((STACK_OF(UI_STRING) *)OPENSSL_sk_new_null())
-#define sk_UI_STRING_new_reserve(cmp, n) ((STACK_OF(UI_STRING) *)OPENSSL_sk_new_reserve(ossl_check_UI_STRING_compfunc_type(cmp), (n)))
+#define sk_UI_STRING_value(sk, idx) ((UI_STRING*)OPENSSL_sk_value(ossl_check_const_UI_STRING_sk_type(sk), (idx)))
+#define sk_UI_STRING_new(cmp) ((STACK_OF(UI_STRING)*)OPENSSL_sk_new(ossl_check_UI_STRING_compfunc_type(cmp)))
+#define sk_UI_STRING_new_null() ((STACK_OF(UI_STRING)*)OPENSSL_sk_new_null())
+#define sk_UI_STRING_new_reserve(cmp, n) ((STACK_OF(UI_STRING)*)OPENSSL_sk_new_reserve(ossl_check_UI_STRING_compfunc_type(cmp), (n)))
 #define sk_UI_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_UI_STRING_sk_type(sk), (n))
 #define sk_UI_STRING_free(sk) OPENSSL_sk_free(ossl_check_UI_STRING_sk_type(sk))
 #define sk_UI_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_UI_STRING_sk_type(sk))
-#define sk_UI_STRING_delete(sk, i) ((UI_STRING *)OPENSSL_sk_delete(ossl_check_UI_STRING_sk_type(sk), (i)))
-#define sk_UI_STRING_delete_ptr(sk, ptr) ((UI_STRING *)OPENSSL_sk_delete_ptr(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr)))
+#define sk_UI_STRING_delete(sk, i) ((UI_STRING*)OPENSSL_sk_delete(ossl_check_UI_STRING_sk_type(sk), (i)))
+#define sk_UI_STRING_delete_ptr(sk, ptr) ((UI_STRING*)OPENSSL_sk_delete_ptr(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr)))
 #define sk_UI_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
 #define sk_UI_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
-#define sk_UI_STRING_pop(sk) ((UI_STRING *)OPENSSL_sk_pop(ossl_check_UI_STRING_sk_type(sk)))
-#define sk_UI_STRING_shift(sk) ((UI_STRING *)OPENSSL_sk_shift(ossl_check_UI_STRING_sk_type(sk)))
-#define sk_UI_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_UI_STRING_sk_type(sk),ossl_check_UI_STRING_freefunc_type(freefunc))
+#define sk_UI_STRING_pop(sk) ((UI_STRING*)OPENSSL_sk_pop(ossl_check_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_shift(sk) ((UI_STRING*)OPENSSL_sk_shift(ossl_check_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_freefunc_type(freefunc))
 #define sk_UI_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr), (idx))
-#define sk_UI_STRING_set(sk, idx, ptr) ((UI_STRING *)OPENSSL_sk_set(ossl_check_UI_STRING_sk_type(sk), (idx), ossl_check_UI_STRING_type(ptr)))
+#define sk_UI_STRING_set(sk, idx, ptr) ((UI_STRING*)OPENSSL_sk_set(ossl_check_UI_STRING_sk_type(sk), (idx), ossl_check_UI_STRING_type(ptr)))
 #define sk_UI_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
 #define sk_UI_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr))
 #define sk_UI_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr), pnum)
 #define sk_UI_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_UI_STRING_sk_type(sk))
 #define sk_UI_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_UI_STRING_sk_type(sk))
-#define sk_UI_STRING_dup(sk) ((STACK_OF(UI_STRING) *)OPENSSL_sk_dup(ossl_check_const_UI_STRING_sk_type(sk)))
-#define sk_UI_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(UI_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_UI_STRING_sk_type(sk), ossl_check_UI_STRING_copyfunc_type(copyfunc), ossl_check_UI_STRING_freefunc_type(freefunc)))
+#define sk_UI_STRING_dup(sk) ((STACK_OF(UI_STRING)*)OPENSSL_sk_dup(ossl_check_const_UI_STRING_sk_type(sk)))
+#define sk_UI_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(UI_STRING)*)OPENSSL_sk_deep_copy(ossl_check_const_UI_STRING_sk_type(sk), ossl_check_UI_STRING_copyfunc_type(copyfunc), ossl_check_UI_STRING_freefunc_type(freefunc)))
 #define sk_UI_STRING_set_cmp_func(sk, cmp) ((sk_UI_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_compfunc_type(cmp)))
 
-
-/*
- * The different types of strings that are currently supported. This is only
- * needed by method authors.
- */
-enum UI_string_types {
-    UIT_NONE = 0,
-    UIT_PROMPT,                 /* Prompt for a string */
-    UIT_VERIFY,                 /* Prompt for a string and verify */
-    UIT_BOOLEAN,                /* Prompt for a yes/no response */
-    UIT_INFO,                   /* Send info to the user */
-    UIT_ERROR                   /* Send an error message to the user */
-};
-
-/* Create and manipulate methods */
-UI_METHOD *UI_create_method(const char *name);
-void UI_destroy_method(UI_METHOD *ui_method);
-int UI_method_set_opener(UI_METHOD *method, int (*opener) (UI *ui));
-int UI_method_set_writer(UI_METHOD *method,
-                         int (*writer) (UI *ui, UI_STRING *uis));
-int UI_method_set_flusher(UI_METHOD *method, int (*flusher) (UI *ui));
-int UI_method_set_reader(UI_METHOD *method,
-                         int (*reader) (UI *ui, UI_STRING *uis));
-int UI_method_set_closer(UI_METHOD *method, int (*closer) (UI *ui));
-int UI_method_set_data_duplicator(UI_METHOD *method,
-                                  void *(*duplicator) (UI *ui, void *ui_data),
-                                  void (*destructor)(UI *ui, void *ui_data));
-int UI_method_set_prompt_constructor(UI_METHOD *method,
-                                     char *(*prompt_constructor) (UI *ui,
-                                                                  const char
-                                                                  *phrase_desc,
-                                                                  const char
-                                                                  *object_name));
-int UI_method_set_ex_data(UI_METHOD *method, int idx, void *data);
-int (*UI_method_get_opener(const UI_METHOD *method)) (UI *);
-int (*UI_method_get_writer(const UI_METHOD *method)) (UI *, UI_STRING *);
-int (*UI_method_get_flusher(const UI_METHOD *method)) (UI *);
-int (*UI_method_get_reader(const UI_METHOD *method)) (UI *, UI_STRING *);
-int (*UI_method_get_closer(const UI_METHOD *method)) (UI *);
-char *(*UI_method_get_prompt_constructor(const UI_METHOD *method))
-    (UI *, const char *, const char *);
-void *(*UI_method_get_data_duplicator(const UI_METHOD *method)) (UI *, void *);
-void (*UI_method_get_data_destructor(const UI_METHOD *method)) (UI *, void *);
-const void *UI_method_get_ex_data(const UI_METHOD *method, int idx);
-
-/*
- * The following functions are helpers for method writers to access relevant
- * data from a UI_STRING.
- */
-
-/* Return type of the UI_STRING */
-enum UI_string_types UI_get_string_type(UI_STRING *uis);
-/* Return input flags of the UI_STRING */
-int UI_get_input_flags(UI_STRING *uis);
-/* Return the actual string to output (the prompt, info or error) */
-const char *UI_get0_output_string(UI_STRING *uis);
-/*
- * Return the optional action string to output (the boolean prompt
- * instruction)
- */
-const char *UI_get0_action_string(UI_STRING *uis);
-/* Return the result of a prompt */
-const char *UI_get0_result_string(UI_STRING *uis);
-int UI_get_result_string_length(UI_STRING *uis);
-/*
- * Return the string to test the result against.  Only useful with verifies.
- */
-const char *UI_get0_test_string(UI_STRING *uis);
-/* Return the required minimum size of the result */
-int UI_get_result_minsize(UI_STRING *uis);
-/* Return the required maximum size of the result */
-int UI_get_result_maxsize(UI_STRING *uis);
-/* Set the result of a UI_STRING. */
-int UI_set_result(UI *ui, UI_STRING *uis, const char *result);
-int UI_set_result_ex(UI *ui, UI_STRING *uis, const char *result, int len);
-
-/* A couple of popular utility functions */
-int UI_UTIL_read_pw_string(char *buf, int length, const char *prompt,
-                           int verify);
-int UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt,
-                    int verify);
-UI_METHOD *UI_UTIL_wrap_read_pem_callback(pem_password_cb *cb, int rwflag);
-
-
-# ifdef  __cplusplus
+    /*
+     * The different types of strings that are currently supported. This is only
+     * needed by method authors.
+     */
+    enum UI_string_types
+    {
+        UIT_NONE = 0,
+        UIT_PROMPT,  /* Prompt for a string */
+        UIT_VERIFY,  /* Prompt for a string and verify */
+        UIT_BOOLEAN, /* Prompt for a yes/no response */
+        UIT_INFO,    /* Send info to the user */
+        UIT_ERROR    /* Send an error message to the user */
+    };
+
+    /* Create and manipulate methods */
+    UI_METHOD* UI_create_method(const char* name);
+    void UI_destroy_method(UI_METHOD* ui_method);
+    int UI_method_set_opener(UI_METHOD* method, int (*opener)(UI* ui));
+    int UI_method_set_writer(UI_METHOD* method, int (*writer)(UI* ui, UI_STRING* uis));
+    int UI_method_set_flusher(UI_METHOD* method, int (*flusher)(UI* ui));
+    int UI_method_set_reader(UI_METHOD* method, int (*reader)(UI* ui, UI_STRING* uis));
+    int UI_method_set_closer(UI_METHOD* method, int (*closer)(UI* ui));
+    int UI_method_set_data_duplicator(UI_METHOD* method, void* (*duplicator)(UI* ui, void* ui_data), void (*destructor)(UI* ui, void* ui_data));
+    int UI_method_set_prompt_constructor(UI_METHOD* method, char* (*prompt_constructor)(UI* ui, const char* phrase_desc, const char* object_name));
+    int UI_method_set_ex_data(UI_METHOD* method, int idx, void* data);
+    int (*UI_method_get_opener(const UI_METHOD* method))(UI*);
+    int (*UI_method_get_writer(const UI_METHOD* method))(UI*, UI_STRING*);
+    int (*UI_method_get_flusher(const UI_METHOD* method))(UI*);
+    int (*UI_method_get_reader(const UI_METHOD* method))(UI*, UI_STRING*);
+    int (*UI_method_get_closer(const UI_METHOD* method))(UI*);
+    char* (*UI_method_get_prompt_constructor(const UI_METHOD* method))(UI*, const char*, const char*);
+    void* (*UI_method_get_data_duplicator(const UI_METHOD* method))(UI*, void*);
+    void (*UI_method_get_data_destructor(const UI_METHOD* method))(UI*, void*);
+    const void* UI_method_get_ex_data(const UI_METHOD* method, int idx);
+
+    /*
+     * The following functions are helpers for method writers to access relevant
+     * data from a UI_STRING.
+     */
+
+    /* Return type of the UI_STRING */
+    enum UI_string_types UI_get_string_type(UI_STRING* uis);
+    /* Return input flags of the UI_STRING */
+    int UI_get_input_flags(UI_STRING* uis);
+    /* Return the actual string to output (the prompt, info or error) */
+    const char* UI_get0_output_string(UI_STRING* uis);
+    /*
+     * Return the optional action string to output (the boolean prompt
+     * instruction)
+     */
+    const char* UI_get0_action_string(UI_STRING* uis);
+    /* Return the result of a prompt */
+    const char* UI_get0_result_string(UI_STRING* uis);
+    int UI_get_result_string_length(UI_STRING* uis);
+    /*
+     * Return the string to test the result against.  Only useful with verifies.
+     */
+    const char* UI_get0_test_string(UI_STRING* uis);
+    /* Return the required minimum size of the result */
+    int UI_get_result_minsize(UI_STRING* uis);
+    /* Return the required maximum size of the result */
+    int UI_get_result_maxsize(UI_STRING* uis);
+    /* Set the result of a UI_STRING. */
+    int UI_set_result(UI* ui, UI_STRING* uis, const char* result);
+    int UI_set_result_ex(UI* ui, UI_STRING* uis, const char* result, int len);
+
+    /* A couple of popular utility functions */
+    int UI_UTIL_read_pw_string(char* buf, int length, const char* prompt, int verify);
+    int UI_UTIL_read_pw(char* buf, char* buff, int size, const char* prompt, int verify);
+    UI_METHOD* UI_UTIL_wrap_read_pem_callback(pem_password_cb* cb, int rwflag);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/uierr.h b/CAPI/cpp/grpc/include/openssl/uierr.h
index 473b04e..5201b03 100644
--- a/CAPI/cpp/grpc/include/openssl/uierr.h
+++ b/CAPI/cpp/grpc/include/openssl/uierr.h
@@ -9,30 +9,28 @@
  */
 
 #ifndef OPENSSL_UIERR_H
-# define OPENSSL_UIERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_UIERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * UI reason codes.
  */
-# define UI_R_COMMON_OK_AND_CANCEL_CHARACTERS             104
-# define UI_R_INDEX_TOO_LARGE                             102
-# define UI_R_INDEX_TOO_SMALL                             103
-# define UI_R_NO_RESULT_BUFFER                            105
-# define UI_R_PROCESSING_ERROR                            107
-# define UI_R_RESULT_TOO_LARGE                            100
-# define UI_R_RESULT_TOO_SMALL                            101
-# define UI_R_SYSASSIGN_ERROR                             109
-# define UI_R_SYSDASSGN_ERROR                             110
-# define UI_R_SYSQIOW_ERROR                               111
-# define UI_R_UNKNOWN_CONTROL_COMMAND                     106
-# define UI_R_UNKNOWN_TTYGET_ERRNO_VALUE                  108
-# define UI_R_USER_DATA_DUPLICATION_UNSUPPORTED           112
+#define UI_R_COMMON_OK_AND_CANCEL_CHARACTERS 104
+#define UI_R_INDEX_TOO_LARGE 102
+#define UI_R_INDEX_TOO_SMALL 103
+#define UI_R_NO_RESULT_BUFFER 105
+#define UI_R_PROCESSING_ERROR 107
+#define UI_R_RESULT_TOO_LARGE 100
+#define UI_R_RESULT_TOO_SMALL 101
+#define UI_R_SYSASSIGN_ERROR 109
+#define UI_R_SYSDASSGN_ERROR 110
+#define UI_R_SYSQIOW_ERROR 111
+#define UI_R_UNKNOWN_CONTROL_COMMAND 106
+#define UI_R_UNKNOWN_TTYGET_ERRNO_VALUE 108
+#define UI_R_USER_DATA_DUPLICATION_UNSUPPORTED 112
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/whrlpool.h b/CAPI/cpp/grpc/include/openssl/whrlpool.h
index 05ba463..f287494 100644
--- a/CAPI/cpp/grpc/include/openssl/whrlpool.h
+++ b/CAPI/cpp/grpc/include/openssl/whrlpool.h
@@ -8,55 +8,55 @@
  */
 
 #ifndef OPENSSL_WHRLPOOL_H
-# define OPENSSL_WHRLPOOL_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_WHRLPOOL_H
-# endif
-
-# include <openssl/opensslconf.h>
-
-# ifndef OPENSSL_NO_WHIRLPOOL
-#  include <openssl/e_os2.h>
-#  include <stddef.h>
-#  ifdef __cplusplus
-extern "C" {
-#  endif
-
-#  define WHIRLPOOL_DIGEST_LENGTH (512/8)
-
-#  if !defined(OPENSSL_NO_DEPRECATED_3_0)
-
-#   define WHIRLPOOL_BBLOCK        512
-#   define WHIRLPOOL_COUNTER       (256/8)
-
-typedef struct {
-    union {
-        unsigned char c[WHIRLPOOL_DIGEST_LENGTH];
-        /* double q is here to ensure 64-bit alignment */
-        double q[WHIRLPOOL_DIGEST_LENGTH / sizeof(double)];
-    } H;
-    unsigned char data[WHIRLPOOL_BBLOCK / 8];
-    unsigned int bitoff;
-    size_t bitlen[WHIRLPOOL_COUNTER / sizeof(size_t)];
-} WHIRLPOOL_CTX;
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Init(WHIRLPOOL_CTX *c);
-OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Update(WHIRLPOOL_CTX *c,
-                                           const void *inp, size_t bytes);
-OSSL_DEPRECATEDIN_3_0 void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c,
-                                               const void *inp, size_t bits);
-OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Final(unsigned char *md, WHIRLPOOL_CTX *c);
-OSSL_DEPRECATEDIN_3_0 unsigned char *WHIRLPOOL(const void *inp, size_t bytes,
-                                               unsigned char *md);
-#  endif
-
-#  ifdef __cplusplus
+#define OPENSSL_WHRLPOOL_H
+#pragma once
+
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_WHRLPOOL_H
+#endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_WHIRLPOOL
+#include <openssl/e_os2.h>
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define WHIRLPOOL_DIGEST_LENGTH (512 / 8)
+
+#if !defined(OPENSSL_NO_DEPRECATED_3_0)
+
+#define WHIRLPOOL_BBLOCK 512
+#define WHIRLPOOL_COUNTER (256 / 8)
+
+    typedef struct
+    {
+        union
+        {
+            unsigned char c[WHIRLPOOL_DIGEST_LENGTH];
+            /* double q is here to ensure 64-bit alignment */
+            double q[WHIRLPOOL_DIGEST_LENGTH / sizeof(double)];
+        } H;
+        unsigned char data[WHIRLPOOL_BBLOCK / 8];
+        unsigned int bitoff;
+        size_t bitlen[WHIRLPOOL_COUNTER / sizeof(size_t)];
+    } WHIRLPOOL_CTX;
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Init(WHIRLPOOL_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Update(WHIRLPOOL_CTX* c, const void* inp, size_t bytes);
+    OSSL_DEPRECATEDIN_3_0 void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX* c, const void* inp, size_t bits);
+    OSSL_DEPRECATEDIN_3_0 int WHIRLPOOL_Final(unsigned char* md, WHIRLPOOL_CTX* c);
+    OSSL_DEPRECATEDIN_3_0 unsigned char* WHIRLPOOL(const void* inp, size_t bytes, unsigned char* md);
+#endif
+
+#ifdef __cplusplus
 }
-#  endif
-# endif
+#endif
+#endif
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509.h b/CAPI/cpp/grpc/include/openssl/x509.h
index eda5d70..5f5ea19 100644
--- a/CAPI/cpp/grpc/include/openssl/x509.h
+++ b/CAPI/cpp/grpc/include/openssl/x509.h
@@ -11,1266 +11,1093 @@
  * https://www.openssl.org/source/license.html
  */
 
+#ifndef OPENSSL_X509_H
+#define OPENSSL_X509_H
+#pragma once
 
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_X509_H
+#endif
 
-#ifndef OPENSSL_X509_H
-# define OPENSSL_X509_H
-# pragma once
-
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_X509_H
-# endif
-
-# include <openssl/e_os2.h>
-# include <openssl/types.h>
-# include <openssl/symhacks.h>
-# include <openssl/buffer.h>
-# include <openssl/evp.h>
-# include <openssl/bio.h>
-# include <openssl/asn1.h>
-# include <openssl/safestack.h>
-# include <openssl/ec.h>
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  include <openssl/rsa.h>
-#  include <openssl/dsa.h>
-#  include <openssl/dh.h>
-# endif
-
-# include <openssl/sha.h>
-# include <openssl/x509err.h>
-
-#ifdef  __cplusplus
-extern "C" {
+#include <openssl/e_os2.h>
+#include <openssl/types.h>
+#include <openssl/symhacks.h>
+#include <openssl/buffer.h>
+#include <openssl/evp.h>
+#include <openssl/bio.h>
+#include <openssl/asn1.h>
+#include <openssl/safestack.h>
+#include <openssl/ec.h>
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#include <openssl/rsa.h>
+#include <openssl/dsa.h>
+#include <openssl/dh.h>
+#endif
+
+#include <openssl/sha.h>
+#include <openssl/x509err.h>
+
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-/* Needed stacks for types defined in other headers */
-SKM_DEFINE_STACK_OF_INTERNAL(X509_NAME, X509_NAME, X509_NAME)
+    /* Needed stacks for types defined in other headers */
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_NAME, X509_NAME, X509_NAME)
 #define sk_X509_NAME_num(sk) OPENSSL_sk_num(ossl_check_const_X509_NAME_sk_type(sk))
-#define sk_X509_NAME_value(sk, idx) ((X509_NAME *)OPENSSL_sk_value(ossl_check_const_X509_NAME_sk_type(sk), (idx)))
-#define sk_X509_NAME_new(cmp) ((STACK_OF(X509_NAME) *)OPENSSL_sk_new(ossl_check_X509_NAME_compfunc_type(cmp)))
-#define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME) *)OPENSSL_sk_new_null())
-#define sk_X509_NAME_new_reserve(cmp, n) ((STACK_OF(X509_NAME) *)OPENSSL_sk_new_reserve(ossl_check_X509_NAME_compfunc_type(cmp), (n)))
+#define sk_X509_NAME_value(sk, idx) ((X509_NAME*)OPENSSL_sk_value(ossl_check_const_X509_NAME_sk_type(sk), (idx)))
+#define sk_X509_NAME_new(cmp) ((STACK_OF(X509_NAME)*)OPENSSL_sk_new(ossl_check_X509_NAME_compfunc_type(cmp)))
+#define sk_X509_NAME_new_null() ((STACK_OF(X509_NAME)*)OPENSSL_sk_new_null())
+#define sk_X509_NAME_new_reserve(cmp, n) ((STACK_OF(X509_NAME)*)OPENSSL_sk_new_reserve(ossl_check_X509_NAME_compfunc_type(cmp), (n)))
 #define sk_X509_NAME_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_NAME_sk_type(sk), (n))
 #define sk_X509_NAME_free(sk) OPENSSL_sk_free(ossl_check_X509_NAME_sk_type(sk))
 #define sk_X509_NAME_zero(sk) OPENSSL_sk_zero(ossl_check_X509_NAME_sk_type(sk))
-#define sk_X509_NAME_delete(sk, i) ((X509_NAME *)OPENSSL_sk_delete(ossl_check_X509_NAME_sk_type(sk), (i)))
-#define sk_X509_NAME_delete_ptr(sk, ptr) ((X509_NAME *)OPENSSL_sk_delete_ptr(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr)))
+#define sk_X509_NAME_delete(sk, i) ((X509_NAME*)OPENSSL_sk_delete(ossl_check_X509_NAME_sk_type(sk), (i)))
+#define sk_X509_NAME_delete_ptr(sk, ptr) ((X509_NAME*)OPENSSL_sk_delete_ptr(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr)))
 #define sk_X509_NAME_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
 #define sk_X509_NAME_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
-#define sk_X509_NAME_pop(sk) ((X509_NAME *)OPENSSL_sk_pop(ossl_check_X509_NAME_sk_type(sk)))
-#define sk_X509_NAME_shift(sk) ((X509_NAME *)OPENSSL_sk_shift(ossl_check_X509_NAME_sk_type(sk)))
-#define sk_X509_NAME_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_NAME_sk_type(sk),ossl_check_X509_NAME_freefunc_type(freefunc))
+#define sk_X509_NAME_pop(sk) ((X509_NAME*)OPENSSL_sk_pop(ossl_check_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_shift(sk) ((X509_NAME*)OPENSSL_sk_shift(ossl_check_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_freefunc_type(freefunc))
 #define sk_X509_NAME_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr), (idx))
-#define sk_X509_NAME_set(sk, idx, ptr) ((X509_NAME *)OPENSSL_sk_set(ossl_check_X509_NAME_sk_type(sk), (idx), ossl_check_X509_NAME_type(ptr)))
+#define sk_X509_NAME_set(sk, idx, ptr) ((X509_NAME*)OPENSSL_sk_set(ossl_check_X509_NAME_sk_type(sk), (idx), ossl_check_X509_NAME_type(ptr)))
 #define sk_X509_NAME_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
 #define sk_X509_NAME_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr))
 #define sk_X509_NAME_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_type(ptr), pnum)
 #define sk_X509_NAME_sort(sk) OPENSSL_sk_sort(ossl_check_X509_NAME_sk_type(sk))
 #define sk_X509_NAME_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_NAME_sk_type(sk))
-#define sk_X509_NAME_dup(sk) ((STACK_OF(X509_NAME) *)OPENSSL_sk_dup(ossl_check_const_X509_NAME_sk_type(sk)))
-#define sk_X509_NAME_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_NAME) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_NAME_sk_type(sk), ossl_check_X509_NAME_copyfunc_type(copyfunc), ossl_check_X509_NAME_freefunc_type(freefunc)))
+#define sk_X509_NAME_dup(sk) ((STACK_OF(X509_NAME)*)OPENSSL_sk_dup(ossl_check_const_X509_NAME_sk_type(sk)))
+#define sk_X509_NAME_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_NAME)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_NAME_sk_type(sk), ossl_check_X509_NAME_copyfunc_type(copyfunc), ossl_check_X509_NAME_freefunc_type(freefunc)))
 #define sk_X509_NAME_set_cmp_func(sk, cmp) ((sk_X509_NAME_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_NAME_sk_type(sk), ossl_check_X509_NAME_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(X509, X509, X509)
+    SKM_DEFINE_STACK_OF_INTERNAL(X509, X509, X509)
 #define sk_X509_num(sk) OPENSSL_sk_num(ossl_check_const_X509_sk_type(sk))
-#define sk_X509_value(sk, idx) ((X509 *)OPENSSL_sk_value(ossl_check_const_X509_sk_type(sk), (idx)))
-#define sk_X509_new(cmp) ((STACK_OF(X509) *)OPENSSL_sk_new(ossl_check_X509_compfunc_type(cmp)))
-#define sk_X509_new_null() ((STACK_OF(X509) *)OPENSSL_sk_new_null())
-#define sk_X509_new_reserve(cmp, n) ((STACK_OF(X509) *)OPENSSL_sk_new_reserve(ossl_check_X509_compfunc_type(cmp), (n)))
+#define sk_X509_value(sk, idx) ((X509*)OPENSSL_sk_value(ossl_check_const_X509_sk_type(sk), (idx)))
+#define sk_X509_new(cmp) ((STACK_OF(X509)*)OPENSSL_sk_new(ossl_check_X509_compfunc_type(cmp)))
+#define sk_X509_new_null() ((STACK_OF(X509)*)OPENSSL_sk_new_null())
+#define sk_X509_new_reserve(cmp, n) ((STACK_OF(X509)*)OPENSSL_sk_new_reserve(ossl_check_X509_compfunc_type(cmp), (n)))
 #define sk_X509_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_sk_type(sk), (n))
 #define sk_X509_free(sk) OPENSSL_sk_free(ossl_check_X509_sk_type(sk))
 #define sk_X509_zero(sk) OPENSSL_sk_zero(ossl_check_X509_sk_type(sk))
-#define sk_X509_delete(sk, i) ((X509 *)OPENSSL_sk_delete(ossl_check_X509_sk_type(sk), (i)))
-#define sk_X509_delete_ptr(sk, ptr) ((X509 *)OPENSSL_sk_delete_ptr(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr)))
+#define sk_X509_delete(sk, i) ((X509*)OPENSSL_sk_delete(ossl_check_X509_sk_type(sk), (i)))
+#define sk_X509_delete_ptr(sk, ptr) ((X509*)OPENSSL_sk_delete_ptr(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr)))
 #define sk_X509_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
 #define sk_X509_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
-#define sk_X509_pop(sk) ((X509 *)OPENSSL_sk_pop(ossl_check_X509_sk_type(sk)))
-#define sk_X509_shift(sk) ((X509 *)OPENSSL_sk_shift(ossl_check_X509_sk_type(sk)))
-#define sk_X509_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_sk_type(sk),ossl_check_X509_freefunc_type(freefunc))
+#define sk_X509_pop(sk) ((X509*)OPENSSL_sk_pop(ossl_check_X509_sk_type(sk)))
+#define sk_X509_shift(sk) ((X509*)OPENSSL_sk_shift(ossl_check_X509_sk_type(sk)))
+#define sk_X509_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_sk_type(sk), ossl_check_X509_freefunc_type(freefunc))
 #define sk_X509_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr), (idx))
-#define sk_X509_set(sk, idx, ptr) ((X509 *)OPENSSL_sk_set(ossl_check_X509_sk_type(sk), (idx), ossl_check_X509_type(ptr)))
+#define sk_X509_set(sk, idx, ptr) ((X509*)OPENSSL_sk_set(ossl_check_X509_sk_type(sk), (idx), ossl_check_X509_type(ptr)))
 #define sk_X509_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
 #define sk_X509_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr))
 #define sk_X509_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_sk_type(sk), ossl_check_X509_type(ptr), pnum)
 #define sk_X509_sort(sk) OPENSSL_sk_sort(ossl_check_X509_sk_type(sk))
 #define sk_X509_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_sk_type(sk))
-#define sk_X509_dup(sk) ((STACK_OF(X509) *)OPENSSL_sk_dup(ossl_check_const_X509_sk_type(sk)))
-#define sk_X509_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_sk_type(sk), ossl_check_X509_copyfunc_type(copyfunc), ossl_check_X509_freefunc_type(freefunc)))
+#define sk_X509_dup(sk) ((STACK_OF(X509)*)OPENSSL_sk_dup(ossl_check_const_X509_sk_type(sk)))
+#define sk_X509_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_sk_type(sk), ossl_check_X509_copyfunc_type(copyfunc), ossl_check_X509_freefunc_type(freefunc)))
 #define sk_X509_set_cmp_func(sk, cmp) ((sk_X509_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_sk_type(sk), ossl_check_X509_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(X509_REVOKED, X509_REVOKED, X509_REVOKED)
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_REVOKED, X509_REVOKED, X509_REVOKED)
 #define sk_X509_REVOKED_num(sk) OPENSSL_sk_num(ossl_check_const_X509_REVOKED_sk_type(sk))
-#define sk_X509_REVOKED_value(sk, idx) ((X509_REVOKED *)OPENSSL_sk_value(ossl_check_const_X509_REVOKED_sk_type(sk), (idx)))
-#define sk_X509_REVOKED_new(cmp) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new(ossl_check_X509_REVOKED_compfunc_type(cmp)))
-#define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new_null())
-#define sk_X509_REVOKED_new_reserve(cmp, n) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_new_reserve(ossl_check_X509_REVOKED_compfunc_type(cmp), (n)))
+#define sk_X509_REVOKED_value(sk, idx) ((X509_REVOKED*)OPENSSL_sk_value(ossl_check_const_X509_REVOKED_sk_type(sk), (idx)))
+#define sk_X509_REVOKED_new(cmp) ((STACK_OF(X509_REVOKED)*)OPENSSL_sk_new(ossl_check_X509_REVOKED_compfunc_type(cmp)))
+#define sk_X509_REVOKED_new_null() ((STACK_OF(X509_REVOKED)*)OPENSSL_sk_new_null())
+#define sk_X509_REVOKED_new_reserve(cmp, n) ((STACK_OF(X509_REVOKED)*)OPENSSL_sk_new_reserve(ossl_check_X509_REVOKED_compfunc_type(cmp), (n)))
 #define sk_X509_REVOKED_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_REVOKED_sk_type(sk), (n))
 #define sk_X509_REVOKED_free(sk) OPENSSL_sk_free(ossl_check_X509_REVOKED_sk_type(sk))
 #define sk_X509_REVOKED_zero(sk) OPENSSL_sk_zero(ossl_check_X509_REVOKED_sk_type(sk))
-#define sk_X509_REVOKED_delete(sk, i) ((X509_REVOKED *)OPENSSL_sk_delete(ossl_check_X509_REVOKED_sk_type(sk), (i)))
-#define sk_X509_REVOKED_delete_ptr(sk, ptr) ((X509_REVOKED *)OPENSSL_sk_delete_ptr(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr)))
+#define sk_X509_REVOKED_delete(sk, i) ((X509_REVOKED*)OPENSSL_sk_delete(ossl_check_X509_REVOKED_sk_type(sk), (i)))
+#define sk_X509_REVOKED_delete_ptr(sk, ptr) ((X509_REVOKED*)OPENSSL_sk_delete_ptr(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr)))
 #define sk_X509_REVOKED_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
 #define sk_X509_REVOKED_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
-#define sk_X509_REVOKED_pop(sk) ((X509_REVOKED *)OPENSSL_sk_pop(ossl_check_X509_REVOKED_sk_type(sk)))
-#define sk_X509_REVOKED_shift(sk) ((X509_REVOKED *)OPENSSL_sk_shift(ossl_check_X509_REVOKED_sk_type(sk)))
-#define sk_X509_REVOKED_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_REVOKED_sk_type(sk),ossl_check_X509_REVOKED_freefunc_type(freefunc))
+#define sk_X509_REVOKED_pop(sk) ((X509_REVOKED*)OPENSSL_sk_pop(ossl_check_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_shift(sk) ((X509_REVOKED*)OPENSSL_sk_shift(ossl_check_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_freefunc_type(freefunc))
 #define sk_X509_REVOKED_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr), (idx))
-#define sk_X509_REVOKED_set(sk, idx, ptr) ((X509_REVOKED *)OPENSSL_sk_set(ossl_check_X509_REVOKED_sk_type(sk), (idx), ossl_check_X509_REVOKED_type(ptr)))
+#define sk_X509_REVOKED_set(sk, idx, ptr) ((X509_REVOKED*)OPENSSL_sk_set(ossl_check_X509_REVOKED_sk_type(sk), (idx), ossl_check_X509_REVOKED_type(ptr)))
 #define sk_X509_REVOKED_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
 #define sk_X509_REVOKED_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr))
 #define sk_X509_REVOKED_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_type(ptr), pnum)
 #define sk_X509_REVOKED_sort(sk) OPENSSL_sk_sort(ossl_check_X509_REVOKED_sk_type(sk))
 #define sk_X509_REVOKED_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_REVOKED_sk_type(sk))
-#define sk_X509_REVOKED_dup(sk) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_dup(ossl_check_const_X509_REVOKED_sk_type(sk)))
-#define sk_X509_REVOKED_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_REVOKED) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_copyfunc_type(copyfunc), ossl_check_X509_REVOKED_freefunc_type(freefunc)))
+#define sk_X509_REVOKED_dup(sk) ((STACK_OF(X509_REVOKED)*)OPENSSL_sk_dup(ossl_check_const_X509_REVOKED_sk_type(sk)))
+#define sk_X509_REVOKED_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_REVOKED)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_copyfunc_type(copyfunc), ossl_check_X509_REVOKED_freefunc_type(freefunc)))
 #define sk_X509_REVOKED_set_cmp_func(sk, cmp) ((sk_X509_REVOKED_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_REVOKED_sk_type(sk), ossl_check_X509_REVOKED_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(X509_CRL, X509_CRL, X509_CRL)
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_CRL, X509_CRL, X509_CRL)
 #define sk_X509_CRL_num(sk) OPENSSL_sk_num(ossl_check_const_X509_CRL_sk_type(sk))
-#define sk_X509_CRL_value(sk, idx) ((X509_CRL *)OPENSSL_sk_value(ossl_check_const_X509_CRL_sk_type(sk), (idx)))
-#define sk_X509_CRL_new(cmp) ((STACK_OF(X509_CRL) *)OPENSSL_sk_new(ossl_check_X509_CRL_compfunc_type(cmp)))
-#define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL) *)OPENSSL_sk_new_null())
-#define sk_X509_CRL_new_reserve(cmp, n) ((STACK_OF(X509_CRL) *)OPENSSL_sk_new_reserve(ossl_check_X509_CRL_compfunc_type(cmp), (n)))
+#define sk_X509_CRL_value(sk, idx) ((X509_CRL*)OPENSSL_sk_value(ossl_check_const_X509_CRL_sk_type(sk), (idx)))
+#define sk_X509_CRL_new(cmp) ((STACK_OF(X509_CRL)*)OPENSSL_sk_new(ossl_check_X509_CRL_compfunc_type(cmp)))
+#define sk_X509_CRL_new_null() ((STACK_OF(X509_CRL)*)OPENSSL_sk_new_null())
+#define sk_X509_CRL_new_reserve(cmp, n) ((STACK_OF(X509_CRL)*)OPENSSL_sk_new_reserve(ossl_check_X509_CRL_compfunc_type(cmp), (n)))
 #define sk_X509_CRL_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_CRL_sk_type(sk), (n))
 #define sk_X509_CRL_free(sk) OPENSSL_sk_free(ossl_check_X509_CRL_sk_type(sk))
 #define sk_X509_CRL_zero(sk) OPENSSL_sk_zero(ossl_check_X509_CRL_sk_type(sk))
-#define sk_X509_CRL_delete(sk, i) ((X509_CRL *)OPENSSL_sk_delete(ossl_check_X509_CRL_sk_type(sk), (i)))
-#define sk_X509_CRL_delete_ptr(sk, ptr) ((X509_CRL *)OPENSSL_sk_delete_ptr(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr)))
+#define sk_X509_CRL_delete(sk, i) ((X509_CRL*)OPENSSL_sk_delete(ossl_check_X509_CRL_sk_type(sk), (i)))
+#define sk_X509_CRL_delete_ptr(sk, ptr) ((X509_CRL*)OPENSSL_sk_delete_ptr(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr)))
 #define sk_X509_CRL_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
 #define sk_X509_CRL_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
-#define sk_X509_CRL_pop(sk) ((X509_CRL *)OPENSSL_sk_pop(ossl_check_X509_CRL_sk_type(sk)))
-#define sk_X509_CRL_shift(sk) ((X509_CRL *)OPENSSL_sk_shift(ossl_check_X509_CRL_sk_type(sk)))
-#define sk_X509_CRL_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_CRL_sk_type(sk),ossl_check_X509_CRL_freefunc_type(freefunc))
+#define sk_X509_CRL_pop(sk) ((X509_CRL*)OPENSSL_sk_pop(ossl_check_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_shift(sk) ((X509_CRL*)OPENSSL_sk_shift(ossl_check_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_freefunc_type(freefunc))
 #define sk_X509_CRL_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr), (idx))
-#define sk_X509_CRL_set(sk, idx, ptr) ((X509_CRL *)OPENSSL_sk_set(ossl_check_X509_CRL_sk_type(sk), (idx), ossl_check_X509_CRL_type(ptr)))
+#define sk_X509_CRL_set(sk, idx, ptr) ((X509_CRL*)OPENSSL_sk_set(ossl_check_X509_CRL_sk_type(sk), (idx), ossl_check_X509_CRL_type(ptr)))
 #define sk_X509_CRL_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
 #define sk_X509_CRL_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr))
 #define sk_X509_CRL_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_type(ptr), pnum)
 #define sk_X509_CRL_sort(sk) OPENSSL_sk_sort(ossl_check_X509_CRL_sk_type(sk))
 #define sk_X509_CRL_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_CRL_sk_type(sk))
-#define sk_X509_CRL_dup(sk) ((STACK_OF(X509_CRL) *)OPENSSL_sk_dup(ossl_check_const_X509_CRL_sk_type(sk)))
-#define sk_X509_CRL_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_CRL) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_CRL_sk_type(sk), ossl_check_X509_CRL_copyfunc_type(copyfunc), ossl_check_X509_CRL_freefunc_type(freefunc)))
+#define sk_X509_CRL_dup(sk) ((STACK_OF(X509_CRL)*)OPENSSL_sk_dup(ossl_check_const_X509_CRL_sk_type(sk)))
+#define sk_X509_CRL_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_CRL)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_CRL_sk_type(sk), ossl_check_X509_CRL_copyfunc_type(copyfunc), ossl_check_X509_CRL_freefunc_type(freefunc)))
 #define sk_X509_CRL_set_cmp_func(sk, cmp) ((sk_X509_CRL_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_CRL_sk_type(sk), ossl_check_X509_CRL_compfunc_type(cmp)))
 
-
 /* Flags for X509_get_signature_info() */
 /* Signature info is valid */
-# define X509_SIG_INFO_VALID     0x1
+#define X509_SIG_INFO_VALID 0x1
 /* Signature is suitable for TLS use */
-# define X509_SIG_INFO_TLS       0x2
-
-# define X509_FILETYPE_PEM       1
-# define X509_FILETYPE_ASN1      2
-# define X509_FILETYPE_DEFAULT   3
-
-# define X509v3_KU_DIGITAL_SIGNATURE     0x0080
-# define X509v3_KU_NON_REPUDIATION       0x0040
-# define X509v3_KU_KEY_ENCIPHERMENT      0x0020
-# define X509v3_KU_DATA_ENCIPHERMENT     0x0010
-# define X509v3_KU_KEY_AGREEMENT         0x0008
-# define X509v3_KU_KEY_CERT_SIGN         0x0004
-# define X509v3_KU_CRL_SIGN              0x0002
-# define X509v3_KU_ENCIPHER_ONLY         0x0001
-# define X509v3_KU_DECIPHER_ONLY         0x8000
-# define X509v3_KU_UNDEF                 0xffff
-
-struct X509_algor_st {
-    ASN1_OBJECT *algorithm;
-    ASN1_TYPE *parameter;
-} /* X509_ALGOR */ ;
-
-typedef STACK_OF(X509_ALGOR) X509_ALGORS;
-
-typedef struct X509_val_st {
-    ASN1_TIME *notBefore;
-    ASN1_TIME *notAfter;
-} X509_VAL;
-
-typedef struct X509_sig_st X509_SIG;
-
-typedef struct X509_name_entry_st X509_NAME_ENTRY;
-
-SKM_DEFINE_STACK_OF_INTERNAL(X509_NAME_ENTRY, X509_NAME_ENTRY, X509_NAME_ENTRY)
+#define X509_SIG_INFO_TLS 0x2
+
+#define X509_FILETYPE_PEM 1
+#define X509_FILETYPE_ASN1 2
+#define X509_FILETYPE_DEFAULT 3
+
+#define X509v3_KU_DIGITAL_SIGNATURE 0x0080
+#define X509v3_KU_NON_REPUDIATION 0x0040
+#define X509v3_KU_KEY_ENCIPHERMENT 0x0020
+#define X509v3_KU_DATA_ENCIPHERMENT 0x0010
+#define X509v3_KU_KEY_AGREEMENT 0x0008
+#define X509v3_KU_KEY_CERT_SIGN 0x0004
+#define X509v3_KU_CRL_SIGN 0x0002
+#define X509v3_KU_ENCIPHER_ONLY 0x0001
+#define X509v3_KU_DECIPHER_ONLY 0x8000
+#define X509v3_KU_UNDEF 0xffff
+
+    struct X509_algor_st
+    {
+        ASN1_OBJECT* algorithm;
+        ASN1_TYPE* parameter;
+    } /* X509_ALGOR */;
+
+    typedef STACK_OF(X509_ALGOR) X509_ALGORS;
+
+    typedef struct X509_val_st
+    {
+        ASN1_TIME* notBefore;
+        ASN1_TIME* notAfter;
+    } X509_VAL;
+
+    typedef struct X509_sig_st X509_SIG;
+
+    typedef struct X509_name_entry_st X509_NAME_ENTRY;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_NAME_ENTRY, X509_NAME_ENTRY, X509_NAME_ENTRY)
 #define sk_X509_NAME_ENTRY_num(sk) OPENSSL_sk_num(ossl_check_const_X509_NAME_ENTRY_sk_type(sk))
-#define sk_X509_NAME_ENTRY_value(sk, idx) ((X509_NAME_ENTRY *)OPENSSL_sk_value(ossl_check_const_X509_NAME_ENTRY_sk_type(sk), (idx)))
-#define sk_X509_NAME_ENTRY_new(cmp) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new(ossl_check_X509_NAME_ENTRY_compfunc_type(cmp)))
-#define sk_X509_NAME_ENTRY_new_null() ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new_null())
-#define sk_X509_NAME_ENTRY_new_reserve(cmp, n) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_new_reserve(ossl_check_X509_NAME_ENTRY_compfunc_type(cmp), (n)))
+#define sk_X509_NAME_ENTRY_value(sk, idx) ((X509_NAME_ENTRY*)OPENSSL_sk_value(ossl_check_const_X509_NAME_ENTRY_sk_type(sk), (idx)))
+#define sk_X509_NAME_ENTRY_new(cmp) ((STACK_OF(X509_NAME_ENTRY)*)OPENSSL_sk_new(ossl_check_X509_NAME_ENTRY_compfunc_type(cmp)))
+#define sk_X509_NAME_ENTRY_new_null() ((STACK_OF(X509_NAME_ENTRY)*)OPENSSL_sk_new_null())
+#define sk_X509_NAME_ENTRY_new_reserve(cmp, n) ((STACK_OF(X509_NAME_ENTRY)*)OPENSSL_sk_new_reserve(ossl_check_X509_NAME_ENTRY_compfunc_type(cmp), (n)))
 #define sk_X509_NAME_ENTRY_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_NAME_ENTRY_sk_type(sk), (n))
 #define sk_X509_NAME_ENTRY_free(sk) OPENSSL_sk_free(ossl_check_X509_NAME_ENTRY_sk_type(sk))
 #define sk_X509_NAME_ENTRY_zero(sk) OPENSSL_sk_zero(ossl_check_X509_NAME_ENTRY_sk_type(sk))
-#define sk_X509_NAME_ENTRY_delete(sk, i) ((X509_NAME_ENTRY *)OPENSSL_sk_delete(ossl_check_X509_NAME_ENTRY_sk_type(sk), (i)))
-#define sk_X509_NAME_ENTRY_delete_ptr(sk, ptr) ((X509_NAME_ENTRY *)OPENSSL_sk_delete_ptr(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr)))
+#define sk_X509_NAME_ENTRY_delete(sk, i) ((X509_NAME_ENTRY*)OPENSSL_sk_delete(ossl_check_X509_NAME_ENTRY_sk_type(sk), (i)))
+#define sk_X509_NAME_ENTRY_delete_ptr(sk, ptr) ((X509_NAME_ENTRY*)OPENSSL_sk_delete_ptr(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr)))
 #define sk_X509_NAME_ENTRY_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
 #define sk_X509_NAME_ENTRY_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
-#define sk_X509_NAME_ENTRY_pop(sk) ((X509_NAME_ENTRY *)OPENSSL_sk_pop(ossl_check_X509_NAME_ENTRY_sk_type(sk)))
-#define sk_X509_NAME_ENTRY_shift(sk) ((X509_NAME_ENTRY *)OPENSSL_sk_shift(ossl_check_X509_NAME_ENTRY_sk_type(sk)))
-#define sk_X509_NAME_ENTRY_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_NAME_ENTRY_sk_type(sk),ossl_check_X509_NAME_ENTRY_freefunc_type(freefunc))
+#define sk_X509_NAME_ENTRY_pop(sk) ((X509_NAME_ENTRY*)OPENSSL_sk_pop(ossl_check_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_shift(sk) ((X509_NAME_ENTRY*)OPENSSL_sk_shift(ossl_check_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_freefunc_type(freefunc))
 #define sk_X509_NAME_ENTRY_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr), (idx))
-#define sk_X509_NAME_ENTRY_set(sk, idx, ptr) ((X509_NAME_ENTRY *)OPENSSL_sk_set(ossl_check_X509_NAME_ENTRY_sk_type(sk), (idx), ossl_check_X509_NAME_ENTRY_type(ptr)))
+#define sk_X509_NAME_ENTRY_set(sk, idx, ptr) ((X509_NAME_ENTRY*)OPENSSL_sk_set(ossl_check_X509_NAME_ENTRY_sk_type(sk), (idx), ossl_check_X509_NAME_ENTRY_type(ptr)))
 #define sk_X509_NAME_ENTRY_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
 #define sk_X509_NAME_ENTRY_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr))
 #define sk_X509_NAME_ENTRY_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_type(ptr), pnum)
 #define sk_X509_NAME_ENTRY_sort(sk) OPENSSL_sk_sort(ossl_check_X509_NAME_ENTRY_sk_type(sk))
 #define sk_X509_NAME_ENTRY_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_NAME_ENTRY_sk_type(sk))
-#define sk_X509_NAME_ENTRY_dup(sk) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_dup(ossl_check_const_X509_NAME_ENTRY_sk_type(sk)))
-#define sk_X509_NAME_ENTRY_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_NAME_ENTRY) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_copyfunc_type(copyfunc), ossl_check_X509_NAME_ENTRY_freefunc_type(freefunc)))
+#define sk_X509_NAME_ENTRY_dup(sk) ((STACK_OF(X509_NAME_ENTRY)*)OPENSSL_sk_dup(ossl_check_const_X509_NAME_ENTRY_sk_type(sk)))
+#define sk_X509_NAME_ENTRY_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_NAME_ENTRY)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_copyfunc_type(copyfunc), ossl_check_X509_NAME_ENTRY_freefunc_type(freefunc)))
 #define sk_X509_NAME_ENTRY_set_cmp_func(sk, cmp) ((sk_X509_NAME_ENTRY_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_NAME_ENTRY_sk_type(sk), ossl_check_X509_NAME_ENTRY_compfunc_type(cmp)))
 
-
-# define X509_EX_V_NETSCAPE_HACK         0x8000
-# define X509_EX_V_INIT                  0x0001
-typedef struct X509_extension_st X509_EXTENSION;
-SKM_DEFINE_STACK_OF_INTERNAL(X509_EXTENSION, X509_EXTENSION, X509_EXTENSION)
+#define X509_EX_V_NETSCAPE_HACK 0x8000
+#define X509_EX_V_INIT 0x0001
+    typedef struct X509_extension_st X509_EXTENSION;
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_EXTENSION, X509_EXTENSION, X509_EXTENSION)
 #define sk_X509_EXTENSION_num(sk) OPENSSL_sk_num(ossl_check_const_X509_EXTENSION_sk_type(sk))
-#define sk_X509_EXTENSION_value(sk, idx) ((X509_EXTENSION *)OPENSSL_sk_value(ossl_check_const_X509_EXTENSION_sk_type(sk), (idx)))
-#define sk_X509_EXTENSION_new(cmp) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new(ossl_check_X509_EXTENSION_compfunc_type(cmp)))
-#define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new_null())
-#define sk_X509_EXTENSION_new_reserve(cmp, n) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_new_reserve(ossl_check_X509_EXTENSION_compfunc_type(cmp), (n)))
+#define sk_X509_EXTENSION_value(sk, idx) ((X509_EXTENSION*)OPENSSL_sk_value(ossl_check_const_X509_EXTENSION_sk_type(sk), (idx)))
+#define sk_X509_EXTENSION_new(cmp) ((STACK_OF(X509_EXTENSION)*)OPENSSL_sk_new(ossl_check_X509_EXTENSION_compfunc_type(cmp)))
+#define sk_X509_EXTENSION_new_null() ((STACK_OF(X509_EXTENSION)*)OPENSSL_sk_new_null())
+#define sk_X509_EXTENSION_new_reserve(cmp, n) ((STACK_OF(X509_EXTENSION)*)OPENSSL_sk_new_reserve(ossl_check_X509_EXTENSION_compfunc_type(cmp), (n)))
 #define sk_X509_EXTENSION_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_EXTENSION_sk_type(sk), (n))
 #define sk_X509_EXTENSION_free(sk) OPENSSL_sk_free(ossl_check_X509_EXTENSION_sk_type(sk))
 #define sk_X509_EXTENSION_zero(sk) OPENSSL_sk_zero(ossl_check_X509_EXTENSION_sk_type(sk))
-#define sk_X509_EXTENSION_delete(sk, i) ((X509_EXTENSION *)OPENSSL_sk_delete(ossl_check_X509_EXTENSION_sk_type(sk), (i)))
-#define sk_X509_EXTENSION_delete_ptr(sk, ptr) ((X509_EXTENSION *)OPENSSL_sk_delete_ptr(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr)))
+#define sk_X509_EXTENSION_delete(sk, i) ((X509_EXTENSION*)OPENSSL_sk_delete(ossl_check_X509_EXTENSION_sk_type(sk), (i)))
+#define sk_X509_EXTENSION_delete_ptr(sk, ptr) ((X509_EXTENSION*)OPENSSL_sk_delete_ptr(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr)))
 #define sk_X509_EXTENSION_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
 #define sk_X509_EXTENSION_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
-#define sk_X509_EXTENSION_pop(sk) ((X509_EXTENSION *)OPENSSL_sk_pop(ossl_check_X509_EXTENSION_sk_type(sk)))
-#define sk_X509_EXTENSION_shift(sk) ((X509_EXTENSION *)OPENSSL_sk_shift(ossl_check_X509_EXTENSION_sk_type(sk)))
-#define sk_X509_EXTENSION_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_EXTENSION_sk_type(sk),ossl_check_X509_EXTENSION_freefunc_type(freefunc))
+#define sk_X509_EXTENSION_pop(sk) ((X509_EXTENSION*)OPENSSL_sk_pop(ossl_check_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_shift(sk) ((X509_EXTENSION*)OPENSSL_sk_shift(ossl_check_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_freefunc_type(freefunc))
 #define sk_X509_EXTENSION_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr), (idx))
-#define sk_X509_EXTENSION_set(sk, idx, ptr) ((X509_EXTENSION *)OPENSSL_sk_set(ossl_check_X509_EXTENSION_sk_type(sk), (idx), ossl_check_X509_EXTENSION_type(ptr)))
+#define sk_X509_EXTENSION_set(sk, idx, ptr) ((X509_EXTENSION*)OPENSSL_sk_set(ossl_check_X509_EXTENSION_sk_type(sk), (idx), ossl_check_X509_EXTENSION_type(ptr)))
 #define sk_X509_EXTENSION_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
 #define sk_X509_EXTENSION_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr))
 #define sk_X509_EXTENSION_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_type(ptr), pnum)
 #define sk_X509_EXTENSION_sort(sk) OPENSSL_sk_sort(ossl_check_X509_EXTENSION_sk_type(sk))
 #define sk_X509_EXTENSION_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_EXTENSION_sk_type(sk))
-#define sk_X509_EXTENSION_dup(sk) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_dup(ossl_check_const_X509_EXTENSION_sk_type(sk)))
-#define sk_X509_EXTENSION_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_EXTENSION) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_copyfunc_type(copyfunc), ossl_check_X509_EXTENSION_freefunc_type(freefunc)))
+#define sk_X509_EXTENSION_dup(sk) ((STACK_OF(X509_EXTENSION)*)OPENSSL_sk_dup(ossl_check_const_X509_EXTENSION_sk_type(sk)))
+#define sk_X509_EXTENSION_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_EXTENSION)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_copyfunc_type(copyfunc), ossl_check_X509_EXTENSION_freefunc_type(freefunc)))
 #define sk_X509_EXTENSION_set_cmp_func(sk, cmp) ((sk_X509_EXTENSION_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_EXTENSION_sk_type(sk), ossl_check_X509_EXTENSION_compfunc_type(cmp)))
 
-typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS;
-typedef struct x509_attributes_st X509_ATTRIBUTE;
-SKM_DEFINE_STACK_OF_INTERNAL(X509_ATTRIBUTE, X509_ATTRIBUTE, X509_ATTRIBUTE)
+    typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS;
+    typedef struct x509_attributes_st X509_ATTRIBUTE;
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_ATTRIBUTE, X509_ATTRIBUTE, X509_ATTRIBUTE)
 #define sk_X509_ATTRIBUTE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_ATTRIBUTE_sk_type(sk))
-#define sk_X509_ATTRIBUTE_value(sk, idx) ((X509_ATTRIBUTE *)OPENSSL_sk_value(ossl_check_const_X509_ATTRIBUTE_sk_type(sk), (idx)))
-#define sk_X509_ATTRIBUTE_new(cmp) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new(ossl_check_X509_ATTRIBUTE_compfunc_type(cmp)))
-#define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new_null())
-#define sk_X509_ATTRIBUTE_new_reserve(cmp, n) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_new_reserve(ossl_check_X509_ATTRIBUTE_compfunc_type(cmp), (n)))
+#define sk_X509_ATTRIBUTE_value(sk, idx) ((X509_ATTRIBUTE*)OPENSSL_sk_value(ossl_check_const_X509_ATTRIBUTE_sk_type(sk), (idx)))
+#define sk_X509_ATTRIBUTE_new(cmp) ((STACK_OF(X509_ATTRIBUTE)*)OPENSSL_sk_new(ossl_check_X509_ATTRIBUTE_compfunc_type(cmp)))
+#define sk_X509_ATTRIBUTE_new_null() ((STACK_OF(X509_ATTRIBUTE)*)OPENSSL_sk_new_null())
+#define sk_X509_ATTRIBUTE_new_reserve(cmp, n) ((STACK_OF(X509_ATTRIBUTE)*)OPENSSL_sk_new_reserve(ossl_check_X509_ATTRIBUTE_compfunc_type(cmp), (n)))
 #define sk_X509_ATTRIBUTE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_ATTRIBUTE_sk_type(sk), (n))
 #define sk_X509_ATTRIBUTE_free(sk) OPENSSL_sk_free(ossl_check_X509_ATTRIBUTE_sk_type(sk))
 #define sk_X509_ATTRIBUTE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_ATTRIBUTE_sk_type(sk))
-#define sk_X509_ATTRIBUTE_delete(sk, i) ((X509_ATTRIBUTE *)OPENSSL_sk_delete(ossl_check_X509_ATTRIBUTE_sk_type(sk), (i)))
-#define sk_X509_ATTRIBUTE_delete_ptr(sk, ptr) ((X509_ATTRIBUTE *)OPENSSL_sk_delete_ptr(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr)))
+#define sk_X509_ATTRIBUTE_delete(sk, i) ((X509_ATTRIBUTE*)OPENSSL_sk_delete(ossl_check_X509_ATTRIBUTE_sk_type(sk), (i)))
+#define sk_X509_ATTRIBUTE_delete_ptr(sk, ptr) ((X509_ATTRIBUTE*)OPENSSL_sk_delete_ptr(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr)))
 #define sk_X509_ATTRIBUTE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
 #define sk_X509_ATTRIBUTE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
-#define sk_X509_ATTRIBUTE_pop(sk) ((X509_ATTRIBUTE *)OPENSSL_sk_pop(ossl_check_X509_ATTRIBUTE_sk_type(sk)))
-#define sk_X509_ATTRIBUTE_shift(sk) ((X509_ATTRIBUTE *)OPENSSL_sk_shift(ossl_check_X509_ATTRIBUTE_sk_type(sk)))
-#define sk_X509_ATTRIBUTE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ATTRIBUTE_sk_type(sk),ossl_check_X509_ATTRIBUTE_freefunc_type(freefunc))
+#define sk_X509_ATTRIBUTE_pop(sk) ((X509_ATTRIBUTE*)OPENSSL_sk_pop(ossl_check_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_shift(sk) ((X509_ATTRIBUTE*)OPENSSL_sk_shift(ossl_check_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_freefunc_type(freefunc))
 #define sk_X509_ATTRIBUTE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr), (idx))
-#define sk_X509_ATTRIBUTE_set(sk, idx, ptr) ((X509_ATTRIBUTE *)OPENSSL_sk_set(ossl_check_X509_ATTRIBUTE_sk_type(sk), (idx), ossl_check_X509_ATTRIBUTE_type(ptr)))
+#define sk_X509_ATTRIBUTE_set(sk, idx, ptr) ((X509_ATTRIBUTE*)OPENSSL_sk_set(ossl_check_X509_ATTRIBUTE_sk_type(sk), (idx), ossl_check_X509_ATTRIBUTE_type(ptr)))
 #define sk_X509_ATTRIBUTE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
 #define sk_X509_ATTRIBUTE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr))
 #define sk_X509_ATTRIBUTE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_type(ptr), pnum)
 #define sk_X509_ATTRIBUTE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_ATTRIBUTE_sk_type(sk))
 #define sk_X509_ATTRIBUTE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_ATTRIBUTE_sk_type(sk))
-#define sk_X509_ATTRIBUTE_dup(sk) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_dup(ossl_check_const_X509_ATTRIBUTE_sk_type(sk)))
-#define sk_X509_ATTRIBUTE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ATTRIBUTE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_copyfunc_type(copyfunc), ossl_check_X509_ATTRIBUTE_freefunc_type(freefunc)))
+#define sk_X509_ATTRIBUTE_dup(sk) ((STACK_OF(X509_ATTRIBUTE)*)OPENSSL_sk_dup(ossl_check_const_X509_ATTRIBUTE_sk_type(sk)))
+#define sk_X509_ATTRIBUTE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ATTRIBUTE)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_copyfunc_type(copyfunc), ossl_check_X509_ATTRIBUTE_freefunc_type(freefunc)))
 #define sk_X509_ATTRIBUTE_set_cmp_func(sk, cmp) ((sk_X509_ATTRIBUTE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_ATTRIBUTE_sk_type(sk), ossl_check_X509_ATTRIBUTE_compfunc_type(cmp)))
 
-typedef struct X509_req_info_st X509_REQ_INFO;
-typedef struct X509_req_st X509_REQ;
-typedef struct x509_cert_aux_st X509_CERT_AUX;
-typedef struct x509_cinf_st X509_CINF;
+    typedef struct X509_req_info_st X509_REQ_INFO;
+    typedef struct X509_req_st X509_REQ;
+    typedef struct x509_cert_aux_st X509_CERT_AUX;
+    typedef struct x509_cinf_st X509_CINF;
 
-/* Flags for X509_print_ex() */
+    /* Flags for X509_print_ex() */
 
-# define X509_FLAG_COMPAT                0
-# define X509_FLAG_NO_HEADER             1L
-# define X509_FLAG_NO_VERSION            (1L << 1)
-# define X509_FLAG_NO_SERIAL             (1L << 2)
-# define X509_FLAG_NO_SIGNAME            (1L << 3)
-# define X509_FLAG_NO_ISSUER             (1L << 4)
-# define X509_FLAG_NO_VALIDITY           (1L << 5)
-# define X509_FLAG_NO_SUBJECT            (1L << 6)
-# define X509_FLAG_NO_PUBKEY             (1L << 7)
-# define X509_FLAG_NO_EXTENSIONS         (1L << 8)
-# define X509_FLAG_NO_SIGDUMP            (1L << 9)
-# define X509_FLAG_NO_AUX                (1L << 10)
-# define X509_FLAG_NO_ATTRIBUTES         (1L << 11)
-# define X509_FLAG_NO_IDS                (1L << 12)
-# define X509_FLAG_EXTENSIONS_ONLY_KID   (1L << 13)
+#define X509_FLAG_COMPAT 0
+#define X509_FLAG_NO_HEADER 1L
+#define X509_FLAG_NO_VERSION (1L << 1)
+#define X509_FLAG_NO_SERIAL (1L << 2)
+#define X509_FLAG_NO_SIGNAME (1L << 3)
+#define X509_FLAG_NO_ISSUER (1L << 4)
+#define X509_FLAG_NO_VALIDITY (1L << 5)
+#define X509_FLAG_NO_SUBJECT (1L << 6)
+#define X509_FLAG_NO_PUBKEY (1L << 7)
+#define X509_FLAG_NO_EXTENSIONS (1L << 8)
+#define X509_FLAG_NO_SIGDUMP (1L << 9)
+#define X509_FLAG_NO_AUX (1L << 10)
+#define X509_FLAG_NO_ATTRIBUTES (1L << 11)
+#define X509_FLAG_NO_IDS (1L << 12)
+#define X509_FLAG_EXTENSIONS_ONLY_KID (1L << 13)
 
-/* Flags specific to X509_NAME_print_ex() */
+    /* Flags specific to X509_NAME_print_ex() */
 
-/* The field separator information */
+    /* The field separator information */
 
-# define XN_FLAG_SEP_MASK        (0xf << 16)
+#define XN_FLAG_SEP_MASK (0xf << 16)
 
-# define XN_FLAG_COMPAT          0/* Traditional; use old X509_NAME_print */
-# define XN_FLAG_SEP_COMMA_PLUS  (1 << 16)/* RFC2253 ,+ */
-# define XN_FLAG_SEP_CPLUS_SPC   (2 << 16)/* ,+ spaced: more readable */
-# define XN_FLAG_SEP_SPLUS_SPC   (3 << 16)/* ;+ spaced */
-# define XN_FLAG_SEP_MULTILINE   (4 << 16)/* One line per field */
+#define XN_FLAG_COMPAT 0                 /* Traditional; use old X509_NAME_print */
+#define XN_FLAG_SEP_COMMA_PLUS (1 << 16) /* RFC2253 ,+ */
+#define XN_FLAG_SEP_CPLUS_SPC (2 << 16)  /* ,+ spaced: more readable */
+#define XN_FLAG_SEP_SPLUS_SPC (3 << 16)  /* ;+ spaced */
+#define XN_FLAG_SEP_MULTILINE (4 << 16)  /* One line per field */
 
-# define XN_FLAG_DN_REV          (1 << 20)/* Reverse DN order */
+#define XN_FLAG_DN_REV (1 << 20) /* Reverse DN order */
 
-/* How the field name is shown */
+    /* How the field name is shown */
 
-# define XN_FLAG_FN_MASK         (0x3 << 21)
+#define XN_FLAG_FN_MASK (0x3 << 21)
 
-# define XN_FLAG_FN_SN           0/* Object short name */
-# define XN_FLAG_FN_LN           (1 << 21)/* Object long name */
-# define XN_FLAG_FN_OID          (2 << 21)/* Always use OIDs */
-# define XN_FLAG_FN_NONE         (3 << 21)/* No field names */
+#define XN_FLAG_FN_SN 0           /* Object short name */
+#define XN_FLAG_FN_LN (1 << 21)   /* Object long name */
+#define XN_FLAG_FN_OID (2 << 21)  /* Always use OIDs */
+#define XN_FLAG_FN_NONE (3 << 21) /* No field names */
 
-# define XN_FLAG_SPC_EQ          (1 << 23)/* Put spaces round '=' */
+#define XN_FLAG_SPC_EQ (1 << 23) /* Put spaces round '=' */
 
-/*
- * This determines if we dump fields we don't recognise: RFC2253 requires
- * this.
- */
+    /*
+     * This determines if we dump fields we don't recognise: RFC2253 requires
+     * this.
+     */
+
+#define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24)
+
+#define XN_FLAG_FN_ALIGN (1 << 25) /* Align field names to 20 \
+                                    * characters */
+
+    /* Complete set of RFC2253 flags */
+
+#define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | XN_FLAG_SEP_COMMA_PLUS | XN_FLAG_DN_REV | XN_FLAG_FN_SN | XN_FLAG_DUMP_UNKNOWN_FIELDS)
+
+    /* readable oneline form */
+
+#define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | ASN1_STRFLGS_ESC_QUOTE | XN_FLAG_SEP_CPLUS_SPC | XN_FLAG_SPC_EQ | XN_FLAG_FN_SN)
+
+    /* readable multiline form */
 
-# define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24)
-
-# define XN_FLAG_FN_ALIGN        (1 << 25)/* Align field names to 20
-                                           * characters */
-
-/* Complete set of RFC2253 flags */
-
-# define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | \
-                        XN_FLAG_SEP_COMMA_PLUS | \
-                        XN_FLAG_DN_REV | \
-                        XN_FLAG_FN_SN | \
-                        XN_FLAG_DUMP_UNKNOWN_FIELDS)
-
-/* readable oneline form */
-
-# define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | \
-                        ASN1_STRFLGS_ESC_QUOTE | \
-                        XN_FLAG_SEP_CPLUS_SPC | \
-                        XN_FLAG_SPC_EQ | \
-                        XN_FLAG_FN_SN)
-
-/* readable multiline form */
-
-# define XN_FLAG_MULTILINE (ASN1_STRFLGS_ESC_CTRL | \
-                        ASN1_STRFLGS_ESC_MSB | \
-                        XN_FLAG_SEP_MULTILINE | \
-                        XN_FLAG_SPC_EQ | \
-                        XN_FLAG_FN_LN | \
-                        XN_FLAG_FN_ALIGN)
-
-typedef struct X509_crl_info_st X509_CRL_INFO;
-
-typedef struct private_key_st {
-    int version;
-    /* The PKCS#8 data types */
-    X509_ALGOR *enc_algor;
-    ASN1_OCTET_STRING *enc_pkey; /* encrypted pub key */
-    /* When decrypted, the following will not be NULL */
-    EVP_PKEY *dec_pkey;
-    /* used to encrypt and decrypt */
-    int key_length;
-    char *key_data;
-    int key_free;               /* true if we should auto free key_data */
-    /* expanded version of 'enc_algor' */
-    EVP_CIPHER_INFO cipher;
-} X509_PKEY;
-
-typedef struct X509_info_st {
-    X509 *x509;
-    X509_CRL *crl;
-    X509_PKEY *x_pkey;
-    EVP_CIPHER_INFO enc_cipher;
-    int enc_len;
-    char *enc_data;
-} X509_INFO;
-SKM_DEFINE_STACK_OF_INTERNAL(X509_INFO, X509_INFO, X509_INFO)
+#define XN_FLAG_MULTILINE (ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | XN_FLAG_SEP_MULTILINE | XN_FLAG_SPC_EQ | XN_FLAG_FN_LN | XN_FLAG_FN_ALIGN)
+
+    typedef struct X509_crl_info_st X509_CRL_INFO;
+
+    typedef struct private_key_st
+    {
+        int version;
+        /* The PKCS#8 data types */
+        X509_ALGOR* enc_algor;
+        ASN1_OCTET_STRING* enc_pkey; /* encrypted pub key */
+        /* When decrypted, the following will not be NULL */
+        EVP_PKEY* dec_pkey;
+        /* used to encrypt and decrypt */
+        int key_length;
+        char* key_data;
+        int key_free; /* true if we should auto free key_data */
+        /* expanded version of 'enc_algor' */
+        EVP_CIPHER_INFO cipher;
+    } X509_PKEY;
+
+    typedef struct X509_info_st
+    {
+        X509* x509;
+        X509_CRL* crl;
+        X509_PKEY* x_pkey;
+        EVP_CIPHER_INFO enc_cipher;
+        int enc_len;
+        char* enc_data;
+    } X509_INFO;
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_INFO, X509_INFO, X509_INFO)
 #define sk_X509_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_X509_INFO_sk_type(sk))
-#define sk_X509_INFO_value(sk, idx) ((X509_INFO *)OPENSSL_sk_value(ossl_check_const_X509_INFO_sk_type(sk), (idx)))
-#define sk_X509_INFO_new(cmp) ((STACK_OF(X509_INFO) *)OPENSSL_sk_new(ossl_check_X509_INFO_compfunc_type(cmp)))
-#define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO) *)OPENSSL_sk_new_null())
-#define sk_X509_INFO_new_reserve(cmp, n) ((STACK_OF(X509_INFO) *)OPENSSL_sk_new_reserve(ossl_check_X509_INFO_compfunc_type(cmp), (n)))
+#define sk_X509_INFO_value(sk, idx) ((X509_INFO*)OPENSSL_sk_value(ossl_check_const_X509_INFO_sk_type(sk), (idx)))
+#define sk_X509_INFO_new(cmp) ((STACK_OF(X509_INFO)*)OPENSSL_sk_new(ossl_check_X509_INFO_compfunc_type(cmp)))
+#define sk_X509_INFO_new_null() ((STACK_OF(X509_INFO)*)OPENSSL_sk_new_null())
+#define sk_X509_INFO_new_reserve(cmp, n) ((STACK_OF(X509_INFO)*)OPENSSL_sk_new_reserve(ossl_check_X509_INFO_compfunc_type(cmp), (n)))
 #define sk_X509_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_INFO_sk_type(sk), (n))
 #define sk_X509_INFO_free(sk) OPENSSL_sk_free(ossl_check_X509_INFO_sk_type(sk))
 #define sk_X509_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_X509_INFO_sk_type(sk))
-#define sk_X509_INFO_delete(sk, i) ((X509_INFO *)OPENSSL_sk_delete(ossl_check_X509_INFO_sk_type(sk), (i)))
-#define sk_X509_INFO_delete_ptr(sk, ptr) ((X509_INFO *)OPENSSL_sk_delete_ptr(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr)))
+#define sk_X509_INFO_delete(sk, i) ((X509_INFO*)OPENSSL_sk_delete(ossl_check_X509_INFO_sk_type(sk), (i)))
+#define sk_X509_INFO_delete_ptr(sk, ptr) ((X509_INFO*)OPENSSL_sk_delete_ptr(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr)))
 #define sk_X509_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
 #define sk_X509_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
-#define sk_X509_INFO_pop(sk) ((X509_INFO *)OPENSSL_sk_pop(ossl_check_X509_INFO_sk_type(sk)))
-#define sk_X509_INFO_shift(sk) ((X509_INFO *)OPENSSL_sk_shift(ossl_check_X509_INFO_sk_type(sk)))
-#define sk_X509_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_INFO_sk_type(sk),ossl_check_X509_INFO_freefunc_type(freefunc))
+#define sk_X509_INFO_pop(sk) ((X509_INFO*)OPENSSL_sk_pop(ossl_check_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_shift(sk) ((X509_INFO*)OPENSSL_sk_shift(ossl_check_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_freefunc_type(freefunc))
 #define sk_X509_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr), (idx))
-#define sk_X509_INFO_set(sk, idx, ptr) ((X509_INFO *)OPENSSL_sk_set(ossl_check_X509_INFO_sk_type(sk), (idx), ossl_check_X509_INFO_type(ptr)))
+#define sk_X509_INFO_set(sk, idx, ptr) ((X509_INFO*)OPENSSL_sk_set(ossl_check_X509_INFO_sk_type(sk), (idx), ossl_check_X509_INFO_type(ptr)))
 #define sk_X509_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
 #define sk_X509_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr))
 #define sk_X509_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_type(ptr), pnum)
 #define sk_X509_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_X509_INFO_sk_type(sk))
 #define sk_X509_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_INFO_sk_type(sk))
-#define sk_X509_INFO_dup(sk) ((STACK_OF(X509_INFO) *)OPENSSL_sk_dup(ossl_check_const_X509_INFO_sk_type(sk)))
-#define sk_X509_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_INFO_sk_type(sk), ossl_check_X509_INFO_copyfunc_type(copyfunc), ossl_check_X509_INFO_freefunc_type(freefunc)))
+#define sk_X509_INFO_dup(sk) ((STACK_OF(X509_INFO)*)OPENSSL_sk_dup(ossl_check_const_X509_INFO_sk_type(sk)))
+#define sk_X509_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_INFO)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_INFO_sk_type(sk), ossl_check_X509_INFO_copyfunc_type(copyfunc), ossl_check_X509_INFO_freefunc_type(freefunc)))
 #define sk_X509_INFO_set_cmp_func(sk, cmp) ((sk_X509_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_INFO_sk_type(sk), ossl_check_X509_INFO_compfunc_type(cmp)))
 
-
-/*
- * The next 2 structures and their 8 routines are used to manipulate Netscape's
- * spki structures - useful if you are writing a CA web page
- */
-typedef struct Netscape_spkac_st {
-    X509_PUBKEY *pubkey;
-    ASN1_IA5STRING *challenge;  /* challenge sent in atlas >= PR2 */
-} NETSCAPE_SPKAC;
-
-typedef struct Netscape_spki_st {
-    NETSCAPE_SPKAC *spkac;      /* signed public key and challenge */
-    X509_ALGOR sig_algor;
-    ASN1_BIT_STRING *signature;
-} NETSCAPE_SPKI;
-
-/* Netscape certificate sequence structure */
-typedef struct Netscape_certificate_sequence {
-    ASN1_OBJECT *type;
-    STACK_OF(X509) *certs;
-} NETSCAPE_CERT_SEQUENCE;
-
-/*- Unused (and iv length is wrong)
-typedef struct CBCParameter_st
-        {
-        unsigned char iv[8];
-        } CBC_PARAM;
-*/
-
-/* Password based encryption structure */
-
-typedef struct PBEPARAM_st {
-    ASN1_OCTET_STRING *salt;
-    ASN1_INTEGER *iter;
-} PBEPARAM;
-
-/* Password based encryption V2 structures */
-
-typedef struct PBE2PARAM_st {
-    X509_ALGOR *keyfunc;
-    X509_ALGOR *encryption;
-} PBE2PARAM;
-
-typedef struct PBKDF2PARAM_st {
-/* Usually OCTET STRING but could be anything */
-    ASN1_TYPE *salt;
-    ASN1_INTEGER *iter;
-    ASN1_INTEGER *keylength;
-    X509_ALGOR *prf;
-} PBKDF2PARAM;
+    /*
+     * The next 2 structures and their 8 routines are used to manipulate Netscape's
+     * spki structures - useful if you are writing a CA web page
+     */
+    typedef struct Netscape_spkac_st
+    {
+        X509_PUBKEY* pubkey;
+        ASN1_IA5STRING* challenge; /* challenge sent in atlas >= PR2 */
+    } NETSCAPE_SPKAC;
+
+    typedef struct Netscape_spki_st
+    {
+        NETSCAPE_SPKAC* spkac; /* signed public key and challenge */
+        X509_ALGOR sig_algor;
+        ASN1_BIT_STRING* signature;
+    } NETSCAPE_SPKI;
+
+    /* Netscape certificate sequence structure */
+    typedef struct Netscape_certificate_sequence
+    {
+        ASN1_OBJECT* type;
+        STACK_OF(X509) * certs;
+    } NETSCAPE_CERT_SEQUENCE;
+
+    /*- Unused (and iv length is wrong)
+    typedef struct CBCParameter_st
+            {
+            unsigned char iv[8];
+            } CBC_PARAM;
+    */
+
+    /* Password based encryption structure */
+
+    typedef struct PBEPARAM_st
+    {
+        ASN1_OCTET_STRING* salt;
+        ASN1_INTEGER* iter;
+    } PBEPARAM;
+
+    /* Password based encryption V2 structures */
+
+    typedef struct PBE2PARAM_st
+    {
+        X509_ALGOR* keyfunc;
+        X509_ALGOR* encryption;
+    } PBE2PARAM;
+
+    typedef struct PBKDF2PARAM_st
+    {
+        /* Usually OCTET STRING but could be anything */
+        ASN1_TYPE* salt;
+        ASN1_INTEGER* iter;
+        ASN1_INTEGER* keylength;
+        X509_ALGOR* prf;
+    } PBKDF2PARAM;
 
 #ifndef OPENSSL_NO_SCRYPT
-typedef struct SCRYPT_PARAMS_st {
-    ASN1_OCTET_STRING *salt;
-    ASN1_INTEGER *costParameter;
-    ASN1_INTEGER *blockSize;
-    ASN1_INTEGER *parallelizationParameter;
-    ASN1_INTEGER *keyLength;
-} SCRYPT_PARAMS;
+    typedef struct SCRYPT_PARAMS_st
+    {
+        ASN1_OCTET_STRING* salt;
+        ASN1_INTEGER* costParameter;
+        ASN1_INTEGER* blockSize;
+        ASN1_INTEGER* parallelizationParameter;
+        ASN1_INTEGER* keyLength;
+    } SCRYPT_PARAMS;
 #endif
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 
-# include <openssl/x509_vfy.h>
-# include <openssl/pkcs7.h>
+#include <openssl/x509_vfy.h>
+#include <openssl/pkcs7.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define X509_EXT_PACK_UNKNOWN 1
+#define X509_EXT_PACK_STRING 2
+
+#define X509_extract_key(x) X509_get_pubkey(x) /*****/
+#define X509_REQ_extract_key(a) X509_REQ_get_pubkey(a)
+#define X509_name_cmp(a, b) X509_NAME_cmp((a), (b))
+
+    void X509_CRL_set_default_method(const X509_CRL_METHOD* meth);
+    X509_CRL_METHOD* X509_CRL_METHOD_new(int (*crl_init)(X509_CRL* crl), int (*crl_free)(X509_CRL* crl), int (*crl_lookup)(X509_CRL* crl, X509_REVOKED** ret, const ASN1_INTEGER* serial, const X509_NAME* issuer), int (*crl_verify)(X509_CRL* crl, EVP_PKEY* pk));
+    void X509_CRL_METHOD_free(X509_CRL_METHOD* m);
+
+    void X509_CRL_set_meth_data(X509_CRL* crl, void* dat);
+    void* X509_CRL_get_meth_data(X509_CRL* crl);
+
+    const char* X509_verify_cert_error_string(long n);
+
+    int X509_verify(X509* a, EVP_PKEY* r);
+    int X509_self_signed(X509* cert, int verify_signature);
+
+    int X509_REQ_verify_ex(X509_REQ* a, EVP_PKEY* r, OSSL_LIB_CTX* libctx, const char* propq);
+    int X509_REQ_verify(X509_REQ* a, EVP_PKEY* r);
+    int X509_CRL_verify(X509_CRL* a, EVP_PKEY* r);
+    int NETSCAPE_SPKI_verify(NETSCAPE_SPKI* a, EVP_PKEY* r);
+
+    NETSCAPE_SPKI* NETSCAPE_SPKI_b64_decode(const char* str, int len);
+    char* NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI* x);
+    EVP_PKEY* NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI* x);
+    int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI* x, EVP_PKEY* pkey);
+
+    int NETSCAPE_SPKI_print(BIO* out, NETSCAPE_SPKI* spki);
+
+    int X509_signature_dump(BIO* bp, const ASN1_STRING* sig, int indent);
+    int X509_signature_print(BIO* bp, const X509_ALGOR* alg, const ASN1_STRING* sig);
+
+    int X509_sign(X509* x, EVP_PKEY* pkey, const EVP_MD* md);
+    int X509_sign_ctx(X509* x, EVP_MD_CTX* ctx);
+    int X509_REQ_sign(X509_REQ* x, EVP_PKEY* pkey, const EVP_MD* md);
+    int X509_REQ_sign_ctx(X509_REQ* x, EVP_MD_CTX* ctx);
+    int X509_CRL_sign(X509_CRL* x, EVP_PKEY* pkey, const EVP_MD* md);
+    int X509_CRL_sign_ctx(X509_CRL* x, EVP_MD_CTX* ctx);
+    int NETSCAPE_SPKI_sign(NETSCAPE_SPKI* x, EVP_PKEY* pkey, const EVP_MD* md);
+
+    int X509_pubkey_digest(const X509* data, const EVP_MD* type, unsigned char* md, unsigned int* len);
+    int X509_digest(const X509* data, const EVP_MD* type, unsigned char* md, unsigned int* len);
+    ASN1_OCTET_STRING* X509_digest_sig(const X509* cert, EVP_MD** md_used, int* md_is_fallback);
+    int X509_CRL_digest(const X509_CRL* data, const EVP_MD* type, unsigned char* md, unsigned int* len);
+    int X509_REQ_digest(const X509_REQ* data, const EVP_MD* type, unsigned char* md, unsigned int* len);
+    int X509_NAME_digest(const X509_NAME* data, const EVP_MD* type, unsigned char* md, unsigned int* len);
+
+    X509* X509_load_http(const char* url, BIO* bio, BIO* rbio, int timeout);
+    X509_CRL* X509_CRL_load_http(const char* url, BIO* bio, BIO* rbio, int timeout);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#include <openssl/http.h> /* OSSL_HTTP_REQ_CTX_nbio_d2i */
+#define X509_http_nbio(rctx, pcert) \
+    OSSL_HTTP_REQ_CTX_nbio_d2i(rctx, pcert, ASN1_ITEM_rptr(X509))
+#define X509_CRL_http_nbio(rctx, pcrl) \
+    OSSL_HTTP_REQ_CTX_nbio_d2i(rctx, pcrl, ASN1_ITEM_rptr(X509_CRL))
+#endif
+
+#ifndef OPENSSL_NO_STDIO
+    X509* d2i_X509_fp(FILE* fp, X509** x509);
+    int i2d_X509_fp(FILE* fp, const X509* x509);
+    X509_CRL* d2i_X509_CRL_fp(FILE* fp, X509_CRL** crl);
+    int i2d_X509_CRL_fp(FILE* fp, const X509_CRL* crl);
+    X509_REQ* d2i_X509_REQ_fp(FILE* fp, X509_REQ** req);
+    int i2d_X509_REQ_fp(FILE* fp, const X509_REQ* req);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 RSA* d2i_RSAPrivateKey_fp(FILE* fp, RSA** rsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_RSAPrivateKey_fp(FILE* fp, const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 RSA* d2i_RSAPublicKey_fp(FILE* fp, RSA** rsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_RSAPublicKey_fp(FILE* fp, const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 RSA* d2i_RSA_PUBKEY_fp(FILE* fp, RSA** rsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_RSA_PUBKEY_fp(FILE* fp, const RSA* rsa);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DSA
+    OSSL_DEPRECATEDIN_3_0 DSA* d2i_DSA_PUBKEY_fp(FILE* fp, DSA** dsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_DSA_PUBKEY_fp(FILE* fp, const DSA* dsa);
+    OSSL_DEPRECATEDIN_3_0 DSA* d2i_DSAPrivateKey_fp(FILE* fp, DSA** dsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_DSAPrivateKey_fp(FILE* fp, const DSA* dsa);
+#endif
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_EC
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* d2i_EC_PUBKEY_fp(FILE* fp, EC_KEY** eckey);
+    OSSL_DEPRECATEDIN_3_0 int i2d_EC_PUBKEY_fp(FILE* fp, const EC_KEY* eckey);
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* d2i_ECPrivateKey_fp(FILE* fp, EC_KEY** eckey);
+    OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey_fp(FILE* fp, const EC_KEY* eckey);
+#endif /* OPENSSL_NO_EC */
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+    X509_SIG* d2i_PKCS8_fp(FILE* fp, X509_SIG** p8);
+    int i2d_PKCS8_fp(FILE* fp, const X509_SIG* p8);
+    X509_PUBKEY* d2i_X509_PUBKEY_fp(FILE* fp, X509_PUBKEY** xpk);
+    int i2d_X509_PUBKEY_fp(FILE* fp, const X509_PUBKEY* xpk);
+    PKCS8_PRIV_KEY_INFO* d2i_PKCS8_PRIV_KEY_INFO_fp(FILE* fp, PKCS8_PRIV_KEY_INFO** p8inf);
+    int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE* fp, const PKCS8_PRIV_KEY_INFO* p8inf);
+    int i2d_PKCS8PrivateKeyInfo_fp(FILE* fp, const EVP_PKEY* key);
+    int i2d_PrivateKey_fp(FILE* fp, const EVP_PKEY* pkey);
+    EVP_PKEY* d2i_PrivateKey_ex_fp(FILE* fp, EVP_PKEY** a, OSSL_LIB_CTX* libctx, const char* propq);
+    EVP_PKEY* d2i_PrivateKey_fp(FILE* fp, EVP_PKEY** a);
+    int i2d_PUBKEY_fp(FILE* fp, const EVP_PKEY* pkey);
+    EVP_PKEY* d2i_PUBKEY_fp(FILE* fp, EVP_PKEY** a);
+#endif
+
+    X509* d2i_X509_bio(BIO* bp, X509** x509);
+    int i2d_X509_bio(BIO* bp, const X509* x509);
+    X509_CRL* d2i_X509_CRL_bio(BIO* bp, X509_CRL** crl);
+    int i2d_X509_CRL_bio(BIO* bp, const X509_CRL* crl);
+    X509_REQ* d2i_X509_REQ_bio(BIO* bp, X509_REQ** req);
+    int i2d_X509_REQ_bio(BIO* bp, const X509_REQ* req);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    OSSL_DEPRECATEDIN_3_0 RSA* d2i_RSAPrivateKey_bio(BIO* bp, RSA** rsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_RSAPrivateKey_bio(BIO* bp, const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 RSA* d2i_RSAPublicKey_bio(BIO* bp, RSA** rsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_RSAPublicKey_bio(BIO* bp, const RSA* rsa);
+    OSSL_DEPRECATEDIN_3_0 RSA* d2i_RSA_PUBKEY_bio(BIO* bp, RSA** rsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_RSA_PUBKEY_bio(BIO* bp, const RSA* rsa);
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DSA
+    OSSL_DEPRECATEDIN_3_0 DSA* d2i_DSA_PUBKEY_bio(BIO* bp, DSA** dsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_DSA_PUBKEY_bio(BIO* bp, const DSA* dsa);
+    OSSL_DEPRECATEDIN_3_0 DSA* d2i_DSAPrivateKey_bio(BIO* bp, DSA** dsa);
+    OSSL_DEPRECATEDIN_3_0 int i2d_DSAPrivateKey_bio(BIO* bp, const DSA* dsa);
+#endif
+#endif
 
-#ifdef  __cplusplus
-extern "C" {
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_EC
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* d2i_EC_PUBKEY_bio(BIO* bp, EC_KEY** eckey);
+    OSSL_DEPRECATEDIN_3_0 int i2d_EC_PUBKEY_bio(BIO* bp, const EC_KEY* eckey);
+    OSSL_DEPRECATEDIN_3_0 EC_KEY* d2i_ECPrivateKey_bio(BIO* bp, EC_KEY** eckey);
+    OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey_bio(BIO* bp, const EC_KEY* eckey);
+#endif /* OPENSSL_NO_EC */
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+    X509_SIG* d2i_PKCS8_bio(BIO* bp, X509_SIG** p8);
+    int i2d_PKCS8_bio(BIO* bp, const X509_SIG* p8);
+    X509_PUBKEY* d2i_X509_PUBKEY_bio(BIO* bp, X509_PUBKEY** xpk);
+    int i2d_X509_PUBKEY_bio(BIO* bp, const X509_PUBKEY* xpk);
+    PKCS8_PRIV_KEY_INFO* d2i_PKCS8_PRIV_KEY_INFO_bio(BIO* bp, PKCS8_PRIV_KEY_INFO** p8inf);
+    int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO* bp, const PKCS8_PRIV_KEY_INFO* p8inf);
+    int i2d_PKCS8PrivateKeyInfo_bio(BIO* bp, const EVP_PKEY* key);
+    int i2d_PrivateKey_bio(BIO* bp, const EVP_PKEY* pkey);
+    EVP_PKEY* d2i_PrivateKey_ex_bio(BIO* bp, EVP_PKEY** a, OSSL_LIB_CTX* libctx, const char* propq);
+    EVP_PKEY* d2i_PrivateKey_bio(BIO* bp, EVP_PKEY** a);
+    int i2d_PUBKEY_bio(BIO* bp, const EVP_PKEY* pkey);
+    EVP_PKEY* d2i_PUBKEY_bio(BIO* bp, EVP_PKEY** a);
+
+    DECLARE_ASN1_DUP_FUNCTION(X509)
+    DECLARE_ASN1_DUP_FUNCTION(X509_ALGOR)
+    DECLARE_ASN1_DUP_FUNCTION(X509_ATTRIBUTE)
+    DECLARE_ASN1_DUP_FUNCTION(X509_CRL)
+    DECLARE_ASN1_DUP_FUNCTION(X509_EXTENSION)
+    DECLARE_ASN1_DUP_FUNCTION(X509_PUBKEY)
+    DECLARE_ASN1_DUP_FUNCTION(X509_REQ)
+    DECLARE_ASN1_DUP_FUNCTION(X509_REVOKED)
+    int X509_ALGOR_set0(X509_ALGOR* alg, ASN1_OBJECT* aobj, int ptype, void* pval);
+    void X509_ALGOR_get0(const ASN1_OBJECT** paobj, int* pptype, const void** ppval, const X509_ALGOR* algor);
+    void X509_ALGOR_set_md(X509_ALGOR* alg, const EVP_MD* md);
+    int X509_ALGOR_cmp(const X509_ALGOR* a, const X509_ALGOR* b);
+    int X509_ALGOR_copy(X509_ALGOR* dest, const X509_ALGOR* src);
+
+    DECLARE_ASN1_DUP_FUNCTION(X509_NAME)
+    DECLARE_ASN1_DUP_FUNCTION(X509_NAME_ENTRY)
+
+    int X509_cmp_time(const ASN1_TIME* s, time_t* t);
+    int X509_cmp_current_time(const ASN1_TIME* s);
+    int X509_cmp_timeframe(const X509_VERIFY_PARAM* vpm, const ASN1_TIME* start, const ASN1_TIME* end);
+    ASN1_TIME* X509_time_adj(ASN1_TIME* s, long adj, time_t* t);
+    ASN1_TIME* X509_time_adj_ex(ASN1_TIME* s, int offset_day, long offset_sec, time_t* t);
+    ASN1_TIME* X509_gmtime_adj(ASN1_TIME* s, long adj);
+
+    const char* X509_get_default_cert_area(void);
+    const char* X509_get_default_cert_dir(void);
+    const char* X509_get_default_cert_file(void);
+    const char* X509_get_default_cert_dir_env(void);
+    const char* X509_get_default_cert_file_env(void);
+    const char* X509_get_default_private_dir(void);
+
+    X509_REQ* X509_to_X509_REQ(X509* x, EVP_PKEY* pkey, const EVP_MD* md);
+    X509* X509_REQ_to_X509(X509_REQ* r, int days, EVP_PKEY* pkey);
+
+    DECLARE_ASN1_FUNCTIONS(X509_ALGOR)
+    DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS)
+    DECLARE_ASN1_FUNCTIONS(X509_VAL)
+
+    DECLARE_ASN1_FUNCTIONS(X509_PUBKEY)
+
+    X509_PUBKEY* X509_PUBKEY_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+    int X509_PUBKEY_set(X509_PUBKEY** x, EVP_PKEY* pkey);
+    EVP_PKEY* X509_PUBKEY_get0(const X509_PUBKEY* key);
+    EVP_PKEY* X509_PUBKEY_get(const X509_PUBKEY* key);
+    int X509_get_pubkey_parameters(EVP_PKEY* pkey, STACK_OF(X509) * chain);
+    long X509_get_pathlen(X509* x);
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(EVP_PKEY, PUBKEY)
+        EVP_PKEY* d2i_PUBKEY_ex(EVP_PKEY** a, const unsigned char** pp, long length, OSSL_LIB_CTX* libctx, const char* propq);
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, RSA, RSA_PUBKEY)
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DSA
+        DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, DSA, DSA_PUBKEY)
 #endif
+#endif
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_EC
+            DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, EC_KEY, EC_PUBKEY)
+#endif
+#endif
+
+                DECLARE_ASN1_FUNCTIONS(X509_SIG) void X509_SIG_get0(const X509_SIG* sig, const X509_ALGOR** palg, const ASN1_OCTET_STRING** pdigest);
+    void X509_SIG_getm(X509_SIG* sig, X509_ALGOR** palg, ASN1_OCTET_STRING** pdigest);
+
+    DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO)
+    DECLARE_ASN1_FUNCTIONS(X509_REQ)
+    X509_REQ* X509_REQ_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+
+    DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE)
+    X509_ATTRIBUTE* X509_ATTRIBUTE_create(int nid, int atrtype, void* value);
 
-# define X509_EXT_PACK_UNKNOWN   1
-# define X509_EXT_PACK_STRING    2
-
-# define         X509_extract_key(x)     X509_get_pubkey(x)/*****/
-# define         X509_REQ_extract_key(a) X509_REQ_get_pubkey(a)
-# define         X509_name_cmp(a,b)      X509_NAME_cmp((a),(b))
-
-void X509_CRL_set_default_method(const X509_CRL_METHOD *meth);
-X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl),
-                                     int (*crl_free) (X509_CRL *crl),
-                                     int (*crl_lookup) (X509_CRL *crl,
-                                                        X509_REVOKED **ret,
-                                                        const
-                                                        ASN1_INTEGER *serial,
-                                                        const
-                                                        X509_NAME *issuer),
-                                     int (*crl_verify) (X509_CRL *crl,
-                                                        EVP_PKEY *pk));
-void X509_CRL_METHOD_free(X509_CRL_METHOD *m);
-
-void X509_CRL_set_meth_data(X509_CRL *crl, void *dat);
-void *X509_CRL_get_meth_data(X509_CRL *crl);
-
-const char *X509_verify_cert_error_string(long n);
-
-int X509_verify(X509 *a, EVP_PKEY *r);
-int X509_self_signed(X509 *cert, int verify_signature);
-
-int X509_REQ_verify_ex(X509_REQ *a, EVP_PKEY *r, OSSL_LIB_CTX *libctx,
-                       const char *propq);
-int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r);
-int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r);
-int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r);
-
-NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len);
-char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x);
-EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x);
-int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey);
-
-int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki);
-
-int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent);
-int X509_signature_print(BIO *bp, const X509_ALGOR *alg,
-                         const ASN1_STRING *sig);
-
-int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
-int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx);
-int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md);
-int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx);
-int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);
-int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx);
-int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);
-
-int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
-                       unsigned char *md, unsigned int *len);
-int X509_digest(const X509 *data, const EVP_MD *type,
-                unsigned char *md, unsigned int *len);
-ASN1_OCTET_STRING *X509_digest_sig(const X509 *cert,
-                                   EVP_MD **md_used, int *md_is_fallback);
-int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
-                    unsigned char *md, unsigned int *len);
-int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
-                    unsigned char *md, unsigned int *len);
-int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
-                     unsigned char *md, unsigned int *len);
-
-X509 *X509_load_http(const char *url, BIO *bio, BIO *rbio, int timeout);
-X509_CRL *X509_CRL_load_http(const char *url, BIO *bio, BIO *rbio, int timeout);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  include <openssl/http.h> /* OSSL_HTTP_REQ_CTX_nbio_d2i */
-#  define X509_http_nbio(rctx, pcert) \
-      OSSL_HTTP_REQ_CTX_nbio_d2i(rctx, pcert, ASN1_ITEM_rptr(X509))
-#  define X509_CRL_http_nbio(rctx, pcrl) \
-      OSSL_HTTP_REQ_CTX_nbio_d2i(rctx, pcrl, ASN1_ITEM_rptr(X509_CRL))
-# endif
-
-# ifndef OPENSSL_NO_STDIO
-X509 *d2i_X509_fp(FILE *fp, X509 **x509);
-int i2d_X509_fp(FILE *fp, const X509 *x509);
-X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl);
-int i2d_X509_CRL_fp(FILE *fp, const X509_CRL *crl);
-X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req);
-int i2d_X509_REQ_fp(FILE *fp, const X509_REQ *req);
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_RSAPrivateKey_fp(FILE *fp, const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_RSAPublicKey_fp(FILE *fp, const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_RSA_PUBKEY_fp(FILE *fp, const RSA *rsa);
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   ifndef OPENSSL_NO_DSA
-OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_DSA_PUBKEY_fp(FILE *fp, const DSA *dsa);
-OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_DSAPrivateKey_fp(FILE *fp, const DSA *dsa);
-#   endif
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   ifndef OPENSSL_NO_EC
-OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);
-OSSL_DEPRECATEDIN_3_0 int i2d_EC_PUBKEY_fp(FILE *fp, const EC_KEY *eckey);
-OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);
-OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey_fp(FILE *fp, const EC_KEY *eckey);
-#   endif /* OPENSSL_NO_EC */
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8);
-int i2d_PKCS8_fp(FILE *fp, const X509_SIG *p8);
-X509_PUBKEY *d2i_X509_PUBKEY_fp(FILE *fp, X509_PUBKEY **xpk);
-int i2d_X509_PUBKEY_fp(FILE *fp, const X509_PUBKEY *xpk);
-PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
-                                                PKCS8_PRIV_KEY_INFO **p8inf);
-int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, const PKCS8_PRIV_KEY_INFO *p8inf);
-int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, const EVP_PKEY *key);
-int i2d_PrivateKey_fp(FILE *fp, const EVP_PKEY *pkey);
-EVP_PKEY *d2i_PrivateKey_ex_fp(FILE *fp, EVP_PKEY **a, OSSL_LIB_CTX *libctx,
-                               const char *propq);
-EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a);
-int i2d_PUBKEY_fp(FILE *fp, const EVP_PKEY *pkey);
-EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a);
-# endif
-
-X509 *d2i_X509_bio(BIO *bp, X509 **x509);
-int i2d_X509_bio(BIO *bp, const X509 *x509);
-X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl);
-int i2d_X509_CRL_bio(BIO *bp, const X509_CRL *crl);
-X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req);
-int i2d_X509_REQ_bio(BIO *bp, const X509_REQ *req);
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_RSAPrivateKey_bio(BIO *bp, const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_RSAPublicKey_bio(BIO *bp, const RSA *rsa);
-OSSL_DEPRECATEDIN_3_0 RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_RSA_PUBKEY_bio(BIO *bp, const RSA *rsa);
-#  endif
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   ifndef OPENSSL_NO_DSA
-OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_DSA_PUBKEY_bio(BIO *bp, const DSA *dsa);
-OSSL_DEPRECATEDIN_3_0 DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);
-OSSL_DEPRECATEDIN_3_0 int i2d_DSAPrivateKey_bio(BIO *bp, const DSA *dsa);
-#   endif
-#  endif
-
-#  ifndef OPENSSL_NO_DEPRECATED_3_0
-#   ifndef OPENSSL_NO_EC
-OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);
-OSSL_DEPRECATEDIN_3_0 int i2d_EC_PUBKEY_bio(BIO *bp, const EC_KEY *eckey);
-OSSL_DEPRECATEDIN_3_0 EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);
-OSSL_DEPRECATEDIN_3_0 int i2d_ECPrivateKey_bio(BIO *bp, const EC_KEY *eckey);
-#   endif /* OPENSSL_NO_EC */
-#  endif /* OPENSSL_NO_DEPRECATED_3_0 */
-
-X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8);
-int i2d_PKCS8_bio(BIO *bp, const X509_SIG *p8);
-X509_PUBKEY *d2i_X509_PUBKEY_bio(BIO *bp, X509_PUBKEY **xpk);
-int i2d_X509_PUBKEY_bio(BIO *bp, const X509_PUBKEY *xpk);
-PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
-                                                 PKCS8_PRIV_KEY_INFO **p8inf);
-int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, const PKCS8_PRIV_KEY_INFO *p8inf);
-int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, const EVP_PKEY *key);
-int i2d_PrivateKey_bio(BIO *bp, const EVP_PKEY *pkey);
-EVP_PKEY *d2i_PrivateKey_ex_bio(BIO *bp, EVP_PKEY **a, OSSL_LIB_CTX *libctx,
-                                const char *propq);
-EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a);
-int i2d_PUBKEY_bio(BIO *bp, const EVP_PKEY *pkey);
-EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a);
-
-DECLARE_ASN1_DUP_FUNCTION(X509)
-DECLARE_ASN1_DUP_FUNCTION(X509_ALGOR)
-DECLARE_ASN1_DUP_FUNCTION(X509_ATTRIBUTE)
-DECLARE_ASN1_DUP_FUNCTION(X509_CRL)
-DECLARE_ASN1_DUP_FUNCTION(X509_EXTENSION)
-DECLARE_ASN1_DUP_FUNCTION(X509_PUBKEY)
-DECLARE_ASN1_DUP_FUNCTION(X509_REQ)
-DECLARE_ASN1_DUP_FUNCTION(X509_REVOKED)
-int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype,
-                    void *pval);
-void X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype,
-                     const void **ppval, const X509_ALGOR *algor);
-void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md);
-int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b);
-int X509_ALGOR_copy(X509_ALGOR *dest, const X509_ALGOR *src);
-
-DECLARE_ASN1_DUP_FUNCTION(X509_NAME)
-DECLARE_ASN1_DUP_FUNCTION(X509_NAME_ENTRY)
-
-int X509_cmp_time(const ASN1_TIME *s, time_t *t);
-int X509_cmp_current_time(const ASN1_TIME *s);
-int X509_cmp_timeframe(const X509_VERIFY_PARAM *vpm,
-                       const ASN1_TIME *start, const ASN1_TIME *end);
-ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *t);
-ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s,
-                            int offset_day, long offset_sec, time_t *t);
-ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj);
-
-const char *X509_get_default_cert_area(void);
-const char *X509_get_default_cert_dir(void);
-const char *X509_get_default_cert_file(void);
-const char *X509_get_default_cert_dir_env(void);
-const char *X509_get_default_cert_file_env(void);
-const char *X509_get_default_private_dir(void);
-
-X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
-X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey);
-
-DECLARE_ASN1_FUNCTIONS(X509_ALGOR)
-DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS)
-DECLARE_ASN1_FUNCTIONS(X509_VAL)
-
-DECLARE_ASN1_FUNCTIONS(X509_PUBKEY)
-
-X509_PUBKEY *X509_PUBKEY_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
-int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);
-EVP_PKEY *X509_PUBKEY_get0(const X509_PUBKEY *key);
-EVP_PKEY *X509_PUBKEY_get(const X509_PUBKEY *key);
-int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain);
-long X509_get_pathlen(X509 *x);
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(EVP_PKEY, PUBKEY)
-EVP_PKEY *d2i_PUBKEY_ex(EVP_PKEY **a, const unsigned char **pp, long length,
-                        OSSL_LIB_CTX *libctx, const char *propq);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,RSA, RSA_PUBKEY)
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifndef OPENSSL_NO_DSA
-DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0,DSA, DSA_PUBKEY)
-#  endif
-# endif
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  ifndef OPENSSL_NO_EC
-DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(OSSL_DEPRECATEDIN_3_0, EC_KEY, EC_PUBKEY)
-#  endif
-# endif
-
-DECLARE_ASN1_FUNCTIONS(X509_SIG)
-void X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg,
-                   const ASN1_OCTET_STRING **pdigest);
-void X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg,
-                   ASN1_OCTET_STRING **pdigest);
-
-DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO)
-DECLARE_ASN1_FUNCTIONS(X509_REQ)
-X509_REQ *X509_REQ_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
-
-DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE)
-X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value);
-
-DECLARE_ASN1_FUNCTIONS(X509_EXTENSION)
-DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS)
-
-DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY)
-
-DECLARE_ASN1_FUNCTIONS(X509_NAME)
-
-int X509_NAME_set(X509_NAME **xn, const X509_NAME *name);
-
-DECLARE_ASN1_FUNCTIONS(X509_CINF)
-DECLARE_ASN1_FUNCTIONS(X509)
-X509 *X509_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
-DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX)
+    DECLARE_ASN1_FUNCTIONS(X509_EXTENSION)
+    DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS)
+
+    DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY)
+
+    DECLARE_ASN1_FUNCTIONS(X509_NAME)
+
+    int X509_NAME_set(X509_NAME** xn, const X509_NAME* name);
+
+    DECLARE_ASN1_FUNCTIONS(X509_CINF)
+    DECLARE_ASN1_FUNCTIONS(X509)
+    X509* X509_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+    DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX)
 
 #define X509_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, l, p, newf, dupf, freef)
-int X509_set_ex_data(X509 *r, int idx, void *arg);
-void *X509_get_ex_data(const X509 *r, int idx);
-DECLARE_ASN1_ENCODE_FUNCTIONS_only(X509,X509_AUX)
+    int X509_set_ex_data(X509* r, int idx, void* arg);
+    void* X509_get_ex_data(const X509* r, int idx);
+    DECLARE_ASN1_ENCODE_FUNCTIONS_only(X509, X509_AUX)
 
-int i2d_re_X509_tbs(X509 *x, unsigned char **pp);
+        int i2d_re_X509_tbs(X509* x, unsigned char** pp);
 
-int X509_SIG_INFO_get(const X509_SIG_INFO *siginf, int *mdnid, int *pknid,
-                      int *secbits, uint32_t *flags);
-void X509_SIG_INFO_set(X509_SIG_INFO *siginf, int mdnid, int pknid,
-                       int secbits, uint32_t flags);
+    int X509_SIG_INFO_get(const X509_SIG_INFO* siginf, int* mdnid, int* pknid, int* secbits, uint32_t* flags);
+    void X509_SIG_INFO_set(X509_SIG_INFO* siginf, int mdnid, int pknid, int secbits, uint32_t flags);
 
-int X509_get_signature_info(X509 *x, int *mdnid, int *pknid, int *secbits,
-                            uint32_t *flags);
+    int X509_get_signature_info(X509* x, int* mdnid, int* pknid, int* secbits, uint32_t* flags);
 
-void X509_get0_signature(const ASN1_BIT_STRING **psig,
-                         const X509_ALGOR **palg, const X509 *x);
-int X509_get_signature_nid(const X509 *x);
+    void X509_get0_signature(const ASN1_BIT_STRING** psig, const X509_ALGOR** palg, const X509* x);
+    int X509_get_signature_nid(const X509* x);
 
-void X509_set0_distinguishing_id(X509 *x, ASN1_OCTET_STRING *d_id);
-ASN1_OCTET_STRING *X509_get0_distinguishing_id(X509 *x);
-void X509_REQ_set0_distinguishing_id(X509_REQ *x, ASN1_OCTET_STRING *d_id);
-ASN1_OCTET_STRING *X509_REQ_get0_distinguishing_id(X509_REQ *x);
+    void X509_set0_distinguishing_id(X509* x, ASN1_OCTET_STRING* d_id);
+    ASN1_OCTET_STRING* X509_get0_distinguishing_id(X509* x);
+    void X509_REQ_set0_distinguishing_id(X509_REQ* x, ASN1_OCTET_STRING* d_id);
+    ASN1_OCTET_STRING* X509_REQ_get0_distinguishing_id(X509_REQ* x);
 
-int X509_alias_set1(X509 *x, const unsigned char *name, int len);
-int X509_keyid_set1(X509 *x, const unsigned char *id, int len);
-unsigned char *X509_alias_get0(X509 *x, int *len);
-unsigned char *X509_keyid_get0(X509 *x, int *len);
+    int X509_alias_set1(X509* x, const unsigned char* name, int len);
+    int X509_keyid_set1(X509* x, const unsigned char* id, int len);
+    unsigned char* X509_alias_get0(X509* x, int* len);
+    unsigned char* X509_keyid_get0(X509* x, int* len);
 
-DECLARE_ASN1_FUNCTIONS(X509_REVOKED)
-DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO)
-DECLARE_ASN1_FUNCTIONS(X509_CRL)
-X509_CRL *X509_CRL_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
+    DECLARE_ASN1_FUNCTIONS(X509_REVOKED)
+    DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO)
+    DECLARE_ASN1_FUNCTIONS(X509_CRL)
+    X509_CRL* X509_CRL_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
 
-int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev);
-int X509_CRL_get0_by_serial(X509_CRL *crl,
-                            X509_REVOKED **ret, const ASN1_INTEGER *serial);
-int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x);
+    int X509_CRL_add0_revoked(X509_CRL* crl, X509_REVOKED* rev);
+    int X509_CRL_get0_by_serial(X509_CRL* crl, X509_REVOKED** ret, const ASN1_INTEGER* serial);
+    int X509_CRL_get0_by_cert(X509_CRL* crl, X509_REVOKED** ret, X509* x);
 
-X509_PKEY *X509_PKEY_new(void);
-void X509_PKEY_free(X509_PKEY *a);
+    X509_PKEY* X509_PKEY_new(void);
+    void X509_PKEY_free(X509_PKEY* a);
 
-DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI)
-DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC)
-DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE)
+    DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI)
+    DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC)
+    DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE)
 
-X509_INFO *X509_INFO_new(void);
-void X509_INFO_free(X509_INFO *a);
-char *X509_NAME_oneline(const X509_NAME *a, char *buf, int size);
+    X509_INFO* X509_INFO_new(void);
+    void X509_INFO_free(X509_INFO* a);
+    char* X509_NAME_oneline(const X509_NAME* a, char* buf, int size);
 
 #ifndef OPENSSL_NO_DEPRECATED_3_0
-OSSL_DEPRECATEDIN_3_0
-int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1,
-                ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey);
-OSSL_DEPRECATEDIN_3_0
-int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data,
-                unsigned char *md, unsigned int *len);
-OSSL_DEPRECATEDIN_3_0
-int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1, X509_ALGOR *algor2,
-              ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey,
-              const EVP_MD *type);
+    OSSL_DEPRECATEDIN_3_0
+    int ASN1_verify(i2d_of_void* i2d, X509_ALGOR* algor1, ASN1_BIT_STRING* signature, char* data, EVP_PKEY* pkey);
+    OSSL_DEPRECATEDIN_3_0
+    int ASN1_digest(i2d_of_void* i2d, const EVP_MD* type, char* data, unsigned char* md, unsigned int* len);
+    OSSL_DEPRECATEDIN_3_0
+    int ASN1_sign(i2d_of_void* i2d, X509_ALGOR* algor1, X509_ALGOR* algor2, ASN1_BIT_STRING* signature, char* data, EVP_PKEY* pkey, const EVP_MD* type);
 #endif
-int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *data,
-                     unsigned char *md, unsigned int *len);
-int ASN1_item_verify(const ASN1_ITEM *it, const X509_ALGOR *alg,
-                     const ASN1_BIT_STRING *signature, const void *data,
-                     EVP_PKEY *pkey);
-int ASN1_item_verify_ctx(const ASN1_ITEM *it, const X509_ALGOR *alg,
-                         const ASN1_BIT_STRING *signature, const void *data,
-                         EVP_MD_CTX *ctx);
-int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2,
-                   ASN1_BIT_STRING *signature, const void *data,
-                   EVP_PKEY *pkey, const EVP_MD *md);
-int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1,
-                       X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
-                       const void *data, EVP_MD_CTX *ctx);
+    int ASN1_item_digest(const ASN1_ITEM* it, const EVP_MD* type, void* data, unsigned char* md, unsigned int* len);
+    int ASN1_item_verify(const ASN1_ITEM* it, const X509_ALGOR* alg, const ASN1_BIT_STRING* signature, const void* data, EVP_PKEY* pkey);
+    int ASN1_item_verify_ctx(const ASN1_ITEM* it, const X509_ALGOR* alg, const ASN1_BIT_STRING* signature, const void* data, EVP_MD_CTX* ctx);
+    int ASN1_item_sign(const ASN1_ITEM* it, X509_ALGOR* algor1, X509_ALGOR* algor2, ASN1_BIT_STRING* signature, const void* data, EVP_PKEY* pkey, const EVP_MD* md);
+    int ASN1_item_sign_ctx(const ASN1_ITEM* it, X509_ALGOR* algor1, X509_ALGOR* algor2, ASN1_BIT_STRING* signature, const void* data, EVP_MD_CTX* ctx);
 
 #define X509_VERSION_1 0
 #define X509_VERSION_2 1
 #define X509_VERSION_3 2
 
-long X509_get_version(const X509 *x);
-int X509_set_version(X509 *x, long version);
-int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);
-ASN1_INTEGER *X509_get_serialNumber(X509 *x);
-const ASN1_INTEGER *X509_get0_serialNumber(const X509 *x);
-int X509_set_issuer_name(X509 *x, const X509_NAME *name);
-X509_NAME *X509_get_issuer_name(const X509 *a);
-int X509_set_subject_name(X509 *x, const X509_NAME *name);
-X509_NAME *X509_get_subject_name(const X509 *a);
-const ASN1_TIME * X509_get0_notBefore(const X509 *x);
-ASN1_TIME *X509_getm_notBefore(const X509 *x);
-int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm);
-const ASN1_TIME *X509_get0_notAfter(const X509 *x);
-ASN1_TIME *X509_getm_notAfter(const X509 *x);
-int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm);
-int X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
-int X509_up_ref(X509 *x);
-int X509_get_signature_type(const X509 *x);
-
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define X509_get_notBefore X509_getm_notBefore
-#  define X509_get_notAfter X509_getm_notAfter
-#  define X509_set_notBefore X509_set1_notBefore
-#  define X509_set_notAfter X509_set1_notAfter
+    long X509_get_version(const X509* x);
+    int X509_set_version(X509* x, long version);
+    int X509_set_serialNumber(X509* x, ASN1_INTEGER* serial);
+    ASN1_INTEGER* X509_get_serialNumber(X509* x);
+    const ASN1_INTEGER* X509_get0_serialNumber(const X509* x);
+    int X509_set_issuer_name(X509* x, const X509_NAME* name);
+    X509_NAME* X509_get_issuer_name(const X509* a);
+    int X509_set_subject_name(X509* x, const X509_NAME* name);
+    X509_NAME* X509_get_subject_name(const X509* a);
+    const ASN1_TIME* X509_get0_notBefore(const X509* x);
+    ASN1_TIME* X509_getm_notBefore(const X509* x);
+    int X509_set1_notBefore(X509* x, const ASN1_TIME* tm);
+    const ASN1_TIME* X509_get0_notAfter(const X509* x);
+    ASN1_TIME* X509_getm_notAfter(const X509* x);
+    int X509_set1_notAfter(X509* x, const ASN1_TIME* tm);
+    int X509_set_pubkey(X509* x, EVP_PKEY* pkey);
+    int X509_up_ref(X509* x);
+    int X509_get_signature_type(const X509* x);
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define X509_get_notBefore X509_getm_notBefore
+#define X509_get_notAfter X509_getm_notAfter
+#define X509_set_notBefore X509_set1_notBefore
+#define X509_set_notAfter X509_set1_notAfter
 #endif
 
+    /*
+     * This one is only used so that a binary form can output, as in
+     * i2d_X509_PUBKEY(X509_get_X509_PUBKEY(x), &buf)
+     */
+    X509_PUBKEY* X509_get_X509_PUBKEY(const X509* x);
+    const STACK_OF(X509_EXTENSION) * X509_get0_extensions(const X509* x);
+    void X509_get0_uids(const X509* x, const ASN1_BIT_STRING** piuid, const ASN1_BIT_STRING** psuid);
+    const X509_ALGOR* X509_get0_tbs_sigalg(const X509* x);
 
-/*
- * This one is only used so that a binary form can output, as in
- * i2d_X509_PUBKEY(X509_get_X509_PUBKEY(x), &buf)
- */
-X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x);
-const STACK_OF(X509_EXTENSION) *X509_get0_extensions(const X509 *x);
-void X509_get0_uids(const X509 *x, const ASN1_BIT_STRING **piuid,
-                    const ASN1_BIT_STRING **psuid);
-const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x);
-
-EVP_PKEY *X509_get0_pubkey(const X509 *x);
-EVP_PKEY *X509_get_pubkey(X509 *x);
-ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x);
+    EVP_PKEY* X509_get0_pubkey(const X509* x);
+    EVP_PKEY* X509_get_pubkey(X509* x);
+    ASN1_BIT_STRING* X509_get0_pubkey_bitstr(const X509* x);
 
 #define X509_REQ_VERSION_1 0
 
-long X509_REQ_get_version(const X509_REQ *req);
-int X509_REQ_set_version(X509_REQ *x, long version);
-X509_NAME *X509_REQ_get_subject_name(const X509_REQ *req);
-int X509_REQ_set_subject_name(X509_REQ *req, const X509_NAME *name);
-void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
-                             const X509_ALGOR **palg);
-void X509_REQ_set0_signature(X509_REQ *req, ASN1_BIT_STRING *psig);
-int X509_REQ_set1_signature_algo(X509_REQ *req, X509_ALGOR *palg);
-int X509_REQ_get_signature_nid(const X509_REQ *req);
-int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp);
-int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
-EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req);
-EVP_PKEY *X509_REQ_get0_pubkey(X509_REQ *req);
-X509_PUBKEY *X509_REQ_get_X509_PUBKEY(X509_REQ *req);
-int X509_REQ_extension_nid(int nid);
-int *X509_REQ_get_extension_nids(void);
-void X509_REQ_set_extension_nids(int *nids);
-STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req);
-int X509_REQ_add_extensions_nid(X509_REQ *req,
-                                const STACK_OF(X509_EXTENSION) *exts, int nid);
-int X509_REQ_add_extensions(X509_REQ *req, const STACK_OF(X509_EXTENSION) *ext);
-int X509_REQ_get_attr_count(const X509_REQ *req);
-int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos);
-int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
-                             int lastpos);
-X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc);
-X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc);
-int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr);
-int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
-                              const ASN1_OBJECT *obj, int type,
-                              const unsigned char *bytes, int len);
-int X509_REQ_add1_attr_by_NID(X509_REQ *req,
-                              int nid, int type,
-                              const unsigned char *bytes, int len);
-int X509_REQ_add1_attr_by_txt(X509_REQ *req,
-                              const char *attrname, int type,
-                              const unsigned char *bytes, int len);
+    long X509_REQ_get_version(const X509_REQ* req);
+    int X509_REQ_set_version(X509_REQ* x, long version);
+    X509_NAME* X509_REQ_get_subject_name(const X509_REQ* req);
+    int X509_REQ_set_subject_name(X509_REQ* req, const X509_NAME* name);
+    void X509_REQ_get0_signature(const X509_REQ* req, const ASN1_BIT_STRING** psig, const X509_ALGOR** palg);
+    void X509_REQ_set0_signature(X509_REQ* req, ASN1_BIT_STRING* psig);
+    int X509_REQ_set1_signature_algo(X509_REQ* req, X509_ALGOR* palg);
+    int X509_REQ_get_signature_nid(const X509_REQ* req);
+    int i2d_re_X509_REQ_tbs(X509_REQ* req, unsigned char** pp);
+    int X509_REQ_set_pubkey(X509_REQ* x, EVP_PKEY* pkey);
+    EVP_PKEY* X509_REQ_get_pubkey(X509_REQ* req);
+    EVP_PKEY* X509_REQ_get0_pubkey(X509_REQ* req);
+    X509_PUBKEY* X509_REQ_get_X509_PUBKEY(X509_REQ* req);
+    int X509_REQ_extension_nid(int nid);
+    int* X509_REQ_get_extension_nids(void);
+    void X509_REQ_set_extension_nids(int* nids);
+    STACK_OF(X509_EXTENSION) * X509_REQ_get_extensions(X509_REQ* req);
+    int X509_REQ_add_extensions_nid(X509_REQ* req, const STACK_OF(X509_EXTENSION) * exts, int nid);
+    int X509_REQ_add_extensions(X509_REQ* req, const STACK_OF(X509_EXTENSION) * ext);
+    int X509_REQ_get_attr_count(const X509_REQ* req);
+    int X509_REQ_get_attr_by_NID(const X509_REQ* req, int nid, int lastpos);
+    int X509_REQ_get_attr_by_OBJ(const X509_REQ* req, const ASN1_OBJECT* obj, int lastpos);
+    X509_ATTRIBUTE* X509_REQ_get_attr(const X509_REQ* req, int loc);
+    X509_ATTRIBUTE* X509_REQ_delete_attr(X509_REQ* req, int loc);
+    int X509_REQ_add1_attr(X509_REQ* req, X509_ATTRIBUTE* attr);
+    int X509_REQ_add1_attr_by_OBJ(X509_REQ* req, const ASN1_OBJECT* obj, int type, const unsigned char* bytes, int len);
+    int X509_REQ_add1_attr_by_NID(X509_REQ* req, int nid, int type, const unsigned char* bytes, int len);
+    int X509_REQ_add1_attr_by_txt(X509_REQ* req, const char* attrname, int type, const unsigned char* bytes, int len);
 
 #define X509_CRL_VERSION_1 0
 #define X509_CRL_VERSION_2 1
 
-int X509_CRL_set_version(X509_CRL *x, long version);
-int X509_CRL_set_issuer_name(X509_CRL *x, const X509_NAME *name);
-int X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);
-int X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);
-int X509_CRL_sort(X509_CRL *crl);
-int X509_CRL_up_ref(X509_CRL *crl);
+    int X509_CRL_set_version(X509_CRL* x, long version);
+    int X509_CRL_set_issuer_name(X509_CRL* x, const X509_NAME* name);
+    int X509_CRL_set1_lastUpdate(X509_CRL* x, const ASN1_TIME* tm);
+    int X509_CRL_set1_nextUpdate(X509_CRL* x, const ASN1_TIME* tm);
+    int X509_CRL_sort(X509_CRL* crl);
+    int X509_CRL_up_ref(X509_CRL* crl);
 
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define X509_CRL_set_lastUpdate X509_CRL_set1_lastUpdate
-#  define X509_CRL_set_nextUpdate X509_CRL_set1_nextUpdate
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define X509_CRL_set_lastUpdate X509_CRL_set1_lastUpdate
+#define X509_CRL_set_nextUpdate X509_CRL_set1_nextUpdate
 #endif
 
-long X509_CRL_get_version(const X509_CRL *crl);
-const ASN1_TIME *X509_CRL_get0_lastUpdate(const X509_CRL *crl);
-const ASN1_TIME *X509_CRL_get0_nextUpdate(const X509_CRL *crl);
+    long X509_CRL_get_version(const X509_CRL* crl);
+    const ASN1_TIME* X509_CRL_get0_lastUpdate(const X509_CRL* crl);
+    const ASN1_TIME* X509_CRL_get0_nextUpdate(const X509_CRL* crl);
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-OSSL_DEPRECATEDIN_1_1_0 ASN1_TIME *X509_CRL_get_lastUpdate(X509_CRL *crl);
-OSSL_DEPRECATEDIN_1_1_0 ASN1_TIME *X509_CRL_get_nextUpdate(X509_CRL *crl);
+    OSSL_DEPRECATEDIN_1_1_0 ASN1_TIME* X509_CRL_get_lastUpdate(X509_CRL* crl);
+    OSSL_DEPRECATEDIN_1_1_0 ASN1_TIME* X509_CRL_get_nextUpdate(X509_CRL* crl);
+#endif
+    X509_NAME* X509_CRL_get_issuer(const X509_CRL* crl);
+    const STACK_OF(X509_EXTENSION) * X509_CRL_get0_extensions(const X509_CRL* crl);
+    STACK_OF(X509_REVOKED) * X509_CRL_get_REVOKED(X509_CRL* crl);
+    void X509_CRL_get0_signature(const X509_CRL* crl, const ASN1_BIT_STRING** psig, const X509_ALGOR** palg);
+    int X509_CRL_get_signature_nid(const X509_CRL* crl);
+    int i2d_re_X509_CRL_tbs(X509_CRL* req, unsigned char** pp);
+
+    const ASN1_INTEGER* X509_REVOKED_get0_serialNumber(const X509_REVOKED* x);
+    int X509_REVOKED_set_serialNumber(X509_REVOKED* x, ASN1_INTEGER* serial);
+    const ASN1_TIME* X509_REVOKED_get0_revocationDate(const X509_REVOKED* x);
+    int X509_REVOKED_set_revocationDate(X509_REVOKED* r, ASN1_TIME* tm);
+    const STACK_OF(X509_EXTENSION) *
+        X509_REVOKED_get0_extensions(const X509_REVOKED* r);
+
+    X509_CRL* X509_CRL_diff(X509_CRL* base, X509_CRL* newer, EVP_PKEY* skey, const EVP_MD* md, unsigned int flags);
+
+    int X509_REQ_check_private_key(X509_REQ* x509, EVP_PKEY* pkey);
+
+    int X509_check_private_key(const X509* x509, const EVP_PKEY* pkey);
+    int X509_chain_check_suiteb(int* perror_depth, X509* x, STACK_OF(X509) * chain, unsigned long flags);
+    int X509_CRL_check_suiteb(X509_CRL* crl, EVP_PKEY* pk, unsigned long flags);
+    STACK_OF(X509) * X509_chain_up_ref(STACK_OF(X509) * chain);
+
+    int X509_issuer_and_serial_cmp(const X509* a, const X509* b);
+    unsigned long X509_issuer_and_serial_hash(X509* a);
+
+    int X509_issuer_name_cmp(const X509* a, const X509* b);
+    unsigned long X509_issuer_name_hash(X509* a);
+
+    int X509_subject_name_cmp(const X509* a, const X509* b);
+    unsigned long X509_subject_name_hash(X509* x);
+
+#ifndef OPENSSL_NO_MD5
+    unsigned long X509_issuer_name_hash_old(X509* a);
+    unsigned long X509_subject_name_hash_old(X509* x);
 #endif
-X509_NAME *X509_CRL_get_issuer(const X509_CRL *crl);
-const STACK_OF(X509_EXTENSION) *X509_CRL_get0_extensions(const X509_CRL *crl);
-STACK_OF(X509_REVOKED) *X509_CRL_get_REVOKED(X509_CRL *crl);
-void X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
-                             const X509_ALGOR **palg);
-int X509_CRL_get_signature_nid(const X509_CRL *crl);
-int i2d_re_X509_CRL_tbs(X509_CRL *req, unsigned char **pp);
-
-const ASN1_INTEGER *X509_REVOKED_get0_serialNumber(const X509_REVOKED *x);
-int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial);
-const ASN1_TIME *X509_REVOKED_get0_revocationDate(const X509_REVOKED *x);
-int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm);
-const STACK_OF(X509_EXTENSION) *
-X509_REVOKED_get0_extensions(const X509_REVOKED *r);
-
-X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer,
-                        EVP_PKEY *skey, const EVP_MD *md, unsigned int flags);
-
-int X509_REQ_check_private_key(X509_REQ *x509, EVP_PKEY *pkey);
-
-int X509_check_private_key(const X509 *x509, const EVP_PKEY *pkey);
-int X509_chain_check_suiteb(int *perror_depth,
-                            X509 *x, STACK_OF(X509) *chain,
-                            unsigned long flags);
-int X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk, unsigned long flags);
-STACK_OF(X509) *X509_chain_up_ref(STACK_OF(X509) *chain);
-
-int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);
-unsigned long X509_issuer_and_serial_hash(X509 *a);
-
-int X509_issuer_name_cmp(const X509 *a, const X509 *b);
-unsigned long X509_issuer_name_hash(X509 *a);
-
-int X509_subject_name_cmp(const X509 *a, const X509 *b);
-unsigned long X509_subject_name_hash(X509 *x);
-
-# ifndef OPENSSL_NO_MD5
-unsigned long X509_issuer_name_hash_old(X509 *a);
-unsigned long X509_subject_name_hash_old(X509 *x);
-# endif
-
-# define X509_ADD_FLAG_DEFAULT  0
-# define X509_ADD_FLAG_UP_REF   0x1
-# define X509_ADD_FLAG_PREPEND  0x2
-# define X509_ADD_FLAG_NO_DUP   0x4
-# define X509_ADD_FLAG_NO_SS    0x8
-int X509_add_cert(STACK_OF(X509) *sk, X509 *cert, int flags);
-int X509_add_certs(STACK_OF(X509) *sk, STACK_OF(X509) *certs, int flags);
-
-int X509_cmp(const X509 *a, const X509 *b);
-int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);
+
+#define X509_ADD_FLAG_DEFAULT 0
+#define X509_ADD_FLAG_UP_REF 0x1
+#define X509_ADD_FLAG_PREPEND 0x2
+#define X509_ADD_FLAG_NO_DUP 0x4
+#define X509_ADD_FLAG_NO_SS 0x8
+    int X509_add_cert(STACK_OF(X509) * sk, X509* cert, int flags);
+    int X509_add_certs(STACK_OF(X509) * sk, STACK_OF(X509) * certs, int flags);
+
+    int X509_cmp(const X509* a, const X509* b);
+    int X509_NAME_cmp(const X509_NAME* a, const X509_NAME* b);
 #ifndef OPENSSL_NO_DEPRECATED_3_0
-# define X509_NAME_hash(x) X509_NAME_hash_ex(x, NULL, NULL, NULL)
-OSSL_DEPRECATEDIN_3_0 int X509_certificate_type(const X509 *x,
-                                                const EVP_PKEY *pubkey);
+#define X509_NAME_hash(x) X509_NAME_hash_ex(x, NULL, NULL, NULL)
+    OSSL_DEPRECATEDIN_3_0 int X509_certificate_type(const X509* x, const EVP_PKEY* pubkey);
+#endif
+    unsigned long X509_NAME_hash_ex(const X509_NAME* x, OSSL_LIB_CTX* libctx, const char* propq, int* ok);
+    unsigned long X509_NAME_hash_old(const X509_NAME* x);
+
+    int X509_CRL_cmp(const X509_CRL* a, const X509_CRL* b);
+    int X509_CRL_match(const X509_CRL* a, const X509_CRL* b);
+    int X509_aux_print(BIO* out, X509* x, int indent);
+#ifndef OPENSSL_NO_STDIO
+    int X509_print_ex_fp(FILE* bp, X509* x, unsigned long nmflag, unsigned long cflag);
+    int X509_print_fp(FILE* bp, X509* x);
+    int X509_CRL_print_fp(FILE* bp, X509_CRL* x);
+    int X509_REQ_print_fp(FILE* bp, X509_REQ* req);
+    int X509_NAME_print_ex_fp(FILE* fp, const X509_NAME* nm, int indent, unsigned long flags);
 #endif
-unsigned long X509_NAME_hash_ex(const X509_NAME *x, OSSL_LIB_CTX *libctx,
-                                const char *propq, int *ok);
-unsigned long X509_NAME_hash_old(const X509_NAME *x);
-
-int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);
-int X509_CRL_match(const X509_CRL *a, const X509_CRL *b);
-int X509_aux_print(BIO *out, X509 *x, int indent);
-# ifndef OPENSSL_NO_STDIO
-int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag,
-                     unsigned long cflag);
-int X509_print_fp(FILE *bp, X509 *x);
-int X509_CRL_print_fp(FILE *bp, X509_CRL *x);
-int X509_REQ_print_fp(FILE *bp, X509_REQ *req);
-int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
-                          unsigned long flags);
-# endif
-
-int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase);
-int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent,
-                       unsigned long flags);
-int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag,
-                  unsigned long cflag);
-int X509_print(BIO *bp, X509 *x);
-int X509_ocspid_print(BIO *bp, X509 *x);
-int X509_CRL_print_ex(BIO *out, X509_CRL *x, unsigned long nmflag);
-int X509_CRL_print(BIO *bp, X509_CRL *x);
-int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag,
-                      unsigned long cflag);
-int X509_REQ_print(BIO *bp, X509_REQ *req);
-
-int X509_NAME_entry_count(const X509_NAME *name);
-int X509_NAME_get_text_by_NID(const X509_NAME *name, int nid,
-                              char *buf, int len);
-int X509_NAME_get_text_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
-                              char *buf, int len);
 
-/*
- * NOTE: you should be passing -1, not 0 as lastpos. The functions that use
- * lastpos, search after that position on.
- */
-int X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos);
-int X509_NAME_get_index_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
-                               int lastpos);
-X509_NAME_ENTRY *X509_NAME_get_entry(const X509_NAME *name, int loc);
-X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);
-int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *ne,
-                        int loc, int set);
-int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
-                               const unsigned char *bytes, int len, int loc,
-                               int set);
-int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
-                               const unsigned char *bytes, int len, int loc,
-                               int set);
-X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
-                                               const char *field, int type,
-                                               const unsigned char *bytes,
-                                               int len);
-X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
-                                               int type,
-                                               const unsigned char *bytes,
-                                               int len);
-int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
-                               const unsigned char *bytes, int len, int loc,
-                               int set);
-X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
-                                               const ASN1_OBJECT *obj, int type,
-                                               const unsigned char *bytes,
-                                               int len);
-int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj);
-int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
-                             const unsigned char *bytes, int len);
-ASN1_OBJECT *X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne);
-ASN1_STRING * X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne);
-int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne);
-
-int X509_NAME_get0_der(const X509_NAME *nm, const unsigned char **pder,
-                       size_t *pderlen);
-
-int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x);
-int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x,
-                          int nid, int lastpos);
-int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x,
-                          const ASN1_OBJECT *obj, int lastpos);
-int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x,
-                               int crit, int lastpos);
-X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc);
-X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc);
-STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x,
-                                         X509_EXTENSION *ex, int loc);
-
-int X509_get_ext_count(const X509 *x);
-int X509_get_ext_by_NID(const X509 *x, int nid, int lastpos);
-int X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos);
-int X509_get_ext_by_critical(const X509 *x, int crit, int lastpos);
-X509_EXTENSION *X509_get_ext(const X509 *x, int loc);
-X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
-int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
-void *X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx);
-int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit,
-                      unsigned long flags);
-
-int X509_CRL_get_ext_count(const X509_CRL *x);
-int X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos);
-int X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj,
-                            int lastpos);
-int X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos);
-X509_EXTENSION *X509_CRL_get_ext(const X509_CRL *x, int loc);
-X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);
-int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);
-void *X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx);
-int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
-                          unsigned long flags);
-
-int X509_REVOKED_get_ext_count(const X509_REVOKED *x);
-int X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos);
-int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
-                                int lastpos);
-int X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit,
-                                     int lastpos);
-X509_EXTENSION *X509_REVOKED_get_ext(const X509_REVOKED *x, int loc);
-X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);
-int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc);
-void *X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit,
-                               int *idx);
-int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
-                              unsigned long flags);
-
-X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,
-                                             int nid, int crit,
-                                             ASN1_OCTET_STRING *data);
-X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
-                                             const ASN1_OBJECT *obj, int crit,
-                                             ASN1_OCTET_STRING *data);
-int X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj);
-int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);
-int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data);
-ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex);
-ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
-int X509_EXTENSION_get_critical(const X509_EXTENSION *ex);
-
-int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x);
-int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
-                           int lastpos);
-int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
-                           const ASN1_OBJECT *obj, int lastpos);
-X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc);
-X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc);
-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
-                                           X509_ATTRIBUTE *attr);
-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)
-                                                  **x, const ASN1_OBJECT *obj,
-                                                  int type,
-                                                  const unsigned char *bytes,
-                                                  int len);
-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)
-                                                  **x, int nid, int type,
-                                                  const unsigned char *bytes,
-                                                  int len);
-STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)
-                                                  **x, const char *attrname,
-                                                  int type,
-                                                  const unsigned char *bytes,
-                                                  int len);
-void *X509at_get0_data_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *x,
-                              const ASN1_OBJECT *obj, int lastpos, int type);
-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
-                                             int atrtype, const void *data,
-                                             int len);
-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
-                                             const ASN1_OBJECT *obj,
-                                             int atrtype, const void *data,
-                                             int len);
-X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
-                                             const char *atrname, int type,
-                                             const unsigned char *bytes,
-                                             int len);
-int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj);
-int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
-                             const void *data, int len);
-void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype,
-                               void *data);
-int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr);
-ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr);
-ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx);
-
-int EVP_PKEY_get_attr_count(const EVP_PKEY *key);
-int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos);
-int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj,
-                             int lastpos);
-X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc);
-X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc);
-int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr);
-int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,
-                              const ASN1_OBJECT *obj, int type,
-                              const unsigned char *bytes, int len);
-int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,
-                              int nid, int type,
-                              const unsigned char *bytes, int len);
-int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,
-                              const char *attrname, int type,
-                              const unsigned char *bytes, int len);
-
-/* lookup a cert from a X509 STACK */
-X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, const X509_NAME *name,
-                                     const ASN1_INTEGER *serial);
-X509 *X509_find_by_subject(STACK_OF(X509) *sk, const X509_NAME *name);
-
-DECLARE_ASN1_FUNCTIONS(PBEPARAM)
-DECLARE_ASN1_FUNCTIONS(PBE2PARAM)
-DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM)
+    int X509_NAME_print(BIO* bp, const X509_NAME* name, int obase);
+    int X509_NAME_print_ex(BIO* out, const X509_NAME* nm, int indent, unsigned long flags);
+    int X509_print_ex(BIO* bp, X509* x, unsigned long nmflag, unsigned long cflag);
+    int X509_print(BIO* bp, X509* x);
+    int X509_ocspid_print(BIO* bp, X509* x);
+    int X509_CRL_print_ex(BIO* out, X509_CRL* x, unsigned long nmflag);
+    int X509_CRL_print(BIO* bp, X509_CRL* x);
+    int X509_REQ_print_ex(BIO* bp, X509_REQ* x, unsigned long nmflag, unsigned long cflag);
+    int X509_REQ_print(BIO* bp, X509_REQ* req);
+
+    int X509_NAME_entry_count(const X509_NAME* name);
+    int X509_NAME_get_text_by_NID(const X509_NAME* name, int nid, char* buf, int len);
+    int X509_NAME_get_text_by_OBJ(const X509_NAME* name, const ASN1_OBJECT* obj, char* buf, int len);
+
+    /*
+     * NOTE: you should be passing -1, not 0 as lastpos. The functions that use
+     * lastpos, search after that position on.
+     */
+    int X509_NAME_get_index_by_NID(const X509_NAME* name, int nid, int lastpos);
+    int X509_NAME_get_index_by_OBJ(const X509_NAME* name, const ASN1_OBJECT* obj, int lastpos);
+    X509_NAME_ENTRY* X509_NAME_get_entry(const X509_NAME* name, int loc);
+    X509_NAME_ENTRY* X509_NAME_delete_entry(X509_NAME* name, int loc);
+    int X509_NAME_add_entry(X509_NAME* name, const X509_NAME_ENTRY* ne, int loc, int set);
+    int X509_NAME_add_entry_by_OBJ(X509_NAME* name, const ASN1_OBJECT* obj, int type, const unsigned char* bytes, int len, int loc, int set);
+    int X509_NAME_add_entry_by_NID(X509_NAME* name, int nid, int type, const unsigned char* bytes, int len, int loc, int set);
+    X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY** ne, const char* field, int type, const unsigned char* bytes, int len);
+    X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY** ne, int nid, int type, const unsigned char* bytes, int len);
+    int X509_NAME_add_entry_by_txt(X509_NAME* name, const char* field, int type, const unsigned char* bytes, int len, int loc, int set);
+    X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY** ne, const ASN1_OBJECT* obj, int type, const unsigned char* bytes, int len);
+    int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY* ne, const ASN1_OBJECT* obj);
+    int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY* ne, int type, const unsigned char* bytes, int len);
+    ASN1_OBJECT* X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY* ne);
+    ASN1_STRING* X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY* ne);
+    int X509_NAME_ENTRY_set(const X509_NAME_ENTRY* ne);
+
+    int X509_NAME_get0_der(const X509_NAME* nm, const unsigned char** pder, size_t* pderlen);
+
+    int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) * x);
+    int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) * x, int nid, int lastpos);
+    int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) * x, const ASN1_OBJECT* obj, int lastpos);
+    int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) * x, int crit, int lastpos);
+    X509_EXTENSION* X509v3_get_ext(const STACK_OF(X509_EXTENSION) * x, int loc);
+    X509_EXTENSION* X509v3_delete_ext(STACK_OF(X509_EXTENSION) * x, int loc);
+    STACK_OF(X509_EXTENSION) * X509v3_add_ext(STACK_OF(X509_EXTENSION) * *x, X509_EXTENSION* ex, int loc);
+
+    int X509_get_ext_count(const X509* x);
+    int X509_get_ext_by_NID(const X509* x, int nid, int lastpos);
+    int X509_get_ext_by_OBJ(const X509* x, const ASN1_OBJECT* obj, int lastpos);
+    int X509_get_ext_by_critical(const X509* x, int crit, int lastpos);
+    X509_EXTENSION* X509_get_ext(const X509* x, int loc);
+    X509_EXTENSION* X509_delete_ext(X509* x, int loc);
+    int X509_add_ext(X509* x, X509_EXTENSION* ex, int loc);
+    void* X509_get_ext_d2i(const X509* x, int nid, int* crit, int* idx);
+    int X509_add1_ext_i2d(X509* x, int nid, void* value, int crit, unsigned long flags);
+
+    int X509_CRL_get_ext_count(const X509_CRL* x);
+    int X509_CRL_get_ext_by_NID(const X509_CRL* x, int nid, int lastpos);
+    int X509_CRL_get_ext_by_OBJ(const X509_CRL* x, const ASN1_OBJECT* obj, int lastpos);
+    int X509_CRL_get_ext_by_critical(const X509_CRL* x, int crit, int lastpos);
+    X509_EXTENSION* X509_CRL_get_ext(const X509_CRL* x, int loc);
+    X509_EXTENSION* X509_CRL_delete_ext(X509_CRL* x, int loc);
+    int X509_CRL_add_ext(X509_CRL* x, X509_EXTENSION* ex, int loc);
+    void* X509_CRL_get_ext_d2i(const X509_CRL* x, int nid, int* crit, int* idx);
+    int X509_CRL_add1_ext_i2d(X509_CRL* x, int nid, void* value, int crit, unsigned long flags);
+
+    int X509_REVOKED_get_ext_count(const X509_REVOKED* x);
+    int X509_REVOKED_get_ext_by_NID(const X509_REVOKED* x, int nid, int lastpos);
+    int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED* x, const ASN1_OBJECT* obj, int lastpos);
+    int X509_REVOKED_get_ext_by_critical(const X509_REVOKED* x, int crit, int lastpos);
+    X509_EXTENSION* X509_REVOKED_get_ext(const X509_REVOKED* x, int loc);
+    X509_EXTENSION* X509_REVOKED_delete_ext(X509_REVOKED* x, int loc);
+    int X509_REVOKED_add_ext(X509_REVOKED* x, X509_EXTENSION* ex, int loc);
+    void* X509_REVOKED_get_ext_d2i(const X509_REVOKED* x, int nid, int* crit, int* idx);
+    int X509_REVOKED_add1_ext_i2d(X509_REVOKED* x, int nid, void* value, int crit, unsigned long flags);
+
+    X509_EXTENSION* X509_EXTENSION_create_by_NID(X509_EXTENSION** ex, int nid, int crit, ASN1_OCTET_STRING* data);
+    X509_EXTENSION* X509_EXTENSION_create_by_OBJ(X509_EXTENSION** ex, const ASN1_OBJECT* obj, int crit, ASN1_OCTET_STRING* data);
+    int X509_EXTENSION_set_object(X509_EXTENSION* ex, const ASN1_OBJECT* obj);
+    int X509_EXTENSION_set_critical(X509_EXTENSION* ex, int crit);
+    int X509_EXTENSION_set_data(X509_EXTENSION* ex, ASN1_OCTET_STRING* data);
+    ASN1_OBJECT* X509_EXTENSION_get_object(X509_EXTENSION* ex);
+    ASN1_OCTET_STRING* X509_EXTENSION_get_data(X509_EXTENSION* ne);
+    int X509_EXTENSION_get_critical(const X509_EXTENSION* ex);
+
+    int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) * x);
+    int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) * x, int nid, int lastpos);
+    int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) * sk, const ASN1_OBJECT* obj, int lastpos);
+    X509_ATTRIBUTE* X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) * x, int loc);
+    X509_ATTRIBUTE* X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) * x, int loc);
+    STACK_OF(X509_ATTRIBUTE) * X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) * *x, X509_ATTRIBUTE* attr);
+    STACK_OF(X509_ATTRIBUTE) * X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) * *x, const ASN1_OBJECT* obj, int type, const unsigned char* bytes, int len);
+    STACK_OF(X509_ATTRIBUTE) * X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) * *x, int nid, int type, const unsigned char* bytes, int len);
+    STACK_OF(X509_ATTRIBUTE) * X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) * *x, const char* attrname, int type, const unsigned char* bytes, int len);
+    void* X509at_get0_data_by_OBJ(const STACK_OF(X509_ATTRIBUTE) * x, const ASN1_OBJECT* obj, int lastpos, int type);
+    X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE** attr, int nid, int atrtype, const void* data, int len);
+    X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE** attr, const ASN1_OBJECT* obj, int atrtype, const void* data, int len);
+    X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE** attr, const char* atrname, int type, const unsigned char* bytes, int len);
+    int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE* attr, const ASN1_OBJECT* obj);
+    int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE* attr, int attrtype, const void* data, int len);
+    void* X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE* attr, int idx, int atrtype, void* data);
+    int X509_ATTRIBUTE_count(const X509_ATTRIBUTE* attr);
+    ASN1_OBJECT* X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE* attr);
+    ASN1_TYPE* X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE* attr, int idx);
+
+    int EVP_PKEY_get_attr_count(const EVP_PKEY* key);
+    int EVP_PKEY_get_attr_by_NID(const EVP_PKEY* key, int nid, int lastpos);
+    int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY* key, const ASN1_OBJECT* obj, int lastpos);
+    X509_ATTRIBUTE* EVP_PKEY_get_attr(const EVP_PKEY* key, int loc);
+    X509_ATTRIBUTE* EVP_PKEY_delete_attr(EVP_PKEY* key, int loc);
+    int EVP_PKEY_add1_attr(EVP_PKEY* key, X509_ATTRIBUTE* attr);
+    int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY* key, const ASN1_OBJECT* obj, int type, const unsigned char* bytes, int len);
+    int EVP_PKEY_add1_attr_by_NID(EVP_PKEY* key, int nid, int type, const unsigned char* bytes, int len);
+    int EVP_PKEY_add1_attr_by_txt(EVP_PKEY* key, const char* attrname, int type, const unsigned char* bytes, int len);
+
+    /* lookup a cert from a X509 STACK */
+    X509* X509_find_by_issuer_and_serial(STACK_OF(X509) * sk, const X509_NAME* name, const ASN1_INTEGER* serial);
+    X509* X509_find_by_subject(STACK_OF(X509) * sk, const X509_NAME* name);
+
+    DECLARE_ASN1_FUNCTIONS(PBEPARAM)
+    DECLARE_ASN1_FUNCTIONS(PBE2PARAM)
+    DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM)
 #ifndef OPENSSL_NO_SCRYPT
-DECLARE_ASN1_FUNCTIONS(SCRYPT_PARAMS)
+    DECLARE_ASN1_FUNCTIONS(SCRYPT_PARAMS)
 #endif
 
-int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
-                         const unsigned char *salt, int saltlen);
-int PKCS5_pbe_set0_algor_ex(X509_ALGOR *algor, int alg, int iter,
-                            const unsigned char *salt, int saltlen,
-                            OSSL_LIB_CTX *libctx);
-
-X509_ALGOR *PKCS5_pbe_set(int alg, int iter,
-                          const unsigned char *salt, int saltlen);
-X509_ALGOR *PKCS5_pbe_set_ex(int alg, int iter,
-                             const unsigned char *salt, int saltlen,
-                             OSSL_LIB_CTX *libctx);
-
-X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
-                           unsigned char *salt, int saltlen);
-X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,
-                              unsigned char *salt, int saltlen,
-                              unsigned char *aiv, int prf_nid);
-X509_ALGOR *PKCS5_pbe2_set_iv_ex(const EVP_CIPHER *cipher, int iter,
-                                 unsigned char *salt, int saltlen,
-                                 unsigned char *aiv, int prf_nid,
-                                 OSSL_LIB_CTX *libctx);
+    int PKCS5_pbe_set0_algor(X509_ALGOR* algor, int alg, int iter, const unsigned char* salt, int saltlen);
+    int PKCS5_pbe_set0_algor_ex(X509_ALGOR* algor, int alg, int iter, const unsigned char* salt, int saltlen, OSSL_LIB_CTX* libctx);
+
+    X509_ALGOR* PKCS5_pbe_set(int alg, int iter, const unsigned char* salt, int saltlen);
+    X509_ALGOR* PKCS5_pbe_set_ex(int alg, int iter, const unsigned char* salt, int saltlen, OSSL_LIB_CTX* libctx);
+
+    X509_ALGOR* PKCS5_pbe2_set(const EVP_CIPHER* cipher, int iter, unsigned char* salt, int saltlen);
+    X509_ALGOR* PKCS5_pbe2_set_iv(const EVP_CIPHER* cipher, int iter, unsigned char* salt, int saltlen, unsigned char* aiv, int prf_nid);
+    X509_ALGOR* PKCS5_pbe2_set_iv_ex(const EVP_CIPHER* cipher, int iter, unsigned char* salt, int saltlen, unsigned char* aiv, int prf_nid, OSSL_LIB_CTX* libctx);
 
 #ifndef OPENSSL_NO_SCRYPT
-X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher,
-                                  const unsigned char *salt, int saltlen,
-                                  unsigned char *aiv, uint64_t N, uint64_t r,
-                                  uint64_t p);
+    X509_ALGOR* PKCS5_pbe2_set_scrypt(const EVP_CIPHER* cipher, const unsigned char* salt, int saltlen, unsigned char* aiv, uint64_t N, uint64_t r, uint64_t p);
 #endif
 
-X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
-                             int prf_nid, int keylen);
-X509_ALGOR *PKCS5_pbkdf2_set_ex(int iter, unsigned char *salt, int saltlen,
-                                int prf_nid, int keylen,
-                                OSSL_LIB_CTX *libctx);
-
-/* PKCS#8 utilities */
-
-DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO)
-
-EVP_PKEY *EVP_PKCS82PKEY(const PKCS8_PRIV_KEY_INFO *p8);
-EVP_PKEY *EVP_PKCS82PKEY_ex(const PKCS8_PRIV_KEY_INFO *p8, OSSL_LIB_CTX *libctx,
-                            const char *propq);
-PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(const EVP_PKEY *pkey);
-
-int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj,
-                    int version, int ptype, void *pval,
-                    unsigned char *penc, int penclen);
-int PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg,
-                    const unsigned char **pk, int *ppklen,
-                    const X509_ALGOR **pa, const PKCS8_PRIV_KEY_INFO *p8);
-
-const STACK_OF(X509_ATTRIBUTE) *
-PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8);
-int PKCS8_pkey_add1_attr(PKCS8_PRIV_KEY_INFO *p8, X509_ATTRIBUTE *attr);
-int PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
-                                const unsigned char *bytes, int len);
-int PKCS8_pkey_add1_attr_by_OBJ(PKCS8_PRIV_KEY_INFO *p8, const ASN1_OBJECT *obj,
-                                int type, const unsigned char *bytes, int len);
-
-
-int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
-                           int ptype, void *pval,
-                           unsigned char *penc, int penclen);
-int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
-                           const unsigned char **pk, int *ppklen,
-                           X509_ALGOR **pa, const X509_PUBKEY *pub);
-int X509_PUBKEY_eq(const X509_PUBKEY *a, const X509_PUBKEY *b);
-
-# ifdef  __cplusplus
+    X509_ALGOR* PKCS5_pbkdf2_set(int iter, unsigned char* salt, int saltlen, int prf_nid, int keylen);
+    X509_ALGOR* PKCS5_pbkdf2_set_ex(int iter, unsigned char* salt, int saltlen, int prf_nid, int keylen, OSSL_LIB_CTX* libctx);
+
+    /* PKCS#8 utilities */
+
+    DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO)
+
+    EVP_PKEY* EVP_PKCS82PKEY(const PKCS8_PRIV_KEY_INFO* p8);
+    EVP_PKEY* EVP_PKCS82PKEY_ex(const PKCS8_PRIV_KEY_INFO* p8, OSSL_LIB_CTX* libctx, const char* propq);
+    PKCS8_PRIV_KEY_INFO* EVP_PKEY2PKCS8(const EVP_PKEY* pkey);
+
+    int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO* priv, ASN1_OBJECT* aobj, int version, int ptype, void* pval, unsigned char* penc, int penclen);
+    int PKCS8_pkey_get0(const ASN1_OBJECT** ppkalg, const unsigned char** pk, int* ppklen, const X509_ALGOR** pa, const PKCS8_PRIV_KEY_INFO* p8);
+
+    const STACK_OF(X509_ATTRIBUTE) *
+        PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO* p8);
+    int PKCS8_pkey_add1_attr(PKCS8_PRIV_KEY_INFO* p8, X509_ATTRIBUTE* attr);
+    int PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO* p8, int nid, int type, const unsigned char* bytes, int len);
+    int PKCS8_pkey_add1_attr_by_OBJ(PKCS8_PRIV_KEY_INFO* p8, const ASN1_OBJECT* obj, int type, const unsigned char* bytes, int len);
+
+    int X509_PUBKEY_set0_param(X509_PUBKEY* pub, ASN1_OBJECT* aobj, int ptype, void* pval, unsigned char* penc, int penclen);
+    int X509_PUBKEY_get0_param(ASN1_OBJECT** ppkalg, const unsigned char** pk, int* ppklen, X509_ALGOR** pa, const X509_PUBKEY* pub);
+    int X509_PUBKEY_eq(const X509_PUBKEY* a, const X509_PUBKEY* b);
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509_vfy.h b/CAPI/cpp/grpc/include/openssl/x509_vfy.h
index e04df0d..0f0d627 100644
--- a/CAPI/cpp/grpc/include/openssl/x509_vfy.h
+++ b/CAPI/cpp/grpc/include/openssl/x509_vfy.h
@@ -10,885 +10,772 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_X509_VFY_H
-# define OPENSSL_X509_VFY_H
-# pragma once
+#define OPENSSL_X509_VFY_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_X509_VFY_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_X509_VFY_H
+#endif
 
 /*
  * Protect against recursion, x509.h and x509_vfy.h each include the other.
  */
-# ifndef OPENSSL_X509_H
-#  include <openssl/x509.h>
-# endif
-
-# include <openssl/opensslconf.h>
-# include <openssl/lhash.h>
-# include <openssl/bio.h>
-# include <openssl/crypto.h>
-# include <openssl/symhacks.h>
-
-#ifdef  __cplusplus
-extern "C" {
+#ifndef OPENSSL_X509_H
+#include <openssl/x509.h>
 #endif
 
-/*-
-SSL_CTX -> X509_STORE
-                -> X509_LOOKUP
-                        ->X509_LOOKUP_METHOD
-                -> X509_LOOKUP
-                        ->X509_LOOKUP_METHOD
+#include <openssl/opensslconf.h>
+#include <openssl/lhash.h>
+#include <openssl/bio.h>
+#include <openssl/crypto.h>
+#include <openssl/symhacks.h>
 
-SSL     -> X509_STORE_CTX
-                ->X509_STORE
-
-The X509_STORE holds the tables etc for verification stuff.
-A X509_STORE_CTX is used while validating a single certificate.
-The X509_STORE has X509_LOOKUPs for looking up certs.
-The X509_STORE then calls a function to actually verify the
-certificate chain.
-*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
 
-typedef enum {
-    X509_LU_NONE = 0,
-    X509_LU_X509, X509_LU_CRL
-} X509_LOOKUP_TYPE;
+    /*-
+    SSL_CTX -> X509_STORE
+                    -> X509_LOOKUP
+                            ->X509_LOOKUP_METHOD
+                    -> X509_LOOKUP
+                            ->X509_LOOKUP_METHOD
+
+    SSL     -> X509_STORE_CTX
+                    ->X509_STORE
+
+    The X509_STORE holds the tables etc for verification stuff.
+    A X509_STORE_CTX is used while validating a single certificate.
+    The X509_STORE has X509_LOOKUPs for looking up certs.
+    The X509_STORE then calls a function to actually verify the
+    certificate chain.
+    */
+
+    typedef enum
+    {
+        X509_LU_NONE = 0,
+        X509_LU_X509,
+        X509_LU_CRL
+    } X509_LOOKUP_TYPE;
 
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#define X509_LU_RETRY   -1
-#define X509_LU_FAIL    0
+#define X509_LU_RETRY -1
+#define X509_LU_FAIL 0
 #endif
 
-SKM_DEFINE_STACK_OF_INTERNAL(X509_LOOKUP, X509_LOOKUP, X509_LOOKUP)
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_LOOKUP, X509_LOOKUP, X509_LOOKUP)
 #define sk_X509_LOOKUP_num(sk) OPENSSL_sk_num(ossl_check_const_X509_LOOKUP_sk_type(sk))
-#define sk_X509_LOOKUP_value(sk, idx) ((X509_LOOKUP *)OPENSSL_sk_value(ossl_check_const_X509_LOOKUP_sk_type(sk), (idx)))
-#define sk_X509_LOOKUP_new(cmp) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new(ossl_check_X509_LOOKUP_compfunc_type(cmp)))
-#define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new_null())
-#define sk_X509_LOOKUP_new_reserve(cmp, n) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_new_reserve(ossl_check_X509_LOOKUP_compfunc_type(cmp), (n)))
+#define sk_X509_LOOKUP_value(sk, idx) ((X509_LOOKUP*)OPENSSL_sk_value(ossl_check_const_X509_LOOKUP_sk_type(sk), (idx)))
+#define sk_X509_LOOKUP_new(cmp) ((STACK_OF(X509_LOOKUP)*)OPENSSL_sk_new(ossl_check_X509_LOOKUP_compfunc_type(cmp)))
+#define sk_X509_LOOKUP_new_null() ((STACK_OF(X509_LOOKUP)*)OPENSSL_sk_new_null())
+#define sk_X509_LOOKUP_new_reserve(cmp, n) ((STACK_OF(X509_LOOKUP)*)OPENSSL_sk_new_reserve(ossl_check_X509_LOOKUP_compfunc_type(cmp), (n)))
 #define sk_X509_LOOKUP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_LOOKUP_sk_type(sk), (n))
 #define sk_X509_LOOKUP_free(sk) OPENSSL_sk_free(ossl_check_X509_LOOKUP_sk_type(sk))
 #define sk_X509_LOOKUP_zero(sk) OPENSSL_sk_zero(ossl_check_X509_LOOKUP_sk_type(sk))
-#define sk_X509_LOOKUP_delete(sk, i) ((X509_LOOKUP *)OPENSSL_sk_delete(ossl_check_X509_LOOKUP_sk_type(sk), (i)))
-#define sk_X509_LOOKUP_delete_ptr(sk, ptr) ((X509_LOOKUP *)OPENSSL_sk_delete_ptr(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr)))
+#define sk_X509_LOOKUP_delete(sk, i) ((X509_LOOKUP*)OPENSSL_sk_delete(ossl_check_X509_LOOKUP_sk_type(sk), (i)))
+#define sk_X509_LOOKUP_delete_ptr(sk, ptr) ((X509_LOOKUP*)OPENSSL_sk_delete_ptr(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr)))
 #define sk_X509_LOOKUP_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
 #define sk_X509_LOOKUP_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
-#define sk_X509_LOOKUP_pop(sk) ((X509_LOOKUP *)OPENSSL_sk_pop(ossl_check_X509_LOOKUP_sk_type(sk)))
-#define sk_X509_LOOKUP_shift(sk) ((X509_LOOKUP *)OPENSSL_sk_shift(ossl_check_X509_LOOKUP_sk_type(sk)))
-#define sk_X509_LOOKUP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_LOOKUP_sk_type(sk),ossl_check_X509_LOOKUP_freefunc_type(freefunc))
+#define sk_X509_LOOKUP_pop(sk) ((X509_LOOKUP*)OPENSSL_sk_pop(ossl_check_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_shift(sk) ((X509_LOOKUP*)OPENSSL_sk_shift(ossl_check_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_freefunc_type(freefunc))
 #define sk_X509_LOOKUP_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr), (idx))
-#define sk_X509_LOOKUP_set(sk, idx, ptr) ((X509_LOOKUP *)OPENSSL_sk_set(ossl_check_X509_LOOKUP_sk_type(sk), (idx), ossl_check_X509_LOOKUP_type(ptr)))
+#define sk_X509_LOOKUP_set(sk, idx, ptr) ((X509_LOOKUP*)OPENSSL_sk_set(ossl_check_X509_LOOKUP_sk_type(sk), (idx), ossl_check_X509_LOOKUP_type(ptr)))
 #define sk_X509_LOOKUP_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
 #define sk_X509_LOOKUP_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr))
 #define sk_X509_LOOKUP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_type(ptr), pnum)
 #define sk_X509_LOOKUP_sort(sk) OPENSSL_sk_sort(ossl_check_X509_LOOKUP_sk_type(sk))
 #define sk_X509_LOOKUP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_LOOKUP_sk_type(sk))
-#define sk_X509_LOOKUP_dup(sk) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_dup(ossl_check_const_X509_LOOKUP_sk_type(sk)))
-#define sk_X509_LOOKUP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_LOOKUP) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_copyfunc_type(copyfunc), ossl_check_X509_LOOKUP_freefunc_type(freefunc)))
+#define sk_X509_LOOKUP_dup(sk) ((STACK_OF(X509_LOOKUP)*)OPENSSL_sk_dup(ossl_check_const_X509_LOOKUP_sk_type(sk)))
+#define sk_X509_LOOKUP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_LOOKUP)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_copyfunc_type(copyfunc), ossl_check_X509_LOOKUP_freefunc_type(freefunc)))
 #define sk_X509_LOOKUP_set_cmp_func(sk, cmp) ((sk_X509_LOOKUP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_LOOKUP_sk_type(sk), ossl_check_X509_LOOKUP_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(X509_OBJECT, X509_OBJECT, X509_OBJECT)
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_OBJECT, X509_OBJECT, X509_OBJECT)
 #define sk_X509_OBJECT_num(sk) OPENSSL_sk_num(ossl_check_const_X509_OBJECT_sk_type(sk))
-#define sk_X509_OBJECT_value(sk, idx) ((X509_OBJECT *)OPENSSL_sk_value(ossl_check_const_X509_OBJECT_sk_type(sk), (idx)))
-#define sk_X509_OBJECT_new(cmp) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new(ossl_check_X509_OBJECT_compfunc_type(cmp)))
-#define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new_null())
-#define sk_X509_OBJECT_new_reserve(cmp, n) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_new_reserve(ossl_check_X509_OBJECT_compfunc_type(cmp), (n)))
+#define sk_X509_OBJECT_value(sk, idx) ((X509_OBJECT*)OPENSSL_sk_value(ossl_check_const_X509_OBJECT_sk_type(sk), (idx)))
+#define sk_X509_OBJECT_new(cmp) ((STACK_OF(X509_OBJECT)*)OPENSSL_sk_new(ossl_check_X509_OBJECT_compfunc_type(cmp)))
+#define sk_X509_OBJECT_new_null() ((STACK_OF(X509_OBJECT)*)OPENSSL_sk_new_null())
+#define sk_X509_OBJECT_new_reserve(cmp, n) ((STACK_OF(X509_OBJECT)*)OPENSSL_sk_new_reserve(ossl_check_X509_OBJECT_compfunc_type(cmp), (n)))
 #define sk_X509_OBJECT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_OBJECT_sk_type(sk), (n))
 #define sk_X509_OBJECT_free(sk) OPENSSL_sk_free(ossl_check_X509_OBJECT_sk_type(sk))
 #define sk_X509_OBJECT_zero(sk) OPENSSL_sk_zero(ossl_check_X509_OBJECT_sk_type(sk))
-#define sk_X509_OBJECT_delete(sk, i) ((X509_OBJECT *)OPENSSL_sk_delete(ossl_check_X509_OBJECT_sk_type(sk), (i)))
-#define sk_X509_OBJECT_delete_ptr(sk, ptr) ((X509_OBJECT *)OPENSSL_sk_delete_ptr(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr)))
+#define sk_X509_OBJECT_delete(sk, i) ((X509_OBJECT*)OPENSSL_sk_delete(ossl_check_X509_OBJECT_sk_type(sk), (i)))
+#define sk_X509_OBJECT_delete_ptr(sk, ptr) ((X509_OBJECT*)OPENSSL_sk_delete_ptr(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr)))
 #define sk_X509_OBJECT_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
 #define sk_X509_OBJECT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
-#define sk_X509_OBJECT_pop(sk) ((X509_OBJECT *)OPENSSL_sk_pop(ossl_check_X509_OBJECT_sk_type(sk)))
-#define sk_X509_OBJECT_shift(sk) ((X509_OBJECT *)OPENSSL_sk_shift(ossl_check_X509_OBJECT_sk_type(sk)))
-#define sk_X509_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_OBJECT_sk_type(sk),ossl_check_X509_OBJECT_freefunc_type(freefunc))
+#define sk_X509_OBJECT_pop(sk) ((X509_OBJECT*)OPENSSL_sk_pop(ossl_check_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_shift(sk) ((X509_OBJECT*)OPENSSL_sk_shift(ossl_check_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_freefunc_type(freefunc))
 #define sk_X509_OBJECT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr), (idx))
-#define sk_X509_OBJECT_set(sk, idx, ptr) ((X509_OBJECT *)OPENSSL_sk_set(ossl_check_X509_OBJECT_sk_type(sk), (idx), ossl_check_X509_OBJECT_type(ptr)))
+#define sk_X509_OBJECT_set(sk, idx, ptr) ((X509_OBJECT*)OPENSSL_sk_set(ossl_check_X509_OBJECT_sk_type(sk), (idx), ossl_check_X509_OBJECT_type(ptr)))
 #define sk_X509_OBJECT_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
 #define sk_X509_OBJECT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr))
 #define sk_X509_OBJECT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_type(ptr), pnum)
 #define sk_X509_OBJECT_sort(sk) OPENSSL_sk_sort(ossl_check_X509_OBJECT_sk_type(sk))
 #define sk_X509_OBJECT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_OBJECT_sk_type(sk))
-#define sk_X509_OBJECT_dup(sk) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_dup(ossl_check_const_X509_OBJECT_sk_type(sk)))
-#define sk_X509_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_OBJECT) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_copyfunc_type(copyfunc), ossl_check_X509_OBJECT_freefunc_type(freefunc)))
+#define sk_X509_OBJECT_dup(sk) ((STACK_OF(X509_OBJECT)*)OPENSSL_sk_dup(ossl_check_const_X509_OBJECT_sk_type(sk)))
+#define sk_X509_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_OBJECT)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_copyfunc_type(copyfunc), ossl_check_X509_OBJECT_freefunc_type(freefunc)))
 #define sk_X509_OBJECT_set_cmp_func(sk, cmp) ((sk_X509_OBJECT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_OBJECT_sk_type(sk), ossl_check_X509_OBJECT_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(X509_VERIFY_PARAM, X509_VERIFY_PARAM, X509_VERIFY_PARAM)
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_VERIFY_PARAM, X509_VERIFY_PARAM, X509_VERIFY_PARAM)
 #define sk_X509_VERIFY_PARAM_num(sk) OPENSSL_sk_num(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk))
-#define sk_X509_VERIFY_PARAM_value(sk, idx) ((X509_VERIFY_PARAM *)OPENSSL_sk_value(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk), (idx)))
-#define sk_X509_VERIFY_PARAM_new(cmp) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new(ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp)))
-#define sk_X509_VERIFY_PARAM_new_null() ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new_null())
-#define sk_X509_VERIFY_PARAM_new_reserve(cmp, n) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_new_reserve(ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp), (n)))
+#define sk_X509_VERIFY_PARAM_value(sk, idx) ((X509_VERIFY_PARAM*)OPENSSL_sk_value(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk), (idx)))
+#define sk_X509_VERIFY_PARAM_new(cmp) ((STACK_OF(X509_VERIFY_PARAM)*)OPENSSL_sk_new(ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp)))
+#define sk_X509_VERIFY_PARAM_new_null() ((STACK_OF(X509_VERIFY_PARAM)*)OPENSSL_sk_new_null())
+#define sk_X509_VERIFY_PARAM_new_reserve(cmp, n) ((STACK_OF(X509_VERIFY_PARAM)*)OPENSSL_sk_new_reserve(ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp), (n)))
 #define sk_X509_VERIFY_PARAM_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (n))
 #define sk_X509_VERIFY_PARAM_free(sk) OPENSSL_sk_free(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
 #define sk_X509_VERIFY_PARAM_zero(sk) OPENSSL_sk_zero(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
-#define sk_X509_VERIFY_PARAM_delete(sk, i) ((X509_VERIFY_PARAM *)OPENSSL_sk_delete(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (i)))
-#define sk_X509_VERIFY_PARAM_delete_ptr(sk, ptr) ((X509_VERIFY_PARAM *)OPENSSL_sk_delete_ptr(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr)))
+#define sk_X509_VERIFY_PARAM_delete(sk, i) ((X509_VERIFY_PARAM*)OPENSSL_sk_delete(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (i)))
+#define sk_X509_VERIFY_PARAM_delete_ptr(sk, ptr) ((X509_VERIFY_PARAM*)OPENSSL_sk_delete_ptr(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr)))
 #define sk_X509_VERIFY_PARAM_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
 #define sk_X509_VERIFY_PARAM_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
-#define sk_X509_VERIFY_PARAM_pop(sk) ((X509_VERIFY_PARAM *)OPENSSL_sk_pop(ossl_check_X509_VERIFY_PARAM_sk_type(sk)))
-#define sk_X509_VERIFY_PARAM_shift(sk) ((X509_VERIFY_PARAM *)OPENSSL_sk_shift(ossl_check_X509_VERIFY_PARAM_sk_type(sk)))
-#define sk_X509_VERIFY_PARAM_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_VERIFY_PARAM_sk_type(sk),ossl_check_X509_VERIFY_PARAM_freefunc_type(freefunc))
+#define sk_X509_VERIFY_PARAM_pop(sk) ((X509_VERIFY_PARAM*)OPENSSL_sk_pop(ossl_check_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_shift(sk) ((X509_VERIFY_PARAM*)OPENSSL_sk_shift(ossl_check_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_freefunc_type(freefunc))
 #define sk_X509_VERIFY_PARAM_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr), (idx))
-#define sk_X509_VERIFY_PARAM_set(sk, idx, ptr) ((X509_VERIFY_PARAM *)OPENSSL_sk_set(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (idx), ossl_check_X509_VERIFY_PARAM_type(ptr)))
+#define sk_X509_VERIFY_PARAM_set(sk, idx, ptr) ((X509_VERIFY_PARAM*)OPENSSL_sk_set(ossl_check_X509_VERIFY_PARAM_sk_type(sk), (idx), ossl_check_X509_VERIFY_PARAM_type(ptr)))
 #define sk_X509_VERIFY_PARAM_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
 #define sk_X509_VERIFY_PARAM_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr))
 #define sk_X509_VERIFY_PARAM_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_type(ptr), pnum)
 #define sk_X509_VERIFY_PARAM_sort(sk) OPENSSL_sk_sort(ossl_check_X509_VERIFY_PARAM_sk_type(sk))
 #define sk_X509_VERIFY_PARAM_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk))
-#define sk_X509_VERIFY_PARAM_dup(sk) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_dup(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk)))
-#define sk_X509_VERIFY_PARAM_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_VERIFY_PARAM) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_copyfunc_type(copyfunc), ossl_check_X509_VERIFY_PARAM_freefunc_type(freefunc)))
+#define sk_X509_VERIFY_PARAM_dup(sk) ((STACK_OF(X509_VERIFY_PARAM)*)OPENSSL_sk_dup(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk)))
+#define sk_X509_VERIFY_PARAM_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_VERIFY_PARAM)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_copyfunc_type(copyfunc), ossl_check_X509_VERIFY_PARAM_freefunc_type(freefunc)))
 #define sk_X509_VERIFY_PARAM_set_cmp_func(sk, cmp) ((sk_X509_VERIFY_PARAM_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_VERIFY_PARAM_sk_type(sk), ossl_check_X509_VERIFY_PARAM_compfunc_type(cmp)))
 
-
-/* This is used for a table of trust checking functions */
-typedef struct x509_trust_st {
-    int trust;
-    int flags;
-    int (*check_trust) (struct x509_trust_st *, X509 *, int);
-    char *name;
-    int arg1;
-    void *arg2;
-} X509_TRUST;
-SKM_DEFINE_STACK_OF_INTERNAL(X509_TRUST, X509_TRUST, X509_TRUST)
+    /* This is used for a table of trust checking functions */
+    typedef struct x509_trust_st
+    {
+        int trust;
+        int flags;
+        int (*check_trust)(struct x509_trust_st*, X509*, int);
+        char* name;
+        int arg1;
+        void* arg2;
+    } X509_TRUST;
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_TRUST, X509_TRUST, X509_TRUST)
 #define sk_X509_TRUST_num(sk) OPENSSL_sk_num(ossl_check_const_X509_TRUST_sk_type(sk))
-#define sk_X509_TRUST_value(sk, idx) ((X509_TRUST *)OPENSSL_sk_value(ossl_check_const_X509_TRUST_sk_type(sk), (idx)))
-#define sk_X509_TRUST_new(cmp) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new(ossl_check_X509_TRUST_compfunc_type(cmp)))
-#define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new_null())
-#define sk_X509_TRUST_new_reserve(cmp, n) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_new_reserve(ossl_check_X509_TRUST_compfunc_type(cmp), (n)))
+#define sk_X509_TRUST_value(sk, idx) ((X509_TRUST*)OPENSSL_sk_value(ossl_check_const_X509_TRUST_sk_type(sk), (idx)))
+#define sk_X509_TRUST_new(cmp) ((STACK_OF(X509_TRUST)*)OPENSSL_sk_new(ossl_check_X509_TRUST_compfunc_type(cmp)))
+#define sk_X509_TRUST_new_null() ((STACK_OF(X509_TRUST)*)OPENSSL_sk_new_null())
+#define sk_X509_TRUST_new_reserve(cmp, n) ((STACK_OF(X509_TRUST)*)OPENSSL_sk_new_reserve(ossl_check_X509_TRUST_compfunc_type(cmp), (n)))
 #define sk_X509_TRUST_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_TRUST_sk_type(sk), (n))
 #define sk_X509_TRUST_free(sk) OPENSSL_sk_free(ossl_check_X509_TRUST_sk_type(sk))
 #define sk_X509_TRUST_zero(sk) OPENSSL_sk_zero(ossl_check_X509_TRUST_sk_type(sk))
-#define sk_X509_TRUST_delete(sk, i) ((X509_TRUST *)OPENSSL_sk_delete(ossl_check_X509_TRUST_sk_type(sk), (i)))
-#define sk_X509_TRUST_delete_ptr(sk, ptr) ((X509_TRUST *)OPENSSL_sk_delete_ptr(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr)))
+#define sk_X509_TRUST_delete(sk, i) ((X509_TRUST*)OPENSSL_sk_delete(ossl_check_X509_TRUST_sk_type(sk), (i)))
+#define sk_X509_TRUST_delete_ptr(sk, ptr) ((X509_TRUST*)OPENSSL_sk_delete_ptr(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr)))
 #define sk_X509_TRUST_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
 #define sk_X509_TRUST_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
-#define sk_X509_TRUST_pop(sk) ((X509_TRUST *)OPENSSL_sk_pop(ossl_check_X509_TRUST_sk_type(sk)))
-#define sk_X509_TRUST_shift(sk) ((X509_TRUST *)OPENSSL_sk_shift(ossl_check_X509_TRUST_sk_type(sk)))
-#define sk_X509_TRUST_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_TRUST_sk_type(sk),ossl_check_X509_TRUST_freefunc_type(freefunc))
+#define sk_X509_TRUST_pop(sk) ((X509_TRUST*)OPENSSL_sk_pop(ossl_check_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_shift(sk) ((X509_TRUST*)OPENSSL_sk_shift(ossl_check_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_freefunc_type(freefunc))
 #define sk_X509_TRUST_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr), (idx))
-#define sk_X509_TRUST_set(sk, idx, ptr) ((X509_TRUST *)OPENSSL_sk_set(ossl_check_X509_TRUST_sk_type(sk), (idx), ossl_check_X509_TRUST_type(ptr)))
+#define sk_X509_TRUST_set(sk, idx, ptr) ((X509_TRUST*)OPENSSL_sk_set(ossl_check_X509_TRUST_sk_type(sk), (idx), ossl_check_X509_TRUST_type(ptr)))
 #define sk_X509_TRUST_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
 #define sk_X509_TRUST_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr))
 #define sk_X509_TRUST_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_type(ptr), pnum)
 #define sk_X509_TRUST_sort(sk) OPENSSL_sk_sort(ossl_check_X509_TRUST_sk_type(sk))
 #define sk_X509_TRUST_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_TRUST_sk_type(sk))
-#define sk_X509_TRUST_dup(sk) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_dup(ossl_check_const_X509_TRUST_sk_type(sk)))
-#define sk_X509_TRUST_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_TRUST) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_copyfunc_type(copyfunc), ossl_check_X509_TRUST_freefunc_type(freefunc)))
+#define sk_X509_TRUST_dup(sk) ((STACK_OF(X509_TRUST)*)OPENSSL_sk_dup(ossl_check_const_X509_TRUST_sk_type(sk)))
+#define sk_X509_TRUST_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_TRUST)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_copyfunc_type(copyfunc), ossl_check_X509_TRUST_freefunc_type(freefunc)))
 #define sk_X509_TRUST_set_cmp_func(sk, cmp) ((sk_X509_TRUST_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_TRUST_sk_type(sk), ossl_check_X509_TRUST_compfunc_type(cmp)))
 
-
 /* standard trust ids */
-# define X509_TRUST_DEFAULT      0 /* Only valid in purpose settings */
-# define X509_TRUST_COMPAT       1
-# define X509_TRUST_SSL_CLIENT   2
-# define X509_TRUST_SSL_SERVER   3
-# define X509_TRUST_EMAIL        4
-# define X509_TRUST_OBJECT_SIGN  5
-# define X509_TRUST_OCSP_SIGN    6
-# define X509_TRUST_OCSP_REQUEST 7
-# define X509_TRUST_TSA          8
+#define X509_TRUST_DEFAULT 0 /* Only valid in purpose settings */
+#define X509_TRUST_COMPAT 1
+#define X509_TRUST_SSL_CLIENT 2
+#define X509_TRUST_SSL_SERVER 3
+#define X509_TRUST_EMAIL 4
+#define X509_TRUST_OBJECT_SIGN 5
+#define X509_TRUST_OCSP_SIGN 6
+#define X509_TRUST_OCSP_REQUEST 7
+#define X509_TRUST_TSA 8
 /* Keep these up to date! */
-# define X509_TRUST_MIN          1
-# define X509_TRUST_MAX          8
+#define X509_TRUST_MIN 1
+#define X509_TRUST_MAX 8
 
 /* trust_flags values */
-# define X509_TRUST_DYNAMIC      (1U << 0)
-# define X509_TRUST_DYNAMIC_NAME (1U << 1)
+#define X509_TRUST_DYNAMIC (1U << 0)
+#define X509_TRUST_DYNAMIC_NAME (1U << 1)
 /* No compat trust if self-signed, preempts "DO_SS" */
-# define X509_TRUST_NO_SS_COMPAT (1U << 2)
+#define X509_TRUST_NO_SS_COMPAT (1U << 2)
 /* Compat trust if no explicit accepted trust EKUs */
-# define X509_TRUST_DO_SS_COMPAT (1U << 3)
+#define X509_TRUST_DO_SS_COMPAT (1U << 3)
 /* Accept "anyEKU" as a wildcard rejection OID and as a wildcard trust OID */
-# define X509_TRUST_OK_ANY_EKU   (1U << 4)
+#define X509_TRUST_OK_ANY_EKU (1U << 4)
 
 /* check_trust return codes */
-# define X509_TRUST_TRUSTED      1
-# define X509_TRUST_REJECTED     2
-# define X509_TRUST_UNTRUSTED    3
-
-int X509_TRUST_set(int *t, int trust);
-int X509_TRUST_get_count(void);
-X509_TRUST *X509_TRUST_get0(int idx);
-int X509_TRUST_get_by_id(int id);
-int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int),
-                   const char *name, int arg1, void *arg2);
-void X509_TRUST_cleanup(void);
-int X509_TRUST_get_flags(const X509_TRUST *xp);
-char *X509_TRUST_get0_name(const X509_TRUST *xp);
-int X509_TRUST_get_trust(const X509_TRUST *xp);
-
-int X509_trusted(const X509 *x);
-int X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj);
-int X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj);
-void X509_trust_clear(X509 *x);
-void X509_reject_clear(X509 *x);
-STACK_OF(ASN1_OBJECT) *X509_get0_trust_objects(X509 *x);
-STACK_OF(ASN1_OBJECT) *X509_get0_reject_objects(X509 *x);
-
-int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *,
-                                                                int);
-int X509_check_trust(X509 *x, int id, int flags);
-
-int X509_verify_cert(X509_STORE_CTX *ctx);
-int X509_STORE_CTX_verify(X509_STORE_CTX *ctx);
-STACK_OF(X509) *X509_build_chain(X509 *target, STACK_OF(X509) *certs,
-                                 X509_STORE *store, int with_self_signed,
-                                 OSSL_LIB_CTX *libctx, const char *propq);
-
-int X509_STORE_set_depth(X509_STORE *store, int depth);
-
-typedef int (*X509_STORE_CTX_verify_cb)(int, X509_STORE_CTX *);
-int X509_STORE_CTX_print_verify_cb(int ok, X509_STORE_CTX *ctx);
-typedef int (*X509_STORE_CTX_verify_fn)(X509_STORE_CTX *);
-typedef int (*X509_STORE_CTX_get_issuer_fn)(X509 **issuer,
-                                            X509_STORE_CTX *ctx, X509 *x);
-typedef int (*X509_STORE_CTX_check_issued_fn)(X509_STORE_CTX *ctx,
-                                              X509 *x, X509 *issuer);
-typedef int (*X509_STORE_CTX_check_revocation_fn)(X509_STORE_CTX *ctx);
-typedef int (*X509_STORE_CTX_get_crl_fn)(X509_STORE_CTX *ctx,
-                                         X509_CRL **crl, X509 *x);
-typedef int (*X509_STORE_CTX_check_crl_fn)(X509_STORE_CTX *ctx, X509_CRL *crl);
-typedef int (*X509_STORE_CTX_cert_crl_fn)(X509_STORE_CTX *ctx,
-                                          X509_CRL *crl, X509 *x);
-typedef int (*X509_STORE_CTX_check_policy_fn)(X509_STORE_CTX *ctx);
-typedef STACK_OF(X509)
-    *(*X509_STORE_CTX_lookup_certs_fn)(X509_STORE_CTX *ctx,
-                                       const X509_NAME *nm);
-typedef STACK_OF(X509_CRL)
-    *(*X509_STORE_CTX_lookup_crls_fn)(const X509_STORE_CTX *ctx,
-                                      const X509_NAME *nm);
-typedef int (*X509_STORE_CTX_cleanup_fn)(X509_STORE_CTX *ctx);
-
-void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth);
-
-# define X509_STORE_CTX_set_app_data(ctx,data) \
-        X509_STORE_CTX_set_ex_data(ctx,0,data)
-# define X509_STORE_CTX_get_app_data(ctx) \
-        X509_STORE_CTX_get_ex_data(ctx,0)
-
-# define X509_L_FILE_LOAD        1
-# define X509_L_ADD_DIR          2
-# define X509_L_ADD_STORE        3
-# define X509_L_LOAD_STORE       4
-
-# define X509_LOOKUP_load_file(x,name,type) \
-                X509_LOOKUP_ctrl((x),X509_L_FILE_LOAD,(name),(long)(type),NULL)
-
-# define X509_LOOKUP_add_dir(x,name,type) \
-                X509_LOOKUP_ctrl((x),X509_L_ADD_DIR,(name),(long)(type),NULL)
-
-# define X509_LOOKUP_add_store(x,name) \
-                X509_LOOKUP_ctrl((x),X509_L_ADD_STORE,(name),0,NULL)
-
-# define X509_LOOKUP_load_store(x,name) \
-                X509_LOOKUP_ctrl((x),X509_L_LOAD_STORE,(name),0,NULL)
-
-# define X509_LOOKUP_load_file_ex(x, name, type, libctx, propq)       \
-X509_LOOKUP_ctrl_ex((x), X509_L_FILE_LOAD, (name), (long)(type), NULL,\
-                    (libctx), (propq))
-
-# define X509_LOOKUP_load_store_ex(x, name, libctx, propq)            \
-X509_LOOKUP_ctrl_ex((x), X509_L_LOAD_STORE, (name), 0, NULL,          \
-                    (libctx), (propq))
-
-# define X509_LOOKUP_add_store_ex(x, name, libctx, propq)             \
-X509_LOOKUP_ctrl_ex((x), X509_L_ADD_STORE, (name), 0, NULL,           \
-                    (libctx), (propq))
-
-# define X509_V_OK                                       0
-# define X509_V_ERR_UNSPECIFIED                          1
-# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT            2
-# define X509_V_ERR_UNABLE_TO_GET_CRL                    3
-# define X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE     4
-# define X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE      5
-# define X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY   6
-# define X509_V_ERR_CERT_SIGNATURE_FAILURE               7
-# define X509_V_ERR_CRL_SIGNATURE_FAILURE                8
-# define X509_V_ERR_CERT_NOT_YET_VALID                   9
-# define X509_V_ERR_CERT_HAS_EXPIRED                     10
-# define X509_V_ERR_CRL_NOT_YET_VALID                    11
-# define X509_V_ERR_CRL_HAS_EXPIRED                      12
-# define X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD       13
-# define X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD        14
-# define X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD       15
-# define X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD       16
-# define X509_V_ERR_OUT_OF_MEM                           17
-# define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT          18
-# define X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN            19
-# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY    20
-# define X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE      21
-# define X509_V_ERR_CERT_CHAIN_TOO_LONG                  22
-# define X509_V_ERR_CERT_REVOKED                         23
-# define X509_V_ERR_NO_ISSUER_PUBLIC_KEY                 24
-# define X509_V_ERR_PATH_LENGTH_EXCEEDED                 25
-# define X509_V_ERR_INVALID_PURPOSE                      26
-# define X509_V_ERR_CERT_UNTRUSTED                       27
-# define X509_V_ERR_CERT_REJECTED                        28
+#define X509_TRUST_TRUSTED 1
+#define X509_TRUST_REJECTED 2
+#define X509_TRUST_UNTRUSTED 3
+
+    int X509_TRUST_set(int* t, int trust);
+    int X509_TRUST_get_count(void);
+    X509_TRUST* X509_TRUST_get0(int idx);
+    int X509_TRUST_get_by_id(int id);
+    int X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST*, X509*, int), const char* name, int arg1, void* arg2);
+    void X509_TRUST_cleanup(void);
+    int X509_TRUST_get_flags(const X509_TRUST* xp);
+    char* X509_TRUST_get0_name(const X509_TRUST* xp);
+    int X509_TRUST_get_trust(const X509_TRUST* xp);
+
+    int X509_trusted(const X509* x);
+    int X509_add1_trust_object(X509* x, const ASN1_OBJECT* obj);
+    int X509_add1_reject_object(X509* x, const ASN1_OBJECT* obj);
+    void X509_trust_clear(X509* x);
+    void X509_reject_clear(X509* x);
+    STACK_OF(ASN1_OBJECT) * X509_get0_trust_objects(X509* x);
+    STACK_OF(ASN1_OBJECT) * X509_get0_reject_objects(X509* x);
+
+    int (*X509_TRUST_set_default(int (*trust)(int, X509*, int)))(int, X509*, int);
+    int X509_check_trust(X509* x, int id, int flags);
+
+    int X509_verify_cert(X509_STORE_CTX* ctx);
+    int X509_STORE_CTX_verify(X509_STORE_CTX* ctx);
+    STACK_OF(X509) * X509_build_chain(X509* target, STACK_OF(X509) * certs, X509_STORE* store, int with_self_signed, OSSL_LIB_CTX* libctx, const char* propq);
+
+    int X509_STORE_set_depth(X509_STORE* store, int depth);
+
+    typedef int (*X509_STORE_CTX_verify_cb)(int, X509_STORE_CTX*);
+    int X509_STORE_CTX_print_verify_cb(int ok, X509_STORE_CTX* ctx);
+    typedef int (*X509_STORE_CTX_verify_fn)(X509_STORE_CTX*);
+    typedef int (*X509_STORE_CTX_get_issuer_fn)(X509** issuer, X509_STORE_CTX* ctx, X509* x);
+    typedef int (*X509_STORE_CTX_check_issued_fn)(X509_STORE_CTX* ctx, X509* x, X509* issuer);
+    typedef int (*X509_STORE_CTX_check_revocation_fn)(X509_STORE_CTX* ctx);
+    typedef int (*X509_STORE_CTX_get_crl_fn)(X509_STORE_CTX* ctx, X509_CRL** crl, X509* x);
+    typedef int (*X509_STORE_CTX_check_crl_fn)(X509_STORE_CTX* ctx, X509_CRL* crl);
+    typedef int (*X509_STORE_CTX_cert_crl_fn)(X509_STORE_CTX* ctx, X509_CRL* crl, X509* x);
+    typedef int (*X509_STORE_CTX_check_policy_fn)(X509_STORE_CTX* ctx);
+    typedef STACK_OF(X509) * (*X509_STORE_CTX_lookup_certs_fn)(X509_STORE_CTX* ctx, const X509_NAME* nm);
+    typedef STACK_OF(X509_CRL) * (*X509_STORE_CTX_lookup_crls_fn)(const X509_STORE_CTX* ctx, const X509_NAME* nm);
+    typedef int (*X509_STORE_CTX_cleanup_fn)(X509_STORE_CTX* ctx);
+
+    void X509_STORE_CTX_set_depth(X509_STORE_CTX* ctx, int depth);
+
+#define X509_STORE_CTX_set_app_data(ctx, data) \
+    X509_STORE_CTX_set_ex_data(ctx, 0, data)
+#define X509_STORE_CTX_get_app_data(ctx) \
+    X509_STORE_CTX_get_ex_data(ctx, 0)
+
+#define X509_L_FILE_LOAD 1
+#define X509_L_ADD_DIR 2
+#define X509_L_ADD_STORE 3
+#define X509_L_LOAD_STORE 4
+
+#define X509_LOOKUP_load_file(x, name, type) \
+    X509_LOOKUP_ctrl((x), X509_L_FILE_LOAD, (name), (long)(type), NULL)
+
+#define X509_LOOKUP_add_dir(x, name, type) \
+    X509_LOOKUP_ctrl((x), X509_L_ADD_DIR, (name), (long)(type), NULL)
+
+#define X509_LOOKUP_add_store(x, name) \
+    X509_LOOKUP_ctrl((x), X509_L_ADD_STORE, (name), 0, NULL)
+
+#define X509_LOOKUP_load_store(x, name) \
+    X509_LOOKUP_ctrl((x), X509_L_LOAD_STORE, (name), 0, NULL)
+
+#define X509_LOOKUP_load_file_ex(x, name, type, libctx, propq) \
+    X509_LOOKUP_ctrl_ex((x), X509_L_FILE_LOAD, (name), (long)(type), NULL, (libctx), (propq))
+
+#define X509_LOOKUP_load_store_ex(x, name, libctx, propq) \
+    X509_LOOKUP_ctrl_ex((x), X509_L_LOAD_STORE, (name), 0, NULL, (libctx), (propq))
+
+#define X509_LOOKUP_add_store_ex(x, name, libctx, propq) \
+    X509_LOOKUP_ctrl_ex((x), X509_L_ADD_STORE, (name), 0, NULL, (libctx), (propq))
+
+#define X509_V_OK 0
+#define X509_V_ERR_UNSPECIFIED 1
+#define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT 2
+#define X509_V_ERR_UNABLE_TO_GET_CRL 3
+#define X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE 4
+#define X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE 5
+#define X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY 6
+#define X509_V_ERR_CERT_SIGNATURE_FAILURE 7
+#define X509_V_ERR_CRL_SIGNATURE_FAILURE 8
+#define X509_V_ERR_CERT_NOT_YET_VALID 9
+#define X509_V_ERR_CERT_HAS_EXPIRED 10
+#define X509_V_ERR_CRL_NOT_YET_VALID 11
+#define X509_V_ERR_CRL_HAS_EXPIRED 12
+#define X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD 13
+#define X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD 14
+#define X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD 15
+#define X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD 16
+#define X509_V_ERR_OUT_OF_MEM 17
+#define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT 18
+#define X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN 19
+#define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY 20
+#define X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE 21
+#define X509_V_ERR_CERT_CHAIN_TOO_LONG 22
+#define X509_V_ERR_CERT_REVOKED 23
+#define X509_V_ERR_NO_ISSUER_PUBLIC_KEY 24
+#define X509_V_ERR_PATH_LENGTH_EXCEEDED 25
+#define X509_V_ERR_INVALID_PURPOSE 26
+#define X509_V_ERR_CERT_UNTRUSTED 27
+#define X509_V_ERR_CERT_REJECTED 28
 
 /* These are 'informational' when looking for issuer cert */
-# define X509_V_ERR_SUBJECT_ISSUER_MISMATCH              29
-# define X509_V_ERR_AKID_SKID_MISMATCH                   30
-# define X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH          31
-# define X509_V_ERR_KEYUSAGE_NO_CERTSIGN                 32
-# define X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER             33
-# define X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION         34
-# define X509_V_ERR_KEYUSAGE_NO_CRL_SIGN                 35
-# define X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION     36
-# define X509_V_ERR_INVALID_NON_CA                       37
-# define X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED           38
-# define X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE        39
-# define X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED       40
-# define X509_V_ERR_INVALID_EXTENSION                    41
-# define X509_V_ERR_INVALID_POLICY_EXTENSION             42
-# define X509_V_ERR_NO_EXPLICIT_POLICY                   43
-# define X509_V_ERR_DIFFERENT_CRL_SCOPE                  44
-# define X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE        45
-# define X509_V_ERR_UNNESTED_RESOURCE                    46
-# define X509_V_ERR_PERMITTED_VIOLATION                  47
-# define X509_V_ERR_EXCLUDED_VIOLATION                   48
-# define X509_V_ERR_SUBTREE_MINMAX                       49
+#define X509_V_ERR_SUBJECT_ISSUER_MISMATCH 29
+#define X509_V_ERR_AKID_SKID_MISMATCH 30
+#define X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH 31
+#define X509_V_ERR_KEYUSAGE_NO_CERTSIGN 32
+#define X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER 33
+#define X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION 34
+#define X509_V_ERR_KEYUSAGE_NO_CRL_SIGN 35
+#define X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION 36
+#define X509_V_ERR_INVALID_NON_CA 37
+#define X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED 38
+#define X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE 39
+#define X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED 40
+#define X509_V_ERR_INVALID_EXTENSION 41
+#define X509_V_ERR_INVALID_POLICY_EXTENSION 42
+#define X509_V_ERR_NO_EXPLICIT_POLICY 43
+#define X509_V_ERR_DIFFERENT_CRL_SCOPE 44
+#define X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE 45
+#define X509_V_ERR_UNNESTED_RESOURCE 46
+#define X509_V_ERR_PERMITTED_VIOLATION 47
+#define X509_V_ERR_EXCLUDED_VIOLATION 48
+#define X509_V_ERR_SUBTREE_MINMAX 49
 /* The application is not happy */
-# define X509_V_ERR_APPLICATION_VERIFICATION             50
-# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE          51
-# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX        52
-# define X509_V_ERR_UNSUPPORTED_NAME_SYNTAX              53
-# define X509_V_ERR_CRL_PATH_VALIDATION_ERROR            54
+#define X509_V_ERR_APPLICATION_VERIFICATION 50
+#define X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE 51
+#define X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX 52
+#define X509_V_ERR_UNSUPPORTED_NAME_SYNTAX 53
+#define X509_V_ERR_CRL_PATH_VALIDATION_ERROR 54
 /* Another issuer check debug option */
-# define X509_V_ERR_PATH_LOOP                            55
+#define X509_V_ERR_PATH_LOOP 55
 /* Suite B mode algorithm violation */
-# define X509_V_ERR_SUITE_B_INVALID_VERSION              56
-# define X509_V_ERR_SUITE_B_INVALID_ALGORITHM            57
-# define X509_V_ERR_SUITE_B_INVALID_CURVE                58
-# define X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM  59
-# define X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED              60
-# define X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 61
+#define X509_V_ERR_SUITE_B_INVALID_VERSION 56
+#define X509_V_ERR_SUITE_B_INVALID_ALGORITHM 57
+#define X509_V_ERR_SUITE_B_INVALID_CURVE 58
+#define X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM 59
+#define X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED 60
+#define X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 61
 /* Host, email and IP check errors */
-# define X509_V_ERR_HOSTNAME_MISMATCH                    62
-# define X509_V_ERR_EMAIL_MISMATCH                       63
-# define X509_V_ERR_IP_ADDRESS_MISMATCH                  64
+#define X509_V_ERR_HOSTNAME_MISMATCH 62
+#define X509_V_ERR_EMAIL_MISMATCH 63
+#define X509_V_ERR_IP_ADDRESS_MISMATCH 64
 /* DANE TLSA errors */
-# define X509_V_ERR_DANE_NO_MATCH                        65
+#define X509_V_ERR_DANE_NO_MATCH 65
 /* security level errors */
-# define X509_V_ERR_EE_KEY_TOO_SMALL                     66
-# define X509_V_ERR_CA_KEY_TOO_SMALL                     67
-# define X509_V_ERR_CA_MD_TOO_WEAK                       68
+#define X509_V_ERR_EE_KEY_TOO_SMALL 66
+#define X509_V_ERR_CA_KEY_TOO_SMALL 67
+#define X509_V_ERR_CA_MD_TOO_WEAK 68
 /* Caller error */
-# define X509_V_ERR_INVALID_CALL                         69
+#define X509_V_ERR_INVALID_CALL 69
 /* Issuer lookup error */
-# define X509_V_ERR_STORE_LOOKUP                         70
+#define X509_V_ERR_STORE_LOOKUP 70
 /* Certificate transparency */
-# define X509_V_ERR_NO_VALID_SCTS                        71
+#define X509_V_ERR_NO_VALID_SCTS 71
 
-# define X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION         72
+#define X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION 72
 /* OCSP status errors */
-# define X509_V_ERR_OCSP_VERIFY_NEEDED                   73  /* Need OCSP verification */
-# define X509_V_ERR_OCSP_VERIFY_FAILED                   74  /* Couldn't verify cert through OCSP */
-# define X509_V_ERR_OCSP_CERT_UNKNOWN                    75  /* Certificate wasn't recognized by the OCSP responder */
+#define X509_V_ERR_OCSP_VERIFY_NEEDED 73 /* Need OCSP verification */
+#define X509_V_ERR_OCSP_VERIFY_FAILED 74 /* Couldn't verify cert through OCSP */
+#define X509_V_ERR_OCSP_CERT_UNKNOWN 75  /* Certificate wasn't recognized by the OCSP responder */
 
-# define X509_V_ERR_UNSUPPORTED_SIGNATURE_ALGORITHM      76
-# define X509_V_ERR_SIGNATURE_ALGORITHM_MISMATCH         77
+#define X509_V_ERR_UNSUPPORTED_SIGNATURE_ALGORITHM 76
+#define X509_V_ERR_SIGNATURE_ALGORITHM_MISMATCH 77
 
 /* Errors in case a check in X509_V_FLAG_X509_STRICT mode fails */
-# define X509_V_ERR_SIGNATURE_ALGORITHM_INCONSISTENCY    78
-# define X509_V_ERR_INVALID_CA                           79
-# define X509_V_ERR_PATHLEN_INVALID_FOR_NON_CA           80
-# define X509_V_ERR_PATHLEN_WITHOUT_KU_KEY_CERT_SIGN     81
-# define X509_V_ERR_KU_KEY_CERT_SIGN_INVALID_FOR_NON_CA  82
-# define X509_V_ERR_ISSUER_NAME_EMPTY                    83
-# define X509_V_ERR_SUBJECT_NAME_EMPTY                   84
-# define X509_V_ERR_MISSING_AUTHORITY_KEY_IDENTIFIER     85
-# define X509_V_ERR_MISSING_SUBJECT_KEY_IDENTIFIER       86
-# define X509_V_ERR_EMPTY_SUBJECT_ALT_NAME               87
-# define X509_V_ERR_EMPTY_SUBJECT_SAN_NOT_CRITICAL       88
-# define X509_V_ERR_CA_BCONS_NOT_CRITICAL                89
-# define X509_V_ERR_AUTHORITY_KEY_IDENTIFIER_CRITICAL    90
-# define X509_V_ERR_SUBJECT_KEY_IDENTIFIER_CRITICAL      91
-# define X509_V_ERR_CA_CERT_MISSING_KEY_USAGE            92
-# define X509_V_ERR_EXTENSIONS_REQUIRE_VERSION_3         93
-# define X509_V_ERR_EC_KEY_EXPLICIT_PARAMS               94
+#define X509_V_ERR_SIGNATURE_ALGORITHM_INCONSISTENCY 78
+#define X509_V_ERR_INVALID_CA 79
+#define X509_V_ERR_PATHLEN_INVALID_FOR_NON_CA 80
+#define X509_V_ERR_PATHLEN_WITHOUT_KU_KEY_CERT_SIGN 81
+#define X509_V_ERR_KU_KEY_CERT_SIGN_INVALID_FOR_NON_CA 82
+#define X509_V_ERR_ISSUER_NAME_EMPTY 83
+#define X509_V_ERR_SUBJECT_NAME_EMPTY 84
+#define X509_V_ERR_MISSING_AUTHORITY_KEY_IDENTIFIER 85
+#define X509_V_ERR_MISSING_SUBJECT_KEY_IDENTIFIER 86
+#define X509_V_ERR_EMPTY_SUBJECT_ALT_NAME 87
+#define X509_V_ERR_EMPTY_SUBJECT_SAN_NOT_CRITICAL 88
+#define X509_V_ERR_CA_BCONS_NOT_CRITICAL 89
+#define X509_V_ERR_AUTHORITY_KEY_IDENTIFIER_CRITICAL 90
+#define X509_V_ERR_SUBJECT_KEY_IDENTIFIER_CRITICAL 91
+#define X509_V_ERR_CA_CERT_MISSING_KEY_USAGE 92
+#define X509_V_ERR_EXTENSIONS_REQUIRE_VERSION_3 93
+#define X509_V_ERR_EC_KEY_EXPLICIT_PARAMS 94
 
 /* Certificate verify flags */
-# ifndef OPENSSL_NO_DEPRECATED_1_1_0
-#  define X509_V_FLAG_CB_ISSUER_CHECK             0x0   /* Deprecated */
-# endif
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+#define X509_V_FLAG_CB_ISSUER_CHECK 0x0 /* Deprecated */
+#endif
 /* Use check time instead of current time */
-# define X509_V_FLAG_USE_CHECK_TIME              0x2
+#define X509_V_FLAG_USE_CHECK_TIME 0x2
 /* Lookup CRLs */
-# define X509_V_FLAG_CRL_CHECK                   0x4
+#define X509_V_FLAG_CRL_CHECK 0x4
 /* Lookup CRLs for whole chain */
-# define X509_V_FLAG_CRL_CHECK_ALL               0x8
+#define X509_V_FLAG_CRL_CHECK_ALL 0x8
 /* Ignore unhandled critical extensions */
-# define X509_V_FLAG_IGNORE_CRITICAL             0x10
+#define X509_V_FLAG_IGNORE_CRITICAL 0x10
 /* Disable workarounds for broken certificates */
-# define X509_V_FLAG_X509_STRICT                 0x20
+#define X509_V_FLAG_X509_STRICT 0x20
 /* Enable proxy certificate validation */
-# define X509_V_FLAG_ALLOW_PROXY_CERTS           0x40
+#define X509_V_FLAG_ALLOW_PROXY_CERTS 0x40
 /* Enable policy checking */
-# define X509_V_FLAG_POLICY_CHECK                0x80
+#define X509_V_FLAG_POLICY_CHECK 0x80
 /* Policy variable require-explicit-policy */
-# define X509_V_FLAG_EXPLICIT_POLICY             0x100
+#define X509_V_FLAG_EXPLICIT_POLICY 0x100
 /* Policy variable inhibit-any-policy */
-# define X509_V_FLAG_INHIBIT_ANY                 0x200
+#define X509_V_FLAG_INHIBIT_ANY 0x200
 /* Policy variable inhibit-policy-mapping */
-# define X509_V_FLAG_INHIBIT_MAP                 0x400
+#define X509_V_FLAG_INHIBIT_MAP 0x400
 /* Notify callback that policy is OK */
-# define X509_V_FLAG_NOTIFY_POLICY               0x800
+#define X509_V_FLAG_NOTIFY_POLICY 0x800
 /* Extended CRL features such as indirect CRLs, alternate CRL signing keys */
-# define X509_V_FLAG_EXTENDED_CRL_SUPPORT        0x1000
+#define X509_V_FLAG_EXTENDED_CRL_SUPPORT 0x1000
 /* Delta CRL support */
-# define X509_V_FLAG_USE_DELTAS                  0x2000
+#define X509_V_FLAG_USE_DELTAS 0x2000
 /* Check self-signed CA signature */
-# define X509_V_FLAG_CHECK_SS_SIGNATURE          0x4000
+#define X509_V_FLAG_CHECK_SS_SIGNATURE 0x4000
 /* Use trusted store first */
-# define X509_V_FLAG_TRUSTED_FIRST               0x8000
+#define X509_V_FLAG_TRUSTED_FIRST 0x8000
 /* Suite B 128 bit only mode: not normally used */
-# define X509_V_FLAG_SUITEB_128_LOS_ONLY         0x10000
+#define X509_V_FLAG_SUITEB_128_LOS_ONLY 0x10000
 /* Suite B 192 bit only mode */
-# define X509_V_FLAG_SUITEB_192_LOS              0x20000
+#define X509_V_FLAG_SUITEB_192_LOS 0x20000
 /* Suite B 128 bit mode allowing 192 bit algorithms */
-# define X509_V_FLAG_SUITEB_128_LOS              0x30000
+#define X509_V_FLAG_SUITEB_128_LOS 0x30000
 /* Allow partial chains if at least one certificate is in trusted store */
-# define X509_V_FLAG_PARTIAL_CHAIN               0x80000
+#define X509_V_FLAG_PARTIAL_CHAIN 0x80000
 /*
  * If the initial chain is not trusted, do not attempt to build an alternative
  * chain. Alternate chain checking was introduced in 1.1.0. Setting this flag
  * will force the behaviour to match that of previous versions.
  */
-# define X509_V_FLAG_NO_ALT_CHAINS               0x100000
+#define X509_V_FLAG_NO_ALT_CHAINS 0x100000
 /* Do not check certificate/CRL validity against current time */
-# define X509_V_FLAG_NO_CHECK_TIME               0x200000
+#define X509_V_FLAG_NO_CHECK_TIME 0x200000
 
-# define X509_VP_FLAG_DEFAULT                    0x1
-# define X509_VP_FLAG_OVERWRITE                  0x2
-# define X509_VP_FLAG_RESET_FLAGS                0x4
-# define X509_VP_FLAG_LOCKED                     0x8
-# define X509_VP_FLAG_ONCE                       0x10
+#define X509_VP_FLAG_DEFAULT 0x1
+#define X509_VP_FLAG_OVERWRITE 0x2
+#define X509_VP_FLAG_RESET_FLAGS 0x4
+#define X509_VP_FLAG_LOCKED 0x8
+#define X509_VP_FLAG_ONCE 0x10
 
 /* Internal use: mask of policy related options */
-# define X509_V_FLAG_POLICY_MASK (X509_V_FLAG_POLICY_CHECK \
-                                | X509_V_FLAG_EXPLICIT_POLICY \
-                                | X509_V_FLAG_INHIBIT_ANY \
-                                | X509_V_FLAG_INHIBIT_MAP)
-
-int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
-                               const X509_NAME *name);
-X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h,
-                                             X509_LOOKUP_TYPE type,
-                                             const X509_NAME *name);
-X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h,
-                                        X509_OBJECT *x);
-int X509_OBJECT_up_ref_count(X509_OBJECT *a);
-X509_OBJECT *X509_OBJECT_new(void);
-void X509_OBJECT_free(X509_OBJECT *a);
-X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a);
-X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a);
-int X509_OBJECT_set1_X509(X509_OBJECT *a, X509 *obj);
-X509_CRL *X509_OBJECT_get0_X509_CRL(const X509_OBJECT *a);
-int X509_OBJECT_set1_X509_CRL(X509_OBJECT *a, X509_CRL *obj);
-X509_STORE *X509_STORE_new(void);
-void X509_STORE_free(X509_STORE *v);
-int X509_STORE_lock(X509_STORE *ctx);
-int X509_STORE_unlock(X509_STORE *ctx);
-int X509_STORE_up_ref(X509_STORE *v);
-STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(const X509_STORE *v);
-STACK_OF(X509) *X509_STORE_get1_all_certs(X509_STORE *st);
-STACK_OF(X509) *X509_STORE_CTX_get1_certs(X509_STORE_CTX *st,
-                                          const X509_NAME *nm);
-STACK_OF(X509_CRL) *X509_STORE_CTX_get1_crls(const X509_STORE_CTX *st,
-                                             const X509_NAME *nm);
-int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags);
-int X509_STORE_set_purpose(X509_STORE *ctx, int purpose);
-int X509_STORE_set_trust(X509_STORE *ctx, int trust);
-int X509_STORE_set1_param(X509_STORE *ctx, const X509_VERIFY_PARAM *pm);
-X509_VERIFY_PARAM *X509_STORE_get0_param(const X509_STORE *ctx);
-
-void X509_STORE_set_verify(X509_STORE *ctx, X509_STORE_CTX_verify_fn verify);
+#define X509_V_FLAG_POLICY_MASK (X509_V_FLAG_POLICY_CHECK | X509_V_FLAG_EXPLICIT_POLICY | X509_V_FLAG_INHIBIT_ANY | X509_V_FLAG_INHIBIT_MAP)
+
+    int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) * h, X509_LOOKUP_TYPE type, const X509_NAME* name);
+    X509_OBJECT* X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) * h, X509_LOOKUP_TYPE type, const X509_NAME* name);
+    X509_OBJECT* X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) * h, X509_OBJECT* x);
+    int X509_OBJECT_up_ref_count(X509_OBJECT* a);
+    X509_OBJECT* X509_OBJECT_new(void);
+    void X509_OBJECT_free(X509_OBJECT* a);
+    X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT* a);
+    X509* X509_OBJECT_get0_X509(const X509_OBJECT* a);
+    int X509_OBJECT_set1_X509(X509_OBJECT* a, X509* obj);
+    X509_CRL* X509_OBJECT_get0_X509_CRL(const X509_OBJECT* a);
+    int X509_OBJECT_set1_X509_CRL(X509_OBJECT* a, X509_CRL* obj);
+    X509_STORE* X509_STORE_new(void);
+    void X509_STORE_free(X509_STORE* v);
+    int X509_STORE_lock(X509_STORE* ctx);
+    int X509_STORE_unlock(X509_STORE* ctx);
+    int X509_STORE_up_ref(X509_STORE* v);
+    STACK_OF(X509_OBJECT) * X509_STORE_get0_objects(const X509_STORE* v);
+    STACK_OF(X509) * X509_STORE_get1_all_certs(X509_STORE* st);
+    STACK_OF(X509) * X509_STORE_CTX_get1_certs(X509_STORE_CTX* st, const X509_NAME* nm);
+    STACK_OF(X509_CRL) * X509_STORE_CTX_get1_crls(const X509_STORE_CTX* st, const X509_NAME* nm);
+    int X509_STORE_set_flags(X509_STORE* ctx, unsigned long flags);
+    int X509_STORE_set_purpose(X509_STORE* ctx, int purpose);
+    int X509_STORE_set_trust(X509_STORE* ctx, int trust);
+    int X509_STORE_set1_param(X509_STORE* ctx, const X509_VERIFY_PARAM* pm);
+    X509_VERIFY_PARAM* X509_STORE_get0_param(const X509_STORE* ctx);
+
+    void X509_STORE_set_verify(X509_STORE* ctx, X509_STORE_CTX_verify_fn verify);
 #define X509_STORE_set_verify_func(ctx, func) \
-            X509_STORE_set_verify((ctx),(func))
-void X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx,
-                               X509_STORE_CTX_verify_fn verify);
-X509_STORE_CTX_verify_fn X509_STORE_get_verify(const X509_STORE *ctx);
-void X509_STORE_set_verify_cb(X509_STORE *ctx,
-                              X509_STORE_CTX_verify_cb verify_cb);
-# define X509_STORE_set_verify_cb_func(ctx,func) \
-            X509_STORE_set_verify_cb((ctx),(func))
-X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(const X509_STORE *ctx);
-void X509_STORE_set_get_issuer(X509_STORE *ctx,
-                               X509_STORE_CTX_get_issuer_fn get_issuer);
-X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(const X509_STORE *ctx);
-void X509_STORE_set_check_issued(X509_STORE *ctx,
-                                 X509_STORE_CTX_check_issued_fn check_issued);
-X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(const X509_STORE *ctx);
-void X509_STORE_set_check_revocation(X509_STORE *ctx,
-                                     X509_STORE_CTX_check_revocation_fn check_revocation);
-X509_STORE_CTX_check_revocation_fn
-    X509_STORE_get_check_revocation(const X509_STORE *ctx);
-void X509_STORE_set_get_crl(X509_STORE *ctx,
-                            X509_STORE_CTX_get_crl_fn get_crl);
-X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(const X509_STORE *ctx);
-void X509_STORE_set_check_crl(X509_STORE *ctx,
-                              X509_STORE_CTX_check_crl_fn check_crl);
-X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(const X509_STORE *ctx);
-void X509_STORE_set_cert_crl(X509_STORE *ctx,
-                             X509_STORE_CTX_cert_crl_fn cert_crl);
-X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(const X509_STORE *ctx);
-void X509_STORE_set_check_policy(X509_STORE *ctx,
-                                 X509_STORE_CTX_check_policy_fn check_policy);
-X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(const X509_STORE *ctx);
-void X509_STORE_set_lookup_certs(X509_STORE *ctx,
-                                 X509_STORE_CTX_lookup_certs_fn lookup_certs);
-X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(const X509_STORE *ctx);
-void X509_STORE_set_lookup_crls(X509_STORE *ctx,
-                                X509_STORE_CTX_lookup_crls_fn lookup_crls);
+    X509_STORE_set_verify((ctx), (func))
+    void X509_STORE_CTX_set_verify(X509_STORE_CTX* ctx, X509_STORE_CTX_verify_fn verify);
+    X509_STORE_CTX_verify_fn X509_STORE_get_verify(const X509_STORE* ctx);
+    void X509_STORE_set_verify_cb(X509_STORE* ctx, X509_STORE_CTX_verify_cb verify_cb);
+#define X509_STORE_set_verify_cb_func(ctx, func) \
+    X509_STORE_set_verify_cb((ctx), (func))
+    X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(const X509_STORE* ctx);
+    void X509_STORE_set_get_issuer(X509_STORE* ctx, X509_STORE_CTX_get_issuer_fn get_issuer);
+    X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(const X509_STORE* ctx);
+    void X509_STORE_set_check_issued(X509_STORE* ctx, X509_STORE_CTX_check_issued_fn check_issued);
+    X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(const X509_STORE* ctx);
+    void X509_STORE_set_check_revocation(X509_STORE* ctx, X509_STORE_CTX_check_revocation_fn check_revocation);
+    X509_STORE_CTX_check_revocation_fn
+        X509_STORE_get_check_revocation(const X509_STORE* ctx);
+    void X509_STORE_set_get_crl(X509_STORE* ctx, X509_STORE_CTX_get_crl_fn get_crl);
+    X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(const X509_STORE* ctx);
+    void X509_STORE_set_check_crl(X509_STORE* ctx, X509_STORE_CTX_check_crl_fn check_crl);
+    X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(const X509_STORE* ctx);
+    void X509_STORE_set_cert_crl(X509_STORE* ctx, X509_STORE_CTX_cert_crl_fn cert_crl);
+    X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(const X509_STORE* ctx);
+    void X509_STORE_set_check_policy(X509_STORE* ctx, X509_STORE_CTX_check_policy_fn check_policy);
+    X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(const X509_STORE* ctx);
+    void X509_STORE_set_lookup_certs(X509_STORE* ctx, X509_STORE_CTX_lookup_certs_fn lookup_certs);
+    X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(const X509_STORE* ctx);
+    void X509_STORE_set_lookup_crls(X509_STORE* ctx, X509_STORE_CTX_lookup_crls_fn lookup_crls);
 #define X509_STORE_set_lookup_crls_cb(ctx, func) \
     X509_STORE_set_lookup_crls((ctx), (func))
-X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(const X509_STORE *ctx);
-void X509_STORE_set_cleanup(X509_STORE *ctx,
-                            X509_STORE_CTX_cleanup_fn cleanup);
-X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(const X509_STORE *ctx);
+    X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(const X509_STORE* ctx);
+    void X509_STORE_set_cleanup(X509_STORE* ctx, X509_STORE_CTX_cleanup_fn cleanup);
+    X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(const X509_STORE* ctx);
 
 #define X509_STORE_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE, l, p, newf, dupf, freef)
-int X509_STORE_set_ex_data(X509_STORE *ctx, int idx, void *data);
-void *X509_STORE_get_ex_data(const X509_STORE *ctx, int idx);
-
-X509_STORE_CTX *X509_STORE_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq);
-X509_STORE_CTX *X509_STORE_CTX_new(void);
-
-int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x);
-
-void X509_STORE_CTX_free(X509_STORE_CTX *ctx);
-int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *trust_store,
-                        X509 *target, STACK_OF(X509) *untrusted);
-void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk);
-void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx);
-
-X509_STORE *X509_STORE_CTX_get0_store(const X509_STORE_CTX *ctx);
-X509 *X509_STORE_CTX_get0_cert(const X509_STORE_CTX *ctx);
-STACK_OF(X509)* X509_STORE_CTX_get0_untrusted(const X509_STORE_CTX *ctx);
-void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk);
-void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
-                                  X509_STORE_CTX_verify_cb verify);
-X509_STORE_CTX_verify_cb X509_STORE_CTX_get_verify_cb(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_verify_fn X509_STORE_CTX_get_verify(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_get_issuer_fn X509_STORE_CTX_get_get_issuer(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_check_issued_fn X509_STORE_CTX_get_check_issued(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_check_revocation_fn X509_STORE_CTX_get_check_revocation(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_get_crl_fn X509_STORE_CTX_get_get_crl(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_check_crl_fn X509_STORE_CTX_get_check_crl(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_cert_crl_fn X509_STORE_CTX_get_cert_crl(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_check_policy_fn X509_STORE_CTX_get_check_policy(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_lookup_certs_fn X509_STORE_CTX_get_lookup_certs(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_lookup_crls_fn X509_STORE_CTX_get_lookup_crls(const X509_STORE_CTX *ctx);
-X509_STORE_CTX_cleanup_fn X509_STORE_CTX_get_cleanup(const X509_STORE_CTX *ctx);
+    int X509_STORE_set_ex_data(X509_STORE* ctx, int idx, void* data);
+    void* X509_STORE_get_ex_data(const X509_STORE* ctx, int idx);
+
+    X509_STORE_CTX* X509_STORE_CTX_new_ex(OSSL_LIB_CTX* libctx, const char* propq);
+    X509_STORE_CTX* X509_STORE_CTX_new(void);
+
+    int X509_STORE_CTX_get1_issuer(X509** issuer, X509_STORE_CTX* ctx, X509* x);
+
+    void X509_STORE_CTX_free(X509_STORE_CTX* ctx);
+    int X509_STORE_CTX_init(X509_STORE_CTX* ctx, X509_STORE* trust_store, X509* target, STACK_OF(X509) * untrusted);
+    void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX* ctx, STACK_OF(X509) * sk);
+    void X509_STORE_CTX_cleanup(X509_STORE_CTX* ctx);
+
+    X509_STORE* X509_STORE_CTX_get0_store(const X509_STORE_CTX* ctx);
+    X509* X509_STORE_CTX_get0_cert(const X509_STORE_CTX* ctx);
+    STACK_OF(X509) * X509_STORE_CTX_get0_untrusted(const X509_STORE_CTX* ctx);
+    void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX* ctx, STACK_OF(X509) * sk);
+    void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX* ctx, X509_STORE_CTX_verify_cb verify);
+    X509_STORE_CTX_verify_cb X509_STORE_CTX_get_verify_cb(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_verify_fn X509_STORE_CTX_get_verify(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_get_issuer_fn X509_STORE_CTX_get_get_issuer(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_check_issued_fn X509_STORE_CTX_get_check_issued(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_check_revocation_fn X509_STORE_CTX_get_check_revocation(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_get_crl_fn X509_STORE_CTX_get_get_crl(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_check_crl_fn X509_STORE_CTX_get_check_crl(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_cert_crl_fn X509_STORE_CTX_get_cert_crl(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_check_policy_fn X509_STORE_CTX_get_check_policy(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_lookup_certs_fn X509_STORE_CTX_get_lookup_certs(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_lookup_crls_fn X509_STORE_CTX_get_lookup_crls(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX_cleanup_fn X509_STORE_CTX_get_cleanup(const X509_STORE_CTX* ctx);
 
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-# define X509_STORE_CTX_get_chain X509_STORE_CTX_get0_chain
-# define X509_STORE_CTX_set_chain X509_STORE_CTX_set0_untrusted
-# define X509_STORE_CTX_trusted_stack X509_STORE_CTX_set0_trusted_stack
-# define X509_STORE_get_by_subject X509_STORE_CTX_get_by_subject
-# define X509_STORE_get1_certs X509_STORE_CTX_get1_certs
-# define X509_STORE_get1_crls X509_STORE_CTX_get1_crls
+#define X509_STORE_CTX_get_chain X509_STORE_CTX_get0_chain
+#define X509_STORE_CTX_set_chain X509_STORE_CTX_set0_untrusted
+#define X509_STORE_CTX_trusted_stack X509_STORE_CTX_set0_trusted_stack
+#define X509_STORE_get_by_subject X509_STORE_CTX_get_by_subject
+#define X509_STORE_get1_certs X509_STORE_CTX_get1_certs
+#define X509_STORE_get1_crls X509_STORE_CTX_get1_crls
 /* the following macro is misspelled; use X509_STORE_get1_certs instead */
-# define X509_STORE_get1_cert X509_STORE_CTX_get1_certs
+#define X509_STORE_get1_cert X509_STORE_CTX_get1_certs
 /* the following macro is misspelled; use X509_STORE_get1_crls instead */
-# define X509_STORE_get1_crl X509_STORE_CTX_get1_crls
+#define X509_STORE_get1_crl X509_STORE_CTX_get1_crls
 #endif
 
-X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m);
-X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void);
-X509_LOOKUP_METHOD *X509_LOOKUP_file(void);
-X509_LOOKUP_METHOD *X509_LOOKUP_store(void);
-
-typedef int (*X509_LOOKUP_ctrl_fn)(X509_LOOKUP *ctx, int cmd, const char *argc,
-                                   long argl, char **ret);
-typedef int (*X509_LOOKUP_ctrl_ex_fn)(
-    X509_LOOKUP *ctx, int cmd, const char *argc, long argl, char **ret,
-    OSSL_LIB_CTX *libctx, const char *propq);
-
-typedef int (*X509_LOOKUP_get_by_subject_fn)(X509_LOOKUP *ctx,
-                                             X509_LOOKUP_TYPE type,
-                                             const X509_NAME *name,
-                                             X509_OBJECT *ret);
-typedef int (*X509_LOOKUP_get_by_subject_ex_fn)(X509_LOOKUP *ctx,
-                                                         X509_LOOKUP_TYPE type,
-                                                         const X509_NAME *name,
-                                                         X509_OBJECT *ret,
-                                                         OSSL_LIB_CTX *libctx,
-                                                         const char *propq);
-typedef int (*X509_LOOKUP_get_by_issuer_serial_fn)(X509_LOOKUP *ctx,
-                                                   X509_LOOKUP_TYPE type,
-                                                   const X509_NAME *name,
-                                                   const ASN1_INTEGER *serial,
-                                                   X509_OBJECT *ret);
-typedef int (*X509_LOOKUP_get_by_fingerprint_fn)(X509_LOOKUP *ctx,
-                                                 X509_LOOKUP_TYPE type,
-                                                 const unsigned char* bytes,
-                                                 int len,
-                                                 X509_OBJECT *ret);
-typedef int (*X509_LOOKUP_get_by_alias_fn)(X509_LOOKUP *ctx,
-                                           X509_LOOKUP_TYPE type,
-                                           const char *str,
-                                           int len,
-                                           X509_OBJECT *ret);
-
-X509_LOOKUP_METHOD *X509_LOOKUP_meth_new(const char *name);
-void X509_LOOKUP_meth_free(X509_LOOKUP_METHOD *method);
-
-int X509_LOOKUP_meth_set_new_item(X509_LOOKUP_METHOD *method,
-                                  int (*new_item) (X509_LOOKUP *ctx));
-int (*X509_LOOKUP_meth_get_new_item(const X509_LOOKUP_METHOD* method))
-    (X509_LOOKUP *ctx);
-
-int X509_LOOKUP_meth_set_free(X509_LOOKUP_METHOD *method,
-                              void (*free_fn) (X509_LOOKUP *ctx));
-void (*X509_LOOKUP_meth_get_free(const X509_LOOKUP_METHOD* method))
-    (X509_LOOKUP *ctx);
-
-int X509_LOOKUP_meth_set_init(X509_LOOKUP_METHOD *method,
-                              int (*init) (X509_LOOKUP *ctx));
-int (*X509_LOOKUP_meth_get_init(const X509_LOOKUP_METHOD* method))
-    (X509_LOOKUP *ctx);
-
-int X509_LOOKUP_meth_set_shutdown(X509_LOOKUP_METHOD *method,
-                                  int (*shutdown) (X509_LOOKUP *ctx));
-int (*X509_LOOKUP_meth_get_shutdown(const X509_LOOKUP_METHOD* method))
-    (X509_LOOKUP *ctx);
-
-int X509_LOOKUP_meth_set_ctrl(X509_LOOKUP_METHOD *method,
-                              X509_LOOKUP_ctrl_fn ctrl_fn);
-X509_LOOKUP_ctrl_fn X509_LOOKUP_meth_get_ctrl(const X509_LOOKUP_METHOD *method);
-
-int X509_LOOKUP_meth_set_get_by_subject(X509_LOOKUP_METHOD *method,
-                                        X509_LOOKUP_get_by_subject_fn fn);
-X509_LOOKUP_get_by_subject_fn X509_LOOKUP_meth_get_get_by_subject(
-    const X509_LOOKUP_METHOD *method);
-
-int X509_LOOKUP_meth_set_get_by_issuer_serial(X509_LOOKUP_METHOD *method,
-    X509_LOOKUP_get_by_issuer_serial_fn fn);
-X509_LOOKUP_get_by_issuer_serial_fn X509_LOOKUP_meth_get_get_by_issuer_serial(
-    const X509_LOOKUP_METHOD *method);
-
-int X509_LOOKUP_meth_set_get_by_fingerprint(X509_LOOKUP_METHOD *method,
-    X509_LOOKUP_get_by_fingerprint_fn fn);
-X509_LOOKUP_get_by_fingerprint_fn X509_LOOKUP_meth_get_get_by_fingerprint(
-    const X509_LOOKUP_METHOD *method);
-
-int X509_LOOKUP_meth_set_get_by_alias(X509_LOOKUP_METHOD *method,
-                                      X509_LOOKUP_get_by_alias_fn fn);
-X509_LOOKUP_get_by_alias_fn X509_LOOKUP_meth_get_get_by_alias(
-    const X509_LOOKUP_METHOD *method);
-
-
-int X509_STORE_add_cert(X509_STORE *ctx, X509 *x);
-int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x);
-
-int X509_STORE_CTX_get_by_subject(const X509_STORE_CTX *vs,
-                                  X509_LOOKUP_TYPE type,
-                                  const X509_NAME *name, X509_OBJECT *ret);
-X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs,
-                                               X509_LOOKUP_TYPE type,
-                                               const X509_NAME *name);
-
-int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc,
-                     long argl, char **ret);
-int X509_LOOKUP_ctrl_ex(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
-                        char **ret, OSSL_LIB_CTX *libctx, const char *propq);
-
-int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type);
-int X509_load_cert_file_ex(X509_LOOKUP *ctx, const char *file, int type,
-                           OSSL_LIB_CTX *libctx, const char *propq);
-int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type);
-int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type);
-int X509_load_cert_crl_file_ex(X509_LOOKUP *ctx, const char *file, int type,
-                               OSSL_LIB_CTX *libctx, const char *propq);
-
-X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method);
-void X509_LOOKUP_free(X509_LOOKUP *ctx);
-int X509_LOOKUP_init(X509_LOOKUP *ctx);
-int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
-                           const X509_NAME *name, X509_OBJECT *ret);
-int X509_LOOKUP_by_subject_ex(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
-                              const X509_NAME *name, X509_OBJECT *ret,
-                              OSSL_LIB_CTX *libctx, const char *propq);
-int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
-                                 const X509_NAME *name,
-                                 const ASN1_INTEGER *serial,
-                                 X509_OBJECT *ret);
-int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
-                               const unsigned char *bytes, int len,
-                               X509_OBJECT *ret);
-int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
-                         const char *str, int len, X509_OBJECT *ret);
-int X509_LOOKUP_set_method_data(X509_LOOKUP *ctx, void *data);
-void *X509_LOOKUP_get_method_data(const X509_LOOKUP *ctx);
-X509_STORE *X509_LOOKUP_get_store(const X509_LOOKUP *ctx);
-int X509_LOOKUP_shutdown(X509_LOOKUP *ctx);
-
-int X509_STORE_load_file(X509_STORE *ctx, const char *file);
-int X509_STORE_load_path(X509_STORE *ctx, const char *path);
-int X509_STORE_load_store(X509_STORE *ctx, const char *store);
-int X509_STORE_load_locations(X509_STORE *ctx,
-                                               const char *file,
-                                               const char *dir);
-int X509_STORE_set_default_paths(X509_STORE *ctx);
-
-int X509_STORE_load_file_ex(X509_STORE *ctx, const char *file,
-                            OSSL_LIB_CTX *libctx, const char *propq);
-int X509_STORE_load_store_ex(X509_STORE *ctx, const char *store,
-                             OSSL_LIB_CTX *libctx, const char *propq);
-int X509_STORE_load_locations_ex(X509_STORE *ctx, const char *file,
-                                 const char *dir, OSSL_LIB_CTX *libctx,
-                                 const char *propq);
-int X509_STORE_set_default_paths_ex(X509_STORE *ctx, OSSL_LIB_CTX *libctx,
-                                    const char *propq);
+    X509_LOOKUP* X509_STORE_add_lookup(X509_STORE* v, X509_LOOKUP_METHOD* m);
+    X509_LOOKUP_METHOD* X509_LOOKUP_hash_dir(void);
+    X509_LOOKUP_METHOD* X509_LOOKUP_file(void);
+    X509_LOOKUP_METHOD* X509_LOOKUP_store(void);
+
+    typedef int (*X509_LOOKUP_ctrl_fn)(X509_LOOKUP* ctx, int cmd, const char* argc, long argl, char** ret);
+    typedef int (*X509_LOOKUP_ctrl_ex_fn)(
+        X509_LOOKUP* ctx, int cmd, const char* argc, long argl, char** ret, OSSL_LIB_CTX* libctx, const char* propq
+    );
+
+    typedef int (*X509_LOOKUP_get_by_subject_fn)(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const X509_NAME* name, X509_OBJECT* ret);
+    typedef int (*X509_LOOKUP_get_by_subject_ex_fn)(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const X509_NAME* name, X509_OBJECT* ret, OSSL_LIB_CTX* libctx, const char* propq);
+    typedef int (*X509_LOOKUP_get_by_issuer_serial_fn)(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const X509_NAME* name, const ASN1_INTEGER* serial, X509_OBJECT* ret);
+    typedef int (*X509_LOOKUP_get_by_fingerprint_fn)(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const unsigned char* bytes, int len, X509_OBJECT* ret);
+    typedef int (*X509_LOOKUP_get_by_alias_fn)(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const char* str, int len, X509_OBJECT* ret);
+
+    X509_LOOKUP_METHOD* X509_LOOKUP_meth_new(const char* name);
+    void X509_LOOKUP_meth_free(X509_LOOKUP_METHOD* method);
+
+    int X509_LOOKUP_meth_set_new_item(X509_LOOKUP_METHOD* method, int (*new_item)(X509_LOOKUP* ctx));
+    int (*X509_LOOKUP_meth_get_new_item(const X509_LOOKUP_METHOD* method))(X509_LOOKUP* ctx);
+
+    int X509_LOOKUP_meth_set_free(X509_LOOKUP_METHOD* method, void (*free_fn)(X509_LOOKUP* ctx));
+    void (*X509_LOOKUP_meth_get_free(const X509_LOOKUP_METHOD* method))(X509_LOOKUP* ctx);
+
+    int X509_LOOKUP_meth_set_init(X509_LOOKUP_METHOD* method, int (*init)(X509_LOOKUP* ctx));
+    int (*X509_LOOKUP_meth_get_init(const X509_LOOKUP_METHOD* method))(X509_LOOKUP* ctx);
+
+    int X509_LOOKUP_meth_set_shutdown(X509_LOOKUP_METHOD* method, int (*shutdown)(X509_LOOKUP* ctx));
+    int (*X509_LOOKUP_meth_get_shutdown(const X509_LOOKUP_METHOD* method))(X509_LOOKUP* ctx);
+
+    int X509_LOOKUP_meth_set_ctrl(X509_LOOKUP_METHOD* method, X509_LOOKUP_ctrl_fn ctrl_fn);
+    X509_LOOKUP_ctrl_fn X509_LOOKUP_meth_get_ctrl(const X509_LOOKUP_METHOD* method);
+
+    int X509_LOOKUP_meth_set_get_by_subject(X509_LOOKUP_METHOD* method, X509_LOOKUP_get_by_subject_fn fn);
+    X509_LOOKUP_get_by_subject_fn X509_LOOKUP_meth_get_get_by_subject(
+        const X509_LOOKUP_METHOD* method
+    );
+
+    int X509_LOOKUP_meth_set_get_by_issuer_serial(X509_LOOKUP_METHOD* method, X509_LOOKUP_get_by_issuer_serial_fn fn);
+    X509_LOOKUP_get_by_issuer_serial_fn X509_LOOKUP_meth_get_get_by_issuer_serial(
+        const X509_LOOKUP_METHOD* method
+    );
+
+    int X509_LOOKUP_meth_set_get_by_fingerprint(X509_LOOKUP_METHOD* method, X509_LOOKUP_get_by_fingerprint_fn fn);
+    X509_LOOKUP_get_by_fingerprint_fn X509_LOOKUP_meth_get_get_by_fingerprint(
+        const X509_LOOKUP_METHOD* method
+    );
+
+    int X509_LOOKUP_meth_set_get_by_alias(X509_LOOKUP_METHOD* method, X509_LOOKUP_get_by_alias_fn fn);
+    X509_LOOKUP_get_by_alias_fn X509_LOOKUP_meth_get_get_by_alias(
+        const X509_LOOKUP_METHOD* method
+    );
+
+    int X509_STORE_add_cert(X509_STORE* ctx, X509* x);
+    int X509_STORE_add_crl(X509_STORE* ctx, X509_CRL* x);
+
+    int X509_STORE_CTX_get_by_subject(const X509_STORE_CTX* vs, X509_LOOKUP_TYPE type, const X509_NAME* name, X509_OBJECT* ret);
+    X509_OBJECT* X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX* vs, X509_LOOKUP_TYPE type, const X509_NAME* name);
+
+    int X509_LOOKUP_ctrl(X509_LOOKUP* ctx, int cmd, const char* argc, long argl, char** ret);
+    int X509_LOOKUP_ctrl_ex(X509_LOOKUP* ctx, int cmd, const char* argc, long argl, char** ret, OSSL_LIB_CTX* libctx, const char* propq);
+
+    int X509_load_cert_file(X509_LOOKUP* ctx, const char* file, int type);
+    int X509_load_cert_file_ex(X509_LOOKUP* ctx, const char* file, int type, OSSL_LIB_CTX* libctx, const char* propq);
+    int X509_load_crl_file(X509_LOOKUP* ctx, const char* file, int type);
+    int X509_load_cert_crl_file(X509_LOOKUP* ctx, const char* file, int type);
+    int X509_load_cert_crl_file_ex(X509_LOOKUP* ctx, const char* file, int type, OSSL_LIB_CTX* libctx, const char* propq);
+
+    X509_LOOKUP* X509_LOOKUP_new(X509_LOOKUP_METHOD* method);
+    void X509_LOOKUP_free(X509_LOOKUP* ctx);
+    int X509_LOOKUP_init(X509_LOOKUP* ctx);
+    int X509_LOOKUP_by_subject(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const X509_NAME* name, X509_OBJECT* ret);
+    int X509_LOOKUP_by_subject_ex(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const X509_NAME* name, X509_OBJECT* ret, OSSL_LIB_CTX* libctx, const char* propq);
+    int X509_LOOKUP_by_issuer_serial(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const X509_NAME* name, const ASN1_INTEGER* serial, X509_OBJECT* ret);
+    int X509_LOOKUP_by_fingerprint(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const unsigned char* bytes, int len, X509_OBJECT* ret);
+    int X509_LOOKUP_by_alias(X509_LOOKUP* ctx, X509_LOOKUP_TYPE type, const char* str, int len, X509_OBJECT* ret);
+    int X509_LOOKUP_set_method_data(X509_LOOKUP* ctx, void* data);
+    void* X509_LOOKUP_get_method_data(const X509_LOOKUP* ctx);
+    X509_STORE* X509_LOOKUP_get_store(const X509_LOOKUP* ctx);
+    int X509_LOOKUP_shutdown(X509_LOOKUP* ctx);
+
+    int X509_STORE_load_file(X509_STORE* ctx, const char* file);
+    int X509_STORE_load_path(X509_STORE* ctx, const char* path);
+    int X509_STORE_load_store(X509_STORE* ctx, const char* store);
+    int X509_STORE_load_locations(X509_STORE* ctx, const char* file, const char* dir);
+    int X509_STORE_set_default_paths(X509_STORE* ctx);
+
+    int X509_STORE_load_file_ex(X509_STORE* ctx, const char* file, OSSL_LIB_CTX* libctx, const char* propq);
+    int X509_STORE_load_store_ex(X509_STORE* ctx, const char* store, OSSL_LIB_CTX* libctx, const char* propq);
+    int X509_STORE_load_locations_ex(X509_STORE* ctx, const char* file, const char* dir, OSSL_LIB_CTX* libctx, const char* propq);
+    int X509_STORE_set_default_paths_ex(X509_STORE* ctx, OSSL_LIB_CTX* libctx, const char* propq);
 
 #define X509_STORE_CTX_get_ex_new_index(l, p, newf, dupf, freef) \
     CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, l, p, newf, dupf, freef)
-int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data);
-void *X509_STORE_CTX_get_ex_data(const X509_STORE_CTX *ctx, int idx);
-int X509_STORE_CTX_get_error(const X509_STORE_CTX *ctx);
-void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int s);
-int X509_STORE_CTX_get_error_depth(const X509_STORE_CTX *ctx);
-void X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth);
-X509 *X509_STORE_CTX_get_current_cert(const X509_STORE_CTX *ctx);
-void X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x);
-X509 *X509_STORE_CTX_get0_current_issuer(const X509_STORE_CTX *ctx);
-X509_CRL *X509_STORE_CTX_get0_current_crl(const X509_STORE_CTX *ctx);
-X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(const X509_STORE_CTX *ctx);
-STACK_OF(X509) *X509_STORE_CTX_get0_chain(const X509_STORE_CTX *ctx);
-STACK_OF(X509) *X509_STORE_CTX_get1_chain(const X509_STORE_CTX *ctx);
-void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *target);
-void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *c, STACK_OF(X509) *sk);
-void X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk);
-int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose);
-int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust);
-int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
-                                   int purpose, int trust);
-void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags);
-void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags,
-                             time_t t);
-
-X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(const X509_STORE_CTX *ctx);
-int X509_STORE_CTX_get_explicit_policy(const X509_STORE_CTX *ctx);
-int X509_STORE_CTX_get_num_untrusted(const X509_STORE_CTX *ctx);
-
-X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(const X509_STORE_CTX *ctx);
-void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param);
-int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name);
-
-/*
- * Bridge opacity barrier between libcrypt and libssl, also needed to support
- * offline testing in test/danetest.c
- */
-void X509_STORE_CTX_set0_dane(X509_STORE_CTX *ctx, SSL_DANE *dane);
+    int X509_STORE_CTX_set_ex_data(X509_STORE_CTX* ctx, int idx, void* data);
+    void* X509_STORE_CTX_get_ex_data(const X509_STORE_CTX* ctx, int idx);
+    int X509_STORE_CTX_get_error(const X509_STORE_CTX* ctx);
+    void X509_STORE_CTX_set_error(X509_STORE_CTX* ctx, int s);
+    int X509_STORE_CTX_get_error_depth(const X509_STORE_CTX* ctx);
+    void X509_STORE_CTX_set_error_depth(X509_STORE_CTX* ctx, int depth);
+    X509* X509_STORE_CTX_get_current_cert(const X509_STORE_CTX* ctx);
+    void X509_STORE_CTX_set_current_cert(X509_STORE_CTX* ctx, X509* x);
+    X509* X509_STORE_CTX_get0_current_issuer(const X509_STORE_CTX* ctx);
+    X509_CRL* X509_STORE_CTX_get0_current_crl(const X509_STORE_CTX* ctx);
+    X509_STORE_CTX* X509_STORE_CTX_get0_parent_ctx(const X509_STORE_CTX* ctx);
+    STACK_OF(X509) * X509_STORE_CTX_get0_chain(const X509_STORE_CTX* ctx);
+    STACK_OF(X509) * X509_STORE_CTX_get1_chain(const X509_STORE_CTX* ctx);
+    void X509_STORE_CTX_set_cert(X509_STORE_CTX* ctx, X509* target);
+    void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX* c, STACK_OF(X509) * sk);
+    void X509_STORE_CTX_set0_crls(X509_STORE_CTX* ctx, STACK_OF(X509_CRL) * sk);
+    int X509_STORE_CTX_set_purpose(X509_STORE_CTX* ctx, int purpose);
+    int X509_STORE_CTX_set_trust(X509_STORE_CTX* ctx, int trust);
+    int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX* ctx, int def_purpose, int purpose, int trust);
+    void X509_STORE_CTX_set_flags(X509_STORE_CTX* ctx, unsigned long flags);
+    void X509_STORE_CTX_set_time(X509_STORE_CTX* ctx, unsigned long flags, time_t t);
+
+    X509_POLICY_TREE* X509_STORE_CTX_get0_policy_tree(const X509_STORE_CTX* ctx);
+    int X509_STORE_CTX_get_explicit_policy(const X509_STORE_CTX* ctx);
+    int X509_STORE_CTX_get_num_untrusted(const X509_STORE_CTX* ctx);
+
+    X509_VERIFY_PARAM* X509_STORE_CTX_get0_param(const X509_STORE_CTX* ctx);
+    void X509_STORE_CTX_set0_param(X509_STORE_CTX* ctx, X509_VERIFY_PARAM* param);
+    int X509_STORE_CTX_set_default(X509_STORE_CTX* ctx, const char* name);
+
+    /*
+     * Bridge opacity barrier between libcrypt and libssl, also needed to support
+     * offline testing in test/danetest.c
+     */
+    void X509_STORE_CTX_set0_dane(X509_STORE_CTX* ctx, SSL_DANE* dane);
 #define DANE_FLAG_NO_DANE_EE_NAMECHECKS (1L << 0)
 
-/* X509_VERIFY_PARAM functions */
-
-X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void);
-void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param);
-int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *to,
-                              const X509_VERIFY_PARAM *from);
-int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to,
-                           const X509_VERIFY_PARAM *from);
-int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name);
-int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param,
-                                unsigned long flags);
-int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param,
-                                  unsigned long flags);
-unsigned long X509_VERIFY_PARAM_get_flags(const X509_VERIFY_PARAM *param);
-int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose);
-int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust);
-void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth);
-void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level);
-time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param);
-void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t);
-int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param,
-                                  ASN1_OBJECT *policy);
-int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
-                                    STACK_OF(ASN1_OBJECT) *policies);
-
-int X509_VERIFY_PARAM_set_inh_flags(X509_VERIFY_PARAM *param,
-                                    uint32_t flags);
-uint32_t X509_VERIFY_PARAM_get_inh_flags(const X509_VERIFY_PARAM *param);
-
-char *X509_VERIFY_PARAM_get0_host(X509_VERIFY_PARAM *param, int idx);
-int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
-                                const char *name, size_t namelen);
-int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
-                                const char *name, size_t namelen);
-void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param,
-                                     unsigned int flags);
-unsigned int X509_VERIFY_PARAM_get_hostflags(const X509_VERIFY_PARAM *param);
-char *X509_VERIFY_PARAM_get0_peername(const X509_VERIFY_PARAM *param);
-void X509_VERIFY_PARAM_move_peername(X509_VERIFY_PARAM *, X509_VERIFY_PARAM *);
-char *X509_VERIFY_PARAM_get0_email(X509_VERIFY_PARAM *param);
-int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,
-                                 const char *email, size_t emaillen);
-char *X509_VERIFY_PARAM_get1_ip_asc(X509_VERIFY_PARAM *param);
-int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param,
-                              const unsigned char *ip, size_t iplen);
-int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param,
-                                  const char *ipasc);
-
-int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param);
-int X509_VERIFY_PARAM_get_auth_level(const X509_VERIFY_PARAM *param);
-const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param);
-
-int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param);
-int X509_VERIFY_PARAM_get_count(void);
-const X509_VERIFY_PARAM *X509_VERIFY_PARAM_get0(int id);
-const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name);
-void X509_VERIFY_PARAM_table_cleanup(void);
+    /* X509_VERIFY_PARAM functions */
+
+    X509_VERIFY_PARAM* X509_VERIFY_PARAM_new(void);
+    void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM* param);
+    int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM* to, const X509_VERIFY_PARAM* from);
+    int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM* to, const X509_VERIFY_PARAM* from);
+    int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM* param, const char* name);
+    int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM* param, unsigned long flags);
+    int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM* param, unsigned long flags);
+    unsigned long X509_VERIFY_PARAM_get_flags(const X509_VERIFY_PARAM* param);
+    int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM* param, int purpose);
+    int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM* param, int trust);
+    void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM* param, int depth);
+    void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM* param, int auth_level);
+    time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM* param);
+    void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM* param, time_t t);
+    int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM* param, ASN1_OBJECT* policy);
+    int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM* param, STACK_OF(ASN1_OBJECT) * policies);
+
+    int X509_VERIFY_PARAM_set_inh_flags(X509_VERIFY_PARAM* param, uint32_t flags);
+    uint32_t X509_VERIFY_PARAM_get_inh_flags(const X509_VERIFY_PARAM* param);
+
+    char* X509_VERIFY_PARAM_get0_host(X509_VERIFY_PARAM* param, int idx);
+    int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM* param, const char* name, size_t namelen);
+    int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM* param, const char* name, size_t namelen);
+    void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM* param, unsigned int flags);
+    unsigned int X509_VERIFY_PARAM_get_hostflags(const X509_VERIFY_PARAM* param);
+    char* X509_VERIFY_PARAM_get0_peername(const X509_VERIFY_PARAM* param);
+    void X509_VERIFY_PARAM_move_peername(X509_VERIFY_PARAM*, X509_VERIFY_PARAM*);
+    char* X509_VERIFY_PARAM_get0_email(X509_VERIFY_PARAM* param);
+    int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM* param, const char* email, size_t emaillen);
+    char* X509_VERIFY_PARAM_get1_ip_asc(X509_VERIFY_PARAM* param);
+    int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM* param, const unsigned char* ip, size_t iplen);
+    int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM* param, const char* ipasc);
+
+    int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM* param);
+    int X509_VERIFY_PARAM_get_auth_level(const X509_VERIFY_PARAM* param);
+    const char* X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM* param);
+
+    int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM* param);
+    int X509_VERIFY_PARAM_get_count(void);
+    const X509_VERIFY_PARAM* X509_VERIFY_PARAM_get0(int id);
+    const X509_VERIFY_PARAM* X509_VERIFY_PARAM_lookup(const char* name);
+    void X509_VERIFY_PARAM_table_cleanup(void);
 
 /* Non positive return values are errors */
-#define X509_PCY_TREE_FAILURE  -2 /* Failure to satisfy explicit policy */
-#define X509_PCY_TREE_INVALID  -1 /* Inconsistent or invalid extensions */
-#define X509_PCY_TREE_INTERNAL  0 /* Internal error, most likely malloc */
+#define X509_PCY_TREE_FAILURE -2 /* Failure to satisfy explicit policy */
+#define X509_PCY_TREE_INVALID -1 /* Inconsistent or invalid extensions */
+#define X509_PCY_TREE_INTERNAL 0 /* Internal error, most likely malloc */
 
 /*
  * Positive return values form a bit mask, all but the first are internal to
  * the library and don't appear in results from X509_policy_check().
  */
-#define X509_PCY_TREE_VALID     1 /* The policy tree is valid */
-#define X509_PCY_TREE_EMPTY     2 /* The policy tree is empty */
-#define X509_PCY_TREE_EXPLICIT  4 /* Explicit policy required */
+#define X509_PCY_TREE_VALID 1    /* The policy tree is valid */
+#define X509_PCY_TREE_EMPTY 2    /* The policy tree is empty */
+#define X509_PCY_TREE_EXPLICIT 4 /* Explicit policy required */
 
-int X509_policy_check(X509_POLICY_TREE **ptree, int *pexplicit_policy,
-                      STACK_OF(X509) *certs,
-                      STACK_OF(ASN1_OBJECT) *policy_oids, unsigned int flags);
+    int X509_policy_check(X509_POLICY_TREE** ptree, int* pexplicit_policy, STACK_OF(X509) * certs, STACK_OF(ASN1_OBJECT) * policy_oids, unsigned int flags);
 
-void X509_policy_tree_free(X509_POLICY_TREE *tree);
+    void X509_policy_tree_free(X509_POLICY_TREE* tree);
 
-int X509_policy_tree_level_count(const X509_POLICY_TREE *tree);
-X509_POLICY_LEVEL *X509_policy_tree_get0_level(const X509_POLICY_TREE *tree,
-                                               int i);
+    int X509_policy_tree_level_count(const X509_POLICY_TREE* tree);
+    X509_POLICY_LEVEL* X509_policy_tree_get0_level(const X509_POLICY_TREE* tree, int i);
 
-STACK_OF(X509_POLICY_NODE)
-    *X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree);
+    STACK_OF(X509_POLICY_NODE)
+    *X509_policy_tree_get0_policies(const X509_POLICY_TREE* tree);
 
-STACK_OF(X509_POLICY_NODE)
-    *X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree);
+    STACK_OF(X509_POLICY_NODE)
+    *X509_policy_tree_get0_user_policies(const X509_POLICY_TREE* tree);
 
-int X509_policy_level_node_count(X509_POLICY_LEVEL *level);
+    int X509_policy_level_node_count(X509_POLICY_LEVEL* level);
 
-X509_POLICY_NODE *X509_policy_level_get0_node(const X509_POLICY_LEVEL *level,
-                                              int i);
+    X509_POLICY_NODE* X509_policy_level_get0_node(const X509_POLICY_LEVEL* level, int i);
 
-const ASN1_OBJECT *X509_policy_node_get0_policy(const X509_POLICY_NODE *node);
+    const ASN1_OBJECT* X509_policy_node_get0_policy(const X509_POLICY_NODE* node);
 
-STACK_OF(POLICYQUALINFO)
-    *X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node);
-const X509_POLICY_NODE
-    *X509_policy_node_get0_parent(const X509_POLICY_NODE *node);
+    STACK_OF(POLICYQUALINFO)
+    *X509_policy_node_get0_qualifiers(const X509_POLICY_NODE* node);
+    const X509_POLICY_NODE* X509_policy_node_get0_parent(const X509_POLICY_NODE* node);
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509err.h b/CAPI/cpp/grpc/include/openssl/x509err.h
index a56facd..239c699 100644
--- a/CAPI/cpp/grpc/include/openssl/x509err.h
+++ b/CAPI/cpp/grpc/include/openssl/x509err.h
@@ -9,60 +9,58 @@
  */
 
 #ifndef OPENSSL_X509ERR_H
-# define OPENSSL_X509ERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_X509ERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * X509 reason codes.
  */
-# define X509_R_AKID_MISMATCH                             110
-# define X509_R_BAD_SELECTOR                              133
-# define X509_R_BAD_X509_FILETYPE                         100
-# define X509_R_BASE64_DECODE_ERROR                       118
-# define X509_R_CANT_CHECK_DH_KEY                         114
-# define X509_R_CERTIFICATE_VERIFICATION_FAILED           139
-# define X509_R_CERT_ALREADY_IN_HASH_TABLE                101
-# define X509_R_CRL_ALREADY_DELTA                         127
-# define X509_R_CRL_VERIFY_FAILURE                        131
-# define X509_R_ERROR_GETTING_MD_BY_NID                   141
-# define X509_R_ERROR_USING_SIGINF_SET                    142
-# define X509_R_IDP_MISMATCH                              128
-# define X509_R_INVALID_ATTRIBUTES                        138
-# define X509_R_INVALID_DIRECTORY                         113
-# define X509_R_INVALID_DISTPOINT                         143
-# define X509_R_INVALID_FIELD_NAME                        119
-# define X509_R_INVALID_TRUST                             123
-# define X509_R_ISSUER_MISMATCH                           129
-# define X509_R_KEY_TYPE_MISMATCH                         115
-# define X509_R_KEY_VALUES_MISMATCH                       116
-# define X509_R_LOADING_CERT_DIR                          103
-# define X509_R_LOADING_DEFAULTS                          104
-# define X509_R_METHOD_NOT_SUPPORTED                      124
-# define X509_R_NAME_TOO_LONG                             134
-# define X509_R_NEWER_CRL_NOT_NEWER                       132
-# define X509_R_NO_CERTIFICATE_FOUND                      135
-# define X509_R_NO_CERTIFICATE_OR_CRL_FOUND               136
-# define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY              105
-# define X509_R_NO_CRL_FOUND                              137
-# define X509_R_NO_CRL_NUMBER                             130
-# define X509_R_PUBLIC_KEY_DECODE_ERROR                   125
-# define X509_R_PUBLIC_KEY_ENCODE_ERROR                   126
-# define X509_R_SHOULD_RETRY                              106
-# define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN        107
-# define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY            108
-# define X509_R_UNKNOWN_KEY_TYPE                          117
-# define X509_R_UNKNOWN_NID                               109
-# define X509_R_UNKNOWN_PURPOSE_ID                        121
-# define X509_R_UNKNOWN_SIGID_ALGS                        144
-# define X509_R_UNKNOWN_TRUST_ID                          120
-# define X509_R_UNSUPPORTED_ALGORITHM                     111
-# define X509_R_WRONG_LOOKUP_TYPE                         112
-# define X509_R_WRONG_TYPE                                122
+#define X509_R_AKID_MISMATCH 110
+#define X509_R_BAD_SELECTOR 133
+#define X509_R_BAD_X509_FILETYPE 100
+#define X509_R_BASE64_DECODE_ERROR 118
+#define X509_R_CANT_CHECK_DH_KEY 114
+#define X509_R_CERTIFICATE_VERIFICATION_FAILED 139
+#define X509_R_CERT_ALREADY_IN_HASH_TABLE 101
+#define X509_R_CRL_ALREADY_DELTA 127
+#define X509_R_CRL_VERIFY_FAILURE 131
+#define X509_R_ERROR_GETTING_MD_BY_NID 141
+#define X509_R_ERROR_USING_SIGINF_SET 142
+#define X509_R_IDP_MISMATCH 128
+#define X509_R_INVALID_ATTRIBUTES 138
+#define X509_R_INVALID_DIRECTORY 113
+#define X509_R_INVALID_DISTPOINT 143
+#define X509_R_INVALID_FIELD_NAME 119
+#define X509_R_INVALID_TRUST 123
+#define X509_R_ISSUER_MISMATCH 129
+#define X509_R_KEY_TYPE_MISMATCH 115
+#define X509_R_KEY_VALUES_MISMATCH 116
+#define X509_R_LOADING_CERT_DIR 103
+#define X509_R_LOADING_DEFAULTS 104
+#define X509_R_METHOD_NOT_SUPPORTED 124
+#define X509_R_NAME_TOO_LONG 134
+#define X509_R_NEWER_CRL_NOT_NEWER 132
+#define X509_R_NO_CERTIFICATE_FOUND 135
+#define X509_R_NO_CERTIFICATE_OR_CRL_FOUND 136
+#define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY 105
+#define X509_R_NO_CRL_FOUND 137
+#define X509_R_NO_CRL_NUMBER 130
+#define X509_R_PUBLIC_KEY_DECODE_ERROR 125
+#define X509_R_PUBLIC_KEY_ENCODE_ERROR 126
+#define X509_R_SHOULD_RETRY 106
+#define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN 107
+#define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY 108
+#define X509_R_UNKNOWN_KEY_TYPE 117
+#define X509_R_UNKNOWN_NID 109
+#define X509_R_UNKNOWN_PURPOSE_ID 121
+#define X509_R_UNKNOWN_SIGID_ALGS 144
+#define X509_R_UNKNOWN_TRUST_ID 120
+#define X509_R_UNSUPPORTED_ALGORITHM 111
+#define X509_R_WRONG_LOOKUP_TYPE 112
+#define X509_R_WRONG_TYPE 122
 
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509v3.h b/CAPI/cpp/grpc/include/openssl/x509v3.h
index 78c390b..ddb2a1d 100644
--- a/CAPI/cpp/grpc/include/openssl/x509v3.h
+++ b/CAPI/cpp/grpc/include/openssl/x509v3.h
@@ -10,1238 +10,1208 @@
  * https://www.openssl.org/source/license.html
  */
 
-
-
 #ifndef OPENSSL_X509V3_H
-# define OPENSSL_X509V3_H
-# pragma once
+#define OPENSSL_X509V3_H
+#pragma once
 
-# include <openssl/macros.h>
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define HEADER_X509V3_H
-# endif
+#include <openssl/macros.h>
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define HEADER_X509V3_H
+#endif
 
-# include <openssl/bio.h>
-# include <openssl/x509.h>
-# include <openssl/conf.h>
-# include <openssl/x509v3err.h>
+#include <openssl/bio.h>
+#include <openssl/x509.h>
+#include <openssl/conf.h>
+#include <openssl/x509v3err.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/* Forward reference */
-struct v3_ext_method;
-struct v3_ext_ctx;
-
-/* Useful typedefs */
-
-typedef void *(*X509V3_EXT_NEW)(void);
-typedef void (*X509V3_EXT_FREE) (void *);
-typedef void *(*X509V3_EXT_D2I)(void *, const unsigned char **, long);
-typedef int (*X509V3_EXT_I2D) (const void *, unsigned char **);
-typedef STACK_OF(CONF_VALUE) *
-    (*X509V3_EXT_I2V) (const struct v3_ext_method *method, void *ext,
-                       STACK_OF(CONF_VALUE) *extlist);
-typedef void *(*X509V3_EXT_V2I)(const struct v3_ext_method *method,
-                                struct v3_ext_ctx *ctx,
-                                STACK_OF(CONF_VALUE) *values);
-typedef char *(*X509V3_EXT_I2S)(const struct v3_ext_method *method,
-                                void *ext);
-typedef void *(*X509V3_EXT_S2I)(const struct v3_ext_method *method,
-                                struct v3_ext_ctx *ctx, const char *str);
-typedef int (*X509V3_EXT_I2R) (const struct v3_ext_method *method, void *ext,
-                               BIO *out, int indent);
-typedef void *(*X509V3_EXT_R2I)(const struct v3_ext_method *method,
-                                struct v3_ext_ctx *ctx, const char *str);
-
-/* V3 extension structure */
-
-struct v3_ext_method {
-    int ext_nid;
-    int ext_flags;
-/* If this is set the following four fields are ignored */
-    ASN1_ITEM_EXP *it;
-/* Old style ASN1 calls */
-    X509V3_EXT_NEW ext_new;
-    X509V3_EXT_FREE ext_free;
-    X509V3_EXT_D2I d2i;
-    X509V3_EXT_I2D i2d;
-/* The following pair is used for string extensions */
-    X509V3_EXT_I2S i2s;
-    X509V3_EXT_S2I s2i;
-/* The following pair is used for multi-valued extensions */
-    X509V3_EXT_I2V i2v;
-    X509V3_EXT_V2I v2i;
-/* The following are used for raw extensions */
-    X509V3_EXT_I2R i2r;
-    X509V3_EXT_R2I r2i;
-    void *usr_data;             /* Any extension specific data */
-};
-
-typedef struct X509V3_CONF_METHOD_st {
-    char *(*get_string) (void *db, const char *section, const char *value);
-    STACK_OF(CONF_VALUE) *(*get_section) (void *db, const char *section);
-    void (*free_string) (void *db, char *string);
-    void (*free_section) (void *db, STACK_OF(CONF_VALUE) *section);
-} X509V3_CONF_METHOD;
-
-/* Context specific info for producing X509 v3 extensions*/
-struct v3_ext_ctx {
-# define X509V3_CTX_TEST 0x1
-# ifndef OPENSSL_NO_DEPRECATED_3_0
-#  define CTX_TEST X509V3_CTX_TEST
-# endif
-# define X509V3_CTX_REPLACE 0x2
-    int flags;
-    X509 *issuer_cert;
-    X509 *subject_cert;
-    X509_REQ *subject_req;
-    X509_CRL *crl;
-    X509V3_CONF_METHOD *db_meth;
-    void *db;
-    EVP_PKEY *issuer_pkey;
-/* Maybe more here */
-};
-
-typedef struct v3_ext_method X509V3_EXT_METHOD;
-
-SKM_DEFINE_STACK_OF_INTERNAL(X509V3_EXT_METHOD, X509V3_EXT_METHOD, X509V3_EXT_METHOD)
+    /* Forward reference */
+    struct v3_ext_method;
+    struct v3_ext_ctx;
+
+    /* Useful typedefs */
+
+    typedef void* (*X509V3_EXT_NEW)(void);
+    typedef void (*X509V3_EXT_FREE)(void*);
+    typedef void* (*X509V3_EXT_D2I)(void*, const unsigned char**, long);
+    typedef int (*X509V3_EXT_I2D)(const void*, unsigned char**);
+    typedef STACK_OF(CONF_VALUE) *
+        (*X509V3_EXT_I2V)(const struct v3_ext_method* method, void* ext, STACK_OF(CONF_VALUE) * extlist);
+    typedef void* (*X509V3_EXT_V2I)(const struct v3_ext_method* method, struct v3_ext_ctx* ctx, STACK_OF(CONF_VALUE) * values);
+    typedef char* (*X509V3_EXT_I2S)(const struct v3_ext_method* method, void* ext);
+    typedef void* (*X509V3_EXT_S2I)(const struct v3_ext_method* method, struct v3_ext_ctx* ctx, const char* str);
+    typedef int (*X509V3_EXT_I2R)(const struct v3_ext_method* method, void* ext, BIO* out, int indent);
+    typedef void* (*X509V3_EXT_R2I)(const struct v3_ext_method* method, struct v3_ext_ctx* ctx, const char* str);
+
+    /* V3 extension structure */
+
+    struct v3_ext_method
+    {
+        int ext_nid;
+        int ext_flags;
+        /* If this is set the following four fields are ignored */
+        ASN1_ITEM_EXP* it;
+        /* Old style ASN1 calls */
+        X509V3_EXT_NEW ext_new;
+        X509V3_EXT_FREE ext_free;
+        X509V3_EXT_D2I d2i;
+        X509V3_EXT_I2D i2d;
+        /* The following pair is used for string extensions */
+        X509V3_EXT_I2S i2s;
+        X509V3_EXT_S2I s2i;
+        /* The following pair is used for multi-valued extensions */
+        X509V3_EXT_I2V i2v;
+        X509V3_EXT_V2I v2i;
+        /* The following are used for raw extensions */
+        X509V3_EXT_I2R i2r;
+        X509V3_EXT_R2I r2i;
+        void* usr_data; /* Any extension specific data */
+    };
+
+    typedef struct X509V3_CONF_METHOD_st
+    {
+        char* (*get_string)(void* db, const char* section, const char* value);
+        STACK_OF(CONF_VALUE) * (*get_section)(void* db, const char* section);
+        void (*free_string)(void* db, char* string);
+        void (*free_section)(void* db, STACK_OF(CONF_VALUE) * section);
+    } X509V3_CONF_METHOD;
+
+    /* Context specific info for producing X509 v3 extensions*/
+    struct v3_ext_ctx
+    {
+#define X509V3_CTX_TEST 0x1
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+#define CTX_TEST X509V3_CTX_TEST
+#endif
+#define X509V3_CTX_REPLACE 0x2
+        int flags;
+        X509* issuer_cert;
+        X509* subject_cert;
+        X509_REQ* subject_req;
+        X509_CRL* crl;
+        X509V3_CONF_METHOD* db_meth;
+        void* db;
+        EVP_PKEY* issuer_pkey;
+        /* Maybe more here */
+    };
+
+    typedef struct v3_ext_method X509V3_EXT_METHOD;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(X509V3_EXT_METHOD, X509V3_EXT_METHOD, X509V3_EXT_METHOD)
 #define sk_X509V3_EXT_METHOD_num(sk) OPENSSL_sk_num(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk))
-#define sk_X509V3_EXT_METHOD_value(sk, idx) ((X509V3_EXT_METHOD *)OPENSSL_sk_value(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk), (idx)))
-#define sk_X509V3_EXT_METHOD_new(cmp) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new(ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp)))
-#define sk_X509V3_EXT_METHOD_new_null() ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new_null())
-#define sk_X509V3_EXT_METHOD_new_reserve(cmp, n) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_new_reserve(ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp), (n)))
+#define sk_X509V3_EXT_METHOD_value(sk, idx) ((X509V3_EXT_METHOD*)OPENSSL_sk_value(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk), (idx)))
+#define sk_X509V3_EXT_METHOD_new(cmp) ((STACK_OF(X509V3_EXT_METHOD)*)OPENSSL_sk_new(ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp)))
+#define sk_X509V3_EXT_METHOD_new_null() ((STACK_OF(X509V3_EXT_METHOD)*)OPENSSL_sk_new_null())
+#define sk_X509V3_EXT_METHOD_new_reserve(cmp, n) ((STACK_OF(X509V3_EXT_METHOD)*)OPENSSL_sk_new_reserve(ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp), (n)))
 #define sk_X509V3_EXT_METHOD_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (n))
 #define sk_X509V3_EXT_METHOD_free(sk) OPENSSL_sk_free(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
 #define sk_X509V3_EXT_METHOD_zero(sk) OPENSSL_sk_zero(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
-#define sk_X509V3_EXT_METHOD_delete(sk, i) ((X509V3_EXT_METHOD *)OPENSSL_sk_delete(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (i)))
-#define sk_X509V3_EXT_METHOD_delete_ptr(sk, ptr) ((X509V3_EXT_METHOD *)OPENSSL_sk_delete_ptr(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr)))
+#define sk_X509V3_EXT_METHOD_delete(sk, i) ((X509V3_EXT_METHOD*)OPENSSL_sk_delete(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (i)))
+#define sk_X509V3_EXT_METHOD_delete_ptr(sk, ptr) ((X509V3_EXT_METHOD*)OPENSSL_sk_delete_ptr(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr)))
 #define sk_X509V3_EXT_METHOD_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
 #define sk_X509V3_EXT_METHOD_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
-#define sk_X509V3_EXT_METHOD_pop(sk) ((X509V3_EXT_METHOD *)OPENSSL_sk_pop(ossl_check_X509V3_EXT_METHOD_sk_type(sk)))
-#define sk_X509V3_EXT_METHOD_shift(sk) ((X509V3_EXT_METHOD *)OPENSSL_sk_shift(ossl_check_X509V3_EXT_METHOD_sk_type(sk)))
-#define sk_X509V3_EXT_METHOD_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509V3_EXT_METHOD_sk_type(sk),ossl_check_X509V3_EXT_METHOD_freefunc_type(freefunc))
+#define sk_X509V3_EXT_METHOD_pop(sk) ((X509V3_EXT_METHOD*)OPENSSL_sk_pop(ossl_check_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_shift(sk) ((X509V3_EXT_METHOD*)OPENSSL_sk_shift(ossl_check_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_freefunc_type(freefunc))
 #define sk_X509V3_EXT_METHOD_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr), (idx))
-#define sk_X509V3_EXT_METHOD_set(sk, idx, ptr) ((X509V3_EXT_METHOD *)OPENSSL_sk_set(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (idx), ossl_check_X509V3_EXT_METHOD_type(ptr)))
+#define sk_X509V3_EXT_METHOD_set(sk, idx, ptr) ((X509V3_EXT_METHOD*)OPENSSL_sk_set(ossl_check_X509V3_EXT_METHOD_sk_type(sk), (idx), ossl_check_X509V3_EXT_METHOD_type(ptr)))
 #define sk_X509V3_EXT_METHOD_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
 #define sk_X509V3_EXT_METHOD_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr))
 #define sk_X509V3_EXT_METHOD_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_type(ptr), pnum)
 #define sk_X509V3_EXT_METHOD_sort(sk) OPENSSL_sk_sort(ossl_check_X509V3_EXT_METHOD_sk_type(sk))
 #define sk_X509V3_EXT_METHOD_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk))
-#define sk_X509V3_EXT_METHOD_dup(sk) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_dup(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk)))
-#define sk_X509V3_EXT_METHOD_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509V3_EXT_METHOD) *)OPENSSL_sk_deep_copy(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_copyfunc_type(copyfunc), ossl_check_X509V3_EXT_METHOD_freefunc_type(freefunc)))
+#define sk_X509V3_EXT_METHOD_dup(sk) ((STACK_OF(X509V3_EXT_METHOD)*)OPENSSL_sk_dup(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk)))
+#define sk_X509V3_EXT_METHOD_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509V3_EXT_METHOD)*)OPENSSL_sk_deep_copy(ossl_check_const_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_copyfunc_type(copyfunc), ossl_check_X509V3_EXT_METHOD_freefunc_type(freefunc)))
 #define sk_X509V3_EXT_METHOD_set_cmp_func(sk, cmp) ((sk_X509V3_EXT_METHOD_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509V3_EXT_METHOD_sk_type(sk), ossl_check_X509V3_EXT_METHOD_compfunc_type(cmp)))
 
-
 /* ext_flags values */
-# define X509V3_EXT_DYNAMIC      0x1
-# define X509V3_EXT_CTX_DEP      0x2
-# define X509V3_EXT_MULTILINE    0x4
-
-typedef BIT_STRING_BITNAME ENUMERATED_NAMES;
-
-typedef struct BASIC_CONSTRAINTS_st {
-    int ca;
-    ASN1_INTEGER *pathlen;
-} BASIC_CONSTRAINTS;
-
-typedef struct PKEY_USAGE_PERIOD_st {
-    ASN1_GENERALIZEDTIME *notBefore;
-    ASN1_GENERALIZEDTIME *notAfter;
-} PKEY_USAGE_PERIOD;
-
-typedef struct otherName_st {
-    ASN1_OBJECT *type_id;
-    ASN1_TYPE *value;
-} OTHERNAME;
-
-typedef struct EDIPartyName_st {
-    ASN1_STRING *nameAssigner;
-    ASN1_STRING *partyName;
-} EDIPARTYNAME;
-
-typedef struct GENERAL_NAME_st {
-# define GEN_OTHERNAME   0
-# define GEN_EMAIL       1
-# define GEN_DNS         2
-# define GEN_X400        3
-# define GEN_DIRNAME     4
-# define GEN_EDIPARTY    5
-# define GEN_URI         6
-# define GEN_IPADD       7
-# define GEN_RID         8
-    int type;
-    union {
-        char *ptr;
-        OTHERNAME *otherName;   /* otherName */
-        ASN1_IA5STRING *rfc822Name;
-        ASN1_IA5STRING *dNSName;
-        ASN1_TYPE *x400Address;
-        X509_NAME *directoryName;
-        EDIPARTYNAME *ediPartyName;
-        ASN1_IA5STRING *uniformResourceIdentifier;
-        ASN1_OCTET_STRING *iPAddress;
-        ASN1_OBJECT *registeredID;
-        /* Old names */
-        ASN1_OCTET_STRING *ip;  /* iPAddress */
-        X509_NAME *dirn;        /* dirn */
-        ASN1_IA5STRING *ia5;    /* rfc822Name, dNSName,
-                                 * uniformResourceIdentifier */
-        ASN1_OBJECT *rid;       /* registeredID */
-        ASN1_TYPE *other;       /* x400Address */
-    } d;
-} GENERAL_NAME;
-
-typedef struct ACCESS_DESCRIPTION_st {
-    ASN1_OBJECT *method;
-    GENERAL_NAME *location;
-} ACCESS_DESCRIPTION;
-
-SKM_DEFINE_STACK_OF_INTERNAL(ACCESS_DESCRIPTION, ACCESS_DESCRIPTION, ACCESS_DESCRIPTION)
+#define X509V3_EXT_DYNAMIC 0x1
+#define X509V3_EXT_CTX_DEP 0x2
+#define X509V3_EXT_MULTILINE 0x4
+
+    typedef BIT_STRING_BITNAME ENUMERATED_NAMES;
+
+    typedef struct BASIC_CONSTRAINTS_st
+    {
+        int ca;
+        ASN1_INTEGER* pathlen;
+    } BASIC_CONSTRAINTS;
+
+    typedef struct PKEY_USAGE_PERIOD_st
+    {
+        ASN1_GENERALIZEDTIME* notBefore;
+        ASN1_GENERALIZEDTIME* notAfter;
+    } PKEY_USAGE_PERIOD;
+
+    typedef struct otherName_st
+    {
+        ASN1_OBJECT* type_id;
+        ASN1_TYPE* value;
+    } OTHERNAME;
+
+    typedef struct EDIPartyName_st
+    {
+        ASN1_STRING* nameAssigner;
+        ASN1_STRING* partyName;
+    } EDIPARTYNAME;
+
+    typedef struct GENERAL_NAME_st
+    {
+#define GEN_OTHERNAME 0
+#define GEN_EMAIL 1
+#define GEN_DNS 2
+#define GEN_X400 3
+#define GEN_DIRNAME 4
+#define GEN_EDIPARTY 5
+#define GEN_URI 6
+#define GEN_IPADD 7
+#define GEN_RID 8
+        int type;
+        union
+        {
+            char* ptr;
+            OTHERNAME* otherName; /* otherName */
+            ASN1_IA5STRING* rfc822Name;
+            ASN1_IA5STRING* dNSName;
+            ASN1_TYPE* x400Address;
+            X509_NAME* directoryName;
+            EDIPARTYNAME* ediPartyName;
+            ASN1_IA5STRING* uniformResourceIdentifier;
+            ASN1_OCTET_STRING* iPAddress;
+            ASN1_OBJECT* registeredID;
+            /* Old names */
+            ASN1_OCTET_STRING* ip; /* iPAddress */
+            X509_NAME* dirn;       /* dirn */
+            ASN1_IA5STRING* ia5;   /* rfc822Name, dNSName,
+                                    * uniformResourceIdentifier */
+            ASN1_OBJECT* rid;      /* registeredID */
+            ASN1_TYPE* other;      /* x400Address */
+        } d;
+    } GENERAL_NAME;
+
+    typedef struct ACCESS_DESCRIPTION_st
+    {
+        ASN1_OBJECT* method;
+        GENERAL_NAME* location;
+    } ACCESS_DESCRIPTION;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(ACCESS_DESCRIPTION, ACCESS_DESCRIPTION, ACCESS_DESCRIPTION)
 #define sk_ACCESS_DESCRIPTION_num(sk) OPENSSL_sk_num(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk))
-#define sk_ACCESS_DESCRIPTION_value(sk, idx) ((ACCESS_DESCRIPTION *)OPENSSL_sk_value(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk), (idx)))
-#define sk_ACCESS_DESCRIPTION_new(cmp) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new(ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp)))
-#define sk_ACCESS_DESCRIPTION_new_null() ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new_null())
-#define sk_ACCESS_DESCRIPTION_new_reserve(cmp, n) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_new_reserve(ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp), (n)))
+#define sk_ACCESS_DESCRIPTION_value(sk, idx) ((ACCESS_DESCRIPTION*)OPENSSL_sk_value(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk), (idx)))
+#define sk_ACCESS_DESCRIPTION_new(cmp) ((STACK_OF(ACCESS_DESCRIPTION)*)OPENSSL_sk_new(ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp)))
+#define sk_ACCESS_DESCRIPTION_new_null() ((STACK_OF(ACCESS_DESCRIPTION)*)OPENSSL_sk_new_null())
+#define sk_ACCESS_DESCRIPTION_new_reserve(cmp, n) ((STACK_OF(ACCESS_DESCRIPTION)*)OPENSSL_sk_new_reserve(ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp), (n)))
 #define sk_ACCESS_DESCRIPTION_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (n))
 #define sk_ACCESS_DESCRIPTION_free(sk) OPENSSL_sk_free(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
 #define sk_ACCESS_DESCRIPTION_zero(sk) OPENSSL_sk_zero(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
-#define sk_ACCESS_DESCRIPTION_delete(sk, i) ((ACCESS_DESCRIPTION *)OPENSSL_sk_delete(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (i)))
-#define sk_ACCESS_DESCRIPTION_delete_ptr(sk, ptr) ((ACCESS_DESCRIPTION *)OPENSSL_sk_delete_ptr(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr)))
+#define sk_ACCESS_DESCRIPTION_delete(sk, i) ((ACCESS_DESCRIPTION*)OPENSSL_sk_delete(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (i)))
+#define sk_ACCESS_DESCRIPTION_delete_ptr(sk, ptr) ((ACCESS_DESCRIPTION*)OPENSSL_sk_delete_ptr(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr)))
 #define sk_ACCESS_DESCRIPTION_push(sk, ptr) OPENSSL_sk_push(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
 #define sk_ACCESS_DESCRIPTION_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
-#define sk_ACCESS_DESCRIPTION_pop(sk) ((ACCESS_DESCRIPTION *)OPENSSL_sk_pop(ossl_check_ACCESS_DESCRIPTION_sk_type(sk)))
-#define sk_ACCESS_DESCRIPTION_shift(sk) ((ACCESS_DESCRIPTION *)OPENSSL_sk_shift(ossl_check_ACCESS_DESCRIPTION_sk_type(sk)))
-#define sk_ACCESS_DESCRIPTION_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ACCESS_DESCRIPTION_sk_type(sk),ossl_check_ACCESS_DESCRIPTION_freefunc_type(freefunc))
+#define sk_ACCESS_DESCRIPTION_pop(sk) ((ACCESS_DESCRIPTION*)OPENSSL_sk_pop(ossl_check_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_shift(sk) ((ACCESS_DESCRIPTION*)OPENSSL_sk_shift(ossl_check_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_freefunc_type(freefunc))
 #define sk_ACCESS_DESCRIPTION_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr), (idx))
-#define sk_ACCESS_DESCRIPTION_set(sk, idx, ptr) ((ACCESS_DESCRIPTION *)OPENSSL_sk_set(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (idx), ossl_check_ACCESS_DESCRIPTION_type(ptr)))
+#define sk_ACCESS_DESCRIPTION_set(sk, idx, ptr) ((ACCESS_DESCRIPTION*)OPENSSL_sk_set(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), (idx), ossl_check_ACCESS_DESCRIPTION_type(ptr)))
 #define sk_ACCESS_DESCRIPTION_find(sk, ptr) OPENSSL_sk_find(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
 #define sk_ACCESS_DESCRIPTION_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr))
 #define sk_ACCESS_DESCRIPTION_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_type(ptr), pnum)
 #define sk_ACCESS_DESCRIPTION_sort(sk) OPENSSL_sk_sort(ossl_check_ACCESS_DESCRIPTION_sk_type(sk))
 #define sk_ACCESS_DESCRIPTION_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk))
-#define sk_ACCESS_DESCRIPTION_dup(sk) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_dup(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk)))
-#define sk_ACCESS_DESCRIPTION_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ACCESS_DESCRIPTION) *)OPENSSL_sk_deep_copy(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_copyfunc_type(copyfunc), ossl_check_ACCESS_DESCRIPTION_freefunc_type(freefunc)))
+#define sk_ACCESS_DESCRIPTION_dup(sk) ((STACK_OF(ACCESS_DESCRIPTION)*)OPENSSL_sk_dup(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk)))
+#define sk_ACCESS_DESCRIPTION_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ACCESS_DESCRIPTION)*)OPENSSL_sk_deep_copy(ossl_check_const_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_copyfunc_type(copyfunc), ossl_check_ACCESS_DESCRIPTION_freefunc_type(freefunc)))
 #define sk_ACCESS_DESCRIPTION_set_cmp_func(sk, cmp) ((sk_ACCESS_DESCRIPTION_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ACCESS_DESCRIPTION_sk_type(sk), ossl_check_ACCESS_DESCRIPTION_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_NAME, GENERAL_NAME, GENERAL_NAME)
+    SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_NAME, GENERAL_NAME, GENERAL_NAME)
 #define sk_GENERAL_NAME_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_NAME_sk_type(sk))
-#define sk_GENERAL_NAME_value(sk, idx) ((GENERAL_NAME *)OPENSSL_sk_value(ossl_check_const_GENERAL_NAME_sk_type(sk), (idx)))
-#define sk_GENERAL_NAME_new(cmp) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new(ossl_check_GENERAL_NAME_compfunc_type(cmp)))
-#define sk_GENERAL_NAME_new_null() ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new_null())
-#define sk_GENERAL_NAME_new_reserve(cmp, n) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_NAME_compfunc_type(cmp), (n)))
+#define sk_GENERAL_NAME_value(sk, idx) ((GENERAL_NAME*)OPENSSL_sk_value(ossl_check_const_GENERAL_NAME_sk_type(sk), (idx)))
+#define sk_GENERAL_NAME_new(cmp) ((STACK_OF(GENERAL_NAME)*)OPENSSL_sk_new(ossl_check_GENERAL_NAME_compfunc_type(cmp)))
+#define sk_GENERAL_NAME_new_null() ((STACK_OF(GENERAL_NAME)*)OPENSSL_sk_new_null())
+#define sk_GENERAL_NAME_new_reserve(cmp, n) ((STACK_OF(GENERAL_NAME)*)OPENSSL_sk_new_reserve(ossl_check_GENERAL_NAME_compfunc_type(cmp), (n)))
 #define sk_GENERAL_NAME_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_NAME_sk_type(sk), (n))
 #define sk_GENERAL_NAME_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_NAME_sk_type(sk))
 #define sk_GENERAL_NAME_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_NAME_sk_type(sk))
-#define sk_GENERAL_NAME_delete(sk, i) ((GENERAL_NAME *)OPENSSL_sk_delete(ossl_check_GENERAL_NAME_sk_type(sk), (i)))
-#define sk_GENERAL_NAME_delete_ptr(sk, ptr) ((GENERAL_NAME *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr)))
+#define sk_GENERAL_NAME_delete(sk, i) ((GENERAL_NAME*)OPENSSL_sk_delete(ossl_check_GENERAL_NAME_sk_type(sk), (i)))
+#define sk_GENERAL_NAME_delete_ptr(sk, ptr) ((GENERAL_NAME*)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr)))
 #define sk_GENERAL_NAME_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
 #define sk_GENERAL_NAME_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
-#define sk_GENERAL_NAME_pop(sk) ((GENERAL_NAME *)OPENSSL_sk_pop(ossl_check_GENERAL_NAME_sk_type(sk)))
-#define sk_GENERAL_NAME_shift(sk) ((GENERAL_NAME *)OPENSSL_sk_shift(ossl_check_GENERAL_NAME_sk_type(sk)))
-#define sk_GENERAL_NAME_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_NAME_sk_type(sk),ossl_check_GENERAL_NAME_freefunc_type(freefunc))
+#define sk_GENERAL_NAME_pop(sk) ((GENERAL_NAME*)OPENSSL_sk_pop(ossl_check_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_shift(sk) ((GENERAL_NAME*)OPENSSL_sk_shift(ossl_check_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_freefunc_type(freefunc))
 #define sk_GENERAL_NAME_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr), (idx))
-#define sk_GENERAL_NAME_set(sk, idx, ptr) ((GENERAL_NAME *)OPENSSL_sk_set(ossl_check_GENERAL_NAME_sk_type(sk), (idx), ossl_check_GENERAL_NAME_type(ptr)))
+#define sk_GENERAL_NAME_set(sk, idx, ptr) ((GENERAL_NAME*)OPENSSL_sk_set(ossl_check_GENERAL_NAME_sk_type(sk), (idx), ossl_check_GENERAL_NAME_type(ptr)))
 #define sk_GENERAL_NAME_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
 #define sk_GENERAL_NAME_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr))
 #define sk_GENERAL_NAME_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_type(ptr), pnum)
 #define sk_GENERAL_NAME_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_NAME_sk_type(sk))
 #define sk_GENERAL_NAME_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_NAME_sk_type(sk))
-#define sk_GENERAL_NAME_dup(sk) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_NAME_sk_type(sk)))
-#define sk_GENERAL_NAME_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_NAME) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_copyfunc_type(copyfunc), ossl_check_GENERAL_NAME_freefunc_type(freefunc)))
+#define sk_GENERAL_NAME_dup(sk) ((STACK_OF(GENERAL_NAME)*)OPENSSL_sk_dup(ossl_check_const_GENERAL_NAME_sk_type(sk)))
+#define sk_GENERAL_NAME_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_NAME)*)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_copyfunc_type(copyfunc), ossl_check_GENERAL_NAME_freefunc_type(freefunc)))
 #define sk_GENERAL_NAME_set_cmp_func(sk, cmp) ((sk_GENERAL_NAME_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_NAME_sk_type(sk), ossl_check_GENERAL_NAME_compfunc_type(cmp)))
 
+    typedef STACK_OF(ACCESS_DESCRIPTION) AUTHORITY_INFO_ACCESS;
+    typedef STACK_OF(ASN1_OBJECT) EXTENDED_KEY_USAGE;
+    typedef STACK_OF(ASN1_INTEGER) TLS_FEATURE;
+    typedef STACK_OF(GENERAL_NAME) GENERAL_NAMES;
 
-typedef STACK_OF(ACCESS_DESCRIPTION) AUTHORITY_INFO_ACCESS;
-typedef STACK_OF(ASN1_OBJECT) EXTENDED_KEY_USAGE;
-typedef STACK_OF(ASN1_INTEGER) TLS_FEATURE;
-typedef STACK_OF(GENERAL_NAME) GENERAL_NAMES;
-
-SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_NAMES, GENERAL_NAMES, GENERAL_NAMES)
+    SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_NAMES, GENERAL_NAMES, GENERAL_NAMES)
 #define sk_GENERAL_NAMES_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_NAMES_sk_type(sk))
-#define sk_GENERAL_NAMES_value(sk, idx) ((GENERAL_NAMES *)OPENSSL_sk_value(ossl_check_const_GENERAL_NAMES_sk_type(sk), (idx)))
-#define sk_GENERAL_NAMES_new(cmp) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new(ossl_check_GENERAL_NAMES_compfunc_type(cmp)))
-#define sk_GENERAL_NAMES_new_null() ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new_null())
-#define sk_GENERAL_NAMES_new_reserve(cmp, n) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_NAMES_compfunc_type(cmp), (n)))
+#define sk_GENERAL_NAMES_value(sk, idx) ((GENERAL_NAMES*)OPENSSL_sk_value(ossl_check_const_GENERAL_NAMES_sk_type(sk), (idx)))
+#define sk_GENERAL_NAMES_new(cmp) ((STACK_OF(GENERAL_NAMES)*)OPENSSL_sk_new(ossl_check_GENERAL_NAMES_compfunc_type(cmp)))
+#define sk_GENERAL_NAMES_new_null() ((STACK_OF(GENERAL_NAMES)*)OPENSSL_sk_new_null())
+#define sk_GENERAL_NAMES_new_reserve(cmp, n) ((STACK_OF(GENERAL_NAMES)*)OPENSSL_sk_new_reserve(ossl_check_GENERAL_NAMES_compfunc_type(cmp), (n)))
 #define sk_GENERAL_NAMES_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_NAMES_sk_type(sk), (n))
 #define sk_GENERAL_NAMES_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_NAMES_sk_type(sk))
 #define sk_GENERAL_NAMES_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_NAMES_sk_type(sk))
-#define sk_GENERAL_NAMES_delete(sk, i) ((GENERAL_NAMES *)OPENSSL_sk_delete(ossl_check_GENERAL_NAMES_sk_type(sk), (i)))
-#define sk_GENERAL_NAMES_delete_ptr(sk, ptr) ((GENERAL_NAMES *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr)))
+#define sk_GENERAL_NAMES_delete(sk, i) ((GENERAL_NAMES*)OPENSSL_sk_delete(ossl_check_GENERAL_NAMES_sk_type(sk), (i)))
+#define sk_GENERAL_NAMES_delete_ptr(sk, ptr) ((GENERAL_NAMES*)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr)))
 #define sk_GENERAL_NAMES_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
 #define sk_GENERAL_NAMES_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
-#define sk_GENERAL_NAMES_pop(sk) ((GENERAL_NAMES *)OPENSSL_sk_pop(ossl_check_GENERAL_NAMES_sk_type(sk)))
-#define sk_GENERAL_NAMES_shift(sk) ((GENERAL_NAMES *)OPENSSL_sk_shift(ossl_check_GENERAL_NAMES_sk_type(sk)))
-#define sk_GENERAL_NAMES_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_NAMES_sk_type(sk),ossl_check_GENERAL_NAMES_freefunc_type(freefunc))
+#define sk_GENERAL_NAMES_pop(sk) ((GENERAL_NAMES*)OPENSSL_sk_pop(ossl_check_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_shift(sk) ((GENERAL_NAMES*)OPENSSL_sk_shift(ossl_check_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_freefunc_type(freefunc))
 #define sk_GENERAL_NAMES_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr), (idx))
-#define sk_GENERAL_NAMES_set(sk, idx, ptr) ((GENERAL_NAMES *)OPENSSL_sk_set(ossl_check_GENERAL_NAMES_sk_type(sk), (idx), ossl_check_GENERAL_NAMES_type(ptr)))
+#define sk_GENERAL_NAMES_set(sk, idx, ptr) ((GENERAL_NAMES*)OPENSSL_sk_set(ossl_check_GENERAL_NAMES_sk_type(sk), (idx), ossl_check_GENERAL_NAMES_type(ptr)))
 #define sk_GENERAL_NAMES_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
 #define sk_GENERAL_NAMES_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr))
 #define sk_GENERAL_NAMES_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_type(ptr), pnum)
 #define sk_GENERAL_NAMES_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_NAMES_sk_type(sk))
 #define sk_GENERAL_NAMES_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_NAMES_sk_type(sk))
-#define sk_GENERAL_NAMES_dup(sk) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_NAMES_sk_type(sk)))
-#define sk_GENERAL_NAMES_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_NAMES) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_copyfunc_type(copyfunc), ossl_check_GENERAL_NAMES_freefunc_type(freefunc)))
+#define sk_GENERAL_NAMES_dup(sk) ((STACK_OF(GENERAL_NAMES)*)OPENSSL_sk_dup(ossl_check_const_GENERAL_NAMES_sk_type(sk)))
+#define sk_GENERAL_NAMES_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_NAMES)*)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_copyfunc_type(copyfunc), ossl_check_GENERAL_NAMES_freefunc_type(freefunc)))
 #define sk_GENERAL_NAMES_set_cmp_func(sk, cmp) ((sk_GENERAL_NAMES_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_NAMES_sk_type(sk), ossl_check_GENERAL_NAMES_compfunc_type(cmp)))
 
-
-typedef struct DIST_POINT_NAME_st {
-    int type;
-    union {
-        GENERAL_NAMES *fullname;
-        STACK_OF(X509_NAME_ENTRY) *relativename;
-    } name;
-/* If relativename then this contains the full distribution point name */
-    X509_NAME *dpname;
-} DIST_POINT_NAME;
+    typedef struct DIST_POINT_NAME_st
+    {
+        int type;
+        union
+        {
+            GENERAL_NAMES* fullname;
+            STACK_OF(X509_NAME_ENTRY) * relativename;
+        } name;
+        /* If relativename then this contains the full distribution point name */
+        X509_NAME* dpname;
+    } DIST_POINT_NAME;
 /* All existing reasons */
-# define CRLDP_ALL_REASONS       0x807f
-
-# define CRL_REASON_NONE                         -1
-# define CRL_REASON_UNSPECIFIED                  0
-# define CRL_REASON_KEY_COMPROMISE               1
-# define CRL_REASON_CA_COMPROMISE                2
-# define CRL_REASON_AFFILIATION_CHANGED          3
-# define CRL_REASON_SUPERSEDED                   4
-# define CRL_REASON_CESSATION_OF_OPERATION       5
-# define CRL_REASON_CERTIFICATE_HOLD             6
-# define CRL_REASON_REMOVE_FROM_CRL              8
-# define CRL_REASON_PRIVILEGE_WITHDRAWN          9
-# define CRL_REASON_AA_COMPROMISE                10
-
-struct DIST_POINT_st {
-    DIST_POINT_NAME *distpoint;
-    ASN1_BIT_STRING *reasons;
-    GENERAL_NAMES *CRLissuer;
-    int dp_reasons;
-};
-
-SKM_DEFINE_STACK_OF_INTERNAL(DIST_POINT, DIST_POINT, DIST_POINT)
+#define CRLDP_ALL_REASONS 0x807f
+
+#define CRL_REASON_NONE -1
+#define CRL_REASON_UNSPECIFIED 0
+#define CRL_REASON_KEY_COMPROMISE 1
+#define CRL_REASON_CA_COMPROMISE 2
+#define CRL_REASON_AFFILIATION_CHANGED 3
+#define CRL_REASON_SUPERSEDED 4
+#define CRL_REASON_CESSATION_OF_OPERATION 5
+#define CRL_REASON_CERTIFICATE_HOLD 6
+#define CRL_REASON_REMOVE_FROM_CRL 8
+#define CRL_REASON_PRIVILEGE_WITHDRAWN 9
+#define CRL_REASON_AA_COMPROMISE 10
+
+    struct DIST_POINT_st
+    {
+        DIST_POINT_NAME* distpoint;
+        ASN1_BIT_STRING* reasons;
+        GENERAL_NAMES* CRLissuer;
+        int dp_reasons;
+    };
+
+    SKM_DEFINE_STACK_OF_INTERNAL(DIST_POINT, DIST_POINT, DIST_POINT)
 #define sk_DIST_POINT_num(sk) OPENSSL_sk_num(ossl_check_const_DIST_POINT_sk_type(sk))
-#define sk_DIST_POINT_value(sk, idx) ((DIST_POINT *)OPENSSL_sk_value(ossl_check_const_DIST_POINT_sk_type(sk), (idx)))
-#define sk_DIST_POINT_new(cmp) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new(ossl_check_DIST_POINT_compfunc_type(cmp)))
-#define sk_DIST_POINT_new_null() ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new_null())
-#define sk_DIST_POINT_new_reserve(cmp, n) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_new_reserve(ossl_check_DIST_POINT_compfunc_type(cmp), (n)))
+#define sk_DIST_POINT_value(sk, idx) ((DIST_POINT*)OPENSSL_sk_value(ossl_check_const_DIST_POINT_sk_type(sk), (idx)))
+#define sk_DIST_POINT_new(cmp) ((STACK_OF(DIST_POINT)*)OPENSSL_sk_new(ossl_check_DIST_POINT_compfunc_type(cmp)))
+#define sk_DIST_POINT_new_null() ((STACK_OF(DIST_POINT)*)OPENSSL_sk_new_null())
+#define sk_DIST_POINT_new_reserve(cmp, n) ((STACK_OF(DIST_POINT)*)OPENSSL_sk_new_reserve(ossl_check_DIST_POINT_compfunc_type(cmp), (n)))
 #define sk_DIST_POINT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_DIST_POINT_sk_type(sk), (n))
 #define sk_DIST_POINT_free(sk) OPENSSL_sk_free(ossl_check_DIST_POINT_sk_type(sk))
 #define sk_DIST_POINT_zero(sk) OPENSSL_sk_zero(ossl_check_DIST_POINT_sk_type(sk))
-#define sk_DIST_POINT_delete(sk, i) ((DIST_POINT *)OPENSSL_sk_delete(ossl_check_DIST_POINT_sk_type(sk), (i)))
-#define sk_DIST_POINT_delete_ptr(sk, ptr) ((DIST_POINT *)OPENSSL_sk_delete_ptr(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr)))
+#define sk_DIST_POINT_delete(sk, i) ((DIST_POINT*)OPENSSL_sk_delete(ossl_check_DIST_POINT_sk_type(sk), (i)))
+#define sk_DIST_POINT_delete_ptr(sk, ptr) ((DIST_POINT*)OPENSSL_sk_delete_ptr(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr)))
 #define sk_DIST_POINT_push(sk, ptr) OPENSSL_sk_push(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
 #define sk_DIST_POINT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
-#define sk_DIST_POINT_pop(sk) ((DIST_POINT *)OPENSSL_sk_pop(ossl_check_DIST_POINT_sk_type(sk)))
-#define sk_DIST_POINT_shift(sk) ((DIST_POINT *)OPENSSL_sk_shift(ossl_check_DIST_POINT_sk_type(sk)))
-#define sk_DIST_POINT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_DIST_POINT_sk_type(sk),ossl_check_DIST_POINT_freefunc_type(freefunc))
+#define sk_DIST_POINT_pop(sk) ((DIST_POINT*)OPENSSL_sk_pop(ossl_check_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_shift(sk) ((DIST_POINT*)OPENSSL_sk_shift(ossl_check_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_freefunc_type(freefunc))
 #define sk_DIST_POINT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr), (idx))
-#define sk_DIST_POINT_set(sk, idx, ptr) ((DIST_POINT *)OPENSSL_sk_set(ossl_check_DIST_POINT_sk_type(sk), (idx), ossl_check_DIST_POINT_type(ptr)))
+#define sk_DIST_POINT_set(sk, idx, ptr) ((DIST_POINT*)OPENSSL_sk_set(ossl_check_DIST_POINT_sk_type(sk), (idx), ossl_check_DIST_POINT_type(ptr)))
 #define sk_DIST_POINT_find(sk, ptr) OPENSSL_sk_find(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
 #define sk_DIST_POINT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr))
 #define sk_DIST_POINT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_type(ptr), pnum)
 #define sk_DIST_POINT_sort(sk) OPENSSL_sk_sort(ossl_check_DIST_POINT_sk_type(sk))
 #define sk_DIST_POINT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_DIST_POINT_sk_type(sk))
-#define sk_DIST_POINT_dup(sk) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_dup(ossl_check_const_DIST_POINT_sk_type(sk)))
-#define sk_DIST_POINT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(DIST_POINT) *)OPENSSL_sk_deep_copy(ossl_check_const_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_copyfunc_type(copyfunc), ossl_check_DIST_POINT_freefunc_type(freefunc)))
+#define sk_DIST_POINT_dup(sk) ((STACK_OF(DIST_POINT)*)OPENSSL_sk_dup(ossl_check_const_DIST_POINT_sk_type(sk)))
+#define sk_DIST_POINT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(DIST_POINT)*)OPENSSL_sk_deep_copy(ossl_check_const_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_copyfunc_type(copyfunc), ossl_check_DIST_POINT_freefunc_type(freefunc)))
 #define sk_DIST_POINT_set_cmp_func(sk, cmp) ((sk_DIST_POINT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_DIST_POINT_sk_type(sk), ossl_check_DIST_POINT_compfunc_type(cmp)))
 
+    typedef STACK_OF(DIST_POINT) CRL_DIST_POINTS;
 
-typedef STACK_OF(DIST_POINT) CRL_DIST_POINTS;
+    struct AUTHORITY_KEYID_st
+    {
+        ASN1_OCTET_STRING* keyid;
+        GENERAL_NAMES* issuer;
+        ASN1_INTEGER* serial;
+    };
 
-struct AUTHORITY_KEYID_st {
-    ASN1_OCTET_STRING *keyid;
-    GENERAL_NAMES *issuer;
-    ASN1_INTEGER *serial;
-};
+    /* Strong extranet structures */
 
-/* Strong extranet structures */
+    typedef struct SXNET_ID_st
+    {
+        ASN1_INTEGER* zone;
+        ASN1_OCTET_STRING* user;
+    } SXNETID;
 
-typedef struct SXNET_ID_st {
-    ASN1_INTEGER *zone;
-    ASN1_OCTET_STRING *user;
-} SXNETID;
-
-SKM_DEFINE_STACK_OF_INTERNAL(SXNETID, SXNETID, SXNETID)
+    SKM_DEFINE_STACK_OF_INTERNAL(SXNETID, SXNETID, SXNETID)
 #define sk_SXNETID_num(sk) OPENSSL_sk_num(ossl_check_const_SXNETID_sk_type(sk))
-#define sk_SXNETID_value(sk, idx) ((SXNETID *)OPENSSL_sk_value(ossl_check_const_SXNETID_sk_type(sk), (idx)))
-#define sk_SXNETID_new(cmp) ((STACK_OF(SXNETID) *)OPENSSL_sk_new(ossl_check_SXNETID_compfunc_type(cmp)))
-#define sk_SXNETID_new_null() ((STACK_OF(SXNETID) *)OPENSSL_sk_new_null())
-#define sk_SXNETID_new_reserve(cmp, n) ((STACK_OF(SXNETID) *)OPENSSL_sk_new_reserve(ossl_check_SXNETID_compfunc_type(cmp), (n)))
+#define sk_SXNETID_value(sk, idx) ((SXNETID*)OPENSSL_sk_value(ossl_check_const_SXNETID_sk_type(sk), (idx)))
+#define sk_SXNETID_new(cmp) ((STACK_OF(SXNETID)*)OPENSSL_sk_new(ossl_check_SXNETID_compfunc_type(cmp)))
+#define sk_SXNETID_new_null() ((STACK_OF(SXNETID)*)OPENSSL_sk_new_null())
+#define sk_SXNETID_new_reserve(cmp, n) ((STACK_OF(SXNETID)*)OPENSSL_sk_new_reserve(ossl_check_SXNETID_compfunc_type(cmp), (n)))
 #define sk_SXNETID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SXNETID_sk_type(sk), (n))
 #define sk_SXNETID_free(sk) OPENSSL_sk_free(ossl_check_SXNETID_sk_type(sk))
 #define sk_SXNETID_zero(sk) OPENSSL_sk_zero(ossl_check_SXNETID_sk_type(sk))
-#define sk_SXNETID_delete(sk, i) ((SXNETID *)OPENSSL_sk_delete(ossl_check_SXNETID_sk_type(sk), (i)))
-#define sk_SXNETID_delete_ptr(sk, ptr) ((SXNETID *)OPENSSL_sk_delete_ptr(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr)))
+#define sk_SXNETID_delete(sk, i) ((SXNETID*)OPENSSL_sk_delete(ossl_check_SXNETID_sk_type(sk), (i)))
+#define sk_SXNETID_delete_ptr(sk, ptr) ((SXNETID*)OPENSSL_sk_delete_ptr(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr)))
 #define sk_SXNETID_push(sk, ptr) OPENSSL_sk_push(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
 #define sk_SXNETID_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
-#define sk_SXNETID_pop(sk) ((SXNETID *)OPENSSL_sk_pop(ossl_check_SXNETID_sk_type(sk)))
-#define sk_SXNETID_shift(sk) ((SXNETID *)OPENSSL_sk_shift(ossl_check_SXNETID_sk_type(sk)))
-#define sk_SXNETID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SXNETID_sk_type(sk),ossl_check_SXNETID_freefunc_type(freefunc))
+#define sk_SXNETID_pop(sk) ((SXNETID*)OPENSSL_sk_pop(ossl_check_SXNETID_sk_type(sk)))
+#define sk_SXNETID_shift(sk) ((SXNETID*)OPENSSL_sk_shift(ossl_check_SXNETID_sk_type(sk)))
+#define sk_SXNETID_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_freefunc_type(freefunc))
 #define sk_SXNETID_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr), (idx))
-#define sk_SXNETID_set(sk, idx, ptr) ((SXNETID *)OPENSSL_sk_set(ossl_check_SXNETID_sk_type(sk), (idx), ossl_check_SXNETID_type(ptr)))
+#define sk_SXNETID_set(sk, idx, ptr) ((SXNETID*)OPENSSL_sk_set(ossl_check_SXNETID_sk_type(sk), (idx), ossl_check_SXNETID_type(ptr)))
 #define sk_SXNETID_find(sk, ptr) OPENSSL_sk_find(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
 #define sk_SXNETID_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr))
 #define sk_SXNETID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_type(ptr), pnum)
 #define sk_SXNETID_sort(sk) OPENSSL_sk_sort(ossl_check_SXNETID_sk_type(sk))
 #define sk_SXNETID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SXNETID_sk_type(sk))
-#define sk_SXNETID_dup(sk) ((STACK_OF(SXNETID) *)OPENSSL_sk_dup(ossl_check_const_SXNETID_sk_type(sk)))
-#define sk_SXNETID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SXNETID) *)OPENSSL_sk_deep_copy(ossl_check_const_SXNETID_sk_type(sk), ossl_check_SXNETID_copyfunc_type(copyfunc), ossl_check_SXNETID_freefunc_type(freefunc)))
+#define sk_SXNETID_dup(sk) ((STACK_OF(SXNETID)*)OPENSSL_sk_dup(ossl_check_const_SXNETID_sk_type(sk)))
+#define sk_SXNETID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SXNETID)*)OPENSSL_sk_deep_copy(ossl_check_const_SXNETID_sk_type(sk), ossl_check_SXNETID_copyfunc_type(copyfunc), ossl_check_SXNETID_freefunc_type(freefunc)))
 #define sk_SXNETID_set_cmp_func(sk, cmp) ((sk_SXNETID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SXNETID_sk_type(sk), ossl_check_SXNETID_compfunc_type(cmp)))
 
-
-
-typedef struct SXNET_st {
-    ASN1_INTEGER *version;
-    STACK_OF(SXNETID) *ids;
-} SXNET;
-
-typedef struct ISSUER_SIGN_TOOL_st {
-    ASN1_UTF8STRING *signTool;
-    ASN1_UTF8STRING *cATool;
-    ASN1_UTF8STRING *signToolCert;
-    ASN1_UTF8STRING *cAToolCert;
-} ISSUER_SIGN_TOOL;
-
-typedef struct NOTICEREF_st {
-    ASN1_STRING *organization;
-    STACK_OF(ASN1_INTEGER) *noticenos;
-} NOTICEREF;
-
-typedef struct USERNOTICE_st {
-    NOTICEREF *noticeref;
-    ASN1_STRING *exptext;
-} USERNOTICE;
-
-typedef struct POLICYQUALINFO_st {
-    ASN1_OBJECT *pqualid;
-    union {
-        ASN1_IA5STRING *cpsuri;
-        USERNOTICE *usernotice;
-        ASN1_TYPE *other;
-    } d;
-} POLICYQUALINFO;
-
-SKM_DEFINE_STACK_OF_INTERNAL(POLICYQUALINFO, POLICYQUALINFO, POLICYQUALINFO)
+    typedef struct SXNET_st
+    {
+        ASN1_INTEGER* version;
+        STACK_OF(SXNETID) * ids;
+    } SXNET;
+
+    typedef struct ISSUER_SIGN_TOOL_st
+    {
+        ASN1_UTF8STRING* signTool;
+        ASN1_UTF8STRING* cATool;
+        ASN1_UTF8STRING* signToolCert;
+        ASN1_UTF8STRING* cAToolCert;
+    } ISSUER_SIGN_TOOL;
+
+    typedef struct NOTICEREF_st
+    {
+        ASN1_STRING* organization;
+        STACK_OF(ASN1_INTEGER) * noticenos;
+    } NOTICEREF;
+
+    typedef struct USERNOTICE_st
+    {
+        NOTICEREF* noticeref;
+        ASN1_STRING* exptext;
+    } USERNOTICE;
+
+    typedef struct POLICYQUALINFO_st
+    {
+        ASN1_OBJECT* pqualid;
+        union
+        {
+            ASN1_IA5STRING* cpsuri;
+            USERNOTICE* usernotice;
+            ASN1_TYPE* other;
+        } d;
+    } POLICYQUALINFO;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(POLICYQUALINFO, POLICYQUALINFO, POLICYQUALINFO)
 #define sk_POLICYQUALINFO_num(sk) OPENSSL_sk_num(ossl_check_const_POLICYQUALINFO_sk_type(sk))
-#define sk_POLICYQUALINFO_value(sk, idx) ((POLICYQUALINFO *)OPENSSL_sk_value(ossl_check_const_POLICYQUALINFO_sk_type(sk), (idx)))
-#define sk_POLICYQUALINFO_new(cmp) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new(ossl_check_POLICYQUALINFO_compfunc_type(cmp)))
-#define sk_POLICYQUALINFO_new_null() ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new_null())
-#define sk_POLICYQUALINFO_new_reserve(cmp, n) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_new_reserve(ossl_check_POLICYQUALINFO_compfunc_type(cmp), (n)))
+#define sk_POLICYQUALINFO_value(sk, idx) ((POLICYQUALINFO*)OPENSSL_sk_value(ossl_check_const_POLICYQUALINFO_sk_type(sk), (idx)))
+#define sk_POLICYQUALINFO_new(cmp) ((STACK_OF(POLICYQUALINFO)*)OPENSSL_sk_new(ossl_check_POLICYQUALINFO_compfunc_type(cmp)))
+#define sk_POLICYQUALINFO_new_null() ((STACK_OF(POLICYQUALINFO)*)OPENSSL_sk_new_null())
+#define sk_POLICYQUALINFO_new_reserve(cmp, n) ((STACK_OF(POLICYQUALINFO)*)OPENSSL_sk_new_reserve(ossl_check_POLICYQUALINFO_compfunc_type(cmp), (n)))
 #define sk_POLICYQUALINFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICYQUALINFO_sk_type(sk), (n))
 #define sk_POLICYQUALINFO_free(sk) OPENSSL_sk_free(ossl_check_POLICYQUALINFO_sk_type(sk))
 #define sk_POLICYQUALINFO_zero(sk) OPENSSL_sk_zero(ossl_check_POLICYQUALINFO_sk_type(sk))
-#define sk_POLICYQUALINFO_delete(sk, i) ((POLICYQUALINFO *)OPENSSL_sk_delete(ossl_check_POLICYQUALINFO_sk_type(sk), (i)))
-#define sk_POLICYQUALINFO_delete_ptr(sk, ptr) ((POLICYQUALINFO *)OPENSSL_sk_delete_ptr(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr)))
+#define sk_POLICYQUALINFO_delete(sk, i) ((POLICYQUALINFO*)OPENSSL_sk_delete(ossl_check_POLICYQUALINFO_sk_type(sk), (i)))
+#define sk_POLICYQUALINFO_delete_ptr(sk, ptr) ((POLICYQUALINFO*)OPENSSL_sk_delete_ptr(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr)))
 #define sk_POLICYQUALINFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
 #define sk_POLICYQUALINFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
-#define sk_POLICYQUALINFO_pop(sk) ((POLICYQUALINFO *)OPENSSL_sk_pop(ossl_check_POLICYQUALINFO_sk_type(sk)))
-#define sk_POLICYQUALINFO_shift(sk) ((POLICYQUALINFO *)OPENSSL_sk_shift(ossl_check_POLICYQUALINFO_sk_type(sk)))
-#define sk_POLICYQUALINFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICYQUALINFO_sk_type(sk),ossl_check_POLICYQUALINFO_freefunc_type(freefunc))
+#define sk_POLICYQUALINFO_pop(sk) ((POLICYQUALINFO*)OPENSSL_sk_pop(ossl_check_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_shift(sk) ((POLICYQUALINFO*)OPENSSL_sk_shift(ossl_check_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_freefunc_type(freefunc))
 #define sk_POLICYQUALINFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr), (idx))
-#define sk_POLICYQUALINFO_set(sk, idx, ptr) ((POLICYQUALINFO *)OPENSSL_sk_set(ossl_check_POLICYQUALINFO_sk_type(sk), (idx), ossl_check_POLICYQUALINFO_type(ptr)))
+#define sk_POLICYQUALINFO_set(sk, idx, ptr) ((POLICYQUALINFO*)OPENSSL_sk_set(ossl_check_POLICYQUALINFO_sk_type(sk), (idx), ossl_check_POLICYQUALINFO_type(ptr)))
 #define sk_POLICYQUALINFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
 #define sk_POLICYQUALINFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr))
 #define sk_POLICYQUALINFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_type(ptr), pnum)
 #define sk_POLICYQUALINFO_sort(sk) OPENSSL_sk_sort(ossl_check_POLICYQUALINFO_sk_type(sk))
 #define sk_POLICYQUALINFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICYQUALINFO_sk_type(sk))
-#define sk_POLICYQUALINFO_dup(sk) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_dup(ossl_check_const_POLICYQUALINFO_sk_type(sk)))
-#define sk_POLICYQUALINFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICYQUALINFO) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_copyfunc_type(copyfunc), ossl_check_POLICYQUALINFO_freefunc_type(freefunc)))
+#define sk_POLICYQUALINFO_dup(sk) ((STACK_OF(POLICYQUALINFO)*)OPENSSL_sk_dup(ossl_check_const_POLICYQUALINFO_sk_type(sk)))
+#define sk_POLICYQUALINFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICYQUALINFO)*)OPENSSL_sk_deep_copy(ossl_check_const_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_copyfunc_type(copyfunc), ossl_check_POLICYQUALINFO_freefunc_type(freefunc)))
 #define sk_POLICYQUALINFO_set_cmp_func(sk, cmp) ((sk_POLICYQUALINFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICYQUALINFO_sk_type(sk), ossl_check_POLICYQUALINFO_compfunc_type(cmp)))
 
+    typedef struct POLICYINFO_st
+    {
+        ASN1_OBJECT* policyid;
+        STACK_OF(POLICYQUALINFO) * qualifiers;
+    } POLICYINFO;
 
-
-typedef struct POLICYINFO_st {
-    ASN1_OBJECT *policyid;
-    STACK_OF(POLICYQUALINFO) *qualifiers;
-} POLICYINFO;
-
-SKM_DEFINE_STACK_OF_INTERNAL(POLICYINFO, POLICYINFO, POLICYINFO)
+    SKM_DEFINE_STACK_OF_INTERNAL(POLICYINFO, POLICYINFO, POLICYINFO)
 #define sk_POLICYINFO_num(sk) OPENSSL_sk_num(ossl_check_const_POLICYINFO_sk_type(sk))
-#define sk_POLICYINFO_value(sk, idx) ((POLICYINFO *)OPENSSL_sk_value(ossl_check_const_POLICYINFO_sk_type(sk), (idx)))
-#define sk_POLICYINFO_new(cmp) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new(ossl_check_POLICYINFO_compfunc_type(cmp)))
-#define sk_POLICYINFO_new_null() ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new_null())
-#define sk_POLICYINFO_new_reserve(cmp, n) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_new_reserve(ossl_check_POLICYINFO_compfunc_type(cmp), (n)))
+#define sk_POLICYINFO_value(sk, idx) ((POLICYINFO*)OPENSSL_sk_value(ossl_check_const_POLICYINFO_sk_type(sk), (idx)))
+#define sk_POLICYINFO_new(cmp) ((STACK_OF(POLICYINFO)*)OPENSSL_sk_new(ossl_check_POLICYINFO_compfunc_type(cmp)))
+#define sk_POLICYINFO_new_null() ((STACK_OF(POLICYINFO)*)OPENSSL_sk_new_null())
+#define sk_POLICYINFO_new_reserve(cmp, n) ((STACK_OF(POLICYINFO)*)OPENSSL_sk_new_reserve(ossl_check_POLICYINFO_compfunc_type(cmp), (n)))
 #define sk_POLICYINFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICYINFO_sk_type(sk), (n))
 #define sk_POLICYINFO_free(sk) OPENSSL_sk_free(ossl_check_POLICYINFO_sk_type(sk))
 #define sk_POLICYINFO_zero(sk) OPENSSL_sk_zero(ossl_check_POLICYINFO_sk_type(sk))
-#define sk_POLICYINFO_delete(sk, i) ((POLICYINFO *)OPENSSL_sk_delete(ossl_check_POLICYINFO_sk_type(sk), (i)))
-#define sk_POLICYINFO_delete_ptr(sk, ptr) ((POLICYINFO *)OPENSSL_sk_delete_ptr(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr)))
+#define sk_POLICYINFO_delete(sk, i) ((POLICYINFO*)OPENSSL_sk_delete(ossl_check_POLICYINFO_sk_type(sk), (i)))
+#define sk_POLICYINFO_delete_ptr(sk, ptr) ((POLICYINFO*)OPENSSL_sk_delete_ptr(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr)))
 #define sk_POLICYINFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
 #define sk_POLICYINFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
-#define sk_POLICYINFO_pop(sk) ((POLICYINFO *)OPENSSL_sk_pop(ossl_check_POLICYINFO_sk_type(sk)))
-#define sk_POLICYINFO_shift(sk) ((POLICYINFO *)OPENSSL_sk_shift(ossl_check_POLICYINFO_sk_type(sk)))
-#define sk_POLICYINFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICYINFO_sk_type(sk),ossl_check_POLICYINFO_freefunc_type(freefunc))
+#define sk_POLICYINFO_pop(sk) ((POLICYINFO*)OPENSSL_sk_pop(ossl_check_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_shift(sk) ((POLICYINFO*)OPENSSL_sk_shift(ossl_check_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_freefunc_type(freefunc))
 #define sk_POLICYINFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr), (idx))
-#define sk_POLICYINFO_set(sk, idx, ptr) ((POLICYINFO *)OPENSSL_sk_set(ossl_check_POLICYINFO_sk_type(sk), (idx), ossl_check_POLICYINFO_type(ptr)))
+#define sk_POLICYINFO_set(sk, idx, ptr) ((POLICYINFO*)OPENSSL_sk_set(ossl_check_POLICYINFO_sk_type(sk), (idx), ossl_check_POLICYINFO_type(ptr)))
 #define sk_POLICYINFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
 #define sk_POLICYINFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr))
 #define sk_POLICYINFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_type(ptr), pnum)
 #define sk_POLICYINFO_sort(sk) OPENSSL_sk_sort(ossl_check_POLICYINFO_sk_type(sk))
 #define sk_POLICYINFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICYINFO_sk_type(sk))
-#define sk_POLICYINFO_dup(sk) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_dup(ossl_check_const_POLICYINFO_sk_type(sk)))
-#define sk_POLICYINFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICYINFO) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_copyfunc_type(copyfunc), ossl_check_POLICYINFO_freefunc_type(freefunc)))
+#define sk_POLICYINFO_dup(sk) ((STACK_OF(POLICYINFO)*)OPENSSL_sk_dup(ossl_check_const_POLICYINFO_sk_type(sk)))
+#define sk_POLICYINFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICYINFO)*)OPENSSL_sk_deep_copy(ossl_check_const_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_copyfunc_type(copyfunc), ossl_check_POLICYINFO_freefunc_type(freefunc)))
 #define sk_POLICYINFO_set_cmp_func(sk, cmp) ((sk_POLICYINFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICYINFO_sk_type(sk), ossl_check_POLICYINFO_compfunc_type(cmp)))
 
+    typedef STACK_OF(POLICYINFO) CERTIFICATEPOLICIES;
 
-typedef STACK_OF(POLICYINFO) CERTIFICATEPOLICIES;
-
-typedef struct POLICY_MAPPING_st {
-    ASN1_OBJECT *issuerDomainPolicy;
-    ASN1_OBJECT *subjectDomainPolicy;
-} POLICY_MAPPING;
+    typedef struct POLICY_MAPPING_st
+    {
+        ASN1_OBJECT* issuerDomainPolicy;
+        ASN1_OBJECT* subjectDomainPolicy;
+    } POLICY_MAPPING;
 
-SKM_DEFINE_STACK_OF_INTERNAL(POLICY_MAPPING, POLICY_MAPPING, POLICY_MAPPING)
+    SKM_DEFINE_STACK_OF_INTERNAL(POLICY_MAPPING, POLICY_MAPPING, POLICY_MAPPING)
 #define sk_POLICY_MAPPING_num(sk) OPENSSL_sk_num(ossl_check_const_POLICY_MAPPING_sk_type(sk))
-#define sk_POLICY_MAPPING_value(sk, idx) ((POLICY_MAPPING *)OPENSSL_sk_value(ossl_check_const_POLICY_MAPPING_sk_type(sk), (idx)))
-#define sk_POLICY_MAPPING_new(cmp) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new(ossl_check_POLICY_MAPPING_compfunc_type(cmp)))
-#define sk_POLICY_MAPPING_new_null() ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new_null())
-#define sk_POLICY_MAPPING_new_reserve(cmp, n) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_new_reserve(ossl_check_POLICY_MAPPING_compfunc_type(cmp), (n)))
+#define sk_POLICY_MAPPING_value(sk, idx) ((POLICY_MAPPING*)OPENSSL_sk_value(ossl_check_const_POLICY_MAPPING_sk_type(sk), (idx)))
+#define sk_POLICY_MAPPING_new(cmp) ((STACK_OF(POLICY_MAPPING)*)OPENSSL_sk_new(ossl_check_POLICY_MAPPING_compfunc_type(cmp)))
+#define sk_POLICY_MAPPING_new_null() ((STACK_OF(POLICY_MAPPING)*)OPENSSL_sk_new_null())
+#define sk_POLICY_MAPPING_new_reserve(cmp, n) ((STACK_OF(POLICY_MAPPING)*)OPENSSL_sk_new_reserve(ossl_check_POLICY_MAPPING_compfunc_type(cmp), (n)))
 #define sk_POLICY_MAPPING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_POLICY_MAPPING_sk_type(sk), (n))
 #define sk_POLICY_MAPPING_free(sk) OPENSSL_sk_free(ossl_check_POLICY_MAPPING_sk_type(sk))
 #define sk_POLICY_MAPPING_zero(sk) OPENSSL_sk_zero(ossl_check_POLICY_MAPPING_sk_type(sk))
-#define sk_POLICY_MAPPING_delete(sk, i) ((POLICY_MAPPING *)OPENSSL_sk_delete(ossl_check_POLICY_MAPPING_sk_type(sk), (i)))
-#define sk_POLICY_MAPPING_delete_ptr(sk, ptr) ((POLICY_MAPPING *)OPENSSL_sk_delete_ptr(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr)))
+#define sk_POLICY_MAPPING_delete(sk, i) ((POLICY_MAPPING*)OPENSSL_sk_delete(ossl_check_POLICY_MAPPING_sk_type(sk), (i)))
+#define sk_POLICY_MAPPING_delete_ptr(sk, ptr) ((POLICY_MAPPING*)OPENSSL_sk_delete_ptr(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr)))
 #define sk_POLICY_MAPPING_push(sk, ptr) OPENSSL_sk_push(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
 #define sk_POLICY_MAPPING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
-#define sk_POLICY_MAPPING_pop(sk) ((POLICY_MAPPING *)OPENSSL_sk_pop(ossl_check_POLICY_MAPPING_sk_type(sk)))
-#define sk_POLICY_MAPPING_shift(sk) ((POLICY_MAPPING *)OPENSSL_sk_shift(ossl_check_POLICY_MAPPING_sk_type(sk)))
-#define sk_POLICY_MAPPING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICY_MAPPING_sk_type(sk),ossl_check_POLICY_MAPPING_freefunc_type(freefunc))
+#define sk_POLICY_MAPPING_pop(sk) ((POLICY_MAPPING*)OPENSSL_sk_pop(ossl_check_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_shift(sk) ((POLICY_MAPPING*)OPENSSL_sk_shift(ossl_check_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_freefunc_type(freefunc))
 #define sk_POLICY_MAPPING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr), (idx))
-#define sk_POLICY_MAPPING_set(sk, idx, ptr) ((POLICY_MAPPING *)OPENSSL_sk_set(ossl_check_POLICY_MAPPING_sk_type(sk), (idx), ossl_check_POLICY_MAPPING_type(ptr)))
+#define sk_POLICY_MAPPING_set(sk, idx, ptr) ((POLICY_MAPPING*)OPENSSL_sk_set(ossl_check_POLICY_MAPPING_sk_type(sk), (idx), ossl_check_POLICY_MAPPING_type(ptr)))
 #define sk_POLICY_MAPPING_find(sk, ptr) OPENSSL_sk_find(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
 #define sk_POLICY_MAPPING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr))
 #define sk_POLICY_MAPPING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_type(ptr), pnum)
 #define sk_POLICY_MAPPING_sort(sk) OPENSSL_sk_sort(ossl_check_POLICY_MAPPING_sk_type(sk))
 #define sk_POLICY_MAPPING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_POLICY_MAPPING_sk_type(sk))
-#define sk_POLICY_MAPPING_dup(sk) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_dup(ossl_check_const_POLICY_MAPPING_sk_type(sk)))
-#define sk_POLICY_MAPPING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICY_MAPPING) *)OPENSSL_sk_deep_copy(ossl_check_const_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_copyfunc_type(copyfunc), ossl_check_POLICY_MAPPING_freefunc_type(freefunc)))
+#define sk_POLICY_MAPPING_dup(sk) ((STACK_OF(POLICY_MAPPING)*)OPENSSL_sk_dup(ossl_check_const_POLICY_MAPPING_sk_type(sk)))
+#define sk_POLICY_MAPPING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(POLICY_MAPPING)*)OPENSSL_sk_deep_copy(ossl_check_const_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_copyfunc_type(copyfunc), ossl_check_POLICY_MAPPING_freefunc_type(freefunc)))
 #define sk_POLICY_MAPPING_set_cmp_func(sk, cmp) ((sk_POLICY_MAPPING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_POLICY_MAPPING_sk_type(sk), ossl_check_POLICY_MAPPING_compfunc_type(cmp)))
 
+    typedef STACK_OF(POLICY_MAPPING) POLICY_MAPPINGS;
 
-typedef STACK_OF(POLICY_MAPPING) POLICY_MAPPINGS;
-
-typedef struct GENERAL_SUBTREE_st {
-    GENERAL_NAME *base;
-    ASN1_INTEGER *minimum;
-    ASN1_INTEGER *maximum;
-} GENERAL_SUBTREE;
+    typedef struct GENERAL_SUBTREE_st
+    {
+        GENERAL_NAME* base;
+        ASN1_INTEGER* minimum;
+        ASN1_INTEGER* maximum;
+    } GENERAL_SUBTREE;
 
-SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_SUBTREE, GENERAL_SUBTREE, GENERAL_SUBTREE)
+    SKM_DEFINE_STACK_OF_INTERNAL(GENERAL_SUBTREE, GENERAL_SUBTREE, GENERAL_SUBTREE)
 #define sk_GENERAL_SUBTREE_num(sk) OPENSSL_sk_num(ossl_check_const_GENERAL_SUBTREE_sk_type(sk))
-#define sk_GENERAL_SUBTREE_value(sk, idx) ((GENERAL_SUBTREE *)OPENSSL_sk_value(ossl_check_const_GENERAL_SUBTREE_sk_type(sk), (idx)))
-#define sk_GENERAL_SUBTREE_new(cmp) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new(ossl_check_GENERAL_SUBTREE_compfunc_type(cmp)))
-#define sk_GENERAL_SUBTREE_new_null() ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new_null())
-#define sk_GENERAL_SUBTREE_new_reserve(cmp, n) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_new_reserve(ossl_check_GENERAL_SUBTREE_compfunc_type(cmp), (n)))
+#define sk_GENERAL_SUBTREE_value(sk, idx) ((GENERAL_SUBTREE*)OPENSSL_sk_value(ossl_check_const_GENERAL_SUBTREE_sk_type(sk), (idx)))
+#define sk_GENERAL_SUBTREE_new(cmp) ((STACK_OF(GENERAL_SUBTREE)*)OPENSSL_sk_new(ossl_check_GENERAL_SUBTREE_compfunc_type(cmp)))
+#define sk_GENERAL_SUBTREE_new_null() ((STACK_OF(GENERAL_SUBTREE)*)OPENSSL_sk_new_null())
+#define sk_GENERAL_SUBTREE_new_reserve(cmp, n) ((STACK_OF(GENERAL_SUBTREE)*)OPENSSL_sk_new_reserve(ossl_check_GENERAL_SUBTREE_compfunc_type(cmp), (n)))
 #define sk_GENERAL_SUBTREE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_GENERAL_SUBTREE_sk_type(sk), (n))
 #define sk_GENERAL_SUBTREE_free(sk) OPENSSL_sk_free(ossl_check_GENERAL_SUBTREE_sk_type(sk))
 #define sk_GENERAL_SUBTREE_zero(sk) OPENSSL_sk_zero(ossl_check_GENERAL_SUBTREE_sk_type(sk))
-#define sk_GENERAL_SUBTREE_delete(sk, i) ((GENERAL_SUBTREE *)OPENSSL_sk_delete(ossl_check_GENERAL_SUBTREE_sk_type(sk), (i)))
-#define sk_GENERAL_SUBTREE_delete_ptr(sk, ptr) ((GENERAL_SUBTREE *)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr)))
+#define sk_GENERAL_SUBTREE_delete(sk, i) ((GENERAL_SUBTREE*)OPENSSL_sk_delete(ossl_check_GENERAL_SUBTREE_sk_type(sk), (i)))
+#define sk_GENERAL_SUBTREE_delete_ptr(sk, ptr) ((GENERAL_SUBTREE*)OPENSSL_sk_delete_ptr(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr)))
 #define sk_GENERAL_SUBTREE_push(sk, ptr) OPENSSL_sk_push(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
 #define sk_GENERAL_SUBTREE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
-#define sk_GENERAL_SUBTREE_pop(sk) ((GENERAL_SUBTREE *)OPENSSL_sk_pop(ossl_check_GENERAL_SUBTREE_sk_type(sk)))
-#define sk_GENERAL_SUBTREE_shift(sk) ((GENERAL_SUBTREE *)OPENSSL_sk_shift(ossl_check_GENERAL_SUBTREE_sk_type(sk)))
-#define sk_GENERAL_SUBTREE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_SUBTREE_sk_type(sk),ossl_check_GENERAL_SUBTREE_freefunc_type(freefunc))
+#define sk_GENERAL_SUBTREE_pop(sk) ((GENERAL_SUBTREE*)OPENSSL_sk_pop(ossl_check_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_shift(sk) ((GENERAL_SUBTREE*)OPENSSL_sk_shift(ossl_check_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_freefunc_type(freefunc))
 #define sk_GENERAL_SUBTREE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr), (idx))
-#define sk_GENERAL_SUBTREE_set(sk, idx, ptr) ((GENERAL_SUBTREE *)OPENSSL_sk_set(ossl_check_GENERAL_SUBTREE_sk_type(sk), (idx), ossl_check_GENERAL_SUBTREE_type(ptr)))
+#define sk_GENERAL_SUBTREE_set(sk, idx, ptr) ((GENERAL_SUBTREE*)OPENSSL_sk_set(ossl_check_GENERAL_SUBTREE_sk_type(sk), (idx), ossl_check_GENERAL_SUBTREE_type(ptr)))
 #define sk_GENERAL_SUBTREE_find(sk, ptr) OPENSSL_sk_find(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
 #define sk_GENERAL_SUBTREE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr))
 #define sk_GENERAL_SUBTREE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_type(ptr), pnum)
 #define sk_GENERAL_SUBTREE_sort(sk) OPENSSL_sk_sort(ossl_check_GENERAL_SUBTREE_sk_type(sk))
 #define sk_GENERAL_SUBTREE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_GENERAL_SUBTREE_sk_type(sk))
-#define sk_GENERAL_SUBTREE_dup(sk) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_dup(ossl_check_const_GENERAL_SUBTREE_sk_type(sk)))
-#define sk_GENERAL_SUBTREE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_SUBTREE) *)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_copyfunc_type(copyfunc), ossl_check_GENERAL_SUBTREE_freefunc_type(freefunc)))
+#define sk_GENERAL_SUBTREE_dup(sk) ((STACK_OF(GENERAL_SUBTREE)*)OPENSSL_sk_dup(ossl_check_const_GENERAL_SUBTREE_sk_type(sk)))
+#define sk_GENERAL_SUBTREE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(GENERAL_SUBTREE)*)OPENSSL_sk_deep_copy(ossl_check_const_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_copyfunc_type(copyfunc), ossl_check_GENERAL_SUBTREE_freefunc_type(freefunc)))
 #define sk_GENERAL_SUBTREE_set_cmp_func(sk, cmp) ((sk_GENERAL_SUBTREE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_GENERAL_SUBTREE_sk_type(sk), ossl_check_GENERAL_SUBTREE_compfunc_type(cmp)))
 
-
-struct NAME_CONSTRAINTS_st {
-    STACK_OF(GENERAL_SUBTREE) *permittedSubtrees;
-    STACK_OF(GENERAL_SUBTREE) *excludedSubtrees;
-};
-
-typedef struct POLICY_CONSTRAINTS_st {
-    ASN1_INTEGER *requireExplicitPolicy;
-    ASN1_INTEGER *inhibitPolicyMapping;
-} POLICY_CONSTRAINTS;
-
-/* Proxy certificate structures, see RFC 3820 */
-typedef struct PROXY_POLICY_st {
-    ASN1_OBJECT *policyLanguage;
-    ASN1_OCTET_STRING *policy;
-} PROXY_POLICY;
-
-typedef struct PROXY_CERT_INFO_EXTENSION_st {
-    ASN1_INTEGER *pcPathLengthConstraint;
-    PROXY_POLICY *proxyPolicy;
-} PROXY_CERT_INFO_EXTENSION;
-
-DECLARE_ASN1_FUNCTIONS(PROXY_POLICY)
-DECLARE_ASN1_FUNCTIONS(PROXY_CERT_INFO_EXTENSION)
-
-struct ISSUING_DIST_POINT_st {
-    DIST_POINT_NAME *distpoint;
-    int onlyuser;
-    int onlyCA;
-    ASN1_BIT_STRING *onlysomereasons;
-    int indirectCRL;
-    int onlyattr;
-};
+    struct NAME_CONSTRAINTS_st
+    {
+        STACK_OF(GENERAL_SUBTREE) * permittedSubtrees;
+        STACK_OF(GENERAL_SUBTREE) * excludedSubtrees;
+    };
+
+    typedef struct POLICY_CONSTRAINTS_st
+    {
+        ASN1_INTEGER* requireExplicitPolicy;
+        ASN1_INTEGER* inhibitPolicyMapping;
+    } POLICY_CONSTRAINTS;
+
+    /* Proxy certificate structures, see RFC 3820 */
+    typedef struct PROXY_POLICY_st
+    {
+        ASN1_OBJECT* policyLanguage;
+        ASN1_OCTET_STRING* policy;
+    } PROXY_POLICY;
+
+    typedef struct PROXY_CERT_INFO_EXTENSION_st
+    {
+        ASN1_INTEGER* pcPathLengthConstraint;
+        PROXY_POLICY* proxyPolicy;
+    } PROXY_CERT_INFO_EXTENSION;
+
+    DECLARE_ASN1_FUNCTIONS(PROXY_POLICY)
+    DECLARE_ASN1_FUNCTIONS(PROXY_CERT_INFO_EXTENSION)
+
+    struct ISSUING_DIST_POINT_st
+    {
+        DIST_POINT_NAME* distpoint;
+        int onlyuser;
+        int onlyCA;
+        ASN1_BIT_STRING* onlysomereasons;
+        int indirectCRL;
+        int onlyattr;
+    };
 
 /* Values in idp_flags field */
 /* IDP present */
-# define IDP_PRESENT     0x1
+#define IDP_PRESENT 0x1
 /* IDP values inconsistent */
-# define IDP_INVALID     0x2
+#define IDP_INVALID 0x2
 /* onlyuser true */
-# define IDP_ONLYUSER    0x4
+#define IDP_ONLYUSER 0x4
 /* onlyCA true */
-# define IDP_ONLYCA      0x8
+#define IDP_ONLYCA 0x8
 /* onlyattr true */
-# define IDP_ONLYATTR    0x10
+#define IDP_ONLYATTR 0x10
 /* indirectCRL true */
-# define IDP_INDIRECT    0x20
+#define IDP_INDIRECT 0x20
 /* onlysomereasons present */
-# define IDP_REASONS     0x40
+#define IDP_REASONS 0x40
 
-# define X509V3_conf_err(val) ERR_add_error_data(6, \
-                        "section:", (val)->section, \
-                        ",name:", (val)->name, ",value:", (val)->value)
+#define X509V3_conf_err(val) ERR_add_error_data(6, "section:", (val)->section, ",name:", (val)->name, ",value:", (val)->value)
 
-# define X509V3_set_ctx_test(ctx) \
+#define X509V3_set_ctx_test(ctx) \
     X509V3_set_ctx(ctx, NULL, NULL, NULL, NULL, X509V3_CTX_TEST)
-# define X509V3_set_ctx_nodb(ctx) (ctx)->db = NULL;
-
-# define EXT_BITSTRING(nid, table) { nid, 0, ASN1_ITEM_ref(ASN1_BIT_STRING), \
-                        0,0,0,0, \
-                        0,0, \
-                        (X509V3_EXT_I2V)i2v_ASN1_BIT_STRING, \
-                        (X509V3_EXT_V2I)v2i_ASN1_BIT_STRING, \
-                        NULL, NULL, \
-                        table}
-
-# define EXT_IA5STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_IA5STRING), \
-                        0,0,0,0, \
-                        (X509V3_EXT_I2S)i2s_ASN1_IA5STRING, \
-                        (X509V3_EXT_S2I)s2i_ASN1_IA5STRING, \
-                        0,0,0,0, \
-                        NULL}
-
-#define EXT_UTF8STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_UTF8STRING), \
-                        0,0,0,0, \
-                        (X509V3_EXT_I2S)i2s_ASN1_UTF8STRING, \
-                        (X509V3_EXT_S2I)s2i_ASN1_UTF8STRING, \
-                        0,0,0,0, \
-                        NULL}
-
-# define EXT_END { -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-
-/* X509_PURPOSE stuff */
-
-# define EXFLAG_BCONS            0x1
-# define EXFLAG_KUSAGE           0x2
-# define EXFLAG_XKUSAGE          0x4
-# define EXFLAG_NSCERT           0x8
-
-# define EXFLAG_CA               0x10
-# define EXFLAG_SI               0x20 /* self-issued, maybe not self-signed */
-# define EXFLAG_V1               0x40
-# define EXFLAG_INVALID          0x80
+#define X509V3_set_ctx_nodb(ctx) (ctx)->db = NULL;
+
+#define EXT_BITSTRING(nid, table)                \
+    {                                            \
+        nid, 0, ASN1_ITEM_ref(ASN1_BIT_STRING),  \
+            0, 0, 0, 0,                          \
+            0, 0,                                \
+            (X509V3_EXT_I2V)i2v_ASN1_BIT_STRING, \
+            (X509V3_EXT_V2I)v2i_ASN1_BIT_STRING, \
+            NULL, NULL,                          \
+            table                                \
+    }
+
+#define EXT_IA5STRING(nid)                      \
+    {                                           \
+        nid, 0, ASN1_ITEM_ref(ASN1_IA5STRING),  \
+            0, 0, 0, 0,                         \
+            (X509V3_EXT_I2S)i2s_ASN1_IA5STRING, \
+            (X509V3_EXT_S2I)s2i_ASN1_IA5STRING, \
+            0, 0, 0, 0,                         \
+            NULL                                \
+    }
+
+#define EXT_UTF8STRING(nid)                      \
+    {                                            \
+        nid, 0, ASN1_ITEM_ref(ASN1_UTF8STRING),  \
+            0, 0, 0, 0,                          \
+            (X509V3_EXT_I2S)i2s_ASN1_UTF8STRING, \
+            (X509V3_EXT_S2I)s2i_ASN1_UTF8STRING, \
+            0, 0, 0, 0,                          \
+            NULL                                 \
+    }
+
+#define EXT_END                                   \
+    {                                             \
+        -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
+    }
+
+    /* X509_PURPOSE stuff */
+
+#define EXFLAG_BCONS 0x1
+#define EXFLAG_KUSAGE 0x2
+#define EXFLAG_XKUSAGE 0x4
+#define EXFLAG_NSCERT 0x8
+
+#define EXFLAG_CA 0x10
+#define EXFLAG_SI 0x20 /* self-issued, maybe not self-signed */
+#define EXFLAG_V1 0x40
+#define EXFLAG_INVALID 0x80
 /* EXFLAG_SET is set to indicate that some values have been precomputed */
-# define EXFLAG_SET              0x100
-# define EXFLAG_CRITICAL         0x200
-# define EXFLAG_PROXY            0x400
-
-# define EXFLAG_INVALID_POLICY   0x800
-# define EXFLAG_FRESHEST         0x1000
-# define EXFLAG_SS               0x2000 /* cert is apparently self-signed */
-
-# define EXFLAG_BCONS_CRITICAL   0x10000
-# define EXFLAG_AKID_CRITICAL    0x20000
-# define EXFLAG_SKID_CRITICAL    0x40000
-# define EXFLAG_SAN_CRITICAL     0x80000
-# define EXFLAG_NO_FINGERPRINT   0x100000
-
-# define KU_DIGITAL_SIGNATURE    0x0080
-# define KU_NON_REPUDIATION      0x0040
-# define KU_KEY_ENCIPHERMENT     0x0020
-# define KU_DATA_ENCIPHERMENT    0x0010
-# define KU_KEY_AGREEMENT        0x0008
-# define KU_KEY_CERT_SIGN        0x0004
-# define KU_CRL_SIGN             0x0002
-# define KU_ENCIPHER_ONLY        0x0001
-# define KU_DECIPHER_ONLY        0x8000
-
-# define NS_SSL_CLIENT           0x80
-# define NS_SSL_SERVER           0x40
-# define NS_SMIME                0x20
-# define NS_OBJSIGN              0x10
-# define NS_SSL_CA               0x04
-# define NS_SMIME_CA             0x02
-# define NS_OBJSIGN_CA           0x01
-# define NS_ANY_CA               (NS_SSL_CA|NS_SMIME_CA|NS_OBJSIGN_CA)
-
-# define XKU_SSL_SERVER          0x1
-# define XKU_SSL_CLIENT          0x2
-# define XKU_SMIME               0x4
-# define XKU_CODE_SIGN           0x8
-# define XKU_SGC                 0x10 /* Netscape or MS Server-Gated Crypto */
-# define XKU_OCSP_SIGN           0x20
-# define XKU_TIMESTAMP           0x40
-# define XKU_DVCS                0x80
-# define XKU_ANYEKU              0x100
-
-# define X509_PURPOSE_DYNAMIC    0x1
-# define X509_PURPOSE_DYNAMIC_NAME       0x2
-
-typedef struct x509_purpose_st {
-    int purpose;
-    int trust;                  /* Default trust ID */
-    int flags;
-    int (*check_purpose) (const struct x509_purpose_st *, const X509 *, int);
-    char *name;
-    char *sname;
-    void *usr_data;
-} X509_PURPOSE;
-
-SKM_DEFINE_STACK_OF_INTERNAL(X509_PURPOSE, X509_PURPOSE, X509_PURPOSE)
+#define EXFLAG_SET 0x100
+#define EXFLAG_CRITICAL 0x200
+#define EXFLAG_PROXY 0x400
+
+#define EXFLAG_INVALID_POLICY 0x800
+#define EXFLAG_FRESHEST 0x1000
+#define EXFLAG_SS 0x2000 /* cert is apparently self-signed */
+
+#define EXFLAG_BCONS_CRITICAL 0x10000
+#define EXFLAG_AKID_CRITICAL 0x20000
+#define EXFLAG_SKID_CRITICAL 0x40000
+#define EXFLAG_SAN_CRITICAL 0x80000
+#define EXFLAG_NO_FINGERPRINT 0x100000
+
+#define KU_DIGITAL_SIGNATURE 0x0080
+#define KU_NON_REPUDIATION 0x0040
+#define KU_KEY_ENCIPHERMENT 0x0020
+#define KU_DATA_ENCIPHERMENT 0x0010
+#define KU_KEY_AGREEMENT 0x0008
+#define KU_KEY_CERT_SIGN 0x0004
+#define KU_CRL_SIGN 0x0002
+#define KU_ENCIPHER_ONLY 0x0001
+#define KU_DECIPHER_ONLY 0x8000
+
+#define NS_SSL_CLIENT 0x80
+#define NS_SSL_SERVER 0x40
+#define NS_SMIME 0x20
+#define NS_OBJSIGN 0x10
+#define NS_SSL_CA 0x04
+#define NS_SMIME_CA 0x02
+#define NS_OBJSIGN_CA 0x01
+#define NS_ANY_CA (NS_SSL_CA | NS_SMIME_CA | NS_OBJSIGN_CA)
+
+#define XKU_SSL_SERVER 0x1
+#define XKU_SSL_CLIENT 0x2
+#define XKU_SMIME 0x4
+#define XKU_CODE_SIGN 0x8
+#define XKU_SGC 0x10 /* Netscape or MS Server-Gated Crypto */
+#define XKU_OCSP_SIGN 0x20
+#define XKU_TIMESTAMP 0x40
+#define XKU_DVCS 0x80
+#define XKU_ANYEKU 0x100
+
+#define X509_PURPOSE_DYNAMIC 0x1
+#define X509_PURPOSE_DYNAMIC_NAME 0x2
+
+    typedef struct x509_purpose_st
+    {
+        int purpose;
+        int trust; /* Default trust ID */
+        int flags;
+        int (*check_purpose)(const struct x509_purpose_st*, const X509*, int);
+        char* name;
+        char* sname;
+        void* usr_data;
+    } X509_PURPOSE;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_PURPOSE, X509_PURPOSE, X509_PURPOSE)
 #define sk_X509_PURPOSE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_PURPOSE_sk_type(sk))
-#define sk_X509_PURPOSE_value(sk, idx) ((X509_PURPOSE *)OPENSSL_sk_value(ossl_check_const_X509_PURPOSE_sk_type(sk), (idx)))
-#define sk_X509_PURPOSE_new(cmp) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new(ossl_check_X509_PURPOSE_compfunc_type(cmp)))
-#define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new_null())
-#define sk_X509_PURPOSE_new_reserve(cmp, n) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_new_reserve(ossl_check_X509_PURPOSE_compfunc_type(cmp), (n)))
+#define sk_X509_PURPOSE_value(sk, idx) ((X509_PURPOSE*)OPENSSL_sk_value(ossl_check_const_X509_PURPOSE_sk_type(sk), (idx)))
+#define sk_X509_PURPOSE_new(cmp) ((STACK_OF(X509_PURPOSE)*)OPENSSL_sk_new(ossl_check_X509_PURPOSE_compfunc_type(cmp)))
+#define sk_X509_PURPOSE_new_null() ((STACK_OF(X509_PURPOSE)*)OPENSSL_sk_new_null())
+#define sk_X509_PURPOSE_new_reserve(cmp, n) ((STACK_OF(X509_PURPOSE)*)OPENSSL_sk_new_reserve(ossl_check_X509_PURPOSE_compfunc_type(cmp), (n)))
 #define sk_X509_PURPOSE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_PURPOSE_sk_type(sk), (n))
 #define sk_X509_PURPOSE_free(sk) OPENSSL_sk_free(ossl_check_X509_PURPOSE_sk_type(sk))
 #define sk_X509_PURPOSE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_PURPOSE_sk_type(sk))
-#define sk_X509_PURPOSE_delete(sk, i) ((X509_PURPOSE *)OPENSSL_sk_delete(ossl_check_X509_PURPOSE_sk_type(sk), (i)))
-#define sk_X509_PURPOSE_delete_ptr(sk, ptr) ((X509_PURPOSE *)OPENSSL_sk_delete_ptr(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr)))
+#define sk_X509_PURPOSE_delete(sk, i) ((X509_PURPOSE*)OPENSSL_sk_delete(ossl_check_X509_PURPOSE_sk_type(sk), (i)))
+#define sk_X509_PURPOSE_delete_ptr(sk, ptr) ((X509_PURPOSE*)OPENSSL_sk_delete_ptr(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr)))
 #define sk_X509_PURPOSE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
 #define sk_X509_PURPOSE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
-#define sk_X509_PURPOSE_pop(sk) ((X509_PURPOSE *)OPENSSL_sk_pop(ossl_check_X509_PURPOSE_sk_type(sk)))
-#define sk_X509_PURPOSE_shift(sk) ((X509_PURPOSE *)OPENSSL_sk_shift(ossl_check_X509_PURPOSE_sk_type(sk)))
-#define sk_X509_PURPOSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_PURPOSE_sk_type(sk),ossl_check_X509_PURPOSE_freefunc_type(freefunc))
+#define sk_X509_PURPOSE_pop(sk) ((X509_PURPOSE*)OPENSSL_sk_pop(ossl_check_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_shift(sk) ((X509_PURPOSE*)OPENSSL_sk_shift(ossl_check_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_freefunc_type(freefunc))
 #define sk_X509_PURPOSE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr), (idx))
-#define sk_X509_PURPOSE_set(sk, idx, ptr) ((X509_PURPOSE *)OPENSSL_sk_set(ossl_check_X509_PURPOSE_sk_type(sk), (idx), ossl_check_X509_PURPOSE_type(ptr)))
+#define sk_X509_PURPOSE_set(sk, idx, ptr) ((X509_PURPOSE*)OPENSSL_sk_set(ossl_check_X509_PURPOSE_sk_type(sk), (idx), ossl_check_X509_PURPOSE_type(ptr)))
 #define sk_X509_PURPOSE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
 #define sk_X509_PURPOSE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr))
 #define sk_X509_PURPOSE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_type(ptr), pnum)
 #define sk_X509_PURPOSE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_PURPOSE_sk_type(sk))
 #define sk_X509_PURPOSE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_PURPOSE_sk_type(sk))
-#define sk_X509_PURPOSE_dup(sk) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_dup(ossl_check_const_X509_PURPOSE_sk_type(sk)))
-#define sk_X509_PURPOSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_PURPOSE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_copyfunc_type(copyfunc), ossl_check_X509_PURPOSE_freefunc_type(freefunc)))
+#define sk_X509_PURPOSE_dup(sk) ((STACK_OF(X509_PURPOSE)*)OPENSSL_sk_dup(ossl_check_const_X509_PURPOSE_sk_type(sk)))
+#define sk_X509_PURPOSE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_PURPOSE)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_copyfunc_type(copyfunc), ossl_check_X509_PURPOSE_freefunc_type(freefunc)))
 #define sk_X509_PURPOSE_set_cmp_func(sk, cmp) ((sk_X509_PURPOSE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_PURPOSE_sk_type(sk), ossl_check_X509_PURPOSE_compfunc_type(cmp)))
 
+#define X509_PURPOSE_SSL_CLIENT 1
+#define X509_PURPOSE_SSL_SERVER 2
+#define X509_PURPOSE_NS_SSL_SERVER 3
+#define X509_PURPOSE_SMIME_SIGN 4
+#define X509_PURPOSE_SMIME_ENCRYPT 5
+#define X509_PURPOSE_CRL_SIGN 6
+#define X509_PURPOSE_ANY 7
+#define X509_PURPOSE_OCSP_HELPER 8
+#define X509_PURPOSE_TIMESTAMP_SIGN 9
 
+#define X509_PURPOSE_MIN 1
+#define X509_PURPOSE_MAX 9
 
-# define X509_PURPOSE_SSL_CLIENT         1
-# define X509_PURPOSE_SSL_SERVER         2
-# define X509_PURPOSE_NS_SSL_SERVER      3
-# define X509_PURPOSE_SMIME_SIGN         4
-# define X509_PURPOSE_SMIME_ENCRYPT      5
-# define X509_PURPOSE_CRL_SIGN           6
-# define X509_PURPOSE_ANY                7
-# define X509_PURPOSE_OCSP_HELPER        8
-# define X509_PURPOSE_TIMESTAMP_SIGN     9
+    /* Flags for X509V3_EXT_print() */
 
-# define X509_PURPOSE_MIN                1
-# define X509_PURPOSE_MAX                9
-
-/* Flags for X509V3_EXT_print() */
-
-# define X509V3_EXT_UNKNOWN_MASK         (0xfL << 16)
+#define X509V3_EXT_UNKNOWN_MASK (0xfL << 16)
 /* Return error for unknown extensions */
-# define X509V3_EXT_DEFAULT              0
+#define X509V3_EXT_DEFAULT 0
 /* Print error for unknown extensions */
-# define X509V3_EXT_ERROR_UNKNOWN        (1L << 16)
+#define X509V3_EXT_ERROR_UNKNOWN (1L << 16)
 /* ASN1 parse unknown extensions */
-# define X509V3_EXT_PARSE_UNKNOWN        (2L << 16)
+#define X509V3_EXT_PARSE_UNKNOWN (2L << 16)
 /* BIO_dump unknown extensions */
-# define X509V3_EXT_DUMP_UNKNOWN         (3L << 16)
-
-/* Flags for X509V3_add1_i2d */
-
-# define X509V3_ADD_OP_MASK              0xfL
-# define X509V3_ADD_DEFAULT              0L
-# define X509V3_ADD_APPEND               1L
-# define X509V3_ADD_REPLACE              2L
-# define X509V3_ADD_REPLACE_EXISTING     3L
-# define X509V3_ADD_KEEP_EXISTING        4L
-# define X509V3_ADD_DELETE               5L
-# define X509V3_ADD_SILENT               0x10
-
-DECLARE_ASN1_FUNCTIONS(BASIC_CONSTRAINTS)
-
-DECLARE_ASN1_FUNCTIONS(SXNET)
-DECLARE_ASN1_FUNCTIONS(SXNETID)
-
-DECLARE_ASN1_FUNCTIONS(ISSUER_SIGN_TOOL)
-
-int SXNET_add_id_asc(SXNET **psx, const char *zone, const char *user, int userlen);
-int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, const char *user,
-                       int userlen);
-int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *izone, const char *user,
-                         int userlen);
-
-ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, const char *zone);
-ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone);
-ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone);
-
-DECLARE_ASN1_FUNCTIONS(AUTHORITY_KEYID)
-
-DECLARE_ASN1_FUNCTIONS(PKEY_USAGE_PERIOD)
-
-DECLARE_ASN1_FUNCTIONS(GENERAL_NAME)
-DECLARE_ASN1_DUP_FUNCTION(GENERAL_NAME)
-int GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b);
-
-ASN1_BIT_STRING *v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
-                                     X509V3_CTX *ctx,
-                                     STACK_OF(CONF_VALUE) *nval);
-STACK_OF(CONF_VALUE) *i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
-                                          ASN1_BIT_STRING *bits,
-                                          STACK_OF(CONF_VALUE) *extlist);
-char *i2s_ASN1_IA5STRING(X509V3_EXT_METHOD *method, ASN1_IA5STRING *ia5);
-ASN1_IA5STRING *s2i_ASN1_IA5STRING(X509V3_EXT_METHOD *method,
-                                   X509V3_CTX *ctx, const char *str);
-char *i2s_ASN1_UTF8STRING(X509V3_EXT_METHOD *method, ASN1_UTF8STRING *utf8);
-ASN1_UTF8STRING *s2i_ASN1_UTF8STRING(X509V3_EXT_METHOD *method,
-                                   X509V3_CTX *ctx, const char *str);
-
-STACK_OF(CONF_VALUE) *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method,
-                                       GENERAL_NAME *gen,
-                                       STACK_OF(CONF_VALUE) *ret);
-int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen);
-
-DECLARE_ASN1_FUNCTIONS(GENERAL_NAMES)
-
-STACK_OF(CONF_VALUE) *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method,
-                                        GENERAL_NAMES *gen,
-                                        STACK_OF(CONF_VALUE) *extlist);
-GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method,
-                                 X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval);
-
-DECLARE_ASN1_FUNCTIONS(OTHERNAME)
-DECLARE_ASN1_FUNCTIONS(EDIPARTYNAME)
-int OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b);
-void GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value);
-void *GENERAL_NAME_get0_value(const GENERAL_NAME *a, int *ptype);
-int GENERAL_NAME_set0_othername(GENERAL_NAME *gen,
-                                ASN1_OBJECT *oid, ASN1_TYPE *value);
-int GENERAL_NAME_get0_otherName(const GENERAL_NAME *gen,
-                                ASN1_OBJECT **poid, ASN1_TYPE **pvalue);
-
-char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
-                            const ASN1_OCTET_STRING *ia5);
-ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
-                                         X509V3_CTX *ctx, const char *str);
-
-DECLARE_ASN1_FUNCTIONS(EXTENDED_KEY_USAGE)
-int i2a_ACCESS_DESCRIPTION(BIO *bp, const ACCESS_DESCRIPTION *a);
-
-DECLARE_ASN1_ALLOC_FUNCTIONS(TLS_FEATURE)
-
-DECLARE_ASN1_FUNCTIONS(CERTIFICATEPOLICIES)
-DECLARE_ASN1_FUNCTIONS(POLICYINFO)
-DECLARE_ASN1_FUNCTIONS(POLICYQUALINFO)
-DECLARE_ASN1_FUNCTIONS(USERNOTICE)
-DECLARE_ASN1_FUNCTIONS(NOTICEREF)
-
-DECLARE_ASN1_FUNCTIONS(CRL_DIST_POINTS)
-DECLARE_ASN1_FUNCTIONS(DIST_POINT)
-DECLARE_ASN1_FUNCTIONS(DIST_POINT_NAME)
-DECLARE_ASN1_FUNCTIONS(ISSUING_DIST_POINT)
-
-int DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, const X509_NAME *iname);
-
-int NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc);
-int NAME_CONSTRAINTS_check_CN(X509 *x, NAME_CONSTRAINTS *nc);
-
-DECLARE_ASN1_FUNCTIONS(ACCESS_DESCRIPTION)
-DECLARE_ASN1_FUNCTIONS(AUTHORITY_INFO_ACCESS)
-
-DECLARE_ASN1_ITEM(POLICY_MAPPING)
-DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_MAPPING)
-DECLARE_ASN1_ITEM(POLICY_MAPPINGS)
-
-DECLARE_ASN1_ITEM(GENERAL_SUBTREE)
-DECLARE_ASN1_ALLOC_FUNCTIONS(GENERAL_SUBTREE)
-
-DECLARE_ASN1_ITEM(NAME_CONSTRAINTS)
-DECLARE_ASN1_ALLOC_FUNCTIONS(NAME_CONSTRAINTS)
-
-DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_CONSTRAINTS)
-DECLARE_ASN1_ITEM(POLICY_CONSTRAINTS)
-
-GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out,
-                               const X509V3_EXT_METHOD *method,
-                               X509V3_CTX *ctx, int gen_type,
-                               const char *value, int is_nc);
-
-# ifdef OPENSSL_CONF_H
-GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method,
-                               X509V3_CTX *ctx, CONF_VALUE *cnf);
-GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out,
-                                  const X509V3_EXT_METHOD *method,
-                                  X509V3_CTX *ctx, CONF_VALUE *cnf,
-                                  int is_nc);
-
-void X509V3_conf_free(CONF_VALUE *val);
-
-X509_EXTENSION *X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid,
-                                     const char *value);
-X509_EXTENSION *X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, const char *name,
-                                 const char *value);
-int X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, const char *section,
-                            STACK_OF(X509_EXTENSION) **sk);
-int X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
-                         X509 *cert);
-int X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
-                             X509_REQ *req);
-int X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
-                             X509_CRL *crl);
-
-X509_EXTENSION *X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf,
-                                    X509V3_CTX *ctx, int ext_nid,
-                                    const char *value);
-X509_EXTENSION *X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
-                                const char *name, const char *value);
-int X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
-                        const char *section, X509 *cert);
-int X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
-                            const char *section, X509_REQ *req);
-int X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
-                            const char *section, X509_CRL *crl);
-
-int X509V3_add_value_bool_nf(const char *name, int asn1_bool,
-                             STACK_OF(CONF_VALUE) **extlist);
-int X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool);
-int X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint);
-void X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf);
-void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash);
-# endif
-
-char *X509V3_get_string(X509V3_CTX *ctx, const char *name, const char *section);
-STACK_OF(CONF_VALUE) *X509V3_get_section(X509V3_CTX *ctx, const char *section);
-void X509V3_string_free(X509V3_CTX *ctx, char *str);
-void X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section);
-void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subject,
-                    X509_REQ *req, X509_CRL *crl, int flags);
-/* For API backward compatibility, this is separate from X509V3_set_ctx(): */
-int X509V3_set_issuer_pkey(X509V3_CTX *ctx, EVP_PKEY *pkey);
-
-int X509V3_add_value(const char *name, const char *value,
-                     STACK_OF(CONF_VALUE) **extlist);
-int X509V3_add_value_uchar(const char *name, const unsigned char *value,
-                           STACK_OF(CONF_VALUE) **extlist);
-int X509V3_add_value_bool(const char *name, int asn1_bool,
-                          STACK_OF(CONF_VALUE) **extlist);
-int X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
-                         STACK_OF(CONF_VALUE) **extlist);
-char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const ASN1_INTEGER *aint);
-ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const char *value);
-char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *meth, const ASN1_ENUMERATED *aint);
-char *i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *meth,
-                                const ASN1_ENUMERATED *aint);
-int X509V3_EXT_add(X509V3_EXT_METHOD *ext);
-int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist);
-int X509V3_EXT_add_alias(int nid_to, int nid_from);
-void X509V3_EXT_cleanup(void);
-
-const X509V3_EXT_METHOD *X509V3_EXT_get(X509_EXTENSION *ext);
-const X509V3_EXT_METHOD *X509V3_EXT_get_nid(int nid);
-int X509V3_add_standard_extensions(void);
-STACK_OF(CONF_VALUE) *X509V3_parse_list(const char *line);
-void *X509V3_EXT_d2i(X509_EXTENSION *ext);
-void *X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *x, int nid, int *crit,
-                     int *idx);
-
-X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc);
-int X509V3_add1_i2d(STACK_OF(X509_EXTENSION) **x, int nid, void *value,
-                    int crit, unsigned long flags);
+#define X509V3_EXT_DUMP_UNKNOWN (3L << 16)
+
+    /* Flags for X509V3_add1_i2d */
+
+#define X509V3_ADD_OP_MASK 0xfL
+#define X509V3_ADD_DEFAULT 0L
+#define X509V3_ADD_APPEND 1L
+#define X509V3_ADD_REPLACE 2L
+#define X509V3_ADD_REPLACE_EXISTING 3L
+#define X509V3_ADD_KEEP_EXISTING 4L
+#define X509V3_ADD_DELETE 5L
+#define X509V3_ADD_SILENT 0x10
+
+    DECLARE_ASN1_FUNCTIONS(BASIC_CONSTRAINTS)
+
+    DECLARE_ASN1_FUNCTIONS(SXNET)
+    DECLARE_ASN1_FUNCTIONS(SXNETID)
+
+    DECLARE_ASN1_FUNCTIONS(ISSUER_SIGN_TOOL)
+
+    int SXNET_add_id_asc(SXNET** psx, const char* zone, const char* user, int userlen);
+    int SXNET_add_id_ulong(SXNET** psx, unsigned long lzone, const char* user, int userlen);
+    int SXNET_add_id_INTEGER(SXNET** psx, ASN1_INTEGER* izone, const char* user, int userlen);
+
+    ASN1_OCTET_STRING* SXNET_get_id_asc(SXNET* sx, const char* zone);
+    ASN1_OCTET_STRING* SXNET_get_id_ulong(SXNET* sx, unsigned long lzone);
+    ASN1_OCTET_STRING* SXNET_get_id_INTEGER(SXNET* sx, ASN1_INTEGER* zone);
+
+    DECLARE_ASN1_FUNCTIONS(AUTHORITY_KEYID)
+
+    DECLARE_ASN1_FUNCTIONS(PKEY_USAGE_PERIOD)
+
+    DECLARE_ASN1_FUNCTIONS(GENERAL_NAME)
+    DECLARE_ASN1_DUP_FUNCTION(GENERAL_NAME)
+    int GENERAL_NAME_cmp(GENERAL_NAME* a, GENERAL_NAME* b);
+
+    ASN1_BIT_STRING* v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD* method, X509V3_CTX* ctx, STACK_OF(CONF_VALUE) * nval);
+    STACK_OF(CONF_VALUE) * i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD* method, ASN1_BIT_STRING* bits, STACK_OF(CONF_VALUE) * extlist);
+    char* i2s_ASN1_IA5STRING(X509V3_EXT_METHOD* method, ASN1_IA5STRING* ia5);
+    ASN1_IA5STRING* s2i_ASN1_IA5STRING(X509V3_EXT_METHOD* method, X509V3_CTX* ctx, const char* str);
+    char* i2s_ASN1_UTF8STRING(X509V3_EXT_METHOD* method, ASN1_UTF8STRING* utf8);
+    ASN1_UTF8STRING* s2i_ASN1_UTF8STRING(X509V3_EXT_METHOD* method, X509V3_CTX* ctx, const char* str);
+
+    STACK_OF(CONF_VALUE) * i2v_GENERAL_NAME(X509V3_EXT_METHOD* method, GENERAL_NAME* gen, STACK_OF(CONF_VALUE) * ret);
+    int GENERAL_NAME_print(BIO* out, GENERAL_NAME* gen);
+
+    DECLARE_ASN1_FUNCTIONS(GENERAL_NAMES)
+
+    STACK_OF(CONF_VALUE) * i2v_GENERAL_NAMES(X509V3_EXT_METHOD* method, GENERAL_NAMES* gen, STACK_OF(CONF_VALUE) * extlist);
+    GENERAL_NAMES* v2i_GENERAL_NAMES(const X509V3_EXT_METHOD* method, X509V3_CTX* ctx, STACK_OF(CONF_VALUE) * nval);
+
+    DECLARE_ASN1_FUNCTIONS(OTHERNAME)
+    DECLARE_ASN1_FUNCTIONS(EDIPARTYNAME)
+    int OTHERNAME_cmp(OTHERNAME* a, OTHERNAME* b);
+    void GENERAL_NAME_set0_value(GENERAL_NAME* a, int type, void* value);
+    void* GENERAL_NAME_get0_value(const GENERAL_NAME* a, int* ptype);
+    int GENERAL_NAME_set0_othername(GENERAL_NAME* gen, ASN1_OBJECT* oid, ASN1_TYPE* value);
+    int GENERAL_NAME_get0_otherName(const GENERAL_NAME* gen, ASN1_OBJECT** poid, ASN1_TYPE** pvalue);
+
+    char* i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD* method, const ASN1_OCTET_STRING* ia5);
+    ASN1_OCTET_STRING* s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD* method, X509V3_CTX* ctx, const char* str);
+
+    DECLARE_ASN1_FUNCTIONS(EXTENDED_KEY_USAGE)
+    int i2a_ACCESS_DESCRIPTION(BIO* bp, const ACCESS_DESCRIPTION* a);
+
+    DECLARE_ASN1_ALLOC_FUNCTIONS(TLS_FEATURE)
+
+    DECLARE_ASN1_FUNCTIONS(CERTIFICATEPOLICIES)
+    DECLARE_ASN1_FUNCTIONS(POLICYINFO)
+    DECLARE_ASN1_FUNCTIONS(POLICYQUALINFO)
+    DECLARE_ASN1_FUNCTIONS(USERNOTICE)
+    DECLARE_ASN1_FUNCTIONS(NOTICEREF)
+
+    DECLARE_ASN1_FUNCTIONS(CRL_DIST_POINTS)
+    DECLARE_ASN1_FUNCTIONS(DIST_POINT)
+    DECLARE_ASN1_FUNCTIONS(DIST_POINT_NAME)
+    DECLARE_ASN1_FUNCTIONS(ISSUING_DIST_POINT)
+
+    int DIST_POINT_set_dpname(DIST_POINT_NAME* dpn, const X509_NAME* iname);
+
+    int NAME_CONSTRAINTS_check(X509* x, NAME_CONSTRAINTS* nc);
+    int NAME_CONSTRAINTS_check_CN(X509* x, NAME_CONSTRAINTS* nc);
+
+    DECLARE_ASN1_FUNCTIONS(ACCESS_DESCRIPTION)
+    DECLARE_ASN1_FUNCTIONS(AUTHORITY_INFO_ACCESS)
+
+    DECLARE_ASN1_ITEM(POLICY_MAPPING)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_MAPPING)
+    DECLARE_ASN1_ITEM(POLICY_MAPPINGS)
+
+    DECLARE_ASN1_ITEM(GENERAL_SUBTREE)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(GENERAL_SUBTREE)
+
+    DECLARE_ASN1_ITEM(NAME_CONSTRAINTS)
+    DECLARE_ASN1_ALLOC_FUNCTIONS(NAME_CONSTRAINTS)
+
+    DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_CONSTRAINTS)
+    DECLARE_ASN1_ITEM(POLICY_CONSTRAINTS)
+
+    GENERAL_NAME* a2i_GENERAL_NAME(GENERAL_NAME* out, const X509V3_EXT_METHOD* method, X509V3_CTX* ctx, int gen_type, const char* value, int is_nc);
+
+#ifdef OPENSSL_CONF_H
+    GENERAL_NAME* v2i_GENERAL_NAME(const X509V3_EXT_METHOD* method, X509V3_CTX* ctx, CONF_VALUE* cnf);
+    GENERAL_NAME* v2i_GENERAL_NAME_ex(GENERAL_NAME* out, const X509V3_EXT_METHOD* method, X509V3_CTX* ctx, CONF_VALUE* cnf, int is_nc);
+
+    void X509V3_conf_free(CONF_VALUE* val);
+
+    X509_EXTENSION* X509V3_EXT_nconf_nid(CONF* conf, X509V3_CTX* ctx, int ext_nid, const char* value);
+    X509_EXTENSION* X509V3_EXT_nconf(CONF* conf, X509V3_CTX* ctx, const char* name, const char* value);
+    int X509V3_EXT_add_nconf_sk(CONF* conf, X509V3_CTX* ctx, const char* section, STACK_OF(X509_EXTENSION) * *sk);
+    int X509V3_EXT_add_nconf(CONF* conf, X509V3_CTX* ctx, const char* section, X509* cert);
+    int X509V3_EXT_REQ_add_nconf(CONF* conf, X509V3_CTX* ctx, const char* section, X509_REQ* req);
+    int X509V3_EXT_CRL_add_nconf(CONF* conf, X509V3_CTX* ctx, const char* section, X509_CRL* crl);
+
+    X509_EXTENSION* X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) * conf, X509V3_CTX* ctx, int ext_nid, const char* value);
+    X509_EXTENSION* X509V3_EXT_conf(LHASH_OF(CONF_VALUE) * conf, X509V3_CTX* ctx, const char* name, const char* value);
+    int X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) * conf, X509V3_CTX* ctx, const char* section, X509* cert);
+    int X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) * conf, X509V3_CTX* ctx, const char* section, X509_REQ* req);
+    int X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) * conf, X509V3_CTX* ctx, const char* section, X509_CRL* crl);
+
+    int X509V3_add_value_bool_nf(const char* name, int asn1_bool, STACK_OF(CONF_VALUE) * *extlist);
+    int X509V3_get_value_bool(const CONF_VALUE* value, int* asn1_bool);
+    int X509V3_get_value_int(const CONF_VALUE* value, ASN1_INTEGER** aint);
+    void X509V3_set_nconf(X509V3_CTX* ctx, CONF* conf);
+    void X509V3_set_conf_lhash(X509V3_CTX* ctx, LHASH_OF(CONF_VALUE) * lhash);
+#endif
+
+    char* X509V3_get_string(X509V3_CTX* ctx, const char* name, const char* section);
+    STACK_OF(CONF_VALUE) * X509V3_get_section(X509V3_CTX* ctx, const char* section);
+    void X509V3_string_free(X509V3_CTX* ctx, char* str);
+    void X509V3_section_free(X509V3_CTX* ctx, STACK_OF(CONF_VALUE) * section);
+    void X509V3_set_ctx(X509V3_CTX* ctx, X509* issuer, X509* subject, X509_REQ* req, X509_CRL* crl, int flags);
+    /* For API backward compatibility, this is separate from X509V3_set_ctx(): */
+    int X509V3_set_issuer_pkey(X509V3_CTX* ctx, EVP_PKEY* pkey);
+
+    int X509V3_add_value(const char* name, const char* value, STACK_OF(CONF_VALUE) * *extlist);
+    int X509V3_add_value_uchar(const char* name, const unsigned char* value, STACK_OF(CONF_VALUE) * *extlist);
+    int X509V3_add_value_bool(const char* name, int asn1_bool, STACK_OF(CONF_VALUE) * *extlist);
+    int X509V3_add_value_int(const char* name, const ASN1_INTEGER* aint, STACK_OF(CONF_VALUE) * *extlist);
+    char* i2s_ASN1_INTEGER(X509V3_EXT_METHOD* meth, const ASN1_INTEGER* aint);
+    ASN1_INTEGER* s2i_ASN1_INTEGER(X509V3_EXT_METHOD* meth, const char* value);
+    char* i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD* meth, const ASN1_ENUMERATED* aint);
+    char* i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD* meth, const ASN1_ENUMERATED* aint);
+    int X509V3_EXT_add(X509V3_EXT_METHOD* ext);
+    int X509V3_EXT_add_list(X509V3_EXT_METHOD* extlist);
+    int X509V3_EXT_add_alias(int nid_to, int nid_from);
+    void X509V3_EXT_cleanup(void);
+
+    const X509V3_EXT_METHOD* X509V3_EXT_get(X509_EXTENSION* ext);
+    const X509V3_EXT_METHOD* X509V3_EXT_get_nid(int nid);
+    int X509V3_add_standard_extensions(void);
+    STACK_OF(CONF_VALUE) * X509V3_parse_list(const char* line);
+    void* X509V3_EXT_d2i(X509_EXTENSION* ext);
+    void* X509V3_get_d2i(const STACK_OF(X509_EXTENSION) * x, int nid, int* crit, int* idx);
+
+    X509_EXTENSION* X509V3_EXT_i2d(int ext_nid, int crit, void* ext_struc);
+    int X509V3_add1_i2d(STACK_OF(X509_EXTENSION) * *x, int nid, void* value, int crit, unsigned long flags);
 
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
 /* The new declarations are in crypto.h, but the old ones were here. */
-# define hex_to_string OPENSSL_buf2hexstr
-# define string_to_hex OPENSSL_hexstr2buf
+#define hex_to_string OPENSSL_buf2hexstr
+#define string_to_hex OPENSSL_hexstr2buf
 #endif
 
-void X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent,
-                        int ml);
-int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, unsigned long flag,
-                     int indent);
+    void X509V3_EXT_val_prn(BIO* out, STACK_OF(CONF_VALUE) * val, int indent, int ml);
+    int X509V3_EXT_print(BIO* out, X509_EXTENSION* ext, unsigned long flag, int indent);
 #ifndef OPENSSL_NO_STDIO
-int X509V3_EXT_print_fp(FILE *out, X509_EXTENSION *ext, int flag, int indent);
+    int X509V3_EXT_print_fp(FILE* out, X509_EXTENSION* ext, int flag, int indent);
 #endif
-int X509V3_extensions_print(BIO *out, const char *title,
-                            const STACK_OF(X509_EXTENSION) *exts,
-                            unsigned long flag, int indent);
-
-int X509_check_ca(X509 *x);
-int X509_check_purpose(X509 *x, int id, int ca);
-int X509_supported_extension(X509_EXTENSION *ex);
-int X509_PURPOSE_set(int *p, int purpose);
-int X509_check_issued(X509 *issuer, X509 *subject);
-int X509_check_akid(const X509 *issuer, const AUTHORITY_KEYID *akid);
-void X509_set_proxy_flag(X509 *x);
-void X509_set_proxy_pathlen(X509 *x, long l);
-long X509_get_proxy_pathlen(X509 *x);
-
-uint32_t X509_get_extension_flags(X509 *x);
-uint32_t X509_get_key_usage(X509 *x);
-uint32_t X509_get_extended_key_usage(X509 *x);
-const ASN1_OCTET_STRING *X509_get0_subject_key_id(X509 *x);
-const ASN1_OCTET_STRING *X509_get0_authority_key_id(X509 *x);
-const GENERAL_NAMES *X509_get0_authority_issuer(X509 *x);
-const ASN1_INTEGER *X509_get0_authority_serial(X509 *x);
-
-int X509_PURPOSE_get_count(void);
-X509_PURPOSE *X509_PURPOSE_get0(int idx);
-int X509_PURPOSE_get_by_sname(const char *sname);
-int X509_PURPOSE_get_by_id(int id);
-int X509_PURPOSE_add(int id, int trust, int flags,
-                     int (*ck) (const X509_PURPOSE *, const X509 *, int),
-                     const char *name, const char *sname, void *arg);
-char *X509_PURPOSE_get0_name(const X509_PURPOSE *xp);
-char *X509_PURPOSE_get0_sname(const X509_PURPOSE *xp);
-int X509_PURPOSE_get_trust(const X509_PURPOSE *xp);
-void X509_PURPOSE_cleanup(void);
-int X509_PURPOSE_get_id(const X509_PURPOSE *);
-
-STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x);
-STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x);
-void X509_email_free(STACK_OF(OPENSSL_STRING) *sk);
-STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x);
+    int X509V3_extensions_print(BIO* out, const char* title, const STACK_OF(X509_EXTENSION) * exts, unsigned long flag, int indent);
+
+    int X509_check_ca(X509* x);
+    int X509_check_purpose(X509* x, int id, int ca);
+    int X509_supported_extension(X509_EXTENSION* ex);
+    int X509_PURPOSE_set(int* p, int purpose);
+    int X509_check_issued(X509* issuer, X509* subject);
+    int X509_check_akid(const X509* issuer, const AUTHORITY_KEYID* akid);
+    void X509_set_proxy_flag(X509* x);
+    void X509_set_proxy_pathlen(X509* x, long l);
+    long X509_get_proxy_pathlen(X509* x);
+
+    uint32_t X509_get_extension_flags(X509* x);
+    uint32_t X509_get_key_usage(X509* x);
+    uint32_t X509_get_extended_key_usage(X509* x);
+    const ASN1_OCTET_STRING* X509_get0_subject_key_id(X509* x);
+    const ASN1_OCTET_STRING* X509_get0_authority_key_id(X509* x);
+    const GENERAL_NAMES* X509_get0_authority_issuer(X509* x);
+    const ASN1_INTEGER* X509_get0_authority_serial(X509* x);
+
+    int X509_PURPOSE_get_count(void);
+    X509_PURPOSE* X509_PURPOSE_get0(int idx);
+    int X509_PURPOSE_get_by_sname(const char* sname);
+    int X509_PURPOSE_get_by_id(int id);
+    int X509_PURPOSE_add(int id, int trust, int flags, int (*ck)(const X509_PURPOSE*, const X509*, int), const char* name, const char* sname, void* arg);
+    char* X509_PURPOSE_get0_name(const X509_PURPOSE* xp);
+    char* X509_PURPOSE_get0_sname(const X509_PURPOSE* xp);
+    int X509_PURPOSE_get_trust(const X509_PURPOSE* xp);
+    void X509_PURPOSE_cleanup(void);
+    int X509_PURPOSE_get_id(const X509_PURPOSE*);
+
+    STACK_OF(OPENSSL_STRING) * X509_get1_email(X509* x);
+    STACK_OF(OPENSSL_STRING) * X509_REQ_get1_email(X509_REQ* x);
+    void X509_email_free(STACK_OF(OPENSSL_STRING) * sk);
+    STACK_OF(OPENSSL_STRING) * X509_get1_ocsp(X509* x);
 /* Flags for X509_check_* functions */
 
 /*
  * Always check subject name for host match even if subject alt names present
  */
-# define X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT    0x1
+#define X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT 0x1
 /* Disable wildcard matching for dnsName fields and common name. */
-# define X509_CHECK_FLAG_NO_WILDCARDS    0x2
+#define X509_CHECK_FLAG_NO_WILDCARDS 0x2
 /* Wildcards must not match a partial label. */
-# define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0x4
+#define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0x4
 /* Allow (non-partial) wildcards to match multiple labels. */
-# define X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS 0x8
+#define X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS 0x8
 /* Constraint verifier subdomain patterns to match a single labels. */
-# define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0x10
+#define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0x10
 /* Never check the subject CN */
-# define X509_CHECK_FLAG_NEVER_CHECK_SUBJECT    0x20
+#define X509_CHECK_FLAG_NEVER_CHECK_SUBJECT 0x20
 /*
  * Match reference identifiers starting with "." to any sub-domain.
  * This is a non-public flag, turned on implicitly when the subject
  * reference identity is a DNS name.
  */
-# define _X509_CHECK_FLAG_DOT_SUBDOMAINS 0x8000
-
-int X509_check_host(X509 *x, const char *chk, size_t chklen,
-                    unsigned int flags, char **peername);
-int X509_check_email(X509 *x, const char *chk, size_t chklen,
-                     unsigned int flags);
-int X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
-                  unsigned int flags);
-int X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags);
-
-ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc);
-ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc);
-int X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE) *dn_sk,
-                             unsigned long chtype);
-
-void X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent);
-SKM_DEFINE_STACK_OF_INTERNAL(X509_POLICY_NODE, X509_POLICY_NODE, X509_POLICY_NODE)
+#define _X509_CHECK_FLAG_DOT_SUBDOMAINS 0x8000
+
+    int X509_check_host(X509* x, const char* chk, size_t chklen, unsigned int flags, char** peername);
+    int X509_check_email(X509* x, const char* chk, size_t chklen, unsigned int flags);
+    int X509_check_ip(X509* x, const unsigned char* chk, size_t chklen, unsigned int flags);
+    int X509_check_ip_asc(X509* x, const char* ipasc, unsigned int flags);
+
+    ASN1_OCTET_STRING* a2i_IPADDRESS(const char* ipasc);
+    ASN1_OCTET_STRING* a2i_IPADDRESS_NC(const char* ipasc);
+    int X509V3_NAME_from_section(X509_NAME* nm, STACK_OF(CONF_VALUE) * dn_sk, unsigned long chtype);
+
+    void X509_POLICY_NODE_print(BIO* out, X509_POLICY_NODE* node, int indent);
+    SKM_DEFINE_STACK_OF_INTERNAL(X509_POLICY_NODE, X509_POLICY_NODE, X509_POLICY_NODE)
 #define sk_X509_POLICY_NODE_num(sk) OPENSSL_sk_num(ossl_check_const_X509_POLICY_NODE_sk_type(sk))
-#define sk_X509_POLICY_NODE_value(sk, idx) ((X509_POLICY_NODE *)OPENSSL_sk_value(ossl_check_const_X509_POLICY_NODE_sk_type(sk), (idx)))
-#define sk_X509_POLICY_NODE_new(cmp) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new(ossl_check_X509_POLICY_NODE_compfunc_type(cmp)))
-#define sk_X509_POLICY_NODE_new_null() ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new_null())
-#define sk_X509_POLICY_NODE_new_reserve(cmp, n) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_new_reserve(ossl_check_X509_POLICY_NODE_compfunc_type(cmp), (n)))
+#define sk_X509_POLICY_NODE_value(sk, idx) ((X509_POLICY_NODE*)OPENSSL_sk_value(ossl_check_const_X509_POLICY_NODE_sk_type(sk), (idx)))
+#define sk_X509_POLICY_NODE_new(cmp) ((STACK_OF(X509_POLICY_NODE)*)OPENSSL_sk_new(ossl_check_X509_POLICY_NODE_compfunc_type(cmp)))
+#define sk_X509_POLICY_NODE_new_null() ((STACK_OF(X509_POLICY_NODE)*)OPENSSL_sk_new_null())
+#define sk_X509_POLICY_NODE_new_reserve(cmp, n) ((STACK_OF(X509_POLICY_NODE)*)OPENSSL_sk_new_reserve(ossl_check_X509_POLICY_NODE_compfunc_type(cmp), (n)))
 #define sk_X509_POLICY_NODE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_POLICY_NODE_sk_type(sk), (n))
 #define sk_X509_POLICY_NODE_free(sk) OPENSSL_sk_free(ossl_check_X509_POLICY_NODE_sk_type(sk))
 #define sk_X509_POLICY_NODE_zero(sk) OPENSSL_sk_zero(ossl_check_X509_POLICY_NODE_sk_type(sk))
-#define sk_X509_POLICY_NODE_delete(sk, i) ((X509_POLICY_NODE *)OPENSSL_sk_delete(ossl_check_X509_POLICY_NODE_sk_type(sk), (i)))
-#define sk_X509_POLICY_NODE_delete_ptr(sk, ptr) ((X509_POLICY_NODE *)OPENSSL_sk_delete_ptr(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr)))
+#define sk_X509_POLICY_NODE_delete(sk, i) ((X509_POLICY_NODE*)OPENSSL_sk_delete(ossl_check_X509_POLICY_NODE_sk_type(sk), (i)))
+#define sk_X509_POLICY_NODE_delete_ptr(sk, ptr) ((X509_POLICY_NODE*)OPENSSL_sk_delete_ptr(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr)))
 #define sk_X509_POLICY_NODE_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
 #define sk_X509_POLICY_NODE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
-#define sk_X509_POLICY_NODE_pop(sk) ((X509_POLICY_NODE *)OPENSSL_sk_pop(ossl_check_X509_POLICY_NODE_sk_type(sk)))
-#define sk_X509_POLICY_NODE_shift(sk) ((X509_POLICY_NODE *)OPENSSL_sk_shift(ossl_check_X509_POLICY_NODE_sk_type(sk)))
-#define sk_X509_POLICY_NODE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_POLICY_NODE_sk_type(sk),ossl_check_X509_POLICY_NODE_freefunc_type(freefunc))
+#define sk_X509_POLICY_NODE_pop(sk) ((X509_POLICY_NODE*)OPENSSL_sk_pop(ossl_check_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_shift(sk) ((X509_POLICY_NODE*)OPENSSL_sk_shift(ossl_check_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_freefunc_type(freefunc))
 #define sk_X509_POLICY_NODE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr), (idx))
-#define sk_X509_POLICY_NODE_set(sk, idx, ptr) ((X509_POLICY_NODE *)OPENSSL_sk_set(ossl_check_X509_POLICY_NODE_sk_type(sk), (idx), ossl_check_X509_POLICY_NODE_type(ptr)))
+#define sk_X509_POLICY_NODE_set(sk, idx, ptr) ((X509_POLICY_NODE*)OPENSSL_sk_set(ossl_check_X509_POLICY_NODE_sk_type(sk), (idx), ossl_check_X509_POLICY_NODE_type(ptr)))
 #define sk_X509_POLICY_NODE_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
 #define sk_X509_POLICY_NODE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr))
 #define sk_X509_POLICY_NODE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_type(ptr), pnum)
 #define sk_X509_POLICY_NODE_sort(sk) OPENSSL_sk_sort(ossl_check_X509_POLICY_NODE_sk_type(sk))
 #define sk_X509_POLICY_NODE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_POLICY_NODE_sk_type(sk))
-#define sk_X509_POLICY_NODE_dup(sk) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_dup(ossl_check_const_X509_POLICY_NODE_sk_type(sk)))
-#define sk_X509_POLICY_NODE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_POLICY_NODE) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_copyfunc_type(copyfunc), ossl_check_X509_POLICY_NODE_freefunc_type(freefunc)))
+#define sk_X509_POLICY_NODE_dup(sk) ((STACK_OF(X509_POLICY_NODE)*)OPENSSL_sk_dup(ossl_check_const_X509_POLICY_NODE_sk_type(sk)))
+#define sk_X509_POLICY_NODE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_POLICY_NODE)*)OPENSSL_sk_deep_copy(ossl_check_const_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_copyfunc_type(copyfunc), ossl_check_X509_POLICY_NODE_freefunc_type(freefunc)))
 #define sk_X509_POLICY_NODE_set_cmp_func(sk, cmp) ((sk_X509_POLICY_NODE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_POLICY_NODE_sk_type(sk), ossl_check_X509_POLICY_NODE_compfunc_type(cmp)))
 
-
-
 #ifndef OPENSSL_NO_RFC3779
-typedef struct ASRange_st {
-    ASN1_INTEGER *min, *max;
-} ASRange;
-
-# define ASIdOrRange_id          0
-# define ASIdOrRange_range       1
-
-typedef struct ASIdOrRange_st {
-    int type;
-    union {
-        ASN1_INTEGER *id;
-        ASRange *range;
-    } u;
-} ASIdOrRange;
-
-SKM_DEFINE_STACK_OF_INTERNAL(ASIdOrRange, ASIdOrRange, ASIdOrRange)
+    typedef struct ASRange_st
+    {
+        ASN1_INTEGER *min, *max;
+    } ASRange;
+
+#define ASIdOrRange_id 0
+#define ASIdOrRange_range 1
+
+    typedef struct ASIdOrRange_st
+    {
+        int type;
+        union
+        {
+            ASN1_INTEGER* id;
+            ASRange* range;
+        } u;
+    } ASIdOrRange;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(ASIdOrRange, ASIdOrRange, ASIdOrRange)
 #define sk_ASIdOrRange_num(sk) OPENSSL_sk_num(ossl_check_const_ASIdOrRange_sk_type(sk))
-#define sk_ASIdOrRange_value(sk, idx) ((ASIdOrRange *)OPENSSL_sk_value(ossl_check_const_ASIdOrRange_sk_type(sk), (idx)))
-#define sk_ASIdOrRange_new(cmp) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new(ossl_check_ASIdOrRange_compfunc_type(cmp)))
-#define sk_ASIdOrRange_new_null() ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new_null())
-#define sk_ASIdOrRange_new_reserve(cmp, n) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_new_reserve(ossl_check_ASIdOrRange_compfunc_type(cmp), (n)))
+#define sk_ASIdOrRange_value(sk, idx) ((ASIdOrRange*)OPENSSL_sk_value(ossl_check_const_ASIdOrRange_sk_type(sk), (idx)))
+#define sk_ASIdOrRange_new(cmp) ((STACK_OF(ASIdOrRange)*)OPENSSL_sk_new(ossl_check_ASIdOrRange_compfunc_type(cmp)))
+#define sk_ASIdOrRange_new_null() ((STACK_OF(ASIdOrRange)*)OPENSSL_sk_new_null())
+#define sk_ASIdOrRange_new_reserve(cmp, n) ((STACK_OF(ASIdOrRange)*)OPENSSL_sk_new_reserve(ossl_check_ASIdOrRange_compfunc_type(cmp), (n)))
 #define sk_ASIdOrRange_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASIdOrRange_sk_type(sk), (n))
 #define sk_ASIdOrRange_free(sk) OPENSSL_sk_free(ossl_check_ASIdOrRange_sk_type(sk))
 #define sk_ASIdOrRange_zero(sk) OPENSSL_sk_zero(ossl_check_ASIdOrRange_sk_type(sk))
-#define sk_ASIdOrRange_delete(sk, i) ((ASIdOrRange *)OPENSSL_sk_delete(ossl_check_ASIdOrRange_sk_type(sk), (i)))
-#define sk_ASIdOrRange_delete_ptr(sk, ptr) ((ASIdOrRange *)OPENSSL_sk_delete_ptr(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr)))
+#define sk_ASIdOrRange_delete(sk, i) ((ASIdOrRange*)OPENSSL_sk_delete(ossl_check_ASIdOrRange_sk_type(sk), (i)))
+#define sk_ASIdOrRange_delete_ptr(sk, ptr) ((ASIdOrRange*)OPENSSL_sk_delete_ptr(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr)))
 #define sk_ASIdOrRange_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
 #define sk_ASIdOrRange_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
-#define sk_ASIdOrRange_pop(sk) ((ASIdOrRange *)OPENSSL_sk_pop(ossl_check_ASIdOrRange_sk_type(sk)))
-#define sk_ASIdOrRange_shift(sk) ((ASIdOrRange *)OPENSSL_sk_shift(ossl_check_ASIdOrRange_sk_type(sk)))
-#define sk_ASIdOrRange_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASIdOrRange_sk_type(sk),ossl_check_ASIdOrRange_freefunc_type(freefunc))
+#define sk_ASIdOrRange_pop(sk) ((ASIdOrRange*)OPENSSL_sk_pop(ossl_check_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_shift(sk) ((ASIdOrRange*)OPENSSL_sk_shift(ossl_check_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_freefunc_type(freefunc))
 #define sk_ASIdOrRange_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr), (idx))
-#define sk_ASIdOrRange_set(sk, idx, ptr) ((ASIdOrRange *)OPENSSL_sk_set(ossl_check_ASIdOrRange_sk_type(sk), (idx), ossl_check_ASIdOrRange_type(ptr)))
+#define sk_ASIdOrRange_set(sk, idx, ptr) ((ASIdOrRange*)OPENSSL_sk_set(ossl_check_ASIdOrRange_sk_type(sk), (idx), ossl_check_ASIdOrRange_type(ptr)))
 #define sk_ASIdOrRange_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
 #define sk_ASIdOrRange_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr))
 #define sk_ASIdOrRange_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_type(ptr), pnum)
 #define sk_ASIdOrRange_sort(sk) OPENSSL_sk_sort(ossl_check_ASIdOrRange_sk_type(sk))
 #define sk_ASIdOrRange_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASIdOrRange_sk_type(sk))
-#define sk_ASIdOrRange_dup(sk) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_dup(ossl_check_const_ASIdOrRange_sk_type(sk)))
-#define sk_ASIdOrRange_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASIdOrRange) *)OPENSSL_sk_deep_copy(ossl_check_const_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_copyfunc_type(copyfunc), ossl_check_ASIdOrRange_freefunc_type(freefunc)))
+#define sk_ASIdOrRange_dup(sk) ((STACK_OF(ASIdOrRange)*)OPENSSL_sk_dup(ossl_check_const_ASIdOrRange_sk_type(sk)))
+#define sk_ASIdOrRange_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASIdOrRange)*)OPENSSL_sk_deep_copy(ossl_check_const_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_copyfunc_type(copyfunc), ossl_check_ASIdOrRange_freefunc_type(freefunc)))
 #define sk_ASIdOrRange_set_cmp_func(sk, cmp) ((sk_ASIdOrRange_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASIdOrRange_sk_type(sk), ossl_check_ASIdOrRange_compfunc_type(cmp)))
 
-
-typedef STACK_OF(ASIdOrRange) ASIdOrRanges;
-
-# define ASIdentifierChoice_inherit              0
-# define ASIdentifierChoice_asIdsOrRanges        1
-
-typedef struct ASIdentifierChoice_st {
-    int type;
-    union {
-        ASN1_NULL *inherit;
-        ASIdOrRanges *asIdsOrRanges;
-    } u;
-} ASIdentifierChoice;
-
-typedef struct ASIdentifiers_st {
-    ASIdentifierChoice *asnum, *rdi;
-} ASIdentifiers;
-
-DECLARE_ASN1_FUNCTIONS(ASRange)
-DECLARE_ASN1_FUNCTIONS(ASIdOrRange)
-DECLARE_ASN1_FUNCTIONS(ASIdentifierChoice)
-DECLARE_ASN1_FUNCTIONS(ASIdentifiers)
-
-typedef struct IPAddressRange_st {
-    ASN1_BIT_STRING *min, *max;
-} IPAddressRange;
-
-# define IPAddressOrRange_addressPrefix  0
-# define IPAddressOrRange_addressRange   1
-
-typedef struct IPAddressOrRange_st {
-    int type;
-    union {
-        ASN1_BIT_STRING *addressPrefix;
-        IPAddressRange *addressRange;
-    } u;
-} IPAddressOrRange;
-
-SKM_DEFINE_STACK_OF_INTERNAL(IPAddressOrRange, IPAddressOrRange, IPAddressOrRange)
+    typedef STACK_OF(ASIdOrRange) ASIdOrRanges;
+
+#define ASIdentifierChoice_inherit 0
+#define ASIdentifierChoice_asIdsOrRanges 1
+
+    typedef struct ASIdentifierChoice_st
+    {
+        int type;
+        union
+        {
+            ASN1_NULL* inherit;
+            ASIdOrRanges* asIdsOrRanges;
+        } u;
+    } ASIdentifierChoice;
+
+    typedef struct ASIdentifiers_st
+    {
+        ASIdentifierChoice *asnum, *rdi;
+    } ASIdentifiers;
+
+    DECLARE_ASN1_FUNCTIONS(ASRange)
+    DECLARE_ASN1_FUNCTIONS(ASIdOrRange)
+    DECLARE_ASN1_FUNCTIONS(ASIdentifierChoice)
+    DECLARE_ASN1_FUNCTIONS(ASIdentifiers)
+
+    typedef struct IPAddressRange_st
+    {
+        ASN1_BIT_STRING *min, *max;
+    } IPAddressRange;
+
+#define IPAddressOrRange_addressPrefix 0
+#define IPAddressOrRange_addressRange 1
+
+    typedef struct IPAddressOrRange_st
+    {
+        int type;
+        union
+        {
+            ASN1_BIT_STRING* addressPrefix;
+            IPAddressRange* addressRange;
+        } u;
+    } IPAddressOrRange;
+
+    SKM_DEFINE_STACK_OF_INTERNAL(IPAddressOrRange, IPAddressOrRange, IPAddressOrRange)
 #define sk_IPAddressOrRange_num(sk) OPENSSL_sk_num(ossl_check_const_IPAddressOrRange_sk_type(sk))
-#define sk_IPAddressOrRange_value(sk, idx) ((IPAddressOrRange *)OPENSSL_sk_value(ossl_check_const_IPAddressOrRange_sk_type(sk), (idx)))
-#define sk_IPAddressOrRange_new(cmp) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new(ossl_check_IPAddressOrRange_compfunc_type(cmp)))
-#define sk_IPAddressOrRange_new_null() ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new_null())
-#define sk_IPAddressOrRange_new_reserve(cmp, n) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_new_reserve(ossl_check_IPAddressOrRange_compfunc_type(cmp), (n)))
+#define sk_IPAddressOrRange_value(sk, idx) ((IPAddressOrRange*)OPENSSL_sk_value(ossl_check_const_IPAddressOrRange_sk_type(sk), (idx)))
+#define sk_IPAddressOrRange_new(cmp) ((STACK_OF(IPAddressOrRange)*)OPENSSL_sk_new(ossl_check_IPAddressOrRange_compfunc_type(cmp)))
+#define sk_IPAddressOrRange_new_null() ((STACK_OF(IPAddressOrRange)*)OPENSSL_sk_new_null())
+#define sk_IPAddressOrRange_new_reserve(cmp, n) ((STACK_OF(IPAddressOrRange)*)OPENSSL_sk_new_reserve(ossl_check_IPAddressOrRange_compfunc_type(cmp), (n)))
 #define sk_IPAddressOrRange_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_IPAddressOrRange_sk_type(sk), (n))
 #define sk_IPAddressOrRange_free(sk) OPENSSL_sk_free(ossl_check_IPAddressOrRange_sk_type(sk))
 #define sk_IPAddressOrRange_zero(sk) OPENSSL_sk_zero(ossl_check_IPAddressOrRange_sk_type(sk))
-#define sk_IPAddressOrRange_delete(sk, i) ((IPAddressOrRange *)OPENSSL_sk_delete(ossl_check_IPAddressOrRange_sk_type(sk), (i)))
-#define sk_IPAddressOrRange_delete_ptr(sk, ptr) ((IPAddressOrRange *)OPENSSL_sk_delete_ptr(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr)))
+#define sk_IPAddressOrRange_delete(sk, i) ((IPAddressOrRange*)OPENSSL_sk_delete(ossl_check_IPAddressOrRange_sk_type(sk), (i)))
+#define sk_IPAddressOrRange_delete_ptr(sk, ptr) ((IPAddressOrRange*)OPENSSL_sk_delete_ptr(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr)))
 #define sk_IPAddressOrRange_push(sk, ptr) OPENSSL_sk_push(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
 #define sk_IPAddressOrRange_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
-#define sk_IPAddressOrRange_pop(sk) ((IPAddressOrRange *)OPENSSL_sk_pop(ossl_check_IPAddressOrRange_sk_type(sk)))
-#define sk_IPAddressOrRange_shift(sk) ((IPAddressOrRange *)OPENSSL_sk_shift(ossl_check_IPAddressOrRange_sk_type(sk)))
-#define sk_IPAddressOrRange_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_IPAddressOrRange_sk_type(sk),ossl_check_IPAddressOrRange_freefunc_type(freefunc))
+#define sk_IPAddressOrRange_pop(sk) ((IPAddressOrRange*)OPENSSL_sk_pop(ossl_check_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_shift(sk) ((IPAddressOrRange*)OPENSSL_sk_shift(ossl_check_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_freefunc_type(freefunc))
 #define sk_IPAddressOrRange_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr), (idx))
-#define sk_IPAddressOrRange_set(sk, idx, ptr) ((IPAddressOrRange *)OPENSSL_sk_set(ossl_check_IPAddressOrRange_sk_type(sk), (idx), ossl_check_IPAddressOrRange_type(ptr)))
+#define sk_IPAddressOrRange_set(sk, idx, ptr) ((IPAddressOrRange*)OPENSSL_sk_set(ossl_check_IPAddressOrRange_sk_type(sk), (idx), ossl_check_IPAddressOrRange_type(ptr)))
 #define sk_IPAddressOrRange_find(sk, ptr) OPENSSL_sk_find(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
 #define sk_IPAddressOrRange_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr))
 #define sk_IPAddressOrRange_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_type(ptr), pnum)
 #define sk_IPAddressOrRange_sort(sk) OPENSSL_sk_sort(ossl_check_IPAddressOrRange_sk_type(sk))
 #define sk_IPAddressOrRange_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_IPAddressOrRange_sk_type(sk))
-#define sk_IPAddressOrRange_dup(sk) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_dup(ossl_check_const_IPAddressOrRange_sk_type(sk)))
-#define sk_IPAddressOrRange_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(IPAddressOrRange) *)OPENSSL_sk_deep_copy(ossl_check_const_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_copyfunc_type(copyfunc), ossl_check_IPAddressOrRange_freefunc_type(freefunc)))
+#define sk_IPAddressOrRange_dup(sk) ((STACK_OF(IPAddressOrRange)*)OPENSSL_sk_dup(ossl_check_const_IPAddressOrRange_sk_type(sk)))
+#define sk_IPAddressOrRange_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(IPAddressOrRange)*)OPENSSL_sk_deep_copy(ossl_check_const_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_copyfunc_type(copyfunc), ossl_check_IPAddressOrRange_freefunc_type(freefunc)))
 #define sk_IPAddressOrRange_set_cmp_func(sk, cmp) ((sk_IPAddressOrRange_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_IPAddressOrRange_sk_type(sk), ossl_check_IPAddressOrRange_compfunc_type(cmp)))
 
+    typedef STACK_OF(IPAddressOrRange) IPAddressOrRanges;
 
-typedef STACK_OF(IPAddressOrRange) IPAddressOrRanges;
-
-# define IPAddressChoice_inherit                 0
-# define IPAddressChoice_addressesOrRanges       1
+#define IPAddressChoice_inherit 0
+#define IPAddressChoice_addressesOrRanges 1
 
-typedef struct IPAddressChoice_st {
-    int type;
-    union {
-        ASN1_NULL *inherit;
-        IPAddressOrRanges *addressesOrRanges;
-    } u;
-} IPAddressChoice;
+    typedef struct IPAddressChoice_st
+    {
+        int type;
+        union
+        {
+            ASN1_NULL* inherit;
+            IPAddressOrRanges* addressesOrRanges;
+        } u;
+    } IPAddressChoice;
 
-typedef struct IPAddressFamily_st {
-    ASN1_OCTET_STRING *addressFamily;
-    IPAddressChoice *ipAddressChoice;
-} IPAddressFamily;
+    typedef struct IPAddressFamily_st
+    {
+        ASN1_OCTET_STRING* addressFamily;
+        IPAddressChoice* ipAddressChoice;
+    } IPAddressFamily;
 
-SKM_DEFINE_STACK_OF_INTERNAL(IPAddressFamily, IPAddressFamily, IPAddressFamily)
+    SKM_DEFINE_STACK_OF_INTERNAL(IPAddressFamily, IPAddressFamily, IPAddressFamily)
 #define sk_IPAddressFamily_num(sk) OPENSSL_sk_num(ossl_check_const_IPAddressFamily_sk_type(sk))
-#define sk_IPAddressFamily_value(sk, idx) ((IPAddressFamily *)OPENSSL_sk_value(ossl_check_const_IPAddressFamily_sk_type(sk), (idx)))
-#define sk_IPAddressFamily_new(cmp) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new(ossl_check_IPAddressFamily_compfunc_type(cmp)))
-#define sk_IPAddressFamily_new_null() ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new_null())
-#define sk_IPAddressFamily_new_reserve(cmp, n) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_new_reserve(ossl_check_IPAddressFamily_compfunc_type(cmp), (n)))
+#define sk_IPAddressFamily_value(sk, idx) ((IPAddressFamily*)OPENSSL_sk_value(ossl_check_const_IPAddressFamily_sk_type(sk), (idx)))
+#define sk_IPAddressFamily_new(cmp) ((STACK_OF(IPAddressFamily)*)OPENSSL_sk_new(ossl_check_IPAddressFamily_compfunc_type(cmp)))
+#define sk_IPAddressFamily_new_null() ((STACK_OF(IPAddressFamily)*)OPENSSL_sk_new_null())
+#define sk_IPAddressFamily_new_reserve(cmp, n) ((STACK_OF(IPAddressFamily)*)OPENSSL_sk_new_reserve(ossl_check_IPAddressFamily_compfunc_type(cmp), (n)))
 #define sk_IPAddressFamily_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_IPAddressFamily_sk_type(sk), (n))
 #define sk_IPAddressFamily_free(sk) OPENSSL_sk_free(ossl_check_IPAddressFamily_sk_type(sk))
 #define sk_IPAddressFamily_zero(sk) OPENSSL_sk_zero(ossl_check_IPAddressFamily_sk_type(sk))
-#define sk_IPAddressFamily_delete(sk, i) ((IPAddressFamily *)OPENSSL_sk_delete(ossl_check_IPAddressFamily_sk_type(sk), (i)))
-#define sk_IPAddressFamily_delete_ptr(sk, ptr) ((IPAddressFamily *)OPENSSL_sk_delete_ptr(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr)))
+#define sk_IPAddressFamily_delete(sk, i) ((IPAddressFamily*)OPENSSL_sk_delete(ossl_check_IPAddressFamily_sk_type(sk), (i)))
+#define sk_IPAddressFamily_delete_ptr(sk, ptr) ((IPAddressFamily*)OPENSSL_sk_delete_ptr(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr)))
 #define sk_IPAddressFamily_push(sk, ptr) OPENSSL_sk_push(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
 #define sk_IPAddressFamily_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
-#define sk_IPAddressFamily_pop(sk) ((IPAddressFamily *)OPENSSL_sk_pop(ossl_check_IPAddressFamily_sk_type(sk)))
-#define sk_IPAddressFamily_shift(sk) ((IPAddressFamily *)OPENSSL_sk_shift(ossl_check_IPAddressFamily_sk_type(sk)))
-#define sk_IPAddressFamily_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_IPAddressFamily_sk_type(sk),ossl_check_IPAddressFamily_freefunc_type(freefunc))
+#define sk_IPAddressFamily_pop(sk) ((IPAddressFamily*)OPENSSL_sk_pop(ossl_check_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_shift(sk) ((IPAddressFamily*)OPENSSL_sk_shift(ossl_check_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_freefunc_type(freefunc))
 #define sk_IPAddressFamily_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr), (idx))
-#define sk_IPAddressFamily_set(sk, idx, ptr) ((IPAddressFamily *)OPENSSL_sk_set(ossl_check_IPAddressFamily_sk_type(sk), (idx), ossl_check_IPAddressFamily_type(ptr)))
+#define sk_IPAddressFamily_set(sk, idx, ptr) ((IPAddressFamily*)OPENSSL_sk_set(ossl_check_IPAddressFamily_sk_type(sk), (idx), ossl_check_IPAddressFamily_type(ptr)))
 #define sk_IPAddressFamily_find(sk, ptr) OPENSSL_sk_find(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
 #define sk_IPAddressFamily_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr))
 #define sk_IPAddressFamily_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_type(ptr), pnum)
 #define sk_IPAddressFamily_sort(sk) OPENSSL_sk_sort(ossl_check_IPAddressFamily_sk_type(sk))
 #define sk_IPAddressFamily_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_IPAddressFamily_sk_type(sk))
-#define sk_IPAddressFamily_dup(sk) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_dup(ossl_check_const_IPAddressFamily_sk_type(sk)))
-#define sk_IPAddressFamily_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(IPAddressFamily) *)OPENSSL_sk_deep_copy(ossl_check_const_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_copyfunc_type(copyfunc), ossl_check_IPAddressFamily_freefunc_type(freefunc)))
+#define sk_IPAddressFamily_dup(sk) ((STACK_OF(IPAddressFamily)*)OPENSSL_sk_dup(ossl_check_const_IPAddressFamily_sk_type(sk)))
+#define sk_IPAddressFamily_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(IPAddressFamily)*)OPENSSL_sk_deep_copy(ossl_check_const_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_copyfunc_type(copyfunc), ossl_check_IPAddressFamily_freefunc_type(freefunc)))
 #define sk_IPAddressFamily_set_cmp_func(sk, cmp) ((sk_IPAddressFamily_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_IPAddressFamily_sk_type(sk), ossl_check_IPAddressFamily_compfunc_type(cmp)))
 
+    typedef STACK_OF(IPAddressFamily) IPAddrBlocks;
 
-
-typedef STACK_OF(IPAddressFamily) IPAddrBlocks;
-
-DECLARE_ASN1_FUNCTIONS(IPAddressRange)
-DECLARE_ASN1_FUNCTIONS(IPAddressOrRange)
-DECLARE_ASN1_FUNCTIONS(IPAddressChoice)
-DECLARE_ASN1_FUNCTIONS(IPAddressFamily)
+    DECLARE_ASN1_FUNCTIONS(IPAddressRange)
+    DECLARE_ASN1_FUNCTIONS(IPAddressOrRange)
+    DECLARE_ASN1_FUNCTIONS(IPAddressChoice)
+    DECLARE_ASN1_FUNCTIONS(IPAddressFamily)
 
 /*
  * API tag for elements of the ASIdentifer SEQUENCE.
  */
-# define V3_ASID_ASNUM   0
-# define V3_ASID_RDI     1
+#define V3_ASID_ASNUM 0
+#define V3_ASID_RDI 1
 
 /*
  * AFI values, assigned by IANA.  It'd be nice to make the AFI
@@ -1249,202 +1219,204 @@ DECLARE_ASN1_FUNCTIONS(IPAddressFamily)
  * that would need to be defined for other address families for it to
  * be worth the trouble.
  */
-# define IANA_AFI_IPV4   1
-# define IANA_AFI_IPV6   2
-
-/*
- * Utilities to construct and extract values from RFC3779 extensions,
- * since some of the encodings (particularly for IP address prefixes
- * and ranges) are a bit tedious to work with directly.
- */
-int X509v3_asid_add_inherit(ASIdentifiers *asid, int which);
-int X509v3_asid_add_id_or_range(ASIdentifiers *asid, int which,
-                                ASN1_INTEGER *min, ASN1_INTEGER *max);
-int X509v3_addr_add_inherit(IPAddrBlocks *addr,
-                            const unsigned afi, const unsigned *safi);
-int X509v3_addr_add_prefix(IPAddrBlocks *addr,
-                           const unsigned afi, const unsigned *safi,
-                           unsigned char *a, const int prefixlen);
-int X509v3_addr_add_range(IPAddrBlocks *addr,
-                          const unsigned afi, const unsigned *safi,
-                          unsigned char *min, unsigned char *max);
-unsigned X509v3_addr_get_afi(const IPAddressFamily *f);
-int X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi,
-                          unsigned char *min, unsigned char *max,
-                          const int length);
-
-/*
- * Canonical forms.
- */
-int X509v3_asid_is_canonical(ASIdentifiers *asid);
-int X509v3_addr_is_canonical(IPAddrBlocks *addr);
-int X509v3_asid_canonize(ASIdentifiers *asid);
-int X509v3_addr_canonize(IPAddrBlocks *addr);
-
-/*
- * Tests for inheritance and containment.
- */
-int X509v3_asid_inherits(ASIdentifiers *asid);
-int X509v3_addr_inherits(IPAddrBlocks *addr);
-int X509v3_asid_subset(ASIdentifiers *a, ASIdentifiers *b);
-int X509v3_addr_subset(IPAddrBlocks *a, IPAddrBlocks *b);
-
-/*
- * Check whether RFC 3779 extensions nest properly in chains.
- */
-int X509v3_asid_validate_path(X509_STORE_CTX *);
-int X509v3_addr_validate_path(X509_STORE_CTX *);
-int X509v3_asid_validate_resource_set(STACK_OF(X509) *chain,
-                                      ASIdentifiers *ext,
-                                      int allow_inheritance);
-int X509v3_addr_validate_resource_set(STACK_OF(X509) *chain,
-                                      IPAddrBlocks *ext, int allow_inheritance);
-
-#endif                         /* OPENSSL_NO_RFC3779 */
-
-SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING, ASN1_STRING, ASN1_STRING)
+#define IANA_AFI_IPV4 1
+#define IANA_AFI_IPV6 2
+
+    /*
+     * Utilities to construct and extract values from RFC3779 extensions,
+     * since some of the encodings (particularly for IP address prefixes
+     * and ranges) are a bit tedious to work with directly.
+     */
+    int X509v3_asid_add_inherit(ASIdentifiers* asid, int which);
+    int X509v3_asid_add_id_or_range(ASIdentifiers* asid, int which, ASN1_INTEGER* min, ASN1_INTEGER* max);
+    int X509v3_addr_add_inherit(IPAddrBlocks* addr, const unsigned afi, const unsigned* safi);
+    int X509v3_addr_add_prefix(IPAddrBlocks* addr, const unsigned afi, const unsigned* safi, unsigned char* a, const int prefixlen);
+    int X509v3_addr_add_range(IPAddrBlocks* addr, const unsigned afi, const unsigned* safi, unsigned char* min, unsigned char* max);
+    unsigned X509v3_addr_get_afi(const IPAddressFamily* f);
+    int X509v3_addr_get_range(IPAddressOrRange* aor, const unsigned afi, unsigned char* min, unsigned char* max, const int length);
+
+    /*
+     * Canonical forms.
+     */
+    int X509v3_asid_is_canonical(ASIdentifiers* asid);
+    int X509v3_addr_is_canonical(IPAddrBlocks* addr);
+    int X509v3_asid_canonize(ASIdentifiers* asid);
+    int X509v3_addr_canonize(IPAddrBlocks* addr);
+
+    /*
+     * Tests for inheritance and containment.
+     */
+    int X509v3_asid_inherits(ASIdentifiers* asid);
+    int X509v3_addr_inherits(IPAddrBlocks* addr);
+    int X509v3_asid_subset(ASIdentifiers* a, ASIdentifiers* b);
+    int X509v3_addr_subset(IPAddrBlocks* a, IPAddrBlocks* b);
+
+    /*
+     * Check whether RFC 3779 extensions nest properly in chains.
+     */
+    int X509v3_asid_validate_path(X509_STORE_CTX*);
+    int X509v3_addr_validate_path(X509_STORE_CTX*);
+    int X509v3_asid_validate_resource_set(STACK_OF(X509) * chain, ASIdentifiers* ext, int allow_inheritance);
+    int X509v3_addr_validate_resource_set(STACK_OF(X509) * chain, IPAddrBlocks* ext, int allow_inheritance);
+
+#endif /* OPENSSL_NO_RFC3779 */
+
+    SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING, ASN1_STRING, ASN1_STRING)
 #define sk_ASN1_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_STRING_sk_type(sk))
-#define sk_ASN1_STRING_value(sk, idx) ((ASN1_STRING *)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_sk_type(sk), (idx)))
-#define sk_ASN1_STRING_new(cmp) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new(ossl_check_ASN1_STRING_compfunc_type(cmp)))
-#define sk_ASN1_STRING_new_null() ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new_null())
-#define sk_ASN1_STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_compfunc_type(cmp), (n)))
+#define sk_ASN1_STRING_value(sk, idx) ((ASN1_STRING*)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_sk_type(sk), (idx)))
+#define sk_ASN1_STRING_new(cmp) ((STACK_OF(ASN1_STRING)*)OPENSSL_sk_new(ossl_check_ASN1_STRING_compfunc_type(cmp)))
+#define sk_ASN1_STRING_new_null() ((STACK_OF(ASN1_STRING)*)OPENSSL_sk_new_null())
+#define sk_ASN1_STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING)*)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_compfunc_type(cmp), (n)))
 #define sk_ASN1_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_STRING_sk_type(sk), (n))
 #define sk_ASN1_STRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_STRING_sk_type(sk))
 #define sk_ASN1_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_STRING_sk_type(sk))
-#define sk_ASN1_STRING_delete(sk, i) ((ASN1_STRING *)OPENSSL_sk_delete(ossl_check_ASN1_STRING_sk_type(sk), (i)))
-#define sk_ASN1_STRING_delete_ptr(sk, ptr) ((ASN1_STRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr)))
+#define sk_ASN1_STRING_delete(sk, i) ((ASN1_STRING*)OPENSSL_sk_delete(ossl_check_ASN1_STRING_sk_type(sk), (i)))
+#define sk_ASN1_STRING_delete_ptr(sk, ptr) ((ASN1_STRING*)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr)))
 #define sk_ASN1_STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
 #define sk_ASN1_STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
-#define sk_ASN1_STRING_pop(sk) ((ASN1_STRING *)OPENSSL_sk_pop(ossl_check_ASN1_STRING_sk_type(sk)))
-#define sk_ASN1_STRING_shift(sk) ((ASN1_STRING *)OPENSSL_sk_shift(ossl_check_ASN1_STRING_sk_type(sk)))
-#define sk_ASN1_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_sk_type(sk),ossl_check_ASN1_STRING_freefunc_type(freefunc))
+#define sk_ASN1_STRING_pop(sk) ((ASN1_STRING*)OPENSSL_sk_pop(ossl_check_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_shift(sk) ((ASN1_STRING*)OPENSSL_sk_shift(ossl_check_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_freefunc_type(freefunc))
 #define sk_ASN1_STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr), (idx))
-#define sk_ASN1_STRING_set(sk, idx, ptr) ((ASN1_STRING *)OPENSSL_sk_set(ossl_check_ASN1_STRING_sk_type(sk), (idx), ossl_check_ASN1_STRING_type(ptr)))
+#define sk_ASN1_STRING_set(sk, idx, ptr) ((ASN1_STRING*)OPENSSL_sk_set(ossl_check_ASN1_STRING_sk_type(sk), (idx), ossl_check_ASN1_STRING_type(ptr)))
 #define sk_ASN1_STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
 #define sk_ASN1_STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr))
 #define sk_ASN1_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_type(ptr), pnum)
 #define sk_ASN1_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_STRING_sk_type(sk))
 #define sk_ASN1_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_STRING_sk_type(sk))
-#define sk_ASN1_STRING_dup(sk) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_sk_type(sk)))
-#define sk_ASN1_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_freefunc_type(freefunc)))
+#define sk_ASN1_STRING_dup(sk) ((STACK_OF(ASN1_STRING)*)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_sk_type(sk)))
+#define sk_ASN1_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING)*)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_freefunc_type(freefunc)))
 #define sk_ASN1_STRING_set_cmp_func(sk, cmp) ((sk_ASN1_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_STRING_sk_type(sk), ossl_check_ASN1_STRING_compfunc_type(cmp)))
 
-
-/*
- * Admission Syntax
- */
-typedef struct NamingAuthority_st NAMING_AUTHORITY;
-typedef struct ProfessionInfo_st PROFESSION_INFO;
-typedef struct Admissions_st ADMISSIONS;
-typedef struct AdmissionSyntax_st ADMISSION_SYNTAX;
-DECLARE_ASN1_FUNCTIONS(NAMING_AUTHORITY)
-DECLARE_ASN1_FUNCTIONS(PROFESSION_INFO)
-DECLARE_ASN1_FUNCTIONS(ADMISSIONS)
-DECLARE_ASN1_FUNCTIONS(ADMISSION_SYNTAX)
-SKM_DEFINE_STACK_OF_INTERNAL(PROFESSION_INFO, PROFESSION_INFO, PROFESSION_INFO)
+    /*
+     * Admission Syntax
+     */
+    typedef struct NamingAuthority_st NAMING_AUTHORITY;
+    typedef struct ProfessionInfo_st PROFESSION_INFO;
+    typedef struct Admissions_st ADMISSIONS;
+    typedef struct AdmissionSyntax_st ADMISSION_SYNTAX;
+    DECLARE_ASN1_FUNCTIONS(NAMING_AUTHORITY)
+    DECLARE_ASN1_FUNCTIONS(PROFESSION_INFO)
+    DECLARE_ASN1_FUNCTIONS(ADMISSIONS)
+    DECLARE_ASN1_FUNCTIONS(ADMISSION_SYNTAX)
+    SKM_DEFINE_STACK_OF_INTERNAL(PROFESSION_INFO, PROFESSION_INFO, PROFESSION_INFO)
 #define sk_PROFESSION_INFO_num(sk) OPENSSL_sk_num(ossl_check_const_PROFESSION_INFO_sk_type(sk))
-#define sk_PROFESSION_INFO_value(sk, idx) ((PROFESSION_INFO *)OPENSSL_sk_value(ossl_check_const_PROFESSION_INFO_sk_type(sk), (idx)))
-#define sk_PROFESSION_INFO_new(cmp) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new(ossl_check_PROFESSION_INFO_compfunc_type(cmp)))
-#define sk_PROFESSION_INFO_new_null() ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new_null())
-#define sk_PROFESSION_INFO_new_reserve(cmp, n) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_new_reserve(ossl_check_PROFESSION_INFO_compfunc_type(cmp), (n)))
+#define sk_PROFESSION_INFO_value(sk, idx) ((PROFESSION_INFO*)OPENSSL_sk_value(ossl_check_const_PROFESSION_INFO_sk_type(sk), (idx)))
+#define sk_PROFESSION_INFO_new(cmp) ((STACK_OF(PROFESSION_INFO)*)OPENSSL_sk_new(ossl_check_PROFESSION_INFO_compfunc_type(cmp)))
+#define sk_PROFESSION_INFO_new_null() ((STACK_OF(PROFESSION_INFO)*)OPENSSL_sk_new_null())
+#define sk_PROFESSION_INFO_new_reserve(cmp, n) ((STACK_OF(PROFESSION_INFO)*)OPENSSL_sk_new_reserve(ossl_check_PROFESSION_INFO_compfunc_type(cmp), (n)))
 #define sk_PROFESSION_INFO_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PROFESSION_INFO_sk_type(sk), (n))
 #define sk_PROFESSION_INFO_free(sk) OPENSSL_sk_free(ossl_check_PROFESSION_INFO_sk_type(sk))
 #define sk_PROFESSION_INFO_zero(sk) OPENSSL_sk_zero(ossl_check_PROFESSION_INFO_sk_type(sk))
-#define sk_PROFESSION_INFO_delete(sk, i) ((PROFESSION_INFO *)OPENSSL_sk_delete(ossl_check_PROFESSION_INFO_sk_type(sk), (i)))
-#define sk_PROFESSION_INFO_delete_ptr(sk, ptr) ((PROFESSION_INFO *)OPENSSL_sk_delete_ptr(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr)))
+#define sk_PROFESSION_INFO_delete(sk, i) ((PROFESSION_INFO*)OPENSSL_sk_delete(ossl_check_PROFESSION_INFO_sk_type(sk), (i)))
+#define sk_PROFESSION_INFO_delete_ptr(sk, ptr) ((PROFESSION_INFO*)OPENSSL_sk_delete_ptr(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr)))
 #define sk_PROFESSION_INFO_push(sk, ptr) OPENSSL_sk_push(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
 #define sk_PROFESSION_INFO_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
-#define sk_PROFESSION_INFO_pop(sk) ((PROFESSION_INFO *)OPENSSL_sk_pop(ossl_check_PROFESSION_INFO_sk_type(sk)))
-#define sk_PROFESSION_INFO_shift(sk) ((PROFESSION_INFO *)OPENSSL_sk_shift(ossl_check_PROFESSION_INFO_sk_type(sk)))
-#define sk_PROFESSION_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PROFESSION_INFO_sk_type(sk),ossl_check_PROFESSION_INFO_freefunc_type(freefunc))
+#define sk_PROFESSION_INFO_pop(sk) ((PROFESSION_INFO*)OPENSSL_sk_pop(ossl_check_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_shift(sk) ((PROFESSION_INFO*)OPENSSL_sk_shift(ossl_check_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_freefunc_type(freefunc))
 #define sk_PROFESSION_INFO_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr), (idx))
-#define sk_PROFESSION_INFO_set(sk, idx, ptr) ((PROFESSION_INFO *)OPENSSL_sk_set(ossl_check_PROFESSION_INFO_sk_type(sk), (idx), ossl_check_PROFESSION_INFO_type(ptr)))
+#define sk_PROFESSION_INFO_set(sk, idx, ptr) ((PROFESSION_INFO*)OPENSSL_sk_set(ossl_check_PROFESSION_INFO_sk_type(sk), (idx), ossl_check_PROFESSION_INFO_type(ptr)))
 #define sk_PROFESSION_INFO_find(sk, ptr) OPENSSL_sk_find(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
 #define sk_PROFESSION_INFO_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr))
 #define sk_PROFESSION_INFO_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_type(ptr), pnum)
 #define sk_PROFESSION_INFO_sort(sk) OPENSSL_sk_sort(ossl_check_PROFESSION_INFO_sk_type(sk))
 #define sk_PROFESSION_INFO_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PROFESSION_INFO_sk_type(sk))
-#define sk_PROFESSION_INFO_dup(sk) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_dup(ossl_check_const_PROFESSION_INFO_sk_type(sk)))
-#define sk_PROFESSION_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PROFESSION_INFO) *)OPENSSL_sk_deep_copy(ossl_check_const_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_copyfunc_type(copyfunc), ossl_check_PROFESSION_INFO_freefunc_type(freefunc)))
+#define sk_PROFESSION_INFO_dup(sk) ((STACK_OF(PROFESSION_INFO)*)OPENSSL_sk_dup(ossl_check_const_PROFESSION_INFO_sk_type(sk)))
+#define sk_PROFESSION_INFO_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PROFESSION_INFO)*)OPENSSL_sk_deep_copy(ossl_check_const_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_copyfunc_type(copyfunc), ossl_check_PROFESSION_INFO_freefunc_type(freefunc)))
 #define sk_PROFESSION_INFO_set_cmp_func(sk, cmp) ((sk_PROFESSION_INFO_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PROFESSION_INFO_sk_type(sk), ossl_check_PROFESSION_INFO_compfunc_type(cmp)))
-SKM_DEFINE_STACK_OF_INTERNAL(ADMISSIONS, ADMISSIONS, ADMISSIONS)
+    SKM_DEFINE_STACK_OF_INTERNAL(ADMISSIONS, ADMISSIONS, ADMISSIONS)
 #define sk_ADMISSIONS_num(sk) OPENSSL_sk_num(ossl_check_const_ADMISSIONS_sk_type(sk))
-#define sk_ADMISSIONS_value(sk, idx) ((ADMISSIONS *)OPENSSL_sk_value(ossl_check_const_ADMISSIONS_sk_type(sk), (idx)))
-#define sk_ADMISSIONS_new(cmp) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new(ossl_check_ADMISSIONS_compfunc_type(cmp)))
-#define sk_ADMISSIONS_new_null() ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new_null())
-#define sk_ADMISSIONS_new_reserve(cmp, n) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_new_reserve(ossl_check_ADMISSIONS_compfunc_type(cmp), (n)))
+#define sk_ADMISSIONS_value(sk, idx) ((ADMISSIONS*)OPENSSL_sk_value(ossl_check_const_ADMISSIONS_sk_type(sk), (idx)))
+#define sk_ADMISSIONS_new(cmp) ((STACK_OF(ADMISSIONS)*)OPENSSL_sk_new(ossl_check_ADMISSIONS_compfunc_type(cmp)))
+#define sk_ADMISSIONS_new_null() ((STACK_OF(ADMISSIONS)*)OPENSSL_sk_new_null())
+#define sk_ADMISSIONS_new_reserve(cmp, n) ((STACK_OF(ADMISSIONS)*)OPENSSL_sk_new_reserve(ossl_check_ADMISSIONS_compfunc_type(cmp), (n)))
 #define sk_ADMISSIONS_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ADMISSIONS_sk_type(sk), (n))
 #define sk_ADMISSIONS_free(sk) OPENSSL_sk_free(ossl_check_ADMISSIONS_sk_type(sk))
 #define sk_ADMISSIONS_zero(sk) OPENSSL_sk_zero(ossl_check_ADMISSIONS_sk_type(sk))
-#define sk_ADMISSIONS_delete(sk, i) ((ADMISSIONS *)OPENSSL_sk_delete(ossl_check_ADMISSIONS_sk_type(sk), (i)))
-#define sk_ADMISSIONS_delete_ptr(sk, ptr) ((ADMISSIONS *)OPENSSL_sk_delete_ptr(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr)))
+#define sk_ADMISSIONS_delete(sk, i) ((ADMISSIONS*)OPENSSL_sk_delete(ossl_check_ADMISSIONS_sk_type(sk), (i)))
+#define sk_ADMISSIONS_delete_ptr(sk, ptr) ((ADMISSIONS*)OPENSSL_sk_delete_ptr(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr)))
 #define sk_ADMISSIONS_push(sk, ptr) OPENSSL_sk_push(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
 #define sk_ADMISSIONS_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
-#define sk_ADMISSIONS_pop(sk) ((ADMISSIONS *)OPENSSL_sk_pop(ossl_check_ADMISSIONS_sk_type(sk)))
-#define sk_ADMISSIONS_shift(sk) ((ADMISSIONS *)OPENSSL_sk_shift(ossl_check_ADMISSIONS_sk_type(sk)))
-#define sk_ADMISSIONS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ADMISSIONS_sk_type(sk),ossl_check_ADMISSIONS_freefunc_type(freefunc))
+#define sk_ADMISSIONS_pop(sk) ((ADMISSIONS*)OPENSSL_sk_pop(ossl_check_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_shift(sk) ((ADMISSIONS*)OPENSSL_sk_shift(ossl_check_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_freefunc_type(freefunc))
 #define sk_ADMISSIONS_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr), (idx))
-#define sk_ADMISSIONS_set(sk, idx, ptr) ((ADMISSIONS *)OPENSSL_sk_set(ossl_check_ADMISSIONS_sk_type(sk), (idx), ossl_check_ADMISSIONS_type(ptr)))
+#define sk_ADMISSIONS_set(sk, idx, ptr) ((ADMISSIONS*)OPENSSL_sk_set(ossl_check_ADMISSIONS_sk_type(sk), (idx), ossl_check_ADMISSIONS_type(ptr)))
 #define sk_ADMISSIONS_find(sk, ptr) OPENSSL_sk_find(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
 #define sk_ADMISSIONS_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr))
 #define sk_ADMISSIONS_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_type(ptr), pnum)
 #define sk_ADMISSIONS_sort(sk) OPENSSL_sk_sort(ossl_check_ADMISSIONS_sk_type(sk))
 #define sk_ADMISSIONS_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ADMISSIONS_sk_type(sk))
-#define sk_ADMISSIONS_dup(sk) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_dup(ossl_check_const_ADMISSIONS_sk_type(sk)))
-#define sk_ADMISSIONS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ADMISSIONS) *)OPENSSL_sk_deep_copy(ossl_check_const_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_copyfunc_type(copyfunc), ossl_check_ADMISSIONS_freefunc_type(freefunc)))
+#define sk_ADMISSIONS_dup(sk) ((STACK_OF(ADMISSIONS)*)OPENSSL_sk_dup(ossl_check_const_ADMISSIONS_sk_type(sk)))
+#define sk_ADMISSIONS_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ADMISSIONS)*)OPENSSL_sk_deep_copy(ossl_check_const_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_copyfunc_type(copyfunc), ossl_check_ADMISSIONS_freefunc_type(freefunc)))
 #define sk_ADMISSIONS_set_cmp_func(sk, cmp) ((sk_ADMISSIONS_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ADMISSIONS_sk_type(sk), ossl_check_ADMISSIONS_compfunc_type(cmp)))
 
-typedef STACK_OF(PROFESSION_INFO) PROFESSION_INFOS;
-
-const ASN1_OBJECT *NAMING_AUTHORITY_get0_authorityId(
-    const NAMING_AUTHORITY *n);
-const ASN1_IA5STRING *NAMING_AUTHORITY_get0_authorityURL(
-    const NAMING_AUTHORITY *n);
-const ASN1_STRING *NAMING_AUTHORITY_get0_authorityText(
-    const NAMING_AUTHORITY *n);
-void NAMING_AUTHORITY_set0_authorityId(NAMING_AUTHORITY *n,
-    ASN1_OBJECT* namingAuthorityId);
-void NAMING_AUTHORITY_set0_authorityURL(NAMING_AUTHORITY *n,
-    ASN1_IA5STRING* namingAuthorityUrl);
-void NAMING_AUTHORITY_set0_authorityText(NAMING_AUTHORITY *n,
-    ASN1_STRING* namingAuthorityText);
-
-const GENERAL_NAME *ADMISSION_SYNTAX_get0_admissionAuthority(
-    const ADMISSION_SYNTAX *as);
-void ADMISSION_SYNTAX_set0_admissionAuthority(
-    ADMISSION_SYNTAX *as, GENERAL_NAME *aa);
-const STACK_OF(ADMISSIONS) *ADMISSION_SYNTAX_get0_contentsOfAdmissions(
-    const ADMISSION_SYNTAX *as);
-void ADMISSION_SYNTAX_set0_contentsOfAdmissions(
-    ADMISSION_SYNTAX *as, STACK_OF(ADMISSIONS) *a);
-const GENERAL_NAME *ADMISSIONS_get0_admissionAuthority(const ADMISSIONS *a);
-void ADMISSIONS_set0_admissionAuthority(ADMISSIONS *a, GENERAL_NAME *aa);
-const NAMING_AUTHORITY *ADMISSIONS_get0_namingAuthority(const ADMISSIONS *a);
-void ADMISSIONS_set0_namingAuthority(ADMISSIONS *a, NAMING_AUTHORITY *na);
-const PROFESSION_INFOS *ADMISSIONS_get0_professionInfos(const ADMISSIONS *a);
-void ADMISSIONS_set0_professionInfos(ADMISSIONS *a, PROFESSION_INFOS *pi);
-const ASN1_OCTET_STRING *PROFESSION_INFO_get0_addProfessionInfo(
-    const PROFESSION_INFO *pi);
-void PROFESSION_INFO_set0_addProfessionInfo(
-    PROFESSION_INFO *pi, ASN1_OCTET_STRING *aos);
-const NAMING_AUTHORITY *PROFESSION_INFO_get0_namingAuthority(
-    const PROFESSION_INFO *pi);
-void PROFESSION_INFO_set0_namingAuthority(
-    PROFESSION_INFO *pi, NAMING_AUTHORITY *na);
-const STACK_OF(ASN1_STRING) *PROFESSION_INFO_get0_professionItems(
-    const PROFESSION_INFO *pi);
-void PROFESSION_INFO_set0_professionItems(
-    PROFESSION_INFO *pi, STACK_OF(ASN1_STRING) *as);
-const STACK_OF(ASN1_OBJECT) *PROFESSION_INFO_get0_professionOIDs(
-    const PROFESSION_INFO *pi);
-void PROFESSION_INFO_set0_professionOIDs(
-    PROFESSION_INFO *pi, STACK_OF(ASN1_OBJECT) *po);
-const ASN1_PRINTABLESTRING *PROFESSION_INFO_get0_registrationNumber(
-    const PROFESSION_INFO *pi);
-void PROFESSION_INFO_set0_registrationNumber(
-    PROFESSION_INFO *pi, ASN1_PRINTABLESTRING *rn);
-
-# ifdef  __cplusplus
+    typedef STACK_OF(PROFESSION_INFO) PROFESSION_INFOS;
+
+    const ASN1_OBJECT* NAMING_AUTHORITY_get0_authorityId(
+        const NAMING_AUTHORITY* n
+    );
+    const ASN1_IA5STRING* NAMING_AUTHORITY_get0_authorityURL(
+        const NAMING_AUTHORITY* n
+    );
+    const ASN1_STRING* NAMING_AUTHORITY_get0_authorityText(
+        const NAMING_AUTHORITY* n
+    );
+    void NAMING_AUTHORITY_set0_authorityId(NAMING_AUTHORITY* n, ASN1_OBJECT* namingAuthorityId);
+    void NAMING_AUTHORITY_set0_authorityURL(NAMING_AUTHORITY* n, ASN1_IA5STRING* namingAuthorityUrl);
+    void NAMING_AUTHORITY_set0_authorityText(NAMING_AUTHORITY* n, ASN1_STRING* namingAuthorityText);
+
+    const GENERAL_NAME* ADMISSION_SYNTAX_get0_admissionAuthority(
+        const ADMISSION_SYNTAX* as
+    );
+    void ADMISSION_SYNTAX_set0_admissionAuthority(
+        ADMISSION_SYNTAX* as, GENERAL_NAME* aa
+    );
+    const STACK_OF(ADMISSIONS) * ADMISSION_SYNTAX_get0_contentsOfAdmissions(
+                                     const ADMISSION_SYNTAX* as
+                                 );
+    void ADMISSION_SYNTAX_set0_contentsOfAdmissions(
+        ADMISSION_SYNTAX* as, STACK_OF(ADMISSIONS) * a
+    );
+    const GENERAL_NAME* ADMISSIONS_get0_admissionAuthority(const ADMISSIONS* a);
+    void ADMISSIONS_set0_admissionAuthority(ADMISSIONS* a, GENERAL_NAME* aa);
+    const NAMING_AUTHORITY* ADMISSIONS_get0_namingAuthority(const ADMISSIONS* a);
+    void ADMISSIONS_set0_namingAuthority(ADMISSIONS* a, NAMING_AUTHORITY* na);
+    const PROFESSION_INFOS* ADMISSIONS_get0_professionInfos(const ADMISSIONS* a);
+    void ADMISSIONS_set0_professionInfos(ADMISSIONS* a, PROFESSION_INFOS* pi);
+    const ASN1_OCTET_STRING* PROFESSION_INFO_get0_addProfessionInfo(
+        const PROFESSION_INFO* pi
+    );
+    void PROFESSION_INFO_set0_addProfessionInfo(
+        PROFESSION_INFO* pi, ASN1_OCTET_STRING* aos
+    );
+    const NAMING_AUTHORITY* PROFESSION_INFO_get0_namingAuthority(
+        const PROFESSION_INFO* pi
+    );
+    void PROFESSION_INFO_set0_namingAuthority(
+        PROFESSION_INFO* pi, NAMING_AUTHORITY* na
+    );
+    const STACK_OF(ASN1_STRING) * PROFESSION_INFO_get0_professionItems(
+                                      const PROFESSION_INFO* pi
+                                  );
+    void PROFESSION_INFO_set0_professionItems(
+        PROFESSION_INFO* pi, STACK_OF(ASN1_STRING) * as
+    );
+    const STACK_OF(ASN1_OBJECT) * PROFESSION_INFO_get0_professionOIDs(
+                                      const PROFESSION_INFO* pi
+                                  );
+    void PROFESSION_INFO_set0_professionOIDs(
+        PROFESSION_INFO* pi, STACK_OF(ASN1_OBJECT) * po
+    );
+    const ASN1_PRINTABLESTRING* PROFESSION_INFO_get0_registrationNumber(
+        const PROFESSION_INFO* pi
+    );
+    void PROFESSION_INFO_set0_registrationNumber(
+        PROFESSION_INFO* pi, ASN1_PRINTABLESTRING* rn
+    );
+
+#ifdef __cplusplus
 }
-# endif
+#endif
 #endif
diff --git a/CAPI/cpp/grpc/include/openssl/x509v3err.h b/CAPI/cpp/grpc/include/openssl/x509v3err.h
index 1ae3a56..7f53f9a 100644
--- a/CAPI/cpp/grpc/include/openssl/x509v3err.h
+++ b/CAPI/cpp/grpc/include/openssl/x509v3err.h
@@ -9,85 +9,83 @@
  */
 
 #ifndef OPENSSL_X509V3ERR_H
-# define OPENSSL_X509V3ERR_H
-# pragma once
-
-# include <openssl/opensslconf.h>
-# include <openssl/symhacks.h>
-# include <openssl/cryptoerr_legacy.h>
-
+#define OPENSSL_X509V3ERR_H
+#pragma once
 
+#include <openssl/opensslconf.h>
+#include <openssl/symhacks.h>
+#include <openssl/cryptoerr_legacy.h>
 
 /*
  * X509V3 reason codes.
  */
-# define X509V3_R_BAD_IP_ADDRESS                          118
-# define X509V3_R_BAD_OBJECT                              119
-# define X509V3_R_BN_DEC2BN_ERROR                         100
-# define X509V3_R_BN_TO_ASN1_INTEGER_ERROR                101
-# define X509V3_R_DIRNAME_ERROR                           149
-# define X509V3_R_DISTPOINT_ALREADY_SET                   160
-# define X509V3_R_DUPLICATE_ZONE_ID                       133
-# define X509V3_R_EMPTY_KEY_USAGE                         169
-# define X509V3_R_ERROR_CONVERTING_ZONE                   131
-# define X509V3_R_ERROR_CREATING_EXTENSION                144
-# define X509V3_R_ERROR_IN_EXTENSION                      128
-# define X509V3_R_EXPECTED_A_SECTION_NAME                 137
-# define X509V3_R_EXTENSION_EXISTS                        145
-# define X509V3_R_EXTENSION_NAME_ERROR                    115
-# define X509V3_R_EXTENSION_NOT_FOUND                     102
-# define X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED         103
-# define X509V3_R_EXTENSION_VALUE_ERROR                   116
-# define X509V3_R_ILLEGAL_EMPTY_EXTENSION                 151
-# define X509V3_R_INCORRECT_POLICY_SYNTAX_TAG             152
-# define X509V3_R_INVALID_ASNUMBER                        162
-# define X509V3_R_INVALID_ASRANGE                         163
-# define X509V3_R_INVALID_BOOLEAN_STRING                  104
-# define X509V3_R_INVALID_CERTIFICATE                     158
-# define X509V3_R_INVALID_EMPTY_NAME                      108
-# define X509V3_R_INVALID_EXTENSION_STRING                105
-# define X509V3_R_INVALID_INHERITANCE                     165
-# define X509V3_R_INVALID_IPADDRESS                       166
-# define X509V3_R_INVALID_MULTIPLE_RDNS                   161
-# define X509V3_R_INVALID_NAME                            106
-# define X509V3_R_INVALID_NULL_ARGUMENT                   107
-# define X509V3_R_INVALID_NULL_VALUE                      109
-# define X509V3_R_INVALID_NUMBER                          140
-# define X509V3_R_INVALID_NUMBERS                         141
-# define X509V3_R_INVALID_OBJECT_IDENTIFIER               110
-# define X509V3_R_INVALID_OPTION                          138
-# define X509V3_R_INVALID_POLICY_IDENTIFIER               134
-# define X509V3_R_INVALID_PROXY_POLICY_SETTING            153
-# define X509V3_R_INVALID_PURPOSE                         146
-# define X509V3_R_INVALID_SAFI                            164
-# define X509V3_R_INVALID_SECTION                         135
-# define X509V3_R_INVALID_SYNTAX                          143
-# define X509V3_R_ISSUER_DECODE_ERROR                     126
-# define X509V3_R_MISSING_VALUE                           124
-# define X509V3_R_NEED_ORGANIZATION_AND_NUMBERS           142
-# define X509V3_R_NEGATIVE_PATHLEN                        168
-# define X509V3_R_NO_CONFIG_DATABASE                      136
-# define X509V3_R_NO_ISSUER_CERTIFICATE                   121
-# define X509V3_R_NO_ISSUER_DETAILS                       127
-# define X509V3_R_NO_POLICY_IDENTIFIER                    139
-# define X509V3_R_NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED   154
-# define X509V3_R_NO_PUBLIC_KEY                           114
-# define X509V3_R_NO_SUBJECT_DETAILS                      125
-# define X509V3_R_OPERATION_NOT_DEFINED                   148
-# define X509V3_R_OTHERNAME_ERROR                         147
-# define X509V3_R_POLICY_LANGUAGE_ALREADY_DEFINED         155
-# define X509V3_R_POLICY_PATH_LENGTH                      156
-# define X509V3_R_POLICY_PATH_LENGTH_ALREADY_DEFINED      157
-# define X509V3_R_POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY 159
-# define X509V3_R_SECTION_NOT_FOUND                       150
-# define X509V3_R_UNABLE_TO_GET_ISSUER_DETAILS            122
-# define X509V3_R_UNABLE_TO_GET_ISSUER_KEYID              123
-# define X509V3_R_UNKNOWN_BIT_STRING_ARGUMENT             111
-# define X509V3_R_UNKNOWN_EXTENSION                       129
-# define X509V3_R_UNKNOWN_EXTENSION_NAME                  130
-# define X509V3_R_UNKNOWN_OPTION                          120
-# define X509V3_R_UNSUPPORTED_OPTION                      117
-# define X509V3_R_UNSUPPORTED_TYPE                        167
-# define X509V3_R_USER_TOO_LONG                           132
+#define X509V3_R_BAD_IP_ADDRESS 118
+#define X509V3_R_BAD_OBJECT 119
+#define X509V3_R_BN_DEC2BN_ERROR 100
+#define X509V3_R_BN_TO_ASN1_INTEGER_ERROR 101
+#define X509V3_R_DIRNAME_ERROR 149
+#define X509V3_R_DISTPOINT_ALREADY_SET 160
+#define X509V3_R_DUPLICATE_ZONE_ID 133
+#define X509V3_R_EMPTY_KEY_USAGE 169
+#define X509V3_R_ERROR_CONVERTING_ZONE 131
+#define X509V3_R_ERROR_CREATING_EXTENSION 144
+#define X509V3_R_ERROR_IN_EXTENSION 128
+#define X509V3_R_EXPECTED_A_SECTION_NAME 137
+#define X509V3_R_EXTENSION_EXISTS 145
+#define X509V3_R_EXTENSION_NAME_ERROR 115
+#define X509V3_R_EXTENSION_NOT_FOUND 102
+#define X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED 103
+#define X509V3_R_EXTENSION_VALUE_ERROR 116
+#define X509V3_R_ILLEGAL_EMPTY_EXTENSION 151
+#define X509V3_R_INCORRECT_POLICY_SYNTAX_TAG 152
+#define X509V3_R_INVALID_ASNUMBER 162
+#define X509V3_R_INVALID_ASRANGE 163
+#define X509V3_R_INVALID_BOOLEAN_STRING 104
+#define X509V3_R_INVALID_CERTIFICATE 158
+#define X509V3_R_INVALID_EMPTY_NAME 108
+#define X509V3_R_INVALID_EXTENSION_STRING 105
+#define X509V3_R_INVALID_INHERITANCE 165
+#define X509V3_R_INVALID_IPADDRESS 166
+#define X509V3_R_INVALID_MULTIPLE_RDNS 161
+#define X509V3_R_INVALID_NAME 106
+#define X509V3_R_INVALID_NULL_ARGUMENT 107
+#define X509V3_R_INVALID_NULL_VALUE 109
+#define X509V3_R_INVALID_NUMBER 140
+#define X509V3_R_INVALID_NUMBERS 141
+#define X509V3_R_INVALID_OBJECT_IDENTIFIER 110
+#define X509V3_R_INVALID_OPTION 138
+#define X509V3_R_INVALID_POLICY_IDENTIFIER 134
+#define X509V3_R_INVALID_PROXY_POLICY_SETTING 153
+#define X509V3_R_INVALID_PURPOSE 146
+#define X509V3_R_INVALID_SAFI 164
+#define X509V3_R_INVALID_SECTION 135
+#define X509V3_R_INVALID_SYNTAX 143
+#define X509V3_R_ISSUER_DECODE_ERROR 126
+#define X509V3_R_MISSING_VALUE 124
+#define X509V3_R_NEED_ORGANIZATION_AND_NUMBERS 142
+#define X509V3_R_NEGATIVE_PATHLEN 168
+#define X509V3_R_NO_CONFIG_DATABASE 136
+#define X509V3_R_NO_ISSUER_CERTIFICATE 121
+#define X509V3_R_NO_ISSUER_DETAILS 127
+#define X509V3_R_NO_POLICY_IDENTIFIER 139
+#define X509V3_R_NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED 154
+#define X509V3_R_NO_PUBLIC_KEY 114
+#define X509V3_R_NO_SUBJECT_DETAILS 125
+#define X509V3_R_OPERATION_NOT_DEFINED 148
+#define X509V3_R_OTHERNAME_ERROR 147
+#define X509V3_R_POLICY_LANGUAGE_ALREADY_DEFINED 155
+#define X509V3_R_POLICY_PATH_LENGTH 156
+#define X509V3_R_POLICY_PATH_LENGTH_ALREADY_DEFINED 157
+#define X509V3_R_POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY 159
+#define X509V3_R_SECTION_NOT_FOUND 150
+#define X509V3_R_UNABLE_TO_GET_ISSUER_DETAILS 122
+#define X509V3_R_UNABLE_TO_GET_ISSUER_KEYID 123
+#define X509V3_R_UNKNOWN_BIT_STRING_ARGUMENT 111
+#define X509V3_R_UNKNOWN_EXTENSION 129
+#define X509V3_R_UNKNOWN_EXTENSION_NAME 130
+#define X509V3_R_UNKNOWN_OPTION 120
+#define X509V3_R_UNSUPPORTED_OPTION 117
+#define X509V3_R_UNSUPPORTED_TYPE 167
+#define X509V3_R_USER_TOO_LONG 132
 
 #endif
diff --git a/CAPI/cpp/grpc/include/re2/filtered_re2.h b/CAPI/cpp/grpc/include/re2/filtered_re2.h
index dd618c7..8befd14 100644
--- a/CAPI/cpp/grpc/include/re2/filtered_re2.h
+++ b/CAPI/cpp/grpc/include/re2/filtered_re2.h
@@ -27,87 +27,88 @@
 
 #include "re2/re2.h"
 
-namespace re2 {
-
-class PrefilterTree;
-
-class FilteredRE2 {
- public:
-  FilteredRE2();
-  explicit FilteredRE2(int min_atom_len);
-  ~FilteredRE2();
-
-  // Not copyable.
-  FilteredRE2(const FilteredRE2&) = delete;
-  FilteredRE2& operator=(const FilteredRE2&) = delete;
-  // Movable.
-  FilteredRE2(FilteredRE2&& other);
-  FilteredRE2& operator=(FilteredRE2&& other);
-
-  // Uses RE2 constructor to create a RE2 object (re). Returns
-  // re->error_code(). If error_code is other than NoError, then re is
-  // deleted and not added to re2_vec_.
-  RE2::ErrorCode Add(const StringPiece& pattern,
-                     const RE2::Options& options,
-                     int* id);
-
-  // Prepares the regexps added by Add for filtering.  Returns a set
-  // of strings that the caller should check for in candidate texts.
-  // The returned strings are lowercased and distinct. When doing
-  // string matching, it should be performed in a case-insensitive
-  // way or the search text should be lowercased first.  Call after
-  // all Add calls are done.
-  void Compile(std::vector<std::string>* strings_to_match);
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Can be called prior to Compile.
-  // Does not do any filtering: simply tries to Match the
-  // regexps in a loop.
-  int SlowFirstMatch(const StringPiece& text) const;
-
-  // Returns the index of the first matching regexp.
-  // Returns -1 on no match. Compile has to be called before
-  // calling this.
-  int FirstMatch(const StringPiece& text,
-                 const std::vector<int>& atoms) const;
-
-  // Returns the indices of all matching regexps, after first clearing
-  // matched_regexps.
-  bool AllMatches(const StringPiece& text,
-                  const std::vector<int>& atoms,
-                  std::vector<int>* matching_regexps) const;
-
-  // Returns the indices of all potentially matching regexps after first
-  // clearing potential_regexps.
-  // A regexp is potentially matching if it passes the filter.
-  // If a regexp passes the filter it may still not match.
-  // A regexp that does not pass the filter is guaranteed to not match.
-  void AllPotentials(const std::vector<int>& atoms,
-                     std::vector<int>* potential_regexps) const;
-
-  // The number of regexps added.
-  int NumRegexps() const { return static_cast<int>(re2_vec_.size()); }
-
-  // Get the individual RE2 objects.
-  const RE2& GetRE2(int regexpid) const { return *re2_vec_[regexpid]; }
-
- private:
-  // Print prefilter.
-  void PrintPrefilter(int regexpid);
-
-  // Useful for testing and debugging.
-  void RegexpsGivenStrings(const std::vector<int>& matched_atoms,
-                           std::vector<int>* passed_regexps);
-
-  // All the regexps in the FilteredRE2.
-  std::vector<RE2*> re2_vec_;
-
-  // Has the FilteredRE2 been compiled using Compile()
-  bool compiled_;
-
-  // An AND-OR tree of string atoms used for filtering regexps.
-  std::unique_ptr<PrefilterTree> prefilter_tree_;
-};
+namespace re2
+{
+
+    class PrefilterTree;
+
+    class FilteredRE2
+    {
+    public:
+        FilteredRE2();
+        explicit FilteredRE2(int min_atom_len);
+        ~FilteredRE2();
+
+        // Not copyable.
+        FilteredRE2(const FilteredRE2&) = delete;
+        FilteredRE2& operator=(const FilteredRE2&) = delete;
+        // Movable.
+        FilteredRE2(FilteredRE2&& other);
+        FilteredRE2& operator=(FilteredRE2&& other);
+
+        // Uses RE2 constructor to create a RE2 object (re). Returns
+        // re->error_code(). If error_code is other than NoError, then re is
+        // deleted and not added to re2_vec_.
+        RE2::ErrorCode Add(const StringPiece& pattern, const RE2::Options& options, int* id);
+
+        // Prepares the regexps added by Add for filtering.  Returns a set
+        // of strings that the caller should check for in candidate texts.
+        // The returned strings are lowercased and distinct. When doing
+        // string matching, it should be performed in a case-insensitive
+        // way or the search text should be lowercased first.  Call after
+        // all Add calls are done.
+        void Compile(std::vector<std::string>* strings_to_match);
+
+        // Returns the index of the first matching regexp.
+        // Returns -1 on no match. Can be called prior to Compile.
+        // Does not do any filtering: simply tries to Match the
+        // regexps in a loop.
+        int SlowFirstMatch(const StringPiece& text) const;
+
+        // Returns the index of the first matching regexp.
+        // Returns -1 on no match. Compile has to be called before
+        // calling this.
+        int FirstMatch(const StringPiece& text, const std::vector<int>& atoms) const;
+
+        // Returns the indices of all matching regexps, after first clearing
+        // matched_regexps.
+        bool AllMatches(const StringPiece& text, const std::vector<int>& atoms, std::vector<int>* matching_regexps) const;
+
+        // Returns the indices of all potentially matching regexps after first
+        // clearing potential_regexps.
+        // A regexp is potentially matching if it passes the filter.
+        // If a regexp passes the filter it may still not match.
+        // A regexp that does not pass the filter is guaranteed to not match.
+        void AllPotentials(const std::vector<int>& atoms, std::vector<int>* potential_regexps) const;
+
+        // The number of regexps added.
+        int NumRegexps() const
+        {
+            return static_cast<int>(re2_vec_.size());
+        }
+
+        // Get the individual RE2 objects.
+        const RE2& GetRE2(int regexpid) const
+        {
+            return *re2_vec_[regexpid];
+        }
+
+    private:
+        // Print prefilter.
+        void PrintPrefilter(int regexpid);
+
+        // Useful for testing and debugging.
+        void RegexpsGivenStrings(const std::vector<int>& matched_atoms, std::vector<int>* passed_regexps);
+
+        // All the regexps in the FilteredRE2.
+        std::vector<RE2*> re2_vec_;
+
+        // Has the FilteredRE2 been compiled using Compile()
+        bool compiled_;
+
+        // An AND-OR tree of string atoms used for filtering regexps.
+        std::unique_ptr<PrefilterTree> prefilter_tree_;
+    };
 
 }  // namespace re2
 
diff --git a/CAPI/cpp/grpc/include/re2/re2.h b/CAPI/cpp/grpc/include/re2/re2.h
index 7fd2245..c92d829 100644
--- a/CAPI/cpp/grpc/include/re2/re2.h
+++ b/CAPI/cpp/grpc/include/re2/re2.h
@@ -217,696 +217,876 @@
 
 #include "re2/stringpiece.h"
 
-namespace re2 {
-class Prog;
-class Regexp;
+namespace re2
+{
+    class Prog;
+    class Regexp;
 }  // namespace re2
 
-namespace re2 {
-
-// Interface for regular expression matching.  Also corresponds to a
-// pre-compiled regular expression.  An "RE2" object is safe for
-// concurrent use by multiple threads.
-class RE2 {
- public:
-  // We convert user-passed pointers into special Arg objects
-  class Arg;
-  class Options;
-
-  // Defined in set.h.
-  class Set;
-
-  enum ErrorCode {
-    NoError = 0,
-
-    // Unexpected error
-    ErrorInternal,
-
-    // Parse errors
-    ErrorBadEscape,          // bad escape sequence
-    ErrorBadCharClass,       // bad character class
-    ErrorBadCharRange,       // bad character class range
-    ErrorMissingBracket,     // missing closing ]
-    ErrorMissingParen,       // missing closing )
-    ErrorUnexpectedParen,    // unexpected closing )
-    ErrorTrailingBackslash,  // trailing \ at end of regexp
-    ErrorRepeatArgument,     // repeat argument missing, e.g. "*"
-    ErrorRepeatSize,         // bad repetition argument
-    ErrorRepeatOp,           // bad repetition operator
-    ErrorBadPerlOp,          // bad perl operator
-    ErrorBadUTF8,            // invalid UTF-8 in regexp
-    ErrorBadNamedCapture,    // bad named capture group
-    ErrorPatternTooLarge     // pattern too large (compile failed)
-  };
-
-  // Predefined common options.
-  // If you need more complicated things, instantiate
-  // an Option class, possibly passing one of these to
-  // the Option constructor, change the settings, and pass that
-  // Option class to the RE2 constructor.
-  enum CannedOptions {
-    DefaultOptions = 0,
-    Latin1, // treat input as Latin-1 (default UTF-8)
-    POSIX, // POSIX syntax, leftmost-longest match
-    Quiet // do not log about regexp parse errors
-  };
-
-  // Need to have the const char* and const std::string& forms for implicit
-  // conversions when passing string literals to FullMatch and PartialMatch.
-  // Otherwise the StringPiece form would be sufficient.
+namespace re2
+{
+
+    // Interface for regular expression matching.  Also corresponds to a
+    // pre-compiled regular expression.  An "RE2" object is safe for
+    // concurrent use by multiple threads.
+    class RE2
+    {
+    public:
+        // We convert user-passed pointers into special Arg objects
+        class Arg;
+        class Options;
+
+        // Defined in set.h.
+        class Set;
+
+        enum ErrorCode
+        {
+            NoError = 0,
+
+            // Unexpected error
+            ErrorInternal,
+
+            // Parse errors
+            ErrorBadEscape,          // bad escape sequence
+            ErrorBadCharClass,       // bad character class
+            ErrorBadCharRange,       // bad character class range
+            ErrorMissingBracket,     // missing closing ]
+            ErrorMissingParen,       // missing closing )
+            ErrorUnexpectedParen,    // unexpected closing )
+            ErrorTrailingBackslash,  // trailing \ at end of regexp
+            ErrorRepeatArgument,     // repeat argument missing, e.g. "*"
+            ErrorRepeatSize,         // bad repetition argument
+            ErrorRepeatOp,           // bad repetition operator
+            ErrorBadPerlOp,          // bad perl operator
+            ErrorBadUTF8,            // invalid UTF-8 in regexp
+            ErrorBadNamedCapture,    // bad named capture group
+            ErrorPatternTooLarge     // pattern too large (compile failed)
+        };
+
+        // Predefined common options.
+        // If you need more complicated things, instantiate
+        // an Option class, possibly passing one of these to
+        // the Option constructor, change the settings, and pass that
+        // Option class to the RE2 constructor.
+        enum CannedOptions
+        {
+            DefaultOptions = 0,
+            Latin1,  // treat input as Latin-1 (default UTF-8)
+            POSIX,   // POSIX syntax, leftmost-longest match
+            Quiet    // do not log about regexp parse errors
+        };
+
+        // Need to have the const char* and const std::string& forms for implicit
+        // conversions when passing string literals to FullMatch and PartialMatch.
+        // Otherwise the StringPiece form would be sufficient.
 #ifndef SWIG
-  RE2(const char* pattern);
-  RE2(const std::string& pattern);
+        RE2(const char* pattern);
+        RE2(const std::string& pattern);
 #endif
-  RE2(const StringPiece& pattern);
-  RE2(const StringPiece& pattern, const Options& options);
-  ~RE2();
-
-  // Returns whether RE2 was created properly.
-  bool ok() const { return error_code() == NoError; }
-
-  // The string specification for this RE2.  E.g.
-  //   RE2 re("ab*c?d+");
-  //   re.pattern();    // "ab*c?d+"
-  const std::string& pattern() const { return pattern_; }
-
-  // If RE2 could not be created properly, returns an error string.
-  // Else returns the empty string.
-  const std::string& error() const { return *error_; }
-
-  // If RE2 could not be created properly, returns an error code.
-  // Else returns RE2::NoError (== 0).
-  ErrorCode error_code() const { return error_code_; }
-
-  // If RE2 could not be created properly, returns the offending
-  // portion of the regexp.
-  const std::string& error_arg() const { return error_arg_; }
-
-  // Returns the program size, a very approximate measure of a regexp's "cost".
-  // Larger numbers are more expensive than smaller numbers.
-  int ProgramSize() const;
-  int ReverseProgramSize() const;
-
-  // If histogram is not null, outputs the program fanout
-  // as a histogram bucketed by powers of 2.
-  // Returns the number of the largest non-empty bucket.
-  int ProgramFanout(std::vector<int>* histogram) const;
-  int ReverseProgramFanout(std::vector<int>* histogram) const;
-
-  // Returns the underlying Regexp; not for general use.
-  // Returns entire_regexp_ so that callers don't need
-  // to know about prefix_ and prefix_foldcase_.
-  re2::Regexp* Regexp() const { return entire_regexp_; }
-
-  /***** The array-based matching interface ******/
-
-  // The functions here have names ending in 'N' and are used to implement
-  // the functions whose names are the prefix before the 'N'. It is sometimes
-  // useful to invoke them directly, but the syntax is awkward, so the 'N'-less
-  // versions should be preferred.
-  static bool FullMatchN(const StringPiece& text, const RE2& re,
-                         const Arg* const args[], int n);
-  static bool PartialMatchN(const StringPiece& text, const RE2& re,
-                            const Arg* const args[], int n);
-  static bool ConsumeN(StringPiece* input, const RE2& re,
-                       const Arg* const args[], int n);
-  static bool FindAndConsumeN(StringPiece* input, const RE2& re,
-                              const Arg* const args[], int n);
+        RE2(const StringPiece& pattern);
+        RE2(const StringPiece& pattern, const Options& options);
+        ~RE2();
+
+        // Returns whether RE2 was created properly.
+        bool ok() const
+        {
+            return error_code() == NoError;
+        }
+
+        // The string specification for this RE2.  E.g.
+        //   RE2 re("ab*c?d+");
+        //   re.pattern();    // "ab*c?d+"
+        const std::string& pattern() const
+        {
+            return pattern_;
+        }
+
+        // If RE2 could not be created properly, returns an error string.
+        // Else returns the empty string.
+        const std::string& error() const
+        {
+            return *error_;
+        }
+
+        // If RE2 could not be created properly, returns an error code.
+        // Else returns RE2::NoError (== 0).
+        ErrorCode error_code() const
+        {
+            return error_code_;
+        }
+
+        // If RE2 could not be created properly, returns the offending
+        // portion of the regexp.
+        const std::string& error_arg() const
+        {
+            return error_arg_;
+        }
+
+        // Returns the program size, a very approximate measure of a regexp's "cost".
+        // Larger numbers are more expensive than smaller numbers.
+        int ProgramSize() const;
+        int ReverseProgramSize() const;
+
+        // If histogram is not null, outputs the program fanout
+        // as a histogram bucketed by powers of 2.
+        // Returns the number of the largest non-empty bucket.
+        int ProgramFanout(std::vector<int>* histogram) const;
+        int ReverseProgramFanout(std::vector<int>* histogram) const;
+
+        // Returns the underlying Regexp; not for general use.
+        // Returns entire_regexp_ so that callers don't need
+        // to know about prefix_ and prefix_foldcase_.
+        re2::Regexp* Regexp() const
+        {
+            return entire_regexp_;
+        }
+
+        /***** The array-based matching interface ******/
+
+        // The functions here have names ending in 'N' and are used to implement
+        // the functions whose names are the prefix before the 'N'. It is sometimes
+        // useful to invoke them directly, but the syntax is awkward, so the 'N'-less
+        // versions should be preferred.
+        static bool FullMatchN(const StringPiece& text, const RE2& re, const Arg* const args[], int n);
+        static bool PartialMatchN(const StringPiece& text, const RE2& re, const Arg* const args[], int n);
+        static bool ConsumeN(StringPiece* input, const RE2& re, const Arg* const args[], int n);
+        static bool FindAndConsumeN(StringPiece* input, const RE2& re, const Arg* const args[], int n);
 
 #ifndef SWIG
- private:
-  template <typename F, typename SP>
-  static inline bool Apply(F f, SP sp, const RE2& re) {
-    return f(sp, re, NULL, 0);
-  }
-
-  template <typename F, typename SP, typename... A>
-  static inline bool Apply(F f, SP sp, const RE2& re, const A&... a) {
-    const Arg* const args[] = {&a...};
-    const int n = sizeof...(a);
-    return f(sp, re, args, n);
-  }
-
- public:
-  // In order to allow FullMatch() et al. to be called with a varying number
-  // of arguments of varying types, we use two layers of variadic templates.
-  // The first layer constructs the temporary Arg objects. The second layer
-  // (above) constructs the array of pointers to the temporary Arg objects.
-
-  /***** The useful part: the matching interface *****/
-
-  // Matches "text" against "re".  If pointer arguments are
-  // supplied, copies matched sub-patterns into them.
-  //
-  // You can pass in a "const char*" or a "std::string" for "text".
-  // You can pass in a "const char*" or a "std::string" or a "RE2" for "re".
-  //
-  // The provided pointer arguments can be pointers to any scalar numeric
-  // type, or one of:
-  //    std::string     (matched piece is copied to string)
-  //    StringPiece     (StringPiece is mutated to point to matched piece)
-  //    T               (where "bool T::ParseFrom(const char*, size_t)" exists)
-  //    (void*)NULL     (the corresponding matched sub-pattern is not copied)
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "text" matches "re" fully - from the beginning to the end of "text".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  //
-  // CAVEAT: An optional sub-pattern that does not exist in the
-  // matched string is assigned the empty string.  Therefore, the
-  // following will return false (because the empty string is not a
-  // valid number):
-  //    int number;
-  //    RE2::FullMatch("abc", "[a-z]+(\\d+)?", &number);
-  template <typename... A>
-  static bool FullMatch(const StringPiece& text, const RE2& re, A&&... a) {
-    return Apply(FullMatchN, text, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like FullMatch(), except that "re" is allowed to match a substring
-  // of "text".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "text" matches "re" partially - for some substring of "text".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool PartialMatch(const StringPiece& text, const RE2& re, A&&... a) {
-    return Apply(PartialMatchN, text, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like FullMatch() and PartialMatch(), except that "re" has to match
-  // a prefix of the text, and "input" is advanced past the matched
-  // text.  Note: "input" is modified iff this routine returns true
-  // and "re" matched a non-empty substring of "input".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "input" matches "re" partially - for some prefix of "input".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool Consume(StringPiece* input, const RE2& re, A&&... a) {
-    return Apply(ConsumeN, input, re, Arg(std::forward<A>(a))...);
-  }
-
-  // Like Consume(), but does not anchor the match at the beginning of
-  // the text.  That is, "re" need not start its match at the beginning
-  // of "input".  For example, "FindAndConsume(s, "(\\w+)", &word)" finds
-  // the next word in "s" and stores it in "word".
-  //
-  // Returns true iff all of the following conditions are satisfied:
-  //   a. "input" matches "re" partially - for some substring of "input".
-  //   b. The number of matched sub-patterns is >= number of supplied pointers.
-  //   c. The "i"th argument has a suitable type for holding the
-  //      string captured as the "i"th sub-pattern.  If you pass in
-  //      NULL for the "i"th argument, or pass fewer arguments than
-  //      number of sub-patterns, the "i"th captured sub-pattern is
-  //      ignored.
-  template <typename... A>
-  static bool FindAndConsume(StringPiece* input, const RE2& re, A&&... a) {
-    return Apply(FindAndConsumeN, input, re, Arg(std::forward<A>(a))...);
-  }
-#endif
 
-  // Replace the first match of "re" in "str" with "rewrite".
-  // Within "rewrite", backslash-escaped digits (\1 to \9) can be
-  // used to insert text matching corresponding parenthesized group
-  // from the pattern.  \0 in "rewrite" refers to the entire matching
-  // text.  E.g.,
-  //
-  //   std::string s = "yabba dabba doo";
-  //   CHECK(RE2::Replace(&s, "b+", "d"));
-  //
-  // will leave "s" containing "yada dabba doo"
-  //
-  // Returns true if the pattern matches and a replacement occurs,
-  // false otherwise.
-  static bool Replace(std::string* str,
-                      const RE2& re,
-                      const StringPiece& rewrite);
-
-  // Like Replace(), except replaces successive non-overlapping occurrences
-  // of the pattern in the string with the rewrite. E.g.
-  //
-  //   std::string s = "yabba dabba doo";
-  //   CHECK(RE2::GlobalReplace(&s, "b+", "d"));
-  //
-  // will leave "s" containing "yada dada doo"
-  // Replacements are not subject to re-matching.
-  //
-  // Because GlobalReplace only replaces non-overlapping matches,
-  // replacing "ana" within "banana" makes only one replacement, not two.
-  //
-  // Returns the number of replacements made.
-  static int GlobalReplace(std::string* str,
-                           const RE2& re,
-                           const StringPiece& rewrite);
-
-  // Like Replace, except that if the pattern matches, "rewrite"
-  // is copied into "out" with substitutions.  The non-matching
-  // portions of "text" are ignored.
-  //
-  // Returns true iff a match occurred and the extraction happened
-  // successfully;  if no match occurs, the string is left unaffected.
-  //
-  // REQUIRES: "text" must not alias any part of "*out".
-  static bool Extract(const StringPiece& text,
-                      const RE2& re,
-                      const StringPiece& rewrite,
-                      std::string* out);
-
-  // Escapes all potentially meaningful regexp characters in
-  // 'unquoted'.  The returned string, used as a regular expression,
-  // will match exactly the original string.  For example,
-  //           1.5-2.0?
-  // may become:
-  //           1\.5\-2\.0\?
-  static std::string QuoteMeta(const StringPiece& unquoted);
-
-  // Computes range for any strings matching regexp. The min and max can in
-  // some cases be arbitrarily precise, so the caller gets to specify the
-  // maximum desired length of string returned.
-  //
-  // Assuming PossibleMatchRange(&min, &max, N) returns successfully, any
-  // string s that is an anchored match for this regexp satisfies
-  //   min <= s && s <= max.
-  //
-  // Note that PossibleMatchRange() will only consider the first copy of an
-  // infinitely repeated element (i.e., any regexp element followed by a '*' or
-  // '+' operator). Regexps with "{N}" constructions are not affected, as those
-  // do not compile down to infinite repetitions.
-  //
-  // Returns true on success, false on error.
-  bool PossibleMatchRange(std::string* min, std::string* max,
-                          int maxlen) const;
-
-  // Generic matching interface
-
-  // Type of match.
-  enum Anchor {
-    UNANCHORED,         // No anchoring
-    ANCHOR_START,       // Anchor at start only
-    ANCHOR_BOTH         // Anchor at start and end
-  };
-
-  // Return the number of capturing subpatterns, or -1 if the
-  // regexp wasn't valid on construction.  The overall match ($0)
-  // does not count: if the regexp is "(a)(b)", returns 2.
-  int NumberOfCapturingGroups() const { return num_captures_; }
-
-  // Return a map from names to capturing indices.
-  // The map records the index of the leftmost group
-  // with the given name.
-  // Only valid until the re is deleted.
-  const std::map<std::string, int>& NamedCapturingGroups() const;
-
-  // Return a map from capturing indices to names.
-  // The map has no entries for unnamed groups.
-  // Only valid until the re is deleted.
-  const std::map<int, std::string>& CapturingGroupNames() const;
-
-  // General matching routine.
-  // Match against text starting at offset startpos
-  // and stopping the search at offset endpos.
-  // Returns true if match found, false if not.
-  // On a successful match, fills in submatch[] (up to nsubmatch entries)
-  // with information about submatches.
-  // I.e. matching RE2("(foo)|(bar)baz") on "barbazbla" will return true, with
-  // submatch[0] = "barbaz", submatch[1].data() = NULL, submatch[2] = "bar",
-  // submatch[3].data() = NULL, ..., up to submatch[nsubmatch-1].data() = NULL.
-  // Caveat: submatch[] may be clobbered even on match failure.
-  //
-  // Don't ask for more match information than you will use:
-  // runs much faster with nsubmatch == 1 than nsubmatch > 1, and
-  // runs even faster if nsubmatch == 0.
-  // Doesn't make sense to use nsubmatch > 1 + NumberOfCapturingGroups(),
-  // but will be handled correctly.
-  //
-  // Passing text == StringPiece(NULL, 0) will be handled like any other
-  // empty string, but note that on return, it will not be possible to tell
-  // whether submatch i matched the empty string or did not match:
-  // either way, submatch[i].data() == NULL.
-  bool Match(const StringPiece& text,
-             size_t startpos,
-             size_t endpos,
-             Anchor re_anchor,
-             StringPiece* submatch,
-             int nsubmatch) const;
-
-  // Check that the given rewrite string is suitable for use with this
-  // regular expression.  It checks that:
-  //   * The regular expression has enough parenthesized subexpressions
-  //     to satisfy all of the \N tokens in rewrite
-  //   * The rewrite string doesn't have any syntax errors.  E.g.,
-  //     '\' followed by anything other than a digit or '\'.
-  // A true return value guarantees that Replace() and Extract() won't
-  // fail because of a bad rewrite string.
-  bool CheckRewriteString(const StringPiece& rewrite,
-                          std::string* error) const;
-
-  // Returns the maximum submatch needed for the rewrite to be done by
-  // Replace(). E.g. if rewrite == "foo \\2,\\1", returns 2.
-  static int MaxSubmatch(const StringPiece& rewrite);
-
-  // Append the "rewrite" string, with backslash subsitutions from "vec",
-  // to string "out".
-  // Returns true on success.  This method can fail because of a malformed
-  // rewrite string.  CheckRewriteString guarantees that the rewrite will
-  // be sucessful.
-  bool Rewrite(std::string* out,
-               const StringPiece& rewrite,
-               const StringPiece* vec,
-               int veclen) const;
-
-  // Constructor options
-  class Options {
-   public:
-    // The options are (defaults in parentheses):
-    //
-    //   utf8             (true)  text and pattern are UTF-8; otherwise Latin-1
-    //   posix_syntax     (false) restrict regexps to POSIX egrep syntax
-    //   longest_match    (false) search for longest match, not first match
-    //   log_errors       (true)  log syntax and execution errors to ERROR
-    //   max_mem          (see below)  approx. max memory footprint of RE2
-    //   literal          (false) interpret string as literal, not regexp
-    //   never_nl         (false) never match \n, even if it is in regexp
-    //   dot_nl           (false) dot matches everything including new line
-    //   never_capture    (false) parse all parens as non-capturing
-    //   case_sensitive   (true)  match is case-sensitive (regexp can override
-    //                              with (?i) unless in posix_syntax mode)
-    //
-    // The following options are only consulted when posix_syntax == true.
-    // When posix_syntax == false, these features are always enabled and
-    // cannot be turned off; to perform multi-line matching in that case,
-    // begin the regexp with (?m).
-    //   perl_classes     (false) allow Perl's \d \s \w \D \S \W
-    //   word_boundary    (false) allow Perl's \b \B (word boundary and not)
-    //   one_line         (false) ^ and $ only match beginning and end of text
-    //
-    // The max_mem option controls how much memory can be used
-    // to hold the compiled form of the regexp (the Prog) and
-    // its cached DFA graphs.  Code Search placed limits on the number
-    // of Prog instructions and DFA states: 10,000 for both.
-    // In RE2, those limits would translate to about 240 KB per Prog
-    // and perhaps 2.5 MB per DFA (DFA state sizes vary by regexp; RE2 does a
-    // better job of keeping them small than Code Search did).
-    // Each RE2 has two Progs (one forward, one reverse), and each Prog
-    // can have two DFAs (one first match, one longest match).
-    // That makes 4 DFAs:
-    //
-    //   forward, first-match    - used for UNANCHORED or ANCHOR_START searches
-    //                               if opt.longest_match() == false
-    //   forward, longest-match  - used for all ANCHOR_BOTH searches,
-    //                               and the other two kinds if
-    //                               opt.longest_match() == true
-    //   reverse, first-match    - never used
-    //   reverse, longest-match  - used as second phase for unanchored searches
-    //
-    // The RE2 memory budget is statically divided between the two
-    // Progs and then the DFAs: two thirds to the forward Prog
-    // and one third to the reverse Prog.  The forward Prog gives half
-    // of what it has left over to each of its DFAs.  The reverse Prog
-    // gives it all to its longest-match DFA.
-    //
-    // Once a DFA fills its budget, it flushes its cache and starts over.
-    // If this happens too often, RE2 falls back on the NFA implementation.
-
-    // For now, make the default budget something close to Code Search.
-    static const int kDefaultMaxMem = 8<<20;
+    private:
+        template<typename F, typename SP>
+        static inline bool Apply(F f, SP sp, const RE2& re)
+        {
+            return f(sp, re, NULL, 0);
+        }
+
+        template<typename F, typename SP, typename... A>
+        static inline bool Apply(F f, SP sp, const RE2& re, const A&... a)
+        {
+            const Arg* const args[] = {&a...};
+            const int n = sizeof...(a);
+            return f(sp, re, args, n);
+        }
+
+    public:
+        // In order to allow FullMatch() et al. to be called with a varying number
+        // of arguments of varying types, we use two layers of variadic templates.
+        // The first layer constructs the temporary Arg objects. The second layer
+        // (above) constructs the array of pointers to the temporary Arg objects.
+
+        /***** The useful part: the matching interface *****/
+
+        // Matches "text" against "re".  If pointer arguments are
+        // supplied, copies matched sub-patterns into them.
+        //
+        // You can pass in a "const char*" or a "std::string" for "text".
+        // You can pass in a "const char*" or a "std::string" or a "RE2" for "re".
+        //
+        // The provided pointer arguments can be pointers to any scalar numeric
+        // type, or one of:
+        //    std::string     (matched piece is copied to string)
+        //    StringPiece     (StringPiece is mutated to point to matched piece)
+        //    T               (where "bool T::ParseFrom(const char*, size_t)" exists)
+        //    (void*)NULL     (the corresponding matched sub-pattern is not copied)
+        //
+        // Returns true iff all of the following conditions are satisfied:
+        //   a. "text" matches "re" fully - from the beginning to the end of "text".
+        //   b. The number of matched sub-patterns is >= number of supplied pointers.
+        //   c. The "i"th argument has a suitable type for holding the
+        //      string captured as the "i"th sub-pattern.  If you pass in
+        //      NULL for the "i"th argument, or pass fewer arguments than
+        //      number of sub-patterns, the "i"th captured sub-pattern is
+        //      ignored.
+        //
+        // CAVEAT: An optional sub-pattern that does not exist in the
+        // matched string is assigned the empty string.  Therefore, the
+        // following will return false (because the empty string is not a
+        // valid number):
+        //    int number;
+        //    RE2::FullMatch("abc", "[a-z]+(\\d+)?", &number);
+        template<typename... A>
+        static bool FullMatch(const StringPiece& text, const RE2& re, A&&... a)
+        {
+            return Apply(FullMatchN, text, re, Arg(std::forward<A>(a))...);
+        }
+
+        // Like FullMatch(), except that "re" is allowed to match a substring
+        // of "text".
+        //
+        // Returns true iff all of the following conditions are satisfied:
+        //   a. "text" matches "re" partially - for some substring of "text".
+        //   b. The number of matched sub-patterns is >= number of supplied pointers.
+        //   c. The "i"th argument has a suitable type for holding the
+        //      string captured as the "i"th sub-pattern.  If you pass in
+        //      NULL for the "i"th argument, or pass fewer arguments than
+        //      number of sub-patterns, the "i"th captured sub-pattern is
+        //      ignored.
+        template<typename... A>
+        static bool PartialMatch(const StringPiece& text, const RE2& re, A&&... a)
+        {
+            return Apply(PartialMatchN, text, re, Arg(std::forward<A>(a))...);
+        }
+
+        // Like FullMatch() and PartialMatch(), except that "re" has to match
+        // a prefix of the text, and "input" is advanced past the matched
+        // text.  Note: "input" is modified iff this routine returns true
+        // and "re" matched a non-empty substring of "input".
+        //
+        // Returns true iff all of the following conditions are satisfied:
+        //   a. "input" matches "re" partially - for some prefix of "input".
+        //   b. The number of matched sub-patterns is >= number of supplied pointers.
+        //   c. The "i"th argument has a suitable type for holding the
+        //      string captured as the "i"th sub-pattern.  If you pass in
+        //      NULL for the "i"th argument, or pass fewer arguments than
+        //      number of sub-patterns, the "i"th captured sub-pattern is
+        //      ignored.
+        template<typename... A>
+        static bool Consume(StringPiece* input, const RE2& re, A&&... a)
+        {
+            return Apply(ConsumeN, input, re, Arg(std::forward<A>(a))...);
+        }
+
+        // Like Consume(), but does not anchor the match at the beginning of
+        // the text.  That is, "re" need not start its match at the beginning
+        // of "input".  For example, "FindAndConsume(s, "(\\w+)", &word)" finds
+        // the next word in "s" and stores it in "word".
+        //
+        // Returns true iff all of the following conditions are satisfied:
+        //   a. "input" matches "re" partially - for some substring of "input".
+        //   b. The number of matched sub-patterns is >= number of supplied pointers.
+        //   c. The "i"th argument has a suitable type for holding the
+        //      string captured as the "i"th sub-pattern.  If you pass in
+        //      NULL for the "i"th argument, or pass fewer arguments than
+        //      number of sub-patterns, the "i"th captured sub-pattern is
+        //      ignored.
+        template<typename... A>
+        static bool FindAndConsume(StringPiece* input, const RE2& re, A&&... a)
+        {
+            return Apply(FindAndConsumeN, input, re, Arg(std::forward<A>(a))...);
+        }
+#endif
 
-    enum Encoding {
-      EncodingUTF8 = 1,
-      EncodingLatin1
+        // Replace the first match of "re" in "str" with "rewrite".
+        // Within "rewrite", backslash-escaped digits (\1 to \9) can be
+        // used to insert text matching corresponding parenthesized group
+        // from the pattern.  \0 in "rewrite" refers to the entire matching
+        // text.  E.g.,
+        //
+        //   std::string s = "yabba dabba doo";
+        //   CHECK(RE2::Replace(&s, "b+", "d"));
+        //
+        // will leave "s" containing "yada dabba doo"
+        //
+        // Returns true if the pattern matches and a replacement occurs,
+        // false otherwise.
+        static bool Replace(std::string* str, const RE2& re, const StringPiece& rewrite);
+
+        // Like Replace(), except replaces successive non-overlapping occurrences
+        // of the pattern in the string with the rewrite. E.g.
+        //
+        //   std::string s = "yabba dabba doo";
+        //   CHECK(RE2::GlobalReplace(&s, "b+", "d"));
+        //
+        // will leave "s" containing "yada dada doo"
+        // Replacements are not subject to re-matching.
+        //
+        // Because GlobalReplace only replaces non-overlapping matches,
+        // replacing "ana" within "banana" makes only one replacement, not two.
+        //
+        // Returns the number of replacements made.
+        static int GlobalReplace(std::string* str, const RE2& re, const StringPiece& rewrite);
+
+        // Like Replace, except that if the pattern matches, "rewrite"
+        // is copied into "out" with substitutions.  The non-matching
+        // portions of "text" are ignored.
+        //
+        // Returns true iff a match occurred and the extraction happened
+        // successfully;  if no match occurs, the string is left unaffected.
+        //
+        // REQUIRES: "text" must not alias any part of "*out".
+        static bool Extract(const StringPiece& text, const RE2& re, const StringPiece& rewrite, std::string* out);
+
+        // Escapes all potentially meaningful regexp characters in
+        // 'unquoted'.  The returned string, used as a regular expression,
+        // will match exactly the original string.  For example,
+        //           1.5-2.0?
+        // may become:
+        //           1\.5\-2\.0\?
+        static std::string QuoteMeta(const StringPiece& unquoted);
+
+        // Computes range for any strings matching regexp. The min and max can in
+        // some cases be arbitrarily precise, so the caller gets to specify the
+        // maximum desired length of string returned.
+        //
+        // Assuming PossibleMatchRange(&min, &max, N) returns successfully, any
+        // string s that is an anchored match for this regexp satisfies
+        //   min <= s && s <= max.
+        //
+        // Note that PossibleMatchRange() will only consider the first copy of an
+        // infinitely repeated element (i.e., any regexp element followed by a '*' or
+        // '+' operator). Regexps with "{N}" constructions are not affected, as those
+        // do not compile down to infinite repetitions.
+        //
+        // Returns true on success, false on error.
+        bool PossibleMatchRange(std::string* min, std::string* max, int maxlen) const;
+
+        // Generic matching interface
+
+        // Type of match.
+        enum Anchor
+        {
+            UNANCHORED,    // No anchoring
+            ANCHOR_START,  // Anchor at start only
+            ANCHOR_BOTH    // Anchor at start and end
+        };
+
+        // Return the number of capturing subpatterns, or -1 if the
+        // regexp wasn't valid on construction.  The overall match ($0)
+        // does not count: if the regexp is "(a)(b)", returns 2.
+        int NumberOfCapturingGroups() const
+        {
+            return num_captures_;
+        }
+
+        // Return a map from names to capturing indices.
+        // The map records the index of the leftmost group
+        // with the given name.
+        // Only valid until the re is deleted.
+        const std::map<std::string, int>& NamedCapturingGroups() const;
+
+        // Return a map from capturing indices to names.
+        // The map has no entries for unnamed groups.
+        // Only valid until the re is deleted.
+        const std::map<int, std::string>& CapturingGroupNames() const;
+
+        // General matching routine.
+        // Match against text starting at offset startpos
+        // and stopping the search at offset endpos.
+        // Returns true if match found, false if not.
+        // On a successful match, fills in submatch[] (up to nsubmatch entries)
+        // with information about submatches.
+        // I.e. matching RE2("(foo)|(bar)baz") on "barbazbla" will return true, with
+        // submatch[0] = "barbaz", submatch[1].data() = NULL, submatch[2] = "bar",
+        // submatch[3].data() = NULL, ..., up to submatch[nsubmatch-1].data() = NULL.
+        // Caveat: submatch[] may be clobbered even on match failure.
+        //
+        // Don't ask for more match information than you will use:
+        // runs much faster with nsubmatch == 1 than nsubmatch > 1, and
+        // runs even faster if nsubmatch == 0.
+        // Doesn't make sense to use nsubmatch > 1 + NumberOfCapturingGroups(),
+        // but will be handled correctly.
+        //
+        // Passing text == StringPiece(NULL, 0) will be handled like any other
+        // empty string, but note that on return, it will not be possible to tell
+        // whether submatch i matched the empty string or did not match:
+        // either way, submatch[i].data() == NULL.
+        bool Match(const StringPiece& text, size_t startpos, size_t endpos, Anchor re_anchor, StringPiece* submatch, int nsubmatch) const;
+
+        // Check that the given rewrite string is suitable for use with this
+        // regular expression.  It checks that:
+        //   * The regular expression has enough parenthesized subexpressions
+        //     to satisfy all of the \N tokens in rewrite
+        //   * The rewrite string doesn't have any syntax errors.  E.g.,
+        //     '\' followed by anything other than a digit or '\'.
+        // A true return value guarantees that Replace() and Extract() won't
+        // fail because of a bad rewrite string.
+        bool CheckRewriteString(const StringPiece& rewrite, std::string* error) const;
+
+        // Returns the maximum submatch needed for the rewrite to be done by
+        // Replace(). E.g. if rewrite == "foo \\2,\\1", returns 2.
+        static int MaxSubmatch(const StringPiece& rewrite);
+
+        // Append the "rewrite" string, with backslash subsitutions from "vec",
+        // to string "out".
+        // Returns true on success.  This method can fail because of a malformed
+        // rewrite string.  CheckRewriteString guarantees that the rewrite will
+        // be sucessful.
+        bool Rewrite(std::string* out, const StringPiece& rewrite, const StringPiece* vec, int veclen) const;
+
+        // Constructor options
+        class Options
+        {
+        public:
+            // The options are (defaults in parentheses):
+            //
+            //   utf8             (true)  text and pattern are UTF-8; otherwise Latin-1
+            //   posix_syntax     (false) restrict regexps to POSIX egrep syntax
+            //   longest_match    (false) search for longest match, not first match
+            //   log_errors       (true)  log syntax and execution errors to ERROR
+            //   max_mem          (see below)  approx. max memory footprint of RE2
+            //   literal          (false) interpret string as literal, not regexp
+            //   never_nl         (false) never match \n, even if it is in regexp
+            //   dot_nl           (false) dot matches everything including new line
+            //   never_capture    (false) parse all parens as non-capturing
+            //   case_sensitive   (true)  match is case-sensitive (regexp can override
+            //                              with (?i) unless in posix_syntax mode)
+            //
+            // The following options are only consulted when posix_syntax == true.
+            // When posix_syntax == false, these features are always enabled and
+            // cannot be turned off; to perform multi-line matching in that case,
+            // begin the regexp with (?m).
+            //   perl_classes     (false) allow Perl's \d \s \w \D \S \W
+            //   word_boundary    (false) allow Perl's \b \B (word boundary and not)
+            //   one_line         (false) ^ and $ only match beginning and end of text
+            //
+            // The max_mem option controls how much memory can be used
+            // to hold the compiled form of the regexp (the Prog) and
+            // its cached DFA graphs.  Code Search placed limits on the number
+            // of Prog instructions and DFA states: 10,000 for both.
+            // In RE2, those limits would translate to about 240 KB per Prog
+            // and perhaps 2.5 MB per DFA (DFA state sizes vary by regexp; RE2 does a
+            // better job of keeping them small than Code Search did).
+            // Each RE2 has two Progs (one forward, one reverse), and each Prog
+            // can have two DFAs (one first match, one longest match).
+            // That makes 4 DFAs:
+            //
+            //   forward, first-match    - used for UNANCHORED or ANCHOR_START searches
+            //                               if opt.longest_match() == false
+            //   forward, longest-match  - used for all ANCHOR_BOTH searches,
+            //                               and the other two kinds if
+            //                               opt.longest_match() == true
+            //   reverse, first-match    - never used
+            //   reverse, longest-match  - used as second phase for unanchored searches
+            //
+            // The RE2 memory budget is statically divided between the two
+            // Progs and then the DFAs: two thirds to the forward Prog
+            // and one third to the reverse Prog.  The forward Prog gives half
+            // of what it has left over to each of its DFAs.  The reverse Prog
+            // gives it all to its longest-match DFA.
+            //
+            // Once a DFA fills its budget, it flushes its cache and starts over.
+            // If this happens too often, RE2 falls back on the NFA implementation.
+
+            // For now, make the default budget something close to Code Search.
+            static const int kDefaultMaxMem = 8 << 20;
+
+            enum Encoding
+            {
+                EncodingUTF8 = 1,
+                EncodingLatin1
+            };
+
+            Options() :
+                encoding_(EncodingUTF8),
+                posix_syntax_(false),
+                longest_match_(false),
+                log_errors_(true),
+                max_mem_(kDefaultMaxMem),
+                literal_(false),
+                never_nl_(false),
+                dot_nl_(false),
+                never_capture_(false),
+                case_sensitive_(true),
+                perl_classes_(false),
+                word_boundary_(false),
+                one_line_(false)
+            {
+            }
+
+            /*implicit*/ Options(CannedOptions);
+
+            Encoding encoding() const
+            {
+                return encoding_;
+            }
+            void set_encoding(Encoding encoding)
+            {
+                encoding_ = encoding;
+            }
+
+            bool posix_syntax() const
+            {
+                return posix_syntax_;
+            }
+            void set_posix_syntax(bool b)
+            {
+                posix_syntax_ = b;
+            }
+
+            bool longest_match() const
+            {
+                return longest_match_;
+            }
+            void set_longest_match(bool b)
+            {
+                longest_match_ = b;
+            }
+
+            bool log_errors() const
+            {
+                return log_errors_;
+            }
+            void set_log_errors(bool b)
+            {
+                log_errors_ = b;
+            }
+
+            int64_t max_mem() const
+            {
+                return max_mem_;
+            }
+            void set_max_mem(int64_t m)
+            {
+                max_mem_ = m;
+            }
+
+            bool literal() const
+            {
+                return literal_;
+            }
+            void set_literal(bool b)
+            {
+                literal_ = b;
+            }
+
+            bool never_nl() const
+            {
+                return never_nl_;
+            }
+            void set_never_nl(bool b)
+            {
+                never_nl_ = b;
+            }
+
+            bool dot_nl() const
+            {
+                return dot_nl_;
+            }
+            void set_dot_nl(bool b)
+            {
+                dot_nl_ = b;
+            }
+
+            bool never_capture() const
+            {
+                return never_capture_;
+            }
+            void set_never_capture(bool b)
+            {
+                never_capture_ = b;
+            }
+
+            bool case_sensitive() const
+            {
+                return case_sensitive_;
+            }
+            void set_case_sensitive(bool b)
+            {
+                case_sensitive_ = b;
+            }
+
+            bool perl_classes() const
+            {
+                return perl_classes_;
+            }
+            void set_perl_classes(bool b)
+            {
+                perl_classes_ = b;
+            }
+
+            bool word_boundary() const
+            {
+                return word_boundary_;
+            }
+            void set_word_boundary(bool b)
+            {
+                word_boundary_ = b;
+            }
+
+            bool one_line() const
+            {
+                return one_line_;
+            }
+            void set_one_line(bool b)
+            {
+                one_line_ = b;
+            }
+
+            void Copy(const Options& src)
+            {
+                *this = src;
+            }
+
+            int ParseFlags() const;
+
+        private:
+            Encoding encoding_;
+            bool posix_syntax_;
+            bool longest_match_;
+            bool log_errors_;
+            int64_t max_mem_;
+            bool literal_;
+            bool never_nl_;
+            bool dot_nl_;
+            bool never_capture_;
+            bool case_sensitive_;
+            bool perl_classes_;
+            bool word_boundary_;
+            bool one_line_;
+        };
+
+        // Returns the options set in the constructor.
+        const Options& options() const
+        {
+            return options_;
+        }
+
+        // Argument converters; see below.
+        template<typename T>
+        static Arg CRadix(T* ptr);
+        template<typename T>
+        static Arg Hex(T* ptr);
+        template<typename T>
+        static Arg Octal(T* ptr);
+
+    private:
+        void Init(const StringPiece& pattern, const Options& options);
+
+        bool DoMatch(const StringPiece& text, Anchor re_anchor, size_t* consumed, const Arg* const args[], int n) const;
+
+        re2::Prog* ReverseProg() const;
+
+        std::string pattern_;         // string regular expression
+        Options options_;             // option flags
+        re2::Regexp* entire_regexp_;  // parsed regular expression
+        const std::string* error_;    // error indicator (or points to empty string)
+        ErrorCode error_code_;        // error code
+        std::string error_arg_;       // fragment of regexp showing error
+        std::string prefix_;          // required prefix (before suffix_regexp_)
+        bool prefix_foldcase_;        // prefix_ is ASCII case-insensitive
+        re2::Regexp* suffix_regexp_;  // parsed regular expression, prefix_ removed
+        re2::Prog* prog_;             // compiled program for regexp
+        int num_captures_;            // number of capturing groups
+        bool is_one_pass_;            // can use prog_->SearchOnePass?
+
+        // Reverse Prog for DFA execution only
+        mutable re2::Prog* rprog_;
+        // Map from capture names to indices
+        mutable const std::map<std::string, int>* named_groups_;
+        // Map from capture indices to names
+        mutable const std::map<int, std::string>* group_names_;
+
+        mutable std::once_flag rprog_once_;
+        mutable std::once_flag named_groups_once_;
+        mutable std::once_flag group_names_once_;
+
+        RE2(const RE2&) = delete;
+        RE2& operator=(const RE2&) = delete;
     };
 
-    Options() :
-      encoding_(EncodingUTF8),
-      posix_syntax_(false),
-      longest_match_(false),
-      log_errors_(true),
-      max_mem_(kDefaultMaxMem),
-      literal_(false),
-      never_nl_(false),
-      dot_nl_(false),
-      never_capture_(false),
-      case_sensitive_(true),
-      perl_classes_(false),
-      word_boundary_(false),
-      one_line_(false) {
-    }
-
-    /*implicit*/ Options(CannedOptions);
-
-    Encoding encoding() const { return encoding_; }
-    void set_encoding(Encoding encoding) { encoding_ = encoding; }
-
-    bool posix_syntax() const { return posix_syntax_; }
-    void set_posix_syntax(bool b) { posix_syntax_ = b; }
-
-    bool longest_match() const { return longest_match_; }
-    void set_longest_match(bool b) { longest_match_ = b; }
-
-    bool log_errors() const { return log_errors_; }
-    void set_log_errors(bool b) { log_errors_ = b; }
-
-    int64_t max_mem() const { return max_mem_; }
-    void set_max_mem(int64_t m) { max_mem_ = m; }
-
-    bool literal() const { return literal_; }
-    void set_literal(bool b) { literal_ = b; }
-
-    bool never_nl() const { return never_nl_; }
-    void set_never_nl(bool b) { never_nl_ = b; }
-
-    bool dot_nl() const { return dot_nl_; }
-    void set_dot_nl(bool b) { dot_nl_ = b; }
-
-    bool never_capture() const { return never_capture_; }
-    void set_never_capture(bool b) { never_capture_ = b; }
-
-    bool case_sensitive() const { return case_sensitive_; }
-    void set_case_sensitive(bool b) { case_sensitive_ = b; }
-
-    bool perl_classes() const { return perl_classes_; }
-    void set_perl_classes(bool b) { perl_classes_ = b; }
-
-    bool word_boundary() const { return word_boundary_; }
-    void set_word_boundary(bool b) { word_boundary_ = b; }
-
-    bool one_line() const { return one_line_; }
-    void set_one_line(bool b) { one_line_ = b; }
-
-    void Copy(const Options& src) {
-      *this = src;
-    }
-
-    int ParseFlags() const;
-
-   private:
-    Encoding encoding_;
-    bool posix_syntax_;
-    bool longest_match_;
-    bool log_errors_;
-    int64_t max_mem_;
-    bool literal_;
-    bool never_nl_;
-    bool dot_nl_;
-    bool never_capture_;
-    bool case_sensitive_;
-    bool perl_classes_;
-    bool word_boundary_;
-    bool one_line_;
-  };
-
-  // Returns the options set in the constructor.
-  const Options& options() const { return options_; }
-
-  // Argument converters; see below.
-  template <typename T>
-  static Arg CRadix(T* ptr);
-  template <typename T>
-  static Arg Hex(T* ptr);
-  template <typename T>
-  static Arg Octal(T* ptr);
-
- private:
-  void Init(const StringPiece& pattern, const Options& options);
-
-  bool DoMatch(const StringPiece& text,
-               Anchor re_anchor,
-               size_t* consumed,
-               const Arg* const args[],
-               int n) const;
-
-  re2::Prog* ReverseProg() const;
-
-  std::string pattern_;         // string regular expression
-  Options options_;             // option flags
-  re2::Regexp* entire_regexp_;  // parsed regular expression
-  const std::string* error_;    // error indicator (or points to empty string)
-  ErrorCode error_code_;        // error code
-  std::string error_arg_;       // fragment of regexp showing error
-  std::string prefix_;          // required prefix (before suffix_regexp_)
-  bool prefix_foldcase_;        // prefix_ is ASCII case-insensitive
-  re2::Regexp* suffix_regexp_;  // parsed regular expression, prefix_ removed
-  re2::Prog* prog_;             // compiled program for regexp
-  int num_captures_;            // number of capturing groups
-  bool is_one_pass_;            // can use prog_->SearchOnePass?
-
-  // Reverse Prog for DFA execution only
-  mutable re2::Prog* rprog_;
-  // Map from capture names to indices
-  mutable const std::map<std::string, int>* named_groups_;
-  // Map from capture indices to names
-  mutable const std::map<int, std::string>* group_names_;
-
-  mutable std::once_flag rprog_once_;
-  mutable std::once_flag named_groups_once_;
-  mutable std::once_flag group_names_once_;
-
-  RE2(const RE2&) = delete;
-  RE2& operator=(const RE2&) = delete;
-};
-
-/***** Implementation details *****/
-
-namespace re2_internal {
-
-// Types for which the 3-ary Parse() function template has specializations.
-template <typename T> struct Parse3ary : public std::false_type {};
-template <> struct Parse3ary<void> : public std::true_type {};
-template <> struct Parse3ary<std::string> : public std::true_type {};
-template <> struct Parse3ary<StringPiece> : public std::true_type {};
-template <> struct Parse3ary<char> : public std::true_type {};
-template <> struct Parse3ary<signed char> : public std::true_type {};
-template <> struct Parse3ary<unsigned char> : public std::true_type {};
-template <> struct Parse3ary<float> : public std::true_type {};
-template <> struct Parse3ary<double> : public std::true_type {};
-
-template <typename T>
-bool Parse(const char* str, size_t n, T* dest);
-
-// Types for which the 4-ary Parse() function template has specializations.
-template <typename T> struct Parse4ary : public std::false_type {};
-template <> struct Parse4ary<long> : public std::true_type {};
-template <> struct Parse4ary<unsigned long> : public std::true_type {};
-template <> struct Parse4ary<short> : public std::true_type {};
-template <> struct Parse4ary<unsigned short> : public std::true_type {};
-template <> struct Parse4ary<int> : public std::true_type {};
-template <> struct Parse4ary<unsigned int> : public std::true_type {};
-template <> struct Parse4ary<long long> : public std::true_type {};
-template <> struct Parse4ary<unsigned long long> : public std::true_type {};
-
-template <typename T>
-bool Parse(const char* str, size_t n, T* dest, int radix);
-
-}  // namespace re2_internal
-
-class RE2::Arg {
- private:
-  template <typename T>
-  using CanParse3ary = typename std::enable_if<
-      re2_internal::Parse3ary<T>::value,
-      int>::type;
-
-  template <typename T>
-  using CanParse4ary = typename std::enable_if<
-      re2_internal::Parse4ary<T>::value,
-      int>::type;
+    /***** Implementation details *****/
+
+    namespace re2_internal
+    {
+
+        // Types for which the 3-ary Parse() function template has specializations.
+        template<typename T>
+        struct Parse3ary : public std::false_type
+        {
+        };
+        template<>
+        struct Parse3ary<void> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse3ary<std::string> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse3ary<StringPiece> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse3ary<char> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse3ary<signed char> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse3ary<unsigned char> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse3ary<float> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse3ary<double> : public std::true_type
+        {
+        };
+
+        template<typename T>
+        bool Parse(const char* str, size_t n, T* dest);
+
+        // Types for which the 4-ary Parse() function template has specializations.
+        template<typename T>
+        struct Parse4ary : public std::false_type
+        {
+        };
+        template<>
+        struct Parse4ary<long> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse4ary<unsigned long> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse4ary<short> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse4ary<unsigned short> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse4ary<int> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse4ary<unsigned int> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse4ary<long long> : public std::true_type
+        {
+        };
+        template<>
+        struct Parse4ary<unsigned long long> : public std::true_type
+        {
+        };
+
+        template<typename T>
+        bool Parse(const char* str, size_t n, T* dest, int radix);
+
+    }  // namespace re2_internal
+
+    class RE2::Arg
+    {
+    private:
+        template<typename T>
+        using CanParse3ary = typename std::enable_if<
+            re2_internal::Parse3ary<T>::value,
+            int>::type;
+
+        template<typename T>
+        using CanParse4ary = typename std::enable_if<
+            re2_internal::Parse4ary<T>::value,
+            int>::type;
 
 #if !defined(_MSC_VER)
-  template <typename T>
-  using CanParseFrom = typename std::enable_if<
-      std::is_member_function_pointer<
-          decltype(static_cast<bool (T::*)(const char*, size_t)>(
-              &T::ParseFrom))>::value,
-      int>::type;
+        template<typename T>
+        using CanParseFrom = typename std::enable_if<
+            std::is_member_function_pointer<
+                decltype(static_cast<bool (T::*)(const char*, size_t)>(
+                    &T::ParseFrom
+                ))>::value,
+            int>::type;
 #endif
 
- public:
-  Arg() : Arg(nullptr) {}
-  Arg(std::nullptr_t ptr) : arg_(ptr), parser_(DoNothing) {}
-
-  template <typename T, CanParse3ary<T> = 0>
-  Arg(T* ptr) : arg_(ptr), parser_(DoParse3ary<T>) {}
-
-  template <typename T, CanParse4ary<T> = 0>
-  Arg(T* ptr) : arg_(ptr), parser_(DoParse4ary<T>) {}
+    public:
+        Arg() :
+            Arg(nullptr)
+        {
+        }
+        Arg(std::nullptr_t ptr) :
+            arg_(ptr),
+            parser_(DoNothing)
+        {
+        }
+
+        template<typename T, CanParse3ary<T> = 0>
+        Arg(T* ptr) :
+            arg_(ptr),
+            parser_(DoParse3ary<T>)
+        {
+        }
+
+        template<typename T, CanParse4ary<T> = 0>
+        Arg(T* ptr) :
+            arg_(ptr),
+            parser_(DoParse4ary<T>)
+        {
+        }
 
 #if !defined(_MSC_VER)
-  template <typename T, CanParseFrom<T> = 0>
-  Arg(T* ptr) : arg_(ptr), parser_(DoParseFrom<T>) {}
+        template<typename T, CanParseFrom<T> = 0>
+        Arg(T* ptr) :
+            arg_(ptr),
+            parser_(DoParseFrom<T>)
+        {
+        }
 #endif
 
-  typedef bool (*Parser)(const char* str, size_t n, void* dest);
-
-  template <typename T>
-  Arg(T* ptr, Parser parser) : arg_(ptr), parser_(parser) {}
-
-  bool Parse(const char* str, size_t n) const {
-    return (*parser_)(str, n, arg_);
-  }
+        typedef bool (*Parser)(const char* str, size_t n, void* dest);
+
+        template<typename T>
+        Arg(T* ptr, Parser parser) :
+            arg_(ptr),
+            parser_(parser)
+        {
+        }
+
+        bool Parse(const char* str, size_t n) const
+        {
+            return (*parser_)(str, n, arg_);
+        }
+
+    private:
+        static bool DoNothing(const char* /*str*/, size_t /*n*/, void* /*dest*/)
+        {
+            return true;
+        }
+
+        template<typename T>
+        static bool DoParse3ary(const char* str, size_t n, void* dest)
+        {
+            return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest));
+        }
+
+        template<typename T>
+        static bool DoParse4ary(const char* str, size_t n, void* dest)
+        {
+            return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 10);
+        }
 
- private:
-  static bool DoNothing(const char* /*str*/, size_t /*n*/, void* /*dest*/) {
-    return true;
-  }
+#if !defined(_MSC_VER)
+        template<typename T>
+        static bool DoParseFrom(const char* str, size_t n, void* dest)
+        {
+            if (dest == NULL)
+                return true;
+            return reinterpret_cast<T*>(dest)->ParseFrom(str, n);
+        }
+#endif
 
-  template <typename T>
-  static bool DoParse3ary(const char* str, size_t n, void* dest) {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest));
-  }
+        void* arg_;
+        Parser parser_;
+    };
 
-  template <typename T>
-  static bool DoParse4ary(const char* str, size_t n, void* dest) {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 10);
-  }
+    template<typename T>
+    inline RE2::Arg RE2::CRadix(T* ptr)
+    {
+        return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool
+                        { return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 0); });
+    }
 
-#if !defined(_MSC_VER)
-  template <typename T>
-  static bool DoParseFrom(const char* str, size_t n, void* dest) {
-    if (dest == NULL) return true;
-    return reinterpret_cast<T*>(dest)->ParseFrom(str, n);
-  }
-#endif
+    template<typename T>
+    inline RE2::Arg RE2::Hex(T* ptr)
+    {
+        return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool
+                        { return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 16); });
+    }
 
-  void*         arg_;
-  Parser        parser_;
-};
-
-template <typename T>
-inline RE2::Arg RE2::CRadix(T* ptr) {
-  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 0);
-  });
-}
-
-template <typename T>
-inline RE2::Arg RE2::Hex(T* ptr) {
-  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 16);
-  });
-}
-
-template <typename T>
-inline RE2::Arg RE2::Octal(T* ptr) {
-  return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool {
-    return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 8);
-  });
-}
+    template<typename T>
+    inline RE2::Arg RE2::Octal(T* ptr)
+    {
+        return RE2::Arg(ptr, [](const char* str, size_t n, void* dest) -> bool
+                        { return re2_internal::Parse(str, n, reinterpret_cast<T*>(dest), 8); });
+    }
 
 #ifndef SWIG
 // Silence warnings about missing initializers for members of LazyRE2.
@@ -914,54 +1094,66 @@ inline RE2::Arg RE2::Octal(T* ptr) {
 #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
 #endif
 
-// Helper for writing global or static RE2s safely.
-// Write
-//     static LazyRE2 re = {".*"};
-// and then use *re instead of writing
-//     static RE2 re(".*");
-// The former is more careful about multithreaded
-// situations than the latter.
-//
-// N.B. This class never deletes the RE2 object that
-// it constructs: that's a feature, so that it can be used
-// for global and function static variables.
-class LazyRE2 {
- private:
-  struct NoArg {};
-
- public:
-  typedef RE2 element_type;  // support std::pointer_traits
-
-  // Constructor omitted to preserve braced initialization in C++98.
-
-  // Pretend to be a pointer to Type (never NULL due to on-demand creation):
-  RE2& operator*() const { return *get(); }
-  RE2* operator->() const { return get(); }
-
-  // Named accessor/initializer:
-  RE2* get() const {
-    std::call_once(once_, &LazyRE2::Init, this);
-    return ptr_;
-  }
-
-  // All data fields must be public to support {"foo"} initialization.
-  const char* pattern_;
-  RE2::CannedOptions options_;
-  NoArg barrier_against_excess_initializers_;
-
-  mutable RE2* ptr_;
-  mutable std::once_flag once_;
-
- private:
-  static void Init(const LazyRE2* lazy_re2) {
-    lazy_re2->ptr_ = new RE2(lazy_re2->pattern_, lazy_re2->options_);
-  }
-
-  void operator=(const LazyRE2&);  // disallowed
-};
+    // Helper for writing global or static RE2s safely.
+    // Write
+    //     static LazyRE2 re = {".*"};
+    // and then use *re instead of writing
+    //     static RE2 re(".*");
+    // The former is more careful about multithreaded
+    // situations than the latter.
+    //
+    // N.B. This class never deletes the RE2 object that
+    // it constructs: that's a feature, so that it can be used
+    // for global and function static variables.
+    class LazyRE2
+    {
+    private:
+        struct NoArg
+        {
+        };
+
+    public:
+        typedef RE2 element_type;  // support std::pointer_traits
+
+        // Constructor omitted to preserve braced initialization in C++98.
+
+        // Pretend to be a pointer to Type (never NULL due to on-demand creation):
+        RE2& operator*() const
+        {
+            return *get();
+        }
+        RE2* operator->() const
+        {
+            return get();
+        }
+
+        // Named accessor/initializer:
+        RE2* get() const
+        {
+            std::call_once(once_, &LazyRE2::Init, this);
+            return ptr_;
+        }
+
+        // All data fields must be public to support {"foo"} initialization.
+        const char* pattern_;
+        RE2::CannedOptions options_;
+        NoArg barrier_against_excess_initializers_;
+
+        mutable RE2* ptr_;
+        mutable std::once_flag once_;
+
+    private:
+        static void Init(const LazyRE2* lazy_re2)
+        {
+            lazy_re2->ptr_ = new RE2(lazy_re2->pattern_, lazy_re2->options_);
+        }
+
+        void operator=(const LazyRE2&);  // disallowed
+    };
 #endif
 
-namespace hooks {
+    namespace hooks
+    {
 
 // Most platforms support thread_local. Older versions of iOS don't support
 // thread_local, but for the sake of brevity, we lump together all versions
@@ -985,33 +1177,35 @@ namespace hooks {
 // could result in infinite mutual recursion. To discourage that possibility,
 // RE2 will not maintain the context pointer correctly when used in that way.
 #ifdef RE2_HAVE_THREAD_LOCAL
-extern thread_local const RE2* context;
+        extern thread_local const RE2* context;
 #endif
 
-struct DFAStateCacheReset {
-  int64_t state_budget;
-  size_t state_cache_size;
-};
+        struct DFAStateCacheReset
+        {
+            int64_t state_budget;
+            size_t state_cache_size;
+        };
 
-struct DFASearchFailure {
-  // Nothing yet...
-};
+        struct DFASearchFailure
+        {
+            // Nothing yet...
+        };
 
-#define DECLARE_HOOK(type)                  \
-  using type##Callback = void(const type&); \
-  void Set##type##Hook(type##Callback* cb); \
-  type##Callback* Get##type##Hook();
+#define DECLARE_HOOK(type)                    \
+    using type##Callback = void(const type&); \
+    void Set##type##Hook(type##Callback* cb); \
+    type##Callback* Get##type##Hook();
 
-DECLARE_HOOK(DFAStateCacheReset)
-DECLARE_HOOK(DFASearchFailure)
+        DECLARE_HOOK(DFAStateCacheReset)
+        DECLARE_HOOK(DFASearchFailure)
 
 #undef DECLARE_HOOK
 
-}  // namespace hooks
+    }  // namespace hooks
 
 }  // namespace re2
 
-using re2::RE2;
 using re2::LazyRE2;
+using re2::RE2;
 
 #endif  // RE2_RE2_H_
diff --git a/CAPI/cpp/grpc/include/re2/set.h b/CAPI/cpp/grpc/include/re2/set.h
index 8d64f30..e1aecf3 100644
--- a/CAPI/cpp/grpc/include/re2/set.h
+++ b/CAPI/cpp/grpc/include/re2/set.h
@@ -12,73 +12,77 @@
 
 #include "re2/re2.h"
 
-namespace re2 {
-class Prog;
-class Regexp;
+namespace re2
+{
+    class Prog;
+    class Regexp;
 }  // namespace re2
 
-namespace re2 {
-
-// An RE2::Set represents a collection of regexps that can
-// be searched for simultaneously.
-class RE2::Set {
- public:
-  enum ErrorKind {
-    kNoError = 0,
-    kNotCompiled,   // The set is not compiled.
-    kOutOfMemory,   // The DFA ran out of memory.
-    kInconsistent,  // The result is inconsistent. This should never happen.
-  };
-
-  struct ErrorInfo {
-    ErrorKind kind;
-  };
-
-  Set(const RE2::Options& options, RE2::Anchor anchor);
-  ~Set();
-
-  // Not copyable.
-  Set(const Set&) = delete;
-  Set& operator=(const Set&) = delete;
-  // Movable.
-  Set(Set&& other);
-  Set& operator=(Set&& other);
-
-  // Adds pattern to the set using the options passed to the constructor.
-  // Returns the index that will identify the regexp in the output of Match(),
-  // or -1 if the regexp cannot be parsed.
-  // Indices are assigned in sequential order starting from 0.
-  // Errors do not increment the index; if error is not NULL, *error will hold
-  // the error message from the parser.
-  int Add(const StringPiece& pattern, std::string* error);
-
-  // Compiles the set in preparation for matching.
-  // Returns false if the compiler runs out of memory.
-  // Add() must not be called again after Compile().
-  // Compile() must be called before Match().
-  bool Compile();
-
-  // Returns true if text matches at least one of the regexps in the set.
-  // Fills v (if not NULL) with the indices of the matching regexps.
-  // Callers must not expect v to be sorted.
-  bool Match(const StringPiece& text, std::vector<int>* v) const;
-
-  // As above, but populates error_info (if not NULL) when none of the regexps
-  // in the set matched. This can inform callers when DFA execution fails, for
-  // example, because they might wish to handle that case differently.
-  bool Match(const StringPiece& text, std::vector<int>* v,
-             ErrorInfo* error_info) const;
-
- private:
-  typedef std::pair<std::string, re2::Regexp*> Elem;
-
-  RE2::Options options_;
-  RE2::Anchor anchor_;
-  std::vector<Elem> elem_;
-  bool compiled_;
-  int size_;
-  std::unique_ptr<re2::Prog> prog_;
-};
+namespace re2
+{
+
+    // An RE2::Set represents a collection of regexps that can
+    // be searched for simultaneously.
+    class RE2::Set
+    {
+    public:
+        enum ErrorKind
+        {
+            kNoError = 0,
+            kNotCompiled,   // The set is not compiled.
+            kOutOfMemory,   // The DFA ran out of memory.
+            kInconsistent,  // The result is inconsistent. This should never happen.
+        };
+
+        struct ErrorInfo
+        {
+            ErrorKind kind;
+        };
+
+        Set(const RE2::Options& options, RE2::Anchor anchor);
+        ~Set();
+
+        // Not copyable.
+        Set(const Set&) = delete;
+        Set& operator=(const Set&) = delete;
+        // Movable.
+        Set(Set&& other);
+        Set& operator=(Set&& other);
+
+        // Adds pattern to the set using the options passed to the constructor.
+        // Returns the index that will identify the regexp in the output of Match(),
+        // or -1 if the regexp cannot be parsed.
+        // Indices are assigned in sequential order starting from 0.
+        // Errors do not increment the index; if error is not NULL, *error will hold
+        // the error message from the parser.
+        int Add(const StringPiece& pattern, std::string* error);
+
+        // Compiles the set in preparation for matching.
+        // Returns false if the compiler runs out of memory.
+        // Add() must not be called again after Compile().
+        // Compile() must be called before Match().
+        bool Compile();
+
+        // Returns true if text matches at least one of the regexps in the set.
+        // Fills v (if not NULL) with the indices of the matching regexps.
+        // Callers must not expect v to be sorted.
+        bool Match(const StringPiece& text, std::vector<int>* v) const;
+
+        // As above, but populates error_info (if not NULL) when none of the regexps
+        // in the set matched. This can inform callers when DFA execution fails, for
+        // example, because they might wish to handle that case differently.
+        bool Match(const StringPiece& text, std::vector<int>* v, ErrorInfo* error_info) const;
+
+    private:
+        typedef std::pair<std::string, re2::Regexp*> Elem;
+
+        RE2::Options options_;
+        RE2::Anchor anchor_;
+        std::vector<Elem> elem_;
+        bool compiled_;
+        int size_;
+        std::unique_ptr<re2::Prog> prog_;
+    };
 
 }  // namespace re2
 
diff --git a/CAPI/cpp/grpc/include/re2/stringpiece.h b/CAPI/cpp/grpc/include/re2/stringpiece.h
index 1d9c2d3..3231638 100644
--- a/CAPI/cpp/grpc/include/re2/stringpiece.h
+++ b/CAPI/cpp/grpc/include/re2/stringpiece.h
@@ -34,176 +34,242 @@
 #include <string_view>
 #endif
 
-namespace re2 {
-
-class StringPiece {
- public:
-  typedef std::char_traits<char> traits_type;
-  typedef char value_type;
-  typedef char* pointer;
-  typedef const char* const_pointer;
-  typedef char& reference;
-  typedef const char& const_reference;
-  typedef const char* const_iterator;
-  typedef const_iterator iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef const_reverse_iterator reverse_iterator;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-  static const size_type npos = static_cast<size_type>(-1);
-
-  // We provide non-explicit singleton constructors so users can pass
-  // in a "const char*" or a "string" wherever a "StringPiece" is
-  // expected.
-  StringPiece()
-      : data_(NULL), size_(0) {}
+namespace re2
+{
+
+    class StringPiece
+    {
+    public:
+        typedef std::char_traits<char> traits_type;
+        typedef char value_type;
+        typedef char* pointer;
+        typedef const char* const_pointer;
+        typedef char& reference;
+        typedef const char& const_reference;
+        typedef const char* const_iterator;
+        typedef const_iterator iterator;
+        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+        typedef const_reverse_iterator reverse_iterator;
+        typedef size_t size_type;
+        typedef ptrdiff_t difference_type;
+        static const size_type npos = static_cast<size_type>(-1);
+
+        // We provide non-explicit singleton constructors so users can pass
+        // in a "const char*" or a "string" wherever a "StringPiece" is
+        // expected.
+        StringPiece() :
+            data_(NULL),
+            size_(0)
+        {
+        }
 #if __has_include(<string_view>) && __cplusplus >= 201703L
-  StringPiece(const std::string_view& str)
-      : data_(str.data()), size_(str.size()) {}
+        StringPiece(const std::string_view& str) :
+            data_(str.data()),
+            size_(str.size())
+        {
+        }
 #endif
-  StringPiece(const std::string& str)
-      : data_(str.data()), size_(str.size()) {}
-  StringPiece(const char* str)
-      : data_(str), size_(str == NULL ? 0 : strlen(str)) {}
-  StringPiece(const char* str, size_type len)
-      : data_(str), size_(len) {}
-
-  const_iterator begin() const { return data_; }
-  const_iterator end() const { return data_ + size_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(data_ + size_);
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(data_);
-  }
-
-  size_type size() const { return size_; }
-  size_type length() const { return size_; }
-  bool empty() const { return size_ == 0; }
-
-  const_reference operator[](size_type i) const { return data_[i]; }
-  const_pointer data() const { return data_; }
-
-  void remove_prefix(size_type n) {
-    data_ += n;
-    size_ -= n;
-  }
-
-  void remove_suffix(size_type n) {
-    size_ -= n;
-  }
-
-  void set(const char* str) {
-    data_ = str;
-    size_ = str == NULL ? 0 : strlen(str);
-  }
-
-  void set(const char* str, size_type len) {
-    data_ = str;
-    size_ = len;
-  }
-
-  // Converts to `std::basic_string`.
-  template <typename A>
-  explicit operator std::basic_string<char, traits_type, A>() const {
-    if (!data_) return {};
-    return std::basic_string<char, traits_type, A>(data_, size_);
-  }
-
-  std::string as_string() const {
-    return std::string(data_, size_);
-  }
-
-  // We also define ToString() here, since many other string-like
-  // interfaces name the routine that converts to a C++ string
-  // "ToString", and it's confusing to have the method that does that
-  // for a StringPiece be called "as_string()".  We also leave the
-  // "as_string()" method defined here for existing code.
-  std::string ToString() const {
-    return std::string(data_, size_);
-  }
-
-  void CopyToString(std::string* target) const {
-    target->assign(data_, size_);
-  }
-
-  void AppendToString(std::string* target) const {
-    target->append(data_, size_);
-  }
-
-  size_type copy(char* buf, size_type n, size_type pos = 0) const;
-  StringPiece substr(size_type pos = 0, size_type n = npos) const;
-
-  int compare(const StringPiece& x) const {
-    size_type min_size = std::min(size(), x.size());
-    if (min_size > 0) {
-      int r = memcmp(data(), x.data(), min_size);
-      if (r < 0) return -1;
-      if (r > 0) return 1;
+        StringPiece(const std::string& str) :
+            data_(str.data()),
+            size_(str.size())
+        {
+        }
+        StringPiece(const char* str) :
+            data_(str),
+            size_(str == NULL ? 0 : strlen(str))
+        {
+        }
+        StringPiece(const char* str, size_type len) :
+            data_(str),
+            size_(len)
+        {
+        }
+
+        const_iterator begin() const
+        {
+            return data_;
+        }
+        const_iterator end() const
+        {
+            return data_ + size_;
+        }
+        const_reverse_iterator rbegin() const
+        {
+            return const_reverse_iterator(data_ + size_);
+        }
+        const_reverse_iterator rend() const
+        {
+            return const_reverse_iterator(data_);
+        }
+
+        size_type size() const
+        {
+            return size_;
+        }
+        size_type length() const
+        {
+            return size_;
+        }
+        bool empty() const
+        {
+            return size_ == 0;
+        }
+
+        const_reference operator[](size_type i) const
+        {
+            return data_[i];
+        }
+        const_pointer data() const
+        {
+            return data_;
+        }
+
+        void remove_prefix(size_type n)
+        {
+            data_ += n;
+            size_ -= n;
+        }
+
+        void remove_suffix(size_type n)
+        {
+            size_ -= n;
+        }
+
+        void set(const char* str)
+        {
+            data_ = str;
+            size_ = str == NULL ? 0 : strlen(str);
+        }
+
+        void set(const char* str, size_type len)
+        {
+            data_ = str;
+            size_ = len;
+        }
+
+        // Converts to `std::basic_string`.
+        template<typename A>
+        explicit operator std::basic_string<char, traits_type, A>() const
+        {
+            if (!data_)
+                return {};
+            return std::basic_string<char, traits_type, A>(data_, size_);
+        }
+
+        std::string as_string() const
+        {
+            return std::string(data_, size_);
+        }
+
+        // We also define ToString() here, since many other string-like
+        // interfaces name the routine that converts to a C++ string
+        // "ToString", and it's confusing to have the method that does that
+        // for a StringPiece be called "as_string()".  We also leave the
+        // "as_string()" method defined here for existing code.
+        std::string ToString() const
+        {
+            return std::string(data_, size_);
+        }
+
+        void CopyToString(std::string* target) const
+        {
+            target->assign(data_, size_);
+        }
+
+        void AppendToString(std::string* target) const
+        {
+            target->append(data_, size_);
+        }
+
+        size_type copy(char* buf, size_type n, size_type pos = 0) const;
+        StringPiece substr(size_type pos = 0, size_type n = npos) const;
+
+        int compare(const StringPiece& x) const
+        {
+            size_type min_size = std::min(size(), x.size());
+            if (min_size > 0)
+            {
+                int r = memcmp(data(), x.data(), min_size);
+                if (r < 0)
+                    return -1;
+                if (r > 0)
+                    return 1;
+            }
+            if (size() < x.size())
+                return -1;
+            if (size() > x.size())
+                return 1;
+            return 0;
+        }
+
+        // Does "this" start with "x"?
+        bool starts_with(const StringPiece& x) const
+        {
+            return x.empty() ||
+                   (size() >= x.size() && memcmp(data(), x.data(), x.size()) == 0);
+        }
+
+        // Does "this" end with "x"?
+        bool ends_with(const StringPiece& x) const
+        {
+            return x.empty() ||
+                   (size() >= x.size() &&
+                    memcmp(data() + (size() - x.size()), x.data(), x.size()) == 0);
+        }
+
+        bool contains(const StringPiece& s) const
+        {
+            return find(s) != npos;
+        }
+
+        size_type find(const StringPiece& s, size_type pos = 0) const;
+        size_type find(char c, size_type pos = 0) const;
+        size_type rfind(const StringPiece& s, size_type pos = npos) const;
+        size_type rfind(char c, size_type pos = npos) const;
+
+    private:
+        const_pointer data_;
+        size_type size_;
+    };
+
+    inline bool operator==(const StringPiece& x, const StringPiece& y)
+    {
+        StringPiece::size_type len = x.size();
+        if (len != y.size())
+            return false;
+        return x.data() == y.data() || len == 0 ||
+               memcmp(x.data(), y.data(), len) == 0;
     }
-    if (size() < x.size()) return -1;
-    if (size() > x.size()) return 1;
-    return 0;
-  }
-
-  // Does "this" start with "x"?
-  bool starts_with(const StringPiece& x) const {
-    return x.empty() ||
-           (size() >= x.size() && memcmp(data(), x.data(), x.size()) == 0);
-  }
-
-  // Does "this" end with "x"?
-  bool ends_with(const StringPiece& x) const {
-    return x.empty() ||
-           (size() >= x.size() &&
-            memcmp(data() + (size() - x.size()), x.data(), x.size()) == 0);
-  }
-
-  bool contains(const StringPiece& s) const {
-    return find(s) != npos;
-  }
-
-  size_type find(const StringPiece& s, size_type pos = 0) const;
-  size_type find(char c, size_type pos = 0) const;
-  size_type rfind(const StringPiece& s, size_type pos = npos) const;
-  size_type rfind(char c, size_type pos = npos) const;
-
- private:
-  const_pointer data_;
-  size_type size_;
-};
-
-inline bool operator==(const StringPiece& x, const StringPiece& y) {
-  StringPiece::size_type len = x.size();
-  if (len != y.size()) return false;
-  return x.data() == y.data() || len == 0 ||
-         memcmp(x.data(), y.data(), len) == 0;
-}
-
-inline bool operator!=(const StringPiece& x, const StringPiece& y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece& x, const StringPiece& y) {
-  StringPiece::size_type min_size = std::min(x.size(), y.size());
-  int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
-  return (r < 0) || (r == 0 && x.size() < y.size());
-}
-
-inline bool operator>(const StringPiece& x, const StringPiece& y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece& x, const StringPiece& y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece& x, const StringPiece& y) {
-  return !(x < y);
-}
-
-// Allow StringPiece to be logged.
-std::ostream& operator<<(std::ostream& o, const StringPiece& p);
+
+    inline bool operator!=(const StringPiece& x, const StringPiece& y)
+    {
+        return !(x == y);
+    }
+
+    inline bool operator<(const StringPiece& x, const StringPiece& y)
+    {
+        StringPiece::size_type min_size = std::min(x.size(), y.size());
+        int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
+        return (r < 0) || (r == 0 && x.size() < y.size());
+    }
+
+    inline bool operator>(const StringPiece& x, const StringPiece& y)
+    {
+        return y < x;
+    }
+
+    inline bool operator<=(const StringPiece& x, const StringPiece& y)
+    {
+        return !(x > y);
+    }
+
+    inline bool operator>=(const StringPiece& x, const StringPiece& y)
+    {
+        return !(x < y);
+    }
+
+    // Allow StringPiece to be logged.
+    std::ostream& operator<<(std::ostream& o, const StringPiece& p);
 
 }  // namespace re2
 
diff --git a/CAPI/cpp/grpc/include/upb/arena.h b/CAPI/cpp/grpc/include/upb/arena.h
index 0c4fd1b..976604f 100644
--- a/CAPI/cpp/grpc/include/upb/arena.h
+++ b/CAPI/cpp/grpc/include/upb/arena.h
@@ -36,185 +36,210 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** upb_alloc *****************************************************************/
+    /** upb_alloc *****************************************************************/
 
-/* A upb_alloc is a possibly-stateful allocator object.
- *
- * It could either be an arena allocator (which doesn't require individual
- * free() calls) or a regular malloc() (which does).  The client must therefore
- * free memory unless it knows that the allocator is an arena allocator. */
-
-struct upb_alloc;
-typedef struct upb_alloc upb_alloc;
-
-/* A malloc()/free() function.
- * If "size" is 0 then the function acts like free(), otherwise it acts like
- * realloc().  Only "oldsize" bytes from a previous allocation are preserved. */
-typedef void* upb_alloc_func(upb_alloc* alloc, void* ptr, size_t oldsize,
-                             size_t size);
+    /* A upb_alloc is a possibly-stateful allocator object.
+     *
+     * It could either be an arena allocator (which doesn't require individual
+     * free() calls) or a regular malloc() (which does).  The client must therefore
+     * free memory unless it knows that the allocator is an arena allocator. */
 
-struct upb_alloc {
-  upb_alloc_func* func;
-};
+    struct upb_alloc;
+    typedef struct upb_alloc upb_alloc;
 
-UPB_INLINE void* upb_malloc(upb_alloc* alloc, size_t size) {
-  UPB_ASSERT(alloc);
-  return alloc->func(alloc, NULL, 0, size);
-}
+    /* A malloc()/free() function.
+     * If "size" is 0 then the function acts like free(), otherwise it acts like
+     * realloc().  Only "oldsize" bytes from a previous allocation are preserved. */
+    typedef void* upb_alloc_func(upb_alloc* alloc, void* ptr, size_t oldsize, size_t size);
 
-UPB_INLINE void* upb_realloc(upb_alloc* alloc, void* ptr, size_t oldsize,
-                             size_t size) {
-  UPB_ASSERT(alloc);
-  return alloc->func(alloc, ptr, oldsize, size);
-}
+    struct upb_alloc
+    {
+        upb_alloc_func* func;
+    };
 
-UPB_INLINE void upb_free(upb_alloc* alloc, void* ptr) {
-  assert(alloc);
-  alloc->func(alloc, ptr, 0, 0);
-}
-
-/* The global allocator used by upb.  Uses the standard malloc()/free(). */
+    UPB_INLINE void* upb_malloc(upb_alloc* alloc, size_t size)
+    {
+        UPB_ASSERT(alloc);
+        return alloc->func(alloc, NULL, 0, size);
+    }
 
-extern upb_alloc upb_alloc_global;
+    UPB_INLINE void* upb_realloc(upb_alloc* alloc, void* ptr, size_t oldsize, size_t size)
+    {
+        UPB_ASSERT(alloc);
+        return alloc->func(alloc, ptr, oldsize, size);
+    }
 
-/* Functions that hard-code the global malloc.
- *
- * We still get benefit because we can put custom logic into our global
- * allocator, like injecting out-of-memory faults in debug/testing builds. */
+    UPB_INLINE void upb_free(upb_alloc* alloc, void* ptr)
+    {
+        assert(alloc);
+        alloc->func(alloc, ptr, 0, 0);
+    }
 
-UPB_INLINE void* upb_gmalloc(size_t size) {
-  return upb_malloc(&upb_alloc_global, size);
-}
+    /* The global allocator used by upb.  Uses the standard malloc()/free(). */
 
-UPB_INLINE void* upb_grealloc(void* ptr, size_t oldsize, size_t size) {
-  return upb_realloc(&upb_alloc_global, ptr, oldsize, size);
-}
+    extern upb_alloc upb_alloc_global;
 
-UPB_INLINE void upb_gfree(void* ptr) { upb_free(&upb_alloc_global, ptr); }
+    /* Functions that hard-code the global malloc.
+     *
+     * We still get benefit because we can put custom logic into our global
+     * allocator, like injecting out-of-memory faults in debug/testing builds. */
 
-/* upb_Arena ******************************************************************/
+    UPB_INLINE void* upb_gmalloc(size_t size)
+    {
+        return upb_malloc(&upb_alloc_global, size);
+    }
 
-/* upb_Arena is a specific allocator implementation that uses arena allocation.
- * The user provides an allocator that will be used to allocate the underlying
- * arena blocks.  Arenas by nature do not require the individual allocations
- * to be freed.  However the Arena does allow users to register cleanup
- * functions that will run when the arena is destroyed.
- *
- * A upb_Arena is *not* thread-safe.
- *
- * You could write a thread-safe arena allocator that satisfies the
- * upb_alloc interface, but it would not be as efficient for the
- * single-threaded case. */
+    UPB_INLINE void* upb_grealloc(void* ptr, size_t oldsize, size_t size)
+    {
+        return upb_realloc(&upb_alloc_global, ptr, oldsize, size);
+    }
 
-typedef void upb_CleanupFunc(void* ud);
+    UPB_INLINE void upb_gfree(void* ptr)
+    {
+        upb_free(&upb_alloc_global, ptr);
+    }
 
-struct upb_Arena;
-typedef struct upb_Arena upb_Arena;
+    /* upb_Arena ******************************************************************/
+
+    /* upb_Arena is a specific allocator implementation that uses arena allocation.
+     * The user provides an allocator that will be used to allocate the underlying
+     * arena blocks.  Arenas by nature do not require the individual allocations
+     * to be freed.  However the Arena does allow users to register cleanup
+     * functions that will run when the arena is destroyed.
+     *
+     * A upb_Arena is *not* thread-safe.
+     *
+     * You could write a thread-safe arena allocator that satisfies the
+     * upb_alloc interface, but it would not be as efficient for the
+     * single-threaded case. */
+
+    typedef void upb_CleanupFunc(void* ud);
+
+    struct upb_Arena;
+    typedef struct upb_Arena upb_Arena;
+
+    typedef struct
+    {
+        /* We implement the allocator interface.
+         * This must be the first member of upb_Arena!
+         * TODO(haberman): remove once handlers are gone. */
+        upb_alloc alloc;
+
+        char *ptr, *end;
+    } _upb_ArenaHead;
+
+    /* Creates an arena from the given initial block (if any -- n may be 0).
+     * Additional blocks will be allocated from |alloc|.  If |alloc| is NULL, this
+     * is a fixed-size arena and cannot grow. */
+    upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc);
+    void upb_Arena_Free(upb_Arena* a);
+    bool upb_Arena_AddCleanup(upb_Arena* a, void* ud, upb_CleanupFunc* func);
+    bool upb_Arena_Fuse(upb_Arena* a, upb_Arena* b);
+    void* _upb_Arena_SlowMalloc(upb_Arena* a, size_t size);
+
+    UPB_INLINE upb_alloc* upb_Arena_Alloc(upb_Arena* a)
+    {
+        return (upb_alloc*)a;
+    }
 
-typedef struct {
-  /* We implement the allocator interface.
-   * This must be the first member of upb_Arena!
-   * TODO(haberman): remove once handlers are gone. */
-  upb_alloc alloc;
+    UPB_INLINE size_t _upb_ArenaHas(upb_Arena* a)
+    {
+        _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+        return (size_t)(h->end - h->ptr);
+    }
 
-  char *ptr, *end;
-} _upb_ArenaHead;
+    UPB_INLINE void* _upb_Arena_FastMalloc(upb_Arena* a, size_t size)
+    {
+        _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+        void* ret = h->ptr;
+        UPB_ASSERT(UPB_ALIGN_MALLOC((uintptr_t)ret) == (uintptr_t)ret);
+        UPB_ASSERT(UPB_ALIGN_MALLOC(size) == size);
+        UPB_UNPOISON_MEMORY_REGION(ret, size);
 
-/* Creates an arena from the given initial block (if any -- n may be 0).
- * Additional blocks will be allocated from |alloc|.  If |alloc| is NULL, this
- * is a fixed-size arena and cannot grow. */
-upb_Arena* upb_Arena_Init(void* mem, size_t n, upb_alloc* alloc);
-void upb_Arena_Free(upb_Arena* a);
-bool upb_Arena_AddCleanup(upb_Arena* a, void* ud, upb_CleanupFunc* func);
-bool upb_Arena_Fuse(upb_Arena* a, upb_Arena* b);
-void* _upb_Arena_SlowMalloc(upb_Arena* a, size_t size);
+        h->ptr += size;
 
-UPB_INLINE upb_alloc* upb_Arena_Alloc(upb_Arena* a) { return (upb_alloc*)a; }
+#if UPB_ASAN
+        {
+            size_t guard_size = 32;
+            if (_upb_ArenaHas(a) >= guard_size)
+            {
+                h->ptr += guard_size;
+            }
+            else
+            {
+                h->ptr = h->end;
+            }
+        }
+#endif
 
-UPB_INLINE size_t _upb_ArenaHas(upb_Arena* a) {
-  _upb_ArenaHead* h = (_upb_ArenaHead*)a;
-  return (size_t)(h->end - h->ptr);
-}
+        return ret;
+    }
 
-UPB_INLINE void* _upb_Arena_FastMalloc(upb_Arena* a, size_t size) {
-  _upb_ArenaHead* h = (_upb_ArenaHead*)a;
-  void* ret = h->ptr;
-  UPB_ASSERT(UPB_ALIGN_MALLOC((uintptr_t)ret) == (uintptr_t)ret);
-  UPB_ASSERT(UPB_ALIGN_MALLOC(size) == size);
-  UPB_UNPOISON_MEMORY_REGION(ret, size);
+    UPB_INLINE void* upb_Arena_Malloc(upb_Arena* a, size_t size)
+    {
+        size = UPB_ALIGN_MALLOC(size);
 
-  h->ptr += size;
+        if (UPB_UNLIKELY(_upb_ArenaHas(a) < size))
+        {
+            return _upb_Arena_SlowMalloc(a, size);
+        }
 
-#if UPB_ASAN
-  {
-    size_t guard_size = 32;
-    if (_upb_ArenaHas(a) >= guard_size) {
-      h->ptr += guard_size;
-    } else {
-      h->ptr = h->end;
+        return _upb_Arena_FastMalloc(a, size);
     }
-  }
-#endif
 
-  return ret;
-}
-
-UPB_INLINE void* upb_Arena_Malloc(upb_Arena* a, size_t size) {
-  size = UPB_ALIGN_MALLOC(size);
-
-  if (UPB_UNLIKELY(_upb_ArenaHas(a) < size)) {
-    return _upb_Arena_SlowMalloc(a, size);
-  }
-
-  return _upb_Arena_FastMalloc(a, size);
-}
-
-// Shrinks the last alloc from arena.
-// REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena.
-// We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if
-// this was not the last alloc.
-UPB_INLINE void upb_Arena_ShrinkLast(upb_Arena* a, void* ptr, size_t oldsize,
-                                     size_t size) {
-  _upb_ArenaHead* h = (_upb_ArenaHead*)a;
-  oldsize = UPB_ALIGN_MALLOC(oldsize);
-  size = UPB_ALIGN_MALLOC(size);
-  UPB_ASSERT((char*)ptr + oldsize == h->ptr);  // Must be the last alloc.
-  UPB_ASSERT(size <= oldsize);
-  h->ptr = (char*)ptr + size;
-}
-
-UPB_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize,
-                                   size_t size) {
-  _upb_ArenaHead* h = (_upb_ArenaHead*)a;
-  oldsize = UPB_ALIGN_MALLOC(oldsize);
-  size = UPB_ALIGN_MALLOC(size);
-  bool is_most_recent_alloc = (uintptr_t)ptr + oldsize == (uintptr_t)h->ptr;
-
-  if (is_most_recent_alloc) {
-    ptrdiff_t diff = size - oldsize;
-    if ((ptrdiff_t)_upb_ArenaHas(a) >= diff) {
-      h->ptr += diff;
-      return ptr;
+    // Shrinks the last alloc from arena.
+    // REQUIRES: (ptr, oldsize) was the last malloc/realloc from this arena.
+    // We could also add a upb_Arena_TryShrinkLast() which is simply a no-op if
+    // this was not the last alloc.
+    UPB_INLINE void upb_Arena_ShrinkLast(upb_Arena* a, void* ptr, size_t oldsize, size_t size)
+    {
+        _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+        oldsize = UPB_ALIGN_MALLOC(oldsize);
+        size = UPB_ALIGN_MALLOC(size);
+        UPB_ASSERT((char*)ptr + oldsize == h->ptr);  // Must be the last alloc.
+        UPB_ASSERT(size <= oldsize);
+        h->ptr = (char*)ptr + size;
     }
-  } else if (size <= oldsize) {
-    return ptr;
-  }
-
-  void* ret = upb_Arena_Malloc(a, size);
 
-  if (ret && oldsize > 0) {
-    memcpy(ret, ptr, UPB_MIN(oldsize, size));
-  }
-
-  return ret;
-}
+    UPB_INLINE void* upb_Arena_Realloc(upb_Arena* a, void* ptr, size_t oldsize, size_t size)
+    {
+        _upb_ArenaHead* h = (_upb_ArenaHead*)a;
+        oldsize = UPB_ALIGN_MALLOC(oldsize);
+        size = UPB_ALIGN_MALLOC(size);
+        bool is_most_recent_alloc = (uintptr_t)ptr + oldsize == (uintptr_t)h->ptr;
+
+        if (is_most_recent_alloc)
+        {
+            ptrdiff_t diff = size - oldsize;
+            if ((ptrdiff_t)_upb_ArenaHas(a) >= diff)
+            {
+                h->ptr += diff;
+                return ptr;
+            }
+        }
+        else if (size <= oldsize)
+        {
+            return ptr;
+        }
+
+        void* ret = upb_Arena_Malloc(a, size);
+
+        if (ret && oldsize > 0)
+        {
+            memcpy(ret, ptr, UPB_MIN(oldsize, size));
+        }
+
+        return ret;
+    }
 
-UPB_INLINE upb_Arena* upb_Arena_New(void) {
-  return upb_Arena_Init(NULL, 0, &upb_alloc_global);
-}
+    UPB_INLINE upb_Arena* upb_Arena_New(void)
+    {
+        return upb_Arena_Init(NULL, 0, &upb_alloc_global);
+    }
 
 #include "upb/port_undef.inc"
 
diff --git a/CAPI/cpp/grpc/include/upb/array.h b/CAPI/cpp/grpc/include/upb/array.h
index 0715d58..a122f1d 100644
--- a/CAPI/cpp/grpc/include/upb/array.h
+++ b/CAPI/cpp/grpc/include/upb/array.h
@@ -35,44 +35,43 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/* Creates a new array on the given arena that holds elements of this type. */
-upb_Array* upb_Array_New(upb_Arena* a, upb_CType type);
+    /* Creates a new array on the given arena that holds elements of this type. */
+    upb_Array* upb_Array_New(upb_Arena* a, upb_CType type);
 
-/* Returns the size of the array. */
-size_t upb_Array_Size(const upb_Array* arr);
+    /* Returns the size of the array. */
+    size_t upb_Array_Size(const upb_Array* arr);
 
-/* Returns the given element, which must be within the array's current size. */
-upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i);
+    /* Returns the given element, which must be within the array's current size. */
+    upb_MessageValue upb_Array_Get(const upb_Array* arr, size_t i);
 
-/* Sets the given element, which must be within the array's current size. */
-void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val);
+    /* Sets the given element, which must be within the array's current size. */
+    void upb_Array_Set(upb_Array* arr, size_t i, upb_MessageValue val);
 
-/* Appends an element to the array.  Returns false on allocation failure. */
-bool upb_Array_Append(upb_Array* array, upb_MessageValue val, upb_Arena* arena);
+    /* Appends an element to the array.  Returns false on allocation failure. */
+    bool upb_Array_Append(upb_Array* array, upb_MessageValue val, upb_Arena* arena);
 
-/* Moves elements within the array using memmove(). Like memmove(), the source
- * and destination elements may be overlapping. */
-void upb_Array_Move(upb_Array* array, size_t dst_idx, size_t src_idx,
-                    size_t count);
+    /* Moves elements within the array using memmove(). Like memmove(), the source
+     * and destination elements may be overlapping. */
+    void upb_Array_Move(upb_Array* array, size_t dst_idx, size_t src_idx, size_t count);
 
-/* Inserts one or more empty elements into the array.  Existing elements are
- * shifted right.  The new elements have undefined state and must be set with
- * `upb_Array_Set()`.
- * REQUIRES: `i <= upb_Array_Size(arr)` */
-bool upb_Array_Insert(upb_Array* array, size_t i, size_t count,
-                      upb_Arena* arena);
+    /* Inserts one or more empty elements into the array.  Existing elements are
+     * shifted right.  The new elements have undefined state and must be set with
+     * `upb_Array_Set()`.
+     * REQUIRES: `i <= upb_Array_Size(arr)` */
+    bool upb_Array_Insert(upb_Array* array, size_t i, size_t count, upb_Arena* arena);
 
-/* Deletes one or more elements from the array.  Existing elements are shifted
- * left.
- * REQUIRES: `i + count <= upb_Array_Size(arr)` */
-void upb_Array_Delete(upb_Array* array, size_t i, size_t count);
+    /* Deletes one or more elements from the array.  Existing elements are shifted
+     * left.
+     * REQUIRES: `i + count <= upb_Array_Size(arr)` */
+    void upb_Array_Delete(upb_Array* array, size_t i, size_t count);
 
-/* Changes the size of a vector.  New elements are initialized to empty/0.
- * Returns false on allocation failure. */
-bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena);
+    /* Changes the size of a vector.  New elements are initialized to empty/0.
+     * Returns false on allocation failure. */
+    bool upb_Array_Resize(upb_Array* array, size_t size, upb_Arena* arena);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/bindings/lua/upb.h b/CAPI/cpp/grpc/include/upb/bindings/lua/upb.h
index e0dc79e..0aa6a90 100644
--- a/CAPI/cpp/grpc/include/upb/bindings/lua/upb.h
+++ b/CAPI/cpp/grpc/include/upb/bindings/lua/upb.h
@@ -63,8 +63,7 @@ int lua_getiuservalue(lua_State* L, int index, int n);
 #endif
 
 /* Registers a type with the given name, methods, and metamethods. */
-void lupb_register_type(lua_State* L, const char* name, const luaL_Reg* m,
-                        const luaL_Reg* mm);
+void lupb_register_type(lua_State* L, const char* name, const luaL_Reg* m, const luaL_Reg* mm);
 
 /* Checks the given upb_Status and throws a Lua error if it is not ok. */
 void lupb_checkstatus(lua_State* L, upb_Status* s);
@@ -103,30 +102,31 @@ void lupb_def_registertypes(lua_State* L);
 
 /** From msg.c. ***************************************************************/
 
-void lupb_pushmsgval(lua_State* L, int container, upb_CType type,
-                     upb_MessageValue val);
+void lupb_pushmsgval(lua_State* L, int container, upb_CType type, upb_MessageValue val);
 int lupb_MessageDef_call(lua_State* L);
 upb_Arena* lupb_Arena_pushnew(lua_State* L);
 
 void lupb_msg_registertypes(lua_State* L);
 
 #define lupb_assert(L, predicate) \
-  if (!(predicate))               \
-    luaL_error(L, "internal error: %s, %s:%d ", #predicate, __FILE__, __LINE__);
+    if (!(predicate))             \
+        luaL_error(L, "internal error: %s, %s:%d ", #predicate, __FILE__, __LINE__);
 
 #define LUPB_UNUSED(var) (void)var
 
 #if defined(__GNUC__) || defined(__clang__)
-#define LUPB_UNREACHABLE()   \
-  do {                       \
-    assert(0);               \
-    __builtin_unreachable(); \
-  } while (0)
+#define LUPB_UNREACHABLE()       \
+    do                           \
+    {                            \
+        assert(0);               \
+        __builtin_unreachable(); \
+    } while (0)
 #else
 #define LUPB_UNREACHABLE() \
-  do {                     \
-    assert(0);             \
-  } while (0)
+    do                     \
+    {                      \
+        assert(0);         \
+    } while (0)
 #endif
 
 #endif /* UPB_LUA_UPB_H_ */
diff --git a/CAPI/cpp/grpc/include/upb/decode.h b/CAPI/cpp/grpc/include/upb/decode.h
index 0c09497..2b4ed40 100644
--- a/CAPI/cpp/grpc/include/upb/decode.h
+++ b/CAPI/cpp/grpc/include/upb/decode.h
@@ -39,52 +39,52 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-enum {
-  /* If set, strings will alias the input buffer instead of copying into the
-   * arena. */
-  kUpb_DecodeOption_AliasString = 1,
+    enum
+    {
+        /* If set, strings will alias the input buffer instead of copying into the
+         * arena. */
+        kUpb_DecodeOption_AliasString = 1,
 
-  /* If set, the parse will return failure if any message is missing any
-   * required fields when the message data ends.  The parse will still continue,
-   * and the failure will only be reported at the end.
-   *
-   * IMPORTANT CAVEATS:
-   *
-   * 1. This can throw a false positive failure if an incomplete message is seen
-   *    on the wire but is later completed when the sub-message occurs again.
-   *    For this reason, a second pass is required to verify a failure, to be
-   *    truly robust.
-   *
-   * 2. This can return a false success if you are decoding into a message that
-   *    already has some sub-message fields present.  If the sub-message does
-   *    not occur in the binary payload, we will never visit it and discover the
-   *    incomplete sub-message.  For this reason, this check is only useful for
-   *    implemting ParseFromString() semantics.  For MergeFromString(), a
-   *    post-parse validation step will always be necessary. */
-  kUpb_DecodeOption_CheckRequired = 2,
-};
+        /* If set, the parse will return failure if any message is missing any
+         * required fields when the message data ends.  The parse will still continue,
+         * and the failure will only be reported at the end.
+         *
+         * IMPORTANT CAVEATS:
+         *
+         * 1. This can throw a false positive failure if an incomplete message is seen
+         *    on the wire but is later completed when the sub-message occurs again.
+         *    For this reason, a second pass is required to verify a failure, to be
+         *    truly robust.
+         *
+         * 2. This can return a false success if you are decoding into a message that
+         *    already has some sub-message fields present.  If the sub-message does
+         *    not occur in the binary payload, we will never visit it and discover the
+         *    incomplete sub-message.  For this reason, this check is only useful for
+         *    implemting ParseFromString() semantics.  For MergeFromString(), a
+         *    post-parse validation step will always be necessary. */
+        kUpb_DecodeOption_CheckRequired = 2,
+    };
 
 #define UPB_DECODE_MAXDEPTH(depth) ((depth) << 16)
 
-typedef enum {
-  kUpb_DecodeStatus_Ok = 0,
-  kUpb_DecodeStatus_Malformed = 1,         // Wire format was corrupt
-  kUpb_DecodeStatus_OutOfMemory = 2,       // Arena alloc failed
-  kUpb_DecodeStatus_BadUtf8 = 3,           // String field had bad UTF-8
-  kUpb_DecodeStatus_MaxDepthExceeded = 4,  // Exceeded UPB_DECODE_MAXDEPTH
+    typedef enum
+    {
+        kUpb_DecodeStatus_Ok = 0,
+        kUpb_DecodeStatus_Malformed = 1,         // Wire format was corrupt
+        kUpb_DecodeStatus_OutOfMemory = 2,       // Arena alloc failed
+        kUpb_DecodeStatus_BadUtf8 = 3,           // String field had bad UTF-8
+        kUpb_DecodeStatus_MaxDepthExceeded = 4,  // Exceeded UPB_DECODE_MAXDEPTH
 
-  // kUpb_DecodeOption_CheckRequired failed (see above), but the parse otherwise
-  // succeeded.
-  kUpb_DecodeStatus_MissingRequired = 5,
-} upb_DecodeStatus;
+        // kUpb_DecodeOption_CheckRequired failed (see above), but the parse otherwise
+        // succeeded.
+        kUpb_DecodeStatus_MissingRequired = 5,
+    } upb_DecodeStatus;
 
-upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg,
-                            const upb_MiniTable* l,
-                            const upb_ExtensionRegistry* extreg, int options,
-                            upb_Arena* arena);
+    upb_DecodeStatus upb_Decode(const char* buf, size_t size, upb_Message* msg, const upb_MiniTable* l, const upb_ExtensionRegistry* extreg, int options, upb_Arena* arena);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/decode_fast.h b/CAPI/cpp/grpc/include/upb/decode_fast.h
index b04aeed..d656c6b 100644
--- a/CAPI/cpp/grpc/include/upb/decode_fast.h
+++ b/CAPI/cpp/grpc/include/upb/decode_fast.h
@@ -68,31 +68,29 @@ struct upb_Decoder;
 
 // The fallback, generic parsing function that can handle any field type.
 // This just uses the regular (non-fast) parser to parse a single field.
-const char* fastdecode_generic(struct upb_Decoder* d, const char* ptr,
-                               upb_Message* msg, intptr_t table,
-                               uint64_t hasbits, uint64_t data);
+const char* fastdecode_generic(struct upb_Decoder* d, const char* ptr, upb_Message* msg, intptr_t table, uint64_t hasbits, uint64_t data);
 
-#define UPB_PARSE_PARAMS                                                    \
-  struct upb_Decoder *d, const char *ptr, upb_Message *msg, intptr_t table, \
-      uint64_t hasbits, uint64_t data
+#define UPB_PARSE_PARAMS                                                      \
+    struct upb_Decoder *d, const char *ptr, upb_Message *msg, intptr_t table, \
+        uint64_t hasbits, uint64_t data
 
 /* primitive fields ***********************************************************/
 
 #define F(card, type, valbytes, tagbytes) \
-  const char* upb_p##card##type##valbytes##_##tagbytes##bt(UPB_PARSE_PARAMS);
+    const char* upb_p##card##type##valbytes##_##tagbytes##bt(UPB_PARSE_PARAMS);
 
 #define TYPES(card, tagbytes) \
-  F(card, b, 1, tagbytes)     \
-  F(card, v, 4, tagbytes)     \
-  F(card, v, 8, tagbytes)     \
-  F(card, z, 4, tagbytes)     \
-  F(card, z, 8, tagbytes)     \
-  F(card, f, 4, tagbytes)     \
-  F(card, f, 8, tagbytes)
+    F(card, b, 1, tagbytes)   \
+    F(card, v, 4, tagbytes)   \
+    F(card, v, 8, tagbytes)   \
+    F(card, z, 4, tagbytes)   \
+    F(card, z, 8, tagbytes)   \
+    F(card, f, 4, tagbytes)   \
+    F(card, f, 8, tagbytes)
 
 #define TAGBYTES(card) \
-  TYPES(card, 1)       \
-  TYPES(card, 2)
+    TYPES(card, 1)     \
+    TYPES(card, 2)
 
 TAGBYTES(s)
 TAGBYTES(o)
@@ -105,17 +103,17 @@ TAGBYTES(p)
 
 /* string fields **************************************************************/
 
-#define F(card, tagbytes, type)                                     \
-  const char* upb_p##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS); \
-  const char* upb_c##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS);
+#define F(card, tagbytes, type)                                       \
+    const char* upb_p##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS); \
+    const char* upb_c##card##type##_##tagbytes##bt(UPB_PARSE_PARAMS);
 
 #define UTF8(card, tagbytes) \
-  F(card, tagbytes, s)       \
-  F(card, tagbytes, b)
+    F(card, tagbytes, s)     \
+    F(card, tagbytes, b)
 
 #define TAGBYTES(card) \
-  UTF8(card, 1)        \
-  UTF8(card, 2)
+    UTF8(card, 1)      \
+    UTF8(card, 2)
 
 TAGBYTES(s)
 TAGBYTES(o)
@@ -127,18 +125,18 @@ TAGBYTES(r)
 /* sub-message fields *********************************************************/
 
 #define F(card, tagbytes, size_ceil, ceil_arg) \
-  const char* upb_p##card##m_##tagbytes##bt_max##size_ceil##b(UPB_PARSE_PARAMS);
+    const char* upb_p##card##m_##tagbytes##bt_max##size_ceil##b(UPB_PARSE_PARAMS);
 
-#define SIZES(card, tagbytes) \
-  F(card, tagbytes, 64, 64)   \
-  F(card, tagbytes, 128, 128) \
-  F(card, tagbytes, 192, 192) \
-  F(card, tagbytes, 256, 256) \
-  F(card, tagbytes, max, -1)
+#define SIZES(card, tagbytes)   \
+    F(card, tagbytes, 64, 64)   \
+    F(card, tagbytes, 128, 128) \
+    F(card, tagbytes, 192, 192) \
+    F(card, tagbytes, 256, 256) \
+    F(card, tagbytes, max, -1)
 
 #define TAGBYTES(card) \
-  SIZES(card, 1)       \
-  SIZES(card, 2)
+    SIZES(card, 1)     \
+    SIZES(card, 2)
 
 TAGBYTES(s)
 TAGBYTES(o)
diff --git a/CAPI/cpp/grpc/include/upb/def.h b/CAPI/cpp/grpc/include/upb/def.h
index 2cb312d..ca9b56b 100644
--- a/CAPI/cpp/grpc/include/upb/def.h
+++ b/CAPI/cpp/grpc/include/upb/def.h
@@ -36,59 +36,65 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif /* __cplusplus */
 
-struct upb_EnumDef;
-typedef struct upb_EnumDef upb_EnumDef;
-struct upb_EnumValueDef;
-typedef struct upb_EnumValueDef upb_EnumValueDef;
-struct upb_ExtensionRange;
-typedef struct upb_ExtensionRange upb_ExtensionRange;
-struct upb_FieldDef;
-typedef struct upb_FieldDef upb_FieldDef;
-struct upb_FileDef;
-typedef struct upb_FileDef upb_FileDef;
-struct upb_MethodDef;
-typedef struct upb_MethodDef upb_MethodDef;
-struct upb_MessageDef;
-typedef struct upb_MessageDef upb_MessageDef;
-struct upb_OneofDef;
-typedef struct upb_OneofDef upb_OneofDef;
-struct upb_ServiceDef;
-typedef struct upb_ServiceDef upb_ServiceDef;
-struct upb_streamdef;
-typedef struct upb_streamdef upb_streamdef;
-struct upb_DefPool;
-typedef struct upb_DefPool upb_DefPool;
-
-typedef enum { kUpb_Syntax_Proto2 = 2, kUpb_Syntax_Proto3 = 3 } upb_Syntax;
-
-/* All the different kind of well known type messages. For simplicity of check,
- * number wrappers and string wrappers are grouped together. Make sure the
- * order and merber of these groups are not changed.
- */
-typedef enum {
-  kUpb_WellKnown_Unspecified,
-  kUpb_WellKnown_Any,
-  kUpb_WellKnown_FieldMask,
-  kUpb_WellKnown_Duration,
-  kUpb_WellKnown_Timestamp,
-  /* number wrappers */
-  kUpb_WellKnown_DoubleValue,
-  kUpb_WellKnown_FloatValue,
-  kUpb_WellKnown_Int64Value,
-  kUpb_WellKnown_UInt64Value,
-  kUpb_WellKnown_Int32Value,
-  kUpb_WellKnown_UInt32Value,
-  /* string wrappers */
-  kUpb_WellKnown_StringValue,
-  kUpb_WellKnown_BytesValue,
-  kUpb_WellKnown_BoolValue,
-  kUpb_WellKnown_Value,
-  kUpb_WellKnown_ListValue,
-  kUpb_WellKnown_Struct
-} upb_WellKnown;
+    struct upb_EnumDef;
+    typedef struct upb_EnumDef upb_EnumDef;
+    struct upb_EnumValueDef;
+    typedef struct upb_EnumValueDef upb_EnumValueDef;
+    struct upb_ExtensionRange;
+    typedef struct upb_ExtensionRange upb_ExtensionRange;
+    struct upb_FieldDef;
+    typedef struct upb_FieldDef upb_FieldDef;
+    struct upb_FileDef;
+    typedef struct upb_FileDef upb_FileDef;
+    struct upb_MethodDef;
+    typedef struct upb_MethodDef upb_MethodDef;
+    struct upb_MessageDef;
+    typedef struct upb_MessageDef upb_MessageDef;
+    struct upb_OneofDef;
+    typedef struct upb_OneofDef upb_OneofDef;
+    struct upb_ServiceDef;
+    typedef struct upb_ServiceDef upb_ServiceDef;
+    struct upb_streamdef;
+    typedef struct upb_streamdef upb_streamdef;
+    struct upb_DefPool;
+    typedef struct upb_DefPool upb_DefPool;
+
+    typedef enum
+    {
+        kUpb_Syntax_Proto2 = 2,
+        kUpb_Syntax_Proto3 = 3
+    } upb_Syntax;
+
+    /* All the different kind of well known type messages. For simplicity of check,
+     * number wrappers and string wrappers are grouped together. Make sure the
+     * order and merber of these groups are not changed.
+     */
+    typedef enum
+    {
+        kUpb_WellKnown_Unspecified,
+        kUpb_WellKnown_Any,
+        kUpb_WellKnown_FieldMask,
+        kUpb_WellKnown_Duration,
+        kUpb_WellKnown_Timestamp,
+        /* number wrappers */
+        kUpb_WellKnown_DoubleValue,
+        kUpb_WellKnown_FloatValue,
+        kUpb_WellKnown_Int64Value,
+        kUpb_WellKnown_UInt64Value,
+        kUpb_WellKnown_Int32Value,
+        kUpb_WellKnown_UInt32Value,
+        /* string wrappers */
+        kUpb_WellKnown_StringValue,
+        kUpb_WellKnown_BytesValue,
+        kUpb_WellKnown_BoolValue,
+        kUpb_WellKnown_Value,
+        kUpb_WellKnown_ListValue,
+        kUpb_WellKnown_Struct
+    } upb_WellKnown;
 
 /* upb_FieldDef ***************************************************************/
 
@@ -96,65 +102,63 @@ typedef enum {
  * protobuf wire format. */
 #define kUpb_MaxFieldNumber ((1 << 29) - 1)
 
-const google_protobuf_FieldOptions* upb_FieldDef_Options(const upb_FieldDef* f);
-bool upb_FieldDef_HasOptions(const upb_FieldDef* f);
-const char* upb_FieldDef_FullName(const upb_FieldDef* f);
-upb_CType upb_FieldDef_CType(const upb_FieldDef* f);
-upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f);
-upb_Label upb_FieldDef_Label(const upb_FieldDef* f);
-uint32_t upb_FieldDef_Number(const upb_FieldDef* f);
-const char* upb_FieldDef_Name(const upb_FieldDef* f);
-const char* upb_FieldDef_JsonName(const upb_FieldDef* f);
-bool upb_FieldDef_HasJsonName(const upb_FieldDef* f);
-bool upb_FieldDef_IsExtension(const upb_FieldDef* f);
-bool upb_FieldDef_IsPacked(const upb_FieldDef* f);
-const upb_FileDef* upb_FieldDef_File(const upb_FieldDef* f);
-const upb_MessageDef* upb_FieldDef_ContainingType(const upb_FieldDef* f);
-const upb_MessageDef* upb_FieldDef_ExtensionScope(const upb_FieldDef* f);
-const upb_OneofDef* upb_FieldDef_ContainingOneof(const upb_FieldDef* f);
-const upb_OneofDef* upb_FieldDef_RealContainingOneof(const upb_FieldDef* f);
-uint32_t upb_FieldDef_Index(const upb_FieldDef* f);
-bool upb_FieldDef_IsSubMessage(const upb_FieldDef* f);
-bool upb_FieldDef_IsString(const upb_FieldDef* f);
-bool upb_FieldDef_IsOptional(const upb_FieldDef* f);
-bool upb_FieldDef_IsRequired(const upb_FieldDef* f);
-bool upb_FieldDef_IsRepeated(const upb_FieldDef* f);
-bool upb_FieldDef_IsPrimitive(const upb_FieldDef* f);
-bool upb_FieldDef_IsMap(const upb_FieldDef* f);
-bool upb_FieldDef_HasDefault(const upb_FieldDef* f);
-bool upb_FieldDef_HasSubDef(const upb_FieldDef* f);
-bool upb_FieldDef_HasPresence(const upb_FieldDef* f);
-const upb_MessageDef* upb_FieldDef_MessageSubDef(const upb_FieldDef* f);
-const upb_EnumDef* upb_FieldDef_EnumSubDef(const upb_FieldDef* f);
-const upb_MiniTable_Field* upb_FieldDef_MiniTable(const upb_FieldDef* f);
-const upb_MiniTable_Extension* _upb_FieldDef_ExtensionMiniTable(
-    const upb_FieldDef* f);
-bool _upb_FieldDef_IsProto3Optional(const upb_FieldDef* f);
-
-/* upb_OneofDef ***************************************************************/
-
-const google_protobuf_OneofOptions* upb_OneofDef_Options(const upb_OneofDef* o);
-bool upb_OneofDef_HasOptions(const upb_OneofDef* o);
-const char* upb_OneofDef_Name(const upb_OneofDef* o);
-const upb_MessageDef* upb_OneofDef_ContainingType(const upb_OneofDef* o);
-uint32_t upb_OneofDef_Index(const upb_OneofDef* o);
-bool upb_OneofDef_IsSynthetic(const upb_OneofDef* o);
-int upb_OneofDef_FieldCount(const upb_OneofDef* o);
-const upb_FieldDef* upb_OneofDef_Field(const upb_OneofDef* o, int i);
-
-/* Oneof lookups:
- * - ntof:  look up a field by name.
- * - ntofz: look up a field by name (as a null-terminated string).
- * - itof:  look up a field by number. */
-const upb_FieldDef* upb_OneofDef_LookupNameWithSize(const upb_OneofDef* o,
-                                                    const char* name,
-                                                    size_t length);
-UPB_INLINE const upb_FieldDef* upb_OneofDef_LookupName(const upb_OneofDef* o,
-                                                       const char* name) {
-  return upb_OneofDef_LookupNameWithSize(o, name, strlen(name));
-}
-const upb_FieldDef* upb_OneofDef_LookupNumber(const upb_OneofDef* o,
-                                              uint32_t num);
+    const google_protobuf_FieldOptions* upb_FieldDef_Options(const upb_FieldDef* f);
+    bool upb_FieldDef_HasOptions(const upb_FieldDef* f);
+    const char* upb_FieldDef_FullName(const upb_FieldDef* f);
+    upb_CType upb_FieldDef_CType(const upb_FieldDef* f);
+    upb_FieldType upb_FieldDef_Type(const upb_FieldDef* f);
+    upb_Label upb_FieldDef_Label(const upb_FieldDef* f);
+    uint32_t upb_FieldDef_Number(const upb_FieldDef* f);
+    const char* upb_FieldDef_Name(const upb_FieldDef* f);
+    const char* upb_FieldDef_JsonName(const upb_FieldDef* f);
+    bool upb_FieldDef_HasJsonName(const upb_FieldDef* f);
+    bool upb_FieldDef_IsExtension(const upb_FieldDef* f);
+    bool upb_FieldDef_IsPacked(const upb_FieldDef* f);
+    const upb_FileDef* upb_FieldDef_File(const upb_FieldDef* f);
+    const upb_MessageDef* upb_FieldDef_ContainingType(const upb_FieldDef* f);
+    const upb_MessageDef* upb_FieldDef_ExtensionScope(const upb_FieldDef* f);
+    const upb_OneofDef* upb_FieldDef_ContainingOneof(const upb_FieldDef* f);
+    const upb_OneofDef* upb_FieldDef_RealContainingOneof(const upb_FieldDef* f);
+    uint32_t upb_FieldDef_Index(const upb_FieldDef* f);
+    bool upb_FieldDef_IsSubMessage(const upb_FieldDef* f);
+    bool upb_FieldDef_IsString(const upb_FieldDef* f);
+    bool upb_FieldDef_IsOptional(const upb_FieldDef* f);
+    bool upb_FieldDef_IsRequired(const upb_FieldDef* f);
+    bool upb_FieldDef_IsRepeated(const upb_FieldDef* f);
+    bool upb_FieldDef_IsPrimitive(const upb_FieldDef* f);
+    bool upb_FieldDef_IsMap(const upb_FieldDef* f);
+    bool upb_FieldDef_HasDefault(const upb_FieldDef* f);
+    bool upb_FieldDef_HasSubDef(const upb_FieldDef* f);
+    bool upb_FieldDef_HasPresence(const upb_FieldDef* f);
+    const upb_MessageDef* upb_FieldDef_MessageSubDef(const upb_FieldDef* f);
+    const upb_EnumDef* upb_FieldDef_EnumSubDef(const upb_FieldDef* f);
+    const upb_MiniTable_Field* upb_FieldDef_MiniTable(const upb_FieldDef* f);
+    const upb_MiniTable_Extension* _upb_FieldDef_ExtensionMiniTable(
+        const upb_FieldDef* f
+    );
+    bool _upb_FieldDef_IsProto3Optional(const upb_FieldDef* f);
+
+    /* upb_OneofDef ***************************************************************/
+
+    const google_protobuf_OneofOptions* upb_OneofDef_Options(const upb_OneofDef* o);
+    bool upb_OneofDef_HasOptions(const upb_OneofDef* o);
+    const char* upb_OneofDef_Name(const upb_OneofDef* o);
+    const upb_MessageDef* upb_OneofDef_ContainingType(const upb_OneofDef* o);
+    uint32_t upb_OneofDef_Index(const upb_OneofDef* o);
+    bool upb_OneofDef_IsSynthetic(const upb_OneofDef* o);
+    int upb_OneofDef_FieldCount(const upb_OneofDef* o);
+    const upb_FieldDef* upb_OneofDef_Field(const upb_OneofDef* o, int i);
+
+    /* Oneof lookups:
+     * - ntof:  look up a field by name.
+     * - ntofz: look up a field by name (as a null-terminated string).
+     * - itof:  look up a field by number. */
+    const upb_FieldDef* upb_OneofDef_LookupNameWithSize(const upb_OneofDef* o, const char* name, size_t length);
+    UPB_INLINE const upb_FieldDef* upb_OneofDef_LookupName(const upb_OneofDef* o, const char* name)
+    {
+        return upb_OneofDef_LookupNameWithSize(o, name, strlen(name));
+    }
+    const upb_FieldDef* upb_OneofDef_LookupNumber(const upb_OneofDef* o, uint32_t num);
 
 /* upb_MessageDef *************************************************************/
 
@@ -174,238 +178,239 @@ const upb_FieldDef* upb_OneofDef_LookupNumber(const upb_OneofDef* o,
 #define kUpb_Timestamp_SecondsFieldNumber 1
 #define kUpb_Timestamp_NanosFieldNumber 2
 
-const google_protobuf_MessageOptions* upb_MessageDef_Options(
-    const upb_MessageDef* m);
-bool upb_MessageDef_HasOptions(const upb_MessageDef* m);
-const char* upb_MessageDef_FullName(const upb_MessageDef* m);
-const upb_FileDef* upb_MessageDef_File(const upb_MessageDef* m);
-const upb_MessageDef* upb_MessageDef_ContainingType(const upb_MessageDef* m);
-const char* upb_MessageDef_Name(const upb_MessageDef* m);
-upb_Syntax upb_MessageDef_Syntax(const upb_MessageDef* m);
-upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m);
-int upb_MessageDef_ExtensionRangeCount(const upb_MessageDef* m);
-int upb_MessageDef_FieldCount(const upb_MessageDef* m);
-int upb_MessageDef_OneofCount(const upb_MessageDef* m);
-const upb_ExtensionRange* upb_MessageDef_ExtensionRange(const upb_MessageDef* m,
-                                                        int i);
-const upb_FieldDef* upb_MessageDef_Field(const upb_MessageDef* m, int i);
-const upb_OneofDef* upb_MessageDef_Oneof(const upb_MessageDef* m, int i);
-const upb_FieldDef* upb_MessageDef_FindFieldByNumber(const upb_MessageDef* m,
-                                                     uint32_t i);
-const upb_FieldDef* upb_MessageDef_FindFieldByNameWithSize(
-    const upb_MessageDef* m, const char* name, size_t len);
-const upb_OneofDef* upb_MessageDef_FindOneofByNameWithSize(
-    const upb_MessageDef* m, const char* name, size_t len);
-const upb_MiniTable* upb_MessageDef_MiniTable(const upb_MessageDef* m);
-
-UPB_INLINE const upb_OneofDef* upb_MessageDef_FindOneofByName(
-    const upb_MessageDef* m, const char* name) {
-  return upb_MessageDef_FindOneofByNameWithSize(m, name, strlen(name));
-}
-
-UPB_INLINE const upb_FieldDef* upb_MessageDef_FindFieldByName(
-    const upb_MessageDef* m, const char* name) {
-  return upb_MessageDef_FindFieldByNameWithSize(m, name, strlen(name));
-}
-
-UPB_INLINE bool upb_MessageDef_IsMapEntry(const upb_MessageDef* m) {
-  return google_protobuf_MessageOptions_map_entry(upb_MessageDef_Options(m));
-}
-
-UPB_INLINE bool upb_MessageDef_IsMessageSet(const upb_MessageDef* m) {
-  return google_protobuf_MessageOptions_message_set_wire_format(
-      upb_MessageDef_Options(m));
-}
-
-/* Nested entities. */
-int upb_MessageDef_NestedMessageCount(const upb_MessageDef* m);
-int upb_MessageDef_NestedEnumCount(const upb_MessageDef* m);
-int upb_MessageDef_NestedExtensionCount(const upb_MessageDef* m);
-const upb_MessageDef* upb_MessageDef_NestedMessage(const upb_MessageDef* m,
-                                                   int i);
-const upb_EnumDef* upb_MessageDef_NestedEnum(const upb_MessageDef* m, int i);
-const upb_FieldDef* upb_MessageDef_NestedExtension(const upb_MessageDef* m,
-                                                   int i);
-
-/* Lookup of either field or oneof by name.  Returns whether either was found.
- * If the return is true, then the found def will be set, and the non-found
- * one set to NULL. */
-bool upb_MessageDef_FindByNameWithSize(const upb_MessageDef* m,
-                                       const char* name, size_t len,
-                                       const upb_FieldDef** f,
-                                       const upb_OneofDef** o);
-
-UPB_INLINE bool upb_MessageDef_FindByName(const upb_MessageDef* m,
-                                          const char* name,
-                                          const upb_FieldDef** f,
-                                          const upb_OneofDef** o) {
-  return upb_MessageDef_FindByNameWithSize(m, name, strlen(name), f, o);
-}
-
-/* Returns a field by either JSON name or regular proto name. */
-const upb_FieldDef* upb_MessageDef_FindByJsonNameWithSize(
-    const upb_MessageDef* m, const char* name, size_t len);
-UPB_INLINE const upb_FieldDef* upb_MessageDef_FindByJsonName(
-    const upb_MessageDef* m, const char* name) {
-  return upb_MessageDef_FindByJsonNameWithSize(m, name, strlen(name));
-}
-
-/* upb_ExtensionRange *********************************************************/
-
-const google_protobuf_ExtensionRangeOptions* upb_ExtensionRange_Options(
-    const upb_ExtensionRange* r);
-bool upb_ExtensionRange_HasOptions(const upb_ExtensionRange* r);
-int32_t upb_ExtensionRange_Start(const upb_ExtensionRange* r);
-int32_t upb_ExtensionRange_End(const upb_ExtensionRange* r);
-
-/* upb_EnumDef ****************************************************************/
-
-const google_protobuf_EnumOptions* upb_EnumDef_Options(const upb_EnumDef* e);
-bool upb_EnumDef_HasOptions(const upb_EnumDef* e);
-const char* upb_EnumDef_FullName(const upb_EnumDef* e);
-const char* upb_EnumDef_Name(const upb_EnumDef* e);
-const upb_FileDef* upb_EnumDef_File(const upb_EnumDef* e);
-const upb_MessageDef* upb_EnumDef_ContainingType(const upb_EnumDef* e);
-int32_t upb_EnumDef_Default(const upb_EnumDef* e);
-int upb_EnumDef_ValueCount(const upb_EnumDef* e);
-const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i);
-
-const upb_EnumValueDef* upb_EnumDef_FindValueByNameWithSize(
-    const upb_EnumDef* e, const char* name, size_t len);
-const upb_EnumValueDef* upb_EnumDef_FindValueByNumber(const upb_EnumDef* e,
-                                                      int32_t num);
-bool upb_EnumDef_CheckNumber(const upb_EnumDef* e, int32_t num);
-
-// Convenience wrapper.
-UPB_INLINE const upb_EnumValueDef* upb_EnumDef_FindValueByName(
-    const upb_EnumDef* e, const char* name) {
-  return upb_EnumDef_FindValueByNameWithSize(e, name, strlen(name));
-}
-
-/* upb_EnumValueDef ***********************************************************/
-
-const google_protobuf_EnumValueOptions* upb_EnumValueDef_Options(
-    const upb_EnumValueDef* e);
-bool upb_EnumValueDef_HasOptions(const upb_EnumValueDef* e);
-const char* upb_EnumValueDef_FullName(const upb_EnumValueDef* e);
-const char* upb_EnumValueDef_Name(const upb_EnumValueDef* e);
-int32_t upb_EnumValueDef_Number(const upb_EnumValueDef* e);
-uint32_t upb_EnumValueDef_Index(const upb_EnumValueDef* e);
-const upb_EnumDef* upb_EnumValueDef_Enum(const upb_EnumValueDef* e);
-
-/* upb_FileDef ****************************************************************/
-
-const google_protobuf_FileOptions* upb_FileDef_Options(const upb_FileDef* f);
-bool upb_FileDef_HasOptions(const upb_FileDef* f);
-const char* upb_FileDef_Name(const upb_FileDef* f);
-const char* upb_FileDef_Package(const upb_FileDef* f);
-upb_Syntax upb_FileDef_Syntax(const upb_FileDef* f);
-int upb_FileDef_DependencyCount(const upb_FileDef* f);
-int upb_FileDef_PublicDependencyCount(const upb_FileDef* f);
-int upb_FileDef_WeakDependencyCount(const upb_FileDef* f);
-int upb_FileDef_TopLevelMessageCount(const upb_FileDef* f);
-int upb_FileDef_TopLevelEnumCount(const upb_FileDef* f);
-int upb_FileDef_TopLevelExtensionCount(const upb_FileDef* f);
-int upb_FileDef_ServiceCount(const upb_FileDef* f);
-const upb_FileDef* upb_FileDef_Dependency(const upb_FileDef* f, int i);
-const upb_FileDef* upb_FileDef_PublicDependency(const upb_FileDef* f, int i);
-const upb_FileDef* upb_FileDef_WeakDependency(const upb_FileDef* f, int i);
-const upb_MessageDef* upb_FileDef_TopLevelMessage(const upb_FileDef* f, int i);
-const upb_EnumDef* upb_FileDef_TopLevelEnum(const upb_FileDef* f, int i);
-const upb_FieldDef* upb_FileDef_TopLevelExtension(const upb_FileDef* f, int i);
-const upb_ServiceDef* upb_FileDef_Service(const upb_FileDef* f, int i);
-const upb_DefPool* upb_FileDef_Pool(const upb_FileDef* f);
-const int32_t* _upb_FileDef_PublicDependencyIndexes(const upb_FileDef* f);
-const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f);
-
-/* upb_MethodDef **************************************************************/
-
-const google_protobuf_MethodOptions* upb_MethodDef_Options(
-    const upb_MethodDef* m);
-bool upb_MethodDef_HasOptions(const upb_MethodDef* m);
-const char* upb_MethodDef_FullName(const upb_MethodDef* m);
-int upb_MethodDef_Index(const upb_MethodDef* m);
-const char* upb_MethodDef_Name(const upb_MethodDef* m);
-const upb_ServiceDef* upb_MethodDef_Service(const upb_MethodDef* m);
-const upb_MessageDef* upb_MethodDef_InputType(const upb_MethodDef* m);
-const upb_MessageDef* upb_MethodDef_OutputType(const upb_MethodDef* m);
-bool upb_MethodDef_ClientStreaming(const upb_MethodDef* m);
-bool upb_MethodDef_ServerStreaming(const upb_MethodDef* m);
-
-/* upb_ServiceDef *************************************************************/
-
-const google_protobuf_ServiceOptions* upb_ServiceDef_Options(
-    const upb_ServiceDef* s);
-bool upb_ServiceDef_HasOptions(const upb_ServiceDef* s);
-const char* upb_ServiceDef_FullName(const upb_ServiceDef* s);
-const char* upb_ServiceDef_Name(const upb_ServiceDef* s);
-int upb_ServiceDef_Index(const upb_ServiceDef* s);
-const upb_FileDef* upb_ServiceDef_File(const upb_ServiceDef* s);
-int upb_ServiceDef_MethodCount(const upb_ServiceDef* s);
-const upb_MethodDef* upb_ServiceDef_Method(const upb_ServiceDef* s, int i);
-const upb_MethodDef* upb_ServiceDef_FindMethodByName(const upb_ServiceDef* s,
-                                                     const char* name);
-
-/* upb_DefPool ****************************************************************/
-
-upb_DefPool* upb_DefPool_New(void);
-void upb_DefPool_Free(upb_DefPool* s);
-const upb_MessageDef* upb_DefPool_FindMessageByName(const upb_DefPool* s,
-                                                    const char* sym);
-const upb_MessageDef* upb_DefPool_FindMessageByNameWithSize(
-    const upb_DefPool* s, const char* sym, size_t len);
-const upb_EnumDef* upb_DefPool_FindEnumByName(const upb_DefPool* s,
-                                              const char* sym);
-const upb_EnumValueDef* upb_DefPool_FindEnumByNameval(const upb_DefPool* s,
-                                                      const char* sym);
-const upb_FieldDef* upb_DefPool_FindExtensionByName(const upb_DefPool* s,
-                                                    const char* sym);
-const upb_FieldDef* upb_DefPool_FindExtensionByNameWithSize(
-    const upb_DefPool* s, const char* sym, size_t len);
-const upb_FileDef* upb_DefPool_FindFileByName(const upb_DefPool* s,
-                                              const char* name);
-const upb_ServiceDef* upb_DefPool_FindServiceByName(const upb_DefPool* s,
-                                                    const char* name);
-const upb_ServiceDef* upb_DefPool_FindServiceByNameWithSize(
-    const upb_DefPool* s, const char* name, size_t size);
-const upb_FileDef* upb_DefPool_FindFileContainingSymbol(const upb_DefPool* s,
-                                                        const char* name);
-const upb_FileDef* upb_DefPool_FindFileByNameWithSize(const upb_DefPool* s,
-                                                      const char* name,
-                                                      size_t len);
-const upb_FileDef* upb_DefPool_AddFile(
-    upb_DefPool* s, const google_protobuf_FileDescriptorProto* file,
-    upb_Status* status);
-size_t _upb_DefPool_BytesLoaded(const upb_DefPool* s);
-upb_Arena* _upb_DefPool_Arena(const upb_DefPool* s);
-const upb_FieldDef* _upb_DefPool_FindExtensionByMiniTable(
-    const upb_DefPool* s, const upb_MiniTable_Extension* ext);
-const upb_FieldDef* upb_DefPool_FindExtensionByNumber(const upb_DefPool* s,
-                                                      const upb_MessageDef* m,
-                                                      int32_t fieldnum);
-const upb_ExtensionRegistry* upb_DefPool_ExtensionRegistry(
-    const upb_DefPool* s);
-const upb_FieldDef** upb_DefPool_GetAllExtensions(const upb_DefPool* s,
-                                                  const upb_MessageDef* m,
-                                                  size_t* count);
-
-/* For generated code only: loads a generated descriptor. */
-typedef struct _upb_DefPool_Init {
-  struct _upb_DefPool_Init** deps; /* Dependencies of this file. */
-  const upb_MiniTable_File* layout;
-  const char* filename;
-  upb_StringView descriptor; /* Serialized descriptor. */
-} _upb_DefPool_Init;
-
-// Should only be directly called by tests.  This variant lets us suppress
-// the use of compiled-in tables, forcing a rebuild of the tables at runtime.
-bool _upb_DefPool_LoadDefInitEx(upb_DefPool* s, const _upb_DefPool_Init* init,
-                                bool rebuild_minitable);
-
-UPB_INLINE bool _upb_DefPool_LoadDefInit(upb_DefPool* s,
-                                         const _upb_DefPool_Init* init) {
-  return _upb_DefPool_LoadDefInitEx(s, init, false);
-}
+    const google_protobuf_MessageOptions* upb_MessageDef_Options(
+        const upb_MessageDef* m
+    );
+    bool upb_MessageDef_HasOptions(const upb_MessageDef* m);
+    const char* upb_MessageDef_FullName(const upb_MessageDef* m);
+    const upb_FileDef* upb_MessageDef_File(const upb_MessageDef* m);
+    const upb_MessageDef* upb_MessageDef_ContainingType(const upb_MessageDef* m);
+    const char* upb_MessageDef_Name(const upb_MessageDef* m);
+    upb_Syntax upb_MessageDef_Syntax(const upb_MessageDef* m);
+    upb_WellKnown upb_MessageDef_WellKnownType(const upb_MessageDef* m);
+    int upb_MessageDef_ExtensionRangeCount(const upb_MessageDef* m);
+    int upb_MessageDef_FieldCount(const upb_MessageDef* m);
+    int upb_MessageDef_OneofCount(const upb_MessageDef* m);
+    const upb_ExtensionRange* upb_MessageDef_ExtensionRange(const upb_MessageDef* m, int i);
+    const upb_FieldDef* upb_MessageDef_Field(const upb_MessageDef* m, int i);
+    const upb_OneofDef* upb_MessageDef_Oneof(const upb_MessageDef* m, int i);
+    const upb_FieldDef* upb_MessageDef_FindFieldByNumber(const upb_MessageDef* m, uint32_t i);
+    const upb_FieldDef* upb_MessageDef_FindFieldByNameWithSize(
+        const upb_MessageDef* m, const char* name, size_t len
+    );
+    const upb_OneofDef* upb_MessageDef_FindOneofByNameWithSize(
+        const upb_MessageDef* m, const char* name, size_t len
+    );
+    const upb_MiniTable* upb_MessageDef_MiniTable(const upb_MessageDef* m);
+
+    UPB_INLINE const upb_OneofDef* upb_MessageDef_FindOneofByName(
+        const upb_MessageDef* m, const char* name
+    )
+    {
+        return upb_MessageDef_FindOneofByNameWithSize(m, name, strlen(name));
+    }
+
+    UPB_INLINE const upb_FieldDef* upb_MessageDef_FindFieldByName(
+        const upb_MessageDef* m, const char* name
+    )
+    {
+        return upb_MessageDef_FindFieldByNameWithSize(m, name, strlen(name));
+    }
+
+    UPB_INLINE bool upb_MessageDef_IsMapEntry(const upb_MessageDef* m)
+    {
+        return google_protobuf_MessageOptions_map_entry(upb_MessageDef_Options(m));
+    }
+
+    UPB_INLINE bool upb_MessageDef_IsMessageSet(const upb_MessageDef* m)
+    {
+        return google_protobuf_MessageOptions_message_set_wire_format(
+            upb_MessageDef_Options(m)
+        );
+    }
+
+    /* Nested entities. */
+    int upb_MessageDef_NestedMessageCount(const upb_MessageDef* m);
+    int upb_MessageDef_NestedEnumCount(const upb_MessageDef* m);
+    int upb_MessageDef_NestedExtensionCount(const upb_MessageDef* m);
+    const upb_MessageDef* upb_MessageDef_NestedMessage(const upb_MessageDef* m, int i);
+    const upb_EnumDef* upb_MessageDef_NestedEnum(const upb_MessageDef* m, int i);
+    const upb_FieldDef* upb_MessageDef_NestedExtension(const upb_MessageDef* m, int i);
+
+    /* Lookup of either field or oneof by name.  Returns whether either was found.
+     * If the return is true, then the found def will be set, and the non-found
+     * one set to NULL. */
+    bool upb_MessageDef_FindByNameWithSize(const upb_MessageDef* m, const char* name, size_t len, const upb_FieldDef** f, const upb_OneofDef** o);
+
+    UPB_INLINE bool upb_MessageDef_FindByName(const upb_MessageDef* m, const char* name, const upb_FieldDef** f, const upb_OneofDef** o)
+    {
+        return upb_MessageDef_FindByNameWithSize(m, name, strlen(name), f, o);
+    }
+
+    /* Returns a field by either JSON name or regular proto name. */
+    const upb_FieldDef* upb_MessageDef_FindByJsonNameWithSize(
+        const upb_MessageDef* m, const char* name, size_t len
+    );
+    UPB_INLINE const upb_FieldDef* upb_MessageDef_FindByJsonName(
+        const upb_MessageDef* m, const char* name
+    )
+    {
+        return upb_MessageDef_FindByJsonNameWithSize(m, name, strlen(name));
+    }
+
+    /* upb_ExtensionRange *********************************************************/
+
+    const google_protobuf_ExtensionRangeOptions* upb_ExtensionRange_Options(
+        const upb_ExtensionRange* r
+    );
+    bool upb_ExtensionRange_HasOptions(const upb_ExtensionRange* r);
+    int32_t upb_ExtensionRange_Start(const upb_ExtensionRange* r);
+    int32_t upb_ExtensionRange_End(const upb_ExtensionRange* r);
+
+    /* upb_EnumDef ****************************************************************/
+
+    const google_protobuf_EnumOptions* upb_EnumDef_Options(const upb_EnumDef* e);
+    bool upb_EnumDef_HasOptions(const upb_EnumDef* e);
+    const char* upb_EnumDef_FullName(const upb_EnumDef* e);
+    const char* upb_EnumDef_Name(const upb_EnumDef* e);
+    const upb_FileDef* upb_EnumDef_File(const upb_EnumDef* e);
+    const upb_MessageDef* upb_EnumDef_ContainingType(const upb_EnumDef* e);
+    int32_t upb_EnumDef_Default(const upb_EnumDef* e);
+    int upb_EnumDef_ValueCount(const upb_EnumDef* e);
+    const upb_EnumValueDef* upb_EnumDef_Value(const upb_EnumDef* e, int i);
+
+    const upb_EnumValueDef* upb_EnumDef_FindValueByNameWithSize(
+        const upb_EnumDef* e, const char* name, size_t len
+    );
+    const upb_EnumValueDef* upb_EnumDef_FindValueByNumber(const upb_EnumDef* e, int32_t num);
+    bool upb_EnumDef_CheckNumber(const upb_EnumDef* e, int32_t num);
+
+    // Convenience wrapper.
+    UPB_INLINE const upb_EnumValueDef* upb_EnumDef_FindValueByName(
+        const upb_EnumDef* e, const char* name
+    )
+    {
+        return upb_EnumDef_FindValueByNameWithSize(e, name, strlen(name));
+    }
+
+    /* upb_EnumValueDef ***********************************************************/
+
+    const google_protobuf_EnumValueOptions* upb_EnumValueDef_Options(
+        const upb_EnumValueDef* e
+    );
+    bool upb_EnumValueDef_HasOptions(const upb_EnumValueDef* e);
+    const char* upb_EnumValueDef_FullName(const upb_EnumValueDef* e);
+    const char* upb_EnumValueDef_Name(const upb_EnumValueDef* e);
+    int32_t upb_EnumValueDef_Number(const upb_EnumValueDef* e);
+    uint32_t upb_EnumValueDef_Index(const upb_EnumValueDef* e);
+    const upb_EnumDef* upb_EnumValueDef_Enum(const upb_EnumValueDef* e);
+
+    /* upb_FileDef ****************************************************************/
+
+    const google_protobuf_FileOptions* upb_FileDef_Options(const upb_FileDef* f);
+    bool upb_FileDef_HasOptions(const upb_FileDef* f);
+    const char* upb_FileDef_Name(const upb_FileDef* f);
+    const char* upb_FileDef_Package(const upb_FileDef* f);
+    upb_Syntax upb_FileDef_Syntax(const upb_FileDef* f);
+    int upb_FileDef_DependencyCount(const upb_FileDef* f);
+    int upb_FileDef_PublicDependencyCount(const upb_FileDef* f);
+    int upb_FileDef_WeakDependencyCount(const upb_FileDef* f);
+    int upb_FileDef_TopLevelMessageCount(const upb_FileDef* f);
+    int upb_FileDef_TopLevelEnumCount(const upb_FileDef* f);
+    int upb_FileDef_TopLevelExtensionCount(const upb_FileDef* f);
+    int upb_FileDef_ServiceCount(const upb_FileDef* f);
+    const upb_FileDef* upb_FileDef_Dependency(const upb_FileDef* f, int i);
+    const upb_FileDef* upb_FileDef_PublicDependency(const upb_FileDef* f, int i);
+    const upb_FileDef* upb_FileDef_WeakDependency(const upb_FileDef* f, int i);
+    const upb_MessageDef* upb_FileDef_TopLevelMessage(const upb_FileDef* f, int i);
+    const upb_EnumDef* upb_FileDef_TopLevelEnum(const upb_FileDef* f, int i);
+    const upb_FieldDef* upb_FileDef_TopLevelExtension(const upb_FileDef* f, int i);
+    const upb_ServiceDef* upb_FileDef_Service(const upb_FileDef* f, int i);
+    const upb_DefPool* upb_FileDef_Pool(const upb_FileDef* f);
+    const int32_t* _upb_FileDef_PublicDependencyIndexes(const upb_FileDef* f);
+    const int32_t* _upb_FileDef_WeakDependencyIndexes(const upb_FileDef* f);
+
+    /* upb_MethodDef **************************************************************/
+
+    const google_protobuf_MethodOptions* upb_MethodDef_Options(
+        const upb_MethodDef* m
+    );
+    bool upb_MethodDef_HasOptions(const upb_MethodDef* m);
+    const char* upb_MethodDef_FullName(const upb_MethodDef* m);
+    int upb_MethodDef_Index(const upb_MethodDef* m);
+    const char* upb_MethodDef_Name(const upb_MethodDef* m);
+    const upb_ServiceDef* upb_MethodDef_Service(const upb_MethodDef* m);
+    const upb_MessageDef* upb_MethodDef_InputType(const upb_MethodDef* m);
+    const upb_MessageDef* upb_MethodDef_OutputType(const upb_MethodDef* m);
+    bool upb_MethodDef_ClientStreaming(const upb_MethodDef* m);
+    bool upb_MethodDef_ServerStreaming(const upb_MethodDef* m);
+
+    /* upb_ServiceDef *************************************************************/
+
+    const google_protobuf_ServiceOptions* upb_ServiceDef_Options(
+        const upb_ServiceDef* s
+    );
+    bool upb_ServiceDef_HasOptions(const upb_ServiceDef* s);
+    const char* upb_ServiceDef_FullName(const upb_ServiceDef* s);
+    const char* upb_ServiceDef_Name(const upb_ServiceDef* s);
+    int upb_ServiceDef_Index(const upb_ServiceDef* s);
+    const upb_FileDef* upb_ServiceDef_File(const upb_ServiceDef* s);
+    int upb_ServiceDef_MethodCount(const upb_ServiceDef* s);
+    const upb_MethodDef* upb_ServiceDef_Method(const upb_ServiceDef* s, int i);
+    const upb_MethodDef* upb_ServiceDef_FindMethodByName(const upb_ServiceDef* s, const char* name);
+
+    /* upb_DefPool ****************************************************************/
+
+    upb_DefPool* upb_DefPool_New(void);
+    void upb_DefPool_Free(upb_DefPool* s);
+    const upb_MessageDef* upb_DefPool_FindMessageByName(const upb_DefPool* s, const char* sym);
+    const upb_MessageDef* upb_DefPool_FindMessageByNameWithSize(
+        const upb_DefPool* s, const char* sym, size_t len
+    );
+    const upb_EnumDef* upb_DefPool_FindEnumByName(const upb_DefPool* s, const char* sym);
+    const upb_EnumValueDef* upb_DefPool_FindEnumByNameval(const upb_DefPool* s, const char* sym);
+    const upb_FieldDef* upb_DefPool_FindExtensionByName(const upb_DefPool* s, const char* sym);
+    const upb_FieldDef* upb_DefPool_FindExtensionByNameWithSize(
+        const upb_DefPool* s, const char* sym, size_t len
+    );
+    const upb_FileDef* upb_DefPool_FindFileByName(const upb_DefPool* s, const char* name);
+    const upb_ServiceDef* upb_DefPool_FindServiceByName(const upb_DefPool* s, const char* name);
+    const upb_ServiceDef* upb_DefPool_FindServiceByNameWithSize(
+        const upb_DefPool* s, const char* name, size_t size
+    );
+    const upb_FileDef* upb_DefPool_FindFileContainingSymbol(const upb_DefPool* s, const char* name);
+    const upb_FileDef* upb_DefPool_FindFileByNameWithSize(const upb_DefPool* s, const char* name, size_t len);
+    const upb_FileDef* upb_DefPool_AddFile(
+        upb_DefPool* s, const google_protobuf_FileDescriptorProto* file, upb_Status* status
+    );
+    size_t _upb_DefPool_BytesLoaded(const upb_DefPool* s);
+    upb_Arena* _upb_DefPool_Arena(const upb_DefPool* s);
+    const upb_FieldDef* _upb_DefPool_FindExtensionByMiniTable(
+        const upb_DefPool* s, const upb_MiniTable_Extension* ext
+    );
+    const upb_FieldDef* upb_DefPool_FindExtensionByNumber(const upb_DefPool* s, const upb_MessageDef* m, int32_t fieldnum);
+    const upb_ExtensionRegistry* upb_DefPool_ExtensionRegistry(
+        const upb_DefPool* s
+    );
+    const upb_FieldDef** upb_DefPool_GetAllExtensions(const upb_DefPool* s, const upb_MessageDef* m, size_t* count);
+
+    /* For generated code only: loads a generated descriptor. */
+    typedef struct _upb_DefPool_Init
+    {
+        struct _upb_DefPool_Init** deps; /* Dependencies of this file. */
+        const upb_MiniTable_File* layout;
+        const char* filename;
+        upb_StringView descriptor; /* Serialized descriptor. */
+    } _upb_DefPool_Init;
+
+    // Should only be directly called by tests.  This variant lets us suppress
+    // the use of compiled-in tables, forcing a rebuild of the tables at runtime.
+    bool _upb_DefPool_LoadDefInitEx(upb_DefPool* s, const _upb_DefPool_Init* init, bool rebuild_minitable);
+
+    UPB_INLINE bool _upb_DefPool_LoadDefInit(upb_DefPool* s, const _upb_DefPool_Init* init)
+    {
+        return _upb_DefPool_LoadDefInitEx(s, init, false);
+    }
 
 #include "upb/port_undef.inc"
 
diff --git a/CAPI/cpp/grpc/include/upb/def.hpp b/CAPI/cpp/grpc/include/upb/def.hpp
index 49cc560..ce7d915 100644
--- a/CAPI/cpp/grpc/include/upb/def.hpp
+++ b/CAPI/cpp/grpc/include/upb/def.hpp
@@ -35,406 +35,678 @@
 #include "upb/reflection.h"
 #include "upb/upb.hpp"
 
-namespace upb {
-
-typedef upb_MessageValue MessageValue;
-
-class EnumDefPtr;
-class FileDefPtr;
-class MessageDefPtr;
-class OneofDefPtr;
-
-// A upb::FieldDefPtr describes a single field in a message.  It is most often
-// found as a part of a upb_MessageDef, but can also stand alone to represent
-// an extension.
-class FieldDefPtr {
- public:
-  FieldDefPtr() : ptr_(nullptr) {}
-  explicit FieldDefPtr(const upb_FieldDef* ptr) : ptr_(ptr) {}
-
-  const upb_FieldDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  typedef upb_CType Type;
-  typedef upb_Label Label;
-  typedef upb_FieldType DescriptorType;
-
-  const char* full_name() const { return upb_FieldDef_FullName(ptr_); }
-
-  Type type() const { return upb_FieldDef_CType(ptr_); }
-  Label label() const { return upb_FieldDef_Label(ptr_); }
-  const char* name() const { return upb_FieldDef_Name(ptr_); }
-  const char* json_name() const { return upb_FieldDef_JsonName(ptr_); }
-  uint32_t number() const { return upb_FieldDef_Number(ptr_); }
-  bool is_extension() const { return upb_FieldDef_IsExtension(ptr_); }
-
-  // For non-string, non-submessage fields, this indicates whether binary
-  // protobufs are encoded in packed or non-packed format.
-  //
-  // Note: this accessor reflects the fact that "packed" has different defaults
-  // depending on whether the proto is proto2 or proto3.
-  bool packed() const { return upb_FieldDef_IsPacked(ptr_); }
-
-  // An integer that can be used as an index into an array of fields for
-  // whatever message this field belongs to.  Guaranteed to be less than
-  // f->containing_type()->field_count().  May only be accessed once the def has
-  // been finalized.
-  uint32_t index() const { return upb_FieldDef_Index(ptr_); }
-
-  // The MessageDef to which this field belongs.
-  //
-  // If this field has been added to a MessageDef, that message can be retrieved
-  // directly (this is always the case for frozen FieldDefs).
-  //
-  // If the field has not yet been added to a MessageDef, you can set the name
-  // of the containing type symbolically instead.  This is mostly useful for
-  // extensions, where the extension is declared separately from the message.
-  MessageDefPtr containing_type() const;
-
-  // The OneofDef to which this field belongs, or NULL if this field is not part
-  // of a oneof.
-  OneofDefPtr containing_oneof() const;
-
-  // The field's type according to the enum in descriptor.proto.  This is not
-  // the same as UPB_TYPE_*, because it distinguishes between (for example)
-  // INT32 and SINT32, whereas our "type" enum does not.  This return of
-  // descriptor_type() is a function of type(), integer_format(), and
-  // is_tag_delimited().
-  DescriptorType descriptor_type() const { return upb_FieldDef_Type(ptr_); }
-
-  // Convenient field type tests.
-  bool IsSubMessage() const { return upb_FieldDef_IsSubMessage(ptr_); }
-  bool IsString() const { return upb_FieldDef_IsString(ptr_); }
-  bool IsSequence() const { return upb_FieldDef_IsRepeated(ptr_); }
-  bool IsPrimitive() const { return upb_FieldDef_IsPrimitive(ptr_); }
-  bool IsMap() const { return upb_FieldDef_IsMap(ptr_); }
-
-  MessageValue default_value() const { return upb_FieldDef_Default(ptr_); }
-
-  // Returns the enum or submessage def for this field, if any.  The field's
-  // type must match (ie. you may only call enum_subdef() for fields where
-  // type() == kUpb_CType_Enum).
-  EnumDefPtr enum_subdef() const;
-  MessageDefPtr message_subdef() const;
-
- private:
-  const upb_FieldDef* ptr_;
-};
-
-// Class that represents a oneof.
-class OneofDefPtr {
- public:
-  OneofDefPtr() : ptr_(nullptr) {}
-  explicit OneofDefPtr(const upb_OneofDef* ptr) : ptr_(ptr) {}
-
-  const upb_OneofDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  // Returns the MessageDef that contains this OneofDef.
-  MessageDefPtr containing_type() const;
-
-  // Returns the name of this oneof.
-  const char* name() const { return upb_OneofDef_Name(ptr_); }
-
-  // Returns the number of fields in the oneof.
-  int field_count() const { return upb_OneofDef_FieldCount(ptr_); }
-  FieldDefPtr field(int i) const {
-    return FieldDefPtr(upb_OneofDef_Field(ptr_, i));
-  }
-
-  // Looks up by name.
-  FieldDefPtr FindFieldByName(const char* name, size_t len) const {
-    return FieldDefPtr(upb_OneofDef_LookupNameWithSize(ptr_, name, len));
-  }
-  FieldDefPtr FindFieldByName(const char* name) const {
-    return FieldDefPtr(upb_OneofDef_LookupName(ptr_, name));
-  }
-
-  template <class T>
-  FieldDefPtr FindFieldByName(const T& str) const {
-    return FindFieldByName(str.c_str(), str.size());
-  }
-
-  // Looks up by tag number.
-  FieldDefPtr FindFieldByNumber(uint32_t num) const {
-    return FieldDefPtr(upb_OneofDef_LookupNumber(ptr_, num));
-  }
-
- private:
-  const upb_OneofDef* ptr_;
-};
-
-// Structure that describes a single .proto message type.
-class MessageDefPtr {
- public:
-  MessageDefPtr() : ptr_(nullptr) {}
-  explicit MessageDefPtr(const upb_MessageDef* ptr) : ptr_(ptr) {}
-
-  const upb_MessageDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  FileDefPtr file() const;
-
-  const char* full_name() const { return upb_MessageDef_FullName(ptr_); }
-  const char* name() const { return upb_MessageDef_Name(ptr_); }
-
-  // The number of fields that belong to the MessageDef.
-  int field_count() const { return upb_MessageDef_FieldCount(ptr_); }
-  FieldDefPtr field(int i) const {
-    return FieldDefPtr(upb_MessageDef_Field(ptr_, i));
-  }
-
-  // The number of oneofs that belong to the MessageDef.
-  int oneof_count() const { return upb_MessageDef_OneofCount(ptr_); }
-  OneofDefPtr oneof(int i) const {
-    return OneofDefPtr(upb_MessageDef_Oneof(ptr_, i));
-  }
-
-  upb_Syntax syntax() const { return upb_MessageDef_Syntax(ptr_); }
-
-  // These return null pointers if the field is not found.
-  FieldDefPtr FindFieldByNumber(uint32_t number) const {
-    return FieldDefPtr(upb_MessageDef_FindFieldByNumber(ptr_, number));
-  }
-  FieldDefPtr FindFieldByName(const char* name, size_t len) const {
-    return FieldDefPtr(upb_MessageDef_FindFieldByNameWithSize(ptr_, name, len));
-  }
-  FieldDefPtr FindFieldByName(const char* name) const {
-    return FieldDefPtr(upb_MessageDef_FindFieldByName(ptr_, name));
-  }
-
-  template <class T>
-  FieldDefPtr FindFieldByName(const T& str) const {
-    return FindFieldByName(str.c_str(), str.size());
-  }
-
-  OneofDefPtr FindOneofByName(const char* name, size_t len) const {
-    return OneofDefPtr(upb_MessageDef_FindOneofByNameWithSize(ptr_, name, len));
-  }
-
-  OneofDefPtr FindOneofByName(const char* name) const {
-    return OneofDefPtr(upb_MessageDef_FindOneofByName(ptr_, name));
-  }
-
-  template <class T>
-  OneofDefPtr FindOneofByName(const T& str) const {
-    return FindOneofByName(str.c_str(), str.size());
-  }
-
-  // Is this message a map entry?
-  bool mapentry() const { return upb_MessageDef_IsMapEntry(ptr_); }
-
-  // Return the type of well known type message. kUpb_WellKnown_Unspecified for
-  // non-well-known message.
-  upb_WellKnown wellknowntype() const {
-    return upb_MessageDef_WellKnownType(ptr_);
-  }
-
- private:
-  class FieldIter {
-   public:
-    explicit FieldIter(const upb_MessageDef* m, int i) : m_(m), i_(i) {}
-    void operator++() { i_++; }
-
-    FieldDefPtr operator*() {
-      return FieldDefPtr(upb_MessageDef_Field(m_, i_));
+namespace upb
+{
+
+    typedef upb_MessageValue MessageValue;
+
+    class EnumDefPtr;
+    class FileDefPtr;
+    class MessageDefPtr;
+    class OneofDefPtr;
+
+    // A upb::FieldDefPtr describes a single field in a message.  It is most often
+    // found as a part of a upb_MessageDef, but can also stand alone to represent
+    // an extension.
+    class FieldDefPtr
+    {
+    public:
+        FieldDefPtr() :
+            ptr_(nullptr)
+        {
+        }
+        explicit FieldDefPtr(const upb_FieldDef* ptr) :
+            ptr_(ptr)
+        {
+        }
+
+        const upb_FieldDef* ptr() const
+        {
+            return ptr_;
+        }
+        explicit operator bool() const
+        {
+            return ptr_ != nullptr;
+        }
+
+        typedef upb_CType Type;
+        typedef upb_Label Label;
+        typedef upb_FieldType DescriptorType;
+
+        const char* full_name() const
+        {
+            return upb_FieldDef_FullName(ptr_);
+        }
+
+        Type type() const
+        {
+            return upb_FieldDef_CType(ptr_);
+        }
+        Label label() const
+        {
+            return upb_FieldDef_Label(ptr_);
+        }
+        const char* name() const
+        {
+            return upb_FieldDef_Name(ptr_);
+        }
+        const char* json_name() const
+        {
+            return upb_FieldDef_JsonName(ptr_);
+        }
+        uint32_t number() const
+        {
+            return upb_FieldDef_Number(ptr_);
+        }
+        bool is_extension() const
+        {
+            return upb_FieldDef_IsExtension(ptr_);
+        }
+
+        // For non-string, non-submessage fields, this indicates whether binary
+        // protobufs are encoded in packed or non-packed format.
+        //
+        // Note: this accessor reflects the fact that "packed" has different defaults
+        // depending on whether the proto is proto2 or proto3.
+        bool packed() const
+        {
+            return upb_FieldDef_IsPacked(ptr_);
+        }
+
+        // An integer that can be used as an index into an array of fields for
+        // whatever message this field belongs to.  Guaranteed to be less than
+        // f->containing_type()->field_count().  May only be accessed once the def has
+        // been finalized.
+        uint32_t index() const
+        {
+            return upb_FieldDef_Index(ptr_);
+        }
+
+        // The MessageDef to which this field belongs.
+        //
+        // If this field has been added to a MessageDef, that message can be retrieved
+        // directly (this is always the case for frozen FieldDefs).
+        //
+        // If the field has not yet been added to a MessageDef, you can set the name
+        // of the containing type symbolically instead.  This is mostly useful for
+        // extensions, where the extension is declared separately from the message.
+        MessageDefPtr containing_type() const;
+
+        // The OneofDef to which this field belongs, or NULL if this field is not part
+        // of a oneof.
+        OneofDefPtr containing_oneof() const;
+
+        // The field's type according to the enum in descriptor.proto.  This is not
+        // the same as UPB_TYPE_*, because it distinguishes between (for example)
+        // INT32 and SINT32, whereas our "type" enum does not.  This return of
+        // descriptor_type() is a function of type(), integer_format(), and
+        // is_tag_delimited().
+        DescriptorType descriptor_type() const
+        {
+            return upb_FieldDef_Type(ptr_);
+        }
+
+        // Convenient field type tests.
+        bool IsSubMessage() const
+        {
+            return upb_FieldDef_IsSubMessage(ptr_);
+        }
+        bool IsString() const
+        {
+            return upb_FieldDef_IsString(ptr_);
+        }
+        bool IsSequence() const
+        {
+            return upb_FieldDef_IsRepeated(ptr_);
+        }
+        bool IsPrimitive() const
+        {
+            return upb_FieldDef_IsPrimitive(ptr_);
+        }
+        bool IsMap() const
+        {
+            return upb_FieldDef_IsMap(ptr_);
+        }
+
+        MessageValue default_value() const
+        {
+            return upb_FieldDef_Default(ptr_);
+        }
+
+        // Returns the enum or submessage def for this field, if any.  The field's
+        // type must match (ie. you may only call enum_subdef() for fields where
+        // type() == kUpb_CType_Enum).
+        EnumDefPtr enum_subdef() const;
+        MessageDefPtr message_subdef() const;
+
+    private:
+        const upb_FieldDef* ptr_;
+    };
+
+    // Class that represents a oneof.
+    class OneofDefPtr
+    {
+    public:
+        OneofDefPtr() :
+            ptr_(nullptr)
+        {
+        }
+        explicit OneofDefPtr(const upb_OneofDef* ptr) :
+            ptr_(ptr)
+        {
+        }
+
+        const upb_OneofDef* ptr() const
+        {
+            return ptr_;
+        }
+        explicit operator bool() const
+        {
+            return ptr_ != nullptr;
+        }
+
+        // Returns the MessageDef that contains this OneofDef.
+        MessageDefPtr containing_type() const;
+
+        // Returns the name of this oneof.
+        const char* name() const
+        {
+            return upb_OneofDef_Name(ptr_);
+        }
+
+        // Returns the number of fields in the oneof.
+        int field_count() const
+        {
+            return upb_OneofDef_FieldCount(ptr_);
+        }
+        FieldDefPtr field(int i) const
+        {
+            return FieldDefPtr(upb_OneofDef_Field(ptr_, i));
+        }
+
+        // Looks up by name.
+        FieldDefPtr FindFieldByName(const char* name, size_t len) const
+        {
+            return FieldDefPtr(upb_OneofDef_LookupNameWithSize(ptr_, name, len));
+        }
+        FieldDefPtr FindFieldByName(const char* name) const
+        {
+            return FieldDefPtr(upb_OneofDef_LookupName(ptr_, name));
+        }
+
+        template<class T>
+        FieldDefPtr FindFieldByName(const T& str) const
+        {
+            return FindFieldByName(str.c_str(), str.size());
+        }
+
+        // Looks up by tag number.
+        FieldDefPtr FindFieldByNumber(uint32_t num) const
+        {
+            return FieldDefPtr(upb_OneofDef_LookupNumber(ptr_, num));
+        }
+
+    private:
+        const upb_OneofDef* ptr_;
+    };
+
+    // Structure that describes a single .proto message type.
+    class MessageDefPtr
+    {
+    public:
+        MessageDefPtr() :
+            ptr_(nullptr)
+        {
+        }
+        explicit MessageDefPtr(const upb_MessageDef* ptr) :
+            ptr_(ptr)
+        {
+        }
+
+        const upb_MessageDef* ptr() const
+        {
+            return ptr_;
+        }
+        explicit operator bool() const
+        {
+            return ptr_ != nullptr;
+        }
+
+        FileDefPtr file() const;
+
+        const char* full_name() const
+        {
+            return upb_MessageDef_FullName(ptr_);
+        }
+        const char* name() const
+        {
+            return upb_MessageDef_Name(ptr_);
+        }
+
+        // The number of fields that belong to the MessageDef.
+        int field_count() const
+        {
+            return upb_MessageDef_FieldCount(ptr_);
+        }
+        FieldDefPtr field(int i) const
+        {
+            return FieldDefPtr(upb_MessageDef_Field(ptr_, i));
+        }
+
+        // The number of oneofs that belong to the MessageDef.
+        int oneof_count() const
+        {
+            return upb_MessageDef_OneofCount(ptr_);
+        }
+        OneofDefPtr oneof(int i) const
+        {
+            return OneofDefPtr(upb_MessageDef_Oneof(ptr_, i));
+        }
+
+        upb_Syntax syntax() const
+        {
+            return upb_MessageDef_Syntax(ptr_);
+        }
+
+        // These return null pointers if the field is not found.
+        FieldDefPtr FindFieldByNumber(uint32_t number) const
+        {
+            return FieldDefPtr(upb_MessageDef_FindFieldByNumber(ptr_, number));
+        }
+        FieldDefPtr FindFieldByName(const char* name, size_t len) const
+        {
+            return FieldDefPtr(upb_MessageDef_FindFieldByNameWithSize(ptr_, name, len));
+        }
+        FieldDefPtr FindFieldByName(const char* name) const
+        {
+            return FieldDefPtr(upb_MessageDef_FindFieldByName(ptr_, name));
+        }
+
+        template<class T>
+        FieldDefPtr FindFieldByName(const T& str) const
+        {
+            return FindFieldByName(str.c_str(), str.size());
+        }
+
+        OneofDefPtr FindOneofByName(const char* name, size_t len) const
+        {
+            return OneofDefPtr(upb_MessageDef_FindOneofByNameWithSize(ptr_, name, len));
+        }
+
+        OneofDefPtr FindOneofByName(const char* name) const
+        {
+            return OneofDefPtr(upb_MessageDef_FindOneofByName(ptr_, name));
+        }
+
+        template<class T>
+        OneofDefPtr FindOneofByName(const T& str) const
+        {
+            return FindOneofByName(str.c_str(), str.size());
+        }
+
+        // Is this message a map entry?
+        bool mapentry() const
+        {
+            return upb_MessageDef_IsMapEntry(ptr_);
+        }
+
+        // Return the type of well known type message. kUpb_WellKnown_Unspecified for
+        // non-well-known message.
+        upb_WellKnown wellknowntype() const
+        {
+            return upb_MessageDef_WellKnownType(ptr_);
+        }
+
+    private:
+        class FieldIter
+        {
+        public:
+            explicit FieldIter(const upb_MessageDef* m, int i) :
+                m_(m),
+                i_(i)
+            {
+            }
+            void operator++()
+            {
+                i_++;
+            }
+
+            FieldDefPtr operator*()
+            {
+                return FieldDefPtr(upb_MessageDef_Field(m_, i_));
+            }
+            bool operator!=(const FieldIter& other)
+            {
+                return i_ != other.i_;
+            }
+            bool operator==(const FieldIter& other)
+            {
+                return i_ == other.i_;
+            }
+
+        private:
+            const upb_MessageDef* m_;
+            int i_;
+        };
+
+        class FieldAccessor
+        {
+        public:
+            explicit FieldAccessor(const upb_MessageDef* md) :
+                md_(md)
+            {
+            }
+            FieldIter begin()
+            {
+                return FieldIter(md_, 0);
+            }
+            FieldIter end()
+            {
+                return FieldIter(md_, upb_MessageDef_FieldCount(md_));
+            }
+
+        private:
+            const upb_MessageDef* md_;
+        };
+
+        class OneofIter
+        {
+        public:
+            explicit OneofIter(const upb_MessageDef* m, int i) :
+                m_(m),
+                i_(i)
+            {
+            }
+            void operator++()
+            {
+                i_++;
+            }
+
+            OneofDefPtr operator*()
+            {
+                return OneofDefPtr(upb_MessageDef_Oneof(m_, i_));
+            }
+            bool operator!=(const OneofIter& other)
+            {
+                return i_ != other.i_;
+            }
+            bool operator==(const OneofIter& other)
+            {
+                return i_ == other.i_;
+            }
+
+        private:
+            const upb_MessageDef* m_;
+            int i_;
+        };
+
+        class OneofAccessor
+        {
+        public:
+            explicit OneofAccessor(const upb_MessageDef* md) :
+                md_(md)
+            {
+            }
+            OneofIter begin()
+            {
+                return OneofIter(md_, 0);
+            }
+            OneofIter end()
+            {
+                return OneofIter(md_, upb_MessageDef_OneofCount(md_));
+            }
+
+        private:
+            const upb_MessageDef* md_;
+        };
+
+    public:
+        FieldAccessor fields() const
+        {
+            return FieldAccessor(ptr());
+        }
+        OneofAccessor oneofs() const
+        {
+            return OneofAccessor(ptr());
+        }
+
+    private:
+        const upb_MessageDef* ptr_;
+    };
+
+    class EnumValDefPtr
+    {
+    public:
+        EnumValDefPtr() :
+            ptr_(nullptr)
+        {
+        }
+        explicit EnumValDefPtr(const upb_EnumValueDef* ptr) :
+            ptr_(ptr)
+        {
+        }
+
+        int32_t number() const
+        {
+            return upb_EnumValueDef_Number(ptr_);
+        }
+        const char* full_name() const
+        {
+            return upb_EnumValueDef_FullName(ptr_);
+        }
+        const char* name() const
+        {
+            return upb_EnumValueDef_Name(ptr_);
+        }
+
+    private:
+        const upb_EnumValueDef* ptr_;
+    };
+
+    class EnumDefPtr
+    {
+    public:
+        EnumDefPtr() :
+            ptr_(nullptr)
+        {
+        }
+        explicit EnumDefPtr(const upb_EnumDef* ptr) :
+            ptr_(ptr)
+        {
+        }
+
+        const upb_EnumDef* ptr() const
+        {
+            return ptr_;
+        }
+        explicit operator bool() const
+        {
+            return ptr_ != nullptr;
+        }
+
+        const char* full_name() const
+        {
+            return upb_EnumDef_FullName(ptr_);
+        }
+        const char* name() const
+        {
+            return upb_EnumDef_Name(ptr_);
+        }
+
+        // The value that is used as the default when no field default is specified.
+        // If not set explicitly, the first value that was added will be used.
+        // The default value must be a member of the enum.
+        // Requires that value_count() > 0.
+        int32_t default_value() const
+        {
+            return upb_EnumDef_Default(ptr_);
+        }
+
+        // Returns the number of values currently defined in the enum.  Note that
+        // multiple names can refer to the same number, so this may be greater than
+        // the total number of unique numbers.
+        int value_count() const
+        {
+            return upb_EnumDef_ValueCount(ptr_);
+        }
+
+        // Lookups from name to integer, returning true if found.
+        EnumValDefPtr FindValueByName(const char* name) const
+        {
+            return EnumValDefPtr(upb_EnumDef_FindValueByName(ptr_, name));
+        }
+
+        // Finds the name corresponding to the given number, or NULL if none was
+        // found.  If more than one name corresponds to this number, returns the
+        // first one that was added.
+        EnumValDefPtr FindValueByNumber(int32_t num) const
+        {
+            return EnumValDefPtr(upb_EnumDef_FindValueByNumber(ptr_, num));
+        }
+
+    private:
+        const upb_EnumDef* ptr_;
+    };
+
+    // Class that represents a .proto file with some things defined in it.
+    //
+    // Many users won't care about FileDefs, but they are necessary if you want to
+    // read the values of file-level options.
+    class FileDefPtr
+    {
+    public:
+        explicit FileDefPtr(const upb_FileDef* ptr) :
+            ptr_(ptr)
+        {
+        }
+
+        const upb_FileDef* ptr() const
+        {
+            return ptr_;
+        }
+        explicit operator bool() const
+        {
+            return ptr_ != nullptr;
+        }
+
+        // Get/set name of the file (eg. "foo/bar.proto").
+        const char* name() const
+        {
+            return upb_FileDef_Name(ptr_);
+        }
+
+        // Package name for definitions inside the file (eg. "foo.bar").
+        const char* package() const
+        {
+            return upb_FileDef_Package(ptr_);
+        }
+
+        // Syntax for the file.  Defaults to proto2.
+        upb_Syntax syntax() const
+        {
+            return upb_FileDef_Syntax(ptr_);
+        }
+
+        // Get the list of dependencies from the file.  These are returned in the
+        // order that they were added to the FileDefPtr.
+        int dependency_count() const
+        {
+            return upb_FileDef_DependencyCount(ptr_);
+        }
+        const FileDefPtr dependency(int index) const
+        {
+            return FileDefPtr(upb_FileDef_Dependency(ptr_, index));
+        }
+
+    private:
+        const upb_FileDef* ptr_;
+    };
+
+    // Non-const methods in upb::DefPool are NOT thread-safe.
+    class DefPool
+    {
+    public:
+        DefPool() :
+            ptr_(upb_DefPool_New(), upb_DefPool_Free)
+        {
+        }
+        explicit DefPool(upb_DefPool* s) :
+            ptr_(s, upb_DefPool_Free)
+        {
+        }
+
+        const upb_DefPool* ptr() const
+        {
+            return ptr_.get();
+        }
+        upb_DefPool* ptr()
+        {
+            return ptr_.get();
+        }
+
+        // Finds an entry in the symbol table with this exact name.  If not found,
+        // returns NULL.
+        MessageDefPtr FindMessageByName(const char* sym) const
+        {
+            return MessageDefPtr(upb_DefPool_FindMessageByName(ptr_.get(), sym));
+        }
+
+        EnumDefPtr FindEnumByName(const char* sym) const
+        {
+            return EnumDefPtr(upb_DefPool_FindEnumByName(ptr_.get(), sym));
+        }
+
+        FileDefPtr FindFileByName(const char* name) const
+        {
+            return FileDefPtr(upb_DefPool_FindFileByName(ptr_.get(), name));
+        }
+
+        // TODO: iteration?
+
+        // Adds the given serialized FileDescriptorProto to the pool.
+        FileDefPtr AddFile(const google_protobuf_FileDescriptorProto* file_proto, Status* status)
+        {
+            return FileDefPtr(
+                upb_DefPool_AddFile(ptr_.get(), file_proto, status->ptr())
+            );
+        }
+
+    private:
+        std::unique_ptr<upb_DefPool, decltype(&upb_DefPool_Free)> ptr_;
+    };
+
+    // TODO(b/236632406): This typedef is deprecated. Delete it.
+    using SymbolTable = DefPool;
+
+    inline FileDefPtr MessageDefPtr::file() const
+    {
+        return FileDefPtr(upb_MessageDef_File(ptr_));
     }
-    bool operator!=(const FieldIter& other) { return i_ != other.i_; }
-    bool operator==(const FieldIter& other) { return i_ == other.i_; }
-
-   private:
-    const upb_MessageDef* m_;
-    int i_;
-  };
-
-  class FieldAccessor {
-   public:
-    explicit FieldAccessor(const upb_MessageDef* md) : md_(md) {}
-    FieldIter begin() { return FieldIter(md_, 0); }
-    FieldIter end() { return FieldIter(md_, upb_MessageDef_FieldCount(md_)); }
-
-   private:
-    const upb_MessageDef* md_;
-  };
-
-  class OneofIter {
-   public:
-    explicit OneofIter(const upb_MessageDef* m, int i) : m_(m), i_(i) {}
-    void operator++() { i_++; }
-
-    OneofDefPtr operator*() {
-      return OneofDefPtr(upb_MessageDef_Oneof(m_, i_));
+
+    inline MessageDefPtr FieldDefPtr::message_subdef() const
+    {
+        return MessageDefPtr(upb_FieldDef_MessageSubDef(ptr_));
+    }
+
+    inline MessageDefPtr FieldDefPtr::containing_type() const
+    {
+        return MessageDefPtr(upb_FieldDef_ContainingType(ptr_));
+    }
+
+    inline MessageDefPtr OneofDefPtr::containing_type() const
+    {
+        return MessageDefPtr(upb_OneofDef_ContainingType(ptr_));
+    }
+
+    inline OneofDefPtr FieldDefPtr::containing_oneof() const
+    {
+        return OneofDefPtr(upb_FieldDef_ContainingOneof(ptr_));
+    }
+
+    inline EnumDefPtr FieldDefPtr::enum_subdef() const
+    {
+        return EnumDefPtr(upb_FieldDef_EnumSubDef(ptr_));
     }
-    bool operator!=(const OneofIter& other) { return i_ != other.i_; }
-    bool operator==(const OneofIter& other) { return i_ == other.i_; }
-
-   private:
-    const upb_MessageDef* m_;
-    int i_;
-  };
-
-  class OneofAccessor {
-   public:
-    explicit OneofAccessor(const upb_MessageDef* md) : md_(md) {}
-    OneofIter begin() { return OneofIter(md_, 0); }
-    OneofIter end() { return OneofIter(md_, upb_MessageDef_OneofCount(md_)); }
-
-   private:
-    const upb_MessageDef* md_;
-  };
-
- public:
-  FieldAccessor fields() const { return FieldAccessor(ptr()); }
-  OneofAccessor oneofs() const { return OneofAccessor(ptr()); }
-
- private:
-  const upb_MessageDef* ptr_;
-};
-
-class EnumValDefPtr {
- public:
-  EnumValDefPtr() : ptr_(nullptr) {}
-  explicit EnumValDefPtr(const upb_EnumValueDef* ptr) : ptr_(ptr) {}
-
-  int32_t number() const { return upb_EnumValueDef_Number(ptr_); }
-  const char* full_name() const { return upb_EnumValueDef_FullName(ptr_); }
-  const char* name() const { return upb_EnumValueDef_Name(ptr_); }
-
- private:
-  const upb_EnumValueDef* ptr_;
-};
-
-class EnumDefPtr {
- public:
-  EnumDefPtr() : ptr_(nullptr) {}
-  explicit EnumDefPtr(const upb_EnumDef* ptr) : ptr_(ptr) {}
-
-  const upb_EnumDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  const char* full_name() const { return upb_EnumDef_FullName(ptr_); }
-  const char* name() const { return upb_EnumDef_Name(ptr_); }
-
-  // The value that is used as the default when no field default is specified.
-  // If not set explicitly, the first value that was added will be used.
-  // The default value must be a member of the enum.
-  // Requires that value_count() > 0.
-  int32_t default_value() const { return upb_EnumDef_Default(ptr_); }
-
-  // Returns the number of values currently defined in the enum.  Note that
-  // multiple names can refer to the same number, so this may be greater than
-  // the total number of unique numbers.
-  int value_count() const { return upb_EnumDef_ValueCount(ptr_); }
-
-  // Lookups from name to integer, returning true if found.
-  EnumValDefPtr FindValueByName(const char* name) const {
-    return EnumValDefPtr(upb_EnumDef_FindValueByName(ptr_, name));
-  }
-
-  // Finds the name corresponding to the given number, or NULL if none was
-  // found.  If more than one name corresponds to this number, returns the
-  // first one that was added.
-  EnumValDefPtr FindValueByNumber(int32_t num) const {
-    return EnumValDefPtr(upb_EnumDef_FindValueByNumber(ptr_, num));
-  }
-
- private:
-  const upb_EnumDef* ptr_;
-};
-
-// Class that represents a .proto file with some things defined in it.
-//
-// Many users won't care about FileDefs, but they are necessary if you want to
-// read the values of file-level options.
-class FileDefPtr {
- public:
-  explicit FileDefPtr(const upb_FileDef* ptr) : ptr_(ptr) {}
-
-  const upb_FileDef* ptr() const { return ptr_; }
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  // Get/set name of the file (eg. "foo/bar.proto").
-  const char* name() const { return upb_FileDef_Name(ptr_); }
-
-  // Package name for definitions inside the file (eg. "foo.bar").
-  const char* package() const { return upb_FileDef_Package(ptr_); }
-
-  // Syntax for the file.  Defaults to proto2.
-  upb_Syntax syntax() const { return upb_FileDef_Syntax(ptr_); }
-
-  // Get the list of dependencies from the file.  These are returned in the
-  // order that they were added to the FileDefPtr.
-  int dependency_count() const { return upb_FileDef_DependencyCount(ptr_); }
-  const FileDefPtr dependency(int index) const {
-    return FileDefPtr(upb_FileDef_Dependency(ptr_, index));
-  }
-
- private:
-  const upb_FileDef* ptr_;
-};
-
-// Non-const methods in upb::DefPool are NOT thread-safe.
-class DefPool {
- public:
-  DefPool() : ptr_(upb_DefPool_New(), upb_DefPool_Free) {}
-  explicit DefPool(upb_DefPool* s) : ptr_(s, upb_DefPool_Free) {}
-
-  const upb_DefPool* ptr() const { return ptr_.get(); }
-  upb_DefPool* ptr() { return ptr_.get(); }
-
-  // Finds an entry in the symbol table with this exact name.  If not found,
-  // returns NULL.
-  MessageDefPtr FindMessageByName(const char* sym) const {
-    return MessageDefPtr(upb_DefPool_FindMessageByName(ptr_.get(), sym));
-  }
-
-  EnumDefPtr FindEnumByName(const char* sym) const {
-    return EnumDefPtr(upb_DefPool_FindEnumByName(ptr_.get(), sym));
-  }
-
-  FileDefPtr FindFileByName(const char* name) const {
-    return FileDefPtr(upb_DefPool_FindFileByName(ptr_.get(), name));
-  }
-
-  // TODO: iteration?
-
-  // Adds the given serialized FileDescriptorProto to the pool.
-  FileDefPtr AddFile(const google_protobuf_FileDescriptorProto* file_proto,
-                     Status* status) {
-    return FileDefPtr(
-        upb_DefPool_AddFile(ptr_.get(), file_proto, status->ptr()));
-  }
-
- private:
-  std::unique_ptr<upb_DefPool, decltype(&upb_DefPool_Free)> ptr_;
-};
-
-// TODO(b/236632406): This typedef is deprecated. Delete it.
-using SymbolTable = DefPool;
-
-inline FileDefPtr MessageDefPtr::file() const {
-  return FileDefPtr(upb_MessageDef_File(ptr_));
-}
-
-inline MessageDefPtr FieldDefPtr::message_subdef() const {
-  return MessageDefPtr(upb_FieldDef_MessageSubDef(ptr_));
-}
-
-inline MessageDefPtr FieldDefPtr::containing_type() const {
-  return MessageDefPtr(upb_FieldDef_ContainingType(ptr_));
-}
-
-inline MessageDefPtr OneofDefPtr::containing_type() const {
-  return MessageDefPtr(upb_OneofDef_ContainingType(ptr_));
-}
-
-inline OneofDefPtr FieldDefPtr::containing_oneof() const {
-  return OneofDefPtr(upb_FieldDef_ContainingOneof(ptr_));
-}
-
-inline EnumDefPtr FieldDefPtr::enum_subdef() const {
-  return EnumDefPtr(upb_FieldDef_EnumSubDef(ptr_));
-}
 
 }  // namespace upb
 
diff --git a/CAPI/cpp/grpc/include/upb/encode.h b/CAPI/cpp/grpc/include/upb/encode.h
index 791d84a..bf48c68 100644
--- a/CAPI/cpp/grpc/include/upb/encode.h
+++ b/CAPI/cpp/grpc/include/upb/encode.h
@@ -38,39 +38,40 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-enum {
-  /* If set, the results of serializing will be deterministic across all
-   * instances of this binary. There are no guarantees across different
-   * binary builds.
-   *
-   * If your proto contains maps, the encoder will need to malloc()/free()
-   * memory during encode. */
-  kUpb_EncodeOption_Deterministic = 1,
+    enum
+    {
+        /* If set, the results of serializing will be deterministic across all
+         * instances of this binary. There are no guarantees across different
+         * binary builds.
+         *
+         * If your proto contains maps, the encoder will need to malloc()/free()
+         * memory during encode. */
+        kUpb_EncodeOption_Deterministic = 1,
 
-  /* When set, unknown fields are not printed. */
-  kUpb_EncodeOption_SkipUnknown = 2,
+        /* When set, unknown fields are not printed. */
+        kUpb_EncodeOption_SkipUnknown = 2,
 
-  /* When set, the encode will fail if any required fields are missing. */
-  kUpb_EncodeOption_CheckRequired = 4,
-};
+        /* When set, the encode will fail if any required fields are missing. */
+        kUpb_EncodeOption_CheckRequired = 4,
+    };
 
 #define UPB_ENCODE_MAXDEPTH(depth) ((depth) << 16)
 
-typedef enum {
-  kUpb_EncodeStatus_Ok = 0,
-  kUpb_EncodeStatus_OutOfMemory = 1,       // Arena alloc failed
-  kUpb_EncodeStatus_MaxDepthExceeded = 2,  // Exceeded UPB_ENCODE_MAXDEPTH
+    typedef enum
+    {
+        kUpb_EncodeStatus_Ok = 0,
+        kUpb_EncodeStatus_OutOfMemory = 1,       // Arena alloc failed
+        kUpb_EncodeStatus_MaxDepthExceeded = 2,  // Exceeded UPB_ENCODE_MAXDEPTH
 
-  // kUpb_EncodeOption_CheckRequired failed but the parse otherwise succeeded.
-  kUpb_EncodeStatus_MissingRequired = 3,
-} upb_EncodeStatus;
+        // kUpb_EncodeOption_CheckRequired failed but the parse otherwise succeeded.
+        kUpb_EncodeStatus_MissingRequired = 3,
+    } upb_EncodeStatus;
 
-upb_EncodeStatus upb_Encode(const void* msg, const upb_MiniTable* l,
-                            int options, upb_Arena* arena, char** buf,
-                            size_t* size);
+    upb_EncodeStatus upb_Encode(const void* msg, const upb_MiniTable* l, int options, upb_Arena* arena, char** buf, size_t* size);
 
 #include "upb/port_undef.inc"
 
diff --git a/CAPI/cpp/grpc/include/upb/extension_registry.h b/CAPI/cpp/grpc/include/upb/extension_registry.h
index 0e0a444..77071aa 100644
--- a/CAPI/cpp/grpc/include/upb/extension_registry.h
+++ b/CAPI/cpp/grpc/include/upb/extension_registry.h
@@ -33,49 +33,50 @@
 #include "upb/upb.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/* Extension registry: a dynamic data structure that stores a map of:
- *   (upb_MiniTable, number) -> extension info
- *
- * upb_decode() uses upb_ExtensionRegistry to look up extensions while parsing
- * binary format.
- *
- * upb_ExtensionRegistry is part of the mini-table (msglayout) family of
- * objects. Like all mini-table objects, it is suitable for reflection-less
- * builds that do not want to expose names into the binary.
- *
- * Unlike most mini-table types, upb_ExtensionRegistry requires dynamic memory
- * allocation and dynamic initialization:
- * * If reflection is being used, then upb_DefPool will construct an appropriate
- *   upb_ExtensionRegistry automatically.
- * * For a mini-table only build, the user must manually construct the
- *   upb_ExtensionRegistry and populate it with all of the extensions the user
- * cares about.
- * * A third alternative is to manually unpack relevant extensions after the
- *   main parse is complete, similar to how Any works. This is perhaps the
- *   nicest solution from the perspective of reducing dependencies, avoiding
- *   dynamic memory allocation, and avoiding the need to parse uninteresting
- *   extensions.  The downsides are:
- *     (1) parse errors are not caught during the main parse
- *     (2) the CPU hit of parsing comes during access, which could cause an
- *         undesirable stutter in application performance.
- *
- * Users cannot directly get or put into this map. Users can only add the
- * extensions from a generated module and pass the extension registry to the
- * binary decoder.
- *
- * A upb_DefPool provides a upb_ExtensionRegistry, so any users who use
- * reflection do not need to populate a upb_ExtensionRegistry directly.
- */
+    /* Extension registry: a dynamic data structure that stores a map of:
+     *   (upb_MiniTable, number) -> extension info
+     *
+     * upb_decode() uses upb_ExtensionRegistry to look up extensions while parsing
+     * binary format.
+     *
+     * upb_ExtensionRegistry is part of the mini-table (msglayout) family of
+     * objects. Like all mini-table objects, it is suitable for reflection-less
+     * builds that do not want to expose names into the binary.
+     *
+     * Unlike most mini-table types, upb_ExtensionRegistry requires dynamic memory
+     * allocation and dynamic initialization:
+     * * If reflection is being used, then upb_DefPool will construct an appropriate
+     *   upb_ExtensionRegistry automatically.
+     * * For a mini-table only build, the user must manually construct the
+     *   upb_ExtensionRegistry and populate it with all of the extensions the user
+     * cares about.
+     * * A third alternative is to manually unpack relevant extensions after the
+     *   main parse is complete, similar to how Any works. This is perhaps the
+     *   nicest solution from the perspective of reducing dependencies, avoiding
+     *   dynamic memory allocation, and avoiding the need to parse uninteresting
+     *   extensions.  The downsides are:
+     *     (1) parse errors are not caught during the main parse
+     *     (2) the CPU hit of parsing comes during access, which could cause an
+     *         undesirable stutter in application performance.
+     *
+     * Users cannot directly get or put into this map. Users can only add the
+     * extensions from a generated module and pass the extension registry to the
+     * binary decoder.
+     *
+     * A upb_DefPool provides a upb_ExtensionRegistry, so any users who use
+     * reflection do not need to populate a upb_ExtensionRegistry directly.
+     */
 
-struct upb_ExtensionRegistry;
-typedef struct upb_ExtensionRegistry upb_ExtensionRegistry;
+    struct upb_ExtensionRegistry;
+    typedef struct upb_ExtensionRegistry upb_ExtensionRegistry;
 
-/* Creates a upb_ExtensionRegistry in the given arena.  The arena must outlive
- * any use of the extreg. */
-upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena);
+    /* Creates a upb_ExtensionRegistry in the given arena.  The arena must outlive
+     * any use of the extreg. */
+    upb_ExtensionRegistry* upb_ExtensionRegistry_New(upb_Arena* arena);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/internal/decode.h b/CAPI/cpp/grpc/include/upb/internal/decode.h
index 708874c..601bf60 100644
--- a/CAPI/cpp/grpc/include/upb/internal/decode.h
+++ b/CAPI/cpp/grpc/include/upb/internal/decode.h
@@ -45,25 +45,26 @@
 
 #define DECODE_NOGROUP (uint32_t) - 1
 
-typedef struct upb_Decoder {
-  const char* end;          /* Can read up to 16 bytes slop beyond this. */
-  const char* limit_ptr;    /* = end + UPB_MIN(limit, 0) */
-  upb_Message* unknown_msg; /* If non-NULL, add unknown data at buffer flip. */
-  const char* unknown;      /* Start of unknown data. */
-  const upb_ExtensionRegistry*
-      extreg;         /* For looking up extensions during the parse. */
-  int limit;          /* Submessage limit relative to end. */
-  int depth;          /* Tracks recursion depth to bound stack usage. */
-  uint32_t end_group; /* field number of END_GROUP tag, else DECODE_NOGROUP */
-  uint16_t options;
-  bool missing_required;
-  char patch[32];
-  upb_Arena arena;
-  jmp_buf err;
+typedef struct upb_Decoder
+{
+    const char* end;          /* Can read up to 16 bytes slop beyond this. */
+    const char* limit_ptr;    /* = end + UPB_MIN(limit, 0) */
+    upb_Message* unknown_msg; /* If non-NULL, add unknown data at buffer flip. */
+    const char* unknown;      /* Start of unknown data. */
+    const upb_ExtensionRegistry*
+        extreg;         /* For looking up extensions during the parse. */
+    int limit;          /* Submessage limit relative to end. */
+    int depth;          /* Tracks recursion depth to bound stack usage. */
+    uint32_t end_group; /* field number of END_GROUP tag, else DECODE_NOGROUP */
+    uint16_t options;
+    bool missing_required;
+    char patch[32];
+    upb_Arena arena;
+    jmp_buf err;
 
 #ifndef NDEBUG
-  const char* debug_tagstart;
-  const char* debug_valstart;
+    const char* debug_tagstart;
+    const char* debug_valstart;
 #endif
 } upb_Decoder;
 
@@ -79,131 +80,147 @@ const char* fastdecode_err(upb_Decoder* d, int status);
 extern const uint8_t upb_utf8_offsets[];
 
 UPB_INLINE
-bool decode_verifyutf8_inl(const char* ptr, int len) {
-  const char* end = ptr + len;
-
-  // Check 8 bytes at a time for any non-ASCII char.
-  while (end - ptr >= 8) {
-    uint64_t data;
-    memcpy(&data, ptr, 8);
-    if (data & 0x8080808080808080) goto non_ascii;
-    ptr += 8;
-  }
+bool decode_verifyutf8_inl(const char* ptr, int len)
+{
+    const char* end = ptr + len;
+
+    // Check 8 bytes at a time for any non-ASCII char.
+    while (end - ptr >= 8)
+    {
+        uint64_t data;
+        memcpy(&data, ptr, 8);
+        if (data & 0x8080808080808080)
+            goto non_ascii;
+        ptr += 8;
+    }
 
-  // Check one byte at a time for non-ASCII.
-  while (ptr < end) {
-    if (*ptr & 0x80) goto non_ascii;
-    ptr++;
-  }
+    // Check one byte at a time for non-ASCII.
+    while (ptr < end)
+    {
+        if (*ptr & 0x80)
+            goto non_ascii;
+        ptr++;
+    }
 
-  return true;
+    return true;
 
 non_ascii:
-  return utf8_range2((const unsigned char*)ptr, end - ptr) == 0;
+    return utf8_range2((const unsigned char*)ptr, end - ptr) == 0;
 }
 
-const char* decode_checkrequired(upb_Decoder* d, const char* ptr,
-                                 const upb_Message* msg,
-                                 const upb_MiniTable* l);
+const char* decode_checkrequired(upb_Decoder* d, const char* ptr, const upb_Message* msg, const upb_MiniTable* l);
 
 /* x86-64 pointers always have the high 16 bits matching. So we can shift
  * left 8 and right 8 without loss of information. */
-UPB_INLINE intptr_t decode_totable(const upb_MiniTable* tablep) {
-  return ((intptr_t)tablep << 8) | tablep->table_mask;
+UPB_INLINE intptr_t decode_totable(const upb_MiniTable* tablep)
+{
+    return ((intptr_t)tablep << 8) | tablep->table_mask;
 }
 
-UPB_INLINE const upb_MiniTable* decode_totablep(intptr_t table) {
-  return (const upb_MiniTable*)(table >> 8);
+UPB_INLINE const upb_MiniTable* decode_totablep(intptr_t table)
+{
+    return (const upb_MiniTable*)(table >> 8);
 }
 
 UPB_INLINE
-const char* decode_isdonefallback_inl(upb_Decoder* d, const char* ptr,
-                                      int overrun, int* status) {
-  if (overrun < d->limit) {
-    /* Need to copy remaining data into patch buffer. */
-    UPB_ASSERT(overrun < 16);
-    if (d->unknown_msg) {
-      if (!_upb_Message_AddUnknown(d->unknown_msg, d->unknown, ptr - d->unknown,
-                                   &d->arena)) {
-        *status = kUpb_DecodeStatus_OutOfMemory;
+const char* decode_isdonefallback_inl(upb_Decoder* d, const char* ptr, int overrun, int* status)
+{
+    if (overrun < d->limit)
+    {
+        /* Need to copy remaining data into patch buffer. */
+        UPB_ASSERT(overrun < 16);
+        if (d->unknown_msg)
+        {
+            if (!_upb_Message_AddUnknown(d->unknown_msg, d->unknown, ptr - d->unknown, &d->arena))
+            {
+                *status = kUpb_DecodeStatus_OutOfMemory;
+                return NULL;
+            }
+            d->unknown = &d->patch[0] + overrun;
+        }
+        memset(d->patch + 16, 0, 16);
+        memcpy(d->patch, d->end, 16);
+        ptr = &d->patch[0] + overrun;
+        d->end = &d->patch[16];
+        d->limit -= 16;
+        d->limit_ptr = d->end + d->limit;
+        d->options &= ~kUpb_DecodeOption_AliasString;
+        UPB_ASSERT(ptr < d->limit_ptr);
+        return ptr;
+    }
+    else
+    {
+        *status = kUpb_DecodeStatus_Malformed;
         return NULL;
-      }
-      d->unknown = &d->patch[0] + overrun;
     }
-    memset(d->patch + 16, 0, 16);
-    memcpy(d->patch, d->end, 16);
-    ptr = &d->patch[0] + overrun;
-    d->end = &d->patch[16];
-    d->limit -= 16;
-    d->limit_ptr = d->end + d->limit;
-    d->options &= ~kUpb_DecodeOption_AliasString;
-    UPB_ASSERT(ptr < d->limit_ptr);
-    return ptr;
-  } else {
-    *status = kUpb_DecodeStatus_Malformed;
-    return NULL;
-  }
 }
 
 const char* decode_isdonefallback(upb_Decoder* d, const char* ptr, int overrun);
 
 UPB_INLINE
-bool decode_isdone(upb_Decoder* d, const char** ptr) {
-  int overrun = *ptr - d->end;
-  if (UPB_LIKELY(*ptr < d->limit_ptr)) {
-    return false;
-  } else if (UPB_LIKELY(overrun == d->limit)) {
-    return true;
-  } else {
-    *ptr = decode_isdonefallback(d, *ptr, overrun);
-    return false;
-  }
+bool decode_isdone(upb_Decoder* d, const char** ptr)
+{
+    int overrun = *ptr - d->end;
+    if (UPB_LIKELY(*ptr < d->limit_ptr))
+    {
+        return false;
+    }
+    else if (UPB_LIKELY(overrun == d->limit))
+    {
+        return true;
+    }
+    else
+    {
+        *ptr = decode_isdonefallback(d, *ptr, overrun);
+        return false;
+    }
 }
 
 #if UPB_FASTTABLE
 UPB_INLINE
-const char* fastdecode_tagdispatch(upb_Decoder* d, const char* ptr,
-                                   upb_Message* msg, intptr_t table,
-                                   uint64_t hasbits, uint64_t tag) {
-  const upb_MiniTable* table_p = decode_totablep(table);
-  uint8_t mask = table;
-  uint64_t data;
-  size_t idx = tag & mask;
-  UPB_ASSUME((idx & 7) == 0);
-  idx >>= 3;
-  data = table_p->fasttable[idx].field_data ^ tag;
-  UPB_MUSTTAIL return table_p->fasttable[idx].field_parser(d, ptr, msg, table,
-                                                           hasbits, data);
+const char* fastdecode_tagdispatch(upb_Decoder* d, const char* ptr, upb_Message* msg, intptr_t table, uint64_t hasbits, uint64_t tag)
+{
+    const upb_MiniTable* table_p = decode_totablep(table);
+    uint8_t mask = table;
+    uint64_t data;
+    size_t idx = tag & mask;
+    UPB_ASSUME((idx & 7) == 0);
+    idx >>= 3;
+    data = table_p->fasttable[idx].field_data ^ tag;
+    UPB_MUSTTAIL return table_p->fasttable[idx].field_parser(d, ptr, msg, table, hasbits, data);
 }
 #endif
 
-UPB_INLINE uint32_t fastdecode_loadtag(const char* ptr) {
-  uint16_t tag;
-  memcpy(&tag, ptr, 2);
-  return tag;
+UPB_INLINE uint32_t fastdecode_loadtag(const char* ptr)
+{
+    uint16_t tag;
+    memcpy(&tag, ptr, 2);
+    return tag;
 }
 
-UPB_INLINE void decode_checklimit(upb_Decoder* d) {
-  UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
+UPB_INLINE void decode_checklimit(upb_Decoder* d)
+{
+    UPB_ASSERT(d->limit_ptr == d->end + UPB_MIN(0, d->limit));
 }
 
-UPB_INLINE int decode_pushlimit(upb_Decoder* d, const char* ptr, int size) {
-  int limit = size + (int)(ptr - d->end);
-  int delta = d->limit - limit;
-  decode_checklimit(d);
-  d->limit = limit;
-  d->limit_ptr = d->end + UPB_MIN(0, limit);
-  decode_checklimit(d);
-  return delta;
+UPB_INLINE int decode_pushlimit(upb_Decoder* d, const char* ptr, int size)
+{
+    int limit = size + (int)(ptr - d->end);
+    int delta = d->limit - limit;
+    decode_checklimit(d);
+    d->limit = limit;
+    d->limit_ptr = d->end + UPB_MIN(0, limit);
+    decode_checklimit(d);
+    return delta;
 }
 
-UPB_INLINE void decode_poplimit(upb_Decoder* d, const char* ptr,
-                                int saved_delta) {
-  UPB_ASSERT(ptr - d->end == d->limit);
-  decode_checklimit(d);
-  d->limit += saved_delta;
-  d->limit_ptr = d->end + UPB_MIN(0, d->limit);
-  decode_checklimit(d);
+UPB_INLINE void decode_poplimit(upb_Decoder* d, const char* ptr, int saved_delta)
+{
+    UPB_ASSERT(ptr - d->end == d->limit);
+    decode_checklimit(d);
+    d->limit += saved_delta;
+    d->limit_ptr = d->end + UPB_MIN(0, d->limit);
+    decode_checklimit(d);
 }
 
 #include "upb/port_undef.inc"
diff --git a/CAPI/cpp/grpc/include/upb/internal/mini_table_accessors.h b/CAPI/cpp/grpc/include/upb/internal/mini_table_accessors.h
index 23f694b..a7f0108 100644
--- a/CAPI/cpp/grpc/include/upb/internal/mini_table_accessors.h
+++ b/CAPI/cpp/grpc/include/upb/internal/mini_table_accessors.h
@@ -34,21 +34,26 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-UPB_INLINE bool _upb_MiniTable_Field_InOneOf(const upb_MiniTable_Field* field) {
-  return field->presence < 0;
-}
-
-UPB_INLINE void _upb_MiniTable_SetPresence(upb_Message* msg,
-                                           const upb_MiniTable_Field* field) {
-  if (field->presence > 0) {
-    _upb_sethas_field(msg, field);
-  } else if (_upb_MiniTable_Field_InOneOf(field)) {
-    *_upb_oneofcase_field(msg, field) = field->number;
-  }
-}
+    UPB_INLINE bool _upb_MiniTable_Field_InOneOf(const upb_MiniTable_Field* field)
+    {
+        return field->presence < 0;
+    }
+
+    UPB_INLINE void _upb_MiniTable_SetPresence(upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        if (field->presence > 0)
+        {
+            _upb_sethas_field(msg, field);
+        }
+        else if (_upb_MiniTable_Field_InOneOf(field))
+        {
+            *_upb_oneofcase_field(msg, field) = field->number;
+        }
+    }
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/internal/table.h b/CAPI/cpp/grpc/include/upb/internal/table.h
index bc647be..ee97e41 100644
--- a/CAPI/cpp/grpc/include/upb/internal/table.h
+++ b/CAPI/cpp/grpc/include/upb/internal/table.h
@@ -56,20 +56,25 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/* upb_value ******************************************************************/
+    /* upb_value ******************************************************************/
 
-typedef struct {
-  uint64_t val;
-} upb_value;
+    typedef struct
+    {
+        uint64_t val;
+    } upb_value;
 
-/* Variant that works with a length-delimited rather than NULL-delimited string,
- * as supported by strtable. */
-char* upb_strdup2(const char* s, size_t len, upb_Arena* a);
+    /* Variant that works with a length-delimited rather than NULL-delimited string,
+     * as supported by strtable. */
+    char* upb_strdup2(const char* s, size_t len, upb_Arena* a);
 
-UPB_INLINE void _upb_value_setval(upb_value* v, uint64_t val) { v->val = val; }
+    UPB_INLINE void _upb_value_setval(upb_value* v, uint64_t val)
+    {
+        v->val = val;
+    }
 
 /* For each value ctype, define the following set of functions:
  *
@@ -80,301 +85,318 @@ UPB_INLINE void _upb_value_setval(upb_value* v, uint64_t val) { v->val = val; }
  * // Construct a new upb_value from an int32.
  * upb_value upb_value_int32(int32_t val); */
 #define FUNCS(name, membername, type_t, converter, proto_type)       \
-  UPB_INLINE void upb_value_set##name(upb_value* val, type_t cval) { \
-    val->val = (converter)cval;                                      \
-  }                                                                  \
-  UPB_INLINE upb_value upb_value_##name(type_t val) {                \
-    upb_value ret;                                                   \
-    upb_value_set##name(&ret, val);                                  \
-    return ret;                                                      \
-  }                                                                  \
-  UPB_INLINE type_t upb_value_get##name(upb_value val) {             \
-    return (type_t)(converter)val.val;                               \
-  }
-
-FUNCS(int32, int32, int32_t, int32_t, UPB_CTYPE_INT32)
-FUNCS(int64, int64, int64_t, int64_t, UPB_CTYPE_INT64)
-FUNCS(uint32, uint32, uint32_t, uint32_t, UPB_CTYPE_UINT32)
-FUNCS(uint64, uint64, uint64_t, uint64_t, UPB_CTYPE_UINT64)
-FUNCS(bool, _bool, bool, bool, UPB_CTYPE_BOOL)
-FUNCS(cstr, cstr, char*, uintptr_t, UPB_CTYPE_CSTR)
-FUNCS(ptr, ptr, void*, uintptr_t, UPB_CTYPE_PTR)
-FUNCS(constptr, constptr, const void*, uintptr_t, UPB_CTYPE_CONSTPTR)
+    UPB_INLINE void upb_value_set##name(upb_value* val, type_t cval) \
+    {                                                                \
+        val->val = (converter)cval;                                  \
+    }                                                                \
+    UPB_INLINE upb_value upb_value_##name(type_t val)                \
+    {                                                                \
+        upb_value ret;                                               \
+        upb_value_set##name(&ret, val);                              \
+        return ret;                                                  \
+    }                                                                \
+    UPB_INLINE type_t upb_value_get##name(upb_value val)             \
+    {                                                                \
+        return (type_t)(converter)val.val;                           \
+    }
+
+    FUNCS(int32, int32, int32_t, int32_t, UPB_CTYPE_INT32)
+    FUNCS(int64, int64, int64_t, int64_t, UPB_CTYPE_INT64)
+    FUNCS(uint32, uint32, uint32_t, uint32_t, UPB_CTYPE_UINT32)
+    FUNCS(uint64, uint64, uint64_t, uint64_t, UPB_CTYPE_UINT64)
+    FUNCS(bool, _bool, bool, bool, UPB_CTYPE_BOOL)
+    FUNCS(cstr, cstr, char*, uintptr_t, UPB_CTYPE_CSTR)
+    FUNCS(ptr, ptr, void*, uintptr_t, UPB_CTYPE_PTR)
+    FUNCS(constptr, constptr, const void*, uintptr_t, UPB_CTYPE_CONSTPTR)
 
 #undef FUNCS
 
-UPB_INLINE void upb_value_setfloat(upb_value* val, float cval) {
-  memcpy(&val->val, &cval, sizeof(cval));
-}
-
-UPB_INLINE void upb_value_setdouble(upb_value* val, double cval) {
-  memcpy(&val->val, &cval, sizeof(cval));
-}
-
-UPB_INLINE upb_value upb_value_float(float cval) {
-  upb_value ret;
-  upb_value_setfloat(&ret, cval);
-  return ret;
-}
-
-UPB_INLINE upb_value upb_value_double(double cval) {
-  upb_value ret;
-  upb_value_setdouble(&ret, cval);
-  return ret;
-}
+    UPB_INLINE void upb_value_setfloat(upb_value* val, float cval)
+    {
+        memcpy(&val->val, &cval, sizeof(cval));
+    }
+
+    UPB_INLINE void upb_value_setdouble(upb_value* val, double cval)
+    {
+        memcpy(&val->val, &cval, sizeof(cval));
+    }
+
+    UPB_INLINE upb_value upb_value_float(float cval)
+    {
+        upb_value ret;
+        upb_value_setfloat(&ret, cval);
+        return ret;
+    }
+
+    UPB_INLINE upb_value upb_value_double(double cval)
+    {
+        upb_value ret;
+        upb_value_setdouble(&ret, cval);
+        return ret;
+    }
 
 #undef SET_TYPE
 
-/* upb_tabkey *****************************************************************/
-
-/* Either:
- *   1. an actual integer key, or
- *   2. a pointer to a string prefixed by its uint32_t length, owned by us.
- *
- * ...depending on whether this is a string table or an int table.  We would
- * make this a union of those two types, but C89 doesn't support statically
- * initializing a non-first union member. */
-typedef uintptr_t upb_tabkey;
-
-UPB_INLINE char* upb_tabstr(upb_tabkey key, uint32_t* len) {
-  char* mem = (char*)key;
-  if (len) memcpy(len, mem, sizeof(*len));
-  return mem + sizeof(*len);
-}
-
-UPB_INLINE upb_StringView upb_tabstrview(upb_tabkey key) {
-  upb_StringView ret;
-  uint32_t len;
-  ret.data = upb_tabstr(key, &len);
-  ret.size = len;
-  return ret;
-}
-
-/* upb_tabval *****************************************************************/
-
-typedef struct upb_tabval {
-  uint64_t val;
-} upb_tabval;
+    /* upb_tabkey *****************************************************************/
+
+    /* Either:
+     *   1. an actual integer key, or
+     *   2. a pointer to a string prefixed by its uint32_t length, owned by us.
+     *
+     * ...depending on whether this is a string table or an int table.  We would
+     * make this a union of those two types, but C89 doesn't support statically
+     * initializing a non-first union member. */
+    typedef uintptr_t upb_tabkey;
+
+    UPB_INLINE char* upb_tabstr(upb_tabkey key, uint32_t* len)
+    {
+        char* mem = (char*)key;
+        if (len)
+            memcpy(len, mem, sizeof(*len));
+        return mem + sizeof(*len);
+    }
+
+    UPB_INLINE upb_StringView upb_tabstrview(upb_tabkey key)
+    {
+        upb_StringView ret;
+        uint32_t len;
+        ret.data = upb_tabstr(key, &len);
+        ret.size = len;
+        return ret;
+    }
+
+    /* upb_tabval *****************************************************************/
+
+    typedef struct upb_tabval
+    {
+        uint64_t val;
+    } upb_tabval;
 
 #define UPB_TABVALUE_EMPTY_INIT \
-  { -1 }
-
-/* upb_table ******************************************************************/
-
-typedef struct _upb_tabent {
-  upb_tabkey key;
-  upb_tabval val;
-
-  /* Internal chaining.  This is const so we can create static initializers for
-   * tables.  We cast away const sometimes, but *only* when the containing
-   * upb_table is known to be non-const.  This requires a bit of care, but
-   * the subtlety is confined to table.c. */
-  const struct _upb_tabent* next;
-} upb_tabent;
-
-typedef struct {
-  size_t count;       /* Number of entries in the hash part. */
-  uint32_t mask;      /* Mask to turn hash value -> bucket. */
-  uint32_t max_count; /* Max count before we hit our load limit. */
-  uint8_t size_lg2;   /* Size of the hashtable part is 2^size_lg2 entries. */
-  upb_tabent* entries;
-} upb_table;
-
-typedef struct {
-  upb_table t;
-} upb_strtable;
-
-typedef struct {
-  upb_table t;             /* For entries that don't fit in the array part. */
-  const upb_tabval* array; /* Array part of the table. See const note above. */
-  size_t array_size;       /* Array part size. */
-  size_t array_count;      /* Array part number of elements. */
-} upb_inttable;
-
-UPB_INLINE size_t upb_table_size(const upb_table* t) {
-  if (t->size_lg2 == 0)
-    return 0;
-  else
-    return 1 << t->size_lg2;
-}
-
-/* Internal-only functions, in .h file only out of necessity. */
-UPB_INLINE bool upb_tabent_isempty(const upb_tabent* e) { return e->key == 0; }
-
-/* Initialize and uninitialize a table, respectively.  If memory allocation
- * failed, false is returned that the table is uninitialized. */
-bool upb_inttable_init(upb_inttable* table, upb_Arena* a);
-bool upb_strtable_init(upb_strtable* table, size_t expected_size, upb_Arena* a);
-
-/* Returns the number of values in the table. */
-size_t upb_inttable_count(const upb_inttable* t);
-UPB_INLINE size_t upb_strtable_count(const upb_strtable* t) {
-  return t->t.count;
-}
-
-void upb_strtable_clear(upb_strtable* t);
-
-/* Inserts the given key into the hashtable with the given value.  The key must
- * not already exist in the hash table.  For strtables, the key is not required
- * to be NULL-terminated, and the table will make an internal copy of the key.
- * Inttables must not insert a value of UINTPTR_MAX.
- *
- * If a table resize was required but memory allocation failed, false is
- * returned and the table is unchanged. */
-bool upb_inttable_insert(upb_inttable* t, uintptr_t key, upb_value val,
-                         upb_Arena* a);
-bool upb_strtable_insert(upb_strtable* t, const char* key, size_t len,
-                         upb_value val, upb_Arena* a);
-
-/* Looks up key in this table, returning "true" if the key was found.
- * If v is non-NULL, copies the value for this key into *v. */
-bool upb_inttable_lookup(const upb_inttable* t, uintptr_t key, upb_value* v);
-bool upb_strtable_lookup2(const upb_strtable* t, const char* key, size_t len,
-                          upb_value* v);
-
-/* For NULL-terminated strings. */
-UPB_INLINE bool upb_strtable_lookup(const upb_strtable* t, const char* key,
-                                    upb_value* v) {
-  return upb_strtable_lookup2(t, key, strlen(key), v);
-}
-
-/* Removes an item from the table.  Returns true if the remove was successful,
- * and stores the removed item in *val if non-NULL. */
-bool upb_inttable_remove(upb_inttable* t, uintptr_t key, upb_value* val);
-bool upb_strtable_remove2(upb_strtable* t, const char* key, size_t len,
-                          upb_value* val);
-
-UPB_INLINE bool upb_strtable_remove(upb_strtable* t, const char* key,
-                                    upb_value* v) {
-  return upb_strtable_remove2(t, key, strlen(key), v);
-}
-
-/* Updates an existing entry in an inttable.  If the entry does not exist,
- * returns false and does nothing.  Unlike insert/remove, this does not
- * invalidate iterators. */
-bool upb_inttable_replace(upb_inttable* t, uintptr_t key, upb_value val);
-
-/* Optimizes the table for the current set of entries, for both memory use and
- * lookup time.  Client should call this after all entries have been inserted;
- * inserting more entries is legal, but will likely require a table resize. */
-void upb_inttable_compact(upb_inttable* t, upb_Arena* a);
-
-/* Exposed for testing only. */
-bool upb_strtable_resize(upb_strtable* t, size_t size_lg2, upb_Arena* a);
-
-/* Iterators ******************************************************************/
-
-/* Iteration over inttable.
- *
- *   intptr_t iter = UPB_INTTABLE_BEGIN;
- *   uintptr_t key;
- *   upb_value val;
- *   while (upb_inttable_next2(t, &key, &val, &iter)) {
- *      // ...
- *   }
- */
+    {                           \
+        -1                      \
+    }
+
+    /* upb_table ******************************************************************/
+
+    typedef struct _upb_tabent
+    {
+        upb_tabkey key;
+        upb_tabval val;
+
+        /* Internal chaining.  This is const so we can create static initializers for
+         * tables.  We cast away const sometimes, but *only* when the containing
+         * upb_table is known to be non-const.  This requires a bit of care, but
+         * the subtlety is confined to table.c. */
+        const struct _upb_tabent* next;
+    } upb_tabent;
+
+    typedef struct
+    {
+        size_t count;       /* Number of entries in the hash part. */
+        uint32_t mask;      /* Mask to turn hash value -> bucket. */
+        uint32_t max_count; /* Max count before we hit our load limit. */
+        uint8_t size_lg2;   /* Size of the hashtable part is 2^size_lg2 entries. */
+        upb_tabent* entries;
+    } upb_table;
+
+    typedef struct
+    {
+        upb_table t;
+    } upb_strtable;
+
+    typedef struct
+    {
+        upb_table t;             /* For entries that don't fit in the array part. */
+        const upb_tabval* array; /* Array part of the table. See const note above. */
+        size_t array_size;       /* Array part size. */
+        size_t array_count;      /* Array part number of elements. */
+    } upb_inttable;
+
+    UPB_INLINE size_t upb_table_size(const upb_table* t)
+    {
+        if (t->size_lg2 == 0)
+            return 0;
+        else
+            return 1 << t->size_lg2;
+    }
+
+    /* Internal-only functions, in .h file only out of necessity. */
+    UPB_INLINE bool upb_tabent_isempty(const upb_tabent* e)
+    {
+        return e->key == 0;
+    }
+
+    /* Initialize and uninitialize a table, respectively.  If memory allocation
+     * failed, false is returned that the table is uninitialized. */
+    bool upb_inttable_init(upb_inttable* table, upb_Arena* a);
+    bool upb_strtable_init(upb_strtable* table, size_t expected_size, upb_Arena* a);
+
+    /* Returns the number of values in the table. */
+    size_t upb_inttable_count(const upb_inttable* t);
+    UPB_INLINE size_t upb_strtable_count(const upb_strtable* t)
+    {
+        return t->t.count;
+    }
+
+    void upb_strtable_clear(upb_strtable* t);
+
+    /* Inserts the given key into the hashtable with the given value.  The key must
+     * not already exist in the hash table.  For strtables, the key is not required
+     * to be NULL-terminated, and the table will make an internal copy of the key.
+     * Inttables must not insert a value of UINTPTR_MAX.
+     *
+     * If a table resize was required but memory allocation failed, false is
+     * returned and the table is unchanged. */
+    bool upb_inttable_insert(upb_inttable* t, uintptr_t key, upb_value val, upb_Arena* a);
+    bool upb_strtable_insert(upb_strtable* t, const char* key, size_t len, upb_value val, upb_Arena* a);
+
+    /* Looks up key in this table, returning "true" if the key was found.
+     * If v is non-NULL, copies the value for this key into *v. */
+    bool upb_inttable_lookup(const upb_inttable* t, uintptr_t key, upb_value* v);
+    bool upb_strtable_lookup2(const upb_strtable* t, const char* key, size_t len, upb_value* v);
+
+    /* For NULL-terminated strings. */
+    UPB_INLINE bool upb_strtable_lookup(const upb_strtable* t, const char* key, upb_value* v)
+    {
+        return upb_strtable_lookup2(t, key, strlen(key), v);
+    }
+
+    /* Removes an item from the table.  Returns true if the remove was successful,
+     * and stores the removed item in *val if non-NULL. */
+    bool upb_inttable_remove(upb_inttable* t, uintptr_t key, upb_value* val);
+    bool upb_strtable_remove2(upb_strtable* t, const char* key, size_t len, upb_value* val);
+
+    UPB_INLINE bool upb_strtable_remove(upb_strtable* t, const char* key, upb_value* v)
+    {
+        return upb_strtable_remove2(t, key, strlen(key), v);
+    }
+
+    /* Updates an existing entry in an inttable.  If the entry does not exist,
+     * returns false and does nothing.  Unlike insert/remove, this does not
+     * invalidate iterators. */
+    bool upb_inttable_replace(upb_inttable* t, uintptr_t key, upb_value val);
+
+    /* Optimizes the table for the current set of entries, for both memory use and
+     * lookup time.  Client should call this after all entries have been inserted;
+     * inserting more entries is legal, but will likely require a table resize. */
+    void upb_inttable_compact(upb_inttable* t, upb_Arena* a);
+
+    /* Exposed for testing only. */
+    bool upb_strtable_resize(upb_strtable* t, size_t size_lg2, upb_Arena* a);
+
+    /* Iterators ******************************************************************/
+
+    /* Iteration over inttable.
+     *
+     *   intptr_t iter = UPB_INTTABLE_BEGIN;
+     *   uintptr_t key;
+     *   upb_value val;
+     *   while (upb_inttable_next2(t, &key, &val, &iter)) {
+     *      // ...
+     *   }
+     */
 
 #define UPB_INTTABLE_BEGIN -1
 
-bool upb_inttable_next2(const upb_inttable* t, uintptr_t* key, upb_value* val,
-                        intptr_t* iter);
-void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter);
+    bool upb_inttable_next2(const upb_inttable* t, uintptr_t* key, upb_value* val, intptr_t* iter);
+    void upb_inttable_removeiter(upb_inttable* t, intptr_t* iter);
 
-/* Iteration over strtable.
- *
- *   intptr_t iter = UPB_INTTABLE_BEGIN;
- *   upb_StringView key;
- *   upb_value val;
- *   while (upb_strtable_next2(t, &key, &val, &iter)) {
- *      // ...
- *   }
- */
+    /* Iteration over strtable.
+     *
+     *   intptr_t iter = UPB_INTTABLE_BEGIN;
+     *   upb_StringView key;
+     *   upb_value val;
+     *   while (upb_strtable_next2(t, &key, &val, &iter)) {
+     *      // ...
+     *   }
+     */
 
 #define UPB_STRTABLE_BEGIN -1
 
-bool upb_strtable_next2(const upb_strtable* t, upb_StringView* key,
-                        upb_value* val, intptr_t* iter);
-void upb_strtable_removeiter(upb_strtable* t, intptr_t* iter);
-
-/* DEPRECATED iterators, slated for removal.
- *
- * Iterators for int and string tables.  We are subject to some kind of unusual
- * design constraints:
- *
- * For high-level languages:
- *  - we must be able to guarantee that we don't crash or corrupt memory even if
- *    the program accesses an invalidated iterator.
- *
- * For C++11 range-based for:
- *  - iterators must be copyable
- *  - iterators must be comparable
- *  - it must be possible to construct an "end" value.
- *
- * Iteration order is undefined.
- *
- * Modifying the table invalidates iterators.  upb_{str,int}table_done() is
- * guaranteed to work even on an invalidated iterator, as long as the table it
- * is iterating over has not been freed.  Calling next() or accessing data from
- * an invalidated iterator yields unspecified elements from the table, but it is
- * guaranteed not to crash and to return real table elements (except when done()
- * is true). */
-
-/* upb_strtable_iter **********************************************************/
-
-/*   upb_strtable_iter i;
- *   upb_strtable_begin(&i, t);
- *   for(; !upb_strtable_done(&i); upb_strtable_next(&i)) {
- *     const char *key = upb_strtable_iter_key(&i);
- *     const upb_value val = upb_strtable_iter_value(&i);
- *     // ...
- *   }
- */
-
-typedef struct {
-  const upb_strtable* t;
-  size_t index;
-} upb_strtable_iter;
-
-void upb_strtable_begin(upb_strtable_iter* i, const upb_strtable* t);
-void upb_strtable_next(upb_strtable_iter* i);
-bool upb_strtable_done(const upb_strtable_iter* i);
-upb_StringView upb_strtable_iter_key(const upb_strtable_iter* i);
-upb_value upb_strtable_iter_value(const upb_strtable_iter* i);
-void upb_strtable_iter_setdone(upb_strtable_iter* i);
-bool upb_strtable_iter_isequal(const upb_strtable_iter* i1,
-                               const upb_strtable_iter* i2);
-
-/* upb_inttable_iter **********************************************************/
-
-/*   upb_inttable_iter i;
- *   upb_inttable_begin(&i, t);
- *   for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
- *     uintptr_t key = upb_inttable_iter_key(&i);
- *     upb_value val = upb_inttable_iter_value(&i);
- *     // ...
- *   }
- */
-
-typedef struct {
-  const upb_inttable* t;
-  size_t index;
-  bool array_part;
-} upb_inttable_iter;
-
-UPB_INLINE const upb_tabent* str_tabent(const upb_strtable_iter* i) {
-  return &i->t->t.entries[i->index];
-}
-
-void upb_inttable_begin(upb_inttable_iter* i, const upb_inttable* t);
-void upb_inttable_next(upb_inttable_iter* i);
-bool upb_inttable_done(const upb_inttable_iter* i);
-uintptr_t upb_inttable_iter_key(const upb_inttable_iter* i);
-upb_value upb_inttable_iter_value(const upb_inttable_iter* i);
-void upb_inttable_iter_setdone(upb_inttable_iter* i);
-bool upb_inttable_iter_isequal(const upb_inttable_iter* i1,
-                               const upb_inttable_iter* i2);
-
-uint32_t _upb_Hash(const void* p, size_t n, uint64_t seed);
+    bool upb_strtable_next2(const upb_strtable* t, upb_StringView* key, upb_value* val, intptr_t* iter);
+    void upb_strtable_removeiter(upb_strtable* t, intptr_t* iter);
+
+    /* DEPRECATED iterators, slated for removal.
+     *
+     * Iterators for int and string tables.  We are subject to some kind of unusual
+     * design constraints:
+     *
+     * For high-level languages:
+     *  - we must be able to guarantee that we don't crash or corrupt memory even if
+     *    the program accesses an invalidated iterator.
+     *
+     * For C++11 range-based for:
+     *  - iterators must be copyable
+     *  - iterators must be comparable
+     *  - it must be possible to construct an "end" value.
+     *
+     * Iteration order is undefined.
+     *
+     * Modifying the table invalidates iterators.  upb_{str,int}table_done() is
+     * guaranteed to work even on an invalidated iterator, as long as the table it
+     * is iterating over has not been freed.  Calling next() or accessing data from
+     * an invalidated iterator yields unspecified elements from the table, but it is
+     * guaranteed not to crash and to return real table elements (except when done()
+     * is true). */
+
+    /* upb_strtable_iter **********************************************************/
+
+    /*   upb_strtable_iter i;
+     *   upb_strtable_begin(&i, t);
+     *   for(; !upb_strtable_done(&i); upb_strtable_next(&i)) {
+     *     const char *key = upb_strtable_iter_key(&i);
+     *     const upb_value val = upb_strtable_iter_value(&i);
+     *     // ...
+     *   }
+     */
+
+    typedef struct
+    {
+        const upb_strtable* t;
+        size_t index;
+    } upb_strtable_iter;
+
+    void upb_strtable_begin(upb_strtable_iter* i, const upb_strtable* t);
+    void upb_strtable_next(upb_strtable_iter* i);
+    bool upb_strtable_done(const upb_strtable_iter* i);
+    upb_StringView upb_strtable_iter_key(const upb_strtable_iter* i);
+    upb_value upb_strtable_iter_value(const upb_strtable_iter* i);
+    void upb_strtable_iter_setdone(upb_strtable_iter* i);
+    bool upb_strtable_iter_isequal(const upb_strtable_iter* i1, const upb_strtable_iter* i2);
+
+    /* upb_inttable_iter **********************************************************/
+
+    /*   upb_inttable_iter i;
+     *   upb_inttable_begin(&i, t);
+     *   for(; !upb_inttable_done(&i); upb_inttable_next(&i)) {
+     *     uintptr_t key = upb_inttable_iter_key(&i);
+     *     upb_value val = upb_inttable_iter_value(&i);
+     *     // ...
+     *   }
+     */
+
+    typedef struct
+    {
+        const upb_inttable* t;
+        size_t index;
+        bool array_part;
+    } upb_inttable_iter;
+
+    UPB_INLINE const upb_tabent* str_tabent(const upb_strtable_iter* i)
+    {
+        return &i->t->t.entries[i->index];
+    }
+
+    void upb_inttable_begin(upb_inttable_iter* i, const upb_inttable* t);
+    void upb_inttable_next(upb_inttable_iter* i);
+    bool upb_inttable_done(const upb_inttable_iter* i);
+    uintptr_t upb_inttable_iter_key(const upb_inttable_iter* i);
+    upb_value upb_inttable_iter_value(const upb_inttable_iter* i);
+    void upb_inttable_iter_setdone(upb_inttable_iter* i);
+    bool upb_inttable_iter_isequal(const upb_inttable_iter* i1, const upb_inttable_iter* i2);
+
+    uint32_t _upb_Hash(const void* p, size_t n, uint64_t seed);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/internal/upb.h b/CAPI/cpp/grpc/include/upb/internal/upb.h
index cdc8bfc..666772d 100644
--- a/CAPI/cpp/grpc/include/upb/internal/upb.h
+++ b/CAPI/cpp/grpc/include/upb/internal/upb.h
@@ -33,26 +33,27 @@
 struct mem_block;
 typedef struct mem_block mem_block;
 
-struct upb_Arena {
-  _upb_ArenaHead head;
-  /* Stores cleanup metadata for this arena.
-   * - a pointer to the current cleanup counter.
-   * - a boolean indicating if there is an unowned initial block.  */
-  uintptr_t cleanup_metadata;
+struct upb_Arena
+{
+    _upb_ArenaHead head;
+    /* Stores cleanup metadata for this arena.
+     * - a pointer to the current cleanup counter.
+     * - a boolean indicating if there is an unowned initial block.  */
+    uintptr_t cleanup_metadata;
 
-  /* Allocator to allocate arena blocks.  We are responsible for freeing these
-   * when we are destroyed. */
-  upb_alloc* block_alloc;
-  uint32_t last_size;
+    /* Allocator to allocate arena blocks.  We are responsible for freeing these
+     * when we are destroyed. */
+    upb_alloc* block_alloc;
+    uint32_t last_size;
 
-  /* When multiple arenas are fused together, each arena points to a parent
-   * arena (root points to itself). The root tracks how many live arenas
-   * reference it. */
-  uint32_t refcount; /* Only used when a->parent == a */
-  struct upb_Arena* parent;
+    /* When multiple arenas are fused together, each arena points to a parent
+     * arena (root points to itself). The root tracks how many live arenas
+     * reference it. */
+    uint32_t refcount; /* Only used when a->parent == a */
+    struct upb_Arena* parent;
 
-  /* Linked list of blocks to free/cleanup. */
-  mem_block *freelist, *freelist_tail;
+    /* Linked list of blocks to free/cleanup. */
+    mem_block *freelist, *freelist_tail;
 };
 
 // Encodes a float or double that is round-trippable, but as short as possible.
@@ -61,7 +62,10 @@ struct upb_Arena {
 // the beginning.
 //
 // The given buffer size must be at least kUpb_RoundTripBufferSize.
-enum { kUpb_RoundTripBufferSize = 32 };
+enum
+{
+    kUpb_RoundTripBufferSize = 32
+};
 void _upb_EncodeRoundTripDouble(double val, char* buf, size_t size);
 void _upb_EncodeRoundTripFloat(float val, char* buf, size_t size);
 
diff --git a/CAPI/cpp/grpc/include/upb/internal/vsnprintf_compat.h b/CAPI/cpp/grpc/include/upb/internal/vsnprintf_compat.h
index a9d84bb..55fbfdf 100644
--- a/CAPI/cpp/grpc/include/upb/internal/vsnprintf_compat.h
+++ b/CAPI/cpp/grpc/include/upb/internal/vsnprintf_compat.h
@@ -33,17 +33,19 @@
 // Must be last.
 #include "upb/port_def.inc"
 
-UPB_INLINE int _upb_vsnprintf(char* buf, size_t size, const char* fmt,
-                              va_list ap) {
+UPB_INLINE int _upb_vsnprintf(char* buf, size_t size, const char* fmt, va_list ap)
+{
 #if defined(__MINGW64__) || defined(__MINGW32__) || defined(_MSC_VER)
-  // The msvc runtime has a non-conforming vsnprintf() that requires the
-  // following compatibility code to become conformant.
-  int n = -1;
-  if (size != 0) n = _vsnprintf_s(buf, size, _TRUNCATE, fmt, ap);
-  if (n == -1) n = _vscprintf(fmt, ap);
-  return n;
+    // The msvc runtime has a non-conforming vsnprintf() that requires the
+    // following compatibility code to become conformant.
+    int n = -1;
+    if (size != 0)
+        n = _vsnprintf_s(buf, size, _TRUNCATE, fmt, ap);
+    if (n == -1)
+        n = _vscprintf(fmt, ap);
+    return n;
 #else
-  return vsnprintf(buf, size, fmt, ap);
+    return vsnprintf(buf, size, fmt, ap);
 #endif
 }
 
diff --git a/CAPI/cpp/grpc/include/upb/json_decode.h b/CAPI/cpp/grpc/include/upb/json_decode.h
index 848f4df..e70f28c 100644
--- a/CAPI/cpp/grpc/include/upb/json_decode.h
+++ b/CAPI/cpp/grpc/include/upb/json_decode.h
@@ -31,14 +31,16 @@
 #include "upb/def.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-enum { upb_JsonDecode_IgnoreUnknown = 1 };
+    enum
+    {
+        upb_JsonDecode_IgnoreUnknown = 1
+    };
 
-bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg,
-                    const upb_MessageDef* m, const upb_DefPool* symtab,
-                    int options, upb_Arena* arena, upb_Status* status);
+    bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg, const upb_MessageDef* m, const upb_DefPool* symtab, int options, upb_Arena* arena, upb_Status* status);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/json_encode.h b/CAPI/cpp/grpc/include/upb/json_encode.h
index 6e0cac3..ec795ea 100644
--- a/CAPI/cpp/grpc/include/upb/json_encode.h
+++ b/CAPI/cpp/grpc/include/upb/json_encode.h
@@ -31,32 +31,32 @@
 #include "upb/def.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-enum {
-  /* When set, emits 0/default values.  TODO(haberman): proto3 only? */
-  upb_JsonEncode_EmitDefaults = 1 << 0,
+    enum
+    {
+        /* When set, emits 0/default values.  TODO(haberman): proto3 only? */
+        upb_JsonEncode_EmitDefaults = 1 << 0,
 
-  /* When set, use normal (snake_case) field names instead of JSON (camelCase)
-     names. */
-  upb_JsonEncode_UseProtoNames = 1 << 1,
+        /* When set, use normal (snake_case) field names instead of JSON (camelCase)
+           names. */
+        upb_JsonEncode_UseProtoNames = 1 << 1,
 
-  /* When set, emits enums as their integer values instead of as their names. */
-  upb_JsonEncode_FormatEnumsAsIntegers = 1 << 2
-};
+        /* When set, emits enums as their integer values instead of as their names. */
+        upb_JsonEncode_FormatEnumsAsIntegers = 1 << 2
+    };
 
-/* Encodes the given |msg| to JSON format.  The message's reflection is given in
- * |m|.  The symtab in |symtab| is used to find extensions (if NULL, extensions
- * will not be printed).
- *
- * Output is placed in the given buffer, and always NULL-terminated.  The output
- * size (excluding NULL) is returned.  This means that a return value >= |size|
- * implies that the output was truncated.  (These are the same semantics as
- * snprintf()). */
-size_t upb_JsonEncode(const upb_Message* msg, const upb_MessageDef* m,
-                      const upb_DefPool* ext_pool, int options, char* buf,
-                      size_t size, upb_Status* status);
+    /* Encodes the given |msg| to JSON format.  The message's reflection is given in
+     * |m|.  The symtab in |symtab| is used to find extensions (if NULL, extensions
+     * will not be printed).
+     *
+     * Output is placed in the given buffer, and always NULL-terminated.  The output
+     * size (excluding NULL) is returned.  This means that a return value >= |size|
+     * implies that the output was truncated.  (These are the same semantics as
+     * snprintf()). */
+    size_t upb_JsonEncode(const upb_Message* msg, const upb_MessageDef* m, const upb_DefPool* ext_pool, int options, char* buf, size_t size, upb_Status* status);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/map.h b/CAPI/cpp/grpc/include/upb/map.h
index 8ee0ddd..e8c078d 100644
--- a/CAPI/cpp/grpc/include/upb/map.h
+++ b/CAPI/cpp/grpc/include/upb/map.h
@@ -35,78 +35,77 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/* Creates a new map on the given arena with the given key/value size. */
-upb_Map* upb_Map_New(upb_Arena* a, upb_CType key_type, upb_CType value_type);
-
-/* Returns the number of entries in the map. */
-size_t upb_Map_Size(const upb_Map* map);
-
-/* Stores a value for the given key into |*val| (or the zero value if the key is
- * not present).  Returns whether the key was present.  The |val| pointer may be
- * NULL, in which case the function tests whether the given key is present.  */
-bool upb_Map_Get(const upb_Map* map, upb_MessageValue key,
-                 upb_MessageValue* val);
-
-/* Removes all entries in the map. */
-void upb_Map_Clear(upb_Map* map);
-
-typedef enum {
-  // LINT.IfChange
-  kUpb_MapInsertStatus_Inserted = 0,
-  kUpb_MapInsertStatus_Replaced = 1,
-  kUpb_MapInsertStatus_OutOfMemory = 2,
-  // LINT.ThenChange(//depot/google3/third_party/upb/upb/msg_internal.h)
-} upb_MapInsertStatus;
-
-/* Sets the given key to the given value, returning whether the key was inserted
- * or replaced.  If the key was inserted, then any existing iterators will be
- * invalidated. */
-upb_MapInsertStatus upb_Map_Insert(upb_Map* map, upb_MessageValue key,
-                                   upb_MessageValue val, upb_Arena* arena);
-
-/* Sets the given key to the given value.  Returns false if memory allocation
- * failed. If the key is newly inserted, then any existing iterators will be
- * invalidated. */
-UPB_INLINE bool upb_Map_Set(upb_Map* map, upb_MessageValue key,
-                            upb_MessageValue val, upb_Arena* arena) {
-  return upb_Map_Insert(map, key, val, arena) !=
-         kUpb_MapInsertStatus_OutOfMemory;
-}
-
-/* Deletes this key from the table.  Returns true if the key was present. */
-bool upb_Map_Delete(upb_Map* map, upb_MessageValue key);
-
-/* Map iteration:
- *
- * size_t iter = kUpb_Map_Begin;
- * while (upb_MapIterator_Next(map, &iter)) {
- *   upb_MessageValue key = upb_MapIterator_Key(map, iter);
- *   upb_MessageValue val = upb_MapIterator_Value(map, iter);
- *
- *   // If mutating is desired.
- *   upb_MapIterator_SetValue(map, iter, value2);
- * }
- */
-
-/* Advances to the next entry.  Returns false if no more entries are present. */
-bool upb_MapIterator_Next(const upb_Map* map, size_t* iter);
-
-/* Returns true if the iterator still points to a valid entry, or false if the
- * iterator is past the last element. It is an error to call this function with
- * kUpb_Map_Begin (you must call next() at least once first). */
-bool upb_MapIterator_Done(const upb_Map* map, size_t iter);
-
-/* Returns the key and value for this entry of the map. */
-upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter);
-upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter);
-
-/* Sets the value for this entry.  The iterator must not be done, and the
- * iterator must not have been initialized const. */
-void upb_MapIterator_SetValue(upb_Map* map, size_t iter,
-                              upb_MessageValue value);
+    /* Creates a new map on the given arena with the given key/value size. */
+    upb_Map* upb_Map_New(upb_Arena* a, upb_CType key_type, upb_CType value_type);
+
+    /* Returns the number of entries in the map. */
+    size_t upb_Map_Size(const upb_Map* map);
+
+    /* Stores a value for the given key into |*val| (or the zero value if the key is
+     * not present).  Returns whether the key was present.  The |val| pointer may be
+     * NULL, in which case the function tests whether the given key is present.  */
+    bool upb_Map_Get(const upb_Map* map, upb_MessageValue key, upb_MessageValue* val);
+
+    /* Removes all entries in the map. */
+    void upb_Map_Clear(upb_Map* map);
+
+    typedef enum
+    {
+        // LINT.IfChange
+        kUpb_MapInsertStatus_Inserted = 0,
+        kUpb_MapInsertStatus_Replaced = 1,
+        kUpb_MapInsertStatus_OutOfMemory = 2,
+        // LINT.ThenChange(//depot/google3/third_party/upb/upb/msg_internal.h)
+    } upb_MapInsertStatus;
+
+    /* Sets the given key to the given value, returning whether the key was inserted
+     * or replaced.  If the key was inserted, then any existing iterators will be
+     * invalidated. */
+    upb_MapInsertStatus upb_Map_Insert(upb_Map* map, upb_MessageValue key, upb_MessageValue val, upb_Arena* arena);
+
+    /* Sets the given key to the given value.  Returns false if memory allocation
+     * failed. If the key is newly inserted, then any existing iterators will be
+     * invalidated. */
+    UPB_INLINE bool upb_Map_Set(upb_Map* map, upb_MessageValue key, upb_MessageValue val, upb_Arena* arena)
+    {
+        return upb_Map_Insert(map, key, val, arena) !=
+               kUpb_MapInsertStatus_OutOfMemory;
+    }
+
+    /* Deletes this key from the table.  Returns true if the key was present. */
+    bool upb_Map_Delete(upb_Map* map, upb_MessageValue key);
+
+    /* Map iteration:
+     *
+     * size_t iter = kUpb_Map_Begin;
+     * while (upb_MapIterator_Next(map, &iter)) {
+     *   upb_MessageValue key = upb_MapIterator_Key(map, iter);
+     *   upb_MessageValue val = upb_MapIterator_Value(map, iter);
+     *
+     *   // If mutating is desired.
+     *   upb_MapIterator_SetValue(map, iter, value2);
+     * }
+     */
+
+    /* Advances to the next entry.  Returns false if no more entries are present. */
+    bool upb_MapIterator_Next(const upb_Map* map, size_t* iter);
+
+    /* Returns true if the iterator still points to a valid entry, or false if the
+     * iterator is past the last element. It is an error to call this function with
+     * kUpb_Map_Begin (you must call next() at least once first). */
+    bool upb_MapIterator_Done(const upb_Map* map, size_t iter);
+
+    /* Returns the key and value for this entry of the map. */
+    upb_MessageValue upb_MapIterator_Key(const upb_Map* map, size_t iter);
+    upb_MessageValue upb_MapIterator_Value(const upb_Map* map, size_t iter);
+
+    /* Sets the value for this entry.  The iterator must not be done, and the
+     * iterator must not have been initialized const. */
+    void upb_MapIterator_SetValue(upb_Map* map, size_t iter, upb_MessageValue value);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/message_value.h b/CAPI/cpp/grpc/include/upb/message_value.h
index a08b90f..5df4d06 100644
--- a/CAPI/cpp/grpc/include/upb/message_value.h
+++ b/CAPI/cpp/grpc/include/upb/message_value.h
@@ -32,30 +32,33 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-// Definitions commn to both upb_Array and upb_Map.
+    // Definitions commn to both upb_Array and upb_Map.
 
-typedef union {
-  bool bool_val;
-  float float_val;
-  double double_val;
-  int32_t int32_val;
-  int64_t int64_val;
-  uint32_t uint32_val;
-  uint64_t uint64_val;
-  const upb_Map* map_val;
-  const upb_Message* msg_val;
-  const upb_Array* array_val;
-  upb_StringView str_val;
-} upb_MessageValue;
+    typedef union
+    {
+        bool bool_val;
+        float float_val;
+        double double_val;
+        int32_t int32_val;
+        int64_t int64_val;
+        uint32_t uint32_val;
+        uint64_t uint64_val;
+        const upb_Map* map_val;
+        const upb_Message* msg_val;
+        const upb_Array* array_val;
+        upb_StringView str_val;
+    } upb_MessageValue;
 
-typedef union {
-  upb_Map* map;
-  upb_Message* msg;
-  upb_Array* array;
-} upb_MutableMessageValue;
+    typedef union
+    {
+        upb_Map* map;
+        upb_Message* msg;
+        upb_Array* array;
+    } upb_MutableMessageValue;
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/mini_descriptor.h b/CAPI/cpp/grpc/include/upb/mini_descriptor.h
index 829d008..de75185 100644
--- a/CAPI/cpp/grpc/include/upb/mini_descriptor.h
+++ b/CAPI/cpp/grpc/include/upb/mini_descriptor.h
@@ -35,19 +35,19 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** upb_MiniDescriptor ********************************************************/
+    /** upb_MiniDescriptor ********************************************************/
 
-upb_StringView upb_MiniDescriptor_EncodeEnum(const upb_EnumDef* enum_def,
-                                             upb_Arena* a);
+    upb_StringView upb_MiniDescriptor_EncodeEnum(const upb_EnumDef* enum_def, upb_Arena* a);
 
-upb_StringView upb_MiniDescriptor_EncodeExtension(const upb_FieldDef* field_def,
-                                                  upb_Arena* a);
+    upb_StringView upb_MiniDescriptor_EncodeExtension(const upb_FieldDef* field_def, upb_Arena* a);
 
-upb_StringView upb_MiniDescriptor_EncodeMessage(
-    const upb_MessageDef* message_def, upb_Arena* a);
+    upb_StringView upb_MiniDescriptor_EncodeMessage(
+        const upb_MessageDef* message_def, upb_Arena* a
+    );
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/mini_table.h b/CAPI/cpp/grpc/include/upb/mini_table.h
index 6c41f81..9e2b2aa 100644
--- a/CAPI/cpp/grpc/include/upb/mini_table.h
+++ b/CAPI/cpp/grpc/include/upb/mini_table.h
@@ -34,151 +34,140 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-const upb_MiniTable_Field* upb_MiniTable_FindFieldByNumber(
-    const upb_MiniTable* table, uint32_t number);
-
-UPB_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
-    const upb_MiniTable* mini_table, const upb_MiniTable_Field* field) {
-  return mini_table->subs[field->submsg_index].submsg;
-}
-
-UPB_INLINE bool upb_MiniTable_Enum_CheckValue(const upb_MiniTable_Enum* e,
-                                              int32_t val) {
-  uint32_t uval = (uint32_t)val;
-  if (uval < 64) return e->mask & (1ULL << uval);
-  // OPT: binary search long lists?
-  int n = e->value_count;
-  for (int i = 0; i < n; i++) {
-    if (e->values[i] == val) return true;
-  }
-  return false;
-}
-
-/** upb_MtDataEncoder *********************************************************/
-
-// Functions to encode a string in a format that can be loaded by
-// upb_MiniTable_Build().
-
-typedef enum {
-  kUpb_MessageModifier_ValidateUtf8 = 1 << 0,
-  kUpb_MessageModifier_DefaultIsPacked = 1 << 1,
-  kUpb_MessageModifier_IsExtendable = 1 << 2,
-} kUpb_MessageModifier;
-
-typedef enum {
-  kUpb_FieldModifier_IsRepeated = 1 << 0,
-  kUpb_FieldModifier_IsPacked = 1 << 1,
-  kUpb_FieldModifier_IsClosedEnum = 1 << 2,
-  kUpb_FieldModifier_IsProto3Singular = 1 << 3,
-  kUpb_FieldModifier_IsRequired = 1 << 4,
-} kUpb_FieldModifier;
-
-typedef struct {
-  char* end;  // Limit of the buffer passed as a parameter.
-  // Aliased to internal-only members in .cc.
-  char internal[32];
-} upb_MtDataEncoder;
+    const upb_MiniTable_Field* upb_MiniTable_FindFieldByNumber(
+        const upb_MiniTable* table, uint32_t number
+    );
+
+    UPB_INLINE const upb_MiniTable* upb_MiniTable_GetSubMessageTable(
+        const upb_MiniTable* mini_table, const upb_MiniTable_Field* field
+    )
+    {
+        return mini_table->subs[field->submsg_index].submsg;
+    }
+
+    UPB_INLINE bool upb_MiniTable_Enum_CheckValue(const upb_MiniTable_Enum* e, int32_t val)
+    {
+        uint32_t uval = (uint32_t)val;
+        if (uval < 64)
+            return e->mask & (1ULL << uval);
+        // OPT: binary search long lists?
+        int n = e->value_count;
+        for (int i = 0; i < n; i++)
+        {
+            if (e->values[i] == val)
+                return true;
+        }
+        return false;
+    }
+
+    /** upb_MtDataEncoder *********************************************************/
+
+    // Functions to encode a string in a format that can be loaded by
+    // upb_MiniTable_Build().
+
+    typedef enum
+    {
+        kUpb_MessageModifier_ValidateUtf8 = 1 << 0,
+        kUpb_MessageModifier_DefaultIsPacked = 1 << 1,
+        kUpb_MessageModifier_IsExtendable = 1 << 2,
+    } kUpb_MessageModifier;
+
+    typedef enum
+    {
+        kUpb_FieldModifier_IsRepeated = 1 << 0,
+        kUpb_FieldModifier_IsPacked = 1 << 1,
+        kUpb_FieldModifier_IsClosedEnum = 1 << 2,
+        kUpb_FieldModifier_IsProto3Singular = 1 << 3,
+        kUpb_FieldModifier_IsRequired = 1 << 4,
+    } kUpb_FieldModifier;
+
+    typedef struct
+    {
+        char* end;  // Limit of the buffer passed as a parameter.
+        // Aliased to internal-only members in .cc.
+        char internal[32];
+    } upb_MtDataEncoder;
 
 // If the input buffer has at least this many bytes available, the encoder call
 // is guaranteed to succeed (as long as field number order is maintained).
 #define kUpb_MtDataEncoder_MinSize 16
 
-// Encodes field/oneof information for a given message.  The sequence of calls
-// should look like:
-//
-//   upb_MtDataEncoder e;
-//   char buf[256];
-//   char* ptr = buf;
-//   e.end = ptr + sizeof(buf);
-//   ptr = upb_MtDataEncoder_StartMessage(&e, ptr);
-//   // Fields *must* be in field number order.
-//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
-//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
-//   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
-//
-//   // If oneofs are present.  Oneofs must be encoded after regular fields.
-//   ptr = upb_MiniTable_StartOneof(&e, ptr)
-//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
-//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
-//
-//   ptr = upb_MiniTable_StartOneof(&e, ptr);
-//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
-//   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
-//
-// Oneofs must be encoded after all regular fields.
-char* upb_MtDataEncoder_StartMessage(upb_MtDataEncoder* e, char* ptr,
-                                     uint64_t msg_mod);
-char* upb_MtDataEncoder_PutField(upb_MtDataEncoder* e, char* ptr,
-                                 upb_FieldType type, uint32_t field_num,
-                                 uint64_t field_mod);
-char* upb_MtDataEncoder_StartOneof(upb_MtDataEncoder* e, char* ptr);
-char* upb_MtDataEncoder_PutOneofField(upb_MtDataEncoder* e, char* ptr,
-                                      uint32_t field_num);
-
-// Encodes the set of values for a given enum.  The values must be given in
-// order (after casting to uint32_t), and repeats are not allowed.
-void upb_MtDataEncoder_StartEnum(upb_MtDataEncoder* e);
-char* upb_MtDataEncoder_PutEnumValue(upb_MtDataEncoder* e, char* ptr,
-                                     uint32_t val);
-char* upb_MtDataEncoder_EndEnum(upb_MtDataEncoder* e, char* ptr);
-
-/** upb_MiniTable *************************************************************/
-
-typedef enum {
-  kUpb_MiniTablePlatform_32Bit,
-  kUpb_MiniTablePlatform_64Bit,
-  kUpb_MiniTablePlatform_Native =
-      UPB_SIZE(kUpb_MiniTablePlatform_32Bit, kUpb_MiniTablePlatform_64Bit),
-} upb_MiniTablePlatform;
-
-// Builds a mini table from the data encoded in the buffer [data, len]. If any
-// errors occur, returns NULL and sets a status message. In the success case,
-// the caller must call upb_MiniTable_SetSub*() for all message or proto2 enum
-// fields to link the table to the appropriate sub-tables.
-upb_MiniTable* upb_MiniTable_Build(const char* data, size_t len,
-                                   upb_MiniTablePlatform platform,
-                                   upb_Arena* arena, upb_Status* status);
-void upb_MiniTable_SetSubMessage(upb_MiniTable* table,
-                                 upb_MiniTable_Field* field,
-                                 const upb_MiniTable* sub);
-void upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTable_Field* field,
-                              const upb_MiniTable_Enum* sub);
-
-bool upb_MiniTable_BuildExtension(const char* data, size_t len,
-                                  upb_MiniTable_Extension* ext,
-                                  upb_MiniTable_Sub sub, upb_Status* status);
-
-// Special-case functions for MessageSet layout and map entries.
-upb_MiniTable* upb_MiniTable_BuildMessageSet(upb_MiniTablePlatform platform,
-                                             upb_Arena* arena);
-upb_MiniTable* upb_MiniTable_BuildMapEntry(upb_FieldType key_type,
-                                           upb_FieldType value_type,
-                                           bool value_is_proto3_enum,
-                                           upb_MiniTablePlatform platform,
-                                           upb_Arena* arena);
-
-upb_MiniTable_Enum* upb_MiniTable_BuildEnum(const char* data, size_t len,
-                                            upb_Arena* arena,
-                                            upb_Status* status);
-
-// Like upb_MiniTable_Build(), but the user provides a buffer of layout data so
-// it can be reused from call to call, avoiding repeated realloc()/free().
-//
-// The caller owns `*buf` both before and after the call, and must free() it
-// when it is no longer in use.  The function will realloc() `*buf` as
-// necessary, updating `*size` accordingly.
-upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len,
-                                          upb_MiniTablePlatform platform,
-                                          upb_Arena* arena, void** buf,
-                                          size_t* buf_size, upb_Status* status);
-
-// For testing only.
-char upb_ToBase92(int8_t ch);
-char upb_FromBase92(uint8_t ch);
-bool upb_IsTypePackable(upb_FieldType type);
+    // Encodes field/oneof information for a given message.  The sequence of calls
+    // should look like:
+    //
+    //   upb_MtDataEncoder e;
+    //   char buf[256];
+    //   char* ptr = buf;
+    //   e.end = ptr + sizeof(buf);
+    //   ptr = upb_MtDataEncoder_StartMessage(&e, ptr);
+    //   // Fields *must* be in field number order.
+    //   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+    //   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+    //   ptr = upb_MtDataEncoder_PutField(&e, ptr, ...);
+    //
+    //   // If oneofs are present.  Oneofs must be encoded after regular fields.
+    //   ptr = upb_MiniTable_StartOneof(&e, ptr)
+    //   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+    //   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+    //
+    //   ptr = upb_MiniTable_StartOneof(&e, ptr);
+    //   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+    //   ptr = upb_MiniTable_PutOneofField(&e, ptr, ...);
+    //
+    // Oneofs must be encoded after all regular fields.
+    char* upb_MtDataEncoder_StartMessage(upb_MtDataEncoder* e, char* ptr, uint64_t msg_mod);
+    char* upb_MtDataEncoder_PutField(upb_MtDataEncoder* e, char* ptr, upb_FieldType type, uint32_t field_num, uint64_t field_mod);
+    char* upb_MtDataEncoder_StartOneof(upb_MtDataEncoder* e, char* ptr);
+    char* upb_MtDataEncoder_PutOneofField(upb_MtDataEncoder* e, char* ptr, uint32_t field_num);
+
+    // Encodes the set of values for a given enum.  The values must be given in
+    // order (after casting to uint32_t), and repeats are not allowed.
+    void upb_MtDataEncoder_StartEnum(upb_MtDataEncoder* e);
+    char* upb_MtDataEncoder_PutEnumValue(upb_MtDataEncoder* e, char* ptr, uint32_t val);
+    char* upb_MtDataEncoder_EndEnum(upb_MtDataEncoder* e, char* ptr);
+
+    /** upb_MiniTable *************************************************************/
+
+    typedef enum
+    {
+        kUpb_MiniTablePlatform_32Bit,
+        kUpb_MiniTablePlatform_64Bit,
+        kUpb_MiniTablePlatform_Native =
+            UPB_SIZE(kUpb_MiniTablePlatform_32Bit, kUpb_MiniTablePlatform_64Bit),
+    } upb_MiniTablePlatform;
+
+    // Builds a mini table from the data encoded in the buffer [data, len]. If any
+    // errors occur, returns NULL and sets a status message. In the success case,
+    // the caller must call upb_MiniTable_SetSub*() for all message or proto2 enum
+    // fields to link the table to the appropriate sub-tables.
+    upb_MiniTable* upb_MiniTable_Build(const char* data, size_t len, upb_MiniTablePlatform platform, upb_Arena* arena, upb_Status* status);
+    void upb_MiniTable_SetSubMessage(upb_MiniTable* table, upb_MiniTable_Field* field, const upb_MiniTable* sub);
+    void upb_MiniTable_SetSubEnum(upb_MiniTable* table, upb_MiniTable_Field* field, const upb_MiniTable_Enum* sub);
+
+    bool upb_MiniTable_BuildExtension(const char* data, size_t len, upb_MiniTable_Extension* ext, upb_MiniTable_Sub sub, upb_Status* status);
+
+    // Special-case functions for MessageSet layout and map entries.
+    upb_MiniTable* upb_MiniTable_BuildMessageSet(upb_MiniTablePlatform platform, upb_Arena* arena);
+    upb_MiniTable* upb_MiniTable_BuildMapEntry(upb_FieldType key_type, upb_FieldType value_type, bool value_is_proto3_enum, upb_MiniTablePlatform platform, upb_Arena* arena);
+
+    upb_MiniTable_Enum* upb_MiniTable_BuildEnum(const char* data, size_t len, upb_Arena* arena, upb_Status* status);
+
+    // Like upb_MiniTable_Build(), but the user provides a buffer of layout data so
+    // it can be reused from call to call, avoiding repeated realloc()/free().
+    //
+    // The caller owns `*buf` both before and after the call, and must free() it
+    // when it is no longer in use.  The function will realloc() `*buf` as
+    // necessary, updating `*size` accordingly.
+    upb_MiniTable* upb_MiniTable_BuildWithBuf(const char* data, size_t len, upb_MiniTablePlatform platform, upb_Arena* arena, void** buf, size_t* buf_size, upb_Status* status);
+
+    // For testing only.
+    char upb_ToBase92(int8_t ch);
+    char upb_FromBase92(uint8_t ch);
+    bool upb_IsTypePackable(upb_FieldType type);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/mini_table.hpp b/CAPI/cpp/grpc/include/upb/mini_table.hpp
index 57de9e9..bf76477 100644
--- a/CAPI/cpp/grpc/include/upb/mini_table.hpp
+++ b/CAPI/cpp/grpc/include/upb/mini_table.hpp
@@ -34,78 +34,100 @@
 
 #include "upb/mini_table.h"
 
-namespace upb {
-
-class MtDataEncoder {
- public:
-  MtDataEncoder() : appender_(&encoder_) {}
-
-  bool StartMessage(uint64_t msg_mod) {
-    return appender_([=](char* buf) {
-      return upb_MtDataEncoder_StartMessage(&encoder_, buf, msg_mod);
-    });
-  }
-
-  bool PutField(upb_FieldType type, uint32_t field_num, uint64_t field_mod) {
-    return appender_([=](char* buf) {
-      return upb_MtDataEncoder_PutField(&encoder_, buf, type, field_num,
-                                        field_mod);
-    });
-  }
-
-  bool StartOneof() {
-    return appender_([=](char* buf) {
-      return upb_MtDataEncoder_StartOneof(&encoder_, buf);
-    });
-  }
-
-  bool PutOneofField(uint32_t field_num) {
-    return appender_([=](char* buf) {
-      return upb_MtDataEncoder_PutOneofField(&encoder_, buf, field_num);
-    });
-  }
-
-  void StartEnum() { upb_MtDataEncoder_StartEnum(&encoder_); }
-
-  bool PutEnumValue(uint32_t enum_value) {
-    return appender_([=](char* buf) {
-      return upb_MtDataEncoder_PutEnumValue(&encoder_, buf, enum_value);
-    });
-  }
-
-  bool EndEnum() {
-    return appender_(
-        [=](char* buf) { return upb_MtDataEncoder_EndEnum(&encoder_, buf); });
-  }
-
-  const std::string& data() const { return appender_.data(); }
-
- private:
-  class StringAppender {
-   public:
-    StringAppender(upb_MtDataEncoder* e) { e->end = buf_ + sizeof(buf_); }
-
-    template <class T>
-    bool operator()(T&& func) {
-      char* end = func(buf_);
-      if (!end) return false;
-      // C++ does not guarantee that string has doubling growth behavior, but
-      // we need it to avoid O(n^2).
-      str_.reserve(_upb_Log2CeilingSize(str_.size() + (end - buf_)));
-      str_.append(buf_, end - buf_);
-      return true;
-    }
-
-    const std::string& data() const { return str_; }
-
-   private:
-    char buf_[kUpb_MtDataEncoder_MinSize];
-    std::string str_;
-  };
-
-  upb_MtDataEncoder encoder_;
-  StringAppender appender_;
-};
+namespace upb
+{
+
+    class MtDataEncoder
+    {
+    public:
+        MtDataEncoder() :
+            appender_(&encoder_)
+        {
+        }
+
+        bool StartMessage(uint64_t msg_mod)
+        {
+            return appender_([=](char* buf)
+                             { return upb_MtDataEncoder_StartMessage(&encoder_, buf, msg_mod); });
+        }
+
+        bool PutField(upb_FieldType type, uint32_t field_num, uint64_t field_mod)
+        {
+            return appender_([=](char* buf)
+                             { return upb_MtDataEncoder_PutField(&encoder_, buf, type, field_num, field_mod); });
+        }
+
+        bool StartOneof()
+        {
+            return appender_([=](char* buf)
+                             { return upb_MtDataEncoder_StartOneof(&encoder_, buf); });
+        }
+
+        bool PutOneofField(uint32_t field_num)
+        {
+            return appender_([=](char* buf)
+                             { return upb_MtDataEncoder_PutOneofField(&encoder_, buf, field_num); });
+        }
+
+        void StartEnum()
+        {
+            upb_MtDataEncoder_StartEnum(&encoder_);
+        }
+
+        bool PutEnumValue(uint32_t enum_value)
+        {
+            return appender_([=](char* buf)
+                             { return upb_MtDataEncoder_PutEnumValue(&encoder_, buf, enum_value); });
+        }
+
+        bool EndEnum()
+        {
+            return appender_(
+                [=](char* buf)
+                { return upb_MtDataEncoder_EndEnum(&encoder_, buf); }
+            );
+        }
+
+        const std::string& data() const
+        {
+            return appender_.data();
+        }
+
+    private:
+        class StringAppender
+        {
+        public:
+            StringAppender(upb_MtDataEncoder* e)
+            {
+                e->end = buf_ + sizeof(buf_);
+            }
+
+            template<class T>
+            bool operator()(T&& func)
+            {
+                char* end = func(buf_);
+                if (!end)
+                    return false;
+                // C++ does not guarantee that string has doubling growth behavior, but
+                // we need it to avoid O(n^2).
+                str_.reserve(_upb_Log2CeilingSize(str_.size() + (end - buf_)));
+                str_.append(buf_, end - buf_);
+                return true;
+            }
+
+            const std::string& data() const
+            {
+                return str_;
+            }
+
+        private:
+            char buf_[kUpb_MtDataEncoder_MinSize];
+            std::string str_;
+        };
+
+        upb_MtDataEncoder encoder_;
+        StringAppender appender_;
+    };
 
 }  // namespace upb
 
diff --git a/CAPI/cpp/grpc/include/upb/mini_table_accessors.h b/CAPI/cpp/grpc/include/upb/mini_table_accessors.h
index 750f66f..1234177 100644
--- a/CAPI/cpp/grpc/include/upb/mini_table_accessors.h
+++ b/CAPI/cpp/grpc/include/upb/mini_table_accessors.h
@@ -36,231 +36,211 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-bool upb_MiniTable_HasField(const upb_Message* msg,
-                            const upb_MiniTable_Field* field);
-
-void upb_MiniTable_ClearField(upb_Message* msg,
-                              const upb_MiniTable_Field* field);
-
-UPB_INLINE bool upb_MiniTable_GetBool(const upb_Message* msg,
-                                      const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bool);
-  return *UPB_PTR_AT(msg, field->offset, bool);
-}
-
-UPB_INLINE void upb_MiniTable_SetBool(upb_Message* msg,
-                                      const upb_MiniTable_Field* field,
-                                      bool value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bool);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, bool) = value;
-}
-
-UPB_INLINE int32_t upb_MiniTable_GetInt32(const upb_Message* msg,
-                                          const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int32 ||
-             field->descriptortype == kUpb_FieldType_SInt32 ||
-             field->descriptortype == kUpb_FieldType_SFixed32);
-  return *UPB_PTR_AT(msg, field->offset, int32_t);
-}
-
-UPB_INLINE void upb_MiniTable_SetInt32(upb_Message* msg,
-                                       const upb_MiniTable_Field* field,
-                                       int32_t value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int32 ||
-             field->descriptortype == kUpb_FieldType_SInt32 ||
-             field->descriptortype == kUpb_FieldType_SFixed32);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, int32_t) = value;
-}
-
-UPB_INLINE uint32_t upb_MiniTable_GetUInt32(const upb_Message* msg,
-                                            const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt32 ||
-             field->descriptortype == kUpb_FieldType_Fixed32);
-  return *UPB_PTR_AT(msg, field->offset, uint32_t);
-}
-
-UPB_INLINE void upb_MiniTable_SetUInt32(upb_Message* msg,
-                                        const upb_MiniTable_Field* field,
-                                        uint32_t value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt32 ||
-             field->descriptortype == kUpb_FieldType_Fixed32);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, uint32_t) = value;
-}
-
-UPB_INLINE int32_t upb_MiniTable_GetEnum(const upb_Message* msg,
-                                         const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Enum);
-  return *UPB_PTR_AT(msg, field->offset, int32_t);
-}
-
-UPB_INLINE void upb_MiniTable_SetEnum(upb_Message* msg,
-                                      const upb_MiniTable_Field* field,
-                                      int32_t value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Enum);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, int32_t) = value;
-}
-
-UPB_INLINE int64_t upb_MiniTable_GetInt64(const upb_Message* msg,
-                                          const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int64 ||
-             field->descriptortype == kUpb_FieldType_SInt64 ||
-             field->descriptortype == kUpb_FieldType_SFixed64);
-  return *UPB_PTR_AT(msg, field->offset, int64_t);
-}
-
-UPB_INLINE void upb_MiniTable_SetInt64(upb_Message* msg,
-                                       const upb_MiniTable_Field* field,
-                                       int64_t value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int64 ||
-             field->descriptortype == kUpb_FieldType_SInt64 ||
-             field->descriptortype == kUpb_FieldType_SFixed64);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, int64_t) = value;
-}
-
-UPB_INLINE uint64_t upb_MiniTable_GetUInt64(const upb_Message* msg,
-                                            const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt64 ||
-             field->descriptortype == kUpb_FieldType_Fixed64);
-  return *UPB_PTR_AT(msg, field->offset, uint64_t);
-}
-
-UPB_INLINE void upb_MiniTable_SetUInt64(upb_Message* msg,
-                                        const upb_MiniTable_Field* field,
-                                        uint64_t value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt64 ||
-             field->descriptortype == kUpb_FieldType_Fixed64);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, uint64_t) = value;
-}
-
-UPB_INLINE float upb_MiniTable_GetFloat(const upb_Message* msg,
-                                        const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Float);
-  return *UPB_PTR_AT(msg, field->offset, float);
-}
-
-UPB_INLINE void upb_MiniTable_SetFloat(upb_Message* msg,
-                                       const upb_MiniTable_Field* field,
-                                       float value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Float);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, float) = value;
-}
-
-UPB_INLINE double upb_MiniTable_GetDouble(const upb_Message* msg,
-                                          const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Double);
-  return *UPB_PTR_AT(msg, field->offset, double);
-}
-
-UPB_INLINE void upb_MiniTable_SetDouble(upb_Message* msg,
-                                        const upb_MiniTable_Field* field,
-                                        double value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Double);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, double) = value;
-}
-
-UPB_INLINE upb_StringView upb_MiniTable_GetString(
-    const upb_Message* msg, const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bytes ||
-             field->descriptortype == kUpb_FieldType_String);
-  return *UPB_PTR_AT(msg, field->offset, upb_StringView);
-}
-
-UPB_INLINE void upb_MiniTable_SetString(upb_Message* msg,
-                                        const upb_MiniTable_Field* field,
-                                        upb_StringView value) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bytes ||
-             field->descriptortype == kUpb_FieldType_String);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, upb_StringView) = value;
-}
-
-UPB_INLINE const upb_Message* upb_MiniTable_GetMessage(
-    const upb_Message* msg, const upb_MiniTable_Field* field) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
-             field->descriptortype == kUpb_FieldType_Group);
-  return *UPB_PTR_AT(msg, field->offset, const upb_Message*);
-}
-
-UPB_INLINE void upb_MiniTable_SetMessage(upb_Message* msg,
-                                         const upb_MiniTable_Field* field,
-                                         upb_Message* sub_message) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
-             field->descriptortype == kUpb_FieldType_Group);
-  _upb_MiniTable_SetPresence(msg, field);
-  *UPB_PTR_AT(msg, field->offset, const upb_Message*) = sub_message;
-}
-
-UPB_INLINE upb_Message* upb_MiniTable_GetMutableMessage(
-    upb_Message* msg, const upb_MiniTable* mini_table,
-    const upb_MiniTable_Field* field, upb_Arena* arena) {
-  UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message ||
-             field->descriptortype == kUpb_FieldType_Group);
-  upb_Message* sub_message = *UPB_PTR_AT(msg, field->offset, upb_Message*);
-  if (!sub_message) {
-    sub_message =
-        _upb_Message_New(mini_table->subs[field->submsg_index].submsg, arena);
-    *UPB_PTR_AT(msg, field->offset, upb_Message*) = sub_message;
-    _upb_MiniTable_SetPresence(msg, field);
-  }
-  return sub_message;
-}
-
-UPB_INLINE const upb_Array* upb_MiniTable_GetArray(
-    const upb_Message* msg, const upb_MiniTable_Field* field) {
-  return (const upb_Array*)*UPB_PTR_AT(msg, field->offset, upb_Array*);
-}
-
-UPB_INLINE upb_Array* upb_MiniTable_GetMutableArray(
-    upb_Message* msg, const upb_MiniTable_Field* field) {
-  return (upb_Array*)*UPB_PTR_AT(msg, field->offset, upb_Array*);
-}
-
-void* upb_MiniTable_ResizeArray(upb_Message* msg,
-                                const upb_MiniTable_Field* field, size_t len,
-                                upb_Arena* arena);
-typedef enum {
-  kUpb_GetExtension_Ok,
-  kUpb_GetExtension_NotPresent,
-  kUpb_GetExtension_ParseError,
-  kUpb_GetExtension_OutOfMemory,
-} upb_GetExtension_Status;
-
-typedef enum {
-  kUpb_GetExtensionAsBytes_Ok,
-  kUpb_GetExtensionAsBytes_NotPresent,
-  kUpb_GetExtensionAsBytes_EncodeError,
-} upb_GetExtensionAsBytes_Status;
-
-// Returns a message extension or promotes an unknown field to
-// an extension.
-//
-// TODO(ferhat): Only supports extension fields that are messages,
-// expand support to include non-message types.
-upb_GetExtension_Status upb_MiniTable_GetOrPromoteExtension(
-    upb_Message* msg, const upb_MiniTable_Extension* ext_table,
-    int decode_options, upb_Arena* arena,
-    const upb_Message_Extension** extension);
-
-// Returns a message extension or unknown field matching the extension
-// data as bytes.
-//
-// If an extension has already been decoded it will be re-encoded
-// to bytes.
-upb_GetExtensionAsBytes_Status upb_MiniTable_GetExtensionAsBytes(
-    const upb_Message* msg, const upb_MiniTable_Extension* ext_table,
-    int encode_options, upb_Arena* arena, const char** extension_data,
-    size_t* len);
+    bool upb_MiniTable_HasField(const upb_Message* msg, const upb_MiniTable_Field* field);
+
+    void upb_MiniTable_ClearField(upb_Message* msg, const upb_MiniTable_Field* field);
+
+    UPB_INLINE bool upb_MiniTable_GetBool(const upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bool);
+        return *UPB_PTR_AT(msg, field->offset, bool);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetBool(upb_Message* msg, const upb_MiniTable_Field* field, bool value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bool);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, bool) = value;
+    }
+
+    UPB_INLINE int32_t upb_MiniTable_GetInt32(const upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int32 || field->descriptortype == kUpb_FieldType_SInt32 || field->descriptortype == kUpb_FieldType_SFixed32);
+        return *UPB_PTR_AT(msg, field->offset, int32_t);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetInt32(upb_Message* msg, const upb_MiniTable_Field* field, int32_t value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int32 || field->descriptortype == kUpb_FieldType_SInt32 || field->descriptortype == kUpb_FieldType_SFixed32);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, int32_t) = value;
+    }
+
+    UPB_INLINE uint32_t upb_MiniTable_GetUInt32(const upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt32 || field->descriptortype == kUpb_FieldType_Fixed32);
+        return *UPB_PTR_AT(msg, field->offset, uint32_t);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetUInt32(upb_Message* msg, const upb_MiniTable_Field* field, uint32_t value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt32 || field->descriptortype == kUpb_FieldType_Fixed32);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, uint32_t) = value;
+    }
+
+    UPB_INLINE int32_t upb_MiniTable_GetEnum(const upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Enum);
+        return *UPB_PTR_AT(msg, field->offset, int32_t);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetEnum(upb_Message* msg, const upb_MiniTable_Field* field, int32_t value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Enum);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, int32_t) = value;
+    }
+
+    UPB_INLINE int64_t upb_MiniTable_GetInt64(const upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int64 || field->descriptortype == kUpb_FieldType_SInt64 || field->descriptortype == kUpb_FieldType_SFixed64);
+        return *UPB_PTR_AT(msg, field->offset, int64_t);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetInt64(upb_Message* msg, const upb_MiniTable_Field* field, int64_t value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Int64 || field->descriptortype == kUpb_FieldType_SInt64 || field->descriptortype == kUpb_FieldType_SFixed64);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, int64_t) = value;
+    }
+
+    UPB_INLINE uint64_t upb_MiniTable_GetUInt64(const upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt64 || field->descriptortype == kUpb_FieldType_Fixed64);
+        return *UPB_PTR_AT(msg, field->offset, uint64_t);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetUInt64(upb_Message* msg, const upb_MiniTable_Field* field, uint64_t value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_UInt64 || field->descriptortype == kUpb_FieldType_Fixed64);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, uint64_t) = value;
+    }
+
+    UPB_INLINE float upb_MiniTable_GetFloat(const upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Float);
+        return *UPB_PTR_AT(msg, field->offset, float);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetFloat(upb_Message* msg, const upb_MiniTable_Field* field, float value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Float);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, float) = value;
+    }
+
+    UPB_INLINE double upb_MiniTable_GetDouble(const upb_Message* msg, const upb_MiniTable_Field* field)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Double);
+        return *UPB_PTR_AT(msg, field->offset, double);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetDouble(upb_Message* msg, const upb_MiniTable_Field* field, double value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Double);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, double) = value;
+    }
+
+    UPB_INLINE upb_StringView upb_MiniTable_GetString(
+        const upb_Message* msg, const upb_MiniTable_Field* field
+    )
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bytes || field->descriptortype == kUpb_FieldType_String);
+        return *UPB_PTR_AT(msg, field->offset, upb_StringView);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetString(upb_Message* msg, const upb_MiniTable_Field* field, upb_StringView value)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Bytes || field->descriptortype == kUpb_FieldType_String);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, upb_StringView) = value;
+    }
+
+    UPB_INLINE const upb_Message* upb_MiniTable_GetMessage(
+        const upb_Message* msg, const upb_MiniTable_Field* field
+    )
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message || field->descriptortype == kUpb_FieldType_Group);
+        return *UPB_PTR_AT(msg, field->offset, const upb_Message*);
+    }
+
+    UPB_INLINE void upb_MiniTable_SetMessage(upb_Message* msg, const upb_MiniTable_Field* field, upb_Message* sub_message)
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message || field->descriptortype == kUpb_FieldType_Group);
+        _upb_MiniTable_SetPresence(msg, field);
+        *UPB_PTR_AT(msg, field->offset, const upb_Message*) = sub_message;
+    }
+
+    UPB_INLINE upb_Message* upb_MiniTable_GetMutableMessage(
+        upb_Message* msg, const upb_MiniTable* mini_table, const upb_MiniTable_Field* field, upb_Arena* arena
+    )
+    {
+        UPB_ASSERT(field->descriptortype == kUpb_FieldType_Message || field->descriptortype == kUpb_FieldType_Group);
+        upb_Message* sub_message = *UPB_PTR_AT(msg, field->offset, upb_Message*);
+        if (!sub_message)
+        {
+            sub_message =
+                _upb_Message_New(mini_table->subs[field->submsg_index].submsg, arena);
+            *UPB_PTR_AT(msg, field->offset, upb_Message*) = sub_message;
+            _upb_MiniTable_SetPresence(msg, field);
+        }
+        return sub_message;
+    }
+
+    UPB_INLINE const upb_Array* upb_MiniTable_GetArray(
+        const upb_Message* msg, const upb_MiniTable_Field* field
+    )
+    {
+        return (const upb_Array*)*UPB_PTR_AT(msg, field->offset, upb_Array*);
+    }
+
+    UPB_INLINE upb_Array* upb_MiniTable_GetMutableArray(
+        upb_Message* msg, const upb_MiniTable_Field* field
+    )
+    {
+        return (upb_Array*)*UPB_PTR_AT(msg, field->offset, upb_Array*);
+    }
+
+    void* upb_MiniTable_ResizeArray(upb_Message* msg, const upb_MiniTable_Field* field, size_t len, upb_Arena* arena);
+    typedef enum
+    {
+        kUpb_GetExtension_Ok,
+        kUpb_GetExtension_NotPresent,
+        kUpb_GetExtension_ParseError,
+        kUpb_GetExtension_OutOfMemory,
+    } upb_GetExtension_Status;
+
+    typedef enum
+    {
+        kUpb_GetExtensionAsBytes_Ok,
+        kUpb_GetExtensionAsBytes_NotPresent,
+        kUpb_GetExtensionAsBytes_EncodeError,
+    } upb_GetExtensionAsBytes_Status;
+
+    // Returns a message extension or promotes an unknown field to
+    // an extension.
+    //
+    // TODO(ferhat): Only supports extension fields that are messages,
+    // expand support to include non-message types.
+    upb_GetExtension_Status upb_MiniTable_GetOrPromoteExtension(
+        upb_Message* msg, const upb_MiniTable_Extension* ext_table, int decode_options, upb_Arena* arena, const upb_Message_Extension** extension
+    );
+
+    // Returns a message extension or unknown field matching the extension
+    // data as bytes.
+    //
+    // If an extension has already been decoded it will be re-encoded
+    // to bytes.
+    upb_GetExtensionAsBytes_Status upb_MiniTable_GetExtensionAsBytes(
+        const upb_Message* msg, const upb_MiniTable_Extension* ext_table, int encode_options, upb_Arena* arena, const char** extension_data, size_t* len
+    );
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/msg.h b/CAPI/cpp/grpc/include/upb/msg.h
index 5c1e8e8..7d04bb1 100644
--- a/CAPI/cpp/grpc/include/upb/msg.h
+++ b/CAPI/cpp/grpc/include/upb/msg.h
@@ -43,26 +43,26 @@
 #include "upb/upb.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-typedef void upb_Message;
+    typedef void upb_Message;
 
-/* For users these are opaque. They can be obtained from
- * upb_MessageDef_MiniTable() but users cannot access any of the members. */
-struct upb_MiniTable;
-typedef struct upb_MiniTable upb_MiniTable;
+    /* For users these are opaque. They can be obtained from
+     * upb_MessageDef_MiniTable() but users cannot access any of the members. */
+    struct upb_MiniTable;
+    typedef struct upb_MiniTable upb_MiniTable;
 
-/* Adds unknown data (serialized protobuf data) to the given message.  The data
- * is copied into the message instance. */
-void upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len,
-                            upb_Arena* arena);
+    /* Adds unknown data (serialized protobuf data) to the given message.  The data
+     * is copied into the message instance. */
+    void upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len, upb_Arena* arena);
 
-/* Returns a reference to the message's unknown data. */
-const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len);
+    /* Returns a reference to the message's unknown data. */
+    const char* upb_Message_GetUnknown(const upb_Message* msg, size_t* len);
 
-/* Returns the number of extensions present in this message. */
-size_t upb_Message_ExtensionCount(const upb_Message* msg);
+    /* Returns the number of extensions present in this message. */
+    size_t upb_Message_ExtensionCount(const upb_Message* msg);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/msg_internal.h b/CAPI/cpp/grpc/include/upb/msg_internal.h
index 4f5c479..0aa7185 100644
--- a/CAPI/cpp/grpc/include/upb/msg_internal.h
+++ b/CAPI/cpp/grpc/include/upb/msg_internal.h
@@ -48,785 +48,876 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** upb_*Int* conversion routines ********************************************/
-
-UPB_INLINE int32_t _upb_Int32_FromI(int v) { return (int32_t)v; }
-
-UPB_INLINE int64_t _upb_Int64_FromLL(long long v) { return (int64_t)v; }
-
-UPB_INLINE uint32_t _upb_UInt32_FromU(unsigned v) { return (uint32_t)v; }
-
-UPB_INLINE uint64_t _upb_UInt64_FromULL(unsigned long long v) {
-  return (uint64_t)v;
-}
-
-/** upb_MiniTable *************************************************************/
-
-/* upb_MiniTable represents the memory layout of a given upb_MessageDef.  The
- * members are public so generated code can initialize them, but users MUST NOT
- * read or write any of its members. */
-
-typedef struct {
-  uint32_t number;
-  uint16_t offset;
-  int16_t presence;       // If >0, hasbit_index.  If <0, ~oneof_index
-  uint16_t submsg_index;  // kUpb_NoSub if descriptortype != MESSAGE/GROUP/ENUM
-  uint8_t descriptortype;
-  uint8_t mode; /* upb_FieldMode | upb_LabelFlags |
-                   (upb_FieldRep << kUpb_FieldRep_Shift) */
-} upb_MiniTable_Field;
+    /** upb_*Int* conversion routines ********************************************/
+
+    UPB_INLINE int32_t _upb_Int32_FromI(int v)
+    {
+        return (int32_t)v;
+    }
+
+    UPB_INLINE int64_t _upb_Int64_FromLL(long long v)
+    {
+        return (int64_t)v;
+    }
+
+    UPB_INLINE uint32_t _upb_UInt32_FromU(unsigned v)
+    {
+        return (uint32_t)v;
+    }
+
+    UPB_INLINE uint64_t _upb_UInt64_FromULL(unsigned long long v)
+    {
+        return (uint64_t)v;
+    }
+
+    /** upb_MiniTable *************************************************************/
+
+    /* upb_MiniTable represents the memory layout of a given upb_MessageDef.  The
+     * members are public so generated code can initialize them, but users MUST NOT
+     * read or write any of its members. */
+
+    typedef struct
+    {
+        uint32_t number;
+        uint16_t offset;
+        int16_t presence;       // If >0, hasbit_index.  If <0, ~oneof_index
+        uint16_t submsg_index;  // kUpb_NoSub if descriptortype != MESSAGE/GROUP/ENUM
+        uint8_t descriptortype;
+        uint8_t mode; /* upb_FieldMode | upb_LabelFlags |
+                         (upb_FieldRep << kUpb_FieldRep_Shift) */
+    } upb_MiniTable_Field;
 
 #define kUpb_NoSub ((uint16_t)-1)
 
-typedef enum {
-  kUpb_FieldMode_Map = 0,
-  kUpb_FieldMode_Array = 1,
-  kUpb_FieldMode_Scalar = 2,
-} upb_FieldMode;
+    typedef enum
+    {
+        kUpb_FieldMode_Map = 0,
+        kUpb_FieldMode_Array = 1,
+        kUpb_FieldMode_Scalar = 2,
+    } upb_FieldMode;
 
 // Mask to isolate the upb_FieldMode from field.mode.
 #define kUpb_FieldMode_Mask 3
 
-/* Extra flags on the mode field. */
-typedef enum {
-  kUpb_LabelFlags_IsPacked = 4,
-  kUpb_LabelFlags_IsExtension = 8,
-} upb_LabelFlags;
-
-// Note: we sort by this number when calculating layout order.
-typedef enum {
-  kUpb_FieldRep_1Byte = 0,
-  kUpb_FieldRep_4Byte = 1,
-  kUpb_FieldRep_StringView = 2,
-  kUpb_FieldRep_Pointer = 3,
-  kUpb_FieldRep_8Byte = 4,
-
-  kUpb_FieldRep_Shift = 5,  // Bit offset of the rep in upb_MiniTable_Field.mode
-  kUpb_FieldRep_Max = kUpb_FieldRep_8Byte,
-} upb_FieldRep;
-
-UPB_INLINE upb_FieldMode upb_FieldMode_Get(const upb_MiniTable_Field* field) {
-  return (upb_FieldMode)(field->mode & 3);
-}
-
-UPB_INLINE bool upb_IsRepeatedOrMap(const upb_MiniTable_Field* field) {
-  /* This works because upb_FieldMode has no value 3. */
-  return !(field->mode & kUpb_FieldMode_Scalar);
-}
-
-UPB_INLINE bool upb_IsSubMessage(const upb_MiniTable_Field* field) {
-  return field->descriptortype == kUpb_FieldType_Message ||
-         field->descriptortype == kUpb_FieldType_Group;
-}
-
-struct upb_Decoder;
-struct upb_MiniTable;
-
-typedef const char* _upb_FieldParser(struct upb_Decoder* d, const char* ptr,
-                                     upb_Message* msg, intptr_t table,
-                                     uint64_t hasbits, uint64_t data);
-
-typedef struct {
-  uint64_t field_data;
-  _upb_FieldParser* field_parser;
-} _upb_FastTable_Entry;
-
-typedef struct {
-  const int32_t* values;  // List of values <0 or >63
-  uint64_t mask;          // Bits are set for acceptable value 0 <= x < 64
-  int value_count;
-} upb_MiniTable_Enum;
-
-typedef union {
-  const struct upb_MiniTable* submsg;
-  const upb_MiniTable_Enum* subenum;
-} upb_MiniTable_Sub;
-
-typedef enum {
-  kUpb_ExtMode_NonExtendable = 0,  // Non-extendable message.
-  kUpb_ExtMode_Extendable = 1,     // Normal extendable message.
-  kUpb_ExtMode_IsMessageSet = 2,   // MessageSet message.
-  kUpb_ExtMode_IsMessageSet_ITEM =
-      3,  // MessageSet item (temporary only, see decode.c)
-
-  // During table building we steal a bit to indicate that the message is a map
-  // entry.  *Only* used during table building!
-  kUpb_ExtMode_IsMapEntry = 4,
-} upb_ExtMode;
-
-/* MessageSet wire format is:
- *   message MessageSet {
- *     repeated group Item = 1 {
- *       required int32 type_id = 2;
- *       required bytes message = 3;
- *     }
- *   }
- */
-typedef enum {
-  _UPB_MSGSET_ITEM = 1,
-  _UPB_MSGSET_TYPEID = 2,
-  _UPB_MSGSET_MESSAGE = 3,
-} upb_msgext_fieldnum;
-
-struct upb_MiniTable {
-  const upb_MiniTable_Sub* subs;
-  const upb_MiniTable_Field* fields;
-  /* Must be aligned to sizeof(void*).  Doesn't include internal members like
-   * unknown fields, extension dict, pointer to msglayout, etc. */
-  uint16_t size;
-  uint16_t field_count;
-  uint8_t ext;  // upb_ExtMode, declared as uint8_t so sizeof(ext) == 1
-  uint8_t dense_below;
-  uint8_t table_mask;
-  uint8_t required_count;  // Required fields have the lowest hasbits.
-  /* To statically initialize the tables of variable length, we need a flexible
-   * array member, and we need to compile in gnu99 mode (constant initialization
-   * of flexible array members is a GNU extension, not in C99 unfortunately. */
-  _upb_FastTable_Entry fasttable[];
-};
-
-typedef struct {
-  upb_MiniTable_Field field;
-  const upb_MiniTable* extendee;
-  upb_MiniTable_Sub sub; /* NULL unless submessage or proto2 enum */
-} upb_MiniTable_Extension;
-
-typedef struct {
-  const upb_MiniTable** msgs;
-  const upb_MiniTable_Enum** enums;
-  const upb_MiniTable_Extension** exts;
-  int msg_count;
-  int enum_count;
-  int ext_count;
-} upb_MiniTable_File;
-
-// Computes a bitmask in which the |l->required_count| lowest bits are set,
-// except that we skip the lowest bit (because upb never uses hasbit 0).
-//
-// Sample output:
-//    requiredmask(1) => 0b10 (0x2)
-//    requiredmask(5) => 0b111110 (0x3e)
-UPB_INLINE uint64_t upb_MiniTable_requiredmask(const upb_MiniTable* l) {
-  int n = l->required_count;
-  assert(0 < n && n <= 63);
-  return ((1ULL << n) - 1) << 1;
-}
-
-/** upb_ExtensionRegistry *****************************************************/
-
-/* Adds the given extension info for message type |l| and field number |num|
- * into the registry. Returns false if this message type and field number were
- * already in the map, or if memory allocation fails. */
-bool _upb_extreg_add(upb_ExtensionRegistry* r,
-                     const upb_MiniTable_Extension** e, size_t count);
-
-/* Looks up the extension (if any) defined for message type |l| and field
- * number |num|.  If an extension was found, copies the field info into |*ext|
- * and returns true. Otherwise returns false. */
-const upb_MiniTable_Extension* _upb_extreg_get(const upb_ExtensionRegistry* r,
-                                               const upb_MiniTable* l,
-                                               uint32_t num);
-
-/** upb_Message ***************************************************************/
-
-/* Internal members of a upb_Message that track unknown fields and/or
- * extensions. We can change this without breaking binary compatibility.  We put
- * these before the user's data.  The user's upb_Message* points after the
- * upb_Message_Internal. */
-
-typedef struct {
-  /* Total size of this structure, including the data that follows.
-   * Must be aligned to 8, which is alignof(upb_Message_Extension) */
-  uint32_t size;
-
-  /* Offsets relative to the beginning of this structure.
-   *
-   * Unknown data grows forward from the beginning to unknown_end.
-   * Extension data grows backward from size to ext_begin.
-   * When the two meet, we're out of data and have to realloc.
-   *
-   * If we imagine that the final member of this struct is:
-   *   char data[size - overhead];  // overhead =
-   * sizeof(upb_Message_InternalData)
-   *
-   * Then we have:
-   *   unknown data: data[0 .. (unknown_end - overhead)]
-   *   extensions data: data[(ext_begin - overhead) .. (size - overhead)] */
-  uint32_t unknown_end;
-  uint32_t ext_begin;
-  /* Data follows, as if there were an array:
-   *   char data[size - sizeof(upb_Message_InternalData)]; */
-} upb_Message_InternalData;
-
-typedef struct {
-  upb_Message_InternalData* internal;
-  /* Message data follows. */
-} upb_Message_Internal;
-
-/* Maps upb_CType -> memory size. */
-extern char _upb_CTypeo_size[12];
-
-UPB_INLINE size_t upb_msg_sizeof(const upb_MiniTable* l) {
-  return l->size + sizeof(upb_Message_Internal);
-}
-
-UPB_INLINE upb_Message* _upb_Message_New_inl(const upb_MiniTable* l,
-                                             upb_Arena* a) {
-  size_t size = upb_msg_sizeof(l);
-  void* mem = upb_Arena_Malloc(a, size + sizeof(upb_Message_Internal));
-  upb_Message* msg;
-  if (UPB_UNLIKELY(!mem)) return NULL;
-  msg = UPB_PTR_AT(mem, sizeof(upb_Message_Internal), upb_Message);
-  memset(mem, 0, size);
-  return msg;
-}
-
-/* Creates a new messages with the given layout on the given arena. */
-upb_Message* _upb_Message_New(const upb_MiniTable* l, upb_Arena* a);
-
-UPB_INLINE upb_Message_Internal* upb_Message_Getinternal(upb_Message* msg) {
-  ptrdiff_t size = sizeof(upb_Message_Internal);
-  return (upb_Message_Internal*)((char*)msg - size);
-}
-
-/* Clears the given message. */
-void _upb_Message_Clear(upb_Message* msg, const upb_MiniTable* l);
-
-/* Discards the unknown fields for this message only. */
-void _upb_Message_DiscardUnknown_shallow(upb_Message* msg);
-
-/* Adds unknown data (serialized protobuf data) to the given message.  The data
- * is copied into the message instance. */
-bool _upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len,
-                             upb_Arena* arena);
-
-/** upb_Message_Extension *****************************************************/
-
-/* The internal representation of an extension is self-describing: it contains
- * enough information that we can serialize it to binary format without needing
- * to look it up in a upb_ExtensionRegistry.
- *
- * This representation allocates 16 bytes to data on 64-bit platforms.  This is
- * rather wasteful for scalars (in the extreme case of bool, it wastes 15
- * bytes). We accept this because we expect messages to be the most common
- * extension type. */
-typedef struct {
-  const upb_MiniTable_Extension* ext;
-  union {
-    upb_StringView str;
-    void* ptr;
-    char scalar_data[8];
-  } data;
-} upb_Message_Extension;
-
-/* Adds the given extension data to the given message. |ext| is copied into the
- * message instance. This logically replaces any previously-added extension with
- * this number */
-upb_Message_Extension* _upb_Message_GetOrCreateExtension(
-    upb_Message* msg, const upb_MiniTable_Extension* ext, upb_Arena* arena);
-
-/* Returns an array of extensions for this message. Note: the array is
- * ordered in reverse relative to the order of creation. */
-const upb_Message_Extension* _upb_Message_Getexts(const upb_Message* msg,
-                                                  size_t* count);
-
-/* Returns an extension for the given field number, or NULL if no extension
- * exists for this field number. */
-const upb_Message_Extension* _upb_Message_Getext(
-    const upb_Message* msg, const upb_MiniTable_Extension* ext);
-
-void _upb_Message_Clearext(upb_Message* msg,
-                           const upb_MiniTable_Extension* ext);
-
-void _upb_Message_Clearext(upb_Message* msg,
-                           const upb_MiniTable_Extension* ext);
-
-/** Hasbit access *************************************************************/
-
-UPB_INLINE bool _upb_hasbit(const upb_Message* msg, size_t idx) {
-  return (*UPB_PTR_AT(msg, idx / 8, const char) & (1 << (idx % 8))) != 0;
-}
-
-UPB_INLINE void _upb_sethas(const upb_Message* msg, size_t idx) {
-  (*UPB_PTR_AT(msg, idx / 8, char)) |= (char)(1 << (idx % 8));
-}
-
-UPB_INLINE void _upb_clearhas(const upb_Message* msg, size_t idx) {
-  (*UPB_PTR_AT(msg, idx / 8, char)) &= (char)(~(1 << (idx % 8)));
-}
-
-UPB_INLINE size_t _upb_Message_Hasidx(const upb_MiniTable_Field* f) {
-  UPB_ASSERT(f->presence > 0);
-  return f->presence;
-}
-
-UPB_INLINE bool _upb_hasbit_field(const upb_Message* msg,
-                                  const upb_MiniTable_Field* f) {
-  return _upb_hasbit(msg, _upb_Message_Hasidx(f));
-}
-
-UPB_INLINE void _upb_sethas_field(const upb_Message* msg,
-                                  const upb_MiniTable_Field* f) {
-  _upb_sethas(msg, _upb_Message_Hasidx(f));
-}
-
-UPB_INLINE void _upb_clearhas_field(const upb_Message* msg,
-                                    const upb_MiniTable_Field* f) {
-  _upb_clearhas(msg, _upb_Message_Hasidx(f));
-}
-
-/** Oneof case access *********************************************************/
-
-UPB_INLINE uint32_t* _upb_oneofcase(upb_Message* msg, size_t case_ofs) {
-  return UPB_PTR_AT(msg, case_ofs, uint32_t);
-}
-
-UPB_INLINE uint32_t _upb_getoneofcase(const void* msg, size_t case_ofs) {
-  return *UPB_PTR_AT(msg, case_ofs, uint32_t);
-}
-
-UPB_INLINE size_t _upb_oneofcase_ofs(const upb_MiniTable_Field* f) {
-  UPB_ASSERT(f->presence < 0);
-  return ~(ptrdiff_t)f->presence;
-}
-
-UPB_INLINE uint32_t* _upb_oneofcase_field(upb_Message* msg,
-                                          const upb_MiniTable_Field* f) {
-  return _upb_oneofcase(msg, _upb_oneofcase_ofs(f));
-}
-
-UPB_INLINE uint32_t _upb_getoneofcase_field(const upb_Message* msg,
-                                            const upb_MiniTable_Field* f) {
-  return _upb_getoneofcase(msg, _upb_oneofcase_ofs(f));
-}
-
-UPB_INLINE bool _upb_has_submsg_nohasbit(const upb_Message* msg, size_t ofs) {
-  return *UPB_PTR_AT(msg, ofs, const upb_Message*) != NULL;
-}
-
-/** upb_Array *****************************************************************/
-
-/* Our internal representation for repeated fields.  */
-typedef struct {
-  uintptr_t data; /* Tagged ptr: low 3 bits of ptr are lg2(elem size). */
-  size_t len;     /* Measured in elements. */
-  size_t size;    /* Measured in elements. */
-  uint64_t junk;
-} upb_Array;
-
-UPB_INLINE const void* _upb_array_constptr(const upb_Array* arr) {
-  UPB_ASSERT((arr->data & 7) <= 4);
-  return (void*)(arr->data & ~(uintptr_t)7);
-}
-
-UPB_INLINE uintptr_t _upb_array_tagptr(void* ptr, int elem_size_lg2) {
-  UPB_ASSERT(elem_size_lg2 <= 4);
-  return (uintptr_t)ptr | elem_size_lg2;
-}
-
-UPB_INLINE void* _upb_array_ptr(upb_Array* arr) {
-  return (void*)_upb_array_constptr(arr);
-}
-
-UPB_INLINE uintptr_t _upb_tag_arrptr(void* ptr, int elem_size_lg2) {
-  UPB_ASSERT(elem_size_lg2 <= 4);
-  UPB_ASSERT(((uintptr_t)ptr & 7) == 0);
-  return (uintptr_t)ptr | (unsigned)elem_size_lg2;
-}
-
-UPB_INLINE upb_Array* _upb_Array_New(upb_Arena* a, size_t init_size,
-                                     int elem_size_lg2) {
-  const size_t arr_size = UPB_ALIGN_UP(sizeof(upb_Array), 8);
-  const size_t bytes = sizeof(upb_Array) + (init_size << elem_size_lg2);
-  upb_Array* arr = (upb_Array*)upb_Arena_Malloc(a, bytes);
-  if (!arr) return NULL;
-  arr->data = _upb_tag_arrptr(UPB_PTR_AT(arr, arr_size, void), elem_size_lg2);
-  arr->len = 0;
-  arr->size = init_size;
-  return arr;
-}
-
-/* Resizes the capacity of the array to be at least min_size. */
-bool _upb_array_realloc(upb_Array* arr, size_t min_size, upb_Arena* arena);
-
-/* Fallback functions for when the accessors require a resize. */
-void* _upb_Array_Resize_fallback(upb_Array** arr_ptr, size_t size,
-                                 int elem_size_lg2, upb_Arena* arena);
-bool _upb_Array_Append_fallback(upb_Array** arr_ptr, const void* value,
-                                int elem_size_lg2, upb_Arena* arena);
-
-UPB_INLINE bool _upb_array_reserve(upb_Array* arr, size_t size,
-                                   upb_Arena* arena) {
-  if (arr->size < size) return _upb_array_realloc(arr, size, arena);
-  return true;
-}
-
-UPB_INLINE bool _upb_Array_Resize(upb_Array* arr, size_t size,
-                                  upb_Arena* arena) {
-  if (!_upb_array_reserve(arr, size, arena)) return false;
-  arr->len = size;
-  return true;
-}
-
-UPB_INLINE void _upb_array_detach(const void* msg, size_t ofs) {
-  *UPB_PTR_AT(msg, ofs, upb_Array*) = NULL;
-}
-
-UPB_INLINE const void* _upb_array_accessor(const void* msg, size_t ofs,
-                                           size_t* size) {
-  const upb_Array* arr = *UPB_PTR_AT(msg, ofs, const upb_Array*);
-  if (arr) {
-    if (size) *size = arr->len;
-    return _upb_array_constptr(arr);
-  } else {
-    if (size) *size = 0;
-    return NULL;
-  }
-}
-
-UPB_INLINE void* _upb_array_mutable_accessor(void* msg, size_t ofs,
-                                             size_t* size) {
-  upb_Array* arr = *UPB_PTR_AT(msg, ofs, upb_Array*);
-  if (arr) {
-    if (size) *size = arr->len;
-    return _upb_array_ptr(arr);
-  } else {
-    if (size) *size = 0;
-    return NULL;
-  }
-}
-
-UPB_INLINE void* _upb_Array_Resize_accessor2(void* msg, size_t ofs, size_t size,
-                                             int elem_size_lg2,
-                                             upb_Arena* arena) {
-  upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
-  upb_Array* arr = *arr_ptr;
-  if (!arr || arr->size < size) {
-    return _upb_Array_Resize_fallback(arr_ptr, size, elem_size_lg2, arena);
-  }
-  arr->len = size;
-  return _upb_array_ptr(arr);
-}
-
-UPB_INLINE bool _upb_Array_Append_accessor2(void* msg, size_t ofs,
-                                            int elem_size_lg2,
-                                            const void* value,
-                                            upb_Arena* arena) {
-  upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
-  size_t elem_size = 1 << elem_size_lg2;
-  upb_Array* arr = *arr_ptr;
-  void* ptr;
-  if (!arr || arr->len == arr->size) {
-    return _upb_Array_Append_fallback(arr_ptr, value, elem_size_lg2, arena);
-  }
-  ptr = _upb_array_ptr(arr);
-  memcpy(UPB_PTR_AT(ptr, arr->len * elem_size, char), value, elem_size);
-  arr->len++;
-  return true;
-}
-
-/* Used by old generated code, remove once all code has been regenerated. */
-UPB_INLINE int _upb_sizelg2(upb_CType type) {
-  switch (type) {
-    case kUpb_CType_Bool:
-      return 0;
-    case kUpb_CType_Float:
-    case kUpb_CType_Int32:
-    case kUpb_CType_UInt32:
-    case kUpb_CType_Enum:
-      return 2;
-    case kUpb_CType_Message:
-      return UPB_SIZE(2, 3);
-    case kUpb_CType_Double:
-    case kUpb_CType_Int64:
-    case kUpb_CType_UInt64:
-      return 3;
-    case kUpb_CType_String:
-    case kUpb_CType_Bytes:
-      return UPB_SIZE(3, 4);
-  }
-  UPB_UNREACHABLE();
-}
-UPB_INLINE void* _upb_Array_Resize_accessor(void* msg, size_t ofs, size_t size,
-                                            upb_CType type, upb_Arena* arena) {
-  return _upb_Array_Resize_accessor2(msg, ofs, size, _upb_sizelg2(type), arena);
-}
-UPB_INLINE bool _upb_Array_Append_accessor(void* msg, size_t ofs,
-                                           size_t elem_size, upb_CType type,
-                                           const void* value,
-                                           upb_Arena* arena) {
-  (void)elem_size;
-  return _upb_Array_Append_accessor2(msg, ofs, _upb_sizelg2(type), value,
-                                     arena);
-}
-
-/** upb_Map *******************************************************************/
-
-/* Right now we use strmaps for everything.  We'll likely want to use
- * integer-specific maps for integer-keyed maps.*/
-typedef struct {
-  /* Size of key and val, based on the map type.  Strings are represented as '0'
-   * because they must be handled specially. */
-  char key_size;
-  char val_size;
-
-  upb_strtable table;
-} upb_Map;
-
-/* Map entries aren't actually stored, they are only used during parsing.  For
- * parsing, it helps a lot if all map entry messages have the same layout.
- * The compiler and def.c must ensure that all map entries have this layout. */
-typedef struct {
-  upb_Message_Internal internal;
-  union {
-    upb_StringView str; /* For str/bytes. */
-    upb_value val;      /* For all other types. */
-  } k;
-  union {
-    upb_StringView str; /* For str/bytes. */
-    upb_value val;      /* For all other types. */
-  } v;
-} upb_MapEntry;
-
-/* Creates a new map on the given arena with this key/value type. */
-upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size);
-
-/* Converting between internal table representation and user values.
- *
- * _upb_map_tokey() and _upb_map_fromkey() are inverses.
- * _upb_map_tovalue() and _upb_map_fromvalue() are inverses.
- *
- * These functions account for the fact that strings are treated differently
- * from other types when stored in a map.
- */
-
-UPB_INLINE upb_StringView _upb_map_tokey(const void* key, size_t size) {
-  if (size == UPB_MAPTYPE_STRING) {
-    return *(upb_StringView*)key;
-  } else {
-    return upb_StringView_FromDataAndSize((const char*)key, size);
-  }
-}
-
-UPB_INLINE void _upb_map_fromkey(upb_StringView key, void* out, size_t size) {
-  if (size == UPB_MAPTYPE_STRING) {
-    memcpy(out, &key, sizeof(key));
-  } else {
-    memcpy(out, key.data, size);
-  }
-}
-
-UPB_INLINE bool _upb_map_tovalue(const void* val, size_t size,
-                                 upb_value* msgval, upb_Arena* a) {
-  if (size == UPB_MAPTYPE_STRING) {
-    upb_StringView* strp = (upb_StringView*)upb_Arena_Malloc(a, sizeof(*strp));
-    if (!strp) return false;
-    *strp = *(upb_StringView*)val;
-    *msgval = upb_value_ptr(strp);
-  } else {
-    memcpy(msgval, val, size);
-  }
-  return true;
-}
-
-UPB_INLINE void _upb_map_fromvalue(upb_value val, void* out, size_t size) {
-  if (size == UPB_MAPTYPE_STRING) {
-    const upb_StringView* strp = (const upb_StringView*)upb_value_getptr(val);
-    memcpy(out, strp, sizeof(upb_StringView));
-  } else {
-    memcpy(out, &val, size);
-  }
-}
-
-/* Map operations, shared by reflection and generated code. */
-
-UPB_INLINE size_t _upb_Map_Size(const upb_Map* map) {
-  return map->table.t.count;
-}
-
-UPB_INLINE bool _upb_Map_Get(const upb_Map* map, const void* key,
-                             size_t key_size, void* val, size_t val_size) {
-  upb_value tabval;
-  upb_StringView k = _upb_map_tokey(key, key_size);
-  bool ret = upb_strtable_lookup2(&map->table, k.data, k.size, &tabval);
-  if (ret && val) {
-    _upb_map_fromvalue(tabval, val, val_size);
-  }
-  return ret;
-}
-
-UPB_INLINE void* _upb_map_next(const upb_Map* map, size_t* iter) {
-  upb_strtable_iter it;
-  it.t = &map->table;
-  it.index = *iter;
-  upb_strtable_next(&it);
-  *iter = it.index;
-  if (upb_strtable_done(&it)) return NULL;
-  return (void*)str_tabent(&it);
-}
-
-typedef enum {
-  // LINT.IfChange
-  _kUpb_MapInsertStatus_Inserted = 0,
-  _kUpb_MapInsertStatus_Replaced = 1,
-  _kUpb_MapInsertStatus_OutOfMemory = 2,
-  // LINT.ThenChange(//depot/google3/third_party/upb/upb/map.h)
-} _upb_MapInsertStatus;
-
-UPB_INLINE _upb_MapInsertStatus _upb_Map_Insert(upb_Map* map, const void* key,
-                                                size_t key_size, void* val,
-                                                size_t val_size, upb_Arena* a) {
-  upb_StringView strkey = _upb_map_tokey(key, key_size);
-  upb_value tabval = {0};
-  if (!_upb_map_tovalue(val, val_size, &tabval, a)) {
-    return _kUpb_MapInsertStatus_OutOfMemory;
-  }
-
-  /* TODO(haberman): add overwrite operation to minimize number of lookups. */
-  bool removed =
-      upb_strtable_remove2(&map->table, strkey.data, strkey.size, NULL);
-  if (!upb_strtable_insert(&map->table, strkey.data, strkey.size, tabval, a)) {
-    return _kUpb_MapInsertStatus_OutOfMemory;
-  }
-  return removed ? _kUpb_MapInsertStatus_Replaced
-                 : _kUpb_MapInsertStatus_Inserted;
-}
-
-UPB_INLINE bool _upb_Map_Delete(upb_Map* map, const void* key,
-                                size_t key_size) {
-  upb_StringView k = _upb_map_tokey(key, key_size);
-  return upb_strtable_remove2(&map->table, k.data, k.size, NULL);
-}
-
-UPB_INLINE void _upb_Map_Clear(upb_Map* map) {
-  upb_strtable_clear(&map->table);
-}
-
-/* Message map operations, these get the map from the message first. */
-
-UPB_INLINE size_t _upb_msg_map_size(const upb_Message* msg, size_t ofs) {
-  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
-  return map ? _upb_Map_Size(map) : 0;
-}
-
-UPB_INLINE bool _upb_msg_map_get(const upb_Message* msg, size_t ofs,
-                                 const void* key, size_t key_size, void* val,
-                                 size_t val_size) {
-  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
-  if (!map) return false;
-  return _upb_Map_Get(map, key, key_size, val, val_size);
-}
-
-UPB_INLINE void* _upb_msg_map_next(const upb_Message* msg, size_t ofs,
-                                   size_t* iter) {
-  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
-  if (!map) return NULL;
-  return _upb_map_next(map, iter);
-}
-
-UPB_INLINE bool _upb_msg_map_set(upb_Message* msg, size_t ofs, const void* key,
-                                 size_t key_size, void* val, size_t val_size,
-                                 upb_Arena* arena) {
-  upb_Map** map = UPB_PTR_AT(msg, ofs, upb_Map*);
-  if (!*map) {
-    *map = _upb_Map_New(arena, key_size, val_size);
-  }
-  return _upb_Map_Insert(*map, key, key_size, val, val_size, arena) !=
-         _kUpb_MapInsertStatus_OutOfMemory;
-}
-
-UPB_INLINE bool _upb_msg_map_delete(upb_Message* msg, size_t ofs,
-                                    const void* key, size_t key_size) {
-  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
-  if (!map) return false;
-  return _upb_Map_Delete(map, key, key_size);
-}
-
-UPB_INLINE void _upb_msg_map_clear(upb_Message* msg, size_t ofs) {
-  upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
-  if (!map) return;
-  _upb_Map_Clear(map);
-}
-
-/* Accessing map key/value from a pointer, used by generated code only. */
-
-UPB_INLINE void _upb_msg_map_key(const void* msg, void* key, size_t size) {
-  const upb_tabent* ent = (const upb_tabent*)msg;
-  uint32_t u32len;
-  upb_StringView k;
-  k.data = upb_tabstr(ent->key, &u32len);
-  k.size = u32len;
-  _upb_map_fromkey(k, key, size);
-}
-
-UPB_INLINE void _upb_msg_map_value(const void* msg, void* val, size_t size) {
-  const upb_tabent* ent = (const upb_tabent*)msg;
-  upb_value v = {ent->val.val};
-  _upb_map_fromvalue(v, val, size);
-}
-
-UPB_INLINE void _upb_msg_map_set_value(void* msg, const void* val,
-                                       size_t size) {
-  upb_tabent* ent = (upb_tabent*)msg;
-  /* This is like _upb_map_tovalue() except the entry already exists so we can
-   * reuse the allocated upb_StringView for string fields. */
-  if (size == UPB_MAPTYPE_STRING) {
-    upb_StringView* strp = (upb_StringView*)(uintptr_t)ent->val.val;
-    memcpy(strp, val, sizeof(*strp));
-  } else {
-    memcpy(&ent->val.val, val, size);
-  }
-}
-
-/** _upb_mapsorter ************************************************************/
-
-/* _upb_mapsorter sorts maps and provides ordered iteration over the entries.
- * Since maps can be recursive (map values can be messages which contain other
- * maps). _upb_mapsorter can contain a stack of maps. */
-
-typedef struct {
-  upb_tabent const** entries;
-  int size;
-  int cap;
-} _upb_mapsorter;
-
-typedef struct {
-  int start;
-  int pos;
-  int end;
-} _upb_sortedmap;
-
-UPB_INLINE void _upb_mapsorter_init(_upb_mapsorter* s) {
-  s->entries = NULL;
-  s->size = 0;
-  s->cap = 0;
-}
-
-UPB_INLINE void _upb_mapsorter_destroy(_upb_mapsorter* s) {
-  if (s->entries) free(s->entries);
-}
-
-bool _upb_mapsorter_pushmap(_upb_mapsorter* s, upb_FieldType key_type,
-                            const upb_Map* map, _upb_sortedmap* sorted);
-
-UPB_INLINE void _upb_mapsorter_popmap(_upb_mapsorter* s,
-                                      _upb_sortedmap* sorted) {
-  s->size = sorted->start;
-}
-
-UPB_INLINE bool _upb_sortedmap_next(_upb_mapsorter* s, const upb_Map* map,
-                                    _upb_sortedmap* sorted, upb_MapEntry* ent) {
-  if (sorted->pos == sorted->end) return false;
-  const upb_tabent* tabent = s->entries[sorted->pos++];
-  upb_StringView key = upb_tabstrview(tabent->key);
-  _upb_map_fromkey(key, &ent->k, map->key_size);
-  upb_value val = {tabent->val.val};
-  _upb_map_fromvalue(val, &ent->v, map->val_size);
-  return true;
-}
+    /* Extra flags on the mode field. */
+    typedef enum
+    {
+        kUpb_LabelFlags_IsPacked = 4,
+        kUpb_LabelFlags_IsExtension = 8,
+    } upb_LabelFlags;
+
+    // Note: we sort by this number when calculating layout order.
+    typedef enum
+    {
+        kUpb_FieldRep_1Byte = 0,
+        kUpb_FieldRep_4Byte = 1,
+        kUpb_FieldRep_StringView = 2,
+        kUpb_FieldRep_Pointer = 3,
+        kUpb_FieldRep_8Byte = 4,
+
+        kUpb_FieldRep_Shift = 5,  // Bit offset of the rep in upb_MiniTable_Field.mode
+        kUpb_FieldRep_Max = kUpb_FieldRep_8Byte,
+    } upb_FieldRep;
+
+    UPB_INLINE upb_FieldMode upb_FieldMode_Get(const upb_MiniTable_Field* field)
+    {
+        return (upb_FieldMode)(field->mode & 3);
+    }
+
+    UPB_INLINE bool upb_IsRepeatedOrMap(const upb_MiniTable_Field* field)
+    {
+        /* This works because upb_FieldMode has no value 3. */
+        return !(field->mode & kUpb_FieldMode_Scalar);
+    }
+
+    UPB_INLINE bool upb_IsSubMessage(const upb_MiniTable_Field* field)
+    {
+        return field->descriptortype == kUpb_FieldType_Message ||
+               field->descriptortype == kUpb_FieldType_Group;
+    }
+
+    struct upb_Decoder;
+    struct upb_MiniTable;
+
+    typedef const char* _upb_FieldParser(struct upb_Decoder* d, const char* ptr, upb_Message* msg, intptr_t table, uint64_t hasbits, uint64_t data);
+
+    typedef struct
+    {
+        uint64_t field_data;
+        _upb_FieldParser* field_parser;
+    } _upb_FastTable_Entry;
+
+    typedef struct
+    {
+        const int32_t* values;  // List of values <0 or >63
+        uint64_t mask;          // Bits are set for acceptable value 0 <= x < 64
+        int value_count;
+    } upb_MiniTable_Enum;
+
+    typedef union
+    {
+        const struct upb_MiniTable* submsg;
+        const upb_MiniTable_Enum* subenum;
+    } upb_MiniTable_Sub;
+
+    typedef enum
+    {
+        kUpb_ExtMode_NonExtendable = 0,  // Non-extendable message.
+        kUpb_ExtMode_Extendable = 1,     // Normal extendable message.
+        kUpb_ExtMode_IsMessageSet = 2,   // MessageSet message.
+        kUpb_ExtMode_IsMessageSet_ITEM =
+            3,  // MessageSet item (temporary only, see decode.c)
+
+        // During table building we steal a bit to indicate that the message is a map
+        // entry.  *Only* used during table building!
+        kUpb_ExtMode_IsMapEntry = 4,
+    } upb_ExtMode;
+
+    /* MessageSet wire format is:
+     *   message MessageSet {
+     *     repeated group Item = 1 {
+     *       required int32 type_id = 2;
+     *       required bytes message = 3;
+     *     }
+     *   }
+     */
+    typedef enum
+    {
+        _UPB_MSGSET_ITEM = 1,
+        _UPB_MSGSET_TYPEID = 2,
+        _UPB_MSGSET_MESSAGE = 3,
+    } upb_msgext_fieldnum;
+
+    struct upb_MiniTable
+    {
+        const upb_MiniTable_Sub* subs;
+        const upb_MiniTable_Field* fields;
+        /* Must be aligned to sizeof(void*).  Doesn't include internal members like
+         * unknown fields, extension dict, pointer to msglayout, etc. */
+        uint16_t size;
+        uint16_t field_count;
+        uint8_t ext;  // upb_ExtMode, declared as uint8_t so sizeof(ext) == 1
+        uint8_t dense_below;
+        uint8_t table_mask;
+        uint8_t required_count;  // Required fields have the lowest hasbits.
+        /* To statically initialize the tables of variable length, we need a flexible
+         * array member, and we need to compile in gnu99 mode (constant initialization
+         * of flexible array members is a GNU extension, not in C99 unfortunately. */
+        _upb_FastTable_Entry fasttable[];
+    };
+
+    typedef struct
+    {
+        upb_MiniTable_Field field;
+        const upb_MiniTable* extendee;
+        upb_MiniTable_Sub sub; /* NULL unless submessage or proto2 enum */
+    } upb_MiniTable_Extension;
+
+    typedef struct
+    {
+        const upb_MiniTable** msgs;
+        const upb_MiniTable_Enum** enums;
+        const upb_MiniTable_Extension** exts;
+        int msg_count;
+        int enum_count;
+        int ext_count;
+    } upb_MiniTable_File;
+
+    // Computes a bitmask in which the |l->required_count| lowest bits are set,
+    // except that we skip the lowest bit (because upb never uses hasbit 0).
+    //
+    // Sample output:
+    //    requiredmask(1) => 0b10 (0x2)
+    //    requiredmask(5) => 0b111110 (0x3e)
+    UPB_INLINE uint64_t upb_MiniTable_requiredmask(const upb_MiniTable* l)
+    {
+        int n = l->required_count;
+        assert(0 < n && n <= 63);
+        return ((1ULL << n) - 1) << 1;
+    }
+
+    /** upb_ExtensionRegistry *****************************************************/
+
+    /* Adds the given extension info for message type |l| and field number |num|
+     * into the registry. Returns false if this message type and field number were
+     * already in the map, or if memory allocation fails. */
+    bool _upb_extreg_add(upb_ExtensionRegistry* r, const upb_MiniTable_Extension** e, size_t count);
+
+    /* Looks up the extension (if any) defined for message type |l| and field
+     * number |num|.  If an extension was found, copies the field info into |*ext|
+     * and returns true. Otherwise returns false. */
+    const upb_MiniTable_Extension* _upb_extreg_get(const upb_ExtensionRegistry* r, const upb_MiniTable* l, uint32_t num);
+
+    /** upb_Message ***************************************************************/
+
+    /* Internal members of a upb_Message that track unknown fields and/or
+     * extensions. We can change this without breaking binary compatibility.  We put
+     * these before the user's data.  The user's upb_Message* points after the
+     * upb_Message_Internal. */
+
+    typedef struct
+    {
+        /* Total size of this structure, including the data that follows.
+         * Must be aligned to 8, which is alignof(upb_Message_Extension) */
+        uint32_t size;
+
+        /* Offsets relative to the beginning of this structure.
+         *
+         * Unknown data grows forward from the beginning to unknown_end.
+         * Extension data grows backward from size to ext_begin.
+         * When the two meet, we're out of data and have to realloc.
+         *
+         * If we imagine that the final member of this struct is:
+         *   char data[size - overhead];  // overhead =
+         * sizeof(upb_Message_InternalData)
+         *
+         * Then we have:
+         *   unknown data: data[0 .. (unknown_end - overhead)]
+         *   extensions data: data[(ext_begin - overhead) .. (size - overhead)] */
+        uint32_t unknown_end;
+        uint32_t ext_begin;
+        /* Data follows, as if there were an array:
+         *   char data[size - sizeof(upb_Message_InternalData)]; */
+    } upb_Message_InternalData;
+
+    typedef struct
+    {
+        upb_Message_InternalData* internal;
+        /* Message data follows. */
+    } upb_Message_Internal;
+
+    /* Maps upb_CType -> memory size. */
+    extern char _upb_CTypeo_size[12];
+
+    UPB_INLINE size_t upb_msg_sizeof(const upb_MiniTable* l)
+    {
+        return l->size + sizeof(upb_Message_Internal);
+    }
+
+    UPB_INLINE upb_Message* _upb_Message_New_inl(const upb_MiniTable* l, upb_Arena* a)
+    {
+        size_t size = upb_msg_sizeof(l);
+        void* mem = upb_Arena_Malloc(a, size + sizeof(upb_Message_Internal));
+        upb_Message* msg;
+        if (UPB_UNLIKELY(!mem))
+            return NULL;
+        msg = UPB_PTR_AT(mem, sizeof(upb_Message_Internal), upb_Message);
+        memset(mem, 0, size);
+        return msg;
+    }
+
+    /* Creates a new messages with the given layout on the given arena. */
+    upb_Message* _upb_Message_New(const upb_MiniTable* l, upb_Arena* a);
+
+    UPB_INLINE upb_Message_Internal* upb_Message_Getinternal(upb_Message* msg)
+    {
+        ptrdiff_t size = sizeof(upb_Message_Internal);
+        return (upb_Message_Internal*)((char*)msg - size);
+    }
+
+    /* Clears the given message. */
+    void _upb_Message_Clear(upb_Message* msg, const upb_MiniTable* l);
+
+    /* Discards the unknown fields for this message only. */
+    void _upb_Message_DiscardUnknown_shallow(upb_Message* msg);
+
+    /* Adds unknown data (serialized protobuf data) to the given message.  The data
+     * is copied into the message instance. */
+    bool _upb_Message_AddUnknown(upb_Message* msg, const char* data, size_t len, upb_Arena* arena);
+
+    /** upb_Message_Extension *****************************************************/
+
+    /* The internal representation of an extension is self-describing: it contains
+     * enough information that we can serialize it to binary format without needing
+     * to look it up in a upb_ExtensionRegistry.
+     *
+     * This representation allocates 16 bytes to data on 64-bit platforms.  This is
+     * rather wasteful for scalars (in the extreme case of bool, it wastes 15
+     * bytes). We accept this because we expect messages to be the most common
+     * extension type. */
+    typedef struct
+    {
+        const upb_MiniTable_Extension* ext;
+        union
+        {
+            upb_StringView str;
+            void* ptr;
+            char scalar_data[8];
+        } data;
+    } upb_Message_Extension;
+
+    /* Adds the given extension data to the given message. |ext| is copied into the
+     * message instance. This logically replaces any previously-added extension with
+     * this number */
+    upb_Message_Extension* _upb_Message_GetOrCreateExtension(
+        upb_Message* msg, const upb_MiniTable_Extension* ext, upb_Arena* arena
+    );
+
+    /* Returns an array of extensions for this message. Note: the array is
+     * ordered in reverse relative to the order of creation. */
+    const upb_Message_Extension* _upb_Message_Getexts(const upb_Message* msg, size_t* count);
+
+    /* Returns an extension for the given field number, or NULL if no extension
+     * exists for this field number. */
+    const upb_Message_Extension* _upb_Message_Getext(
+        const upb_Message* msg, const upb_MiniTable_Extension* ext
+    );
+
+    void _upb_Message_Clearext(upb_Message* msg, const upb_MiniTable_Extension* ext);
+
+    void _upb_Message_Clearext(upb_Message* msg, const upb_MiniTable_Extension* ext);
+
+    /** Hasbit access *************************************************************/
+
+    UPB_INLINE bool _upb_hasbit(const upb_Message* msg, size_t idx)
+    {
+        return (*UPB_PTR_AT(msg, idx / 8, const char) & (1 << (idx % 8))) != 0;
+    }
+
+    UPB_INLINE void _upb_sethas(const upb_Message* msg, size_t idx)
+    {
+        (*UPB_PTR_AT(msg, idx / 8, char)) |= (char)(1 << (idx % 8));
+    }
+
+    UPB_INLINE void _upb_clearhas(const upb_Message* msg, size_t idx)
+    {
+        (*UPB_PTR_AT(msg, idx / 8, char)) &= (char)(~(1 << (idx % 8)));
+    }
+
+    UPB_INLINE size_t _upb_Message_Hasidx(const upb_MiniTable_Field* f)
+    {
+        UPB_ASSERT(f->presence > 0);
+        return f->presence;
+    }
+
+    UPB_INLINE bool _upb_hasbit_field(const upb_Message* msg, const upb_MiniTable_Field* f)
+    {
+        return _upb_hasbit(msg, _upb_Message_Hasidx(f));
+    }
+
+    UPB_INLINE void _upb_sethas_field(const upb_Message* msg, const upb_MiniTable_Field* f)
+    {
+        _upb_sethas(msg, _upb_Message_Hasidx(f));
+    }
+
+    UPB_INLINE void _upb_clearhas_field(const upb_Message* msg, const upb_MiniTable_Field* f)
+    {
+        _upb_clearhas(msg, _upb_Message_Hasidx(f));
+    }
+
+    /** Oneof case access *********************************************************/
+
+    UPB_INLINE uint32_t* _upb_oneofcase(upb_Message* msg, size_t case_ofs)
+    {
+        return UPB_PTR_AT(msg, case_ofs, uint32_t);
+    }
+
+    UPB_INLINE uint32_t _upb_getoneofcase(const void* msg, size_t case_ofs)
+    {
+        return *UPB_PTR_AT(msg, case_ofs, uint32_t);
+    }
+
+    UPB_INLINE size_t _upb_oneofcase_ofs(const upb_MiniTable_Field* f)
+    {
+        UPB_ASSERT(f->presence < 0);
+        return ~(ptrdiff_t)f->presence;
+    }
+
+    UPB_INLINE uint32_t* _upb_oneofcase_field(upb_Message* msg, const upb_MiniTable_Field* f)
+    {
+        return _upb_oneofcase(msg, _upb_oneofcase_ofs(f));
+    }
+
+    UPB_INLINE uint32_t _upb_getoneofcase_field(const upb_Message* msg, const upb_MiniTable_Field* f)
+    {
+        return _upb_getoneofcase(msg, _upb_oneofcase_ofs(f));
+    }
+
+    UPB_INLINE bool _upb_has_submsg_nohasbit(const upb_Message* msg, size_t ofs)
+    {
+        return *UPB_PTR_AT(msg, ofs, const upb_Message*) != NULL;
+    }
+
+    /** upb_Array *****************************************************************/
+
+    /* Our internal representation for repeated fields.  */
+    typedef struct
+    {
+        uintptr_t data; /* Tagged ptr: low 3 bits of ptr are lg2(elem size). */
+        size_t len;     /* Measured in elements. */
+        size_t size;    /* Measured in elements. */
+        uint64_t junk;
+    } upb_Array;
+
+    UPB_INLINE const void* _upb_array_constptr(const upb_Array* arr)
+    {
+        UPB_ASSERT((arr->data & 7) <= 4);
+        return (void*)(arr->data & ~(uintptr_t)7);
+    }
+
+    UPB_INLINE uintptr_t _upb_array_tagptr(void* ptr, int elem_size_lg2)
+    {
+        UPB_ASSERT(elem_size_lg2 <= 4);
+        return (uintptr_t)ptr | elem_size_lg2;
+    }
+
+    UPB_INLINE void* _upb_array_ptr(upb_Array* arr)
+    {
+        return (void*)_upb_array_constptr(arr);
+    }
+
+    UPB_INLINE uintptr_t _upb_tag_arrptr(void* ptr, int elem_size_lg2)
+    {
+        UPB_ASSERT(elem_size_lg2 <= 4);
+        UPB_ASSERT(((uintptr_t)ptr & 7) == 0);
+        return (uintptr_t)ptr | (unsigned)elem_size_lg2;
+    }
+
+    UPB_INLINE upb_Array* _upb_Array_New(upb_Arena* a, size_t init_size, int elem_size_lg2)
+    {
+        const size_t arr_size = UPB_ALIGN_UP(sizeof(upb_Array), 8);
+        const size_t bytes = sizeof(upb_Array) + (init_size << elem_size_lg2);
+        upb_Array* arr = (upb_Array*)upb_Arena_Malloc(a, bytes);
+        if (!arr)
+            return NULL;
+        arr->data = _upb_tag_arrptr(UPB_PTR_AT(arr, arr_size, void), elem_size_lg2);
+        arr->len = 0;
+        arr->size = init_size;
+        return arr;
+    }
+
+    /* Resizes the capacity of the array to be at least min_size. */
+    bool _upb_array_realloc(upb_Array* arr, size_t min_size, upb_Arena* arena);
+
+    /* Fallback functions for when the accessors require a resize. */
+    void* _upb_Array_Resize_fallback(upb_Array** arr_ptr, size_t size, int elem_size_lg2, upb_Arena* arena);
+    bool _upb_Array_Append_fallback(upb_Array** arr_ptr, const void* value, int elem_size_lg2, upb_Arena* arena);
+
+    UPB_INLINE bool _upb_array_reserve(upb_Array* arr, size_t size, upb_Arena* arena)
+    {
+        if (arr->size < size)
+            return _upb_array_realloc(arr, size, arena);
+        return true;
+    }
+
+    UPB_INLINE bool _upb_Array_Resize(upb_Array* arr, size_t size, upb_Arena* arena)
+    {
+        if (!_upb_array_reserve(arr, size, arena))
+            return false;
+        arr->len = size;
+        return true;
+    }
+
+    UPB_INLINE void _upb_array_detach(const void* msg, size_t ofs)
+    {
+        *UPB_PTR_AT(msg, ofs, upb_Array*) = NULL;
+    }
+
+    UPB_INLINE const void* _upb_array_accessor(const void* msg, size_t ofs, size_t* size)
+    {
+        const upb_Array* arr = *UPB_PTR_AT(msg, ofs, const upb_Array*);
+        if (arr)
+        {
+            if (size)
+                *size = arr->len;
+            return _upb_array_constptr(arr);
+        }
+        else
+        {
+            if (size)
+                *size = 0;
+            return NULL;
+        }
+    }
+
+    UPB_INLINE void* _upb_array_mutable_accessor(void* msg, size_t ofs, size_t* size)
+    {
+        upb_Array* arr = *UPB_PTR_AT(msg, ofs, upb_Array*);
+        if (arr)
+        {
+            if (size)
+                *size = arr->len;
+            return _upb_array_ptr(arr);
+        }
+        else
+        {
+            if (size)
+                *size = 0;
+            return NULL;
+        }
+    }
+
+    UPB_INLINE void* _upb_Array_Resize_accessor2(void* msg, size_t ofs, size_t size, int elem_size_lg2, upb_Arena* arena)
+    {
+        upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
+        upb_Array* arr = *arr_ptr;
+        if (!arr || arr->size < size)
+        {
+            return _upb_Array_Resize_fallback(arr_ptr, size, elem_size_lg2, arena);
+        }
+        arr->len = size;
+        return _upb_array_ptr(arr);
+    }
+
+    UPB_INLINE bool _upb_Array_Append_accessor2(void* msg, size_t ofs, int elem_size_lg2, const void* value, upb_Arena* arena)
+    {
+        upb_Array** arr_ptr = UPB_PTR_AT(msg, ofs, upb_Array*);
+        size_t elem_size = 1 << elem_size_lg2;
+        upb_Array* arr = *arr_ptr;
+        void* ptr;
+        if (!arr || arr->len == arr->size)
+        {
+            return _upb_Array_Append_fallback(arr_ptr, value, elem_size_lg2, arena);
+        }
+        ptr = _upb_array_ptr(arr);
+        memcpy(UPB_PTR_AT(ptr, arr->len * elem_size, char), value, elem_size);
+        arr->len++;
+        return true;
+    }
+
+    /* Used by old generated code, remove once all code has been regenerated. */
+    UPB_INLINE int _upb_sizelg2(upb_CType type)
+    {
+        switch (type)
+        {
+            case kUpb_CType_Bool:
+                return 0;
+            case kUpb_CType_Float:
+            case kUpb_CType_Int32:
+            case kUpb_CType_UInt32:
+            case kUpb_CType_Enum:
+                return 2;
+            case kUpb_CType_Message:
+                return UPB_SIZE(2, 3);
+            case kUpb_CType_Double:
+            case kUpb_CType_Int64:
+            case kUpb_CType_UInt64:
+                return 3;
+            case kUpb_CType_String:
+            case kUpb_CType_Bytes:
+                return UPB_SIZE(3, 4);
+        }
+        UPB_UNREACHABLE();
+    }
+    UPB_INLINE void* _upb_Array_Resize_accessor(void* msg, size_t ofs, size_t size, upb_CType type, upb_Arena* arena)
+    {
+        return _upb_Array_Resize_accessor2(msg, ofs, size, _upb_sizelg2(type), arena);
+    }
+    UPB_INLINE bool _upb_Array_Append_accessor(void* msg, size_t ofs, size_t elem_size, upb_CType type, const void* value, upb_Arena* arena)
+    {
+        (void)elem_size;
+        return _upb_Array_Append_accessor2(msg, ofs, _upb_sizelg2(type), value, arena);
+    }
+
+    /** upb_Map *******************************************************************/
+
+    /* Right now we use strmaps for everything.  We'll likely want to use
+     * integer-specific maps for integer-keyed maps.*/
+    typedef struct
+    {
+        /* Size of key and val, based on the map type.  Strings are represented as '0'
+         * because they must be handled specially. */
+        char key_size;
+        char val_size;
+
+        upb_strtable table;
+    } upb_Map;
+
+    /* Map entries aren't actually stored, they are only used during parsing.  For
+     * parsing, it helps a lot if all map entry messages have the same layout.
+     * The compiler and def.c must ensure that all map entries have this layout. */
+    typedef struct
+    {
+        upb_Message_Internal internal;
+        union
+        {
+            upb_StringView str; /* For str/bytes. */
+            upb_value val;      /* For all other types. */
+        } k;
+        union
+        {
+            upb_StringView str; /* For str/bytes. */
+            upb_value val;      /* For all other types. */
+        } v;
+    } upb_MapEntry;
+
+    /* Creates a new map on the given arena with this key/value type. */
+    upb_Map* _upb_Map_New(upb_Arena* a, size_t key_size, size_t value_size);
+
+    /* Converting between internal table representation and user values.
+     *
+     * _upb_map_tokey() and _upb_map_fromkey() are inverses.
+     * _upb_map_tovalue() and _upb_map_fromvalue() are inverses.
+     *
+     * These functions account for the fact that strings are treated differently
+     * from other types when stored in a map.
+     */
+
+    UPB_INLINE upb_StringView _upb_map_tokey(const void* key, size_t size)
+    {
+        if (size == UPB_MAPTYPE_STRING)
+        {
+            return *(upb_StringView*)key;
+        }
+        else
+        {
+            return upb_StringView_FromDataAndSize((const char*)key, size);
+        }
+    }
+
+    UPB_INLINE void _upb_map_fromkey(upb_StringView key, void* out, size_t size)
+    {
+        if (size == UPB_MAPTYPE_STRING)
+        {
+            memcpy(out, &key, sizeof(key));
+        }
+        else
+        {
+            memcpy(out, key.data, size);
+        }
+    }
+
+    UPB_INLINE bool _upb_map_tovalue(const void* val, size_t size, upb_value* msgval, upb_Arena* a)
+    {
+        if (size == UPB_MAPTYPE_STRING)
+        {
+            upb_StringView* strp = (upb_StringView*)upb_Arena_Malloc(a, sizeof(*strp));
+            if (!strp)
+                return false;
+            *strp = *(upb_StringView*)val;
+            *msgval = upb_value_ptr(strp);
+        }
+        else
+        {
+            memcpy(msgval, val, size);
+        }
+        return true;
+    }
+
+    UPB_INLINE void _upb_map_fromvalue(upb_value val, void* out, size_t size)
+    {
+        if (size == UPB_MAPTYPE_STRING)
+        {
+            const upb_StringView* strp = (const upb_StringView*)upb_value_getptr(val);
+            memcpy(out, strp, sizeof(upb_StringView));
+        }
+        else
+        {
+            memcpy(out, &val, size);
+        }
+    }
+
+    /* Map operations, shared by reflection and generated code. */
+
+    UPB_INLINE size_t _upb_Map_Size(const upb_Map* map)
+    {
+        return map->table.t.count;
+    }
+
+    UPB_INLINE bool _upb_Map_Get(const upb_Map* map, const void* key, size_t key_size, void* val, size_t val_size)
+    {
+        upb_value tabval;
+        upb_StringView k = _upb_map_tokey(key, key_size);
+        bool ret = upb_strtable_lookup2(&map->table, k.data, k.size, &tabval);
+        if (ret && val)
+        {
+            _upb_map_fromvalue(tabval, val, val_size);
+        }
+        return ret;
+    }
+
+    UPB_INLINE void* _upb_map_next(const upb_Map* map, size_t* iter)
+    {
+        upb_strtable_iter it;
+        it.t = &map->table;
+        it.index = *iter;
+        upb_strtable_next(&it);
+        *iter = it.index;
+        if (upb_strtable_done(&it))
+            return NULL;
+        return (void*)str_tabent(&it);
+    }
+
+    typedef enum
+    {
+        // LINT.IfChange
+        _kUpb_MapInsertStatus_Inserted = 0,
+        _kUpb_MapInsertStatus_Replaced = 1,
+        _kUpb_MapInsertStatus_OutOfMemory = 2,
+        // LINT.ThenChange(//depot/google3/third_party/upb/upb/map.h)
+    } _upb_MapInsertStatus;
+
+    UPB_INLINE _upb_MapInsertStatus _upb_Map_Insert(upb_Map* map, const void* key, size_t key_size, void* val, size_t val_size, upb_Arena* a)
+    {
+        upb_StringView strkey = _upb_map_tokey(key, key_size);
+        upb_value tabval = {0};
+        if (!_upb_map_tovalue(val, val_size, &tabval, a))
+        {
+            return _kUpb_MapInsertStatus_OutOfMemory;
+        }
+
+        /* TODO(haberman): add overwrite operation to minimize number of lookups. */
+        bool removed =
+            upb_strtable_remove2(&map->table, strkey.data, strkey.size, NULL);
+        if (!upb_strtable_insert(&map->table, strkey.data, strkey.size, tabval, a))
+        {
+            return _kUpb_MapInsertStatus_OutOfMemory;
+        }
+        return removed ? _kUpb_MapInsertStatus_Replaced : _kUpb_MapInsertStatus_Inserted;
+    }
+
+    UPB_INLINE bool _upb_Map_Delete(upb_Map* map, const void* key, size_t key_size)
+    {
+        upb_StringView k = _upb_map_tokey(key, key_size);
+        return upb_strtable_remove2(&map->table, k.data, k.size, NULL);
+    }
+
+    UPB_INLINE void _upb_Map_Clear(upb_Map* map)
+    {
+        upb_strtable_clear(&map->table);
+    }
+
+    /* Message map operations, these get the map from the message first. */
+
+    UPB_INLINE size_t _upb_msg_map_size(const upb_Message* msg, size_t ofs)
+    {
+        upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+        return map ? _upb_Map_Size(map) : 0;
+    }
+
+    UPB_INLINE bool _upb_msg_map_get(const upb_Message* msg, size_t ofs, const void* key, size_t key_size, void* val, size_t val_size)
+    {
+        upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+        if (!map)
+            return false;
+        return _upb_Map_Get(map, key, key_size, val, val_size);
+    }
+
+    UPB_INLINE void* _upb_msg_map_next(const upb_Message* msg, size_t ofs, size_t* iter)
+    {
+        upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+        if (!map)
+            return NULL;
+        return _upb_map_next(map, iter);
+    }
+
+    UPB_INLINE bool _upb_msg_map_set(upb_Message* msg, size_t ofs, const void* key, size_t key_size, void* val, size_t val_size, upb_Arena* arena)
+    {
+        upb_Map** map = UPB_PTR_AT(msg, ofs, upb_Map*);
+        if (!*map)
+        {
+            *map = _upb_Map_New(arena, key_size, val_size);
+        }
+        return _upb_Map_Insert(*map, key, key_size, val, val_size, arena) !=
+               _kUpb_MapInsertStatus_OutOfMemory;
+    }
+
+    UPB_INLINE bool _upb_msg_map_delete(upb_Message* msg, size_t ofs, const void* key, size_t key_size)
+    {
+        upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+        if (!map)
+            return false;
+        return _upb_Map_Delete(map, key, key_size);
+    }
+
+    UPB_INLINE void _upb_msg_map_clear(upb_Message* msg, size_t ofs)
+    {
+        upb_Map* map = *UPB_PTR_AT(msg, ofs, upb_Map*);
+        if (!map)
+            return;
+        _upb_Map_Clear(map);
+    }
+
+    /* Accessing map key/value from a pointer, used by generated code only. */
+
+    UPB_INLINE void _upb_msg_map_key(const void* msg, void* key, size_t size)
+    {
+        const upb_tabent* ent = (const upb_tabent*)msg;
+        uint32_t u32len;
+        upb_StringView k;
+        k.data = upb_tabstr(ent->key, &u32len);
+        k.size = u32len;
+        _upb_map_fromkey(k, key, size);
+    }
+
+    UPB_INLINE void _upb_msg_map_value(const void* msg, void* val, size_t size)
+    {
+        const upb_tabent* ent = (const upb_tabent*)msg;
+        upb_value v = {ent->val.val};
+        _upb_map_fromvalue(v, val, size);
+    }
+
+    UPB_INLINE void _upb_msg_map_set_value(void* msg, const void* val, size_t size)
+    {
+        upb_tabent* ent = (upb_tabent*)msg;
+        /* This is like _upb_map_tovalue() except the entry already exists so we can
+         * reuse the allocated upb_StringView for string fields. */
+        if (size == UPB_MAPTYPE_STRING)
+        {
+            upb_StringView* strp = (upb_StringView*)(uintptr_t)ent->val.val;
+            memcpy(strp, val, sizeof(*strp));
+        }
+        else
+        {
+            memcpy(&ent->val.val, val, size);
+        }
+    }
+
+    /** _upb_mapsorter ************************************************************/
+
+    /* _upb_mapsorter sorts maps and provides ordered iteration over the entries.
+     * Since maps can be recursive (map values can be messages which contain other
+     * maps). _upb_mapsorter can contain a stack of maps. */
+
+    typedef struct
+    {
+        upb_tabent const** entries;
+        int size;
+        int cap;
+    } _upb_mapsorter;
+
+    typedef struct
+    {
+        int start;
+        int pos;
+        int end;
+    } _upb_sortedmap;
+
+    UPB_INLINE void _upb_mapsorter_init(_upb_mapsorter* s)
+    {
+        s->entries = NULL;
+        s->size = 0;
+        s->cap = 0;
+    }
+
+    UPB_INLINE void _upb_mapsorter_destroy(_upb_mapsorter* s)
+    {
+        if (s->entries)
+            free(s->entries);
+    }
+
+    bool _upb_mapsorter_pushmap(_upb_mapsorter* s, upb_FieldType key_type, const upb_Map* map, _upb_sortedmap* sorted);
+
+    UPB_INLINE void _upb_mapsorter_popmap(_upb_mapsorter* s, _upb_sortedmap* sorted)
+    {
+        s->size = sorted->start;
+    }
+
+    UPB_INLINE bool _upb_sortedmap_next(_upb_mapsorter* s, const upb_Map* map, _upb_sortedmap* sorted, upb_MapEntry* ent)
+    {
+        if (sorted->pos == sorted->end)
+            return false;
+        const upb_tabent* tabent = s->entries[sorted->pos++];
+        upb_StringView key = upb_tabstrview(tabent->key);
+        _upb_map_fromkey(key, &ent->k, map->key_size);
+        upb_value val = {tabent->val.val};
+        _upb_map_fromvalue(val, &ent->v, map->val_size);
+        return true;
+    }
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/reflection.h b/CAPI/cpp/grpc/include/upb/reflection.h
index 6071fba..36a54e8 100644
--- a/CAPI/cpp/grpc/include/upb/reflection.h
+++ b/CAPI/cpp/grpc/include/upb/reflection.h
@@ -36,70 +36,64 @@
 #include "upb/upb.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-upb_MessageValue upb_FieldDef_Default(const upb_FieldDef* f);
+    upb_MessageValue upb_FieldDef_Default(const upb_FieldDef* f);
 
-/** upb_Message
- * *******************************************************************/
+    /** upb_Message
+     * *******************************************************************/
 
-/* Creates a new message of the given type in the given arena. */
-upb_Message* upb_Message_New(const upb_MessageDef* m, upb_Arena* a);
+    /* Creates a new message of the given type in the given arena. */
+    upb_Message* upb_Message_New(const upb_MessageDef* m, upb_Arena* a);
 
-/* Returns the value associated with this field. */
-upb_MessageValue upb_Message_Get(const upb_Message* msg, const upb_FieldDef* f);
+    /* Returns the value associated with this field. */
+    upb_MessageValue upb_Message_Get(const upb_Message* msg, const upb_FieldDef* f);
 
-/* Returns a mutable pointer to a map, array, or submessage value.  If the given
- * arena is non-NULL this will construct a new object if it was not previously
- * present.  May not be called for primitive fields. */
-upb_MutableMessageValue upb_Message_Mutable(upb_Message* msg,
-                                            const upb_FieldDef* f,
-                                            upb_Arena* a);
+    /* Returns a mutable pointer to a map, array, or submessage value.  If the given
+     * arena is non-NULL this will construct a new object if it was not previously
+     * present.  May not be called for primitive fields. */
+    upb_MutableMessageValue upb_Message_Mutable(upb_Message* msg, const upb_FieldDef* f, upb_Arena* a);
 
-/* May only be called for fields where upb_FieldDef_HasPresence(f) == true. */
-bool upb_Message_Has(const upb_Message* msg, const upb_FieldDef* f);
+    /* May only be called for fields where upb_FieldDef_HasPresence(f) == true. */
+    bool upb_Message_Has(const upb_Message* msg, const upb_FieldDef* f);
 
-/* Returns the field that is set in the oneof, or NULL if none are set. */
-const upb_FieldDef* upb_Message_WhichOneof(const upb_Message* msg,
-                                           const upb_OneofDef* o);
+    /* Returns the field that is set in the oneof, or NULL if none are set. */
+    const upb_FieldDef* upb_Message_WhichOneof(const upb_Message* msg, const upb_OneofDef* o);
 
-/* Sets the given field to the given value.  For a msg/array/map/string, the
- * caller must ensure that the target data outlives |msg| (by living either in
- * the same arena or a different arena that outlives it).
- *
- * Returns false if allocation fails. */
-bool upb_Message_Set(upb_Message* msg, const upb_FieldDef* f,
-                     upb_MessageValue val, upb_Arena* a);
+    /* Sets the given field to the given value.  For a msg/array/map/string, the
+     * caller must ensure that the target data outlives |msg| (by living either in
+     * the same arena or a different arena that outlives it).
+     *
+     * Returns false if allocation fails. */
+    bool upb_Message_Set(upb_Message* msg, const upb_FieldDef* f, upb_MessageValue val, upb_Arena* a);
 
-/* Clears any field presence and sets the value back to its default. */
-void upb_Message_ClearField(upb_Message* msg, const upb_FieldDef* f);
+    /* Clears any field presence and sets the value back to its default. */
+    void upb_Message_ClearField(upb_Message* msg, const upb_FieldDef* f);
 
-/* Clear all data and unknown fields. */
-void upb_Message_Clear(upb_Message* msg, const upb_MessageDef* m);
+    /* Clear all data and unknown fields. */
+    void upb_Message_Clear(upb_Message* msg, const upb_MessageDef* m);
 
-/* Iterate over present fields.
- *
- * size_t iter = kUpb_Message_Begin;
- * const upb_FieldDef *f;
- * upb_MessageValue val;
- * while (upb_Message_Next(msg, m, ext_pool, &f, &val, &iter)) {
- *   process_field(f, val);
- * }
- *
- * If ext_pool is NULL, no extensions will be returned.  If the given symtab
- * returns extensions that don't match what is in this message, those extensions
- * will be skipped.
- */
+    /* Iterate over present fields.
+     *
+     * size_t iter = kUpb_Message_Begin;
+     * const upb_FieldDef *f;
+     * upb_MessageValue val;
+     * while (upb_Message_Next(msg, m, ext_pool, &f, &val, &iter)) {
+     *   process_field(f, val);
+     * }
+     *
+     * If ext_pool is NULL, no extensions will be returned.  If the given symtab
+     * returns extensions that don't match what is in this message, those extensions
+     * will be skipped.
+     */
 
 #define kUpb_Message_Begin -1
-bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m,
-                      const upb_DefPool* ext_pool, const upb_FieldDef** f,
-                      upb_MessageValue* val, size_t* iter);
+    bool upb_Message_Next(const upb_Message* msg, const upb_MessageDef* m, const upb_DefPool* ext_pool, const upb_FieldDef** f, upb_MessageValue* val, size_t* iter);
 
-/* Clears all unknown field data from this message and all submessages. */
-bool upb_Message_DiscardUnknown(upb_Message* msg, const upb_MessageDef* m,
-                                int maxdepth);
+    /* Clears all unknown field data from this message and all submessages. */
+    bool upb_Message_DiscardUnknown(upb_Message* msg, const upb_MessageDef* m, int maxdepth);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/reflection.hpp b/CAPI/cpp/grpc/include/upb/reflection.hpp
index b653893..57a28f1 100644
--- a/CAPI/cpp/grpc/include/upb/reflection.hpp
+++ b/CAPI/cpp/grpc/include/upb/reflection.hpp
@@ -28,9 +28,10 @@
 
 #include "upb/reflection.h"
 
-namespace upb {
+namespace upb
+{
 
-typedef upb_MessageValue MessageValue;
+    typedef upb_MessageValue MessageValue;
 
 }  // namespace upb
 
diff --git a/CAPI/cpp/grpc/include/upb/status.h b/CAPI/cpp/grpc/include/upb/status.h
index 2c5c2a7..dbdd50c 100644
--- a/CAPI/cpp/grpc/include/upb/status.h
+++ b/CAPI/cpp/grpc/include/upb/status.h
@@ -34,28 +34,28 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #define _kUpb_Status_MaxMessage 127
 
-typedef struct {
-  bool ok;
-  char msg[_kUpb_Status_MaxMessage]; /* Error message; NULL-terminated. */
-} upb_Status;
+    typedef struct
+    {
+        bool ok;
+        char msg[_kUpb_Status_MaxMessage]; /* Error message; NULL-terminated. */
+    } upb_Status;
 
-const char* upb_Status_ErrorMessage(const upb_Status* status);
-bool upb_Status_IsOk(const upb_Status* status);
+    const char* upb_Status_ErrorMessage(const upb_Status* status);
+    bool upb_Status_IsOk(const upb_Status* status);
 
-/* These are no-op if |status| is NULL. */
-void upb_Status_Clear(upb_Status* status);
-void upb_Status_SetErrorMessage(upb_Status* status, const char* msg);
-void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...)
-    UPB_PRINTF(2, 3);
-void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt,
-                                va_list args) UPB_PRINTF(2, 0);
-void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt,
-                                   va_list args) UPB_PRINTF(2, 0);
+    /* These are no-op if |status| is NULL. */
+    void upb_Status_Clear(upb_Status* status);
+    void upb_Status_SetErrorMessage(upb_Status* status, const char* msg);
+    void upb_Status_SetErrorFormat(upb_Status* status, const char* fmt, ...)
+        UPB_PRINTF(2, 3);
+    void upb_Status_VSetErrorFormat(upb_Status* status, const char* fmt, va_list args) UPB_PRINTF(2, 0);
+    void upb_Status_VAppendErrorFormat(upb_Status* status, const char* fmt, va_list args) UPB_PRINTF(2, 0);
 
 #include "upb/port_undef.inc"
 
diff --git a/CAPI/cpp/grpc/include/upb/text_encode.h b/CAPI/cpp/grpc/include/upb/text_encode.h
index 2e817a3..b0e0fdb 100644
--- a/CAPI/cpp/grpc/include/upb/text_encode.h
+++ b/CAPI/cpp/grpc/include/upb/text_encode.h
@@ -31,31 +31,31 @@
 #include "upb/def.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-enum {
-  /* When set, prints everything on a single line. */
-  UPB_TXTENC_SINGLELINE = 1,
+    enum
+    {
+        /* When set, prints everything on a single line. */
+        UPB_TXTENC_SINGLELINE = 1,
 
-  /* When set, unknown fields are not printed. */
-  UPB_TXTENC_SKIPUNKNOWN = 2,
+        /* When set, unknown fields are not printed. */
+        UPB_TXTENC_SKIPUNKNOWN = 2,
 
-  /* When set, maps are *not* sorted (this avoids allocating tmp mem). */
-  UPB_TXTENC_NOSORT = 4
-};
+        /* When set, maps are *not* sorted (this avoids allocating tmp mem). */
+        UPB_TXTENC_NOSORT = 4
+    };
 
-/* Encodes the given |msg| to text format.  The message's reflection is given in
- * |m|.  The symtab in |symtab| is used to find extensions (if NULL, extensions
- * will not be printed).
- *
- * Output is placed in the given buffer, and always NULL-terminated.  The output
- * size (excluding NULL) is returned.  This means that a return value >= |size|
- * implies that the output was truncated.  (These are the same semantics as
- * snprintf()). */
-size_t upb_TextEncode(const upb_Message* msg, const upb_MessageDef* m,
-                      const upb_DefPool* ext_pool, int options, char* buf,
-                      size_t size);
+    /* Encodes the given |msg| to text format.  The message's reflection is given in
+     * |m|.  The symtab in |symtab| is used to find extensions (if NULL, extensions
+     * will not be printed).
+     *
+     * Output is placed in the given buffer, and always NULL-terminated.  The output
+     * size (excluding NULL) is returned.  This means that a return value >= |size|
+     * implies that the output was truncated.  (These are the same semantics as
+     * snprintf()). */
+    size_t upb_TextEncode(const upb_Message* msg, const upb_MessageDef* m, const upb_DefPool* ext_pool, int options, char* buf, size_t size);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/upb.h b/CAPI/cpp/grpc/include/upb/upb.h
index 7398d09..90228e1 100644
--- a/CAPI/cpp/grpc/include/upb/upb.h
+++ b/CAPI/cpp/grpc/include/upb/upb.h
@@ -47,133 +47,158 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-/** upb_StringView ************************************************************/
+    /** upb_StringView ************************************************************/
 
-typedef struct {
-  const char* data;
-  size_t size;
-} upb_StringView;
+    typedef struct
+    {
+        const char* data;
+        size_t size;
+    } upb_StringView;
 
-UPB_INLINE upb_StringView upb_StringView_FromDataAndSize(const char* data,
-                                                         size_t size) {
-  upb_StringView ret;
-  ret.data = data;
-  ret.size = size;
-  return ret;
-}
+    UPB_INLINE upb_StringView upb_StringView_FromDataAndSize(const char* data, size_t size)
+    {
+        upb_StringView ret;
+        ret.data = data;
+        ret.size = size;
+        return ret;
+    }
 
-UPB_INLINE upb_StringView upb_StringView_FromString(const char* data) {
-  return upb_StringView_FromDataAndSize(data, strlen(data));
-}
+    UPB_INLINE upb_StringView upb_StringView_FromString(const char* data)
+    {
+        return upb_StringView_FromDataAndSize(data, strlen(data));
+    }
 
-UPB_INLINE bool upb_StringView_IsEqual(upb_StringView a, upb_StringView b) {
-  return a.size == b.size && memcmp(a.data, b.data, a.size) == 0;
-}
+    UPB_INLINE bool upb_StringView_IsEqual(upb_StringView a, upb_StringView b)
+    {
+        return a.size == b.size && memcmp(a.data, b.data, a.size) == 0;
+    }
 
 #define UPB_STRINGVIEW_INIT(ptr, len) \
-  { ptr, len }
+    {                                 \
+        ptr, len                      \
+    }
 
 #define UPB_STRINGVIEW_FORMAT "%.*s"
 #define UPB_STRINGVIEW_ARGS(view) (int)(view).size, (view).data
 
-/* Constants ******************************************************************/
-
-/* A list of types as they are encoded on-the-wire. */
-typedef enum {
-  kUpb_WireType_Varint = 0,
-  kUpb_WireType_64Bit = 1,
-  kUpb_WireType_Delimited = 2,
-  kUpb_WireType_StartGroup = 3,
-  kUpb_WireType_EndGroup = 4,
-  kUpb_WireType_32Bit = 5
-} upb_WireType;
-
-/* The types a field can have.  Note that this list is not identical to the
- * types defined in descriptor.proto, which gives INT32 and SINT32 separate
- * types (we distinguish the two with the "integer encoding" enum below). */
-typedef enum {
-  kUpb_CType_Bool = 1,
-  kUpb_CType_Float = 2,
-  kUpb_CType_Int32 = 3,
-  kUpb_CType_UInt32 = 4,
-  kUpb_CType_Enum = 5, /* Enum values are int32. */
-  kUpb_CType_Message = 6,
-  kUpb_CType_Double = 7,
-  kUpb_CType_Int64 = 8,
-  kUpb_CType_UInt64 = 9,
-  kUpb_CType_String = 10,
-  kUpb_CType_Bytes = 11
-} upb_CType;
-
-/* The repeated-ness of each field; this matches descriptor.proto. */
-typedef enum {
-  kUpb_Label_Optional = 1,
-  kUpb_Label_Required = 2,
-  kUpb_Label_Repeated = 3
-} upb_Label;
-
-/* Descriptor types, as defined in descriptor.proto. */
-typedef enum {
-  kUpb_FieldType_Double = 1,
-  kUpb_FieldType_Float = 2,
-  kUpb_FieldType_Int64 = 3,
-  kUpb_FieldType_UInt64 = 4,
-  kUpb_FieldType_Int32 = 5,
-  kUpb_FieldType_Fixed64 = 6,
-  kUpb_FieldType_Fixed32 = 7,
-  kUpb_FieldType_Bool = 8,
-  kUpb_FieldType_String = 9,
-  kUpb_FieldType_Group = 10,
-  kUpb_FieldType_Message = 11,
-  kUpb_FieldType_Bytes = 12,
-  kUpb_FieldType_UInt32 = 13,
-  kUpb_FieldType_Enum = 14,
-  kUpb_FieldType_SFixed32 = 15,
-  kUpb_FieldType_SFixed64 = 16,
-  kUpb_FieldType_SInt32 = 17,
-  kUpb_FieldType_SInt64 = 18
-} upb_FieldType;
+    /* Constants ******************************************************************/
+
+    /* A list of types as they are encoded on-the-wire. */
+    typedef enum
+    {
+        kUpb_WireType_Varint = 0,
+        kUpb_WireType_64Bit = 1,
+        kUpb_WireType_Delimited = 2,
+        kUpb_WireType_StartGroup = 3,
+        kUpb_WireType_EndGroup = 4,
+        kUpb_WireType_32Bit = 5
+    } upb_WireType;
+
+    /* The types a field can have.  Note that this list is not identical to the
+     * types defined in descriptor.proto, which gives INT32 and SINT32 separate
+     * types (we distinguish the two with the "integer encoding" enum below). */
+    typedef enum
+    {
+        kUpb_CType_Bool = 1,
+        kUpb_CType_Float = 2,
+        kUpb_CType_Int32 = 3,
+        kUpb_CType_UInt32 = 4,
+        kUpb_CType_Enum = 5, /* Enum values are int32. */
+        kUpb_CType_Message = 6,
+        kUpb_CType_Double = 7,
+        kUpb_CType_Int64 = 8,
+        kUpb_CType_UInt64 = 9,
+        kUpb_CType_String = 10,
+        kUpb_CType_Bytes = 11
+    } upb_CType;
+
+    /* The repeated-ness of each field; this matches descriptor.proto. */
+    typedef enum
+    {
+        kUpb_Label_Optional = 1,
+        kUpb_Label_Required = 2,
+        kUpb_Label_Repeated = 3
+    } upb_Label;
+
+    /* Descriptor types, as defined in descriptor.proto. */
+    typedef enum
+    {
+        kUpb_FieldType_Double = 1,
+        kUpb_FieldType_Float = 2,
+        kUpb_FieldType_Int64 = 3,
+        kUpb_FieldType_UInt64 = 4,
+        kUpb_FieldType_Int32 = 5,
+        kUpb_FieldType_Fixed64 = 6,
+        kUpb_FieldType_Fixed32 = 7,
+        kUpb_FieldType_Bool = 8,
+        kUpb_FieldType_String = 9,
+        kUpb_FieldType_Group = 10,
+        kUpb_FieldType_Message = 11,
+        kUpb_FieldType_Bytes = 12,
+        kUpb_FieldType_UInt32 = 13,
+        kUpb_FieldType_Enum = 14,
+        kUpb_FieldType_SFixed32 = 15,
+        kUpb_FieldType_SFixed64 = 16,
+        kUpb_FieldType_SInt32 = 17,
+        kUpb_FieldType_SInt64 = 18
+    } upb_FieldType;
 
 #define kUpb_Map_Begin ((size_t)-1)
 
-UPB_INLINE bool _upb_IsLittleEndian(void) {
-  int x = 1;
-  return *(char*)&x == 1;
-}
-
-UPB_INLINE uint32_t _upb_BigEndian_Swap32(uint32_t val) {
-  if (_upb_IsLittleEndian()) {
-    return val;
-  } else {
-    return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
-           ((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
-  }
-}
-
-UPB_INLINE uint64_t _upb_BigEndian_Swap64(uint64_t val) {
-  if (_upb_IsLittleEndian()) {
-    return val;
-  } else {
-    return ((uint64_t)_upb_BigEndian_Swap32((uint32_t)val) << 32) |
-           _upb_BigEndian_Swap32((uint32_t)(val >> 32));
-  }
-}
-
-UPB_INLINE int _upb_Log2Ceiling(int x) {
-  if (x <= 1) return 0;
+    UPB_INLINE bool _upb_IsLittleEndian(void)
+    {
+        int x = 1;
+        return *(char*)&x == 1;
+    }
+
+    UPB_INLINE uint32_t _upb_BigEndian_Swap32(uint32_t val)
+    {
+        if (_upb_IsLittleEndian())
+        {
+            return val;
+        }
+        else
+        {
+            return ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
+                   ((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
+        }
+    }
+
+    UPB_INLINE uint64_t _upb_BigEndian_Swap64(uint64_t val)
+    {
+        if (_upb_IsLittleEndian())
+        {
+            return val;
+        }
+        else
+        {
+            return ((uint64_t)_upb_BigEndian_Swap32((uint32_t)val) << 32) |
+                   _upb_BigEndian_Swap32((uint32_t)(val >> 32));
+        }
+    }
+
+    UPB_INLINE int _upb_Log2Ceiling(int x)
+    {
+        if (x <= 1)
+            return 0;
 #ifdef __GNUC__
-  return 32 - __builtin_clz(x - 1);
+        return 32 - __builtin_clz(x - 1);
 #else
-  int lg2 = 0;
-  while (1 << lg2 < x) lg2++;
-  return lg2;
+    int lg2 = 0;
+    while (1 << lg2 < x)
+        lg2++;
+    return lg2;
 #endif
-}
+    }
 
-UPB_INLINE int _upb_Log2CeilingSize(int x) { return 1 << _upb_Log2Ceiling(x); }
+    UPB_INLINE int _upb_Log2CeilingSize(int x)
+    {
+        return 1 << _upb_Log2Ceiling(x);
+    }
 
 #include "upb/port_undef.inc"
 
diff --git a/CAPI/cpp/grpc/include/upb/upb.hpp b/CAPI/cpp/grpc/include/upb/upb.hpp
index 2e4a21b..587194e 100644
--- a/CAPI/cpp/grpc/include/upb/upb.hpp
+++ b/CAPI/cpp/grpc/include/upb/upb.hpp
@@ -30,85 +30,121 @@
 
 #include "upb/upb.h"
 
-namespace upb {
-
-class Status {
- public:
-  Status() { upb_Status_Clear(&status_); }
-
-  upb_Status* ptr() { return &status_; }
-
-  // Returns true if there is no error.
-  bool ok() const { return upb_Status_IsOk(&status_); }
-
-  // Guaranteed to be NULL-terminated.
-  const char* error_message() const {
-    return upb_Status_ErrorMessage(&status_);
-  }
-
-  // The error message will be truncated if it is longer than
-  // _kUpb_Status_MaxMessage-4.
-  void SetErrorMessage(const char* msg) {
-    upb_Status_SetErrorMessage(&status_, msg);
-  }
-  void SetFormattedErrorMessage(const char* fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    upb_Status_VSetErrorFormat(&status_, fmt, args);
-    va_end(args);
-  }
-
-  // Resets the status to a successful state with no message.
-  void Clear() { upb_Status_Clear(&status_); }
-
- private:
-  upb_Status status_;
-};
-
-class Arena {
- public:
-  // A simple arena with no initial memory block and the default allocator.
-  Arena() : ptr_(upb_Arena_New(), upb_Arena_Free) {}
-  Arena(char* initial_block, size_t size)
-      : ptr_(upb_Arena_Init(initial_block, size, &upb_alloc_global),
-             upb_Arena_Free) {}
-
-  upb_Arena* ptr() { return ptr_.get(); }
-
-  // Allows this arena to be used as a generic allocator.
-  //
-  // The arena does not need free() calls so when using Arena as an allocator
-  // it is safe to skip them.  However they are no-ops so there is no harm in
-  // calling free() either.
-  upb_alloc* allocator() { return upb_Arena_Alloc(ptr_.get()); }
-
-  // Add a cleanup function to run when the arena is destroyed.
-  // Returns false on out-of-memory.
-  template <class T>
-  bool Own(T* obj) {
-    return upb_Arena_AddCleanup(ptr_.get(), obj,
-                                [](void* obj) { delete static_cast<T*>(obj); });
-  }
-
-  void Fuse(Arena& other) { upb_Arena_Fuse(ptr(), other.ptr()); }
-
- private:
-  std::unique_ptr<upb_Arena, decltype(&upb_Arena_Free)> ptr_;
-};
-
-// InlinedArena seeds the arenas with a predefined amount of memory.  No
-// heap memory will be allocated until the initial block is exceeded.
-template <int N>
-class InlinedArena : public Arena {
- public:
-  InlinedArena() : Arena(initial_block_, N) {}
-
- private:
-  InlinedArena(const InlinedArena*) = delete;
-  InlinedArena& operator=(const InlinedArena*) = delete;
-
-  char initial_block_[N];
-};
+namespace upb
+{
+
+    class Status
+    {
+    public:
+        Status()
+        {
+            upb_Status_Clear(&status_);
+        }
+
+        upb_Status* ptr()
+        {
+            return &status_;
+        }
+
+        // Returns true if there is no error.
+        bool ok() const
+        {
+            return upb_Status_IsOk(&status_);
+        }
+
+        // Guaranteed to be NULL-terminated.
+        const char* error_message() const
+        {
+            return upb_Status_ErrorMessage(&status_);
+        }
+
+        // The error message will be truncated if it is longer than
+        // _kUpb_Status_MaxMessage-4.
+        void SetErrorMessage(const char* msg)
+        {
+            upb_Status_SetErrorMessage(&status_, msg);
+        }
+        void SetFormattedErrorMessage(const char* fmt, ...)
+        {
+            va_list args;
+            va_start(args, fmt);
+            upb_Status_VSetErrorFormat(&status_, fmt, args);
+            va_end(args);
+        }
+
+        // Resets the status to a successful state with no message.
+        void Clear()
+        {
+            upb_Status_Clear(&status_);
+        }
+
+    private:
+        upb_Status status_;
+    };
+
+    class Arena
+    {
+    public:
+        // A simple arena with no initial memory block and the default allocator.
+        Arena() :
+            ptr_(upb_Arena_New(), upb_Arena_Free)
+        {
+        }
+        Arena(char* initial_block, size_t size) :
+            ptr_(upb_Arena_Init(initial_block, size, &upb_alloc_global), upb_Arena_Free)
+        {
+        }
+
+        upb_Arena* ptr()
+        {
+            return ptr_.get();
+        }
+
+        // Allows this arena to be used as a generic allocator.
+        //
+        // The arena does not need free() calls so when using Arena as an allocator
+        // it is safe to skip them.  However they are no-ops so there is no harm in
+        // calling free() either.
+        upb_alloc* allocator()
+        {
+            return upb_Arena_Alloc(ptr_.get());
+        }
+
+        // Add a cleanup function to run when the arena is destroyed.
+        // Returns false on out-of-memory.
+        template<class T>
+        bool Own(T* obj)
+        {
+            return upb_Arena_AddCleanup(ptr_.get(), obj, [](void* obj)
+                                        { delete static_cast<T*>(obj); });
+        }
+
+        void Fuse(Arena& other)
+        {
+            upb_Arena_Fuse(ptr(), other.ptr());
+        }
+
+    private:
+        std::unique_ptr<upb_Arena, decltype(&upb_Arena_Free)> ptr_;
+    };
+
+    // InlinedArena seeds the arenas with a predefined amount of memory.  No
+    // heap memory will be allocated until the initial block is exceeded.
+    template<int N>
+    class InlinedArena : public Arena
+    {
+    public:
+        InlinedArena() :
+            Arena(initial_block_, N)
+        {
+        }
+
+    private:
+        InlinedArena(const InlinedArena*) = delete;
+        InlinedArena& operator=(const InlinedArena*) = delete;
+
+        char initial_block_[N];
+    };
 
 }  // namespace upb
 
diff --git a/CAPI/cpp/grpc/include/upb/util/compare.h b/CAPI/cpp/grpc/include/upb/util/compare.h
index 92f6d83..d8ec156 100644
--- a/CAPI/cpp/grpc/include/upb/util/compare.h
+++ b/CAPI/cpp/grpc/include/upb/util/compare.h
@@ -31,33 +31,31 @@
 #include "upb/def.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-// Returns true if unknown fields from the two messages are equal when sorted
-// and varints are made canonical.
-//
-// This function is discouraged, as the comparison is inherently lossy without
-// schema data:
-//
-//  1. We don't know whether delimited fields are sub-messages. Unknown
-//     sub-messages will therefore not have their fields sorted and varints
-//     canonicalized.
-//  2. We don't know about oneof/non-repeated fields, which should semantically
-//     discard every value except the last.
+    // Returns true if unknown fields from the two messages are equal when sorted
+    // and varints are made canonical.
+    //
+    // This function is discouraged, as the comparison is inherently lossy without
+    // schema data:
+    //
+    //  1. We don't know whether delimited fields are sub-messages. Unknown
+    //     sub-messages will therefore not have their fields sorted and varints
+    //     canonicalized.
+    //  2. We don't know about oneof/non-repeated fields, which should semantically
+    //     discard every value except the last.
 
-typedef enum {
-  kUpb_UnknownCompareResult_Equal = 0,
-  kUpb_UnknownCompareResult_NotEqual = 1,
-  kUpb_UnknownCompareResult_OutOfMemory = 2,
-  kUpb_UnknownCompareResult_MaxDepthExceeded = 3,
-} upb_UnknownCompareResult;
+    typedef enum
+    {
+        kUpb_UnknownCompareResult_Equal = 0,
+        kUpb_UnknownCompareResult_NotEqual = 1,
+        kUpb_UnknownCompareResult_OutOfMemory = 2,
+        kUpb_UnknownCompareResult_MaxDepthExceeded = 3,
+    } upb_UnknownCompareResult;
 
-upb_UnknownCompareResult upb_Message_UnknownFieldsAreEqual(const char* buf1,
-                                                           size_t size1,
-                                                           const char* buf2,
-                                                           size_t size2,
-                                                           int max_depth);
+    upb_UnknownCompareResult upb_Message_UnknownFieldsAreEqual(const char* buf1, size_t size1, const char* buf2, size_t size2, int max_depth);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/util/def_to_proto.h b/CAPI/cpp/grpc/include/upb/util/def_to_proto.h
index 24f65b9..15cd4e5 100644
--- a/CAPI/cpp/grpc/include/upb/util/def_to_proto.h
+++ b/CAPI/cpp/grpc/include/upb/util/def_to_proto.h
@@ -31,29 +31,32 @@
 #include "upb/def.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-// Functions for converting defs back to the equivalent descriptor proto.
-// Ultimately the goal is that a round-trip proto->def->proto is lossless.  Each
-// function returns a new proto created in arena `a`, or NULL if memory
-// allocation failed.
-google_protobuf_DescriptorProto* upb_MessageDef_ToProto(const upb_MessageDef* m,
-                                                        upb_Arena* a);
-google_protobuf_EnumDescriptorProto* upb_EnumDef_ToProto(const upb_EnumDef* e,
-                                                         upb_Arena* a);
-google_protobuf_EnumValueDescriptorProto* upb_EnumValueDef_ToProto(
-    const upb_EnumValueDef* e, upb_Arena* a);
-google_protobuf_FieldDescriptorProto* upb_FieldDef_ToProto(
-    const upb_FieldDef* f, upb_Arena* a);
-google_protobuf_OneofDescriptorProto* upb_OneofDef_ToProto(
-    const upb_OneofDef* o, upb_Arena* a);
-google_protobuf_FileDescriptorProto* upb_FileDef_ToProto(const upb_FileDef* f,
-                                                         upb_Arena* a);
-google_protobuf_MethodDescriptorProto* upb_MethodDef_ToProto(
-    const upb_MethodDef* m, upb_Arena* a);
-google_protobuf_ServiceDescriptorProto* upb_ServiceDef_ToProto(
-    const upb_ServiceDef* s, upb_Arena* a);
+    // Functions for converting defs back to the equivalent descriptor proto.
+    // Ultimately the goal is that a round-trip proto->def->proto is lossless.  Each
+    // function returns a new proto created in arena `a`, or NULL if memory
+    // allocation failed.
+    google_protobuf_DescriptorProto* upb_MessageDef_ToProto(const upb_MessageDef* m, upb_Arena* a);
+    google_protobuf_EnumDescriptorProto* upb_EnumDef_ToProto(const upb_EnumDef* e, upb_Arena* a);
+    google_protobuf_EnumValueDescriptorProto* upb_EnumValueDef_ToProto(
+        const upb_EnumValueDef* e, upb_Arena* a
+    );
+    google_protobuf_FieldDescriptorProto* upb_FieldDef_ToProto(
+        const upb_FieldDef* f, upb_Arena* a
+    );
+    google_protobuf_OneofDescriptorProto* upb_OneofDef_ToProto(
+        const upb_OneofDef* o, upb_Arena* a
+    );
+    google_protobuf_FileDescriptorProto* upb_FileDef_ToProto(const upb_FileDef* f, upb_Arena* a);
+    google_protobuf_MethodDescriptorProto* upb_MethodDef_ToProto(
+        const upb_MethodDef* m, upb_Arena* a
+    );
+    google_protobuf_ServiceDescriptorProto* upb_ServiceDef_ToProto(
+        const upb_ServiceDef* s, upb_Arena* a
+    );
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/upb/util/required_fields.h b/CAPI/cpp/grpc/include/upb/util/required_fields.h
index 874914b..2d69742 100644
--- a/CAPI/cpp/grpc/include/upb/util/required_fields.h
+++ b/CAPI/cpp/grpc/include/upb/util/required_fields.h
@@ -35,55 +35,55 @@
 #include "upb/port_def.inc"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-// A FieldPath can be encoded as an array of upb_FieldPathEntry, in the
-// following format:
-//    { {.field = f1}, {.field = f2} }                      # f1.f2
-//    { {.field = f1}, {.index = 5}, {.field = f2} }        # f1[5].f2
-//    { {.field = f1}, {.key = "abc"}, {.field = f2} }      # f1["abc"].f2
-//
-// Users must look at the type of `field` to know if an index or map key
-// follows.
-//
-// A field path may be NULL-terminated, in which case a NULL field indicates
-// the end of the field path.
-typedef union {
-  const upb_FieldDef* field;
-  size_t array_index;
-  upb_MessageValue map_key;
-} upb_FieldPathEntry;
+    // A FieldPath can be encoded as an array of upb_FieldPathEntry, in the
+    // following format:
+    //    { {.field = f1}, {.field = f2} }                      # f1.f2
+    //    { {.field = f1}, {.index = 5}, {.field = f2} }        # f1[5].f2
+    //    { {.field = f1}, {.key = "abc"}, {.field = f2} }      # f1["abc"].f2
+    //
+    // Users must look at the type of `field` to know if an index or map key
+    // follows.
+    //
+    // A field path may be NULL-terminated, in which case a NULL field indicates
+    // the end of the field path.
+    typedef union
+    {
+        const upb_FieldDef* field;
+        size_t array_index;
+        upb_MessageValue map_key;
+    } upb_FieldPathEntry;
 
-// Writes a string representing `*path` to `buf` in the following textual
-// format:
-//    foo.bar                    # Regular fields
-//    repeated_baz[2].bar        # Repeated field
-//    int32_msg_map[5].bar       # Integer-keyed map
-//    string_msg_map["abc"]      # String-keyed map
-//    bool_msg_map[true]         # Bool-keyed map
-//
-// The input array `*path` must be NULL-terminated.  The pointer `*path` will be
-// updated to point to one past the terminating NULL pointer of the input array.
-//
-// The output buffer `buf` will always be NULL-terminated. If the output data
-// (including NULL terminator) exceeds `size`, the result will be truncated.
-// Returns the string length of the data we attempted to write, excluding the
-// terminating NULL.
-size_t upb_FieldPath_ToText(upb_FieldPathEntry** path, char* buf, size_t size);
+    // Writes a string representing `*path` to `buf` in the following textual
+    // format:
+    //    foo.bar                    # Regular fields
+    //    repeated_baz[2].bar        # Repeated field
+    //    int32_msg_map[5].bar       # Integer-keyed map
+    //    string_msg_map["abc"]      # String-keyed map
+    //    bool_msg_map[true]         # Bool-keyed map
+    //
+    // The input array `*path` must be NULL-terminated.  The pointer `*path` will be
+    // updated to point to one past the terminating NULL pointer of the input array.
+    //
+    // The output buffer `buf` will always be NULL-terminated. If the output data
+    // (including NULL terminator) exceeds `size`, the result will be truncated.
+    // Returns the string length of the data we attempted to write, excluding the
+    // terminating NULL.
+    size_t upb_FieldPath_ToText(upb_FieldPathEntry** path, char* buf, size_t size);
 
-// Checks whether `msg` or any of its children has unset required fields,
-// returning `true` if any are found.  `msg` may be NULL, in which case the
-// message will be treated as empty.
-//
-// When this function returns true, `fields` is updated (if non-NULL) to point
-// to a heap-allocated array encoding the field paths of the required fields
-// that are missing.  Each path is terminated with {.field = NULL}, and a final
-// {.field = NULL} terminates the list of paths.  The caller is responsible for
-// freeing this array.
-bool upb_util_HasUnsetRequired(const upb_Message* msg, const upb_MessageDef* m,
-                               const upb_DefPool* ext_pool,
-                               upb_FieldPathEntry** fields);
+    // Checks whether `msg` or any of its children has unset required fields,
+    // returning `true` if any are found.  `msg` may be NULL, in which case the
+    // message will be treated as empty.
+    //
+    // When this function returns true, `fields` is updated (if non-NULL) to point
+    // to a heap-allocated array encoding the field paths of the required fields
+    // that are missing.  Each path is terminated with {.field = NULL}, and a final
+    // {.field = NULL} terminates the list of paths.  The caller is responsible for
+    // freeing this array.
+    bool upb_util_HasUnsetRequired(const upb_Message* msg, const upb_MessageDef* m, const upb_DefPool* ext_pool, upb_FieldPathEntry** fields);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/CAPI/cpp/grpc/include/zconf.h b/CAPI/cpp/grpc/include/zconf.h
index 2536736..c374878 100644
--- a/CAPI/cpp/grpc/include/zconf.h
+++ b/CAPI/cpp/grpc/include/zconf.h
@@ -16,177 +16,177 @@
  * Even better than compiling with -DZ_PREFIX would be to use configure to set
  * this permanently in zconf.h using "./configure --zprefix".
  */
-#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
-#  define Z_PREFIX_SET
+#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
+#define Z_PREFIX_SET
 
 /* all linked symbols and init macros */
-#  define _dist_code            z__dist_code
-#  define _length_code          z__length_code
-#  define _tr_align             z__tr_align
-#  define _tr_flush_bits        z__tr_flush_bits
-#  define _tr_flush_block       z__tr_flush_block
-#  define _tr_init              z__tr_init
-#  define _tr_stored_block      z__tr_stored_block
-#  define _tr_tally             z__tr_tally
-#  define adler32               z_adler32
-#  define adler32_combine       z_adler32_combine
-#  define adler32_combine64     z_adler32_combine64
-#  define adler32_z             z_adler32_z
-#  ifndef Z_SOLO
-#    define compress              z_compress
-#    define compress2             z_compress2
-#    define compressBound         z_compressBound
-#  endif
-#  define crc32                 z_crc32
-#  define crc32_combine         z_crc32_combine
-#  define crc32_combine64       z_crc32_combine64
-#  define crc32_z               z_crc32_z
-#  define deflate               z_deflate
-#  define deflateBound          z_deflateBound
-#  define deflateCopy           z_deflateCopy
-#  define deflateEnd            z_deflateEnd
-#  define deflateGetDictionary  z_deflateGetDictionary
-#  define deflateInit           z_deflateInit
-#  define deflateInit2          z_deflateInit2
-#  define deflateInit2_         z_deflateInit2_
-#  define deflateInit_          z_deflateInit_
-#  define deflateParams         z_deflateParams
-#  define deflatePending        z_deflatePending
-#  define deflatePrime          z_deflatePrime
-#  define deflateReset          z_deflateReset
-#  define deflateResetKeep      z_deflateResetKeep
-#  define deflateSetDictionary  z_deflateSetDictionary
-#  define deflateSetHeader      z_deflateSetHeader
-#  define deflateTune           z_deflateTune
-#  define deflate_copyright     z_deflate_copyright
-#  define get_crc_table         z_get_crc_table
-#  ifndef Z_SOLO
-#    define gz_error              z_gz_error
-#    define gz_intmax             z_gz_intmax
-#    define gz_strwinerror        z_gz_strwinerror
-#    define gzbuffer              z_gzbuffer
-#    define gzclearerr            z_gzclearerr
-#    define gzclose               z_gzclose
-#    define gzclose_r             z_gzclose_r
-#    define gzclose_w             z_gzclose_w
-#    define gzdirect              z_gzdirect
-#    define gzdopen               z_gzdopen
-#    define gzeof                 z_gzeof
-#    define gzerror               z_gzerror
-#    define gzflush               z_gzflush
-#    define gzfread               z_gzfread
-#    define gzfwrite              z_gzfwrite
-#    define gzgetc                z_gzgetc
-#    define gzgetc_               z_gzgetc_
-#    define gzgets                z_gzgets
-#    define gzoffset              z_gzoffset
-#    define gzoffset64            z_gzoffset64
-#    define gzopen                z_gzopen
-#    define gzopen64              z_gzopen64
-#    ifdef _WIN32
-#      define gzopen_w              z_gzopen_w
-#    endif
-#    define gzprintf              z_gzprintf
-#    define gzputc                z_gzputc
-#    define gzputs                z_gzputs
-#    define gzread                z_gzread
-#    define gzrewind              z_gzrewind
-#    define gzseek                z_gzseek
-#    define gzseek64              z_gzseek64
-#    define gzsetparams           z_gzsetparams
-#    define gztell                z_gztell
-#    define gztell64              z_gztell64
-#    define gzungetc              z_gzungetc
-#    define gzvprintf             z_gzvprintf
-#    define gzwrite               z_gzwrite
-#  endif
-#  define inflate               z_inflate
-#  define inflateBack           z_inflateBack
-#  define inflateBackEnd        z_inflateBackEnd
-#  define inflateBackInit       z_inflateBackInit
-#  define inflateBackInit_      z_inflateBackInit_
-#  define inflateCodesUsed      z_inflateCodesUsed
-#  define inflateCopy           z_inflateCopy
-#  define inflateEnd            z_inflateEnd
-#  define inflateGetDictionary  z_inflateGetDictionary
-#  define inflateGetHeader      z_inflateGetHeader
-#  define inflateInit           z_inflateInit
-#  define inflateInit2          z_inflateInit2
-#  define inflateInit2_         z_inflateInit2_
-#  define inflateInit_          z_inflateInit_
-#  define inflateMark           z_inflateMark
-#  define inflatePrime          z_inflatePrime
-#  define inflateReset          z_inflateReset
-#  define inflateReset2         z_inflateReset2
-#  define inflateResetKeep      z_inflateResetKeep
-#  define inflateSetDictionary  z_inflateSetDictionary
-#  define inflateSync           z_inflateSync
-#  define inflateSyncPoint      z_inflateSyncPoint
-#  define inflateUndermine      z_inflateUndermine
-#  define inflateValidate       z_inflateValidate
-#  define inflate_copyright     z_inflate_copyright
-#  define inflate_fast          z_inflate_fast
-#  define inflate_table         z_inflate_table
-#  ifndef Z_SOLO
-#    define uncompress            z_uncompress
-#    define uncompress2           z_uncompress2
-#  endif
-#  define zError                z_zError
-#  ifndef Z_SOLO
-#    define zcalloc               z_zcalloc
-#    define zcfree                z_zcfree
-#  endif
-#  define zlibCompileFlags      z_zlibCompileFlags
-#  define zlibVersion           z_zlibVersion
+#define _dist_code z__dist_code
+#define _length_code z__length_code
+#define _tr_align z__tr_align
+#define _tr_flush_bits z__tr_flush_bits
+#define _tr_flush_block z__tr_flush_block
+#define _tr_init z__tr_init
+#define _tr_stored_block z__tr_stored_block
+#define _tr_tally z__tr_tally
+#define adler32 z_adler32
+#define adler32_combine z_adler32_combine
+#define adler32_combine64 z_adler32_combine64
+#define adler32_z z_adler32_z
+#ifndef Z_SOLO
+#define compress z_compress
+#define compress2 z_compress2
+#define compressBound z_compressBound
+#endif
+#define crc32 z_crc32
+#define crc32_combine z_crc32_combine
+#define crc32_combine64 z_crc32_combine64
+#define crc32_z z_crc32_z
+#define deflate z_deflate
+#define deflateBound z_deflateBound
+#define deflateCopy z_deflateCopy
+#define deflateEnd z_deflateEnd
+#define deflateGetDictionary z_deflateGetDictionary
+#define deflateInit z_deflateInit
+#define deflateInit2 z_deflateInit2
+#define deflateInit2_ z_deflateInit2_
+#define deflateInit_ z_deflateInit_
+#define deflateParams z_deflateParams
+#define deflatePending z_deflatePending
+#define deflatePrime z_deflatePrime
+#define deflateReset z_deflateReset
+#define deflateResetKeep z_deflateResetKeep
+#define deflateSetDictionary z_deflateSetDictionary
+#define deflateSetHeader z_deflateSetHeader
+#define deflateTune z_deflateTune
+#define deflate_copyright z_deflate_copyright
+#define get_crc_table z_get_crc_table
+#ifndef Z_SOLO
+#define gz_error z_gz_error
+#define gz_intmax z_gz_intmax
+#define gz_strwinerror z_gz_strwinerror
+#define gzbuffer z_gzbuffer
+#define gzclearerr z_gzclearerr
+#define gzclose z_gzclose
+#define gzclose_r z_gzclose_r
+#define gzclose_w z_gzclose_w
+#define gzdirect z_gzdirect
+#define gzdopen z_gzdopen
+#define gzeof z_gzeof
+#define gzerror z_gzerror
+#define gzflush z_gzflush
+#define gzfread z_gzfread
+#define gzfwrite z_gzfwrite
+#define gzgetc z_gzgetc
+#define gzgetc_ z_gzgetc_
+#define gzgets z_gzgets
+#define gzoffset z_gzoffset
+#define gzoffset64 z_gzoffset64
+#define gzopen z_gzopen
+#define gzopen64 z_gzopen64
+#ifdef _WIN32
+#define gzopen_w z_gzopen_w
+#endif
+#define gzprintf z_gzprintf
+#define gzputc z_gzputc
+#define gzputs z_gzputs
+#define gzread z_gzread
+#define gzrewind z_gzrewind
+#define gzseek z_gzseek
+#define gzseek64 z_gzseek64
+#define gzsetparams z_gzsetparams
+#define gztell z_gztell
+#define gztell64 z_gztell64
+#define gzungetc z_gzungetc
+#define gzvprintf z_gzvprintf
+#define gzwrite z_gzwrite
+#endif
+#define inflate z_inflate
+#define inflateBack z_inflateBack
+#define inflateBackEnd z_inflateBackEnd
+#define inflateBackInit z_inflateBackInit
+#define inflateBackInit_ z_inflateBackInit_
+#define inflateCodesUsed z_inflateCodesUsed
+#define inflateCopy z_inflateCopy
+#define inflateEnd z_inflateEnd
+#define inflateGetDictionary z_inflateGetDictionary
+#define inflateGetHeader z_inflateGetHeader
+#define inflateInit z_inflateInit
+#define inflateInit2 z_inflateInit2
+#define inflateInit2_ z_inflateInit2_
+#define inflateInit_ z_inflateInit_
+#define inflateMark z_inflateMark
+#define inflatePrime z_inflatePrime
+#define inflateReset z_inflateReset
+#define inflateReset2 z_inflateReset2
+#define inflateResetKeep z_inflateResetKeep
+#define inflateSetDictionary z_inflateSetDictionary
+#define inflateSync z_inflateSync
+#define inflateSyncPoint z_inflateSyncPoint
+#define inflateUndermine z_inflateUndermine
+#define inflateValidate z_inflateValidate
+#define inflate_copyright z_inflate_copyright
+#define inflate_fast z_inflate_fast
+#define inflate_table z_inflate_table
+#ifndef Z_SOLO
+#define uncompress z_uncompress
+#define uncompress2 z_uncompress2
+#endif
+#define zError z_zError
+#ifndef Z_SOLO
+#define zcalloc z_zcalloc
+#define zcfree z_zcfree
+#endif
+#define zlibCompileFlags z_zlibCompileFlags
+#define zlibVersion z_zlibVersion
 
 /* all zlib typedefs in zlib.h and zconf.h */
-#  define Byte                  z_Byte
-#  define Bytef                 z_Bytef
-#  define alloc_func            z_alloc_func
-#  define charf                 z_charf
-#  define free_func             z_free_func
-#  ifndef Z_SOLO
-#    define gzFile                z_gzFile
-#  endif
-#  define gz_header             z_gz_header
-#  define gz_headerp            z_gz_headerp
-#  define in_func               z_in_func
-#  define intf                  z_intf
-#  define out_func              z_out_func
-#  define uInt                  z_uInt
-#  define uIntf                 z_uIntf
-#  define uLong                 z_uLong
-#  define uLongf                z_uLongf
-#  define voidp                 z_voidp
-#  define voidpc                z_voidpc
-#  define voidpf                z_voidpf
+#define Byte z_Byte
+#define Bytef z_Bytef
+#define alloc_func z_alloc_func
+#define charf z_charf
+#define free_func z_free_func
+#ifndef Z_SOLO
+#define gzFile z_gzFile
+#endif
+#define gz_header z_gz_header
+#define gz_headerp z_gz_headerp
+#define in_func z_in_func
+#define intf z_intf
+#define out_func z_out_func
+#define uInt z_uInt
+#define uIntf z_uIntf
+#define uLong z_uLong
+#define uLongf z_uLongf
+#define voidp z_voidp
+#define voidpc z_voidpc
+#define voidpf z_voidpf
 
 /* all zlib structs in zlib.h and zconf.h */
-#  define gz_header_s           z_gz_header_s
-#  define internal_state        z_internal_state
+#define gz_header_s z_gz_header_s
+#define internal_state z_internal_state
 
 #endif
 
 #if defined(__MSDOS__) && !defined(MSDOS)
-#  define MSDOS
+#define MSDOS
 #endif
 #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
-#  define OS2
+#define OS2
 #endif
 #if defined(_WINDOWS) && !defined(WINDOWS)
-#  define WINDOWS
+#define WINDOWS
 #endif
 #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
-#  ifndef WIN32
-#    define WIN32
-#  endif
+#ifndef WIN32
+#define WIN32
+#endif
 #endif
 #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
-#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
-#    ifndef SYS16BIT
-#      define SYS16BIT
-#    endif
-#  endif
+#if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#ifndef SYS16BIT
+#define SYS16BIT
+#endif
+#endif
 #endif
 
 /*
@@ -194,73 +194,73 @@
  * than 64k bytes at a time (needed on systems with 16-bit int).
  */
 #ifdef SYS16BIT
-#  define MAXSEG_64K
+#define MAXSEG_64K
 #endif
 #ifdef MSDOS
-#  define UNALIGNED_OK
+#define UNALIGNED_OK
 #endif
 
 #ifdef __STDC_VERSION__
-#  ifndef STDC
-#    define STDC
-#  endif
-#  if __STDC_VERSION__ >= 199901L
-#    ifndef STDC99
-#      define STDC99
-#    endif
-#  endif
+#ifndef STDC
+#define STDC
+#endif
+#if __STDC_VERSION__ >= 199901L
+#ifndef STDC99
+#define STDC99
+#endif
+#endif
 #endif
 #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
-#  define STDC
+#define STDC
 #endif
 #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
-#  define STDC
+#define STDC
 #endif
 #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
-#  define STDC
+#define STDC
 #endif
 #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
-#  define STDC
+#define STDC
 #endif
 
-#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
-#  define STDC
+#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */
+#define STDC
 #endif
 
 #ifndef STDC
-#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
-#    define const       /* note: need a more gentle solution here */
-#  endif
+#ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#define const /* note: need a more gentle solution here */
+#endif
 #endif
 
 #if defined(ZLIB_CONST) && !defined(z_const)
-#  define z_const const
+#define z_const const
 #else
-#  define z_const
+#define z_const
 #endif
 
 #ifdef Z_SOLO
-   typedef unsigned long z_size_t;
+typedef unsigned long z_size_t;
+#else
+#define z_longlong long long
+#if defined(NO_SIZE_T)
+typedef unsigned NO_SIZE_T z_size_t;
+#elif defined(STDC)
+#include <stddef.h>
+typedef size_t z_size_t;
 #else
-#  define z_longlong long long
-#  if defined(NO_SIZE_T)
-     typedef unsigned NO_SIZE_T z_size_t;
-#  elif defined(STDC)
-#    include <stddef.h>
-     typedef size_t z_size_t;
-#  else
-     typedef unsigned long z_size_t;
-#  endif
-#  undef z_longlong
+typedef unsigned long z_size_t;
+#endif
+#undef z_longlong
 #endif
 
 /* Maximum value for memLevel in deflateInit2 */
 #ifndef MAX_MEM_LEVEL
-#  ifdef MAXSEG_64K
-#    define MAX_MEM_LEVEL 8
-#  else
-#    define MAX_MEM_LEVEL 9
-#  endif
+#ifdef MAXSEG_64K
+#define MAX_MEM_LEVEL 8
+#else
+#define MAX_MEM_LEVEL 9
+#endif
 #endif
 
 /* Maximum value for windowBits in deflateInit2 and inflateInit2.
@@ -269,7 +269,7 @@
  * gzip.)
  */
 #ifndef MAX_WBITS
-#  define MAX_WBITS   15 /* 32K LZ77 window */
+#define MAX_WBITS 15 /* 32K LZ77 window */
 #endif
 
 /* The memory requirements for deflate are (in bytes):
@@ -285,22 +285,22 @@
  for small objects.
 */
 
-                        /* Type declarations */
+/* Type declarations */
 
 #ifndef OF /* function prototypes */
-#  ifdef STDC
-#    define OF(args)  args
-#  else
-#    define OF(args)  ()
-#  endif
+#ifdef STDC
+#define OF(args) args
+#else
+#define OF(args) ()
+#endif
 #endif
 
 #ifndef Z_ARG /* function prototypes for stdarg */
-#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#    define Z_ARG(args)  args
-#  else
-#    define Z_ARG(args)  ()
-#  endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#define Z_ARG(args) args
+#else
+#define Z_ARG(args) ()
+#endif
 #endif
 
 /* The following definitions for FAR are needed only for MSDOS mixed
@@ -310,161 +310,161 @@
  * just define FAR to be empty.
  */
 #ifdef SYS16BIT
-#  if defined(M_I86SM) || defined(M_I86MM)
-     /* MSC small or medium model */
-#    define SMALL_MEDIUM
-#    ifdef _MSC_VER
-#      define FAR _far
-#    else
-#      define FAR far
-#    endif
-#  endif
-#  if (defined(__SMALL__) || defined(__MEDIUM__))
-     /* Turbo C small or medium model */
-#    define SMALL_MEDIUM
-#    ifdef __BORLANDC__
-#      define FAR _far
-#    else
-#      define FAR far
-#    endif
-#  endif
+#if defined(M_I86SM) || defined(M_I86MM)
+/* MSC small or medium model */
+#define SMALL_MEDIUM
+#ifdef _MSC_VER
+#define FAR _far
+#else
+#define FAR far
+#endif
+#endif
+#if (defined(__SMALL__) || defined(__MEDIUM__))
+/* Turbo C small or medium model */
+#define SMALL_MEDIUM
+#ifdef __BORLANDC__
+#define FAR _far
+#else
+#define FAR far
+#endif
+#endif
 #endif
 
 #if defined(WINDOWS) || defined(WIN32)
-   /* If building or using zlib as a DLL, define ZLIB_DLL.
-    * This is not mandatory, but it offers a little performance increase.
-    */
-#  ifdef ZLIB_DLL
-#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
-#      ifdef ZLIB_INTERNAL
-#        define ZEXTERN extern __declspec(dllexport)
-#      else
-#        define ZEXTERN extern __declspec(dllimport)
-#      endif
-#    endif
-#  endif  /* ZLIB_DLL */
-   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
-    * define ZLIB_WINAPI.
-    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
-    */
-#  ifdef ZLIB_WINAPI
-#    ifdef FAR
-#      undef FAR
-#    endif
-#    include <windows.h>
-     /* No need for _export, use ZLIB.DEF instead. */
-     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
-#    define ZEXPORT WINAPI
-#    ifdef WIN32
-#      define ZEXPORTVA WINAPIV
-#    else
-#      define ZEXPORTVA FAR CDECL
-#    endif
-#  endif
-#endif
-
-#if defined (__BEOS__)
-#  ifdef ZLIB_DLL
-#    ifdef ZLIB_INTERNAL
-#      define ZEXPORT   __declspec(dllexport)
-#      define ZEXPORTVA __declspec(dllexport)
-#    else
-#      define ZEXPORT   __declspec(dllimport)
-#      define ZEXPORTVA __declspec(dllimport)
-#    endif
-#  endif
+/* If building or using zlib as a DLL, define ZLIB_DLL.
+ * This is not mandatory, but it offers a little performance increase.
+ */
+#ifdef ZLIB_DLL
+#if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#ifdef ZLIB_INTERNAL
+#define ZEXTERN extern __declspec(dllexport)
+#else
+#define ZEXTERN extern __declspec(dllimport)
+#endif
+#endif
+#endif /* ZLIB_DLL */
+       /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+        * define ZLIB_WINAPI.
+        * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+        */
+#ifdef ZLIB_WINAPI
+#ifdef FAR
+#undef FAR
+#endif
+#include <windows.h>
+/* No need for _export, use ZLIB.DEF instead. */
+/* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#define ZEXPORT WINAPI
+#ifdef WIN32
+#define ZEXPORTVA WINAPIV
+#else
+#define ZEXPORTVA FAR CDECL
+#endif
+#endif
+#endif
+
+#if defined(__BEOS__)
+#ifdef ZLIB_DLL
+#ifdef ZLIB_INTERNAL
+#define ZEXPORT __declspec(dllexport)
+#define ZEXPORTVA __declspec(dllexport)
+#else
+#define ZEXPORT __declspec(dllimport)
+#define ZEXPORTVA __declspec(dllimport)
+#endif
+#endif
 #endif
 
 #ifndef ZEXTERN
-#  define ZEXTERN extern
+#define ZEXTERN extern
 #endif
 #ifndef ZEXPORT
-#  define ZEXPORT
+#define ZEXPORT
 #endif
 #ifndef ZEXPORTVA
-#  define ZEXPORTVA
+#define ZEXPORTVA
 #endif
 
 #ifndef FAR
-#  define FAR
+#define FAR
 #endif
 
 #if !defined(__MACTYPES__)
-typedef unsigned char  Byte;  /* 8 bits */
+typedef unsigned char Byte; /* 8 bits */
 #endif
-typedef unsigned int   uInt;  /* 16 bits or more */
-typedef unsigned long  uLong; /* 32 bits or more */
+typedef unsigned int uInt;   /* 16 bits or more */
+typedef unsigned long uLong; /* 32 bits or more */
 
 #ifdef SMALL_MEDIUM
-   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
-#  define Bytef Byte FAR
+/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#define Bytef Byte FAR
 #else
-   typedef Byte  FAR Bytef;
+typedef Byte FAR Bytef;
 #endif
-typedef char  FAR charf;
-typedef int   FAR intf;
-typedef uInt  FAR uIntf;
+typedef char FAR charf;
+typedef int FAR intf;
+typedef uInt FAR uIntf;
 typedef uLong FAR uLongf;
 
 #ifdef STDC
-   typedef void const *voidpc;
-   typedef void FAR   *voidpf;
-   typedef void       *voidp;
+typedef void const* voidpc;
+typedef void FAR* voidpf;
+typedef void* voidp;
 #else
-   typedef Byte const *voidpc;
-   typedef Byte FAR   *voidpf;
-   typedef Byte       *voidp;
+typedef Byte const* voidpc;
+typedef Byte FAR* voidpf;
+typedef Byte* voidp;
 #endif
 
 #if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
-#  include <limits.h>
-#  if (UINT_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned
-#  elif (ULONG_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned long
-#  elif (USHRT_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned short
-#  endif
+#include <limits.h>
+#if (UINT_MAX == 0xffffffffUL)
+#define Z_U4 unsigned
+#elif (ULONG_MAX == 0xffffffffUL)
+#define Z_U4 unsigned long
+#elif (USHRT_MAX == 0xffffffffUL)
+#define Z_U4 unsigned short
+#endif
 #endif
 
 #ifdef Z_U4
-   typedef Z_U4 z_crc_t;
+typedef Z_U4 z_crc_t;
 #else
-   typedef unsigned long z_crc_t;
+typedef unsigned long z_crc_t;
 #endif
 
-#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
-#  if ~(~HAVE_UNISTD_H + 0) == 0 && ~(~HAVE_UNISTD_H + 1) == 1
-#    define Z_HAVE_UNISTD_H
-#  elif HAVE_UNISTD_H != 0
-#    define Z_HAVE_UNISTD_H
-#  endif
+#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */
+#if ~(~HAVE_UNISTD_H + 0) == 0 && ~(~HAVE_UNISTD_H + 1) == 1
+#define Z_HAVE_UNISTD_H
+#elif HAVE_UNISTD_H != 0
+#define Z_HAVE_UNISTD_H
+#endif
 #endif
 
-#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
-#  if ~(~HAVE_STDARG_H + 0) == 0 && ~(~HAVE_STDARG_H + 1) == 1
-#    define Z_HAVE_STDARG_H
-#  elif HAVE_STDARG_H != 0
-#    define Z_HAVE_STDARG_H
-#  endif
+#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */
+#if ~(~HAVE_STDARG_H + 0) == 0 && ~(~HAVE_STDARG_H + 1) == 1
+#define Z_HAVE_STDARG_H
+#elif HAVE_STDARG_H != 0
+#define Z_HAVE_STDARG_H
+#endif
 #endif
 
 #ifdef STDC
-#  ifndef Z_SOLO
-#    include <sys/types.h>      /* for off_t */
-#  endif
+#ifndef Z_SOLO
+#include <sys/types.h> /* for off_t */
+#endif
 #endif
 
 #if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#  ifndef Z_SOLO
-#    include <stdarg.h>         /* for va_list */
-#  endif
+#ifndef Z_SOLO
+#include <stdarg.h> /* for va_list */
+#endif
 #endif
 
 #ifdef _WIN32
-#  ifndef Z_SOLO
-#    include <stddef.h>         /* for wchar_t */
-#  endif
+#ifndef Z_SOLO
+#include <stddef.h> /* for wchar_t */
+#endif
 #endif
 
 /* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
@@ -474,71 +474,71 @@ typedef uLong FAR uLongf;
  * equivalently requesting no 64-bit operations
  */
 #if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
-#  undef _LARGEFILE64_SOURCE
+#undef _LARGEFILE64_SOURCE
 #endif
 
 #if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
-#  define Z_HAVE_UNISTD_H
+#define Z_HAVE_UNISTD_H
 #endif
 #ifndef Z_SOLO
-#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
-#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
-#    ifdef VMS
-#      include <unixio.h>       /* for off_t */
-#    endif
-#    ifndef z_off_t
-#      define z_off_t off_t
-#    endif
-#  endif
+#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#ifdef VMS
+#include <unixio.h> /* for off_t */
+#endif
+#ifndef z_off_t
+#define z_off_t off_t
+#endif
+#endif
 #endif
 
-#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
-#  define Z_LFS64
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE - 0
+#define Z_LFS64
 #endif
 
 #if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
-#  define Z_LARGE64
+#define Z_LARGE64
 #endif
 
-#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
-#  define Z_WANT64
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS - 0 == 64 && defined(Z_LFS64)
+#define Z_WANT64
 #endif
 
 #if !defined(SEEK_SET) && !defined(Z_SOLO)
-#  define SEEK_SET        0       /* Seek from beginning of file.  */
-#  define SEEK_CUR        1       /* Seek from current position.  */
-#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#define SEEK_SET 0 /* Seek from beginning of file.  */
+#define SEEK_CUR 1 /* Seek from current position.  */
+#define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
 #endif
 
 #ifndef z_off_t
-#  define z_off_t long
+#define z_off_t long
 #endif
 
 #if !defined(_WIN32) && defined(Z_LARGE64)
-#  define z_off64_t off64_t
+#define z_off64_t off64_t
+#else
+#if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#define z_off64_t __int64
 #else
-#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
-#    define z_off64_t __int64
-#  else
-#    define z_off64_t z_off_t
-#  endif
+#define z_off64_t z_off_t
+#endif
 #endif
 
 /* MVS linker does not support external names larger than 8 bytes */
 #if defined(__MVS__)
-  #pragma map(deflateInit_,"DEIN")
-  #pragma map(deflateInit2_,"DEIN2")
-  #pragma map(deflateEnd,"DEEND")
-  #pragma map(deflateBound,"DEBND")
-  #pragma map(inflateInit_,"ININ")
-  #pragma map(inflateInit2_,"ININ2")
-  #pragma map(inflateEnd,"INEND")
-  #pragma map(inflateSync,"INSY")
-  #pragma map(inflateSetDictionary,"INSEDI")
-  #pragma map(compressBound,"CMBND")
-  #pragma map(inflate_table,"INTABL")
-  #pragma map(inflate_fast,"INFA")
-  #pragma map(inflate_copyright,"INCOPY")
+#pragma map(deflateInit_, "DEIN")
+#pragma map(deflateInit2_, "DEIN2")
+#pragma map(deflateEnd, "DEEND")
+#pragma map(deflateBound, "DEBND")
+#pragma map(inflateInit_, "ININ")
+#pragma map(inflateInit2_, "ININ2")
+#pragma map(inflateEnd, "INEND")
+#pragma map(inflateSync, "INSY")
+#pragma map(inflateSetDictionary, "INSEDI")
+#pragma map(compressBound, "CMBND")
+#pragma map(inflate_table, "INTABL")
+#pragma map(inflate_fast, "INFA")
+#pragma map(inflate_copyright, "INCOPY")
 #endif
 
 #endif /* ZCONF_H */
diff --git a/CAPI/cpp/grpc/include/zlib.h b/CAPI/cpp/grpc/include/zlib.h
index 4a98e38..16a26f5 100644
--- a/CAPI/cpp/grpc/include/zlib.h
+++ b/CAPI/cpp/grpc/include/zlib.h
@@ -34,7 +34,8 @@
 #include "zconf.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #define ZLIB_VERSION "1.2.12"
@@ -44,1806 +45,1748 @@ extern "C" {
 #define ZLIB_VER_REVISION 12
 #define ZLIB_VER_SUBREVISION 0
 
-/*
-    The 'zlib' compression library provides in-memory compression and
-  decompression functions, including integrity checks of the uncompressed data.
-  This version of the library supports only one compression method (deflation)
-  but other algorithms will be added later and will have the same stream
-  interface.
-
-    Compression can be done in a single step if the buffers are large enough,
-  or can be done by repeated calls of the compression function.  In the latter
-  case, the application must provide more input and/or consume the output
-  (providing more output space) before each call.
-
-    The compressed data format used by default by the in-memory functions is
-  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
-  around a deflate stream, which is itself documented in RFC 1951.
-
-    The library also supports reading and writing files in gzip (.gz) format
-  with an interface similar to that of stdio using the functions that start
-  with "gz".  The gzip format is different from the zlib format.  gzip is a
-  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
-
-    This library can optionally read and write gzip and raw deflate streams in
-  memory as well.
-
-    The zlib format was designed to be compact and fast for use in memory
-  and on communications channels.  The gzip format was designed for single-
-  file compression on file systems, has a larger header than zlib to maintain
-  directory information, and uses a different, slower check method than zlib.
-
-    The library does not install any signal handler.  The decoder checks
-  the consistency of the compressed data, so the library should never crash
-  even in the case of corrupted input.
-*/
+    /*
+        The 'zlib' compression library provides in-memory compression and
+      decompression functions, including integrity checks of the uncompressed data.
+      This version of the library supports only one compression method (deflation)
+      but other algorithms will be added later and will have the same stream
+      interface.
 
-typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
-typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+        Compression can be done in a single step if the buffers are large enough,
+      or can be done by repeated calls of the compression function.  In the latter
+      case, the application must provide more input and/or consume the output
+      (providing more output space) before each call.
 
-struct internal_state;
+        The compressed data format used by default by the in-memory functions is
+      the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+      around a deflate stream, which is itself documented in RFC 1951.
 
-typedef struct z_stream_s {
-    z_const Bytef *next_in;     /* next input byte */
-    uInt     avail_in;  /* number of bytes available at next_in */
-    uLong    total_in;  /* total number of input bytes read so far */
+        The library also supports reading and writing files in gzip (.gz) format
+      with an interface similar to that of stdio using the functions that start
+      with "gz".  The gzip format is different from the zlib format.  gzip is a
+      gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
 
-    Bytef    *next_out; /* next output byte will go here */
-    uInt     avail_out; /* remaining free space at next_out */
-    uLong    total_out; /* total number of bytes output so far */
+        This library can optionally read and write gzip and raw deflate streams in
+      memory as well.
 
-    z_const char *msg;  /* last error message, NULL if no error */
-    struct internal_state FAR *state; /* not visible by applications */
+        The zlib format was designed to be compact and fast for use in memory
+      and on communications channels.  The gzip format was designed for single-
+      file compression on file systems, has a larger header than zlib to maintain
+      directory information, and uses a different, slower check method than zlib.
 
-    alloc_func zalloc;  /* used to allocate the internal state */
-    free_func  zfree;   /* used to free the internal state */
-    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+        The library does not install any signal handler.  The decoder checks
+      the consistency of the compressed data, so the library should never crash
+      even in the case of corrupted input.
+    */
 
-    int     data_type;  /* best guess about the data type: binary or text
-                           for deflate, or the decoding state for inflate */
-    uLong   adler;      /* Adler-32 or CRC-32 value of the uncompressed data */
-    uLong   reserved;   /* reserved for future use */
-} z_stream;
+    typedef voidpf(*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+    typedef void(*free_func) OF((voidpf opaque, voidpf address));
 
-typedef z_stream FAR *z_streamp;
+    struct internal_state;
 
-/*
-     gzip header information passed to and from zlib routines.  See RFC 1952
-  for more details on the meanings of these fields.
-*/
-typedef struct gz_header_s {
-    int     text;       /* true if compressed data believed to be text */
-    uLong   time;       /* modification time */
-    int     xflags;     /* extra flags (not used when writing a gzip file) */
-    int     os;         /* operating system */
-    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
-    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
-    uInt    extra_max;  /* space at extra (only when reading header) */
-    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
-    uInt    name_max;   /* space at name (only when reading header) */
-    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
-    uInt    comm_max;   /* space at comment (only when reading header) */
-    int     hcrc;       /* true if there was or will be a header crc */
-    int     done;       /* true when done reading gzip header (not used
-                           when writing a gzip file) */
-} gz_header;
-
-typedef gz_header FAR *gz_headerp;
-
-/*
-     The application must update next_in and avail_in when avail_in has dropped
-   to zero.  It must update next_out and avail_out when avail_out has dropped
-   to zero.  The application must initialize zalloc, zfree and opaque before
-   calling the init function.  All other fields are set by the compression
-   library and must not be updated by the application.
-
-     The opaque value provided by the application will be passed as the first
-   parameter for calls of zalloc and zfree.  This can be useful for custom
-   memory management.  The compression library attaches no meaning to the
-   opaque value.
-
-     zalloc must return Z_NULL if there is not enough memory for the object.
-   If zlib is used in a multi-threaded application, zalloc and zfree must be
-   thread safe.  In that case, zlib is thread-safe.  When zalloc and zfree are
-   Z_NULL on entry to the initialization function, they are set to internal
-   routines that use the standard library functions malloc() and free().
-
-     On 16-bit systems, the functions zalloc and zfree must be able to allocate
-   exactly 65536 bytes, but will not be required to allocate more than this if
-   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
-   returned by zalloc for objects of exactly 65536 bytes *must* have their
-   offset normalized to zero.  The default allocation function provided by this
-   library ensures this (see zutil.c).  To reduce memory requirements and avoid
-   any allocation of 64K objects, at the expense of compression ratio, compile
-   the library with -DMAX_WBITS=14 (see zconf.h).
-
-     The fields total_in and total_out can be used for statistics or progress
-   reports.  After compression, total_in holds the total size of the
-   uncompressed data and may be saved for use by the decompressor (particularly
-   if the decompressor wants to decompress everything in a single step).
-*/
+    typedef struct z_stream_s
+    {
+        z_const Bytef* next_in; /* next input byte */
+        uInt avail_in;          /* number of bytes available at next_in */
+        uLong total_in;         /* total number of input bytes read so far */
+
+        Bytef* next_out; /* next output byte will go here */
+        uInt avail_out;  /* remaining free space at next_out */
+        uLong total_out; /* total number of bytes output so far */
+
+        z_const char* msg;                /* last error message, NULL if no error */
+        struct internal_state FAR* state; /* not visible by applications */
 
-                        /* constants */
+        alloc_func zalloc; /* used to allocate the internal state */
+        free_func zfree;   /* used to free the internal state */
+        voidpf opaque;     /* private data object passed to zalloc and zfree */
 
-#define Z_NO_FLUSH      0
+        int data_type;  /* best guess about the data type: binary or text
+                           for deflate, or the decoding state for inflate */
+        uLong adler;    /* Adler-32 or CRC-32 value of the uncompressed data */
+        uLong reserved; /* reserved for future use */
+    } z_stream;
+
+    typedef z_stream FAR* z_streamp;
+
+    /*
+         gzip header information passed to and from zlib routines.  See RFC 1952
+      for more details on the meanings of these fields.
+    */
+    typedef struct gz_header_s
+    {
+        int text;       /* true if compressed data believed to be text */
+        uLong time;     /* modification time */
+        int xflags;     /* extra flags (not used when writing a gzip file) */
+        int os;         /* operating system */
+        Bytef* extra;   /* pointer to extra field or Z_NULL if none */
+        uInt extra_len; /* extra field length (valid if extra != Z_NULL) */
+        uInt extra_max; /* space at extra (only when reading header) */
+        Bytef* name;    /* pointer to zero-terminated file name or Z_NULL */
+        uInt name_max;  /* space at name (only when reading header) */
+        Bytef* comment; /* pointer to zero-terminated comment or Z_NULL */
+        uInt comm_max;  /* space at comment (only when reading header) */
+        int hcrc;       /* true if there was or will be a header crc */
+        int done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+    } gz_header;
+
+    typedef gz_header FAR* gz_headerp;
+
+    /*
+         The application must update next_in and avail_in when avail_in has dropped
+       to zero.  It must update next_out and avail_out when avail_out has dropped
+       to zero.  The application must initialize zalloc, zfree and opaque before
+       calling the init function.  All other fields are set by the compression
+       library and must not be updated by the application.
+
+         The opaque value provided by the application will be passed as the first
+       parameter for calls of zalloc and zfree.  This can be useful for custom
+       memory management.  The compression library attaches no meaning to the
+       opaque value.
+
+         zalloc must return Z_NULL if there is not enough memory for the object.
+       If zlib is used in a multi-threaded application, zalloc and zfree must be
+       thread safe.  In that case, zlib is thread-safe.  When zalloc and zfree are
+       Z_NULL on entry to the initialization function, they are set to internal
+       routines that use the standard library functions malloc() and free().
+
+         On 16-bit systems, the functions zalloc and zfree must be able to allocate
+       exactly 65536 bytes, but will not be required to allocate more than this if
+       the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
+       returned by zalloc for objects of exactly 65536 bytes *must* have their
+       offset normalized to zero.  The default allocation function provided by this
+       library ensures this (see zutil.c).  To reduce memory requirements and avoid
+       any allocation of 64K objects, at the expense of compression ratio, compile
+       the library with -DMAX_WBITS=14 (see zconf.h).
+
+         The fields total_in and total_out can be used for statistics or progress
+       reports.  After compression, total_in holds the total size of the
+       uncompressed data and may be saved for use by the decompressor (particularly
+       if the decompressor wants to decompress everything in a single step).
+    */
+
+    /* constants */
+
+#define Z_NO_FLUSH 0
 #define Z_PARTIAL_FLUSH 1
-#define Z_SYNC_FLUSH    2
-#define Z_FULL_FLUSH    3
-#define Z_FINISH        4
-#define Z_BLOCK         5
-#define Z_TREES         6
-/* Allowed flush values; see deflate() and inflate() below for details */
-
-#define Z_OK            0
-#define Z_STREAM_END    1
-#define Z_NEED_DICT     2
-#define Z_ERRNO        (-1)
+#define Z_SYNC_FLUSH 2
+#define Z_FULL_FLUSH 3
+#define Z_FINISH 4
+#define Z_BLOCK 5
+#define Z_TREES 6
+    /* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK 0
+#define Z_STREAM_END 1
+#define Z_NEED_DICT 2
+#define Z_ERRNO (-1)
 #define Z_STREAM_ERROR (-2)
-#define Z_DATA_ERROR   (-3)
-#define Z_MEM_ERROR    (-4)
-#define Z_BUF_ERROR    (-5)
+#define Z_DATA_ERROR (-3)
+#define Z_MEM_ERROR (-4)
+#define Z_BUF_ERROR (-5)
 #define Z_VERSION_ERROR (-6)
-/* Return codes for the compression/decompression functions. Negative values
- * are errors, positive values are used for special but normal events.
- */
-
-#define Z_NO_COMPRESSION         0
-#define Z_BEST_SPEED             1
-#define Z_BEST_COMPRESSION       9
-#define Z_DEFAULT_COMPRESSION  (-1)
-/* compression levels */
-
-#define Z_FILTERED            1
-#define Z_HUFFMAN_ONLY        2
-#define Z_RLE                 3
-#define Z_FIXED               4
-#define Z_DEFAULT_STRATEGY    0
-/* compression strategy; see deflateInit2() below for details */
-
-#define Z_BINARY   0
-#define Z_TEXT     1
-#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
-#define Z_UNKNOWN  2
-/* Possible values of the data_type field for deflate() */
-
-#define Z_DEFLATED   8
-/* The deflate compression method (the only one supported in this version) */
-
-#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+    /* Return codes for the compression/decompression functions. Negative values
+     * are errors, positive values are used for special but normal events.
+     */
+
+#define Z_NO_COMPRESSION 0
+#define Z_BEST_SPEED 1
+#define Z_BEST_COMPRESSION 9
+#define Z_DEFAULT_COMPRESSION (-1)
+    /* compression levels */
+
+#define Z_FILTERED 1
+#define Z_HUFFMAN_ONLY 2
+#define Z_RLE 3
+#define Z_FIXED 4
+#define Z_DEFAULT_STRATEGY 0
+    /* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY 0
+#define Z_TEXT 1
+#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN 2
+    /* Possible values of the data_type field for deflate() */
+
+#define Z_DEFLATED 8
+    /* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
 
 #define zlib_version zlibVersion()
-/* for compatibility with versions < 1.0.2 */
-
-
-                        /* basic functions */
-
-ZEXTERN const char * ZEXPORT zlibVersion OF((void));
-/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
-   If the first character differs, the library code actually used is not
-   compatible with the zlib.h header file used by the application.  This check
-   is automatically made by deflateInit and inflateInit.
- */
-
-/*
-ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
-
-     Initializes the internal stream state for compression.  The fields
-   zalloc, zfree and opaque must be initialized before by the caller.  If
-   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
-   allocation functions.
-
-     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
-   1 gives best speed, 9 gives best compression, 0 gives no compression at all
-   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
-   requests a default compromise between speed and compression (currently
-   equivalent to level 6).
-
-     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_STREAM_ERROR if level is not a valid compression level, or
-   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
-   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
-   if there is no error message.  deflateInit does not perform any compression:
-   this will be done by deflate().
-*/
-
-
-ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
-/*
-    deflate compresses as much data as possible, and stops when the input
-  buffer becomes empty or the output buffer becomes full.  It may introduce
-  some output latency (reading input without producing any output) except when
-  forced to flush.
-
-    The detailed semantics are as follows.  deflate performs one or both of the
-  following actions:
-
-  - Compress more input starting at next_in and update next_in and avail_in
-    accordingly.  If not all input can be processed (because there is not
-    enough room in the output buffer), next_in and avail_in are updated and
-    processing will resume at this point for the next call of deflate().
-
-  - Generate more output starting at next_out and update next_out and avail_out
-    accordingly.  This action is forced if the parameter flush is non zero.
-    Forcing flush frequently degrades the compression ratio, so this parameter
-    should be set only when necessary.  Some output may be provided even if
-    flush is zero.
-
-    Before the call of deflate(), the application should ensure that at least
-  one of the actions is possible, by providing more input and/or consuming more
-  output, and updating avail_in or avail_out accordingly; avail_out should
-  never be zero before the call.  The application can consume the compressed
-  output when it wants, for example when the output buffer is full (avail_out
-  == 0), or after each call of deflate().  If deflate returns Z_OK and with
-  zero avail_out, it must be called again after making room in the output
-  buffer because there might be more output pending. See deflatePending(),
-  which can be used if desired to determine whether or not there is more ouput
-  in that case.
-
-    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
-  decide how much data to accumulate before producing output, in order to
-  maximize compression.
-
-    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
-  flushed to the output buffer and the output is aligned on a byte boundary, so
-  that the decompressor can get all input data available so far.  (In
-  particular avail_in is zero after the call if enough output space has been
-  provided before the call.) Flushing may degrade compression for some
-  compression algorithms and so it should be used only when necessary.  This
-  completes the current deflate block and follows it with an empty stored block
-  that is three bits plus filler bits to the next byte, followed by four bytes
-  (00 00 ff ff).
-
-    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
-  output buffer, but the output is not aligned to a byte boundary.  All of the
-  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
-  This completes the current deflate block and follows it with an empty fixed
-  codes block that is 10 bits long.  This assures that enough bytes are output
-  in order for the decompressor to finish the block before the empty fixed
-  codes block.
-
-    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
-  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
-  seven bits of the current block are held to be written as the next byte after
-  the next deflate block is completed.  In this case, the decompressor may not
-  be provided enough bits at this point in order to complete decompression of
-  the data provided so far to the compressor.  It may need to wait for the next
-  block to be emitted.  This is for advanced applications that need to control
-  the emission of deflate blocks.
-
-    If flush is set to Z_FULL_FLUSH, all output is flushed as with
-  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
-  restart from this point if previous compressed data has been damaged or if
-  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
-  compression.
-
-    If deflate returns with avail_out == 0, this function must be called again
-  with the same value of the flush parameter and more output space (updated
-  avail_out), until the flush is complete (deflate returns with non-zero
-  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
-  avail_out is greater than six to avoid repeated flush markers due to
-  avail_out == 0 on return.
-
-    If the parameter flush is set to Z_FINISH, pending input is processed,
-  pending output is flushed and deflate returns with Z_STREAM_END if there was
-  enough output space.  If deflate returns with Z_OK or Z_BUF_ERROR, this
-  function must be called again with Z_FINISH and more output space (updated
-  avail_out) but no more input data, until it returns with Z_STREAM_END or an
-  error.  After deflate has returned Z_STREAM_END, the only possible operations
-  on the stream are deflateReset or deflateEnd.
-
-    Z_FINISH can be used in the first deflate call after deflateInit if all the
-  compression is to be done in a single step.  In order to complete in one
-  call, avail_out must be at least the value returned by deflateBound (see
-  below).  Then deflate is guaranteed to return Z_STREAM_END.  If not enough
-  output space is provided, deflate will not return Z_STREAM_END, and it must
-  be called again as described above.
-
-    deflate() sets strm->adler to the Adler-32 checksum of all input read
-  so far (that is, total_in bytes).  If a gzip stream is being generated, then
-  strm->adler will be the CRC-32 checksum of the input read so far.  (See
-  deflateInit2 below.)
-
-    deflate() may update strm->data_type if it can make a good guess about
-  the input data type (Z_BINARY or Z_TEXT).  If in doubt, the data is
-  considered binary.  This field is only for information purposes and does not
-  affect the compression algorithm in any manner.
-
-    deflate() returns Z_OK if some progress has been made (more input
-  processed or more output produced), Z_STREAM_END if all input has been
-  consumed and all output has been produced (only when flush is set to
-  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
-  if next_in or next_out was Z_NULL or the state was inadvertently written over
-  by the application), or Z_BUF_ERROR if no progress is possible (for example
-  avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not fatal, and
-  deflate() can be called again with more input and more output space to
-  continue compressing.
-*/
-
-
-ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
-/*
-     All dynamically allocated data structures for this stream are freed.
-   This function discards any unprocessed input and does not flush any pending
-   output.
-
-     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
-   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
-   prematurely (some input or output was discarded).  In the error case, msg
-   may be set but then points to a static string (which must not be
-   deallocated).
-*/
-
-
-/*
-ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
-
-     Initializes the internal stream state for decompression.  The fields
-   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
-   the caller.  In the current version of inflate, the provided input is not
-   read or consumed.  The allocation of a sliding window will be deferred to
-   the first call of inflate (if the decompression does not complete on the
-   first call).  If zalloc and zfree are set to Z_NULL, inflateInit updates
-   them to use default allocation functions.
-
-     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
-   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
-   invalid, such as a null pointer to the structure.  msg is set to null if
-   there is no error message.  inflateInit does not perform any decompression.
-   Actual decompression will be done by inflate().  So next_in, and avail_in,
-   next_out, and avail_out are unused and unchanged.  The current
-   implementation of inflateInit() does not process any header information --
-   that is deferred until inflate() is called.
-*/
-
-
-ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
-/*
-    inflate decompresses as much data as possible, and stops when the input
-  buffer becomes empty or the output buffer becomes full.  It may introduce
-  some output latency (reading input without producing any output) except when
-  forced to flush.
-
-  The detailed semantics are as follows.  inflate performs one or both of the
-  following actions:
-
-  - Decompress more input starting at next_in and update next_in and avail_in
-    accordingly.  If not all input can be processed (because there is not
-    enough room in the output buffer), then next_in and avail_in are updated
-    accordingly, and processing will resume at this point for the next call of
-    inflate().
-
-  - Generate more output starting at next_out and update next_out and avail_out
-    accordingly.  inflate() provides as much output as possible, until there is
-    no more input data or no more space in the output buffer (see below about
-    the flush parameter).
-
-    Before the call of inflate(), the application should ensure that at least
-  one of the actions is possible, by providing more input and/or consuming more
-  output, and updating the next_* and avail_* values accordingly.  If the
-  caller of inflate() does not provide both available input and available
-  output space, it is possible that there will be no progress made.  The
-  application can consume the uncompressed output when it wants, for example
-  when the output buffer is full (avail_out == 0), or after each call of
-  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
-  called again after making room in the output buffer because there might be
-  more output pending.
-
-    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
-  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
-  output as possible to the output buffer.  Z_BLOCK requests that inflate()
-  stop if and when it gets to the next deflate block boundary.  When decoding
-  the zlib or gzip format, this will cause inflate() to return immediately
-  after the header and before the first block.  When doing a raw inflate,
-  inflate() will go ahead and process the first block, and will return when it
-  gets to the end of that block, or when it runs out of data.
-
-    The Z_BLOCK option assists in appending to or combining deflate streams.
-  To assist in this, on return inflate() always sets strm->data_type to the
-  number of unused bits in the last byte taken from strm->next_in, plus 64 if
-  inflate() is currently decoding the last block in the deflate stream, plus
-  128 if inflate() returned immediately after decoding an end-of-block code or
-  decoding the complete header up to just before the first byte of the deflate
-  stream.  The end-of-block will not be indicated until all of the uncompressed
-  data from that block has been written to strm->next_out.  The number of
-  unused bits may in general be greater than seven, except when bit 7 of
-  data_type is set, in which case the number of unused bits will be less than
-  eight.  data_type is set as noted here every time inflate() returns for all
-  flush options, and so can be used to determine the amount of currently
-  consumed input in bits.
-
-    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
-  end of each deflate block header is reached, before any actual data in that
-  block is decoded.  This allows the caller to determine the length of the
-  deflate block header for later use in random access within a deflate block.
-  256 is added to the value of strm->data_type when inflate() returns
-  immediately after reaching the end of the deflate block header.
-
-    inflate() should normally be called until it returns Z_STREAM_END or an
-  error.  However if all decompression is to be performed in a single step (a
-  single call of inflate), the parameter flush should be set to Z_FINISH.  In
-  this case all pending input is processed and all pending output is flushed;
-  avail_out must be large enough to hold all of the uncompressed data for the
-  operation to complete.  (The size of the uncompressed data may have been
-  saved by the compressor for this purpose.)  The use of Z_FINISH is not
-  required to perform an inflation in one step.  However it may be used to
-  inform inflate that a faster approach can be used for the single inflate()
-  call.  Z_FINISH also informs inflate to not maintain a sliding window if the
-  stream completes, which reduces inflate's memory footprint.  If the stream
-  does not complete, either because not all of the stream is provided or not
-  enough output space is provided, then a sliding window will be allocated and
-  inflate() can be called again to continue the operation as if Z_NO_FLUSH had
-  been used.
-
-     In this implementation, inflate() always flushes as much output as
-  possible to the output buffer, and always uses the faster approach on the
-  first call.  So the effects of the flush parameter in this implementation are
-  on the return value of inflate() as noted below, when inflate() returns early
-  when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
-  memory for a sliding window when Z_FINISH is used.
-
-     If a preset dictionary is needed after this call (see inflateSetDictionary
-  below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
-  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
-  strm->adler to the Adler-32 checksum of all output produced so far (that is,
-  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
-  below.  At the end of the stream, inflate() checks that its computed Adler-32
-  checksum is equal to that saved by the compressor and returns Z_STREAM_END
-  only if the checksum is correct.
-
-    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
-  deflate data.  The header type is detected automatically, if requested when
-  initializing with inflateInit2().  Any information contained in the gzip
-  header is not retained unless inflateGetHeader() is used.  When processing
-  gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
-  produced so far.  The CRC-32 is checked against the gzip trailer, as is the
-  uncompressed length, modulo 2^32.
-
-    inflate() returns Z_OK if some progress has been made (more input processed
-  or more output produced), Z_STREAM_END if the end of the compressed data has
-  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
-  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
-  corrupted (input stream not conforming to the zlib format or incorrect check
-  value, in which case strm->msg points to a string with a more specific
-  error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
-  next_in or next_out was Z_NULL, or the state was inadvertently written over
-  by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
-  if no progress was possible or if there was not enough room in the output
-  buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
-  inflate() can be called again with more input and more output space to
-  continue decompressing.  If Z_DATA_ERROR is returned, the application may
-  then call inflateSync() to look for a good compression block if a partial
-  recovery of the data is to be attempted.
-*/
-
-
-ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
-/*
-     All dynamically allocated data structures for this stream are freed.
-   This function discards any unprocessed input and does not flush any pending
-   output.
-
-     inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
-   was inconsistent.
-*/
-
-
-                        /* Advanced functions */
-
-/*
-    The following functions are needed only in some special applications.
-*/
-
-/*
-ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
-                                     int  level,
-                                     int  method,
-                                     int  windowBits,
-                                     int  memLevel,
-                                     int  strategy));
-
-     This is another version of deflateInit with more compression options.  The
-   fields zalloc, zfree and opaque must be initialized before by the caller.
-
-     The method parameter is the compression method.  It must be Z_DEFLATED in
-   this version of the library.
-
-     The windowBits parameter is the base two logarithm of the window size
-   (the size of the history buffer).  It should be in the range 8..15 for this
-   version of the library.  Larger values of this parameter result in better
-   compression at the expense of memory usage.  The default value is 15 if
-   deflateInit is used instead.
-
-     For the current implementation of deflate(), a windowBits value of 8 (a
-   window size of 256 bytes) is not supported.  As a result, a request for 8
-   will result in 9 (a 512-byte window).  In that case, providing 8 to
-   inflateInit2() will result in an error when the zlib header with 9 is
-   checked against the initialization of inflate().  The remedy is to not use 8
-   with deflateInit2() with this initialization, or at least in that case use 9
-   with inflateInit2().
-
-     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
-   determines the window size.  deflate() will then generate raw deflate data
-   with no zlib header or trailer, and will not compute a check value.
-
-     windowBits can also be greater than 15 for optional gzip encoding.  Add
-   16 to windowBits to write a simple gzip header and trailer around the
-   compressed data instead of a zlib wrapper.  The gzip header will have no
-   file name, no extra data, no comment, no modification time (set to zero), no
-   header crc, and the operating system will be set to the appropriate value,
-   if the operating system was determined at compile time.  If a gzip stream is
-   being written, strm->adler is a CRC-32 instead of an Adler-32.
-
-     For raw deflate or gzip encoding, a request for a 256-byte window is
-   rejected as invalid, since only the zlib header provides a means of
-   transmitting the window size to the decompressor.
-
-     The memLevel parameter specifies how much memory should be allocated
-   for the internal compression state.  memLevel=1 uses minimum memory but is
-   slow and reduces compression ratio; memLevel=9 uses maximum memory for
-   optimal speed.  The default value is 8.  See zconf.h for total memory usage
-   as a function of windowBits and memLevel.
-
-     The strategy parameter is used to tune the compression algorithm.  Use the
-   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
-   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
-   string match), or Z_RLE to limit match distances to one (run-length
-   encoding).  Filtered data consists mostly of small values with a somewhat
-   random distribution.  In this case, the compression algorithm is tuned to
-   compress them better.  The effect of Z_FILTERED is to force more Huffman
-   coding and less string matching; it is somewhat intermediate between
-   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
-   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
-   strategy parameter only affects the compression ratio but not the
-   correctness of the compressed output even if it is not set appropriately.
-   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
-   decoder for special applications.
-
-     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
-   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
-   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
-   set to null if there is no error message.  deflateInit2 does not perform any
-   compression: this will be done by deflate().
-*/
-
-ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
-                                             const Bytef *dictionary,
-                                             uInt  dictLength));
-/*
-     Initializes the compression dictionary from the given byte sequence
-   without producing any compressed output.  When using the zlib format, this
-   function must be called immediately after deflateInit, deflateInit2 or
-   deflateReset, and before any call of deflate.  When doing raw deflate, this
-   function must be called either before any call of deflate, or immediately
-   after the completion of a deflate block, i.e. after all input has been
-   consumed and all output has been delivered when using any of the flush
-   options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
-   compressor and decompressor must use exactly the same dictionary (see
-   inflateSetDictionary).
-
-     The dictionary should consist of strings (byte sequences) that are likely
-   to be encountered later in the data to be compressed, with the most commonly
-   used strings preferably put towards the end of the dictionary.  Using a
-   dictionary is most useful when the data to be compressed is short and can be
-   predicted with good accuracy; the data can then be compressed better than
-   with the default empty dictionary.
-
-     Depending on the size of the compression data structures selected by
-   deflateInit or deflateInit2, a part of the dictionary may in effect be
-   discarded, for example if the dictionary is larger than the window size
-   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
-   useful should be put at the end of the dictionary, not at the front.  In
-   addition, the current implementation of deflate will use at most the window
-   size minus 262 bytes of the provided dictionary.
-
-     Upon return of this function, strm->adler is set to the Adler-32 value
-   of the dictionary; the decompressor may later use this value to determine
-   which dictionary has been used by the compressor.  (The Adler-32 value
-   applies to the whole dictionary even if only a subset of the dictionary is
-   actually used by the compressor.) If a raw deflate was requested, then the
-   Adler-32 value is not computed and strm->adler is not set.
-
-     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
-   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
-   inconsistent (for example if deflate has already been called for this stream
-   or if not at a block boundary for raw deflate).  deflateSetDictionary does
-   not perform any compression: this will be done by deflate().
-*/
-
-ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
-                                             Bytef *dictionary,
-                                             uInt  *dictLength));
-/*
-     Returns the sliding dictionary being maintained by deflate.  dictLength is
-   set to the number of bytes in the dictionary, and that many bytes are copied
-   to dictionary.  dictionary must have enough space, where 32768 bytes is
-   always enough.  If deflateGetDictionary() is called with dictionary equal to
-   Z_NULL, then only the dictionary length is returned, and nothing is copied.
-   Similary, if dictLength is Z_NULL, then it is not set.
-
-     deflateGetDictionary() may return a length less than the window size, even
-   when more than the window size in input has been provided. It may return up
-   to 258 bytes less in that case, due to how zlib's implementation of deflate
-   manages the sliding window and lookahead for matches, where matches can be
-   up to 258 bytes long. If the application needs the last window-size bytes of
-   input, then that would need to be saved by the application outside of zlib.
-
-     deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
-   stream state is inconsistent.
-*/
-
-ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
-                                    z_streamp source));
-/*
-     Sets the destination stream as a complete copy of the source stream.
-
-     This function can be useful when several compression strategies will be
-   tried, for example when there are several ways of pre-processing the input
-   data with a filter.  The streams that will be discarded should then be freed
-   by calling deflateEnd.  Note that deflateCopy duplicates the internal
-   compression state which can be quite large, so this strategy is slow and can
-   consume lots of memory.
-
-     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
-   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
-   destination.
-*/
-
-ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
-/*
-     This function is equivalent to deflateEnd followed by deflateInit, but
-   does not free and reallocate the internal compression state.  The stream
-   will leave the compression level and any other attributes that may have been
-   set unchanged.
-
-     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being Z_NULL).
-*/
-
-ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
-                                      int level,
-                                      int strategy));
-/*
-     Dynamically update the compression level and compression strategy.  The
-   interpretation of level and strategy is as in deflateInit2().  This can be
-   used to switch between compression and straight copy of the input data, or
-   to switch to a different kind of input data requiring a different strategy.
-   If the compression approach (which is a function of the level) or the
-   strategy is changed, and if there have been any deflate() calls since the
-   state was initialized or reset, then the input available so far is
-   compressed with the old level and strategy using deflate(strm, Z_BLOCK).
-   There are three approaches for the compression levels 0, 1..3, and 4..9
-   respectively.  The new level and strategy will take effect at the next call
-   of deflate().
-
-     If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
-   not have enough output space to complete, then the parameter change will not
-   take effect.  In this case, deflateParams() can be called again with the
-   same parameters and more output space to try again.
-
-     In order to assure a change in the parameters on the first try, the
-   deflate stream should be flushed using deflate() with Z_BLOCK or other flush
-   request until strm.avail_out is not zero, before calling deflateParams().
-   Then no more input data should be provided before the deflateParams() call.
-   If this is done, the old level and strategy will be applied to the data
-   compressed before deflateParams(), and the new level and strategy will be
-   applied to the the data compressed after deflateParams().
-
-     deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
-   state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
-   there was not enough output space to complete the compression of the
-   available input data before a change in the strategy or approach.  Note that
-   in the case of a Z_BUF_ERROR, the parameters are not changed.  A return
-   value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
-   retried with more output space.
-*/
-
-ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
-                                    int good_length,
-                                    int max_lazy,
-                                    int nice_length,
-                                    int max_chain));
-/*
-     Fine tune deflate's internal compression parameters.  This should only be
-   used by someone who understands the algorithm used by zlib's deflate for
-   searching for the best matching string, and even then only by the most
-   fanatic optimizer trying to squeeze out the last compressed bit for their
-   specific input data.  Read the deflate.c source code for the meaning of the
-   max_lazy, good_length, nice_length, and max_chain parameters.
-
-     deflateTune() can be called after deflateInit() or deflateInit2(), and
-   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
- */
-
-ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
-                                       uLong sourceLen));
-/*
-     deflateBound() returns an upper bound on the compressed size after
-   deflation of sourceLen bytes.  It must be called after deflateInit() or
-   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
-   to allocate an output buffer for deflation in a single pass, and so would be
-   called before deflate().  If that first deflate() call is provided the
-   sourceLen input bytes, an output buffer allocated to the size returned by
-   deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
-   to return Z_STREAM_END.  Note that it is possible for the compressed size to
-   be larger than the value returned by deflateBound() if flush options other
-   than Z_FINISH or Z_NO_FLUSH are used.
-*/
-
-ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
-                                       unsigned *pending,
-                                       int *bits));
-/*
-     deflatePending() returns the number of bytes and bits of output that have
-   been generated, but not yet provided in the available output.  The bytes not
-   provided would be due to the available output space having being consumed.
-   The number of bits of output not provided are between 0 and 7, where they
-   await more bits to join them in order to fill out a full byte.  If pending
-   or bits are Z_NULL, then those values are not set.
-
-     deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
- */
-
-ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
-                                     int bits,
-                                     int value));
-/*
-     deflatePrime() inserts bits in the deflate output stream.  The intent
-   is that this function is used to start off the deflate output with the bits
-   leftover from a previous deflate stream when appending to it.  As such, this
-   function can only be used for raw deflate, and must be used before the first
-   deflate() call after a deflateInit2() or deflateReset().  bits must be less
-   than or equal to 16, and that many of the least significant bits of value
-   will be inserted in the output.
-
-     deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
-   room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
-   source stream state was inconsistent.
-*/
-
-ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
-                                         gz_headerp head));
-/*
-     deflateSetHeader() provides gzip header information for when a gzip
-   stream is requested by deflateInit2().  deflateSetHeader() may be called
-   after deflateInit2() or deflateReset() and before the first call of
-   deflate().  The text, time, os, extra field, name, and comment information
-   in the provided gz_header structure are written to the gzip header (xflag is
-   ignored -- the extra flags are set according to the compression level).  The
-   caller must assure that, if not Z_NULL, name and comment are terminated with
-   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
-   available there.  If hcrc is true, a gzip header crc is included.  Note that
-   the current versions of the command-line version of gzip (up through version
-   1.3.x) do not support header crc's, and will report that it is a "multi-part
-   gzip file" and give up.
-
-     If deflateSetHeader is not used, the default gzip header has text false,
-   the time set to zero, and os set to 255, with no extra, name, or comment
-   fields.  The gzip header is returned to the default state by deflateReset().
-
-     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
-*/
-
-/*
-ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
-                                     int  windowBits));
-
-     This is another version of inflateInit with an extra parameter.  The
-   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
-   before by the caller.
-
-     The windowBits parameter is the base two logarithm of the maximum window
-   size (the size of the history buffer).  It should be in the range 8..15 for
-   this version of the library.  The default value is 15 if inflateInit is used
-   instead.  windowBits must be greater than or equal to the windowBits value
-   provided to deflateInit2() while compressing, or it must be equal to 15 if
-   deflateInit2() was not used.  If a compressed stream with a larger window
-   size is given as input, inflate() will return with the error code
-   Z_DATA_ERROR instead of trying to allocate a larger window.
-
-     windowBits can also be zero to request that inflate use the window size in
-   the zlib header of the compressed stream.
-
-     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
-   determines the window size.  inflate() will then process raw deflate data,
-   not looking for a zlib or gzip header, not generating a check value, and not
-   looking for any check values for comparison at the end of the stream.  This
-   is for use with other formats that use the deflate compressed data format
-   such as zip.  Those formats provide their own check values.  If a custom
-   format is developed using the raw deflate format for compressed data, it is
-   recommended that a check value such as an Adler-32 or a CRC-32 be applied to
-   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
-   most applications, the zlib format should be used as is.  Note that comments
-   above on the use in deflateInit2() applies to the magnitude of windowBits.
-
-     windowBits can also be greater than 15 for optional gzip decoding.  Add
-   32 to windowBits to enable zlib and gzip decoding with automatic header
-   detection, or add 16 to decode only the gzip format (the zlib format will
-   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
-   CRC-32 instead of an Adler-32.  Unlike the gunzip utility and gzread() (see
-   below), inflate() will *not* automatically decode concatenated gzip members.
-   inflate() will return Z_STREAM_END at the end of the gzip member.  The state
-   would need to be reset to continue decoding a subsequent gzip member.  This
-   *must* be done if there is more data after a gzip member, in order for the
-   decompression to be compliant with the gzip standard (RFC 1952).
-
-     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
-   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
-   invalid, such as a null pointer to the structure.  msg is set to null if
-   there is no error message.  inflateInit2 does not perform any decompression
-   apart from possibly reading the zlib header if present: actual decompression
-   will be done by inflate().  (So next_in and avail_in may be modified, but
-   next_out and avail_out are unused and unchanged.) The current implementation
-   of inflateInit2() does not process any header information -- that is
-   deferred until inflate() is called.
-*/
-
-ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
-                                             const Bytef *dictionary,
-                                             uInt  dictLength));
-/*
-     Initializes the decompression dictionary from the given uncompressed byte
-   sequence.  This function must be called immediately after a call of inflate,
-   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
-   can be determined from the Adler-32 value returned by that call of inflate.
-   The compressor and decompressor must use exactly the same dictionary (see
-   deflateSetDictionary).  For raw inflate, this function can be called at any
-   time to set the dictionary.  If the provided dictionary is smaller than the
-   window and there is already data in the window, then the provided dictionary
-   will amend what's there.  The application must insure that the dictionary
-   that was used for compression is provided.
-
-     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
-   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
-   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
-   expected one (incorrect Adler-32 value).  inflateSetDictionary does not
-   perform any decompression: this will be done by subsequent calls of
-   inflate().
-*/
-
-ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
-                                             Bytef *dictionary,
-                                             uInt  *dictLength));
-/*
-     Returns the sliding dictionary being maintained by inflate.  dictLength is
-   set to the number of bytes in the dictionary, and that many bytes are copied
-   to dictionary.  dictionary must have enough space, where 32768 bytes is
-   always enough.  If inflateGetDictionary() is called with dictionary equal to
-   Z_NULL, then only the dictionary length is returned, and nothing is copied.
-   Similary, if dictLength is Z_NULL, then it is not set.
-
-     inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
-   stream state is inconsistent.
-*/
-
-ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
-/*
-     Skips invalid compressed data until a possible full flush point (see above
-   for the description of deflate with Z_FULL_FLUSH) can be found, or until all
-   available input is skipped.  No output is provided.
-
-     inflateSync searches for a 00 00 FF FF pattern in the compressed data.
-   All full flush points have this pattern, but not all occurrences of this
-   pattern are full flush points.
-
-     inflateSync returns Z_OK if a possible full flush point has been found,
-   Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
-   has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
-   In the success case, the application may save the current current value of
-   total_in which indicates where valid compressed data was found.  In the
-   error case, the application may repeatedly call inflateSync, providing more
-   input each time, until success or end of the input data.
-*/
-
-ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
-                                    z_streamp source));
-/*
-     Sets the destination stream as a complete copy of the source stream.
-
-     This function can be useful when randomly accessing a large stream.  The
-   first pass through the stream can periodically record the inflate state,
-   allowing restarting inflate at those points when randomly accessing the
-   stream.
-
-     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
-   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
-   destination.
-*/
-
-ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
-/*
-     This function is equivalent to inflateEnd followed by inflateInit,
-   but does not free and reallocate the internal decompression state.  The
-   stream will keep attributes that may have been set by inflateInit2.
-
-     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being Z_NULL).
-*/
-
-ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
-                                      int windowBits));
-/*
-     This function is the same as inflateReset, but it also permits changing
-   the wrap and window size requests.  The windowBits parameter is interpreted
-   the same as it is for inflateInit2.  If the window size is changed, then the
-   memory allocated for the window is freed, and the window will be reallocated
-   by inflate() if needed.
-
-     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
-   the windowBits parameter is invalid.
-*/
-
-ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
-                                     int bits,
-                                     int value));
-/*
-     This function inserts bits in the inflate input stream.  The intent is
-   that this function is used to start inflating at a bit position in the
-   middle of a byte.  The provided bits will be used before any bytes are used
-   from next_in.  This function should only be used with raw inflate, and
-   should be used before the first inflate() call after inflateInit2() or
-   inflateReset().  bits must be less than or equal to 16, and that many of the
-   least significant bits of value will be inserted in the input.
-
-     If bits is negative, then the input stream bit buffer is emptied.  Then
-   inflatePrime() can be called again to put bits in the buffer.  This is used
-   to clear out bits leftover after feeding inflate a block description prior
-   to feeding inflate codes.
-
-     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
-*/
-
-ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
-/*
-     This function returns two values, one in the lower 16 bits of the return
-   value, and the other in the remaining upper bits, obtained by shifting the
-   return value down 16 bits.  If the upper value is -1 and the lower value is
-   zero, then inflate() is currently decoding information outside of a block.
-   If the upper value is -1 and the lower value is non-zero, then inflate is in
-   the middle of a stored block, with the lower value equaling the number of
-   bytes from the input remaining to copy.  If the upper value is not -1, then
-   it is the number of bits back from the current bit position in the input of
-   the code (literal or length/distance pair) currently being processed.  In
-   that case the lower value is the number of bytes already emitted for that
-   code.
-
-     A code is being processed if inflate is waiting for more input to complete
-   decoding of the code, or if it has completed decoding but is waiting for
-   more output space to write the literal or match data.
-
-     inflateMark() is used to mark locations in the input data for random
-   access, which may be at bit positions, and to note those cases where the
-   output of a code may span boundaries of random access blocks.  The current
-   location in the input stream can be determined from avail_in and data_type
-   as noted in the description for the Z_BLOCK flush parameter for inflate.
-
-     inflateMark returns the value noted above, or -65536 if the provided
-   source stream state was inconsistent.
-*/
-
-ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
-                                         gz_headerp head));
-/*
-     inflateGetHeader() requests that gzip header information be stored in the
-   provided gz_header structure.  inflateGetHeader() may be called after
-   inflateInit2() or inflateReset(), and before the first call of inflate().
-   As inflate() processes the gzip stream, head->done is zero until the header
-   is completed, at which time head->done is set to one.  If a zlib stream is
-   being decoded, then head->done is set to -1 to indicate that there will be
-   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
-   used to force inflate() to return immediately after header processing is
-   complete and before any actual data is decompressed.
-
-     The text, time, xflags, and os fields are filled in with the gzip header
-   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
-   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
-   contains the maximum number of bytes to write to extra.  Once done is true,
-   extra_len contains the actual extra field length, and extra contains the
-   extra field, or that field truncated if extra_max is less than extra_len.
-   If name is not Z_NULL, then up to name_max characters are written there,
-   terminated with a zero unless the length is greater than name_max.  If
-   comment is not Z_NULL, then up to comm_max characters are written there,
-   terminated with a zero unless the length is greater than comm_max.  When any
-   of extra, name, or comment are not Z_NULL and the respective field is not
-   present in the header, then that field is set to Z_NULL to signal its
-   absence.  This allows the use of deflateSetHeader() with the returned
-   structure to duplicate the header.  However if those fields are set to
-   allocated memory, then the application will need to save those pointers
-   elsewhere so that they can be eventually freed.
-
-     If inflateGetHeader is not used, then the header information is simply
-   discarded.  The header is always checked for validity, including the header
-   CRC if present.  inflateReset() will reset the process to discard the header
-   information.  The application would need to call inflateGetHeader() again to
-   retrieve the header from the next gzip stream.
-
-     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent.
-*/
-
-/*
-ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
-                                        unsigned char FAR *window));
-
-     Initialize the internal stream state for decompression using inflateBack()
-   calls.  The fields zalloc, zfree and opaque in strm must be initialized
-   before the call.  If zalloc and zfree are Z_NULL, then the default library-
-   derived memory allocation routines are used.  windowBits is the base two
-   logarithm of the window size, in the range 8..15.  window is a caller
-   supplied buffer of that size.  Except for special applications where it is
-   assured that deflate was used with small window sizes, windowBits must be 15
-   and a 32K byte window must be supplied to be able to decompress general
-   deflate streams.
-
-     See inflateBack() for the usage of these routines.
-
-     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
-   the parameters are invalid, Z_MEM_ERROR if the internal state could not be
-   allocated, or Z_VERSION_ERROR if the version of the library does not match
-   the version of the header file.
-*/
-
-typedef unsigned (*in_func) OF((void FAR *,
-                                z_const unsigned char FAR * FAR *));
-typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
-
-ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
-                                    in_func in, void FAR *in_desc,
-                                    out_func out, void FAR *out_desc));
-/*
-     inflateBack() does a raw inflate with a single call using a call-back
-   interface for input and output.  This is potentially more efficient than
-   inflate() for file i/o applications, in that it avoids copying between the
-   output and the sliding window by simply making the window itself the output
-   buffer.  inflate() can be faster on modern CPUs when used with large
-   buffers.  inflateBack() trusts the application to not change the output
-   buffer passed by the output function, at least until inflateBack() returns.
-
-     inflateBackInit() must be called first to allocate the internal state
-   and to initialize the state with the user-provided window buffer.
-   inflateBack() may then be used multiple times to inflate a complete, raw
-   deflate stream with each call.  inflateBackEnd() is then called to free the
-   allocated state.
-
-     A raw deflate stream is one with no zlib or gzip header or trailer.
-   This routine would normally be used in a utility that reads zip or gzip
-   files and writes out uncompressed files.  The utility would decode the
-   header and process the trailer on its own, hence this routine expects only
-   the raw deflate stream to decompress.  This is different from the default
-   behavior of inflate(), which expects a zlib header and trailer around the
-   deflate stream.
-
-     inflateBack() uses two subroutines supplied by the caller that are then
-   called by inflateBack() for input and output.  inflateBack() calls those
-   routines until it reads a complete deflate stream and writes out all of the
-   uncompressed data, or until it encounters an error.  The function's
-   parameters and return types are defined above in the in_func and out_func
-   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
-   number of bytes of provided input, and a pointer to that input in buf.  If
-   there is no input available, in() must return zero -- buf is ignored in that
-   case -- and inflateBack() will return a buffer error.  inflateBack() will
-   call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
-   out() should return zero on success, or non-zero on failure.  If out()
-   returns non-zero, inflateBack() will return with an error.  Neither in() nor
-   out() are permitted to change the contents of the window provided to
-   inflateBackInit(), which is also the buffer that out() uses to write from.
-   The length written by out() will be at most the window size.  Any non-zero
-   amount of input may be provided by in().
-
-     For convenience, inflateBack() can be provided input on the first call by
-   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
-   in() will be called.  Therefore strm->next_in must be initialized before
-   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
-   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
-   must also be initialized, and then if strm->avail_in is not zero, input will
-   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
-
-     The in_desc and out_desc parameters of inflateBack() is passed as the
-   first parameter of in() and out() respectively when they are called.  These
-   descriptors can be optionally used to pass any information that the caller-
-   supplied in() and out() functions need to do their job.
-
-     On return, inflateBack() will set strm->next_in and strm->avail_in to
-   pass back any unused input that was provided by the last in() call.  The
-   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
-   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
-   in the deflate stream (in which case strm->msg is set to indicate the nature
-   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
-   In the case of Z_BUF_ERROR, an input or output error can be distinguished
-   using strm->next_in which will be Z_NULL only if in() returned an error.  If
-   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
-   non-zero.  (in() will always be called before out(), so strm->next_in is
-   assured to be defined if out() returns non-zero.)  Note that inflateBack()
-   cannot return Z_OK.
-*/
-
-ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
-/*
-     All memory allocated by inflateBackInit() is freed.
-
-     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
-   state was inconsistent.
-*/
-
-ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
-/* Return flags indicating compile-time options.
-
-    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
-     1.0: size of uInt
-     3.2: size of uLong
-     5.4: size of voidpf (pointer)
-     7.6: size of z_off_t
-
-    Compiler, assembler, and debug options:
-     8: ZLIB_DEBUG
-     9: ASMV or ASMINF -- use ASM code
-     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
-     11: 0 (reserved)
-
-    One-time table building (smaller code, but not thread-safe if true):
-     12: BUILDFIXED -- build static block decoding tables when needed
-     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
-     14,15: 0 (reserved)
-
-    Library content (indicates missing functionality):
-     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
-                          deflate code when not needed)
-     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
-                    and decode gzip streams (to avoid linking crc code)
-     18-19: 0 (reserved)
-
-    Operation variations (changes in library functionality):
-     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
-     21: FASTEST -- deflate algorithm with only one, lowest compression level
-     22,23: 0 (reserved)
-
-    The sprintf variant used by gzprintf (zero is best):
-     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
-     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
-     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
-
-    Remainder:
-     27-31: 0 (reserved)
- */
+    /* for compatibility with versions < 1.0.2 */
+
+    /* basic functions */
+
+    ZEXTERN const char* ZEXPORT zlibVersion OF((void));
+    /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+       If the first character differs, the library code actually used is not
+       compatible with the zlib.h header file used by the application.  This check
+       is automatically made by deflateInit and inflateInit.
+     */
+
+    /*
+    ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+         Initializes the internal stream state for compression.  The fields
+       zalloc, zfree and opaque must be initialized before by the caller.  If
+       zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
+       allocation functions.
+
+         The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+       1 gives best speed, 9 gives best compression, 0 gives no compression at all
+       (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
+       requests a default compromise between speed and compression (currently
+       equivalent to level 6).
+
+         deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+       memory, Z_STREAM_ERROR if level is not a valid compression level, or
+       Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+       with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
+       if there is no error message.  deflateInit does not perform any compression:
+       this will be done by deflate().
+    */
+
+    ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+    /*
+        deflate compresses as much data as possible, and stops when the input
+      buffer becomes empty or the output buffer becomes full.  It may introduce
+      some output latency (reading input without producing any output) except when
+      forced to flush.
+
+        The detailed semantics are as follows.  deflate performs one or both of the
+      following actions:
+
+      - Compress more input starting at next_in and update next_in and avail_in
+        accordingly.  If not all input can be processed (because there is not
+        enough room in the output buffer), next_in and avail_in are updated and
+        processing will resume at this point for the next call of deflate().
+
+      - Generate more output starting at next_out and update next_out and avail_out
+        accordingly.  This action is forced if the parameter flush is non zero.
+        Forcing flush frequently degrades the compression ratio, so this parameter
+        should be set only when necessary.  Some output may be provided even if
+        flush is zero.
+
+        Before the call of deflate(), the application should ensure that at least
+      one of the actions is possible, by providing more input and/or consuming more
+      output, and updating avail_in or avail_out accordingly; avail_out should
+      never be zero before the call.  The application can consume the compressed
+      output when it wants, for example when the output buffer is full (avail_out
+      == 0), or after each call of deflate().  If deflate returns Z_OK and with
+      zero avail_out, it must be called again after making room in the output
+      buffer because there might be more output pending. See deflatePending(),
+      which can be used if desired to determine whether or not there is more ouput
+      in that case.
+
+        Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+      decide how much data to accumulate before producing output, in order to
+      maximize compression.
+
+        If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+      flushed to the output buffer and the output is aligned on a byte boundary, so
+      that the decompressor can get all input data available so far.  (In
+      particular avail_in is zero after the call if enough output space has been
+      provided before the call.) Flushing may degrade compression for some
+      compression algorithms and so it should be used only when necessary.  This
+      completes the current deflate block and follows it with an empty stored block
+      that is three bits plus filler bits to the next byte, followed by four bytes
+      (00 00 ff ff).
+
+        If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
+      output buffer, but the output is not aligned to a byte boundary.  All of the
+      input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
+      This completes the current deflate block and follows it with an empty fixed
+      codes block that is 10 bits long.  This assures that enough bytes are output
+      in order for the decompressor to finish the block before the empty fixed
+      codes block.
+
+        If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
+      for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
+      seven bits of the current block are held to be written as the next byte after
+      the next deflate block is completed.  In this case, the decompressor may not
+      be provided enough bits at this point in order to complete decompression of
+      the data provided so far to the compressor.  It may need to wait for the next
+      block to be emitted.  This is for advanced applications that need to control
+      the emission of deflate blocks.
+
+        If flush is set to Z_FULL_FLUSH, all output is flushed as with
+      Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+      restart from this point if previous compressed data has been damaged or if
+      random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
+      compression.
+
+        If deflate returns with avail_out == 0, this function must be called again
+      with the same value of the flush parameter and more output space (updated
+      avail_out), until the flush is complete (deflate returns with non-zero
+      avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+      avail_out is greater than six to avoid repeated flush markers due to
+      avail_out == 0 on return.
+
+        If the parameter flush is set to Z_FINISH, pending input is processed,
+      pending output is flushed and deflate returns with Z_STREAM_END if there was
+      enough output space.  If deflate returns with Z_OK or Z_BUF_ERROR, this
+      function must be called again with Z_FINISH and more output space (updated
+      avail_out) but no more input data, until it returns with Z_STREAM_END or an
+      error.  After deflate has returned Z_STREAM_END, the only possible operations
+      on the stream are deflateReset or deflateEnd.
+
+        Z_FINISH can be used in the first deflate call after deflateInit if all the
+      compression is to be done in a single step.  In order to complete in one
+      call, avail_out must be at least the value returned by deflateBound (see
+      below).  Then deflate is guaranteed to return Z_STREAM_END.  If not enough
+      output space is provided, deflate will not return Z_STREAM_END, and it must
+      be called again as described above.
+
+        deflate() sets strm->adler to the Adler-32 checksum of all input read
+      so far (that is, total_in bytes).  If a gzip stream is being generated, then
+      strm->adler will be the CRC-32 checksum of the input read so far.  (See
+      deflateInit2 below.)
+
+        deflate() may update strm->data_type if it can make a good guess about
+      the input data type (Z_BINARY or Z_TEXT).  If in doubt, the data is
+      considered binary.  This field is only for information purposes and does not
+      affect the compression algorithm in any manner.
+
+        deflate() returns Z_OK if some progress has been made (more input
+      processed or more output produced), Z_STREAM_END if all input has been
+      consumed and all output has been produced (only when flush is set to
+      Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+      if next_in or next_out was Z_NULL or the state was inadvertently written over
+      by the application), or Z_BUF_ERROR if no progress is possible (for example
+      avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not fatal, and
+      deflate() can be called again with more input and more output space to
+      continue compressing.
+    */
+
+    ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+    /*
+         All dynamically allocated data structures for this stream are freed.
+       This function discards any unprocessed input and does not flush any pending
+       output.
+
+         deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+       stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+       prematurely (some input or output was discarded).  In the error case, msg
+       may be set but then points to a static string (which must not be
+       deallocated).
+    */
+
+    /*
+    ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+         Initializes the internal stream state for decompression.  The fields
+       next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+       the caller.  In the current version of inflate, the provided input is not
+       read or consumed.  The allocation of a sliding window will be deferred to
+       the first call of inflate (if the decompression does not complete on the
+       first call).  If zalloc and zfree are set to Z_NULL, inflateInit updates
+       them to use default allocation functions.
+
+         inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+       memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+       version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+       invalid, such as a null pointer to the structure.  msg is set to null if
+       there is no error message.  inflateInit does not perform any decompression.
+       Actual decompression will be done by inflate().  So next_in, and avail_in,
+       next_out, and avail_out are unused and unchanged.  The current
+       implementation of inflateInit() does not process any header information --
+       that is deferred until inflate() is called.
+    */
+
+    ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+    /*
+        inflate decompresses as much data as possible, and stops when the input
+      buffer becomes empty or the output buffer becomes full.  It may introduce
+      some output latency (reading input without producing any output) except when
+      forced to flush.
+
+      The detailed semantics are as follows.  inflate performs one or both of the
+      following actions:
+
+      - Decompress more input starting at next_in and update next_in and avail_in
+        accordingly.  If not all input can be processed (because there is not
+        enough room in the output buffer), then next_in and avail_in are updated
+        accordingly, and processing will resume at this point for the next call of
+        inflate().
+
+      - Generate more output starting at next_out and update next_out and avail_out
+        accordingly.  inflate() provides as much output as possible, until there is
+        no more input data or no more space in the output buffer (see below about
+        the flush parameter).
+
+        Before the call of inflate(), the application should ensure that at least
+      one of the actions is possible, by providing more input and/or consuming more
+      output, and updating the next_* and avail_* values accordingly.  If the
+      caller of inflate() does not provide both available input and available
+      output space, it is possible that there will be no progress made.  The
+      application can consume the uncompressed output when it wants, for example
+      when the output buffer is full (avail_out == 0), or after each call of
+      inflate().  If inflate returns Z_OK and with zero avail_out, it must be
+      called again after making room in the output buffer because there might be
+      more output pending.
+
+        The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
+      Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
+      output as possible to the output buffer.  Z_BLOCK requests that inflate()
+      stop if and when it gets to the next deflate block boundary.  When decoding
+      the zlib or gzip format, this will cause inflate() to return immediately
+      after the header and before the first block.  When doing a raw inflate,
+      inflate() will go ahead and process the first block, and will return when it
+      gets to the end of that block, or when it runs out of data.
+
+        The Z_BLOCK option assists in appending to or combining deflate streams.
+      To assist in this, on return inflate() always sets strm->data_type to the
+      number of unused bits in the last byte taken from strm->next_in, plus 64 if
+      inflate() is currently decoding the last block in the deflate stream, plus
+      128 if inflate() returned immediately after decoding an end-of-block code or
+      decoding the complete header up to just before the first byte of the deflate
+      stream.  The end-of-block will not be indicated until all of the uncompressed
+      data from that block has been written to strm->next_out.  The number of
+      unused bits may in general be greater than seven, except when bit 7 of
+      data_type is set, in which case the number of unused bits will be less than
+      eight.  data_type is set as noted here every time inflate() returns for all
+      flush options, and so can be used to determine the amount of currently
+      consumed input in bits.
+
+        The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
+      end of each deflate block header is reached, before any actual data in that
+      block is decoded.  This allows the caller to determine the length of the
+      deflate block header for later use in random access within a deflate block.
+      256 is added to the value of strm->data_type when inflate() returns
+      immediately after reaching the end of the deflate block header.
+
+        inflate() should normally be called until it returns Z_STREAM_END or an
+      error.  However if all decompression is to be performed in a single step (a
+      single call of inflate), the parameter flush should be set to Z_FINISH.  In
+      this case all pending input is processed and all pending output is flushed;
+      avail_out must be large enough to hold all of the uncompressed data for the
+      operation to complete.  (The size of the uncompressed data may have been
+      saved by the compressor for this purpose.)  The use of Z_FINISH is not
+      required to perform an inflation in one step.  However it may be used to
+      inform inflate that a faster approach can be used for the single inflate()
+      call.  Z_FINISH also informs inflate to not maintain a sliding window if the
+      stream completes, which reduces inflate's memory footprint.  If the stream
+      does not complete, either because not all of the stream is provided or not
+      enough output space is provided, then a sliding window will be allocated and
+      inflate() can be called again to continue the operation as if Z_NO_FLUSH had
+      been used.
+
+         In this implementation, inflate() always flushes as much output as
+      possible to the output buffer, and always uses the faster approach on the
+      first call.  So the effects of the flush parameter in this implementation are
+      on the return value of inflate() as noted below, when inflate() returns early
+      when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of
+      memory for a sliding window when Z_FINISH is used.
+
+         If a preset dictionary is needed after this call (see inflateSetDictionary
+      below), inflate sets strm->adler to the Adler-32 checksum of the dictionary
+      chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+      strm->adler to the Adler-32 checksum of all output produced so far (that is,
+      total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+      below.  At the end of the stream, inflate() checks that its computed Adler-32
+      checksum is equal to that saved by the compressor and returns Z_STREAM_END
+      only if the checksum is correct.
+
+        inflate() can decompress and check either zlib-wrapped or gzip-wrapped
+      deflate data.  The header type is detected automatically, if requested when
+      initializing with inflateInit2().  Any information contained in the gzip
+      header is not retained unless inflateGetHeader() is used.  When processing
+      gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
+      produced so far.  The CRC-32 is checked against the gzip trailer, as is the
+      uncompressed length, modulo 2^32.
+
+        inflate() returns Z_OK if some progress has been made (more input processed
+      or more output produced), Z_STREAM_END if the end of the compressed data has
+      been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+      preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+      corrupted (input stream not conforming to the zlib format or incorrect check
+      value, in which case strm->msg points to a string with a more specific
+      error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+      next_in or next_out was Z_NULL, or the state was inadvertently written over
+      by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
+      if no progress was possible or if there was not enough room in the output
+      buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
+      inflate() can be called again with more input and more output space to
+      continue decompressing.  If Z_DATA_ERROR is returned, the application may
+      then call inflateSync() to look for a good compression block if a partial
+      recovery of the data is to be attempted.
+    */
+
+    ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+    /*
+         All dynamically allocated data structures for this stream are freed.
+       This function discards any unprocessed input and does not flush any pending
+       output.
+
+         inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
+       was inconsistent.
+    */
+
+    /* Advanced functions */
+
+    /*
+        The following functions are needed only in some special applications.
+    */
+
+    /*
+    ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                         int  level,
+                                         int  method,
+                                         int  windowBits,
+                                         int  memLevel,
+                                         int  strategy));
+
+         This is another version of deflateInit with more compression options.  The
+       fields zalloc, zfree and opaque must be initialized before by the caller.
+
+         The method parameter is the compression method.  It must be Z_DEFLATED in
+       this version of the library.
+
+         The windowBits parameter is the base two logarithm of the window size
+       (the size of the history buffer).  It should be in the range 8..15 for this
+       version of the library.  Larger values of this parameter result in better
+       compression at the expense of memory usage.  The default value is 15 if
+       deflateInit is used instead.
+
+         For the current implementation of deflate(), a windowBits value of 8 (a
+       window size of 256 bytes) is not supported.  As a result, a request for 8
+       will result in 9 (a 512-byte window).  In that case, providing 8 to
+       inflateInit2() will result in an error when the zlib header with 9 is
+       checked against the initialization of inflate().  The remedy is to not use 8
+       with deflateInit2() with this initialization, or at least in that case use 9
+       with inflateInit2().
+
+         windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
+       determines the window size.  deflate() will then generate raw deflate data
+       with no zlib header or trailer, and will not compute a check value.
+
+         windowBits can also be greater than 15 for optional gzip encoding.  Add
+       16 to windowBits to write a simple gzip header and trailer around the
+       compressed data instead of a zlib wrapper.  The gzip header will have no
+       file name, no extra data, no comment, no modification time (set to zero), no
+       header crc, and the operating system will be set to the appropriate value,
+       if the operating system was determined at compile time.  If a gzip stream is
+       being written, strm->adler is a CRC-32 instead of an Adler-32.
+
+         For raw deflate or gzip encoding, a request for a 256-byte window is
+       rejected as invalid, since only the zlib header provides a means of
+       transmitting the window size to the decompressor.
+
+         The memLevel parameter specifies how much memory should be allocated
+       for the internal compression state.  memLevel=1 uses minimum memory but is
+       slow and reduces compression ratio; memLevel=9 uses maximum memory for
+       optimal speed.  The default value is 8.  See zconf.h for total memory usage
+       as a function of windowBits and memLevel.
+
+         The strategy parameter is used to tune the compression algorithm.  Use the
+       value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+       filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+       string match), or Z_RLE to limit match distances to one (run-length
+       encoding).  Filtered data consists mostly of small values with a somewhat
+       random distribution.  In this case, the compression algorithm is tuned to
+       compress them better.  The effect of Z_FILTERED is to force more Huffman
+       coding and less string matching; it is somewhat intermediate between
+       Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
+       fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
+       strategy parameter only affects the compression ratio but not the
+       correctness of the compressed output even if it is not set appropriately.
+       Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
+       decoder for special applications.
+
+         deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+       memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
+       method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
+       incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
+       set to null if there is no error message.  deflateInit2 does not perform any
+       compression: this will be done by deflate().
+    */
+
+    ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, const Bytef* dictionary, uInt dictLength));
+    /*
+         Initializes the compression dictionary from the given byte sequence
+       without producing any compressed output.  When using the zlib format, this
+       function must be called immediately after deflateInit, deflateInit2 or
+       deflateReset, and before any call of deflate.  When doing raw deflate, this
+       function must be called either before any call of deflate, or immediately
+       after the completion of a deflate block, i.e. after all input has been
+       consumed and all output has been delivered when using any of the flush
+       options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH.  The
+       compressor and decompressor must use exactly the same dictionary (see
+       inflateSetDictionary).
+
+         The dictionary should consist of strings (byte sequences) that are likely
+       to be encountered later in the data to be compressed, with the most commonly
+       used strings preferably put towards the end of the dictionary.  Using a
+       dictionary is most useful when the data to be compressed is short and can be
+       predicted with good accuracy; the data can then be compressed better than
+       with the default empty dictionary.
+
+         Depending on the size of the compression data structures selected by
+       deflateInit or deflateInit2, a part of the dictionary may in effect be
+       discarded, for example if the dictionary is larger than the window size
+       provided in deflateInit or deflateInit2.  Thus the strings most likely to be
+       useful should be put at the end of the dictionary, not at the front.  In
+       addition, the current implementation of deflate will use at most the window
+       size minus 262 bytes of the provided dictionary.
+
+         Upon return of this function, strm->adler is set to the Adler-32 value
+       of the dictionary; the decompressor may later use this value to determine
+       which dictionary has been used by the compressor.  (The Adler-32 value
+       applies to the whole dictionary even if only a subset of the dictionary is
+       actually used by the compressor.) If a raw deflate was requested, then the
+       Adler-32 value is not computed and strm->adler is not set.
+
+         deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+       parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+       inconsistent (for example if deflate has already been called for this stream
+       or if not at a block boundary for raw deflate).  deflateSetDictionary does
+       not perform any compression: this will be done by deflate().
+    */
+
+    ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, Bytef* dictionary, uInt* dictLength));
+    /*
+         Returns the sliding dictionary being maintained by deflate.  dictLength is
+       set to the number of bytes in the dictionary, and that many bytes are copied
+       to dictionary.  dictionary must have enough space, where 32768 bytes is
+       always enough.  If deflateGetDictionary() is called with dictionary equal to
+       Z_NULL, then only the dictionary length is returned, and nothing is copied.
+       Similary, if dictLength is Z_NULL, then it is not set.
+
+         deflateGetDictionary() may return a length less than the window size, even
+       when more than the window size in input has been provided. It may return up
+       to 258 bytes less in that case, due to how zlib's implementation of deflate
+       manages the sliding window and lookahead for matches, where matches can be
+       up to 258 bytes long. If the application needs the last window-size bytes of
+       input, then that would need to be saved by the application outside of zlib.
+
+         deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+       stream state is inconsistent.
+    */
+
+    ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, z_streamp source));
+    /*
+         Sets the destination stream as a complete copy of the source stream.
+
+         This function can be useful when several compression strategies will be
+       tried, for example when there are several ways of pre-processing the input
+       data with a filter.  The streams that will be discarded should then be freed
+       by calling deflateEnd.  Note that deflateCopy duplicates the internal
+       compression state which can be quite large, so this strategy is slow and can
+       consume lots of memory.
+
+         deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+       enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+       (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+       destination.
+    */
+
+    ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+    /*
+         This function is equivalent to deflateEnd followed by deflateInit, but
+       does not free and reallocate the internal compression state.  The stream
+       will leave the compression level and any other attributes that may have been
+       set unchanged.
+
+         deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+       stream state was inconsistent (such as zalloc or state being Z_NULL).
+    */
+
+    ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy));
+    /*
+         Dynamically update the compression level and compression strategy.  The
+       interpretation of level and strategy is as in deflateInit2().  This can be
+       used to switch between compression and straight copy of the input data, or
+       to switch to a different kind of input data requiring a different strategy.
+       If the compression approach (which is a function of the level) or the
+       strategy is changed, and if there have been any deflate() calls since the
+       state was initialized or reset, then the input available so far is
+       compressed with the old level and strategy using deflate(strm, Z_BLOCK).
+       There are three approaches for the compression levels 0, 1..3, and 4..9
+       respectively.  The new level and strategy will take effect at the next call
+       of deflate().
+
+         If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+       not have enough output space to complete, then the parameter change will not
+       take effect.  In this case, deflateParams() can be called again with the
+       same parameters and more output space to try again.
+
+         In order to assure a change in the parameters on the first try, the
+       deflate stream should be flushed using deflate() with Z_BLOCK or other flush
+       request until strm.avail_out is not zero, before calling deflateParams().
+       Then no more input data should be provided before the deflateParams() call.
+       If this is done, the old level and strategy will be applied to the data
+       compressed before deflateParams(), and the new level and strategy will be
+       applied to the the data compressed after deflateParams().
+
+         deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
+       state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
+       there was not enough output space to complete the compression of the
+       available input data before a change in the strategy or approach.  Note that
+       in the case of a Z_BUF_ERROR, the parameters are not changed.  A return
+       value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
+       retried with more output space.
+    */
+
+    ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain));
+    /*
+         Fine tune deflate's internal compression parameters.  This should only be
+       used by someone who understands the algorithm used by zlib's deflate for
+       searching for the best matching string, and even then only by the most
+       fanatic optimizer trying to squeeze out the last compressed bit for their
+       specific input data.  Read the deflate.c source code for the meaning of the
+       max_lazy, good_length, nice_length, and max_chain parameters.
+
+         deflateTune() can be called after deflateInit() or deflateInit2(), and
+       returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+     */
+
+    ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, uLong sourceLen));
+    /*
+         deflateBound() returns an upper bound on the compressed size after
+       deflation of sourceLen bytes.  It must be called after deflateInit() or
+       deflateInit2(), and after deflateSetHeader(), if used.  This would be used
+       to allocate an output buffer for deflation in a single pass, and so would be
+       called before deflate().  If that first deflate() call is provided the
+       sourceLen input bytes, an output buffer allocated to the size returned by
+       deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed
+       to return Z_STREAM_END.  Note that it is possible for the compressed size to
+       be larger than the value returned by deflateBound() if flush options other
+       than Z_FINISH or Z_NO_FLUSH are used.
+    */
+
+    ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, unsigned* pending, int* bits));
+    /*
+         deflatePending() returns the number of bytes and bits of output that have
+       been generated, but not yet provided in the available output.  The bytes not
+       provided would be due to the available output space having being consumed.
+       The number of bits of output not provided are between 0 and 7, where they
+       await more bits to join them in order to fill out a full byte.  If pending
+       or bits are Z_NULL, then those values are not set.
+
+         deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source
+       stream state was inconsistent.
+     */
+
+    ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, int bits, int value));
+    /*
+         deflatePrime() inserts bits in the deflate output stream.  The intent
+       is that this function is used to start off the deflate output with the bits
+       leftover from a previous deflate stream when appending to it.  As such, this
+       function can only be used for raw deflate, and must be used before the first
+       deflate() call after a deflateInit2() or deflateReset().  bits must be less
+       than or equal to 16, and that many of the least significant bits of value
+       will be inserted in the output.
+
+         deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough
+       room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the
+       source stream state was inconsistent.
+    */
+
+    ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, gz_headerp head));
+    /*
+         deflateSetHeader() provides gzip header information for when a gzip
+       stream is requested by deflateInit2().  deflateSetHeader() may be called
+       after deflateInit2() or deflateReset() and before the first call of
+       deflate().  The text, time, os, extra field, name, and comment information
+       in the provided gz_header structure are written to the gzip header (xflag is
+       ignored -- the extra flags are set according to the compression level).  The
+       caller must assure that, if not Z_NULL, name and comment are terminated with
+       a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+       available there.  If hcrc is true, a gzip header crc is included.  Note that
+       the current versions of the command-line version of gzip (up through version
+       1.3.x) do not support header crc's, and will report that it is a "multi-part
+       gzip file" and give up.
+
+         If deflateSetHeader is not used, the default gzip header has text false,
+       the time set to zero, and os set to 255, with no extra, name, or comment
+       fields.  The gzip header is returned to the default state by deflateReset().
+
+         deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+       stream state was inconsistent.
+    */
+
+    /*
+    ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                         int  windowBits));
+
+         This is another version of inflateInit with an extra parameter.  The
+       fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+       before by the caller.
+
+         The windowBits parameter is the base two logarithm of the maximum window
+       size (the size of the history buffer).  It should be in the range 8..15 for
+       this version of the library.  The default value is 15 if inflateInit is used
+       instead.  windowBits must be greater than or equal to the windowBits value
+       provided to deflateInit2() while compressing, or it must be equal to 15 if
+       deflateInit2() was not used.  If a compressed stream with a larger window
+       size is given as input, inflate() will return with the error code
+       Z_DATA_ERROR instead of trying to allocate a larger window.
+
+         windowBits can also be zero to request that inflate use the window size in
+       the zlib header of the compressed stream.
+
+         windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
+       determines the window size.  inflate() will then process raw deflate data,
+       not looking for a zlib or gzip header, not generating a check value, and not
+       looking for any check values for comparison at the end of the stream.  This
+       is for use with other formats that use the deflate compressed data format
+       such as zip.  Those formats provide their own check values.  If a custom
+       format is developed using the raw deflate format for compressed data, it is
+       recommended that a check value such as an Adler-32 or a CRC-32 be applied to
+       the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+       most applications, the zlib format should be used as is.  Note that comments
+       above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+         windowBits can also be greater than 15 for optional gzip decoding.  Add
+       32 to windowBits to enable zlib and gzip decoding with automatic header
+       detection, or add 16 to decode only the gzip format (the zlib format will
+       return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+       CRC-32 instead of an Adler-32.  Unlike the gunzip utility and gzread() (see
+       below), inflate() will *not* automatically decode concatenated gzip members.
+       inflate() will return Z_STREAM_END at the end of the gzip member.  The state
+       would need to be reset to continue decoding a subsequent gzip member.  This
+       *must* be done if there is more data after a gzip member, in order for the
+       decompression to be compliant with the gzip standard (RFC 1952).
+
+         inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+       memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+       version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+       invalid, such as a null pointer to the structure.  msg is set to null if
+       there is no error message.  inflateInit2 does not perform any decompression
+       apart from possibly reading the zlib header if present: actual decompression
+       will be done by inflate().  (So next_in and avail_in may be modified, but
+       next_out and avail_out are unused and unchanged.) The current implementation
+       of inflateInit2() does not process any header information -- that is
+       deferred until inflate() is called.
+    */
+
+    ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, const Bytef* dictionary, uInt dictLength));
+    /*
+         Initializes the decompression dictionary from the given uncompressed byte
+       sequence.  This function must be called immediately after a call of inflate,
+       if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
+       can be determined from the Adler-32 value returned by that call of inflate.
+       The compressor and decompressor must use exactly the same dictionary (see
+       deflateSetDictionary).  For raw inflate, this function can be called at any
+       time to set the dictionary.  If the provided dictionary is smaller than the
+       window and there is already data in the window, then the provided dictionary
+       will amend what's there.  The application must insure that the dictionary
+       that was used for compression is provided.
+
+         inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+       parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+       inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+       expected one (incorrect Adler-32 value).  inflateSetDictionary does not
+       perform any decompression: this will be done by subsequent calls of
+       inflate().
+    */
+
+    ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, Bytef* dictionary, uInt* dictLength));
+    /*
+         Returns the sliding dictionary being maintained by inflate.  dictLength is
+       set to the number of bytes in the dictionary, and that many bytes are copied
+       to dictionary.  dictionary must have enough space, where 32768 bytes is
+       always enough.  If inflateGetDictionary() is called with dictionary equal to
+       Z_NULL, then only the dictionary length is returned, and nothing is copied.
+       Similary, if dictLength is Z_NULL, then it is not set.
+
+         inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+       stream state is inconsistent.
+    */
+
+    ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+    /*
+         Skips invalid compressed data until a possible full flush point (see above
+       for the description of deflate with Z_FULL_FLUSH) can be found, or until all
+       available input is skipped.  No output is provided.
+
+         inflateSync searches for a 00 00 FF FF pattern in the compressed data.
+       All full flush points have this pattern, but not all occurrences of this
+       pattern are full flush points.
+
+         inflateSync returns Z_OK if a possible full flush point has been found,
+       Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point
+       has been found, or Z_STREAM_ERROR if the stream structure was inconsistent.
+       In the success case, the application may save the current current value of
+       total_in which indicates where valid compressed data was found.  In the
+       error case, the application may repeatedly call inflateSync, providing more
+       input each time, until success or end of the input data.
+    */
+
+    ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, z_streamp source));
+    /*
+         Sets the destination stream as a complete copy of the source stream.
+
+         This function can be useful when randomly accessing a large stream.  The
+       first pass through the stream can periodically record the inflate state,
+       allowing restarting inflate at those points when randomly accessing the
+       stream.
+
+         inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+       enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+       (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+       destination.
+    */
+
+    ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+    /*
+         This function is equivalent to inflateEnd followed by inflateInit,
+       but does not free and reallocate the internal decompression state.  The
+       stream will keep attributes that may have been set by inflateInit2.
+
+         inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+       stream state was inconsistent (such as zalloc or state being Z_NULL).
+    */
+
+    ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, int windowBits));
+    /*
+         This function is the same as inflateReset, but it also permits changing
+       the wrap and window size requests.  The windowBits parameter is interpreted
+       the same as it is for inflateInit2.  If the window size is changed, then the
+       memory allocated for the window is freed, and the window will be reallocated
+       by inflate() if needed.
+
+         inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
+       stream state was inconsistent (such as zalloc or state being Z_NULL), or if
+       the windowBits parameter is invalid.
+    */
+
+    ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, int bits, int value));
+    /*
+         This function inserts bits in the inflate input stream.  The intent is
+       that this function is used to start inflating at a bit position in the
+       middle of a byte.  The provided bits will be used before any bytes are used
+       from next_in.  This function should only be used with raw inflate, and
+       should be used before the first inflate() call after inflateInit2() or
+       inflateReset().  bits must be less than or equal to 16, and that many of the
+       least significant bits of value will be inserted in the input.
+
+         If bits is negative, then the input stream bit buffer is emptied.  Then
+       inflatePrime() can be called again to put bits in the buffer.  This is used
+       to clear out bits leftover after feeding inflate a block description prior
+       to feeding inflate codes.
+
+         inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+       stream state was inconsistent.
+    */
+
+    ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
+    /*
+         This function returns two values, one in the lower 16 bits of the return
+       value, and the other in the remaining upper bits, obtained by shifting the
+       return value down 16 bits.  If the upper value is -1 and the lower value is
+       zero, then inflate() is currently decoding information outside of a block.
+       If the upper value is -1 and the lower value is non-zero, then inflate is in
+       the middle of a stored block, with the lower value equaling the number of
+       bytes from the input remaining to copy.  If the upper value is not -1, then
+       it is the number of bits back from the current bit position in the input of
+       the code (literal or length/distance pair) currently being processed.  In
+       that case the lower value is the number of bytes already emitted for that
+       code.
+
+         A code is being processed if inflate is waiting for more input to complete
+       decoding of the code, or if it has completed decoding but is waiting for
+       more output space to write the literal or match data.
+
+         inflateMark() is used to mark locations in the input data for random
+       access, which may be at bit positions, and to note those cases where the
+       output of a code may span boundaries of random access blocks.  The current
+       location in the input stream can be determined from avail_in and data_type
+       as noted in the description for the Z_BLOCK flush parameter for inflate.
+
+         inflateMark returns the value noted above, or -65536 if the provided
+       source stream state was inconsistent.
+    */
+
+    ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, gz_headerp head));
+    /*
+         inflateGetHeader() requests that gzip header information be stored in the
+       provided gz_header structure.  inflateGetHeader() may be called after
+       inflateInit2() or inflateReset(), and before the first call of inflate().
+       As inflate() processes the gzip stream, head->done is zero until the header
+       is completed, at which time head->done is set to one.  If a zlib stream is
+       being decoded, then head->done is set to -1 to indicate that there will be
+       no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
+       used to force inflate() to return immediately after header processing is
+       complete and before any actual data is decompressed.
+
+         The text, time, xflags, and os fields are filled in with the gzip header
+       contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+       was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+       contains the maximum number of bytes to write to extra.  Once done is true,
+       extra_len contains the actual extra field length, and extra contains the
+       extra field, or that field truncated if extra_max is less than extra_len.
+       If name is not Z_NULL, then up to name_max characters are written there,
+       terminated with a zero unless the length is greater than name_max.  If
+       comment is not Z_NULL, then up to comm_max characters are written there,
+       terminated with a zero unless the length is greater than comm_max.  When any
+       of extra, name, or comment are not Z_NULL and the respective field is not
+       present in the header, then that field is set to Z_NULL to signal its
+       absence.  This allows the use of deflateSetHeader() with the returned
+       structure to duplicate the header.  However if those fields are set to
+       allocated memory, then the application will need to save those pointers
+       elsewhere so that they can be eventually freed.
+
+         If inflateGetHeader is not used, then the header information is simply
+       discarded.  The header is always checked for validity, including the header
+       CRC if present.  inflateReset() will reset the process to discard the header
+       information.  The application would need to call inflateGetHeader() again to
+       retrieve the header from the next gzip stream.
+
+         inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+       stream state was inconsistent.
+    */
+
+    /*
+    ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                            unsigned char FAR *window));
+
+         Initialize the internal stream state for decompression using inflateBack()
+       calls.  The fields zalloc, zfree and opaque in strm must be initialized
+       before the call.  If zalloc and zfree are Z_NULL, then the default library-
+       derived memory allocation routines are used.  windowBits is the base two
+       logarithm of the window size, in the range 8..15.  window is a caller
+       supplied buffer of that size.  Except for special applications where it is
+       assured that deflate was used with small window sizes, windowBits must be 15
+       and a 32K byte window must be supplied to be able to decompress general
+       deflate streams.
+
+         See inflateBack() for the usage of these routines.
+
+         inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+       the parameters are invalid, Z_MEM_ERROR if the internal state could not be
+       allocated, or Z_VERSION_ERROR if the version of the library does not match
+       the version of the header file.
+    */
+
+    typedef unsigned(*in_func) OF((void FAR*, z_const unsigned char FAR* FAR*));
+    typedef int(*out_func) OF((void FAR*, unsigned char FAR*, unsigned));
+
+    ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, in_func in, void FAR* in_desc, out_func out, void FAR* out_desc));
+    /*
+         inflateBack() does a raw inflate with a single call using a call-back
+       interface for input and output.  This is potentially more efficient than
+       inflate() for file i/o applications, in that it avoids copying between the
+       output and the sliding window by simply making the window itself the output
+       buffer.  inflate() can be faster on modern CPUs when used with large
+       buffers.  inflateBack() trusts the application to not change the output
+       buffer passed by the output function, at least until inflateBack() returns.
+
+         inflateBackInit() must be called first to allocate the internal state
+       and to initialize the state with the user-provided window buffer.
+       inflateBack() may then be used multiple times to inflate a complete, raw
+       deflate stream with each call.  inflateBackEnd() is then called to free the
+       allocated state.
+
+         A raw deflate stream is one with no zlib or gzip header or trailer.
+       This routine would normally be used in a utility that reads zip or gzip
+       files and writes out uncompressed files.  The utility would decode the
+       header and process the trailer on its own, hence this routine expects only
+       the raw deflate stream to decompress.  This is different from the default
+       behavior of inflate(), which expects a zlib header and trailer around the
+       deflate stream.
+
+         inflateBack() uses two subroutines supplied by the caller that are then
+       called by inflateBack() for input and output.  inflateBack() calls those
+       routines until it reads a complete deflate stream and writes out all of the
+       uncompressed data, or until it encounters an error.  The function's
+       parameters and return types are defined above in the in_func and out_func
+       typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+       number of bytes of provided input, and a pointer to that input in buf.  If
+       there is no input available, in() must return zero -- buf is ignored in that
+       case -- and inflateBack() will return a buffer error.  inflateBack() will
+       call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
+       out() should return zero on success, or non-zero on failure.  If out()
+       returns non-zero, inflateBack() will return with an error.  Neither in() nor
+       out() are permitted to change the contents of the window provided to
+       inflateBackInit(), which is also the buffer that out() uses to write from.
+       The length written by out() will be at most the window size.  Any non-zero
+       amount of input may be provided by in().
+
+         For convenience, inflateBack() can be provided input on the first call by
+       setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+       in() will be called.  Therefore strm->next_in must be initialized before
+       calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+       immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+       must also be initialized, and then if strm->avail_in is not zero, input will
+       initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
+
+         The in_desc and out_desc parameters of inflateBack() is passed as the
+       first parameter of in() and out() respectively when they are called.  These
+       descriptors can be optionally used to pass any information that the caller-
+       supplied in() and out() functions need to do their job.
+
+         On return, inflateBack() will set strm->next_in and strm->avail_in to
+       pass back any unused input that was provided by the last in() call.  The
+       return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+       if in() or out() returned an error, Z_DATA_ERROR if there was a format error
+       in the deflate stream (in which case strm->msg is set to indicate the nature
+       of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
+       In the case of Z_BUF_ERROR, an input or output error can be distinguished
+       using strm->next_in which will be Z_NULL only if in() returned an error.  If
+       strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
+       non-zero.  (in() will always be called before out(), so strm->next_in is
+       assured to be defined if out() returns non-zero.)  Note that inflateBack()
+       cannot return Z_OK.
+    */
+
+    ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+    /*
+         All memory allocated by inflateBackInit() is freed.
+
+         inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+       state was inconsistent.
+    */
+
+    ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+    /* Return flags indicating compile-time options.
+
+        Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+         1.0: size of uInt
+         3.2: size of uLong
+         5.4: size of voidpf (pointer)
+         7.6: size of z_off_t
+
+        Compiler, assembler, and debug options:
+         8: ZLIB_DEBUG
+         9: ASMV or ASMINF -- use ASM code
+         10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+         11: 0 (reserved)
+
+        One-time table building (smaller code, but not thread-safe if true):
+         12: BUILDFIXED -- build static block decoding tables when needed
+         13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+         14,15: 0 (reserved)
+
+        Library content (indicates missing functionality):
+         16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                              deflate code when not needed)
+         17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                        and decode gzip streams (to avoid linking crc code)
+         18-19: 0 (reserved)
+
+        Operation variations (changes in library functionality):
+         20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+         21: FASTEST -- deflate algorithm with only one, lowest compression level
+         22,23: 0 (reserved)
+
+        The sprintf variant used by gzprintf (zero is best):
+         24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+         25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+         26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+        Remainder:
+         27-31: 0 (reserved)
+     */
 
 #ifndef Z_SOLO
 
-                        /* utility functions */
-
-/*
-     The following utility functions are implemented on top of the basic
-   stream-oriented functions.  To simplify the interface, some default options
-   are assumed (compression level and memory usage, standard memory allocation
-   functions).  The source code of these utility functions can be modified if
-   you need special options.
-*/
-
-ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
-                                 const Bytef *source, uLong sourceLen));
-/*
-     Compresses the source buffer into the destination buffer.  sourceLen is
-   the byte length of the source buffer.  Upon entry, destLen is the total size
-   of the destination buffer, which must be at least the value returned by
-   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
-   compressed data.  compress() is equivalent to compress2() with a level
-   parameter of Z_DEFAULT_COMPRESSION.
-
-     compress returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_BUF_ERROR if there was not enough room in the output
-   buffer.
-*/
-
-ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
-                                  const Bytef *source, uLong sourceLen,
-                                  int level));
-/*
-     Compresses the source buffer into the destination buffer.  The level
-   parameter has the same meaning as in deflateInit.  sourceLen is the byte
-   length of the source buffer.  Upon entry, destLen is the total size of the
-   destination buffer, which must be at least the value returned by
-   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
-   compressed data.
-
-     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
-   Z_STREAM_ERROR if the level parameter is invalid.
-*/
-
-ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
-/*
-     compressBound() returns an upper bound on the compressed size after
-   compress() or compress2() on sourceLen bytes.  It would be used before a
-   compress() or compress2() call to allocate the destination buffer.
-*/
-
-ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
-                                   const Bytef *source, uLong sourceLen));
-/*
-     Decompresses the source buffer into the destination buffer.  sourceLen is
-   the byte length of the source buffer.  Upon entry, destLen is the total size
-   of the destination buffer, which must be large enough to hold the entire
-   uncompressed data.  (The size of the uncompressed data must have been saved
-   previously by the compressor and transmitted to the decompressor by some
-   mechanism outside the scope of this compression library.) Upon exit, destLen
-   is the actual size of the uncompressed data.
-
-     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_BUF_ERROR if there was not enough room in the output
-   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
-   the case where there is not enough room, uncompress() will fill the output
-   buffer with the uncompressed data up to that point.
-*/
-
-ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest,   uLongf *destLen,
-                                    const Bytef *source, uLong *sourceLen));
-/*
-     Same as uncompress, except that sourceLen is a pointer, where the
-   length of the source is *sourceLen.  On return, *sourceLen is the number of
-   source bytes consumed.
-*/
-
-                        /* gzip file access functions */
-
-/*
-     This library supports reading and writing files in gzip (.gz) format with
-   an interface similar to that of stdio, using the functions that start with
-   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
-   wrapper, documented in RFC 1952, wrapped around a deflate stream.
-*/
-
-typedef struct gzFile_s *gzFile;    /* semi-opaque gzip file descriptor */
-
-/*
-ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
-
-     Open the gzip (.gz) file at path for reading and decompressing, or
-   compressing and writing.  The mode parameter is as in fopen ("rb" or "wb")
-   but can also include a compression level ("wb9") or a strategy: 'f' for
-   filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h",
-   'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression
-   as in "wb9F".  (See the description of deflateInit2 for more information
-   about the strategy parameter.)  'T' will request transparent writing or
-   appending with no compression and not using the gzip format.
-
-     "a" can be used instead of "w" to request that the gzip stream that will
-   be written be appended to the file.  "+" will result in an error, since
-   reading and writing to the same gzip file is not supported.  The addition of
-   "x" when writing will create the file exclusively, which fails if the file
-   already exists.  On systems that support it, the addition of "e" when
-   reading or writing will set the flag to close the file on an execve() call.
-
-     These functions, as well as gzip, will read and decode a sequence of gzip
-   streams in a file.  The append function of gzopen() can be used to create
-   such a file.  (Also see gzflush() for another way to do this.)  When
-   appending, gzopen does not test whether the file begins with a gzip stream,
-   nor does it look for the end of the gzip streams to begin appending.  gzopen
-   will simply append a gzip stream to the existing file.
-
-     gzopen can be used to read a file which is not in gzip format; in this
-   case gzread will directly read from the file without decompression.  When
-   reading, this will be detected automatically by looking for the magic two-
-   byte gzip header.
-
-     gzopen returns NULL if the file could not be opened, if there was
-   insufficient memory to allocate the gzFile state, or if an invalid mode was
-   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
-   errno can be checked to determine if the reason gzopen failed was that the
-   file could not be opened.
-*/
-
-ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
-/*
-     Associate a gzFile with the file descriptor fd.  File descriptors are
-   obtained from calls like open, dup, creat, pipe or fileno (if the file has
-   been previously opened with fopen).  The mode parameter is as in gzopen.
-
-     The next call of gzclose on the returned gzFile will also close the file
-   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
-   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
-   mode);.  The duplicated descriptor should be saved to avoid a leak, since
-   gzdopen does not close fd if it fails.  If you are using fileno() to get the
-   file descriptor from a FILE *, then you will have to use dup() to avoid
-   double-close()ing the file descriptor.  Both gzclose() and fclose() will
-   close the associated file descriptor, so they need to have different file
-   descriptors.
-
-     gzdopen returns NULL if there was insufficient memory to allocate the
-   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
-   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
-   used until the next gz* read, write, seek, or close operation, so gzdopen
-   will not detect if fd is invalid (unless fd is -1).
-*/
-
-ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
-/*
-     Set the internal buffer size used by this library's functions for file to
-   size.  The default buffer size is 8192 bytes.  This function must be called
-   after gzopen() or gzdopen(), and before any other calls that read or write
-   the file.  The buffer memory allocation is always deferred to the first read
-   or write.  Three times that size in buffer space is allocated.  A larger
-   buffer size of, for example, 64K or 128K bytes will noticeably increase the
-   speed of decompression (reading).
-
-     The new buffer size also affects the maximum length for gzprintf().
-
-     gzbuffer() returns 0 on success, or -1 on failure, such as being called
-   too late.
-*/
-
-ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
-/*
-     Dynamically update the compression level and strategy for file.  See the
-   description of deflateInit2 for the meaning of these parameters. Previously
-   provided data is flushed before applying the parameter changes.
-
-     gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
-   opened for writing, Z_ERRNO if there is an error writing the flushed data,
-   or Z_MEM_ERROR if there is a memory allocation error.
-*/
-
-ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
-/*
-     Read and decompress up to len uncompressed bytes from file into buf.  If
-   the input file is not in gzip format, gzread copies the given number of
-   bytes into the buffer directly from the file.
-
-     After reaching the end of a gzip stream in the input, gzread will continue
-   to read, looking for another gzip stream.  Any number of gzip streams may be
-   concatenated in the input file, and will all be decompressed by gzread().
-   If something other than a gzip stream is encountered after a gzip stream,
-   that remaining trailing garbage is ignored (and no error is returned).
-
-     gzread can be used to read a gzip file that is being concurrently written.
-   Upon reaching the end of the input, gzread will return with the available
-   data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
-   gzclearerr can be used to clear the end of file indicator in order to permit
-   gzread to be tried again.  Z_OK indicates that a gzip stream was completed
-   on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
-   middle of a gzip stream.  Note that gzread does not return -1 in the event
-   of an incomplete gzip stream.  This error is deferred until gzclose(), which
-   will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
-   stream.  Alternatively, gzerror can be used before gzclose to detect this
-   case.
-
-     gzread returns the number of uncompressed bytes actually read, less than
-   len for end of file, or -1 for error.  If len is too large to fit in an int,
-   then nothing is read, -1 is returned, and the error state is set to
-   Z_STREAM_ERROR.
-*/
-
-ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
-                                     gzFile file));
-/*
-     Read and decompress up to nitems items of size size from file into buf,
-   otherwise operating as gzread() does.  This duplicates the interface of
-   stdio's fread(), with size_t request and return types.  If the library
-   defines size_t, then z_size_t is identical to size_t.  If not, then z_size_t
-   is an unsigned integer type that can contain a pointer.
-
-     gzfread() returns the number of full items read of size size, or zero if
-   the end of the file was reached and a full item could not be read, or if
-   there was an error.  gzerror() must be consulted if zero is returned in
-   order to determine if there was an error.  If the multiplication of size and
-   nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
-   is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
-
-     In the event that the end of file is reached and only a partial item is
-   available at the end, i.e. the remaining uncompressed data length is not a
-   multiple of size, then the final partial item is nevetheless read into buf
-   and the end-of-file flag is set.  The length of the partial item read is not
-   provided, but could be inferred from the result of gztell().  This behavior
-   is the same as the behavior of fread() implementations in common libraries,
-   but it prevents the direct use of gzfread() to read a concurrently written
-   file, reseting and retrying on end-of-file, when size is not 1.
-*/
-
-ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len));
-/*
-     Compress and write the len uncompressed bytes at buf to file. gzwrite
-   returns the number of uncompressed bytes written or 0 in case of error.
-*/
-
-ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
-                                      z_size_t nitems, gzFile file));
-/*
-     Compress and write nitems items of size size from buf to file, duplicating
-   the interface of stdio's fwrite(), with size_t request and return types.  If
-   the library defines size_t, then z_size_t is identical to size_t.  If not,
-   then z_size_t is an unsigned integer type that can contain a pointer.
-
-     gzfwrite() returns the number of full items written of size size, or zero
-   if there was an error.  If the multiplication of size and nitems overflows,
-   i.e. the product does not fit in a z_size_t, then nothing is written, zero
-   is returned, and the error state is set to Z_STREAM_ERROR.
-*/
-
-ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
-/*
-     Convert, format, compress, and write the arguments (...) to file under
-   control of the string format, as in fprintf.  gzprintf returns the number of
-   uncompressed bytes actually written, or a negative zlib error code in case
-   of error.  The number of uncompressed bytes written is limited to 8191, or
-   one less than the buffer size given to gzbuffer().  The caller should assure
-   that this limit is not exceeded.  If it is exceeded, then gzprintf() will
-   return an error (0) with nothing written.  In this case, there may also be a
-   buffer overflow with unpredictable consequences, which is possible only if
-   zlib was compiled with the insecure functions sprintf() or vsprintf(),
-   because the secure snprintf() or vsnprintf() functions were not available.
-   This can be determined using zlibCompileFlags().
-*/
-
-ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
-/*
-     Compress and write the given null-terminated string s to file, excluding
-   the terminating null character.
-
-     gzputs returns the number of characters written, or -1 in case of error.
-*/
-
-ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
-/*
-     Read and decompress bytes from file into buf, until len-1 characters are
-   read, or until a newline character is read and transferred to buf, or an
-   end-of-file condition is encountered.  If any characters are read or if len
-   is one, the string is terminated with a null character.  If no characters
-   are read due to an end-of-file or len is less than one, then the buffer is
-   left untouched.
-
-     gzgets returns buf which is a null-terminated string, or it returns NULL
-   for end-of-file or in case of error.  If there was an error, the contents at
-   buf are indeterminate.
-*/
-
-ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
-/*
-     Compress and write c, converted to an unsigned char, into file.  gzputc
-   returns the value that was written, or -1 in case of error.
-*/
-
-ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
-/*
-     Read and decompress one byte from file.  gzgetc returns this byte or -1
-   in case of end of file or error.  This is implemented as a macro for speed.
-   As such, it does not do all of the checking the other functions do.  I.e.
-   it does not check to see if file is NULL, nor whether the structure file
-   points to has been clobbered or not.
-*/
-
-ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
-/*
-     Push c back onto the stream for file to be read as the first character on
-   the next read.  At least one character of push-back is always allowed.
-   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
-   fail if c is -1, and may fail if a character has been pushed but not read
-   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
-   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
-   The pushed character will be discarded if the stream is repositioned with
-   gzseek() or gzrewind().
-*/
-
-ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
-/*
-     Flush all pending output to file.  The parameter flush is as in the
-   deflate() function.  The return value is the zlib error number (see function
-   gzerror below).  gzflush is only permitted when writing.
-
-     If the flush parameter is Z_FINISH, the remaining data is written and the
-   gzip stream is completed in the output.  If gzwrite() is called again, a new
-   gzip stream will be started in the output.  gzread() is able to read such
-   concatenated gzip streams.
-
-     gzflush should be called only when strictly necessary because it will
-   degrade compression if called too often.
-*/
-
-/*
-ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
-                                   z_off_t offset, int whence));
-
-     Set the starting position to offset relative to whence for the next gzread
-   or gzwrite on file.  The offset represents a number of bytes in the
-   uncompressed data stream.  The whence parameter is defined as in lseek(2);
-   the value SEEK_END is not supported.
-
-     If the file is opened for reading, this function is emulated but can be
-   extremely slow.  If the file is opened for writing, only forward seeks are
-   supported; gzseek then compresses a sequence of zeroes up to the new
-   starting position.
-
-     gzseek returns the resulting offset location as measured in bytes from
-   the beginning of the uncompressed stream, or -1 in case of error, in
-   particular if the file is opened for writing and the new starting position
-   would be before the current position.
-*/
-
-ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
-/*
-     Rewind file. This function is supported only for reading.
-
-     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET).
-*/
-
-/*
-ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
-
-     Return the starting position for the next gzread or gzwrite on file.
-   This position represents a number of bytes in the uncompressed data stream,
-   and is zero when starting, even if appending or reading a gzip stream from
-   the middle of a file using gzdopen().
-
-     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
-*/
-
-/*
-ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
-
-     Return the current compressed (actual) read or write offset of file.  This
-   offset includes the count of bytes that precede the gzip stream, for example
-   when appending or when using gzdopen() for reading.  When reading, the
-   offset does not include as yet unused buffered input.  This information can
-   be used for a progress indicator.  On error, gzoffset() returns -1.
-*/
-
-ZEXTERN int ZEXPORT gzeof OF((gzFile file));
-/*
-     Return true (1) if the end-of-file indicator for file has been set while
-   reading, false (0) otherwise.  Note that the end-of-file indicator is set
-   only if the read tried to go past the end of the input, but came up short.
-   Therefore, just like feof(), gzeof() may return false even if there is no
-   more data to read, in the event that the last read request was for the exact
-   number of bytes remaining in the input file.  This will happen if the input
-   file size is an exact multiple of the buffer size.
-
-     If gzeof() returns true, then the read functions will return no more data,
-   unless the end-of-file indicator is reset by gzclearerr() and the input file
-   has grown since the previous end of file was detected.
-*/
-
-ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
-/*
-     Return true (1) if file is being copied directly while reading, or false
-   (0) if file is a gzip stream being decompressed.
-
-     If the input file is empty, gzdirect() will return true, since the input
-   does not contain a gzip stream.
-
-     If gzdirect() is used immediately after gzopen() or gzdopen() it will
-   cause buffers to be allocated to allow reading the file to determine if it
-   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
-   gzdirect().
-
-     When writing, gzdirect() returns true (1) if transparent writing was
-   requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
-   gzdirect() is not needed when writing.  Transparent writing must be
-   explicitly requested, so the application already knows the answer.  When
-   linking statically, using gzdirect() will include all of the zlib code for
-   gzip file reading and decompression, which may not be desired.)
-*/
-
-ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
-/*
-     Flush all pending output for file, if necessary, close file and
-   deallocate the (de)compression state.  Note that once file is closed, you
-   cannot call gzerror with file, since its structures have been deallocated.
-   gzclose must not be called more than once on the same file, just as free
-   must not be called more than once on the same allocation.
-
-     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
-   file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
-   last read ended in the middle of a gzip stream, or Z_OK on success.
-*/
-
-ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
-ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
-/*
-     Same as gzclose(), but gzclose_r() is only for use when reading, and
-   gzclose_w() is only for use when writing or appending.  The advantage to
-   using these instead of gzclose() is that they avoid linking in zlib
-   compression or decompression code that is not used when only reading or only
-   writing respectively.  If gzclose() is used, then both compression and
-   decompression code will be included the application when linking to a static
-   zlib library.
-*/
-
-ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
-/*
-     Return the error message for the last error which occurred on file.
-   errnum is set to zlib error number.  If an error occurred in the file system
-   and not in the compression library, errnum is set to Z_ERRNO and the
-   application may consult errno to get the exact error code.
-
-     The application must not modify the returned string.  Future calls to
-   this function may invalidate the previously returned string.  If file is
-   closed, then the string previously returned by gzerror will no longer be
-   available.
-
-     gzerror() should be used to distinguish errors from end-of-file for those
-   functions above that do not distinguish those cases in their return values.
-*/
-
-ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
-/*
-     Clear the error and end-of-file flags for file.  This is analogous to the
-   clearerr() function in stdio.  This is useful for continuing to read a gzip
-   file that is being written concurrently.
-*/
+    /* utility functions */
+
+    /*
+         The following utility functions are implemented on top of the basic
+       stream-oriented functions.  To simplify the interface, some default options
+       are assumed (compression level and memory usage, standard memory allocation
+       functions).  The source code of these utility functions can be modified if
+       you need special options.
+    */
+
+    ZEXTERN int ZEXPORT compress OF((Bytef * dest, uLongf* destLen, const Bytef* source, uLong sourceLen));
+    /*
+         Compresses the source buffer into the destination buffer.  sourceLen is
+       the byte length of the source buffer.  Upon entry, destLen is the total size
+       of the destination buffer, which must be at least the value returned by
+       compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+       compressed data.  compress() is equivalent to compress2() with a level
+       parameter of Z_DEFAULT_COMPRESSION.
+
+         compress returns Z_OK if success, Z_MEM_ERROR if there was not
+       enough memory, Z_BUF_ERROR if there was not enough room in the output
+       buffer.
+    */
+
+    ZEXTERN int ZEXPORT compress2 OF((Bytef * dest, uLongf* destLen, const Bytef* source, uLong sourceLen, int level));
+    /*
+         Compresses the source buffer into the destination buffer.  The level
+       parameter has the same meaning as in deflateInit.  sourceLen is the byte
+       length of the source buffer.  Upon entry, destLen is the total size of the
+       destination buffer, which must be at least the value returned by
+       compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+       compressed data.
+
+         compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+       memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+       Z_STREAM_ERROR if the level parameter is invalid.
+    */
+
+    ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+    /*
+         compressBound() returns an upper bound on the compressed size after
+       compress() or compress2() on sourceLen bytes.  It would be used before a
+       compress() or compress2() call to allocate the destination buffer.
+    */
+
+    ZEXTERN int ZEXPORT uncompress OF((Bytef * dest, uLongf* destLen, const Bytef* source, uLong sourceLen));
+    /*
+         Decompresses the source buffer into the destination buffer.  sourceLen is
+       the byte length of the source buffer.  Upon entry, destLen is the total size
+       of the destination buffer, which must be large enough to hold the entire
+       uncompressed data.  (The size of the uncompressed data must have been saved
+       previously by the compressor and transmitted to the decompressor by some
+       mechanism outside the scope of this compression library.) Upon exit, destLen
+       is the actual size of the uncompressed data.
+
+         uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+       enough memory, Z_BUF_ERROR if there was not enough room in the output
+       buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
+       the case where there is not enough room, uncompress() will fill the output
+       buffer with the uncompressed data up to that point.
+    */
+
+    ZEXTERN int ZEXPORT uncompress2 OF((Bytef * dest, uLongf* destLen, const Bytef* source, uLong* sourceLen));
+    /*
+         Same as uncompress, except that sourceLen is a pointer, where the
+       length of the source is *sourceLen.  On return, *sourceLen is the number of
+       source bytes consumed.
+    */
+
+    /* gzip file access functions */
+
+    /*
+         This library supports reading and writing files in gzip (.gz) format with
+       an interface similar to that of stdio, using the functions that start with
+       "gz".  The gzip format is different from the zlib format.  gzip is a gzip
+       wrapper, documented in RFC 1952, wrapped around a deflate stream.
+    */
+
+    typedef struct gzFile_s* gzFile; /* semi-opaque gzip file descriptor */
+
+    /*
+    ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+
+         Open the gzip (.gz) file at path for reading and decompressing, or
+       compressing and writing.  The mode parameter is as in fopen ("rb" or "wb")
+       but can also include a compression level ("wb9") or a strategy: 'f' for
+       filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h",
+       'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression
+       as in "wb9F".  (See the description of deflateInit2 for more information
+       about the strategy parameter.)  'T' will request transparent writing or
+       appending with no compression and not using the gzip format.
+
+         "a" can be used instead of "w" to request that the gzip stream that will
+       be written be appended to the file.  "+" will result in an error, since
+       reading and writing to the same gzip file is not supported.  The addition of
+       "x" when writing will create the file exclusively, which fails if the file
+       already exists.  On systems that support it, the addition of "e" when
+       reading or writing will set the flag to close the file on an execve() call.
+
+         These functions, as well as gzip, will read and decode a sequence of gzip
+       streams in a file.  The append function of gzopen() can be used to create
+       such a file.  (Also see gzflush() for another way to do this.)  When
+       appending, gzopen does not test whether the file begins with a gzip stream,
+       nor does it look for the end of the gzip streams to begin appending.  gzopen
+       will simply append a gzip stream to the existing file.
+
+         gzopen can be used to read a file which is not in gzip format; in this
+       case gzread will directly read from the file without decompression.  When
+       reading, this will be detected automatically by looking for the magic two-
+       byte gzip header.
+
+         gzopen returns NULL if the file could not be opened, if there was
+       insufficient memory to allocate the gzFile state, or if an invalid mode was
+       specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
+       errno can be checked to determine if the reason gzopen failed was that the
+       file could not be opened.
+    */
+
+    ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char* mode));
+    /*
+         Associate a gzFile with the file descriptor fd.  File descriptors are
+       obtained from calls like open, dup, creat, pipe or fileno (if the file has
+       been previously opened with fopen).  The mode parameter is as in gzopen.
+
+         The next call of gzclose on the returned gzFile will also close the file
+       descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
+       fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
+       mode);.  The duplicated descriptor should be saved to avoid a leak, since
+       gzdopen does not close fd if it fails.  If you are using fileno() to get the
+       file descriptor from a FILE *, then you will have to use dup() to avoid
+       double-close()ing the file descriptor.  Both gzclose() and fclose() will
+       close the associated file descriptor, so they need to have different file
+       descriptors.
+
+         gzdopen returns NULL if there was insufficient memory to allocate the
+       gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
+       provided, or '+' was provided), or if fd is -1.  The file descriptor is not
+       used until the next gz* read, write, seek, or close operation, so gzdopen
+       will not detect if fd is invalid (unless fd is -1).
+    */
+
+    ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
+    /*
+         Set the internal buffer size used by this library's functions for file to
+       size.  The default buffer size is 8192 bytes.  This function must be called
+       after gzopen() or gzdopen(), and before any other calls that read or write
+       the file.  The buffer memory allocation is always deferred to the first read
+       or write.  Three times that size in buffer space is allocated.  A larger
+       buffer size of, for example, 64K or 128K bytes will noticeably increase the
+       speed of decompression (reading).
+
+         The new buffer size also affects the maximum length for gzprintf().
+
+         gzbuffer() returns 0 on success, or -1 on failure, such as being called
+       too late.
+    */
+
+    ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+    /*
+         Dynamically update the compression level and strategy for file.  See the
+       description of deflateInit2 for the meaning of these parameters. Previously
+       provided data is flushed before applying the parameter changes.
+
+         gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
+       opened for writing, Z_ERRNO if there is an error writing the flushed data,
+       or Z_MEM_ERROR if there is a memory allocation error.
+    */
+
+    ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+    /*
+         Read and decompress up to len uncompressed bytes from file into buf.  If
+       the input file is not in gzip format, gzread copies the given number of
+       bytes into the buffer directly from the file.
+
+         After reaching the end of a gzip stream in the input, gzread will continue
+       to read, looking for another gzip stream.  Any number of gzip streams may be
+       concatenated in the input file, and will all be decompressed by gzread().
+       If something other than a gzip stream is encountered after a gzip stream,
+       that remaining trailing garbage is ignored (and no error is returned).
+
+         gzread can be used to read a gzip file that is being concurrently written.
+       Upon reaching the end of the input, gzread will return with the available
+       data.  If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then
+       gzclearerr can be used to clear the end of file indicator in order to permit
+       gzread to be tried again.  Z_OK indicates that a gzip stream was completed
+       on the last gzread.  Z_BUF_ERROR indicates that the input file ended in the
+       middle of a gzip stream.  Note that gzread does not return -1 in the event
+       of an incomplete gzip stream.  This error is deferred until gzclose(), which
+       will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip
+       stream.  Alternatively, gzerror can be used before gzclose to detect this
+       case.
+
+         gzread returns the number of uncompressed bytes actually read, less than
+       len for end of file, or -1 for error.  If len is too large to fit in an int,
+       then nothing is read, -1 is returned, and the error state is set to
+       Z_STREAM_ERROR.
+    */
+
+    ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, gzFile file));
+    /*
+         Read and decompress up to nitems items of size size from file into buf,
+       otherwise operating as gzread() does.  This duplicates the interface of
+       stdio's fread(), with size_t request and return types.  If the library
+       defines size_t, then z_size_t is identical to size_t.  If not, then z_size_t
+       is an unsigned integer type that can contain a pointer.
+
+         gzfread() returns the number of full items read of size size, or zero if
+       the end of the file was reached and a full item could not be read, or if
+       there was an error.  gzerror() must be consulted if zero is returned in
+       order to determine if there was an error.  If the multiplication of size and
+       nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
+       is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
+
+         In the event that the end of file is reached and only a partial item is
+       available at the end, i.e. the remaining uncompressed data length is not a
+       multiple of size, then the final partial item is nevetheless read into buf
+       and the end-of-file flag is set.  The length of the partial item read is not
+       provided, but could be inferred from the result of gztell().  This behavior
+       is the same as the behavior of fread() implementations in common libraries,
+       but it prevents the direct use of gzfread() to read a concurrently written
+       file, reseting and retrying on end-of-file, when size is not 1.
+    */
+
+    ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len));
+    /*
+         Compress and write the len uncompressed bytes at buf to file. gzwrite
+       returns the number of uncompressed bytes written or 0 in case of error.
+    */
+
+    ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, z_size_t nitems, gzFile file));
+    /*
+         Compress and write nitems items of size size from buf to file, duplicating
+       the interface of stdio's fwrite(), with size_t request and return types.  If
+       the library defines size_t, then z_size_t is identical to size_t.  If not,
+       then z_size_t is an unsigned integer type that can contain a pointer.
+
+         gzfwrite() returns the number of full items written of size size, or zero
+       if there was an error.  If the multiplication of size and nitems overflows,
+       i.e. the product does not fit in a z_size_t, then nothing is written, zero
+       is returned, and the error state is set to Z_STREAM_ERROR.
+    */
+
+    ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char* format, ...));
+    /*
+         Convert, format, compress, and write the arguments (...) to file under
+       control of the string format, as in fprintf.  gzprintf returns the number of
+       uncompressed bytes actually written, or a negative zlib error code in case
+       of error.  The number of uncompressed bytes written is limited to 8191, or
+       one less than the buffer size given to gzbuffer().  The caller should assure
+       that this limit is not exceeded.  If it is exceeded, then gzprintf() will
+       return an error (0) with nothing written.  In this case, there may also be a
+       buffer overflow with unpredictable consequences, which is possible only if
+       zlib was compiled with the insecure functions sprintf() or vsprintf(),
+       because the secure snprintf() or vsnprintf() functions were not available.
+       This can be determined using zlibCompileFlags().
+    */
+
+    ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char* s));
+    /*
+         Compress and write the given null-terminated string s to file, excluding
+       the terminating null character.
+
+         gzputs returns the number of characters written, or -1 in case of error.
+    */
+
+    ZEXTERN char* ZEXPORT gzgets OF((gzFile file, char* buf, int len));
+    /*
+         Read and decompress bytes from file into buf, until len-1 characters are
+       read, or until a newline character is read and transferred to buf, or an
+       end-of-file condition is encountered.  If any characters are read or if len
+       is one, the string is terminated with a null character.  If no characters
+       are read due to an end-of-file or len is less than one, then the buffer is
+       left untouched.
+
+         gzgets returns buf which is a null-terminated string, or it returns NULL
+       for end-of-file or in case of error.  If there was an error, the contents at
+       buf are indeterminate.
+    */
+
+    ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+    /*
+         Compress and write c, converted to an unsigned char, into file.  gzputc
+       returns the value that was written, or -1 in case of error.
+    */
+
+    ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+    /*
+         Read and decompress one byte from file.  gzgetc returns this byte or -1
+       in case of end of file or error.  This is implemented as a macro for speed.
+       As such, it does not do all of the checking the other functions do.  I.e.
+       it does not check to see if file is NULL, nor whether the structure file
+       points to has been clobbered or not.
+    */
+
+    ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+    /*
+         Push c back onto the stream for file to be read as the first character on
+       the next read.  At least one character of push-back is always allowed.
+       gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
+       fail if c is -1, and may fail if a character has been pushed but not read
+       yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
+       output buffer size of pushed characters is allowed.  (See gzbuffer above.)
+       The pushed character will be discarded if the stream is repositioned with
+       gzseek() or gzrewind().
+    */
+
+    ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+    /*
+         Flush all pending output to file.  The parameter flush is as in the
+       deflate() function.  The return value is the zlib error number (see function
+       gzerror below).  gzflush is only permitted when writing.
+
+         If the flush parameter is Z_FINISH, the remaining data is written and the
+       gzip stream is completed in the output.  If gzwrite() is called again, a new
+       gzip stream will be started in the output.  gzread() is able to read such
+       concatenated gzip streams.
+
+         gzflush should be called only when strictly necessary because it will
+       degrade compression if called too often.
+    */
+
+    /*
+    ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+                                       z_off_t offset, int whence));
+
+         Set the starting position to offset relative to whence for the next gzread
+       or gzwrite on file.  The offset represents a number of bytes in the
+       uncompressed data stream.  The whence parameter is defined as in lseek(2);
+       the value SEEK_END is not supported.
+
+         If the file is opened for reading, this function is emulated but can be
+       extremely slow.  If the file is opened for writing, only forward seeks are
+       supported; gzseek then compresses a sequence of zeroes up to the new
+       starting position.
+
+         gzseek returns the resulting offset location as measured in bytes from
+       the beginning of the uncompressed stream, or -1 in case of error, in
+       particular if the file is opened for writing and the new starting position
+       would be before the current position.
+    */
+
+    ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
+    /*
+         Rewind file. This function is supported only for reading.
+
+         gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET).
+    */
+
+    /*
+    ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+
+         Return the starting position for the next gzread or gzwrite on file.
+       This position represents a number of bytes in the uncompressed data stream,
+       and is zero when starting, even if appending or reading a gzip stream from
+       the middle of a file using gzdopen().
+
+         gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+    */
+
+    /*
+    ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
+
+         Return the current compressed (actual) read or write offset of file.  This
+       offset includes the count of bytes that precede the gzip stream, for example
+       when appending or when using gzdopen() for reading.  When reading, the
+       offset does not include as yet unused buffered input.  This information can
+       be used for a progress indicator.  On error, gzoffset() returns -1.
+    */
+
+    ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+    /*
+         Return true (1) if the end-of-file indicator for file has been set while
+       reading, false (0) otherwise.  Note that the end-of-file indicator is set
+       only if the read tried to go past the end of the input, but came up short.
+       Therefore, just like feof(), gzeof() may return false even if there is no
+       more data to read, in the event that the last read request was for the exact
+       number of bytes remaining in the input file.  This will happen if the input
+       file size is an exact multiple of the buffer size.
+
+         If gzeof() returns true, then the read functions will return no more data,
+       unless the end-of-file indicator is reset by gzclearerr() and the input file
+       has grown since the previous end of file was detected.
+    */
+
+    ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+    /*
+         Return true (1) if file is being copied directly while reading, or false
+       (0) if file is a gzip stream being decompressed.
+
+         If the input file is empty, gzdirect() will return true, since the input
+       does not contain a gzip stream.
+
+         If gzdirect() is used immediately after gzopen() or gzdopen() it will
+       cause buffers to be allocated to allow reading the file to determine if it
+       is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+       gzdirect().
+
+         When writing, gzdirect() returns true (1) if transparent writing was
+       requested ("wT" for the gzopen() mode), or false (0) otherwise.  (Note:
+       gzdirect() is not needed when writing.  Transparent writing must be
+       explicitly requested, so the application already knows the answer.  When
+       linking statically, using gzdirect() will include all of the zlib code for
+       gzip file reading and decompression, which may not be desired.)
+    */
+
+    ZEXTERN int ZEXPORT gzclose OF((gzFile file));
+    /*
+         Flush all pending output for file, if necessary, close file and
+       deallocate the (de)compression state.  Note that once file is closed, you
+       cannot call gzerror with file, since its structures have been deallocated.
+       gzclose must not be called more than once on the same file, just as free
+       must not be called more than once on the same allocation.
+
+         gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+       file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the
+       last read ended in the middle of a gzip stream, or Z_OK on success.
+    */
+
+    ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
+    ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
+    /*
+         Same as gzclose(), but gzclose_r() is only for use when reading, and
+       gzclose_w() is only for use when writing or appending.  The advantage to
+       using these instead of gzclose() is that they avoid linking in zlib
+       compression or decompression code that is not used when only reading or only
+       writing respectively.  If gzclose() is used, then both compression and
+       decompression code will be included the application when linking to a static
+       zlib library.
+    */
+
+    ZEXTERN const char* ZEXPORT gzerror OF((gzFile file, int* errnum));
+    /*
+         Return the error message for the last error which occurred on file.
+       errnum is set to zlib error number.  If an error occurred in the file system
+       and not in the compression library, errnum is set to Z_ERRNO and the
+       application may consult errno to get the exact error code.
+
+         The application must not modify the returned string.  Future calls to
+       this function may invalidate the previously returned string.  If file is
+       closed, then the string previously returned by gzerror will no longer be
+       available.
+
+         gzerror() should be used to distinguish errors from end-of-file for those
+       functions above that do not distinguish those cases in their return values.
+    */
+
+    ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+    /*
+         Clear the error and end-of-file flags for file.  This is analogous to the
+       clearerr() function in stdio.  This is useful for continuing to read a gzip
+       file that is being written concurrently.
+    */
 
 #endif /* !Z_SOLO */
 
-                        /* checksum functions */
-
-/*
-     These functions are not related to compression but are exported
-   anyway because they might be useful in applications using the compression
-   library.
-*/
-
-ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
-/*
-     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
-   return the updated checksum. An Adler-32 value is in the range of a 32-bit
-   unsigned integer. If buf is Z_NULL, this function returns the required
-   initial value for the checksum.
-
-     An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
-   much faster.
-
-   Usage example:
-
-     uLong adler = adler32(0L, Z_NULL, 0);
-
-     while (read_buffer(buffer, length) != EOF) {
-       adler = adler32(adler, buffer, length);
-     }
-     if (adler != original_adler) error();
-*/
-
-ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
-                                    z_size_t len));
-/*
-     Same as adler32(), but with a size_t length.
-*/
-
-/*
-ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
-                                          z_off_t len2));
-
-     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
-   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
-   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
-   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
-   that the z_off_t type (like off_t) is a signed integer.  If len2 is
-   negative, the result has no meaning or utility.
-*/
-
-ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
-/*
-     Update a running CRC-32 with the bytes buf[0..len-1] and return the
-   updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer.
-   If buf is Z_NULL, this function returns the required initial value for the
-   crc. Pre- and post-conditioning (one's complement) is performed within this
-   function so it shouldn't be done by the application.
-
-   Usage example:
-
-     uLong crc = crc32(0L, Z_NULL, 0);
-
-     while (read_buffer(buffer, length) != EOF) {
-       crc = crc32(crc, buffer, length);
-     }
-     if (crc != original_crc) error();
-*/
-
-ZEXTERN uLong ZEXPORT crc32_z OF((uLong crc, const Bytef *buf,
-                                  z_size_t len));
-/*
-     Same as crc32(), but with a size_t length.
-*/
-
-/*
-ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
-
-     Combine two CRC-32 check values into one.  For two sequences of bytes,
-   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
-   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
-   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
-   len2.
-*/
-
-/*
-ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2));
-
-     Return the operator corresponding to length len2, to be used with
-   crc32_combine_op().
-*/
-
-ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op));
-/*
-     Give the same result as crc32_combine(), using op in place of len2. op is
-   is generated from len2 by crc32_combine_gen(). This will be faster than
-   crc32_combine() if the generated op is used more than once.
-*/
-
-
-                        /* various hacks, don't look :) */
-
-/* deflateInit and inflateInit are macros to allow checking the zlib version
- * and the compiler's view of z_stream:
- */
-ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
-                                     const char *version, int stream_size));
-ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
-                                     const char *version, int stream_size));
-ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
-                                      int windowBits, int memLevel,
-                                      int strategy, const char *version,
-                                      int stream_size));
-ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
-                                      const char *version, int stream_size));
-ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
-                                         unsigned char FAR *window,
-                                         const char *version,
-                                         int stream_size));
+    /* checksum functions */
+
+    /*
+         These functions are not related to compression but are exported
+       anyway because they might be useful in applications using the compression
+       library.
+    */
+
+    ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef* buf, uInt len));
+    /*
+         Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+       return the updated checksum. An Adler-32 value is in the range of a 32-bit
+       unsigned integer. If buf is Z_NULL, this function returns the required
+       initial value for the checksum.
+
+         An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
+       much faster.
+
+       Usage example:
+
+         uLong adler = adler32(0L, Z_NULL, 0);
+
+         while (read_buffer(buffer, length) != EOF) {
+           adler = adler32(adler, buffer, length);
+         }
+         if (adler != original_adler) error();
+    */
+
+    ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef* buf, z_size_t len));
+    /*
+         Same as adler32(), but with a size_t length.
+    */
+
+    /*
+    ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                              z_off_t len2));
+
+         Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+       and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+       each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+       seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
+       that the z_off_t type (like off_t) is a signed integer.  If len2 is
+       negative, the result has no meaning or utility.
+    */
+
+    ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef* buf, uInt len));
+    /*
+         Update a running CRC-32 with the bytes buf[0..len-1] and return the
+       updated CRC-32. A CRC-32 value is in the range of a 32-bit unsigned integer.
+       If buf is Z_NULL, this function returns the required initial value for the
+       crc. Pre- and post-conditioning (one's complement) is performed within this
+       function so it shouldn't be done by the application.
+
+       Usage example:
+
+         uLong crc = crc32(0L, Z_NULL, 0);
+
+         while (read_buffer(buffer, length) != EOF) {
+           crc = crc32(crc, buffer, length);
+         }
+         if (crc != original_crc) error();
+    */
+
+    ZEXTERN uLong ZEXPORT crc32_z OF((uLong crc, const Bytef* buf, z_size_t len));
+    /*
+         Same as crc32(), but with a size_t length.
+    */
+
+    /*
+    ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+         Combine two CRC-32 check values into one.  For two sequences of bytes,
+       seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+       calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+       check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+       len2.
+    */
+
+    /*
+    ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2));
+
+         Return the operator corresponding to length len2, to be used with
+       crc32_combine_op().
+    */
+
+    ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op));
+    /*
+         Give the same result as crc32_combine(), using op in place of len2. op is
+       is generated from len2 by crc32_combine_gen(). This will be faster than
+       crc32_combine() if the generated op is used more than once.
+    */
+
+    /* various hacks, don't look :) */
+
+    /* deflateInit and inflateInit are macros to allow checking the zlib version
+     * and the compiler's view of z_stream:
+     */
+    ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, const char* version, int stream_size));
+    ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, const char* version, int stream_size));
+    ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char* version, int stream_size));
+    ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, const char* version, int stream_size));
+    ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, unsigned char FAR* window, const char* version, int stream_size));
 #ifdef Z_PREFIX_SET
-#  define z_deflateInit(strm, level) \
-          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
-#  define z_inflateInit(strm) \
-          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
-#  define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
-          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
-                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
-#  define z_inflateInit2(strm, windowBits) \
-          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
-                        (int)sizeof(z_stream))
-#  define z_inflateBackInit(strm, windowBits, window) \
-          inflateBackInit_((strm), (windowBits), (window), \
-                           ZLIB_VERSION, (int)sizeof(z_stream))
+#define z_deflateInit(strm, level) \
+    deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#define z_inflateInit(strm) \
+    inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+    deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#define z_inflateInit2(strm, windowBits) \
+    inflateInit2_((strm), (windowBits), ZLIB_VERSION, (int)sizeof(z_stream))
+#define z_inflateBackInit(strm, windowBits, window) \
+    inflateBackInit_((strm), (windowBits), (window), ZLIB_VERSION, (int)sizeof(z_stream))
 #else
-#  define deflateInit(strm, level) \
-          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
-#  define inflateInit(strm) \
-          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
-#  define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
-          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
-                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
-#  define inflateInit2(strm, windowBits) \
-          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
-                        (int)sizeof(z_stream))
-#  define inflateBackInit(strm, windowBits, window) \
-          inflateBackInit_((strm), (windowBits), (window), \
-                           ZLIB_VERSION, (int)sizeof(z_stream))
+#define deflateInit(strm, level) \
+    deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+#define inflateInit(strm) \
+    inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+    deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+    inflateInit2_((strm), (windowBits), ZLIB_VERSION, (int)sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+    inflateBackInit_((strm), (windowBits), (window), ZLIB_VERSION, (int)sizeof(z_stream))
 #endif
 
 #ifndef Z_SOLO
 
-/* gzgetc() macro and its supporting function and exposed data structure.  Note
- * that the real internal state is much larger than the exposed structure.
- * This abbreviated structure exposes just enough for the gzgetc() macro.  The
- * user should not mess with these exposed elements, since their names or
- * behavior could change in the future, perhaps even capriciously.  They can
- * only be used by the gzgetc() macro.  You have been warned.
- */
-struct gzFile_s {
-    unsigned have;
-    unsigned char *next;
-    z_off64_t pos;
-};
-ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));  /* backward compatibility */
+    /* gzgetc() macro and its supporting function and exposed data structure.  Note
+     * that the real internal state is much larger than the exposed structure.
+     * This abbreviated structure exposes just enough for the gzgetc() macro.  The
+     * user should not mess with these exposed elements, since their names or
+     * behavior could change in the future, perhaps even capriciously.  They can
+     * only be used by the gzgetc() macro.  You have been warned.
+     */
+    struct gzFile_s
+    {
+        unsigned have;
+        unsigned char* next;
+        z_off64_t pos;
+    };
+    ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
 #ifdef Z_PREFIX_SET
-#  undef z_gzgetc
-#  define z_gzgetc(g) \
-          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
+#undef z_gzgetc
+#define z_gzgetc(g) \
+    ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
 #else
-#  define gzgetc(g) \
-          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
+#define gzgetc(g) \
+    ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
 #endif
 
 /* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
@@ -1853,79 +1796,76 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));  /* backward compatibility */
  * without large file support, _LFS64_LARGEFILE must also be true
  */
 #ifdef Z_LARGE64
-   ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
-   ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
-   ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
-   ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
-   ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
-   ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
-   ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t));
+    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char*, const char*));
+    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
+    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
+    ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t));
 #endif
 
 #if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
-#  ifdef Z_PREFIX_SET
-#    define z_gzopen z_gzopen64
-#    define z_gzseek z_gzseek64
-#    define z_gztell z_gztell64
-#    define z_gzoffset z_gzoffset64
-#    define z_adler32_combine z_adler32_combine64
-#    define z_crc32_combine z_crc32_combine64
-#    define z_crc32_combine_gen z_crc32_combine_gen64
-#  else
-#    define gzopen gzopen64
-#    define gzseek gzseek64
-#    define gztell gztell64
-#    define gzoffset gzoffset64
-#    define adler32_combine adler32_combine64
-#    define crc32_combine crc32_combine64
-#    define crc32_combine_gen crc32_combine_gen64
-#  endif
-#  ifndef Z_LARGE64
-     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
-     ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
-     ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
-     ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
-     ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
-     ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
-     ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off_t));
-#  endif
+#ifdef Z_PREFIX_SET
+#define z_gzopen z_gzopen64
+#define z_gzseek z_gzseek64
+#define z_gztell z_gztell64
+#define z_gzoffset z_gzoffset64
+#define z_adler32_combine z_adler32_combine64
+#define z_crc32_combine z_crc32_combine64
+#define z_crc32_combine_gen z_crc32_combine_gen64
+#else
+#define gzopen gzopen64
+#define gzseek gzseek64
+#define gztell gztell64
+#define gzoffset gzoffset64
+#define adler32_combine adler32_combine64
+#define crc32_combine crc32_combine64
+#define crc32_combine_gen crc32_combine_gen64
+#endif
+#ifndef Z_LARGE64
+    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char*, const char*));
+    ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
+    ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
+    ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
+    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+    ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off_t));
+#endif
 #else
-   ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
-   ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
-   ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
-   ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
-   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
-   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
-   ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t));
+    ZEXTERN gzFile ZEXPORT gzopen OF((const char*, const char*));
+    ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
+    ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
+    ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
+    ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+    ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+    ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t));
 #endif
 
 #else /* Z_SOLO */
 
-   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
-   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
-   ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t));
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t));
 
 #endif /* !Z_SOLO */
 
-/* undocumented functions */
-ZEXTERN const char   * ZEXPORT zError           OF((int));
-ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
-ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table    OF((void));
-ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
-ZEXTERN int            ZEXPORT inflateValidate OF((z_streamp, int));
-ZEXTERN unsigned long  ZEXPORT inflateCodesUsed OF ((z_streamp));
-ZEXTERN int            ZEXPORT inflateResetKeep OF((z_streamp));
-ZEXTERN int            ZEXPORT deflateResetKeep OF((z_streamp));
+    /* undocumented functions */
+    ZEXTERN const char* ZEXPORT zError OF((int));
+    ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
+    ZEXTERN const z_crc_t FAR* ZEXPORT get_crc_table OF((void));
+    ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
+    ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int));
+    ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF((z_streamp));
+    ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
+    ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
 #if defined(_WIN32) && !defined(Z_SOLO)
-ZEXTERN gzFile         ZEXPORT gzopen_w OF((const wchar_t *path,
-                                            const char *mode));
+    ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t* path, const char* mode));
 #endif
 #if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#  ifndef Z_SOLO
-ZEXTERN int            ZEXPORTVA gzvprintf Z_ARG((gzFile file,
-                                                  const char *format,
-                                                  va_list va));
-#  endif
+#ifndef Z_SOLO
+    ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, const char* format, va_list va));
+#endif
 #endif
 
 #ifdef __cplusplus

From 179b944df4d08ace32c90486f65085d5cd68c1a2 Mon Sep 17 00:00:00 2001
From: Shawqeem <1004837646@qq.com>
Date: Sun, 16 Apr 2023 00:02:55 +0800
Subject: [PATCH 07/10] fix: :bug: fix bugs to fit robots in the field

---
 logic/Client/MainWindow.xaml.cs | 9 +++++++--
 logic/cmd/gameServer.cmd        | 4 ++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/logic/Client/MainWindow.xaml.cs b/logic/Client/MainWindow.xaml.cs
index 7999ed6..5461fb4 100644
--- a/logic/Client/MainWindow.xaml.cs
+++ b/logic/Client/MainWindow.xaml.cs
@@ -675,7 +675,7 @@ namespace Client
                     MaxButton.Content = "🗖";
                 foreach (var obj in listOfHuman)
                 {
-                    if (obj.PlayerId < GameData.numOfStudent)
+                    if (obj.PlayerId < GameData.numOfStudent && obj.StudentType != StudentType.Robot)
                     {
                         IStudentType occupation = (IStudentType)OccupationFactory.FindIOccupation(Transformation.ToStudentType(obj.StudentType));
                         totalLife[obj.PlayerId] = occupation.MaxHp;
@@ -749,7 +749,8 @@ namespace Client
                             DrawMap();
                         foreach (var data in listOfHuman)
                         {
-                            StatusBarsOfSurvivor[data.PlayerId].SetValue(data, data.PlayerId);
+                            if (data.StudentType != StudentType.Robot)
+                                StatusBarsOfSurvivor[data.PlayerId].SetValue(data, data.PlayerId);
                             if (CanSee(data))
                             {
                                 Ellipse icon = new()
@@ -761,6 +762,8 @@ namespace Client
                                     Margin = new Thickness(data.Y * unitWidth / 1000.0 - unitWidth * radiusTimes, data.X * unitHeight / 1000.0 - unitHeight * radiusTimes, 0, 0),
                                     Fill = Brushes.BlueViolet,
                                 };
+                                if (data.StudentType == StudentType.Robot)
+                                    icon.Fill = Brushes.Gray;
                                 TextBox num = new()
                                 {
                                     FontSize = 7 * UpperLayerOfMap.ActualHeight / 650,
@@ -775,6 +778,8 @@ namespace Client
                                     IsReadOnly = true,
                                     Foreground = Brushes.White,
                                 };
+                                if (data.StudentType == StudentType.Robot)
+                                    num.Text = Convert.ToString(data.PlayerId - Preparation.Utility.GameData.numOfPeople);
                                 UpperLayerOfMap.Children.Add(icon);
                                 UpperLayerOfMap.Children.Add(num);
                             }
diff --git a/logic/cmd/gameServer.cmd b/logic/cmd/gameServer.cmd
index 22cac6c..4e2bc41 100644
--- a/logic/cmd/gameServer.cmd
+++ b/logic/cmd/gameServer.cmd
@@ -6,9 +6,9 @@ ping -n 2 127.0.0.1 > NUL
 
 start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 4 --type 2 --occupation 4
 
-start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 0 --type 1 --occupation 6
+start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 0 --type 1 --occupation 5
 
-start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 1 --type 1 --occupation 2
+start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 1 --type 1 --occupation 5
 
 start cmd /k ..\Client\bin\Debug\net6.0-windows\Client.exe --cl --port 8888 --characterID 2 --type 1 --occupation 3
 

From 6aa49b08fd98217c1fb3919f01d3910d64884d0d Mon Sep 17 00:00:00 2001
From: DragonAura <dragonaurapvp@gmail.com>
Date: Sun, 16 Apr 2023 00:25:05 +0800
Subject: [PATCH 08/10] fix: :bug: delete wrong cout

---
 CAPI/cpp/API/src/Communication.cpp | 1 -
 CAPI/cpp/API/src/main.cpp          | 1 -
 2 files changed, 2 deletions(-)

diff --git a/CAPI/cpp/API/src/Communication.cpp b/CAPI/cpp/API/src/Communication.cpp
index 01b4b25..6bcf8d8 100644
--- a/CAPI/cpp/API/src/Communication.cpp
+++ b/CAPI/cpp/API/src/Communication.cpp
@@ -19,7 +19,6 @@ bool Communication::Move(int64_t time, double angle, int64_t playerID)
     protobuf::MoveRes moveResult;
     ClientContext context;
     auto request = THUAI62Proto::THUAI62ProtobufMove(time, angle, playerID);
-    std::cout << "Move request sent" << std::endl;
     auto status = THUAI6Stub->Move(&context, request, &moveResult);
     if (status.ok())
         return moveResult.act_success();
diff --git a/CAPI/cpp/API/src/main.cpp b/CAPI/cpp/API/src/main.cpp
index ea8d2df..037a842 100644
--- a/CAPI/cpp/API/src/main.cpp
+++ b/CAPI/cpp/API/src/main.cpp
@@ -69,7 +69,6 @@ int THUAI6Main(int argc, char** argv, CreateAIFunc AIBuilder)
         std::cerr << "Parsing error: " << e.error() << " for arg " << e.argId() << std::endl;
         return 1;
     }
-    std::cout << file << std::endl;
     try
     {
         Logic logic(playerType, pID, trickerType, studentType);

From fde5e156c8715162c6f0f6865b81d8f770049829 Mon Sep 17 00:00:00 2001
From: shangfengh <3495281661@qq.com>
Date: Sun, 16 Apr 2023 00:33:50 +0800
Subject: [PATCH 09/10] fix: :bug: fix a bug about UseRobot

---
 CAPI/cpp/API/include/constants.h              |  9 +++++--
 CAPI/python/PyAPI/constants.py                |  8 ++++--
 logic/GameClass/GameObj/Map/Map.cs            |  4 ++-
 logic/GameRules.md                            | 11 +++++---
 logic/Gaming/ActionManager.cs                 | 10 +++----
 logic/Gaming/PropManager.cs                   |  2 +-
 .../SkillManager/SkillManager.ActiveSkill.cs  | 26 +++++++++++--------
 logic/Preparation/Utility/GameData.cs         | 22 +++++++++-------
 8 files changed, 56 insertions(+), 36 deletions(-)

diff --git a/CAPI/cpp/API/include/constants.h b/CAPI/cpp/API/include/constants.h
index 55f3d00..34867b2 100644
--- a/CAPI/cpp/API/include/constants.h
+++ b/CAPI/cpp/API/include/constants.h
@@ -44,7 +44,7 @@ namespace Constants
     SCCI int basicStudentAlertnessRadius = 15 * numOfGridPerCell;
     SCCI int basicTrickerAlertnessRadius = 17 * numOfGridPerCell;
     SCCI int basicStudentViewRange = 10 * numOfGridPerCell;
-    SCCI int basicTrickerViewRange = 15 * numOfGridPerCell;
+    SCCI int basicTrickerViewRange = 13 * numOfGridPerCell;
     SCCI int PinningDownRange = 5 * numOfGridPerCell;
 
     SCCI int maxNumOfProp = 3;  // 人物道具栏容量
@@ -218,8 +218,13 @@ namespace Constants
 
     SCCI int timeOfStunnedWhenJumpyDumpty = 3070;
 
-    SCCI double addedTimeOfSpeedWhenInspire = 0.6;
+    SCCI double addedTimeOfSpeedWhenInspire = 1.6;
     SCCI int timeOfAddingSpeedWhenInspire = 6000;
+
+    SCCI int addHpWhenEncourage = basicHp / 4;
+
+    SCCI int checkIntervalWhenShowTime = 200;
+    SCCI int addAddictionPer100msWhenShowTime = 300;
     struct CanBeginToCharge
     {
         SCCI int skillCD = commonSkillCD * 2;
diff --git a/CAPI/python/PyAPI/constants.py b/CAPI/python/PyAPI/constants.py
index e76b7d9..dea67a2 100644
--- a/CAPI/python/PyAPI/constants.py
+++ b/CAPI/python/PyAPI/constants.py
@@ -43,7 +43,7 @@ class Constants(NoInstance):
     basicStudentAlertnessRadius = 15 * numOfGridPerCell
     basicTrickerAlertnessRadius = 17 * numOfGridPerCell
     basicStudentViewRange = 10 * numOfGridPerCell
-    basicTrickerViewRange = 15 * numOfGridPerCell
+    basicTrickerViewRange = 13 * numOfGridPerCell
     PinningDownRange = 5 * numOfGridPerCell
 
     maxNumOfProp = 3  # 人物道具栏容量
@@ -82,8 +82,12 @@ class Constants(NoInstance):
 
     timeOfStunnedWhenJumpyDumpty = 3070
 
-    addedTimeOfSpeedWhenInspire = 0.6
+    addedTimeOfSpeedWhenInspire = 1.6
     timeOfAddingSpeedWhenInspire = 6000
+    addHpWhenEncourage = basicHp / 4;
+
+    checkIntervalWhenShowTime = 200;
+    addAddictionPer100msWhenShowTime = 300;
 
 
 class Assassin:
diff --git a/logic/GameClass/GameObj/Map/Map.cs b/logic/GameClass/GameObj/Map/Map.cs
index 75645fc..1ca3ec9 100644
--- a/logic/GameClass/GameObj/Map/Map.cs
+++ b/logic/GameClass/GameObj/Map/Map.cs
@@ -179,9 +179,11 @@ namespace GameClass.GameObj
                     {
                         if (person.CharacterType == CharacterType.TechOtaku && person.FindIActiveSkill(ActiveSkillType.UseRobot).IsBeingUsed)
                         {
+                            Debugger.Output(person, person.PlayerID.ToString());
                             foreach (Character character in gameObjDict[GameObjType.Character])
                             {
-                                if (playerID + GameData.numOfPeople == character.ID)
+                                Debugger.Output(character, character.PlayerID.ToString());
+                                if (person.PlayerID + GameData.numOfPeople == character.PlayerID)
                                 {
                                     player = character;
                                     break;
diff --git a/logic/GameRules.md b/logic/GameRules.md
index 5c032cd..2e9659e 100644
--- a/logic/GameRules.md
+++ b/logic/GameRules.md
@@ -178,8 +178,8 @@ V4.4
 | :------------ |  :--------------------- |  :--------------------- | :--------------------- | :--------------------- |
 |   移动速度/s   |     1980             |      1800                    |   1926      | 1,800 |
 |   隐蔽度   |      1.5              |      1                            |     0.8     | 0.75|
-|   警戒范围   |     22,100             |      17000                      |  15,300      | 17000
-|   视野范围   |      18,000             |      15000                   |    15000   | 16,500|
+|   警戒范围   |     22,100             |      17000                      |  15300      | 17000
+|   视野范围   |      15600             |      13000                   |    13000   | 14300|
 |   开锁门速度 |     4000              |    4000                             |      4000      |4000 |
 |   翻窗速度   |   1270                   |       1270       |     1,397       |   1270|  
 |   翻箱速度   |          1000      |   1100         |     1000      |1000|
@@ -220,8 +220,11 @@ V4.4
 - 普通攻击为 CommonAttackOfGhost
 - 主动技能
  - ShowTime
-    - CD: 75s 持续时间：10s
-    - 持续时间内每一帧向所有学生发送向自己移动的指令。
+    - CD: 80s 持续时间：10s
+    - 持续时间内
+      - 使警戒范围外的学生眩晕并每200ms发送向自己移动200ms的指令（速度为学生本应速度*二者距离/警戒范围）
+      - 对于视野范围（不是可视区域）内的学生每200ms加600的沉迷度
+      - 捣蛋鬼变为0.8倍速
 
 ### 学生（&老师）
 
diff --git a/logic/Gaming/ActionManager.cs b/logic/Gaming/ActionManager.cs
index 2d07cea..cb8486d 100644
--- a/logic/Gaming/ActionManager.cs
+++ b/logic/Gaming/ActionManager.cs
@@ -23,16 +23,16 @@ namespace Gaming
                 {
                     if (((Bullet)collisionObj).Parent != player && ((Bullet)collisionObj).TypeOfBullet == BulletType.JumpyDumpty)
                     {
-                        if (characterManager.BeStunned((Character)player, GameData.TimeOfStunnedWhenJumpyDumpty))
-                            player.AddScore(GameData.TrickerScoreStudentBeStunned(GameData.TimeOfStunnedWhenJumpyDumpty));
+                        if (characterManager.BeStunned((Character)player, GameData.timeOfStunnedWhenJumpyDumpty))
+                            player.AddScore(GameData.TrickerScoreStudentBeStunned(GameData.timeOfStunnedWhenJumpyDumpty));
                         gameMap.Remove((GameObj)collisionObj);
                     }
                 }
                 if (player.FindIActiveSkill(ActiveSkillType.CanBeginToCharge).IsBeingUsed && collisionObj.Type == GameObjType.Character && ((Character)collisionObj).IsGhost())
                 {
-                    if (characterManager.BeStunned((Character)collisionObj, GameData.TimeOfGhostStunnedWhenCharge))
-                        player.AddScore(GameData.StudentScoreTrickerBeStunned(GameData.TimeOfGhostStunnedWhenCharge));
-                    characterManager.BeStunned(player, GameData.TimeOfStudentStunnedWhenCharge);
+                    if (characterManager.BeStunned((Character)collisionObj, GameData.timeOfGhostStunnedWhenCharge))
+                        player.AddScore(GameData.StudentScoreTrickerBeStunned(GameData.timeOfGhostStunnedWhenCharge));
+                    characterManager.BeStunned(player, GameData.timeOfStudentStunnedWhenCharge);
                 }
             }
             public bool MovePlayer(Character playerToMove, int moveTimeInMilliseconds, double moveDirection)
diff --git a/logic/Gaming/PropManager.cs b/logic/Gaming/PropManager.cs
index ae97ce7..6b2ba2b 100644
--- a/logic/Gaming/PropManager.cs
+++ b/logic/Gaming/PropManager.cs
@@ -42,7 +42,7 @@ namespace Gaming
                         break;
                     case PropType.AddSpeed:
                         player.AddScore(GameData.ScorePropAddSpeed);
-                        player.AddMoveSpeed(GameData.PropDuration);
+                        player.AddMoveSpeed(GameData.PropDuration, 2.0);
                         break;
                     case PropType.AddHpOrAp:
                         if (!player.IsGhost())
diff --git a/logic/Gaming/SkillManager/SkillManager.ActiveSkill.cs b/logic/Gaming/SkillManager/SkillManager.ActiveSkill.cs
index 55d4740..9216c4b 100644
--- a/logic/Gaming/SkillManager/SkillManager.ActiveSkill.cs
+++ b/logic/Gaming/SkillManager/SkillManager.ActiveSkill.cs
@@ -35,6 +35,7 @@ namespace Gaming
 
                 return ActiveSkillEffect(skill, player, () =>
                 {
+                    player.AddMoveSpeed(skill.DurationTime, 0.8);
                     new Thread
                     (
                    () =>
@@ -87,7 +88,10 @@ namespace Gaming
 
             public static bool UseRobot(Character player)
             {
+                IGolem? golem = (IGolem?)(((SummonGolem)player.FindIActiveSkill(ActiveSkillType.SummonGolem)).GolemSummoned);
+                Debugger.Output(player, (golem != null).ToString());
                 if ((!player.Commandable()) || ((SummonGolem)player.FindIActiveSkill(ActiveSkillType.SummonGolem)).GolemSummoned == null) return false;
+                Debugger.Output(player, player.PlayerID.ToString());
                 IActiveSkill activeSkill = player.FindIActiveSkill(ActiveSkillType.UseRobot);
                 activeSkill.IsBeingUsed = (activeSkill.IsBeingUsed) ? false : true;
                 return true;
@@ -132,10 +136,11 @@ namespace Gaming
                 XY res = player.Position + new XY(player.FacingDirection, player.Radius * 2);
                 if (actionManager.moveEngine.CheckCollision(player, res) != null)
                     return false;
-
+                Golem? golem = (Golem?)characterManager.AddPlayer(res, player.TeamID, player.PlayerID + GameData.numOfPeople, CharacterType.Robot, player);
+                if (golem == null) return false;
+                ((SummonGolem)activeSkill).GolemSummoned = golem;
                 return ActiveSkillEffect(activeSkill, player, () =>
                 {
-                    characterManager.AddPlayer(res, player.TeamID, player.PlayerID + GameData.numOfPeople, CharacterType.Robot, player);
                 },
                                                       () =>
                                                       { });
@@ -164,9 +169,8 @@ namespace Gaming
                         {
                             if (!character.IsGhost() && XY.Distance(character.Position, player.Position) <= player.ViewRange)
                             {
-                                if (characterManager.BeStunned(character, GameData.TimeOfStudentStunnedWhenHowl))
-                                    player.AddScore(GameData.TrickerScoreStudentBeStunned(GameData.TimeOfStudentStunnedWhenHowl));
-                                break;
+                                if (characterManager.BeStunned(character, GameData.timeOfStudentStunnedWhenHowl))
+                                    player.AddScore(GameData.TrickerScoreStudentBeStunned(GameData.timeOfStudentStunnedWhenHowl));
                             }
                         }
                     }
@@ -174,7 +178,7 @@ namespace Gaming
                     {
                         gameMap.GameObjLockDict[GameObjType.Character].ExitReadLock();
                     }
-                    characterManager.BackSwing(player, GameData.TimeOfGhostSwingingAfterHowl);
+                    characterManager.BackSwing(player, GameData.timeOfGhostSwingingAfterHowl);
                     Debugger.Output(player, "howled!");
                 },
                                                       () =>
@@ -196,8 +200,8 @@ namespace Gaming
                                 || character.PlayerState == PlayerStateType.UsingSkill || character.PlayerState == PlayerStateType.LockingOrOpeningTheDoor || character.PlayerState == PlayerStateType.ClimbingThroughWindows)
                                 && gameMap.CanSee(player, character))
                             {
-                                if (characterManager.BeStunned(character, GameData.TimeOfGhostStunnedWhenPunish + GameData.factorOfTimeStunnedWhenPunish * (player.MaxHp - player.HP)))
-                                    player.AddScore(GameData.StudentScoreTrickerBeStunned(GameData.TimeOfGhostStunnedWhenPunish + GameData.factorOfTimeStunnedWhenPunish * (player.MaxHp - player.HP)));
+                                if (characterManager.BeStunned(character, GameData.timeOfGhostStunnedWhenPunish + GameData.factorOfTimeStunnedWhenPunish * (player.MaxHp - player.HP)))
+                                    player.AddScore(GameData.StudentScoreTrickerBeStunned(GameData.timeOfGhostStunnedWhenPunish + GameData.factorOfTimeStunnedWhenPunish * (player.MaxHp - player.HP)));
                                 break;
                             }
                         }
@@ -254,8 +258,8 @@ namespace Gaming
                         {
                             if ((character.HP < character.MaxHp) && gameMap.CanSee(player, character))
                             {
-                                player.AddScore(GameData.StudentScoreTreat(GameData.AddHpWhenEncourage));
-                                character.HP += GameData.AddHpWhenEncourage;
+                                player.AddScore(GameData.StudentScoreTreat(GameData.addHpWhenEncourage));
+                                character.HP += GameData.addHpWhenEncourage;
                                 ((Student)character).SetDegreeOfTreatment0();
                                 break;
                             }
@@ -284,7 +288,7 @@ namespace Gaming
                             if (gameMap.CanSee(player, character))
                             {
                                 player.AddScore(GameData.ScoreInspire);
-                                character.AddMoveSpeed(GameData.TimeOfAddingSpeedWhenInspire, GameData.AddedTimeOfSpeedWhenInspire);
+                                character.AddMoveSpeed(GameData.timeOfAddingSpeedWhenInspire, GameData.addedTimeOfSpeedWhenInspire);
                             }
                         }
                     }
diff --git a/logic/Preparation/Utility/GameData.cs b/logic/Preparation/Utility/GameData.cs
index be19eb2..78dade7 100644
--- a/logic/Preparation/Utility/GameData.cs
+++ b/logic/Preparation/Utility/GameData.cs
@@ -117,7 +117,7 @@ namespace Preparation.Utility
         public const int basicStudentAlertnessRadius = 15 * numOfPosGridPerCell;
         public const int basicGhostAlertnessRadius = 17 * numOfPosGridPerCell;
         public const int basicStudentViewRange = 10 * numOfPosGridPerCell;
-        public const int basicGhostViewRange = 15 * numOfPosGridPerCell;
+        public const int basicGhostViewRange = 13 * numOfPosGridPerCell;
         public const int PinningDownRange = 5 * numOfPosGridPerCell;
 
         public const int maxNumOfPropInPropInventory = 3;
@@ -210,22 +210,24 @@ namespace Preparation.Utility
         public const int commonSkillCD = 30000;                      // 普通技能标准冷却时间
         public const int commonSkillTime = 10000;                    // 普通技能标准持续时间
 
-        public const int TimeOfGhostStunnedWhenCharge = 7220;
-        public const int TimeOfStudentStunnedWhenCharge = 2090;
+        public const int timeOfGhostStunnedWhenCharge = 7220;
+        public const int timeOfStudentStunnedWhenCharge = 2090;
 
-        public const int TimeOfGhostStunnedWhenPunish = 3070;
+        public const int timeOfGhostStunnedWhenPunish = 3070;
         public const int factorOfTimeStunnedWhenPunish = 300 / basicApOfGhost;
 
-        public const int TimeOfGhostSwingingAfterHowl = 800;
-        public const int TimeOfStudentStunnedWhenHowl = 5500;
+        public const int timeOfGhostSwingingAfterHowl = 800;
+        public const int timeOfStudentStunnedWhenHowl = 5500;
 
-        public const int TimeOfStunnedWhenJumpyDumpty = 3070;
+        public const int timeOfStunnedWhenJumpyDumpty = 3070;
 
-        public const double AddedTimeOfSpeedWhenInspire = 0.6;
-        public const int TimeOfAddingSpeedWhenInspire = 6000;
+        public const double addedTimeOfSpeedWhenInspire = 1.6;
+        public const int timeOfAddingSpeedWhenInspire = 6000;
 
-        public const int AddHpWhenEncourage = basicHp / 4;
+        public const int addHpWhenEncourage = basicHp / 4;
 
+        public const int checkIntervalWhenShowTime = 200;
+        public const int addAddictionPer100msWhenShowTime = 300;
         #endregion
         #region 道具相关
         public const int PropRadius = numOfPosGridPerCell / 2;

From 401a98cb27a24f64a60277a4d213d7e542dd63e5 Mon Sep 17 00:00:00 2001
From: shangfengh <3495281661@qq.com>
Date: Sun, 16 Apr 2023 00:44:11 +0800
Subject: [PATCH 10/10] fix: :bug: fix a bug about attacking the Robot

---
 logic/Gaming/CharacterManager .cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/logic/Gaming/CharacterManager .cs b/logic/Gaming/CharacterManager .cs
index 399666f..c5bc77c 100644
--- a/logic/Gaming/CharacterManager .cs	
+++ b/logic/Gaming/CharacterManager .cs	
@@ -398,7 +398,7 @@ namespace Gaming
                 {
                     if (((Golem)player).Parent != null && ((Golem)player).Parent.CharacterType == CharacterType.TechOtaku)
                     {
-                        ((SummonGolem)player.FindIActiveSkill(ActiveSkillType.SummonGolem)).GolemSummoned = null;
+                        ((SummonGolem)(((Golem)player).Parent.FindIActiveSkill(ActiveSkillType.SummonGolem))).GolemSummoned = null;
                         player.FindIActiveSkill(ActiveSkillType.UseRobot).IsBeingUsed = false;
                     }
                     return;